flacdec.c 20 KB
Newer Older
1 2 3 4
/*
 * FLAC (Free Lossless Audio Codec) decoder
 * Copyright (c) 2003 Alex Beregszaszi
 *
5 6 7
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
8 9
 * modify it under the terms of the GNU Lesser General Public
 * 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 14 15 16 17
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * 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
24 25
 * FLAC (Free Lossless Audio Codec) decoder
 * @author Alex Beregszaszi
26
 * @see http://flac.sourceforge.net/
27 28 29 30 31
 *
 * This decoder can be used in 1 of 2 ways: Either raw FLAC data can be fed
 * through, starting from the initial 'fLaC' signature; or by passing the
 * 34-byte streaminfo structure through avctx->extradata[_size] followed
 * by data starting with the 0xFFF8 marker.
32
 */
33

Michael Niedermayer's avatar
Michael Niedermayer committed
34
#include <limits.h>
35

36
#include "libavutil/crc.h"
37
#include "avcodec.h"
38
#include "internal.h"
39
#include "get_bits.h"
40
#include "bytestream.h"
41
#include "golomb.h"
42
#include "flac.h"
43
#include "flacdata.h"
44

Michael Niedermayer's avatar
Michael Niedermayer committed
45 46 47
#undef NDEBUG
#include <assert.h>

48
typedef struct FLACContext {
49 50
    FLACSTREAMINFO

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

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

61
    int32_t *decoded[FLAC_MAX_CHANNELS];    ///< decoded samples
62 63
} FLACContext;

64
static void allocate_buffers(FLACContext *s);
65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91

int ff_flac_is_extradata_valid(AVCodecContext *avctx,
                               enum FLACExtradataFormat *format,
                               uint8_t **streaminfo_start)
{
    if (!avctx->extradata || avctx->extradata_size < FLAC_STREAMINFO_SIZE) {
        av_log(avctx, AV_LOG_ERROR, "extradata NULL or too small.\n");
        return 0;
    }
    if (AV_RL32(avctx->extradata) != MKTAG('f','L','a','C')) {
        /* extradata contains STREAMINFO only */
        if (avctx->extradata_size != FLAC_STREAMINFO_SIZE) {
            av_log(avctx, AV_LOG_WARNING, "extradata contains %d bytes too many.\n",
                   FLAC_STREAMINFO_SIZE-avctx->extradata_size);
        }
        *format = FLAC_EXTRADATA_FORMAT_STREAMINFO;
        *streaminfo_start = avctx->extradata;
    } else {
        if (avctx->extradata_size < 8+FLAC_STREAMINFO_SIZE) {
            av_log(avctx, AV_LOG_ERROR, "extradata too small.\n");
            return 0;
        }
        *format = FLAC_EXTRADATA_FORMAT_FULL_HEADER;
        *streaminfo_start = &avctx->extradata[8];
    }
    return 1;
}
92

93
static av_cold int flac_decode_init(AVCodecContext *avctx)
94
{
95 96
    enum FLACExtradataFormat format;
    uint8_t *streaminfo;
97 98 99
    FLACContext *s = avctx->priv_data;
    s->avctx = avctx;

100
    avctx->sample_fmt = AV_SAMPLE_FMT_S16;
101

102 103 104 105 106 107 108 109
    /* for now, the raw FLAC header is allowed to be passed to the decoder as
       frame data instead of extradata. */
    if (!avctx->extradata)
        return 0;

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

110 111
    /* initialize based on the demuxer-supplied streamdata header */
    ff_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
112
    if (s->bps > 16)
113
        avctx->sample_fmt = AV_SAMPLE_FMT_S32;
114
    else
115
        avctx->sample_fmt = AV_SAMPLE_FMT_S16;
116
    allocate_buffers(s);
117
    s->got_streaminfo = 1;
118

119 120 121
    return 0;
}

