flacdec.c 18.8 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/avassert.h"
37
#include "libavutil/crc.h"
38
#include "avcodec.h"
39
#include "internal.h"
40
#include "get_bits.h"
41
#include "bytestream.h"
42
#include "golomb.h"
43
#include "flac.h"
44
#include "flacdata.h"
45
#include "flacdsp.h"
46
#include "thread.h"
47 48
#include "unary.h"

49 50

typedef struct FLACContext {
51 52
    FLACSTREAMINFO

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

56
    int blocksize;                          ///< number of samples in the current frame
57
    int sample_shift;                       ///< shift required to make output samples 16-bit or 32-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
    uint8_t *decoded_buffer;
    unsigned int decoded_buffer_size;
64 65

    FLACDSPContext dsp;
66 67
} FLACContext;

68
static int allocate_buffers(FLACContext *s);
69

70 71
static void flac_set_bps(FLACContext *s)
{
72 73 74 75 76 77 78 79 80 81
    enum AVSampleFormat req = s->avctx->request_sample_fmt;
    int need32 = s->bps > 16;
    int want32 = av_get_bytes_per_sample(req) > 2;
    int planar = av_sample_fmt_is_planar(req);

    if (need32 || want32) {
        if (planar)
            s->avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
        else
            s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
82 83
        s->sample_shift = 32 - s->bps;
    } else {
84 85 86 87
        if (planar)
            s->avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
        else
            s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
88 89 90 91
        s->sample_shift = 16 - s->bps;
    }
}

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

100 101 102 103 104
    /* 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;

105
    if (!ff_flac_is_extradata_valid(avctx, &format, &streaminfo))
106
        return AVERROR_INVALIDDATA;
107

108
    /* initialize based on the demuxer-supplied streamdata header */
109
    ff_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
110 111 112
    ret = allocate_buffers(s);
    if (ret < 0)
        return ret;
113
    flac_set_bps(s);
114
    ff_flacdsp_init(&s->dsp, avctx->sample_fmt, s->channels, s->bps);
115
    s->got_streaminfo = 1;
116

117 118 119
    return 0;
}

120
static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
121
{
122
    av_log(avctx, AV_LOG_DEBUG, "  Max Blocksize: %d\n", s->max_blocksize);
123 124 125 126
    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);
127 128
}

129
static int allocate_buffers(FLACContext *s)
130
{
131
    int buf_size;
132
    int ret;
133

134
    av_assert0(s->max_blocksize);
Michael Niedermayer's avatar
Michael Niedermayer committed
135

136 137 138 139 140 141 142 143 144
    buf_size = av_samples_get_buffer_size(NULL, s->channels, s->max_blocksize,
                                          AV_SAMPLE_FMT_S32P, 0);
    if (buf_size < 0)
        return buf_size;

    av_fast_malloc(&s->decoded_buffer, &s->decoded_buffer_size, buf_size);
    if (!s->decoded_buffer)
        return AVERROR(ENOMEM);

145
    ret = av_samples_fill_arrays((uint8_t **)s->decoded, NULL,
146 147
                                  s->decoded_buffer, s->channels,
                                  s->max_blocksize, AV_SAMPLE_FMT_S32P, 0);
148
    return ret < 0 ? ret : 0;
Michael Niedermayer's avatar
Michael Niedermayer committed
149 150
}

151
/**
152 153 154 155
 * 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
156
 * @return non-zero if metadata is invalid
157
 */
158
static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
159
{
160
    int metadata_type, metadata_size, ret;
161

162 163 164 165
    if (buf_size < FLAC_STREAMINFO_SIZE+8) {
        /* need more data */
        return 0;
    }
166
    flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
167 168 169 170
    if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
        metadata_size != FLAC_STREAMINFO_SIZE) {
        return AVERROR_INVALIDDATA;
    }
171
    ff_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]);
172 173 174
    ret = allocate_buffers(s);
    if (ret < 0)
        return ret;
175
    flac_set_bps(s);
176
    ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->channels, s->bps);
177
    s->got_streaminfo = 1;
178

179 180
    return 0;
}
181

182 183 184 185 186 187 188 189 190 191
/**
 * 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;
192

193 194
    buf += 4;
    do {
195 196
        if (buf_end - buf < 4)
            return 0;
197
        flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
198
        buf += 4;
199
        if (buf_end - buf < metadata_size) {
200 201
            /* need more data in order to read the complete header */
            return 0;
202
        }
203
        buf += metadata_size;
204
    } while (!metadata_last);
205

206
    return buf_size - (buf_end - buf);
207 208
}

209
static int decode_residuals(FLACContext *s, int32_t *decoded, int pred_order)
210 211
{
    int i, tmp, partition, method_type, rice_order;
212
    int rice_bits, rice_esc;
213
    int samples;
214 215

    method_type = get_bits(&s->gb, 2);
216
    if (method_type > 1) {
217 218
        av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
               method_type);
219
        return AVERROR_INVALIDDATA;
Michael Niedermayer's avatar
Michael Niedermayer committed
220
    }
