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);
72 s->pict_type = FF_I_TYPE;
79 * @param buf_size input length, to signal EOF, this should be 0 (so that the last frame can be output)
80 * @param pts input presentation timestamp
81 * @param dts input decoding timestamp
82 * @param poutbuf will contain a pointer to the first byte of the output frame
83 * @param poutbuf_size will contain the length of the output frame
84 * @return the number of bytes of the input bitstream used
89 * len = av_parser_parse(myparser, AVCodecContext, &data, &size,
96 * decode_frame(data, size);
100 int av_parser_parse(AVCodecParserContext *s,
101 AVCodecContext *avctx,
102 uint8_t **poutbuf, int *poutbuf_size,
103 const uint8_t *buf, int buf_size,
104 int64_t pts, int64_t dts)
107 uint8_t dummy_buf[FF_INPUT_BUFFER_PADDING_SIZE];
110 /* padding is always necessary even if EOF, so we add it here */
111 memset(dummy_buf, 0, sizeof(dummy_buf));
114 /* add a new packet descriptor */
115 k = (s->cur_frame_start_index + 1) & (AV_PARSER_PTS_NB - 1);
116 s->cur_frame_start_index = k;
117 s->cur_frame_offset[k] = s->cur_offset;
118 s->cur_frame_pts[k] = pts;
119 s->cur_frame_dts[k] = dts;
121 /* fill first PTS/DTS */
122 if (s->fetch_timestamp){
123 s->fetch_timestamp=0;
127 s->cur_frame_pts[k] =
128 s->cur_frame_dts[k] = AV_NOPTS_VALUE;
132 /* WARNING: the returned index can be negative */
133 index = s->parser->parser_parse(s, avctx, (const uint8_t **)poutbuf, poutbuf_size, buf, buf_size);
134 //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);
135 /* update the file pointer */
137 /* fill the data for the current frame */
138 s->frame_offset = s->last_frame_offset;
139 s->pts = s->last_pts;
140 s->dts = s->last_dts;
141 s->offset = s->last_offset;
143 /* offset of the next frame */
144 s->last_frame_offset = s->cur_offset + index;
145 /* find the packet in which the new frame starts. It
146 is tricky because of MPEG video start codes
147 which can begin in one packet and finish in
148 another packet. In the worst case, an MPEG
149 video start code could be in 4 different
151 k = s->cur_frame_start_index;
152 for(i = 0; i < AV_PARSER_PTS_NB; i++) {
153 if (s->last_frame_offset >= s->cur_frame_offset[k])
155 k = (k - 1) & (AV_PARSER_PTS_NB - 1);
158 s->last_pts = s->cur_frame_pts[k];
159 s->last_dts = s->cur_frame_dts[k];
160 s->last_offset = s->last_frame_offset - s->cur_frame_offset[k];
162 /* some parsers tell us the packet size even before seeing the first byte of the next packet,
163 so the next pts/dts is in the next chunk */
164 if(index == buf_size){
165 s->fetch_timestamp=1;
170 s->cur_offset += index;
176 * @return 0 if the output buffer is a subset of the input, 1 if it is allocated and must be freed
177 * @deprecated use AVBitstreamFilter
179 int av_parser_change(AVCodecParserContext *s,
180 AVCodecContext *avctx,
181 uint8_t **poutbuf, int *poutbuf_size,
182 const uint8_t *buf, int buf_size, int keyframe){
184 if(s && s->parser->split){
185 if((avctx->flags & CODEC_FLAG_GLOBAL_HEADER) || (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER)){
186 int i= s->parser->split(avctx, buf, buf_size);
192 /* cast to avoid warning about discarding qualifiers */
193 *poutbuf= (uint8_t *) buf;
194 *poutbuf_size= buf_size;
195 if(avctx->extradata){
196 if( (keyframe && (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER))
197 /*||(s->pict_type != I_TYPE && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_NOKEY))*/
198 /*||(? && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_BEGIN)*/){
199 int size= buf_size + avctx->extradata_size;
201 *poutbuf= av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
203 memcpy(*poutbuf, avctx->extradata, avctx->extradata_size);
204 memcpy((*poutbuf) + avctx->extradata_size, buf, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
212 void av_parser_close(AVCodecParserContext *s)
214 if (s->parser->parser_close)
215 s->parser->parser_close(s);
216 av_free(s->priv_data);
220 /*****************************************************/
223 * combines the (truncated) bitstream to a complete frame
224 * @returns -1 if no complete frame could be created
226 int ff_combine_frame(ParseContext *pc, int next, const uint8_t **buf, int *buf_size)
230 printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
231 printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
235 /* Copy overread bytes from last frame into buffer. */
236 for(; pc->overread>0; pc->overread--){
237 pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
240 /* flush remaining if EOF */
241 if(!*buf_size && next == END_NOT_FOUND){
245 pc->last_index= pc->index;
247 /* copy into buffer end return */
248 if(next == END_NOT_FOUND){
249 pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
251 memcpy(&pc->buffer[pc->index], *buf, *buf_size);
252 pc->index += *buf_size;
257 pc->overread_index= pc->index + next;
259 /* append to buffer */
261 pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
263 memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
268 /* store overread bytes */
269 for(;next < 0; next++){
270 pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
276 printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
277 printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
284 void ff_parse_close(AVCodecParserContext *s)
286 ParseContext *pc = s->priv_data;
291 void ff_parse1_close(AVCodecParserContext *s)
293 ParseContext1 *pc1 = s->priv_data;
295 av_free(pc1->pc.buffer);
299 /*************************/
301 int ff_mpeg4video_split(AVCodecContext *avctx,
302 const uint8_t *buf, int buf_size)
307 for(i=0; i<buf_size; i++){
308 state= (state<<8) | buf[i];
309 if(state == 0x1B3 || state == 0x1B6)
315 /*************************/
317 #if defined(CONFIG_AC3_PARSER) || defined(CONFIG_AAC_PARSER)
318 /* also used for ADTS AAC */
319 typedef struct AC3ParseContext {
323 int (*sync)(const uint8_t *buf, int *channels, int *sample_rate,
324 int *bit_rate, int *samples);
325 uint8_t inbuf[8192]; /* input buffer */
328 #define AC3_HEADER_SIZE 7
329 #define AAC_HEADER_SIZE 7
331 #ifdef CONFIG_AC3_PARSER
333 static const uint8_t eac3_blocks[4] = {
337 #endif /* CONFIG_AC3_PARSER */
339 #ifdef CONFIG_AAC_PARSER
340 static const int aac_sample_rates[16] = {
341 96000, 88200, 64000, 48000, 44100, 32000,
342 24000, 22050, 16000, 12000, 11025, 8000, 7350
345 static const int aac_channels[8] = {
346 0, 1, 2, 3, 4, 5, 6, 8
350 #ifdef CONFIG_AC3_PARSER
351 int ff_ac3_parse_header(const uint8_t buf[7], AC3HeaderInfo *hdr)
355 memset(hdr, 0, sizeof(*hdr));
357 init_get_bits(&gbc, buf, 54);
359 hdr->sync_word = get_bits(&gbc, 16);
360 if(hdr->sync_word != 0x0B77)
363 /* read ahead to bsid to make sure this is AC-3, not E-AC-3 */
364 hdr->bsid = show_bits_long(&gbc, 29) & 0x1F;
368 hdr->crc1 = get_bits(&gbc, 16);
369 hdr->fscod = get_bits(&gbc, 2);
373 hdr->frmsizecod = get_bits(&gbc, 6);
374 if(hdr->frmsizecod > 37)
377 skip_bits(&gbc, 5); // skip bsid, already got it
379 hdr->bsmod = get_bits(&gbc, 3);
380 hdr->acmod = get_bits(&gbc, 3);
381 if((hdr->acmod & 1) && hdr->acmod != 1) {
382 hdr->cmixlev = get_bits(&gbc, 2);
385 hdr->surmixlev = get_bits(&gbc, 2);
387 if(hdr->acmod == 2) {
388 hdr->dsurmod = get_bits(&gbc, 2);
390 hdr->lfeon = get_bits1(&gbc);
392 hdr->halfratecod = FFMAX(hdr->bsid, 8) - 8;
393 hdr->sample_rate = ff_ac3_freqs[hdr->fscod] >> hdr->halfratecod;
394 hdr->bit_rate = (ff_ac3_bitratetab[hdr->frmsizecod>>1] * 1000) >> hdr->halfratecod;
395 hdr->channels = ff_ac3_channels[hdr->acmod] + hdr->lfeon;
396 hdr->frame_size = ff_ac3_frame_sizes[hdr->frmsizecod][hdr->fscod] * 2;
401 static int ac3_sync(const uint8_t *buf, int *channels, int *sample_rate,
402 int *bit_rate, int *samples)
405 unsigned int fscod, acmod, bsid, lfeon;
406 unsigned int strmtyp, substreamid, frmsiz, fscod2, numblkscod;
410 err = ff_ac3_parse_header(buf, &hdr);
412 if(err < 0 && err != -2)
416 if(bsid <= 10) { /* Normal AC-3 */
417 *sample_rate = hdr.sample_rate;
418 *bit_rate = hdr.bit_rate;
419 *channels = hdr.channels;
420 *samples = AC3_FRAME_SIZE;
421 return hdr.frame_size;
422 } else if (bsid > 10 && bsid <= 16) { /* Enhanced AC-3 */
423 init_get_bits(&bits, &buf[2], (AC3_HEADER_SIZE-2) * 8);
424 strmtyp = get_bits(&bits, 2);
425 substreamid = get_bits(&bits, 3);
427 if (strmtyp != 0 || substreamid != 0)
428 return 0; /* Currently don't support additional streams */
430 frmsiz = get_bits(&bits, 11) + 1;
431 fscod = get_bits(&bits, 2);
433 fscod2 = get_bits(&bits, 2);
439 *sample_rate = ff_ac3_freqs[fscod2] / 2;
441 numblkscod = get_bits(&bits, 2);
443 *sample_rate = ff_ac3_freqs[fscod];
446 acmod = get_bits(&bits, 3);
447 lfeon = get_bits1(&bits);
449 *samples = eac3_blocks[numblkscod] * 256;
450 *bit_rate = frmsiz * (*sample_rate) * 16 / (*samples);
451 *channels = ff_ac3_channels[acmod] + lfeon;
456 /* Unsupported bitstream version */
459 #endif /* CONFIG_AC3_PARSER */
461 #ifdef CONFIG_AAC_PARSER
462 static int aac_sync(const uint8_t *buf, int *channels, int *sample_rate,
463 int *bit_rate, int *samples)
466 int size, rdb, ch, sr;
468 init_get_bits(&bits, buf, AAC_HEADER_SIZE * 8);
470 if(get_bits(&bits, 12) != 0xfff)
473 skip_bits1(&bits); /* id */
474 skip_bits(&bits, 2); /* layer */
475 skip_bits1(&bits); /* protection_absent */
476 skip_bits(&bits, 2); /* profile_objecttype */
477 sr = get_bits(&bits, 4); /* sample_frequency_index */
478 if(!aac_sample_rates[sr])
480 skip_bits1(&bits); /* private_bit */
481 ch = get_bits(&bits, 3); /* channel_configuration */
482 if(!aac_channels[ch])
484 skip_bits1(&bits); /* original/copy */
485 skip_bits1(&bits); /* home */
487 /* adts_variable_header */
488 skip_bits1(&bits); /* copyright_identification_bit */
489 skip_bits1(&bits); /* copyright_identification_start */
490 size = get_bits(&bits, 13); /* aac_frame_length */
491 skip_bits(&bits, 11); /* adts_buffer_fullness */
492 rdb = get_bits(&bits, 2); /* number_of_raw_data_blocks_in_frame */
494 *channels = aac_channels[ch];
495 *sample_rate = aac_sample_rates[sr];
496 *samples = (rdb + 1) * 1024;
497 *bit_rate = size * 8 * *sample_rate / *samples;
501 #endif /* CONFIG_AAC_PARSER */
503 #ifdef CONFIG_AC3_PARSER
504 static int ac3_parse_init(AVCodecParserContext *s1)
506 AC3ParseContext *s = s1->priv_data;
507 s->inbuf_ptr = s->inbuf;
508 s->header_size = AC3_HEADER_SIZE;
514 #ifdef CONFIG_AAC_PARSER
515 static int aac_parse_init(AVCodecParserContext *s1)
517 AC3ParseContext *s = s1->priv_data;
518 s->inbuf_ptr = s->inbuf;
519 s->header_size = AAC_HEADER_SIZE;
525 /* also used for ADTS AAC */
526 static int ac3_parse(AVCodecParserContext *s1,
527 AVCodecContext *avctx,
528 const uint8_t **poutbuf, int *poutbuf_size,
529 const uint8_t *buf, int buf_size)
531 AC3ParseContext *s = s1->priv_data;
532 const uint8_t *buf_ptr;
533 int len, sample_rate, bit_rate, channels, samples;
539 while (buf_size > 0) {
540 len = s->inbuf_ptr - s->inbuf;
541 if (s->frame_size == 0) {
542 /* no header seen : find one. We need at least s->header_size
544 len = FFMIN(s->header_size - len, buf_size);
546 memcpy(s->inbuf_ptr, buf_ptr, len);
550 if ((s->inbuf_ptr - s->inbuf) == s->header_size) {
551 len = s->sync(s->inbuf, &channels, &sample_rate, &bit_rate,
554 /* no sync found : move by one byte (inefficient, but simple!) */
555 memmove(s->inbuf, s->inbuf + 1, s->header_size - 1);
559 /* update codec info */
560 avctx->sample_rate = sample_rate;
561 /* set channels,except if the user explicitly requests 1 or 2 channels, XXX/FIXME this is a bit ugly */
562 if(avctx->codec_id == CODEC_ID_AC3){
563 if(avctx->channels!=1 && avctx->channels!=2){
564 avctx->channels = channels;
567 avctx->channels = channels;
569 avctx->bit_rate = bit_rate;
570 avctx->frame_size = samples;
574 len = FFMIN(s->frame_size - len, buf_size);
576 memcpy(s->inbuf_ptr, buf_ptr, len);
581 if(s->inbuf_ptr - s->inbuf == s->frame_size){
583 *poutbuf_size = s->frame_size;
584 s->inbuf_ptr = s->inbuf;
590 return buf_ptr - buf;
592 #endif /* CONFIG_AC3_PARSER || CONFIG_AAC_PARSER */
594 #ifdef CONFIG_AC3_PARSER
595 AVCodecParser ac3_parser = {
597 sizeof(AC3ParseContext),
603 #ifdef CONFIG_AAC_PARSER
604 AVCodecParser aac_parser = {
606 sizeof(AC3ParseContext),