Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.     IMGLIB:  An example image loading library for use with SDL
  3.     Copyright (C) 1999  Sam Lantinga
  4.  
  5.     This library is free software; you can redistribute it and/or
  6.     modify it under the terms of the GNU Library General Public
  7.     License as published by the Free Software Foundation; either
  8.     version 2 of the License, or (at your option) any later version.
  9.  
  10.     This library is distributed in the hope that it will be useful,
  11.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13.     Library General Public License for more details.
  14.  
  15.     You should have received a copy of the GNU Library General Public
  16.     License along with this library; if not, write to the Free
  17.     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18.  
  19.     Sam Lantinga
  20.     5635-34 Springhouse Dr.
  21.     Pleasanton, CA 94588 (USA)
  22.     slouken@devolution.com
  23. */
  24.  
  25. /* A simple library to load images of various formats as SDL surfaces */
  26.  
  27. #include <stdio.h>
  28. #include <string.h>
  29. #include <ctype.h>
  30.  
  31. #include "SDL_image.h"
  32.  
  33. #define ARRAYSIZE(a) (sizeof(a) / sizeof((a)[0]))
  34.  
  35. /* Table of image detection and loading functions */
  36. static struct {
  37.         char *type;
  38.         int (*is)(SDL_RWops *src);
  39.         SDL_Surface *(*load)(SDL_RWops *src);
  40. } supported[] = {
  41.         /* keep magicless formats first */
  42.         { "TGA", 0,         IMG_LoadTGA_RW },
  43.         { "BMP", IMG_isBMP, IMG_LoadBMP_RW },
  44.         { "PNM", IMG_isPNM, IMG_LoadPNM_RW }, /* P[BGP]M share code */
  45.         { "XPM", IMG_isXPM, IMG_LoadXPM_RW },
  46.         { "XCF", IMG_isXCF, IMG_LoadXCF_RW },
  47.         { "PCX", IMG_isPCX, IMG_LoadPCX_RW },
  48.         { "GIF", IMG_isGIF, IMG_LoadGIF_RW },
  49.         { "JPG", IMG_isJPG, IMG_LoadJPG_RW },
  50.         { "TIF", IMG_isTIF, IMG_LoadTIF_RW },
  51.         { "PNG", IMG_isPNG, IMG_LoadPNG_RW }
  52. };
  53.  
  54. /* Load an image from a file */
  55. SDL_Surface *IMG_Load(const char *file)
  56. {
  57.     SDL_RWops *src = SDL_RWFromFile(file, "rb");
  58.     char *ext = strrchr(file, '.');
  59.     if(ext)
  60.         ext++;
  61.     return IMG_LoadTyped_RW(src, 1, ext);
  62. }
  63.  
  64. /* Load an image from an SDL datasource (for compatibility) */
  65. SDL_Surface *IMG_Load_RW(SDL_RWops *src, int freesrc)
  66. {
  67.     return IMG_LoadTyped_RW(src, freesrc, NULL);
  68. }
  69.  
  70. /* Portable case-insensitive string compare function */
  71. int IMG_string_equals(const char *str1, const char *str2)
  72. {
  73.         while ( *str1 && *str2 ) {
  74.                 if ( toupper((unsigned char)*str1) !=
  75.                      toupper((unsigned char)*str2) )
  76.                         break;
  77.                 ++str1;
  78.                 ++str2;
  79.         }
  80.         return (!*str1 && !*str2);
  81. }
  82.  
  83. /* Load an image from an SDL datasource, optionally specifying the type */
  84. SDL_Surface *IMG_LoadTyped_RW(SDL_RWops *src, int freesrc, char *type)
  85. {
  86.         int i, start;
  87.         SDL_Surface *image;
  88.  
  89.         /* Make sure there is something to do.. */
  90.         if ( src == NULL ) {
  91.                 return(NULL);
  92.         }
  93.  
  94.         /* See whether or not this data source can handle seeking */
  95.         if ( SDL_RWseek(src, 0, SEEK_CUR) < 0 ) {
  96.                 IMG_SetError("Can't seek in this data source");
  97.                 return(NULL);
  98.         }
  99.  
  100.         /* Detect the type of image being loaded */
  101.         start = SDL_RWtell(src);
  102.         image = NULL;
  103.         for ( i=0; i < ARRAYSIZE(supported); ++i ) {
  104.                 if( (supported[i].is
  105.                      && (SDL_RWseek(src, start, SEEK_SET),
  106.                          supported[i].is(src)))
  107.                     || (type && IMG_string_equals(type, supported[i].type))) {
  108. #ifdef DEBUG_IMGLIB
  109.                         SDL_printf("IMGLIB: Loading image as %s\n",
  110.                                                         supported[i].type);
  111. #endif
  112.                         SDL_RWseek(src, start, SEEK_SET);
  113.                         image = supported[i].load(src);
  114.                         break;
  115.                 }
  116.         }
  117.  
  118.         /* Clean up, check for errors, and return */
  119.         if ( freesrc ) {
  120.                 SDL_RWclose(src);
  121.         }
  122.         if ( i == ARRAYSIZE(supported) ) {
  123.                 IMG_SetError("Unsupported image format");
  124.         }
  125.         return(image);
  126. }
  127.  
  128. /* Invert the alpha of a surface for use with OpenGL
  129.    This function is a no-op and only kept for backwards compatibility.
  130.  */
  131. int IMG_InvertAlpha(int on)
  132. {
  133.     return 1;
  134. }
  135.