mlt_properties_init( properties, this );
// Set default properties on the frame
- mlt_properties_set_position( properties, "position", 0.0 );
+ mlt_properties_set_position( properties, "_position", 0.0 );
mlt_properties_set_data( properties, "image", NULL, 0, NULL, NULL );
mlt_properties_set_int( properties, "width", 720 );
mlt_properties_set_int( properties, "height", 576 );
mlt_position mlt_frame_get_position( mlt_frame this )
{
- return mlt_properties_get_position( mlt_frame_properties( this ), "position" );
+ return mlt_properties_get_position( mlt_frame_properties( this ), "_position" );
}
/** Set the position of this frame.
int mlt_frame_set_position( mlt_frame this, mlt_position value )
{
- return mlt_properties_set_position( mlt_frame_properties( this ), "position", value );
+ return mlt_properties_set_position( mlt_frame_properties( this ), "_position", value );
}
/** Stack a get_image callback.
}
else
{
- if ( test_card.vfmt != *format )
+ if ( test_card.vfmt != *format || test_card.width != *width || test_card.height != *height || test_card.image == NULL )
{
uint8_t *p;
uint8_t *q;
-
+
test_card.vfmt = *format;
test_card.width = *width == 0 ? 720 : *width;
test_card.height = *height == 0 ? 576 : *height;
*width = test_card.width;
*height = test_card.height;
*buffer = test_card.image;
+
+ mlt_properties_set_int( properties, "width", *width );
+ mlt_properties_set_int( properties, "height", *height );
+
+ if ( writable )
+ {
+ uint8_t *copy = malloc( *width * *height * 2 );
+ memcpy( copy, *buffer, *width * *height * 2 );
+ mlt_properties_set_data( properties, "image", copy, *width * *height * 2, free, NULL );
+ *buffer = copy;
+ }
+ else
+ {
+ mlt_properties_set_data( properties, "image", *buffer, *width * *height * 2, NULL, NULL );
+ }
}
return 0;
return ret;
}
-int mlt_frame_composite_yuv( mlt_frame this, mlt_frame that, int x, int y, float weight )
-{
- int ret = 0;
- int width_src = 0, height_src = 0;
- int width_dest = 0, height_dest = 0;
- mlt_image_format format_src = mlt_image_yuv422, format_dest = mlt_image_yuv422;
- uint8_t *p_src, *p_dest;
- int i, j;
- int stride_src;
- int stride_dest;
- int x_src = 0, y_src = 0;
-
- // optimization point - no work to do
- if ( ( x < 0 && -x >= width_src ) || ( y < 0 && -y >= height_src ) )
- return ret;
-
- format_src = mlt_image_yuv422;
- format_dest = mlt_image_yuv422;
-
- //fprintf( stderr, "call get_image on frame a\n"), fflush( stderr );
- mlt_frame_get_image( this, &p_dest, &format_dest, &width_dest, &height_dest, 1 /* writable */ );
- //fprintf( stderr, "call get_image on frame b\n"), fflush( stderr );
- mlt_frame_get_image( that, &p_src, &format_src, &width_src, &height_src, 0 /* writable */ );
-
- //fprintf( stderr, "mlt_frame_composite_yuv %dx%d -> %dx%d\n", width_src, height_src, width_dest, height_dest );
- //fflush(stderr);
- //return ret;
- stride_src = width_src * 2;
- stride_dest = width_dest * 2;
-
- // crop overlay off the left edge of frame
- if ( x < 0 )
- {
- x_src = -x;
- width_src -= x_src;
- x = 0;
- }
-
- // crop overlay beyond right edge of frame
- else if ( x + width_src > width_dest )
- width_src = width_dest - x;
-
- // crop overlay off the top edge of the frame
- if ( y < 0 )
- {
- y_src = -y;
- height_src -= y_src;
- }
- // crop overlay below bottom edge of frame
- else if ( y + height_src > height_dest )
- height_src = height_dest - y;
-
- // offset pointer into overlay buffer based on cropping
- p_src += x_src * 2 + y_src * stride_src;
-
- // offset pointer into frame buffer based upon positive, even coordinates only!
-// if ( interlaced && y % 2 )
-// ++y;
- p_dest += ( x < 0 ? 0 : x ) * 2 + ( y < 0 ? 0 : y ) * stride_dest;
-
- // Get the alpha channel of the overlay
- uint8_t *p_alpha = mlt_frame_get_alpha_mask( that );
-
- // offset pointer into alpha channel based upon cropping
- if ( p_alpha )
- p_alpha += x_src + y_src * stride_src / 2;
-
- // now do the compositing only to cropped extents
- for ( i = 0; i < height_src; i++ )
- {
- uint8_t *p = p_src;
- uint8_t *q = p_dest;
- uint8_t *o = p_dest;
- uint8_t *z = p_alpha;
-
- for ( j = 0; j < width_src; j ++ )
- {
- uint8_t y = *p ++;
- uint8_t uv = *p ++;
- uint8_t a = ( z == NULL ) ? 255 : *z ++;
- float value = ( weight * ( float ) a / 255.0 );
- *o ++ = (uint8_t)( y * value + *q++ * ( 1 - value ) );
- *o ++ = (uint8_t)( uv * value + *q++ * ( 1 - value ) );
- }
-
- p_src += stride_src;
- p_dest += stride_dest;
- if ( p_alpha )
- p_alpha += stride_src / 2;
- }
-
- return ret;
-}
-
void *memfill( void *dst, void *src, int l, int elements )
{
int i = 0;
mlt_properties_set_data( properties, "image", output, owidth * oheight * 2, free, NULL );
mlt_properties_set_int( properties, "width", owidth );
mlt_properties_set_int( properties, "height", oheight );
+ mlt_frame_set_aspect_ratio( this, 4.0/3.0/*( float )owidth / oheight*/ );
// Return the output
return output;
uint8_t *in_ptr;
// Generate the affine transform scaling values
- float scale_width = ( float )iwidth / ( float )owidth;
- float scale_height = ( float )iheight / ( float )oheight;
+ int scale_width = ( iwidth << 16 ) / owidth;
+ int scale_height = ( iheight << 16 ) / oheight;
// Loop for the entirety of our output height.
for ( y = - out_y_range; y < out_y_range ; y ++ )
{
// Calculate the derived y value
- dy = scale_height * y;
+ dy = ( scale_height * y ) >> 16;
// Start at the beginning of the line
out_ptr = out_line;
for ( x = - out_x_range; x < out_x_range; x += 1 )
{
// Calculated the derived x
- dx = scale_width * x;
-
- // Check if x and y are in the valid input range.
- if ( abs( dx ) < in_x_range && abs( dy ) < in_y_range )
- {
- // We're in the input range for this row.
- in_ptr = in_line + ( dx >> 1 ) * 4 + 2 * ( x & 1 );
- *out_ptr ++ = *in_ptr ++;
- *out_ptr ++ = *in_ptr ++;
- }
- else
- {
- // We're not in the input range for this row.
- *out_ptr ++ = 16;
- *out_ptr ++ = 128;
- }
+ dx = ( scale_width * x ) >> 16;
+
+ // We're in the input range for this row.
+ in_ptr = in_line + ( dx << 1 );
+ *out_ptr ++ = *in_ptr ++;
+ in_ptr = in_line + ( ( dx >> 1 ) << 2 ) + ( ( x & 1 ) << 1 ) + 1;
+ *out_ptr ++ = *in_ptr;
}
// Move to next output line
int16_t *src, *dest;
//static int16_t *extra_src = NULL, *extra_dest = NULL;
static int extra_src_samples = 0, extra_dest_samples = 0;
- int frequency_src = 0, frequency_dest = 0;
- int channels_src = 0, channels_dest = 0;
- int samples_src = 0, samples_dest = 0;
+ int frequency_src = *frequency, frequency_dest = *frequency;
+ int channels_src = *channels, channels_dest = *channels;
+ int samples_src = *samples, samples_dest = *samples;
int i, j;
+ double d = 0, s = 0;
mlt_frame_get_audio( this, &p_dest, format, &frequency_dest, &channels_dest, &samples_dest );
- //fprintf( stderr, "frame dest samples %d channels %d position %f\n", samples_dest, channels_dest, mlt_properties_get_position( mlt_frame_properties( this ), "position" ) );
+ //fprintf( stderr, "mix: frame dest samples %d channels %d position %lld\n", samples_dest, channels_dest, mlt_properties_get_position( mlt_frame_properties( this ), "_position" ) );
mlt_frame_get_audio( that, &p_src, format, &frequency_src, &channels_src, &samples_src );
- //fprintf( stderr, "frame src samples %d channels %d\n", samples_src, channels_src );
+ //fprintf( stderr, "mix: frame src samples %d channels %d\n", samples_src, channels_src );
+ src = p_src;
+ dest = p_dest;
if ( channels_src > 6 )
channels_src = 0;
if ( channels_dest > 6 )
}
else
src = p_src;
-#else
- src = p_src;
- dest = p_dest;
#endif
// determine number of samples to process
*channels = channels_src < channels_dest ? channels_src : channels_dest;
*buffer = p_dest;
+ *frequency = frequency_dest;
// Mixdown
for ( i = 0; i < *samples; i++ )
{
for ( j = 0; j < *channels; j++ )
{
- double d = (double) dest[ i * channels_dest + j ];
- double s = (double) src[ i * channels_src + j ];
+ if ( j < channels_dest )
+ d = (double) dest[ i * channels_dest + j ];
+ if ( j < channels_src )
+ s = (double) src[ i * channels_src + j ];
dest[ i * channels_dest + j ] = s * weight + d * ( 1.0 - weight );
}
}