
/* Bring up a window and manipulate the gamma on it */

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>

#include "SDL.h"

/* Call this instead of exit(), so we can clean up SDL: atexit() is evil. */
static void
quit(int rc)
{
    SDL_Quit();
    exit(rc);
}

/* Turn a normal gamma value into an appropriate gamma ramp */
void
CalculateGamma(double gamma, Uint16 * ramp)
{
    int i, value;

    gamma = 1.0 / gamma;
    for (i = 0; i < 256; ++i) {
        value = (int) (pow((double) i / 256.0, gamma) * 65535.0 + 0.5);
        if (value > 65535) {
            value = 65535;
        }
        ramp[i] = (Uint16) value;
    }
}

/* This can be used as a general routine for all of the test programs */
int
get_video_args(char *argv[], int *w, int *h, int *bpp, Uint32 * flags)
{
    int i;

    *w = 640;
    *h = 480;
    *bpp = 0;
    *flags = SDL_SWSURFACE;

    for (i = 1; argv[i]; ++i) {
        if (strcmp(argv[i], "-width") == 0) {
            if (argv[i + 1]) {
                *w = atoi(argv[++i]);
            }
        } else if (strcmp(argv[i], "-height") == 0) {
            if (argv[i + 1]) {
                *h = atoi(argv[++i]);
            }
        } else if (strcmp(argv[i], "-bpp") == 0) {
            if (argv[i + 1]) {
                *bpp = atoi(argv[++i]);
            }
        } else if (strcmp(argv[i], "-fullscreen") == 0) {
            *flags |= SDL_FULLSCREEN;
        } else if (strcmp(argv[i], "-hw") == 0) {
            *flags |= SDL_HWSURFACE;
        } else if (strcmp(argv[i], "-hwpalette") == 0) {
            *flags |= SDL_HWPALETTE;
        } else
            break;
    }
    return i;
}

int
main(int argc, char *argv[])
{
    SDL_Surface *screen;
    SDL_Surface *image;
    float gamma;
    int i;
    int w, h, bpp;
    Uint32 flags;
    Uint16 ramp[256];
    Uint16 red_ramp[256];
    Uint32 then, timeout;

    /* Check command line arguments */
    argv += get_video_args(argv, &w, &h, &bpp, &flags);

    /* Initialize SDL */
    if (SDL_Init(SDL_INIT_VIDEO) < 0) {
        fprintf(stderr, "Couldn't initialize SDL: %s\n", SDL_GetError());
        return (1);
    }

    /* Initialize the display, always use hardware palette */
    screen = SDL_SetVideoMode(w, h, bpp, flags | SDL_HWPALETTE);
    if (screen == NULL) {
        fprintf(stderr, "Couldn't set %dx%d video mode: %s\n",
                w, h, SDL_GetError());
        quit(1);
    }

    /* Set the window manager title bar */
    SDL_WM_SetCaption("SDL gamma test", "testgamma");

    /* Set the desired gamma, if any */
    gamma = 1.0f;
    if (*argv) {
        gamma = (float) atof(*argv);
    }
    if (SDL_SetGamma(gamma, gamma, gamma) < 0) {
        fprintf(stderr, "Unable to set gamma: %s\n", SDL_GetError());
        quit(1);
    }
#if 0                           /* This isn't supported.  Integrating the gamma ramps isn't exact */
    /* See what gamma was actually set */
    float real[3];
    if (SDL_GetGamma(&real[0], &real[1], &real[2]) < 0) {
        printf("Couldn't get gamma: %s\n", SDL_GetError());
    } else {
        printf("Set gamma values: R=%2.2f, G=%2.2f, B=%2.2f\n",
               real[0], real[1], real[2]);
    }
#endif

    /* Do all the drawing work */
    image = SDL_LoadBMP("sample.bmp");
    if (image) {
        SDL_Rect dst;

        dst.x = (screen->w - image->w) / 2;
        dst.y = (screen->h - image->h) / 2;
        dst.w = image->w;
        dst.h = image->h;
        SDL_BlitSurface(image, NULL, screen, &dst);
        SDL_UpdateRects(screen, 1, &dst);
    }

    /* Wait a bit, handling events */
    then = SDL_GetTicks();
    timeout = (5 * 1000);
    while ((SDL_GetTicks() - then) < timeout) {
        SDL_Event event;

        while (SDL_PollEvent(&event)) {
            switch (event.type) {
            case SDL_QUIT:     /* Quit now */
                timeout = 0;
                break;
            case SDL_KEYDOWN:
                switch (event.key.keysym.sym) {
                case SDLK_SPACE:       /* Go longer.. */
                    timeout += (5 * 1000);
                    break;
                case SDLK_UP:
                    gamma += 0.2f;
                    SDL_SetGamma(gamma, gamma, gamma);
                    break;
                case SDLK_DOWN:
                    gamma -= 0.2f;
                    SDL_SetGamma(gamma, gamma, gamma);
                    break;
                case SDLK_ESCAPE:
                    timeout = 0;
                    break;
                default:
                    break;
                }
                break;
            }
        }
    }

    /* Perform a gamma flash to red using color ramps */
    while (gamma < 10.0) {
        /* Increase the red gamma and decrease everything else... */
        gamma += 0.1f;
        CalculateGamma(gamma, red_ramp);
        CalculateGamma(1.0 / gamma, ramp);
        SDL_SetGammaRamp(red_ramp, ramp, ramp);
    }
    /* Finish completely red */
    memset(red_ramp, 255, sizeof(red_ramp));
    memset(ramp, 0, sizeof(ramp));
    SDL_SetGammaRamp(red_ramp, ramp, ramp);

    /* Now fade out to black */
    for (i = (red_ramp[0] >> 8); i >= 0; --i) {
        memset(red_ramp, i, sizeof(red_ramp));
        SDL_SetGammaRamp(red_ramp, NULL, NULL);
    }
    SDL_Delay(1 * 1000);

    SDL_Quit();
    return (0);
}