#include "trenderer.h"

#include "trendererP.h"

// TnzCore includes

#include "tsystem.h"

#include "tthreadmessage.h"

#include "tthread.h"

#include "tconvert.h"

#include "tstream.h"

#include "trasterimage.h"

#include "trop.h"

#include "timagecache.h"

#include "tstopwatch.h"

// TnzBase includes

#include "trenderresourcemanager.h"

#include "tpredictivecachemanager.h"

// Qt includes

#include <qeventloop></qeventloop>

#include <qcoreapplication></qcoreapplication>

#include <qreadwritelock></qreadwritelock>

#include <qreadlocker></qreadlocker>

#include <qwritelocker></qwritelocker>

#include <qthreadstorage></qthreadstorage>

// Debug

// #define DIAGNOSTICS

// #include "diagnostics.h"

#include <queue></queue>

#include <functional></functional>

#include <qoffscreensurface></qoffscreensurface>

#include <qsurfaceformat></qsurfaceformat>

#include <qopenglcontext></qopenglcontext>

#include <qthread></qthread>

#include <qguiapplication></qguiapplication>

using namespace TThread;

std::vector<const *="" tfx=""> calculateSortedFxs(TRasterFxP rootFx);</const>

//================================================================================

//    Preliminaries - Anonymous namespace

//================================================================================

namespace {

// TRenderer-thread association storage. It provides TRenderers the per-thread

// singleton status from inside a rendering process.

QThreadStorage<trendererimp **=""> rendererStorage;</trendererimp>

// Same for render process ids.

QThreadStorage<unsigned *="" long=""> renderIdsStorage;</unsigned>

//-------------------------------------------------------------------------------

// Interlacing functions for field-based rendering

inline void interlace(TRasterP f0, const TRasterP &f1, int field) {

  if (f0->getPixelSize() != f1->getPixelSize())

    throw TException("interlace: invalid raster combination");

  assert(f0->getBounds() == f1->getBounds());

  int outWrapBytes  = f0->getWrap() * f0->getPixelSize();

  int inWrapBytes   = f1->getWrap() * f1->getPixelSize();

  int outWrapBytes2 = outWrapBytes * 2;

  int inWrapBytes2  = inWrapBytes * 2;

  int rowSize       = f0->getLx() * f0->getPixelSize();

  f1->lock();

  f0->lock();

  UCHAR *rowIn  = f1->getRawData();

  UCHAR *rowOut = f0->getRawData();

  if (field) rowIn += inWrapBytes;

  int count = f0->getLy() / 2;

  while (--count) {

    memcpy(rowOut, rowIn, rowSize);

    rowIn += inWrapBytes2;

    rowOut += outWrapBytes2;

  }

  f1->unlock();

  f0->unlock();

}

}  // anonymous namespace

//================================================================================

//    Preliminaries - output rasters management

//================================================================================

//===================

//    RasterItem

//-------------------

//! The RasterItem class represents a reusable output raster for rendering

//! purposes.

//! RasterItems are used as TRenderer's output rasters in order to avoid the

//! overhead

//! of allocating one raster for each rendered frame.

//! Each frame-rendering task will lock a RasterItem as preallocated output

//! before starting the

//! render, therefore changing the \b RasterItem::m_busy attribute accordingly.

//! As each frame is rendered on a separate thread, the number of RasterItems

//! that

//! TRenderer will allocate depends on the number of rendering threads specified

//! to it.

//! \sa RasterPool, TRenderer classes

class RasterItem {

  std::string m_rasterId;

public:

  int m_bpp;

  bool m_busy;

  //---------------------------------------------------------

  RasterItem(const TDimension &size, int bpp, bool busyFlag)

      : m_rasterId(""), m_bpp(bpp), m_busy(busyFlag) {

    TRasterP raster;

    if (bpp == 32)

      raster = TRaster32P(size);

    else if (bpp == 64)

      raster = TRaster64P(size);

    else if (bpp == 128)

      raster = TRasterFP(size);

    else

      assert(false);

    m_rasterId = TImageCache::instance()->getUniqueId();

    TImageCache::instance()->add(m_rasterId, TRasterImageP(raster));

  }

  //---------------------------------------------------------

  ~RasterItem() { TImageCache::instance()->remove(m_rasterId); }

  //---------------------------------------------------------

