/*
 * Benchmarks surface-to-surface blits in various formats.
 *
 *  Written by Ryan C. Gordon.
 */

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

#include "SDL.h"

static SDL_Surface *dest = NULL;
static SDL_Surface *src = NULL;
static int testSeconds = 10;


static int
percent (int val, int total)
{
    return ((int) ((((float) val) / ((float) total)) * 100.0f));
}

static int
randRange (int lo, int hi)
{
    return (lo + (int) (((double) hi) * rand () / (RAND_MAX + 1.0)));
}

static void
copy_trunc_str (char *str, size_t strsize, const char *flagstr)
{
    if ((strlen (str) + strlen (flagstr)) >= (strsize - 1))
        strcpy (str + (strsize - 5), " ...");
    else
        strcat (str, flagstr);
}

static void
__append_sdl_surface_flag (SDL_Surface * _surface, char *str,
                           size_t strsize, Uint32 flag, const char *flagstr)
{
    if (_surface->flags & flag)
        copy_trunc_str (str, strsize, flagstr);
}


#define append_sdl_surface_flag(a, b, c, fl) __append_sdl_surface_flag(a, b, c, fl, " " #fl)
#define print_tf_state(str, val) printf("%s: {%s}\n", str, (val) ? "true" : "false" )

static void
output_videoinfo_details (void)
{
    const SDL_VideoInfo *info = SDL_GetVideoInfo ();
    printf ("SDL_GetVideoInfo():\n");
    if (info == NULL)
        printf ("  (null.)\n");
    else {
        print_tf_state ("  hardware surface available", info->hw_available);
        print_tf_state ("  window manager available", info->wm_available);
        print_tf_state ("  accelerated hardware->hardware blits",
                        info->blit_hw);
        print_tf_state ("  accelerated hardware->hardware colorkey blits",
                        info->blit_hw_CC);
        print_tf_state ("  accelerated hardware->hardware alpha blits",
                        info->blit_hw_A);
        print_tf_state ("  accelerated software->hardware blits",
                        info->blit_sw);
        print_tf_state ("  accelerated software->hardware colorkey blits",
                        info->blit_sw_CC);
        print_tf_state ("  accelerated software->hardware alpha blits",
                        info->blit_sw_A);
        print_tf_state ("  accelerated color fills", info->blit_fill);
        printf ("  video memory: (%d)\n", info->video_mem);
    }

    printf ("\n");
}

static void
output_surface_details (const char *name, SDL_Surface * surface)
{
    printf ("Details for %s:\n", name);

    if (surface == NULL) {
        printf ("-WARNING- You've got a NULL surface!");
    } else {
        char f[256];
        printf ("  width      : %d\n", surface->w);
        printf ("  height     : %d\n", surface->h);
        printf ("  depth      : %d bits per pixel\n",
                surface->format->BitsPerPixel);
        printf ("  pitch      : %d\n", (int) surface->pitch);
        printf ("  alpha      : %d\n", (int) surface->format->alpha);
        printf ("  colorkey   : 0x%X\n",
                (unsigned int) surface->format->colorkey);

        printf ("  red bits   : 0x%08X mask, %d shift, %d loss\n",
                (int) surface->format->Rmask,
                (int) surface->format->Rshift, (int) surface->format->Rloss);
        printf ("  green bits : 0x%08X mask, %d shift, %d loss\n",
                (int) surface->format->Gmask,
                (int) surface->format->Gshift, (int) surface->format->Gloss);
        printf ("  blue bits  : 0x%08X mask, %d shift, %d loss\n",
                (int) surface->format->Bmask,
                (int) surface->format->Bshift, (int) surface->format->Bloss);
        printf ("  alpha bits : 0x%08X mask, %d shift, %d loss\n",
                (int) surface->format->Amask,
                (int) surface->format->Ashift, (int) surface->format->Aloss);

        f[0] = '\0';

        /*append_sdl_surface_flag(surface, f, sizeof (f), SDL_SWSURFACE); */
        if ((surface->flags & SDL_HWSURFACE) == 0)
            copy_trunc_str (f, sizeof (f), " SDL_SWSURFACE");

        append_sdl_surface_flag (surface, f, sizeof (f), SDL_HWSURFACE);
        append_sdl_surface_flag (surface, f, sizeof (f), SDL_ASYNCBLIT);
        append_sdl_surface_flag (surface, f, sizeof (f), SDL_ANYFORMAT);
        append_sdl_surface_flag (surface, f, sizeof (f), SDL_HWPALETTE);
        append_sdl_surface_flag (surface, f, sizeof (f), SDL_DOUBLEBUF);
        append_sdl_surface_flag (surface, f, sizeof (f), SDL_FULLSCREEN);
        append_sdl_surface_flag (surface, f, sizeof (f), SDL_OPENGL);
        append_sdl_surface_flag (surface, f, sizeof (f), SDL_RESIZABLE);
        append_sdl_surface_flag (surface, f, sizeof (f), SDL_NOFRAME);
        append_sdl_surface_flag (surface, f, sizeof (f), SDL_HWACCEL);
        append_sdl_surface_flag (surface, f, sizeof (f), SDL_SRCCOLORKEY);
        append_sdl_surface_flag (surface, f, sizeof (f), SDL_RLEACCELOK);
        append_sdl_surface_flag (surface, f, sizeof (f), SDL_RLEACCEL);
        append_sdl_surface_flag (surface, f, sizeof (f), SDL_SRCALPHA);
        append_sdl_surface_flag (surface, f, sizeof (f), SDL_PREALLOC);

        if (f[0] == '\0')
            strcpy (f, " (none)");

        printf ("  flags      :%s\n", f);
    }

    printf ("\n");
}

