BdsDataFileBds.h

Go to the documentation of this file.

/*******************************************************************************
 *  BdsDataFileBds.h    Bds internal data file format
 *              T.Barnaby,  BEAM Ltd,   2008-05-06
 *******************************************************************************
 *
 *  Supported sub-formats:
 *      BDS, BDS-SM BDS Sample Multiplexed
 *      BDS-CM      BDS Channel Multiplexed
 *      BDS-SM-CC   BDS Sample Multiplexed, Canadian Compression
 *
 * A BDS data file contains multiple streams. Each stream, numbered from 0 upwards, contains information blocks or
 *  data blocks for a specic data channel or set of channels if the channel data is sample multiplexed into a block.
 * Data streams are split into segments at time discontinuities when using the getInfo() function..
 * Each segment consists of a set of data blocks and each data block can be for one channel or a number of sample multiplexed channels.
 * The siesmic channel to stream mapping is stored in the Information blocks. An information block is located at the start of the
 *  file and at each append point. You can only append data channels that the files was originally created for (ie. the first setInfo() API call).
 *
 * If the ReadOptionReorder option is used the data segments and blocks are sorted into time order.
 *
 * The file can be appended to. When opened for appending
 */
#ifndef BdsDataFileBds_H
#define BdsDataFileBds_H    1
 
#include <BdsDataFile.h>
#include <BBuffer.h>
 
namespace Bds {
 
enum BdsDataType        { BdsDataTypeBlock = 0x42534442, BdsDataTypeInfo = 0x30534442, BdsDataTypeData = 0x31534442, BdsDataTypeInfoExtra = 0x32534442 };
 
struct BdsDataBlockHeader {
    BUInt32     type;           
    BUInt32     length;         
    BUInt32     packetOffset;       
};
 
struct BdsDataBlock {
    BdsDataBlockHeader  header;
    char            data[4];    
};
 
struct BdsDataPacketHeader {
    BUInt32     type;           
    BUInt32     length;         
    BUInt32     streamlet;      
    BUInt32     sequence;       
    BUInt32     checksum;       
    BTimeStamp  startTime;      
    BTimeStamp  endTime;        
};
 
class BdsDataPacket : public BBufferStore {
public:
            BdsDataPacket();
            ~BdsDataPacket();
 
    void        clear();
    void        reset();
 
    void        setChecksumAndLength();
    BError      validateChecksum();
 
    BError      setHeader(const BdsDataPacketHeader& header);
    BError      getHeader(BdsDataPacketHeader& header);
    
    void        dump();
};
 
class BdsDataBlockPos {
public:
                BdsDataBlockPos(BTimeStamp startTime = 0, BTimeStamp endTime = 0, BUInt32 channel = 0, BUInt32 numChannels = 0, BUInt32 segment = 0, BUInt64 position = 0, BUInt64 numSamples = 0) :
                    startTime(startTime), endTime(endTime), channel(channel), numChannels(numChannels), segment(segment), position(position), numSamples(numSamples){}
    int         operator<(const BdsDataBlockPos& b) const { return startTime < b.startTime; }
 
    BTimeStamp      startTime;
    BTimeStamp      endTime;
    BUInt32         channel;
    BUInt32         numChannels;
    BUInt32         segment;
    BUInt64         position;
    BUInt64         numSamples;
};
 
class BdsDataSegment {
public:
                BdsDataSegment() : numBlocks(0), numSamples(0), sampleRate(0.0){};
    int         operator<(const BdsDataSegment& b) const { return startTime < b.startTime; }
 
    BTimeStamp      startTime;
    BTimeStamp      endTime;
    BUInt32         numBlocks;
    BUInt32         numSamples;
    double          sampleRate;
    BArray<BdsDataBlockPos> blocks;         // The list of blocks in the segment
};
 
class BdsDataStreamlet {
public:
                BdsDataStreamlet() : packetNumber(0), position(0), channel(0), numChannels(0){}
 
