aspect fixes for rescale=none

git-svn-id: https://mlt.svn.sourceforge.net/svnroot/mlt/trunk/mlt@259 d19143bc-622f-0410-bfdd-b5b2a6649095

diff --git a/demo/consumers.ini b/demo/consumers.ini
index 7cd55e5050df6f645b974b6d5c8a0fc11d1c25ab..e70707084a88745785936864e25ac4b2fe13f5a3 100644 (file)
--- a/demo/consumers.ini
+++ b/demo/consumers.ini
@@ -1,5 +1,5 @@
 SDL Default                                            sdl
-SDL Half D1                                            sdl:360x288 rescale=nearest
+SDL Half D1                                            sdl:384x288 rescale=nearest
 SDL High Latency                               sdl buffer=12 rescale=none
 SDL Progressive                                        sdl progressive=1
 Westley to Terminal                            westley

diff --git a/src/modules/gtk2/filter_rescale.c b/src/modules/gtk2/filter_rescale.c
index c57e33d1bd3a86ad59b5a9c00b65f950b82ae3e0..936e0e6d49570dacc43bf2491587c97a32150e81 100644 (file)
--- a/src/modules/gtk2/filter_rescale.c
+++ b/src/modules/gtk2/filter_rescale.c
@@ -65,8 +65,17 @@ static int filter_get_image( mlt_frame this, uint8_t **image, mlt_image_format *
        }
 
        // Let the producer know what we are actually requested to obtain
-       mlt_properties_set_int( properties, "rescale_width", *width );
-       mlt_properties_set_int( properties, "rescale_height", *height );
+       if ( *format == mlt_image_yuv422 && strcmp( interps, "none" ) )
+       {
+               mlt_properties_set_int( properties, "rescale_width", *width );
+               mlt_properties_set_int( properties, "rescale_height", *height );
+       }
+       else
+       {
+               // When no scaling is requested, revert the requested dimensions if possible
+               mlt_properties_set_int( properties, "rescale_width", ( iwidth / 2 ) * 2 );
+               mlt_properties_set_int( properties, "rescale_height", ( iheight /2 ) * 2 );
+       }
 
        // Get the image as requested
        mlt_frame_get_image( this, &input, format, &iwidth, &iheight, writable );

