DAFFReaderImpl.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.
 *
 *  ------------------------------------------------------------------------------------
 *
 */

#ifndef IW_DAFF_READERIMPL
#define IW_DAFF_READERIMPL

#include <DAFFDefs.h>
#include <DAFFContent.h>
#include <DAFFContentIR.h>
#include <DAFFContentMS.h>
#include <DAFFContentPS.h>
#include <DAFFContentMPS.h>
#include <DAFFContentDFT.h>
#include "DAFFHeader.h"
#include <DAFFProperties.h>
#include <DAFFReader.h>
#include <DAFFSCTransform.h>

class DAFFMetadataImpl;

class DAFFReaderImpl : public DAFFReader, public DAFFProperties, public DAFFContentIR, public DAFFContentMS, public DAFFContentPS, public DAFFContentMPS, public DAFFContentDFT {
public:
    DAFFReaderImpl();
    ~DAFFReaderImpl();

    bool isFileOpened() const;
    int openFile( const std::string& );
    void closeFile();
    std::string getFilename() const;

    int deserialize( char* pDAFFDataBuffer );
    bool isValid() const;

    int getFileFormatVersion() const;
    int getContentType() const;
    DAFFContent* getContent() const;
    const DAFFMetadata* getMetadata() const;
    DAFFProperties* getProperties() const;

    std::string toString() const;   

    // --= Implementation of the interface "DAFFProperties" =--

    int getQuantization() const;
    int getNumberOfChannels() const;
    int getNumberOfRecords() const;
    std::string getChannelLabel(int iChannel) const;

    int getAlphaPoints() const;
    float getAlphaResolution() const;
    float getAlphaStart() const;
    float getAlphaEnd() const;
    float getAlphaSpan() const;
    int getBetaPoints() const;
    float getBetaResolution() const;
    float getBetaStart() const;
    float getBetaEnd() const;
    float getBetaSpan() const;

    void getDefaultOrientation(DAFFOrientationYPR& o) const;
    void setDefaultOrientation();
    void getOrientation(DAFFOrientationYPR& o) const;
    void setOrientation(const DAFFOrientationYPR& o);

    bool coversFullAlphaRange() const;
    bool coversFullBetaRange() const;
    bool coversFullSphere() const;

    // --= Interface "DAFFContent" =--

    DAFFReader* getParent() const;
    const DAFFMetadata* getRecordMetadata(int iRecordIndex) const;
    int getRecordCoords(int iRecordIndex, int iView, float& fAngle1, float& fAngle2) const;
    void getNearestNeighbour(int iView, float fAngle1Deg, float fAngle2Deg, int& iRecordIndex) const;
    void getNearestNeighbour(int iView, float fAngle1Deg, float fAngle2Deg, int& iRecordIndex, bool& bOutOfBounds) const;
    void getCell(int iView, float fAngle1, float fAngle2, DAFFQuad& qIndices) const;
    void transformAnglesD2O(float fAlpha, float fBeta, float& fAzimuth, float& fElevation) const;
    void transformAnglesO2D(float fAzimuth, float fElevation, float& fAlpha, float& fBeta) const;

    // --= Interface "DAFFContentIR" =--

    double getSamplerate() const;
    int getFilterLength() const;
    int getFilterCoeffs(int iRecordIndex, int iChannel, float* pfDest, float fGain=1.0F) const;
    int addFilterCoeffs(int iRecordIndex, int iChannel, float* pfDest, float fGain=1.0F) const;
    int getMinEffectiveFilterOffset() const;
    int getMaxEffectiveFilterLength() const;
    int getEffectiveFilterBounds(int iRecordIndex, int iChannel, int& iOffset, int& iLength) const;
    int getEffectiveFilterCoeffs(int iRecordIndex, int iChannel, float* pfDest, float fGain=1.0F) const;
    int addEffectiveFilterCoeffs(int iRecordIndex, int iChannel, float* pfDest, float fGain=1.0F) const;
    float getOverallPeak(); // no const because of lazy initialization

    // --= Interface "DAFFContentMS" =--

    int getNumFrequencies() const;
    const std::vector<float>& getFrequencies() const;
    float getOverallMagnitudeMaximum() const;
    int getMagnitudes(int iRecordIndex, int iChannel, float* pfData) const;
    int getMagnitude(int iRecordIndex, int iChannel, int iFreqIndex, float& fMag) const;
    
    // --= Interface "DAFFContentPS" =--

    int getPhases(int iRecordIndex, int iChannel, float* pfData) const;
    int getPhase(int iRecordIndex, int iChannel, int iFreqIndex, float& fPhase) const;

    // --= Interface "DAFFContentMPS" =--

    int getCoefficientsMP(int iRecordIndex, int iChannel, float* pfDest) const;
    int getCoefficientsRI(int iRecordIndex, int iChannel, float* pfDest) const;

    // --= Interface "DAFFContentDFT" =--

    int getTransformSize() const;
    int getNumDFTCoeffs() const;
    bool isSymmetric() const;
    double getFrequencyBandwidth() const;
    int getDFTCoeff(int iRecordIndex, int iChannel, int iDFTCoeff, float& fReal, float& fImag) const;
    int getDFTCoeffs(int iRecordIndex, int iChannel, float* pfDest) const;

private:
    bool m_bDAFFObjectValid;                    
    bool m_bDAFFObjectFromFileValid;            
    std::string m_sFilePath;                    
    FILE* m_file;                               
    DAFFFileHeader m_fileHeader;                
    DAFFMainHeader* m_pMainHeader;              
    DAFFFileBlockEntry* m_pFileBlockTable;      
    DAFFFileBlockEntry* m_pRecordDescriptorTable;               
    DAFFFileBlockEntry* m_pDataFileBlock;               
    void* m_pContentHeader;                     
    void* m_pRecordDescriptorBlock;                 
    void* m_pDataBlock;                         
    int m_iRecordChannelDescSize;               

    DAFFContentHeaderIR* m_pContentHeaderIR;    
    DAFFContentHeaderMS* m_pContentHeaderMS;    
    DAFFContentHeaderPS* m_pContentHeaderPS;    
    DAFFContentHeaderMPS* m_pContentHeaderMPS;  
    DAFFContentHeaderDFT* m_pContentHeaderDFT;  
    std::vector< float > m_vfFreqs;             
    
    const DAFFMetadataImpl* m_pEmptyMetadata;   
    std::vector< DAFFMetadataImpl* > m_vpMetadata;  
    DAFFProperties* m_pProperties;              
    bool m_bOverallPeakInitialized;             
    float m_fOverallPeak;                       

    DAFFOrientationYPR m_orientation;           
    DAFFOrientationYPR m_orientationDefault;    

    float m_fAlphaResolution;                   
    float m_fBetaResolution;                    
    DAFFSCTransform m_tTrans;                   


    int loadFileHeader();


    int loadFileBlockTable();


    int loadMainHeader();


    int loadContentHeader();


    int loadRecordDescriptor();


    int loadRecordData();


    int loadMetadata( char* );


    void fixAngleRanges();
    

    /* @return Total number of matching file blocks)
     */
    int getFirstFileBlockByID( int iID, DAFFFileBlockEntry*& pfDest ) const;

    int getFileBlocksByID( int iID, std::vector< DAFFFileBlockEntry* >& vpfDest ) const;

    void* getRecordChannelDescPtr( int iRecord, int iChannel ) const;

    int* getRecordMetadataIndexPtr( int iRecord ) const;

    void tidyup();
};

#endif // IW_DAFF_READERIMPL