juce/source/src/io/streams/juce_GZIPCompressorOutputStream.cpp

   1 /*
   2   ==============================================================================
   3
   4    This file is part of the JUCE library - "Jules' Utility Class Extensions"
   5    Copyright 2004-11 by Raw Material Software Ltd.
   6
   7   ------------------------------------------------------------------------------
   8
   9    JUCE can be redistributed and/or modified under the terms of the GNU General
  10    Public License (Version 2), as published by the Free Software Foundation.
  11    A copy of the license is included in the JUCE distribution, or can be found
  12    online at www.gnu.org/licenses.
  13
  14    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY
  15    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  16    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  17
  18   ------------------------------------------------------------------------------
  19
  20    To release a closed-source product which uses JUCE, commercial licenses are
  21    available: visit www.rawmaterialsoftware.com/juce for more information.
  22
  23   ==============================================================================
  24 */
  25
  26 #include "../../core/juce_StandardHeader.h"
  27
  28 namespace zlibNamespace
  29 {
  30  #if JUCE_INCLUDE_ZLIB_CODE
  31   #undef OS_CODE
  32   #undef fdopen
  33   #include "zlib/zlib.h"
  34   #undef OS_CODE
  35  #else
  36   #include <zlib.h>
  37  #endif
  38 }
  39
  40 BEGIN_JUCE_NAMESPACE
  41
  42 #include "juce_GZIPCompressorOutputStream.h"
  43
  44 //==============================================================================
  45 class GZIPCompressorOutputStream::GZIPCompressorHelper
  46 {
  47 public:
  48     GZIPCompressorHelper (const int compressionLevel, const int windowBits)
  49         : data (nullptr),
  50           dataSize (0),
  51           compLevel (compressionLevel),
  52           strategy (0),
  53           setParams (true),
  54           streamIsValid (false),
  55           finished (false),
  56           shouldFinish (false)
  57     {
  58         using namespace zlibNamespace;
  59         zerostruct (stream);
  60
  61         streamIsValid = (deflateInit2 (&stream, compLevel, Z_DEFLATED,
  62                                        windowBits != 0 ? windowBits : MAX_WBITS,
  63                                        8, strategy) == Z_OK);
  64     }
  65
  66     ~GZIPCompressorHelper()
  67     {
  68         using namespace zlibNamespace;
  69         if (streamIsValid)
  70             deflateEnd (&stream);
  71     }
  72
  73     bool needsInput() const noexcept
  74     {
  75         return dataSize <= 0;
  76     }
  77
  78     void setInput (const uint8* const newData, const int size) noexcept
  79     {
  80         data = newData;
  81         dataSize = size;
  82     }
  83
  84     int doNextBlock (uint8* const dest, const int destSize) noexcept
  85     {
  86         using namespace zlibNamespace;
  87         if (streamIsValid)
  88         {
  89             stream.next_in = const_cast <uint8*> (data);
  90             stream.next_out = dest;
  91             stream.avail_in = dataSize;
  92             stream.avail_out = destSize;
  93
  94             const int result = setParams ? deflateParams (&stream, compLevel, strategy)
  95                                          : deflate (&stream, shouldFinish ? Z_FINISH : Z_NO_FLUSH);
  96
  97             setParams = false;
  98
  99             switch (result)
 100             {
 101             case Z_STREAM_END:
 102                 finished = true;
 103                 // Deliberate fall-through..
 104             case Z_OK:
 105                 data += dataSize - stream.avail_in;
 106                 dataSize = stream.avail_in;
 107
 108                 return destSize - stream.avail_out;
 109
 110             default:
 111                 break;
 112             }
 113         }
 114
 115         return 0;
 116     }
 117
 118     enum { gzipCompBufferSize = 32768 };
 119
 120 private:
 121     zlibNamespace::z_stream stream;
 122     const uint8* data;
 123     int dataSize, compLevel, strategy;
 124     bool setParams, streamIsValid;
 125
 126 public:
 127     bool finished, shouldFinish;
 128 };
 129
 130 //==============================================================================
 131 GZIPCompressorOutputStream::GZIPCompressorOutputStream (OutputStream* const destStream_,
 132                                                         int compressionLevel,
 133                                                         const bool deleteDestStream,
 134                                                         const int windowBits)
 135   : destStream (destStream_, deleteDestStream),
 136     buffer ((size_t) GZIPCompressorHelper::gzipCompBufferSize)
 137 {
 138     if (compressionLevel < 1 || compressionLevel > 9)
 139         compressionLevel = -1;
 140
 141     helper = new GZIPCompressorHelper (compressionLevel, windowBits);
 142 }
 143
 144 GZIPCompressorOutputStream::~GZIPCompressorOutputStream()
 145 {
 146     flushInternal();
 147 }
 148
 149 //==============================================================================
 150 void GZIPCompressorOutputStream::flushInternal()
 151 {
 152     if (! helper->finished)
 153     {
 154         helper->shouldFinish = true;
 155
 156         while (! helper->finished)
 157             doNextBlock();
 158     }
 159
 160     destStream->flush();
 161 }
 162
 163 void GZIPCompressorOutputStream::flush()
 164 {
 165     flushInternal();
 166 }
 167
 168 bool GZIPCompressorOutputStream::write (const void* destBuffer, int howMany)
 169 {
 170     if (! helper->finished)
 171     {
 172         helper->setInput (static_cast <const uint8*> (destBuffer), howMany);
 173
 174         while (! helper->needsInput())
 175         {
 176             if (! doNextBlock())
 177                 return false;
 178         }
 179     }
 180
 181     return true;
 182 }
 183
 184 bool GZIPCompressorOutputStream::doNextBlock()
 185 {
 186     const int len = helper->doNextBlock (buffer, (int) GZIPCompressorHelper::gzipCompBufferSize);
 187     return len <= 0 || destStream->write (buffer, len);
 188 }
 189
 190 int64 GZIPCompressorOutputStream::getPosition()
 191 {
 192     return destStream->getPosition();
 193 }
 194
 195 bool GZIPCompressorOutputStream::setPosition (int64 /*newPosition*/)
 196 {
 197     jassertfalse; // can't do it!
 198     return false;
 199 }
 200
 201 END_JUCE_NAMESPACE