X-Git-Url: http://research.m1stereo.tv/gitweb?a=blobdiff_plain;f=src%2Fframework%2Fmlt_frame.c;h=3b11fcf1357317f3819f2dd7ecdde1cc2d562f21;hb=41cbc901f138ce1ba5ed3cbde5942b91d2b803a0;hp=6b1558fc6a3c03e60e7e518ac7b681ffd091fb9f;hpb=092636b85449e57fd33ffd4954a2de23c2a5f81c;p=melted diff --git a/src/framework/mlt_frame.c b/src/framework/mlt_frame.c index 6b1558f..3b11fcf 100644 --- a/src/framework/mlt_frame.c +++ b/src/framework/mlt_frame.c @@ -239,17 +239,20 @@ int mlt_frame_get_audio( mlt_frame this, int16_t **buffer, mlt_audio_format *for } else { + if ( *samples <= 0 ) + *samples = 1920; + if ( *channels <= 0 ) + *channels = 2; + if ( *frequency <= 0 ) + *frequency = 48000; if ( test_card.afmt != *format ) { test_card.afmt = *format; - test_card.audio = realloc( test_card.audio, 1920 * 2 * sizeof( int16_t ) ); - memset( test_card.audio, 0, 1920 * 2 * sizeof( int16_t ) ); + test_card.audio = realloc( test_card.audio, *samples * *channels * sizeof( int16_t ) ); + memset( test_card.audio, 0, *samples * *channels * sizeof( int16_t ) ); } *buffer = test_card.audio; - *frequency = 48000; - *channels = 2; - *samples = 1920; } return 0; } @@ -362,18 +365,50 @@ int mlt_convert_rgb24_to_yuv422( uint8_t *rgb, int width, int height, int stride return ret; } +int mlt_convert_yuv420p_to_yuv422( uint8_t *yuv420p, int width, int height, int stride, uint8_t *yuv ) +{ + int ret = 0; + register int i, j; + + int half = width >> 1; + + uint8_t *Y = yuv420p; + uint8_t *U = Y + width * height; + uint8_t *V = U + width * height / 4; + + register uint8_t *d = yuv; + + for ( i = 0; i < height; i++ ) + { + register uint8_t *u = U + ( i / 2 ) * ( half ); + register uint8_t *v = V + ( i / 2 ) * ( half ); + + for ( j = 0; j < half; j++ ) + { + *d ++ = *Y ++; + *d ++ = *u ++; + *d ++ = *Y ++; + *d ++ = *v ++; + } + } + return ret; +} + int mlt_frame_composite_yuv( mlt_frame this, mlt_frame that, int x, int y, float weight ) { int ret = 0; - int x_start = 0; int width_src, height_src; int width_dest, height_dest; mlt_image_format format_src, format_dest; uint8_t *p_src, *p_dest; - int x_end; 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; @@ -381,52 +416,68 @@ int mlt_frame_composite_yuv( mlt_frame this, mlt_frame that, int x, int y, float mlt_frame_get_image( this, &p_dest, &format_dest, &width_dest, &height_dest, 1 /* writable */ ); mlt_frame_get_image( that, &p_src, &format_src, &width_src, &height_src, 0 /* writable */ ); - x_end = width_src; - stride_src = width_src * 2; stride_dest = width_dest * 2; - uint8_t *lower = p_dest; - uint8_t *upper = p_dest + height_dest * stride_dest; - - p_dest += ( y * stride_dest ) + ( x * 2 ); - + + // crop overlay off the left edge of frame if ( x < 0 ) { - x_start = -x; - x_end += x_start; + 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; - uint8_t *z = mlt_frame_get_alpha_mask( that ); + // 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 ++ ) { - if ( q >= lower && q < upper && j >= x_start && j < x_end ) - { 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 ) ); - } - else - { - p += 2; - o += 2; - q += 2; - if ( z != NULL ) - z += 1; - } } p_src += stride_src; p_dest += stride_dest; + if ( p_alpha ) + p_alpha += stride_src / 2; } return ret; @@ -446,6 +497,11 @@ void mlt_resize_yuv422( uint8_t *output, int owidth, int oheight, uint8_t *input int istride = iwidth * 2; int ostride = owidth * 2; + iwidth = iwidth - ( iwidth % 4 ); + owidth = owidth - ( owidth % 4 ); + iheight = iheight - ( iheight % 2 ); + oheight = oheight - ( oheight % 2 ); + // Coordinates (0,0 is middle of output) int y; @@ -457,7 +513,7 @@ void mlt_resize_yuv422( uint8_t *output, int owidth, int oheight, uint8_t *input // Output pointers uint8_t *out_line = output; - uint8_t *out_ptr; + uint8_t *out_ptr = out_line; // Calculate a middle and possibly invalid pointer in the input uint8_t *in_middle = input + istride * ( iheight / 2 ) + ( iwidth / 2 ) * 2; @@ -477,8 +533,8 @@ void mlt_resize_yuv422( uint8_t *output, int owidth, int oheight, uint8_t *input out_ptr = memfill( out_ptr, black, 2, out_x_range - in_x_range ); // We're in the input range for this row. - memcpy( out_ptr, in_middle + in_line, 4 * in_x_range ); - out_ptr += 4 * in_x_range; + memcpy( out_ptr, in_middle + in_line, 2 * iwidth ); + out_ptr += 2 * iwidth; // Fill the outer part with black out_ptr = memfill( out_ptr, black, 2, out_x_range - in_x_range ); @@ -557,6 +613,8 @@ uint8_t *mlt_frame_rescale_yuv422( mlt_frame this, int owidth, int oheight ) int istride = iwidth * 2; int ostride = owidth * 2; + iwidth = iwidth - ( iwidth % 4 ); + // Coordinates (0,0 is middle of output) int y, x; @@ -604,7 +662,7 @@ uint8_t *mlt_frame_rescale_yuv422( mlt_frame this, int owidth, int oheight ) 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 ); + in_ptr = in_line + ( dx >> 1 ) * 4 + 2 * ( x & 1 ); *out_ptr ++ = *in_ptr ++; *out_ptr ++ = *in_ptr ++; } @@ -633,3 +691,147 @@ uint8_t *mlt_frame_rescale_yuv422( mlt_frame this, int owidth, int oheight ) return input; } +int mlt_frame_mix_audio( mlt_frame this, mlt_frame that, float weight, int16_t **buffer, mlt_audio_format *format, int *frequency, int *channels, int *samples ) +{ + int ret = 0; + int16_t *p_src, *p_dest; + 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, frequency_dest; + int channels_src, channels_dest; + int samples_src, samples_dest; + int i, j; + + mlt_frame_get_audio( this, &p_dest, format, &frequency_dest, &channels_dest, &samples_dest ); + mlt_frame_get_audio( that, &p_src, format, &frequency_src, &channels_src, &samples_src ); + //fprintf( stderr, "frame dest samples %d channels %d\n", samples_dest, channels_dest ); + //fprintf( stderr, "frame src samples %d channels %d\n", samples_src, channels_src ); + + +#if 0 + // Append new samples to leftovers + if ( extra_dest_samples > 0 ) + { + fprintf( stderr, "prepending %d samples to dest\n", extra_dest_samples ); + dest = realloc( extra_dest, ( samples_dest + extra_dest_samples ) * 2 * channels_dest ); + memcpy( &extra_dest[ extra_dest_samples * channels_dest ], p_dest, samples_dest * 2 * channels_dest ); + } + else + dest = p_dest; + if ( extra_src_samples > 0 ) + { + fprintf( stderr, "prepending %d samples to src\n", extra_src_samples ); + src = realloc( extra_src, ( samples_src + extra_src_samples ) * 2 * channels_src ); + memcpy( &extra_src[ extra_src_samples * channels_src ], p_src, samples_src * 2 * channels_src ); + } + else + src = p_src; +#else + src = p_src; + dest = p_dest; +#endif + + // determine number of samples to process + if ( samples_src + extra_src_samples < samples_dest + extra_dest_samples ) + *samples = samples_src + extra_src_samples; + else if ( samples_dest + extra_dest_samples < samples_src + extra_src_samples ) + *samples = samples_dest + extra_dest_samples; + + *channels = channels_src < channels_dest ? channels_src : channels_dest; + *buffer = p_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 ]; + dest[ i * channels_dest + j ] = s * weight + d * ( 1.0 - weight ); + } + } + + // We have to copy --sigh + if ( dest != p_dest ) + memcpy( p_dest, dest, *samples * 2 * *channels ); + +#if 0 + // Store the leftovers + if ( samples_src + extra_src_samples < samples_dest + extra_dest_samples ) + { + extra_dest_samples = ( samples_dest + extra_dest_samples ) - ( samples_src + extra_src_samples ); + size_t size = extra_dest_samples * 2 * channels_dest; + fprintf( stderr, "storing %d samples from dest\n", extra_dest_samples ); + if ( extra_dest ) + free( extra_dest ); + extra_dest = malloc( size ); + if ( extra_dest ) + memcpy( extra_dest, &p_dest[ ( samples_dest - extra_dest_samples - 1 ) * channels_dest ], size ); + else + extra_dest_samples = 0; + } + else if ( samples_dest + extra_dest_samples < samples_src + extra_src_samples ) + { + extra_src_samples = ( samples_src + extra_src_samples ) - ( samples_dest + extra_dest_samples ); + size_t size = extra_src_samples * 2 * channels_src; + fprintf( stderr, "storing %d samples from src\n", extra_dest_samples ); + if ( extra_src ) + free( extra_src ); + extra_src = malloc( size ); + if ( extra_src ) + memcpy( extra_src, &p_src[ ( samples_src - extra_src_samples - 1 ) * channels_src ], size ); + else + extra_src_samples = 0; + } +#endif + + return ret; +} + +int mlt_sample_calculator( float fps, int frequency, int64_t position ) +{ + int samples = 0; + + if ( fps > 29 && fps <= 30 ) + { + samples = frequency / 30; + + switch ( frequency ) + { + case 48000: + if ( position % 5 != 0 ) + samples += 2; + break; + case 44100: + if ( position % 300 == 0 ) + samples = 1471; + else if ( position % 30 == 0 ) + samples = 1470; + else if ( position % 2 == 0 ) + samples = 1472; + else + samples = 1471; + break; + case 32000: + if ( position % 30 == 0 ) + samples = 1068; + else if ( position % 29 == 0 ) + samples = 1067; + else if ( position % 4 == 2 ) + samples = 1067; + else + samples = 1068; + break; + default: + samples = 0; + } + } + else if ( fps != 0 ) + { + samples = frequency / fps; + } + + return samples; +} +