/* * Linux VeeJay * * Copyright(C)2002 Niels Elburg * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version 2 * of the License , or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307 , USA. */ /* This effect recalculates a pretty large table if 'waves' or 'amplitude' is changed. Results will be placed in ripple_table, a copy of the frame is kept in ripple_data. So is the calculation of the first frame slow, the following frames will use the cached coordinates until the user changes the number of waves or the amplitude. */ #include "common.h" #include #include "ripple.h" #define RIPPLE_DEGREES 360 #define RIPPLE_VAL 180.0 typedef struct { double *ripple_table; uint8_t *ripple_data[4]; double *ripple_sin; double *ripple_cos; int ripple_waves; int ripple_ampli; int ripple_attn; } ripple_t; vj_effect *ripple_init(int width, int height) { vj_effect *ve = (vj_effect *) vj_calloc(sizeof(vj_effect)); ve->num_params = 3; ve->defaults = (int *) vj_calloc(sizeof(int) * ve->num_params); /* default values */ ve->limits[0] = (int *) vj_calloc(sizeof(int) * ve->num_params); /* min */ ve->limits[1] = (int *) vj_calloc(sizeof(int) * ve->num_params); /* max */ ve->limits[0][0] = 1; ve->limits[1][0] = 3600; ve->limits[0][1] = 1; ve->limits[1][1] = 80; ve->limits[0][2] = 1; ve->limits[1][2] = 360; ve->defaults[0] = 132; ve->defaults[1] = 47; ve->defaults[2] = 7; ve->description = "Ripple"; ve->sub_format = 1; ve->extra_frame = 0; ve->has_user = 0; ve->param_description = vje_build_param_list( ve->num_params, "Waves", "Amplitude", "Attenuation"); return ve; } void *ripple_malloc(int width, int height) { int i; ripple_t *r = (ripple_t*) vj_calloc(sizeof(ripple_t)); if(!r) { return NULL; } r->ripple_table = (double*) vj_malloc(sizeof(double) * (RUP8(width * height) + width) ); if(!r->ripple_table) { free(r); return NULL; } r->ripple_data[0] = (uint8_t*)vj_malloc( sizeof(uint8_t) * 3 * ( RUP8(width * height) + width) ); if(!r->ripple_data[0]) { free(r->ripple_table); free(r); return NULL; } r->ripple_data[1] = r->ripple_data[0] +(RUP8(width*height) + width); r->ripple_data[2] = r->ripple_data[1] +(RUP8(width*height) + width); veejay_memset( r->ripple_data[1], 128, RUP8(width * height) + width ); veejay_memset( r->ripple_data[2], 128, RUP8(width * height) + width ); veejay_memset( r->ripple_data[0], pixel_Y_lo_, RUP8(width*height) + width); r->ripple_sin = (double*) vj_malloc(sizeof(double) * RIPPLE_DEGREES); if(!r->ripple_sin) { free(r->ripple_table); free(r->ripple_data); free(r); return NULL; } r->ripple_cos = (double*) vj_malloc(sizeof(double) * RIPPLE_DEGREES); if(!r->ripple_cos) { free(r->ripple_table); free(r->ripple_data); free(r->ripple_sin); free(r); return NULL; } for(i=0; i < RIPPLE_DEGREES; i++) { fast_sin(r->ripple_sin[i], (M_PI * i) / RIPPLE_VAL); fast_sin(r->ripple_cos[i], (M_PI * i) / RIPPLE_VAL); } return (void*) r; } void ripple_free(void *ptr) { ripple_t *r = (ripple_t*) ptr; free(r->ripple_table); free(r->ripple_sin); free(r->ripple_cos); free(r->ripple_data[0]); free(r); } void ripple_apply(void *ptr, VJFrame *frame, int *args ) { const unsigned int width = frame->width; const unsigned int height = frame->height; const int len = frame->len; double wp2 = width * 0.5; double hp2 = height * 0.5; int x,y,dx,dy,a=0,sx=0,sy=0,angle=0; double r,z; double maxradius,frequency,amplitude; int _w = args[0]; int _a = args[1]; int _att = args[2]; double waves = (_w/10.0); double ampli = (double) (_a/10.0); double attenuation = (_att/10.0); uint8_t *Y = frame->data[0]; uint8_t *Cb= frame->data[1]; uint8_t *Cr= frame->data[2]; ripple_t *ripple = (ripple_t*) ptr; fast_sqrt(maxradius, wp2 * wp2 + hp2 * hp2); frequency = 360.0 * waves / maxradius; amplitude = maxradius / ampli; int have_calc_data=0; if(ripple->ripple_waves != _w || ripple->ripple_ampli != _a || ripple->ripple_attn != _att) { ripple->ripple_waves = _w; ripple->ripple_ampli = _a; ripple->ripple_attn = _att; have_calc_data=1; } int strides[4] = { len, len, len,0 }; vj_frame_copy( frame->data, ripple->ripple_data , strides ); double *ripple_table = ripple->ripple_table; uint8_t **ripple_data = ripple->ripple_data; double *ripple_sin = ripple->ripple_sin; double *ripple_cos = ripple->ripple_cos; if (have_calc_data) { for(y=0; y < height-1;y++) { for (x=0; x < width; x++) { dx = x - wp2; dy = y - hp2; angle = 180.0 * (atan2(dx,dy)/M_PI); if (angle < 0) angle+=360.0; fast_sqrt( r, dx * dx + dy * dy); z = amplitude/ pow(r,attenuation) * ripple_sin[ ((int)(frequency * r)) % 360 ]; a = ((int) (angle)) % 360; sx = (int) (x+z * ripple_cos[a]); sy = (int) (y+z * ripple_sin[a]); if(sy > (height-1)) sy = height-1; if(sx > width) sx = width; if(sx < 0) sx =0; if(sy < 0) sy =0; ripple_table[(y*width)+x] = (sx + (sy * width)); Y[((y * width) +x)] = ripple_data[0][(sx +( sy * width)) ]; Cb[((y * width) +x)] = ripple_data[1][(sx +( sy * width)) ]; Cr[((y * width) +x)] = ripple_data[2][(sx +( sy * width)) ]; } } } else { for(y=0; y < height-1;y++) { for (x=0; x < width; x++) { sx = (int) ripple_table[(y*width)+x]; Y[(y * width) +x] = ripple_data[0][sx]; Cb[(y * width) +x] = ripple_data[1][sx]; Cr[(y * width) +x] = ripple_data[2][sx]; } } } }