122
static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
123
{
124
    av_log(avctx, AV_LOG_DEBUG, "  Max Blocksize: %d\n", s->max_blocksize);
125 126 127 128
    av_log(avctx, AV_LOG_DEBUG, "  Max Framesize: %d\n", s->max_framesize);
    av_log(avctx, AV_LOG_DEBUG, "  Samplerate: %d\n", s->samplerate);
    av_log(avctx, AV_LOG_DEBUG, "  Channels: %d\n", s->channels);
    av_log(avctx, AV_LOG_DEBUG, "  Bits: %d\n", s->bps);
129 130
}

131 132
static void allocate_buffers(FLACContext *s)
{
133 134
    int i;

Michael Niedermayer's avatar
Michael Niedermayer committed
135 136
    assert(s->max_blocksize);

137
    for (i = 0; i < s->channels; i++) {
138 139
        s->decoded[i] = av_realloc(s->decoded[i],
                                   sizeof(int32_t)*s->max_blocksize);
Michael Niedermayer's avatar
Michael Niedermayer committed
140 141 142
    }
}

143 144
void ff_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s,
                              const uint8_t *buffer)
Michael Niedermayer's avatar
Michael Niedermayer committed
145
{
146 147 148
    GetBitContext gb;
    init_get_bits(&gb, buffer, FLAC_STREAMINFO_SIZE*8);

149
    skip_bits(&gb, 16); /* skip min blocksize */
150
    s->max_blocksize = get_bits(&gb, 16);
151
    if (s->max_blocksize < FLAC_MIN_BLOCKSIZE) {
152 153 154 155
        av_log(avctx, AV_LOG_WARNING, "invalid max blocksize: %d\n",
               s->max_blocksize);
        s->max_blocksize = 16;
    }
156

157 158
    skip_bits(&gb, 24); /* skip min frame size */
    s->max_framesize = get_bits_long(&gb, 24);
159

160 161 162
    s->samplerate = get_bits_long(&gb, 20);
    s->channels = get_bits(&gb, 3) + 1;
    s->bps = get_bits(&gb, 5) + 1;
163

164 165
    avctx->channels = s->channels;
    avctx->sample_rate = s->samplerate;
166
    avctx->bits_per_raw_sample = s->bps;
167

168
    s->samples  = get_bits_long(&gb, 32) << 4;
169
    s->samples |= get_bits(&gb, 4);
170

171 172
    skip_bits_long(&gb, 64); /* md5 sum */
    skip_bits_long(&gb, 64); /* md5 sum */
173

174
    dump_headers(avctx, s);
175 176
}

177 178 179 180 181 182 183 184 185 186 187 188
void ff_flac_parse_block_header(const uint8_t *block_header,
                                int *last, int *type, int *size)
{
    int tmp = bytestream_get_byte(&block_header);
    if (last)
        *last = tmp & 0x80;
    if (type)
        *type = tmp & 0x7F;
    if (size)
        *size = bytestream_get_be24(&block_header);
}

189
/**
190 191 192 193
 * Parse the STREAMINFO from an inline header.
 * @param s the flac decoding context
 * @param buf input buffer, starting with the "fLaC" marker
 * @param buf_size buffer size
194
 * @return non-zero if metadata is invalid
195
 */
196
static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
197
{
198
    int metadata_type, metadata_size;
199

200 201 202 203
    if (buf_size < FLAC_STREAMINFO_SIZE+8) {
        /* need more data */
        return 0;
    }
204
    ff_flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
205 206 207 208
    if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
        metadata_size != FLAC_STREAMINFO_SIZE) {
        return AVERROR_INVALIDDATA;
    }
209
    ff_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]);
210 211
    allocate_buffers(s);
    s->got_streaminfo = 1;
212

213 214
    return 0;
}
215

216 217 218 219 220 221 222 223 224 225
/**
 * Determine the size of an inline header.
 * @param buf input buffer, starting with the "fLaC" marker
 * @param buf_size buffer size
 * @return number of bytes in the header, or 0 if more data is needed
 */
