//-----------------------------------------------------------------------------
//    ____ _               
//   | ___| |   ___  _  _  
//   | ___| |  / __)\ \/ / 
//   | |  | |_| ___) |  |
//   |_|  \___|\___)/_/\_\ Image Library  Intel Corporation
//		
//	  2006, Intel Corporation, licensed under Apache 2.0 
//
// file :		FlexImageStore.h 
// author :		Scott Ettinger - scott.m.ettinger@intel.com
// description: FlexImageStore definition.  Templated image storage object.  
//				All storage for images is allocated in a FlexImageStore object. 
//				FlexImageStore objects use a reference counter to track how
//				many FlexImage objects are associated with it.  When the 
//				count is zero, it is destroyed by the last FlexImage object to use it.
//
//				The smart pointers must be protected by a semaphore lock 
//				(currently commented out) to be accessed by multiple threads.
//
//				
// modified : 
//-----------------------------------------------------------------------------

#ifndef FLEXIMAGESTORE_H
#define FLEXIMAGESTORE_H

#if defined(HAVE_CONFIG_H)
# include "config.h"
#endif

#include "FlexDefs.h"

template <class T, int C>
class FlexImageStore { 

protected:
	
	int mCount;
	//CSemaphore mLock;
	T *mData;				//Pixel Data
	FISize mSize;			//Image dimensions
	int mStepBytes;			//Stride in bytes per line (step y)

	void Allocate();

public:

	///Destructor
	~FlexImageStore();
	///Default Constructor
	FlexImageStore();
	///Constructor specifying dimensions
	FlexImageStore(int width, int height);

	///IPP memory allocation 
	inline T *FlexMalloc(int widthPixels, int heightPixels, int &pStepBytes);

	///Reallocate to new size - returns true if successful
	bool SetSize(int width, int height);

	//Decrement Reference counter - returns true if zero references remain
	bool DecReferences();
	///Increment Reference counter
	void IncReferences();

	///Get function for data pointer
	inline T *Data() { return(mData); };
	///Get function for image size
	inline FISize Size() { return(mSize); };
	///Get function for step size (bytes per line)
	inline int StepBytes() { return(mStepBytes); };
	
	///Returns false if data is successfully allocated, true if error occurs
	bool Err() { return(mData == NULL);} ;

	//Sets data pointer directly - Dangerous!! Debug purposes only...
	void SetData(T *p) {mData = p;};

};

//Implementation

template <class T, int C>
FlexImageStore<T,C>::FlexImageStore()
{
	mCount = 1;
	mSize.height = 0;
	mSize.width = 0;
	mData = NULL;
}

template <class T, int C>
FlexImageStore<T,C>::FlexImageStore(int width, int height)
{	//construct to given size
	mCount = 1;
	mData = NULL;
	SetSize(width, height);
}

template <class T, int C>
bool FlexImageStore<T,C>::SetSize(int width, int height)
{	//reallocate to new size
	mSize.width = width;
	mSize.height = height;
	mData = NULL;
	Allocate();
	return( Err() );
}

template <class T, int C>
FlexImageStore<T,C>::~FlexImageStore()
{
	if(mData != NULL)
		free(mData);
}

template <class T, int C>
void FlexImageStore<T,C>::Allocate()
{	//free any existing data
	if(mData != NULL)
		free(mData);
	//Allocate space for pixel data	
	mData = FlexMalloc(mSize.width, mSize.height, mStepBytes);
}

//update reference counts
template <class T, int C>
bool FlexImageStore<T,C>::DecReferences()
{
	//CSingleLock l(mLock, true);
	return( (--mCount) == 0);
}
template <class T, int C>
void FlexImageStore<T,C>::IncReferences()
{
	//CSingleLock l(mLock, true);
	mCount++;
}

template<class T, int C>
T *FlexImageStore<T,C>::FlexMalloc(int widthPixels, int heightPixels, int &StepBytes)
{
	StepBytes = widthPixels * C * sizeof(T);			//calculate bytes per image line
	StepBytes = int((StepBytes - 1) / 4) * 4 + 4;		//enforce multiples of 4
	return (T *)malloc(size_t(StepBytes * heightPixels));
}

#endif