#define _CRT_SECURE_NO_WARNINGS (1)   // Warning treated as errors

#define _CRT_SECURE_NO_DEPRECATE (1)  // use of fopen deprecated

// Tnz includes (-.-')

#include "../toonz/tapp.h"

// TFarmController includes

#include "tfarmcontroller.h"

// TnzStdfx includes

#include "stdfx/shaderfx.h"

// TnzLib includes

#include "toonz/toonzfolders.h"

#include "toonz/tlog.h"

#include "toonz/tstageobjecttree.h"

#include "toonz/stage.h"

#include "toonz/preferences.h"

#include "toonz/tproject.h"

#include "toonz/toonzscene.h"

#include "toonz/sceneproperties.h"

#include "toonz/txshsoundlevel.h"

#include "toonz/txshsoundcolumn.h"

#include "toonz/tcamera.h"

#include "toonz/scenefx.h"

#include "toonz/movierenderer.h"

#include "toonz/multimediarenderer.h"

#include "toutputproperties.h"

#include "toonz/imagestyles.h"

// TnzSound includes

#include "tnzsound.h"

// TnzImage includes

#include "timage_io.h"

#include "tnzimage.h"

#include "tflash.h"

#ifdef _WIN32

#include "avicodecrestrictions.h"

#endif

// TnzBase includes

#include "tcli.h"

#include "tunit.h"

#include "tenv.h"

#include "tpassivecachemanager.h"

//#include "tcacheresourcepool.h"

// TnzCore includes

#include "tsystem.h"

#include "tsmartpointer.h"

#include "tthread.h"

#include "tthreadmessage.h"

#include "tmsgcore.h"

#include "tstopwatch.h"

#include "timagecache.h"

#include "tstream.h"

#include "tfilepath_io.h"

#include "tpluginmanager.h"

#include "tiio_std.h"

#include "tsimplecolorstyles.h"

#include "tvectorbrushstyle.h"

#include "tpalette.h"

// TnzQt includes

#include "toonzqt/pluginloader.h"

// Qt includes

#include <qapplication></qapplication>

#include <qwaitcondition></qwaitcondition>

#include <qmessagebox></qmessagebox>

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

using namespace std;

using namespace TCli;

typedef ArgumentT<tfilepath> FilePathArgument;</tfilepath>

typedef QualifierT<tfilepath> FilePathQualifier;</tfilepath>

namespace {

double currentCameraSize = 12;

double getCurrentCameraSize() { return currentCameraSize; }

}

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

//

// Application names and versions

//

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

