Statistics
| Branch: | Revision:

ffmpeg / libavcodec / parser.c @ a74008a4

History | View | Annotate | Download (26 KB)

1
/*
2
 * Audio and Video frame extraction
3
 * Copyright (c) 2003 Fabrice Bellard.
4
 * Copyright (c) 2003 Michael Niedermayer.
5
 *
6
 * This file is part of FFmpeg.
7
 *
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.
12
 *
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.
17
 *
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
21
 */
22
#include "avcodec.h"
23
#include "mpegvideo.h"
24
#include "mpegaudio.h"
25
#include "ac3.h"
26
#include "parser.h"
27

    
28
AVCodecParser *av_first_parser = NULL;
29

    
30
void av_register_codec_parser(AVCodecParser *parser)
31
{
32
    parser->next = av_first_parser;
33
    av_first_parser = parser;
34
}
35

    
36
AVCodecParserContext *av_parser_init(int codec_id)
37
{
38
    AVCodecParserContext *s;
39
    AVCodecParser *parser;
40
    int ret;
41

    
42
    if(codec_id == CODEC_ID_NONE)
43
        return NULL;
44

    
45
    for(parser = av_first_parser; parser != NULL; parser = parser->next) {
46
        if (parser->codec_ids[0] == codec_id ||
47
            parser->codec_ids[1] == codec_id ||
48
            parser->codec_ids[2] == codec_id ||
49
            parser->codec_ids[3] == codec_id ||
50
            parser->codec_ids[4] == codec_id)
51
            goto found;
52
    }
53
    return NULL;
54
 found:
55
    s = av_mallocz(sizeof(AVCodecParserContext));
56
    if (!s)
57
        return NULL;
58
    s->parser = parser;
59
    s->priv_data = av_mallocz(parser->priv_data_size);
60
    if (!s->priv_data) {
61
        av_free(s);
62
        return NULL;
63
    }
64
    if (parser->parser_init) {
65
        ret = parser->parser_init(s);
66
        if (ret != 0) {
67
            av_free(s->priv_data);
68
            av_free(s);
69
            return NULL;
70
        }
71
    }
72
    s->fetch_timestamp=1;
73
    s->pict_type = FF_I_TYPE;
74
    return s;
75
}
76

    
77
/**
78
 *
79
 * @param buf           input
80
 * @param buf_size      input length, to signal EOF, this should be 0 (so that the last frame can be output)
81
 * @param pts           input presentation timestamp
82
 * @param dts           input decoding timestamp
83
 * @param poutbuf       will contain a pointer to the first byte of the output frame
84
 * @param poutbuf_size  will contain the length of the output frame
85
 * @return the number of bytes of the input bitstream used
86
 *
87
 * Example:
88
 * @code
89
 *   while(in_len){
90
 *       len = av_parser_parse(myparser, AVCodecContext, &data, &size,
91
 *                                       in_data, in_len,
92
 *                                       pts, dts);
93
 *       in_data += len;
94
 *       in_len  -= len;
95
 *
96
 *       if(size)
97
 *          decode_frame(data, size);
98
 *   }
99
 * @endcode
100
 */
101
int av_parser_parse(AVCodecParserContext *s,
102
                    AVCodecContext *avctx,
103
                    uint8_t **poutbuf, int *poutbuf_size,
104
                    const uint8_t *buf, int buf_size,
105
                    int64_t pts, int64_t dts)
