RepoMirrors/ffmpeg
1
0
Fork 0
mirror of https://git.ffmpeg.org/ffmpeg.git synced 2024-12-25 00:32:31 +00:00
Code Issues Projects Releases Wiki Activity
242f7bf202
ffmpeg/libavcodec/mlpenc.c
Jai Luthra 15b86f480a mlpenc: Working MLP/TrueHD encoder 
* Multichannel support for TrueHD is experimental

    There should be downmix substreams present for 2+ channel bitstreams,
    but ffmpeg decoder doesn't need it. Will add support for this soon.

* There might be lossless check failures on LFE channels

* 32-bit sample support has been removed for now, will add it later

    While testing, some samples gave lossless check failures when enforcing
    s32. Probably this will also get solved with the LFE issues.

Signed-off-by: Jai Luthra <me@jailuthra.in>
2016-09-17 13:23:56 +01:00

2417 lines
83 KiB
C
Raw Blame History

/**
* MLP encoder
* Copyright (c) 2008 Ramiro Polla
*
* 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
*/
#include "avcodec.h"
#include "internal.h"
#include "put_bits.h"
#include "audio_frame_queue.h"
#include "libavutil/crc.h"
#include "libavutil/avstring.h"
#include "libavutil/samplefmt.h"
#include "mlp.h"
#include "lpc.h"
#define MAJOR_HEADER_INTERVAL 16
#define MLP_MIN_LPC_ORDER 1
#define MLP_MAX_LPC_ORDER 8
#define MLP_MIN_LPC_SHIFT 8
#define MLP_MAX_LPC_SHIFT 15
typedef struct {
uint8_t min_channel; ///< The index of the first channel coded in this substream.
uint8_t max_channel; ///< The index of the last channel coded in this substream.
uint8_t max_matrix_channel; ///< The number of channels input into the rematrix stage.
uint8_t noise_shift; ///< The left shift applied to random noise in 0x31ea substreams.
uint32_t noisegen_seed; ///< The current seed value for the pseudorandom noise generator(s).
int data_check_present; ///< Set if the substream contains extra info to check the size of VLC blocks.
int32_t lossless_check_data; ///< XOR of all output samples
uint8_t max_huff_lsbs; ///< largest huff_lsbs
uint8_t max_output_bits; ///< largest output bit-depth
} RestartHeader;
typedef struct {
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
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.
} MatrixParams;
enum ParamFlags {
PARAMS_DEFAULT = 0xff,
PARAM_PRESENCE_FLAGS = 1 << 8,
PARAM_BLOCKSIZE = 1 << 7,
PARAM_MATRIX = 1 << 6,
PARAM_OUTSHIFT = 1 << 5,
PARAM_QUANTSTEP = 1 << 4,
PARAM_FIR = 1 << 3,
PARAM_IIR = 1 << 2,
PARAM_HUFFOFFSET = 1 << 1,
PARAM_PRESENT = 1 << 0,
};
typedef struct {
uint16_t blocksize; ///< number of PCM samples in current audio block
uint8_t quant_step_size[MAX_CHANNELS]; ///< left shift to apply to Huffman-decoded residuals
MatrixParams matrix_params;
uint8_t param_presence_flags; ///< Bitmask of which parameter sets are conveyed in a decoding parameter block.
} DecodingParams;
typedef struct BestOffset {
int16_t offset;
int bitcount;
int lsb_bits;
int16_t min;
int16_t max;
} BestOffset;
#define HUFF_OFFSET_MIN -16384
#define HUFF_OFFSET_MAX 16383
/** Number of possible codebooks (counting "no codebooks") */
#define NUM_CODEBOOKS 4
typedef struct {
AVCodecContext *avctx;
int num_substreams; ///< Number of substreams contained within this stream.
int num_channels; /**< Number of channels in major_scratch_buffer.
* Normal channels + noise channels. */
int coded_sample_fmt [2]; ///< sample format encoded for MLP
int coded_sample_rate[2]; ///< sample rate encoded for MLP
int coded_peak_bitrate; ///< peak bitrate for this major sync header
int flags; ///< major sync info flags
/* channel_meaning */
int substream_info;
int fs;
int wordlength;
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_frame; ///< Pointer to last frame with data to encode.
int32_t *lpc_sample_buffer;
unsigned int major_number_of_frames;
unsigned int next_major_number_of_frames;
unsigned int major_frame_size; ///< Number of samples in current major frame being encoded.
unsigned int next_major_frame_size; ///< Counter of number of samples for next major frame.
int32_t *lossless_check_data; ///< Array with lossless_check_data for each access unit.
unsigned int *max_output_bits; ///< largest output bit-depth
unsigned int *frame_size; ///< Array with number of samples/channel in each access unit.
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 max_restart_interval; ///< Max interval of access units in between two major frames.
unsigned int min_restart_interval; ///< Min interval of access units in between two major frames.
unsigned int restart_intervals; ///< Number of possible major frame sizes.
uint16_t timestamp; ///< Timestamp of current access unit.
uint16_t dts; ///< Decoding timestamp of current access unit.
uint8_t channel_arrangement; ///< channel arrangement for MLP streams
uint8_t ch_modifier_thd0; ///< channel modifier for TrueHD stream 0
uint8_t ch_modifier_thd1; ///< channel modifier for TrueHD stream 1
uint8_t ch_modifier_thd2; ///< channel modifier for TrueHD stream 2
unsigned int seq_size [MAJOR_HEADER_INTERVAL];
unsigned int seq_offset[MAJOR_HEADER_INTERVAL];
unsigned int sequence_size;
ChannelParams *channel_params;
BestOffset best_offset[MAJOR_HEADER_INTERVAL+1][MAX_CHANNELS][NUM_CODEBOOKS];
DecodingParams *decoding_params;
RestartHeader restart_header [MAX_SUBSTREAMS];
ChannelParams major_channel_params[MAJOR_HEADER_INTERVAL+1][MAX_CHANNELS]; ///< ChannelParams to be written to bitstream.
DecodingParams major_decoding_params[MAJOR_HEADER_INTERVAL+1][MAX_SUBSTREAMS]; ///< DecodingParams to be written to bitstream.
int major_params_changed[MAJOR_HEADER_INTERVAL+1][MAX_SUBSTREAMS]; ///< params_changed to be written to bitstream.
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 starting_frame_index;
unsigned int number_of_frames;
unsigned int number_of_samples;
unsigned int number_of_subblocks;
unsigned int seq_index; ///< Sequence index for high compression levels.
ChannelParams *prev_channel_params;
DecodingParams *prev_decoding_params;
ChannelParams *seq_channel_params;
DecodingParams *seq_decoding_params;
unsigned int max_codebook_search;
LPCContext lpc_ctx;
} MLPEncodeContext;
static ChannelParams restart_channel_params[MAX_CHANNELS];
static DecodingParams restart_decoding_params[MAX_SUBSTREAMS];
static BestOffset restart_best_offset[NUM_CODEBOOKS] = {{0}};
#define SYNC_MAJOR 0xf8726f
#define MAJOR_SYNC_INFO_SIGNATURE 0xB752
#define SYNC_MLP 0xbb
#define SYNC_TRUEHD 0xba
/* must be set for DVD-A */
#define FLAGS_DVDA 0x4000
/* FIFO delay must be constant */
#define FLAGS_CONST 0x8000
#define SUBSTREAM_INFO_MAX_2_CHAN 0x01
#define SUBSTREAM_INFO_HIGH_RATE 0x02
#define SUBSTREAM_INFO_ALWAYS_SET 0x04
#define SUBSTREAM_INFO_2_SUBSTREAMS 0x08
/****************************************************************************
************ Functions that copy, clear, or compare parameters *************
****************************************************************************/
/** Compares two FilterParams structures and returns 1 if anything has
* changed. Returns 0 if they are both equal.
*/
static int compare_filter_params(const ChannelParams *prev_cp, const ChannelParams *cp, int filter)
{
const FilterParams *prev = &prev_cp->filter_params[filter];
const FilterParams *fp = &cp->filter_params[filter];
int i;
if (prev->order != fp->order)
return 1;
if (!prev->order)
return 0;
if (prev->shift != fp->shift)
return 1;
for (i = 0; i < fp->order; i++)
if (prev_cp->coeff[filter][i] != cp->coeff[filter][i])
return 1;
return 0;
}
/** Compare two primitive matrices and returns 1 if anything has changed.
* Returns 0 if they are both equal.
*/
static int compare_matrix_params(MLPEncodeContext *ctx, const MatrixParams *prev, const MatrixParams *mp)
{
RestartHeader *rh = ctx->cur_restart_header;
unsigned int channel, mat;
if (prev->count != mp->count)
return 1;
if (!prev->count)
return 0;
for (channel = rh->min_channel; channel <= rh->max_channel; channel++)
if (prev->fbits[channel] != mp->fbits[channel])
return 1;
for (mat = 0; mat < mp->count; mat++) {
if (prev->outch[mat] != mp->outch[mat])
return 1;
for (channel = 0; channel < ctx->num_channels; channel++)
if (prev->coeff[mat][channel] != mp->coeff[mat][channel])
return 1;
}
return 0;
}
/** 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)
{
DecodingParams *prev = ctx->prev_decoding_params;
DecodingParams *dp = ctx->cur_decoding_params;
MatrixParams *prev_mp = &prev->matrix_params;
MatrixParams *mp = &dp->matrix_params;
RestartHeader *rh = ctx->cur_restart_header;
unsigned int ch;
int retval = 0;
if (prev->param_presence_flags != dp->param_presence_flags)
retval |= PARAM_PRESENCE_FLAGS;
if (prev->blocksize != dp->blocksize)
retval |= PARAM_BLOCKSIZE;
if (compare_matrix_params(ctx, prev_mp, mp))
retval |= PARAM_MATRIX;
for (ch = 0; ch <= rh->max_matrix_channel; ch++)
if (prev_mp->shift[ch] != mp->shift[ch]) {
retval |= PARAM_OUTSHIFT;
break;
}
for (ch = 0; ch <= rh->max_channel; ch++)
if (prev->quant_step_size[ch] != dp->quant_step_size[ch]) {
retval |= PARAM_QUANTSTEP;
break;
}
for (ch = rh->min_channel; ch <= rh->max_channel; ch++) {
ChannelParams *prev_cp = &ctx->prev_channel_params[ch];
ChannelParams *cp = &ctx->cur_channel_params[ch];
if (!(retval & PARAM_FIR) &&
compare_filter_params(prev_cp, cp, FIR))
retval |= PARAM_FIR;
if (!(retval & PARAM_IIR) &&
compare_filter_params(prev_cp, cp, IIR))
retval |= PARAM_IIR;
if (prev_cp->huff_offset != cp->huff_offset)
retval |= PARAM_HUFFOFFSET;
if (prev_cp->codebook != cp->codebook ||
prev_cp->huff_lsbs != cp->huff_lsbs )
retval |= 0x1;
}
return retval;
}
static void copy_filter_params(ChannelParams *dst_cp, ChannelParams *src_cp, int filter)
{
FilterParams *dst = &dst_cp->filter_params[filter];
FilterParams *src = &src_cp->filter_params[filter];
unsigned int order;
dst->order = src->order;
if (dst->order) {
dst->shift = src->shift;
dst->coeff_shift = src->coeff_shift;
dst->coeff_bits = src->coeff_bits;
}
for (order = 0; order < dst->order; order++)
dst_cp->coeff[filter][order] = src_cp->coeff[filter][order];
}
static void copy_matrix_params(MatrixParams *dst, MatrixParams *src)
{
dst->count = src->count;
if (dst->count) {
unsigned int channel, count;
for (channel = 0; channel < MAX_CHANNELS; channel++) {
dst->fbits[channel] = src->fbits[channel];
dst->shift[channel] = src->shift[channel];
for (count = 0; count < MAX_MATRICES; count++)
dst->coeff[count][channel] = src->coeff[count][channel];
}
for (count = 0; count < MAX_MATRICES; count++)
dst->outch[count] = src->outch[count];
}
}
static void copy_restart_frame_params(MLPEncodeContext *ctx,
unsigned int substr)
{
unsigned int index;
for (index = 0; index < ctx->number_of_subblocks; index++) {
DecodingParams *dp = ctx->seq_decoding_params + index*(ctx->num_substreams) + substr;
unsigned int channel;
copy_matrix_params(&dp->matrix_params, &ctx->cur_decoding_params->matrix_params);
for (channel = 0; channel < ctx->avctx->channels; channel++) {
ChannelParams *cp = ctx->seq_channel_params + index*(ctx->avctx->channels) + channel;
unsigned int filter;
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];
if (index)
for (filter = 0; filter < NUM_FILTERS; filter++)
copy_filter_params(cp, &ctx->cur_channel_params[channel], filter);
}
}
}
/** Clears a DecodingParams struct the way it should be after a restart header. */
static void clear_decoding_params(MLPEncodeContext *ctx, DecodingParams decoding_params[MAX_SUBSTREAMS])
{
unsigned int substr;
for (substr = 0; substr < ctx->num_substreams; substr++) {
DecodingParams *dp = &decoding_params[substr];
dp->param_presence_flags = 0xff;
dp->blocksize = 8;
memset(&dp->matrix_params , 0, sizeof(MatrixParams ));
memset(dp->quant_step_size, 0, sizeof(dp->quant_step_size));
}
}
/** Clears a ChannelParams struct the way it should be after a restart header. */
static void clear_channel_params(MLPEncodeContext *ctx, ChannelParams channel_params[MAX_CHANNELS])
{
unsigned int channel;
for (channel = 0; channel < ctx->avctx->channels; channel++) {
ChannelParams *cp = &channel_params[channel];
memset(&cp->filter_params, 0, sizeof(cp->filter_params));
/* Default audio coding is 24-bit raw PCM. */
cp->huff_offset = 0;
cp->codebook = 0;
cp->huff_lsbs = 24;
}
}
/** Sets default vales in our encoder for a DecodingParams struct. */
static void default_decoding_params(MLPEncodeContext *ctx,
DecodingParams decoding_params[MAX_SUBSTREAMS])
{
unsigned int substr;
clear_decoding_params(ctx, decoding_params);
for (substr = 0; substr < ctx->num_substreams; substr++) {
DecodingParams *dp = &decoding_params[substr];
uint8_t param_presence_flags = 0;
param_presence_flags |= PARAM_BLOCKSIZE;
param_presence_flags |= PARAM_MATRIX;
param_presence_flags |= PARAM_OUTSHIFT;
param_presence_flags |= PARAM_QUANTSTEP;
param_presence_flags |= PARAM_FIR;
/* param_presence_flags |= PARAM_IIR; */
param_presence_flags |= PARAM_HUFFOFFSET;
param_presence_flags |= PARAM_PRESENT;
dp->param_presence_flags = param_presence_flags;
}
}
/****************************************************************************/
/** Calculates the smallest number of bits it takes to encode a given signed
* value in two's complement.
*/
static int inline number_sbits(int number)
{
if (number < 0)
number++;
return av_log2(FFABS(number)) + 1 + !!number;
}
enum InputBitDepth {
BITS_16,
BITS_20,
BITS_24,
};
static int mlp_peak_bitrate(int peak_bitrate, int sample_rate)
{
return ((peak_bitrate << 4) - 8) / sample_rate;
}
static av_cold int mlp_encode_init(AVCodecContext *avctx)
{
MLPEncodeContext *ctx = avctx->priv_data;
unsigned int substr, index;
unsigned int sum = 0;
unsigned int size;
int ret;
ctx->avctx = avctx;
switch (avctx->sample_rate) {
case 44100 << 0:
avctx->frame_size = 40 << 0;
ctx->coded_sample_rate[0] = 0x08 + 0;
ctx->fs = 0x08 + 1;
break;
case 44100 << 1:
avctx->frame_size = 40 << 1;
ctx->coded_sample_rate[0] = 0x08 + 1;
ctx->fs = 0x0C + 1;
break;
case 44100 << 2:
ctx->substream_info |= SUBSTREAM_INFO_HIGH_RATE;
avctx->frame_size = 40 << 2;
ctx->coded_sample_rate[0] = 0x08 + 2;
ctx->fs = 0x10 + 1;
break;
case 48000 << 0:
avctx->frame_size = 40 << 0;
ctx->coded_sample_rate[0] = 0x00 + 0;
ctx->fs = 0x08 + 2;
break;
case 48000 << 1:
avctx->frame_size = 40 << 1;
ctx->coded_sample_rate[0] = 0x00 + 1;
ctx->fs = 0x0C + 2;
break;
case 48000 << 2:
ctx->substream_info |= SUBSTREAM_INFO_HIGH_RATE;
avctx->frame_size = 40 << 2;
ctx->coded_sample_rate[0] = 0x00 + 2;
ctx->fs = 0x10 + 2;
break;
default:
av_log(avctx, AV_LOG_ERROR, "Unsupported sample rate %d. Supported "
"sample rates are 44100, 88200, 176400, 48000, "
"96000, and 192000.\n", avctx->sample_rate);
return -1;
}
ctx->coded_sample_rate[1] = -1 & 0xf;
/* TODO Keep count of bitrate and calculate real value. */
ctx->coded_peak_bitrate = mlp_peak_bitrate(9600000, avctx->sample_rate);
/* TODO support more channels. */
if (avctx->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) {
ctx->substream_info |= SUBSTREAM_INFO_MAX_2_CHAN;
}
switch (avctx->sample_fmt) {
case AV_SAMPLE_FMT_S16:
ctx->coded_sample_fmt[0] = BITS_16;
ctx->wordlength = 16;
avctx->bits_per_raw_sample = 16;
break;
/* TODO 20 bits: */
case AV_SAMPLE_FMT_S32:
ctx->coded_sample_fmt[0] = BITS_24;
ctx->wordlength = 24;
avctx->bits_per_raw_sample = 24;
break;
default:
av_log(avctx, AV_LOG_ERROR, "Sample format not supported. "
"Only 16- and 24-bit samples are supported.\n");
return -1;
}
ctx->coded_sample_fmt[1] = -1 & 0xf;
ctx->dts = -avctx->frame_size;
ctx->num_channels = avctx->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. */
ctx->max_restart_interval = MAJOR_HEADER_INTERVAL;
ctx->max_codebook_search = 3;
ctx->min_restart_interval = MAJOR_HEADER_INTERVAL;
ctx->restart_intervals = ctx->max_restart_interval / ctx->min_restart_interval;
/* TODO Let user pass parameters for LPC filter. */
size = avctx->frame_size * ctx->max_restart_interval;
ctx->lpc_sample_buffer = av_malloc_array(size, sizeof(int32_t));
if (!ctx->lpc_sample_buffer) {
av_log(avctx, AV_LOG_ERROR,
"Not enough memory for buffering samples.\n");
return AVERROR(ENOMEM);
}
size = ctx->one_sample_buffer_size * ctx->max_restart_interval;
ctx->major_scratch_buffer = av_malloc_array(size, sizeof(int32_t));
if (!ctx->major_scratch_buffer) {
av_log(avctx, AV_LOG_ERROR,
"Not enough memory for buffering samples.\n");
return AVERROR(ENOMEM);
}
ctx->major_inout_buffer = av_malloc_array(size, sizeof(int32_t));
if (!ctx->major_inout_buffer) {
av_log(avctx, AV_LOG_ERROR,
"Not enough memory for buffering samples.\n");
return AVERROR(ENOMEM);
}
ff_mlp_init_crc();
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:
av_log(avctx, AV_LOG_ERROR, "Unsupported channel arrangement\n");
return -1;
}
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:
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:
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:
ctx->ch_modifier_thd0 = 2;
ctx->ch_modifier_thd1 = 1;
ctx->ch_modifier_thd2 = 2;
ctx->channel_arrangement = 15;
break;
default:
av_log(avctx, AV_LOG_ERROR, "Unsupported channel arrangement\n");
return -1;
}
ctx->flags = 0;
ctx->channel_occupancy = 0;
ctx->summary_info = 0;
}
size = sizeof(unsigned int) * ctx->max_restart_interval;
ctx->frame_size = av_malloc(size);
if (!ctx->frame_size)
return AVERROR(ENOMEM);
ctx->max_output_bits = av_malloc(size);
if (!ctx->max_output_bits)
return AVERROR(ENOMEM);
size = sizeof(int32_t)
* ctx->num_substreams * ctx->max_restart_interval;
ctx->lossless_check_data = av_malloc(size);
if (!ctx->lossless_check_data)
return AVERROR(ENOMEM);
for (index = 0; index < ctx->restart_intervals; index++) {
ctx->seq_offset[index] = sum;
ctx->seq_size [index] = ((index + 1) * ctx->min_restart_interval) + 1;
sum += ctx->seq_size[index];
}
ctx->sequence_size = sum;
size = sizeof(ChannelParams)
* ctx->restart_intervals * ctx->sequence_size * ctx->avctx->channels;
ctx->channel_params = av_malloc(size);
if (!ctx->channel_params) {
av_log(avctx, AV_LOG_ERROR,
"Not enough memory for analysis context.\n");
return AVERROR(ENOMEM);
}
size = sizeof(DecodingParams)
* ctx->restart_intervals * ctx->sequence_size * ctx->num_substreams;
ctx->decoding_params = av_malloc(size);
if (!ctx->decoding_params) {
av_log(avctx, AV_LOG_ERROR,
"Not enough memory for analysis context.\n");
return AVERROR(ENOMEM);
}
for (substr = 0; substr < ctx->num_substreams; substr++) {
RestartHeader *rh = &ctx->restart_header [substr];
/* TODO see if noisegen_seed is really worth it. */
rh->noisegen_seed = 0;
rh->min_channel = 0;
rh->max_channel = avctx->channels - 1;
/* FIXME: this works for 1 and 2 channels, but check for more */
rh->max_matrix_channel = rh->max_channel;
}
clear_channel_params(ctx, restart_channel_params);
clear_decoding_params(ctx, restart_decoding_params);
if ((ret = ff_lpc_init(&ctx->lpc_ctx, ctx->number_of_samples,
MLP_MAX_LPC_ORDER, FF_LPC_TYPE_LEVINSON)) < 0) {
av_log(avctx, AV_LOG_ERROR,
"Not enough memory for LPC context.\n");
return ret;
}
ff_af_queue_init(avctx, &ctx->afq);
return 0;
}
/****************************************************************************
****************** Functions that write to the bitstream *******************
****************************************************************************/
/** Writes a major sync header to the bitstream. */
static void write_major_sync(MLPEncodeContext *ctx, uint8_t *buf, int buf_size)
{
PutBitContext pb;
init_put_bits(&pb, buf, buf_size);
put_bits(&pb, 24, SYNC_MAJOR );
if (ctx->avctx->codec_id == AV_CODEC_ID_MLP) {
put_bits(&pb, 8, SYNC_MLP );
put_bits(&pb, 4, ctx->coded_sample_fmt [0]);
put_bits(&pb, 4, ctx->coded_sample_fmt [1]);
put_bits(&pb, 4, ctx->coded_sample_rate[0]);
put_bits(&pb, 4, ctx->coded_sample_rate[1]);
put_bits(&pb, 4, 0 ); /* ignored */
put_bits(&pb, 4, 0 ); /* multi_channel_type */
put_bits(&pb, 3, 0 ); /* ignored */
put_bits(&pb, 5, ctx->channel_arrangement );
} else if (ctx->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
put_bits(&pb, 8, SYNC_TRUEHD );
put_bits(&pb, 4, ctx->coded_sample_rate[0]);
put_bits(&pb, 4, 0 ); /* ignored */
put_bits(&pb, 2, ctx->ch_modifier_thd0 );
put_bits(&pb, 2, ctx->ch_modifier_thd1 );
put_bits(&pb, 5, ctx->channel_arrangement );
put_bits(&pb, 2, ctx->ch_modifier_thd2 );
put_bits(&pb, 13, ctx->channel_arrangement );
}
put_bits(&pb, 16, MAJOR_SYNC_INFO_SIGNATURE);
put_bits(&pb, 16, ctx->flags );
put_bits(&pb, 16, 0 ); /* ignored */
put_bits(&pb, 1, 1 ); /* is_vbr */
put_bits(&pb, 15, ctx->coded_peak_bitrate );
put_bits(&pb, 4, 1 ); /* num_substreams */
put_bits(&pb, 4, 0x1 ); /* ignored */
/* channel_meaning */
put_bits(&pb, 8, ctx->substream_info );
put_bits(&pb, 5, ctx->fs );
put_bits(&pb, 5, ctx->wordlength );
put_bits(&pb, 6, ctx->channel_occupancy );
put_bits(&pb, 3, 0 ); /* ignored */
put_bits(&pb, 10, 0 ); /* speaker_layout */
put_bits(&pb, 3, 0 ); /* copy_protection */
put_bits(&pb, 16, 0x8080 ); /* ignored */
put_bits(&pb, 7, 0 ); /* ignored */
put_bits(&pb, 4, 0 ); /* source_format */
put_bits(&pb, 5, ctx->summary_info );
flush_put_bits(&pb);
AV_WL16(buf+26, ff_mlp_checksum16(buf, 26));
}
/** Writes a restart header to the bitstream. Damaged streams can start being
* decoded losslessly again after such a header and the subsequent decoding
* params header.
*/
static void write_restart_header(MLPEncodeContext *ctx, PutBitContext *pb)
{
RestartHeader *rh = ctx->cur_restart_header;
int32_t lossless_check = xor_32_to_8(rh->lossless_check_data);
unsigned int start_count = put_bits_count(pb);
PutBitContext tmpb;
uint8_t checksum;
unsigned int ch;
put_bits(pb, 14, 0x31ea ); /* TODO 0x31eb */
put_bits(pb, 16, ctx->timestamp );
put_bits(pb, 4, rh->min_channel );
put_bits(pb, 4, rh->max_channel );
put_bits(pb, 4, rh->max_matrix_channel);
put_bits(pb, 4, rh->noise_shift );
put_bits(pb, 23, rh->noisegen_seed );
put_bits(pb, 4, 0 ); /* TODO max_shift */
put_bits(pb, 5, rh->max_huff_lsbs );
put_bits(pb, 5, rh->max_output_bits );
put_bits(pb, 5, rh->max_output_bits );
put_bits(pb, 1, rh->data_check_present);
put_bits(pb, 8, lossless_check );
put_bits(pb, 16, 0 ); /* ignored */
for (ch = 0; ch <= rh->max_matrix_channel; ch++)
put_bits(pb, 6, ch);
/* Data must be flushed for the checksum to be correct. */
tmpb = *pb;
flush_put_bits(&tmpb);
checksum = ff_mlp_restart_checksum(pb->buf, put_bits_count(pb) - start_count);
put_bits(pb, 8, checksum);
}
/** Writes matrix params for all primitive matrices to the bitstream. */
static void write_matrix_params(MLPEncodeContext *ctx, PutBitContext *pb)
{
DecodingParams *dp = ctx->cur_decoding_params;
MatrixParams *mp = &dp->matrix_params;
unsigned int mat;
put_bits(pb, 4, mp->count);
for (mat = 0; mat < mp->count; mat++) {
unsigned int channel;
put_bits(pb, 4, mp->outch[mat]); /* matrix_out_ch */
put_bits(pb, 4, mp->fbits[mat]);
put_bits(pb, 1, 0 ); /* lsb_bypass */
for (channel = 0; channel < ctx->num_channels; channel++) {
int32_t coeff = mp->coeff[mat][channel];
if (coeff) {
put_bits(pb, 1, 1);
coeff >>= 14 - mp->fbits[mat];
put_sbits(pb, mp->fbits[mat] + 2, coeff);
} else {
put_bits(pb, 1, 0);
}
}
}
}
/** Writes filter parameters for one filter to the bitstream. */
static void write_filter_params(MLPEncodeContext *ctx, PutBitContext *pb,
unsigned int channel, unsigned int filter)
{
FilterParams *fp = &ctx->cur_channel_params[channel].filter_params[filter];
put_bits(pb, 4, fp->order);
if (fp->order > 0) {
int i;
int32_t *fcoeff = ctx->cur_channel_params[channel].coeff[filter];
put_bits(pb, 4, fp->shift );
put_bits(pb, 5, fp->coeff_bits );
put_bits(pb, 3, fp->coeff_shift);
for (i = 0; i < fp->order; i++) {
put_sbits(pb, fp->coeff_bits, fcoeff[i] >> fp->coeff_shift);
}
/* TODO state data for IIR filter. */
put_bits(pb, 1, 0);
}
}
/** Writes decoding parameters to the bitstream. These change very often,
* usually at almost every frame.
*/
static void write_decoding_params(MLPEncodeContext *ctx, PutBitContext *pb,
int params_changed)
{
DecodingParams *dp = ctx->cur_decoding_params;
RestartHeader *rh = ctx->cur_restart_header;
MatrixParams *mp = &dp->matrix_params;
unsigned int ch;
if (dp->param_presence_flags != PARAMS_DEFAULT &&
params_changed & PARAM_PRESENCE_FLAGS) {
put_bits(pb, 1, 1);
put_bits(pb, 8, dp->param_presence_flags);
} else {
put_bits(pb, 1, 0);
}
if (dp->param_presence_flags & PARAM_BLOCKSIZE) {
if (params_changed & PARAM_BLOCKSIZE) {
put_bits(pb, 1, 1);
put_bits(pb, 9, dp->blocksize);
} else {
put_bits(pb, 1, 0);
}
}
if (dp->param_presence_flags & PARAM_MATRIX) {
if (params_changed & PARAM_MATRIX) {
put_bits(pb, 1, 1);
write_matrix_params(ctx, pb);
} else {
put_bits(pb, 1, 0);
}
}
if (dp->param_presence_flags & PARAM_OUTSHIFT) {
if (params_changed & PARAM_OUTSHIFT) {
put_bits(pb, 1, 1);
for (ch = 0; ch <= rh->max_matrix_channel; ch++)
put_sbits(pb, 4, mp->shift[ch]);
} else {
put_bits(pb, 1, 0);
}
}
if (dp->param_presence_flags & PARAM_QUANTSTEP) {
if (params_changed & PARAM_QUANTSTEP) {
put_bits(pb, 1, 1);
for (ch = 0; ch <= rh->max_channel; ch++)
put_bits(pb, 4, dp->quant_step_size[ch]);
} else {
put_bits(pb, 1, 0);
}
}
for (ch = rh->min_channel; ch <= rh->max_channel; ch++) {
ChannelParams *cp = &ctx->cur_channel_params[ch];
if (dp->param_presence_flags & 0xF) {
put_bits(pb, 1, 1);
if (dp->param_presence_flags & PARAM_FIR) {
if (params_changed & PARAM_FIR) {
put_bits(pb, 1, 1);
write_filter_params(ctx, pb, ch, FIR);
} else {
put_bits(pb, 1, 0);
}
}
if (dp->param_presence_flags & PARAM_IIR) {
if (params_changed & PARAM_IIR) {
put_bits(pb, 1, 1);
write_filter_params(ctx, pb, ch, IIR);
} else {
put_bits(pb, 1, 0);
}
}
if (dp->param_presence_flags & PARAM_HUFFOFFSET) {
if (params_changed & PARAM_HUFFOFFSET) {
put_bits (pb, 1, 1);
put_sbits(pb, 15, cp->huff_offset);
} else {
put_bits(pb, 1, 0);
}
}
put_bits(pb, 2, cp->codebook );
put_bits(pb, 5, cp->huff_lsbs);
} else {
put_bits(pb, 1, 0);
}
}
}
/** 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)
{
DecodingParams *dp = ctx->cur_decoding_params;
RestartHeader *rh = ctx->cur_restart_header;
int32_t *sample_buffer = ctx->write_buffer;
int32_t sign_huff_offset[MAX_CHANNELS];
int codebook_index [MAX_CHANNELS];
int lsb_bits [MAX_CHANNELS];
unsigned int i, ch;
for (ch = rh->min_channel; ch <= rh->max_channel; ch++) {
ChannelParams *cp = &ctx->cur_channel_params[ch];
int sign_shift;
lsb_bits [ch] = cp->huff_lsbs - dp->quant_step_size[ch];
codebook_index [ch] = cp->codebook - 1;
sign_huff_offset[ch] = cp->huff_offset;
sign_shift = lsb_bits[ch] - 1;
if (cp->codebook > 0) {
sign_huff_offset[ch] -= 7 << lsb_bits[ch];
sign_shift += 3 - cp->codebook;
}
/* Unsign if needed. */
if (sign_shift >= 0)
sign_huff_offset[ch] -= 1 << sign_shift;
}
for (i = 0; i < dp->blocksize; i++) {
for (ch = rh->min_channel; ch <= rh->max_channel; ch++) {
int32_t sample = *sample_buffer++ >> dp->quant_step_size[ch];
sample -= sign_huff_offset[ch];
if (codebook_index[ch] >= 0) {
int vlc = sample >> lsb_bits[ch];
put_bits(pb, ff_mlp_huffman_tables[codebook_index[ch]][vlc][1],
ff_mlp_huffman_tables[codebook_index[ch]][vlc][0]);
}
put_sbits(pb, lsb_bits[ch], sample);
}
sample_buffer += 2; /* noise channels */
}
ctx->write_buffer = sample_buffer;
}
/** Writes the substreams data to the bitstream. */
static uint8_t *write_substrs(MLPEncodeContext *ctx, uint8_t *buf, int buf_size,
int restart_frame,
uint16_t substream_data_len[MAX_SUBSTREAMS])
{
int32_t *lossless_check_data = ctx->lossless_check_data;
unsigned int substr;
int end = 0;
lossless_check_data += ctx->frame_index * ctx->num_substreams;
for (substr = 0; substr < ctx->num_substreams; substr++) {
unsigned int cur_subblock_index = ctx->major_cur_subblock_index;
unsigned int num_subblocks = ctx->major_filter_state_subblock;
unsigned int subblock;
RestartHeader *rh = &ctx->restart_header [substr];
int substr_restart_frame = restart_frame;
uint8_t parity, checksum;
PutBitContext pb, tmpb;
int params_changed;
ctx->cur_restart_header = rh;
init_put_bits(&pb, buf, buf_size);
for (subblock = 0; subblock <= num_subblocks; subblock++) {
unsigned int subblock_index;
subblock_index = cur_subblock_index++;
ctx->cur_decoding_params = &ctx->major_decoding_params[subblock_index][substr];
ctx->cur_channel_params = ctx->major_channel_params[subblock_index];
params_changed = ctx->major_params_changed[subblock_index][substr];
if (substr_restart_frame || params_changed) {
put_bits(&pb, 1, 1);
if (substr_restart_frame) {
put_bits(&pb, 1, 1);
write_restart_header(ctx, &pb);
rh->lossless_check_data = 0;
} else {
put_bits(&pb, 1, 0);
}
write_decoding_params(ctx, &pb, params_changed);
} else {
put_bits(&pb, 1, 0);
}
write_block_data(ctx, &pb);
put_bits(&pb, 1, !substr_restart_frame);
substr_restart_frame = 0;
}
put_bits(&pb, (-put_bits_count(&pb)) & 15, 0);
rh->lossless_check_data ^= *lossless_check_data++;
if (ctx->last_frame == ctx->inout_buffer) {
/* TODO find a sample and implement shorten_by. */
put_bits(&pb, 32, END_OF_STREAM);
}
/* Data must be flushed for the checksum and parity to be correct. */
tmpb = pb;
flush_put_bits(&tmpb);
parity = ff_mlp_calculate_parity(buf, put_bits_count(&pb) >> 3) ^ 0xa9;
checksum = ff_mlp_checksum8 (buf, put_bits_count(&pb) >> 3);
put_bits(&pb, 8, parity );
put_bits(&pb, 8, checksum);
flush_put_bits(&pb);
end += put_bits_count(&pb) >> 3;
substream_data_len[substr] = end;
buf += put_bits_count(&pb) >> 3;
}
ctx->major_cur_subblock_index += ctx->major_filter_state_subblock + 1;
ctx->major_filter_state_subblock = 0;
return buf;
}
/** Writes the access unit and substream headers to the bitstream. */
static void write_frame_headers(MLPEncodeContext *ctx, uint8_t *frame_header,
uint8_t *substream_headers, unsigned int length,
int restart_frame,
uint16_t substream_data_len[MAX_SUBSTREAMS])
{
uint16_t access_unit_header = 0;
uint16_t parity_nibble = 0;
unsigned int substr;
parity_nibble = ctx->dts;
parity_nibble ^= length;
for (substr = 0; substr < ctx->num_substreams; substr++) {
uint16_t substr_hdr = 0;
substr_hdr |= (0 << 15); /* extraword */
substr_hdr |= (!restart_frame << 14); /* !restart_frame */
substr_hdr |= (1 << 13); /* checkdata */
substr_hdr |= (0 << 12); /* ??? */
substr_hdr |= (substream_data_len[substr] / 2) & 0x0FFF;
AV_WB16(substream_headers, substr_hdr);
parity_nibble ^= *substream_headers++;
parity_nibble ^= *substream_headers++;
}
parity_nibble ^= parity_nibble >> 8;
parity_nibble ^= parity_nibble >> 4;
parity_nibble &= 0xF;
access_unit_header |= (parity_nibble ^ 0xF) << 12;
access_unit_header |= length & 0xFFF;
AV_WB16(frame_header , access_unit_header);
AV_WB16(frame_header+2, ctx->dts );
}
/** Writes an entire access unit to the bitstream. */
static unsigned int write_access_unit(MLPEncodeContext *ctx, uint8_t *buf,
int buf_size, int restart_frame)
{
uint16_t substream_data_len[MAX_SUBSTREAMS];
uint8_t *buf1, *buf0 = buf;
unsigned int substr;
int total_length;
if (buf_size < 4)
return -1;
/* Frame header will be written at the end. */
buf += 4;
buf_size -= 4;
if (restart_frame) {
if (buf_size < 28)
return -1;
write_major_sync(ctx, buf, buf_size);
buf += 28;
buf_size -= 28;
}
buf1 = buf;
/* Substream headers will be written at the end. */
for (substr = 0; substr < ctx->num_substreams; substr++) {
buf += 2;
buf_size -= 2;
}
buf = write_substrs(ctx, buf, buf_size, restart_frame, substream_data_len);
total_length = buf - buf0;
write_frame_headers(ctx, buf0, buf1, total_length / 2, restart_frame, substream_data_len);
return total_length;
}
/****************************************************************************
****************** Functions that input data to context ********************
****************************************************************************/
/** Inputs data from the samples passed by lavc into the context, shifts them
* appropriately depending on the bit-depth, and calculates the
* lossless_check_data that will be written to the restart header.
*/
static void input_data_internal(MLPEncodeContext *ctx, const uint8_t *samples,
int is24)
{
int32_t *lossless_check_data = ctx->lossless_check_data;
const int32_t *samples_32 = (const int32_t *) samples;
const int16_t *samples_16 = (const int16_t *) samples;
unsigned int substr;
lossless_check_data += ctx->frame_index * ctx->num_substreams;
for (substr = 0; substr < ctx->num_substreams; substr++) {
RestartHeader *rh = &ctx->restart_header [substr];
int32_t *sample_buffer = ctx->inout_buffer;
int32_t temp_lossless_check_data = 0;
uint32_t greatest = 0;
unsigned int channel;
int i;
for (i = 0; i < ctx->frame_size[ctx->frame_index]; i++) {
for (channel = 0; channel <= rh->max_channel; channel++) {
uint32_t abs_sample;
int32_t sample;
sample = is24 ? *samples_32++ >> 8 : *samples_16++ << 8;
/* TODO Find out if number_sbits can be used for negative values. */
abs_sample = FFABS(sample);
if (greatest < abs_sample)
greatest = abs_sample;
temp_lossless_check_data ^= (sample & 0x00ffffff) << channel;
*sample_buffer++ = sample;
}
sample_buffer += 2; /* noise channels */
}
ctx->max_output_bits[ctx->frame_index] = number_sbits(greatest);
*lossless_check_data++ = temp_lossless_check_data;
}
}
/** Wrapper function for inputting data in two different bit-depths. */
static void input_data(MLPEncodeContext *ctx, void *samples)
{
if (ctx->avctx->sample_fmt == AV_SAMPLE_FMT_S32)
input_data_internal(ctx, samples, 1);
else
input_data_internal(ctx, samples, 0);
}
static void input_to_sample_buffer(MLPEncodeContext *ctx)
{
int32_t *sample_buffer = ctx->sample_buffer;
unsigned int index;
for (index = 0; index < ctx->number_of_frames; index++) {
unsigned int cur_index = (ctx->starting_frame_index + index) % ctx->max_restart_interval;
int32_t *input_buffer = ctx->inout_buffer + cur_index * ctx->one_sample_buffer_size;
unsigned int i, channel;
for (i = 0; i < ctx->frame_size[cur_index]; i++) {
for (channel = 0; channel < ctx->avctx->channels; channel++)
*sample_buffer++ = *input_buffer++;
sample_buffer += 2; /* noise_channels */
input_buffer += 2; /* noise_channels */
}
}
}
/****************************************************************************
********* Functions that analyze the data and set the parameters ***********
****************************************************************************/
/** Counts the number of trailing zeroes in a value */
static int number_trailing_zeroes(int32_t sample)
{
int bits;
for (bits = 0; bits < 24 && !(sample & (1<<bits)); bits++);
/* All samples are 0. TODO Return previous quant_step_size to avoid
* writing a new header. */
if (bits == 24)
return 0;
return bits;
}
/** Determines how many bits are zero at the end of all samples so they can be
* shifted out.
*/
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;
int32_t sample_mask[MAX_CHANNELS];
unsigned int channel;
int i;
memset(sample_mask, 0x00, sizeof(sample_mask));
for (i = 0; i < ctx->number_of_samples; i++) {
for (channel = 0; channel <= rh->max_channel; channel++)
sample_mask[channel] |= *sample_buffer++;
sample_buffer += 2; /* noise channels */
}
for (channel = 0; channel <= rh->max_channel; channel++)
dp->quant_step_size[channel] = number_trailing_zeroes(sample_mask[channel]) - mp->shift[channel];
}
/** Determines the smallest number of bits needed to encode the filter
* coefficients, and if it's possible to right-shift their values without
* losing any precision.
*/
static void code_filter_coeffs(MLPEncodeContext *ctx, FilterParams *fp, int32_t *fcoeff)
{
int min = INT_MAX, max = INT_MIN;
int bits, shift;
int coeff_mask = 0;
int order;
for (order = 0; order < fp->order; order++) {
int coeff = fcoeff[order];
if (coeff < min)
min = coeff;
if (coeff > max)
max = coeff;
coeff_mask |= coeff;
}
bits = FFMAX(number_sbits(min), number_sbits(max));
for (shift = 0; shift < 7 && bits + shift < 16 && !(coeff_mask & (1<<shift)); shift++);
fp->coeff_bits = bits;
fp->coeff_shift = shift;
}
/** Determines the best filter parameters for the given data and writes the
* necessary information to the context.
* TODO Add IIR filter predictor!
*/
static void set_filter_params(MLPEncodeContext *ctx,
unsigned int channel, unsigned int filter,
int clear_filter)
{
ChannelParams *cp = &ctx->cur_channel_params[channel];
FilterParams *fp = &cp->filter_params[filter];
if ((filter == IIR && ctx->substream_info & SUBSTREAM_INFO_HIGH_RATE) ||
clear_filter) {
fp->order = 0;
} else if (filter == IIR) {
fp->order = 0;
} else if (filter == FIR) {
const int max_order = (ctx->substream_info & SUBSTREAM_INFO_HIGH_RATE)
? 4 : MLP_MAX_LPC_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];
int shift[MLP_MAX_LPC_ORDER];
unsigned int i;
int order;
for (i = 0; i < ctx->number_of_samples; i++) {
*lpc_samples++ = *sample_buffer;
sample_buffer += ctx->num_channels;
}
order = ff_lpc_calc_coefs(&ctx->lpc_ctx, ctx->lpc_sample_buffer,
ctx->number_of_samples, MLP_MIN_LPC_ORDER,
max_order, 11, coefs, shift, FF_LPC_TYPE_LEVINSON, 0,
ORDER_METHOD_EST, MLP_MIN_LPC_SHIFT,
MLP_MAX_LPC_SHIFT, MLP_MIN_LPC_SHIFT);
fp->order = order;
fp->shift = shift[order-1];
for (i = 0; i < order; i++)
fcoeff[i] = coefs[order-1][i];
code_filter_coeffs(ctx, fp, fcoeff);
}
}
/** Tries to determine a good prediction filter, and applies it to the samples
* buffer if the filter is good enough. Sets the filter data to be cleared if
* no good filter was found.
*/
static void determine_filters(MLPEncodeContext *ctx)
{
RestartHeader *rh = ctx->cur_restart_header;
int channel, filter;
for (channel = rh->min_channel; channel <= rh->max_channel; channel++) {
for (filter = 0; filter < NUM_FILTERS; filter++)
set_filter_params(ctx, channel, filter, 0);
}
}
enum MLPChMode {
MLP_CHMODE_LEFT_RIGHT,
MLP_CHMODE_LEFT_SIDE,
MLP_CHMODE_RIGHT_SIDE,
MLP_CHMODE_MID_SIDE,
};
static enum MLPChMode estimate_stereo_mode(MLPEncodeContext *ctx)
{
uint64_t score[4], sum[4] = { 0, 0, 0, 0, };
int32_t *right_ch = ctx->sample_buffer + 1;
int32_t *left_ch = ctx->sample_buffer;
int i;
enum MLPChMode best = 0;
for(i = 2; i < ctx->number_of_samples; i++) {
int32_t left = left_ch [i * ctx->num_channels] - 2 * left_ch [(i - 1) * ctx->num_channels] + left_ch [(i - 2) * ctx->num_channels];
int32_t right = right_ch[i * ctx->num_channels] - 2 * right_ch[(i - 1) * ctx->num_channels] + right_ch[(i - 2) * ctx->num_channels];
sum[0] += FFABS( left );
sum[1] += FFABS( right);
sum[2] += FFABS((left + right) >> 1);
sum[3] += FFABS( left - right);
}
score[MLP_CHMODE_LEFT_RIGHT] = sum[0] + sum[1];
score[MLP_CHMODE_LEFT_SIDE] = sum[0] + sum[3];
score[MLP_CHMODE_RIGHT_SIDE] = sum[1] + sum[3];
score[MLP_CHMODE_MID_SIDE] = sum[2] + sum[3];
for(i = 1; i < 3; i++)
if(score[i] < score[best])
best = i;
return best;
}
/** 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)
{
DecodingParams *dp = ctx->cur_decoding_params;
MatrixParams *mp = &dp->matrix_params;
int32_t coeff_mask = 0;
unsigned int channel;
unsigned int bits;
for (channel = 0; channel < ctx->num_channels; channel++) {
int32_t coeff = mp->coeff[mat][channel];
coeff_mask |= coeff;
}
for (bits = 0; bits < 14 && !(coeff_mask & (1<<bits)); bits++);
mp->fbits [mat] = 14 - bits;
}
/** Determines best coefficients to use for the lossless matrix. */
static void lossless_matrix_coeffs(MLPEncodeContext *ctx)
{
DecodingParams *dp = ctx->cur_decoding_params;
MatrixParams *mp = &dp->matrix_params;
unsigned int shift = 0;
unsigned int channel;
int mat;
enum MLPChMode mode;
/* No decorrelation for non-stereo. */
if (ctx->num_channels - 2 != 2) {
mp->count = 0;
return;
}
mode = estimate_stereo_mode(ctx);
switch(mode) {
/* TODO: add matrix for MID_SIDE */
case MLP_CHMODE_MID_SIDE:
case MLP_CHMODE_LEFT_RIGHT:
mp->count = 0;
break;
case MLP_CHMODE_LEFT_SIDE:
mp->count = 1;
mp->outch[0] = 1;
mp->coeff[0][0] = 1 << 14; mp->coeff[0][1] = -(1 << 14);
mp->coeff[0][2] = 0 << 14; mp->coeff[0][2] = 0 << 14;
mp->forco[0][0] = 1 << 14; mp->forco[0][1] = -(1 << 14);
mp->forco[0][2] = 0 << 14; mp->forco[0][2] = 0 << 14;
break;
case MLP_CHMODE_RIGHT_SIDE:
mp->count = 1;
mp->outch[0] = 0;
mp->coeff[0][0] = 1 << 14; mp->coeff[0][1] = 1 << 14;
mp->coeff[0][2] = 0 << 14; mp->coeff[0][2] = 0 << 14;
mp->forco[0][0] = 1 << 14; mp->forco[0][1] = -(1 << 14);
mp->forco[0][2] = 0 << 14; mp->forco[0][2] = 0 << 14;
break;
}
for (mat = 0; mat < mp->count; mat++)
code_matrix_coeffs(ctx, mat);
for (channel = 0; channel < ctx->num_channels; channel++)
mp->shift[channel] = shift;
}
/** Min and max values that can be encoded with each codebook. The values for
* the third codebook take into account the fact that the sign shift for this
* codebook is outside the coded value, so it has one more bit of precision.
* It should actually be -7 -> 7, shifted down by 0.5.
*/
static const int codebook_extremes[3][2] = {
{-9, 8}, {-8, 7}, {-15, 14},
};
/** Determines the amount of bits needed to encode the samples using no
* codebooks and a specified offset.
*/
static void no_codebook_bits_offset(MLPEncodeContext *ctx,
unsigned int channel, int16_t offset,
int32_t min, int32_t max,
BestOffset *bo)
{
DecodingParams *dp = ctx->cur_decoding_params;
int32_t unsign;
int lsb_bits;
min -= offset;
max -= offset;
lsb_bits = FFMAX(number_sbits(min), number_sbits(max)) - 1;
lsb_bits += !!lsb_bits;
unsign = 1 << (lsb_bits - 1);
bo->offset = offset;
bo->lsb_bits = lsb_bits;
bo->bitcount = lsb_bits * dp->blocksize;
bo->min = offset - unsign + 1;
bo->max = offset + unsign;
}
/** Determines the least amount of bits needed to encode the samples using no
* codebooks.
*/
static void no_codebook_bits(MLPEncodeContext *ctx,
unsigned int channel,
int32_t min, int32_t max,
BestOffset *bo)
{
DecodingParams *dp = ctx->cur_decoding_params;
int16_t offset;
int32_t unsign;
uint32_t diff;
int lsb_bits;
/* Set offset inside huffoffset's boundaries by adjusting extremes
* so that more bits are used, thus shifting the offset. */
if (min < HUFF_OFFSET_MIN)
max = FFMAX(max, 2 * HUFF_OFFSET_MIN - min + 1);
if (max > HUFF_OFFSET_MAX)
min = FFMIN(min, 2 * HUFF_OFFSET_MAX - max - 1);
/* Determine offset and minimum number of bits. */
diff = max - min;
lsb_bits = number_sbits(diff) - 1;
unsign = 1 << (lsb_bits - 1);
/* If all samples are the same (lsb_bits == 0), offset must be
* adjusted because of sign_shift. */
offset = min + diff / 2 + !!lsb_bits;
bo->offset = offset;
bo->lsb_bits = lsb_bits;
bo->bitcount = lsb_bits * dp->blocksize;
bo->min = max - unsign + 1;
bo->max = min + unsign;
}
/** Determines the least amount of bits needed to encode the samples using a
* given codebook and a given offset.
*/
static inline void codebook_bits_offset(MLPEncodeContext *ctx,
unsigned int channel, int codebook,
int32_t sample_min, int32_t sample_max,
int16_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;
int codebook_offset = 7 + (2 - codebook);
int32_t unsign_offset = offset;
int lsb_bits = 0, bitcount = 0;
int offset_min = INT_MAX, offset_max = INT_MAX;
int unsign, mask;
int i;
sample_min -= offset;
sample_max -= offset;
while (sample_min < codebook_min || sample_max > codebook_max) {
lsb_bits++;
sample_min >>= 1;
sample_max >>= 1;
}
unsign = 1 << lsb_bits;
mask = unsign - 1;
if (codebook == 2) {
unsign_offset -= unsign;
lsb_bits++;
}
for (i = 0; i < dp->blocksize; i++) {
int32_t sample = *sample_buffer >> dp->quant_step_size[channel];
int temp_min, temp_max;
sample -= unsign_offset;
temp_min = sample & mask;
if (temp_min < offset_min)
offset_min = temp_min;
temp_max = unsign - temp_min - 1;
if (temp_max < offset_max)
offset_max = temp_max;
sample >>= lsb_bits;
bitcount += ff_mlp_huffman_tables[codebook][sample + codebook_offset][1];
sample_buffer += ctx->num_channels;
}
bo->offset = offset;
bo->lsb_bits = lsb_bits;
bo->bitcount = lsb_bits * dp->blocksize + bitcount;
bo->min = FFMAX(offset - offset_min, HUFF_OFFSET_MIN);
bo->max = FFMIN(offset + offset_max, HUFF_OFFSET_MAX);
}
/** Determines the least amount of bits needed to encode the samples using a
* given codebook. Searches for the best offset to minimize the bits.
*/
static inline void codebook_bits(MLPEncodeContext *ctx,
unsigned int channel, int codebook,
int offset, int32_t min, int32_t max,
BestOffset *bo, int direction)
{
int previous_count = INT_MAX;
int offset_min, offset_max;
int is_greater = 0;
offset_min = FFMAX(min, HUFF_OFFSET_MIN);
offset_max = FFMIN(max, HUFF_OFFSET_MAX);
for (;;) {
BestOffset temp_bo;
codebook_bits_offset(ctx, channel, codebook,
min, max, offset,
&temp_bo);
if (temp_bo.bitcount < previous_count) {
if (temp_bo.bitcount < bo->bitcount)
*bo = temp_bo;
is_greater = 0;
} else if (++is_greater >= ctx->max_codebook_search)
break;
previous_count = temp_bo.bitcount;
if (direction) {
offset = temp_bo.max + 1;
if (offset > offset_max)
break;
} else {
offset = temp_bo.min - 1;
if (offset < offset_min)
break;
}
}
}
/** Determines the least amount of bits needed to encode the samples using
* any or no codebook.
*/
static void determine_bits(MLPEncodeContext *ctx)
{
DecodingParams *dp = ctx->cur_decoding_params;
RestartHeader *rh = ctx->cur_restart_header;
unsigned int channel;
for (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;
int i;
/* Determine extremes and average. */
for (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;
/* 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 (i = 1; i < NUM_CODEBOOKS; i++) {
BestOffset temp_bo = { 0, INT_MAX, 0, 0, 0, };
int16_t offset_max;
codebook_bits_offset(ctx, channel, i - 1,
min, max, offset,
&temp_bo);
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);
}
ctx->cur_best_offset[channel][i] = temp_bo;
}
}
}
/****************************************************************************
*************** Functions that process the data in some way ****************
****************************************************************************/
#define SAMPLE_MAX(bitdepth) ((1 << (bitdepth - 1)) - 1)
#define SAMPLE_MIN(bitdepth) (~SAMPLE_MAX(bitdepth))
#define MSB_MASK(bits) (-1u << bits)
/** Applies the filter to the current samples, and saves the residual back
* into the samples buffer. If the filter is too bad and overflows the
* maximum amount of bits allowed (16 or 24), the samples buffer is left as is and
* the function returns -1.
*/
static int apply_filter(MLPEncodeContext *ctx, unsigned int channel)
{
FilterParams *fp[NUM_FILTERS] = { &ctx->cur_channel_params[channel].filter_params[FIR],
&ctx->cur_channel_params[channel].filter_params[IIR], };
int32_t *filter_state_buffer[NUM_FILTERS];
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;
unsigned int filter_shift = fp[FIR]->shift;
int filter;
int i;
for (i = 0; i < NUM_FILTERS; i++) {
unsigned int size = ctx->number_of_samples;
filter_state_buffer[i] = av_malloc(size*sizeof(int32_t));
if (!filter_state_buffer[i]) {
av_log(ctx->avctx, AV_LOG_ERROR,
"Not enough memory for applying filters.\n");
return -1;
}
}
for (i = 0; i < 8; i++) {
filter_state_buffer[FIR][i] = *sample_buffer;
filter_state_buffer[IIR][i] = *sample_buffer;
sample_buffer += ctx->num_channels;
}
for (i = 8; i < number_of_samples; i++) {
int32_t sample = *sample_buffer;
unsigned int order;
int64_t accum = 0;
int32_t residual;
for (filter = 0; filter < NUM_FILTERS; filter++) {
int32_t *fcoeff = ctx->cur_channel_params[channel].coeff[filter];
for (order = 0; order < fp[filter]->order; order++)
accum += (int64_t)filter_state_buffer[filter][i - 1 - order] *
fcoeff[order];
}
accum >>= filter_shift;
residual = sample - (accum & mask);
if (residual < SAMPLE_MIN(ctx->wordlength) || residual > SAMPLE_MAX(ctx->wordlength))
return -1;
filter_state_buffer[FIR][i] = sample;
filter_state_buffer[IIR][i] = residual;
sample_buffer += ctx->num_channels;
}
sample_buffer = ctx->sample_buffer + channel;
for (i = 0; i < number_of_samples; i++) {
*sample_buffer = filter_state_buffer[IIR][i];
sample_buffer += ctx->num_channels;
}
for (i = 0; i < NUM_FILTERS; i++) {
av_freep(&filter_state_buffer[i]);
}
return 0;
}
static void apply_filters(MLPEncodeContext *ctx)
{
RestartHeader *rh = ctx->cur_restart_header;
int channel;
for (channel = rh->min_channel; channel <= rh->max_channel; channel++) {
if (apply_filter(ctx, channel) < 0) {
/* Filter is horribly wrong.
* Clear filter params and update state. */
set_filter_params(ctx, channel, FIR, 1);
set_filter_params(ctx, channel, IIR, 1);
apply_filter(ctx, channel);
}
}
}
/** 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;
unsigned int i;
uint32_t seed = rh->noisegen_seed;
for (i = 0; i < ctx->number_of_samples; i++) {
uint16_t seed_shr7 = seed >> 7;
*sample_buffer++ = ((int8_t)(seed >> 15)) << rh->noise_shift;
*sample_buffer++ = ((int8_t) seed_shr7) << rh->noise_shift;
seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
sample_buffer += ctx->num_channels - 2;
}
rh->noisegen_seed = seed & ((1 << 24)-1);
}
/** 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;
unsigned int mat, i, maxchan;
maxchan = ctx->num_channels;
for (mat = 0; mat < mp->count; mat++) {
unsigned int msb_mask_bits = (ctx->avctx->sample_fmt == AV_SAMPLE_FMT_S16 ? 8 : 0) - mp->shift[mat];
int32_t mask = MSB_MASK(msb_mask_bits);
unsigned int outch = mp->outch[mat];
sample_buffer = ctx->sample_buffer;
for (i = 0; i < ctx->number_of_samples; i++) {
unsigned int src_ch;
int64_t accum = 0;
for (src_ch = 0; src_ch < maxchan; src_ch++) {
int32_t sample = *(sample_buffer + src_ch);
accum += (int64_t) sample * mp->forco[mat][src_ch];
}
sample_buffer[outch] = (accum >> 14) & mask;
sample_buffer += ctx->num_channels;
}
}
}
/****************************************************************************
**** Functions that deal with determining the best parameters and output ***
****************************************************************************/
typedef struct {
char path[MAJOR_HEADER_INTERVAL + 3];
int bitcount;
} PathCounter;
static const char *path_counter_codebook[] = { "0", "1", "2", "3", };
#define ZERO_PATH '0'
#define CODEBOOK_CHANGE_BITS 21
static void clear_path_counter(PathCounter *path_counter)
{
unsigned int i;
for (i = 0; i < NUM_CODEBOOKS + 1; i++) {
path_counter[i].path[0] = ZERO_PATH;
path_counter[i].path[1] = 0x00;
path_counter[i].bitcount = 0;
}
}
static int compare_best_offset(BestOffset *prev, BestOffset *cur)
{
if (prev->lsb_bits != cur->lsb_bits)
return 1;
return 0;
}
static int best_codebook_path_cost(MLPEncodeContext *ctx, unsigned int channel,
PathCounter *src, int cur_codebook)
{
BestOffset *cur_bo, *prev_bo = restart_best_offset;
int bitcount = src->bitcount;
char *path = src->path + 1;
int prev_codebook;
int i;
for (i = 0; path[i]; i++)
prev_bo = ctx->best_offset[i][channel];
prev_codebook = path[i - 1] - ZERO_PATH;
cur_bo = ctx->best_offset[i][channel];
bitcount += cur_bo[cur_codebook].bitcount;
if (prev_codebook != cur_codebook ||
compare_best_offset(&prev_bo[prev_codebook], &cur_bo[cur_codebook]))
bitcount += CODEBOOK_CHANGE_BITS;
return bitcount;
}
static void set_best_codebook(MLPEncodeContext *ctx)
{
DecodingParams *dp = ctx->cur_decoding_params;
RestartHeader *rh = ctx->cur_restart_header;
unsigned int channel;
for (channel = rh->min_channel; channel <= rh->max_channel; channel++) {
BestOffset *cur_bo, *prev_bo = restart_best_offset;
PathCounter path_counter[NUM_CODEBOOKS + 1];
unsigned int best_codebook;
unsigned int index;
char *best_path;
clear_path_counter(path_counter);
for (index = 0; index < ctx->number_of_subblocks; index++) {
unsigned int best_bitcount = INT_MAX;
unsigned int codebook;
cur_bo = ctx->best_offset[index][channel];
for (codebook = 0; codebook < NUM_CODEBOOKS; codebook++) {
int prev_best_bitcount = INT_MAX;
int last_best;
for (last_best = 0; last_best < 2; last_best++) {
PathCounter *dst_path = &path_counter[codebook];
PathCounter *src_path;
int temp_bitcount;
/* First test last path with same headers,
* then with last best. */
if (last_best) {
src_path = &path_counter[NUM_CODEBOOKS];
} else {
if (compare_best_offset(&prev_bo[codebook], &cur_bo[codebook]))
continue;
else
src_path = &path_counter[codebook];
}
temp_bitcount = best_codebook_path_cost(ctx, channel, src_path, codebook);
if (temp_bitcount < best_bitcount) {
best_bitcount = temp_bitcount;
best_codebook = codebook;
}
if (temp_bitcount < prev_best_bitcount) {
prev_best_bitcount = temp_bitcount;
if (src_path != dst_path)
memcpy(dst_path, src_path, sizeof(PathCounter));
av_strlcat(dst_path->path, path_counter_codebook[codebook], sizeof(dst_path->path));
dst_path->bitcount = temp_bitcount;
}
}
}
prev_bo = cur_bo;
memcpy(&path_counter[NUM_CODEBOOKS], &path_counter[best_codebook], sizeof(PathCounter));
}
best_path = path_counter[NUM_CODEBOOKS].path + 1;
/* Update context. */
for (index = 0; index < ctx->number_of_subblocks; index++) {
ChannelParams *cp = ctx->seq_channel_params + index*(ctx->avctx->channels) + channel;
best_codebook = *best_path++ - ZERO_PATH;
cur_bo = &ctx->best_offset[index][channel][best_codebook];
cp->huff_offset = cur_bo->offset;
cp->huff_lsbs = cur_bo->lsb_bits + dp->quant_step_size[channel];
cp->codebook = best_codebook;
}
}
}
/** Analyzes all collected bitcounts and selects the best parameters for each
* individual access unit.
* TODO This is just a stub!
*/
static void set_major_params(MLPEncodeContext *ctx)
{
RestartHeader *rh = ctx->cur_restart_header;
unsigned int index;
unsigned int substr;
uint8_t max_huff_lsbs = 0;
uint8_t max_output_bits = 0;
for (substr = 0; substr < ctx->num_substreams; substr++) {
DecodingParams *seq_dp = (DecodingParams *) ctx->decoding_params+
(ctx->restart_intervals - 1)*(ctx->sequence_size)*(ctx->avctx->channels) +
(ctx->seq_offset[ctx->restart_intervals - 1])*(ctx->avctx->channels);
ChannelParams *seq_cp = (ChannelParams *) ctx->channel_params +
(ctx->restart_intervals - 1)*(ctx->sequence_size)*(ctx->avctx->channels) +
(ctx->seq_offset[ctx->restart_intervals - 1])*(ctx->avctx->channels);
unsigned int channel;
for (index = 0; index < ctx->seq_size[ctx->restart_intervals-1]; index++) {
memcpy(&ctx->major_decoding_params[index][substr], seq_dp + index*(ctx->num_substreams) + substr, sizeof(DecodingParams));
for (channel = 0; channel < ctx->avctx->channels; channel++) {
uint8_t huff_lsbs = (seq_cp + index*(ctx->avctx->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),
sizeof(ChannelParams));
}
}
}
rh->max_huff_lsbs = max_huff_lsbs;
for (index = 0; index < ctx->number_of_frames; index++)
if (max_output_bits < ctx->max_output_bits[index])
max_output_bits = ctx->max_output_bits[index];
rh->max_output_bits = max_output_bits;
for (substr = 0; substr < ctx->num_substreams; substr++) {
ctx->cur_restart_header = &ctx->restart_header[substr];
ctx->prev_decoding_params = &restart_decoding_params[substr];
ctx->prev_channel_params = restart_channel_params;
for (index = 0; index < MAJOR_HEADER_INTERVAL + 1; index++) {
ctx->cur_decoding_params = &ctx->major_decoding_params[index][substr];
ctx->cur_channel_params = ctx->major_channel_params[index];
ctx->major_params_changed[index][substr] = compare_decoding_params(ctx);
ctx->prev_decoding_params = ctx->cur_decoding_params;
ctx->prev_channel_params = ctx->cur_channel_params;
}
}
ctx->major_number_of_subblocks = ctx->number_of_subblocks;
ctx->major_filter_state_subblock = 1;
ctx->major_cur_subblock_index = 0;
}
static void analyze_sample_buffer(MLPEncodeContext *ctx)
{
ChannelParams *seq_cp = ctx->seq_channel_params;
DecodingParams *seq_dp = ctx->seq_decoding_params;
unsigned int index;
unsigned int substr;
for (substr = 0; substr < ctx->num_substreams; substr++) {
ctx->cur_restart_header = &ctx->restart_header[substr];
ctx->cur_decoding_params = seq_dp + 1*(ctx->num_substreams) + substr;
ctx->cur_channel_params = seq_cp + 1*(ctx->avctx->channels);
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, substr);
/* Copy frame_size from frames 0...max to decoding_params 1...max + 1
* decoding_params[0] is for the filter state subblock.
*/
for (index = 0; index < ctx->number_of_frames; index++) {
DecodingParams *dp = seq_dp + (index + 1)*(ctx->num_substreams) + substr;
dp->blocksize = ctx->frame_size[index];
}
/* The official encoder seems to always encode a filter state subblock
* even if there are no filters. TODO check if it is possible to skip
* the filter state subblock for no filters.
*/
(seq_dp + substr)->blocksize = 8;
(seq_dp + 1*(ctx->num_substreams) + substr)->blocksize -= 8;
for (index = 0; index < ctx->number_of_subblocks; index++) {
ctx->cur_decoding_params = seq_dp + index*(ctx->num_substreams) + substr;
ctx->cur_channel_params = seq_cp + index*(ctx->avctx->channels);
ctx->cur_best_offset = ctx->best_offset[index];
determine_bits(ctx);
ctx->sample_buffer += ctx->cur_decoding_params->blocksize * ctx->num_channels;
}
set_best_codebook(ctx);
}
}
static void process_major_frame(MLPEncodeContext *ctx)
{
unsigned int substr;
ctx->sample_buffer = ctx->major_inout_buffer;
ctx->starting_frame_index = 0;
ctx->number_of_frames = ctx->major_number_of_frames;
ctx->number_of_samples = ctx->major_frame_size;
for (substr = 0; substr < ctx->num_substreams; substr++) {
RestartHeader *rh = ctx->cur_restart_header;
unsigned int channel;
ctx->cur_restart_header = &ctx->restart_header[substr];
ctx->cur_decoding_params = &ctx->major_decoding_params[1][substr];
ctx->cur_channel_params = ctx->major_channel_params[1];
generate_2_noise_channels(ctx);
rematrix_channels (ctx);
for (channel = rh->min_channel; channel <= rh->max_channel; channel++)
apply_filter(ctx, channel);
}
}
/****************************************************************************/
static int mlp_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
const AVFrame *frame, int *got_packet)
{
MLPEncodeContext *ctx = avctx->priv_data;
unsigned int bytes_written = 0;
int restart_frame, ret;
uint8_t *data;
if ((ret = ff_alloc_packet2(avctx, avpkt, 87500 * avctx->channels, 0)) < 0)
return ret;
if (!frame)
return 1;
/* add current frame to queue */
if (frame) {
if ((ret = ff_af_queue_add(&ctx->afq, frame)) < 0)
return ret;
}
data = frame->data[0];
ctx->frame_index = avctx->frame_number % ctx->max_restart_interval;
ctx->inout_buffer = ctx->major_inout_buffer
+ ctx->frame_index * ctx->one_sample_buffer_size;
if (ctx->last_frame == ctx->inout_buffer) {
return 0;
}
ctx->sample_buffer = ctx->major_scratch_buffer
+ ctx->frame_index * ctx->one_sample_buffer_size;
ctx->write_buffer = ctx->inout_buffer;
if (avctx->frame_number < ctx->max_restart_interval) {
if (data) {
goto input_and_return;
} else {
/* There are less frames than the requested major header interval.
* Update the context to reflect this.
*/
ctx->max_restart_interval = avctx->frame_number;
ctx->frame_index = 0;
ctx->sample_buffer = ctx->major_scratch_buffer;
ctx->inout_buffer = ctx->major_inout_buffer;
}
}
if (ctx->frame_size[ctx->frame_index] > MAX_BLOCKSIZE) {
av_log(avctx, AV_LOG_ERROR, "Invalid frame size (%d > %d)\n",
ctx->frame_size[ctx->frame_index], MAX_BLOCKSIZE);
return -1;
}
restart_frame = !ctx->frame_index;
if (restart_frame) {
set_major_params(ctx);
if (ctx->min_restart_interval != ctx->max_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->timestamp += ctx->frame_size[ctx->frame_index];
ctx->dts += ctx->frame_size[ctx->frame_index];
input_and_return:
if (data) {
ctx->frame_size[ctx->frame_index] = avctx->frame_size;
ctx->next_major_frame_size += avctx->frame_size;
ctx->next_major_number_of_frames++;
input_data(ctx, data);
} else if (!ctx->last_frame) {
ctx->last_frame = ctx->inout_buffer;
}
restart_frame = (ctx->frame_index + 1) % ctx->min_restart_interval;
if (!restart_frame) {
int seq_index;
for (seq_index = 0;
seq_index < ctx->restart_intervals && (seq_index * ctx->min_restart_interval) <= ctx->avctx->frame_number;
seq_index++) {
unsigned int number_of_samples = 0;
unsigned int index;
ctx->sample_buffer = ctx->major_scratch_buffer;
ctx->inout_buffer = ctx->major_inout_buffer;
ctx->seq_index = seq_index;
ctx->starting_frame_index = (ctx->avctx->frame_number - (ctx->avctx->frame_number % ctx->min_restart_interval)
- (seq_index * ctx->min_restart_interval)) % ctx->max_restart_interval;
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 = (ChannelParams *) ctx->channel_params +
(ctx->frame_index / ctx->min_restart_interval)*(ctx->sequence_size)*(ctx->avctx->channels) +
(ctx->seq_offset[seq_index])*(ctx->avctx->channels);
ctx->seq_decoding_params = (DecodingParams *) ctx->decoding_params +
(ctx->frame_index / ctx->min_restart_interval)*(ctx->sequence_size)*(ctx->num_substreams) +
(ctx->seq_offset[seq_index])*(ctx->num_substreams);
for (index = 0; index < ctx->number_of_frames; index++) {
number_of_samples += ctx->frame_size[(ctx->starting_frame_index + index) % ctx->max_restart_interval];
}
ctx->number_of_samples = number_of_samples;
for (index = 0; index < ctx->seq_size[seq_index]; index++) {
clear_channel_params(ctx, ctx->seq_channel_params + index*(ctx->avctx->channels));
default_decoding_params(ctx, ctx->seq_decoding_params + index*(ctx->num_substreams));
}
input_to_sample_buffer(ctx);
analyze_sample_buffer(ctx);
}
if (ctx->frame_index == (ctx->max_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;
ctx->next_major_number_of_frames = 0;
if (!ctx->major_frame_size)
goto no_data_left;
}
}
no_data_left:
ff_af_queue_remove(&ctx->afq, avctx->frame_size, &avpkt->pts,
&avpkt->duration);
avpkt->size = bytes_written;
*got_packet = 1;
return 0;
}
static av_cold int mlp_encode_close(AVCodecContext *avctx)
{
MLPEncodeContext *ctx = avctx->priv_data;
ff_lpc_end(&ctx->lpc_ctx);
av_freep(&ctx->lossless_check_data);
av_freep(&ctx->major_scratch_buffer);
av_freep(&ctx->major_inout_buffer);
av_freep(&ctx->lpc_sample_buffer);
av_freep(&ctx->decoding_params);
av_freep(&ctx->channel_params);
av_freep(&ctx->frame_size);
ff_af_queue_close(&ctx->afq);
return 0;
}
#if CONFIG_MLP_ENCODER
AVCodec ff_mlp_encoder = {
.name ="mlp",
.long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
.type = AVMEDIA_TYPE_AUDIO,
.id = AV_CODEC_ID_MLP,
.priv_data_size = sizeof(MLPEncodeContext),
.init = mlp_encode_init,
.encode2 = mlp_encode_frame,
.close = mlp_encode_close,
.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_NONE},
.supported_samplerates = (const int[]) {44100, 48000, 88200, 96000, 176400, 192000, 0},
.channel_layouts = ff_mlp_channel_layouts,
};
#endif
#if CONFIG_TRUEHD_ENCODER
AVCodec ff_truehd_encoder = {
.name ="truehd",
.long_name = NULL_IF_CONFIG_SMALL("TrueHD"),
.type = AVMEDIA_TYPE_AUDIO,
.id = AV_CODEC_ID_TRUEHD,
.priv_data_size = sizeof(MLPEncodeContext),
.init = mlp_encode_init,
.encode2 = mlp_encode_frame,
.close = mlp_encode_close,
.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_NONE},
.supported_samplerates = (const int[]) {44100, 48000, 88200, 96000, 176400, 192000, 0},
.channel_layouts = (const uint64_t[]) {AV_CH_LAYOUT_STEREO, AV_CH_LAYOUT_5POINT0_BACK, AV_CH_LAYOUT_5POINT1_BACK, 0},
};
#endif
Reference in New Issue View Git Blame Copy Permalink