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 * 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_luma.h"
22 #include <framework/mlt.h>
30 /** Calculate the position for this frame.
33 static float position_calculate( mlt_transition
this, mlt_frame frame
)
35 // Get the in and out position
36 mlt_position in
= mlt_transition_get_in( this );
37 mlt_position out
= mlt_transition_get_out( this );
39 // Get the position of the frame
40 char *name
= mlt_properties_get( MLT_TRANSITION_PROPERTIES( this ), "_unique_id" );
41 mlt_position position
= mlt_properties_get_position( MLT_FRAME_PROPERTIES( frame
), name
);
44 return ( float )( position
- in
) / ( float )( out
- in
+ 1 );
47 /** Calculate the field delta for this frame - position between two frames.
50 static float delta_calculate( mlt_transition
this, mlt_frame frame
)
52 // Get the in and out position
53 mlt_position in
= mlt_transition_get_in( this );
54 mlt_position out
= mlt_transition_get_out( this );
56 // Get the position of the frame
57 mlt_position position
= mlt_frame_get_position( frame
);
60 float x
= ( float )( position
- in
) / ( float )( out
- in
+ 1 );
61 float y
= ( float )( position
+ 1 - in
) / ( float )( out
- in
+ 1 );
63 return ( y
- x
) / 2.0;
66 static inline int dissolve_yuv( mlt_frame
this, mlt_frame that
, float weight
, int width
, int height
)
69 int width_src
= width
, height_src
= height
;
70 mlt_image_format format
= mlt_image_yuv422
;
71 uint8_t *p_src
, *p_dest
;
77 int32_t weigh
= weight
* ( 1 << 16 );
78 int32_t weigh_complement
= ( 1 - weight
) * ( 1 << 16 );
80 if ( mlt_properties_get( &this->parent
, "distort" ) )
81 mlt_properties_set( &that
->parent
, "distort", mlt_properties_get( &this->parent
, "distort" ) );
82 mlt_properties_set_int( &that
->parent
, "consumer_deinterlace", mlt_properties_get_int( &this->parent
, "consumer_deinterlace" ) );
83 mlt_frame_get_image( this, &p_dest
, &format
, &width
, &height
, 1 );
84 alpha_dst
= mlt_frame_get_alpha_mask( this );
85 mlt_frame_get_image( that
, &p_src
, &format
, &width_src
, &height_src
, 0 );
86 alpha_src
= mlt_frame_get_alpha_mask( that
);
88 // Pick the lesser of two evils ;-)
89 width_src
= width_src
> width ? width
: width_src
;
90 height_src
= height_src
> height ? height
: height_src
;
94 limit
= p_dest
+ height_src
* width_src
* 2;
98 *p_dest
++ = ( *p_src
++ * weigh
+ *p
++ * weigh_complement
) >> 16;
99 *p_dest
++ = ( *p_src
++ * weigh
+ *p
++ * weigh_complement
) >> 16;
100 *alpha_dst
++ = ( *alpha_src
++ * weigh
+ *q
++ * weigh_complement
) >> 16;
106 // image processing functions
108 static inline int32_t smoothstep( int32_t edge1
, int32_t edge2
, uint32_t a
)
116 a
= ( ( a
- edge1
) << 16 ) / ( edge2
- edge1
);
118 return ( ( ( a
* a
) >> 16 ) * ( ( 3 << 16 ) - ( 2 * a
) ) ) >> 16;
123 \param field_order -1 = progressive, 0 = lower field first, 1 = top field first
125 static void luma_composite( mlt_frame a_frame
, mlt_frame b_frame
, int luma_width
, int luma_height
,
126 uint16_t *luma_bitmap
, float pos
, float frame_delta
, float softness
, int field_order
,
127 int *width
, int *height
)
129 int width_src
= *width
, height_src
= *height
;
130 int width_dest
= *width
, height_dest
= *height
;
131 mlt_image_format format_src
= mlt_image_yuv422
, format_dest
= mlt_image_yuv422
;
132 uint8_t *p_src
, *p_dest
;
138 format_src
= mlt_image_yuv422
;
139 format_dest
= mlt_image_yuv422
;
141 if ( mlt_properties_get( &a_frame
->parent
, "distort" ) )
142 mlt_properties_set( &b_frame
->parent
, "distort", mlt_properties_get( &a_frame
->parent
, "distort" ) );
143 mlt_properties_set_int( &b_frame
->parent
, "consumer_deinterlace", mlt_properties_get_int( &a_frame
->parent
, "consumer_deinterlace" ) );
144 mlt_frame_get_image( a_frame
, &p_dest
, &format_dest
, &width_dest
, &height_dest
, 1 );
145 mlt_frame_get_image( b_frame
, &p_src
, &format_src
, &width_src
, &height_src
, 0 );
147 // Pick the lesser of two evils ;-)
148 width_src
= width_src
> width_dest ? width_dest
: width_src
;
149 height_src
= height_src
> height_dest ? height_dest
: height_src
;
151 stride_src
= width_src
* 2;
152 stride_dest
= width_dest
* 2;
154 // Offset the position based on which field we're looking at ...
155 int32_t field_pos
[ 2 ];
156 field_pos
[ 0 ] = ( pos
+ ( ( field_order
== 0 ?
1 : 0 ) * frame_delta
* 0.5 ) ) * ( 1 << 16 ) * ( 1.0 + softness
);
157 field_pos
[ 1 ] = ( pos
+ ( ( field_order
== 0 ?
0 : 1 ) * frame_delta
* 0.5 ) ) * ( 1 << 16 ) * ( 1.0 + softness
);
166 int32_t x_diff
= ( luma_width
<< 16 ) / *width
;
167 int32_t y_diff
= ( luma_height
<< 16 ) / *height
;
168 int32_t x_offset
= 0;
169 int32_t y_offset
= 0;
173 int32_t i_softness
= softness
* ( 1 << 16 );
175 int field_count
= field_order
< 0 ?
1 : 2;
176 int field_stride_src
= field_count
* stride_src
;
177 int field_stride_dest
= field_count
* stride_dest
;
180 // composite using luma map
181 while ( field
< field_count
)
183 p_row
= p_src
+ field
* stride_src
;
184 q_row
= p_dest
+ field
* stride_dest
;
185 y_offset
= field
<< 16;
188 while ( i
< height_src
)
193 l
= luma_bitmap
+ ( y_offset
>> 16 ) * ( luma_width
* field_count
);
199 weight
= l
[ x_offset
>> 16 ];
200 value
= smoothstep( weight
, i_softness
+ weight
, field_pos
[ field
] );
201 *o
++ = ( *p
++ * value
+ *q
++ * ( ( 1 << 16 ) - value
) ) >> 16;
202 *o
++ = ( *p
++ * value
+ *q
++ * ( ( 1 << 16 ) - value
) ) >> 16;
208 p_row
+= field_stride_src
;
209 q_row
+= field_stride_dest
;
216 /** Load the luma map from PGM stream.
219 static void luma_read_pgm( FILE *f
, uint16_t **map
, int *width
, int *height
)
221 uint8_t *data
= NULL
;
233 // get the magic code
234 if ( fgets( line
, 127, f
) == NULL
)
238 while ( sscanf( line
, " #%s", comment
) > 0 )
239 if ( fgets( line
, 127, f
) == NULL
)
242 if ( line
[0] != 'P' || line
[1] != '5' )
245 // skip white space and see if a new line must be fetched
246 for ( i
= 2; i
< 127 && line
[i
] != '\0' && isspace( line
[i
] ); i
++ );
247 if ( ( line
[i
] == '\0' || line
[i
] == '#' ) && fgets( line
, 127, f
) == NULL
)
251 while ( sscanf( line
, " #%s", comment
) > 0 )
252 if ( fgets( line
, 127, f
) == NULL
)
255 // get the dimensions
256 if ( line
[0] == 'P' )
257 i
= sscanf( line
, "P5 %d %d %d", width
, height
, &maxval
);
259 i
= sscanf( line
, "%d %d %d", width
, height
, &maxval
);
261 // get the height value, if not yet
264 if ( fgets( line
, 127, f
) == NULL
)
268 while ( sscanf( line
, " #%s", comment
) > 0 )
269 if ( fgets( line
, 127, f
) == NULL
)
272 i
= sscanf( line
, "%d", height
);
279 // get the maximum gray value, if not yet
282 if ( fgets( line
, 127, f
) == NULL
)
286 while ( sscanf( line
, " #%s", comment
) > 0 )
287 if ( fgets( line
, 127, f
) == NULL
)
290 i
= sscanf( line
, "%d", &maxval
);
295 // determine if this is one or two bytes per pixel
296 bpp
= maxval
> 255 ?
2 : 1;
298 // allocate temporary storage for the raw data
299 data
= mlt_pool_alloc( *width
* *height
* bpp
);
304 if ( fread( data
, *width
* *height
* bpp
, 1, f
) != 1 )
307 // allocate the luma bitmap
308 *map
= p
= (uint16_t*)mlt_pool_alloc( *width
* *height
* sizeof( uint16_t ) );
312 // proces the raw data into the luma bitmap
313 for ( i
= 0; i
< *width
* *height
* bpp
; i
+= bpp
)
316 *p
++ = data
[ i
] << 8;
318 *p
++ = ( data
[ i
] << 8 ) + data
[ i
+1 ];
325 mlt_pool_release( data
);
328 /** Generate a luma map from an RGB image.
331 static void luma_read_yuv422( uint8_t *image
, uint16_t **map
, int width
, int height
)
334 int size
= width
* height
* 2;
336 // allocate the luma bitmap
337 uint16_t *p
= *map
= ( uint16_t* )mlt_pool_alloc( width
* height
* sizeof( uint16_t ) );
341 // proces the image data into the luma bitmap
342 for ( i
= 0; i
< size
; i
+= 2 )
343 *p
++ = ( image
[ i
] - 16 ) * 299; // 299 = 65535 / 219
346 /** Generate a luma map from a YUV image.
348 static void luma_read_rgb24( uint8_t *image
, uint16_t **map
, int width
, int height
)
355 static int transition_get_image( mlt_frame a_frame
, uint8_t **image
, mlt_image_format
*format
, int *width
, int *height
, int writable
)
357 // Get the b frame from the stack
358 mlt_frame b_frame
= mlt_frame_pop_frame( a_frame
);
360 // Get the transition object
361 mlt_transition transition
= mlt_frame_pop_service( a_frame
);
363 // Get the properties of the transition
364 mlt_properties properties
= MLT_TRANSITION_PROPERTIES( transition
);
366 // Get the properties of the a frame
367 mlt_properties a_props
= MLT_FRAME_PROPERTIES( a_frame
);
369 // Get the properties of the b frame
370 mlt_properties b_props
= MLT_FRAME_PROPERTIES( b_frame
);
372 // The cached luma map information
373 int luma_width
= mlt_properties_get_int( properties
, "width" );
374 int luma_height
= mlt_properties_get_int( properties
, "height" );
375 uint16_t *luma_bitmap
= mlt_properties_get_data( properties
, "bitmap", NULL
);
377 // If the filename property changed, reload the map
378 char *resource
= mlt_properties_get( properties
, "resource" );
380 // Correct width/height if not specified
381 if ( luma_width
== 0 || luma_height
== 0 )
383 luma_width
= mlt_properties_get_int( a_props
, "width" );
384 luma_height
= mlt_properties_get_int( a_props
, "height" );
387 if ( luma_bitmap
== NULL
&& resource
!= NULL
)
390 char *extension
= strrchr( resource
, '.' );
392 if ( strchr( resource
, '%' ) )
395 sprintf( temp
, "%s/lumas/%s/%s", mlt_factory_prefix( ), mlt_environment( "MLT_NORMALISATION" ), strchr( resource
, '%' ) + 1 );
396 test
= fopen( temp
, "r" );
398 strcat( temp
, ".png" );
402 extension
= strrchr( resource
, '.' );
405 // See if it is a PGM
406 if ( extension
!= NULL
&& strcmp( extension
, ".pgm" ) == 0 )
409 FILE *f
= fopen( resource
, "r" );
413 luma_read_pgm( f
, &luma_bitmap
, &luma_width
, &luma_height
);
416 // Set the transition properties
417 mlt_properties_set_int( properties
, "width", luma_width
);
418 mlt_properties_set_int( properties
, "height", luma_height
);
419 mlt_properties_set_data( properties
, "bitmap", luma_bitmap
, luma_width
* luma_height
* 2, mlt_pool_release
, NULL
);
424 // Get the factory producer service
425 char *factory
= mlt_properties_get( properties
, "factory" );
427 // Create the producer
428 mlt_producer producer
= mlt_factory_producer( factory
, resource
);
431 if ( producer
!= NULL
)
433 // Get the producer properties
434 mlt_properties producer_properties
= MLT_PRODUCER_PROPERTIES( producer
);
436 // Ensure that we loop
437 mlt_properties_set( producer_properties
, "eof", "loop" );
439 // Now pass all producer. properties on the transition down
440 mlt_properties_pass( producer_properties
, properties
, "producer." );
442 // We will get the alpha frame from the producer
443 mlt_frame luma_frame
= NULL
;
445 // Get the luma frame
446 if ( mlt_service_get_frame( MLT_PRODUCER_SERVICE( producer
), &luma_frame
, 0 ) == 0 )
448 uint8_t *luma_image
= NULL
;
449 mlt_image_format luma_format
= mlt_image_yuv422
;
451 // Get image from the luma producer
452 mlt_properties_set( MLT_FRAME_PROPERTIES( luma_frame
), "rescale.interp", "nearest" );
453 mlt_frame_get_image( luma_frame
, &luma_image
, &luma_format
, &luma_width
, &luma_height
, 0 );
455 // Generate the luma map
456 if ( luma_image
!= NULL
&& luma_format
== mlt_image_yuv422
)
457 luma_read_yuv422( luma_image
, &luma_bitmap
, luma_width
, luma_height
);
459 else if ( luma_image
!= NULL
&& luma_format
== mlt_image_rgb24
)
460 luma_read_rgb24( luma_image
, &luma_bitmap
, luma_width
, luma_height
);
462 // Set the transition properties
463 mlt_properties_set_int( properties
, "width", luma_width
);
464 mlt_properties_set_int( properties
, "height", luma_height
);
465 mlt_properties_set_data( properties
, "bitmap", luma_bitmap
, luma_width
* luma_height
* 2, mlt_pool_release
, NULL
);
467 // Cleanup the luma frame
468 mlt_frame_close( luma_frame
);
471 // Cleanup the luma producer
472 mlt_producer_close( producer
);
477 // Arbitrary composite defaults
478 float mix
= position_calculate( transition
, a_frame
);
479 float frame_delta
= delta_calculate( transition
, a_frame
);
481 float luma_softness
= mlt_properties_get_double( properties
, "softness" );
483 mlt_properties_get_int( a_props
, "consumer_deinterlace" ) ||
484 mlt_properties_get_int( properties
, "progressive" ) ||
485 mlt_properties_get_int( b_props
, "luma.progressive" );
486 int top_field_first
= mlt_properties_get_int( b_props
, "top_field_first" );
487 int reverse
= mlt_properties_get_int( properties
, "reverse" );
488 int invert
= mlt_properties_get_int( properties
, "invert" );
490 if ( mlt_properties_get( a_props
, "rescale.interp" ) == NULL
|| !strcmp( mlt_properties_get( a_props
, "rescale.interp" ), "none" ) )
491 mlt_properties_set( a_props
, "rescale.interp", "nearest" );
493 // Since we are the consumer of the b_frame, we must pass along this
494 // consumer property from the a_frame
495 if ( mlt_properties_get_double( a_props
, "aspect_ratio" ) == 0.0 )
496 mlt_properties_set_double( a_props
, "aspect_ratio", mlt_properties_get_double( a_props
, "consumer_aspect_ratio" ) );
497 if ( mlt_properties_get_double( b_props
, "aspect_ratio" ) == 0.0 )
498 mlt_properties_set_double( b_props
, "aspect_ratio", mlt_properties_get_double( a_props
, "consumer_aspect_ratio" ) );
499 mlt_properties_set_double( b_props
, "consumer_aspect_ratio", mlt_properties_get_double( a_props
, "consumer_aspect_ratio" ) );
501 // Honour the reverse here
505 mix
= reverse
|| invert ?
1 - mix
: mix
;
506 frame_delta
*= reverse
|| invert ?
-1.0 : 1.0;
508 // Ensure we get scaling on the b_frame
509 if ( mlt_properties_get( b_props
, "rescale.interp" ) == NULL
|| !strcmp( mlt_properties_get( b_props
, "rescale.interp" ), "none" ) )
510 mlt_properties_set( b_props
, "rescale.interp", "nearest" );
512 if ( mlt_properties_get( properties
, "fixed" ) )
513 mix
= mlt_properties_get_double( properties
, "fixed" );
515 if ( luma_width
> 0 && luma_height
> 0 && luma_bitmap
!= NULL
)
516 // Composite the frames using a luma map
517 luma_composite( !invert ? a_frame
: b_frame
, !invert ? b_frame
: a_frame
, luma_width
, luma_height
, luma_bitmap
, mix
, frame_delta
,
518 luma_softness
, progressive ?
-1 : top_field_first
, width
, height
);
520 // Dissolve the frames using the time offset for mix value
521 dissolve_yuv( a_frame
, b_frame
, mix
, *width
, *height
);
523 // Extract the a_frame image info
524 *width
= mlt_properties_get_int( !invert ? a_props
: b_props
, "width" );
525 *height
= mlt_properties_get_int( !invert ? a_props
: b_props
, "height" );
526 *image
= mlt_properties_get_data( !invert ? a_props
: b_props
, "image", NULL
);
532 /** Luma transition processing.
535 static mlt_frame
transition_process( mlt_transition transition
, mlt_frame a_frame
, mlt_frame b_frame
)
537 // Get a unique name to store the frame position
538 char *name
= mlt_properties_get( MLT_TRANSITION_PROPERTIES( transition
), "_unique_id" );
540 // Assign the current position to the name
541 mlt_properties_set_position( MLT_FRAME_PROPERTIES( a_frame
), name
, mlt_frame_get_position( a_frame
) );
543 // Push the transition on to the frame
544 mlt_frame_push_service( a_frame
, transition
);
546 // Push the b_frame on to the stack
547 mlt_frame_push_frame( a_frame
, b_frame
);
549 // Push the transition method
550 mlt_frame_push_get_image( a_frame
, transition_get_image
);
555 /** Constructor for the filter.
558 mlt_transition
transition_luma_init( char *lumafile
)
560 mlt_transition transition
= mlt_transition_new( );
561 if ( transition
!= NULL
)
564 transition
->process
= transition_process
;
567 mlt_properties_set( MLT_TRANSITION_PROPERTIES( transition
), "factory", "fezzik" );
569 // Set the main property
570 mlt_properties_set( MLT_TRANSITION_PROPERTIES( transition
), "resource", lumafile
);
572 // Inform apps and framework that this is a video only transition
573 mlt_properties_set_int( MLT_TRANSITION_PROPERTIES( transition
), "_transition_type", 1 );