libvision/system/ExynosVisionResManager.h - LeafOS-Devices/android_hardware_samsung_slsi-linaro_exynos - Gitiles

 /*
  * Copyright (C) 2015, 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.
  */

 #ifndef EXYNOS_VISION_RESOURCE_MNGR_H
 #define EXYNOS_VISION_RESOURCE_MNGR_H

 #include <utils/threads.h>
 #include <utils/Mutex.h>
 #include <utils/List.h>
 #include <utils/Vector.h>

 #include <VX/vx.h>

 #include "ExynosVisionMemoryAllocator.h"
 #include "ExynosVisionPool.h"
 #include "ExynosVisionState.h"

 #define RES_DBG_MSG  0

 namespace android {

 enum RES_ELEMENT_STATE {
     RES_ELEMENT_NO_LOCK,
     RES_ELEMENT_WRITE_LOCK,
     RES_ELEMENT_READ_LOCK
 };

 template<typename T>
 class ExynosVisionResElement {
 private:
     T m_resource;

     ExynosVisionState m_state;

     vx_uint32 m_frame_id;
     /* this indicates the index within resource manager */
     vx_uint32 m_index;

     /* for management read reference */
     vx_int32 m_read_demand_number;

     vx_int32 m_read_ref_count;
     vx_int32 m_read_demand_count;

     /* this indicates the data is valid after writing */
     vx_bool m_valid;

 public:

 private:

 public:
     /* Constructor */
     ExynosVisionResElement(void)
     {
         m_state.setState(RES_ELEMENT_NO_LOCK);
         m_frame_id = 0;
         m_index = 0;

         m_read_demand_number = 0;
         m_read_demand_count = 0;
         m_read_ref_count = 0;

         m_resource = NULL;

         m_valid = vx_true_e;
     }

     /* Destructor */
     virtual ~ExynosVisionResElement()
     {
         /* do nothing */
     }

     void clearReadInfo(void)
     {
         m_read_demand_number = 0;
         m_read_demand_count = 0;
         m_read_ref_count = 0;
     }

     void setResource(T resource)
     {
         m_resource = resource;
     }

     T getResource()
     {
         return m_resource;
     }
     void setId(vx_int32 frame_id)
     {
         m_frame_id = frame_id;
     };
     vx_uint32 getId()
     {
         return m_frame_id;
     };

     void setIndex(vx_int32 index)
     {
         m_index = index;
     };
     vx_uint32 getIndex()
     {
         return m_index;
     };
     vx_uint32 getReadRefCnt()
     {
         return m_read_ref_count;
     };
     vx_uint32 getReadDemandCnt()
     {
         return m_read_demand_count;
     };
     vx_uint32 getReadDemandNum()
     {
         return m_read_demand_number;
     };
     void setReadDemandNum(vx_uint32 demand_num)
     {
         m_read_demand_number = demand_num;
     }
     void incReadDemCnt(void)
     {
         m_read_demand_count++;
     }
     void incReadRefCnt(void)
     {
         m_read_ref_count++;
     }
     void decReadRefCnt(void)
     {
         m_read_ref_count--;
     }

     vx_bool isReadComplete(void)
     {
         if (m_read_ref_count == 0 && m_read_demand_count == m_read_demand_number)
             return vx_true_e;
         else
             return vx_false_e;
     }

     void setState(vx_enum new_state)
     {
         m_state.setState(new_state);
     }

     vx_enum getState(void)
     {
         return m_state.getState();
     }

     void setValid(vx_bool valid)
     {
         m_valid = valid;
     }

     vx_bool getValid(void)
     {
         return m_valid;
     }

 };

 enum RESOURCE_MNGR_TYPE {
     /* resource manager is not assigned */
     RESOURCE_MNGR_NULL,
     /* single resource, support slot event, single object */
     RESOURCE_MNGR_SOLID,
     /* multi resource, support slot event, multi object */
     RESOURCE_MNGR_SLOT,
     /* multi resource, support queue event, single object */
     RESOURCE_MNGR_QUEUE,
 };

 struct resource_solid_param {

 };

 struct resource_slot_param {
     vx_uint32 slot_num;
 };

 struct resource_queue_param {
     vx_uint32 direction;
 };

 struct resource_param {
     union {
         struct resource_solid_param solid_param;
         struct resource_slot_param slot_param;
         struct resource_queue_param queue_param;
     } param;
 };

 enum RESOURCE_CLASS_TYPE {
     RESOURCE_CLASS_NONE,
     RESOURCE_CLASS_SLOT,
     RESOURCE_CLASS_INPUT_QUEUE,
     RESOURCE_CLASS_OUTPUT_QUEUE
 };

 template<typename T>
 class ExynosVisionResManager {
 private:

 protected:
     Mutex               m_res_mutex;
     vx_enum m_res_class_type;

     List<ExynosVisionResElement<T>*> m_using_res_element_list;

 private:

 public:
     /* Constructor */
     ExynosVisionResManager(void)
     {
         m_res_class_type = RESOURCE_CLASS_NONE;
     }

     /* Destructor */
     virtual ~ExynosVisionResManager()
     {
         /* do noting */
     }

     virtual vx_status registerResource(T)
     {
         VXLOGE("not implemented at res-class-type %d", m_res_class_type);
         return VX_FAILURE;
     }

     virtual vx_status destroy(void)
     {
         VXLOGE("not implemented at res-class-type %d", m_res_class_type);
         return VX_FAILURE;
     }

     virtual T waitAndGetEmptyResAndWrLk(vx_uint32 frame_id)
     {
         VXLOGE("not supported, frame_id:%d", frame_id);
         return NULL;
     }

     virtual vx_status setFilledRes(vx_uint32 frame_id, vx_bool data_valid)
     {
         VXLOGE("not supported, frame_id:%d, data_valid:%d", frame_id, data_valid);
         return VX_FAILURE;
     }

     virtual vx_status setFilledResAndRdLk(vx_uint32 frame_id, vx_uint32 demand_number, vx_bool data_valid)
     {
         VXLOGE("not supported, frame_id:%d, demand_num:%d, data_valid:%d", frame_id, demand_number, data_valid);
         return VX_FAILURE;
     }

     virtual T getFilledRes(vx_uint32 frame_id, vx_bool *ret_data_valid)
     {
         VXLOGE("not supported, frame_id:%d, &ret_data_valid:%p", frame_id, ret_data_valid);
         return NULL;
     }

     virtual vx_status putFilledRes(vx_uint32 frame_id)
     {
         VXLOGE("not supported, frame_id:%d", frame_id);
         return VX_FAILURE;
     }

     /* output queue type */
     virtual vx_status pushResource(vx_uint32 index, T resource)
     {
         VXLOGE("not supported, index:%d, resource:%p", index, resource);
         return VX_FAILURE;
     }

     /* input queue type */
     virtual vx_status pushResource(vx_uint32 index, T resource, vx_uint32 frame_id, vx_uint32 demand_number)
     {
         VXLOGE("not supported, index:%d, resource:%p, frame id:%d, demand:%d", index, resource, frame_id, demand_number);
         return VX_FAILURE;
     }

     virtual vx_status popResource(vx_uint32 *ret_index, vx_bool *ret_data_valid, T *ret_resource)
     {
         VXLOGE("not supported, &index:%p, &data_valid:%p, &resource:%p", ret_index, ret_data_valid, ret_resource);
         return VX_FAILURE;
     }

     virtual void displayBuff(vx_uint32 tab_num, vx_bool detail_info)
     {
         VXLOGE("not supported, %d, %d", tab_num, detail_info);
     }
 };

 template<typename T>
 class ExynosVisionResSlotType : public ExynosVisionResManager<T> {
 private:
     vx_uint32 m_slot_num;

     /* m_buf_element_list has the all of the res element */
     List<ExynosVisionResElement<T>*> m_registered_res_element_list;

     ExynosVisionPool<ExynosVisionResElement<T>*> m_free_res_element_pool;

 public:

 private:

 public:
     /* Constructor */
     ExynosVisionResSlotType(vx_uint32 slot_num = 1)
     {
         ExynosVisionResManager<T>::m_res_class_type = RESOURCE_CLASS_SLOT;
         m_slot_num = slot_num;
     }

     /* Destructor */
     virtual ~ExynosVisionResSlotType()
     {
         /* do nothing */
     }

     virtual vx_status registerResource(T resource)
     {
         if (m_registered_res_element_list.size() >= m_slot_num) {
             ALOGE("[%s] resource number is overflowed, slot_num:%d", m_slot_num);
             return VX_FAILURE;
         }

         ExynosVisionResManager<T>::m_res_mutex.lock();
         ExynosVisionResElement<T> *res_element = new ExynosVisionResElement<T>();
         res_element->setResource(resource);
         res_element->setIndex(m_registered_res_element_list.size());

         m_registered_res_element_list.push_back(res_element);
         ExynosVisionResManager<T>::m_res_mutex.unlock();

         m_free_res_element_pool.putResource(res_element);

         return VX_SUCCESS;
     }

     virtual vx_status destroy(void)
     {
         vx_status status = VX_SUCCESS;

         m_free_res_element_pool.release();
         m_free_res_element_pool.flush();

         typename List<ExynosVisionResElement<T>*>::iterator elem_iter;
         for (elem_iter=m_registered_res_element_list.begin(); elem_iter!=m_registered_res_element_list.end(); elem_iter++)
             delete (*elem_iter);

         m_slot_num = 0;

         return status;
     }

     virtual T waitAndGetEmptyResAndWrLk(vx_uint32 frame_id)
     {
         pool_exception_t pool_exception;
         ExynosVisionResElement<T>* res_element = NULL;

         pool_exception = m_free_res_element_pool.getResource(&res_element);

         if (pool_exception == POOL_EXCEPTION_NONE) {
             ExynosVisionResManager<T>::m_res_mutex.lock();
             res_element->setId(frame_id);
             res_element->setState(RES_ELEMENT_WRITE_LOCK);
             res_element->setValid(vx_true_e);
             ExynosVisionResManager<T>::m_using_res_element_list.push_back(res_element);
             ExynosVisionResManager<T>::m_res_mutex.unlock();

             return res_element->getResource();
         } else {
             VXLOGE("getting empty buffer");
             displayBuff(0, vx_true_e);

             return NULL;
         }
     }

     virtual vx_status setFilledResAndRdLk(vx_uint32 frame_id, vx_uint32 demand_number, vx_bool data_valid)
     {
         vx_status status = VX_FAILURE;

         typename List<ExynosVisionResElement<T>*>::iterator elem_iter;

         ExynosVisionResManager<T>::m_res_mutex.lock();
         for (elem_iter=ExynosVisionResManager<T>::m_using_res_element_list.begin();
                 elem_iter!=ExynosVisionResManager<T>::m_using_res_element_list.end();
                 elem_iter++) {
             ExynosVisionResElement<T> *res_element = *elem_iter;
             if (res_element->getId() == frame_id) {
                 res_element->setState(RES_ELEMENT_READ_LOCK);
                 res_element->setValid(data_valid);
                 res_element->setReadDemandNum(demand_number);
                 status = VX_SUCCESS;
                 break;
             }
         }
         ExynosVisionResManager<T>::m_res_mutex.unlock();

         if (status != VX_SUCCESS)
             VXLOGE("cannot find perfer buffer, id:%d", frame_id);

         return status;
     }


     virtual T getFilledRes(vx_uint32 frame_id, vx_bool *ret_data_valid)
     {
 #if (RES_DBG_MSG==1)
         VXLOGD("frame:%d", frame_id);
         VXLOGD("enter");
         displayBuff(0, vx_true_e);
 #endif

         vx_status status = VX_FAILURE;
         ExynosVisionResElement<T>* res_element = NULL;

         typename List<ExynosVisionResElement<T>*>::iterator elem_iter;
         ExynosVisionResManager<T>::m_res_mutex.lock();
         for (elem_iter=ExynosVisionResManager<T>::m_using_res_element_list.begin();
                 elem_iter!=ExynosVisionResManager<T>::m_using_res_element_list.end();
                 elem_iter++) {
             res_element = *elem_iter;
             if (res_element->getId() == frame_id) {
                 res_element->incReadRefCnt();
                 res_element->incReadDemCnt();
                 *ret_data_valid = res_element->getValid();
                 status = VX_SUCCESS;
                 break;
             }
         }
         ExynosVisionResManager<T>::m_res_mutex.unlock();

 #if (RES_DBG_MSG==1)
         VXLOGD("exit");
         displayBuff(0, vx_true_e);
 #endif

         if (status != VX_SUCCESS) {
             VXLOGE("cannot find perfer buffer, id:%d", frame_id);
             this->displayBuff(0, vx_true_e);

             return NULL;
         } else {
             return res_element->getResource();
         }
     }

     virtual vx_status putFilledRes(vx_uint32 frame_id)
     {
 #if (RES_DBG_MSG==1)
         VXLOGD("frame:%d", frame_id);
         VXLOGD("enter");
         displayBuff(0, vx_true_e);
 #endif

         vx_status status = VX_FAILURE;
         ExynosVisionResElement<T> *res_element;

         typename List<ExynosVisionResElement<T>*>::iterator elem_iter;
         ExynosVisionResManager<T>::m_res_mutex.lock();
         for (elem_iter=ExynosVisionResManager<T>::m_using_res_element_list.begin();
                 elem_iter!=ExynosVisionResManager<T>::m_using_res_element_list.end();
                 elem_iter++) {
             res_element = *elem_iter;
             if (res_element->getId() == frame_id) {
                 res_element->decReadRefCnt();
                 status = VX_SUCCESS;
                 break;
             }
         }

         if (status != VX_SUCCESS) {
             VXLOGE("cannot find perfer buffer, id:%d", frame_id);
         } else {
             if (res_element->isReadComplete()) {
                 ExynosVisionResManager<T>::m_using_res_element_list.erase(elem_iter);
                 res_element->clearReadInfo();
                 res_element->setId(0);
                 res_element->setState(RES_ELEMENT_NO_LOCK);
                 m_free_res_element_pool.putResource(res_element);
             }
         }

         ExynosVisionResManager<T>::m_res_mutex.unlock();

 #if (RES_DBG_MSG==1)
         VXLOGD("exit");
         displayBuff(0, vx_true_e);
 #endif

         return status;
     }

     virtual void displayBuff(vx_uint32 tab_num, vx_bool detail_info)
     {
         vx_char tap[MAX_TAB_NUM];
         ExynosVisionResElement<T> *res_element = NULL;

         vx_uint32 i;
         typename List<ExynosVisionResElement<T>*>::iterator elem_iter;

         VXLOGD("%s[SLOT]used buf num:%d, free buf num:%d", MAKE_TAB(tap, tab_num), ExynosVisionResManager<T>::m_using_res_element_list.size(), m_free_res_element_pool.getFreeNum());
         if (detail_info == vx_true_e) {
             for (elem_iter=ExynosVisionResManager<T>::m_using_res_element_list.begin(), i=0;
                     elem_iter!=ExynosVisionResManager<T>::m_using_res_element_list.end();
                     elem_iter++, i++) {
                 res_element = *elem_iter;
                 VXLOGD("%sused buf, frame_id:%d, state:%d, RRefCnt:%d, RDemCnt:%d, RDemNum:%d", MAKE_TAB(tap, tab_num), res_element->getId(), res_element->getState(),
                                                                                         res_element->getReadRefCnt(), res_element->getReadDemandCnt(), res_element->getReadDemandNum());
             }
         }
     }
 };

 template<typename T>
 class ExynosVisionResQueueType : public ExynosVisionResManager<T> {
 #define MAX_QUEUE_RES_NUM     10

 private:

 protected:
     Vector<ExynosVisionResElement<T>*> m_res_element_vector;
     ExynosVisionPool<ExynosVisionResElement<T>*> m_done_res_element_pool;

 public:

 private:

 public:
     /* Constructor */
     ExynosVisionResQueueType(void)
     {
         for (vx_uint32 i=0; i<MAX_QUEUE_RES_NUM; i++) {
             ExynosVisionResElement<T> *res_element = new ExynosVisionResElement<T>();
             res_element->setIndex(m_res_element_vector.size());
             m_res_element_vector.push_back(res_element);
         }
     }

     /* Destructor */
     virtual ~ExynosVisionResQueueType()
     {
         for (vx_uint32 i=0; i<MAX_QUEUE_RES_NUM; i++) {
             if (m_res_element_vector.editItemAt(i)->getResource() != NULL)
                 VXLOGE("index:%d still hold resource", i);

             delete m_res_element_vector.editItemAt(i);
         }

         m_res_element_vector.clear();
     }

     virtual vx_status destroy(void)
     {
         return VX_SUCCESS;
     }

     virtual vx_status popResource(vx_uint32 *ret_index, vx_bool *ret_data_valid, T *ret_resource)
     {
         vx_status status = VX_SUCCESS;

         pool_exception_t pool_exception;
         ExynosVisionResElement<T>* res_element = NULL;

         pool_exception = m_done_res_element_pool.getResource(&res_element);
         if (pool_exception == POOL_EXCEPTION_NONE) {
             ExynosVisionResManager<T>::m_res_mutex.lock();
             if (res_element->getResource() == NULL)
                 VXLOGE("element holds null resource");

             *ret_index = res_element->getIndex();
             *ret_data_valid = res_element->getValid();
             *ret_resource = res_element->getResource();
             res_element->setResource(NULL);
             res_element->setId(0);
             ExynosVisionResManager<T>::m_res_mutex.unlock();
         } else {
             VXLOGE("getting empty buffer");
             status = VX_FAILURE;
         }

         return status;
     }
 };

 template<typename T>
 class ExynosVisionResInputQueueType : public ExynosVisionResQueueType<T> {
 private:

 public:

 private:

 public:
     /* Constructor */
     ExynosVisionResInputQueueType(void)
     {
         ExynosVisionResManager<T>::m_res_class_type = RESOURCE_CLASS_INPUT_QUEUE;
     }

     virtual vx_status pushResource(vx_uint32 index, T resource, vx_uint32 frame_id, vx_uint32 demand_number) {
         ExynosVisionResElement<T> *res_element;

         ExynosVisionResManager<T>::m_res_mutex.lock();

         if (index < MAX_QUEUE_RES_NUM) {
             res_element = ExynosVisionResQueueType<T>::m_res_element_vector.editItemAt(index);
         } else {
             VXLOGE("index:%d is out of bound", index);

             ExynosVisionResManager<T>::m_res_mutex.unlock();
             return VX_FAILURE;
         }

         if (res_element->getResource() != NULL) {
             VXLOGE("index:%d is already assigned resource", index);

             ExynosVisionResManager<T>::m_res_mutex.unlock();
             return VX_FAILURE;
         }

         res_element->setResource(resource);
         res_element->setId(frame_id);
         res_element->setReadDemandNum(demand_number);
         res_element->setState(RES_ELEMENT_READ_LOCK);
         res_element->setValid(vx_true_e);

         ExynosVisionResManager<T>::m_using_res_element_list.push_back(res_element);

         ExynosVisionResManager<T>::m_res_mutex.unlock();
         return VX_SUCCESS;
     }

     virtual T getFilledRes(vx_uint32 frame_id, vx_bool *ret_data_valid)
     {
         vx_status status = VX_FAILURE;
         ExynosVisionResElement<T>* res_element = NULL;

         typename List<ExynosVisionResElement<T>*>::iterator elem_iter;
         ExynosVisionResManager<T>::m_res_mutex.lock();
         for (elem_iter=ExynosVisionResManager<T>::m_using_res_element_list.begin();
                 elem_iter!=ExynosVisionResManager<T>::m_using_res_element_list.end();
                 elem_iter++) {
             res_element = *elem_iter;
             if (res_element->getId() == frame_id) {
                 res_element->incReadRefCnt();
                 res_element->incReadDemCnt();
                 *ret_data_valid = res_element->getValid();
                 status = VX_SUCCESS;
                 break;
             }
         }
         ExynosVisionResManager<T>::m_res_mutex.unlock();

         if (status != VX_SUCCESS) {
             VXLOGE("cannot find perfer buffer, id:%d", frame_id);
             return NULL;
         } else {
             return res_element->getResource();
         }
     }

     virtual vx_status putFilledRes(vx_uint32 frame_id)
     {
         vx_status status = VX_FAILURE;
         ExynosVisionResElement<T> *res_element;

         typename List<ExynosVisionResElement<T>*>::iterator elem_iter;
         ExynosVisionResManager<T>::m_res_mutex.lock();
         for (elem_iter=ExynosVisionResManager<T>::m_using_res_element_list.begin();
                 elem_iter!=ExynosVisionResManager<T>::m_using_res_element_list.end();
                 elem_iter++) {
             res_element = *elem_iter;
             if (res_element->getId() == frame_id) {
                 res_element->decReadRefCnt();
                 status = VX_SUCCESS;
                 break;
             }
         }

         if (status != VX_SUCCESS) {
             VXLOGE("cannot find perfer buffer, id:%d", frame_id);
         } else {
             if (res_element->isReadComplete()) {
                 ExynosVisionResManager<T>::m_using_res_element_list.erase(elem_iter);
                 res_element->clearReadInfo();
                 res_element->setState(RES_ELEMENT_NO_LOCK);
                 ExynosVisionResQueueType<T>::m_done_res_element_pool.putResource(res_element);
             }
         }

         ExynosVisionResManager<T>::m_res_mutex.unlock();

         return status;
     }

     virtual void displayBuff(vx_uint32 tab_num, vx_bool detail_info)
     {
         vx_char tap[MAX_TAB_NUM];
         ExynosVisionResElement<T> *res_element = NULL;

         vx_uint32 i;
         typename List<ExynosVisionResElement<T>*>::iterator elem_iter;

         VXLOGD("%s[QUEU][%d]rece buf num:%d, done buf num:%d", MAKE_TAB(tap, tab_num), detail_info, ExynosVisionResQueueType<T>::m_using_res_element_list.size(), ExynosVisionResQueueType<T>::m_done_res_element_pool.getFreeNum());
     }
 };

 template<typename T>
 class ExynosVisionResOutputQueueType : public ExynosVisionResQueueType<T> {
 private:
     ExynosVisionPool<ExynosVisionResElement<T>*> m_free_res_element_pool;

 public:

 private:

 public:
     /* Constructor */
     ExynosVisionResOutputQueueType(void)
     {
         ExynosVisionResManager<T>::m_res_class_type = RESOURCE_CLASS_OUTPUT_QUEUE;
     }

     virtual vx_status pushResource(vx_uint32 index, T resource) {
         ExynosVisionResElement<T> *res_element;

         ExynosVisionResManager<T>::m_res_mutex.lock();
         if (index < MAX_QUEUE_RES_NUM) {
             res_element = ExynosVisionResQueueType<T>::m_res_element_vector.editItemAt(index);
         } else {
             VXLOGE("index:%d is out of bound", index);

             ExynosVisionResManager<T>::m_res_mutex.unlock();
             return VX_FAILURE;
         }

         if (res_element->getResource() != NULL) {
             VXLOGE("index:%d is already assigned resource", index);

             ExynosVisionResManager<T>::m_res_mutex.unlock();
             return VX_FAILURE;
         }

         res_element->setResource(resource);
         ExynosVisionResManager<T>::m_res_mutex.unlock();

         m_free_res_element_pool.putResource(res_element);

         return VX_SUCCESS;
     }

     virtual T waitAndGetEmptyResAndWrLk(vx_uint32 frame_id) {
         pool_exception_t pool_exception;
         ExynosVisionResElement<T>* res_element = NULL;

         pool_exception = m_free_res_element_pool.getResource(&res_element);

         if (pool_exception == POOL_EXCEPTION_NONE) {
             ExynosVisionResManager<T>::m_res_mutex.lock();
             res_element->setId(frame_id);
             res_element->setState(RES_ELEMENT_WRITE_LOCK);
             res_element->setValid(vx_true_e);
             ExynosVisionResQueueType<T>::m_using_res_element_list.push_back(res_element);
             ExynosVisionResManager<T>::m_res_mutex.unlock();

             return res_element->getResource();
         } else {
             VXLOGE("getting empty buffer");
             return NULL;
         }
     }

     virtual vx_status setFilledRes(vx_uint32 frame_id, vx_bool data_valid)
     {
         vx_status status = VX_FAILURE;
         ExynosVisionResElement<T> *res_element;

         typename List<ExynosVisionResElement<T>*>::iterator elem_iter;
         ExynosVisionResManager<T>::m_res_mutex.lock();
         for (elem_iter=ExynosVisionResQueueType<T>::m_using_res_element_list.begin();
                 elem_iter!= ExynosVisionResQueueType<T>::m_using_res_element_list.end();
                 elem_iter++) {
             res_element = *elem_iter;
             if (res_element->getId() == frame_id) {
                 res_element->setState(RES_ELEMENT_NO_LOCK);
                 res_element->setValid(data_valid);
                 status = VX_SUCCESS;
                 break;
             }
         }

         if (status != VX_SUCCESS) {
             VXLOGE("cannot find perfer buffer, id:%d", frame_id);
         } else {
             ExynosVisionResQueueType<T>::m_using_res_element_list.erase(elem_iter);
             ExynosVisionResQueueType<T>::m_done_res_element_pool.putResource(res_element);
         }

         ExynosVisionResManager<T>::m_res_mutex.unlock();

         return status;
     }

     virtual void displayBuff(vx_uint32 tab_num, vx_bool detail_info)
     {
         vx_char tap[MAX_TAB_NUM];
         ExynosVisionResElement<T> *res_element = NULL;

         vx_uint32 i;
         typename List<ExynosVisionResElement<T>*>::iterator elem_iter;

         VXLOGD("%s[QUEU][%d]free buf num:%d, done buf num:%d", MAKE_TAB(tap, tab_num), detail_info,
                 m_free_res_element_pool.getFreeNum(),
                 ExynosVisionResQueueType<T>::m_done_res_element_pool.getFreeNum());
     }
 };

 }; // namespace android
 #endif
	/*
	* Copyright (C) 2015, 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.
	*/

	#ifndef EXYNOS_VISION_RESOURCE_MNGR_H
	#define EXYNOS_VISION_RESOURCE_MNGR_H

	#include <utils/threads.h>
	#include <utils/Mutex.h>
	#include <utils/List.h>
	#include <utils/Vector.h>

	#include <VX/vx.h>

	#include "ExynosVisionMemoryAllocator.h"
	#include "ExynosVisionPool.h"
	#include "ExynosVisionState.h"

	#define RES_DBG_MSG 0

	namespace android {

	enum RES_ELEMENT_STATE {
	RES_ELEMENT_NO_LOCK,
	RES_ELEMENT_WRITE_LOCK,
	RES_ELEMENT_READ_LOCK
	};

	template<typename T>
	class ExynosVisionResElement {
	private:
	T m_resource;

	ExynosVisionState m_state;

	vx_uint32 m_frame_id;
	/* this indicates the index within resource manager */
	vx_uint32 m_index;

	/* for management read reference */
	vx_int32 m_read_demand_number;

	vx_int32 m_read_ref_count;
	vx_int32 m_read_demand_count;

	/* this indicates the data is valid after writing */
	vx_bool m_valid;

	public:

	private:

	public:
	/* Constructor */
	ExynosVisionResElement(void)
	{
	m_state.setState(RES_ELEMENT_NO_LOCK);
	m_frame_id = 0;
	m_index = 0;

	m_read_demand_number = 0;
	m_read_demand_count = 0;
	m_read_ref_count = 0;

	m_resource = NULL;

	m_valid = vx_true_e;
	}

	/* Destructor */
	virtual ~ExynosVisionResElement()
	{
	/* do nothing */
	}

	void clearReadInfo(void)
	{
	m_read_demand_number = 0;
	m_read_demand_count = 0;
	m_read_ref_count = 0;
	}

	void setResource(T resource)
	{
	m_resource = resource;
	}

	T getResource()
	{
	return m_resource;
	}
	void setId(vx_int32 frame_id)
	{
	m_frame_id = frame_id;
	};
	vx_uint32 getId()
	{
	return m_frame_id;
	};

	void setIndex(vx_int32 index)
	{
	m_index = index;
	};
	vx_uint32 getIndex()
	{
	return m_index;
	};
	vx_uint32 getReadRefCnt()
	{
	return m_read_ref_count;
	};
	vx_uint32 getReadDemandCnt()
	{
	return m_read_demand_count;
	};
	vx_uint32 getReadDemandNum()
	{
	return m_read_demand_number;
	};
	void setReadDemandNum(vx_uint32 demand_num)
	{
	m_read_demand_number = demand_num;
	}
	void incReadDemCnt(void)
	{
	m_read_demand_count++;
	}
	void incReadRefCnt(void)
	{
	m_read_ref_count++;
	}
	void decReadRefCnt(void)
	{
	m_read_ref_count--;
	}

	vx_bool isReadComplete(void)
	{
	if (m_read_ref_count == 0 && m_read_demand_count == m_read_demand_number)
	return vx_true_e;
	else
	return vx_false_e;
	}

	void setState(vx_enum new_state)
	{
	m_state.setState(new_state);
	}

	vx_enum getState(void)
	{
	return m_state.getState();
	}

	void setValid(vx_bool valid)
	{
	m_valid = valid;
	}

	vx_bool getValid(void)
	{
	return m_valid;
	}

	};

	enum RESOURCE_MNGR_TYPE {
	/* resource manager is not assigned */
	RESOURCE_MNGR_NULL,
	/* single resource, support slot event, single object */
	RESOURCE_MNGR_SOLID,
	/* multi resource, support slot event, multi object */
	RESOURCE_MNGR_SLOT,
	/* multi resource, support queue event, single object */
	RESOURCE_MNGR_QUEUE,
	};

	struct resource_solid_param {

	};

	struct resource_slot_param {
	vx_uint32 slot_num;
	};

	struct resource_queue_param {
	vx_uint32 direction;
	};

	struct resource_param {
	union {
	struct resource_solid_param solid_param;
	struct resource_slot_param slot_param;
	struct resource_queue_param queue_param;
	} param;
	};

	enum RESOURCE_CLASS_TYPE {
	RESOURCE_CLASS_NONE,
	RESOURCE_CLASS_SLOT,
	RESOURCE_CLASS_INPUT_QUEUE,
	RESOURCE_CLASS_OUTPUT_QUEUE
	};

	template<typename T>
	class ExynosVisionResManager {
	private:

	protected:
	Mutex m_res_mutex;
	vx_enum m_res_class_type;

	List<ExynosVisionResElement<T>*> m_using_res_element_list;

	private:

	public:
	/* Constructor */
	ExynosVisionResManager(void)
	{
	m_res_class_type = RESOURCE_CLASS_NONE;
	}

	/* Destructor */
	virtual ~ExynosVisionResManager()
	{
	/* do noting */
	}

	virtual vx_status registerResource(T)
	{
	VXLOGE("not implemented at res-class-type %d", m_res_class_type);
	return VX_FAILURE;
	}

	virtual vx_status destroy(void)
	{
	VXLOGE("not implemented at res-class-type %d", m_res_class_type);
	return VX_FAILURE;
	}

	virtual T waitAndGetEmptyResAndWrLk(vx_uint32 frame_id)
	{
	VXLOGE("not supported, frame_id:%d", frame_id);
	return NULL;
	}

	virtual vx_status setFilledRes(vx_uint32 frame_id, vx_bool data_valid)
	{
	VXLOGE("not supported, frame_id:%d, data_valid:%d", frame_id, data_valid);
	return VX_FAILURE;
	}

	virtual vx_status setFilledResAndRdLk(vx_uint32 frame_id, vx_uint32 demand_number, vx_bool data_valid)
	{
	VXLOGE("not supported, frame_id:%d, demand_num:%d, data_valid:%d", frame_id, demand_number, data_valid);
	return VX_FAILURE;
	}

	virtual T getFilledRes(vx_uint32 frame_id, vx_bool *ret_data_valid)
	{
	VXLOGE("not supported, frame_id:%d, &ret_data_valid:%p", frame_id, ret_data_valid);
	return NULL;
	}

	virtual vx_status putFilledRes(vx_uint32 frame_id)
	{
	VXLOGE("not supported, frame_id:%d", frame_id);
	return VX_FAILURE;
	}

	/* output queue type */
	virtual vx_status pushResource(vx_uint32 index, T resource)
	{
	VXLOGE("not supported, index:%d, resource:%p", index, resource);
	return VX_FAILURE;
	}

	/* input queue type */
	virtual vx_status pushResource(vx_uint32 index, T resource, vx_uint32 frame_id, vx_uint32 demand_number)
	{
	VXLOGE("not supported, index:%d, resource:%p, frame id:%d, demand:%d", index, resource, frame_id, demand_number);
	return VX_FAILURE;
	}

	virtual vx_status popResource(vx_uint32 ret_index, vx_bool ret_data_valid, T *ret_resource)
	{
	VXLOGE("not supported, &index:%p, &data_valid:%p, &resource:%p", ret_index, ret_data_valid, ret_resource);
	return VX_FAILURE;
	}

	virtual void displayBuff(vx_uint32 tab_num, vx_bool detail_info)
	{
	VXLOGE("not supported, %d, %d", tab_num, detail_info);
	}
	};

	template<typename T>
	class ExynosVisionResSlotType : public ExynosVisionResManager<T> {
	private:
	vx_uint32 m_slot_num;

	/* m_buf_element_list has the all of the res element */
	List<ExynosVisionResElement<T>*> m_registered_res_element_list;

	ExynosVisionPool<ExynosVisionResElement<T>*> m_free_res_element_pool;

	public:

	private:

	public:
	/* Constructor */
	ExynosVisionResSlotType(vx_uint32 slot_num = 1)
	{
	ExynosVisionResManager<T>::m_res_class_type = RESOURCE_CLASS_SLOT;
	m_slot_num = slot_num;
	}

	/* Destructor */
	virtual ~ExynosVisionResSlotType()
	{
	/* do nothing */
	}

	virtual vx_status registerResource(T resource)
	{
	if (m_registered_res_element_list.size() >= m_slot_num) {
	ALOGE("[%s] resource number is overflowed, slot_num:%d", m_slot_num);
	return VX_FAILURE;
	}

	ExynosVisionResManager<T>::m_res_mutex.lock();
	ExynosVisionResElement<T> *res_element = new ExynosVisionResElement<T>();
	res_element->setResource(resource);
	res_element->setIndex(m_registered_res_element_list.size());

	m_registered_res_element_list.push_back(res_element);
	ExynosVisionResManager<T>::m_res_mutex.unlock();

	m_free_res_element_pool.putResource(res_element);

	return VX_SUCCESS;
	}

	virtual vx_status destroy(void)
	{
	vx_status status = VX_SUCCESS;

	m_free_res_element_pool.release();
	m_free_res_element_pool.flush();

	typename List<ExynosVisionResElement<T>*>::iterator elem_iter;
	for (elem_iter=m_registered_res_element_list.begin(); elem_iter!=m_registered_res_element_list.end(); elem_iter++)
	delete (*elem_iter);

	m_slot_num = 0;

	return status;
	}

	virtual T waitAndGetEmptyResAndWrLk(vx_uint32 frame_id)
	{
	pool_exception_t pool_exception;
	ExynosVisionResElement<T>* res_element = NULL;

	pool_exception = m_free_res_element_pool.getResource(&res_element);

	if (pool_exception == POOL_EXCEPTION_NONE) {
	ExynosVisionResManager<T>::m_res_mutex.lock();
	res_element->setId(frame_id);
	res_element->setState(RES_ELEMENT_WRITE_LOCK);
	res_element->setValid(vx_true_e);
	ExynosVisionResManager<T>::m_using_res_element_list.push_back(res_element);
	ExynosVisionResManager<T>::m_res_mutex.unlock();

	return res_element->getResource();
	} else {
	VXLOGE("getting empty buffer");
	displayBuff(0, vx_true_e);

	return NULL;
	}
	}

	virtual vx_status setFilledResAndRdLk(vx_uint32 frame_id, vx_uint32 demand_number, vx_bool data_valid)
	{
	vx_status status = VX_FAILURE;

	typename List<ExynosVisionResElement<T>*>::iterator elem_iter;

	ExynosVisionResManager<T>::m_res_mutex.lock();
	for (elem_iter=ExynosVisionResManager<T>::m_using_res_element_list.begin();
	elem_iter!=ExynosVisionResManager<T>::m_using_res_element_list.end();
	elem_iter++) {
	ExynosVisionResElement<T> res_element = elem_iter;
	if (res_element->getId() == frame_id) {
	res_element->setState(RES_ELEMENT_READ_LOCK);
	res_element->setValid(data_valid);
	res_element->setReadDemandNum(demand_number);
	status = VX_SUCCESS;
	break;
	}
	}
	ExynosVisionResManager<T>::m_res_mutex.unlock();

	if (status != VX_SUCCESS)
	VXLOGE("cannot find perfer buffer, id:%d", frame_id);

	return status;
	}


	virtual T getFilledRes(vx_uint32 frame_id, vx_bool *ret_data_valid)
	{
	#if (RES_DBG_MSG==1)
	VXLOGD("frame:%d", frame_id);
	VXLOGD("enter");
	displayBuff(0, vx_true_e);
	#endif

	vx_status status = VX_FAILURE;
	ExynosVisionResElement<T>* res_element = NULL;

	typename List<ExynosVisionResElement<T>*>::iterator elem_iter;
	ExynosVisionResManager<T>::m_res_mutex.lock();
	for (elem_iter=ExynosVisionResManager<T>::m_using_res_element_list.begin();
	elem_iter!=ExynosVisionResManager<T>::m_using_res_element_list.end();
	elem_iter++) {
	res_element = *elem_iter;
	if (res_element->getId() == frame_id) {
	res_element->incReadRefCnt();
	res_element->incReadDemCnt();
	*ret_data_valid = res_element->getValid();
	status = VX_SUCCESS;
	break;
	}
	}
	ExynosVisionResManager<T>::m_res_mutex.unlock();

	#if (RES_DBG_MSG==1)
	VXLOGD("exit");
	displayBuff(0, vx_true_e);
	#endif

	if (status != VX_SUCCESS) {
	VXLOGE("cannot find perfer buffer, id:%d", frame_id);
	this->displayBuff(0, vx_true_e);

	return NULL;
	} else {
	return res_element->getResource();
	}
	}

	virtual vx_status putFilledRes(vx_uint32 frame_id)
	{
	#if (RES_DBG_MSG==1)
	VXLOGD("frame:%d", frame_id);
	VXLOGD("enter");
	displayBuff(0, vx_true_e);
	#endif

	vx_status status = VX_FAILURE;
	ExynosVisionResElement<T> *res_element;

	typename List<ExynosVisionResElement<T>*>::iterator elem_iter;
	ExynosVisionResManager<T>::m_res_mutex.lock();
	for (elem_iter=ExynosVisionResManager<T>::m_using_res_element_list.begin();
	elem_iter!=ExynosVisionResManager<T>::m_using_res_element_list.end();
	elem_iter++) {
	res_element = *elem_iter;
	if (res_element->getId() == frame_id) {
	res_element->decReadRefCnt();
	status = VX_SUCCESS;
	break;
	}
	}

	if (status != VX_SUCCESS) {
	VXLOGE("cannot find perfer buffer, id:%d", frame_id);
	} else {
	if (res_element->isReadComplete()) {
	ExynosVisionResManager<T>::m_using_res_element_list.erase(elem_iter);
	res_element->clearReadInfo();
	res_element->setId(0);
	res_element->setState(RES_ELEMENT_NO_LOCK);
	m_free_res_element_pool.putResource(res_element);
	}
	}

	ExynosVisionResManager<T>::m_res_mutex.unlock();

	#if (RES_DBG_MSG==1)
	VXLOGD("exit");
	displayBuff(0, vx_true_e);
	#endif

	return status;
	}

	virtual void displayBuff(vx_uint32 tab_num, vx_bool detail_info)
	{
	vx_char tap[MAX_TAB_NUM];
	ExynosVisionResElement<T> *res_element = NULL;

	vx_uint32 i;
	typename List<ExynosVisionResElement<T>*>::iterator elem_iter;

	VXLOGD("%s[SLOT]used buf num:%d, free buf num:%d", MAKE_TAB(tap, tab_num), ExynosVisionResManager<T>::m_using_res_element_list.size(), m_free_res_element_pool.getFreeNum());
	if (detail_info == vx_true_e) {
	for (elem_iter=ExynosVisionResManager<T>::m_using_res_element_list.begin(), i=0;
	elem_iter!=ExynosVisionResManager<T>::m_using_res_element_list.end();
	elem_iter++, i++) {
	res_element = *elem_iter;
	VXLOGD("%sused buf, frame_id:%d, state:%d, RRefCnt:%d, RDemCnt:%d, RDemNum:%d", MAKE_TAB(tap, tab_num), res_element->getId(), res_element->getState(),
	res_element->getReadRefCnt(), res_element->getReadDemandCnt(), res_element->getReadDemandNum());
	}
	}
	}
	};

	template<typename T>
	class ExynosVisionResQueueType : public ExynosVisionResManager<T> {
	#define MAX_QUEUE_RES_NUM 10

	private:

	protected:
	Vector<ExynosVisionResElement<T>*> m_res_element_vector;
	ExynosVisionPool<ExynosVisionResElement<T>*> m_done_res_element_pool;

	public:

	private:

	public:
	/* Constructor */
	ExynosVisionResQueueType(void)
	{
	for (vx_uint32 i=0; i<MAX_QUEUE_RES_NUM; i++) {
	ExynosVisionResElement<T> *res_element = new ExynosVisionResElement<T>();
	res_element->setIndex(m_res_element_vector.size());
	m_res_element_vector.push_back(res_element);
	}
	}

	/* Destructor */
	virtual ~ExynosVisionResQueueType()
	{
	for (vx_uint32 i=0; i<MAX_QUEUE_RES_NUM; i++) {
	if (m_res_element_vector.editItemAt(i)->getResource() != NULL)
	VXLOGE("index:%d still hold resource", i);

	delete m_res_element_vector.editItemAt(i);
	}

	m_res_element_vector.clear();
	}

	virtual vx_status destroy(void)
	{
	return VX_SUCCESS;
	}

	virtual vx_status popResource(vx_uint32 ret_index, vx_bool ret_data_valid, T *ret_resource)
	{
	vx_status status = VX_SUCCESS;

	pool_exception_t pool_exception;
	ExynosVisionResElement<T>* res_element = NULL;

	pool_exception = m_done_res_element_pool.getResource(&res_element);
	if (pool_exception == POOL_EXCEPTION_NONE) {
	ExynosVisionResManager<T>::m_res_mutex.lock();
	if (res_element->getResource() == NULL)
	VXLOGE("element holds null resource");

	*ret_index = res_element->getIndex();
	*ret_data_valid = res_element->getValid();
	*ret_resource = res_element->getResource();
	res_element->setResource(NULL);
	res_element->setId(0);
	ExynosVisionResManager<T>::m_res_mutex.unlock();
	} else {
	VXLOGE("getting empty buffer");
	status = VX_FAILURE;
	}

	return status;
	}
	};

	template<typename T>
	class ExynosVisionResInputQueueType : public ExynosVisionResQueueType<T> {
	private:

	public:

	private:

	public:
	/* Constructor */
	ExynosVisionResInputQueueType(void)
	{
	ExynosVisionResManager<T>::m_res_class_type = RESOURCE_CLASS_INPUT_QUEUE;
	}

	virtual vx_status pushResource(vx_uint32 index, T resource, vx_uint32 frame_id, vx_uint32 demand_number) {
	ExynosVisionResElement<T> *res_element;

	ExynosVisionResManager<T>::m_res_mutex.lock();

	if (index < MAX_QUEUE_RES_NUM) {
	res_element = ExynosVisionResQueueType<T>::m_res_element_vector.editItemAt(index);
	} else {
	VXLOGE("index:%d is out of bound", index);

	ExynosVisionResManager<T>::m_res_mutex.unlock();
	return VX_FAILURE;
	}

	if (res_element->getResource() != NULL) {
	VXLOGE("index:%d is already assigned resource", index);

	ExynosVisionResManager<T>::m_res_mutex.unlock();
	return VX_FAILURE;
	}

	res_element->setResource(resource);
	res_element->setId(frame_id);
	res_element->setReadDemandNum(demand_number);
	res_element->setState(RES_ELEMENT_READ_LOCK);
	res_element->setValid(vx_true_e);

	ExynosVisionResManager<T>::m_using_res_element_list.push_back(res_element);

	ExynosVisionResManager<T>::m_res_mutex.unlock();
	return VX_SUCCESS;
	}

	virtual T getFilledRes(vx_uint32 frame_id, vx_bool *ret_data_valid)
	{
	vx_status status = VX_FAILURE;
	ExynosVisionResElement<T>* res_element = NULL;

	typename List<ExynosVisionResElement<T>*>::iterator elem_iter;
	ExynosVisionResManager<T>::m_res_mutex.lock();
	for (elem_iter=ExynosVisionResManager<T>::m_using_res_element_list.begin();
	elem_iter!=ExynosVisionResManager<T>::m_using_res_element_list.end();
	elem_iter++) {
	res_element = *elem_iter;
	if (res_element->getId() == frame_id) {
	res_element->incReadRefCnt();
	res_element->incReadDemCnt();
	*ret_data_valid = res_element->getValid();
	status = VX_SUCCESS;
	break;
	}
	}
	ExynosVisionResManager<T>::m_res_mutex.unlock();

	if (status != VX_SUCCESS) {
	VXLOGE("cannot find perfer buffer, id:%d", frame_id);
	return NULL;
	} else {
	return res_element->getResource();
	}
	}

	virtual vx_status putFilledRes(vx_uint32 frame_id)
	{
	vx_status status = VX_FAILURE;
	ExynosVisionResElement<T> *res_element;

	typename List<ExynosVisionResElement<T>*>::iterator elem_iter;
	ExynosVisionResManager<T>::m_res_mutex.lock();
	for (elem_iter=ExynosVisionResManager<T>::m_using_res_element_list.begin();
	elem_iter!=ExynosVisionResManager<T>::m_using_res_element_list.end();
	elem_iter++) {
	res_element = *elem_iter;
	if (res_element->getId() == frame_id) {
	res_element->decReadRefCnt();
	status = VX_SUCCESS;
	break;
	}
	}

	if (status != VX_SUCCESS) {
	VXLOGE("cannot find perfer buffer, id:%d", frame_id);
	} else {
	if (res_element->isReadComplete()) {
	ExynosVisionResManager<T>::m_using_res_element_list.erase(elem_iter);
	res_element->clearReadInfo();
	res_element->setState(RES_ELEMENT_NO_LOCK);
	ExynosVisionResQueueType<T>::m_done_res_element_pool.putResource(res_element);
	}
	}

	ExynosVisionResManager<T>::m_res_mutex.unlock();

	return status;
	}

	virtual void displayBuff(vx_uint32 tab_num, vx_bool detail_info)
	{
	vx_char tap[MAX_TAB_NUM];
	ExynosVisionResElement<T> *res_element = NULL;

	vx_uint32 i;
	typename List<ExynosVisionResElement<T>*>::iterator elem_iter;

	VXLOGD("%s[QUEU][%d]rece buf num:%d, done buf num:%d", MAKE_TAB(tap, tab_num), detail_info, ExynosVisionResQueueType<T>::m_using_res_element_list.size(), ExynosVisionResQueueType<T>::m_done_res_element_pool.getFreeNum());
	}
	};

	template<typename T>
	class ExynosVisionResOutputQueueType : public ExynosVisionResQueueType<T> {
	private:
	ExynosVisionPool<ExynosVisionResElement<T>*> m_free_res_element_pool;

	public:

	private:

	public:
	/* Constructor */
	ExynosVisionResOutputQueueType(void)
	{
	ExynosVisionResManager<T>::m_res_class_type = RESOURCE_CLASS_OUTPUT_QUEUE;
	}

	virtual vx_status pushResource(vx_uint32 index, T resource) {
	ExynosVisionResElement<T> *res_element;

	ExynosVisionResManager<T>::m_res_mutex.lock();
	if (index < MAX_QUEUE_RES_NUM) {
	res_element = ExynosVisionResQueueType<T>::m_res_element_vector.editItemAt(index);
	} else {
	VXLOGE("index:%d is out of bound", index);

	ExynosVisionResManager<T>::m_res_mutex.unlock();
	return VX_FAILURE;
	}

	if (res_element->getResource() != NULL) {
	VXLOGE("index:%d is already assigned resource", index);

	ExynosVisionResManager<T>::m_res_mutex.unlock();
	return VX_FAILURE;
	}

	res_element->setResource(resource);
	ExynosVisionResManager<T>::m_res_mutex.unlock();

	m_free_res_element_pool.putResource(res_element);

	return VX_SUCCESS;
	}

	virtual T waitAndGetEmptyResAndWrLk(vx_uint32 frame_id) {
	pool_exception_t pool_exception;
	ExynosVisionResElement<T>* res_element = NULL;

	pool_exception = m_free_res_element_pool.getResource(&res_element);

	if (pool_exception == POOL_EXCEPTION_NONE) {
	ExynosVisionResManager<T>::m_res_mutex.lock();
	res_element->setId(frame_id);
	res_element->setState(RES_ELEMENT_WRITE_LOCK);
	res_element->setValid(vx_true_e);
	ExynosVisionResQueueType<T>::m_using_res_element_list.push_back(res_element);
	ExynosVisionResManager<T>::m_res_mutex.unlock();

	return res_element->getResource();
	} else {
	VXLOGE("getting empty buffer");
	return NULL;
	}
	}

	virtual vx_status setFilledRes(vx_uint32 frame_id, vx_bool data_valid)
	{
	vx_status status = VX_FAILURE;
	ExynosVisionResElement<T> *res_element;

	typename List<ExynosVisionResElement<T>*>::iterator elem_iter;
	ExynosVisionResManager<T>::m_res_mutex.lock();
	for (elem_iter=ExynosVisionResQueueType<T>::m_using_res_element_list.begin();
	elem_iter!= ExynosVisionResQueueType<T>::m_using_res_element_list.end();
	elem_iter++) {
	res_element = *elem_iter;
	if (res_element->getId() == frame_id) {
	res_element->setState(RES_ELEMENT_NO_LOCK);
	res_element->setValid(data_valid);
	status = VX_SUCCESS;
	break;
	}
	}

	if (status != VX_SUCCESS) {
	VXLOGE("cannot find perfer buffer, id:%d", frame_id);
	} else {
	ExynosVisionResQueueType<T>::m_using_res_element_list.erase(elem_iter);
	ExynosVisionResQueueType<T>::m_done_res_element_pool.putResource(res_element);
	}

	ExynosVisionResManager<T>::m_res_mutex.unlock();

	return status;
	}

	virtual void displayBuff(vx_uint32 tab_num, vx_bool detail_info)
	{
	vx_char tap[MAX_TAB_NUM];
	ExynosVisionResElement<T> *res_element = NULL;

	vx_uint32 i;
	typename List<ExynosVisionResElement<T>*>::iterator elem_iter;

	VXLOGD("%s[QUEU][%d]free buf num:%d, done buf num:%d", MAKE_TAB(tap, tab_num), detail_info,
	m_free_res_element_pool.getFreeNum(),
	ExynosVisionResQueueType<T>::m_done_res_element_pool.getFreeNum());
	}
	};

	}; // namespace android
	#endif