l4/pkg/libsdl-image/contrib/IMG_UIImage.m

   1 /*
   2  *  IMG_ImageIO.c
   3  *  SDL_image
   4  *
   5  *  Created by Eric Wing on 1/2/09.
   6  *  Copyright 2009 __MyCompanyName__. All rights reserved.
   7  *
   8  */
   9 #include "SDL_image.h"
  10 #import <UIKit/UIKit.h>
  11 #import <MobileCoreServices/MobileCoreServices.h> // for UTCoreTypes.h
  12
  13 // Once we have our image, we need to get it into an SDL_Surface
  14 // (Copied straight from the ImageIO backend.)
  15 static SDL_Surface* Create_SDL_Surface_From_CGImage(CGImageRef image_ref)
  16 {
  17         /* This code is adapted from Apple's Documentation found here:
  18          * http://developer.apple.com/documentation/GraphicsImaging/Conceptual/OpenGL-MacProgGuide/index.html
  19          * Listing 9-4††Using a Quartz image as a texture source.
  20          * Unfortunately, this guide doesn't show what to do about
  21          * non-RGBA image formats so I'm making the rest up.
  22          * All this code should be scrutinized.
  23          */
  24
  25         size_t w = CGImageGetWidth(image_ref);
  26         size_t h = CGImageGetHeight(image_ref);
  27         CGRect rect = {{0, 0}, {w, h}};
  28
  29         CGImageAlphaInfo alpha = CGImageGetAlphaInfo(image_ref);
  30         //size_t bits_per_pixel = CGImageGetBitsPerPixel(image_ref);
  31         size_t bits_per_component = 8;
  32
  33         SDL_Surface* surface;
  34         Uint32 Amask;
  35         Uint32 Rmask;
  36         Uint32 Gmask;
  37         Uint32 Bmask;
  38
  39         CGContextRef bitmap_context;
  40         CGBitmapInfo bitmap_info;
  41         CGColorSpaceRef color_space = CGColorSpaceCreateDeviceRGB();
  42
  43         if (alpha == kCGImageAlphaNone ||
  44             alpha == kCGImageAlphaNoneSkipFirst ||
  45             alpha == kCGImageAlphaNoneSkipLast) {
  46                 bitmap_info = kCGImageAlphaNoneSkipFirst | kCGBitmapByteOrder32Host; /* XRGB */
  47                 Amask = 0x00000000;
  48         } else {
  49                 /* kCGImageAlphaFirst isn't supported */
  50                 //bitmap_info = kCGImageAlphaFirst | kCGBitmapByteOrder32Host; /* ARGB */
  51                 bitmap_info = kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host; /* ARGB */
  52                 Amask = 0xFF000000;
  53         }
  54
  55         Rmask = 0x00FF0000;
  56         Gmask = 0x0000FF00;
  57         Bmask = 0x000000FF;
  58
  59         surface = SDL_CreateRGBSurface(SDL_SWSURFACE, w, h, 32, Rmask, Gmask, Bmask, Amask);
  60         if (surface)
  61         {
  62                 // Sets up a context to be drawn to with surface->pixels as the area to be drawn to
  63                 bitmap_context = CGBitmapContextCreate(
  64                                                                                                                         surface->pixels,
  65                                                                                                                         surface->w,
  66                                                                                                                         surface->h,
  67                                                                                                                         bits_per_component,
  68                                                                                                                         surface->pitch,
  69                                                                                                                         color_space,
  70                                                                                                                         bitmap_info
  71                                                                                                                         );
  72
  73                 // Draws the image into the context's image_data
  74                 CGContextDrawImage(bitmap_context, rect, image_ref);
  75
  76                 CGContextRelease(bitmap_context);
  77
  78                 // FIXME: Reverse the premultiplied alpha
  79                 if ((bitmap_info & kCGBitmapAlphaInfoMask) == kCGImageAlphaPremultipliedFirst) {
  80                         int i, j;
  81                         Uint8 *p = (Uint8 *)surface->pixels;
  82                         for (i = surface->h * surface->pitch/4; i--; ) {
  83 #if __LITTLE_ENDIAN__
  84                                 Uint8 A = p[3];
  85                                 if (A) {
  86                                         for (j = 0; j < 3; ++j) {
  87                                                 p[j] = (p[j] * 255) / A;
  88                                         }
  89                                 }
  90 #else
  91                                 Uint8 A = p[0];
  92                                 if (A) {
  93                                         for (j = 1; j < 4; ++j) {
  94                                                 p[j] = (p[j] * 255) / A;
  95                                         }
  96                                 }
  97 #endif /* ENDIAN */
  98                                 p += 4;
  99                         }
 100                 }
 101         }
 102
 103         if (color_space)
 104         {
 105                 CGColorSpaceRelease(color_space);
 106         }
 107
 108         return surface;
 109 }
 110
 111 static SDL_Surface* LoadImageFromRWops(SDL_RWops* rw_ops, CFStringRef uti_string_hint)
 112 {
 113         NSAutoreleasePool* autorelease_pool = [[NSAutoreleasePool alloc] init];
 114         SDL_Surface* sdl_surface;
 115         UIImage* ui_image;
 116
 117         int bytes_read = 0;
 118         // I don't know what a good size is.
 119         // Max recommended texture size is 1024x1024 on iPhone so maybe base it on that?
 120         const int block_size = 1024*4;
 121         char temp_buffer[block_size];
 122
 123         NSMutableData* ns_data = [[NSMutableData alloc] initWithCapacity:1024*1024*4];
 124
 125
 126         do
 127         {
 128                 bytes_read = SDL_RWread(rw_ops, temp_buffer, 1, block_size);
 129                 [ns_data appendBytes:temp_buffer length:bytes_read];
 130         } while(bytes_read > 0);
 131
 132         ui_image = [[UIImage alloc] initWithData:ns_data];
 133
 134         sdl_surface = Create_SDL_Surface_From_CGImage([ui_image CGImage]);
 135
 136         [ui_image release];
 137         [ns_data release];
 138
 139         [autorelease_pool drain];
 140
 141         return sdl_surface;
 142 }
 143
 144 static SDL_Surface* LoadImageFromFile(const char *file)
 145 {
 146         NSAutoreleasePool* autorelease_pool = [[NSAutoreleasePool alloc] init];
 147         SDL_Surface* sdl_surface = NULL;
 148         UIImage* ui_image;
 149         NSString* ns_string;
 150
 151         ns_string = [[NSString alloc] initWithUTF8String:file];
 152         ui_image = [[UIImage alloc] initWithContentsOfFile:ns_string];
 153         if(ui_image != NULL)
 154         {
 155                 sdl_surface = Create_SDL_Surface_From_CGImage([ui_image CGImage]);
 156         }
 157
 158         [ui_image release];
 159         [ns_string release];
 160
 161         [autorelease_pool drain];
 162
 163         return sdl_surface;
 164 }
 165
 166
 167 /* Since UIImage doesn't really support streams well, we should optimize for the file case. */
 168 SDL_Surface *IMG_Load(const char *file)
 169 {
 170         SDL_Surface* sdl_surface = NULL;
 171
 172         sdl_surface = LoadImageFromFile(file);
 173         if(NULL == sdl_surface)
 174         {
 175                 // Either the file doesn't exist or ImageIO doesn't understand the format.
 176                 // For the latter case, fallback to the native SDL_image handlers.
 177
 178                 SDL_RWops *src = SDL_RWFromFile(file, "rb");
 179                 char *ext = strrchr(file, '.');
 180                 if(ext) {
 181                         ext++;
 182                 }
 183                 if(!src) {
 184                         /* The error message has been set in SDL_RWFromFile */
 185                         return NULL;
 186                 }
 187                 sdl_surface = IMG_LoadTyped_RW(src, 1, ext);
 188         }
 189         return sdl_surface;
 190 }
 191
 192
 193 int IMG_InitJPG()
 194 {
 195         return 0;
 196 }
 197
 198 void IMG_QuitJPG()
 199 {
 200 }
 201
 202 int IMG_InitPNG()
 203 {
 204         return 0;
 205 }
 206
 207 void IMG_QuitPNG()
 208 {
 209 }
 210
 211 int IMG_InitTIF()
 212 {
 213         return 0;
 214 }
 215
 216 void IMG_QuitTIF()
 217 {
 218 }
 219
 220 /* Copied straight from other files so I don't have to alter them. */
 221 static int IMG_isICOCUR(SDL_RWops *src, int type)
 222 {
 223         int start;
 224         int is_ICOCUR;
 225
 226         /* The Win32 ICO file header (14 bytes) */
 227     Uint16 bfReserved;
 228     Uint16 bfType;
 229     Uint16 bfCount;
 230
 231         if ( !src )
 232                 return 0;
 233         start = SDL_RWtell(src);
 234         is_ICOCUR = 0;
 235     bfReserved = SDL_ReadLE16(src);
 236     bfType = SDL_ReadLE16(src);
 237     bfCount = SDL_ReadLE16(src);
 238     if ((bfReserved == 0) && (bfType == type) && (bfCount != 0))
 239         is_ICOCUR = 1;
 240         SDL_RWseek(src, start, SEEK_SET);
 241
 242         return (is_ICOCUR);
 243 }
 244
 245 int IMG_isICO(SDL_RWops *src)
 246 {
 247         return IMG_isICOCUR(src, 1);
 248 }
 249
 250 int IMG_isCUR(SDL_RWops *src)
 251 {
 252         return IMG_isICOCUR(src, 2);
 253 }
 254
 255 int IMG_isBMP(SDL_RWops *src)
 256 {
 257         int start;
 258         int is_BMP;
 259         char magic[2];
 260
 261         if ( !src )
 262                 return 0;
 263         start = SDL_RWtell(src);
 264         is_BMP = 0;
 265         if ( SDL_RWread(src, magic, sizeof(magic), 1) ) {
 266                 if ( strncmp(magic, "BM", 2) == 0 ) {
 267                         is_BMP = 1;
 268                 }
 269         }
 270         SDL_RWseek(src, start, SEEK_SET);
 271         return(is_BMP);
 272 }
 273
 274 int IMG_isGIF(SDL_RWops *src)
 275 {
 276         int start;
 277         int is_GIF;
 278         char magic[6];
 279
 280         if ( !src )
 281                 return 0;
 282         start = SDL_RWtell(src);
 283         is_GIF = 0;
 284         if ( SDL_RWread(src, magic, sizeof(magic), 1) ) {
 285                 if ( (strncmp(magic, "GIF", 3) == 0) &&
 286                         ((memcmp(magic + 3, "87a", 3) == 0) ||
 287                          (memcmp(magic + 3, "89a", 3) == 0)) ) {
 288                         is_GIF = 1;
 289                 }
 290         }
 291         SDL_RWseek(src, start, SEEK_SET);
 292         return(is_GIF);
 293 }
 294
 295 int IMG_isJPG(SDL_RWops *src)
 296 {
 297         int start;
 298         int is_JPG;
 299         int in_scan;
 300         Uint8 magic[4];
 301
 302         /* This detection code is by Steaphan Greene <stea@cs.binghamton.edu> */
 303         /* Blame me, not Sam, if this doesn't work right. */
 304         /* And don't forget to report the problem to the the sdl list too! */
 305
 306         if ( !src )
 307                 return 0;
 308         start = SDL_RWtell(src);
 309         is_JPG = 0;
 310         in_scan = 0;
 311         if ( SDL_RWread(src, magic, 2, 1) ) {
 312                 if ( (magic[0] == 0xFF) && (magic[1] == 0xD8) ) {
 313                         is_JPG = 1;
 314                         while (is_JPG == 1) {
 315                                 if(SDL_RWread(src, magic, 1, 2) != 2) {
 316                                         is_JPG = 0;
 317                                 } else if( (magic[0] != 0xFF) && (in_scan == 0) ) {
 318                                         is_JPG = 0;
 319                                 } else if( (magic[0] != 0xFF) || (magic[1] == 0xFF) ) {
 320                                         /* Extra padding in JPEG (legal) */
 321                                         /* or this is data and we are scanning */
 322                                         SDL_RWseek(src, -1, SEEK_CUR);
 323                                 } else if(magic[1] == 0xD9) {
 324                                         /* Got to end of good JPEG */
 325                                         break;
 326                                 } else if( (in_scan == 1) && (magic[1] == 0x00) ) {
 327                                         /* This is an encoded 0xFF within the data */
 328                                 } else if( (magic[1] >= 0xD0) && (magic[1] < 0xD9) ) {
 329                                         /* These have nothing else */
 330                                 } else if(SDL_RWread(src, magic+2, 1, 2) != 2) {
 331                                         is_JPG = 0;
 332                                 } else {
 333                                         /* Yes, it's big-endian */
 334                                         Uint32 start;
 335                                         Uint32 size;
 336                                         Uint32 end;
 337                                         start = SDL_RWtell(src);
 338                                         size = (magic[2] << 8) + magic[3];
 339                                         end = SDL_RWseek(src, size-2, SEEK_CUR);
 340                                         if ( end != start + size - 2 ) is_JPG = 0;
 341                                         if ( magic[1] == 0xDA ) {
 342                                                 /* Now comes the actual JPEG meat */
 343 #ifdef  FAST_IS_JPEG
 344                                                 /* Ok, I'm convinced.  It is a JPEG. */
 345                                                 break;
 346 #else
 347                                                 /* I'm not convinced.  Prove it! */
 348                                                 in_scan = 1;
 349 #endif
 350                                         }
 351                                 }
 352                         }
 353                 }
 354         }
 355         SDL_RWseek(src, start, SEEK_SET);
 356         return(is_JPG);
 357 }
 358
 359 int IMG_isPNG(SDL_RWops *src)
 360 {
 361         int start;
 362         int is_PNG;
 363         Uint8 magic[4];
 364
 365         if ( !src )
 366                 return 0;
 367         start = SDL_RWtell(src);
 368         is_PNG = 0;
 369         if ( SDL_RWread(src, magic, 1, sizeof(magic)) == sizeof(magic) ) {
 370                 if ( magic[0] == 0x89 &&
 371                         magic[1] == 'P' &&
 372                         magic[2] == 'N' &&
 373                         magic[3] == 'G' ) {
 374                         is_PNG = 1;
 375                 }
 376         }
 377         SDL_RWseek(src, start, SEEK_SET);
 378         return(is_PNG);
 379 }
 380
 381 int IMG_isTIF(SDL_RWops* src)
 382 {
 383         int start;
 384         int is_TIF;
 385         Uint8 magic[4];
 386
 387         if ( !src )
 388                 return 0;
 389         start = SDL_RWtell(src);
 390         is_TIF = 0;
 391         if ( SDL_RWread(src, magic, 1, sizeof(magic)) == sizeof(magic) ) {
 392                 if ( (magic[0] == 'I' &&
 393                           magic[1] == 'I' &&
 394                       magic[2] == 0x2a &&
 395                           magic[3] == 0x00) ||
 396                         (magic[0] == 'M' &&
 397                          magic[1] == 'M' &&
 398                          magic[2] == 0x00 &&
 399                          magic[3] == 0x2a) ) {
 400                         is_TIF = 1;
 401                 }
 402         }
 403         SDL_RWseek(src, start, SEEK_SET);
 404         return(is_TIF);
 405 }
 406
 407 SDL_Surface* IMG_LoadCUR_RW(SDL_RWops *src)
 408 {
 409         /* FIXME: Is this a supported type? */
 410         return LoadImageFromRWops(src, CFSTR("com.microsoft.cur"));
 411 }
 412 SDL_Surface* IMG_LoadICO_RW(SDL_RWops *src)
 413 {
 414         return LoadImageFromRWops(src, kUTTypeICO);
 415 }
 416 SDL_Surface* IMG_LoadBMP_RW(SDL_RWops *src)
 417 {
 418         return LoadImageFromRWops(src, kUTTypeBMP);
 419 }
 420 SDL_Surface* IMG_LoadGIF_RW(SDL_RWops *src)
 421 {
 422         return LoadImageFromRWops(src, kUTTypeGIF);
 423 }
 424 SDL_Surface* IMG_LoadJPG_RW(SDL_RWops *src)
 425 {
 426         return LoadImageFromRWops(src, kUTTypeJPEG);
 427 }
 428 SDL_Surface* IMG_LoadPNG_RW(SDL_RWops *src)
 429 {
 430         return LoadImageFromRWops(src, kUTTypePNG);
 431 }
 432 SDL_Surface* IMG_LoadTGA_RW(SDL_RWops *src)
 433 {
 434         return LoadImageFromRWops(src, CFSTR("com.truevision.tga-image"));
 435 }
 436 SDL_Surface* IMG_LoadTIF_RW(SDL_RWops *src)
 437 {
 438         return LoadImageFromRWops(src, kUTTypeTIFF);
 439 }
 440