alsoundextractor.cpp

Go to the documentation of this file.

#include <alaudio/alsoundextractor.h>
#include <alproxies/almemoryproxy.h>
#include <alcommon/alproxy.h>
#include <alcommon/albroker.h>
#include <iostream>

namespace AL
{

ALSoundExtractor::ALSoundExtractor(boost::shared_ptr<ALBroker> pBroker,
                                   std::string pName)
  : ALExtractor(pBroker, pName)
  , fIsRunning(false)
  , fbDebugMode(false)
  , audioDevice()
{
  functionName("setDebugMode",
               "ALSoundExtractor",
               "enable/disable the printing of some debug information");
  addParam("bSetOrUnset",
           "enable the functionnality when true.");
  BIND_METHOD(ALSoundExtractor::setDebugMode);

  functionName("processRemote",
               "ALSoundExtractor",
               "enable/disable the printing of some debug information");
  addParam("nbOfChannels",
           "Provides the number of channels of the buffer.");
  addParam("nbOfSamplesByChannel",
           "Provides the number of samples by channel.");
  addParam("timestamp",
           "Provides the timestamp of the buffer.");
  addParam("buffer",
           "Provides the audio buffer as an ALValue.");
  BIND_METHOD(ALSoundExtractor::processRemote);

  functionName("processSoundRemote",
               "ALSoundExtractor",
               "enable/disable the printing of some debug information");
  addParam("nbOfChannels",
           "Provides the number of channels of the buffer.");
  addParam("nbOfSamplesByChannel",
           "Provides the number of samples by channel.");
  addParam("buffer",
           "Provides the audio buffer as an ALValue.");
  BIND_METHOD(ALSoundExtractor::processSoundRemote);


  try
  {
    audioDevice = getParentBroker()->getProxy("ALAudioDevice");
  }
  catch(const ALError& e)
  {
    qiLogWarning("audio.alsoundextractor") << e.what()
                                           << " Sound capture will not work.";
  }

  fNullTimestamp.arrayReserve(2);
  fNullTimestamp.arrayPush(0);
  fNullTimestamp.arrayPush(0);
}

ALSoundExtractor::~ALSoundExtractor()
{
  stopDetection();
}

void ALSoundExtractor::startDetection()
{
  if(!fIsRunning)
  {
    qiLogVerbose("audio.alsoundextractor", "ALSoundExtractor : startDetection");
    try
    {
      if(!audioDevice)
        audioDevice = getParentBroker()->getProxy("ALAudioDevice");
      audioDevice->callVoid("subscribe", this->getName());
    }
    catch(ALError & error)
    {
      fIsRunning = false;
      throw ALError(getName(), "startDetection", error.what());
    }

    fIsRunning = true;
  }
}

void ALSoundExtractor::stopDetection()
{
  if(fIsRunning)
  {
    qiLogVerbose("audio.alsoundextractor", "ALSoundExtractor : stopDetection");
    fIsRunning = false;
    audioDevice->callVoid("unsubscribe", this->getName());
  }
}

void ALSoundExtractor::process(const int & nbOfChannels,
                               const int & nbrOfSamplesByChannel,
                               const AL_SOUND_FORMAT * buffer,
                               const ALValue & timestamp)
{
  /* Since ALAudioDevice CLient is only calling the process method,
   * we call the deprecated method processSound here.
   */

  processSound(nbOfChannels, nbrOfSamplesByChannel, buffer);
}

void ALSoundExtractor::processSound(const int pNbOfInputChannels,
                                    const int pNbrSamples,
                                    const AL_SOUND_FORMAT * bBuffer)
{
}

void ALSoundExtractor::processSoundRemote(const int & pNbOfInputChannels,
                                          const int & pNbrSamples,
                                          const ALValue & pBuffer)
{
}


void ALSoundExtractor::processRemote(const int & pNbOfInputChannels,
                                     const int & pNbrSamples,
                                     const ALValue & timestamp,
                                     const ALValue & buffer)
{
  process(pNbOfInputChannels,
          pNbrSamples,
          (const AL_SOUND_FORMAT *)buffer.GetBinary(),
          timestamp);

  processSoundRemote(pNbOfInputChannels,
          pNbrSamples,
          (const AL_SOUND_FORMAT *)buffer.GetBinary());
}

std::vector<std::string> ALSoundExtractor::getOutputNames(void)
{
  return getParentBroker()->getProxy("ALMemory")->
      call<std::vector<std::string> >("getExtractorEvent", getName());
}

}  // namespace AL