106
{
107
    int index, i, k;
108
    uint8_t dummy_buf[FF_INPUT_BUFFER_PADDING_SIZE];
109

    
110
    if (buf_size == 0) {
111
        /* padding is always necessary even if EOF, so we add it here */
112
        memset(dummy_buf, 0, sizeof(dummy_buf));
113
        buf = dummy_buf;
114
    } else {
115
        /* add a new packet descriptor */
116
        k = (s->cur_frame_start_index + 1) & (AV_PARSER_PTS_NB - 1);
117
        s->cur_frame_start_index = k;
118
        s->cur_frame_offset[k] = s->cur_offset;
119
        s->cur_frame_pts[k] = pts;
120
        s->cur_frame_dts[k] = dts;
121

    
122
        /* fill first PTS/DTS */
123
        if (s->fetch_timestamp){
124
            s->fetch_timestamp=0;
125
            s->last_pts = pts;
126
            s->last_dts = dts;
127
            s->last_offset = 0;
128
            s->cur_frame_pts[k] =
129
            s->cur_frame_dts[k] = AV_NOPTS_VALUE;
130
        }
131
    }
132

    
133
    /* WARNING: the returned index can be negative */
134
    index = s->parser->parser_parse(s, avctx, poutbuf, poutbuf_size, buf, buf_size);
135
//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);
136
    /* update the file pointer */
137
    if (*poutbuf_size) {
138
        /* fill the data for the current frame */
139
        s->frame_offset = s->last_frame_offset;
140
        s->pts = s->last_pts;
141
        s->dts = s->last_dts;
142
        s->offset = s->last_offset;
143

    
144
        /* offset of the next frame */
145
        s->last_frame_offset = s->cur_offset + index;
146
        /* find the packet in which the new frame starts. It
147
           is tricky because of MPEG video start codes
148
           which can begin in one packet and finish in
149
           another packet. In the worst case, an MPEG
150
           video start code could be in 4 different
151
           packets. */
152
        k = s->cur_frame_start_index;
153
        for(i = 0; i < AV_PARSER_PTS_NB; i++) {
154
            if (s->last_frame_offset >= s->cur_frame_offset[k])
155
                break;
156
            k = (k - 1) & (AV_PARSER_PTS_NB - 1);
157
        }
158

    
159
        s->last_pts = s->cur_frame_pts[k];
160
        s->last_dts = s->cur_frame_dts[k];
161
        s->last_offset = s->last_frame_offset - s->cur_frame_offset[k];
162

    
163
        /* some parsers tell us the packet size even before seeing the first byte of the next packet,
164
           so the next pts/dts is in the next chunk */
165
        if(index == buf_size){
166
            s->fetch_timestamp=1;
167
        }
168
    }
169
    if (index < 0)
170
        index = 0;
171
    s->cur_offset += index;
172
    return index;
173
}
174

    
175
/**
176
 *
177
 * @return 0 if the output buffer is a subset of the input, 1 if it is allocated and must be freed
178
 * @deprecated use AVBitstreamFilter
179
 */
