From e727806e894128be3004502eee4d41537fb31c7d Mon Sep 17 00:00:00 2001 From: lilo_booter Date: Mon, 1 Nov 2004 13:14:57 +0000 Subject: [PATCH] Fixes threaded pixbuf usage and removes flash when swicthing between sdl preview modes git-svn-id: https://mlt.svn.sourceforge.net/svnroot/mlt/trunk/mlt@502 d19143bc-622f-0410-bfdd-b5b2a6649095 --- src/modules/gtk2/consumer_gtk2.c | 1 + src/modules/gtk2/producer_pixbuf.c | 10 +- src/modules/sdl/consumer_sdl.c | 54 ++++--- src/modules/sdl/consumer_sdl_preview.c | 19 ++- src/modules/sdl/consumer_sdl_still.c | 251 +++++++++++++++++++++++--------- 5 files changed, 234 insertions(+), 101 deletions(-) diff --git a/src/modules/gtk2/consumer_gtk2.c b/src/modules/gtk2/consumer_gtk2.c index 4da317c..f563ecf 100644 --- a/src/modules/gtk2/consumer_gtk2.c +++ b/src/modules/gtk2/consumer_gtk2.c @@ -47,6 +47,7 @@ mlt_consumer consumer_gtk2_preview_init( GtkWidget *widget ) if ( consumer != NULL ) { mlt_properties properties = mlt_consumer_properties( consumer ); + mlt_properties_set_int( properties, "app_locked", 1 ); mlt_properties_set_data( properties, "app_lock", gdk_threads_enter, 0, NULL, NULL ); mlt_properties_set_data( properties, "app_unlock", gdk_threads_leave, 0, NULL, NULL ); } diff --git a/src/modules/gtk2/producer_pixbuf.c b/src/modules/gtk2/producer_pixbuf.c index 4cd7a4c..be66990 100644 --- a/src/modules/gtk2/producer_pixbuf.c +++ b/src/modules/gtk2/producer_pixbuf.c @@ -25,12 +25,15 @@ #include #include #include +#include #include #include #include #include #include +pthread_mutex_t fastmutex = PTHREAD_MUTEX_INITIALIZER; + typedef struct producer_pixbuf_s *producer_pixbuf; struct producer_pixbuf_s @@ -77,9 +80,6 @@ mlt_producer producer_pixbuf_init( char *filename ) mlt_properties_set( properties, "resource", filename ); mlt_properties_set_int( properties, "ttl", 25 ); - // Initialise gobject types - g_type_init(); - return producer; } free( this ); @@ -113,6 +113,8 @@ static void refresh_image( mlt_frame frame, int width, int height ) // Image index int image_idx = ( int )floor( ( double )position / ttl ) % this->count; + pthread_mutex_lock( &fastmutex ); + // optimization for subsequent iterations on single picture if ( width != 0 && this->image != NULL && image_idx == this->image_idx ) { @@ -206,6 +208,8 @@ static void refresh_image( mlt_frame frame, int width, int height ) // pass the image data without destructor mlt_properties_set_data( properties, "image", this->image, this->width * ( this->height + 1 ) * 2, NULL, NULL ); mlt_properties_set_data( properties, "alpha", this->alpha, this->width * this->height, NULL, NULL ); + + pthread_mutex_unlock( &fastmutex ); } static int producer_get_image( mlt_frame frame, uint8_t **buffer, mlt_image_format *format, int *width, int *height, int writable ) diff --git a/src/modules/sdl/consumer_sdl.c b/src/modules/sdl/consumer_sdl.c index b707f78..b5c8fd1 100644 --- a/src/modules/sdl/consumer_sdl.c +++ b/src/modules/sdl/consumer_sdl.c @@ -61,6 +61,7 @@ struct consumer_sdl_s SDL_Overlay *sdl_overlay; SDL_Rect rect; uint8_t *buffer; + int bpp; }; /** Forward references to static functions. @@ -118,7 +119,7 @@ mlt_consumer consumer_sdl_init( char *arg ) mlt_properties_set_int( this->properties, "progressive", 0 ); // Default audio buffer - mlt_properties_set_int( this->properties, "audio_buffer", 1024 ); + mlt_properties_set_int( this->properties, "audio_buffer", 512 ); // Get sample aspect ratio this->aspect_ratio = mlt_properties_get_double( this->properties, "aspect_ratio" ); @@ -417,14 +418,11 @@ static int consumer_play_video( consumer_sdl this, mlt_frame frame ) } } - if ( width != this->width || height != this->height || - ( ( int )( this->last_frame_aspect * 1000 ) != ( int )( mlt_frame_get_aspect_ratio( frame ) * 1000 ) && - ( mlt_frame_get_aspect_ratio( frame ) != 1.0 || this->last_frame_aspect == 0.0 ) ) ) + if ( width != this->width || height != this->height ) { - this->width = width; - this->height = height; - this->last_frame_aspect = mlt_frame_get_aspect_ratio( frame ); - changed = 1; + if ( this->sdl_overlay != NULL ) + SDL_FreeYUVOverlay( this->sdl_overlay ); + this->sdl_overlay = NULL; } if ( this->running && ( this->sdl_screen == NULL || changed ) ) @@ -432,16 +430,28 @@ static int consumer_play_video( consumer_sdl this, mlt_frame frame ) // Force an overlay recreation if ( this->sdl_overlay != NULL ) SDL_FreeYUVOverlay( this->sdl_overlay ); + this->sdl_overlay = NULL; // open SDL window with video overlay, if possible sdl_lock_display(); - this->sdl_screen = SDL_SetVideoMode( this->window_width, this->window_height, 0, this->sdl_flags ); + this->sdl_screen = SDL_SetVideoMode( this->window_width, this->window_height, this->bpp, this->sdl_flags ); sdl_unlock_display(); if ( consumer_get_dimensions( &this->window_width, &this->window_height ) ) - this->sdl_screen = SDL_SetVideoMode( this->window_width, this->window_height, 0, this->sdl_flags ); + this->sdl_screen = SDL_SetVideoMode( this->window_width, this->window_height, this->bpp, this->sdl_flags ); //SDL_Flip( this->sdl_screen ); mlt_properties_set_int( properties, "changed", 0 ); + } + else if ( mlt_properties_get_int( properties, "changed" ) ) + { + sdl_lock_display(); + this->sdl_screen = SDL_SetVideoMode( this->window_width, this->window_height, this->bpp, this->sdl_flags ); + SDL_SetClipRect( this->sdl_screen, &this->rect ); + sdl_unlock_display(); + mlt_properties_set_int( properties, "changed", 0 ); + } + if ( 1 ) + { // Determine window's new display aspect ratio float this_aspect = ( float )this->window_width / this->window_height; @@ -501,22 +511,16 @@ static int consumer_play_video( consumer_sdl this, mlt_frame frame ) mlt_properties_set_int( this->properties, "rect_w", this->rect.w ); mlt_properties_set_int( this->properties, "rect_h", this->rect.h ); - if ( this->sdl_screen != NULL ) - { - SDL_SetClipRect( this->sdl_screen, &this->rect ); - sdl_lock_display(); - this->sdl_overlay = SDL_CreateYUVOverlay( this->width, this->height, SDL_YUY2_OVERLAY, this->sdl_screen ); - sdl_unlock_display(); - } + SDL_SetClipRect( this->sdl_screen, &this->rect ); } - else if ( mlt_properties_get_int( properties, "changed" ) ) + + if ( this->sdl_screen != NULL && this->sdl_overlay == NULL ) { - sdl_lock_display(); - this->sdl_screen = SDL_SetVideoMode( this->window_width, this->window_height, 0, this->sdl_flags ); SDL_SetClipRect( this->sdl_screen, &this->rect ); - //SDL_Flip( this->sdl_screen ); + SDL_Flip( this->sdl_screen ); + sdl_lock_display(); + this->sdl_overlay = SDL_CreateYUVOverlay( this->width, this->height, SDL_YUY2_OVERLAY, this->sdl_screen ); sdl_unlock_display(); - mlt_properties_set_int( properties, "changed", 0 ); } if ( this->sdl_screen != NULL && this->sdl_overlay != NULL ) @@ -641,6 +645,8 @@ static void *consumer_thread( void *arg ) int64_t playtime = 0; struct timespec tm = { 0, 100000 }; + this->bpp = mlt_properties_get_int( this->properties, "bpp" ); + if ( mlt_properties_get_int( mlt_consumer_properties( consumer ), "sdl_started" ) == 0 ) { if ( SDL_Init( SDL_INIT_VIDEO | SDL_INIT_NOPARACHUTE ) < 0 ) @@ -655,7 +661,11 @@ static void *consumer_thread( void *arg ) else { if ( SDL_GetVideoSurface( ) != NULL ) + { + this->sdl_screen = SDL_GetVideoSurface( ); consumer_get_dimensions( &this->window_width, &this->window_height ); + mlt_properties_set_int( this->properties, "changed", 0 ); + } } if ( !mlt_properties_get_int( mlt_consumer_properties( consumer ), "audio_off" ) ) diff --git a/src/modules/sdl/consumer_sdl_preview.c b/src/modules/sdl/consumer_sdl_preview.c index 5415ed3..84a2c30 100644 --- a/src/modules/sdl/consumer_sdl_preview.c +++ b/src/modules/sdl/consumer_sdl_preview.c @@ -139,11 +139,20 @@ static int consumer_stop( mlt_consumer parent ) if ( this->joined == 0 ) { + mlt_properties properties = mlt_consumer_properties( parent ); + int app_locked = mlt_properties_get_int( properties, "app_locked" ); + void ( *lock )( void ) = mlt_properties_get_data( properties, "app_lock", NULL ); + void ( *unlock )( void ) = mlt_properties_get_data( properties, "app_unlock", NULL ); + + if ( app_locked && unlock ) unlock( ); + // Kill the thread and clean up this->running = 0; pthread_join( this->thread, NULL ); this->joined = 1; + + if ( app_locked && lock ) lock( ); } return 0; @@ -190,12 +199,14 @@ static void *consumer_thread( void *arg ) mlt_properties_set_data( still, "transport_producer", mlt_properties_get_data( properties, "transport_producer", NULL ), 0, NULL, NULL ); mlt_properties_set_data( play, "transport_callback", mlt_properties_get_data( properties, "transport_callback", NULL ), 0, NULL, NULL ); mlt_properties_set_data( still, "transport_callback", mlt_properties_get_data( properties, "transport_callback", NULL ), 0, NULL, NULL ); + mlt_properties_set_int( play, "resize", mlt_properties_get_int( properties, "resize" ) ); + mlt_properties_set_int( still, "resize", mlt_properties_get_int( properties, "resize" ) ); mlt_properties_set( play, "rescale", mlt_properties_get( properties, "rescale" ) ); mlt_properties_set( still, "rescale", mlt_properties_get( properties, "rescale" ) ); - mlt_properties_set( play, "width", mlt_properties_get( properties, "width" ) ); - mlt_properties_set( still, "width", mlt_properties_get( properties, "width" ) ); - mlt_properties_set( play, "height", mlt_properties_get( properties, "height" ) ); - mlt_properties_set( still, "height", mlt_properties_get( properties, "height" ) ); + mlt_properties_set_int( play, "width", mlt_properties_get_int( properties, "width" ) ); + mlt_properties_set_int( still, "width", mlt_properties_get_int( properties, "width" ) ); + mlt_properties_set_int( play, "height", mlt_properties_get_int( properties, "height" ) ); + mlt_properties_set_int( still, "height", mlt_properties_get_int( properties, "height" ) ); mlt_properties_set_int( play, "progressive", 1 ); mlt_properties_set_int( still, "progressive", 1 ); diff --git a/src/modules/sdl/consumer_sdl_still.c b/src/modules/sdl/consumer_sdl_still.c index 3cf9d09..cdc2b0f 100644 --- a/src/modules/sdl/consumer_sdl_still.c +++ b/src/modules/sdl/consumer_sdl_still.c @@ -224,6 +224,126 @@ static void sdl_unlock_display( ) SDL_UnlockSurface( screen ); } +static inline void display_1( SDL_Surface *screen, SDL_Rect rect, uint8_t *image, int width, int height ) +{ + // Generate the affine transform scaling values + int scale_width = ( width << 16 ) / rect.w; + int scale_height = ( height << 16 ) / rect.h; + int stride = width * 3; + int x, y, row_index; + uint8_t *q, *row; + + // Constants defined for clarity and optimisation + int scanlength = screen->pitch; + uint8_t *start = ( uint8_t * )screen->pixels + rect.y * scanlength + rect.x; + uint8_t *p; + + // Iterate through the screen using a very basic scaling algorithm + for ( y = 0; y < rect.h; y ++ ) + { + p = start; + row_index = ( scale_height * y ) >> 16; + row = image + stride * row_index; + for ( x = 0; x < rect.w; x ++ ) + { + q = row + ( ( ( scale_width * x ) >> 16 ) * 3 ); + *p ++ = SDL_MapRGB( screen->format, *q, *( q + 1 ), *( q + 2 ) ); + } + start += scanlength; + } +} + +static inline void display_2( SDL_Surface *screen, SDL_Rect rect, uint8_t *image, int width, int height ) +{ + // Generate the affine transform scaling values + int scale_width = ( width << 16 ) / rect.w; + int scale_height = ( height << 16 ) / rect.h; + int stride = width * 3; + int x, y, row_index; + uint8_t *q, *row; + + // Constants defined for clarity and optimisation + int scanlength = screen->pitch / 2; + uint16_t *start = ( uint16_t * )screen->pixels + rect.y * scanlength + rect.x; + uint16_t *p; + + // Iterate through the screen using a very basic scaling algorithm + for ( y = 0; y < rect.h; y ++ ) + { + p = start; + row_index = ( scale_height * y ) >> 16; + row = image + stride * row_index; + for ( x = 0; x < rect.w; x ++ ) + { + q = row + ( ( ( scale_width * x ) >> 16 ) * 3 ); + *p ++ = SDL_MapRGB( screen->format, *q, *( q + 1 ), *( q + 2 ) ); + } + start += scanlength; + } +} + +static inline void display_3( SDL_Surface *screen, SDL_Rect rect, uint8_t *image, int width, int height ) +{ + // Generate the affine transform scaling values + int scale_width = ( width << 16 ) / rect.w; + int scale_height = ( height << 16 ) / rect.h; + int stride = width * 3; + int x, y, row_index; + uint8_t *q, *row; + + // Constants defined for clarity and optimisation + int scanlength = screen->pitch; + uint8_t *start = ( uint8_t * )screen->pixels + rect.y * scanlength + rect.x; + uint8_t *p; + uint32_t pixel; + + // Iterate through the screen using a very basic scaling algorithm + for ( y = 0; y < rect.h; y ++ ) + { + p = start; + row_index = ( scale_height * y ) >> 16; + row = image + stride * row_index; + for ( x = 0; x < rect.w; x ++ ) + { + q = row + ( ( ( scale_width * x ) >> 16 ) * 3 ); + pixel = SDL_MapRGB( screen->format, *q, *( q + 1 ), *( q + 2 ) ); + *p ++ = (pixel & 0xFF0000) >> 16; + *p ++ = (pixel & 0x00FF00) >> 8; + *p ++ = (pixel & 0x0000FF); + } + start += scanlength; + } +} + +static inline void display_4( SDL_Surface *screen, SDL_Rect rect, uint8_t *image, int width, int height ) +{ + // Generate the affine transform scaling values + int scale_width = ( width << 16 ) / rect.w; + int scale_height = ( height << 16 ) / rect.h; + int stride = width * 3; + int x, y, row_index; + uint8_t *q, *row; + + // Constants defined for clarity and optimisation + int scanlength = screen->pitch / 4; + uint32_t *start = ( uint32_t * )screen->pixels + rect.y * scanlength + rect.x; + uint32_t *p; + + // Iterate through the screen using a very basic scaling algorithm + for ( y = 0; y < rect.h; y ++ ) + { + p = start; + row_index = ( scale_height * y ) >> 16; + row = image + stride * row_index; + for ( x = 0; x < rect.w; x ++ ) + { + q = row + ( ( ( scale_width * x ) >> 16 ) * 3 ); + *p ++ = SDL_MapRGB( screen->format, *q, *( q + 1 ), *( q + 2 ) ); + } + start += scanlength; + } +} + static int consumer_play_video( consumer_sdl this, mlt_frame frame ) { // Get the properties of this consumer @@ -279,52 +399,23 @@ static int consumer_play_video( consumer_sdl this, mlt_frame frame ) } } - if ( ( ( int )( this->last_frame_aspect * 1000 ) != ( int )( mlt_frame_get_aspect_ratio( frame ) * 1000 ) && - ( mlt_frame_get_aspect_ratio( frame ) != 1.0 || this->last_frame_aspect == 0.0 ) ) ) - { - this->last_frame_aspect = mlt_frame_get_aspect_ratio( frame ); - changed = 1; - } - if ( this->sdl_screen == NULL || changed || mlt_properties_get_int( properties, "changed" ) == 2 ) { // open SDL window - this->sdl_screen = SDL_SetVideoMode( this->window_width, this->window_height, 16, this->sdl_flags ); + this->sdl_screen = SDL_SetVideoMode( this->window_width, this->window_height, 0, this->sdl_flags ); if ( consumer_get_dimensions( &this->window_width, &this->window_height ) ) - this->sdl_screen = SDL_SetVideoMode( this->window_width, this->window_height, 16, this->sdl_flags ); + this->sdl_screen = SDL_SetVideoMode( this->window_width, this->window_height, 0, this->sdl_flags ); changed = 1; mlt_properties_set_int( properties, "changed", 0 ); - - // May as well use the mlt rescaler... - //if ( mlt_properties_get( properties, "rescale" ) != NULL && !strcmp( mlt_properties_get( properties, "rescale" ), "none" ) ) - //mlt_properties_set( properties, "rescale", "nearest" ); - - // Determine window's new display aspect ratio - float this_aspect = this->display_aspect / ( ( float )this->window_width / ( float )this->window_height ); - - this->rect.w = this_aspect * this->window_width; - this->rect.h = this->window_height; - if ( this->rect.w > this->window_width ) - { - this->rect.w = this->window_width; - this->rect.h = ( 1.0 / this_aspect ) * this->window_height; - } - - this->rect.x = ( this->window_width - this->rect.w ) / 2; - this->rect.y = ( this->window_height - this->rect.h ) / 2; - - mlt_properties_set_int( this->properties, "rect_x", this->rect.x ); - mlt_properties_set_int( this->properties, "rect_y", this->rect.y ); - mlt_properties_set_int( this->properties, "rect_w", this->rect.w ); - mlt_properties_set_int( this->properties, "rect_h", this->rect.h ); } else { changed = mlt_properties_get_int( properties, "changed" ) | mlt_properties_get_int( mlt_frame_properties( frame ), "refresh" ); mlt_properties_set_int( properties, "changed", 0 ); } - + + if ( changed == 0 && this->last_position == mlt_frame_get_position( frame ) && this->last_producer == mlt_properties_get_data( mlt_frame_properties( frame ), "_producer", NULL ) ) @@ -355,50 +446,62 @@ static int consumer_play_video( consumer_sdl this, mlt_frame frame ) mlt_frame_get_image( frame, &image, &vfmt, &width, &height, 0 ); } - if ( this->sdl_screen != NULL ) + if ( 1 ) { - // Calculate the scan length - int scanlength = this->sdl_screen->pitch / 2; - - // Obtain the clip rect from the screen - SDL_Rect rect = this->rect; - - // Generate the affine transform scaling values - int scale_width = ( width << 16 ) / rect.w; - int scale_height = ( height << 16 ) / rect.h; - - // Constants defined for clarity and optimisation - int stride = width * 3; - uint16_t *start = ( uint16_t * )this->sdl_screen->pixels + rect.y * scanlength + rect.x; - - int x, y, row_index; - uint16_t *p; - uint8_t *q, *row; - - // Iterate through the screen using a very basic scaling algorithm - for ( y = 0; y < rect.h && this->last_position != -1; y ++ ) + char *rescale = mlt_properties_get( properties, "rescale" ); + if ( rescale != NULL && strcmp( rescale, "none" ) ) { - // Obtain the pointer to the current screen row - p = start; - - // Calculate the row_index - row_index = ( scale_height * y ) >> 16; - - // Calculate the pointer for the y offset (positioned on B instead of R) - row = image + stride * row_index; - - // Iterate through the screen width - for ( x = 0; x < rect.w; x ++ ) + float this_aspect = this->display_aspect / ( ( float )this->window_width / ( float )this->window_height ); + this->rect.w = this_aspect * this->window_width; + this->rect.h = this->window_height; + if ( this->rect.w > this->window_width ) { - // Obtain the pixel pointer - q = row + ( ( ( scale_width * x ) >> 16 ) * 3 ); - - // Map the BGR colour from the frame to the SDL format - *p ++ = SDL_MapRGB( this->sdl_screen->format, *q, *( q + 1 ), *( q + 2 ) ); + this->rect.w = this->window_width; + this->rect.h = ( 1.0 / this_aspect ) * this->window_height; } + } + else + { + float frame_aspect = mlt_frame_get_aspect_ratio( frame ) * width / height; + this->rect.w = frame_aspect * this->window_height; + this->rect.h = this->window_height; + if ( this->rect.w > this->window_width ) + { + this->rect.w = this->window_width; + this->rect.h = ( 1.0 / frame_aspect ) * this->window_width; + } + } + + this->rect.x = ( this->window_width - this->rect.w ) / 2; + this->rect.y = ( this->window_height - this->rect.h ) / 2; - // Move to the next row - start += scanlength; + mlt_properties_set_int( this->properties, "rect_x", this->rect.x ); + mlt_properties_set_int( this->properties, "rect_y", this->rect.y ); + mlt_properties_set_int( this->properties, "rect_w", this->rect.w ); + mlt_properties_set_int( this->properties, "rect_h", this->rect.h ); + } + + if ( this->sdl_screen != NULL ) + { + memset( this->sdl_screen->pixels, 0, this->window_width * this->window_height * this->sdl_screen->format->BytesPerPixel ); + + switch( this->sdl_screen->format->BytesPerPixel ) + { + case 1: + display_1( this->sdl_screen, this->rect, image, width, height ); + break; + case 2: + display_2( this->sdl_screen, this->rect, image, width, height ); + break; + case 3: + display_3( this->sdl_screen, this->rect, image, width, height ); + break; + case 4: + display_4( this->sdl_screen, this->rect, image, width, height ); + break; + default: + fprintf( stderr, "Unsupported video depth %d\n", this->sdl_screen->format->BytesPerPixel ); + break; } // Flip it into sight @@ -442,7 +545,11 @@ static void *consumer_thread( void *arg ) { mlt_properties_set_int( mlt_consumer_properties( consumer ), "changed", 2 ); if ( SDL_GetVideoSurface( ) != NULL ) + { + this->sdl_screen = SDL_GetVideoSurface( ); consumer_get_dimensions( &this->window_width, &this->window_height ); + mlt_properties_set_int( mlt_consumer_properties( consumer ), "changed", 0 ); + } } // Loop until told not to -- 1.7.4.4