Ticket #8249: aspect3.diff

File aspect3.diff, 26.9 KB (added by fingolfin, 21 years ago)

3rd version

  • README 

    RCS file: /cvsroot/scummvm/scummvm/README,v
retrieving revision 1.115
diff -u -d -r1.115 README
     
    339339
    340340        scummvm [OPTIONS] [GAME]
    341341
    342         [GAME]        - Short name of game to load. For example, 'monkey' for
    343                         Monkey Island.
     342        [GAME]         - Short name of game to load. For example, 'monkey' for
     343                         Monkey Island.
     344
     345        -p<path>       - Path to where the game is installed. Default is Cwd.
     346        -x[<num>]      - Save game slot to load (default: autosave)
     347        -f             - Full-screen mode.
     348        -g<mode>       - Select graphics scaler. See below.
     349        -e<mode>       - Select sound engine. See below.
     350        -a             - Enable amiga pal conversion, for playing Amiga
     351                         versions
     352        -q<lang>       - Select language. See below.
     353        -c<num>        - Drive to play cd audio from.  E.g., 0 is first drive.
     354        -m<num>        - Set the music volume, 0-255.  Default is '192'
     355        -o<num>        - Set the master volume, 0-255. Default is '192'
     356        -s<num>        - Set the sfx volume, 0-255.    Default is '192'
     357        -t<num>        - Set music tempo. 50-200. Default is '100' (percent)
     358        -n             - Disable subtitles. Use with games that have voice.
     359        -y             - Set talk speed ('yak option'). Default is '60'
     360        -l<file>       - Load alternate configuration file
     361        -w[<file>]     - Write configuration file
     362        -v             - Show version information and exit
     363        -z             - Display list of games
     364        -b<num>        - Start in room <num>.
     365        -d[<num>]      - Set debug verbosity to <num>
     366        -u             - Dump scripts if a directory called 'dumps' exists in
     367                         current directory
     368        --multi-midi   - enable combination Adlib and native MIDI
     369        --native-mt32  - true Roland MT-32 (disable GM emulation)
     370        --aspect-ratio - enable aspect ratio correction
    344371
    345         -p<path>      - Path to where the game is installed. Default is Cwd.
    346         -x[<num>]     - Save game slot to load (default: autosave)
    347         -f            - Full-screen mode.
    348         -g<mode>      - Select graphics scaler. See below.
    349         -e<mode>      - Select sound engine. See below.
    350         -a            - Enable amiga pal conversion, for playing Amiga versions
    351         -q<lang>      - Select language. See below.
    352         -c<num>       - Drive to play cd audio from.  E.g., 0 is first drive.
    353         -m<num>       - Set the music volume, 0-255.  Default is '192'
    354         -o<num>       - Set the master volume, 0-255. Default is '192'
    355         -s<num>       - Set the sfx volume, 0-255.    Default is '192'
    356         -t<num>       - Set music tempo. 50-200. Default is '100' (percent)
    357         -n            - Disable subtitles. Use with games that have voice.
    358         -y            - Set talk speed ('yak option'). Default is '60'
    359         -l<file>      - Load alternate configuration file
    360         -w[<file>]    - Write configuration file
    361         -v            - Show version information and exit
    362         -z            - Display list of games
    363         -b<num>       - Start in room <num>.
    364         -d[<num>]     - Set debug verbosity to <num>
    365         -u            - Dump scripts if a directory called 'dumps' exists in
    366                         current directory
    367         --multi-midi  - enable combination Adlib and native MIDI
    368         --native-mt32 - true Roland MT-32 (disable GM emulation)
    369372
    370373
    371374Hot Keys:
    … …  
    380383        Ctrl-Alt 0-9           - Switch between graphics filters
    381384        Ctrl-Alt b             - Switch beetwen bilinear and non-linear
    382385                                 filtering [OpenGL backend]
    383         Ctrl-Alt a             - Switch between: [OpenGL backend]
    384                                  - Fit the game in the whole screen (No black borders)
    385                                  - Don't fit the game in the whole screen (Black borders)
     386        Ctrl-Alt a             - Toggle aspect-ratio correction on/off.
     387                                 Most of the games use a 320x200 pixel
     388                                 resolution, which may look squashed on
     389                                 modern monitors. Aspect-ratio correction
     390                                 stretches the image to use 320x240 pixels
     391                                 instead, or a multiple thereof.
     392
    386393    Scumm:
    387394        Ctrl 0-9 and Alt 0-9   - load and save game state
    388395        Ctrl-g                 - runs in really REALLY fast mode.

  • backends/sdl/sdl-common.cpp 

    RCS file: /cvsroot/scummvm/scummvm/backends/sdl/sdl-common.cpp,v
