MASpeakerController.cpp

/*
 *  This file is part of the AiBO+ project
 *
 *  Copyright (C) 2005-2016 Csaba Kertész (csaba.kertesz@gmail.com)
 *
 *  AiBO+ 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.
 *
 *  AiBO+ 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., 59 Temple Street #330, Boston, MA 02111-1307, USA.
 *
 */

#include "MASpeakerController.hpp"

#include "types/MAAudio.hpp"
#include "types/MARobotState.hpp"
#include "sound/MASoundDatabase.hpp"
#include "MABehaviorManager.hpp"

#include <MCLog.hpp>
#include <MCTimer.hpp>

namespace MA
{
MCThreadLocalData<MASpeakerController> Speaker(false);
}

namespace
{
typedef boost::unordered_map<std::string, MA::SoundBaseSPtr> SoundDataMap;

typedef std::pair<std::string, int> FutureSoundDescriptor;
typedef boost::unordered_map<int, FutureSoundDescriptor> FutureSoundMap;

// Global playback ID
MCThreadLocalData<int> PlaybackID(true);
// Loaded sounds
MCThreadLocalData<SoundDataMap> Sounds(true);
// Future sounds
MCThreadLocalData<FutureSoundMap> FutureSounds(true);
// Preloaded sounds
MCThreadLocalData<MC::StringList> PreloadedSounds(true);

void CheckStaticSpeakerControllerVariables(bool reset_if_exists)
{
  if (unlikely(!PlaybackID.get()))
  {
    PlaybackID.reset(new int);
    *PlaybackID = 0;
    Sounds.reset(new SoundDataMap);
    FutureSounds.reset(new FutureSoundMap);
    PreloadedSounds.reset(new MC::StringList);
  } else
  if (reset_if_exists)
  {
    *PlaybackID = 0;
    Sounds->clear();
    FutureSounds->clear();
    PreloadedSounds->clear();
  }
}
}

MASpeakerController::MASpeakerController() : MAController(MA::SpeakerController), BufferSize(512)
{
  CheckStaticSpeakerControllerVariables(true);
  if (MA::Speaker.get())
  {
    MC_WARNING("The global speaker controller is overridden.");
  }
  MA::Speaker.reset(this);
}


MASpeakerController::~MASpeakerController()
{
  if (MA::Speaker.get() == this)
  {
    MA::Speaker.release();
  }
  Playbacks.clear();
  // Remove the non-cached sound files
  for (auto iter = Sounds->begin(); iter != Sounds->end();)
  {
    MASoundBase* SoundData = iter->second.get();

    if (!SoundData->IsCached())
    {
      iter = Sounds->erase(iter);
      // This safety check is required otherwise crash
      if (iter == Sounds->end())
        break;

      continue;
    }
    ++iter;
  }
}


void MASpeakerController::UpdateRobotState(MARobotState& state)
{
  state.Audio->SpeakerVolume = (int)SpeakerDevice->GetVolume();
  state.Audio->RemainingPlaybackTime = (int)GetRemainingPlaybackTime();
  state.Audio->EffectsPlayed = (int)IsOnlyEffectsPlayed();
}


MA::DeviceList MASpeakerController::GetMotors() const
{
  // Nothing to return
  return MA::DeviceList();
}


void MASpeakerController::RegisterFutureSound(const int id, const std::string& name,
                                              const int duration)
{
  CheckStaticSpeakerControllerVariables(false);
  FutureSounds->insert(std::make_pair(id, FutureSoundDescriptor(name, duration)));
}


bool MASpeakerController::IsFree() const
{
  return Playbacks.empty();
}


void MASpeakerController::SwitchSoundProfile()
{
  // Release the sounds
  *PlaybackID = 0;
  Sounds->clear();
  // Switch profile
  MA::SoundDatabase->SwitchProfile();
  // Reload preloaded samples
  for (unsigned int i = 0; i < PreloadedSounds->size(); ++i)
    Preload((*PreloadedSounds)[i]);
  SaveSoundProfile();
}


std::string MASpeakerController::GetSoundProfileName() const
{
  return MA::SoundDatabase->GetProfileName();
}


