Statistics
| Branch: | Revision:

ffmpeg / libavcodec / flacdec.c @ 3b4d96fa

History | View | Annotate | Download (23.1 KB)

1
/*
2
 * FLAC (Free Lossless Audio Codec) decoder
3
 * Copyright (c) 2003 Alex Beregszaszi
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21

    
22
/**
23
 * @file libavcodec/flacdec.c
24
 * FLAC (Free Lossless Audio Codec) decoder
25
 * @author Alex Beregszaszi
26
 *
27
 * For more information on the FLAC format, visit:
28
 *  http://flac.sourceforge.net/
29
 *
30
 * This decoder can be used in 1 of 2 ways: Either raw FLAC data can be fed
31
 * through, starting from the initial 'fLaC' signature; or by passing the
32
 * 34-byte streaminfo structure through avctx->extradata[_size] followed
33
 * by data starting with the 0xFFF8 marker.
34
 */
35

    
36
#include <limits.h>
37

    
38
#include "libavutil/crc.h"
39
#include "avcodec.h"
40
#include "internal.h"
41
#include "bitstream.h"
42
#include "bytestream.h"
43
#include "golomb.h"
44
#include "flac.h"
45
#include "flacdata.h"
46

    
47
#undef NDEBUG
48
#include <assert.h>
49

    
50
typedef struct FLACContext {
51
    FLACSTREAMINFO
52

    
53
    AVCodecContext *avctx;                  ///< parent AVCodecContext
54
    GetBitContext gb;                       ///< GetBitContext initialized to start at the current frame
55

    
56
    int blocksize;                          ///< number of samples in the current frame
57
    int curr_bps;                           ///< bps for current subframe, adjusted for channel correlation and wasted bits
58
    int sample_shift;                       ///< shift required to make output samples 16-bit or 32-bit
59
    int is32;                               ///< flag to indicate if output should be 32-bit instead of 16-bit
60
    int ch_mode;                            ///< channel decorrelation type in the current frame
61
    int got_streaminfo;                     ///< indicates if the STREAMINFO has been read
62

    
63
    int32_t *decoded[FLAC_MAX_CHANNELS];    ///< decoded samples
64
    uint8_t *bitstream;
65
    unsigned int bitstream_size;
66
    unsigned int bitstream_index;
67
    unsigned int allocated_bitstream_size;
68
} FLACContext;
69

    
70
static const int sample_size_table[] =
71
{ 0, 8, 12, 0, 16, 20, 24, 0 };
72

    
73
static int64_t get_utf8(GetBitContext *gb)
74
{
75
    int64_t val;
76
    GET_UTF8(val, get_bits(gb, 8), return -1;)
77
    return val;
78
}
79

    
80
static void allocate_buffers(FLACContext *s);
81

    
82
int ff_flac_is_extradata_valid(AVCodecContext *avctx,
83
                               enum FLACExtradataFormat *format,
84
                               uint8_t **streaminfo_start)
