// overridden is identity
bool
SwitchPlugin::isIdentity(const OFX::RenderArguments &args, OFX::Clip * &identityClip, double &identityTime)
{
int input;
which_->getValueAtTime(args.time, input);
identityClip = srcClip_[input];
return true;
}
void
SwitchPlugin::changedClip(const OFX::InstanceChangedArgs &args, const std::string &clipName)
{
int maxconnected = 1;
for (int i = 2; i < kSwitchPluginSourceClipCount; ++i) {
if (srcClip_[i]->isConnected()) {
maxconnected = i;
}
}
which_->setDisplayRange(0, maxconnected);
}
OfxRectD CropPlugin::getCropRect( const OfxRectD& rod, const double par )
{
OfxRectD rect;
OFX::IntParam* upBand = fetchIntParam( kParamUp );
OFX::IntParam* downBand = fetchIntParam( kParamDown );
OFX::IntParam* leftBand = fetchIntParam( kParamLeft );
OFX::IntParam* rightBand = fetchIntParam( kParamRight );
rect.x1 = par * leftBand->getValue();
rect.x2 = rod.x2 - par* rightBand->getValue();
rect.y1 = downBand->getValue();
rect.y2 = rod.y2 - upBand->getValue();
return rect;
}
// overridden getTransform
bool SwitchPlugin::getTransform(const OFX::TransformArguments &args, OFX::Clip * &transformClip, double transformMatrix[9])
{
int input;
which_->getValueAtTime(args.time, input);
transformClip = srcClip_[input];
transformMatrix[0] = 1.;
transformMatrix[1] = 0.;
transformMatrix[2] = 0.;
transformMatrix[3] = 0.;
transformMatrix[4] = 1.;
transformMatrix[5] = 0.;
transformMatrix[6] = 0.;
transformMatrix[7] = 0.;
transformMatrix[8] = 1.;
return true;
}
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();
}
void CropPlugin::changedParam( const OFX::InstanceChangedArgs& args, const std::string& paramName )
{
if( paramName == kCropHelpButton )
{
sendMessage( OFX::Message::eMessageMessage,
"", // No XML resources
kCropHelpString );
}
else if( paramName == kParamPresets )
{
// Compute bands sizes in pixels
int f, bandSize;
double ratio;
_paramFormats->getValue( f );
OFX::IntParam* upBand = fetchIntParam( kParamUp );
OFX::IntParam* downBand = fetchIntParam( kParamDown );
OFX::IntParam* leftBand = fetchIntParam( kParamLeft );
OFX::IntParam* rightBand = fetchIntParam( kParamRight );
OfxRectD rod = _clipSrc->getCanonicalRod( timeLineGetTime() );
double par = _clipSrc->getPixelAspectRatio();
int w = (int)std::abs( rod.x2 - rod.x1 );
int h = (int)std::abs( rod.y2 - rod.y1 );
switch( f )
{
// 4/3
case k1_1_33:
ratio = 4.0 / 3.0;
break;
// 16 / 9
case k1_1_77:
ratio = 16.0 / 9.0;
break;
// 1:1.85
case k1_1_85:
ratio = 1.85;
break;
// Cinemascope
case k1_2_35:
ratio = 2.35;
break;
case k1_2_40:
ratio = 2.40;
break;
default:
ratio = 0;
break;
}
// If image ratio is lesser than the specified ratio, we need to add left and right bands
if( ( (double)( w ) / h ) > ratio )
{
bandSize = (int)round( ( w - ( h / ( 1.0 / ratio ) ) ) / 2.0 );
upBand->setValue( 0 );
downBand->setValue( 0 );
leftBand->setValue( (int)round( bandSize / par ) );
rightBand->setValue( (int)round( bandSize / par ) );
}
else if( ( (double)( w ) / h ) < ratio )
{
// Add top and bottom bands
bandSize = (int)round( ( h - ( ( w ) / ratio ) ) / 2.0 );
upBand->setValue( bandSize );
downBand->setValue( bandSize );
leftBand->setValue( 0 );
rightBand->setValue( 0 );
}
else
{
upBand->setValue( 0 );
downBand->setValue( 0 );
leftBand->setValue( 0 );
rightBand->setValue( 0 );
}
}
}
