diff --git a/CMakeLists.txt b/CMakeLists.txt index 81d4286..b018c23 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,5 +1,5 @@ -# Copyright (c) 2013-2016, EPFL/Blue Brain Project +# Copyright (c) 2013-2017, EPFL/Blue Brain Project # Raphael Dumusc # Daniel Nachbaur diff --git a/apps/SimpleStreamer/main.cpp b/apps/SimpleStreamer/main.cpp index 7022f66..c50e9a1 100644 --- a/apps/SimpleStreamer/main.cpp +++ b/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,7 +295,7 @@ 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 @@ -303,7 +303,7 @@ void display() 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(); diff --git a/deflect/Frame.h b/deflect/Frame.h index 628c9c8..9bbf2d8 100644 --- a/deflect/Frame.h +++ b/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; diff --git a/deflect/FrameDispatcher.cpp b/deflect/FrameDispatcher.cpp index 207a085..c979aff 100644 --- a/deflect/FrameDispatcher.cpp +++ b/deflect/FrameDispatcher.cpp @@ -57,15 +57,15 @@ 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; } @@ -73,25 +73,25 @@ class FrameDispatcher::Impl { 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 )); diff --git a/deflect/FrameDispatcher.h b/deflect/FrameDispatcher.h index caf1f9c..36c69d6 100644 --- a/deflect/FrameDispatcher.h +++ b/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 diff --git a/deflect/ImageWrapper.h b/deflect/ImageWrapper.h index 8a172ed..f2a21fd 100644 --- a/deflect/ImageWrapper.h +++ b/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. diff --git a/deflect/ReceiveBuffer.cpp b/deflect/ReceiveBuffer.cpp index 34261fa..fcb8d62 100644 --- a/deflect/ReceiveBuffer.cpp +++ b/deflect/ReceiveBuffer.cpp @@ -39,16 +39,15 @@ #include "ReceiveBuffer.h" -#include #include #include namespace { const size_t MAX_QUEUE_SIZE = 150; // stream blocked for ~5 seconds at 30Hz -const auto views = std::array{{ deflect::View::MONO, - deflect::View::LEFT_EYE, - deflect::View::RIGHT_EYE }}; +const auto views = std::array{{ 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 leftSources; std::set 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)]; } } diff --git a/deflect/ReceiveBuffer.h b/deflect/ReceiveBuffer.h index efbfad1..e0bee78 100644 --- a/deflect/ReceiveBuffer.h +++ b/deflect/ReceiveBuffer.h @@ -47,6 +47,7 @@ #include +#include #include 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 _sourceBuffers; - FrameIndex _lastFrameComplete = 0u; - FrameIndex _lastFrameCompleteLeft = 0u; - FrameIndex _lastFrameCompleteRight = 0u; + /** The current indices of the mono/left/right frame for this source. */ + std::array _lastFrameComplete = { { 0u, 0u, 0u } }; - bool _allowedToSend = false; - bool _allowedToSendLeft = false; - bool _allowedToSendRight = false; + /** Is the mono/left/right channel allowed to send. */ + std::array _allowedToSend = { { false, false, false } }; FrameIndex _getLastCompleteFrameIndex( View view ) const; void _incrementLastFrameComplete( View view ); diff --git a/deflect/Server.h b/deflect/Server.h index b7e77e2..2f596ea 100644 --- a/deflect/Server.h +++ b/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 */ diff --git a/deflect/ServerWorker.cpp b/deflect/ServerWorker.cpp index 5a09526..a7c86e4 100644 --- a/deflect/ServerWorker.cpp +++ b/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( byteArray.data( )); - if( *view >= deflect::View::MONO && *view <= deflect::View::RIGHT_EYE ) + if( *view >= View::mono && *view <= View::right_eye ) _activeView = *view; break; } diff --git a/deflect/SourceBuffer.cpp b/deflect/SourceBuffer.cpp index 7e89e07..99717b8 100644 --- a/deflect/SourceBuffer.cpp +++ b/deflect/SourceBuffer.cpp @@ -46,9 +46,9 @@ namespace deflect SourceBuffer::SourceBuffer() { - _segmentsMono.push( Segments( )); - _segmentsLeft.push( Segments( )); - _segmentsRight.push( Segments( )); + _getQueue( View::mono ).push( Segments( )); + _getQueue( View::left_eye ).push( Segments( )); + _getQueue( View::right_eye ).push( Segments( )); } const Segments& SourceBuffer::getSegments( const View view ) const @@ -58,17 +58,7 @@ const Segments& SourceBuffer::getSegments( const View view ) const FrameIndex SourceBuffer::getBackFrameIndex( const View view ) const { - switch( view ) - { - case View::MONO: - return _backFrameIndexMono; - case View::LEFT_EYE: - return _backFrameIndexLeft; - case View::RIGHT_EYE: - return _backFrameIndexRight; - default: - throw std::invalid_argument( "no such view" ); // keep compiler happy - }; + return _backFrameIndex[as_underlying_type(view)]; } bool SourceBuffer::isBackFrameEmpty( const View view ) const @@ -84,22 +74,10 @@ void SourceBuffer::pop( const View view ) void SourceBuffer::push( const View view ) { _getQueue( view ).push( Segments( )); - - switch( view ) - { - case View::MONO: - ++_backFrameIndexMono; - break; - case View::LEFT_EYE: - ++_backFrameIndexLeft; - break; - case View::RIGHT_EYE: - ++_backFrameIndexRight; - break; - }; + ++_backFrameIndex[as_underlying_type(view)]; } -void SourceBuffer::insert( const Segment& segment, const deflect::View view ) +void SourceBuffer::insert( const Segment& segment, const View view ) { _getQueue( view ).back().push_back( segment ); } @@ -109,35 +87,15 @@ size_t SourceBuffer::getQueueSize( const View view ) const return _getQueue( view ).size(); } -std::queue& SourceBuffer::_getQueue( const deflect::View view ) +std::queue& SourceBuffer::_getQueue( const View view ) { - switch( view ) - { - case View::MONO: - return _segmentsMono; - case View::LEFT_EYE: - return _segmentsLeft; - case View::RIGHT_EYE: - return _segmentsRight; - default: - throw std::invalid_argument( "no such view" ); // keep compiler happy - }; + return _segments[as_underlying_type(view)]; } const std::queue& -SourceBuffer::_getQueue( const deflect::View view ) const +SourceBuffer::_getQueue( const View view ) const { - switch( view ) - { - case View::MONO: - return _segmentsMono; - case View::LEFT_EYE: - return _segmentsLeft; - case View::RIGHT_EYE: - return _segmentsRight; - default: - throw std::invalid_argument( "no such view" ); // keep compiler happy - }; + return _segments[as_underlying_type(view)]; } } diff --git a/deflect/SourceBuffer.h b/deflect/SourceBuffer.h index 65b9cfd..63c1f69 100644 --- a/deflect/SourceBuffer.h +++ b/deflect/SourceBuffer.h @@ -44,6 +44,7 @@ #include #include +#include #include namespace deflect @@ -70,25 +71,23 @@ class SourceBuffer bool isBackFrameEmpty( View view ) const; /** Insert a segment into the back frame of the appropriate queue. */ - void insert( const Segment& segment, const View view ); + void insert( const Segment& segment, View view ); /** Push a new frame to the back of given view. */ - void push( const View view ); + void push( View view ); /** Pop the front frame of the buffer for the given view. */ - void pop( const View view ); + void pop( View view ); /** @return the size of the queue for the given view. */ - size_t getQueueSize( const View view ) const; + size_t getQueueSize( View view ) const; private: - /** The collections of segments for each view. */ - std::queue _segmentsMono, _segmentsLeft, _segmentsRight; + /** The collections of segments for each mono/left/right view. */ + std::queue _segments[3]; - /** The current indices of the frame for this source. */ - FrameIndex _backFrameIndexMono = 0u; - FrameIndex _backFrameIndexLeft = 0u; - FrameIndex _backFrameIndexRight = 0u; + /** The current indices of the mono/left/right frame for this source. */ + std::array _backFrameIndex = { { 0u, 0u, 0u } }; std::queue& _getQueue( View view ); const std::queue& _getQueue( View view ) const; diff --git a/deflect/StreamPrivate.cpp b/deflect/StreamPrivate.cpp index 8e002b0..85472ea 100644 --- a/deflect/StreamPrivate.cpp +++ b/deflect/StreamPrivate.cpp @@ -141,7 +141,9 @@ bool StreamPrivate::send( const ImageWrapper& image ) return false; } - sendImageView( image.view ); + if( !sendImageView( image.view )) + return false; + const auto sendFunc = std::bind( &StreamPrivate::sendPixelStreamSegment, this, std::placeholders::_1 ); return imageSegmenter.generate( image, sendFunc ); diff --git a/deflect/types.h b/deflect/types.h index 6815997..31bd6d6 100644 --- a/deflect/types.h +++ b/deflect/types.h @@ -50,7 +50,14 @@ namespace deflect { /** The different types of view. */ -enum class View : std::int8_t { MONO, LEFT_EYE, RIGHT_EYE }; +enum class View : std::uint8_t { mono, left_eye, right_eye }; + +/** Cast an enum class value to its underlying type. */ +template +constexpr typename std::underlying_type::type as_underlying_type( E e ) +{ + return static_cast::type>( e ); +} class EventReceiver; class Frame; diff --git a/doc/StereoStreaming.md b/doc/StereoStreaming.md index 3f05095..a2240d2 100644 --- a/doc/StereoStreaming.md +++ b/doc/StereoStreaming.md @@ -16,7 +16,7 @@ This document describes the stereo streaming support introduced in Deflect 0.13. New view enum in deflect/types.h: - enum class View : std::int8_t { MONO, LEFT_EYE, RIGHT_EYE }; + enum class View : std::int8_t { mono, left_eye, right_eye }; On the client side, no changes to the Stream API. The ImageWrapper takes an additional View parameter. @@ -42,13 +42,13 @@ Example of a stereo 3D client application using the blocking Stream API: /** ...render left image... */ deflect::ImageWrapper leftImage( data, width, height, deflect::RGBA ); - leftImage.view = deflect::View::LEFT_EYE; + leftImage.view = deflect::View::left_eye; deflectStream->send( leftImage ); /** ...render right image... */ deflect::ImageWrapper rightImage( data, width, height, deflect::RGBA ); - rightImage.view = deflect::View::RIGHT_EYE; + rightImage.view = deflect::View::right_eye; deflectStream->send( rightImage ); deflectStream->finishFrame(); @@ -76,7 +76,7 @@ Example of a stereo 3D client application using the asynchronous Stream API: /** ...render left image... */ deflect::ImageWrapper leftImage( leftData, width, height, deflect::RGBA ); - leftImage.view = deflect::View::LEFT_EYE; + leftImage.view = deflect::View::left_eye; leftFuture = deflectStream->asyncSend( leftImage ); if( !rightFuture.valid() || !rightFuture.get( )) @@ -85,7 +85,7 @@ Example of a stereo 3D client application using the asynchronous Stream API: /** ...render right image... */ deflect::ImageWrapper rightImage( rightData, width, height, deflect::RGBA ); - rightImage.view = deflect::View::RIGHT_EYE; + rightImage.view = deflect::View::right_eye; rightFuture = deflectStream->send( rightImage ); /** ...synchronize with other render clients (network barrier)... */ diff --git a/tests/cpp/ReceiveBufferTests.cpp b/tests/cpp/ReceiveBufferTests.cpp index bf0bf35..59234da 100644 --- a/tests/cpp/ReceiveBufferTests.cpp +++ b/tests/cpp/ReceiveBufferTests.cpp @@ -79,24 +79,24 @@ BOOST_AUTO_TEST_CASE( TestAllowedToSend ) { deflect::ReceiveBuffer buffer; - BOOST_CHECK( !buffer.isAllowedToSend( deflect::View::MONO )); - BOOST_CHECK( !buffer.isAllowedToSend( deflect::View::LEFT_EYE )); - BOOST_CHECK( !buffer.isAllowedToSend( deflect::View::RIGHT_EYE )); - - buffer.setAllowedToSend( true, deflect::View::MONO ); - BOOST_CHECK( buffer.isAllowedToSend( deflect::View::MONO )); - buffer.setAllowedToSend( false, deflect::View::MONO ); - BOOST_CHECK( !buffer.isAllowedToSend( deflect::View::MONO )); - - buffer.setAllowedToSend( true, deflect::View::LEFT_EYE ); - BOOST_CHECK( buffer.isAllowedToSend( deflect::View::LEFT_EYE )); - buffer.setAllowedToSend( false, deflect::View::LEFT_EYE ); - BOOST_CHECK( !buffer.isAllowedToSend( deflect::View::LEFT_EYE )); - - buffer.setAllowedToSend( true, deflect::View::RIGHT_EYE ); - BOOST_CHECK( buffer.isAllowedToSend( deflect::View::RIGHT_EYE )); - buffer.setAllowedToSend( false, deflect::View::RIGHT_EYE ); - BOOST_CHECK( !buffer.isAllowedToSend( deflect::View::RIGHT_EYE )); + BOOST_CHECK( !buffer.isAllowedToSend( deflect::View::mono )); + BOOST_CHECK( !buffer.isAllowedToSend( deflect::View::left_eye )); + BOOST_CHECK( !buffer.isAllowedToSend( deflect::View::right_eye )); + + buffer.setAllowedToSend( true, deflect::View::mono ); + BOOST_CHECK( buffer.isAllowedToSend( deflect::View::mono )); + buffer.setAllowedToSend( false, deflect::View::mono ); + BOOST_CHECK( !buffer.isAllowedToSend( deflect::View::mono )); + + buffer.setAllowedToSend( true, deflect::View::left_eye ); + BOOST_CHECK( buffer.isAllowedToSend( deflect::View::left_eye )); + buffer.setAllowedToSend( false, deflect::View::left_eye ); + BOOST_CHECK( !buffer.isAllowedToSend( deflect::View::left_eye )); + + buffer.setAllowedToSend( true, deflect::View::right_eye ); + BOOST_CHECK( buffer.isAllowedToSend( deflect::View::right_eye )); + buffer.setAllowedToSend( false, deflect::View::right_eye ); + BOOST_CHECK( !buffer.isAllowedToSend( deflect::View::right_eye )); } BOOST_AUTO_TEST_CASE( TestCompleteAFrame ) @@ -114,14 +114,17 @@ BOOST_AUTO_TEST_CASE( TestCompleteAFrame ) buffer.insert( segment, sourceIndex ); BOOST_CHECK( !buffer.hasCompleteMonoFrame( )); + BOOST_CHECK( !buffer.hasCompleteStereoFrame( )); buffer.finishFrameForSource( sourceIndex ); BOOST_CHECK( buffer.hasCompleteMonoFrame( )); + BOOST_CHECK( !buffer.hasCompleteStereoFrame( )); deflect::Segments segments = buffer.popFrame(); BOOST_CHECK_EQUAL( segments.size(), 1 ); BOOST_CHECK( !buffer.hasCompleteMonoFrame( )); + BOOST_CHECK( !buffer.hasCompleteStereoFrame( )); deflect::Frame frame; frame.segments = segments; @@ -327,11 +330,11 @@ void _insert( deflect::ReceiveBuffer& buffer, const size_t sourceIndex, void _testStereoBuffer( deflect::ReceiveBuffer& buffer ) { - const auto leftSegments = buffer.popFrame( deflect::View::LEFT_EYE ); + const auto leftSegments = buffer.popFrame( deflect::View::left_eye ); BOOST_CHECK_EQUAL( leftSegments.size(), 4 ); BOOST_CHECK( !buffer.hasCompleteStereoFrame( )); - const auto rightSegments = buffer.popFrame( deflect::View::RIGHT_EYE ); + const auto rightSegments = buffer.popFrame( deflect::View::right_eye ); BOOST_CHECK_EQUAL( rightSegments.size(), 4 ); BOOST_CHECK( !buffer.hasCompleteStereoFrame( )); @@ -351,10 +354,10 @@ BOOST_AUTO_TEST_CASE( TestStereoOneSource ) deflect::Segments testSegments = generateTestSegments(); - _insert( buffer, sourceIndex, testSegments, deflect::View::LEFT_EYE ); + _insert( buffer, sourceIndex, testSegments, deflect::View::left_eye ); BOOST_CHECK( !buffer.hasCompleteStereoFrame( )); - _insert( buffer, sourceIndex, testSegments, deflect::View::RIGHT_EYE ); + _insert( buffer, sourceIndex, testSegments, deflect::View::right_eye ); BOOST_CHECK( buffer.hasCompleteStereoFrame( )); _testStereoBuffer( buffer ); @@ -370,11 +373,11 @@ BOOST_AUTO_TEST_CASE( TestStereoSingleFinishFrame ) const deflect::Segments testSegments = generateTestSegments(); for( const auto& segment : testSegments ) - buffer.insert( segment, sourceIndex, deflect::View::LEFT_EYE ); + buffer.insert( segment, sourceIndex, deflect::View::left_eye ); BOOST_CHECK( !buffer.hasCompleteStereoFrame( )); for( const auto& segment : testSegments ) - buffer.insert( segment, sourceIndex, deflect::View::RIGHT_EYE ); + buffer.insert( segment, sourceIndex, deflect::View::right_eye ); BOOST_CHECK( !buffer.hasCompleteStereoFrame( )); buffer.finishFrameForSource( sourceIndex ); @@ -398,14 +401,14 @@ BOOST_AUTO_TEST_CASE( TestStereoTwoSourcesScreenSpaceSplit ) const auto segmentsScreen2 = deflect::Segments{ testSegments[2], testSegments[3] }; - _insert( buffer, sourceIndex1, segmentsScreen1, deflect::View::LEFT_EYE ); + _insert( buffer, sourceIndex1, segmentsScreen1, deflect::View::left_eye ); BOOST_CHECK( !buffer.hasCompleteStereoFrame( )); - _insert( buffer, sourceIndex1, segmentsScreen1, deflect::View::RIGHT_EYE ); + _insert( buffer, sourceIndex1, segmentsScreen1, deflect::View::right_eye ); BOOST_CHECK( !buffer.hasCompleteStereoFrame( )); - _insert( buffer, sourceIndex2, segmentsScreen2, deflect::View::LEFT_EYE ); + _insert( buffer, sourceIndex2, segmentsScreen2, deflect::View::left_eye ); BOOST_CHECK( !buffer.hasCompleteStereoFrame( )); - _insert( buffer, sourceIndex2, segmentsScreen2, deflect::View::RIGHT_EYE ); + _insert( buffer, sourceIndex2, segmentsScreen2, deflect::View::right_eye ); BOOST_CHECK( buffer.hasCompleteStereoFrame( )); _testStereoBuffer( buffer ); @@ -422,9 +425,9 @@ BOOST_AUTO_TEST_CASE( TestStereoTwoSourcesStereoSplit ) const auto testSegments = generateTestSegments(); - _insert( buffer, sourceIndex1, testSegments, deflect::View::LEFT_EYE ); + _insert( buffer, sourceIndex1, testSegments, deflect::View::left_eye ); BOOST_CHECK( !buffer.hasCompleteStereoFrame( )); - _insert( buffer, sourceIndex2, testSegments, deflect::View::RIGHT_EYE ); + _insert( buffer, sourceIndex2, testSegments, deflect::View::right_eye ); BOOST_CHECK( buffer.hasCompleteStereoFrame( )); _testStereoBuffer( buffer ); @@ -449,29 +452,29 @@ BOOST_AUTO_TEST_CASE( TestStereoFourSourcesScreenSpaceAndStereoSplit ) const auto segmentsScreen2 = deflect::Segments{ testSegments[2], testSegments[3] }; - _insert( buffer, sourceIndex1, segmentsScreen1, deflect::View::LEFT_EYE ); + _insert( buffer, sourceIndex1, segmentsScreen1, deflect::View::left_eye ); BOOST_CHECK( !buffer.hasCompleteStereoFrame( )); - _insert( buffer, sourceIndex2, segmentsScreen1, deflect::View::RIGHT_EYE ); + _insert( buffer, sourceIndex2, segmentsScreen1, deflect::View::right_eye ); BOOST_CHECK( !buffer.hasCompleteStereoFrame( )); - _insert( buffer, sourceIndex3, segmentsScreen2, deflect::View::LEFT_EYE ); + _insert( buffer, sourceIndex3, segmentsScreen2, deflect::View::left_eye ); BOOST_CHECK( !buffer.hasCompleteStereoFrame( )); - _insert( buffer, sourceIndex4, segmentsScreen2, deflect::View::RIGHT_EYE ); + _insert( buffer, sourceIndex4, segmentsScreen2, deflect::View::right_eye ); BOOST_CHECK( buffer.hasCompleteStereoFrame( )); _testStereoBuffer( buffer ); // Random insertion order - _insert( buffer, sourceIndex1, segmentsScreen1, deflect::View::LEFT_EYE ); + _insert( buffer, sourceIndex1, segmentsScreen1, deflect::View::left_eye ); BOOST_CHECK( !buffer.hasCompleteStereoFrame( )); - _insert( buffer, sourceIndex3, segmentsScreen2, deflect::View::LEFT_EYE ); + _insert( buffer, sourceIndex3, segmentsScreen2, deflect::View::left_eye ); BOOST_CHECK( !buffer.hasCompleteStereoFrame( )); - _insert( buffer, sourceIndex2, segmentsScreen1, deflect::View::RIGHT_EYE ); + _insert( buffer, sourceIndex2, segmentsScreen1, deflect::View::right_eye ); BOOST_CHECK( !buffer.hasCompleteStereoFrame( )); - _insert( buffer, sourceIndex1, segmentsScreen1, deflect::View::LEFT_EYE ); + _insert( buffer, sourceIndex1, segmentsScreen1, deflect::View::left_eye ); BOOST_CHECK( !buffer.hasCompleteStereoFrame( )); - _insert( buffer, sourceIndex2, segmentsScreen1, deflect::View::RIGHT_EYE ); + _insert( buffer, sourceIndex2, segmentsScreen1, deflect::View::right_eye ); BOOST_CHECK( !buffer.hasCompleteStereoFrame( )); - _insert( buffer, sourceIndex4, segmentsScreen2, deflect::View::RIGHT_EYE ); + _insert( buffer, sourceIndex4, segmentsScreen2, deflect::View::right_eye ); BOOST_CHECK( buffer.hasCompleteStereoFrame( )); _testStereoBuffer( buffer );