al_AudioIO.hpp

#ifndef INCLUDE_AL_AUDIO_IO_HPP
#define INCLUDE_AL_AUDIO_IO_HPP
 
/*  Allocore --
        Multimedia / virtual environment application class library
 
        Copyright (C) 2009. AlloSphere Research Group, Media Arts & Technology,
   UCSB. Copyright (C) 2012. The Regents of the University of California. All
   rights reserved.
 
        Redistribution and use in source and binary forms, with or without
        modification, are permitted provided that the following conditions are
   met:
 
                Redistributions of source code must retain the above copyright
   notice, this list of conditions and the following disclaimer.
 
                Redistributions in binary form must reproduce the above
   copyright notice, this list of conditions and the following disclaimer in the
                documentation and/or other materials provided with the
   distribution.
 
                Neither the name of the University of California nor the names
   of its contributors may be used to endorse or promote products derived from
                this software without specific prior written permission.
 
        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
   IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
        IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
   OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
   WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
   OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
   ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
        File description:
        An interface to low-level audio device streams
 
        File author(s):
        Lance Putnam, 2010, putnam.lance@gmail.com
        Andres Cabrera, 2017 mantaraya36@gmail.com
*/
 
#include <functional>
#include <memory>
#include <string>
#include <vector>
 
#include "al/io/al_AudioIOData.hpp"
 
namespace al {
 
typedef void (*audioCallback)(AudioIOData &io);
 
class AudioDevice;
 
class AudioBackend {
public:
  AudioBackend();
 
  ~AudioBackend() {}
 
  bool isOpen() const;
  bool isRunning() const;
  bool error() const;
 
  void printError(const char *text = "") const;
  void printInfo() const;
 
  bool supportsFPS(double fps);
 
  void inDevice(int index);
  void outDevice(int index);
 
  void channels(int num, bool forOutput);
  void setStreamName(std::string name);
 
  int inDeviceChans();
  int outDeviceChans();
  void setInDeviceChans(int num);
  void setOutDeviceChans(int num);
 
  double time();
 
  bool open(int framesPerSecond, unsigned int framesPerBuffer, void *userdata);
  bool close();
 
  bool start(int framesPerSecond, int framesPerBuffer, void *userdata);
  bool stop();
  double cpu();
 
  // Device information
  static AudioDevice defaultInput();
  static AudioDevice defaultOutput();
  static bool deviceIsValid(int num);
  static int deviceMaxInputChannels(int num);
  static int deviceMaxOutputChannels(int num);
  static double devicePreferredSamplingRate(int num);
  static std::string deviceName(int num);
  static int numDevices();
 
protected:
  bool mRunning{false};
  bool mOpen{false};
  std::shared_ptr<void> mBackendData;
};
 
class AudioDevice : public AudioDeviceInfo {
public:
  enum StreamMode {
    INPUT = 1, 
    OUTPUT = 2 
  };
 
  AudioDevice(int deviceNum = -1);
 
  AudioDevice(const std::string &nameKeyword,
              StreamMode stream = StreamMode(INPUT | OUTPUT));
 
  virtual bool valid() const { return mValid; }
  virtual bool hasInput() const {
    return channelsInMax() > 0;
  } 
  virtual bool hasOutput() const {
    return channelsOutMax() > 0;
  } 
 
  virtual void
  print() const; 
 
  static AudioDevice defaultInput();  
  static AudioDevice defaultOutput(); 
  static int numDevices(); 
  static void
  printAll(); 
 
protected:
  void setImpl(int deviceNum);
  static void initDevices();
};
 
inline AudioDevice::StreamMode operator|(const AudioDevice::StreamMode &a,
                                         const AudioDevice::StreamMode &b) {
  return static_cast<AudioDevice::StreamMode>(+a | +b);
}
 
class AudioIO : public AudioIOData {
public:
  AudioIO();
  virtual ~AudioIO();
  void init(void (*callback)(AudioIOData &), void *userData,
            int framesPerBuf = 64, double framesPerSec = 44100.0,
            int outChans = 2, int inChans = 0);
 
  void init(void (*callback)(AudioIOData &), void *userData, AudioDevice &dev,
            int framesPerBuf = 64, double framesPerSec = 44100.0,
            int outChans = 2, int inChans = 0);
 
  void initWithDefaults(void (*callback)(AudioIOData &), void *userData,
                        bool use_out, bool use_in, int framesPerBuffer = 256);
 
  bool open();  
  bool close(); 
  bool start(); 
  bool stop();  
  void processAudio(); 
 
  bool isOpen();    
  bool isRunning(); 
 
  bool autoZeroOut() const { return mAutoZeroOut; }
  int channelsInDevice()
      const; 
  int channelsOutDevice()
      const; 
  bool clipOut() const { return mClipOut; } 
  double cpu() const; 
  bool
  supportsFPS(double fps); 
  bool zeroNANs()
      const; 
 
  void channels(int num, bool forOutput) override;
  void channelsBus(int num) override; 
 
  void setStreamName(std::string name);
 
  void clipOut(bool v); 
  void
  device(const AudioDevice &v); 
  void deviceIn(const AudioDevice &v);  
  void deviceOut(const AudioDevice &v); 
  virtual void
  framesPerSecond(double v) override; 
  virtual void framesPerBuffer(
      unsigned int n) override; 
  void zeroNANs(bool v) {
    mZeroNANs = v;
  } 
 
  void print() const; 
  static const char *errorText(int errNum); 
 
  double time() const;          
  double time(int frame) const; 
 
  AudioIO &append(AudioCallback &v);
  AudioIO &prepend(AudioCallback &v);
  AudioIO &insertBefore(AudioCallback &v, AudioCallback &beforeThis);
  AudioIO &insertAfter(AudioCallback &v, AudioCallback &afterThis);
 
  AudioIO &remove(AudioCallback &v);
 
  using AudioIOData::channelsBus;
  using AudioIOData::channelsIn;
  using AudioIOData::channelsOut;
  using AudioIOData::framesPerBuffer;
  using AudioIOData::framesPerSecond;
 
  audioCallback callback; 
 
private:
  AudioDevice mInDevice, mOutDevice;
  bool mZeroNANs;    // whether to zero NANs
  bool mClipOut;     // whether to clip output between -1 and 1
  bool mAutoZeroOut; // whether to automatically zero output buffers each block
  std::vector<AudioCallback *> mAudioCallbacks;
 
  void reopen(); // reopen stream (restarts stream if needed)
  void resizeBuffer(bool forOutput);
  void operator=(const AudioIO &) = delete; // Disallow copy
 
  std::unique_ptr<AudioBackend> mBackend;
};
 
} // namespace al
 
#endif