#include "texternfx.h"
#include "tsystem.h"
#include "tdoubleparam.h"
#include "timage_io.h"
//#include "tfx.h"
#include "trasterfx.h"
//#include "tsystem.h"
//#include "tparamcontainer.h"
#include "tfxparam.h"
#include "tstream.h"
namespace
{
TFilePath getExternFxPath()
{
return TSystem::getBinDir() + "plugins" + "externFxs";
}
}
//=========================================================
// not implemented yet
void TExternFx::getNames(vector<string> &names)
{
}
//=========================================================
TExternFx *TExternFx::create(string name)
{
TExternalProgramFx *fx = new TExternalProgramFx(name);
return fx;
}
//=========================================================
TExternalProgramFx::TExternalProgramFx(string name)
: m_externFxName(name)
{
initialize(name);
setName(L"ExternalProgramFx");
// addInputPort("input2", m_input2);
}
//------------------------------------------------------------------
TExternalProgramFx::TExternalProgramFx()
: m_externFxName()
{
setName(L"ExternalProgramFx");
// addInputPort("input2", m_input2);
}
//------------------------------------------------------------------
TExternalProgramFx::~TExternalProgramFx()
{
}
//------------------------------------------------------------------
void TExternalProgramFx::initialize(string name)
{
TFilePath fp = getExternFxPath() + (name + ".xml");
TIStream is(fp);
if (!is)
return;
string tagName;
if (!is.matchTag(tagName) || tagName != "externFx")
return;
try {
while (is.matchTag(tagName)) {
if (tagName == "executable") {
TFilePath executable = TFilePath(is.getTagAttribute("path"));
string args = is.getTagAttribute("args");
if (executable == TFilePath())
throw TException("missing executable path");
if (args == "")
throw TException("missing args string");
setExecutable(executable, args);
} else if (tagName == "inport" || tagName == "outport") {
string portName = is.getTagAttribute("name");
string ext = is.getTagAttribute("ext");
if (portName == "")
throw TException("missing port name");
if (ext == "")
throw TException("missing port ext");
addPort(portName, ext, tagName == "inport");
} else if (tagName == "param") {
string paramName = is.getTagAttribute("name");
if (paramName == "")
throw TException("missing param name");
string type = is.getTagAttribute("type");
if (type == "")
throw TException("missing param type");
if (type != "double")
throw TException("param type not yet implemented");
TDoubleParamP param = new TDoubleParam();
param->setName(paramName);
m_params.push_back(param);
} else
throw TException("unexpected tag " + tagName);
}
is.closeChild();
for (int i = 0; i < (int)m_params.size(); i++)
bindParam(this, m_params[i]->getName(), m_params[i]);
} catch (...) {
}
}
//------------------------------------------------------------------
void TExternalProgramFx::addPort(string portName, string ext, bool isInput)
{
if (isInput) {
TRasterFxPort *port = new TRasterFxPort();
m_ports[portName] = Port(portName, ext, port);
addInputPort(portName, *port);
} else
m_ports[portName] = Port(portName, ext, 0);
}
//------------------------------------------------------------------
//void TExternalProgramFx::addParam(string paramName, const TParamP ¶m)
//{
// m_params[paramName] = param;
// TFx::addParam(paramName, param);
//}
//------------------------------------------------------------------
TFx *TExternalProgramFx::clone(bool recursive) const
{
TExternalProgramFx *fx =
dynamic_cast<TExternalProgramFx *>(TExternFx::create(m_externFxName));
assert(fx);
//new TExternalProgramFx();
//fx->setExecutable(m_executablePath, m_args);
// copia della time region
fx->setActiveTimeRegion(getActiveTimeRegion());
// fx->m_imp->m_activeTimeRegion = m_imp->m_activeTimeRegion;
fx->getParams()->copy(getParams());
assert(getInputPortCount() == fx->getInputPortCount());
//std::map<string, Port>::const_iterator j;
//for(j=m_ports.begin(); j!=m_ports.end(); ++j)
// fx->addPort(j->first, j->second.m_ext, j->second.m_port != 0);
// copia ricorsiva sulle porte
if (recursive) {
for (int i = 0; i < getInputPortCount(); ++i) {
TFxPort *port = getInputPort(i);
if (port->getFx())
fx->connect(getInputPortName(i), port->getFx()->clone(true));
}
}
//std::map<string, TParamP>::const_iterator j;
//for(j=m_params.begin(); j!=m_params.end(); ++j)
// fx->addParam(j->first, j->second->clone());
return fx;
}
//------------------------------------------------------------------
bool TExternalProgramFx::doGetBBox(double frame, TRectD &bBox, const TRenderSettings &info)
{
// bBox = TRectD(-30,-30,30,30);
// return true;
std::map<string, Port>::const_iterator portIt;
for (portIt = m_ports.begin(); portIt != m_ports.end(); ++portIt) {
if (portIt->second.m_port != 0) {
TRasterFxPort *tmp;
tmp = portIt->second.m_port;
if (tmp->isConnected()) {
TRectD tmpbBox;
(*tmp)->doGetBBox(frame, tmpbBox, info);
bBox += tmpbBox;
}
}
}
if (bBox.isEmpty()) {
bBox = TRectD();
return false;
} else
return true;
/*
if(m_input1.isConnected() || m_input2.isConnected())
{
bool ret = m_input1->doGetBBox(frame, bBox) || m_input1->doGetBBox(frame, bBox);
return ret;
}
else
{
bBox = TRectD();
return false;
}
*/
}
//------------------------------------------------------------------
void TExternalProgramFx::doCompute(TTile &tile, double frame, const TRenderSettings &ri)
{
TRaster32P ras = tile.getRaster();
if (!ras)
return;
string args = m_args;
string executablePath = toString(m_executablePath.getWideString());
std::map<string, TFilePath> tmpFiles; // portname --> file
TFilePath outputTmpFile;
std::map<string, Port>::const_iterator portIt;
for (portIt = m_ports.begin(); portIt != m_ports.end(); ++portIt) {
TFilePath fp = TSystem::getUniqueFile("externfx");
fp = fp.withType(portIt->second.m_ext);
tmpFiles[portIt->first] = fp;
if (portIt->second.m_port == 0) // solo una porta e' di output
outputTmpFile = fp;
else {
TRasterFxPort *tmp;
tmp = portIt->second.m_port;
if (tmp->isConnected()) {
(*tmp)->compute(tile, frame, ri);
TImageWriter::save(fp, ras);
}
}
}
// args e' della forma "$src $ctrl -o $out -v $value"
// sostituisco le variabili
int i = 0;
for (;;) {
i = args.find('$', i);
if (i == (int)string::npos)
break;
int j = i + 1;
int len = args.length();
while (j < len && isalnum(args[j]))
j++;
// un '$' non seguito da caratteri alfanumerici va ignorato
if (j == i + 1) {
// la sequenza '$$' diventa '$'
if (j < len && args[j] == '$')
args.replace(i, 2, "$");
i++;
continue;
}
// ho trovato una variabile
int m = j - i - 1;
string name = args.substr(i + 1, m);
// calcolo il valore.
string value;
std::map<string, TFilePath>::const_iterator it;
it = tmpFiles.find(name);
if (it != tmpFiles.end()) {
// e' una porta. il valore e' il nome del
// file temporaneo
value = "\"" + toString(it->second.getWideString()) + "\"";
} else {
// e' un parametro
// se il nome non viene riconosciuto sostituisco la stringa nulla
TDoubleParamP param = TParamP(getParams()->getParam(name));
if (param)
value = toString(param->getValue(frame));
}
args.replace(i, m + 1, value);
}
args = " " + args; //aggiungo uno spazio per sicurezza
//ofstream os("C:\\temp\\butta.txt");
//os << args << endl;
// bisognerebbe calcolare le immagini dalla/e porta/e di input
// scrivere il/i valore/i nei files temporanei/o
// chiamare "m_executablePath args"
// e leggere l'immagine scritta in outputTmpFile
// poi cancellare tutto
string expandedargs;
char buffer[1024];
#ifdef WIN32
ExpandEnvironmentStrings(args.c_str(), buffer, 1024);
STARTUPINFO si;
PROCESS_INFORMATION pinfo;
GetStartupInfo(&si);
BOOL ret = CreateProcess(
(char *)executablePath.c_str(), // name of executable module
buffer, // command line string
NULL, // SD
NULL, // SD
TRUE, // handle inheritance option
CREATE_NO_WINDOW, /*CREATE_NEW_CONSOLE*/ // creation flags
NULL, // new environment block
NULL, // current directory name
&si, // startup information
&pinfo // process information
);
if (!ret)
DWORD err = GetLastError();
// aspetta che il processo termini
WaitForSingleObject(pinfo.hProcess, INFINITE);
DWORD exitCode;
ret = GetExitCodeProcess(
pinfo.hProcess, // handle to the process
&exitCode); // termination status
#else
string cmdline = executablePath + buffer;
// int exitCode =
system(cmdline.c_str());
#endif
/*
string name = m_executablePath.getName();
TPixel32 color;
if(name == "saturate") color = TPixel32::Magenta;
else if(name == "over") color = TPixel32::Green;
else color = TPixel32::Red;
for(int iy=0;iy<ras->getLy();iy++)
{
TPixel32 *pix = ras->pixels(iy);
TPixel32 *endPix = pix + ras->getLx();
double x = tile.m_pos.x;
double y = tile.m_pos.y + iy;
while(pix<endPix)
{
if(x*x+y*y<900) *pix = color;
else *pix = TPixel32(0,0,0,0);
++pix;
x+=1.0;
}
}
*/
try {
TRasterP ras = tile.getRaster();
TImageReader::load(outputTmpFile, ras);
} catch (...) {
}
//butto i file temporanei creati
std::map<string, TFilePath>::const_iterator fileIt;
for (fileIt = tmpFiles.begin(); fileIt != tmpFiles.end(); ++fileIt) {
if (TFileStatus(fileIt->second).doesExist() == true)
try {
TSystem::deleteFile(fileIt->second);
} catch (...) {
}
}
if (TFileStatus(outputTmpFile).doesExist() == true)
try {
TSystem::deleteFile(outputTmpFile);
} catch (...) {
}
}
//------------------------------------------------------------------
void TExternalProgramFx::loadData(TIStream &is)
{
string tagName;
while (is.openChild(tagName)) {
if (tagName == "path") {
is >> m_executablePath;
} else if (tagName == "args") {
is >> m_args;
} else if (tagName == "name") {
is >> m_externFxName;
// initialize(m_externFxName);
} else if (tagName == "params") {
while (is.matchTag(tagName)) {
if (tagName == "param") {
// assert(0);
string paramName = is.getTagAttribute("name");
TDoubleParamP param = new TDoubleParam();
param->setName(paramName);
m_params.push_back(param);
} else
throw TException("unexpected tag " + tagName);
}
for (int i = 0; i < (int)m_params.size(); i++)
bindParam(this, m_params[i]->getName(), m_params[i]);
} else if (tagName == "ports") {
while (is.matchTag(tagName)) {
if (tagName == "port") {
string name = is.getTagAttribute("name");
string ext = is.getTagAttribute("ext");
addPort(name, ext, true);
} else if (tagName == "outport") {
string name = is.getTagAttribute("name");
string ext = is.getTagAttribute("ext");
addPort(name, ext, false);
} else
throw TException("unexpected tag " + tagName);
}
} else if (tagName == "super") {
TExternFx::loadData(is);
} else
throw TException("unexpected tag " + tagName);
is.closeChild();
}
}
void TExternalProgramFx::saveData(TOStream &os)
{
os.child("name") << m_externFxName;
os.child("path") << m_executablePath;
os.child("args") << m_args;
os.openChild("params");
for (int i = 0; i < getParams()->getParamCount(); i++) {
std::map<string, string> attr;
attr["name"] = getParams()->getParamName(i);
attr["type"] = "double";
os.openCloseChild("param", attr);
}
os.closeChild();
os.openChild("ports");
std::map<string, Port>::iterator portIt;
for (portIt = m_ports.begin(); portIt != m_ports.end(); ++portIt) {
std::map<string, string> attr;
attr["name"] = portIt->second.m_name;
attr["ext"] = portIt->second.m_ext;
string tagName = portIt->second.m_port == 0 ? "outport" : "port";
os.openCloseChild(tagName, attr);
}
os.closeChild();
os.openChild("super");
TExternFx::saveData(os);
os.closeChild();
}
//------------------------------------------------------------------
#ifdef CICCIO
//-------------------------------------------------------------------
void ExternalProgramFx::doCompute(TTile &tile, double frame, const TRenderSettings &ri)
{
if (!m_input1.isConnected() || !m_input2.isConnected()) {
tile.getRaster()->clear();
return;
}
string name1("C:\\temp\\uno..tif");
string name2("C:\\temp\\due..tif");
string outname("C:\\temp\\outfile.0001.jpg");
string program("C:\\temp\\xdissolve.exe");
string extension(".jpg");
TFilePath programpath(program);
m_input1->compute(tile, frame, ri);
TFilePath fname1(name1);
TFilePath fname2(name2);
string tmp1 = fname1.getName() + extension;
string tmp2 = fname2.getName() + extension;
TFilePath tmpname1(fname1.getParentDir() + tmp1);
TFilePath tmpname2(fname2.getParentDir() + tmp2);
TFilePath out(outname);
TImageWriter::save(tmpname1, tile.getRaster());
m_input2->compute(tile, frame, ri);
TImageWriter::save(tmpname2, tile.getRaster());
string arglist = " -range1 1 1 -start2 1 -startout 1 ";
arglist += toString(tmpname1.getWideString());
arglist += " " + toString(tmpname2.getWideString());
arglist += " " + outname;
string cmdline = program + arglist;
#ifdef WIN32
STARTUPINFO si;
PROCESS_INFORMATION pinfo;
GetStartupInfo(&si);
BOOL ret = CreateProcess(
NULL, // name of executable module
(char *)cmdline.c_str(), // command line string
NULL, // SD
NULL, // SD
TRUE, // handle inheritance option
CREATE_NO_WINDOW, /*CREATE_NEW_CONSOLE*/ // creation flags
NULL, // new environment block
NULL, // current directory name
&si, // startup information
&pinfo // process information
);
if (!ret)
DWORD err = GetLastError();
// aspetta che il processo termini
WaitForSingleObject(pinfo.hProcess, INFINITE);
DWORD exitCode;
ret = GetExitCodeProcess(
pinfo.hProcess, // handle to the process
&exitCode); // termination status
#else
int exitCode = system(cmdline.c_str());
#endif
TImageReader::load(out, tile.getRaster());
TSystem::deleteFile(tmpname1);
TSystem::deleteFile(tmpname2);
TSystem::deleteFile(out);
}
FX_PLUGIN_IDENTIFIER(ExternalProgramFx, "externalProgramFx");
* /
#endif
FX_IDENTIFIER(TExternalProgramFx, "externalProgramFx")