int GlslManager::render_frame_texture(mlt_service service, mlt_frame frame, int width, int height, uint8_t **image)
{
EffectChain* chain = get_chain( service );
if (!chain) return 1;
glsl_fbo fbo = get_fbo( width, height );
if (!fbo) return 1;
glsl_texture texture = get_texture( width, height, GL_RGBA );
if (!texture) {
release_fbo( fbo );
return 1;
}
glBindFramebuffer( GL_FRAMEBUFFER, fbo->fbo );
check_error();
glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture->texture, 0 );
check_error();
glBindFramebuffer( GL_FRAMEBUFFER, 0 );
check_error();
render_fbo( service, chain, fbo->fbo, width, height );
glFinish();
check_error();
glBindFramebuffer( GL_FRAMEBUFFER, 0 );
check_error();
release_fbo( fbo );
*image = (uint8_t*) &texture->texture;
mlt_frame_set_image( frame, *image, 0, NULL );
mlt_properties_set_data( MLT_FRAME_PROPERTIES(frame), "movit.convert.texture", texture, 0,
(mlt_destructor) GlslManager::release_texture, NULL );
return 0;
}
static void add_clock_to_frame( mlt_producer producer, mlt_frame frame, time_info* info )
{
mlt_profile profile = mlt_service_profile( MLT_PRODUCER_SERVICE( producer ) );
mlt_properties producer_properties = MLT_PRODUCER_PROPERTIES( producer );
uint8_t* image = NULL;
mlt_image_format format = mlt_image_rgb24a;
int size = 0;
int width = profile->width;
int height = profile->height;
int line_width = LINE_WIDTH_RATIO * (width > height ? height : width) / 100;
int radius = (width > height ? height : width) / 2;
char* direction = mlt_properties_get( producer_properties, "direction" );
int clock_angle = 0;
mlt_frame_get_image( frame, &image, &format, &width, &height, 1 );
// Calculate the angle for the clock.
int frames = info->frames;
if( !strcmp( direction, "down" ) )
{
frames = info->fps - info->frames - 1;
}
clock_angle = (frames + 1) * 360 / info->fps;
draw_clock( image, profile, clock_angle, line_width );
draw_cross( image, profile, line_width );
draw_ring( image, profile, ( radius * OUTER_RING_RATIO ) / 100, line_width );
draw_ring( image, profile, ( radius * INNER_RING_RATIO ) / 100, line_width );
size = mlt_image_format_size( format, width, height, NULL );
mlt_frame_set_image( frame, image, size, mlt_pool_release );
}
static int get_image( mlt_frame frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
{
context cx = mlt_frame_pop_service( frame );
mlt_frame nested_frame = mlt_frame_pop_service( frame );
*width = cx->profile->width;
*height = cx->profile->height;
int result = mlt_frame_get_image( nested_frame, image, format, width, height, writable );
// Allocate the image
int size = mlt_image_format_size( *format, *width, *height, NULL );
uint8_t *new_image = mlt_pool_alloc( size );
// Update the frame
mlt_properties properties = mlt_frame_properties( frame );
mlt_frame_set_image( frame, new_image, size, mlt_pool_release );
memcpy( new_image, *image, size );
mlt_properties_set( properties, "progressive", mlt_properties_get( MLT_FRAME_PROPERTIES(nested_frame), "progressive" ) );
*image = new_image;
// Copy the alpha channel
uint8_t *alpha = mlt_properties_get_data( MLT_FRAME_PROPERTIES( nested_frame ), "alpha", &size );
if ( alpha && size > 0 )
{
new_image = mlt_pool_alloc( size );
memcpy( new_image, alpha, size );
mlt_frame_set_alpha( frame, new_image, size, mlt_pool_release );
}
return result;
}
static int producer_get_image( mlt_frame self, uint8_t **buffer, mlt_image_format *format, int *width, int *height, int writable )
{
uint8_t *data = NULL;
int size = 0;
mlt_properties properties = MLT_FRAME_PROPERTIES( self );
mlt_frame frame = mlt_frame_pop_service( self );
mlt_properties frame_properties = MLT_FRAME_PROPERTIES( frame );
mlt_properties_set( frame_properties, "rescale.interp", mlt_properties_get( properties, "rescale.interp" ) );
mlt_properties_set_int( frame_properties, "resize_alpha", mlt_properties_get_int( properties, "resize_alpha" ) );
mlt_properties_set_int( frame_properties, "distort", mlt_properties_get_int( properties, "distort" ) );
mlt_properties_set_int( frame_properties, "consumer_deinterlace", mlt_properties_get_int( properties, "consumer_deinterlace" ) );
mlt_properties_set( frame_properties, "deinterlace_method", mlt_properties_get( properties, "deinterlace_method" ) );
mlt_properties_set_int( frame_properties, "consumer_tff", mlt_properties_get_int( properties, "consumer_tff" ) );
mlt_frame_get_image( frame, buffer, format, width, height, writable );
mlt_frame_set_image( self, *buffer, 0, NULL );
mlt_properties_set_int( properties, "width", *width );
mlt_properties_set_int( properties, "height", *height );
mlt_properties_set_int( properties, "format", *format );
mlt_properties_set_double( properties, "aspect_ratio", mlt_frame_get_aspect_ratio( frame ) );
mlt_properties_set_int( properties, "progressive", mlt_properties_get_int( frame_properties, "progressive" ) );
mlt_properties_set_int( properties, "distort", mlt_properties_get_int( frame_properties, "distort" ) );
mlt_properties_set_int( properties, "colorspace", mlt_properties_get_int( frame_properties, "colorspace" ) );
mlt_properties_set_int( properties, "force_full_luma", mlt_properties_get_int( frame_properties, "force_full_luma" ) );
mlt_properties_set_int( properties, "top_field_first", mlt_properties_get_int( frame_properties, "top_field_first" ) );
mlt_properties_set_data( properties, "movit.convert.fence",
mlt_properties_get_data( frame_properties, "movit.convert.fence", NULL ),
0, NULL, NULL );
data = mlt_frame_get_alpha_mask( frame );
mlt_properties_get_data( frame_properties, "alpha", &size );
mlt_frame_set_alpha( self, data, size, NULL );
self->convert_image = frame->convert_image;
self->convert_audio = frame->convert_audio;
return 0;
}
static int producer_get_image( mlt_frame frame, uint8_t** image, mlt_image_format* format, int* width, int* height, int writable )
{
mlt_producer producer = mlt_frame_pop_service( frame );
mlt_frame bg_frame = NULL;
mlt_frame text_frame = NULL;
int error = 1;
int size = 0;
char* background = mlt_properties_get( MLT_PRODUCER_PROPERTIES( producer ), "background" );
time_info info;
mlt_service_lock( MLT_PRODUCER_SERVICE( producer ) );
get_time_info( producer, frame, &info );
bg_frame = get_background_frame( producer );
if( !strcmp( background, "clock" ) )
{
add_clock_to_frame( producer, bg_frame, &info );
}
text_frame = get_text_frame( producer, &info );
add_text_to_bg( producer, bg_frame, text_frame );
if( bg_frame )
{
// Get the image from the background frame.
error = mlt_frame_get_image( bg_frame, image, format, width, height, writable );
size = mlt_image_format_size( *format, *width, *height, NULL );
// Detach the image from the bg_frame so it is not released.
mlt_frame_set_image( bg_frame, *image, size, NULL );
// Attach the image to the input frame.
mlt_frame_set_image( frame, *image, size, mlt_pool_release );
mlt_frame_close( bg_frame );
}
if( text_frame )
{
mlt_frame_close( text_frame );
}
mlt_service_unlock( MLT_PRODUCER_SERVICE( producer ) );
return error;
}
static int producer_get_image( mlt_frame frame, uint8_t **buffer, mlt_image_format *format, int *width, int *height, int writable )
{
/* Obtain properties of frame */
mlt_properties properties = MLT_FRAME_PROPERTIES( frame );
/* Obtain the producer for this frame */
producer_ktitle this = mlt_properties_get_data( properties, "producer_kdenlivetitle", NULL );
/* Obtain properties of producer */
mlt_properties producer_props = MLT_PRODUCER_PROPERTIES( &this->parent );
*width = mlt_properties_get_int( properties, "rescale_width" );
*height = mlt_properties_get_int( properties, "rescale_height" );
mlt_service_lock( MLT_PRODUCER_SERVICE( &this->parent ) );
/* Allocate the image */
*format = mlt_image_rgb24a;
mlt_position time = mlt_producer_position( &this->parent ) + mlt_producer_get_in( &this->parent );
if ( mlt_properties_get_int( producer_props, "force_reload" ) ) {
if (mlt_properties_get_int( producer_props, "force_reload" ) > 1) read_xml(producer_props);
mlt_properties_set_int( producer_props, "force_reload", 0 );
drawKdenliveTitle( this, frame, *width, *height, time, 1);
}
else drawKdenliveTitle( this, frame, *width, *height, time, 0);
// Get width and height (may have changed during the refresh)
*width = mlt_properties_get_int( properties, "width" );
*height = mlt_properties_get_int( properties, "height" );
if ( this->current_image )
{
// Clone the image and the alpha
int image_size = this->current_width * ( this->current_height ) * 4;
uint8_t *image_copy = mlt_pool_alloc( image_size );
memcpy( image_copy, this->current_image, image_size );
// Now update properties so we free the copy after
mlt_frame_set_image( frame, image_copy, image_size, mlt_pool_release );
// We're going to pass the copy on
*buffer = image_copy;
mlt_log_debug( MLT_PRODUCER_SERVICE( &this->parent ), "width:%d height:%d %s\n", *width, *height, mlt_image_format_name( *format ) );
}
mlt_service_unlock( MLT_PRODUCER_SERVICE( &this->parent ) );
return 0;
}
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 producerGetImage(mlt_frame frame, uint8_t **buffer, mlt_image_format *format, int *width, int *height, int /*writable*/) {
int error = 0;
mlt_properties properties = MLT_FRAME_PROPERTIES(frame);
mlt_producer producer = (mlt_producer)mlt_properties_get_data(properties, kWebVfxProducerPropertyName, NULL);
mlt_properties producer_props = MLT_PRODUCER_PROPERTIES(producer);
int size;
int bpp;
bool hasTransparency = false;
{
MLTWebVfx::ServiceLocker locker(MLT_PRODUCER_SERVICE(producer));
if (!locker.initialize(*width, *height))
return 1;
if (mlt_properties_get_int( producer_props, "transparent") ) {
*format = mlt_image_rgb24a;
hasTransparency = true;
}
else {
*format = mlt_image_rgb24;
}
// Get bpp from image format
mlt_image_format_size(*format, 0, 0, &bpp);
size = *width * *height * bpp;
*buffer = (uint8_t*)mlt_pool_alloc(size);
// When not using transparency, this will make the background black...
memset( *buffer, 255, size );
WebVfx::Image outputImage(*buffer, *width, *height, size, hasTransparency);
locker.getManager()->render(&outputImage,
mlt_properties_get_position(properties, kWebVfxPositionPropertyName),
mlt_producer_get_length(producer), hasTransparency);
}
mlt_frame_set_image(frame, *buffer, size, mlt_pool_release);
if (hasTransparency) {
// Create the alpha channel
int alpha_size = *width * *height;
uint8_t *alpha = (uint8_t *)mlt_pool_alloc( alpha_size );
// Initialise the alpha
memset( alpha, 255, alpha_size );
mlt_frame_set_alpha(frame, alpha, alpha_size, mlt_pool_release);
}
return error;
}
static uint8_t *frame_resize_image( mlt_frame frame, int owidth, int oheight, int bpp )
{
// Get properties
mlt_properties properties = MLT_FRAME_PROPERTIES( frame );
// Get the input image, width and height
uint8_t *input = mlt_properties_get_data( properties, "image", NULL );
uint8_t *alpha = mlt_frame_get_alpha( frame );
int alpha_size = 0;
mlt_properties_get_data( properties, "alpha", &alpha_size );
int iwidth = mlt_properties_get_int( properties, "width" );
int iheight = mlt_properties_get_int( properties, "height" );
// If width and height are correct, don't do anything
if ( iwidth < owidth || iheight < oheight )
{
uint8_t alpha_value = mlt_properties_get_int( properties, "resize_alpha" );
// Create the output image
uint8_t *output = mlt_pool_alloc( owidth * ( oheight + 1 ) * bpp );
// Call the generic resize
resize_image( output, owidth, oheight, input, iwidth, iheight, bpp );
// Now update the frame
mlt_frame_set_image( frame, output, owidth * ( oheight + 1 ) * bpp, mlt_pool_release );
// We should resize the alpha too
if ( alpha && alpha_size >= iwidth * iheight )
{
alpha = resize_alpha( alpha, owidth, oheight, iwidth, iheight, alpha_value );
if ( alpha )
mlt_frame_set_alpha( frame, alpha, owidth * oheight, mlt_pool_release );
}
// Return the output
return output;
}
// No change, return input
return input;
}
static int producer_get_image( mlt_frame frame, uint8_t** buffer, mlt_image_format* format, int* width, int* height, int writable )
{
mlt_properties frame_properties = MLT_FRAME_PROPERTIES( frame );
mlt_producer producer = static_cast<mlt_producer>( mlt_properties_get_data( frame_properties, "_producer_qtext", NULL ) );
mlt_properties producer_properties = MLT_PRODUCER_PROPERTIES( producer );
int img_size = 0;
int alpha_size = 0;
uint8_t* alpha = NULL;
QImage* qImg = static_cast<QImage*>( mlt_properties_get_data( producer_properties, "_qimg", NULL ) );
mlt_service_lock( MLT_PRODUCER_SERVICE( producer ) );
// Regenerate the qimage if necessary
if( check_qimage( frame_properties ) == true )
{
generate_qimage( frame_properties );
}
*format = mlt_image_rgb24a;
*width = qImg->width();
*height = qImg->height();
// Allocate and fill the image buffer
img_size = mlt_image_format_size( *format, *width, *height, NULL );
*buffer = static_cast<uint8_t*>( mlt_pool_alloc( img_size ) );
copy_qimage_to_mlt_image( qImg, *buffer );
mlt_service_unlock( MLT_PRODUCER_SERVICE( producer ) );
// Allocate and fill the alpha buffer
alpha_size = *width * *height;
alpha = static_cast<uint8_t*>( mlt_pool_alloc( alpha_size ) );
copy_image_to_alpha( *buffer, alpha, *width, *height );
// Update the frame
mlt_frame_set_image( frame, *buffer, img_size, mlt_pool_release );
mlt_frame_set_alpha( frame, alpha, alpha_size, mlt_pool_release );
mlt_properties_set_int( frame_properties, "width", *width );
mlt_properties_set_int( frame_properties, "height", *height );
return 0;
}
static int get_image(mlt_frame frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable)
{
mlt_transition transition = mlt_frame_pop_service(frame);
*format = mlt_frame_pop_service_int(frame);
int error = mlt_frame_get_image(frame, image, format, width, height, writable);
if (!error) {
mlt_properties properties = MLT_FRAME_PROPERTIES(frame);
mlt_frame clone = mlt_properties_get_data(properties, "mask frame", NULL);
if (clone) {
mlt_frame_push_get_image(frame, dummy_get_image);
mlt_service_lock(MLT_TRANSITION_SERVICE(transition));
mlt_transition_process(transition, clone, frame);
mlt_service_unlock(MLT_TRANSITION_SERVICE(transition));
error = mlt_frame_get_image(clone, image, format, width, height, writable);
if (!error) {
int size = mlt_image_format_size(*format, *width, *height, NULL);
mlt_frame_set_image(frame, *image, size, NULL);
}
}
}
return error;
}
static int producer_get_image( mlt_frame frame, uint8_t **buffer, mlt_image_format *format, int *width, int *height, int writable )
{
// Obtain properties of frame
mlt_properties properties = MLT_FRAME_PROPERTIES( frame );
// Obtain the producer for this frame
mlt_producer producer = mlt_properties_get_data( properties, "producer_frei0r", NULL );
// Obtain properties of producer
mlt_properties producer_props = MLT_PRODUCER_PROPERTIES( producer );
// Choose suitable out values if nothing specific requested
if ( *width <= 0 )
*width = mlt_service_profile( MLT_PRODUCER_SERVICE(producer) )->width;
if ( *height <= 0 )
*height = mlt_service_profile( MLT_PRODUCER_SERVICE(producer) )->height;
// Allocate the image
int size = *width * ( *height + 1 ) * 4;
// Allocate the image
*buffer = mlt_pool_alloc( size );
// Update the frame
mlt_frame_set_image( frame, *buffer, size, mlt_pool_release );
*format = mlt_image_rgb24a;
if ( *buffer != NULL )
{
double position = mlt_frame_get_position( frame );
mlt_profile profile = mlt_service_profile( MLT_PRODUCER_SERVICE( producer ) );
double time = position / mlt_profile_fps( profile );
process_frei0r_item( MLT_PRODUCER_SERVICE(producer), position, time, producer_props, frame, buffer, width, height );
}
return 0;
}
static int producer_get_image( mlt_frame frame, uint8_t **buffer, mlt_image_format *format, int *width, int *height, int writable )
{
// Obtain properties of frame
mlt_properties properties = MLT_FRAME_PROPERTIES( frame );
// Obtain the producer for this frame
mlt_producer producer = mlt_properties_get_data( properties, "producer_colour", NULL );
mlt_service_lock( MLT_PRODUCER_SERVICE( producer ) );
// Obtain properties of producer
mlt_properties producer_props = MLT_PRODUCER_PROPERTIES( producer );
// Get the current and previous colour strings
char *now = mlt_properties_get( producer_props, "resource" );
char *then = mlt_properties_get( producer_props, "_resource" );
// Get the current image and dimensions cached in the producer
int size = 0;
uint8_t *image = mlt_properties_get_data( producer_props, "image", &size );
int current_width = mlt_properties_get_int( producer_props, "_width" );
int current_height = mlt_properties_get_int( producer_props, "_height" );
mlt_image_format current_format = mlt_properties_get_int( producer_props, "_format" );
// Parse the colour
if ( now && strchr( now, '/' ) )
{
now = strdup( strrchr( now, '/' ) + 1 );
mlt_properties_set( producer_props, "resource", now );
free( now );
now = mlt_properties_get( producer_props, "resource" );
}
mlt_color color = mlt_properties_get_color( producer_props, "resource" );
if ( mlt_properties_get( producer_props, "mlt_image_format") )
*format = mlt_image_format_id( mlt_properties_get( producer_props, "mlt_image_format") );
// Choose suitable out values if nothing specific requested
if ( *format == mlt_image_none || *format == mlt_image_glsl )
*format = mlt_image_rgb24a;
if ( *width <= 0 )
*width = mlt_service_profile( MLT_PRODUCER_SERVICE(producer) )->width;
if ( *height <= 0 )
*height = mlt_service_profile( MLT_PRODUCER_SERVICE(producer) )->height;
// Choose default image format if specific request is unsupported
if (*format!=mlt_image_yuv420p && *format!=mlt_image_yuv422 && *format!=mlt_image_rgb24 && *format!= mlt_image_glsl && *format!= mlt_image_glsl_texture)
*format = mlt_image_rgb24a;
// See if we need to regenerate
if ( !now || ( then && strcmp( now, then ) ) || *width != current_width || *height != current_height || *format != current_format )
{
// Color the image
int i = *width * *height + 1;
int bpp;
// Allocate the image
size = mlt_image_format_size( *format, *width, *height, &bpp );
uint8_t *p = image = mlt_pool_alloc( size );
// Update the producer
mlt_properties_set_data( producer_props, "image", image, size, mlt_pool_release, NULL );
mlt_properties_set_int( producer_props, "_width", *width );
mlt_properties_set_int( producer_props, "_height", *height );
mlt_properties_set_int( producer_props, "_format", *format );
mlt_properties_set( producer_props, "_resource", now );
mlt_service_unlock( MLT_PRODUCER_SERVICE( producer ) );
switch ( *format )
{
case mlt_image_yuv420p:
{
int plane_size = *width * *height;
uint8_t y, u, v;
RGB2YUV_601_SCALED( color.r, color.g, color.b, y, u, v );
memset(p + 0, y, plane_size);
memset(p + plane_size, u, plane_size/4);
memset(p + plane_size + plane_size/4, v, plane_size/4);
mlt_properties_set_int( properties, "colorspace", 601 );
break;
}
case mlt_image_yuv422:
{
int uneven = *width % 2;
int count = ( *width - uneven ) / 2 + 1;
uint8_t y, u, v;
RGB2YUV_601_SCALED( color.r, color.g, color.b, y, u, v );
i = *height + 1;
while ( --i )
{
int j = count;
while ( --j )
{
*p ++ = y;
*p ++ = u;
*p ++ = y;
*p ++ = v;
}
if ( uneven )
{
*p ++ = y;
*p ++ = u;
}
}
mlt_properties_set_int( properties, "colorspace", 601 );
break;
}
case mlt_image_rgb24:
while ( --i )
{
*p ++ = color.r;
*p ++ = color.g;
*p ++ = color.b;
}
break;
case mlt_image_glsl:
case mlt_image_glsl_texture:
memset(p, 0, size);
break;
case mlt_image_rgb24a:
while ( --i )
{
*p ++ = color.r;
*p ++ = color.g;
*p ++ = color.b;
*p ++ = color.a;
}
break;
default:
mlt_log_error( MLT_PRODUCER_SERVICE( producer ),
"invalid image format %s\n", mlt_image_format_name( *format ) );
}
}
else
{
mlt_service_unlock( MLT_PRODUCER_SERVICE( producer ) );
}
// Create the alpha channel
int alpha_size = 0;
uint8_t *alpha = NULL;
// Initialise the alpha
if (color.a < 255 || *format == mlt_image_rgb24a) {
alpha_size = *width * *height;
alpha = mlt_pool_alloc( alpha_size );
if ( alpha )
memset( alpha, color.a, alpha_size );
else
alpha_size = 0;
}
// Clone our image
if (buffer && image && size > 0) {
*buffer = mlt_pool_alloc( size );
memcpy( *buffer, image, size );
}
// Now update properties so we free the copy after
mlt_frame_set_image( frame, *buffer, size, mlt_pool_release );
mlt_frame_set_alpha( frame, alpha, alpha_size, mlt_pool_release );
mlt_properties_set_double( properties, "aspect_ratio", mlt_properties_get_double( producer_props, "aspect_ratio" ) );
mlt_properties_set_int( properties, "meta.media.width", *width );
mlt_properties_set_int( properties, "meta.media.height", *height );
return 0;
}
static int framebuffer_get_image( mlt_frame frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
{
// Get the filter object and properties
mlt_producer producer = mlt_frame_pop_service( frame );
int index = ( int )mlt_frame_pop_service( frame );
mlt_properties properties = MLT_PRODUCER_PROPERTIES( producer );
mlt_service_lock( MLT_PRODUCER_SERVICE( producer ) );
// Frame properties objects
mlt_properties frame_properties = MLT_FRAME_PROPERTIES( frame );
mlt_frame first_frame = mlt_properties_get_data( properties, "first_frame", NULL );
// Get producer parameters
int strobe = mlt_properties_get_int( properties, "strobe" );
int freeze = mlt_properties_get_int( properties, "freeze" );
int freeze_after = mlt_properties_get_int( properties, "freeze_after" );
int freeze_before = mlt_properties_get_int( properties, "freeze_before" );
int in = mlt_properties_get_position( properties, "in" );
// Determine the position
mlt_position first_position = (first_frame != NULL) ? mlt_frame_get_position( first_frame ) : -1;
mlt_position need_first = freeze;
if ( !freeze || freeze_after || freeze_before )
{
double prod_speed = mlt_properties_get_double( properties, "_speed" );
double actual_position = in + prod_speed * (double) mlt_producer_position( producer );
if ( mlt_properties_get_int( properties, "reverse" ) )
actual_position = mlt_producer_get_playtime( producer ) - actual_position;
if ( strobe < 2 )
{
need_first = floor( actual_position );
}
else
{
// Strobe effect wanted, calculate frame position
need_first = floor( actual_position );
need_first -= need_first % strobe;
}
if ( freeze )
{
if ( freeze_after && need_first > freeze ) need_first = freeze;
else if ( freeze_before && need_first < freeze ) need_first = freeze;
}
}
// Determine output buffer size
*width = mlt_properties_get_int( frame_properties, "width" );
*height = mlt_properties_get_int( frame_properties, "height" );
int size = mlt_image_format_size( *format, *width, *height, NULL );
// Get output buffer
int buffersize = 0;
int alphasize = *width * *height;
uint8_t *output = mlt_properties_get_data( properties, "output_buffer", &buffersize );
uint8_t *output_alpha = mlt_properties_get_data( properties, "output_alpha", NULL );
if( buffersize == 0 || buffersize != size )
{
// invalidate cached frame
first_position = -1;
}
if ( need_first != first_position )
{
// invalidate cached frame
first_position = -1;
// Bust the cached frame
mlt_properties_set_data( properties, "first_frame", NULL, 0, NULL, NULL );
first_frame = NULL;
}
if ( output && first_position != -1 ) {
// Using the cached frame
uint8_t *image_copy = mlt_pool_alloc( size );
memcpy( image_copy, output, size );
uint8_t *alpha_copy = mlt_pool_alloc( alphasize );
memcpy( alpha_copy, output_alpha, alphasize );
// Set the output image
*image = image_copy;
mlt_frame_set_image( frame, image_copy, size, mlt_pool_release );
mlt_frame_set_alpha( frame, alpha_copy, alphasize, mlt_pool_release );
*width = mlt_properties_get_int( properties, "_output_width" );
*height = mlt_properties_get_int( properties, "_output_height" );
*format = mlt_properties_get_int( properties, "_output_format" );
mlt_service_unlock( MLT_PRODUCER_SERVICE( producer ) );
return 0;
}
// Get the cached frame
if ( first_frame == NULL )
{
// Get the frame to cache from the real producer
mlt_producer real_producer = mlt_properties_get_data( properties, "producer", NULL );
// Seek the producer to the correct place
mlt_producer_seek( real_producer, need_first );
// Get the frame
mlt_service_get_frame( MLT_PRODUCER_SERVICE( real_producer ), &first_frame, index );
// Cache the frame
mlt_properties_set_data( properties, "first_frame", first_frame, 0, ( mlt_destructor )mlt_frame_close, NULL );
}
mlt_properties first_frame_properties = MLT_FRAME_PROPERTIES( first_frame );
// Which frames are buffered?
uint8_t *first_image = mlt_properties_get_data( first_frame_properties, "image", NULL );
uint8_t *first_alpha = mlt_properties_get_data( first_frame_properties, "alpha", NULL );
if ( !first_image )
{
mlt_properties_set( first_frame_properties, "rescale.interp", mlt_properties_get( frame_properties, "rescale.interp" ) );
int error = mlt_frame_get_image( first_frame, &first_image, format, width, height, writable );
if ( error != 0 ) {
mlt_log_error( MLT_PRODUCER_SERVICE( producer ), "first_image == NULL get image died\n" );
mlt_service_unlock( MLT_PRODUCER_SERVICE( producer ) );
return error;
}
output = mlt_pool_alloc( size );
memcpy( output, first_image, size );
// Let someone else clean up
mlt_properties_set_data( properties, "output_buffer", output, size, mlt_pool_release, NULL );
mlt_properties_set_int( properties, "_output_width", *width );
mlt_properties_set_int( properties, "_output_height", *height );
mlt_properties_set_int( properties, "_output_format", *format );
}
if ( !first_alpha )
{
alphasize = *width * *height;
first_alpha = mlt_frame_get_alpha_mask( first_frame );
output_alpha = mlt_pool_alloc( alphasize );
memcpy( output_alpha, first_alpha, alphasize );
mlt_properties_set_data( properties, "output_alpha", output_alpha, alphasize, mlt_pool_release, NULL );
}
mlt_service_unlock( MLT_PRODUCER_SERVICE( producer ) );
// Create a copy
uint8_t *image_copy = mlt_pool_alloc( size );
memcpy( image_copy, first_image, size );
uint8_t *alpha_copy = mlt_pool_alloc( alphasize );
memcpy( alpha_copy, first_alpha, alphasize );
// Set the output image
*image = image_copy;
mlt_frame_set_image( frame, *image, size, mlt_pool_release );
mlt_frame_set_alpha( frame, alpha_copy, alphasize, mlt_pool_release );
return 0;
}
int GlslManager::render_frame_rgba(mlt_service service, mlt_frame frame, int width, int height, uint8_t **image)
{
EffectChain* chain = get_chain( service );
if (!chain) return 1;
glsl_fbo fbo = get_fbo( width, height );
if (!fbo) return 1;
glsl_texture texture = get_texture( width, height, GL_RGBA );
if (!texture) {
release_fbo( fbo );
return 1;
}
// Use a PBO to hold the data we read back with glReadPixels().
// (Intel/DRI goes into a slow path if we don't read to PBO.)
int img_size = width * height * 4;
glsl_pbo pbo = get_pbo( img_size );
if (!pbo) {
release_fbo( fbo );
release_texture(texture);
return 1;
}
// Set the FBO
check_error();
glBindFramebuffer( GL_FRAMEBUFFER, fbo->fbo );
check_error();
glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture->texture, 0 );
check_error();
glBindFramebuffer( GL_FRAMEBUFFER, 0 );
check_error();
render_fbo( service, chain, fbo->fbo, width, height );
// Read FBO into PBO
glBindFramebuffer( GL_FRAMEBUFFER, fbo->fbo );
check_error();
glBindBuffer( GL_PIXEL_PACK_BUFFER_ARB, pbo->pbo );
check_error();
glBufferData( GL_PIXEL_PACK_BUFFER_ARB, img_size, NULL, GL_STREAM_READ );
check_error();
glReadPixels( 0, 0, width, height, GL_BGRA, GL_UNSIGNED_BYTE, BUFFER_OFFSET(0) );
check_error();
// Copy from PBO
uint8_t* buf = (uint8_t*) glMapBuffer( GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY );
check_error();
*image = (uint8_t*) mlt_pool_alloc( img_size );
mlt_frame_set_image( frame, *image, img_size, mlt_pool_release );
memcpy( *image, buf, img_size );
// Convert BGRA to RGBA
register uint8_t *p = *image;
register int n = width * height + 1;
while ( --n ) {
uint8_t b = p[0];
*p = p[2]; p += 2;
*p = b; p += 2;
}
// Release PBO and FBO
glUnmapBuffer( GL_PIXEL_PACK_BUFFER_ARB );
check_error();
glBindBuffer( GL_PIXEL_PACK_BUFFER_ARB, 0 );
check_error();
glBindFramebuffer( GL_FRAMEBUFFER, 0 );
check_error();
glBindTexture( GL_TEXTURE_2D, 0 );
check_error();
mlt_properties_set_data( MLT_FRAME_PROPERTIES(frame), "movit.convert.texture", texture, 0,
(mlt_destructor) GlslManager::release_texture, NULL);
release_fbo( fbo );
return 0;
}
static int convert_image( mlt_frame frame, uint8_t **image, mlt_image_format *format, mlt_image_format output_format )
{
mlt_properties properties = MLT_FRAME_PROPERTIES( frame );
int width = mlt_properties_get_int( properties, "width" );
int height = mlt_properties_get_int( properties, "height" );
int error = 0;
if ( *format != output_format )
{
int colorspace = mlt_properties_get_int( properties, "colorspace" );
int force_full_luma = -1;
mlt_log_debug( NULL, "[filter avcolor_space] %s -> %s @ %dx%d space %d\n",
mlt_image_format_name( *format ), mlt_image_format_name( output_format ),
width, height, colorspace );
int in_fmt = convert_mlt_to_av_cs( *format );
int out_fmt = convert_mlt_to_av_cs( output_format );
int size = FFMAX( avpicture_get_size( out_fmt, width, height ),
mlt_image_format_size( output_format, width, height, NULL ) );
uint8_t *output = mlt_pool_alloc( size );
if ( *format == mlt_image_rgb24a || *format == mlt_image_opengl )
{
register int len = width * height;
uint8_t *alpha = mlt_pool_alloc( len );
if ( alpha )
{
// Extract the alpha mask from the RGBA image using Duff's Device
register uint8_t *s = *image + 3; // start on the alpha component
register uint8_t *d = alpha;
register int n = ( len + 7 ) / 8;
switch ( len % 8 )
{
case 0: do { *d++ = *s; s += 4;
case 7: *d++ = *s; s += 4;
case 6: *d++ = *s; s += 4;
case 5: *d++ = *s; s += 4;
case 4: *d++ = *s; s += 4;
case 3: *d++ = *s; s += 4;
case 2: *d++ = *s; s += 4;
case 1: *d++ = *s; s += 4;
}
while ( --n > 0 );
}
mlt_frame_set_alpha( frame, alpha, len, mlt_pool_release );
}
}
// Update the output
if ( *format == mlt_image_yuv422 && mlt_properties_get( properties, "force_full_luma" )
&& ( output_format == mlt_image_rgb24 || output_format == mlt_image_rgb24a ) )
{
// By removing the frame property we only permit the luma to skip scaling once.
// Thereafter, we let swscale scale the luma range as it pleases since it seems
// we do not have control over the RGB to YUV conversion.
force_full_luma = mlt_properties_get_int( properties, "force_full_luma" );
mlt_properties_set( properties, "force_full_luma", NULL );
}
av_convert_image( output, *image, out_fmt, in_fmt, width, height, colorspace, force_full_luma );
*image = output;
*format = output_format;
mlt_frame_set_image( frame, output, size, mlt_pool_release );
mlt_properties_set_int( properties, "format", output_format );
if ( output_format == mlt_image_rgb24a || output_format == mlt_image_opengl )
{
register int len = width * height;
int alpha_size = 0;
uint8_t *alpha = mlt_frame_get_alpha_mask( frame );
mlt_properties_get_data( properties, "alpha", &alpha_size );
if ( alpha && alpha_size >= len )
{
// Merge the alpha mask from into the RGBA image using Duff's Device
register uint8_t *s = alpha;
register uint8_t *d = *image + 3; // start on the alpha component
register int n = ( len + 7 ) / 8;
switch ( len % 8 )
{
case 0: do { *d = *s++; d += 4;
case 7: *d = *s++; d += 4;
case 6: *d = *s++; d += 4;
case 5: *d = *s++; d += 4;
case 4: *d = *s++; d += 4;
case 3: *d = *s++; d += 4;
case 2: *d = *s++; d += 4;
case 1: *d = *s++; d += 4;
}
while ( --n > 0 );
}
}
}
}
return error;
}
static int filter_get_image( mlt_frame frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
{
// Get the filter
mlt_filter 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 )
{
// Get the charcoal scatter value
int x_scatter = mlt_properties_anim_get_double( properties, "x_scatter", position, length );
int y_scatter = mlt_properties_anim_get_double( properties, "y_scatter", position, length );
float scale = mlt_properties_anim_get_double( properties, "scale" ,position, length);
float mix = mlt_properties_anim_get_double( properties, "mix", position, length);
int invert = mlt_properties_anim_get_int( properties, "invert", position, length);
// We'll process pixel by pixel
int x = 0;
int y = 0;
// We need to create a new frame as this effect modifies the input
uint8_t *temp = mlt_pool_alloc( *width * *height * 2 );
uint8_t *p = temp;
uint8_t *q = *image;
// Calculations are carried out on a 3x3 matrix
int matrix[ 3 ][ 3 ];
// Used to carry out the matrix calculations
int sum1;
int sum2;
float sum;
int val;
// Loop for each row
for ( y = 0; y < *height; y ++ )
{
// Loop for each pixel
for ( x = 0; x < *width; x ++ )
{
// Populate the matrix
matrix[ 0 ][ 0 ] = get_Y( *image, *width, *height, x - x_scatter, y - y_scatter );
matrix[ 0 ][ 1 ] = get_Y( *image, *width, *height, x , y - y_scatter );
matrix[ 0 ][ 2 ] = get_Y( *image, *width, *height, x + x_scatter, y - y_scatter );
matrix[ 1 ][ 0 ] = get_Y( *image, *width, *height, x - x_scatter, y );
matrix[ 1 ][ 2 ] = get_Y( *image, *width, *height, x + x_scatter, y );
matrix[ 2 ][ 0 ] = get_Y( *image, *width, *height, x - x_scatter, y + y_scatter );
matrix[ 2 ][ 1 ] = get_Y( *image, *width, *height, x , y + y_scatter );
matrix[ 2 ][ 2 ] = get_Y( *image, *width, *height, x + x_scatter, y + y_scatter );
// Do calculations
sum1 = (matrix[2][0] - matrix[0][0]) + ( (matrix[2][1] - matrix[0][1]) << 1 ) + (matrix[2][2] - matrix[2][0]);
sum2 = (matrix[0][2] - matrix[0][0]) + ( (matrix[1][2] - matrix[1][0]) << 1 ) + (matrix[2][2] - matrix[2][0]);
sum = scale * sqrti( sum1 * sum1 + sum2 * sum2 );
// Assign value
*p ++ = !invert ? ( sum >= 16 && sum <= 235 ? 251 - sum : sum < 16 ? 235 : 16 ) :
( sum >= 16 && sum <= 235 ? sum : sum < 16 ? 16 : 235 );
q ++;
val = 128 + mix * ( *q ++ - 128 );
val = val < 16 ? 16 : val > 240 ? 240 : val;
*p ++ = val;
}
}
// Return the created image
*image = temp;
// Store new and destroy old
mlt_frame_set_image( frame, *image, *width * *height * 2, 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 )
{
// Error we will return
int error = 0;
// Get the watermark filter object
mlt_filter this = mlt_frame_pop_service( frame );
// Get the properties of the filter
mlt_properties properties = MLT_FILTER_PROPERTIES( this );
mlt_service_lock( MLT_FILTER_SERVICE( this ) );
// Get the producer from the filter
mlt_producer producer = mlt_properties_get_data( properties, "producer", NULL );
// Get the composite from the filter
mlt_transition composite = mlt_properties_get_data( properties, "composite", NULL );
// Get the resource to use
char *resource = mlt_properties_get( properties, "resource" );
// Get the old resource
char *old_resource = mlt_properties_get( properties, "_old_resource" );
// Create a composite if we don't have one
if ( composite == NULL )
{
// Create composite via the factory
mlt_profile profile = mlt_service_profile( MLT_FILTER_SERVICE( this ) );
composite = mlt_factory_transition( profile, "composite", NULL );
// Register the composite for reuse/destruction
if ( composite != NULL )
mlt_properties_set_data( properties, "composite", composite, 0, ( mlt_destructor )mlt_transition_close, NULL );
}
// If we have one
if ( composite != NULL )
{
// Get the properties
mlt_properties composite_properties = MLT_TRANSITION_PROPERTIES( composite );
// Pass all the composite. properties on the filter down
mlt_properties_pass( composite_properties, properties, "composite." );
if ( mlt_properties_get( properties, "composite.out" ) == NULL )
mlt_properties_set_int( composite_properties, "out", mlt_properties_get_int( properties, "_out" ) );
// Force a refresh
mlt_properties_set_int( composite_properties, "refresh", 1 );
}
// Create a producer if don't have one
if ( producer == NULL || ( old_resource != NULL && strcmp( resource, old_resource ) ) )
{
// Get the factory producer service
char *factory = mlt_properties_get( properties, "factory" );
// Create the producer
mlt_profile profile = mlt_service_profile( MLT_FILTER_SERVICE( this ) );
producer = mlt_factory_producer( profile, factory, resource );
// If we have one
if ( producer != NULL )
{
// Register the producer for reuse/destruction
mlt_properties_set_data( properties, "producer", producer, 0, ( mlt_destructor )mlt_producer_close, NULL );
// Ensure that we loop
mlt_properties_set( MLT_PRODUCER_PROPERTIES( producer ), "eof", "loop" );
// Set the old resource
mlt_properties_set( properties, "_old_resource", resource );
}
}
if ( producer != NULL )
{
// Get the producer properties
mlt_properties producer_properties = MLT_PRODUCER_PROPERTIES( producer );
// Now pass all producer. properties on the filter down
mlt_properties_pass( producer_properties, properties, "producer." );
}
mlt_service_unlock( MLT_FILTER_SERVICE( this ) );
// Only continue if we have both producer and composite
if ( composite != NULL && producer != NULL )
{
// Get the service of the producer
mlt_service service = MLT_PRODUCER_SERVICE( producer );
// We will get the 'b frame' from the producer
mlt_frame b_frame = NULL;
// Get the original producer position
mlt_position position = mlt_filter_get_position( this, frame );
// Make sure the producer is in the correct position
mlt_producer_seek( producer, position );
// Resetting position to appease the composite transition
mlt_frame_set_position( frame, position );
// Get the b frame and process with composite if successful
if ( mlt_service_get_frame( service, &b_frame, 0 ) == 0 )
{
// Get the a and b frame properties
mlt_properties a_props = MLT_FRAME_PROPERTIES( frame );
mlt_properties b_props = MLT_FRAME_PROPERTIES( b_frame );
mlt_profile profile = mlt_service_profile( service );
// Set the b frame to be in the same position and have same consumer requirements
mlt_frame_set_position( b_frame, position );
mlt_properties_set_int( b_props, "consumer_deinterlace", mlt_properties_get_int( a_props, "consumer_deinterlace" ) || mlt_properties_get_int( properties, "deinterlace" ) );
// Check for the special case - no aspect ratio means no problem :-)
if ( mlt_frame_get_aspect_ratio( b_frame ) == 0 )
mlt_frame_set_aspect_ratio( b_frame, mlt_profile_sar( profile ) );
if ( mlt_frame_get_aspect_ratio( frame ) == 0 )
mlt_frame_set_aspect_ratio( frame, mlt_profile_sar( profile ) );
if ( mlt_properties_get_int( properties, "distort" ) )
{
mlt_properties_set_int( MLT_TRANSITION_PROPERTIES( composite ), "distort", 1 );
mlt_properties_set_int( a_props, "distort", 1 );
mlt_properties_set_int( b_props, "distort", 1 );
}
*format = mlt_image_yuv422;
if ( mlt_properties_get_int( properties, "reverse" ) == 0 )
{
// Apply all filters that are attached to this filter to the b frame
mlt_service_apply_filters( MLT_FILTER_SERVICE( this ), b_frame, 0 );
// Process the frame
mlt_transition_process( composite, frame, b_frame );
// Get the image
error = mlt_frame_get_image( frame, image, format, width, height, 1 );
}
else
{
char temp[ 132 ];
int count = 0;
uint8_t *alpha = NULL;
const char *rescale = mlt_properties_get( a_props, "rescale.interp" );
if ( rescale == NULL || !strcmp( rescale, "none" ) )
rescale = "hyper";
mlt_transition_process( composite, b_frame, frame );
mlt_properties_set_int( a_props, "consumer_deinterlace", 1 );
mlt_properties_set_int( b_props, "consumer_deinterlace", 1 );
mlt_properties_set( a_props, "rescale.interp", rescale );
mlt_properties_set( b_props, "rescale.interp", rescale );
mlt_service_apply_filters( MLT_FILTER_SERVICE( this ), b_frame, 0 );
error = mlt_frame_get_image( b_frame, image, format, width, height, 1 );
alpha = mlt_frame_get_alpha_mask( b_frame );
mlt_frame_set_image( frame, *image, *width * *height * 2, NULL );
mlt_frame_set_alpha( frame, alpha, *width * *height, NULL );
mlt_properties_set_int( a_props, "width", *width );
mlt_properties_set_int( a_props, "height", *height );
mlt_properties_set_int( a_props, "progressive", 1 );
mlt_properties_inc_ref( b_props );
strcpy( temp, "_b_frame" );
while( mlt_properties_get_data( a_props, temp, NULL ) != NULL )
sprintf( temp, "_b_frame%d", count ++ );
mlt_properties_set_data( a_props, temp, b_frame, 0, ( mlt_destructor )mlt_frame_close, NULL );
}
}
// Close the b frame
mlt_frame_close( b_frame );
}
else
{
// Get the image from the frame without running fx
error = mlt_frame_get_image( frame, image, format, width, height, 1 );
}
return error;
}
virtual HRESULT STDMETHODCALLTYPE VideoInputFrameArrived(
IDeckLinkVideoInputFrame* video,
IDeckLinkAudioInputPacket* audio )
{
if ( mlt_properties_get_int( MLT_PRODUCER_PROPERTIES( getProducer() ), "preview" ) &&
mlt_producer_get_speed( getProducer() ) == 0.0 && !mlt_deque_count( m_queue ))
{
pthread_cond_broadcast( &m_condition );
return S_OK;
}
// Create mlt_frame
mlt_frame frame = mlt_frame_init( MLT_PRODUCER_SERVICE( getProducer() ) );
// Copy video
if ( video )
{
if ( !( video->GetFlags() & bmdFrameHasNoInputSource ) )
{
int size = video->GetRowBytes() * ( video->GetHeight() + m_vancLines );
void* image = mlt_pool_alloc( size );
void* buffer = 0;
unsigned char* p = (unsigned char*) image;
int n = size / 2;
\
// Initialize VANC lines to nominal black
while ( --n )
{
*p ++ = 16;
*p ++ = 128;
}
// Capture VANC
if ( m_vancLines > 0 )
{
IDeckLinkVideoFrameAncillary* vanc = 0;
if ( video->GetAncillaryData( &vanc ) == S_OK && vanc )
{
for ( int i = 1; i < m_vancLines + 1; i++ )
{
if ( vanc->GetBufferForVerticalBlankingLine( i, &buffer ) == S_OK )
swab( (char*) buffer, (char*) image + ( i - 1 ) * video->GetRowBytes(), video->GetRowBytes() );
else
mlt_log_debug( getProducer(), "failed capture vanc line %d\n", i );
}
SAFE_RELEASE(vanc);
}
}
// Capture image
video->GetBytes( &buffer );
if ( image && buffer )
{
size = video->GetRowBytes() * video->GetHeight();
swab( (char*) buffer, (char*) image + m_vancLines * video->GetRowBytes(), size );
mlt_frame_set_image( frame, (uint8_t*) image, size, mlt_pool_release );
}
else if ( image )
{
mlt_log_verbose( getProducer(), "no video\n" );
mlt_pool_release( image );
}
}
else
{
mlt_log_verbose( getProducer(), "no signal\n" );
mlt_frame_close( frame );
frame = 0;
}
// Get timecode
IDeckLinkTimecode* timecode = 0;
if ( video->GetTimecode( bmdTimecodeVITC, &timecode ) == S_OK && timecode )
{
DLString timecodeString = 0;
if ( timecode->GetString( &timecodeString ) == S_OK )
{
char* s = getCString( timecodeString );
mlt_properties_set( MLT_FRAME_PROPERTIES( frame ), "meta.attr.vitc.markup", s );
mlt_log_debug( getProducer(), "timecode %s\n", s );
freeCString( s );
}
freeDLString( timecodeString );
SAFE_RELEASE( timecode );
}
}
else
{
mlt_log_verbose( getProducer(), "no video\n" );
mlt_frame_close( frame );
frame = 0;
}
// Copy audio
if ( frame && audio )
{
int channels = mlt_properties_get_int( MLT_PRODUCER_PROPERTIES( getProducer() ), "channels" );
int size = audio->GetSampleFrameCount() * channels * sizeof(int16_t);
mlt_audio_format format = mlt_audio_s16;
void* pcm = mlt_pool_alloc( size );
void* buffer = 0;
audio->GetBytes( &buffer );
if ( buffer )
{
memcpy( pcm, buffer, size );
mlt_frame_set_audio( frame, pcm, format, size, mlt_pool_release );
mlt_properties_set_int( MLT_FRAME_PROPERTIES(frame), "audio_samples", audio->GetSampleFrameCount() );
}
else
{
mlt_log_verbose( getProducer(), "no audio\n" );
mlt_pool_release( pcm );
}
}
else
{
mlt_log_verbose( getProducer(), "no audio\n" );
}
// Put frame in queue
if ( frame )
{
int queueMax = mlt_properties_get_int( MLT_PRODUCER_PROPERTIES( getProducer() ), "buffer" );
pthread_mutex_lock( &m_mutex );
if ( mlt_deque_count( m_queue ) < queueMax )
{
mlt_deque_push_back( m_queue, frame );
pthread_cond_broadcast( &m_condition );
}
else
{
mlt_frame_close( frame );
mlt_properties_set_int( MLT_PRODUCER_PROPERTIES( getProducer() ), "dropped", ++m_dropped );
mlt_log_warning( getProducer(), "frame dropped %d\n", m_dropped );
}
pthread_mutex_unlock( &m_mutex );
}
return S_OK;
}
static int convert_image( mlt_frame frame, uint8_t **image, mlt_image_format *format, mlt_image_format output_format )
{
mlt_properties properties = MLT_FRAME_PROPERTIES( frame );
int width = mlt_properties_get_int( properties, "width" );
int height = mlt_properties_get_int( properties, "height" );
int error = 0;
if ( *format != output_format )
{
mlt_profile profile = mlt_service_profile(
MLT_PRODUCER_SERVICE( mlt_frame_get_original_producer( frame ) ) );
int profile_colorspace = profile ? profile->colorspace : 601;
int colorspace = mlt_properties_get_int( properties, "colorspace" );
int force_full_luma = 0;
mlt_log_debug( NULL, "[filter avcolor_space] %s -> %s @ %dx%d space %d->%d\n",
mlt_image_format_name( *format ), mlt_image_format_name( output_format ),
width, height, colorspace, profile_colorspace );
int in_fmt = convert_mlt_to_av_cs( *format );
int out_fmt = convert_mlt_to_av_cs( output_format );
int size = FFMAX( avpicture_get_size( out_fmt, width, height ),
mlt_image_format_size( output_format, width, height, NULL ) );
uint8_t *output = mlt_pool_alloc( size );
if ( *format == mlt_image_rgb24a || *format == mlt_image_opengl )
{
register int len = width * height;
uint8_t *alpha = mlt_pool_alloc( len );
if ( alpha )
{
// Extract the alpha mask from the RGBA image using Duff's Device
register uint8_t *s = *image + 3; // start on the alpha component
register uint8_t *d = alpha;
register int n = ( len + 7 ) / 8;
switch ( len % 8 )
{
case 0: do { *d++ = *s; s += 4;
case 7: *d++ = *s; s += 4;
case 6: *d++ = *s; s += 4;
case 5: *d++ = *s; s += 4;
case 4: *d++ = *s; s += 4;
case 3: *d++ = *s; s += 4;
case 2: *d++ = *s; s += 4;
case 1: *d++ = *s; s += 4;
}
while ( --n > 0 );
}
mlt_frame_set_alpha( frame, alpha, len, mlt_pool_release );
}
}
// Update the output
if ( !av_convert_image( output, *image, out_fmt, in_fmt, width, height,
colorspace, profile_colorspace, force_full_luma ) )
{
// The new colorspace is only valid if destination is YUV.
if ( output_format == mlt_image_yuv422 || output_format == mlt_image_yuv420p )
mlt_properties_set_int( properties, "colorspace", profile_colorspace );
}
*image = output;
*format = output_format;
mlt_frame_set_image( frame, output, size, mlt_pool_release );
mlt_properties_set_int( properties, "format", output_format );
if ( output_format == mlt_image_rgb24a || output_format == mlt_image_opengl )
{
register int len = width * height;
int alpha_size = 0;
uint8_t *alpha = mlt_frame_get_alpha( frame );
mlt_properties_get_data( properties, "alpha", &alpha_size );
if ( alpha && alpha_size >= len )
{
// Merge the alpha mask from into the RGBA image using Duff's Device
register uint8_t *s = alpha;
register uint8_t *d = *image + 3; // start on the alpha component
register int n = ( len + 7 ) / 8;
switch ( len % 8 )
{
case 0: do { *d = *s++; d += 4;
case 7: *d = *s++; d += 4;
case 6: *d = *s++; d += 4;
case 5: *d = *s++; d += 4;
case 4: *d = *s++; d += 4;
case 3: *d = *s++; d += 4;
case 2: *d = *s++; d += 4;
case 1: *d = *s++; d += 4;
}
while ( --n > 0 );
}
}
}
}
return error;
}
static int filter_get_image( mlt_frame frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
{
int error = 0;
mlt_profile profile = mlt_frame_pop_service( frame );
// Get the properties from the frame
mlt_properties properties = MLT_FRAME_PROPERTIES( frame );
// Correct Width/height if necessary
if ( *width == 0 || *height == 0 )
{
*width = profile->width;
*height = profile->height;
}
int left = mlt_properties_get_int( properties, "crop.left" );
int right = mlt_properties_get_int( properties, "crop.right" );
int top = mlt_properties_get_int( properties, "crop.top" );
int bottom = mlt_properties_get_int( properties, "crop.bottom" );
// Request the image at its original resolution
if ( left || right || top || bottom )
{
mlt_properties_set_int( properties, "rescale_width", mlt_properties_get_int( properties, "crop.original_width" ) );
mlt_properties_set_int( properties, "rescale_height", mlt_properties_get_int( properties, "crop.original_height" ) );
}
// Now get the image
error = mlt_frame_get_image( frame, image, format, width, height, writable );
int owidth = *width - left - right;
int oheight = *height - top - bottom;
owidth = owidth < 0 ? 0 : owidth;
oheight = oheight < 0 ? 0 : oheight;
if ( ( owidth != *width || oheight != *height ) &&
error == 0 && *image != NULL && owidth > 0 && oheight > 0 )
{
int bpp;
// Subsampled YUV is messy and less precise.
if ( *format == mlt_image_yuv422 && frame->convert_image )
{
mlt_image_format requested_format = mlt_image_rgb24;
frame->convert_image( frame, image, format, requested_format );
}
mlt_log_debug( NULL, "[filter crop] %s %dx%d -> %dx%d\n", mlt_image_format_name(*format),
*width, *height, owidth, oheight);
// Provides a manual override for misreported field order
if ( mlt_properties_get( properties, "meta.top_field_first" ) )
{
mlt_properties_set_int( properties, "top_field_first", mlt_properties_get_int( properties, "meta.top_field_first" ) );
mlt_properties_set_int( properties, "meta.top_field_first", 0 );
}
if ( top % 2 )
mlt_properties_set_int( properties, "top_field_first", !mlt_properties_get_int( properties, "top_field_first" ) );
// Create the output image
int size = mlt_image_format_size( *format, owidth, oheight, &bpp );
uint8_t *output = mlt_pool_alloc( size );
if ( output )
{
// Call the generic resize
crop( *image, output, bpp, *width, *height, left, right, top, bottom );
// Now update the frame
mlt_frame_set_image( frame, output, size, mlt_pool_release );
*image = output;
}
// We should resize the alpha too
uint8_t *alpha = mlt_frame_get_alpha_mask( frame );
int alpha_size = 0;
mlt_properties_get_data( properties, "alpha", &alpha_size );
if ( alpha && alpha_size >= ( *width * *height ) )
{
uint8_t *newalpha = mlt_pool_alloc( owidth * oheight );
if ( newalpha )
{
crop( alpha, newalpha, 1, *width, *height, left, right, top, bottom );
mlt_frame_set_alpha( frame, newalpha, owidth * oheight, mlt_pool_release );
}
}
*width = owidth;
*height = oheight;
}
return error;
}
static int get_image( mlt_frame a_frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
{
int error = 0;
// Get the b frame from the stack
mlt_frame b_frame = (mlt_frame) mlt_frame_pop_frame( a_frame );
// Get the transition object
mlt_transition transition = (mlt_transition) mlt_frame_pop_service( a_frame );
// Get the properties of the transition
mlt_properties properties = MLT_TRANSITION_PROPERTIES( transition );
// Get the properties of the a frame
mlt_properties a_props = MLT_FRAME_PROPERTIES( a_frame );
// Get the movit objects
mlt_service service = MLT_TRANSITION_SERVICE( transition );
mlt_service_lock( service );
EffectChain* chain = GlslManager::get_chain( service );
MltInput* a_input = GlslManager::get_input( service );
MltInput* b_input = (MltInput*) mlt_properties_get_data( properties, "movit input B", NULL );
mlt_image_format output_format = *format;
if ( !chain || !a_input ) {
mlt_service_unlock( service );
return 2;
}
// Get the frames' textures
GLuint* texture_id[2] = {0, 0};
*format = mlt_image_glsl_texture;
mlt_frame_get_image( a_frame, (uint8_t**) &texture_id[0], format, width, height, 0 );
a_input->useFBOInput( chain, *texture_id[0] );
*format = mlt_image_glsl_texture;
mlt_frame_get_image( b_frame, (uint8_t**) &texture_id[1], format, width, height, 0 );
b_input->useFBOInput( chain, *texture_id[1] );
// Set resolution to that of the a_frame
*width = mlt_properties_get_int( a_props, "width" );
*height = mlt_properties_get_int( a_props, "height" );
// Setup rendering to an FBO
GlslManager* glsl = GlslManager::get_instance();
glsl_fbo fbo = glsl->get_fbo( *width, *height );
if ( output_format == mlt_image_glsl_texture ) {
glsl_texture texture = glsl->get_texture( *width, *height, GL_RGBA );
glBindFramebuffer( GL_FRAMEBUFFER, fbo->fbo );
check_error();
glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture->texture, 0 );
check_error();
glBindFramebuffer( GL_FRAMEBUFFER, 0 );
check_error();
GlslManager::render( service, chain, fbo->fbo, *width, *height );
glFinish();
check_error();
glBindFramebuffer( GL_FRAMEBUFFER, 0 );
check_error();
*image = (uint8_t*) &texture->texture;
mlt_frame_set_image( a_frame, *image, 0, NULL );
mlt_properties_set_data( properties, "movit.convert", texture, 0,
(mlt_destructor) GlslManager::release_texture, NULL );
*format = output_format;
}
else {
// Use a PBO to hold the data we read back with glReadPixels()
// (Intel/DRI goes into a slow path if we don't read to PBO)
GLenum gl_format = ( output_format == mlt_image_rgb24a || output_format == mlt_image_opengl )?
GL_RGBA : GL_RGB;
int img_size = *width * *height * ( gl_format == GL_RGB? 3 : 4 );
glsl_pbo pbo = glsl->get_pbo( img_size );
glsl_texture texture = glsl->get_texture( *width, *height, gl_format );
if ( fbo && pbo && texture ) {
// Set the FBO
glBindFramebuffer( GL_FRAMEBUFFER, fbo->fbo );
check_error();
glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture->texture, 0 );
check_error();
glBindFramebuffer( GL_FRAMEBUFFER, 0 );
check_error();
GlslManager::render( service, chain, fbo->fbo, *width, *height );
// Read FBO into PBO
glBindBuffer( GL_PIXEL_PACK_BUFFER_ARB, pbo->pbo );
check_error();
glBufferData( GL_PIXEL_PACK_BUFFER_ARB, img_size, NULL, GL_STREAM_READ );
check_error();
glReadPixels( 0, 0, *width, *height, gl_format, GL_UNSIGNED_BYTE, BUFFER_OFFSET(0) );
check_error();
// Copy from PBO
uint8_t* buf = (uint8_t*) glMapBuffer( GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY );
check_error();
*format = gl_format == GL_RGBA ? mlt_image_rgb24a : mlt_image_rgb24;
*image = (uint8_t*) mlt_pool_alloc( img_size );
mlt_frame_set_image( a_frame, *image, img_size, mlt_pool_release );
memcpy( *image, buf, img_size );
// Release PBO and FBO
glUnmapBuffer( GL_PIXEL_PACK_BUFFER_ARB );
check_error();
glBindBuffer( GL_PIXEL_PACK_BUFFER_ARB, 0 );
check_error();
glBindFramebuffer( GL_FRAMEBUFFER, 0 );
check_error();
glBindTexture( GL_TEXTURE_2D, 0 );
check_error();
GlslManager::release_texture( texture );
}
else {
error = 1;
}
}
if ( fbo ) GlslManager::release_fbo( fbo );
mlt_service_lock( service );
return error;
}
static int filter_get_image( mlt_frame frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
{
// Get the filter
mlt_filter filter = mlt_frame_pop_service( frame );
// Get the properties
mlt_properties properties = MLT_FILTER_PROPERTIES( filter );
// Get the image
int error = 0;
*format = mlt_image_rgb24a;
// Only process if we have no error and a valid colour space
if ( error == 0 )
{
mlt_service_lock( MLT_FILTER_SERVICE( filter ) );
mlt_producer producer = mlt_properties_get_data( properties, "producer", NULL );
mlt_transition transition = mlt_properties_get_data( properties, "transition", NULL );
mlt_frame a_frame = NULL;
mlt_profile profile = mlt_service_profile( MLT_FILTER_SERVICE( filter ) );
if ( producer == NULL )
{
char *background = mlt_properties_get( properties, "background" );
producer = mlt_factory_producer( profile, NULL, background );
mlt_properties_set_data( properties, "producer", producer, 0, (mlt_destructor)mlt_producer_close, NULL );
}
if ( transition == NULL )
{
transition = mlt_factory_transition( profile, "qtblend", NULL );
mlt_properties_set_data( properties, "transition", transition, 0, (mlt_destructor)mlt_transition_close, NULL );
if ( transition )
mlt_properties_set_int( MLT_TRANSITION_PROPERTIES( transition ), "b_alpha", 1 );
}
if ( producer != NULL && transition != NULL )
{
mlt_position position = mlt_filter_get_position( filter, frame );
mlt_properties frame_properties = MLT_FRAME_PROPERTIES( frame );
mlt_position in = mlt_filter_get_in( filter );
mlt_position out = mlt_filter_get_out( filter );
double consumer_ar = mlt_profile_sar( profile );
mlt_transition_set_in_and_out( transition, in, out );
if ( out > 0 ) {
mlt_properties_set_position( MLT_PRODUCER_PROPERTIES( producer ), "length", out - in + 1 );
mlt_producer_set_in_and_out( producer, in, out );
}
mlt_producer_seek( producer, in + position );
mlt_frame_set_position( frame, position );
mlt_properties_pass( MLT_PRODUCER_PROPERTIES( producer ), properties, "producer." );
mlt_properties_pass( MLT_TRANSITION_PROPERTIES( transition ), properties, "transition." );
mlt_service_get_frame( MLT_PRODUCER_SERVICE( producer ), &a_frame, 0 );
mlt_frame_set_position( a_frame, in + position );
// Set the rescale interpolation to match the frame
mlt_properties_set( MLT_FRAME_PROPERTIES( a_frame ), "rescale.interp", mlt_properties_get( frame_properties, "rescale.interp" ) );
// Special case - aspect_ratio = 0
if ( mlt_frame_get_aspect_ratio( frame ) == 0 )
mlt_frame_set_aspect_ratio( frame, consumer_ar );
if ( mlt_frame_get_aspect_ratio( a_frame ) == 0 )
mlt_frame_set_aspect_ratio( a_frame, consumer_ar );
// Add the qtblend transition onto the frame stack
mlt_service_unlock( MLT_FILTER_SERVICE( filter ) );
mlt_transition_process( transition, a_frame, frame );
if ( mlt_properties_get_int( properties, "use_normalised" ) )
{
// Use the normalised width & height
mlt_profile profile = mlt_service_profile( MLT_FILTER_SERVICE( filter ) );
*width = profile->width;
*height = profile->height;
}
mlt_frame_get_image( a_frame, image, format, width, height, writable );
mlt_properties_set_data( frame_properties, "affine_frame", a_frame, 0, (mlt_destructor)mlt_frame_close, NULL );
mlt_frame_set_image( frame, *image, *width * *height * 4, NULL );
//mlt_frame_set_alpha( frame, mlt_frame_get_alpha_mask( a_frame ), *width * *height, NULL );
}
else
{
mlt_service_unlock( MLT_FILTER_SERVICE( filter ) );
}
}
return error;
}
static int transition_get_image( mlt_frame a_frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
{
// Get the b frame from the stack
mlt_frame b_frame = mlt_frame_pop_frame( a_frame );
// Get the transition object
mlt_transition transition = mlt_frame_pop_service( a_frame );
// Get the properties of the transition
mlt_properties properties = MLT_TRANSITION_PROPERTIES( transition );
// Get the properties of the a frame
mlt_properties a_props = MLT_FRAME_PROPERTIES( a_frame );
// Get the properties of the b frame
mlt_properties b_props = MLT_FRAME_PROPERTIES( b_frame );
// Image, format, width, height and image for the b frame
uint8_t *b_image = NULL;
mlt_image_format b_format = mlt_image_rgb24a;
int b_width = mlt_properties_get_int( b_props, "meta.media.width" );
int b_height = mlt_properties_get_int( b_props, "meta.media.height" );
double b_ar = mlt_frame_get_aspect_ratio( b_frame );
double b_dar = b_ar * b_width / b_height;
// Assign the current position
mlt_position position = mlt_transition_get_position( transition, a_frame );
int mirror = mlt_properties_get_position( properties, "mirror" );
int length = mlt_transition_get_length( transition );
if ( mlt_properties_get_int( properties, "always_active" ) )
{
mlt_properties props = mlt_properties_get_data( b_props, "_producer", NULL );
mlt_position in = mlt_properties_get_int( props, "in" );
mlt_position out = mlt_properties_get_int( props, "out" );
length = out - in + 1;
}
// Obtain the normalised width and height from the a_frame
mlt_profile profile = mlt_service_profile( MLT_TRANSITION_SERVICE( transition ) );
int normalised_width = profile->width;
int normalised_height = profile->height;
double consumer_ar = mlt_profile_sar( profile );
if ( mirror && position > length / 2 )
position = abs( position - length );
// Fetch the a frame image
*format = mlt_image_rgb24a;
int error = mlt_frame_get_image( a_frame, image, format, width, height, 1 );
if (error || !image)
return error;
// Calculate the region now
mlt_rect result = {0, 0, normalised_width, normalised_height, 1.0};
mlt_service_lock( MLT_TRANSITION_SERVICE( transition ) );
if (mlt_properties_get(properties, "geometry"))
{
// Structures for geometry
struct mlt_geometry_item_s geometry;
composite_calculate( transition, &geometry, normalised_width, normalised_height, ( double )position );
result.x = geometry.x;
result.y = geometry.y;
result.w = geometry.w;
result.h = geometry.h;
result.o = geometry.mix / 100.0f;
}
else if (mlt_properties_get(properties, "rect"))
{
// Determine length and obtain cycle
double cycle = mlt_properties_get_double( properties, "cycle" );
// Allow a repeat cycle
if ( cycle >= 1 )
length = cycle;
else if ( cycle > 0 )
length *= cycle;
mlt_position anim_pos = repeat_position(properties, "rect", position, length);
result = mlt_properties_anim_get_rect(properties, "rect", anim_pos, length);
if (mlt_properties_get(properties, "rect") && strchr(mlt_properties_get(properties, "rect"), '%')) {
result.x *= normalised_width;
result.y *= normalised_height;
result.w *= normalised_width;
result.h *= normalised_height;
}
result.o = (result.o == DBL_MIN)? 1.0 : MIN(result.o, 1.0);
}
mlt_service_unlock( MLT_TRANSITION_SERVICE( transition ) );
double geometry_w = result.w;
double geometry_h = result.h;
if ( !mlt_properties_get_int( properties, "fill" ) )
{
double geometry_dar = result.w * consumer_ar / result.h;
if ( b_dar > geometry_dar )
{
result.w = MIN( result.w, b_width * b_ar / consumer_ar );
result.h = result.w * consumer_ar / b_dar;
}
else
{
result.h = MIN( result.h, b_height );
result.w = result.h * b_dar / consumer_ar;
}
}
// Fetch the b frame image
result.w = ( result.w * *width / normalised_width );
result.h = ( result.h * *height / normalised_height );
result.x = ( result.x * *width / normalised_width );
result.y = ( result.y * *height / normalised_height );
if (mlt_properties_get_int(properties, "b_scaled")) {
// Request b frame image size just what is needed.
b_width = result.w;
b_height = result.h;
// Set the rescale interpolation to match the frame
mlt_properties_set( b_props, "rescale.interp", mlt_properties_get( a_props, "rescale.interp" ) );
} else {
// Request full resolution of b frame image.
mlt_properties_set_int( b_props, "rescale_width", b_width );
mlt_properties_set_int( b_props, "rescale_height", b_height );
// Suppress padding and aspect normalization.
mlt_properties_set( b_props, "rescale.interp", "none" );
}
// This is not a field-aware transform.
mlt_properties_set_int( b_props, "consumer_deinterlace", 1 );
error = mlt_frame_get_image( b_frame, &b_image, &b_format, &b_width, &b_height, 0 );
if (error || !b_image) {
// Remove potentially large image on the B frame.
mlt_frame_set_image( b_frame, NULL, 0, NULL );
return error;
}
// Check that both images are of the correct format and process
if ( *format == mlt_image_rgb24a && b_format == mlt_image_rgb24a )
{
double sw, sh;
// Get values from the transition
double scale_x = mlt_properties_anim_get_double( properties, "scale_x", position, length );
double scale_y = mlt_properties_anim_get_double( properties, "scale_y", position, length );
int scale = mlt_properties_get_int( properties, "scale" );
double geom_scale_x = (double) b_width / result.w;
double geom_scale_y = (double) b_height / result.h;
struct sliced_desc desc = {
.a_image = *image,
.b_image = b_image,
.interp = interpBL_b32,
.a_width = *width,
.a_height = *height,
.b_width = b_width,
.b_height = b_height,
.lower_x = -(result.x + result.w / 2.0), // center
.lower_y = -(result.y + result.h / 2.0), // middle
.mix = result.o,
.x_offset = (double) b_width / 2.0,
.y_offset = (double) b_height / 2.0,
.b_alpha = mlt_properties_get_int( properties, "b_alpha" ),
// Affine boundaries
.minima = 0,
.xmax = b_width - 1,
.ymax = b_height - 1
};
// Recalculate vars if alignment supplied.
if ( mlt_properties_get( properties, "halign" ) || mlt_properties_get( properties, "valign" ) )
{
double halign = alignment_parse( mlt_properties_get( properties, "halign" ) );
double valign = alignment_parse( mlt_properties_get( properties, "valign" ) );
desc.x_offset = halign * b_width / 2.0;
desc.y_offset = valign * b_height / 2.0;
desc.lower_x = -(result.x + geometry_w * halign / 2.0f);
desc.lower_y = -(result.y + geometry_h * valign / 2.0f);
}
affine_init( desc.affine.matrix );
// Compute the affine transform
get_affine( &desc.affine, transition, ( double )position, length );
desc.dz = MapZ( desc.affine.matrix, 0, 0 );
if ( (int) fabs( desc.dz * 1000 ) < 25 )
return 0;
// Factor scaling into the transformation based on output resolution.
if ( mlt_properties_get_int( properties, "distort" ) )
{
scale_x = geom_scale_x * ( scale_x == 0 ? 1 : scale_x );
scale_y = geom_scale_y * ( scale_y == 0 ? 1 : scale_y );
}
else
{
// Determine scale with respect to aspect ratio.
double consumer_dar = consumer_ar * normalised_width / normalised_height;
if ( b_dar > consumer_dar )
{
scale_x = geom_scale_x * ( scale_x == 0 ? 1 : scale_x );
scale_y = geom_scale_x * ( scale_y == 0 ? 1 : scale_y );
scale_y *= b_ar / consumer_ar;
}
else
{
scale_x = geom_scale_y * ( scale_x == 0 ? 1 : scale_x );
scale_y = geom_scale_y * ( scale_y == 0 ? 1 : scale_y );
scale_x *= consumer_ar / b_ar;
}
}
if ( scale )
{
affine_max_output( desc.affine.matrix, &sw, &sh, desc.dz, *width, *height );
affine_scale( desc.affine.matrix, sw * MIN( geom_scale_x, geom_scale_y ), sh * MIN( geom_scale_x, geom_scale_y ) );
}
else if ( scale_x != 0 && scale_y != 0 )
{
affine_scale( desc.affine.matrix, scale_x, scale_y );
}
char *interps = mlt_properties_get( a_props, "rescale.interp" );
// Copy in case string is changed.
if ( interps )
interps = strdup( interps );
// Set the interpolation function
if ( interps == NULL || strcmp( interps, "nearest" ) == 0 || strcmp( interps, "neighbor" ) == 0 || strcmp( interps, "tiles" ) == 0 || strcmp( interps, "fast_bilinear" ) == 0 )
{
desc.interp = interpNN_b32;
// uses lrintf. Values should be >= -0.5 and < max + 0.5
desc.minima -= 0.5;
desc.xmax += 0.49;
desc.ymax += 0.49;
}
else if ( strcmp( interps, "bilinear" ) == 0 )
{
desc.interp = interpBL_b32;
// uses floorf.
}
else if ( strcmp( interps, "bicubic" ) == 0 || strcmp( interps, "hyper" ) == 0 || strcmp( interps, "sinc" ) == 0 || strcmp( interps, "lanczos" ) == 0 || strcmp( interps, "spline" ) == 0 )
{
// TODO: lanczos 8x8
// TODO: spline 4x4 or 6x6
desc.interp = interpBC_b32;
// uses ceilf. Values should be > -1 and <= max.
desc.minima -= 1;
}
free( interps );
// Do the transform with interpolation
int threads = mlt_properties_get_int(properties, "threads");
threads = CLAMP(threads, 0, mlt_slices_count_normal());
if (threads == 1)
sliced_proc(0, 0, 1, &desc);
else
mlt_slices_run_normal(threads, sliced_proc, &desc);
// Remove potentially large image on the B frame.
mlt_frame_set_image( b_frame, NULL, 0, NULL );
}
return 0;
}
static int producer_get_image( mlt_frame frame, uint8_t **buffer, mlt_image_format *format, int *width, int *height, int writable )
{
int error = 0;
/* Obtain properties of frame */
mlt_properties properties = MLT_FRAME_PROPERTIES( frame );
/* Obtain the producer for this frame */
producer_ktitle self = mlt_properties_get_data( properties, "producer_kdenlivetitle", NULL );
/* Obtain properties of producer */
mlt_producer producer = &self->parent;
mlt_properties producer_props = MLT_PRODUCER_PROPERTIES( producer );
if ( mlt_properties_get_int( properties, "rescale_width" ) > 0 )
*width = mlt_properties_get_int( properties, "rescale_width" );
if ( mlt_properties_get_int( properties, "rescale_height" ) > 0 )
*height = mlt_properties_get_int( properties, "rescale_height" );
mlt_service_lock( MLT_PRODUCER_SERVICE( producer ) );
/* Allocate the image */
if ( mlt_properties_get_int( producer_props, "force_reload" ) ) {
if ( mlt_properties_get_int( producer_props, "force_reload" ) > 1 ) read_xml( producer_props );
mlt_properties_set_int( producer_props, "force_reload", 0 );
drawKdenliveTitle( self, frame, *format, *width, *height, mlt_frame_original_position( frame ), 1 );
}
else
{
drawKdenliveTitle( self, frame, *format, *width, *height, mlt_frame_original_position( frame ), 0 );
}
// Get width and height (may have changed during the refresh)
*width = mlt_properties_get_int( properties, "width" );
*height = mlt_properties_get_int( properties, "height" );
*format = self->format;
if ( self->current_image )
{
// Clone the image and the alpha
int image_size = mlt_image_format_size( self->format, self->current_width, self->current_height, NULL );
uint8_t *image_copy = mlt_pool_alloc( image_size );
// We use height-1 because mlt_image_format_size() uses height + 1.
// XXX Remove -1 when mlt_image_format_size() is changed.
memcpy( image_copy, self->current_image,
mlt_image_format_size( self->format, self->current_width, self->current_height - 1, NULL ) );
// Now update properties so we free the copy after
mlt_frame_set_image( frame, image_copy, image_size, mlt_pool_release );
// We're going to pass the copy on
*buffer = image_copy;
// Clone the alpha channel
if ( self->current_alpha )
{
image_copy = mlt_pool_alloc( self->current_width * self->current_height );
memcpy( image_copy, self->current_alpha, self->current_width * self->current_height );
mlt_frame_set_alpha( frame, image_copy, self->current_width * self->current_height, mlt_pool_release );
}
}
else
{
error = 1;
}
mlt_service_unlock( MLT_PRODUCER_SERVICE( producer ) );
return error;
}
void refresh_image( producer_qimage self, mlt_frame frame, mlt_image_format format, int width, int height )
{
// Obtain properties of frame and producer
mlt_properties properties = MLT_FRAME_PROPERTIES( frame );
mlt_producer producer = &self->parent;
// Get index and qimage
int image_idx = refresh_qimage( self, frame );
// optimization for subsequent iterations on single pictur
if ( image_idx != self->image_idx || width != self->current_width || height != self->current_height )
self->current_image = NULL;
// If we have a qimage and need a new scaled image
if ( self->qimage && ( !self->current_image || ( format != mlt_image_none && format != self->format ) ) )
{
char *interps = mlt_properties_get( properties, "rescale.interp" );
int interp = 0;
QImage *qimage = static_cast<QImage*>( self->qimage );
// QImage has two scaling modes - we'll toggle between them here
if ( strcmp( interps, "tiles" ) == 0
|| strcmp( interps, "hyper" ) == 0
|| strcmp( interps, "bicubic" ) == 0 )
interp = 1;
// Note - the original qimage is already safe and ready for destruction
if ( qimage->depth() == 1 )
{
QImage temp = qimage->convertToFormat( QImage::Format_RGB32 );
delete qimage;
qimage = new QImage( temp );
self->qimage = qimage;
}
QImage scaled = interp == 0 ? qimage->scaled( QSize( width, height ) ) :
qimage->scaled( QSize(width, height), Qt::IgnoreAspectRatio, Qt::SmoothTransformation );
int has_alpha = scaled.hasAlphaChannel();
// Store width and height
self->current_width = width;
self->current_height = height;
// Allocate/define image
int dst_stride = width * ( has_alpha ? 4 : 3 );
int image_size = dst_stride * ( height + 1 );
self->current_image = ( uint8_t * )mlt_pool_alloc( image_size );
self->current_alpha = NULL;
self->format = has_alpha ? mlt_image_rgb24a : mlt_image_rgb24;
// Copy the image
int y = self->current_height + 1;
uint8_t *dst = self->current_image;
while ( --y )
{
QRgb *src = (QRgb*) scaled.scanLine( self->current_height - y );
int x = self->current_width + 1;
while ( --x )
{
*dst++ = qRed(*src);
*dst++ = qGreen(*src);
*dst++ = qBlue(*src);
if ( has_alpha ) *dst++ = qAlpha(*src);
++src;
}
}
// Convert image to requested format
if ( format != mlt_image_none && format != self->format )
{
uint8_t *buffer = NULL;
// First, set the image so it can be converted when we get it
mlt_frame_replace_image( frame, self->current_image, self->format, width, height );
mlt_frame_set_image( frame, self->current_image, image_size, mlt_pool_release );
self->format = format;
// get_image will do the format conversion
mlt_frame_get_image( frame, &buffer, &format, &width, &height, 0 );
// cache copies of the image and alpha buffers
if ( buffer )
{
image_size = mlt_image_format_size( format, width, height, NULL );
self->current_image = (uint8_t*) mlt_pool_alloc( image_size );
memcpy( self->current_image, buffer, image_size );
}
if ( ( buffer = mlt_frame_get_alpha_mask( frame ) ) )
{
self->current_alpha = (uint8_t*) mlt_pool_alloc( width * height );
memcpy( self->current_alpha, buffer, width * height );
}
}
// Update the cache
mlt_cache_item_close( self->image_cache );
mlt_service_cache_put( MLT_PRODUCER_SERVICE( producer ), "qimage.image", self->current_image, image_size, mlt_pool_release );
self->image_cache = mlt_service_cache_get( MLT_PRODUCER_SERVICE( producer ), "qimage.image" );
self->image_idx = image_idx;
mlt_cache_item_close( self->alpha_cache );
self->alpha_cache = NULL;
if ( self->current_alpha )
{
mlt_service_cache_put( MLT_PRODUCER_SERVICE( producer ), "qimage.alpha", self->current_alpha, width * height, mlt_pool_release );
self->alpha_cache = mlt_service_cache_get( MLT_PRODUCER_SERVICE( producer ), "qimage.alpha" );
}
}
// Set width/height of frame
mlt_properties_set_int( properties, "width", self->current_width );
mlt_properties_set_int( properties, "height", self->current_height );
}
static int producer_get_image( mlt_frame frame, uint8_t **buffer, mlt_image_format *format, int *width, int *height, int writable )
{
int error = 0;
// Obtain properties of frame and producer
mlt_properties properties = MLT_FRAME_PROPERTIES( frame );
producer_qimage self = mlt_properties_get_data( properties, "producer_qimage", NULL );
mlt_producer producer = &self->parent;
*width = mlt_properties_get_int( properties, "rescale_width" );
*height = mlt_properties_get_int( properties, "rescale_height" );
mlt_service_lock( MLT_PRODUCER_SERVICE( &self->parent ) );
// Refresh the image
self->qimage_cache = mlt_service_cache_get( MLT_PRODUCER_SERVICE( producer ), "qimage.qimage" );
self->qimage = mlt_cache_item_data( self->qimage_cache, NULL );
self->image_cache = mlt_service_cache_get( MLT_PRODUCER_SERVICE( producer ), "qimage.image" );
self->current_image = mlt_cache_item_data( self->image_cache, NULL );
self->alpha_cache = mlt_service_cache_get( MLT_PRODUCER_SERVICE( producer ), "qimage.alpha" );
self->current_alpha = mlt_cache_item_data( self->alpha_cache, NULL );
refresh_image( self, frame, *format, *width, *height );
// Get width and height (may have changed during the refresh)
*width = mlt_properties_get_int( properties, "width" );
*height = mlt_properties_get_int( properties, "height" );
*format = self->format;
// NB: Cloning is necessary with this producer (due to processing of images ahead of use)
// The fault is not in the design of mlt, but in the implementation of the qimage producer...
if ( self->current_image )
{
// Clone the image and the alpha
int image_size = mlt_image_format_size( self->format, self->current_width, self->current_height, NULL );
uint8_t *image_copy = mlt_pool_alloc( image_size );
memcpy( image_copy, self->current_image, image_size );
// Now update properties so we free the copy after
mlt_frame_set_image( frame, image_copy, image_size, mlt_pool_release );
// We're going to pass the copy on
*buffer = image_copy;
mlt_log_debug( MLT_PRODUCER_SERVICE( &self->parent ), "%dx%d (%s)\n",
self->current_width, self->current_height, mlt_image_format_name( *format ) );
// Clone the alpha channel
if ( self->current_alpha )
{
image_copy = mlt_pool_alloc( self->current_width * self->current_height );
memcpy( image_copy, self->current_alpha, self->current_width * self->current_height );
mlt_frame_set_alpha( frame, image_copy, self->current_width * self->current_height, mlt_pool_release );
}
}
else
{
error = 1;
}
// Release references and locks
mlt_cache_item_close( self->qimage_cache );
mlt_cache_item_close( self->image_cache );
mlt_cache_item_close( self->alpha_cache );
mlt_service_unlock( MLT_PRODUCER_SERVICE( &self->parent ) );
return error;
}
static void refresh_image( producer_pixbuf self, mlt_frame frame, mlt_image_format format, int width, int height )
{
// Obtain properties of frame and producer
mlt_properties properties = MLT_FRAME_PROPERTIES( frame );
mlt_producer producer = &self->parent;
// Get index and pixbuf
int current_idx = refresh_pixbuf( self, frame );
// optimization for subsequent iterations on single picture
if ( current_idx != self->image_idx || width != self->width || height != self->height )
self->image = NULL;
mlt_log_debug( MLT_PRODUCER_SERVICE( producer ), "image %p pixbuf %p idx %d current_idx %d pixbuf_idx %d width %d\n",
self->image, self->pixbuf, current_idx, self->image_idx, self->pixbuf_idx, width );
// If we have a pixbuf and we need an image
if ( self->pixbuf && ( !self->image || ( format != mlt_image_none && format != mlt_image_glsl && format != self->format ) ) )
{
char *interps = mlt_properties_get( properties, "rescale.interp" );
if ( interps ) interps = strdup( interps );
int interp = GDK_INTERP_BILINEAR;
if ( !interps ) {
// Keep bilinear by default
}
else if ( strcmp( interps, "nearest" ) == 0 )
interp = GDK_INTERP_NEAREST;
else if ( strcmp( interps, "tiles" ) == 0 )
interp = GDK_INTERP_TILES;
else if ( strcmp( interps, "hyper" ) == 0 || strcmp( interps, "bicubic" ) == 0 )
interp = GDK_INTERP_HYPER;
free( interps );
// Note - the original pixbuf is already safe and ready for destruction
pthread_mutex_lock( &g_mutex );
GdkPixbuf* pixbuf = gdk_pixbuf_scale_simple( self->pixbuf, width, height, interp );
// Store width and height
self->width = width;
self->height = height;
// Allocate/define image
int has_alpha = gdk_pixbuf_get_has_alpha( pixbuf );
int src_stride = gdk_pixbuf_get_rowstride( pixbuf );
int dst_stride = self->width * ( has_alpha ? 4 : 3 );
int image_size = dst_stride * ( height + 1 );
self->image = mlt_pool_alloc( image_size );
self->alpha = NULL;
self->format = has_alpha ? mlt_image_rgb24a : mlt_image_rgb24;
if ( src_stride != dst_stride )
{
int y = self->height;
uint8_t *src = gdk_pixbuf_get_pixels( pixbuf );
uint8_t *dst = self->image;
while ( y-- )
{
memcpy( dst, src, dst_stride );
dst += dst_stride;
src += src_stride;
}
}
else
{
memcpy( self->image, gdk_pixbuf_get_pixels( pixbuf ), src_stride * height );
}
pthread_mutex_unlock( &g_mutex );
// Convert image to requested format
if ( format != mlt_image_none && format != mlt_image_glsl && format != self->format )
{
uint8_t *buffer = NULL;
// First, set the image so it can be converted when we get it
mlt_frame_replace_image( frame, self->image, self->format, width, height );
mlt_frame_set_image( frame, self->image, image_size, mlt_pool_release );
self->format = format;
// get_image will do the format conversion
mlt_frame_get_image( frame, &buffer, &format, &width, &height, 0 );
// cache copies of the image and alpha buffers
if ( buffer )
{
image_size = mlt_image_format_size( format, width, height, NULL );
self->image = mlt_pool_alloc( image_size );
memcpy( self->image, buffer, image_size );
}
if ( ( buffer = mlt_frame_get_alpha_mask( frame ) ) )
{
self->alpha = mlt_pool_alloc( width * height );
memcpy( self->alpha, buffer, width * height );
}
}
// Update the cache
mlt_cache_item_close( self->image_cache );
mlt_service_cache_put( MLT_PRODUCER_SERVICE( producer ), "pixbuf.image", self->image, image_size, mlt_pool_release );
self->image_cache = mlt_service_cache_get( MLT_PRODUCER_SERVICE( producer ), "pixbuf.image" );
self->image_idx = current_idx;
mlt_cache_item_close( self->alpha_cache );
self->alpha_cache = NULL;
if ( self->alpha )
{
mlt_service_cache_put( MLT_PRODUCER_SERVICE( producer ), "pixbuf.alpha", self->alpha, width * height, mlt_pool_release );
self->alpha_cache = mlt_service_cache_get( MLT_PRODUCER_SERVICE( producer ), "pixbuf.alpha" );
}
// Finished with pixbuf now
g_object_unref( pixbuf );
}
// Set width/height of frame
mlt_properties_set_int( properties, "width", self->width );
mlt_properties_set_int( properties, "height", self->height );
}
static int convert_image( mlt_frame frame, uint8_t **image, mlt_image_format *format, mlt_image_format output_format )
{
// Nothing to do!
if ( *format == output_format )
return 0;
mlt_properties properties = MLT_FRAME_PROPERTIES( frame );
mlt_log_debug( NULL, "filter_movit_convert: %s -> %s\n",
mlt_image_format_name( *format ), mlt_image_format_name( output_format ) );
// Use CPU if glsl not initialized or not supported.
GlslManager* glsl = GlslManager::get_instance();
if ( !glsl || !glsl->get_int("glsl_supported" ) )
return convert_on_cpu( frame, image, format, output_format );
// Do non-GL image conversions on a CPU-based image converter.
if ( *format != mlt_image_glsl && output_format != mlt_image_glsl && output_format != mlt_image_glsl_texture )
return convert_on_cpu( frame, image, format, output_format );
int error = 0;
int width = mlt_properties_get_int( properties, "width" );
int height = mlt_properties_get_int( properties, "height" );
int img_size = mlt_image_format_size( *format, width, height, NULL );
mlt_producer producer = mlt_producer_cut_parent( mlt_frame_get_original_producer( frame ) );
mlt_service service = MLT_PRODUCER_SERVICE(producer);
GlslManager::get_instance()->lock_service( frame );
EffectChain* chain = GlslManager::get_chain( service );
MltInput* input = GlslManager::get_input( service );
if ( !chain || !input ) {
GlslManager::get_instance()->unlock_service( frame );
return 2;
}
if ( *format != mlt_image_glsl ) {
bool finalize_chain = false;
if ( output_format == mlt_image_glsl_texture ) {
// We might already have a texture from a previous conversion from mlt_image_glsl.
glsl_texture texture = (glsl_texture) mlt_properties_get_data( properties, "movit.convert.texture", NULL );
// XXX: requires a special property set on the frame by the app for now
// because we do not have reliable way to clear the texture property
// when a downstream filter has changed image.
if ( texture && mlt_properties_get_int( properties, "movit.convert.use_texture") ) {
*image = (uint8_t*) &texture->texture;
mlt_frame_set_image( frame, *image, 0, NULL );
mlt_properties_set_int( properties, "format", output_format );
*format = output_format;
GlslManager::get_instance()->unlock_service( frame );
return error;
} else {
// Use a separate chain to convert image in RAM to OpenGL texture.
// Use cached chain if available and compatible.
Mlt::Producer producer( mlt_producer_cut_parent( mlt_frame_get_original_producer( frame ) ) );
chain = (EffectChain*) producer.get_data( "movit.convert.chain" );
input = (MltInput*) producer.get_data( "movit.convert.input" );
int w = producer.get_int( "movit.convert.width" );
int h = producer.get_int( "movit.convert.height" );
mlt_image_format f = (mlt_image_format) producer.get_int( "movit.convert.format" );
if ( !chain || width != w || height != h || output_format != f ) {
chain = new EffectChain( width, height );
input = new MltInput( width, height );
chain->add_input( input );
chain->add_effect( new Mlt::VerticalFlip() );
finalize_chain = true;
producer.set( "movit.convert.chain", chain, 0, (mlt_destructor) delete_chain );
producer.set( "movit.convert.input", input, 0 );
producer.set( "movit.convert.width", width );
producer.set( "movit.convert.height", height );
producer.set( "movit.convert.format", output_format );
}
}
}
if ( *format == mlt_image_rgb24a || *format == mlt_image_opengl ) {
input->useFlatInput( chain, FORMAT_RGBA_POSTMULTIPLIED_ALPHA, width, height );
input->set_pixel_data( *image );
}
else if ( *format == mlt_image_rgb24 ) {
input->useFlatInput( chain, FORMAT_RGB, width, height );
input->set_pixel_data( *image );
}
else if ( *format == mlt_image_yuv420p ) {
ImageFormat image_format;
YCbCrFormat ycbcr_format;
if ( 709 == mlt_properties_get_int( properties, "colorspace" ) ) {
image_format.color_space = COLORSPACE_REC_709;
image_format.gamma_curve = GAMMA_REC_709;
ycbcr_format.luma_coefficients = YCBCR_REC_709;
} else if ( 576 == mlt_properties_get_int( properties, "height" ) ) {
image_format.color_space = COLORSPACE_REC_601_625;
image_format.gamma_curve = GAMMA_REC_601;
ycbcr_format.luma_coefficients = YCBCR_REC_601;
} else {
image_format.color_space = COLORSPACE_REC_601_525;
image_format.gamma_curve = GAMMA_REC_601;
ycbcr_format.luma_coefficients = YCBCR_REC_601;
}
ycbcr_format.full_range = mlt_properties_get_int( properties, "force_full_luma" );
ycbcr_format.chroma_subsampling_x = ycbcr_format.chroma_subsampling_y = 2;
// TODO: make new frame properties set by producers
ycbcr_format.cb_x_position = ycbcr_format.cr_x_position = 0.0f;
ycbcr_format.cb_y_position = ycbcr_format.cr_y_position = 0.5f;
input->useYCbCrInput( chain, image_format, ycbcr_format, width, height );
input->set_pixel_data( *image );
}
else if ( *format == mlt_image_yuv422 ) {
ImageFormat image_format;
YCbCrFormat ycbcr_format;
if ( 709 == mlt_properties_get_int( properties, "colorspace" ) ) {
image_format.color_space = COLORSPACE_REC_709;
image_format.gamma_curve = GAMMA_REC_709;
ycbcr_format.luma_coefficients = YCBCR_REC_709;
} else if ( 576 == height ) {
image_format.color_space = COLORSPACE_REC_601_625;
image_format.gamma_curve = GAMMA_REC_601;
ycbcr_format.luma_coefficients = YCBCR_REC_601;
} else {
image_format.color_space = COLORSPACE_REC_601_525;
image_format.gamma_curve = GAMMA_REC_601;
ycbcr_format.luma_coefficients = YCBCR_REC_601;
}
ycbcr_format.full_range = mlt_properties_get_int( properties, "force_full_luma" );
ycbcr_format.chroma_subsampling_x = 2;
ycbcr_format.chroma_subsampling_y = 1;
// TODO: make new frame properties set by producers
ycbcr_format.cb_x_position = ycbcr_format.cr_x_position = 0.0f;
ycbcr_format.cb_y_position = ycbcr_format.cr_y_position = 0.5f;
input->useYCbCrInput( chain, image_format, ycbcr_format, width, height );
// convert chunky to planar
uint8_t* planar = (uint8_t*) mlt_pool_alloc( img_size );
yuv422_to_yuv422p( *image, planar, width, height );
input->set_pixel_data( planar );
mlt_frame_set_image( frame, planar, img_size, mlt_pool_release );
}
// Finalize the separate conversion chain if needed.
if ( finalize_chain )
chain->finalize();
}
if ( output_format != mlt_image_glsl ) {
glsl_fbo fbo = glsl->get_fbo( width, height );
if ( output_format == mlt_image_glsl_texture ) {
glsl_texture texture = glsl->get_texture( width, height, GL_RGBA );
glBindFramebuffer( GL_FRAMEBUFFER, fbo->fbo );
check_error();
glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture->texture, 0 );
check_error();
glBindFramebuffer( GL_FRAMEBUFFER, 0 );
check_error();
GlslManager::render( service, chain, fbo->fbo, width, height );
glFinish();
check_error();
glBindFramebuffer( GL_FRAMEBUFFER, 0 );
check_error();
*image = (uint8_t*) &texture->texture;
mlt_frame_set_image( frame, *image, 0, NULL );
mlt_properties_set_data( properties, "movit.convert.texture", texture, 0,
(mlt_destructor) GlslManager::release_texture, NULL );
mlt_properties_set_int( properties, "format", output_format );
*format = output_format;
}
else {
// Use a PBO to hold the data we read back with glReadPixels()
// (Intel/DRI goes into a slow path if we don't read to PBO)
GLenum gl_format = ( output_format == mlt_image_rgb24a || output_format == mlt_image_opengl )?
GL_RGBA : GL_RGB;
img_size = width * height * ( gl_format == GL_RGB? 3 : 4 );
glsl_pbo pbo = glsl->get_pbo( img_size );
glsl_texture texture = glsl->get_texture( width, height, gl_format );
if ( fbo && pbo && texture ) {
// Set the FBO
glBindFramebuffer( GL_FRAMEBUFFER, fbo->fbo );
check_error();
glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture->texture, 0 );
check_error();
glBindFramebuffer( GL_FRAMEBUFFER, 0 );
check_error();
GlslManager::render( service, chain, fbo->fbo, width, height );
// Read FBO into PBO
glBindBuffer( GL_PIXEL_PACK_BUFFER_ARB, pbo->pbo );
check_error();
glBufferData( GL_PIXEL_PACK_BUFFER_ARB, img_size, NULL, GL_STREAM_READ );
check_error();
glReadPixels( 0, 0, width, height, gl_format, GL_UNSIGNED_BYTE, BUFFER_OFFSET(0) );
check_error();
// Copy from PBO
uint8_t* buf = (uint8_t*) glMapBuffer( GL_PIXEL_PACK_BUFFER_ARB, GL_READ_ONLY );
check_error();
*image = (uint8_t*) mlt_pool_alloc( img_size );
mlt_frame_set_image( frame, *image, img_size, mlt_pool_release );
memcpy( *image, buf, img_size );
if ( output_format == mlt_image_yuv422 || output_format == mlt_image_yuv420p ) {
*format = mlt_image_rgb24;
error = convert_on_cpu( frame, image, format, output_format );
}
// Release PBO and FBO
glUnmapBuffer( GL_PIXEL_PACK_BUFFER_ARB );
check_error();
glBindBuffer( GL_PIXEL_PACK_BUFFER_ARB, 0 );
check_error();
glBindFramebuffer( GL_FRAMEBUFFER, 0 );
check_error();
glBindTexture( GL_TEXTURE_2D, 0 );
check_error();
mlt_properties_set_data( properties, "movit.convert.texture", texture, 0,
(mlt_destructor) GlslManager::release_texture, NULL);
mlt_properties_set_int( properties, "format", output_format );
*format = output_format;
}
else {
error = 1;
}
}
if ( fbo ) GlslManager::release_fbo( fbo );
}
else {
mlt_properties_set_int( properties, "format", output_format );
*format = output_format;
}
GlslManager::get_instance()->unlock_service( frame );
return error;
}
