|| || || || || || || ||

---

ImageLoader.h

Go to the documentation of this file.

#ifndef IMAGELOADER_H
#define IMAGELOADER_H

#ifdef USE_BOOST_THREAD
#ifndef USE_BOOST_THREADPOOL
#include <boost/thread/thread.hpp>
#endif
#endif

#ifdef USE_BOOST_THREADPOOL
#define USE_BOOST_THREAD
// use this version for boost v. 34 (as on UvA FC8)
//#include "threadpool23/threadpool.hpp"
// use this version for boost >= 37 (as on decent machines)
#include "threadpool25/threadpool.hpp"
#endif

#ifndef BOOST_THREADPOOL_SIZE
#define BOOST_THREADPOOL_SIZE 8
#endif

#include "Visualization/RgbOglImage.h"
#include "Core/Array/ReadImage.h"

#include "OglGui/GetOglImageByIdInterface.h"

namespace Impala { namespace Application { namespace MediaTable {

class ImageLoader : public OglGui::GetOglImageByIdInterface {
public:
#ifdef USE_BOOST_THREADPOOL
        typedef boost::threadpool::thread_pool
                <boost::threadpool::task_func, boost::threadpool::lifo_scheduler, 
                 boost::threadpool::static_size, boost::threadpool::resize_controller, 
                 boost::threadpool::wait_for_active_tasks> pool;
#endif
        ImageLoader(OglGui::GetOglImageByIdInterface* getOglImageById, int size = BOOST_THREADPOOL_SIZE)
        {
                mGetOglImageById = getOglImageById;
#ifdef USE_BOOST_THREADPOOL
        /* ToDo:
         * mThreadPool = new boost::threadpool::pool(1);
         * if(source->MultiThreadImageCacheSupported)
         *   mThreadPool->size_controller().resize(8); */
                mThreadPool = pool(size);
#endif
        }
        
        ~ImageLoader() 
        {
                WaitUntilDone();
        }
        
        bool IsLoading()
        {
#ifdef USE_BOOST_THREADPOOL
                ILOG_DEBUG("TP check: Size " << mThreadPool.size() << " Active tasks " << mThreadPool.active() << " Pending tasks " << mThreadPool.pending());
                if(mThreadPool.active())
                        return true;
                if(mThreadPool.pending())
                        return true;
#endif
                return false;
        }

        /* GetOglImageById returns an OGLIMAGE* that is either the resulting image
         * or if Boost::Thread is used an empty image of 0x0.
         *
         * This empty image will be initialized in a thread with the correct data.
         */
        OGLIMAGE* GetOglImageById(long long id)
        {
#ifdef USE_BOOST_THREAD
        Core::Array::Array2dVec3UInt8* emptyArray;
        emptyArray = Core::Array::ArrayCreate<Core::Array::Array2dVec3UInt8>(0, 0, 0, 0, 0, true);
        OGLIMAGE* oglIm = Visualization::RgbOglImage::OglImage(emptyArray);
                // OGLIMAGE* oglIm = oglSys.OglImage(GL_RGB, 0, 0);

                // Make sure image does not get destroyed while loading.
                // Comparable to locking the image. Lock is released when
                // image is loaded or loading failed.
                oglIm->refCount++;
                
        Worker worker = Worker(oglIm, mGetOglImageById, id);
#ifdef USE_BOOST_THREADPOOL
        mThreadPool.schedule(worker);
#else
        boost::thread work(worker);
#endif

#else
        OGLIMAGE* oglIm = mGetOglImageById->GetOglImageById(id);
#endif
        if(oglIm != 0)
                ILOG_DEBUG("Returning image of " << oglIm->w << "x" << oglIm->h <<" pixels at " << oglIm);
        return oglIm;
        }

#ifdef USE_BOOST_THREAD
        class Worker {
        public:
                Worker(OGLIMAGE* oglIm, OglGui::GetOglImageByIdInterface* getOglImageById, long long id)
                {
                        mTargetOglImage         = oglIm;
                        mGetOglImageById        = getOglImageById;
                        mId                             = id;
                }

                int operator()()
                {
                        if(!mTargetOglImage || !(mTargetOglImage->refCount > 1))
                        {
                                // TODO: OglImageCache screws this up, as it ups refCount
                                
                                // We are the only one using this image, so stop loading.
                                ReleaseOglImage(mTargetOglImage);
                                
                                ILOG_INFO("Image has refCount 0, skipped loading image.");
                                // Nothing to do
                                return 0;
                        }

                        OGLIMAGE* im = mGetOglImageById->GetOglImageById(mId);

                        if(im != 0) {
                                assert(im->refCount == 1);
                                //mTargetOglImage->imDataFunc  = im->imDataFunc;
                                //mTargetOglImage->onDestroy   = im->onDestroy;
                                mTargetOglImage->imageHandle = im->imageHandle;
                                // Maybe we should change this to:
                                // *mTargetOglImage = *im;
                                // and store refCount of target
                                im->imageHandle = 0;

                                mTargetOglImage->h = im->h;
                                mTargetOglImage->w = im->w;
                                mTargetOglImage->changed = 1;
                                
                                ILOG_DEBUG("Loaded an image of " << mTargetOglImage->w <<
                                                        "x" << mTargetOglImage->h << " pixels to " <<
                                                        mTargetOglImage);

                                ReleaseOglImage(im);
                                if(mTargetOglImage)
                                        ReleaseOglImage(mTargetOglImage);
                                return 1;
                        }

                        ReleaseOglImage(im);
                        if(mTargetOglImage)
                                ReleaseOglImage(mTargetOglImage);
                        ILOG_ERROR("Failed to load image for " << mTargetOglImage);
                        return 0;
                }

        private:
                OGLIMAGE*                                                       mTargetOglImage;
                OglGui::GetOglImageByIdInterface*       mGetOglImageById;
                long long                                                       mId;
        };

#ifdef USE_BOOST_THREADPOOL
        pool                                                                    mThreadPool;
#endif
#endif

        void WaitUntilDone()
        {
#ifdef USE_BOOST_THREADPOOL
                mThreadPool.wait();
#endif
        }

        OglGui::GetOglImageByIdInterface*       mGetOglImageById;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(ImageLoader, Application.MediaTable);

} } } // Namespace Impala::Application::MediaTable

#endif // IMAGELOADER_H

---