Sound.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <unordered_map>
#include <cstdint>
 
#define WORD_SIZE 2
 
#define SAMPLE_DATATYPE short
 
#include <portaudio.h>
 
 
#include <vector>
#include <string>
 
// This avoids a glitch on archlinux
#ifdef __linux__
#include <cstdint>
#endif
 
namespace small3d {
 
  class Sound {
    
  private:
 
    struct SoundData {
      int channels = 0;
      int rate = 0;
      long samples = 0;
      long size = 0;
      double duration = 0;
      double startTime = 0;
      bool repeat = false;
      unsigned long currentFrame = 0;
      std::vector<char> data;
      bool playingRepeat = false;
 
      template <class Archive>
      void serialize(Archive& archive) {
        archive(channels,
        rate,
        samples,
        size,
        duration,
        startTime,
        repeat,
        currentFrame,
        data,
        playingRepeat
        );
      }
    };
 
    SoundData soundData;
    
#if !defined(__ANDROID__) && !defined(SMALL3D_IOS)
    PaStream *stream;
#elif defined(__ANDROID__)
    oboe::AudioStreamBuilder *streamBuilder;
    oboe::AudioStream *stream;
#elif defined(SMALL3D_IOS)
static ALCdevice *openalDevice;
static ALCcontext *openalContext;
    ALuint openalSource;
    ALuint openalBuffer;
#endif
 
    static bool noOutputDevice;
 
    static unsigned int numInstances;
    
#if !defined(SMALL3D_IOS) && !defined(__ANDROID__)
    static PaDeviceIndex defaultOutput;
    static int audioCallback(const void *inputBuffer, void *outputBuffer,
                 unsigned long framesPerBuffer,
                 const PaStreamCallbackTimeInfo *timeInfo,
                 PaStreamCallbackFlags statusFlags,
                 void *userData);
#elif defined(__ANDROID__)
 
    class AudioCallbackClass : public oboe::AudioStreamDataCallback {
    private:
      SoundData *soundData;
    public:
      AudioCallbackClass(SoundData *soundData) {
        this->soundData = soundData;
      }
      oboe::DataCallbackResult onAudioReady(oboe::AudioStream *audioStream, void *audioData,
                                            int32_t numFrames) {
 
        auto *out = static_cast<SAMPLE_DATATYPE*>(audioData);
 
        if (soundData->currentFrame * SAMPLES_PER_FRAME >= soundData->samples) {
          if (soundData->repeat) {
            soundData->currentFrame = 0;
          }
          else {
            // Always write something to the stream
            memset(out, 0, WORD_SIZE * numFrames * SAMPLES_PER_FRAME * soundData->channels);
            return oboe::DataCallbackResult::Stop;
          }
        }
 
        memcpy(out, &soundData->data.data()[WORD_SIZE * soundData->currentFrame *
                                            SAMPLES_PER_FRAME * soundData->channels],
               WORD_SIZE * numFrames * SAMPLES_PER_FRAME * soundData->channels);
 
        soundData->currentFrame += numFrames;
 
        return oboe::DataCallbackResult::Continue;
      }
    };
 
    AudioCallbackClass audioCallbackObject;
 
#endif
 
    void load(const std::string& soundFilePath);
    void openStream();
 
  public:
    Sound();
 
    explicit Sound(const std::string& soundFilePath);
 
    ~Sound();
 
    void play(const bool repeat=false);
 
    void stop();
 
    void divideVolume(uint32_t divisor);
 
    Sound(const Sound& other);
 
    Sound(const Sound&& other);
 
    Sound& operator=(const Sound& other);
 
    Sound& operator=(const Sound&& other);
 
    void saveBinary(const std::string& binaryFilePath);
    
  };
 
}