180
int av_parser_change(AVCodecParserContext *s,
181
                     AVCodecContext *avctx,
182
                     uint8_t **poutbuf, int *poutbuf_size,
183
                     const uint8_t *buf, int buf_size, int keyframe){
184

    
185
    if(s && s->parser->split){
186
        if((avctx->flags & CODEC_FLAG_GLOBAL_HEADER) || (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER)){
187
            int i= s->parser->split(avctx, buf, buf_size);
188
            buf += i;
189
            buf_size -= i;
190
        }
191
    }
192

    
193
    /* cast to avoid warning about discarding qualifiers */
194
    *poutbuf= (uint8_t *) buf;
195
    *poutbuf_size= buf_size;
196
    if(avctx->extradata){
197
        if(  (keyframe && (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER))
198
            /*||(s->pict_type != I_TYPE && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_NOKEY))*/
199
            /*||(? && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_BEGIN)*/){
200
            int size= buf_size + avctx->extradata_size;
201
            *poutbuf_size= size;
202
            *poutbuf= av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
203

    
204
            memcpy(*poutbuf, avctx->extradata, avctx->extradata_size);
205
            memcpy((*poutbuf) + avctx->extradata_size, buf, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
206
            return 1;
207
        }
208
    }
209

    
210
    return 0;
211
}
212

    
213
void av_parser_close(AVCodecParserContext *s)
214
{
215
    if (s->parser->parser_close)
216
        s->parser->parser_close(s);
217
    av_free(s->priv_data);
218
    av_free(s);
219
}
220

    
221
/*****************************************************/
222

    
223
/**
224
 * combines the (truncated) bitstream to a complete frame
225
 * @returns -1 if no complete frame could be created
226
 */
227
int ff_combine_frame(ParseContext *pc, int next, uint8_t **buf, int *buf_size)
228
{
229
#if 0
230
    if(pc->overread){
231
        printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
232
        printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
233
    }
234
#endif
235

    
236
    /* Copy overread bytes from last frame into buffer. */
237
    for(; pc->overread>0; pc->overread--){
238
        pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
239
    }
240

    
241
    /* flush remaining if EOF */
242
    if(!*buf_size && next == END_NOT_FOUND){
243
        next= 0;
244
    }
245

    
246
    pc->last_index= pc->index;
247

    
248
    /* copy into buffer end return */
249
    if(next == END_NOT_FOUND){
250
        pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
251

    
252
        memcpy(&pc->buffer[pc->index], *buf, *buf_size);
253
        pc->index += *buf_size;
254
        return -1;
255
    }
256

    
257
    *buf_size=
258
    pc->overread_index= pc->index + next;
259

    
260
    /* append to buffer */
261
    if(pc->index){
262
        pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
263

    
264
        memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
265
        pc->index = 0;
266
        *buf= pc->buffer;
267
    }
268

    
269
    /* store overread bytes */
270
    for(;next < 0; next++){
271
        pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
272
        pc->overread++;
273
    }
274

    
275
#if 0
276
    if(pc->overread){
277
        printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
278
        printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
279
    }
280
#endif
281

    
282
    return 0;
283
}
284

    
285
void ff_parse_close(AVCodecParserContext *s)
286
{
287
    ParseContext *pc = s->priv_data;
288

    
289
    av_free(pc->buffer);
290
}
291

    
292
void ff_parse1_close(AVCodecParserContext *s)
293
{
294
    ParseContext1 *pc1 = s->priv_data;
295

    
296
    av_free(pc1->pc.buffer);
297
    av_free(pc1->enc);
298
}
299

    
300
/*************************/
301

    
302
#ifdef CONFIG_MPEG4VIDEO_PARSER
303
/* used by parser */
304
/* XXX: make it use less memory */
305
static int av_mpeg4_decode_header(AVCodecParserContext *s1,
306
                                  AVCodecContext *avctx,
307
                                  const uint8_t *buf, int buf_size)
308
{
309
    ParseContext1 *pc = s1->priv_data;
310
    MpegEncContext *s = pc->enc;
311
    GetBitContext gb1, *gb = &gb1;
312
    int ret;
313

    
314
    s->avctx = avctx;
315
    s->current_picture_ptr = &s->current_picture;
316

    
317
    if (avctx->extradata_size && pc->first_picture){
318
        init_get_bits(gb, avctx->extradata, avctx->extradata_size*8);
319
        ret = ff_mpeg4_decode_picture_header(s, gb);
320
    }
321

    
322
    init_get_bits(gb, buf, 8 * buf_size);
323
    ret = ff_mpeg4_decode_picture_header(s, gb);
324
    if (s->width) {
325
        avcodec_set_dimensions(avctx, s->width, s->height);
326
    }
327
    s1->pict_type= s->pict_type;
328
    pc->first_picture = 0;
329
    return ret;
330
}
331

    
332
static int mpeg4video_parse_init(AVCodecParserContext *s)
333
{
334
    ParseContext1 *pc = s->priv_data;
335

    
336
    pc->enc = av_mallocz(sizeof(MpegEncContext));
337
    if (!pc->enc)
338
        return -1;
339
    pc->first_picture = 1;
340
    return 0;
341
}
342

    
343
static int mpeg4video_parse(AVCodecParserContext *s,
344
                           AVCodecContext *avctx,
345
                           uint8_t **poutbuf, int *poutbuf_size,
346
                           const uint8_t *buf, int buf_size)
347
{
348
    ParseContext *pc = s->priv_data;
349
    int next;
350

    
351
    if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
352
        next= buf_size;
353
    }else{
354
        next= ff_mpeg4_find_frame_end(pc, buf, buf_size);
355

    
356
        if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
357
            *poutbuf = NULL;
358
            *poutbuf_size = 0;
359
            return buf_size;
360
        }
361
    }