221

222 223
    rice_order = get_bits(&s->gb, 4);

Michael Niedermayer's avatar
Michael Niedermayer committed
224
    samples= s->blocksize >> rice_order;
225 226 227 228 229 230
    if (samples << rice_order != s->blocksize) {
        av_log(s->avctx, AV_LOG_ERROR, "invalid rice order: %i blocksize %i\n",
               rice_order, s->blocksize);
        return AVERROR_INVALIDDATA;
    }

231
    if (pred_order > samples) {
232 233
        av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
               pred_order, samples);
234
        return AVERROR_INVALIDDATA;
235
    }
236

237 238 239
    rice_bits = 4 + method_type;
    rice_esc  = (1 << rice_bits) - 1;

240
    decoded += pred_order;
Michael Niedermayer's avatar
Michael Niedermayer committed
241
    i= pred_order;
242
    for (partition = 0; partition < (1 << rice_order); partition++) {
243 244
        tmp = get_bits(&s->gb, rice_bits);
        if (tmp == rice_esc) {
245
            tmp = get_bits(&s->gb, 5);
246 247
            for (; i < samples; i++)
                *decoded++ = get_sbits_long(&s->gb, tmp);
248
        } else {
249 250
            for (; i < samples; i++) {
                *decoded++ = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
Michael Niedermayer's avatar
Michael Niedermayer committed
251
            }
252
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
253
        i= 0;
254 255 256
    }

    return 0;
257
}
258

259 260
static int decode_subframe_fixed(FLACContext *s, int32_t *decoded,
                                 int pred_order, int bps)
261
{
262
    const int blocksize = s->blocksize;
263
    int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i;
264
    int ret;
265

266
    /* warm up samples */
267
    for (i = 0; i < pred_order; i++) {
268
        decoded[i] = get_sbits_long(&s->gb, bps);
269
    }
270

271 272
    if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
        return ret;
273

274
    if (pred_order > 0)
Ramiro Polla's avatar
Ramiro Polla committed
275
        a = decoded[pred_order-1];
276
    if (pred_order > 1)
Ramiro Polla's avatar
Ramiro Polla committed
277
        b = a - decoded[pred_order-2];
278
    if (pred_order > 2)
Ramiro Polla's avatar
Ramiro Polla committed
279
        c = b - decoded[pred_order-2] + decoded[pred_order-3];
280
    if (pred_order > 3)
Ramiro Polla's avatar
Ramiro Polla committed
281
        d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
282

283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303
    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);
304
        return AVERROR_INVALIDDATA;
305
    }
Michael Niedermayer's avatar
Michael Niedermayer committed
306

307 308 309
    return 0;
}

310
static int decode_subframe_lpc(FLACContext *s, int32_t *decoded, int pred_order,
311
                               int bps)
312
{
313
    int i, ret;
314
    int coeff_prec, qlevel;
315
    int coeffs[32];
316

317
    /* warm up samples */
318
    for (i = 0; i < pred_order; i++) {
319
        decoded[i] = get_sbits_long(&s->gb, bps);
320
    }
321

322
    coeff_prec = get_bits(&s->gb, 4) + 1;
323
    if (coeff_prec == 16) {
324
        av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
325
        return AVERROR_INVALIDDATA;
326
    }
Michael Niedermayer's avatar
Michael Niedermayer committed
327
    qlevel = get_sbits(&s->gb, 5);
328
    if (qlevel < 0) {
329 330
        av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
               qlevel);
331
        return AVERROR_INVALIDDATA;
332 333
    }

334
    for (i = 0; i < pred_order; i++) {
335
        coeffs[pred_order - i - 1] = get_sbits(&s->gb, coeff_prec);
336
    }
337

338 339
    if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
        return ret;
340

341
    s->dsp.lpc(decoded, coeffs, pred_order, qlevel, s->blocksize);
342

343 344 345 346 347
    return 0;
}

