new audio/video parser API
[libav.git] / libavcodec / parser.c
CommitLineData
8424cf50
FB
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
24AVCodecParser *av_first_parser = NULL;
25
26void av_register_codec_parser(AVCodecParser *parser)
27{
28 parser->next = av_first_parser;
29 av_first_parser = parser;
30}
31
32AVCodecParserContext *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 return s;
64}
65
66int av_parser_parse(AVCodecParserContext *s,
67 AVCodecContext *avctx,
68 uint8_t **poutbuf, int *poutbuf_size,
69 const uint8_t *buf, int buf_size)
70{
71 int index;
72 /* WARNING: the returned index can be negative */
73 index = s->parser->parser_parse(s, avctx, poutbuf, poutbuf_size, buf, buf_size);
74 /* update the file pointer */
75 if (*poutbuf_size) {
76 s->frame_offset = s->last_frame_offset;
77 s->last_frame_offset = s->cur_offset + index;
78 }
79 if (index < 0)
80 index = 0;
81 s->cur_offset += index;
82 return index;
83}
84
85void av_parser_close(AVCodecParserContext *s)
86{
87 if (s->parser->parser_close)
88 s->parser->parser_close(s);
89 av_free(s->priv_data);
90 av_free(s);
91}
92
93/*****************************************************/
94
95//#define END_NOT_FOUND (-100)
96
97#define PICTURE_START_CODE 0x00000100
98#define SEQ_START_CODE 0x000001b3
99#define EXT_START_CODE 0x000001b5
100#define SLICE_MIN_START_CODE 0x00000101
101#define SLICE_MAX_START_CODE 0x000001af
102
103typedef struct ParseContext1{
104 uint8_t *buffer;
105 int index;
106 int last_index;
107 int buffer_size;
108 uint32_t state; ///< contains the last few bytes in MSB order
109 int frame_start_found;
110 int overread; ///< the number of bytes which where irreversibly read from the next frame
111 int overread_index; ///< the index into ParseContext1.buffer of the overreaded bytes
112
113 /* MPEG2 specific */
114 int frame_rate;
115 int progressive_sequence;
116 int width, height;
117 /* XXX: suppress that, needed by MPEG4 */
118 MpegEncContext *enc;
119} ParseContext1;
120
121/**
122 * combines the (truncated) bitstream to a complete frame
123 * @returns -1 if no complete frame could be created
124 */
125static int ff_combine_frame1(ParseContext1 *pc, int next, uint8_t **buf, int *buf_size)
126{
127#if 0
128 if(pc->overread){
129 printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
130 printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
131 }
132#endif
133
134 /* copy overreaded bytes from last frame into buffer */
135 for(; pc->overread>0; pc->overread--){
136 pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
137 }
138
139 pc->last_index= pc->index;
140
141 /* copy into buffer end return */
142 if(next == END_NOT_FOUND){
143 pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
144
145 memcpy(&pc->buffer[pc->index], *buf, *buf_size);
146 pc->index += *buf_size;
147 return -1;
148 }
149
150 *buf_size=
151 pc->overread_index= pc->index + next;
152
153 /* append to buffer */
154 if(pc->index){
155 pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
156
157 memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
158 pc->index = 0;
159 *buf= pc->buffer;
160 }
161
162 /* store overread bytes */
163 for(;next < 0; next++){
164 pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
165 pc->overread++;
166 }
167
168#if 0
169 if(pc->overread){
170 printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
171 printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
172 }
173#endif
174
175 return 0;
176}
177
178/**
179 * finds the end of the current frame in the bitstream.
180 * @return the position of the first byte of the next frame, or -1
181 */
182static int mpeg1_find_frame_end(ParseContext1 *pc, const uint8_t *buf, int buf_size)
183{
184 int i;
185 uint32_t state;
186
187 state= pc->state;
188
189 i=0;
190 if(!pc->frame_start_found){
191 for(i=0; i<buf_size; i++){
192 state= (state<<8) | buf[i];
193 if(state >= SLICE_MIN_START_CODE && state <= SLICE_MAX_START_CODE){
194 i++;
195 pc->frame_start_found=1;
196 break;
197 }
198 }
199 }
200
201 if(pc->frame_start_found){
202 for(; i<buf_size; i++){
203 state= (state<<8) | buf[i];
204 if((state&0xFFFFFF00) == 0x100){
205 if(state < SLICE_MIN_START_CODE || state > SLICE_MAX_START_CODE){
206 pc->frame_start_found=0;
207 pc->state=-1;
208 return i-3;
209 }
210 }
211 }
212 }
213 pc->state= state;
214 return END_NOT_FOUND;
215}
216
217static int find_start_code(const uint8_t **pbuf_ptr, const uint8_t *buf_end)
218{
219 const uint8_t *buf_ptr;
220 unsigned int state=0xFFFFFFFF, v;
221 int val;
222
223 buf_ptr = *pbuf_ptr;
224 while (buf_ptr < buf_end) {
225 v = *buf_ptr++;
226 if (state == 0x000001) {
227 state = ((state << 8) | v) & 0xffffff;
228 val = state;
229 goto found;
230 }
231 state = ((state << 8) | v) & 0xffffff;
232 }
233 val = -1;
234 found:
235 *pbuf_ptr = buf_ptr;
236 return val;
237}
238
239/* XXX: merge with libavcodec ? */
240#define MPEG1_FRAME_RATE_BASE 1001
241
242static const int frame_rate_tab[16] = {
243 0,
244 24000,
245 24024,
246 25025,
247 30000,
248 30030,
249 50050,
250 60000,
251 60060,
252 // Xing's 15fps: (9)
253 15015,
254 // libmpeg3's "Unofficial economy rates": (10-13)
255 5005,
256 10010,
257 12012,
258 15015,
259 // random, just to avoid segfault !never encode these
260 25025,
261 25025,
262};
263
264static void mpegvideo_extract_headers(AVCodecParserContext *s,
265 AVCodecContext *avctx,
266 const uint8_t *buf, int buf_size)
267{
268 ParseContext1 *pc = s->priv_data;
269 const uint8_t *buf_end;
270 int32_t start_code;
271 int frame_rate_index, ext_type, bytes_left;
272 int frame_rate_ext_n, frame_rate_ext_d;
273 int top_field_first, repeat_first_field, progressive_frame;
274 int horiz_size_ext, vert_size_ext;
275
276 s->repeat_pict = 0;
277 buf_end = buf + buf_size;
278 while (buf < buf_end) {
279 start_code = find_start_code(&buf, buf_end);
280 bytes_left = buf_end - buf;
281 switch(start_code) {
282 case PICTURE_START_CODE:
283 if (bytes_left >= 2) {
284 s->pict_type = (buf[1] >> 3) & 7;
285 }
286 break;
287 case SEQ_START_CODE:
288 if (bytes_left >= 4) {
289 pc->width = avctx->width = (buf[0] << 4) | (buf[1] >> 4);
290 pc->height = avctx->height = ((buf[1] & 0x0f) << 8) | buf[2];
291 frame_rate_index = buf[3] & 0xf;
292 pc->frame_rate = avctx->frame_rate = frame_rate_tab[frame_rate_index];
293 avctx->frame_rate_base = MPEG1_FRAME_RATE_BASE;
294 }
295 break;
296 case EXT_START_CODE:
297 if (bytes_left >= 1) {
298 ext_type = (buf[0] >> 4);
299 switch(ext_type) {
300 case 0x1: /* sequence extension */
301 if (bytes_left >= 6) {
302 horiz_size_ext = ((buf[1] & 1) << 1) | (buf[2] >> 7);
303 vert_size_ext = (buf[2] >> 5) & 3;
304 frame_rate_ext_n = (buf[5] >> 5) & 3;
305 frame_rate_ext_d = (buf[5] & 0x1f);
306 pc->progressive_sequence = buf[1] & (1 << 3);
307
308 avctx->width = pc->width | (horiz_size_ext << 12);
309 avctx->height = pc->height | (vert_size_ext << 12);
310 avctx->frame_rate = pc->frame_rate * (frame_rate_ext_n + 1);
311 avctx->frame_rate_base = MPEG1_FRAME_RATE_BASE * (frame_rate_ext_d + 1);
312 avctx->sub_id = 2; /* forces MPEG2 */
313 }
314 break;
315 case 0x8: /* picture coding extension */
316 if (bytes_left >= 5) {
317 top_field_first = buf[3] & (1 << 7);
318 repeat_first_field = buf[3] & (1 << 1);
319 progressive_frame = buf[4] & (1 << 7);
320
321 /* check if we must repeat the frame */
322 if (repeat_first_field) {
323 if (pc->progressive_sequence) {
324 if (top_field_first)
325 s->repeat_pict = 4;
326 else
327 s->repeat_pict = 2;
328 } else if (progressive_frame) {
329 s->repeat_pict = 1;
330 }
331 }
332 }
333 break;
334 }
335 }
336 break;
337 case -1:
338 goto the_end;
339 default:
340 /* we stop parsing when we encounter a slice. It ensures
341 that this function takes a negligible amount of time */
342 if (start_code >= SLICE_MIN_START_CODE &&
343 start_code <= SLICE_MAX_START_CODE)
344 goto the_end;
345 break;
346 }
347 }
348 the_end: ;
349}
350
351static int mpegvideo_parse(AVCodecParserContext *s,
352 AVCodecContext *avctx,
353 uint8_t **poutbuf, int *poutbuf_size,
354 const uint8_t *buf, int buf_size)
355{
356 ParseContext1 *pc = s->priv_data;
357 int next;
358
359 next= mpeg1_find_frame_end(pc, buf, buf_size);
360
361 if (ff_combine_frame1(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
362 *poutbuf = NULL;
363 *poutbuf_size = 0;
364 return buf_size;
365 }
366 /* we have a full frame : we just parse the first few MPEG headers
367 to have the full timing information. The time take by this
368 function should be negligible for uncorrupted streams */
369 mpegvideo_extract_headers(s, avctx, buf, buf_size);
370#if 0
371 printf("pict_type=%d frame_rate=%0.3f repeat_pict=%d\n",
372 s->pict_type, (double)avctx->frame_rate / avctx->frame_rate_base, s->repeat_pict);
373#endif
374
375 *poutbuf = (uint8_t *)buf;
376 *poutbuf_size = buf_size;
377 return next;
378}
379
380static void mpegvideo_parse_close(AVCodecParserContext *s)
381{
382 ParseContext1 *pc = s->priv_data;
383
384 av_free(pc->buffer);
385 av_free(pc->enc);
386}
387
388/*************************/
389
390/**
391 * finds the end of the current frame in the bitstream.
392 * @return the position of the first byte of the next frame, or -1
393 */
394static int mpeg4_find_frame_end(ParseContext1 *pc,
395 const uint8_t *buf, int buf_size)
396{
397 int vop_found, i;
398 uint32_t state;
399
400 vop_found= pc->frame_start_found;
401 state= pc->state;
402
403 i=0;
404 if(!vop_found){
405 for(i=0; i<buf_size; i++){
406 state= (state<<8) | buf[i];
407 if(state == 0x1B6){
408 i++;
409 vop_found=1;
410 break;
411 }
412 }
413 }
414
415 if(vop_found){
416 for(; i<buf_size; i++){
417 state= (state<<8) | buf[i];
418 if((state&0xFFFFFF00) == 0x100){
419 pc->frame_start_found=0;
420 pc->state=-1;
421 return i-3;
422 }
423 }
424 }
425 pc->frame_start_found= vop_found;
426 pc->state= state;
427 return END_NOT_FOUND;
428}
429
430/* used by parser */
431/* XXX: make it use less memory */
432static int av_mpeg4_decode_header(AVCodecParserContext *s1,
433 AVCodecContext *avctx,
434 const uint8_t *buf, int buf_size)
435{
436 ParseContext1 *pc = s1->priv_data;
437 MpegEncContext *s = pc->enc;
438 GetBitContext gb1, *gb = &gb1;
439 int ret;
440
441 s->avctx = avctx;
442 init_get_bits(gb, buf, 8 * buf_size);
443 ret = ff_mpeg4_decode_picture_header(s, gb);
444 if (s->width) {
445 avctx->width = s->width;
446 avctx->height = s->height;
447 }
448 return ret;
449}
450
451int mpeg4video_parse_init(AVCodecParserContext *s)
452{
453 ParseContext1 *pc = s->priv_data;
454 pc->enc = av_mallocz(sizeof(MpegEncContext));
455 if (!pc->enc)
456 return -1;
457 return 0;
458}
459
460static int mpeg4video_parse(AVCodecParserContext *s,
461 AVCodecContext *avctx,
462 uint8_t **poutbuf, int *poutbuf_size,
463 const uint8_t *buf, int buf_size)
464{
465 ParseContext1 *pc = s->priv_data;
466 int next;
467
468 next= mpeg4_find_frame_end(pc, buf, buf_size);
469
470 if (ff_combine_frame1(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
471 *poutbuf = NULL;
472 *poutbuf_size = 0;
473 return buf_size;
474 }
475 av_mpeg4_decode_header(s, avctx, buf, buf_size);
476
477 *poutbuf = (uint8_t *)buf;
478 *poutbuf_size = buf_size;
479 return next;
480}
481
482/*************************/
483
484static int h263_find_frame_end(ParseContext1 *pc, const uint8_t *buf, int buf_size)
485{
486 int vop_found, i;
487 uint32_t state;
488
489 vop_found= pc->frame_start_found;
490 state= pc->state;
491
492 i=0;
493 if(!vop_found){
494 for(i=0; i<buf_size; i++){
495 state= (state<<8) | buf[i];
496 if(state>>(32-22) == 0x20){
497 i++;
498 vop_found=1;
499 break;
500 }
501 }
502 }
503
504 if(vop_found){
505 for(; i<buf_size; i++){
506 state= (state<<8) | buf[i];
507 if(state>>(32-22) == 0x20){
508 pc->frame_start_found=0;
509 pc->state=-1;
510 return i-3;
511 }
512 }
513 }
514 pc->frame_start_found= vop_found;
515 pc->state= state;
516
517 return END_NOT_FOUND;
518}
519
520static int h263_parse(AVCodecParserContext *s,
521 AVCodecContext *avctx,
522 uint8_t **poutbuf, int *poutbuf_size,
523 const uint8_t *buf, int buf_size)
524{
525 ParseContext1 *pc = s->priv_data;
526 int next;
527
528 next= h263_find_frame_end(pc, buf, buf_size);
529
530 if (ff_combine_frame1(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
531 *poutbuf = NULL;
532 *poutbuf_size = 0;
533 return buf_size;
534 }
535
536 *poutbuf = (uint8_t *)buf;
537 *poutbuf_size = buf_size;
538 return next;
539}
540
541/*************************/
542
543/**
544 * finds the end of the current frame in the bitstream.
545 * @return the position of the first byte of the next frame, or -1
546 */
547static int h264_find_frame_end(ParseContext1 *pc, const uint8_t *buf, int buf_size)
548{
549 int i;
550 uint32_t state;
551//printf("first %02X%02X%02X%02X\n", buf[0], buf[1],buf[2],buf[3]);
552// mb_addr= pc->mb_addr - 1;
553 state= pc->state;
554 //FIXME this will fail with slices
555 for(i=0; i<buf_size; i++){
556 state= (state<<8) | buf[i];
557 if((state&0xFFFFFF1F) == 0x101 || (state&0xFFFFFF1F) == 0x102 || (state&0xFFFFFF1F) == 0x105){
558 if(pc->frame_start_found){
559 pc->state=-1;
560 pc->frame_start_found= 0;
561 return i-3;
562 }
563 pc->frame_start_found= 1;
564 }
565 }
566
567 pc->state= state;
568 return END_NOT_FOUND;
569}
570
571static int h264_parse(AVCodecParserContext *s,
572 AVCodecContext *avctx,
573 uint8_t **poutbuf, int *poutbuf_size,
574 const uint8_t *buf, int buf_size)
575{
576 ParseContext1 *pc = s->priv_data;
577 int next;
578
579 next= h264_find_frame_end(pc, buf, buf_size);
580
581 if (ff_combine_frame1(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
582 *poutbuf = NULL;
583 *poutbuf_size = 0;
584 return buf_size;
585 }
586
587 *poutbuf = (uint8_t *)buf;
588 *poutbuf_size = buf_size;
589 return next;
590}
591
592/*************************/
593
594typedef struct MpegAudioParseContext {
595 uint8_t inbuf[MPA_MAX_CODED_FRAME_SIZE]; /* input buffer */
596 uint8_t *inbuf_ptr;
597 int frame_size;
598 int free_format_frame_size;
599 int free_format_next_header;
600} MpegAudioParseContext;
601
602#define MPA_HEADER_SIZE 4
603
604/* header + layer + bitrate + freq + lsf/mpeg25 */
605#define SAME_HEADER_MASK \
606 (0xffe00000 | (3 << 17) | (0xf << 12) | (3 << 10) | (3 << 19))
607
608static int mpegaudio_parse_init(AVCodecParserContext *s1)
609{
610 MpegAudioParseContext *s = s1->priv_data;
611 s->inbuf_ptr = s->inbuf;
612 return 0;
613}
614
615static int mpegaudio_parse(AVCodecParserContext *s1,
616 AVCodecContext *avctx,
617 uint8_t **poutbuf, int *poutbuf_size,
618 const uint8_t *buf, int buf_size)
619{
620 MpegAudioParseContext *s = s1->priv_data;
621 int len, ret;
622 uint32_t header;
623 const uint8_t *buf_ptr;
624
625 *poutbuf = NULL;
626 *poutbuf_size = 0;
627 buf_ptr = buf;
628 while (buf_size > 0) {
629 len = s->inbuf_ptr - s->inbuf;
630 if (s->frame_size == 0) {
631 /* special case for next header for first frame in free
632 format case (XXX: find a simpler method) */
633 if (s->free_format_next_header != 0) {
634 s->inbuf[0] = s->free_format_next_header >> 24;
635 s->inbuf[1] = s->free_format_next_header >> 16;
636 s->inbuf[2] = s->free_format_next_header >> 8;
637 s->inbuf[3] = s->free_format_next_header;
638 s->inbuf_ptr = s->inbuf + 4;
639 s->free_format_next_header = 0;
640 goto got_header;
641 }
642 /* no header seen : find one. We need at least MPA_HEADER_SIZE
643 bytes to parse it */
644 len = MPA_HEADER_SIZE - len;
645 if (len > buf_size)
646 len = buf_size;
647 if (len > 0) {
648 memcpy(s->inbuf_ptr, buf_ptr, len);
649 buf_ptr += len;
650 buf_size -= len;
651 s->inbuf_ptr += len;
652 }
653 if ((s->inbuf_ptr - s->inbuf) >= MPA_HEADER_SIZE) {
654 got_header:
655 header = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
656 (s->inbuf[2] << 8) | s->inbuf[3];
657
658 ret = mpa_decode_header(avctx, header);
659 if (ret < 0) {
660 /* no sync found : move by one byte (inefficient, but simple!) */
661 memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
662 s->inbuf_ptr--;
663 dprintf("skip %x\n", header);
664 /* reset free format frame size to give a chance
665 to get a new bitrate */
666 s->free_format_frame_size = 0;
667 } else {
668 s->frame_size = ret;
669#if 0
670 /* free format: prepare to compute frame size */
671 if (decode_header(s, header) == 1) {
672 s->frame_size = -1;
673 }
674#endif
675 }
676 }
677 } else
678#if 0
679 if (s->frame_size == -1) {
680 /* free format : find next sync to compute frame size */
681 len = MPA_MAX_CODED_FRAME_SIZE - len;
682 if (len > buf_size)
683 len = buf_size;
684 if (len == 0) {
685 /* frame too long: resync */
686 s->frame_size = 0;
687 memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
688 s->inbuf_ptr--;
689 } else {
690 uint8_t *p, *pend;
691 uint32_t header1;
692 int padding;
693
694 memcpy(s->inbuf_ptr, buf_ptr, len);
695 /* check for header */
696 p = s->inbuf_ptr - 3;
697 pend = s->inbuf_ptr + len - 4;
698 while (p <= pend) {
699 header = (p[0] << 24) | (p[1] << 16) |
700 (p[2] << 8) | p[3];
701 header1 = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
702 (s->inbuf[2] << 8) | s->inbuf[3];
703 /* check with high probability that we have a
704 valid header */
705 if ((header & SAME_HEADER_MASK) ==
706 (header1 & SAME_HEADER_MASK)) {
707 /* header found: update pointers */
708 len = (p + 4) - s->inbuf_ptr;
709 buf_ptr += len;
710 buf_size -= len;
711 s->inbuf_ptr = p;
712 /* compute frame size */
713 s->free_format_next_header = header;
714 s->free_format_frame_size = s->inbuf_ptr - s->inbuf;
715 padding = (header1 >> 9) & 1;
716 if (s->layer == 1)
717 s->free_format_frame_size -= padding * 4;
718 else
719 s->free_format_frame_size -= padding;
720 dprintf("free frame size=%d padding=%d\n",
721 s->free_format_frame_size, padding);
722 decode_header(s, header1);
723 goto next_data;
724 }
725 p++;
726 }
727 /* not found: simply increase pointers */
728 buf_ptr += len;
729 s->inbuf_ptr += len;
730 buf_size -= len;
731 }
732 } else
733#endif
734 if (len < s->frame_size) {
735 if (s->frame_size > MPA_MAX_CODED_FRAME_SIZE)
736 s->frame_size = MPA_MAX_CODED_FRAME_SIZE;
737 len = s->frame_size - len;
738 if (len > buf_size)
739 len = buf_size;
740 memcpy(s->inbuf_ptr, buf_ptr, len);
741 buf_ptr += len;
742 s->inbuf_ptr += len;
743 buf_size -= len;
744 }
745 // next_data:
746 if (s->frame_size > 0 &&
747 (s->inbuf_ptr - s->inbuf) >= s->frame_size) {
748 *poutbuf = s->inbuf;
749 *poutbuf_size = s->inbuf_ptr - s->inbuf;
750 s->inbuf_ptr = s->inbuf;
751 s->frame_size = 0;
752 break;
753 }
754 }
755 return buf_ptr - buf;
756}
757
758#ifdef CONFIG_AC3
759extern int a52_syncinfo (const uint8_t * buf, int * flags,
760 int * sample_rate, int * bit_rate);
761
762typedef struct AC3ParseContext {
763 uint8_t inbuf[4096]; /* input buffer */
764 uint8_t *inbuf_ptr;
765 int frame_size;
766 int flags;
767} AC3ParseContext;
768
769#define AC3_HEADER_SIZE 7
770#define A52_LFE 16
771
772static int ac3_parse_init(AVCodecParserContext *s1)
773{
774 AC3ParseContext *s = s1->priv_data;
775 s->inbuf_ptr = s->inbuf;
776 return 0;
777}
778
779static int ac3_parse(AVCodecParserContext *s1,
780 AVCodecContext *avctx,
781 uint8_t **poutbuf, int *poutbuf_size,
782 const uint8_t *buf, int buf_size)
783{
784 AC3ParseContext *s = s1->priv_data;
785 const uint8_t *buf_ptr;
786 int len, sample_rate, bit_rate;
787 static const int ac3_channels[8] = {
788 2, 1, 2, 3, 3, 4, 4, 5
789 };
790
791 *poutbuf = NULL;
792 *poutbuf_size = 0;
793
794 buf_ptr = buf;
795 while (buf_size > 0) {
796 len = s->inbuf_ptr - s->inbuf;
797 if (s->frame_size == 0) {
798 /* no header seen : find one. We need at least 7 bytes to parse it */
799 len = AC3_HEADER_SIZE - len;
800 if (len > buf_size)
801 len = buf_size;
802 memcpy(s->inbuf_ptr, buf_ptr, len);
803 buf_ptr += len;
804 s->inbuf_ptr += len;
805 buf_size -= len;
806 if ((s->inbuf_ptr - s->inbuf) == AC3_HEADER_SIZE) {
807 len = a52_syncinfo(s->inbuf, &s->flags, &sample_rate, &bit_rate);
808 if (len == 0) {
809 /* no sync found : move by one byte (inefficient, but simple!) */
810 memmove(s->inbuf, s->inbuf + 1, AC3_HEADER_SIZE - 1);
811 s->inbuf_ptr--;
812 } else {
813 s->frame_size = len;
814 /* update codec info */
815 avctx->sample_rate = sample_rate;
816 avctx->channels = ac3_channels[s->flags & 7];
817 if (s->flags & A52_LFE)
818 avctx->channels++;
819 avctx->bit_rate = bit_rate;
820 avctx->frame_size = 6 * 256;
821 }
822 }
823 } else if (len < s->frame_size) {
824 len = s->frame_size - len;
825 if (len > buf_size)
826 len = buf_size;
827
828 memcpy(s->inbuf_ptr, buf_ptr, len);
829 buf_ptr += len;
830 s->inbuf_ptr += len;
831 buf_size -= len;
832 } else {
833 *poutbuf = s->inbuf;
834 *poutbuf_size = s->frame_size;
835 s->inbuf_ptr = s->inbuf;
836 s->frame_size = 0;
837 break;
838 }
839 }
840 return buf_ptr - buf;
841}
842#endif
843
844AVCodecParser mpegvideo_parser = {
845 { CODEC_ID_MPEG1VIDEO, CODEC_ID_MPEG2VIDEO },
846 sizeof(ParseContext1),
847 NULL,
848 mpegvideo_parse,
849 mpegvideo_parse_close,
850};
851
852AVCodecParser mpeg4video_parser = {
853 { CODEC_ID_MPEG4 },
854 sizeof(ParseContext1),
855 mpeg4video_parse_init,
856 mpeg4video_parse,
857 mpegvideo_parse_close,
858};
859
860AVCodecParser h263_parser = {
861 { CODEC_ID_H263 },
862 sizeof(ParseContext1),
863 NULL,
864 h263_parse,
865 mpegvideo_parse_close,
866};
867
868AVCodecParser h264_parser = {
869 { CODEC_ID_H264 },
870 sizeof(ParseContext1),
871 NULL,
872 h264_parse,
873 mpegvideo_parse_close,
874};
875
876AVCodecParser mpegaudio_parser = {
877 { CODEC_ID_MP2, CODEC_ID_MP3 },
878 sizeof(MpegAudioParseContext),
879 mpegaudio_parse_init,
880 mpegaudio_parse,
881 NULL,
882};
883
884#ifdef CONFIG_AC3
885AVCodecParser ac3_parser = {
886 { CODEC_ID_AC3 },
887 sizeof(AC3ParseContext),
888 ac3_parse_init,
889 ac3_parse,
890 NULL,
891};
892#endif