← Back to branch summary

~ubuntu-branches/debian/wheezy/vlc/wheezy

« back to all changes in this revision

Viewing changes to extras/ffmpeg/libavcodec/parser.c

Tags: upstream-0.7.2.final
Import upstream version 0.7.2.final

Show diffs side-by-side

added added

removed removed

Lines of Context:
extras/ffmpeg/libavcodec/parser.c
 
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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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
    for(parser = av_first_parser; parser != NULL; parser = parser->next) {
 
39
        if (parser->codec_ids[0] == codec_id ||
 
40
            parser->codec_ids[1] == codec_id ||
 
41
            parser->codec_ids[2] == codec_id)
 
42
            goto found;
 
43
    }
 
44
    return NULL;
 
45
 found:
 
46
    s = av_mallocz(sizeof(AVCodecParserContext));
 
47
    if (!s)
 
48
        return NULL;
 
49
    s->parser = parser;
 
50
    s->priv_data = av_mallocz(parser->priv_data_size);
 
51
    if (!s->priv_data) {
 
52
        av_free(s);
 
53
        return NULL;
 
54
    }
 
55
    if (parser->parser_init) {
 
56
        ret = parser->parser_init(s);
 
57
        if (ret != 0) {
 
58
            av_free(s->priv_data);
 
59
            av_free(s);
 
60
            return NULL;
 
61
        }
 
62
    }
 
63
    return s;
 
64
}
 
65
 
 
66
/* NOTE: buf_size == 0 is used to signal EOF so that the last frame
 
67
   can be returned if necessary */
 
68
int av_parser_parse(AVCodecParserContext *s, 
 
69
                    AVCodecContext *avctx,
 
70
                    uint8_t **poutbuf, int *poutbuf_size, 
 
71
                    const uint8_t *buf, int buf_size,
 
72
                    int64_t pts, int64_t dts)
 
73
{
 
74
    int index, i, k;
 
75
    uint8_t dummy_buf[FF_INPUT_BUFFER_PADDING_SIZE];
 
76
    
 
77
    if (buf_size == 0) {
 
78
        /* padding is always necessary even if EOF, so we add it here */
 
79
        memset(dummy_buf, 0, sizeof(dummy_buf));
 
80
        buf = dummy_buf;
 
81
    } else {
 
82
        /* add a new packet descriptor */
 
83
        k = (s->cur_frame_start_index + 1) & (AV_PARSER_PTS_NB - 1);
 
84
        s->cur_frame_start_index = k;
 
85
        s->cur_frame_offset[k] = s->cur_offset;
 
86
        s->cur_frame_pts[k] = pts;
 
87
        s->cur_frame_dts[k] = dts;
 
88
 
 
89
        /* fill first PTS/DTS */
 
90
        if (s->cur_offset == 0) {
 
91
            s->last_pts = pts;
 
92
            s->last_dts = dts;
 
93
        }
 
94
    }
 
95
 
 
96
    /* WARNING: the returned index can be negative */
 
97
    index = s->parser->parser_parse(s, avctx, poutbuf, poutbuf_size, buf, buf_size);
 
98
    /* update the file pointer */
 
99
    if (*poutbuf_size) {
 
100
        /* fill the data for the current frame */
 
101
        s->frame_offset = s->last_frame_offset;
 
102
        s->pts = s->last_pts;
 
103
        s->dts = s->last_dts;
 
104
        
 
105
        /* offset of the next frame */
 
106
        s->last_frame_offset = s->cur_offset + index;
 
107
        /* find the packet in which the new frame starts. It
 
108
           is tricky because of MPEG video start codes
 
109
           which can begin in one packet and finish in
 
110
           another packet. In the worst case, an MPEG
 
111
           video start code could be in 4 different
 
112
           packets. */
 
113
        k = s->cur_frame_start_index;
 
114
        for(i = 0; i < AV_PARSER_PTS_NB; i++) {
 
115
            if (s->last_frame_offset >= s->cur_frame_offset[k])
 
116
                break;
 
117
            k = (k - 1) & (AV_PARSER_PTS_NB - 1);
 
118
        }
 
119
        s->last_pts = s->cur_frame_pts[k];
 
120
        s->last_dts = s->cur_frame_dts[k];
 
121
    }
 
122
    if (index < 0)
 
123
        index = 0;
 
124
    s->cur_offset += index;
 
125
    return index;
 
126
}
 
