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;
1146 uint8_t *substream_headers,
unsigned int length,
1150 uint16_t access_unit_header = 0;
1151 uint16_t parity_nibble = 0;
1152 unsigned int substr;
1154 parity_nibble = ctx->
dts;
1155 parity_nibble ^= length;
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;
1630 unsigned int channel,
int codebook,
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;
1694 unsigned int channel,
int codebook,
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");
1827 for (i = 0; i < 8; i++) {
1828 filter_state_buffer[
FIR][
i] = *sample_buffer;
1829 filter_state_buffer[
IIR][
i] = *sample_buffer;
1834 for (i = 8; i < number_of_samples; i++) {
1840 for (filter = 0; filter <
NUM_FILTERS; filter++) {
1842 for (order = 0; order < fp[
filter]->
order; order++)
1843 accum += (int64_t)filter_state_buffer[
filter][i - 1 - order] *
1847 accum >>= filter_shift;
1848 residual = sample - (accum &
mask);
1852 goto free_and_return;
1862 for (i = 0; i < number_of_samples; i++) {
1863 *sample_buffer = filter_state_buffer[
IIR][
i];
1901 uint16_t seed_shr7 = seed >> 7;
1902 *sample_buffer++ = ((int8_t)(seed >> 15)) * (1 << rh->
noise_shift);
1903 *sample_buffer++ = ((int8_t) seed_shr7) * (1 << rh->
noise_shift);
1905 seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
1919 unsigned int mat,
i, maxchan;
1923 for (mat = 0; mat < mp->
count; mat++) {
1926 unsigned int outch = mp->
outch[mat];
1930 unsigned int src_ch;
1933 for (src_ch = 0; src_ch < maxchan; src_ch++) {
1935 accum += (int64_t) sample * mp->
forco[mat][src_ch];
1937 sample_buffer[outch] = (accum >> 14) &
mask;
1955 #define ZERO_PATH '0' 1956 #define CODEBOOK_CHANGE_BITS 21 1964 path_counter[
i].
path[1] = 0x00;
1982 char *path = src->
path + 1;
1986 for (i = 0; path[
i]; i++)
1989 prev_codebook = path[i - 1] -
ZERO_PATH;
1993 bitcount += cur_bo[cur_codebook].
bitcount;
1995 if (prev_codebook != cur_codebook ||
2011 unsigned int best_codebook;
2018 unsigned int best_bitcount = INT_MAX;
2019 unsigned int codebook;
2024 int prev_best_bitcount = INT_MAX;
2027 for (last_best = 0; last_best < 2; last_best++) {
2040 src_path = &path_counter[codebook];
2045 if (temp_bitcount < best_bitcount) {
2046 best_bitcount = temp_bitcount;
2047 best_codebook = codebook;
2050 if (temp_bitcount < prev_best_bitcount) {
2051 prev_best_bitcount = temp_bitcount;
2052 if (src_path != dst_path)
2055 dst_path->
bitcount = temp_bitcount;
2062 memcpy(&path_counter[NUM_CODEBOOKS], &path_counter[best_codebook],
sizeof(
PathCounter));
2071 best_codebook = *best_path++ -
ZERO_PATH;
2089 unsigned int substr;
2104 for (channel = 0; channel < ctx->
avctx->
channels; channel++) {
2106 if (max_huff_lsbs < huff_lsbs)
2107 max_huff_lsbs = huff_lsbs;
2118 if (max_output_bits < ctx->max_output_bits[index])
2150 unsigned int substr;
2178 (seq_dp + substr)->blocksize = 8;
2195 unsigned int substr;
2222 unsigned int bytes_written = 0;
2223 int restart_frame, ret;
2236 data = frame->
data[0];
2254 goto input_and_return;
2275 if (restart_frame) {
2302 if (!restart_frame) {
2308 unsigned int number_of_samples = 0;
2333 for (index = 0; index < ctx->
seq_size[seq_index]; index++) {
2358 avpkt->
size = bytes_written;
2382 #if CONFIG_MLP_ENCODER 2394 .supported_samplerates = (
const int[]) {44100, 48000, 88200, 96000, 176400, 192000, 0},
2399 #if CONFIG_TRUEHD_ENCODER 2411 .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
static void default_decoding_params(MLPEncodeContext *ctx, DecodingParams decoding_params[MAX_SUBSTREAMS])
Sets default vales in our encoder for a DecodingParams struct.
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
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
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
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
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 filter(int16_t *output, ptrdiff_t out_stride, int16_t *low, ptrdiff_t low_stride, int16_t *high, ptrdiff_t high_stride, int len, int clip)
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
static av_cold int end(AVCodecContext *avctx)
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.
static const char * path_counter_codebook[]
#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 i(width, name, range_min, range_max)
#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.
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)
#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.
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.
size_t av_strlcat(char *dst, const char *src, size_t size)
Append the string src to the string dst, but to a total length of no more than size - 1 bytes...
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
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.
char path[MAJOR_HEADER_INTERVAL+3]
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...