/* 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);
}