void Node::_flushObjects()
{
ClientPtr client = getClient();
{
lunchbox::ScopedMutex<> mutex( _barriers );
for( BarrierHash::const_iterator i =_barriers->begin();
i != _barriers->end(); ++ i )
{
co::Barrier* barrier = i->second;
client->unmapObject( barrier );
delete barrier;
}
_barriers->clear();
}
lunchbox::ScopedMutex<> mutex( _frameDatas );
LBASSERT( _frameDatas->empty( ));
for( FrameDataHashCIter i = _frameDatas->begin();
i != _frameDatas->end(); ++i )
{
FrameDataPtr frameData = i->second;
client->unmapObject( frameData.get( ));
}
_frameDatas->clear();
}
bool Node::_cmdFrameDataTransmit( co::ICommand& cmd )
{
co::ObjectICommand command( cmd );
const co::ObjectVersion& frameDataVersion =
command.read< co::ObjectVersion >();
const PixelViewport& pvp = command.read< PixelViewport >();
const Zoom& zoom = command.read< Zoom >();
const uint32_t buffers = command.read< uint32_t >();
const uint32_t frameNumber = command.read< uint32_t >();
const bool useAlpha = command.read< bool >();
const uint8_t* data = reinterpret_cast< const uint8_t* >(
command.getRemainingBuffer( command.getRemainingBufferSize( )));
LBLOG( LOG_ASSEMBLY )
<< "received image data for " << frameDataVersion << ", buffers "
<< buffers << " pvp " << pvp << std::endl;
LBASSERT( pvp.isValid( ));
FrameDataPtr frameData = getFrameData( frameDataVersion );
LBASSERT( !frameData->isReady() );
NodeStatistics event( Statistic::NODE_FRAME_DECOMPRESS, this,
frameNumber );
// Note on the const_cast: since the PixelData structure stores non-const
// pointers, we have to go non-const at some point, even though we do not
// modify the data.
LBCHECK( frameData->addImage( frameDataVersion, pvp, zoom, buffers,
useAlpha, const_cast< uint8_t* >( data )));
return true;
}
bool Node::_cmdFrameDataReady( co::Command& command )
{
const NodeFrameDataReadyPacket* packet =
command.get<NodeFrameDataReadyPacket>();
LBLOG( LOG_ASSEMBLY ) << "received ready for " << packet->frameData
<< std::endl;
FrameDataPtr frameData = getFrameData( packet->frameData );
LBASSERT( frameData );
LBASSERT( !frameData->isReady() );
frameData->setReady( packet );
LBASSERT( frameData->isReady() );
return true;
}
FrameDataPtr Node::getFrameData( const co::ObjectVersion& frameDataVersion )
{
lunchbox::ScopedWrite mutex( _frameDatas );
FrameDataPtr data = _frameDatas.data[ frameDataVersion.identifier ];
if( !data )
{
data = new FrameData;
data->setID( frameDataVersion.identifier );
_frameDatas.data[ frameDataVersion.identifier ] = data;
}
LBASSERT( frameDataVersion.version.high() == 0 );
data->setVersion( frameDataVersion.version.low( ));
return data;
}
bool Node::_cmdFrameDataReady( co::ICommand& cmd )
{
co::ObjectICommand command( cmd );
const co::ObjectVersion& frameDataVersion =
command.read< co::ObjectVersion >();
const fabric::FrameData& data = command.read< fabric::FrameData >();
LBLOG( LOG_ASSEMBLY ) << "received ready for " << frameDataVersion
<< std::endl;
FrameDataPtr frameData = getFrameData( frameDataVersion );
LBASSERT( frameData );
LBASSERT( !frameData->isReady() );
frameData->setReady( frameDataVersion, data );
LBASSERT( frameData->isReady() );
return true;
}
bool Node::_cmdFrameDataTransmit( co::Command& command )
{
const NodeFrameDataTransmitPacket* packet =
command.get<NodeFrameDataTransmitPacket>();
LBLOG( LOG_ASSEMBLY )
<< "received image data for " << packet->frameData << ", buffers "
<< packet->buffers << " pvp " << packet->pvp << std::endl;
LBASSERT( packet->pvp.isValid( ));
FrameDataPtr frameData = getFrameData( packet->frameData );
LBASSERT( !frameData->isReady() );
NodeStatistics event( Statistic::NODE_FRAME_DECOMPRESS, this,
packet->frameNumber );
LBCHECK( frameData->addImage( packet ));
return true;
}
void Node::releaseFrameData( FrameDataPtr data )
{
lunchbox::ScopedWrite mutex( _frameDatas );
FrameDataHashIter i = _frameDatas->find( data->getID( ));
EQASSERT( i != _frameDatas->end( ));
if( i == _frameDatas->end( ))
return;
_frameDatas->erase( i );
}
Frame* Pipe::getFrame( const co::ObjectVersion& frameVersion, const Eye eye,
const bool isOutput )
{
LB_TS_THREAD( _pipeThread );
Frame* frame = _impl->frames[ frameVersion.identifier ];
if( !frame )
{
ClientPtr client = getClient();
frame = new Frame();
LBCHECK( client->mapObject( frame, frameVersion ));
_impl->frames[ frameVersion.identifier ] = frame;
}
else
frame->sync( frameVersion.version );
const co::ObjectVersion& dataVersion = frame->getDataVersion( eye );
LBLOG( LOG_ASSEMBLY ) << "Use " << dataVersion << std::endl;
FrameDataPtr frameData = getNode()->getFrameData( dataVersion );
LBASSERT( frameData );
if( isOutput )
{
if( !frameData->isAttached() )
{
ClientPtr client = getClient();
LBCHECK( client->mapObject( frameData.get(), dataVersion ));
}
else if( frameData->getVersion() < dataVersion.version )
frameData->sync( dataVersion.version );
_impl->outputFrameDatas[ dataVersion.identifier ] = frameData;
}
else
_impl->inputFrameDatas[ dataVersion.identifier ] = frameData;
frame->setFrameData( frameData );
return frame;
}
void Pipe::flushFrames( ObjectManager* om )
{
LB_TS_THREAD( _pipeThread );
ClientPtr client = getClient();
for( FrameHashCIter i = _impl->frames.begin(); i !=_impl->frames.end(); ++i)
{
Frame* frame = i->second;
frame->setFrameData( 0 ); // datas are flushed below
client->unmapObject( frame );
delete frame;
}
_impl->frames.clear();
for( FrameDataHashCIter i = _impl->inputFrameDatas.begin();
i != _impl->inputFrameDatas.end(); ++i )
{
FrameDataPtr data = i->second;
data->deleteGLObjects( om );
}
_impl->inputFrameDatas.clear();
for( FrameDataHashCIter i = _impl->outputFrameDatas.begin();
i != _impl->outputFrameDatas.end(); ++i )
{
FrameDataPtr data = i->second;
data->resetPlugins();
data->deleteGLObjects( om );
client->unmapObject( data.get( ));
getNode()->releaseFrameData( data );
}
_impl->outputFrameDatas.clear();
}
void Node::_flushObjects()
{
ClientPtr client = getClient();
{
lunchbox::ScopedMutex<> mutex( _impl->barriers );
for( BarrierHash::const_iterator i = _impl->barriers->begin();
i != _impl->barriers->end(); ++i )
{
delete i->second;
}
_impl->barriers->clear();
}
lunchbox::ScopedMutex<> mutex( _impl->frameDatas );
for( FrameDataHashCIter i = _impl->frameDatas->begin();
i != _impl->frameDatas->end(); ++i )
{
FrameDataPtr frameData = i->second;
frameData->resetPlugins();
client->unmapObject( frameData.get( ));
}
_impl->frameDatas->clear();
}
