0e1c0d76153c5babefaeff041eaf73aa6c9e36c5
[melted] / src / modules / core / transition_composite.c
1 /*
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>
5 *
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.
10 *
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.
15 *
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.
19 */
20
21 #include "transition_composite.h"
22 #include <framework/mlt_frame.h>
23
24 #include <stdio.h>
25 #include <stdlib.h>
26
27 /** Geometry struct.
28 */
29
30 struct geometry_s
31 {
32 float x;
33 float y;
34 float w;
35 float h;
36 float mix;
37 };
38
39 /** Parse a geometry property string.
40 */
41
42 static void geometry_parse( struct geometry_s *geometry, struct geometry_s *defaults, char *property )
43 {
44 // Assign from defaults if available
45 if ( defaults != NULL )
46 {
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;
52 }
53 else
54 {
55 geometry->mix = 100;
56 }
57
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 );
61 }
62
63 /** Calculate real geometry.
64 */
65
66 static void geometry_calculate( struct geometry_s *output, struct geometry_s *in, struct geometry_s *out, float position )
67 {
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;
74 }
75
76 /** Calculate the position for this frame.
77 */
78
79 static float position_calculate( mlt_transition this, mlt_frame frame )
80 {
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 );
84
85 // Get the position of the frame
86 mlt_position position = mlt_frame_get_position( frame );
87
88 // Now do the calcs
89 return ( float )( position - in ) / ( float )( out - in + 1 );
90 }
91
92 /** Composite function.
93 */
94
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 )
96 {
97 int ret = 0;
98 uint8_t *p_src;
99 int i, j;
100 int stride_src;
101 int stride_dest;
102 int x_src = 0, y_src = 0;
103
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
109 // Compute the dimensioning rectangle
110 int width_src = ( int )( ( float )width_dest * geometry.w / 100 );
111 int height_src = ( int )( ( float )height_dest * geometry.h / 100 );
112
113 mlt_properties b_props = mlt_frame_properties( that );
114 mlt_transition this = mlt_properties_get_data( b_props, "transition_composite", NULL );
115 mlt_properties properties = mlt_transition_properties( this );
116
117 if ( mlt_properties_get( properties, "distort" ) == NULL &&
118 mlt_properties_get( mlt_frame_properties( that ), "real_width" ) != NULL )
119 {
120 int width_b = mlt_properties_get_double( b_props, "real_width" );
121 int height_b = mlt_properties_get_double( b_props, "real_height" );
122
123 // Maximise the dimensioning rectangle to the aspect of the b_frame
124 if ( mlt_properties_get_double( b_props, "aspect_ratio" ) * height_src > width_src )
125 height_src = ( double )width_src / mlt_properties_get_double( b_props, "aspect_ratio" ) + 0.5;
126 else
127 width_src = mlt_properties_get_double( b_props, "aspect_ratio" ) * height_src + 0.5;
128
129 // See if we need to normalise pixel aspect ratio
130 // We can use consumer_aspect_ratio because the a_frame will take on this aspect
131 double aspect = mlt_properties_get_double( b_props, "consumer_aspect_ratio" );
132 if ( aspect != 0 )
133 {
134 // Derive the consumer pixel aspect
135 double oaspect = aspect / ( double )width_dest * height_dest;
136
137 // Get the b frame pixel aspect - usually 1
138 double iaspect = mlt_properties_get_double( b_props, "aspect_ratio" ) / width_b * height_b;
139
140 // Normalise pixel aspect
141 if ( iaspect != 0 && iaspect != oaspect )
142 {
143 width_b = iaspect / oaspect * ( double )width_b + 0.5;
144 width_src = iaspect / oaspect * ( double )width_src + 0.5;
145 }
146
147 // Tell rescale not to normalise display aspect
148 mlt_frame_set_aspect_ratio( that, aspect );
149 }
150
151 // Adjust overall scale for consumer
152 double consumer_scale = mlt_properties_get_double( b_props, "consumer_scale" );
153 if ( consumer_scale > 0 )
154 {
155 width_b = consumer_scale * width_b + 0.5;
156 height_b = consumer_scale * height_b + 0.5;
157 }
158
159 // fprintf( stderr, "bounding rect %dx%d for overlay %dx%d\n", width_src, height_src, width_b, height_b );
160 // Constrain the overlay to the dimensioning rectangle
161 if ( width_b < width_src && height_b < height_src )
162 {
163 width_src = width_b;
164 height_src = height_b;
165 }
166 }
167 else if ( mlt_properties_get( b_props, "real_width" ) != NULL )
168 {
169 // Tell rescale not to normalise display aspect
170 mlt_properties_set_double( b_props, "consumer_aspect_ratio", 0 );
171 }
172
173 x -= x % 2;
174
175 // optimization points - no work to do
176 if ( width_src <= 0 || height_src <= 0 )
177 return ret;
178
179 if ( ( x < 0 && -x >= width_src ) || ( y < 0 && -y >= height_src ) )
180 return ret;
181
182 format_src = mlt_image_yuv422;
183 format_dest = mlt_image_yuv422;
184
185 mlt_frame_get_image( that, &p_src, &format_src, &width_src, &height_src, 1 /* writable */ );
186
187 stride_src = width_src * 2;
188 stride_dest = width_dest * 2;
189
190 // crop overlay off the left edge of frame
191 if ( x < 0 )
192 {
193 x_src = -x;
194 width_src -= x_src;
195 x = 0;
196 }
197
198 // crop overlay beyond right edge of frame
199 else if ( x + width_src > width_dest )
200 width_src = width_dest - x;
201
202 // crop overlay off the top edge of the frame
203 if ( y < 0 )
204 {
205 y_src = -y;
206 height_src -= y_src;
207 }
208 // crop overlay below bottom edge of frame
209 else if ( y + height_src > height_dest )
210 height_src = height_dest - y;
211
212 // offset pointer into overlay buffer based on cropping
213 p_src += x_src * 2 + y_src * stride_src;
214
215 // offset pointer into frame buffer based upon positive, even coordinates only!
216 p_dest += ( x < 0 ? 0 : x ) * 2 + ( y < 0 ? 0 : y ) * stride_dest;
217
218 // Get the alpha channel of the overlay
219 uint8_t *p_alpha = mlt_frame_get_alpha_mask( that );
220
221 // offset pointer into alpha channel based upon cropping
222 if ( p_alpha )
223 p_alpha += x_src + y_src * stride_src / 2;
224
225 uint8_t *p = p_src;
226 uint8_t *q = p_dest;
227 uint8_t *o = p_dest;
228 uint8_t *z = p_alpha;
229
230 uint8_t Y;
231 uint8_t UV;
232 uint8_t a;
233 float value;
234
235 // now do the compositing only to cropped extents
236 for ( i = 0; i < height_src; i++ )
237 {
238 p = p_src;
239 q = p_dest;
240 o = p_dest;
241 z = p_alpha;
242
243 for ( j = 0; j < width_src; j ++ )
244 {
245 Y = *p ++;
246 UV = *p ++;
247 a = ( z == NULL ) ? 255 : *z ++;
248 value = ( weight * ( float ) a / 255.0 );
249 *o ++ = (uint8_t)( Y * value + *q++ * ( 1 - value ) );
250 *o ++ = (uint8_t)( UV * value + *q++ * ( 1 - value ) );
251 }
252
253 p_src += stride_src;
254 p_dest += stride_dest;
255 if ( p_alpha )
256 p_alpha += stride_src / 2;
257 }
258
259 return ret;
260 }
261
262
263 /** Get the image.
264 */
265
266 static int transition_get_image( mlt_frame a_frame, uint8_t **image, mlt_image_format *format, int *width, int *height, int writable )
267 {
268 // Get the b frame from the stack
269 mlt_frame b_frame = mlt_frame_pop_frame( a_frame );
270
271 // Get the image from the a frame
272 mlt_frame_get_image( a_frame, image, format, width, height, 1 );
273
274 if ( b_frame != NULL )
275 {
276 // Get the properties of the b frame
277 mlt_properties b_props = mlt_frame_properties( b_frame );
278
279 // Get the transition from the b frame
280 mlt_transition this = mlt_properties_get_data( b_props, "transition_composite", NULL );
281
282 // Get the properties from the transition
283 mlt_properties properties = mlt_transition_properties( this );
284
285 // Structures for geometry
286 struct geometry_s result;
287 struct geometry_s start;
288 struct geometry_s end;
289
290 // Calculate the position
291 float position = position_calculate( this, a_frame );
292
293 // Now parse the geometries
294 geometry_parse( &start, NULL, mlt_properties_get( properties, "start" ) );
295 geometry_parse( &end, &start, mlt_properties_get( properties, "end" ) );
296
297 // Do the calculation
298 geometry_calculate( &result, &start, &end, position );
299
300 // Since we are the consumer of the b_frame, we must pass along these
301 // consumer properties from the a_frame
302 mlt_properties_set_double( b_props, "consumer_aspect_ratio",
303 mlt_properties_get_double( mlt_frame_properties( a_frame ), "consumer_aspect_ratio" ) );
304 mlt_properties_set_double( b_props, "consumer_scale",
305 mlt_properties_get_double( mlt_frame_properties( a_frame ), "consumer_scale" ) );
306
307 // Composite the b_frame on the a_frame
308 composite_yuv( *image, *format, *width, *height, b_frame, result );
309 }
310
311 return 0;
312 }
313
314 /** Composition transition processing.
315 */
316
317 static mlt_frame composite_process( mlt_transition this, mlt_frame a_frame, mlt_frame b_frame )
318 {
319 // Propogate the transition properties to the b frame
320 mlt_properties b_props = mlt_frame_properties( b_frame );
321 mlt_properties_set_data( b_props, "transition_composite", this, 0, NULL, NULL );
322 mlt_frame_push_get_image( a_frame, transition_get_image );
323 mlt_frame_push_frame( a_frame, b_frame );
324 return a_frame;
325 }
326
327 /** Constructor for the filter.
328 */
329
330 mlt_transition transition_composite_init( char *arg )
331 {
332 mlt_transition this = calloc( sizeof( struct mlt_transition_s ), 1 );
333 if ( this != NULL && mlt_transition_init( this, NULL ) == 0 )
334 {
335 this->process = composite_process;
336 mlt_properties_set( mlt_transition_properties( this ), "start", arg != NULL ? arg : "85,5:10x10" );
337 mlt_properties_set( mlt_transition_properties( this ), "end", "" );
338 }
339 return this;
340 }
341