2 * transition_composite.c -- compose one image over another using alpha channel
3 * Copyright (C) 2003-2004 Ushodaya Enterprises Limited
4 * Author: Dan Dennedy <dan@dennedy.org>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software Foundation,
18 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
21 #include "transition_composite.h"
22 #include <framework/mlt_frame.h>
39 /** Parse a geometry property string.
42 static void geometry_parse( struct geometry_s
*geometry
, struct geometry_s
*defaults
, char *property
)
44 // Assign from defaults if available
45 if ( defaults
!= NULL
)
47 geometry
->x
= defaults
->x
;
48 geometry
->y
= defaults
->y
;
49 geometry
->w
= defaults
->w
;
50 geometry
->h
= defaults
->h
;
51 geometry
->mix
= defaults
->mix
;
58 // Parse the geomtry string
59 if ( property
!= NULL
)
60 sscanf( property
, "%f,%f:%fx%f:%f", &geometry
->x
, &geometry
->y
, &geometry
->w
, &geometry
->h
, &geometry
->mix
);
63 /** Calculate real geometry.
66 static void geometry_calculate( struct geometry_s
*output
, struct geometry_s
*in
, struct geometry_s
*out
, float position
)
68 // Calculate this frames geometry
69 output
->x
= in
->x
+ ( out
->x
- in
->x
) * position
;
70 output
->y
= in
->y
+ ( out
->y
- in
->y
) * position
;
71 output
->w
= in
->w
+ ( out
->w
- in
->w
) * position
;
72 output
->h
= in
->h
+ ( out
->h
- in
->h
) * position
;
73 output
->mix
= in
->mix
+ ( out
->mix
- in
->mix
) * position
;
76 /** Calculate the position for this frame.
79 static float position_calculate( mlt_transition
this, mlt_frame frame
)
81 // Get the in and out position
82 mlt_position in
= mlt_transition_get_in( this );
83 mlt_position out
= mlt_transition_get_out( this );
85 // Get the position of the frame
86 mlt_position position
= mlt_frame_get_position( frame
);
89 return ( float )( position
- in
) / ( float )( out
- in
+ 1 );
92 /** Composite function.
95 static int composite_yuv( uint8_t *p_dest
, mlt_image_format format_dest
, int width_dest
, int height_dest
, mlt_frame that
, struct geometry_s geometry
)
102 int x_src
= 0, y_src
= 0;
104 mlt_image_format format_src
= format_dest
;
105 int x
= ( int )( ( float )width_dest
* geometry
.x
/ 100 );
106 int y
= ( int )( ( float )height_dest
* geometry
.y
/ 100 );
107 float weight
= geometry
.mix
/ 100;
108 int width_src
= ( int )( ( float )width_dest
* geometry
.w
/ 100 );
109 int height_src
= ( int )( ( float )height_dest
* geometry
.h
/ 100 );
113 // optimization point - no work to do
114 if ( ( x
< 0 && -x
>= width_src
) || ( y
< 0 && -y
>= height_src
) )
117 format_src
= mlt_image_yuv422
;
118 format_dest
= mlt_image_yuv422
;
120 mlt_frame_get_image( that
, &p_src
, &format_src
, &width_src
, &height_src
, 1 /* writable */ );
122 stride_src
= width_src
* 2;
123 stride_dest
= width_dest
* 2;
125 // crop overlay off the left edge of frame
133 // crop overlay beyond right edge of frame
134 else if ( x
+ width_src
> width_dest
)
135 width_src
= width_dest
- x
;
137 // crop overlay off the top edge of the frame
143 // crop overlay below bottom edge of frame
144 else if ( y
+ height_src
> height_dest
)
145 height_src
= height_dest
- y
;
147 // offset pointer into overlay buffer based on cropping
148 p_src
+= x_src
* 2 + y_src
* stride_src
;
150 // offset pointer into frame buffer based upon positive, even coordinates only!
151 p_dest
+= ( x
< 0 ?
0 : x
) * 2 + ( y
< 0 ?
0 : y
) * stride_dest
;
153 // Get the alpha channel of the overlay
154 uint8_t *p_alpha
= mlt_frame_get_alpha_mask( that
);
156 // offset pointer into alpha channel based upon cropping
158 p_alpha
+= x_src
+ y_src
* stride_src
/ 2;
163 uint8_t *z
= p_alpha
;
170 // now do the compositing only to cropped extents
171 for ( i
= 0; i
< height_src
; i
++ )
178 for ( j
= 0; j
< width_src
; j
++ )
182 a
= ( z
== NULL
) ?
255 : *z
++;
183 value
= ( weight
* ( float ) a
/ 255.0 );
184 *o
++ = (uint8_t)( Y
* value
+ *q
++ * ( 1 - value
) );
185 *o
++ = (uint8_t)( UV
* value
+ *q
++ * ( 1 - value
) );
189 p_dest
+= stride_dest
;
191 p_alpha
+= stride_src
/ 2;
201 static int transition_get_image( mlt_frame a_frame
, uint8_t **image
, mlt_image_format
*format
, int *width
, int *height
, int writable
)
203 // Get the b frame from the stack
204 mlt_frame b_frame
= mlt_frame_pop_frame( a_frame
);
206 // Get the image from the a frame
207 mlt_frame_get_image( a_frame
, image
, format
, width
, height
, 1 );
209 if ( b_frame
!= NULL
)
211 // Get the properties of the b frame
212 mlt_properties b_props
= mlt_frame_properties( b_frame
);
214 // Get the transition from the b frame
215 mlt_transition
this = mlt_properties_get_data( b_props
, "transition_composite", NULL
);
217 // Get the properties from the transition
218 mlt_properties properties
= mlt_transition_properties( this );
220 // Structures for geometry
221 struct geometry_s result
;
222 struct geometry_s start
;
223 struct geometry_s end
;
225 // Calculate the position
226 float position
= position_calculate( this, a_frame
);
228 // Now parse the geometries
229 geometry_parse( &start
, NULL
, mlt_properties_get( properties
, "start" ) );
230 geometry_parse( &end
, &start
, mlt_properties_get( properties
, "end" ) );
232 // Do the calculation
233 geometry_calculate( &result
, &start
, &end
, position
);
235 // Composite the b_frame on the a_frame
236 composite_yuv( *image
, *format
, *width
, *height
, b_frame
, result
);
242 /** Composition transition processing.
245 static mlt_frame
composite_process( mlt_transition
this, mlt_frame a_frame
, mlt_frame b_frame
)
247 // Propogate the transition properties to the b frame
248 mlt_properties b_props
= mlt_frame_properties( b_frame
);
249 mlt_properties_set_data( b_props
, "transition_composite", this, 0, NULL
, NULL
);
250 mlt_frame_push_get_image( a_frame
, transition_get_image
);
251 mlt_frame_push_frame( a_frame
, b_frame
);
255 /** Constructor for the filter.
258 mlt_transition
transition_composite_init( char *arg
)
260 mlt_transition
this = calloc( sizeof( struct mlt_transition_s
), 1 );
261 if ( this != NULL
&& mlt_transition_init( this, NULL
) == 0 )
263 this->process
= composite_process
;
264 mlt_properties_set( mlt_transition_properties( this ), "start", arg
!= NULL ? arg
: "85,5:10x10" );
265 mlt_properties_set( mlt_transition_properties( this ), "end", "" );