Source/System/FileIO/Base/OSGZStream.h

   1 /*
   2 zipstream Library License:
   3 --------------------------
   4
   5 The zlib/libpng License Copyright (c) 2003 Jonathan de Halleux.
   6
   7 This software is provided 'as-is', without any express or implied warranty. In
   8 no event will the authors be held liable for any damages arising from the use
   9 of this software.
  10
  11 Permission is granted to anyone to use this software for any purpose,
  12 including commercial applications, and to alter it and redistribute it freely,
  13 subject to the following restrictions:
  14
  15 1. The origin of this software must not be misrepresented; you must not claim
  16    that you wrote the original software. If you use this software in a
  17    product, an acknowledgment in the product documentation would be
  18    appreciated but is not required.
  19
  20 2. Altered source versions must be plainly marked as such, and must not be
  21    misrepresented as being the original software.
  22
  23 3. This notice may not be removed or altered from any source distribution
  24
  25 Author: Jonathan de Halleux, dehalleux@pelikhan.com, 2003
  26
  27 Altered by: Andreas Zieringer 2003
  28             made it platform independent, gzip conform, fixed gzip footer)
  29 */
  30
  31 #ifndef _OSGZSTREAM_H_
  32 #define _OSGZSTREAM_H_
  33
  34 #include <vector>
  35 #include <string>
  36 #include <streambuf>
  37 #include <sstream>
  38 #include <iostream>
  39 #include <algorithm>
  40
  41 OSG_BEGIN_NAMESPACE
  42
  43 /*! Helper function to check whether stream is compressed or not.
  44     \ingroup GrpSystemFileIOHelper
  45  */
  46
  47 inline
  48 bool isGZip(std::istream &is)
  49 {
  50     const int gz_magic[2] = {0x1f, 0x8b};
  51
  52     int c1 = int(is.get());
  53     if(c1 != gz_magic[0])
  54     {
  55         is.putback(c1);
  56         return false;
  57     }
  58
  59     int c2 = int(is.get());
  60     if(c2 != gz_magic[1])
  61     {
  62         is.putback(c2);
  63         is.putback(c1);
  64         return false;
  65     }
  66
  67     is.putback(c2);
  68     is.putback(c1);
  69     return true;
  70 }
  71
  72 OSG_END_NAMESPACE
  73
  74 #ifdef OSG_WITH_ZLIB
  75
  76 #define OSG_ZSTREAM_SUPPORTED
  77 #define OSG_ZSTREAM_DATA_HAND_OVER_SUPPORTED
  78
  79 #include <zlib.h>
  80
  81 #ifdef WIN32 /* Window 95 & Windows NT */
  82 #  define OS_CODE  0x0b
  83 #endif
  84 #if defined(MACOS) || defined(TARGET_OS_MAC)
  85 #  define OS_CODE  0x07
  86 #endif
  87 #ifndef OS_CODE
  88 #  define OS_CODE  0x03  /* assume Unix */
  89 #endif
  90
  91 #ifdef OSG_WIN32_CL
  92 #pragma warning(disable : 4355)
  93 #endif
  94
  95 OSG_BEGIN_NAMESPACE
  96
  97 namespace detail
  98 {
  99     const int gz_magic[2] = {0x1f, 0x8b}; /* gzip magic header */
 100
 101     /* gzip flag byte */
 102     const int gz_ascii_flag =  0x01; /* bit 0 set: file probably ascii text */
 103     const int gz_head_crc    = 0x02; /* bit 1 set: header CRC present */
 104     const int gz_extra_field = 0x04; /* bit 2 set: extra field present */
 105     const int gz_orig_name  =  0x08; /* bit 3 set: original file name present*/
 106
 107     const int gz_comment    =  0x10; /* bit 4 set: file comment present */
 108     const int gz_reserved   =  0xE0; /* bits 5..7: reserved */
 109 }
 110
 111 /// default gzip buffer size,
 112 /// change this to suite your needs
 113 const size_t zstream_default_buffer_size = 4096;
 114
 115 /// Compression strategy, see zlib doc.
 116 enum EStrategy
 117 {
 118     StrategyFiltered = 1,
 119     StrategyHuffmanOnly = 2,
 120     DefaultStrategy = 0
 121 };
 122
 123
 124 //*****************************************************************************
 125 //  template class basic_zip_streambuf
 126 //*****************************************************************************
 127
 128 /*! \brief A stream decorator that takes raw input and zips it to a ostream.
 129     \ingroup GrpSystemFileIOHelper
 130     The class wraps up the inflate method of the zlib library 1.1.4
 131     http://www.gzip.org/zlib/
 132  */
 133 template <class charT,
 134           class traits = std::char_traits<charT> >
 135 class basic_zip_streambuf : public std::basic_streambuf<charT, traits>
 136 {
 137
 138   public:
 139
 140     typedef std::basic_ostream<charT, traits>& ostream_reference;
 141     typedef unsigned char byte_type;
 142     typedef char          char_type;
 143     typedef byte_type* byte_buffer_type;
 144     typedef std::vector<byte_type> byte_vector_type;
 145     typedef std::vector<char_type> char_vector_type;
 146     typedef int int_type;
 147     typedef basic_zip_streambuf Self;
 148     typedef std::basic_streambuf<charT, traits> Inherited;
 149
 150     basic_zip_streambuf(ostream_reference ostream,
 151                         int               level,
 152                         EStrategy         strategy,
 153                         int               window_size,
 154                         int               memory_level,
 155                         size_t            buffer_size);
 156     ~basic_zip_streambuf(void);
 157
 158     int               sync        (void);
 159     int_type          overflow    (int_type c);
 160     std::streamsize   flush       (void);
 161     ostream_reference get_ostream (void) const;
 162     int               get_zerr    (void) const;
 163     unsigned long     get_crc     (void) const;
 164     unsigned long     get_in_size (void) const;
 165     long              get_out_size(void) const;
 166
 167
 168   private:
 169
 170     bool zip_to_stream(char_type *buffer, std::streamsize buffer_size);
 171
 172     ostream_reference   _ostream;
 173     z_stream            _zip_stream;
 174     int                 _err;
 175     byte_vector_type    _output_buffer;
 176     char_vector_type    _buffer;
 177     unsigned long       _crc;
 178 };
 179
 180 //*****************************************************************************
 181 //  template class basic_unzip_streambuf
 182 //*****************************************************************************
 183
 184 /*! \brief A stream decorator that takes compressed input and unzips it to a
 185     istream.
 186
 187     \ingroup GrpSystemFileIOHelper
 188
 189     The class wraps up the deflate method of the zlib library 1.1.4
 190     http://www.gzip.org/zlib/
 191  */
 192
 193 template <class charT,
 194           class traits = std::char_traits<charT> >
 195 class basic_unzip_streambuf :
 196     public std::basic_streambuf<charT, traits>
 197 {
 198   public:
 199
 200     typedef std::basic_istream<charT,traits>& istream_reference;
 201     typedef unsigned char byte_type;
 202     typedef char          char_type;
 203     typedef byte_type* byte_buffer_type;
 204     typedef std::vector<byte_type> byte_vector_type;
 205     typedef std::vector<char_type> char_vector_type;
 206     typedef int int_type;
 207
 208      /** Construct a unzip stream
 209       * More info on the following parameters can be found in the zlib
 210       * documentation
 211      */
 212     basic_unzip_streambuf(istream_reference istream,
 213                           int window_size,
 214                           size_t read_buffer_size,
 215                           size_t input_buffer_size);
 216     ~basic_unzip_streambuf(void);
 217
 218
 219     int_type           underflow     (void);
 220     istream_reference  get_istream   (void);
 221     z_stream          &get_zip_stream(void);
 222     int                get_zerr      (void) const;
 223     unsigned           long get_crc  (void) const;
 224     long               get_out_size  (void) const;
 225     long               get_in_size   (void) const;
 226
 227   protected:
 228
 229     byte_vector_type    _input_buffer;
 230     char_vector_type    _buffer;
 231
 232     enum StreamType { UNKNOWN_ST, GZIP_ST, DATA_ST };
 233
 234     StreamType _streamType;
 235
 236   private:
 237
 238     void            put_back_from_zip_stream(void                        );
 239     std::streamsize unzip_from_stream       (char_type       *buffer,
 240                                              std::streamsize  buffer_size);
 241     size_t          fill_input_buffer       (void                        );
 242
 243     istream_reference   _istream;
 244     z_stream            _zip_stream;
 245     int                 _err;
 246     unsigned long       _crc;
 247 };
 248
 249 // ****************************************************************************
 250 //  template class basic_zip_ostream
 251 // ****************************************************************************
 252
 253 /*! \ingroup GrpSystemFileIOHelper
 254  */
 255
 256 template <class charT,
 257           class traits = std::char_traits<charT> >
 258 class basic_zip_ostream :
 259     private basic_zip_streambuf<charT, traits>,
 260     public std::basic_ostream<charT, traits>
 261 {
 262   public:
 263
 264     typedef char char_type;
 265     typedef std::basic_ostream<charT, traits>& ostream_reference;
 266
 267     explicit basic_zip_ostream(ostream_reference ostream,
 268                                bool isGzip = false,
 269                                int level = Z_DEFAULT_COMPRESSION,
 270                                EStrategy strategy = DefaultStrategy,
 271                                int window_size = -15 /*windowBits is passed < 0 to suppress zlib header */,
 272                                int memory_level = 8,
 273                                size_t buffer_size = zstream_default_buffer_size) ;
 274     ~basic_zip_ostream(void);
 275
 276     bool                              is_gzip (void) const;
 277     basic_zip_ostream<charT, traits> &zflush  (void);
 278     void                              finished(void);
 279
 280   private:
 281
 282     basic_zip_ostream<charT,traits>& add_header(void);
 283     basic_zip_ostream<charT,traits>& add_footer(void);
 284
 285     bool _is_gzip;
 286     bool _added_footer;
 287 };
 288
 289 // ****************************************************************************
 290 //  template class basic_zip_istream
 291 // ****************************************************************************
 292
 293 /*! \ingroup GrpSystemFileIOHelper
 294  */
 295
 296 template <class charT,
 297           class traits = std::char_traits<charT> >
 298 class basic_zip_istream :
 299     public basic_unzip_streambuf<charT, traits>,
 300     public std::basic_istream<charT, traits>
 301 {
 302   public:
 303     typedef basic_unzip_streambuf<charT, traits> BufferType;
 304
 305     typedef std::basic_istream<charT, traits>& istream_reference;
 306
 307     explicit basic_zip_istream(istream_reference istream,
 308                                int window_size = -15 /*windowBits is passed < 0 to suppress zlib header */,
 309                                size_t read_buffer_size = zstream_default_buffer_size,
 310                                size_t input_buffer_size = zstream_default_buffer_size);
 311
 312     bool is_gzip           (void) const;
 313     bool check_crc         (void);
 314     bool check_data_size   (void) const;
 315     long get_gzip_crc      (void) const;
 316     long get_gzip_data_size(void) const;
 317
 318   protected:
 319
 320     int check_header(void);
 321     void read_footer(void);
 322
 323     bool _is_gzip;
 324     long _gzip_crc;
 325     long _gzip_data_size;
 326 };
 327
 328 OSG_END_NAMESPACE
 329
 330 #include "OSGZStream.inl"
 331
 332 OSG_BEGIN_NAMESPACE
 333
 334 /*! A typedef for basic_zip_ostream<char>
 335     \ingroup GrpSystemFileIOHelper
 336  */
 337
 338 typedef basic_zip_ostream<char> zip_ostream;
 339
 340 /// A typedef for basic_zip_ostream<wchar_t>
 341 //typedef basic_zip_ostream<wchar_t> zip_wostream;
 342
 343 /*! A typedef for basic_zip_istream<char>
 344     \ingroup GrpSystemFileIOHelper
 345  */
 346
 347 typedef basic_zip_istream<char> zip_istream;
 348
 349 /// A typedef for basic_zip_istream<wchart>
 350 //typedef basic_zip_istream<wchar_t> zip_wistream;
 351
 352 OSG_END_NAMESPACE
 353
 354 #ifdef OSG_WIN32_CL
 355 #pragma warning(default : 4355)
 356 #endif
 357
 358 #endif // OSG_WITH_ZLIB
 359
 360 #endif // _OSGZSTREAM_H_
 361