  TRasterP getRaster() const {

    TRasterImageP rimg =

        (TRasterImageP)TImageCache::instance()->get(m_rasterId, true);

    return rimg ? rimg->getRaster() : TRasterP();

  }

private:

  // not implemented

  RasterItem();

  RasterItem(const TRaster &RasterItem);

};

//================================================================================

//===================

//    RasterPool

//-------------------

//! Stores a list of RasterItems under TRenderer's requests.

class RasterPool {

  TDimension m_size;

  int m_bpp;

  typedef std::list<rasteritem *=""> RasterRepository;</rasteritem>

  RasterRepository m_rasterRepository;

  TThread::Mutex m_repositoryLock;

public:

  RasterPool() : m_size(-1, -1) {}

  ~RasterPool();

  void setRasterSpecs(const TDimension &size, int bpp);

  void getRasterSpecs(TDimension &size, int &bpp) {

    size = m_size;

    bpp  = m_bpp;

  }

  TRasterP getRaster();

  TRasterP getRaster(const TDimension &size, int bpp);

  void releaseRaster(const TRasterP &r);

  void clear();

};

//---------------------------------------------------------

void RasterPool::clear() {

  QMutexLocker sl(&m_repositoryLock);

  clearPointerContainer(m_rasterRepository);

}

//---------------------------------------------------------

void RasterPool::setRasterSpecs(const TDimension &size, int bpp) {

  if (size != m_size || bpp != m_bpp) {

    m_size = size;

    m_bpp  = bpp;

    clear();

  }

}

//---------------------------------------------------------

TRasterP RasterPool::getRaster(const TDimension &size, int bpp) {

  assert(size == m_size && bpp == m_bpp);

  return getRaster();

}

//---------------------------------------------------------

//! Returns for the first not-busy raster

TRasterP RasterPool::getRaster() {

  QMutexLocker sl(&m_repositoryLock);

  RasterRepository::iterator it = m_rasterRepository.begin();

  while (it != m_rasterRepository.end()) {

    RasterItem *rasItem = *it;

    if (rasItem->m_busy == false) {

      TRasterP raster = rasItem->getRaster();

      if (!raster) {

        delete rasItem;

        m_rasterRepository.erase(it++);

        continue;

      }

      rasItem->m_busy = true;

      raster->clear();

      return raster;

    }

    ++it;

  }

  RasterItem *rasItem = new RasterItem(m_size, m_bpp, true);

  m_rasterRepository.push_back(rasItem);

  return rasItem->getRaster();

}

//---------------------------------------------------------

//! Cerca il raster \b r in m_rasterRepository; se lo trova setta a \b false il

//! campo \b m_busy.

void RasterPool::releaseRaster(const TRasterP &r) {

  if (!r) return;

  QMutexLocker sl(&m_repositoryLock);

  for (RasterRepository::iterator it = m_rasterRepository.begin();

       it != m_rasterRepository.end(); ++it) {

    RasterItem *rasItem = *it;

    if (rasItem->getRaster()->getRawData() == r->getRawData()) {

      assert(rasItem->m_busy);

      rasItem->m_busy = false;

      return;

    }

  }

}

//---------------------------------------------------------

RasterPool::~RasterPool() {

  /*if (m_rasterRepository.size())

TSystem::outputDebug("~RasterPool: itemCount = " + toString

((int)m_rasterRepository.size())+" (should be 0)\n");*/

  // Release all raster items

  clear();

}

//================================================================================

//    Internal rendering classes declaration

//================================================================================

//=====================

//    TRendererImp

//---------------------

class TRendererImp final : public TSmartObject {

public:

  struct RenderInstanceInfos {

    int m_canceled;

    int m_activeTasks;

    int m_status;

    RenderInstanceInfos()

        : m_canceled(false), m_activeTasks(0), m_status(TRenderer::IDLE) {}

  };

public:

  typedef std::vector<trenderport *=""> PortContainer;</trenderport>

  typedef PortContainer::iterator PortContainerIterator;

  QReadWriteLock m_portsLock;

  PortContainer m_ports;

  QMutex m_renderInstancesMutex;

  std::map<unsigned long,="" renderinstanceinfos=""> m_activeInstances;</unsigned>

  //! The renderer Id is a number uniquely associated with a TRenderer instance.

  static unsigned long m_rendererIdCounter;

  //! The render Id is a number uniquely associated with a render process

