Allows the AC3 parser to read the frame size and codec parameters from E-AC3 streams,
[ffmpeg.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 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 #include "avcodec.h"
23 #include "mpegvideo.h"
24 #include "mpegaudio.h"
25 #include "parser.h"
26
27 AVCodecParser *av_first_parser = NULL;
28
29 void av_register_codec_parser(AVCodecParser *parser)
30 {
31     parser->next = av_first_parser;
32     av_first_parser = parser;
33 }
34
35 AVCodecParserContext *av_parser_init(int codec_id)
36 {
37     AVCodecParserContext *s;
38     AVCodecParser *parser;
39     int ret;
40
41     if(codec_id == CODEC_ID_NONE)
42         return NULL;
43
44     for(parser = av_first_parser; parser != NULL; parser = parser->next) {
45         if (parser->codec_ids[0] == codec_id ||
46             parser->codec_ids[1] == codec_id ||
47             parser->codec_ids[2] == codec_id ||
48             parser->codec_ids[3] == codec_id ||
49             parser->codec_ids[4] == codec_id)
50             goto found;
51     }
52     return NULL;
53  found:
54     s = av_mallocz(sizeof(AVCodecParserContext));
55     if (!s)
56         return NULL;
57     s->parser = parser;
58     s->priv_data = av_mallocz(parser->priv_data_size);
59     if (!s->priv_data) {
60         av_free(s);
61         return NULL;
62     }
63     if (parser->parser_init) {
64         ret = parser->parser_init(s);
65         if (ret != 0) {
66             av_free(s->priv_data);
67             av_free(s);
68             return NULL;
69         }
70     }
71     s->fetch_timestamp=1;
72     return s;
73 }
74
75 /**
76  *
77  * @param buf           input
78  * @param buf_size      input length, to signal EOF, this should be 0 (so that the last frame can be output)
79  * @param pts           input presentation timestamp
80  * @param dts           input decoding timestamp
81  * @param poutbuf       will contain a pointer to the first byte of the output frame
82  * @param poutbuf_size  will contain the length of the output frame
83  * @return the number of bytes of the input bitstream used
84  *
85  * Example:
86  * @code
87  *   while(in_len){
88  *       len = av_parser_parse(myparser, AVCodecContext, &data, &size,
89  *                                       in_data, in_len,
90  *                                       pts, dts);
91  *       in_data += len;
92  *       in_len  -= len;
93  *
94  *       if(size)
95  *          decode_frame(data, size);
96  *   }
97  * @endcode
98  */
99 int av_parser_parse(AVCodecParserContext *s,
100                     AVCodecContext *avctx,
101                     uint8_t **poutbuf, int *poutbuf_size,
102                     const uint8_t *buf, int buf_size,
103                     int64_t pts, int64_t dts)
104 {
105     int index, i, k;
106     uint8_t dummy_buf[FF_INPUT_BUFFER_PADDING_SIZE];
107
108     if (buf_size == 0) {
109         /* padding is always necessary even if EOF, so we add it here */
110         memset(dummy_buf, 0, sizeof(dummy_buf));
111         buf = dummy_buf;
112     } else {
113         /* add a new packet descriptor */
114         k = (s->cur_frame_start_index + 1) & (AV_PARSER_PTS_NB - 1);
115         s->cur_frame_start_index = k;
116         s->cur_frame_offset[k] = s->cur_offset;
117         s->cur_frame_pts[k] = pts;
118         s->cur_frame_dts[k] = dts;
119
120         /* fill first PTS/DTS */
121         if (s->fetch_timestamp){
122             s->fetch_timestamp=0;
123             s->last_pts = pts;
124             s->last_dts = dts;
125             s->cur_frame_pts[k] =
126             s->cur_frame_dts[k] = AV_NOPTS_VALUE;
127         }
128     }
129
130     /* WARNING: the returned index can be negative */
131     index = s->parser->parser_parse(s, avctx, poutbuf, poutbuf_size, buf, buf_size);
132 //av_log(NULL, AV_LOG_DEBUG, "parser: in:%"PRId64", %"PRId64", out:%"PRId64", %"PRId64", in:%d out:%d id:%d\n", pts, dts, s->last_pts, s->last_dts, buf_size, *poutbuf_size, avctx->codec_id);
133     /* update the file pointer */
134     if (*poutbuf_size) {
135         /* fill the data for the current frame */
136         s->frame_offset = s->last_frame_offset;
137         s->pts = s->last_pts;
138         s->dts = s->last_dts;
139
140         /* offset of the next frame */
141         s->last_frame_offset = s->cur_offset + index;
142         /* find the packet in which the new frame starts. It
143            is tricky because of MPEG video start codes
144            which can begin in one packet and finish in
145            another packet. In the worst case, an MPEG
146            video start code could be in 4 different
147            packets. */
148         k = s->cur_frame_start_index;
149         for(i = 0; i < AV_PARSER_PTS_NB; i++) {
150             if (s->last_frame_offset >= s->cur_frame_offset[k])
151                 break;
152             k = (k - 1) & (AV_PARSER_PTS_NB - 1);
153         }
154
155         s->last_pts = s->cur_frame_pts[k];
156         s->last_dts = s->cur_frame_dts[k];
157
158         /* some parsers tell us the packet size even before seeing the first byte of the next packet,
159            so the next pts/dts is in the next chunk */
160         if(index == buf_size){
161             s->fetch_timestamp=1;
162         }
163     }
164     if (index < 0)
165         index = 0;
166     s->cur_offset += index;
167     return index;
168 }
169
170 /**
171  *
172  * @return 0 if the output buffer is a subset of the input, 1 if it is allocated and must be freed
173  * @deprecated use AVBitstreamFilter
174  */
175 int av_parser_change(AVCodecParserContext *s,
176                      AVCodecContext *avctx,
177                      uint8_t **poutbuf, int *poutbuf_size,
178                      const uint8_t *buf, int buf_size, int keyframe){
179
180     if(s && s->parser->split){
181         if((avctx->flags & CODEC_FLAG_GLOBAL_HEADER) || (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER)){
182             int i= s->parser->split(avctx, buf, buf_size);
183             buf += i;
184             buf_size -= i;
185         }
186     }
187
188     /* cast to avoid warning about discarding qualifiers */
189     *poutbuf= (uint8_t *) buf;
190     *poutbuf_size= buf_size;
191     if(avctx->extradata){
192         if(  (keyframe && (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER))
193             /*||(s->pict_type != I_TYPE && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_NOKEY))*/
194             /*||(? && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_BEGIN)*/){
195             int size= buf_size + avctx->extradata_size;
196             *poutbuf_size= size;
197             *poutbuf= av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
198
199             memcpy(*poutbuf, avctx->extradata, avctx->extradata_size);
200             memcpy((*poutbuf) + avctx->extradata_size, buf, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
201             return 1;
202         }
203     }
204
205     return 0;
206 }
207
208 void av_parser_close(AVCodecParserContext *s)
209 {
210     if (s->parser->parser_close)
211         s->parser->parser_close(s);
212     av_free(s->priv_data);
213     av_free(s);
214 }
215
216 /*****************************************************/
217
218 /**
219  * combines the (truncated) bitstream to a complete frame
220  * @returns -1 if no complete frame could be created
221  */
222 int ff_combine_frame(ParseContext *pc, int next, uint8_t **buf, int *buf_size)
223 {
224 #if 0
225     if(pc->overread){
226         printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
227         printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
228     }
229 #endif
230
231     /* copy overreaded bytes from last frame into buffer */
232     for(; pc->overread>0; pc->overread--){
233         pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
234     }
235
236     /* flush remaining if EOF */
237     if(!*buf_size && next == END_NOT_FOUND){
238         next= 0;
239     }
240
241     pc->last_index= pc->index;
242
243     /* copy into buffer end return */
244     if(next == END_NOT_FOUND){
245         pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
246
247         memcpy(&pc->buffer[pc->index], *buf, *buf_size);
248         pc->index += *buf_size;
249         return -1;
250     }
251
252     *buf_size=
253     pc->overread_index= pc->index + next;
254
255     /* append to buffer */
256     if(pc->index){
257         pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
258
259         memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
260         pc->index = 0;
261         *buf= pc->buffer;
262     }
263
264     /* store overread bytes */
265     for(;next < 0; next++){
266         pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
267         pc->overread++;
268     }
269
270 #if 0
271     if(pc->overread){
272         printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
273         printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
274     }
275 #endif
276
277     return 0;
278 }
279
280 void ff_parse_close(AVCodecParserContext *s)
281 {
282     ParseContext *pc = s->priv_data;
283
284     av_free(pc->buffer);
285 }
286
287 void ff_parse1_close(AVCodecParserContext *s)
288 {
289     ParseContext1 *pc1 = s->priv_data;
290
291     av_free(pc1->pc.buffer);
292     av_free(pc1->enc);
293 }
294
295 /*************************/
296
297 #ifdef CONFIG_MPEG4VIDEO_PARSER
298 /* used by parser */
299 /* XXX: make it use less memory */
300 static int av_mpeg4_decode_header(AVCodecParserContext *s1,
301                                   AVCodecContext *avctx,
302                                   const uint8_t *buf, int buf_size)
303 {
304     ParseContext1 *pc = s1->priv_data;
305     MpegEncContext *s = pc->enc;
306     GetBitContext gb1, *gb = &gb1;
307     int ret;
308
309     s->avctx = avctx;
310     s->current_picture_ptr = &s->current_picture;
311
312     if (avctx->extradata_size && pc->first_picture){
313         init_get_bits(gb, avctx->extradata, avctx->extradata_size*8);
314         ret = ff_mpeg4_decode_picture_header(s, gb);
315     }
316
317     init_get_bits(gb, buf, 8 * buf_size);
318     ret = ff_mpeg4_decode_picture_header(s, gb);
319     if (s->width) {
320         avcodec_set_dimensions(avctx, s->width, s->height);
321     }
322     s1->pict_type= s->pict_type;
323     pc->first_picture = 0;
324     return ret;
325 }
326
327 static int mpeg4video_parse_init(AVCodecParserContext *s)
328 {
329     ParseContext1 *pc = s->priv_data;
330
331     pc->enc = av_mallocz(sizeof(MpegEncContext));
332     if (!pc->enc)
333         return -1;
334     pc->first_picture = 1;
335     return 0;
336 }
337
338 static int mpeg4video_parse(AVCodecParserContext *s,
339                            AVCodecContext *avctx,
340                            uint8_t **poutbuf, int *poutbuf_size,
341                            const uint8_t *buf, int buf_size)
342 {
343     ParseContext *pc = s->priv_data;
344     int next;
345
346     if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
347         next= buf_size;
348     }else{
349         next= ff_mpeg4_find_frame_end(pc, buf, buf_size);
350
351         if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
352             *poutbuf = NULL;
353             *poutbuf_size = 0;
354             return buf_size;
355         }
356     }
357     av_mpeg4_decode_header(s, avctx, buf, buf_size);
358
359     *poutbuf = (uint8_t *)buf;
360     *poutbuf_size = buf_size;
361     return next;
362 }
363 #endif
364
365 int ff_mpeg4video_split(AVCodecContext *avctx,
366                            const uint8_t *buf, int buf_size)
367 {
368     int i;
369     uint32_t state= -1;
370
371     for(i=0; i<buf_size; i++){
372         state= (state<<8) | buf[i];
373         if(state == 0x1B3 || state == 0x1B6)
374             return i-3;
375     }
376     return 0;
377 }
378
379 /*************************/
380
381 #ifdef CONFIG_MPEGAUDIO_PARSER
382 typedef struct MpegAudioParseContext {
383     uint8_t inbuf[MPA_MAX_CODED_FRAME_SIZE];    /* input buffer */
384     uint8_t *inbuf_ptr;
385     int frame_size;
386     int free_format_frame_size;
387     int free_format_next_header;
388     uint32_t header;
389     int header_count;
390 } MpegAudioParseContext;
391
392 #define MPA_HEADER_SIZE 4
393
394 /* header + layer + bitrate + freq + lsf/mpeg25 */
395 #undef SAME_HEADER_MASK /* mpegaudio.h defines different version */
396 #define SAME_HEADER_MASK \
397    (0xffe00000 | (3 << 17) | (3 << 10) | (3 << 19))
398
399 static int mpegaudio_parse_init(AVCodecParserContext *s1)
400 {
401     MpegAudioParseContext *s = s1->priv_data;
402     s->inbuf_ptr = s->inbuf;
403     return 0;
404 }
405
406 static int mpegaudio_parse(AVCodecParserContext *s1,
407                            AVCodecContext *avctx,
408                            uint8_t **poutbuf, int *poutbuf_size,
409                            const uint8_t *buf, int buf_size)
410 {
411     MpegAudioParseContext *s = s1->priv_data;
412     int len, ret, sr;
413     uint32_t header;
414     const uint8_t *buf_ptr;
415
416     *poutbuf = NULL;
417     *poutbuf_size = 0;
418     buf_ptr = buf;
419     while (buf_size > 0) {
420         len = s->inbuf_ptr - s->inbuf;
421         if (s->frame_size == 0) {
422             /* special case for next header for first frame in free
423                format case (XXX: find a simpler method) */
424             if (s->free_format_next_header != 0) {
425                 s->inbuf[0] = s->free_format_next_header >> 24;
426                 s->inbuf[1] = s->free_format_next_header >> 16;
427                 s->inbuf[2] = s->free_format_next_header >> 8;
428                 s->inbuf[3] = s->free_format_next_header;
429                 s->inbuf_ptr = s->inbuf + 4;
430                 s->free_format_next_header = 0;
431                 goto got_header;
432             }
433             /* no header seen : find one. We need at least MPA_HEADER_SIZE
434                bytes to parse it */
435             len = FFMIN(MPA_HEADER_SIZE - len, buf_size);
436             if (len > 0) {
437                 memcpy(s->inbuf_ptr, buf_ptr, len);
438                 buf_ptr += len;
439                 buf_size -= len;
440                 s->inbuf_ptr += len;
441             }
442             if ((s->inbuf_ptr - s->inbuf) >= MPA_HEADER_SIZE) {
443             got_header:
444                 header = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
445                     (s->inbuf[2] << 8) | s->inbuf[3];
446
447                 ret = mpa_decode_header(avctx, header, &sr);
448                 if (ret < 0) {
449                     s->header_count= -2;
450                     /* no sync found : move by one byte (inefficient, but simple!) */
451                     memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
452                     s->inbuf_ptr--;
453                     dprintf("skip %x\n", header);
454                     /* reset free format frame size to give a chance
455                        to get a new bitrate */
456                     s->free_format_frame_size = 0;
457                 } else {
458                     if((header&SAME_HEADER_MASK) != (s->header&SAME_HEADER_MASK) && s->header)
459                         s->header_count= -3;
460                     s->header= header;
461                     s->header_count++;
462                     s->frame_size = ret;
463
464 #if 0
465                     /* free format: prepare to compute frame size */
466                     if (decode_header(s, header) == 1) {
467                         s->frame_size = -1;
468                     }
469 #endif
470                 }
471                 if(s->header_count > 1)
472                     avctx->sample_rate= sr;
473             }
474         } else
475 #if 0
476         if (s->frame_size == -1) {
477             /* free format : find next sync to compute frame size */
478             len = MPA_MAX_CODED_FRAME_SIZE - len;
479             if (len > buf_size)
480                 len = buf_size;
481             if (len == 0) {
482                 /* frame too long: resync */
483                 s->frame_size = 0;
484                 memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
485                 s->inbuf_ptr--;
486             } else {
487                 uint8_t *p, *pend;
488                 uint32_t header1;
489                 int padding;
490
491                 memcpy(s->inbuf_ptr, buf_ptr, len);
492                 /* check for header */
493                 p = s->inbuf_ptr - 3;
494                 pend = s->inbuf_ptr + len - 4;
495                 while (p <= pend) {
496                     header = (p[0] << 24) | (p[1] << 16) |
497                         (p[2] << 8) | p[3];
498                     header1 = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
499                         (s->inbuf[2] << 8) | s->inbuf[3];
500                     /* check with high probability that we have a
501                        valid header */
502                     if ((header & SAME_HEADER_MASK) ==
503                         (header1 & SAME_HEADER_MASK)) {
504                         /* header found: update pointers */
505                         len = (p + 4) - s->inbuf_ptr;
506                         buf_ptr += len;
507                         buf_size -= len;
508                         s->inbuf_ptr = p;
509                         /* compute frame size */
510                         s->free_format_next_header = header;
511                         s->free_format_frame_size = s->inbuf_ptr - s->inbuf;
512                         padding = (header1 >> 9) & 1;
513                         if (s->layer == 1)
514                             s->free_format_frame_size -= padding * 4;
515                         else
516                             s->free_format_frame_size -= padding;
517                         dprintf("free frame size=%d padding=%d\n",
518                                 s->free_format_frame_size, padding);
519                         decode_header(s, header1);
520                         goto next_data;
521                     }
522                     p++;
523                 }
524                 /* not found: simply increase pointers */
525                 buf_ptr += len;
526                 s->inbuf_ptr += len;
527                 buf_size -= len;
528             }
529         } else
530 #endif
531         if (len < s->frame_size) {
532             if (s->frame_size > MPA_MAX_CODED_FRAME_SIZE)
533                 s->frame_size = MPA_MAX_CODED_FRAME_SIZE;
534             len = FFMIN(s->frame_size - len, buf_size);
535             memcpy(s->inbuf_ptr, buf_ptr, len);
536             buf_ptr += len;
537             s->inbuf_ptr += len;
538             buf_size -= len;
539         }
540
541         if(s->frame_size > 0 && buf_ptr - buf == s->inbuf_ptr - s->inbuf
542            && buf_size + buf_ptr - buf >= s->frame_size){
543             if(s->header_count > 0){
544                 *poutbuf = buf;
545                 *poutbuf_size = s->frame_size;
546             }
547             buf_ptr = buf + s->frame_size;
548             s->inbuf_ptr = s->inbuf;
549             s->frame_size = 0;
550             break;
551         }
552
553         //    next_data:
554         if (s->frame_size > 0 &&
555             (s->inbuf_ptr - s->inbuf) >= s->frame_size) {
556             if(s->header_count > 0){
557                 *poutbuf = s->inbuf;
558                 *poutbuf_size = s->inbuf_ptr - s->inbuf;
559             }
560             s->inbuf_ptr = s->inbuf;
561             s->frame_size = 0;
562             break;
563         }
564     }
565     return buf_ptr - buf;
566 }
567 #endif /* CONFIG_MPEGAUDIO_PARSER */
568
569 #if defined(CONFIG_AC3_PARSER) || defined(CONFIG_AAC_PARSER)
570 /* also used for ADTS AAC */
571 typedef struct AC3ParseContext {
572     uint8_t *inbuf_ptr;
573     int frame_size;
574     int header_size;
575     int (*sync)(const uint8_t *buf, int *channels, int *sample_rate,
576                 int *bit_rate, int *samples);
577     uint8_t inbuf[8192]; /* input buffer */
578 } AC3ParseContext;
579
580 #define AC3_HEADER_SIZE 7
581 #define AAC_HEADER_SIZE 7
582
583 #ifdef CONFIG_AC3_PARSER
584 static const int ac3_sample_rates[4] = {
585     48000, 44100, 32000, 0
586 };
587
588 static const int ac3_frame_sizes[64][3] = {
589     { 64,   69,   96   },
590     { 64,   70,   96   },
591     { 80,   87,   120  },
592     { 80,   88,   120  },
593     { 96,   104,  144  },
594     { 96,   105,  144  },
595     { 112,  121,  168  },
596     { 112,  122,  168  },
597     { 128,  139,  192  },
598     { 128,  140,  192  },
599     { 160,  174,  240  },
600     { 160,  175,  240  },
601     { 192,  208,  288  },
602     { 192,  209,  288  },
603     { 224,  243,  336  },
604     { 224,  244,  336  },
605     { 256,  278,  384  },
606     { 256,  279,  384  },
607     { 320,  348,  480  },
608     { 320,  349,  480  },
609     { 384,  417,  576  },
610     { 384,  418,  576  },
611     { 448,  487,  672  },
612     { 448,  488,  672  },
613     { 512,  557,  768  },
614     { 512,  558,  768  },
615     { 640,  696,  960  },
616     { 640,  697,  960  },
617     { 768,  835,  1152 },
618     { 768,  836,  1152 },
619     { 896,  975,  1344 },
620     { 896,  976,  1344 },
621     { 1024, 1114, 1536 },
622     { 1024, 1115, 1536 },
623     { 1152, 1253, 1728 },
624     { 1152, 1254, 1728 },
625     { 1280, 1393, 1920 },
626     { 1280, 1394, 1920 },
627 };
628
629 static const int ac3_bitrates[64] = {
630     32, 32, 40, 40, 48, 48, 56, 56, 64, 64, 80, 80, 96, 96, 112, 112,
631     128, 128, 160, 160, 192, 192, 224, 224, 256, 256, 320, 320, 384,
632     384, 448, 448, 512, 512, 576, 576, 640, 640,
633 };
634
635 static const uint8_t ac3_channels[8] = {
636     2, 1, 2, 3, 3, 4, 4, 5
637 };
638
639 static const uint8_t eac3_blocks[4] = {
640     1, 2, 3, 6
641 };
642
643 #endif /* CONFIG_AC3_PARSER */
644
645 #ifdef CONFIG_AAC_PARSER
646 static const int aac_sample_rates[16] = {
647     96000, 88200, 64000, 48000, 44100, 32000,
648     24000, 22050, 16000, 12000, 11025, 8000, 7350
649 };
650
651 static const int aac_channels[8] = {
652     0, 1, 2, 3, 4, 5, 6, 8
653 };
654 #endif
655
656 #ifdef CONFIG_AC3_PARSER
657 static int ac3_sync(const uint8_t *buf, int *channels, int *sample_rate,
658                     int *bit_rate, int *samples)
659 {
660     unsigned int fscod, frmsizecod, acmod, bsid, lfeon;
661     unsigned int strmtyp, substreamid, frmsiz, fscod2, numblkscod;
662     GetBitContext bits;
663
664     init_get_bits(&bits, buf, AC3_HEADER_SIZE * 8);
665
666     if(get_bits(&bits, 16) != 0x0b77)
667         return 0;
668
669     bsid = show_bits_long(&bits, 29) & 0x1f;
670     if(bsid <= 8) {             /* Normal AC-3 */
671     skip_bits(&bits, 16);       /* crc */
672     fscod = get_bits(&bits, 2);
673     frmsizecod = get_bits(&bits, 6);
674
675     if(fscod == 3)
676         return 0;
677
678     skip_bits(&bits, 5);        /* bsid */
679     skip_bits(&bits, 3);        /* bsmod */
680     acmod = get_bits(&bits, 3);
681     if(acmod & 1 && acmod != 1)
682         skip_bits(&bits, 2);    /* cmixlev */
683     if(acmod & 4)
684         skip_bits(&bits, 2);    /* surmixlev */
685     if(acmod & 2)
686         skip_bits(&bits, 2);    /* dsurmod */
687     lfeon = get_bits1(&bits);
688
689     *sample_rate = ac3_sample_rates[fscod];
690     *bit_rate = ac3_bitrates[frmsizecod] * 1000;
691     *channels = ac3_channels[acmod] + lfeon;
692     *samples = 6 * 256;
693
694     return ac3_frame_sizes[frmsizecod][fscod] * 2;
695     } else if (bsid >= 10 && bsid <= 16) { /* Enhanced AC-3 */
696         strmtyp = get_bits(&bits, 2);
697         substreamid = get_bits(&bits, 3);
698
699         if (strmtyp != 0 || substreamid != 0)
700             return 0;   /* Currently don't support additional streams */
701
702         frmsiz = get_bits(&bits, 11) + 1;
703         fscod = get_bits(&bits, 2);
704         if (fscod == 3) {
705             fscod2 = get_bits(&bits, 2);
706             numblkscod = 3;
707
708             if(fscod2 == 3)
709                 return 0;
710
711             *sample_rate = ac3_sample_rates[fscod2] / 2;
712         } else {
713             numblkscod = get_bits(&bits, 2);
714
715             *sample_rate = ac3_sample_rates[fscod];
716         }
717
718         acmod = get_bits(&bits, 3);
719         lfeon = get_bits1(&bits);
720
721         *samples = eac3_blocks[numblkscod] * 256;
722         *bit_rate = frmsiz * (*sample_rate) * 16 / (*samples);
723         *channels = ac3_channels[acmod] + lfeon;
724
725         return frmsiz * 2;
726     }
727
728     /* Unsupported bitstream version */
729     return 0;
730 }
731 #endif /* CONFIG_AC3_PARSER */
732
733 #ifdef CONFIG_AAC_PARSER
734 static int aac_sync(const uint8_t *buf, int *channels, int *sample_rate,
735                     int *bit_rate, int *samples)
736 {
737     GetBitContext bits;
738     int size, rdb, ch, sr;
739
740     init_get_bits(&bits, buf, AAC_HEADER_SIZE * 8);
741
742     if(get_bits(&bits, 12) != 0xfff)
743         return 0;
744
745     skip_bits1(&bits);          /* id */
746     skip_bits(&bits, 2);        /* layer */
747     skip_bits1(&bits);          /* protection_absent */
748     skip_bits(&bits, 2);        /* profile_objecttype */
749     sr = get_bits(&bits, 4);    /* sample_frequency_index */
750     if(!aac_sample_rates[sr])
751         return 0;
752     skip_bits1(&bits);          /* private_bit */
753     ch = get_bits(&bits, 3);    /* channel_configuration */
754     if(!aac_channels[ch])
755         return 0;
756     skip_bits1(&bits);          /* original/copy */
757     skip_bits1(&bits);          /* home */
758
759     /* adts_variable_header */
760     skip_bits1(&bits);          /* copyright_identification_bit */
761     skip_bits1(&bits);          /* copyright_identification_start */
762     size = get_bits(&bits, 13); /* aac_frame_length */
763     skip_bits(&bits, 11);       /* adts_buffer_fullness */
764     rdb = get_bits(&bits, 2);   /* number_of_raw_data_blocks_in_frame */
765
766     *channels = aac_channels[ch];
767     *sample_rate = aac_sample_rates[sr];
768     *samples = (rdb + 1) * 1024;
769     *bit_rate = size * 8 * *sample_rate / *samples;
770
771     return size;
772 }
773 #endif /* CONFIG_AAC_PARSER */
774
775 #ifdef CONFIG_AC3_PARSER
776 static int ac3_parse_init(AVCodecParserContext *s1)
777 {
778     AC3ParseContext *s = s1->priv_data;
779     s->inbuf_ptr = s->inbuf;
780     s->header_size = AC3_HEADER_SIZE;
781     s->sync = ac3_sync;
782     return 0;
783 }
784 #endif
785
786 #ifdef CONFIG_AAC_PARSER
787 static int aac_parse_init(AVCodecParserContext *s1)
788 {
789     AC3ParseContext *s = s1->priv_data;
790     s->inbuf_ptr = s->inbuf;
791     s->header_size = AAC_HEADER_SIZE;
792     s->sync = aac_sync;
793     return 0;
794 }
795 #endif
796
797 /* also used for ADTS AAC */
798 static int ac3_parse(AVCodecParserContext *s1,
799                      AVCodecContext *avctx,
800                      uint8_t **poutbuf, int *poutbuf_size,
801                      const uint8_t *buf, int buf_size)
802 {
803     AC3ParseContext *s = s1->priv_data;
804     const uint8_t *buf_ptr;
805     int len, sample_rate, bit_rate, channels, samples;
806
807     *poutbuf = NULL;
808     *poutbuf_size = 0;
809
810     buf_ptr = buf;
811     while (buf_size > 0) {
812         len = s->inbuf_ptr - s->inbuf;
813         if (s->frame_size == 0) {
814             /* no header seen : find one. We need at least s->header_size
815                bytes to parse it */
816             len = FFMIN(s->header_size - len, buf_size);
817
818             memcpy(s->inbuf_ptr, buf_ptr, len);
819             buf_ptr += len;
820             s->inbuf_ptr += len;
821             buf_size -= len;
822             if ((s->inbuf_ptr - s->inbuf) == s->header_size) {
823                 len = s->sync(s->inbuf, &channels, &sample_rate, &bit_rate,
824                               &samples);
825                 if (len == 0) {
826                     /* no sync found : move by one byte (inefficient, but simple!) */
827                     memmove(s->inbuf, s->inbuf + 1, s->header_size - 1);
828                     s->inbuf_ptr--;
829                 } else {
830                     s->frame_size = len;
831                     /* update codec info */
832                     avctx->sample_rate = sample_rate;
833                     /* set channels,except if the user explicitly requests 1 or 2 channels, XXX/FIXME this is a bit ugly */
834                     if(avctx->codec_id == CODEC_ID_AC3){
835                         if(avctx->channels!=1 && avctx->channels!=2){
836                             avctx->channels = channels;
837                         }
838                     } else {
839                         avctx->channels = channels;
840                     }
841                     avctx->bit_rate = bit_rate;
842                     avctx->frame_size = samples;
843                 }
844             }
845         } else {
846             len = FFMIN(s->frame_size - len, buf_size);
847
848             memcpy(s->inbuf_ptr, buf_ptr, len);
849             buf_ptr += len;
850             s->inbuf_ptr += len;
851             buf_size -= len;
852
853             if(s->inbuf_ptr - s->inbuf == s->frame_size){
854                 *poutbuf = s->inbuf;
855                 *poutbuf_size = s->frame_size;
856                 s->inbuf_ptr = s->inbuf;
857                 s->frame_size = 0;
858                 break;
859             }
860         }
861     }
862     return buf_ptr - buf;
863 }
864 #endif /* CONFIG_AC3_PARSER || CONFIG_AAC_PARSER */
865
866 #ifdef CONFIG_MPEG4VIDEO_PARSER
867 AVCodecParser mpeg4video_parser = {
868     { CODEC_ID_MPEG4 },
869     sizeof(ParseContext1),
870     mpeg4video_parse_init,
871     mpeg4video_parse,
872     ff_parse1_close,
873     ff_mpeg4video_split,
874 };
875 #endif
876 #ifdef CONFIG_MPEGAUDIO_PARSER
877 AVCodecParser mpegaudio_parser = {
878     { CODEC_ID_MP2, CODEC_ID_MP3 },
879     sizeof(MpegAudioParseContext),
880     mpegaudio_parse_init,
881     mpegaudio_parse,
882     NULL,
883 };
884 #endif
885 #ifdef CONFIG_AC3_PARSER
886 AVCodecParser ac3_parser = {
887     { CODEC_ID_AC3 },
888     sizeof(AC3ParseContext),
889     ac3_parse_init,
890     ac3_parse,
891     NULL,
892 };
893 #endif
894 #ifdef CONFIG_AAC_PARSER
895 AVCodecParser aac_parser = {
896     { CODEC_ID_AAC },
897     sizeof(AC3ParseContext),
898     aac_parse_init,
899     ac3_parse,
900     NULL,
901 };
902 #endif