title: IMG_Load returns SDL_image error "unsupported image format"
body: <p>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.</p>
  
  <p>I am working on a Linux machine, compiling with g++</p>
  
  <p>Here are my libraries...</p>
  
  <pre><code>#include &lt;SDL2/SDL.h&gt;
  #include &lt;SDL/SDL_image.h&gt;
  #include &lt;stdio.h&gt;
  #include &lt;string&gt;
  #include &lt;zlib.h&gt;
  #include &lt;png.h&gt;
  </code></pre>
  
  <p>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. </p>
  
  <p>Here is my code, the error occurs in the loadSurface function(I believe).</p>
  
  <pre><code>//Using SDL, SDL_image, standard IO, and strings
  #include &lt;SDL2/SDL.h&gt;
  //#include &lt;SDL/SDL_version.h&gt;
  #include &lt;SDL/SDL_image.h&gt;
  #include &lt;stdio.h&gt;
  #include &lt;string&gt;
  #include &lt;zlib.h&gt;
  #include &lt;png.h&gt;
  
  //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 ) &lt; 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 ) &amp; 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-&gt;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( &amp;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;
  }
  </code></pre>
  
  <p>When I compile, I use g++, compiler flags -w, and linker flags -lSDL2 -lSDL_image</p>
  
  <p>When I run, the output is as shows...</p>
  
  <p>1Unable to load image loaded.png! SDL_image Error: Unsupported image format</p>
  
  <p>Failed to load PNG image!</p>
  
  <p>Failed to load media!</p>