static void
output_details (void)
{
    output_videoinfo_details ();
    output_surface_details ("Source Surface", src);
    output_surface_details ("Destination Surface", dest);
}

static Uint32
blit (SDL_Surface * dst, SDL_Surface * src, int x, int y)
{
    Uint32 start = 0;
    SDL_Rect srcRect;
    SDL_Rect dstRect;

    srcRect.x = 0;
    srcRect.y = 0;
    dstRect.x = x;
    dstRect.y = y;
    dstRect.w = srcRect.w = src->w;     /* SDL will clip as appropriate. */
    dstRect.h = srcRect.h = src->h;

    start = SDL_GetTicks ();
    SDL_BlitSurface (src, &srcRect, dst, &dstRect);
    return (SDL_GetTicks () - start);
}

static void
blitCentered (SDL_Surface * dst, SDL_Surface * src)
{
    int x = (dst->w - src->w) / 2;
    int y = (dst->h - src->h) / 2;
    blit (dst, src, x, y);
}

static int
atoi_hex (const char *str)
{
    if (str == NULL)
        return 0;

    if (strlen (str) > 2) {
        int retval = 0;
        if ((str[0] == '0') && (str[1] == 'x'))
            sscanf (str + 2, "%X", &retval);
        return (retval);
    }

    return (atoi (str));
}