  //! started

  //! with the startRendering() method.

  static unsigned long m_renderIdCounter;

  unsigned long m_rendererId;

  Executor m_executor;

  bool m_precomputingEnabled;

  RasterPool m_rasterPool;

  std::vector<trenderresourcemanager *=""> m_managers;</trenderresourcemanager>

  TAtomicVar m_undoneTasks;

  // std::vector<qeventloop*> m_waitingLoops;</qeventloop*>

  std::vector<bool *=""> m_waitingLoops;</bool>

  TRasterFxP rootFx;

  //-------------------------------------------------------------

  TRendererImp(int nThreads);

  ~TRendererImp();

  void startRendering(unsigned long renderId,

                      const std::vector<trenderer::renderdata> &renderDatas);</trenderer::renderdata>

  void notifyRasterStarted(const TRenderPort::RenderData &rd);

  void notifyRasterCompleted(const TRenderPort::RenderData &rd);

  void notifyRasterFailure(const TRenderPort::RenderData &rd, TException &e);

  void notifyRenderFinished(bool isCanceled = false);

  void addPort(TRenderPort *port);

  void removePort(TRenderPort *port);

  void abortRendering(unsigned long renderId);

  void stopRendering(bool waitForCompleteStop);

  bool hasToDie(unsigned long renderId);

  int getRenderStatus(unsigned long renderId);

  void enablePrecomputing(bool on) { m_precomputingEnabled = on; }

  bool isPrecomputingEnabled() const { return m_precomputingEnabled; }

  void setThreadsCount(int nThreads) { m_executor.setMaxActiveTasks(nThreads); }

  inline void declareRenderStart(unsigned long renderId);

  inline void declareRenderEnd(unsigned long renderId);

  inline void declareFrameStart(double frame);

  inline void declareFrameEnd(double frame);

  inline void declareStatusStart(int renderStatus);

  inline void declareStatusEnd(int renderStatus);

  void quitWaitingLoops();

};

#ifdef _WIN32

template class DVAPI TSmartPointerT<trendererimp>;</trendererimp>

#endif

typedef TSmartPointerT<trendererimp> TRendererImpP;</trendererimp>

unsigned long TRendererImp::m_rendererIdCounter = 0;

unsigned long TRendererImp::m_renderIdCounter   = 0;

//================================================================================

//===================

//    RenderTask

//-------------------

class RenderTask final : public TThread::Runnable {

  std::vector<double> m_frames;</double>

  unsigned long m_taskId;

  unsigned long m_renderId;

  TRendererImpP m_rendererImp;

  TFxPair m_fx;

  TPointD m_framePos;

  TDimension m_frameSize;

  TRenderSettings m_info;

  bool m_fieldRender, m_stereoscopic;

  Mutex m_rasterGuard;

  TTile m_tileA;  // in normal and field rendering, Rendered at given frame; in

                  // stereoscopic, rendered left frame

  TTile m_tileB;  // in  field rendering, rendered at frame + 0.5; in

                  // stereoscopic, rendered right frame

public:

  RenderTask(unsigned long renderId, unsigned long taskId, double frame,

             const TRenderSettings &ri, const TFxPair &fx,

             const TPointD &framePos, const TDimension &frameSize,

             const TRendererImpP &rendererImp);

  ~RenderTask() {}

  void addFrame(double frame) { m_frames.push_back(frame); }

  void buildTile(TTile &tile);

  void releaseTiles();

  void onFrameStarted();

  void onFrameCompleted();

  void onFrameFailed(TException &e);

  void preRun();

  void run() override;

  int taskLoad() override { return 100; }

  void onFinished(TThread::RunnableP) override;

};

//================================================================================

//    Implementations

//================================================================================

//==================

//    TRenderer

//------------------

TRenderer::TRenderer(int nThread) {

  m_imp = new TRendererImp(nThread);  // Already adds a ref

}

//---------------------------------------------------------

TRenderer::TRenderer(TRendererImp *imp) : m_imp(imp) {

  if (m_imp) m_imp->addRef();

}

//---------------------------------------------------------

TRenderer::TRenderer(const TRenderer &r) : m_imp(r.m_imp) {

  if (m_imp) m_imp->addRef();

}

//---------------------------------------------------------

void TRenderer::operator=(const TRenderer &r) {

  m_imp = r.m_imp;

  if (m_imp) m_imp->addRef();

}