void MASpeakerController::SetSoundProfileName(const std::string& profile_name)
{
  // Release the sounds
  *PlaybackID = 0;
  Sounds->clear();
  // Set new profile
  MA::SoundDatabase->SetProfileName(profile_name);
  // Reload preloaded samples
  for (unsigned int i = 0; i < PreloadedSounds->size(); ++i)
    Preload((*PreloadedSounds)[i]);
  SaveSoundProfile();
}


void MASpeakerController::LoadSoundProfile()
{
}


void MASpeakerController::SaveSoundProfile()
{
}


void MASpeakerController::LoadVolumeControl()
{
}


void MASpeakerController::SaveVolumeControl()
{
}


bool MASpeakerController::Preload(const std::string& name)
{
  std::string FileName = MA::SoundDatabase->GetSoundFileName(name);

  if (FileName.empty())
  {
    MC_WARNING("File is not found: %s", name.c_str());
    return false;
  }
  if (!(*Sounds)[FileName])
  {
    MA::SoundBaseSPtr NewSoundFile(MA::SoundDatabase->GetSoundFile(FileName, true));

    PreloadedSounds->push_back(name);
    // The sound file is not valid (not found, read error or empty file)
    if (!NewSoundFile->IsValid())
    {
      return false;
    }
    (*Sounds)[FileName] = NewSoundFile;
    if (MAController::IsVerbose())
      MC_LOG("Preload a sound file: %s", FileName.c_str());
  }
  return true;
}


void MASpeakerController::FreePreloadedSound(const std::string& name)
{
  auto Iter = std::find(PreloadedSounds->begin(), PreloadedSounds->end(), name);

  if (Iter != PreloadedSounds->end())
  {
    PreloadedSounds->erase(Iter);
  }
  std::string FileName = MA::SoundDatabase->GetSoundFileName(name);
  auto FileIter = Sounds->find(FileName);
  MASoundBase* SoundDataPtr = nullptr;

  if (FileIter != Sounds->end())
  {
    SoundDataPtr = FileIter->second.get();
    Sounds->erase(FileIter);
  }
  if (SoundDataPtr)
  {
    for (auto iter = Playbacks.begin(); iter != Playbacks.end(); ++iter)
    {
      if (iter->first.get() == SoundDataPtr)
      {
        Playbacks.erase(iter);
        break;
      }
    }
  }
  MC_LOG("Preloaded sound freed: %s", name.c_str());
}


int MASpeakerController::Play(const std::string& name)
{
  std::string FileName = MA::SoundDatabase->GetSoundFileName(name);

  if (FileName.empty())
  {
    MC_WARNING("Sound file is not found: %s", name.c_str());
    return -1;
  }
  if (!(*Sounds)[FileName])
  {
    MA::SoundBaseSPtr NewSoundFile(MA::SoundDatabase->GetSoundFile(FileName, false));

    // The sound file is not valid (not found, read error or empty file)
    if (!NewSoundFile->IsValid())
    {
      return -1;
    }
    (*Sounds)[FileName] = NewSoundFile;
  }
  return Play((*Sounds)[FileName]);
}


int MASpeakerController::Play(MA::SoundBaseSPtr sound)
{
  (*PlaybackID)++;
  // Overflow detection (not too practical error case)
  if (*PlaybackID < 0)
  {
    *PlaybackID = 1;
  }
  MA::PlaybackDescriptor PlaybackDescriptor;
  const auto Iter = FutureSounds->find(*PlaybackID);

  PlaybackDescriptor.get<0>() = *PlaybackID;
  // Remember for the start time
  PlaybackDescriptor.get<2>() = MCTimer::GetElapsedSystemTime() / 1000;
  // Try to find in the future sounds
  if (Iter != FutureSounds->end() && Iter->second.first == sound->GetDisplayName())
  {
    PlaybackDescriptor.get<3>() = Iter->second.second;
  }
  Playbacks.insert(std::make_pair(sound, PlaybackDescriptor));
  if (MAController::IsVerbose())
  {
    MC_LOG("Play a sound file: %s (id: %d)", sound->GetDisplayName().c_str(), *PlaybackID);
  }
  return *PlaybackID;
}


