104 #define WMAPRO_MAX_CHANNELS 8
105 #define MAX_SUBFRAMES 32
107 #define MAX_FRAMESIZE 32768
109 #define WMAPRO_BLOCK_MIN_BITS 6
110 #define WMAPRO_BLOCK_MAX_BITS 13
111 #define WMAPRO_BLOCK_MIN_SIZE (1 << WMAPRO_BLOCK_MIN_BITS)
112 #define WMAPRO_BLOCK_MAX_SIZE (1 << WMAPRO_BLOCK_MAX_BITS)
113 #define WMAPRO_BLOCK_SIZES (WMAPRO_BLOCK_MAX_BITS - WMAPRO_BLOCK_MIN_BITS + 1)
117 #define SCALEVLCBITS 8
118 #define VEC4MAXDEPTH ((HUFF_VEC4_MAXBITS+VLCBITS-1)/VLCBITS)
119 #define VEC2MAXDEPTH ((HUFF_VEC2_MAXBITS+VLCBITS-1)/VLCBITS)
120 #define VEC1MAXDEPTH ((HUFF_VEC1_MAXBITS+VLCBITS-1)/VLCBITS)
121 #define SCALEMAXDEPTH ((HUFF_SCALE_MAXBITS+SCALEVLCBITS-1)/SCALEVLCBITS)
122 #define SCALERLMAXDEPTH ((HUFF_SCALE_RL_MAXBITS+VLCBITS-1)/VLCBITS)
241 #define PRINT(a, b) av_log(s->avctx, AV_LOG_DEBUG, " %s = %d\n", a, b);
242 #define PRINT_HEX(a, b) av_log(s->avctx, AV_LOG_DEBUG, " %s = %"PRIx32"\n", a, b);
280 unsigned int channel_mask;
282 int log2_max_num_subframes;
283 int num_possible_block_sizes;
301 channel_mask =
AV_RL32(edata_ptr+2);
334 log2_max_num_subframes = ((s->
decode_flags & 0x38) >> 3);
340 num_possible_block_sizes = log2_max_num_subframes + 1;
372 for (i = 0; i < avctx->
channels; i++)
378 if (channel_mask & 8) {
380 for (mask = 1; mask < 16; mask <<= 1) {
381 if (channel_mask & mask)
416 for (i = 0; i < num_possible_block_sizes; i++) {
430 if (offset >= subframe_len)
447 for (i = 0; i < num_possible_block_sizes; i++) {
449 for (b = 0; b < s->
num_sfb[i]; b++) {
453 for (x = 0; x < num_possible_block_sizes; x++) {
478 for (i = 0; i < num_possible_block_sizes; i++) {
486 for (i = 0; i < 33; i++)
505 int frame_len_shift = 0;
525 if (subframe_len < s->min_samples_per_subframe ||
559 int fixed_channel_layout = 0;
560 int min_channel_len = 0;
574 fixed_channel_layout = 1;
582 if (num_samples[c] == min_channel_len) {
583 if (fixed_channel_layout || channels_for_cur_subframe == 1 ||
585 contains_subframe[
c] = 1;
589 contains_subframe[
c] = 0;
597 min_channel_len += subframe_len;
601 if (contains_subframe[c]) {
604 "broken frame: num subframes > 31\n");
608 num_samples[
c] += subframe_len;
612 "channel len > samples_per_frame\n");
615 }
else if (num_samples[c] <= min_channel_len) {
616 if (num_samples[c] < min_channel_len) {
617 channels_for_cur_subframe = 0;
618 min_channel_len = num_samples[
c];
620 ++channels_for_cur_subframe;
623 }
while (min_channel_len < s->samples_per_frame);
663 for (x = 0; x < i; x++) {
665 for (y = 0; y < i + 1; y++) {
668 int n = rotation_offset[offset + x];
677 cosv = -
sin64[n - 32];
681 (v1 * sinv) - (v2 * cosv);
683 (v1 * cosv) + (v2 * sinv);
710 "Channel transform bit");
722 if (remaining_channels > 2) {
747 "Unknown channel transform type");
774 "Coupled channels > 6");
814 static const uint32_t fval_tab[16] = {
815 0x00000000, 0x3f800000, 0x40000000, 0x40400000,
816 0x40800000, 0x40a00000, 0x40c00000, 0x40e00000,
817 0x41000000, 0x41100000, 0x41200000, 0x41300000,
818 0x41400000, 0x41500000, 0x41600000, 0x41700000,
829 ff_dlog(s->
avctx,
"decode coefficients for channel %i\n", c);
832 vlc = &coef_vlc[vlctable];
853 for (i = 0; i < 4; i += 2) {
867 vals[i+1] = fval_tab[symbol_to_vec2[idx] & 0xF];
872 vals[1] = fval_tab[(symbol_to_vec4[idx] >> 8) & 0xF];
873 vals[2] = fval_tab[(symbol_to_vec4[idx] >> 4) & 0xF];
874 vals[3] = fval_tab[ symbol_to_vec4[idx] & 0xF];
878 for (i = 0; i < 4; i++) {
884 ci->
coeffs[cur_coeff] = 0;
894 if (cur_coeff < s->subframe_len) {
895 memset(&ci->
coeffs[cur_coeff], 0,
898 level, run, 1, ci->
coeffs,
965 sign = (code & 1) - 1;
966 skip = (code & 0x3f) >> 1;
967 }
else if (idx == 1) {
978 "invalid scale factor coding\n");
1014 float** ch_end = ch_data + num_channels;
1020 sfb < s->cur_sfb_offsets + s->
num_bands; sfb++) {
1026 const float* data_end = data + num_channels;
1027 float* data_ptr =
data;
1030 for (ch = ch_data; ch < ch_end; ch++)
1031 *data_ptr++ = (*ch)[
y];
1033 for (ch = ch_data; ch < ch_end; ch++) {
1036 while (data_ptr < data_end)
1037 sum += *data_ptr++ * *mat++;
1045 ch_data[0] + sfb[0],
1048 ch_data[1] + sfb[0],
1065 const float* window;
1096 int transmit_coeffs = 0;
1097 int cur_subwoofer_cutoff;
1115 "processing subframe with offset %i len %i\n", offset, subframe_len);
1165 if (!(num_fill_bits =
get_bits(&s->
gb, 2))) {
1167 num_fill_bits = (len ?
get_bits(&s->
gb, len) : 0) + 1;
1170 if (num_fill_bits >= 0) {
1194 transmit_coeffs = 1;
1198 if (transmit_coeffs) {
1207 int num_vec_coeffs =
get_bits(&s->
gb, num_bits) << 2;
1224 if (step == -32 || step == 31) {
1225 const int sign = (step == 31) - 1;
1231 quant_step += ((quant + step) ^ sign) - sign;
1233 if (quant_step < 0) {
1260 ff_dlog(s->
avctx,
"BITSTREAM: subframe header length was %i\n",
1274 ff_dlog(s->
avctx,
"BITSTREAM: subframe length was %i\n",
1277 if (transmit_coeffs) {
1287 memset(&s->
tmp[cur_subwoofer_cutoff], 0,
sizeof(*s->
tmp) *
1288 (subframe_len - cur_subwoofer_cutoff));
1296 const float quant = pow(10.0, exp / 20.0);
1300 quant, end - start);
1334 int more_frames = 0;
1342 ff_dlog(s->
avctx,
"decoding frame with length %x\n", len);
1383 ff_dlog(s->
avctx,
"BITSTREAM: frame header length was %i\n",
1388 for (i = 0; i < avctx->
channels; i++) {
1410 for (i = 0; i < avctx->
channels; i++)
1414 for (i = 0; i < avctx->
channels; i++) {
1433 "frame[%"PRIu32
"] would have to skip %i bits\n",
1503 align =
FFMIN(align, len);
1527 int *got_frame_ptr,
AVPacket* avpkt)
1532 int buf_size = avpkt->
size;
1533 int num_bits_prev_frame;
1534 int packet_sequence_number;
1542 if (buf_size < avctx->block_align) {
1554 packet_sequence_number =
get_bits(gb, 4);
1560 num_bits_prev_frame);
1567 "Packet loss detected! seq %"PRIx8
" vs %x\n",
1572 if (num_bits_prev_frame > 0) {
1574 if (num_bits_prev_frame >= remaining_packet_bits) {
1575 num_bits_prev_frame = remaining_packet_bits;
1581 save_bits(s, gb, num_bits_prev_frame, 1);
1582 ff_dlog(avctx,
"accumulated %x bits of frame data\n",
1589 ff_dlog(avctx,
"ignoring %x previously saved bits\n",
1650 for (i = 0; i < avctx->
channels; i++)
float * channel_data[WMAPRO_MAX_CHANNELS]
transformation coefficients
uint8_t max_num_subframes
const char const char void * val
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.
This structure describes decoded (raw) audio or video data.
int subframe_offset
subframe offset in the bit reservoir
static const uint16_t vec1_huffcodes[HUFF_VEC1_SIZE]
ptrdiff_t const GLvoid * data
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 void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
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)
static av_cold int init(AVCodecContext *avctx)
AVCodecContext * avctx
codec context for av_log
uint32_t decode_flags
used compression features
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
PutBitContext pb
context for filling the frame_data buffer
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
#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
static av_cold void dump_context(WMAProDecodeCtx *s)
helper function to print the most important members of the context
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.
#define av_assert0(cond)
assert() equivalent, that is always enabled.
int frame_offset
frame offset in the bit reservoir
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
void(* vector_fmul_window)(float *dst, const float *src0, const float *src1, const float *win, int len)
Overlap/add with window function.
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
static av_cold int end(AVCodecContext *avctx)
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
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
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.
#define CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
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]
static VLC vec4_vlc
4 coefficients per symbol
static int get_bits_left(GetBitContext *gb)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
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]
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
static const uint8_t coef0_huffbits[666]
static float sin64[33]
sine table for decorrelation
int max_scale_factor
maximum scale factor for the current subframe
const char * name
Name of the codec implementation.
int8_t channels_for_cur_subframe
number of channels that contain the subframe
static const uint8_t offset[127][2]
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]
Libavcodec external API header.
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 int put_bits_count(PutBitContext *s)
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])
#define FF_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
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]
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.
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
void(* vector_fmul_scalar)(float *dst, const float *src, float mul, int len)
Multiply a vector of floats by a scalar float.
#define MAX_BANDS
max number of scale factor bands
const float * windows[WMAPRO_BLOCK_SIZES]
windows for the different block sizes
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 FFmpeg, patches welcome.
const AVS_VideoInfo int align
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
AVSampleFormat
Audio sample formats.
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]
main external API structure.
static const uint8_t symbol_to_vec2[HUFF_VEC2_SIZE]
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
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
SINETABLE_CONST float *const ff_sine_windows[14]
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
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
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.
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
static int decode_channel_transform(WMAProDecodeCtx *s)
Decode channel transformation parameters.
av_cold int ff_wma_get_frame_len_bits(int sample_rate, int version, unsigned int decode_flags)
Get the samples per frame for this stream.
FFTContext mdct_ctx[WMAPRO_BLOCK_SIZES]
MDCT context per block size.
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
#define CODEC_CAP_SUBFRAMES
Codec can output multiple frames per AVPacket Normally demuxers return one frame at a time...
static int decode(AVCodecContext *avctx, void *data, int *got_sub, AVPacket *avpkt)
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.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
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]
#define FF_DEBUG_BITSTREAM
GetBitContext pgb
bitstream reader context for the packet
int channels
number of audio channels
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]
static enum AVSampleFormat sample_fmts[]
static int decode_frame(WMAProDecodeCtx *s, AVFrame *frame, int *got_frame_ptr)
Decode one WMA frame.
int frame_number
Frame counter, set by libavcodec.
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
uint8_t len_prefix
frame is prefixed with its length
float decorrelation_matrix[WMAPRO_MAX_CHANNELS *WMAPRO_MAX_CHANNELS]
uint8_t ** extended_data
pointers to the data planes/channels.
static av_cold int decode_end(AVCodecContext *avctx)
Uninitialize the decoder and free all resources.
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
This structure stores compressed data.
#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