AudioFile.h

Go to the documentation of this file.

#ifndef __EO_UTILS_AUDIO_FILE_H__
#define __EO_UTILS_AUDIO_FILE_H__
 
#include <string>
#include <fstream>
#include <map>
#include <sstream>
 
#include "AudioFileResultType.h"
#include "AudioFileInfo.h"
 
namespace EOUtils
{
        enum AudioFileModes
        {
                AUDIO_FILE_READ,
                AUDIO_FILE_WRITE,
                AUDIO_FILE_READ_WRITE
        };
 
        class AudioFile
        {
                public:
                        explicit AudioFile(const std::string& pFilename);
 
                        explicit AudioFile(const std::string& pFilename, AudioFileModes pFileMode);
 
                        AudioFile(const AudioFile& pAudioFile);
 
                        virtual ~AudioFile();
 
                        virtual void setAudioFileInfo(const AudioFileInfo& pAudioFileInfo) = 0;
 
                        virtual AudioFileResultType open(AudioFileModes pOpenMode);
 
                        virtual bool isOpen() const;
 
                        virtual bool hasReadMode() const;
 
                        virtual bool hasWriteMode() const;
 
                        virtual void close();
 
                        virtual AudioFileResultType getNextSample_int64(int64_t& pAudioSample) = 0;
 
                        virtual AudioFileResultType writeSample_int64(int64_t pAudioSample) = 0;
 
                        virtual AudioFileResultType getHighestSampleValue_int64(int64_t& pHighestAudioSample) = 0;
 
                        virtual AudioFileResultType goToAudioDataPos() = 0;
 
                        virtual size_t numSamples() const = 0;
 
                        virtual int64_t maxValueForSampleSize() const = 0;
 
                        const std::string& Filename() const;
 
                        void Filename(const std::string& pFilename);
 
                        void setMetadata(const std::string& pName, const std::string& pValue);
 
                        template<typename T>
                        void setMetadataFromVal(const std::string& pName, const T& pValue)
                        {
                                std::ostringstream oss;
                                oss << pValue;
                                mMetadata[pName] = oss.str();
                        }
 
                        AudioFileResultType getMetadata(const std::string& pName, std::string& pValue) const;
 
                        template<typename T>
                        AudioFileResultType getMetadataAs(const std::string& pName, T& pValue) const
                        {
                                AudioFileResultType result;
                                std::map<std::string, std::string>::const_iterator iterator = mMetadata.find(pName);
                                if (iterator != mMetadata.end())
                                {
                                        std::istringstream iss(iterator->second);
                                        iss >> pValue;
                                }
                                else
                                        result.addError("Audio flie metadata with name " + pName + " was not found");
                                return result;
                        }
 
                        std::string getMetadata(const std::string& pName) const;
 
                        template<typename T>
                        T getMetadataAs(const std::string& pName) const
                        {
                                T value;
                                std::map<std::string, std::string>::const_iterator iterator = mMetadata.find(pName);
                                if (iterator != mMetadata.end())
                                {
                                        std::istringstream iss(iterator->second);
                                        iss >> value;
                                }
                                return value;
                        }
 
                        template<typename T>
                        T getMetadataAs(const std::string& pName, const T& pDefaultVal) const
                        {
                                T value = pDefaultVal;
                                std::map<std::string, std::string>::const_iterator iterator = mMetadata.find(pName);
                                if (iterator != mMetadata.end())
                                {
                                        std::istringstream iss(iterator->second);
                                        iss >> value;
                                }
                                return value;
                        }
 
                        bool hasMetadata(const std::string& pName) const;
 
                        virtual AudioFileInfo getAudioFileInfo() const = 0;
 
                        virtual void seekOutputToSampleNum(size_t pSampleNum) = 0;
 
                protected:
                        std::string mFilename;
                        std::fstream mFileStream;
                        std::ios_base::openmode mFileOpenMode;
                        size_t mDataSizeBytes;
                        std::map<std::string, std::string> mMetadata;
 
                        virtual std::streampos fileSizeAccordingToStream();
 
                        virtual void setFileMode(AudioFileModes pFileMode);
        };
}
 
#endif