AudioSystem.cpp

#include "AudioSystem.h"
#include "AudioListenerComponent.h"
#include "Context.h"
 
#include "Systems/Core/TransformSystem.h"
#include "Services/Time.h"
 
#include "Foundation/Logging/Logger.h"
 
#include <xaudio2.h>
#include <x3daudio.h>
#include <atlbase.h>
 
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("AudioSystem");
}
 
namespace Cogs
{
  namespace Core
  {
    struct AudioDevice
    {
      ~AudioDevice()
      {
        if(initialized_com) CoUninitialize();
      }
      void initialize()
      {
        CoInitializeEx(nullptr, COINIT_MULTITHREADED);
        initialized_com = true;
 
        HRESULT hr = XAudio2Create(&audioDevice, 0, XAUDIO2_DEFAULT_PROCESSOR);
 
        if (FAILED(hr)) {
          LOG_ERROR(logger, "Failed to initialize audio device.");
          return;
        }
 
        //NOTE: Debug messages will appear in the VS Output window.
        XAUDIO2_DEBUG_CONFIGURATION debugConfiguration = {};
#ifdef _DEBUG
        debugConfiguration.TraceMask = XAUDIO2_LOG_ERRORS;
#endif
        audioDevice->SetDebugConfiguration(&debugConfiguration);
 
        hr = audioDevice->CreateMasteringVoice(&masteringVoice);
 
        if (FAILED(hr)) {
          LOG_ERROR(logger, "Could not create mastering voice.");
          return;
        }
 
        DWORD channelMask = 0;
        masteringVoice->GetChannelMask(&channelMask);
 
        hr = X3DAudioInitialize(channelMask, X3DAUDIO_SPEED_OF_SOUND, x3DInstance);
 
        if (FAILED(hr)) {
          LOG_ERROR(logger, "Failed to initialize X3D Audio.");
          return;
        }
 
        initialized = true;
      }
 
      CComPtr<IXAudio2> audioDevice;
      IXAudio2MasteringVoice * masteringVoice;
 
      X3DAUDIO_HANDLE x3DInstance;
 
      bool initialized = false;
      bool initialized_com = false;
    };
  }
}
 
Cogs::Core::AudioSystem::AudioSystem(Memory::Allocator * allocator, SizeType size) :
  ComponentSystemWithDataPool(allocator, size),
  subSystem(std::make_unique<AudioDevice>())
{}
 
Cogs::Core::AudioSystem::~AudioSystem()
{
}
 
void Cogs::Core::AudioSystem::initialize(Context * context)
{
  ComponentSystemWithDataPool::initialize(context);
 
  subSystem->initialize();
}
 
namespace
{
  X3DAUDIO_VECTOR toX3D(const glm::vec3 & v)
  {
    return *reinterpret_cast<const X3DAUDIO_VECTOR *>(&v);
  }
}
 
