LCOV - code coverage report
Current view: top level - eq/server - frame.cpp (source / functions) Hit Total Coverage
Test: Equalizer Lines: 31 101 30.7 %
Date: 2016-07-30 05:04:55 Functions: 6 13 46.2 %

          Line data    Source code
       1             : 
       2             : /* Copyright (c) 2006-2012, Stefan Eilemann <eile@equalizergraphics.com>
       3             :  *                    2010, Cedric Stalder <cedric.stalder@gmail.com>
       4             :  *
       5             :  * This library is free software; you can redistribute it and/or modify it under
       6             :  * the terms of the GNU Lesser General Public License version 2.1 as published
       7             :  * by the Free Software Foundation.
       8             :  *
       9             :  * This library is distributed in the hope that it will be useful, but WITHOUT
      10             :  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
      11             :  * FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
      12             :  * details.
      13             :  *
      14             :  * You should have received a copy of the GNU Lesser General Public License
      15             :  * along with this library; if not, write to the Free Software Foundation, Inc.,
      16             :  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
      17             :  */
      18             : 
      19             : #include "frame.h"
      20             : 
      21             : #include "compound.h"
      22             : #include "frameData.h"
      23             : #include "node.h"
      24             : 
      25             : #include <co/dataIStream.h>
      26             : #include <co/dataOStream.h>
      27             : 
      28             : namespace eq
      29             : {
      30             : namespace server
      31             : {
      32             : 
      33        5564 : Frame::Frame()
      34             :         : _compound( 0 )
      35             :         , _buffers( BUFFER_UNDEFINED )
      36             :         , _type( TYPE_MEMORY )
      37             :         , _native()
      38        5564 :         , _masterFrameData( 0 )
      39             : {
      40        5564 :     setNativeZoom( Zoom( 0.f, 0.f )); //set invalid zoom to detect 'set' state
      41       22256 :     for( unsigned i = 0; i < NUM_EYES; ++i )
      42       16692 :         _frameData[i] = 0;
      43        5564 : }
      44             : 
      45           0 : Frame::Frame( const Frame& from )
      46             :         : fabric::Frame( from )
      47             :         , _compound( 0 )
      48             :         , _vp( from._vp )
      49             :         , _buffers( from._buffers )
      50             :         , _type( from._type )
      51             :         , _native( from._native )
      52           0 :         , _masterFrameData( 0 )
      53             : {
      54           0 :     for( unsigned i = 0; i < NUM_EYES; ++i )
      55           0 :         _frameData[i] = 0;
      56           0 : }
      57             : 
      58       16692 : Frame::~Frame()
      59             : {
      60        5564 :     LBASSERT( _datas.empty());
      61        5564 :     _compound = 0;
      62        5564 :     _masterFrameData = 0;
      63       11128 : }
      64             : 
      65           0 : void Frame::flush()
      66             : {
      67           0 :     unsetData();
      68             : 
      69           0 :     while( !_datas.empty( ))
      70             :     {
      71           0 :         FrameData* data = _datas.front();
      72           0 :         _datas.pop_front();
      73           0 :         getLocalNode()->deregisterObject( data );
      74           0 :         delete data;
      75             :     }
      76           0 : }
      77             : 
      78           0 : void Frame::unsetData()
      79             : {
      80           0 :     for( unsigned i = 0; i < NUM_EYES; ++i )
      81             :     {
      82           0 :         _frameData[i] = 0;
      83           0 :         _inputFrames[i].clear();
      84           0 :         _getInputNodes( i ).clear();
      85           0 :         _getInputNetNodes( i ).clear();
      86             :     }
      87           0 : }
      88             : 
      89           0 : void Frame::commitData()
      90             : {
      91           0 :     if( !_masterFrameData ) // not used
      92           0 :         return;
      93             : 
      94           0 :     for( unsigned i = 0; i< NUM_EYES; ++i )
      95             :     {
      96           0 :         if( _frameData[i] )
      97             :         {
      98           0 :             if( _frameData[i] != _masterFrameData )
      99           0 :                 _frameData[i]->fabric::FrameData::operator =(*_masterFrameData);
     100             : 
     101           0 :             _frameData[i]->commit();
     102             :         }
     103             :     }
     104             : }
     105             : 
     106           0 : uint128_t Frame::commit( const uint32_t incarnation )
     107             : {
     108           0 :     for( unsigned i = 0; i < NUM_EYES; ++i )
     109           0 :         _setDataVersion( i, co::ObjectVersion( _frameData[i] ));
     110           0 :     return co::Object::commit( incarnation );
     111             : }
     112             : 
     113           0 : void Frame::cycleData( const uint32_t frameNumber, const Compound* compound )
     114             : {
     115           0 :     _masterFrameData = 0;
     116           0 :     for( unsigned i = 0; i < NUM_EYES; ++i )
     117             :     {
     118           0 :         _inputFrames[i].clear();
     119             : 
     120           0 :         const Eye eye = Eye(1<<i);
     121           0 :         if( !compound->isInheritActive( eye )) // eye pass not used
     122             :         {
     123           0 :             _frameData[i] = 0;
     124           0 :             continue;
     125             :         }
     126             : 
     127             :         // reuse unused frame data
     128           0 :         FrameData*     data    = _datas.empty() ? 0 : _datas.back();
     129           0 :         const uint32_t latency = getAutoObsolete();
     130           0 :         const uint32_t dataAge = data ? data->getFrameNumber() : 0;
     131             : 
     132           0 :         if( data && dataAge < frameNumber-latency && frameNumber > latency )
     133             :             // not used anymore
     134           0 :             _datas.pop_back();
     135             :         else // still used - allocate new data
     136             :         {
     137           0 :             data = new FrameData;
     138             : 
     139           0 :             getLocalNode()->registerObject( data );
     140           0 :             data->setAutoObsolete( 1 ); // current + in use by render nodes
     141             :         }
     142             : 
     143           0 :         data->setFrameNumber( frameNumber );
     144             : 
     145           0 :         _datas.push_front( data );
     146           0 :         _frameData[i] = data;
     147           0 :         _getInputNodes( i ).clear();
     148           0 :         _getInputNetNodes( i ).clear();
     149           0 :         if( !_masterFrameData )
     150           0 :             _masterFrameData = data;
     151             :     }
     152           0 : }
     153             : 
     154           0 : void Frame::addInputFrame( Frame* frame, const Compound* compound )
     155             : {
     156           0 :     for( unsigned i = 0; i < NUM_EYES; ++i )
     157             :     {
     158             :         // eye pass not used && no output frame for eye pass
     159           0 :         const Eye eye = Eye( 1<<i );
     160           0 :         if( compound->isInheritActive( eye ) && _frameData[i] )
     161             :         {
     162           0 :             frame->_frameData[i] = _frameData[i];
     163           0 :             _inputFrames[i].push_back( frame );
     164             : 
     165           0 :             const Node* inputNode = frame->getNode();
     166           0 :             if( inputNode != getNode( ))
     167             :             {
     168           0 :                 co::NodePtr inputNetNode = inputNode->getNode();
     169           0 :                 _getInputNodes( i ).push_back( inputNode->getID( ));
     170           0 :                 _getInputNetNodes( i ).push_back( inputNetNode->getNodeID( ));
     171             :             }
     172             :         }
     173             :         else
     174             :         {
     175           0 :             frame->_frameData[i] = 0;
     176             :         }
     177             :     }
     178           0 : }
     179             : 
     180        2782 : std::ostream& operator << ( std::ostream& os, const Frame& frame )
     181             : {
     182        2782 :     os << lunchbox::disableFlush << "frame" << std::endl
     183        2782 :        << "{" << std::endl << lunchbox::indent
     184        5564 :        << "name     \"" << frame.getName() << "\"" << std::endl;
     185             : 
     186        2782 :     const uint32_t buffers = frame.getBuffers();
     187        2782 :     if( buffers != Frame::BUFFER_UNDEFINED )
     188             :     {
     189         124 :         os << "buffers  [";
     190         124 :         if( buffers & Frame::BUFFER_COLOR )  os << " COLOR";
     191         124 :         if( buffers & Frame::BUFFER_DEPTH )  os << " DEPTH";
     192         124 :         os << " ]" << std::endl;
     193             :     }
     194             : 
     195        2782 :     const Frame::Type frameType = frame.getType();
     196        2782 :     if( frameType != Frame::TYPE_MEMORY )
     197          62 :         os  << frameType;
     198             : 
     199        2782 :     const Viewport& vp = frame.getViewport();
     200        2782 :     if( vp != Viewport::FULL )
     201         738 :         os << "viewport " << vp << std::endl;
     202             : 
     203        2782 :     const Zoom& zoom = frame.getZoom();
     204        2782 :     if( zoom.isValid() && zoom != Zoom::NONE )
     205           0 :         os << zoom << std::endl;
     206             : 
     207        2782 :     return os << lunchbox::exdent << "}" << lunchbox::enableFlush;
     208             : }
     209             : 
     210             : }
     211          84 : }

Generated by: LCOV version 1.11