362
    av_mpeg4_decode_header(s, avctx, buf, buf_size);
363

    
364
    *poutbuf = (uint8_t *)buf;
365
    *poutbuf_size = buf_size;
366
    return next;
367
}
368
#endif
369

    
370
int ff_mpeg4video_split(AVCodecContext *avctx,
371
                           const uint8_t *buf, int buf_size)
372
{
373
    int i;
374
    uint32_t state= -1;
375

    
376
    for(i=0; i<buf_size; i++){
377
        state= (state<<8) | buf[i];
378
        if(state == 0x1B3 || state == 0x1B6)
379
            return i-3;
380
    }
381
    return 0;
382
}
383

    
384
/*************************/
385

    
386
#ifdef CONFIG_MPEGAUDIO_PARSER
387
typedef struct MpegAudioParseContext {
388
    uint8_t inbuf[MPA_MAX_CODED_FRAME_SIZE];    /* input buffer */
389
    uint8_t *inbuf_ptr;
390
    int frame_size;
391
    int free_format_frame_size;
392
    int free_format_next_header;
393
    uint32_t header;
394
    int header_count;
395
} MpegAudioParseContext;
396

    
397
#define MPA_HEADER_SIZE 4
398

    
399
/* header + layer + bitrate + freq + lsf/mpeg25 */
400
#undef SAME_HEADER_MASK /* mpegaudio.h defines different version */
401
#define SAME_HEADER_MASK \
402
   (0xffe00000 | (3 << 17) | (3 << 10) | (3 << 19))
403

    
404
static int mpegaudio_parse_init(AVCodecParserContext *s1)
405
{
406
    MpegAudioParseContext *s = s1->priv_data;
407
    s->inbuf_ptr = s->inbuf;
408
    return 0;
409
}
410

    
411
static int mpegaudio_parse(AVCodecParserContext *s1,
412
                           AVCodecContext *avctx,
413
                           uint8_t **poutbuf, int *poutbuf_size,
414
                           const uint8_t *buf, int buf_size)
