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