85
{
86
    if (!avctx->extradata || avctx->extradata_size < FLAC_STREAMINFO_SIZE) {
87
        av_log(avctx, AV_LOG_ERROR, "extradata NULL or too small.\n");
88
        return 0;
89
    }
90
    if (AV_RL32(avctx->extradata) != MKTAG('f','L','a','C')) {
91
        /* extradata contains STREAMINFO only */
92
        if (avctx->extradata_size != FLAC_STREAMINFO_SIZE) {
93
            av_log(avctx, AV_LOG_WARNING, "extradata contains %d bytes too many.\n",
94
                   FLAC_STREAMINFO_SIZE-avctx->extradata_size);
95
        }
96
        *format = FLAC_EXTRADATA_FORMAT_STREAMINFO;
97
        *streaminfo_start = avctx->extradata;
98
    } else {
99
        if (avctx->extradata_size < 8+FLAC_STREAMINFO_SIZE) {
100
            av_log(avctx, AV_LOG_ERROR, "extradata too small.\n");
101
            return 0;
102
        }
103
        *format = FLAC_EXTRADATA_FORMAT_FULL_HEADER;
104
        *streaminfo_start = &avctx->extradata[8];
105
    }
106
    return 1;
107
}
108

    
109
static av_cold int flac_decode_init(AVCodecContext *avctx)
110
{
111
    enum FLACExtradataFormat format;
112
    uint8_t *streaminfo;
113
    FLACContext *s = avctx->priv_data;
114
    s->avctx = avctx;
115

    
116
    avctx->sample_fmt = SAMPLE_FMT_S16;
117

    
118
    /* for now, the raw FLAC header is allowed to be passed to the decoder as
119
       frame data instead of extradata. */
120
    if (!avctx->extradata)
121
        return 0;
122

    
123
    if (!ff_flac_is_extradata_valid(avctx, &format, &streaminfo))
124
        return -1;
125

    
126
    /* initialize based on the demuxer-supplied streamdata header */
127
    ff_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
128
    allocate_buffers(s);
129
    s->got_streaminfo = 1;
130

    
131
    return 0;
132
}
133

    
134
static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
135
{
136
    av_log(avctx, AV_LOG_DEBUG, "  Max Blocksize: %d\n", s->max_blocksize);
137
    av_log(avctx, AV_LOG_DEBUG, "  Max Framesize: %d\n", s->max_framesize);
138
    av_log(avctx, AV_LOG_DEBUG, "  Samplerate: %d\n", s->samplerate);
139
    av_log(avctx, AV_LOG_DEBUG, "  Channels: %d\n", s->channels);
140
    av_log(avctx, AV_LOG_DEBUG, "  Bits: %d\n", s->bps);
141
}
142

    
143
static void allocate_buffers(FLACContext *s)
144
{
145
    int i;
146

    
147
    assert(s->max_blocksize);
148

    
149
    if (s->max_framesize == 0 && s->max_blocksize) {
150
        s->max_framesize = ff_flac_get_max_frame_size(s->max_blocksize,
151
                                                      s->channels, s->bps);
152
    }
153

    
154
    for (i = 0; i < s->channels; i++) {
155
        s->decoded[i] = av_realloc(s->decoded[i],
156
                                   sizeof(int32_t)*s->max_blocksize);
157
    }
158

    
159
    if (s->allocated_bitstream_size < s->max_framesize)
160
        s->bitstream= av_fast_realloc(s->bitstream,
161
                                      &s->allocated_bitstream_size,
162
                                      s->max_framesize);
163
}
164

    
165
void ff_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s,
166
                              const uint8_t *buffer)
167
{
168
    GetBitContext gb;
169
    init_get_bits(&gb, buffer, FLAC_STREAMINFO_SIZE*8);
170

    
171
    skip_bits(&gb, 16); /* skip min blocksize */
172
    s->max_blocksize = get_bits(&gb, 16);
173
    if (s->max_blocksize < FLAC_MIN_BLOCKSIZE) {
174
        av_log(avctx, AV_LOG_WARNING, "invalid max blocksize: %d\n",
175
               s->max_blocksize);
176
        s->max_blocksize = 16;
177
    }
178

    
179
    skip_bits(&gb, 24); /* skip min frame size */
180
    s->max_framesize = get_bits_long(&gb, 24);
181

    
182
    s->samplerate = get_bits_long(&gb, 20);
183
    s->channels = get_bits(&gb, 3) + 1;
184
    s->bps = get_bits(&gb, 5) + 1;
185

    
186
    avctx->channels = s->channels;
187
    avctx->sample_rate = s->samplerate;
188
    avctx->bits_per_raw_sample = s->bps;
189
    if (s->bps > 16)
190
        avctx->sample_fmt = SAMPLE_FMT_S32;
191
    else
192
        avctx->sample_fmt = SAMPLE_FMT_S16;
193

    
194
    s->samples  = get_bits_long(&gb, 32) << 4;
195
    s->samples |= get_bits(&gb, 4);
196

    
197
    skip_bits_long(&gb, 64); /* md5 sum */
198
    skip_bits_long(&gb, 64); /* md5 sum */
199

    
200
    dump_headers(avctx, s);
201
}
202

    
203
void ff_flac_parse_block_header(const uint8_t *block_header,
204
                                int *last, int *type, int *size)