diff --git a/src/modules/gtk2/producer_pixbuf.c b/src/modules/gtk2/producer_pixbuf.c
index d6eeb4220e1c004c73b25a56fb2b1d372cf25cd3..5007ad7bdbe0a885c0dfab184cb61ac8bc1a75a9 100644 (file)
--- a/src/modules/gtk2/producer_pixbuf.c
+++ b/src/modules/gtk2/producer_pixbuf.c
@@ -219,10 +219,6 @@ static int producer_get_image( mlt_frame frame, uint8_t **buffer, mlt_image_form
        // Refresh the image
        refresh_image( frame, *width, *height );
 
-       // Determine format
-       //mlt_producer this = mlt_properties_get_data( properties, "producer_pixbuf", NULL );
-       //*format = ( mlt_properties_get_int( mlt_producer_properties( this ), "bpp" ) == 4 ) ? mlt_image_rgb24a : mlt_image_rgb24;
-
        // May need to know the size of the image to clone it
        int size = 0;
 

diff --git a/src/modules/sdl/consumer_sdl.c b/src/modules/sdl/consumer_sdl.c
index 238bf2a7fa1cd38e853fd4e74bd6194a9e481e0c..d94022b2883cadc0da0ba43a8059375abde962e6 100644 (file)
--- a/src/modules/sdl/consumer_sdl.c
+++ b/src/modules/sdl/consumer_sdl.c
@@ -48,6 +48,7 @@ struct consumer_sdl_s
        int window_width;
        int window_height;
        float aspect_ratio;
+       float display_aspect;
        int width;
        int height;
        int playing;
@@ -108,20 +109,38 @@ mlt_consumer consumer_sdl_init( char *arg )
                // Default progressive true
                mlt_properties_set_int( this->properties, "progressive", 0 );
 
-               // Get aspect ratio
+               // Get sample aspect ratio
                this->aspect_ratio = mlt_properties_get_double( this->properties, "aspect_ratio" );
                
+               // Default display aspect ratio
+               this->display_aspect = 4.0 / 3.0;
+               
                // process actual param
                if ( arg == NULL || sscanf( arg, "%dx%d", &this->width, &this->height ) != 2 )
                {
                        this->width = mlt_properties_get_int( this->properties, "width" );
                        this->height = mlt_properties_get_int( this->properties, "height" );
+                       
+                       // Default window size
+                       this->window_width = ( float )this->height * this->display_aspect + 0.5;
+                       this->window_height = this->height;
                }
-               
-               // Default window size
-               this->window_width = (int)( (float)this->height * 4.0/3.0 + 0.5);
-               this->window_height = this->height;
-               
+               else
+               {
+                       if ( (int)( ( float )this->width / this->height * 1000 ) != 
+                                (int)( this->display_aspect * 1000 ) ) 
+                       {
+                               // Override these
+                               this->display_aspect = ( float )this->width / this->height;
+                               this->aspect_ratio = 1.0;
+                               mlt_properties_set_double( this->properties, "aspect_ratio", this->aspect_ratio );
+                       }
+                       
+                       // Set window size
+                       this->window_width = this->width;
+                       this->window_height = this->height;
+               }
+
                // Set the sdl flags
                this->sdl_flags = SDL_HWSURFACE | SDL_ASYNCBLIT | SDL_HWACCEL | SDL_RESIZABLE;
 
@@ -328,7 +347,7 @@ static int consumer_play_video( consumer_sdl this, mlt_frame frame )
        {
                // Get the image, width and height
                mlt_frame_get_image( frame, &image, &vfmt, &width, &height, 0 );
-
+               
                // Handle events
                if ( this->sdl_screen != NULL )
                {
@@ -373,40 +392,60 @@ static int consumer_play_video( consumer_sdl this, mlt_frame frame )
 
                if ( this->sdl_screen == NULL || changed )
                {
-                       double aspect_ratio = ( float )this->aspect_ratio * this->width / this->height;
-                       float display_aspect_ratio = ( float )width / height;
                        SDL_Rect rect;
-                       if ( mlt_properties_get( properties, "rescale" ) != NULL &&
-                                       !strcmp( mlt_properties_get( properties, "rescale" ), "none" ) )
-                               aspect_ratio = mlt_frame_get_aspect_ratio( frame ) * mlt_properties_get_int(mlt_frame_properties(frame),"width") / mlt_properties_get_int(mlt_frame_properties(frame),"height");
+                       
+                       // Determine frame's display aspect ratio
+                       float frame_aspect = mlt_frame_get_aspect_ratio( frame ) * this->width / this->height;
+                       
+                       // Determine window's new display aspect ratio
+                       float this_aspect = ( float )this->window_width / this->window_height;
 
-                       if ( aspect_ratio == 1 )
+                       // If using hardware scaler
+                       if ( mlt_properties_get( properties, "rescale" ) != NULL &&
+                               !strcmp( mlt_properties_get( properties, "rescale" ), "none" ) )
+                       {
+                               // Special case optimisation to negate odd effect of sample aspect ratio
+                               // not corresponding exactly with image resolution.
+                               if ( ( (int)( this_aspect * 1000 ) == (int)( this->display_aspect * 1000 ) ) && 
+                                        ( (int)( mlt_frame_get_aspect_ratio( frame ) * 1000 ) == (int)( this->aspect_ratio * 1000 ) ) )
+                               {
+                                       rect.w = this->window_width;
+                                       rect.h = this->window_height;
+                               }
+                               else
+                               {
+                                       // Use hardware scaler to normalise display aspect ratio
+                                       rect.w = frame_aspect / this_aspect * this->window_width + 0.5;
+                                       rect.h = this->window_height;
+                                       if ( rect.w > this->window_width )
+                                       {
+                                               rect.w = this->window_width;
+                                               rect.h = this_aspect / frame_aspect * this->window_height + 0.5;
+                                       }
+                               }
+                       }
+                       // Special case optimisation to negate odd effect of sample aspect ratio
+                       // not corresponding exactly with image resolution.
+                       else if ( (int)( this_aspect * 1000 ) == (int)( this->display_aspect * 1000 ) ) 
                        {
                                rect.w = this->window_width;
                                rect.h = this->window_height;
                        }
-                       else if ( this->window_width < this->window_height * aspect_ratio )
+                       // Use hardware scaler to normalise sample aspect ratio
+                       else if ( this->window_height * frame_aspect > this->window_width )
                        {
                                rect.w = this->window_width;
-                               rect.h = this->window_width / aspect_ratio + 1;
+                               rect.h = this->window_width / frame_aspect + 0.5;
                        }
                        else
                        {
-                               rect.w = this->window_height * aspect_ratio + 1;
+                               rect.w = this->window_height * frame_aspect + 0.5;
                                rect.h = this->window_height;
                        }
-
-                       if ( mlt_properties_get_int( properties, "scale_overlay" ) )
-                       {
-                               if ( ( float )rect.w * display_aspect_ratio < this->window_width )
-                                       rect.w = ( int )( ( float )rect.w * display_aspect_ratio );
-                               else if ( ( float )rect.h * display_aspect_ratio < this->window_height )
-                                       rect.h = ( int )( ( float )rect.h * display_aspect_ratio );
-                       }
-
+                       
                        rect.x = ( this->window_width - rect.w ) / 2;
                        rect.y = ( this->window_height - rect.h ) / 2;
-
+                       
                        // Force an overlay recreation
                        if ( this->sdl_overlay != NULL )
                                SDL_FreeYUVOverlay( this->sdl_overlay );
@@ -419,7 +458,7 @@ static int consumer_play_video( consumer_sdl this, mlt_frame frame )
                                SDL_SetClipRect( this->sdl_screen, &rect );
                        
                                sdl_lock_display();
-                               this->sdl_overlay = SDL_CreateYUVOverlay( this->width - (this->width % 4), this->height- (this->height % 2 ), SDL_YUY2_OVERLAY, this->sdl_screen );
+                               this->sdl_overlay = SDL_CreateYUVOverlay( this->width - (this->width % 4), this->height - (this->height % 2 ), SDL_YUY2_OVERLAY, this->sdl_screen );
                                sdl_unlock_display();
                        }
                }