flacdec.c 18.5 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/channel_layout.h"
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
#include "flacdsp.h"
47
#include "thread.h"
48 49
#include "unary.h"

50 51

typedef struct FLACContext {
52 53
    FLACSTREAMINFO

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

57
    int blocksize;                          ///< number of samples in the current frame
58
    int sample_shift;                       ///< shift required to make output samples 16-bit or 32-bit
59
    int ch_mode;                            ///< channel decorrelation type in the current frame
60
    int got_streaminfo;                     ///< indicates if the STREAMINFO has been read
61

62
    int32_t *decoded[FLAC_MAX_CHANNELS];    ///< decoded samples
63 64
    uint8_t *decoded_buffer;
    unsigned int decoded_buffer_size;
65 66

    FLACDSPContext dsp;
67 68
} FLACContext;

69
static int allocate_buffers(FLACContext *s);
70

71 72
static void flac_set_bps(FLACContext *s)
{
73 74 75 76 77 78 79 80 81 82
    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;
83 84
        s->sample_shift = 32 - s->bps;
    } else {
85 86 87 88
        if (planar)
            s->avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
        else
            s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
89 90 91 92
        s->sample_shift = 16 - s->bps;
    }
}

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

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

106
    if (!avpriv_flac_is_extradata_valid(avctx, &format, &streaminfo))
107
        return AVERROR_INVALIDDATA;
108

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

118 119 120
    return 0;
}

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

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

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

136 137 138 139 140 141 142 143 144 145 146 147
    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);

    return av_samples_fill_arrays((uint8_t **)s->decoded, NULL,
                                  s->decoded_buffer, s->channels,
                                  s->max_blocksize, AV_SAMPLE_FMT_S32P, 0);
Michael Niedermayer's avatar
Michael Niedermayer committed
148 149
}

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

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

178 179
    return 0;
}
180

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

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

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

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

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

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

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

230 231 232
    rice_bits = 4 + method_type;
    rice_esc  = (1 << rice_bits) - 1;

233
    decoded += pred_order;
Michael Niedermayer's avatar
Michael Niedermayer committed
234
    i= pred_order;
235
    for (partition = 0; partition < (1 << rice_order); partition++) {
236 237
        tmp = get_bits(&s->gb, rice_bits);
        if (tmp == rice_esc) {
238
            tmp = get_bits(&s->gb, 5);
239 240
            for (; i < samples; i++)
                *decoded++ = get_sbits_long(&s->gb, tmp);
241
        } else {
242 243
            for (; i < samples; i++) {
                *decoded++ = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
Michael Niedermayer's avatar
Michael Niedermayer committed
244
            }
245
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
246
        i= 0;
247 248 249
    }

    return 0;
250
}
251

252 253
static int decode_subframe_fixed(FLACContext *s, int32_t *decoded,
                                 int pred_order, int bps)
254
{
255
    const int blocksize = s->blocksize;
256
    int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i;
257
    int ret;
258

259
    /* warm up samples */
260
    for (i = 0; i < pred_order; i++) {
261
        decoded[i] = get_sbits_long(&s->gb, bps);
262
    }
263

264 265
    if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
        return ret;
266

267
    if (pred_order > 0)
Ramiro Polla's avatar
Ramiro Polla committed
268
        a = decoded[pred_order-1];
269
    if (pred_order > 1)
Ramiro Polla's avatar
Ramiro Polla committed
270
        b = a - decoded[pred_order-2];
271
    if (pred_order > 2)
Ramiro Polla's avatar
Ramiro Polla committed
272
        c = b - decoded[pred_order-2] + decoded[pred_order-3];
273
    if (pred_order > 3)
Ramiro Polla's avatar
Ramiro Polla committed
274
        d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
275

276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296
    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);
297
        return AVERROR_INVALIDDATA;
298
    }
Michael Niedermayer's avatar
Michael Niedermayer committed
299

300 301 302
    return 0;
}

303
static int decode_subframe_lpc(FLACContext *s, int32_t *decoded, int pred_order,
304
                               int bps)