205
{
206
    int tmp = bytestream_get_byte(&block_header);
207
    if (last)
208
        *last = tmp & 0x80;
209
    if (type)
210
        *type = tmp & 0x7F;
211
    if (size)
212
        *size = bytestream_get_be24(&block_header);
213
}
214

    
215
/**
216
 * Parse the STREAMINFO from an inline header.
217
 * @param s the flac decoding context
218
 * @param buf input buffer, starting with the "fLaC" marker
219
 * @param buf_size buffer size
220
 * @return non-zero if metadata is invalid
221
 */
222
static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
223
{
224
    int metadata_type, metadata_size;
225

    
226
    if (buf_size < FLAC_STREAMINFO_SIZE+8) {
227
        /* need more data */
228
        return 0;
229
    }
230
    ff_flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
231
    if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
232
        metadata_size != FLAC_STREAMINFO_SIZE) {
233
        return AVERROR_INVALIDDATA;
234
    }
235
    ff_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]);
236
    allocate_buffers(s);
237
    s->got_streaminfo = 1;
238

    
239
    return 0;
240
}
241

    
242
/**
243
 * Determine the size of an inline header.
244
 * @param buf input buffer, starting with the "fLaC" marker
245
 * @param buf_size buffer size
246
 * @return number of bytes in the header, or 0 if more data is needed
247
 */
248
static int get_metadata_size(const uint8_t *buf, int buf_size)
249
{
250
    int metadata_last, metadata_size;
251
    const uint8_t *buf_end = buf + buf_size;
252

    
253
    buf += 4;
254
    do {
255
        ff_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
256
        buf += 4;
257
        if (buf + metadata_size > buf_end) {
258
            /* need more data in order to read the complete header */
259
            return 0;
260
        }
261
        buf += metadata_size;
262
    } while (!metadata_last);
263

    
264
    return buf_size - (buf_end - buf);
265
}
266

    
267
static int decode_residuals(FLACContext *s, int channel, int pred_order)
268
{
269
    int i, tmp, partition, method_type, rice_order;
270
    int sample = 0, samples;
271

    
272
    method_type = get_bits(&s->gb, 2);
273
    if (method_type > 1) {
274
        av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
275
               method_type);
276
        return -1;
277
    }
278

    
279
    rice_order = get_bits(&s->gb, 4);
280

    
281
    samples= s->blocksize >> rice_order;
282
    if (pred_order > samples) {
283
        av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
284
               pred_order, samples);
285
        return -1;
286
    }
287

    
288
    sample=
289
    i= pred_order;
290
    for (partition = 0; partition < (1 << rice_order); partition++) {
291
        tmp = get_bits(&s->gb, method_type == 0 ? 4 : 5);
292
        if (tmp == (method_type == 0 ? 15 : 31)) {
293
            tmp = get_bits(&s->gb, 5);
294
            for (; i < samples; i++, sample++)
295
                s->decoded[channel][sample] = get_sbits_long(&s->gb, tmp);
296
        } else {
297
            for (; i < samples; i++, sample++) {
298
                s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
299
            }
300
        }
301
        i= 0;
302
    }
303

    
304
    return 0;
