107 #define WMAPRO_MAX_CHANNELS 8 108 #define MAX_SUBFRAMES 32
110 #define MAX_FRAMESIZE 32768
111 #define XMA_MAX_STREAMS 8
112 #define XMA_MAX_CHANNELS_STREAM 2 113 #define XMA_MAX_CHANNELS (XMA_MAX_STREAMS * XMA_MAX_CHANNELS_STREAM) 115 #define WMAPRO_BLOCK_MIN_BITS 6 116 #define WMAPRO_BLOCK_MAX_BITS 13
117 #define WMAPRO_BLOCK_MIN_SIZE (1 << WMAPRO_BLOCK_MIN_BITS)
118 #define WMAPRO_BLOCK_MAX_SIZE (1 << WMAPRO_BLOCK_MAX_BITS)
119 #define WMAPRO_BLOCK_SIZES (WMAPRO_BLOCK_MAX_BITS - WMAPRO_BLOCK_MIN_BITS + 1)
123 #define SCALEVLCBITS 8 124 #define VEC4MAXDEPTH ((HUFF_VEC4_MAXBITS+VLCBITS-1)/VLCBITS) 125 #define VEC2MAXDEPTH ((HUFF_VEC2_MAXBITS+VLCBITS-1)/VLCBITS) 126 #define VEC1MAXDEPTH ((HUFF_VEC1_MAXBITS+VLCBITS-1)/VLCBITS) 127 #define SCALEMAXDEPTH ((HUFF_SCALE_MAXBITS+SCALEVLCBITS-1)/SCALEVLCBITS) 128 #define SCALERLMAXDEPTH ((HUFF_SCALE_RL_MAXBITS+VLCBITS-1)/VLCBITS) 259 #define PRINT(a, b) av_log(s->avctx, AV_LOG_DEBUG, " %s = %d\n", a, b); 260 #define PRINT_HEX(a, b) av_log(s->avctx, AV_LOG_DEBUG, " %s = %"PRIx32"\n", a, b); 320 unsigned int channel_mask;
322 int log2_max_num_subframes;
323 int num_possible_block_sizes;
357 s->
nb_channels = edata_ptr[32 + ((edata_ptr[0]==3)?0:8) + 4*num_stream + 0];
362 s->
nb_channels = edata_ptr[8 + 20*num_stream + 17];
365 channel_mask =
AV_RL32(edata_ptr+2);
407 log2_max_num_subframes = ((s->
decode_flags & 0x38) >> 3);
413 num_possible_block_sizes = log2_max_num_subframes + 1;
455 if (channel_mask & 8) {
457 for (mask = 1; mask < 16; mask <<= 1) {
458 if (channel_mask & mask)
493 for (i = 0; i < num_possible_block_sizes; i++) {
507 if (offset >= subframe_len)
524 for (i = 0; i < num_possible_block_sizes; i++) {
526 for (b = 0; b < s->
num_sfb[
i]; b++) {
530 for (x = 0; x < num_possible_block_sizes; x++) {
559 for (i = 0; i < num_possible_block_sizes; i++) {
567 for (i = 0; i < 33; i++)
598 int frame_len_shift = 0;
618 if (subframe_len < s->min_samples_per_subframe ||
652 int fixed_channel_layout = 0;
653 int min_channel_len = 0;
667 fixed_channel_layout = 1;
675 if (num_samples[c] == min_channel_len) {
676 if (fixed_channel_layout || channels_for_cur_subframe == 1 ||
678 contains_subframe[
c] = 1;
682 contains_subframe[
c] = 0;
694 if (contains_subframe[c]) {
697 "broken frame: num subframes > 31\n");
705 "channel len > samples_per_frame\n");
708 }
else if (num_samples[c] <= min_channel_len) {
709 if (num_samples[c] < min_channel_len) {
710 channels_for_cur_subframe = 0;
711 min_channel_len = num_samples[
c];
713 ++channels_for_cur_subframe;
716 }
while (min_channel_len < s->samples_per_frame);
722 ff_dlog(s->
avctx,
"frame[%"PRIu32
"] channel[%i] subframe[%i]" 756 for (x = 0; x <
i; x++) {
758 for (y = 0; y < i + 1; y++) {
761 int n = rotation_offset[offset + x];
767 cosv =
sin64[32 - n];
769 sinv =
sin64[64 - n];
770 cosv = -
sin64[n - 32];
774 (v1 * sinv) - (v2 * cosv);
776 (v1 * cosv) + (v2 * sinv);
803 "Channel transform bit");
815 if (remaining_channels > 2) {
840 "Unknown channel transform type");
867 "Coupled channels > 6");
907 static const uint32_t fval_tab[16] = {
908 0x00000000, 0x3f800000, 0x40000000, 0x40400000,
909 0x40800000, 0x40a00000, 0x40c00000, 0x40e00000,
910 0x41000000, 0x41100000, 0x41200000, 0x41300000,
911 0x41400000, 0x41500000, 0x41600000, 0x41700000,
922 ff_dlog(s->
avctx,
"decode coefficients for channel %i\n", c);
925 vlc = &coef_vlc[vlctable];
946 for (i = 0; i < 4; i += 2) {
960 vals[i+1] = fval_tab[symbol_to_vec2[idx] & 0xF];
965 vals[1] = fval_tab[(symbol_to_vec4[idx] >> 8) & 0xF];
966 vals[2] = fval_tab[(symbol_to_vec4[idx] >> 4) & 0xF];
967 vals[3] = fval_tab[ symbol_to_vec4[idx] & 0xF];
971 for (i = 0; i < 4; i++) {
977 ci->
coeffs[cur_coeff] = 0;
988 memset(&ci->
coeffs[cur_coeff], 0,
991 level, run, 1, ci->
coeffs,
1058 sign = (code & 1) - 1;
1059 skip = (code & 0x3f) >> 1;
1060 }
else if (idx == 1) {
1071 "invalid scale factor coding\n");
1107 float** ch_end = ch_data + num_channels;
1113 sfb < s->cur_sfb_offsets + s->
num_bands; sfb++) {
1119 const float* data_end = data + num_channels;
1120 float* data_ptr =
data;
1123 for (ch = ch_data; ch < ch_end; ch++)
1124 *data_ptr++ = (*ch)[y];
1126 for (ch = ch_data; ch < ch_end; ch++) {
1129 while (data_ptr < data_end)
1130 sum += *data_ptr++ * *mat++;
1138 ch_data[0] + sfb[0],
1141 ch_data[1] + sfb[0],
1189 int transmit_coeffs = 0;
1190 int cur_subwoofer_cutoff;
1208 "processing subframe with offset %i len %i\n", offset, subframe_len);
1258 if (!(num_fill_bits =
get_bits(&s->
gb, 2))) {
1263 if (num_fill_bits >= 0) {
1287 transmit_coeffs = 1;
1291 if (transmit_coeffs) {
1317 if (step == -32 || step == 31) {
1318 const int sign = (step == 31) - 1;
1324 quant_step += ((quant +
step) ^ sign) - sign;
1326 if (quant_step < 0) {
1353 ff_dlog(s->
avctx,
"BITSTREAM: subframe header length was %i\n",
1367 ff_dlog(s->
avctx,
"BITSTREAM: subframe length was %i\n",
1370 if (transmit_coeffs) {
1380 memset(&s->
tmp[cur_subwoofer_cutoff], 0,
sizeof(*s->
tmp) *
1381 (subframe_len - cur_subwoofer_cutoff));
1393 quant, end - start);
1426 int more_frames = 0;
1434 ff_dlog(s->
avctx,
"decoding frame with length %x\n", len);
1475 ff_dlog(s->
avctx,
"BITSTREAM: frame header length was %i\n",
1518 "frame[%"PRIu32
"] would have to skip %i bits\n",
1588 align =
FFMIN(align, len);
1609 int buf_size = avpkt->
size;
1610 int num_bits_prev_frame;
1611 int packet_sequence_number;
1665 packet_sequence_number =
get_bits(gb, 4);
1670 packet_sequence_number = 0;
1682 num_bits_prev_frame);
1689 "Packet loss detected! seq %"PRIx8
" vs %x\n",
1694 if (num_bits_prev_frame > 0) {
1696 if (num_bits_prev_frame >= remaining_packet_bits) {
1697 num_bits_prev_frame = remaining_packet_bits;
1703 save_bits(s, gb, num_bits_prev_frame, 1);
1704 ff_dlog(avctx,
"accumulated %x bits of frame data\n",
1711 ff_dlog(avctx,
"ignoring %x previously saved bits\n",
1781 int *got_frame_ptr,
AVPacket *avpkt)
1798 int *got_frame_ptr,
AVPacket *avpkt)
1801 int got_stream_frame_ptr = 0;
1813 &got_stream_frame_ptr, avpkt);
1816 got_stream_frame_ptr = 0;
1821 if (got_stream_frame_ptr) {
1829 }
else if (ret < 0) {
1899 int i,
ret, start_channels = 0;
1947 if (start_channels != avctx->
channels)
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
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.
#define XMA_MAX_CHANNELS_STREAM
This structure describes decoded (raw) audio or video data.
float samples[XMA_MAX_CHANNELS][512 *64]
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)
Skips the specified number of bits.
static av_cold int init(AVCodecContext *avctx)
AVCodecContext * avctx
codec context for av_log
int offset[XMA_MAX_STREAMS]
#define INIT_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)
uint32_t decode_flags
used compression features
#define avpriv_request_sample(...)
int start_channel[XMA_MAX_STREAMS]
#define FF_DEBUG_BITSTREAM
static const uint16_t vec4_huffcodes[HUFF_VEC4_SIZE]
int8_t scale_factor_step
scaling step for the current subframe
static void wmapro_flush(AVCodecContext *avctx)
Clear decoder buffers (for seeking).
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
if it could not because there are no more frames
#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 void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
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
SINETABLE_CONST float *const ff_sine_windows[]
static av_cold int xma_decode_init(AVCodecContext *avctx)
static const uint8_t scale_rl_run[HUFF_SCALE_RL_SIZE]
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
#define av_assert0(cond)
assert() equivalent, that is always enabled.
int frame_offset
frame offset in the bit reservoir
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)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
int8_t num_bands
number of scale factor bands
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
static av_cold int xma_decode_end(AVCodecContext *avctx)
void ff_copy_bits(PutBitContext *pb, const uint8_t *src, int length)
Copy the content of src to the bitstream.
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
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
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 av_cold int wmapro_decode_end(AVCodecContext *avctx)
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]
static VLC vec4_vlc
4 coefficients per symbol
static int get_bits_left(GetBitContext *gb)
void(* vector_fmul_window)(float *dst, const float *src0, const float *src1, const float *win, int len)
Overlap/add with window function.
static av_always_inline double ff_exp10(double x)
Compute 10^x for floating point values.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static int decode_subframe(WMAProDecodeCtx *s)
Decode a single subframe (block).
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
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
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
static av_cold int decode_end(WMAProDecodeCtx *s)
Uninitialize the decoder and free all resources.
#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.
int flags
AV_CODEC_FLAG_*.
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
AVCodec ff_wmapro_decoder
wmapro decoder
static int decode_subframe_length(WMAProDecodeCtx *s, int offset)
Decode the subframe length.
int8_t nb_channels
number of channels in stream (XMA1/2)
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 int put_bits_count(PutBitContext *s)
static int decode_packet(AVCodecContext *avctx, WMAProDecodeCtx *s, void *data, int *got_frame_ptr, AVPacket *avpkt)
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 const uint16_t symbol_to_vec4[HUFF_VEC4_SIZE]
static SDL_Window * window
static int decode_coeffs(WMAProDecodeCtx *s, int c)
Extract the coefficients from the bitstream.
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
uint8_t skip_packets
packets to skip to find next packet in a stream (XMA1/2)
uint32_t frame_num
current frame number (not used for decoding)
static void xma_flush(AVCodecContext *avctx)
static void flush(WMAProDecodeCtx *s)
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 av_cold int decode_init(WMAProDecodeCtx *s, AVCodecContext *avctx, int num_stream)
Initialize the decoder.
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
uint16_t decoded_samples
number of already processed samples
AVFrame * frames[XMA_MAX_STREAMS]
uint8_t frame_data[MAX_FRAMESIZE+AV_INPUT_BUFFER_PADDING_SIZE]
compressed frame data
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 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
uint8_t eof_done
set when EOF reached and extra subframe is written (XMA1/2)
#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.
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?
Libavcodec external API header.
channel group for channel transformations
AVSampleFormat
Audio sample formats.
static av_cold int wmapro_decode_init(AVCodecContext *avctx)
Initialize the decoder.
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]
tables for wmapro decoding
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
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
#define AV_CODEC_CAP_SUBFRAMES
Codec can output multiple frames per AVPacket Normally demuxers return one frame at a time...
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.
void(* vector_fmul_scalar)(float *dst, const float *src, float mul, int len)
Multiply a vector of floats by a scalar float.
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 av_cold int get_rate(AVCodecContext *avctx)
static VLC sf_rl_vlc
scale factor run length vlc
float * coeffs
pointer to the subframe decode buffer
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(* imdct_half)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
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.
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
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.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
int8_t scale_factor_idx
index for the transmitted scale factor values (used for resampling)
#define WMAPRO_BLOCK_MAX_SIZE
maximum block size
uint16_t subframe_len[MAX_SUBFRAMES]
subframe length in samples
internal math functions header
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.
channel
Use these values when setting the channel map with ebur128_set_channel().
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
#define AV_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_level[HUFF_SCALE_RL_SIZE]
GetBitContext pgb
bitstream reader context for the packet
int channels
number of audio channels
VLC_TYPE(* table)[2]
code, bits
WMAProDecodeCtx xma[XMA_MAX_STREAMS]
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.
Filter the word “frame” indicates either a video frame or a group of audio samples
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]
static int wmapro_decode_packet(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Decode a single WMA packet.
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
uint8_t ** extended_data
pointers to the data planes/channels.
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
static double val(void *priv, double ch)
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
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
int8_t skip_frame
skip output step
void ff_init_ff_sine_windows(int index)
initialize the specified entry of ff_sine_windows
static av_always_inline int get_bitsz(GetBitContext *s, int n)
Read 0-25 bits.
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step
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
static int xma_decode_packet(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)