127
 
 
128
void av_parser_close(AVCodecParserContext *s)
 
129
{
 
130
    if (s->parser->parser_close)
 
131
        s->parser->parser_close(s);
 
132
    av_free(s->priv_data);
 
133
    av_free(s);
 
134
}
 
135
 
 
136
/*****************************************************/
 
137
 
 
138
//#define END_NOT_FOUND (-100)
 
139
 
 
140
#define PICTURE_START_CODE      0x00000100
 
141
#define SEQ_START_CODE          0x000001b3
 
142
#define EXT_START_CODE          0x000001b5
 
143
#define SLICE_MIN_START_CODE    0x00000101
 
144
#define SLICE_MAX_START_CODE    0x000001af
 
145
 
 
146
typedef struct ParseContext1{
 
147
    ParseContext pc;
 
148
/* XXX/FIXME PC1 vs. PC */
 
149
    /* MPEG2 specific */
 
150
    int frame_rate;
 
151
    int progressive_sequence;
 
152
    int width, height;
 
153
 
 
154
    /* XXX: suppress that, needed by MPEG4 */
 
155
    MpegEncContext *enc;
 
156
    int first_picture;
 
157
} ParseContext1;
 
158
 
 
159
/**
 
160
 * combines the (truncated) bitstream to a complete frame
 
161
 * @returns -1 if no complete frame could be created
 
162
 */
 
163
int ff_combine_frame(ParseContext *pc, int next, uint8_t **buf, int *buf_size)
 
164
{
 
165
#if 0
 
166
    if(pc->overread){
 
167
        printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
 
168
        printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
 
169
    }
 
170
#endif
 
171
 
 
172
    /* copy overreaded bytes from last frame into buffer */
 
173
    for(; pc->overread>0; pc->overread--){
 
174
        pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
 
175
    }
 
176
    
 
177
    pc->last_index= pc->index;
 
178
 
 
179
    /* copy into buffer end return */
 
180
    if(next == END_NOT_FOUND){
 
181
        pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
 
182
 
 
183
        memcpy(&pc->buffer[pc->index], *buf, *buf_size);
 
184
        pc->index += *buf_size;
 
185
        return -1;
 
186
    }
 
187
 
 
188
    *buf_size=
 
189
    pc->overread_index= pc->index + next;
 
190
    
 
191
    /* append to buffer */
 
192
    if(pc->index){
 
193
        pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
 
194
 
 
195
        memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
 
196
        pc->index = 0;
 
197
        *buf= pc->buffer;
 
198
    }
 
199
 
 
200
    /* store overread bytes */
 
201
    for(;next < 0; next++){
 
202
        pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
 
203
        pc->overread++;
 
204
    }
 
205
 
 
206
#if 0
 
207
    if(pc->overread){
 
208
        printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
 
209
        printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
 
210
    }
 
211
#endif
 
212
 
 
213
    return 0;
 
214
}
 
215
 
 
216
static int find_start_code(const uint8_t **pbuf_ptr, const uint8_t *buf_end)
 
217
{
 
218
    const uint8_t *buf_ptr;
 
219
    unsigned int state=0xFFFFFFFF, v;
 
220
    int val;
 
221
 
 
222
    buf_ptr = *pbuf_ptr;
 
223
    while (buf_ptr < buf_end) {
 
224
        v = *buf_ptr++;
 
225
        if (state == 0x000001) {
 
226
            state = ((state << 8) | v) & 0xffffff;
 
227
            val = state;
 
228
            goto found;
 
229
        }
 
230
        state = ((state << 8) | v) & 0xffffff;
 
231
    }
 
232
    val = -1;
 
233
 found:
 
234
    *pbuf_ptr = buf_ptr;
 
235
    return val;
 
236
}
 
237
 
 
238
/* XXX: merge with libavcodec ? */
 
239
#define MPEG1_FRAME_RATE_BASE 1001
 
240
 
 
241
static const int frame_rate_tab[16] = {
 
242
        0,        
 
243
    24000,
 
244
    24024,
 
245
    25025,
 
246
    30000,
 
247
    30030,
 
248
    50050,
 
249
    60000,
 
250
    60060,
 
251
  // Xing's 15fps: (9)
 
252
    15015,
 
253
  // libmpeg3's "Unofficial economy rates": (10-13)
 
254
     5005,
 
255
    10010,
 
256
    12012,
 
257
    15015,
 
258
  // random, just to avoid segfault !never encode these
 
259
    25025,
 
260
    25025,
 
261
};
 
