33 #define MAJOR_HEADER_INTERVAL 16 35 #define MLP_MIN_LPC_ORDER 1 36 #define MLP_MAX_LPC_ORDER 8 37 #define MLP_MIN_LPC_SHIFT 8 38 #define MLP_MAX_LPC_SHIFT 15 97 #define HUFF_OFFSET_MIN (-16384) 98 #define HUFF_OFFSET_MAX ( 16383) 101 #define NUM_CODEBOOKS 4 111 int coded_sample_fmt [2];
112 int coded_sample_rate[2];
208 #define SYNC_MAJOR 0xf8726f 209 #define MAJOR_SYNC_INFO_SIGNATURE 0xB752 211 #define SYNC_MLP 0xbb 212 #define SYNC_TRUEHD 0xba 215 #define FLAGS_DVDA 0x4000 217 #define FLAGS_CONST 0x8000 219 #define SUBSTREAM_INFO_MAX_2_CHAN 0x01 220 #define SUBSTREAM_INFO_HIGH_RATE 0x02 221 #define SUBSTREAM_INFO_ALWAYS_SET 0x04 222 #define SUBSTREAM_INFO_2_SUBSTREAMS 0x08 246 for (i = 0; i < fp->
order; i++)
247 if (prev_cp->
coeff[filter][i] != cp->
coeff[filter][i])
268 if (prev->
fbits[channel] != mp->
fbits[channel])
271 for (mat = 0; mat < mp->
count; mat++) {
275 for (channel = 0; channel < ctx->
num_channels; channel++)
276 if (prev->
coeff[mat][channel] != mp->
coeff[mat][channel])
317 for (ch = rh->
min_channel; ch <= rh->max_channel; ch++) {
355 for (order = 0; order < dst->
order; order++)
356 dst_cp->
coeff[filter][order] = src_cp->
coeff[filter][order];
372 dst->
coeff[count][channel] = src->
coeff[count][channel];
391 for (channel = 0; channel < ctx->
avctx->
channels; channel++) {
426 for (channel = 0; channel < ctx->
avctx->
channels; channel++) {
448 uint8_t param_presence_flags = 0;
490 unsigned int substr,
index;
491 unsigned int sum = 0;
532 "sample rates are 44100, 88200, 176400, 48000, " 544 "Only mono and stereo are supported at the moment.\n");
566 "Only 16- and 24-bit samples are supported.\n");
590 "Not enough memory for buffering samples.\n");
599 "Not enough memory for buffering samples.\n");
606 "Not enough memory for buffering samples.\n");
704 "Not enough memory for analysis context.\n");
713 "Not enough memory for analysis context.\n");
735 "Not enough memory for LPC context.\n");
853 for (mat = 0; mat < mp->
count; mat++) {
860 for (channel = 0; channel < ctx->
num_channels; channel++) {
866 coeff >>= 14 - mp->
fbits[mat];
892 for (i = 0; i < fp->
order; i++) {
958 for (ch = rh->
min_channel; ch <= rh->max_channel; ch++) {
1015 for (ch = rh->
min_channel; ch <= rh->max_channel; ch++) {
1020 codebook_index [ch] = cp->
codebook - 1;
1026 sign_huff_offset[ch] -= 7 << lsb_bits[ch];
1029 if (sign_shift >= 0)
1030 sign_huff_offset[ch] -= 1 << sign_shift;
1034 for (ch = rh->
min_channel; ch <= rh->max_channel; ch++) {
1036 sample -= sign_huff_offset[ch];
1038 if (codebook_index[ch] >= 0) {
1039 int vlc = sample >> lsb_bits[ch];
1058 unsigned int substr;
1066 unsigned int subblock;
1068 int substr_restart_frame = restart_frame;
1077 for (subblock = 0; subblock <= num_subblocks; subblock++) {
1078 unsigned int subblock_index;
1080 subblock_index = cur_subblock_index++;
1087 if (substr_restart_frame || params_changed) {
1090 if (substr_restart_frame) {
1106 put_bits(&pb, 1, !substr_restart_frame);
1108 substr_restart_frame = 0;
1133 substream_data_len[substr] = end;
1150 uint16_t access_unit_header = 0;
1151 uint16_t parity_nibble = 0;
1152 unsigned int substr;
1154 parity_nibble = ctx->
dts;
1158 uint16_t substr_hdr = 0;
1160 substr_hdr |= (0 << 15);
1161 substr_hdr |= (!restart_frame << 14);
1162 substr_hdr |= (1 << 13);
1163 substr_hdr |= (0 << 12);
1164 substr_hdr |= (substream_data_len[substr] / 2) & 0x0FFF;
1166 AV_WB16(substream_headers, substr_hdr);
1168 parity_nibble ^= *substream_headers++;
1169 parity_nibble ^= *substream_headers++;
1172 parity_nibble ^= parity_nibble >> 8;
1173 parity_nibble ^= parity_nibble >> 4;
1174 parity_nibble &= 0xF;
1176 access_unit_header |= (parity_nibble ^ 0xF) << 12;
1177 access_unit_header |= length & 0xFFF;
1179 AV_WB16(frame_header , access_unit_header);
1185 int buf_size,
int restart_frame)
1189 unsigned int substr;
1199 if (restart_frame) {
1215 buf =
write_substrs(ctx, buf, buf_size, restart_frame, substream_data_len);
1217 total_length = buf - buf0;
1219 write_frame_headers(ctx, buf0, buf1, total_length / 2, restart_frame, substream_data_len);
1221 return total_length;
1237 const int16_t *samples_16 = (
const int16_t *) samples;
1238 unsigned int substr;
1245 int32_t temp_lossless_check_data = 0;
1246 uint32_t greatest = 0;
1251 for (channel = 0; channel <= rh->
max_channel; channel++) {
1252 uint32_t abs_sample;
1255 sample = is24 ? *samples_32++ >> 8 : *samples_16++ * 256;
1258 abs_sample =
FFABS(sample);
1259 if (greatest < abs_sample)
1260 greatest = abs_sample;
1262 temp_lossless_check_data ^= (sample & 0x00ffffff) << channel;
1263 *sample_buffer++ =
sample;
1271 *lossless_check_data++ = temp_lossless_check_data;
1296 *sample_buffer++ = *input_buffer++;
1312 for (bits = 0; bits < 24 && !(sample & (1<<
bits)); bits++);
1335 memset(sample_mask, 0x00,
sizeof(sample_mask));
1338 for (channel = 0; channel <= rh->
max_channel; channel++)
1339 sample_mask[channel] |= *sample_buffer++;
1344 for (channel = 0; channel <= rh->
max_channel; channel++)
1354 int min = INT_MAX,
max = INT_MIN;
1359 for (order = 0; order < fp->
order; order++) {
1360 int coeff = fcoeff[order];
1367 coeff_mask |=
coeff;
1372 for (shift = 0; shift < 7 && bits + shift < 16 && !(coeff_mask & (1<<
shift)); shift++);
1392 }
else if (filter ==
IIR) {
1394 }
else if (filter ==
FIR) {
1406 *lpc_samples++ = *sample_buffer;
1417 fp->
shift = shift[order-1];
1419 for (i = 0; i < order; i++)
1420 fcoeff[i] = coefs[order-1][i];
1450 uint64_t score[4], sum[4] = { 0, 0, 0, 0, };
1460 sum[0] +=
FFABS( left );
1461 sum[1] +=
FFABS( right);
1462 sum[2] +=
FFABS((left + right) >> 1);
1463 sum[3] +=
FFABS( left - right);
1471 for(i = 1; i < 3; i++)
1472 if(score[i] < score[best])
1489 for (channel = 0; channel < ctx->
num_channels; channel++) {
1491 coeff_mask |=
coeff;
1494 for (bits = 0; bits < 14 && !(coeff_mask & (1<<
bits)); bits++);
1504 unsigned int shift = 0;
1526 mp->
coeff[0][0] = 1 << 14; mp->
coeff[0][1] = -(1 << 14);
1527 mp->
coeff[0][2] = 0 << 14; mp->
coeff[0][2] = 0 << 14;
1528 mp->
forco[0][0] = 1 << 14; mp->
forco[0][1] = -(1 << 14);
1529 mp->
forco[0][2] = 0 << 14; mp->
forco[0][2] = 0 << 14;
1534 mp->
coeff[0][0] = 1 << 14; mp->
coeff[0][1] = 1 << 14;
1535 mp->
coeff[0][2] = 0 << 14; mp->
coeff[0][2] = 0 << 14;
1536 mp->
forco[0][0] = 1 << 14; mp->
forco[0][1] = -(1 << 14);
1537 mp->
forco[0][2] = 0 << 14; mp->
forco[0][2] = 0 << 14;
1541 for (mat = 0; mat < mp->
count; mat++)
1544 for (channel = 0; channel < ctx->
num_channels; channel++)
1545 mp->
shift[channel] = shift;
1554 {-9, 8}, {-8, 7}, {-15, 14},
1577 unsign = 1 << (lsb_bits - 1);
1582 bo->
min = offset - unsign + 1;
1583 bo->
max = offset + unsign;
1613 unsign = 1 << (lsb_bits - 1);
1617 offset = min + diff / 2 + !!
lsb_bits;
1622 bo->
min = max - unsign + 1;
1623 bo->
max = min + unsign;
1638 int codebook_offset = 7 + (2 -
codebook);
1641 int offset_min = INT_MAX, offset_max = INT_MAX;
1648 while (sample_min < codebook_min || sample_max > codebook_max) {
1657 if (codebook == 2) {
1658 unsign_offset -= unsign;
1664 int temp_min, temp_max;
1666 sample -= unsign_offset;
1668 temp_min = sample &
mask;
1669 if (temp_min < offset_min)
1670 offset_min = temp_min;
1672 temp_max = unsign - temp_min - 1;
1673 if (temp_max < offset_max)
1674 offset_max = temp_max;
1698 int previous_count = INT_MAX;
1699 int offset_min, offset_max;
1705 while (offset <= offset_max && offset >= offset_min) {
1712 if (temp_bo.
bitcount < previous_count) {
1723 offset = temp_bo.
max + 1;
1725 offset = temp_bo.
min - 1;
1739 for (channel = 0; channel <= rh->
max_channel; channel++) {
1762 if (no_filters_used) {
1770 BestOffset temp_bo = { 0, INT_MAX, 0, 0, 0, };
1777 if (no_filters_used) {
1778 offset_max = temp_bo.
max;
1781 min, max, &temp_bo, 0);
1783 min, max, &temp_bo, 1);
1795 #define SAMPLE_MAX(bitdepth) ((1 << (bitdepth - 1)) - 1) 1796 #define SAMPLE_MIN(bitdepth) (~SAMPLE_MAX(bitdepth)) 1798 #define MSB_MASK(bits) (-(int)(1u << (bits))) 1813 unsigned int filter_shift = fp[
FIR]->
shift;
1820 if (!filter_state_buffer[i]) {
1822 "Not enough memory for applying filters.\n");
1824 goto free_and_return;
1828 for (i = 0; i < 8; i++) {
1829 filter_state_buffer[
FIR][
i] = *sample_buffer;
1830 filter_state_buffer[
IIR][
i] = *sample_buffer;
1835 for (i = 8; i < number_of_samples; i++) {
1841 for (filter = 0; filter <
NUM_FILTERS; filter++) {
1843 for (order = 0; order < fp[
filter]->
order; order++)
1844 accum += (int64_t)filter_state_buffer[
filter][i - 1 - order] *
1848 accum >>= filter_shift;
1849 residual = sample - (accum &
mask);
1853 goto free_and_return;
1863 for (i = 0; i < number_of_samples; i++) {
1864 *sample_buffer = filter_state_buffer[
IIR][
i];
1902 uint16_t seed_shr7 = seed >> 7;
1903 *sample_buffer++ = ((int8_t)(seed >> 15)) * (1 << rh->
noise_shift);
1904 *sample_buffer++ = ((int8_t) seed_shr7) * (1 << rh->
noise_shift);
1906 seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
1920 unsigned int mat,
i, maxchan;
1924 for (mat = 0; mat < mp->
count; mat++) {
1927 unsigned int outch = mp->
outch[mat];
1931 unsigned int src_ch;
1934 for (src_ch = 0; src_ch < maxchan; src_ch++) {
1936 accum += (int64_t) sample * mp->
forco[mat][src_ch];
1938 sample_buffer[outch] = (accum >> 14) &
mask;
1955 #define CODEBOOK_CHANGE_BITS 21 1959 memset(path_counter, 0, (
NUM_CODEBOOKS + 1) *
sizeof(*path_counter));
1977 int prev_codebook = src->
path[idx];
1979 bitcount += cur_bo[cur_codebook].
bitcount;
1981 if (prev_codebook != cur_codebook ||
1997 unsigned int best_codebook;
2004 unsigned int best_bitcount = INT_MAX;
2010 int prev_best_bitcount = INT_MAX;
2013 for (last_best = 0; last_best < 2; last_best++) {
2026 src_path = &path_counter[
codebook];
2031 if (temp_bitcount < best_bitcount) {
2032 best_bitcount = temp_bitcount;
2036 if (temp_bitcount < prev_best_bitcount) {
2037 prev_best_bitcount = temp_bitcount;
2038 if (src_path != dst_path)
2042 dst_path->
bitcount = temp_bitcount;
2049 memcpy(&path_counter[NUM_CODEBOOKS], &path_counter[best_codebook],
sizeof(
PathCounter));
2058 best_codebook = *best_path++;
2076 unsigned int substr;
2091 for (channel = 0; channel < ctx->
avctx->
channels; channel++) {
2093 if (max_huff_lsbs < huff_lsbs)
2094 max_huff_lsbs = huff_lsbs;
2105 if (max_output_bits < ctx->max_output_bits[index])
2137 unsigned int substr;
2165 (seq_dp + substr)->blocksize = 8;
2182 unsigned int substr;
2209 unsigned int bytes_written = 0;
2210 int restart_frame,
ret;
2220 data = frame->
data[0];
2238 goto input_and_return;
2259 if (restart_frame) {
2286 if (!restart_frame) {
2292 unsigned int number_of_samples = 0;
2317 for (index = 0; index < ctx->
seq_size[seq_index]; index++) {
2342 avpkt->
size = bytes_written;
2366 #if CONFIG_MLP_ENCODER 2378 .supported_samplerates = (
const int[]) {44100, 48000, 88200, 96000, 176400, 192000, 0},
2383 #if CONFIG_TRUEHD_ENCODER 2395 .supported_samplerates = (
const int[]) {44100, 48000, 88200, 96000, 176400, 192000, 0},
uint8_t shift
Right shift to apply to output of filter.
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
AVCodec ff_truehd_encoder
void ff_af_queue_remove(AudioFrameQueue *afq, int nb_samples, int64_t *pts, int64_t *duration)
Remove frame(s) from the queue.
unsigned int seq_size[MAJOR_HEADER_INTERVAL]
int32_t * lpc_sample_buffer
static void analyze_sample_buffer(MLPEncodeContext *ctx)
#define SAMPLE_MIN(bitdepth)
#define AV_CH_LAYOUT_4POINT1
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
static void default_decoding_params(MLPEncodeContext *ctx, DecodingParams decoding_params[MAX_SUBSTREAMS])
Sets default vales in our encoder for a DecodingParams struct.
static const unsigned codebook[256][2]
DecodingParams * seq_decoding_params
static int shift(int a, int b)
FilterParams filter_params[NUM_FILTERS]
static int mlp_peak_bitrate(int peak_bitrate, int sample_rate)
This structure describes decoded (raw) audio or video data.
static int compare_decoding_params(MLPEncodeContext *ctx)
Compares two DecodingParams and ChannelParams structures to decide if a new decoding params header ha...
#define SUBSTREAM_INFO_ALWAYS_SET
ptrdiff_t const GLvoid * data
unsigned int seq_offset[MAJOR_HEADER_INTERVAL]
unsigned int number_of_subblocks
static int best_codebook_path_cost(MLPEncodeContext *ctx, unsigned int channel, PathCounter *src, int cur_codebook)
static void put_sbits(PutBitContext *pb, int n, int32_t value)
static void write_filter_params(MLPEncodeContext *ctx, PutBitContext *pb, unsigned int channel, unsigned int filter)
Writes filter parameters for one filter to the bitstream.
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
#define AV_LOG_WARNING
Something somehow does not look correct.
#define AV_CH_LAYOUT_SURROUND
uint16_t ff_mlp_checksum16(const uint8_t *buf, unsigned int buf_size)
static av_cold int init(AVCodecContext *avctx)
unsigned int min_restart_interval
Min interval of access units in between two major frames.
static int compare_matrix_params(MLPEncodeContext *ctx, const MatrixParams *prev, const MatrixParams *mp)
Compare two primitive matrices and returns 1 if anything has changed.
static int mlp_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet)
uint8_t param_presence_flags
Bitmask of which parameter sets are conveyed in a decoding parameter block.
DecodingParams major_decoding_params[MAJOR_HEADER_INTERVAL+1][MAX_SUBSTREAMS]
DecodingParams to be written to bitstream.
static void codebook_bits_offset(MLPEncodeContext *ctx, unsigned int channel, int codebook, int32_t sample_min, int32_t sample_max, int16_t offset, BestOffset *bo)
Determines the least amount of bits needed to encode the samples using a given codebook and a given o...
#define MAJOR_SYNC_INFO_SIGNATURE
unsigned int major_cur_subblock_index
unsigned int major_number_of_frames
const uint8_t ff_mlp_huffman_tables[3][18][2]
Tables defining the Huffman codes.
#define AV_CODEC_CAP_EXPERIMENTAL
Codec is experimental and is thus avoided in favor of non experimental encoders.
static void code_matrix_coeffs(MLPEncodeContext *ctx, unsigned int mat)
Determines how many fractional bits are needed to encode matrix coefficients.
#define AV_CH_LAYOUT_4POINT0
#define SUBSTREAM_INFO_MAX_2_CHAN
#define FF_ARRAY_ELEMS(a)
unsigned int next_major_frame_size
Counter of number of samples for next major frame.
int coded_sample_fmt[2]
sample format encoded for MLP
#define AV_CH_LAYOUT_STEREO
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
static const float quant_step_size[]
static void copy_matrix_params(MatrixParams *dst, MatrixParams *src)
const uint64_t ff_mlp_channel_layouts[12]
int32_t * sample_buffer
Pointer to current access unit samples.
static const int codebook_extremes[3][2]
Min and max values that can be encoded with each codebook.
static void write_matrix_params(MLPEncodeContext *ctx, PutBitContext *pb)
Writes matrix params for all primitive matrices to the bitstream.
int32_t * major_scratch_buffer
Scratch buffer big enough to fit all data for one entire major frame interval.
static int compare_filter_params(const ChannelParams *prev_cp, const ChannelParams *cp, int filter)
Compares two FilterParams structures and returns 1 if anything has changed.
#define NUM_CODEBOOKS
Number of possible codebooks (counting "no codebooks")
static void code_filter_coeffs(MLPEncodeContext *ctx, FilterParams *fp, int32_t *fcoeff)
Determines the smallest number of bits needed to encode the filter coefficients, and if it's possible...
unsigned int number_of_frames
DecodingParams * prev_decoding_params
int32_t forco[MAX_MATRICES][MAX_CHANNELS+2]
forward coefficients
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
uint16_t blocksize
number of PCM samples in current audio block
static void process_major_frame(MLPEncodeContext *ctx)
int8_t shift[MAX_CHANNELS]
Left shift to apply to decoded PCM values to get final 24-bit output.
enum AVSampleFormat sample_fmt
audio sample format
#define MAJOR_HEADER_INTERVAL
MLP encoder Copyright (c) 2008 Ramiro Polla Copyright (c) 2016-2019 Jai Luthra.
uint8_t fbits[MAX_CHANNELS]
fraction bits
static av_cold int mlp_encode_close(AVCodecContext *avctx)
static uint8_t xor_32_to_8(uint32_t value)
XOR four bytes into one.
static void clear_channel_params(MLPEncodeContext *ctx, ChannelParams channel_params[MAX_CHANNELS])
Clears a ChannelParams struct the way it should be after a restart header.
av_cold void ff_af_queue_init(AVCodecContext *avctx, AudioFrameQueue *afq)
Initialize AudioFrameQueue.
ChannelParams * seq_channel_params
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
static void no_codebook_bits(MLPEncodeContext *ctx, unsigned int channel, int32_t min, int32_t max, BestOffset *bo)
Determines the least amount of bits needed to encode the samples using no codebooks.
Public header for CRC hash function implementation.
#define MLP_MIN_LPC_ORDER
static void input_data(MLPEncodeContext *ctx, void *samples)
Wrapper function for inputting data in two different bit-depths.
static void clear_path_counter(PathCounter *path_counter)
static void apply_filters(MLPEncodeContext *ctx)
static ChannelParams restart_channel_params[MAX_CHANNELS]
static uint8_t * write_substrs(MLPEncodeContext *ctx, uint8_t *buf, int buf_size, int restart_frame, uint16_t substream_data_len[MAX_SUBSTREAMS])
Writes the substreams data to the bitstream.
int16_t huff_offset
Offset to apply to residual values.
unsigned int sequence_size
static void set_major_params(MLPEncodeContext *ctx)
Analyzes all collected bitcounts and selects the best parameters for each individual access unit...
static void generate_2_noise_channels(MLPEncodeContext *ctx)
Generates two noise channels worth of data.
int flags
major sync info flags
ChannelParams major_channel_params[MAJOR_HEADER_INTERVAL+1][MAX_CHANNELS]
ChannelParams to be written to bitstream.
#define NUM_FILTERS
number of allowed filters
uint8_t ff_mlp_calculate_parity(const uint8_t *buf, unsigned int buf_size)
XOR together all the bytes of a buffer.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static int number_trailing_zeroes(int32_t sample)
Counts the number of trailing zeroes in a value.
unsigned int major_frame_size
Number of samples in current major frame being encoded.
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce then the filter should push the output frames on the output link immediately As an exception to the previous rule if the input frame is enough to produce several output frames then the filter needs output only at least one per link The additional frames can be left buffered in the filter
static const uint16_t mask[17]
int32_t * lossless_check_data
Array with lossless_check_data for each access unit.
static void determine_filters(MLPEncodeContext *ctx)
Tries to determine a good prediction filter, and applies it to the samples buffer if the filter is go...
unsigned int starting_frame_index
RestartHeader restart_header[MAX_SUBSTREAMS]
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
unsigned int major_filter_state_subblock
#define AV_CH_LAYOUT_QUAD
#define SAMPLE_MAX(bitdepth)
const char * name
Name of the codec implementation.
static av_cold int mlp_encode_init(AVCodecContext *avctx)
uint16_t dts
Decoding timestamp of current access unit.
static void write_restart_header(MLPEncodeContext *ctx, PutBitContext *pb)
Writes a restart header to the bitstream.
int num_channels
Number of channels in major_scratch_buffer.
int ff_af_queue_add(AudioFrameQueue *afq, const AVFrame *f)
Add a frame to the queue.
static BestOffset restart_best_offset[NUM_CODEBOOKS]
int coded_sample_rate[2]
sample rate encoded for MLP
uint64_t channel_layout
Audio channel layout.
static int put_bits_count(PutBitContext *s)
uint8_t ch_modifier_thd2
channel modifier for TrueHD stream 2
unsigned int major_number_of_subblocks
#define MLP_MIN_LPC_SHIFT
uint8_t quant_step_size[MAX_CHANNELS]
left shift to apply to Huffman-decoded residuals
uint8_t ff_mlp_restart_checksum(const uint8_t *buf, unsigned int bit_size)
Calculate an 8-bit checksum over a restart header – a non-multiple-of-8 number of bits...
av_cold void ff_lpc_end(LPCContext *s)
Uninitialize LPCContext.
const ChannelInformation ff_mlp_ch_info[21]
Tables defining channel information.
#define AV_CODEC_CAP_SMALL_LAST_FRAME
Codec can be fed a final frame with a smaller size.
unsigned int max_restart_interval
Max interval of access units in between two major frames.
#define AV_CH_LAYOUT_3POINT1
int32_t * write_buffer
Pointer to data currently being written to bitstream.
#define MLP_MAX_LPC_ORDER
static enum MLPChMode estimate_stereo_mode(MLPEncodeContext *ctx)
uint8_t ch_modifier_thd0
channel modifier for TrueHD stream 0
DecodingParams * cur_decoding_params
ChannelParams * prev_channel_params
int num_substreams
Number of substreams contained within this stream.
int32_t coeff[MAX_MATRICES][MAX_CHANNELS+2]
decoding coefficients
static void copy_restart_frame_params(MLPEncodeContext *ctx, unsigned int substr)
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
char path[MAJOR_HEADER_INTERVAL+2]
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
uint16_t timestamp
Timestamp of current access unit.
int32_t coeff[NUM_FILTERS][MAX_FIR_ORDER]
static volatile int checksum
#define AV_CH_LAYOUT_5POINT1_BACK
RestartHeader * cur_restart_header
static void codebook_bits(MLPEncodeContext *ctx, unsigned int channel, int codebook, int offset, int32_t min, int32_t max, BestOffset *bo, int direction)
Determines the least amount of bits needed to encode the samples using a given codebook.
unsigned int restart_intervals
Number of possible major frame sizes.
int major_params_changed[MAJOR_HEADER_INTERVAL+1][MAX_SUBSTREAMS]
params_changed to be written to bitstream.
static void write_major_sync(MLPEncodeContext *ctx, uint8_t *buf, int buf_size)
Writes a major sync header to the bitstream.
int frame_size
Number of samples per channel in an audio frame.
ChannelParams * cur_channel_params
unsigned int * frame_size
Array with number of samples/channel in each access unit.
static void determine_quant_step_size(MLPEncodeContext *ctx)
Determines how many bits are zero at the end of all samples so they can be shifted out...
uint8_t codebook
Which VLC codebook to use to read residuals.
Libavcodec external API header.
AVSampleFormat
Audio sample formats.
unsigned int * max_output_bits
largest output bit-depth
unsigned int max_codebook_search
int sample_rate
samples per second
uint8_t order
number of taps in filter
unsigned int number_of_samples
main external API structure.
static void write_block_data(MLPEncodeContext *ctx, PutBitContext *pb)
Writes the residuals to the bitstream.
Levinson-Durbin recursion.
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2]...the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so...,+,-,+,-,+,+,-,+,-,+,...hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32-hcoeff[1]-hcoeff[2]-...a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2}an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||.........intra?||||:Block01:yes no||||:Block02:.................||||:Block03::y DC::ref index:||||:Block04::cb DC::motion x:||||.........:cr DC::motion y:||||.................|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------------------------------|||Y subbands||Cb subbands||Cr subbands||||------||------||------|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||------||------||------||||------||------||------|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||------||------||------||||------||------||------|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||------||------||------||||------||------||------|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------------------------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction------------|\Dequantization-------------------\||Reference frames|\IDWT|--------------|Motion\|||Frame 0||Frame 1||Compensation.OBMC v-------|--------------|--------------.\------> Frame n output Frame Frame<----------------------------------/|...|-------------------Range Coder:============Binary Range Coder:-------------------The implemented range coder is an adapted version based upon"Range encoding: an algorithm for removing redundancy from a digitised message."by G.N.N.Martin.The symbols encoded by the Snow range coder are bits(0|1).The associated probabilities are not fix but change depending on the symbol mix seen so far.bit seen|new state---------+-----------------------------------------------0|256-state_transition_table[256-old_state];1|state_transition_table[old_state];state_transition_table={0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:-------------------------FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1.the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
uint8_t channel_arrangement
channel arrangement for MLP streams
MatrixParams matrix_params
int32_t * last_frame
Pointer to last frame with data to encode.
static void lossless_matrix_coeffs(MLPEncodeContext *ctx)
Determines best coefficients to use for the lossless matrix.
#define AV_CH_LAYOUT_5POINT0_BACK
BestOffset(* cur_best_offset)[NUM_CODEBOOKS]
static void copy_filter_params(ChannelParams *dst_cp, ChannelParams *src_cp, int filter)
unsigned int seq_index
Sequence index for high compression levels.
int ff_lpc_calc_coefs(LPCContext *s, const int32_t *samples, int blocksize, int min_order, int max_order, int precision, int32_t coefs[][MAX_LPC_ORDER], int *shift, enum FFLPCType lpc_type, int lpc_passes, int omethod, int min_shift, int max_shift, int zero_shift)
Calculate LPC coefficients for multiple orders.
int32_t * major_inout_buffer
Buffer with all in/out data for one entire major frame interval.
av_cold int ff_lpc_init(LPCContext *s, int blocksize, int max_order, enum FFLPCType lpc_type)
Initialize LPCContext.
uint8_t huff_lsbs
Size of residual suffix not encoded using VLC.
#define CODEBOOK_CHANGE_BITS
static void set_best_codebook(MLPEncodeContext *ctx)
static void input_to_sample_buffer(MLPEncodeContext *ctx)
unsigned int next_major_number_of_frames
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])
Writes the access unit and substream headers to the bitstream.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
uint8_t count
number of matrices to apply
DecodingParams * decoding_params
uint8_t outch[MAX_MATRICES]
output channel for each matrix
common internal api header.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
#define MLP_MAX_LPC_SHIFT
int32_t * inout_buffer
Pointer to data currently being read from lavc or written to bitstream.
#define AV_CH_LAYOUT_2POINT1
channel
Use these values when setting the channel map with ebur128_set_channel().
#define MAX_SUBSTREAMS
Maximum number of substreams that can be decoded.
BestOffset best_offset[MAJOR_HEADER_INTERVAL+1][MAX_CHANNELS][NUM_CODEBOOKS]
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
static void set_filter_params(MLPEncodeContext *ctx, unsigned int channel, unsigned int filter, int clear_filter)
Determines the best filter parameters for the given data and writes the necessary information to the ...
static av_always_inline int diff(const uint32_t a, const uint32_t b)
static void clear_decoding_params(MLPEncodeContext *ctx, DecodingParams decoding_params[MAX_SUBSTREAMS])
Clears a DecodingParams struct the way it should be after a restart header.
static int number_sbits(int number)
Calculates the smallest number of bits it takes to encode a given signed value in two's complement...
sample data coding information
int channels
number of audio channels
av_cold void ff_mlp_init_crc(void)
static unsigned int write_access_unit(MLPEncodeContext *ctx, uint8_t *buf, int buf_size, int restart_frame)
Writes an entire access unit to the bitstream.
static void write_decoding_params(MLPEncodeContext *ctx, PutBitContext *pb, int params_changed)
Writes decoding parameters to the bitstream.
static const double coeff[2][5]
void ff_af_queue_close(AudioFrameQueue *afq)
Close AudioFrameQueue.
ChannelParams * channel_params
static enum AVSampleFormat sample_fmts[]
int frame_number
Frame counter, set by libavcodec.
unsigned int one_sample_buffer_size
Number of samples*channel for one access unit.
uint8_t ch_modifier_thd1
channel modifier for TrueHD stream 1
Filter the word “frame” indicates either a video frame or a group of audio samples
static int apply_filter(MLPEncodeContext *ctx, unsigned int channel)
Applies the filter to the current samples, and saves the residual back into the samples buffer...
#define av_malloc_array(a, b)
#define SUBSTREAM_INFO_HIGH_RATE
static void rematrix_channels(MLPEncodeContext *ctx)
Rematrixes all channels using chosen coefficients.
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
static void no_codebook_bits_offset(MLPEncodeContext *ctx, unsigned int channel, int16_t offset, int32_t min, int32_t max, BestOffset *bo)
Determines the amount of bits needed to encode the samples using no codebooks and a specified offset...
int coded_peak_bitrate
peak bitrate for this major sync header
#define AV_CH_LAYOUT_MONO
static void determine_bits(MLPEncodeContext *ctx)
Determines the least amount of bits needed to encode the samples using any or no codebook.
This structure stores compressed data.
mode
Use these values in ebur128_init (or'ed).
static DecodingParams restart_decoding_params[MAX_SUBSTREAMS]
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
static int compare_best_offset(BestOffset *prev, BestOffset *cur)
static void input_data_internal(MLPEncodeContext *ctx, const uint8_t *samples, int is24)
Inputs data from the samples passed by lavc into the context, shifts them appropriately depending on ...
unsigned int frame_index
Index of current frame being encoded.
uint8_t ff_mlp_checksum8(const uint8_t *buf, unsigned int buf_size)
MLP uses checksums that seem to be based on the standard CRC algorithm, but are not (in implementatio...