Statistics
| Branch: | Revision:

ffmpeg / libavcodec / parser.c @ b482e2d1

History | View | Annotate | Download (32.7 KB)

1
/*
2
 * Audio and Video frame extraction
3
 * Copyright (c) 2003 Fabrice Bellard.
4
 * Copyright (c) 2003 Michael Niedermayer.
5
 *
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.
10
 *
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.
15
 *
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
19
 */
20
#include "avcodec.h"
21
#include "mpegvideo.h"
22
#include "mpegaudio.h"
23

    
24
AVCodecParser *av_first_parser = NULL;
25

    
26
void av_register_codec_parser(AVCodecParser *parser)
27
{
28
    parser->next = av_first_parser;
29
    av_first_parser = parser;
30
}
31

    
32
AVCodecParserContext *av_parser_init(int codec_id)
33
{
34
    AVCodecParserContext *s;
35
    AVCodecParser *parser;
36
    int ret;
37

    
38
    if(codec_id == CODEC_ID_NONE)
39
        return NULL;
40

    
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)
47
            goto found;
48
    }
49
    return NULL;
50
 found:
51
    s = av_mallocz(sizeof(AVCodecParserContext));
52
    if (!s)
53
        return NULL;
54
    s->parser = parser;
55
    s->priv_data = av_mallocz(parser->priv_data_size);
56
    if (!s->priv_data) {
57
        av_free(s);
58
        return NULL;
59
    }
60
    if (parser->parser_init) {
61
        ret = parser->parser_init(s);
62
        if (ret != 0) {
63
            av_free(s->priv_data);
64
            av_free(s);
65
            return NULL;
66
        }
67
    }
68
    s->fetch_timestamp=1;
69
    return s;
70
}
71

    
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)
79
{
80
    int index, i, k;
81
    uint8_t dummy_buf[FF_INPUT_BUFFER_PADDING_SIZE];
82

    
83
    if (buf_size == 0) {
84
        /* padding is always necessary even if EOF, so we add it here */
85
        memset(dummy_buf, 0, sizeof(dummy_buf));
86
        buf = dummy_buf;
87
    } else {
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;
94

    
95
        /* fill first PTS/DTS */
96
        if (s->fetch_timestamp){
97
            s->fetch_timestamp=0;
98
            s->last_pts = pts;
99
            s->last_dts = dts;
100
            s->cur_frame_pts[k] =
101
            s->cur_frame_dts[k] = AV_NOPTS_VALUE;
102
        }
103
    }
104

    
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 */
109
    if (*poutbuf_size) {
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;
114

    
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
122
           packets. */
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])
126
                break;
127
            k = (k - 1) & (AV_PARSER_PTS_NB - 1);
128
        }
129

    
130
        s->last_pts = s->cur_frame_pts[k];
131
        s->last_dts = s->cur_frame_dts[k];
132

    
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;
137
        }
138
    }
139
    if (index < 0)
140
        index = 0;
141
    s->cur_offset += index;
142
    return index;
143
}
144

    
145
/**
146
 *
147
 * @return 0 if the output buffer is a subset of the input, 1 if it is allocated and must be freed
148
 */
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){
153

    
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);
157
            buf += i;
158
            buf_size -= i;
159
        }
160
    }
161

    
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;
170
            *poutbuf_size= size;
171
            *poutbuf= av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
172

    
173
            memcpy(*poutbuf, avctx->extradata, avctx->extradata_size);
174
            memcpy((*poutbuf) + avctx->extradata_size, buf, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
175
            return 1;
176
        }
177
    }
178

    
179
    return 0;
