Statistics
| Branch: | Revision:

ffmpeg / libavcodec / flacdec.c @ 8d1e885f

History | View | Annotate | Download (23.4 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

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

    
49
#define MAX_CHANNELS 8
50
#define MAX_BLOCKSIZE 65535
51

    
52
enum decorrelation_type {
53
    INDEPENDENT,
54
    LEFT_SIDE,
55
    RIGHT_SIDE,
56
    MID_SIDE,
57
};
58

    
59
typedef struct FLACContext {
60
    FLACSTREAMINFO
61

    
62
    AVCodecContext *avctx;                  ///< parent AVCodecContext
63
    GetBitContext gb;                       ///< GetBitContext initialized to start at the current frame
64

    
65
    int blocksize;                          ///< number of samples in the current frame
66
    int curr_bps;                           ///< bps for current subframe, adjusted for channel correlation and wasted bits
67
    int sample_shift;                       ///< shift required to make output samples 16-bit or 32-bit
68
    int is32;                               ///< flag to indicate if output should be 32-bit instead of 16-bit
69
    enum decorrelation_type decorrelation;  ///< channel decorrelation type in the current frame
70
    int got_streaminfo;                     ///< indicates if the STREAMINFO has been read
71

    
72
    int32_t *decoded[MAX_CHANNELS];         ///< decoded samples
73
    uint8_t *bitstream;
74
    unsigned int bitstream_size;
75
    unsigned int bitstream_index;
76
    unsigned int allocated_bitstream_size;
77
} FLACContext;
78

    
79
static const int sample_rate_table[] =
80
{ 0,
81
  88200, 176400, 192000,
82
  8000, 16000, 22050, 24000, 32000, 44100, 48000, 96000,
83
  0, 0, 0, 0 };
84

    
85
static const int sample_size_table[] =
86
{ 0, 8, 12, 0, 16, 20, 24, 0 };
87

    
88
static const int blocksize_table[] = {
89
     0,    192, 576<<0, 576<<1, 576<<2, 576<<3,      0,      0,
90
256<<0, 256<<1, 256<<2, 256<<3, 256<<4, 256<<5, 256<<6, 256<<7
91
};
92

    
93
static int64_t get_utf8(GetBitContext *gb)
94
{
95
    int64_t val;
96
    GET_UTF8(val, get_bits(gb, 8), return -1;)
97
    return val;
98
}
99

    
100
static void allocate_buffers(FLACContext *s);
101

    
102
int ff_flac_is_extradata_valid(AVCodecContext *avctx,
103
                               enum FLACExtradataFormat *format,
104
                               uint8_t **streaminfo_start)
105
{
106
    if (!avctx->extradata || avctx->extradata_size < FLAC_STREAMINFO_SIZE) {
107
        av_log(avctx, AV_LOG_ERROR, "extradata NULL or too small.\n");
108
        return 0;
109
    }
110
    if (AV_RL32(avctx->extradata) != MKTAG('f','L','a','C')) {
111
        /* extradata contains STREAMINFO only */
112
        if (avctx->extradata_size != FLAC_STREAMINFO_SIZE) {
113
            av_log(avctx, AV_LOG_WARNING, "extradata contains %d bytes too many.\n",
114
                   FLAC_STREAMINFO_SIZE-avctx->extradata_size);
115
        }
116
        *format = FLAC_EXTRADATA_FORMAT_STREAMINFO;
117
        *streaminfo_start = avctx->extradata;
118
    } else {
119
        if (avctx->extradata_size < 8+FLAC_STREAMINFO_SIZE) {
120
            av_log(avctx, AV_LOG_ERROR, "extradata too small.\n");
121
            return 0;
122
        }
123
        *format = FLAC_EXTRADATA_FORMAT_FULL_HEADER;
124
        *streaminfo_start = &avctx->extradata[8];
125
    }
126
    return 1;
127
}
128

    
129
static av_cold int flac_decode_init(AVCodecContext *avctx)
130
{
131
    enum FLACExtradataFormat format;
132
    uint8_t *streaminfo;
133
    FLACContext *s = avctx->priv_data;
134
    s->avctx = avctx;
135

    
136
    avctx->sample_fmt = SAMPLE_FMT_S16;
137

    
138
    /* for now, the raw FLAC header is allowed to be passed to the decoder as
139
       frame data instead of extradata. */
140
    if (!avctx->extradata)
141
        return 0;
142

    
143
    if (!ff_flac_is_extradata_valid(avctx, &format, &streaminfo))
144
        return -1;
145

    
146
    /* initialize based on the demuxer-supplied streamdata header */
147
    ff_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
148
    allocate_buffers(s);
149
    s->got_streaminfo = 1;
150

    
151
    return 0;
152
}
153

    
154
static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
155
{
156
    av_log(avctx, AV_LOG_DEBUG, "  Max Blocksize: %d\n", s->max_blocksize);
157
    av_log(avctx, AV_LOG_DEBUG, "  Max Framesize: %d\n", s->max_framesize);
158
    av_log(avctx, AV_LOG_DEBUG, "  Samplerate: %d\n", s->samplerate);
159
    av_log(avctx, AV_LOG_DEBUG, "  Channels: %d\n", s->channels);
160
    av_log(avctx, AV_LOG_DEBUG, "  Bits: %d\n", s->bps);
161
}
162

    
163
static void allocate_buffers(FLACContext *s)
164
{
165
    int i;
166

    
167
    assert(s->max_blocksize);
168

    
169
    if (s->max_framesize == 0 && s->max_blocksize) {
170
        // FIXME header overhead
171
        s->max_framesize= (s->channels * s->bps * s->max_blocksize + 7)/ 8;
172
    }
173

    
174
    for (i = 0; i < s->channels; i++) {
175
        s->decoded[i] = av_realloc(s->decoded[i],
176
                                   sizeof(int32_t)*s->max_blocksize);
177
    }
178

    
179
    if (s->allocated_bitstream_size < s->max_framesize)
180
        s->bitstream= av_fast_realloc(s->bitstream,
181
                                      &s->allocated_bitstream_size,
182
                                      s->max_framesize);
183
}
184

    
185
void ff_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s,
186
                              const uint8_t *buffer)