262
 
 
263
static void mpegvideo_extract_headers(AVCodecParserContext *s, 
 
264
                                      AVCodecContext *avctx,
 
265
                                      const uint8_t *buf, int buf_size)
 
266
{
 
267
    ParseContext1 *pc = s->priv_data;
 
268
    const uint8_t *buf_end;
 
269
    int32_t start_code;
 
270
    int frame_rate_index, ext_type, bytes_left;
 
271
    int frame_rate_ext_n, frame_rate_ext_d;
 
272
    int top_field_first, repeat_first_field, progressive_frame;
 
273
    int horiz_size_ext, vert_size_ext;
 
274
 
 
275
    s->repeat_pict = 0;
 
276
    buf_end = buf + buf_size;
 
277
    while (buf < buf_end) {
 
278
        start_code = find_start_code(&buf, buf_end);
 
279
        bytes_left = buf_end - buf;
 
280
        switch(start_code) {
 
281
        case PICTURE_START_CODE:
 
282
            if (bytes_left >= 2) {
 
283
                s->pict_type = (buf[1] >> 3) & 7;
 
284
            }
 
285
            break;
 
286
        case SEQ_START_CODE:
 
287
            if (bytes_left >= 4) {
 
288
                pc->width = avctx->width = (buf[0] << 4) | (buf[1] >> 4);
 
289
                pc->height = avctx->height = ((buf[1] & 0x0f) << 8) | buf[2];
 
290
                frame_rate_index = buf[3] & 0xf;
 
291
                pc->frame_rate = avctx->frame_rate = frame_rate_tab[frame_rate_index];
 
292
                avctx->frame_rate_base = MPEG1_FRAME_RATE_BASE;
 
293
                avctx->codec_id = CODEC_ID_MPEG1VIDEO;
 
294
                avctx->sub_id = 1;
 
295
            }
 
296
            break;
 
297
        case EXT_START_CODE:
 
298
            if (bytes_left >= 1) {
 
299
                ext_type = (buf[0] >> 4);
 
300
                switch(ext_type) {
 
301
                case 0x1: /* sequence extension */
 
302
                    if (bytes_left >= 6) {
 
303
                        horiz_size_ext = ((buf[1] & 1) << 1) | (buf[2] >> 7);
 
304
                        vert_size_ext = (buf[2] >> 5) & 3;
 
305
                        frame_rate_ext_n = (buf[5] >> 5) & 3;
 
306
                        frame_rate_ext_d = (buf[5] & 0x1f);
 
307
                        pc->progressive_sequence = buf[1] & (1 << 3);
 
308
 
 
309
                        avctx->width = pc->width | (horiz_size_ext << 12);
 
310
                        avctx->height = pc->height | (vert_size_ext << 12);
 
311
                        avctx->frame_rate = pc->frame_rate * (frame_rate_ext_n + 1);
 
312
                        avctx->frame_rate_base = MPEG1_FRAME_RATE_BASE * (frame_rate_ext_d + 1);
 
313
                        avctx->codec_id = CODEC_ID_MPEG2VIDEO;
 
314
                        avctx->sub_id = 2; /* forces MPEG2 */
 
315
                    }
 
316
                    break;
 
317
                case 0x8: /* picture coding extension */
 
318
                    if (bytes_left >= 5) {
 
319
                        top_field_first = buf[3] & (1 << 7);
 
320
                        repeat_first_field = buf[3] & (1 << 1);
 
321
                        progressive_frame = buf[4] & (1 << 7);
 
322
                    
 
323
                        /* check if we must repeat the frame */
 
324
                        if (repeat_first_field) {
 
325
                            if (pc->progressive_sequence) {
 
326
                                if (top_field_first)
 
327
                                    s->repeat_pict = 4;
 
328
                                else
 
329
                                    s->repeat_pict = 2;
 
330
                            } else if (progressive_frame) {
 
331
                                s->repeat_pict = 1;
 
332
                            }
 
333
                        }
 
334
                    }
 
335
                    break;
 
336
                }
 
337
            }
 
338
            break;
 
339
        case -1:
 
340
            goto the_end;
 
341
        default:
 
342
            /* we stop parsing when we encounter a slice. It ensures
 
343
               that this function takes a negligible amount of time */
 
344
            if (start_code >= SLICE_MIN_START_CODE && 
 
345
                start_code <= SLICE_MAX_START_CODE)
 
346
                goto the_end;
 
347
            break;
 
348
        }
 
349
    }
 
350
 the_end: ;
 
351
}
 
