Patrick
Patrick

Reputation: 53

IMG_Load returns SDL_image error "unsupported image format"

When I attempt to load a png file, the error "unsupported image format" is returned. People have previously posted about this topic on StackOverflow, but none of the solutions have seemed to work for me.

I am working on a Linux machine, compiling with g++

Here are my libraries...

#include <SDL2/SDL.h>
#include <SDL/SDL_image.h>
#include <stdio.h>
#include <string>
#include <zlib.h>
#include <png.h>

And when I compile I include the -lSDL2 and -lSDL_image flags. I do not use SDL2/SDL_image.h because it is not installed on the machines I am working on. Additionally, my png file is definitely in the same directory as my code that tries to load it and I do call IMG_Init(IMG_INIT_PNG) and IMG_INIT_PNG.

Here is my code, the error occurs in the loadSurface function(I believe).

//Using SDL, SDL_image, standard IO, and strings
#include <SDL2/SDL.h>
//#include <SDL/SDL_version.h>
#include <SDL/SDL_image.h>
#include <stdio.h>
#include <string>
#include <zlib.h>
#include <png.h>

//Screen dimension constants
const int SCREEN_WIDTH = 640;
const int SCREEN_HEIGHT = 480;

//Starts up SDL and creates window
bool init();

//Loads media
bool loadMedia();

//Frees media and shuts down SDL
void close();

//Loads individual image
SDL_Surface* loadSurface( std::string path );

//The window we'll be rendering to
SDL_Window* gWindow = NULL;

//The surface contained by the window
SDL_Surface* gScreenSurface = NULL;

//Current displayed PNG image
SDL_Surface* gPNGSurface = NULL;

bool init()
{
        //Initialization flag
 bool success = true;

        //Initialize SDL
        if( SDL_Init( SDL_INIT_VIDEO ) < 0 )
        {
                printf( "SDL could not initialize! SDL Error: %s\n", SDL_GetError() );
                success = false;
        }
        else
        {
                //Create window
                gWindow = SDL_CreateWindow( "SDL Tutorial", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN );
                if( gWindow == NULL )
                {
                        printf( "Window could not be created! SDL Error: %s\n", SDL_GetError() );
                        success = false;
                }
                else
                {
                        //Initialize PNG loading
                        int imgFlags = IMG_INIT_PNG;
                      if( !( IMG_Init( imgFlags ) & imgFlags ) )
                      {
                              printf( "SDL_image could not initialize! SDL_image Error: %s\n", IMG_GetError() );
                              success = false;
                      }
                      else
                        {
                                //Get window surface
                                gScreenSurface = SDL_GetWindowSurface( gWindow );
                        }
                }
        }

        return success;
}

bool loadMedia()
{
        //Loading success flag
        bool success = true;

        //Load PNG surface
        gPNGSurface = loadSurface( "loaded.png" );
        if( gPNGSurface == NULL )
        {
                printf( "Failed to load PNG image!\n" );
                success = false;
        }

        return success;
}

void close()
{
        //Free loaded image
        SDL_FreeSurface( gPNGSurface );
        gPNGSurface = NULL;

        //Destroy window
        SDL_DestroyWindow( gWindow );
        gWindow = NULL;

        //Quit SDL subsystems
        IMG_Quit();
        SDL_Quit();
}

SDL_Surface* loadSurface( std::string path )
{
        //The final optimized image
        SDL_Surface* optimizedSurface = NULL;
 //Load image at specified path
        SDL_Surface* loadedSurface = IMG_Load( path.c_str() );
        if( loadedSurface == NULL )
        {
                printf( "1Unable to load image %s! SDL_image Error: %s\n", path.c_str(), IMG_GetError() );
        }
        else
        {
                //Convert surface to screen format
                optimizedSurface = SDL_ConvertSurface( loadedSurface, gScreenSurface->format, NULL );
                if( optimizedSurface == NULL )
                {
                        printf( "2Unable to optimize image %s! SDL Error: %s\n", path.c_str(), SDL_GetError() );
                }

                //Get rid of old loaded surface
                SDL_FreeSurface( loadedSurface );
        }

        return optimizedSurface;
}

int main( int argc, char* args[] )
{
        //Start up SDL and create window
        if( !init() )
        {
                printf( "Failed to initialize!\n" );
        }
        else
        {
                //Load media
                if( !loadMedia() )
                {
                        printf( "Failed to load media!\n" );
                }
                else
                {
                       //Main loop flag
                        bool quit = false;

                        //Event handler
                        SDL_Event e;

                        //While application is running
                        while( !quit )
                        {
                                //Handle events on queue
                                while( SDL_PollEvent( &e ) != 0 )
                                {
                                        //User requests quit
                                        if( e.type == SDL_QUIT )
                                        {
                                                quit = true;
                                        }
                                }

                                //Apply the PNG image
                                SDL_BlitSurface( gPNGSurface, NULL, gScreenSurface, NULL );

                                //Update the surface
                                SDL_UpdateWindowSurface( gWindow );
                        }
                }
        }

        //Free resources and close SDL
        close();

        return 0;
}

When I compile, I use g++, compiler flags -w, and linker flags -lSDL2 -lSDL_image

When I run, the output is as shows...

1Unable to load image loaded.png! SDL_image Error: Unsupported image format

Failed to load PNG image!

Failed to load media!

Upvotes: 5

Views: 5604

Answers (2)

Andrew Chandradat
Andrew Chandradat

Reputation: 61

The compiler flag -lSDL_image should be -lSDL2_image

Upvotes: 6

MatthewRock
MatthewRock

Reputation: 1091

First of all, there are few steps when you're compiling your code. Compilation, linking, and execution. If your program gets past first two steps, it's ready to work - to be executed. If it passed first two steps, you know that there are no syntax errors or linking errors(e.g. you passed proper flags to linker). However, if you receive error on runtime(which is exactly what happened), something is wrong with environment or program logic.

This said, you didn't provide any code at all, so that's hard to help you. I'm not sure if you know how to load image at all - you seem to include lots of unnecessary libs for this operations. I'd recommend you reading this tutorial to learn how to load images with SDL. Probably something is wrong with code(flags, maybe?), but you might as well compiled the code by yourself and be missing some dependencies.

Upvotes: 0

Related Questions