180
}
181

    
182
void av_parser_close(AVCodecParserContext *s)
183
{
184
    if (s->parser->parser_close)
185
        s->parser->parser_close(s);
186
    av_free(s->priv_data);
187
    av_free(s);
188
}
189

    
190
/*****************************************************/
191

    
192
//#define END_NOT_FOUND (-100)
193

    
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
199

    
200
typedef struct ParseContext1{
201
    ParseContext pc;
202
/* XXX/FIXME PC1 vs. PC */
203
    /* MPEG2 specific */
204
    int frame_rate;
205
    int progressive_sequence;
206
    int width, height;
207

    
208
    /* XXX: suppress that, needed by MPEG4 */
209
    MpegEncContext *enc;
210
    int first_picture;
211
} ParseContext1;
212

    
213
/**
214
 * combines the (truncated) bitstream to a complete frame
215
 * @returns -1 if no complete frame could be created
216
 */
217
int ff_combine_frame(ParseContext *pc, int next, uint8_t **buf, int *buf_size)
218
{
219
#if 0
220
    if(pc->overread){
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]);
223
    }
224
#endif
225

    
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++];
229
    }
230

    
231
    /* flush remaining if EOF */
232
    if(!*buf_size && next == END_NOT_FOUND){
233
        next= 0;
234
    }
235

    
236
    pc->last_index= pc->index;
237

    
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);
241

    
242
        memcpy(&pc->buffer[pc->index], *buf, *buf_size);
243
        pc->index += *buf_size;
244
        return -1;
245
    }
246

    
247
    *buf_size=
248
    pc->overread_index= pc->index + next;
249

    
250
    /* append to buffer */
251
    if(pc->index){
252
        pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
253

    
254
        memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
255
        pc->index = 0;
256
        *buf= pc->buffer;
257
    }
258

    
259
    /* store overread bytes */
260
    for(;next < 0; next++){
261
        pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
262
        pc->overread++;
263
    }
264

    
265
#if 0
266
    if(pc->overread){
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]);
269
    }
270
#endif
271

    
272
    return 0;
273
}
274

    
275
/* XXX: merge with libavcodec ? */
276
#define MPEG1_FRAME_RATE_BASE 1001
277

    
278
static const int frame_rate_tab[16] = {
279
        0,
280
    24000,
281
    24024,
282
    25025,
283
    30000,
284
    30030,
285
    50050,
286
    60000,
287
    60060,
288
  // Xing's 15fps: (9)
289
    15015,
290
  // libmpeg3's "Unofficial economy rates": (10-13)
291
     5005,
292
    10010,
293
    12012,
294
    15015,
295
  // random, just to avoid segfault !never encode these
296
    25025,
297
    25025,
298
};
299

    
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)
304
{
305
    ParseContext1 *pc = s->priv_data;
306
    const uint8_t *buf_end;
307
    int32_t start_code;
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()
313
    s->repeat_pict = 0;
314
    buf_end = buf + buf_size;
315
    while (buf < buf_end) {
316
        start_code= -1;
317
        buf= ff_find_start_code(buf, buf_end, &start_code);
318
        bytes_left = buf_end - buf;
319
        switch(start_code) {
320
        case PICTURE_START_CODE:
321
            if (bytes_left >= 2) {
322
                s->pict_type = (buf[1] >> 3) & 7;
323
            }
324
            break;
325
        case SEQ_START_CODE:
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;
335
                avctx->sub_id = 1;
336
            }
337
            break;
338
        case EXT_START_CODE:
339
            if (bytes_left >= 1) {
340
                ext_type = (buf[0] >> 4);
341
                switch(ext_type) {
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);
351

    
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 */
360
                    }
361
                    break;
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);
368

    
369
                        /* check if we must repeat the frame */
370
                        if (repeat_first_field) {
371
                            if (pc->progressive_sequence) {
372
                                if (top_field_first)
373
                                    s->repeat_pict = 4;
374
                                else
375
                                    s->repeat_pict = 2;
376
                            } else if (progressive_frame) {
377
                                s->repeat_pict = 1;
378
                            }
379
                        }
380

    
381
                        /* the packet only represents half a frame
382
                           XXX,FIXME maybe find a different solution */
383
                        if(picture_structure != 3)
384
                            s->repeat_pict = -1;
385
                    }
386
                    break;