bool MASpeakerController::IsPlayed(const int playback_id) const
{
  if (Playbacks.empty())
    return false;

  for (auto& playback : Playbacks)
  {
    const MA::PlaybackDescriptor& Descriptor = playback.second;

    if (Descriptor.get<0>() == playback_id)
      return true;
  }
  return false;
}


bool MASpeakerController::IsPlayed(const std::string& sound_name) const
{
  if (Playbacks.empty())
    return false;

  for (auto& playback : Playbacks)
  {
    if (playback.first.get() && playback.first->GetDisplayName() == sound_name)
      return true;
  }
  return false;
}


void MASpeakerController::SetVolume(const MA::VolumeType new_volume)
{
  SpeakerDevice->SetVolumeState(new_volume);
}


void MASpeakerController::MixNextBuffer(int16_t* target_buffer, bool limit_non_cached)
{
  int Counter = 0;
  bool NonCachedSample = false;
  int32_t TempBuffer[BufferSize];

  // Clear the buffers
  memset(target_buffer, 0, BufferSize*sizeof(int16_t));
  memset(&TempBuffer[0], 0, BufferSize*sizeof(int32_t));
  // Mix the samples
  for (auto iter = Playbacks.begin(); iter != Playbacks.end();)
  {
    MA::PlaybackDescriptor& Descriptor = iter->second;

    // Mixing if cached or the non-cached limit has not been reached
    if (iter->first->IsCached() || !NonCachedSample)
      iter->first->AddToBuffer(Descriptor.get<1>(), BufferSize, TempBuffer);
    if (!iter->first->IsCached() && limit_non_cached)
      NonCachedSample = true;

    Descriptor.get<1>() += BufferSize;
    // Remove any finished sample
    // Note: Erasing from multimap while iterating: see http://stackoverflow.com/questions/446205
    if ((iter->first->GetSize() <= Descriptor.get<1>() &&
        // Check if the sound has expected duration
        (Descriptor.get<3>() <= 0 || Descriptor.get<3>() <=
         (int)(MCTimer::GetElapsedSystemTime() / 1000-Descriptor.get<2>()))) ||
        // Remove a non-cached sample if there is a non-cached sample already
        (!iter->first->IsCached() && !NonCachedSample))
    {
      if (MAController::IsVerbose())
      {
        MC_LOG("Sound file ended: %s (id: %d, duration: %d)", iter->first->GetDisplayName().c_str(),
               iter->second.get<0>(), (int)(MCTimer::GetElapsedSystemTime() / 1000-Descriptor.get<2>()));
      }
      Playbacks.erase(iter++);
    } else {
      ++iter;
    }
    Counter++;
  }
  // Final mixing into the target buffer
  for (int i = 0; i < BufferSize; ++i)
    target_buffer[i] = (int16_t)MCBound((int32_t)-32768, TempBuffer[i], (int32_t)32767);
}


unsigned int MASpeakerController::GetRemainingPlaybackTime() const
{
  if (Playbacks.empty())
    return 0;

  unsigned int RemainingData = 0;

  for (auto& playback : Playbacks)
  {
    const MA::PlaybackDescriptor& Descriptor = playback.second;
    int SoundSize = playback.first->GetSize();
    int CurrentPosition = Descriptor.get<1>();

    // Find the longest remaining duration from the playback list
    if (CurrentPosition < SoundSize && (unsigned int)(SoundSize-CurrentPosition) > RemainingData)
      RemainingData = (unsigned int)(SoundSize-CurrentPosition);
  }
  // Note: It is multiplied by 2 because RemainingData is based on int16_t size while
  // GetMsecSampleSize() is based on byte size.
  return RemainingData*2 / SpeakerDevice->GetMsecSampleSize();
}


bool MASpeakerController::IsOnlyEffectsPlayed() const
{
  if (Playbacks.empty())
    return false;

  for (auto& playback : Playbacks)
  {
    if (!playback.first->IsEffect())
      return false;
  }
  return true;
}


MA::DeviceGeneratorsMap MASpeakerController::GetSkitTransitionGenerators(MA::SkitBaseSPtr)
{
  return MA::DeviceGeneratorsMap();
}