RepoMirrors
/
ffmpeg
mirror of https://git.ffmpeg.org/ffmpeg.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

pcm: convert to new channel layout API 

Signed-off-by: Vittorio Giovara <vittorio.giovara@gmail.com>
Signed-off-by: Anton Khirnov <anton@khirnov.net>
Signed-off-by: James Almer <jamrial@gmail.com>
This commit is contained in:
Anton Khirnov 2013-05-07 07:20:32 +02:00 committed by James Almer
parent d2a360c139
commit ac0d207a1a
6 changed files with 94 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
libavcodec/pcm-bluray.c
View File

@ -54,14 +54,12 @@ static int pcm_bluray_parse_header(AVCodecContext *avctx,
const uint8_t *header)
{
static const uint8_t bits_per_samples[4] = { 0, 16, 20, 24 };
static const uint32_t channel_layouts[16] = {
0, AV_CH_LAYOUT_MONO, 0, AV_CH_LAYOUT_STEREO, AV_CH_LAYOUT_SURROUND,
AV_CH_LAYOUT_2_1, AV_CH_LAYOUT_4POINT0, AV_CH_LAYOUT_2_2,
AV_CH_LAYOUT_5POINT0, AV_CH_LAYOUT_5POINT1, AV_CH_LAYOUT_7POINT0,
AV_CH_LAYOUT_7POINT1, 0, 0, 0, 0
};
static const uint8_t channels[16] = {
0, 1, 0, 2, 3, 3, 4, 4, 5, 6, 7, 8, 0, 0, 0, 0
static const AVChannelLayout channel_layouts[16] = {
{ 0 }, AV_CHANNEL_LAYOUT_MONO, { 0 },
AV_CHANNEL_LAYOUT_STEREO, AV_CHANNEL_LAYOUT_SURROUND, AV_CHANNEL_LAYOUT_2_1,
AV_CHANNEL_LAYOUT_4POINT0, AV_CHANNEL_LAYOUT_2_2, AV_CHANNEL_LAYOUT_5POINT0,
AV_CHANNEL_LAYOUT_5POINT1, AV_CHANNEL_LAYOUT_7POINT0, AV_CHANNEL_LAYOUT_7POINT1,
{ 0 }, { 0 }, { 0 }, { 0 },
};
uint8_t channel_layout = header[2] >> 4;
@ -104,21 +102,21 @@ static int pcm_bluray_parse_header(AVCodecContext *avctx,
* differ from the actual meaningful number, e.g. mono audio still has two
* channels, one being empty.
*/
avctx->channel_layout = channel_layouts[channel_layout];
avctx->channels = channels[channel_layout];
if (!avctx->channels) {
av_channel_layout_uninit(&avctx->ch_layout);
avctx->ch_layout = channel_layouts[channel_layout];
if (!avctx->ch_layout.nb_channels) {
av_log(avctx, AV_LOG_ERROR, "reserved channel configuration (%d)\n",
channel_layout);
return AVERROR_INVALIDDATA;
}
avctx->bit_rate = FFALIGN(avctx->channels, 2) * avctx->sample_rate *
avctx->bit_rate = FFALIGN(avctx->ch_layout.nb_channels, 2) * avctx->sample_rate *
avctx->bits_per_coded_sample;
if (avctx->debug & FF_DEBUG_PICT_INFO)
ff_dlog(avctx,
"pcm_bluray_parse_header: %d channels, %d bits per sample, %d Hz, %"PRId64" bit/s\n",
avctx->channels, avctx->bits_per_coded_sample,
avctx->ch_layout.nb_channels, avctx->bits_per_coded_sample,
avctx->sample_rate, avctx->bit_rate);
return 0;
}
@ -148,7 +146,7 @@ static int pcm_bluray_decode_frame(AVCodecContext *avctx, void *data,
bytestream2_init(&gb, src, buf_size);
/* There's always an even number of channels in the source */
num_source_channels = FFALIGN(avctx->channels, 2);
num_source_channels = FFALIGN(avctx->ch_layout.nb_channels, 2);
sample_size = (num_source_channels *
(avctx->sample_fmt == AV_SAMPLE_FMT_S16 ? 16 : 24)) >> 3;
samples = buf_size / sample_size;
@ -161,7 +159,7 @@ static int pcm_bluray_decode_frame(AVCodecContext *avctx, void *data,
dst32 = (int32_t *)frame->data[0];
if (samples) {
switch (avctx->channel_layout) {
switch (avctx->ch_layout.u.mask) {
/* cases with same number of source and coded channels */
case AV_CH_LAYOUT_STEREO:
case AV_CH_LAYOUT_4POINT0:
@ -189,10 +187,10 @@ static int pcm_bluray_decode_frame(AVCodecContext *avctx, void *data,
if (AV_SAMPLE_FMT_S16 == avctx->sample_fmt) {
do {
#if HAVE_BIGENDIAN
bytestream2_get_buffer(&gb, dst16, avctx->channels * 2);
dst16 += avctx->channels;
bytestream2_get_buffer(&gb, dst16, avctx->ch_layout.nb_channels * 2);
dst16 += avctx->ch_layout.nb_channels;
#else
channel = avctx->channels;
channel = avctx->ch_layout.nb_channels;
do {
*dst16++ = bytestream2_get_be16u(&gb);
} while (--channel);
@ -201,7 +199,7 @@ static int pcm_bluray_decode_frame(AVCodecContext *avctx, void *data,
} while (--samples);
} else {
do {
channel = avctx->channels;
channel = avctx->ch_layout.nb_channels;
do {
*dst32++ = bytestream2_get_be24u(&gb) << 8;
} while (--channel);

28
libavcodec/pcm-blurayenc.c
View File

@ -61,7 +61,7 @@ static av_cold int pcm_bluray_encode_init(AVCodecContext *avctx)
return AVERROR_BUG;
}
switch (avctx->channel_layout) {
switch (avctx->ch_layout.u.mask) {
case AV_CH_LAYOUT_MONO:
ch_layout = 1;
break;
@ -112,7 +112,7 @@ static int pcm_bluray_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
PutByteContext pb;
int ret;
num_dest_channels = FFALIGN(avctx->channels, 2);
num_dest_channels = FFALIGN(avctx->ch_layout.nb_channels, 2);
sample_size = (num_dest_channels *
(avctx->sample_fmt == AV_SAMPLE_FMT_S16 ? 16 : 24)) >> 3;
samples = frame->nb_samples;
@ -130,7 +130,7 @@ static int pcm_bluray_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
bytestream2_init_writer(&pb, avpkt->data + 4, avpkt->size - 4);
switch (avctx->channel_layout) {
switch (avctx->ch_layout.u.mask) {
/* cases with same number of source and coded channels */
case AV_CH_LAYOUT_STEREO:
case AV_CH_LAYOUT_4POINT0:
@ -158,10 +158,10 @@ static int pcm_bluray_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
if (AV_SAMPLE_FMT_S16 == avctx->sample_fmt) {
do {
#if HAVE_BIGENDIAN
bytestream2_put_bufferu(&pb, (const uint8_t *)src16, avctx->channels * 2);
src16 += avctx->channels;
bytestream2_put_bufferu(&pb, (const uint8_t *)src16, avctx->ch_layout.nb_channels * 2);
src16 += avctx->ch_layout.nb_channels;
#else
channel = avctx->channels;
channel = avctx->ch_layout.nb_channels;
do {
bytestream2_put_be16u(&pb, *src16++);
} while (--channel);
@ -170,7 +170,7 @@ static int pcm_bluray_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
} while (--samples);
} else {
do {
channel = avctx->channels;
channel = avctx->ch_layout.nb_channels;
do {
bytestream2_put_be24u(&pb, (*src32++) >> 8);
} while (--channel);
@ -278,6 +278,7 @@ const AVCodec ff_pcm_bluray_encoder = {
.init = pcm_bluray_encode_init,
.encode2 = pcm_bluray_encode_frame,
.supported_samplerates = (const int[]) { 48000, 96000, 192000, 0 },
#if FF_API_OLD_CHANNEL_LAYOUT
.channel_layouts = (const uint64_t[]) {
AV_CH_LAYOUT_MONO,
AV_CH_LAYOUT_STEREO,
@ -290,6 +291,19 @@ const AVCodec ff_pcm_bluray_encoder = {
AV_CH_LAYOUT_7POINT0,
AV_CH_LAYOUT_7POINT1,
0 },
#endif
.ch_layouts = (const AVChannelLayout[]) {
AV_CHANNEL_LAYOUT_MONO,
AV_CHANNEL_LAYOUT_STEREO,
AV_CHANNEL_LAYOUT_SURROUND,
AV_CHANNEL_LAYOUT_2_1,
AV_CHANNEL_LAYOUT_4POINT0,
AV_CHANNEL_LAYOUT_2_2,
AV_CHANNEL_LAYOUT_5POINT0,
AV_CHANNEL_LAYOUT_5POINT1,
AV_CHANNEL_LAYOUT_7POINT0,
AV_CHANNEL_LAYOUT_7POINT1,
{ 0 } },
.sample_fmts = (const enum AVSampleFormat[]) {
AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_NONE },
.caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,

28
libavcodec/pcm-dvd.c
View File

@ -55,6 +55,7 @@ static int pcm_dvd_parse_header(AVCodecContext *avctx, const uint8_t *header)
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);
int channels;
/* early exit if the header didn't change apart from the frame number */
if (s->last_header == header_int)
@ -89,9 +90,12 @@ static int pcm_dvd_parse_header(AVCodecContext *avctx, const uint8_t *header)
avctx->sample_rate = frequencies[header[1] >> 4 & 3];
/* get the number of channels */
avctx->channels = 1 + (header[1] & 7);
channels = 1 + (header[1] & 7);
av_channel_layout_uninit(&avctx->ch_layout);
av_channel_layout_default(&avctx->ch_layout, channels);
/* calculate the bitrate */
avctx->bit_rate = avctx->channels *
avctx->bit_rate = channels *
avctx->sample_rate *
avctx->bits_per_coded_sample;
@ -100,15 +104,15 @@ static int pcm_dvd_parse_header(AVCodecContext *avctx, const uint8_t *header)
* 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;
s->block_size = channels * 2;
} else {
switch (avctx->channels) {
switch (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->samples_per_block = 4 / channels;
s->groups_per_block = 1;
break;
case 8:
@ -118,11 +122,11 @@ static int pcm_dvd_parse_header(AVCodecContext *avctx, const uint8_t *header)
s->groups_per_block = 2;
break;
default:
/* need avctx->channels groups */
s->block_size = 4 * avctx->channels *
/* need channels groups */
s->block_size = 4 * channels *
avctx->bits_per_coded_sample / 8;
s->samples_per_block = 4;
s->groups_per_block = avctx->channels;
s->groups_per_block = channels;
break;
}
}
@ -130,7 +134,7 @@ static int pcm_dvd_parse_header(AVCodecContext *avctx, const uint8_t *header)
if (avctx->debug & FF_DEBUG_PICT_INFO)
ff_dlog(avctx,
"pcm_dvd_parse_header: %d channels, %d bits per sample, %d Hz, %"PRId64" bit/s\n",
avctx->channels, avctx->bits_per_coded_sample,
avctx->ch_layout.nb_channels, avctx->bits_per_coded_sample,
avctx->sample_rate, avctx->bit_rate);
s->last_header = header_int;
@ -155,7 +159,7 @@ static void *pcm_dvd_decode_samples(AVCodecContext *avctx, const uint8_t *src,
bytestream2_get_buffer(&gb, dst16, blocks * s->block_size);
dst16 += blocks * s->block_size / 2;
#else
int samples = blocks * avctx->channels;
int samples = blocks * avctx->ch_layout.nb_channels;
do {
*dst16++ = bytestream2_get_be16u(&gb);
} while (--samples);
@ -163,7 +167,7 @@ static void *pcm_dvd_decode_samples(AVCodecContext *avctx, const uint8_t *src,
return dst16;
}
case 20:
if (avctx->channels == 1) {
if (avctx->ch_layout.nb_channels == 1) {
do {
for (i = 2; i; i--) {
dst32[0] = bytestream2_get_be16u(&gb) << 16;
@ -191,7 +195,7 @@ static void *pcm_dvd_decode_samples(AVCodecContext *avctx, const uint8_t *src,
}
return dst32;
case 24:
if (avctx->channels == 1) {
if (avctx->ch_layout.nb_channels == 1) {
do {
for (i = 2; i; i--) {
dst32[0] = bytestream2_get_be16u(&gb) << 16;

27
libavcodec/pcm-dvdenc.c
View File

@ -60,7 +60,7 @@ static av_cold int pcm_dvd_encode_init(AVCodecContext *avctx)
}
avctx->bits_per_coded_sample = 16 + quant * 4;
avctx->block_align = avctx->channels * avctx->bits_per_coded_sample / 8;
avctx->block_align = avctx->ch_layout.nb_channels * avctx->bits_per_coded_sample / 8;
avctx->bit_rate = avctx->block_align * 8LL * avctx->sample_rate;
if (avctx->bit_rate > 9800000) {
av_log(avctx, AV_LOG_ERROR, "Too big bitrate: reduce sample rate, bitdepth or channels.\n");
@ -69,16 +69,16 @@ static av_cold int pcm_dvd_encode_init(AVCodecContext *avctx)
if (avctx->sample_fmt == AV_SAMPLE_FMT_S16) {
s->samples_per_block = 1;
s->block_size = avctx->channels * 2;
s->block_size = avctx->ch_layout.nb_channels * 2;
frame_size = 2008 / s->block_size;
} else {
switch (avctx->channels) {
switch (avctx->ch_layout.nb_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->samples_per_block = 4 / avctx->ch_layout.nb_channels;
s->groups_per_block = 1;
break;
case 8:
@ -88,11 +88,11 @@ static av_cold int pcm_dvd_encode_init(AVCodecContext *avctx)
s->groups_per_block = 2;
break;
default:
/* need avctx->channels groups */
s->block_size = 4 * avctx->channels *
/* need avctx->ch_layout.nb_channels groups */
s->block_size = 4 * avctx->ch_layout.nb_channels *
avctx->bits_per_coded_sample / 8;
s->samples_per_block = 4;
s->groups_per_block = avctx->channels;
s->groups_per_block = avctx->ch_layout.nb_channels;
break;
}
@ -100,7 +100,7 @@ static av_cold int pcm_dvd_encode_init(AVCodecContext *avctx)
}
s->header[0] = 0x0c;
s->header[1] = (quant << 6) | (freq << 4) | (avctx->channels - 1);
s->header[1] = (quant << 6) | (freq << 4) | (avctx->ch_layout.nb_channels - 1);
s->header[2] = 0x80;
if (!avctx->frame_size)
@ -113,7 +113,7 @@ static int pcm_dvd_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
const AVFrame *frame, int *got_packet_ptr)
{
PCMDVDContext *s = avctx->priv_data;
int samples = frame->nb_samples * avctx->channels;
int samples = frame->nb_samples * avctx->ch_layout.nb_channels;
int64_t pkt_size = (frame->nb_samples / s->samples_per_block) * s->block_size + 3;
int blocks = (pkt_size - 3) / s->block_size;
const int16_t *src16;
@ -138,7 +138,7 @@ static int pcm_dvd_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
} while (--samples);
break;
case AV_SAMPLE_FMT_S32:
if (avctx->channels == 1) {
if (avctx->ch_layout.nb_channels == 1) {
do {
for (int i = 2; i; i--) {
bytestream2_put_be16(&pb, src32[0] >> 16);
@ -181,11 +181,18 @@ const AVCodec ff_pcm_dvd_encoder = {
.init = pcm_dvd_encode_init,
.encode2 = pcm_dvd_encode_frame,
.supported_samplerates = (const int[]) { 48000, 96000, 0},
#if FF_API_OLD_CHANNEL_LAYOUT
.channel_layouts = (const uint64_t[]) { AV_CH_LAYOUT_MONO,
AV_CH_LAYOUT_STEREO,
AV_CH_LAYOUT_5POINT1,
AV_CH_LAYOUT_7POINT1,
0 },
#endif
.ch_layouts = (const AVChannelLayout[]) { AV_CHANNEL_LAYOUT_MONO,
AV_CHANNEL_LAYOUT_STEREO,
AV_CHANNEL_LAYOUT_5POINT1,
AV_CHANNEL_LAYOUT_7POINT1,
{ 0 } },
.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
AV_SAMPLE_FMT_S32,
AV_SAMPLE_FMT_NONE },

39
libavcodec/pcm.c
View File

@ -56,7 +56,7 @@ static av_cold int pcm_encode_init(AVCodecContext *avctx)
#endif
avctx->bits_per_coded_sample = av_get_bits_per_sample(avctx->codec->id);
avctx->block_align = avctx->channels * avctx->bits_per_coded_sample / 8;
avctx->block_align = avctx->ch_layout.nb_channels * avctx->bits_per_coded_sample / 8;
avctx->bit_rate = avctx->block_align * 8LL * avctx->sample_rate;
return 0;
@ -80,8 +80,8 @@ static av_cold int pcm_encode_init(AVCodecContext *avctx)
}
#define ENCODE_PLANAR(type, endian, dst, n, shift, offset) \
n /= avctx->channels; \
for (c = 0; c < avctx->channels; c++) { \
n /= avctx->ch_layout.nb_channels; \
for (c = 0; c < avctx->ch_layout.nb_channels; c++) { \
int i; \
samples_ ## type = (const type *) frame->extended_data[c]; \
for (i = n; i > 0; i--) { \
@ -104,7 +104,7 @@ static int pcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
const uint32_t *samples_uint32_t;
sample_size = av_get_bits_per_sample(avctx->codec->id) / 8;
n = frame->nb_samples * avctx->channels;
n = frame->nb_samples * avctx->ch_layout.nb_channels;
samples = (const short *)frame->data[0];
if ((ret = ff_get_encode_buffer(avctx, avpkt, n * sample_size, 0)) < 0)
@ -207,8 +207,8 @@ static int pcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
case AV_CODEC_ID_PCM_S16LE_PLANAR:
case AV_CODEC_ID_PCM_S32LE_PLANAR:
#endif /* HAVE_BIGENDIAN */
n /= avctx->channels;
for (c = 0; c < avctx->channels; c++) {
n /= avctx->ch_layout.nb_channels;
for (c = 0; c < avctx->ch_layout.nb_channels; c++) {
const uint8_t *src = frame->extended_data[c];
bytestream_put_buffer(&dst, src, n * sample_size);
}
@ -252,7 +252,7 @@ static av_cold int pcm_decode_init(AVCodecContext *avctx)
AVFloatDSPContext *fdsp;
int i;
if (avctx->channels <= 0) {
if (avctx->ch_layout.nb_channels <= 0) {
av_log(avctx, AV_LOG_ERROR, "PCM channels out of bounds\n");
return AVERROR(EINVAL);
}
@ -312,8 +312,8 @@ static av_cold int pcm_decode_init(AVCodecContext *avctx)
}
#define DECODE_PLANAR(size, endian, src, dst, n, shift, offset) \
n /= avctx->channels; \
for (c = 0; c < avctx->channels; c++) { \
n /= channels; \
for (c = 0; c < avctx->ch_layout.nb_channels; c++) { \
int i; \
dst = frame->extended_data[c]; \
for (i = n; i > 0; i--) { \
@ -330,6 +330,7 @@ static int pcm_decode_frame(AVCodecContext *avctx, void *data,
int buf_size = avpkt->size;
PCMDecode *s = avctx->priv_data;
AVFrame *frame = data;
int channels = avctx->ch_layout.nb_channels;
int sample_size, c, n, ret, samples_per_block;
uint8_t *samples;
int32_t *dst_int32_t;
@ -349,7 +350,7 @@ static int pcm_decode_frame(AVCodecContext *avctx, void *data,
return AVERROR(EINVAL);
}
if (avctx->channels == 0) {
if (channels == 0) {
av_log(avctx, AV_LOG_ERROR, "Invalid number of channels\n");
return AVERROR(EINVAL);
}
@ -359,7 +360,7 @@ static int pcm_decode_frame(AVCodecContext *avctx, void *data,
return AVERROR(EINVAL);
}
n = avctx->channels * sample_size;
n = channels * sample_size;
if (n && buf_size % n) {
if (buf_size < n) {
@ -374,7 +375,7 @@ static int pcm_decode_frame(AVCodecContext *avctx, void *data,
n = buf_size / sample_size;
/* get output buffer */
frame->nb_samples = n * samples_per_block / avctx->channels;
frame->nb_samples = n * samples_per_block / channels;
if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
return ret;
samples = frame->data[0];
@ -429,8 +430,8 @@ static int pcm_decode_frame(AVCodecContext *avctx, void *data,
}
break;
case AV_CODEC_ID_PCM_S8_PLANAR:
n /= avctx->channels;
for (c = 0; c < avctx->channels; c++) {
n /= avctx->ch_layout.nb_channels;
for (c = 0; c < avctx->ch_layout.nb_channels; c++) {
int i;
samples = frame->extended_data[c];
for (i = n; i > 0; i--)
@ -494,8 +495,8 @@ static int pcm_decode_frame(AVCodecContext *avctx, void *data,
case AV_CODEC_ID_PCM_S16LE_PLANAR:
case AV_CODEC_ID_PCM_S32LE_PLANAR:
#endif /* HAVE_BIGENDIAN */
n /= avctx->channels;
for (c = 0; c < avctx->channels; c++) {
n /= avctx->ch_layout.nb_channels;
for (c = 0; c < avctx->ch_layout.nb_channels; c++) {
samples = frame->extended_data[c];
bytestream_get_buffer(&src, samples, n * sample_size);
}
@ -511,8 +512,8 @@ static int pcm_decode_frame(AVCodecContext *avctx, void *data,
case AV_CODEC_ID_PCM_LXF:
{
int i;
n /= avctx->channels;
for (c = 0; c < avctx->channels; c++) {
n /= channels;
for (c = 0; c < channels; c++) {
dst_int32_t = (int32_t *)frame->extended_data[c];
for (i = 0; i < n; i++) {
// extract low 20 bits and expand to 32 bits
@ -540,7 +541,7 @@ static int pcm_decode_frame(AVCodecContext *avctx, void *data,
avctx->codec_id == AV_CODEC_ID_PCM_F24LE) {
s->vector_fmul_scalar((float *)frame->extended_data[0],
(const float *)frame->extended_data[0],
s->scale, FFALIGN(frame->nb_samples * avctx->channels, 4));
s->scale, FFALIGN(frame->nb_samples * avctx->ch_layout.nb_channels, 4));
emms_c();
}

5
libavcodec/pcm_rechunk_bsf.c
View File

@ -42,11 +42,12 @@ static int init(AVBSFContext *ctx)
AVRational sr = av_make_q(ctx->par_in->sample_rate, 1);
int64_t min_samples;
if (ctx->par_in->channels <= 0 || ctx->par_in->sample_rate <= 0)
if (ctx->par_in->ch_layout.nb_channels <= 0 || ctx->par_in->sample_rate <= 0)
return AVERROR(EINVAL);
ctx->time_base_out = av_inv_q(sr);
s->sample_size = ctx->par_in->channels * av_get_bits_per_sample(ctx->par_in->codec_id) / 8;
s->sample_size = ctx->par_in->ch_layout.nb_channels *
av_get_bits_per_sample(ctx->par_in->codec_id) / 8;
if (s->frame_rate.num) {
min_samples = av_rescale_q_rnd(1, sr, s->frame_rate, AV_ROUND_DOWN);