CR#2: various style cleanups

CMakeLists.txt

@@ -1,5 +1,5 @@
 
-# Copyright (c) 2013-2016, EPFL/Blue Brain Project
+# Copyright (c) 2013-2017, EPFL/Blue Brain Project
 # Raphael Dumusc <raphael.dumusc@epfl.ch>
 # Daniel Nachbaur <daniel.nachbaur@epfl.ch>
 

apps/SimpleStreamer/main.cpp

@@ -286,7 +286,7 @@ void display()
  glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
  glutSolidTeapot( 1.f );
  const auto leftImage = Image::readGlBuffer();
- success = send( leftImage, deflect::View::LEFT_EYE );
+ success = send( leftImage, deflect::View::left_eye );
  }
  if( deflectStereoStreamRight && !waitToStart )
  {
@@ -295,15 +295,15 @@ void display()
  glutSolidTeapot( 1.f );
  const auto rightImage = Image::readGlBuffer();
  success = (!deflectStereoStreamLeft || success) &&
- send( rightImage, deflect::View::RIGHT_EYE );
+ send( rightImage, deflect::View::right_eye );
  }
  }
  else
  {
  glClearColor( 0.5, 0.5, 0.5, 1.0 );
  glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
  glutSolidTeapot( 1.f );
- success = send( Image::readGlBuffer(), deflect::View::MONO );
+ success = send( Image::readGlBuffer(), deflect::View::mono );
  }
 
  glutSwapBuffers();

deflect/Frame.h

@@ -63,7 +63,7 @@ class Frame
  QString uri;
 
  /** The view to which this frame belongs. */
- View view = View::MONO;
+ View view = View::mono;
 
  /** Get the total dimensions of this frame. */
  DEFLECT_API QSize computeDimensions() const;

deflect/FrameDispatcher.cpp

@@ -57,41 +57,41 @@ class FrameDispatcher::Impl
  {
  FramePtr frame( new Frame );
  frame->uri = uri;
- frame->view = View::MONO;
+ frame->view = View::mono;
 
  ReceiveBuffer& buffer = streamBuffers[uri];
  while( buffer.hasCompleteMonoFrame( ))
- frame->segments = buffer.popFrame( View::MONO );
+ frame->segments = buffer.popFrame( View::mono );
  assert( !frame->segments.empty( ));
 
  // receiver will request a new frame once this frame was consumed
- buffer.setAllowedToSend( false, View::MONO );
+ buffer.setAllowedToSend( false, View::mono );
  return frame;
  }
 
  std::pair<FramePtr,FramePtr> consumeLatestStereoFrame( const QString& uri )
  {
  FramePtr frameLeft( new Frame );
  frameLeft->uri = uri;
- frameLeft->view = View::LEFT_EYE;
+ frameLeft->view = View::left_eye;
 
  FramePtr frameRight( new Frame );
  frameRight->uri = uri;
- frameRight->view = View::RIGHT_EYE;
+ frameRight->view = View::right_eye;
 
  ReceiveBuffer& buffer = streamBuffers[uri];
 
  while( buffer.hasCompleteStereoFrame( ))
  {
- frameLeft->segments = buffer.popFrame( View::LEFT_EYE );
- frameRight->segments = buffer.popFrame( View::RIGHT_EYE );
+ frameLeft->segments = buffer.popFrame( View::left_eye );
+ frameRight->segments = buffer.popFrame( View::right_eye );
  }
  assert( !frameLeft->segments.empty( ));
  assert( !frameRight->segments.empty( ));
 
  // receiver will request a new frame once this frame was consumed
- buffer.setAllowedToSend( false, View::LEFT_EYE );
- buffer.setAllowedToSend( false, View::RIGHT_EYE );
+ buffer.setAllowedToSend( false, View::left_eye );
+ buffer.setAllowedToSend( false, View::right_eye );
  return std::make_pair( std::move( frameLeft ), std::move( frameRight ));
  }
 
@@ -150,11 +150,11 @@ void FrameDispatcher::processFrameFinished( const QString uri,
  return;
  }
 
- if( buffer.isAllowedToSend( View::MONO ) && buffer.hasCompleteMonoFrame( ))
+ if( buffer.isAllowedToSend( View::mono ) && buffer.hasCompleteMonoFrame( ))
  emit sendFrame( _impl->consumeLatestMonoFrame( uri ));
 
