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