HUIO.h

#pragma once
 
#include <Carna/Carna.h>
#include <ostream>
#include <istream>
#include <queue>
#include <cstdint>
 
namespace Carna
{
 
namespace testing
{
 
namespace HUIO
{
 
 
 
// ----------------------------------------------------------------------------------
// Types & Constants
// ----------------------------------------------------------------------------------
 
typedef uint16_t shifted_huv_t;
 
struct buffer_t
{
    unsigned int first : 12;
    unsigned int second : 12;
};
 
const std::streamsize BUFFER_LENGTH = 3;
 
 
 
// ----------------------------------------------------------------------------------
// Writer
// ----------------------------------------------------------------------------------
 
struct Writer
{
 
    Writer( std::ostream& out )
        : out( out )
    {
    }
 
    ~Writer()
    {
        flush();
    }
 
    void write( signed short huv )
    {
        const signed short shifted_huv = huv + 1024;
        buffered_shifted_huv.push( static_cast< shifted_huv_t >( shifted_huv ) );
        if( buffered_shifted_huv.size() % 2 == 0 )
        {
            flush();
        }
    }
 
private:
 
    std::ostream& out;
 
    std::queue< shifted_huv_t > buffered_shifted_huv;
    buffer_t buffer;
 
    void flush()
    {
        if( buffered_shifted_huv.empty() )
        {
            return;
        }
 
        buffer.first = buffered_shifted_huv.front();
        buffered_shifted_huv.pop();
 
        if( buffered_shifted_huv.empty() )
        {
            buffer.second = 0; // padding
        }
        else
        {
            buffer.second = buffered_shifted_huv.front();
            buffered_shifted_huv.pop();
        }
 
        out.write( reinterpret_cast< const char* >( &buffer ), BUFFER_LENGTH );
    }
 
};  // HUIO :: Writer
 
 
 
// ----------------------------------------------------------------------------------
// Reader
// ----------------------------------------------------------------------------------
 
struct Reader
{
 
    Reader( std::istream& in )
        : in( in )
    {
    }
 
    signed short read()
    {
        if( read_values.empty() )
        {
            readAhead();
        }
        const shifted_huv_t shifted_huv = read_values.front();
        read_values.pop();
        const signed short huv = static_cast< signed short >( shifted_huv ) - 1024;
        return huv;
    }
 
private:
 
    std::istream& in;
 
    buffer_t buffer;
    std::queue< shifted_huv_t > read_values;
 
    void readAhead()
    {
        in.read( reinterpret_cast< char* >( &buffer ), BUFFER_LENGTH );
        read_values.push( buffer.first );
        read_values.push( buffer.second );
    }
 
};  // HUIO :: Reader
 
 
 
}  // namespace HUIO
 
}  // namespace testing
 
}  // namespace Carna