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