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 private:
 154   /*
 155    * Undefined copy constructor.
 156    */
 157   PixelBuffer(const PixelBuffer& other);
 158
 159   /*
 160    * Undefined assignment operator.
 161    */
 162   PixelBuffer& operator= (const PixelBuffer& other);
 163
 164   /**
 165    * Internal method to apply the mask to this buffer. Expects that they are the same size.
 166    */
 167   void ApplyMaskInternal( const PixelBuffer& mask );
 168
 169   /**
 170    * Takes ownership of the other object's pixel buffer.
 171    */
 172   void TakeOwnershipOfBuffer( PixelBuffer& pixelBuffer );
 173
 174   /**
 175    * Release the buffer
 176    */
 177   void ReleaseBuffer();
 178
 179   /**
 180    * Scales this buffer buffer by the given factor, and crops at the center to the
 181    * given dimensions.
 182    */
 183   void ScaleAndCrop( float scaleFactor, ImageDimensions cropDimensions );
 184
 185   /**
 186    * Creates a new buffer which is a crop of the passed in buffer,
 187    * using the given crop rectangle. Assumes the crop rectangle is
 188    * within the bounds of this size.
 189    * @param[in] inBuffer The source buffer
 190    * @param[in] x The top left corner's X
 191    * @param[in] y The top left corner's y
 192    * @param[in] cropDimensions The dimensions of the crop
 193    * @return the new pixel buffer
 194    */
 195   static PixelBufferPtr NewCrop( const PixelBuffer& inBuffer, uint16_t x, uint16_t y, ImageDimensions cropDimensions );
 196
 197   /**
 198    * Creates a new buffer which is a resized version of the passed in buffer.
 199    * Uses either Lanczos4 for downscaling, or Mitchell for upscaling.
 200    * @param[in] inBuffer The source buffer
 201    * @param[in] outDimensions The new dimensions
 202    * @return a new buffer of the given size.
 203    */
 204   static PixelBufferPtr NewResize( const PixelBuffer& inBuffer, ImageDimensions outDimensions );
 205
 206   /**
 207    * Crops this buffer to the given crop rectangle. Assumes the crop rectangle
 208    * is within the bounds of this size.
 209    * @param[in] x The top left corner's X
 210    * @param[in] y The top left corner's y
 211    * @param[in] cropDimensions The dimensions of the crop
 212    */
 213   void Crop( uint16_t x, uint16_t y, ImageDimensions cropDimensions );
 214
 215   /**
 216    * Resizes the buffer to the given dimensions. Uses either Lanczos4 for downscaling
 217    * or Mitchell for upscaling
 218    * @param[in] outDimensions The new dimensions
 219    */
 220   void Resize( ImageDimensions outDimensions );
 221
 222 private:
 223
 224   unsigned char* mBuffer;           ///< The raw pixel data
 225   unsigned int   mBufferSize;       ///< Buffer sized in bytes
 226   unsigned int   mWidth;            ///< Buffer width in pixels
 227   unsigned int   mHeight;           ///< Buffer height in pixels
 228   Pixel::Format  mPixelFormat;      ///< Pixel format
 229 };
 230
 231 } // namespace Adaptor
 232
 233 } // namespace Internal
 234
 235 /**
 236  * Helper methods for public API
 237  */
 238 inline Internal::Adaptor::PixelBuffer& GetImplementation( Devel::PixelBuffer& handle )
 239 {
 240   DALI_ASSERT_ALWAYS( handle && "handle is empty" );
 241
 242   BaseObject& object = handle.GetBaseObject();
 243
 244   return static_cast<Internal::Adaptor::PixelBuffer&>( object );
 245 }
 246
 247 inline const Internal::Adaptor::PixelBuffer& GetImplementation( const Devel::PixelBuffer& handle )
 248 {
 249   DALI_ASSERT_ALWAYS( handle && "handle is empty" );
 250
 251   const BaseObject& object = handle.GetBaseObject();
 252
 253   return static_cast<const Internal::Adaptor::PixelBuffer&>( object );
 254 }
 255
 256 } // namespace Dali
 257
 258 #endif // __DALI_INTERNAL_ADAPTOR_PIXEL_BUFFER_H__