static void makegauss(struct ctx *k, unsigned int sizeb)
{
assert(sizeb >= 1 && sizeb <= MAX_SIZEB);
av_lfg_init(&k->avlfg, 123);
k->sizeb = sizeb;
k->size = 1 << k->sizeb;
k->size2 = k->size * k->size;
k->gauss_radius = k->size / 2 - 1;
k->gauss_middle = XY(k, k->gauss_radius, k->gauss_radius);
unsigned int gauss_size = k->gauss_radius * 2 + 1;
unsigned int gauss_size2 = gauss_size * gauss_size;
for (index_t c = 0; c < k->size2; c++)
k->gauss[c] = 0;
double sigma = -log(1.5 / UINT64_MAX * gauss_size2) / k->gauss_radius;
for (index_t gy = 0; gy <= k->gauss_radius; gy++) {
for (index_t gx = 0; gx <= gy; gx++) {
int cx = (int)gx - k->gauss_radius;
int cy = (int)gy - k->gauss_radius;
int sq = cx * cx + cy * cy;
double e = exp(-sqrt(sq) * sigma);
uint64_t v = e / gauss_size2 * UINT64_MAX;
k->gauss[XY(k, gx, gy)] =
k->gauss[XY(k, gy, gx)] =
k->gauss[XY(k, gx, gauss_size - 1 - gy)] =
k->gauss[XY(k, gy, gauss_size - 1 - gx)] =
k->gauss[XY(k, gauss_size - 1 - gx, gy)] =
k->gauss[XY(k, gauss_size - 1 - gy, gx)] =
k->gauss[XY(k, gauss_size - 1 - gx, gauss_size - 1 - gy)] =
k->gauss[XY(k, gauss_size - 1 - gy, gauss_size - 1 - gx)] = v;
}
}
uint64_t total = 0;
for (index_t c = 0; c < k->size2; c++) {
uint64_t oldtotal = total;
total += k->gauss[c];
assert(total >= oldtotal);
}
}
static av_cold int roq_encode_init(AVCodecContext *avctx)
{
RoqContext *enc = avctx->priv_data;
av_lfg_init(&enc->randctx, 1);
enc->framesSinceKeyframe = 0;
if ((avctx->width & 0xf) || (avctx->height & 0xf)) {
av_log(avctx, AV_LOG_ERROR, "Dimensions must be divisible by 16\n");
return -1;
}
if (((avctx->width)&(avctx->width-1))||((avctx->height)&(avctx->height-1)))
av_log(avctx, AV_LOG_ERROR, "Warning: dimensions not power of two\n");
enc->width = avctx->width;
enc->height = avctx->height;
enc->framesSinceKeyframe = 0;
enc->first_frame = 1;
enc->last_frame = av_frame_alloc();
enc->current_frame = av_frame_alloc();
if (!enc->last_frame || !enc->current_frame) {
roq_encode_end(avctx);
return AVERROR(ENOMEM);
}
enc->tmpData = av_malloc(sizeof(RoqTempdata));
enc->this_motion4 =
av_mallocz((enc->width*enc->height/16)*sizeof(motion_vect));
enc->last_motion4 =
av_malloc ((enc->width*enc->height/16)*sizeof(motion_vect));
enc->this_motion8 =
av_mallocz((enc->width*enc->height/64)*sizeof(motion_vect));
enc->last_motion8 =
av_malloc ((enc->width*enc->height/64)*sizeof(motion_vect));
return 0;
}
static av_cold int amrwb_decode_init(AVCodecContext *avctx)
{
AMRWBContext *ctx = avctx->priv_data;
int i;
avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
av_lfg_init(&ctx->prng, 1);
ctx->excitation = &ctx->excitation_buf[AMRWB_P_DELAY_MAX + LP_ORDER + 1];
ctx->first_frame = 1;
for (i = 0; i < LP_ORDER; i++)
ctx->isf_past_final[i] = isf_init[i] * (1.0f / (1 << 15));
for (i = 0; i < 4; i++)
ctx->prediction_error[i] = MIN_ENERGY;
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);
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;
}
int main(void){
RangeCoder c;
uint8_t b[9*SIZE];
uint8_t r[9*SIZE];
int i;
uint8_t state[10]= {0};
AVLFG prng;
av_lfg_init(&prng, 1);
ff_init_range_encoder(&c, b, SIZE);
ff_build_rac_states(&c, 0.05*(1LL<<32), 128+64+32+16);
memset(state, 128, sizeof(state));
for(i=0; i<SIZE; i++){
r[i] = av_lfg_get(&prng) % 7;
}
for(i=0; i<SIZE; i++){
START_TIMER
put_rac(&c, state, r[i]&1);
STOP_TIMER("put_rac")
}
ff_rac_terminate(&c);
ff_init_range_decoder(&c, b, SIZE);
memset(state, 128, sizeof(state));
for(i=0; i<SIZE; i++){
START_TIMER
if( (r[i]&1) != get_rac(&c, state) )
av_log(NULL, AV_LOG_DEBUG, "rac failure at %d\n", i);
STOP_TIMER("get_rac")
}
return 0;
}
static int config_input(AVFilterLink *inlink)
{
AVFilterContext *ctx = inlink->dst;
DrawTextContext *s = ctx->priv;
int ret;
ff_draw_init(&s->dc, inlink->format, FF_DRAW_PROCESS_ALPHA);
ff_draw_color(&s->dc, &s->fontcolor, s->fontcolor.rgba);
ff_draw_color(&s->dc, &s->shadowcolor, s->shadowcolor.rgba);
ff_draw_color(&s->dc, &s->bordercolor, s->bordercolor.rgba);
ff_draw_color(&s->dc, &s->boxcolor, s->boxcolor.rgba);
s->var_values[VAR_w] = s->var_values[VAR_W] = s->var_values[VAR_MAIN_W] = inlink->w;
s->var_values[VAR_h] = s->var_values[VAR_H] = s->var_values[VAR_MAIN_H] = inlink->h;
s->var_values[VAR_SAR] = inlink->sample_aspect_ratio.num ? av_q2d(inlink->sample_aspect_ratio) : 1;
s->var_values[VAR_DAR] = (double)inlink->w / inlink->h * s->var_values[VAR_SAR];
s->var_values[VAR_HSUB] = 1 << s->dc.hsub_max;
s->var_values[VAR_VSUB] = 1 << s->dc.vsub_max;
s->var_values[VAR_X] = NAN;
s->var_values[VAR_Y] = NAN;
s->var_values[VAR_T] = NAN;
av_lfg_init(&s->prng, av_get_random_seed());
av_expr_free(s->x_pexpr);
av_expr_free(s->y_pexpr);
s->x_pexpr = s->y_pexpr = NULL;
if ((ret = av_expr_parse(&s->x_pexpr, s->x_expr, var_names,
NULL, NULL, fun2_names, fun2, 0, ctx)) < 0 ||
(ret = av_expr_parse(&s->y_pexpr, s->y_expr, var_names,
NULL, NULL, fun2_names, fun2, 0, ctx)) < 0 ||
(ret = av_expr_parse(&s->a_pexpr, s->a_expr, var_names,
NULL, NULL, fun2_names, fun2, 0, ctx)) < 0)
return AVERROR(EINVAL);
return 0;
}
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;
return 0;
}
static av_cold int amrwb_decode_init(AVCodecContext *avctx)
{
AMRWBContext *ctx = avctx->priv_data;
int i;
if (avctx->channels > 1) {
av_log_missing_feature(avctx, "multi-channel AMR", 0);
return AVERROR_PATCHWELCOME;
}
avctx->channels = 1;
avctx->channel_layout = AV_CH_LAYOUT_MONO;
if (!avctx->sample_rate)
avctx->sample_rate = 16000;
avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
av_lfg_init(&ctx->prng, 1);
ctx->excitation = &ctx->excitation_buf[AMRWB_P_DELAY_MAX + LP_ORDER + 1];
ctx->first_frame = 1;
for (i = 0; i < LP_ORDER; i++)
ctx->isf_past_final[i] = isf_init[i] * (1.0f / (1 << 15));
for (i = 0; i < 4; i++)
ctx->prediction_error[i] = MIN_ENERGY;
avcodec_get_frame_defaults(&ctx->avframe);
avctx->coded_frame = &ctx->avframe;
ff_acelp_filter_init(&ctx->acelpf_ctx);
ff_acelp_vectors_init(&ctx->acelpv_ctx);
ff_celp_filter_init(&ctx->celpf_ctx);
ff_celp_math_init(&ctx->celpm_ctx);
return 0;
}
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);
ff_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;
}
int main(void)
{
RangeCoder c;
uint8_t b[9 * SIZE];
uint8_t r[9 * SIZE];
int i;
uint8_t state[10];
AVLFG prng;
av_lfg_init(&prng, 1);
ff_init_range_encoder(&c, b, SIZE);
ff_build_rac_states(&c, 0.05 * (1LL << 32), 128 + 64 + 32 + 16);
memset(state, 128, sizeof(state));
for (i = 0; i < SIZE; i++)
r[i] = av_lfg_get(&prng) % 7;
for (i = 0; i < SIZE; i++)
put_rac(&c, state, r[i] & 1);
ff_rac_terminate(&c);
ff_init_range_decoder(&c, b, SIZE);
memset(state, 128, sizeof(state));
for (i = 0; i < SIZE; i++)
if ((r[i] & 1) != get_rac(&c, state)) {
av_log(NULL, AV_LOG_ERROR, "rac failure at %d\n", i);
return 1;
}
return 0;
}
static float frandom(void)
{
AVLFG prn;
av_lfg_init(&prn, 1);
return (float)((av_lfg_get(&prn) & 0xffff) - 32768) / 32768.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;
}
DitherContext *ff_dither_alloc(AVAudioResampleContext *avr,
enum AVSampleFormat out_fmt,
enum AVSampleFormat in_fmt,
int channels, int sample_rate)
{
AVLFG seed_gen;
DitherContext *c;
int ch;
if (av_get_packed_sample_fmt(out_fmt) != AV_SAMPLE_FMT_S16 ||
av_get_bytes_per_sample(in_fmt) <= 2) {
av_log(avr, AV_LOG_ERROR, "dithering %s to %s is not supported\n",
av_get_sample_fmt_name(in_fmt), av_get_sample_fmt_name(out_fmt));
return NULL;
}
c = av_mallocz(sizeof(*c));
if (!c)
return NULL;
if (avr->dither_method == AV_RESAMPLE_DITHER_TRIANGULAR_NS &&
sample_rate != 48000 && sample_rate != 44100) {
av_log(avr, AV_LOG_WARNING, "sample rate must be 48000 or 44100 Hz "
"for triangular_ns dither. using triangular_hp instead.\n");
avr->dither_method = AV_RESAMPLE_DITHER_TRIANGULAR_HP;
}
c->method = avr->dither_method;
dither_init(&c->ddsp, c->method);
if (c->method == AV_RESAMPLE_DITHER_TRIANGULAR_NS) {
if (sample_rate == 48000) {
c->ns_coef_b = ns_48_coef_b;
c->ns_coef_a = ns_48_coef_a;
} else {
c->ns_coef_b = ns_44_coef_b;
c->ns_coef_a = ns_44_coef_a;
}
}
/* Either s16 or s16p output format is allowed, but s16p is used
internally, so we need to use a temp buffer and interleave if the output
format is s16 */
if (out_fmt != AV_SAMPLE_FMT_S16P) {
c->s16_data = ff_audio_data_alloc(channels, 1024, AV_SAMPLE_FMT_S16P,
"dither s16 buffer");
if (!c->s16_data)
goto fail;
c->ac_out = ff_audio_convert_alloc(avr, out_fmt, AV_SAMPLE_FMT_S16P,
channels, sample_rate);
if (!c->ac_out)
goto fail;
}
if (in_fmt != AV_SAMPLE_FMT_FLTP) {
c->flt_data = ff_audio_data_alloc(channels, 1024, AV_SAMPLE_FMT_FLTP,
"dither flt buffer");
if (!c->flt_data)
goto fail;
c->ac_in = ff_audio_convert_alloc(avr, AV_SAMPLE_FMT_FLTP, in_fmt,
channels, sample_rate);
if (!c->ac_in)
goto fail;
}
c->state = av_mallocz(channels * sizeof(*c->state));
if (!c->state)
goto fail;
c->channels = channels;
/* calculate thresholds for turning off dithering during periods of
silence to avoid replacing digital silence with quiet dither noise */
c->mute_dither_threshold = lrintf(sample_rate * MUTE_THRESHOLD_SEC);
c->mute_reset_threshold = c->mute_dither_threshold * 4;
/* initialize dither states */
av_lfg_init(&seed_gen, 0xC0FFEE);
for (ch = 0; ch < channels; ch++) {
DitherState *state = &c->state[ch];
state->mute = c->mute_reset_threshold + 1;
state->seed = av_lfg_get(&seed_gen);
generate_dither_noise(c, state, FFMAX(32768, sample_rate / 2));
}
return c;
fail:
ff_dither_free(&c);
return NULL;
}
int main(void){
PCA *pca;
int i, j, k;
#define LEN 8
double eigenvector[LEN*LEN];
double eigenvalue[LEN];
AVLFG prng;
av_lfg_init(&prng, 1);
pca= ff_pca_init(LEN);
for(i=0; i<9000000; i++){
double v[2*LEN+100];
double sum=0;
int pos = av_lfg_get(&prng) % LEN;
int v2 = av_lfg_get(&prng) % 101 - 50;
v[0] = av_lfg_get(&prng) % 101 - 50;
for(j=1; j<8; j++){
if(j<=pos) v[j]= v[0];
else v[j]= v2;
sum += v[j];
}
/* for(j=0; j<LEN; j++){
v[j] -= v[pos];
}*/
// sum += av_lfg_get(&prng) % 10;
/* for(j=0; j<LEN; j++){
v[j] -= sum/LEN;
}*/
// lbt1(v+100,v+100,LEN);
ff_pca_add(pca, v);
}
ff_pca(pca, eigenvector, eigenvalue);
for(i=0; i<LEN; i++){
pca->count= 1;
pca->mean[i]= 0;
// (0.5^|x|)^2 = 0.5^2|x| = 0.25^|x|
// pca.covariance[i + i*LEN]= pow(0.5, fabs
for(j=i; j<LEN; j++){
printf("%f ", pca->covariance[i + j*LEN]);
}
printf("\n");
}
#if 1
for(i=0; i<LEN; i++){
double v[LEN];
double error=0;
memset(v, 0, sizeof(v));
for(j=0; j<LEN; j++){
for(k=0; k<LEN; k++){
v[j] += pca->covariance[FFMIN(k,j) + FFMAX(k,j)*LEN] * eigenvector[i + k*LEN];
}
v[j] /= eigenvalue[i];
error += fabs(v[j] - eigenvector[i + j*LEN]);
}
printf("%f ", error);
}
printf("\n");
#endif
for(i=0; i<LEN; i++){
for(j=0; j<LEN; j++){
printf("%9.6f ", eigenvector[i + j*LEN]);
}
printf(" %9.1f %f\n", eigenvalue[i], eigenvalue[i]/eigenvalue[0]);
}
return 0;
}
int main(void) {
CABACContext c;
uint8_t b[9*SIZE];
uint8_t r[9*SIZE];
int i;
uint8_t state[10]= {0};
AVLFG prng;
av_lfg_init(&prng, 1);
ff_init_cabac_encoder(&c, b, SIZE);
ff_init_cabac_states(&c);
for(i=0; i<SIZE; i++) {
r[i] = av_lfg_get(&prng) % 7;
}
for(i=0; i<SIZE; i++) {
START_TIMER
put_cabac_bypass(&c, r[i]&1);
STOP_TIMER("put_cabac_bypass")
}
for(i=0; i<SIZE; i++) {
START_TIMER
put_cabac(&c, state, r[i]&1);
STOP_TIMER("put_cabac")
}
for(i=0; i<SIZE; i++) {
START_TIMER
put_cabac_u(&c, state, r[i], 6, 3, i&1);
STOP_TIMER("put_cabac_u")
}
for(i=0; i<SIZE; i++) {
START_TIMER
put_cabac_ueg(&c, state, r[i], 3, 0, 1, 2);
STOP_TIMER("put_cabac_ueg")
}
put_cabac_terminate(&c, 1);
ff_init_cabac_decoder(&c, b, SIZE);
memset(state, 0, sizeof(state));
for(i=0; i<SIZE; i++) {
START_TIMER
if( (r[i]&1) != get_cabac_bypass(&c) )
av_log(NULL, AV_LOG_ERROR, "CABAC bypass failure at %d\n", i);
STOP_TIMER("get_cabac_bypass")
}
for(i=0; i<SIZE; i++) {
START_TIMER
if( (r[i]&1) != get_cabac(&c, state) )
av_log(NULL, AV_LOG_ERROR, "CABAC failure at %d\n", i);
STOP_TIMER("get_cabac")
}
#if 0
for(i=0; i<SIZE; i++) {
START_TIMER
if( r[i] != get_cabac_u(&c, state, (i&1) ? 6 : 7, 3, i&1) )
av_log(NULL, AV_LOG_ERROR, "CABAC unary (truncated) binarization failure at %d\n", i);
STOP_TIMER("get_cabac_u")
}
for(i=0; i<SIZE; i++) {
START_TIMER
if( r[i] != get_cabac_ueg(&c, state, 3, 0, 1, 2))
av_log(NULL, AV_LOG_ERROR, "CABAC unary (truncated) binarization failure at %d\n", i);
STOP_TIMER("get_cabac_ueg")
}
#endif
if(!get_cabac_terminate(&c))
av_log(NULL, AV_LOG_ERROR, "where's the Terminator?\n");
return 0;
}
/**
* Cook initialization
*
* @param avctx pointer to the AVCodecContext
*/
static av_cold int cook_decode_init(AVCodecContext *avctx)
{
COOKContext *q = avctx->priv_data;
const uint8_t *edata_ptr = avctx->extradata;
const uint8_t *edata_ptr_end = edata_ptr + avctx->extradata_size;
int extradata_size = avctx->extradata_size;
int s = 0;
unsigned int channel_mask = 0;
int samples_per_frame = 0;
int ret;
q->avctx = avctx;
/* Take care of the codec specific extradata. */
if (extradata_size <= 0) {
av_log(avctx, AV_LOG_ERROR, "Necessary extradata missing!\n");
return AVERROR_INVALIDDATA;
}
av_log(avctx, AV_LOG_DEBUG, "codecdata_length=%d\n", avctx->extradata_size);
/* Take data from the AVCodecContext (RM container). */
if (!avctx->channels) {
av_log(avctx, AV_LOG_ERROR, "Invalid number of channels\n");
return AVERROR_INVALIDDATA;
}
/* Initialize RNG. */
av_lfg_init(&q->random_state, 0);
ff_dsputil_init(&q->dsp, avctx);
while (edata_ptr < edata_ptr_end) {
/* 8 for mono, 16 for stereo, ? for multichannel
Swap to right endianness so we don't need to care later on. */
if (extradata_size >= 8) {
q->subpacket[s].cookversion = bytestream_get_be32(&edata_ptr);
samples_per_frame = bytestream_get_be16(&edata_ptr);
q->subpacket[s].subbands = bytestream_get_be16(&edata_ptr);
extradata_size -= 8;
}
if (extradata_size >= 8) {
bytestream_get_be32(&edata_ptr); // Unknown unused
q->subpacket[s].js_subband_start = bytestream_get_be16(&edata_ptr);
q->subpacket[s].js_vlc_bits = bytestream_get_be16(&edata_ptr);
extradata_size -= 8;
}
/* Initialize extradata related variables. */
q->subpacket[s].samples_per_channel = samples_per_frame / avctx->channels;
q->subpacket[s].bits_per_subpacket = avctx->block_align * 8;
/* Initialize default data states. */
q->subpacket[s].log2_numvector_size = 5;
q->subpacket[s].total_subbands = q->subpacket[s].subbands;
q->subpacket[s].num_channels = 1;
/* Initialize version-dependent variables */
av_log(avctx, AV_LOG_DEBUG, "subpacket[%i].cookversion=%x\n", s,
q->subpacket[s].cookversion);
q->subpacket[s].joint_stereo = 0;
switch (q->subpacket[s].cookversion) {
case MONO:
if (avctx->channels != 1) {
av_log_ask_for_sample(avctx, "Container channels != 1.\n");
return AVERROR_PATCHWELCOME;
}
av_log(avctx, AV_LOG_DEBUG, "MONO\n");
break;
case STEREO:
if (avctx->channels != 1) {
q->subpacket[s].bits_per_subpdiv = 1;
q->subpacket[s].num_channels = 2;
}
av_log(avctx, AV_LOG_DEBUG, "STEREO\n");
break;
case JOINT_STEREO:
if (avctx->channels != 2) {
av_log_ask_for_sample(avctx, "Container channels != 2.\n");
return AVERROR_PATCHWELCOME;
}
av_log(avctx, AV_LOG_DEBUG, "JOINT_STEREO\n");
if (avctx->extradata_size >= 16) {
q->subpacket[s].total_subbands = q->subpacket[s].subbands +
q->subpacket[s].js_subband_start;
q->subpacket[s].joint_stereo = 1;
q->subpacket[s].num_channels = 2;
}
if (q->subpacket[s].samples_per_channel > 256) {
q->subpacket[s].log2_numvector_size = 6;
}
if (q->subpacket[s].samples_per_channel > 512) {
q->subpacket[s].log2_numvector_size = 7;
}
break;
case MC_COOK:
av_log(avctx, AV_LOG_DEBUG, "MULTI_CHANNEL\n");
if (extradata_size >= 4)
channel_mask |= q->subpacket[s].channel_mask = bytestream_get_be32(&edata_ptr);
if (av_get_channel_layout_nb_channels(q->subpacket[s].channel_mask) > 1) {
q->subpacket[s].total_subbands = q->subpacket[s].subbands +
q->subpacket[s].js_subband_start;
q->subpacket[s].joint_stereo = 1;
q->subpacket[s].num_channels = 2;
q->subpacket[s].samples_per_channel = samples_per_frame >> 1;
if (q->subpacket[s].samples_per_channel > 256) {
q->subpacket[s].log2_numvector_size = 6;
}
if (q->subpacket[s].samples_per_channel > 512) {
q->subpacket[s].log2_numvector_size = 7;
}
} else
q->subpacket[s].samples_per_channel = samples_per_frame;
break;
default:
av_log_ask_for_sample(avctx, "Unknown Cook version.\n");
return AVERROR_PATCHWELCOME;
}
int main(int argc, char **argv)
{
FFTComplex *tab, *tab1, *tab_ref;
FFTSample *tab2;
enum tf_transform transform = TRANSFORM_FFT;
FFTContext m, s;
#if FFT_FLOAT
RDFTContext r;
DCTContext d;
#if CONFIG_LIBFFTW3
FFTWContext fftw;
FFTWComplex *tab_fftw, *tab_fftw_copy;
#endif /* CONFIG_LIBFFTW3 */
#endif /* FFT_FLOAT */
int it, i, err = 1;
int do_speed = 0, do_inverse = 0;
int fft_nbits = 9, fft_size;
double scale = 1.0;
AVLFG prng;
av_lfg_init(&prng, 1);
for (;;) {
int c = getopt(argc, argv, "hsitmrdn:f:c:");
if (c == -1)
break;
switch (c) {
case 'h':
help();
return 1;
case 's':
do_speed = 1;
break;
case 'i':
do_inverse = 1;
break;
#if CONFIG_LIBFFTW3
case 't':
transform = TRANSFORM_FFTW;
break;
#endif /* CONFIG_LIBFFTW3 */
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;
case 'c':
{
unsigned cpuflags = av_get_cpu_flags();
if (av_parse_cpu_caps(&cpuflags, optarg) < 0)
return 1;
av_force_cpu_flags(cpuflags);
break;
}
}
}
fft_size = 1 << fft_nbits;
tab = av_malloc_array(fft_size, sizeof(FFTComplex));
tab1 = av_malloc_array(fft_size, sizeof(FFTComplex));
tab_ref = av_malloc_array(fft_size, sizeof(FFTComplex));
tab2 = av_malloc_array(fft_size, sizeof(FFTSample));
#if CONFIG_LIBFFTW3 && FFT_FLOAT
tab_fftw = av_malloc_array(fft_size, sizeof(*tab_fftw));
tab_fftw_copy = av_malloc_array(fft_size, sizeof(*tab_fftw_copy));
if (!(tab_fftw && tab_fftw_copy))
goto cleanup_fftw;
#endif /* CONFIG_LIBFFTW3 */
if (!(tab && tab1 && tab_ref && tab2))
goto cleanup;
switch (transform) {
#if CONFIG_MDCT
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;
#endif /* CONFIG_MDCT */
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);
if ((err = fft_ref_init(fft_nbits, do_inverse)) < 0)
goto cleanup;
break;
#if CONFIG_LIBFFTW3 && FFT_FLOAT
case TRANSFORM_FFTW:
if (do_inverse)
av_log(NULL, AV_LOG_INFO, "IFFTW");
else
av_log(NULL, AV_LOG_INFO, "FFTW");
ff_fftw_init(&fftw, fft_size, do_inverse);
if ((err = fft_ref_init(fft_nbits, do_inverse)) < 0)
goto cleanup;
break;
#endif /* CONFIG_LIBFFTW3 */
#if FFT_FLOAT
# if CONFIG_RDFT
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);
if ((err = fft_ref_init(fft_nbits, do_inverse)) < 0)
goto cleanup;
break;
# endif /* CONFIG_RDFT */
# if CONFIG_DCT
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;
# endif /* CONFIG_DCT */
#endif /* FFT_FLOAT */
default:
av_log(NULL, AV_LOG_ERROR, "Requested transform not supported\n");
goto cleanup;
}
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);
#if CONFIG_LIBFFTW3 && FFT_FLOAT
tab_fftw[i][0] = tab1[i].re;
tab_fftw[i][1] = tab1[i].im;
#endif /* CONFIG_LIBFFTW3 */
}
#if CONFIG_LIBFFTW3 && FFT_FLOAT
memcpy(tab_fftw_copy, tab_fftw, fft_size * sizeof(*tab_fftw));
#endif
/* checking result */
av_log(NULL, AV_LOG_INFO, "Checking...\n");
switch (transform) {
#if CONFIG_MDCT
case TRANSFORM_MDCT:
if (do_inverse) {
imdct_ref(&tab_ref->re, &tab1->re, fft_nbits);
m.imdct_calc(&m, tab2, &tab1->re);
err = check_diff(&tab_ref->re, tab2, fft_size, scale);
} else {
mdct_ref(&tab_ref->re, &tab1->re, fft_nbits);
m.mdct_calc(&m, tab2, &tab1->re);
err = check_diff(&tab_ref->re, tab2, fft_size / 2, scale);
}
break;
#endif /* CONFIG_MDCT */
case TRANSFORM_FFT:
memcpy(tab, tab1, fft_size * sizeof(FFTComplex));
s.fft_permute(&s, tab);
s.fft_calc(&s, tab);
fft_ref(tab_ref, tab1, fft_nbits);
err = check_diff(&tab_ref->re, &tab->re, fft_size * 2, 1.0);
break;
#if CONFIG_LIBFFTW3 && FFT_FLOAT
case TRANSFORM_FFTW:
fftw.fft_calc(&fftw, tab_fftw);
fft_ref(tab_ref, tab1, fft_nbits);
for (i = 0; i < fft_size; i++) {
tab[i].re = tab_fftw[i][0];
tab[i].im = tab_fftw[i][1];
}
err = check_diff(&tab_ref->re, &tab->re, fft_size * 2, 1.0);
break;
#endif /* CONFIG_LIBFFTW3 */
#if FFT_FLOAT
#if CONFIG_RDFT
case TRANSFORM_RDFT:
{
int fft_size_2 = fft_size >> 1;
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;
r.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(&tab_ref->re, &tab->re, fft_size * 2, 0.5);
} else {
for (i = 0; i < fft_size; i++) {
tab2[i] = tab1[i].re;
tab1[i].im = 0;
}
r.rdft_calc(&r, tab2);
fft_ref(tab_ref, tab1, fft_nbits);
tab_ref[0].im = tab_ref[fft_size_2].re;
err = check_diff(&tab_ref->re, tab2, fft_size, 1.0);
}
break;
}
#endif /* CONFIG_RDFT */
#if CONFIG_DCT
case TRANSFORM_DCT:
memcpy(tab, tab1, fft_size * sizeof(FFTComplex));
d.dct_calc(&d, &tab->re);
if (do_inverse)
idct_ref(&tab_ref->re, &tab1->re, fft_nbits);
else
dct_ref(&tab_ref->re, &tab1->re, fft_nbits);
err = check_diff(&tab_ref->re, &tab->re, fft_size, 1.0);
break;
#endif /* CONFIG_DCT */
#endif /* FFT_FLOAT */
}
/* 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 = av_gettime_relative();
for (it = 0; it < nb_its; it++) {
switch (transform) {
case TRANSFORM_MDCT:
if (do_inverse)
m.imdct_calc(&m, &tab->re, &tab1->re);
else
m.mdct_calc(&m, &tab->re, &tab1->re);
break;
case TRANSFORM_FFT:
memcpy(tab, tab1, fft_size * sizeof(FFTComplex));
s.fft_permute(&s, tab);
s.fft_calc(&s, tab);
break;
#if CONFIG_LIBFFTW3 && FFT_FLOAT
case TRANSFORM_FFTW:
memcpy(tab_fftw, tab_fftw_copy, fft_size * sizeof(*tab_fftw));
fftw.fft_calc(&fftw, tab_fftw);
break;
#endif /* CONFIG_LIBFFTW3 */
#if FFT_FLOAT
case TRANSFORM_RDFT:
memcpy(tab2, tab1, fft_size * sizeof(FFTSample));
r.rdft_calc(&r, tab2);
break;
case TRANSFORM_DCT:
memcpy(tab2, tab1, fft_size * sizeof(FFTSample));
d.dct_calc(&d, tab2);
break;
#endif /* FFT_FLOAT */
}
}
duration = av_gettime_relative() - time_start;
if (duration >= 1000000)
break;
nb_its *= 2;
}
av_log(NULL, AV_LOG_INFO,
"time: %0.2f us/transform [total time=%0.2f s its=%d]\n",
(double) duration / nb_its,
(double) duration / 1000000.0,
nb_its);
}
switch (transform) {
#if CONFIG_MDCT
case TRANSFORM_MDCT:
ff_mdct_end(&m);
break;
#endif /* CONFIG_MDCT */
case TRANSFORM_FFT:
ff_fft_end(&s);
break;
#if CONFIG_LIBFFTW3 && FFT_FLOAT
case TRANSFORM_FFTW:
ff_fftw_deinit(&fftw);
break;
#endif /* CONFIG_LIBFFTW3 */
#if FFT_FLOAT
# if CONFIG_RDFT
case TRANSFORM_RDFT:
ff_rdft_end(&r);
break;
# endif /* CONFIG_RDFT */
# if CONFIG_DCT
case TRANSFORM_DCT:
ff_dct_end(&d);
break;
# endif /* CONFIG_DCT */
#endif /* FFT_FLOAT */
}
#if CONFIG_LIBFFTW3 && FFT_FLOAT
cleanup_fftw:
av_freep(&tab_fftw);
#endif /* CONFIG_LIBFFTW3 */
cleanup:
av_freep(&tab);
av_freep(&tab1);
av_freep(&tab2);
av_freep(&tab_ref);
av_freep(&exptab);
if (err)
printf("Error: %d.\n", err);
return !!err;
}
static av_cold int mpc8_decode_init(AVCodecContext * avctx)
{
int i;
MPCContext *c = avctx->priv_data;
GetBitContext gb;
static int vlc_initialized = 0;
static VLC_TYPE band_table[542][2];
static VLC_TYPE q1_table[520][2];
static VLC_TYPE q9up_table[524][2];
static VLC_TYPE scfi0_table[1 << MPC8_SCFI0_BITS][2];
static VLC_TYPE scfi1_table[1 << MPC8_SCFI1_BITS][2];
static VLC_TYPE dscf0_table[560][2];
static VLC_TYPE dscf1_table[598][2];
static VLC_TYPE q3_0_table[512][2];
static VLC_TYPE q3_1_table[516][2];
static VLC_TYPE codes_table[5708][2];
if(avctx->extradata_size < 2){
av_log(avctx, AV_LOG_ERROR, "Too small extradata size (%i)!\n", avctx->extradata_size);
return -1;
}
memset(c->oldDSCF, 0, sizeof(c->oldDSCF));
av_lfg_init(&c->rnd, 0xDEADBEEF);
dsputil_init(&c->dsp, avctx);
ff_mpc_init();
init_get_bits(&gb, avctx->extradata, 16);
skip_bits(&gb, 3);//sample rate
c->maxbands = get_bits(&gb, 5) + 1;
skip_bits(&gb, 4);//channels
c->MSS = get_bits1(&gb);
c->frames = 1 << (get_bits(&gb, 3) * 2);
avctx->sample_fmt = SAMPLE_FMT_S16;
avctx->channel_layout = (avctx->channels==2) ? CH_LAYOUT_STEREO : CH_LAYOUT_MONO;
if(vlc_initialized) return 0;
av_log(avctx, AV_LOG_DEBUG, "Initing VLC\n");
band_vlc.table = band_table;
band_vlc.table_allocated = 542;
init_vlc(&band_vlc, MPC8_BANDS_BITS, MPC8_BANDS_SIZE,
mpc8_bands_bits, 1, 1,
mpc8_bands_codes, 1, 1, INIT_VLC_USE_NEW_STATIC);
q1_vlc.table = q1_table;
q1_vlc.table_allocated = 520;
init_vlc(&q1_vlc, MPC8_Q1_BITS, MPC8_Q1_SIZE,
mpc8_q1_bits, 1, 1,
mpc8_q1_codes, 1, 1, INIT_VLC_USE_NEW_STATIC);
q9up_vlc.table = q9up_table;
q9up_vlc.table_allocated = 524;
init_vlc(&q9up_vlc, MPC8_Q9UP_BITS, MPC8_Q9UP_SIZE,
mpc8_q9up_bits, 1, 1,
mpc8_q9up_codes, 1, 1, INIT_VLC_USE_NEW_STATIC);
scfi_vlc[0].table = scfi0_table;
scfi_vlc[0].table_allocated = 1 << MPC8_SCFI0_BITS;
init_vlc(&scfi_vlc[0], MPC8_SCFI0_BITS, MPC8_SCFI0_SIZE,
mpc8_scfi0_bits, 1, 1,
mpc8_scfi0_codes, 1, 1, INIT_VLC_USE_NEW_STATIC);
scfi_vlc[1].table = scfi1_table;
scfi_vlc[1].table_allocated = 1 << MPC8_SCFI1_BITS;
init_vlc(&scfi_vlc[1], MPC8_SCFI1_BITS, MPC8_SCFI1_SIZE,
mpc8_scfi1_bits, 1, 1,
mpc8_scfi1_codes, 1, 1, INIT_VLC_USE_NEW_STATIC);
dscf_vlc[0].table = dscf0_table;
dscf_vlc[0].table_allocated = 560;
init_vlc(&dscf_vlc[0], MPC8_DSCF0_BITS, MPC8_DSCF0_SIZE,
mpc8_dscf0_bits, 1, 1,
mpc8_dscf0_codes, 1, 1, INIT_VLC_USE_NEW_STATIC);
dscf_vlc[1].table = dscf1_table;
dscf_vlc[1].table_allocated = 598;
init_vlc(&dscf_vlc[1], MPC8_DSCF1_BITS, MPC8_DSCF1_SIZE,
mpc8_dscf1_bits, 1, 1,
mpc8_dscf1_codes, 1, 1, INIT_VLC_USE_NEW_STATIC);
q3_vlc[0].table = q3_0_table;
q3_vlc[0].table_allocated = 512;
init_vlc_sparse(&q3_vlc[0], MPC8_Q3_BITS, MPC8_Q3_SIZE,
mpc8_q3_bits, 1, 1,
mpc8_q3_codes, 1, 1,
mpc8_q3_syms, 1, 1, INIT_VLC_USE_NEW_STATIC);
q3_vlc[1].table = q3_1_table;
q3_vlc[1].table_allocated = 516;
init_vlc_sparse(&q3_vlc[1], MPC8_Q4_BITS, MPC8_Q4_SIZE,
mpc8_q4_bits, 1, 1,
mpc8_q4_codes, 1, 1,
mpc8_q4_syms, 1, 1, INIT_VLC_USE_NEW_STATIC);
for(i = 0; i < 2; i++){
res_vlc[i].table = &codes_table[vlc_offsets[0+i]];
res_vlc[i].table_allocated = vlc_offsets[1+i] - vlc_offsets[0+i];
init_vlc(&res_vlc[i], MPC8_RES_BITS, MPC8_RES_SIZE,
&mpc8_res_bits[i], 1, 1,
&mpc8_res_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
q2_vlc[i].table = &codes_table[vlc_offsets[2+i]];
q2_vlc[i].table_allocated = vlc_offsets[3+i] - vlc_offsets[2+i];
init_vlc(&q2_vlc[i], MPC8_Q2_BITS, MPC8_Q2_SIZE,
&mpc8_q2_bits[i], 1, 1,
&mpc8_q2_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
quant_vlc[0][i].table = &codes_table[vlc_offsets[4+i]];
quant_vlc[0][i].table_allocated = vlc_offsets[5+i] - vlc_offsets[4+i];
init_vlc(&quant_vlc[0][i], MPC8_Q5_BITS, MPC8_Q5_SIZE,
&mpc8_q5_bits[i], 1, 1,
&mpc8_q5_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
quant_vlc[1][i].table = &codes_table[vlc_offsets[6+i]];
quant_vlc[1][i].table_allocated = vlc_offsets[7+i] - vlc_offsets[6+i];
init_vlc(&quant_vlc[1][i], MPC8_Q6_BITS, MPC8_Q6_SIZE,
&mpc8_q6_bits[i], 1, 1,
&mpc8_q6_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
quant_vlc[2][i].table = &codes_table[vlc_offsets[8+i]];
quant_vlc[2][i].table_allocated = vlc_offsets[9+i] - vlc_offsets[8+i];
init_vlc(&quant_vlc[2][i], MPC8_Q7_BITS, MPC8_Q7_SIZE,
&mpc8_q7_bits[i], 1, 1,
&mpc8_q7_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
quant_vlc[3][i].table = &codes_table[vlc_offsets[10+i]];
quant_vlc[3][i].table_allocated = vlc_offsets[11+i] - vlc_offsets[10+i];
init_vlc(&quant_vlc[3][i], MPC8_Q8_BITS, MPC8_Q8_SIZE,
&mpc8_q8_bits[i], 1, 1,
&mpc8_q8_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
}
vlc_initialized = 1;
return 0;
}
int main(int argc, char **argv)
{
unsigned int p, i, type, size, retry;
AVProbeData pd = { 0 };
AVLFG state;
PutBitContext pb;
int retry_count= 4097;
int max_size = 65537;
int j;
for (j = i = 1; i<argc; i++) {
if (!strcmp(argv[i], "-f") && i+1<argc && !single_format) {
single_format = argv[++i];
} else if (read_int(argv[i])>0 && j == 1) {
retry_count = read_int(argv[i]);
j++;
} else if (read_int(argv[i])>0 && j == 2) {
max_size = read_int(argv[i]);
j++;
} else {
fprintf(stderr, "probetest [-f <input format>] [<retry_count> [<max_size>]]\n");
return 1;
}
}
if (max_size > 1000000000U/8) {
fprintf(stderr, "max_size out of bounds\n");
return 1;
}
if (retry_count > 1000000000U) {
fprintf(stderr, "retry_count out of bounds\n");
return 1;
}
av_lfg_init(&state, 0xdeadbeef);
pd.buf = NULL;
for (size = 1; size < max_size; size *= 2) {
pd.buf_size = size;
pd.buf = av_realloc(pd.buf, size + AVPROBE_PADDING_SIZE);
pd.filename = "";
if (!pd.buf) {
fprintf(stderr, "out of memory\n");
return 1;
}
memset(pd.buf, 0, size + AVPROBE_PADDING_SIZE);
fprintf(stderr, "testing size=%d\n", size);
for (retry = 0; retry < retry_count; retry += FFMAX(size, 32)) {
for (type = 0; type < 4; type++) {
for (p = 0; p < 4096; p++) {
unsigned hist = 0;
init_put_bits(&pb, pd.buf, size);
switch (type) {
case 0:
for (i = 0; i < size * 8; i++)
put_bits(&pb, 1, (av_lfg_get(&state) & 0xFFFFFFFF) > p << 20);
break;
case 1:
for (i = 0; i < size * 8; i++) {
unsigned int p2 = hist ? p & 0x3F : (p >> 6);
unsigned int v = (av_lfg_get(&state) & 0xFFFFFFFF) > p2 << 26;
put_bits(&pb, 1, v);
hist = v;
}
break;
case 2:
for (i = 0; i < size * 8; i++) {
unsigned int p2 = (p >> (hist * 3)) & 7;
unsigned int v = (av_lfg_get(&state) & 0xFFFFFFFF) > p2 << 29;
put_bits(&pb, 1, v);
hist = (2 * hist + v) & 3;
}
break;
case 3:
for (i = 0; i < size; i++) {
int c = 0;
while (p & 63) {
c = (av_lfg_get(&state) & 0xFFFFFFFF) >> 24;
if (c >= 'a' && c <= 'z' && (p & 1))
break;
else if (c >= 'A' && c <= 'Z' && (p & 2))
break;
else if (c >= '0' && c <= '9' && (p & 4))
break;
else if (c == ' ' && (p & 8))
break;
else if (c == 0 && (p & 16))
break;
else if (c == 1 && (p & 32))
break;
}
pd.buf[i] = c;
}
}
flush_put_bits(&pb);
probe(&pd, type, p, size);
}
}
}
}
if(AV_READ_TIME())
print_times();
return failures;
}
int main(int argc, char **argv)
{
int i, j;
AVAES b;
static const uint8_t rkey[2][16] = {
{ 0 },
{ 0x10, 0xa5, 0x88, 0x69, 0xd7, 0x4b, 0xe5, 0xa3,
0x74, 0xcf, 0x86, 0x7c, 0xfb, 0x47, 0x38, 0x59 }
};
static const uint8_t rpt[2][16] = {
{ 0x6a, 0x84, 0x86, 0x7c, 0xd7, 0x7e, 0x12, 0xad,
0x07, 0xea, 0x1b, 0xe8, 0x95, 0xc5, 0x3f, 0xa3 },
{ 0 }
};
static const uint8_t rct[2][16] = {
{ 0x73, 0x22, 0x81, 0xc0, 0xa0, 0xaa, 0xb8, 0xf7,
0xa5, 0x4a, 0x0c, 0x67, 0xa0, 0xc4, 0x5e, 0xcf },
{ 0x6d, 0x25, 0x1e, 0x69, 0x44, 0xb0, 0x51, 0xe0,
0x4e, 0xaa, 0x6f, 0xb4, 0xdb, 0xf7, 0x84, 0x65 }
};
uint8_t pt[16], temp[16];
int err = 0;
av_log_set_level(AV_LOG_DEBUG);
for (i = 0; i < 2; i++) {
av_aes_init(&b, rkey[i], 128, 1);
av_aes_crypt(&b, temp, rct[i], 1, NULL, 1);
for (j = 0; j < 16; j++) {
if (rpt[i][j] != temp[j]) {
av_log(NULL, AV_LOG_ERROR, "%d %02X %02X\n",
j, rpt[i][j], temp[j]);
err = 1;
}
}
}
if (argc > 1 && !strcmp(argv[1], "-t")) {
AVAES ae, ad;
AVLFG prng;
av_aes_init(&ae, "PI=3.141592654..", 128, 0);
av_aes_init(&ad, "PI=3.141592654..", 128, 1);
av_lfg_init(&prng, 1);
for (i = 0; i < 10000; i++) {
for (j = 0; j < 16; j++)
pt[j] = av_lfg_get(&prng);
{
START_TIMER;
av_aes_crypt(&ae, temp, pt, 1, NULL, 0);
if (!(i & (i - 1)))
av_log(NULL, AV_LOG_ERROR, "%02X %02X %02X %02X\n",
temp[0], temp[5], temp[10], temp[15]);
av_aes_crypt(&ad, temp, temp, 1, NULL, 1);
STOP_TIMER("aes");
}
for (j = 0; j < 16; j++) {
if (pt[j] != temp[j]) {
av_log(NULL, AV_LOG_ERROR, "%d %d %02X %02X\n",
i, j, pt[j], temp[j]);
}
}
}
}
return err;
}
int main(void)
{
AVLFG prng;
double n0,n1;
#define SAMPLES 1000
double ideal[SAMPLES];
double samples[SAMPLES];
#if 1
for(n0= 0; n0<40; n0=2*n0+1){
for(n1= 0; n1<10; n1=2*n1+1){
#else
{{
n0=7;
n1=1;
#endif
double best_error= 1000000000;
double bestpar0=1;
double bestpar1=0.001;
int better, i;
av_lfg_init(&prng, 123);
for(i=0; i<SAMPLES; i++){
ideal[i] = 10 + i + n1*i/(1000);
samples[i] = ideal[i] + n0 * (av_lfg_get(&prng) - LFG_MAX / 2)
/ (LFG_MAX * 10LL);
}
do{
double par0, par1;
better=0;
for(par0= bestpar0*0.8; par0<=bestpar0*1.21; par0+=bestpar0*0.05){
for(par1= bestpar1*0.8; par1<=bestpar1*1.21; par1+=bestpar1*0.05){
double error=0;
TimeFilter *tf= ff_timefilter_new(1, par0, par1);
for(i=0; i<SAMPLES; i++){
double filtered;
filtered= ff_timefilter_update(tf, samples[i], 1);
error += (filtered - ideal[i]) * (filtered - ideal[i]);
}
ff_timefilter_destroy(tf);
if(error < best_error){
best_error= error;
bestpar0= par0;
bestpar1= par1;
better=1;
}
}
}
}while(better);
#if 0
double lastfil=9;
TimeFilter *tf= ff_timefilter_new(1, bestpar0, bestpar1);
for(i=0; i<SAMPLES; i++){
double filtered;
filtered= ff_timefilter_update(tf, samples[i], 1);
printf("%f %f %f %f\n", i - samples[i] + 10, filtered - samples[i], samples[FFMAX(i, 1)] - samples[FFMAX(i-1, 0)], filtered - lastfil);
lastfil= filtered;
}
ff_timefilter_destroy(tf);
#else
printf(" [%f %f %9f]", bestpar0, bestpar1, best_error);
#endif
}
printf("\n");
}
return 0;
}
static av_cold int aac_encode_init(AVCodecContext *avctx)
{
AACEncContext *s = avctx->priv_data;
int i, ret = 0;
const uint8_t *sizes[2];
uint8_t grouping[AAC_MAX_CHANNELS];
int lengths[2];
s->channels = avctx->channels;
s->chan_map = aac_chan_configs[s->channels-1];
s->lambda = avctx->global_quality > 0 ? avctx->global_quality : 120;
s->last_frame_pb_count = 0;
avctx->extradata_size = 5;
avctx->frame_size = 1024;
avctx->initial_padding = 1024;
avctx->bit_rate = (int)FFMIN(
6144 * s->channels / 1024.0 * avctx->sample_rate,
avctx->bit_rate);
avctx->profile = avctx->profile == FF_PROFILE_UNKNOWN ? FF_PROFILE_AAC_LOW :
avctx->profile;
for (i = 0; i < 16; i++)
if (avctx->sample_rate == avpriv_mpeg4audio_sample_rates[i])
break;
s->samplerate_index = i;
ERROR_IF(s->samplerate_index == 16 ||
s->samplerate_index >= ff_aac_swb_size_1024_len ||
s->samplerate_index >= ff_aac_swb_size_128_len,
"Unsupported sample rate %d\n", avctx->sample_rate);
ERROR_IF(s->channels > AAC_MAX_CHANNELS || s->channels == 7,
"Unsupported number of channels: %d\n", s->channels);
WARN_IF(1024.0 * avctx->bit_rate / avctx->sample_rate > 6144 * s->channels,
"Too many bits %f > %d per frame requested, clamping to max\n",
1024.0 * avctx->bit_rate / avctx->sample_rate,
6144 * s->channels);
for (i = 0; i < FF_ARRAY_ELEMS(aacenc_profiles); i++)
if (avctx->profile == aacenc_profiles[i])
break;
ERROR_IF(i == FF_ARRAY_ELEMS(aacenc_profiles),
"Unsupported encoding profile: %d\n", avctx->profile);
if (avctx->profile == FF_PROFILE_MPEG2_AAC_LOW) {
avctx->profile = FF_PROFILE_AAC_LOW;
ERROR_IF(s->options.pred,
"Main prediction unavailable in the \"mpeg2_aac_low\" profile\n");
ERROR_IF(s->options.ltp,
"LTP prediction unavailable in the \"mpeg2_aac_low\" profile\n");
WARN_IF(s->options.pns,
"PNS unavailable in the \"mpeg2_aac_low\" profile, turning off\n");
s->options.pns = 0;
} else if (avctx->profile == FF_PROFILE_AAC_LTP) {
s->options.ltp = 1;
ERROR_IF(s->options.pred,
"Main prediction unavailable in the \"aac_ltp\" profile\n");
} else if (avctx->profile == FF_PROFILE_AAC_MAIN) {
s->options.pred = 1;
ERROR_IF(s->options.ltp,
"LTP prediction unavailable in the \"aac_main\" profile\n");
} else if (s->options.ltp) {
avctx->profile = FF_PROFILE_AAC_LTP;
WARN_IF(1,
"Chainging profile to \"aac_ltp\"\n");
ERROR_IF(s->options.pred,
"Main prediction unavailable in the \"aac_ltp\" profile\n");
} else if (s->options.pred) {
avctx->profile = FF_PROFILE_AAC_MAIN;
WARN_IF(1,
"Chainging profile to \"aac_main\"\n");
ERROR_IF(s->options.ltp,
"LTP prediction unavailable in the \"aac_main\" profile\n");
}
s->profile = avctx->profile;
s->coder = &ff_aac_coders[s->options.coder];
if (s->options.coder != AAC_CODER_TWOLOOP) {
ERROR_IF(avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL,
"Coders other than twoloop require -strict -2 and some may be removed in the future\n");
WARN_IF(s->options.coder == AAC_CODER_FAAC,
"The FAAC-like coder will be removed in the near future, please use twoloop!\n");
s->options.intensity_stereo = 0;
s->options.pns = 0;
}
if ((ret = dsp_init(avctx, s)) < 0)
goto fail;
if ((ret = alloc_buffers(avctx, s)) < 0)
goto fail;
put_audio_specific_config(avctx);
sizes[0] = ff_aac_swb_size_1024[s->samplerate_index];
sizes[1] = ff_aac_swb_size_128[s->samplerate_index];
lengths[0] = ff_aac_num_swb_1024[s->samplerate_index];
lengths[1] = ff_aac_num_swb_128[s->samplerate_index];
for (i = 0; i < s->chan_map[0]; i++)
grouping[i] = s->chan_map[i + 1] == TYPE_CPE;
if ((ret = ff_psy_init(&s->psy, avctx, 2, sizes, lengths,
s->chan_map[0], grouping)) < 0)
goto fail;
s->psypp = ff_psy_preprocess_init(avctx);
ff_lpc_init(&s->lpc, 2*avctx->frame_size, TNS_MAX_ORDER, FF_LPC_TYPE_LEVINSON);
av_lfg_init(&s->lfg, 0x72adca55);
if (HAVE_MIPSDSP)
ff_aac_coder_init_mips(s);
if ((ret = ff_thread_once(&aac_table_init, &aac_encode_init_tables)) != 0)
return AVERROR_UNKNOWN;
ff_af_queue_init(avctx, &s->afq);
return 0;
fail:
aac_encode_end(avctx);
return ret;
}
int main(int argc, char **argv)
{
unsigned int p, i, type, size, retry;
AVProbeData pd;
AVLFG state;
PutBitContext pb;
int retry_count= 4097;
int max_size = 65537;
if(argc >= 2)
retry_count = atoi(argv[1]);
if(argc >= 3)
max_size = atoi(argv[2]);
if (max_size > 1000000000U/8) {
fprintf(stderr, "max_size out of bounds\n");
return 1;
}
if (retry_count > 1000000000U) {
fprintf(stderr, "retry_count out of bounds\n");
return 1;
}
avcodec_register_all();
av_register_all();
av_lfg_init(&state, 0xdeadbeef);
pd.buf = NULL;
for (size = 1; size < max_size; size *= 2) {
pd.buf_size = size;
pd.buf = av_realloc(pd.buf, size + AVPROBE_PADDING_SIZE);
pd.filename = "";
fprintf(stderr, "testing size=%d\n", size);
for (retry = 0; retry < retry_count; retry += FFMAX(size, 32)) {
for (type = 0; type < 4; type++) {
for (p = 0; p < 4096; p++) {
unsigned hist = 0;
init_put_bits(&pb, pd.buf, size);
switch (type) {
case 0:
for (i = 0; i < size * 8; i++)
put_bits(&pb, 1, (av_lfg_get(&state) & 0xFFFFFFFF) > p << 20);
break;
case 1:
for (i = 0; i < size * 8; i++) {
unsigned int p2 = hist ? p & 0x3F : (p >> 6);
unsigned int v = (av_lfg_get(&state) & 0xFFFFFFFF) > p2 << 26;
put_bits(&pb, 1, v);
hist = v;
}
break;
case 2:
for (i = 0; i < size * 8; i++) {
unsigned int p2 = (p >> (hist * 3)) & 7;
unsigned int v = (av_lfg_get(&state) & 0xFFFFFFFF) > p2 << 29;
put_bits(&pb, 1, v);
hist = (2 * hist + v) & 3;
}
break;
case 3:
for (i = 0; i < size; i++) {
int c = 0;
while (p & 63) {
c = (av_lfg_get(&state) & 0xFFFFFFFF) >> 24;
if (c >= 'a' && c <= 'z' && (p & 1))
break;
else if (c >= 'A' && c <= 'Z' && (p & 2))
break;
else if (c >= '0' && c <= '9' && (p & 4))
break;
else if (c == ' ' && (p & 8))
break;
else if (c == 0 && (p & 16))
break;
else if (c == 1 && (p & 32))
break;
}
pd.buf[i] = c;
}
}
flush_put_bits(&pb);
probe(&pd, type, p, size);
}
}
}
}
return failures;
}