static inline int decode_subframe(FLACContext *s, int channel)
{
348
    int32_t *decoded = s->decoded[channel];
349
    int type, wasted = 0;
350
    int bps = s->bps;
351
    int i, tmp, ret;
352

353
    if (channel == 0) {
354
        if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
355
            bps++;
356
    } else {
357
        if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
358
            bps++;
Michael Niedermayer's avatar
Michael Niedermayer committed
359 360
    }

361
    if (get_bits1(&s->gb)) {
362
        av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
363
        return AVERROR_INVALIDDATA;
364 365
    }
    type = get_bits(&s->gb, 6);
366

367
    if (get_bits1(&s->gb)) {
368
        int left = get_bits_left(&s->gb);
369
        if ( left <= 0 ||
370 371
            (left < bps && !show_bits_long(&s->gb, left)) ||
                           !show_bits_long(&s->gb, bps)) {
372 373
            av_log(s->avctx, AV_LOG_ERROR,
                   "Invalid number of wasted bits > available bits (%d) - left=%d\n",
374
                   bps, left);
375 376
            return AVERROR_INVALIDDATA;
        }
377
        wasted = 1 + get_unary(&s->gb, 1, get_bits_left(&s->gb));
378
        bps -= wasted;
379
    }
380
    if (bps > 32) {
381
        avpriv_report_missing_feature(s->avctx, "Decorrelated bit depth > 32");
382
        return AVERROR_PATCHWELCOME;
383
    }
384

Michael Niedermayer's avatar
Michael Niedermayer committed
385
//FIXME use av_log2 for types
386
    if (type == 0) {
387
        tmp = get_sbits_long(&s->gb, bps);
388
        for (i = 0; i < s->blocksize; i++)
389
            decoded[i] = tmp;
390
    } else if (type == 1) {
391
        for (i = 0; i < s->blocksize; i++)
392
            decoded[i] = get_sbits_long(&s->gb, bps);
393
    } else if ((type >= 8) && (type <= 12)) {
394 395
        if ((ret = decode_subframe_fixed(s, decoded, type & ~0x8, bps)) < 0)
            return ret;
396
    } else if (type >= 32) {
397 398
        if ((ret = decode_subframe_lpc(s, decoded, (type & ~0x20)+1, bps)) < 0)
            return ret;
399
    } else {
400
        av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
401
        return AVERROR_INVALIDDATA;
402
    }
403

404
    if (wasted) {
405 406
        int i;
        for (i = 0; i < s->blocksize; i++)
407
            decoded[i] <<= wasted;
408 409 410 411 412
    }

    return 0;
}

413 414
static int decode_frame(FLACContext *s)
{
415
    int i, ret;
416 417 418
    GetBitContext *gb = &s->gb;
    FLACFrameInfo fi;

419
    if ((ret = ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) < 0) {
420
        av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
421
        return ret;
422
    }
423

424 425 426 427 428 429
    if (s->channels && fi.channels != s->channels && s->got_streaminfo) {
        s->channels = s->avctx->channels = fi.channels;
        ff_flac_set_channel_layout(s->avctx);
        ret = allocate_buffers(s);
        if (ret < 0)
            return ret;
430
    }
431
    s->channels = s->avctx->channels = fi.channels;
432
    if (!s->avctx->channel_layout)
433
        ff_flac_set_channel_layout(s->avctx);
434
    s->ch_mode = fi.ch_mode;
435

436 437
    if (!s->bps && !fi.bps) {
        av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
438
        return AVERROR_INVALIDDATA;
439 440 441 442
    }
    if (!fi.bps) {
        fi.bps = s->bps;
    } else if (s->bps && fi.bps != s->bps) {
443 444
        av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
                                       "supported\n");
445
        return AVERROR_INVALIDDATA;
446
    }
447

448 449 450 451
    if (!s->bps) {
        s->bps = s->avctx->bits_per_raw_sample = fi.bps;
        flac_set_bps(s);
    }
452

453 454
    if (!s->max_blocksize)
        s->max_blocksize = FLAC_MAX_BLOCKSIZE;
455 456
    if (fi.blocksize > s->max_blocksize) {
        av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
457
               s->max_blocksize);
458
        return AVERROR_INVALIDDATA;
459
    }
460
    s->blocksize = fi.blocksize;
461

462 463 464
    if (!s->samplerate && !fi.samplerate) {
        av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
                                        " or frame header\n");
465
        return AVERROR_INVALIDDATA;
466
    }
467
    if (fi.samplerate == 0)
468 469
        fi.samplerate = s->samplerate;
    s->samplerate = s->avctx->sample_rate = fi.samplerate;
470

471
    if (!s->got_streaminfo) {
472
        ret = allocate_buffers(s);
473 474
        if (ret < 0)
            return ret;
475 476 477
        s->got_streaminfo = 1;
        dump_headers(s->avctx, (FLACStreaminfo *)s);
    }
478
    ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->channels, s->bps);
479

480
//    dump_headers(s->avctx, (FLACStreaminfo *)s);
481 482

    /* subframes */
483
    for (i = 0; i < s->channels; i++) {
484 485
        if ((ret = decode_subframe(s, i)) < 0)
            return ret;
486
    }
487

488
    align_get_bits(gb);
489 490

    /* frame footer */
491
    skip_bits(gb, 16); /* data crc */
492 493 494 495

    return 0;
}

496 497
static int flac_decode_frame(AVCodecContext *avctx, void *data,
                             int *got_frame_ptr, AVPacket *avpkt)
