2 * transition_luma.c -- a generic dissolve/wipe processor
3 * Copyright (C) 2003-2004 Ushodaya Enterprises Limited
4 * Author: Dan Dennedy <dan@dennedy.org>
6 * Adapted from Kino Plugin Timfx, which is
7 * Copyright (C) 2002 Timothy M. Shead <tshead@k-3d.com>
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 #include <framework/mlt.h>
32 /** Calculate the position for this frame.
35 static float position_calculate( mlt_transition
this, mlt_frame frame
)
37 // Get the in and out position
38 mlt_position in
= mlt_transition_get_in( this );
39 mlt_position out
= mlt_transition_get_out( this );
41 // Get the position of the frame
42 char *name
= mlt_properties_get( MLT_TRANSITION_PROPERTIES( this ), "_unique_id" );
43 mlt_position position
= mlt_properties_get_position( MLT_FRAME_PROPERTIES( frame
), name
);
46 return ( float )( position
- in
) / ( float )( out
- in
+ 1 );
49 /** Calculate the field delta for this frame - position between two frames.
52 static float delta_calculate( mlt_transition
this, mlt_frame frame
)
54 // Get the in and out position
55 mlt_position in
= mlt_transition_get_in( this );
56 mlt_position out
= mlt_transition_get_out( this );
58 // Get the position of the frame
59 mlt_position position
= mlt_frame_get_position( frame
);
62 float x
= ( float )( position
- in
) / ( float )( out
- in
+ 1 );
63 float y
= ( float )( position
+ 1 - in
) / ( float )( out
- in
+ 1 );
65 return ( y
- x
) / 2.0;
68 static inline int dissolve_yuv( mlt_frame
this, mlt_frame that
, float weight
, int width
, int height
)
71 int width_src
= width
, height_src
= height
;
72 mlt_image_format format
= mlt_image_yuv422
;
73 uint8_t *p_src
, *p_dest
;
79 int32_t weigh
= weight
* ( 1 << 16 );
80 int32_t weigh_complement
= ( 1 - weight
) * ( 1 << 16 );
82 if ( mlt_properties_get( &this->parent
, "distort" ) )
83 mlt_properties_set( &that
->parent
, "distort", mlt_properties_get( &this->parent
, "distort" ) );
84 mlt_properties_set_int( &that
->parent
, "consumer_deinterlace", mlt_properties_get_int( &this->parent
, "consumer_deinterlace" ) );
85 mlt_frame_get_image( this, &p_dest
, &format
, &width
, &height
, 1 );
86 alpha_dst
= mlt_frame_get_alpha_mask( this );
87 mlt_frame_get_image( that
, &p_src
, &format
, &width_src
, &height_src
, 0 );
88 alpha_src
= mlt_frame_get_alpha_mask( that
);
90 // Pick the lesser of two evils ;-)
91 width_src
= width_src
> width ? width
: width_src
;
92 height_src
= height_src
> height ? height
: height_src
;
96 limit
= p_dest
+ height_src
* width_src
* 2;
100 *p_dest
++ = ( *p_src
++ * weigh
+ *p
++ * weigh_complement
) >> 16;
101 *p_dest
++ = ( *p_src
++ * weigh
+ *p
++ * weigh_complement
) >> 16;
102 *alpha_dst
++ = ( *alpha_src
++ * weigh
+ *q
++ * weigh_complement
) >> 16;
108 // image processing functions
110 static inline int32_t smoothstep( int32_t edge1
, int32_t edge2
, uint32_t a
)
118 a
= ( ( a
- edge1
) << 16 ) / ( edge2
- edge1
);
120 return ( ( ( a
* a
) >> 16 ) * ( ( 3 << 16 ) - ( 2 * a
) ) ) >> 16;
125 \param field_order -1 = progressive, 0 = lower field first, 1 = top field first
127 static void luma_composite( mlt_frame a_frame
, mlt_frame b_frame
, int luma_width
, int luma_height
,
128 uint16_t *luma_bitmap
, float pos
, float frame_delta
, float softness
, int field_order
,
129 int *width
, int *height
)
131 int width_src
= *width
, height_src
= *height
;
132 int width_dest
= *width
, height_dest
= *height
;
133 mlt_image_format format_src
= mlt_image_yuv422
, format_dest
= mlt_image_yuv422
;
134 uint8_t *p_src
, *p_dest
;
140 format_src
= mlt_image_yuv422
;
141 format_dest
= mlt_image_yuv422
;
143 if ( mlt_properties_get( &a_frame
->parent
, "distort" ) )
144 mlt_properties_set( &b_frame
->parent
, "distort", mlt_properties_get( &a_frame
->parent
, "distort" ) );
145 mlt_properties_set_int( &b_frame
->parent
, "consumer_deinterlace", mlt_properties_get_int( &a_frame
->parent
, "consumer_deinterlace" ) );
146 mlt_frame_get_image( a_frame
, &p_dest
, &format_dest
, &width_dest
, &height_dest
, 1 );
147 mlt_frame_get_image( b_frame
, &p_src
, &format_src
, &width_src
, &height_src
, 0 );
149 // Pick the lesser of two evils ;-)
150 width_src
= width_src
> width_dest ? width_dest
: width_src
;
151 height_src
= height_src
> height_dest ? height_dest
: height_src
;
153 stride_src
= width_src
* 2;
154 stride_dest
= width_dest
* 2;
156 // Offset the position based on which field we're looking at ...
157 int32_t field_pos
[ 2 ];
158 field_pos
[ 0 ] = ( pos
+ ( ( field_order
== 0 ?
1 : 0 ) * frame_delta
* 0.5 ) ) * ( 1 << 16 ) * ( 1.0 + softness
);
159 field_pos
[ 1 ] = ( pos
+ ( ( field_order
== 0 ?
0 : 1 ) * frame_delta
* 0.5 ) ) * ( 1 << 16 ) * ( 1.0 + softness
);
168 int32_t x_diff
= ( luma_width
<< 16 ) / *width
;
169 int32_t y_diff
= ( luma_height
<< 16 ) / *height
;
170 int32_t x_offset
= 0;
171 int32_t y_offset
= 0;
175 int32_t i_softness
= softness
* ( 1 << 16 );
177 int field_count
= field_order
< 0 ?
1 : 2;
178 int field_stride_src
= field_count
* stride_src
;
179 int field_stride_dest
= field_count
* stride_dest
;
182 // composite using luma map
183 while ( field
< field_count
)
185 p_row
= p_src
+ field
* stride_src
;
186 q_row
= p_dest
+ field
* stride_dest
;
187 y_offset
= field
<< 16;
190 while ( i
< height_src
)
195 l
= luma_bitmap
+ ( y_offset
>> 16 ) * ( luma_width
* field_count
);
201 weight
= l
[ x_offset
>> 16 ];
202 value
= smoothstep( weight
, i_softness
+ weight
, field_pos
[ field
] );
203 *o
++ = ( *p
++ * value
+ *q
++ * ( ( 1 << 16 ) - value
) ) >> 16;
204 *o
++ = ( *p
++ * value
+ *q
++ * ( ( 1 << 16 ) - value
) ) >> 16;
210 p_row
+= field_stride_src
;
211 q_row
+= field_stride_dest
;
218 /** Load the luma map from PGM stream.
221 static void luma_read_pgm( FILE *f
, uint16_t **map
, int *width
, int *height
)
223 uint8_t *data
= NULL
;
235 // get the magic code
236 if ( fgets( line
, 127, f
) == NULL
)
240 while ( sscanf( line
, " #%s", comment
) > 0 )
241 if ( fgets( line
, 127, f
) == NULL
)
244 if ( line
[0] != 'P' || line
[1] != '5' )
247 // skip white space and see if a new line must be fetched
248 for ( i
= 2; i
< 127 && line
[i
] != '\0' && isspace( line
[i
] ); i
++ );
249 if ( ( line
[i
] == '\0' || line
[i
] == '#' ) && fgets( line
, 127, f
) == NULL
)
253 while ( sscanf( line
, " #%s", comment
) > 0 )
254 if ( fgets( line
, 127, f
) == NULL
)
257 // get the dimensions
258 if ( line
[0] == 'P' )
259 i
= sscanf( line
, "P5 %d %d %d", width
, height
, &maxval
);
261 i
= sscanf( line
, "%d %d %d", width
, height
, &maxval
);
263 // get the height value, if not yet
266 if ( fgets( line
, 127, f
) == NULL
)
270 while ( sscanf( line
, " #%s", comment
) > 0 )
271 if ( fgets( line
, 127, f
) == NULL
)
274 i
= sscanf( line
, "%d", height
);
281 // get the maximum gray value, if not yet
284 if ( fgets( line
, 127, f
) == NULL
)
288 while ( sscanf( line
, " #%s", comment
) > 0 )
289 if ( fgets( line
, 127, f
) == NULL
)
292 i
= sscanf( line
, "%d", &maxval
);
297 // determine if this is one or two bytes per pixel
298 bpp
= maxval
> 255 ?
2 : 1;
300 // allocate temporary storage for the raw data
301 data
= mlt_pool_alloc( *width
* *height
* bpp
);
306 if ( fread( data
, *width
* *height
* bpp
, 1, f
) != 1 )
309 // allocate the luma bitmap
310 *map
= p
= (uint16_t*)mlt_pool_alloc( *width
* *height
* sizeof( uint16_t ) );
314 // proces the raw data into the luma bitmap
315 for ( i
= 0; i
< *width
* *height
* bpp
; i
+= bpp
)
318 *p
++ = data
[ i
] << 8;
320 *p
++ = ( data
[ i
] << 8 ) + data
[ i
+1 ];
327 mlt_pool_release( data
);
330 /** Generate a luma map from an RGB image.
333 static void luma_read_yuv422( uint8_t *image
, uint16_t **map
, int width
, int height
)
336 int size
= width
* height
* 2;
338 // allocate the luma bitmap
339 uint16_t *p
= *map
= ( uint16_t* )mlt_pool_alloc( width
* height
* sizeof( uint16_t ) );
343 // proces the image data into the luma bitmap
344 for ( i
= 0; i
< size
; i
+= 2 )
345 *p
++ = ( image
[ i
] - 16 ) * 299; // 299 = 65535 / 219
348 /** Generate a luma map from a YUV image.
350 static void luma_read_rgb24( uint8_t *image
, uint16_t **map
, int width
, int height
)
357 static int transition_get_image( mlt_frame a_frame
, uint8_t **image
, mlt_image_format
*format
, int *width
, int *height
, int writable
)
359 // Get the b frame from the stack
360 mlt_frame b_frame
= mlt_frame_pop_frame( a_frame
);
362 // Get the transition object
363 mlt_transition transition
= mlt_frame_pop_service( a_frame
);
365 // Get the properties of the transition
366 mlt_properties properties
= MLT_TRANSITION_PROPERTIES( transition
);
368 // Get the properties of the a frame
369 mlt_properties a_props
= MLT_FRAME_PROPERTIES( a_frame
);
371 // Get the properties of the b frame
372 mlt_properties b_props
= MLT_FRAME_PROPERTIES( b_frame
);
374 // This compositer is yuv422 only
375 *format
= mlt_image_yuv422
;
377 // The cached luma map information
378 int luma_width
= mlt_properties_get_int( properties
, "width" );
379 int luma_height
= mlt_properties_get_int( properties
, "height" );
380 uint16_t *luma_bitmap
= mlt_properties_get_data( properties
, "bitmap", NULL
);
382 // If the filename property changed, reload the map
383 char *resource
= mlt_properties_get( properties
, "resource" );
385 // Correct width/height if not specified
386 if ( luma_width
== 0 || luma_height
== 0 )
388 luma_width
= mlt_properties_get_int( a_props
, "width" );
389 luma_height
= mlt_properties_get_int( a_props
, "height" );
392 if ( luma_bitmap
== NULL
&& resource
!= NULL
)
395 char *extension
= strrchr( resource
, '.' );
397 if ( strchr( resource
, '%' ) )
400 sprintf( temp
, "%s/lumas/%s/%s", mlt_factory_prefix( ), mlt_environment( "MLT_NORMALISATION" ), strchr( resource
, '%' ) + 1 );
401 test
= fopen( temp
, "r" );
403 strcat( temp
, ".png" );
407 extension
= strrchr( resource
, '.' );
410 // See if it is a PGM
411 if ( extension
!= NULL
&& strcmp( extension
, ".pgm" ) == 0 )
414 FILE *f
= fopen( resource
, "r" );
418 luma_read_pgm( f
, &luma_bitmap
, &luma_width
, &luma_height
);
421 // Set the transition properties
422 mlt_properties_set_int( properties
, "width", luma_width
);
423 mlt_properties_set_int( properties
, "height", luma_height
);
424 mlt_properties_set_data( properties
, "bitmap", luma_bitmap
, luma_width
* luma_height
* 2, mlt_pool_release
, NULL
);
429 // Get the factory producer service
430 char *factory
= mlt_properties_get( properties
, "factory" );
432 // Create the producer
433 mlt_profile profile
= mlt_service_profile( MLT_TRANSITION_SERVICE( transition
) );
434 mlt_producer producer
= mlt_factory_producer( profile
, factory
, resource
);
437 if ( producer
!= NULL
)
439 // Get the producer properties
440 mlt_properties producer_properties
= MLT_PRODUCER_PROPERTIES( producer
);
442 // Ensure that we loop
443 mlt_properties_set( producer_properties
, "eof", "loop" );
445 // Now pass all producer. properties on the transition down
446 mlt_properties_pass( producer_properties
, properties
, "producer." );
448 // We will get the alpha frame from the producer
449 mlt_frame luma_frame
= NULL
;
451 // Get the luma frame
452 if ( mlt_service_get_frame( MLT_PRODUCER_SERVICE( producer
), &luma_frame
, 0 ) == 0 )
454 uint8_t *luma_image
= NULL
;
455 mlt_image_format luma_format
= mlt_image_yuv422
;
457 // Get image from the luma producer
458 mlt_properties_set( MLT_FRAME_PROPERTIES( luma_frame
), "rescale.interp", "nearest" );
459 mlt_frame_get_image( luma_frame
, &luma_image
, &luma_format
, &luma_width
, &luma_height
, 0 );
461 // Generate the luma map
462 if ( luma_image
!= NULL
&& luma_format
== mlt_image_yuv422
)
463 luma_read_yuv422( luma_image
, &luma_bitmap
, luma_width
, luma_height
);
465 else if ( luma_image
!= NULL
&& luma_format
== mlt_image_rgb24
)
466 luma_read_rgb24( luma_image
, &luma_bitmap
, luma_width
, luma_height
);
468 // Set the transition properties
469 mlt_properties_set_int( properties
, "width", luma_width
);
470 mlt_properties_set_int( properties
, "height", luma_height
);
471 mlt_properties_set_data( properties
, "bitmap", luma_bitmap
, luma_width
* luma_height
* 2, mlt_pool_release
, NULL
);
473 // Cleanup the luma frame
474 mlt_frame_close( luma_frame
);
477 // Cleanup the luma producer
478 mlt_producer_close( producer
);
483 // Arbitrary composite defaults
484 float mix
= position_calculate( transition
, a_frame
);
485 float frame_delta
= delta_calculate( transition
, a_frame
);
487 float luma_softness
= mlt_properties_get_double( properties
, "softness" );
489 mlt_properties_get_int( a_props
, "consumer_deinterlace" ) ||
490 mlt_properties_get_int( properties
, "progressive" ) ||
491 mlt_properties_get_int( b_props
, "luma.progressive" );
492 int top_field_first
= mlt_properties_get_int( b_props
, "top_field_first" );
493 int reverse
= mlt_properties_get_int( properties
, "reverse" );
494 int invert
= mlt_properties_get_int( properties
, "invert" );
496 if ( mlt_properties_get( a_props
, "rescale.interp" ) == NULL
|| !strcmp( mlt_properties_get( a_props
, "rescale.interp" ), "none" ) )
497 mlt_properties_set( a_props
, "rescale.interp", "nearest" );
499 // Since we are the consumer of the b_frame, we must pass along this
500 // consumer property from the a_frame
501 if ( mlt_properties_get_double( a_props
, "aspect_ratio" ) == 0.0 )
502 mlt_properties_set_double( a_props
, "aspect_ratio", mlt_properties_get_double( a_props
, "consumer_aspect_ratio" ) );
503 if ( mlt_properties_get_double( b_props
, "aspect_ratio" ) == 0.0 )
504 mlt_properties_set_double( b_props
, "aspect_ratio", mlt_properties_get_double( a_props
, "consumer_aspect_ratio" ) );
505 mlt_properties_set_double( b_props
, "consumer_aspect_ratio", mlt_properties_get_double( a_props
, "consumer_aspect_ratio" ) );
507 // Honour the reverse here
511 mix
= reverse
|| invert ?
1 - mix
: mix
;
512 frame_delta
*= reverse
|| invert ?
-1.0 : 1.0;
514 // Ensure we get scaling on the b_frame
515 if ( mlt_properties_get( b_props
, "rescale.interp" ) == NULL
|| !strcmp( mlt_properties_get( b_props
, "rescale.interp" ), "none" ) )
516 mlt_properties_set( b_props
, "rescale.interp", "nearest" );
518 if ( mlt_properties_get( properties
, "fixed" ) )
519 mix
= mlt_properties_get_double( properties
, "fixed" );
522 if ( luma_width
> 0 && luma_height
> 0 && luma_bitmap
!= NULL
)
523 // Composite the frames using a luma map
524 luma_composite( !invert ? a_frame
: b_frame
, !invert ? b_frame
: a_frame
, luma_width
, luma_height
, luma_bitmap
, mix
, frame_delta
,
525 luma_softness
, progressive ?
-1 : top_field_first
, width
, height
);
527 // Dissolve the frames using the time offset for mix value
528 dissolve_yuv( a_frame
, b_frame
, mix
, *width
, *height
);
531 // Extract the a_frame image info
532 *width
= mlt_properties_get_int( !invert ? a_props
: b_props
, "width" );
533 *height
= mlt_properties_get_int( !invert ? a_props
: b_props
, "height" );
534 *image
= mlt_properties_get_data( !invert ? a_props
: b_props
, "image", NULL
);
540 /** Luma transition processing.
543 static mlt_frame
transition_process( mlt_transition transition
, mlt_frame a_frame
, mlt_frame b_frame
)
545 // Get a unique name to store the frame position
546 char *name
= mlt_properties_get( MLT_TRANSITION_PROPERTIES( transition
), "_unique_id" );
548 // Assign the current position to the name
549 mlt_properties_set_position( MLT_FRAME_PROPERTIES( a_frame
), name
, mlt_frame_get_position( a_frame
) );
551 // Push the transition on to the frame
552 mlt_frame_push_service( a_frame
, transition
);
554 // Push the b_frame on to the stack
555 mlt_frame_push_frame( a_frame
, b_frame
);
557 // Push the transition method
558 mlt_frame_push_get_image( a_frame
, transition_get_image
);
563 /** Constructor for the filter.
566 mlt_transition
transition_luma_init( mlt_profile profile
, mlt_service_type type
, const char *id
, char *lumafile
)
568 mlt_transition transition
= mlt_transition_new( );
569 if ( transition
!= NULL
)
572 transition
->process
= transition_process
;
575 mlt_properties_set( MLT_TRANSITION_PROPERTIES( transition
), "factory", "fezzik" );
577 // Set the main property
578 mlt_properties_set( MLT_TRANSITION_PROPERTIES( transition
), "resource", lumafile
);
580 // Inform apps and framework that this is a video only transition
581 mlt_properties_set_int( MLT_TRANSITION_PROPERTIES( transition
), "_transition_type", 1 );