static av_cold int aac_encode_init(AVCodecContext *avctx)
{
AACEncContext *s = avctx->priv_data;
int i;
const uint8_t *sizes[2];
int lengths[2];
avctx->frame_size = 1024;
for (i = 0; i < 16; i++)
if (avctx->sample_rate == ff_mpeg4audio_sample_rates[i])
break;
if (i == 16) {
av_log(avctx, AV_LOG_ERROR, "Unsupported sample rate %d\n", avctx->sample_rate);
return -1;
}
if (avctx->channels > AAC_MAX_CHANNELS) {
av_log(avctx, AV_LOG_ERROR, "Unsupported number of channels: %d\n", avctx->channels);
return -1;
}
if (avctx->profile != FF_PROFILE_UNKNOWN && avctx->profile != FF_PROFILE_AAC_LOW) {
av_log(avctx, AV_LOG_ERROR, "Unsupported profile %d\n", avctx->profile);
return -1;
}
if (1024.0 * avctx->bit_rate / avctx->sample_rate > 6144 * avctx->channels) {
av_log(avctx, AV_LOG_ERROR, "Too many bits per frame requested\n");
return -1;
}
s->samplerate_index = i;
dsputil_init(&s->dsp, avctx);
ff_mdct_init(&s->mdct1024, 11, 0, 1.0);
ff_mdct_init(&s->mdct128, 8, 0, 1.0);
// window init
ff_kbd_window_init(ff_aac_kbd_long_1024, 4.0, 1024);
ff_kbd_window_init(ff_aac_kbd_short_128, 6.0, 128);
ff_init_ff_sine_windows(10);
ff_init_ff_sine_windows(7);
s->chan_map = aac_chan_configs[avctx->channels-1];
s->samples = av_malloc(2 * 1024 * avctx->channels * sizeof(s->samples[0]));
s->cpe = av_mallocz(sizeof(ChannelElement) * s->chan_map[0]);
avctx->extradata = av_mallocz(5 + FF_INPUT_BUFFER_PADDING_SIZE);
avctx->extradata_size = 5;
put_audio_specific_config(avctx);
sizes[0] = swb_size_1024[i];
sizes[1] = swb_size_128[i];
lengths[0] = ff_aac_num_swb_1024[i];
lengths[1] = ff_aac_num_swb_128[i];
ff_psy_init(&s->psy, avctx, 2, sizes, lengths, s->chan_map[0], &s->chan_map[1]);
s->psypp = ff_psy_preprocess_init(avctx);
s->coder = &ff_aac_coders[2];
s->lambda = avctx->global_quality ? avctx->global_quality : 120;
ff_aac_tableinit();
return 0;
}
static av_cold int aac_encode_init(AVCodecContext *avctx)
{
AACEncContext *s = avctx->priv_data;
int i;
const uint8_t *sizes[2];
int lengths[2];
avctx->frame_size = 1024;
for(i = 0; i < 16; i++)
if(avctx->sample_rate == ff_mpeg4audio_sample_rates[i])
break;
if(i == 16){
av_log(avctx, AV_LOG_ERROR, "Unsupported sample rate %d\n", avctx->sample_rate);
return -1;
}
if(avctx->channels > 6){
av_log(avctx, AV_LOG_ERROR, "Unsupported number of channels: %d\n", avctx->channels);
return -1;
}
s->samplerate_index = i;
dsputil_init(&s->dsp, avctx);
ff_mdct_init(&s->mdct1024, 11, 0, 1.0);
ff_mdct_init(&s->mdct128, 8, 0, 1.0);
// window init
ff_kbd_window_init(ff_aac_kbd_long_1024, 4.0, 1024);
ff_kbd_window_init(ff_aac_kbd_short_128, 6.0, 128);
ff_sine_window_init(ff_sine_1024, 1024);
ff_sine_window_init(ff_sine_128, 128);
s->samples = av_malloc(2 * 1024 * avctx->channels * sizeof(s->samples[0]));
s->cpe = av_mallocz(sizeof(ChannelElement) * aac_chan_configs[avctx->channels-1][0]);
avctx->extradata = av_malloc(2);
avctx->extradata_size = 2;
put_audio_specific_config(avctx);
sizes[0] = swb_size_1024[i];
sizes[1] = swb_size_128[i];
lengths[0] = ff_aac_num_swb_1024[i];
lengths[1] = ff_aac_num_swb_128[i];
ff_psy_init(&s->psy, avctx, 2, sizes, lengths);
s->psypp = ff_psy_preprocess_init(avctx);
s->coder = &ff_aac_coders[0];
s->lambda = avctx->global_quality ? avctx->global_quality : 120;
#if !CONFIG_HARDCODED_TABLES
for (i = 0; i < 428; i++)
ff_aac_pow2sf_tab[i] = pow(2, (i - 200)/4.);
#endif /* CONFIG_HARDCODED_TABLES */
if (avctx->channels > 5)
av_log(avctx, AV_LOG_ERROR, "This encoder does not yet enforce the restrictions on LFEs. "
"The output will most likely be an illegal bitstream.\n");
return 0;
}
static av_cold int dca_decode_init(AVCodecContext * avctx)
{
DCAContext *s = avctx->priv_data;
int i;
s->avctx = avctx;
dca_init_vlcs();
dsputil_init(&s->dsp, avctx);
ff_mdct_init(&s->imdct, 6, 1, 1.0);
for(i = 0; i < 6; i++)
s->samples_chanptr[i] = s->samples + i * 256;
avctx->sample_fmt = SAMPLE_FMT_S16;
if(s->dsp.float_to_int16_interleave == ff_float_to_int16_interleave_c) {
s->add_bias = 385.0f;
s->scale_bias = 1.0 / 32768.0;
} else {
s->add_bias = 0.0f;
s->scale_bias = 1.0;
/* allow downmixing to stereo */
if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
avctx->request_channels == 2) {
avctx->channels = avctx->request_channels;
}
}
return 0;
}
static av_cold int decode_init(AVCodecContext * avctx) {
NellyMoserDecodeContext *s = avctx->priv_data;
s->avctx = avctx;
av_lfg_init(&s->random_state, ff_random_get_seed());
ff_mdct_init(&s->imdct_ctx, 8, 1, 1.0);
dsputil_init(&s->dsp, avctx);
if(s->dsp.float_to_int16 == ff_float_to_int16_c) {
s->add_bias = 385;
s->scale_bias = 1.0/(8*32768);
} else {
s->add_bias = 0;
s->scale_bias = 1.0/(1*8);
}
/* Generate overlap window */
if (!ff_sine_128[127])
ff_sine_window_init(ff_sine_128, 128);
avctx->sample_fmt = SAMPLE_FMT_S16;
avctx->channel_layout = CH_LAYOUT_MONO;
return 0;
}
static av_cold int decode_init(AVCodecContext * avctx) {
NellyMoserDecodeContext *s = avctx->priv_data;
int i;
s->avctx = avctx;
av_init_random(0, &s->random_state);
ff_mdct_init(&s->imdct_ctx, 8, 1);
dsputil_init(&s->dsp, avctx);
if(s->dsp.float_to_int16 == ff_float_to_int16_c) {
s->add_bias = 385;
s->scale_bias = 1.0/(8*32768);
} else {
s->add_bias = 0;
s->scale_bias = 1.0/(1*8);
}
/* Generate overlap window */
if (!sine_window[0])
for (i=0 ; i<128; i++) {
sine_window[i] = sin((i + 0.5) / 256.0 * M_PI);
}
return 0;
}
static av_cold void init_atrac3_transforms(ATRAC3Context *q) {
float enc_window[256];
float s;
int i;
/* Generate the mdct window, for details see
* http://wiki.multimedia.cx/index.php?title=RealAudio_atrc#Windows */
for (i=0 ; i<256; i++)
enc_window[i] = (sin(((i + 0.5) / 256.0 - 0.5) * M_PI) + 1.0) * 0.5;
if (!mdct_window[0])
for (i=0 ; i<256; i++) {
mdct_window[i] = enc_window[i]/(enc_window[i]*enc_window[i] + enc_window[255-i]*enc_window[255-i]);
mdct_window[511-i] = mdct_window[i];
}
/* Generate the QMF window. */
for (i=0 ; i<24; i++) {
s = qmf_48tap_half[i] * 2.0;
qmf_window[i] = s;
qmf_window[47 - i] = s;
}
/* Initialize the MDCT transform. */
ff_mdct_init(&mdct_ctx, 9, 1);
}
static av_cold int decode_init(AVCodecContext * avctx) {
NellyMoserDecodeContext *s = avctx->priv_data;
s->avctx = avctx;
s->imdct_out = s->imdct_buf[0];
s->imdct_prev = s->imdct_buf[1];
av_lfg_init(&s->random_state, 0);
ff_mdct_init(&s->imdct_ctx, 8, 1, 1.0);
avpriv_float_dsp_init(&s->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
s->scale_bias = 1.0/(32768*8);
avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
/* Generate overlap window */
if (!ff_sine_128[127])
ff_init_ff_sine_windows(7);
avctx->channels = 1;
avctx->channel_layout = AV_CH_LAYOUT_MONO;
avcodec_get_frame_defaults(&s->frame);
avctx->coded_frame = &s->frame;
return 0;
}
static av_cold int decode_init(AVCodecContext * avctx) {
NellyMoserDecodeContext *s = avctx->priv_data;
s->avctx = avctx;
av_lfg_init(&s->random_state, 0);
ff_mdct_init(&s->imdct_ctx, 8, 1, 1.0);
dsputil_init(&s->dsp, avctx);
if (avctx->request_sample_fmt == AV_SAMPLE_FMT_FLT) {
s->scale_bias = 1.0/(32768*8);
avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
} else {
s->scale_bias = 1.0/(1*8);
avctx->sample_fmt = AV_SAMPLE_FMT_S16;
ff_fmt_convert_init(&s->fmt_conv, avctx);
s->float_buf = av_mallocz(NELLY_SAMPLES * sizeof(*s->float_buf));
if (!s->float_buf) {
av_log(avctx, AV_LOG_ERROR, "error allocating float buffer\n");
return AVERROR(ENOMEM);
}
}
/* Generate overlap window */
if (!ff_sine_128[127])
ff_init_ff_sine_windows(7);
avctx->channel_layout = AV_CH_LAYOUT_MONO;
avcodec_get_frame_defaults(&s->frame);
avctx->coded_frame = &s->frame;
return 0;
}
/**
* Initialize MDCT tables.
* @param nbits log2(MDCT size)
*/
av_cold int AC3_NAME(mdct_init)(AVCodecContext *avctx, AC3MDCTContext *mdct,
int nbits)
{
int ret = ff_mdct_init(&mdct->fft, nbits, 0, -1.0);
mdct->window = ff_ac3_window;
return ret;
}
av_cold void ff_atrac3p_init_imdct(AVCodecContext *avctx, FFTContext *mdct_ctx)
{
ff_init_ff_sine_windows(7);
ff_init_ff_sine_windows(6);
/* Initialize the MDCT transform. */
ff_mdct_init(mdct_ctx, 8, 1, -1.0);
}
static inline void mdct_init(FFTContext **s, int nbits, int inverse, double scale)
{
#if AVFFT
*s = av_mdct_init(nbits, inverse, scale);
#else
ff_mdct_init(*s, nbits, inverse, scale);
#endif
}
FFTContext *av_mdct_init(int nbits, int inverse, double scale)
{
FFTContext *s = av_malloc(sizeof(*s));
if (s)
ff_mdct_init(s, nbits, inverse, scale);
return s;
}
static av_cold int decode_init(AVCodecContext *avctx)
{
ATRAC3PContext *ctx = avctx->priv_data;
int i, ch, ret;
ff_atrac3p_init_vlcs();
avpriv_float_dsp_init(&ctx->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
/* initialize IPQF */
ff_mdct_init(&ctx->ipqf_dct_ctx, 5, 1, 32.0 / 32768.0);
ff_atrac3p_init_imdct(avctx, &ctx->mdct_ctx);
ff_atrac_init_gain_compensation(&ctx->gainc_ctx, 6, 2);
ff_atrac3p_init_wave_synth();
if ((ret = set_channel_params(ctx, avctx)) < 0)
return ret;
ctx->my_channel_layout = avctx->channel_layout;
ctx->ch_units = av_mallocz(sizeof(*ctx->ch_units) *
ctx->num_channel_blocks);
if (!ctx->ch_units) {
decode_close(avctx);
return AVERROR(ENOMEM);
}
for (i = 0; i < ctx->num_channel_blocks; i++) {
for (ch = 0; ch < 2; ch++) {
ctx->ch_units[i].channels[ch].ch_num = ch;
ctx->ch_units[i].channels[ch].wnd_shape = &ctx->ch_units[i].channels[ch].wnd_shape_hist[0][0];
ctx->ch_units[i].channels[ch].wnd_shape_prev = &ctx->ch_units[i].channels[ch].wnd_shape_hist[1][0];
ctx->ch_units[i].channels[ch].gain_data = &ctx->ch_units[i].channels[ch].gain_data_hist[0][0];
ctx->ch_units[i].channels[ch].gain_data_prev = &ctx->ch_units[i].channels[ch].gain_data_hist[1][0];
ctx->ch_units[i].channels[ch].tones_info = &ctx->ch_units[i].channels[ch].tones_info_hist[0][0];
ctx->ch_units[i].channels[ch].tones_info_prev = &ctx->ch_units[i].channels[ch].tones_info_hist[1][0];
/* clear IMDCT overlapping buffer */
memset(&ctx->ch_units[i].prev_buf[ch][0], 0,
sizeof(ctx->ch_units[i].prev_buf[ch][0]) *
ATRAC3P_FRAME_SAMPLES);
/* clear IPQF history */
memset(&ctx->ch_units[i].ipqf_ctx[ch], 0,
sizeof(ctx->ch_units[i].ipqf_ctx[ch]));
}
ctx->ch_units[i].waves_info = &ctx->ch_units[i].wave_synth_hist[0];
ctx->ch_units[i].waves_info_prev = &ctx->ch_units[i].wave_synth_hist[1];
}
avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
return 0;
}
static av_cold int dsp_init(AVCodecContext *avctx, AACEncContext *s)
{
int ret = 0;
ff_dsputil_init(&s->dsp, avctx);
// window init
ff_kbd_window_init(ff_aac_kbd_long_1024, 4.0, 1024);
ff_kbd_window_init(ff_aac_kbd_short_128, 6.0, 128);
ff_init_ff_sine_windows(10);
ff_init_ff_sine_windows(7);
if (ret = ff_mdct_init(&s->mdct1024, 11, 0, 32768.0))
return ret;
if (ret = ff_mdct_init(&s->mdct128, 8, 0, 32768.0))
return ret;
return 0;
}
static av_cold int dsp_init(AVCodecContext *avctx, AACEncContext *s)
{
int ret = 0;
avpriv_float_dsp_init(&s->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
// window init
ff_kbd_window_init(ff_aac_kbd_long_1024, 4.0, 1024);
ff_kbd_window_init(ff_aac_kbd_short_128, 6.0, 128);
ff_init_ff_sine_windows(10);
ff_init_ff_sine_windows(7);
if (ret = ff_mdct_init(&s->mdct1024, 11, 0, 32768.0))
return ret;
if (ret = ff_mdct_init(&s->mdct128, 8, 0, 32768.0))
return ret;
return 0;
}
static av_cold int aac_encode_init(AVCodecContext *avctx)
{
AACEncContext *s = avctx->priv_data;
int i;
avctx->frame_size = 1024;
for(i = 0; i < 16; i++)
if(avctx->sample_rate == ff_mpeg4audio_sample_rates[i])
break;
if(i == 16){
av_log(avctx, AV_LOG_ERROR, "Unsupported sample rate %d\n", avctx->sample_rate);
return -1;
}
if(avctx->channels > 6){
av_log(avctx, AV_LOG_ERROR, "Unsupported number of channels: %d\n", avctx->channels);
return -1;
}
s->samplerate_index = i;
dsputil_init(&s->dsp, avctx);
ff_mdct_init(&s->mdct1024, 11, 0);
ff_mdct_init(&s->mdct128, 8, 0);
// window init
ff_kbd_window_init(ff_aac_kbd_long_1024, 4.0, 1024);
ff_kbd_window_init(ff_aac_kbd_short_128, 6.0, 128);
ff_sine_window_init(ff_sine_1024, 1024);
ff_sine_window_init(ff_sine_128, 128);
s->samples = av_malloc(2 * 1024 * avctx->channels * sizeof(s->samples[0]));
s->cpe = av_mallocz(sizeof(ChannelElement) * aac_chan_configs[avctx->channels-1][0]);
if(ff_aac_psy_init(&s->psy, avctx, AAC_PSY_3GPP,
aac_chan_configs[avctx->channels-1][0], 0,
swb_size_1024[i], ff_aac_num_swb_1024[i], swb_size_128[i], ff_aac_num_swb_128[i]) < 0){
av_log(avctx, AV_LOG_ERROR, "Cannot initialize selected model.\n");
return -1;
}
avctx->extradata = av_malloc(2);
avctx->extradata_size = 2;
put_audio_specific_config(avctx);
return 0;
}
FFTContext *av_mdct_init(int nbits, int inverse, double scale)
{
FFTContext *s = (FFTContext*)malloc(sizeof(*s));
if (s && ff_mdct_init(s, nbits, inverse, scale)) {
free(s);
s = 0;
}
return s;
}
static av_cold int atrac3p_decode_init(AVCodecContext *avctx)
{
ATRAC3PContext *ctx = avctx->priv_data;
int i, ch, ret;
if (!avctx->block_align) {
av_log(avctx, AV_LOG_ERROR, "block_align is not set\n");
return AVERROR(EINVAL);
}
ff_atrac3p_init_vlcs();
/* initialize IPQF */
ff_mdct_init(&ctx->ipqf_dct_ctx, 5, 1, 32.0 / 32768.0);
ff_atrac3p_init_imdct(avctx, &ctx->mdct_ctx);
ff_atrac_init_gain_compensation(&ctx->gainc_ctx, 6, 2);
ff_atrac3p_init_wave_synth();
if ((ret = set_channel_params(ctx, avctx)) < 0)
return ret;
ctx->my_channel_layout = avctx->channel_layout;
ctx->ch_units = av_mallocz_array(ctx->num_channel_blocks, sizeof(*ctx->ch_units));
ctx->fdsp = avpriv_float_dsp_alloc(avctx->flags & CODEC_FLAG_BITEXACT);
if (!ctx->ch_units || !ctx->fdsp) {
atrac3p_decode_close(avctx);
return AVERROR(ENOMEM);
}
for (i = 0; i < ctx->num_channel_blocks; i++) {
for (ch = 0; ch < 2; ch++) {
ctx->ch_units[i].channels[ch].ch_num = ch;
ctx->ch_units[i].channels[ch].wnd_shape = &ctx->ch_units[i].channels[ch].wnd_shape_hist[0][0];
ctx->ch_units[i].channels[ch].wnd_shape_prev = &ctx->ch_units[i].channels[ch].wnd_shape_hist[1][0];
ctx->ch_units[i].channels[ch].gain_data = &ctx->ch_units[i].channels[ch].gain_data_hist[0][0];
ctx->ch_units[i].channels[ch].gain_data_prev = &ctx->ch_units[i].channels[ch].gain_data_hist[1][0];
ctx->ch_units[i].channels[ch].tones_info = &ctx->ch_units[i].channels[ch].tones_info_hist[0][0];
ctx->ch_units[i].channels[ch].tones_info_prev = &ctx->ch_units[i].channels[ch].tones_info_hist[1][0];
}
ctx->ch_units[i].waves_info = &ctx->ch_units[i].wave_synth_hist[0];
ctx->ch_units[i].waves_info_prev = &ctx->ch_units[i].wave_synth_hist[1];
}
avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
return 0;
}
static int encode_init(AVCodecContext * avctx){
WMACodecContext *s = avctx->priv_data;
int i, flags1, flags2;
uint8_t *extradata;
s->avctx = avctx;
if(avctx->channels > MAX_CHANNELS) {
av_log(avctx, AV_LOG_ERROR, "too many channels: got %i, need %i or fewer",
avctx->channels, MAX_CHANNELS);
return AVERROR(EINVAL);
}
if(avctx->bit_rate < 24*1000) {
av_log(avctx, AV_LOG_ERROR, "bitrate too low: got %"PRId64", need 24000 or higher\n",
avctx->bit_rate);
return AVERROR(EINVAL);
}
/* extract flag infos */
flags1 = 0;
flags2 = 1;
if (avctx->codec->id == CODEC_ID_WMAV1) {
extradata= av_malloc(4);
avctx->extradata_size= 4;
AV_WL16(extradata, flags1);
AV_WL16(extradata+2, flags2);
} else if (avctx->codec->id == CODEC_ID_WMAV2) {
extradata= av_mallocz(10);
avctx->extradata_size= 10;
AV_WL32(extradata, flags1);
AV_WL16(extradata+4, flags2);
}else
assert(0);
avctx->extradata= extradata;
s->use_exp_vlc = flags2 & 0x0001;
s->use_bit_reservoir = flags2 & 0x0002;
s->use_variable_block_len = flags2 & 0x0004;
ff_wma_init(avctx, flags2);
/* init MDCT */
for(i = 0; i < s->nb_block_sizes; i++)
ff_mdct_init(&s->mdct_ctx[i], s->frame_len_bits - i + 1, 0, 1.0);
avctx->block_align=
s->block_align= avctx->bit_rate*s->frame_len / (avctx->sample_rate*8);
//av_log(NULL, AV_LOG_ERROR, "%d %"PRId64" %d %d\n", s->block_align, avctx->bit_rate, s->frame_len, avctx->sample_rate);
avctx->frame_size= s->frame_len;
return 0;
}
/**
* Init IMDCT and windowing tables
*/
static av_cold int init_mdct_win(TwinVQContext *tctx)
{
int i, j, ret;
const TwinVQModeTab *mtab = tctx->mtab;
int size_s = mtab->size / mtab->fmode[TWINVQ_FT_SHORT].sub;
int size_m = mtab->size / mtab->fmode[TWINVQ_FT_MEDIUM].sub;
int channels = tctx->avctx->channels;
float norm = channels == 1 ? 2.0 : 1.0;
for (i = 0; i < 3; i++) {
int bsize = tctx->mtab->size / tctx->mtab->fmode[i].sub;
if ((ret = ff_mdct_init(&tctx->mdct_ctx[i], av_log2(bsize) + 1, 1,
-sqrt(norm / bsize) / (1 << 15))))
return ret;
}
FF_ALLOC_OR_GOTO(tctx->avctx, tctx->tmp_buf,
mtab->size * sizeof(*tctx->tmp_buf), alloc_fail);
FF_ALLOC_OR_GOTO(tctx->avctx, tctx->spectrum,
2 * mtab->size * channels * sizeof(*tctx->spectrum),
alloc_fail);
FF_ALLOC_OR_GOTO(tctx->avctx, tctx->curr_frame,
2 * mtab->size * channels * sizeof(*tctx->curr_frame),
alloc_fail);
FF_ALLOC_OR_GOTO(tctx->avctx, tctx->prev_frame,
2 * mtab->size * channels * sizeof(*tctx->prev_frame),
alloc_fail);
for (i = 0; i < 3; i++) {
int m = 4 * mtab->size / mtab->fmode[i].sub;
double freq = 2 * M_PI / m;
FF_ALLOC_OR_GOTO(tctx->avctx, tctx->cos_tabs[i],
(m / 4) * sizeof(*tctx->cos_tabs[i]), alloc_fail);
for (j = 0; j <= m / 8; j++)
tctx->cos_tabs[i][j] = cos((2 * j + 1) * freq);
for (j = 1; j < m / 8; j++)
tctx->cos_tabs[i][m / 4 - j] = tctx->cos_tabs[i][j];
}
ff_init_ff_sine_windows(av_log2(size_m));
ff_init_ff_sine_windows(av_log2(size_s / 2));
ff_init_ff_sine_windows(av_log2(mtab->size));
return 0;
alloc_fail:
return AVERROR(ENOMEM);
}
static int encode_init(AVCodecContext * avctx){
WMACodecContext *s = avctx->priv_data;
int i, flags1, flags2;
uint8_t *extradata;
s->avctx = avctx;
if(avctx->channels > MAX_CHANNELS)
return -1;
if(avctx->bit_rate < 24*1000)
return -1;
/* extract flag infos */
flags1 = 0;
flags2 = 1;
if (avctx->codec->id == CODEC_ID_WMAV1) {
extradata= av_malloc(4);
avctx->extradata_size= 4;
AV_WL16(extradata, flags1);
AV_WL16(extradata+2, flags2);
} else if (avctx->codec->id == CODEC_ID_WMAV2) {
extradata= av_mallocz(10);
avctx->extradata_size= 10;
AV_WL32(extradata, flags1);
AV_WL16(extradata+4, flags2);
}else
assert(0);
avctx->extradata= extradata;
s->use_exp_vlc = flags2 & 0x0001;
s->use_bit_reservoir = flags2 & 0x0002;
s->use_variable_block_len = flags2 & 0x0004;
ff_wma_init(avctx, flags2);
/* init MDCT */
for(i = 0; i < s->nb_block_sizes; i++)
ff_mdct_init(&s->mdct_ctx[i], s->frame_len_bits - i + 1, 0);
avctx->block_align=
s->block_align= avctx->bit_rate*(int64_t)s->frame_len / (avctx->sample_rate*8);
//av_log(NULL, AV_LOG_ERROR, "%d %d %d %d\n", s->block_align, avctx->bit_rate, s->frame_len, avctx->sample_rate);
avctx->frame_size= s->frame_len;
return 0;
}
/**
* Initialize MDCT tables.
* @param nbits log2(MDCT size)
*/
av_cold int ff_ac3_float_mdct_init(AC3EncodeContext *s)
{
float *window;
int i, n, n2;
n = 1 << 9;
n2 = n >> 1;
window = av_malloc(n * sizeof(*window));
if (!window) {
av_log(s->avctx, AV_LOG_ERROR, "Cannot allocate memory.\n");
return AVERROR(ENOMEM);
}
ff_kbd_window_init(window, 5.0, n2);
for (i = 0; i < n2; i++)
window[n-1-i] = window[i];
s->mdct_window = window;
return ff_mdct_init(&s->mdct, 9, 0, -2.0 / n);
}
static av_cold int decode_init(AVCodecContext * avctx) {
NellyMoserDecodeContext *s = avctx->priv_data;
s->avctx = avctx;
av_lfg_init(&s->random_state, 0);
ff_mdct_init(&s->imdct_ctx, 8, 1, 1.0);
dsputil_init(&s->dsp, avctx);
ff_fmt_convert_init(&s->fmt_conv, avctx);
s->scale_bias = 1.0/(1*8);
/* Generate overlap window */
if (!ff_sine_128[127])
ff_init_ff_sine_windows(7);
avctx->sample_fmt = AV_SAMPLE_FMT_S16;
avctx->channel_layout = AV_CH_LAYOUT_MONO;
return 0;
}
/**
* Initialize MDCT tables.
* @param nbits log2(MDCT size)
*/
static av_cold int mdct_init(AVCodecContext *avctx, AC3MDCTContext *mdct,
int nbits)
{
float *window;
int i, n, n2;
n = 1 << nbits;
n2 = n >> 1;
window = av_malloc(n * sizeof(*window));
if (!window) {
av_log(avctx, AV_LOG_ERROR, "Cannot allocate memory.\n");
return AVERROR(ENOMEM);
}
ff_kbd_window_init(window, 5.0, n2);
for (i = 0; i < n2; i++)
window[n-1-i] = window[i];
mdct->window = window;
return ff_mdct_init(&mdct->fft, nbits, 0, -2.0 / n);
}
static int init_cook_mlt(COOKContext *q) {
int j;
int mlt_size = q->samples_per_channel;
if ((q->mlt_window = av_malloc(sizeof(float)*mlt_size)) == 0)
return -1;
/* Initialize the MLT window: simple sine window. */
ff_sine_window_init(q->mlt_window, mlt_size);
for(j=0 ; j<mlt_size ; j++)
q->mlt_window[j] *= sqrt(2.0 / q->samples_per_channel);
/* Initialize the MDCT. */
if (ff_mdct_init(&q->mdct_ctx, av_log2(mlt_size)+1, 1)) {
av_free(q->mlt_window);
return -1;
}
av_log(NULL,AV_LOG_DEBUG,"MDCT initialized, order = %d.\n",
av_log2(mlt_size)+1);
return 0;
}
static av_cold int init_cook_mlt(COOKContext *q) {
int j, ret;
int mlt_size = q->samples_per_channel;
if ((q->mlt_window = av_malloc(mlt_size * sizeof(*q->mlt_window))) == 0)
return AVERROR(ENOMEM);
/* Initialize the MLT window: simple sine window. */
ff_sine_window_init(q->mlt_window, mlt_size);
for(j=0 ; j<mlt_size ; j++)
q->mlt_window[j] *= sqrt(2.0 / q->samples_per_channel);
/* Initialize the MDCT. */
if ((ret = ff_mdct_init(&q->mdct_ctx, av_log2(mlt_size)+1, 1, 1.0/32768.0))) {
av_free(q->mlt_window);
return ret;
}
av_log(q->avctx,AV_LOG_DEBUG,"MDCT initialized, order = %d.\n",
av_log2(mlt_size)+1);
return 0;
}
static av_cold int encode_init(AVCodecContext *avctx)
{
WMACodecContext *s = avctx->priv_data;
int i, flags1, flags2, block_align;
uint8_t *extradata;
int ret;
s->avctx = avctx;
if (avctx->channels > MAX_CHANNELS) {
av_log(avctx, AV_LOG_ERROR,
"too many channels: got %i, need %i or fewer\n",
avctx->channels, MAX_CHANNELS);
return AVERROR(EINVAL);
}
if (avctx->sample_rate > 48000) {
av_log(avctx, AV_LOG_ERROR, "sample rate is too high: %d > 48kHz\n",
avctx->sample_rate);
return AVERROR(EINVAL);
}
if (avctx->bit_rate < 24 * 1000) {
av_log(avctx, AV_LOG_ERROR,
"bitrate too low: got %i, need 24000 or higher\n",
avctx->bit_rate);
return AVERROR(EINVAL);
}
/* extract flag infos */
flags1 = 0;
flags2 = 1;
if (avctx->codec->id == AV_CODEC_ID_WMAV1) {
extradata = av_malloc(4);
if (!extradata)
return AVERROR(ENOMEM);
avctx->extradata_size = 4;
AV_WL16(extradata, flags1);
AV_WL16(extradata + 2, flags2);
} else if (avctx->codec->id == AV_CODEC_ID_WMAV2) {
extradata = av_mallocz(10);
if (!extradata)
return AVERROR(ENOMEM);
avctx->extradata_size = 10;
AV_WL32(extradata, flags1);
AV_WL16(extradata + 4, flags2);
} else {
av_assert0(0);
}
avctx->extradata = extradata;
s->use_exp_vlc = flags2 & 0x0001;
s->use_bit_reservoir = flags2 & 0x0002;
s->use_variable_block_len = flags2 & 0x0004;
if (avctx->channels == 2)
s->ms_stereo = 1;
if ((ret = ff_wma_init(avctx, flags2)) < 0)
return ret;
/* init MDCT */
for (i = 0; i < s->nb_block_sizes; i++)
ff_mdct_init(&s->mdct_ctx[i], s->frame_len_bits - i + 1, 0, 1.0);
block_align = avctx->bit_rate * (int64_t) s->frame_len /
(avctx->sample_rate * 8);
block_align = FFMIN(block_align, MAX_CODED_SUPERFRAME_SIZE);
avctx->block_align = block_align;
avctx->frame_size = avctx->initial_padding = s->frame_len;
return 0;
}
static int encode_init(AVCodecContext * avctx){
WMACodecContext *s = avctx->priv_data;
int i, flags1, flags2;
uint8_t *extradata;
s->avctx = avctx;
if(avctx->channels > MAX_CHANNELS) {
av_log(avctx, AV_LOG_ERROR, "too many channels: got %i, need %i or fewer",
avctx->channels, MAX_CHANNELS);
return AVERROR(EINVAL);
}
if (avctx->sample_rate > 48000) {
av_log(avctx, AV_LOG_ERROR, "sample rate is too high: %d > 48kHz",
avctx->sample_rate);
return AVERROR(EINVAL);
}
if(avctx->bit_rate < 24*1000) {
av_log(avctx, AV_LOG_ERROR, "bitrate too low: got %i, need 24000 or higher\n",
avctx->bit_rate);
return AVERROR(EINVAL);
}
/* extract flag infos */
flags1 = 0;
flags2 = 1;
if (avctx->codec->id == AV_CODEC_ID_WMAV1) {
extradata= av_malloc(4);
avctx->extradata_size= 4;
AV_WL16(extradata, flags1);
AV_WL16(extradata+2, flags2);
} else if (avctx->codec->id == AV_CODEC_ID_WMAV2) {
extradata= av_mallocz(10);
avctx->extradata_size= 10;
AV_WL32(extradata, flags1);
AV_WL16(extradata+4, flags2);
}else
assert(0);
avctx->extradata= extradata;
s->use_exp_vlc = flags2 & 0x0001;
s->use_bit_reservoir = flags2 & 0x0002;
s->use_variable_block_len = flags2 & 0x0004;
if (avctx->channels == 2)
s->ms_stereo = 1;
ff_wma_init(avctx, flags2);
/* init MDCT */
for(i = 0; i < s->nb_block_sizes; i++)
ff_mdct_init(&s->mdct_ctx[i], s->frame_len_bits - i + 1, 0, 1.0);
s->block_align = avctx->bit_rate * (int64_t)s->frame_len /
(avctx->sample_rate * 8);
s->block_align = FFMIN(s->block_align, MAX_CODED_SUPERFRAME_SIZE);
avctx->block_align = s->block_align;
avctx->bit_rate = avctx->block_align * 8LL * avctx->sample_rate /
s->frame_len;
avctx->frame_size = avctx->delay = s->frame_len;
#if FF_API_OLD_ENCODE_AUDIO
avctx->coded_frame = &s->frame;
avcodec_get_frame_defaults(avctx->coded_frame);
#endif
return 0;
}
int main(int argc, char **argv)
{
FFTComplex *tab, *tab1, *tab_ref;
FFTSample *tab2;
int it, i, c;
int do_speed = 0;
int do_mdct = 0;
int do_inverse = 0;
FFTContext s1, *s = &s1;
MDCTContext m1, *m = &m1;
int fft_nbits, fft_size;
fft_nbits = 9;
for(;;) {
c = getopt(argc, argv, "hsimn:");
if (c == -1)
break;
switch(c) {
case 'h':
help();
break;
case 's':
do_speed = 1;
break;
case 'i':
do_inverse = 1;
break;
case 'm':
do_mdct = 1;
break;
case 'n':
fft_nbits = atoi(optarg);
break;
}
}
fft_size = 1 << fft_nbits;
tab = av_malloc(fft_size * sizeof(FFTComplex));
tab1 = av_malloc(fft_size * sizeof(FFTComplex));
tab_ref = av_malloc(fft_size * sizeof(FFTComplex));
tab2 = av_malloc(fft_size * sizeof(FFTSample));
if (do_mdct) {
if (do_inverse)
av_log(NULL, AV_LOG_INFO,"IMDCT");
else
av_log(NULL, AV_LOG_INFO,"MDCT");
ff_mdct_init(m, fft_nbits, do_inverse);
} else {
if (do_inverse)
av_log(NULL, AV_LOG_INFO,"IFFT");
else
av_log(NULL, AV_LOG_INFO,"FFT");
ff_fft_init(s, fft_nbits, do_inverse);
fft_ref_init(fft_nbits, do_inverse);
}
av_log(NULL, AV_LOG_INFO," %d test\n", fft_size);
/* generate random data */
for(i=0;i<fft_size;i++) {
tab1[i].re = frandom();
tab1[i].im = frandom();
}
/* checking result */
av_log(NULL, AV_LOG_INFO,"Checking...\n");
if (do_mdct) {
if (do_inverse) {
imdct_ref((float *)tab_ref, (float *)tab1, fft_nbits);
ff_imdct_calc(m, tab2, (float *)tab1);
check_diff((float *)tab_ref, tab2, fft_size);
} else {
mdct_ref((float *)tab_ref, (float *)tab1, fft_nbits);
ff_mdct_calc(m, tab2, (float *)tab1);
check_diff((float *)tab_ref, tab2, fft_size / 2);
}
} else {
memcpy(tab, tab1, fft_size * sizeof(FFTComplex));
ff_fft_permute(s, tab);
ff_fft_calc(s, tab);
fft_ref(tab_ref, tab1, fft_nbits);
check_diff((float *)tab_ref, (float *)tab, fft_size * 2);
}
/* do a speed test */
if (do_speed) {
int64_t time_start, duration;
int nb_its;
av_log(NULL, AV_LOG_INFO,"Speed test...\n");
/* we measure during about 1 seconds */
nb_its = 1;
for(;;) {
time_start = gettime();
for(it=0;it<nb_its;it++) {
if (do_mdct) {
if (do_inverse) {
ff_imdct_calc(m, (float *)tab, (float *)tab1);
} else {
ff_mdct_calc(m, (float *)tab, (float *)tab1);
}
} else {
memcpy(tab, tab1, fft_size * sizeof(FFTComplex));
ff_fft_calc(s, tab);
}
}
duration = gettime() - time_start;
if (duration >= 1000000)
break;
nb_its *= 2;
}
av_log(NULL, AV_LOG_INFO,"time: %0.1f us/transform [total time=%0.2f s its=%d]\n",
(double)duration / nb_its,
(double)duration / 1000000.0,
nb_its);
}
if (do_mdct) {
ff_mdct_end(m);
} else {
ff_fft_end(s);
}
return 0;
}
int main(int argc, char **argv)
{
FFTComplex *tab, *tab1, *tab_ref;
FFTSample *tab2;
int it, i, c;
int do_speed = 0;
int err = 1;
enum tf_transform transform = TRANSFORM_FFT;
int do_inverse = 0;
FFTContext s1, *s = &s1;
FFTContext m1, *m = &m1;
RDFTContext r1, *r = &r1;
DCTContext d1, *d = &d1;
int fft_nbits, fft_size, fft_size_2;
double scale = 1.0;
AVLFG prng;
av_lfg_init(&prng, 1);
fft_nbits = 9;
for(;;) {
c = getopt(argc, argv, "hsimrdn:f:");
if (c == -1)
break;
switch(c) {
case 'h':
help();
break;
case 's':
do_speed = 1;
break;
case 'i':
do_inverse = 1;
break;
case 'm':
transform = TRANSFORM_MDCT;
break;
case 'r':
transform = TRANSFORM_RDFT;
break;
case 'd':
transform = TRANSFORM_DCT;
break;
case 'n':
fft_nbits = atoi(optarg);
break;
case 'f':
scale = atof(optarg);
break;
}
}
fft_size = 1 << fft_nbits;
fft_size_2 = fft_size >> 1;
tab = av_malloc(fft_size * sizeof(FFTComplex));
tab1 = av_malloc(fft_size * sizeof(FFTComplex));
tab_ref = av_malloc(fft_size * sizeof(FFTComplex));
tab2 = av_malloc(fft_size * sizeof(FFTSample));
switch (transform) {
case TRANSFORM_MDCT:
av_log(NULL, AV_LOG_INFO,"Scale factor is set to %f\n", scale);
if (do_inverse)
av_log(NULL, AV_LOG_INFO,"IMDCT");
else
av_log(NULL, AV_LOG_INFO,"MDCT");
ff_mdct_init(m, fft_nbits, do_inverse, scale);
break;
case TRANSFORM_FFT:
if (do_inverse)
av_log(NULL, AV_LOG_INFO,"IFFT");
else
av_log(NULL, AV_LOG_INFO,"FFT");
ff_fft_init(s, fft_nbits, do_inverse);
fft_ref_init(fft_nbits, do_inverse);
break;
case TRANSFORM_RDFT:
if (do_inverse)
av_log(NULL, AV_LOG_INFO,"IDFT_C2R");
else
av_log(NULL, AV_LOG_INFO,"DFT_R2C");
ff_rdft_init(r, fft_nbits, do_inverse ? IDFT_C2R : DFT_R2C);
fft_ref_init(fft_nbits, do_inverse);
break;
case TRANSFORM_DCT:
if (do_inverse)
av_log(NULL, AV_LOG_INFO,"DCT_III");
else
av_log(NULL, AV_LOG_INFO,"DCT_II");
ff_dct_init(d, fft_nbits, do_inverse ? DCT_III : DCT_II);
break;
}
av_log(NULL, AV_LOG_INFO," %d test\n", fft_size);
/* generate random data */
for (i = 0; i < fft_size; i++) {
tab1[i].re = frandom(&prng);
tab1[i].im = frandom(&prng);
}
/* checking result */
av_log(NULL, AV_LOG_INFO,"Checking...\n");
switch (transform) {
case TRANSFORM_MDCT:
if (do_inverse) {
imdct_ref((float *)tab_ref, (float *)tab1, fft_nbits);
ff_imdct_calc(m, tab2, (float *)tab1);
err = check_diff((float *)tab_ref, tab2, fft_size, scale);
} else {
mdct_ref((float *)tab_ref, (float *)tab1, fft_nbits);
ff_mdct_calc(m, tab2, (float *)tab1);
err = check_diff((float *)tab_ref, tab2, fft_size / 2, scale);
}
break;
case TRANSFORM_FFT:
memcpy(tab, tab1, fft_size * sizeof(FFTComplex));
ff_fft_permute(s, tab);
ff_fft_calc(s, tab);
fft_ref(tab_ref, tab1, fft_nbits);
err = check_diff((float *)tab_ref, (float *)tab, fft_size * 2, 1.0);
break;
case TRANSFORM_RDFT:
if (do_inverse) {
tab1[ 0].im = 0;
tab1[fft_size_2].im = 0;
for (i = 1; i < fft_size_2; i++) {
tab1[fft_size_2+i].re = tab1[fft_size_2-i].re;
tab1[fft_size_2+i].im = -tab1[fft_size_2-i].im;
}
memcpy(tab2, tab1, fft_size * sizeof(FFTSample));
tab2[1] = tab1[fft_size_2].re;
ff_rdft_calc(r, tab2);
fft_ref(tab_ref, tab1, fft_nbits);
for (i = 0; i < fft_size; i++) {
tab[i].re = tab2[i];
tab[i].im = 0;
}
err = check_diff((float *)tab_ref, (float *)tab, fft_size * 2, 0.5);
} else {
for (i = 0; i < fft_size; i++) {
tab2[i] = tab1[i].re;
tab1[i].im = 0;
}
ff_rdft_calc(r, tab2);
fft_ref(tab_ref, tab1, fft_nbits);
tab_ref[0].im = tab_ref[fft_size_2].re;
err = check_diff((float *)tab_ref, (float *)tab2, fft_size, 1.0);
}
break;
case TRANSFORM_DCT:
memcpy(tab, tab1, fft_size * sizeof(FFTComplex));
ff_dct_calc(d, tab);
if (do_inverse) {
idct_ref(tab_ref, tab1, fft_nbits);
} else {
dct_ref(tab_ref, tab1, fft_nbits);
}
err = check_diff((float *)tab_ref, (float *)tab, fft_size, 1.0);
break;
}
/* do a speed test */
if (do_speed) {
int64_t time_start, duration;
int nb_its;
av_log(NULL, AV_LOG_INFO,"Speed test...\n");
/* we measure during about 1 seconds */
nb_its = 1;
for(;;) {
time_start = gettime();
for (it = 0; it < nb_its; it++) {
switch (transform) {
case TRANSFORM_MDCT:
if (do_inverse) {
ff_imdct_calc(m, (float *)tab, (float *)tab1);
} else {
ff_mdct_calc(m, (float *)tab, (float *)tab1);
}
break;
case TRANSFORM_FFT:
memcpy(tab, tab1, fft_size * sizeof(FFTComplex));
ff_fft_calc(s, tab);
break;
case TRANSFORM_RDFT:
memcpy(tab2, tab1, fft_size * sizeof(FFTSample));
ff_rdft_calc(r, tab2);
break;
case TRANSFORM_DCT:
memcpy(tab2, tab1, fft_size * sizeof(FFTSample));
ff_dct_calc(d, tab2);
break;
}
}
duration = gettime() - time_start;
if (duration >= 1000000)
break;
nb_its *= 2;
}
av_log(NULL, AV_LOG_INFO,"time: %0.1f us/transform [total time=%0.2f s its=%d]\n",
(double)duration / nb_its,
(double)duration / 1000000.0,
nb_its);
}
switch (transform) {
case TRANSFORM_MDCT:
ff_mdct_end(m);
break;
case TRANSFORM_FFT:
ff_fft_end(s);
break;
case TRANSFORM_RDFT:
ff_rdft_end(r);
break;
case TRANSFORM_DCT:
ff_dct_end(d);
break;
}
av_free(tab);
av_free(tab1);
av_free(tab2);
av_free(tab_ref);
av_free(exptab);
return err;
}