//---------------------------------------------------------

TRenderer::~TRenderer() {

  if (m_imp) m_imp->release();

}

//---------------------------------------------------------

//! The static method is intended for use inside a rendering thread only. It

//! returns

//! a copy of the eventual TRenderer interface installed on the thread -

//! or an empty TRenderer if none happened to be. It can be set using the

//! install() and uninstall() methods.

TRenderer TRenderer::instance() {

  TRendererImp **lData = rendererStorage.localData();

  if (lData) return TRenderer(*lData);

  return 0;

}

//---------------------------------------------------------

//! Returns the renderer id.

unsigned long TRenderer::rendererId() { return m_imp->m_rendererId; }

//---------------------------------------------------------

//! Returns the rendering process id currently running on the invoking

//! thread.

unsigned long TRenderer::renderId() {

  unsigned long *lData = renderIdsStorage.localData();

  return lData ? *lData : -1;

}

//---------------------------------------------------------

//! Builds and returns an id for starting a new rendering process.

unsigned long TRenderer::buildRenderId() {

  return TRendererImp::m_renderIdCounter++;

}

//---------------------------------------------------------

//! Returns the renderId that will be used by the next startRendering() call.

//! This method can be used to retrieve the renderId of a rendering instance

//! before it is actually started - provided that no other render instance

//! is launched inbetween.

unsigned long TRenderer::nextRenderId() {

  return TRendererImp::m_renderIdCounter;

}

//---------------------------------------------------------

inline void TRendererImp::declareRenderStart(unsigned long renderId) {

  // Inform the resource managers

  for (unsigned int i = 0; i < m_managers.size(); ++i)

    m_managers[i]->onRenderInstanceStart(renderId);

}

//! Declares that the render process of passed renderId is about to start.

void TRenderer::declareRenderStart(unsigned long renderId) {

  m_imp->declareRenderStart(renderId);

}

//---------------------------------------------------------

inline void TRendererImp::declareRenderEnd(unsigned long renderId) {

  // Inform the resource managers

  for (int i = m_managers.size() - 1; i >= 0; --i)

    m_managers[i]->onRenderInstanceEnd(renderId);

}

//! Declares that the render process of passed renderId has ended.

void TRenderer::declareRenderEnd(unsigned long renderId) {

  m_imp->declareRenderEnd(renderId);

}

//---------------------------------------------------------

inline void TRendererImp::declareFrameStart(double frame) {

  // Inform the resource managers

  for (unsigned int i = 0; i < m_managers.size(); ++i)

    m_managers[i]->onRenderFrameStart(frame);

}

//! Declares that render of passed frame is about to start.

void TRenderer::declareFrameStart(double frame) {

  m_imp->declareFrameStart(frame);

}

//---------------------------------------------------------

inline void TRendererImp::declareFrameEnd(double frame) {

  // Inform the resource managers

  for (int i = m_managers.size() - 1; i >= 0; --i)

    m_managers[i]->onRenderFrameEnd(frame);

}

//! Declares that render of passed has ended.

void TRenderer::declareFrameEnd(double frame) { m_imp->declareFrameEnd(frame); }

//---------------------------------------------------------

inline void TRendererImp::declareStatusStart(int renderStatus) {

  // Inform the resource managers

  for (unsigned int i = 0; i < m_managers.size(); ++i)

    m_managers[i]->onRenderStatusStart(renderStatus);

}

//---------------------------------------------------------

inline void TRendererImp::declareStatusEnd(int renderStatus) {

  // Inform the resource managers

  for (int i = m_managers.size() - 1; i >= 0; --i)

    m_managers[i]->onRenderStatusEnd(renderStatus);

}

//---------------------------------------------------------

//! Installs the specified render process on the invoking thread.

void TRenderer::install(unsigned long renderId) {

  m_imp->addRef();

  rendererStorage.setLocalData(new (TRendererImp *)(m_imp));

  renderIdsStorage.setLocalData(new unsigned long(renderId));

}

//---------------------------------------------------------

//! Uninstalls any rendering process active on the invoking thread.

void TRenderer::uninstall() {

  rendererStorage.setLocalData(0);

  renderIdsStorage.setLocalData(0);

  m_imp->release();

}

//---------------------------------------------------------