187
{
188
    GetBitContext gb;
189
    init_get_bits(&gb, buffer, FLAC_STREAMINFO_SIZE*8);
190

    
191
    skip_bits(&gb, 16); /* skip min blocksize */
192
    s->max_blocksize = get_bits(&gb, 16);
193
    if (s->max_blocksize < 16) {
194
        av_log(avctx, AV_LOG_WARNING, "invalid max blocksize: %d\n",
195
               s->max_blocksize);
196
        s->max_blocksize = 16;
197
    }
198

    
199
    skip_bits(&gb, 24); /* skip min frame size */
200
    s->max_framesize = get_bits_long(&gb, 24);
201

    
202
    s->samplerate = get_bits_long(&gb, 20);
203
    s->channels = get_bits(&gb, 3) + 1;
204
    s->bps = get_bits(&gb, 5) + 1;
205

    
206
    avctx->channels = s->channels;
207
    avctx->sample_rate = s->samplerate;
208
    avctx->bits_per_raw_sample = s->bps;
209
    if (s->bps > 16)
210
        avctx->sample_fmt = SAMPLE_FMT_S32;
211
    else
212
        avctx->sample_fmt = SAMPLE_FMT_S16;
213

    
214
    s->samples  = get_bits_long(&gb, 32) << 4;
215
    s->samples |= get_bits(&gb, 4);
216

    
217
    skip_bits_long(&gb, 64); /* md5 sum */
218
    skip_bits_long(&gb, 64); /* md5 sum */
219

    
220
    dump_headers(avctx, s);
221
}
222

    
223
/**
224
 * Parse the STREAMINFO from an inline header.
225
 * @param s the flac decoding context
226
 * @param buf input buffer, starting with the "fLaC" marker
227
 * @param buf_size buffer size
228
 * @return non-zero if metadata is invalid
229
 */
