adaptors/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) 2017 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 <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
  27 namespace Dali
  28 {
  29
  30 namespace Internal
  31 {
  32
  33 namespace Adaptor
  34 {
  35
  36 class PixelBuffer;
  37 typedef IntrusivePtr<PixelBuffer> PixelBufferPtr;
  38
  39 class PixelBuffer : public BaseObject
  40 {
  41 public:
  42
  43   /**
  44    * @brief Create a PixelBuffer object with a pre-allocated buffer.
  45    * The PixelBuffer object owns this buffer, which may be retrieved
  46    * and modified using GetBuffer().
  47    *
  48    * @param [in] width            Buffer width in pixels
  49    * @param [in] height           Buffer height in pixels
  50    * @param [in] pixelFormat      The pixel format
  51    */
  52   static PixelBufferPtr New( unsigned int width,
  53                              unsigned int height,
  54                              Pixel::Format pixelFormat );
  55
  56   /**
  57    * @brief Create a PixelBuffer object. For internal use only.
  58    *
  59    * @param [in] buffer           The raw pixel data.
  60    * @param [in] bufferSize       The size of the buffer in bytes
  61    * @param [in] width            Buffer width in pixels
  62    * @param [in] height           Buffer height in pixels
  63    * @param [in] pixelFormat      The pixel format
  64    * @param [in] releaseFunction  The function used to release the memory.
  65    */
  66   static PixelBufferPtr New( unsigned char* buffer,
  67                              unsigned int bufferSize,
  68                              unsigned int width,
  69                              unsigned int height,
  70                              Pixel::Format pixelFormat );
  71
  72   /**
  73    * Convert a pixelBuffer object into a PixelData object.
  74    * The new object takes ownership of the buffer data, and the
  75    * mBuffer pointer is reset to NULL.
  76    * @param[in] pixelBuffer The buffer to convert
  77    * @return the pixelData
  78    */
  79   static Dali::PixelData Convert( PixelBuffer& pixelBuffer );
  80
  81   /**
  82    * @brief Constructor.
  83    *
  84    * @param [in] buffer           The raw pixel data.
  85    * @param [in] bufferSize       The size of the buffer in bytes
  86    * @param [in] width            Buffer width in pixels
  87    * @param [in] height           Buffer height in pixels
  88    * @param [in] pixelFormat      The pixel format
  89    */
  90   PixelBuffer( unsigned char* buffer,
  91                unsigned int bufferSize,
  92                unsigned int width,
  93                unsigned int height,
  94                Pixel::Format pixelFormat );
  95
  96 protected:
  97
  98   /**
  99    * @brief Destructor.
 100    *
 101    * Release the pixel buffer if exists.
 102    */
 103   ~PixelBuffer();
 104
 105 public:
 106
 107   /**
 108    * Get the width of the buffer in pixels.
 109    * @return The width of the buffer in pixels
 110    */
 111   unsigned int GetWidth() const;
 112
 113   /**
 114    * Get the height of the buffer in pixels
 115    * @return The height of the buffer in pixels
 116    */
 117   unsigned int GetHeight() const;
 118
 119   /**
 120    * Get the pixel format
 121    * @return The pixel format
 122    */
 123   Pixel::Format GetPixelFormat() const;
 124
 125   /**
 126    * Get the pixel buffer if it's present.
 127    * @return The buffer if exists, or NULL if there is no pixel buffer.
 128    */
 129   unsigned char* GetBuffer() const;
 130
 131   /**
 132    * Get the size of the buffer in bytes
 133    * @return The size of the buffer
 134    */
 135   unsigned int GetBufferSize() const;
 136
 137   /**
 138    * Copy the buffer into a new PixelData
 139    */
 140   Dali::PixelData CreatePixelData() const;
 141
 142   /**
 143    * Apply the mask to the current buffer. This method may update the
 144    * internal object - e.g. the new buffer may have a different pixel
 145    * format - as an alpha channel may be added.
 146    * @param[in] mask The mask to apply to this pixel buffer
 147    * @param[in] contentScale The scaling factor to apply to the content
 148    * @param[in] cropToMask Whether to crop the output to the mask size (true) or scale the
 149    * mask to the content size (false)
 150    */
 151   void ApplyMask( const PixelBuffer& mask, float contentScale, bool cropToMask );
 152
 153   /**
 154    * Apply a Gaussian blur to the current buffer with the given radius.
 155    *
 156    * @param[in] blurRadius The radius for Gaussian blur
 157    */
 158   void ApplyGaussianBlur( const float blurRadius );
 159
 160 private:
 161   /*
 162    * Undefined copy constructor.
 163    */
 164   PixelBuffer(const PixelBuffer& other);
 165
 166   /*
 167    * Undefined assignment operator.
 168    */
 169   PixelBuffer& operator= (const PixelBuffer& other);
 170
 171   /**
 172    * Internal method to apply the mask to this buffer. Expects that they are the same size.
 173    */
 174   void ApplyMaskInternal( const PixelBuffer& mask );
 175
 176   /**
 177    * Takes ownership of the other object's pixel buffer.
 178    */
 179   void TakeOwnershipOfBuffer( PixelBuffer& pixelBuffer );
 180
 181   /**
 182    * Release the buffer
 183    */
 184   void ReleaseBuffer();
 185
 186   /**
 187    * Scales this buffer buffer by the given factor, and crops at the center to the
 188    * given dimensions.
 189    */
 190   void ScaleAndCrop( float scaleFactor, ImageDimensions cropDimensions );
 191
 192   /**
 193    * Creates a new buffer which is a crop of the passed in buffer,
 194    * using the given crop rectangle. Assumes the crop rectangle is
 195    * within the bounds of this size.
 196    * @param[in] inBuffer The source buffer
 197    * @param[in] x The top left corner's X
 198    * @param[in] y The top left corner's y
 199    * @param[in] cropDimensions The dimensions of the crop
 200    * @return the new pixel buffer
 201    */
 202   static PixelBufferPtr NewCrop( const PixelBuffer& inBuffer, uint16_t x, uint16_t y, ImageDimensions cropDimensions );
 203
 204   /**
 205    * Creates a new buffer which is a resized version of the passed in buffer.
 206    * Uses either Lanczos4 for downscaling, or Mitchell for upscaling.
 207    * @param[in] inBuffer The source buffer
 208    * @param[in] outDimensions The new dimensions
 209    * @return a new buffer of the given size.
 210    */
 211   static PixelBufferPtr NewResize( const PixelBuffer& inBuffer, ImageDimensions outDimensions );
 212
 213   /**
 214    * Crops this buffer to the given crop rectangle. Assumes the crop rectangle
 215    * is within the bounds of this size.
 216    * @param[in] x The top left corner's X
 217    * @param[in] y The top left corner's y
 218    * @param[in] cropDimensions The dimensions of the crop
 219    */
 220   void Crop( uint16_t x, uint16_t y, ImageDimensions cropDimensions );
 221
 222   /**
 223    * Resizes the buffer to the given dimensions. Uses either Lanczos4 for downscaling
 224    * or Mitchell for upscaling
 225    * @param[in] outDimensions The new dimensions
 226    */
 227   void Resize( ImageDimensions outDimensions );
 228
 229 private:
 230
 231   unsigned char* mBuffer;           ///< The raw pixel data
 232   unsigned int   mBufferSize;       ///< Buffer sized in bytes
 233   unsigned int   mWidth;            ///< Buffer width in pixels
 234   unsigned int   mHeight;           ///< Buffer height in pixels
 235   Pixel::Format  mPixelFormat;      ///< Pixel format
 236 };
 237
 238 } // namespace Adaptor
 239
 240 } // namespace Internal
 241
 242 /**
 243  * Helper methods for public API
 244  */
 245 inline Internal::Adaptor::PixelBuffer& GetImplementation( Devel::PixelBuffer& handle )
 246 {
 247   DALI_ASSERT_ALWAYS( handle && "handle is empty" );
 248
 249   BaseObject& object = handle.GetBaseObject();
 250
 251   return static_cast<Internal::Adaptor::PixelBuffer&>( object );
 252 }
 253
 254 inline const Internal::Adaptor::PixelBuffer& GetImplementation( const Devel::PixelBuffer& handle )
 255 {
 256   DALI_ASSERT_ALWAYS( handle && "handle is empty" );
 257
 258   const BaseObject& object = handle.GetBaseObject();
 259
 260   return static_cast<const Internal::Adaptor::PixelBuffer&>( object );
 261 }
 262
 263 } // namespace Dali
 264
 265 #endif // __DALI_INTERNAL_ADAPTOR_PIXEL_BUFFER_H__