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
);
381 char *current_resource
= mlt_properties_get( properties
, "_resource" );
383 // If the filename property changed, reload the map
384 char *resource
= mlt_properties_get( properties
, "resource" );
386 // Correct width/height if not specified
387 if ( luma_width
== 0 || luma_height
== 0 )
389 luma_width
= mlt_properties_get_int( a_props
, "width" );
390 luma_height
= mlt_properties_get_int( a_props
, "height" );
393 if ( resource
!= current_resource
)
396 char *extension
= strrchr( resource
, '.' );
398 if ( strchr( resource
, '%' ) )
401 sprintf( temp
, "%s/lumas/%s/%s", mlt_environment( "MLT_DATA" ), mlt_environment( "MLT_NORMALISATION" ), strchr( resource
, '%' ) + 1 );
402 test
= fopen( temp
, "r" );
404 strcat( temp
, ".png" );
408 extension
= strrchr( resource
, '.' );
411 // See if it is a PGM
412 if ( extension
!= NULL
&& strcmp( extension
, ".pgm" ) == 0 )
415 FILE *f
= fopen( resource
, "r" );
419 luma_read_pgm( f
, &luma_bitmap
, &luma_width
, &luma_height
);
422 // Set the transition properties
423 mlt_properties_set_int( properties
, "width", luma_width
);
424 mlt_properties_set_int( properties
, "height", luma_height
);
425 mlt_properties_set( properties
, "_resource", resource
);
426 mlt_properties_set_data( properties
, "bitmap", luma_bitmap
, luma_width
* luma_height
* 2, mlt_pool_release
, NULL
);
432 mlt_properties_set( properties
, "_resource", NULL
);
433 mlt_properties_set_data( properties
, "bitmap", luma_bitmap
, 0, mlt_pool_release
, NULL
);
437 // Get the factory producer service
438 char *factory
= mlt_properties_get( properties
, "factory" );
440 // Create the producer
441 mlt_profile profile
= mlt_service_profile( MLT_TRANSITION_SERVICE( transition
) );
442 mlt_producer producer
= mlt_factory_producer( profile
, factory
, resource
);
445 if ( producer
!= NULL
)
447 // Get the producer properties
448 mlt_properties producer_properties
= MLT_PRODUCER_PROPERTIES( producer
);
450 // Ensure that we loop
451 mlt_properties_set( producer_properties
, "eof", "loop" );
453 // Now pass all producer. properties on the transition down
454 mlt_properties_pass( producer_properties
, properties
, "producer." );
456 // We will get the alpha frame from the producer
457 mlt_frame luma_frame
= NULL
;
459 // Get the luma frame
460 if ( mlt_service_get_frame( MLT_PRODUCER_SERVICE( producer
), &luma_frame
, 0 ) == 0 )
462 uint8_t *luma_image
= NULL
;
463 mlt_image_format luma_format
= mlt_image_yuv422
;
465 // Get image from the luma producer
466 mlt_properties_set( MLT_FRAME_PROPERTIES( luma_frame
), "rescale.interp", "nearest" );
467 mlt_frame_get_image( luma_frame
, &luma_image
, &luma_format
, &luma_width
, &luma_height
, 0 );
469 // Generate the luma map
470 if ( luma_image
!= NULL
&& luma_format
== mlt_image_yuv422
)
471 luma_read_yuv422( luma_image
, &luma_bitmap
, luma_width
, luma_height
);
473 else if ( luma_image
!= NULL
&& luma_format
== mlt_image_rgb24
)
474 luma_read_rgb24( luma_image
, &luma_bitmap
, luma_width
, luma_height
);
476 // Set the transition properties
477 mlt_properties_set_int( properties
, "width", luma_width
);
478 mlt_properties_set_int( properties
, "height", luma_height
);
479 mlt_properties_set( properties
, "_resource", resource
);
480 mlt_properties_set_data( properties
, "bitmap", luma_bitmap
, luma_width
* luma_height
* 2, mlt_pool_release
, NULL
);
482 // Cleanup the luma frame
483 mlt_frame_close( luma_frame
);
486 // Cleanup the luma producer
487 mlt_producer_close( producer
);
492 // Arbitrary composite defaults
493 float mix
= position_calculate( transition
, a_frame
);
494 float frame_delta
= delta_calculate( transition
, a_frame
);
496 float luma_softness
= mlt_properties_get_double( properties
, "softness" );
498 mlt_properties_get_int( a_props
, "consumer_deinterlace" ) ||
499 mlt_properties_get_int( properties
, "progressive" ) ||
500 mlt_properties_get_int( b_props
, "luma.progressive" );
501 int top_field_first
= mlt_properties_get_int( b_props
, "top_field_first" );
502 int reverse
= mlt_properties_get_int( properties
, "reverse" );
503 int invert
= mlt_properties_get_int( properties
, "invert" );
505 if ( mlt_properties_get( a_props
, "rescale.interp" ) == NULL
|| !strcmp( mlt_properties_get( a_props
, "rescale.interp" ), "none" ) )
506 mlt_properties_set( a_props
, "rescale.interp", "nearest" );
508 // Since we are the consumer of the b_frame, we must pass along this
509 // consumer property from the a_frame
510 if ( mlt_properties_get_double( a_props
, "aspect_ratio" ) == 0.0 )
511 mlt_properties_set_double( a_props
, "aspect_ratio", mlt_properties_get_double( a_props
, "consumer_aspect_ratio" ) );
512 if ( mlt_properties_get_double( b_props
, "aspect_ratio" ) == 0.0 )
513 mlt_properties_set_double( b_props
, "aspect_ratio", mlt_properties_get_double( a_props
, "consumer_aspect_ratio" ) );
514 mlt_properties_set_double( b_props
, "consumer_aspect_ratio", mlt_properties_get_double( a_props
, "consumer_aspect_ratio" ) );
516 // Honour the reverse here
520 mix
= reverse
|| invert ?
1 - mix
: mix
;
521 frame_delta
*= reverse
|| invert ?
-1.0 : 1.0;
523 // Ensure we get scaling on the b_frame
524 if ( mlt_properties_get( b_props
, "rescale.interp" ) == NULL
|| !strcmp( mlt_properties_get( b_props
, "rescale.interp" ), "none" ) )
525 mlt_properties_set( b_props
, "rescale.interp", "nearest" );
527 if ( mlt_properties_get( properties
, "fixed" ) )
528 mix
= mlt_properties_get_double( properties
, "fixed" );
531 if ( luma_width
> 0 && luma_height
> 0 && luma_bitmap
!= NULL
)
532 // Composite the frames using a luma map
533 luma_composite( !invert ? a_frame
: b_frame
, !invert ? b_frame
: a_frame
, luma_width
, luma_height
, luma_bitmap
, mix
, frame_delta
,
534 luma_softness
, progressive ?
-1 : top_field_first
, width
, height
);
536 // Dissolve the frames using the time offset for mix value
537 dissolve_yuv( a_frame
, b_frame
, mix
, *width
, *height
);
540 // Extract the a_frame image info
541 *width
= mlt_properties_get_int( !invert ? a_props
: b_props
, "width" );
542 *height
= mlt_properties_get_int( !invert ? a_props
: b_props
, "height" );
543 *image
= mlt_properties_get_data( !invert ? a_props
: b_props
, "image", NULL
);
549 /** Luma transition processing.
552 static mlt_frame
transition_process( mlt_transition transition
, mlt_frame a_frame
, mlt_frame b_frame
)
554 // Get a unique name to store the frame position
555 char *name
= mlt_properties_get( MLT_TRANSITION_PROPERTIES( transition
), "_unique_id" );
557 // Assign the current position to the name
558 mlt_properties_set_position( MLT_FRAME_PROPERTIES( a_frame
), name
, mlt_frame_get_position( a_frame
) );
560 // Push the transition on to the frame
561 mlt_frame_push_service( a_frame
, transition
);
563 // Push the b_frame on to the stack
564 mlt_frame_push_frame( a_frame
, b_frame
);
566 // Push the transition method
567 mlt_frame_push_get_image( a_frame
, transition_get_image
);
572 /** Constructor for the filter.
575 mlt_transition
transition_luma_init( mlt_profile profile
, mlt_service_type type
, const char *id
, char *lumafile
)
577 mlt_transition transition
= mlt_transition_new( );
578 if ( transition
!= NULL
)
581 transition
->process
= transition_process
;
584 mlt_properties_set( MLT_TRANSITION_PROPERTIES( transition
), "factory", "fezzik" );
586 // Set the main property
587 mlt_properties_set( MLT_TRANSITION_PROPERTIES( transition
), "resource", lumafile
);
589 // Inform apps and framework that this is a video only transition
590 mlt_properties_set_int( MLT_TRANSITION_PROPERTIES( transition
), "_transition_type", 1 );