230
static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
231
{
232
    int metadata_type, metadata_size;
233

    
234
    if (buf_size < FLAC_STREAMINFO_SIZE+8) {
235
        /* need more data */
236
        return 0;
237
    }
238
    buf += 4;
239
    metadata_type = bytestream_get_byte(&buf) & 0x7F;
240
    metadata_size = bytestream_get_be24(&buf);
241
    if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
242
        metadata_size != FLAC_STREAMINFO_SIZE) {
243
        return AVERROR_INVALIDDATA;
244
    }
245
    ff_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, buf);
246
    allocate_buffers(s);
247
    s->got_streaminfo = 1;
248

    
249
    return 0;
250
}
251

    
252
/**
253
 * Determine the size of an inline header.
254
 * @param buf input buffer, starting with the "fLaC" marker
255
 * @param buf_size buffer size
256
 * @return number of bytes in the header, or 0 if more data is needed
257
 */
258
static int get_metadata_size(const uint8_t *buf, int buf_size)
259
{
260
    int metadata_last, metadata_size;
261
    const uint8_t *buf_end = buf + buf_size;
262

    
263
    buf += 4;
264
    do {
265
        metadata_last = bytestream_get_byte(&buf) & 0x80;
266
        metadata_size = bytestream_get_be24(&buf);
267
        if (buf + metadata_size > buf_end) {
268
            /* need more data in order to read the complete header */
269
            return 0;
270
        }
271
        buf += metadata_size;
272
    } while (!metadata_last);
273

    
274
    return buf_size - (buf_end - buf);
275
}
276

    
277
static int decode_residuals(FLACContext *s, int channel, int pred_order)
278
{
279
    int i, tmp, partition, method_type, rice_order;
280
    int sample = 0, samples;
281

    
282
    method_type = get_bits(&s->gb, 2);
283
    if (method_type > 1) {
284
        av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
285
               method_type);
286
        return -1;
287
    }
288

    
289
    rice_order = get_bits(&s->gb, 4);
290

    
291
    samples= s->blocksize >> rice_order;
292
    if (pred_order > samples) {
293
        av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
294
               pred_order, samples);
295
        return -1;
296
    }
297

    
298
    sample=
299
    i= pred_order;
300
    for (partition = 0; partition < (1 << rice_order); partition++) {
301
        tmp = get_bits(&s->gb, method_type == 0 ? 4 : 5);
302
        if (tmp == (method_type == 0 ? 15 : 31)) {
303
            tmp = get_bits(&s->gb, 5);
304
            for (; i < samples; i++, sample++)
305
                s->decoded[channel][sample] = get_sbits_long(&s->gb, tmp);
306
        } else {
307
            for (; i < samples; i++, sample++) {
308
                s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
309
            }
310
        }
311
        i= 0;
312
    }
313

    
314
    return 0;
