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