387
                }
388
            }
389
            break;
390
        case -1:
391
            goto the_end;
392
        default:
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)
397
                goto the_end;
398
            break;
399
        }
400
    }
401
 the_end: ;
402
}
403

    
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)
408
{
409
    ParseContext1 *pc1 = s->priv_data;
410
    ParseContext *pc= &pc1->pc;
411
    int next;
412

    
413
    if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
414
        next= buf_size;
415
    }else{
416
        next= ff_mpeg1_find_frame_end(pc, buf, buf_size);
417

    
418
        if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
419
            *poutbuf = NULL;
420
            *poutbuf_size = 0;
421
            return buf_size;
422
        }
423

    
424
    }
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);
429
#if 0
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);
432
#endif
433

    
434
    *poutbuf = (uint8_t *)buf;
435
    *poutbuf_size = buf_size;
436
    return next;
437
}
438

    
439
static int mpegvideo_split(AVCodecContext *avctx,
440
                           const uint8_t *buf, int buf_size)
441
{
442
    int i;
443
    uint32_t state= -1;
444

    
445
    for(i=0; i<buf_size; i++){
446
        state= (state<<8) | buf[i];
447
        if(state != 0x1B3 && state != 0x1B5 && state < 0x200 && state >= 0x100)
448
            return i-3;
449
    }
450
    return 0;
451
}
452

    
453
void ff_parse_close(AVCodecParserContext *s)
454
{
455
    ParseContext *pc = s->priv_data;
456

    
457
    av_free(pc->buffer);
458
}
459

    
460
static void parse1_close(AVCodecParserContext *s)
461
{
462
    ParseContext1 *pc1 = s->priv_data;
463

    
464
    av_free(pc1->pc.buffer);
465
    av_free(pc1->enc);
466
}
467

    
468
/*************************/
469

    
470
/* used by parser */
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)
475
{
476
    ParseContext1 *pc = s1->priv_data;
477
    MpegEncContext *s = pc->enc;
478
    GetBitContext gb1, *gb = &gb1;
479
    int ret;
480

    
481
    s->avctx = avctx;
482
    s->current_picture_ptr = &s->current_picture;
483

    
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);
487
    }
488

    
489
    init_get_bits(gb, buf, 8 * buf_size);
490
    ret = ff_mpeg4_decode_picture_header(s, gb);
491
    if (s->width) {
492
        avcodec_set_dimensions(avctx, s->width, s->height);
493
    }
494
    s1->pict_type= s->pict_type;
495
    pc->first_picture = 0;
496
    return ret;
497
}
498

    
499
static int mpeg4video_parse_init(AVCodecParserContext *s)
500
{
501
    ParseContext1 *pc = s->priv_data;
502

    
503
    pc->enc = av_mallocz(sizeof(MpegEncContext));
504
    if (!pc->enc)
505
        return -1;
506
    pc->first_picture = 1;
507
    return 0;
508
}
509

    
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)
514
{
515
    ParseContext *pc = s->priv_data;
516
    int next;
517

    
518
    if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
519
        next= buf_size;
520
    }else{
521
        next= ff_mpeg4_find_frame_end(pc, buf, buf_size);
522

    
523
        if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
524
            *poutbuf = NULL;
525
            *poutbuf_size = 0;
526
            return buf_size;
527
        }
528
    }
529
    av_mpeg4_decode_header(s, avctx, buf, buf_size);
530

    
531
    *poutbuf = (uint8_t *)buf;
532
    *poutbuf_size = buf_size;
533
    return next;
534
}
535

    
536
static int cavsvideo_parse(AVCodecParserContext *s,
537
                           AVCodecContext *avctx,
538
                           uint8_t **poutbuf, int *poutbuf_size,
539
                           const uint8_t *buf, int buf_size)
