TDRFile.hpp

Go to the documentation of this file.

 
#ifndef H_POTTU_TDRFILE
#define H_POTTU_TDRFILE
 
 
#include "ebyedataheader.hpp"
#include "dataitem.hpp"
 
#include "GZFile.hpp"
 
#include <zlib.h>
 
#include <fmt/format.h>
 
#include <string>
#include <cstdint>
#include <vector>
#include <cstdio>
 
 
namespace pottu {
 
    class TDRFile {
    public:
 
    TDRFile( const std::string &path ) : _path(path) {}
 
    void open() {
        if( _f.isOpen() )
        return;
        // Finding first the real file size
        {
        FILE *ftmp = fopen( _path.c_str(), "rb" );
        if( !ftmp ) {
            std::string errmsg = fmt::format( "TDRFile::open(): Couldn't open \'{}\'. Reason: {}",
                              _path, std::strerror(errno) );
            throw std::runtime_error( errmsg );
        }
        off_t p = fseek( ftmp, 0, SEEK_END );
        if( p < 0 ) {
            std::string errmsg( std::strerror(errno) );
            fclose( ftmp );
            throw std::runtime_error( errmsg );
        }
        _filesize = ftell( ftmp );
        fclose( ftmp );
        }
        _f.open( _path, "rb" );
        _gzipped = _f.isZipped();
        _findWordOrderingAndBlocksize();
        _currentblock = 0;
    }
 
    void close() {
        _f.close();
    }
 
 
    size_t readBlock( uint8_t *buf ) {
        /*
        if( !_f.isOpen() )
        throw std::runtime_error( "Cannot read. File is not open." );
        if( _f.isEof() )
        return 0;
        int ret = _f.read( (char *)_blockbuf.data(), _blockbuf.size() );
        if( ret != int(_blockbuf.size()) && ret != 0 )
        throw std::runtime_error( "Immature end of file or failure in reading" );
        else {
        ++_currentblock;
        _lastheader = ebyedataheader_t::createFromMemory( (const char *)_blockbuf.data() );
        if( _lastheader.dataLen )
            std::memcpy( buf, _blockbuf.data()+24, _lastheader.dataLen );
        return _lastheader.dataLen;
        }
        */
        if( !_f.isOpen() )
        throw std::runtime_error( "Cannot read. File is not open." );
        if( _f.isEof() )
        return 0;
        int ret = _f.read( (char *)buf, _blocksize );
        if( ret == 0 && _f.isEof() )
        return 0;
        else if( ret == int(_blocksize) ) {
        ++_currentblock;
        _lastheader = ebyedataheader_t::createFromMemory( (const char *)buf );
        return _lastheader.dataLen;
        } else
        throw std::runtime_error( "Immature end of file or failure in reading" );
    }
    
    const GZFile &getGZFile() const noexcept { return _f; }
 
    bool isOpen() const noexcept { return _f.isOpen(); }
    bool isEof() const noexcept { return _f.isEof(); }
 
    bool isZipped() const noexcept { return _gzipped; }
    bool isWordSwapRequired() const noexcept { return _wordSwapRequired; }
    uint32_t getBlocksize() const noexcept { return _blocksize; }
    int64_t getFilesize() const noexcept { return _filesize; }
 
    const std::string &getPath() const noexcept { return _path; }
 
    const ebyedataheader_t &getLastHeader() const noexcept { return _lastheader; }
    
    private:
 
 
    void _findWordOrderingAndBlocksize() {
        // Assumes that we are at the beginning of the file
        char buf[24];
        int readCount = _f.read( buf, 24 );
        if( readCount != 24 )
        throw std::runtime_error( "Failed to read the header." );       
        ebyedataheader_t header0 = ebyedataheader_t::createFromMemory( buf );
        if( !header0.isValid() ) {
        std::cerr << header0 << "\n";
        throw std::runtime_error( "Header is not valid" );
        }
 
        std::vector<dataitem_t> tmpdata;
        tmpdata.resize( header0.dataLen / 8 ); // Resize to fit all the data in the first block here.
        int bytesToRead = (header0.dataLen / 8) * 8;
        readCount = _f.read( (char *)tmpdata.data(), bytesToRead );
        if( readCount != bytesToRead )
        throw std::runtime_error( "Failed to read the first block of data." );
        
        // Iterating through the data and counting the number of
        // different recordtypes for both non swapped and swapped
        // words.
        unsigned noswap_rectypes[4] = {0};
        unsigned swap_rectypes[4] = {0};
        for( const auto &item : tmpdata ) {
        ++noswap_rectypes[ static_cast<uint32_t>( item.getType() ) ];
        ++swap_rectypes[ static_cast<uint32_t>( item.asSwapped().getType() ) ];
        }
        // The bits 60 & 61 defines the record type and are both
        // zero only for tracedata. The bits 30 & 31 are zero for
        // all items. Therefore, for wrong word order there should
        // be only "tracedata" items in this block. I.e. The
        // correct word ordering is with that one giving more
        // other than tracedata items.
        _wordSwapRequired = swap_rectypes[2] + swap_rectypes[3] > noswap_rectypes[2] + noswap_rectypes[3];
 
        uint32_t testblocksize = 1024;
        while( testblocksize < (1<<20) ) {
        testblocksize *= 2;
        if( testblocksize < header0.dataLen )
            // Blocksize cannot be smaller than the size of the data in first block...
            continue;
        
        _f.seek( testblocksize );
        // Reading the header
        readCount = _f.read( buf, 24 );
        if( readCount != 24 )
            throw std::runtime_error( "Failed to read the header while guessing the blocksize." );
        ebyedataheader_t h = ebyedataheader_t::createFromMemory( buf );
        
        // Did We found the next header?
        if( h.isValid() )
            break;
        }
        if( testblocksize >= (1<<20) )
        throw std::runtime_error( "Failed to find the blocksize." );        
 
        _blocksize = testblocksize;
 
        // Seeking back to beginning
        _f.seek( 0 );
 
        _blockbuf.resize( _blocksize );
    }
    
    
    std::string _path;
    uint32_t    _blocksize{0};
    int64_t     _filesize{-1};
    bool        _gzipped;
    bool        _wordSwapRequired{false};
    GZFile      _f;
    uint32_t    _currentblock{0};
 
    ebyedataheader_t      _lastheader;
    std::vector<uint8_t>  _blockbuf;
    };
 
 
}
 
    
#endif