struct private_wmadec_data {
struct asf_header_info ahi;
struct getbit_context gb;
+ /** Whether to use the bit reservoir. */
int use_bit_reservoir;
+ /** Whether to use variable block length. */
int use_variable_block_len;
- int use_exp_vlc; ///< exponent coding: 0 = lsp, 1 = vlc + delta
- int use_noise_coding; ///< true if perceptual noise is added
+ /** Whether to use exponent coding. */
+ int use_exp_vlc;
+ /** Whether perceptual noise is added. */
+ int use_noise_coding;
int byte_offset_bits;
struct vlc exp_vlc;
int exponent_sizes[BLOCK_NB_SIZES];
uint16_t exponent_bands[BLOCK_NB_SIZES][25];
- int high_band_start[BLOCK_NB_SIZES]; ///< index of first coef in high band
- int coefs_start; ///< first coded coef
+ /** The index of the first coef in high band. */
+ int high_band_start[BLOCK_NB_SIZES];
int coefs_end[BLOCK_NB_SIZES]; ///< max number of coded coefficients
int exponent_high_sizes[BLOCK_NB_SIZES];
int exponent_high_bands[BLOCK_NB_SIZES][HIGH_BAND_MAX_SIZE];
/* frame info */
int frame_len; ///< frame length in samples
int frame_len_bits; ///< frame_len = 1 << frame_len_bits
- int nb_block_sizes; ///< number of block sizes
+ /** Number of block sizes. */
+ int nb_block_sizes;
/* block info */
int reset_block_lengths;
int block_len_bits; ///< log2 of current block length
int a, b, pos, lpos, k, block_len, i, j, n;
const uint8_t *table;
- pwd->coefs_start = 0;
for (k = 0; k < pwd->nb_block_sizes; k++) {
block_len = pwd->frame_len >> k;
while (q < q_end) {
code = get_vlc(&pwd->gb, pwd->exp_vlc.table, EXPVLCBITS, EXPMAX);
if (code < 0)
- return -1;
+ return code;
/* NOTE: this offset is the same as MPEG4 AAC ! */
last_exp += code - 60;
/* XXX: use a table */
pwd->hgain_vlc.table, HGAINVLCBITS,
HGAINMAX);
if (code < 0)
- return -1;
+ return code;
val += code - 18;
}
pwd->high_band_values[ch][i] = val;
coefs = pwd->coefs[ch];
if (!pwd->use_noise_coding) {
/* XXX: optimize more */
- for (i = 0; i < pwd->coefs_start; i++)
- *coefs++ = 0.0;
n = nb_coefs[ch];
for (i = 0; i < n; i++)
*coefs++ = coefs1[i] *
continue;
}
mult1 = mult;
- /* very low freqs: noise */
- for (i = 0; i < pwd->coefs_start; i++) {
- *coefs++ = pwd->noise_table[pwd->noise_index] *
- exponents[i << bsize >> esize] * mult1;
- pwd->noise_index = (pwd->noise_index + 1) &
- (NOISE_TAB_SIZE - 1);
- }
n1 = pwd->exponent_high_sizes[bsize];
/* compute power of high bands */
exponents = pwd->exponents[ch] +
exponents += n << bsize;
}
/* main freqs and high freqs */
- exponents = pwd->exponents[ch] + (pwd->coefs_start << bsize);
+ exponents = pwd->exponents[ch];
for (j = -1; j < n1; j++) {
if (j < 0)
- n = pwd->high_band_start[bsize]
- - pwd->coefs_start;
+ n = pwd->high_band_start[bsize];
else
n = pwd->exponent_high_bands[pwd->frame_len_bits
- pwd->block_len_bits][j];
}
/**
- * @return 0 if OK. 1 if last block of frame. return -1 if
- * unrecorrable error.
+ * Returns 0 if OK, 1 if last block of frame, negative on uncorrectable
+ * errors.
*/
static int wma_decode_block(struct private_wmadec_data *pwd)
{
- int n, v, ch, code, bsize;
+ int ret, n, v, ch, code, bsize;
int coef_nb_bits, total_gain;
int nb_coefs[MAX_CHANNELS];
pwd->reset_block_lengths = 0;
v = get_bits(&pwd->gb, n);
if (v >= pwd->nb_block_sizes)
- return -1;
+ return -E_WMA_BLOCK_SIZE;
pwd->prev_block_len_bits = pwd->frame_len_bits - v;
v = get_bits(&pwd->gb, n);
if (v >= pwd->nb_block_sizes)
- return -1;
+ return -E_WMA_BLOCK_SIZE;
pwd->block_len_bits = pwd->frame_len_bits - v;
} else {
/* update block lengths */
}
v = get_bits(&pwd->gb, n);
if (v >= pwd->nb_block_sizes)
- return -1;
+ return -E_WMA_BLOCK_SIZE;
pwd->next_block_len_bits = pwd->frame_len_bits - v;
} else {
/* fixed block len */
if (!v)
goto next;
- /* read total gain and extract corresponding number of bits for
- coef escape coding */
+ /*
+ * Read total gain and extract corresponding number of bits for coef
+ * escape coding.
+ */
total_gain = 1;
for (;;) {
int a = get_bits(&pwd->gb, 7);
coef_nb_bits = wma_total_gain_to_bits(total_gain);
/* compute number of coefficients */
- n = pwd->coefs_end[bsize] - pwd->coefs_start;
+ n = pwd->coefs_end[bsize];
for (ch = 0; ch < pwd->ahi.channels; ch++)
nb_coefs[ch] = n;
- if (compute_high_band_values(pwd, bsize, nb_coefs) < 0)
- return -1;
+ ret = compute_high_band_values(pwd, bsize, nb_coefs);
+ if (ret < 0)
+ return ret;
/* exponents can be reused in short blocks. */
if ((pwd->block_len_bits == pwd->frame_len_bits) || get_bit(&pwd->gb)) {
for (ch = 0; ch < pwd->ahi.channels; ch++) {
if (pwd->channel_coded[ch]) {
if (pwd->use_exp_vlc) {
- if (decode_exp_vlc(pwd, ch) < 0)
- return -1;
- } else {
+ ret = decode_exp_vlc(pwd, ch);
+ if (ret < 0)
+ return ret;
+ } else
decode_exp_lsp(pwd, ch);
- }
pwd->exponents_bsize[ch] = bsize;
}
}
code = get_vlc(&pwd->gb, coef_vlc->table,
VLCBITS, VLCMAX);
if (code < 0)
- return -1;
+ return code;
if (code == 1) /* EOB */
break;
if (code == 0) { /* escape */
break;
}
}
-
compute_mdct_coefficients(pwd, bsize, total_gain, nb_coefs);
-
if (pwd->ms_stereo && pwd->channel_coded[1]) {
float a, b;
int i;
-
/*
* Nominal case for ms stereo: we do it before mdct.
*
pwd->coefs[1][i] = a - b;
}
}
-
next:
for (ch = 0; ch < pwd->ahi.channels; ch++) {
int n4, index;
for (;;) {
ret = wma_decode_block(pwd);
if (ret < 0)
- return -1;
+ return ret;
if (ret)
break;
}
* This frame is stored in the last superframe and in
* the current one.
*/
- ret = -E_WMA_DECODE;
- if (wma_decode_frame(pwd, samples) < 0)
+ ret = wma_decode_frame(pwd, samples);
+ if (ret < 0)
goto fail;
frame_count++;
samples += pwd->ahi.channels * pwd->frame_len;
pwd->reset_block_lengths = 1;
for (i = 0; i < nb_frames; i++) {
- ret = -E_WMA_DECODE;
- if (wma_decode_frame(pwd, samples) < 0)
+ ret = wma_decode_frame(pwd, samples);
+ if (ret < 0)
goto fail;
frame_count++;
samples += pwd->ahi.channels * pwd->frame_len;
if (pwd->ahi.channels * pwd->frame_len * sizeof(int16_t) > *data_size)
goto fail;
/* single frame decode */
- ret = -E_WMA_DECODE;
- if (wma_decode_frame(pwd, samples) < 0)
+ ret = wma_decode_frame(pwd, samples);
+ if (ret < 0)
goto fail;
frame_count++;
samples += pwd->ahi.channels * pwd->frame_len;
static ssize_t wmadec_convert(char *inbuffer, size_t len,
struct filter_node *fn)
{
- int ret, out_size = fn->bufsize - fn->loaded;
+ int ret, converted = 0;
struct private_wmadec_data *pwd = fn->private_data;
- if (out_size < 128 * 1024)
- return 0;
if (len <= WMA_FRAME_SKIP)
return 0;
if (!pwd) {
fn->fc->samplerate = pwd->ahi.sample_rate;
return pwd->ahi.header_len;
}
- /* skip 31 bytes */
- if (len <= WMA_FRAME_SKIP + pwd->ahi.block_align)
- return 0;
- ret = wma_decode_superframe(pwd, fn->buf + fn->loaded,
- &out_size, (uint8_t *)inbuffer + WMA_FRAME_SKIP,
- len - WMA_FRAME_SKIP);
- if (ret < 0)
- return ret;
- fn->loaded += out_size;
- return ret + WMA_FRAME_SKIP;
+ for (;;) {
+ int out_size;
+ if (converted + WMA_FRAME_SKIP + pwd->ahi.block_align > len)
+ break;
+ out_size = fn->bufsize - fn->loaded;
+ if (out_size < 128 * 1024)
+ break;
+ ret = wma_decode_superframe(pwd, fn->buf + fn->loaded,
+ &out_size, (uint8_t *)inbuffer + converted + WMA_FRAME_SKIP,
+ len - WMA_FRAME_SKIP);
+ if (ret < 0)
+ return ret;
+ fn->loaded += out_size;
+ converted += ret + WMA_FRAME_SKIP;
+ }
+ return converted;
}
static void wmadec_close(struct filter_node *fn)
projects / paraslash.git / blobdiff