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