namespace {

//

// applicationName & Version compongono la registry root

// applicationFullName e' la title bar (e compare dentro i .tnz)

// rootVarName e' quello che dice di essere

// systemVarPrefix viene prefissa a tutte le variabili nei registry

//   (es <systemvarprefix>PROJECTS etc.)</systemvarprefix>

//

const char *applicationName     = "OpenToonz";

const char *applicationVersion  = "1.0";

const char *applicationFullName = "OpenToonz 1.0";

const char *rootVarName         = "TOONZROOT";

const char *systemVarPrefix     = "TOONZ";

// TODO: forse anche questo andrebbe in tnzbase

// ci possono essere altri programmi offline oltre al tcomposer

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

//

// fatalError

//

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

void fatalError(string msg) {

#ifdef _WIN32

  std::cout << msg << std::endl;

  // MessageBox(0,msg.c_str(),"Fatal error",MB_ICONERROR);

  exit(1);

#else

  // TODO: Come si fa ad aggiungere un messaggio di errore qui?

  std::cout << msg << std::endl;

  abort();

#endif

}

//

#ifdef MACOSX

inline bool isBlank(char c) { return c == ' ' || c == '\t' || c == '\n'; }

//

// TODO: se questo sistema e' il modo Mac di emulare i registry di windows

// allora **DEVE** essere messo in libreria. Parliamone.

//

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

// setToonzFolder

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

// Ritorna il path della variabile passata come secondo argomento

// entrambe vengono lette da un file di testo (filename).

TFilePath setToonzFolder(const TFilePath &filename, std::string toonzVar) {

  Tifstream is(filename);

  if (!is) return TFilePath();

  char buffer[1024];

  while (is.getline(buffer, sizeof(buffer))) {

    // le righe dentro toonzenv.txt sono del tipo

    // export set TOONZPROJECT="....."

    // devo trovare la linea che contiene toonzVar

    char *s = buffer;

    while (isBlank(*s)) s++;

    // Se la riga  vuota, o inizia per # o ! salto alla prossima

    if (*s == '\0' || *s == '#' || *s == '!') continue;

    if (*s == '=') continue;  // errore: nome variabile non c'

    char *t = s;

    // Mi prendo la sottoStringa fino all'=

    while (*t && *t != '=') t++;

    if (*t != '=') continue;  // errore: manca '='

    char *q = t;

    // Torno indietro fino al primo blank

    while (q > s && !isBlank(*(q - 1))) q--;

    if (q == s)

      continue;  // non dovrebbe mai succedere: prima di '=' tutti blanks

    string toonzVarString(q, t);

    // Confronto la stringa trovata con toonzVar, se   lei vado avanti.

    if (toonzVar != toonzVarString) continue;  // errore: stringhe diverse

    s = t + 1;

    // Salto gli spazi

    while (isBlank(*s)) s++;

    if (*s == '\0') continue;  // errore: dst vuoto

    t = s;

    while (*t) t++;

    while (t > s && isBlank(*(t - 1))) t--;

    if (t == s) continue;

    // ATTENZIONE : tolgo le virgolette !!

    string pathName(s + 1, t - s - 2);

    return TFilePath(pathName);

  }

  return TFilePath();

}

#endif

}  // namespace

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

namespace {

TStopWatch Sw1;

TStopWatch Sw2;

bool UseRenderFarm = false;

QString FarmControllerName;

int FarmControllerPort;

TFarmController *FarmController = 0;

TUserLogAppend *m_userLog;

QString TaskId;

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

void tcomposerRunOutOfContMemHandler(unsigned long size) {

  string msg("Run out of contiguous memory: tried to allocate " +

             std::to_string(size >> 10) + " KB");

  cout << msg << endl;

  m_userLog->error(msg);

  // The task will necessarily do something wrong. So we quit with an error

  // code.

  TImageCache::instance()->clear(true);

  exit(2);

}

}

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

class MyMovieRenderListener : public MovieRenderer::Listener {

public:

  MyMovieRenderListener(const TFilePath &fp, int frameCount,

                        QWaitCondition &renderCompleted, bool stereo)

      : m_fp(fp)

      , m_frameCount(frameCount)

      , m_frameCompletedCount(0)

      , m_frameFailedCount(0)

      , m_renderCompleted(renderCompleted)

      , m_stereo(stereo) {}

  bool onFrameCompleted(int frame) override;

  bool onFrameFailed(int frame, TException &e) override;

  void onSequenceCompleted(const TFilePath &fp) override;

  TFilePath m_fp;

  int m_frameCount;

  int m_frameCompletedCount;

  int m_frameFailedCount;

  QWaitCondition &m_renderCompleted;

  bool m_stereo;

};

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

bool MyMovieRenderListener::onFrameCompleted(int frame) {

  TFilePath fp = m_fp.withFrame(frame + 1);

  string msg;

  if (m_stereo)

    msg = ::to_string(fp.withName(fp.getName() + "_l")) + " and " +

          ::to_string(fp.withName(fp.getName() + "_r")) + " computed";

  else

    msg = ::to_string(fp) + " computed";

  cout << msg << endl;

  m_userLog->info(msg);

  DVGui::info(QString::fromStdString(msg));

  if (FarmController) {

    try {

      FarmController->taskProgress(TaskId,

                                   m_frameCompletedCount + m_frameFailedCount,

                                   m_frameCount, frame + 1, FrameDone);

    } catch (...) {

      msg = "Unable to connect to " + std::to_string(FarmControllerPort) + "@" +

            FarmControllerName.toStdString();

      cout << msg;

      m_userLog->error(msg);

    }

  }

  m_frameCompletedCount++;

  return true;

}

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