352
 
 
353
static int mpegvideo_parse(AVCodecParserContext *s,
 
354
                           AVCodecContext *avctx,
 
355
                           uint8_t **poutbuf, int *poutbuf_size, 
 
356
                           const uint8_t *buf, int buf_size)
 
357
{
 
358
    ParseContext1 *pc1 = s->priv_data;
 
359
    ParseContext *pc= &pc1->pc;
 
360
    int next;
 
361
    
 
362
    next= ff_mpeg1_find_frame_end(pc, buf, buf_size);
 
363
    
 
364
    if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
 
365
        *poutbuf = NULL;
 
366
        *poutbuf_size = 0;
 
367
        return buf_size;
 
368
    }
 
369
    /* we have a full frame : we just parse the first few MPEG headers
 
370
       to have the full timing information. The time take by this
 
371
       function should be negligible for uncorrupted streams */
 
372
    mpegvideo_extract_headers(s, avctx, buf, buf_size);
 
373
#if 0
 
374
    printf("pict_type=%d frame_rate=%0.3f repeat_pict=%d\n", 
 
375
           s->pict_type, (double)avctx->frame_rate / avctx->frame_rate_base, s->repeat_pict);
 
376
#endif
 
377
 
 
378
    *poutbuf = (uint8_t *)buf;
 
379
    *poutbuf_size = buf_size;
 
380
    return next;
 
381
}
 
382
 
 
383
void ff_parse_close(AVCodecParserContext *s)
 
384
{
 
385
    ParseContext *pc = s->priv_data;
 
386
 
 
387
    av_free(pc->buffer);
 
388
}
 
389
 
 
390
static void parse1_close(AVCodecParserContext *s)
 
391
{
 
392
    ParseContext1 *pc1 = s->priv_data;
 
393
 
 
394
    av_free(pc1->pc.buffer);
 
395
    av_free(pc1->enc);
 
396
}
 
397
 
 
398
/*************************/
 
399
 
 
400
/* used by parser */
 
401
/* XXX: make it use less memory */
 
402
static int av_mpeg4_decode_header(AVCodecParserContext *s1, 
 
403
                                  AVCodecContext *avctx,
 
404
                                  const uint8_t *buf, int buf_size)
 
405
{
 
406
    ParseContext1 *pc = s1->priv_data;
 
407
    MpegEncContext *s = pc->enc;
 
408
    GetBitContext gb1, *gb = &gb1;
 
409
    int ret;
 
410
 
 
411
    s->avctx = avctx;
 
412
    s->current_picture_ptr = &s->current_picture;
 
413
 
 
414
    if (avctx->extradata_size && pc->first_picture){
 
415
        init_get_bits(gb, avctx->extradata, avctx->extradata_size*8);
 
416
        ret = ff_mpeg4_decode_picture_header(s, gb);
 
417
    }
 
418
 
 
419
    init_get_bits(gb, buf, 8 * buf_size);
 
420
    ret = ff_mpeg4_decode_picture_header(s, gb);
 
421
    if (s->width) {
 
422
        avctx->width = s->width;
 
423
        avctx->height = s->height;
 
424
    }
 
425
    pc->first_picture = 0;
 
426
    return ret;
 
427
}
 
428
 
 
429
static int mpeg4video_parse_init(AVCodecParserContext *s)
 
430
{
 
431
    ParseContext1 *pc = s->priv_data;
 
432
 
 
433
    pc->enc = av_mallocz(sizeof(MpegEncContext));
 
434
    if (!pc->enc)
 
435
        return -1;
 
436
    pc->first_picture = 1;
 
437
    return 0;
 
438
}
 
439
 
 
440
static int mpeg4video_parse(AVCodecParserContext *s,
 
441
                           AVCodecContext *avctx,
 
442
                           uint8_t **poutbuf, int *poutbuf_size, 
 
443
                           const uint8_t *buf, int buf_size)
 
444
{
 
445
    ParseContext *pc = s->priv_data;
 
446
    int next;
 
447
    
 
448
    next= ff_mpeg4_find_frame_end(pc, buf, buf_size);
 
449
 
 
450
    if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
 
451
        *poutbuf = NULL;
 
452
        *poutbuf_size = 0;
 
453
        return buf_size;
 
454
    }
 
