#ifndef __DALI_INTEGRATION_BITMAP_H__
#define __DALI_INTEGRATION_BITMAP_H__
-//
-// Copyright (c) 2014 Samsung Electronics Co., Ltd.
-//
-// Licensed under the Flora License, Version 1.0 (the License);
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://floralicense.org/license/
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an AS IS BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
+/*
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
// EXTERNAL INCLUDES
#include <dali/public-api/common/intrusive-ptr.h>
#include <dali/public-api/images/pixel.h>
#include <dali/public-api/object/ref-object.h>
+#include <dali/integration-api/resource-policies.h>
namespace Dali
{
* @param[out] pixelDataType pixel data type (eg. GL_UNSIGNED_BYTE)
* @param[out] internalFormat pixel internal format (eg. GL_RGBA)
*/
-DALI_IMPORT_API void ConvertToGlFormat(Pixel::Format pixelformat, unsigned& pixelDataType, unsigned& internalFormat);
+DALI_CORE_API void ConvertToGlFormat(Pixel::Format pixelformat, unsigned& pixelDataType, unsigned& internalFormat);
class Bitmap;
typedef IntrusivePtr<Bitmap> BitmapPtr;
/**
* Bitmap class.
* An abstract container for image data.
- * \sa{BitmapPackedPixel BitmapCompressed BitmapExternal} for concrete
- * subclasses.
*/
-class DALI_IMPORT_API Bitmap : public Dali::RefObject
+class DALI_CORE_API Bitmap : public Dali::RefObject
{
protected:
+
/**
* Constructor
- * Use the static function Bitmap::Create() to create instances.
+ * Use the static function Bitmap::New() to create instances.
* @param[in] discardable Flag to tell the bitmap if it can delete the buffer with the pixel data.
* @param[in] pixBuf External buffer of pixel data or null.
*/
- Bitmap( bool discardable = false, Dali::Integration::PixelBuffer* pixBuf = 0 );
+ Bitmap( ResourcePolicy::Discardable discardable = ResourcePolicy::OWNED_RETAIN, Dali::Integration::PixelBuffer* pixBuf = 0 );
/**
* Initializes internal class members
BITMAP_COMPRESSED
};
+ enum ReleaseFunction
+ {
+ FREE, ///< Use free function to release the buffer
+ DELETE_ARRAY, ///< Use delete[] operator to release the buffer
+ };
+
/**
- * Create a new instance of a Bitmap with the profile asked for.
+ * Create a new instance of a Bitmap with the required profile.
* @return Pointer to created Bitmap subclass. Clients should immediately
* wrap this in a reference-counting smart pointer or store it in a similarly
* automatic owning collection.
* @param[in] profile Defines required features of the bitmap (\sa Profile).
- * @param[in] managePixelBuffer If true, the bitmap object owns it's own
- * buffer of pixel data and can delete it, else the lifetime of the pixel
- * buffer is managed by an external component and is guaranteed to remain
- * dereferenceable at least as long as the Bitmap remains alive.
- **/
- static Bitmap* New(Profile profile, bool managePixelBuffer);
+ * @param[in] discardable OWNED_DISCARD means that the data is owned by bitmap,
+ * and may released away after uploading to GPU.
+ * OWNED_RETAIN means that the data is owned and must be kept in CPU memory
+ * e.g. for an image that cannot be reloaded from disk.
+ */
+ static Bitmap* New( Profile profile, ResourcePolicy::Discardable discardable );
/** \name GeneralFeatures
* Features that are generic between profiles. */
}
/**
- * Get the pixel buffer
- * @return The buffer. You can modify its contents.
+ * Get the pixel buffer if it's present.
+ * @return The buffer if present, or NULL if there is no pixel buffer.
+ * You can modify its contents.
* @sa ReserveBuffer GetBufferSize
*/
virtual PixelBuffer* GetBuffer()
{
- DALI_ASSERT_DEBUG(mData != NULL);
return mData;
}
/**
+ * Get the pixel buffer if it's present and take over the ownership.
+ * @note With this function called, the bitmap loses the ownership and is no longer responsible for the release of pixel buffer.
+ * @return The raw pointer pointing to the pixel buffer
+ */
+ PixelBuffer* GetBufferOwnership();
+
+ /**
* Get the pixel buffer size in bytes
* @return The buffer size in bytes.
* @sa ReserveBuffer GetBuffer
return !(HasAlphaChannel() && mAlphaChannelUsed);
}
+ /**
+ * Returns which release function has to be called to release the data in the bitmap
+ * @return FREE if memory has been allocated with malloc DELETE_ARRAY if memory has been allocated with new
+ */
+ virtual ReleaseFunction GetReleaseFunction() = 0;
+
/**@}*/ ///< End of generic features
* This property can then be tested for with IsFullyOpaque().
*/
virtual void TestForTransparency() = 0;
+
+ protected:
+
+ /**
+ * Virtual destructor, no deletion through this interface
+ */
+ virtual ~PackedPixelsProfile() {}
};
/**
const unsigned width,
const unsigned height,
const size_t numBytes ) = 0;
+ protected:
+
+ /**
+ * Virtual destructor, no deletion through this interface
+ */
+ virtual ~CompressedProfile() {}
};
virtual const CompressedProfile* GetCompressedProfile() const { return 0; }
*/
bool IsDiscardable() const
{
- return mDiscardable;
+ return mDiscardable == ResourcePolicy::OWNED_DISCARD;
}
- /**
- * Transfer ownership of the pixel buffer to the calling function.
- * @post bitmaps pixel data is set to NULL
- * @return the bitmaps pixel buffer
- */
- PixelBuffer* ReleaseBuffer();
/**
* Delete the pixel buffer data
*/
void DeletePixelBuffer();
+protected:
+
/**
* A reference counted object may only be deleted by calling Unreference()
*/
private:
- bool mDiscardable; ///< Should delete the buffer when discard buffer is called.
+ ResourcePolicy::Discardable mDiscardable; ///< Should delete the buffer when discard buffer is called.
Bitmap(const Bitmap& other); ///< defined private to prevent use
Bitmap& operator = (const Bitmap& other); ///< defined private to prevent use