bool MyMovieRenderListener::onFrameFailed(int frame, TException &e) {

  TFilePath fp = m_fp.withFrame(frame + 1);

  string msg;

  msg = ::to_string(fp) + " failed";

  if (!e.getMessage().empty()) msg += ": " + ::to_string(e.getMessage());

  cout << msg << endl;

  m_userLog->error(msg);

  if (FarmController) {

    try {

      FarmController->taskProgress(TaskId,

                                   m_frameCompletedCount + m_frameFailedCount,

                                   m_frameCount, frame + 1, FrameFailed);

    } catch (...) {

      msg = "Unable to connect to " + std::to_string(FarmControllerPort) + "@" +

            FarmControllerName.toStdString();

      cout << msg;

      m_userLog->error(msg);

    }

  }

  m_frameFailedCount++;

  return true;

}

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

void MyMovieRenderListener::onSequenceCompleted(const TFilePath &fp) {

  cout << endl;

  QCoreApplication::instance()->quit();

}

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

class MyMultimediaRenderListener : public MultimediaRenderer::Listener {

public:

  TFilePath m_fp;

  int m_frameCount;

  int m_frameCompletedCount;

  int m_frameFailedCount;

  MyMultimediaRenderListener(const TFilePath &fp, int frameCount)

      : m_fp(fp)

      , m_frameCount(frameCount)

      , m_frameCompletedCount(0)

      , m_frameFailedCount(0) {}

  bool onFrameCompleted(int frame, int column) override;

  bool onFrameFailed(int frame, int column, TException &e) override;

  void onSequenceCompleted(int column) override {}

  void onRenderCompleted() override {}

};

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

bool MyMultimediaRenderListener::onFrameCompleted(int frame, int column) {

  int actualFrame = frame + 1;

  string msg      = ::to_string(m_fp) + ", column " + std::to_string(column) +

               ", frame " + std::to_string(actualFrame) + " computed";

  cout << msg << endl;

  m_userLog->info(msg);

  if (FarmController) {

    try {

      FarmController->taskProgress(TaskId,

                                   m_frameCompletedCount + m_frameFailedCount,

                                   m_frameCount, actualFrame, FrameDone);

    } catch (...) {

      msg = "Unable to connect to " + std::to_string(FarmControllerPort) + "@" +

            FarmControllerName.toStdString();

      cout << msg;

      m_userLog->error(msg);

    }

  }

  m_frameCompletedCount++;

  return true;

}

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

bool MyMultimediaRenderListener::onFrameFailed(int frame, int column,

                                               TException &e) {

  int actualFrame = frame + 1;

  string msg      = ::to_string(m_fp) + ", column " + std::to_string(column) +

               ", frame " + std::to_string(actualFrame) + " failed";

  if (!e.getMessage().empty()) msg += ": " + ::to_string(e.getMessage());

  cout << msg << endl;

  m_userLog->error(msg);

  if (FarmController) {

    try {

      FarmController->taskProgress(TaskId,

                                   m_frameCompletedCount + m_frameFailedCount,

                                   m_frameCount, actualFrame, FrameFailed);

    } catch (...) {

      msg = "Unable to connect to " + std::to_string(FarmControllerPort) + "@" +

            FarmControllerName.toStdString();

      cout << msg;

      m_userLog->error(msg);

    }

  }

  m_frameFailedCount++;

  return true;

}

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

