bool ReaderPlugin::getTimeDomain(OfxRangeD& range)
{
range.min = getFirstTime();
range.max = getLastTime();
TUTTLE_LOG_INFO("[Reader plugin] Time Domain : " << range.min << " to " << range.max);
return true;
}
void ProcessGraph::endSequence()
{
_options.endSequenceHandle();
TUTTLE_LOG_INFO( "[Process render] process end sequence" );
//--- END sequence render
BOOST_FOREACH( NodeMap::value_type& p, _nodes )
{
p.second->endSequence( _procOptions ); // node option... or no option here ?
}
/*
*Generate average from color selection clip
*/
bool SelectionAverage::computeAverageSelection(OFX::Clip* clipColor, const OfxPointD& renderScale)
{
// connection test
if( ! clipColor->isConnected() )
{
return false;
}
boost::scoped_ptr<OFX::Image> src( clipColor->fetchImage(_time, clipColor->getCanonicalRod(_time, renderScale)) ); //scoped pointer of current source clip
// Compatibility tests
if( !src.get() ) // source isn't accessible
{
TUTTLE_LOG_INFO( "color src is not accessible (average)" );
return false;
}
if( src->getRowDistanceBytes() == 0 )//if source is wrong
{
BOOST_THROW_EXCEPTION( exception::WrongRowBytes() );
return false;
}
const OfxRectI srcPixelRod = clipColor->getPixelRod( _time, renderScale ); //get current RoD
if( (clipColor->getPixelDepth() != OFX::eBitDepthFloat) ||
(!clipColor->getPixelComponents()) )
{
BOOST_THROW_EXCEPTION( exception::Unsupported() << exception::user() + "Can't compute histogram data with the actual input clip format." );
return false;
}
//TUTTLE_TLOG_VAR( TUTTLE_INFO, src->getBounds());
//TUTTLE_TLOG_VAR( TUTTLE_INFO, src->getRegionOfDefinition() );
if( srcPixelRod != src->getBounds() )// the host does bad things !
{
// remove overlay... but do not crash.
TUTTLE_LOG_WARNING( "Image RoD and image bounds are not the same (rod=" << srcPixelRod << " , bounds:" << src->getBounds() << ")." );
return false;
}
// Compute if source is OK
SView colorView = tuttle::plugin::getGilView<SView>( src.get(), srcPixelRod, eImageOrientationIndependant ); // get current view from color clip
ComputeAverage<SView>::CPixel average = ComputeAverage<SView>()( colorView ); // compute color clip average
//copy computed average into average stock variable
_averageValue.x = average[0]; //red channel value
_averageValue.y = average[1]; //green channel value
_averageValue.z = average[2]; //blue channel values
return true; //average has been computed
}
void WriterPlugin::render( const OFX::RenderArguments& args )
{
_oneRender = false;
TUTTLE_LOG_INFO( " --> " << getAbsoluteFilenameAt( args.time ) );
if( _paramCopyToOutput->getValue() )
{
boost::scoped_ptr<OFX::Image> src( _clipSrc->fetchImage( args.time ) );
boost::scoped_ptr<OFX::Image> dst( _clipDst->fetchImage( args.time ) );
// Copy buffer
const OfxRectI bounds = dst->getBounds();
TUTTLE_LOG_VAR( TUTTLE_TRACE, bounds );
if( src->isLinearBuffer() && dst->isLinearBuffer() )
{
TUTTLE_LOG_TRACE( "isLinearBuffer" );
const std::size_t imageDataBytes = dst->getBoundsImageDataBytes();
TUTTLE_LOG_VAR( TUTTLE_TRACE, imageDataBytes );
if( imageDataBytes )
{
void* dataSrcPtr = src->getPixelAddress( bounds.x1, bounds.y1 );
void* dataDstPtr = dst->getPixelAddress( bounds.x1, bounds.y1 );
memcpy( dataDstPtr, dataSrcPtr, imageDataBytes );
}
}
else
{
const std::size_t rowBytesToCopy = dst->getBoundsRowDataBytes();
for( int y = bounds.y1; y < bounds.y2; ++y )
{
void* dataSrcPtr = src->getPixelAddress( bounds.x1, y );
void* dataDstPtr = dst->getPixelAddress( bounds.x1, y );
memcpy( dataDstPtr, dataSrcPtr, rowBytesToCopy );
}
}
}
}
void ReaderPlugin::render(const OFX::RenderArguments& args)
{
std::string filename = getAbsoluteFilenameAt(args.time);
TUTTLE_LOG_INFO(" >-- " << filename);
}
