#include "para.h"
#include "error.h"
#include "list.h"
-#include "ggo.h"
#include "string.h"
#include "sched.h"
#include "buffer_tree.h"
#include "filter.h"
+#include "portable_io.h"
#include "bitstream.h"
#include "imdct.h"
#include "wma.h"
int frame_len_bits;
/** Number of block sizes, one if !ahi->use_variable_block_len. */
int nb_block_sizes;
- /* block info */
- int reset_block_lengths;
+ /* Whether to update block lengths from getbit context. */
+ bool reset_block_lengths;
/** log2 of current block length. */
int block_len_bits;
/** log2 of next block length. */
};
#define EXPVLCBITS 8
-#define EXPMAX DIV_ROUND_UP(19, EXPVLCBITS)
-
#define HGAINVLCBITS 9
-#define HGAINMAX DIV_ROUND_UP(13, HGAINVLCBITS)
-
#define VLCBITS 9
-#define VLCMAX DIV_ROUND_UP(22, VLCBITS)
/** \cond sine_winows */
window[i] = sinf((i + 0.5) * (M_PI / (2.0 * n)));
}
-static void wmadec_cleanup(struct private_wmadec_data *pwd)
-{
- int i;
-
- for (i = 0; i < pwd->nb_block_sizes; i++)
- imdct_end(pwd->mdct_ctx[i]);
- if (pwd->ahi.use_exp_vlc)
- free_vlc(&pwd->exp_vlc);
- if (pwd->use_noise_coding)
- free_vlc(&pwd->hgain_vlc);
- for (i = 0; i < 2; i++) {
- free_vlc(&pwd->coef_vlc[i]);
- free(pwd->run_table[i]);
- free(pwd->level_table[i]);
- }
-}
-
static void init_coef_vlc(struct vlc *vlc, uint16_t **prun_table,
uint16_t **plevel_table, const struct coef_vlc_table *vlc_table)
{
else
high_freq = high_freq * 0.5;
}
- PARA_INFO_LOG("channels=%d sample_rate=%d "
- "bitrate=%d block_align=%d\n",
+ PARA_INFO_LOG("channels=%u sample_rate=%u "
+ "bitrate=%u block_align=%d\n",
ahi->channels, ahi->sample_rate,
ahi->bit_rate, ahi->block_align);
PARA_INFO_LOG("frame_len=%d, bps=%f bps1=%f "
pwd->windows[i] = sine_windows[pwd->frame_len_bits - i - 7];
}
- pwd->reset_block_lengths = 1;
+ pwd->reset_block_lengths = true;
if (pwd->use_noise_coding) {
/* init the noise generator */
return 0;
}
-static void wma_lsp_to_curve_init(struct private_wmadec_data *pwd, int frame_len)
+static void wma_lsp_to_curve_init(struct private_wmadec_data *pwd)
{
float wdel, a, b;
int i, e, m;
- wdel = M_PI / frame_len;
- for (i = 0; i < frame_len; i++)
+ wdel = M_PI / pwd->frame_len;
+ for (i = 0; i < pwd->frame_len; i++)
pwd->lsp_cos_table[i] = 2.0f * cos(wdel * i);
/* tables for x^-0.25 computation */
wma_scale_huffbits, wma_scale_huffcodes, 4);
} else {
PARA_INFO_LOG("using curve\n");
- wma_lsp_to_curve_init(pwd, pwd->frame_len);
+ wma_lsp_to_curve_init(pwd);
}
*result = pwd;
return pwd->ahi.header_len;
last_exp = 36;
while (q < q_end) {
- code = get_vlc(&pwd->gb, pwd->exp_vlc.table, EXPVLCBITS, EXPMAX);
+ code = get_vlc(&pwd->gb, &pwd->exp_vlc);
if (code < 0)
return code;
/* NOTE: this offset is the same as MPEG4 AAC ! */
if (val == (int)0x80000000)
val = get_bits(&pwd->gb, 7) - 19;
else {
- int code = get_vlc(&pwd->gb,
- pwd->hgain_vlc.table, HGAINVLCBITS,
- HGAINMAX);
+ int code = get_vlc(&pwd->gb, &pwd->hgain_vlc);
if (code < 0)
return code;
val += code - 18;
}
/* very high freqs: noise */
n = pwd->block_len - pwd->coefs_end[bsize];
- mult1 = mult * exponents[((-1 << bsize)) >> esize];
+ mult1 = mult * exponents[(-(1 << bsize)) >> esize];
for (i = 0; i < n; i++) {
*coefs++ = pwd->noise_table[pwd->noise_index] * mult1;
pwd->noise_index = (pwd->noise_index + 1)
n = wma_log2(pwd->nb_block_sizes - 1) + 1;
if (pwd->reset_block_lengths) {
- pwd->reset_block_lengths = 0;
+ pwd->reset_block_lengths = false;
v = get_bits(&pwd->gb, n);
if (v >= pwd->nb_block_sizes)
return -E_WMA_BLOCK_SIZE;
eptr = ptr + nb_coefs[ch];
memset(ptr, 0, pwd->block_len * sizeof(int16_t));
for (;;) {
- code = get_vlc(&pwd->gb, coef_vlc->table,
- VLCBITS, VLCMAX);
+ code = get_vlc(&pwd->gb, coef_vlc);
if (code < 0)
return code;
if (code == 1) /* EOB */
/* Decode a frame of frame_len samples. */
static int wma_decode_frame(struct private_wmadec_data *pwd, int16_t *samples)
{
- int ret, i, n, ch, incr;
+ int ret, i, ch;
int16_t *ptr;
float *iptr;
}
/* convert frame to integer */
- n = pwd->frame_len;
- incr = pwd->ahi.channels;
for (ch = 0; ch < pwd->ahi.channels; ch++) {
ptr = samples + ch;
iptr = pwd->frame_out[ch];
- for (i = 0; i < n; i++) {
+ for (i = 0; i < pwd->frame_len; i++) {
*ptr = av_clip_int16(lrintf(*iptr++));
- ptr += incr;
+ ptr += pwd->ahi.channels;
}
/* prepare for next block */
memmove(&pwd->frame_out[ch][0], &pwd->frame_out[ch][pwd->frame_len],
}
static int wma_decode_superframe(struct private_wmadec_data *pwd, void *data,
- int *data_size, const uint8_t *buf, int buf_size)
+ int *data_size, const uint8_t *buf)
{
- int ret;
+ int ret, buf_size = pwd->ahi.packet_size - WMA_FRAME_SKIP;
int16_t *samples;
- if (buf_size == 0) {
- pwd->last_superframe_len = 0;
- return 0;
- }
- if (buf_size < pwd->ahi.block_align)
- return 0;
- buf_size = pwd->ahi.block_align;
samples = data;
init_get_bits(&pwd->gb, buf, buf_size);
if (pwd->ahi.use_bit_reservoir) {
if (len > 0)
skip_bits(&pwd->gb, len);
- pwd->reset_block_lengths = 1;
+ pwd->reset_block_lengths = true;
for (i = 0; i < nb_frames; i++) {
ret = wma_decode_frame(pwd, samples);
if (ret < 0)
static void wmadec_close(struct filter_node *fn)
{
struct private_wmadec_data *pwd = fn->private_data;
+ int i;
if (!pwd)
return;
- wmadec_cleanup(pwd);
+ for (i = 0; i < pwd->nb_block_sizes; i++)
+ imdct_end(pwd->mdct_ctx[i]);
+ if (pwd->ahi.use_exp_vlc)
+ free_vlc(&pwd->exp_vlc);
+ if (pwd->use_noise_coding)
+ free_vlc(&pwd->hgain_vlc);
+ for (i = 0; i < 2; i++) {
+ free_vlc(&pwd->coef_vlc[i]);
+ free(pwd->run_table[i]);
+ free(pwd->level_table[i]);
+ }
free(fn->private_data);
fn->private_data = NULL;
}
if (ret == 0)
return 0;
btr_merge(btrn, fn->min_iqs);
- len = btr_next_buffer(btrn, (char **)&in);
+ len = btr_next_buffer(btrn, &in);
ret = -E_WMADEC_EOF;
if (len < fn->min_iqs)
goto err;
fn->min_iqs += 4096;
goto next_buffer;
}
- fn->min_iqs = 2 * (WMA_FRAME_SKIP + pwd->ahi.block_align);
+ fn->min_iqs = 2 * pwd->ahi.packet_size;
fn->private_data = pwd;
converted = pwd->ahi.header_len;
goto success;
}
- fn->min_iqs = WMA_FRAME_SKIP + pwd->ahi.block_align;
+ fn->min_iqs = pwd->ahi.packet_size;
if (fn->min_iqs > len)
goto success;
out_size = WMA_OUTPUT_BUFFER_SIZE;
out = para_malloc(out_size);
ret = wma_decode_superframe(pwd, out, &out_size,
- (uint8_t *)in + WMA_FRAME_SKIP, len - WMA_FRAME_SKIP);
+ (uint8_t *)in + WMA_FRAME_SKIP);
if (ret < 0) {
free(out);
goto err;
}
- out = para_realloc(out, out_size);
- if (out_size > 0)
+ if (out_size > 0) {
+ out = para_realloc(out, out_size);
btr_add_output(out, out_size, btrn);
- converted += ret + WMA_FRAME_SKIP;
+ } else
+ free(out);
+ converted += pwd->ahi.packet_size;
success:
btr_consume(btrn, converted);
return 0;
fn->min_iqs = 4096;
}
-/**
- * The init function of the wma decoder.
- *
- * \param f Its fields are filled in by the function.
- */
-void wmadec_filter_init(struct filter *f)
-{
- f->open = wmadec_open;
- f->close = wmadec_close;
- f->execute = wmadec_execute;
- f->pre_select = generic_filter_pre_select;
- f->post_select = wmadec_post_select;
-}
+const struct filter lsg_filter_cmd_com_wmadec_user_data = {
+ .open = wmadec_open,
+ .close = wmadec_close,
+ .execute = wmadec_execute,
+ .pre_select = generic_filter_pre_select,
+ .post_select = wmadec_post_select,
+};
projects / paraslash.git / blobdiff