305
}
306

    
307
static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order)
308
{
309
    const int blocksize = s->blocksize;
310
    int32_t *decoded = s->decoded[channel];
311
    int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i;
312

    
313
    /* warm up samples */
314
    for (i = 0; i < pred_order; i++) {
315
        decoded[i] = get_sbits_long(&s->gb, s->curr_bps);
316
    }
317

    
318
    if (decode_residuals(s, channel, pred_order) < 0)
319
        return -1;
320

    
321
    if (pred_order > 0)
322
        a = decoded[pred_order-1];
323
    if (pred_order > 1)
324
        b = a - decoded[pred_order-2];
325
    if (pred_order > 2)
326
        c = b - decoded[pred_order-2] + decoded[pred_order-3];
327
    if (pred_order > 3)
328
        d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
329

    
330
    switch (pred_order) {
331
    case 0:
332
        break;
333
    case 1:
334
        for (i = pred_order; i < blocksize; i++)
335
            decoded[i] = a += decoded[i];
336
        break;
337
    case 2:
338
        for (i = pred_order; i < blocksize; i++)
339
            decoded[i] = a += b += decoded[i];
340
        break;
341
    case 3:
342
        for (i = pred_order; i < blocksize; i++)
343
            decoded[i] = a += b += c += decoded[i];
344
        break;
345
    case 4:
346
        for (i = pred_order; i < blocksize; i++)
347
            decoded[i] = a += b += c += d += decoded[i];
348
        break;
349
    default:
350
        av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
351
        return -1;
352
    }
353

    
354
    return 0;
355
}
356

    
357
static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order)
358
{
359
    int i, j;
360
    int coeff_prec, qlevel;
361
    int coeffs[pred_order];
362
    int32_t *decoded = s->decoded[channel];
363

    
364
    /* warm up samples */
365
    for (i = 0; i < pred_order; i++) {
366
        decoded[i] = get_sbits_long(&s->gb, s->curr_bps);
367
    }
368

    
369
    coeff_prec = get_bits(&s->gb, 4) + 1;
370
    if (coeff_prec == 16) {
371
        av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
372
        return -1;
373
    }
374
    qlevel = get_sbits(&s->gb, 5);
375
    if (qlevel < 0) {
376
        av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
377
               qlevel);
378
        return -1;
379
    }
380

    
381
    for (i = 0; i < pred_order; i++) {
382
        coeffs[i] = get_sbits(&s->gb, coeff_prec);
383
    }
384

    
385
    if (decode_residuals(s, channel, pred_order) < 0)
386
        return -1;
387

    
388
    if (s->bps > 16) {
389
        int64_t sum;
390
        for (i = pred_order; i < s->blocksize; i++) {
391
            sum = 0;
392
            for (j = 0; j < pred_order; j++)
393
                sum += (int64_t)coeffs[j] * decoded[i-j-1];
394
            decoded[i] += sum >> qlevel;
395
        }
396
    } else {
397
        for (i = pred_order; i < s->blocksize-1; i += 2) {
398
            int c;
399
            int d = decoded[i-pred_order];
400
            int s0 = 0, s1 = 0;
401
            for (j = pred_order-1; j > 0; j--) {
402
                c = coeffs[j];
403
                s0 += c*d;
404
                d = decoded[i-j];
405
                s1 += c*d;
406
            }
407
            c = coeffs[0];
408
            s0 += c*d;
409
            d = decoded[i] += s0 >> qlevel;
410
            s1 += c*d;
411
            decoded[i+1] += s1 >> qlevel;
412
        }
413
        if (i < s->blocksize) {
414
            int sum = 0;
415
            for (j = 0; j < pred_order; j++)
416
                sum += coeffs[j] * decoded[i-j-1];
417
            decoded[i] += sum >> qlevel;
418
        }
419
    }
420

    
421
    return 0;
422
}
423

    
424
static inline int decode_subframe(FLACContext *s, int channel)
425
{
426
    int type, wasted = 0;
427
    int i, tmp;
428

    
429
    s->curr_bps = s->bps;
430
    if (channel == 0) {
431
        if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
432
            s->curr_bps++;
433
    } else {
434
        if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
435
            s->curr_bps++;
436
    }
437

    
438
    if (get_bits1(&s->gb)) {
439
        av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
440
        return -1;
441
    }
442
    type = get_bits(&s->gb, 6);
443

    
444
    if (get_bits1(&s->gb)) {
445
        wasted = 1;
446
        while (!get_bits1(&s->gb))
447
            wasted++;
448
        s->curr_bps -= wasted;
449
    }
450
    if (s->curr_bps > 32) {
451
        ff_log_missing_feature(s->avctx, "decorrelated bit depth > 32", 0);
452
        return -1;
453
    }
454

    
455
//FIXME use av_log2 for types
456
    if (type == 0) {
457
        tmp = get_sbits_long(&s->gb, s->curr_bps);
458
        for (i = 0; i < s->blocksize; i++)
459
            s->decoded[channel][i] = tmp;
460
    } else if (type == 1) {
461
        for (i = 0; i < s->blocksize; i++)
462
            s->decoded[channel][i] = get_sbits_long(&s->gb, s->curr_bps);
463
    } else if ((type >= 8) && (type <= 12)) {
464
        if (decode_subframe_fixed(s, channel, type & ~0x8) < 0)
465
            return -1;
466
    } else if (type >= 32) {
467
        if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0)
468
            return -1;
469
    } else {
470
        av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
471
        return -1;
472
    }
