vcl/source/graphic/BinaryDataContainer.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  */
  10
  11 #include <vcl/BinaryDataContainer.hxx>
  12 #include <o3tl/hash_combine.hxx>
  13 #include <unotools/tempfile.hxx>
  14 #include <comphelper/lok.hxx>
  15 #include <comphelper/seqstream.hxx>
  16 #include <sal/log.hxx>
  17
  18 #include <vector>
  19
  20 struct BinaryDataContainer::Impl
  21 {
  22     // temp file to store the data out of RAM if necessary
  23     std::unique_ptr<utl::TempFileFast> mpFile;
  24     // the binary data
  25     std::shared_ptr<std::vector<sal_uInt8>> mpData;
  26
  27     Impl(SvStream& stream, size_t size) { readData(stream, size); }
  28
  29     /// Populate mpData from the stream
  30     void readData(SvStream& stream, size_t size)
  31     {
  32         auto pData = std::make_shared<std::vector<sal_uInt8>>(size);
  33         if (stream.ReadBytes(pData->data(), pData->size()) == size)
  34             mpData = std::move(pData);
  35     }
  36
  37     /// ensure the data is in-RAM
  38     void ensureSwappedIn()
  39     {
  40         if (mpData || !mpFile)
  41             return;
  42
  43         auto pStream = mpFile->GetStream(StreamMode::READ);
  44         pStream->Seek(0);
  45         readData(*pStream, pStream->remainingSize());
  46
  47         // Horrifying data loss ...
  48         SAL_WARN_IF(pStream->GetError(), "vcl",
  49                     "Inconsistent system - failed to swap image back in");
  50     }
  51
  52     void swapOut()
  53     {
  54         if (mpFile)
  55         {
  56             // we already have it swapped out.
  57             mpData.reset();
  58             return;
  59         }
  60
  61         if (!mpData || mpData->empty())
  62             return;
  63
  64         mpFile.reset(new utl::TempFileFast());
  65         auto pStream = mpFile->GetStream(StreamMode::READWRITE);
  66
  67         pStream->WriteBytes(mpData->data(), mpData->size());
  68
  69         mpData.reset();
  70     }
  71 };
  72
  73 BinaryDataContainer::BinaryDataContainer(SvStream& stream, size_t size)
  74     : mpImpl(new Impl(stream, size))
  75 {
  76 }
  77
  78 size_t BinaryDataContainer::calculateHash() const
  79 {
  80     size_t nSeed = 0;
  81     if (mpImpl && mpImpl->mpData && !mpImpl->mpData->empty())
  82     {
  83         o3tl::hash_combine(nSeed, getSize());
  84         for (sal_uInt8 const& rByte : *mpImpl->mpData)
  85             o3tl::hash_combine(nSeed, rByte);
  86     }
  87     return nSeed;
  88 }
  89
  90 css::uno::Sequence<sal_Int8> BinaryDataContainer::getCopyAsByteSequence() const
  91 {
  92     if (isEmpty())
  93         return css::uno::Sequence<sal_Int8>();
  94     assert(mpImpl);
  95
  96     css::uno::Sequence<sal_Int8> aData(getSize());
  97
  98     std::copy(mpImpl->mpData->cbegin(), mpImpl->mpData->cend(), aData.getArray());
  99
 100     return aData;
 101 }
 102
 103 namespace
 104 {
 105 /*
 106  * Hold a reference on the internal state in case we swap out
 107  * and free the vector while someone holds an SvStream pointer.
 108  */
 109 class ReferencedMemoryStream : public SvMemoryStream
 110 {
 111     std::shared_ptr<std::vector<sal_uInt8>> mpData;
 112
 113 public:
 114     ReferencedMemoryStream(const std::shared_ptr<std::vector<sal_uInt8>>& pData)
 115         : SvMemoryStream(pData->data(), pData->size(), StreamMode::READ)
 116         , mpData(pData)
 117     {
 118     }
 119 };
 120
 121 class ReferencedXInputStream : public comphelper::MemoryInputStream
 122 {
 123     std::shared_ptr<std::vector<sal_uInt8>> mpData;
 124
 125 public:
 126     ReferencedXInputStream(const std::shared_ptr<std::vector<sal_uInt8>>& pData)
 127         : comphelper::MemoryInputStream(reinterpret_cast<const sal_Int8*>(pData->data()),
 128                                         pData->size())
 129         , mpData(pData)
 130     {
 131     }
 132 };
 133 }
 134
 135 std::shared_ptr<SvStream> BinaryDataContainer::getAsStream()
 136 {
 137     ensureSwappedIn(); // TODO: transfer in streamed chunks
 138     return std::make_shared<ReferencedMemoryStream>(mpImpl->mpData);
 139 }
 140
 141 css::uno::Reference<css::io::XInputStream> BinaryDataContainer::getAsXInputStream()
 142 {
 143     ensureSwappedIn(); // TODO: transfer in streamed chunks
 144     return new ReferencedXInputStream(mpImpl->mpData);
 145 }
 146
 147 std::size_t BinaryDataContainer::writeToStream(SvStream& rStream) const
 148 {
 149     ensureSwappedIn(); // TODO: transfer in streamed chunks
 150     return rStream.WriteBytes(getData(), getSize());
 151 }
 152
 153 size_t BinaryDataContainer::getSize() const
 154 {
 155     ensureSwappedIn();
 156     return mpImpl && mpImpl->mpData ? mpImpl->mpData->size() : 0;
 157 }
 158
 159 size_t BinaryDataContainer::getSizeBytes() const
 160 {
 161     return mpImpl && mpImpl->mpData ? mpImpl->mpData->size() : 0;
 162 }
 163
 164 bool BinaryDataContainer::isEmpty() const
 165 {
 166     ensureSwappedIn();
 167     return !mpImpl || !mpImpl->mpData || mpImpl->mpData->empty();
 168 }
 169
 170 const sal_uInt8* BinaryDataContainer::getData() const
 171 {
 172     ensureSwappedIn();
 173     return mpImpl && mpImpl->mpData ? mpImpl->mpData->data() : nullptr;
 174 }
 175
 176 void BinaryDataContainer::ensureSwappedIn() const
 177 {
 178     if (mpImpl)
 179         mpImpl->ensureSwappedIn();
 180 }
 181
 182 void BinaryDataContainer::swapOut() const
 183 {
 184     // Only bother reducing memory footprint in kit mode - for mobile/online etc.
 185     if (!mpImpl || !comphelper::LibreOfficeKit::isActive())
 186         return;
 187
 188     mpImpl->swapOut();
 189 }
 190
 191 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */