102 #define WMAPRO_MAX_CHANNELS 8
103 #define MAX_SUBFRAMES 32
105 #define MAX_FRAMESIZE 32768
107 #define WMAPRO_BLOCK_MIN_BITS 6
108 #define WMAPRO_BLOCK_MAX_BITS 12
109 #define WMAPRO_BLOCK_MIN_SIZE (1 << WMAPRO_BLOCK_MIN_BITS)
110 #define WMAPRO_BLOCK_MAX_SIZE (1 << WMAPRO_BLOCK_MAX_BITS)
111 #define WMAPRO_BLOCK_SIZES (WMAPRO_BLOCK_MAX_BITS - WMAPRO_BLOCK_MIN_BITS + 1)
115 #define SCALEVLCBITS 8
116 #define VEC4MAXDEPTH ((HUFF_VEC4_MAXBITS+VLCBITS-1)/VLCBITS)
117 #define VEC2MAXDEPTH ((HUFF_VEC2_MAXBITS+VLCBITS-1)/VLCBITS)
118 #define VEC1MAXDEPTH ((HUFF_VEC1_MAXBITS+VLCBITS-1)/VLCBITS)
119 #define SCALEMAXDEPTH ((HUFF_SCALE_MAXBITS+SCALEVLCBITS-1)/SCALEVLCBITS)
120 #define SCALERLMAXDEPTH ((HUFF_SCALE_RL_MAXBITS+VLCBITS-1)/VLCBITS)
242 #define PRINT(a, b) av_log(s->avctx, AV_LOG_DEBUG, " %s = %d\n", a, b);
243 #define PRINT_HEX(a, b) av_log(s->avctx, AV_LOG_DEBUG, " %s = %x\n", a, b);
279 unsigned int channel_mask;
281 int log2_max_num_subframes;
282 int num_possible_block_sizes;
298 channel_mask =
AV_RL32(edata_ptr+2);
323 log2_max_num_subframes = ((s->
decode_flags & 0x38) >> 3);
329 num_possible_block_sizes = log2_max_num_subframes + 1;
367 if (channel_mask & 8) {
369 for (mask = 1; mask < 16; mask <<= 1) {
370 if (channel_mask & mask)
405 for (i = 0; i < num_possible_block_sizes; i++) {
429 for (i = 0; i < num_possible_block_sizes; i++) {
431 for (b = 0; b < s->
num_sfb[i]; b++) {
435 for (x = 0; x < num_possible_block_sizes; x++) {
459 for (i = 0; i < num_possible_block_sizes; i++) {
467 for (i = 0; i < 33; i++)
489 int frame_len_shift = 0;
506 if (subframe_len < s->min_samples_per_subframe ||
540 int fixed_channel_layout = 0;
541 int min_channel_len = 0;
554 memset(num_samples, 0,
sizeof(num_samples));
557 fixed_channel_layout = 1;
565 if (num_samples[c] == min_channel_len) {
566 if (fixed_channel_layout || channels_for_cur_subframe == 1 ||
568 contains_subframe[c] = 1;
572 contains_subframe[c] = 0;
580 min_channel_len += subframe_len;
584 if (contains_subframe[c]) {
587 "broken frame: num subframes > 31\n");
591 num_samples[c] += subframe_len;
595 "channel len > samples_per_frame\n");
598 }
else if (num_samples[c] <= min_channel_len) {
599 if (num_samples[c] < min_channel_len) {
600 channels_for_cur_subframe = 0;
601 min_channel_len = num_samples[c];
603 ++channels_for_cur_subframe;
606 }
while (min_channel_len < s->samples_per_frame);
646 for (x = 0; x < i; x++) {
648 for (y = 0; y < i + 1; y++) {
651 int n = rotation_offset[offset + x];
657 cosv =
sin64[32 - n];
659 sinv =
sin64[64 - n];
660 cosv = -
sin64[n - 32];
664 (v1 * sinv) - (v2 * cosv);
666 (v1 * cosv) + (v2 * sinv);
693 "unsupported channel transform bit\n");
705 if (remaining_channels > 2) {
730 "unsupported channel transform type\n");
757 "coupled channels > 6\n");
797 static const uint32_t fval_tab[16] = {
798 0x00000000, 0x3f800000, 0x40000000, 0x40400000,
799 0x40800000, 0x40a00000, 0x40c00000, 0x40e00000,
800 0x41000000, 0x41100000, 0x41200000, 0x41300000,
801 0x41400000, 0x41500000, 0x41600000, 0x41700000,
812 av_dlog(s->
avctx,
"decode coefficients for channel %i\n", c);
815 vlc = &coef_vlc[vlctable];
836 for (i = 0; i < 4; i += 2) {
850 vals[i+1] = fval_tab[symbol_to_vec2[idx] & 0xF];
855 vals[1] = fval_tab[(symbol_to_vec4[idx] >> 8) & 0xF];
856 vals[2] = fval_tab[(symbol_to_vec4[idx] >> 4) & 0xF];
857 vals[3] = fval_tab[ symbol_to_vec4[idx] & 0xF];
861 for (i = 0; i < 4; i++) {
867 ci->
coeffs[cur_coeff] = 0;
877 if (cur_coeff < s->subframe_len) {
878 memset(&ci->
coeffs[cur_coeff], 0,
881 level, run, 1, ci->
coeffs,
948 sign = (code & 1) - 1;
949 skip = (code & 0x3f) >> 1;
950 }
else if (idx == 1) {
961 "invalid scale factor coding\n");
997 float** ch_end = ch_data + num_channels;
1003 sfb < s->cur_sfb_offsets + s->
num_bands; sfb++) {
1009 const float* data_end = data + num_channels;
1010 float* data_ptr =
data;
1013 for (ch = ch_data; ch < ch_end; ch++)
1014 *data_ptr++ = (*ch)[y];
1016 for (ch = ch_data; ch < ch_end; ch++) {
1019 while (data_ptr < data_end)
1020 sum += *data_ptr++ * *mat++;
1028 ch_data[0] + sfb[0],
1031 ch_data[1] + sfb[0],
1079 int transmit_coeffs = 0;
1080 int cur_subwoofer_cutoff;
1098 "processing subframe with offset %i len %i\n", offset, subframe_len);
1148 if (!(num_fill_bits =
get_bits(&s->
gb, 2))) {
1153 if (num_fill_bits >= 0) {
1177 transmit_coeffs = 1;
1180 if (transmit_coeffs) {
1189 int num_vec_coeffs =
get_bits(&s->
gb, num_bits) << 2;
1205 if (step == -32 || step == 31) {
1206 const int sign = (step == 31) - 1;
1212 quant_step += ((quant +
step) ^ sign) - sign;
1214 if (quant_step < 0) {
1241 av_dlog(s->
avctx,
"BITSTREAM: subframe header length was %i\n",
1255 av_dlog(s->
avctx,
"BITSTREAM: subframe length was %i\n",
1258 if (transmit_coeffs) {
1268 memset(&s->
tmp[cur_subwoofer_cutoff], 0,
sizeof(*s->
tmp) *
1269 (subframe_len - cur_subwoofer_cutoff));
1277 const float quant = pow(10.0, exp / 20.0);
1281 quant, end - start);
1315 int more_frames = 0;
1325 av_dlog(s->
avctx,
"decoding frame with length %x\n", len);
1366 av_dlog(s->
avctx,
"BITSTREAM: frame header length was %i\n",
1418 "frame[%i] would have to skip %i bits\n", s->
frame_num,
1481 "Cannot append %d bits, only %d bits available.\n",
1493 align =
FFMIN(align, len);
1518 int *got_frame_ptr,
AVPacket* avpkt)
1522 const uint8_t* buf = avpkt->
data;
1523 int buf_size = avpkt->
size;
1524 int num_bits_prev_frame;
1525 int packet_sequence_number;
1533 if (buf_size < avctx->block_align) {
1545 packet_sequence_number =
get_bits(gb, 4);
1551 num_bits_prev_frame);
1562 if (num_bits_prev_frame > 0) {
1564 if (num_bits_prev_frame >= remaining_packet_bits) {
1565 num_bits_prev_frame = remaining_packet_bits;
1571 save_bits(s, gb, num_bits_prev_frame, 1);
1572 av_dlog(avctx,
"accumulated %x bits of frame data\n",
1579 av_dlog(avctx,
"ignoring %x previously saved bits\n",
void(* vector_fmul_window)(float *dst, const float *src0, const float *src1, const float *win, int len)
float * channel_data[WMAPRO_MAX_CHANNELS]
transformation coefficients
uint8_t max_num_subframes
static const uint16_t critical_freq[]
frequencies to divide the frequency spectrum into scale factor bands
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
static int decode_tilehdr(WMAProDecodeCtx *s)
Decode how the data in the frame is split into subframes.
int8_t num_channels
number of channels in the stream (same as AVCodecContext.num_channels)
int subframe_offset
subframe offset in the bit reservoir
static const uint16_t vec1_huffcodes[HUFF_VEC1_SIZE]
static const float coef0_level[HUFF_COEF0_SIZE]
uint8_t table_idx
index for the num_sfb, sfb_offsets, sf_offsets and subwoofer_cutoffs tables
static const uint32_t scale_rl_huffcodes[HUFF_SCALE_RL_SIZE]
uint16_t num_vec_coeffs
number of vector coded coefficients
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
#define WMAPRO_BLOCK_MIN_SIZE
minimum block size
uint16_t min_samples_per_subframe
static void skip_bits_long(GetBitContext *s, int n)
AVFrame * coded_frame
the picture in the bitstream
AVCodecContext * avctx
codec context for av_log
uint32_t decode_flags
used compression features
#define FF_DEBUG_BITSTREAM
static const uint16_t vec4_huffcodes[HUFF_VEC4_SIZE]
void avpriv_copy_bits(PutBitContext *pb, const uint8_t *src, int length)
Copy the content of src to the bitstream.
int8_t scale_factor_step
scaling step for the current subframe
#define DECLARE_ALIGNED(n, t, v)
int ff_wma_run_level_decode(AVCodecContext *avctx, GetBitContext *gb, VLC *vlc, const float *level_table, const uint16_t *run_table, int version, WMACoef *ptr, int offset, int num_coefs, int block_len, int frame_len_bits, int coef_nb_bits)
Decode run level compressed coefficients.
static const uint8_t scale_huffbits[HUFF_SCALE_SIZE]
uint8_t table_idx
index in sf_offsets for the scale factor reference block
#define FF_ARRAY_ELEMS(a)
int16_t * cur_sfb_offsets
sfb offsets for the current block
WMAProChannelGrp chgroup[WMAPRO_MAX_CHANNELS]
channel group information
SINETABLE_CONST float *const ff_sine_windows[13]
PutBitContext pb
context for filling the frame_data buffer
void(* float_interleave)(float *dst, const float **src, unsigned int len, int channels)
Convert multiple arrays of float to an array of interleaved float.
#define WMAPRO_MAX_CHANNELS
current decoder limitations
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs...
static int get_sbits(GetBitContext *s, int n)
static VLC vec1_vlc
1 coefficient per symbol
int av_cold ff_wma_get_frame_len_bits(int sample_rate, int version, unsigned int decode_flags)
Get the samples per frame for this stream.
static const uint8_t scale_rl_run[HUFF_SCALE_RL_SIZE]
static int decode_packet(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Decode a single WMA packet.
int frame_offset
frame offset in the bit reservoir
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
DSPContext dsp
accelerated DSP functions
static const float coef1_level[HUFF_COEF1_SIZE]
uint16_t subframe_offset[MAX_SUBFRAMES]
subframe positions in the current frame
enum AVSampleFormat sample_fmt
audio sample format
static void inverse_channel_transform(WMAProDecodeCtx *s)
Reconstruct the individual channel data.
int16_t sfb_offsets[WMAPRO_BLOCK_SIZES][MAX_BANDS]
scale factor band offsets (multiples of 4)
#define INIT_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)
int8_t num_bands
number of scale factor bands
uint8_t frame_data[MAX_FRAMESIZE+FF_INPUT_BUFFER_PADDING_SIZE]
compressed frame data
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
uint8_t packet_sequence_number
current packet number
uint8_t drc_gain
gain for the DRC tool
uint8_t dynamic_range_compression
frame contains DRC data
static uint8_t * append(uint8_t *buf, const uint8_t *src, int size)
#define MAX_FRAMESIZE
maximum compressed frame size
int16_t prev_block_len
length of the previous block
WMAProChannelCtx channel[WMAPRO_MAX_CHANNELS]
per channel data
GetBitContext gb
bitstream reader context
uint8_t grouped
channel is part of a group
static int get_bits_count(const GetBitContext *s)
#define WMAPRO_BLOCK_MAX_BITS
log2 of max block size
int * scale_factors
pointer to the scale factor values used for decoding
bitstream reader API header.
int next_packet_start
start offset of the next wma packet in the demuxer packet
int num_saved_bits
saved number of bits
static const uint16_t scale_huffcodes[HUFF_SCALE_SIZE]
int buf_bit_size
buffer size in bits
static const uint32_t coef1_huffcodes[555]
av_cold void dsputil_init(DSPContext *c, AVCodecContext *avctx)
static int init(AVCodecParserContext *s)
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
static VLC vec4_vlc
4 coefficients per symbol
static int decode_subframe(WMAProDecodeCtx *s)
Decode a single subframe (block).
uint8_t packet_loss
set in case of bitstream error
static int put_bits_left(PutBitContext *s)
static const uint16_t mask[17]
#define MAX_SUBFRAMES
max number of subframes per channel
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
int8_t channel_indexes_for_cur_subframe[WMAPRO_MAX_CHANNELS]
static const uint8_t coef0_huffbits[666]
static float sin64[33]
sinus table for decorrelation
void av_log(void *avcl, int level, const char *fmt,...)
int max_scale_factor
maximum scale factor for the current subframe
const char * name
Name of the codec implementation.
static void put_bits(PutBitContext *s, int n, unsigned int value)
Write up to 31 bits into a bitstream.
int8_t channels_for_cur_subframe
number of channels that contain the subframe
AVCodec ff_wmapro_decoder
wmapro decoder
static int decode_subframe_length(WMAProDecodeCtx *s, int offset)
Decode the subframe length.
static const uint8_t coef1_huffbits[555]
float out[WMAPRO_BLOCK_MAX_SIZE+WMAPRO_BLOCK_MAX_SIZE/2]
output buffer
int quant_step
quantization step for the current subframe
static const uint16_t coef1_run[HUFF_COEF1_SIZE]
uint64_t channel_layout
Audio channel layout.
frame specific decoder context for a single channel
static VLC sf_vlc
scale factor DPCM vlc
uint8_t bits_per_sample
integer audio sample size for the unscaled IMDCT output (used to scale to [-1.0, 1.0])
static const uint8_t scale_rl_huffbits[HUFF_SCALE_RL_SIZE]
static void flush(AVCodecContext *avctx)
Clear decoder buffers (for seeking).
static const uint16_t symbol_to_vec4[HUFF_VEC4_SIZE]
void(* vector_fmul_scalar)(float *dst, const float *src, float mul, int len)
Multiply a vector of floats by a scalar float.
struct WMAProDecodeCtx WMAProDecodeCtx
main decoder context
static int decode_coeffs(WMAProDecodeCtx *s, int c)
Extract the coefficients from the bitstream.
uint32_t frame_num
current frame number (not used for decoding)
int8_t transform
transform on / off
float tmp[WMAPRO_BLOCK_MAX_SIZE]
IMDCT output buffer.
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame)
int8_t sf_offsets[WMAPRO_BLOCK_SIZES][WMAPRO_BLOCK_SIZES][MAX_BANDS]
scale factor resample matrix
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
uint16_t decoded_samples
number of already processed samples
static const float *const default_decorrelation[]
default decorrelation matrix offsets
static void save_bits(WMAProDecodeCtx *s, GetBitContext *gb, int len, int append)
Fill the bit reservoir with a (partial) frame.
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
int8_t transmit_num_vec_coeffs
number of vector coded coefficients is part of the bitstream
#define MAX_BANDS
max number of scale factor bands
#define av_dlog(pctx,...)
av_dlog macros Useful to print debug messages that shouldn't get compiled in normally.
uint8_t subframe_len_bits
number of bits used for the subframe length
int8_t transform_band[MAX_BANDS]
controls if the transform is enabled for a certain band
#define AVERROR_PATCHWELCOME
Not yet implemented in Libav, patches welcome.
int8_t lfe_channel
lfe channel index
int16_t subwoofer_cutoffs[WMAPRO_BLOCK_SIZES]
subwoofer cutoff values
static VLC vec2_vlc
2 coefficients per symbol
int8_t parsed_all_subframes
all subframes decoded?
channel group for channel transformations
int16_t subframe_len
current subframe length
int sample_rate
samples per second
#define WMAPRO_BLOCK_SIZES
possible block sizes
static const uint8_t vec4_huffbits[HUFF_VEC4_SIZE]
void av_log_ask_for_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message asking for a sample.
main external API structure.
static void close(AVCodecParserContext *s)
static const uint8_t symbol_to_vec2[HUFF_VEC2_SIZE]
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
tables for wmapro decoding
void(* imdct_half)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
static VLC coef_vlc[2]
coefficient run length vlc codes
static unsigned int get_bits1(GetBitContext *s)
static void skip_bits(GetBitContext *s, int n)
int8_t reuse_sf
share scale factors between subframes
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
uint8_t packet_offset
frame offset in the packet
static int decode_scale_factors(WMAProDecodeCtx *s)
Extract scale factors from the bitstream.
int saved_scale_factors[2][MAX_BANDS]
resampled and (previously) transmitted scale factor values
uint8_t num_channels
number of channels in the group
static VLC sf_rl_vlc
scale factor run length vlc
float * coeffs
pointer to the subframe decode buffer
#define FF_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
float * windows[WMAPRO_BLOCK_SIZES]
windows for the different block sizes
uint8_t cur_subframe
current subframe number
static av_always_inline uint32_t av_float2int(float f)
Reinterpret a float as a 32-bit integer.
static int remaining_bits(WMAProDecodeCtx *s, GetBitContext *gb)
Calculate remaining input buffer length.
static int decode_channel_transform(WMAProDecodeCtx *s)
Decode channel transformation parameters.
FFTContext mdct_ctx[WMAPRO_BLOCK_SIZES]
MDCT context per block size.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
FmtConvertContext fmt_conv
int8_t scale_factor_idx
index for the transmitted scale factor values (used for resampling)
#define WMAPRO_BLOCK_MAX_SIZE
maximum block size
static av_cold int decode_init(AVCodecContext *avctx)
Initialize the decoder.
uint16_t subframe_len[MAX_SUBFRAMES]
subframe length in samples
int8_t num_sfb[WMAPRO_BLOCK_SIZES]
scale factor bands per block size
common internal api header.
static void decode_decorrelation_matrix(WMAProDecodeCtx *s, WMAProChannelGrp *chgroup)
Calculate a decorrelation matrix from the bitstream parameters.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
static int decode_frame(WMAProDecodeCtx *s, int *got_frame_ptr)
Decode one WMA frame.
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
static void wmapro_window(WMAProDecodeCtx *s)
Apply sine window and reconstruct the output buffer.
#define WMAPRO_BLOCK_MIN_BITS
log2 of min block size
static const uint8_t scale_rl_level[HUFF_SCALE_RL_SIZE]
static void av_cold dump_context(WMAProDecodeCtx *s)
helper function to print the most important members of the context
av_cold void ff_fmt_convert_init(FmtConvertContext *c, AVCodecContext *avctx)
GetBitContext pgb
bitstream reader context for the packet
int channels
number of audio channels
#define CODEC_CAP_SUBFRAMES
Codec can output multiple frames per AVPacket Normally demuxers return one frame at a time...
VLC_TYPE(* table)[2]
code, bits
unsigned int ff_wma_get_large_val(GetBitContext *gb)
Decode an uncompressed coefficient.
static const uint32_t coef0_huffcodes[666]
int frame_number
audio or video frame number
uint16_t samples_per_frame
number of samples to output
static const uint8_t vec1_huffbits[HUFF_VEC1_SIZE]
static const uint16_t coef0_run[HUFF_COEF0_SIZE]
static const uint16_t vec2_huffcodes[HUFF_VEC2_SIZE]
int8_t esc_len
length of escaped coefficients
void avcodec_get_frame_defaults(AVFrame *pic)
Set the fields of the given AVFrame to default values.
uint8_t len_prefix
frame is prefixed with its length
float decorrelation_matrix[WMAPRO_MAX_CHANNELS *WMAPRO_MAX_CHANNELS]
static av_cold int decode_end(AVCodecContext *avctx)
Uninitialize the decoder and free all resources.
AVFrame frame
AVFrame for decoded output.
#define HUFF_SCALE_RL_SIZE
uint8_t max_subframe_len_bit
flag indicating that the subframe is of maximum size when the first subframe length bit is 1 ...
int nb_samples
number of audio samples (per channel) described by this frame
int8_t skip_frame
skip output step
void ff_init_ff_sine_windows(int index)
initialize the specified entry of ff_sine_windows
static const uint8_t vec2_huffbits[HUFF_VEC2_SIZE]
uint8_t num_chgroups
number of channel groups
uint8_t packet_done
set when a packet is fully decoded