473

    
474
    if (wasted) {
475
        int i;
476
        for (i = 0; i < s->blocksize; i++)
477
            s->decoded[channel][i] <<= wasted;
478
    }
479

    
480
    return 0;
481
}
482

    
483
static int decode_frame(FLACContext *s, int alloc_data_size)
484
{
485
    int bs_code, sr_code, bps_code, i, crc8;
486
    int ch_mode, bps, blocksize, samplerate;
487
    GetBitContext *gb = &s->gb;
488

    
489
    bs_code = get_bits(gb, 4);
490

    
491
    sr_code = get_bits(gb, 4);
492

    
493
    ch_mode = get_bits(gb, 4); /* channel assignment */
494
    if (ch_mode < FLAC_MAX_CHANNELS && s->channels == ch_mode+1) {
495
        ch_mode = FLAC_CHMODE_INDEPENDENT;
496
    } else if (ch_mode > FLAC_CHMODE_MID_SIDE || s->channels != 2) {
497
        av_log(s->avctx, AV_LOG_ERROR, "unsupported channel assignment %d (channels=%d)\n",
498
               ch_mode, s->channels);
499
        return -1;
500
    }
501

    
502
    bps_code = get_bits(gb, 3);
503
    if (bps_code == 0)
504
        bps= s->bps;
505
    else if ((bps_code != 3) && (bps_code != 7))
506
        bps = sample_size_table[bps_code];
507
    else {
508
        av_log(s->avctx, AV_LOG_ERROR, "invalid sample size code (%d)\n",
509
               bps_code);
510
        return -1;
511
    }
512
    if (bps > 16) {
513
        s->avctx->sample_fmt = SAMPLE_FMT_S32;
514
        s->sample_shift = 32 - bps;
515
        s->is32 = 1;
516
    } else {
517
        s->avctx->sample_fmt = SAMPLE_FMT_S16;
518
        s->sample_shift = 16 - bps;
519
        s->is32 = 0;
520
    }
521
    s->bps = s->avctx->bits_per_raw_sample = bps;
522

    
523
    if (get_bits1(gb)) {
524
        av_log(s->avctx, AV_LOG_ERROR, "broken stream, invalid padding\n");
525
        return -1;
526
    }
527

    
528
    if (get_utf8(gb) < 0) {
529
        av_log(s->avctx, AV_LOG_ERROR, "utf8 fscked\n");
530
        return -1;
531
    }
532

    
533
    if (bs_code == 0) {
534
        av_log(s->avctx, AV_LOG_ERROR, "reserved blocksize code: 0\n");
535
        return -1;
536
    } else if (bs_code == 6)
537
        blocksize = get_bits(gb, 8)+1;
538
    else if (bs_code == 7)
539
        blocksize = get_bits(gb, 16)+1;
540
    else
541
        blocksize = ff_flac_blocksize_table[bs_code];
542

    
543
    if (blocksize > s->max_blocksize) {
544
        av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", blocksize,
545
               s->max_blocksize);
546
        return -1;
547
    }
548

    
549
    if (blocksize * s->channels * (s->is32 ? 4 : 2) > alloc_data_size)
550
        return -1;
551

    
552
    if (sr_code == 0)
553
        samplerate= s->samplerate;