540
{
541
    ParseContext *pc = s->priv_data;
542
    int next;
543

    
544
    if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
545
        next= buf_size;
546
    }else{
547
        next= ff_cavs_find_frame_end(pc, buf, buf_size);
548

    
549
        if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
550
            *poutbuf = NULL;
551
            *poutbuf_size = 0;
552
            return buf_size;
553
        }
554
    }
555
    *poutbuf = (uint8_t *)buf;
556
    *poutbuf_size = buf_size;
557
    return next;
558
}
559

    
560
static int mpeg4video_split(AVCodecContext *avctx,
561
                           const uint8_t *buf, int buf_size)
562
{
563
    int i;
564
    uint32_t state= -1;
565

    
566
    for(i=0; i<buf_size; i++){
567
        state= (state<<8) | buf[i];
568
        if(state == 0x1B3 || state == 0x1B6)
569
            return i-3;
570
    }
571
    return 0;
572
}
573

    
574
/*************************/
575

    
576
typedef struct MpegAudioParseContext {
577
    uint8_t inbuf[MPA_MAX_CODED_FRAME_SIZE];    /* input buffer */
578
    uint8_t *inbuf_ptr;
579
    int frame_size;
580
    int free_format_frame_size;
581
    int free_format_next_header;
582
    uint32_t header;
583
    int header_count;
584
} MpegAudioParseContext;
585

    
586
#define MPA_HEADER_SIZE 4
587

    
588
/* header + layer + bitrate + freq + lsf/mpeg25 */
589
#undef SAME_HEADER_MASK /* mpegaudio.h defines different version */
590
#define SAME_HEADER_MASK \
591
   (0xffe00000 | (3 << 17) | (3 << 10) | (3 << 19))
592

    
593
static int mpegaudio_parse_init(AVCodecParserContext *s1)
594
{
595
    MpegAudioParseContext *s = s1->priv_data;
596
    s->inbuf_ptr = s->inbuf;
597
    return 0;
598
}
599

    
600
static int mpegaudio_parse(AVCodecParserContext *s1,
601
                           AVCodecContext *avctx,
602
                           uint8_t **poutbuf, int *poutbuf_size,
603
                           const uint8_t *buf, int buf_size)
