Mercurial > libavcodec.hg
annotate parser.c @ 2497:69adfbbdcdeb libavcodec
- samples from mplayer ftp in the "adv" profile seem to have profile=2,
which isn't the advanced one; and indeed, using adv. profile parser fails.
Using normal parser works, and that's what is done
- attempt at taking care of stride for NORM2 bitplane decoding
- duplication of much code from msmpeg4.c; this code isn't yet used, but
goes down as far as the block layer (mainly Transform Type stuff, the
remains are wild editing without checking). Unusable yet, and lacks the AC
decoding (but a step further in bitstream parsing)
patch by anonymous
author | michael |
---|---|
date | Fri, 04 Feb 2005 02:20:38 +0000 |
parents | f2a9559db6ac |
children | e25782262d7d |
rev | line source |
---|---|
1613 | 1 /* |
2 * Audio and Video frame extraction | |
3 * Copyright (c) 2003 Fabrice Bellard. | |
4 * Copyright (c) 2003 Michael Niedermayer. | |
5 * | |
6 * This library is free software; you can redistribute it and/or | |
7 * modify it under the terms of the GNU Lesser General Public | |
8 * License as published by the Free Software Foundation; either | |
9 * version 2 of the License, or (at your option) any later version. | |
10 * | |
11 * This library is distributed in the hope that it will be useful, | |
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
14 * Lesser General Public License for more details. | |
15 * | |
16 * You should have received a copy of the GNU Lesser General Public | |
17 * License along with this library; if not, write to the Free Software | |
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
19 */ | |
20 #include "avcodec.h" | |
21 #include "mpegvideo.h" | |
22 #include "mpegaudio.h" | |
23 | |
24 AVCodecParser *av_first_parser = NULL; | |
25 | |
26 void av_register_codec_parser(AVCodecParser *parser) | |
27 { | |
28 parser->next = av_first_parser; | |
29 av_first_parser = parser; | |
30 } | |
31 | |
32 AVCodecParserContext *av_parser_init(int codec_id) | |
33 { | |
34 AVCodecParserContext *s; | |
35 AVCodecParser *parser; | |
36 int ret; | |
2486
f2a9559db6ac
10l (array gets padded with 0 which is CODEC_ID_NONE -> parsers claim to support CODEC_ID_NONE)
michael
parents:
2480
diff
changeset
|
37 |
f2a9559db6ac
10l (array gets padded with 0 which is CODEC_ID_NONE -> parsers claim to support CODEC_ID_NONE)
michael
parents:
2480
diff
changeset
|
38 if(codec_id == CODEC_ID_NONE) |
f2a9559db6ac
10l (array gets padded with 0 which is CODEC_ID_NONE -> parsers claim to support CODEC_ID_NONE)
michael
parents:
2480
diff
changeset
|
39 return NULL; |
1613 | 40 |
41 for(parser = av_first_parser; parser != NULL; parser = parser->next) { | |
42 if (parser->codec_ids[0] == codec_id || | |
43 parser->codec_ids[1] == codec_id || | |
2348 | 44 parser->codec_ids[2] == codec_id || |
45 parser->codec_ids[3] == codec_id || | |
46 parser->codec_ids[4] == codec_id) | |
1613 | 47 goto found; |
48 } | |
49 return NULL; | |
50 found: | |
51 s = av_mallocz(sizeof(AVCodecParserContext)); | |
52 if (!s) | |
53 return NULL; | |
54 s->parser = parser; | |
55 s->priv_data = av_mallocz(parser->priv_data_size); | |
56 if (!s->priv_data) { | |
57 av_free(s); | |
58 return NULL; | |
59 } | |
60 if (parser->parser_init) { | |
61 ret = parser->parser_init(s); | |
62 if (ret != 0) { | |
63 av_free(s->priv_data); | |
64 av_free(s); | |
65 return NULL; | |
66 } | |
67 } | |
2030 | 68 s->fetch_timestamp=1; |
1613 | 69 return s; |
70 } | |
71 | |
1694
13169235c306
added End Of File handling to return last picture for MPEG1/2/4
bellard
parents:
1681
diff
changeset
|
72 /* NOTE: buf_size == 0 is used to signal EOF so that the last frame |
13169235c306
added End Of File handling to return last picture for MPEG1/2/4
bellard
parents:
1681
diff
changeset
|
73 can be returned if necessary */ |
1613 | 74 int av_parser_parse(AVCodecParserContext *s, |
75 AVCodecContext *avctx, | |
76 uint8_t **poutbuf, int *poutbuf_size, | |
1696 | 77 const uint8_t *buf, int buf_size, |
78 int64_t pts, int64_t dts) | |
1613 | 79 { |
1696 | 80 int index, i, k; |
1694
13169235c306
added End Of File handling to return last picture for MPEG1/2/4
bellard
parents:
1681
diff
changeset
|
81 uint8_t dummy_buf[FF_INPUT_BUFFER_PADDING_SIZE]; |
13169235c306
added End Of File handling to return last picture for MPEG1/2/4
bellard
parents:
1681
diff
changeset
|
82 |
13169235c306
added End Of File handling to return last picture for MPEG1/2/4
bellard
parents:
1681
diff
changeset
|
83 if (buf_size == 0) { |
13169235c306
added End Of File handling to return last picture for MPEG1/2/4
bellard
parents:
1681
diff
changeset
|
84 /* padding is always necessary even if EOF, so we add it here */ |
13169235c306
added End Of File handling to return last picture for MPEG1/2/4
bellard
parents:
1681
diff
changeset
|
85 memset(dummy_buf, 0, sizeof(dummy_buf)); |
13169235c306
added End Of File handling to return last picture for MPEG1/2/4
bellard
parents:
1681
diff
changeset
|
86 buf = dummy_buf; |
1696 | 87 } else { |
88 /* add a new packet descriptor */ | |
89 k = (s->cur_frame_start_index + 1) & (AV_PARSER_PTS_NB - 1); | |
90 s->cur_frame_start_index = k; | |
91 s->cur_frame_offset[k] = s->cur_offset; | |
92 s->cur_frame_pts[k] = pts; | |
93 s->cur_frame_dts[k] = dts; | |
94 | |
95 /* fill first PTS/DTS */ | |
2030 | 96 if (s->fetch_timestamp){ |
97 s->fetch_timestamp=0; | |
1696 | 98 s->last_pts = pts; |
99 s->last_dts = dts; | |
2107 | 100 s->cur_frame_pts[k] = |
101 s->cur_frame_dts[k] = AV_NOPTS_VALUE; | |
1696 | 102 } |
1694
13169235c306
added End Of File handling to return last picture for MPEG1/2/4
bellard
parents:
1681
diff
changeset
|
103 } |
13169235c306
added End Of File handling to return last picture for MPEG1/2/4
bellard
parents:
1681
diff
changeset
|
104 |
1613 | 105 /* WARNING: the returned index can be negative */ |
106 index = s->parser->parser_parse(s, avctx, poutbuf, poutbuf_size, buf, buf_size); | |
2107 | 107 //av_log(NULL, AV_LOG_DEBUG, "parser: in:%lld, %lld, out:%lld, %lld, in:%d out:%d id:%d\n", pts, dts, s->last_pts, s->last_dts, buf_size, *poutbuf_size, avctx->codec_id); |
1613 | 108 /* update the file pointer */ |
109 if (*poutbuf_size) { | |
1696 | 110 /* fill the data for the current frame */ |
1613 | 111 s->frame_offset = s->last_frame_offset; |
1696 | 112 s->pts = s->last_pts; |
113 s->dts = s->last_dts; | |
114 | |
115 /* offset of the next frame */ | |
1613 | 116 s->last_frame_offset = s->cur_offset + index; |
1696 | 117 /* find the packet in which the new frame starts. It |
118 is tricky because of MPEG video start codes | |
119 which can begin in one packet and finish in | |
120 another packet. In the worst case, an MPEG | |
121 video start code could be in 4 different | |
122 packets. */ | |
123 k = s->cur_frame_start_index; | |
124 for(i = 0; i < AV_PARSER_PTS_NB; i++) { | |
125 if (s->last_frame_offset >= s->cur_frame_offset[k]) | |
126 break; | |
127 k = (k - 1) & (AV_PARSER_PTS_NB - 1); | |
128 } | |
2030 | 129 |
1696 | 130 s->last_pts = s->cur_frame_pts[k]; |
131 s->last_dts = s->cur_frame_dts[k]; | |
2030 | 132 |
133 /* some parsers tell us the packet size even before seeing the first byte of the next packet, | |
134 so the next pts/dts is in the next chunk */ | |
135 if(index == buf_size){ | |
136 s->fetch_timestamp=1; | |
137 } | |
1613 | 138 } |
139 if (index < 0) | |
140 index = 0; | |
141 s->cur_offset += index; | |
142 return index; | |
143 } | |
144 | |
145 void av_parser_close(AVCodecParserContext *s) | |
146 { | |
147 if (s->parser->parser_close) | |
148 s->parser->parser_close(s); | |
149 av_free(s->priv_data); | |
150 av_free(s); | |
151 } | |
152 | |
153 /*****************************************************/ | |
154 | |
155 //#define END_NOT_FOUND (-100) | |
156 | |
157 #define PICTURE_START_CODE 0x00000100 | |
158 #define SEQ_START_CODE 0x000001b3 | |
159 #define EXT_START_CODE 0x000001b5 | |
160 #define SLICE_MIN_START_CODE 0x00000101 | |
161 #define SLICE_MAX_START_CODE 0x000001af | |
162 | |
163 typedef struct ParseContext1{ | |
1988 | 164 ParseContext pc; |
165 /* XXX/FIXME PC1 vs. PC */ | |
1613 | 166 /* MPEG2 specific */ |
167 int frame_rate; | |
168 int progressive_sequence; | |
169 int width, height; | |
1614 | 170 |
1613 | 171 /* XXX: suppress that, needed by MPEG4 */ |
172 MpegEncContext *enc; | |
1614 | 173 int first_picture; |
1613 | 174 } ParseContext1; |
175 | |
176 /** | |
177 * combines the (truncated) bitstream to a complete frame | |
178 * @returns -1 if no complete frame could be created | |
179 */ | |
1988 | 180 int ff_combine_frame(ParseContext *pc, int next, uint8_t **buf, int *buf_size) |
1613 | 181 { |
182 #if 0 | |
183 if(pc->overread){ | |
184 printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index); | |
185 printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]); | |
186 } | |
187 #endif | |
188 | |
189 /* copy overreaded bytes from last frame into buffer */ | |
190 for(; pc->overread>0; pc->overread--){ | |
191 pc->buffer[pc->index++]= pc->buffer[pc->overread_index++]; | |
192 } | |
2386 | 193 |
194 /* flush remaining if EOF */ | |
195 if(!*buf_size && next == END_NOT_FOUND){ | |
196 next= 0; | |
197 } | |
198 | |
1613 | 199 pc->last_index= pc->index; |
200 | |
201 /* copy into buffer end return */ | |
202 if(next == END_NOT_FOUND){ | |
203 pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE); | |
204 | |
205 memcpy(&pc->buffer[pc->index], *buf, *buf_size); | |
206 pc->index += *buf_size; | |
207 return -1; | |
208 } | |
209 | |
210 *buf_size= | |
211 pc->overread_index= pc->index + next; | |
212 | |
213 /* append to buffer */ | |
214 if(pc->index){ | |
215 pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE); | |
216 | |
217 memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE ); | |
218 pc->index = 0; | |
219 *buf= pc->buffer; | |
220 } | |
221 | |
222 /* store overread bytes */ | |
223 for(;next < 0; next++){ | |
224 pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next]; | |
225 pc->overread++; | |
226 } | |
227 | |
228 #if 0 | |
229 if(pc->overread){ | |
230 printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index); | |
231 printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]); | |
232 } | |
233 #endif | |
234 | |
235 return 0; | |
236 } | |
237 | |
238 static int find_start_code(const uint8_t **pbuf_ptr, const uint8_t *buf_end) | |
239 { | |
240 const uint8_t *buf_ptr; | |
241 unsigned int state=0xFFFFFFFF, v; | |
242 int val; | |
243 | |
244 buf_ptr = *pbuf_ptr; | |
245 while (buf_ptr < buf_end) { | |
246 v = *buf_ptr++; | |
247 if (state == 0x000001) { | |
248 state = ((state << 8) | v) & 0xffffff; | |
249 val = state; | |
250 goto found; | |
251 } | |
252 state = ((state << 8) | v) & 0xffffff; | |
253 } | |
254 val = -1; | |
255 found: | |
256 *pbuf_ptr = buf_ptr; | |
257 return val; | |
258 } | |
259 | |
260 /* XXX: merge with libavcodec ? */ | |
261 #define MPEG1_FRAME_RATE_BASE 1001 | |
262 | |
263 static const int frame_rate_tab[16] = { | |
264 0, | |
265 24000, | |
266 24024, | |
267 25025, | |
268 30000, | |
269 30030, | |
270 50050, | |
271 60000, | |
272 60060, | |
273 // Xing's 15fps: (9) | |
274 15015, | |
275 // libmpeg3's "Unofficial economy rates": (10-13) | |
276 5005, | |
277 10010, | |
278 12012, | |
279 15015, | |
280 // random, just to avoid segfault !never encode these | |
281 25025, | |
282 25025, | |
283 }; | |
284 | |
285 static void mpegvideo_extract_headers(AVCodecParserContext *s, | |
286 AVCodecContext *avctx, | |
287 const uint8_t *buf, int buf_size) | |
288 { | |
289 ParseContext1 *pc = s->priv_data; | |
290 const uint8_t *buf_end; | |
291 int32_t start_code; | |
292 int frame_rate_index, ext_type, bytes_left; | |
293 int frame_rate_ext_n, frame_rate_ext_d; | |
2119 | 294 int picture_structure, top_field_first, repeat_first_field, progressive_frame; |
1613 | 295 int horiz_size_ext, vert_size_ext; |
296 | |
297 s->repeat_pict = 0; | |
298 buf_end = buf + buf_size; | |
299 while (buf < buf_end) { | |
300 start_code = find_start_code(&buf, buf_end); | |
301 bytes_left = buf_end - buf; | |
302 switch(start_code) { | |
303 case PICTURE_START_CODE: | |
304 if (bytes_left >= 2) { | |
305 s->pict_type = (buf[1] >> 3) & 7; | |
306 } | |
307 break; | |
308 case SEQ_START_CODE: | |
309 if (bytes_left >= 4) { | |
2269 | 310 pc->width = (buf[0] << 4) | (buf[1] >> 4); |
311 pc->height = ((buf[1] & 0x0f) << 8) | buf[2]; | |
2270 | 312 avcodec_set_dimensions(avctx, pc->width, pc->height); |
1613 | 313 frame_rate_index = buf[3] & 0xf; |
314 pc->frame_rate = avctx->frame_rate = frame_rate_tab[frame_rate_index]; | |
315 avctx->frame_rate_base = MPEG1_FRAME_RATE_BASE; | |
1681 | 316 avctx->codec_id = CODEC_ID_MPEG1VIDEO; |
317 avctx->sub_id = 1; | |
1613 | 318 } |
319 break; | |
320 case EXT_START_CODE: | |
321 if (bytes_left >= 1) { | |
322 ext_type = (buf[0] >> 4); | |
323 switch(ext_type) { | |
324 case 0x1: /* sequence extension */ | |
325 if (bytes_left >= 6) { | |
326 horiz_size_ext = ((buf[1] & 1) << 1) | (buf[2] >> 7); | |
327 vert_size_ext = (buf[2] >> 5) & 3; | |
328 frame_rate_ext_n = (buf[5] >> 5) & 3; | |
329 frame_rate_ext_d = (buf[5] & 0x1f); | |
330 pc->progressive_sequence = buf[1] & (1 << 3); | |
2389
429c1eedeee9
fix timestamp prediction for low_delay mpeg streams
michael
parents:
2386
diff
changeset
|
331 avctx->has_b_frames= buf[5] >> 7; |
1613 | 332 |
2269 | 333 pc->width |=(horiz_size_ext << 12); |
334 pc->height |=( vert_size_ext << 12); | |
2270 | 335 avcodec_set_dimensions(avctx, pc->width, pc->height); |
1613 | 336 avctx->frame_rate = pc->frame_rate * (frame_rate_ext_n + 1); |
337 avctx->frame_rate_base = MPEG1_FRAME_RATE_BASE * (frame_rate_ext_d + 1); | |
1681 | 338 avctx->codec_id = CODEC_ID_MPEG2VIDEO; |
1613 | 339 avctx->sub_id = 2; /* forces MPEG2 */ |
340 } | |
341 break; | |
342 case 0x8: /* picture coding extension */ | |
343 if (bytes_left >= 5) { | |
2120 | 344 picture_structure = buf[2]&3; |
1613 | 345 top_field_first = buf[3] & (1 << 7); |
346 repeat_first_field = buf[3] & (1 << 1); | |
347 progressive_frame = buf[4] & (1 << 7); | |
348 | |
349 /* check if we must repeat the frame */ | |
350 if (repeat_first_field) { | |
351 if (pc->progressive_sequence) { | |
352 if (top_field_first) | |
353 s->repeat_pict = 4; | |
354 else | |
355 s->repeat_pict = 2; | |
356 } else if (progressive_frame) { | |
357 s->repeat_pict = 1; | |
358 } | |
359 } | |
2119 | 360 |
361 /* the packet only represents half a frame | |
362 XXX,FIXME maybe find a different solution */ | |
363 if(picture_structure != 3) | |
364 s->repeat_pict = -1; | |
1613 | 365 } |
366 break; | |
367 } | |
368 } | |
369 break; | |
370 case -1: | |
371 goto the_end; | |
372 default: | |
373 /* we stop parsing when we encounter a slice. It ensures | |
374 that this function takes a negligible amount of time */ | |
375 if (start_code >= SLICE_MIN_START_CODE && | |
376 start_code <= SLICE_MAX_START_CODE) | |
377 goto the_end; | |
378 break; | |
379 } | |
380 } | |
381 the_end: ; | |
382 } | |
383 | |
384 static int mpegvideo_parse(AVCodecParserContext *s, | |
385 AVCodecContext *avctx, | |
386 uint8_t **poutbuf, int *poutbuf_size, | |
387 const uint8_t *buf, int buf_size) | |
388 { | |
1988 | 389 ParseContext1 *pc1 = s->priv_data; |
390 ParseContext *pc= &pc1->pc; | |
1613 | 391 int next; |
392 | |
1988 | 393 next= ff_mpeg1_find_frame_end(pc, buf, buf_size); |
1613 | 394 |
1988 | 395 if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) { |
1613 | 396 *poutbuf = NULL; |
397 *poutbuf_size = 0; | |
398 return buf_size; | |
399 } | |
400 /* we have a full frame : we just parse the first few MPEG headers | |
401 to have the full timing information. The time take by this | |
402 function should be negligible for uncorrupted streams */ | |
403 mpegvideo_extract_headers(s, avctx, buf, buf_size); | |
404 #if 0 | |
405 printf("pict_type=%d frame_rate=%0.3f repeat_pict=%d\n", | |
406 s->pict_type, (double)avctx->frame_rate / avctx->frame_rate_base, s->repeat_pict); | |
407 #endif | |
408 | |
409 *poutbuf = (uint8_t *)buf; | |
410 *poutbuf_size = buf_size; | |
411 return next; | |
412 } | |
413 | |
1988 | 414 void ff_parse_close(AVCodecParserContext *s) |
1613 | 415 { |
1988 | 416 ParseContext *pc = s->priv_data; |
1613 | 417 |
418 av_free(pc->buffer); | |
1988 | 419 } |
420 | |
421 static void parse1_close(AVCodecParserContext *s) | |
422 { | |
423 ParseContext1 *pc1 = s->priv_data; | |
424 | |
425 av_free(pc1->pc.buffer); | |
426 av_free(pc1->enc); | |
1613 | 427 } |
428 | |
429 /*************************/ | |
430 | |
431 /* used by parser */ | |
432 /* XXX: make it use less memory */ | |
433 static int av_mpeg4_decode_header(AVCodecParserContext *s1, | |
434 AVCodecContext *avctx, | |
435 const uint8_t *buf, int buf_size) | |
436 { | |
437 ParseContext1 *pc = s1->priv_data; | |
438 MpegEncContext *s = pc->enc; | |
439 GetBitContext gb1, *gb = &gb1; | |
440 int ret; | |
441 | |
442 s->avctx = avctx; | |
1614 | 443 s->current_picture_ptr = &s->current_picture; |
444 | |
445 if (avctx->extradata_size && pc->first_picture){ | |
446 init_get_bits(gb, avctx->extradata, avctx->extradata_size*8); | |
447 ret = ff_mpeg4_decode_picture_header(s, gb); | |
448 } | |
449 | |
1613 | 450 init_get_bits(gb, buf, 8 * buf_size); |
451 ret = ff_mpeg4_decode_picture_header(s, gb); | |
452 if (s->width) { | |
2270 | 453 avcodec_set_dimensions(avctx, s->width, s->height); |
1613 | 454 } |
1614 | 455 pc->first_picture = 0; |
1613 | 456 return ret; |
457 } | |
458 | |
2024
f65d87bfdd5a
some of the warning fixes by (Michael Roitzsch <mroi at users dot sourceforge dot net>)
michael
parents:
1988
diff
changeset
|
459 static int mpeg4video_parse_init(AVCodecParserContext *s) |
1613 | 460 { |
461 ParseContext1 *pc = s->priv_data; | |
1614 | 462 |
1613 | 463 pc->enc = av_mallocz(sizeof(MpegEncContext)); |
464 if (!pc->enc) | |
465 return -1; | |
1614 | 466 pc->first_picture = 1; |
1613 | 467 return 0; |
468 } | |
469 | |
470 static int mpeg4video_parse(AVCodecParserContext *s, | |
471 AVCodecContext *avctx, | |
472 uint8_t **poutbuf, int *poutbuf_size, | |
473 const uint8_t *buf, int buf_size) | |
474 { | |
1988 | 475 ParseContext *pc = s->priv_data; |
1613 | 476 int next; |
477 | |
1988 | 478 next= ff_mpeg4_find_frame_end(pc, buf, buf_size); |
1613 | 479 |
1988 | 480 if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) { |
1613 | 481 *poutbuf = NULL; |
482 *poutbuf_size = 0; | |
483 return buf_size; | |
484 } | |
485 av_mpeg4_decode_header(s, avctx, buf, buf_size); | |
486 | |
487 *poutbuf = (uint8_t *)buf; | |
488 *poutbuf_size = buf_size; | |
489 return next; | |
490 } | |
491 | |
492 /*************************/ | |
493 | |
494 typedef struct MpegAudioParseContext { | |
495 uint8_t inbuf[MPA_MAX_CODED_FRAME_SIZE]; /* input buffer */ | |
496 uint8_t *inbuf_ptr; | |
497 int frame_size; | |
498 int free_format_frame_size; | |
499 int free_format_next_header; | |
2470
06aafb585f69
require a few valid and equal mp3 headers for resync
michael
parents:
2389
diff
changeset
|
500 uint32_t header; |
06aafb585f69
require a few valid and equal mp3 headers for resync
michael
parents:
2389
diff
changeset
|
501 int header_count; |
1613 | 502 } MpegAudioParseContext; |
503 | |
504 #define MPA_HEADER_SIZE 4 | |
505 | |
506 /* header + layer + bitrate + freq + lsf/mpeg25 */ | |
507 #define SAME_HEADER_MASK \ | |
2480 | 508 (0xffe00000 | (3 << 17) | (3 << 10) | (3 << 19)) |
1613 | 509 |
510 static int mpegaudio_parse_init(AVCodecParserContext *s1) | |
511 { | |
512 MpegAudioParseContext *s = s1->priv_data; | |
513 s->inbuf_ptr = s->inbuf; | |
514 return 0; | |
515 } | |
516 | |
517 static int mpegaudio_parse(AVCodecParserContext *s1, | |
518 AVCodecContext *avctx, | |
519 uint8_t **poutbuf, int *poutbuf_size, | |
520 const uint8_t *buf, int buf_size) | |
521 { | |
522 MpegAudioParseContext *s = s1->priv_data; | |
2470
06aafb585f69
require a few valid and equal mp3 headers for resync
michael
parents:
2389
diff
changeset
|
523 int len, ret, sr; |
1613 | 524 uint32_t header; |
525 const uint8_t *buf_ptr; | |
526 | |
527 *poutbuf = NULL; | |
528 *poutbuf_size = 0; | |
529 buf_ptr = buf; | |
530 while (buf_size > 0) { | |
531 len = s->inbuf_ptr - s->inbuf; | |
532 if (s->frame_size == 0) { | |
533 /* special case for next header for first frame in free | |
534 format case (XXX: find a simpler method) */ | |
535 if (s->free_format_next_header != 0) { | |
536 s->inbuf[0] = s->free_format_next_header >> 24; | |
537 s->inbuf[1] = s->free_format_next_header >> 16; | |
538 s->inbuf[2] = s->free_format_next_header >> 8; | |
539 s->inbuf[3] = s->free_format_next_header; | |
540 s->inbuf_ptr = s->inbuf + 4; | |
541 s->free_format_next_header = 0; | |
542 goto got_header; | |
543 } | |
544 /* no header seen : find one. We need at least MPA_HEADER_SIZE | |
545 bytes to parse it */ | |
546 len = MPA_HEADER_SIZE - len; | |
547 if (len > buf_size) | |
548 len = buf_size; | |
549 if (len > 0) { | |
550 memcpy(s->inbuf_ptr, buf_ptr, len); | |
551 buf_ptr += len; | |
552 buf_size -= len; | |
553 s->inbuf_ptr += len; | |
554 } | |
555 if ((s->inbuf_ptr - s->inbuf) >= MPA_HEADER_SIZE) { | |
556 got_header: | |
2470
06aafb585f69
require a few valid and equal mp3 headers for resync
michael
parents:
2389
diff
changeset
|
557 sr= avctx->sample_rate; |
1613 | 558 header = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) | |
559 (s->inbuf[2] << 8) | s->inbuf[3]; | |
560 | |
561 ret = mpa_decode_header(avctx, header); | |
562 if (ret < 0) { | |
2470
06aafb585f69
require a few valid and equal mp3 headers for resync
michael
parents:
2389
diff
changeset
|
563 s->header_count= -2; |
1613 | 564 /* no sync found : move by one byte (inefficient, but simple!) */ |
565 memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1); | |
566 s->inbuf_ptr--; | |
567 dprintf("skip %x\n", header); | |
568 /* reset free format frame size to give a chance | |
569 to get a new bitrate */ | |
570 s->free_format_frame_size = 0; | |
571 } else { | |
2470
06aafb585f69
require a few valid and equal mp3 headers for resync
michael
parents:
2389
diff
changeset
|
572 if((header&SAME_HEADER_MASK) != (s->header&SAME_HEADER_MASK) && s->header) |
06aafb585f69
require a few valid and equal mp3 headers for resync
michael
parents:
2389
diff
changeset
|
573 s->header_count= -3; |
06aafb585f69
require a few valid and equal mp3 headers for resync
michael
parents:
2389
diff
changeset
|
574 s->header= header; |
06aafb585f69
require a few valid and equal mp3 headers for resync
michael
parents:
2389
diff
changeset
|
575 s->header_count++; |
1613 | 576 s->frame_size = ret; |
2470
06aafb585f69
require a few valid and equal mp3 headers for resync
michael
parents:
2389
diff
changeset
|
577 |
1613 | 578 #if 0 |
579 /* free format: prepare to compute frame size */ | |
580 if (decode_header(s, header) == 1) { | |
581 s->frame_size = -1; | |
582 } | |
583 #endif | |
584 } | |
2470
06aafb585f69
require a few valid and equal mp3 headers for resync
michael
parents:
2389
diff
changeset
|
585 if(s->header_count <= 0) |
06aafb585f69
require a few valid and equal mp3 headers for resync
michael
parents:
2389
diff
changeset
|
586 avctx->sample_rate= sr; //FIXME ugly |
1613 | 587 } |
588 } else | |
589 #if 0 | |
590 if (s->frame_size == -1) { | |
591 /* free format : find next sync to compute frame size */ | |
592 len = MPA_MAX_CODED_FRAME_SIZE - len; | |
593 if (len > buf_size) | |
594 len = buf_size; | |
595 if (len == 0) { | |
596 /* frame too long: resync */ | |
597 s->frame_size = 0; | |
598 memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1); | |
599 s->inbuf_ptr--; | |
600 } else { | |
601 uint8_t *p, *pend; | |
602 uint32_t header1; | |
603 int padding; | |
604 | |
605 memcpy(s->inbuf_ptr, buf_ptr, len); | |
606 /* check for header */ | |
607 p = s->inbuf_ptr - 3; | |
608 pend = s->inbuf_ptr + len - 4; | |
609 while (p <= pend) { | |
610 header = (p[0] << 24) | (p[1] << 16) | | |
611 (p[2] << 8) | p[3]; | |
612 header1 = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) | | |
613 (s->inbuf[2] << 8) | s->inbuf[3]; | |
614 /* check with high probability that we have a | |
615 valid header */ | |
616 if ((header & SAME_HEADER_MASK) == | |
617 (header1 & SAME_HEADER_MASK)) { | |
618 /* header found: update pointers */ | |
619 len = (p + 4) - s->inbuf_ptr; | |
620 buf_ptr += len; | |
621 buf_size -= len; | |
622 s->inbuf_ptr = p; | |
623 /* compute frame size */ | |
624 s->free_format_next_header = header; | |
625 s->free_format_frame_size = s->inbuf_ptr - s->inbuf; | |
626 padding = (header1 >> 9) & 1; | |
627 if (s->layer == 1) | |
628 s->free_format_frame_size -= padding * 4; | |
629 else | |
630 s->free_format_frame_size -= padding; | |
631 dprintf("free frame size=%d padding=%d\n", | |
632 s->free_format_frame_size, padding); | |
633 decode_header(s, header1); | |
634 goto next_data; | |
635 } | |
636 p++; | |
637 } | |
638 /* not found: simply increase pointers */ | |
639 buf_ptr += len; | |
640 s->inbuf_ptr += len; | |
641 buf_size -= len; | |
642 } | |
643 } else | |
644 #endif | |
645 if (len < s->frame_size) { | |
646 if (s->frame_size > MPA_MAX_CODED_FRAME_SIZE) | |
647 s->frame_size = MPA_MAX_CODED_FRAME_SIZE; | |
648 len = s->frame_size - len; | |
649 if (len > buf_size) | |
650 len = buf_size; | |
651 memcpy(s->inbuf_ptr, buf_ptr, len); | |
652 buf_ptr += len; | |
653 s->inbuf_ptr += len; | |
654 buf_size -= len; | |
655 } | |
656 // next_data: | |
657 if (s->frame_size > 0 && | |
658 (s->inbuf_ptr - s->inbuf) >= s->frame_size) { | |
2470
06aafb585f69
require a few valid and equal mp3 headers for resync
michael
parents:
2389
diff
changeset
|
659 if(s->header_count > 0){ |
06aafb585f69
require a few valid and equal mp3 headers for resync
michael
parents:
2389
diff
changeset
|
660 *poutbuf = s->inbuf; |
06aafb585f69
require a few valid and equal mp3 headers for resync
michael
parents:
2389
diff
changeset
|
661 *poutbuf_size = s->inbuf_ptr - s->inbuf; |
06aafb585f69
require a few valid and equal mp3 headers for resync
michael
parents:
2389
diff
changeset
|
662 } |
1613 | 663 s->inbuf_ptr = s->inbuf; |
664 s->frame_size = 0; | |
665 break; | |
666 } | |
667 } | |
668 return buf_ptr - buf; | |
669 } | |
670 | |
671 #ifdef CONFIG_AC3 | |
672 extern int a52_syncinfo (const uint8_t * buf, int * flags, | |
673 int * sample_rate, int * bit_rate); | |
674 | |
675 typedef struct AC3ParseContext { | |
676 uint8_t inbuf[4096]; /* input buffer */ | |
677 uint8_t *inbuf_ptr; | |
678 int frame_size; | |
679 int flags; | |
680 } AC3ParseContext; | |
681 | |
682 #define AC3_HEADER_SIZE 7 | |
683 #define A52_LFE 16 | |
684 | |
685 static int ac3_parse_init(AVCodecParserContext *s1) | |
686 { | |
687 AC3ParseContext *s = s1->priv_data; | |
688 s->inbuf_ptr = s->inbuf; | |
689 return 0; | |
690 } | |
691 | |
692 static int ac3_parse(AVCodecParserContext *s1, | |
693 AVCodecContext *avctx, | |
694 uint8_t **poutbuf, int *poutbuf_size, | |
695 const uint8_t *buf, int buf_size) | |
696 { | |
697 AC3ParseContext *s = s1->priv_data; | |
698 const uint8_t *buf_ptr; | |
699 int len, sample_rate, bit_rate; | |
700 static const int ac3_channels[8] = { | |
701 2, 1, 2, 3, 3, 4, 4, 5 | |
702 }; | |
703 | |
704 *poutbuf = NULL; | |
705 *poutbuf_size = 0; | |
706 | |
707 buf_ptr = buf; | |
708 while (buf_size > 0) { | |
709 len = s->inbuf_ptr - s->inbuf; | |
710 if (s->frame_size == 0) { | |
711 /* no header seen : find one. We need at least 7 bytes to parse it */ | |
712 len = AC3_HEADER_SIZE - len; | |
713 if (len > buf_size) | |
714 len = buf_size; | |
715 memcpy(s->inbuf_ptr, buf_ptr, len); | |
716 buf_ptr += len; | |
717 s->inbuf_ptr += len; | |
718 buf_size -= len; | |
719 if ((s->inbuf_ptr - s->inbuf) == AC3_HEADER_SIZE) { | |
720 len = a52_syncinfo(s->inbuf, &s->flags, &sample_rate, &bit_rate); | |
721 if (len == 0) { | |
722 /* no sync found : move by one byte (inefficient, but simple!) */ | |
723 memmove(s->inbuf, s->inbuf + 1, AC3_HEADER_SIZE - 1); | |
724 s->inbuf_ptr--; | |
725 } else { | |
726 s->frame_size = len; | |
727 /* update codec info */ | |
728 avctx->sample_rate = sample_rate; | |
1987 | 729 /* set channels,except if the user explicitly requests 1 or 2 channels, XXX/FIXME this is a bit ugly */ |
730 if(avctx->channels!=1 && avctx->channels!=2){ | |
731 avctx->channels = ac3_channels[s->flags & 7]; | |
732 if (s->flags & A52_LFE) | |
733 avctx->channels++; | |
734 } | |
1613 | 735 avctx->bit_rate = bit_rate; |
736 avctx->frame_size = 6 * 256; | |
737 } | |
738 } | |
739 } else if (len < s->frame_size) { | |
740 len = s->frame_size - len; | |
741 if (len > buf_size) | |
742 len = buf_size; | |
743 | |
744 memcpy(s->inbuf_ptr, buf_ptr, len); | |
745 buf_ptr += len; | |
746 s->inbuf_ptr += len; | |
747 buf_size -= len; | |
748 } else { | |
749 *poutbuf = s->inbuf; | |
750 *poutbuf_size = s->frame_size; | |
751 s->inbuf_ptr = s->inbuf; | |
752 s->frame_size = 0; | |
753 break; | |
754 } | |
755 } | |
756 return buf_ptr - buf; | |
757 } | |
758 #endif | |
759 | |
760 AVCodecParser mpegvideo_parser = { | |
761 { CODEC_ID_MPEG1VIDEO, CODEC_ID_MPEG2VIDEO }, | |
762 sizeof(ParseContext1), | |
763 NULL, | |
764 mpegvideo_parse, | |
1988 | 765 parse1_close, |
1613 | 766 }; |
767 | |
768 AVCodecParser mpeg4video_parser = { | |
769 { CODEC_ID_MPEG4 }, | |
770 sizeof(ParseContext1), | |
771 mpeg4video_parse_init, | |
772 mpeg4video_parse, | |
1988 | 773 parse1_close, |
1613 | 774 }; |
775 | |
776 AVCodecParser mpegaudio_parser = { | |
777 { CODEC_ID_MP2, CODEC_ID_MP3 }, | |
778 sizeof(MpegAudioParseContext), | |
779 mpegaudio_parse_init, | |
780 mpegaudio_parse, | |
781 NULL, | |
782 }; | |
783 | |
784 #ifdef CONFIG_AC3 | |
785 AVCodecParser ac3_parser = { | |
786 { CODEC_ID_AC3 }, | |
787 sizeof(AC3ParseContext), | |
788 ac3_parse_init, | |
789 ac3_parse, | |
790 NULL, | |
791 }; | |
792 #endif |