Return to resolution.c CVS log

Up to [HATARI the Atari ST Emulator] / hatari / src

Annotation of hatari/src/resolution.c, revision 1.1

1.1     ! root        1: /*
        !             2:   Hatari - resolution.c
        !             3: 
        !             4:   This file is distributed under the GNU Public License, version 2 or at
        !             5:   your option any later version. Read the file gpl.txt for details.
        !             6: 
        !             7:   SDL resolution limitation and selection routines.
        !             8: */
        !             9: const char Resolution_fileid[] = "Hatari resolution.c : " __DATE__ " " __TIME__;
        !            10: 
        !            11: #include <SDL.h>
        !            12: #include "main.h"
        !            13: #include "configuration.h"
        !            14: #include "resolution.h"
        !            15: #include "screen.h"
        !            16: 
        !            17: #define RESOLUTION_DEBUG 0
        !            18: 
        !            19: #if RESOLUTION_DEBUG
        !            20: #define Dprintf(a) printf a
        !            21: #else
        !            22: #define Dprintf(a)
        !            23: #endif
        !            24: 
        !            25: 
        !            26: /**
        !            27:  * Select best resolution from given SDL video modes.
        !            28:  * - If width and height are given, select the smallest mode larger
        !            29:  *   or equal to requested size
        !            30:  * - Otherwise select the largest available mode
        !            31:  * return true for success and false if no matching mode was found.
        !            32:  */
        !            33: static bool Resolution_Select(SDL_Rect **modes, int *width, int *height)
        !            34: {
        !            35: #define TOO_LARGE 0x7fff
        !            36:        int i, bestw, besth;
        !            37: 
        !            38:        if (!(*width && *height)) {
        !            39:                /* search the largest mode (prefer wider ones) */
        !            40:                for (i = 0; modes[i]; i++) {
        !            41:                        if ((modes[i]->w > *width) && (modes[i]->h >= *height)) {
        !            42:                                *width = modes[i]->w;
        !            43:                                *height = modes[i]->h;
        !            44:                        }
        !            45:                }
        !            46:                Dprintf(("hostscreen: largest found video mode: %dx%d\n",*width,*height));
        !            47:                return true;
        !            48:        }
        !            49: 
        !            50:        /* Search the smallest mode larger or equal to requested size */
        !            51:        bestw = TOO_LARGE;
        !            52:        besth = TOO_LARGE;
        !            53:        for (i = 0; modes[i]; i++) {
        !            54:                if ((modes[i]->w >= *width) && (modes[i]->h >= *height)) {
        !            55:                        if ((modes[i]->w < bestw) || (modes[i]->h < besth)) {
        !            56:                                bestw = modes[i]->w;
        !            57:                                besth = modes[i]->h;
        !            58:                        }
        !            59:                }
        !            60:        }
        !            61:        if (bestw == TOO_LARGE || besth == TOO_LARGE) {
        !            62:                return false;
        !            63:        }
        !            64:        *width = bestw;
        !            65:        *height = besth;
        !            66:        Dprintf(("hostscreen: video mode found: %dx%d\n",*width,*height));
        !            67:        return true;
        !            68: #undef TOO_LARGE
        !            69: }
        !            70: 
        !            71: 
        !            72: /**
        !            73:  * Search video mode size that best suits the given width/height/bpp
        !            74:  * constraints and set them into given arguments.  With zeroed arguments,
        !            75:  * return largest video mode.
        !            76:  */
        !            77: void Resolution_Search(int *width, int *height, int *bpp)
        !            78: {
        !            79:        SDL_Rect **modes;
        !            80:        SDL_PixelFormat pixelformat;
        !            81:        Uint32 modeflags;
        !            82: 
        !            83:        /* Search in available modes the best suited */
        !            84:        Dprintf(("hostscreen: video mode asked: %dx%dx%d\n",
        !            85:                 *width, *height, *bpp));
        !            86: 
        !            87:        /* Read available video modes */
        !            88:        modeflags = 0 /*SDL_HWSURFACE | SDL_HWPALETTE*/;
        !            89:        if (bInFullScreen)
        !            90:                modeflags |= SDL_FULLSCREEN;
        !            91: 
        !            92:        /*--- Search a video mode with asked bpp ---*/
        !            93:        if (*bpp != 0) {
        !            94:                pixelformat.BitsPerPixel = *bpp;
        !            95:                modes = SDL_ListModes(&pixelformat, modeflags);
        !            96:                if ((modes != (SDL_Rect **) 0) && (modes != (SDL_Rect **) -1)) {
        !            97:                        Dprintf(("hostscreen: searching a good video mode (any bpp)\n"));
        !            98:                        if (Resolution_Select(modes, width, height)) {
        !            99:                                Dprintf(("hostscreen: video mode selected: %dx%dx%d\n",
        !           100:                                         *width, *height, *bpp));
        !           101:                                return;
        !           102:                        }
        !           103:                }
        !           104:        }
        !           105: 
        !           106:        /*--- Search a video mode with any bpp ---*/
        !           107:        modes = SDL_ListModes(NULL, modeflags);
        !           108:        if ((modes != (SDL_Rect **) 0) && (modes != (SDL_Rect **) -1)) {
        !           109:                Dprintf(("hostscreen: searching a good video mode\n"));
        !           110:                if (Resolution_Select(modes, width, height)) {
        !           111:                        Dprintf(("hostscreen: video mode selected: %dx%dx%d\n",
        !           112:                                 *width, *height, *bpp));
        !           113:                        return;
        !           114:                }
        !           115:        }
        !           116: 
        !           117:        if (modes == (SDL_Rect **) 0) {
        !           118:                fprintf(stderr, "WARNING: No suitable video modes available!\n");
        !           119:        }
        !           120: 
        !           121:        if (modes == (SDL_Rect **) -1) {
        !           122:                /* Any mode available */
        !           123:                Dprintf(("hostscreen: All resolutions available.\n"));
        !           124:        }
        !           125: 
        !           126:        Dprintf(("hostscreen: video mode selected: %dx%dx%d\n",
        !           127:                 *width, *height, *bpp));
        !           128: }
        !           129: 
        !           130: 
        !           131: /**
        !           132:  * Set given width & height arguments to maximum size in the configuration,
        !           133:  * or if that's too large for the requested bit depth, to the largest
        !           134:  * available video mode size.
        !           135:  */
        !           136: void Resolution_GetLimits(int *width, int *height, int *bpp)
        !           137: {
        !           138:        *width = *height = 0;
        !           139:        /* constrain max size to what HW/SDL offers */
        !           140:        Resolution_Search(width, height, bpp);
        !           141:        if (!(*width && *width) ||
        !           142:            (ConfigureParams.Screen.nMaxWidth < *width &&
        !           143:             ConfigureParams.Screen.nMaxHeight < *height)) {
        !           144:                /* already within it, use user provided value */
        !           145:                *width = ConfigureParams.Screen.nMaxWidth;
        !           146:                *height = ConfigureParams.Screen.nMaxHeight;
        !           147:        }
        !           148: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.