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
#ifdef CONFIG_MPEGVIDEO_PARSER
302
//FIXME move into mpeg12.c
303
static void mpegvideo_extract_headers(AVCodecParserContext *s,
304
AVCodecContext *avctx,
305
const uint8_t *buf, int buf_size)
307
ParseContext1 *pc = s->priv_data;
308
const uint8_t *buf_end;
310
int frame_rate_index, ext_type, bytes_left;
311
int frame_rate_ext_n, frame_rate_ext_d;
312
int picture_structure, top_field_first, repeat_first_field, progressive_frame;
313
int horiz_size_ext, vert_size_ext, bit_rate_ext;
314
//FIXME replace the crap with get_bits()
316
buf_end = buf + buf_size;
317
while (buf < buf_end) {
319
buf= ff_find_start_code(buf, buf_end, &start_code);
320
bytes_left = buf_end - buf;
322
case PICTURE_START_CODE:
323
if (bytes_left >= 2) {
324
s->pict_type = (buf[1] >> 3) & 7;
328
if (bytes_left >= 7) {
329
pc->width = (buf[0] << 4) | (buf[1] >> 4);
330
pc->height = ((buf[1] & 0x0f) << 8) | buf[2];
331
avcodec_set_dimensions(avctx, pc->width, pc->height);
332
frame_rate_index = buf[3] & 0xf;
333
pc->frame_rate = avctx->time_base.den = frame_rate_tab[frame_rate_index];
334
avctx->time_base.num = MPEG1_FRAME_RATE_BASE;
335
avctx->bit_rate = ((buf[4]<<10) | (buf[5]<<2) | (buf[6]>>6))*400;
336
avctx->codec_id = CODEC_ID_MPEG1VIDEO;
341
if (bytes_left >= 1) {
342
ext_type = (buf[0] >> 4);
344
case 0x1: /* sequence extension */
345
if (bytes_left >= 6) {
346
horiz_size_ext = ((buf[1] & 1) << 1) | (buf[2] >> 7);
347
vert_size_ext = (buf[2] >> 5) & 3;
348
bit_rate_ext = ((buf[2] & 0x1F)<<7) | (buf[3]>>1);
349
frame_rate_ext_n = (buf[5] >> 5) & 3;
350
frame_rate_ext_d = (buf[5] & 0x1f);
351
pc->progressive_sequence = buf[1] & (1 << 3);
352
avctx->has_b_frames= !(buf[5] >> 7);
354
pc->width |=(horiz_size_ext << 12);
355
pc->height |=( vert_size_ext << 12);
356
avctx->bit_rate += (bit_rate_ext << 18) * 400;
357
avcodec_set_dimensions(avctx, pc->width, pc->height);
358
avctx->time_base.den = pc->frame_rate * (frame_rate_ext_n + 1);
359
avctx->time_base.num = MPEG1_FRAME_RATE_BASE * (frame_rate_ext_d + 1);
360
avctx->codec_id = CODEC_ID_MPEG2VIDEO;
361
avctx->sub_id = 2; /* forces MPEG2 */
364
case 0x8: /* picture coding extension */
365
if (bytes_left >= 5) {
366
picture_structure = buf[2]&3;
367
top_field_first = buf[3] & (1 << 7);
368
repeat_first_field = buf[3] & (1 << 1);
369
progressive_frame = buf[4] & (1 << 7);
371
/* check if we must repeat the frame */
372
if (repeat_first_field) {
373
if (pc->progressive_sequence) {
378
} else if (progressive_frame) {
383
/* the packet only represents half a frame
384
XXX,FIXME maybe find a different solution */
385
if(picture_structure != 3)
395
/* we stop parsing when we encounter a slice. It ensures
396
that this function takes a negligible amount of time */
397
if (start_code >= SLICE_MIN_START_CODE &&
398
start_code <= SLICE_MAX_START_CODE)
406
static int mpegvideo_parse(AVCodecParserContext *s,
407
AVCodecContext *avctx,
408
uint8_t **poutbuf, int *poutbuf_size,
409
const uint8_t *buf, int buf_size)
411
ParseContext1 *pc1 = s->priv_data;
412
ParseContext *pc= &pc1->pc;
415
if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
418
next= ff_mpeg1_find_frame_end(pc, buf, buf_size);
420
if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
427
/* we have a full frame : we just parse the first few MPEG headers
428
to have the full timing information. The time take by this
429
function should be negligible for uncorrupted streams */
430
mpegvideo_extract_headers(s, avctx, buf, buf_size);
432
printf("pict_type=%d frame_rate=%0.3f repeat_pict=%d\n",
433
s->pict_type, (double)avctx->time_base.den / avctx->time_base.num, s->repeat_pict);
436
*poutbuf = (uint8_t *)buf;
437
*poutbuf_size = buf_size;
441
static int mpegvideo_split(AVCodecContext *avctx,
442
const uint8_t *buf, int buf_size)
447
for(i=0; i<buf_size; i++){
448
state= (state<<8) | buf[i];
449
if(state != 0x1B3 && state != 0x1B5 && state < 0x200 && state >= 0x100)
454
#endif /* CONFIG_MPEGVIDEO_PARSER */
456
void ff_parse_close(AVCodecParserContext *s)
458
ParseContext *pc = s->priv_data;
463
static void parse1_close(AVCodecParserContext *s)
465
ParseContext1 *pc1 = s->priv_data;
467
av_free(pc1->pc.buffer);
471
/*************************/
473
#ifdef CONFIG_MPEG4VIDEO_PARSER
475
/* XXX: make it use less memory */
476
static int av_mpeg4_decode_header(AVCodecParserContext *s1,
477
AVCodecContext *avctx,
478
const uint8_t *buf, int buf_size)
480
ParseContext1 *pc = s1->priv_data;
481
MpegEncContext *s = pc->enc;
482
GetBitContext gb1, *gb = &gb1;
486
s->current_picture_ptr = &s->current_picture;
488
if (avctx->extradata_size && pc->first_picture){
489
init_get_bits(gb, avctx->extradata, avctx->extradata_size*8);
490
ret = ff_mpeg4_decode_picture_header(s, gb);
493
init_get_bits(gb, buf, 8 * buf_size);
494
ret = ff_mpeg4_decode_picture_header(s, gb);
496
avcodec_set_dimensions(avctx, s->width, s->height);
498
s1->pict_type= s->pict_type;
499
pc->first_picture = 0;
503
static int mpeg4video_parse_init(AVCodecParserContext *s)
505
ParseContext1 *pc = s->priv_data;
507
pc->enc = av_mallocz(sizeof(MpegEncContext));
510
pc->first_picture = 1;
514
static int mpeg4video_parse(AVCodecParserContext *s,
515
AVCodecContext *avctx,
516
uint8_t **poutbuf, int *poutbuf_size,
517
const uint8_t *buf, int buf_size)
519
ParseContext *pc = s->priv_data;
522
if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
525
next= ff_mpeg4_find_frame_end(pc, buf, buf_size);
527
if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
533
av_mpeg4_decode_header(s, avctx, buf, buf_size);
535
*poutbuf = (uint8_t *)buf;
536
*poutbuf_size = buf_size;
541
#ifdef CONFIG_CAVSVIDEO_PARSER
542
static int cavsvideo_parse(AVCodecParserContext *s,
543
AVCodecContext *avctx,
544
uint8_t **poutbuf, int *poutbuf_size,
545
const uint8_t *buf, int buf_size)
547
ParseContext *pc = s->priv_data;
550
if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
553
next= ff_cavs_find_frame_end(pc, buf, buf_size);
555
if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
561
*poutbuf = (uint8_t *)buf;
562
*poutbuf_size = buf_size;
565
#endif /* CONFIG_CAVSVIDEO_PARSER */
567
static int mpeg4video_split(AVCodecContext *avctx,
568
const uint8_t *buf, int buf_size)
573
for(i=0; i<buf_size; i++){
574
state= (state<<8) | buf[i];
575
if(state == 0x1B3 || state == 0x1B6)
581
/*************************/
583
#ifdef CONFIG_MPEGAUDIO_PARSER
584
typedef struct MpegAudioParseContext {
585
uint8_t inbuf[MPA_MAX_CODED_FRAME_SIZE]; /* input buffer */
588
int free_format_frame_size;
589
int free_format_next_header;
592
} MpegAudioParseContext;
594
#define MPA_HEADER_SIZE 4
596
/* header + layer + bitrate + freq + lsf/mpeg25 */
597
#undef SAME_HEADER_MASK /* mpegaudio.h defines different version */
598
#define SAME_HEADER_MASK \
599
(0xffe00000 | (3 << 17) | (3 << 10) | (3 << 19))
601
static int mpegaudio_parse_init(AVCodecParserContext *s1)
603
MpegAudioParseContext *s = s1->priv_data;
604
s->inbuf_ptr = s->inbuf;
608
static int mpegaudio_parse(AVCodecParserContext *s1,
609
AVCodecContext *avctx,
610
uint8_t **poutbuf, int *poutbuf_size,
611
const uint8_t *buf, int buf_size)
613
MpegAudioParseContext *s = s1->priv_data;
616
const uint8_t *buf_ptr;
621
while (buf_size > 0) {
622
len = s->inbuf_ptr - s->inbuf;
623
if (s->frame_size == 0) {
624
/* special case for next header for first frame in free
625
format case (XXX: find a simpler method) */
626
if (s->free_format_next_header != 0) {
627
s->inbuf[0] = s->free_format_next_header >> 24;
628
s->inbuf[1] = s->free_format_next_header >> 16;
629
s->inbuf[2] = s->free_format_next_header >> 8;
630
s->inbuf[3] = s->free_format_next_header;
631
s->inbuf_ptr = s->inbuf + 4;
632
s->free_format_next_header = 0;
635
/* no header seen : find one. We need at least MPA_HEADER_SIZE
637
len = MPA_HEADER_SIZE - len;
641
memcpy(s->inbuf_ptr, buf_ptr, len);
646
if ((s->inbuf_ptr - s->inbuf) >= MPA_HEADER_SIZE) {
648
sr= avctx->sample_rate;
649
header = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
650
(s->inbuf[2] << 8) | s->inbuf[3];
652
ret = mpa_decode_header(avctx, header);
655
/* no sync found : move by one byte (inefficient, but simple!) */
656
memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
658
dprintf("skip %x\n", header);
659
/* reset free format frame size to give a chance
660
to get a new bitrate */
661
s->free_format_frame_size = 0;
663
if((header&SAME_HEADER_MASK) != (s->header&SAME_HEADER_MASK) && s->header)
670
/* free format: prepare to compute frame size */
671
if (decode_header(s, header) == 1) {
676
if(s->header_count <= 0)
677
avctx->sample_rate= sr; //FIXME ugly
681
if (s->frame_size == -1) {
682
/* free format : find next sync to compute frame size */
683
len = MPA_MAX_CODED_FRAME_SIZE - len;
687
/* frame too long: resync */
689
memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
696
memcpy(s->inbuf_ptr, buf_ptr, len);
697
/* check for header */
698
p = s->inbuf_ptr - 3;
699
pend = s->inbuf_ptr + len - 4;
701
header = (p[0] << 24) | (p[1] << 16) |
703
header1 = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
704
(s->inbuf[2] << 8) | s->inbuf[3];
705
/* check with high probability that we have a
707
if ((header & SAME_HEADER_MASK) ==
708
(header1 & SAME_HEADER_MASK)) {
709
/* header found: update pointers */
710
len = (p + 4) - s->inbuf_ptr;
714
/* compute frame size */
715
s->free_format_next_header = header;
716
s->free_format_frame_size = s->inbuf_ptr - s->inbuf;
717
padding = (header1 >> 9) & 1;
719
s->free_format_frame_size -= padding * 4;
721
s->free_format_frame_size -= padding;
722
dprintf("free frame size=%d padding=%d\n",
723
s->free_format_frame_size, padding);
724
decode_header(s, header1);
729
/* not found: simply increase pointers */
736
if (len < s->frame_size) {
737
if (s->frame_size > MPA_MAX_CODED_FRAME_SIZE)
738
s->frame_size = MPA_MAX_CODED_FRAME_SIZE;
739
len = s->frame_size - len;
742
memcpy(s->inbuf_ptr, buf_ptr, len);
748
if (s->frame_size > 0 &&
749
(s->inbuf_ptr - s->inbuf) >= s->frame_size) {
750
if(s->header_count > 0){
752
*poutbuf_size = s->inbuf_ptr - s->inbuf;
754
s->inbuf_ptr = s->inbuf;
759
return buf_ptr - buf;
761
#endif /* CONFIG_MPEGAUDIO_PARSER */
763
#if defined(CONFIG_AC3_PARSER) || defined(CONFIG_AAC_PARSER)
764
/* also used for ADTS AAC */
765
typedef struct AC3ParseContext {
769
int (*sync)(const uint8_t *buf, int *channels, int *sample_rate,
770
int *bit_rate, int *samples);
771
uint8_t inbuf[8192]; /* input buffer */
774
#define AC3_HEADER_SIZE 7
775
#define AAC_HEADER_SIZE 7
777
#ifdef CONFIG_AC3_PARSER
778
static const int ac3_sample_rates[4] = {
779
48000, 44100, 32000, 0
782
static const int ac3_frame_sizes[64][3] = {
815
{ 1024, 1114, 1536 },
816
{ 1024, 1115, 1536 },
817
{ 1152, 1253, 1728 },
818
{ 1152, 1254, 1728 },
819
{ 1280, 1393, 1920 },
820
{ 1280, 1394, 1920 },
823
static const int ac3_bitrates[64] = {
824
32, 32, 40, 40, 48, 48, 56, 56, 64, 64, 80, 80, 96, 96, 112, 112,
825
128, 128, 160, 160, 192, 192, 224, 224, 256, 256, 320, 320, 384,
826
384, 448, 448, 512, 512, 576, 576, 640, 640,
829
static const int ac3_channels[8] = {
830
2, 1, 2, 3, 3, 4, 4, 5
832
#endif /* CONFIG_AC3_PARSER */
834
#ifdef CONFIG_AAC_PARSER
835
static const int aac_sample_rates[16] = {
836
96000, 88200, 64000, 48000, 44100, 32000,
837
24000, 22050, 16000, 12000, 11025, 8000, 7350
840
static const int aac_channels[8] = {
841
0, 1, 2, 3, 4, 5, 6, 8
845
#ifdef CONFIG_AC3_PARSER
846
static int ac3_sync(const uint8_t *buf, int *channels, int *sample_rate,
847
int *bit_rate, int *samples)
849
unsigned int fscod, frmsizecod, acmod, bsid, lfeon;
852
init_get_bits(&bits, buf, AC3_HEADER_SIZE * 8);
854
if(get_bits(&bits, 16) != 0x0b77)
857
skip_bits(&bits, 16); /* crc */
858
fscod = get_bits(&bits, 2);
859
frmsizecod = get_bits(&bits, 6);
861
if(!ac3_sample_rates[fscod])
864
bsid = get_bits(&bits, 5);
867
skip_bits(&bits, 3); /* bsmod */
868
acmod = get_bits(&bits, 3);
869
if(acmod & 1 && acmod != 1)
870
skip_bits(&bits, 2); /* cmixlev */
872
skip_bits(&bits, 2); /* surmixlev */
874
skip_bits(&bits, 2); /* dsurmod */
875
lfeon = get_bits1(&bits);
877
*sample_rate = ac3_sample_rates[fscod];
878
*bit_rate = ac3_bitrates[frmsizecod] * 1000;
879
*channels = ac3_channels[acmod] + lfeon;
882
return ac3_frame_sizes[frmsizecod][fscod] * 2;
884
#endif /* CONFIG_AC3_PARSER */
886
#ifdef CONFIG_AAC_PARSER
887
static int aac_sync(const uint8_t *buf, int *channels, int *sample_rate,
888
int *bit_rate, int *samples)
891
int size, rdb, ch, sr;
893
init_get_bits(&bits, buf, AAC_HEADER_SIZE * 8);
895
if(get_bits(&bits, 12) != 0xfff)
898
skip_bits1(&bits); /* id */
899
skip_bits(&bits, 2); /* layer */
900
skip_bits1(&bits); /* protection_absent */
901
skip_bits(&bits, 2); /* profile_objecttype */
902
sr = get_bits(&bits, 4); /* sample_frequency_index */
903
if(!aac_sample_rates[sr])
905
skip_bits1(&bits); /* private_bit */
906
ch = get_bits(&bits, 3); /* channel_configuration */
907
if(!aac_channels[ch])
909
skip_bits1(&bits); /* original/copy */
910
skip_bits1(&bits); /* home */
912
/* adts_variable_header */
913
skip_bits1(&bits); /* copyright_identification_bit */
914
skip_bits1(&bits); /* copyright_identification_start */
915
size = get_bits(&bits, 13); /* aac_frame_length */
916
skip_bits(&bits, 11); /* adts_buffer_fullness */
917
rdb = get_bits(&bits, 2); /* number_of_raw_data_blocks_in_frame */
919
*channels = aac_channels[ch];
920
*sample_rate = aac_sample_rates[sr];
921
*samples = (rdb + 1) * 1024;
922
*bit_rate = size * 8 * *sample_rate / *samples;
926
#endif /* CONFIG_AAC_PARSER */
928
#ifdef CONFIG_AC3_PARSER
929
static int ac3_parse_init(AVCodecParserContext *s1)
931
AC3ParseContext *s = s1->priv_data;
932
s->inbuf_ptr = s->inbuf;
933
s->header_size = AC3_HEADER_SIZE;
939
#ifdef CONFIG_AAC_PARSER
940
static int aac_parse_init(AVCodecParserContext *s1)
942
AC3ParseContext *s = s1->priv_data;
943
s->inbuf_ptr = s->inbuf;
944
s->header_size = AAC_HEADER_SIZE;
950
/* also used for ADTS AAC */
951
static int ac3_parse(AVCodecParserContext *s1,
952
AVCodecContext *avctx,
953
uint8_t **poutbuf, int *poutbuf_size,
954
const uint8_t *buf, int buf_size)
956
AC3ParseContext *s = s1->priv_data;
957
const uint8_t *buf_ptr;
958
int len, sample_rate, bit_rate, channels, samples;
964
while (buf_size > 0) {
965
len = s->inbuf_ptr - s->inbuf;
966
if (s->frame_size == 0) {
967
/* no header seen : find one. We need at least s->header_size
969
len = FFMIN(s->header_size - len, buf_size);
971
memcpy(s->inbuf_ptr, buf_ptr, len);
975
if ((s->inbuf_ptr - s->inbuf) == s->header_size) {
976
len = s->sync(s->inbuf, &channels, &sample_rate, &bit_rate,
979
/* no sync found : move by one byte (inefficient, but simple!) */
980
memmove(s->inbuf, s->inbuf + 1, s->header_size - 1);
984
/* update codec info */
985
avctx->sample_rate = sample_rate;
986
/* set channels,except if the user explicitly requests 1 or 2 channels, XXX/FIXME this is a bit ugly */
987
if(avctx->codec_id == CODEC_ID_AC3){
988
if(avctx->channels!=1 && avctx->channels!=2){
989
avctx->channels = channels;
992
avctx->channels = channels;
994
avctx->bit_rate = bit_rate;
995
avctx->frame_size = samples;
999
len = FFMIN(s->frame_size - len, buf_size);
1001
memcpy(s->inbuf_ptr, buf_ptr, len);
1003
s->inbuf_ptr += len;
1006
if(s->inbuf_ptr - s->inbuf == s->frame_size){
1007
*poutbuf = s->inbuf;
1008
*poutbuf_size = s->frame_size;
1009
s->inbuf_ptr = s->inbuf;
1015
return buf_ptr - buf;
1017
#endif /* CONFIG_AC3_PARSER || CONFIG_AAC_PARSER */
1019
#ifdef CONFIG_MPEGVIDEO_PARSER
1020
AVCodecParser mpegvideo_parser = {
1021
{ CODEC_ID_MPEG1VIDEO, CODEC_ID_MPEG2VIDEO },
1022
sizeof(ParseContext1),
1029
#ifdef CONFIG_MPEG4VIDEO_PARSER
1030
AVCodecParser mpeg4video_parser = {
1032
sizeof(ParseContext1),
1033
mpeg4video_parse_init,
1039
#ifdef CONFIG_CAVSVIDEO_PARSER
1040
AVCodecParser cavsvideo_parser = {
1042
sizeof(ParseContext1),
1049
#ifdef CONFIG_MPEGAUDIO_PARSER
1050
AVCodecParser mpegaudio_parser = {
1051
{ CODEC_ID_MP2, CODEC_ID_MP3 },
1052
sizeof(MpegAudioParseContext),
1053
mpegaudio_parse_init,
1058
#ifdef CONFIG_AC3_PARSER
1059
AVCodecParser ac3_parser = {
1061
sizeof(AC3ParseContext),
1067
#ifdef CONFIG_AAC_PARSER
1068
AVCodecParser aac_parser = {
1070
sizeof(AC3ParseContext),
added
removed
avidemux/ADM_lavcodec/parser.c
