streamWriter_test.cpp

Go to the documentation of this file.

 
#include "../../../tests/catch2/catch.hpp"
#include "../../tests/testMacrosINDI.hpp"
 
#include "../streamWriter.hpp"
 
using namespace MagAOX::app;
 
namespace MagAOX
{
namespace app
{
 
//Standard test harness for INDI callbacks
struct streamWriter_test : public streamWriter
{
    streamWriter *m_sw;
 
    streamWriter_test(const std::string & device)
    {
        m_configName = device;
        m_outName = device;
 
        XWCTEST_SETUP_INDI_NEW_PROP(writing);
    }
 
 
};
 
//Test harness for data writing
struct streamWriter_data_test
{
    streamWriter_test *m_sw;
 
    streamWriter_data_test( streamWriter_test *sw )
    {
        m_sw = sw;
    }
 
    std::string rawimageDir()
    {
        return m_sw->m_rawimageDir;
    }
 
    int setup_circbufs( int width, int height, int dataType, int circBuffLength, int writeChunkLength )
    {
        m_sw->m_typeSize = ImageStreamIO_typesize( dataType );
 
        m_sw->m_maxCircBuffLength   = circBuffLength;
        m_sw->m_maxCircBuffSize     = ( width * height * m_sw->m_typeSize * circBuffLength + 1 ) / 1048576.0;
        m_sw->m_maxWriteChunkLength = writeChunkLength;
 
        m_sw->m_width    = width;
        m_sw->m_height   = height;
        m_sw->m_dataType = dataType;
 
        return m_sw->allocate_circbufs();
    }
 
    // Sets m_writeChunkLength and calls allocate_xrif
    // Call this *only* after setup_circbufs.
    int setup_xrif()
    {
 
        m_sw->initialize_xrif();
        return m_sw->allocate_xrif();
    }
 
    // Fill the circular buffers.
    int fill_circbuf_uint16()
    {
        // fill in image data with increasing 256 bit vals.
        for( size_t pp = 0; pp < m_sw->m_circBuffLength; ++pp )
        {
            uint16_t v = pp;
            for( size_t rr = 0; rr < m_sw->m_width; ++rr )
            {
                for( size_t cc = 0; cc < m_sw->m_height; ++cc )
                {
                    ( (uint16_t *)
                          m_sw->m_rawImageCircBuff )[pp * m_sw->m_width * m_sw->m_height + rr * m_sw->m_height + cc] =
                        v;
                    ++v;
                }
            }
 
            // fitsFile<uint16_t> ff;
            // ff.write("cb.fits", m_sw->m_rawImageCircBuff);
 
            // Fill in timing values with unique vals.
            uint64_t *curr_timing = m_sw->m_timingCircBuff + 5 * pp;
            curr_timing[0]        = pp;                                 // image number
            curr_timing[1]        = pp + 1000;                          // atime sec
            curr_timing[2]        = pp + 2000;                          // atime nsec
            curr_timing[3]        = pp + m_sw->m_circBuffLength + 1000; // wtime sec
            curr_timing[4]        = pp + m_sw->m_circBuffLength + 2000; // wtime nsec
        }
        return 0;
    }
 
    int write_frames( int start, // arbitrary.
                      int stop   // should be a m_writeChunkLength boundary
    )
    {
        m_sw->m_rawimageDir = "/tmp";
 
        m_sw->m_currSaveStart       = start;
        m_sw->m_currSaveStop        = stop;
        m_sw->m_currSaveStopFrameNo = stop;
 
        m_sw->m_writing = WRITING;
        return m_sw->doEncode();
    }
 
    // Read the xrif archive back in and compare the results.
    int comp_frames_uint16( size_t start, size_t stop )
    {
 
        std::cout << "Reading: " << m_sw->m_outFilePath << "\n";
 
        xrif_t       xrif;
        xrif_error_t xrv = xrif_new( &xrif );
 
        char header[XRIF_HEADER_SIZE];
 
        FILE  *fp_xrif = fopen( m_sw->m_outFilePath.c_str(), "rb" );
        size_t nr      = fread( header, 1, XRIF_HEADER_SIZE, fp_xrif );
 
        if( nr != XRIF_HEADER_SIZE )
        {
            std::cerr << "Error reading header of " << m_sw->m_outFilePath << "\n";
            fclose( fp_xrif );
            return -1;
        }
 
        uint32_t header_size;
        xrif_read_header( xrif, &header_size, header );
 
        int rv = 0;
        if( xrif_width( xrif ) != m_sw->m_width )
        {
            std::cerr << "width mismatch\n";
            rv = -1;
        }
 
        if( xrif_height( xrif ) != m_sw->m_height )
        {
            std::cerr << "height mismatch\n";
            rv = -1;
        }
 
        if( xrif_depth( xrif ) != 1 )
        {
            std::cerr << "depth mismatch\n";
            rv = -1;
        }
 
        if( xrif_frames( xrif ) != stop - start )
        {
            std::cerr << "frames mismatch\n";
            rv = -1;
        }
 
        xrif_allocate( xrif );
 
        nr = fread( xrif->raw_buffer, 1, xrif->compressed_size, fp_xrif );
 
        if( nr != xrif->compressed_size )
        {
            std::cerr << "error reading compressed image buffer.\n";
            return -1;
        }
 
        xrv = xrif_decode( xrif );
        if( xrv != XRIF_NOERROR )
        {
            std::cerr << "error decoding compressed image buffer. Code: " << xrv << "\n";
            return -1;
        }
 
        size_t badpix = 0;
 
        for( size_t n = 0; n < m_sw->m_width * m_sw->m_height * m_sw->m_typeSize * ( stop - start ); ++n )
        {
            if( m_sw->m_rawImageCircBuff[start * m_sw->m_width * m_sw->m_height * m_sw->m_typeSize + n] !=
                xrif->raw_buffer[n] )
                ++badpix;
        }
 
        if( badpix > 0 )
        {
            std::cerr << "Buffers don't match: " << badpix << " bad pixels.\n";
            return -1;
        }
 
        return rv;
    }
};
} // namespace app
} // namespace MagAOX
 
