dali/internal/imaging/common/pixel-buffer-impl.h

   1 #ifndef DALI_INTERNAL_ADAPTOR_PIXEL_BUFFER_H
   2 #define DALI_INTERNAL_ADAPTOR_PIXEL_BUFFER_H
   3
   4 /*
   5  * Copyright (c) 2019 Samsung Electronics Co., Ltd.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  * http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  */
  20
  21 // INTERNAL INCLUDES
  22 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
  23 #include <dali/public-api/images/image-operations.h> // For ImageDimensions
  24 #include <dali/public-api/images/pixel-data.h>
  25 #include <dali/public-api/object/base-object.h>
  26 #include <dali/public-api/object/property-map.h>
  27
  28 // EXTERNAL INCLUDES
  29 #include <memory>
  30
  31 namespace Dali
  32 {
  33
  34 namespace Internal
  35 {
  36
  37 namespace Adaptor
  38 {
  39
  40 class PixelBuffer;
  41 typedef IntrusivePtr<PixelBuffer> PixelBufferPtr;
  42
  43 class PixelBuffer : public BaseObject
  44 {
  45 public:
  46
  47   /**
  48    * @brief Create a PixelBuffer object with a pre-allocated buffer.
  49    * The PixelBuffer object owns this buffer, which may be retrieved
  50    * and modified using GetBuffer().
  51    *
  52    * @param [in] width            Buffer width in pixels
  53    * @param [in] height           Buffer height in pixels
  54    * @param [in] pixelFormat      The pixel format
  55    */
  56   static PixelBufferPtr New( unsigned int width,
  57                              unsigned int height,
  58                              Pixel::Format pixelFormat );
  59
  60   /**
  61    * @brief Create a PixelBuffer object. For internal use only.
  62    *
  63    * @param [in] buffer           The raw pixel data.
  64    * @param [in] bufferSize       The size of the buffer in bytes
  65    * @param [in] width            Buffer width in pixels
  66    * @param [in] height           Buffer height in pixels
  67    * @param [in] pixelFormat      The pixel format
  68    * @param [in] releaseFunction  The function used to release the memory.
  69    */
  70   static PixelBufferPtr New( unsigned char* buffer,
  71                              unsigned int bufferSize,
  72                              unsigned int width,
  73                              unsigned int height,
  74                              Pixel::Format pixelFormat );
  75
  76   /**
  77    * Convert a pixelBuffer object into a PixelData object.
  78    * The new object takes ownership of the buffer data, and the
  79    * mBuffer pointer is reset to NULL.
  80    * @param[in] pixelBuffer The buffer to convert
  81    * @return the pixelData
  82    */
  83   static Dali::PixelData Convert( PixelBuffer& pixelBuffer );
  84
  85   /**
  86    * @brief Constructor.
  87    *
  88    * @param [in] buffer           The raw pixel data.
  89    * @param [in] bufferSize       The size of the buffer in bytes
  90    * @param [in] width            Buffer width in pixels
  91    * @param [in] height           Buffer height in pixels
  92    * @param [in] pixelFormat      The pixel format
  93    */
  94   PixelBuffer( unsigned char* buffer,
  95                unsigned int bufferSize,
  96                unsigned int width,
  97                unsigned int height,
  98                Pixel::Format pixelFormat );
  99
 100 protected:
 101
 102   /**
 103    * @brief Destructor.
 104    *
 105    * Release the pixel buffer if exists.
 106    */
 107   ~PixelBuffer() override;
 108
 109 public:
 110
 111   /**
 112    * Get the width of the buffer in pixels.
 113    * @return The width of the buffer in pixels
 114    */
 115   unsigned int GetWidth() const;
 116
 117   /**
 118    * Get the height of the buffer in pixels
 119    * @return The height of the buffer in pixels
 120    */
 121   unsigned int GetHeight() const;
 122
 123   /**
 124    * Get the pixel format
 125    * @return The pixel format
 126    */
 127   Pixel::Format GetPixelFormat() const;
 128
 129   /**
 130    * Get the pixel buffer if it's present.
 131    * @return The buffer if exists, or NULL if there is no pixel buffer.
 132    */
 133   unsigned char* GetBuffer() const;
 134
 135   /**
 136    * @copydoc Devel::PixelBuffer::GetBuffer()
 137    */
 138   const unsigned char* const GetConstBuffer() const;
 139
 140   /**
 141    * Get the size of the buffer in bytes
 142    * @return The size of the buffer
 143    */
 144   unsigned int GetBufferSize() const;
 145
 146   /**
 147    * Copy the buffer into a new PixelData
 148    */
 149   Dali::PixelData CreatePixelData() const;
 150
 151   /**
 152    * @brief Apply the mask to the current buffer.
 153    *
 154    * This method may update the internal object - e.g. the new buffer
 155    * may have a different pixel format - as an alpha channel may be
 156    * added.
 157    * @param[in] mask The mask to apply to this pixel buffer
 158    * @param[in] contentScale The scaling factor to apply to the content
 159    * @param[in] cropToMask Whether to crop the output to the mask size (true) or scale the
 160    * mask to the content size (false)
 161    */
 162   void ApplyMask( const PixelBuffer& mask, float contentScale, bool cropToMask );
 163
 164   /**
 165    * @brief Apply a Gaussian blur to the current buffer with the given radius.
 166    *
 167    * @param[in] blurRadius The radius for Gaussian blur
 168    */
 169   void ApplyGaussianBlur( const float blurRadius );
 170
 171   /**
 172    * Crops this buffer to the given crop rectangle. Assumes the crop rectangle
 173    * is within the bounds of this size.
 174    * @param[in] x The top left corner's X
 175    * @param[in] y The top left corner's y
 176    * @param[in] cropDimensions The dimensions of the crop
 177    */
 178   void Crop( uint16_t x, uint16_t y, ImageDimensions cropDimensions );
 179
 180   /**
 181    * Resizes the buffer to the given dimensions. Uses either Lanczos4 for downscaling
 182    * or Mitchell for upscaling
 183    * @param[in] outDimensions The new dimensions
 184    */
 185   void Resize( ImageDimensions outDimensions );
 186
 187   /**
 188    * Multiplies the image's color values by the alpha value. This provides better
 189    * blending capability.
 190    */
 191   void MultiplyColorByAlpha();
 192
 193   /**
 194    * @brief Sets image metadata
 195    *
 196    * @param map Property map containing Exif fields
 197    */
 198   void SetMetadata( const Property::Map& map );
 199
 200   /**
 201    * @brief Returns image metadata as a property map
 202    * @param[out] outMetadata Property map to copy the data into
 203    * @return True on success
 204    */
 205   bool GetMetadata(Property::Map& outMetadata) const;
 206
 207   /**
 208    * @brief Sets metadata property map for the pixel buffer
 209    * @note The function takes over the ownership of the property map
 210    * @param[in] metadata Property map to copy the data into
 211    */
 212   void SetMetadata(std::unique_ptr<Property::Map> metadata);
 213
 214   /**
 215    * Allocates fixed amount of memory for the pixel data. Used by compressed formats.
 216    * @param[in] size Size of memory to be allocated
 217    */
 218   void AllocateFixedSize( uint32_t size );
 219
 220   /**
 221    * @copydoc Devel::PixelBuffer::Rotate()
 222    */
 223   bool Rotate( Degree angle );
 224
 225   /**
 226    * @copydoc Devel::PixelBuffer::IsAlphaPreMultiplied()
 227    */
 228   bool IsAlphaPreMultiplied() const;
 229
 230 private:
 231   /*
 232    * Undefined copy constructor.
 233    */
 234   PixelBuffer(const PixelBuffer& other);
 235
 236   /*
 237    * Undefined assignment operator.
 238    */
 239   PixelBuffer& operator= (const PixelBuffer& other);
 240
 241   /**
 242    * Internal method to apply the mask to this buffer. Expects that they are the same size.
 243    */
 244   void ApplyMaskInternal( const PixelBuffer& mask );
 245
 246   /**
 247    * Takes ownership of the other object's pixel buffer.
 248    */
 249   void TakeOwnershipOfBuffer( PixelBuffer& pixelBuffer );
 250
 251   /**
 252    * Release the buffer
 253    */
 254   void ReleaseBuffer();
 255
 256   /**
 257    * Scales this buffer buffer by the given factor, and crops at the center to the
 258    * given dimensions.
 259    */
 260   void ScaleAndCrop( float scaleFactor, ImageDimensions cropDimensions );
 261
 262   /**
 263    * Creates a new buffer which is a crop of the passed in buffer,
 264    * using the given crop rectangle. Assumes the crop rectangle is
 265    * within the bounds of this size.
 266    * @param[in] inBuffer The source buffer
 267    * @param[in] x The top left corner's X
 268    * @param[in] y The top left corner's y
 269    * @param[in] cropDimensions The dimensions of the crop
 270    * @return the new pixel buffer
 271    */
 272   static PixelBufferPtr NewCrop( const PixelBuffer& inBuffer, uint16_t x, uint16_t y, ImageDimensions cropDimensions );
 273
 274   /**
 275    * Creates a new buffer which is a resized version of the passed in buffer.
 276    * Uses either Lanczos4 for downscaling, or Mitchell for upscaling.
 277    * @param[in] inBuffer The source buffer
 278    * @param[in] outDimensions The new dimensions
 279    * @return a new buffer of the given size.
 280    */
 281   static PixelBufferPtr NewResize( const PixelBuffer& inBuffer, ImageDimensions outDimensions );
 282
 283 private:
 284
 285   std::unique_ptr<Property::Map>  mMetadata;         ///< Metadata fields
 286   unsigned char*                  mBuffer;           ///< The raw pixel data
 287   unsigned int                    mBufferSize;       ///< Buffer sized in bytes
 288   unsigned int                    mWidth;            ///< Buffer width in pixels
 289   unsigned int                    mHeight;           ///< Buffer height in pixels
 290   Pixel::Format                   mPixelFormat;      ///< Pixel format
 291   bool                            mPreMultiplied; ///< PreMultiplied
 292 };
 293
 294 } // namespace Adaptor
 295
 296 } // namespace Internal
 297
 298 /**
 299  * Helper methods for public API
 300  */
 301 inline Internal::Adaptor::PixelBuffer& GetImplementation( Devel::PixelBuffer& handle )
 302 {
 303   DALI_ASSERT_ALWAYS( handle && "handle is empty" );
 304
 305   BaseObject& object = handle.GetBaseObject();
 306
 307   return static_cast<Internal::Adaptor::PixelBuffer&>( object );
 308 }
 309
 310 inline const Internal::Adaptor::PixelBuffer& GetImplementation( const Devel::PixelBuffer& handle )
 311 {
 312   DALI_ASSERT_ALWAYS( handle && "handle is empty" );
 313
 314   const BaseObject& object = handle.GetBaseObject();
 315
 316   return static_cast<const Internal::Adaptor::PixelBuffer&>( object );
 317 }
 318
 319 } // namespace Dali
 320
 321 #endif // DALI_INTERNAL_ADAPTOR_PIXEL_BUFFER_H