source/blender/imbuf/intern/readimage.c

   1 /**
   2  *
   3  * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; either version 2
   8  * of the License, or (at your option) any later version. The Blender
   9  * Foundation also sells licenses for use in proprietary software under
  10  * the Blender License.  See http://www.blender.org/BL/ for information
  11  * about this.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software Foundation,
  20  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  21  *
  22  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  23  * All rights reserved.
  24  *
  25  * The Original Code is: all of this file.
  26  *
  27  * Contributor(s): none yet.
  28  *
  29  * ***** END GPL/BL DUAL LICENSE BLOCK *****
  30  * allocimbuf.c
  31  *
  32  * $Id$
  33  */
  34
  35 #ifdef WIN32
  36 #include <io.h>
  37 #endif
  38
  39 #include "BLI_blenlib.h"
  40
  41 #include "imbuf.h"
  42 #include "imbuf_patch.h"
  43 #include "IMB_imbuf_types.h"
  44 #include "IMB_imbuf.h"
  45
  46 #include "IMB_amiga.h"
  47 #include "IMB_iris.h"
  48 #include "IMB_targa.h"
  49 #include "IMB_png.h"
  50 #include "IMB_hamx.h"
  51 #include "IMB_jpeg.h"
  52 #include "IMB_bmp.h"
  53 #include "BKE_global.h"
  54
  55 #ifdef WITH_QUICKTIME
  56 #if defined(_WIN32) || defined (__APPLE__)
  57 #include "quicktime_import.h"
  58 #elif defined (__linux__)
  59 #include "quicktime_import_linux.h"
  60 #endif
  61 #endif
  62 #ifdef WITH_FREEIMAGE
  63 #include "IMB_freeimage.h"
  64 #endif
  65
  66 /* actually hard coded endianness */
  67 #define GET_BIG_LONG(x) (((uchar *) (x))[0] << 24 | ((uchar *) (x))[1] << 16 | ((uchar *) (x))[2] << 8 | ((uchar *) (x))[3])
  68 #define GET_LITTLE_LONG(x) (((uchar *) (x))[3] << 24 | ((uchar *) (x))[2] << 16 | ((uchar *) (x))[1] << 8 | ((uchar *) (x))[0])
  69 #define SWAP_L(x) (((x << 24) & 0xff000000) | ((x << 8) & 0xff0000) | ((x >> 8) & 0xff00) | ((x >> 24) & 0xff))
  70 #define SWAP_S(x) (((x << 8) & 0xff00) | ((x >> 8) & 0xff))
  71
  72 /* more endianness... should move to a separate file... */
  73 #if defined(__sgi) || defined (__sparc) || defined (__sparc__) || defined (__PPC__) || defined (__ppc__) || defined (__BIG_ENDIAN__)
  74 #define GET_ID GET_BIG_LONG
  75 #define LITTLE_LONG SWAP_LONG
  76 #else
  77 #define GET_ID GET_LITTLE_LONG
  78 #define LITTLE_LONG ENDIAN_NOP
  79 #endif
  80
  81 /* from misc_util: flip the bytes from x  */
  82 #define GS(x) (((unsigned char *)(x))[0] << 8 | ((unsigned char *)(x))[1])
  83
  84 /* this one is only def-ed once, strangely... */
  85 #define GSS(x) (((uchar *)(x))[1] << 8 | ((uchar *)(x))[0])
  86
  87 int IB_verbose = TRUE;
  88
  89 ImBuf *IMB_ibImageFromMemory(int *mem, int size, int flags) {
  90         int len;
  91         struct ImBuf *ibuf;
  92
  93         if (mem == NULL) {
  94                 printf("Error in ibImageFromMemory: NULL pointer\n");
  95         } else {
  96                 if ((GS(mem) == IMAGIC) || (GSS(mem) == IMAGIC)){
  97                         return (imb_loadiris((uchar *) mem, flags));
  98                 } else if ((BIG_LONG(mem[0]) & 0xfffffff0) == 0xffd8ffe0) {
  99                         return (imb_ibJpegImageFromMemory((uchar *)mem, size, flags));
 100                 }
 101
 102                 if (GET_ID(mem) == CAT){
 103                         mem += 3;
 104                         size -= 4;
 105                         while (size > 0){
 106                                 if (GET_ID(mem) == FORM){
 107                                         len = ((GET_BIG_LONG(mem+1) + 1) & ~1) + 8;
 108                                         if ((GET_ID(mem+2) == ILBM) || (GET_ID(mem+2) == ANIM)) break;
 109                                         mem = (int *)((uchar *)mem +len);
 110                                         size -= len;
 111                                 } else return(0);
 112                         }
 113                 }
 114
 115                 if (size > 0){
 116                         if (GET_ID(mem) == FORM){
 117                                 if (GET_ID(mem+2) == ILBM){
 118                                         return (imb_loadamiga(mem, flags));
 119                                 } else if (GET_ID(mem+5) == ILBM){                      /* animaties */
 120                                         return (imb_loadamiga(mem+3, flags));
 121                                 } else if (GET_ID(mem+2) == ANIM){
 122                                         return (imb_loadanim(mem, flags));
 123                                 }
 124                         }
 125                 }
 126
 127                 /* let quicktime handle png's, skips error messages ;)
 128                  * but only on windows
 129                  */
 130 #ifdef _WIN32
 131                 if(G.have_quicktime == FALSE) {
 132 #else
 133                 if(1) {
 134 #endif
 135                         ibuf = imb_loadpng((uchar *)mem, size, flags);
 136                         if (ibuf) return(ibuf);
 137                 }
 138
 139                 ibuf = imb_bmp_decode((uchar *)mem, size, flags);
 140                 if (ibuf) return(ibuf);
 141
 142                 ibuf = imb_loadtarga((uchar *)mem, flags);
 143                 if (ibuf) return(ibuf);
 144
 145 #ifdef WITH_QUICKTIME
 146 #if defined(_WIN32) || defined (__APPLE__)
 147                 if(G.have_quicktime) {
 148                         ibuf = imb_quicktime_decode((uchar *)mem, size, flags);
 149                         if (ibuf) return(ibuf);
 150                 }
 151 #endif
 152 #endif
 153 #ifdef WITH_FREEIMAGE
 154                 ibuf = imb_freeimage_decode((uchar *)mem, size, flags);
 155                 if (ibuf) return(ibuf);
 156 #endif
 157 #ifdef WITH_IMAGEMAGICK
 158                 ibuf = imb_imagick_decode((uchar *)mem, size, flags);
 159                 if (ibuf) return(ibuf);
 160 #endif
 161
 162                 if (IB_verbose) fprintf(stderr, "Unknown fileformat\n");
 163         }
 164
 165         return (0);
 166 }
 167
 168
 169 struct ImBuf *IMB_loadiffmem(int *mem, int flags) {
 170         int len,maxlen;
 171         struct ImBuf *ibuf;
 172
 173         // IMB_loadiffmem shouldn't be used anymore in new development
 174         // it's still here to be backwards compatible...
 175
 176         maxlen= (GET_BIG_LONG(mem+1) + 1) & ~1;
 177
 178         if (GET_ID(mem) == CAT){
 179                 mem += 3;
 180                 maxlen -= 4;
 181                 while(maxlen > 0){
 182                         if (GET_ID(mem) == FORM){
 183                                 len = ((GET_BIG_LONG(mem+1) + 1) & ~1) + 8;
 184                                 if ((GET_ID(mem+2) == ILBM) || (GET_ID(mem+2) == ANIM)) break;
 185                                 mem = (int *)((uchar *)mem +len);
 186                                 maxlen -= len;
 187                         } else return(0);
 188                 }
 189         }
 190
 191         if (maxlen > 0){
 192                 if (GET_ID(mem) == FORM){
 193                         if (GET_ID(mem+2) == ILBM){
 194                                 return (imb_loadamiga(mem, flags));
 195                         } else if (GET_ID(mem+5) == ILBM){                      /* animaties */
 196                                 return (imb_loadamiga(mem+3, flags));
 197                         } else if (GET_ID(mem+2) == ANIM){
 198                                 return (imb_loadanim(mem, flags));
 199                         }
 200                 } else if ((GS(mem) == IMAGIC) || (GSS(mem) == IMAGIC)){
 201                         return (imb_loadiris((uchar *) mem,flags));
 202                 } else if ((BIG_LONG(mem[0]) & 0xfffffff0) == 0xffd8ffe0) {
 203                         return (0);
 204                 }
 205         }
 206
 207         ibuf = imb_loadtarga((uchar *) mem,flags);
 208         if (ibuf) return(ibuf);
 209
 210         if (IB_verbose) fprintf(stderr,"Unknown fileformat\n");
 211         return (0);
 212 }
 213
 214 struct ImBuf *IMB_loadifffile(int file, int flags) {
 215         struct ImBuf *ibuf;
 216         int size, *mem;
 217
 218         if (file == -1) return (0);
 219
 220         size = BLI_filesize(file);
 221
 222 #if defined(AMIGA) || defined(__BeOS) || defined(WIN32)
 223         mem= (int *)malloc(size);
 224         if (mem==0) {
 225                 printf("Out of mem\n");
 226                 return (0);
 227         }
 228
 229         if (read(file, mem, size)!=size){
 230                 printf("Read Error\n");
 231                 free(mem);
 232                 return (0);
 233         }
 234
 235         ibuf = IMB_ibImageFromMemory(mem, size, flags);
 236         free(mem);
 237
 238         /* for jpeg read */
 239         lseek(file, 0L, SEEK_SET);
 240
 241 #else
 242         mem= (int *)mmap(0,size,PROT_READ,MAP_SHARED,file,0);
 243         if (mem==(int *)-1){
 244                 printf("Couldn't get mapping\n");
 245                 return (0);
 246         }
 247
 248         ibuf = IMB_ibImageFromMemory(mem, size, flags);
 249
 250         if (munmap( (void *) mem, size)){
 251                 printf("Couldn't unmap file.\n");
 252         }
 253 #endif
 254         return(ibuf);
 255 }
 256
 257
 258 struct ImBuf *IMB_loadiffname(char *naam, int flags) {
 259         int file;
 260         struct ImBuf *ibuf;
 261         int buf[1];
 262
 263         file = open(naam, O_BINARY|O_RDONLY);
 264
 265         if (file == -1) return (0);
 266
 267         ibuf= IMB_loadifffile(file, flags);
 268
 269         if (ibuf == 0) {
 270                 if (read(file, buf, 4) != 4) buf[0] = 0;
 271                 if ((BIG_LONG(buf[0]) & 0xfffffff0) == 0xffd8ffe0)
 272                         ibuf = imb_ibJpegImageFromFilename(naam, flags);
 273         }
 274
 275         if (ibuf) {
 276                 strncpy(ibuf->name, naam, sizeof(ibuf->name));
 277                 if (flags & IB_fields) IMB_de_interlace(ibuf);
 278         }
 279         close(file);
 280         return(ibuf);
 281 }
 282
 283 struct ImBuf *IMB_testiffname(char *naam,int flags) {
 284         int file;
 285         struct ImBuf *ibuf;
 286
 287         flags |= IB_test;
 288         file = open(naam,O_BINARY|O_RDONLY);
 289
 290         if (file<=0) return (0);
 291
 292         ibuf=IMB_loadifffile(file,flags);
 293         if (ibuf) {
 294                 strncpy(ibuf->name, naam, sizeof(ibuf->name));
 295         }
 296         close(file);
 297         return(ibuf);
 298 }