intial removal of Audio to audio-client

gvr-interface/CMakeLists.txt

@@ -10,9 +10,7 @@ setup_hifi_library(Gui Widgets)
 
 include_glm()
 
-set(REQUIRED_HIFI_LIBRARIES "shared" "networking")
+link_hifi_libraries(shared networking audio-client)
-
-link_hifi_libraries(${REQUIRED_HIFI_LIBRARIES})
 include_dependency_includes()
 
 set(ANDROID_SDK_ROOT $ENV{ANDROID_HOME})

interface/CMakeLists.txt

@@ -2,7 +2,7 @@ set(TARGET_NAME interface)
 project(${TARGET_NAME})
 
 # set a default root dir for each of our optional externals if it was not passed
-set(OPTIONAL_EXTERNALS "Faceshift" "LibOVR" "PrioVR" "Sixense" "LeapMotion" "RtMidi" "Qxmpp" "SDL2" "Gverb" "RSSDK")
+set(OPTIONAL_EXTERNALS "Faceshift" "LibOVR" "PrioVR" "Sixense" "LeapMotion" "RtMidi" "Qxmpp" "SDL2" "RSSDK")
 foreach(EXTERNAL ${OPTIONAL_EXTERNALS})
   string(TOUPPER ${EXTERNAL} ${EXTERNAL}_UPPERCASE)
   if (NOT ${${EXTERNAL}_UPPERCASE}_ROOT_DIR)
@@ -14,10 +14,6 @@ endforeach()
 find_package(Qt5LinguistTools REQUIRED)
 find_package(Qt5LinguistToolsMacros)
 
-
-# As Gverb is currently the only reverb library, it's required.
-find_package(Gverb REQUIRED)
-
 if (DEFINED ENV{JOB_ID})
   set(BUILD_SEQ $ENV{JOB_ID})
 else ()
@@ -108,7 +104,8 @@ endif()
 add_executable(${TARGET_NAME} MACOSX_BUNDLE ${INTERFACE_SRCS} ${QM})
 
 # link required hifi libraries
