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 | 9896 | AVCodecParserContext *av_parser_init(int codec_id) | |
33 | { | ||
34 | 9896 | AVCodecParserContext *s = NULL; | |
35 | const AVCodecParser *parser; | ||
36 | 9896 | void *i = 0; | |
37 | int ret; | ||
38 | |||
39 |
2/2✓ Branch 0 taken 60 times.
✓ Branch 1 taken 9836 times.
|
9896 | if (codec_id == AV_CODEC_ID_NONE) |
40 | 60 | return NULL; | |
41 | |||
42 |
2/2✓ Branch 1 taken 451885 times.
✓ Branch 2 taken 3419 times.
|
455304 | while ((parser = av_parser_iterate(&i))) { |
43 |
2/2✓ Branch 0 taken 449076 times.
✓ Branch 1 taken 2809 times.
|
451885 | if (parser->codec_ids[0] == codec_id || |
44 |
2/2✓ Branch 0 taken 445641 times.
✓ Branch 1 taken 3435 times.
|
449076 | parser->codec_ids[1] == codec_id || |
45 |
2/2✓ Branch 0 taken 445488 times.
✓ Branch 1 taken 153 times.
|
445641 | parser->codec_ids[2] == codec_id || |
46 |
2/2✓ Branch 0 taken 445480 times.
✓ Branch 1 taken 8 times.
|
445488 | parser->codec_ids[3] == codec_id || |
47 |
2/2✓ Branch 0 taken 445472 times.
✓ Branch 1 taken 8 times.
|
445480 | parser->codec_ids[4] == codec_id || |
48 |
2/2✓ Branch 0 taken 445468 times.
✓ Branch 1 taken 4 times.
|
445472 | parser->codec_ids[5] == codec_id || |
49 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 445468 times.
|
445468 | parser->codec_ids[6] == codec_id) |
50 | 6417 | goto found; | |
51 | } | ||
52 | 3419 | return NULL; | |
53 | |||
54 | 6417 | found: | |
55 | 6417 | s = av_mallocz(sizeof(AVCodecParserContext)); | |
56 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6417 times.
|
6417 | if (!s) |
57 | ✗ | goto err_out; | |
58 | 6417 | s->parser = parser; | |
59 | 6417 | s->priv_data = av_mallocz(parser->priv_data_size); | |
60 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6417 times.
|
6417 | if (!s->priv_data) |
61 | ✗ | goto err_out; | |
62 | 6417 | s->fetch_timestamp=1; | |
63 | 6417 | s->pict_type = AV_PICTURE_TYPE_I; | |
64 |
2/2✓ Branch 0 taken 2040 times.
✓ Branch 1 taken 4377 times.
|
6417 | if (parser->parser_init) { |
65 | 2040 | ret = parser->parser_init(s); | |
66 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2040 times.
|
2040 | if (ret != 0) |
67 | ✗ | goto err_out; | |
68 | } | ||
69 | 6417 | s->key_frame = -1; | |
70 | 6417 | s->dts_sync_point = INT_MIN; | |
71 | 6417 | s->dts_ref_dts_delta = INT_MIN; | |
72 | 6417 | s->pts_dts_delta = INT_MIN; | |
73 | 6417 | s->format = -1; | |
74 | |||
75 | 6417 | 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 | 189316 | void ff_fetch_timestamp(AVCodecParserContext *s, int off, int remove, int fuzzy) | |
85 | { | ||
86 | int i; | ||
87 | |||
88 |
2/2✓ Branch 0 taken 188491 times.
✓ Branch 1 taken 825 times.
|
189316 | if (!fuzzy) { |
89 | 188491 | s->dts = | |
90 | 188491 | s->pts = AV_NOPTS_VALUE; | |
91 | 188491 | s->pos = -1; | |
92 | 188491 | s->offset = 0; | |
93 | } | ||
94 |
2/2✓ Branch 0 taken 555363 times.
✓ Branch 1 taken 55729 times.
|
611092 | for (i = 0; i < AV_PARSER_PTS_NB; i++) { |
95 |
2/2✓ Branch 0 taken 546281 times.
✓ Branch 1 taken 9082 times.
|
555363 | if (s->cur_offset + off >= s->cur_frame_offset[i] && |
96 |
2/2✓ Branch 0 taken 359448 times.
✓ Branch 1 taken 186833 times.
|
546281 | (s->frame_offset < s->cur_frame_offset[i] || |
97 |
4/4✓ Branch 0 taken 5437 times.
✓ Branch 1 taken 354011 times.
✓ Branch 2 taken 2012 times.
✓ Branch 3 taken 3425 times.
|
359448 | (!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 187821 times.
✓ Branch 1 taken 1024 times.
|
188845 | /*s->next_frame_offset + off <*/ s->cur_frame_end[i]){ |
100 | |||
101 |
4/4✓ Branch 0 taken 1125 times.
✓ Branch 1 taken 186696 times.
✓ Branch 2 taken 248 times.
✓ Branch 3 taken 877 times.
|
187821 | if (!fuzzy || s->cur_frame_dts[i] != AV_NOPTS_VALUE) { |
102 | 186944 | s->dts = s->cur_frame_dts[i]; | |
103 | 186944 | s->pts = s->cur_frame_pts[i]; | |
104 | 186944 | s->pos = s->cur_frame_pos[i]; | |
105 | 186944 | s->offset = s->next_frame_offset - s->cur_frame_offset[i]; | |
106 | } | ||
107 |
2/2✓ Branch 0 taken 12234 times.
✓ Branch 1 taken 175587 times.
|
187821 | if (remove) |
108 | 12234 | s->cur_frame_offset[i] = INT64_MAX; | |
109 |
2/2✓ Branch 0 taken 133587 times.
✓ Branch 1 taken 54234 times.
|
187821 | if (s->cur_offset + off < s->cur_frame_end[i]) |
110 | 133587 | break; | |
111 | } | ||
112 | } | ||
113 | 189316 | } | |
114 | |||
115 | 799542 | 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 3375 times.
✓ Branch 1 taken 796167 times.
|
799542 | if (!(s->flags & PARSER_FLAG_FETCHED_OFFSET)) { |
135 | 3375 | s->next_frame_offset = | |
136 | 3375 | s->cur_offset = pos; | |
137 | 3375 | s->flags |= PARSER_FLAG_FETCHED_OFFSET; | |
138 | } | ||
139 | |||
140 |
2/2✓ Branch 0 taken 3083 times.
✓ Branch 1 taken 796459 times.
|
799542 | if (buf_size == 0) { |
141 | /* padding is always necessary even if EOF, so we add it here */ | ||
142 | 3083 | memset(dummy_buf, 0, sizeof(dummy_buf)); | |
143 | 3083 | buf = dummy_buf; | |
144 |
2/2✓ Branch 0 taken 683296 times.
✓ Branch 1 taken 113163 times.
|
796459 | } 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 | 683296 | i = (s->cur_frame_start_index + 1) & (AV_PARSER_PTS_NB - 1); | |
147 | 683296 | s->cur_frame_start_index = i; | |
148 | 683296 | s->cur_frame_offset[i] = s->cur_offset; | |
149 | 683296 | s->cur_frame_end[i] = s->cur_offset + buf_size; | |
150 | 683296 | s->cur_frame_pts[i] = pts; | |
151 | 683296 | s->cur_frame_dts[i] = dts; | |
152 | 683296 | s->cur_frame_pos[i] = pos; | |
153 | } | ||
154 | |||
155 |
2/2✓ Branch 0 taken 182345 times.
✓ Branch 1 taken 617197 times.
|
799542 | if (s->fetch_timestamp) { |
156 | 182345 | s->fetch_timestamp = 0; | |
157 | 182345 | s->last_pts = s->pts; | |
158 | 182345 | s->last_dts = s->dts; | |
159 | 182345 | s->last_pos = s->pos; | |
160 | 182345 | ff_fetch_timestamp(s, 0, 0, 0); | |
161 | } | ||
162 | /* WARNING: the returned index can be negative */ | ||
163 | 799542 | 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 799542 times.
|
799542 | 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 606984 times.
✓ Branch 1 taken 192558 times.
|
799542 | if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) { |
168 |
4/4✓ Branch 0 taken 226384 times.
✓ Branch 1 taken 380600 times.
✓ Branch 2 taken 434 times.
✓ Branch 3 taken 225950 times.
|
606984 | FILL(field_order); |
169 |
4/4✓ Branch 0 taken 316457 times.
✓ Branch 1 taken 290527 times.
✓ Branch 2 taken 457 times.
✓ Branch 3 taken 316000 times.
|
606984 | FILL(coded_width); |
170 |
4/4✓ Branch 0 taken 316457 times.
✓ Branch 1 taken 290527 times.
✓ Branch 2 taken 457 times.
✓ Branch 3 taken 316000 times.
|
606984 | FILL(coded_height); |
171 |
4/4✓ Branch 0 taken 317020 times.
✓ Branch 1 taken 289964 times.
✓ Branch 2 taken 462 times.
✓ Branch 3 taken 316558 times.
|
606984 | FILL(width); |
172 |
4/4✓ Branch 0 taken 317020 times.
✓ Branch 1 taken 289964 times.
✓ Branch 2 taken 462 times.
✓ Branch 3 taken 316558 times.
|
606984 | FILL(height); |
173 | } | ||
174 | |||
175 | /* update the file pointer */ | ||
176 |
2/2✓ Branch 0 taken 179938 times.
✓ Branch 1 taken 619604 times.
|
799542 | if (*poutbuf_size) { |
177 | /* fill the data for the current frame */ | ||
178 | 179938 | s->frame_offset = s->next_frame_offset; | |
179 | |||
180 | /* offset of the next frame */ | ||
181 | 179938 | s->next_frame_offset = s->cur_offset + index; | |
182 | 179938 | s->fetch_timestamp = 1; | |
183 | } else { | ||
184 | /* Don't return a pointer to dummy_buf. */ | ||
185 | 619604 | *poutbuf = NULL; | |
186 | } | ||
187 |
2/2✓ Branch 0 taken 4700 times.
✓ Branch 1 taken 794842 times.
|
799542 | if (index < 0) |
188 | 4700 | index = 0; | |
189 | 799542 | s->cur_offset += index; | |
190 | 799542 | return index; | |
191 | } | ||
192 | |||
193 | 17971 | void av_parser_close(AVCodecParserContext *s) | |
194 | { | ||
195 |
2/2✓ Branch 0 taken 6417 times.
✓ Branch 1 taken 11554 times.
|
17971 | if (s) { |
196 |
2/2✓ Branch 0 taken 6082 times.
✓ Branch 1 taken 335 times.
|
6417 | if (s->parser->parser_close) |
197 | 6082 | s->parser->parser_close(s); | |
198 | 6417 | av_freep(&s->priv_data); | |
199 | 6417 | av_free(s); | |
200 | } | ||
201 | 17971 | } | |
202 | |||
203 | 742413 | int ff_combine_frame(ParseContext *pc, int next, | |
204 | const uint8_t **buf, int *buf_size) | ||
205 | { | ||
206 | 742413 | 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 582 times.
✓ Branch 1 taken 742413 times.
|
742995 | for (; pc->overread > 0; pc->overread--) |
215 | 582 | pc->buffer[pc->index++] = pc->buffer[pc->overread_index++]; | |
216 | |||
217 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 742413 times.
|
742413 | if (next > *buf_size) |
218 | ✗ | return AVERROR(EINVAL); | |
219 | |||
220 | /* flush remaining if EOF */ | ||
221 |
4/4✓ Branch 0 taken 2032 times.
✓ Branch 1 taken 740381 times.
✓ Branch 2 taken 1595 times.
✓ Branch 3 taken 437 times.
|
742413 | if (!*buf_size && next == END_NOT_FOUND) |
222 | 1595 | next = 0; | |
223 | |||
224 | 742413 | pc->last_index = pc->index; | |
225 | |||
226 | /* copy into buffer end return */ | ||
227 |
2/2✓ Branch 0 taken 609549 times.
✓ Branch 1 taken 132864 times.
|
742413 | if (next == END_NOT_FOUND) { |
228 | 609549 | void *new_buffer = av_fast_realloc(pc->buffer, &pc->buffer_size, | |
229 | 609549 | *buf_size + pc->index + | |
230 | AV_INPUT_BUFFER_PADDING_SIZE); | ||
231 | |||
232 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 609549 times.
|
609549 | 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 | 609549 | pc->buffer = new_buffer; | |
238 | 609549 | memcpy(&pc->buffer[pc->index], *buf, *buf_size); | |
239 | 609549 | pc->index += *buf_size; | |
240 | 609549 | return -1; | |
241 | } | ||
242 | |||
243 |
3/4✓ Branch 0 taken 238 times.
✓ Branch 1 taken 132626 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 238 times.
|
132864 | av_assert0(next >= 0 || pc->buffer); |
244 | |||
245 | 132864 | *buf_size = | |
246 | 132864 | pc->overread_index = pc->index + next; | |
247 | |||
248 | /* append to buffer */ | ||
249 |
2/2✓ Branch 0 taken 58344 times.
✓ Branch 1 taken 74520 times.
|
132864 | if (pc->index) { |
250 | 58344 | void *new_buffer = av_fast_realloc(pc->buffer, &pc->buffer_size, | |
251 | 58344 | next + pc->index + | |
252 | AV_INPUT_BUFFER_PADDING_SIZE); | ||
253 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 58344 times.
|
58344 | 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 | ✗ | pc->overread_index = | |
256 | ✗ | pc->index = 0; | |
257 | ✗ | return AVERROR(ENOMEM); | |
258 | } | ||
259 | 58344 | pc->buffer = new_buffer; | |
260 |
2/2✓ Branch 0 taken 58340 times.
✓ Branch 1 taken 4 times.
|
58344 | if (next > -AV_INPUT_BUFFER_PADDING_SIZE) |
261 | 58340 | memcpy(&pc->buffer[pc->index], *buf, | |
262 | 58340 | next + AV_INPUT_BUFFER_PADDING_SIZE); | |
263 | 58344 | pc->index = 0; | |
264 | 58344 | *buf = pc->buffer; | |
265 | } | ||
266 | |||
267 |
2/2✓ Branch 0 taken 37 times.
✓ Branch 1 taken 132827 times.
|
132864 | if (next < -8) { |
268 | 37 | pc->overread += -8 - next; | |
269 | 37 | next = -8; | |
270 | } | ||
271 | /* store overread bytes */ | ||
272 |
2/2✓ Branch 0 taken 878 times.
✓ Branch 1 taken 132864 times.
|
133742 | for (; next < 0; next++) { |
273 | 878 | pc->state = pc->state << 8 | pc->buffer[pc->last_index + next]; | |
274 | 878 | pc->state64 = pc->state64 << 8 | pc->buffer[pc->last_index + next]; | |
275 | 878 | pc->overread++; | |
276 | } | ||
277 | |||
278 | 132864 | if (pc->overread) { | |
279 | ff_dlog(NULL, "overread %d, state:%"PRIX32" next:%d index:%d o_index:%d\n", | ||
280 | pc->overread, pc->state, next, pc->index, pc->overread_index); | ||
281 | ff_dlog(NULL, "%X %X %X %X\n", | ||
282 | (*buf)[0], (*buf)[1], (*buf)[2], (*buf)[3]); | ||
283 | } | ||
284 | |||
285 | 132864 | return 0; | |
286 | } | ||
287 | |||
288 | 5082 | void ff_parse_close(AVCodecParserContext *s) | |
289 | { | ||
290 | 5082 | ParseContext *pc = s->priv_data; | |
291 | |||
292 | 5082 | av_freep(&pc->buffer); | |
293 | 5082 | } | |
294 |