src/third_party/ffmpeg/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/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 #include "unary.h"
  49
  50
  51 typedef struct FLACContext {
  52     FLACSTREAMINFO
  53
  54     AVCodecContext *avctx;                  ///< parent AVCodecContext
  55     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     uint8_t *decoded_buffer;
  64     unsigned int decoded_buffer_size;
  65
  66     FLACDSPContext dsp;
  67 } FLACContext;
  68
  69 static int allocate_buffers(FLACContext *s);
  70
  71 static void flac_set_bps(FLACContext *s)
  72 {
  73     enum AVSampleFormat req = s->avctx->request_sample_fmt;
  74     int need32 = s->bps > 16;
  75     int want32 = av_get_bytes_per_sample(req) > 2;
  76     int planar = av_sample_fmt_is_planar(req);
  77
  78     if (need32 || want32) {
  79         if (planar)
  80             s->avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
  81         else
  82             s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
  83         s->sample_shift = 32 - s->bps;
  84     } else {
  85         if (planar)
  86             s->avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
  87         else
  88             s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
  89         s->sample_shift = 16 - s->bps;
  90     }
  91 }
  92
  93 static av_cold int flac_decode_init(AVCodecContext *avctx)
  94 {
  95     enum FLACExtradataFormat format;
  96     uint8_t *streaminfo;
  97     int ret;
  98     FLACContext *s = avctx->priv_data;
  99     s->avctx = avctx;
 100
 101     /* for now, the raw FLAC header is allowed to be passed to the decoder as
 102        frame data instead of extradata. */
 103     if (!avctx->extradata)
 104         return 0;
 105
 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     ret = allocate_buffers(s);
 112     if (ret < 0)
 113         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     return 0;
 119 }
 120
 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     av_log(avctx, AV_LOG_DEBUG, "  Max Framesize: %d\n", s->max_framesize);
 125     av_log(avctx, AV_LOG_DEBUG, "  Samplerate: %d\n", s->samplerate);
 126     av_log(avctx, AV_LOG_DEBUG, "  Channels: %d\n", s->channels);
 127     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     int ret;
 134
 135     av_assert0(s->max_blocksize);
 136
 137     buf_size = av_samples_get_buffer_size(NULL, s->channels, s->max_blocksize,
 138                                           AV_SAMPLE_FMT_S32P, 0);
 139     if (buf_size < 0)
 140         return buf_size;
 141
 142     av_fast_malloc(&s->decoded_buffer, &s->decoded_buffer_size, buf_size);
 143     if (!s->decoded_buffer)
 144         return AVERROR(ENOMEM);
 145
 146     ret = av_samples_fill_arrays((uint8_t **)s->decoded, NULL,
 147                                   s->decoded_buffer, s->channels,
 148                                   s->max_blocksize, AV_SAMPLE_FMT_S32P, 0);
 149     return ret < 0 ? ret : 0;
 150 }
 151
 152 /**
 153  * Parse the STREAMINFO from an inline header.
 154  * @param s the flac decoding context
 155  * @param buf input buffer, starting with the "fLaC" marker
 156  * @param buf_size buffer size
 157  * @return non-zero if metadata is invalid
 158  */
 159 static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
 160 {
 161     int metadata_type, metadata_size, ret;
 162
 163     if (buf_size < FLAC_STREAMINFO_SIZE+8) {
 164         /* need more data */
 165         return 0;
 166     }
 167     flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
 168     if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
 169         metadata_size != FLAC_STREAMINFO_SIZE) {
 170         return AVERROR_INVALIDDATA;
 171     }
 172     avpriv_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]);
 173     ret = allocate_buffers(s);
 174     if (ret < 0)
 175         return ret;
 176     flac_set_bps(s);
 177     ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
 178     s->got_streaminfo = 1;
 179
 180     return 0;
 181 }
 182
 183 /**
 184  * Determine the size of an inline header.
 185  * @param buf input buffer, starting with the "fLaC" marker
 186  * @param buf_size buffer size
 187  * @return number of bytes in the header, or 0 if more data is needed
 188  */
 189 static int get_metadata_size(const uint8_t *buf, int buf_size)
 190 {
 191     int metadata_last, metadata_size;
 192     const uint8_t *buf_end = buf + buf_size;
 193
 194     buf += 4;
 195     do {
 196         if (buf_end - buf < 4)
 197             return 0;
 198         flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
 199         buf += 4;
 200         if (buf_end - buf < metadata_size) {
 201             /* need more data in order to read the complete header */
 202             return 0;
 203         }
 204         buf += metadata_size;
 205     } while (!metadata_last);
 206
 207     return buf_size - (buf_end - buf);
 208 }
 209
 210 static int decode_residuals(FLACContext *s, int32_t *decoded, int pred_order)
 211 {
 212     int i, tmp, partition, method_type, rice_order;
 213     int rice_bits, rice_esc;
 214     int samples;
 215
 216     method_type = get_bits(&s->gb, 2);
 217     if (method_type > 1) {
 218         av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
 219                method_type);
 220         return AVERROR_INVALIDDATA;
 221     }
 222
 223     rice_order = get_bits(&s->gb, 4);
 224
 225     samples= s->blocksize >> rice_order;
 226     if (samples << rice_order != s->blocksize) {
 227         av_log(s->avctx, AV_LOG_ERROR, "invalid rice order: %i blocksize %i\n",
 228                rice_order, s->blocksize);
 229         return AVERROR_INVALIDDATA;
 230     }
 231
 232     if (pred_order > samples) {
 233         av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
 234                pred_order, samples);
 235         return AVERROR_INVALIDDATA;
 236     }
 237
 238     rice_bits = 4 + method_type;
 239     rice_esc  = (1 << rice_bits) - 1;
 240
 241     decoded += pred_order;
 242     i= pred_order;
 243     for (partition = 0; partition < (1 << rice_order); partition++) {
 244         tmp = get_bits(&s->gb, rice_bits);
 245         if (tmp == rice_esc) {
 246             tmp = get_bits(&s->gb, 5);
 247             for (; i < samples; i++)
 248                 *decoded++ = get_sbits_long(&s->gb, tmp);
 249         } else {
 250             for (; i < samples; i++) {
 251                 *decoded++ = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
 252             }
 253         }
 254         i= 0;
 255     }
 256
 257     return 0;
 258 }
 259
 260 static int decode_subframe_fixed(FLACContext *s, int32_t *decoded,
 261                                  int pred_order, int bps)
 262 {
 263     const int blocksize = s->blocksize;
 264     int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i;
 265     int ret;
 266
 267     /* warm up samples */
 268     for (i = 0; i < pred_order; i++) {
 269         decoded[i] = get_sbits_long(&s->gb, bps);
 270     }
 271
 272     if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
 273         return ret;
 274
 275     if (pred_order > 0)
 276         a = decoded[pred_order-1];
 277     if (pred_order > 1)
 278         b = a - decoded[pred_order-2];
 279     if (pred_order > 2)
 280         c = b - decoded[pred_order-2] + decoded[pred_order-3];
 281     if (pred_order > 3)
 282         d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
 283
 284     switch (pred_order) {
 285     case 0:
 286         break;
 287     case 1:
 288         for (i = pred_order; i < blocksize; i++)
 289             decoded[i] = a += decoded[i];
 290         break;
 291     case 2:
 292         for (i = pred_order; i < blocksize; i++)
 293             decoded[i] = a += b += decoded[i];
 294         break;
 295     case 3:
 296         for (i = pred_order; i < blocksize; i++)
 297             decoded[i] = a += b += c += decoded[i];
 298         break;
 299     case 4:
 300         for (i = pred_order; i < blocksize; i++)
 301             decoded[i] = a += b += c += d += decoded[i];
 302         break;
 303     default:
 304         av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
 305         return AVERROR_INVALIDDATA;
 306     }
 307
 308     return 0;
 309 }
 310
 311 static int decode_subframe_lpc(FLACContext *s, int32_t *decoded, int pred_order,
 312                                int bps)
 313 {
 314     int i, ret;
 315     int coeff_prec, qlevel;
 316     int coeffs[32];
 317
 318     /* warm up samples */
 319     for (i = 0; i < pred_order; i++) {
 320         decoded[i] = get_sbits_long(&s->gb, bps);
 321     }
 322
 323     coeff_prec = get_bits(&s->gb, 4) + 1;
 324     if (coeff_prec == 16) {
 325         av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
 326         return AVERROR_INVALIDDATA;
 327     }
 328     qlevel = get_sbits(&s->gb, 5);
 329     if (qlevel < 0) {
 330         av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
 331                qlevel);
 332         return AVERROR_INVALIDDATA;
 333     }
 334
 335     for (i = 0; i < pred_order; i++) {
 336         coeffs[pred_order - i - 1] = get_sbits(&s->gb, coeff_prec);
 337     }
 338
 339     if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
 340         return ret;
 341
 342     s->dsp.lpc(decoded, coeffs, pred_order, qlevel, s->blocksize);
 343
 344     return 0;
 345 }
 346
 347 static inline int decode_subframe(FLACContext *s, int channel)
 348 {
 349     int32_t *decoded = s->decoded[channel];
 350     int type, wasted = 0;
 351     int bps = s->bps;
 352     int i, tmp, ret;
 353
 354     if (channel == 0) {
 355         if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
 356             bps++;
 357     } else {
 358         if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
 359             bps++;
 360     }
 361
 362     if (get_bits1(&s->gb)) {
 363         av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
 364         return AVERROR_INVALIDDATA;
 365     }
 366     type = get_bits(&s->gb, 6);
 367
 368     if (get_bits1(&s->gb)) {
 369         int left = get_bits_left(&s->gb);
 370         if ( left < 0 ||
 371             (left < bps && !show_bits_long(&s->gb, left)) ||
 372                            !show_bits_long(&s->gb, bps)) {
 373             av_log(s->avctx, AV_LOG_ERROR,
 374                    "Invalid number of wasted bits > available bits (%d) - left=%d\n",
 375                    bps, left);
 376             return AVERROR_INVALIDDATA;
 377         }
 378         wasted = 1 + get_unary(&s->gb, 1, get_bits_left(&s->gb));
 379         bps -= wasted;
 380     }
 381     if (bps > 32) {
 382         avpriv_report_missing_feature(s->avctx, "Decorrelated bit depth > 32");
 383         return AVERROR_PATCHWELCOME;
 384     }
 385
 386 //FIXME use av_log2 for types
 387     if (type == 0) {
 388         tmp = get_sbits_long(&s->gb, bps);
 389         for (i = 0; i < s->blocksize; i++)
 390             decoded[i] = tmp;
 391     } else if (type == 1) {
 392         for (i = 0; i < s->blocksize; i++)
 393             decoded[i] = get_sbits_long(&s->gb, bps);
 394     } else if ((type >= 8) && (type <= 12)) {
 395         if ((ret = decode_subframe_fixed(s, decoded, type & ~0x8, bps)) < 0)
 396             return ret;
 397     } else if (type >= 32) {
 398         if ((ret = decode_subframe_lpc(s, decoded, (type & ~0x20)+1, bps)) < 0)
 399             return ret;
 400     } else {
 401         av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
 402         return AVERROR_INVALIDDATA;
 403     }
 404
 405     if (wasted) {
 406         int i;
 407         for (i = 0; i < s->blocksize; i++)
 408             decoded[i] <<= wasted;
 409     }
 410
 411     return 0;
 412 }
 413
 414 static int decode_frame(FLACContext *s)
 415 {
 416     int i, ret;
 417     GetBitContext *gb = &s->gb;
 418     FLACFrameInfo fi;
 419
 420     if ((ret = ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) < 0) {
 421         av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
 422         return ret;
 423     }
 424
 425     if (s->channels && fi.channels != s->channels && s->got_streaminfo) {
 426         s->channels = s->avctx->channels = fi.channels;
 427         ff_flac_set_channel_layout(s->avctx);
 428         ret = allocate_buffers(s);
 429         if (ret < 0)
 430             return ret;
 431     }
 432     s->channels = s->avctx->channels = fi.channels;
 433     if (!s->avctx->channel_layout)
 434         ff_flac_set_channel_layout(s->avctx);
 435     s->ch_mode = fi.ch_mode;
 436
 437     if (!s->bps && !fi.bps) {
 438         av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
 439         return AVERROR_INVALIDDATA;
 440     }
 441     if (!fi.bps) {
 442         fi.bps = s->bps;
 443     } else if (s->bps && fi.bps != s->bps) {
 444         av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
 445                                        "supported\n");
 446         return AVERROR_INVALIDDATA;
 447     }
 448
 449     if (!s->bps) {
 450         s->bps = s->avctx->bits_per_raw_sample = fi.bps;
 451         flac_set_bps(s);
 452     }
 453
 454     if (!s->max_blocksize)
 455         s->max_blocksize = FLAC_MAX_BLOCKSIZE;
 456     if (fi.blocksize > s->max_blocksize) {
 457         av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
 458                s->max_blocksize);
 459         return AVERROR_INVALIDDATA;
 460     }
 461     s->blocksize = fi.blocksize;
 462
 463     if (!s->samplerate && !fi.samplerate) {
 464         av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
 465                                         " or frame header\n");
 466         return AVERROR_INVALIDDATA;
 467     }
 468     if (fi.samplerate == 0)
 469         fi.samplerate = s->samplerate;
 470     s->samplerate = s->avctx->sample_rate = fi.samplerate;
 471
 472     if (!s->got_streaminfo) {
 473         ret = allocate_buffers(s);
 474         if (ret < 0)
 475             return ret;
 476         ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
 477         s->got_streaminfo = 1;
 478         dump_headers(s->avctx, (FLACStreaminfo *)s);
 479     }
 480
 481 //    dump_headers(s->avctx, (FLACStreaminfo *)s);
 482
 483     /* subframes */
 484     for (i = 0; i < s->channels; i++) {
 485         if ((ret = decode_subframe(s, i)) < 0)
 486             return ret;
 487     }
 488
 489     align_get_bits(gb);
 490
 491     /* frame footer */
 492     skip_bits(gb, 16); /* data crc */
 493
 494     return 0;
 495 }
 496
 497 static int flac_decode_frame(AVCodecContext *avctx, void *data,
 498                              int *got_frame_ptr, AVPacket *avpkt)
 499 {
 500     AVFrame *frame     = data;
 501     ThreadFrame tframe = { .f = data };
 502     const uint8_t *buf = avpkt->data;
 503     int buf_size = avpkt->size;
 504     FLACContext *s = avctx->priv_data;
 505     int bytes_read = 0;
 506     int ret;
 507
 508     *got_frame_ptr = 0;
 509
 510     if (s->max_framesize == 0) {
 511         s->max_framesize =
 512             ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
 513                                        FLAC_MAX_CHANNELS, 32);
 514     }
 515
 516     if (buf_size > 5 && !memcmp(buf, "\177FLAC", 5)) {
 517         av_log(s->avctx, AV_LOG_DEBUG, "skipping flac header packet 1\n");
 518         return buf_size;
 519     }
 520
 521     if (buf_size > 0 && (*buf & 0x7F) == FLAC_METADATA_TYPE_VORBIS_COMMENT) {
 522         av_log(s->avctx, AV_LOG_DEBUG, "skipping vorbis comment\n");
 523         return buf_size;
 524     }
 525
 526     /* check that there is at least the smallest decodable amount of data.
 527        this amount corresponds to the smallest valid FLAC frame possible.
 528        FF F8 69 02 00 00 9A 00 00 34 46 */
 529     if (buf_size < FLAC_MIN_FRAME_SIZE)
 530         return buf_size;
 531
 532     /* check for inline header */
 533     if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
 534         if (!s->got_streaminfo && (ret = parse_streaminfo(s, buf, buf_size))) {
 535             av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
 536             return ret;
 537         }
 538         return get_metadata_size(buf, buf_size);
 539     }
 540
 541     /* decode frame */
 542     if ((ret = init_get_bits8(&s->gb, buf, buf_size)) < 0)
 543         return ret;
 544     if ((ret = decode_frame(s)) < 0) {
 545         av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
 546         return ret;
 547     }
 548     bytes_read = get_bits_count(&s->gb)/8;
 549
 550     if ((s->avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_COMPLIANT)) &&
 551         av_crc(av_crc_get_table(AV_CRC_16_ANSI),
 552                0, buf, bytes_read)) {
 553         av_log(s->avctx, AV_LOG_ERROR, "CRC error at PTS %"PRId64"\n", avpkt->pts);
 554         if (s->avctx->err_recognition & AV_EF_EXPLODE)
 555             return AVERROR_INVALIDDATA;
 556     }
 557
 558     /* get output buffer */
 559     frame->nb_samples = s->blocksize;
 560     if ((ret = ff_thread_get_buffer(avctx, &tframe, 0)) < 0)
 561         return ret;
 562
 563     s->dsp.decorrelate[s->ch_mode](frame->data, s->decoded, s->channels,
 564                                    s->blocksize, s->sample_shift);
 565
 566     if (bytes_read > buf_size) {
 567         av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
 568         return AVERROR_INVALIDDATA;
 569     }
 570     if (bytes_read < buf_size) {
 571         av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
 572                buf_size - bytes_read, buf_size);
 573     }
 574
 575     *got_frame_ptr = 1;
 576
 577     return bytes_read;
 578 }
 579
 580 static int init_thread_copy(AVCodecContext *avctx)
 581 {
 582     FLACContext *s = avctx->priv_data;
 583     s->decoded_buffer = NULL;
 584     s->decoded_buffer_size = 0;
 585     s->avctx = avctx;
 586     if (s->max_blocksize)
 587         return allocate_buffers(s);
 588     return 0;
 589 }
 590
 591 static av_cold int flac_decode_close(AVCodecContext *avctx)
 592 {
 593     FLACContext *s = avctx->priv_data;
 594
 595     av_freep(&s->decoded_buffer);
 596
 597     return 0;
 598 }
 599
 600 AVCodec ff_flac_decoder = {
 601     .name           = "flac",
 602     .long_name      = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
 603     .type           = AVMEDIA_TYPE_AUDIO,
 604     .id             = AV_CODEC_ID_FLAC,
 605     .priv_data_size = sizeof(FLACContext),
 606     .init           = flac_decode_init,
 607     .close          = flac_decode_close,
 608     .decode         = flac_decode_frame,
 609     .init_thread_copy = ONLY_IF_THREADS_ENABLED(init_thread_copy),
 610     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
 611     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
 612                                                       AV_SAMPLE_FMT_S16P,
 613                                                       AV_SAMPLE_FMT_S32,
 614                                                       AV_SAMPLE_FMT_S32P,
 615                                                       AV_SAMPLE_FMT_NONE },
 616 };