From 9adc5d8bfec8e34234680e7f64e461fd28a77fd3 Mon Sep 17 00:00:00 2001 From: Paul B Mahol Date: Fri, 13 Oct 2023 12:23:34 +0200 Subject: [PATCH] avcodec/mlpenc: restructure code even more Implement lsb_bypass for lossless rematrix. --- libavcodec/mlpenc.c | 633 ++++++++++++++++++++++---------------------- 1 file changed, 317 insertions(+), 316 deletions(-) diff --git a/libavcodec/mlpenc.c b/libavcodec/mlpenc.c index b9a22dc4b2..88da6c56c8 100644 --- a/libavcodec/mlpenc.c +++ b/libavcodec/mlpenc.c @@ -38,6 +38,8 @@ #include "mlp.h" #include "lpc.h" +#define MAX_NCHANNELS (MAX_CHANNELS + 2) + #define MIN_HEADER_INTERVAL 8 #define MAX_HEADER_INTERVAL 128 @@ -66,11 +68,13 @@ typedef struct MatrixParams { uint8_t count; ///< number of matrices to apply uint8_t outch[MAX_MATRICES]; ///< output channel for each matrix - int32_t forco[MAX_MATRICES][MAX_CHANNELS+2]; ///< forward coefficients - int32_t coeff[MAX_MATRICES][MAX_CHANNELS+2]; ///< decoding coefficients + int32_t forco[MAX_MATRICES][MAX_NCHANNELS]; ///< forward coefficients + int32_t coeff[MAX_MATRICES][MAX_NCHANNELS]; ///< decoding coefficients uint8_t fbits[MAX_CHANNELS]; ///< fraction bits int8_t shift[MAX_CHANNELS]; ///< Left shift to apply to decoded PCM values to get final 24-bit output. + uint8_t lsb_bypass[MAX_MATRICES]; + int8_t bypassed_lsbs[MAX_MATRICES][MAX_BLOCKSIZE]; } MatrixParams; enum ParamFlags { @@ -93,6 +97,7 @@ typedef struct DecodingParams { MatrixParams matrix_params; uint8_t param_presence_flags; ///< Bitmask of which parameter sets are conveyed in a decoding parameter block. + int32_t sample_buffer[MAX_NCHANNELS][MAX_BLOCKSIZE]; } DecodingParams; typedef struct BestOffset { @@ -111,14 +116,15 @@ typedef struct BestOffset { typedef struct MLPBlock { unsigned int seq_size; + ChannelParams channel_params[MAX_CHANNELS]; DecodingParams decoding_params; int32_t lossless_check_data; ///< Array with lossless_check_data for each access unit. unsigned int max_output_bits; ///< largest output bit-depth BestOffset best_offset[MAX_CHANNELS][NUM_CODEBOOKS]; - ChannelParams channel_params[MAX_CHANNELS]; ChannelParams major_channel_params[MAX_CHANNELS]; ///< ChannelParams to be written to bitstream. DecodingParams major_decoding_params; ///< DecodingParams to be written to bitstream. int major_params_changed; ///< params_changed to be written to bitstream. + int32_t inout_buffer[MAX_NCHANNELS][MAX_BLOCKSIZE]; } MLPBlock; typedef struct MLPEncodeContext { @@ -127,6 +133,7 @@ typedef struct MLPEncodeContext { int max_restart_interval; ///< Max interval of access units in between two major frames. int min_restart_interval; ///< Min interval of access units in between two major frames. + int cur_restart_interval; int lpc_coeff_precision; int lpc_type; int lpc_passes; @@ -152,11 +159,6 @@ typedef struct MLPEncodeContext { int channel_occupancy; int summary_info; - int32_t *inout_buffer; ///< Pointer to data currently being read from lavc or written to bitstream. - int32_t *major_inout_buffer; ///< Buffer with all in/out data for one entire major frame interval. - int32_t *write_buffer; ///< Pointer to data currently being written to bitstream. - int32_t *sample_buffer; ///< Pointer to current access unit samples. - int32_t *major_scratch_buffer; ///< Scratch buffer big enough to fit all data for one entire major frame interval. int32_t last_frames; ///< Signal last frames. unsigned int major_number_of_frames; @@ -167,8 +169,6 @@ typedef struct MLPEncodeContext { unsigned int frame_index; ///< Index of current frame being encoded. - unsigned int one_sample_buffer_size; ///< Number of samples*channel for one access unit. - unsigned int restart_intervals; ///< Number of possible major frame sizes. uint16_t output_timing; ///< Timestamp of current access unit. @@ -185,28 +185,21 @@ typedef struct MLPEncodeContext { RestartHeader restart_header; MLPBlock b[MAX_HEADER_INTERVAL + 1]; + int32_t filter_state[NUM_FILTERS][MAX_HEADER_INTERVAL * MAX_BLOCKSIZE]; int32_t lpc_sample_buffer[MAX_HEADER_INTERVAL * MAX_BLOCKSIZE]; - int32_t filter_state_buffer[NUM_FILTERS][MAX_BLOCKSIZE * MAX_HEADER_INTERVAL]; unsigned int major_cur_subblock_index; unsigned int major_filter_state_subblock; unsigned int major_number_of_subblocks; - BestOffset (*cur_best_offset)[NUM_CODEBOOKS]; - ChannelParams *cur_channel_params; - DecodingParams *cur_decoding_params; RestartHeader *cur_restart_header; AudioFrameQueue afq; /* Analysis stage. */ unsigned int number_of_frames; - unsigned int number_of_samples; unsigned int number_of_subblocks; - const ChannelParams *prev_channel_params; - const DecodingParams *prev_decoding_params; - int shorten_by; LPCContext lpc_ctx; @@ -278,6 +271,9 @@ static int compare_matrix_params(MLPEncodeContext *ctx, const MatrixParams *prev if (prev->outch[mat] != mp->outch[mat]) return 1; + if (prev->lsb_bypass[mat] != mp->lsb_bypass[mat]) + return 1; + for (unsigned int channel = 0; channel < ctx->num_channels; channel++) if (prev->coeff[mat][channel] != mp->coeff[mat][channel]) return 1; @@ -289,13 +285,14 @@ static int compare_matrix_params(MLPEncodeContext *ctx, const MatrixParams *prev /** Compares two DecodingParams and ChannelParams structures to decide if a * new decoding params header has to be written. */ -static int compare_decoding_params(MLPEncodeContext *ctx) +static int compare_decoding_params(MLPEncodeContext *ctx, + unsigned int index) { - const DecodingParams *prev = ctx->prev_decoding_params; - DecodingParams *dp = ctx->cur_decoding_params; + const DecodingParams *prev = index ? &ctx->b[index-1].major_decoding_params : restart_decoding_params; + DecodingParams *dp = &ctx->b[index].major_decoding_params; const MatrixParams *prev_mp = &prev->matrix_params; MatrixParams *mp = &dp->matrix_params; - RestartHeader *rh = ctx->cur_restart_header; + RestartHeader *rh = ctx->cur_restart_header; int retval = 0; if (prev->param_presence_flags != dp->param_presence_flags) @@ -320,8 +317,8 @@ static int compare_decoding_params(MLPEncodeContext *ctx) } for (unsigned int ch = rh->min_channel; ch <= rh->max_channel; ch++) { - const ChannelParams *prev_cp = &ctx->prev_channel_params[ch]; - ChannelParams *cp = &ctx->cur_channel_params[ch]; + const ChannelParams *prev_cp = index ? &ctx->b[index-1].major_channel_params[ch] : &restart_channel_params[ch]; + ChannelParams *cp = &ctx->b[index].major_channel_params[ch]; if (!(retval & PARAM_FIR) && compare_filter_params(prev_cp, cp, FIR)) @@ -374,8 +371,10 @@ static void copy_matrix_params(MatrixParams *dst, MatrixParams *src) dst->coeff[count][channel] = src->coeff[count][channel]; } - for (unsigned int count = 0; count < MAX_MATRICES; count++) + for (unsigned int count = 0; count < MAX_MATRICES; count++) { dst->outch[count] = src->outch[count]; + dst->lsb_bypass[count] = src->lsb_bypass[count]; + } } } @@ -384,17 +383,17 @@ static void copy_restart_frame_params(MLPEncodeContext *ctx) for (unsigned int index = 0; index < ctx->number_of_subblocks; index++) { DecodingParams *dp = &ctx->b[index].decoding_params; - copy_matrix_params(&dp->matrix_params, &ctx->cur_decoding_params->matrix_params); + copy_matrix_params(&dp->matrix_params, &ctx->b[1].decoding_params.matrix_params); for (unsigned int channel = 0; channel < ctx->avctx->ch_layout.nb_channels; channel++) { ChannelParams *cp = &ctx->b[index].channel_params[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]; + dp->quant_step_size[channel] = ctx->b[1].decoding_params.quant_step_size[channel]; + dp->matrix_params.shift[channel] = ctx->b[1].decoding_params.matrix_params.shift[channel]; if (index) for (unsigned int filter = 0; filter < NUM_FILTERS; filter++) - copy_filter_params(cp, &ctx->cur_channel_params[channel], filter); + copy_filter_params(cp, &ctx->b[1].channel_params[channel], filter); } } } @@ -405,10 +404,11 @@ static void clear_decoding_params(DecodingParams *decoding_params) DecodingParams *dp = decoding_params; dp->param_presence_flags = 0xff; - dp->blocksize = 8; + dp->blocksize = 0; - memset(&dp->matrix_params , 0, sizeof(MatrixParams )); + memset(&dp->matrix_params, 0, sizeof(dp->matrix_params )); memset(dp->quant_step_size, 0, sizeof(dp->quant_step_size)); + memset(dp->sample_buffer, 0, sizeof(dp->sample_buffer )); } /** Clears a ChannelParams struct the way it should be after a restart header. */ @@ -427,12 +427,11 @@ static void clear_channel_params(ChannelParams *channel_params, int nb_channels) } /** Sets default vales in our encoder for a DecodingParams struct. */ -static void default_decoding_params(MLPEncodeContext *ctx, DecodingParams *decoding_params) +static void default_decoding_params(MLPEncodeContext *ctx, DecodingParams *dp) { - DecodingParams *dp = decoding_params; uint8_t param_presence_flags = 0; - clear_decoding_params(decoding_params); + clear_decoding_params(dp); param_presence_flags |= PARAM_BLOCKSIZE; param_presence_flags |= PARAM_MATRIX; @@ -480,7 +479,6 @@ static av_cold int mlp_encode_init(AVCodecContext *avctx) MLPEncodeContext *ctx = avctx->priv_data; RestartHeader *const rh = &ctx->restart_header; uint64_t channels_present; - size_t size; int ret; ctx->avctx = avctx; @@ -555,21 +553,10 @@ static av_cold int mlp_encode_init(AVCodecContext *avctx) ctx->input_timing = -avctx->frame_size; ctx->num_channels = avctx->ch_layout.nb_channels + 2; /* +2 noise channels */ - ctx->one_sample_buffer_size = avctx->frame_size - * ctx->num_channels; - ctx->min_restart_interval = ctx->max_restart_interval; + ctx->min_restart_interval = ctx->cur_restart_interval = ctx->max_restart_interval; ctx->restart_intervals = ctx->max_restart_interval / ctx->min_restart_interval; - size = ctx->one_sample_buffer_size * ctx->max_restart_interval; - ctx->major_scratch_buffer = av_calloc(size, sizeof(*ctx->major_scratch_buffer)); - if (!ctx->major_scratch_buffer) - return AVERROR(ENOMEM); - - ctx->major_inout_buffer = av_calloc(size, sizeof(*ctx->major_inout_buffer)); - if (!ctx->major_inout_buffer) - return AVERROR(ENOMEM); - ctx->num_substreams = 1; // TODO: change this after adding multi-channel support for TrueHD channels_present = av_channel_layout_subset(&avctx->ch_layout, ~(uint64_t)0); @@ -643,9 +630,7 @@ static av_cold int mlp_encode_init(AVCodecContext *avctx) /* FIXME: this works for 1 and 2 channels, but check for more */ rh->max_matrix_channel = rh->max_channel; - ctx->number_of_samples = avctx->frame_size * ctx->max_restart_interval; - - if ((ret = ff_lpc_init(&ctx->lpc_ctx, ctx->number_of_samples, + if ((ret = ff_lpc_init(&ctx->lpc_ctx, ctx->avctx->frame_size, MLP_MAX_LPC_ORDER, ctx->lpc_type)) < 0) return ret; @@ -779,9 +764,10 @@ static void write_restart_header(MLPEncodeContext *ctx, PutBitContext *pb) } /** Writes matrix params for all primitive matrices to the bitstream. */ -static void write_matrix_params(MLPEncodeContext *ctx, PutBitContext *pb) +static void write_matrix_params(MLPEncodeContext *ctx, + DecodingParams *dp, + PutBitContext *pb) { - DecodingParams *dp = ctx->cur_decoding_params; MatrixParams *mp = &dp->matrix_params; put_bits(pb, 4, mp->count); @@ -789,7 +775,7 @@ static void write_matrix_params(MLPEncodeContext *ctx, PutBitContext *pb) for (unsigned int mat = 0; mat < mp->count; mat++) { put_bits(pb, 4, mp->outch[mat]); /* matrix_out_ch */ put_bits(pb, 4, mp->fbits[mat]); - put_bits(pb, 1, 0 ); /* lsb_bypass */ + put_bits(pb, 1, mp->lsb_bypass[mat]); for (unsigned int channel = 0; channel < ctx->num_channels; channel++) { int32_t coeff = mp->coeff[mat][channel]; @@ -808,15 +794,17 @@ static void write_matrix_params(MLPEncodeContext *ctx, PutBitContext *pb) } /** Writes filter parameters for one filter to the bitstream. */ -static void write_filter_params(MLPEncodeContext *ctx, PutBitContext *pb, +static void write_filter_params(MLPEncodeContext *ctx, + ChannelParams *cp, + PutBitContext *pb, unsigned int channel, unsigned int filter) { - FilterParams *fp = &ctx->cur_channel_params[channel].filter_params[filter]; + FilterParams *fp = &cp->filter_params[filter]; put_bits(pb, 4, fp->order); if (fp->order > 0) { - int32_t *fcoeff = ctx->cur_channel_params[channel].coeff[filter]; + int32_t *fcoeff = cp->coeff[filter]; put_bits(pb, 4, fp->shift ); put_bits(pb, 5, fp->coeff_bits ); @@ -835,10 +823,11 @@ static void write_filter_params(MLPEncodeContext *ctx, PutBitContext *pb, * usually at almost every frame. */ static void write_decoding_params(MLPEncodeContext *ctx, PutBitContext *pb, - int params_changed) + int params_changed, + unsigned int subblock_index) { - DecodingParams *dp = ctx->cur_decoding_params; - RestartHeader *rh = ctx->cur_restart_header; + DecodingParams *dp = &ctx->b[subblock_index].major_decoding_params; + RestartHeader *rh = ctx->cur_restart_header; MatrixParams *mp = &dp->matrix_params; if (dp->param_presence_flags != PARAMS_DEFAULT && @@ -861,7 +850,7 @@ static void write_decoding_params(MLPEncodeContext *ctx, PutBitContext *pb, if (dp->param_presence_flags & PARAM_MATRIX) { if (params_changed & PARAM_MATRIX) { put_bits(pb, 1, 1); - write_matrix_params(ctx, pb); + write_matrix_params(ctx, dp, pb); } else { put_bits(pb, 1, 0); } @@ -888,7 +877,7 @@ static void write_decoding_params(MLPEncodeContext *ctx, PutBitContext *pb, } for (unsigned int ch = rh->min_channel; ch <= rh->max_channel; ch++) { - ChannelParams *cp = &ctx->cur_channel_params[ch]; + ChannelParams *cp = &ctx->b[subblock_index].major_channel_params[ch]; if (dp->param_presence_flags & 0xF) { put_bits(pb, 1, 1); @@ -896,7 +885,7 @@ static void write_decoding_params(MLPEncodeContext *ctx, PutBitContext *pb, if (dp->param_presence_flags & PARAM_FIR) { if (params_changed & PARAM_FIR) { put_bits(pb, 1, 1); - write_filter_params(ctx, pb, ch, FIR); + write_filter_params(ctx, cp, pb, ch, FIR); } else { put_bits(pb, 1, 0); } @@ -905,7 +894,7 @@ static void write_decoding_params(MLPEncodeContext *ctx, PutBitContext *pb, if (dp->param_presence_flags & PARAM_IIR) { if (params_changed & PARAM_IIR) { put_bits(pb, 1, 1); - write_filter_params(ctx, pb, ch, IIR); + write_filter_params(ctx, cp, pb, ch, IIR); } else { put_bits(pb, 1, 0); } @@ -934,17 +923,18 @@ static void write_decoding_params(MLPEncodeContext *ctx, PutBitContext *pb, /** Writes the residuals to the bitstream. That is, the VLC codes from the * codebooks (if any is used), and then the residual. */ -static void write_block_data(MLPEncodeContext *ctx, PutBitContext *pb) +static void write_block_data(MLPEncodeContext *ctx, PutBitContext *pb, + unsigned int subblock_index) { - DecodingParams *dp = ctx->cur_decoding_params; - RestartHeader *rh = ctx->cur_restart_header; - int32_t *sample_buffer = ctx->write_buffer; + RestartHeader *rh = ctx->cur_restart_header; + DecodingParams *dp = &ctx->b[subblock_index].major_decoding_params; + MatrixParams *mp = &dp->matrix_params; int32_t sign_huff_offset[MAX_CHANNELS]; int codebook_index [MAX_CHANNELS]; int lsb_bits [MAX_CHANNELS]; for (unsigned int ch = rh->min_channel; ch <= rh->max_channel; ch++) { - ChannelParams *cp = &ctx->cur_channel_params[ch]; + ChannelParams *cp = &ctx->b[subblock_index].major_channel_params[ch]; int sign_shift; lsb_bits [ch] = cp->huff_lsbs - dp->quant_step_size[ch]; @@ -962,8 +952,17 @@ static void write_block_data(MLPEncodeContext *ctx, PutBitContext *pb) } for (unsigned int i = 0; i < dp->blocksize; i++) { + for (unsigned int mat = 0; mat < mp->count; mat++) { + if (mp->lsb_bypass[mat]) { + const int8_t *bypassed_lsbs = mp->bypassed_lsbs[mat]; + + put_bits(pb, 1, bypassed_lsbs[i]); + } + } + for (unsigned int ch = rh->min_channel; ch <= rh->max_channel; ch++) { - int32_t sample = *sample_buffer++ >> dp->quant_step_size[ch]; + int32_t *sample_buffer = dp->sample_buffer[ch]; + int32_t sample = sample_buffer[i] >> dp->quant_step_size[ch]; sample -= sign_huff_offset[ch]; if (codebook_index[ch] >= 0) { @@ -975,10 +974,7 @@ static void write_block_data(MLPEncodeContext *ctx, PutBitContext *pb) put_bits(pb, lsb_bits[ch], sample); } - sample_buffer += 2; /* noise channels */ } - - ctx->write_buffer = sample_buffer; } /** Writes the substream data to the bitstream. */ @@ -989,7 +985,7 @@ static uint8_t *write_substr(MLPEncodeContext *ctx, uint8_t *buf, int buf_size, int32_t *lossless_check_data = &ctx->b[ctx->frame_index].lossless_check_data; unsigned int cur_subblock_index = ctx->major_cur_subblock_index; unsigned int num_subblocks = ctx->major_filter_state_subblock; - RestartHeader *rh = &ctx->restart_header; + RestartHeader *rh = &ctx->restart_header; int substr_restart_frame = restart_frame; uint8_t parity, checksum; PutBitContext pb; @@ -1001,12 +997,7 @@ static uint8_t *write_substr(MLPEncodeContext *ctx, uint8_t *buf, int buf_size, init_put_bits(&pb, buf, buf_size); for (unsigned int subblock = 0; subblock <= num_subblocks; subblock++) { - unsigned int subblock_index; - - subblock_index = cur_subblock_index++; - - ctx->cur_decoding_params = &ctx->b[subblock_index].major_decoding_params; - ctx->cur_channel_params = ctx->b[subblock_index].major_channel_params; + unsigned int subblock_index = cur_subblock_index++; params_changed = ctx->b[subblock_index].major_params_changed; @@ -1022,12 +1013,13 @@ static uint8_t *write_substr(MLPEncodeContext *ctx, uint8_t *buf, int buf_size, put_bits(&pb, 1, 0); } - write_decoding_params(ctx, &pb, params_changed); + write_decoding_params(ctx, &pb, params_changed, + subblock_index); } else { put_bits(&pb, 1, 0); } - write_block_data(ctx, &pb); + write_block_data(ctx, &pb, subblock_index); put_bits(&pb, 1, !substr_restart_frame); @@ -1159,23 +1151,21 @@ static void input_data_internal(MLPEncodeContext *ctx, const uint8_t *samples, const int32_t *samples_32 = (const int32_t *) samples; const int16_t *samples_16 = (const int16_t *) samples; RestartHeader *rh = &ctx->restart_header; - int32_t *sample_buffer = ctx->inout_buffer; int32_t temp_lossless_check_data = 0; uint32_t bits = 0; for (int i = 0; i < nb_samples; i++) { - for (unsigned int channel = 0; channel <= rh->max_channel; channel++) { + for (unsigned int ch = 0; ch <= rh->max_channel; ch++) { + int32_t *sample_buffer = ctx->b[ctx->frame_index].inout_buffer[ch]; int32_t sample; sample = is24 ? *samples_32++ >> 8 : *samples_16++ * 256; bits = FFMAX(number_sbits(sample), bits); - temp_lossless_check_data ^= (sample & 0x00ffffff) << channel; - *sample_buffer++ = sample; + temp_lossless_check_data ^= (sample & 0x00ffffff) << ch; + sample_buffer[i] = sample; } - - sample_buffer += 2; /* noise channels */ } ctx->b[ctx->frame_index].max_output_bits = bits; @@ -1191,17 +1181,25 @@ static void input_data(MLPEncodeContext *ctx, const void *samples, int nb_sample static void input_to_sample_buffer(MLPEncodeContext *ctx) { - int32_t *sample_buffer = ctx->sample_buffer; - for (unsigned int index = 0; index < ctx->number_of_frames; index++) { - unsigned int cur_index = (ctx->frame_index + index + 1) % ctx->max_restart_interval; - 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->ch_layout.nb_channels; channel++) - *sample_buffer++ = *input_buffer++; - sample_buffer += 2; /* noise_channels */ - input_buffer += 2; /* noise_channels */ + unsigned int cur_index = (ctx->frame_index + index + 1) % ctx->cur_restart_interval; + DecodingParams *dp = &ctx->b[index+1].decoding_params; + + for (unsigned int ch = 0; ch < ctx->avctx->ch_layout.nb_channels; ch++) { + const int32_t *input_buffer = ctx->b[cur_index].inout_buffer[ch]; + int32_t *sample_buffer = dp->sample_buffer[ch]; + int off = 0; + + if (dp->blocksize < ctx->avctx->frame_size) { + DecodingParams *dp = &ctx->b[index].decoding_params; + int32_t *sample_buffer = dp->sample_buffer[ch]; + for (unsigned int i = 0; i < dp->blocksize; i++) + sample_buffer[i] = input_buffer[i]; + off = dp->blocksize; + } + + for (unsigned int i = 0; i < dp->blocksize; i++) + sample_buffer[i] = input_buffer[i + off]; } } } @@ -1221,23 +1219,25 @@ static int number_trailing_zeroes(int32_t sample, unsigned int max, unsigned int */ static void determine_quant_step_size(MLPEncodeContext *ctx) { - DecodingParams *dp = ctx->cur_decoding_params; - RestartHeader *rh = ctx->cur_restart_header; - MatrixParams *mp = &dp->matrix_params; - int32_t *sample_buffer = ctx->sample_buffer; + RestartHeader *rh = ctx->cur_restart_header; + DecodingParams *dp1 = &ctx->b[1].decoding_params; int32_t sample_mask[MAX_CHANNELS]; - memset(sample_mask, 0x00, sizeof(sample_mask)); + memset(sample_mask, 0, sizeof(sample_mask)); - for (unsigned int i = 0; i < ctx->number_of_samples; i++) { - for (unsigned int channel = 0; channel <= rh->max_channel; channel++) - sample_mask[channel] |= *sample_buffer++; + for (unsigned int j = 0; j <= ctx->cur_restart_interval; j++) { + DecodingParams *dp = &ctx->b[j].decoding_params; - sample_buffer += 2; /* noise channels */ + for (unsigned int ch = 0; ch <= rh->max_channel; ch++) { + int32_t *sample_buffer = dp->sample_buffer[ch]; + + for (unsigned int i = 0; i < dp->blocksize; i++) + sample_mask[ch] |= sample_buffer[i]; + } } for (unsigned int channel = 0; channel <= rh->max_channel; channel++) - dp->quant_step_size[channel] = number_trailing_zeroes(sample_mask[channel], 15, 0) - mp->shift[channel]; + dp1->quant_step_size[channel] = number_trailing_zeroes(sample_mask[channel], 15, 0); } /** Determines the smallest number of bits needed to encode the filter @@ -1271,7 +1271,7 @@ static void set_filter_params(MLPEncodeContext *ctx, unsigned int channel, unsigned int filter, int clear_filter) { - ChannelParams *cp = &ctx->cur_channel_params[channel]; + ChannelParams *cp = &ctx->b[1].channel_params[channel]; FilterParams *fp = &cp->filter_params[filter]; if (clear_filter) { @@ -1280,21 +1280,26 @@ static void set_filter_params(MLPEncodeContext *ctx, fp->order = 0; } else if (filter == FIR) { const int max_order = MAX_FIR_ORDER; - int32_t *sample_buffer = ctx->sample_buffer + channel; int32_t coefs[MAX_LPC_ORDER][MAX_LPC_ORDER]; int32_t *lpc_samples = ctx->lpc_sample_buffer; - int32_t *fcoeff = ctx->cur_channel_params[channel].coeff[filter]; + int32_t *fcoeff = cp->coeff[filter]; int shift[MAX_LPC_ORDER]; int order; - for (unsigned int i = 0; i < ctx->number_of_samples; i++) { - *lpc_samples++ = *sample_buffer; - sample_buffer += ctx->num_channels; + for (unsigned int j = 0; j <= ctx->cur_restart_interval; j++) { + DecodingParams *dp = &ctx->b[j].decoding_params; + int32_t *sample_buffer = dp->sample_buffer[channel]; + + for (unsigned int i = 0; i < dp->blocksize; i++) + lpc_samples[i] = sample_buffer[i]; + lpc_samples += dp->blocksize; } order = ff_lpc_calc_coefs(&ctx->lpc_ctx, ctx->lpc_sample_buffer, - ctx->number_of_samples, MLP_MIN_LPC_ORDER, - max_order, ctx->lpc_coeff_precision, coefs, shift, ctx->lpc_type, ctx->lpc_passes, + lpc_samples - ctx->lpc_sample_buffer, + MLP_MIN_LPC_ORDER, max_order, + ctx->lpc_coeff_precision, + coefs, shift, ctx->lpc_type, ctx->lpc_passes, ctx->prediction_order, MLP_MIN_LPC_SHIFT, MLP_MAX_LPC_SHIFT, MLP_MIN_LPC_SHIFT); @@ -1326,53 +1331,53 @@ static int estimate_coeff(MLPEncodeContext *ctx, MatrixParams *mp, unsigned int ch0, unsigned int ch1) { - const int number_of_samples = ctx->number_of_samples; - const int num_channels = ctx->num_channels; int first = 1, x, x0; - const int32_t *ch[2]; int64_t g = 0, g0 = 0; - ch[0] = ctx->sample_buffer + ch0; - ch[1] = ctx->sample_buffer + ch1; + for (int j = 0; j <= ctx->cur_restart_interval; j++) { + DecodingParams *dp = &ctx->b[j].decoding_params; + const int32_t *ch[2]; - for (int n = 0, i = 0; n < number_of_samples; n++) { - int64_t c0, c1; - int32_t a0, a1; + ch[0] = dp->sample_buffer[ch0]; + ch[1] = dp->sample_buffer[ch1]; - c0 = ch[0][i]; - c1 = ch[1][i]; + for (int i = 0; i < dp->blocksize; i++) { + int64_t c0, c1; + int32_t a0, a1; - if (!c0 && !c1) - goto next; + c0 = ch[0][i]; + c1 = ch[1][i]; - if (!c0 || !c1) { - g0 = 0; - break; - } + if (!c0 && !c1) + continue; - a0 = FFABS(c0); - a1 = FFABS(c1); + if (!c0 || !c1) { + g0 = 0; + goto end; + } - if (a0 >= a1) { - g = (c1 * (1 << 14)) / c0; - x = ch1; - } else if (a0 < a1) { - g = (c0 * (1 << 14)) / c1; - x = ch0; - } + a0 = FFABS(c0); + a1 = FFABS(c1); - if (first) { - g0 = g; - x0 = x; - first = 0; - } else if (g != g0 || x != x0) { - g0 = 0; - break; - } + if (a0 >= a1) { + g = (c1 * (1 << 14)) / c0; + x = ch1; + } else if (a0 < a1) { + g = (c0 * (1 << 14)) / c1; + x = ch0; + } -next: - i += num_channels; + if (first) { + g0 = g; + x0 = x; + first = 0; + } else if (g != g0 || x != x0) { + g0 = 0; + goto end; + } + } } +end: if (g0) { mp->outch[0] = (x0 == ch0) ? ch0 : ch1; @@ -1383,9 +1388,6 @@ next: mp->forco[0][ch0] = 0; mp->forco[0][ch1] = 0; - mp->coeff[0][num_channels - 2] = mp->coeff[0][num_channels - 1] = 0; - mp->forco[0][num_channels - 2] = mp->forco[0][num_channels - 1] = 0; - return 1; } @@ -1395,9 +1397,10 @@ next: /** Determines how many fractional bits are needed to encode matrix * coefficients. Also shifts the coefficients to fit within 2.14 bits. */ -static void code_matrix_coeffs(MLPEncodeContext *ctx, unsigned int mat) +static void code_matrix_coeffs(MLPEncodeContext *ctx, + DecodingParams *dp, + unsigned int mat) { - DecodingParams *dp = ctx->cur_decoding_params; MatrixParams *mp = &dp->matrix_params; int32_t coeff_mask = 0; @@ -1411,9 +1414,8 @@ static void code_matrix_coeffs(MLPEncodeContext *ctx, unsigned int mat) /** Determines best coefficients to use for the lossless matrix. */ static void lossless_matrix_coeffs(MLPEncodeContext *ctx) { - DecodingParams *dp = ctx->cur_decoding_params; + DecodingParams *dp = &ctx->b[1].decoding_params; MatrixParams *mp = &dp->matrix_params; - unsigned int shift = 0; mp->count = 0; if (ctx->num_channels - 2 != 2) @@ -1422,10 +1424,7 @@ static void lossless_matrix_coeffs(MLPEncodeContext *ctx) mp->count = estimate_coeff(ctx, mp, 0, 1); for (int mat = 0; mat < mp->count; mat++) - code_matrix_coeffs(ctx, mat); - - for (unsigned int channel = 0; channel < ctx->num_channels; channel++) - mp->shift[channel] = shift; + code_matrix_coeffs(ctx, dp, mat); } /** Min and max values that can be encoded with each codebook. The values for @@ -1441,11 +1440,11 @@ static const int8_t codebook_extremes[3][2] = { * codebooks and a specified offset. */ static void no_codebook_bits_offset(MLPEncodeContext *ctx, + DecodingParams *dp, unsigned int channel, int32_t offset, int32_t min, int32_t max, BestOffset *bo) { - DecodingParams *dp = ctx->cur_decoding_params; int32_t unsign = 0; int lsb_bits; @@ -1470,11 +1469,11 @@ static void no_codebook_bits_offset(MLPEncodeContext *ctx, * codebooks. */ static void no_codebook_bits(MLPEncodeContext *ctx, + DecodingParams *dp, unsigned int channel, int32_t min, int32_t max, BestOffset *bo) { - DecodingParams *dp = ctx->cur_decoding_params; int32_t offset, unsign = 0; uint8_t lsb_bits; @@ -1507,14 +1506,14 @@ static void no_codebook_bits(MLPEncodeContext *ctx, * given codebook and a given offset. */ static inline void codebook_bits_offset(MLPEncodeContext *ctx, + DecodingParams *dp, unsigned int channel, int codebook, int32_t sample_min, int32_t sample_max, int32_t offset, BestOffset *bo) { int32_t codebook_min = codebook_extremes[codebook][0]; int32_t codebook_max = codebook_extremes[codebook][1]; - int32_t *sample_buffer = ctx->sample_buffer + channel; - DecodingParams *dp = ctx->cur_decoding_params; + int32_t *sample_buffer = dp->sample_buffer[channel]; int codebook_offset = 7 + (2 - codebook); int32_t unsign_offset = offset; uint32_t bitcount = 0; @@ -1540,7 +1539,7 @@ static inline void codebook_bits_offset(MLPEncodeContext *ctx, } for (int i = 0; i < dp->blocksize; i++) { - int32_t sample = *sample_buffer >> dp->quant_step_size[channel]; + int32_t sample = sample_buffer[i] >> dp->quant_step_size[channel]; int temp_min, temp_max; sample -= unsign_offset; @@ -1556,8 +1555,6 @@ static inline void codebook_bits_offset(MLPEncodeContext *ctx, sample >>= lsb_bits; bitcount += ff_mlp_huffman_tables[codebook][sample + codebook_offset][1]; - - sample_buffer += ctx->num_channels; } bo->offset = offset; @@ -1571,6 +1568,7 @@ static inline void codebook_bits_offset(MLPEncodeContext *ctx, * given codebook. Searches for the best offset to minimize the bits. */ static inline void codebook_bits(MLPEncodeContext *ctx, + DecodingParams *dp, unsigned int channel, int codebook, int offset, int32_t min, int32_t max, BestOffset *bo, int direction) @@ -1585,7 +1583,7 @@ static inline void codebook_bits(MLPEncodeContext *ctx, while (offset <= offset_max && offset >= offset_min) { BestOffset temp_bo; - codebook_bits_offset(ctx, channel, codebook, + codebook_bits_offset(ctx, dp, channel, codebook, min, max, offset, &temp_bo); @@ -1612,56 +1610,57 @@ static inline void codebook_bits(MLPEncodeContext *ctx, */ static void determine_bits(MLPEncodeContext *ctx) { - DecodingParams *dp = ctx->cur_decoding_params; - RestartHeader *rh = ctx->cur_restart_header; - - for (unsigned int channel = 0; channel <= rh->max_channel; channel++) { - ChannelParams *cp = &ctx->cur_channel_params[channel]; - int32_t *sample_buffer = ctx->sample_buffer + channel; - int32_t min = INT32_MAX, max = INT32_MIN; - int no_filters_used = !cp->filter_params[FIR].order; - int average = 0; - int offset = 0; - - /* Determine extremes and average. */ - for (int i = 0; i < dp->blocksize; i++) { - int32_t sample = *sample_buffer >> dp->quant_step_size[channel]; - if (sample < min) - min = sample; - if (sample > max) - max = sample; - average += sample; - sample_buffer += ctx->num_channels; - } - average /= dp->blocksize; + RestartHeader *rh = ctx->cur_restart_header; + for (unsigned int index = 0; index < ctx->number_of_subblocks; index++) { + DecodingParams *dp = &ctx->b[index].decoding_params; - /* If filtering is used, we always set the offset to zero, otherwise - * we search for the offset that minimizes the bitcount. */ - if (no_filters_used) { - no_codebook_bits(ctx, channel, min, max, &ctx->cur_best_offset[channel][0]); - offset = av_clip(average, HUFF_OFFSET_MIN, HUFF_OFFSET_MAX); - } else { - no_codebook_bits_offset(ctx, channel, offset, min, max, &ctx->cur_best_offset[channel][0]); - } + for (unsigned int channel = 0; channel <= rh->max_channel; channel++) { + ChannelParams *cp = &ctx->b[index].channel_params[channel]; + int32_t *sample_buffer = dp->sample_buffer[channel]; + int32_t min = INT32_MAX, max = INT32_MIN; + int no_filters_used = !cp->filter_params[FIR].order; + int average = 0; + int offset = 0; + + /* Determine extremes and average. */ + for (int i = 0; i < dp->blocksize; i++) { + int32_t sample = sample_buffer[i] >> dp->quant_step_size[channel]; + if (sample < min) + min = sample; + if (sample > max) + max = sample; + average += sample; + } + average /= dp->blocksize; + + /* If filtering is used, we always set the offset to zero, otherwise + * we search for the offset that minimizes the bitcount. */ + if (no_filters_used) { + no_codebook_bits(ctx, dp, channel, min, max, &ctx->b[index].best_offset[channel][0]); + offset = av_clip(average, HUFF_OFFSET_MIN, HUFF_OFFSET_MAX); + } else { + no_codebook_bits_offset(ctx, dp, channel, offset, min, max, &ctx->b[index].best_offset[channel][0]); + } - for (int i = 1; i < NUM_CODEBOOKS; i++) { - BestOffset temp_bo = { 0, UINT32_MAX, 0, 0, 0, }; - int32_t offset_max; + for (int i = 1; i < NUM_CODEBOOKS; i++) { + BestOffset temp_bo = { 0, UINT32_MAX, 0, 0, 0, }; + int32_t offset_max; - codebook_bits_offset(ctx, channel, i - 1, - min, max, offset, - &temp_bo); + codebook_bits_offset(ctx, dp, channel, i - 1, + min, max, offset, + &temp_bo); - if (no_filters_used) { - offset_max = temp_bo.max; + if (no_filters_used) { + offset_max = temp_bo.max; - codebook_bits(ctx, channel, i - 1, temp_bo.min - 1, - min, max, &temp_bo, 0); - codebook_bits(ctx, channel, i - 1, offset_max + 1, - min, max, &temp_bo, 1); - } + codebook_bits(ctx, dp, channel, i - 1, temp_bo.min - 1, + min, max, &temp_bo, 0); + codebook_bits(ctx, dp, channel, i - 1, offset_max + 1, + min, max, &temp_bo, 1); + } - ctx->cur_best_offset[channel][i] = temp_bo; + ctx->b[index].best_offset[channel][i] = temp_bo; + } } } } @@ -1682,34 +1681,40 @@ static void determine_bits(MLPEncodeContext *ctx) */ static int apply_filter(MLPEncodeContext *ctx, unsigned int channel) { - ChannelParams *cp = &ctx->cur_channel_params[channel]; + DecodingParams *dp = &ctx->b[1].decoding_params; + ChannelParams *cp = &ctx->b[1].channel_params[channel]; FilterParams *fp[NUM_FILTERS] = { &cp->filter_params[FIR], &cp->filter_params[IIR], }; const uint8_t codebook = cp->codebook; - int32_t mask = MSB_MASK(ctx->cur_decoding_params->quant_step_size[channel]); - int32_t *sample_buffer = ctx->sample_buffer + channel; - unsigned int number_of_samples = ctx->number_of_samples; + int32_t mask = MSB_MASK(dp->quant_step_size[channel]); + int32_t *sample_buffer = ctx->b[0].decoding_params.sample_buffer[channel]; unsigned int filter_shift = fp[FIR]->shift; + int32_t *filter_state[NUM_FILTERS] = { ctx->filter_state[FIR], + ctx->filter_state[IIR], }; + int i, j = 1, k = 0; - for (int i = 0; i < 8; i++) { - ctx->filter_state_buffer[FIR][i] = *sample_buffer; - ctx->filter_state_buffer[IIR][i] = *sample_buffer; - - sample_buffer += ctx->num_channels; + for (i = 0; i < 8; i++) { + filter_state[FIR][i] = sample_buffer[i]; + filter_state[IIR][i] = sample_buffer[i]; } - for (int i = 8; i < number_of_samples; i++) { - int32_t sample = *sample_buffer; + while (1) { + int32_t *sample_buffer = ctx->b[j].decoding_params.sample_buffer[channel]; + unsigned int blocksize = ctx->b[j].decoding_params.blocksize; + int32_t sample, residual; int64_t accum = 0; - int32_t residual; + + if (!blocksize) + break; for (int filter = 0; filter < NUM_FILTERS; filter++) { int32_t *fcoeff = cp->coeff[filter]; for (unsigned int order = 0; order < fp[filter]->order; order++) - accum += (int64_t)ctx->filter_state_buffer[filter][i - 1 - order] * - fcoeff[order]; + accum += (int64_t)filter_state[filter][i - 1 - order] * + fcoeff[order]; } + sample = sample_buffer[k]; accum >>= filter_shift; residual = sample - (accum & mask); @@ -1718,17 +1723,25 @@ static int apply_filter(MLPEncodeContext *ctx, unsigned int channel) residual > SAMPLE_MAX(24))) return -1; - ctx->filter_state_buffer[FIR][i] = sample; - ctx->filter_state_buffer[IIR][i] = residual; + filter_state[FIR][i] = sample; + filter_state[IIR][i] = residual; - sample_buffer += ctx->num_channels; + i++; + k++; + if (k >= blocksize) { + k = 0; + j++; + if (j > ctx->cur_restart_interval) + break; + } } - sample_buffer = ctx->sample_buffer + channel; - for (int i = 0; i < number_of_samples; i++) { - *sample_buffer = ctx->filter_state_buffer[IIR][i]; + for (int l = 0, j = 0; j <= ctx->cur_restart_interval; j++) { + int32_t *sample_buffer = ctx->b[j].decoding_params.sample_buffer[channel]; + unsigned int blocksize = ctx->b[j].decoding_params.blocksize; - sample_buffer += ctx->num_channels; + for (int i = 0; i < blocksize; i++, l++) + sample_buffer[i] = filter_state[IIR][l]; } return 0; @@ -1752,18 +1765,21 @@ static void apply_filters(MLPEncodeContext *ctx) /** Generates two noise channels worth of data. */ static void generate_2_noise_channels(MLPEncodeContext *ctx) { - int32_t *sample_buffer = ctx->sample_buffer + ctx->num_channels - 2; RestartHeader *rh = ctx->cur_restart_header; uint32_t seed = rh->noisegen_seed; - for (unsigned int i = 0; i < ctx->number_of_samples; i++) { - uint16_t seed_shr7 = seed >> 7; - *sample_buffer++ = ((int8_t)(seed >> 15)) * (1 << rh->noise_shift); - *sample_buffer++ = ((int8_t) seed_shr7) * (1 << rh->noise_shift); + for (unsigned int j = 0; j <= ctx->cur_restart_interval; j++) { + DecodingParams *dp = &ctx->b[j].decoding_params; + int32_t *sample_buffer2 = dp->sample_buffer[ctx->num_channels-2]; + int32_t *sample_buffer1 = dp->sample_buffer[ctx->num_channels-1]; - seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5); + for (unsigned int i = 0; i < dp->blocksize; i++) { + uint16_t seed_shr7 = seed >> 7; + sample_buffer2[i] = ((int8_t)(seed >> 15)) * (1 << rh->noise_shift); + sample_buffer1[i] = ((int8_t) seed_shr7) * (1 << rh->noise_shift); - sample_buffer += ctx->num_channels - 2; + seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5); + } } rh->noisegen_seed = seed & ((1 << 24)-1); @@ -1772,27 +1788,55 @@ static void generate_2_noise_channels(MLPEncodeContext *ctx) /** Rematrixes all channels using chosen coefficients. */ static void rematrix_channels(MLPEncodeContext *ctx) { - DecodingParams *dp = ctx->cur_decoding_params; - MatrixParams *mp = &dp->matrix_params; - int32_t *sample_buffer = ctx->sample_buffer; + DecodingParams *dp1 = &ctx->b[1].decoding_params; + MatrixParams *mp1 = &dp1->matrix_params; unsigned int maxchan = ctx->num_channels; + int32_t input_samples[MAX_NCHANNELS]; + uint8_t lsb_bypass[MAX_MATRICES] = { 0 }; - for (unsigned int mat = 0; mat < mp->count; mat++) { - unsigned int outch = mp->outch[mat]; + for (unsigned int j = 0; j <= ctx->cur_restart_interval; j++) { + DecodingParams *dp = &ctx->b[j].decoding_params; + MatrixParams *mp = &dp->matrix_params; - sample_buffer = ctx->sample_buffer; - for (unsigned int i = 0; i < ctx->number_of_samples; i++) { - int64_t accum = 0; + for (unsigned int i = 0; i < dp->blocksize; i++) { + for (unsigned int ch = 0; ch < maxchan; ch++) + input_samples[ch] = dp->sample_buffer[ch][i]; - for (unsigned int src_ch = 0; src_ch < maxchan; src_ch++) { - int32_t sample = *(sample_buffer + src_ch); - accum += (int64_t) sample * mp->forco[mat][src_ch]; + for (unsigned int mat = 0; mat < mp1->count; mat++) { + unsigned int outch = mp1->outch[mat]; + int64_t accum = 0; + + for (unsigned int ch = 0; ch < maxchan; ch++) { + int32_t sample = input_samples[ch]; + + accum += (int64_t)sample * mp1->forco[mat][ch]; + } + + dp->sample_buffer[outch][i] = accum >> 14; } - sample_buffer[outch] = accum >> 14; - sample_buffer += ctx->num_channels; + for (unsigned int mat = 0; mat < mp1->count; mat++) { + int8_t *bypassed_lsbs = mp->bypassed_lsbs[mat]; + unsigned int outch = mp1->outch[mat]; + int64_t accum = 0; + int8_t bit; + + for (unsigned int ch = 0; ch < maxchan; ch++) { + int32_t sample = dp->sample_buffer[ch][i]; + + accum += (int64_t)sample * mp1->coeff[mat][ch]; + } + + bit = (accum >> 14) != input_samples[outch]; + + bypassed_lsbs[i] = bit; + lsb_bypass[mat] |= bit; + } } } + + for (unsigned int mat = 0; mat < mp1->count; mat++) + mp1->lsb_bypass[mat] = lsb_bypass[mat]; } /**************************************************************************** @@ -1945,18 +1989,8 @@ static void set_major_params(MLPEncodeContext *ctx) ctx->cur_restart_header = &ctx->restart_header; - ctx->prev_decoding_params = restart_decoding_params; - ctx->prev_channel_params = restart_channel_params; - - for (unsigned int index = 0; index < MAX_HEADER_INTERVAL + 1; index++) { - ctx->cur_decoding_params = &ctx->b[index].major_decoding_params; - ctx->cur_channel_params = ctx->b[index].major_channel_params; - - ctx->b[index].major_params_changed = compare_decoding_params(ctx); - - ctx->prev_decoding_params = ctx->cur_decoding_params; - ctx->prev_channel_params = ctx->cur_channel_params; - } + for (unsigned int index = 0; index <= ctx->cur_restart_interval; index++) + ctx->b[index].major_params_changed = compare_decoding_params(ctx, index); ctx->major_number_of_subblocks = ctx->number_of_subblocks; ctx->major_filter_state_subblock = 1; @@ -1966,23 +2000,12 @@ static void set_major_params(MLPEncodeContext *ctx) static void analyze_sample_buffer(MLPEncodeContext *ctx) { ctx->cur_restart_header = &ctx->restart_header; - ctx->cur_decoding_params = &ctx->b[1].decoding_params; - ctx->cur_channel_params = ctx->b[1].channel_params; - - determine_quant_step_size(ctx); - generate_2_noise_channels(ctx); - lossless_matrix_coeffs (ctx); - rematrix_channels (ctx); - determine_filters (ctx); - apply_filters (ctx); - - copy_restart_frame_params(ctx); /* Copy frame_size from frames 0...max to decoding_params 1...max + 1 * decoding_params[0] is for the filter state subblock. */ for (unsigned int index = 0; index < ctx->number_of_frames; index++) { - DecodingParams *dp = &ctx->b[index + 1].decoding_params; + DecodingParams *dp = &ctx->b[index+1].decoding_params; dp->blocksize = ctx->avctx->frame_size; } /* The official encoder seems to always encode a filter state subblock @@ -1992,29 +2015,27 @@ static void analyze_sample_buffer(MLPEncodeContext *ctx) ctx->b[0].decoding_params.blocksize = 8; ctx->b[1].decoding_params.blocksize -= 8; - for (unsigned int index = 0; index < ctx->number_of_subblocks; index++) { - ctx->cur_decoding_params = &ctx->b[index].decoding_params; - ctx->cur_channel_params = ctx->b[index].channel_params; - ctx->cur_best_offset = ctx->b[index].best_offset; - determine_bits(ctx); - ctx->sample_buffer += ctx->cur_decoding_params->blocksize * ctx->num_channels; - } + input_to_sample_buffer (ctx); + generate_2_noise_channels(ctx); + lossless_matrix_coeffs (ctx); + rematrix_channels (ctx); + determine_quant_step_size(ctx); + determine_filters (ctx); + apply_filters (ctx); + + copy_restart_frame_params(ctx); + + determine_bits(ctx); set_best_codebook(ctx); } static void process_major_frame(MLPEncodeContext *ctx) { - ctx->sample_buffer = ctx->major_inout_buffer; - ctx->number_of_frames = ctx->major_number_of_frames; - ctx->number_of_samples = ctx->major_frame_size; ctx->cur_restart_header = &ctx->restart_header; - ctx->cur_decoding_params = &ctx->b[1].major_decoding_params; - ctx->cur_channel_params = ctx->b[1].major_channel_params; - generate_2_noise_channels(ctx); rematrix_channels (ctx); @@ -2049,17 +2070,9 @@ static int mlp_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, data = frame ? frame->data[0] : NULL; - ctx->frame_index = avctx->frame_num % ctx->max_restart_interval; + ctx->frame_index = avctx->frame_num % ctx->cur_restart_interval; - ctx->inout_buffer = ctx->major_inout_buffer - + ctx->frame_index * ctx->one_sample_buffer_size; - - ctx->sample_buffer = ctx->major_scratch_buffer - + ctx->frame_index * ctx->one_sample_buffer_size; - - ctx->write_buffer = ctx->inout_buffer; - - if (avctx->frame_num < ctx->max_restart_interval) { + if (avctx->frame_num < ctx->cur_restart_interval) { if (data) goto input_and_return; } @@ -2069,13 +2082,10 @@ static int mlp_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, if (restart_frame) { avpkt->flags |= AV_PKT_FLAG_KEY; set_major_params(ctx); - if (ctx->min_restart_interval != ctx->max_restart_interval) + if (ctx->min_restart_interval != ctx->cur_restart_interval) process_major_frame(ctx); } - if (ctx->min_restart_interval == ctx->max_restart_interval) - ctx->write_buffer = ctx->sample_buffer; - bytes_written = write_access_unit(ctx, avpkt->data, avpkt->size, restart_frame); ctx->output_timing += avctx->frame_size; @@ -2097,27 +2107,21 @@ input_and_return: for (unsigned int seq_index = 0; seq_index < ctx->restart_intervals; seq_index++) { unsigned int number_of_samples; - ctx->sample_buffer = ctx->major_scratch_buffer; - ctx->inout_buffer = ctx->major_inout_buffer; - ctx->number_of_frames = ctx->next_major_number_of_frames; ctx->number_of_subblocks = ctx->next_major_number_of_frames + 1; number_of_samples = avctx->frame_size * ctx->number_of_frames; - ctx->number_of_samples = number_of_samples; for (unsigned int index = 0; index < ctx->b[seq_index].seq_size; index++) { clear_channel_params(ctx->b[index].channel_params, channels); default_decoding_params(ctx, &ctx->b[index].decoding_params); } - input_to_sample_buffer(ctx); - if (number_of_samples > 0) analyze_sample_buffer(ctx); } - if (ctx->frame_index == (ctx->max_restart_interval - 1)) { + if (ctx->frame_index == (ctx->cur_restart_interval - 1)) { ctx->major_frame_size = ctx->next_major_frame_size; ctx->next_major_frame_size = 0; ctx->major_number_of_frames = ctx->next_major_number_of_frames; @@ -2125,7 +2129,7 @@ input_and_return: } } - if (!frame && ctx->last_frames < ctx->max_restart_interval - 1) + if (!frame && ctx->last_frames < ctx->cur_restart_interval - 1) avctx->frame_num++; if (bytes_written > 0) { @@ -2149,9 +2153,6 @@ static av_cold int mlp_encode_close(AVCodecContext *avctx) MLPEncodeContext *ctx = avctx->priv_data; ff_lpc_end(&ctx->lpc_ctx); - - av_freep(&ctx->major_scratch_buffer); - av_freep(&ctx->major_inout_buffer); ff_af_queue_close(&ctx->afq); return 0;