Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

mlp: convert to new channel layout API

Browse Source 
Signed-off-by: James Almer <jamrial@gmail.com>
release/5.1
Anton Khirnov 6 years ago committed by James Almer
parent 6d8b25841c
commit d4b79b2e32
5 changed files with 153 additions and 99 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 9
      libavcodec/mlp.c
  2. 5
      libavcodec/mlp.h
  3. 12
      libavcodec/mlp_parser.c
  4. 120
      libavcodec/mlpdec.c
  5. 106
      libavcodec/mlpenc.c

9
libavcodec/mlp.c
Unescape View File

@ -57,12 +57,21 @@ const ChannelInformation ff_mlp_ch_info[21] = {
{ 0x3F, 0x04, 0x02, 0x00 },
};
#if FF_API_OLD_CHANNEL_LAYOUT
const uint64_t ff_mlp_channel_layouts[12] = {
AV_CH_LAYOUT_MONO, AV_CH_LAYOUT_STEREO, AV_CH_LAYOUT_2_1,
AV_CH_LAYOUT_QUAD, AV_CH_LAYOUT_2POINT1, AV_CH_LAYOUT_SURROUND,
AV_CH_LAYOUT_4POINT0, AV_CH_LAYOUT_5POINT0_BACK, AV_CH_LAYOUT_3POINT1,
AV_CH_LAYOUT_4POINT1, AV_CH_LAYOUT_5POINT1_BACK, 0,
};
#endif
const AVChannelLayout ff_mlp_ch_layouts[12] = {
AV_CHANNEL_LAYOUT_MONO, AV_CHANNEL_LAYOUT_STEREO, AV_CHANNEL_LAYOUT_2_1,
AV_CHANNEL_LAYOUT_QUAD, AV_CHANNEL_LAYOUT_2POINT1, AV_CHANNEL_LAYOUT_SURROUND,
AV_CHANNEL_LAYOUT_4POINT0, AV_CHANNEL_LAYOUT_5POINT0_BACK, AV_CHANNEL_LAYOUT_3POINT1,
AV_CHANNEL_LAYOUT_4POINT1, AV_CHANNEL_LAYOUT_5POINT1_BACK, { 0 },
};
#if CONFIG_SMALL
#define CRC_TABLE_SIZE 257

5
libavcodec/mlp.h
Unescape View File

@ -24,6 +24,8 @@
#include <stdint.h>
#include "libavutil/channel_layout.h"
#define SYNC_MLP 0xbb
#define SYNC_TRUEHD 0xba
@ -135,7 +137,10 @@ typedef struct {
*/
extern const ChannelInformation ff_mlp_ch_info[21];
#if FF_API_OLD_CHANNEL_LAYOUT
extern const uint64_t ff_mlp_channel_layouts[12];
#endif
extern const AVChannelLayout ff_mlp_ch_layouts[12];
/** MLP uses checksums that seem to be based on the standard CRC algorithm, but
* are not (in implementation terms, the table lookup and XOR are reversed).

12
libavcodec/mlp_parser.c
Unescape View File

@ -175,22 +175,18 @@ static int mlp_parse(AVCodecParserContext *s,
avctx->frame_size =
s->duration = mh.access_unit_size;
if(!avctx->channels || !avctx->channel_layout) {
av_channel_layout_uninit(&avctx->ch_layout);
if (mh.stream_type == 0xbb) {
/* MLP stream */
avctx->channels = mh.channels_mlp;
avctx->channel_layout = mh.channel_layout_mlp;
av_channel_layout_from_mask(&avctx->ch_layout, mh.channel_layout_mlp);
} else { /* mh.stream_type == 0xba */
/* TrueHD stream */
if (!mh.channels_thd_stream2) {
avctx->channels = mh.channels_thd_stream1;
avctx->channel_layout = mh.channel_layout_thd_stream1;
av_channel_layout_from_mask(&avctx->ch_layout, mh.channel_layout_thd_stream1);
} else {
avctx->channels = mh.channels_thd_stream2;
avctx->channel_layout = mh.channel_layout_thd_stream2;
av_channel_layout_from_mask(&avctx->ch_layout, mh.channel_layout_thd_stream2);
}
}
}
if (!mh.is_vbr) /* Stream is CBR */
avctx->bit_rate = mh.peak_bitrate;

120
libavcodec/mlpdec.c
Unescape View File