- if( buffer.isAllowedToSend( View::LEFT_EYE ) &&
- buffer.isAllowedToSend( View::RIGHT_EYE ) &&
+ if( buffer.isAllowedToSend( View::left_eye ) &&
+ buffer.isAllowedToSend( View::right_eye ) &&
  buffer.hasCompleteStereoFrame( ))
  {
  const auto frames = _impl->consumeLatestStereoFrame( uri );
@@ -169,9 +169,9 @@ void FrameDispatcher::requestFrame( const QString uri )
  return;
 
  ReceiveBuffer& buffer = _impl->streamBuffers[uri];
- buffer.setAllowedToSend( true, View::MONO );
- buffer.setAllowedToSend( true, View::LEFT_EYE );
- buffer.setAllowedToSend( true, View::RIGHT_EYE );
+ buffer.setAllowedToSend( true, View::mono );
+ buffer.setAllowedToSend( true, View::left_eye );
+ buffer.setAllowedToSend( true, View::right_eye );
 
  if( buffer.hasCompleteMonoFrame( ))
  emit sendFrame( _impl->consumeLatestMonoFrame( uri ));

deflect/FrameDispatcher.h

@@ -100,12 +100,12 @@ public slots:
  void processFrameFinished( QString uri, size_t sourceIndex );
 
  /**
- * Request the dispatching of a new frame for any stream (MONO/STEREO).
+ * Request the dispatching of a new frame for any stream (mono/stereo).
  *
  * A sendFrame() signal will be emitted for each of the view for which a
  * frame becomes available.
  *
- * Stereo LEFT/RIGHT frames will only be be dispatched together when both
+ * Stereo left/right frames will only be be dispatched together when both
  * are available to ensure that the two eye channels remain synchronized.
  *
  * @param uri Identifier for the stream

deflect/ImageWrapper.h

@@ -121,10 +121,10 @@ struct ImageWrapper
  //@}
 
  /**
- * The view that this image represents in stereo 3D streams.
+ * The view that this image represents.
  * @version 1.6
  */
- View view = View::MONO;
+ View view = View::mono;
 
  /**
  * Get the number of bytes per pixel based on the pixelFormat.

deflect/ReceiveBuffer.cpp

@@ -39,16 +39,15 @@
 
 #include "ReceiveBuffer.h"
 
-#include <array>
 #include <cassert>
 #include <set>
 
 namespace
 {
 const size_t MAX_QUEUE_SIZE = 150; // stream blocked for ~5 seconds at 30Hz
-const auto views = std::array<deflect::View, 3>{{ deflect::View::MONO,
- deflect::View::LEFT_EYE,
- deflect::View::RIGHT_EYE }};
+const auto views = std::array<deflect::View, 3>{{ deflect::View::mono,
+ deflect::View::left_eye,
+ deflect::View::right_eye }};
 }
 
 namespace deflect
@@ -78,7 +77,7 @@ size_t ReceiveBuffer::getSourceCount() const
 }
 
 void ReceiveBuffer::insert( const Segment& segment, const size_t sourceIndex,
- const deflect::View view )
+ const View view )
 {
  assert( _sourceBuffers.count( sourceIndex ));
 
@@ -108,10 +107,11 @@ bool ReceiveBuffer::hasCompleteMonoFrame() const
  assert( !_sourceBuffers.empty( ));
 
  // Check if all sources for Stream have reached the same index
+ const auto lastCompleteFrame = _getLastCompleteFrameIndex( View::mono );
  for( const auto& kv : _sourceBuffers )
  {
  const auto& buffer = kv.second;
- if( buffer.getBackFrameIndex( View::MONO ) <= _lastFrameComplete )
+ if( buffer.getBackFrameIndex( View::mono ) <= lastCompleteFrame )
  return false;
  }
  return true;
@@ -122,12 +122,15 @@ bool ReceiveBuffer::hasCompleteStereoFrame() const
  std::set<size_t> leftSources;
  std::set<size_t> rightSources;
 
+ const auto lastFrameLeft = _getLastCompleteFrameIndex( View::left_eye );
+ const auto lastFrameRight = _getLastCompleteFrameIndex( View::right_eye );
+
  for( const auto& kv : _sourceBuffers )
  {
  const auto& buffer = kv.second;
- if( buffer.getBackFrameIndex( View::LEFT_EYE ) > _lastFrameCompleteLeft )
+ if( buffer.getBackFrameIndex( View::left_eye ) > lastFrameLeft )
  leftSources.insert( kv.first );
- if( buffer.getBackFrameIndex( View::RIGHT_EYE ) > _lastFrameCompleteRight )
+ if( buffer.getBackFrameIndex( View::right_eye ) > lastFrameRight )
  rightSources.insert( kv.first );
  }
 
@@ -168,64 +171,22 @@ Segments ReceiveBuffer::popFrame( const View view )
 
 void ReceiveBuffer::setAllowedToSend( const bool enable, const View view )
 {
- switch( view )
- {
- case View::MONO:
- _allowedToSend = enable;
- break;
- case View::LEFT_EYE:
- _allowedToSendLeft = enable;
- break;
- case View::RIGHT_EYE:
- _allowedToSendRight = enable;
- break;
- };
+ _allowedToSend[as_underlying_type(view)] = enable;
 }
 
 bool ReceiveBuffer::isAllowedToSend( const View view ) const
 {
- switch( view )
- {
- case View::MONO:
- return _allowedToSend;
- case View::LEFT_EYE:
- return _allowedToSendLeft;
- case View::RIGHT_EYE:
- return _allowedToSendRight;
- default:
- throw std::invalid_argument( "no such view" ); // keep compiler happy
- };
+ return _allowedToSend[as_underlying_type(view)];
 }
 
 FrameIndex ReceiveBuffer::_getLastCompleteFrameIndex( const View view ) const
 {
- switch( view )
- {
- case View::MONO:
- return _lastFrameComplete;
- case View::LEFT_EYE:
- return _lastFrameCompleteLeft;
- case View::RIGHT_EYE:
- return _lastFrameCompleteRight;
- default:
- throw std::invalid_argument( "no such view" ); // keep compiler happy
- };
+ return _lastFrameComplete[as_underlying_type(view)];
 }
 
 void ReceiveBuffer::_incrementLastFrameComplete( const View view )
 {
- switch( view )
- {
- case View::MONO:
- ++_lastFrameComplete;
- break;
- case View::LEFT_EYE:
- ++_lastFrameCompleteLeft;
- break;
- case View::RIGHT_EYE:
- ++_lastFrameCompleteRight;
- break;
- };
+ ++_lastFrameComplete[as_underlying_type(view)];
 }
 
 }

deflect/ReceiveBuffer.h

@@ -47,6 +47,7 @@
 
 #include <QSize>
 
+#include <array>
 #include <map>
 
 namespace deflect
@@ -85,7 +86,7 @@ class ReceiveBuffer
  * @param view in which the segment should be inserted
  */
  DEFLECT_API void insert( const Segment& segment, size_t sourceIndex,
- deflect::View view = deflect::View::MONO );
+ View view = View::mono );
 
  /**
  * Call when the source has finished sending segments for the current frame.
@@ -104,7 +105,7 @@ class ReceiveBuffer
  * Get the finished frame.
  * @return A collection of segments that form a frame
  */
- DEFLECT_API Segments popFrame( View view = deflect::View::MONO );
+ DEFLECT_API Segments popFrame( View view = View::mono );
 
  /** Allow this buffer to be used by the next FrameDispatcher::sendLatestFrame */
  DEFLECT_API void setAllowedToSend( bool enable, View view );
@@ -115,13 +116,11 @@ class ReceiveBuffer
 private:
  std::map<size_t, SourceBuffer> _sourceBuffers;
 
- FrameIndex _lastFrameComplete = 0u;
- FrameIndex _lastFrameCompleteLeft = 0u;
- FrameIndex _lastFrameCompleteRight = 0u;
+ /** The current indices of the mono/left/right frame for this source. */
+ std::array<FrameIndex, 3> _lastFrameComplete = { { 0u, 0u, 0u } };
 
- bool _allowedToSend = false;
- bool _allowedToSendLeft = false;
- bool _allowedToSendRight = false;
+ /** Is the mono/left/right channel allowed to send. */
+ std::array<bool, 3> _allowedToSend = { { false, false, false } };
 
  FrameIndex _getLastCompleteFrameIndex( View view ) const;
  void _incrementLastFrameComplete( View view );

deflect/Server.h

@@ -82,10 +82,10 @@ public slots:
  * Request the dispatching of the next frame for a given pixel stream.
  *
  * A receivedFrame() signal will subsequently be emitted for each of the
- * view(s) (MONO or STEREO) for which a frame is or becomes available.
+ * view(s) (mono or stereo) for which a frame is or becomes available.
  *
  * To ensure that the two eye channels remain synchronized, stereo
- * LEFT/RIGHT frames are dispatched together only when both are available.
+ * left/right frames are dispatched together only when both are available.
  *
  * @param uri Identifier for the stream
  */

deflect/ServerWorker.cpp

@@ -61,7 +61,7 @@ ServerWorker::ServerWorker( const int socketDescriptor )
  , _sourceId( socketDescriptor )
  , _clientProtocolVersion( NETWORK_PROTOCOL_VERSION )
  , _registeredToEvents( false )
- , _activeView( View::MONO )
+ , _activeView( View::mono )
 {
  if( !_tcpSocket->setSocketDescriptor( socketDescriptor ))
  {
@@ -257,7 +257,7 @@ void ServerWorker::_handleMessage( const MessageHeader& messageHeader,
  case MESSAGE_TYPE_IMAGE_VIEW:
  {
  const auto view = reinterpret_cast<const View*>( byteArray.data( ));
- if( *view >= deflect::View::MONO && *view <= deflect::View::RIGHT_EYE )
+ if( *view >= View::mono && *view <= View::right_eye )
  _activeView = *view;
  break;
  }