std::pair<int, int=""> generateMovie(ToonzScene *scene, const TFilePath &fp,</int,>

                                  int r0, int r1, int step, int shrink,

                                  int threadCount, int maxTileSize) {

  QWaitCondition renderCompleted;

  // riporto gli indici a base zero

  r0 = r0 - 1;

  r1 = r1 - 1;

  if (r0 < 0) r0                                 = 0;

  if (r1 < 0 || r1 >= scene->getFrameCount()) r1 = scene->getFrameCount() - 1;

  string msg;

  assert(r1 >= r0);

  TSceneProperties *sprop          = scene->getProperties();

  TOutputProperties outputSettings = *sprop->getOutputProperties();

  currentCameraSize = scene->getCurrentCamera()->getSize().lx;

  TDimension cameraSize = scene->getCurrentCamera()->getRes();

  TSystem::touchParentDir(fp);

  string ext = fp.getType();

#ifdef _WIN32

  if (ext == "avi") {

    TPropertyGroup *props =

        scene->getProperties()->getOutputProperties()->getFileFormatProperties(

            ext);

    string codecName = props->getProperty(0)->getValueAsString();

    TDimension res   = scene->getCurrentCamera()->getRes();

    if (!AviCodecRestrictions::canWriteMovie(::to_wstring(codecName), res)) {

      string msg(

          "The resolution of the output camera does not fit with the options "

          "chosen for the output file format.");

      m_userLog->error(msg);

      exit(1);

    }

  }

#endif

  double cameraXDpi, cameraYDpi;

  TPointD camDpi = scene->getCurrentCamera()->getDpi();

  cameraXDpi     = camDpi.x;

  cameraYDpi     = camDpi.y;

  int which        = outputSettings.getWhichLevels();

  double stretchTo = (double)outputSettings.getRenderSettings().m_timeStretchTo;

  double stretchFrom =

      (double)outputSettings.getRenderSettings().m_timeStretchFrom;

  double timeStretchFactor = stretchFrom / stretchTo;

  int numFrames            = (int)((r1 - r0 + 1) / timeStretchFactor);

  double r                 = (r0)*timeStretchFactor;

  double stepd             = step * timeStretchFactor;

  int multimediaRender = outputSettings.getMultimediaRendering();

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

  //    Multimedia render

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

  if (multimediaRender) {

    MultimediaRenderer multimediaRenderer(scene, fp, multimediaRender,

                                          threadCount);

    TRenderSettings rs = outputSettings.getRenderSettings();

    rs.m_maxTileSize   = maxTileSize;

    rs.m_shrinkX = rs.m_shrinkY = shrink;

    multimediaRenderer.setRenderSettings(rs);

    multimediaRenderer.setDpi(cameraXDpi, cameraYDpi);

    multimediaRenderer.enablePrecomputing(true);

    for (int i = 0; i < numFrames; i += step, r += stepd)

      multimediaRenderer.addFrame(r);

    MyMultimediaRenderListener *listener = new MyMultimediaRenderListener(

        fp, multimediaRenderer.getFrameCount() *

                multimediaRenderer.getColumnsCount());

    multimediaRenderer.addListener(listener);

    multimediaRenderer.start();

    //----------------- main thread remains above until render is done

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

    // NOTE: the passed total frame count "columns * frames" is an overestimate

    // in this case:

    // columns which do not appear on certain frames are not rendered. So, just

    // realize the

    // number of failed frames if any.

    std::pair<int, int=""> framePair =</int,>

        std::make_pair(listener->m_frameCount, listener->m_frameCount);

    delete listener;

    return framePair;

  }

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

  //    Movie render

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

  else {

    MovieRenderer movieRenderer(scene, fp, threadCount, false);

    TRenderSettings rs = outputSettings.getRenderSettings();

    rs.m_maxTileSize   = maxTileSize;

    rs.m_shrinkX = rs.m_shrinkY = shrink;

    movieRenderer.setRenderSettings(rs);

    movieRenderer.setDpi(cameraXDpi, cameraYDpi);

    movieRenderer.enablePrecomputing(true);

    MyMovieRenderListener *listener =

        new MyMovieRenderListener(fp, tceil((numFrames) / (float)step),

                                  renderCompleted, rs.m_stereoscopic);

    movieRenderer.addListener(listener);

    for (int i = 0; i < numFrames; i += step, r += stepd) {

      TFxPair fx;

      if (rs.m_stereoscopic) scene->shiftCameraX(-rs.m_stereoscopicShift / 2);

      fx.m_frameA = (TRasterFxP)buildSceneFx(scene, scene->getXsheet(), r,

                                             which, shrink, false);

      if (rs.m_fieldPrevalence != TRenderSettings::NoField)

        fx.m_frameB = (TRasterFxP)buildSceneFx(scene, scene->getXsheet(),

                                               r + 0.5 * timeStretchFactor,

                                               which, shrink, false);

      else if (rs.m_stereoscopic) {

        scene->shiftCameraX(rs.m_stereoscopicShift);

        fx.m_frameB = (TRasterFxP)buildSceneFx(scene, scene->getXsheet(), r,

                                               which, shrink, false);

        scene->shiftCameraX(-rs.m_stereoscopicShift / 2);

      } else

        fx.m_frameB = TRasterFxP();

      movieRenderer.addFrame(r, fx);

    }

    movieRenderer.start();

    // Start main loop

    QCoreApplication::instance()->exec();

    //----------------- tcomposer's main thread loops here ----------------

    // int frameCompleted = listener->m_frameCompletedCount;

    std::pair<int, int=""> framePair =</int,>

        std::make_pair(listener->m_frameCompletedCount, listener->m_frameCount);

    delete listener;

    return framePair;

  }

}

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