TRenderResourceManager *TRenderer::getManager(unsigned int id) const {

  return m_imp->m_managers[id];

}

//---------------------------------------------------------

void TRenderer::enablePrecomputing(bool on) { m_imp->enablePrecomputing(on); }

//---------------------------------------------------------

bool TRenderer::isPrecomputingEnabled() const {

  return m_imp->isPrecomputingEnabled();

}

//---------------------------------------------------------

void TRenderer::setThreadsCount(int nThreads) {

  m_imp->setThreadsCount(nThreads);

}

//---------------------------------------------------------

void TRenderer::addPort(TRenderPort *port) { m_imp->addPort(port); }

//---------------------------------------------------------

void TRenderer::removePort(TRenderPort *port) { m_imp->removePort(port); }

//---------------------------------------------------------

unsigned long TRenderer::startRendering(double f, const TRenderSettings &info,

                                        const TFxPair &actualRoot) {

  assert(f >= 0);

  std::vector<renderdata> *rds = new std::vector<renderdata>;</renderdata></renderdata>

  rds->push_back(RenderData(f, info, actualRoot));

  return startRendering(rds);

}

//---------------------------------------------------------

//! Queues a rendering event in the main event loop.

//! NOTE: The passed pointer is owned by the TRenderer after it is submitted for

//! rendering -

//! do not delete it later.

unsigned long TRenderer::startRendering(

    const std::vector<renderdata> *renderDatas) {</renderdata>

  if (renderDatas->empty()) {

    delete renderDatas;

    return -1;

  }

  // Build a new render Id

  unsigned long renderId = m_imp->m_renderIdCounter++;

  TRendererStartInvoker::StartInvokerRenderData srd;

  srd.m_renderId         = renderId;

  srd.m_renderDataVector = renderDatas;

  TRendererStartInvoker::instance()->emitStartRender(m_imp, srd);

  return renderId;

}

//---------------------------------------------------------

void TRenderer::abortRendering(unsigned long renderId) {

  m_imp->abortRendering(renderId);

}

//---------------------------------------------------------

void TRenderer::stopRendering(bool waitForCompleteStop) {

  m_imp->stopRendering(waitForCompleteStop);

}

//---------------------------------------------------------

bool TRenderer::isAborted(unsigned long renderId) const {

  return m_imp->hasToDie(renderId);

}

//---------------------------------------------------------

int TRenderer::getRenderStatus(unsigned long renderId) const {

  return m_imp->getRenderStatus(renderId);

}

//================================================================================

//=====================

//    TRendererImp

//---------------------

TRendererImp::TRendererImp(int nThreads)

    : m_executor()

    , m_undoneTasks()

    , m_rendererId(m_rendererIdCounter++)

    , m_precomputingEnabled(true) {

  m_executor.setMaxActiveTasks(nThreads);

  std::vector<trenderresourcemanagergenerator *=""> &generators =</trenderresourcemanagergenerator>

      TRenderResourceManagerGenerator::generators(false);

  // May be adopted by other TRenderers from now on.

  addRef();

  rendererStorage.setLocalData(new (TRendererImp *)(this));

  unsigned int i;

  for (i = 0; i < generators.size(); ++i) {

    TRenderResourceManager *manager = (*generators[i])();

    if (manager) m_managers.push_back(manager);

  }

  rendererStorage.setLocalData(0);

}

//---------------------------------------------------------

TRendererImp::~TRendererImp() {

  rendererStorage.setLocalData(new (TRendererImp *)(this));

  int i;

  for (i = m_managers.size() - 1; i >= 0; --i)

    if (m_managers[i]->renderHasOwnership()) delete m_managers[i];

  rendererStorage.setLocalData(0);

}

//---------------------------------------------------------

void TRendererImp::addPort(TRenderPort *port) {

  QWriteLocker sl(&m_portsLock);

  PortContainerIterator it = std::find(m_ports.begin(), m_ports.end(), port);

  if (it == m_ports.end()) m_ports.push_back(port);

}

//---------------------------------------------------------

void TRendererImp::removePort(TRenderPort *port) {

  QWriteLocker sl(&m_portsLock);

  PortContainerIterator it = std::find(m_ports.begin(), m_ports.end(), port);

  if (it != m_ports.end()) m_ports.erase(it);

}

//---------------------------------------------------------

