/* 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();
}
/* 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));
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!
}
// 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();
}
/* set up and run a processor */
void
CrossFadePlugin::setupAndProcess(OFX::ImageBlenderBase &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 the two source images
std::auto_ptr<OFX::Image> fromImg(fromClip_->fetchImage(args.time));
std::auto_ptr<OFX::Image> toImg(toClip_->fetchImage(args.time));
// make sure bit depths are sane
if(fromImg.get()) checkComponents(*fromImg, dstBitDepth, dstComponents);
if(toImg.get()) checkComponents(*toImg, dstBitDepth, dstComponents);
// get the transition value
float blend = (float)transition_->getValueAtTime(args.time);
// set the images
processor.setDstImg(dst.get());
processor.setFromImg(fromImg.get());
processor.setToImg(toImg.get());
// set the render window
processor.setRenderWindow(args.renderWindow);
// set the scales
processor.setBlend(blend);
// Call the base class process member, this will call the derived templated process code
processor.process();
}
/* 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();
}
// the overridden render function
void
NoisePlugin::render(const OFX::RenderArguments &args)
{
// instantiate the render code based on the pixel depth of the dst clip
OFX::BitDepthEnum dstBitDepth = dstClip_->getPixelDepth();
OFX::PixelComponentEnum dstComponents = dstClip_->getPixelComponents();
// do the rendering
if(dstComponents == OFX::ePixelComponentRGBA) {
switch(dstBitDepth)
{
case OFX::eBitDepthUByte : {
NoiseGenerator<unsigned char, 4, 255> fred(*this);
setupAndProcess(fred, args);
}
break;
case OFX::eBitDepthUShort :
{
NoiseGenerator<unsigned short, 4, 65535> fred(*this);
setupAndProcess(fred, args);
}
break;
case OFX::eBitDepthFloat :
{
NoiseGenerator<float, 4, 1> fred(*this);
setupAndProcess(fred, args);
}
break;
}
}
else {
switch(dstBitDepth)
{
case OFX::eBitDepthUByte :
{
NoiseGenerator<unsigned char, 1, 255> fred(*this);
setupAndProcess(fred, args);
}
break;
case OFX::eBitDepthUShort :
{
NoiseGenerator<unsigned short, 1, 65536> fred(*this);
setupAndProcess(fred, args);
}
break;
case OFX::eBitDepthFloat :
{
NoiseGenerator<float, 1, 1> fred(*this);
setupAndProcess(fred, args);
}
break;
}
}
}
// the overridden render function
void
BasicPlugin::render(const OFX::RenderArguments &args)
{
// instantiate the render code based on the pixel depth of the dst clip
OFX::BitDepthEnum dstBitDepth = dstClip_->getPixelDepth();
OFX::PixelComponentEnum dstComponents = dstClip_->getPixelComponents();
// do the rendering
if(dstComponents == OFX::ePixelComponentRGBA) {
switch(dstBitDepth) {
case OFX::eBitDepthUByte : {
ImageScaler<unsigned char, 4, 255> fred(*this);
setupAndProcess(fred, args);
}
break;
case OFX::eBitDepthUShort : {
ImageScaler<unsigned short, 4, 65535> fred(*this);
setupAndProcess(fred, args);
}
break;
case OFX::eBitDepthFloat : {
ImageScaler<float, 4, 1> fred(*this);
setupAndProcess(fred, args);
}
break;
default :
OFX::throwSuiteStatusException(kOfxStatErrUnsupported);
}
}
else {
switch(dstBitDepth) {
case OFX::eBitDepthUByte : {
ImageScaler<unsigned char, 1, 255> fred(*this);
setupAndProcess(fred, args);
}
break;
case OFX::eBitDepthUShort : {
ImageScaler<unsigned short, 1, 65535> fred(*this);
setupAndProcess(fred, args);
}
break;
case OFX::eBitDepthFloat : {
ImageScaler<float, 1, 1> fred(*this);
setupAndProcess(fred, args);
}
break;
default :
OFX::throwSuiteStatusException(kOfxStatErrUnsupported);
}
}
}
/** @brief render for the filter */
void
FilterPlugin::render(const OFX::RenderArguments &args)
{
OFX::Image *src = 0, *dst = 0;
try {
// get a src image
src = srcClip_->fetchImage(args.time);
// get a dst image
dst = dstClip_->fetchImage(args.time);
// push some pixels
// blah;
// blah;
// blah;
}
catch(...) {
delete src;
delete dst;
throw;
}
// delete them
delete src;
delete dst;
}
ImageFilterProcessor(OFX::ImageEffect& effect, const EImageOrientation imageOrientation)
: ImageProcessor(effect, imageOrientation)
{
_clipSrc = effect.fetchClip(kOfxImageEffectSimpleSourceClipName);
if(!_clipSrc->isConnected())
BOOST_THROW_EXCEPTION(exception::ImageNotConnected());
}
virtual void setup( const OFX::RenderArguments& args )
{
// destination view
// TUTTLE_COUT_INFOS;
// TUTTLE_COUT_VAR( "dst - fetchImage " << time );
_dst.reset( _clipDst->fetchImage( args.time ) );
if( !_dst.get() )
BOOST_THROW_EXCEPTION( exception::ImageNotReady()
<< exception::dev() + "Error on clip " + quotes(_clipDst->name()) );
if( _dst->getRowDistanceBytes() == 0 )
BOOST_THROW_EXCEPTION( exception::WrongRowBytes()
<< exception::dev() + "Error on clip " + quotes(_clipDst->name()) );
// _dstPixelRod = _dst->getRegionOfDefinition(); // bug in nuke, returns bounds
_dstPixelRod = _clipDst->getPixelRod( args.time, args.renderScale );
_dstPixelRodSize.x = ( this->_dstPixelRod.x2 - this->_dstPixelRod.x1 );
_dstPixelRodSize.y = ( this->_dstPixelRod.y2 - this->_dstPixelRod.y1 );
}
// override the rod call
bool
BasicPlugin::getRegionOfDefinition(const OFX::RegionOfDefinitionArguments &args, OfxRectD &rod)
{
// our RoD is the same as the 'Source' clip's, we are not interested in the mask
rod = srcClip_->getRegionOfDefinition(args.time);
// say we set it
return true;
}
// 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);
}
void GenericTestPlugin::setupAndProcess(GenericTestBase &processor, const OFX::RenderArguments &args)
{
std::auto_ptr<OFX::Image> dst(dstClip_->fetchImage(args.time));
OFX::BitDepthEnum dstBitDepth = dst->getPixelDepth();
OFX::PixelComponentEnum dstComponents = dst->getPixelComponents();
std::auto_ptr<OFX::Image> src(srcClip_->fetchImage(args.time));
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!
}
processor.setDstImg(dst.get());
processor.setSrcImg(src.get());
processor.setRenderWindow(args.renderWindow);
processor.process();
}
virtual void setup(const OFX::RenderArguments& args)
{
ImageProcessor::setup(args);
// source view
_src.reset(_clipSrc->fetchImage(args.time));
if(!_src.get())
BOOST_THROW_EXCEPTION(exception::ImageNotReady()
<< exception::dev() + "Error on clip " + quotes(_clipSrc->name()));
if(_src->getRowDistanceBytes() == 0)
BOOST_THROW_EXCEPTION(exception::WrongRowBytes()
<< exception::dev() + "Error on clip " + quotes(_clipSrc->name()));
if(OFX::getImageEffectHostDescription()->hostName == "uk.co.thefoundry.nuke")
{
// bug in nuke, getRegionOfDefinition() on OFX::Image returns bounds
_srcPixelRod = _clipSrc->getPixelRod(args.time, args.renderScale);
}
else
{
_srcPixelRod = _src->getRegionOfDefinition();
}
}
// the overridden render function
void
AnaglyphPlugin::render(const OFX::RenderArguments &args)
{
if (!OFX::fetchSuite(kOfxVegasStereoscopicImageEffectSuite, 1, true)) {
OFX::throwHostMissingSuiteException(kOfxVegasStereoscopicImageEffectSuite);
}
// instantiate the render code based on the pixel depth of the dst clip
OFX::BitDepthEnum dstBitDepth = dstClip_->getPixelDepth();
OFX::PixelComponentEnum dstComponents = dstClip_->getPixelComponents();
// do the rendering
assert(dstComponents == OFX::ePixelComponentRGBA);
switch (dstBitDepth) {
case OFX::eBitDepthUByte : {
ImageAnaglypher<unsigned char, 255> fred(*this);
setupAndProcess(fred, args);
}
break;
case OFX::eBitDepthUShort : {
ImageAnaglypher<unsigned short, 65535> fred(*this);
setupAndProcess(fred, args);
}
break;
case OFX::eBitDepthFloat : {
ImageAnaglypher<float, 1> fred(*this);
setupAndProcess(fred, args);
}
break;
default :
OFX::throwSuiteStatusException(kOfxStatErrUnsupported);
}
}
virtual void setup( const OFX::RenderArguments& args )
{
// destination view
_dst.reset( _clipDst->fetchImage( args.time ) );
if( !_dst.get() )
BOOST_THROW_EXCEPTION( exception::ImageNotReady() );
if( _dst->getRowBytes() == 0 )
BOOST_THROW_EXCEPTION( exception::WrongRowBytes() );
// _dstPixelRod = _dst->getRegionOfDefinition(); // bug in nuke, returns bounds
_dstPixelRod = _clipDst->getPixelRod( args.time, args.renderScale );
_dstPixelRodSize.x = ( this->_dstPixelRod.x2 - this->_dstPixelRod.x1 );
_dstPixelRodSize.y = ( this->_dstPixelRod.y2 - this->_dstPixelRod.y1 );
_dstView = getView( _dst.get(), _dstPixelRod );
#ifndef TUTTLE_PRODUCTION
// init dst buffer with red to highlight uninitialized pixels
const OfxRectI dstBounds = this->translateRoWToOutputClipCoordinates( _dst->getBounds() );
View dstToFill = boost::gil::subimage_view( _dstView,
dstBounds.x1, dstBounds.y1,
dstBounds.x2 - dstBounds.x1, dstBounds.y2 - dstBounds.y1 );
const boost::gil::rgba32f_pixel_t errorColor( 1.0, 0.0, 0.0, 1.0 );
fill_pixels( dstToFill, errorColor );
#endif
}
/* override the time domain action, only for the general context */
bool
RetimerPlugin::getTimeDomain(OfxRangeD &range)
{
// this should only be called in the general context, ever!
if(getContext() == OFX::eContextGeneral) {
// If we are a general context, we can changed the duration of the effect, so have a param to do that
// We need a separate param as it is impossible to derive this from a speed param and the input clip
// duration (the speed may be animating or wired to an expression).
double duration = duration_->getValue(); //don't animate
// how many frames on the input clip
OfxRangeD srcRange = srcClip_->getFrameRange();
range.min = 0;
range.max = srcRange.max * duration;
return true;
}
return false;
}
/* set up and run a processor */
void
NoisePlugin::setupAndProcess(NoiseGeneratorBase &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();
// set the images
processor.setDstImg(dst.get());
// set the render window
processor.setRenderWindow(args.renderWindow);
// set the scales
processor.setNoiseLevel((float)noise_->getValueAtTime(args.time));
// set the seed based on the current time, and double it we get difference seeds on different fields
processor.setSeed(uint32_t(args.time * 2.0f + 2000.0f));
// Call the base class process member, this will call the derived templated process code
processor.process();
}
/* set up and run a processor */
void
RetimerPlugin::setupAndProcess(OFX::ImageBlenderBase &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();
// figure the frame we should be retiming from
double sourceTime;
if(getContext() == OFX::eContextRetimer) {
// the host is specifying it, so fetch it from the "sourceTime" pseudo-param
sourceTime = sourceTime_->getValueAtTime(args.time);
}
else {
// we have our own param, which is a speed, so we integrate it to get the time we want
sourceTime = speed_->integrate(0, args.time);
}
// figure the two images we are blending between
double fromTime, toTime;
double blend;
if(args.fieldToRender == OFX::eFieldNone) {
// unfielded, easy peasy
fromTime = floor(sourceTime);
toTime = fromTime + 1;
blend = sourceTime - fromTime;
}
else {
// Fielded clips, pook. We are rendering field doubled images,
// and so need to blend between fields, not frames.
double frac = sourceTime - floor(sourceTime);
if(frac < 0.5) {
// need to go between the first and second fields of this frame
fromTime = floor(sourceTime); // this will get the first field
toTime = fromTime + 0.5; // this will get the second field of the same frame
blend = frac * 2.0; // and the blend is between those two
}
else { // frac > 0.5
fromTime = floor(sourceTime) + 0.5; // this will get the second field of this frame
toTime = floor(sourceTime) + 1.0; // this will get the first field of the next frame
blend = (frac - 0.5) * 2.0;
}
}
// fetch the two source images
std::auto_ptr<OFX::Image> fromImg(srcClip_->fetchImage(fromTime));
std::auto_ptr<OFX::Image> toImg(srcClip_->fetchImage(toTime));
// make sure bit depths are sane
if(fromImg.get()) checkComponents(*fromImg, dstBitDepth, dstComponents);
if(toImg.get()) checkComponents(*toImg, dstBitDepth, dstComponents);
// set the images
processor.setDstImg(dst.get());
processor.setFromImg(fromImg.get());
processor.setToImg(toImg.get());
// set the render window
processor.setRenderWindow(args.renderWindow);
// set the blend between
processor.setBlend((float)blend);
// Call the base class process member, this will call the derived templated process code
processor.process();
}
/* 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 changedParam(const OFX::InstanceChangedArgs &args, const std::string ¶mName)
{
if(paramName=="enableTest")
{
OFX::ChoiceParam* choice = fetchChoiceParam("enableTest");
OFX::DoubleParam* dbl = fetchDoubleParam("enableDbl");
int value = 0;
choice->getValueAtTime(args.time, value);
dbl->setEnabled(value ==0 );
}
else if(paramName=="pbButton")
{
sendMessage(OFX::Message::eMessageMessage, "", "Push Button Pressed - TestPassed!");
}
else if(paramName=="widgetPos")
{
redrawOverlays();
}
else if(paramName == "analyseButton")
{
OFX::BitDepthEnum dstBitDepth = srcClip_->getPixelDepth();
OFX::PixelComponentEnum dstComponents = srcClip_->getPixelComponents();
OFX::DoubleParam* dbl = fetchDoubleParam("analysisParam");
if(dstComponents == OFX::ePixelComponentRGBA)
{
switch(dstBitDepth)
{
case OFX::eBitDepthUByte :
{
Analyser<unsigned char, 4, 255> analyse(srcClip_, dbl);
break;
}
case OFX::eBitDepthUShort :
{
Analyser<unsigned short, 4, 65535> analyse(srcClip_, dbl);
break;
}
case OFX::eBitDepthFloat :
{
Analyser<float, 4, 1> analyse(srcClip_, dbl);
break;
}
default :
OFX::throwSuiteStatusException(kOfxStatErrUnsupported);
}
}
else
{
switch(dstBitDepth)
{
case OFX::eBitDepthUByte :
{
Analyser<unsigned char, 1, 255> analyse(srcClip_, dbl);
break;
}
case OFX::eBitDepthUShort :
{
Analyser<unsigned short, 1, 65535> analyse(srcClip_, dbl);
break;
}
case OFX::eBitDepthFloat :
{
Analyser<float, 1, 1> analyse(srcClip_, dbl);
break;
}
default :
OFX::throwSuiteStatusException(kOfxStatErrUnsupported);
}
}
}
}
void GenericTestPlugin::render(const OFX::RenderArguments &args)
{
OFX::BitDepthEnum dstBitDepth = dstClip_->getPixelDepth();
OFX::PixelComponentEnum dstComponents = dstClip_->getPixelComponents();
if(dstComponents == OFX::ePixelComponentRGBA)
{
switch(dstBitDepth)
{
case OFX::eBitDepthUByte :
{
ImageGenericTester<unsigned char, 4, 255> fred(*this);
setupAndProcess(fred, args);
}
break;
case OFX::eBitDepthUShort :
{
ImageGenericTester<unsigned short, 4, 65535> fred(*this);
setupAndProcess(fred, args);
}
break;
case OFX::eBitDepthFloat :
{
ImageGenericTester<float, 4, 1> fred(*this);
setupAndProcess(fred, args);
}
break;
default :
OFX::throwSuiteStatusException(kOfxStatErrUnsupported);
}
}
else {
switch(dstBitDepth)
{
case OFX::eBitDepthUByte :
{
ImageGenericTester<unsigned char, 1, 255> fred(*this);
setupAndProcess(fred, args);
}
break;
case OFX::eBitDepthUShort :
{
ImageGenericTester<unsigned short, 1, 65535> fred(*this);
setupAndProcess(fred, args);
}
break;
case OFX::eBitDepthFloat :
{
ImageGenericTester<float, 1, 1> fred(*this);
setupAndProcess(fred, args);
}
break;
default :
OFX::throwSuiteStatusException(kOfxStatErrUnsupported);
}
}
}