static int get_metadata_size(const uint8_t *buf, int buf_size)
{
    int metadata_last, metadata_size;
    const uint8_t *buf_end = buf + buf_size;
226

227 228
    buf += 4;
    do {
229 230
        ff_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
        buf += 4;
231 232 233
        if (buf + metadata_size > buf_end) {
            /* need more data in order to read the complete header */
            return 0;
234
        }
235
        buf += metadata_size;
236
    } while (!metadata_last);
237

238
    return buf_size - (buf_end - buf);
239 240 241 242 243 244 245 246
}

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

    method_type = get_bits(&s->gb, 2);
247
    if (method_type > 1) {
248 249
        av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
               method_type);
250
        return -1;
Michael Niedermayer's avatar
Michael Niedermayer committed
251
    }
252

253 254
    rice_order = get_bits(&s->gb, 4);

Michael Niedermayer's avatar
Michael Niedermayer committed
255
    samples= s->blocksize >> rice_order;
256
    if (pred_order > samples) {
257 258
        av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
               pred_order, samples);
259 260
        return -1;
    }
261

262
    sample=
Michael Niedermayer's avatar
Michael Niedermayer committed
263
    i= pred_order;
264
    for (partition = 0; partition < (1 << rice_order); partition++) {
265
        tmp = get_bits(&s->gb, method_type == 0 ? 4 : 5);
266
        if (tmp == (method_type == 0 ? 15 : 31)) {
267 268
            tmp = get_bits(&s->gb, 5);
            for (; i < samples; i++, sample++)
269
                s->decoded[channel][sample] = get_sbits_long(&s->gb, tmp);
270 271
        } else {
            for (; i < samples; i++, sample++) {
272
                s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
Michael Niedermayer's avatar
Michael Niedermayer committed
273
            }
274
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
275
        i= 0;
276 277 278
    }

    return 0;
279
}
280 281 282

static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order)
{
283 284
    const int blocksize = s->blocksize;
    int32_t *decoded = s->decoded[channel];
285
    int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i;
286

287
    /* warm up samples */
288
    for (i = 0; i < pred_order; i++) {
289
        decoded[i] = get_sbits_long(&s->gb, s->curr_bps);
290
    }
291

292 293 294
    if (decode_residuals(s, channel, pred_order) < 0)
        return -1;

295
    if (pred_order > 0)
Ramiro Polla's avatar
Ramiro Polla committed
296
        a = decoded[pred_order-1];
297
    if (pred_order > 1)
Ramiro Polla's avatar
Ramiro Polla committed
298
        b = a - decoded[pred_order-2];
299
    if (pred_order > 2)
Ramiro Polla's avatar
Ramiro Polla committed
300
        c = b - decoded[pred_order-2] + decoded[pred_order-3];
301
    if (pred_order > 3)
Ramiro Polla's avatar
Ramiro Polla committed
302
        d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
303

304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325
    switch (pred_order) {
    case 0:
        break;
    case 1:
        for (i = pred_order; i < blocksize; i++)
            decoded[i] = a += decoded[i];
        break;
    case 2:
        for (i = pred_order; i < blocksize; i++)
            decoded[i] = a += b += decoded[i];
        break;
    case 3:
        for (i = pred_order; i < blocksize; i++)
            decoded[i] = a += b += c += decoded[i];
        break;
    case 4:
        for (i = pred_order; i < blocksize; i++)
            decoded[i] = a += b += c += d += decoded[i];
        break;
    default:
        av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
        return -1;
326
    }
Michael Niedermayer's avatar
Michael Niedermayer committed
327

328 329 330 331 332
    return 0;
}

