int main(void) {
AVLFG prng;
int i,j;
int border[2][2];
int ret, decomp_levels;
av_lfg_init(&prng, 1);
for (i = 0; i<MAX_W * MAX_W; i++)
arrayf[i] = reff[i] = array[i] = ref[i] = av_lfg_get(&prng) % 2048;
for (i = 0; i < 100; i++) {
for (j=0; j<4; j++)
border[j>>1][j&1] = av_lfg_get(&prng) % MAX_W;
if (border[0][0] >= border[0][1] || border[1][0] >= border[1][1])
continue;
decomp_levels = av_lfg_get(&prng) % FF_DWT_MAX_DECLVLS;
ret = test_dwt(array, ref, border, decomp_levels, FF_DWT53, 0);
if (ret)
return ret;
ret = test_dwt(array, ref, border, decomp_levels, FF_DWT97_INT, FFMIN(7+5*decomp_levels, 15+3*decomp_levels));
if (ret)
return ret;
ret = test_dwtf(arrayf, reff, border, decomp_levels, 0.05);
if (ret)
return ret;
}
return 0;
}
int main(void)
{
LLSModel m;
int i, order;
AVLFG lfg;
av_lfg_init(&lfg, 1);
avpriv_init_lls(&m, 3);
for (i = 0; i < 100; i++) {
double var[4];
double eval;
var[0] = (av_lfg_get(&lfg) / (double) UINT_MAX - 0.5) * 2;
var[1] = var[0] + av_lfg_get(&lfg) / (double) UINT_MAX - 0.5;
var[2] = var[1] + av_lfg_get(&lfg) / (double) UINT_MAX - 0.5;
var[3] = var[2] + av_lfg_get(&lfg) / (double) UINT_MAX - 0.5;
avpriv_update_lls(&m, var, 0.99);
avpriv_solve_lls(&m, 0.001, 0);
for (order = 0; order < 3; order++) {
eval = avpriv_evaluate_lls(&m, var + 1, order);
printf("real:%9f order:%d pred:%9f var:%f coeffs:%f %9f %9f\n",
var[0], order, eval, sqrt(m.variance[order] / (i + 1)),
m.coeff[order][0], m.coeff[order][1],
m.coeff[order][2]);
}
}
return 0;
}
void av_bmg_get(AVLFG *lfg, double out[2])
{
double x1, x2, w;
do {
x1 = 2.0 / UINT_MAX * av_lfg_get(lfg) - 1.0;
x2 = 2.0 / UINT_MAX * av_lfg_get(lfg) - 1.0;
w = x1 * x1 + x2 * x2;
} while (w >= 1.0);
w = sqrt((-2.0 * log(w)) / w);
out[0] = x1 * w;
out[1] = x2 * w;
}
int main(void)
{
int i;
AVTreeNode *root = NULL, *node = NULL;
AVLFG prng;
av_lfg_init(&prng, 1);
for (i = 0; i < 10000; i++) {
AVTreeNode *node2 = NULL;
intptr_t j = av_lfg_get(&prng) % 86294;
void *ret, *jj = (void *)(j + 1);
while (ret = av_tree_find(root, jj, cmp, NULL)) {
j = av_lfg_get(&prng) % 86294;
jj = (void *)(j + 1);
}
if (check(root) > 999) {
av_log(NULL, AV_LOG_ERROR, "FATAL error %d\n", i);
print(root, 0);
return 1;
}
if (!node)
node = av_tree_node_alloc();
if (!node) {
av_log(NULL, AV_LOG_ERROR, "Memory allocation failure.\n");
return 1;
}
av_tree_insert(&root, jj, cmp, &node);
while (ret = av_tree_find(root, jj, cmp, NULL)) {
j = av_lfg_get(&prng) % 86294;
jj = (void *)(j + 1);
}
ret = av_tree_insert(&root, jj, cmp, &node2);
if (ret != jj)
av_tree_destroy(node2);
ret = av_tree_find(root, jj, cmp, NULL);
if (ret)
av_log(NULL, AV_LOG_ERROR, "removal failure %d\n", i);
}
av_tree_destroy(root);
return 0;
}
int main(void)
{
RangeCoder c;
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, (1LL << 32) / 20, 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;
}
int main(int argc, char **argv){
uint8_t *rgb_data = malloc (W*H*4);
uint8_t *rgb_src[3]= {rgb_data, NULL, NULL};
int rgb_stride[3]={4*W, 0, 0};
uint8_t *data = malloc (4*W*H);
uint8_t *src[4]= {data, data+W*H, data+W*H*2, data+W*H*3};
int stride[4]={W, W, W, W};
int x, y;
struct SwsContext *sws;
AVLFG rand;
sws= sws_getContext(W/12, H/12, PIX_FMT_RGB32, W, H, PIX_FMT_YUVA420P, 2, NULL, NULL, NULL);
av_lfg_init(&rand, 1);
for (y=0; y<H; y++){
for (x=0; x<W*4; x++){
rgb_data[ x + y*4*W]= av_lfg_get(&rand);
}
}
sws_scale(sws, rgb_src, rgb_stride, 0, H, src, stride);
selfTest(src, stride, W, H);
return 123;
}
int main(void)
{
int x = 0;
int i, j;
AVLFG state;
av_lfg_init(&state, 0xdeadbeef);
for (j = 0; j < 10000; j++) {
START_TIMER
for (i = 0; i < 624; i++)
x += av_lfg_get(&state);
STOP_TIMER("624 calls of av_lfg_get");
}
av_log(NULL, AV_LOG_ERROR, "final value:%X\n", x);
/* BMG usage example */
{
double mean = 1000;
double stddev = 53;
av_lfg_init(&state, 42);
for (i = 0; i < 1000; i += 2) {
double bmg_out[2];
av_bmg_get(&state, bmg_out);
av_log(NULL, AV_LOG_INFO,
"%f\n%f\n",
bmg_out[0] * stddev + mean,
bmg_out[1] * stddev + mean);
}
}
return 0;
}
static int generate_dither_noise(DitherContext *c, DitherState *state,
int min_samples)
{
int i;
int nb_samples = FFALIGN(min_samples, 16) + 16;
int buf_samples = nb_samples *
(c->method == AV_RESAMPLE_DITHER_RECTANGULAR ? 1 : 2);
unsigned int *noise_buf_ui;
av_freep(&state->noise_buf);
state->noise_buf_size = state->noise_buf_ptr = 0;
state->noise_buf = av_malloc(buf_samples * sizeof(*state->noise_buf));
if (!state->noise_buf)
return AVERROR(ENOMEM);
state->noise_buf_size = FFALIGN(min_samples, 16);
noise_buf_ui = (unsigned int *)state->noise_buf;
av_lfg_init(&state->lfg, state->seed);
for (i = 0; i < buf_samples; i++)
noise_buf_ui[i] = av_lfg_get(&state->lfg);
c->ddsp.dither_int_to_float(state->noise_buf, noise_buf_ui, nb_samples);
if (c->method == AV_RESAMPLE_DITHER_TRIANGULAR_HP)
dither_highpass_filter(state->noise_buf, nb_samples);
return 0;
}
int main(int argc, char **argv)
{
int i;
void *k;
AVTreeNode *root = NULL, *node = NULL;
AVLFG prng;
int log_level = argc <= 1 ? AV_LOG_INFO : atoi(argv[1]);
av_log_set_level(log_level);
av_lfg_init(&prng, 1);
for (i = 0; i < 10000; i++) {
intptr_t j = av_lfg_get(&prng) % 86294;
if (check(root) > 999) {
av_log(NULL, AV_LOG_ERROR, "FATAL error %d\n", i);
print(root, 0);
return 1;
}
av_log(NULL, AV_LOG_DEBUG, "inserting %4d\n", (int)j);
if (!node)
node = av_tree_node_alloc();
if (!node) {
av_log(NULL, AV_LOG_ERROR, "Memory allocation failure.\n");
return 1;
}
av_tree_insert(&root, (void *)(j + 1), cmp, &node);
j = av_lfg_get(&prng) % 86294;
{
AVTreeNode *node2 = NULL;
av_log(NULL, AV_LOG_DEBUG, "removing %4d\n", (int)j);
av_tree_insert(&root, (void *)(j + 1), cmp, &node2);
k = av_tree_find(root, (void *)(j + 1), cmp, NULL);
if (k)
av_log(NULL, AV_LOG_ERROR, "removal failure %d\n", i);
av_free(node2);
}
}
av_free(node);
av_tree_destroy(root);
return 0;
}
static int cng_decode_frame(AVCodecContext *avctx, void *data,
int *got_frame_ptr, AVPacket *avpkt)
{
CNGContext *p = avctx->priv_data;
int buf_size = avpkt->size;
int ret, i;
int16_t *buf_out;
float e = 1.0;
float scaling;
if (avpkt->size) {
int dbov = -avpkt->data[0];
p->target_energy = 1081109975 * pow(10, dbov / 10.0) * 0.75;
memset(p->target_refl_coef, 0, p->order * sizeof(*p->target_refl_coef));
for (i = 0; i < FFMIN(avpkt->size - 1, p->order); i++) {
p->target_refl_coef[i] = (avpkt->data[1 + i] - 127) / 128.0;
}
}
if (p->inited) {
p->energy = p->energy / 2 + p->target_energy / 2;
for (i = 0; i < p->order; i++)
p->refl_coef[i] = 0.6 *p->refl_coef[i] + 0.4 * p->target_refl_coef[i];
} else {
p->energy = p->target_energy;
memcpy(p->refl_coef, p->target_refl_coef, p->order * sizeof(*p->refl_coef));
p->inited = 1;
}
make_lpc_coefs(p->lpc_coef, p->refl_coef, p->order);
for (i = 0; i < p->order; i++)
e *= 1.0 - p->refl_coef[i]*p->refl_coef[i];
scaling = sqrt(e * p->energy / 1081109975);
for (i = 0; i < avctx->frame_size; i++) {
int r = (av_lfg_get(&p->lfg) & 0xffff) - 0x8000;
p->excitation[i] = scaling * r;
}
ff_celp_lp_synthesis_filterf(p->filter_out + p->order, p->lpc_coef,
p->excitation, avctx->frame_size, p->order);
p->avframe.nb_samples = avctx->frame_size;
if ((ret = ff_get_buffer(avctx, &p->avframe)) < 0) {
av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
return ret;
}
buf_out = (int16_t *)p->avframe.data[0];
for (i = 0; i < avctx->frame_size; i++)
buf_out[i] = p->filter_out[i + p->order];
memcpy(p->filter_out, p->filter_out + avctx->frame_size,
p->order * sizeof(*p->filter_out));
*got_frame_ptr = 1;
*(AVFrame *)data = p->avframe;
return buf_size;
}
static void fill_random(uint8_t *tab, int size)
{
int i;
AVLFG prng;
av_lfg_init(&prng, 1);
for(i=0;i<size;i++) {
tab[i] = av_lfg_get(&prng) % 256;
}
}
static void nelly_decode_block(NellyMoserDecodeContext *s,
const unsigned char block[NELLY_BLOCK_LEN],
float audio[NELLY_SAMPLES])
{
int i,j;
float buf[NELLY_FILL_LEN], pows[NELLY_FILL_LEN];
float *aptr, *bptr, *pptr, val, pval;
int bits[NELLY_BUF_LEN];
unsigned char v;
init_get_bits(&s->gb, block, NELLY_BLOCK_LEN * 8);
bptr = buf;
pptr = pows;
val = ff_nelly_init_table[get_bits(&s->gb, 6)];
for (i=0 ; i<NELLY_BANDS ; i++) {
if (i > 0)
val += ff_nelly_delta_table[get_bits(&s->gb, 5)];
pval = -pow(2, val/2048) * s->scale_bias;
for (j = 0; j < ff_nelly_band_sizes_table[i]; j++) {
*bptr++ = val;
*pptr++ = pval;
}
}
ff_nelly_get_sample_bits(buf, bits);
for (i = 0; i < 2; i++) {
aptr = audio + i * NELLY_BUF_LEN;
init_get_bits(&s->gb, block, NELLY_BLOCK_LEN * 8);
skip_bits_long(&s->gb, NELLY_HEADER_BITS + i*NELLY_DETAIL_BITS);
for (j = 0; j < NELLY_FILL_LEN; j++) {
if (bits[j] <= 0) {
aptr[j] = M_SQRT1_2*pows[j];
if (av_lfg_get(&s->random_state) & 1)
aptr[j] *= -1.0;
} else {
v = get_bits(&s->gb, bits[j]);
aptr[j] = ff_nelly_dequantization_table[(1<<bits[j])-1+v]*pows[j];
}
}
memset(&aptr[NELLY_FILL_LEN], 0,
(NELLY_BUF_LEN - NELLY_FILL_LEN) * sizeof(float));
s->imdct_ctx.imdct_calc(&s->imdct_ctx, s->imdct_out, aptr);
/* XXX: overlapping and windowing should be part of a more
generic imdct function */
s->dsp.vector_fmul_reverse(s->state, s->state, ff_sine_128, NELLY_BUF_LEN);
s->dsp.vector_fmul_add(aptr, s->imdct_out, ff_sine_128, s->state, NELLY_BUF_LEN);
memcpy(s->state, s->imdct_out + NELLY_BUF_LEN, sizeof(float)*NELLY_BUF_LEN);
}
}
static int get_high_utility_cell(elbg_data *elbg)
{
int i=0;
/* Using linear search, do binary if it ever turns to be speed critical */
int r = av_lfg_get(elbg->rand_state)%elbg->utility_inc[elbg->numCB-1] + 1;
while (elbg->utility_inc[i] < r)
i++;
assert(!elbg->cells[i]);
return i;
}
static int get_high_utility_cell(elbg_data *elbg)
{
int i=0;
/* Using linear search, do binary if it ever turns to be speed critical */
uint64_t r;
if (elbg->utility_inc[elbg->numCB-1] < INT_MAX) {
r = av_lfg_get(elbg->rand_state) % (unsigned int)elbg->utility_inc[elbg->numCB-1] + 1;
} else {
r = av_lfg_get(elbg->rand_state);
r = (av_lfg_get(elbg->rand_state) + (r<<32)) % elbg->utility_inc[elbg->numCB-1] + 1;
}
while (elbg->utility_inc[i] < r) {
i++;
}
av_assert2(elbg->cells[i]);
return i;
}
int main(void)
{
int x = 0;
int i, j;
AVLFG state;
av_lfg_init(&state, 0xdeadbeef);
for (j = 0; j < 10000; j++) {
START_TIMER
for (i = 0; i < 624; i++) {
//av_log(NULL, AV_LOG_ERROR, "%X\n", av_lfg_get(&state));
x += av_lfg_get(&state);
}
STOP_TIMER("624 calls of av_lfg_get");
}
av_log(NULL, AV_LOG_ERROR, "final value:%X\n", x);
/* BMG usage example */
{
double mean = 1000;
double stddev = 53;
double samp_mean = 0.0, samp_stddev = 0.0;
double samp0, samp1;
av_lfg_init(&state, 42);
for (i = 0; i < 1000; i += 2) {
double bmg_out[2];
av_bmg_get(&state, bmg_out);
samp0 = bmg_out[0] * stddev + mean;
samp1 = bmg_out[1] * stddev + mean;
samp_mean += samp0 + samp1;
samp_stddev += samp0 * samp0 + samp1 * samp1;
av_log(NULL, AV_LOG_INFO,
"%f\n%f\n",
samp0,
samp1);
}
/* TODO: add proper normality test */
samp_mean /= 1000;
samp_stddev /= 999;
samp_stddev -= (1000.0/999.0)*samp_mean*samp_mean;
samp_stddev = sqrt(samp_stddev);
av_log(NULL, AV_LOG_INFO, "sample mean : %f\n"
"true mean : %f\n"
"sample stddev: %f\n"
"true stddev : %f\n",
samp_mean, mean, samp_stddev, stddev);
}
return 0;
}
static void shuffle(int* arr, size_t len)
{
int replace, index;
if (len <= 1) return;
av_lfg_get(&index);
index = 1 + index % len;
replace = arr[0];
arr[0] = arr[index];
arr[index] = replace;
shuffle(arr+1, len-1);
}
int generate_segment_session_id(char * ssid, int size)
{
AVLFG rnd;
char *ex_id = "E4499E08-D4C5-4DB0-A21C-";
unsigned int session_id = 0;
char session_name[SESSLEN] = "";
av_lfg_init(&rnd, av_get_random_seed());
session_id = av_lfg_get(&rnd);
snprintf(session_name, SESSLEN, "%s%012u", ex_id, session_id);
if (ssid != NULL) {
snprintf(ssid, size, "%s", session_name);
return 0;
}
return -1;
}
int generate_playback_session_id(char * ssid, int size)
{
AVLFG rnd;
char *ex_id = "314F1B49-AA3C-4715-950D-";
unsigned int session_id = 0;
char session_name[SESSLEN] = "";
av_lfg_init(&rnd, av_get_random_seed());
session_id = av_lfg_get(&rnd);
snprintf(session_name, SESSLEN, "%s%012u", ex_id, session_id);
if (ssid != NULL) {
snprintf(ssid, size, "%s", session_name);
return 0;
}
return -1;
}
static void scalar_dequant_float(COOKContext *q, int index, int quant_index,
int* subband_coef_index, int* subband_coef_sign,
float* mlt_p){
int i;
float f1;
for(i=0 ; i<SUBBAND_SIZE ; i++) {
if (subband_coef_index[i]) {
f1 = quant_centroid_tab[index][subband_coef_index[i]];
if (subband_coef_sign[i]) f1 = -f1;
} else {
/* noise coding if subband_coef_index[i] == 0 */
f1 = dither_tab[index];
if (av_lfg_get(&q->random_state) < 0x80000000) f1 = -f1;
}
mlt_p[i] = f1 * rootpow2tab[quant_index+63];
}
}
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 index_t getmin(struct ctx *k)
{
uint64_t min = UINT64_MAX;
index_t resnum = 0;
unsigned int size2 = k->size2;
for (index_t c = 0; c < size2; c++) {
if (k->calcmat[c])
continue;
uint64_t total = k->gaussmat[c];
if (total <= min) {
if (total != min) {
min = total;
resnum = 0;
}
k->randomat[resnum++] = c;
}
}
if (resnum == 1)
return k->randomat[0];
if (resnum == size2)
return size2 / 2;
return k->randomat[av_lfg_get(&k->avlfg) % resnum];
}
static float frandom(AVLFG *prng)
{
return (int16_t)av_lfg_get(prng) / 32768.0;
}
static double drand(void *opaque, double min, double max)
{
return min + (max-min) / UINT_MAX * av_lfg_get(opaque);
}
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;
}
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;
}
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)
{
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(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)
{
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 FFTSample frandom(AVLFG *prng)
{
return (int16_t)av_lfg_get(prng) / 32768.0 * RANGE;
}
