#include <string.h>
#include <regex.h>
#include <sys/select.h>
+#include <stdbool.h>
#include "para.h"
#include "error.h"
#include "ggo.h"
#include "string.h"
#include "sched.h"
+#include "buffer_tree.h"
#include "filter.h"
#include "bitstream.h"
#include "imdct.h"
#define LSP_POW_BITS 7
struct private_wmadec_data {
+ /** Information contained in the audio file header. */
struct asf_header_info ahi;
struct getbit_context gb;
/** Whether to use the bit reservoir. */
uint16_t exponent_bands[BLOCK_NB_SIZES][25];
/** 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
+ /** Maximal number of coded coefficients. */
+ int coefs_end[BLOCK_NB_SIZES];
int exponent_high_sizes[BLOCK_NB_SIZES];
int exponent_high_bands[BLOCK_NB_SIZES][HIGH_BAND_MAX_SIZE];
struct vlc hgain_vlc;
uint16_t *run_table[2];
uint16_t *level_table[2];
const struct coef_vlc_table *coef_vlcs[2];
- /* frame info */
- int frame_len; ///< frame length in samples
- int frame_len_bits; ///< frame_len = 1 << frame_len_bits
+ /** Frame length in samples. */
+ int frame_len;
+ /** log2 of frame_len. */
+ int frame_len_bits;
/** Number of block sizes. */
int nb_block_sizes;
/* block info */
int reset_block_lengths;
- int block_len_bits; ///< log2 of current block length
- int next_block_len_bits; ///< log2 of next block length
- int prev_block_len_bits; ///< log2 of prev block length
- int block_len; ///< block length in samples
- int block_pos; ///< current position in frame
- uint8_t ms_stereo; ///< true if mid/side stereo mode
- uint8_t channel_coded[MAX_CHANNELS]; ///< true if channel is coded
- int exponents_bsize[MAX_CHANNELS]; ///< log2 ratio frame/exp. length
+ /** log2 of current block length. */
+ int block_len_bits;
+ /** log2 of next block length. */
+ int next_block_len_bits;
+ /** log2 of previous block length. */
+ int prev_block_len_bits;
+ /** Block length in samples. */
+ int block_len;
+ /** Current position in frame. */
+ int block_pos;
+ /** True if mid/side stereo mode. */
+ uint8_t ms_stereo;
+ /** True if channel is coded. */
+ uint8_t channel_coded[MAX_CHANNELS];
+ /** log2 ratio frame/exp. length. */
+ int exponents_bsize[MAX_CHANNELS];
+
float exponents[MAX_CHANNELS][BLOCK_MAX_SIZE];
float max_exponent[MAX_CHANNELS];
int16_t coefs1[MAX_CHANNELS][BLOCK_MAX_SIZE];
float output[BLOCK_MAX_SIZE * 2];
struct mdct_context *mdct_ctx[BLOCK_NB_SIZES];
float *windows[BLOCK_NB_SIZES];
- /* output buffer for one frame and the last for IMDCT windowing */
+ /** Output buffer for one frame and the last for IMDCT windowing. */
float frame_out[MAX_CHANNELS][BLOCK_MAX_SIZE * 2];
- /* last frame info */
+ /** Last frame info. */
uint8_t last_superframe[MAX_CODED_SUPERFRAME_SIZE + 4]; /* padding added */
int last_bitoffset;
int last_superframe_len;
};
#define EXPVLCBITS 8
-#define EXPMAX ((19 + EXPVLCBITS - 1) / EXPVLCBITS)
+#define EXPMAX DIV_ROUND_UP(19, EXPVLCBITS)
#define HGAINVLCBITS 9
-#define HGAINMAX ((13 + HGAINVLCBITS - 1) / HGAINVLCBITS)
+#define HGAINMAX DIV_ROUND_UP(13, HGAINVLCBITS)
#define VLCBITS 9
-#define VLCMAX ((22 + VLCBITS - 1) / VLCBITS)
+#define VLCMAX DIV_ROUND_UP(22, VLCBITS)
-#define SINE_WINDOW(x) float sine_ ## x[x] __aligned(16)
+#define SINE_WINDOW(x) static float sine_ ## x[x] __a_aligned(16)
SINE_WINDOW(128);
SINE_WINDOW(256);
}
next:
for (ch = 0; ch < pwd->ahi.channels; ch++) {
- int n4, index;
+ int n4, idx;
n = pwd->block_len;
n4 = pwd->block_len / 2;
memset(pwd->output, 0, sizeof(pwd->output));
/* multiply by the window and add in the frame */
- index = (pwd->frame_len / 2) + pwd->block_pos - n4;
- wma_window(pwd, &pwd->frame_out[ch][index]);
+ idx = (pwd->frame_len / 2) + pwd->block_pos - n4;
+ wma_window(pwd, &pwd->frame_out[ch][idx]);
}
/* update block number */
goto fail;
samples += pwd->ahi.channels * pwd->frame_len;
}
- PARA_DEBUG_LOG("frame_len: %d, block_len: %d, outbytes: %zd, eaten: %d\n",
+ PARA_DEBUG_LOG("frame_len: %d, block_len: %d, outbytes: %d, eaten: %d\n",
pwd->frame_len, pwd->block_len,
- (int8_t *) samples - (int8_t *) data, pwd->ahi.block_align);
+ (int)((int8_t *)samples - (int8_t *)data), pwd->ahi.block_align);
*data_size = (int8_t *)samples - (int8_t *)data;
return pwd->ahi.block_align;
fail:
return ret;
}
-static ssize_t wmadec_convert(char *inbuffer, size_t len,
- struct filter_node *fn)
+static void wmadec_close(struct filter_node *fn)
{
- int ret, converted = 0;
struct private_wmadec_data *pwd = fn->private_data;
- if (len <= WMA_FRAME_SKIP)
- return 0;
+ if (!pwd)
+ return;
+ wmadec_cleanup(pwd);
+ free(fn->private_data);
+ fn->private_data = NULL;
+}
+
+static int wmadec_execute(struct btr_node *btrn, const char *cmd, char **result)
+{
+ struct filter_node *fn = btr_context(btrn);
+ struct private_wmadec_data *pwd = fn->private_data;
+
+ return decoder_execute(cmd, pwd->ahi.sample_rate, pwd->ahi.channels,
+ result);
+}
+
+#define WMA_OUTPUT_BUFFER_SIZE (128 * 1024)
+
+static void wmadec_post_select(__a_unused struct sched *s, struct task *t)
+{
+ struct filter_node *fn = container_of(t, struct filter_node, task);
+ int ret, converted;
+ struct private_wmadec_data *pwd = fn->private_data;
+ struct btr_node *btrn = fn->btrn;
+ size_t len;
+ char *in;
+
+next_buffer:
+ converted = 0;
+ t->error = 0;
+ ret = btr_node_status(btrn, fn->min_iqs, BTR_NT_INTERNAL);
+ if (ret < 0)
+ goto err;
+ if (ret == 0)
+ return;
+ btr_merge(btrn, fn->min_iqs);
+ len = btr_next_buffer(btrn, (char **)&in);
+ ret = -E_WMADEC_EOF;
+ if (len < fn->min_iqs)
+ goto err;
if (!pwd) {
- ret = wma_decode_init(inbuffer, len, &pwd);
- if (ret <= 0)
- return ret;
+ ret = wma_decode_init(in, len, &pwd);
+ if (ret < 0)
+ goto err;
+ if (ret == 0) {
+ fn->min_iqs += 4096;
+ goto next_buffer;
+ }
+ fn->min_iqs = 2 * (WMA_FRAME_SKIP + pwd->ahi.block_align);
fn->private_data = pwd;
- fn->fc->channels = pwd->ahi.channels;
- fn->fc->samplerate = pwd->ahi.sample_rate;
- return pwd->ahi.header_len;
+ converted = pwd->ahi.header_len;
+ goto success;
}
+ fn->min_iqs = WMA_FRAME_SKIP + pwd->ahi.block_align;
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)
+ char *out;
+ int out_size = WMA_OUTPUT_BUFFER_SIZE;
+ if (converted + fn->min_iqs > len)
break;
- ret = wma_decode_superframe(pwd, fn->buf + fn->loaded,
- &out_size, (uint8_t *)inbuffer + converted + WMA_FRAME_SKIP,
+ out = para_malloc(WMA_OUTPUT_BUFFER_SIZE);
+ ret = wma_decode_superframe(pwd, out,
+ &out_size, (uint8_t *)in + converted + WMA_FRAME_SKIP,
len - WMA_FRAME_SKIP);
- if (ret < 0)
- return ret;
- fn->loaded += out_size;
+ if (ret < 0) {
+ free(out);
+ goto err;
+ }
+ btr_add_output(out, out_size, btrn);
converted += ret + WMA_FRAME_SKIP;
}
- return converted;
-}
-
-static void wmadec_close(struct filter_node *fn)
-{
- struct private_wmadec_data *pwd = fn->private_data;
-
- if (!pwd)
- return;
- wmadec_cleanup(pwd);
- free(fn->buf);
- fn->buf = NULL;
- free(fn->private_data);
- fn->private_data = NULL;
+success:
+ btr_consume(btrn, converted);
+ return;
+err:
+ assert(ret < 0);
+ t->error = ret;
+ btr_remove_node(btrn);
}
static void wmadec_open(struct filter_node *fn)
{
- fn->bufsize = 1024 * 1024;
- fn->buf = para_malloc(fn->bufsize);
fn->private_data = NULL;
- fn->loaded = 0;
+ fn->min_iqs = 4096;
}
/**
{
f->open = wmadec_open;
f->close = wmadec_close;
- f->convert = wmadec_convert;
+ f->execute = wmadec_execute;
+ f->pre_select = generic_filter_pre_select;
+ f->post_select = wmadec_post_select;
}