static int filter_get_image( mlt_frame frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
{
mlt_filter filter = (mlt_filter) mlt_frame_pop_service( frame );
mlt_properties properties = MLT_FILTER_PROPERTIES( filter );
mlt_position position = mlt_filter_get_position( filter, frame );
mlt_position length = mlt_filter_get_length2( filter, frame );
// Get the image
*format = mlt_image_yuv422;
int error = mlt_frame_get_image( frame, image, format, width, height, 1 );
// Only process if we have no error and a valid colour space
if ( error == 0 )
{
double level = 1.0;
// Use animated "level" property only if it has been set since init
char* level_property = mlt_properties_get( MLT_FILTER_PROPERTIES( filter ), "level" );
if ( level_property != NULL )
{
level = mlt_properties_anim_get_double( properties, "level", position, length );
}
else
{
// Get level using old "start,"end" mechanics
// Get the starting brightness level
level = fabs( mlt_properties_get_double( MLT_FILTER_PROPERTIES( filter ), "start" ) );
// If there is an end adjust gain to the range
if ( mlt_properties_get( MLT_FILTER_PROPERTIES( filter ), "end" ) != NULL )
{
// Determine the time position of this frame in the transition duration
double end = fabs( mlt_properties_get_double( MLT_FILTER_PROPERTIES( filter ), "end" ) );
level += ( end - level ) * mlt_filter_get_progress( filter, frame );
}
}
// Only process if level is something other than 1
if ( level != 1.0 )
{
int i = *width * *height + 1;
uint8_t *p = *image;
int32_t m = level * ( 1 << 16 );
int32_t n = 128 * ( ( 1 << 16 ) - m );
while ( --i )
{
p[0] = CLAMP( (p[0] * m) >> 16, 16, 235 );
p[1] = CLAMP( (p[1] * m + n) >> 16, 16, 240 );
p += 2;
}
}
static int filter_get_image( mlt_frame frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
{
mlt_filter filter = (mlt_filter) mlt_frame_pop_service( frame );
mlt_properties properties = MLT_FILTER_PROPERTIES( filter );
mlt_position position = mlt_frame_get_position( frame );
// Get the image
*format = mlt_image_yuv422;
int error = mlt_frame_get_image( frame, image, format, width, height, 0 );
// Only process if we have no error and a valid colour space
if ( error == 0 )
{
double factor = mlt_properties_get_double( properties, "start" );
mlt_position f_pos = mlt_filter_get_position( filter, frame );
mlt_position f_len = mlt_filter_get_length2( filter, frame );
int speed = mlt_properties_anim_get_int( properties, "speed", f_pos, f_len );
int deformX = mlt_properties_anim_get_int( properties, "deformX", f_pos, f_len );
int deformY = mlt_properties_anim_get_int( properties, "deformY", f_pos, f_len );
if ( mlt_properties_get( properties, "end" ) )
{
// Determine the time position of this frame in the transition duration
double end = fabs( mlt_properties_get_double( MLT_FILTER_PROPERTIES( filter ), "end" ) );
factor += ( end - factor ) * mlt_filter_get_progress( filter, frame );
}
// If animated property "wave" is set, use its value.
char* wave_property = mlt_properties_get( properties, "wave" );
if ( wave_property )
{
factor = mlt_properties_anim_get_double( properties, "wave", f_pos, f_len );
}
if (factor != 0)
{
int image_size = *width * (*height) * 2;
uint8_t *dst = mlt_pool_alloc (image_size);
DoWave(*image, *width, (*height), dst, position, speed, factor, deformX, deformY);
*image = dst;
mlt_frame_set_image( frame, *image, image_size, mlt_pool_release );
}
}
return error;
}
static int filter_get_image( mlt_frame frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
{
mlt_filter filter = (mlt_filter) mlt_frame_pop_service( frame );
mlt_properties properties = MLT_FILTER_PROPERTIES( filter );
mlt_position pos = mlt_filter_get_position( filter, frame );
mlt_position len = mlt_filter_get_length2( filter, frame );
*format = mlt_image_yuv422;
int error = mlt_frame_get_image( frame, image, format, width, height, 1 );
if ( error == 0 && *image )
{
int h = *height;
int w = *width;
double position = mlt_filter_get_progress( filter, frame );
srand(position*10000);
int noise = mlt_properties_anim_get_int( properties, "noise", pos, len );
double contrast = mlt_properties_anim_get_double( properties, "contrast", pos, len ) / 100.0;
double brightness = 127.0 * (mlt_properties_anim_get_double( properties, "brightness", pos, len ) -100.0 ) / 100.0;
int x = 0,y = 0,pix = 0;
for ( x = 0; x < w; x++ )
{
for( y = 0; y < h; y++ )
{
uint8_t* pixel = (*image + (y) * w * 2 + (x) * 2 );
if (*pixel > 20)
{
pix = MIN ( MAX ( ( (double)*pixel -127.0 ) * contrast + 127.0 + brightness , 0 ) , 255 ) ;
if ( noise > 0 ) pix -= ( rand() % noise - noise );
*pixel = MIN ( MAX ( pix , 0 ) , 255 );
}
}
}
}
return error;
}
static int filter_get_image( mlt_frame frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
{
// Pop the top of stack now
mlt_filter filter = mlt_frame_pop_service( frame );
// Get the image from the frame
*format = mlt_image_yuv422;
int error = mlt_frame_get_image( frame, image, format, width, height, 1 );
// Get the image from the frame
if ( error == 0 )
{
if ( filter != NULL )
{
// Get the filter properties
mlt_properties properties = MLT_FILTER_PROPERTIES( filter );
mlt_profile profile = mlt_service_profile( MLT_FILTER_SERVICE( filter ) );
// Structures for geometry
struct geometry_s result;
struct geometry_s start;
struct geometry_s end;
// Retrieve the position
float position = mlt_filter_get_progress( filter, frame );
// Now parse the geometries
geometry_parse( &start, NULL, mlt_properties_get( properties, "start" ), profile->width, profile->height );
geometry_parse( &end, &start, mlt_properties_get( properties, "end" ), profile->width, profile->height );
// Do the calculation
geometry_calculate( &result, &start, &end, position, *width, *height );
// Now actually render it
obscure_render( *image, *width, *height, result );
}
}
return error;
}
static int filter_get_image( mlt_frame frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
{
mlt_filter filter = (mlt_filter) mlt_frame_pop_service( frame );
mlt_properties properties = MLT_FILTER_PROPERTIES( filter );
mlt_position position = mlt_filter_get_position( filter, frame );
mlt_position length = mlt_filter_get_length2( filter, frame );
double level = 1.0;
// Use animated "level" property only if it has been set since init
char* level_property = mlt_properties_get( properties, "level" );
if ( level_property != NULL )
{
level = mlt_properties_anim_get_double( properties, "level", position, length );
}
else
{
// Get level using old "start,"end" mechanics
// Get the starting brightness level
level = fabs( mlt_properties_get_double( properties, "start" ) );
// If there is an end adjust gain to the range
if ( mlt_properties_get( properties, "end" ) != NULL )
{
// Determine the time position of this frame in the transition duration
double end = fabs( mlt_properties_get_double( properties, "end" ) );
level += ( end - level ) * mlt_filter_get_progress( filter, frame );
}
}
// Do not cause an image conversion unless there is real work to do.
if ( level != 1.0 )
*format = mlt_image_yuv422;
// Get the image
int error = mlt_frame_get_image( frame, image, format, width, height, 1 );
// Only process if we have no error.
if ( error == 0 )
{
// Only process if level is something other than 1
if ( level != 1.0 && *format == mlt_image_yuv422 )
{
int i = *width * *height + 1;
uint8_t *p = *image;
int32_t m = level * ( 1 << 16 );
int32_t n = 128 * ( ( 1 << 16 ) - m );
while ( --i )
{
p[0] = CLAMP( (p[0] * m) >> 16, 16, 235 );
p[1] = CLAMP( (p[1] * m + n) >> 16, 16, 240 );
p += 2;
}
}
// Process the alpha channel if requested.
if ( mlt_properties_get( properties, "alpha" ) )
{
double alpha = mlt_properties_anim_get_double( properties, "alpha", position, length );
alpha = alpha >= 0.0 ? alpha : level;
if ( alpha != 1.0 )
{
int32_t m = alpha * ( 1 << 16 );
int i = *width * *height + 1;
if ( *format == mlt_image_rgb24a ) {
uint8_t *p = *image + 3;
for ( ; --i; p += 4 )
p[0] = ( p[0] * m ) >> 16;
} else {
static int filter_get_image( mlt_frame frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
{
mlt_filter filter = (mlt_filter) mlt_frame_pop_service( frame );
mlt_properties properties = MLT_FILTER_PROPERTIES( filter );
mlt_position pos = mlt_filter_get_position( filter, frame );
mlt_position len = mlt_filter_get_length2( filter, frame );
*format = mlt_image_yuv422;
int error = mlt_frame_get_image( frame, image, format, width, height, 1 );
if ( error == 0 && *image )
{
int h = *height;
int w = *width;
int x = 0;
int y = 0;
double position = mlt_filter_get_progress( filter, frame );
srand( position * 10000);
int delta = mlt_properties_anim_get_int( properties, "delta", pos, len );
int every = mlt_properties_anim_get_int( properties, "every", pos, len );
int bdu = mlt_properties_anim_get_int( properties, "brightnessdelta_up", pos, len );
int bdd = mlt_properties_anim_get_int( properties, "brightnessdelta_down", pos, len );
int bevery = mlt_properties_anim_get_int( properties, "brightnessdelta_every", pos, len );
int udu = mlt_properties_anim_get_int( properties, "unevendevelop_up", pos, len );
int udd = mlt_properties_anim_get_int( properties, "unevendevelop_down", pos, len );
int uduration = mlt_properties_anim_get_int( properties, "unevendevelop_duration", pos, len );
int diffpic = 0;
if ( delta )
diffpic = rand() % delta * 2 - delta;
int brightdelta = 0;
if (( bdu + bdd ) != 0 )
brightdelta = rand() % (bdu + bdd) - bdd;
if ( rand() % 100 > every )
diffpic = 0;
if ( rand() % 100 > bevery)
brightdelta = 0;
int yend, ydiff;
int unevendevelop_delta = 0;
if ( uduration > 0 )
{
float uval = sinarr[ ( ((int)position) % uduration) * 100 / uduration ];
unevendevelop_delta = uval * ( uval > 0 ? udu : udd );
}
if ( diffpic <= 0 )
{
y = h;
yend = 0;
ydiff = -1;
}
else
{
y = 0;
yend = h;
ydiff = 1;
}
while( y != yend )
{
for ( x = 0; x < w; x++ )
{
uint8_t* pic = ( *image + y * w * 2 + x * 2 );
int newy = y + diffpic;
if ( newy > 0 && newy < h )
{
uint8_t oldval= *( pic + diffpic * w * 2 );
if ( ((int) oldval + brightdelta + unevendevelop_delta ) > 255 )
{
*pic=255;
}
else if ( ( (int) oldval + brightdelta + unevendevelop_delta ) <0 )
{
*pic=0;
}
else
{
*pic = oldval + brightdelta + unevendevelop_delta;
}
*( pic + 1 ) =* ( pic + diffpic * w * 2 + 1 );
}
else
{
*pic = 0;
}
}
y += ydiff;
}
}
return error;
}
static mlt_frame filter_process( mlt_filter filter, mlt_frame frame )
{
mlt_properties filter_props = MLT_FILTER_PROPERTIES( filter );
mlt_properties instance_props = mlt_frame_unique_properties( frame, MLT_FILTER_SERVICE( filter ) );
double gain = 1.0; // no adjustment
// Parse the gain property
if ( mlt_properties_get( filter_props, "gain" ) != NULL )
{
char *p = mlt_properties_get( filter_props, "gain" );
if ( strncaseeq( p, "normalise", 9 ) )
mlt_properties_set( filter_props, "normalise", "" );
else
{
if ( strcmp( p, "" ) != 0 )
gain = strtod( p, &p );
while ( isspace( *p ) )
p++;
/* check if "dB" is given after number */
if ( strncaseeq( p, "db", 2 ) )
gain = DBFSTOAMP( gain );
else
gain = fabs( gain );
// If there is an end adjust gain to the range
if ( mlt_properties_get( filter_props, "end" ) != NULL )
{
double end = -1;
char *p = mlt_properties_get( filter_props, "end" );
if ( strcmp( p, "" ) != 0 )
end = strtod( p, &p );
while ( isspace( *p ) )
p++;
/* check if "dB" is given after number */
if ( strncaseeq( p, "db", 2 ) )
end = DBFSTOAMP( end );
else
end = fabs( end );
if ( end != -1 )
gain += ( end - gain ) * mlt_filter_get_progress( filter, frame );
}
}
}
mlt_properties_set_double( instance_props, "gain", gain );
// Parse the maximum gain property
if ( mlt_properties_get( filter_props, "max_gain" ) != NULL )
{
char *p = mlt_properties_get( filter_props, "max_gain" );
double gain = strtod( p, &p ); // 0 = no max
while ( isspace( *p ) )
p++;
/* check if "dB" is given after number */
if ( strncaseeq( p, "db", 2 ) )
gain = DBFSTOAMP( gain );
else
gain = fabs( gain );
mlt_properties_set_double( instance_props, "max_gain", gain );
}
// Parse the limiter property
if ( mlt_properties_get( filter_props, "limiter" ) != NULL )
{
char *p = mlt_properties_get( filter_props, "limiter" );
double level = 0.5; /* -6dBFS */
if ( strcmp( p, "" ) != 0 )
level = strtod( p, &p);
while ( isspace( *p ) )
p++;
/* check if "dB" is given after number */
if ( strncaseeq( p, "db", 2 ) )
{
if ( level > 0 )
level = -level;
level = DBFSTOAMP( level );
}
else
{
if ( level < 0 )
level = -level;
}
mlt_properties_set_double( instance_props, "limiter", level );
}
// Parse the normalise property
if ( mlt_properties_get( filter_props, "normalise" ) != NULL )
{
char *p = mlt_properties_get( filter_props, "normalise" );
double amplitude = 0.2511886431509580; /* -12dBFS */
if ( strcmp( p, "" ) != 0 )
amplitude = strtod( p, &p);
while ( isspace( *p ) )
p++;
/* check if "dB" is given after number */
if ( strncaseeq( p, "db", 2 ) )
{
if ( amplitude > 0 )
amplitude = -amplitude;
amplitude = DBFSTOAMP( amplitude );
}
else
{
if ( amplitude < 0 )
amplitude = -amplitude;
if ( amplitude > 1.0 )
amplitude = 1.0;
}
// If there is an end adjust gain to the range
if ( mlt_properties_get( filter_props, "end" ) != NULL )
{
amplitude *= mlt_filter_get_progress( filter, frame );
}
mlt_properties_set_int( instance_props, "normalise", 1 );
mlt_properties_set_double( instance_props, "amplitude", amplitude );
}
// Parse the window property and allocate smoothing buffer if needed
int window = mlt_properties_get_int( filter_props, "window" );
if ( mlt_properties_get( filter_props, "smooth_buffer" ) == NULL && window > 1 )
{
// Create a smoothing buffer for the calculated "max power" of frame of audio used in normalisation
double *smooth_buffer = (double*) calloc( window, sizeof( double ) );
int i;
for ( i = 0; i < window; i++ )
smooth_buffer[ i ] = -1.0;
mlt_properties_set_data( filter_props, "smooth_buffer", smooth_buffer, 0, free, NULL );
}
// Push the filter onto the stack
mlt_frame_push_audio( frame, filter );
// Override the get_audio method
mlt_frame_push_audio( frame, filter_get_audio );
return frame;
}
static int filter_get_image( mlt_frame frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
{
mlt_filter filter = (mlt_filter) mlt_frame_pop_service( frame );
mlt_properties properties = MLT_FILTER_PROPERTIES( filter );
mlt_position pos = mlt_filter_get_position( filter, frame );
mlt_position len = mlt_filter_get_length2( filter, frame );
int maxdia = mlt_properties_anim_get_int( properties, "maxdiameter", pos, len );
int maxcount = mlt_properties_anim_get_int( properties, "maxcount", pos, len );
*format = mlt_image_yuv422;
int error = mlt_frame_get_image( frame, image, format, width, height, 1 );
// Load svg
char *factory = mlt_properties_get( properties, "factory" );
char temp[1204] = "";
sprintf( temp, "%s/oldfilm/", mlt_environment( "MLT_DATA" ) );
mlt_properties direntries = mlt_properties_new();
mlt_properties_dir_list( direntries, temp,"dust*.svg",1 );
if (!maxcount)
return 0;
double position = mlt_filter_get_progress( filter, frame );
srand( position * 10000 );
mlt_service_lock( MLT_FILTER_SERVICE( filter ) );
int im = rand() % maxcount;
int piccount = mlt_properties_count( direntries );
while ( im-- && piccount )
{
int picnum = rand() % piccount;
int y1 = rand() % *height;
int x1 = rand() % *width;
char resource[1024] = "";
char savename[1024] = "", savename1[1024] = "", cachedy[100];
int dx = ( *width * maxdia / 100);
int luma_width, luma_height;
uint8_t *luma_image = NULL;
uint8_t *alpha = NULL;
int updown = rand() % 2;
int mirror = rand() % 2;
sprintf( resource, "%s", mlt_properties_get_value(direntries,picnum) );
sprintf( savename, "cache-%d-%d", picnum,dx );
sprintf( savename1, "cache-alpha-%d-%d", picnum, dx );
sprintf( cachedy, "cache-dy-%d-%d", picnum,dx );
luma_image = mlt_properties_get_data( properties , savename , NULL );
alpha = mlt_properties_get_data( properties , savename1 , NULL );
if ( luma_image == NULL || alpha == NULL )
{
mlt_profile profile = mlt_service_profile( MLT_FILTER_SERVICE( filter ) );
mlt_producer producer = mlt_factory_producer( profile, factory, resource );
if ( producer != NULL )
{
mlt_properties producer_properties = MLT_PRODUCER_PROPERTIES( producer );
mlt_properties_set( producer_properties, "eof", "loop" );
mlt_frame luma_frame = NULL;
if ( mlt_service_get_frame( MLT_PRODUCER_SERVICE( producer ), &luma_frame, 0 ) == 0 )
{
mlt_image_format luma_format = mlt_image_yuv422;
luma_width = dx;
luma_height = luma_width * mlt_properties_get_int( MLT_FRAME_PROPERTIES ( luma_frame ) , "height" ) / mlt_properties_get_int( MLT_FRAME_PROPERTIES ( luma_frame ) , "width" );
mlt_properties_set( MLT_FRAME_PROPERTIES( luma_frame ), "rescale.interp", "best" );// none/nearest/tiles/hyper
mlt_frame_get_image( luma_frame, &luma_image, &luma_format, &luma_width, &luma_height, 0 );
alpha = mlt_frame_get_alpha_mask (luma_frame );
uint8_t* savealpha = mlt_pool_alloc( luma_width * luma_height );
uint8_t* savepic = mlt_pool_alloc( luma_width * luma_height * 2);
if ( savealpha && savepic )
{
memcpy( savealpha, alpha , luma_width * luma_height );
memcpy( savepic, luma_image , luma_width * luma_height * 2 );
mlt_properties_set_data( properties, savename, savepic, luma_width * luma_height * 2, mlt_pool_release, NULL );
mlt_properties_set_data( properties, savename1, savealpha, luma_width * luma_height, mlt_pool_release, NULL );
mlt_properties_set_int( properties, cachedy, luma_height );
overlay_image( *image, *width, *height, luma_image, luma_width, luma_height, alpha, x1, y1, updown, mirror );
}
else
{
if ( savealpha )
mlt_pool_release( savealpha );
if ( savepic )
mlt_pool_release( savepic );
}
mlt_frame_close( luma_frame );
}
mlt_producer_close( producer );
}
}
else
{
overlay_image ( *image, *width, *height, luma_image, dx, mlt_properties_get_int ( properties, cachedy ), alpha, x1, y1, updown, mirror );
}
}
mlt_service_unlock( MLT_FILTER_SERVICE( filter ) );
if (piccount>0 )
return 0;
if ( error == 0 && *image )
{
int h = *height;
int w = *width;
int im = rand() % maxcount;
while ( im-- )
{
int type = im % 2;
int y1 = rand() % h;
int x1 = rand() % w;
int dx = rand() % maxdia;
int dy = rand() % maxdia;
int x=0, y=0;
double v = 0.0;
for ( x = -dx ; x < dx ; x++ )
{
for ( y = -dy ; y < dy ; y++ )
{
if ( x1 + x < w && x1 + x > 0 && y1 + y < h && y1 + y > 0 ){
uint8_t *pix = *image + (y+y1) * w * 2 + (x + x1) * 2;
v=pow((double) x /(double)dx * 5.0, 2.0) + pow((double)y / (double)dy * 5.0, 2.0);
if (v>10)
v=10;
v = 1.0 - ( v / 10.0 );
switch(type)
{
case 0:
*pix -= (*pix) * v;
break;
case 1:
*pix += ( 255-*pix ) * v;
break;
}
}
}
}
}
}
return error;
}