@ -32,6 +32,7 @@
#include "libavutil/channel_layout.h"
#include "libavutil/mem_internal.h"
#include "libavutil/thread.h"
#include "libavutil/opt.h"
#include "get_bits.h"
#include "internal.h"
#include "libavutil/crc.h"
@ -132,8 +133,11 @@ typedef struct SubStream {
} SubStream;
typedef struct MLPDecodeContext {
const AVClass *class;
AVCodecContext *avctx;
AVChannelLayout downmix_layout;
/// Current access unit being read has a major sync.
int is_major_sync_unit;
@ -169,39 +173,41 @@ typedef struct MLPDecodeContext {
MLPDSPContext dsp;
} MLPDecodeContext;
static const uint64_t thd_channel_order[] = {
AV_CH_FRONT_LEFT, AV_CH_FRONT_RIGHT, // LR
AV_CH_FRONT_CENTER, // C
AV_CH_LOW_FREQUENCY, // LFE
AV_CH_SIDE_LEFT, AV_CH_SIDE_RIGHT, // LRs
AV_CH_TOP_FRONT_LEFT, AV_CH_TOP_FRONT_RIGHT, // LRvh
AV_CH_FRONT_LEFT_OF_CENTER, AV_CH_FRONT_RIGHT_OF_CENTER, // LRc
AV_CH_BACK_LEFT, AV_CH_BACK_RIGHT, // LRrs
AV_CH_BACK_CENTER, // Cs
AV_CH_TOP_CENTER, // Ts
AV_CH_SURROUND_DIRECT_LEFT, AV_CH_SURROUND_DIRECT_RIGHT, // LRsd
AV_CH_WIDE_LEFT, AV_CH_WIDE_RIGHT, // LRw
AV_CH_TOP_FRONT_CENTER, // Cvh
AV_CH_LOW_FREQUENCY_2, // LFE2
static const enum AVChannel thd_channel_order[] = {
AV_CHAN_FRONT_LEFT, AV_CHAN_FRONT_RIGHT, // LR
AV_CHAN_FRONT_CENTER, // C
AV_CHAN_LOW_FREQUENCY, // LFE
AV_CHAN_SIDE_LEFT, AV_CHAN_SIDE_RIGHT, // LRs
AV_CHAN_TOP_FRONT_LEFT, AV_CHAN_TOP_FRONT_RIGHT, // LRvh
AV_CHAN_FRONT_LEFT_OF_CENTER, AV_CHAN_FRONT_RIGHT_OF_CENTER, // LRc
AV_CHAN_BACK_LEFT, AV_CHAN_BACK_RIGHT, // LRrs
AV_CHAN_BACK_CENTER, // Cs
AV_CHAN_TOP_CENTER, // Ts
AV_CHAN_SURROUND_DIRECT_LEFT, AV_CHAN_SURROUND_DIRECT_RIGHT, // LRsd
AV_CHAN_WIDE_LEFT, AV_CHAN_WIDE_RIGHT, // LRw
AV_CHAN_TOP_FRONT_CENTER, // Cvh
AV_CHAN_LOW_FREQUENCY_2, // LFE2
};
static int mlp_channel_layout_subset(uint64_t channel_layout, uint64_t mask)
static int mlp_channel_layout_subset(AVChannelLayout *layout, uint64_t mask)
{
return channel_layout && ((channel_layout & mask) == channel_layout);
return av_channel_layout_check(layout) &&
av_channel_layout_subset(layout, mask) ==
av_channel_layout_subset(layout, UINT64_MAX);
}
static uint64_t thd_channel_layout_extract_channel(uint64_t channel_layout,
int index)
static enum AVChannel thd_channel_layout_extract_channel(uint64_t channel_layout,
int index)
{
int i;
if (av_get_channel_layout_nb_channels(channel_layout) <= index)
return 0;
if (av_popcount64(channel_layout) <= index)
return AV_CHAN_NONE;
for (i = 0; i < FF_ARRAY_ELEMS(thd_channel_order); i++)
if (channel_layout & thd_channel_order[i] && !index--)
if (channel_layout & (1 << thd_channel_order[i]) && !index--)
return thd_channel_order[i];
return 0;
return AV_CHAN_NONE;
}
static VLC huff_vlc[3];
@ -290,6 +296,14 @@ static av_cold int mlp_decode_init(AVCodecContext *avctx)
m->substream[substr].lossless_check_data = 0xffffffff;
ff_mlpdsp_init(&m->dsp);
#if FF_API_OLD_CHANNEL_LAYOUT
FF_DISABLE_DEPRECATION_WARNINGS
if (avctx->request_channel_layout) {
av_channel_layout_uninit(&m->downmix_layout);
av_channel_layout_from_mask(&m->downmix_layout, avctx->request_channel_layout);
}
FF_ENABLE_DEPRECATION_WARNINGS
#endif
ff_thread_once(&init_static_once, init_static);
return 0;
@ -410,7 +424,7 @@ static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)
}
if (mh.channels_thd_stream1 == 2 &&
mh.channels_thd_stream2 == 2 &&
m->avctx->channels == 2)
m->avctx->ch_layout.nb_channels == 2)
m->substream[0].mask = AV_CH_LAYOUT_STEREO;
if ((substr = (mh.num_substreams > 1)))
m->substream[0].mask = AV_CH_LAYOUT_STEREO;
@ -419,14 +433,17 @@ static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)
m->substream[2].mask = mh.channel_layout_thd_stream2;
else
m->substream[2].mask = mh.channel_layout_thd_stream1;
if (m->avctx->channels > 2)
if (m->avctx->ch_layout.nb_channels > 2)
m->substream[mh.num_substreams > 1].mask = mh.channel_layout_thd_stream1;
if (m->avctx->channels<=2 && m->substream[substr].mask == AV_CH_LAYOUT_MONO && m->max_decoded_substream == 1) {
if (m->avctx->ch_layout.nb_channels <= 2 &&
m->substream[substr].mask == AV_CH_LAYOUT_MONO && m->max_decoded_substream == 1) {
av_log(m->avctx, AV_LOG_DEBUG, "Mono stream with 2 substreams, ignoring 2nd\n");
m->max_decoded_substream = 0;
if (m->avctx->channels==2)
m->avctx->channel_layout = AV_CH_LAYOUT_STEREO;
if (m->avctx->ch_layout.nb_channels == 2) {
av_channel_layout_uninit(&m->avctx->ch_layout);
m->avctx->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_STEREO;
}
}
}
@ -548,7 +565,7 @@ static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
s->max_matrix_channel = max_matrix_channel;
s->noise_type = noise_type;
if (mlp_channel_layout_subset(m->avctx->request_channel_layout, s->mask) &&
if (mlp_channel_layout_subset(&m->downmix_layout, s->mask) &&
m->max_decoded_substream > substr) {
av_log(m->avctx, AV_LOG_DEBUG,
"Extracting %d-channel downmix (0x%"PRIx64") from substream %d. "
@ -580,10 +597,11 @@ static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
for (ch = 0; ch <= s->max_matrix_channel; ch++) {
int ch_assign = get_bits(gbp, 6);
if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
uint64_t channel = thd_channel_layout_extract_channel(s->mask,
ch_assign);
ch_assign = av_get_channel_layout_channel_index(s->mask,
channel);
AVChannelLayout l;
enum AVChannel channel = thd_channel_layout_extract_channel(s->mask, ch_assign);
av_channel_layout_from_mask(&l, s->mask);
ch_assign = av_channel_layout_index_from_channel(&l, channel);
}
if (ch_assign < 0 || ch_assign > s->max_matrix_channel) {
avpriv_request_sample(m->avctx,
@ -623,21 +641,21 @@ static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
}
if (substr == m->max_decoded_substream) {
m->avctx->channels = s->max_matrix_channel + 1;
m->avctx->channel_layout = s->mask;
av_channel_layout_uninit(&m->avctx->ch_layout);
av_channel_layout_from_mask(&m->avctx->ch_layout, s->mask);
m->dsp.mlp_pack_output = m->dsp.mlp_select_pack_output(s->ch_assign,
s->output_shift,
s->max_matrix_channel,
m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
if (m->avctx->codec_id == AV_CODEC_ID_MLP && m->needs_reordering) {
if (m->avctx->channel_layout == (AV_CH_LAYOUT_QUAD|AV_CH_LOW_FREQUENCY) ||
m->avctx->channel_layout == AV_CH_LAYOUT_5POINT0_BACK) {
if (s->mask == (AV_CH_LAYOUT_QUAD|AV_CH_LOW_FREQUENCY) ||
s->mask == AV_CH_LAYOUT_5POINT0_BACK) {
int i = s->ch_assign[4];
s->ch_assign[4] = s->ch_assign[3];
s->ch_assign[3] = s->ch_assign[2];
s->ch_assign[2] = i;
} else if (m->avctx->channel_layout == AV_CH_LAYOUT_5POINT1_BACK) {
} else if (s->mask == AV_CH_LAYOUT_5POINT1_BACK) {
FFSWAP(int, s->ch_assign[2], s->ch_assign[4]);
FFSWAP(int, s->ch_assign[3], s->ch_assign[5]);
}
@ -1078,7 +1096,7 @@ static int output_data(MLPDecodeContext *m, unsigned int substr,
int ret;
int is32 = (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
if (m->avctx->channels != s->max_matrix_channel + 1) {
if (m->avctx->ch_layout.nb_channels != s->max_matrix_channel + 1) {
av_log(m->avctx, AV_LOG_ERROR, "channel count mismatch\n");
return AVERROR_INVALIDDATA;
}
@ -1255,7 +1273,7 @@ static int read_access_unit(AVCodecContext *avctx, void* data,
if (substr != m->max_decoded_substream &&
m->substream[m->max_decoded_substream].min_channel == 0 &&
m->substream[m->max_decoded_substream].max_channel == avctx->channels - 1)
m->substream[m->max_decoded_substream].max_channel == avctx->ch_layout.nb_channels - 1)
goto skip_substr;
init_get_bits(&gb, buf, substream_data_len[substr] * 8);
@ -1372,6 +1390,28 @@ static void mlp_decode_flush(AVCodecContext *avctx)
}
}
#define OFFSET(x) offsetof(MLPDecodeContext, x)
#define FLAGS (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)
static const AVOption options[] = {
{ "downmix", "Request a specific channel layout from the decoder", OFFSET(downmix_layout),
AV_OPT_TYPE_CHLAYOUT, {.str = NULL}, .flags = FLAGS },
{ NULL },
};
static const AVClass mlp_decoder_class = {
.class_name = "MLP decoder",
.item_name = av_default_item_name,
.option = options,
.version = LIBAVUTIL_VERSION_INT,
};
static const AVClass truehd_decoder_class = {
.class_name = "TrueHD decoder",
.item_name = av_default_item_name,
.option = options,
.version = LIBAVUTIL_VERSION_INT,
};
#if CONFIG_MLP_DECODER
const AVCodec ff_mlp_decoder = {
.name = "mlp",
@ -1379,6 +1419,7 @@ const AVCodec ff_mlp_decoder = {
.type = AVMEDIA_TYPE_AUDIO,
.id = AV_CODEC_ID_MLP,
.priv_data_size = sizeof(MLPDecodeContext),
.priv_class = &mlp_decoder_class,
.init = mlp_decode_init,
.decode = read_access_unit,
.flush = mlp_decode_flush,
@ -1393,6 +1434,7 @@ const AVCodec ff_truehd_decoder = {
.type = AVMEDIA_TYPE_AUDIO,
.id = AV_CODEC_ID_TRUEHD,
.priv_data_size = sizeof(MLPDecodeContext),
.priv_class = &truehd_decoder_class,
.init = mlp_decode_init,
.decode = read_access_unit,
.flush = mlp_decode_flush,

106
libavcodec/mlpenc.c
Unescape View File

@ -381,8 +381,8 @@ static void copy_restart_frame_params(MLPEncodeContext *ctx)
copy_matrix_params(&dp->matrix_params, &ctx->cur_decoding_params->matrix_params);
for (unsigned int channel = 0; channel < ctx->avctx->channels; channel++) {
ChannelParams *cp = ctx->seq_channel_params + index*(ctx->avctx->channels) + channel;
for (unsigned int channel = 0; channel < ctx->avctx->ch_layout.nb_channels; channel++) {
ChannelParams *cp = ctx->seq_channel_params + index*(ctx->avctx->ch_layout.nb_channels) + channel;
dp->quant_step_size[channel] = ctx->cur_decoding_params->quant_step_size[channel];
dp->matrix_params.shift[channel] = ctx->cur_decoding_params->matrix_params.shift[channel];
@ -528,13 +528,13 @@ static av_cold int mlp_encode_init(AVCodecContext *avctx)
ctx->coded_peak_bitrate = mlp_peak_bitrate(9600000, avctx->sample_rate);
/* TODO support more channels. */
if (avctx->channels > 2) {
if (avctx->ch_layout.nb_channels > 2) {
av_log(avctx, AV_LOG_WARNING,
"Only mono and stereo are supported at the moment.\n");
}
ctx->substream_info |= SUBSTREAM_INFO_ALWAYS_SET;
if (avctx->channels <= 2) {
if (avctx->ch_layout.nb_channels <= 2) {
ctx->substream_info |= SUBSTREAM_INFO_MAX_2_CHAN;
}
@ -559,7 +559,7 @@ static av_cold int mlp_encode_init(AVCodecContext *avctx)
ctx->dts = -avctx->frame_size;
ctx->num_channels = avctx->channels + 2; /* +2 noise channels */
ctx->num_channels = avctx->ch_layout.nb_channels + 2; /* +2 noise channels */
ctx->one_sample_buffer_size = avctx->frame_size
* ctx->num_channels;
/* TODO Let user pass major header interval as parameter. */
@ -588,59 +588,48 @@ static av_cold int mlp_encode_init(AVCodecContext *avctx)
ctx->num_substreams = 1; // TODO: change this after adding multi-channel support for TrueHD
if (ctx->avctx->codec_id == AV_CODEC_ID_MLP) {
/* MLP */
switch(avctx->channel_layout) {
case AV_CH_LAYOUT_MONO:
ctx->channel_arrangement = 0; break;
case AV_CH_LAYOUT_STEREO:
ctx->channel_arrangement = 1; break;
case AV_CH_LAYOUT_2_1:
ctx->channel_arrangement = 2; break;
case AV_CH_LAYOUT_QUAD:
ctx->channel_arrangement = 3; break;
case AV_CH_LAYOUT_2POINT1:
ctx->channel_arrangement = 4; break;
case AV_CH_LAYOUT_SURROUND:
ctx->channel_arrangement = 7; break;
case AV_CH_LAYOUT_4POINT0:
ctx->channel_arrangement = 8; break;
case AV_CH_LAYOUT_5POINT0_BACK:
ctx->channel_arrangement = 9; break;
case AV_CH_LAYOUT_3POINT1:
ctx->channel_arrangement = 10; break;
case AV_CH_LAYOUT_4POINT1:
ctx->channel_arrangement = 11; break;
case AV_CH_LAYOUT_5POINT1_BACK:
ctx->channel_arrangement = 12; break;
default:
static const AVChannelLayout layout_arrangement[] = {
AV_CHANNEL_LAYOUT_MONO, AV_CHANNEL_LAYOUT_STEREO,
AV_CHANNEL_LAYOUT_2_1, AV_CHANNEL_LAYOUT_QUAD,
AV_CHANNEL_LAYOUT_2POINT1, { 0 }, { 0 },
AV_CHANNEL_LAYOUT_SURROUND, AV_CHANNEL_LAYOUT_4POINT0,
AV_CHANNEL_LAYOUT_5POINT0_BACK, AV_CHANNEL_LAYOUT_3POINT1,
AV_CHANNEL_LAYOUT_4POINT1, AV_CHANNEL_LAYOUT_5POINT1_BACK,
};
int i;
for (i = 0; i < FF_ARRAY_ELEMS(layout_arrangement); i++)
if (!av_channel_layout_compare(&avctx->ch_layout, &layout_arrangement[i]))
break;
if (i == FF_ARRAY_ELEMS(layout_arrangement)) {
av_log(avctx, AV_LOG_ERROR, "Unsupported channel arrangement\n");
return AVERROR(EINVAL);
}
ctx->channel_arrangement = i;
ctx->flags = FLAGS_DVDA;
ctx->channel_occupancy = ff_mlp_ch_info[ctx->channel_arrangement].channel_occupancy;
ctx->summary_info = ff_mlp_ch_info[ctx->channel_arrangement].summary_info ;
} else {
/* TrueHD */
switch(avctx->channel_layout) {
case AV_CH_LAYOUT_STEREO:
if (!av_channel_layout_compare(&avctx->ch_layout,
&(AVChannelLayout)AV_CHANNEL_LAYOUT_STEREO)) {
ctx->ch_modifier_thd0 = 0;
ctx->ch_modifier_thd1 = 0;
ctx->ch_modifier_thd2 = 0;
ctx->channel_arrangement = 1;
break;
case AV_CH_LAYOUT_5POINT0_BACK:
} else if (!av_channel_layout_compare(&avctx->ch_layout,
&(AVChannelLayout)AV_CHANNEL_LAYOUT_5POINT0_BACK)) {
ctx->ch_modifier_thd0 = 1;
ctx->ch_modifier_thd1 = 1;
ctx->ch_modifier_thd2 = 1;
ctx->channel_arrangement = 11;
break;
case AV_CH_LAYOUT_5POINT1_BACK:
} else if (!av_channel_layout_compare(&avctx->ch_layout,
&(AVChannelLayout)AV_CHANNEL_LAYOUT_5POINT1_BACK)) {
ctx->ch_modifier_thd0 = 2;
ctx->ch_modifier_thd1 = 1;
ctx->ch_modifier_thd2 = 2;
ctx->channel_arrangement = 15;
break;
default:
} else {
av_log(avctx, AV_LOG_ERROR, "Unsupported channel arrangement\n");
return AVERROR(EINVAL);
}
@ -665,7 +654,7 @@ static av_cold int mlp_encode_init(AVCodecContext *avctx)
sum += ctx->seq_size[index];
}
ctx->sequence_size = sum;
size = ctx->restart_intervals * ctx->sequence_size * ctx->avctx->channels;
size = ctx->restart_intervals * ctx->sequence_size * ctx->avctx->ch_layout.nb_channels;
ctx->channel_params = av_calloc(size, sizeof(*ctx->channel_params));
if (!ctx->channel_params)
return AVERROR(ENOMEM);
@ -679,7 +668,7 @@ static av_cold int mlp_encode_init(AVCodecContext *avctx)
rh->noisegen_seed = 0;
rh->min_channel = 0;
rh->max_channel = avctx->channels - 1;
rh->max_channel = avctx->ch_layout.nb_channels - 1;
/* FIXME: this works for 1 and 2 channels, but check for more */
rh->max_matrix_channel = rh->max_channel;
@ -1228,7 +1217,7 @@ static void input_to_sample_buffer(MLPEncodeContext *ctx)
int32_t *input_buffer = ctx->inout_buffer + cur_index * ctx->one_sample_buffer_size;
for (unsigned int i = 0; i < ctx->avctx->frame_size; i++) {
for (unsigned int channel = 0; channel < ctx->avctx->channels; channel++)
for (unsigned int channel = 0; channel < ctx->avctx->ch_layout.nb_channels; channel++)
*sample_buffer++ = *input_buffer++;
sample_buffer += 2; /* noise_channels */
input_buffer += 2; /* noise_channels */
@ -1947,7 +1936,7 @@ static void set_best_codebook(MLPEncodeContext *ctx)
/* Update context. */
for (unsigned int index = 0; index < ctx->number_of_subblocks; index++) {
ChannelParams *cp = ctx->seq_channel_params + index*(ctx->avctx->channels) + channel;
ChannelParams *cp = ctx->seq_channel_params + index*(ctx->avctx->ch_layout.nb_channels) + channel;
best_codebook = *best_path++;
cur_bo = &ctx->best_offset[index][channel][best_codebook];
@ -1968,17 +1957,18 @@ static void set_major_params(MLPEncodeContext *ctx)
RestartHeader *rh = ctx->cur_restart_header;
uint8_t max_huff_lsbs = 0;
uint8_t max_output_bits = 0;
DecodingParams *seq_dp = ctx->decoding_params + ctx->seq_offset[0] * ctx->avctx->channels;
ChannelParams *seq_cp = ctx->channel_params + ctx->seq_offset[0] * ctx->avctx->channels;
int channels = ctx->avctx->ch_layout.nb_channels;
DecodingParams *seq_dp = ctx->decoding_params + ctx->seq_offset[0] * channels;
ChannelParams *seq_cp = ctx->channel_params + ctx->seq_offset[0] * channels;
for (unsigned int index = 0; index < ctx->seq_size[ctx->restart_intervals-1]; index++) {
memcpy(&ctx->major_decoding_params[index], seq_dp + index, sizeof(DecodingParams));
for (unsigned int channel = 0; channel < ctx->avctx->channels; channel++) {
uint8_t huff_lsbs = (seq_cp + index*(ctx->avctx->channels) + channel)->huff_lsbs;
for (unsigned int channel = 0; channel < channels; channel++) {
uint8_t huff_lsbs = (seq_cp + index*(channels) + channel)->huff_lsbs;
if (max_huff_lsbs < huff_lsbs)
max_huff_lsbs = huff_lsbs;
memcpy(&ctx->major_channel_params[index][channel],
(seq_cp + index*(ctx->avctx->channels) + channel),
(seq_cp + index*(channels) + channel),
sizeof(ChannelParams));
}
}
@ -2017,7 +2007,7 @@ static void analyze_sample_buffer(MLPEncodeContext *ctx)
ctx->cur_restart_header = &ctx->restart_header;
ctx->cur_decoding_params = seq_dp + 1;
ctx->cur_channel_params = seq_cp + ctx->avctx->channels;
ctx->cur_channel_params = seq_cp + ctx->avctx->ch_layout.nb_channels;
determine_quant_step_size(ctx);
generate_2_noise_channels(ctx);
@ -2044,7 +2034,7 @@ static void analyze_sample_buffer(MLPEncodeContext *ctx)
for (unsigned int index = 0; index < ctx->number_of_subblocks; index++) {
ctx->cur_decoding_params = seq_dp + index;
ctx->cur_channel_params = seq_cp + index*(ctx->avctx->channels);
ctx->cur_channel_params = seq_cp + index*(ctx->avctx->ch_layout.nb_channels);
ctx->cur_best_offset = ctx->best_offset[index];
determine_bits(ctx);
ctx->sample_buffer += ctx->cur_decoding_params->blocksize * ctx->num_channels;
@ -2078,13 +2068,14 @@ static int mlp_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
{
MLPEncodeContext *ctx = avctx->priv_data;
int bytes_written = 0;
int channels = avctx->ch_layout.nb_channels;
int restart_frame, ret;
uint8_t *data;
if (!frame && !ctx->last_frames--)
return 0;
if ((ret = ff_alloc_packet(avctx, avpkt, 87500 * avctx->channels)) < 0)
if ((ret = ff_alloc_packet(avctx, avpkt, 87500 * channels)) < 0)
return ret;
if (frame) {
@ -2149,7 +2140,7 @@ input_and_return:
ctx->number_of_frames = ctx->next_major_number_of_frames;
ctx->number_of_subblocks = ctx->next_major_number_of_frames + 1;
ctx->seq_channel_params = ctx->channel_params + ctx->seq_offset[seq_index] * ctx->avctx->channels;
ctx->seq_channel_params = ctx->channel_params + ctx->seq_offset[seq_index] * channels;
ctx->seq_decoding_params = ctx->decoding_params + ctx->seq_offset[seq_index];
@ -2157,7 +2148,7 @@ input_and_return:
ctx->number_of_samples = number_of_samples;
for (unsigned int index = 0; index < ctx->seq_size[seq_index]; index++) {
clear_channel_params(ctx->seq_channel_params + index * ctx->avctx->channels, ctx->avctx->channels);
clear_channel_params(ctx->seq_channel_params + index * channels, channels);
default_decoding_params(ctx, ctx->seq_decoding_params + index);
}
@ -2225,7 +2216,10 @@ const AVCodec ff_mlp_encoder = {
.capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_EXPERIMENTAL,
.sample_fmts = (const enum AVSampleFormat[]) {AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_NONE},
.supported_samplerates = (const int[]) {44100, 48000, 88200, 96000, 176400, 192000, 0},
#if FF_API_OLD_CHANNEL_LAYOUT
.channel_layouts = ff_mlp_channel_layouts,
#endif
.ch_layouts = ff_mlp_ch_layouts,
.caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
};
#endif
@ -2242,7 +2236,15 @@ const AVCodec ff_truehd_encoder = {
.capabilities = AV_CODEC_CAP_SMALL_LAST_FRAME | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_EXPERIMENTAL,
.sample_fmts = (const enum AVSampleFormat[]) {AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_NONE},
.supported_samplerates = (const int[]) {44100, 48000, 88200, 96000, 176400, 192000, 0},
#if FF_API_OLD_CHANNEL_LAYOUT
.channel_layouts = (const uint64_t[]) {AV_CH_LAYOUT_STEREO, AV_CH_LAYOUT_5POINT0_BACK, AV_CH_LAYOUT_5POINT1_BACK, 0},
#endif
.ch_layouts = (const AVChannelLayout[]) {
AV_CHANNEL_LAYOUT_STEREO,
AV_CHANNEL_LAYOUT_5POINT0_BACK,
AV_CHANNEL_LAYOUT_5POINT1_BACK,
{ 0 }
},
.caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
};
#endif

Write Preview
Loading…
Cancel
Save