498
{
499
    AVFrame *frame     = data;
500
    ThreadFrame tframe = { .f = data };
501 502
    const uint8_t *buf = avpkt->data;
    int buf_size = avpkt->size;
503
    FLACContext *s = avctx->priv_data;
504
    int bytes_read = 0;
505
    int ret;
506

507
    *got_frame_ptr = 0;
508

509
    if (s->max_framesize == 0) {
510 511 512
        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
513
    }
514

515
    if (buf_size > 5 && !memcmp(buf, "\177FLAC", 5)) {
Michael Niedermayer's avatar
Michael Niedermayer committed
516
        av_log(s->avctx, AV_LOG_DEBUG, "skipping flac header packet 1\n");
517 518 519 520
        return buf_size;
    }

    if (buf_size > 0 && (*buf & 0x7F) == FLAC_METADATA_TYPE_VORBIS_COMMENT) {
Michael Niedermayer's avatar
Michael Niedermayer committed
521
        av_log(s->avctx, AV_LOG_DEBUG, "skipping vorbis comment\n");
522 523 524
        return buf_size;
    }

525
    /* check that there is at least the smallest decodable amount of data.
526 527
       this amount corresponds to the smallest valid FLAC frame possible.
       FF F8 69 02 00 00 9A 00 00 34 46 */
528
    if (buf_size < FLAC_MIN_FRAME_SIZE)
529
        return buf_size;
530

531
    /* check for inline header */
532
    if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
533
        if (!s->got_streaminfo && (ret = parse_streaminfo(s, buf, buf_size))) {
534
            av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
535
            return ret;
536
        }
537
        return get_metadata_size(buf, buf_size);
Justin Ruggles's avatar
Justin Ruggles committed
538
    }
539 540

    /* decode frame */
541 542
    if ((ret = init_get_bits8(&s->gb, buf, buf_size)) < 0)
        return ret;
543
    if ((ret = decode_frame(s)) < 0) {
Justin Ruggles's avatar
Justin Ruggles committed
544
        av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
545
        return ret;
Justin Ruggles's avatar
Justin Ruggles committed
546
    }
547 548
    bytes_read = get_bits_count(&s->gb)/8;

549
    if ((s->avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_COMPLIANT)) &&
550 551 552 553 554 555
        av_crc(av_crc_get_table(AV_CRC_16_ANSI),
               0, buf, bytes_read)) {
        av_log(s->avctx, AV_LOG_ERROR, "CRC error at PTS %"PRId64"\n", avpkt->pts);
        if (s->avctx->err_recognition & AV_EF_EXPLODE)
            return AVERROR_INVALIDDATA;
    }
Michael Niedermayer's avatar
Michael Niedermayer committed
556

557
    /* get output buffer */
558
    frame->nb_samples = s->blocksize;
559
    if ((ret = ff_thread_get_buffer(avctx, &tframe, 0)) < 0)
560
        return ret;
561

562
    s->dsp.decorrelate[s->ch_mode](frame->data, s->decoded, s->channels,
563
                                   s->blocksize, s->sample_shift);
564

565 566
    if (bytes_read > buf_size) {
        av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
567
        return AVERROR_INVALIDDATA;
Michael Niedermayer's avatar
Michael Niedermayer committed
568
    }
569 570 571 572
    if (bytes_read < buf_size) {
        av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
               buf_size - bytes_read, buf_size);
    }
573

574
    *got_frame_ptr = 1;
575

576
    return bytes_read;
577 578
}

579 580 581 582 583
static int init_thread_copy(AVCodecContext *avctx)
{
    FLACContext *s = avctx->priv_data;
    s->decoded_buffer = NULL;
    s->decoded_buffer_size = 0;
584
    s->avctx = avctx;
585 586 587
    if (s->max_blocksize)
        return allocate_buffers(s);
    return 0;
588 589
}

590
static av_cold int flac_decode_close(AVCodecContext *avctx)
591 592
{
    FLACContext *s = avctx->priv_data;
593

594
    av_freep(&s->decoded_buffer);
595

596 597 598
    return 0;
}

599
AVCodec ff_flac_decoder = {
600
    .name           = "flac",
601
    .long_name      = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
602
    .type           = AVMEDIA_TYPE_AUDIO,
603
    .id             = AV_CODEC_ID_FLAC,
604 605 606 607
    .priv_data_size = sizeof(FLACContext),
    .init           = flac_decode_init,
    .close          = flac_decode_close,
    .decode         = flac_decode_frame,
608
    .init_thread_copy = ONLY_IF_THREADS_ENABLED(init_thread_copy),
609
    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
610 611 612 613
    .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
                                                      AV_SAMPLE_FMT_S16P,
                                                      AV_SAMPLE_FMT_S32,
                                                      AV_SAMPLE_FMT_S32P,
614
                                                      AV_SAMPLE_FMT_NONE },
615
};