/* set up and run a processor */
void
InvertPlugin::setupAndProcess(InvertBase &processor, const OFX::RenderArguments &args)
{
// get a dst image
std::auto_ptr<OFX::Image> dst(dstClip_->fetchImage(args.time));
if (!dst.get()) {
OFX::throwSuiteStatusException(kOfxStatFailed);
}
OFX::BitDepthEnum dstBitDepth = dst->getPixelDepth();
OFX::PixelComponentEnum dstComponents = dst->getPixelComponents();
// fetch main input image
std::auto_ptr<OFX::Image> src(srcClip_->fetchImage(args.time));
// make sure bit depths are sane
if (src.get()) {
OFX::BitDepthEnum srcBitDepth = src->getPixelDepth();
OFX::PixelComponentEnum srcComponents = src->getPixelComponents();
// see if they have the same depths and bytes and all
if (srcBitDepth != dstBitDepth || srcComponents != dstComponents) {
OFX::throwSuiteStatusException(kOfxStatErrImageFormat);
}
}
// auto ptr for the mask.
std::auto_ptr<OFX::Image> mask((getContext() != OFX::eContextFilter) ? maskClip_->fetchImage(args.time) : 0);
// do we do masking
if (getContext() != OFX::eContextFilter && maskClip_->isConnected()) {
// say we are masking
processor.doMasking(true);
// Set it in the processor
processor.setMaskImg(mask.get());
}
bool red, green, blue, alpha;
_paramProcessR->getValueAtTime(args.time, red);
_paramProcessG->getValueAtTime(args.time, green);
_paramProcessB->getValueAtTime(args.time, blue);
_paramProcessA->getValueAtTime(args.time, alpha);
double mix;
_mix->getValueAtTime(args.time, mix);
bool maskInvert;
_maskInvert->getValueAtTime(args.time, maskInvert);
processor.setValues(red, green, blue, alpha, mix, maskInvert);
// set the images
processor.setDstImg(dst.get());
processor.setSrcImg(src.get());
// set the render window
processor.setRenderWindow(args.renderWindow);
// Call the base class process member, this will call the derived templated process code
processor.process();
}
bool CropPlugin::getRegionOfDefinition( const OFX::RegionOfDefinitionArguments& args, OfxRectD& rod )
{
OFX::BooleanParam* bop = fetchBooleanParam( kParamFillMode );
if( bop->getValue() == false )
{
rod = getCropRect( args.time );
return true;
}
return false;
}
/* set up and run a processor */
void
BasicPlugin::setupAndProcess(ImageScalerBase &processor, const OFX::RenderArguments &args)
{
// get a dst image
std::auto_ptr<OFX::Image> dst(dstClip_->fetchImage(args.time));
OFX::BitDepthEnum dstBitDepth = dst->getPixelDepth();
OFX::PixelComponentEnum dstComponents = dst->getPixelComponents();
// fetch main input image
std::auto_ptr<OFX::Image> src(srcClip_->fetchImage(args.time));
// make sure bit depths are sane
if(src.get()) {
OFX::BitDepthEnum srcBitDepth = src->getPixelDepth();
OFX::PixelComponentEnum srcComponents = src->getPixelComponents();
// see if they have the same depths and bytes and all
if(srcBitDepth != dstBitDepth || srcComponents != dstComponents)
throw int(1); // HACK!! need to throw an sensible exception here!
}
// auto ptr for the mask.
// Should do this inside the if statement below but the MS compiler I have doesn't have
// a 'reset' function on the auto_ptr class
std::auto_ptr<OFX::Image> mask(getContext() != OFX::eContextFilter ? maskClip_->fetchImage(args.time) : 0);
// do we do masking
if(getContext() != OFX::eContextFilter) {
// say we are masking
processor.doMasking(true);
// Set it in the processor
processor.setMaskImg(mask.get());
}
// get the scale parameter values...
double r, g, b, a = aScale_->getValueAtTime(args.time);
r = g = b = scale_->getValueAtTime(args.time);
// see if the individual component scales are enabled
if(componentScalesEnabled_->getValueAtTime(args.time)) {
r *= rScale_->getValueAtTime(args.time);
g *= gScale_->getValueAtTime(args.time);
b *= bScale_->getValueAtTime(args.time);
}
// set the images
processor.setDstImg(dst.get());
processor.setSrcImg(src.get());
// set the render window
processor.setRenderWindow(args.renderWindow);
// set the scales
processor.setScales((float)r, (float)g, (float)b, (float)a);
// Call the base class process member, this will call the derived templated process code
processor.process();
}
bool
InvertPlugin::isIdentity(const RenderArguments &args, Clip * &identityClip, double &identityTime)
{
bool red, green, blue, alpha;
double mix;
_paramProcessR->getValueAtTime(args.time, red);
_paramProcessG->getValueAtTime(args.time, green);
_paramProcessB->getValueAtTime(args.time, blue);
_paramProcessA->getValueAtTime(args.time, alpha);
_mix->getValueAtTime(args.time, mix);
if (mix == 0. || (!red && !green && !blue && !alpha)) {
identityClip = srcClip_;
return true;
} else {
return false;
}
}
// set the enabledness of the individual component scales
void
BasicPlugin::setEnabledness(void)
{
// the componet enabledness depends on the clip being RGBA and the param being true
bool v = componentScalesEnabled_->getValue() && srcClip_->getPixelComponents() == OFX::ePixelComponentRGBA;
// enable them
rScale_->setEnabled(v);
gScale_->setEnabled(v);
bScale_->setEnabled(v);
aScale_->setEnabled(v);
}
// overridden is identity
bool
BasicPlugin:: isIdentity(const OFX::IsIdentityArguments &args, OFX::Clip * &identityClip, double &identityTime)
{
// get the scale parameters
double scale = scale_->getValueAtTime(args.time);
double rScale = 1, gScale = 1, bScale = 1, aScale = 1;
if(componentScalesEnabled_->getValueAtTime(args.time)) {
rScale = rScale_->getValueAtTime(args.time);
gScale = gScale_->getValueAtTime(args.time);
bScale = bScale_->getValueAtTime(args.time);
aScale = aScale_->getValueAtTime(args.time);
}
rScale *= scale; gScale *= scale; bScale *= scale;
// do we do any scaling ?
if(rScale == 1 && gScale == 1 && bScale == 1 && aScale == 1) {
identityClip = srcClip_;
identityTime = args.time;
return true;
}
// nope, idenity we is
return false;
}
bool LibAVParams::setOption( const std::string& libAVOptionName, const std::string& value, const std::string& detailedName )
{
try
{
// Get libav option
avtranscoder::Option& option = getLibAVOption( libAVOptionName, detailedName );
// Set libav option's value
option.setString( value );
// Get corresponding OFX parameter
OFX::ValueParam* param = getOFXParameter( libAVOptionName, detailedName );
if( ! param)
{
TUTTLE_LOG_WARNING( "Can't get OFX parameter corresponding to option " << libAVOptionName << " of subgroup " << detailedName );
return false;
}
// Set OFX parameter's value
OFX::BooleanParam* paramBoolean = dynamic_cast<OFX::BooleanParam*>( param );
if( paramBoolean )
{
paramBoolean->setValue( option.getBool() );
return true;
}
OFX::IntParam* paramInt = dynamic_cast<OFX::IntParam*>( param );
if( paramInt )
{
paramInt->setValue( option.getInt() );
return true;
}
OFX::DoubleParam* paramDouble = dynamic_cast<OFX::DoubleParam*>( param );
if( paramDouble )
{
paramDouble->setValue( option.getDouble() );
return true;
}
OFX::StringParam* paramString = dynamic_cast<OFX::StringParam*>( param );
if( paramString )
{
paramString->setValue( option.getString() );
return true;
}
OFX::Int2DParam* paramRatio = dynamic_cast<OFX::Int2DParam*>( param );
if( paramRatio )
{
paramRatio->setValue( option.getRatio().first, option.getRatio().second );
return true;
}
OFX::ChoiceParam* paramChoice = dynamic_cast<OFX::ChoiceParam*>( param );
if( paramChoice )
{
paramChoice->setValue( option.getInt() );
return true;
}
}
catch( std::exception& e )
{
TUTTLE_LOG_WARNING( "Can't set option " << libAVOptionName << " to " << value << ": " << e.what() );
return false;
}
}
/* set up and run a processor */
void
AnaglyphPlugin::setupAndProcess(AnaglyphBase &processor, const OFX::RenderArguments &args)
{
// get a dst image
std::auto_ptr<OFX::Image> dst(dstClip_->fetchImage(args.time));
if (!dst.get()) {
OFX::throwSuiteStatusException(kOfxStatFailed);
}
if (dst->getRenderScale().x != args.renderScale.x ||
dst->getRenderScale().y != args.renderScale.y ||
dst->getField() != args.fieldToRender) {
setPersistentMessage(OFX::Message::eMessageError, "", "OFX Host gave image with wrong scale or field properties");
OFX::throwSuiteStatusException(kOfxStatFailed);
}
OFX::BitDepthEnum dstBitDepth = dst->getPixelDepth();
OFX::PixelComponentEnum dstComponents = dst->getPixelComponents();
// fetch main input image
std::auto_ptr<OFX::Image> srcLeft(srcClip_->fetchStereoscopicImage(args.time,0));
if (srcLeft.get()) {
if (srcLeft->getRenderScale().x != args.renderScale.x ||
srcLeft->getRenderScale().y != args.renderScale.y ||
srcLeft->getField() != args.fieldToRender) {
setPersistentMessage(OFX::Message::eMessageError, "", "OFX Host gave image with wrong scale or field properties");
OFX::throwSuiteStatusException(kOfxStatFailed);
}
}
std::auto_ptr<OFX::Image> srcRight(srcClip_->fetchStereoscopicImage(args.time,1));
if (srcRight.get()) {
if (srcRight->getRenderScale().x != args.renderScale.x ||
srcRight->getRenderScale().y != args.renderScale.y ||
srcRight->getField() != args.fieldToRender) {
setPersistentMessage(OFX::Message::eMessageError, "", "OFX Host gave image with wrong scale or field properties");
OFX::throwSuiteStatusException(kOfxStatFailed);
}
}
// make sure bit depths are sane
if (srcLeft.get()) {
OFX::BitDepthEnum srcBitDepth = srcLeft->getPixelDepth();
OFX::PixelComponentEnum srcComponents = srcLeft->getPixelComponents();
// see if they have the same depths and bytes and all
if (srcBitDepth != dstBitDepth || srcComponents != dstComponents)
OFX::throwSuiteStatusException(kOfxStatErrImageFormat);
}
if (srcRight.get()) {
OFX::BitDepthEnum srcBitDepth = srcRight->getPixelDepth();
OFX::PixelComponentEnum srcComponents = srcRight->getPixelComponents();
// see if they have the same depths and bytes and all
if (srcBitDepth != dstBitDepth || srcComponents != dstComponents)
OFX::throwSuiteStatusException(kOfxStatErrImageFormat);
}
double amtcolour = amtcolour_->getValueAtTime(args.time);
bool swap = swap_->getValueAtTime(args.time);
int offset = offset_->getValueAtTime(args.time);
// set the images
processor.setDstImg(dst.get());
processor.setSrcLeftImg(srcLeft.get());
processor.setSrcRightImg(srcRight.get());
// set the render window
processor.setRenderWindow(args.renderWindow);
// set the parameters
processor.setAmtColour(amtcolour);
processor.setSwap(swap);
processor.setOffset(offset);
// Call the base class process member, this will call the derived templated process code
processor.process();
}
void WriteOIIOPlugin::encode(const std::string& filename, OfxTime time, const float *pixelData, const OfxRectI& bounds, OFX::PixelComponentEnum pixelComponents, int rowBytes)
{
if (pixelComponents != OFX::ePixelComponentRGBA && pixelComponents != OFX::ePixelComponentRGB && pixelComponents != OFX::ePixelComponentAlpha) {
setPersistentMessage(OFX::Message::eMessageError, "", "OIIO: can only write RGBA, RGB or Alpha components images");
OFX::throwSuiteStatusException(kOfxStatErrFormat);
}
int numChannels;
switch(pixelComponents)
{
case OFX::ePixelComponentRGBA:
numChannels = 4;
break;
case OFX::ePixelComponentRGB:
numChannels = 3;
break;
case OFX::ePixelComponentAlpha:
numChannels = 1;
break;
default:
OFX::throwSuiteStatusException(kOfxStatErrFormat);
}
std::auto_ptr<ImageOutput> output(ImageOutput::create(filename));
if (!output.get()) {
// output is NULL
setPersistentMessage(OFX::Message::eMessageError, "", std::string("Cannot create output file ")+filename);
return;
}
OpenImageIO::TypeDesc oiioBitDepth;
//size_t sizeOfChannel = 0;
int bitsPerSample = 0;
int finalBitDepth_i;
_bitDepth->getValue(finalBitDepth_i);
ETuttlePluginBitDepth finalBitDepth = getDefaultBitDepth(filename,(ETuttlePluginBitDepth)finalBitDepth_i);
switch (finalBitDepth) {
case eTuttlePluginBitDepthAuto:
OFX::throwSuiteStatusException(kOfxStatErrUnknown);
case eTuttlePluginBitDepth8:
oiioBitDepth = TypeDesc::UINT8;
bitsPerSample = 8;
//sizeOfChannel = 1;
break;
case eTuttlePluginBitDepth10:
oiioBitDepth = TypeDesc::UINT16;
bitsPerSample = 10;
//sizeOfChannel = 2;
break;
case eTuttlePluginBitDepth12:
oiioBitDepth = TypeDesc::UINT16;
bitsPerSample = 12;
//sizeOfChannel = 2;
break;
case eTuttlePluginBitDepth16:
oiioBitDepth = TypeDesc::UINT16;
bitsPerSample = 16;
//sizeOfChannel = 2;
break;
case eTuttlePluginBitDepth16f:
oiioBitDepth = TypeDesc::HALF;
bitsPerSample = 16;
//sizeOfChannel = 2;
break;
case eTuttlePluginBitDepth32:
oiioBitDepth = TypeDesc::UINT32;
bitsPerSample = 32;
//sizeOfChannel = 4;
break;
case eTuttlePluginBitDepth32f:
oiioBitDepth = TypeDesc::FLOAT;
bitsPerSample = 32;
//sizeOfChannel = 4;
break;
case eTuttlePluginBitDepth64:
oiioBitDepth = TypeDesc::UINT64;
bitsPerSample = 64;
//sizeOfChannel = 8;
break;
case eTuttlePluginBitDepth64f:
oiioBitDepth = TypeDesc::DOUBLE;
bitsPerSample = 64;
//sizeOfChannel = 8;
break;
}
ImageSpec spec (bounds.x2 - bounds.x1, bounds.y2 - bounds.y1, numChannels, oiioBitDepth);
bool premultiply;
_premult->getValue(premultiply);
int quality;
_quality->getValue(quality);
int orientation;
_orientation->getValue(orientation);
int compression_i;
_compression->getValue(compression_i);
std::string compression;
switch ((EParamCompression)compression_i) {
case eParamCompressionAuto:
break;
case eParamCompressionNone: // EXR, TIFF, IFF
compression = "none";
break;
case eParamCompressionZip: // EXR, TIFF, Zfile
compression = "zip";
break;
case eParamCompressionZips: // EXR
compression = "zips";
break;
case eParamCompressionRle: // DPX, IFF, EXR, TGA, RLA
compression = "rle";
case eParamCompressionPiz: // EXR
compression = "piz";
break;
case eParamCompressionPxr24: // EXR
compression = "pxr24";
break;
case eParamCompressionB44: // EXR
compression = "b44";
break;
case eParamCompressionB44a: // EXR
compression = "b44a";
break;
case eParamCompressionLZW: // TIFF
compression = "lzw";
break;
case eParamCompressionCCITTRLE: // TIFF
compression = "ccittrle";
break;
case eParamCompressionPACKBITS: // TIFF
compression = "packbits";
break;
}
spec.attribute("oiio:BitsPerSample", bitsPerSample);
spec.attribute("oiio:UnassociatedAlpha", premultiply);
#ifdef OFX_IO_USING_OCIO
std::string ocioColorspace = _ocio->getOutputColorspace(time);
float gamma = 0.;
std::string colorSpaceStr;
if (ocioColorspace == "Gamma1.8") {
// Gamma1.8 in nuke-default
colorSpaceStr = "GammaCorrected";
gamma = 1.8;
} else if (ocioColorspace == "Gamma2.2" || ocioColorspace == "vd8" || ocioColorspace == "vd10" || ocioColorspace == "vd16") {
// Gamma2.2 in nuke-default
// vd8, vd10, vd16 in spi-anim and spi-vfx
colorSpaceStr = "GammaCorrected";
gamma = 2.2;
} else if (ocioColorspace == "sRGB" || ocioColorspace == "rrt_srgb" || ocioColorspace == "srgb8") {
// sRGB in nuke-default
// rrt_srgb in aces
// srgb8 in spi-vfx
colorSpaceStr = "sRGB";
} else if (ocioColorspace == "Rec709" || ocioColorspace == "rrt_rec709" || ocioColorspace == "hd10") {
// Rec709 in nuke-default
// rrt_rec709 in aces
// hd10 in spi-anim and spi-vfx
colorSpaceStr = "Rec709";
} else if(ocioColorspace == "KodakLog" || ocioColorspace == "Cineon" || ocioColorspace == "lg10") {
// Cineon in nuke-default
// lg10 in spi-vfx
colorSpaceStr = "KodakLog";
} else if(ocioColorspace == "Linear" || ocioColorspace == "linear" || ocioColorspace == "aces" || ocioColorspace == "lnf" || ocioColorspace == "ln16") {
// linear in nuke-default
// aces in aces
// lnf, ln16 in spi-anim and spi-vfx
colorSpaceStr = "Linear";
} else if(ocioColorspace == "raw" || ocioColorspace == "ncf") {
// raw in nuke-default
// raw in aces
// ncf in spi-anim and spi-vfx
// leave empty
} else {
//unknown color-space, don't do anything
}
if (!colorSpaceStr.empty()) {
spec.attribute("oiio:ColorSpace", colorSpaceStr);
}
if (gamma != 0.) {
spec.attribute("oiio:Gamma", gamma);
}
#endif
spec.attribute("CompressionQuality", quality);
spec.attribute("Orientation", orientation + 1);
if (!compression.empty()) { // some formats have a good value for the default compression
spec.attribute("compression", compression);
}
// by default, the channel names are R, G, B, A, which is OK except for Alpha images
if (pixelComponents == OFX::ePixelComponentAlpha) {
spec.channelnames.clear();
spec.channelnames.push_back ("A");
spec.alpha_channel = 0;
}
bool supportsRectangles = output->supports("rectangles");
if (supportsRectangles) {
spec.x = bounds.x1;
spec.y = bounds.y1;
spec.full_x = bounds.x1;
spec.full_y = bounds.y1;
}
if (!output->open(filename, spec)) {
setPersistentMessage(OFX::Message::eMessageError, "", output->geterror());
OFX::throwSuiteStatusException(kOfxStatFailed);
}
if (supportsRectangles) {
output->write_rectangle(spec.x, //xmin
spec.x + spec.width, //xmax
spec.y, //ymin
spec.y + spec.height, //ymax
0, //zmin
1, //zmax
TypeDesc::FLOAT, //datatype
(char*)pixelData + (spec.height - 1) * rowBytes, //invert y
AutoStride, //xstride
-rowBytes, //ystride
AutoStride //zstride
);
} else {
output->write_image(TypeDesc::FLOAT,
(char*)pixelData + (spec.height - 1) * rowBytes, //invert y
AutoStride, //xstride
-rowBytes, //ystride
AutoStride //zstride
);
}
output->close();
}