305
{
306
    int i, ret;
307
    int coeff_prec, qlevel;
308
    int coeffs[32];
309

310
    /* warm up samples */
311
    for (i = 0; i < pred_order; i++) {
312
        decoded[i] = get_sbits_long(&s->gb, bps);
313
    }
314

315
    coeff_prec = get_bits(&s->gb, 4) + 1;
316
    if (coeff_prec == 16) {
317
        av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
318
        return AVERROR_INVALIDDATA;
319
    }
Michael Niedermayer's avatar
Michael Niedermayer committed
320
    qlevel = get_sbits(&s->gb, 5);
321
    if (qlevel < 0) {
322 323
        av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
               qlevel);
324
        return AVERROR_INVALIDDATA;
325 326
    }

327
    for (i = 0; i < pred_order; i++) {
328
        coeffs[pred_order - i - 1] = get_sbits(&s->gb, coeff_prec);
329
    }
330

331 332
    if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
        return ret;
333

334
    s->dsp.lpc(decoded, coeffs, pred_order, qlevel, s->blocksize);
335

336 337 338 339 340
    return 0;
}

static inline int decode_subframe(FLACContext *s, int channel)
{
341
    int32_t *decoded = s->decoded[channel];
342
    int type, wasted = 0;
343
    int bps = s->bps;
344
    int i, tmp, ret;
345

346
    if (channel == 0) {
347
        if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
348
            bps++;
349
    } else {
350
        if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
351
            bps++;
Michael Niedermayer's avatar
Michael Niedermayer committed
352 353
    }

354
    if (get_bits1(&s->gb)) {
355
        av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
356
        return AVERROR_INVALIDDATA;
357 358
    }
    type = get_bits(&s->gb, 6);
359

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

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

397
    if (wasted) {
398 399
        int i;
        for (i = 0; i < s->blocksize; i++)
400
            decoded[i] <<= wasted;
401 402 403 404 405
    }

    return 0;
}

406 407
static int decode_frame(FLACContext *s)
{
408
    int i, ret;
409 410 411
    GetBitContext *gb = &s->gb;
    FLACFrameInfo fi;

412
    if ((ret = ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) < 0) {
413
        av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
414
        return ret;
415
    }
416

417 418 419 420 421 422
    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;
423
    }
424
    s->channels = s->avctx->channels = fi.channels;
425
    if (!s->avctx->channel_layout)
426
        ff_flac_set_channel_layout(s->avctx);
427
    s->ch_mode = fi.ch_mode;
428

429 430
    if (!s->bps && !fi.bps) {
        av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
431
        return AVERROR_INVALIDDATA;
432 433 434 435
    }
    if (!fi.bps) {
        fi.bps = s->bps;
    } else if (s->bps && fi.bps != s->bps) {
436 437
        av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
                                       "supported\n");
438
        return AVERROR_INVALIDDATA;
439
    }
440

441 442 443 444
    if (!s->bps) {
        s->bps = s->avctx->bits_per_raw_sample = fi.bps;
        flac_set_bps(s);
    }
445

446 447
    if (!s->max_blocksize)
        s->max_blocksize = FLAC_MAX_BLOCKSIZE;
448 449
    if (fi.blocksize > s->max_blocksize) {
        av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
450
               s->max_blocksize);
451
        return AVERROR_INVALIDDATA;
452
    }
453
    s->blocksize = fi.blocksize;
454

455 456 457
    if (!s->samplerate && !fi.samplerate) {
        av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
                                        " or frame header\n");
458
        return AVERROR_INVALIDDATA;
459
    }
460
    if (fi.samplerate == 0)
461 462
        fi.samplerate = s->samplerate;
    s->samplerate = s->avctx->sample_rate = fi.samplerate;
463

464
    if (!s->got_streaminfo) {
465
        ret = allocate_buffers(s);
466 467
        if (ret < 0)
            return ret;
468
        ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
469 470 471 472
        s->got_streaminfo = 1;
        dump_headers(s->avctx, (FLACStreaminfo *)s);
    }