static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order)
{
333
    int i, j;
334
    int coeff_prec, qlevel;
335
    int coeffs[32];
336
    int32_t *decoded = s->decoded[channel];
337

338
    /* warm up samples */
339
    for (i = 0; i < pred_order; i++) {
340
        decoded[i] = get_sbits_long(&s->gb, s->curr_bps);
341
    }
342

343
    coeff_prec = get_bits(&s->gb, 4) + 1;
344
    if (coeff_prec == 16) {
345
        av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
346 347
        return -1;
    }
Michael Niedermayer's avatar
Michael Niedermayer committed
348
    qlevel = get_sbits(&s->gb, 5);
349
    if (qlevel < 0) {
350 351
        av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
               qlevel);
352 353 354
        return -1;
    }

355
    for (i = 0; i < pred_order; i++) {
Michael Niedermayer's avatar
Michael Niedermayer committed
356
        coeffs[i] = get_sbits(&s->gb, coeff_prec);
357
    }
358

359 360 361
    if (decode_residuals(s, channel, pred_order) < 0)
        return -1;

362 363
    if (s->bps > 16) {
        int64_t sum;
364
        for (i = pred_order; i < s->blocksize; i++) {
365 366
            sum = 0;
            for (j = 0; j < pred_order; j++)
367 368
                sum += (int64_t)coeffs[j] * decoded[i-j-1];
            decoded[i] += sum >> qlevel;
369 370
        }
    } else {
371
        for (i = pred_order; i < s->blocksize-1; i += 2) {
372 373 374
            int c;
            int d = decoded[i-pred_order];
            int s0 = 0, s1 = 0;
375
            for (j = pred_order-1; j > 0; j--) {
376
                c = coeffs[j];
377
                s0 += c*d;
378 379
                d = decoded[i-j];
                s1 += c*d;
380
            }
381 382 383 384 385
            c = coeffs[0];
            s0 += c*d;
            d = decoded[i] += s0 >> qlevel;
            s1 += c*d;
            decoded[i+1] += s1 >> qlevel;
386
        }
387
        if (i < s->blocksize) {
388
            int sum = 0;
389
            for (j = 0; j < pred_order; j++)
390 391
                sum += coeffs[j] * decoded[i-j-1];
            decoded[i] += sum >> qlevel;
392
        }
393
    }
394

395 396 397 398 399 400 401
    return 0;
}

static inline int decode_subframe(FLACContext *s, int channel)
{
    int type, wasted = 0;
    int i, tmp;
402

403
    s->curr_bps = s->bps;
404
    if (channel == 0) {
405
        if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
Michael Niedermayer's avatar
Michael Niedermayer committed
406
            s->curr_bps++;
407
    } else {
408
        if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
Michael Niedermayer's avatar
Michael Niedermayer committed
409 410 411
            s->curr_bps++;
    }

412
    if (get_bits1(&s->gb)) {
413
        av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
414 415 416
        return -1;
    }
    type = get_bits(&s->gb, 6);
417

418
    if (get_bits1(&s->gb)) {
419 420 421 422 423
        wasted = 1;
        while (!get_bits1(&s->gb))
            wasted++;
        s->curr_bps -= wasted;
    }
424
    if (s->curr_bps > 32) {
425
        av_log_missing_feature(s->avctx, "decorrelated bit depth > 32", 0);
426 427
        return -1;
    }
428

Michael Niedermayer's avatar
Michael Niedermayer committed
429
//FIXME use av_log2 for types
430
    if (type == 0) {
431
        tmp = get_sbits_long(&s->gb, s->curr_bps);
432 433
        for (i = 0; i < s->blocksize; i++)
            s->decoded[channel][i] = tmp;
434
    } else if (type == 1) {
435
        for (i = 0; i < s->blocksize; i++)
436
            s->decoded[channel][i] = get_sbits_long(&s->gb, s->curr_bps);
437
    } else if ((type >= 8) && (type <= 12)) {
438 439
        if (decode_subframe_fixed(s, channel, type & ~0x8) < 0)
            return -1;
440
    } else if (type >= 32) {
441 442
        if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0)
            return -1;
443
    } else {
444
        av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
445 446
        return -1;
    }