604
{
605
    MpegAudioParseContext *s = s1->priv_data;
606
    int len, ret, sr;
607
    uint32_t header;
608
    const uint8_t *buf_ptr;
609

    
610
    *poutbuf = NULL;
611
    *poutbuf_size = 0;
612
    buf_ptr = buf;
613
    while (buf_size > 0) {
614
        len = s->inbuf_ptr - s->inbuf;
615
        if (s->frame_size == 0) {
616
            /* special case for next header for first frame in free
617
               format case (XXX: find a simpler method) */
618
            if (s->free_format_next_header != 0) {
619
                s->inbuf[0] = s->free_format_next_header >> 24;
620
                s->inbuf[1] = s->free_format_next_header >> 16;
621
                s->inbuf[2] = s->free_format_next_header >> 8;
622
                s->inbuf[3] = s->free_format_next_header;
623
                s->inbuf_ptr = s->inbuf + 4;
624
                s->free_format_next_header = 0;
625
                goto got_header;
626
            }
627
            /* no header seen : find one. We need at least MPA_HEADER_SIZE
628
               bytes to parse it */
629
            len = MPA_HEADER_SIZE - len;
630
            if (len > buf_size)
631
                len = buf_size;
632
            if (len > 0) {
633
                memcpy(s->inbuf_ptr, buf_ptr, len);
634
                buf_ptr += len;
635
                buf_size -= len;
636
                s->inbuf_ptr += len;
637
            }
638
            if ((s->inbuf_ptr - s->inbuf) >= MPA_HEADER_SIZE) {
639
            got_header:
640
                sr= avctx->sample_rate;
641
                header = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
642
                    (s->inbuf[2] << 8) | s->inbuf[3];
643

    
644
                ret = mpa_decode_header(avctx, header);
645
                if (ret < 0) {
646
                    s->header_count= -2;
647
                    /* no sync found : move by one byte (inefficient, but simple!) */
648
                    memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
649
                    s->inbuf_ptr--;
650
                    dprintf("skip %x\n", header);
651
                    /* reset free format frame size to give a chance
652
                       to get a new bitrate */
653
                    s->free_format_frame_size = 0;
654
                } else {
655
                    if((header&SAME_HEADER_MASK) != (s->header&SAME_HEADER_MASK) && s->header)
656
                        s->header_count= -3;
657
                    s->header= header;
658
                    s->header_count++;
659
                    s->frame_size = ret;
660

    
661
#if 0
662
                    /* free format: prepare to compute frame size */
663
                    if (decode_header(s, header) == 1) {
664
                        s->frame_size = -1;
665
                    }
666
#endif
667
                }
668
                if(s->header_count <= 0)
669
                    avctx->sample_rate= sr; //FIXME ugly
670
            }
671
        } else
672
#if 0
673
        if (s->frame_size == -1) {
674
            /* free format : find next sync to compute frame size */
675
            len = MPA_MAX_CODED_FRAME_SIZE - len;
676
            if (len > buf_size)
677
                len = buf_size;
678
            if (len == 0) {
679
                /* frame too long: resync */
680
                s->frame_size = 0;
681
                memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
682
                s->inbuf_ptr--;
683
            } else {
684
                uint8_t *p, *pend;
685
                uint32_t header1;
686
                int padding;
687

688
                memcpy(s->inbuf_ptr, buf_ptr, len);
689
                /* check for header */
690
                p = s->inbuf_ptr - 3;
691
                pend = s->inbuf_ptr + len - 4;
692
                while (p <= pend) {
693
                    header = (p[0] << 24) | (p[1] << 16) |
694
                        (p[2] << 8) | p[3];
695
                    header1 = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
696
                        (s->inbuf[2] << 8) | s->inbuf[3];
697
                    /* check with high probability that we have a
698
                       valid header */
699
                    if ((header & SAME_HEADER_MASK) ==
700
                        (header1 & SAME_HEADER_MASK)) {
701
                        /* header found: update pointers */
702
                        len = (p + 4) - s->inbuf_ptr;
703
                        buf_ptr += len;
704
                        buf_size -= len;
705
                        s->inbuf_ptr = p;
706
                        /* compute frame size */
707
                        s->free_format_next_header = header;
708
                        s->free_format_frame_size = s->inbuf_ptr - s->inbuf;
709
                        padding = (header1 >> 9) & 1;
710
                        if (s->layer == 1)
711
                            s->free_format_frame_size -= padding * 4;
712
                        else
713
                            s->free_format_frame_size -= padding;
714
                        dprintf("free frame size=%d padding=%d\n",
715
                                s->free_format_frame_size, padding);
716
                        decode_header(s, header1);
717
                        goto next_data;
718
                    }
719
                    p++;
720
                }
721
                /* not found: simply increase pointers */
722
                buf_ptr += len;
723
                s->inbuf_ptr += len;
724
                buf_size -= len;
725
            }
726
        } else
727
#endif
728
        if (len < s->frame_size) {
729
            if (s->frame_size > MPA_MAX_CODED_FRAME_SIZE)
730
                s->frame_size = MPA_MAX_CODED_FRAME_SIZE;
731
            len = s->frame_size - len;
732
            if (len > buf_size)
733
                len = buf_size;
734
            memcpy(s->inbuf_ptr, buf_ptr, len);
735
            buf_ptr += len;
736
            s->inbuf_ptr += len;
737
            buf_size -= len;
738
        }
739
        //    next_data:
740
        if (s->frame_size > 0 &&
741
            (s->inbuf_ptr - s->inbuf) >= s->frame_size) {
742
            if(s->header_count > 0){
743
                *poutbuf = s->inbuf;
744
                *poutbuf_size = s->inbuf_ptr - s->inbuf;
745
            }
746
            s->inbuf_ptr = s->inbuf;
747
            s->frame_size = 0;
748
            break;
749
        }
750
    }
751
    return buf_ptr - buf;
752
}
753

    
754
/* also used for ADTS AAC */
755
typedef struct AC3ParseContext {
756
    uint8_t *inbuf_ptr;
757
    int frame_size;
758
    int header_size;
759
    int (*sync)(const uint8_t *buf, int *channels, int *sample_rate,
760
                int *bit_rate, int *samples);
761
    uint8_t inbuf[8192]; /* input buffer */
762
} AC3ParseContext;
763

    
764
#define AC3_HEADER_SIZE 7
765
#define AAC_HEADER_SIZE 7
766

    
767
static const int ac3_sample_rates[4] = {
768
    48000, 44100, 32000, 0
769
};
770

    
771
static const int ac3_frame_sizes[64][3] = {
772
    { 64,   69,   96   },
773
    { 64,   70,   96   },
774
    { 80,   87,   120  },
775
    { 80,   88,   120  },
776
    { 96,   104,  144  },
777
    { 96,   105,  144  },
778
    { 112,  121,  168  },
779
    { 112,  122,  168  },
780
    { 128,  139,  192  },
781
    { 128,  140,  192  },
782
    { 160,  174,  240  },
783
    { 160,  175,  240  },
784
    { 192,  208,  288  },
785
    { 192,  209,  288  },
786
    { 224,  243,  336  },
787
    { 224,  244,  336  },
788
    { 256,  278,  384  },
789
    { 256,  279,  384  },
790
    { 320,  348,  480  },
791
    { 320,  349,  480  },
792
    { 384,  417,  576  },
793
    { 384,  418,  576  },
794
    { 448,  487,  672  },
795
    { 448,  488,  672  },
796
    { 512,  557,  768  },
797
    { 512,  558,  768  },
798
    { 640,  696,  960  },
799
    { 640,  697,  960  },
800
    { 768,  835,  1152 },
801
    { 768,  836,  1152 },
802
    { 896,  975,  1344 },
803
    { 896,  976,  1344 },
804
    { 1024, 1114, 1536 },
805
    { 1024, 1115, 1536 },
806
    { 1152, 1253, 1728 },
807
    { 1152, 1254, 1728 },
808
    { 1280, 1393, 1920 },
809
    { 1280, 1394, 1920 },
810
};
811

    
812
static const int ac3_bitrates[64] = {
813
    32, 32, 40, 40, 48, 48, 56, 56, 64, 64, 80, 80, 96, 96, 112, 112,
814
    128, 128, 160, 160, 192, 192, 224, 224, 256, 256, 320, 320, 384,
815
    384, 448, 448, 512, 512, 576, 576, 640, 640,
816
};
817

    
818
static const int ac3_channels[8] = {
819
    2, 1, 2, 3, 3, 4, 4, 5
820
};
821

    
822
static int aac_sample_rates[16] = {
823
    96000, 88200, 64000, 48000, 44100, 32000,
824
    24000, 22050, 16000, 12000, 11025, 8000, 7350
825
};
826

    
827
static int aac_channels[8] = {
828
    0, 1, 2, 3, 4, 5, 6, 8
829
};
830

    
831
static int ac3_sync(const uint8_t *buf, int *channels, int *sample_rate,
832
                    int *bit_rate, int *samples)