    BUInt32         packetNumber;
    BUInt64         position;
    BUInt32         channel;        // The base channel number of data in this streamlet
    BUInt32         numChannels;        // The number of channels of data in this streamlet
    BArray<BdsDataBlockPos> blocks;         // All blocks in this streamlet
    BArray<BdsDataSegment>  segments;       // Segments of data
};
 
 
class DataFileBds : public DataFile {
public:
    enum            { StreamsMax = 256 };
    enum            { DefaultBlockSize = 65536 };
    enum PackFormat     { PackFormat_Unknown = 0, PackFormat_SM = 1, PackFormat_CM = 2, PackFormat_SM_CC = 3 };
    
    // Generic access
                DataFileBds();
                ~DataFileBds();
    
    BError          open(BString fileName, BString mode);                           
    BError          flush();                    
    BError          close();                                        
 
                // Write routines
    BError          setFormat(BString format);                              
    BError          setInfo(const DataInfo& dataInfo, const ChannelInfos& channelInfos, WriteOptionsList options = WriteOptionSensorData);      
    BError          writeData(const DataBlock& data);                               
 
                // Read routines
    DataOrder       getDataOrder();
    BError          getInfo(DataInfo& dataInfo, DataFileOptions options, BList<DataError>& errors);         
    BError          seekBlock(BUInt32 channel, BUInt segment, BTimeStamp time, BUInt32& blockNumber, BUInt64& sampleNumber, DataBlock& dataBlock);  
    BError          readData(BUInt32 channel, BUInt segment, BUInt32 blockNumber, DataBlock& dataBlock);        
 
    static DataFormats  getFormats();                   
 
    BError          setDiskBlockSize(BUInt32 blockSize);                
    BUInt32         getDiskBlockSize();                     
 
    
    // Low Level Packet I/O
    BError          streamletToChannel(BUInt streamlet, BUInt& channel);                    
    BError          setWritePositionForAppend();                                
    BError          setReadPositionToStart();
    BError          packetRead(BdsDataPacket& packet);                          
    BError          packetWrite(BdsDataPacket& packet);                         
 
private:
    void            clear();
 
    // DataBlock exists checks
    BError          dataBlockAdd(BUInt32 streamlet, BTimeStamp startTime, BTimeStamp endTime);
    Bool            dataBlockCheckIfExists(BUInt32 streamlet, BTimeStamp startTime, BTimeStamp endTime);        
    
    // Low level file access
    BError          setInfoRepeat(BUInt32 repeat);                              
    BError          infoSet(BUInt32 streamlet, BTimeStamp startTime, BTimeStamp endTime, BDictString& info);    
    BError          infoGet(BdsDataPacket& packet, BDictString& info);                  
    BError          readInfoPacket();                                   
    BError          addInfoPacket();
    BError          addInfoExtraPacket();
    BError          streamletFromChannel(BUInt channel, BUInt& streamlet);                  
 
    BError          dataAppend(const DataBlock& data);                          
    BError          dataGet(BUInt channel, BdsDataPacket& packet, DataBlock& data);             
 
    // Low level Disk Block access functions
    BError          diskBlockWrite(void* data, BUInt32 numBytes, int header = 0);   
    BError          diskBlockWriteFlush();                      
    BError          diskBlockRead(void* data, BUInt32 numBytes, int header = 0);    
    BError          diskBlockSeek(BUInt64 position);
 
    BString         omode;                  
    BString         oformat;                
    PackFormat      opackFormat;                
    DataInfo        odataInfo;              
    ChannelInfos        ochannelInfos;              
    
    BUInt32         oinfoRepeat;                
    BDictString     oinfo;                  
    BdsDataPacketHeader oinfoHeader;                
 
    // Disk Block access data
    BUInt32         odiskBlockSize;             
    BdsDataBlock*       odiskBlockRead;             
    BUInt64         odiskPositionRead;          
    BdsDataBlock*       odiskBlockWrite;            
    BUInt64         odiskPositionWrite;         
 
    BArray<BdsDataStreamlet>    ostreamlets;            
    BdsDataPacket           opacket;            
};
}
#endif