include/core/audioapi.hpp

   1 #ifndef _audioapi__hpp__included__
   2 #define _audioapi__hpp__included__
   3
   4 #include "library/threads.hpp"
   5
   6 #include <map>
   7 #include <cstdint>
   8 #include <cstdlib>
   9 #include <string>
  10 #include <stdexcept>
  11
  12 class audioapi_instance
  13 {
  14 public:
  15 /**
  16  * Audio API music buffer.
  17  */
  18         struct buffer
  19         {
  20 /**
  21  * The samples.
  22  *
  23  * Note: May be NULL if no samples are available..
  24  */
  25                 int16_t* samples;
  26 /**
  27  * Playback pointer in samples structure.
  28  */
  29                 size_t pointer;
  30 /**
  31  * Total number of samples in this buffer.
  32  */
  33                 size_t total;
  34 /**
  35  * True if buffer is stereo, false if mono.
  36  */
  37                 bool stereo;
  38 /**
  39  * The rate in samples per second the buffer is supposed to be played at.
  40  */
  41                 double rate;
  42         };
  43
  44 /**
  45  * Audio API VU calculator.
  46  */
  47         struct vumeter
  48         {
  49 /**
  50  * Initialize.
  51  */
  52                 vumeter();
  53 /**
  54  * Submit samples.
  55  *
  56  * Parameter samples: The samples to submit. If NULL, reads all samples as 0.
  57  * Parameter count: Number of samples.
  58  * Parameter stereo: If true, read only every other sample (but still read count samples).
  59  * Parameter rate: Sound sampling rate.
  60  * Parameter scale: Value to scale the samples by.
  61  */
  62                 void operator()(float* samples, size_t count, bool stereo, double rate, double scale);
  63 /**
  64  * Get VU value in dB.
  65  */
  66                 operator float() const throw() { return vu; }
  67         private:
  68                 double accumulator;
  69                 size_t samples;
  70                 float vu;
  71                 void update_vu();
  72         };
  73         //Resampler.
  74         class resampler
  75         {
  76         public:
  77                 resampler();
  78                 //After call, either insize or outsize is zero.
  79                 void resample(float*& in, size_t& insize, float*& out, size_t& outsize, double ratio, bool stereo);
  80         private:
  81                 double position;
  82                 double vAl, vBl, vCl, vDl, vAr, vBr, vCr, vDr;
  83         };
  84 /**
  85  * Ctor.
  86  */
  87         audioapi_instance();
  88         ~audioapi_instance();
  89 //The following are intended to be used by the emulator core.
  90 /**
  91  * Submit a buffer for playback on music channel.
  92  *
  93  * Parameter samples: The samples in the buffer. If stereo is true, each sample takes two elements (L, R).
  94  * Parameter count: The number of samples in buffer.
  95  * Parameter stereo: If true, the signal is stereo. If false, mono.
  96  * Parameter rate: Rate of buffer in samples per second.
  97  */
  98         void submit_buffer(int16_t* samples, size_t count, bool stereo, double rate);
  99 /**
 100  * Get the voice channel playback/record rate.
 101  *
 102  * Returns: The rate in samples per second (first for recording, then for playback).
 103  */
 104         std::pair<unsigned,unsigned> voice_rate();
 105 /**
 106  * Get the voice channel nominal playback/record rate.
 107  *
 108  * Returns: The rate in samples per second.
 109  */
 110         unsigned orig_voice_rate();
 111 /**
 112  * Get the voice channel playback status register.
 113  *
 114  * Returns: The number of samples free for playback.
 115  */
 116         unsigned voice_p_status();
 117 /**
 118  * Get the voice channel playback status register2.
 119  *
 120  * Returns: The number of samples in playback buffer.
 121  */
 122         unsigned voice_p_status2();
 123 /**
 124  * Get the voice channel record status register.
 125  *
 126  * Returns: The number of samples in capture buffer.
 127  */
 128         unsigned voice_r_status();
 129 /**
 130  * Play sound on voice channel.
 131  *
 132  * Parameter samples: The samples to play.
 133  * Parameter count: Number of samples to play. Must be less than number of samples free for playback.
 134  */
 135         void play_voice(float* samples, size_t count);
 136 /**
 137  * Capture sound on voice channel.
 138  *
 139  * Parameter samples: The buffer to store captured samples to.
 140  * Parameter count: Number of samples to capture. Must be less than number of samples used for capture.
 141  */
 142         void record_voice(float* samples, size_t count);
 143 /**
 144  * Init the audio. Call on emulator startup.
 145  */
 146         void init();
 147 /**
 148  * Quit the audio. Call on emulator shutdown.
 149  */
 150         void quit();
 151 /**
 152  * Set music volume.
 153  *
 154  * Parameter volume: The volume (0-1).
 155  */
 156         void music_volume(float volume);
 157 /**
 158  * Get music volume.
 159  *
 160  * Returns: The music volume.
 161  */
 162         float music_volume();
 163 /**
 164  * Set voice playback volume.
 165  *
 166  * Parameter volume: The volume (0-1).
 167  */
 168         void voicep_volume(float volume);
 169 /**
 170  * Get voice playback volume.
 171  *
 172  * Returns: The voice playback volume.
 173  */
 174         float voicep_volume();
 175 /**
 176  * Set voice capture volume.
 177  *
 178  * Parameter volume: The volume (0-1).
 179  */
 180         void voicer_volume(float volume);
 181 /**
 182  * Get voice capture volume.
 183  *
 184  * Returns: The voice capture volume.
 185  */
 186         float voicer_volume();
 187
 188 //The following are intended to be used by the driver from the callback
 189 /**
 190  * Get mixed music + voice buffer to play (at voice rate).
 191  *
 192  * Parameter samples: Buffer to store the samples to.
 193  * Parameter count: Number of samples to generate.
 194  * Parameter stereo: If true, return stereo buffer, else mono.
 195  */
 196         void get_mixed(int16_t* samples, size_t count, bool stereo);
 197 /**
 198  * Get music channel buffer to play.
 199  *
 200  * Parameter played: Number of samples to ACK as played.
 201  * Returns: Buffer to play.
 202  *
 203  * Note: This should only be called from the sound driver.
 204  */
 205         struct buffer get_music(size_t played);
 206 /**
 207  * Get voice channel buffer to play.
 208  *
 209  * Parameter samples: The place to store the samples.
 210  * Parameter count: Number of samples to fill.
 211  *
 212  * Note: This should only be called from the sound driver.
 213  */
 214         void get_voice(float* samples, size_t count);
 215 /**
 216  * Put recorded voice channel buffer.
 217  *
 218  * Parameter samples: The samples to send. Can be NULL to send silence.
 219  * Parameter count: Number of samples to send.
 220  *
 221  * Note: Even if audio driver does not support capture, one should send in silence.
 222  * Note: This should only be called from the sound driver.
 223  */
 224         void put_voice(float* samples, size_t count);
 225 /**
 226  * Set the voice channel playback/record rate.
 227  *
 228  * Parameter rate_r: The recording rate in samples per second.
 229  * Parameter rate_p: The playback rate in samples per second.
 230  *
 231  * Note: This should only be called from the sound driver.
 232  * Note: Setting rate to 0 enables dummy callbacks.
 233  */
 234         void voice_rate(unsigned rate_r, unsigned rate_p);
 235 /**
 236  * Suppress all future VU updates.
 237  */
 238         static void disable_vu_updates();
 239         //Vu values.
 240         vumeter vu_mleft;
 241         vumeter vu_mright;
 242         vumeter vu_vout;
 243         vumeter vu_vin;
 244 private:
 245         struct dummy_cb_proc
 246         {
 247                 dummy_cb_proc(audioapi_instance& _parent);
 248                 int operator()();
 249                 audioapi_instance& parent;
 250         };
 251         dummy_cb_proc dummyproc;
 252         threads::thread* dummythread;
 253         //3 music buffers is not enough due to huge blocksizes used by SDL.
 254         const static unsigned MUSIC_BUFFERS = 8;
 255         const static unsigned voicep_bufsize = 65536;
 256         const static unsigned voicer_bufsize = 65536;
 257         const static unsigned music_bufsize = 8192;
 258         float voicep_buffer[voicep_bufsize];
 259         float voicer_buffer[voicer_bufsize];
 260         int16_t music_buffer[MUSIC_BUFFERS * music_bufsize];
 261         volatile bool music_stereo[MUSIC_BUFFERS];
 262         volatile double music_rate[MUSIC_BUFFERS];
 263         volatile size_t music_size[MUSIC_BUFFERS];
 264         unsigned music_ptr;
 265         unsigned last_complete_music_seen;
 266         volatile unsigned last_complete_music;
 267         volatile unsigned voicep_get;
 268         volatile unsigned voicep_put;
 269         volatile unsigned voicer_get;
 270         volatile unsigned voicer_put;
 271         volatile unsigned voice_rate_play;
 272         volatile unsigned orig_voice_rate_play;
 273         volatile unsigned voice_rate_rec;
 274         volatile bool dummy_cb_active_record;
 275         volatile bool dummy_cb_active_play;
 276         volatile bool dummy_cb_quit;
 277         volatile float _music_volume;
 278         volatile float _voicep_volume;
 279         volatile float _voicer_volume;
 280         resampler music_resampler;
 281         bool last_adjust;       //Adjusting consequtively is too hard.
 282         static bool vu_disabled;
 283 };
 284
 285
 286 #endif