473
//    dump_headers(s->avctx, (FLACStreaminfo *)s);
474 475

    /* subframes */
476
    for (i = 0; i < s->channels; i++) {
477 478
        if ((ret = decode_subframe(s, i)) < 0)
            return ret;
479
    }
480

481
    align_get_bits(gb);
482 483

    /* frame footer */
484
    skip_bits(gb, 16); /* data crc */
485 486 487 488

    return 0;
}

489 490
static int flac_decode_frame(AVCodecContext *avctx, void *data,
                             int *got_frame_ptr, AVPacket *avpkt)
491
{
492
    AVFrame *frame     = data;
493
    ThreadFrame tframe = { .f = data };
494 495
    const uint8_t *buf = avpkt->data;
    int buf_size = avpkt->size;
496
    FLACContext *s = avctx->priv_data;
497
    int bytes_read = 0;
498
    int ret;
499

500
    *got_frame_ptr = 0;
501

502
    if (s->max_framesize == 0) {
503 504 505
        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
506
    }
507

508 509 510 511 512 513 514 515 516 517
    if (buf_size > 5 && !memcmp(buf, "\177FLAC", 5)) {
        av_log(s->avctx, AV_LOG_DEBUG, "skiping flac header packet 1\n");
        return buf_size;
    }

    if (buf_size > 0 && (*buf & 0x7F) == FLAC_METADATA_TYPE_VORBIS_COMMENT) {
        av_log(s->avctx, AV_LOG_DEBUG, "skiping vorbis comment\n");
        return buf_size;
    }

518
    /* check that there is at least the smallest decodable amount of data.
519 520
       this amount corresponds to the smallest valid FLAC frame possible.
       FF F8 69 02 00 00 9A 00 00 34 46 */
521
    if (buf_size < FLAC_MIN_FRAME_SIZE)
522
        return buf_size;
523

524
    /* check for inline header */
525
    if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
526
        if (!s->got_streaminfo && (ret = parse_streaminfo(s, buf, buf_size))) {
527
            av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
528
            return ret;
529
        }
530
        return get_metadata_size(buf, buf_size);
Justin Ruggles's avatar
Justin Ruggles committed
531
    }
532 533

    /* decode frame */
534 535
    if ((ret = init_get_bits8(&s->gb, buf, buf_size)) < 0)
        return ret;
536
    if ((ret = decode_frame(s)) < 0) {
Justin Ruggles's avatar
Justin Ruggles committed
537
        av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
538
        return ret;
Justin Ruggles's avatar
Justin Ruggles committed
539
    }
540 541
    bytes_read = get_bits_count(&s->gb)/8;

542
    if ((s->avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_COMPLIANT)) &&
543 544 545 546 547 548
        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
549

550
    /* get output buffer */
551
    frame->nb_samples = s->blocksize;
552
    if ((ret = ff_thread_get_buffer(avctx, &tframe, 0)) < 0)
553
        return ret;
554

555
    s->dsp.decorrelate[s->ch_mode](frame->data, s->decoded, s->channels,
556
                                   s->blocksize, s->sample_shift);
557

558 559
    if (bytes_read > buf_size) {
        av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
560
        return AVERROR_INVALIDDATA;
Michael Niedermayer's avatar
Michael Niedermayer committed
561
    }
562 563 564 565
    if (bytes_read < buf_size) {
        av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
               buf_size - bytes_read, buf_size);
    }
566

567
    *got_frame_ptr = 1;
568

569
    return bytes_read;
570 571
}

572 573 574 575 576
static int init_thread_copy(AVCodecContext *avctx)
{
    FLACContext *s = avctx->priv_data;
    s->decoded_buffer = NULL;
    s->decoded_buffer_size = 0;
577
    s->avctx = avctx;
578 579 580
    if (s->max_blocksize)
        return allocate_buffers(s);
    return 0;
581 582
}

583
static av_cold int flac_decode_close(AVCodecContext *avctx)
584 585
{
    FLACContext *s = avctx->priv_data;
586

587
    av_freep(&s->decoded_buffer);
588

589 590 591
    return 0;
}

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