static void chromastore_frame(VJFrame *src, int w, int h, int n, int no_reverse)
{
int strides[4] = { (w * h), (w*h), (w*h) , 0 };
uint8_t *dest[4] = {
cframe[0] + (w*h*cnframe),
cframe[1] + (w*h*cnframe),
cframe[2] + (w*h*cnframe),
NULL };
if (!cnreverse) {
vj_frame_copy( src->data, dest, strides );
} else {
vj_frame_copy( dest, src->data, strides );
}
if (cnreverse)
cnframe--;
else
cnframe++;
if (cnframe >= n) {
if (no_reverse == 0) {
cnreverse = 1;
cnframe = n - 1;
if(cnframe < 0 )
cnframe = 0;
} else {
cnframe = 0;
}
}
if (cnframe == 0)
cnreverse = 0;
}
void tracer_apply(VJFrame *frame, VJFrame *frame2,
int width, int height, int opacity, int n)
{
unsigned int x, len = frame->len;
unsigned int op1 = (opacity > 255) ? 255 : opacity;
unsigned int op0 = 255 - op1;
unsigned int uv_len = frame->uv_len;
uint8_t *Y = frame->data[0];
uint8_t *Cb= frame->data[1];
uint8_t *Cr= frame->data[2];
uint8_t *Y2 = frame2->data[0];
uint8_t *Cb2= frame2->data[1];
uint8_t *Cr2= frame2->data[2];
if (trace_counter == 0)
{
for (x = 0; x < len; x++)
{
Y[x] = func_opacity(Y[x], Y2[x], op0, op1);
}
for (x = 0; x < uv_len; x++)
{
Cb[x] = func_opacity(Cb[x], Cb2[x], op0, op1);
Cr[x] = func_opacity(Cr[x], Cr2[x], op0, op1);
}
int strides[4] = { len, uv_len, uv_len, 0 };
vj_frame_copy( frame->data, trace_buffer, strides );
}
else
{
for (x = 0; x < len; x++)
{
Y[x] =
((op0 * Y[x]) + (op1 * trace_buffer[0][x])) >> 8; // / 255;
}
for (x = 0; x < uv_len; x++)
{
Cb[x] =
((op0 * Cb[x]) + (op1 * trace_buffer[1][x])) >> 8 ; // 255;
Cr[x] =
((op0 * Cr[x]) + (op1 * trace_buffer[2][x])) >> 8 ; // 255;
}
int strides[4] = { len, uv_len, uv_len, 0 };
vj_frame_copy( frame->data, trace_buffer, strides );
}
trace_counter++;
if (trace_counter >= n)
trace_counter = 0;
}
int vj_shm_write( void *vv, uint8_t *frame[4], int plane_sizes[4] )
{
vj_shm_t *v = (vj_shm_t*) vv;
vj_shared_data *data = (vj_shared_data*) v->sms;
//@ call wrlock_wrlock N times before giving up ..
int res = pthread_rwlock_wrlock( &data->rwlock );
if( res == -1 ) {
veejay_msg(0, "SHM locking error: %s",strerror(errno));
return -1;
}
uint8_t *ptr = ( (uint8_t*) v->sms) + HEADER_LENGTH;
uint8_t *dst[4] = { ptr, ptr + plane_sizes[0], ptr + plane_sizes[0] + plane_sizes[1], NULL };
plane_sizes[3] = 0;
vj_frame_copy( frame, dst, plane_sizes );
// veejay_memcpy( ptr , frame[0], plane_sizes[0] );
// veejay_memcpy( ptr + plane_sizes[0], frame[1], plane_sizes[1] );
// veejay_memcpy( ptr + plane_sizes[0] +
// plane_sizes[1], frame[2], plane_sizes[2] );
res = pthread_rwlock_unlock( &data->rwlock );
if( res == -1 ) {
veejay_msg(0, "SHM locking error: %s",strerror(errno));
return -1;
}
return 0;
}
int vj_shm_read( void *vv , uint8_t *dst[4] )
{
vj_shm_t *v = (vj_shm_t*) vv;
vj_shared_data *data = (vj_shared_data*) v->sms;
int res = pthread_rwlock_rdlock( &data->rwlock );
if( res == -1 ) {
// veejay_msg(0, "%s",strerror(errno));
return -1;
}
uint8_t *ptr = ( (uint8_t*) v->sms ) + HEADER_LENGTH;
int len = data->header[0] * data->header[1]; //@
int uv_len = len / 2;
uint8_t *in[4] = { ptr, ptr + len, ptr + len + uv_len,NULL };
int strides[4] = { len, uv_len, uv_len,0 };
vj_frame_copy( in, dst, strides );
// veejay_memcpy( dst[0], ptr, len );
// veejay_memcpy( dst[1], ptr + len, uv_len );
// veejay_memcpy( dst[2], ptr + len + uv_len, uv_len );
res = pthread_rwlock_unlock( &data->rwlock );
if( res == -1 ) {
// veejay_msg(0, "%s",strerror(errno));
return -1;
}
return 0;
}
void scratcher_apply(VJFrame *src,
int width, int height, int opacity, int n,
int no_reverse)
{
unsigned int len = src->len;
unsigned int op1 = (opacity > 255) ? 255 : opacity;
int offset = len * nframe;
int uv_len = src->uv_len;
int uv_offset = uv_len * nframe;
VJFrame copy;
if (nframe== 0) {
int strides[4] = { len, uv_len, uv_len, 0 };
vj_frame_copy( src->data, frame, strides );
return;
}
VJFrame srcB;
veejay_memcpy( &srcB, src, sizeof(VJFrame) );
srcB.data[0] = frame[0] + offset;
srcB.data[1] = frame[1] + uv_offset;
srcB.data[2] = frame[2] + uv_offset;
opacity_applyN( src, &srcB, src->width,src->height, opacity );
copy.uv_len = src->uv_len;
copy.data[0] = frame[0];
copy.data[1] = frame[1];
copy.data[2] = frame[2];
store_frame( ©, width, height, n, no_reverse);
}
void store_frame(VJFrame *src, int w, int h, int n, int no_reverse)
{
int uv_len = src->uv_len;
int strides[4] = { (w * h), uv_len, uv_len , 0 };
uint8_t *Y = src->data[0];
uint8_t *Cb= src->data[1];
uint8_t *Cr= src->data[2];
uint8_t *dest[4] = {
frame[0] + (w*h*nframe),
frame[1] + (uv_len*nframe),
frame[2] + (uv_len*nframe),
NULL };
if (!nreverse) {
vj_frame_copy( src->data, dest, strides );
} else {
vj_frame_copy( dest, src->data, strides );
}
if (nreverse)
nframe--;
else
nframe++;
if (nframe >= n) {
if (no_reverse == 0) {
nreverse = 1;
nframe = n - 1;
} else {
nframe = 0;
}
}
if (nframe == 0)
nreverse = 0;
}
static void store_frame(VJFrame *src, int n, int no_reverse)
{
const int len = src->len;
int uv_len = src->uv_len;
int strides[4] = { len, uv_len, uv_len , 0 };
uint8_t *dest[4] = {
frame[0] + (len*nframe),
frame[1] + (uv_len*nframe),
frame[2] + (uv_len*nframe),
NULL
};
if (!nreverse) {
vj_frame_copy( src->data, dest, strides );
}
else {
vj_frame_copy( dest, src->data, strides );
}
if (nreverse)
nframe--;
else
nframe++;
if (nframe >= n) {
if (no_reverse == 0) {
nreverse = 1;
nframe = n - 1;
if(nframe < 0)
nframe = 0;
} else {
nframe = 0;
}
}
if (nframe == 0)
nreverse = 0;
}
void chameleon_apply( VJFrame *frame, int mode)
{
const int len = frame->len;
VJFrame source;
int strides[4] = { len, len, len, 0 };
vj_frame_copy( frame->data, tmpimage, strides );
source.data[0] = tmpimage[0];
source.data[1] = tmpimage[1];
source.data[2] = tmpimage[2];
source.len = len;
uint32_t activity = 0;
int auto_switch = 0;
int tmp1,tmp2;
if( motionmap_active() )
{
motionmap_scale_to( 32,32,1,1, &tmp1,&tmp2, &n__, &N__ );
auto_switch = 1;
activity = motionmap_activity();
}
else
{
N__ = 0;
n__ = 0;
}
if( n__ == N__ || n__ == 0 )
auto_switch = 0;
if(auto_switch)
{
if( activity <= 40 )
{
// into the wall
drawDisappearing( &source, frame );
}
else
{
// out of the wall
drawAppearing( &source, frame );
}
}
if( mode == 0 )
drawDisappearing( &source, frame );
else
drawAppearing( &source, frame );
}
void zoom_apply( VJFrame *frame, int width, int height, int x, int y, int factor, int dir)
{
if( zoom_[0] != x || zoom_[1] != y || zoom_[2] != factor || !zoom_vp_ || dir != zoom_[3])
{
if( zoom_vp_ )
viewport_destroy( zoom_vp_ );
zoom_vp_ = viewport_fx_init( VP_QUADZOOM, width,height,x,y,factor, dir );
if(!zoom_vp_ )
return;
zoom_[0] = x; zoom_[1] = y; zoom_[2] = factor; zoom_[3] = dir;
}
int strides[4] = { (width*height),(width*height),(width*height), 0 };
vj_frame_copy( frame->data, zoom_private_, strides );
viewport_process_dynamic( zoom_vp_, zoom_private_, frame->data );
}
int chameleonblend_prepare( uint8_t *map[4], int width, int height )
{
if(!bgimage[0])
return 0;
int strides[4] = { width*height,width*height,width*height, 0 };
vj_frame_copy( map, bgimage, strides );
VJFrame tmp;
veejay_memset( &tmp, 0, sizeof(VJFrame));
tmp.data[0] = bgimage[0];
tmp.width = width;
tmp.height = height;
//@ 3x3 blur
softblur_apply( &tmp, width,height,0);
veejay_msg(2, "Chameleon BlendTV: Snapped background mask");
return 1;
}
void radcor_apply( VJFrame *frame, int alpaX, int alpaY, int dir, int alpha)
{
int i,j;
int i2,j2;
const unsigned int width = frame->width;
const unsigned int height = frame->height;
const int len = frame->len;
double x,y,x2,x3,y2,y3,r;
uint8_t *Y = frame->data[0];
uint8_t *Cb = frame->data[1];
uint8_t *Cr = frame->data[2];
uint8_t *A = frame->data[3];
int nx = width;
int ny = height;
int nxout = nx;
int nyout = ny;
//@ copy source image to internal buffer
uint8_t *dest[4] = { badbuf, badbuf + len, badbuf + len + len, badbuf + len + len + len };
int strides[4] = { len, len, len, 0 };
if( alpha )
strides[3] = len;
vj_frame_copy( frame->data, dest, strides );
uint8_t *Yi = badbuf;
uint8_t *Cbi = badbuf + len;
uint8_t *Cri = badbuf + len + len;
uint8_t *Ai = badbuf + len + len + len;
double alphax = alpaX / (double) 1000.0;
double alphay = alpaY / (double) 1000.0;
if(!dir)
{
alphax *= -1.0; // inward, outward, change sign
alphay *= -1.0;
}
vj_frame_clear1( Y, 0, len );
vj_frame_clear1( Cb, 128, len );
vj_frame_clear1( Cr, 128, len );
if( alpha )
vj_frame_clear1( A, 0, len );
int update_map = 0;
if( map_upd[0] != alpaX || map_upd[1] != alpaY || map_upd[2] != dir )
{
map_upd[0] = alpaX;
map_upd[1] = alpaY;
map_upd[2] = dir;
update_map = 1;
}
if( update_map )
{
for( i = 0; i < nyout; i ++ )
{
for( j = 0; j < nxout; j ++ )
{
x = ( 2 * j - nxout ) / (double) nxout;
y = ( 2 * i - nyout ) / (double) nyout;
r = x*x + y*y;
x3 = x / (1 - alphax * r);
y3 = y / (1 - alphay * r);
x2 = x / (1 - alphax * (x3*x3+y3*y3));
y2 = y / (1 - alphay * (x3*x3+y3*y3));
i2 = (y2 + 1) * ny / 2;
j2 = (x2 + 1) * nx / 2;
if( i2 >= 0 && i2 < ny && j2 >= 0 && j2 < nx )
Map[ i * nxout + j ] = i2 * nx + j2;
else
Map[ i * nxout + j ] = 0;
}
}
}
// process
for( i = 0; i < height; i ++ )
{
for( j = 0; j < width ; j ++ )
{
Y[ i * width + j ] = Yi[ Map[i * width + j] ];
Cb[ i * width + j ] = Cbi[ Map[i * width + j] ];
Cr[ i * width + j ] = Cri[ Map[i * width + j] ];
}
}
if( alpha)
{
for( i = 0; i < len; i ++ )
{
A[i] = Ai[ Map[i] ];
}
}
}
void timedistort_apply( VJFrame *frame, int width, int height, int val)
{
unsigned int i;
const int len = (width * height);
uint8_t *Y = frame->data[0];
uint8_t *Cb = frame->data[1];
uint8_t *Cr = frame->data[2];
uint8_t *diff = nonmap;
uint8_t *prev = nonmap + len;
int interpolate = 1;
int motion = 0;
int tmp1,tmp2;
if(motionmap_active()) //@ use motion mapping frame
{
motionmap_scale_to( 255,255,1,1,&tmp1,&tmp2, &n__,&N__ );
motion = 1;
diff = motionmap_bgmap();
}
else
{
n__ = 0;
N__ = 0;
if(!have_bg)
{
vj_frame_copy1( Y, prev, len );
VJFrame smooth;
veejay_memcpy(&smooth,frame, sizeof(VJFrame));
smooth.data[0] = prev;
softblur_apply(&smooth, width, height, 0 );
veejay_memset( diff, 0, len );
have_bg = 1;
return;
}
else
{
/*for( i = 0; i < len ; i ++ )
{
diff[i] = (abs(prev[i] - Y[i])> val ? 0xff: 0 );
}*/
vje_diff_plane( prev, Y, diff, val, len );
vj_frame_copy1( Y, prev, len );
VJFrame smooth;
veejay_memcpy(&smooth,frame, sizeof(VJFrame));
smooth.data[0] = prev;
softblur_apply(&smooth, width, height, 0 );
}
}
if( n__ == N__ || n__ == 0 )
interpolate = 0;
//@ process
uint8_t *planeTables[4] = { planetableY[plane], planetableU[plane], planetableV[plane], NULL };
int strides[4] = { len, len, len, 0 };
vj_frame_copy( frame->data, planeTables, strides );
uint8_t *p = warptime[ warptimeFrame ] + width + 1;
uint8_t *q = warptime[ warptimeFrame ^ 1] + width + 1;
unsigned int x,y;
for( y = height - 2; y > 0 ; y -- )
{
for( x = width - 2; x > 0; x -- )
{
i = *(p - width) + *(p-1) + *(p+1) + *(p + width);
if( i > 3 ) i-= 3;
p++;
*q++ = i >> 2;
}
p += 2;
q += 2;
}
q = warptime[ warptimeFrame ^ 1 ] + width + 1;
int n_plane = 0;
for( i = 0; i < len; i ++ )
{
if( diff[i] ) {
q[i] = PLANES - 1;
}
n_plane = ( plane - q[i] + PLANES ) & (PLANES-1);
Y[i] = planetableY[ n_plane ][i];
Cb[i] = planetableU[ n_plane ][i];
Cr[i] = planetableV[ n_plane ][i];
}
plane ++;
plane = plane & (PLANES-1);
warptimeFrame ^= 1;
if(interpolate)
motionmap_interpolate_frame( frame, N__,n__ );
if(motion)
motionmap_store_frame(frame);
}
void magicmirror_apply( VJFrame *frame, int w, int h, int vx, int vy, int d, int n )
{
double c1 = (double)vx;
double c2 = (double)vy;
int motion = 0;
if( motionmap_active())
{
motionmap_scale_to( 100,100,0,0, &d, &n, &n__, &N__ );
motion = 1;
}
else
{
n__ = 0;
N__ = 0;
}
double c3 = (double)d * 0.001;
unsigned int dx,dy,x,y,p,q,len=w*h;
double c4 = (double)n * 0.001;
int changed = 0;
uint8_t *Y = frame->data[0];
uint8_t *Cb= frame->data[1];
uint8_t *Cr= frame->data[2];
int interpolate = 1;
if( n__ == N__ || n__ == 0)
interpolate = 0;
if( d != last[1] )
{
changed = 1; last[1] =d;
}
if( n != last[0] )
{
changed = 1; last[0] = n;
}
if(changed==1)
{ // degrees x or y changed, need new sin
for(x=0; x < w ; x++)
{
double res;
fast_sin(res,(double)(c3*x));
funhouse_x[x] = res;
//funhouse_x[x] = sin(c3 * x);
}
for(y=0; y < h; y++)
{
double res;
fast_sin(res,(double)(c4*y));
funhouse_y[y] = res;
//funhouse_y[y] = sin(c4 * y);
}
}
int strides[4] = { len,len,len, 0 };
vj_frame_copy( frame->data, magicmirrorbuf, strides );
for(x=0; x < w; x++)
{
dx = x + funhouse_x[x] * c1;
if(dx < 0) dx += w;
if(dx < 0) dx = 0; else if (dx >= w) dx = w-1;
cache_x[x] = dx;
}
for(y=0; y < h; y++)
{
dy = y + funhouse_y[y] * c2;
if(dy < 0) dy += h;
if(dy < 0) dy = 0; else if (dy >= h) dy = h-1;
cache_y[y] = dy;
}
for(y=1; y < h-1; y++)
{
for(x=1; x < w-1; x++)
{
p = cache_y[y] * w + cache_x[x];
q = y * w + x;
Y[q] = magicmirrorbuf[0][p];
Cb[q] = magicmirrorbuf[1][p];
Cr[q] = magicmirrorbuf[2][p];
}
}
if( interpolate )
{
motionmap_interpolate_frame( frame, N__, n__ );
}
if( motion )
{
motionmap_store_frame(frame);
}
}
void neighbours3_apply( VJFrame *frame, int width, int height, int brush_size, int intensity_level, int mode )
{
int x,y;
const double intensity = intensity_level / 255.0;
uint8_t *Y = tmp_buf[0];
uint8_t *Y2 = tmp_buf[1];
uint8_t *dstY = frame->data[0];
uint8_t *dstCb = frame->data[1];
uint8_t *dstCr = frame->data[2];
// keep luma
vj_frame_copy1( frame->data[0],Y2, frame->len );
if(mode)
{
int strides[4] = { 0, frame->len, frame->len, 0 };
uint8_t *dest[4] = { NULL, chromacity[0], chromacity[1], NULL };
vj_frame_copy( frame->data, dest, strides );
}
// premultiply intensity map
for( y = 0 ; y < frame->len ; y ++ )
Y[y] = (uint8_t) ( (double)Y2[y] * intensity );
if(!mode)
{
for( y = 0; y < height; y ++ )
{
for( x = 0; x < width; x ++ )
{
*(dstY)++ = evaluate_pixel_b(
x,y,
brush_size,
intensity,
width,
height,
Y,
Y2
);
}
}
veejay_memset( frame->data[1], 128, frame->len );
veejay_memset( frame->data[2], 128, frame->len );
}
else
{
pixel_t tmp;
for( y = 0; y < height; y ++ )
{
for( x = 0; x < width; x ++ )
{
tmp = evaluate_pixel_bc(
x,y,
brush_size,
intensity,
width,
height,
Y,
Y2,
chromacity[0],
chromacity[1]
);
*(dstY++) = tmp.y;
*(dstCb++) = tmp.u;
*(dstCr++) = tmp.v;
}
}
}
}
