Source/System/Image/FileIO/OSGSGIImageFileType.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *             Copyright (C) 2000-2002 by the OpenSG Forum                   *
   6  *                                                                           *
   7  *                            www.opensg.org                                 *
   8  *                                                                           *
   9  *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
  10  *                                                                           *
  11 \*---------------------------------------------------------------------------*/
  12 /*---------------------------------------------------------------------------*\
  13  *                                License                                    *
  14  *                                                                           *
  15  * This library is free software; you can redistribute it and/or modify it   *
  16  * under the terms of the GNU Library General Public License as published    *
  17  * by the Free Software Foundation, version 2.                               *
  18  *                                                                           *
  19  * This library is distributed in the hope that it will be useful, but       *
  20  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  22  * Library General Public License for more details.                          *
  23  *                                                                           *
  24  * You should have received a copy of the GNU Library General Public         *
  25  * License along with this library; if not, write to the Free Software       *
  26  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
  27  *                                                                           *
  28 \*---------------------------------------------------------------------------*/
  29 /*---------------------------------------------------------------------------*\
  30  *                                Changes                                    *
  31  *                                                                           *
  32  *                                                                           *
  33  *                                                                           *
  34  *                                                                           *
  35  *                                                                           *
  36  *                                                                           *
  37 \*---------------------------------------------------------------------------*/
  38
  39 //-------------------------------
  40 //      Includes
  41 //-------------------------------
  42
  43 #include <cstdlib>
  44 #include <cstdio>
  45
  46 #include "OSGConfig.h"
  47
  48 #include "OSGBaseFunctions.h"
  49
  50 #include <iostream>
  51 #include <fstream>
  52
  53 #include "OSGLog.h"
  54
  55 #include "OSGSGIImageFileType.h"
  56
  57 #ifdef OSG_SGI_STL
  58 //#include <limits>
  59 #ifndef INT_MAX
  60 #define INT_MAX numeric_limits<int>::max()
  61 #endif
  62 #else
  63 #include <climits>
  64 #endif
  65
  66 static const OSG::Char8 *suffixArray[] =
  67 {
  68     "rgb", "rgba", "sgi", "bw", "int", "inta"
  69 };
  70
  71 OSG_BEGIN_NAMESPACE
  72
  73 /*! \class SGIImageFileType
  74
  75   Image File Type to read/write and store/restore Image objects as
  76   SGI data.
  77
  78   All the type specific code is included in the class. Does
  79   not depend on external libs.
  80
  81 */
  82
  83
  84 /* the basic reader functions */
  85
  86 /* I found these on the net a long time ago. They didn't contain any copyright
  87    notice and I couldn't find out where I found them.
  88    If you wrote them please let us know (info@opensg.org) so that we can either
  89    credit you or remove them if you have a problem with us using them.
  90    Thanks
  91             Dirk
  92 */
  93
  94 #if !defined(OSG_DO_DOC) || defined(OSG_DOC_DEV)
  95
  96 /*! \nohierarchy
  97  */
  98
  99 struct ImageRec
 100 {
 101     unsigned short imagic;
 102     unsigned short type;
 103     unsigned short dim;
 104     unsigned short xsize, ysize, zsize;
 105     unsigned int min, max;
 106     unsigned int wasteBytes;
 107     char name[80];
 108     unsigned long colorMap;
 109     std::istream *is;
 110     std::vector<unsigned char> tmp;
 111     std::vector<unsigned int> rowStart;
 112     std::vector<unsigned int> rowSize;
 113
 114     ImageRec(void) :
 115         imagic    (0   ),
 116         type      (0   ),
 117         dim       (0   ),
 118         xsize     (0   ),
 119         ysize     (0   ),
 120         zsize     (0   ),
 121         min       (0   ),
 122         max       (0   ),
 123         wasteBytes(0   ),
 124         colorMap  (0   ),
 125         is        (NULL),
 126         tmp       (    ),
 127         rowStart  (    ),
 128         rowSize   (    ) {}
 129
 130   private:
 131
 132     ImageRec(const ImageRec &other);
 133     void operator =(const ImageRec &rhs);
 134 };
 135
 136 #endif
 137
 138 static void
 139 ConvertShort(unsigned short *array, long length)
 140 {
 141     unsigned b1, b2;
 142     unsigned char *ptr;
 143
 144     ptr = reinterpret_cast<unsigned char *>(array);
 145     while (length--)
 146     {
 147         b1 = *ptr++;
 148         b2 = *ptr++;
 149         *array++ = (b1 << 8) | (b2);
 150     }
 151 }
 152
 153 static void
 154 ConvertLong(unsigned *array, unsigned long length)
 155 {
 156     unsigned long b1, b2, b3, b4;
 157     unsigned char *ptr;
 158
 159     ptr = reinterpret_cast<unsigned char *>(array);
 160     while (length--)
 161     {
 162         b1 = *ptr++;
 163         b2 = *ptr++;
 164         b3 = *ptr++;
 165         b4 = *ptr++;
 166         *array++ = (b1 << 24) | (b2 << 16) | (b3 << 8) | (b4);
 167     }
 168 }
 169
 170 static bool ImageOpen(ImageRec &image, std::istream &is)
 171 {
 172     image.is = &is;
 173
 174     is.read(reinterpret_cast<char*>(&image), 12);
 175
 176     if(is.gcount() != 12)
 177         return false;
 178
 179     bool swapFlag = !osgIsBigEndian();
 180
 181     if(swapFlag == true)
 182         ConvertShort(&image.imagic, 6);
 183
 184     if((image.type & 0xFF00) == 0x0100)
 185     {
 186         is.ignore(512 - 12);
 187         if (is.gcount() != 512 - 12)
 188             return false;
 189
 190         int n = image.ysize * image.zsize;
 191         int len = n * sizeof(unsigned);
 192
 193         image.rowStart.resize(n);
 194
 195         is.read(reinterpret_cast<char*>(&(image.rowStart.front())), len);
 196
 197         if(is.gcount() != len)
 198             return false;
 199
 200         image.rowSize.resize(n);
 201
 202         is.read(reinterpret_cast<char*>(&(image.rowSize.front())), len);
 203
 204         if(is.gcount() != len)
 205             return false;
 206
 207         if(swapFlag == true)
 208         {
 209             ConvertLong(&(image.rowStart.front()), n);
 210             ConvertLong(&(image.rowSize .front()), n);
 211         }
 212         unsigned int maxSize = 0;
 213
 214         for(int i = 0; i < n; ++i)
 215         {
 216             if(image.rowSize[i] > maxSize)
 217                 maxSize = image.rowSize[i];
 218         }
 219
 220         image.tmp.resize(maxSize);
 221     }
 222     else
 223     {
 224         image.tmp.resize(image.xsize);
 225     }
 226
 227     return true;
 228 }
 229
 230 static bool ImageGetRow(ImageRec      &image,
 231                         unsigned char *buf,
 232                         int            y,
 233                         int            z,
 234                         int            stride)
 235 {
 236     unsigned char *iPtr = &(image.tmp.front());
 237     unsigned char *oPtr = buf;
 238
 239     if((image.type & 0xFF00) == 0x0100)
 240     {
 241         unsigned int row = y + z * image.ysize;
 242
 243         image.is->seekg(image.rowStart[row], std::ios::beg);
 244
 245         long len = image.rowSize[row];
 246
 247         image.is->read(reinterpret_cast<char*>(iPtr), len);
 248
 249         if(image.is->gcount() != len)
 250             return false;
 251
 252         int npix = image.xsize;
 253
 254         while(len > 0)
 255         {
 256             --len;
 257             unsigned char pixel = *iPtr++;
 258             int count = pixel & 0x7F;
 259
 260             if(count == 0)
 261                 break;
 262
 263             if(npix < count)
 264                 return false;
 265
 266             npix -= count;
 267
 268             if(pixel & 0x80)
 269             {
 270                 if(len < count)
 271                     return false;
 272
 273                 len -= count;
 274
 275                 while(count--)
 276                 {
 277                     *oPtr = *iPtr++;
 278                     oPtr += stride;
 279                 }
 280             }
 281             else
 282             {
 283                 if(len < 1)
 284                     return false;
 285
 286                 --len;
 287
 288                 pixel = *iPtr++;
 289
 290                 while(count--)
 291                 {
 292                     *oPtr = pixel;
 293                     oPtr += stride;
 294                 }
 295             }
 296         }
 297     }
 298     else
 299     {
 300         image.is->seekg(512 + (y + z * image.ysize) * image.xsize,
 301                         std::ios::beg);
 302
 303         image.is->read(reinterpret_cast<char*>(iPtr), image.xsize);
 304
 305         if(image.is->gcount() != image.xsize)
 306             return false;
 307
 308         int count = image.xsize;
 309
 310         while(count--)
 311         {
 312             *oPtr = *iPtr++;
 313             oPtr += stride;
 314         }
 315     }
 316
 317     return true;
 318 }
 319
 320 static const UInt32 zsize2pixelformat[] =
 321 {
 322     Image::OSG_L_PF,
 323     Image::OSG_LA_PF,
 324     Image::OSG_RGB_PF,
 325     Image::OSG_RGBA_PF
 326 };
 327
 328 SGIImageFileType SGIImageFileType::_the("image/x-sgi",
 329                                         suffixArray,
 330                                         sizeof(suffixArray));
 331
 332
 333 //-------------------------------------------------------------------------
 334 /*! Tries to fill the image object with the data read from
 335     the given input stream. Returns true on success.
 336  */
 337
 338 bool SGIImageFileType::read(      Image            *pImage,
 339                                   std::istream     &is,
 340                             const std::string      &mimetype)
 341 {
 342     ImageRec img;
 343
 344         if(ImageOpen(img, is) == false)
 345         return false;
 346
 347     if((img.zsize < 1) || (img.zsize > 4))
 348         return false;
 349
 350     pImage->set(zsize2pixelformat[img.zsize - 1], img.xsize, img.ysize);
 351
 352     unsigned char *lptr = pImage->editData();
 353
 354     unsigned int lineStride = img.xsize * img.zsize;
 355
 356     for(int y = 0; y < img.ysize; ++y)
 357     {
 358         for(int z = 0; z < img.zsize; ++z)
 359         {
 360             if(ImageGetRow(img, lptr + z, y, z, img.zsize) == false)
 361                 return false;
 362         }
 363
 364         lptr += lineStride;
 365     }
 366
 367     return true;
 368 }
 369
 370 //-------------------------------------------------------------------------
 371 /*! Tries to write the image object to the given fileName.
 372     Returns true on success.
 373  */
 374
 375 bool SGIImageFileType::write(const Image            *pImage,
 376                                    std::ostream     &os,
 377                              const std::string      &mimetype)
 378 {
 379     FWARNING(("SGIImageFileType::write: not implemented yet!\n"));
 380
 381     return false;
 382 }
 383
 384 bool SGIImageFileType::validateHeader(const Char8 *fileName, bool &implemented)
 385 {
 386     implemented = true;
 387
 388     if(fileName == NULL)
 389         return false;
 390
 391     FILE *file = fopen(fileName, "rb");
 392
 393     if(file == NULL)
 394         return false;
 395
 396     UInt16 magic = 0;
 397
 398     fread(static_cast<void *>(&magic), sizeof(magic), 1, file);
 399
 400     fclose(file);
 401
 402 #if BYTE_ORDER == LITTLE_ENDIAN
 403     if(magic == 0xda01) // the magic header is big endian need to swap it.
 404 #else
 405     if(magic == 0x01da)
 406 #endif
 407     {
 408         return true;
 409     }
 410
 411     return false;
 412 }
 413
 414 //-------------------------------------------------------------------------
 415 /*!
 416   Tries to determine the mime type of the data provided by an input stream
 417   by searching for magic bytes. Returns the mime type or an empty string
 418   when the function could not determine the mime type.
 419  */
 420
 421 std::string SGIImageFileType::determineMimetypeFromStream(std::istream &is)
 422 {
 423     char filecode[2];
 424
 425     is.read(filecode, 2);
 426     is.seekg(-2, std::ios::cur);
 427
 428     return strncmp(filecode, "\x01\xda", 2) == 0 ?
 429         std::string(getMimeType()) : std::string();
 430 }
 431
 432 //-------------------------------------------------------------------------
 433 /*! Constructor used for the singleton object
 434  */
 435
 436 SGIImageFileType::SGIImageFileType(const Char8  *mimeType,
 437                                    const Char8  *suffixArray[],
 438                                          UInt16  suffixByteCount) :
 439
 440     Inherited(mimeType, suffixArray, suffixByteCount)
 441 {
 442 }
 443
 444 //-------------------------------------------------------------------------
 445 /*! Destructor
 446  */
 447
 448 SGIImageFileType::~SGIImageFileType(void)
 449 {
 450 }
 451
 452 OSG_END_NAMESPACE
 453