//

// main()

//

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

// TODO: il main comincia a diventare troppo lungo. Forse val la pena

// separarlo in varie funzioni

// (tipo initToonzEnvironment(), parseCommandLine(), ecc)

DV_IMPORT_API void initStdFx();

DV_IMPORT_API void initColorFx();

int main(int argc, char *argv[]) {

  QApplication app(argc, argv);

  // Create a QObject destroyed just before app - see Tnz6's main.cpp for

  // rationale

  std::auto_ptr<qobject> mainScope(new QObject(&app));</qobject>

  mainScope->setObjectName("mainScope");

#ifdef _WIN32

#ifndef x64

  // Store the floating point control word. It will be re-set before Toonz

  // initialization

  // has ended.

  unsigned int fpWord = 0;

  _controlfp_s(&fpWord, 0, 0);

#endif

#endif

  // Set the app's locale for numeric stuff to standard C. This is important for

  // atof() and similar

  // calls that are locale-dependant.

  setlocale(LC_NUMERIC, "C");

  // Install run out of contiguous memory callback

  TBigMemoryManager::instance()->setRunOutOfContiguousMemoryHandler(

      &tcomposerRunOutOfContMemHandler);

#ifdef _WIN32

// Define 64-bit precision for floating-point arithmetic. Please observe that

// the

// initImageIo() call below would already impose this precision. This just wants

// to be

// explicit.

//_controlfp_s(0, 0, 0x10000);

#endif

  // Initialize thread components

  TThread::init();

  // questo definisce la registry root e inizializza TEnv

  TEnv::setApplication(applicationName, applicationVersion);

  TEnv::setApplicationFullName(applicationFullName);

  TEnv::setRootVarName(rootVarName);

  TEnv::setSystemVarPrefix(systemVarPrefix);

  TSystem::hasMainLoop(true);

  // QMessageBox::information(0, QString("eccolo"), QString("composer!"));

  int i;

  for (i = 0; i < argc; i++)  // tmsg must be set as soon as it's possible

  {

    QString str = argv[i];

    if (str == "-tmsg") {

      TMsgCore::instance()->connectTo(argv[i + 1]);

      break;

    }

  }

  if (i == argc) TMsgCore::instance()->connectTo("");

// TODO: non va qui. Bisognerebbe semmai modificare l'implementazione

// delle TEnv:: precedenti. Discutiamone

#ifdef MACOSX

  // StuffDir

  QFileInfo infoStuff(QString("Toonz 7.1 stuff"));

  TFilePath stuffDirPath(infoStuff.absoluteFilePath().toStdString());

  TEnv::setStuffDir(stuffDirPath);

#endif

  // controllo se la xxxroot e' definita e corrisponde ad un file esistente

  TFilePath fp = TEnv::getStuffDir();

  if (fp == TFilePath())

    fatalError(string("Undefined: \"") + ::to_string(TEnv::getRootVarPath()) +

               "\"");

  if (!TFileStatus(fp).isDirectory())

    fatalError(string("Directory \"") + ::to_string(fp) +

               "\" not found or not readable");

  TFilePath lRootDir    = fp + "toonzfarm";

  TFilePath logFilePath = lRootDir + "tcomposer.log";

  m_userLog             = new TUserLogAppend(logFilePath);

  string msg;

  // Initialize measure units

  Preferences::instance();                      // Loads standard (linear) units

  TMeasureManager::instance()->                 // Loads camera-related units

      addCameraMeasures(getCurrentCameraSize);  //

  TFilePathSet fps = ToonzFolder::getProjectsFolders();

  TFilePathSet::iterator fpIt;

  for (fpIt = fps.begin(); fpIt != fps.end(); ++fpIt)

    TProjectManager::instance()->addProjectsRoot(*fpIt);

  TFilePath libraryFolder = ToonzFolder::getLibraryFolder();

  TRasterImagePatternStrokeStyle::setRootDir(libraryFolder);

  TVectorImagePatternStrokeStyle::setRootDir(libraryFolder);

  TVectorBrushStyle::setRootDir(libraryFolder);

  TPalette::setRootDir(libraryFolder);

  TImageStyle::setLibraryDir(libraryFolder);

  TFilePath cacheRoot                = ToonzFolder::getCacheRootFolder();

  if (cacheRoot.isEmpty()) cacheRoot = TEnv::getStuffDir() + "cache";

  TImageCache::instance()->setRootDir(cacheRoot);

  // #endif

  //  setCurrentModule("tcomposer");

  TCli::FilePathArgument srcName("srcName", "Source file");

  FilePathQualifier dstName("-o dstName", "Target file");

  RangeQualifier range;

  IntQualifier stepOpt("-step n", "Step");

  IntQualifier shrinkOpt("-shrink n", "Shrink");

  IntQualifier multimedia("-multimedia n", "Multimedia rendering mode");

  StringQualifier farmData("-farm data", "TFarm Controller");

  StringQualifier idq("-id n", "id");

  StringQualifier nthreads("-nthreads n", "Number of rendering threads");

  StringQualifier tileSize("-maxtilesize n",

                           "Enable tile rendering of max n MB per tile");

  StringQualifier tmsg("-tmsg val", "only internal use");

  Usage usage(argv[0]);

  usage.add(srcName + dstName + range + stepOpt + shrinkOpt + multimedia +

            farmData + idq + nthreads + tileSize + tmsg);

  if (!usage.parse(argc, argv)) exit(1);

  TaskId       = QString::fromStdString(idq.getValue());

  string fdata = farmData.getValue();

  if (fdata.empty())

    UseRenderFarm = false;

  else {

    UseRenderFarm         = true;

    string::size_type pos = fdata.find('@');

    if (pos == string::npos)

      UseRenderFarm = false;

    else {

      FarmControllerPort = std::stoi(fdata.substr(0, pos));

      FarmControllerName = QString::fromStdString(fdata.substr(pos + 1));

    }

  }

  if (UseRenderFarm) {

    TFarmControllerFactory factory;

    factory.create(FarmControllerName, FarmControllerPort, &FarmController);

  }

  while (!PluginLoader::load_entries("")) app.processEvents();

  std::pair<int, int=""> framePair(1, 0);</int,>

  try {

    Tiio::defineStd();

    initImageIo();

    Tiio::defineStd();

    initSoundIo();

    initStdFx();

    initColorFx();

    loadShaderInterfaces(ToonzFolder::getLibraryFolder() +

                         TFilePath("shaders"));

    //#endif

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

    TFilePath srcFilePath = srcName.getValue();

    try {

      srcFilePath = TSystem::toLocalPath(srcFilePath);

    } catch (...) {

    }

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

    msg = "Loading " + srcFilePath.getName();

    cout << endl << msg << endl;

    m_userLog->info(msg);

    TProjectManager *pm = TProjectManager::instance();

    // pm->enableTabMode(true);

    TProjectP project = pm->loadSceneProject(srcFilePath);

    if (!project) {

      msg = "Couldn't find the project";  //+ project->getName().getName();

      cerr << msg << endl;

      m_userLog->error(msg);

      return -2;

    }

    msg = "project: " + project->getName().getName();

    cout << msg << endl;

    m_userLog->info(msg);

    // pm->setCurrentProject(project, false); // false => temporaneamente

    Sw1.start();

    if (!TSystem::doesExistFileOrLevel(srcFilePath)) return false;

    ToonzScene *scene = new ToonzScene();

    TImageStyle::setCurrentScene(scene);

    try {

      Sw2.start();

      scene->load(srcFilePath);

      Sw2.stop();

    } catch (TException &e) {

      cout << ::to_string(e.getMessage()) << endl;

      m_userLog->error(::to_string(e.getMessage()));

      return -2;

    } catch (...) {

      string msg;

      msg = "There were problems loading the scene " +

            ::to_string(srcFilePath) + ".\n Some files may be missing.";

      cout << msg << endl;

      m_userLog->error(msg);

      // return false;

    }

    msg = "scene loaded";

    cout << "scene loaded" << endl;

    m_userLog->info(msg);

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

    TFilePath dstFilePath;

    if (dstName.isSelected())

      dstFilePath = dstName.getValue();

    else {

      dstFilePath = scene->getProperties()->getOutputProperties()->getPath();

      if (dstFilePath == TFilePath())

        dstFilePath = TFilePath("+outputs") + "$scenename.tif";

      else if (dstFilePath.getName() == "")

        dstFilePath = (dstFilePath.getParentDir() + scene->getSceneName())

                          .withType(dstFilePath.getType());

    }

    dstFilePath = scene->decodeFilePath(dstFilePath);

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

    msg = "Generating " + dstFilePath.getName();

    cout << endl << "Generating " << dstFilePath << endl << endl;

    m_userLog->info(msg);

    TFilePath theDstFilePath = dstFilePath;

    try {

      theDstFilePath = TSystem::toLocalPath(dstFilePath);

    } catch (...) {

    }

    int r0 = -1, r1 = -1, step = 1, shrink = 1;

    TOutputProperties *outProp = scene->getProperties()->getOutputProperties();

    int scene_from, scene_to, scene_step;

    outProp->getRange(scene_from, scene_to, scene_step);

    int scene_shrink = outProp->getRenderSettings().m_shrinkX;

    if (scene_from == 0 && scene_to == -1) {

      scene_from = 1;

      scene_to   = scene->getFrameCount();

    } else {

      scene_from++;

      scene_to++;

    }

    if (range.isSelected()) {

      r0 = range.getFrom();

      r1 = range.getTo();

    } else {

      r0 = scene_from;

      r1 = scene_to;

    }

    if (stepOpt.isSelected())

      step = stepOpt.getValue();

    else

      step = scene_step;

    if (shrinkOpt.isSelected())

      shrink = shrinkOpt.getValue();

    else

      shrink = scene_shrink;

    if (multimedia.isSelected())

      scene->getProperties()->getOutputProperties()->setMultimediaRendering(

          multimedia.getValue());

    // Retrieve Thread count

    const int procCount = TSystem::getProcessorCount();

    int threadCount;

    const int threadCounts[3] = {1, procCount / 2, procCount};

    if (nthreads.isSelected()) {

      QString threadCountStr = QString::fromStdString(nthreads.getValue());

      threadCount            = (threadCountStr == "single")

                        ? threadCounts[0]

                        : (threadCountStr == "half")

                              ? threadCounts[1]

                              : (threadCountStr == "all")

                                    ? threadCounts[2]

                                    : threadCountStr.toInt();

      if (threadCount <= 0) {

        cout << "Qualifier 'nthreads': bad input" << endl;

        exit(1);

      }

    } else {

      int threadIndex = outProp->getThreadIndex();

      threadCount     = threadCounts[threadIndex];

    }

    threadCount = tcrop(1, procCount, threadCount);

    // Retrieve max tile size (raster granularity)

    int maxTileSize;

    const int maxTileSizes[4] = {

        (std::numeric_limits<int>::max)(), TOutputProperties::LargeVal,</int>

        TOutputProperties::MediumVal, TOutputProperties::SmallVal};

    if (tileSize.isSelected()) {

      QString tileSizeStr = QString::fromStdString(tileSize.getValue());

      maxTileSize         = (tileSizeStr == "none")

                        ? maxTileSizes[0]

                        : (tileSizeStr == "large")

                              ? maxTileSizes[1]

                              : (tileSizeStr == "medium")

                                    ? maxTileSizes[2]

                                    : (tileSizeStr == "small")