/* Simple program -- figure out what kind of video display we have */

#include <stdlib.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "SDL.h"

#define NUM_BLITS	10

#define NUM_UPDATES	500

#define FLAG_MASK	(SDL_HWSURFACE | SDL_FULLSCREEN | SDL_DOUBLEBUF | \

                         SDL_SRCCOLORKEY | SDL_SRCALPHA | SDL_RLEACCEL  | \

                         SDL_RLEACCELOK)

#if 0

void

PrintFlags(Uint32 flags)

{

    printf("0x%8.8x", (flags & FLAG_MASK));

    if (flags & SDL_HWSURFACE) {

        printf(" SDL_HWSURFACE");

    } else {

        printf(" SDL_SWSURFACE");

    }

    if (flags & SDL_FULLSCREEN) {

        printf(" | SDL_FULLSCREEN");

    }

    if (flags & SDL_DOUBLEBUF) {

        printf(" | SDL_DOUBLEBUF");

    }

    if (flags & SDL_SRCCOLORKEY) {

        printf(" | SDL_SRCCOLORKEY");

    }

    if (flags & SDL_SRCALPHA) {

        printf(" | SDL_SRCALPHA");

    }

    if (flags & SDL_RLEACCEL) {

        printf(" | SDL_RLEACCEL");

    }

    if (flags & SDL_RLEACCELOK) {

        printf(" | SDL_RLEACCELOK");

    }

}

int

RunBlitTests(SDL_Surface * screen, SDL_Surface * bmp, int blitcount)

{

    int i, j;

    int maxx;

    int maxy;

    SDL_Rect dst;

    maxx = (int) screen->w - bmp->w + 1;

    maxy = (int) screen->h - bmp->h + 1;

    for (i = 0; i < NUM_UPDATES; ++i) {

        for (j = 0; j < blitcount; ++j) {

            if (maxx) {

                dst.x = rand() % maxx;

            } else {

                dst.x = 0;

            }

            if (maxy) {

                dst.y = rand() % maxy;

            } else {

                dst.y = 0;

            }

            dst.w = bmp->w;

            dst.h = bmp->h;

            SDL_BlitSurface(bmp, NULL, screen, &dst);

        }

        SDL_Flip(screen);

    }

    return i;

}

int

RunModeTests(SDL_Surface * screen)

