/*
* transition_affine.c -- affine transformations
- * Copyright (C) 2003-2004 Ushodaya Enterprises Limited
+ * Copyright (C) 2003-2010 Ushodaya Enterprises Limited
* Author: Charles Yates <charles.yates@pandora.be>
+ * Author: Dan Dennedy <dan@dennedy.org>
*
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
*
- * This program is distributed in the hope that it will be useful,
+ * This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
*
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
-#include "transition_affine.h"
+#include <framework/mlt_transition.h>
#include <framework/mlt.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
-/** Geometry struct.
-*/
+#include "interp.h"
-struct geometry_s
-{
- int frame;
- float position;
- float mix;
- int nw; // normalised width
- int nh; // normalised height
- int sw; // scaled width, not including consumer scale based upon w/nw
- int sh; // scaled height, not including consumer scale based upon h/nh
- float x;
- float y;
- float w;
- float h;
- struct geometry_s *next;
-};
-
-/** Parse a value from a geometry string.
+/** Calculate real geometry.
*/
-static float parse_value( char **ptr, int normalisation, char delim, float defaults )
+static void geometry_calculate( mlt_transition transition, const char *store, struct mlt_geometry_item_s *output, float position )
{
- float value = defaults;
-
- if ( *ptr != NULL && **ptr != '\0' )
+ mlt_properties properties = MLT_TRANSITION_PROPERTIES( transition );
+ mlt_geometry geometry = mlt_properties_get_data( properties, store, NULL );
+ int mirror_off = mlt_properties_get_int( properties, "mirror_off" );
+ int repeat_off = mlt_properties_get_int( properties, "repeat_off" );
+ int length = mlt_geometry_get_length( geometry );
+
+ // Allow wrapping
+ if ( !repeat_off && position >= length && length != 0 )
{
- char *end = NULL;
- value = strtod( *ptr, &end );
- if ( end != NULL )
- {
- if ( *end == '%' )
- value = ( value / 100.0 ) * normalisation;
- while ( *end == delim || *end == '%' )
- end ++;
- }
- *ptr = end;
+ int section = position / length;
+ position -= section * length;
+ if ( !mirror_off && section % 2 == 1 )
+ position = length - position;
}
- return value;
+ // Fetch the key for the position
+ mlt_geometry_fetch( geometry, output, position );
}
-/** Parse a geometry property string with the syntax X,Y:WxH:MIX. Any value can be
- expressed as a percentage by appending a % after the value, otherwise values are
- assumed to be relative to the normalised dimensions of the consumer.
-*/
-static void geometry_parse( struct geometry_s *geometry, struct geometry_s *defaults, char *property, int nw, int nh )
+static mlt_geometry transition_parse_keys( mlt_transition transition, const char *name, const char *store, int normalised_width, int normalised_height )
{
- // Assign normalised width and height
- geometry->nw = nw;
- geometry->nh = nh;
-
- // Assign from defaults if available
- if ( defaults != NULL )
- {
- geometry->x = defaults->x;
- geometry->y = defaults->y;
- geometry->w = geometry->sw = defaults->w;
- geometry->h = geometry->sh = defaults->h;
- geometry->mix = defaults->mix;
- defaults->next = geometry;
- }
- else
- {
- geometry->mix = 100;
- }
-
- // Parse the geomtry string
- if ( property != NULL && strcmp( property, "" ) )
- {
- char *ptr = property;
- geometry->x = parse_value( &ptr, nw, ',', geometry->x );
- geometry->y = parse_value( &ptr, nh, ':', geometry->y );
- geometry->w = geometry->sw = parse_value( &ptr, nw, 'x', geometry->w );
- geometry->h = geometry->sh = parse_value( &ptr, nh, ':', geometry->h );
- geometry->mix = parse_value( &ptr, 100, ' ', geometry->mix );
- }
-}
+ // Get the properties of the transition
+ mlt_properties properties = MLT_TRANSITION_PROPERTIES( transition );
-/** Calculate real geometry.
-*/
+ // Try to fetch it first
+ mlt_geometry geometry = mlt_properties_get_data( properties, store, NULL );
-static void geometry_calculate( struct geometry_s *output, struct geometry_s *in, float position )
-{
- // Search in for position
- struct geometry_s *out = in->next;
+ // Determine length and obtain cycle
+ mlt_position length = mlt_transition_get_length( transition );
+ double cycle = mlt_properties_get_double( properties, "cycle" );
- if ( position >= 1.0 )
- {
- int section = floor( position );
- position -= section;
- if ( section % 2 == 1 )
- position = 1.0 - position;
- }
+ // Allow a geometry repeat cycle
+ if ( cycle >= 1 )
+ length = cycle;
+ else if ( cycle > 0 )
+ length *= cycle;
- while ( out->next != NULL )
+ if ( geometry == NULL )
{
- if ( position >= in->position && position < out->position )
- break;
+ // Get the new style geometry string
+ char *property = mlt_properties_get( properties, name );
- in = out;
- out = in->next;
- }
+ // Create an empty geometries object
+ geometry = mlt_geometry_init( );
- position = ( position - in->position ) / ( out->position - in->position );
+ // Parse the geometry if we have one
+ mlt_geometry_parse( geometry, property, length, normalised_width, normalised_height );
- // Calculate this frames geometry
- if ( in->frame != out->frame - 1 )
- {
- output->nw = in->nw;
- output->nh = in->nh;
- output->x = in->x + ( out->x - in->x ) * position;
- output->y = in->y + ( out->y - in->y ) * position;
- output->w = in->w + ( out->w - in->w ) * position;
- output->h = in->h + ( out->h - in->h ) * position;
- output->mix = in->mix + ( out->mix - in->mix ) * position;
+ // Store it
+ mlt_properties_set_data( properties, store, geometry, 0, ( mlt_destructor )mlt_geometry_close, NULL );
}
else
{
- output->nw = out->nw;
- output->nh = out->nh;
- output->x = out->x;
- output->y = out->y;
- output->w = out->w;
- output->h = out->h;
- output->mix = out->mix;
+ // Check for updates and refresh if necessary
+ mlt_geometry_refresh( geometry, mlt_properties_get( properties, name ), length, normalised_width, normalised_height );
}
-}
-
-void transition_destroy_keys( void *arg )
-{
- struct geometry_s *ptr = arg;
- struct geometry_s *next = NULL;
- while ( ptr != NULL )
- {
- next = ptr->next;
- free( ptr );
- ptr = next;
- }
+ return geometry;
}
-static struct geometry_s *transition_parse_keys( mlt_transition this, int normalised_width, int normalised_height )
+static mlt_geometry composite_calculate( mlt_transition transition, struct mlt_geometry_item_s *result, int nw, int nh, float position )
{
- // Loop variable for property interrogation
- int i = 0;
-
- // Get the properties of the transition
- mlt_properties properties = MLT_TRANSITION_PROPERTIES( this );
-
- // Get the in and out position
- mlt_position in = mlt_transition_get_in( this );
- mlt_position out = mlt_transition_get_out( this );
-
- // Create the start
- struct geometry_s *start = calloc( 1, sizeof( struct geometry_s ) );
-
- // Create the end (we always need two entries)
- struct geometry_s *end = calloc( 1, sizeof( struct geometry_s ) );
-
- // Pointer
- struct geometry_s *ptr = start;
-
- // Parse the start property
- geometry_parse( start, NULL, mlt_properties_get( properties, "start" ), normalised_width, normalised_height );
-
- // Parse the keys in between
- for ( i = 0; i < mlt_properties_count( properties ); i ++ )
- {
- // Get the name of the property
- char *name = mlt_properties_get_name( properties, i );
-
- // Check that it's valid
- if ( !strncmp( name, "key[", 4 ) )
- {
- // Get the value of the property
- char *value = mlt_properties_get_value( properties, i );
-
- // Determine the frame number
- int frame = atoi( name + 4 );
-
- // Determine the position
- float position = 0;
-
- if ( frame >= 0 && frame < ( out - in ) )
- position = ( float )frame / ( float )( out - in + 1 );
- else if ( frame < 0 && - frame < ( out - in ) )
- position = ( float )( out - in + frame ) / ( float )( out - in + 1 );
-
- // For now, we'll exclude all keys received out of order
- if ( position > ptr->position )
- {
- // Create a new geometry
- struct geometry_s *temp = calloc( 1, sizeof( struct geometry_s ) );
-
- // Parse and add to the list
- geometry_parse( temp, ptr, value, normalised_width, normalised_height );
-
- // Assign the position and frame
- temp->frame = frame;
- temp->position = position;
-
- // Allow the next to be appended after this one
- ptr = temp;
- }
- else
- {
- fprintf( stderr, "Key out of order - skipping %s\n", name );
- }
- }
- }
-
- // Parse the end
- geometry_parse( end, ptr, mlt_properties_get( properties, "end" ), normalised_width, normalised_height );
- if ( out > 0 )
- end->position = ( float )( out - in ) / ( float )( out - in + 1 );
- else
- end->position = 1;
+ // Structures for geometry
+ mlt_geometry start = transition_parse_keys( transition, "geometry", "geometries", nw, nh );
- // Assign to properties to ensure we get destroyed
- mlt_properties_set_data( properties, "geometries", start, 0, transition_destroy_keys, NULL );
+ // Do the calculation
+ geometry_calculate( transition, "geometries", result, position );
return start;
}
-struct geometry_s *composite_calculate( struct geometry_s *result, mlt_transition this, mlt_frame a_frame, float position )
+static inline float composite_calculate_key( mlt_transition transition, const char *name, const char *store, int norm, float position )
{
- // Get the properties from the transition
- mlt_properties properties = MLT_TRANSITION_PROPERTIES( this );
+ // Struct for the result
+ struct mlt_geometry_item_s result;
- // Get the properties from the frame
- mlt_properties a_props = MLT_FRAME_PROPERTIES( a_frame );
-
// Structures for geometry
- struct geometry_s *start = mlt_properties_get_data( properties, "geometries", NULL );
-
- // Now parse the geometries
- if ( start == NULL )
- {
- // Obtain the normalised width and height from the a_frame
- int normalised_width = mlt_properties_get_int( a_props, "normalised_width" );
- int normalised_height = mlt_properties_get_int( a_props, "normalised_height" );
-
- // Parse the transitions properties
- start = transition_parse_keys( this, normalised_width, normalised_height );
- }
+ transition_parse_keys( transition, name, store, norm, 0 );
// Do the calculation
- geometry_calculate( result, start, position );
+ geometry_calculate( transition, store, &result, position );
- return start;
+ return result.x;
}
-typedef struct
+typedef struct
{
float matrix[3][3];
}
affine_t;
-static void affine_init( float this[3][3] )
+static void affine_init( float affine[3][3] )
{
- this[0][0] = 1;
- this[0][1] = 0;
- this[0][2] = 0;
- this[1][0] = 0;
- this[1][1] = 1;
- this[1][2] = 0;
- this[2][0] = 0;
- this[2][1] = 0;
- this[2][2] = 1;
+ affine[0][0] = 1;
+ affine[0][1] = 0;
+ affine[0][2] = 0;
+ affine[1][0] = 0;
+ affine[1][1] = 1;
+ affine[1][2] = 0;
+ affine[2][0] = 0;
+ affine[2][1] = 0;
+ affine[2][2] = 1;
}
// Multiply two this affine transform with that
-static void affine_multiply( float this[3][3], float that[3][3] )
+static void affine_multiply( float affine[3][3], float matrix[3][3] )
{
float output[3][3];
int i;
for ( i = 0; i < 3; i ++ )
for ( j = 0; j < 3; j ++ )
- output[i][j] = this[i][0] * that[j][0] + this[i][1] * that[j][1] + this[i][2] * that[j][2];
-
- this[0][0] = output[0][0];
- this[0][1] = output[0][1];
- this[0][2] = output[0][2];
- this[1][0] = output[1][0];
- this[1][1] = output[1][1];
- this[1][2] = output[1][2];
- this[2][0] = output[2][0];
- this[2][1] = output[2][1];
- this[2][2] = output[2][2];
+ output[i][j] = affine[i][0] * matrix[j][0] + affine[i][1] * matrix[j][1] + affine[i][2] * matrix[j][2];
+
+ affine[0][0] = output[0][0];
+ affine[0][1] = output[0][1];
+ affine[0][2] = output[0][2];
+ affine[1][0] = output[1][0];
+ affine[1][1] = output[1][1];
+ affine[1][2] = output[1][2];
+ affine[2][0] = output[2][0];
+ affine[2][1] = output[2][1];
+ affine[2][2] = output[2][2];
}
// Rotate by a given angle
-static void affine_rotate( float this[3][3], float angle )
+static void affine_rotate_x( float affine[3][3], float angle )
{
- float affine[3][3];
- affine[0][0] = cos( angle * M_PI / 180 );
- affine[0][1] = 0 - sin( angle * M_PI / 180 );
- affine[0][2] = 0;
- affine[1][0] = sin( angle * M_PI / 180 );
- affine[1][1] = cos( angle * M_PI / 180 );
- affine[1][2] = 0;
- affine[2][0] = 0;
- affine[2][1] = 0;
- affine[2][2] = 1;
- affine_multiply( this, affine );
+ float matrix[3][3];
+ matrix[0][0] = cos( angle * M_PI / 180 );
+ matrix[0][1] = 0 - sin( angle * M_PI / 180 );
+ matrix[0][2] = 0;
+ matrix[1][0] = sin( angle * M_PI / 180 );
+ matrix[1][1] = cos( angle * M_PI / 180 );
+ matrix[1][2] = 0;
+ matrix[2][0] = 0;
+ matrix[2][1] = 0;
+ matrix[2][2] = 1;
+ affine_multiply( affine, affine );
}
-static void affine_rotate_y( float this[3][3], float angle )
+static void affine_rotate_y( float affine[3][3], float angle )
{
- float affine[3][3];
- affine[0][0] = cos( angle * M_PI / 180 );
- affine[0][1] = 0;
- affine[0][2] = 0 - sin( angle * M_PI / 180 );
- affine[1][0] = 0;
- affine[1][1] = 1;
- affine[1][2] = 0;
- affine[2][0] = sin( angle * M_PI / 180 );
- affine[2][1] = 0;
- affine[2][2] = cos( angle * M_PI / 180 );
- affine_multiply( this, affine );
+ float matrix[3][3];
+ matrix[0][0] = cos( angle * M_PI / 180 );
+ matrix[0][1] = 0;
+ matrix[0][2] = 0 - sin( angle * M_PI / 180 );
+ matrix[1][0] = 0;
+ matrix[1][1] = 1;
+ matrix[1][2] = 0;
+ matrix[2][0] = sin( angle * M_PI / 180 );
+ matrix[2][1] = 0;
+ matrix[2][2] = cos( angle * M_PI / 180 );
+ affine_multiply( affine, matrix );
}
-static void affine_rotate_z( float this[3][3], float angle )
+static void affine_rotate_z( float affine[3][3], float angle )
{
- float affine[3][3];
- affine[0][0] = 1;
- affine[0][1] = 0;
- affine[0][2] = 0;
- affine[1][0] = 0;
- affine[1][1] = cos( angle * M_PI / 180 );
- affine[1][2] = sin( angle * M_PI / 180 );
- affine[2][0] = 0;
- affine[2][1] = - sin( angle * M_PI / 180 );
- affine[2][2] = cos( angle * M_PI / 180 );
- affine_multiply( this, affine );
+ float matrix[3][3];
+ matrix[0][0] = 1;
+ matrix[0][1] = 0;
+ matrix[0][2] = 0;
+ matrix[1][0] = 0;
+ matrix[1][1] = cos( angle * M_PI / 180 );
+ matrix[1][2] = sin( angle * M_PI / 180 );
+ matrix[2][0] = 0;
+ matrix[2][1] = - sin( angle * M_PI / 180 );
+ matrix[2][2] = cos( angle * M_PI / 180 );
+ affine_multiply( affine, matrix );
}
-static void affine_scale( float this[3][3], float sx, float sy )
+static void affine_scale( float affine[3][3], float sx, float sy )
{
- float affine[3][3];
- affine[0][0] = sx;
- affine[0][1] = 0;
- affine[0][2] = 0;
- affine[1][0] = 0;
- affine[1][1] = sy;
- affine[1][2] = 0;
- affine[2][0] = 0;
- affine[2][1] = 0;
- affine[2][2] = 1;
- affine_multiply( this, affine );
+ float matrix[3][3];
+ matrix[0][0] = sx;
+ matrix[0][1] = 0;
+ matrix[0][2] = 0;
+ matrix[1][0] = 0;
+ matrix[1][1] = sy;
+ matrix[1][2] = 0;
+ matrix[2][0] = 0;
+ matrix[2][1] = 0;
+ matrix[2][2] = 1;
+ affine_multiply( affine, matrix );
}
// Shear by a given value
-static void affine_shear( float this[3][3], float shear_x, float shear_y, float shear_z )
+static void affine_shear( float affine[3][3], float shear_x, float shear_y, float shear_z )
{
- float affine[3][3];
- affine[0][0] = 1;
- affine[0][1] = tan( shear_x * M_PI / 180 );
- affine[0][2] = 0;
- affine[1][0] = tan( shear_y * M_PI / 180 );
- affine[1][1] = 1;
- affine[1][2] = tan( shear_z * M_PI / 180 );
- affine[2][0] = 0;
- affine[2][1] = 0;
- affine[2][2] = 1;
- affine_multiply( this, affine );
+ float matrix[3][3];
+ matrix[0][0] = 1;
+ matrix[0][1] = tan( shear_x * M_PI / 180 );
+ matrix[0][2] = 0;
+ matrix[1][0] = tan( shear_y * M_PI / 180 );
+ matrix[1][1] = 1;
+ matrix[1][2] = tan( shear_z * M_PI / 180 );
+ matrix[2][0] = 0;
+ matrix[2][1] = 0;
+ matrix[2][2] = 1;
+ affine_multiply( affine, matrix );
}
-static void affine_offset( float this[3][3], int x, int y )
+static void affine_offset( float affine[3][3], float x, float y )
{
- this[0][2] += x;
- this[1][2] += y;
+ affine[0][2] += x;
+ affine[1][2] += y;
}
// Obtain the mapped x coordinate of the input
-static inline double MapX( float this[3][3], int x, int y )
+static inline double MapX( float affine[3][3], float x, float y )
{
- return this[0][0] * x + this[0][1] * y + this[0][2];
+ return affine[0][0] * x + affine[0][1] * y + affine[0][2];
}
// Obtain the mapped y coordinate of the input
-static inline double MapY( float this[3][3], int x, int y )
+static inline double MapY( float affine[3][3], float x, float y )
{
- return this[1][0] * x + this[1][1] * y + this[1][2];
+ return affine[1][0] * x + affine[1][1] * y + affine[1][2];
}
-static inline double MapZ( float this[3][3], int x, int y )
+static inline double MapZ( float affine[3][3], float x, float y )
{
- return this[2][0] * x + this[2][1] * y + this[2][2];
+ return affine[2][0] * x + affine[2][1] * y + affine[2][2];
}
#define MAX( x, y ) x > y ? x : y
#define MIN( x, y ) x < y ? x : y
-static void affine_max_output( float this[3][3], float *w, float *h, float dz )
+static void affine_max_output( float affine[3][3], float *w, float *h, float dz, float max_width, float max_height )
{
- int tlx = MapX( this, -720, 576 ) / dz;
- int tly = MapY( this, -720, 576 ) / dz;
- int trx = MapX( this, 720, 576 ) / dz;
- int try = MapY( this, 720, 576 ) / dz;
- int blx = MapX( this, -720, -576 ) / dz;
- int bly = MapY( this, -720, -576 ) / dz;
- int brx = MapX( this, 720, -576 ) / dz;
- int bry = MapY( this, 720, -576 ) / dz;
+ int tlx = MapX( affine, -max_width, max_height ) / dz;
+ int tly = MapY( affine, -max_width, max_height ) / dz;
+ int trx = MapX( affine, max_width, max_height ) / dz;
+ int try = MapY( affine, max_width, max_height ) / dz;
+ int blx = MapX( affine, -max_width, -max_height ) / dz;
+ int bly = MapY( affine, -max_width, -max_height ) / dz;
+ int brx = MapX( affine, max_width, -max_height ) / dz;
+ int bry = MapY( affine, max_width, -max_height ) / dz;
int max_x;
int max_y;
min_y = MIN( min_y, bly );
min_y = MIN( min_y, bry );
- *w = ( float )( max_x - min_x + 1 ) / 1440.0;
- *h = ( float )( max_y - min_y + 1 ) / 1152.0;
+ *w = ( float )( max_x - min_x + 1 ) / max_width / 2.0;
+ *h = ( float )( max_y - min_y + 1 ) / max_height / 2.0;
}
#define IN_RANGE( v, r ) ( v >= - r / 2 && v < r / 2 )
+static inline void get_affine( affine_t *affine, mlt_transition transition, float position )
+{
+ mlt_properties properties = MLT_TRANSITION_PROPERTIES( transition );
+ int keyed = mlt_properties_get_int( properties, "keyed" );
+
+ if ( keyed == 0 )
+ {
+ float fix_rotate_x = mlt_properties_get_double( properties, "fix_rotate_x" );
+ float fix_rotate_y = mlt_properties_get_double( properties, "fix_rotate_y" );
+ float fix_rotate_z = mlt_properties_get_double( properties, "fix_rotate_z" );
+ float rotate_x = mlt_properties_get_double( properties, "rotate_x" );
+ float rotate_y = mlt_properties_get_double( properties, "rotate_y" );
+ float rotate_z = mlt_properties_get_double( properties, "rotate_z" );
+ float fix_shear_x = mlt_properties_get_double( properties, "fix_shear_x" );
+ float fix_shear_y = mlt_properties_get_double( properties, "fix_shear_y" );
+ float fix_shear_z = mlt_properties_get_double( properties, "fix_shear_z" );
+ float shear_x = mlt_properties_get_double( properties, "shear_x" );
+ float shear_y = mlt_properties_get_double( properties, "shear_y" );
+ float shear_z = mlt_properties_get_double( properties, "shear_z" );
+ float ox = mlt_properties_get_double( properties, "ox" );
+ float oy = mlt_properties_get_double( properties, "oy" );
+
+ affine_rotate_x( affine->matrix, fix_rotate_x + rotate_x * position );
+ affine_rotate_y( affine->matrix, fix_rotate_y + rotate_y * position );
+ affine_rotate_z( affine->matrix, fix_rotate_z + rotate_z * position );
+ affine_shear( affine->matrix,
+ fix_shear_x + shear_x * position,
+ fix_shear_y + shear_y * position,
+ fix_shear_z + shear_z * position );
+ affine_offset( affine->matrix, ox, oy );
+ }
+ else
+ {
+ float rotate_x = composite_calculate_key( transition, "rotate_x", "rotate_x_info", 360, position );
+ float rotate_y = composite_calculate_key( transition, "rotate_y", "rotate_y_info", 360, position );
+ float rotate_z = composite_calculate_key( transition, "rotate_z", "rotate_z_info", 360, position );
+ float shear_x = composite_calculate_key( transition, "shear_x", "shear_x_info", 360, position );
+ float shear_y = composite_calculate_key( transition, "shear_y", "shear_y_info", 360, position );
+ float shear_z = composite_calculate_key( transition, "shear_z", "shear_z_info", 360, position );
+ float o_x = composite_calculate_key( transition, "ox", "ox_info", 0, position );
+ float o_y = composite_calculate_key( transition, "oy", "oy_info", 0, position );
+
+ affine_rotate_x( affine->matrix, rotate_x );
+ affine_rotate_y( affine->matrix, rotate_y );
+ affine_rotate_z( affine->matrix, rotate_z );
+ affine_shear( affine->matrix, shear_x, shear_y, shear_z );
+ affine_offset( affine->matrix, o_x, o_y );
+ }
+}
+
/** Get the image.
*/
mlt_frame b_frame = mlt_frame_pop_frame( a_frame );
// Get the transition object
- mlt_transition this = mlt_frame_pop_service( a_frame );
+ mlt_transition transition = mlt_frame_pop_service( a_frame );
// Get the properties of the transition
- mlt_properties properties = MLT_TRANSITION_PROPERTIES( this );
+ mlt_properties properties = MLT_TRANSITION_PROPERTIES( transition );
// Get the properties of the a frame
mlt_properties a_props = MLT_FRAME_PROPERTIES( a_frame );
// Image, format, width, height and image for the b frame
uint8_t *b_image = NULL;
- mlt_image_format b_format = mlt_image_yuv422;
+ mlt_image_format b_format = mlt_image_rgb24a;
int b_width;
int b_height;
- // Get the unique name to retrieve the frame position
- char *name = mlt_properties_get( properties, "_unique_id" );
+ // Assign the current position
+ mlt_position position = mlt_transition_get_position( transition, a_frame );
- // Assign the current position to the name
- mlt_position position = mlt_properties_get_position( a_props, name );
- mlt_position in = mlt_properties_get_position( properties, "in" );
- mlt_position out = mlt_properties_get_position( properties, "out" );
int mirror = mlt_properties_get_position( properties, "mirror" );
- int length = out - in + 1;
+ 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_properties_get_double( a_props, "consumer_aspect_ratio" );
// Structures for geometry
- struct geometry_s *start = mlt_properties_get_data( properties, "geometries", NULL );
- struct geometry_s result;
+ struct mlt_geometry_item_s result;
if ( mirror && position > length / 2 )
position = abs( position - length );
- // Now parse the geometries
- if ( start == NULL )
- {
- // Obtain the normalised width and height from the a_frame
- int normalised_width = mlt_properties_get_int( a_props, "normalised_width" );
- int normalised_height = mlt_properties_get_int( a_props, "normalised_height" );
-
- // Parse the transitions properties
- start = transition_parse_keys( this, normalised_width, normalised_height );
- }
-
// Fetch the a frame image
+ *format = mlt_image_rgb24a;
mlt_frame_get_image( a_frame, image, format, width, height, 1 );
// Calculate the region now
- composite_calculate( &result, this, a_frame, ( float )position / length );
+ mlt_service_lock( MLT_TRANSITION_SERVICE( transition ) );
+ composite_calculate( transition, &result, normalised_width, normalised_height, ( float )position );
+ mlt_service_unlock( MLT_TRANSITION_SERVICE( transition ) );
// Fetch the b frame image
- result.w = ( int )( result.w * *width / result.nw );
- result.h = ( int )( result.h * *height / result.nh );
- result.x = ( int )( result.x * *width / result.nw );
- result.y = ( int )( result.y * *height / result.nh );
- result.w -= ( int )abs( result.w ) % 2;
- result.x -= ( int )abs( result.x ) % 2;
- b_width = result.w;
- b_height = result.h;
-
- if ( !strcmp( mlt_properties_get( a_props, "rescale.interp" ), "none" ) )
- {
- mlt_properties_set( b_props, "rescale.interp", "nearest" );
- mlt_properties_set_double( b_props, "consumer_aspect_ratio", mlt_properties_get_double( a_props, "aspect_ratio" ) );
- }
- else
- {
- mlt_properties_set( b_props, "rescale.interp", mlt_properties_get( a_props, "rescale.interp" ) );
- mlt_properties_set_double( b_props, "consumer_aspect_ratio", mlt_properties_get_double( a_props, "consumer_aspect_ratio" ) );
- }
+ 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 );
+
+ // Request full resolution of b frame image.
+ b_width = mlt_properties_get_int( b_props, "real_width" );
+ b_height = mlt_properties_get_int( b_props, "real_height" );
+ 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.
+ char *interps = mlt_properties_get( a_props, "rescale.interp" );
+ if ( interps )
+ interps = strdup( interps );
+ mlt_properties_set( b_props, "rescale.interp", "none" );
+
+ // This is not a field-aware transform.
+ mlt_properties_set_int( b_props, "consumer_deinterlace", 1 );
- mlt_properties_set_int( b_props, "distort", mlt_properties_get_int( properties, "distort" ) );
mlt_frame_get_image( b_frame, &b_image, &b_format, &b_width, &b_height, 0 );
- result.w = b_width;
- result.h = b_height;
// Check that both images are of the correct format and process
- if ( *format == mlt_image_yuv422 && b_format == mlt_image_yuv422 )
+ if ( *format == mlt_image_rgb24a && b_format == mlt_image_rgb24a )
{
- register int x, y;
- register int dx, dy;
- double dz;
+ float x, y;
+ float dx, dy;
+ float dz;
float sw, sh;
+ uint8_t *p = *image;
// Get values from the transition
- float fix_rotate_x = mlt_properties_get_double( properties, "fix_rotate_x" );
- float fix_rotate_y = mlt_properties_get_double( properties, "fix_rotate_y" );
- float fix_rotate_z = mlt_properties_get_double( properties, "fix_rotate_z" );
- float rotate_x = mlt_properties_get_double( properties, "rotate_x" );
- float rotate_y = mlt_properties_get_double( properties, "rotate_y" );
- float rotate_z = mlt_properties_get_double( properties, "rotate_z" );
- float fix_shear_x = mlt_properties_get_double( properties, "fix_shear_x" );
- float fix_shear_y = mlt_properties_get_double( properties, "fix_shear_y" );
- float fix_shear_z = mlt_properties_get_double( properties, "fix_shear_z" );
- float shear_x = mlt_properties_get_double( properties, "shear_x" );
- float shear_y = mlt_properties_get_double( properties, "shear_y" );
- float shear_z = mlt_properties_get_double( properties, "shear_z" );
- float ox = mlt_properties_get_double( properties, "ox" );
- float oy = mlt_properties_get_double( properties, "oy" );
+ float scale_x = mlt_properties_get_double( properties, "scale_x" );
+ float scale_y = mlt_properties_get_double( properties, "scale_y" );
int scale = mlt_properties_get_int( properties, "scale" );
-
- uint8_t *p = *image;
- uint8_t *q = *image;
-
- int cx = result.x + ( b_width >> 1 );
- int cy = result.y + ( b_height >> 1 );
-
- int lower_x = 0 - cx;
- int upper_x = *width - cx;
- int lower_y = 0 - cy;
- int upper_y = *height - cy;
-
- int b_stride = b_width << 1;
- int a_stride = *width << 1;
- int x_offset = ( int )result.w >> 1;
- int y_offset = ( int )result.h >> 1;
-
- uint8_t *alpha = mlt_frame_get_alpha_mask( b_frame );
- uint8_t *mask = mlt_pool_alloc( b_width * b_height );
- uint8_t *pmask = mask;
- float mix;
-
+ float geom_scale_x = (float) b_width / result.w;
+ float geom_scale_y = (float) b_height / result.h;
+ float cx = result.x + result.w / 2.0;
+ float cy = result.y + result.h / 2.0;
+ float lower_x = - cx;
+ float lower_y = - cy;
+ float x_offset = (float) b_width / 2.0;
+ float y_offset = (float) b_height / 2.0;
affine_t affine;
- affine_init( affine.matrix );
- affine_rotate( affine.matrix, fix_rotate_x + rotate_x * position );
- affine_rotate_y( affine.matrix, fix_rotate_y + rotate_y * position );
- affine_rotate_z( affine.matrix, fix_rotate_z + rotate_z * position );
- affine_shear( affine.matrix,
- fix_shear_x + shear_x * position,
- fix_shear_y + shear_y * position,
- fix_shear_z + shear_z * position );
- affine_offset( affine.matrix, ox, oy );
-
- lower_x -= ( lower_x & 1 );
- upper_x -= ( upper_x & 1 );
+ interpp interp = interpBL_b32;
+ int i, j; // loop counters
- q = *image;
+ affine_init( affine.matrix );
+ // Compute the affine transform
+ get_affine( &affine, transition, ( float )position );
dz = MapZ( affine.matrix, 0, 0 );
-
- if ( mask != NULL )
- memset( mask, 0, b_width * b_height );
-
if ( ( int )abs( dz * 1000 ) < 25 )
- goto getout;
+ {
+ if ( interps )
+ free( interps );
+ 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;
+ double b_ar = mlt_properties_get_double( b_props, "aspect_ratio" );
+ double b_dar = b_ar * b_width / b_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 );
+ }
+ 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( affine.matrix, &sw, &sh, dz );
- affine_scale( affine.matrix, sw, sh );
+ affine_max_output( affine.matrix, &sw, &sh, dz, *width, *height );
+ affine_scale( affine.matrix, sw * MIN( geom_scale_x, geom_scale_y ), sh * MIN( geom_scale_x, geom_scale_y ) );
}
-
- for ( y = lower_y; y < upper_y; y ++ )
+ else if ( scale_x != 0 && scale_y != 0 )
{
- p = q;
+ affine_scale( affine.matrix, scale_x, scale_y );
+ }
- for ( x = lower_x; x < upper_x; x ++ )
+ // Set the interpolation function
+ if ( interps == NULL || strcmp( interps, "nearest" ) == 0 || strcmp( interps, "neighbor" ) == 0 )
+ interp = interpNN_b32;
+ else if ( strcmp( interps, "tiles" ) == 0 || strcmp( interps, "fast_bilinear" ) == 0 )
+ interp = interpNN_b32;
+ else if ( strcmp( interps, "bilinear" ) == 0 )
+ interp = interpBL_b32;
+ else if ( strcmp( interps, "bicubic" ) == 0 )
+ interp = interpBC_b32;
+ // TODO: lanczos 8x8
+ else if ( strcmp( interps, "hyper" ) == 0 || strcmp( interps, "sinc" ) == 0 || strcmp( interps, "lanczos" ) == 0 )
+ interp = interpBC_b32;
+ else if ( strcmp( interps, "spline" ) == 0 ) // TODO: spline 4x4 or 6x6
+ interp = interpBC_b32;
+
+ // Do the transform with interpolation
+ for ( i = 0, y = lower_y; i < *height; i++, y++ )
+ {
+ for ( j = 0, x = lower_x; j < *width; j++, x++ )
{
dx = MapX( affine.matrix, x, y ) / dz + x_offset;
dy = MapY( affine.matrix, x, y ) / dz + y_offset;
-
- if ( dx >= 0 && dx < b_width && dy >=0 && dy < b_height )
- {
- if ( alpha == NULL )
- {
- *pmask ++ = 255;
- dx += dx & 1;
- *p ++ = *( b_image + dy * b_stride + ( dx << 1 ) );
- *p ++ = *( b_image + dy * b_stride + ( dx << 1 ) + ( ( x & 1 ) << 1 ) + 1 );
- }
- else
- {
- *pmask ++ = *( alpha + dy * b_width + dx );
- mix = ( float )*( alpha + dy * b_width + dx ) / 255.0;
- dx += dx & 1;
- *p = *p * ( 1 - mix ) + mix * *( b_image + dy * b_stride + ( dx << 1 ) );
- p ++;
- *p = *p * ( 1 - mix ) + mix * *( b_image + dy * b_stride + ( dx << 1 ) + ( ( x & 1 ) << 1 ) + 1 );
- p ++;
- }
- }
- else
- {
- p += 2;
- pmask ++;
- }
+ if ( dx >= 0 && dx < (b_width - 1) && dy >=0 && dy < (b_height - 1) )
+ interp( b_image, b_width, b_height, dx, dy, result.mix/100.0, p );
+ p += 4;
}
-
- q += a_stride;
}
-
-getout:
- b_frame->get_alpha_mask = NULL;
- mlt_properties_set_data( b_props, "alpha", mask, 0, mlt_pool_release, NULL );
}
+ if ( interps )
+ free( interps );
return 0;
}
static mlt_frame transition_process( mlt_transition transition, mlt_frame a_frame, mlt_frame b_frame )
{
- // Get a unique name to store the frame position
- char *name = mlt_properties_get( MLT_TRANSITION_PROPERTIES( transition ), "_unique_id" );
-
- // Assign the current position to the name
- mlt_properties a_props = MLT_FRAME_PROPERTIES( a_frame );
- mlt_properties_set_position( a_props, name, mlt_frame_get_position( a_frame ) );
-
// Push the transition on to the frame
mlt_frame_push_service( a_frame, transition );
/** Constructor for the filter.
*/
-mlt_transition transition_affine_init( char *arg )
+mlt_transition transition_affine_init( mlt_profile profile, mlt_service_type type, const char *id, char *arg )
{
mlt_transition transition = mlt_transition_new( );
if ( transition != NULL )
{
- mlt_properties_set_int( MLT_TRANSITION_PROPERTIES( transition ), "sx", 1 );
- mlt_properties_set_int( MLT_TRANSITION_PROPERTIES( transition ), "sy", 1 );
mlt_properties_set_int( MLT_TRANSITION_PROPERTIES( transition ), "distort", 0 );
- mlt_properties_set( MLT_TRANSITION_PROPERTIES( transition ), "start", "0,0:100%x100%" );
+ mlt_properties_set( MLT_TRANSITION_PROPERTIES( transition ), "geometry", "0/0:100%x100%" );
// Inform apps and framework that this is a video only transition
mlt_properties_set_int( MLT_TRANSITION_PROPERTIES( transition ), "_transition_type", 1 );
transition->process = transition_process;
projects / mlt / blobdiff