Source/System/Image/FileIO/OSGMNGImageFileType.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 #ifdef   OSG_SGI_LIB
  49 #include <limits>
  50 #endif
  51
  52 #ifdef MNG_LIB
  53 #include <mng.h>
  54 #endif
  55
  56 #include "OSGMNGImageFileType.h"
  57 #include "OSGLog.h"
  58
  59 #ifndef OSG_DO_DOC
  60 #    ifdef OSG_WITH_MNG
  61 #        define OSG_MNG_ARG(ARG) ARG
  62 #    else
  63 #        define OSG_MNG_ARG(ARG)
  64 #    endif
  65 #else
  66 #    define OSG_MNG_ARG(ARG) ARG
  67 #endif
  68
  69 // Static Class Varible implementations:
  70 static const OSG::Char8 *suffixArray[] =
  71 {
  72     "mng"
  73 };
  74
  75 OSG_BEGIN_NAMESPACE
  76
  77 /*! \class MNGImageFileType
  78
  79   Image File Type to read/write and store/restore Image objects as
  80   MNG data.
  81
  82   To be able to load MNG images you need the MNG library,
  83   (check the Prerequisites page on www.opensg.org).
  84   The lib comes with all Linux distributions.
  85
  86   You have to --enable-mng in the configure line to enable
  87   the singleton object.
  88
  89 */
  90
  91 MNGImageFileType MNGImageFileType::_the("video/x-mng",
  92                                         suffixArray,
  93                                         sizeof(suffixArray));
  94
  95
  96 //-------------------------------------------------------------------------
  97 /*! Tries to fill the image object with the data read from
  98    the given fileName. Returns true on success.
  99  */
 100
 101 bool MNGImageFileType::read(      Image            *,
 102                                   std::istream     &,
 103                             const std::string      &)
 104 {
 105
 106 #ifdef MNG_LIB
 107
 108   /*
 109
 110     png_structp png_ptr;
 111     png_infop info_ptr;
 112     png_uint_32 width, wc, height, h, i;
 113     png_byte bit_depth, channels, color_type;
 114     png_bytep *row_pointers, base;
 115     FILE *fd;
 116   bool retCode;
 117
 118     if ((fd = fopen(fileName, "rb")) == 0) {
 119         cerr << "Could not open file " << fileName << std::endl;
 120         return false;
 121     }
 122
 123     png_ptr = png_create_read_struct(MNG_LIBMNG_VER_STRING, 0, 0, 0);
 124     if (!png_ptr) {
 125         fclose(fd);
 126         return false;
 127     }
 128
 129     info_ptr = png_create_info_struct(png_ptr);
 130     if (!info_ptr) {
 131         fclose(fd);
 132         png_destroy_read_struct(&png_ptr, 0, 0);
 133         return false;
 134     }
 135
 136     if (setjmp(png_ptr->jmpbuf)) {
 137         png_destroy_read_struct(&png_ptr, &info_ptr, 0);
 138         fclose(fd);
 139         return false;
 140     }
 141
 142     png_init_io(png_ptr, fd);
 143
 144     png_read_info(png_ptr, info_ptr);
 145
 146     width = png_get_image_width(png_ptr, info_ptr);
 147     height = png_get_image_height(png_ptr, info_ptr);
 148     bit_depth = png_get_bit_depth(png_ptr, info_ptr);
 149     channels = png_get_channels(png_ptr, info_ptr);
 150     color_type = png_get_color_type(png_ptr, info_ptr);
 151
 152     if (image.set(width, height, channels)) {
 153
 154         // Convert paletted images to RGB
 155         if (color_type == MNG_COLOR_TYPE_PALETTE && bit_depth <= 8)
 156             png_set_expand(png_ptr);
 157         // Convert < 8 bit to 8 bit
 158         if (color_type == MNG_COLOR_TYPE_GRAY && bit_depth < 8)
 159             png_set_expand(png_ptr);
 160         // Add a full alpha channel if there is transparency
 161         // information in a tRNS chunk
 162         if (png_get_valid(png_ptr, info_ptr, MNG_INFO_tRNS))
 163             png_set_expand(png_ptr);
 164
 165         // Convert 16 bit to 8 bit
 166         if (bit_depth == 16)
 167             png_set_strip_16(png_ptr);
 168
 169         // Calculate the row pointers
 170         row_pointers = new png_bytep[height];
 171         wc = width * channels;
 172         h = height - 1;
 173         base = image.data();
 174         for (i = 0; i < height; ++i)
 175             row_pointers[i] = base + (h - i) * wc;
 176
 177         // Read the image data
 178         png_read_image(png_ptr, row_pointers);
 179
 180         delete [] row_pointers;
 181
 182         retCode = true;
 183     }
 184     else
 185         retCode = false;
 186
 187     png_destroy_read_struct(&png_ptr, &info_ptr, 0);
 188
 189     fclose(fd);
 190
 191     return retCode;
 192
 193   */
 194
 195     SWARNING << getMimeType()
 196              << " write is not implemented "
 197              << endLog;
 198
 199 #else
 200
 201     SWARNING << getMimeType()
 202              << " read is not compiled into the current binary "
 203              << std::endl;
 204
 205   return false;
 206
 207 #endif
 208
 209 }
 210
 211 //-------------------------------------------------------------------------
 212 /*! Tries to write the image object to the given fileName.
 213     Returns true on success.
 214  */
 215
 216 bool MNGImageFileType::write(const Image        *,
 217                                    std::ostream &,
 218                              const std::string  &)
 219 {
 220
 221 #ifdef MNG_LIB
 222
 223     SWARNING << getMimeType()
 224              << " write is not implemented "
 225              << endLog;
 226
 227 #else
 228
 229     SWARNING << getMimeType()
 230              << " write is not compiled into the current binary "
 231              << endLog;
 232
 233   return false;
 234
 235 #endif
 236
 237 }
 238
 239 //-------------------------------------------------------------------------
 240 /*!
 241   Tries to determine the mime type of the data provided by an input stream
 242   by searching for magic bytes. Returns the mime type or an empty string
 243   when the function could not determine the mime type.
 244  */
 245
 246 std::string MNGImageFileType::determineMimetypeFromStream(std::istream &is)
 247 {
 248     char filecode[4];
 249
 250     is.read(filecode, 4);
 251     is.seekg(-4, std::ios::cur);
 252
 253     if (strncmp(filecode, "\x8aMNG", 4) == 0)
 254         return std::string(getMimeType());
 255     if (strncmp(filecode, "\x8aJNG", 4) == 0)
 256         return std::string(getMimeType());
 257
 258     return std::string();
 259 }
 260
 261 //-------------------------------------------------------------------------
 262 /*! Constructor used for the singleton object
 263  */
 264
 265 MNGImageFileType::MNGImageFileType(const Char8  *mimeType,
 266                                    const Char8  *suffixArray[],
 267                                          UInt16  suffixByteCount) :
 268
 269     Inherited(mimeType, suffixArray, suffixByteCount)
 270 {
 271 }
 272
 273 //-------------------------------------------------------------------------
 274 /*! Destructor
 275  */
 276
 277 MNGImageFileType::~MNGImageFileType (void )
 278 {
 279 }
 280
 281 OSG_END_NAMESPACE
 282