415
{
416
    MpegAudioParseContext *s = s1->priv_data;
417
    int len, ret, sr;
418
    uint32_t header;
419
    const uint8_t *buf_ptr;
420

    
421
    *poutbuf = NULL;
422
    *poutbuf_size = 0;
423
    buf_ptr = buf;
424
    while (buf_size > 0) {
425
        len = s->inbuf_ptr - s->inbuf;
426
        if (s->frame_size == 0) {
427
            /* special case for next header for first frame in free
428
               format case (XXX: find a simpler method) */
429
            if (s->free_format_next_header != 0) {
430
                s->inbuf[0] = s->free_format_next_header >> 24;
431
                s->inbuf[1] = s->free_format_next_header >> 16;
432
                s->inbuf[2] = s->free_format_next_header >> 8;
433
                s->inbuf[3] = s->free_format_next_header;
434
                s->inbuf_ptr = s->inbuf + 4;
435
                s->free_format_next_header = 0;
436
                goto got_header;
437
            }
438
            /* no header seen : find one. We need at least MPA_HEADER_SIZE
439
               bytes to parse it */
440
            len = FFMIN(MPA_HEADER_SIZE - len, buf_size);
441
            if (len > 0) {
442
                memcpy(s->inbuf_ptr, buf_ptr, len);
443
                buf_ptr += len;
444
                buf_size -= len;
445
                s->inbuf_ptr += len;
446
            }
447
            if ((s->inbuf_ptr - s->inbuf) >= MPA_HEADER_SIZE) {
448
            got_header:
449
                header = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
450
                    (s->inbuf[2] << 8) | s->inbuf[3];
451

    
452
                ret = mpa_decode_header(avctx, header, &sr);
453
                if (ret < 0) {
454
                    s->header_count= -2;
455
                    /* no sync found : move by one byte (inefficient, but simple!) */
456
                    memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
457
                    s->inbuf_ptr--;
458
                    dprintf(avctx, "skip %x\n", header);
459
                    /* reset free format frame size to give a chance
460
                       to get a new bitrate */
461
                    s->free_format_frame_size = 0;
462
                } else {
463
                    if((header&SAME_HEADER_MASK) != (s->header&SAME_HEADER_MASK) && s->header)
464
                        s->header_count= -3;
465
                    s->header= header;
466
                    s->header_count++;
467
                    s->frame_size = ret;
468

    
469
#if 0
470
                    /* free format: prepare to compute frame size */
471
                    if (decode_header(s, header) == 1) {
472
                        s->frame_size = -1;
473
                    }
474
#endif
475
                }
476
                if(s->header_count > 1)
477
                    avctx->sample_rate= sr;
478
            }
479
        } else
480
#if 0
481
        if (s->frame_size == -1) {
482
            /* free format : find next sync to compute frame size */
483
            len = MPA_MAX_CODED_FRAME_SIZE - len;
484
            if (len > buf_size)
485
                len = buf_size;
486
            if (len == 0) {
487
                /* frame too long: resync */
488
                s->frame_size = 0;
489
                memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
490
                s->inbuf_ptr--;
491
            } else {
492
                uint8_t *p, *pend;
493
                uint32_t header1;
494
                int padding;
495

496
                memcpy(s->inbuf_ptr, buf_ptr, len);
497
                /* check for header */
498
                p = s->inbuf_ptr - 3;
499
                pend = s->inbuf_ptr + len - 4;
500
                while (p <= pend) {
501
                    header = (p[0] << 24) | (p[1] << 16) |
502
                        (p[2] << 8) | p[3];
503
                    header1 = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
504
                        (s->inbuf[2] << 8) | s->inbuf[3];
505
                    /* check with high probability that we have a
506
                       valid header */
507
                    if ((header & SAME_HEADER_MASK) ==
508
                        (header1 & SAME_HEADER_MASK)) {
509
                        /* header found: update pointers */
510
                        len = (p + 4) - s->inbuf_ptr;
511
                        buf_ptr += len;
512
                        buf_size -= len;
513
                        s->inbuf_ptr = p;
514
                        /* compute frame size */
515
                        s->free_format_next_header = header;
516
                        s->free_format_frame_size = s->inbuf_ptr - s->inbuf;
517
                        padding = (header1 >> 9) & 1;
518
                        if (s->layer == 1)
519
                            s->free_format_frame_size -= padding * 4;
520
                        else
521
                            s->free_format_frame_size -= padding;
522
                        dprintf(avctx, "free frame size=%d padding=%d\n",
523
                                s->free_format_frame_size, padding);
524
                        decode_header(s, header1);
525
                        goto next_data;
526
                    }
527
                    p++;
528
                }
529
                /* not found: simply increase pointers */
530
                buf_ptr += len;
531
                s->inbuf_ptr += len;
532
                buf_size -= len;
533
            }
534
        } else
535
#endif
536
        if (len < s->frame_size) {
537
            if (s->frame_size > MPA_MAX_CODED_FRAME_SIZE)
538
                s->frame_size = MPA_MAX_CODED_FRAME_SIZE;
539
            len = FFMIN(s->frame_size - len, buf_size);
540
            memcpy(s->inbuf_ptr, buf_ptr, len);
541
            buf_ptr += len;
542
            s->inbuf_ptr += len;
543
            buf_size -= len;
544
        }
545

    
546
        if(s->frame_size > 0 && buf_ptr - buf == s->inbuf_ptr - s->inbuf
547
           && buf_size + buf_ptr - buf >= s->frame_size){
548
            if(s->header_count > 0){
549
                *poutbuf = buf;
550
                *poutbuf_size = s->frame_size;
551
            }
552
            buf_ptr = buf + s->frame_size;
553
            s->inbuf_ptr = s->inbuf;
554
            s->frame_size = 0;
555
            break;
556
        }
557

    
558
        //    next_data:
559
        if (s->frame_size > 0 &&
560
            (s->inbuf_ptr - s->inbuf) >= s->frame_size) {
561
            if(s->header_count > 0){
562
                *poutbuf = s->inbuf;
563
                *poutbuf_size = s->inbuf_ptr - s->inbuf;
564
            }
565
            s->inbuf_ptr = s->inbuf;
566
            s->frame_size = 0;
567
            break;
568
        }
569
    }
570
    return buf_ptr - buf;
571
}
572
#endif /* CONFIG_MPEGAUDIO_PARSER */
573

    
574
#if defined(CONFIG_AC3_PARSER) || defined(CONFIG_AAC_PARSER)
575
/* also used for ADTS AAC */
576
typedef struct AC3ParseContext {
577
    uint8_t *inbuf_ptr;
578
    int frame_size;
579
    int header_size;
580
    int (*sync)(const uint8_t *buf, int *channels, int *sample_rate,
581
                int *bit_rate, int *samples);
582
    uint8_t inbuf[8192]; /* input buffer */
583
} AC3ParseContext;
584

    
585
#define AC3_HEADER_SIZE 7
586
#define AAC_HEADER_SIZE 7
587

    
588
#ifdef CONFIG_AC3_PARSER
589

    
590
static const uint8_t eac3_blocks[4] = {
591
    1, 2, 3, 6
592
};
593

    
594
#endif /* CONFIG_AC3_PARSER */
595

    
596
#ifdef CONFIG_AAC_PARSER
597
static const int aac_sample_rates[16] = {
598
    96000, 88200, 64000, 48000, 44100, 32000,
599
    24000, 22050, 16000, 12000, 11025, 8000, 7350
600
};
601

    
602
static const int aac_channels[8] = {
603
    0, 1, 2, 3, 4, 5, 6, 8
604
};
605
#endif
606

    
607
#ifdef CONFIG_AC3_PARSER
608
static int ac3_sync(const uint8_t *buf, int *channels, int *sample_rate,
609
                    int *bit_rate, int *samples)
