DAFFHeader.h

Go to the documentation of this file.

/*
 * -------------------------------------------------------------------------------------
 *
 *  OpenDAFF - A free, open source software package for directional audio data
 *  Copyright 2016 Institute of Technical Acoustics, RWTH Aachen University
 *  OpenDAFF is distributed under the Apache License Version 2.0.
 *
 *  ------------------------------------------------------------------------------------
 *
 */

/*
 *  In this file packaged data structures are defined,
 *  so basically with identical member memory layout as in the DAFF files
 *
 */

#ifndef IW_DAFF_HEADER
#define IW_DAFF_HEADER

#include "Utils.h"

#ifdef _MSC_VER
// No packing attribute on Microsoft Compilers
#define DAFF_PACK_ATTR
#else
// Packing attribute requires for the GCC
#define DAFF_PACK_ATTR __attribute__((__packed__))
// #define HANDLE_PRAGMA_PACK_PUSH_POP // try this with your gcc compiler, if packing errors occur
#endif

/* +---------------------------------------------------+
   |                                                   |
   |   DAFF file block idenfiticators (IDs)            |
   |                                                   |
   +---------------------------------------------------+ */

static const int FILEBLOCK_DAFF1_MAIN_HEADER_ID = 0x0001;

static const int FILEBLOCK_DAFF1_CONTENT_HEADER_ID = 0x0002;

static const int FILEBLOCK_DAFF1_RECORD_DESC_ID = 0x0003;

static const int FILEBLOCK_DAFF1_DATA_ID = 0x0004;

static const int FILEBLOCK_DAFF1_METADATA_ID = 0x0005;


/* +---------------------------------------------------+
   |                                                   |
   |   DAFF file format header                         |
   |                                                   |
   +---------------------------------------------------+ */

struct DAFFFileHeader
{
#pragma pack(push,1)
    uint8_t pcSignature[ 2 ];           
    int32_t iFileFormatVersion;     
    int32_t iNumFileBlocks;         

    // << From here file block entries succeed >>
#pragma pack(pop)

    inline void fixEndianness()
    {
        DAFF::le2se_4byte( &iFileFormatVersion, 1 );
        DAFF::le2se_4byte( &iNumFileBlocks, 1 );
    };
} DAFF_PACK_ATTR;


struct DAFFFileBlockEntry
{
#pragma pack(push,1)
    int32_t iID;            // File block identifier
    uint64_t ui64Offset;    // Start offset of the block within the file
    uint64_t ui64Size;      // Size of the block [Bytes]
#pragma pack(pop)

    inline void fixEndianness()
    {
        DAFF::le2se_4byte( &iID, 1 );
        DAFF::le2se_8byte( &ui64Offset, 1 );
        DAFF::le2se_8byte( &ui64Size, 1 );
    };
} DAFF_PACK_ATTR;

/* +---------------------------------------------------+
   |                                                   |
   |   DAFF file format main header                    |
   |                                                   |
   +---------------------------------------------------+ */

struct DAFFMainHeader
{
#pragma pack(push,1)
    // Common definitions
    int32_t iContentType;           
    int32_t iQuantization;          
    int32_t iNumChannels;           
    int32_t iNumRecords;            
    int32_t iElementsPerRecord;     
    int32_t iMetadataIndex;         

    int32_t iAlphaPoints;           
    float fAlphaStart, fAlphaEnd;   
    int32_t iBetaPoints;            
    float fBetaStart, fBetaEnd;     

    float fOrientYaw;               
    float fOrientPitch;             
    float fOrientRoll;              

#pragma pack(pop)

    inline void fixEndianness()
    {
        DAFF::le2se_4byte( &iContentType, 1 );
        DAFF::le2se_4byte( &iQuantization, 1 );
        DAFF::le2se_4byte( &iNumChannels, 1 );
        DAFF::le2se_4byte( &iNumRecords, 1 );
        DAFF::le2se_4byte( &iElementsPerRecord, 1 );
        DAFF::le2se_4byte( &iMetadataIndex, 1 );

        DAFF::le2se_4byte( &iAlphaPoints, 1 );
        DAFF::le2se_4byte( &fAlphaStart, 1 );
        DAFF::le2se_4byte( &fAlphaEnd, 1 );
        DAFF::le2se_4byte( &iBetaPoints, 1 );
        DAFF::le2se_4byte( &fBetaStart, 1 );
        DAFF::le2se_4byte( &fBetaEnd, 1 );

        DAFF::le2se_4byte( &fOrientYaw, 1 );
        DAFF::le2se_4byte( &fOrientPitch, 1 );
        DAFF::le2se_4byte( &fOrientRoll, 1 );
    };
} DAFF_PACK_ATTR;