315
}
316

    
317
static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order)
318
{
319
    const int blocksize = s->blocksize;
320
    int32_t *decoded = s->decoded[channel];
321
    int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i;
322

    
323
    /* warm up samples */
324
    for (i = 0; i < pred_order; i++) {
325
        decoded[i] = get_sbits_long(&s->gb, s->curr_bps);
326
    }
327

    
328
    if (decode_residuals(s, channel, pred_order) < 0)
329
        return -1;
330

    
331
    if (pred_order > 0)
332
        a = decoded[pred_order-1];
333
    if (pred_order > 1)
334
        b = a - decoded[pred_order-2];
335
    if (pred_order > 2)
336
        c = b - decoded[pred_order-2] + decoded[pred_order-3];
337
    if (pred_order > 3)
338
        d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
339

    
340
    switch (pred_order) {
341
    case 0:
342
        break;
343
    case 1:
344
        for (i = pred_order; i < blocksize; i++)
345
            decoded[i] = a += decoded[i];
346
        break;
347
    case 2:
348
        for (i = pred_order; i < blocksize; i++)
349
            decoded[i] = a += b += decoded[i];
350
        break;
351
    case 3:
352
        for (i = pred_order; i < blocksize; i++)
353
            decoded[i] = a += b += c += decoded[i];
354
        break;
355
    case 4:
356
        for (i = pred_order; i < blocksize; i++)
357
            decoded[i] = a += b += c += d += decoded[i];
358
        break;
359
    default:
360
        av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
361
        return -1;
362
    }
363

    
364
    return 0;
365
}
366

    
367
static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order)
368
{
369
    int i, j;
370
    int coeff_prec, qlevel;
371
    int coeffs[pred_order];
372
    int32_t *decoded = s->decoded[channel];
373

    
374
    /* warm up samples */
375
    for (i = 0; i < pred_order; i++) {
376
        decoded[i] = get_sbits_long(&s->gb, s->curr_bps);
377
    }
378

    
379
    coeff_prec = get_bits(&s->gb, 4) + 1;
380
    if (coeff_prec == 16) {
381
        av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
382
        return -1;
383
    }
384
    qlevel = get_sbits(&s->gb, 5);
385
    if (qlevel < 0) {
386
        av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
387
               qlevel);
388
        return -1;
389
    }
390

    
391
    for (i = 0; i < pred_order; i++) {
392
        coeffs[i] = get_sbits(&s->gb, coeff_prec);
393
    }
394

    
395
    if (decode_residuals(s, channel, pred_order) < 0)
396
        return -1;
397

    
398
    if (s->bps > 16) {
399
        int64_t sum;
400
        for (i = pred_order; i < s->blocksize; i++) {
401
            sum = 0;
402
            for (j = 0; j < pred_order; j++)
403
                sum += (int64_t)coeffs[j] * decoded[i-j-1];
404
            decoded[i] += sum >> qlevel;
405
        }
406
    } else {
407
        for (i = pred_order; i < s->blocksize-1; i += 2) {
408
            int c;
409
            int d = decoded[i-pred_order];
410
            int s0 = 0, s1 = 0;
411
            for (j = pred_order-1; j > 0; j--) {
412
                c = coeffs[j];
413
                s0 += c*d;
414
                d = decoded[i-j];
415
                s1 += c*d;
416
            }
417
            c = coeffs[0];
418
            s0 += c*d;
419
            d = decoded[i] += s0 >> qlevel;
420
            s1 += c*d;
421
            decoded[i+1] += s1 >> qlevel;
422
        }
423
        if (i < s->blocksize) {
424
            int sum = 0;
425
            for (j = 0; j < pred_order; j++)
426
                sum += coeffs[j] * decoded[i-j-1];
427
            decoded[i] += sum >> qlevel;
428
        }
429
    }
430

    
431
    return 0;
432
}
433

    
434
static inline int decode_subframe(FLACContext *s, int channel)
435
{
436
    int type, wasted = 0;
437
    int i, tmp;
438

    
439
    s->curr_bps = s->bps;
440
    if (channel == 0) {
441
        if (s->decorrelation == RIGHT_SIDE)
442
            s->curr_bps++;
443
    } else {
444
        if (s->decorrelation == LEFT_SIDE || s->decorrelation == MID_SIDE)
445
            s->curr_bps++;
446
    }
447

    
448
    if (get_bits1(&s->gb)) {
449
        av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
450
        return -1;
451
    }
452
    type = get_bits(&s->gb, 6);
453

    
454
    if (get_bits1(&s->gb)) {
455
        wasted = 1;
456
        while (!get_bits1(&s->gb))
457
            wasted++;
458
        s->curr_bps -= wasted;
459
    }
460
    if (s->curr_bps > 32) {
461
        ff_log_missing_feature(s->avctx, "decorrelated bit depth > 32", 0);
462
        return -1;
463
    }
464

    
465
//FIXME use av_log2 for types
466
    if (type == 0) {
467
        tmp = get_sbits_long(&s->gb, s->curr_bps);
468
        for (i = 0; i < s->blocksize; i++)
469
            s->decoded[channel][i] = tmp;
470
    } else if (type == 1) {
471
        for (i = 0; i < s->blocksize; i++)
472
            s->decoded[channel][i] = get_sbits_long(&s->gb, s->curr_bps);
473
    } else if ((type >= 8) && (type <= 12)) {
474
        if (decode_subframe_fixed(s, channel, type & ~0x8) < 0)
475
            return -1;
476
    } else if (type >= 32) {
477
        if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0)
478
            return -1;
479
    } else {
480
        av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
481
        return -1;
482
    }