447

448
    if (wasted) {
449 450 451 452 453 454 455 456
        int i;
        for (i = 0; i < s->blocksize; i++)
            s->decoded[channel][i] <<= wasted;
    }

    return 0;
}

457 458 459 460 461 462
static int decode_frame(FLACContext *s)
{
    int i;
    GetBitContext *gb = &s->gb;
    FLACFrameInfo fi;

463
    if (ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) {
464
        av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
465 466
        return -1;
    }
467

468
    if (s->channels && fi.channels != s->channels) {
469 470 471 472
        av_log(s->avctx, AV_LOG_ERROR, "switching channel layout mid-stream "
                                       "is not supported\n");
        return -1;
    }
473
    s->channels = s->avctx->channels = fi.channels;
474
    s->ch_mode = fi.ch_mode;
475

476 477 478 479 480 481 482
    if (!s->bps && !fi.bps) {
        av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
        return -1;
    }
    if (!fi.bps) {
        fi.bps = s->bps;
    } else if (s->bps && fi.bps != s->bps) {
483 484 485 486
        av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
                                       "supported\n");
        return -1;
    }
487 488
    s->bps = s->avctx->bits_per_raw_sample = fi.bps;

489
    if (s->bps > 16) {
490
        s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
491 492 493
        s->sample_shift = 32 - s->bps;
        s->is32 = 1;
    } else {
494
        s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
495 496 497 498
        s->sample_shift = 16 - s->bps;
        s->is32 = 0;
    }

499 500
    if (!s->max_blocksize)
        s->max_blocksize = FLAC_MAX_BLOCKSIZE;
501 502
    if (fi.blocksize > s->max_blocksize) {
        av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
503 504 505
               s->max_blocksize);
        return -1;
    }
506
    s->blocksize = fi.blocksize;
507

508 509 510 511 512
    if (!s->samplerate && !fi.samplerate) {
        av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
                                        " or frame header\n");
        return -1;
    }
513 514
    if (fi.samplerate == 0) {
        fi.samplerate = s->samplerate;
515
    } else if (s->samplerate && fi.samplerate != s->samplerate) {
516
        av_log(s->avctx, AV_LOG_WARNING, "sample rate changed from %d to %d\n",
517
               s->samplerate, fi.samplerate);
518
    }
519
    s->samplerate = s->avctx->sample_rate = fi.samplerate;
520

521 522 523 524 525 526
    if (!s->got_streaminfo) {
        allocate_buffers(s);
        s->got_streaminfo = 1;
        dump_headers(s->avctx, (FLACStreaminfo *)s);
    }

527
//    dump_headers(s->avctx, (FLACStreaminfo *)s);
528 529

    /* subframes */
530
    for (i = 0; i < s->channels; i++) {
531 532 533
        if (decode_subframe(s, i) < 0)
            return -1;
    }
534

535
    align_get_bits(gb);
536 537

    /* frame footer */
538
    skip_bits(gb, 16); /* data crc */
539 540 541 542 543 544

    return 0;
}

static int flac_decode_frame(AVCodecContext *avctx,
                            void *data, int *data_size,
545
                            AVPacket *avpkt)
546
{
547 548
    const uint8_t *buf = avpkt->data;
    int buf_size = avpkt->size;
549
    FLACContext *s = avctx->priv_data;
550
    int i, j = 0, bytes_read = 0;
551 552
    int16_t *samples_16 = data;
    int32_t *samples_32 = data;
553
    int alloc_data_size= *data_size;
554
    int output_size;
555 556

    *data_size=0;
557

558
    if (s->max_framesize == 0) {
559 560 561
        s->max_framesize =
            ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
                                       FLAC_MAX_CHANNELS, 32);
Michael Niedermayer's avatar
Michael Niedermayer committed
562
    }
563

