2 * Audio and Video frame extraction
3 * Copyright (c) 2003 Fabrice Bellard.
4 * Copyright (c) 2003 Michael Niedermayer.
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.
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.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 #include "mpegvideo.h"
22 #include "mpegaudio.h"
24 AVCodecParser *av_first_parser = NULL;
26 void av_register_codec_parser(AVCodecParser *parser)
28 parser->next = av_first_parser;
29 av_first_parser = parser;
32 AVCodecParserContext *av_parser_init(int codec_id)
34 AVCodecParserContext *s;
35 AVCodecParser *parser;
38 if(codec_id == CODEC_ID_NONE)
41 for(parser = av_first_parser; parser != NULL; parser = parser->next) {
42 if (parser->codec_ids[0] == codec_id ||
43 parser->codec_ids[1] == codec_id ||
44 parser->codec_ids[2] == codec_id ||
45 parser->codec_ids[3] == codec_id ||
46 parser->codec_ids[4] == codec_id)
51 s = av_mallocz(sizeof(AVCodecParserContext));
55 s->priv_data = av_mallocz(parser->priv_data_size);
60 if (parser->parser_init) {
61 ret = parser->parser_init(s);
63 av_free(s->priv_data);
72 /* NOTE: buf_size == 0 is used to signal EOF so that the last frame
73 can be returned if necessary */
74 int av_parser_parse(AVCodecParserContext *s,
75 AVCodecContext *avctx,
76 uint8_t **poutbuf, int *poutbuf_size,
77 const uint8_t *buf, int buf_size,
78 int64_t pts, int64_t dts)
81 uint8_t dummy_buf[FF_INPUT_BUFFER_PADDING_SIZE];
84 /* padding is always necessary even if EOF, so we add it here */
85 memset(dummy_buf, 0, sizeof(dummy_buf));
88 /* add a new packet descriptor */
89 k = (s->cur_frame_start_index + 1) & (AV_PARSER_PTS_NB - 1);
90 s->cur_frame_start_index = k;
91 s->cur_frame_offset[k] = s->cur_offset;
92 s->cur_frame_pts[k] = pts;
93 s->cur_frame_dts[k] = dts;
95 /* fill first PTS/DTS */
96 if (s->fetch_timestamp){
100 s->cur_frame_pts[k] =
101 s->cur_frame_dts[k] = AV_NOPTS_VALUE;
105 /* WARNING: the returned index can be negative */
106 index = s->parser->parser_parse(s, avctx, poutbuf, poutbuf_size, buf, buf_size);
107 //av_log(NULL, AV_LOG_DEBUG, "parser: in:%lld, %lld, out:%lld, %lld, in:%d out:%d id:%d\n", pts, dts, s->last_pts, s->last_dts, buf_size, *poutbuf_size, avctx->codec_id);
108 /* update the file pointer */
110 /* fill the data for the current frame */
111 s->frame_offset = s->last_frame_offset;
112 s->pts = s->last_pts;
113 s->dts = s->last_dts;
115 /* offset of the next frame */
116 s->last_frame_offset = s->cur_offset + index;
117 /* find the packet in which the new frame starts. It
118 is tricky because of MPEG video start codes
119 which can begin in one packet and finish in
120 another packet. In the worst case, an MPEG
121 video start code could be in 4 different
123 k = s->cur_frame_start_index;
124 for(i = 0; i < AV_PARSER_PTS_NB; i++) {
125 if (s->last_frame_offset >= s->cur_frame_offset[k])
127 k = (k - 1) & (AV_PARSER_PTS_NB - 1);
130 s->last_pts = s->cur_frame_pts[k];
131 s->last_dts = s->cur_frame_dts[k];
133 /* some parsers tell us the packet size even before seeing the first byte of the next packet,
134 so the next pts/dts is in the next chunk */
135 if(index == buf_size){
136 s->fetch_timestamp=1;
141 s->cur_offset += index;
147 * @return 0 if the output buffer is a subset of the input, 1 if it is allocated and must be freed
148 * @deprecated use AVBitstreamFilter
150 int av_parser_change(AVCodecParserContext *s,
151 AVCodecContext *avctx,
152 uint8_t **poutbuf, int *poutbuf_size,
153 const uint8_t *buf, int buf_size, int keyframe){
155 if(s && s->parser->split){
156 if((avctx->flags & CODEC_FLAG_GLOBAL_HEADER) || (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER)){
157 int i= s->parser->split(avctx, buf, buf_size);
163 /* cast to avoid warning about discarding qualifiers */
164 *poutbuf= (uint8_t *) buf;
165 *poutbuf_size= buf_size;
166 if(avctx->extradata){
167 if( (keyframe && (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER))
168 /*||(s->pict_type != I_TYPE && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_NOKEY))*/
169 /*||(? && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_BEGIN)*/){
170 int size= buf_size + avctx->extradata_size;
172 *poutbuf= av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
174 memcpy(*poutbuf, avctx->extradata, avctx->extradata_size);
175 memcpy((*poutbuf) + avctx->extradata_size, buf, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
183 void av_parser_close(AVCodecParserContext *s)
185 if (s->parser->parser_close)
186 s->parser->parser_close(s);
187 av_free(s->priv_data);
191 /*****************************************************/
193 //#define END_NOT_FOUND (-100)
195 #define PICTURE_START_CODE 0x00000100
196 #define SEQ_START_CODE 0x000001b3
197 #define EXT_START_CODE 0x000001b5
198 #define SLICE_MIN_START_CODE 0x00000101
199 #define SLICE_MAX_START_CODE 0x000001af
201 typedef struct ParseContext1{
203 /* XXX/FIXME PC1 vs. PC */
206 int progressive_sequence;
209 /* XXX: suppress that, needed by MPEG4 */
215 * combines the (truncated) bitstream to a complete frame
216 * @returns -1 if no complete frame could be created
218 int ff_combine_frame(ParseContext *pc, int next, uint8_t **buf, int *buf_size)
222 printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
223 printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
227 /* copy overreaded bytes from last frame into buffer */
228 for(; pc->overread>0; pc->overread--){
229 pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
232 /* flush remaining if EOF */
233 if(!*buf_size && next == END_NOT_FOUND){
237 pc->last_index= pc->index;
239 /* copy into buffer end return */
240 if(next == END_NOT_FOUND){
241 pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
243 memcpy(&pc->buffer[pc->index], *buf, *buf_size);
244 pc->index += *buf_size;
249 pc->overread_index= pc->index + next;
251 /* append to buffer */
253 pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
255 memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
260 /* store overread bytes */
261 for(;next < 0; next++){
262 pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
268 printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
269 printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
276 /* XXX: merge with libavcodec ? */
277 #define MPEG1_FRAME_RATE_BASE 1001
279 static const int frame_rate_tab[16] = {
291 // libmpeg3's "Unofficial economy rates": (10-13)
296 // random, just to avoid segfault !never encode these
301 //FIXME move into mpeg12.c
302 static void mpegvideo_extract_headers(AVCodecParserContext *s,
303 AVCodecContext *avctx,
304 const uint8_t *buf, int buf_size)
306 ParseContext1 *pc = s->priv_data;
307 const uint8_t *buf_end;
309 int frame_rate_index, ext_type, bytes_left;
310 int frame_rate_ext_n, frame_rate_ext_d;
311 int picture_structure, top_field_first, repeat_first_field, progressive_frame;
312 int horiz_size_ext, vert_size_ext, bit_rate_ext;
313 //FIXME replace the crap with get_bits()
315 buf_end = buf + buf_size;
316 while (buf < buf_end) {
318 buf= ff_find_start_code(buf, buf_end, &start_code);
319 bytes_left = buf_end - buf;
321 case PICTURE_START_CODE:
322 if (bytes_left >= 2) {
323 s->pict_type = (buf[1] >> 3) & 7;
327 if (bytes_left >= 7) {
328 pc->width = (buf[0] << 4) | (buf[1] >> 4);
329 pc->height = ((buf[1] & 0x0f) << 8) | buf[2];
330 avcodec_set_dimensions(avctx, pc->width, pc->height);
331 frame_rate_index = buf[3] & 0xf;
332 pc->frame_rate = avctx->time_base.den = frame_rate_tab[frame_rate_index];
333 avctx->time_base.num = MPEG1_FRAME_RATE_BASE;
334 avctx->bit_rate = ((buf[4]<<10) | (buf[5]<<2) | (buf[6]>>6))*400;
335 avctx->codec_id = CODEC_ID_MPEG1VIDEO;
340 if (bytes_left >= 1) {
341 ext_type = (buf[0] >> 4);
343 case 0x1: /* sequence extension */
344 if (bytes_left >= 6) {
345 horiz_size_ext = ((buf[1] & 1) << 1) | (buf[2] >> 7);
346 vert_size_ext = (buf[2] >> 5) & 3;
347 bit_rate_ext = ((buf[2] & 0x1F)<<7) | (buf[3]>>1);
348 frame_rate_ext_n = (buf[5] >> 5) & 3;
349 frame_rate_ext_d = (buf[5] & 0x1f);
350 pc->progressive_sequence = buf[1] & (1 << 3);
351 avctx->has_b_frames= !(buf[5] >> 7);
353 pc->width |=(horiz_size_ext << 12);
354 pc->height |=( vert_size_ext << 12);
355 avctx->bit_rate += (bit_rate_ext << 18) * 400;
356 avcodec_set_dimensions(avctx, pc->width, pc->height);
357 avctx->time_base.den = pc->frame_rate * (frame_rate_ext_n + 1);
358 avctx->time_base.num = MPEG1_FRAME_RATE_BASE * (frame_rate_ext_d + 1);
359 avctx->codec_id = CODEC_ID_MPEG2VIDEO;
360 avctx->sub_id = 2; /* forces MPEG2 */
363 case 0x8: /* picture coding extension */
364 if (bytes_left >= 5) {
365 picture_structure = buf[2]&3;
366 top_field_first = buf[3] & (1 << 7);
367 repeat_first_field = buf[3] & (1 << 1);
368 progressive_frame = buf[4] & (1 << 7);
370 /* check if we must repeat the frame */
371 if (repeat_first_field) {
372 if (pc->progressive_sequence) {
377 } else if (progressive_frame) {
382 /* the packet only represents half a frame
383 XXX,FIXME maybe find a different solution */
384 if(picture_structure != 3)
394 /* we stop parsing when we encounter a slice. It ensures
395 that this function takes a negligible amount of time */
396 if (start_code >= SLICE_MIN_START_CODE &&
397 start_code <= SLICE_MAX_START_CODE)
405 static int mpegvideo_parse(AVCodecParserContext *s,
406 AVCodecContext *avctx,
407 uint8_t **poutbuf, int *poutbuf_size,
408 const uint8_t *buf, int buf_size)
410 ParseContext1 *pc1 = s->priv_data;
411 ParseContext *pc= &pc1->pc;
414 if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
417 next= ff_mpeg1_find_frame_end(pc, buf, buf_size);
419 if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
426 /* we have a full frame : we just parse the first few MPEG headers
427 to have the full timing information. The time take by this
428 function should be negligible for uncorrupted streams */
429 mpegvideo_extract_headers(s, avctx, buf, buf_size);
431 printf("pict_type=%d frame_rate=%0.3f repeat_pict=%d\n",
432 s->pict_type, (double)avctx->time_base.den / avctx->time_base.num, s->repeat_pict);
435 *poutbuf = (uint8_t *)buf;
436 *poutbuf_size = buf_size;
440 static int mpegvideo_split(AVCodecContext *avctx,
441 const uint8_t *buf, int buf_size)
446 for(i=0; i<buf_size; i++){
447 state= (state<<8) | buf[i];
448 if(state != 0x1B3 && state != 0x1B5 && state < 0x200 && state >= 0x100)
454 void ff_parse_close(AVCodecParserContext *s)
456 ParseContext *pc = s->priv_data;
461 static void parse1_close(AVCodecParserContext *s)
463 ParseContext1 *pc1 = s->priv_data;
465 av_free(pc1->pc.buffer);
469 /*************************/
472 /* XXX: make it use less memory */
473 static int av_mpeg4_decode_header(AVCodecParserContext *s1,
474 AVCodecContext *avctx,
475 const uint8_t *buf, int buf_size)
477 ParseContext1 *pc = s1->priv_data;
478 MpegEncContext *s = pc->enc;
479 GetBitContext gb1, *gb = &gb1;
483 s->current_picture_ptr = &s->current_picture;
485 if (avctx->extradata_size && pc->first_picture){
486 init_get_bits(gb, avctx->extradata, avctx->extradata_size*8);
487 ret = ff_mpeg4_decode_picture_header(s, gb);
490 init_get_bits(gb, buf, 8 * buf_size);
491 ret = ff_mpeg4_decode_picture_header(s, gb);
493 avcodec_set_dimensions(avctx, s->width, s->height);
495 s1->pict_type= s->pict_type;
496 pc->first_picture = 0;
500 static int mpeg4video_parse_init(AVCodecParserContext *s)
502 ParseContext1 *pc = s->priv_data;
504 pc->enc = av_mallocz(sizeof(MpegEncContext));
507 pc->first_picture = 1;
511 static int mpeg4video_parse(AVCodecParserContext *s,
512 AVCodecContext *avctx,
513 uint8_t **poutbuf, int *poutbuf_size,
514 const uint8_t *buf, int buf_size)
516 ParseContext *pc = s->priv_data;
519 if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
522 next= ff_mpeg4_find_frame_end(pc, buf, buf_size);
524 if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
530 av_mpeg4_decode_header(s, avctx, buf, buf_size);
532 *poutbuf = (uint8_t *)buf;
533 *poutbuf_size = buf_size;
537 static int cavsvideo_parse(AVCodecParserContext *s,
538 AVCodecContext *avctx,
539 uint8_t **poutbuf, int *poutbuf_size,
540 const uint8_t *buf, int buf_size)
542 ParseContext *pc = s->priv_data;
545 if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
548 next= ff_cavs_find_frame_end(pc, buf, buf_size);
550 if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
556 *poutbuf = (uint8_t *)buf;
557 *poutbuf_size = buf_size;
561 static int mpeg4video_split(AVCodecContext *avctx,
562 const uint8_t *buf, int buf_size)
567 for(i=0; i<buf_size; i++){
568 state= (state<<8) | buf[i];
569 if(state == 0x1B3 || state == 0x1B6)
575 /*************************/
577 typedef struct MpegAudioParseContext {
578 uint8_t inbuf[MPA_MAX_CODED_FRAME_SIZE]; /* input buffer */
581 int free_format_frame_size;
582 int free_format_next_header;
585 } MpegAudioParseContext;
587 #define MPA_HEADER_SIZE 4
589 /* header + layer + bitrate + freq + lsf/mpeg25 */
590 #undef SAME_HEADER_MASK /* mpegaudio.h defines different version */
591 #define SAME_HEADER_MASK \
592 (0xffe00000 | (3 << 17) | (3 << 10) | (3 << 19))
594 static int mpegaudio_parse_init(AVCodecParserContext *s1)
596 MpegAudioParseContext *s = s1->priv_data;
597 s->inbuf_ptr = s->inbuf;
601 static int mpegaudio_parse(AVCodecParserContext *s1,
602 AVCodecContext *avctx,
603 uint8_t **poutbuf, int *poutbuf_size,
604 const uint8_t *buf, int buf_size)
606 MpegAudioParseContext *s = s1->priv_data;
609 const uint8_t *buf_ptr;
614 while (buf_size > 0) {
615 len = s->inbuf_ptr - s->inbuf;
616 if (s->frame_size == 0) {
617 /* special case for next header for first frame in free
618 format case (XXX: find a simpler method) */
619 if (s->free_format_next_header != 0) {
620 s->inbuf[0] = s->free_format_next_header >> 24;
621 s->inbuf[1] = s->free_format_next_header >> 16;
622 s->inbuf[2] = s->free_format_next_header >> 8;
623 s->inbuf[3] = s->free_format_next_header;
624 s->inbuf_ptr = s->inbuf + 4;
625 s->free_format_next_header = 0;
628 /* no header seen : find one. We need at least MPA_HEADER_SIZE
630 len = MPA_HEADER_SIZE - len;
634 memcpy(s->inbuf_ptr, buf_ptr, len);
639 if ((s->inbuf_ptr - s->inbuf) >= MPA_HEADER_SIZE) {
641 sr= avctx->sample_rate;
642 header = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
643 (s->inbuf[2] << 8) | s->inbuf[3];
645 ret = mpa_decode_header(avctx, header);
648 /* no sync found : move by one byte (inefficient, but simple!) */
649 memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
651 dprintf("skip %x\n", header);
652 /* reset free format frame size to give a chance
653 to get a new bitrate */
654 s->free_format_frame_size = 0;
656 if((header&SAME_HEADER_MASK) != (s->header&SAME_HEADER_MASK) && s->header)
663 /* free format: prepare to compute frame size */
664 if (decode_header(s, header) == 1) {
669 if(s->header_count <= 0)
670 avctx->sample_rate= sr; //FIXME ugly
674 if (s->frame_size == -1) {
675 /* free format : find next sync to compute frame size */
676 len = MPA_MAX_CODED_FRAME_SIZE - len;
680 /* frame too long: resync */
682 memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
689 memcpy(s->inbuf_ptr, buf_ptr, len);
690 /* check for header */
691 p = s->inbuf_ptr - 3;
692 pend = s->inbuf_ptr + len - 4;
694 header = (p[0] << 24) | (p[1] << 16) |
696 header1 = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
697 (s->inbuf[2] << 8) | s->inbuf[3];
698 /* check with high probability that we have a
700 if ((header & SAME_HEADER_MASK) ==
701 (header1 & SAME_HEADER_MASK)) {
702 /* header found: update pointers */
703 len = (p + 4) - s->inbuf_ptr;
707 /* compute frame size */
708 s->free_format_next_header = header;
709 s->free_format_frame_size = s->inbuf_ptr - s->inbuf;
710 padding = (header1 >> 9) & 1;
712 s->free_format_frame_size -= padding * 4;
714 s->free_format_frame_size -= padding;
715 dprintf("free frame size=%d padding=%d\n",
716 s->free_format_frame_size, padding);
717 decode_header(s, header1);
722 /* not found: simply increase pointers */
729 if (len < s->frame_size) {
730 if (s->frame_size > MPA_MAX_CODED_FRAME_SIZE)
731 s->frame_size = MPA_MAX_CODED_FRAME_SIZE;
732 len = s->frame_size - len;
735 memcpy(s->inbuf_ptr, buf_ptr, len);
741 if (s->frame_size > 0 &&
742 (s->inbuf_ptr - s->inbuf) >= s->frame_size) {
743 if(s->header_count > 0){
745 *poutbuf_size = s->inbuf_ptr - s->inbuf;
747 s->inbuf_ptr = s->inbuf;
752 return buf_ptr - buf;
755 /* also used for ADTS AAC */
756 typedef struct AC3ParseContext {
760 int (*sync)(const uint8_t *buf, int *channels, int *sample_rate,
761 int *bit_rate, int *samples);
762 uint8_t inbuf[8192]; /* input buffer */
765 #define AC3_HEADER_SIZE 7
766 #define AAC_HEADER_SIZE 7
768 static const int ac3_sample_rates[4] = {
769 48000, 44100, 32000, 0
772 static const int ac3_frame_sizes[64][3] = {
805 { 1024, 1114, 1536 },
806 { 1024, 1115, 1536 },
807 { 1152, 1253, 1728 },
808 { 1152, 1254, 1728 },
809 { 1280, 1393, 1920 },
810 { 1280, 1394, 1920 },
813 static const int ac3_bitrates[64] = {
814 32, 32, 40, 40, 48, 48, 56, 56, 64, 64, 80, 80, 96, 96, 112, 112,
815 128, 128, 160, 160, 192, 192, 224, 224, 256, 256, 320, 320, 384,
816 384, 448, 448, 512, 512, 576, 576, 640, 640,
819 static const int ac3_channels[8] = {
820 2, 1, 2, 3, 3, 4, 4, 5
823 static int aac_sample_rates[16] = {
824 96000, 88200, 64000, 48000, 44100, 32000,
825 24000, 22050, 16000, 12000, 11025, 8000, 7350
828 static int aac_channels[8] = {
829 0, 1, 2, 3, 4, 5, 6, 8
832 static int ac3_sync(const uint8_t *buf, int *channels, int *sample_rate,
833 int *bit_rate, int *samples)
835 unsigned int fscod, frmsizecod, acmod, bsid, lfeon;
838 init_get_bits(&bits, buf, AC3_HEADER_SIZE * 8);
840 if(get_bits(&bits, 16) != 0x0b77)
843 skip_bits(&bits, 16); /* crc */
844 fscod = get_bits(&bits, 2);
845 frmsizecod = get_bits(&bits, 6);
847 if(!ac3_sample_rates[fscod])
850 bsid = get_bits(&bits, 5);
853 skip_bits(&bits, 3); /* bsmod */
854 acmod = get_bits(&bits, 3);
855 if(acmod & 1 && acmod != 1)
856 skip_bits(&bits, 2); /* cmixlev */
858 skip_bits(&bits, 2); /* surmixlev */
860 skip_bits(&bits, 2); /* dsurmod */
861 lfeon = get_bits1(&bits);
863 *sample_rate = ac3_sample_rates[fscod];
864 *bit_rate = ac3_bitrates[frmsizecod] * 1000;
865 *channels = ac3_channels[acmod] + lfeon;
868 return ac3_frame_sizes[frmsizecod][fscod] * 2;
871 static int aac_sync(const uint8_t *buf, int *channels, int *sample_rate,
872 int *bit_rate, int *samples)
875 int size, rdb, ch, sr;
877 init_get_bits(&bits, buf, AAC_HEADER_SIZE * 8);
879 if(get_bits(&bits, 12) != 0xfff)
882 skip_bits1(&bits); /* id */
883 skip_bits(&bits, 2); /* layer */
884 skip_bits1(&bits); /* protection_absent */
885 skip_bits(&bits, 2); /* profile_objecttype */
886 sr = get_bits(&bits, 4); /* sample_frequency_index */
887 if(!aac_sample_rates[sr])
889 skip_bits1(&bits); /* private_bit */
890 ch = get_bits(&bits, 3); /* channel_configuration */
891 if(!aac_channels[ch])
893 skip_bits1(&bits); /* original/copy */
894 skip_bits1(&bits); /* home */
896 /* adts_variable_header */
897 skip_bits1(&bits); /* copyright_identification_bit */
898 skip_bits1(&bits); /* copyright_identification_start */
899 size = get_bits(&bits, 13); /* aac_frame_length */
900 skip_bits(&bits, 11); /* adts_buffer_fullness */
901 rdb = get_bits(&bits, 2); /* number_of_raw_data_blocks_in_frame */
903 *channels = aac_channels[ch];
904 *sample_rate = aac_sample_rates[sr];
905 *samples = (rdb + 1) * 1024;
906 *bit_rate = size * 8 * *sample_rate / *samples;
911 static int ac3_parse_init(AVCodecParserContext *s1)
913 AC3ParseContext *s = s1->priv_data;
914 s->inbuf_ptr = s->inbuf;
915 s->header_size = AC3_HEADER_SIZE;
920 static int aac_parse_init(AVCodecParserContext *s1)
922 AC3ParseContext *s = s1->priv_data;
923 s->inbuf_ptr = s->inbuf;
924 s->header_size = AAC_HEADER_SIZE;
929 /* also used for ADTS AAC */
930 static int ac3_parse(AVCodecParserContext *s1,
931 AVCodecContext *avctx,
932 uint8_t **poutbuf, int *poutbuf_size,
933 const uint8_t *buf, int buf_size)
935 AC3ParseContext *s = s1->priv_data;
936 const uint8_t *buf_ptr;
937 int len, sample_rate, bit_rate, channels, samples;
943 while (buf_size > 0) {
944 len = s->inbuf_ptr - s->inbuf;
945 if (s->frame_size == 0) {
946 /* no header seen : find one. We need at least s->header_size
948 len = FFMIN(s->header_size - len, buf_size);
950 memcpy(s->inbuf_ptr, buf_ptr, len);
954 if ((s->inbuf_ptr - s->inbuf) == s->header_size) {
955 len = s->sync(s->inbuf, &channels, &sample_rate, &bit_rate,
958 /* no sync found : move by one byte (inefficient, but simple!) */
959 memmove(s->inbuf, s->inbuf + 1, s->header_size - 1);
963 /* update codec info */
964 avctx->sample_rate = sample_rate;
965 /* set channels,except if the user explicitly requests 1 or 2 channels, XXX/FIXME this is a bit ugly */
966 if(avctx->codec_id == CODEC_ID_AC3){
967 if(avctx->channels!=1 && avctx->channels!=2){
968 avctx->channels = channels;
971 avctx->channels = channels;
973 avctx->bit_rate = bit_rate;
974 avctx->frame_size = samples;
978 len = FFMIN(s->frame_size - len, buf_size);
980 memcpy(s->inbuf_ptr, buf_ptr, len);
985 if(s->inbuf_ptr - s->inbuf == s->frame_size){
987 *poutbuf_size = s->frame_size;
988 s->inbuf_ptr = s->inbuf;
994 return buf_ptr - buf;
997 AVCodecParser mpegvideo_parser = {
998 { CODEC_ID_MPEG1VIDEO, CODEC_ID_MPEG2VIDEO },
999 sizeof(ParseContext1),
1006 AVCodecParser mpeg4video_parser = {
1008 sizeof(ParseContext1),
1009 mpeg4video_parse_init,
1015 AVCodecParser cavsvideo_parser = {
1017 sizeof(ParseContext1),
1024 AVCodecParser mpegaudio_parser = {
1025 { CODEC_ID_MP2, CODEC_ID_MP3 },
1026 sizeof(MpegAudioParseContext),
1027 mpegaudio_parse_init,
1032 AVCodecParser ac3_parser = {
1034 sizeof(AC3ParseContext),
1040 AVCodecParser aac_parser = {
1042 sizeof(AC3ParseContext),