483

    
484
    if (wasted) {
485
        int i;
486
        for (i = 0; i < s->blocksize; i++)
487
            s->decoded[channel][i] <<= wasted;
488
    }
489

    
490
    return 0;
491
}
492

    
493
static int decode_frame(FLACContext *s, int alloc_data_size)
494
{
495
    int blocksize_code, sample_rate_code, sample_size_code, assignment, i, crc8;
496
    int decorrelation, bps, blocksize, samplerate;
497

    
498
    blocksize_code = get_bits(&s->gb, 4);
499

    
500
    sample_rate_code = get_bits(&s->gb, 4);
501

    
502
    assignment = get_bits(&s->gb, 4); /* channel assignment */
503
    if (assignment < 8 && s->channels == assignment+1)
504
        decorrelation = INDEPENDENT;
505
    else if (assignment >=8 && assignment < 11 && s->channels == 2)
506
        decorrelation = LEFT_SIDE + assignment - 8;
507
    else {
508
        av_log(s->avctx, AV_LOG_ERROR, "unsupported channel assignment %d (channels=%d)\n",
509
               assignment, s->channels);
510
        return -1;
511
    }
512

    
513
    sample_size_code = get_bits(&s->gb, 3);
514
    if (sample_size_code == 0)
515
        bps= s->bps;
516
    else if ((sample_size_code != 3) && (sample_size_code != 7))
517
        bps = sample_size_table[sample_size_code];
518
    else {
519
        av_log(s->avctx, AV_LOG_ERROR, "invalid sample size code (%d)\n",
520
               sample_size_code);
521
        return -1;
522
    }
523
    if (bps > 16) {
524
        s->avctx->sample_fmt = SAMPLE_FMT_S32;
525
        s->sample_shift = 32 - bps;
526
        s->is32 = 1;
527
    } else {
528
        s->avctx->sample_fmt = SAMPLE_FMT_S16;
529
        s->sample_shift = 16 - bps;
530
        s->is32 = 0;
531
    }
532
    s->bps = s->avctx->bits_per_raw_sample = bps;
533

    
534
    if (get_bits1(&s->gb)) {
535
        av_log(s->avctx, AV_LOG_ERROR, "broken stream, invalid padding\n");
536
        return -1;
537
    }
538

    
539
    if (get_utf8(&s->gb) < 0) {
540
        av_log(s->avctx, AV_LOG_ERROR, "utf8 fscked\n");
541
        return -1;
542
    }
543

    
544
    if (blocksize_code == 0) {
545
        av_log(s->avctx, AV_LOG_ERROR, "reserved blocksize code: 0\n");
546
        return -1;
547
    } else if (blocksize_code == 6)
548
        blocksize = get_bits(&s->gb, 8)+1;
549
    else if (blocksize_code == 7)
550
        blocksize = get_bits(&s->gb, 16)+1;
551
    else
552
        blocksize = blocksize_table[blocksize_code];
553

    
554
    if (blocksize > s->max_blocksize) {
555
        av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", blocksize,
556
               s->max_blocksize);
557
        return -1;
558
    }
559

    
560
    if (blocksize * s->channels * (s->is32 ? 4 : 2) > alloc_data_size)
561
        return -1;
562

    
563
    if (sample_rate_code == 0)
564
        samplerate= s->samplerate;
565
    else if (sample_rate_code < 12)