455
    av_mpeg4_decode_header(s, avctx, buf, buf_size);
 
456
 
 
457
    *poutbuf = (uint8_t *)buf;
 
458
    *poutbuf_size = buf_size;
 
459
    return next;
 
460
}
 
461
 
 
462
/*************************/
 
463
 
 
464
typedef struct MpegAudioParseContext {
 
465
    uint8_t inbuf[MPA_MAX_CODED_FRAME_SIZE];    /* input buffer */
 
466
    uint8_t *inbuf_ptr;
 
467
    int frame_size;
 
468
    int free_format_frame_size;
 
469
    int free_format_next_header;
 
470
} MpegAudioParseContext;
 
471
 
 
472
#define MPA_HEADER_SIZE 4
 
473
 
 
474
/* header + layer + bitrate + freq + lsf/mpeg25 */
 
475
#define SAME_HEADER_MASK \
 
476
   (0xffe00000 | (3 << 17) | (0xf << 12) | (3 << 10) | (3 << 19))
 
477
 
 
478
static int mpegaudio_parse_init(AVCodecParserContext *s1)
 
479
{
 
480
    MpegAudioParseContext *s = s1->priv_data;
 
481
    s->inbuf_ptr = s->inbuf;
 
482
    return 0;
 
483
}
 
484
 
 
485
static int mpegaudio_parse(AVCodecParserContext *s1,
 
486
                           AVCodecContext *avctx,
 
487
                           uint8_t **poutbuf, int *poutbuf_size, 
 
488
                           const uint8_t *buf, int buf_size)
 
