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 | 10127 | AVCodecParserContext *av_parser_init(int codec_id) | |
33 | { | ||
34 | 10127 | AVCodecParserContext *s = NULL; | |
35 | const AVCodecParser *parser; | ||
36 | 10127 | void *i = 0; | |
37 | int ret; | ||
38 | |||
39 |
2/2✓ Branch 0 taken 64 times.
✓ Branch 1 taken 10063 times.
|
10127 | if (codec_id == AV_CODEC_ID_NONE) |
40 | 64 | return NULL; | |
41 | |||
42 |
2/2✓ Branch 1 taken 460524 times.
✓ Branch 2 taken 3447 times.
|
463971 | while ((parser = av_parser_iterate(&i))) { |
43 |
2/2✓ Branch 0 taken 457548 times.
✓ Branch 1 taken 2976 times.
|
460524 | if (parser->codec_ids[0] == codec_id || |
44 |
2/2✓ Branch 0 taken 454081 times.
✓ Branch 1 taken 3467 times.
|
457548 | parser->codec_ids[1] == codec_id || |
45 |
2/2✓ Branch 0 taken 453928 times.
✓ Branch 1 taken 153 times.
|
454081 | parser->codec_ids[2] == codec_id || |
46 |
2/2✓ Branch 0 taken 453920 times.
✓ Branch 1 taken 8 times.
|
453928 | parser->codec_ids[3] == codec_id || |
47 |
2/2✓ Branch 0 taken 453912 times.
✓ Branch 1 taken 8 times.
|
453920 | parser->codec_ids[4] == codec_id || |
48 |
2/2✓ Branch 0 taken 453908 times.
✓ Branch 1 taken 4 times.
|
453912 | parser->codec_ids[5] == codec_id || |
49 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 453908 times.
|
453908 | parser->codec_ids[6] == codec_id) |
50 | 6616 | goto found; | |
51 | } | ||
52 | 3447 | return NULL; | |
53 | |||
54 | 6616 | found: | |
55 | 6616 | s = av_mallocz(sizeof(AVCodecParserContext)); | |
56 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6616 times.
|
6616 | if (!s) |
57 | ✗ | goto err_out; | |
58 | 6616 | s->parser = parser; | |
59 | 6616 | s->priv_data = av_mallocz(parser->priv_data_size); | |
60 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6616 times.
|
6616 | if (!s->priv_data) |
61 | ✗ | goto err_out; | |
62 | 6616 | s->fetch_timestamp=1; | |
63 | 6616 | s->pict_type = AV_PICTURE_TYPE_I; | |
64 |
2/2✓ Branch 0 taken 2155 times.
✓ Branch 1 taken 4461 times.
|
6616 | if (parser->parser_init) { |
65 | 2155 | ret = parser->parser_init(s); | |
66 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2155 times.
|
2155 | if (ret != 0) |
67 | ✗ | goto err_out; | |
68 | } | ||
69 | 6616 | s->key_frame = -1; | |
70 | 6616 | s->dts_sync_point = INT_MIN; | |
71 | 6616 | s->dts_ref_dts_delta = INT_MIN; | |
72 | 6616 | s->pts_dts_delta = INT_MIN; | |
73 | 6616 | s->format = -1; | |
74 | |||
75 | 6616 | 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 | 192002 | void ff_fetch_timestamp(AVCodecParserContext *s, int off, int remove, int fuzzy) | |
85 | { | ||
86 | int i; | ||
87 | |||
88 |
2/2✓ Branch 0 taken 191174 times.
✓ Branch 1 taken 828 times.
|
192002 | if (!fuzzy) { |
89 | 191174 | s->dts = | |
90 | 191174 | s->pts = AV_NOPTS_VALUE; | |
91 | 191174 | s->pos = -1; | |
92 | 191174 | s->offset = 0; | |
93 | } | ||
94 |
2/2✓ Branch 0 taken 563389 times.
✓ Branch 1 taken 56624 times.
|
620013 | for (i = 0; i < AV_PARSER_PTS_NB; i++) { |
95 |
2/2✓ Branch 0 taken 554313 times.
✓ Branch 1 taken 9076 times.
|
563389 | if (s->cur_offset + off >= s->cur_frame_offset[i] && |
96 |
2/2✓ Branch 0 taken 364918 times.
✓ Branch 1 taken 189395 times.
|
554313 | (s->frame_offset < s->cur_frame_offset[i] || |
97 |
4/4✓ Branch 0 taken 5561 times.
✓ Branch 1 taken 359357 times.
✓ Branch 2 taken 2094 times.
✓ Branch 3 taken 3467 times.
|
364918 | (!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 190430 times.
✓ Branch 1 taken 1059 times.
|
191489 | /*s->next_frame_offset + off <*/ s->cur_frame_end[i]){ |
100 | |||
101 |
4/4✓ Branch 0 taken 1128 times.
✓ Branch 1 taken 189302 times.
✓ Branch 2 taken 250 times.
✓ Branch 3 taken 878 times.
|
190430 | if (!fuzzy || s->cur_frame_dts[i] != AV_NOPTS_VALUE) { |
102 | 189552 | s->dts = s->cur_frame_dts[i]; | |
103 | 189552 | s->pts = s->cur_frame_pts[i]; | |
104 | 189552 | s->pos = s->cur_frame_pos[i]; | |
105 | 189552 | s->offset = s->next_frame_offset - s->cur_frame_offset[i]; | |
106 | } | ||
107 |
2/2✓ Branch 0 taken 12293 times.
✓ Branch 1 taken 178137 times.
|
190430 | if (remove) |
108 | 12293 | s->cur_frame_offset[i] = INT64_MAX; | |
109 |
2/2✓ Branch 0 taken 135378 times.
✓ Branch 1 taken 55052 times.
|
190430 | if (s->cur_offset + off < s->cur_frame_end[i]) |
110 | 135378 | break; | |
111 | } | ||
112 | } | ||
113 | 192002 | } | |
114 | |||
115 | 807839 | 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 3421 times.
✓ Branch 1 taken 804418 times.
|
807839 | if (!(s->flags & PARSER_FLAG_FETCHED_OFFSET)) { |
135 | 3421 | s->next_frame_offset = | |
136 | 3421 | s->cur_offset = pos; | |
137 | 3421 | s->flags |= PARSER_FLAG_FETCHED_OFFSET; | |
138 | } | ||
139 | |||
140 |
2/2✓ Branch 0 taken 3163 times.
✓ Branch 1 taken 804676 times.
|
807839 | if (buf_size == 0) { |
141 | /* padding is always necessary even if EOF, so we add it here */ | ||
142 | 3163 | memset(dummy_buf, 0, sizeof(dummy_buf)); | |
143 | 3163 | buf = dummy_buf; | |
144 |
2/2✓ Branch 0 taken 689191 times.
✓ Branch 1 taken 115485 times.
|
804676 | } 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 | 689191 | i = (s->cur_frame_start_index + 1) & (AV_PARSER_PTS_NB - 1); | |
147 | 689191 | s->cur_frame_start_index = i; | |
148 | 689191 | s->cur_frame_offset[i] = s->cur_offset; | |
149 | 689191 | s->cur_frame_end[i] = s->cur_offset + buf_size; | |
150 | 689191 | s->cur_frame_pts[i] = pts; | |
151 | 689191 | s->cur_frame_dts[i] = dts; | |
152 | 689191 | s->cur_frame_pos[i] = pos; | |
153 | } | ||
154 | |||
155 |
2/2✓ Branch 0 taken 185003 times.
✓ Branch 1 taken 622836 times.
|
807839 | if (s->fetch_timestamp) { |
156 | 185003 | s->fetch_timestamp = 0; | |
157 | 185003 | s->last_pts = s->pts; | |
158 | 185003 | s->last_dts = s->dts; | |
159 | 185003 | s->last_pos = s->pos; | |
160 | 185003 | ff_fetch_timestamp(s, 0, 0, 0); | |
161 | } | ||
162 | /* WARNING: the returned index can be negative */ | ||
163 | 807839 | 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 807839 times.
|
807839 | 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 615200 times.
✓ Branch 1 taken 192639 times.
|
807839 | if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) { |
168 |
4/4✓ Branch 0 taken 235476 times.
✓ Branch 1 taken 379724 times.
✓ Branch 2 taken 462 times.
✓ Branch 3 taken 235014 times.
|
615200 | FILL(field_order); |
169 |
4/4✓ Branch 0 taken 322890 times.
✓ Branch 1 taken 292310 times.
✓ Branch 2 taken 790 times.
✓ Branch 3 taken 322100 times.
|
615200 | FILL(coded_width); |
170 |
4/4✓ Branch 0 taken 322890 times.
✓ Branch 1 taken 292310 times.
✓ Branch 2 taken 790 times.
✓ Branch 3 taken 322100 times.
|
615200 | FILL(coded_height); |
171 |
4/4✓ Branch 0 taken 323793 times.
✓ Branch 1 taken 291407 times.
✓ Branch 2 taken 498 times.
✓ Branch 3 taken 323295 times.
|
615200 | FILL(width); |
172 |
4/4✓ Branch 0 taken 323793 times.
✓ Branch 1 taken 291407 times.
✓ Branch 2 taken 498 times.
✓ Branch 3 taken 323295 times.
|
615200 | FILL(height); |
173 | } | ||
174 | |||
175 | /* update the file pointer */ | ||
176 |
2/2✓ Branch 0 taken 182550 times.
✓ Branch 1 taken 625289 times.
|
807839 | if (*poutbuf_size) { |
177 | /* fill the data for the current frame */ | ||
178 | 182550 | s->frame_offset = s->next_frame_offset; | |
179 | |||
180 | /* offset of the next frame */ | ||
181 | 182550 | s->next_frame_offset = s->cur_offset + index; | |
182 | 182550 | s->fetch_timestamp = 1; | |
183 | } else { | ||
184 | /* Don't return a pointer to dummy_buf. */ | ||
185 | 625289 | *poutbuf = NULL; | |
186 | } | ||
187 |
2/2✓ Branch 0 taken 4801 times.
✓ Branch 1 taken 803038 times.
|
807839 | if (index < 0) |
188 | 4801 | index = 0; | |
189 | 807839 | s->cur_offset += index; | |
190 | 807839 | return index; | |
191 | } | ||
192 | |||
193 | 18461 | void av_parser_close(AVCodecParserContext *s) | |
194 | { | ||
195 |
2/2✓ Branch 0 taken 6616 times.
✓ Branch 1 taken 11845 times.
|
18461 | if (s) { |
196 |
2/2✓ Branch 0 taken 6281 times.
✓ Branch 1 taken 335 times.
|
6616 | if (s->parser->parser_close) |
197 | 6281 | s->parser->parser_close(s); | |
198 | 6616 | av_freep(&s->priv_data); | |
199 | 6616 | av_free(s); | |
200 | } | ||
201 | 18461 | } | |
202 | |||
203 | 750523 | int ff_combine_frame(ParseContext *pc, int next, | |
204 | const uint8_t **buf, int *buf_size) | ||
205 | { | ||
206 | 750523 | 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 1354 times.
✓ Branch 1 taken 750523 times.
|
751877 | for (; pc->overread > 0; pc->overread--) |
215 | 1354 | pc->buffer[pc->index++] = pc->buffer[pc->overread_index++]; | |
216 | |||
217 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 750523 times.
|
750523 | if (next > *buf_size) |
218 | ✗ | return AVERROR(EINVAL); | |
219 | |||
220 | /* flush remaining if EOF */ | ||
221 |
4/4✓ Branch 0 taken 2105 times.
✓ Branch 1 taken 748418 times.
✓ Branch 2 taken 1668 times.
✓ Branch 3 taken 437 times.
|
750523 | if (!*buf_size && next == END_NOT_FOUND) |
222 | 1668 | next = 0; | |
223 | |||
224 | 750523 | pc->last_index = pc->index; | |
225 | |||
226 | /* copy into buffer end return */ | ||
227 |
2/2✓ Branch 0 taken 615180 times.
✓ Branch 1 taken 135343 times.
|
750523 | if (next == END_NOT_FOUND) { |
228 | 615180 | void *new_buffer = av_fast_realloc(pc->buffer, &pc->buffer_size, | |
229 | 615180 | *buf_size + pc->index + | |
230 | AV_INPUT_BUFFER_PADDING_SIZE); | ||
231 | |||
232 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 615180 times.
|
615180 | 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 | 615180 | pc->buffer = new_buffer; | |
238 | 615180 | memcpy(&pc->buffer[pc->index], *buf, *buf_size); | |
239 | 615180 | pc->index += *buf_size; | |
240 | 615180 | return -1; | |
241 | } | ||
242 | |||
243 |
3/4✓ Branch 0 taken 266 times.
✓ Branch 1 taken 135077 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 266 times.
|
135343 | av_assert0(next >= 0 || pc->buffer); |
244 | |||
245 | 135343 | *buf_size = | |
246 | 135343 | pc->overread_index = pc->index + next; | |
247 | |||
248 | /* append to buffer */ | ||
249 |
2/2✓ Branch 0 taken 59842 times.
✓ Branch 1 taken 75501 times.
|
135343 | if (pc->index) { |
250 | 59842 | void *new_buffer = av_fast_realloc(pc->buffer, &pc->buffer_size, | |
251 | 59842 | next + pc->index + | |
252 | AV_INPUT_BUFFER_PADDING_SIZE); | ||
253 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 59842 times.
|
59842 | if (!new_buffer) { |
254 | ✗ | av_log(NULL, AV_LOG_ERROR, "Failed to reallocate parser buffer to %d\n", next + pc->index + AV_INPUT_BUFFER_PADDING_SIZE); | |
255 | ✗ | *buf_size = | |
256 | ✗ | pc->overread_index = | |
257 | ✗ | pc->index = 0; | |
258 | ✗ | return AVERROR(ENOMEM); | |
259 | } | ||
260 | 59842 | pc->buffer = new_buffer; | |
261 |
2/2✓ Branch 0 taken 59837 times.
✓ Branch 1 taken 5 times.
|
59842 | if (next > -AV_INPUT_BUFFER_PADDING_SIZE) |
262 | 59837 | memcpy(&pc->buffer[pc->index], *buf, | |
263 | 59837 | next + AV_INPUT_BUFFER_PADDING_SIZE); | |
264 | 59842 | pc->index = 0; | |
265 | 59842 | *buf = pc->buffer; | |
266 | } | ||
267 | |||
268 |
2/2✓ Branch 0 taken 38 times.
✓ Branch 1 taken 135305 times.
|
135343 | if (next < -8) { |
269 | 38 | pc->overread += -8 - next; | |
270 | 38 | next = -8; | |
271 | } | ||
272 | /* store overread bytes */ | ||
273 |
2/2✓ Branch 0 taken 959 times.
✓ Branch 1 taken 135343 times.
|
136302 | for (; next < 0; next++) { |
274 | 959 | pc->state = pc->state << 8 | pc->buffer[pc->last_index + next]; | |
275 | 959 | pc->state64 = pc->state64 << 8 | pc->buffer[pc->last_index + next]; | |
276 | 959 | pc->overread++; | |
277 | } | ||
278 | |||
279 | 135343 | if (pc->overread) { | |
280 | ff_dlog(NULL, "overread %d, state:%"PRIX32" next:%d index:%d o_index:%d\n", | ||
281 | pc->overread, pc->state, next, pc->index, pc->overread_index); | ||
282 | ff_dlog(NULL, "%X %X %X %X\n", | ||
283 | (*buf)[0], (*buf)[1], (*buf)[2], (*buf)[3]); | ||
284 | } | ||
285 | |||
286 | 135343 | return 0; | |
287 | } | ||
288 | |||
289 | 5142 | void ff_parse_close(AVCodecParserContext *s) | |
290 | { | ||
291 | 5142 | ParseContext *pc = s->priv_data; | |
292 | |||
293 | 5142 | av_freep(&pc->buffer); | |
294 | 5142 | } | |
295 |