412cd835948fc50c732ff3069cfbd34ff9cb7f2f
[libav.git] / libavcodec / parser.c
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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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;
37
38 if(codec_id == CODEC_ID_NONE)
39 return NULL;
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 ||
44 parser->codec_ids[2] == codec_id ||
45 parser->codec_ids[3] == codec_id ||
46 parser->codec_ids[4] == codec_id)
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 }
68 s->fetch_timestamp=1;
69 return s;
70 }
71
72 /* NOTE: buf_size == 0 is used to signal EOF so that the last frame
73 can be returned if necessary */
74 int av_parser_parse(AVCodecParserContext *s,
75 AVCodecContext *avctx,
76 uint8_t **poutbuf, int *poutbuf_size,
77 const uint8_t *buf, int buf_size,
78 int64_t pts, int64_t dts)
79 {
80 int index, i, k;
81 uint8_t dummy_buf[FF_INPUT_BUFFER_PADDING_SIZE];
82
83 if (buf_size == 0) {
84 /* padding is always necessary even if EOF, so we add it here */
85 memset(dummy_buf, 0, sizeof(dummy_buf));
86 buf = dummy_buf;
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 */
96 if (s->fetch_timestamp){
97 s->fetch_timestamp=0;
98 s->last_pts = pts;
99 s->last_dts = dts;
100 s->cur_frame_pts[k] =
101 s->cur_frame_dts[k] = AV_NOPTS_VALUE;
102 }
103 }
104
105 /* WARNING: the returned index can be negative */
106 index = s->parser->parser_parse(s, avctx, poutbuf, poutbuf_size, buf, buf_size);
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);
108 /* update the file pointer */
109 if (*poutbuf_size) {
110 /* fill the data for the current frame */
111 s->frame_offset = s->last_frame_offset;
112 s->pts = s->last_pts;
113 s->dts = s->last_dts;
114
115 /* offset of the next frame */
116 s->last_frame_offset = s->cur_offset + index;
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 }
129
130 s->last_pts = s->cur_frame_pts[k];
131 s->last_dts = s->cur_frame_dts[k];
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 }
138 }
139 if (index < 0)
140 index = 0;
141 s->cur_offset += index;
142 return index;
143 }
144
145 /**
146 *
147 * @return 0 if the output buffer is a subset of the input, 1 if it is allocated and must be freed
148 */
149 int av_parser_change(AVCodecParserContext *s,
150 AVCodecContext *avctx,
151 uint8_t **poutbuf, int *poutbuf_size,
152 const uint8_t *buf, int buf_size, int keyframe){
153
154 if(s && s->parser->split){
155 if((avctx->flags & CODEC_FLAG_GLOBAL_HEADER) || (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER)){
156 int i= s->parser->split(avctx, buf, buf_size);
157 buf += i;
158 buf_size -= i;
159 }
160 }
161
162 /* cast to avoid warning about discarding qualifiers */
163 *poutbuf= (uint8_t *) buf;
164 *poutbuf_size= buf_size;
165 if(avctx->extradata){
166 if( (keyframe && (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER))
167 /*||(s->pict_type != I_TYPE && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_NOKEY))*/
168 /*||(? && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_BEGIN)*/){
169 int size= buf_size + avctx->extradata_size;
170 *poutbuf_size= size;
171 *poutbuf= av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
172
173 memcpy(*poutbuf, avctx->extradata, avctx->extradata_size);
174 memcpy((*poutbuf) + avctx->extradata_size, buf, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
175 return 1;
176 }
177 }
178
179 return 0;
180 }
181
182 void av_parser_close(AVCodecParserContext *s)
183 {
184 if (s->parser->parser_close)
185 s->parser->parser_close(s);
186 av_free(s->priv_data);
187 av_free(s);
188 }
189
190 /*****************************************************/
191
192 //#define END_NOT_FOUND (-100)
193
194 #define PICTURE_START_CODE 0x00000100
195 #define SEQ_START_CODE 0x000001b3
196 #define EXT_START_CODE 0x000001b5
197 #define SLICE_MIN_START_CODE 0x00000101
198 #define SLICE_MAX_START_CODE 0x000001af
199
200 typedef struct ParseContext1{
201 ParseContext pc;
202 /* XXX/FIXME PC1 vs. PC */
203 /* MPEG2 specific */
204 int frame_rate;
205 int progressive_sequence;
206 int width, height;
207
208 /* XXX: suppress that, needed by MPEG4 */
209 MpegEncContext *enc;
210 int first_picture;
211 } ParseContext1;
212
213 /**
214 * combines the (truncated) bitstream to a complete frame
215 * @returns -1 if no complete frame could be created
216 */
217 int ff_combine_frame(ParseContext *pc, int next, uint8_t **buf, int *buf_size)
218 {
219 #if 0
220 if(pc->overread){
221 printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
222 printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
223 }
224 #endif
225
226 /* copy overreaded bytes from last frame into buffer */
227 for(; pc->overread>0; pc->overread--){
228 pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
229 }
230
231 /* flush remaining if EOF */
232 if(!*buf_size && next == END_NOT_FOUND){
233 next= 0;
234 }
235
236 pc->last_index= pc->index;
237
238 /* copy into buffer end return */
239 if(next == END_NOT_FOUND){
240 pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
241
242 memcpy(&pc->buffer[pc->index], *buf, *buf_size);
243 pc->index += *buf_size;
244 return -1;
245 }
246
247 *buf_size=
248 pc->overread_index= pc->index + next;
249
250 /* append to buffer */
251 if(pc->index){
252 pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
253
254 memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
255 pc->index = 0;
256 *buf= pc->buffer;
257 }
258
259 /* store overread bytes */
260 for(;next < 0; next++){
261 pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
262 pc->overread++;
263 }
264
265 #if 0
266 if(pc->overread){
267 printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
268 printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
269 }
270 #endif
271
272 return 0;
273 }
274
275 /* XXX: merge with libavcodec ? */
276 #define MPEG1_FRAME_RATE_BASE 1001
277
278 static const int frame_rate_tab[16] = {
279 0,
280 24000,
281 24024,
282 25025,
283 30000,
284 30030,
285 50050,
286 60000,
287 60060,
288 // Xing's 15fps: (9)
289 15015,
290 // libmpeg3's "Unofficial economy rates": (10-13)
291 5005,
292 10010,
293 12012,
294 15015,
295 // random, just to avoid segfault !never encode these
296 25025,
297 25025,
298 };
299
300 //FIXME move into mpeg12.c
301 static void mpegvideo_extract_headers(AVCodecParserContext *s,
302 AVCodecContext *avctx,
303 const uint8_t *buf, int buf_size)
304 {
305 ParseContext1 *pc = s->priv_data;
306 const uint8_t *buf_end;
307 int32_t start_code;
308 int frame_rate_index, ext_type, bytes_left;
309 int frame_rate_ext_n, frame_rate_ext_d;
310 int picture_structure, top_field_first, repeat_first_field, progressive_frame;
311 int horiz_size_ext, vert_size_ext, bit_rate_ext;
312 //FIXME replace the crap with get_bits()
313 s->repeat_pict = 0;
314 buf_end = buf + buf_size;
315 while (buf < buf_end) {
316 start_code= -1;
317 buf= ff_find_start_code(buf, buf_end, &start_code);
318 bytes_left = buf_end - buf;
319 switch(start_code) {
320 case PICTURE_START_CODE:
321 if (bytes_left >= 2) {
322 s->pict_type = (buf[1] >> 3) & 7;
323 }
324 break;
325 case SEQ_START_CODE:
326 if (bytes_left >= 7) {
327 pc->width = (buf[0] << 4) | (buf[1] >> 4);
328 pc->height = ((buf[1] & 0x0f) << 8) | buf[2];
329 avcodec_set_dimensions(avctx, pc->width, pc->height);
330 frame_rate_index = buf[3] & 0xf;
331 pc->frame_rate = avctx->time_base.den = frame_rate_tab[frame_rate_index];
332 avctx->time_base.num = MPEG1_FRAME_RATE_BASE;
333 avctx->bit_rate = ((buf[4]<<10) | (buf[5]<<2) | (buf[6]>>6))*400;
334 avctx->codec_id = CODEC_ID_MPEG1VIDEO;
335 avctx->sub_id = 1;
336 }
337 break;
338 case EXT_START_CODE:
339 if (bytes_left >= 1) {
340 ext_type = (buf[0] >> 4);
341 switch(ext_type) {
342 case 0x1: /* sequence extension */
343 if (bytes_left >= 6) {
344 horiz_size_ext = ((buf[1] & 1) << 1) | (buf[2] >> 7);
345 vert_size_ext = (buf[2] >> 5) & 3;
346 bit_rate_ext = ((buf[2] & 0x1F)<<7) | (buf[3]>>1);
347 frame_rate_ext_n = (buf[5] >> 5) & 3;
348 frame_rate_ext_d = (buf[5] & 0x1f);
349 pc->progressive_sequence = buf[1] & (1 << 3);
350 avctx->has_b_frames= !(buf[5] >> 7);
351
352 pc->width |=(horiz_size_ext << 12);
353 pc->height |=( vert_size_ext << 12);
354 avctx->bit_rate += (bit_rate_ext << 18) * 400;
355 avcodec_set_dimensions(avctx, pc->width, pc->height);
356 avctx->time_base.den = pc->frame_rate * (frame_rate_ext_n + 1);
357 avctx->time_base.num = MPEG1_FRAME_RATE_BASE * (frame_rate_ext_d + 1);
358 avctx->codec_id = CODEC_ID_MPEG2VIDEO;
359 avctx->sub_id = 2; /* forces MPEG2 */
360 }
361 break;
362 case 0x8: /* picture coding extension */
363 if (bytes_left >= 5) {
364 picture_structure = buf[2]&3;
365 top_field_first = buf[3] & (1 << 7);
366 repeat_first_field = buf[3] & (1 << 1);
367 progressive_frame = buf[4] & (1 << 7);
368
369 /* check if we must repeat the frame */
370 if (repeat_first_field) {
371 if (pc->progressive_sequence) {
372 if (top_field_first)
373 s->repeat_pict = 4;
374 else
375 s->repeat_pict = 2;
376 } else if (progressive_frame) {
377 s->repeat_pict = 1;
378 }
379 }
380
381 /* the packet only represents half a frame
382 XXX,FIXME maybe find a different solution */
383 if(picture_structure != 3)
384 s->repeat_pict = -1;
385 }
386 break;
387 }
388 }
389 break;
390 case -1:
391 goto the_end;
392 default:
393 /* we stop parsing when we encounter a slice. It ensures
394 that this function takes a negligible amount of time */
395 if (start_code >= SLICE_MIN_START_CODE &&
396 start_code <= SLICE_MAX_START_CODE)
397 goto the_end;
398 break;
399 }
400 }
401 the_end: ;
402 }
403
404 static int mpegvideo_parse(AVCodecParserContext *s,
405 AVCodecContext *avctx,
406 uint8_t **poutbuf, int *poutbuf_size,
407 const uint8_t *buf, int buf_size)
408 {
409 ParseContext1 *pc1 = s->priv_data;
410 ParseContext *pc= &pc1->pc;
411 int next;
412
413 if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
414 next= buf_size;
415 }else{
416 next= ff_mpeg1_find_frame_end(pc, buf, buf_size);
417
418 if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
419 *poutbuf = NULL;
420 *poutbuf_size = 0;
421 return buf_size;
422 }
423
424 }
425 /* we have a full frame : we just parse the first few MPEG headers
426 to have the full timing information. The time take by this
427 function should be negligible for uncorrupted streams */
428 mpegvideo_extract_headers(s, avctx, buf, buf_size);
429 #if 0
430 printf("pict_type=%d frame_rate=%0.3f repeat_pict=%d\n",
431 s->pict_type, (double)avctx->time_base.den / avctx->time_base.num, s->repeat_pict);
432 #endif
433
434 *poutbuf = (uint8_t *)buf;
435 *poutbuf_size = buf_size;
436 return next;
437 }
438
439 static int mpegvideo_split(AVCodecContext *avctx,
440 const uint8_t *buf, int buf_size)
441 {
442 int i;
443 uint32_t state= -1;
444
445 for(i=0; i<buf_size; i++){
446 state= (state<<8) | buf[i];
447 if(state != 0x1B3 && state != 0x1B5 && state < 0x200 && state >= 0x100)
448 return i-3;
449 }
450 return 0;
451 }
452
453 void ff_parse_close(AVCodecParserContext *s)
454 {
455 ParseContext *pc = s->priv_data;
456
457 av_free(pc->buffer);
458 }
459
460 static void parse1_close(AVCodecParserContext *s)
461 {
462 ParseContext1 *pc1 = s->priv_data;
463
464 av_free(pc1->pc.buffer);
465 av_free(pc1->enc);
466 }
467
468 /*************************/
469
470 /* used by parser */
471 /* XXX: make it use less memory */
472 static int av_mpeg4_decode_header(AVCodecParserContext *s1,
473 AVCodecContext *avctx,
474 const uint8_t *buf, int buf_size)
475 {
476 ParseContext1 *pc = s1->priv_data;
477 MpegEncContext *s = pc->enc;
478 GetBitContext gb1, *gb = &gb1;
479 int ret;
480
481 s->avctx = avctx;
482 s->current_picture_ptr = &s->current_picture;
483
484 if (avctx->extradata_size && pc->first_picture){
485 init_get_bits(gb, avctx->extradata, avctx->extradata_size*8);
486 ret = ff_mpeg4_decode_picture_header(s, gb);
487 }
488
489 init_get_bits(gb, buf, 8 * buf_size);
490 ret = ff_mpeg4_decode_picture_header(s, gb);
491 if (s->width) {
492 avcodec_set_dimensions(avctx, s->width, s->height);
493 }
494 s1->pict_type= s->pict_type;
495 pc->first_picture = 0;
496 return ret;
497 }
498
499 static int mpeg4video_parse_init(AVCodecParserContext *s)
500 {
501 ParseContext1 *pc = s->priv_data;
502
503 pc->enc = av_mallocz(sizeof(MpegEncContext));
504 if (!pc->enc)
505 return -1;
506 pc->first_picture = 1;
507 return 0;
508 }
509
510 static int mpeg4video_parse(AVCodecParserContext *s,
511 AVCodecContext *avctx,
512 uint8_t **poutbuf, int *poutbuf_size,
513 const uint8_t *buf, int buf_size)
514 {
515 ParseContext *pc = s->priv_data;
516 int next;
517
518 if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
519 next= buf_size;
520 }else{
521 next= ff_mpeg4_find_frame_end(pc, buf, buf_size);
522
523 if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
524 *poutbuf = NULL;
525 *poutbuf_size = 0;
526 return buf_size;
527 }
528 }
529 av_mpeg4_decode_header(s, avctx, buf, buf_size);
530
531 *poutbuf = (uint8_t *)buf;
532 *poutbuf_size = buf_size;
533 return next;
534 }
535
536 static int mpeg4video_split(AVCodecContext *avctx,
537 const uint8_t *buf, int buf_size)
538 {
539 int i;
540 uint32_t state= -1;
541
542 for(i=0; i<buf_size; i++){
543 state= (state<<8) | buf[i];
544 if(state == 0x1B3 || state == 0x1B6)
545 return i-3;
546 }
547 return 0;
548 }
549
550 /*************************/
551
552 typedef struct MpegAudioParseContext {
553 uint8_t inbuf[MPA_MAX_CODED_FRAME_SIZE]; /* input buffer */
554 uint8_t *inbuf_ptr;
555 int frame_size;
556 int free_format_frame_size;
557 int free_format_next_header;
558 uint32_t header;
559 int header_count;
560 } MpegAudioParseContext;
561
562 #define MPA_HEADER_SIZE 4
563
564 /* header + layer + bitrate + freq + lsf/mpeg25 */
565 #undef SAME_HEADER_MASK /* mpegaudio.h defines different version */
566 #define SAME_HEADER_MASK \
567 (0xffe00000 | (3 << 17) | (3 << 10) | (3 << 19))
568
569 static int mpegaudio_parse_init(AVCodecParserContext *s1)
570 {
571 MpegAudioParseContext *s = s1->priv_data;
572 s->inbuf_ptr = s->inbuf;
573 return 0;
574 }
575
576 static int mpegaudio_parse(AVCodecParserContext *s1,
577 AVCodecContext *avctx,
578 uint8_t **poutbuf, int *poutbuf_size,
579 const uint8_t *buf, int buf_size)
580 {
581 MpegAudioParseContext *s = s1->priv_data;
582 int len, ret, sr;
583 uint32_t header;
584 const uint8_t *buf_ptr;
585
586 *poutbuf = NULL;
587 *poutbuf_size = 0;
588 buf_ptr = buf;
589 while (buf_size > 0) {
590 len = s->inbuf_ptr - s->inbuf;
591 if (s->frame_size == 0) {
592 /* special case for next header for first frame in free
593 format case (XXX: find a simpler method) */
594 if (s->free_format_next_header != 0) {
595 s->inbuf[0] = s->free_format_next_header >> 24;
596 s->inbuf[1] = s->free_format_next_header >> 16;
597 s->inbuf[2] = s->free_format_next_header >> 8;
598 s->inbuf[3] = s->free_format_next_header;
599 s->inbuf_ptr = s->inbuf + 4;
600 s->free_format_next_header = 0;
601 goto got_header;
602 }
603 /* no header seen : find one. We need at least MPA_HEADER_SIZE
604 bytes to parse it */
605 len = MPA_HEADER_SIZE - len;
606 if (len > buf_size)
607 len = buf_size;
608 if (len > 0) {
609 memcpy(s->inbuf_ptr, buf_ptr, len);
610 buf_ptr += len;
611 buf_size -= len;
612 s->inbuf_ptr += len;
613 }
614 if ((s->inbuf_ptr - s->inbuf) >= MPA_HEADER_SIZE) {
615 got_header:
616 sr= avctx->sample_rate;
617 header = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
618 (s->inbuf[2] << 8) | s->inbuf[3];
619
620 ret = mpa_decode_header(avctx, header);
621 if (ret < 0) {
622 s->header_count= -2;
623 /* no sync found : move by one byte (inefficient, but simple!) */
624 memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
625 s->inbuf_ptr--;
626 dprintf("skip %x\n", header);
627 /* reset free format frame size to give a chance
628 to get a new bitrate */
629 s->free_format_frame_size = 0;
630 } else {
631 if((header&SAME_HEADER_MASK) != (s->header&SAME_HEADER_MASK) && s->header)
632 s->header_count= -3;
633 s->header= header;
634 s->header_count++;
635 s->frame_size = ret;
636
637 #if 0
638 /* free format: prepare to compute frame size */
639 if (decode_header(s, header) == 1) {
640 s->frame_size = -1;
641 }
642 #endif
643 }
644 if(s->header_count <= 0)
645 avctx->sample_rate= sr; //FIXME ugly
646 }
647 } else
648 #if 0
649 if (s->frame_size == -1) {
650 /* free format : find next sync to compute frame size */
651 len = MPA_MAX_CODED_FRAME_SIZE - len;
652 if (len > buf_size)
653 len = buf_size;
654 if (len == 0) {
655 /* frame too long: resync */
656 s->frame_size = 0;
657 memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
658 s->inbuf_ptr--;
659 } else {
660 uint8_t *p, *pend;
661 uint32_t header1;
662 int padding;
663
664 memcpy(s->inbuf_ptr, buf_ptr, len);
665 /* check for header */
666 p = s->inbuf_ptr - 3;
667 pend = s->inbuf_ptr + len - 4;
668 while (p <= pend) {
669 header = (p[0] << 24) | (p[1] << 16) |
670 (p[2] << 8) | p[3];
671 header1 = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
672 (s->inbuf[2] << 8) | s->inbuf[3];
673 /* check with high probability that we have a
674 valid header */
675 if ((header & SAME_HEADER_MASK) ==
676 (header1 & SAME_HEADER_MASK)) {
677 /* header found: update pointers */
678 len = (p + 4) - s->inbuf_ptr;
679 buf_ptr += len;
680 buf_size -= len;
681 s->inbuf_ptr = p;
682 /* compute frame size */
683 s->free_format_next_header = header;
684 s->free_format_frame_size = s->inbuf_ptr - s->inbuf;
685 padding = (header1 >> 9) & 1;
686 if (s->layer == 1)
687 s->free_format_frame_size -= padding * 4;
688 else
689 s->free_format_frame_size -= padding;
690 dprintf("free frame size=%d padding=%d\n",
691 s->free_format_frame_size, padding);
692 decode_header(s, header1);
693 goto next_data;
694 }
695 p++;
696 }
697 /* not found: simply increase pointers */
698 buf_ptr += len;
699 s->inbuf_ptr += len;
700 buf_size -= len;
701 }
702 } else
703 #endif
704 if (len < s->frame_size) {
705 if (s->frame_size > MPA_MAX_CODED_FRAME_SIZE)
706 s->frame_size = MPA_MAX_CODED_FRAME_SIZE;
707 len = s->frame_size - len;
708 if (len > buf_size)
709 len = buf_size;
710 memcpy(s->inbuf_ptr, buf_ptr, len);
711 buf_ptr += len;
712 s->inbuf_ptr += len;
713 buf_size -= len;
714 }
715 // next_data:
716 if (s->frame_size > 0 &&
717 (s->inbuf_ptr - s->inbuf) >= s->frame_size) {
718 if(s->header_count > 0){
719 *poutbuf = s->inbuf;
720 *poutbuf_size = s->inbuf_ptr - s->inbuf;
721 }
722 s->inbuf_ptr = s->inbuf;
723 s->frame_size = 0;
724 break;
725 }
726 }
727 return buf_ptr - buf;
728 }
729
730 typedef struct AC3ParseContext {
731 uint8_t inbuf[4096]; /* input buffer */
732 uint8_t *inbuf_ptr;
733 int frame_size;
734 } AC3ParseContext;
735
736 #define AC3_HEADER_SIZE 7
737
738 static const int ac3_sample_rates[4] = {
739 48000, 44100, 32000, 0
740 };
741
742 static const int ac3_frame_sizes[64][3] = {
743 { 64, 69, 96 },
744 { 64, 70, 96 },
745 { 80, 87, 120 },
746 { 80, 88, 120 },
747 { 96, 104, 144 },
748 { 96, 105, 144 },
749 { 112, 121, 168 },
750 { 112, 122, 168 },
751 { 128, 139, 192 },
752 { 128, 140, 192 },
753 { 160, 174, 240 },
754 { 160, 175, 240 },
755 { 192, 208, 288 },
756 { 192, 209, 288 },
757 { 224, 243, 336 },
758 { 224, 244, 336 },
759 { 256, 278, 384 },
760 { 256, 279, 384 },
761 { 320, 348, 480 },
762 { 320, 349, 480 },
763 { 384, 417, 576 },
764 { 384, 418, 576 },
765 { 448, 487, 672 },
766 { 448, 488, 672 },
767 { 512, 557, 768 },
768 { 512, 558, 768 },
769 { 640, 696, 960 },
770 { 640, 697, 960 },
771 { 768, 835, 1152 },
772 { 768, 836, 1152 },
773 { 896, 975, 1344 },
774 { 896, 976, 1344 },
775 { 1024, 1114, 1536 },
776 { 1024, 1115, 1536 },
777 { 1152, 1253, 1728 },
778 { 1152, 1254, 1728 },
779 { 1280, 1393, 1920 },
780 { 1280, 1394, 1920 },
781 };
782
783 static const int ac3_bitrates[64] = {
784 32, 32, 40, 40, 48, 48, 56, 56, 64, 64, 80, 80, 96, 96, 112, 112,
785 128, 128, 160, 160, 192, 192, 224, 224, 256, 256, 320, 320, 384,
786 384, 448, 448, 512, 512, 576, 576, 640, 640,
787 };
788
789 static const int ac3_channels[8] = {
790 2, 1, 2, 3, 3, 4, 4, 5
791 };
792
793 static int ac3_sync(const uint8_t *buf, int *channels, int *sample_rate,
794 int *bit_rate)
795 {
796 unsigned int fscod, frmsizecod, acmod, bsid, lfeon;
797 GetBitContext bits;
798
799 init_get_bits(&bits, buf, AC3_HEADER_SIZE * 8);
800
801 if(get_bits(&bits, 16) != 0x0b77)
802 return 0;
803
804 get_bits(&bits, 16); /* crc */
805 fscod = get_bits(&bits, 2);
806 frmsizecod = get_bits(&bits, 6);
807
808 if(!ac3_sample_rates[fscod])
809 return 0;
810
811 bsid = get_bits(&bits, 5);
812 if(bsid > 8)
813 return 0;
814 get_bits(&bits, 3); /* bsmod */
815 acmod = get_bits(&bits, 3);
816 if(acmod & 1 && acmod != 1)
817 get_bits(&bits, 2); /* cmixlev */
818 if(acmod & 4)
819 get_bits(&bits, 2); /* surmixlev */
820 if(acmod & 2)
821 get_bits(&bits, 2); /* dsurmod */
822 lfeon = get_bits(&bits, 1);
823
824 *sample_rate = ac3_sample_rates[fscod];
825 *bit_rate = ac3_bitrates[frmsizecod] * 1000;
826 *channels = ac3_channels[acmod] + lfeon;
827
828 return ac3_frame_sizes[frmsizecod][fscod] * 2;
829 }
830
831 static int ac3_parse_init(AVCodecParserContext *s1)
832 {
833 AC3ParseContext *s = s1->priv_data;
834 s->inbuf_ptr = s->inbuf;
835 return 0;
836 }
837
838 static int ac3_parse(AVCodecParserContext *s1,
839 AVCodecContext *avctx,
840 uint8_t **poutbuf, int *poutbuf_size,
841 const uint8_t *buf, int buf_size)
842 {
843 AC3ParseContext *s = s1->priv_data;
844 const uint8_t *buf_ptr;
845 int len, sample_rate, bit_rate, channels;
846
847 *poutbuf = NULL;
848 *poutbuf_size = 0;
849
850 buf_ptr = buf;
851 while (buf_size > 0) {
852 len = s->inbuf_ptr - s->inbuf;
853 if (s->frame_size == 0) {
854 /* no header seen : find one. We need at least 7 bytes to parse it */
855 len = FFMIN(AC3_HEADER_SIZE - len, buf_size);
856
857 memcpy(s->inbuf_ptr, buf_ptr, len);
858 buf_ptr += len;
859 s->inbuf_ptr += len;
860 buf_size -= len;
861 if ((s->inbuf_ptr - s->inbuf) == AC3_HEADER_SIZE) {
862 len = ac3_sync(s->inbuf, &channels, &sample_rate, &bit_rate);
863 if (len == 0) {
864 /* no sync found : move by one byte (inefficient, but simple!) */
865 memmove(s->inbuf, s->inbuf + 1, AC3_HEADER_SIZE - 1);
866 s->inbuf_ptr--;
867 } else {
868 s->frame_size = len;
869 /* update codec info */
870 avctx->sample_rate = sample_rate;
871 /* set channels,except if the user explicitly requests 1 or 2 channels, XXX/FIXME this is a bit ugly */
872 if(avctx->channels!=1 && avctx->channels!=2){
873 avctx->channels = channels;
874 }
875 avctx->bit_rate = bit_rate;
876 avctx->frame_size = 6 * 256;
877 }
878 }
879 } else {
880 len = FFMIN(s->frame_size - len, buf_size);
881
882 memcpy(s->inbuf_ptr, buf_ptr, len);
883 buf_ptr += len;
884 s->inbuf_ptr += len;
885 buf_size -= len;
886
887 if(s->inbuf_ptr - s->inbuf == s->frame_size){
888 *poutbuf = s->inbuf;
889 *poutbuf_size = s->frame_size;
890 s->inbuf_ptr = s->inbuf;
891 s->frame_size = 0;
892 break;
893 }
894 }
895 }
896 return buf_ptr - buf;
897 }
898
899 AVCodecParser mpegvideo_parser = {
900 { CODEC_ID_MPEG1VIDEO, CODEC_ID_MPEG2VIDEO },
901 sizeof(ParseContext1),
902 NULL,
903 mpegvideo_parse,
904 parse1_close,
905 mpegvideo_split,
906 };
907
908 AVCodecParser mpeg4video_parser = {
909 { CODEC_ID_MPEG4 },
910 sizeof(ParseContext1),
911 mpeg4video_parse_init,
912 mpeg4video_parse,
913 parse1_close,
914 mpeg4video_split,
915 };
916
917 AVCodecParser mpegaudio_parser = {
918 { CODEC_ID_MP2, CODEC_ID_MP3 },
919 sizeof(MpegAudioParseContext),
920 mpegaudio_parse_init,
921 mpegaudio_parse,
922 NULL,
923 };
924
925 AVCodecParser ac3_parser = {
926 { CODEC_ID_AC3 },
927 sizeof(AC3ParseContext),
928 ac3_parse_init,
929 ac3_parse,
930 NULL,
931 };