35 float **plevel_table, uint16_t **pint_table,
40 const uint32_t *table_codes = vlc_table->
huffcodes;
41 const uint16_t *levels_table = vlc_table->
levels;
42 uint16_t *run_table, *int_table;
51 if (!run_table || !flevel_table || !int_table) {
62 l = levels_table[k++];
63 for (j = 0; j < l; j++) {
70 *prun_table = run_table;
71 *plevel_table = flevel_table;
72 *pint_table = int_table;
81 float bps1, high_freq;
100 s->next_block_len_bits =
s->frame_len_bits;
101 s->prev_block_len_bits =
s->frame_len_bits;
102 s->block_len_bits =
s->frame_len_bits;
104 s->frame_len = 1 <<
s->frame_len_bits;
105 if (
s->use_variable_block_len) {
107 nb = ((flags2 >> 3) & 3) + 1;
113 s->nb_block_sizes = nb + 1;
115 s->nb_block_sizes = 1;
118 s->use_noise_coding = 1;
123 if (
s->version == 2) {
124 if (sample_rate1 >= 44100)
125 sample_rate1 = 44100;
126 else if (sample_rate1 >= 22050)
127 sample_rate1 = 22050;
128 else if (sample_rate1 >= 16000)
129 sample_rate1 = 16000;
130 else if (sample_rate1 >= 11025)
131 sample_rate1 = 11025;
132 else if (sample_rate1 >= 8000)
138 s->byte_offset_bits =
av_log2((
int) (
bps *
s->frame_len / 8.0 + 0.5)) + 2;
149 if (sample_rate1 == 44100) {
151 s->use_noise_coding = 0;
153 high_freq = high_freq * 0.4;
154 }
else if (sample_rate1 == 22050) {
156 s->use_noise_coding = 0;
157 else if (bps1 >= 0.72)
158 high_freq = high_freq * 0.7;
160 high_freq = high_freq * 0.6;
161 }
else if (sample_rate1 == 16000) {
163 high_freq = high_freq * 0.5;
165 high_freq = high_freq * 0.3;
166 }
else if (sample_rate1 == 11025)
167 high_freq = high_freq * 0.7;
168 else if (sample_rate1 == 8000) {
170 high_freq = high_freq * 0.5;
172 s->use_noise_coding = 0;
174 high_freq = high_freq * 0.65;
177 high_freq = high_freq * 0.75;
179 high_freq = high_freq * 0.6;
181 high_freq = high_freq * 0.5;
183 ff_dlog(
s->avctx,
"flags2=0x%x\n", flags2);
184 ff_dlog(
s->avctx,
"version=%d channels=%d sample_rate=%d bitrate=%"PRId64
" block_align=%d\n",
187 ff_dlog(
s->avctx,
"bps=%f bps1=%f high_freq=%f bitoffset=%d\n",
188 bps, bps1, high_freq,
s->byte_offset_bits);
189 ff_dlog(
s->avctx,
"use_noise_coding=%d use_exp_vlc=%d nb_block_sizes=%d\n",
190 s->use_noise_coding,
s->use_exp_vlc,
s->nb_block_sizes);
194 int a,
b,
pos, lpos, k, block_len,
i, j, n;
201 for (k = 0; k <
s->nb_block_sizes; k++) {
202 block_len =
s->frame_len >> k;
204 if (
s->version == 1) {
206 for (
i = 0;
i < 25;
i++) {
209 pos = ((block_len * 2 *
a) + (
b >> 1)) /
b;
212 s->exponent_bands[0][
i] =
pos - lpos;
213 if (
pos >= block_len) {
219 s->exponent_sizes[0] =
i;
234 for (
i = 0;
i < n;
i++)
236 s->exponent_sizes[k] = n;
240 for (
i = 0;
i < 25;
i++) {
243 pos = ((block_len * 2 *
a) + (
b << 1)) / (4 *
b);
248 s->exponent_bands[k][j++] =
pos - lpos;
249 if (
pos >= block_len)
253 s->exponent_sizes[k] = j;
258 s->coefs_end[k] = (
s->frame_len - ((
s->frame_len * 9) / 100)) >> k;
260 s->high_band_start[k] = (
int) ((block_len * 2 * high_freq) /
262 n =
s->exponent_sizes[k];
265 for (
i = 0;
i < n;
i++) {
268 pos +=
s->exponent_bands[k][
i];
270 if (start < s->high_band_start[k])
271 start =
s->high_band_start[k];
272 if (end >
s->coefs_end[k])
273 end =
s->coefs_end[k];
275 s->exponent_high_bands[k][j++] = end - start;
277 s->exponent_high_sizes[k] = j;
284 for (
i = 0;
i <
s->nb_block_sizes;
i++) {
287 s->exponent_sizes[
i]);
288 for (j = 0; j <
s->exponent_sizes[
i]; j++)
289 ff_tlog(
s->avctx,
" %d",
s->exponent_bands[
i][j]);
296 for (
i = 0;
i <
s->nb_block_sizes;
i++) {
301 s->reset_block_lengths = 1;
303 if (
s->use_noise_coding) {
306 s->noise_mult = 0.02;
308 s->noise_mult = 0.04;
312 s->noise_table[
i] = 1.0 *
s->noise_mult;
318 norm = (1.0 / (
float) (1LL << 31)) * sqrt(3) *
s->noise_mult;
321 s->noise_table[
i] = (float) ((
int)
seed) * norm;
333 if (avctx->sample_rate >= 32000) {
336 else if (bps1 < 1.16)
339 s->coef_vlcs[0] = &
coef_vlcs[coef_vlc_table * 2];
340 s->coef_vlcs[1] = &
coef_vlcs[coef_vlc_table * 2 + 1];
342 &
s->int_table[0],
s->coef_vlcs[0]);
347 &
s->int_table[1],
s->coef_vlcs[1]);
354 else if (total_gain < 32)
356 else if (total_gain < 40)
358 else if (total_gain < 45)
369 for (
i = 0;
i <
s->nb_block_sizes;
i++)
374 if (
s->use_noise_coding)
376 for (
i = 0;
i < 2;
i++) {
425 VLC *vlc,
const float *level_table,
426 const uint16_t *run_table,
int version,
428 int block_len,
int frame_len_bits,
432 const uint32_t *ilvl = (
const uint32_t *) level_table;
433 uint32_t *iptr = (uint32_t *) ptr;
434 const unsigned int coef_mask = block_len - 1;
441 iptr[
offset & coef_mask] = ilvl[
code] ^ (sign & 0x80000000);
442 }
else if (
code == 1) {
459 "broken escape sequence\n");
474 "overflow (%d > %d) in spectral RLE, ignoring\n",
Macro definitions for various function/variable attributes.
Libavcodec external API header.
void ff_free_vlc(VLC *vlc)
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
static unsigned int get_bits1(GetBitContext *s)
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
common internal API header
static const uint16_t table[]
void ff_init_ff_sine_windows(int index)
initialize the specified entry of ff_sine_windows
SINETABLE_CONST float *const ff_sine_windows[]
main external API structure.
int64_t bit_rate
the average bitrate
const struct AVCodec * codec
int sample_rate
samples per second
int channels
number of audio channels
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs.
const uint32_t * huffcodes
VLC bit values.
const uint8_t * huffbits
VLC bit size.
int n
total number of codes
const uint16_t * levels
table to build run/level tables
VLC_TYPE(* table)[2]
code, bits
#define av_malloc_array(a, b)
static const uint8_t offset[127][2]
#define init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
int ff_wma_total_gain_to_bits(int total_gain)
static av_cold int init_coef_vlc(VLC *vlc, uint16_t **prun_table, float **plevel_table, uint16_t **pint_table, const CoefVLCTable *vlc_table)
av_cold int ff_wma_init(AVCodecContext *avctx, int flags2)
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.
unsigned int ff_wma_get_large_val(GetBitContext *gb)
Decode an uncompressed coefficient.
int ff_wma_end(AVCodecContext *avctx)
float WMACoef
type for decoded coefficients, int16_t would be enough for wma 1/2
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.
const uint16_t ff_wma_critical_freqs[25]
static const uint8_t exponent_band_32000[3][25]
static const uint8_t exponent_band_22050[3][25]
static const CoefVLCTable coef_vlcs[6]
static const uint8_t exponent_band_44100[3][25]