void Cogs::Core::AudioSystem::update(Context * context)
{
  if (!subSystem->initialized) return;
 
  const double time = context->time->getAnimationTime();
  float elapsed = static_cast<float>(time - prevTime);
  prevTime = time;
 
  X3DAUDIO_LISTENER listener = {};
  X3DAUDIO_EMITTER emitter = {};
 
  XAUDIO2_VOICE_DETAILS voiceDetails = {};
  subSystem->masteringVoice->GetVoiceDetails(&voiceDetails);
 
  float volume = 1.0f;
 
  if(auto listenerComponent = listenerHandle.resolveComponent<AudioListenerComponent>(); listenerComponent) {
    auto listenerTransformComponent = listenerComponent->getComponent<TransformComponent>();
    auto & listenerTransform = context->transformSystem->getLocalToWorld(listenerTransformComponent);
 
    // X3DAudio uses left-handed system.
    auto front = glm::normalize(glm::vec3(listenerTransform * glm::vec4(0, 0, 1, 0)));
    auto up = glm::normalize(glm::vec3(listenerTransform * glm::vec4(0, 1, 0, 0)));
 
    auto listenerPosition = glm::vec3(listenerTransform * glm::vec4(0, 0, 0, 1));
 
    listener.Position = toX3D(listenerPosition);
    listener.OrientFront = toX3D(front);
    listener.OrientTop = toX3D(up);
 
    auto listenerDiff = (listenerPosition - listenerComponent->previousPosition) / elapsed;
    listener.Velocity = toX3D(listenerDiff);
    listenerComponent->previousPosition = listenerPosition;
 
    volume = listenerComponent->volume;
  }
 
  for (auto & c : pool) {
    auto & data = getData(&c);
 
    if (data.state == AudioState::None && c.enabled && c.sound) {
      auto hr = subSystem->audioDevice->CreateSourceVoice(&data.sourceVoice, &c.sound->format.Format);
 
      if (FAILED(hr)) {
        continue;
      }
 
      hr = subSystem->audioDevice->CreateSubmixVoice(&data.submixVoice, 2, voiceDetails.InputSampleRate, XAUDIO2_VOICE_USEFILTER, 0);
 
      if (FAILED(hr)) {
        continue;
      }
 
      // Send audio from source voice only through submix voice.
      std::vector<XAUDIO2_SEND_DESCRIPTOR> descs = {
        { 0, data.submixVoice }
      };
 
      XAUDIO2_VOICE_SENDS sends;
      sends.SendCount = static_cast<uint32_t>(descs.size());
      sends.pSends = descs.data();
 
      hr = data.sourceVoice->SetOutputVoices(&sends);
 
      if (FAILED(hr)) {
        continue;
      }
 
      data.state = AudioState::Stopped;
    }
 
    if (c.enabled && data.state == AudioState::Stopped) {
      data.state = AudioState::StartPlaying;
    } else if (!c.enabled && data.state == AudioState::Playing) {
      data.state = AudioState::StopPlaying;
    }
 
    if (data.state == AudioState::StopPlaying) {
      data.sourceVoice->Stop();
 
      if (!c.enabled) {
        data.sourceVoice->DestroyVoice();
        data.submixVoice->DestroyVoice();
        data.state = AudioState::None;
      } else {
        data.state = AudioState::Stopped;
      }
    }
 
    if (c.sound && data.state == AudioState::StartPlaying) {
      XAUDIO2_BUFFER buffer = {};
      buffer.pAudioData = (unsigned char *)c.sound->data.data();
      buffer.AudioBytes = static_cast<uint32_t>(c.sound->data.size());
      buffer.Flags = XAUDIO2_END_OF_STREAM;
      buffer.LoopCount = c.loop ? XAUDIO2_LOOP_INFINITE : 0;
 
      data.sourceVoice->Stop();
      data.sourceVoice->FlushSourceBuffers();
 
      auto hr = data.sourceVoice->SubmitSourceBuffer(&buffer);
 
      if (FAILED(hr)) {
        continue;
      }
 
      hr = data.sourceVoice->Start();
 
      if (FAILED(hr)) {
        continue;
      }
 
      data.state = AudioState::Playing;
    }
 
    if (data.state == AudioState::Playing) {
      emitter.ChannelCount = 1;
 
      std::vector<float> azimuths(emitter.ChannelCount);
      emitter.pChannelAzimuths = azimuths.data();
 
      auto transformComponent = c.getComponent<TransformComponent>();
      auto & transform = context->transformSystem->getLocalToWorld(transformComponent);
 
      auto emitterPosition = glm::vec3(transform * glm::vec4(0, 0, 0, 1));
 
      auto emitterDiff = (emitterPosition - data.previousPosition) / elapsed;
      emitter.Velocity = toX3D(emitterDiff);
      data.previousPosition = emitterPosition;
 
      auto front = glm::normalize(glm::vec3(transform * glm::vec4(0, 0, 1, 0)));
      auto up = glm::normalize(glm::vec3(transform * glm::vec4(0, 1, 0, 0)));
      
      emitter.Position = toX3D(emitterPosition);
      emitter.OrientFront = toX3D(front);
      emitter.OrientTop = toX3D(up);
 
      emitter.CurveDistanceScaler = c.radius;
      emitter.DopplerScaler = c.dopplerScale;
 
      std::vector<float> coefficients(2 * voiceDetails.InputChannels);
 
      X3DAUDIO_DSP_SETTINGS dspSettings = {};
      dspSettings.SrcChannelCount = emitter.ChannelCount;
      dspSettings.DstChannelCount = voiceDetails.InputChannels;
      dspSettings.pMatrixCoefficients = coefficients.data();
 
      X3DAudioCalculate(subSystem->x3DInstance,
        &listener,
        &emitter,
        X3DAUDIO_CALCULATE_MATRIX | X3DAUDIO_CALCULATE_DOPPLER | X3DAUDIO_CALCULATE_REVERB | X3DAUDIO_CALCULATE_LPF_DIRECT,
        &dspSettings);
 
      auto hr = data.sourceVoice->SetOutputMatrix(data.submixVoice,
        2,
        voiceDetails.InputChannels,
        dspSettings.pMatrixCoefficients);
 
      if (FAILED(hr)) {
        continue;
      }
      
      hr = data.sourceVoice->SetFrequencyRatio(dspSettings.DopplerFactor * c.frequencyModulation);
 
      if (FAILED(hr)) {
        continue;
      }
 
      XAUDIO2_FILTER_PARAMETERS FilterParameters = {
        LowPassFilter,
        2.0f * sinf(X3DAUDIO_PI / 6.0f * dspSettings.LPFDirectCoefficient),
        1.0f
      };
 
      data.submixVoice->SetFilterParameters(&FilterParameters);
 
      data.sourceVoice->SetVolume(volume * c.volume);
    }
  }
}
 
void Cogs::Core::AudioSystem::cleanup(Context * /*context*/)
{
 
}
 
void Cogs::Core::AudioSystem::destroyComponent(ComponentHandle handle)
{
  auto component = handle.resolveComponent<AudioComponent>();
 
  auto & data = getData(component);
 
  if (data.state == AudioState::Playing || data.state == AudioState::StopPlaying) {
    data.sourceVoice->Stop();
    data.sourceVoice->DestroyVoice();
    data.submixVoice->DestroyVoice();
  }
 
  ComponentSystemWithDataPool::destroyComponent(handle);
}
 
void Cogs::Core::AudioSystem::setAudioListener(ComponentHandle handle)
{
  listenerHandle = handle;
}