Sorry, I wasnt able to create an attachment due to a bug in bugzilla. So I copy and paste the testprogramm here:

/* Bring up a window and play with it */

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

#define BENCHMARK_SDL

#define NOTICE(X)	printf("%s", X);

#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);
}

void
DrawPict(SDL_Surface * screen, char *bmpfile,
         int speedy, int flip, int nofade)
{
    SDL_Surface *picture;
    SDL_Rect dest, update;
    int i, centered;
    int ncolors;
    SDL_Color *colors, *cmap;

    /* Load the image into a surface */
    if (bmpfile == NULL) {
        bmpfile = "sample.bmp"; /* Sample image */
    }
    fprintf(stderr, "Loading picture: %s\n", bmpfile);
    picture = SDL_LoadBMP(bmpfile);
    if (picture == NULL) {
        fprintf(stderr, "Couldn't load %s: %s\n", bmpfile, SDL_GetError());
        return;
    }

    /* Set the display colors -- on a hicolor display this is a no-op */
    if (picture->format->palette) {
        ncolors = picture->format->palette->ncolors;
        colors = (SDL_Color *) malloc(ncolors * sizeof(SDL_Color));
        cmap = (SDL_Color *) malloc(ncolors * sizeof(SDL_Color));
        memcpy(colors, picture->format->palette->colors,
               ncolors * sizeof(SDL_Color));
    } else {
        int r, g, b;

        /* Allocate 256 color palette */
        ncolors = 256;
        colors = (SDL_Color *) malloc(ncolors * sizeof(SDL_Color));
        cmap = (SDL_Color *) malloc(ncolors * sizeof(SDL_Color));

        /* Set a 3,3,2 color cube */
        for (r = 0; r < 8; ++r) {
            for (g = 0; g < 8; ++g) {
                for (b = 0; b < 4; ++b) {
                    i = ((r << 5) | (g << 2) | b);
                    colors[i].r = r << 5;
                    colors[i].g = g << 5;
                    colors[i].b = b << 6;
                }
            }
        }
    }
    NOTICE("testwin: setting colors\n");
    if (!SDL_SetColors(screen, colors, 0, ncolors) &&
        (screen->format->palette != NULL)) {
        fprintf(stderr,
                "Warning: Couldn't set all of the colors, but SDL will map the image\n"
                "         (colormap fading will suffer - try the -warp option)\n");
    }

    /* Set the screen to black (not really necessary) */
    if (SDL_LockSurface(screen) == 0) {
        Uint32 black;
        Uint8 *pixels;

        black = SDL_MapRGB(screen->format, 0, 0, 0);
        pixels = (Uint8 *) screen->pixels;
        for (i = 0; i < screen->h; ++i) {
            memset(pixels, black, screen->w * screen->format->BytesPerPixel);
            pixels += screen->pitch;
        }
        SDL_UnlockSurface(screen);
        SDL_UpdateRect(screen, 0, 0, 0, 0);
    }

    /* Display the picture */
    if (speedy) {
        SDL_Surface *displayfmt;

        fprintf(stderr, "Converting picture\n");
        displayfmt = SDL_DisplayFormat(picture);
        if (displayfmt == NULL) {
            fprintf(stderr, "Couldn't convert image: %s\n", SDL_GetError());
            goto done;
        }
        SDL_FreeSurface(picture);
        picture = displayfmt;
    }
    printf("(image surface located in %s memory)\n",
           (picture->flags & SDL_HWSURFACE) ? "video" : "system");
    centered = (screen->w - picture->w) / 2;
    if (centered < 0) {
        centered = 0;
    }
    dest.y = (screen->h - picture->h) / 2;
    dest.w = picture->w;
    dest.h = picture->h;
    NOTICE("testwin: moving image\n");
    for (i = 0; i <= centered; ++i) {
        dest.x = i;
        update = dest;
        if (SDL_BlitSurface(picture, NULL, screen, &update) < 0) {
            fprintf(stderr, "Blit failed: %s\n", SDL_GetError());
            break;
        }
        if (flip) {
            SDL_Flip(screen);
        } else {
            SDL_UpdateRects(screen, 1, &update);
        }
    }

#ifdef SCREENSHOT
    if (SDL_SaveBMP(screen, "screen.bmp") < 0)
        printf("Couldn't save screen: %s\n", SDL_GetError());
#endif

#ifndef BENCHMARK_SDL
    /* Let it sit there for a while */
    SDL_Delay(5 * 1000);
#endif
    /* Fade the colormap */
    if (!nofade) {
        int maxstep;
        SDL_Color final;
        SDL_Color palcolors[256];
        struct
        {
            Sint16 r, g, b;
        } cdist[256];

        NOTICE("testwin: fading out...\n");
        memcpy(cmap, colors, ncolors * sizeof(SDL_Color));
        maxstep = 32 - 1;
        final.r = 0xFF;
        final.g = 0x00;
        final.b = 0x00;
        memcpy(palcolors, colors, ncolors * sizeof(SDL_Color));
        for (i = 0; i < ncolors; ++i) {
            cdist[i].r = final.r - palcolors[i].r;
            cdist[i].g = final.g - palcolors[i].g;
            cdist[i].b = final.b - palcolors[i].b;
        }
        for (i = 0; i <= maxstep / 2; ++i) {    /* halfway fade */
            int c;
            for (c = 0; c < ncolors; ++c) {
                colors[c].r = palcolors[c].r + ((cdist[c].r * i)) / maxstep;
                colors[c].g = palcolors[c].g + ((cdist[c].g * i)) / maxstep;
                colors[c].b = palcolors[c].b + ((cdist[c].b * i)) / maxstep;
            }
            SDL_SetColors(screen, colors, 0, ncolors);
            SDL_Delay(1);
        }
        final.r = 0x00;
        final.g = 0x00;
        final.b = 0x00;
        memcpy(palcolors, colors, ncolors * sizeof(SDL_Color));
        for (i = 0; i < ncolors; ++i) {
            cdist[i].r = final.r - palcolors[i].r;
            cdist[i].g = final.g - palcolors[i].g;
            cdist[i].b = final.b - palcolors[i].b;
        }
        maxstep /= 2;
        for (i = 0; i <= maxstep; ++i) {        /* finish fade out */
            int c;
            for (c = 0; c < ncolors; ++c) {
                colors[c].r = palcolors[c].r + ((cdist[c].r * i)) / maxstep;
                colors[c].g = palcolors[c].g + ((cdist[c].g * i)) / maxstep;
                colors[c].b = palcolors[c].b + ((cdist[c].b * i)) / maxstep;
            }
            SDL_SetColors(screen, colors, 0, ncolors);
            SDL_Delay(1);
        }
        for (i = 0; i < ncolors; ++i) {
            colors[i].r = final.r;
            colors[i].g = final.g;
            colors[i].b = final.b;
        }
        SDL_SetColors(screen, colors, 0, ncolors);
        NOTICE("testwin: fading in...\n");
        memcpy(palcolors, colors, ncolors * sizeof(SDL_Color));
        for (i = 0; i < ncolors; ++i) {
            cdist[i].r = cmap[i].r - palcolors[i].r;
            cdist[i].g = cmap[i].g - palcolors[i].g;
            cdist[i].b = cmap[i].b - palcolors[i].b;
        }
        for (i = 0; i <= maxstep; ++i) {        /* 32 step fade in */
            int c;
            for (c = 0; c < ncolors; ++c) {
                colors[c].r = palcolors[c].r + ((cdist[c].r * i)) / maxstep;
                colors[c].g = palcolors[c].g + ((cdist[c].g * i)) / maxstep;
                colors[c].b = palcolors[c].b + ((cdist[c].b * i)) / maxstep;
            }
            SDL_SetColors(screen, colors, 0, ncolors);
            SDL_Delay(1);
        }
        NOTICE("testwin: fading over\n");
    }

  done:
    /* Free the picture and return */
    SDL_FreeSurface(picture);
    free(colors);
    free(cmap);
    return;
}

