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