833
{
834
    unsigned int fscod, frmsizecod, acmod, bsid, lfeon;
835
    GetBitContext bits;
836

    
837
    init_get_bits(&bits, buf, AC3_HEADER_SIZE * 8);
838

    
839
    if(get_bits(&bits, 16) != 0x0b77)
840
        return 0;
841

    
842
    skip_bits(&bits, 16);       /* crc */
843
    fscod = get_bits(&bits, 2);
844
    frmsizecod = get_bits(&bits, 6);
845

    
846
    if(!ac3_sample_rates[fscod])
847
        return 0;
848

    
849
    bsid = get_bits(&bits, 5);
850
    if(bsid > 8)
851
        return 0;
852
    skip_bits(&bits, 3);        /* bsmod */
853
    acmod = get_bits(&bits, 3);
854
    if(acmod & 1 && acmod != 1)
855
        skip_bits(&bits, 2);    /* cmixlev */
856
    if(acmod & 4)
857
        skip_bits(&bits, 2);    /* surmixlev */
858
    if(acmod & 2)
859
        skip_bits(&bits, 2);    /* dsurmod */
860
    lfeon = get_bits1(&bits);
861

    
862
    *sample_rate = ac3_sample_rates[fscod];
863
    *bit_rate = ac3_bitrates[frmsizecod] * 1000;
864
    *channels = ac3_channels[acmod] + lfeon;
865
    *samples = 6 * 256;
866

    
867
    return ac3_frame_sizes[frmsizecod][fscod] * 2;
868
}
869

    
870
static int aac_sync(const uint8_t *buf, int *channels, int *sample_rate,
871
                    int *bit_rate, int *samples)
