My first (real) experimentation with SDL

/* SDL_image blitting/compositing example.                *
 *                                                        *
 * Compile with:                                          *
 *                                                        *
 * gcc -lSDL -lSDL_image -o SDL_composite SDL_composite.c *
 *                                                        *
 * …on Linux and other UNIX-likes, else use whatever      *
 * compiler came with your system.  This should compile   *
 * on pretty much anything capable of running an OS and a *
 * windowing system, as long as it also has its own       *
 * implementation of the SDL libs.                        *
 *                                                        *
 * Note: You may need to change the SDL header #include   *
 * statements below to properly reflect the location of   *
 * your system's SDL header files.                        */

#include <stdio.h>
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>

#define BPP 24

SDL_Surface* LoadImage(char* file);

int main(int argc,char** argv)
{
    if(argc == 3)
    {
        char quit = 0;    
    
        SDL_Surface* scr = NULL; //Display surface
        SDL_Surface *img1 = NULL, //Background surface
                    *img2 = NULL; //Foreground surface

        SDL_Rect draw; //Drawing rectangle for foreground surface

        SDL_Event ev; //Event structure

        /*Assuming everything went well with initialization…*/
        if(SDL_Init(SDL_INIT_VIDEO) == -1)
        {
            fprintf(stderr,"%s\n",SDL_GetError());
            return -1;
        }

        /*…go ahead and set the video mode, checking for screwups afterward*/
        scr = SDL_SetVideoMode(1,1,BPP,SDL_HWSURFACE | SDL_DOUBLEBUF);
        if(scr == NULL)
        {
            fprintf(stderr,"%s\n",SDL_GetError());
            return -1;
        }

        /*Load images*/
        img1 = LoadImage(argv[1]);
        if(img1 == NULL)
        {
            fprintf(stderr,"%s\n",SDL_GetError());
            return -1;
        }
    
        img2 = LoadImage(argv[2]);
        if(img2 == NULL)
        {
            fprintf(stderr,"%s\n",SDL_GetError());
            return -1;
        }
        
        /*Re-set screen video mode to width and height of background image*/
        scr = SDL_SetVideoMode(img1->w,img1->h,BPP,SDL_HWSURFACE |
                                                   SDL_DOUBLEBUF);

        SDL_WM_SetCaption("SDL Blitting/Compositing Demo",NULL);

        /*Set drawing rect position/dimensions*/
        draw.x = (img1->w / 2) - (img2->w / 2);
        draw.y = (img1->h / 2) - (img2->h / 2);
        
        draw.w = img2->w;
        draw.h = img2->h;

        /*Blit background first, then foreground on top*/
        SDL_BlitSurface(img1,NULL,scr,NULL);
        SDL_BlitSurface(img2,NULL,scr,&draw);

        /*Update screen*/
        SDL_Flip(scr);

        while(quit == 0)
        {
            /*While there are events in the queue*/
            while(SDL_PollEvent(&ev))
            {
                switch(ev.type)
                {
                    /*If the user hits the close button in the window*/
                    case SDL_QUIT:
                        quit = 1;
                    break;
                    case SDL_KEYDOWN:
                    {
                        /*If the user presses the escape key*/
                        if(ev.key.keysym.sym == SDLK_ESCAPE)
                            quit = 1;
                    } break;
                    /*If the cursor moves in the window*/
                    case SDL_MOUSEMOTION:
                    {
                        /*Set drawing rect position/dimensions*/
                        draw.x = ev.motion.x - (img2->w / 2);
                        draw.y = ev.motion.y - (img2->h / 2);

                        draw.w = img2->w;
                        draw.h = img2->h;

                        /*Blit background first, then foreground on top*/
                        SDL_BlitSurface(img1,NULL,scr,NULL);
                        SDL_BlitSurface(img2,NULL,scr,&draw);
                        
                        /*Update screen*/
                        SDL_Flip(scr);
                    } break;
                }
            }

            /* Delay for approx. 17 ms after each event poll *
             * for approx. 60 polling ticks/sec.             *
             * Without this, the program will poll for       *
             * events as often as it can, taking 100% CPU    *
             * time in the process.                          */
            SDL_Delay((int)1000/60);
        }

        /*Free surface pointers and quit*/
        SDL_FreeSurface(img1);
        SDL_FreeSurface(img2);
        SDL_Quit();
    }
    else
    {
        printf("Usage: ./SDL_composite <fg> <bg>\n");
        printf("SDL Example: composites <fg> onto <bg>.\n");
        printf("Also demonstrates event-based programming with SDL.\n");
        
        return 1;
    }
    
    return 0;
}

SDL_Surface* LoadImage(char* file)
{
    SDL_Surface* initImage = NULL;
    SDL_Surface* optImage  = NULL;

    initImage = IMG_Load(file);

    if(initImage != NULL)
    {
        optImage = SDL_DisplayFormat(initImage);

        SDL_FreeSurface(initImage);
    }

    return optImage;
}