566
        samplerate = sample_rate_table[sample_rate_code];
567
    else if (sample_rate_code == 12)
568
        samplerate = get_bits(&s->gb, 8) * 1000;
569
    else if (sample_rate_code == 13)
570
        samplerate = get_bits(&s->gb, 16);
571
    else if (sample_rate_code == 14)
572
        samplerate = get_bits(&s->gb, 16) * 10;
573
    else {
574
        av_log(s->avctx, AV_LOG_ERROR, "illegal sample rate code %d\n",
575
               sample_rate_code);
576
        return -1;
577
    }
578

    
579
    skip_bits(&s->gb, 8);
580
    crc8 = av_crc(av_crc_get_table(AV_CRC_8_ATM), 0,
581
                  s->gb.buffer, get_bits_count(&s->gb)/8);
582
    if (crc8) {
583
        av_log(s->avctx, AV_LOG_ERROR, "header crc mismatch crc=%2X\n", crc8);
584
        return -1;
585
    }
586

    
587
    s->blocksize    = blocksize;
588
    s->samplerate   = samplerate;
589
    s->bps          = bps;
590
    s->decorrelation= decorrelation;
591

    
592
//    dump_headers(s->avctx, (FLACStreaminfo *)s);
593

    
594
    /* subframes */
595
    for (i = 0; i < s->channels; i++) {
596
        if (decode_subframe(s, i) < 0)
597
            return -1;
598
    }
599

    
600
    align_get_bits(&s->gb);
601

    
602
    /* frame footer */
603
    skip_bits(&s->gb, 16); /* data crc */
604

    
605
    return 0;
606
}
607

    
608
static int flac_decode_frame(AVCodecContext *avctx,
609
                            void *data, int *data_size,
610
                            const uint8_t *buf, int buf_size)
611
{
612
    FLACContext *s = avctx->priv_data;
613
    int i, j = 0, input_buf_size = 0, bytes_read = 0;
614
    int16_t *samples_16 = data;
615
    int32_t *samples_32 = data;
616
    int alloc_data_size= *data_size;
617

    
618
    *data_size=0;
619

    
620
    if (s->max_framesize == 0) {
621
        s->max_framesize= FFMAX(4, buf_size); // should hopefully be enough for the first header
622
        s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
623
    }
624

    
625
    if (1 && s->max_framesize) { //FIXME truncated
626
        if (s->bitstream_size < 4 || AV_RL32(s->bitstream) != MKTAG('f','L','a','C'))
627
            buf_size= FFMIN(buf_size, s->max_framesize - FFMIN(s->bitstream_size, s->max_framesize));
628
        input_buf_size= buf_size;
629

    
630
        if (s->bitstream_size + buf_size < buf_size || s->bitstream_index + s->bitstream_size + buf_size < s->bitstream_index)
631
            return -1;
632

    
633
        if (s->allocated_bitstream_size < s->bitstream_size + buf_size)
634
            s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->bitstream_size + buf_size);
635

    
636
        if (s->bitstream_index + s->bitstream_size + buf_size > s->allocated_bitstream_size) {
637
            memmove(s->bitstream, &s->bitstream[s->bitstream_index],
638
                    s->bitstream_size);
639
            s->bitstream_index=0;
640
        }
641
        memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size],
642
               buf, buf_size);
643
        buf= &s->bitstream[s->bitstream_index];
644
        buf_size += s->bitstream_size;
645
        s->bitstream_size= buf_size;
646

    
647
        if (buf_size < s->max_framesize && input_buf_size) {
648
            return input_buf_size;
649
        }
650
    }
651

    
652
    /* check that there is at least the smallest decodable amount of data.
653
       this amount corresponds to the smallest valid FLAC frame possible.
654
       FF F8 69 02 00 00 9A 00 00 34 46 */
655
    if (buf_size < 11)
656
        goto end;
657

    
658
    /* check for inline header */
659
    if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
660
        if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) {
661
            av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
662
            return -1;
663
        }
