4f82edab55ec0620058ec4e154bfdf1ccd6d6152
[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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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     for(parser = av_first_parser; parser != NULL; parser = parser->next) {
39         if (parser->codec_ids[0] == codec_id ||
40             parser->codec_ids[1] == codec_id ||
41             parser->codec_ids[2] == codec_id)
42             goto found;
43     }
44     return NULL;
45  found:
46     s = av_mallocz(sizeof(AVCodecParserContext));
47     if (!s)
48         return NULL;
49     s->parser = parser;
50     s->priv_data = av_mallocz(parser->priv_data_size);
51     if (!s->priv_data) {
52         av_free(s);
53         return NULL;
54     }
55     if (parser->parser_init) {
56         ret = parser->parser_init(s);
57         if (ret != 0) {
58             av_free(s->priv_data);
59             av_free(s);
60             return NULL;
61         }
62     }
63     s->fetch_timestamp=1;
64     return s;
65 }
66
67 /* NOTE: buf_size == 0 is used to signal EOF so that the last frame
68    can be returned if necessary */
69 int av_parser_parse(AVCodecParserContext *s, 
70                     AVCodecContext *avctx,
71                     uint8_t **poutbuf, int *poutbuf_size, 
72                     const uint8_t *buf, int buf_size,
73                     int64_t pts, int64_t dts)
74 {
75     int index, i, k;
76     uint8_t dummy_buf[FF_INPUT_BUFFER_PADDING_SIZE];
77     
78     if (buf_size == 0) {
79         /* padding is always necessary even if EOF, so we add it here */
80         memset(dummy_buf, 0, sizeof(dummy_buf));
81         buf = dummy_buf;
82     } else {
83         /* add a new packet descriptor */
84         k = (s->cur_frame_start_index + 1) & (AV_PARSER_PTS_NB - 1);
85         s->cur_frame_start_index = k;
86         s->cur_frame_offset[k] = s->cur_offset;
87         s->cur_frame_pts[k] = pts;
88         s->cur_frame_dts[k] = dts;
89
90         /* fill first PTS/DTS */
91         if (s->fetch_timestamp){
92             s->fetch_timestamp=0;
93             s->last_pts = pts;
94             s->last_dts = dts;
95             s->cur_frame_pts[k] =
96             s->cur_frame_dts[k] = AV_NOPTS_VALUE;
97         }
98     }
99
100     /* WARNING: the returned index can be negative */
101     index = s->parser->parser_parse(s, avctx, poutbuf, poutbuf_size, buf, buf_size);
102 //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);
103     /* update the file pointer */
104     if (*poutbuf_size) {
105         /* fill the data for the current frame */
106         s->frame_offset = s->last_frame_offset;
107         s->pts = s->last_pts;
108         s->dts = s->last_dts;
109         
110         /* offset of the next frame */
111         s->last_frame_offset = s->cur_offset + index;
112         /* find the packet in which the new frame starts. It
113            is tricky because of MPEG video start codes
114            which can begin in one packet and finish in
115            another packet. In the worst case, an MPEG
116            video start code could be in 4 different
117            packets. */
118         k = s->cur_frame_start_index;
119         for(i = 0; i < AV_PARSER_PTS_NB; i++) {
120             if (s->last_frame_offset >= s->cur_frame_offset[k])
121                 break;
122             k = (k - 1) & (AV_PARSER_PTS_NB - 1);
123         }
124
125         s->last_pts = s->cur_frame_pts[k];
126         s->last_dts = s->cur_frame_dts[k];
127         
128         /* some parsers tell us the packet size even before seeing the first byte of the next packet,
129            so the next pts/dts is in the next chunk */
130         if(index == buf_size){
131             s->fetch_timestamp=1;
132         }
133     }
134     if (index < 0)
135         index = 0;
136     s->cur_offset += index;
137     return index;
138 }
139
140 void av_parser_close(AVCodecParserContext *s)
141 {
142     if (s->parser->parser_close)
143         s->parser->parser_close(s);
144     av_free(s->priv_data);
145     av_free(s);
146 }
147
148 /*****************************************************/
149
150 //#define END_NOT_FOUND (-100)
151
152 #define PICTURE_START_CODE      0x00000100
153 #define SEQ_START_CODE          0x000001b3
154 #define EXT_START_CODE          0x000001b5
155 #define SLICE_MIN_START_CODE    0x00000101
156 #define SLICE_MAX_START_CODE    0x000001af
157
158 typedef struct ParseContext1{
159     ParseContext pc;
160 /* XXX/FIXME PC1 vs. PC */
161     /* MPEG2 specific */
162     int frame_rate;
163     int progressive_sequence;
164     int width, height;
165
166     /* XXX: suppress that, needed by MPEG4 */
167     MpegEncContext *enc;
168     int first_picture;
169 } ParseContext1;
170
171 /**
172  * combines the (truncated) bitstream to a complete frame
173  * @returns -1 if no complete frame could be created
174  */
175 int ff_combine_frame(ParseContext *pc, int next, uint8_t **buf, int *buf_size)
176 {
177 #if 0
178     if(pc->overread){
179         printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
180         printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
181     }
182 #endif
183
184     /* copy overreaded bytes from last frame into buffer */
185     for(; pc->overread>0; pc->overread--){
186         pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
187     }
188     
189     pc->last_index= pc->index;
190
191     /* copy into buffer end return */
192     if(next == END_NOT_FOUND){
193         pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
194
195         memcpy(&pc->buffer[pc->index], *buf, *buf_size);
196         pc->index += *buf_size;
197         return -1;
198     }
199
200     *buf_size=
201     pc->overread_index= pc->index + next;
202     
203     /* append to buffer */
204     if(pc->index){
205         pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
206
207         memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
208         pc->index = 0;
209         *buf= pc->buffer;
210     }
211
212     /* store overread bytes */
213     for(;next < 0; next++){
214         pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
215         pc->overread++;
216     }
217
218 #if 0
219     if(pc->overread){
220         printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
221         printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
222     }
223 #endif
224
225     return 0;
226 }
227
228 static int find_start_code(const uint8_t **pbuf_ptr, const uint8_t *buf_end)
229 {
230     const uint8_t *buf_ptr;
231     unsigned int state=0xFFFFFFFF, v;
232     int val;
233
234     buf_ptr = *pbuf_ptr;
235     while (buf_ptr < buf_end) {
236         v = *buf_ptr++;
237         if (state == 0x000001) {
238             state = ((state << 8) | v) & 0xffffff;
239             val = state;
240             goto found;
241         }
242         state = ((state << 8) | v) & 0xffffff;
243     }
244     val = -1;
245  found:
246     *pbuf_ptr = buf_ptr;
247     return val;
248 }
249
250 /* XXX: merge with libavcodec ? */
251 #define MPEG1_FRAME_RATE_BASE 1001
252
253 static const int frame_rate_tab[16] = {
254         0,        
255     24000,
256     24024,
257     25025,
258     30000,
259     30030,
260     50050,
261     60000,
262     60060,
263   // Xing's 15fps: (9)
264     15015,
265   // libmpeg3's "Unofficial economy rates": (10-13)
266      5005,
267     10010,
268     12012,
269     15015,
270   // random, just to avoid segfault !never encode these
271     25025,
272     25025,
273 };
274
275 static void mpegvideo_extract_headers(AVCodecParserContext *s, 
276                                       AVCodecContext *avctx,
277                                       const uint8_t *buf, int buf_size)
278 {
279     ParseContext1 *pc = s->priv_data;
280     const uint8_t *buf_end;
281     int32_t start_code;
282     int frame_rate_index, ext_type, bytes_left;
283     int frame_rate_ext_n, frame_rate_ext_d;
284     int picture_structure, top_field_first, repeat_first_field, progressive_frame;
285     int horiz_size_ext, vert_size_ext;
286
287     s->repeat_pict = 0;
288     buf_end = buf + buf_size;
289     while (buf < buf_end) {
290         start_code = find_start_code(&buf, buf_end);
291         bytes_left = buf_end - buf;
292         switch(start_code) {
293         case PICTURE_START_CODE:
294             if (bytes_left >= 2) {
295                 s->pict_type = (buf[1] >> 3) & 7;
296             }
297             break;
298         case SEQ_START_CODE:
299             if (bytes_left >= 4) {
300                 pc->width  = (buf[0] << 4) | (buf[1] >> 4);
301                 pc->height = ((buf[1] & 0x0f) << 8) | buf[2];
302                 avctx->width  = -((-pc->width )>>avctx->lowres);
303                 avctx->height = -((-pc->height)>>avctx->lowres);
304                 frame_rate_index = buf[3] & 0xf;
305                 pc->frame_rate = avctx->frame_rate = frame_rate_tab[frame_rate_index];
306                 avctx->frame_rate_base = MPEG1_FRAME_RATE_BASE;
307                 avctx->codec_id = CODEC_ID_MPEG1VIDEO;
308                 avctx->sub_id = 1;
309             }
310             break;
311         case EXT_START_CODE:
312             if (bytes_left >= 1) {
313                 ext_type = (buf[0] >> 4);
314                 switch(ext_type) {
315                 case 0x1: /* sequence extension */
316                     if (bytes_left >= 6) {
317                         horiz_size_ext = ((buf[1] & 1) << 1) | (buf[2] >> 7);
318                         vert_size_ext = (buf[2] >> 5) & 3;
319                         frame_rate_ext_n = (buf[5] >> 5) & 3;
320                         frame_rate_ext_d = (buf[5] & 0x1f);
321                         pc->progressive_sequence = buf[1] & (1 << 3);
322
323                         pc->width  |=(horiz_size_ext << 12);
324                         pc->height |=( vert_size_ext << 12);
325                         avctx->width  = -((-pc->width )>>avctx->lowres);
326                         avctx->height = -((-pc->height)>>avctx->lowres);
327                         avctx->frame_rate = pc->frame_rate * (frame_rate_ext_n + 1);
328                         avctx->frame_rate_base = MPEG1_FRAME_RATE_BASE * (frame_rate_ext_d + 1);
329                         avctx->codec_id = CODEC_ID_MPEG2VIDEO;
330                         avctx->sub_id = 2; /* forces MPEG2 */
331                     }
332                     break;
333                 case 0x8: /* picture coding extension */
334                     if (bytes_left >= 5) {
335                         picture_structure = buf[2]&3;
336                         top_field_first = buf[3] & (1 << 7);
337                         repeat_first_field = buf[3] & (1 << 1);
338                         progressive_frame = buf[4] & (1 << 7);
339                     
340                         /* check if we must repeat the frame */
341                         if (repeat_first_field) {
342                             if (pc->progressive_sequence) {
343                                 if (top_field_first)
344                                     s->repeat_pict = 4;
345                                 else
346                                     s->repeat_pict = 2;
347                             } else if (progressive_frame) {
348                                 s->repeat_pict = 1;
349                             }
350                         }
351                         
352                         /* the packet only represents half a frame 
353                            XXX,FIXME maybe find a different solution */
354                         if(picture_structure != 3)
355                             s->repeat_pict = -1;
356                     }
357                     break;
358                 }
359             }
360             break;
361         case -1:
362             goto the_end;
363         default:
364             /* we stop parsing when we encounter a slice. It ensures
365                that this function takes a negligible amount of time */
366             if (start_code >= SLICE_MIN_START_CODE && 
367                 start_code <= SLICE_MAX_START_CODE)
368                 goto the_end;
369             break;
370         }
371     }
372  the_end: ;
373 }
374
375 static int mpegvideo_parse(AVCodecParserContext *s,
376                            AVCodecContext *avctx,
377                            uint8_t **poutbuf, int *poutbuf_size, 
378                            const uint8_t *buf, int buf_size)
379 {
380     ParseContext1 *pc1 = s->priv_data;
381     ParseContext *pc= &pc1->pc;
382     int next;
383     
384     next= ff_mpeg1_find_frame_end(pc, buf, buf_size);
385     
386     if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
387         *poutbuf = NULL;
388         *poutbuf_size = 0;
389         return buf_size;
390     }
391     /* we have a full frame : we just parse the first few MPEG headers
392        to have the full timing information. The time take by this
393        function should be negligible for uncorrupted streams */
394     mpegvideo_extract_headers(s, avctx, buf, buf_size);
395 #if 0
396     printf("pict_type=%d frame_rate=%0.3f repeat_pict=%d\n", 
397            s->pict_type, (double)avctx->frame_rate / avctx->frame_rate_base, s->repeat_pict);
398 #endif
399
400     *poutbuf = (uint8_t *)buf;
401     *poutbuf_size = buf_size;
402     return next;
403 }
404
405 void ff_parse_close(AVCodecParserContext *s)
406 {
407     ParseContext *pc = s->priv_data;
408
409     av_free(pc->buffer);
410 }
411
412 static void parse1_close(AVCodecParserContext *s)
413 {
414     ParseContext1 *pc1 = s->priv_data;
415
416     av_free(pc1->pc.buffer);
417     av_free(pc1->enc);
418 }
419
420 /*************************/
421
422 /* used by parser */
423 /* XXX: make it use less memory */
424 static int av_mpeg4_decode_header(AVCodecParserContext *s1, 
425                                   AVCodecContext *avctx,
426                                   const uint8_t *buf, int buf_size)
427 {
428     ParseContext1 *pc = s1->priv_data;
429     MpegEncContext *s = pc->enc;
430     GetBitContext gb1, *gb = &gb1;
431     int ret;
432
433     s->avctx = avctx;
434     s->current_picture_ptr = &s->current_picture;
435
436     if (avctx->extradata_size && pc->first_picture){
437         init_get_bits(gb, avctx->extradata, avctx->extradata_size*8);
438         ret = ff_mpeg4_decode_picture_header(s, gb);
439     }
440
441     init_get_bits(gb, buf, 8 * buf_size);
442     ret = ff_mpeg4_decode_picture_header(s, gb);
443     if (s->width) {
444         avctx->width  = -((-s->width )>>avctx->lowres);
445         avctx->height = -((-s->height)>>avctx->lowres);
446     }
447     pc->first_picture = 0;
448     return ret;
449 }
450
451 static int mpeg4video_parse_init(AVCodecParserContext *s)
452 {
453     ParseContext1 *pc = s->priv_data;
454
455     pc->enc = av_mallocz(sizeof(MpegEncContext));
456     if (!pc->enc)
457         return -1;
458     pc->first_picture = 1;
459     return 0;
460 }
461
462 static int mpeg4video_parse(AVCodecParserContext *s,
463                            AVCodecContext *avctx,
464                            uint8_t **poutbuf, int *poutbuf_size, 
465                            const uint8_t *buf, int buf_size)
466 {
467     ParseContext *pc = s->priv_data;
468     int next;
469     
470     next= ff_mpeg4_find_frame_end(pc, buf, buf_size);
471
472     if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
473         *poutbuf = NULL;
474         *poutbuf_size = 0;
475         return buf_size;
476     }
477     av_mpeg4_decode_header(s, avctx, buf, buf_size);
478
479     *poutbuf = (uint8_t *)buf;
480     *poutbuf_size = buf_size;
481     return next;
482 }
483
484 /*************************/
485
486 typedef struct MpegAudioParseContext {
487     uint8_t inbuf[MPA_MAX_CODED_FRAME_SIZE];    /* input buffer */
488     uint8_t *inbuf_ptr;
489     int frame_size;
490     int free_format_frame_size;
491     int free_format_next_header;
492 } MpegAudioParseContext;
493
494 #define MPA_HEADER_SIZE 4
495
496 /* header + layer + bitrate + freq + lsf/mpeg25 */
497 #define SAME_HEADER_MASK \
498    (0xffe00000 | (3 << 17) | (0xf << 12) | (3 << 10) | (3 << 19))
499
500 static int mpegaudio_parse_init(AVCodecParserContext *s1)
501 {
502     MpegAudioParseContext *s = s1->priv_data;
503     s->inbuf_ptr = s->inbuf;
504     return 0;
505 }
506
507 static int mpegaudio_parse(AVCodecParserContext *s1,
508                            AVCodecContext *avctx,
509                            uint8_t **poutbuf, int *poutbuf_size, 
510                            const uint8_t *buf, int buf_size)
511 {
512     MpegAudioParseContext *s = s1->priv_data;
513     int len, ret;
514     uint32_t header;
515     const uint8_t *buf_ptr;
516
517     *poutbuf = NULL;
518     *poutbuf_size = 0;
519     buf_ptr = buf;
520     while (buf_size > 0) {
521         len = s->inbuf_ptr - s->inbuf;
522         if (s->frame_size == 0) {
523             /* special case for next header for first frame in free
524                format case (XXX: find a simpler method) */
525             if (s->free_format_next_header != 0) {
526                 s->inbuf[0] = s->free_format_next_header >> 24;
527                 s->inbuf[1] = s->free_format_next_header >> 16;
528                 s->inbuf[2] = s->free_format_next_header >> 8;
529                 s->inbuf[3] = s->free_format_next_header;
530                 s->inbuf_ptr = s->inbuf + 4;
531                 s->free_format_next_header = 0;
532                 goto got_header;
533             }
534             /* no header seen : find one. We need at least MPA_HEADER_SIZE
535                bytes to parse it */
536             len = MPA_HEADER_SIZE - len;
537             if (len > buf_size)
538                 len = buf_size;
539             if (len > 0) {
540                 memcpy(s->inbuf_ptr, buf_ptr, len);
541                 buf_ptr += len;
542                 buf_size -= len;
543                 s->inbuf_ptr += len;
544             }
545             if ((s->inbuf_ptr - s->inbuf) >= MPA_HEADER_SIZE) {
546             got_header:
547                 header = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
548                     (s->inbuf[2] << 8) | s->inbuf[3];
549
550                 ret = mpa_decode_header(avctx, header);
551                 if (ret < 0) {
552                     /* no sync found : move by one byte (inefficient, but simple!) */
553                     memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
554                     s->inbuf_ptr--;
555                     dprintf("skip %x\n", header);
556                     /* reset free format frame size to give a chance
557                        to get a new bitrate */
558                     s->free_format_frame_size = 0;
559                 } else {
560                     s->frame_size = ret;
561 #if 0
562                     /* free format: prepare to compute frame size */
563                     if (decode_header(s, header) == 1) {
564                         s->frame_size = -1;
565                     }
566 #endif
567                 }
568             }
569         } else 
570 #if 0
571         if (s->frame_size == -1) {
572             /* free format : find next sync to compute frame size */
573             len = MPA_MAX_CODED_FRAME_SIZE - len;
574             if (len > buf_size)
575                 len = buf_size;
576             if (len == 0) {
577                 /* frame too long: resync */
578                 s->frame_size = 0;
579                 memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
580                 s->inbuf_ptr--;
581             } else {
582                 uint8_t *p, *pend;
583                 uint32_t header1;
584                 int padding;
585
586                 memcpy(s->inbuf_ptr, buf_ptr, len);
587                 /* check for header */
588                 p = s->inbuf_ptr - 3;
589                 pend = s->inbuf_ptr + len - 4;
590                 while (p <= pend) {
591                     header = (p[0] << 24) | (p[1] << 16) |
592                         (p[2] << 8) | p[3];
593                     header1 = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
594                         (s->inbuf[2] << 8) | s->inbuf[3];
595                     /* check with high probability that we have a
596                        valid header */
597                     if ((header & SAME_HEADER_MASK) ==
598                         (header1 & SAME_HEADER_MASK)) {
599                         /* header found: update pointers */
600                         len = (p + 4) - s->inbuf_ptr;
601                         buf_ptr += len;
602                         buf_size -= len;
603                         s->inbuf_ptr = p;
604                         /* compute frame size */
605                         s->free_format_next_header = header;
606                         s->free_format_frame_size = s->inbuf_ptr - s->inbuf;
607                         padding = (header1 >> 9) & 1;
608                         if (s->layer == 1)
609                             s->free_format_frame_size -= padding * 4;
610                         else
611                             s->free_format_frame_size -= padding;
612                         dprintf("free frame size=%d padding=%d\n", 
613                                 s->free_format_frame_size, padding);
614                         decode_header(s, header1);
615                         goto next_data;
616                     }
617                     p++;
618                 }
619                 /* not found: simply increase pointers */
620                 buf_ptr += len;
621                 s->inbuf_ptr += len;
622                 buf_size -= len;
623             }
624         } else 
625 #endif
626         if (len < s->frame_size) {
627             if (s->frame_size > MPA_MAX_CODED_FRAME_SIZE)
628                 s->frame_size = MPA_MAX_CODED_FRAME_SIZE;
629             len = s->frame_size - len;
630             if (len > buf_size)
631                 len = buf_size;
632             memcpy(s->inbuf_ptr, buf_ptr, len);
633             buf_ptr += len;
634             s->inbuf_ptr += len;
635             buf_size -= len;
636         }
637         //    next_data:
638         if (s->frame_size > 0 && 
639             (s->inbuf_ptr - s->inbuf) >= s->frame_size) {
640             *poutbuf = s->inbuf;
641             *poutbuf_size = s->inbuf_ptr - s->inbuf;
642             s->inbuf_ptr = s->inbuf;
643             s->frame_size = 0;
644             break;
645         }
646     }
647     return buf_ptr - buf;
648 }
649
650 #ifdef CONFIG_AC3
651 extern int a52_syncinfo (const uint8_t * buf, int * flags,
652                          int * sample_rate, int * bit_rate);
653
654 typedef struct AC3ParseContext {
655     uint8_t inbuf[4096]; /* input buffer */
656     uint8_t *inbuf_ptr;
657     int frame_size;
658     int flags;
659 } AC3ParseContext;
660
661 #define AC3_HEADER_SIZE 7
662 #define A52_LFE 16
663
664 static int ac3_parse_init(AVCodecParserContext *s1)
665 {
666     AC3ParseContext *s = s1->priv_data;
667     s->inbuf_ptr = s->inbuf;
668     return 0;
669 }
670
671 static int ac3_parse(AVCodecParserContext *s1,
672                      AVCodecContext *avctx,
673                      uint8_t **poutbuf, int *poutbuf_size, 
674                      const uint8_t *buf, int buf_size)
675 {
676     AC3ParseContext *s = s1->priv_data;
677     const uint8_t *buf_ptr;
678     int len, sample_rate, bit_rate;
679     static const int ac3_channels[8] = {
680         2, 1, 2, 3, 3, 4, 4, 5
681     };
682
683     *poutbuf = NULL;
684     *poutbuf_size = 0;
685
686     buf_ptr = buf;
687     while (buf_size > 0) {
688         len = s->inbuf_ptr - s->inbuf;
689         if (s->frame_size == 0) {
690             /* no header seen : find one. We need at least 7 bytes to parse it */
691             len = AC3_HEADER_SIZE - len;
692             if (len > buf_size)
693                 len = buf_size;
694             memcpy(s->inbuf_ptr, buf_ptr, len);
695             buf_ptr += len;
696             s->inbuf_ptr += len;
697             buf_size -= len;
698             if ((s->inbuf_ptr - s->inbuf) == AC3_HEADER_SIZE) {
699                 len = a52_syncinfo(s->inbuf, &s->flags, &sample_rate, &bit_rate);
700                 if (len == 0) {
701                     /* no sync found : move by one byte (inefficient, but simple!) */
702                     memmove(s->inbuf, s->inbuf + 1, AC3_HEADER_SIZE - 1);
703                     s->inbuf_ptr--;
704                 } else {
705                     s->frame_size = len;
706                     /* update codec info */
707                     avctx->sample_rate = sample_rate;
708                     /* set channels,except if the user explicitly requests 1 or 2 channels, XXX/FIXME this is a bit ugly */
709                     if(avctx->channels!=1 && avctx->channels!=2){
710                         avctx->channels = ac3_channels[s->flags & 7];
711                         if (s->flags & A52_LFE)
712                             avctx->channels++;
713                     }
714                     avctx->bit_rate = bit_rate;
715                     avctx->frame_size = 6 * 256;
716                 }
717             }
718         } else if (len < s->frame_size) {
719             len = s->frame_size - len;
720             if (len > buf_size)
721                 len = buf_size;
722
723             memcpy(s->inbuf_ptr, buf_ptr, len);
724             buf_ptr += len;
725             s->inbuf_ptr += len;
726             buf_size -= len;
727         } else {
728             *poutbuf = s->inbuf;
729             *poutbuf_size = s->frame_size;
730             s->inbuf_ptr = s->inbuf;
731             s->frame_size = 0;
732             break;
733         }
734     }
735     return buf_ptr - buf;
736 }
737 #endif
738
739 AVCodecParser mpegvideo_parser = {
740     { CODEC_ID_MPEG1VIDEO, CODEC_ID_MPEG2VIDEO },
741     sizeof(ParseContext1),
742     NULL,
743     mpegvideo_parse,
744     parse1_close,
745 };
746
747 AVCodecParser mpeg4video_parser = {
748     { CODEC_ID_MPEG4 },
749     sizeof(ParseContext1),
750     mpeg4video_parse_init,
751     mpeg4video_parse,
752     parse1_close,
753 };
754
755 AVCodecParser mpegaudio_parser = {
756     { CODEC_ID_MP2, CODEC_ID_MP3 },
757     sizeof(MpegAudioParseContext),
758     mpegaudio_parse_init,
759     mpegaudio_parse,
760     NULL,
761 };
762
763 #ifdef CONFIG_AC3
764 AVCodecParser ac3_parser = {
765     { CODEC_ID_AC3 },
766     sizeof(AC3ParseContext),
767     ac3_parse_init,
768     ac3_parse,
769     NULL,
770 };
771 #endif