[deb_ffmpeg.git] / ffmpeg / libavcodec / pcm-dvd.c

/*
 * LPCM codecs for PCM formats found in Video DVD streams
 * Copyright (c) 2013 Christian Schmidt
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * 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
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/**
 * @file
 * LPCM codecs for PCM formats found in Video DVD streams
 */

#include "avcodec.h"
#include "bytestream.h"
#include "internal.h"

typedef struct PCMDVDContext {
    uint32_t last_header;    // Cached header to see if parsing is needed
    int block_size;          // Size of a block of samples in bytes
    int last_block_size;     // Size of the last block of samples in bytes
    int samples_per_block;   // Number of samples per channel per block
    int groups_per_block;    // Number of 20/24bit sample groups per block
    uint8_t *extra_samples;  // Pointer to leftover samples from a frame
    int extra_sample_count;  // Number of leftover samples in the buffer
} PCMDVDContext;

static av_cold int pcm_dvd_decode_init(AVCodecContext *avctx)
{
    PCMDVDContext *s = avctx->priv_data;

    /* Invalid header to force parsing of the first header */
    s->last_header = -1;
    /* reserve space for 8 channels, 3 bytes/sample, 4 samples/block */
    if (!(s->extra_samples = av_malloc(8 * 3 * 4)))
        return AVERROR(ENOMEM);

    return 0;
}

static av_cold int pcm_dvd_decode_uninit(AVCodecContext *avctx)
{
    PCMDVDContext *s = avctx->priv_data;

    av_freep(&s->extra_samples);

    return 0;
}

static int pcm_dvd_parse_header(AVCodecContext *avctx, const uint8_t *header)
{
    /* no traces of 44100 and 32000Hz in any commercial software or player */
    static const uint32_t frequencies[4] = { 48000, 96000, 44100, 32000 };
    PCMDVDContext *s = avctx->priv_data;
    int header_int = (header[0] & 0xe0) | (header[1] << 8) | (header[2] << 16);

    /* early exit if the header didn't change apart from the frame number */
    if (s->last_header == header_int)
        return 0;
    s->last_header = -1;

    if (avctx->debug & FF_DEBUG_PICT_INFO)
        av_dlog(avctx, "pcm_dvd_parse_header: header = %02x%02x%02x\n",
                header[0], header[1], header[2]);
    /*
     * header[0] emphasis (1), muse(1), reserved(1), frame number(5)
     * header[1] quant (2), freq(2), reserved(1), channels(3)
     * header[2] dynamic range control (0x80 = off)
     */

    /* Discard potentially existing leftover samples from old channel layout */
    s->extra_sample_count = 0;

    /* get the sample depth and derive the sample format from it */
    avctx->bits_per_coded_sample = 16 + (header[1] >> 6 & 3) * 4;
    if (avctx->bits_per_coded_sample == 28) {
        av_log(avctx, AV_LOG_ERROR,
               "PCM DVD unsupported sample depth %i\n",
               avctx->bits_per_coded_sample);
        return AVERROR_INVALIDDATA;
    }
    avctx->sample_fmt = avctx->bits_per_coded_sample == 16 ? AV_SAMPLE_FMT_S16
                                                           : AV_SAMPLE_FMT_S32;
    avctx->bits_per_raw_sample = avctx->bits_per_coded_sample;

    /* get the sample rate */
    avctx->sample_rate = frequencies[header[1] >> 4 & 3];

    /* get the number of channels */
    avctx->channels = 1 + (header[1] & 7);
    /* calculate the bitrate */
    avctx->bit_rate = avctx->channels *
                      avctx->sample_rate *
                      avctx->bits_per_coded_sample;

    /* 4 samples form a group in 20/24bit PCM on DVD Video.
     * A block is formed by the number of groups that are
     * needed to complete a set of samples for each channel. */
    if (avctx->bits_per_coded_sample == 16) {
        s->samples_per_block = 1;
        s->block_size        = avctx->channels * 2;
    } else {
        switch (avctx->channels) {
        case 1:
        case 2:
        case 4:
            /* one group has all the samples needed */
            s->block_size        = 4 * avctx->bits_per_coded_sample / 8;
            s->samples_per_block = 4 / avctx->channels;
            s->groups_per_block  = 1;
            break;
        case 8:
            /* two groups have all the samples needed */
            s->block_size        = 8 * avctx->bits_per_coded_sample / 8;
            s->samples_per_block = 1;
            s->groups_per_block  = 2;
            break;
        default:
            /* need avctx->channels groups */
            s->block_size        = 4 * avctx->channels *
                                   avctx->bits_per_coded_sample / 8;
            s->samples_per_block = 4;
            s->groups_per_block  = avctx->channels;
            break;
        }
    }

    if (avctx->debug & FF_DEBUG_PICT_INFO)
        av_dlog(avctx,
                "pcm_dvd_parse_header: %d channels, %d bits per sample, %d Hz, %d bit/s\n",
                avctx->channels, avctx->bits_per_coded_sample,
                avctx->sample_rate, avctx->bit_rate);

    s->last_header = header_int;

    return 0;
}