554
    else if (sr_code < 12)
555
        samplerate = ff_flac_sample_rate_table[sr_code];
556
    else if (sr_code == 12)
557
        samplerate = get_bits(gb, 8) * 1000;
558
    else if (sr_code == 13)
559
        samplerate = get_bits(gb, 16);
560
    else if (sr_code == 14)
561
        samplerate = get_bits(gb, 16) * 10;
562
    else {
563
        av_log(s->avctx, AV_LOG_ERROR, "illegal sample rate code %d\n",
564
               sr_code);
565
        return -1;
566
    }
567

    
568
    skip_bits(gb, 8);
569
    crc8 = av_crc(av_crc_get_table(AV_CRC_8_ATM), 0,
570
                  gb->buffer, get_bits_count(gb)/8);
571
    if (crc8) {
572
        av_log(s->avctx, AV_LOG_ERROR, "header crc mismatch crc=%2X\n", crc8);
573
        return -1;
574
    }
575

    
576
    s->blocksize    = blocksize;
577
    s->samplerate   = samplerate;
578
    s->bps          = bps;
579
    s->ch_mode      = ch_mode;
580

    
581
//    dump_headers(s->avctx, (FLACStreaminfo *)s);
582

    
583
    /* subframes */
584
    for (i = 0; i < s->channels; i++) {
585
        if (decode_subframe(s, i) < 0)
586
            return -1;
587
    }
588

    
589
    align_get_bits(gb);
590

    
591
    /* frame footer */
592
    skip_bits(gb, 16); /* data crc */
593

    
594
    return 0;
595
}
596

    
597
static int flac_decode_frame(AVCodecContext *avctx,
598
                            void *data, int *data_size,
599
                            const uint8_t *buf, int buf_size)
600
{
601
    FLACContext *s = avctx->priv_data;
602
    int i, j = 0, input_buf_size = 0, bytes_read = 0;
603
    int16_t *samples_16 = data;
604
    int32_t *samples_32 = data;
605
    int alloc_data_size= *data_size;
606

    
607
    *data_size=0;
608

    
609
    if (s->max_framesize == 0) {
610
        s->max_framesize= FFMAX(4, buf_size); // should hopefully be enough for the first header
611
        s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
612
    }
613

    
614
    if (1 && s->max_framesize) { //FIXME truncated
615
        if (s->bitstream_size < 4 || AV_RL32(s->bitstream) != MKTAG('f','L','a','C'))
616
            buf_size= FFMIN(buf_size, s->max_framesize - FFMIN(s->bitstream_size, s->max_framesize));
617
        input_buf_size= buf_size;
618

    
619
        if (s->bitstream_size + buf_size < buf_size || s->bitstream_index + s->bitstream_size + buf_size < s->bitstream_index)
620
            return -1;
621

    
622
        if (s->allocated_bitstream_size < s->bitstream_size + buf_size)
623
            s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->bitstream_size + buf_size);
624

    
625
        if (s->bitstream_index + s->bitstream_size + buf_size > s->allocated_bitstream_size) {
626
            memmove(s->bitstream, &s->bitstream[s->bitstream_index],
627
                    s->bitstream_size);
628
            s->bitstream_index=0;
629
        }
630
        memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size],
631
               buf, buf_size);
632
        buf= &s->bitstream[s->bitstream_index];
633
        buf_size += s->bitstream_size;
634
        s->bitstream_size= buf_size;
635

    
636
        if (buf_size < s->max_framesize && input_buf_size) {
637
            return input_buf_size;
638
        }
639
    }
640

    
641
    /* check that there is at least the smallest decodable amount of data.
642
       this amount corresponds to the smallest valid FLAC frame possible.
643
       FF F8 69 02 00 00 9A 00 00 34 46 */
644
    if (buf_size < 11)
645
        goto end;
646

    
647
    /* check for inline header */
648
    if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
649
        if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) {
650
            av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
651
            return -1;
652
        }
653
        bytes_read = get_metadata_size(buf, buf_size);
654
        goto end;
