git.sesse.net Git - ffmpeg/blob - libavcodec/flacdec.c

   1 /*
   2  * FLAC (Free Lossless Audio Codec) decoder
   3  * Copyright (c) 2003 Alex Beregszaszi
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 /**
  23  * @file
  24  * FLAC (Free Lossless Audio Codec) decoder
  25  * @author Alex Beregszaszi
  26  * @see http://flac.sourceforge.net/
  27  *
  28  * This decoder can be used in 1 of 2 ways: Either raw FLAC data can be fed
  29  * through, starting from the initial 'fLaC' signature; or by passing the
  30  * 34-byte streaminfo structure through avctx->extradata[_size] followed
  31  * by data starting with the 0xFFF8 marker.
  32  */
  33
  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 #include "unary.h"
  48
  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 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     uint8_t *decoded_buffer;
  63     unsigned int decoded_buffer_size;
  64
  65     FLACDSPContext dsp;
  66 } FLACContext;
  67
  68 static int allocate_buffers(FLACContext *s);
  69
  70 static void flac_set_bps(FLACContext *s)
  71 {
  72     enum AVSampleFormat req = s->avctx->request_sample_fmt;
  73     int need32 = s->bps > 16;
  74     int want32 = av_get_bytes_per_sample(req) > 2;
  75     int planar = av_sample_fmt_is_planar(req);
  76
  77     if (need32 || want32) {
  78         if (planar)
  79             s->avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
  80         else
  81             s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
  82         s->sample_shift = 32 - s->bps;
  83     } else {
  84         if (planar)
  85             s->avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
  86         else
  87             s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
  88         s->sample_shift = 16 - s->bps;
  89     }
  90 }
  91
  92 static av_cold int flac_decode_init(AVCodecContext *avctx)
  93 {
  94     enum FLACExtradataFormat format;
  95     uint8_t *streaminfo;
  96     int ret;
  97     FLACContext *s = avctx->priv_data;
  98     s->avctx = avctx;
  99
 100     /* for now, the raw FLAC header is allowed to be passed to the decoder as
 101        frame data instead of extradata. */
 102     if (!avctx->extradata)
 103         return 0;
 104
 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     ret = allocate_buffers(s);
 111     if (ret < 0)
 112         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     return 0;
 118 }
 119
 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     av_log(avctx, AV_LOG_DEBUG, "  Max Framesize: %d\n", s->max_framesize);
 124     av_log(avctx, AV_LOG_DEBUG, "  Samplerate: %d\n", s->samplerate);
 125     av_log(avctx, AV_LOG_DEBUG, "  Channels: %d\n", s->channels);
 126     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);
 135
 136     buf_size = av_samples_get_buffer_size(NULL, s->channels, s->max_blocksize,
 137                                           AV_SAMPLE_FMT_S32P, 0);
 138     if (buf_size < 0)
 139         return buf_size;
 140
 141     av_fast_malloc(&s->decoded_buffer, &s->decoded_buffer_size, buf_size);
 142     if (!s->decoded_buffer)
 143         return AVERROR(ENOMEM);
 144
 145     ret = av_samples_fill_arrays((uint8_t **)s->decoded, NULL,
 146                                   s->decoded_buffer, s->channels,
 147                                   s->max_blocksize, AV_SAMPLE_FMT_S32P, 0);
 148     return ret < 0 ? ret : 0;
 149 }
 150
 151 /**
 152  * Parse the STREAMINFO from an inline header.
 153  * @param s the flac decoding context
 154  * @param buf input buffer, starting with the "fLaC" marker
 155  * @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     if (buf_size < FLAC_STREAMINFO_SIZE+8) {
 163         /* need more data */
 164         return 0;
 165     }
 166     flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
 167     if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
 168         metadata_size != FLAC_STREAMINFO_SIZE) {
 169         return AVERROR_INVALIDDATA;
 170     }
 171     ff_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]);
 172     ret = allocate_buffers(s);
 173     if (ret < 0)
 174         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     return 0;
 180 }
 181
 182 /**
 183  * Determine the size of an inline header.
 184  * @param buf input buffer, starting with the "fLaC" marker
 185  * @param buf_size buffer size
 186  * @return number of bytes in the header, or 0 if more data is needed
 187  */
 188 static int get_metadata_size(const uint8_t *buf, int buf_size)
 189 {
 190     int metadata_last, metadata_size;
 191     const uint8_t *buf_end = buf + buf_size;
 192
 193     buf += 4;
 194     do {
 195         if (buf_end - buf < 4)
 196             return 0;
 197         flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
 198         buf += 4;
 199         if (buf_end - buf < metadata_size) {
 200             /* need more data in order to read the complete header */
 201             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         av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
 218                method_type);
 219         return AVERROR_INVALIDDATA;
 220     }
 221
 222     rice_order = get_bits(&s->gb, 4);
 223
 224     samples= s->blocksize >> rice_order;
 225     if (samples << rice_order != s->blocksize) {
 226         av_log(s->avctx, AV_LOG_ERROR, "invalid rice order: %i blocksize %i\n",
 227                rice_order, s->blocksize);
 228         return AVERROR_INVALIDDATA;
 229     }
 230
 231     if (pred_order > samples) {
 232         av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
 233                pred_order, samples);
 234         return AVERROR_INVALIDDATA;
 235     }
 236
 237     rice_bits = 4 + method_type;
 238     rice_esc  = (1 << rice_bits) - 1;
 239
 240     decoded += pred_order;
 241     i= pred_order;
 242     for (partition = 0; partition < (1 << rice_order); partition++) {
 243         tmp = get_bits(&s->gb, rice_bits);
 244         if (tmp == rice_esc) {
 245             tmp = get_bits(&s->gb, 5);
 246             for (; i < samples; i++)
 247                 *decoded++ = get_sbits_long(&s->gb, tmp);
 248         } else {
 249             for (; i < samples; i++) {
 250                 *decoded++ = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
 251             }
 252         }
 253         i= 0;
 254     }
 255
 256     return 0;
 257 }
 258
 259 static int decode_subframe_fixed(FLACContext *s, int32_t *decoded,
 260                                  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     if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
 272         return ret;
 273
 274     if (pred_order > 0)
 275         a = decoded[pred_order-1];
 276     if (pred_order > 1)
 277         b = a - decoded[pred_order-2];
 278     if (pred_order > 2)
 279         c = b - decoded[pred_order-2] + decoded[pred_order-3];
 280     if (pred_order > 3)
 281         d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
 282
 283     switch (pred_order) {
 284     case 0:
 285         break;
 286     case 1:
 287         for (i = pred_order; i < blocksize; i++)
 288             decoded[i] = a += decoded[i];
 289         break;
 290     case 2:
 291         for (i = pred_order; i < blocksize; i++)
 292             decoded[i] = a += b += decoded[i];
 293         break;
 294     case 3:
 295         for (i = pred_order; i < blocksize; i++)
 296             decoded[i] = a += b += c += decoded[i];
 297         break;
 298     case 4:
 299         for (i = pred_order; i < blocksize; i++)
 300             decoded[i] = a += b += c += d += decoded[i];
 301         break;
 302     default:
 303         av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
 304         return AVERROR_INVALIDDATA;
 305     }
 306
 307     return 0;
 308 }
 309
 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     }
 327     qlevel = get_sbits(&s->gb, 5);
 328     if (qlevel < 0) {
 329         av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
 330                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     if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
 339         return ret;
 340
 341     s->dsp.lpc(decoded, coeffs, pred_order, qlevel, s->blocksize);
 342
 343     return 0;
 344 }
 345
 346 static inline int decode_subframe(FLACContext *s, int channel)
 347 {
 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++;
 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             (left < bps && !show_bits_long(&s->gb, left)) ||
 371                            !show_bits_long(&s->gb, bps)) {
 372             av_log(s->avctx, AV_LOG_ERROR,
 373                    "Invalid number of wasted bits > available bits (%d) - left=%d\n",
 374                    bps, left);
 375             return AVERROR_INVALIDDATA;
 376         }
 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
 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         if ((ret = decode_subframe_fixed(s, decoded, type & ~0x8, bps)) < 0)
 395             return ret;
 396     } else if (type >= 32) {
 397         if ((ret = decode_subframe_lpc(s, decoded, (type & ~0x20)+1, bps)) < 0)
 398             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         int i;
 406         for (i = 0; i < s->blocksize; i++)
 407             decoded[i] <<= wasted;
 408     }
 409
 410     return 0;
 411 }
 412
 413 static int decode_frame(FLACContext *s)
 414 {
 415     int i, ret;
 416     GetBitContext *gb = &s->gb;
 417     FLACFrameInfo fi;
 418
 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     if (s->channels && fi.channels != s->channels && s->got_streaminfo) {
 425         s->channels = s->avctx->channels = fi.channels;
 426         ff_flac_set_channel_layout(s->avctx);
 427         ret = allocate_buffers(s);
 428         if (ret < 0)
 429             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     if (!s->bps && !fi.bps) {
 437         av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
 438         return AVERROR_INVALIDDATA;
 439     }
 440     if (!fi.bps) {
 441         fi.bps = s->bps;
 442     } else if (s->bps && fi.bps != s->bps) {
 443         av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
 444                                        "supported\n");
 445         return AVERROR_INVALIDDATA;
 446     }
 447
 448     if (!s->bps) {
 449         s->bps = s->avctx->bits_per_raw_sample = fi.bps;
 450         flac_set_bps(s);
 451     }
 452
 453     if (!s->max_blocksize)
 454         s->max_blocksize = FLAC_MAX_BLOCKSIZE;
 455     if (fi.blocksize > s->max_blocksize) {
 456         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     if (!s->samplerate && !fi.samplerate) {
 463         av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
 464                                         " or frame header\n");
 465         return AVERROR_INVALIDDATA;
 466     }
 467     if (fi.samplerate == 0)
 468         fi.samplerate = s->samplerate;
 469     s->samplerate = s->avctx->sample_rate = fi.samplerate;
 470
 471     if (!s->got_streaminfo) {
 472         ret = allocate_buffers(s);
 473         if (ret < 0)
 474             return ret;
 475         s->got_streaminfo = 1;
 476         dump_headers(s->avctx, (FLACStreaminfo *)s);
 477     }
 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         if ((ret = decode_subframe(s, i)) < 0)
 485             return ret;
 486     }
 487
 488     align_get_bits(gb);
 489
 490     /* frame footer */
 491     skip_bits(gb, 16); /* data crc */
 492
 493     return 0;
 494 }
 495
 496 static int flac_decode_frame(AVCodecContext *avctx, void *data,
 497                              int *got_frame_ptr, AVPacket *avpkt)
 498 {
 499     AVFrame *frame     = data;
 500     ThreadFrame tframe = { .f = data };
 501     const uint8_t *buf = avpkt->data;
 502     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         s->max_framesize =
 511             ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
 512                                        FLAC_MAX_CHANNELS, 32);
 513     }
 514
 515     if (buf_size > 5 && !memcmp(buf, "\177FLAC", 5)) {
 516         av_log(s->avctx, AV_LOG_DEBUG, "skipping flac header packet 1\n");
 517         return buf_size;
 518     }
 519
 520     if (buf_size > 0 && (*buf & 0x7F) == FLAC_METADATA_TYPE_VORBIS_COMMENT) {
 521         av_log(s->avctx, AV_LOG_DEBUG, "skipping vorbis comment\n");
 522         return buf_size;
 523     }
 524
 525     /* check that there is at least the smallest decodable amount of data.
 526        this amount corresponds to the smallest valid FLAC frame possible.
 527        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);
 538     }
 539
 540     /* decode frame */
 541     if ((ret = init_get_bits8(&s->gb, buf, buf_size)) < 0)
 542         return ret;
 543     if ((ret = decode_frame(s)) < 0) {
 544         av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
 545         return ret;
 546     }
 547     bytes_read = get_bits_count(&s->gb)/8;
 548
 549     if ((s->avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_COMPLIANT)) &&
 550         av_crc(av_crc_get_table(AV_CRC_16_ANSI),
 551                0, buf, bytes_read)) {
 552         av_log(s->avctx, AV_LOG_ERROR, "CRC error at PTS %"PRId64"\n", avpkt->pts);
 553         if (s->avctx->err_recognition & AV_EF_EXPLODE)
 554             return AVERROR_INVALIDDATA;
 555     }
 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     if (bytes_read > buf_size) {
 566         av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
 567         return AVERROR_INVALIDDATA;
 568     }
 569     if (bytes_read < buf_size) {
 570         av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
 571                buf_size - bytes_read, buf_size);
 572     }
 573
 574     *got_frame_ptr = 1;
 575
 576     return bytes_read;
 577 }
 578
 579 static int init_thread_copy(AVCodecContext *avctx)
 580 {
 581     FLACContext *s = avctx->priv_data;
 582     s->decoded_buffer = NULL;
 583     s->decoded_buffer_size = 0;
 584     s->avctx = avctx;
 585     if (s->max_blocksize)
 586         return allocate_buffers(s);
 587     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     return 0;
 597 }
 598
 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     .priv_data_size = sizeof(FLACContext),
 605     .init           = flac_decode_init,
 606     .close          = flac_decode_close,
 607     .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     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
 611                                                       AV_SAMPLE_FMT_S16P,
 612                                                       AV_SAMPLE_FMT_S32,
 613                                                       AV_SAMPLE_FMT_S32P,
 614                                                       AV_SAMPLE_FMT_NONE },
 615 };