LCOV - code coverage report
Current view: top level - eq/server - frame.cpp (source / functions) Hit Total Coverage
Test: lcov2.info Lines: 90 101 89.1 %
Date: 2014-06-18 Functions: 12 13 92.3 %

          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        2924 : Frame::Frame()
      34             :         : _compound( 0 )
      35             :         , _buffers( BUFFER_UNDEFINED )
      36             :         , _type( TYPE_MEMORY )
      37        2924 :         , _masterFrameData( 0 )
      38             : {
      39        2924 :     setNativeZoom( Zoom( 0.f, 0.f )); //set invalid zoom to detect 'set' state
      40       11696 :     for( unsigned i = 0; i < NUM_EYES; ++i )
      41        8772 :         _frameData[i] = 0;
      42        2924 : }
      43             : 
      44           0 : Frame::Frame( const Frame& from )
      45             :         : fabric::Frame( from )
      46             :         , _compound( 0 )
      47             :         , _vp( from._vp )
      48             :         , _buffers( from._buffers )
      49             :         , _type( from._type )
      50           0 :         , _masterFrameData( 0 )
      51             : {
      52           0 :     for( unsigned i = 0; i < NUM_EYES; ++i )
      53           0 :         _frameData[i] = 0;
      54           0 : }
      55             : 
      56        8772 : Frame::~Frame()
      57             : {
      58        2924 :     LBASSERT( _datas.empty());
      59        2924 :     _compound = 0;
      60        2924 :     _masterFrameData = 0;
      61        5848 : }
      62             : 
      63         150 : void Frame::flush()
      64             : {
      65         150 :     unsetData();
      66             : 
      67         309 :     while( !_datas.empty( ))
      68             :     {
      69           9 :         FrameData* data = _datas.front();
      70           9 :         _datas.pop_front();
      71           9 :         getLocalNode()->deregisterObject( data );
      72           9 :         delete data;
      73             :     }
      74         150 : }
      75             : 
      76         150 : void Frame::unsetData()
      77             : {
      78         600 :     for( unsigned i = 0; i < NUM_EYES; ++i )
      79             :     {
      80         450 :         _frameData[i] = 0;
      81         450 :         _inputFrames[i].clear();
      82         450 :         _getInputNodes( i ).clear();
      83         450 :         _getInputNetNodes( i ).clear();
      84             :     }
      85         150 : }
      86             : 
      87           9 : void Frame::commitData()
      88             : {
      89           9 :     if( !_masterFrameData ) // not used
      90           9 :         return;
      91             : 
      92          36 :     for( unsigned i = 0; i< NUM_EYES; ++i )
      93             :     {
      94          27 :         if( _frameData[i] )
      95             :         {
      96           9 :             if( _frameData[i] != _masterFrameData )
      97           0 :                 _frameData[i]->_data = _masterFrameData->_data;
      98             : 
      99           9 :             _frameData[i]->commit();
     100             :         }
     101             :     }
     102             : }
     103             : 
     104          18 : uint128_t Frame::commit( const uint32_t incarnation )
     105             : {
     106          72 :     for( unsigned i = 0; i < NUM_EYES; ++i )
     107          54 :         _setDataVersion( i, _frameData[i] );
     108          18 :     return co::Object::commit( incarnation );
     109             : }
     110             : 
     111           9 : void Frame::cycleData( const uint32_t frameNumber, const Compound* compound )
     112             : {
     113           9 :     _masterFrameData = 0;
     114          36 :     for( unsigned i = 0; i < NUM_EYES; ++i )
     115             :     {
     116          27 :         _inputFrames[i].clear();
     117             : 
     118          27 :         const Eye eye = Eye(1<<i);
     119          27 :         if( !compound->isInheritActive( eye )) // eye pass not used
     120             :         {
     121          18 :             _frameData[i] = 0;
     122          18 :             continue;
     123             :         }
     124             : 
     125             :         // reuse unused frame data
     126           9 :         FrameData*     data    = _datas.empty() ? 0 : _datas.back();
     127           9 :         const uint32_t latency = getAutoObsolete();
     128           9 :         const uint32_t dataAge = data ? data->getFrameNumber() : 0;
     129             : 
     130           9 :         if( data && dataAge < frameNumber-latency && frameNumber > latency )
     131             :             // not used anymore
     132           0 :             _datas.pop_back();
     133             :         else // still used - allocate new data
     134             :         {
     135           9 :             data = new FrameData;
     136             : 
     137           9 :             getLocalNode()->registerObject( data );
     138           9 :             data->setAutoObsolete( 1 ); // current + in use by render nodes
     139             :         }
     140             : 
     141           9 :         data->setFrameNumber( frameNumber );
     142             :     
     143           9 :         _datas.push_front( data );
     144           9 :         _frameData[i] = data;
     145           9 :         _getInputNodes( i ).clear();
     146           9 :         _getInputNetNodes( i ).clear();
     147           9 :         if( !_masterFrameData )
     148           9 :             _masterFrameData = data;
     149             :     }
     150           9 : }
     151             : 
     152           9 : void Frame::addInputFrame( Frame* frame, const Compound* compound )
     153             : {
     154          36 :     for( unsigned i = 0; i < NUM_EYES; ++i )
     155             :     {
     156             :         // eye pass not used && no output frame for eye pass
     157          27 :         const Eye eye = Eye( 1<<i );
     158          27 :         if( compound->isInheritActive( eye ) && _frameData[i] )     
     159             :         {
     160           9 :             frame->_frameData[i] = _frameData[i];
     161           9 :             _inputFrames[i].push_back( frame );
     162             : 
     163           9 :             const Node* inputNode = frame->getNode();
     164           9 :             if( inputNode != getNode( ))
     165             :             {
     166           0 :                 co::NodePtr inputNetNode = inputNode->getNode();
     167           0 :                 _getInputNodes( i ).push_back( inputNode->getID( ));
     168           0 :                 _getInputNetNodes( i ).push_back( inputNetNode->getNodeID( ));
     169             :             }
     170             :         }
     171             :         else
     172             :         {
     173          18 :             frame->_frameData[i] = 0;
     174             :         }
     175             :     }
     176           9 : }
     177             : 
     178        1705 : std::ostream& operator << ( std::ostream& os, const Frame& frame )
     179             : {
     180        1705 :     os << lunchbox::disableFlush << "frame" << std::endl
     181        1705 :        << "{" << std::endl << lunchbox::indent
     182        3410 :        << "name     \"" << frame.getName() << "\"" << std::endl;
     183             : 
     184        1705 :     const uint32_t buffers = frame.getBuffers();
     185        1705 :     if( buffers != Frame::BUFFER_UNDEFINED )
     186             :     {
     187          62 :         os << "buffers  [";
     188          62 :         if( buffers & Frame::BUFFER_COLOR )  os << " COLOR";
     189          62 :         if( buffers & Frame::BUFFER_DEPTH )  os << " DEPTH";
     190          62 :         os << " ]" << std::endl;
     191             :     }
     192             : 
     193        1705 :     const Frame::Type frameType = frame.getType();
     194        1705 :     if( frameType != Frame::TYPE_MEMORY )
     195          29 :         os  << frameType;
     196             :     
     197        1705 :     const Viewport& vp = frame.getViewport();
     198        1705 :     if( vp != Viewport::FULL )
     199         367 :         os << "viewport " << vp << std::endl;
     200             : 
     201        1705 :     const Zoom& zoom = frame.getZoom();
     202        1705 :     if( zoom.isValid() && zoom != Zoom::NONE )
     203           0 :         os << zoom << std::endl;
     204             : 
     205        1705 :     return os << lunchbox::exdent << "}" << lunchbox::enableFlush;
     206             : }
     207             : 
     208             : }
     209          27 : }

Generated by: LCOV version 1.10