src/parallel/ossimImageHandlerMtAdaptor.cpp

//**************************************************************************************************
//                          OSSIM -- Open Source Software Image Map
//
// LICENSE: See top level LICENSE.txt file.
//
// AUTHOR: Oscar Kramer
//
//! Intended mainly to provide a mechanism for mutex-locking access to a shared resource during
//! a getTile operation on an ossimImageHandler. This is needed for multi-threaded implementation.
//
//**************************************************************************************************
//  $Id$
#include <ossim/parallel/ossimImageHandlerMtAdaptor.h>
#include <ossim/imaging/ossimImageHandlerRegistry.h>
  // #include <ossim/parallel/ossimMtDebug.h>
#include <ossim/base/ossimCommon.h>
#include <ossim/base/ossimTimer.h>
#include <ossim/base/ossimTrace.h>
#include <cstdio>
#include <ctime>
// #include <sys/time.h>

using namespace std;

RTTI_DEF1(ossimImageHandlerMtAdaptor, "ossimImageHandlerMtAdaptor", ossimImageHandler);

const char* ossimImageHandlerMtAdaptor::ADAPTEE_ID_KW = "adaptee_id";
static ossimTrace traceDebug = ossimTrace("ossimImageHandlerMtAdaptor:debug");

//**************************************************************************************************
// Constructor
//**************************************************************************************************
ossimImageHandlerMtAdaptor::ossimImageHandlerMtAdaptor(ossimImageHandler* adaptee, bool use_cache, ossim_uint32 cache_tile_size)
   :  d_getTileT (0),
      d_cacheTileSize(1024),
      m_adaptedHandler (0),
      m_cache (0),
      d_useCache (false),
      d_useFauxTile (false)
{
   //###### DEBUG ############
   // ossimMtDebug* mt_debug = ossimMtDebug::instance();
   //d_useCache = mt_debug->handlerCacheEnabled;
   //d_useFauxTile = mt_debug->handlerUseFauxTile;
   //###### END DEBUG ############

   setUseCache(use_cache);
   setCacheTileSize(cache_tile_size);
   setAdaptee(adaptee);
}

//**************************************************************************************************
// Destructor
//**************************************************************************************************
ossimImageHandlerMtAdaptor::~ossimImageHandlerMtAdaptor()
{
   m_adaptedHandler = 0;
   m_cache = 0;
   d_fauxTile = 0;
}

//**************************************************************************************************
//! Sets the handler being adapted.
//**************************************************************************************************
void ossimImageHandlerMtAdaptor::setAdaptee(ossimImageHandler* handler)
{
   m_adaptedHandler = handler;
   if (handler == NULL)
      return;

   // Fetch the adaptee's output list and make it our own:
   ConnectableObjectList output_list = handler->getOutputList();

   if (d_useCache)
   {
      // Create the cache and connect this adaptor as its output:
      m_cache = new ossimCacheTileSource;
      m_cache->setTileSize(ossimIpt(d_cacheTileSize, d_cacheTileSize));
      m_cache->connectMyOutputTo(this, true, false);
      m_cache->changeOwner(this);
      //m_cache->connectMyOutputTo(this, true, false);
      handler->disconnectMyOutputs(output_list, true, false);
      handler->connectMyOutputTo(m_cache.get(), true, true);
   }
   else
   {
      handler->disconnectMyOutputs(output_list, true, false);
      handler->connectMyOutputTo(this, true, false);
   }

   // Finally connect the adaptee's outputs to this and fire connection events:
   connectMyOutputTo(output_list, true, true);
   handler->changeOwner(this);

   if (d_useFauxTile)
   {
      d_fauxTile = (ossimImageData*) handler->getTile(ossimIpt(0,0), 0)->dup();
      //d_fauxTile = new ossimImageData(this,
      //                                handler->getOutputScalarType(),
      //                                handler->getNumberOfOutputBands(),
      //                                handler->getTileWidth(),
      //                                handler->getTileHeight());
      //d_fauxTile->fill(128.0);
   }
}

//**************************************************************************************************
//! Only an ossimImageHandler is allowed as input here.
//**************************************************************************************************
bool ossimImageHandlerMtAdaptor::canConnectMyInputTo(ossim_int32 inputIndex,
                                                     const ossimConnectableObject* obj) const
{
   const ossimImageHandler* h = dynamic_cast<const ossimImageHandler*>(obj);
   if ((inputIndex == 0) && (h != NULL))
      return true;
   return false;
}


//**************************************************************************************************
//! Intercepts the getTile call intended for the adaptee and sets a mutex lock around the
//! adaptee's getTile call.
//**************************************************************************************************
ossimRefPtr<ossimImageData>
   ossimImageHandlerMtAdaptor::getTile(const ossimIpt& origin, ossim_uint32 rLevel)
{
   if (!m_adaptedHandler.valid())
      return NULL;

   // Establish tile rect to call overloaded getTile(tile_rect):
   ossim_uint32 h = m_adaptedHandler->getTileHeight();
   ossim_uint32 w = m_adaptedHandler->getTileWidth();
   ossimIpt lr (origin.x + w - 1, origin.y + h - 1);
   ossimIrect tile_rect (origin, lr);

   // Need to unlock to prevent freezing in the called getTile():
   return getTile(tile_rect, rLevel);
}