static int
setup_test (int argc, char **argv)
{
    const char *dumpfile = NULL;
    SDL_Surface *bmp = NULL;
    Uint32 dstbpp = 32;
    Uint32 dstrmask = 0x00FF0000;
    Uint32 dstgmask = 0x0000FF00;
    Uint32 dstbmask = 0x000000FF;
    Uint32 dstamask = 0x00000000;
    Uint32 dstflags = 0;
    int dstw = 640;
    int dsth = 480;
    Uint32 srcbpp = 32;
    Uint32 srcrmask = 0x00FF0000;
    Uint32 srcgmask = 0x0000FF00;
    Uint32 srcbmask = 0x000000FF;
    Uint32 srcamask = 0x00000000;
    Uint32 srcflags = 0;
    int srcw = 640;
    int srch = 480;
    Uint32 origsrcalphaflags = 0;
    Uint32 origdstalphaflags = 0;
    Uint32 srcalphaflags = 0;
    Uint32 dstalphaflags = 0;
    int srcalpha = 255;
    int dstalpha = 255;
    int screenSurface = 0;
    int i = 0;

    for (i = 1; i < argc; i++) {
        const char *arg = argv[i];

        if (strcmp (arg, "--dstbpp") == 0)
            dstbpp = atoi (argv[++i]);
        else if (strcmp (arg, "--dstrmask") == 0)
            dstrmask = atoi_hex (argv[++i]);
        else if (strcmp (arg, "--dstgmask") == 0)
            dstgmask = atoi_hex (argv[++i]);
        else if (strcmp (arg, "--dstbmask") == 0)
            dstbmask = atoi_hex (argv[++i]);
        else if (strcmp (arg, "--dstamask") == 0)
            dstamask = atoi_hex (argv[++i]);
        else if (strcmp (arg, "--dstwidth") == 0)
            dstw = atoi (argv[++i]);
        else if (strcmp (arg, "--dstheight") == 0)
            dsth = atoi (argv[++i]);
        else if (strcmp (arg, "--dsthwsurface") == 0)
            dstflags |= SDL_HWSURFACE;
        else if (strcmp (arg, "--srcbpp") == 0)
            srcbpp = atoi (argv[++i]);
        else if (strcmp (arg, "--srcrmask") == 0)
            srcrmask = atoi_hex (argv[++i]);
        else if (strcmp (arg, "--srcgmask") == 0)
            srcgmask = atoi_hex (argv[++i]);
        else if (strcmp (arg, "--srcbmask") == 0)
            srcbmask = atoi_hex (argv[++i]);
        else if (strcmp (arg, "--srcamask") == 0)
            srcamask = atoi_hex (argv[++i]);
        else if (strcmp (arg, "--srcwidth") == 0)
            srcw = atoi (argv[++i]);
        else if (strcmp (arg, "--srcheight") == 0)
            srch = atoi (argv[++i]);
        else if (strcmp (arg, "--srchwsurface") == 0)
            srcflags |= SDL_HWSURFACE;
        else if (strcmp (arg, "--seconds") == 0)
            testSeconds = atoi (argv[++i]);
        else if (strcmp (arg, "--screen") == 0)
            screenSurface = 1;
        else if (strcmp (arg, "--dumpfile") == 0)
            dumpfile = argv[++i];
        /* !!! FIXME: set colorkey. */
        else if (0) {           /* !!! FIXME: we handle some commandlines elsewhere now */
            fprintf (stderr, "Unknown commandline option: %s\n", arg);
            return (0);
        }
    }

    if (SDL_Init (SDL_INIT_VIDEO) == -1) {
        fprintf (stderr, "SDL_Init failed: %s\n", SDL_GetError ());
        return (0);
    }

    bmp = SDL_LoadBMP ("sample.bmp");
    if (bmp == NULL) {
        fprintf (stderr, "SDL_LoadBMP failed: %s\n", SDL_GetError ());
        SDL_Quit ();
        return (0);
    }

    if ((dstflags & SDL_HWSURFACE) == 0)
        dstflags |= SDL_SWSURFACE;
    if ((srcflags & SDL_HWSURFACE) == 0)
        srcflags |= SDL_SWSURFACE;

    if (screenSurface)
        dest = SDL_SetVideoMode (dstw, dsth, dstbpp, dstflags);
    else {
        dest = SDL_CreateRGBSurface (dstflags, dstw, dsth, dstbpp,
                                     dstrmask, dstgmask, dstbmask, dstamask);
    }

    if (dest == NULL) {
        fprintf (stderr, "dest surface creation failed: %s\n",
                 SDL_GetError ());
        SDL_Quit ();
        return (0);
    }

    src = SDL_CreateRGBSurface (srcflags, srcw, srch, srcbpp,
                                srcrmask, srcgmask, srcbmask, srcamask);
    if (src == NULL) {
        fprintf (stderr, "src surface creation failed: %s\n",
                 SDL_GetError ());
        SDL_Quit ();
        return (0);
    }

    /* handle alpha settings... */
    srcalphaflags = (src->flags & SDL_SRCALPHA) | (src->flags & SDL_RLEACCEL);
    dstalphaflags =
        (dest->flags & SDL_SRCALPHA) | (dest->flags & SDL_RLEACCEL);
    origsrcalphaflags = srcalphaflags;
    origdstalphaflags = dstalphaflags;
    srcalpha = src->format->alpha;
    dstalpha = dest->format->alpha;
    for (i = 1; i < argc; i++) {
        const char *arg = argv[i];

        if (strcmp (arg, "--srcalpha") == 0)
            srcalpha = atoi (argv[++i]);
        else if (strcmp (arg, "--dstalpha") == 0)
            dstalpha = atoi (argv[++i]);
        else if (strcmp (arg, "--srcsrcalpha") == 0)
            srcalphaflags |= SDL_SRCALPHA;
        else if (strcmp (arg, "--srcnosrcalpha") == 0)
            srcalphaflags &= ~SDL_SRCALPHA;
        else if (strcmp (arg, "--srcrleaccel") == 0)
            srcalphaflags |= SDL_RLEACCEL;
        else if (strcmp (arg, "--srcnorleaccel") == 0)
            srcalphaflags &= ~SDL_RLEACCEL;
        else if (strcmp (arg, "--dstsrcalpha") == 0)
            dstalphaflags |= SDL_SRCALPHA;
        else if (strcmp (arg, "--dstnosrcalpha") == 0)
            dstalphaflags &= ~SDL_SRCALPHA;
        else if (strcmp (arg, "--dstrleaccel") == 0)
            dstalphaflags |= SDL_RLEACCEL;
        else if (strcmp (arg, "--dstnorleaccel") == 0)
            dstalphaflags &= ~SDL_RLEACCEL;
    }
    if ((dstalphaflags != origdstalphaflags)
        || (dstalpha != dest->format->alpha))
        SDL_SetAlpha (dest, dstalphaflags, (Uint8) dstalpha);
    if ((srcalphaflags != origsrcalphaflags)
        || (srcalpha != src->format->alpha))
        SDL_SetAlpha (src, srcalphaflags, (Uint8) srcalpha);

    /* set some sane defaults so we can see if the blit code is broken... */
    SDL_FillRect (dest, NULL, SDL_MapRGB (dest->format, 0, 0, 0));
    SDL_FillRect (src, NULL, SDL_MapRGB (src->format, 0, 0, 0));

    blitCentered (src, bmp);
    SDL_FreeSurface (bmp);

    if (dumpfile)
        SDL_SaveBMP (src, dumpfile);    /* make sure initial convert is sane. */

    output_details ();

    return (1);
}


