SDL Library Documentation
Prev |  | Next

# Chapter 2. Graphics and Video

# Introduction to SDL Video

Video is probably the most common thing that SDL is used for, and so it has the most complete subsystem. Here are a few examples to demonstrate the basics.

## Initializing the Video Display

This is what almost all SDL programs have to do in one way or another.

Example 2-1. Initializing the Video Display

        SDL_Surface *screen;

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

        /* Clean up on exit */
        atexit(SDL_Quit);

        /*
         * Initialize the display in a 640x480 8-bit palettized mode,
         * requesting a software surface
         */
        screen = SDL_SetVideoMode(640, 480, 8, SDL_SWSURFACE);
        if ( screen == NULL ) {
            fprintf(stderr, "Couldn't set 640x480x8 video mode: %s\n",
                            SDL_GetError());
            exit(1);
        }

## Initializing the Best Video Mode

If you have a preference for a certain pixel depth but will accept any other, use SDL_SetVideoMode with SDL_ANYFORMAT as below. You can also use SDL_VideoModeOK() to find the native video mode that is closest to the mode you request.

Example 2-2. Initializing the Best Video Mode

        /* Have a preference for 8-bit, but accept any depth */
        screen = SDL_SetVideoMode(640, 480, 8, SDL_SWSURFACE|SDL_ANYFORMAT);
        if ( screen == NULL ) {
            fprintf(stderr, "Couldn't set 640x480x8 video mode: %s\n",
                            SDL_GetError());
            exit(1);
        }
        printf("Set 640x480 at %d bits-per-pixel mode\n",
               screen->format->BitsPerPixel);

## Loading and Displaying a BMP File

The following function loads and displays a BMP file given as argument, once SDL is initialised and a video mode has been set.

Example 2-3. Loading and Displaying a BMP File

    void display_bmp(char *file_name)
    {
        SDL_Surface *image;

        /* Load the BMP file into a surface */
        image = SDL_LoadBMP(file_name);
        if (image == NULL) {
            fprintf(stderr, "Couldn't load %s: %s\n", file_name, SDL_GetError());
            return;
        }

        /*
         * Palettized screen modes will have a default palette (a standard
         * 8*8*4 colour cube), but if the image is palettized as well we can
         * use that palette for a nicer colour matching
         */
        if (image->format->palette && screen->format->palette) {
        SDL_SetColors(screen, image->format->palette->colors, 0,
                      image->format->palette->ncolors);
        }

        /* Blit onto the screen surface */
        if(SDL_BlitSurface(image, NULL, screen, NULL) < 0)
            fprintf(stderr, "BlitSurface error: %s\n", SDL_GetError());

        SDL_UpdateRect(screen, 0, 0, image->w, image->h);

        /* Free the allocated BMP surface */
        SDL_FreeSurface(image);
    }

## Drawing Directly to the Display

The following two functions can be used to get and set single pixels of a surface. They are carefully written to work with any depth currently supported by SDL. Remember to lock the surface before calling them, and to unlock it before calling any other SDL functions.

To convert between pixel values and their red, green, blue components, use SDL_GetRGB() and SDL_MapRGB().

Example 2-4. getpixel()

    /*
     * Return the pixel value at (x, y)
     * NOTE: The surface must be locked before calling this!
     */
    Uint32 getpixel(SDL_Surface *surface, int x, int y)
    {
        int bpp = surface->format->BytesPerPixel;
        /* Here p is the address to the pixel we want to retrieve */
        Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp;

        switch(bpp) {
        case 1:
            return *p;

        case 2:
            return *(Uint16 *)p;

        case 3:
            if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
                return p[0] << 16 | p[1] << 8 | p[2];
            else
                return p[0] | p[1] << 8 | p[2] << 16;

        case 4:
            return *(Uint32 *)p;

        default:
            return 0;       /* shouldn't happen, but avoids warnings */
        }
    }

Example 2-5. putpixel()

    /*
     * Set the pixel at (x, y) to the given value
     * NOTE: The surface must be locked before calling this!
     */
    void putpixel(SDL_Surface *surface, int x, int y, Uint32 pixel)
    {
        int bpp = surface->format->BytesPerPixel;
        /* Here p is the address to the pixel we want to set */
        Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp;

        switch(bpp) {
        case 1:
            *p = pixel;
            break;

        case 2:
            *(Uint16 *)p = pixel;
            break;

        case 3:
            if(SDL_BYTEORDER == SDL_BIG_ENDIAN) {
                p[0] = (pixel >> 16) & 0xff;
                p[1] = (pixel >> 8) & 0xff;
                p[2] = pixel & 0xff;
            } else {
                p[0] = pixel & 0xff;
                p[1] = (pixel >> 8) & 0xff;
                p[2] = (pixel >> 16) & 0xff;
            }
            break;

        case 4:
            *(Uint32 *)p = pixel;
            break;
        }
    }

The following code uses the putpixel() function above to set a yellow pixel in the middle of the screen.

Example 2-6. Using putpixel()

        /* Code to set a yellow pixel at the center of the screen */

        int x, y;
        Uint32 yellow;

        /* Map the color yellow to this display (R=0xff, G=0xFF, B=0x00)
           Note:  If the display is palettized, you must set the palette first.
        */
        yellow = SDL_MapRGB(screen->format, 0xff, 0xff, 0x00);

        x = screen->w / 2;
        y = screen->h / 2;

        /* Lock the screen for direct access to the pixels */
        if ( SDL_MUSTLOCK(screen) ) {
            if ( SDL_LockSurface(screen) < 0 ) {
                fprintf(stderr, "Can't lock screen: %s\n", SDL_GetError());
                return;
            }
        }

        putpixel(screen, x, y, yellow);

        if ( SDL_MUSTLOCK(screen) ) {
            SDL_UnlockSurface(screen);
        }
        /* Update just the part of the display that we've changed */
        SDL_UpdateRect(screen, x, y, 1, 1);

        return;

Prev | Home | Next
Initializing SDL | Up | Using OpenGL With SDL