//**************************************************************************************************
//! Intercepts the getTile call intended for the adaptee and sets a mutex lock around the
//! adaptee's getTile call.
//**************************************************************************************************
ossimRefPtr<ossimImageData>
   ossimImageHandlerMtAdaptor::getTile(const ossimIrect& tile_rect, ossim_uint32 rLevel)
{
   if (traceDebug())
   {
       std::cout << "TILE: " << tile_rect << std::endl;
   }

   if (d_useFauxTile)
   {
      ossimRefPtr<ossimImageData> ftile = new ossimImageData(*(d_fauxTile.get()));
      ftile->setOrigin(tile_rect.ul());
      return ftile;
   }

   if (!m_adaptedHandler.valid())
      return NULL;

   // The sole purpose of the adapter is this mutex lock around the actual handler getTile:
   //std::lock_guard<std::mutex> lock(m_mutex);

   ossimRefPtr<ossimImageData> tile = new ossimImageData();
   ossimRefPtr<ossimImageData> temp_tile = 0;
   double dt = ossimTimer::instance()->time_s();

   //writeTime();
   if (traceDebug())
   {
     std::cout << "WAIT LOCK: " << tile_rect << std::endl;
   }
   std::lock_guard<std::mutex> lock(m_mutex);

   if (traceDebug())
   {
     std::cout << "START LOCK: " << tile_rect << std::endl;
   }

   if (d_useCache)
      temp_tile = m_cache->getTile(tile_rect, rLevel);
   else
      temp_tile = m_adaptedHandler->getTile(tile_rect, rLevel);
   d_getTileT += ossimTimer::instance()->time_s() - dt;

   // We make our own instance of a tile and copy the adaptee's returned tile to it. This avoids
   // the product tile from changing while being processed up the chain. The adaptee's tile can
   // change as soon as the mutex lock is released:

   if (temp_tile.valid())
      *tile = *(temp_tile.get());
   else
      tile = NULL;

   //writeTime();
   if (traceDebug())
   {
      std::cout << "END LOCK: " << tile_rect << std::endl;
   }
   if (traceDebug())
   {
       std::cout << "END TILE: " << tile_rect << std::endl;
   }

   return tile;
}

//**************************************************************************************************
//! Intercepts the getTile call intended for the adaptee and sets a mutex lock around the
//! adaptee's getTile call.
//**************************************************************************************************
bool ossimImageHandlerMtAdaptor::getTile(ossimImageData* tile, ossim_uint32 rLevel)
{
   if ((!m_adaptedHandler.valid()) || (tile == NULL))
      return false;

   // The sole purpose of the adapter is this mutex lock around the actual handler getTile:
   std::lock_guard<std::mutex> lock(m_mutex);

   // This is effectively a copy of ossimImageSource::getTile(ossimImageData*). It is reimplemented
   // here to save two additional function calls:
   tile->ref();
   bool status = true;
   ossimIrect tile_rect = tile->getImageRectangle();

   ossimRefPtr<ossimImageData> temp_tile = 0;
   if (d_useCache)
      temp_tile = m_cache->getTile(tile_rect, rLevel);
   else
      temp_tile = m_adaptedHandler->getTile(tile_rect, rLevel);

   if (temp_tile.valid())
      *tile = *(temp_tile.get());
   else
      status = false;
   tile->unref();

   return status;
}

//**************************************************************************************************
//! Method to save the state of an object to a keyword list.
//! Return true if ok or false on error.
//**************************************************************************************************
bool ossimImageHandlerMtAdaptor::saveState(ossimKeywordlist& kwl, const char* prefix)const
{
   if (!m_adaptedHandler.valid())
      return false;

   // Skip the ossimImageHandler::saveState() since it is not necessary here:
   ossimImageSource::saveState(kwl, prefix);

   kwl.add(prefix, ADAPTEE_ID_KW, m_adaptedHandler->getId().getId());

   return true;
}

//**************************************************************************************************
//! Method to the load (recreate) the state of an object from a keyword
//! list.  Return true if ok or false on error.
//**************************************************************************************************
bool ossimImageHandlerMtAdaptor::loadState(const ossimKeywordlist& kwl, const char* prefix)
{
   m_adaptedHandler = 0;

   // Skip the ossimImageHandler::loadState() since it is not necessary here:
   if (!ossimImageSource::loadState(kwl, prefix))
      return false;

   // The adaptee's ID at least will be in the KWL:
   ossimString value = kwl.find(prefix, ADAPTEE_ID_KW);
   if (value.empty())
      return false;

   return true;
}

//**************************************************************************************************
// The following are virtuals in the base class. Implemented here as pass-through to adaptee
//**************************************************************************************************
ossim_uint32 ossimImageHandlerMtAdaptor::getNumberOfInputBands() const
{
   if (m_adaptedHandler.valid())
      return m_adaptedHandler->getNumberOfInputBands();
   return 0;
}

