dali/internal/render/gl-resources/bitmap-texture.cpp

   1 /*
   2  * Copyright (c) 2014 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include <dali/internal/render/gl-resources/bitmap-texture.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <math.h>
  23 #include <memory.h>
  24
  25 // INTERNAL INCLUDES
  26 #include <dali/public-api/math/rect.h>
  27 #include <dali/public-api/math/math-utils.h>
  28 #include <dali/integration-api/debug.h>
  29 #include <dali/internal/render/common/vertex.h>
  30 #include <dali/internal/render/common/performance-monitor.h>
  31 #include <dali/internal/render/gl-resources/context.h>
  32
  33 namespace Dali
  34 {
  35
  36 namespace Internal
  37 {
  38
  39 BitmapTexture::BitmapTexture(Integration::Bitmap* const bitmap, const Integration::Bitmap::PackedPixelsProfile * const bitmapPackedPixelsProfile, Context& context)
  40 : Texture(context,
  41           bitmapPackedPixelsProfile->GetBufferWidth(),
  42           bitmapPackedPixelsProfile->GetBufferHeight(),
  43           bitmap->GetImageWidth(),
  44           bitmap->GetImageHeight(),
  45           bitmap->GetPixelFormat()),
  46   mBitmap(bitmap),
  47   mClearPixels(false)
  48 {
  49   DALI_LOG_TRACE_METHOD(Debug::Filter::gImage);
  50   DALI_LOG_SET_OBJECT_STRING(this, DALI_LOG_GET_OBJECT_STRING(bitmap));
  51 }
  52
  53 BitmapTexture::BitmapTexture(
  54   unsigned int  width,
  55   unsigned int  height,
  56   Pixel::Format pixelFormat,
  57   bool          clearPixels,
  58   Context&      context)
  59 : Texture(context,
  60           width, height,
  61           width, height,
  62           pixelFormat),
  63   mBitmap(NULL),
  64   mClearPixels(clearPixels)
  65 {
  66   DALI_LOG_TRACE_METHOD(Debug::Filter::gImage);
  67 }
  68
  69 BitmapTexture::~BitmapTexture()
  70 {
  71   DALI_LOG_TRACE_METHOD(Debug::Filter::gImage);
  72   // GlCleanup() should already have been called by TextureCache ensuring the resource is destroyed
  73   // on the render thread. (And avoiding a potentially problematic virtual call in the destructor)
  74 }
  75
  76 void BitmapTexture::UploadBitmapArray( const BitmapUploadArray& bitmapArray )
  77 {
  78   if( mId == 0 )
  79   {
  80     CreateGlTexture();
  81   }
  82
  83   mContext.ActiveTexture(GL_TEXTURE7);  // bind in unused unit so rebind works the first time
  84   mContext.Bind2dTexture(mId);
  85   mContext.PixelStorei(GL_UNPACK_ALIGNMENT, 1); // We always use tightly packed data
  86
  87   GLenum pixelFormat   = GL_RGBA;
  88   GLenum pixelDataType = GL_UNSIGNED_BYTE;
  89
  90   Integration::ConvertToGlFormat(mPixelFormat, pixelDataType, pixelFormat);
  91
  92   // go through each bitmap uploading it
  93
  94   for( BitmapUploadArray::const_iterator iter =  bitmapArray.begin(), endIter = bitmapArray.end(); iter != endIter ; ++iter)
  95   {
  96     const BitmapUpload& bitmapItem((*iter));
  97
  98     DALI_ASSERT_ALWAYS(bitmapItem.mPixelData);
  99
 100     const unsigned char* pixels = bitmapItem.mPixelData;
 101
 102     DALI_ASSERT_DEBUG( (pixels!=NULL) && "bitmap has no data \n");
 103
 104     unsigned int bitmapWidth(bitmapItem.mWidth);
 105     unsigned int bitmapHeight(bitmapItem.mHeight);
 106
 107     DALI_LOG_INFO(Debug::Filter::gImage, Debug::General, "upload bitmap to texture :%d y:%d w:%d h:%d\n",
 108                             bitmapItem.mXpos,
 109                             bitmapItem.mYpos,
 110                             bitmapWidth,
 111                             bitmapHeight);
 112
 113      mContext.TexSubImage2D(GL_TEXTURE_2D,
 114                             0,                   /* mip map level */
 115                             bitmapItem.mXpos,    /* X pos */
 116                             bitmapItem.mYpos,    /* Y pos */
 117                             bitmapWidth,         /* width */
 118                             bitmapHeight,        /* height */
 119                             pixelFormat,         /* our bitmap format (should match internal format) */
 120                             pixelDataType,       /* pixel data type */
 121                             pixels);             /* texture data */
 122
 123      if( BitmapUpload::DISCARD_PIXEL_DATA == bitmapItem.mDiscard)
 124      {
 125        delete [] bitmapItem.mPixelData;
 126      }
 127   }
 128 }
 129
 130 bool BitmapTexture::HasAlphaChannel() const
 131 {
 132   return Pixel::HasAlpha(mPixelFormat);
 133 }
 134
 135 bool BitmapTexture::IsFullyOpaque() const
 136 {
 137   if( mBitmap )
 138   {
 139     return mBitmap->IsFullyOpaque();
 140   }
 141   else
 142   {
 143     return ! HasAlphaChannel(); // Todo: amalgamate updated bitmap's IsFullyOpaque()
 144   }
 145 }
 146
 147 // Bitmap buffer has been changed. Upload changes to GPU.
 148 void BitmapTexture::AreaUpdated( const RectArea& updateArea, const unsigned char* pixels )
 149 {
 150   DALI_LOG_TRACE_METHOD(Debug::Filter::gImage);
 151   DALI_LOG_INFO(Debug::Filter::gGLResource, Debug::Verbose, "BitmapTexture::AreaUpdated()\n");
 152
 153   GLenum pixelFormat   = GL_RGBA;
 154   GLenum pixelDataType = GL_UNSIGNED_BYTE;
 155   Integration::ConvertToGlFormat(mPixelFormat, pixelDataType, pixelFormat);
 156
 157   mContext.ActiveTexture(GL_TEXTURE7);  // bind in unused unit so rebind works the first time
 158
 159   mContext.Bind2dTexture(mId);
 160
 161   if( ! updateArea.IsEmpty() )
 162   {
 163     mContext.PixelStorei( GL_UNPACK_ALIGNMENT, 1 ); // We always use tightly packed data
 164     DALI_LOG_INFO( Debug::Filter::gImage, Debug::General, "Update x:%d y:%d w:%d h:%d\n",
 165                    updateArea.x, updateArea.y, updateArea.width ,updateArea.height );
 166
 167     // TODO: obtain pitch of source image, obtain pixel depth of source image.
 168     const unsigned int pitchPixels = mImageWidth;
 169     const unsigned int pixelDepth = sizeof(unsigned int);
 170
 171     // If the width of the source update area is the same as the pitch, then can
 172     // copy the contents in a single contiguous TexSubImage call.
 173     if(updateArea.x == 0 && updateArea.width == pitchPixels)
 174     {
 175       pixels += updateArea.y * pitchPixels * pixelDepth;
 176       mContext.TexSubImage2D( GL_TEXTURE_2D,0, updateArea.x, updateArea.y,
 177                               updateArea.width, updateArea.height,
 178                               pixelFormat, pixelDataType, pixels );
 179     }
 180     else
 181     {
 182       // Otherwise the source buffer needs to be copied line at a time, as OpenGL ES
 183       // does not support source strides. (no GL_UNPACK_ROW_LENGTH supported)
 184       unsigned int yBottom = updateArea.y + updateArea.height;
 185       pixels += (updateArea.y * pitchPixels + updateArea.x) * pixelDepth;
 186
 187       for(unsigned int y = updateArea.y; y < yBottom; y++)
 188       {
 189         mContext.TexSubImage2D( GL_TEXTURE_2D,0, updateArea.x, y,
 190                                 updateArea.width, 1,
 191                                 pixelFormat, pixelDataType, pixels );
 192         pixels += pitchPixels * pixelDepth;
 193       }
 194     }
 195
 196     INCREASE_BY( PerformanceMonitor::TEXTURE_DATA_UPLOADED,
 197                  updateArea.Area()* GetBytesPerPixel( mPixelFormat ));
 198   }
 199 }
 200
 201
 202 void BitmapTexture::AssignBitmap( bool generateTexture, const unsigned char* pixels )
 203 {
 204   DALI_LOG_TRACE_METHOD(Debug::Filter::gImage);
 205   DALI_LOG_INFO(Debug::Filter::gGLResource, Debug::Verbose, "BitmapTexture::AssignBitmap()\n");
 206
 207   GLenum pixelFormat = GL_RGBA;
 208   GLenum pixelDataType = GL_UNSIGNED_BYTE;
 209
 210   if( generateTexture )
 211   {
 212     mContext.GenTextures(1, &mId);
 213   }
 214   DALI_ASSERT_DEBUG( mId != 0 );
 215
 216   mContext.ActiveTexture(GL_TEXTURE7); // bind in unused unit so rebind works the first time
 217   mContext.Bind2dTexture(mId);
 218   Integration::ConvertToGlFormat(mPixelFormat, pixelDataType, pixelFormat);
 219
 220   mContext.PixelStorei(GL_UNPACK_ALIGNMENT, 1); // We always use tightly packed data
 221   mContext.TexImage2D(GL_TEXTURE_2D, 0, pixelFormat, mWidth, mHeight, 0, pixelFormat, pixelDataType, pixels);
 222   mContext.TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 223   mContext.TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 224
 225   INCREASE_BY( PerformanceMonitor::TEXTURE_DATA_UPLOADED, GetBytesPerPixel(mPixelFormat) * mWidth * mHeight );
 226 }
 227
 228 void BitmapTexture::Update( Integration::Bitmap* bitmap )
 229 {
 230   DALI_LOG_INFO( Debug::Filter::gGLResource, Debug::General, "BitmapTexture::Update(bitmap:%p )\n", bitmap );
 231   DALI_ASSERT_DEBUG( bitmap != 0 );
 232   if( !bitmap )
 233   {
 234     DALI_LOG_ERROR( "Passed a null bitmap to update this bitmap texture." );
 235     return;
 236   }
 237
 238   // Only Packed-pixel bitmaps are ever associated with BitmapTextures, so we should never be passed any other kind:
 239   const Integration::Bitmap::PackedPixelsProfile * const bitmapPackedPixels = bitmap->GetPackedPixelsProfile();
 240   DALI_ASSERT_DEBUG(bitmapPackedPixels);
 241   if( !bitmapPackedPixels )
 242   {
 243     ///! This should never happen.
 244     DALI_LOG_ERROR("Passed an incompatible bitmap type to update this bitmap texture.");
 245     return;
 246   }
 247   mBitmap = bitmap;
 248
 249   const unsigned char* pixels = mBitmap->GetBuffer();
 250
 251   DALI_ASSERT_DEBUG( pixels != NULL );
 252
 253   if ( NULL == pixels )
 254   {
 255     DALI_LOG_ERROR("bitmap has no data\n");
 256     GlCleanup(); // Note, We suicide here in the case of bad input.
 257   }
 258   else
 259   {
 260     if( mImageWidth == mBitmap->GetImageWidth() &&
 261         mImageHeight == mBitmap->GetImageHeight() &&
 262         mWidth  == bitmapPackedPixels->GetBufferWidth() &&
 263         mHeight == bitmapPackedPixels->GetBufferHeight() &&
 264         mPixelFormat == mBitmap->GetPixelFormat() ) // and size hasn't changed
 265     {
 266       if ( mId ) // If the texture is already bound
 267       {
 268         RectArea area(0, 0, mImageWidth, mImageHeight);  // just update whole texture
 269         AreaUpdated( area, pixels );
 270         mBitmap->DiscardBuffer();
 271       }
 272     }
 273     else
 274     {                                           // Otherwise, reload the pixel data
 275       mImageWidth  = mBitmap->GetImageWidth();
 276       mImageHeight = mBitmap->GetImageHeight();
 277       mWidth       = bitmapPackedPixels->GetBufferWidth();
 278       mHeight      = bitmapPackedPixels->GetBufferHeight();
 279       mPixelFormat = mBitmap->GetPixelFormat();
 280
 281       if ( mId ) // If the texture is already bound
 282       {
 283         AssignBitmap( false, pixels );
 284         mBitmap->DiscardBuffer();
 285       }
 286     }
 287   }
 288 }
 289
 290 void BitmapTexture::UpdateArea( const RectArea& updateArea )
 291 {
 292   DALI_LOG_INFO(Debug::Filter::gGLResource, Debug::General, "BitmapTexture::UpdateArea()\n");
 293
 294   if( mBitmap != 0 )
 295   {
 296     const unsigned char* pixels = mBitmap->GetBuffer();
 297     if ( NULL == pixels )
 298     {
 299       DALI_LOG_ERROR("bitmap has no data\n");
 300       GlCleanup(); ///!ToDo: Why do we suicide in the case of bad input?
 301     }
 302     else
 303     {
 304       if ( mId ) // If the texture is already bound
 305       {
 306         if( updateArea.IsEmpty() )
 307         {
 308           RectArea area;
 309           area.x = 0;
 310           area.y = 0;
 311           area.width = mImageWidth;
 312           area.height = mImageHeight;
 313           AreaUpdated( area, pixels );
 314         }
 315         else
 316         {
 317           AreaUpdated( updateArea, pixels );
 318         }
 319       }
 320     }
 321   }
 322 }
 323
 324 void BitmapTexture::ClearAreas( const BitmapClearArray& areaArray, std::size_t blockSize, uint32_t color )
 325 {
 326   if(mId > 0)
 327   {
 328     DALI_LOG_TRACE_METHOD(Debug::Filter::gImage);
 329     DALI_LOG_INFO(Debug::Filter::gGLResource, Debug::Verbose, "BitmapTexture::AreaUpdated()\n");
 330
 331     GLenum pixelFormat   = GL_RGBA;
 332     GLenum pixelDataType = GL_UNSIGNED_BYTE;
 333     Integration::ConvertToGlFormat(mPixelFormat, pixelDataType, pixelFormat);
 334
 335     mContext.ActiveTexture(GL_TEXTURE7);  // bind in unused unit so rebind works the first time
 336     mContext.Bind2dTexture(mId);
 337
 338     size_t numPixels = blockSize*blockSize;
 339     size_t bytesPerPixel = Pixel::GetBytesPerPixel(mPixelFormat);
 340     char* clearPixels = (char*)malloc(numPixels * bytesPerPixel);
 341
 342     for(size_t i=0; i<numPixels; i++)
 343     {
 344       memcpy(&clearPixels[i*bytesPerPixel], &color, bytesPerPixel);
 345     }
 346
 347     for( BitmapClearArray::const_iterator iter =  areaArray.begin(), endIter = areaArray.end(); iter != endIter ; ++iter)
 348     {
 349       const Vector2& clearPos((*iter));
 350
 351       mContext.PixelStorei( GL_UNPACK_ALIGNMENT, 1 ); // We always use tightly packed data
 352       DALI_LOG_INFO( Debug::Filter::gImage, Debug::General, "Update x:%0.2f y:%0.2f w:%d h:%d\n",
 353                      clearPos.x, clearPos.y, blockSize, blockSize );
 354
 355       mContext.TexSubImage2D(GL_TEXTURE_2D,
 356                              0,
 357                              clearPos.x,
 358                              clearPos.y,
 359                              blockSize,
 360                              blockSize,
 361                              pixelFormat,         /* our bitmap format (should match internal format) */
 362                              pixelDataType,       /* pixel data type */
 363                              clearPixels);        /* texture data */
 364
 365       INCREASE_BY( PerformanceMonitor::TEXTURE_DATA_UPLOADED, numPixels * bytesPerPixel );
 366     }
 367     free(clearPixels);
 368   }
 369 }
 370
 371 bool BitmapTexture::UpdateOnCreate()
 372 {
 373   return true;
 374 }
 375
 376 bool BitmapTexture::CreateGlTexture()
 377 {
 378   DALI_LOG_TRACE_METHOD(Debug::Filter::gImage);
 379   DALI_LOG_INFO(Debug::Filter::gImage, Debug::Verbose, "Bitmap: %s\n", DALI_LOG_GET_OBJECT_C_STR(this));
 380
 381   if( mBitmap )
 382   {
 383     const unsigned char* pixels = mBitmap->GetBuffer();
 384
 385     DALI_ASSERT_DEBUG(pixels != NULL);
 386
 387     if( NULL != pixels )
 388     {
 389       AssignBitmap( true, pixels );
 390       mBitmap->DiscardBuffer();
 391     }
 392   }
 393   else
 394   {
 395     const unsigned char* pixels = NULL;
 396     std::vector<unsigned char> pixelData;
 397     if( ( NULL == pixels ) && ( true == mClearPixels ) )
 398     {
 399       unsigned int size = mWidth * mHeight * Pixel::GetBytesPerPixel(mPixelFormat);
 400       pixelData.resize(size, 0);
 401       pixels = &pixelData[0];
 402     }
 403     AssignBitmap( true, pixels );
 404   }
 405
 406   return mId != 0;
 407 }
 408
 409 bool BitmapTexture::Init()
 410 {
 411   DALI_LOG_TRACE_METHOD(Debug::Filter::gImage);
 412   // mBitmap should be initialized by now
 413   return (mBitmap != 0);
 414 }
 415
 416 unsigned int BitmapTexture::GetWidth() const
 417 {
 418   unsigned int width = mWidth;
 419   if( mBitmap )
 420   {
 421     width = mBitmap->GetImageWidth();
 422   }
 423   return width;
 424 }
 425
 426 unsigned int BitmapTexture::GetHeight() const
 427 {
 428   unsigned int height = mHeight;
 429   if( mBitmap )
 430   {
 431     height = mBitmap->GetImageHeight();
 432   }
 433   return height;
 434 }
 435
 436 } //namespace Internal
 437
 438 } //namespace Dali