static void *pcm_dvd_decode_samples(AVCodecContext *avctx, const uint8_t *src,
                                    void *dst, int blocks)
{
    PCMDVDContext *s = avctx->priv_data;
    int16_t *dst16   = dst;
    int32_t *dst32   = dst;
    GetByteContext gb;
    int i;
    uint8_t t;

    bytestream2_init(&gb, src, blocks * s->block_size);
    switch (avctx->bits_per_coded_sample) {
    case 16: {
#if HAVE_BIGENDIAN
        bytestream2_get_buffer(&gb, dst16, blocks * s->block_size);
        dst16 += blocks * s->block_size / 2;
#else
        int samples = blocks * avctx->channels;
        do {
            *dst16++ = bytestream2_get_be16u(&gb);
        } while (--samples);
#endif
        return dst16;
    }
    case 20:
        if (avctx->channels == 1) {
            do {
                for (i = 2; i; i--) {
                    dst32[0] = bytestream2_get_be16u(&gb) << 16;
                    dst32[1] = bytestream2_get_be16u(&gb) << 16;
                    t = bytestream2_get_byteu(&gb);
                    *dst32++ += (t & 0xf0) << 8;
                    *dst32++ += (t & 0x0f) << 12;
                }
            } while (--blocks);
        } else {
        do {
            for (i = s->groups_per_block; i; i--) {
                dst32[0] = bytestream2_get_be16u(&gb) << 16;
                dst32[1] = bytestream2_get_be16u(&gb) << 16;
                dst32[2] = bytestream2_get_be16u(&gb) << 16;
                dst32[3] = bytestream2_get_be16u(&gb) << 16;
                t = bytestream2_get_byteu(&gb);
                *dst32++ += (t & 0xf0) << 8;
                *dst32++ += (t & 0x0f) << 12;
                t = bytestream2_get_byteu(&gb);
                *dst32++ += (t & 0xf0) << 8;
                *dst32++ += (t & 0x0f) << 12;
            }
        } while (--blocks);
        }
        return dst32;
    case 24:
        if (avctx->channels == 1) {
            do {
                for (i = 2; i; i--) {
                    dst32[0] = bytestream2_get_be16u(&gb) << 16;
                    dst32[1] = bytestream2_get_be16u(&gb) << 16;
                    *dst32++ += bytestream2_get_byteu(&gb) << 8;
                    *dst32++ += bytestream2_get_byteu(&gb) << 8;
                }
            } while (--blocks);
        } else {
        do {
            for (i = s->groups_per_block; i; i--) {
                dst32[0] = bytestream2_get_be16u(&gb) << 16;
                dst32[1] = bytestream2_get_be16u(&gb) << 16;
                dst32[2] = bytestream2_get_be16u(&gb) << 16;
                dst32[3] = bytestream2_get_be16u(&gb) << 16;
                *dst32++ += bytestream2_get_byteu(&gb) << 8;
                *dst32++ += bytestream2_get_byteu(&gb) << 8;
                *dst32++ += bytestream2_get_byteu(&gb) << 8;
                *dst32++ += bytestream2_get_byteu(&gb) << 8;
            }
        } while (--blocks);
        }
        return dst32;
    default:
        return NULL;
    }
}

