Go to the documentation of this file.
34 float **plevel_table, uint16_t **pint_table,
38 const uint8_t *table_bits = vlc_table->
huffbits;
39 const uint32_t *table_codes = vlc_table->
huffcodes;
40 const uint16_t *levels_table = vlc_table->
levels;
41 uint16_t *run_table, *int_table;
52 if (!run_table || !flevel_table || !int_table) {
63 l = levels_table[k++];
64 for (j = 0; j < l; j++) {
71 *prun_table = run_table;
72 *plevel_table = flevel_table;
73 *pint_table = int_table;
83 float bps1, high_freq;
102 s->next_block_len_bits =
s->frame_len_bits;
103 s->prev_block_len_bits =
s->frame_len_bits;
104 s->block_len_bits =
s->frame_len_bits;
106 s->frame_len = 1 <<
s->frame_len_bits;
107 if (
s->use_variable_block_len) {
109 nb = ((flags2 >> 3) & 3) + 1;
115 s->nb_block_sizes = nb + 1;
117 s->nb_block_sizes = 1;
120 s->use_noise_coding = 1;
125 if (
s->version == 2) {
126 if (sample_rate1 >= 44100)
127 sample_rate1 = 44100;
128 else if (sample_rate1 >= 22050)
129 sample_rate1 = 22050;
130 else if (sample_rate1 >= 16000)
131 sample_rate1 = 16000;
132 else if (sample_rate1 >= 11025)
133 sample_rate1 = 11025;
134 else if (sample_rate1 >= 8000)
140 s->byte_offset_bits =
av_log2((
int) (
bps *
s->frame_len / 8.0 + 0.5)) + 2;
151 if (sample_rate1 == 44100) {
153 s->use_noise_coding = 0;
155 high_freq = high_freq * 0.4;
156 }
else if (sample_rate1 == 22050) {
158 s->use_noise_coding = 0;
159 else if (bps1 >= 0.72)
160 high_freq = high_freq * 0.7;
162 high_freq = high_freq * 0.6;
163 }
else if (sample_rate1 == 16000) {
165 high_freq = high_freq * 0.5;
167 high_freq = high_freq * 0.3;
168 }
else if (sample_rate1 == 11025)
169 high_freq = high_freq * 0.7;
170 else if (sample_rate1 == 8000) {
172 high_freq = high_freq * 0.5;
174 s->use_noise_coding = 0;
176 high_freq = high_freq * 0.65;
179 high_freq = high_freq * 0.75;
181 high_freq = high_freq * 0.6;
183 high_freq = high_freq * 0.5;
185 ff_dlog(
s->avctx,
"flags2=0x%x\n", flags2);
186 ff_dlog(
s->avctx,
"version=%d channels=%d sample_rate=%d bitrate=%"PRId64
" block_align=%d\n",
189 ff_dlog(
s->avctx,
"bps=%f bps1=%f high_freq=%f bitoffset=%d\n",
190 bps, bps1, high_freq,
s->byte_offset_bits);
191 ff_dlog(
s->avctx,
"use_noise_coding=%d use_exp_vlc=%d nb_block_sizes=%d\n",
192 s->use_noise_coding,
s->use_exp_vlc,
s->nb_block_sizes);
196 int a,
b,
pos, lpos, k, block_len,
i, j, n;
197 const uint8_t *
table;
203 for (k = 0; k <
s->nb_block_sizes; k++) {
204 block_len =
s->frame_len >> k;
206 if (
s->version == 1) {
208 for (
i = 0;
i < 25;
i++) {
211 pos = ((block_len * 2 *
a) + (
b >> 1)) /
b;
214 s->exponent_bands[0][
i] =
pos - lpos;
215 if (
pos >= block_len) {
221 s->exponent_sizes[0] =
i;
236 for (
i = 0;
i < n;
i++)
238 s->exponent_sizes[k] = n;
242 for (
i = 0;
i < 25;
i++) {
245 pos = ((block_len * 2 *
a) + (
b << 1)) / (4 *
b);
250 s->exponent_bands[k][j++] =
pos - lpos;
251 if (
pos >= block_len)
255 s->exponent_sizes[k] = j;
260 s->coefs_end[k] = (
s->frame_len - ((
s->frame_len * 9) / 100)) >> k;
262 s->high_band_start[k] = (
int) ((block_len * 2 * high_freq) /
264 n =
s->exponent_sizes[k];
267 for (
i = 0;
i < n;
i++) {
270 pos +=
s->exponent_bands[k][
i];
272 if (start < s->high_band_start[k])
273 start =
s->high_band_start[k];
274 if (end >
s->coefs_end[k])
275 end =
s->coefs_end[k];
277 s->exponent_high_bands[k][j++] = end - start;
279 s->exponent_high_sizes[k] = j;
286 for (
i = 0;
i <
s->nb_block_sizes;
i++) {
289 s->exponent_sizes[
i]);
290 for (j = 0; j <
s->exponent_sizes[
i]; j++)
291 ff_tlog(
s->avctx,
" %d",
s->exponent_bands[
i][j]);
298 for (
i = 0;
i <
s->nb_block_sizes;
i++) {
303 s->reset_block_lengths = 1;
305 if (
s->use_noise_coding) {
308 s->noise_mult = 0.02;
310 s->noise_mult = 0.04;
314 s->noise_table[
i] = 1.0 *
s->noise_mult;
320 norm = (1.0 / (
float) (1LL << 31)) * sqrt(3) *
s->noise_mult;
335 if (avctx->sample_rate >= 32000) {
338 else if (bps1 < 1.16)
341 s->coef_vlcs[0] = &
coef_vlcs[coef_vlc_table * 2];
342 s->coef_vlcs[1] = &
coef_vlcs[coef_vlc_table * 2 + 1];
344 &
s->int_table[0],
s->coef_vlcs[0]);
349 &
s->int_table[1],
s->coef_vlcs[1]);
356 else if (total_gain < 32)
358 else if (total_gain < 40)
360 else if (total_gain < 45)
371 for (
i = 0;
i <
s->nb_block_sizes;
i++)
376 if (
s->use_noise_coding)
378 for (
i = 0;
i < 2;
i++) {
427 VLC *vlc,
const float *level_table,
428 const uint16_t *run_table,
int version,
430 int block_len,
int frame_len_bits,
434 const uint32_t *ilvl = (
const uint32_t *) level_table;
435 uint32_t *iptr = (uint32_t *) ptr;
436 const unsigned int coef_mask = block_len - 1;
443 iptr[
offset & coef_mask] = ilvl[
code] ^ (sign & 0x80000000);
444 }
else if (
code == 1) {
461 "broken escape sequence\n");
476 "overflow (%d > %d) in spectral RLE, ignoring\n",
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
SINETABLE_CONST float *const ff_sine_windows[]
static const CoefVLCTable coef_vlcs[6]
int sample_rate
samples per second
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
static const uint8_t exponent_band_32000[3][25]
static const uint16_t table[]
int n
total number of codes
int nb_channels
Number of channels in this layout.
const uint8_t * huffbits
VLC bit size.
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
static av_cold int init_coef_vlc(VLC *vlc, uint16_t **prun_table, float **plevel_table, uint16_t **pint_table, const CoefVLCTable *vlc_table)
const struct AVCodec * codec
float WMACoef
type for decoded coefficients, int16_t would be enough for wma 1/2
AVChannelLayout ch_layout
Audio channel layout.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
#define vlc_init(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
const uint16_t ff_wma_critical_freqs[25]
int ff_wma_total_gain_to_bits(int total_gain)
const uint32_t * huffcodes
VLC bit values.
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
int64_t bit_rate
the average bitrate
static unsigned int get_bits1(GetBitContext *s)
static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)
Parse a vlc code.
int ff_wma_end(AVCodecContext *avctx)
av_cold int ff_wma_init(AVCodecContext *avctx, int flags2)
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
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
av_cold void av_tx_uninit(AVTXContext **ctx)
Frees a context and sets *ctx to NULL, does nothing when *ctx == NULL.
#define i(width, name, range_min, range_max)
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
static const uint8_t exponent_band_44100[3][25]
#define av_malloc_array(a, b)
void ff_vlc_free(VLC *vlc)
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs.
main external API structure.
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.
void ff_init_ff_sine_windows(int index)
initialize the specified entry of ff_sine_windows
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
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.
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
static const uint8_t exponent_band_22050[3][25]
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
const uint16_t * levels
table to build run/level tables
unsigned int ff_wma_get_large_val(GetBitContext *gb)
Decode an uncompressed coefficient.