dali/internal/event/images/bitmap-packed-pixel.h

   1 #ifndef __DALI_INTERNAL_BITMAP_H__
   2 #define __DALI_INTERNAL_BITMAP_H__
   3
   4 /*
   5  * Copyright (c) 2014 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 // EXTERNAL INCLUDES
  22
  23 // INTERNAL INCLUDES
  24 #include <dali/integration-api/bitmap.h>
  25
  26 namespace Dali
  27 {
  28 namespace Internal
  29 {
  30
  31 class BitmapPackedPixel;
  32 typedef IntrusivePtr<BitmapPackedPixel>        BitmapPackedPixelPtr;
  33
  34 /**
  35  * BitmapPackedPixel class.
  36  * A container for image data that is packed into individual struct-like
  37  * pixels in an addressable 2D array, with each pixel occupying a whole
  38  * number of bytes.
  39  * This is a vanilla Bitmap class, typically used to hold data decompressed
  40  * from PNG and JPEG file formats for example.
  41  *
  42  * \sa{Bitmap BitmapCompressed BitmapExternal}
  43  */
  44 class BitmapPackedPixel : public Dali::Integration::Bitmap, Dali::Integration::Bitmap::PackedPixelsProfile
  45 {
  46 public:
  47   /**
  48    * Constructor
  49    * @param[in] discardable Flag to tell the bitmap if it can delete the buffer with the pixel data.
  50    */
  51   BitmapPackedPixel( ResourcePolicy::Discardable discardable = ResourcePolicy::RETAIN, Dali::Integration::PixelBuffer* pixBuf = 0 );
  52
  53 public:
  54   virtual const Bitmap::PackedPixelsProfile* GetPackedPixelsProfile() const { return this; }
  55   virtual Bitmap::PackedPixelsProfile* GetPackedPixelsProfile() { return this; }
  56
  57   /**
  58    * (Re-)Allocate pixel buffer for the Bitmap. Any previously allocated pixel buffer is deleted.
  59    * Dali has ownership of the buffer, but its contents can be modified.
  60    * Bitmap stores given size information about the image.
  61    * @pre bufferWidth, bufferHeight have to be power of two
  62    * @param[in] pixelFormat   pixel format
  63    * @param[in] width         Image width in pixels
  64    * @param[in] height        Image height in pixels
  65    * @param[in] bufferWidth   Buffer width (stride) in pixels
  66    * @param[in] bufferHeight  Buffer height in pixels
  67    * @return pixel buffer pointer
  68    */
  69   virtual Dali::Integration::PixelBuffer* ReserveBuffer(Pixel::Format pixelFormat,
  70                                      unsigned int width,
  71                                      unsigned int height,
  72                                      unsigned int bufferWidth = 0,
  73                                      unsigned int bufferHeight = 0);
  74
  75   /**
  76    * Assign a pixel buffer. Any previously allocated pixel buffer is deleted.
  77    * Dali has ownership of the buffer, but its contents can be modified.
  78    * Bitmap stores given size information about the image.
  79    * @pre bufferWidth, bufferHeight have to be power of two
  80    * @param[in] pixelFormat   pixel format
  81    * @param[in] buffer        the pixel buffer
  82    * @param[in] bufferSize    size of the pixel buffer
  83    * @param[in] width         Image width in pixels
  84    * @param[in] height        Image height in pixels
  85    * @param[in] bufferWidth   Buffer width (stride) in pixels
  86    * @param[in] bufferHeight  Buffer height in pixels
  87    */
  88   virtual void AssignBuffer(Pixel::Format pixelFormat,
  89                             Dali::Integration::PixelBuffer* buffer,
  90                             std::size_t bufferSize,
  91                             unsigned int width,
  92                             unsigned int height,
  93                             unsigned int bufferWidth = 0,
  94                             unsigned int bufferHeight = 0);
  95
  96   /**
  97    * Get the width of the buffer (stride)
  98    * @return The width of the buffer in pixels
  99    */
 100   virtual unsigned GetBufferWidth() const
 101   {
 102     return mBufferWidth;
 103   }
 104
 105   /**
 106    * Get the height of the buffer
 107    * @return The height of the buffer in pixels
 108    */
 109   virtual unsigned GetBufferHeight() const
 110   {
 111     return mBufferHeight;
 112   }
 113
 114   /**
 115    * Get the pixel buffer size in bytes
 116    * @return The buffer size in bytes.
 117    */
 118   // unsigned int GetBufferSize() const
 119   virtual size_t GetBufferSize() const
 120   {
 121     return mBufferWidth*mBytesPerPixel*mBufferHeight;
 122   }
 123
 124   /**
 125    * Get the pixel buffer stride.
 126    * @return The buffer stride (in bytes).
 127    */
 128   virtual unsigned int GetBufferStride() const;
 129   //{
 130   //  return mBufferWidth*mBytesPerPixel;
 131   //}
 132
 133   /**
 134    * Get the pixel format
 135    * @return The pixel format
 136    */
 137   Pixel::Format GetPixelFormat() const
 138   {
 139     return mPixelFormat;
 140   }
 141
 142   /**
 143    * Check the bitmap data and test whether it has any transparent pixels.
 144    * This property can then be tested for with IsFullyOpaque().
 145    */
 146   virtual void TestForTransparency();
 147
 148 protected:
 149
 150   /**
 151    * A reference counted object may only be deleted by calling Unreference()
 152    */
 153   virtual ~BitmapPackedPixel();
 154
 155 protected:
 156
 157   unsigned int  mBufferWidth;         ///< Buffer width (stride) in pixels
 158   unsigned int  mBufferHeight;        ///< Buffer height in pixels
 159   unsigned int  mBytesPerPixel;       ///< Bytes per pixel
 160
 161 private:
 162
 163   /**
 164    * Initializes internal class members
 165    * @param[in] pixelFormat   pixel format
 166    * @param[in] width         Image width in pixels
 167    * @param[in] height        Image height in pixels
 168    * @param[in] bufferWidth   Buffer width (stride) in pixels
 169    * @param[in] bufferHeight  Buffer height in pixels
 170    */
 171   void Initialize(Pixel::Format pixelFormat,
 172                            unsigned int width,
 173                            unsigned int height,
 174                            unsigned int bufferWidth,
 175                            unsigned int bufferHeight);
 176
 177
 178   BitmapPackedPixel(const BitmapPackedPixel& other);  ///< defined private to prevent use
 179   BitmapPackedPixel& operator = (const BitmapPackedPixel& other); ///< defined private to prevent use
 180
 181   // Changes scope, should be at end of class
 182   DALI_LOG_OBJECT_STRING_DECLARATION;
 183 };
 184
 185 } // namespace Integration
 186
 187 } // namespace Dali
 188
 189 #endif // __DALI_INTERNAL_BITMAP_H__