489
{
 
490
    MpegAudioParseContext *s = s1->priv_data;
 
491
    int len, ret;
 
492
    uint32_t header;
 
493
    const uint8_t *buf_ptr;
 
494
 
 
495
    *poutbuf = NULL;
 
496
    *poutbuf_size = 0;
 
497
    buf_ptr = buf;
 
498
    while (buf_size > 0) {
 
499
        len = s->inbuf_ptr - s->inbuf;
 
500
        if (s->frame_size == 0) {
 
501
            /* special case for next header for first frame in free
 
502
               format case (XXX: find a simpler method) */
 
503
            if (s->free_format_next_header != 0) {
 
504
                s->inbuf[0] = s->free_format_next_header >> 24;
 
505
                s->inbuf[1] = s->free_format_next_header >> 16;
 
506
                s->inbuf[2] = s->free_format_next_header >> 8;
 
507
                s->inbuf[3] = s->free_format_next_header;
 
508
                s->inbuf_ptr = s->inbuf + 4;
 
509
                s->free_format_next_header = 0;
 
510
                goto got_header;
 
511
            }
 
512
            /* no header seen : find one. We need at least MPA_HEADER_SIZE
 
513
               bytes to parse it */
 
514
            len = MPA_HEADER_SIZE - len;
 
515
            if (len > buf_size)
 
516
                len = buf_size;
 
517
            if (len > 0) {
 
518
                memcpy(s->inbuf_ptr, buf_ptr, len);
 
519
                buf_ptr += len;
 
520
                buf_size -= len;
 
521
                s->inbuf_ptr += len;
 
522
            }
 
523
            if ((s->inbuf_ptr - s->inbuf) >= MPA_HEADER_SIZE) {
 
524
            got_header:
 
525
                header = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
 
526
                    (s->inbuf[2] << 8) | s->inbuf[3];
 
527
 
 
528
                ret = mpa_decode_header(avctx, header);
 
529
                if (ret < 0) {
 
530
                    /* no sync found : move by one byte (inefficient, but simple!) */
 
531
                    memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
 
532
                    s->inbuf_ptr--;
 
533
                    dprintf("skip %x\n", header);
 
534
                    /* reset free format frame size to give a chance
 
535
                       to get a new bitrate */
 
536
                    s->free_format_frame_size = 0;
 
537
                } else {
 
538
                    s->frame_size = ret;
 
539
#if 0
 
540
                    /* free format: prepare to compute frame size */
 
541
                    if (decode_header(s, header) == 1) {
 
542
                        s->frame_size = -1;
 
543
                    }
 
544
#endif
 
545
                }
 
546
            }
 
547
        } else 
 
548
#if 0
 
549
        if (s->frame_size == -1) {
 
550
            /* free format : find next sync to compute frame size */
 
551
            len = MPA_MAX_CODED_FRAME_SIZE - len;
 
552
            if (len > buf_size)
 
553
                len = buf_size;
 
554
            if (len == 0) {
 
555
                /* frame too long: resync */
 
556
                s->frame_size = 0;
 
557
                memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
 
558
                s->inbuf_ptr--;
 
559
            } else {
 
560
                uint8_t *p, *pend;
 
561
                uint32_t header1;
 
562
                int padding;
 
563
 
 
564
                memcpy(s->inbuf_ptr, buf_ptr, len);
 
565
                /* check for header */
 
566
                p = s->inbuf_ptr - 3;
 
567
                pend = s->inbuf_ptr + len - 4;
 
568
                while (p <= pend) {
 
569
                    header = (p[0] << 24) | (p[1] << 16) |
 
570
                        (p[2] << 8) | p[3];
 
571
                    header1 = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
 
572
                        (s->inbuf[2] << 8) | s->inbuf[3];
 
573
                    /* check with high probability that we have a
 
574
                       valid header */
 
575
                    if ((header & SAME_HEADER_MASK) ==
 
576
                        (header1 & SAME_HEADER_MASK)) {
 
577
                        /* header found: update pointers */
 
578
                        len = (p + 4) - s->inbuf_ptr;
 
579
                        buf_ptr += len;
 
580
                        buf_size -= len;
 
581
                        s->inbuf_ptr = p;
 
582
                        /* compute frame size */
 
583
                        s->free_format_next_header = header;
 
584
                        s->free_format_frame_size = s->inbuf_ptr - s->inbuf;
 
585
                        padding = (header1 >> 9) & 1;
 
586
                        if (s->layer == 1)
 
587
                            s->free_format_frame_size -= padding * 4;
 
588
                        else
 
589
                            s->free_format_frame_size -= padding;
 
590
                        dprintf("free frame size=%d padding=%d\n", 
 
591
                                s->free_format_frame_size, padding);
 
592
                        decode_header(s, header1);
 
593
                        goto next_data;
 
594
                    }
 
595
                    p++;
 
596
                }
 
597
                /* not found: simply increase pointers */
 
598
                buf_ptr += len;
 
599
                s->inbuf_ptr += len;
 
600
                buf_size -= len;
 
601
            }
 
602
        } else 
 
603
#endif
 
604
        if (len < s->frame_size) {
 
605
            if (s->frame_size > MPA_MAX_CODED_FRAME_SIZE)
 
606
                s->frame_size = MPA_MAX_CODED_FRAME_SIZE;
 
607
            len = s->frame_size - len;
 
608
            if (len > buf_size)
 
609
                len = buf_size;
 
610
            memcpy(s->inbuf_ptr, buf_ptr, len);
 
611
            buf_ptr += len;
 
612
            s->inbuf_ptr += len;
 
613
            buf_size -= len;
 
614
        }
 
615
        //    next_data:
 
616
        if (s->frame_size > 0 && 
 
617
            (s->inbuf_ptr - s->inbuf) >= s->frame_size) {
 
618
            *poutbuf = s->inbuf;
 
619
            *poutbuf_size = s->inbuf_ptr - s->inbuf;
 
620
            s->inbuf_ptr = s->inbuf;
 
621
            s->frame_size = 0;
 
622
            break;
 
623
        }
 
624
    }
 
625
    return buf_ptr - buf;
 
626
}
 
627
 
 
628
#ifdef CONFIG_AC3
 
629
extern int a52_syncinfo (const uint8_t * buf, int * flags,
 
630
                         int * sample_rate, int * bit_rate);
 
631
 
 
632
typedef struct AC3ParseContext {
 
633
    uint8_t inbuf[4096]; /* input buffer */
 
634
    uint8_t *inbuf_ptr;
 
635
    int frame_size;
 
636
    int flags;
 
637
} AC3ParseContext;
 
638
 
 
639
#define AC3_HEADER_SIZE 7
 
640
#define A52_LFE 16
 
641
 
 
642
static int ac3_parse_init(AVCodecParserContext *s1)
 
643
{
 
644
    AC3ParseContext *s = s1->priv_data;
 
645
    s->inbuf_ptr = s->inbuf;
 
646
    return 0;
 
647
}
 
648
 
 
649
static int ac3_parse(AVCodecParserContext *s1,
 
650
                     AVCodecContext *avctx,
 
651
                     uint8_t **poutbuf, int *poutbuf_size, 
 
652
                     const uint8_t *buf, int buf_size)
 