bool ossimImageHandlerMtAdaptor::isOpen() const
{
   if (m_adaptedHandler.valid())
      return m_adaptedHandler->isOpen();
   return false;
}

bool ossimImageHandlerMtAdaptor::open()
{
   if (m_adaptedHandler.valid())
      return m_adaptedHandler->open();
   return false;
}

ossim_uint32 ossimImageHandlerMtAdaptor::getNumberOfLines(ossim_uint32 resLevel) const
{
   if (m_adaptedHandler.valid())
      return m_adaptedHandler->getNumberOfLines(resLevel);
   return 0;
}

ossim_uint32 ossimImageHandlerMtAdaptor::getNumberOfSamples(ossim_uint32 resLevel) const
{
   if (m_adaptedHandler.valid())
      return m_adaptedHandler->getNumberOfSamples(resLevel);
   return 0;
}

ossim_uint32 ossimImageHandlerMtAdaptor::getImageTileWidth() const
{
   if (m_adaptedHandler.valid())
      return m_adaptedHandler->getImageTileWidth();
   return 0;
}

ossim_uint32 ossimImageHandlerMtAdaptor::getImageTileHeight() const
{
   if (m_adaptedHandler.valid())
      return m_adaptedHandler->getImageTileHeight();
   return 0;
}

ossimString ossimImageHandlerMtAdaptor::getLongName() const
{
   if (m_adaptedHandler.valid())
      return m_adaptedHandler->getLongName();
   return ossimString();
}

ossimString ossimImageHandlerMtAdaptor::getShortName() const
{
   if (m_adaptedHandler.valid())
      return m_adaptedHandler->getShortName();
   return ossimString();
}

void ossimImageHandlerMtAdaptor::close()
{
   removeListener((ossimConnectableObjectListener*)this);
   this->disconnectAllOutputs();
   m_cache = 0;
   if (m_adaptedHandler.valid())
   {
       m_adaptedHandler->closeOverview();
       m_adaptedHandler->close();
   }
   d_fauxTile = 0;
}

ossim_uint32 ossimImageHandlerMtAdaptor::getNumberOfOutputBands() const
{
   if (m_adaptedHandler.valid())
      return m_adaptedHandler->getNumberOfOutputBands();
   return 0;
}

void ossimImageHandlerMtAdaptor::setUseCache(bool use_cache)
{
   d_useCache = use_cache;
}

void ossimImageHandlerMtAdaptor::setCacheTileSize(ossim_uint32 cache_tile_size)
{
   d_cacheTileSize = cache_tile_size;
}

ossim_uint32 ossimImageHandlerMtAdaptor::getNumberOfDecimationLevels() const
{
   if (m_adaptedHandler.valid())
      return m_adaptedHandler->getNumberOfDecimationLevels();
   return 0;
}

void ossimImageHandlerMtAdaptor::writeTime() const
{
#if 0  /* not portable (drb) */
   struct timeval tv;
   struct timezone tz;
   struct tm *tm;
   gettimeofday(&tv, &tz);
   tm=localtime(&tv.tv_sec);
   printf("%d:%02d:%02d.%ld ", tm->tm_hour, tm->tm_min,tm->tm_sec,tv.tv_usec);
#endif
   // Sorry no usecs...
   time_t rawTime = (time_t)ossim::getTime();
   char buf[9];
   strftime(buf, 9, "%H:%M:%S", gmtime(&rawTime));
   cerr << buf << std::endl;
}

ossimScalarType ossimImageHandlerMtAdaptor::getOutputScalarType() const
{
   if (m_adaptedHandler.valid())
      return m_adaptedHandler->getOutputScalarType();
   return OSSIM_SCALAR_UNKNOWN;
}

ossim_uint32 ossimImageHandlerMtAdaptor::getTileWidth() const
{
   if (m_adaptedHandler.valid())
      return m_adaptedHandler->getTileWidth();
   return 0;
}

ossim_uint32 ossimImageHandlerMtAdaptor::getTileHeight() const
{
   if (m_adaptedHandler.valid())
      return m_adaptedHandler->getTileHeight();
   return 0;
}

ossim_float64 ossimImageHandlerMtAdaptor::getMinPixelValue(ossim_uint32 band) const
{
   if (m_adaptedHandler.valid())
      return m_adaptedHandler->getMinPixelValue(band);
   return 0.0;
}

ossim_float64 ossimImageHandlerMtAdaptor::getMaxPixelValue(ossim_uint32 band) const
{
   if (m_adaptedHandler.valid())
      return m_adaptedHandler->getMaxPixelValue(band);
   return 0.0;
}

ossim_float64 ossimImageHandlerMtAdaptor::getNullPixelValue(ossim_uint32 band) const
{
   if (m_adaptedHandler.valid())
      return m_adaptedHandler->getNullPixelValue(band);
   return 0.0;
}