bool TRendererImp::hasToDie(unsigned long renderId) {

  QMutexLocker sl(&m_renderInstancesMutex);

  std::map<unsigned long,="" renderinstanceinfos="">::iterator it =</unsigned>

      m_activeInstances.find(renderId);

  assert(it != m_activeInstances.end());

  return it == m_activeInstances.end() ? true : it->second.m_canceled;

}

//---------------------------------------------------------

int TRendererImp::getRenderStatus(unsigned long renderId) {

  QMutexLocker sl(&m_renderInstancesMutex);

  std::map<unsigned long,="" renderinstanceinfos="">::iterator it =</unsigned>

      m_activeInstances.find(renderId);

  assert(it != m_activeInstances.end());

  return it == m_activeInstances.end() ? true : it->second.m_status;

}

//---------------------------------------------------------

void TRendererImp::abortRendering(unsigned long renderId) {

  QMutexLocker sl(&m_renderInstancesMutex);

  std::map<unsigned long,="" renderinstanceinfos="">::iterator it =</unsigned>

      m_activeInstances.find(renderId);

  if (it != m_activeInstances.end()) it->second.m_canceled = true;

}

//---------------------------------------------------------

void TRendererImp::stopRendering(bool waitForCompleteStop) {

  QMutexLocker sl(&m_renderInstancesMutex);

  {

    // Tasks already stop rendering on their own when they don't find their

    // render ids here.

    std::map<unsigned long,="" renderinstanceinfos="">::iterator it;</unsigned>

    for (it = m_activeInstances.begin(); it != m_activeInstances.end(); ++it)

      it->second.m_canceled = true;

  }

  if (waitForCompleteStop && m_undoneTasks > 0) {

    // Sometimes, QEventLoop suddenly stops processing slots (especially those

    // notifications

    // from active rendering instances) - therefore resulting in a block of the

    // application.

    // I've not figured out why (#QTBUG-11649?) - but substituting with a plain

    // while

    // seems to do the trick...

    /*QEventLoop eventLoop;

m_waitingLoops.push_back(&eventLoop);

eventLoop.exec();*/

    bool loopQuit = false;

    m_waitingLoops.push_back(&loopQuit);

    sl.unlock();

    while (!loopQuit)

      QCoreApplication::processEvents(QEventLoop::AllEvents |

                                      QEventLoop::WaitForMoreEvents);

  }

}

//---------------------------------------------------------

void TRendererImp::quitWaitingLoops() {

  // Make the stopRendering waiting loops quit

  while (!m_waitingLoops.empty()) {

    // rendererImp->m_waitingLoops.back()->quit();

    *m_waitingLoops.back() = true;

    m_waitingLoops.pop_back();

  }

}

//---------------------------------------------------------

void TRendererImp::notifyRasterStarted(const TRenderPort::RenderData &rd) {

  // Since notifications may trigger port removals, we always work on a copy of

  // the ports

  // vector.

  TRendererImp::PortContainer portsCopy;

  {

    QReadLocker sl(&m_portsLock);

    portsCopy = m_ports;

  }

  for (PortContainerIterator it = portsCopy.begin(); it != portsCopy.end();

       ++it)

    (*it)->onRenderRasterStarted(rd);

}

//---------------------------------------------------------

void TRendererImp::notifyRasterCompleted(const TRenderPort::RenderData &rd) {

  TRendererImp::PortContainer portsCopy;

  {

    QReadLocker sl(&m_portsLock);

    portsCopy = m_ports;

  }

  assert(rd.m_rasA);

  for (PortContainerIterator it = portsCopy.begin(); it != portsCopy.end();

       ++it)

    (*it)->onRenderRasterCompleted(rd);

}

//---------------------------------------------------------

void TRendererImp::notifyRasterFailure(const TRenderPort::RenderData &rd,

                                       TException &e) {

  TRendererImp::PortContainer portsCopy;

  {

    QReadLocker sl(&m_portsLock);

    portsCopy = m_ports;

  }

  for (PortContainerIterator it = portsCopy.begin(); it != portsCopy.end();

       ++it)

    (*it)->onRenderFailure(rd, e);

}

//---------------------------------------------------------

void TRendererImp::notifyRenderFinished(bool isCanceled) {

  TRendererImp::PortContainer portsCopy;

  {

    QReadLocker sl(&m_portsLock);

    portsCopy = m_ports;

  }