610
{
611
    int err;
612
    unsigned int fscod, acmod, bsid, lfeon;
613
    unsigned int strmtyp, substreamid, frmsiz, fscod2, numblkscod;
614
    GetBitContext bits;
615
    AC3HeaderInfo hdr;
616

    
617
    err = ff_ac3_parse_header(buf, &hdr);
618

    
619
    if(err < 0 && err != -2)
620
        return 0;
621

    
622
    bsid = hdr.bsid;
623
    if(bsid <= 10) {             /* Normal AC-3 */
624
        *sample_rate = hdr.sample_rate;
625
        *bit_rate = hdr.bit_rate;
626
        *channels = hdr.channels;
627
        *samples = AC3_FRAME_SIZE;
628
        return hdr.frame_size;
629
    } else if (bsid > 10 && bsid <= 16) { /* Enhanced AC-3 */
630
        init_get_bits(&bits, &buf[2], (AC3_HEADER_SIZE-2) * 8);
631
        strmtyp = get_bits(&bits, 2);
632
        substreamid = get_bits(&bits, 3);
633

    
634
        if (strmtyp != 0 || substreamid != 0)
635
            return 0;   /* Currently don't support additional streams */
636

    
637
        frmsiz = get_bits(&bits, 11) + 1;
638
        fscod = get_bits(&bits, 2);
639
        if (fscod == 3) {
640
            fscod2 = get_bits(&bits, 2);
641
            numblkscod = 3;
642

    
643
            if(fscod2 == 3)
644
                return 0;
645

    
646
            *sample_rate = ff_ac3_freqs[fscod2] / 2;
647
        } else {
648
            numblkscod = get_bits(&bits, 2);
649

    
650
            *sample_rate = ff_ac3_freqs[fscod];
651
        }
652

    
653
        acmod = get_bits(&bits, 3);
654
        lfeon = get_bits1(&bits);
655

    
656
        *samples = eac3_blocks[numblkscod] * 256;
657
        *bit_rate = frmsiz * (*sample_rate) * 16 / (*samples);
658
        *channels = ff_ac3_channels[acmod] + lfeon;
659

    
660
        return frmsiz * 2;
661
    }
662

    
663
    /* Unsupported bitstream version */
664
    return 0;
665
}
666
#endif /* CONFIG_AC3_PARSER */
667

    
668
#ifdef CONFIG_AAC_PARSER
669
static int aac_sync(const uint8_t *buf, int *channels, int *sample_rate,
670
                    int *bit_rate, int *samples)
