Statistics
| Branch: | Revision:

ffmpeg / libavcodec / parser.c @ 4f8ff17e

History | View | Annotate | Download (31.9 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 mpeg4video_split(AVCodecContext *avctx,
537
                           const uint8_t *buf, int buf_size)
538
{
539
    int i;
540
    uint32_t state= -1;
541

    
542
    for(i=0; i<buf_size; i++){
543
        state= (state<<8) | buf[i];
544
        if(state == 0x1B3 || state == 0x1B6)
545
            return i-3;
546
    }
547
    return 0;
548
}
549

    
550
/*************************/
551

    
552
typedef struct MpegAudioParseContext {
553
    uint8_t inbuf[MPA_MAX_CODED_FRAME_SIZE];    /* input buffer */
554
    uint8_t *inbuf_ptr;
555
    int frame_size;
556
    int free_format_frame_size;
557
    int free_format_next_header;
558
    uint32_t header;
559
    int header_count;
560
} MpegAudioParseContext;
561

    
562
#define MPA_HEADER_SIZE 4
563

    
564
/* header + layer + bitrate + freq + lsf/mpeg25 */
565
#undef SAME_HEADER_MASK /* mpegaudio.h defines different version */
566
#define SAME_HEADER_MASK \
567
   (0xffe00000 | (3 << 17) | (3 << 10) | (3 << 19))
568

    
569
static int mpegaudio_parse_init(AVCodecParserContext *s1)
570
{
571
    MpegAudioParseContext *s = s1->priv_data;
572
    s->inbuf_ptr = s->inbuf;
573
    return 0;
574
}
575

    
576
static int mpegaudio_parse(AVCodecParserContext *s1,
577
                           AVCodecContext *avctx,
578
                           uint8_t **poutbuf, int *poutbuf_size,
579
                           const uint8_t *buf, int buf_size)
580
{
581
    MpegAudioParseContext *s = s1->priv_data;
582
    int len, ret, sr;
583
    uint32_t header;
584
    const uint8_t *buf_ptr;
585

    
586
    *poutbuf = NULL;
587
    *poutbuf_size = 0;
588
    buf_ptr = buf;
589
    while (buf_size > 0) {
590
        len = s->inbuf_ptr - s->inbuf;
591
        if (s->frame_size == 0) {
592
            /* special case for next header for first frame in free
593
               format case (XXX: find a simpler method) */
594
            if (s->free_format_next_header != 0) {
595
                s->inbuf[0] = s->free_format_next_header >> 24;
596
                s->inbuf[1] = s->free_format_next_header >> 16;
597
                s->inbuf[2] = s->free_format_next_header >> 8;
598
                s->inbuf[3] = s->free_format_next_header;
599
                s->inbuf_ptr = s->inbuf + 4;
600
                s->free_format_next_header = 0;
601
                goto got_header;
602
            }
603
            /* no header seen : find one. We need at least MPA_HEADER_SIZE
604
               bytes to parse it */
605
            len = MPA_HEADER_SIZE - len;
606
            if (len > buf_size)
607
                len = buf_size;
608
            if (len > 0) {
609
                memcpy(s->inbuf_ptr, buf_ptr, len);
610
                buf_ptr += len;
611
                buf_size -= len;
612
                s->inbuf_ptr += len;
613
            }
614
            if ((s->inbuf_ptr - s->inbuf) >= MPA_HEADER_SIZE) {
615
            got_header:
616
                sr= avctx->sample_rate;
617
                header = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
618
                    (s->inbuf[2] << 8) | s->inbuf[3];
619

    
620
                ret = mpa_decode_header(avctx, header);
621
                if (ret < 0) {
622
                    s->header_count= -2;
623
                    /* no sync found : move by one byte (inefficient, but simple!) */
624
                    memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
625
                    s->inbuf_ptr--;
626
                    dprintf("skip %x\n", header);
627
                    /* reset free format frame size to give a chance
628
                       to get a new bitrate */
629
                    s->free_format_frame_size = 0;
630
                } else {
631
                    if((header&SAME_HEADER_MASK) != (s->header&SAME_HEADER_MASK) && s->header)
632
                        s->header_count= -3;
633
                    s->header= header;
634
                    s->header_count++;
635
                    s->frame_size = ret;
636

    
637
#if 0
638
                    /* free format: prepare to compute frame size */
639
                    if (decode_header(s, header) == 1) {
640
                        s->frame_size = -1;
641
                    }
642
#endif
643
                }
644
                if(s->header_count <= 0)
645
                    avctx->sample_rate= sr; //FIXME ugly
646
            }
647
        } else
648
#if 0
649
        if (s->frame_size == -1) {
650
            /* free format : find next sync to compute frame size */
651
            len = MPA_MAX_CODED_FRAME_SIZE - len;
652
            if (len > buf_size)
653
                len = buf_size;
654
            if (len == 0) {
655
                /* frame too long: resync */
656
                s->frame_size = 0;
657
                memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
658
                s->inbuf_ptr--;
659
            } else {
660
                uint8_t *p, *pend;
661
                uint32_t header1;
662
                int padding;
663

664
                memcpy(s->inbuf_ptr, buf_ptr, len);
665
                /* check for header */
666
                p = s->inbuf_ptr - 3;
667
                pend = s->inbuf_ptr + len - 4;
668
                while (p <= pend) {
669
                    header = (p[0] << 24) | (p[1] << 16) |
670
                        (p[2] << 8) | p[3];
671
                    header1 = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
672
                        (s->inbuf[2] << 8) | s->inbuf[3];
673
                    /* check with high probability that we have a
674
                       valid header */
675
                    if ((header & SAME_HEADER_MASK) ==
676
                        (header1 & SAME_HEADER_MASK)) {
677
                        /* header found: update pointers */
678
                        len = (p + 4) - s->inbuf_ptr;
679
                        buf_ptr += len;
680
                        buf_size -= len;
681
                        s->inbuf_ptr = p;
682
                        /* compute frame size */
683
                        s->free_format_next_header = header;
684
                        s->free_format_frame_size = s->inbuf_ptr - s->inbuf;
685
                        padding = (header1 >> 9) & 1;
686
                        if (s->layer == 1)
687
                            s->free_format_frame_size -= padding * 4;
688
                        else
689
                            s->free_format_frame_size -= padding;
690
                        dprintf("free frame size=%d padding=%d\n",
691
                                s->free_format_frame_size, padding);
692
                        decode_header(s, header1);
693
                        goto next_data;
694
                    }
695
                    p++;
696
                }
697
                /* not found: simply increase pointers */
698
                buf_ptr += len;
699
                s->inbuf_ptr += len;
700
                buf_size -= len;
701
            }
702
        } else
703
#endif
704
        if (len < s->frame_size) {
705
            if (s->frame_size > MPA_MAX_CODED_FRAME_SIZE)
706
                s->frame_size = MPA_MAX_CODED_FRAME_SIZE;
707
            len = s->frame_size - len;
708
            if (len > buf_size)
709
                len = buf_size;
710
            memcpy(s->inbuf_ptr, buf_ptr, len);
711
            buf_ptr += len;
712
            s->inbuf_ptr += len;
713
            buf_size -= len;
714
        }
715
        //    next_data:
716
        if (s->frame_size > 0 &&
717
            (s->inbuf_ptr - s->inbuf) >= s->frame_size) {
718
            if(s->header_count > 0){
719
                *poutbuf = s->inbuf;
720
                *poutbuf_size = s->inbuf_ptr - s->inbuf;
721
            }
722
            s->inbuf_ptr = s->inbuf;
723
            s->frame_size = 0;
724
            break;
725
        }
726
    }
727
    return buf_ptr - buf;
728
}
729

    
730
/* also used for ADTS AAC */
731
typedef struct AC3ParseContext {
732
    uint8_t *inbuf_ptr;
733
    int frame_size;
734
    int header_size;
735
    int (*sync)(const uint8_t *buf, int *channels, int *sample_rate,
736
                int *bit_rate, int *samples);
737
    uint8_t inbuf[8192]; /* input buffer */
738
} AC3ParseContext;
739

    
740
#define AC3_HEADER_SIZE 7
741
#define AAC_HEADER_SIZE 7
742

    
743
static const int ac3_sample_rates[4] = {
744
    48000, 44100, 32000, 0
745
};
746

    
747
static const int ac3_frame_sizes[64][3] = {
748
    { 64,   69,   96   },
749
    { 64,   70,   96   },
750
    { 80,   87,   120  },
751
    { 80,   88,   120  },
752
    { 96,   104,  144  },
753
    { 96,   105,  144  },
754
    { 112,  121,  168  },
755
    { 112,  122,  168  },
756
    { 128,  139,  192  },
757
    { 128,  140,  192  },
758
    { 160,  174,  240  },
759
    { 160,  175,  240  },
760
    { 192,  208,  288  },
761
    { 192,  209,  288  },
762
    { 224,  243,  336  },
763
    { 224,  244,  336  },
764
    { 256,  278,  384  },
765
    { 256,  279,  384  },
766
    { 320,  348,  480  },
767
    { 320,  349,  480  },
768
    { 384,  417,  576  },
769
    { 384,  418,  576  },
770
    { 448,  487,  672  },
771
    { 448,  488,  672  },
772
    { 512,  557,  768  },
773
    { 512,  558,  768  },
774
    { 640,  696,  960  },
775
    { 640,  697,  960  },
776
    { 768,  835,  1152 },
777
    { 768,  836,  1152 },
778
    { 896,  975,  1344 },
779
    { 896,  976,  1344 },
780
    { 1024, 1114, 1536 },
781
    { 1024, 1115, 1536 },
782
    { 1152, 1253, 1728 },
783
    { 1152, 1254, 1728 },
784
    { 1280, 1393, 1920 },
785
    { 1280, 1394, 1920 },
786
};
787

    
788
static const int ac3_bitrates[64] = {
789
    32, 32, 40, 40, 48, 48, 56, 56, 64, 64, 80, 80, 96, 96, 112, 112,
790
    128, 128, 160, 160, 192, 192, 224, 224, 256, 256, 320, 320, 384,
791
    384, 448, 448, 512, 512, 576, 576, 640, 640,
792
};
793

    
794
static const int ac3_channels[8] = {
795
    2, 1, 2, 3, 3, 4, 4, 5
796
};
797

    
798
static int aac_sample_rates[16] = {
799
    96000, 88200, 64000, 48000, 44100, 32000,
800
    24000, 22050, 16000, 12000, 11025, 8000, 7350
801
};
802

    
803
static int aac_channels[8] = {
804
    0, 1, 2, 3, 4, 5, 6, 8
805
};
806

    
807
static int ac3_sync(const uint8_t *buf, int *channels, int *sample_rate,
808
                    int *bit_rate, int *samples)
809
{
810
    unsigned int fscod, frmsizecod, acmod, bsid, lfeon;
811
    GetBitContext bits;
812

    
813
    init_get_bits(&bits, buf, AC3_HEADER_SIZE * 8);
814

    
815
    if(get_bits(&bits, 16) != 0x0b77)
816
        return 0;
817

    
818
    skip_bits(&bits, 16);       /* crc */
819
    fscod = get_bits(&bits, 2);
820
    frmsizecod = get_bits(&bits, 6);
821

    
822
    if(!ac3_sample_rates[fscod])
823
        return 0;
824

    
825
    bsid = get_bits(&bits, 5);
826
    if(bsid > 8)
827
        return 0;
828
    skip_bits(&bits, 3);        /* bsmod */
829
    acmod = get_bits(&bits, 3);
830
    if(acmod & 1 && acmod != 1)
831
        skip_bits(&bits, 2);    /* cmixlev */
832
    if(acmod & 4)
833
        skip_bits(&bits, 2);    /* surmixlev */
834
    if(acmod & 2)
835
        skip_bits(&bits, 2);    /* dsurmod */
836
    lfeon = get_bits1(&bits);
837

    
838
    *sample_rate = ac3_sample_rates[fscod];
839
    *bit_rate = ac3_bitrates[frmsizecod] * 1000;
840
    *channels = ac3_channels[acmod] + lfeon;
841
    *samples = 6 * 256;
842

    
843
    return ac3_frame_sizes[frmsizecod][fscod] * 2;
844
}
845

    
846
static int aac_sync(const uint8_t *buf, int *channels, int *sample_rate,
847
                    int *bit_rate, int *samples)
848
{
849
    GetBitContext bits;
850
    int size, rdb, ch, sr;
851

    
852
    init_get_bits(&bits, buf, AAC_HEADER_SIZE * 8);
853

    
854
    if(get_bits(&bits, 12) != 0xfff)
855
        return 0;
856

    
857
    skip_bits1(&bits);          /* id */
858
    skip_bits(&bits, 2);        /* layer */
859
    skip_bits1(&bits);          /* protection_absent */
860
    skip_bits(&bits, 2);        /* profile_objecttype */
861
    sr = get_bits(&bits, 4);    /* sample_frequency_index */
862
    if(!aac_sample_rates[sr])
863
        return 0;
864
    skip_bits1(&bits);          /* private_bit */
865
    ch = get_bits(&bits, 3);    /* channel_configuration */
866
    if(!aac_channels[ch])
867
        return 0;
868
    skip_bits1(&bits);          /* original/copy */
869
    skip_bits1(&bits);          /* home */
870

    
871
    /* adts_variable_header */
872
    skip_bits1(&bits);          /* copyright_identification_bit */
873
    skip_bits1(&bits);          /* copyright_identification_start */
874
    size = get_bits(&bits, 13); /* aac_frame_length */
875
    skip_bits(&bits, 11);       /* adts_buffer_fullness */
876
    rdb = get_bits(&bits, 2);   /* number_of_raw_data_blocks_in_frame */
877

    
878
    *channels = aac_channels[ch];
879
    *sample_rate = aac_sample_rates[sr];
880
    *samples = (rdb + 1) * 1024;
881
    *bit_rate = size * 8 * *sample_rate / *samples;
882

    
883
    return size;
884
}
885

    
886
static int ac3_parse_init(AVCodecParserContext *s1)
887
{
888
    AC3ParseContext *s = s1->priv_data;
889
    s->inbuf_ptr = s->inbuf;
890
    s->header_size = AC3_HEADER_SIZE;
891
    s->sync = ac3_sync;
892
    return 0;
893
}
894

    
895
static int aac_parse_init(AVCodecParserContext *s1)
896
{
897
    AC3ParseContext *s = s1->priv_data;
898
    s->inbuf_ptr = s->inbuf;
899
    s->header_size = AAC_HEADER_SIZE;
900
    s->sync = aac_sync;
901
    return 0;
902
}
903

    
904
/* also used for ADTS AAC */
905
static int ac3_parse(AVCodecParserContext *s1,
906
                     AVCodecContext *avctx,
907
                     uint8_t **poutbuf, int *poutbuf_size,
908
                     const uint8_t *buf, int buf_size)
909
{
910
    AC3ParseContext *s = s1->priv_data;
911
    const uint8_t *buf_ptr;
912
    int len, sample_rate, bit_rate, channels, samples;
913

    
914
    *poutbuf = NULL;
915
    *poutbuf_size = 0;
916

    
917
    buf_ptr = buf;
918
    while (buf_size > 0) {
919
        len = s->inbuf_ptr - s->inbuf;
920
        if (s->frame_size == 0) {
921
            /* no header seen : find one. We need at least s->header_size
922
               bytes to parse it */
923
            len = FFMIN(s->header_size - len, buf_size);
924

    
925
            memcpy(s->inbuf_ptr, buf_ptr, len);
926
            buf_ptr += len;
927
            s->inbuf_ptr += len;
928
            buf_size -= len;
929
            if ((s->inbuf_ptr - s->inbuf) == s->header_size) {
930
                len = s->sync(s->inbuf, &channels, &sample_rate, &bit_rate,
931
                              &samples);
932
                if (len == 0) {
933
                    /* no sync found : move by one byte (inefficient, but simple!) */
934
                    memmove(s->inbuf, s->inbuf + 1, s->header_size - 1);
935
                    s->inbuf_ptr--;
936
                } else {
937
                    s->frame_size = len;
938
                    /* update codec info */
939
                    avctx->sample_rate = sample_rate;
940
                    /* set channels,except if the user explicitly requests 1 or 2 channels, XXX/FIXME this is a bit ugly */
941
                    if(avctx->codec_id == CODEC_ID_AC3){
942
                        if(avctx->channels!=1 && avctx->channels!=2){
943
                            avctx->channels = channels;
944
                        }
945
                    } else {
946
                        avctx->channels = channels;
947
                    }
948
                    avctx->bit_rate = bit_rate;
949
                    avctx->frame_size = samples;
950
                }
951
            }
952
        } else {
953
            len = FFMIN(s->frame_size - len, buf_size);
954

    
955
            memcpy(s->inbuf_ptr, buf_ptr, len);
956
            buf_ptr += len;
957
            s->inbuf_ptr += len;
958
            buf_size -= len;
959

    
960
            if(s->inbuf_ptr - s->inbuf == s->frame_size){
961
                *poutbuf = s->inbuf;
962
                *poutbuf_size = s->frame_size;
963
                s->inbuf_ptr = s->inbuf;
964
                s->frame_size = 0;
965
                break;
966
            }
967
        }
968
    }
969
    return buf_ptr - buf;
970
}
971

    
972
AVCodecParser mpegvideo_parser = {
973
    { CODEC_ID_MPEG1VIDEO, CODEC_ID_MPEG2VIDEO },
974
    sizeof(ParseContext1),
975
    NULL,
976
    mpegvideo_parse,
977
    parse1_close,
978
    mpegvideo_split,
979
};
980

    
981
AVCodecParser mpeg4video_parser = {
982
    { CODEC_ID_MPEG4 },
983
    sizeof(ParseContext1),
984
    mpeg4video_parse_init,
985
    mpeg4video_parse,
986
    parse1_close,
987
    mpeg4video_split,
988
};
989

    
990
AVCodecParser mpegaudio_parser = {
991
    { CODEC_ID_MP2, CODEC_ID_MP3 },
992
    sizeof(MpegAudioParseContext),
993
    mpegaudio_parse_init,
994
    mpegaudio_parse,
995
    NULL,
996
};
997

    
998
AVCodecParser ac3_parser = {
999
    { CODEC_ID_AC3 },
1000
    sizeof(AC3ParseContext),
1001
    ac3_parse_init,
1002
    ac3_parse,
1003
    NULL,
1004
};
1005

    
1006
AVCodecParser aac_parser = {
1007
    { CODEC_ID_AAC },
1008
    sizeof(AC3ParseContext),
1009
    aac_parse_init,
1010
    ac3_parse,
1011
    NULL,
1012
};