564
    /* check that there is at least the smallest decodable amount of data.
565 566
       this amount corresponds to the smallest valid FLAC frame possible.
       FF F8 69 02 00 00 9A 00 00 34 46 */
567
    if (buf_size < FLAC_MIN_FRAME_SIZE)
568
        return buf_size;
569

570
    /* check for inline header */
571 572
    if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
        if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) {
573 574 575
            av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
            return -1;
        }
576
        return get_metadata_size(buf, buf_size);
Justin Ruggles's avatar
Justin Ruggles committed
577
    }
578 579 580

    /* decode frame */
    init_get_bits(&s->gb, buf, buf_size*8);
581
    if (decode_frame(s) < 0) {
Justin Ruggles's avatar
Justin Ruggles committed
582 583 584
        av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
        return -1;
    }
585
    bytes_read = (get_bits_count(&s->gb)+7)/8;
Michael Niedermayer's avatar
Michael Niedermayer committed
586

587 588 589 590 591
    /* check if allocated data size is large enough for output */
    output_size = s->blocksize * s->channels * (s->is32 ? 4 : 2);
    if (output_size > alloc_data_size) {
        av_log(s->avctx, AV_LOG_ERROR, "output data size is larger than "
                                       "allocated data size\n");
592
        return -1;
593 594 595
    }
    *data_size = output_size;

596 597
#define DECORRELATE(left, right)\
            assert(s->channels == 2);\
598
            for (i = 0; i < s->blocksize; i++) {\
599 600
                int a= s->decoded[0][i];\
                int b= s->decoded[1][i];\
601 602 603 604 605 606 607
                if (s->is32) {\
                    *samples_32++ = (left)  << s->sample_shift;\
                    *samples_32++ = (right) << s->sample_shift;\
                } else {\
                    *samples_16++ = (left)  << s->sample_shift;\
                    *samples_16++ = (right) << s->sample_shift;\
                }\
608 609 610
            }\
            break;

611
    switch (s->ch_mode) {
612
    case FLAC_CHMODE_INDEPENDENT:
613
        for (j = 0; j < s->blocksize; j++) {
614 615 616 617 618 619
            for (i = 0; i < s->channels; i++) {
                if (s->is32)
                    *samples_32++ = s->decoded[i][j] << s->sample_shift;
                else
                    *samples_16++ = s->decoded[i][j] << s->sample_shift;
            }
620 621
        }
        break;
622
    case FLAC_CHMODE_LEFT_SIDE:
623
        DECORRELATE(a,a-b)
624
    case FLAC_CHMODE_RIGHT_SIDE:
625
        DECORRELATE(a+b,b)
626
    case FLAC_CHMODE_MID_SIDE:
627
        DECORRELATE( (a-=b>>1) + b, a)
628 629
    }

630 631
    if (bytes_read > buf_size) {
        av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
Michael Niedermayer's avatar
Michael Niedermayer committed
632 633
        return -1;
    }
634 635 636 637
    if (bytes_read < buf_size) {
        av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
               buf_size - bytes_read, buf_size);
    }
638

639
    return bytes_read;
640 641
}

642
static av_cold int flac_decode_close(AVCodecContext *avctx)
643 644 645
{
    FLACContext *s = avctx->priv_data;
    int i;
646

647
    for (i = 0; i < s->channels; i++) {
Michael Niedermayer's avatar
Michael Niedermayer committed
648
        av_freep(&s->decoded[i]);
649
    }
650

651 652 653
    return 0;
}

654
AVCodec ff_flac_decoder = {
655 656 657 658 659 660 661
    .name           = "flac",
    .type           = AVMEDIA_TYPE_AUDIO,
    .id             = CODEC_ID_FLAC,
    .priv_data_size = sizeof(FLACContext),
    .init           = flac_decode_init,
    .close          = flac_decode_close,
    .decode         = flac_decode_frame,
662
    .long_name= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
663
};