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
149 int av_parser_change(AVCodecParserContext *s,
150 AVCodecContext *avctx,
151 uint8_t **poutbuf, int *poutbuf_size,
152 const uint8_t *buf, int buf_size, int keyframe){
154 if(s && s->parser->split){
155 if((avctx->flags & CODEC_FLAG_GLOBAL_HEADER) || (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER)){
156 int i= s->parser->split(avctx, buf, buf_size);
162 /* cast to avoid warning about discarding qualifiers */
163 *poutbuf= (uint8_t *) buf;
164 *poutbuf_size= buf_size;
165 if(avctx->extradata){
166 if( (keyframe && (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER))
167 /*||(s->pict_type != I_TYPE && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_NOKEY))*/
168 /*||(? && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_BEGIN)*/){
169 int size= buf_size + avctx->extradata_size;
171 *poutbuf= av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
173 memcpy(*poutbuf, avctx->extradata, avctx->extradata_size);
174 memcpy((*poutbuf) + avctx->extradata_size, buf, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
182 void av_parser_close(AVCodecParserContext *s)
184 if (s->parser->parser_close)
185 s->parser->parser_close(s);
186 av_free(s->priv_data);
190 /*****************************************************/
192 //#define END_NOT_FOUND (-100)
194 #define PICTURE_START_CODE 0x00000100
195 #define SEQ_START_CODE 0x000001b3
196 #define EXT_START_CODE 0x000001b5
197 #define SLICE_MIN_START_CODE 0x00000101
198 #define SLICE_MAX_START_CODE 0x000001af
200 typedef struct ParseContext1{
202 /* XXX/FIXME PC1 vs. PC */
205 int progressive_sequence;
208 /* XXX: suppress that, needed by MPEG4 */
214 * combines the (truncated) bitstream to a complete frame
215 * @returns -1 if no complete frame could be created
217 int ff_combine_frame(ParseContext *pc, int next, uint8_t **buf, int *buf_size)
221 printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
222 printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
226 /* copy overreaded bytes from last frame into buffer */
227 for(; pc->overread>0; pc->overread--){
228 pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
231 /* flush remaining if EOF */
232 if(!*buf_size && next == END_NOT_FOUND){
236 pc->last_index= pc->index;
238 /* copy into buffer end return */
239 if(next == END_NOT_FOUND){
240 pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
242 memcpy(&pc->buffer[pc->index], *buf, *buf_size);
243 pc->index += *buf_size;
248 pc->overread_index= pc->index + next;
250 /* append to buffer */
252 pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
254 memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
259 /* store overread bytes */
260 for(;next < 0; next++){
261 pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
267 printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
268 printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
275 /* XXX: merge with libavcodec ? */
276 #define MPEG1_FRAME_RATE_BASE 1001
278 static const int frame_rate_tab[16] = {
290 // libmpeg3's "Unofficial economy rates": (10-13)
295 // random, just to avoid segfault !never encode these
300 //FIXME move into mpeg12.c
301 static void mpegvideo_extract_headers(AVCodecParserContext *s,
302 AVCodecContext *avctx,
303 const uint8_t *buf, int buf_size)
305 ParseContext1 *pc = s->priv_data;
306 const uint8_t *buf_end;
308 int frame_rate_index, ext_type, bytes_left;
309 int frame_rate_ext_n, frame_rate_ext_d;
310 int picture_structure, top_field_first, repeat_first_field, progressive_frame;
311 int horiz_size_ext, vert_size_ext, bit_rate_ext;
312 //FIXME replace the crap with get_bits()
314 buf_end = buf + buf_size;
315 while (buf < buf_end) {
317 buf= ff_find_start_code(buf, buf_end, &start_code);
318 bytes_left = buf_end - buf;
320 case PICTURE_START_CODE:
321 if (bytes_left >= 2) {
322 s->pict_type = (buf[1] >> 3) & 7;
326 if (bytes_left >= 7) {
327 pc->width = (buf[0] << 4) | (buf[1] >> 4);
328 pc->height = ((buf[1] & 0x0f) << 8) | buf[2];
329 avcodec_set_dimensions(avctx, pc->width, pc->height);
330 frame_rate_index = buf[3] & 0xf;
331 pc->frame_rate = avctx->time_base.den = frame_rate_tab[frame_rate_index];
332 avctx->time_base.num = MPEG1_FRAME_RATE_BASE;
333 avctx->bit_rate = ((buf[4]<<10) | (buf[5]<<2) | (buf[6]>>6))*400;
334 avctx->codec_id = CODEC_ID_MPEG1VIDEO;
339 if (bytes_left >= 1) {
340 ext_type = (buf[0] >> 4);
342 case 0x1: /* sequence extension */
343 if (bytes_left >= 6) {
344 horiz_size_ext = ((buf[1] & 1) << 1) | (buf[2] >> 7);
345 vert_size_ext = (buf[2] >> 5) & 3;
346 bit_rate_ext = ((buf[2] & 0x1F)<<7) | (buf[3]>>1);
347 frame_rate_ext_n = (buf[5] >> 5) & 3;
348 frame_rate_ext_d = (buf[5] & 0x1f);
349 pc->progressive_sequence = buf[1] & (1 << 3);
350 avctx->has_b_frames= !(buf[5] >> 7);
352 pc->width |=(horiz_size_ext << 12);
353 pc->height |=( vert_size_ext << 12);
354 avctx->bit_rate += (bit_rate_ext << 18) * 400;
355 avcodec_set_dimensions(avctx, pc->width, pc->height);
356 avctx->time_base.den = pc->frame_rate * (frame_rate_ext_n + 1);
357 avctx->time_base.num = MPEG1_FRAME_RATE_BASE * (frame_rate_ext_d + 1);
358 avctx->codec_id = CODEC_ID_MPEG2VIDEO;
359 avctx->sub_id = 2; /* forces MPEG2 */
362 case 0x8: /* picture coding extension */
363 if (bytes_left >= 5) {
364 picture_structure = buf[2]&3;
365 top_field_first = buf[3] & (1 << 7);
366 repeat_first_field = buf[3] & (1 << 1);
367 progressive_frame = buf[4] & (1 << 7);
369 /* check if we must repeat the frame */
370 if (repeat_first_field) {
371 if (pc->progressive_sequence) {
376 } else if (progressive_frame) {
381 /* the packet only represents half a frame
382 XXX,FIXME maybe find a different solution */
383 if(picture_structure != 3)
393 /* we stop parsing when we encounter a slice. It ensures
394 that this function takes a negligible amount of time */
395 if (start_code >= SLICE_MIN_START_CODE &&
396 start_code <= SLICE_MAX_START_CODE)
404 static int mpegvideo_parse(AVCodecParserContext *s,
405 AVCodecContext *avctx,
406 uint8_t **poutbuf, int *poutbuf_size,
407 const uint8_t *buf, int buf_size)
409 ParseContext1 *pc1 = s->priv_data;
410 ParseContext *pc= &pc1->pc;
413 if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
416 next= ff_mpeg1_find_frame_end(pc, buf, buf_size);
418 if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
425 /* we have a full frame : we just parse the first few MPEG headers
426 to have the full timing information. The time take by this
427 function should be negligible for uncorrupted streams */
428 mpegvideo_extract_headers(s, avctx, buf, buf_size);
430 printf("pict_type=%d frame_rate=%0.3f repeat_pict=%d\n",
431 s->pict_type, (double)avctx->time_base.den / avctx->time_base.num, s->repeat_pict);
434 *poutbuf = (uint8_t *)buf;
435 *poutbuf_size = buf_size;
439 static int mpegvideo_split(AVCodecContext *avctx,
440 const uint8_t *buf, int buf_size)
445 for(i=0; i<buf_size; i++){
446 state= (state<<8) | buf[i];
447 if(state != 0x1B3 && state != 0x1B5 && state < 0x200 && state >= 0x100)
453 void ff_parse_close(AVCodecParserContext *s)
455 ParseContext *pc = s->priv_data;
460 static void parse1_close(AVCodecParserContext *s)
462 ParseContext1 *pc1 = s->priv_data;
464 av_free(pc1->pc.buffer);
468 /*************************/
471 /* XXX: make it use less memory */
472 static int av_mpeg4_decode_header(AVCodecParserContext *s1,
473 AVCodecContext *avctx,
474 const uint8_t *buf, int buf_size)
476 ParseContext1 *pc = s1->priv_data;
477 MpegEncContext *s = pc->enc;
478 GetBitContext gb1, *gb = &gb1;
482 s->current_picture_ptr = &s->current_picture;
484 if (avctx->extradata_size && pc->first_picture){
485 init_get_bits(gb, avctx->extradata, avctx->extradata_size*8);
486 ret = ff_mpeg4_decode_picture_header(s, gb);
489 init_get_bits(gb, buf, 8 * buf_size);
490 ret = ff_mpeg4_decode_picture_header(s, gb);
492 avcodec_set_dimensions(avctx, s->width, s->height);
494 s1->pict_type= s->pict_type;
495 pc->first_picture = 0;
499 static int mpeg4video_parse_init(AVCodecParserContext *s)
501 ParseContext1 *pc = s->priv_data;
503 pc->enc = av_mallocz(sizeof(MpegEncContext));
506 pc->first_picture = 1;
510 static int mpeg4video_parse(AVCodecParserContext *s,
511 AVCodecContext *avctx,
512 uint8_t **poutbuf, int *poutbuf_size,
513 const uint8_t *buf, int buf_size)
515 ParseContext *pc = s->priv_data;
518 if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
521 next= ff_mpeg4_find_frame_end(pc, buf, buf_size);
523 if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
529 av_mpeg4_decode_header(s, avctx, buf, buf_size);
531 *poutbuf = (uint8_t *)buf;
532 *poutbuf_size = buf_size;
536 static int mpeg4video_split(AVCodecContext *avctx,
537 const uint8_t *buf, int buf_size)
542 for(i=0; i<buf_size; i++){
543 state= (state<<8) | buf[i];
544 if(state == 0x1B3 || state == 0x1B6)
550 /*************************/
552 typedef struct MpegAudioParseContext {
553 uint8_t inbuf[MPA_MAX_CODED_FRAME_SIZE]; /* input buffer */
556 int free_format_frame_size;
557 int free_format_next_header;
560 } MpegAudioParseContext;
562 #define MPA_HEADER_SIZE 4
564 /* header + layer + bitrate + freq + lsf/mpeg25 */
565 #undef SAME_HEADER_MASK /* mpegaudio.h defines different version */
566 #define SAME_HEADER_MASK \
567 (0xffe00000 | (3 << 17) | (3 << 10) | (3 << 19))
569 static int mpegaudio_parse_init(AVCodecParserContext *s1)
571 MpegAudioParseContext *s = s1->priv_data;
572 s->inbuf_ptr = s->inbuf;
576 static int mpegaudio_parse(AVCodecParserContext *s1,
577 AVCodecContext *avctx,
578 uint8_t **poutbuf, int *poutbuf_size,
579 const uint8_t *buf, int buf_size)
581 MpegAudioParseContext *s = s1->priv_data;
584 const uint8_t *buf_ptr;
589 while (buf_size > 0) {
590 len = s->inbuf_ptr - s->inbuf;
591 if (s->frame_size == 0) {
592 /* special case for next header for first frame in free
593 format case (XXX: find a simpler method) */
594 if (s->free_format_next_header != 0) {
595 s->inbuf[0] = s->free_format_next_header >> 24;
596 s->inbuf[1] = s->free_format_next_header >> 16;
597 s->inbuf[2] = s->free_format_next_header >> 8;
598 s->inbuf[3] = s->free_format_next_header;
599 s->inbuf_ptr = s->inbuf + 4;
600 s->free_format_next_header = 0;
603 /* no header seen : find one. We need at least MPA_HEADER_SIZE
605 len = MPA_HEADER_SIZE - len;
609 memcpy(s->inbuf_ptr, buf_ptr, len);
614 if ((s->inbuf_ptr - s->inbuf) >= MPA_HEADER_SIZE) {
616 sr= avctx->sample_rate;
617 header = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
618 (s->inbuf[2] << 8) | s->inbuf[3];
620 ret = mpa_decode_header(avctx, header);
623 /* no sync found : move by one byte (inefficient, but simple!) */
624 memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
626 dprintf("skip %x\n", header);
627 /* reset free format frame size to give a chance
628 to get a new bitrate */
629 s->free_format_frame_size = 0;
631 if((header&SAME_HEADER_MASK) != (s->header&SAME_HEADER_MASK) && s->header)
638 /* free format: prepare to compute frame size */
639 if (decode_header(s, header) == 1) {
644 if(s->header_count <= 0)
645 avctx->sample_rate= sr; //FIXME ugly
649 if (s->frame_size == -1) {
650 /* free format : find next sync to compute frame size */
651 len = MPA_MAX_CODED_FRAME_SIZE - len;
655 /* frame too long: resync */
657 memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
664 memcpy(s->inbuf_ptr, buf_ptr, len);
665 /* check for header */
666 p = s->inbuf_ptr - 3;
667 pend = s->inbuf_ptr + len - 4;
669 header = (p[0] << 24) | (p[1] << 16) |
671 header1 = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
672 (s->inbuf[2] << 8) | s->inbuf[3];
673 /* check with high probability that we have a
675 if ((header & SAME_HEADER_MASK) ==
676 (header1 & SAME_HEADER_MASK)) {
677 /* header found: update pointers */
678 len = (p + 4) - s->inbuf_ptr;
682 /* compute frame size */
683 s->free_format_next_header = header;
684 s->free_format_frame_size = s->inbuf_ptr - s->inbuf;
685 padding = (header1 >> 9) & 1;
687 s->free_format_frame_size -= padding * 4;
689 s->free_format_frame_size -= padding;
690 dprintf("free frame size=%d padding=%d\n",
691 s->free_format_frame_size, padding);
692 decode_header(s, header1);
697 /* not found: simply increase pointers */
704 if (len < s->frame_size) {
705 if (s->frame_size > MPA_MAX_CODED_FRAME_SIZE)
706 s->frame_size = MPA_MAX_CODED_FRAME_SIZE;
707 len = s->frame_size - len;
710 memcpy(s->inbuf_ptr, buf_ptr, len);
716 if (s->frame_size > 0 &&
717 (s->inbuf_ptr - s->inbuf) >= s->frame_size) {
718 if(s->header_count > 0){
720 *poutbuf_size = s->inbuf_ptr - s->inbuf;
722 s->inbuf_ptr = s->inbuf;
727 return buf_ptr - buf;
730 /* also used for ADTS AAC */
731 typedef struct AC3ParseContext {
735 int (*sync)(const uint8_t *buf, int *channels, int *sample_rate,
736 int *bit_rate, int *samples);
737 uint8_t inbuf[8192]; /* input buffer */
740 #define AC3_HEADER_SIZE 7
741 #define AAC_HEADER_SIZE 7
743 static const int ac3_sample_rates[4] = {
744 48000, 44100, 32000, 0
747 static const int ac3_frame_sizes[64][3] = {
780 { 1024, 1114, 1536 },
781 { 1024, 1115, 1536 },
782 { 1152, 1253, 1728 },
783 { 1152, 1254, 1728 },
784 { 1280, 1393, 1920 },
785 { 1280, 1394, 1920 },
788 static const int ac3_bitrates[64] = {
789 32, 32, 40, 40, 48, 48, 56, 56, 64, 64, 80, 80, 96, 96, 112, 112,
790 128, 128, 160, 160, 192, 192, 224, 224, 256, 256, 320, 320, 384,
791 384, 448, 448, 512, 512, 576, 576, 640, 640,
794 static const int ac3_channels[8] = {
795 2, 1, 2, 3, 3, 4, 4, 5
798 static int aac_sample_rates[16] = {
799 96000, 88200, 64000, 48000, 44100, 32000,
800 24000, 22050, 16000, 12000, 11025, 8000, 7350
803 static int aac_channels[8] = {
804 0, 1, 2, 3, 4, 5, 6, 8
807 static int ac3_sync(const uint8_t *buf, int *channels, int *sample_rate,
808 int *bit_rate, int *samples)
810 unsigned int fscod, frmsizecod, acmod, bsid, lfeon;
813 init_get_bits(&bits, buf, AC3_HEADER_SIZE * 8);
815 if(get_bits(&bits, 16) != 0x0b77)
818 skip_bits(&bits, 16); /* crc */
819 fscod = get_bits(&bits, 2);
820 frmsizecod = get_bits(&bits, 6);
822 if(!ac3_sample_rates[fscod])
825 bsid = get_bits(&bits, 5);
828 skip_bits(&bits, 3); /* bsmod */
829 acmod = get_bits(&bits, 3);
830 if(acmod & 1 && acmod != 1)
831 skip_bits(&bits, 2); /* cmixlev */
833 skip_bits(&bits, 2); /* surmixlev */
835 skip_bits(&bits, 2); /* dsurmod */
836 lfeon = get_bits1(&bits);
838 *sample_rate = ac3_sample_rates[fscod];
839 *bit_rate = ac3_bitrates[frmsizecod] * 1000;
840 *channels = ac3_channels[acmod] + lfeon;
843 return ac3_frame_sizes[frmsizecod][fscod] * 2;
846 static int aac_sync(const uint8_t *buf, int *channels, int *sample_rate,
847 int *bit_rate, int *samples)
850 int size, rdb, ch, sr;
852 init_get_bits(&bits, buf, AAC_HEADER_SIZE * 8);
854 if(get_bits(&bits, 12) != 0xfff)
857 skip_bits1(&bits); /* id */
858 skip_bits(&bits, 2); /* layer */
859 skip_bits1(&bits); /* protection_absent */
860 skip_bits(&bits, 2); /* profile_objecttype */
861 sr = get_bits(&bits, 4); /* sample_frequency_index */
862 if(!aac_sample_rates[sr])
864 skip_bits1(&bits); /* private_bit */
865 ch = get_bits(&bits, 3); /* channel_configuration */
866 if(!aac_channels[ch])
868 skip_bits1(&bits); /* original/copy */
869 skip_bits1(&bits); /* home */
871 /* adts_variable_header */
872 skip_bits1(&bits); /* copyright_identification_bit */
873 skip_bits1(&bits); /* copyright_identification_start */
874 size = get_bits(&bits, 13); /* aac_frame_length */
875 skip_bits(&bits, 11); /* adts_buffer_fullness */
876 rdb = get_bits(&bits, 2); /* number_of_raw_data_blocks_in_frame */
878 *channels = aac_channels[ch];
879 *sample_rate = aac_sample_rates[sr];
880 *samples = (rdb + 1) * 1024;
881 *bit_rate = size * 8 * *sample_rate / *samples;
886 static int ac3_parse_init(AVCodecParserContext *s1)
888 AC3ParseContext *s = s1->priv_data;
889 s->inbuf_ptr = s->inbuf;
890 s->header_size = AC3_HEADER_SIZE;
895 static int aac_parse_init(AVCodecParserContext *s1)
897 AC3ParseContext *s = s1->priv_data;
898 s->inbuf_ptr = s->inbuf;
899 s->header_size = AAC_HEADER_SIZE;
904 /* also used for ADTS AAC */
905 static int ac3_parse(AVCodecParserContext *s1,
906 AVCodecContext *avctx,
907 uint8_t **poutbuf, int *poutbuf_size,
908 const uint8_t *buf, int buf_size)
910 AC3ParseContext *s = s1->priv_data;
911 const uint8_t *buf_ptr;
912 int len, sample_rate, bit_rate, channels, samples;
918 while (buf_size > 0) {
919 len = s->inbuf_ptr - s->inbuf;
920 if (s->frame_size == 0) {
921 /* no header seen : find one. We need at least s->header_size
923 len = FFMIN(s->header_size - len, buf_size);
925 memcpy(s->inbuf_ptr, buf_ptr, len);
929 if ((s->inbuf_ptr - s->inbuf) == s->header_size) {
930 len = s->sync(s->inbuf, &channels, &sample_rate, &bit_rate,
933 /* no sync found : move by one byte (inefficient, but simple!) */
934 memmove(s->inbuf, s->inbuf + 1, s->header_size - 1);
938 /* update codec info */
939 avctx->sample_rate = sample_rate;
940 /* set channels,except if the user explicitly requests 1 or 2 channels, XXX/FIXME this is a bit ugly */
941 if(avctx->codec_id == CODEC_ID_AC3){
942 if(avctx->channels!=1 && avctx->channels!=2){
943 avctx->channels = channels;
946 avctx->channels = channels;
948 avctx->bit_rate = bit_rate;
949 avctx->frame_size = samples;
953 len = FFMIN(s->frame_size - len, buf_size);
955 memcpy(s->inbuf_ptr, buf_ptr, len);
960 if(s->inbuf_ptr - s->inbuf == s->frame_size){
962 *poutbuf_size = s->frame_size;
963 s->inbuf_ptr = s->inbuf;
969 return buf_ptr - buf;
972 AVCodecParser mpegvideo_parser = {
973 { CODEC_ID_MPEG1VIDEO, CODEC_ID_MPEG2VIDEO },
974 sizeof(ParseContext1),
981 AVCodecParser mpeg4video_parser = {
983 sizeof(ParseContext1),
984 mpeg4video_parse_init,
990 AVCodecParser mpegaudio_parser = {
991 { CODEC_ID_MP2, CODEC_ID_MP3 },
992 sizeof(MpegAudioParseContext),
993 mpegaudio_parse_init,
998 AVCodecParser ac3_parser = {
1000 sizeof(AC3ParseContext),
1006 AVCodecParser aac_parser = {
1008 sizeof(AC3ParseContext),