-link_hifi_libraries(shared octree environment gpu model fbx metavoxels networking entities avatars audio animation script-engine physics 
+link_hifi_libraries(shared octree environment gpu model fbx metavoxels networking entities avatars 
+                    audio audio-client animation script-engine physics 
                     render-utils entities-renderer)
 
 # find any optional and required libraries
@@ -173,13 +170,6 @@ if (QXMPP_FOUND AND NOT DISABLE_QXMPP AND WIN32)
   add_definitions(-DQXMPP_STATIC) 
 endif ()
 
-if (GVERB_FOUND)
-  file(GLOB GVERB_SRCS ${GVERB_SRC_DIRS}/*.c)
-  include_directories(${GVERB_INCLUDE_DIRS})
-  add_library(gverb STATIC ${GVERB_SRCS})
-  target_link_libraries(${TARGET_NAME} gverb)
-endif (GVERB_FOUND)
-
 # include headers for interface and InterfaceConfig.
 include_directories("${PROJECT_SOURCE_DIR}/src" "${PROJECT_BINARY_DIR}/includes")
 

interface/src/Application.cpp

@@ -162,7 +162,7 @@ bool setupEssentials(int& argc, char** argv) {
     auto geometryCache = DependencyManager::set<GeometryCache>();
     auto glowEffect = DependencyManager::set<GlowEffect>();
     auto faceshift = DependencyManager::set<Faceshift>();
-    auto audio = DependencyManager::set<Audio>();
+    auto audio = DependencyManager::set<AudioClient>();
     auto audioScope = DependencyManager::set<AudioScope>();
     auto audioIOStatsRenderer = DependencyManager::set<AudioIOStatsRenderer>();
     auto deferredLightingEffect = DependencyManager::set<DeferredLightingEffect>();
@@ -278,9 +278,9 @@ Application::Application(int& argc, char** argv, QElapsedTimer &startup_time) :
     // put the audio processing on a separate thread
     QThread* audioThread = new QThread(this);
     
-    auto audioIO = DependencyManager::get<Audio>();
+    auto audioIO = DependencyManager::get<AudioClient>();
     audioIO->moveToThread(audioThread);
-    connect(audioThread, &QThread::started, audioIO.data(), &Audio::start);
+    connect(audioThread, &QThread::started, audioIO.data(), &AudioClient::start);
 
     audioThread->start();
     
@@ -476,7 +476,7 @@ Application::~Application() {
     // kill any audio injectors that are still around
     AudioScriptingInterface::getInstance().stopAllInjectors();
     
-    auto audioIO = DependencyManager::get<Audio>();
+    auto audioIO = DependencyManager::get<AudioClient>();
 
     // stop the audio process
     QMetaObject::invokeMethod(audioIO.data(), "stop", Qt::BlockingQueuedConnection);
@@ -2117,7 +2117,7 @@ void Application::update(float deltaTime) {
         if (sinceLastNack > TOO_LONG_SINCE_LAST_SEND_DOWNSTREAM_AUDIO_STATS) {
             _lastSendDownstreamAudioStats = now;
 
-            QMetaObject::invokeMethod(DependencyManager::get<Audio>().data(), "sendDownstreamAudioStatsPacket", Qt::QueuedConnection);
+            QMetaObject::invokeMethod(DependencyManager::get<AudioClient>().data(), "sendDownstreamAudioStatsPacket", Qt::QueuedConnection);
         }
     }
 }
@@ -3113,7 +3113,7 @@ void Application::resetSensors() {
     
     _myAvatar->reset();
 
-    QMetaObject::invokeMethod(DependencyManager::get<Audio>().data(), "reset", Qt::QueuedConnection);
+    QMetaObject::invokeMethod(DependencyManager::get<AudioClient>().data(), "reset", Qt::QueuedConnection);
 }
 
 static void setShortcutsEnabled(QWidget* widget, bool enabled) {
@@ -3253,7 +3253,7 @@ void Application::nodeKilled(SharedNodePointer node) {
     _entityEditSender.nodeKilled(node);
 
     if (node->getType() == NodeType::AudioMixer) {
-        QMetaObject::invokeMethod(DependencyManager::get<Audio>().data(), "audioMixerKilled");
+        QMetaObject::invokeMethod(DependencyManager::get<AudioClient>().data(), "audioMixerKilled");
     }
 
     if (node->getType() == NodeType::EntityServer) {

interface/src/DatagramProcessor.cpp

@@ -54,15 +54,15 @@ void DatagramProcessor::processDatagrams() {
                 case PacketTypeMixedAudio:
                 case PacketTypeSilentAudioFrame: {
                     if (incomingType == PacketTypeAudioStreamStats) {
-                        QMetaObject::invokeMethod(DependencyManager::get<Audio>().data(), "parseAudioStreamStatsPacket",
+                        QMetaObject::invokeMethod(DependencyManager::get<AudioClient>().data(), "parseAudioStreamStatsPacket",
                                                   Qt::QueuedConnection,
                                                   Q_ARG(QByteArray, incomingPacket));
                     } else if (incomingType == PacketTypeAudioEnvironment) {
-                        QMetaObject::invokeMethod(DependencyManager::get<Audio>().data(), "parseAudioEnvironmentData",
+                        QMetaObject::invokeMethod(DependencyManager::get<AudioClient>().data(), "parseAudioEnvironmentData",
                                                   Qt::QueuedConnection,
                                                   Q_ARG(QByteArray, incomingPacket));
                     } else {
-                        QMetaObject::invokeMethod(DependencyManager::get<Audio>().data(), "addReceivedAudioToStream",
+                        QMetaObject::invokeMethod(DependencyManager::get<AudioClient>().data(), "addReceivedAudioToStream",
                                                   Qt::QueuedConnection,
                                                   Q_ARG(QByteArray, incomingPacket));
                     }
@@ -129,7 +129,7 @@ void DatagramProcessor::processDatagrams() {
                 }
                 case PacketTypeNoisyMute:
                 case PacketTypeMuteEnvironment: {
-                    bool mute = !DependencyManager::get<Audio>()->isMuted();
+                    bool mute = !DependencyManager::get<AudioClient>()->isMuted();
                     
                     if (incomingType == PacketTypeMuteEnvironment) {
                         glm::vec3 position;
@@ -144,7 +144,7 @@ void DatagramProcessor::processDatagrams() {
                     }
                     
                     if (mute) {
-                        DependencyManager::get<Audio>()->toggleMute();
+                        DependencyManager::get<AudioClient>()->toggleMute();
                         if (incomingType == PacketTypeMuteEnvironment) {
                             AudioScriptingInterface::getInstance().environmentMuted();
                         } else {

interface/src/Menu.cpp

@@ -490,7 +490,7 @@ Menu::Menu() :
     addCheckableActionToQMenuAndActionHash(timingMenu, MenuOption::PipelineWarnings);
     addCheckableActionToQMenuAndActionHash(timingMenu, MenuOption::SuppressShortTimings);
 
-    auto audioIO = DependencyManager::get<Audio>();
+    auto audioIO = DependencyManager::get<AudioClient>();
     QMenu* audioDebugMenu = developerMenu->addMenu("Audio");
     addCheckableActionToQMenuAndActionHash(audioDebugMenu, MenuOption::AudioNoiseReduction,
                                            0,
@@ -615,7 +615,7 @@ void Menu::loadSettings(QSettings* settings) {
     _receivedAudioStreamSettings._windowSecondsForDesiredReduction = settings->value("windowSecondsForDesiredReduction", DEFAULT_WINDOW_SECONDS_FOR_DESIRED_REDUCTION).toInt();
     _receivedAudioStreamSettings._repetitionWithFade = settings->value("repetitionWithFade", DEFAULT_REPETITION_WITH_FADE).toBool();
 
-    auto audio = DependencyManager::get<Audio>();
+    auto audio = DependencyManager::get<AudioClient>();
     audio->setOutputStarveDetectionEnabled(settings->value("audioOutputStarveDetectionEnabled", DEFAULT_AUDIO_OUTPUT_STARVE_DETECTION_ENABLED).toBool());
     audio->setOutputStarveDetectionThreshold(settings->value("audioOutputStarveDetectionThreshold", DEFAULT_AUDIO_OUTPUT_STARVE_DETECTION_THRESHOLD).toInt());
     audio->setOutputStarveDetectionPeriod(settings->value("audioOutputStarveDetectionPeriod", DEFAULT_AUDIO_OUTPUT_STARVE_DETECTION_PERIOD).toInt());
@@ -680,7 +680,7 @@ void Menu::saveSettings(QSettings* settings) {
     settings->setValue("windowSecondsForDesiredReduction", _receivedAudioStreamSettings._windowSecondsForDesiredReduction);
     settings->setValue("repetitionWithFade", _receivedAudioStreamSettings._repetitionWithFade);
 
-    auto audio = DependencyManager::get<Audio>();
+    auto audio = DependencyManager::get<AudioClient>();
     settings->setValue("audioOutputStarveDetectionEnabled", audio->getOutputStarveDetectionEnabled());
     settings->setValue("audioOutputStarveDetectionThreshold", audio->getOutputStarveDetectionThreshold());
     settings->setValue("audioOutputStarveDetectionPeriod", audio->getOutputStarveDetectionPeriod());
@@ -1297,7 +1297,7 @@ void Menu::toggleToolWindow() {
 void Menu::audioMuteToggled() {
     QAction *muteAction = _actionHash.value(MenuOption::MuteAudio);
     if (muteAction) {
-        muteAction->setChecked(DependencyManager::get<Audio>()->isMuted());
+        muteAction->setChecked(DependencyManager::get<AudioClient>()->isMuted());
     }
 }
 

interface/src/audio/AudioIOStatsRenderer.cpp

@@ -28,7 +28,7 @@ AudioIOStatsRenderer::AudioIOStatsRenderer() :
     _shouldShowInjectedStreams(false)
 {
     // grab the stats object from the audio I/O singleton
-    _stats = &DependencyManager::get<Audio>()->getStats();
+    _stats = &DependencyManager::get<AudioClient>()->getStats();
 }
 
 #ifdef _WIN32

interface/src/audio/AudioScope.cpp

@@ -41,14 +41,14 @@ AudioScope::AudioScope() :
     _outputLeftID(DependencyManager::get<GeometryCache>()->allocateID()),
     _outputRightD(DependencyManager::get<GeometryCache>()->allocateID())
 {
-    auto audioIO = DependencyManager::get<Audio>();
+    auto audioIO = DependencyManager::get<AudioClient>();
     connect(&audioIO->getReceivedAudioStream(), &MixedProcessedAudioStream::addedSilence,
             this, &AudioScope::addStereoSilenceToScope);
     connect(&audioIO->getReceivedAudioStream(), &MixedProcessedAudioStream::addedLastFrameRepeatedWithFade,
             this, &AudioScope::addLastFrameRepeatedWithFadeToScope);
     connect(&audioIO->getReceivedAudioStream(), &MixedProcessedAudioStream::addedStereoSamples,
             this, &AudioScope::addStereoSamplesToScope);
-    connect(audioIO.data(), &Audio::inputReceived, this, &AudioScope::addInputToScope);
+    connect(audioIO.data(), &AudioClient::inputReceived, this, &AudioScope::addInputToScope);
 }
 
 void AudioScope::toggle() {

interface/src/audio/AudioToolBox.cpp

@@ -29,7 +29,7 @@ AudioToolBox::AudioToolBox() :
 
 bool AudioToolBox::mousePressEvent(int x, int y) {
     if (_iconBounds.contains(x, y)) {
-        DependencyManager::get<Audio>()->toggleMute();
+        DependencyManager::get<AudioClient>()->toggleMute();
         return true;
     }
     return false;
@@ -49,7 +49,7 @@ void AudioToolBox::render(int x, int y, bool boxed) {
         _boxTextureId =  glCanvas->bindTexture(QImage(PathUtils::resourcesPath() + "images/audio-box.svg"));
     }
     
-    auto audioIO = DependencyManager::get<Audio>();
+    auto audioIO = DependencyManager::get<AudioClient>();
     
     if (boxed) {
         bool isClipping = ((audioIO->getTimeSinceLastClip() > 0.0f) && (audioIO->getTimeSinceLastClip() < 1.0f));

interface/src/avatar/MyAvatar.cpp

@@ -146,7 +146,7 @@ void MyAvatar::update(float deltaTime) {
     head->relaxLean(deltaTime);
     updateFromTrackers(deltaTime);
     //  Get audio loudness data from audio input device
-    auto audio = DependencyManager::get<Audio>();
+    auto audio = DependencyManager::get<AudioClient>();
     head->setAudioLoudness(audio->getLastInputLoudness());
     head->setAudioAverageLoudness(audio->getAudioAverageInputLoudness());
 
@@ -490,7 +490,7 @@ void MyAvatar::startRecording() {
     if (!_recorder) {
         _recorder = RecorderPointer(new Recorder(this));
     }
-    DependencyManager::get<Audio>()->setRecorder(_recorder);
+    DependencyManager::get<AudioClient>()->setRecorder(_recorder);
     _recorder->startRecording();
     
 }

interface/src/scripting/AudioDeviceScriptingInterface.cpp

@@ -19,13 +19,13 @@ AudioDeviceScriptingInterface* AudioDeviceScriptingInterface::getInstance() {
 }
 
 AudioDeviceScriptingInterface::AudioDeviceScriptingInterface() {
-    connect(DependencyManager::get<Audio>().data(), &Audio::muteToggled,
+    connect(DependencyManager::get<AudioClient>().data(), &AudioClient::muteToggled,
             this, &AudioDeviceScriptingInterface::muteToggled);
 }
 
 bool AudioDeviceScriptingInterface::setInputDevice(const QString& deviceName) {
     bool result;
-    QMetaObject::invokeMethod(DependencyManager::get<Audio>().data(), "switchInputToAudioDevice",
+    QMetaObject::invokeMethod(DependencyManager::get<AudioClient>().data(), "switchInputToAudioDevice",
                               Qt::BlockingQueuedConnection,
                               Q_RETURN_ARG(bool, result),
                               Q_ARG(const QString&, deviceName));
@@ -35,7 +35,7 @@ bool AudioDeviceScriptingInterface::setInputDevice(const QString& deviceName) {
 
 bool AudioDeviceScriptingInterface::setOutputDevice(const QString& deviceName) {
     bool result;
-    QMetaObject::invokeMethod(DependencyManager::get<Audio>().data(), "switchOutputToAudioDevice",
+    QMetaObject::invokeMethod(DependencyManager::get<AudioClient>().data(), "switchOutputToAudioDevice",
                               Qt::BlockingQueuedConnection,
                               Q_RETURN_ARG(bool, result),
                               Q_ARG(const QString&, deviceName));
@@ -44,50 +44,50 @@ bool AudioDeviceScriptingInterface::setOutputDevice(const QString& deviceName) {
 }
 
 QString AudioDeviceScriptingInterface::getInputDevice() {
-    return DependencyManager::get<Audio>()->getDeviceName(QAudio::AudioInput);
+    return DependencyManager::get<AudioClient>()->getDeviceName(QAudio::AudioInput);
 }
 
 QString AudioDeviceScriptingInterface::getOutputDevice() {
-    return DependencyManager::get<Audio>()->getDeviceName(QAudio::AudioOutput);
+    return DependencyManager::get<AudioClient>()->getDeviceName(QAudio::AudioOutput);
 }
 
 QString AudioDeviceScriptingInterface::getDefaultInputDevice() {
-    return DependencyManager::get<Audio>()->getDefaultDeviceName(QAudio::AudioInput);
+    return DependencyManager::get<AudioClient>()->getDefaultDeviceName(QAudio::AudioInput);
 }
 
 QString AudioDeviceScriptingInterface::getDefaultOutputDevice() {
-    return DependencyManager::get<Audio>()->getDefaultDeviceName(QAudio::AudioOutput);
+    return DependencyManager::get<AudioClient>()->getDefaultDeviceName(QAudio::AudioOutput);
 }
 
 QVector<QString> AudioDeviceScriptingInterface::getInputDevices() {
-    return DependencyManager::get<Audio>()->getDeviceNames(QAudio::AudioInput);
+    return DependencyManager::get<AudioClient>()->getDeviceNames(QAudio::AudioInput);
 }
 
 QVector<QString> AudioDeviceScriptingInterface::getOutputDevices() {
-    return DependencyManager::get<Audio>()->getDeviceNames(QAudio::AudioOutput);
+    return DependencyManager::get<AudioClient>()->getDeviceNames(QAudio::AudioOutput);
 }
 
 
 float AudioDeviceScriptingInterface::getInputVolume() {
-    return DependencyManager::get<Audio>()->getInputVolume();
+    return DependencyManager::get<AudioClient>()->getInputVolume();
 }
 
 void AudioDeviceScriptingInterface::setInputVolume(float volume) {
-    DependencyManager::get<Audio>()->setInputVolume(volume);
+    DependencyManager::get<AudioClient>()->setInputVolume(volume);
 }
 
 void AudioDeviceScriptingInterface::setReverb(bool reverb) {
-    DependencyManager::get<Audio>()->setReverb(reverb);
+    DependencyManager::get<AudioClient>()->setReverb(reverb);
 }
 
 void AudioDeviceScriptingInterface::setReverbOptions(const AudioEffectOptions* options) {
-    DependencyManager::get<Audio>()->setReverbOptions(options);
+    DependencyManager::get<AudioClient>()->setReverbOptions(options);
 }
 
 void AudioDeviceScriptingInterface::toggleMute() {
-    DependencyManager::get<Audio>()->toggleMute();
+    DependencyManager::get<AudioClient>()->toggleMute();
 }
 
 bool AudioDeviceScriptingInterface::getMuted() {
-    return DependencyManager::get<Audio>()->isMuted();
+    return DependencyManager::get<AudioClient>()->isMuted();
 }

interface/src/ui/ApplicationOverlay.cpp

@@ -787,7 +787,7 @@ void ApplicationOverlay::renderMagnifier(glm::vec2 magPos, float sizeMult, bool
 
 void ApplicationOverlay::renderAudioMeter() {
     auto glCanvas = DependencyManager::get<GLCanvas>();
-    auto audio = DependencyManager::get<Audio>();
+    auto audio = DependencyManager::get<AudioClient>();
 
     //  Audio VU Meter and Mute Icon
     const int MUTE_ICON_SIZE = 24;

interface/src/ui/PreferencesDialog.cpp

@@ -140,7 +140,7 @@ void PreferencesDialog::loadPreferences() {
     ui.windowSecondsForDesiredReductionSpin->setValue(streamSettings._windowSecondsForDesiredReduction);
     ui.repetitionWithFadeCheckBox->setChecked(streamSettings._repetitionWithFade);
 
-    auto audio = DependencyManager::get<Audio>();
+    auto audio = DependencyManager::get<AudioClient>();
     ui.outputBufferSizeSpinner->setValue(audio->getOutputBufferSize());
 
     ui.outputStarveDetectionCheckBox->setChecked(audio->getOutputStarveDetectionEnabled());
@@ -256,7 +256,7 @@ void PreferencesDialog::savePreferences() {
 
     Menu::getInstance()->setReceivedAudioStreamSettings(streamSettings);
 
-    auto audio = DependencyManager::get<Audio>();
+    auto audio = DependencyManager::get<AudioClient>();
 
     QMetaObject::invokeMethod(audio.data(), "setOutputBufferSize", Q_ARG(int, ui.outputBufferSizeSpinner->value()));
 

libraries/audio-client/CMakeLists.txt

@@ -0,0 +1,21 @@
+set(TARGET_NAME audio-client)
+
+# use setup_hifi_library macro to setup our project and link appropriate Qt modules
+setup_hifi_library(Network)
+
+link_hifi_libraries(audio)
+
+# call macro to include our dependency includes and bubble them up via a property on our target
+include_dependency_includes()
+
+set(GVERB_ROOT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/external/gverb")
+
+# As Gverb is currently the only reverb library, it's required.
+find_package(Gverb REQUIRED)
+
+if (GVERB_FOUND)
+  file(GLOB GVERB_SRCS ${GVERB_SRC_DIRS}/*.c)
+  include_directories(${GVERB_INCLUDE_DIRS})
+  add_library(gverb STATIC ${GVERB_SRCS})
+  target_link_libraries(${TARGET_NAME} gverb)
+endif (GVERB_FOUND)

libraries/audio-client/external/gverb/include/gverb.h

@@ -0,0 +1,234 @@
+/*
+
+        Copyright (C) 1999 Juhana Sadeharju
+                       kouhia at nic.funet.fi
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+    */
+
+#ifndef GVERB_H
+#define GVERB_H
+
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+#include "gverbdsp.h"
+#include "gverb.h"
+#include "ladspa-util.h"
+
+#define FDNORDER 4
+
+typedef struct {
+  int rate;
+  float inputbandwidth;
+  float taillevel;
+  float earlylevel;
+  ty_damper *inputdamper;
+  float maxroomsize;
+  float roomsize;
+  float revtime;
+  float maxdelay;
+  float largestdelay;
+  ty_fixeddelay **fdndels;
+  float *fdngains;
+  int *fdnlens;
+  ty_damper **fdndamps; 
+  float fdndamping;
+  ty_diffuser **ldifs;
+  ty_diffuser **rdifs;
+  ty_fixeddelay *tapdelay;
+  int *taps;
+  float *tapgains;
+  float *d;
+  float *u;
+  float *f;
+  double alpha;
+} ty_gverb;
+
+
+ty_gverb *gverb_new(int, float, float, float, float, float, float, float, float);
+void gverb_free(ty_gverb *);
+void gverb_flush(ty_gverb *);
+static void gverb_do(ty_gverb *, float, float *, float *);
+static void gverb_set_roomsize(ty_gverb *, float);
+static void gverb_set_revtime(ty_gverb *, float);
+static void gverb_set_damping(ty_gverb *, float);
+static void gverb_set_inputbandwidth(ty_gverb *, float);
+static void gverb_set_earlylevel(ty_gverb *, float);
+static void gverb_set_taillevel(ty_gverb *, float);
+
+/*
+ * This FDN reverb can be made smoother by setting matrix elements at the
+ * diagonal and near of it to zero or nearly zero. By setting diagonals to zero
+ * means we remove the effect of the parallel comb structure from the
+ * reverberation.  A comb generates uniform impulse stream to the reverberation
+ * impulse response, and thus it is not good. By setting near diagonal elements
+ * to zero means we remove delay sequences having consequtive delays of the
+ * similar lenths, when the delays are in sorted in length with respect to
+ * matrix element index. The matrix described here could be generated by
+ * differencing Rocchesso's circulant matrix at max diffuse value and at low
+ * diffuse value (approaching parallel combs).
+ *
+ * Example 1:
+ * Set a(k,k), for all k, equal to 0.
+ *
+ * Example 2:
+ * Set a(k,k), a(k,k-1) and a(k,k+1) equal to 0.
+ *
+ * Example 3: The transition to zero gains could be smooth as well.
+ * a(k,k-1) and a(k,k+1) could be 0.3, and a(k,k-2) and a(k,k+2) could
+ * be 0.5, say.
+ */
+
+static __inline void gverb_fdnmatrix(float *a, float *b)
+{
+  const float dl0 = a[0], dl1 = a[1], dl2 = a[2], dl3 = a[3];
+
+  b[0] = 0.5f*(+dl0 + dl1 - dl2 - dl3);
+  b[1] = 0.5f*(+dl0 - dl1 - dl2 + dl3);
+  b[2] = 0.5f*(-dl0 + dl1 - dl2 + dl3);
+  b[3] = 0.5f*(+dl0 + dl1 + dl2 + dl3);
+}
+
+static __inline void gverb_do(ty_gverb *p, float x, float *yl, float *yr)
+{
+  float z;
+  unsigned int i;
+  float lsum,rsum,sum,sign;
+
+    if ((x != x) || fabsf(x) > 100000.0f) {
+    x = 0.0f;
+  }
+
+  z = damper_do(p->inputdamper, x);
+
+  z = diffuser_do(p->ldifs[0],z);
+
+  for(i = 0; i < FDNORDER; i++) {
+    p->u[i] = p->tapgains[i]*fixeddelay_read(p->tapdelay,p->taps[i]);
+  }
+  fixeddelay_write(p->tapdelay,z);
+
+  for(i = 0; i < FDNORDER; i++) {
+    p->d[i] = damper_do(p->fdndamps[i],
+			p->fdngains[i]*fixeddelay_read(p->fdndels[i],
+						       p->fdnlens[i]));
+  }
+
+  sum = 0.0f;
+  sign = 1.0f;
+  for(i = 0; i < FDNORDER; i++) {
+    sum += sign*(p->taillevel*p->d[i] + p->earlylevel*p->u[i]);
+    sign = -sign;
+  }
+  sum += x*p->earlylevel;
+  lsum = sum;
+  rsum = sum;
+
+  gverb_fdnmatrix(p->d,p->f);
+
+  for(i = 0; i < FDNORDER; i++) {
+    fixeddelay_write(p->fdndels[i],p->u[i]+p->f[i]);
+  }
+
+  lsum = diffuser_do(p->ldifs[1],lsum);
+  lsum = diffuser_do(p->ldifs[2],lsum);
+  lsum = diffuser_do(p->ldifs[3],lsum);
+  rsum = diffuser_do(p->rdifs[1],rsum);
+  rsum = diffuser_do(p->rdifs[2],rsum);
+  rsum = diffuser_do(p->rdifs[3],rsum);
+
+  *yl = lsum;
+  *yr = rsum;
+}
+
+static __inline void gverb_set_roomsize(ty_gverb *p, const float a)
+{
+  unsigned int i;
+
+    if (a <= 1.0 || (a != a)) {
+    p->roomsize = 1.0;
+  } else {
+    p->roomsize = a;
+  }
+  p->largestdelay = p->rate * p->roomsize * 0.00294f;
+
+  p->fdnlens[0] = f_round(1.000000f*p->largestdelay);
+  p->fdnlens[1] = f_round(0.816490f*p->largestdelay);
+  p->fdnlens[2] = f_round(0.707100f*p->largestdelay);
+  p->fdnlens[3] = f_round(0.632450f*p->largestdelay);
+  for(i = 0; i < FDNORDER; i++) {
+    p->fdngains[i] = -powf((float)p->alpha, p->fdnlens[i]);
+  }
+
+  p->taps[0] = 5+f_round(0.410f*p->largestdelay);
+  p->taps[1] = 5+f_round(0.300f*p->largestdelay);
+  p->taps[2] = 5+f_round(0.155f*p->largestdelay);
+  p->taps[3] = 5+f_round(0.000f*p->largestdelay);
+
+  for(i = 0; i < FDNORDER; i++) {
+    p->tapgains[i] = powf((float)p->alpha, p->taps[i]);
+  }
+
+}
+
+static __inline void gverb_set_revtime(ty_gverb *p,float a)
+{
+  float ga,gt;
+  double n;
+  unsigned int i;
+
+  p->revtime = a;
+
+  ga = 60.0;
+  gt = p->revtime;
+  ga = powf(10.0f,-ga/20.0f);
+  n = p->rate*gt;
+  p->alpha = (double)powf(ga,1.0f/n);
+
+  for(i = 0; i < FDNORDER; i++) {
+    p->fdngains[i] = -powf((float)p->alpha, p->fdnlens[i]);
+  }
+
+}
+
+static __inline void gverb_set_damping(ty_gverb *p,float a)
+{
+  unsigned int i;
+
+  p->fdndamping = a;
+  for(i = 0; i < FDNORDER; i++) {
+    damper_set(p->fdndamps[i],p->fdndamping);
+  }
+}
+
+static __inline void gverb_set_inputbandwidth(ty_gverb *p,float a)
+{
+  p->inputbandwidth = a;
+  damper_set(p->inputdamper,1.0 - p->inputbandwidth);
+}
+
+static __inline void gverb_set_earlylevel(ty_gverb *p,float a)
+{
+  p->earlylevel = a;
+}
+
+static __inline void gverb_set_taillevel(ty_gverb *p,float a)
+{
+  p->taillevel = a;
+}
+
+#endif

libraries/audio-client/external/gverb/include/gverbdsp.h

@@ -0,0 +1,85 @@
+
+#ifndef GVERBDSP_H
+#define GVERBDSP_H
+
+#include "ladspa-util.h"
+
+typedef struct {
+  int size;
+  int idx;
+  float *buf;
+} ty_fixeddelay;
+
+typedef struct {
+  int size;
+  float coeff;
+  int idx;
+  float *buf;
+} ty_diffuser;
+
+typedef struct {
+  float damping;
+  float delay;
+} ty_damper;
+
+ty_diffuser *diffuser_make(int, float);
+void diffuser_free(ty_diffuser *);
+void diffuser_flush(ty_diffuser *);
+//float diffuser_do(ty_diffuser *, float);
+
+ty_damper *damper_make(float);
+void damper_free(ty_damper *);
+void damper_flush(ty_damper *);
+//void damper_set(ty_damper *, float);
+//float damper_do(ty_damper *, float);
+
+ty_fixeddelay *fixeddelay_make(int);
+void fixeddelay_free(ty_fixeddelay *);
+void fixeddelay_flush(ty_fixeddelay *);
+//float fixeddelay_read(ty_fixeddelay *, int);
+//void fixeddelay_write(ty_fixeddelay *, float);
+
+int isprime(int);
+int nearest_prime(int, float);
+
+static __inline float diffuser_do(ty_diffuser *p, float x)
+{
+  float y,w;
+
+  w = x - p->buf[p->idx]*p->coeff;
+  w = flush_to_zero(w);
+  y = p->buf[p->idx] + w*p->coeff;
+  p->buf[p->idx] = w;
+  p->idx = (p->idx + 1) % p->size;
+  return(y);
+}
+
+static __inline float fixeddelay_read(ty_fixeddelay *p, int n)
+{
+  int i;
+
+  i = (p->idx - n + p->size) % p->size;
+  return(p->buf[i]);
+}
+
+static __inline void fixeddelay_write(ty_fixeddelay *p, float x)
+{
+  p->buf[p->idx] = x;
+  p->idx = (p->idx + 1) % p->size;
+}
+
+static __inline void damper_set(ty_damper *p, float damping)
+{ 
+  p->damping = damping;
+} 
+  
+static __inline float damper_do(ty_damper *p, float x)
+{ 
+  float y;
+    
+  y = x*(1.0-p->damping) + p->delay*p->damping;
+  p->delay = y;
+  return(y);
+}
+
+#endif

libraries/audio-client/external/gverb/include/ladspa-util.h

@@ -0,0 +1,234 @@
+/* Some misc util functions for audio DSP work, written by Steve Harris,
+ * December 2000
+ *
+ *  steve@plugin.org.uk
+ */
+
+#ifndef LADSPA_UTIL_H
+#define LADSPA_UTIL_H
+
+#include <math.h>
+#include <stdint.h>
+#include <string.h>
+
+#define buffer_write(a, b) a=(b)
+
+// 16.16 fixpoint
+typedef union {
+	int32_t all;
+	struct {
+#ifdef WORDS_BIGENDIAN
+		int16_t in;
+		uint16_t fr;
+#else
+		uint16_t fr;
+		int16_t in;
+#endif
+	} part;
+} fixp16;
+
+// 32.32 fixpoint
+typedef union {
+	int64_t all;
+	struct {
+#ifdef WORDS_BIGENDIAN
+		int32_t in;
+		uint32_t fr;
+#else
+		uint32_t fr;
+		int32_t in;
+#endif
+	} part;
+} fixp32;
+
+/* 32 bit "pointer cast" union */
+typedef union {
+        float f;
+        int32_t i;
+} ls_pcast32;
+
+// Sometimes it doesn't get defined, even though it eists and C99 is declared
+long int lrintf (float x);
+
+// 1.0 / ln(2)
+#define LN2R 1.442695041f
+
+/* detet floating point denormal numbers by comparing them to the smallest
+ * normal, crap, but reliable */
+#define DN_CHECK(x, l) if (fabs(x) < 1e-38) printf("DN: " l"\n")
+
+// Denormalise floats, only actually needed for PIII and recent PowerPC
+//#define FLUSH_TO_ZERO(fv) (((*(unsigned int*)&(fv))&0x7f800000)==0)?0.0f:(fv)
+
+static __inline float flush_to_zero(float f)
+{
+	ls_pcast32 v;
+
+	v.f = f;
+
+	// original: return (v.i & 0x7f800000) == 0 ? 0.0f : f;
+	// version from Tim Blechmann
+	return (v.i & 0x7f800000) < 0x08000000 ? 0.0f : f;
+}
+
+static __inline void round_to_zero(volatile float *f)
+{
+	*f += 1e-18;
+	*f -= 1e-18;
+}
+
+/* A set of branchless clipping operations from Laurent de Soras */
+
+static __inline float f_max(float x, float a)
+{
+	x -= a;
+	x += fabs(x);
+	x *= 0.5;
+	x += a;
+
+	return x;
+}
+
+static __inline float f_min(float x, float b)
+{
+	x = b - x;
+	x += fabs(x);
+	x *= 0.5;
+	x = b - x;
+
+	return x;
+}
+
+static __inline float f_clamp(float x, float a, float b)
+{
+	const float x1 = fabs(x - a);
+	const float x2 = fabs(x - b);
+
+	x = x1 + a + b;
+	x -= x2;
+	x *= 0.5;
+
+	return x;
+}
+
+// Limit a value to be l<=v<=u
+#define LIMIT(v,l,u) ((v)<(l)?(l):((v)>(u)?(u):(v)))
+
+// Truncate-to-zero modulo (ANSI C doesn't specify) will only work
+// if -m < v < 2m
+#define MOD(v,m) (v<0?v+m:(v>=m?v-m:v))
+
+// Truncate-to-zero modulo (ANSI C doesn't specify) will only work
+// if v > -m and v < m
+#define NEG_MOD(v,m) ((v)<0?((v)+(m)):(v))
+
+// Convert a value in dB's to a coefficent
+#define DB_CO(g) ((g) > -90.0f ? powf(10.0f, (g) * 0.05f) : 0.0f)
+#define CO_DB(v) (20.0f * log10f(v))
+
+// Linearly interpolate [ = a * (1 - f) + b * f]
+#define LIN_INTERP(f,a,b) ((a) + (f) * ((b) - (a)))
+
+// Cubic interpolation function
+static __inline float cube_interp(const float fr, const float inm1, const float
+                                in, const float inp1, const float inp2)
+{
+	return in + 0.5f * fr * (inp1 - inm1 +
+	 fr * (4.0f * inp1 + 2.0f * inm1 - 5.0f * in - inp2 +
+	 fr * (3.0f * (in - inp1) - inm1 + inp2)));
+}
+
+/* fast sin^2 aproxiamtion, adapted from jan AT rpgfan's posting to the
+ * music-dsp list */
+static __inline float f_sin_sq(float angle)
+{
+	const float asqr = angle * angle;
+	float result = -2.39e-08f;
+
+	result *= asqr;
+	result += 2.7526e-06f;
+	result *= asqr;
+	result -= 1.98409e-04f;
+	result *= asqr;
+	result += 8.3333315e-03f;
+	result *= asqr;
+	result -= 1.666666664e-01f;
+	result *= asqr;
+	result += 1.0f;
+	result *= angle;
+
+	return result * result;
+}
+
+#ifdef HAVE_LRINTF
+
+#define f_round(f) lrintf(f)
+
+#else
+
+// Round float to int using IEEE int* hack
+static __inline int f_round(float f)
+{
+	ls_pcast32 p;
+
+	p.f = f;
+	p.f += (3<<22);
+
+	return p.i - 0x4b400000;
+}
+
+#endif
+
+// Truncate float to int
+static __inline int f_trunc(float f)
+{
+	return f_round(floorf(f));
+}
+
+/* Andrew Simper's pow(2, x) aproximation from the music-dsp list */
+
+#if 0
+
+/* original */
+static __inline float f_pow2(float x)
+{
+	long *px = (long*)(&x); // store address of float as long pointer
+	const float tx = (x-0.5f) + (3<<22); // temporary value for truncation
+	const long  lx = *((long*)&tx) - 0x4b400000; // integer power of 2
+	const float dx = x-(float)(lx); // float remainder of power of 2
+
+	x = 1.0f + dx*(0.6960656421638072f + // cubic apporoximation of 2^x
+                   dx*(0.224494337302845f +  // for x in the range [0, 1]
+                   dx*(0.07944023841053369f)));
+	*px += (lx<<23); // add integer power of 2 to exponent
+
+	return x;
+}
+
+#else
+
+/* union version */
+static __inline float f_pow2(float x)
+{
+	ls_pcast32 *px, tx, lx;
+	float dx;
+
+	px = (ls_pcast32 *)&x; // store address of float as long pointer
+	tx.f = (x-0.5f) + (3<<22); // temporary value for truncation
+	lx.i = tx.i - 0x4b400000; // integer power of 2
+	dx = x - (float)lx.i; // float remainder of power of 2
+
+	x = 1.0f + dx * (0.6960656421638072f + // cubic apporoximation of 2^x
+		   dx * (0.224494337302845f +  // for x in the range [0, 1]
+		   dx * (0.07944023841053369f)));
+	(*px).i += (lx.i << 23); // add integer power of 2 to exponent
+
+	return (*px).f;
+}
+
+#endif
+
+/* Fast exponentiation function, y = e^x */
+#define f_exp(x) f_pow2(x * LN2R)
+
+#endif

libraries/audio-client/external/gverb/readme.txt

@@ -0,0 +1,14 @@
+Instructions for adding the Gverb library to Interface
+(This is a required library)
+Clément Brisset, October 22nd, 2014
+
+1. Go to https://github.com/highfidelity/gverb
+   Or download the sources directly via this link: 
+   https://github.com/highfidelity/gverb/archive/master.zip
+
+2. Extract the archive
+
+3. Place the directories “include” and “src” in libraries/audio-client/external/gverb 
+   (Normally next to this readme)
+
+4. Clear your build directory, run cmake, build and you should be all set.

libraries/audio-client/external/gverb/src/gverb.c

@@ -0,0 +1,207 @@
+/*
+
+        Copyright (C) 1999 Juhana Sadeharju
+                       kouhia at nic.funet.fi
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+    */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+#include "gverbdsp.h"
+#include "gverb.h"
+#include "../include/ladspa-util.h"
+
+ty_gverb *gverb_new(int srate, float maxroomsize, float roomsize,
+		    float revtime,
+		    float damping, float spread,
+		    float inputbandwidth, float earlylevel,
+		    float taillevel)
+{
+  ty_gverb *p;
+  float ga,gb,gt;
+  int i,n;
+  float r;
+  float diffscale;
+  int a,b,c,cc,d,dd,e;
+  float spread1,spread2;
+
+  p = (ty_gverb *)malloc(sizeof(ty_gverb));
+  p->rate = srate;
+  p->fdndamping = damping;
+  p->maxroomsize = maxroomsize;
+  p->roomsize = roomsize;
+  p->revtime = revtime;
+  p->earlylevel = earlylevel;
+  p->taillevel = taillevel;
+
+  p->maxdelay = p->rate*p->maxroomsize/340.0;
+  p->largestdelay = p->rate*p->roomsize/340.0;
+
+
+  /* Input damper */
+
+  p->inputbandwidth = inputbandwidth;
+  p->inputdamper = damper_make(1.0 - p->inputbandwidth);
+
+
+  /* FDN section */
+
+
+  p->fdndels = (ty_fixeddelay **)calloc(FDNORDER, sizeof(ty_fixeddelay *));
+  for(i = 0; i < FDNORDER; i++) {
+    p->fdndels[i] = fixeddelay_make((int)p->maxdelay+1000);
+  }
+  p->fdngains = (float *)calloc(FDNORDER, sizeof(float));
+  p->fdnlens = (int *)calloc(FDNORDER, sizeof(int));
+
+  p->fdndamps = (ty_damper **)calloc(FDNORDER, sizeof(ty_damper *));
+  for(i = 0; i < FDNORDER; i++) {
+    p->fdndamps[i] = damper_make(p->fdndamping);
+  }
+
+  ga = 60.0;
+  gt = p->revtime;
+  ga = powf(10.0f,-ga/20.0f);
+  n = p->rate*gt;
+  p->alpha = pow((double)ga, 1.0/(double)n);
+
+  gb = 0.0;
+  for(i = 0; i < FDNORDER; i++) {
+    if (i == 0) gb = 1.000000*p->largestdelay;
+    if (i == 1) gb = 0.816490*p->largestdelay;
+    if (i == 2) gb = 0.707100*p->largestdelay;
+    if (i == 3) gb = 0.632450*p->largestdelay;
+
+#if 0
+    p->fdnlens[i] = nearest_prime((int)gb, 0.5);
+#else
+    p->fdnlens[i] = f_round(gb);
+#endif
+    p->fdngains[i] = -powf((float)p->alpha,p->fdnlens[i]);
+  }
+
+  p->d = (float *)calloc(FDNORDER, sizeof(float));
+  p->u = (float *)calloc(FDNORDER, sizeof(float));
+  p->f = (float *)calloc(FDNORDER, sizeof(float));
+
+  /* Diffuser section */
+
+  diffscale = (float)p->fdnlens[3]/(210+159+562+410);
+  spread1 = spread;
+  spread2 = 3.0*spread;
+
+  b = 210;
+  r = 0.125541;
+  a = spread1*r;
+  c = 210+159+a;
+  cc = c-b;
+  r = 0.854046;
+  a = spread2*r;
+  d = 210+159+562+a;
+  dd = d-c;
+  e = 1341-d;
+
+  p->ldifs = (ty_diffuser **)calloc(4, sizeof(ty_diffuser *));
+  p->ldifs[0] = diffuser_make((int)(diffscale*b),0.75);
+  p->ldifs[1] = diffuser_make((int)(diffscale*cc),0.75);
+  p->ldifs[2] = diffuser_make((int)(diffscale*dd),0.625);
+  p->ldifs[3] = diffuser_make((int)(diffscale*e),0.625);
+
+  b = 210;
+  r = -0.568366;
+  a = spread1*r;
+  c = 210+159+a;
+  cc = c-b;
+  r = -0.126815;
+  a = spread2*r;
+  d = 210+159+562+a;
+  dd = d-c;
+  e = 1341-d;
+
+  p->rdifs = (ty_diffuser **)calloc(4, sizeof(ty_diffuser *));
+  p->rdifs[0] = diffuser_make((int)(diffscale*b),0.75);
+  p->rdifs[1] = diffuser_make((int)(diffscale*cc),0.75);
+  p->rdifs[2] = diffuser_make((int)(diffscale*dd),0.625);
+  p->rdifs[3] = diffuser_make((int)(diffscale*e),0.625);
+
+
+
+  /* Tapped delay section */
+
+  p->tapdelay = fixeddelay_make(44000);
+  p->taps = (int *)calloc(FDNORDER, sizeof(int));
+  p->tapgains = (float *)calloc(FDNORDER, sizeof(float));
+
+  p->taps[0] = 5+0.410*p->largestdelay;
+  p->taps[1] = 5+0.300*p->largestdelay;
+  p->taps[2] = 5+0.155*p->largestdelay;
+  p->taps[3] = 5+0.000*p->largestdelay;
+
+  for(i = 0; i < FDNORDER; i++) {
+    p->tapgains[i] = pow(p->alpha,(double)p->taps[i]);
+  }
+
+  return(p);
+}
+
+void gverb_free(ty_gverb *p)
+{
+  int i;
+
+  damper_free(p->inputdamper);
+  for(i = 0; i < FDNORDER; i++) {
+    fixeddelay_free(p->fdndels[i]);
+    damper_free(p->fdndamps[i]);
+    diffuser_free(p->ldifs[i]);
+    diffuser_free(p->rdifs[i]);
+  }
+  free(p->fdndels);
+  free(p->fdngains);
+  free(p->fdnlens);
+  free(p->fdndamps);
+  free(p->d);
+  free(p->u);
+  free(p->f);
+  free(p->ldifs);
+  free(p->rdifs);
+  free(p->taps);
+  free(p->tapgains);
+  fixeddelay_free(p->tapdelay);
+  free(p);
+}
+
+void gverb_flush(ty_gverb *p)
+{
+  int i;
+
+  damper_flush(p->inputdamper);
+  for(i = 0; i < FDNORDER; i++) {
+    fixeddelay_flush(p->fdndels[i]);
+    damper_flush(p->fdndamps[i]);
+    diffuser_flush(p->ldifs[i]);
+    diffuser_flush(p->rdifs[i]);
+  }
+  memset(p->d, 0, FDNORDER * sizeof(float));
+  memset(p->u, 0, FDNORDER * sizeof(float));
+  memset(p->f, 0, FDNORDER * sizeof(float));
+  fixeddelay_flush(p->tapdelay);
+}
+
+/* swh: other functions are now in the .h file for inlining */

libraries/audio-client/external/gverb/src/gverbdsp.c

@@ -0,0 +1,130 @@
+
+
+/*
+
+        Copyright (C) 1999 Juhana Sadeharju
+                       kouhia at nic.funet.fi
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+    */
+
+#include <stdio.h>
+#include <math.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "gverbdsp.h"
+
+#define TRUE 1
+#define FALSE 0
+
+ty_diffuser *diffuser_make(int size, float coeff)
+{
+  ty_diffuser *p;
+  int i;
+
+  p = (ty_diffuser *)malloc(sizeof(ty_diffuser));
+  p->size = size;
+  p->coeff = coeff;
+  p->idx = 0;
+  p->buf = (float *)malloc(size*sizeof(float));
+  for (i = 0; i < size; i++) p->buf[i] = 0.0;
+  return(p);
+}
+
+void diffuser_free(ty_diffuser *p)
+{
+  free(p->buf);
+  free(p);
+}
+
+void diffuser_flush(ty_diffuser *p)
+{
+  memset(p->buf, 0, p->size * sizeof(float));
+}
+
+ty_damper *damper_make(float damping)
+{
+  ty_damper *p;
+
+  p = (ty_damper *)malloc(sizeof(ty_damper));
+  p->damping = damping;
+  p->delay = 0.0f;
+  return(p);
+}
+
+void damper_free(ty_damper *p)
+{
+  free(p);
+}
+
+void damper_flush(ty_damper *p)
+{
+  p->delay = 0.0f;
+}
+
+ty_fixeddelay *fixeddelay_make(int size)
+{
+  ty_fixeddelay *p;
+  int i;
+
+  p = (ty_fixeddelay *)malloc(sizeof(ty_fixeddelay));
+  p->size = size;
+  p->idx = 0;
+  p->buf = (float *)malloc(size*sizeof(float));
+  for (i = 0; i < size; i++) p->buf[i] = 0.0;
+  return(p);
+}
+
+void fixeddelay_free(ty_fixeddelay *p)
+{
+  free(p->buf);
+  free(p);
+}
+
+void fixeddelay_flush(ty_fixeddelay *p)
+{
+  memset(p->buf, 0, p->size * sizeof(float));
+}
+
+int isprime(int n)
+{
+  unsigned int i;
+  const unsigned int lim = (int)sqrtf((float)n);
+
+  if (n == 2) return(TRUE);
+  if ((n & 1) == 0) return(FALSE);
+  for(i = 3; i <= lim; i += 2)
+    if ((n % i) == 0) return(FALSE);
+  return(TRUE);
+}
+
+int nearest_prime(int n, float rerror)
+     /* relative error; new prime will be in range
+      * [n-n*rerror, n+n*rerror];
+      */
+{
+  int bound,k;
+
+  if (isprime(n)) return(n);
+  /* assume n is large enough and n*rerror enough smaller than n */
+  bound = n*rerror;
+  for(k = 1; k <= bound; k++) {
+    if (isprime(n+k)) return(n+k);
+    if (isprime(n-k)) return(n-k);
+  }
+  return(-1);
+}

libraries/audio-client/src/AudioClient.cpp

@@ -1,5 +1,5 @@
 //
-//  Audio.cpp
+//  AudioClient.cpp
 //  interface/src
 //
 //  Created by Stephen Birarda on 1/22/13.
@@ -28,30 +28,27 @@
 #include <VersionHelpers.h>
 #endif
 
-#include <AudioConstants.h>
-
 #include <QtCore/QBuffer>
 #include <QtMultimedia/QAudioInput>
 #include <QtMultimedia/QAudioOutput>
 
 #include <glm/glm.hpp>
 
-#include <AudioInjector.h>
 #include <NodeList.h>
 #include <PacketHeaders.h>
 
-#include <PositionalAudioStream.h>
-
 #include <SharedUtil.h>
 #include <UUID.h>
 
-#include "Application.h"
+#include "AudioInjector.h"
+#include "AudioConstants.h"
+#include "PositionalAudioStream.h"
 
-#include "Audio.h"
+#include "AudioClient.h"
 
 static const int RECEIVED_AUDIO_STREAM_CAPACITY_FRAMES = 100;
 
-Audio::Audio() :
+AudioClient::AudioClient() :
     AbstractAudioInterface(),
     _audioInput(NULL),
     _desiredInputFormat(),
@@ -95,13 +92,13 @@ Audio::Audio() :
     // clear the array of locally injected samples
     memset(_localProceduralSamples, 0, AudioConstants::NETWORK_FRAME_BYTES_PER_CHANNEL);
     
-    connect(&_receivedAudioStream, &MixedProcessedAudioStream::processSamples, this, &Audio::processReceivedSamples, Qt::DirectConnection);
+    connect(&_receivedAudioStream, &MixedProcessedAudioStream::processSamples, this, &AudioClient::processReceivedSamples, Qt::DirectConnection);
     
     // Initialize GVerb
     initGverb();
 }
 
-void Audio::reset() {
+void AudioClient::reset() {
     _receivedAudioStream.reset();
     _stats.reset();
     _noiseSource.reset();
@@ -110,7 +107,7 @@ void Audio::reset() {
     _inputGain.reset();
 }
 
-void Audio::audioMixerKilled() {
+void AudioClient::audioMixerKilled() {
     _outgoingAvatarAudioSequenceNumber = 0;
     _stats.reset();
 }
@@ -358,7 +355,7 @@ void linearResampling(const int16_t* sourceSamples, int16_t* destinationSamples,
     }
 }
 
-void Audio::start() {
+void AudioClient::start() {
 
     // set up the desired audio format
     _desiredInputFormat.setSampleRate(AudioConstants::SAMPLE_RATE);
@@ -397,7 +394,7 @@ void Audio::start() {
     _inputGain.setParameters(1.0f,0.0f);
 }
 
-void Audio::stop() {
+void AudioClient::stop() {
 
     _inputFrameBuffer.finalize();
     _inputGain.finalize();
@@ -410,12 +407,12 @@ void Audio::stop() {
     switchOutputToAudioDevice(QAudioDeviceInfo());
 }
 
-QString Audio::getDefaultDeviceName(QAudio::Mode mode) {
+QString AudioClient::getDefaultDeviceName(QAudio::Mode mode) {
     QAudioDeviceInfo deviceInfo = defaultAudioDeviceForMode(mode);
     return deviceInfo.deviceName();
 }
 
-QVector<QString> Audio::getDeviceNames(QAudio::Mode mode) {
+QVector<QString> AudioClient::getDeviceNames(QAudio::Mode mode) {
     QVector<QString> deviceNames;
     foreach(QAudioDeviceInfo audioDevice, QAudioDeviceInfo::availableDevices(mode)) {
         deviceNames << audioDevice.deviceName().trimmed();
@@ -423,17 +420,17 @@ QVector<QString> Audio::getDeviceNames(QAudio::Mode mode) {
     return deviceNames;
 }
 
-bool Audio::switchInputToAudioDevice(const QString& inputDeviceName) {
+bool AudioClient::switchInputToAudioDevice(const QString& inputDeviceName) {
     qDebug() << "DEBUG [" << inputDeviceName << "] [" << getNamedAudioDeviceForMode(QAudio::AudioInput, inputDeviceName).deviceName() << "]";
     return switchInputToAudioDevice(getNamedAudioDeviceForMode(QAudio::AudioInput, inputDeviceName));
 }
 
-bool Audio::switchOutputToAudioDevice(const QString& outputDeviceName) {
+bool AudioClient::switchOutputToAudioDevice(const QString& outputDeviceName) {
     qDebug() << "DEBUG [" << outputDeviceName << "] [" << getNamedAudioDeviceForMode(QAudio::AudioOutput, outputDeviceName).deviceName() << "]";
     return switchOutputToAudioDevice(getNamedAudioDeviceForMode(QAudio::AudioOutput, outputDeviceName));
 }
 
-void Audio::initGverb() {
+void AudioClient::initGverb() {
     // Initialize a new gverb instance
     _gverbLocal = gverb_new(_outputFormat.sampleRate(), _reverbOptions->getMaxRoomSize(), _reverbOptions->getRoomSize(),
                             _reverbOptions->getReverbTime(), _reverbOptions->getDamping(), _reverbOptions->getSpread(),
@@ -460,7 +457,7 @@ void Audio::initGverb() {
     gverb_set_taillevel(_gverb, DB_CO(_reverbOptions->getTailLevel()));
 }
 
-void Audio::updateGverbOptions() {
+void AudioClient::updateGverbOptions() {
     bool reverbChanged = false;
     if (_receivedAudioStream.hasReverb()) {
         
@@ -487,7 +484,7 @@ void Audio::updateGverbOptions() {
     }
 }
 
-void Audio::setReverbOptions(const AudioEffectOptions* options) {
+void AudioClient::setReverbOptions(const AudioEffectOptions* options) {
     // Save the new options
     _scriptReverbOptions.setMaxRoomSize(options->getMaxRoomSize());
     _scriptReverbOptions.setRoomSize(options->getRoomSize());
@@ -507,7 +504,7 @@ void Audio::setReverbOptions(const AudioEffectOptions* options) {
     }
 }
 
-void Audio::addReverb(ty_gverb* gverb, int16_t* samplesData, int numSamples, QAudioFormat& audioFormat, bool noEcho) {
+void AudioClient::addReverb(ty_gverb* gverb, int16_t* samplesData, int numSamples, QAudioFormat& audioFormat, bool noEcho) {
     float wetFraction = DB_CO(_reverbOptions->getWetLevel());
     float dryFraction = (noEcho) ? 0.0f : (1.0f - wetFraction);
     
@@ -536,7 +533,7 @@ void Audio::addReverb(ty_gverb* gverb, int16_t* samplesData, int numSamples, QAu
     }
 }
 
-void Audio::handleLocalEchoAndReverb(QByteArray& inputByteArray) {
+void AudioClient::handleLocalEchoAndReverb(QByteArray& inputByteArray) {
     // If there is server echo, reverb will be applied to the recieved audio stream so no need to have it here.
     bool hasLocalReverb = (_reverb || _receivedAudioStream.hasReverb()) &&
                           !_shouldEchoToServer;
@@ -576,7 +573,7 @@ void Audio::handleLocalEchoAndReverb(QByteArray& inputByteArray) {
     }
 }
 
-void Audio::handleAudioInput() {
+void AudioClient::handleAudioInput() {
     static char audioDataPacket[MAX_PACKET_SIZE];
 
     static int numBytesPacketHeader = numBytesForPacketHeaderGivenPacketType(PacketTypeMicrophoneAudioNoEcho);
@@ -758,7 +755,7 @@ void Audio::handleAudioInput() {
     }
 }
 
-void Audio::processReceivedSamples(const QByteArray& inputBuffer, QByteArray& outputBuffer) {
+void AudioClient::processReceivedSamples(const QByteArray& inputBuffer, QByteArray& outputBuffer) {
     const int numNetworkOutputSamples = inputBuffer.size() / sizeof(int16_t);
     const int numDeviceOutputSamples = numNetworkOutputSamples * (_outputFormat.sampleRate() * _outputFormat.channelCount())
         / (_desiredOutputFormat.sampleRate() * _desiredOutputFormat.channelCount());
@@ -785,7 +782,7 @@ void Audio::processReceivedSamples(const QByteArray& inputBuffer, QByteArray& ou
     }
 }
 
-void Audio::sendMuteEnvironmentPacket() {
+void AudioClient::sendMuteEnvironmentPacket() {
     QByteArray mutePacket = byteArrayWithPopulatedHeader(PacketTypeMuteEnvironment);
     QDataStream mutePacketStream(&mutePacket, QIODevice::Append);
     
@@ -805,7 +802,7 @@ void Audio::sendMuteEnvironmentPacket() {
     }
 }
 
-void Audio::addReceivedAudioToStream(const QByteArray& audioByteArray) {
+void AudioClient::addReceivedAudioToStream(const QByteArray& audioByteArray) {
     if (_audioOutput) {
         // Audio output must exist and be correctly set up if we're going to process received audio
         _receivedAudioStream.parseData(audioByteArray);
@@ -814,7 +811,7 @@ void Audio::addReceivedAudioToStream(const QByteArray& audioByteArray) {
     Application::getInstance()->getBandwidthMeter()->inputStream(BandwidthMeter::AUDIO).updateValue(audioByteArray.size());
 }
 
-void Audio::parseAudioEnvironmentData(const QByteArray &packet) {
+void AudioClient::parseAudioEnvironmentData(const QByteArray &packet) {
     int numBytesPacketHeader = numBytesForPacketHeader(packet);
     const char* dataAt = packet.constData() + numBytesPacketHeader;
     
@@ -835,12 +832,12 @@ void Audio::parseAudioEnvironmentData(const QByteArray &packet) {
     }
 }
 
-void Audio::toggleMute() {
+void AudioClient::toggleMute() {
     _muted = !_muted;
     muteToggled();
 }
 
-void Audio::setIsStereoInput(bool isStereoInput) {
+void AudioClient::setIsStereoInput(bool isStereoInput) {
     if (isStereoInput != _isStereoInput) {
         _isStereoInput = isStereoInput;
         
@@ -855,21 +852,21 @@ void Audio::setIsStereoInput(bool isStereoInput) {
     }
 }
 
-void Audio::toggleAudioSourceInject() {
+void AudioClient::toggleAudioSourceInject() {
     _audioSourceInjectEnabled = !_audioSourceInjectEnabled;
 }
 
-void Audio::selectAudioSourcePinkNoise() {
+void AudioClient::selectAudioSourcePinkNoise() {
     _noiseSourceEnabled = true;
     _toneSourceEnabled = false;
 }
  
-void Audio::selectAudioSourceSine440() {
+void AudioClient::selectAudioSourceSine440() {
     _toneSourceEnabled = true;
     _noiseSourceEnabled = false;
 }
 
-bool Audio::outputLocalInjector(bool isStereo, qreal volume, AudioInjector* injector) {
+bool AudioClient::outputLocalInjector(bool isStereo, qreal volume, AudioInjector* injector) {
     if (injector->getLocalBuffer()) {
         QAudioFormat localFormat = _desiredOutputFormat;
         localFormat.setChannelCount(isStereo ? 2 : 1);
@@ -895,13 +892,13 @@ bool Audio::outputLocalInjector(bool isStereo, qreal volume, AudioInjector* inje
 }
 
 
-void Audio::outputFormatChanged() {
+void AudioClient::outputFormatChanged() {
     int outputFormatChannelCountTimesSampleRate = _outputFormat.channelCount() * _outputFormat.sampleRate();
     _outputFrameSize = AudioConstants::NETWORK_FRAME_SAMPLES_PER_CHANNEL * outputFormatChannelCountTimesSampleRate / _desiredOutputFormat.sampleRate();
     _receivedAudioStream.outputFormatChanged(outputFormatChannelCountTimesSampleRate);
 }
 
-bool Audio::switchInputToAudioDevice(const QAudioDeviceInfo& inputDeviceInfo) {
+bool AudioClient::switchInputToAudioDevice(const QAudioDeviceInfo& inputDeviceInfo) {
     bool supportedFormat = false;
     
     // cleanup any previously initialized device
@@ -946,7 +943,7 @@ bool Audio::switchInputToAudioDevice(const QAudioDeviceInfo& inputDeviceInfo) {
     return supportedFormat;
 }
 
-void Audio::outputNotify() {
+void AudioClient::outputNotify() {
     int recentUnfulfilled = _audioOutputIODevice.getRecentUnfulfilledReads();
     if (recentUnfulfilled > 0) {
         if (_outputStarveDetectionEnabled) {
@@ -970,7 +967,7 @@ void Audio::outputNotify() {
     }
 }
 
-bool Audio::switchOutputToAudioDevice(const QAudioDeviceInfo& outputDeviceInfo) {
+bool AudioClient::switchOutputToAudioDevice(const QAudioDeviceInfo& outputDeviceInfo) {
     bool supportedFormat = false;
 
     // cleanup any previously initialized device
@@ -998,7 +995,7 @@ bool Audio::switchOutputToAudioDevice(const QAudioDeviceInfo& outputDeviceInfo)
             _audioOutput = new QAudioOutput(outputDeviceInfo, _outputFormat, this);
             _audioOutput->setBufferSize(_outputBufferSizeFrames * _outputFrameSize * sizeof(int16_t));
 
-            connect(_audioOutput, &QAudioOutput::notify, this, &Audio::outputNotify);
+            connect(_audioOutput, &QAudioOutput::notify, this, &AudioClient::outputNotify);
 
             qDebug() << "Output Buffer capacity in frames: " << _audioOutput->bufferSize() / sizeof(int16_t) / (float)_outputFrameSize;
             
@@ -1017,7 +1014,7 @@ bool Audio::switchOutputToAudioDevice(const QAudioDeviceInfo& outputDeviceInfo)
     return supportedFormat;
 }
 
-void Audio::setOutputBufferSize(int numFrames) {
+void AudioClient::setOutputBufferSize(int numFrames) {
     numFrames = std::min(std::max(numFrames, MIN_AUDIO_OUTPUT_BUFFER_SIZE_FRAMES), MAX_AUDIO_OUTPUT_BUFFER_SIZE_FRAMES);
     if (numFrames != _outputBufferSizeFrames) {
         qDebug() << "Audio output buffer size (frames): " << numFrames;
@@ -1037,18 +1034,18 @@ void Audio::setOutputBufferSize(int numFrames) {
 // proportional to the accelerator ratio. 
 
 #ifdef Q_OS_WIN
-const float Audio::CALLBACK_ACCELERATOR_RATIO = 0.1f;
+const float AudioClient::CALLBACK_ACCELERATOR_RATIO = 0.1f;
 #endif
 
 #ifdef Q_OS_MAC
-const float Audio::CALLBACK_ACCELERATOR_RATIO = 2.0f;
+const float AudioClient::CALLBACK_ACCELERATOR_RATIO = 2.0f;
 #endif
 
 #ifdef Q_OS_LINUX
-const float Audio::CALLBACK_ACCELERATOR_RATIO = 2.0f;
+const float AudioClient::CALLBACK_ACCELERATOR_RATIO = 2.0f;
 #endif
 
-int Audio::calculateNumberOfInputCallbackBytes(const QAudioFormat& format) const {
+int AudioClient::calculateNumberOfInputCallbackBytes(const QAudioFormat& format) const {
     int numInputCallbackBytes = (int)(((AudioConstants::NETWORK_FRAME_BYTES_PER_CHANNEL
         * format.channelCount()
         * (format.sampleRate() / AudioConstants::SAMPLE_RATE))
@@ -1057,7 +1054,7 @@ int Audio::calculateNumberOfInputCallbackBytes(const QAudioFormat& format) const
     return numInputCallbackBytes;
 }
 
-float Audio::calculateDeviceToNetworkInputRatio(int numBytes) const {
+float AudioClient::calculateDeviceToNetworkInputRatio(int numBytes) const {
     float inputToNetworkInputRatio = (int)((_numInputCallbackBytes 
         * CALLBACK_ACCELERATOR_RATIO
         / AudioConstants::NETWORK_FRAME_BYTES_PER_CHANNEL) + 0.5f);
@@ -1065,18 +1062,18 @@ float Audio::calculateDeviceToNetworkInputRatio(int numBytes) const {
     return inputToNetworkInputRatio;
 }
 
-int Audio::calculateNumberOfFrameSamples(int numBytes) const {
+int AudioClient::calculateNumberOfFrameSamples(int numBytes) const {
     int frameSamples = (int)(numBytes * CALLBACK_ACCELERATOR_RATIO + 0.5f) / sizeof(int16_t);
     return frameSamples;
 }
 
-float Audio::getInputRingBufferMsecsAvailable() const {
+float AudioClient::getInputRingBufferMsecsAvailable() const {
     int bytesInInputRingBuffer = _inputRingBuffer.samplesAvailable() * sizeof(int16_t);
     float msecsInInputRingBuffer = bytesInInputRingBuffer / (float)(_inputFormat.bytesForDuration(USECS_PER_MSEC));
     return  msecsInInputRingBuffer;
 }
 
-float Audio::getAudioOutputMsecsUnplayed() const {
+float AudioClient::getAudioOutputMsecsUnplayed() const {
     if (!_audioOutput) {
         return 0.0f;
     }
@@ -1085,7 +1082,7 @@ float Audio::getAudioOutputMsecsUnplayed() const {
     return msecsAudioOutputUnplayed;
 }
 
-qint64 Audio::AudioOutputIODevice::readData(char * data, qint64 maxSize) {
+qint64 AudioClient::AudioOutputIODevice::readData(char * data, qint64 maxSize) {
     int samplesRequested = maxSize / sizeof(int16_t);
     int samplesPopped;
     int bytesWritten;

libraries/audio-client/src/AudioClient.h

@@ -1,5 +1,5 @@
 //
-//  Audio.h
+//  AudioClient.h
 //  interface/src
 //
 //  Created by Stephen Birarda on 1/22/13.
@@ -9,43 +9,38 @@
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 //
 
-#ifndef hifi_Audio_h
+#ifndef hifi_AudioClient_h
-#define hifi_Audio_h
+#define hifi_AudioClient_h
 
 #include <fstream>
 #include <vector>
 
-#include <QAudio>
+#include <QtCore/QByteArray>
-#include <QAudioInput>
+#include <QtCore/QElapsedTimer>
-#include <QElapsedTimer>
-#include <QGLWidget>
 #include <QtCore/QObject>
 #include <QtCore/QVector>
+#include <QtMultimedia/QAudio>
 #include <QtMultimedia/QAudioFormat>
-#include <QVector>
+#include <QtMultimedia/QAudioInput>
-#include <QByteArray>
 
 #include <AbstractAudioInterface.h>
+#include <AudioBuffer.h>
+#include <AudioEffectOptions.h>
+#include <AudioFormat.h>
+#include <AudioGain.h>
 #include <AudioRingBuffer.h>
+#include <AudioSourceTone.h>
+#include <AudioSourceNoise.h>
+#include <AudioStreamStats.h>
 #include <DependencyManager.h>
+#include <MixedProcessedAudioStream.h>
+#include <RingBufferHistory.h>
 #include <StDev.h>
 
-#include "InterfaceConfig.h"
-#include "audio/AudioIOStats.h"
-#include "audio/AudioNoiseGate.h"
-#include "AudioStreamStats.h"
 #include "Recorder.h"
-#include "RingBufferHistory.h"
-#include "AudioRingBuffer.h"
-#include "AudioFormat.h"
-#include "AudioBuffer.h"
-#include "AudioSourceTone.h"
-#include "AudioSourceNoise.h"
-#include "AudioGain.h"
-
-#include "MixedProcessedAudioStream.h"
-#include "AudioEffectOptions.h"
 
+#include "AudioIOStats.h"
+#include "AudioNoiseGate.h"
 
 #ifdef _WIN32
 #pragma warning( push )
@@ -73,14 +68,14 @@ class QAudioInput;
 class QAudioOutput;
 class QIODevice;
 
-class Audio : public AbstractAudioInterface, public Dependency {
+class AudioClient : public AbstractAudioInterface, public Dependency {
     Q_OBJECT
     SINGLETON_DEPENDENCY
 public:
 
     class AudioOutputIODevice : public QIODevice {
     public:
-        AudioOutputIODevice(MixedProcessedAudioStream& receivedAudioStream, Audio* audio) : 
+        AudioOutputIODevice(MixedProcessedAudioStream& receivedAudioStream, AudioClient* audio) :
             _receivedAudioStream(receivedAudioStream), _audio(audio), _unfulfilledReads(0) {};
 
         void start() { open(QIODevice::ReadOnly); }
@@ -91,7 +86,7 @@ public:
         int getRecentUnfulfilledReads() { int unfulfilledReads = _unfulfilledReads; _unfulfilledReads = 0; return unfulfilledReads; }
     private:
         MixedProcessedAudioStream& _receivedAudioStream;
-        Audio* _audio;
+        AudioClient* _audio;
         int _unfulfilledReads;
     };
     
@@ -179,7 +174,7 @@ signals:
     void inputReceived(const QByteArray& inputSamples);
 
 protected:
-    Audio();
+    AudioClient();
     
 private:
     void outputFormatChanged();
@@ -278,4 +273,4 @@ private:
 };
 
 
-#endif // hifi_Audio_h
+#endif // hifi_AudioClient_h

libraries/audio-client/src/AudioIOStats.cpp

@@ -9,14 +9,12 @@
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 //
 
-#include "InterfaceConfig.h"
-
 #include <AudioConstants.h>
 #include <MixedProcessedAudioStream.h>
 #include <NodeList.h>
 #include <PositionalAudioStream.h>
 
-#include "Audio.h"
+#include "AudioClient.h"
 
 #include "AudioIOStats.h"
 
@@ -27,7 +25,7 @@ const int APPROXIMATELY_30_SECONDS_OF_AUDIO_PACKETS = (int)(30.0f * 1000.0f / Au
 
 AudioIOStats::AudioIOStats(MixedProcessedAudioStream* receivedAudioStream) :
     _receivedAudioStream(receivedAudioStream),
-    _audioInputMsecsReadStats(MSECS_PER_SECOND / (float)AudioConstants::NETWORK_FRAME_MSECS * Audio::CALLBACK_ACCELERATOR_RATIO, FRAMES_AVAILABLE_STATS_WINDOW_SECONDS),
+    _audioInputMsecsReadStats(MSECS_PER_SECOND / (float)AudioConstants::NETWORK_FRAME_MSECS * AudioClient::CALLBACK_ACCELERATOR_RATIO, FRAMES_AVAILABLE_STATS_WINDOW_SECONDS),
     _inputRingBufferMsecsAvailableStats(1, FRAMES_AVAILABLE_STATS_WINDOW_SECONDS),
     _audioOutputMsecsUnplayedStats(1, FRAMES_AVAILABLE_STATS_WINDOW_SECONDS),
     _lastSentAudioPacket(0),
@@ -97,7 +95,7 @@ void AudioIOStats::parseAudioStreamStatsPacket(const QByteArray& packet) {
 
 void AudioIOStats::sendDownstreamAudioStatsPacket() {
     
-    auto audioIO = DependencyManager::get<Audio>();
+    auto audioIO = DependencyManager::get<AudioClient>();
     
     // since this function is called every second, we'll sample for some of our stats here
     _inputRingBufferMsecsAvailableStats.update(audioIO->getInputRingBufferMsecsAvailable());

libraries/audio/src/AudioBuffer.h

@@ -1,6 +1,6 @@
 //
 //  AudioBuffer.h
-//  hifi
+//  libraries/audio/src
 //
 //  Created by Craig Hansen-Sturm on 8/29/14.
 //  Copyright 2014 High Fidelity, Inc.
@@ -16,6 +16,8 @@
 
 #include <QDebug>
 
+#include "AudioFormat.h"
+
 template< typename T >
 class AudioFrameBuffer {
     

libraries/audio/src/MixedProcessedAudioStream.h

@@ -14,7 +14,7 @@
 
 #include "InboundAudioStream.h"
 
-class Audio;
+class AudioClient;
 
 class MixedProcessedAudioStream  : public InboundAudioStream {
     Q_OBJECT

libraries/avatars/src/Recorder.h

@@ -1,6 +1,6 @@
 //
 //  Recorder.h
-//
+//  libraries/avatars/src
 //
 //  Created by Clement on 8/7/14.
 //  Copyright 2014 High Fidelity, Inc.