void
schro_async_free (SchroAsync *async)
{
int i;
HANDLE *handles;
EnterCriticalSection (&async->mutex);
async->stop = TRUE;
LeaveCriticalSection (&async->mutex);
for(i=0;i<async->n_threads;i++){
SetEvent (async->threads[i].event);
}
handles = schro_malloc (sizeof(HANDLE) * async->n_threads);
for(i=0;i<async->n_threads;i++){
handles[i] = async->threads[i].thread;
}
WaitForMultipleObjects (async->n_threads, handles, TRUE,
INFINITE);
schro_free (handles);
for(i=0;i<async->n_threads;i++){
CloseHandle (async->threads[i].event);
CloseHandle (async->threads[i].thread);
}
CloseHandle (async->app_event);
DeleteCriticalSection (&async->mutex);
schro_free(async->threads);
schro_free(async);
}
void
schro_motion_free (SchroMotion *motion)
{
schro_free (motion->tmpdata);
schro_free (motion->motion_vectors);
schro_free (motion);
}
void
schro_fft_fwd_f32 (float *d_real, float *d_imag, const float *s_real,
const float *s_imag, const float *costable, const float *sintable,
int shift)
{
int i;
int n = 1 << shift;
float *tmp;
float *tmp1_1, *tmp1_2, *tmp2_1, *tmp2_2;
tmp = schro_malloc (4 * sizeof (float) * n);
tmp1_1 = tmp;
tmp1_2 = tmp + n;
tmp2_1 = tmp + 2 * n;
tmp2_2 = tmp + 3 * n;
i = 0;
fft_stage (tmp1_1, tmp1_2, s_real, s_imag, costable, sintable, i, shift);
for (i = 1; i < shift - 2; i += 2) {
fft_stage (tmp2_1, tmp2_2, tmp1_1, tmp1_2, costable, sintable, i, shift);
fft_stage (tmp1_1, tmp1_2, tmp2_1, tmp2_2, costable, sintable, i + 1,
shift);
}
if (i < shift - 1) {
fft_stage (tmp2_1, tmp2_2, tmp1_1, tmp1_2, costable, sintable, i, shift);
fft_stage (d_real, d_imag, tmp2_1, tmp2_2, costable, sintable, i + 1,
shift);
} else {
fft_stage (d_real, d_imag, tmp1_1, tmp1_2, costable, sintable, i, shift);
}
schro_free (tmp);
}
void
schro_motionest_free (SchroMotionEst *me)
{
int ref;
int i;
for(ref=0;ref<2;ref++){
for(i=0;i<5;i++){
if (me->downsampled_mf[ref][i]) {
schro_motion_field_free (me->downsampled_mf[ref][i]);
}
}
}
schro_free (me->sblocks);
schro_free (me);
}
void
schro_async_free (SchroAsync * async)
{
int i;
pthread_mutex_lock (&async->mutex);
async->stop = DIE;
while (async->n_threads_running > 0) {
pthread_cond_signal (&async->thread_cond);
pthread_cond_wait (&async->app_cond, &async->mutex);
}
pthread_mutex_unlock (&async->mutex);
for (i = 0; i < async->n_threads; i++) {
void *ignore;
pthread_join (async->threads[i].pthread, &ignore);
}
schro_free (async->threads);
schro_free (async);
}
void
schro_async_free (SchroAsync * async)
{
int i;
g_mutex_lock (async->mutex);
async->stop = DIE;
while (async->n_threads_running > 0) {
g_cond_signal (async->thread_cond);
g_cond_wait (async->app_cond, async->mutex);
}
g_mutex_unlock (async->mutex);
for (i = 0; i < async->n_threads; i++) {
g_thread_join (async->threads[i].thread);
}
g_mutex_free (async->mutex);
g_cond_free (async->app_cond);
g_cond_free (async->thread_cond);
schro_free (async->threads);
schro_free (async);
}
void
schro_memory_domain_free (SchroMemoryDomain * domain)
{
int i;
SCHRO_ASSERT (domain != NULL);
for (i = 0; i < SCHRO_MEMORY_DOMAIN_SLOTS; i++) {
if (domain->slots[i].flags & SCHRO_MEMORY_DOMAIN_SLOT_ALLOCATED) {
domain->free (domain->slots[i].ptr, domain->slots[i].size);
}
}
schro_mutex_free (domain->mutex);
schro_free (domain);
}
void
schro_mutex_free (SchroMutex * mutex)
{
pthread_mutex_destroy (&mutex->mutex);
schro_free (mutex);
}
static void
schro_lowdelay_cleanup (SchroLowDelay *lowdelay)
{
schro_free (lowdelay->saved_dc_values);
}
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);
}
void
schro_arith_free (SchroArith *arith)
{
schro_free(arith);
}