retrieving revision 1.62
diff -u -d -r1.62 sdl-common.cpp
     
    4141#define JOY_BUT_SPACE 4
    4242#define JOY_BUT_F5 5
    4343
    44 OSystem *OSystem_SDL_create(int gfx_mode, bool full_screen) {
    45         return OSystem_SDL_Common::create(gfx_mode, full_screen);
     44OSystem *OSystem_SDL_create(int gfx_mode, bool full_screen, bool aspect_ratio) {
     45        return OSystem_SDL_Common::create(gfx_mode, full_screen, aspect_ratio);
    4646}
    4747
    48 OSystem *OSystem_SDL_Common::create(int gfx_mode, bool full_screen) {
     48OSystem *OSystem_SDL_Common::create(int gfx_mode, bool full_screen, bool aspect_ratio) {
    4949        OSystem_SDL_Common *syst = OSystem_SDL_Common::create_intern();
    5050
    51         syst->init_intern(gfx_mode, full_screen);
     51        syst->init_intern(gfx_mode, full_screen, aspect_ratio);
    5252
    5353        return syst;
    5454}
    5555
    56 void OSystem_SDL_Common::init_intern(int gfx_mode, bool full_screen) {
     56void OSystem_SDL_Common::init_intern(int gfx_mode, bool full_screen, bool aspect_ratio) {
    5757
    5858        _mode = gfx_mode;
    5959        _full_screen = full_screen;
     60        _adjustAspectRatio = aspect_ratio;
    6061
    6162        if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER | SDL_INIT_JOYSTICK) ==-1) {
    6263                error("Could not initialize SDL: %s.\n", SDL_GetError());
    … …  
    129130
    130131        _screenWidth = w;
    131132        _screenHeight = h;
     133
     134        if (h != 200)
     135                _adjustAspectRatio = false;
     136
    132137        CKSUM_NUM = (_screenWidth * _screenHeight / (8 * 8));
    133138        if (_dirty_checksums)
    134139                free(_dirty_checksums);
    … …  
    576581                                }
    577582                        }
    578583
    579                         // Ctr-Alt-a will change aspect ratio in OpenGL backend
     584                        // Ctr-Alt-a will change aspect ratio
    580585                        if (b == (KBD_CTRL|KBD_ALT) && ev.key.keysym.sym=='a') {
    581                                         Property prop;
    582                                         prop.gfx_mode = 11;
    583                                         property(PROP_SET_GFX_MODE, &prop);
    584                                         break;
     586                                property(PROP_TOGGLE_ASPECT_RATIO, NULL);
     587                                break;
    585588                        }
    586589
    587590                        // Ctr-Alt-b will change bilinear filtering in OpenGL backend
    588591                        if (b == (KBD_CTRL|KBD_ALT) && ev.key.keysym.sym=='b') {
    589                                         Property prop;
    590                                         prop.gfx_mode = 12;
    591                                         property(PROP_SET_GFX_MODE, &prop);
    592                                         break;
     592                                Property prop;
     593                                prop.gfx_mode = GFX_BILINEAR;
     594                                property(PROP_SET_GFX_MODE, &prop);
     595                                break;
    593596                        }
    594597
    595598#ifdef QTOPIA
    … …  
    698701                        event->mouse.x /= _scaleFactor;
    699702                        event->mouse.y /= _scaleFactor;
    700703
     704                        if (_adjustAspectRatio)
     705                                event->mouse.y = aspect2Real(event->mouse.y);
    701706                        return true;
    702707
    703708                case SDL_MOUSEBUTTONDOWN:
    … …  
    718723                        event->mouse.x /= _scaleFactor;
    719724                        event->mouse.y /= _scaleFactor;
    720725
     726                        if (_adjustAspectRatio)
     727                                event->mouse.y = aspect2Real(event->mouse.y);
     728
    721729                        return true;
    722730
    723731                case SDL_MOUSEBUTTONUP:
    … …  
    731739                        event->mouse.y = ev.button.y;
    732740                        event->mouse.x /= _scaleFactor;
    733741                        event->mouse.y /= _scaleFactor;
     742
     743                        if (_adjustAspectRatio)
     744                                event->mouse.y = aspect2Real(event->mouse.y);
     745
    734746                        return true;
    735747
    736748                case SDL_JOYBUTTONDOWN:
    … …  
    835847                        event->mouse.y = km.y;
    836848                        event->mouse.x /= _scaleFactor;
    837849                        event->mouse.y /= _scaleFactor;
     850
     851                        if (_adjustAspectRatio)
     852                                event->mouse.y = aspect2Real(event->mouse.y);
     853
    838854                        return true;
    839855
    840856                case SDL_VIDEOEXPOSE:

  • backends/sdl/sdl-common.h 

    RCS file: /cvsroot/scummvm/scummvm/backends/sdl/sdl-common.h,v
retrieving revision 1.27
diff -u -d -r1.27 sdl-common.h
     
    123123        virtual int16 RGBToColor(uint8 r, uint8 g, uint8 b);
    124124        virtual void colorToRGB(int16 color, uint8 &r, uint8 &g, uint8 &b);
    125125
    126         static OSystem *create(int gfx_mode, bool full_screen);
     126        static OSystem *create(int gfx_mode, bool full_screenm, bool aspect_ratio);
    127127
    128128protected:
    129129        OSystem_SDL_Common();
    … …  
    131131
    132132        static OSystem_SDL_Common *create_intern();
    133133
    134         void init_intern(int gfx_mode, bool full_screen);
     134        void init_intern(int gfx_mode, bool full_screen, bool aspect_ratio);
    135135
    136136        // unseen game screen
    137137        SDL_Surface *_screen;
    … …  
    141141        SDL_Surface *_tmpscreen;
    142142        int _tmpScreenWidth;
    143143        bool _overlayVisible;
     144
     145        bool _adjustAspectRatio;
    144146
    145147        // CD Audio
    146148        SDL_CD *_cdrom;

  • backends/sdl/sdl.cpp 

    RCS file: /cvsroot/scummvm/scummvm/backends/sdl/sdl.cpp,v
retrieving revision 1.35
diff -u -d -r1.35 sdl.cpp
     
    147147        //
    148148        // Create the surface that contains the scaled graphics in 16 bit mode
    149149        //
    150         _hwscreen = SDL_SetVideoMode(_screenWidth * _scaleFactor, _screenHeight * _scaleFactor, 16,
     150
     151        _hwscreen = SDL_SetVideoMode(_screenWidth * _scaleFactor, (_adjustAspectRatio ? 240 : _screenHeight) * _scaleFactor, 16,
    151152                _full_screen ? (SDL_FULLSCREEN|SDL_SWSURFACE) : SDL_SWSURFACE
    152153        );
    153154        if (_hwscreen == NULL)
    154155                error("_hwscreen failed");
    155        
     156
    156157        //
    157158        // Create the surface used for the graphics in 16 bit before scaling, and also the overlay
    158159        //
    … …  
    192193                SDL_FreeSurface(_hwscreen);
    193194                _hwscreen = NULL;
    194195        }
    195        
     196
    196197        if (_tmpscreen) {
    197198                free(_tmpscreen->pixels);
    198199                SDL_FreeSurface(_tmpscreen);
    … …  
    281282                uint32 srcPitch, dstPitch;
    282283                SDL_Rect *last_rect = _dirty_rect_list + _num_dirty_rects;
    283284
    284                 if (_scaler_proc == Normal1x) {
     285                if (_scaler_proc == Normal1x && !_adjustAspectRatio) {
    285286                        SDL_Surface *target = _overlayVisible ? _tmpscreen : _screen;
    286287                        for (r = _dirty_rect_list; r != last_rect; ++r) {
    287288                                dst = *r;
    … …  
    314315                        for (r = _dirty_rect_list; r != last_rect; ++r) {
    315316                                register int dst_y = r->y + _currentShakePos;
    316317                                register int dst_h = 0;
     318                                register int orig_dst_y = 0;
     319
    317320                                if (dst_y < _screenHeight) {
    318321                                        dst_h = r->h;
    319322                                        if (dst_h > _screenHeight - dst_y)
    320323                                                dst_h = _screenHeight - dst_y;
    321324
    322                                                 dst_y *= _scaleFactor;
     325                                        dst_y *= _scaleFactor;
    323326
    324                                                 _scaler_proc((byte *)_tmpscreen->pixels + (r->x * 2 + 2) + (r->y + 1) * srcPitch, srcPitch,
     327                                        if (_adjustAspectRatio) {
     328                                                orig_dst_y = dst_y;
     329                                                dst_y = real2Aspect(dst_y);
     330                                        }
     331
     332                                        _scaler_proc((byte *)_tmpscreen->pixels + (r->x * 2 + 2) + (r->y + 1) * srcPitch, srcPitch,
    325333                                                (byte *)_hwscreen->pixels + r->x * 2 * _scaleFactor + dst_y * dstPitch, dstPitch, r->w, dst_h);
    326334                                }
    327                        
     335
    328336                                r->x *= _scaleFactor;
    329337                                r->y = dst_y;
    330338                                r->w *= _scaleFactor;
    331339                                r->h = dst_h * _scaleFactor;
    332                         }
    333340
     341                                if (_adjustAspectRatio && orig_dst_y / _scaleFactor < _screenHeight)
     342                                        r->h = stretch200To240((uint8 *) _hwscreen->pixels, dstPitch, r->w, r->h, r->x, r->y, orig_dst_y);
     343                        }
    334344                        SDL_UnlockSurface(_tmpscreen);
    335345                        SDL_UnlockSurface(_hwscreen);
    336346                }
    … …  
    339349                // This is necessary if shaking is active.
    340350                if (_forceFull) {
    341351                        _dirty_rect_list[0].y = 0;
    342                         _dirty_rect_list[0].h = _screenHeight * _scaleFactor;
     352                        _dirty_rect_list[0].h = (_adjustAspectRatio ? 240 : _screenHeight) * _scaleFactor;
    343353                }
    344354
    345355                // Finally, blit all our changes to the screen
    … …  
    374384                hotswap_gfx_mode();
    375385
    376386                return 1;
     387        } else if (param == PROP_TOGGLE_ASPECT_RATIO) {
     388                if (_screenHeight == 200) {
     389                        assert(_hwscreen != 0);
     390                        _adjustAspectRatio ^= true;
     391                        hotswap_gfx_mode();
     392                }
    377393        }
    378394
    379395        return OSystem_SDL_Common::property(param, value);

  • backends/sdl/sdl_gl.cpp 

    RCS file: /cvsroot/scummvm/scummvm/backends/sdl/sdl_gl.cpp,v
retrieving revision 1.36
diff -u -d -r1.36 sdl_gl.cpp
     
    5454        int _glFlags;
    5555        int _glScreenStart;
    5656        bool _glBilinearFilter;
    57         bool _glAspectRatio;
    5857        bool _usingOpenGL;
    5958        SDL_Surface *tmpSurface; // Used for black rectangles blitting
    6059        SDL_Rect tmpBlackRect;   // Black rectangle at end of the GL screen
    … …  
    7978{
    8079  _glScreenStart = 0;
    8180  _glBilinearFilter = true;
    82   _glAspectRatio = false;
    8381  _usingOpenGL = false; // false => Switch to filters used in the sdl.cpp version
    8482  _glBottomOfTexture = 256; // height is always 256
    8583  // 640x480 resolution
    … …  
    165163
    166164        case GFX_NORMAL:
    167165normal_mode:;
    168                 _scaleFactor = 1;
     166                _scaleFactor = _usingOpenGL ? 2 : 1;
    169167                _scaler_proc = Normal1x;
    170168                break;
    171169        default:
    … …  
    199197                fb2gl.init(_glWindow.w, _glWindow.h, 0, _glScreenStart? 15: 70,
    200198                    _glFlags);
    201199               
    202         }
    203         else { // SDL backend
     200        } else { // SDL backend
    204201         
    205202                _hwscreen = SDL_SetVideoMode(_screenWidth * _scaleFactor, _screenHeight * _scaleFactor, 16,
    206203                  _full_screen ? (SDL_FULLSCREEN|SDL_SWSURFACE) : SDL_SWSURFACE
    … …  
    234231                                                Gmask,
    235232                                                Bmask,
    236233                                                Amask);
    237         }
    238         else { // SDL backend
     234        } else { // SDL backend
    239235                _tmpscreen = SDL_CreateRGBSurfaceFrom(tmp_screen,
    240236                                                _tmpScreenWidth,
    241237                                                _screenHeight + 3,
    … …  
    346342               
    347343                        SDL_FillRect(tmpSurface, &blackrect, 0);
    348344                        fb2gl.blit16(tmpSurface, 1, &blackrect, 0, 0);
    349                 }
    350                 else { // SDL backend
     345                } else { // SDL backend
    351346                        SDL_Rect blackrect = {0, 0, _screenWidth * _scaleFactor, _newShakePos * _scaleFactor};
    352347                        SDL_FillRect(_hwscreen, &blackrect, 0);
    353348                }
    … …  
    545540#endif
    546541
    547542                return 1;
    548         }
    549         else if (param == PROP_SET_GFX_MODE) {
     543        } else if (param == PROP_TOGGLE_ASPECT_RATIO) {
     544                if (!_usingOpenGL) {
     545                        _usingOpenGL = true;
     546                        _mode = GFX_NORMAL;
     547                        hotswap_gfx_mode();
     548                }
     549
     550                _adjustAspectRatio ^= true;
     551                if (_adjustAspectRatio) {
     552                        // Don't use the whole screen (black borders)
     553                        fb2gl.init(0, 0, 0, 15, _glFlags);
     554                        _glScreenStart = 20;
     555                        SDL_FillRect(tmpSurface, &tmpBlackRect, 0);
     556                        fb2gl.blit16(tmpSurface, 1, &tmpBlackRect, 0, 0);
     557                } else {
     558                        // Use the whole screen
     559                        fb2gl.init(0, 0, 0, 70, _glFlags);
     560                        _glScreenStart = 0;
     561                }
     562
    550563                SDL_Rect full = {0, 0, _screenWidth, _screenHeight};
     564                fb2gl.blit16(_tmpscreen, 1, &full, 0, _glScreenStart);
     565                fb2gl.display();
     566        } else if (param == PROP_SET_GFX_MODE) {
    551567
    552568                if (value->gfx_mode > 10) { // OpenGL modes
    553569                        if (!_usingOpenGL) {
    … …  
    562578                                _glBilinearFilter ^= true;
    563579                                fb2gl.setBilinearMode(_glBilinearFilter);
    564580                                break;
    565                         case GFX_ASPECTRATIO:
    566                                 _glAspectRatio ^= true;
    567                                 if (_glAspectRatio) {
    568                                         // Don't use the whole screen (black borders)
    569                                         fb2gl.init(0, 0, 0, 15, _glFlags);
    570                                         _glScreenStart = 20;
    571                                         SDL_FillRect(tmpSurface, &tmpBlackRect, 0);
    572                                         fb2gl.blit16(tmpSurface, 1, &tmpBlackRect, 0, 0);
    573                                 } else {
    574                                         // Use the whole screen
    575                                         fb2gl.init(0, 0, 0, 70, _glFlags);
    576                                         _glScreenStart = 0;
    577                                 }
    578                                 break;
    579581                        default: // SDL backend
    580582                                if (value->gfx_mode >= 10)
    581583                                  return 0;
    … …  
    589591                };
    590592
    591593                if (_usingOpenGL) {
     594                        SDL_Rect full = {0, 0, _screenWidth, _screenHeight};
    592595                        fb2gl.blit16(_tmpscreen, 1, &full, 0, _glScreenStart);
    593596                        fb2gl.display();
    594597                }

  • common/gameDetector.cpp 

    RCS file: /cvsroot/scummvm/scummvm/common/gameDetector.cpp,v
retrieving revision 1.113
diff -u -d -r1.113 gameDetector.cpp
     
    5050        "Syntax:\n"
    5151        "\tscummvm [-v] [-d[<num>]] [-n] [-b<num>] [-t<num>] [-s<num>] [-p<path>] [-m<num>] [-f] game\n"
    5252        "Flags:\n"
    53         "\t-p<path>      - look for game in <path>\n"
    54         "\t-x[<num>]     - load this savegame (default: 0 - autosave)\n"
    55         "\t-f            - fullscreen mode\n"
    56         "\t-g<mode>      - graphics mode (normal,2x,3x,2xsai,super2xsai,supereagle,advmame2x,advmame3x,tv2x,dotmatrix)\n"
    57         "\t-e<mode>      - set music engine (see README for details)\n"
    58         "\t-a            - specify game is amiga version\n"
    59         "\t-q<lang>      - specify language (en,de,fr,it,pt,es,jp,zh,kr,hb)\n"
     53        "\t-p<path>       - look for game in <path>\n"
     54        "\t-x[<num>]      - load this savegame (default: 0 - autosave)\n"
     55        "\t-f             - fullscreen mode\n"
     56        "\t-g<mode>       - graphics mode (normal,2x,3x,2xsai,super2xsai,supereagle,advmame2x,advmame3x,tv2x,dotmatrix)\n"
     57        "\t-e<mode>       - set music engine (see README for details)\n"
     58        "\t-a             - specify game is amiga version\n"
     59        "\t-q<lang>       - specify language (en,de,fr,it,pt,es,jp,zh,kr,hb)\n"
    6060        "\n"
    61         "\t-c<num>       - use cdrom <num> for cd audio\n"
    62         "\t-m<num>       - set music volume to <num> (0-255)\n"
    63         "\t-o<num>       - set master volume to <num> (0-255)\n"
    64         "\t-s<num>       - set sfx volume to <num> (0-255)\n"
    65         "\t-t<num>       - set music tempo (50-200, default 100%%)\n"
     61        "\t-c<num>        - use cdrom <num> for cd audio\n"
     62        "\t-m<num>        - set music volume to <num> (0-255)\n"
     63        "\t-o<num>        - set master volume to <num> (0-255)\n"
     64        "\t-s<num>        - set sfx volume to <num> (0-255)\n"
     65        "\t-t<num>        - set music tempo (50-200, default 100%%)\n"
    6666        "\n"
    67         "\t-n            - no subtitles for speech\n"
    68         "\t-y            - set text speed (default: 60)\n"
     67        "\t-n             - no subtitles for speech\n"
     68        "\t-y             - set text speed (default: 60)\n"
    6969        "\n"
    70         "\t-l<file>      - load config file instead of default\n"
     70        "\t-l<file>       - load config file instead of default\n"
    7171#if defined(UNIX)
    72         "\t-w[<file>]    - write to config file [~/.scummvmrc]\n"
     72        "\t-w[<file>]     - write to config file [~/.scummvmrc]\n"
    7373#else
    74         "\t-w[<file>]    - write to config file [scummvm.ini]\n"
     74        "\t-w[<file>]     - write to config file [scummvm.ini]\n"
    7575#endif
    76         "\t-v            - show version info and exit\n"
    77         "\t-z            - display list of games\n"
     76        "\t-v             - show version info and exit\n"
     77        "\t-z             - display list of games\n"
    7878        "\n"
    79         "\t-b<num>       - start in room <num>\n"
    80         "\t-d[<num>]     - enable debug output (debug level [1])\n"
    81         "\t-u            - dump scripts\n"
     79        "\t-b<num>        - start in room <num>\n"
     80        "\t-d[<num>]      - enable debug output (debug level [1])\n"
     81        "\t-u             - dump scripts\n"
    8282        "\n"
    83         "\t--multi-midi  - enable combination Adlib and native MIDI\n"
    84         "\t--native-mt32 - true Roland MT-32 (disable GM emulation)\n"
     83        "\t--multi-midi   - enable combination Adlib and native MIDI\n"
     84        "\t--native-mt32  - true Roland MT-32 (disable GM emulation)\n"
     85        "\t--aspect-ratio - enable aspect ratio correction\n"
    8586;
    8687#endif
    8788// This contains a pointer to a list of all supported games.
    … …  
    148149
    149150GameDetector::GameDetector() {
    150151        _fullScreen = false;
     152        _aspectRatio = false;
    151153
    152154        _use_adlib = false;
    153155
    … …  
    245247                }
    246248
    247249        _fullScreen = g_config->getBool("fullscreen", _fullScreen);
     250        _aspectRatio = g_config->getBool("aspect_ratio", _aspectRatio);
    248251
    249252        if ((val = g_config->get("gfx_mode")))
    250253                if ((_gfx_mode = parseGraphicsMode(val)) == -1) {
    … …  
    453456                                } else if (!strcmp (s, "native-mt32")) {
    454457                                        _native_mt32 = true;
    455458                                        g_config->setBool ("native_mt32", true);
     459                                } else if (!strcmp (s, "aspect-ratio")) {
     460                                        _aspectRatio = true;
     461                                        g_config->setBool ("aspect_ratio", true);
    456462                                } else {
    457463                                        goto ShowHelpAndExit;
    458464                                }
    … …  
    673679        return OSystem_PALMOS_create(_gfx_mode);
    674680#else
    675681        /* SDL is the default driver for now */
    676         return OSystem_SDL_create(_gfx_mode, _fullScreen);
     682        return OSystem_SDL_create(_gfx_mode, _fullScreen, _aspectRatio);
    677683#endif
    678684}
    679685

  • common/gameDetector.h 

    RCS file: /cvsroot/scummvm/scummvm/common/gameDetector.h,v
retrieving revision 1.45
diff -u -d -r1.45 gameDetector.h
     
    110110        const String& getGameName(void);
    111111       
    112112        bool _fullScreen;
     113        bool _aspectRatio;
    113114
    114115        bool _use_adlib;
    115116

  • common/scaler.cpp 

    RCS file: /cvsroot/scummvm/scummvm/common/scaler.cpp,v
retrieving revision 1.21
diff -u -d -r1.21 scaler.cpp
     
    3030static uint32 qcolorMask = 0xE79CE79C;
    3131static uint32 qlowpixelMask = 0x18631863;
    3232static uint32 redblueMask = 0xF81F;
    33 static uint32 greenMask = 0x7E0;
     33static uint32 redMask = 0xF800;
     34static uint32 greenMask = 0x07E0;
     35static uint32 blueMask = 0x001F;
    3436
    3537static const uint16 dotmatrix_565[16] = {
    3638        0x01E0, 0x0007, 0x3800, 0x0000,
    … …  
    5355                qcolorMask = 0xE79CE79C;
    5456                qlowpixelMask = 0x18631863;
    5557                redblueMask = 0xF81F;
    56                 greenMask = 0x7E0;
     58                redMask = 0xF800;
     59                greenMask = 0x07E0;
     60                blueMask = 0x001F;
    5761                dotmatrix = dotmatrix_565;
    5862        } else if (BitFormat == 555) {
    5963                colorMask = 0x7BDE7BDE;
    … …  
    6165                qcolorMask = 0x739C739C;
    6266                qlowpixelMask = 0x0C630C63;
    6367                redblueMask = 0x7C1F;
    64                 greenMask = 0x3E0;
     68                redMask = 0x7C00;
     69                greenMask = 0x03E0;
     70                blueMask = 0x001F;
    6571                dotmatrix = dotmatrix_555;
    6672        } else {
    6773                return 0;
    … …  
    631637                p += nextlineSrc;
    632638                q += nextlineDst << 1;
    633639        }
     640}
     641
     642
     643static inline uint32 interpolate5(uint16 A, uint16 B, int scale) {
     644        uint16 r = ((A & redMask) * scale + (B & redMask) * (5 - scale)) / 5;
     645        uint16 g = ((A & greenMask) * scale + (B & greenMask) * (5 - scale)) / 5;
     646        uint16 b = ((A & blueMask) * scale + (B & blueMask) * (5 - scale)) / 5;
     647
     648        return (r & redMask) | (g & greenMask) | (b & blueMask);
     649}
     650
     651static inline void interpolate5Line(uint16 *dst, const uint16 *srcA, const uint16 *srcB, int scale, int width) {
     652#if 0
     653        // Accurate but slightly slower code
     654        while (width--) {
     655                *dst++ = interpolate5(*srcA++, *srcB++, scale);
     656        }
     657#else
     658        // Not fully accurate, but a bit faster
     659        width /= 2;
     660        const uint32 *sA = (const uint32 *)srcA;
     661        const uint32 *sB = (const uint32 *)srcB;
     662        uint32 *d = (uint32 *)dst;
     663        if (scale == 1) {
     664                while (width--) {
     665                        uint32 B = *sB++;
     666                        *d++ = Q_INTERPOLATE(*sA++, B, B, B);
     667                }
     668        } else {
     669                while (width--) {
     670                        *d++ = INTERPOLATE(*sA++, *sB++);
     671                }
     672        }
     673#endif
     674}
     675
     676/**
     677 * Stretch a 16bpp image vertically by factor 1.2. Used to correct the
     678 * aspect-ratio in games using 320x200 pixel graphics with non-qudratic
     679 * pixels. Applying this method effectively turns that into 320x240, which
     680 * provides the correct aspect-ratio on modern displays.
     681 *
     682 * The image would normally have occupied y coordinates origSrcY through
     683 * origSrcY + height - 1.
     684 *
     685 * However, we have already placed it at srcY - the aspect-corrected y
     686 * coordinate - to allow in-place stretching.
     687 *
     688 * Therefore, the source image now occupies Y coordinates srcY through
     689 * srcY + height - 1, and it should be stretched to Y coordinates srcY
     690 * through real2Aspect(srcY + height - 1).
     691 *
     692 * @todo Implement bilinear filtering instead of stupid pixel doubling?
     693 *
     694 * The theory of bilinear filtering:
     695 *
     696 * For each destination pixel, calculate its exact scaled position in the
     697 * source image. It is unlikely that it will correspond to any one source pixel
     698 * so its colour is interpolated from the four surrounding pixels, like so:
     699 *
     700 *    c0| fx      |c1
     701 *    --+-----+---+--
     702 *      |     |   |
     703 *    fy|     |   |
     704 *      +-----X   |
     705 *      |         |
     706 *    --+---------+--
     707 *    c2|         |c3
     708 *
     709 * The colour c at X is
     710 *
     711 *    c = c0 * (1-fx) * (1-fy)
     712 *      + c1 * fx * (1-fy)
     713 *      + c2 * (1-fx) * fy
     714 *      + c3 * fx * fy
     715 *
     716 * We only stretch the height so fx is always 0, which leads to the following,
     717 * simplified formula:
     718 *
     719 *    c = c0 * (1-fy)
     720 *      + c2 * fy
     721 *
     722 * And it should be possible to pre-calculate fy as well, since the image is
     723 * always stretched to the same proportions.
     724 */
     725int stretch200To240(uint8 *buf, uint32 pitch, int width, int height, int srcX, int srcY, int origSrcY) {
     726        int maxDstY = real2Aspect(origSrcY + height - 1);
     727        int off = srcY - origSrcY;
     728        int y;
     729
     730        uint8 *dstPtr = buf + srcX * 2 + maxDstY * pitch;
     731
     732        for (y = maxDstY; y >= srcY; y--) {
     733                uint8 *srcPtr = buf + srcX * 2 + (aspect2Real(y) + off) * pitch;
     734
     735                if (srcPtr == dstPtr)
     736                        break;
     737               
     738#if 0
     739                memcpy(dstPtr, srcPtr, width * 2);
     740#else
     741                switch (y % 6) {
     742                case 0:
     743                case 5:
     744                        memcpy(dstPtr, srcPtr, width * 2);
     745//                      interpolate5Line((uint16 *)dstPtr, (uint16 *)(srcPtr - pitch), (uint16 *)srcPtr, 0, width);
     746                        break;
     747                case 1:
     748                case 4:
     749                        interpolate5Line((uint16 *)dstPtr, (uint16 *)(srcPtr - pitch), (uint16 *)srcPtr, 1, width);
     750                        break;
     751                case 2:
     752                case 3:
     753                        interpolate5Line((uint16 *)dstPtr, (uint16 *)(srcPtr - pitch), (uint16 *)srcPtr, 2, width);
     754                        break;
     755                }
     756#endif
     757                dstPtr -= pitch;
     758        }
     759
     760        return 1 + maxDstY - srcY;
    634761}

  • common/scaler.h 

    RCS file: /cvsroot/scummvm/scummvm/common/scaler.h,v
retrieving revision 1.11
diff -u -d -r1.11 scaler.h
     
    4141DECLARE_SCALER(TV2x);
    4242DECLARE_SCALER(DotMatrix);
    4343
     44FORCEINLINE int real2Aspect(int y) {
     45        return y + (y + 1) / 5;
     46}
     47
     48FORCEINLINE int aspect2Real(int y) {
     49        return (y * 5 + 3) / 6;
     50}
     51
     52extern int stretch200To240(uint8 *buf, uint32 pitch, int width, int height, int srcX, int srcY, int origSrcY);
    4453
    4554enum {
    4655        GFX_NORMAL = 0,
    … …  
    5463        GFX_TV2X = 8,
    5564        GFX_DOTMATRIX = 9,
    5665
    57         GFX_ASPECTRATIO = 11, // OpenGL backend
    5866        GFX_BILINEAR = 12,    // OpenGL backend
    5967       
    6068        GFX_FLIPPING = 100,     // Palmos

  • common/system.h 

    RCS file: /cvsroot/scummvm/scummvm/common/system.h,v
retrieving revision 1.32
diff -u -d -r1.32 system.h
     
    9494                PROP_GET_SAMPLE_RATE = 6,
    9595                PROP_GET_FULLSCREEN = 7,
    9696                PROP_GET_FMOPL_ENV_BITS = 8,
    97                 PROP_GET_FMOPL_EG_ENT = 9
     97                PROP_GET_FMOPL_EG_ENT = 9,
     98                PROP_TOGGLE_ASPECT_RATIO = 10
    9899        };
    99100        union Property {
    100101                const char *caption;
    … …  
    363364/* Factory functions. This means we don't have to include the headers for
    364365 * all backends.
    365366 */
    366 extern OSystem *OSystem_SDL_create(int gfx_driver, bool full_screen);
     367extern OSystem *OSystem_SDL_create(int gfx_driver, bool full_screen, bool aspect_ratio);
    367368extern OSystem *OSystem_NULL_create();
    368369extern OSystem *OSystem_MorphOS_create(int game_id, int gfx_driver, bool full_screen);
    369370extern OSystem *OSystem_Dreamcast_create();