static int pcm_dvd_decode_frame(AVCodecContext *avctx, void *data,
                                int *got_frame_ptr, AVPacket *avpkt)
{
    AVFrame *frame     = data;
    const uint8_t *src = avpkt->data;
    int buf_size       = avpkt->size;
    PCMDVDContext *s   = avctx->priv_data;
    int retval;
    int blocks;
    void *dst;

    if (buf_size < 3) {
        av_log(avctx, AV_LOG_ERROR, "PCM packet too small\n");
        return AVERROR_INVALIDDATA;
    }

    if ((retval = pcm_dvd_parse_header(avctx, src)))
        return retval;
    if (s->last_block_size && s->last_block_size != s->block_size) {
        av_log(avctx, AV_LOG_WARNING, "block_size has changed %d != %d\n", s->last_block_size, s->block_size);
        s->extra_sample_count = 0;
    }
    s->last_block_size = s->block_size;
    src      += 3;
    buf_size -= 3;

    blocks = (buf_size + s->extra_sample_count) / s->block_size;

    /* get output buffer */
    frame->nb_samples = blocks * s->samples_per_block;
    if ((retval = ff_get_buffer(avctx, frame, 0)) < 0)
        return retval;
    dst = frame->data[0];

    /* consume leftover samples from last packet */
    if (s->extra_sample_count) {
        int missing_samples = s->block_size - s->extra_sample_count;
        if (buf_size >= missing_samples) {
            memcpy(s->extra_samples + s->extra_sample_count, src,
                   missing_samples);
            dst = pcm_dvd_decode_samples(avctx, s->extra_samples, dst, 1);
            src += missing_samples;
            buf_size -= missing_samples;
            s->extra_sample_count = 0;
            blocks--;
        } else {
            /* new packet still doesn't have enough samples */
            memcpy(s->extra_samples + s->extra_sample_count, src, buf_size);
            s->extra_sample_count += buf_size;
            return avpkt->size;
        }
    }

    /* decode remaining complete samples */
    if (blocks) {
        pcm_dvd_decode_samples(avctx, src, dst, blocks);
        buf_size -= blocks * s->block_size;
    }

    /* store leftover samples */
    if (buf_size) {
        src += blocks * s->block_size;
        memcpy(s->extra_samples, src, buf_size);
        s->extra_sample_count = buf_size;
    }

    *got_frame_ptr = 1;

    return avpkt->size;
}