{

    Uint32 then, now;

    Uint32 frames;

    float seconds;

    int i;

    Uint8 r, g, b;

    SDL_Surface *bmp, *bmpcc, *tmp;

    SDL_Event event;

    while (SDL_PollEvent(&event)) {

        if (event.type == SDL_KEYDOWN)

            return 0;

    }

    /* First test fills and screen update speed */

    printf("Running color fill and fullscreen update test\n");

    then = SDL_GetTicks();

    frames = 0;

    for (i = 0; i < 256; ++i) {

        r = i;

        g = 0;

        b = 0;

        SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, r, g, b));

        SDL_Flip(screen);

        ++frames;

    }

    for (i = 0; i < 256; ++i) {

        r = 0;

        g = i;

        b = 0;

        SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, r, g, b));

        SDL_Flip(screen);

        ++frames;

    }

    for (i = 0; i < 256; ++i) {

        r = 0;

        g = 0;

        b = i;

        SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, r, g, b));

        SDL_Flip(screen);

        ++frames;

    }

    now = SDL_GetTicks();

    seconds = (float) (now - then) / 1000.0f;

    if (seconds > 0.0f) {

        printf("%d fills and flips in %2.2f seconds, %2.2f FPS\n", frames,

               seconds, (float) frames / seconds);

    } else {

        printf("%d fills and flips in zero seconds!n", frames);

    }

    /* clear the screen after fill test */

    SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));

    SDL_Flip(screen);

    while (SDL_PollEvent(&event)) {

        if (event.type == SDL_KEYDOWN)

            return 0;

    }

    /* run the generic blit test */

    bmp = SDL_LoadBMP("sample.bmp");

    if (!bmp) {

        printf("Couldn't load sample.bmp: %s\n", SDL_GetError());

        return 0;

    }

    printf("Running freshly loaded blit test: %dx%d at %d bpp, flags: ",

           bmp->w, bmp->h, bmp->format->BitsPerPixel);

    PrintFlags(bmp->flags);

    printf("\n");

    then = SDL_GetTicks();

    frames = RunBlitTests(screen, bmp, NUM_BLITS);

    now = SDL_GetTicks();

    seconds = (float) (now - then) / 1000.0f;

    if (seconds > 0.0f) {

        printf("%d blits / %d updates in %2.2f seconds, %2.2f FPS\n",

               NUM_BLITS * frames, frames, seconds, (float) frames / seconds);

    } else {

        printf("%d blits / %d updates in zero seconds!\n",

               NUM_BLITS * frames, frames);

    }

    /* clear the screen after blit test */

    SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));

    SDL_Flip(screen);

    while (SDL_PollEvent(&event)) {

        if (event.type == SDL_KEYDOWN)

            return 0;

    }

    /* run the colorkeyed blit test */

    bmpcc = SDL_LoadBMP("sample.bmp");

    if (!bmpcc) {

        printf("Couldn't load sample.bmp: %s\n", SDL_GetError());

        return 0;

    }

    printf("Running freshly loaded cc blit test: %dx%d at %d bpp, flags: ",

           bmpcc->w, bmpcc->h, bmpcc->format->BitsPerPixel);

    SDL_SetColorKey(bmpcc, SDL_SRCCOLORKEY | SDL_RLEACCEL,

                    *(Uint8 *) bmpcc->pixels);

    PrintFlags(bmpcc->flags);

    printf("\n");

    then = SDL_GetTicks();

    frames = RunBlitTests(screen, bmpcc, NUM_BLITS);

    now = SDL_GetTicks();

    seconds = (float) (now - then) / 1000.0f;

    if (seconds > 0.0f) {

        printf("%d cc blits / %d updates in %2.2f seconds, %2.2f FPS\n",

               NUM_BLITS * frames, frames, seconds, (float) frames / seconds);

    } else {

        printf("%d cc blits / %d updates in zero seconds!\n",

               NUM_BLITS * frames, frames);

    }

    /* clear the screen after cc blit test */

    SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));

    SDL_Flip(screen);

    while (SDL_PollEvent(&event)) {

        if (event.type == SDL_KEYDOWN)

            return 0;

    }

    /* run the generic blit test */

    tmp = bmp;

    bmp = SDL_DisplayFormat(bmp);

    SDL_FreeSurface(tmp);

    if (!bmp) {

        printf("Couldn't convert sample.bmp: %s\n", SDL_GetError());

        return 0;

    }

    printf("Running display format blit test: %dx%d at %d bpp, flags: ",

           bmp->w, bmp->h, bmp->format->BitsPerPixel);

    PrintFlags(bmp->flags);

    printf("\n");

    then = SDL_GetTicks();

    frames = RunBlitTests(screen, bmp, NUM_BLITS);

    now = SDL_GetTicks();

    seconds = (float) (now - then) / 1000.0f;

    if (seconds > 0.0f) {

        printf("%d blits / %d updates in %2.2f seconds, %2.2f FPS\n",

               NUM_BLITS * frames, frames, seconds, (float) frames / seconds);

    } else {

        printf("%d blits / %d updates in zero seconds!\n",

               NUM_BLITS * frames, frames);

    }

    /* clear the screen after blit test */

    SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));

    SDL_Flip(screen);

    while (SDL_PollEvent(&event)) {

        if (event.type == SDL_KEYDOWN)

            return 0;

    }

    /* run the colorkeyed blit test */

    tmp = bmpcc;

    bmpcc = SDL_DisplayFormat(bmpcc);

    SDL_FreeSurface(tmp);

    if (!bmpcc) {

        printf("Couldn't convert sample.bmp: %s\n", SDL_GetError());

        return 0;

    }

    printf("Running display format cc blit test: %dx%d at %d bpp, flags: ",

           bmpcc->w, bmpcc->h, bmpcc->format->BitsPerPixel);

    PrintFlags(bmpcc->flags);

    printf("\n");

    then = SDL_GetTicks();

    frames = RunBlitTests(screen, bmpcc, NUM_BLITS);

    now = SDL_GetTicks();

    seconds = (float) (now - then) / 1000.0f;

    if (seconds > 0.0f) {

        printf("%d cc blits / %d updates in %2.2f seconds, %2.2f FPS\n",

               NUM_BLITS * frames, frames, seconds, (float) frames / seconds);

    } else {

        printf("%d cc blits / %d updates in zero seconds!\n",

               NUM_BLITS * frames, frames);

    }

    /* clear the screen after cc blit test */

    SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));

    SDL_Flip(screen);

    while (SDL_PollEvent(&event)) {

        if (event.type == SDL_KEYDOWN)

            return 0;

    }

    /* run the alpha blit test only if screen bpp>8 */

    if (bmp->format->BitsPerPixel > 8) {

        SDL_FreeSurface(bmp);

        bmp = SDL_LoadBMP("sample.bmp");

        SDL_SetAlpha(bmp, SDL_SRCALPHA, 85);    /* 85 - 33% alpha */

        tmp = bmp;

        bmp = SDL_DisplayFormat(bmp);

        SDL_FreeSurface(tmp);

        if (!bmp) {

            printf("Couldn't convert sample.bmp: %s\n", SDL_GetError());

            return 0;

        }

        printf

            ("Running display format alpha blit test: %dx%d at %d bpp, flags: ",

             bmp->w, bmp->h, bmp->format->BitsPerPixel);

        PrintFlags(bmp->flags);

        printf("\n");

        then = SDL_GetTicks();

        frames = RunBlitTests(screen, bmp, NUM_BLITS);

        now = SDL_GetTicks();

        seconds = (float) (now - then) / 1000.0f;

        if (seconds > 0.0f) {

            printf

                ("%d alpha blits / %d updates in %2.2f seconds, %2.2f FPS\n",

                 NUM_BLITS * frames, frames, seconds,

                 (float) frames / seconds);

        } else {

            printf("%d alpha blits / %d updates in zero seconds!\n",

                   NUM_BLITS * frames, frames);

        }

    }

    /* clear the screen after alpha blit test */

    SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));

    SDL_Flip(screen);

    while (SDL_PollEvent(&event)) {

        if (event.type == SDL_KEYDOWN)

            return 0;

    }

    /* run the cc+alpha blit test only if screen bpp>8 */

    if (bmp->format->BitsPerPixel > 8) {

        SDL_FreeSurface(bmpcc);

        bmpcc = SDL_LoadBMP("sample.bmp");

        SDL_SetAlpha(bmpcc, SDL_SRCALPHA, 85);  /* 85 - 33% alpha */

        SDL_SetColorKey(bmpcc, SDL_SRCCOLORKEY | SDL_RLEACCEL,

                        *(Uint8 *) bmpcc->pixels);

        tmp = bmpcc;

        bmpcc = SDL_DisplayFormat(bmpcc);

        SDL_FreeSurface(tmp);

        if (!bmpcc) {

            printf("Couldn't convert sample.bmp: %s\n", SDL_GetError());

            return 0;

        }

        printf

            ("Running display format cc+alpha blit test: %dx%d at %d bpp, flags: ",

             bmpcc->w, bmpcc->h, bmpcc->format->BitsPerPixel);

        PrintFlags(bmpcc->flags);

        printf("\n");

        then = SDL_GetTicks();

        frames = RunBlitTests(screen, bmpcc, NUM_BLITS);

        now = SDL_GetTicks();

        seconds = (float) (now - then) / 1000.0f;

        if (seconds > 0.0f) {

            printf

                ("%d cc+alpha blits / %d updates in %2.2f seconds, %2.2f FPS\n",

                 NUM_BLITS * frames, frames, seconds,

                 (float) frames / seconds);

        } else {

            printf("%d cc+alpha blits / %d updates in zero seconds!\n",

                   NUM_BLITS * frames, frames);

        }

    }

    SDL_FreeSurface(bmpcc);

    SDL_FreeSurface(bmp);

    while (SDL_PollEvent(&event)) {

        if (event.type == SDL_KEYDOWN)

            return 0;

    }

    return 1;

}

