sd/source/ui/slidesorter/cache/SlsBitmapCompressor.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  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "SlsBitmapCompressor.hxx"
  21
  22 #include <tools/stream.hxx>
  23 #include <vcl/bitmapex.hxx>
  24 #include <vcl/filter/PngImageReader.hxx>
  25 #include <vcl/filter/PngImageWriter.hxx>
  26
  27 namespace sd::slidesorter::cache {
  28
  29 //===== NoBitmapCompression ===================================================
  30
  31 /** This dummy replacement simply stores a shared pointer to the original
  32     preview bitmap.
  33 */
  34 class NoBitmapCompression::DummyReplacement
  35     : public BitmapReplacement
  36 {
  37 public:
  38     BitmapEx maPreview;
  39
  40     explicit DummyReplacement (const BitmapEx& rPreview) : maPreview(rPreview)  { }
  41     virtual ~DummyReplacement() {}
  42     virtual sal_Int32 GetMemorySize() const override { return maPreview.GetSizeBytes(); }
  43 };
  44
  45 std::shared_ptr<BitmapReplacement> NoBitmapCompression::Compress (const BitmapEx& rBitmap) const
  46 {
  47     return std::make_shared<DummyReplacement>(rBitmap);
  48 }
  49
  50 BitmapEx NoBitmapCompression::Decompress (const BitmapReplacement& rBitmapData) const
  51 {
  52     return dynamic_cast<const DummyReplacement&>(rBitmapData).maPreview;
  53 }
  54
  55 bool NoBitmapCompression::IsLossless() const
  56 {
  57     return true;
  58 }
  59
  60 //===== CompressionByDeletion =================================================
  61
  62 std::shared_ptr<BitmapReplacement> CompressionByDeletion::Compress (const BitmapEx& ) const
  63 {
  64     return std::shared_ptr<BitmapReplacement>();
  65 }
  66
  67 BitmapEx CompressionByDeletion::Decompress (const BitmapReplacement& ) const
  68 {
  69     // Return a NULL pointer.  This will eventually lead to a request for
  70     // the creation of a new one.
  71     return BitmapEx();
  72 }
  73
  74 bool CompressionByDeletion::IsLossless() const
  75 {
  76     return false;
  77 }
  78
  79 //===== ResolutionReduction ===================================================
  80
  81 /** Store a scaled down bitmap together with the original size.
  82 */
  83 class ResolutionReduction::ResolutionReducedReplacement : public BitmapReplacement
  84 {
  85 public:
  86     BitmapEx maPreview;
  87     Size maOriginalSize;
  88
  89     virtual ~ResolutionReducedReplacement();
  90     virtual sal_Int32 GetMemorySize() const override;
  91 };
  92
  93 ResolutionReduction::ResolutionReducedReplacement::~ResolutionReducedReplacement()
  94 {
  95 }
  96
  97 sal_Int32 ResolutionReduction::ResolutionReducedReplacement::GetMemorySize() const
  98 {
  99     return maPreview.GetSizeBytes();
 100 }
 101
 102 std::shared_ptr<BitmapReplacement> ResolutionReduction::Compress (
 103     const BitmapEx& rBitmap) const
 104 {
 105     auto pResult = std::make_shared<ResolutionReducedReplacement>();
 106     pResult->maPreview = rBitmap;
 107     Size aSize (rBitmap.GetSizePixel());
 108     pResult->maOriginalSize = aSize;
 109     if (aSize.Width()>0 && aSize.Width()<mnWidth)
 110     {
 111         int nHeight = aSize.Height() * mnWidth / aSize.Width() ;
 112         pResult->maPreview.Scale(Size(mnWidth,nHeight));
 113     }
 114
 115     return pResult;
 116 }
 117
 118 BitmapEx ResolutionReduction::Decompress (const BitmapReplacement& rBitmapData) const
 119 {
 120     BitmapEx aResult;
 121
 122     const ResolutionReducedReplacement* pData (
 123         dynamic_cast<const ResolutionReducedReplacement*>(&rBitmapData));
 124
 125     if ( pData && ! pData->maPreview.IsEmpty())
 126     {
 127         aResult = pData->maPreview;
 128         if (pData->maOriginalSize.Width() > mnWidth)
 129             aResult.Scale(pData->maOriginalSize);
 130     }
 131
 132     return aResult;
 133 }
 134
 135 bool ResolutionReduction::IsLossless() const
 136 {
 137     return false;
 138 }
 139
 140 //===== PNGCompression ========================================================
 141
 142 class PngCompression::PngReplacement : public BitmapReplacement
 143 {
 144 public:
 145     void* mpData;
 146     sal_Int32 mnDataSize;
 147     PngReplacement()
 148         : mpData(nullptr),
 149           mnDataSize(0)
 150     {}
 151     virtual ~PngReplacement()
 152     {
 153         delete [] static_cast<char*>(mpData);
 154     }
 155     virtual sal_Int32 GetMemorySize() const override
 156     {
 157         return mnDataSize;
 158     }
 159 };
 160
 161 std::shared_ptr<BitmapReplacement> PngCompression::Compress (const BitmapEx& rBitmap) const
 162 {
 163     SvMemoryStream aStream (32768, 32768);
 164     vcl::PngImageWriter aWriter(aStream);
 165     aWriter.write(rBitmap);
 166
 167     auto pResult = std::make_shared<PngReplacement>();
 168     pResult->mnDataSize = aStream.Tell();
 169     pResult->mpData = new char[pResult->mnDataSize];
 170     memcpy(pResult->mpData, aStream.GetData(), pResult->mnDataSize);
 171
 172     return pResult;
 173 }
 174
 175 BitmapEx PngCompression::Decompress (
 176     const BitmapReplacement& rBitmapData) const
 177 {
 178     BitmapEx aResult;
 179     const PngReplacement* pData (dynamic_cast<const PngReplacement*>(&rBitmapData));
 180     if (pData != nullptr)
 181     {
 182         SvMemoryStream aStream (pData->mpData, pData->mnDataSize, StreamMode::READ);
 183         vcl::PngImageReader aReader (aStream);
 184         aResult = aReader.read().GetBitmap();
 185     }
 186
 187     return aResult;
 188 }
 189
 190 bool PngCompression::IsLossless() const
 191 {
 192     return true;
 193 }
 194
 195 } // end of namespace ::sd::slidesorter::cache
 196
 197 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */