2 * Audio and Video frame extraction
3 * Copyright (c) 2003 Fabrice Bellard.
4 * Copyright (c) 2003 Michael Niedermayer.
6 * This file is part of FFmpeg.
8 * FFmpeg is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * FFmpeg is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with FFmpeg; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 #include "mpegvideo.h"
24 #include "mpegaudio.h"
27 AVCodecParser *av_first_parser = NULL;
29 void av_register_codec_parser(AVCodecParser *parser)
31 parser->next = av_first_parser;
32 av_first_parser = parser;
35 AVCodecParserContext *av_parser_init(int codec_id)
37 AVCodecParserContext *s;
38 AVCodecParser *parser;
41 if(codec_id == CODEC_ID_NONE)
44 for(parser = av_first_parser; parser != NULL; parser = parser->next) {
45 if (parser->codec_ids[0] == codec_id ||
46 parser->codec_ids[1] == codec_id ||
47 parser->codec_ids[2] == codec_id ||
48 parser->codec_ids[3] == codec_id ||
49 parser->codec_ids[4] == codec_id)
54 s = av_mallocz(sizeof(AVCodecParserContext));
58 s->priv_data = av_mallocz(parser->priv_data_size);
63 if (parser->parser_init) {
64 ret = parser->parser_init(s);
66 av_free(s->priv_data);
78 * @param buf_size input length, to signal EOF, this should be 0 (so that the last frame can be output)
79 * @param pts input presentation timestamp
80 * @param dts input decoding timestamp
81 * @param poutbuf will contain a pointer to the first byte of the output frame
82 * @param poutbuf_size will contain the length of the output frame
83 * @return the number of bytes of the input bitstream used
88 * len = av_parser_parse(myparser, AVCodecContext, &data, &size,
94 * decode_frame(data, size);
98 int av_parser_parse(AVCodecParserContext *s,
99 AVCodecContext *avctx,
100 uint8_t **poutbuf, int *poutbuf_size,
101 const uint8_t *buf, int buf_size,
102 int64_t pts, int64_t dts)
105 uint8_t dummy_buf[FF_INPUT_BUFFER_PADDING_SIZE];
108 /* padding is always necessary even if EOF, so we add it here */
109 memset(dummy_buf, 0, sizeof(dummy_buf));
112 /* add a new packet descriptor */
113 k = (s->cur_frame_start_index + 1) & (AV_PARSER_PTS_NB - 1);
114 s->cur_frame_start_index = k;
115 s->cur_frame_offset[k] = s->cur_offset;
116 s->cur_frame_pts[k] = pts;
117 s->cur_frame_dts[k] = dts;
119 /* fill first PTS/DTS */
120 if (s->fetch_timestamp){
121 s->fetch_timestamp=0;
124 s->cur_frame_pts[k] =
125 s->cur_frame_dts[k] = AV_NOPTS_VALUE;
129 /* WARNING: the returned index can be negative */
130 index = s->parser->parser_parse(s, avctx, poutbuf, poutbuf_size, buf, buf_size);
131 //av_log(NULL, AV_LOG_DEBUG, "parser: in:%"PRId64", %"PRId64", out:%"PRId64", %"PRId64", in:%d out:%d id:%d\n", pts, dts, s->last_pts, s->last_dts, buf_size, *poutbuf_size, avctx->codec_id);
132 /* update the file pointer */
134 /* fill the data for the current frame */
135 s->frame_offset = s->last_frame_offset;
136 s->pts = s->last_pts;
137 s->dts = s->last_dts;
139 /* offset of the next frame */
140 s->last_frame_offset = s->cur_offset + index;
141 /* find the packet in which the new frame starts. It
142 is tricky because of MPEG video start codes
143 which can begin in one packet and finish in
144 another packet. In the worst case, an MPEG
145 video start code could be in 4 different
147 k = s->cur_frame_start_index;
148 for(i = 0; i < AV_PARSER_PTS_NB; i++) {
149 if (s->last_frame_offset >= s->cur_frame_offset[k])
151 k = (k - 1) & (AV_PARSER_PTS_NB - 1);
154 s->last_pts = s->cur_frame_pts[k];
155 s->last_dts = s->cur_frame_dts[k];
157 /* some parsers tell us the packet size even before seeing the first byte of the next packet,
158 so the next pts/dts is in the next chunk */
159 if(index == buf_size){
160 s->fetch_timestamp=1;
165 s->cur_offset += index;
171 * @return 0 if the output buffer is a subset of the input, 1 if it is allocated and must be freed
172 * @deprecated use AVBitstreamFilter
174 int av_parser_change(AVCodecParserContext *s,
175 AVCodecContext *avctx,
176 uint8_t **poutbuf, int *poutbuf_size,
177 const uint8_t *buf, int buf_size, int keyframe){
179 if(s && s->parser->split){
180 if((avctx->flags & CODEC_FLAG_GLOBAL_HEADER) || (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER)){
181 int i= s->parser->split(avctx, buf, buf_size);
187 /* cast to avoid warning about discarding qualifiers */
188 *poutbuf= (uint8_t *) buf;
189 *poutbuf_size= buf_size;
190 if(avctx->extradata){
191 if( (keyframe && (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER))
192 /*||(s->pict_type != I_TYPE && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_NOKEY))*/
193 /*||(? && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_BEGIN)*/){
194 int size= buf_size + avctx->extradata_size;
196 *poutbuf= av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
198 memcpy(*poutbuf, avctx->extradata, avctx->extradata_size);
199 memcpy((*poutbuf) + avctx->extradata_size, buf, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
207 void av_parser_close(AVCodecParserContext *s)
209 if (s->parser->parser_close)
210 s->parser->parser_close(s);
211 av_free(s->priv_data);
215 /*****************************************************/
218 * combines the (truncated) bitstream to a complete frame
219 * @returns -1 if no complete frame could be created
221 int ff_combine_frame(ParseContext *pc, int next, uint8_t **buf, int *buf_size)
225 printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
226 printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
230 /* copy overreaded bytes from last frame into buffer */
231 for(; pc->overread>0; pc->overread--){
232 pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
235 /* flush remaining if EOF */
236 if(!*buf_size && next == END_NOT_FOUND){
240 pc->last_index= pc->index;
242 /* copy into buffer end return */
243 if(next == END_NOT_FOUND){
244 pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
246 memcpy(&pc->buffer[pc->index], *buf, *buf_size);
247 pc->index += *buf_size;
252 pc->overread_index= pc->index + next;
254 /* append to buffer */
256 pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
258 memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
263 /* store overread bytes */
264 for(;next < 0; next++){
265 pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
271 printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
272 printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
279 void ff_parse_close(AVCodecParserContext *s)
281 ParseContext *pc = s->priv_data;
286 void ff_parse1_close(AVCodecParserContext *s)
288 ParseContext1 *pc1 = s->priv_data;
290 av_free(pc1->pc.buffer);
294 /*************************/
296 #ifdef CONFIG_MPEG4VIDEO_PARSER
298 /* XXX: make it use less memory */
299 static int av_mpeg4_decode_header(AVCodecParserContext *s1,
300 AVCodecContext *avctx,
301 const uint8_t *buf, int buf_size)
303 ParseContext1 *pc = s1->priv_data;
304 MpegEncContext *s = pc->enc;
305 GetBitContext gb1, *gb = &gb1;
309 s->current_picture_ptr = &s->current_picture;
311 if (avctx->extradata_size && pc->first_picture){
312 init_get_bits(gb, avctx->extradata, avctx->extradata_size*8);
313 ret = ff_mpeg4_decode_picture_header(s, gb);
316 init_get_bits(gb, buf, 8 * buf_size);
317 ret = ff_mpeg4_decode_picture_header(s, gb);
319 avcodec_set_dimensions(avctx, s->width, s->height);
321 s1->pict_type= s->pict_type;
322 pc->first_picture = 0;
326 static int mpeg4video_parse_init(AVCodecParserContext *s)
328 ParseContext1 *pc = s->priv_data;
330 pc->enc = av_mallocz(sizeof(MpegEncContext));
333 pc->first_picture = 1;
337 static int mpeg4video_parse(AVCodecParserContext *s,
338 AVCodecContext *avctx,
339 uint8_t **poutbuf, int *poutbuf_size,
340 const uint8_t *buf, int buf_size)
342 ParseContext *pc = s->priv_data;
345 if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
348 next= ff_mpeg4_find_frame_end(pc, buf, buf_size);
350 if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
356 av_mpeg4_decode_header(s, avctx, buf, buf_size);
358 *poutbuf = (uint8_t *)buf;
359 *poutbuf_size = buf_size;
364 int ff_mpeg4video_split(AVCodecContext *avctx,
365 const uint8_t *buf, int buf_size)
370 for(i=0; i<buf_size; i++){
371 state= (state<<8) | buf[i];
372 if(state == 0x1B3 || state == 0x1B6)
378 /*************************/
380 #ifdef CONFIG_MPEGAUDIO_PARSER
381 typedef struct MpegAudioParseContext {
382 uint8_t inbuf[MPA_MAX_CODED_FRAME_SIZE]; /* input buffer */
385 int free_format_frame_size;
386 int free_format_next_header;
389 } MpegAudioParseContext;
391 #define MPA_HEADER_SIZE 4
393 /* header + layer + bitrate + freq + lsf/mpeg25 */
394 #undef SAME_HEADER_MASK /* mpegaudio.h defines different version */
395 #define SAME_HEADER_MASK \
396 (0xffe00000 | (3 << 17) | (3 << 10) | (3 << 19))
398 static int mpegaudio_parse_init(AVCodecParserContext *s1)
400 MpegAudioParseContext *s = s1->priv_data;
401 s->inbuf_ptr = s->inbuf;
405 static int mpegaudio_parse(AVCodecParserContext *s1,
406 AVCodecContext *avctx,
407 uint8_t **poutbuf, int *poutbuf_size,
408 const uint8_t *buf, int buf_size)
410 MpegAudioParseContext *s = s1->priv_data;
413 const uint8_t *buf_ptr;
418 while (buf_size > 0) {
419 len = s->inbuf_ptr - s->inbuf;
420 if (s->frame_size == 0) {
421 /* special case for next header for first frame in free
422 format case (XXX: find a simpler method) */
423 if (s->free_format_next_header != 0) {
424 s->inbuf[0] = s->free_format_next_header >> 24;
425 s->inbuf[1] = s->free_format_next_header >> 16;
426 s->inbuf[2] = s->free_format_next_header >> 8;
427 s->inbuf[3] = s->free_format_next_header;
428 s->inbuf_ptr = s->inbuf + 4;
429 s->free_format_next_header = 0;
432 /* no header seen : find one. We need at least MPA_HEADER_SIZE
434 len = FFMIN(MPA_HEADER_SIZE - len, buf_size);
436 memcpy(s->inbuf_ptr, buf_ptr, len);
441 if ((s->inbuf_ptr - s->inbuf) >= MPA_HEADER_SIZE) {
443 header = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
444 (s->inbuf[2] << 8) | s->inbuf[3];
446 ret = mpa_decode_header(avctx, header, &sr);
449 /* no sync found : move by one byte (inefficient, but simple!) */
450 memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
452 dprintf("skip %x\n", header);
453 /* reset free format frame size to give a chance
454 to get a new bitrate */
455 s->free_format_frame_size = 0;
457 if((header&SAME_HEADER_MASK) != (s->header&SAME_HEADER_MASK) && s->header)
464 /* free format: prepare to compute frame size */
465 if (decode_header(s, header) == 1) {
470 if(s->header_count > 1)
471 avctx->sample_rate= sr;
475 if (s->frame_size == -1) {
476 /* free format : find next sync to compute frame size */
477 len = MPA_MAX_CODED_FRAME_SIZE - len;
481 /* frame too long: resync */
483 memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
490 memcpy(s->inbuf_ptr, buf_ptr, len);
491 /* check for header */
492 p = s->inbuf_ptr - 3;
493 pend = s->inbuf_ptr + len - 4;
495 header = (p[0] << 24) | (p[1] << 16) |
497 header1 = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
498 (s->inbuf[2] << 8) | s->inbuf[3];
499 /* check with high probability that we have a
501 if ((header & SAME_HEADER_MASK) ==
502 (header1 & SAME_HEADER_MASK)) {
503 /* header found: update pointers */
504 len = (p + 4) - s->inbuf_ptr;
508 /* compute frame size */
509 s->free_format_next_header = header;
510 s->free_format_frame_size = s->inbuf_ptr - s->inbuf;
511 padding = (header1 >> 9) & 1;
513 s->free_format_frame_size -= padding * 4;
515 s->free_format_frame_size -= padding;
516 dprintf("free frame size=%d padding=%d\n",
517 s->free_format_frame_size, padding);
518 decode_header(s, header1);
523 /* not found: simply increase pointers */
530 if (len < s->frame_size) {
531 if (s->frame_size > MPA_MAX_CODED_FRAME_SIZE)
532 s->frame_size = MPA_MAX_CODED_FRAME_SIZE;
533 len = FFMIN(s->frame_size - len, buf_size);
534 memcpy(s->inbuf_ptr, buf_ptr, len);
540 if(s->frame_size > 0 && buf_ptr - buf == s->inbuf_ptr - s->inbuf
541 && buf_size + buf_ptr - buf >= s->frame_size){
542 if(s->header_count > 0){
544 *poutbuf_size = s->frame_size;
546 buf_ptr = buf + s->frame_size;
547 s->inbuf_ptr = s->inbuf;
553 if (s->frame_size > 0 &&
554 (s->inbuf_ptr - s->inbuf) >= s->frame_size) {
555 if(s->header_count > 0){
557 *poutbuf_size = s->inbuf_ptr - s->inbuf;
559 s->inbuf_ptr = s->inbuf;
564 return buf_ptr - buf;
566 #endif /* CONFIG_MPEGAUDIO_PARSER */
568 #if defined(CONFIG_AC3_PARSER) || defined(CONFIG_AAC_PARSER)
569 /* also used for ADTS AAC */
570 typedef struct AC3ParseContext {
574 int (*sync)(const uint8_t *buf, int *channels, int *sample_rate,
575 int *bit_rate, int *samples);
576 uint8_t inbuf[8192]; /* input buffer */
579 #define AC3_HEADER_SIZE 7
580 #define AAC_HEADER_SIZE 7
582 #ifdef CONFIG_AC3_PARSER
583 static const int ac3_sample_rates[4] = {
584 48000, 44100, 32000, 0
587 static const int ac3_frame_sizes[64][3] = {
620 { 1024, 1114, 1536 },
621 { 1024, 1115, 1536 },
622 { 1152, 1253, 1728 },
623 { 1152, 1254, 1728 },
624 { 1280, 1393, 1920 },
625 { 1280, 1394, 1920 },
628 static const int ac3_bitrates[64] = {
629 32, 32, 40, 40, 48, 48, 56, 56, 64, 64, 80, 80, 96, 96, 112, 112,
630 128, 128, 160, 160, 192, 192, 224, 224, 256, 256, 320, 320, 384,
631 384, 448, 448, 512, 512, 576, 576, 640, 640,
634 static const int ac3_channels[8] = {
635 2, 1, 2, 3, 3, 4, 4, 5
637 #endif /* CONFIG_AC3_PARSER */
639 #ifdef CONFIG_AAC_PARSER
640 static const int aac_sample_rates[16] = {
641 96000, 88200, 64000, 48000, 44100, 32000,
642 24000, 22050, 16000, 12000, 11025, 8000, 7350
645 static const int aac_channels[8] = {
646 0, 1, 2, 3, 4, 5, 6, 8
650 #ifdef CONFIG_AC3_PARSER
651 static int ac3_sync(const uint8_t *buf, int *channels, int *sample_rate,
652 int *bit_rate, int *samples)
654 unsigned int fscod, frmsizecod, acmod, bsid, lfeon;
657 init_get_bits(&bits, buf, AC3_HEADER_SIZE * 8);
659 if(get_bits(&bits, 16) != 0x0b77)
662 skip_bits(&bits, 16); /* crc */
663 fscod = get_bits(&bits, 2);
664 frmsizecod = get_bits(&bits, 6);
666 if(!ac3_sample_rates[fscod])
669 bsid = get_bits(&bits, 5);
672 skip_bits(&bits, 3); /* bsmod */
673 acmod = get_bits(&bits, 3);
674 if(acmod & 1 && acmod != 1)
675 skip_bits(&bits, 2); /* cmixlev */
677 skip_bits(&bits, 2); /* surmixlev */
679 skip_bits(&bits, 2); /* dsurmod */
680 lfeon = get_bits1(&bits);
682 *sample_rate = ac3_sample_rates[fscod];
683 *bit_rate = ac3_bitrates[frmsizecod] * 1000;
684 *channels = ac3_channels[acmod] + lfeon;
687 return ac3_frame_sizes[frmsizecod][fscod] * 2;
689 #endif /* CONFIG_AC3_PARSER */
691 #ifdef CONFIG_AAC_PARSER
692 static int aac_sync(const uint8_t *buf, int *channels, int *sample_rate,
693 int *bit_rate, int *samples)
696 int size, rdb, ch, sr;
698 init_get_bits(&bits, buf, AAC_HEADER_SIZE * 8);
700 if(get_bits(&bits, 12) != 0xfff)
703 skip_bits1(&bits); /* id */
704 skip_bits(&bits, 2); /* layer */
705 skip_bits1(&bits); /* protection_absent */
706 skip_bits(&bits, 2); /* profile_objecttype */
707 sr = get_bits(&bits, 4); /* sample_frequency_index */
708 if(!aac_sample_rates[sr])
710 skip_bits1(&bits); /* private_bit */
711 ch = get_bits(&bits, 3); /* channel_configuration */
712 if(!aac_channels[ch])
714 skip_bits1(&bits); /* original/copy */
715 skip_bits1(&bits); /* home */
717 /* adts_variable_header */
718 skip_bits1(&bits); /* copyright_identification_bit */
719 skip_bits1(&bits); /* copyright_identification_start */
720 size = get_bits(&bits, 13); /* aac_frame_length */
721 skip_bits(&bits, 11); /* adts_buffer_fullness */
722 rdb = get_bits(&bits, 2); /* number_of_raw_data_blocks_in_frame */
724 *channels = aac_channels[ch];
725 *sample_rate = aac_sample_rates[sr];
726 *samples = (rdb + 1) * 1024;
727 *bit_rate = size * 8 * *sample_rate / *samples;
731 #endif /* CONFIG_AAC_PARSER */
733 #ifdef CONFIG_AC3_PARSER
734 static int ac3_parse_init(AVCodecParserContext *s1)
736 AC3ParseContext *s = s1->priv_data;
737 s->inbuf_ptr = s->inbuf;
738 s->header_size = AC3_HEADER_SIZE;
744 #ifdef CONFIG_AAC_PARSER
745 static int aac_parse_init(AVCodecParserContext *s1)
747 AC3ParseContext *s = s1->priv_data;
748 s->inbuf_ptr = s->inbuf;
749 s->header_size = AAC_HEADER_SIZE;
755 /* also used for ADTS AAC */
756 static int ac3_parse(AVCodecParserContext *s1,
757 AVCodecContext *avctx,
758 uint8_t **poutbuf, int *poutbuf_size,
759 const uint8_t *buf, int buf_size)
761 AC3ParseContext *s = s1->priv_data;
762 const uint8_t *buf_ptr;
763 int len, sample_rate, bit_rate, channels, samples;
769 while (buf_size > 0) {
770 len = s->inbuf_ptr - s->inbuf;
771 if (s->frame_size == 0) {
772 /* no header seen : find one. We need at least s->header_size
774 len = FFMIN(s->header_size - len, buf_size);
776 memcpy(s->inbuf_ptr, buf_ptr, len);
780 if ((s->inbuf_ptr - s->inbuf) == s->header_size) {
781 len = s->sync(s->inbuf, &channels, &sample_rate, &bit_rate,
784 /* no sync found : move by one byte (inefficient, but simple!) */
785 memmove(s->inbuf, s->inbuf + 1, s->header_size - 1);
789 /* update codec info */
790 avctx->sample_rate = sample_rate;
791 /* set channels,except if the user explicitly requests 1 or 2 channels, XXX/FIXME this is a bit ugly */
792 if(avctx->codec_id == CODEC_ID_AC3){
793 if(avctx->channels!=1 && avctx->channels!=2){
794 avctx->channels = channels;
797 avctx->channels = channels;
799 avctx->bit_rate = bit_rate;
800 avctx->frame_size = samples;
804 len = FFMIN(s->frame_size - len, buf_size);
806 memcpy(s->inbuf_ptr, buf_ptr, len);
811 if(s->inbuf_ptr - s->inbuf == s->frame_size){
813 *poutbuf_size = s->frame_size;
814 s->inbuf_ptr = s->inbuf;
820 return buf_ptr - buf;
822 #endif /* CONFIG_AC3_PARSER || CONFIG_AAC_PARSER */
824 #ifdef CONFIG_MPEG4VIDEO_PARSER
825 AVCodecParser mpeg4video_parser = {
827 sizeof(ParseContext1),
828 mpeg4video_parse_init,
834 #ifdef CONFIG_MPEGAUDIO_PARSER
835 AVCodecParser mpegaudio_parser = {
836 { CODEC_ID_MP2, CODEC_ID_MP3 },
837 sizeof(MpegAudioParseContext),
838 mpegaudio_parse_init,
843 #ifdef CONFIG_AC3_PARSER
844 AVCodecParser ac3_parser = {
846 sizeof(AC3ParseContext),
852 #ifdef CONFIG_AAC_PARSER
853 AVCodecParser aac_parser = {
855 sizeof(AC3ParseContext),