AVCodec ff_pcm_dvd_decoder = {
    .name           = "pcm_dvd",
    .long_name      = NULL_IF_CONFIG_SMALL("PCM signed 16|20|24-bit big-endian for DVD media"),
    .type           = AVMEDIA_TYPE_AUDIO,
    .id             = AV_CODEC_ID_PCM_DVD,
    .priv_data_size = sizeof(PCMDVDContext),
    .init           = pcm_dvd_decode_init,
    .decode         = pcm_dvd_decode_frame,
    .close          = pcm_dvd_decode_uninit,
    .capabilities   = CODEC_CAP_DR1,
    .sample_fmts    = (const enum AVSampleFormat[]) {
        AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_NONE
    }
};
Commit	Line	Data
2ba45a60 DM	1	/*
	2	* LPCM codecs for PCM formats found in Video DVD streams
	3	* Copyright (c) 2013 Christian Schmidt
	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	* LPCM codecs for PCM formats found in Video DVD streams
	25	*/
	26
	27	#include "avcodec.h"
	28	#include "bytestream.h"
	29	#include "internal.h"
	30
	31	typedef struct PCMDVDContext {
	32	uint32_t last_header; // Cached header to see if parsing is needed
	33	int block_size; // Size of a block of samples in bytes
	34	int last_block_size; // Size of the last block of samples in bytes
	35	int samples_per_block; // Number of samples per channel per block
	36	int groups_per_block; // Number of 20/24bit sample groups per block
	37	uint8_t *extra_samples; // Pointer to leftover samples from a frame
	38	int extra_sample_count; // Number of leftover samples in the buffer
	39	} PCMDVDContext;
	40
	41	static av_cold int pcm_dvd_decode_init(AVCodecContext *avctx)
	42	{
	43	PCMDVDContext *s = avctx->priv_data;
	44
	45	/* Invalid header to force parsing of the first header */
	46	s->last_header = -1;
	47	/* reserve space for 8 channels, 3 bytes/sample, 4 samples/block */
	48	if (!(s->extra_samples = av_malloc(8 * 3 * 4)))
	49	return AVERROR(ENOMEM);
	50
	51	return 0;
	52	}
	53
	54	static av_cold int pcm_dvd_decode_uninit(AVCodecContext *avctx)
	55	{
	56	PCMDVDContext *s = avctx->priv_data;
	57
	58	av_freep(&s->extra_samples);
	59
	60	return 0;
	61	}
	62
	63	static int pcm_dvd_parse_header(AVCodecContext avctx, const uint8_t header)
	64	{
65	/* no traces of 44100 and 32000Hz in any commercial software or player */
66	static const uint32_t frequencies[4] = { 48000, 96000, 44100, 32000 };
67	PCMDVDContext *s = avctx->priv_data;
68	int header_int = (header[0] & 0xe0) \| (header[1] << 8) \| (header[2] << 16);
69
70	/* early exit if the header didn't change apart from the frame number */
71	if (s->last_header == header_int)
72	return 0;
73	s->last_header = -1;
74
75	if (avctx->debug & FF_DEBUG_PICT_INFO)
76	av_dlog(avctx, "pcm_dvd_parse_header: header = %02x%02x%02x\n",
77	header[0], header[1], header[2]);
78	/*
79	* header[0] emphasis (1), muse(1), reserved(1), frame number(5)
80	* header[1] quant (2), freq(2), reserved(1), channels(3)
81	* header[2] dynamic range control (0x80 = off)
82	*/
83
84	/* Discard potentially existing leftover samples from old channel layout */
85	s->extra_sample_count = 0;
86
87	/* get the sample depth and derive the sample format from it */
88	avctx->bits_per_coded_sample = 16 + (header[1] >> 6 & 3) * 4;
89	if (avctx->bits_per_coded_sample == 28) {
90	av_log(avctx, AV_LOG_ERROR,
91	"PCM DVD unsupported sample depth %i\n",
92	avctx->bits_per_coded_sample);
93	return AVERROR_INVALIDDATA;
94	}
95	avctx->sample_fmt = avctx->bits_per_coded_sample == 16 ? AV_SAMPLE_FMT_S16
96	: AV_SAMPLE_FMT_S32;
97	avctx->bits_per_raw_sample = avctx->bits_per_coded_sample;
98
99	/* get the sample rate */
100	avctx->sample_rate = frequencies[header[1] >> 4 & 3];
101
102	/* get the number of channels */
103	avctx->channels = 1 + (header[1] & 7);
104	/* calculate the bitrate */
105	avctx->bit_rate = avctx->channels *
106	avctx->sample_rate *
107	avctx->bits_per_coded_sample;
108
109	/* 4 samples form a group in 20/24bit PCM on DVD Video.
110	* A block is formed by the number of groups that are
111	* needed to complete a set of samples for each channel. */
112	if (avctx->bits_per_coded_sample == 16) {
113	s->samples_per_block = 1;
114	s->block_size = avctx->channels * 2;
115	} else {
116	switch (avctx->channels) {
117	case 1:
118	case 2:
119	case 4:
120	/* one group has all the samples needed */
121	s->block_size = 4 * avctx->bits_per_coded_sample / 8;
122	s->samples_per_block = 4 / avctx->channels;
123	s->groups_per_block = 1;
124	break;
125	case 8:
126	/* two groups have all the samples needed */
127	s->block_size = 8 * avctx->bits_per_coded_sample / 8;
128	s->samples_per_block = 1;
129	s->groups_per_block = 2;
130	break;
131	default:
132	/* need avctx->channels groups */
133	s->block_size = 4 * avctx->channels *
134	avctx->bits_per_coded_sample / 8;
135	s->samples_per_block = 4;
136	s->groups_per_block = avctx->channels;
137	break;
138	}
139	}
140
141	if (avctx->debug & FF_DEBUG_PICT_INFO)
142	av_dlog(avctx,
143	"pcm_dvd_parse_header: %d channels, %d bits per sample, %d Hz, %d bit/s\n",
144	avctx->channels, avctx->bits_per_coded_sample,
145	avctx->sample_rate, avctx->bit_rate);
146
147	s->last_header = header_int;
148
149	return 0;
150	}
151
152	static void pcm_dvd_decode_samples(AVCodecContext avctx, const uint8_t *src,
153	void *dst, int blocks)
154	{
155	PCMDVDContext *s = avctx->priv_data;
156	int16_t *dst16 = dst;
157	int32_t *dst32 = dst;
158	GetByteContext gb;
159	int i;
160	uint8_t t;
2ba45a60 DM	161
	162	bytestream2_init(&gb, src, blocks * s->block_size);
	163	switch (avctx->bits_per_coded_sample) {
f6fa7814	164	case 16: {
2ba45a60 DM	165	#if HAVE_BIGENDIAN
	166	bytestream2_get_buffer(&gb, dst16, blocks * s->block_size);
	167	dst16 += blocks * s->block_size / 2;
	168	#else
f6fa7814	169	int samples = blocks * avctx->channels;
2ba45a60 DM	170	do {
	171	*dst16++ = bytestream2_get_be16u(&gb);
	172	} while (--samples);
	173	#endif
	174	return dst16;
f6fa7814	175	}
2ba45a60 DM	176	case 20:
	177	if (avctx->channels == 1) {
	178	do {
	179	for (i = 2; i; i--) {
	180	dst32[0] = bytestream2_get_be16u(&gb) << 16;
	181	dst32[1] = bytestream2_get_be16u(&gb) << 16;
	182	t = bytestream2_get_byteu(&gb);
	183	*dst32++ += (t & 0xf0) << 8;
	184	*dst32++ += (t & 0x0f) << 12;
	185	}
	186	} while (--blocks);
	187	} else {
	188	do {
	189	for (i = s->groups_per_block; i; i--) {
	190	dst32[0] = bytestream2_get_be16u(&gb) << 16;
	191	dst32[1] = bytestream2_get_be16u(&gb) << 16;
	192	dst32[2] = bytestream2_get_be16u(&gb) << 16;
	193	dst32[3] = bytestream2_get_be16u(&gb) << 16;
	194	t = bytestream2_get_byteu(&gb);
	195	*dst32++ += (t & 0xf0) << 8;
	196	*dst32++ += (t & 0x0f) << 12;
	197	t = bytestream2_get_byteu(&gb);
	198	*dst32++ += (t & 0xf0) << 8;
	199	*dst32++ += (t & 0x0f) << 12;
	200	}
	201	} while (--blocks);
	202	}
	203	return dst32;
	204	case 24:
	205	if (avctx->channels == 1) {
	206	do {
	207	for (i = 2; i; i--) {
	208	dst32[0] = bytestream2_get_be16u(&gb) << 16;
	209	dst32[1] = bytestream2_get_be16u(&gb) << 16;
	210	*dst32++ += bytestream2_get_byteu(&gb) << 8;
	211	*dst32++ += bytestream2_get_byteu(&gb) << 8;
	212	}
	213	} while (--blocks);
	214	} else {
	215	do {
	216	for (i = s->groups_per_block; i; i--) {
	217	dst32[0] = bytestream2_get_be16u(&gb) << 16;
	218	dst32[1] = bytestream2_get_be16u(&gb) << 16;
	219	dst32[2] = bytestream2_get_be16u(&gb) << 16;
	220	dst32[3] = bytestream2_get_be16u(&gb) << 16;
	221	*dst32++ += bytestream2_get_byteu(&gb) << 8;
	222	*dst32++ += bytestream2_get_byteu(&gb) << 8;
	223	*dst32++ += bytestream2_get_byteu(&gb) << 8;
	224	*dst32++ += bytestream2_get_byteu(&gb) << 8;
	225	}
	226	} while (--blocks);
	227	}
	228	return dst32;
	229	default:
	230	return NULL;
	231	}
	232	}
	233
	234	static int pcm_dvd_decode_frame(AVCodecContext avctx, void data,
	235	int got_frame_ptr, AVPacket avpkt)
	236	{
	237	AVFrame *frame = data;
	238	const uint8_t *src = avpkt->data;
	239	int buf_size = avpkt->size;
240	PCMDVDContext *s = avctx->priv_data;
241	int retval;
242	int blocks;
243	void *dst;
244
245	if (buf_size < 3) {
246	av_log(avctx, AV_LOG_ERROR, "PCM packet too small\n");
247	return AVERROR_INVALIDDATA;
248	}
249
250	if ((retval = pcm_dvd_parse_header(avctx, src)))
251	return retval;
252	if (s->last_block_size && s->last_block_size != s->block_size) {
253	av_log(avctx, AV_LOG_WARNING, "block_size has changed %d != %d\n", s->last_block_size, s->block_size);
254	s->extra_sample_count = 0;
255	}
256	s->last_block_size = s->block_size;
257	src += 3;
258	buf_size -= 3;
259
260	blocks = (buf_size + s->extra_sample_count) / s->block_size;
261
262	/* get output buffer */
263	frame->nb_samples = blocks * s->samples_per_block;
264	if ((retval = ff_get_buffer(avctx, frame, 0)) < 0)
265	return retval;
266	dst = frame->data[0];
267
268	/* consume leftover samples from last packet */
269	if (s->extra_sample_count) {
270	int missing_samples = s->block_size - s->extra_sample_count;
271	if (buf_size >= missing_samples) {
272	memcpy(s->extra_samples + s->extra_sample_count, src,
273	missing_samples);
274	dst = pcm_dvd_decode_samples(avctx, s->extra_samples, dst, 1);
275	src += missing_samples;
276	buf_size -= missing_samples;
277	s->extra_sample_count = 0;
278	blocks--;
279	} else {
280	/* new packet still doesn't have enough samples */
281	memcpy(s->extra_samples + s->extra_sample_count, src, buf_size);
282	s->extra_sample_count += buf_size;
283	return avpkt->size;
284	}
285	}
286
287	/* decode remaining complete samples */
288	if (blocks) {
289	pcm_dvd_decode_samples(avctx, src, dst, blocks);
290	buf_size -= blocks * s->block_size;
291	}
292
293	/* store leftover samples */
294	if (buf_size) {
295	src += blocks * s->block_size;
296	memcpy(s->extra_samples, src, buf_size);
297	s->extra_sample_count = buf_size;
298	}
299
300	*got_frame_ptr = 1;
301
302	return avpkt->size;
303	}
304
305	AVCodec ff_pcm_dvd_decoder = {
306	.name = "pcm_dvd",
307	.long_name = NULL_IF_CONFIG_SMALL("PCM signed 16\|20\|24-bit big-endian for DVD media"),
308	.type = AVMEDIA_TYPE_AUDIO,
309	.id = AV_CODEC_ID_PCM_DVD,
310	.priv_data_size = sizeof(PCMDVDContext),
311	.init = pcm_dvd_decode_init,
312	.decode = pcm_dvd_decode_frame,
313	.close = pcm_dvd_decode_uninit,
314	.capabilities = CODEC_CAP_DR1,
315	.sample_fmts = (const enum AVSampleFormat[]) {
316	AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_NONE
317	}
318	};