Statistics
| Branch: | Revision:

ffmpeg / libavcodec / flacdec.c @ 2912e87a

History | View | Annotate | Download (20 KB)

1
/*
2
 * FLAC (Free Lossless Audio Codec) decoder
3
 * Copyright (c) 2003 Alex Beregszaszi
4
 *
5
 * This file is part of Libav.
6
 *
7
 * Libav 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
 * Libav 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 Libav; 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
 * 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 "get_bits.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
} FLACContext;
65

    
66
static void allocate_buffers(FLACContext *s);
67

    
68
int ff_flac_is_extradata_valid(AVCodecContext *avctx,
69
                               enum FLACExtradataFormat *format,
70
                               uint8_t **streaminfo_start)
71
{
72
    if (!avctx->extradata || avctx->extradata_size < FLAC_STREAMINFO_SIZE) {
73
        av_log(avctx, AV_LOG_ERROR, "extradata NULL or too small.\n");
74
        return 0;
75
    }
76
    if (AV_RL32(avctx->extradata) != MKTAG('f','L','a','C')) {
77
        /* extradata contains STREAMINFO only */
78
        if (avctx->extradata_size != FLAC_STREAMINFO_SIZE) {
79
            av_log(avctx, AV_LOG_WARNING, "extradata contains %d bytes too many.\n",
80
                   FLAC_STREAMINFO_SIZE-avctx->extradata_size);
81
        }
82
        *format = FLAC_EXTRADATA_FORMAT_STREAMINFO;
83
        *streaminfo_start = avctx->extradata;
84
    } else {
85
        if (avctx->extradata_size < 8+FLAC_STREAMINFO_SIZE) {
86
            av_log(avctx, AV_LOG_ERROR, "extradata too small.\n");
87
            return 0;
88
        }
89
        *format = FLAC_EXTRADATA_FORMAT_FULL_HEADER;
90
        *streaminfo_start = &avctx->extradata[8];
91
    }
92
    return 1;
93
}
94

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

    
102
    avctx->sample_fmt = AV_SAMPLE_FMT_S16;
103

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

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

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

    
121
    return 0;
122
}
123

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

    
133
static void allocate_buffers(FLACContext *s)
134
{
135
    int i;
136

    
137
    assert(s->max_blocksize);
138

    
139
    for (i = 0; i < s->channels; i++) {
140
        s->decoded[i] = av_realloc(s->decoded[i],
141
                                   sizeof(int32_t)*s->max_blocksize);
142
    }
143
}
144

    
145
void ff_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s,
146
                              const uint8_t *buffer)
147
{
148
    GetBitContext gb;
149
    init_get_bits(&gb, buffer, FLAC_STREAMINFO_SIZE*8);
150

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

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

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

    
166
    avctx->channels = s->channels;
167
    avctx->sample_rate = s->samplerate;
168
    avctx->bits_per_raw_sample = s->bps;
169

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

    
173
    skip_bits_long(&gb, 64); /* md5 sum */
174
    skip_bits_long(&gb, 64); /* md5 sum */
175

    
176
    dump_headers(avctx, s);
177
}
178

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

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

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

    
215
    return 0;
216
}
217

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

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

    
240
    return buf_size - (buf_end - buf);
241
}
242

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

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

    
255
    rice_order = get_bits(&s->gb, 4);
256

    
257
    samples= s->blocksize >> rice_order;
258
    if (pred_order > samples) {
259
        av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
260
               pred_order, samples);
261
        return -1;
262
    }
263

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

    
280
    return 0;
281
}
282

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

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

    
294
    if (decode_residuals(s, channel, pred_order) < 0)
295
        return -1;
296

    
297
    if (pred_order > 0)
298
        a = decoded[pred_order-1];
299
    if (pred_order > 1)
300
        b = a - decoded[pred_order-2];
301
    if (pred_order > 2)
302
        c = b - decoded[pred_order-2] + decoded[pred_order-3];
303
    if (pred_order > 3)
304
        d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
305

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

    
330
    return 0;
331
}
332

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

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

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

    
357
    for (i = 0; i < pred_order; i++) {
358
        coeffs[i] = get_sbits(&s->gb, coeff_prec);
359
    }
360

    
361
    if (decode_residuals(s, channel, pred_order) < 0)
362
        return -1;
363

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

    
397
    return 0;
398
}
399

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

    
405
    s->curr_bps = s->bps;
406
    if (channel == 0) {
407
        if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
408
            s->curr_bps++;
409
    } else {
410
        if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
411
            s->curr_bps++;
412
    }
413

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

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

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

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

    
456
    return 0;
457
}
458

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

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

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

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

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

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

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

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

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

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

    
537
    align_get_bits(gb);
538

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

    
542
    return 0;
543
}
544

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

    
558
    *data_size=0;
559

    
560
    if (s->max_framesize == 0) {
561
        s->max_framesize =
562
            ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
563
                                       FLAC_MAX_CHANNELS, 32);
564
    }
565

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

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

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

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

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

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

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

    
641
    return bytes_read;
642
}
643

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

    
649
    for (i = 0; i < s->channels; i++) {
650
        av_freep(&s->decoded[i]);
651
    }
652

    
653
    return 0;
654
}
655

    
656
AVCodec ff_flac_decoder = {
657
    "flac",
658
    AVMEDIA_TYPE_AUDIO,
659
    CODEC_ID_FLAC,
660
    sizeof(FLACContext),
661
    flac_decode_init,
662
    NULL,
663
    flac_decode_close,
664
    flac_decode_frame,
665
    .long_name= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
666
};