653
{
 
654
    AC3ParseContext *s = s1->priv_data;
 
655
    const uint8_t *buf_ptr;
 
656
    int len, sample_rate, bit_rate;
 
657
    static const int ac3_channels[8] = {
 
658
        2, 1, 2, 3, 3, 4, 4, 5
 
659
    };
 
660
 
 
661
    *poutbuf = NULL;
 
662
    *poutbuf_size = 0;
 
663
 
 
664
    buf_ptr = buf;
 
665
    while (buf_size > 0) {
 
666
        len = s->inbuf_ptr - s->inbuf;
 
667
        if (s->frame_size == 0) {
 
668
            /* no header seen : find one. We need at least 7 bytes to parse it */
 
669
            len = AC3_HEADER_SIZE - len;
 
670
            if (len > buf_size)
 
671
                len = buf_size;
 
672
            memcpy(s->inbuf_ptr, buf_ptr, len);
 
673
            buf_ptr += len;
 
674
            s->inbuf_ptr += len;
 
675
            buf_size -= len;
 
676
            if ((s->inbuf_ptr - s->inbuf) == AC3_HEADER_SIZE) {
 
677
                len = a52_syncinfo(s->inbuf, &s->flags, &sample_rate, &bit_rate);
 
678
                if (len == 0) {
 
679
                    /* no sync found : move by one byte (inefficient, but simple!) */
 
680
                    memmove(s->inbuf, s->inbuf + 1, AC3_HEADER_SIZE - 1);
 
681
                    s->inbuf_ptr--;
 
682
                } else {
 
683
                    s->frame_size = len;
 
684
                    /* update codec info */
 
685
                    avctx->sample_rate = sample_rate;
 
686
                    /* set channels,except if the user explicitly requests 1 or 2 channels, XXX/FIXME this is a bit ugly */
 
687
                    if(avctx->channels!=1 && avctx->channels!=2){
 
688
                        avctx->channels = ac3_channels[s->flags & 7];
 
689
                        if (s->flags & A52_LFE)
 
690
                            avctx->channels++;
 
691
                    }
 
692
                    avctx->bit_rate = bit_rate;
 
693
                    avctx->frame_size = 6 * 256;
 
694
                }
 
695
            }
 
696
        } else if (len < s->frame_size) {
 
697
            len = s->frame_size - len;
 
698
            if (len > buf_size)
 
699
                len = buf_size;
 
700
 
 
701
            memcpy(s->inbuf_ptr, buf_ptr, len);
 
702
            buf_ptr += len;
 
703
            s->inbuf_ptr += len;
 
704
            buf_size -= len;
 
705
        } else {
 
706
            *poutbuf = s->inbuf;
 
707
            *poutbuf_size = s->frame_size;
 
708
            s->inbuf_ptr = s->inbuf;
 
709
            s->frame_size = 0;
 
710
            break;
 
711
        }
 
712
    }
 
713
    return buf_ptr - buf;
 
714
}
 
715
#endif
 
716
 
 
717
AVCodecParser mpegvideo_parser = {
 
718
    { CODEC_ID_MPEG1VIDEO, CODEC_ID_MPEG2VIDEO },
 
719
    sizeof(ParseContext1),
 
720
    NULL,
 
721
    mpegvideo_parse,
 
722
    parse1_close,
 
723
};
 
724
 
 
725
AVCodecParser mpeg4video_parser = {
 
726
    { CODEC_ID_MPEG4 },
 
727
    sizeof(ParseContext1),
 
728
    mpeg4video_parse_init,
 
729
    mpeg4video_parse,
 
730
    parse1_close,
 
731
};
 
732
 
 
733
AVCodecParser mpegaudio_parser = {
 
734
    { CODEC_ID_MP2, CODEC_ID_MP3 },
 
735
    sizeof(MpegAudioParseContext),
 
736
    mpegaudio_parse_init,
 
737
    mpegaudio_parse,
 
738
    NULL,
 
739
};
 
740
 
 
741
#ifdef CONFIG_AC3
 
742
AVCodecParser ac3_parser = {
 
743
    { CODEC_ID_AC3 },
 
744
    sizeof(AC3ParseContext),
 
745
    ac3_parse_init,
 
746
    ac3_parse,
 
747
    NULL,
 
748
};
 
749
#endif