664
        bytes_read = get_metadata_size(buf, buf_size);
665
        goto end;
666
    }
667

    
668
    /* check for frame sync code and resync stream if necessary */
669
    if ((AV_RB16(buf) & 0xFFFE) != 0xFFF8) {
670
        const uint8_t *buf_end = buf + buf_size;
671
        av_log(s->avctx, AV_LOG_ERROR, "FRAME HEADER not here\n");
672
        while (buf+2 < buf_end && (AV_RB16(buf) & 0xFFFE) != 0xFFF8)
673
            buf++;
674
        bytes_read = buf_size - (buf_end - buf);
675
        goto end; // we may not have enough bits left to decode a frame, so try next time
676
    }
677

    
678
    /* decode frame */
679
    init_get_bits(&s->gb, buf, buf_size*8);
680
    skip_bits(&s->gb, 16);
681
    if (decode_frame(s, alloc_data_size) < 0) {
682
        av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
683
        s->bitstream_size=0;
684
        s->bitstream_index=0;
685
        return -1;
686
    }
687
    *data_size = s->blocksize * s->channels * (s->is32 ? 4 : 2);
688
    bytes_read = (get_bits_count(&s->gb)+7)/8;
689

    
690
#define DECORRELATE(left, right)\
691
            assert(s->channels == 2);\
692
            for (i = 0; i < s->blocksize; i++) {\
693
                int a= s->decoded[0][i];\
694
                int b= s->decoded[1][i];\
695
                if (s->is32) {\
696
                    *samples_32++ = (left)  << s->sample_shift;\
697
                    *samples_32++ = (right) << s->sample_shift;\
698
                } else {\
699
                    *samples_16++ = (left)  << s->sample_shift;\
700
                    *samples_16++ = (right) << s->sample_shift;\
701
                }\
702
            }\
703
            break;
704

    
705
    switch (s->decorrelation) {
706
    case INDEPENDENT:
707
        for (j = 0; j < s->blocksize; j++) {
708
            for (i = 0; i < s->channels; i++) {
709
                if (s->is32)
710
                    *samples_32++ = s->decoded[i][j] << s->sample_shift;
711
                else
712
                    *samples_16++ = s->decoded[i][j] << s->sample_shift;
713
            }
714
        }
715
        break;
716
    case LEFT_SIDE:
717
        DECORRELATE(a,a-b)
718
    case RIGHT_SIDE:
719
        DECORRELATE(a+b,b)
720
    case MID_SIDE:
721
        DECORRELATE( (a-=b>>1) + b, a)
722
    }
723

    
724
end:
725
    if (bytes_read > buf_size) {
726
        av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
727
        s->bitstream_size=0;
728
        s->bitstream_index=0;
729
        return -1;
730
    }
731

    
732
    if (s->bitstream_size) {
733
        s->bitstream_index += bytes_read;
734
        s->bitstream_size  -= bytes_read;
735
        return input_buf_size;
736
    } else
737
        return bytes_read;
738
}
739

    
740
static av_cold int flac_decode_close(AVCodecContext *avctx)
741
{
742
    FLACContext *s = avctx->priv_data;
743
    int i;
744

    
745
    for (i = 0; i < s->channels; i++) {
746
        av_freep(&s->decoded[i]);
747
    }
748
    av_freep(&s->bitstream);
749

    
750
    return 0;
751
}
752

    
753
static void flac_flush(AVCodecContext *avctx)
754
{
755
    FLACContext *s = avctx->priv_data;
756

    
757
    s->bitstream_size=
758
    s->bitstream_index= 0;
759
}
760

    
761
AVCodec flac_decoder = {
762
    "flac",
763
    CODEC_TYPE_AUDIO,
764
    CODEC_ID_FLAC,
765
    sizeof(FLACContext),
766
    flac_decode_init,
767
    NULL,
768
    flac_decode_close,
769
    flac_decode_frame,
770
    CODEC_CAP_DELAY,
771
    .flush= flac_flush,
772
    .long_name= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
773
};