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 (pred_order > samples) {
 225         av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
 226                pred_order, samples);
 227         return AVERROR_INVALIDDATA;
 228     }
 229
 230     rice_bits = 4 + method_type;
 231     rice_esc  = (1 << rice_bits) - 1;
 232
 233     decoded += pred_order;
 234     i= pred_order;
 235     for (partition = 0; partition < (1 << rice_order); partition++) {
 236         tmp = get_bits(&s->gb, rice_bits);
 237         if (tmp == rice_esc) {
 238             tmp = get_bits(&s->gb, 5);
 239             for (; i < samples; i++)
 240                 *decoded++ = get_sbits_long(&s->gb, tmp);
 241         } else {
 242             for (; i < samples; i++) {
 243                 *decoded++ = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
 244             }
 245         }
 246         i= 0;
 247     }
 248
 249     return 0;
 250 }
 251
 252 static int decode_subframe_fixed(FLACContext *s, int32_t *decoded,
 253                                  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     if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
 265         return ret;
 266
 267     if (pred_order > 0)
 268         a = decoded[pred_order-1];
 269     if (pred_order > 1)
 270         b = a - decoded[pred_order-2];
 271     if (pred_order > 2)
 272         c = b - decoded[pred_order-2] + decoded[pred_order-3];
 273     if (pred_order > 3)
 274         d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
 275
 276     switch (pred_order) {
 277     case 0:
 278         break;
 279     case 1:
 280         for (i = pred_order; i < blocksize; i++)
 281             decoded[i] = a += decoded[i];
 282         break;
 283     case 2:
 284         for (i = pred_order; i < blocksize; i++)
 285             decoded[i] = a += b += decoded[i];
 286         break;
 287     case 3:
 288         for (i = pred_order; i < blocksize; i++)
 289             decoded[i] = a += b += c += decoded[i];
 290         break;
 291     case 4:
 292         for (i = pred_order; i < blocksize; i++)
 293             decoded[i] = a += b += c += d += decoded[i];
 294         break;
 295     default:
 296         av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
 297         return AVERROR_INVALIDDATA;
 298     }
 299
 300     return 0;
 301 }
 302
 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     }
 320     qlevel = get_sbits(&s->gb, 5);
 321     if (qlevel < 0) {
 322         av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
 323                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     if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
 332         return ret;
 333
 334     s->dsp.lpc(decoded, coeffs, pred_order, qlevel, s->blocksize);
 335
 336     return 0;
 337 }
 338
 339 static inline int decode_subframe(FLACContext *s, int channel)
 340 {
 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++;
 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         int left = get_bits_left(&s->gb);
 362         if ( left < 0 ||
 363             (left < bps && !show_bits_long(&s->gb, left)) ||
 364                            !show_bits_long(&s->gb, bps)) {
 365             av_log(s->avctx, AV_LOG_ERROR,
 366                    "Invalid number of wasted bits > available bits (%d) - left=%d\n",
 367                    bps, left);
 368             return AVERROR_INVALIDDATA;
 369         }
 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
 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         if ((ret = decode_subframe_fixed(s, decoded, type & ~0x8, bps)) < 0)
 388             return ret;
 389     } else if (type >= 32) {
 390         if ((ret = decode_subframe_lpc(s, decoded, (type & ~0x20)+1, bps)) < 0)
 391             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         int i;
 399         for (i = 0; i < s->blocksize; i++)
 400             decoded[i] <<= wasted;
 401     }
 402
 403     return 0;
 404 }
 405
 406 static int decode_frame(FLACContext *s)
 407 {
 408     int i, ret;
 409     GetBitContext *gb = &s->gb;
 410     FLACFrameInfo fi;
 411
 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     if (s->channels && fi.channels != s->channels && s->got_streaminfo) {
 418         s->channels = s->avctx->channels = fi.channels;
 419         ff_flac_set_channel_layout(s->avctx);
 420         ret = allocate_buffers(s);
 421         if (ret < 0)
 422             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     if (!s->bps && !fi.bps) {
 430         av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
 431         return AVERROR_INVALIDDATA;
 432     }
 433     if (!fi.bps) {
 434         fi.bps = s->bps;
 435     } else if (s->bps && fi.bps != s->bps) {
 436         av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
 437                                        "supported\n");
 438         return AVERROR_INVALIDDATA;
 439     }
 440
 441     if (!s->bps) {
 442         s->bps = s->avctx->bits_per_raw_sample = fi.bps;
 443         flac_set_bps(s);
 444     }
 445
 446     if (!s->max_blocksize)
 447         s->max_blocksize = FLAC_MAX_BLOCKSIZE;
 448     if (fi.blocksize > s->max_blocksize) {
 449         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     if (!s->samplerate && !fi.samplerate) {
 456         av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
 457                                         " or frame header\n");
 458         return AVERROR_INVALIDDATA;
 459     }
 460     if (fi.samplerate == 0)
 461         fi.samplerate = s->samplerate;
 462     s->samplerate = s->avctx->sample_rate = fi.samplerate;
 463
 464     if (!s->got_streaminfo) {
 465         ret = allocate_buffers(s);
 466         if (ret < 0)
 467             return ret;
 468         ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
 469         s->got_streaminfo = 1;
 470         dump_headers(s->avctx, (FLACStreaminfo *)s);
 471     }
 472
 473 //    dump_headers(s->avctx, (FLACStreaminfo *)s);
 474
 475     /* subframes */
 476     for (i = 0; i < s->channels; i++) {
 477         if ((ret = decode_subframe(s, i)) < 0)
 478             return ret;
 479     }
 480
 481     align_get_bits(gb);
 482
 483     /* frame footer */
 484     skip_bits(gb, 16); /* data crc */
 485
 486     return 0;
 487 }
 488
 489 static int flac_decode_frame(AVCodecContext *avctx, void *data,
 490                              int *got_frame_ptr, AVPacket *avpkt)
 491 {
 492     AVFrame *frame     = data;
 493     ThreadFrame tframe = { .f = data };
 494     const uint8_t *buf = avpkt->data;
 495     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         s->max_framesize =
 504             ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
 505                                        FLAC_MAX_CHANNELS, 32);
 506     }
 507
 508     if (buf_size > 5 && !memcmp(buf, "\177FLAC", 5)) {
 509         av_log(s->avctx, AV_LOG_DEBUG, "skiping flac header packet 1\n");
 510         return buf_size;
 511     }
 512
 513     if (buf_size > 0 && (*buf & 0x7F) == FLAC_METADATA_TYPE_VORBIS_COMMENT) {
 514         av_log(s->avctx, AV_LOG_DEBUG, "skiping vorbis comment\n");
 515         return buf_size;
 516     }
 517
 518     /* check that there is at least the smallest decodable amount of data.
 519        this amount corresponds to the smallest valid FLAC frame possible.
 520        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);
 531     }
 532
 533     /* decode frame */
 534     if ((ret = init_get_bits8(&s->gb, buf, buf_size)) < 0)
 535         return ret;
 536     if ((ret = decode_frame(s)) < 0) {
 537         av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
 538         return ret;
 539     }
 540     bytes_read = get_bits_count(&s->gb)/8;
 541
 542     if ((s->avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_COMPLIANT)) &&
 543         av_crc(av_crc_get_table(AV_CRC_16_ANSI),
 544                0, buf, bytes_read)) {
 545         av_log(s->avctx, AV_LOG_ERROR, "CRC error at PTS %"PRId64"\n", avpkt->pts);
 546         if (s->avctx->err_recognition & AV_EF_EXPLODE)
 547             return AVERROR_INVALIDDATA;
 548     }
 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     if (bytes_read > buf_size) {
 559         av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
 560         return AVERROR_INVALIDDATA;
 561     }
 562     if (bytes_read < buf_size) {
 563         av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
 564                buf_size - bytes_read, buf_size);
 565     }
 566
 567     *got_frame_ptr = 1;
 568
 569     return bytes_read;
 570 }
 571
 572 static int init_thread_copy(AVCodecContext *avctx)
 573 {
 574     FLACContext *s = avctx->priv_data;
 575     s->decoded_buffer = NULL;
 576     s->decoded_buffer_size = 0;
 577     s->avctx = avctx;
 578     if (s->max_blocksize)
 579         return allocate_buffers(s);
 580     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     return 0;
 590 }
 591
 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     .priv_data_size = sizeof(FLACContext),
 598     .init           = flac_decode_init,
 599     .close          = flac_decode_close,
 600     .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     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
 604                                                       AV_SAMPLE_FMT_S16P,
 605                                                       AV_SAMPLE_FMT_S32,
 606                                                       AV_SAMPLE_FMT_S32P,
 607                                                       AV_SAMPLE_FMT_NONE },
 608 };