671
{
672
    GetBitContext bits;
673
    int size, rdb, ch, sr;
674

    
675
    init_get_bits(&bits, buf, AAC_HEADER_SIZE * 8);
676

    
677
    if(get_bits(&bits, 12) != 0xfff)
678
        return 0;
679

    
680
    skip_bits1(&bits);          /* id */
681
    skip_bits(&bits, 2);        /* layer */
682
    skip_bits1(&bits);          /* protection_absent */
683
    skip_bits(&bits, 2);        /* profile_objecttype */
684
    sr = get_bits(&bits, 4);    /* sample_frequency_index */
685
    if(!aac_sample_rates[sr])
686
        return 0;
687
    skip_bits1(&bits);          /* private_bit */
688
    ch = get_bits(&bits, 3);    /* channel_configuration */
689
    if(!aac_channels[ch])
690
        return 0;
691
    skip_bits1(&bits);          /* original/copy */
692
    skip_bits1(&bits);          /* home */
693

    
694
    /* adts_variable_header */
695
    skip_bits1(&bits);          /* copyright_identification_bit */
696
    skip_bits1(&bits);          /* copyright_identification_start */
697
    size = get_bits(&bits, 13); /* aac_frame_length */
698
    skip_bits(&bits, 11);       /* adts_buffer_fullness */
699
    rdb = get_bits(&bits, 2);   /* number_of_raw_data_blocks_in_frame */
700

    
701
    *channels = aac_channels[ch];
702
    *sample_rate = aac_sample_rates[sr];
703
    *samples = (rdb + 1) * 1024;
704
    *bit_rate = size * 8 * *sample_rate / *samples;
705

    
706
    return size;
707
}
708
#endif /* CONFIG_AAC_PARSER */
709

    
710
#ifdef CONFIG_AC3_PARSER
711
static int ac3_parse_init(AVCodecParserContext *s1)
712
{
713
    AC3ParseContext *s = s1->priv_data;
714
    s->inbuf_ptr = s->inbuf;
715
    s->header_size = AC3_HEADER_SIZE;
716
    s->sync = ac3_sync;
717
    return 0;
718
}
719
#endif
720

    
721
#ifdef CONFIG_AAC_PARSER
722
static int aac_parse_init(AVCodecParserContext *s1)
723
{
724
    AC3ParseContext *s = s1->priv_data;
725
    s->inbuf_ptr = s->inbuf;
726
    s->header_size = AAC_HEADER_SIZE;
727
    s->sync = aac_sync;
728
    return 0;
729
}
730
#endif
731

    
732
/* also used for ADTS AAC */
733
static int ac3_parse(AVCodecParserContext *s1,
734
                     AVCodecContext *avctx,
735
                     uint8_t **poutbuf, int *poutbuf_size,
736
                     const uint8_t *buf, int buf_size)
