blob: f87e8631b1654d93818261555b93ffc9ddf355c8
1 | /* |
2 | * Audio and Video frame extraction |
3 | * Copyright (c) 2003 Fabrice Bellard |
4 | * Copyright (c) 2003 Michael Niedermayer |
5 | * |
6 | * This file is part of FFmpeg. |
7 | * |
8 | * FFmpeg is free software; you can redistribute it and/or |
9 | * modify it under the terms of the GNU Lesser General Public |
10 | * License as published by the Free Software Foundation; either |
11 | * version 2.1 of the License, or (at your option) any later version. |
12 | * |
13 | * FFmpeg is distributed in the hope that it will be useful, |
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
16 | * Lesser General Public License for more details. |
17 | * |
18 | * You should have received a copy of the GNU Lesser General Public |
19 | * License along with FFmpeg; if not, write to the Free Software |
20 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
21 | */ |
22 | |
23 | #include <stdint.h> |
24 | #include <string.h> |
25 | |
26 | #include "libavutil/avassert.h" |
27 | #include "libavutil/atomic.h" |
28 | #include "libavutil/internal.h" |
29 | #include "libavutil/mem.h" |
30 | |
31 | #include "internal.h" |
32 | #include "parser.h" |
33 | |
34 | static AVCodecParser *av_first_parser = NULL; |
35 | |
36 | AVCodecParser *av_parser_next(const AVCodecParser *p) |
37 | { |
38 | if (p) |
39 | return p->next; |
40 | else |
41 | return av_first_parser; |
42 | } |
43 | |
44 | void av_register_codec_parser(AVCodecParser *parser) |
45 | { |
46 | do { |
47 | parser->next = av_first_parser; |
48 | } while (parser->next != avpriv_atomic_ptr_cas((void * volatile *)&av_first_parser, parser->next, parser)); |
49 | } |
50 | |
51 | AVCodecParserContext *av_parser_init(int codec_id) |
52 | { |
53 | AVCodecParserContext *s = NULL; |
54 | AVCodecParser *parser; |
55 | int ret; |
56 | |
57 | if (codec_id == AV_CODEC_ID_NONE) |
58 | return NULL; |
59 | |
60 | for (parser = av_first_parser; parser; parser = parser->next) { |
61 | if (parser->codec_ids[0] == codec_id || |
62 | parser->codec_ids[1] == codec_id || |
63 | parser->codec_ids[2] == codec_id || |
64 | parser->codec_ids[3] == codec_id || |
65 | parser->codec_ids[4] == codec_id) |
66 | goto found; |
67 | } |
68 | return NULL; |
69 | |
70 | found: |
71 | s = av_mallocz(sizeof(AVCodecParserContext)); |
72 | if (!s) |
73 | goto err_out; |
74 | s->parser = parser; |
75 | s->priv_data = av_mallocz(parser->priv_data_size); |
76 | if (!s->priv_data) |
77 | goto err_out; |
78 | s->fetch_timestamp=1; |
79 | s->pict_type = AV_PICTURE_TYPE_I; |
80 | if (parser->parser_init) { |
81 | ret = parser->parser_init(s); |
82 | if (ret != 0) |
83 | goto err_out; |
84 | } |
85 | s->key_frame = -1; |
86 | #if FF_API_CONVERGENCE_DURATION |
87 | FF_DISABLE_DEPRECATION_WARNINGS |
88 | s->convergence_duration = 0; |
89 | FF_ENABLE_DEPRECATION_WARNINGS |
90 | #endif |
91 | s->dts_sync_point = INT_MIN; |
92 | s->dts_ref_dts_delta = INT_MIN; |
93 | s->pts_dts_delta = INT_MIN; |
94 | s->format = -1; |
95 | |
96 | return s; |
97 | |
98 | err_out: |
99 | if (s) |
100 | av_freep(&s->priv_data); |
101 | av_free(s); |
102 | return NULL; |
103 | } |
104 | |
105 | void ff_fetch_timestamp(AVCodecParserContext *s, int off, int remove, int fuzzy) |
106 | { |
107 | int i; |
108 | |
109 | if (!fuzzy) { |
110 | s->dts = |
111 | s->pts = AV_NOPTS_VALUE; |
112 | s->pos = -1; |
113 | s->offset = 0; |
114 | } |
115 | for (i = 0; i < AV_PARSER_PTS_NB; i++) { |
116 | if (s->cur_offset + off >= s->cur_frame_offset[i] && |
117 | (s->frame_offset < s->cur_frame_offset[i] || |
118 | (!s->frame_offset && !s->next_frame_offset)) && // first field/frame |
119 | // check disabled since MPEG-TS does not send complete PES packets |
120 | /*s->next_frame_offset + off <*/ s->cur_frame_end[i]){ |
121 | |
122 | if (!fuzzy || s->cur_frame_dts[i] != AV_NOPTS_VALUE) { |
123 | s->dts = s->cur_frame_dts[i]; |
124 | s->pts = s->cur_frame_pts[i]; |
125 | s->pos = s->cur_frame_pos[i]; |
126 | s->offset = s->next_frame_offset - s->cur_frame_offset[i]; |
127 | } |
128 | if (remove) |
129 | s->cur_frame_offset[i] = INT64_MAX; |
130 | if (s->cur_offset + off < s->cur_frame_end[i]) |
131 | break; |
132 | } |
133 | } |
134 | } |
135 | |
136 | int av_parser_parse2(AVCodecParserContext *s, AVCodecContext *avctx, |
137 | uint8_t **poutbuf, int *poutbuf_size, |
138 | const uint8_t *buf, int buf_size, |
139 | int64_t pts, int64_t dts, int64_t pos) |
140 | { |
141 | int index, i; |
142 | uint8_t dummy_buf[AV_INPUT_BUFFER_PADDING_SIZE]; |
143 | |
144 | av_assert1(avctx->codec_id != AV_CODEC_ID_NONE); |
145 | |
146 | /* Parsers only work for the specified codec ids. */ |
147 | av_assert1(avctx->codec_id == s->parser->codec_ids[0] || |
148 | avctx->codec_id == s->parser->codec_ids[1] || |
149 | avctx->codec_id == s->parser->codec_ids[2] || |
150 | avctx->codec_id == s->parser->codec_ids[3] || |
151 | avctx->codec_id == s->parser->codec_ids[4]); |
152 | |
153 | if (!(s->flags & PARSER_FLAG_FETCHED_OFFSET)) { |
154 | s->next_frame_offset = |
155 | s->cur_offset = pos; |
156 | s->flags |= PARSER_FLAG_FETCHED_OFFSET; |
157 | } |
158 | |
159 | if (buf_size == 0) { |
160 | /* padding is always necessary even if EOF, so we add it here */ |
161 | memset(dummy_buf, 0, sizeof(dummy_buf)); |
162 | buf = dummy_buf; |
163 | } else if (s->cur_offset + buf_size != s->cur_frame_end[s->cur_frame_start_index]) { /* skip remainder packets */ |
164 | /* add a new packet descriptor */ |
165 | i = (s->cur_frame_start_index + 1) & (AV_PARSER_PTS_NB - 1); |
166 | s->cur_frame_start_index = i; |
167 | s->cur_frame_offset[i] = s->cur_offset; |
168 | s->cur_frame_end[i] = s->cur_offset + buf_size; |
169 | s->cur_frame_pts[i] = pts; |
170 | s->cur_frame_dts[i] = dts; |
171 | s->cur_frame_pos[i] = pos; |
172 | } |
173 | |
174 | if (s->fetch_timestamp) { |
175 | s->fetch_timestamp = 0; |
176 | s->last_pts = s->pts; |
177 | s->last_dts = s->dts; |
178 | s->last_pos = s->pos; |
179 | ff_fetch_timestamp(s, 0, 0, 0); |
180 | } |
181 | /* WARNING: the returned index can be negative */ |
182 | index = s->parser->parser_parse(s, avctx, (const uint8_t **) poutbuf, |
183 | poutbuf_size, buf, buf_size); |
184 | av_assert0(index > -0x20000000); // The API does not allow returning AVERROR codes |
185 | #define FILL(name) if(s->name > 0 && avctx->name <= 0) avctx->name = s->name |
186 | if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) { |
187 | FILL(field_order); |
188 | } |
189 | |
190 | /* update the file pointer */ |
191 | if (*poutbuf_size) { |
192 | /* fill the data for the current frame */ |
193 | s->frame_offset = s->next_frame_offset; |
194 | |
195 | /* offset of the next frame */ |
196 | s->next_frame_offset = s->cur_offset + index; |
197 | s->fetch_timestamp = 1; |
198 | } |
199 | if (index < 0) |
200 | index = 0; |
201 | s->cur_offset += index; |
202 | return index; |
203 | } |
204 | |
205 | int av_parser_change(AVCodecParserContext *s, AVCodecContext *avctx, |
206 | uint8_t **poutbuf, int *poutbuf_size, |
207 | const uint8_t *buf, int buf_size, int keyframe) |
208 | { |
209 | if (s && s->parser->split) { |
210 | if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER || |
211 | avctx->flags2 & AV_CODEC_FLAG2_LOCAL_HEADER) { |
212 | int i = s->parser->split(avctx, buf, buf_size); |
213 | buf += i; |
214 | buf_size -= i; |
215 | } |
216 | } |
217 | |
218 | /* cast to avoid warning about discarding qualifiers */ |
219 | *poutbuf = (uint8_t *) buf; |
220 | *poutbuf_size = buf_size; |
221 | if (avctx->extradata) { |
222 | if (keyframe && (avctx->flags2 & AV_CODEC_FLAG2_LOCAL_HEADER)) { |
223 | int size = buf_size + avctx->extradata_size; |
224 | |
225 | *poutbuf_size = size; |
226 | *poutbuf = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE); |
227 | if (!*poutbuf) |
228 | return AVERROR(ENOMEM); |
229 | |
230 | memcpy(*poutbuf, avctx->extradata, avctx->extradata_size); |
231 | memcpy(*poutbuf + avctx->extradata_size, buf, |
232 | buf_size + AV_INPUT_BUFFER_PADDING_SIZE); |
233 | return 1; |
234 | } |
235 | } |
236 | |
237 | return 0; |
238 | } |
239 | |
240 | void av_parser_close(AVCodecParserContext *s) |
241 | { |
242 | if (s) { |
243 | if (s->parser->parser_close) |
244 | s->parser->parser_close(s); |
245 | av_freep(&s->priv_data); |
246 | av_free(s); |
247 | } |
248 | } |
249 | |
250 | int ff_combine_frame(ParseContext *pc, int next, |
251 | const uint8_t **buf, int *buf_size) |
252 | { |
253 | if (pc->overread) { |
254 | ff_dlog(NULL, "overread %d, state:%"PRIX32" next:%d index:%d o_index:%d\n", |
255 | pc->overread, pc->state, next, pc->index, pc->overread_index); |
256 | ff_dlog(NULL, "%X %X %X %X\n", |
257 | (*buf)[0], (*buf)[1], (*buf)[2], (*buf)[3]); |
258 | } |
259 | |
260 | /* Copy overread bytes from last frame into buffer. */ |
261 | for (; pc->overread > 0; pc->overread--) |
262 | pc->buffer[pc->index++] = pc->buffer[pc->overread_index++]; |
263 | |
264 | /* flush remaining if EOF */ |
265 | if (!*buf_size && next == END_NOT_FOUND) |
266 | next = 0; |
267 | |
268 | pc->last_index = pc->index; |
269 | |
270 | /* copy into buffer end return */ |
271 | if (next == END_NOT_FOUND) { |
272 | void *new_buffer = av_fast_realloc(pc->buffer, &pc->buffer_size, |
273 | *buf_size + pc->index + |
274 | AV_INPUT_BUFFER_PADDING_SIZE); |
275 | |
276 | if (!new_buffer) { |
277 | av_log(NULL, AV_LOG_ERROR, "Failed to reallocate parser buffer to %d\n", *buf_size + pc->index + AV_INPUT_BUFFER_PADDING_SIZE); |
278 | pc->index = 0; |
279 | return AVERROR(ENOMEM); |
280 | } |
281 | pc->buffer = new_buffer; |
282 | memcpy(&pc->buffer[pc->index], *buf, *buf_size); |
283 | pc->index += *buf_size; |
284 | return -1; |
285 | } |
286 | |
287 | *buf_size = |
288 | pc->overread_index = pc->index + next; |
289 | |
290 | /* append to buffer */ |
291 | if (pc->index) { |
292 | void *new_buffer = av_fast_realloc(pc->buffer, &pc->buffer_size, |
293 | next + pc->index + |
294 | AV_INPUT_BUFFER_PADDING_SIZE); |
295 | if (!new_buffer) { |
296 | av_log(NULL, AV_LOG_ERROR, "Failed to reallocate parser buffer to %d\n", next + pc->index + AV_INPUT_BUFFER_PADDING_SIZE); |
297 | pc->overread_index = |
298 | pc->index = 0; |
299 | return AVERROR(ENOMEM); |
300 | } |
301 | pc->buffer = new_buffer; |
302 | if (next > -AV_INPUT_BUFFER_PADDING_SIZE) |
303 | memcpy(&pc->buffer[pc->index], *buf, |
304 | next + AV_INPUT_BUFFER_PADDING_SIZE); |
305 | pc->index = 0; |
306 | *buf = pc->buffer; |
307 | } |
308 | |
309 | /* store overread bytes */ |
310 | for (; next < 0; next++) { |
311 | pc->state = pc->state << 8 | pc->buffer[pc->last_index + next]; |
312 | pc->state64 = pc->state64 << 8 | pc->buffer[pc->last_index + next]; |
313 | pc->overread++; |
314 | } |
315 | |
316 | if (pc->overread) { |
317 | ff_dlog(NULL, "overread %d, state:%"PRIX32" next:%d index:%d o_index:%d\n", |
318 | pc->overread, pc->state, next, pc->index, pc->overread_index); |
319 | ff_dlog(NULL, "%X %X %X %X\n", |
320 | (*buf)[0], (*buf)[1], (*buf)[2], (*buf)[3]); |
321 | } |
322 | |
323 | return 0; |
324 | } |
325 | |
326 | void ff_parse_close(AVCodecParserContext *s) |
327 | { |
328 | ParseContext *pc = s->priv_data; |
329 | |
330 | av_freep(&pc->buffer); |
331 | } |
332 | |
333 | int ff_mpeg4video_split(AVCodecContext *avctx, const uint8_t *buf, int buf_size) |
334 | { |
335 | uint32_t state = -1; |
336 | const uint8_t *ptr = buf, *end = buf + buf_size; |
337 | |
338 | while (ptr < end) { |
339 | ptr = avpriv_find_start_code(ptr, end, &state); |
340 | if (state == 0x1B3 || state == 0x1B6) |
341 | return ptr - 4 - buf; |
342 | } |
343 | |
344 | return 0; |
345 | } |
346 |