struct DAFFContentHeaderIR
{
#pragma pack(push,1)
    float fSamplerate;                  
    int32_t iMinFilterOffset;           
    int32_t iMaxEffectiveFilterLength;  
#pragma pack(pop)

    inline void fixEndianness()
    {
        DAFF::le2se_4byte( &fSamplerate, 1 );
        DAFF::le2se_4byte( &iMinFilterOffset, 1 );
        DAFF::le2se_4byte( &iMaxEffectiveFilterLength, 1 );
    };
} DAFF_PACK_ATTR;

struct DAFFContentHeaderMS
{
#pragma pack(push,1)
    float fMax;             
    int32_t iNumFreqs;      

    // Next: Support frequency values [in Hertz] (float)
#pragma pack(pop)

    inline void fixEndianness()
    {
        DAFF::le2se_4byte( &fMax, 1 );
        DAFF::le2se_4byte( &iNumFreqs, 1 );
    };
} DAFF_PACK_ATTR;

struct DAFFContentHeaderPS
{
#pragma pack(push,1)
    int32_t iNumFreqs;      

#pragma pack(pop)

    inline void fixEndianness()
    {
        DAFF::le2se_4byte( &iNumFreqs, 1 );
    };
} DAFF_PACK_ATTR;

struct DAFFContentHeaderMPS
{
#pragma pack(push,1)
    float fMax;             
    int32_t iNumFreqs;      

#pragma pack(pop)

    inline void fixEndianness()
    {
        DAFF::le2se_4byte( &fMax, 1 );
        DAFF::le2se_4byte( &iNumFreqs, 1 );
    };
} DAFF_PACK_ATTR;

struct DAFFContentHeaderDFT
{
#pragma pack(push,1)
    int32_t iNumDFTCoeffs;      
    int32_t iTransformSize;     
    float fSamplerate;          
    float fMax;                 
#pragma pack(pop)

    inline void fixEndianness()
    {
        DAFF::le2se_4byte( &iNumDFTCoeffs, 1 );
        DAFF::le2se_4byte( &iTransformSize, 1 );
        DAFF::le2se_4byte( &fSamplerate, 1 );
        DAFF::le2se_4byte( &fMax, 1 );
    };
} DAFF_PACK_ATTR;

/* +---------------------------------------------------+
   |                                                   |
   |   DAFF record descriptors                         |
   |                                                   |
   +---------------------------------------------------+ */

// Default record channel descriptor for records with constant size.
// (Used for: MS, PS, MPS and DFT content)
struct DAFFRecordChannelDescDefault
{
#pragma pack(push,1)
    int32_t iMetaDataIndex;     
    uint64_t ui64DataOffset;    
#pragma pack(pop)

    inline void fixEndianness()
    {
        DAFF::le2se_4byte( &iMetaDataIndex, 1 );
        DAFF::le2se_8byte( &ui64DataOffset, 1 );
    };
} DAFF_PACK_ATTR;

struct DAFFRecordChannelDescIR
{
#pragma pack(push,1)
    int32_t iMetaDataIndex;     
    uint64_t ui64DataOffset;    
    int32_t iLeadingZeros;      
    int32_t iElementLength;     
#pragma pack(pop)

    inline void fixEndianness()
    {
        DAFF::le2se_4byte( &iMetaDataIndex, 1 );
        DAFF::le2se_8byte( &ui64DataOffset, 1 );
        DAFF::le2se_4byte( &iLeadingZeros, 1 );
        DAFF::le2se_4byte( &iElementLength, 1 );
    };
} DAFF_PACK_ATTR;

#endif // IW_DAFF_HEADER