655
    }
656

    
657
    /* check for frame sync code and resync stream if necessary */
658
    if ((AV_RB16(buf) & 0xFFFE) != 0xFFF8) {
659
        const uint8_t *buf_end = buf + buf_size;
660
        av_log(s->avctx, AV_LOG_ERROR, "FRAME HEADER not here\n");
661
        while (buf+2 < buf_end && (AV_RB16(buf) & 0xFFFE) != 0xFFF8)
662
            buf++;
663
        bytes_read = buf_size - (buf_end - buf);
664
        goto end; // we may not have enough bits left to decode a frame, so try next time
665
    }
666

    
667
    /* decode frame */
668
    init_get_bits(&s->gb, buf, buf_size*8);
669
    skip_bits(&s->gb, 16);
670
    if (decode_frame(s, alloc_data_size) < 0) {
671
        av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
672
        s->bitstream_size=0;
673
        s->bitstream_index=0;
674
        return -1;
675
    }
676
    *data_size = s->blocksize * s->channels * (s->is32 ? 4 : 2);
677
    bytes_read = (get_bits_count(&s->gb)+7)/8;
678

    
679
#define DECORRELATE(left, right)\
680
            assert(s->channels == 2);\
681
            for (i = 0; i < s->blocksize; i++) {\
682
                int a= s->decoded[0][i];\
683
                int b= s->decoded[1][i];\
684
                if (s->is32) {\
685
                    *samples_32++ = (left)  << s->sample_shift;\
686
                    *samples_32++ = (right) << s->sample_shift;\
687
                } else {\
688
                    *samples_16++ = (left)  << s->sample_shift;\
689
                    *samples_16++ = (right) << s->sample_shift;\
690
                }\
691
            }\
692
            break;
693

    
694
    switch (s->ch_mode) {
695
    case FLAC_CHMODE_INDEPENDENT:
696
        for (j = 0; j < s->blocksize; j++) {
697
            for (i = 0; i < s->channels; i++) {
698
                if (s->is32)
699
                    *samples_32++ = s->decoded[i][j] << s->sample_shift;
700
                else
701
                    *samples_16++ = s->decoded[i][j] << s->sample_shift;
702
            }
703
        }
704
        break;
705
    case FLAC_CHMODE_LEFT_SIDE:
706
        DECORRELATE(a,a-b)
707
    case FLAC_CHMODE_RIGHT_SIDE:
708
        DECORRELATE(a+b,b)
709
    case FLAC_CHMODE_MID_SIDE:
710
        DECORRELATE( (a-=b>>1) + b, a)
711
    }
712

    
713
end:
714
    if (bytes_read > buf_size) {
715
        av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
716
        s->bitstream_size=0;
717
        s->bitstream_index=0;
718
        return -1;
719
    }
720

    
721
    if (s->bitstream_size) {
722
        s->bitstream_index += bytes_read;
723
        s->bitstream_size  -= bytes_read;
724
        return input_buf_size;
725
    } else
726
        return bytes_read;
727
}
728

    
729
static av_cold int flac_decode_close(AVCodecContext *avctx)
730
{
731
    FLACContext *s = avctx->priv_data;
732
    int i;
733

    
734
    for (i = 0; i < s->channels; i++) {
735
        av_freep(&s->decoded[i]);
736
    }
737
    av_freep(&s->bitstream);
738

    
739
    return 0;
740
}
741

    
742
static void flac_flush(AVCodecContext *avctx)
743
{
744
    FLACContext *s = avctx->priv_data;
745

    
746
    s->bitstream_size=
747
    s->bitstream_index= 0;
748
}
749

    
750
AVCodec flac_decoder = {
751
    "flac",
752
    CODEC_TYPE_AUDIO,
753
    CODEC_ID_FLAC,
754
    sizeof(FLACContext),
755
    flac_decode_init,
756
    NULL,
757
    flac_decode_close,
758
    flac_decode_frame,
759
    CODEC_CAP_DELAY,
760
    .flush= flac_flush,
761
    .long_name= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
762
};