static void
test_blit_speed (void)
{
    Uint32 clearColor = SDL_MapRGB (dest->format, 0, 0, 0);
    Uint32 iterations = 0;
    Uint32 elasped = 0;
    Uint32 end = 0;
    Uint32 now = 0;
    Uint32 last = 0;
    int testms = testSeconds * 1000;
    int wmax = (dest->w - src->w);
    int hmax = (dest->h - src->h);
    int isScreen = (SDL_GetVideoSurface () == dest);
    SDL_Event event;

    printf ("Testing blit speed for %d seconds...\n", testSeconds);

    now = SDL_GetTicks ();
    end = now + testms;

    do {
        /* pump the event queue occasionally to keep OS happy... */
        if (now - last > 1000) {
            last = now;
            while (SDL_PollEvent (&event)) {    /* no-op. */
            }
        }

        iterations++;
        elasped += blit (dest, src, randRange (0, wmax), randRange (0, hmax));
        if (isScreen) {
            SDL_Flip (dest);    /* show it! */
            SDL_FillRect (dest, NULL, clearColor);      /* blank it for next time! */
        }

        now = SDL_GetTicks ();
    }
    while (now < end);

    printf ("Non-blitting crap accounted for %d percent of this run.\n",
            percent (testms - elasped, testms));

    printf ("%d blits took %d ms (%d fps).\n",
            (int) iterations,
            (int) elasped,
            (int) (((float) iterations) / (((float) elasped) / 1000.0f)));
}

int
main (int argc, char **argv)
{
    int initialized = setup_test (argc, argv);
    if (initialized) {
        test_blit_speed ();
        SDL_Quit ();
    }
    return (!initialized);
}

/* end of testblitspeed.c ... */