Line | Branch | Exec | Source |
---|---|---|---|
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 <inttypes.h> | ||
24 | #include <stdint.h> | ||
25 | #include <string.h> | ||
26 | |||
27 | #include "libavutil/avassert.h" | ||
28 | #include "libavutil/mem.h" | ||
29 | |||
30 | #include "parser.h" | ||
31 | |||
32 | 10196 | AVCodecParserContext *av_parser_init(int codec_id) | |
33 | { | ||
34 | 10196 | AVCodecParserContext *s = NULL; | |
35 | const AVCodecParser *parser; | ||
36 | 10196 | void *i = 0; | |
37 | int ret; | ||
38 | |||
39 |
2/2✓ Branch 0 taken 65 times.
✓ Branch 1 taken 10131 times.
|
10196 | if (codec_id == AV_CODEC_ID_NONE) |
40 | 65 | return NULL; | |
41 | |||
42 |
2/2✓ Branch 1 taken 463263 times.
✓ Branch 2 taken 3479 times.
|
466742 | while ((parser = av_parser_iterate(&i))) { |
43 |
2/2✓ Branch 0 taken 460248 times.
✓ Branch 1 taken 3015 times.
|
463263 | if (parser->codec_ids[0] == codec_id || |
44 |
2/2✓ Branch 0 taken 456784 times.
✓ Branch 1 taken 3464 times.
|
460248 | parser->codec_ids[1] == codec_id || |
45 |
2/2✓ Branch 0 taken 456631 times.
✓ Branch 1 taken 153 times.
|
456784 | parser->codec_ids[2] == codec_id || |
46 |
2/2✓ Branch 0 taken 456623 times.
✓ Branch 1 taken 8 times.
|
456631 | parser->codec_ids[3] == codec_id || |
47 |
2/2✓ Branch 0 taken 456615 times.
✓ Branch 1 taken 8 times.
|
456623 | parser->codec_ids[4] == codec_id || |
48 |
2/2✓ Branch 0 taken 456611 times.
✓ Branch 1 taken 4 times.
|
456615 | parser->codec_ids[5] == codec_id || |
49 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 456611 times.
|
456611 | parser->codec_ids[6] == codec_id) |
50 | 6652 | goto found; | |
51 | } | ||
52 | 3479 | return NULL; | |
53 | |||
54 | 6652 | found: | |
55 | 6652 | s = av_mallocz(sizeof(AVCodecParserContext)); | |
56 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6652 times.
|
6652 | if (!s) |
57 | ✗ | goto err_out; | |
58 | 6652 | s->parser = parser; | |
59 | 6652 | s->priv_data = av_mallocz(parser->priv_data_size); | |
60 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6652 times.
|
6652 | if (!s->priv_data) |
61 | ✗ | goto err_out; | |
62 | 6652 | s->fetch_timestamp=1; | |
63 | 6652 | s->pict_type = AV_PICTURE_TYPE_I; | |
64 |
2/2✓ Branch 0 taken 2179 times.
✓ Branch 1 taken 4473 times.
|
6652 | if (parser->parser_init) { |
65 | 2179 | ret = parser->parser_init(s); | |
66 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2179 times.
|
2179 | if (ret != 0) |
67 | ✗ | goto err_out; | |
68 | } | ||
69 | 6652 | s->key_frame = -1; | |
70 | 6652 | s->dts_sync_point = INT_MIN; | |
71 | 6652 | s->dts_ref_dts_delta = INT_MIN; | |
72 | 6652 | s->pts_dts_delta = INT_MIN; | |
73 | 6652 | s->format = -1; | |
74 | |||
75 | 6652 | return s; | |
76 | |||
77 | ✗ | err_out: | |
78 | ✗ | if (s) | |
79 | ✗ | av_freep(&s->priv_data); | |
80 | ✗ | av_free(s); | |
81 | ✗ | return NULL; | |
82 | } | ||
83 | |||
84 | 192381 | void ff_fetch_timestamp(AVCodecParserContext *s, int off, int remove, int fuzzy) | |
85 | { | ||
86 | int i; | ||
87 | |||
88 |
2/2✓ Branch 0 taken 191553 times.
✓ Branch 1 taken 828 times.
|
192381 | if (!fuzzy) { |
89 | 191553 | s->dts = | |
90 | 191553 | s->pts = AV_NOPTS_VALUE; | |
91 | 191553 | s->pos = -1; | |
92 | 191553 | s->offset = 0; | |
93 | } | ||
94 |
2/2✓ Branch 0 taken 564377 times.
✓ Branch 1 taken 56654 times.
|
621031 | for (i = 0; i < AV_PARSER_PTS_NB; i++) { |
95 |
2/2✓ Branch 0 taken 555286 times.
✓ Branch 1 taken 9091 times.
|
564377 | if (s->cur_offset + off >= s->cur_frame_offset[i] && |
96 |
2/2✓ Branch 0 taken 365105 times.
✓ Branch 1 taken 190181 times.
|
555286 | (s->frame_offset < s->cur_frame_offset[i] || |
97 |
4/4✓ Branch 0 taken 5582 times.
✓ Branch 1 taken 359523 times.
✓ Branch 2 taken 2110 times.
✓ Branch 3 taken 3472 times.
|
365105 | (!s->frame_offset && !s->next_frame_offset)) && // first field/frame |
98 | // check disabled since MPEG-TS does not send complete PES packets | ||
99 |
2/2✓ Branch 0 taken 191224 times.
✓ Branch 1 taken 1067 times.
|
192291 | /*s->next_frame_offset + off <*/ s->cur_frame_end[i]){ |
100 | |||
101 |
4/4✓ Branch 0 taken 1128 times.
✓ Branch 1 taken 190096 times.
✓ Branch 2 taken 250 times.
✓ Branch 3 taken 878 times.
|
191224 | if (!fuzzy || s->cur_frame_dts[i] != AV_NOPTS_VALUE) { |
102 | 190346 | s->dts = s->cur_frame_dts[i]; | |
103 | 190346 | s->pts = s->cur_frame_pts[i]; | |
104 | 190346 | s->pos = s->cur_frame_pos[i]; | |
105 | 190346 | s->offset = s->next_frame_offset - s->cur_frame_offset[i]; | |
106 | } | ||
107 |
2/2✓ Branch 0 taken 12306 times.
✓ Branch 1 taken 178918 times.
|
191224 | if (remove) |
108 | 12306 | s->cur_frame_offset[i] = INT64_MAX; | |
109 |
2/2✓ Branch 0 taken 135727 times.
✓ Branch 1 taken 55497 times.
|
191224 | if (s->cur_offset + off < s->cur_frame_end[i]) |
110 | 135727 | break; | |
111 | } | ||
112 | } | ||
113 | 192381 | } | |
114 | |||
115 | 811001 | int av_parser_parse2(AVCodecParserContext *s, AVCodecContext *avctx, | |
116 | uint8_t **poutbuf, int *poutbuf_size, | ||
117 | const uint8_t *buf, int buf_size, | ||
118 | int64_t pts, int64_t dts, int64_t pos) | ||
119 | { | ||
120 | int index, i; | ||
121 | uint8_t dummy_buf[AV_INPUT_BUFFER_PADDING_SIZE]; | ||
122 | |||
123 | av_assert1(avctx->codec_id != AV_CODEC_ID_NONE); | ||
124 | |||
125 | /* Parsers only work for the specified codec ids. */ | ||
126 | av_assert1(avctx->codec_id == s->parser->codec_ids[0] || | ||
127 | avctx->codec_id == s->parser->codec_ids[1] || | ||
128 | avctx->codec_id == s->parser->codec_ids[2] || | ||
129 | avctx->codec_id == s->parser->codec_ids[3] || | ||
130 | avctx->codec_id == s->parser->codec_ids[4] || | ||
131 | avctx->codec_id == s->parser->codec_ids[5] || | ||
132 | avctx->codec_id == s->parser->codec_ids[6]); | ||
133 | |||
134 |
2/2✓ Branch 0 taken 3432 times.
✓ Branch 1 taken 807569 times.
|
811001 | if (!(s->flags & PARSER_FLAG_FETCHED_OFFSET)) { |
135 | 3432 | s->next_frame_offset = | |
136 | 3432 | s->cur_offset = pos; | |
137 | 3432 | s->flags |= PARSER_FLAG_FETCHED_OFFSET; | |
138 | } | ||
139 | |||
140 |
2/2✓ Branch 0 taken 3191 times.
✓ Branch 1 taken 807810 times.
|
811001 | if (buf_size == 0) { |
141 | /* padding is always necessary even if EOF, so we add it here */ | ||
142 | 3191 | memset(dummy_buf, 0, sizeof(dummy_buf)); | |
143 | 3191 | buf = dummy_buf; | |
144 |
2/2✓ Branch 0 taken 691916 times.
✓ Branch 1 taken 115894 times.
|
807810 | } else if (s->cur_offset + buf_size != s->cur_frame_end[s->cur_frame_start_index]) { /* skip remainder packets */ |
145 | /* add a new packet descriptor */ | ||
146 | 691916 | i = (s->cur_frame_start_index + 1) & (AV_PARSER_PTS_NB - 1); | |
147 | 691916 | s->cur_frame_start_index = i; | |
148 | 691916 | s->cur_frame_offset[i] = s->cur_offset; | |
149 | 691916 | s->cur_frame_end[i] = s->cur_offset + buf_size; | |
150 | 691916 | s->cur_frame_pts[i] = pts; | |
151 | 691916 | s->cur_frame_dts[i] = dts; | |
152 | 691916 | s->cur_frame_pos[i] = pos; | |
153 | } | ||
154 | |||
155 |
2/2✓ Branch 0 taken 185373 times.
✓ Branch 1 taken 625628 times.
|
811001 | if (s->fetch_timestamp) { |
156 | 185373 | s->fetch_timestamp = 0; | |
157 | 185373 | s->last_pts = s->pts; | |
158 | 185373 | s->last_dts = s->dts; | |
159 | 185373 | s->last_pos = s->pos; | |
160 | 185373 | ff_fetch_timestamp(s, 0, 0, 0); | |
161 | } | ||
162 | /* WARNING: the returned index can be negative */ | ||
163 | 811001 | index = s->parser->parser_parse(s, avctx, (const uint8_t **) poutbuf, | |
164 | poutbuf_size, buf, buf_size); | ||
165 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 811001 times.
|
811001 | av_assert0(index > -0x20000000); // The API does not allow returning AVERROR codes |
166 | #define FILL(name) if(s->name > 0 && avctx->name <= 0) avctx->name = s->name | ||
167 |
2/2✓ Branch 0 taken 618359 times.
✓ Branch 1 taken 192642 times.
|
811001 | if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) { |
168 |
4/4✓ Branch 0 taken 235843 times.
✓ Branch 1 taken 382516 times.
✓ Branch 2 taken 467 times.
✓ Branch 3 taken 235376 times.
|
618359 | FILL(field_order); |
169 |
4/4✓ Branch 0 taken 325826 times.
✓ Branch 1 taken 292533 times.
✓ Branch 2 taken 802 times.
✓ Branch 3 taken 325024 times.
|
618359 | FILL(coded_width); |
170 |
4/4✓ Branch 0 taken 325826 times.
✓ Branch 1 taken 292533 times.
✓ Branch 2 taken 802 times.
✓ Branch 3 taken 325024 times.
|
618359 | FILL(coded_height); |
171 |
4/4✓ Branch 0 taken 326729 times.
✓ Branch 1 taken 291630 times.
✓ Branch 2 taken 506 times.
✓ Branch 3 taken 326223 times.
|
618359 | FILL(width); |
172 |
4/4✓ Branch 0 taken 326729 times.
✓ Branch 1 taken 291630 times.
✓ Branch 2 taken 506 times.
✓ Branch 3 taken 326223 times.
|
618359 | FILL(height); |
173 | } | ||
174 | |||
175 | /* update the file pointer */ | ||
176 |
2/2✓ Branch 0 taken 182909 times.
✓ Branch 1 taken 628092 times.
|
811001 | if (*poutbuf_size) { |
177 | /* fill the data for the current frame */ | ||
178 | 182909 | s->frame_offset = s->next_frame_offset; | |
179 | |||
180 | /* offset of the next frame */ | ||
181 | 182909 | s->next_frame_offset = s->cur_offset + index; | |
182 | 182909 | s->fetch_timestamp = 1; | |
183 | } else { | ||
184 | /* Don't return a pointer to dummy_buf. */ | ||
185 | 628092 | *poutbuf = NULL; | |
186 | } | ||
187 |
2/2✓ Branch 0 taken 4831 times.
✓ Branch 1 taken 806170 times.
|
811001 | if (index < 0) |
188 | 4831 | index = 0; | |
189 | 811001 | s->cur_offset += index; | |
190 | 811001 | return index; | |
191 | } | ||
192 | |||
193 | 18666 | void av_parser_close(AVCodecParserContext *s) | |
194 | { | ||
195 |
2/2✓ Branch 0 taken 6652 times.
✓ Branch 1 taken 12014 times.
|
18666 | if (s) { |
196 |
2/2✓ Branch 0 taken 6317 times.
✓ Branch 1 taken 335 times.
|
6652 | if (s->parser->parser_close) |
197 | 6317 | s->parser->parser_close(s); | |
198 | 6652 | av_freep(&s->priv_data); | |
199 | 6652 | av_free(s); | |
200 | } | ||
201 | 18666 | } | |
202 | |||
203 | 753748 | int ff_combine_frame(ParseContext *pc, int next, | |
204 | const uint8_t **buf, int *buf_size) | ||
205 | { | ||
206 | 753748 | if (pc->overread) { | |
207 | ff_dlog(NULL, "overread %d, state:%"PRIX32" next:%d index:%d o_index:%d\n", | ||
208 | pc->overread, pc->state, next, pc->index, pc->overread_index); | ||
209 | ff_dlog(NULL, "%X %X %X %X\n", | ||
210 | (*buf)[0], (*buf)[1], (*buf)[2], (*buf)[3]); | ||
211 | } | ||
212 | |||
213 | /* Copy overread bytes from last frame into buffer. */ | ||
214 |
2/2✓ Branch 0 taken 1367 times.
✓ Branch 1 taken 753748 times.
|
755115 | for (; pc->overread > 0; pc->overread--) |
215 | 1367 | pc->buffer[pc->index++] = pc->buffer[pc->overread_index++]; | |
216 | |||
217 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 753748 times.
|
753748 | if (next > *buf_size) |
218 | ✗ | return AVERROR(EINVAL); | |
219 | |||
220 | /* flush remaining if EOF */ | ||
221 |
4/4✓ Branch 0 taken 2137 times.
✓ Branch 1 taken 751611 times.
✓ Branch 2 taken 1694 times.
✓ Branch 3 taken 443 times.
|
753748 | if (!*buf_size && next == END_NOT_FOUND) |
222 | 1694 | next = 0; | |
223 | |||
224 | 753748 | pc->last_index = pc->index; | |
225 | |||
226 | /* copy into buffer end return */ | ||
227 |
2/2✓ Branch 0 taken 617971 times.
✓ Branch 1 taken 135777 times.
|
753748 | if (next == END_NOT_FOUND) { |
228 | 617971 | void *new_buffer = av_fast_realloc(pc->buffer, &pc->buffer_size, | |
229 | 617971 | *buf_size + pc->index + | |
230 | AV_INPUT_BUFFER_PADDING_SIZE); | ||
231 | |||
232 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 617971 times.
|
617971 | if (!new_buffer) { |
233 | ✗ | av_log(NULL, AV_LOG_ERROR, "Failed to reallocate parser buffer to %d\n", *buf_size + pc->index + AV_INPUT_BUFFER_PADDING_SIZE); | |
234 | ✗ | pc->index = 0; | |
235 | ✗ | return AVERROR(ENOMEM); | |
236 | } | ||
237 | 617971 | pc->buffer = new_buffer; | |
238 | 617971 | memcpy(&pc->buffer[pc->index], *buf, *buf_size); | |
239 | 617971 | memset(&pc->buffer[pc->index + *buf_size], 0, AV_INPUT_BUFFER_PADDING_SIZE); | |
240 | 617971 | pc->index += *buf_size; | |
241 | 617971 | return -1; | |
242 | } | ||
243 | |||
244 |
3/4✓ Branch 0 taken 270 times.
✓ Branch 1 taken 135507 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 270 times.
|
135777 | av_assert0(next >= 0 || pc->buffer); |
245 | |||
246 | 135777 | *buf_size = | |
247 | 135777 | pc->overread_index = pc->index + next; | |
248 | |||
249 | /* append to buffer */ | ||
250 |
2/2✓ Branch 0 taken 60249 times.
✓ Branch 1 taken 75528 times.
|
135777 | if (pc->index) { |
251 | 60249 | void *new_buffer = av_fast_realloc(pc->buffer, &pc->buffer_size, | |
252 | 60249 | next + pc->index + | |
253 | AV_INPUT_BUFFER_PADDING_SIZE); | ||
254 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 60249 times.
|
60249 | if (!new_buffer) { |
255 | ✗ | av_log(NULL, AV_LOG_ERROR, "Failed to reallocate parser buffer to %d\n", next + pc->index + AV_INPUT_BUFFER_PADDING_SIZE); | |
256 | ✗ | *buf_size = | |
257 | ✗ | pc->overread_index = | |
258 | ✗ | pc->index = 0; | |
259 | ✗ | return AVERROR(ENOMEM); | |
260 | } | ||
261 | 60249 | pc->buffer = new_buffer; | |
262 |
2/2✓ Branch 0 taken 60244 times.
✓ Branch 1 taken 5 times.
|
60249 | if (next > -AV_INPUT_BUFFER_PADDING_SIZE) |
263 | 60244 | memcpy(&pc->buffer[pc->index], *buf, | |
264 | 60244 | next + AV_INPUT_BUFFER_PADDING_SIZE); | |
265 | 60249 | pc->index = 0; | |
266 | 60249 | *buf = pc->buffer; | |
267 | } | ||
268 | |||
269 |
2/2✓ Branch 0 taken 38 times.
✓ Branch 1 taken 135739 times.
|
135777 | if (next < -8) { |
270 | 38 | pc->overread += -8 - next; | |
271 | 38 | next = -8; | |
272 | } | ||
273 | /* store overread bytes */ | ||
274 |
2/2✓ Branch 0 taken 972 times.
✓ Branch 1 taken 135777 times.
|
136749 | for (; next < 0; next++) { |
275 | 972 | pc->state = pc->state << 8 | pc->buffer[pc->last_index + next]; | |
276 | 972 | pc->state64 = pc->state64 << 8 | pc->buffer[pc->last_index + next]; | |
277 | 972 | pc->overread++; | |
278 | } | ||
279 | |||
280 | 135777 | if (pc->overread) { | |
281 | ff_dlog(NULL, "overread %d, state:%"PRIX32" next:%d index:%d o_index:%d\n", | ||
282 | pc->overread, pc->state, next, pc->index, pc->overread_index); | ||
283 | ff_dlog(NULL, "%X %X %X %X\n", | ||
284 | (*buf)[0], (*buf)[1], (*buf)[2], (*buf)[3]); | ||
285 | } | ||
286 | |||
287 | 135777 | return 0; | |
288 | } | ||
289 | |||
290 | 5150 | void ff_parse_close(AVCodecParserContext *s) | |
291 | { | ||
292 | 5150 | ParseContext *pc = s->priv_data; | |
293 | |||
294 | 5150 | av_freep(&pc->buffer); | |
295 | 5150 | } | |
296 |