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