Go to the documentation of this file.
27 #include "config_components.h"
50 #define VLC_STATIC_SIZE 64
53 #define VLC_STATIC_SIZE 512
181 int8_t *output_shift,
182 uint8_t max_matrix_channel,
229 for (
int i = 0;
i < 3;
i++) {
242 unsigned int substr,
unsigned int ch)
246 int lsb_bits = cp->
huff_lsbs -
s->quant_step_size[ch];
251 sign_huff_offset -= 7 << lsb_bits;
254 sign_huff_offset -= 1 << sign_shift;
256 return sign_huff_offset;
263 unsigned int substr,
unsigned int pos)
268 for (mat = 0; mat <
s->num_primitive_matrices; mat++)
269 if (
s->lsb_bypass[mat])
343 if (
mh.group1_bits == 0) {
347 if (
mh.group2_bits >
mh.group1_bits) {
349 "Channel group 2 cannot have more bits per sample than group 1.\n");
353 if (
mh.group2_samplerate &&
mh.group2_samplerate !=
mh.group1_samplerate) {
355 "Channel groups with differing sample rates are not currently supported.\n");
359 if (
mh.group1_samplerate == 0) {
365 "Sampling rate %d is greater than the supported maximum (%d).\n",
371 "Block size %d is greater than the supported maximum (%d).\n",
377 "Block size pow2 %d is greater than the supported maximum (%d).\n",
382 if (
mh.num_substreams == 0)
390 "%d substreams (more than the "
391 "maximum supported by the decoder)",
420 if (
mh.group1_bits > 16)
439 "unexpected stream_type %X in MLP",
443 if ((substr = (
mh.num_substreams > 1)))
449 "unexpected stream_type %X in !MLP",
454 if (
mh.channels_thd_stream1 == 2 &&
455 mh.channels_thd_stream2 == 2 &&
458 if ((substr = (
mh.num_substreams > 1)))
460 if (
mh.num_substreams == 1 &&
461 mh.channels_thd_stream1 == 1 &&
462 mh.channels_thd_stream2 == 1 &&
465 if (
mh.num_substreams > 2)
466 if (
mh.channel_layout_thd_stream2)
471 if (
mh.num_substreams > 2)
494 if (
mh.num_substreams > 2 &&
500 if (
mh.num_substreams > 1 &&
506 if (
mh.num_substreams > 0)
507 switch (
mh.channel_modifier_thd_stream0) {
527 const uint8_t *buf,
unsigned int substr)
533 uint8_t lossless_check;
535 int min_channel, max_channel, max_matrix_channel, noise_type;
542 if (sync_word != 0x31ea >> 1) {
544 "restart header sync incorrect (got 0x%04x)\n", sync_word);
559 max_matrix_channel =
get_bits(gbp, 4);
561 if (max_matrix_channel > std_max_matrix_channel) {
563 "Max matrix channel cannot be greater than %d.\n",
564 std_max_matrix_channel);
572 "%d channels (more than the "
573 "maximum supported by the decoder)",
578 if (max_channel + 1 >
MAX_CHANNELS || max_channel + 1 < min_channel)
581 s->min_channel = min_channel;
582 s->max_channel = max_channel;
583 s->coded_channels = ((1LL << (max_channel - min_channel + 1)) - 1) << min_channel;
584 s->max_matrix_channel = max_matrix_channel;
585 s->noise_type = noise_type;
590 "Extracting %d-channel downmix (0x%"PRIx64
") from substream %d. "
591 "Further substreams will be skipped.\n",
592 s->max_channel + 1,
s->mask, substr);
604 &&
s->lossless_check_data != 0xffffffff) {
606 if (
tmp != lossless_check)
608 "Lossless check failed - expected %02x, calculated %02x.\n",
609 lossless_check,
tmp);
614 memset(
s->ch_assign, 0,
sizeof(
s->ch_assign));
616 for (ch = 0; ch <=
s->max_matrix_channel; ch++) {
625 if (ch_assign < 0 || ch_assign >
s->max_matrix_channel) {
627 "Assignment of matrix channel %d to invalid output channel %d",
631 s->ch_assign[ch_assign] = ch;
640 s->param_presence_flags = 0xff;
641 s->num_primitive_matrices = 0;
643 s->lossless_check_data = 0;
645 memset(
s->output_shift , 0,
sizeof(
s->output_shift ));
646 memset(
s->quant_step_size, 0,
sizeof(
s->quant_step_size));
648 for (ch =
s->min_channel; ch <= s->max_channel; ch++) {
667 s->max_matrix_channel,
673 int i =
s->ch_assign[4];
674 s->ch_assign[4] =
s->ch_assign[3];
675 s->ch_assign[3] =
s->ch_assign[2];
678 FFSWAP(
int,
s->ch_assign[2],
s->ch_assign[4]);
679 FFSWAP(
int,
s->ch_assign[3],
s->ch_assign[5]);
691 unsigned int substr,
unsigned int channel,
697 const char fchar =
filter ?
'I' :
'F';
709 if (order > max_order) {
711 "%cIR filter order %d is greater than maximum %d.\n",
712 fchar, order, max_order);
719 int coeff_bits, coeff_shift;
725 if (coeff_bits < 1 || coeff_bits > 16) {
727 "%cIR filter coeff_bits must be between 1 and 16.\n",
731 if (coeff_bits + coeff_shift > 16) {
733 "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
738 for (
i = 0;
i < order;
i++)
739 fcoeff[
i] =
get_sbits(gbp, coeff_bits) * (1 << coeff_shift);
742 int state_bits, state_shift;
746 "FIR filter has state data specified.\n");
755 for (
i = 0;
i < order;
i++)
756 fp->
state[
i] = state_bits ?
get_sbits(gbp, state_bits) * (1 << state_shift) : 0;
768 unsigned int mat, ch;
778 s->num_primitive_matrices =
get_bits(gbp, 4);
780 if (
s->num_primitive_matrices > max_primitive_matrices) {
782 "Number of primitive matrices cannot be greater than %d.\n",
783 max_primitive_matrices);
787 for (mat = 0; mat <
s->num_primitive_matrices; mat++) {
788 int frac_bits, max_chan;
789 s->matrix_out_ch[mat] =
get_bits(gbp, 4);
793 if (
s->matrix_out_ch[mat] >
s->max_matrix_channel) {
795 "Invalid channel %d specified as output from matrix.\n",
796 s->matrix_out_ch[mat]);
799 if (frac_bits > 14) {
801 "Too many fractional bits specified.\n");
805 max_chan =
s->max_matrix_channel;
809 for (ch = 0; ch <= max_chan; ch++) {
812 coeff_val =
get_sbits(gbp, frac_bits + 2);
814 s->matrix_coeff[mat][ch] = coeff_val * (1 << (14 - frac_bits));
818 s->matrix_noise_shift[mat] =
get_bits(gbp, 4);
820 s->matrix_noise_shift[mat] = 0;
825 s->num_primitive_matrices = 0;
826 memset(
s->matrix_out_ch, 0,
sizeof(
s->matrix_out_ch));
860 "FIR and IIR filters must use the same precision.\n");
896 unsigned recompute_sho = 0;
900 s->param_presence_flags =
get_bits(gbp, 8);
919 for (ch = 0; ch <=
s->max_matrix_channel; ch++) {
921 if (
s->output_shift[ch] < 0) {
923 s->output_shift[ch] = 0;
929 s->max_matrix_channel,
935 for (ch = 0; ch <=
s->max_channel; ch++) {
936 s->quant_step_size[ch] =
get_bits(gbp, 4);
938 recompute_sho |= 1<<ch;
941 for (ch =
s->min_channel; ch <= s->max_channel; ch++)
943 recompute_sho |= 1<<ch;
950 for (ch = 0; ch <=
s->max_channel; ch++) {
951 if (recompute_sho & (1<<ch)) {
959 s->quant_step_size[ch] = 0;
968 #define MSB_MASK(bits) (-(1 << (bits)))
983 unsigned int filter_shift = fir->
shift;
991 filter_shift,
mask,
s->blocksize,
1001 unsigned int substr)
1004 unsigned int i, ch, expected_stream_pos = 0;
1007 if (
s->data_check_present) {
1009 expected_stream_pos +=
get_bits(gbp, 16);
1011 "Substreams with VLC block size check info");
1022 for (
i = 0;
i <
s->blocksize;
i++)
1026 for (ch =
s->min_channel; ch <= s->max_channel; ch++)
1029 s->blockpos +=
s->blocksize;
1031 if (
s->data_check_present) {
1043 30, 51, 22, 54, 3, 7, -4, 38, 14, 55, 46, 81, 22, 58, -3, 2,
1044 52, 31, -7, 51, 15, 44, 74, 30, 85, -17, 10, 33, 18, 80, 28, 62,
1045 10, 32, 23, 69, 72, 26, 35, 17, 73, 60, 8, 56, 2, 6, -2, -5,
1046 51, 4, 11, 50, 66, 76, 21, 44, 33, 47, 1, 26, 64, 48, 57, 40,
1047 38, 16, -10, -28, 92, 22, -18, 29, -10, 5, -13, 49, 19, 24, 70, 34,
1048 61, 48, 30, 14, -6, 25, 58, 33, 42, 60, 67, 17, 54, 17, 22, 30,
1049 67, 44, -9, 50, -11, 43, 40, 32, 59, 82, 13, 49, -14, 55, 60, 36,
1050 48, 49, 31, 47, 15, 12, 4, 65, 1, 23, 29, 39, 45, -2, 84, 69,
1051 0, 72, 37, 57, 27, 41, -15, -16, 35, 31, 14, 61, 24, 0, 27, 24,
1052 16, 41, 55, 34, 53, 9, 56, 12, 25, 29, 53, 5, 20, -20, -8, 20,
1053 13, 28, -3, 78, 38, 16, 11, 62, 46, 29, 21, 24, 46, 65, 43, -23,
1054 89, 18, 74, 21, 38, -12, 19, 12, -19, 8, 15, 33, 4, 57, 9, -8,
1055 36, 35, 26, 28, 7, 83, 63, 79, 75, 11, 3, 87, 37, 47, 34, 40,
1056 39, 19, 20, 42, 27, 34, 39, 77, 13, 42, 59, 64, 45, -1, 32, 37,
1057 45, -5, 53, -6, 7, 36, 50, 23, 6, 32, 9, -21, 18, 71, 27, 52,
1058 -25, 31, 35, 42, -1, 68, 63, 52, 26, 43, 66, 37, 41, 25, 40, 70,
1075 uint32_t
seed =
s->noisegen_seed;
1076 unsigned int maxchan =
s->max_matrix_channel;
1078 for (
i = 0;
i <
s->blockpos;
i++) {
1079 uint16_t seed_shr7 =
seed >> 7;
1081 m->
sample_buffer[
i][maxchan+2] = ((int8_t) seed_shr7) * (1 <<
s->noise_shift);
1083 seed = (
seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
1086 s->noisegen_seed =
seed;
1095 uint32_t
seed =
s->noisegen_seed;
1098 uint8_t seed_shr15 =
seed >> 15;
1100 seed = (
seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
1103 s->noisegen_seed =
seed;
1114 unsigned int maxchan;
1128 maxchan =
s->max_matrix_channel;
1129 if (!
s->noise_type) {
1138 for (mat = 0; mat <
s->num_primitive_matrices; mat++) {
1139 unsigned int dest_ch =
s->matrix_out_ch[mat];
1141 s->matrix_coeff[mat],
1144 s->num_primitive_matrices - mat,
1148 s->matrix_noise_shift[mat],
1154 frame->nb_samples =
s->blockpos;
1157 s->lossless_check_data = m->
pack_output(
s->lossless_check_data,
1163 s->max_matrix_channel,
1167 if (
s->matrix_encoding !=
s->prev_matrix_encoding) {
1171 s->prev_matrix_encoding =
s->matrix_encoding;
1184 int *got_frame_ptr,
AVPacket *avpkt)
1186 const uint8_t *buf = avpkt->
data;
1187 int buf_size = avpkt->
size;
1190 unsigned int length, substr;
1191 unsigned int substream_start;
1192 unsigned int header_size = 4;
1193 unsigned int substr_header_size = 0;
1196 uint8_t parity_bits;
1202 length = (
AV_RB16(buf) & 0xfff) * 2;
1204 if (length < 4 || length > buf_size)
1220 "Stream parameters not seen; skipping frame.\n");
1225 substream_start = 0;
1228 int extraword_present, checkdata_present, end, nonrestart_substr;
1237 substr_header_size += 2;
1239 if (extraword_present) {
1245 substr_header_size += 2;
1248 if (length < header_size + substr_header_size) {
1258 if (end + header_size + substr_header_size > length) {
1260 "Indicated length of substream %d data goes off end of "
1261 "packet.\n", substr);
1262 end = length - header_size - substr_header_size;
1265 if (end < substream_start) {
1267 "Indicated end offset of substream %d data "
1268 "is smaller than calculated start offset.\n",
1276 substream_parity_present[substr] = checkdata_present;
1277 substream_data_len[substr] = end - substream_start;
1278 substream_start = end;
1284 if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
1289 buf += header_size + substr_header_size;
1306 s->restart_seen = 1;
1309 if (!
s->restart_seen)
1315 if (!
s->restart_seen)
1324 substr > 0 && substr < m->max_decoded_substream &&
1327 "Previous substream(%d) channels overlaps current substream(%d) channels, skipping.\n",
1328 substr - 1, substr);
1335 "Current substream(%d) channels overlaps final substream(%d) channels, skipping.\n",
1344 goto substream_length_mismatch;
1350 if (substream_data_len[substr] * 8 -
get_bits_count(&gb) >= 32) {
1358 s->blockpos -=
FFMIN(shorten_by & 0x1FFF,
s->blockpos);
1363 s->end_of_stream = 1;
1366 if (substream_parity_present[substr]) {
1367 uint8_t
parity, checksum;
1370 goto substream_length_mismatch;
1382 goto substream_length_mismatch;
1385 if (!
s->restart_seen)
1387 "No restart header present in substream %d.\n", substr);
1389 buf += substream_data_len[substr];
1398 if (
s->end_of_stream) {
1399 s->lossless_check_data = 0xffffffff;
1400 s->end_of_stream = 0;
1407 substream_length_mismatch:
1424 s->lossless_check_data = 0xffffffff;
1425 s->prev_matrix_encoding = 0;
1429 #define OFFSET(x) offsetof(MLPDecodeContext, x)
1430 #define FLAGS (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)
1432 {
"downmix",
"Request a specific channel layout from the decoder",
OFFSET(downmix_layout),
1451 #if CONFIG_MLP_DECODER
1465 #if CONFIG_TRUEHD_DECODER
uint8_t params_valid
Set if a valid major sync block has been read. Otherwise no decoding is possible.
static void error(const char *err)
int frame_size
Number of samples per channel in an audio frame.
#define AV_LOG_WARNING
Something somehow does not look correct.
static const int8_t noise_table[256]
Data table used for TrueHD noise generation function.
#define AV_CHANNEL_LAYOUT_STEREO_DOWNMIX
#define AV_CH_LAYOUT_5POINT0_BACK
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
uint8_t codebook
Which VLC codebook to use to read residuals.
static uint8_t xor_32_to_8(uint32_t value)
XOR four bytes into one.
int32_t matrix_coeff[MAX_MATRICES][MAX_CHANNELS]
Matrix coefficients, stored as 2.14 fixed point.
enum AVMatrixEncoding prev_matrix_encoding
#define AV_CHANNEL_LAYOUT_STEREO
int sample_rate
samples per second
uint8_t end_of_stream
Set if end of stream is encountered.
#define AV_CH_LAYOUT_MONO
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
int8_t output_shift[MAX_CHANNELS]
Left shift to apply to decoded PCM values to get final 24-bit output.
@ THD_CH_MODIFIER_SURROUNDEX
static int get_bits_count(const GetBitContext *s)
static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp, unsigned int substr)
Read decoding parameters that change more often than those in the restart header.
#define MAX_SAMPLERATE
maximum sample frequency seen in files
int32_t(* pack_output)(int32_t lossless_check_data, uint16_t blockpos, int32_t(*sample_buffer)[MAX_CHANNELS], void *data, uint8_t *ch_assign, int8_t *output_shift, uint8_t max_matrix_channel, int is32)
static av_cold void init_static(void)
Initialize static data, constant between all invocations of the codec.
This structure describes decoded (raw) audio or video data.
uint8_t ff_mlp_calculate_parity(const uint8_t *buf, unsigned int buf_size)
XOR together all the bytes of a buffer.
static const uint16_t table[]
static void filter_channel(MLPDecodeContext *m, unsigned int substr, unsigned int channel)
Generate PCM samples using the prediction filters and residual values read from the data stream,...
uint8_t restart_seen
Set if a valid restart header has been read. Otherwise the substream cannot be decoded.
static int output_data(MLPDecodeContext *m, unsigned int substr, AVFrame *frame, int *got_frame_ptr)
Write the audio data into the output buffer.
uint64_t mask
The channel layout for this substream.
uint8_t min_channel
The index of the first channel coded in this substream.
void(* filter)(uint8_t *src, int stride, int qscale)
int major_sync_header_size
Size of the major sync unit, in bytes.
int nb_channels
Number of channels in this layout.
av_cold void ff_mlpdsp_init(MLPDSPContext *c)
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
uint8_t max_channel
The index of the last channel coded in this substream.
uint8_t ch_assign[MAX_CHANNELS]
For each channel output by the matrix, the output channel to map it to.
static void skip_bits(GetBitContext *s, int n)
uint8_t substream_info
Which substream of substreams carry 2/6/8-channel presentation.
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
@ AV_CHAN_SURROUND_DIRECT_LEFT
AVCodec p
The public AVCodec.
FilterParams filter_params[NUM_FILTERS]
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...
AVChannelLayout ch_layout
Audio channel layout.
uint8_t huff_lsbs
Size of residual suffix not encoded using VLC.
#define AV_PROFILE_TRUEHD_ATMOS
static int32_t calculate_sign_huff(MLPDecodeContext *m, unsigned int substr, unsigned int ch)
#define AV_CH_LAYOUT_STEREO
#define AV_CH_LAYOUT_QUAD
#define MAX_MATRICES_MLP
Maximum number of matrices used in decoding; most streams have one matrix per output channel,...
static int ff_thread_once(char *control, void(*routine)(void))
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
uint8_t needs_reordering
Stream needs channel reordering to comply with FFmpeg's channel order.
static const AVClass mlp_decoder_class
#define FF_ARRAY_ELEMS(a)
int ff_side_data_update_matrix_encoding(AVFrame *frame, enum AVMatrixEncoding matrix_encoding)
Add or update AV_FRAME_DATA_MATRIXENCODING side data.
@ AV_MATRIX_ENCODING_DOLBY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
ChannelParams channel_params[MAX_CHANNELS]
Channel coding parameters for channels in the substream.
#define AV_CH_LOW_FREQUENCY
#define FF_CODEC_DECODE_CB(func)
int av_channel_layout_from_mask(AVChannelLayout *channel_layout, uint64_t mask)
Initialize a native channel layout from a bitmask indicating which channels are present.
void(* mlp_filter_channel)(int32_t *state, const int32_t *coeff, int firorder, int iirorder, unsigned int filter_shift, int32_t mask, int blocksize, int32_t *sample_buffer)
#define av_assert0(cond)
assert() equivalent, that is always enabled.
#define vlc_init(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
static int get_sbits(GetBitContext *s, int n)
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
#define CODEC_LONG_NAME(str)
int32_t(*(* mlp_select_pack_output)(uint8_t *ch_assign, int8_t *output_shift, uint8_t max_matrix_channel, int is32))(int32_t
@ AV_MATRIX_ENCODING_DOLBYHEADPHONE
static int read_access_unit(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)
Read an access unit from the stream.
#define LIBAVUTIL_VERSION_INT
Describe the class of an AVClass context structure.
and forward the result(frame or status change) to the corresponding input. If nothing is possible
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
int32_t lossless_check_data
Running XOR of all output samples.
int8_t bypassed_lsbs[MAX_BLOCKSIZE][MAX_CHANNELS]
uint8_t quant_step_size[MAX_CHANNELS]
Left shift to apply to Huffman-decoded residuals.
const char * av_default_item_name(void *ptr)
Return the context name.
static unsigned int get_bits1(GetBitContext *s)
static const float quant_step_size[]
int filter_changed[MAX_CHANNELS][NUM_FILTERS]
@ AV_OPT_TYPE_CHLAYOUT
Underlying C type is AVChannelLayout.
static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)
Parse a vlc code.
int access_unit_size
number of PCM samples contained in each frame
@ AV_CHAN_FRONT_RIGHT_OF_CENTER
uint8_t max_matrix_channel
The number of channels input into the rematrix stage.
uint8_t extended_substream_info
Which substream of substreams carry 16-channel presentation.
@ THD_CH_MODIFIER_LBINRBIN
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
int32_t sample_buffer[MAX_BLOCKSIZE][MAX_CHANNELS]
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,...
static const AVOption options[]
static enum AVChannel thd_channel_order[]
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
#define MAX_MATRIX_CHANNEL_MLP
Last possible matrix channel for each codec.
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
uint16_t noise_type
restart header data
An AVChannelLayout holds information about the channel layout of audio data.
#define DECLARE_ALIGNED(n, t, v)
uint8_t num_substreams
Number of substreams contained within this stream.
SubStream substream[MAX_SUBSTREAMS]
@ AV_MATRIX_ENCODING_NONE
enum AVSampleFormat sample_fmt
audio sample format
#define MAX_SUBSTREAMS
Maximum number of substreams that can be decoded.
int is_major_sync_unit
Current access unit being read has a major sync.
#define MAX_MATRIX_CHANNEL_TRUEHD
static av_cold int mlp_decode_init(AVCodecContext *avctx)
#define MAX_MATRICES_TRUEHD
#define NUM_FILTERS
number of allowed filters
uint8_t order
number of taps in filter
int ff_mlp_read_major_sync(void *log, MLPHeaderInfo *mh, GetBitContext *gb)
Read a major sync info header - contains high level information about the stream - sample rate,...
#define AV_CH_LAYOUT_5POINT1_BACK
@ AV_CHAN_TOP_FRONT_RIGHT
int16_t huff_offset
Offset to apply to residual values.
static void skip_bits1(GetBitContext *s)
AVChannelLayout downmix_layout
uint32_t noisegen_seed
The current seed value for the pseudorandom noise generator(s).
@ AV_CHAN_FRONT_LEFT_OF_CENTER
uint8_t max_decoded_substream
Index of the last substream to decode - further substreams are skipped.
uint8_t lsb_bypass[MAX_MATRICES]
Whether the LSBs of the matrix output are encoded in the bitstream.
const FFCodec ff_mlp_decoder
uint8_t matrix_out_ch[MAX_MATRICES]
matrix output channel
#define MAX_FIR_ORDER
The maximum number of taps in IIR and FIR filters.
int av_channel_layout_compare(const AVChannelLayout *chl, const AVChannelLayout *chl1)
Check whether two channel layouts are semantically the same, i.e.
void(* mlp_rematrix_channel)(int32_t *samples, const int32_t *coeffs, const uint8_t *bypassed_lsbs, const int8_t *noise_buffer, int index, unsigned int dest_ch, uint16_t blockpos, unsigned int maxchan, int matrix_noise_shift, int access_unit_size_pow2, int32_t mask)
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 layout
static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp, const uint8_t *buf, unsigned int substr)
Read a restart header from a block in a substream.
uint64_t coded_channels
The coded channels mask in this substream.
@ AV_CHAN_SURROUND_DIRECT_RIGHT
#define i(width, name, range_min, range_max)
uint16_t blockpos
Number of PCM samples decoded so far in this frame.
uint8_t noise_shift
The left shift applied to random noise in 0x31ea substreams.
uint16_t blocksize
number of PCM samples in current audio block
@ AV_SAMPLE_FMT_S16
signed 16 bits
static int read_channel_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp, unsigned int ch)
Read channel parameters.
const char * name
Name of the codec implementation.
sample data coding information
static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
Generate a block of noise, used when restart sync word == 0x31eb.
av_cold void ff_mlp_init_crc(void)
int32_t sign_huff_offset
sign/rounding-corrected version of huff_offset
static int mlp_channel_layout_subset(AVChannelLayout *layout, uint64_t mask)
int access_unit_size_pow2
next power of two above the number of samples in each frame
static enum AVChannel thd_channel_layout_extract_channel(uint64_t channel_layout, int index)
#define FFSWAP(type, a, b)
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
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
static void mlp_decode_flush(AVCodecContext *avctx)
const FFCodec ff_truehd_decoder
uint8_t num_primitive_matrices
matrix data
int av_channel_layout_check(const AVChannelLayout *channel_layout)
Check whether a channel layout is valid, i.e.
int32_t state[MAX_FIR_ORDER]
uint8_t data_check_present
Set if the substream contains extra info to check the size of VLC blocks.
@ AV_CHAN_NONE
Invalid channel index.
uint8_t matrix_noise_shift[MAX_MATRICES]
Left shift to apply to noise values in 0x31eb substreams.
main external API structure.
#define VLC_BITS
number of bits used for VLC lookup - longest Huffman code is 9
@ AV_CHAN_LOW_FREQUENCY_2
uint64_t av_channel_layout_subset(const AVChannelLayout *channel_layout, uint64_t mask)
Find out what channels from a given set are present in a channel layout, without regard for their pos...
@ AV_MATRIX_ENCODING_DOLBYEX
int av_channel_layout_index_from_channel(const AVChannelLayout *channel_layout, enum AVChannel channel)
Get the index of a given channel in a channel layout.
void av_channel_layout_uninit(AVChannelLayout *channel_layout)
Free any allocated data in the channel layout and reset the channel count to 0.
@ AV_CHAN_TOP_FRONT_CENTER
static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp, unsigned int substr, unsigned int channel, unsigned int filter)
Read parameters for one of the prediction filters.
static int read_huff_channels(MLPDecodeContext *m, GetBitContext *gbp, unsigned int substr, unsigned int pos)
Read a sample, consisting of either, both or neither of entropy-coded MSBs and plain LSBs.
#define avpriv_request_sample(...)
static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)
Read a major sync info header - contains high level information about the stream - sample rate,...
const uint8_t ff_mlp_huffman_tables[3][18][2]
Tables defining the Huffman codes.
uint8_t param_presence_flags
Bitmask of which parameter sets are conveyed in a decoding parameter block.
This structure stores compressed data.
static const AVClass truehd_decoder_class
static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
Read parameters for primitive matrices.
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
#define VLC_INIT_USE_STATIC
#define AV_CHANNEL_LAYOUT_5POINT0
const AVProfile ff_truehd_profiles[]
#define AV_CHANNEL_LAYOUT_5POINT1
uint8_t shift
Right shift to apply to output of filter.
@ AV_SAMPLE_FMT_S32
signed 32 bits
static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
Noise generation functions.
enum AVMatrixEncoding matrix_encoding
The matrix encoding mode for this substream.
#define MAX_BLOCKSIZE_POW2
next power of two greater than MAX_BLOCKSIZE
int8_t noise_buffer[MAX_BLOCKSIZE_POW2]
static const unsigned codebook[256][2]
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp, unsigned int substr)
Read a block of PCM residual data (or actual if no filtering active).