source/modules/water/streams/MemoryOutputStream.cpp

   1 /*
   2   ==============================================================================
   3
   4    This file is part of the Water library.
   5    Copyright (c) 2016 ROLI Ltd.
   6    Copyright (C) 2017 Filipe Coelho <falktx@falktx.com>
   7
   8    Permission is granted to use this software under the terms of the ISC license
   9    http://www.isc.org/downloads/software-support-policy/isc-license/
  10
  11    Permission to use, copy, modify, and/or distribute this software for any
  12    purpose with or without fee is hereby granted, provided that the above
  13    copyright notice and this permission notice appear in all copies.
  14
  15    THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH REGARD
  16    TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  17    FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT,
  18    OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
  19    USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  20    TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  21    OF THIS SOFTWARE.
  22
  23   ==============================================================================
  24 */
  25
  26 #include "MemoryOutputStream.h"
  27 #include "InputStream.h"
  28
  29 namespace water {
  30
  31 MemoryOutputStream::MemoryOutputStream (const size_t initialSize)
  32   : internalBlock(), blockToUse (internalBlock),
  33     position (0), size (0),
  34     usingInternalBlock (true)
  35 {
  36     internalBlock.setSize (initialSize, false);
  37 }
  38
  39 MemoryOutputStream::MemoryOutputStream (MemoryBlock& memoryBlockToWriteTo,
  40                                         const bool appendToExistingBlockContent)
  41   : internalBlock(), blockToUse (memoryBlockToWriteTo),
  42     position (0), size (0),
  43     usingInternalBlock (false)
  44 {
  45     if (appendToExistingBlockContent)
  46         position = size = memoryBlockToWriteTo.getSize();
  47 }
  48
  49 MemoryOutputStream::~MemoryOutputStream()
  50 {
  51     trimExternalBlockSize();
  52 }
  53
  54 void MemoryOutputStream::flush()
  55 {
  56     trimExternalBlockSize();
  57 }
  58
  59 void MemoryOutputStream::trimExternalBlockSize()
  60 {
  61     if (! usingInternalBlock)
  62         blockToUse.setSize (size, false);
  63 }
  64
  65 void MemoryOutputStream::preallocate (const size_t bytesToPreallocate)
  66 {
  67     blockToUse.ensureSize (bytesToPreallocate + 1);
  68 }
  69
  70 void MemoryOutputStream::reset() noexcept
  71 {
  72     position = 0;
  73     size = 0;
  74 }
  75
  76 char* MemoryOutputStream::prepareToWrite (size_t numBytes)
  77 {
  78     CARLA_SAFE_ASSERT_RETURN ((ssize_t) numBytes >= 0, nullptr);
  79
  80     const size_t storageNeeded = position + numBytes;
  81
  82     if (storageNeeded >= blockToUse.getSize())
  83         blockToUse.ensureSize ((storageNeeded + jmin (storageNeeded / 2, (size_t) (1024 * 1024)) + 32) & ~31u);
  84
  85     char* const data = static_cast<char*> (blockToUse.getData());
  86     char* const writePointer = data + position;
  87     position += numBytes;
  88     size = jmax (size, position);
  89     return writePointer;
  90 }
  91
  92 bool MemoryOutputStream::write (const void* const buffer, size_t howMany)
  93 {
  94     CARLA_SAFE_ASSERT_RETURN (buffer != nullptr, false);
  95
  96     if (howMany == 0)
  97         return true;
  98
  99     if (char* const dest = prepareToWrite (howMany))
 100     {
 101         std::memcpy (dest, buffer, howMany);
 102         return true;
 103     }
 104
 105     return false;
 106 }
 107
 108 bool MemoryOutputStream::writeRepeatedByte (uint8 byte, size_t howMany)
 109 {
 110     if (howMany == 0)
 111         return true;
 112
 113     if (char* dest = prepareToWrite (howMany))
 114     {
 115         memset (dest, byte, howMany);
 116         return true;
 117     }
 118
 119     return false;
 120 }
 121
 122 bool MemoryOutputStream::appendUTF8Char (water_uchar c)
 123 {
 124     if (char* dest = prepareToWrite (CharPointer_UTF8::getBytesRequiredFor (c)))
 125     {
 126         CharPointer_UTF8 (dest).write (c);
 127         return true;
 128     }
 129
 130     return false;
 131 }
 132
 133 MemoryBlock MemoryOutputStream::getMemoryBlock() const
 134 {
 135     return MemoryBlock (getData(), getDataSize());
 136 }
 137
 138 const void* MemoryOutputStream::getData() const noexcept
 139 {
 140     if (blockToUse.getSize() > size)
 141         static_cast<char*> (blockToUse.getData()) [size] = 0;
 142
 143     return blockToUse.getData();
 144 }
 145
 146 void* MemoryOutputStream::getDataAndRelease() noexcept
 147 {
 148     if (blockToUse.getSize() > size)
 149         static_cast<char*> (blockToUse.getData()) [size] = 0;
 150
 151     return blockToUse.release();
 152 }
 153
 154 bool MemoryOutputStream::setPosition (int64 newPosition)
 155 {
 156     if (newPosition <= (int64) size)
 157     {
 158         // ok to seek backwards
 159         position = jlimit ((size_t) 0, size, (size_t) newPosition);
 160         return true;
 161     }
 162
 163     // can't move beyond the end of the stream..
 164     return false;
 165 }
 166
 167 int64 MemoryOutputStream::writeFromInputStream (InputStream& source, int64 maxNumBytesToWrite)
 168 {
 169     // before writing from an input, see if we can preallocate to make it more efficient..
 170     int64 availableData = source.getTotalLength() - source.getPosition();
 171
 172     if (availableData > 0)
 173     {
 174         if (maxNumBytesToWrite > availableData || maxNumBytesToWrite < 0)
 175             maxNumBytesToWrite = availableData;
 176
 177         preallocate (blockToUse.getSize() + (size_t) maxNumBytesToWrite);
 178     }
 179
 180     return OutputStream::writeFromInputStream (source, maxNumBytesToWrite);
 181 }
 182
 183 String MemoryOutputStream::toUTF8() const
 184 {
 185     const char* const d = static_cast<const char*> (getData());
 186     return String (CharPointer_UTF8 (d), CharPointer_UTF8 (d + getDataSize()));
 187 }
 188
 189 String MemoryOutputStream::toString() const
 190 {
 191     return String::createStringFromData (getData(), (int) getDataSize());
 192 }
 193
 194 OutputStream&  operator<< (OutputStream& stream, const MemoryOutputStream& streamToRead)
 195 {
 196     const size_t dataSize = streamToRead.getDataSize();
 197
 198     if (dataSize > 0)
 199         stream.write (streamToRead.getData(), dataSize);
 200
 201     return stream;
 202 }
 203
 204 }