audio.hpp

Go to the documentation of this file.

#ifndef RAPP_OBJECT_AUDIO
#define RAPP_OBJECT_AUDIO
#include "includes.ihh"
namespace rapp {
namespace object {
class audio
{
public:
    audio(const std::string filepath)
    {
        std::ifstream bytestream(filepath, 
                                 std::ios::in | 
                                 std::ios::binary | 
                                 std::ios::ate);
        if (!bytestream.is_open()) {
            throw std::runtime_error("could not open bytestream for "+filepath);
        }
        else {
            read_bytes(bytestream);
        }
    }

    audio(std::ifstream & bytestream)
    {
        read_bytes(bytestream);
    }

    audio(std::vector<rapp::types::byte> bytearray)
    : bytearray_(bytearray)
    {}

    audio(const audio &) = default;

    std::vector<rapp::types::byte> bytearray() const
    {
        return bytearray_;
    }

    bool operator==(const audio & rhs) const
    {
        return typeid(*this) == typeid(rhs) &&
               (this->bytearray_ == rhs.bytearray_);
    }

    audio & operator=(const audio &) = default;

    bool save(const std::string filepath)
    {
        std::ofstream os(filepath, std::ios::out | std::ofstream::binary);
        if (os.is_open())
        {
            std::copy(bytearray_.begin(), bytearray_.end(), 
                      std::ostreambuf_iterator<rapp::types::byte>(os));
            os.close();
            return true;
        }
        else
            return false;
    }

    virtual std::string audio_source() const
    { return ""; }

    virtual std::string extension() const
    { return ""; }

private:

    // Delete empty constructor    
    audio() = delete;

    // Copy the bytestream into the bytearray
    void read_bytes(std::ifstream & bytestream)
    {
        bytestream.seekg(0, std::ios_base::end);
        std::streampos fileSize = bytestream.tellg();
        bytearray_.resize(fileSize);
        bytestream.seekg(0, std::ios_base::beg);
        bytestream.read(&bytearray_[0], fileSize);
    }

    // Actual bytes of audio file
    std::vector<rapp::types::byte> bytearray_;
};
class ogg : public audio
{
public:

    ogg(const std::string filepath) 
    : audio(filepath){}

    ogg(std::ifstream & bytestream) 
    : audio(bytestream){}

    std::string audio_source() const
    { return "nao_ogg";}

    std::string extension() const
    { return ".ogg";}
};
class nao_single_channel_wav : public audio
{
public:

    nao_single_channel_wav(const std::string filepath)
    : audio (filepath){}

    nao_single_channel_wav(std::ifstream & bytestream)
    : audio (bytestream){}

    std::string audio_source() const
    { return "nao_wav_1_ch"; }

    std::string extension() const
    { return ".wav"; }
};
class nao_quad_channel_wav : public audio
{
public:

    nao_quad_channel_wav(const std::string filepath)
    : audio (filepath){}

    nao_quad_channel_wav(std::ifstream & bytestream)
    : audio (bytestream){}

    std::string audio_source() const
    { return "nao_wav_4_ch";}

    std::string extension() const
    { return ".wav";}
};
class microphone_wav : public audio
{
public:

    microphone_wav(const std::string filepath)
    : audio (filepath){}

    microphone_wav(std::ifstream & bytestream)
    : audio (bytestream){}

    microphone_wav(std::vector<rapp::types::byte> bytearray)
    : audio(bytearray)
    {}

    std::string audio_source() const
    { return "headset";}

    std::string extension() const
    { return ".wav";}
};
}
}
#endif