void

RunVideoTests()

{

    static const struct

    {

        int w, h, bpp;

    } mode_list[] = {

        {

        640, 480, 8}, {

        640, 480, 16}, {

        640, 480, 32}, {

        800, 600, 8}, {

        800, 600, 16}, {

        800, 600, 32}, {

        1024, 768, 8}, {

        1024, 768, 16}, {

        1024, 768, 32}

    };

    static const Uint32 flags[] = {

        (SDL_SWSURFACE),

        (SDL_SWSURFACE | SDL_FULLSCREEN),

        (SDL_HWSURFACE | SDL_FULLSCREEN),

        (SDL_HWSURFACE | SDL_FULLSCREEN | SDL_DOUBLEBUF)

    };

    int i, j;

    SDL_Surface *screen;

    /* Test out several different video mode combinations */

    SDL_WM_SetCaption("SDL Video Benchmark", "vidtest");

    SDL_ShowCursor(0);

    for (i = 0; i < SDL_TABLESIZE(mode_list); ++i) {

        for (j = 0; j < SDL_TABLESIZE(flags); ++j) {

            printf("===================================\n");

            printf("Setting video mode: %dx%d at %d bpp, flags: ",

                   mode_list[i].w, mode_list[i].h, mode_list[i].bpp);

            PrintFlags(flags[j]);

            printf("\n");

            screen = SDL_SetVideoMode(mode_list[i].w,

                                      mode_list[i].h,

                                      mode_list[i].bpp, flags[j]);

            if (!screen) {

                printf("Setting video mode failed: %s\n", SDL_GetError());

                continue;

            }

            if ((screen->flags & FLAG_MASK) != flags[j]) {

                printf("Flags didn't match: ");

                PrintFlags(screen->flags);

                printf("\n");

                continue;

            }

            if (!RunModeTests(screen)) {

                return;

            }

        }

    }

}

#endif

int

main(int argc, char *argv[])

{

    const SDL_VideoInfo *info;

    const char *driver;

    const SDL_DisplayMode *mode;

    int bpp;

    Uint32 Rmask, Gmask, Bmask, Amask;

    int nmodes;

    /* Print available video drivers */

    n = SDL_GetNumVideoDrivers();

    if (n == 0) {

        printf("No built-in video drivers\n");

    } else {

        printf("Built-in video drivers:");

        for (i = 0; i < n; ++i) {

            if (i > 0) {

                printf(",");

            }

            printf(" %s", SDL_GetVideoDriver(i));

        }

        printf("\n");

    }

    if (SDL_Init(SDL_INIT_VIDEO) < 0) {

        fprintf(stderr, "Couldn't initialize SDL: %s\n", SDL_GetError());

        exit(1);

    }

    driver = SDL_GetCurrentVideoDriver();

    if (driver) {

        printf("Video driver: %s\n", driver);

    }

    printf("Number of displays: %d\n", SDL_GetNumVideoDisplays());