void
generate_noise (SchroFrame *frame, int n_transforms, double *weights)
{
int i;
int j;
int k;
int l;
int pos;
int w, h, x_offset, y_offset, y_skip;
int16_t *data;
SchroFrameData *comp;
for(k=0;k<3;k++){
comp = frame->components + k;
for(l=0;l<1+3*n_transforms;l++){
pos = schro_subband_get_position (l);
w = comp->width >> (n_transforms - SCHRO_SUBBAND_SHIFT(pos));
h = comp->height >> (n_transforms - SCHRO_SUBBAND_SHIFT(pos));
y_skip = 1<<(n_transforms - SCHRO_SUBBAND_SHIFT(pos));
if (pos&1) {
x_offset = w;
} else {
x_offset = 0;
}
if (pos&2) {
y_offset = y_skip / 2;
} else {
y_offset = 0;
}
//printf("%d %d w %d h %d x_offset %d y_offset %d y_skip %d\n", l, pos, w, h, x_offset, y_offset, y_skip);
for(j=0;j<h;j++){
data = OFFSET(comp->data,
(j*y_skip + y_offset)*comp->stride);
data += x_offset;
for(i=0;i<w;i++){
data[i] = rint(random_std()*AMPLITUDE*weights[l]);
//data[i] = rint(random_std()*AMPLITUDE);
}
}
}
}
}
void
schro_subband_get_frame_data (SchroFrameData * fd,
SchroFrame * frame, int component, int position, SchroParams * params)
{
int shift;
SchroFrameData *comp = &frame->components[component];
shift = params->transform_depth - SCHRO_SUBBAND_SHIFT (position);
fd->format = frame->format;
fd->h_shift = comp->h_shift + shift;
fd->v_shift = comp->v_shift + shift;
fd->stride = comp->stride << shift;
if (component == 0) {
fd->width = params->iwt_luma_width >> shift;
fd->height = params->iwt_luma_height >> shift;
} else {
static void
schro_encoder_generate_subband_histograms (SchroEncoderFrame *frame)
{
SchroParams *params = &frame->params;
int i;
int component;
int pos;
int skip;
for(component=0;component<3;component++){
for(i=0;i<1 + 3*params->transform_depth; i++) {
pos = schro_subband_get_position (i);
skip = 1<<MAX(0,SCHRO_SUBBAND_SHIFT(pos)-1);
schro_encoder_generate_subband_histogram (frame, component, i,
&frame->subband_hists[component][i], skip);
}
}
frame->have_histograms = TRUE;
}
void
schro_encoder_calculate_subband_weights (SchroEncoder *encoder,
double (*perceptual_weight)(double))
{
int wavelet;
int n_levels;
double *matrix;
int n;
int i,j;
double column[SCHRO_LIMIT_SUBBANDS];
double *weight;
matrix = schro_malloc (sizeof(double)*SCHRO_LIMIT_SUBBANDS*SCHRO_LIMIT_SUBBANDS);
weight = schro_malloc (sizeof(double)*CURVE_SIZE*CURVE_SIZE);
for(j=0;j<CURVE_SIZE;j++){
for(i=0;i<CURVE_SIZE;i++){
double fv = j*encoder->cycles_per_degree_vert*(1.0/CURVE_SIZE);
double fh = i*encoder->cycles_per_degree_horiz*(1.0/CURVE_SIZE);
weight[j*CURVE_SIZE+i] = perceptual_weight (sqrt(fv*fv+fh*fh));
}
}
for(wavelet=0;wavelet<SCHRO_N_WAVELETS;wavelet++) {
for(n_levels=1;n_levels<=4;n_levels++){
const float *h_curve[SCHRO_LIMIT_SUBBANDS];
const float *v_curve[SCHRO_LIMIT_SUBBANDS];
int hi[SCHRO_LIMIT_SUBBANDS];
int vi[SCHRO_LIMIT_SUBBANDS];
n = 3*n_levels+1;
for(i=0;i<n;i++){
int position = schro_subband_get_position(i);
int n_transforms;
n_transforms = n_levels - SCHRO_SUBBAND_SHIFT(position);
if (position&1) {
hi[i] = (n_transforms-1)*2;
} else {
hi[i] = (n_transforms-1)*2+1;
}
if (position&2) {
vi[i] = (n_transforms-1)*2;
} else {
vi[i] = (n_transforms-1)*2+1;
}
h_curve[i] = schro_tables_wavelet_noise_curve[wavelet][hi[i]];
v_curve[i] = schro_tables_wavelet_noise_curve[wavelet][vi[i]];
}
if (0) {
for(i=0;i<n;i++){
column[i] = weighted_sum(h_curve[i], v_curve[i], weight);
matrix[i*n+i] = dot_product (h_curve[i], v_curve[i],
h_curve[i], v_curve[i], weight);
for(j=i+1;j<n;j++) {
matrix[i*n+j] = dot_product (h_curve[i], v_curve[i],
h_curve[j], v_curve[j], weight);
matrix[j*n+i] = matrix[i*n+j];
}
}
solve (matrix, column, n);
for(i=0;i<n;i++){
if (column[i] < 0) {
SCHRO_ERROR("BROKEN wavelet %d n_levels %d", wavelet, n_levels);
break;
}
}
SCHRO_DEBUG("wavelet %d n_levels %d", wavelet, n_levels);
for(i=0;i<n;i++){
SCHRO_DEBUG("%g", 1.0/sqrt(column[i]));
encoder->subband_weights[wavelet][n_levels-1][i] = sqrt(column[i]);
}
} else {
for(i=0;i<n;i++){
int position = schro_subband_get_position(i);
int n_transforms;
double size;
n_transforms = n_levels - SCHRO_SUBBAND_SHIFT(position);
size = (1.0/CURVE_SIZE)*(1<<n_transforms);
encoder->subband_weights[wavelet][n_levels-1][i] = 1.0/(size *
sqrt(weighted_sum(h_curve[i], v_curve[i], weight)));
}
}
}
}
#if 0
for(wavelet=0;wavelet<8;wavelet++) {
for(n_levels=1;n_levels<=4;n_levels++){
double alpha, beta, shift;
double gain;
alpha = schro_tables_wavelet_gain[wavelet][0];
beta = schro_tables_wavelet_gain[wavelet][1];
shift = (1<<filtershift[wavelet]);
n = 3*n_levels+1;
gain = shift;
for(i=n_levels-1;i>=0;i--){
encoder->subband_weights[wavelet][n_levels-1][1+3*i+0] =
sqrt(alpha*beta)*gain;
encoder->subband_weights[wavelet][n_levels-1][1+3*i+1] =
sqrt(alpha*beta)*gain;
encoder->subband_weights[wavelet][n_levels-1][1+3*i+2] =
sqrt(beta*beta)*gain;
gain *= alpha;
gain *= shift;
}
encoder->subband_weights[wavelet][n_levels-1][0] = gain / shift;
if (wavelet == 3 && n_levels == 3) {
for(i=0;i<10;i++){
SCHRO_ERROR("%g",
encoder->subband_weights[wavelet][n_levels-1][i]);
}
}
}
}
#endif
schro_free(weight);
schro_free(matrix);
}