737
{
738
    AC3ParseContext *s = s1->priv_data;
739
    const uint8_t *buf_ptr;
740
    int len, sample_rate, bit_rate, channels, samples;
741

    
742
    *poutbuf = NULL;
743
    *poutbuf_size = 0;
744

    
745
    buf_ptr = buf;
746
    while (buf_size > 0) {
747
        len = s->inbuf_ptr - s->inbuf;
748
        if (s->frame_size == 0) {
749
            /* no header seen : find one. We need at least s->header_size
750
               bytes to parse it */
751
            len = FFMIN(s->header_size - len, buf_size);
752

    
753
            memcpy(s->inbuf_ptr, buf_ptr, len);
754
            buf_ptr += len;
755
            s->inbuf_ptr += len;
756
            buf_size -= len;
757
            if ((s->inbuf_ptr - s->inbuf) == s->header_size) {
758
                len = s->sync(s->inbuf, &channels, &sample_rate, &bit_rate,
759
                              &samples);
760
                if (len == 0) {
761
                    /* no sync found : move by one byte (inefficient, but simple!) */
762
                    memmove(s->inbuf, s->inbuf + 1, s->header_size - 1);
763
                    s->inbuf_ptr--;
764
                } else {
765
                    s->frame_size = len;
766
                    /* update codec info */
767
                    avctx->sample_rate = sample_rate;
768
                    /* set channels,except if the user explicitly requests 1 or 2 channels, XXX/FIXME this is a bit ugly */
769
                    if(avctx->codec_id == CODEC_ID_AC3){
770
                        if(avctx->channels!=1 && avctx->channels!=2){
771
                            avctx->channels = channels;
772
                        }
773
                    } else {
774
                        avctx->channels = channels;
775
                    }
776
                    avctx->bit_rate = bit_rate;
777
                    avctx->frame_size = samples;
778
                }
779
            }
780
        } else {
781
            len = FFMIN(s->frame_size - len, buf_size);
782

    
783
            memcpy(s->inbuf_ptr, buf_ptr, len);
784
            buf_ptr += len;
785
            s->inbuf_ptr += len;
786
            buf_size -= len;
787

    
788
            if(s->inbuf_ptr - s->inbuf == s->frame_size){
789
                *poutbuf = s->inbuf;
790
                *poutbuf_size = s->frame_size;
791
                s->inbuf_ptr = s->inbuf;
792
                s->frame_size = 0;
793
                break;
794
            }
795
        }
796
    }
797
    return buf_ptr - buf;
798
}
799
#endif /* CONFIG_AC3_PARSER || CONFIG_AAC_PARSER */
800

    
801
#ifdef CONFIG_MPEG4VIDEO_PARSER
802
AVCodecParser mpeg4video_parser = {
803
    { CODEC_ID_MPEG4 },
804
    sizeof(ParseContext1),
805
    mpeg4video_parse_init,
806
    mpeg4video_parse,
807
    ff_parse1_close,
808
    ff_mpeg4video_split,
809
};
810
#endif
811
#ifdef CONFIG_MPEGAUDIO_PARSER
812
AVCodecParser mpegaudio_parser = {
813
    { CODEC_ID_MP2, CODEC_ID_MP3 },
814
    sizeof(MpegAudioParseContext),
815
    mpegaudio_parse_init,
816
    mpegaudio_parse,
817
    NULL,
818
};
819
#endif
820
#ifdef CONFIG_AC3_PARSER
821
AVCodecParser ac3_parser = {
822
    { CODEC_ID_AC3 },
823
    sizeof(AC3ParseContext),
824
    ac3_parse_init,
825
    ac3_parse,
826
    NULL,
827
};
828
#endif
829
#ifdef CONFIG_AAC_PARSER
830
AVCodecParser aac_parser = {
831
    { CODEC_ID_AAC },
832
    sizeof(AC3ParseContext),
833
    aac_parse_init,
834
    ac3_parse,
835
    NULL,
836
};
837
#endif