872
{
873
    GetBitContext bits;
874
    int size, rdb, ch, sr;
875

    
876
    init_get_bits(&bits, buf, AAC_HEADER_SIZE * 8);
877

    
878
    if(get_bits(&bits, 12) != 0xfff)
879
        return 0;
880

    
881
    skip_bits1(&bits);          /* id */
882
    skip_bits(&bits, 2);        /* layer */
883
    skip_bits1(&bits);          /* protection_absent */
884
    skip_bits(&bits, 2);        /* profile_objecttype */
885
    sr = get_bits(&bits, 4);    /* sample_frequency_index */
886
    if(!aac_sample_rates[sr])
887
        return 0;
888
    skip_bits1(&bits);          /* private_bit */
889
    ch = get_bits(&bits, 3);    /* channel_configuration */
890
    if(!aac_channels[ch])
891
        return 0;
892
    skip_bits1(&bits);          /* original/copy */
893
    skip_bits1(&bits);          /* home */
894

    
895
    /* adts_variable_header */
896
    skip_bits1(&bits);          /* copyright_identification_bit */
897
    skip_bits1(&bits);          /* copyright_identification_start */
898
    size = get_bits(&bits, 13); /* aac_frame_length */
899
    skip_bits(&bits, 11);       /* adts_buffer_fullness */
900
    rdb = get_bits(&bits, 2);   /* number_of_raw_data_blocks_in_frame */
901

    
902
    *channels = aac_channels[ch];
903
    *sample_rate = aac_sample_rates[sr];
904
    *samples = (rdb + 1) * 1024;
905
    *bit_rate = size * 8 * *sample_rate / *samples;
906

    
907
    return size;
908
}
909

    
910
static int ac3_parse_init(AVCodecParserContext *s1)
911
{
912
    AC3ParseContext *s = s1->priv_data;
913
    s->inbuf_ptr = s->inbuf;
914
    s->header_size = AC3_HEADER_SIZE;
915
    s->sync = ac3_sync;
916
    return 0;
917
}
918

    
919
static int aac_parse_init(AVCodecParserContext *s1)
920
{
921
    AC3ParseContext *s = s1->priv_data;
922
    s->inbuf_ptr = s->inbuf;
923
    s->header_size = AAC_HEADER_SIZE;
924
    s->sync = aac_sync;
925
    return 0;
926
}
927

    
928
/* also used for ADTS AAC */
929
static int ac3_parse(AVCodecParserContext *s1,
930
                     AVCodecContext *avctx,
931
                     uint8_t **poutbuf, int *poutbuf_size,
932
                     const uint8_t *buf, int buf_size)