using namespace MagAOX::app;
 
SCENARIO( "streamWriter INDI Callbacks", "[streamWriter]" )
{
    XWCTEST_INDI_NEW_CALLBACK( streamWriter, writing);
}
 
SCENARIO( "streamWriter Configuration", "[streamWriter]" )
{
    GIVEN( "A default constructed streamWriter" )
    {
        streamWriter_test      sw("testdev");
        streamWriter_data_test sw_test( &sw );
 
        WHEN( "default configurations" )
        {
            REQUIRE( sw_test.rawimageDir() == "" );
        }
    }
}
 
SCENARIO( "streamWriter encoding data", "[streamWriter]" )
{
    GIVEN( "A default constructed streamWriter and a 120x120 uint16 stream" )
    {
        streamWriter_test      sw("testdev");
        streamWriter_data_test sw_test( &sw );
 
        WHEN( "writing full 1st chunk" )
        {
            int circBuffLength   = 10;
            int writeChunkLength = 5;
            REQUIRE( sw_test.setup_circbufs( 120, 120, XRIF_TYPECODE_UINT16, circBuffLength, writeChunkLength ) == 0 );
            REQUIRE( sw_test.setup_xrif() == 0 );
 
            REQUIRE( sw_test.fill_circbuf_uint16() == 0 );
 
            REQUIRE( sw_test.write_frames( 0, 5 ) == 0 );
 
            REQUIRE( sw_test.comp_frames_uint16( 0, 5 ) == 0 );
        }
 
        WHEN( "writing full 2nd chunk" )
        {
            int circBuffLength   = 10;
            int writeChunkLength = 5;
            REQUIRE( sw_test.setup_circbufs( 120, 120, XRIF_TYPECODE_UINT16, circBuffLength, writeChunkLength ) == 0 );
            REQUIRE( sw_test.setup_xrif() == 0 );
            //REQUIRE( sw_test.setup_fname() == 0 );
 
            REQUIRE( sw_test.fill_circbuf_uint16() == 0 );
 
            REQUIRE( sw_test.write_frames( 5, 10 ) == 0 );
 
            REQUIRE( sw_test.comp_frames_uint16( 5, 10 ) == 0 );
        }
 
        WHEN( "writing partial 1st chunk" )
        {
            int circBuffLength   = 10;
            int writeChunkLength = 5;
            REQUIRE( sw_test.setup_circbufs( 120, 120, XRIF_TYPECODE_UINT16, circBuffLength, writeChunkLength ) == 0 );
            REQUIRE( sw_test.setup_xrif() == 0 );
            //REQUIRE( sw_test.setup_fname() == 0 );
 
            REQUIRE( sw_test.fill_circbuf_uint16() == 0 );
 
            REQUIRE( sw_test.write_frames( 2, 5 ) == 0 );
 
            REQUIRE( sw_test.comp_frames_uint16( 2, 5 ) == 0 );
        }
 
        WHEN( "writing partial 2nd chunk" )
        {
            int circBuffLength   = 10;
            int writeChunkLength = 5;
            REQUIRE( sw_test.setup_circbufs( 120, 120, XRIF_TYPECODE_UINT16, circBuffLength, writeChunkLength ) == 0 );
            REQUIRE( sw_test.setup_xrif() == 0 );
            //REQUIRE( sw_test.setup_fname() == 0 );
 
            REQUIRE( sw_test.fill_circbuf_uint16() == 0 );
 
            REQUIRE( sw_test.write_frames( 5, 8 ) == 0 );
 
            REQUIRE( sw_test.comp_frames_uint16( 5, 8 ) == 0 );
        }
    }
}