int
main(int argc, char *argv[])
{
    SDL_Surface *screen;
    /* Options */
    int speedy, flip, nofade;
    int delay;
    int w, h;
    int desired_bpp;
    Uint32 video_flags;
#ifdef BENCHMARK_SDL
    Uint32 then, now;
#endif
    /* Set default options and check command-line */
    speedy = 0;
    flip = 0;
    nofade = 0;
    delay = 1;

#ifdef _WIN32_WCE
    w = 240;
    h = 320;
    desired_bpp = 8;
    video_flags = SDL_FULLSCREEN;
#else
    w = 640;
    h = 480;
    desired_bpp = 0;
    video_flags = 0;
#endif
    if (SDL_Init(SDL_INIT_VIDEO) < 0) {
        fprintf(stderr, "Couldn't initialize SDL: %s\n", SDL_GetError());
        return (1);
    }

    while (argc > 1) {
        if (strcmp(argv[1], "-speedy") == 0) {
            speedy = 1;
            argv += 1;
            argc -= 1;
        } else if (strcmp(argv[1], "-nofade") == 0) {
            nofade = 1;
            argv += 1;
            argc -= 1;
        } else if (strcmp(argv[1], "-delay") == 0) {
            if (argv[2]) {
                delay = atoi(argv[2]);
                argv += 2;
                argc -= 2;
            } else {
                fprintf(stderr, "The -delay option requires an argument\n");
                quit(1);
            }
        } else if (strcmp(argv[1], "-width") == 0) {
            if (argv[2] && ((w = atoi(argv[2])) > 0)) {
                argv += 2;
                argc -= 2;
            } else {
                fprintf(stderr, "The -width option requires an argument\n");
                quit(1);
            }
        } else if (strcmp(argv[1], "-height") == 0) {
            if (argv[2] && ((h = atoi(argv[2])) > 0)) {
                argv += 2;
                argc -= 2;
            } else {
                fprintf(stderr, "The -height option requires an argument\n");
                quit(1);
            }
        } else if (strcmp(argv[1], "-bpp") == 0) {
            if (argv[2]) {
                desired_bpp = atoi(argv[2]);
                argv += 2;
                argc -= 2;
            } else {
                fprintf(stderr, "The -bpp option requires an argument\n");
                quit(1);
            }
        } else if (strcmp(argv[1], "-warp") == 0) {
            video_flags |= SDL_HWPALETTE;
            argv += 1;
            argc -= 1;
        } else if (strcmp(argv[1], "-hw") == 0) {
        	video_flags |= SDL_HWSURFACE;
            argv += 1;
            argc -= 1;
        } else if (strcmp(argv[1], "-resizable" ) == 0 ) {
        	video_flags |= SDL_RESIZABLE;
        	argv += 1;
        	argc -= 1;
        } else if (strcmp(argv[1], "-flip") == 0) {
            video_flags |= SDL_DOUBLEBUF;
            argv += 1;
            argc -= 1;
        } else if (strcmp(argv[1], "-fullscreen") == 0) {
            video_flags |= SDL_FULLSCREEN;
            argv += 1;
            argc -= 1;
        } else
            break;
    }

    /* Initialize the display */
    screen = SDL_SetVideoMode(w, h, desired_bpp, video_flags);
    if (screen == NULL) {
        fprintf(stderr, "Couldn't set %dx%dx%d video mode: %s\n",
                w, h, desired_bpp, SDL_GetError());
        quit(1);
    }
    printf("Set%s %dx%dx%d mode\n",
           screen->flags & SDL_FULLSCREEN ? " fullscreen" : "",
           screen->w, screen->h, screen->format->BitsPerPixel);
    printf("(video surface located in %s memory)\n",
           (screen->flags & SDL_HWSURFACE) ? "video" : "system");
    if (screen->flags & SDL_DOUBLEBUF) {
        printf("Double-buffering enabled\n");
        flip = 1;
    }

    /* Set the window manager title bar */
    SDL_WM_SetCaption("SDL test window", "testwin");

    /* Do all the drawing work */
#ifdef BENCHMARK_SDL
    then = SDL_GetTicks();
    DrawPict(screen, argv[1], speedy, flip, nofade);
    now = SDL_GetTicks();
    printf("Time: %d milliseconds\n", now - then);
#else
    DrawPict(screen, argv[1], speedy, flip, nofade);
#endif
    SDL_Delay(delay * 1000);
    SDL_Quit();
    return (0);
}

Sorry for bugging you.
It works not with a metacity wm setup, but it works with other window managers.
So I set it to WORKSFORME.