933
{
934
    AC3ParseContext *s = s1->priv_data;
935
    const uint8_t *buf_ptr;
936
    int len, sample_rate, bit_rate, channels, samples;
937

    
938
    *poutbuf = NULL;
939
    *poutbuf_size = 0;
940

    
941
    buf_ptr = buf;
942
    while (buf_size > 0) {
943
        len = s->inbuf_ptr - s->inbuf;
944
        if (s->frame_size == 0) {
945
            /* no header seen : find one. We need at least s->header_size
946
               bytes to parse it */
947
            len = FFMIN(s->header_size - len, buf_size);
948

    
949
            memcpy(s->inbuf_ptr, buf_ptr, len);
950
            buf_ptr += len;
951
            s->inbuf_ptr += len;
952
            buf_size -= len;
953
            if ((s->inbuf_ptr - s->inbuf) == s->header_size) {
954
                len = s->sync(s->inbuf, &channels, &sample_rate, &bit_rate,
955
                              &samples);
956
                if (len == 0) {
957
                    /* no sync found : move by one byte (inefficient, but simple!) */
958
                    memmove(s->inbuf, s->inbuf + 1, s->header_size - 1);
959
                    s->inbuf_ptr--;
960
                } else {
961
                    s->frame_size = len;
962
                    /* update codec info */
963
                    avctx->sample_rate = sample_rate;
964
                    /* set channels,except if the user explicitly requests 1 or 2 channels, XXX/FIXME this is a bit ugly */
965
                    if(avctx->codec_id == CODEC_ID_AC3){
966
                        if(avctx->channels!=1 && avctx->channels!=2){
967
                            avctx->channels = channels;
968
                        }
969
                    } else {
970
                        avctx->channels = channels;
971
                    }
972
                    avctx->bit_rate = bit_rate;
973
                    avctx->frame_size = samples;
974
                }
975
            }
976
        } else {
977
            len = FFMIN(s->frame_size - len, buf_size);
978

    
979
            memcpy(s->inbuf_ptr, buf_ptr, len);
980
            buf_ptr += len;
981
            s->inbuf_ptr += len;
982
            buf_size -= len;
983

    
984
            if(s->inbuf_ptr - s->inbuf == s->frame_size){
985
                *poutbuf = s->inbuf;
986
                *poutbuf_size = s->frame_size;
987
                s->inbuf_ptr = s->inbuf;
988
                s->frame_size = 0;
989
                break;
990
            }
991
        }
992
    }
993
    return buf_ptr - buf;
994
}
995

    
996
AVCodecParser mpegvideo_parser = {
997
    { CODEC_ID_MPEG1VIDEO, CODEC_ID_MPEG2VIDEO },
998
    sizeof(ParseContext1),
999
    NULL,
1000
    mpegvideo_parse,
1001
    parse1_close,
1002
    mpegvideo_split,
1003
};
1004

    
1005
AVCodecParser mpeg4video_parser = {
1006
    { CODEC_ID_MPEG4 },
1007
    sizeof(ParseContext1),
1008
    mpeg4video_parse_init,
1009
    mpeg4video_parse,
1010
    parse1_close,
1011
    mpeg4video_split,
1012
};
1013

    
1014
AVCodecParser cavsvideo_parser = {
1015
    { CODEC_ID_CAVS },
1016
    sizeof(ParseContext1),
1017
    NULL,
1018
    cavsvideo_parse,
1019
    parse1_close,
1020
    mpeg4video_split,
1021
};
1022

    
1023
AVCodecParser mpegaudio_parser = {
1024
    { CODEC_ID_MP2, CODEC_ID_MP3 },
1025
    sizeof(MpegAudioParseContext),
1026
    mpegaudio_parse_init,
1027
    mpegaudio_parse,
1028
    NULL,
1029
};
1030

    
1031
AVCodecParser ac3_parser = {
1032
    { CODEC_ID_AC3 },
1033
    sizeof(AC3ParseContext),
1034
    ac3_parse_init,
1035
    ac3_parse,
1036
    NULL,
1037
};
1038

    
1039
AVCodecParser aac_parser = {
1040
    { CODEC_ID_AAC },
1041
    sizeof(AC3ParseContext),
1042
    aac_parse_init,
1043
    ac3_parse,
1044
    NULL,
1045
};