MASoundData.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 "MASoundData.hpp"

#include "MALossyConverter.hpp"

#include <MCSampleStatistics.hpp>

#include <libresample.h>

#include <WaveFile.h>

#include <boost/algorithm/string/predicate.hpp>
#include <boost/scoped_ptr.hpp>

const int MASoundData::SampleRateOnAIBO = 16000;

int MASoundData::GetFileDuration(const std::string& file_name)
{
  WaveFile AudioFile(file_name);

  if (AudioFile.GetBitsPerSample() != 16 || (int)AudioFile.GetAudioFormat() != 1 ||
      AudioFile.GetNumChannels() < 1 || AudioFile.GetNumChannels() > 2)
  {
    MC_WARNING("Only 16 bit mono or stereo PCM Wave files are supported (file: %s)!", file_name.c_str());
    return 0;
  }
  float Divider = (float)2*AudioFile.GetNumChannels()*AudioFile.GetSampleRate() / 1000;

  return (int)((float)MCGetFileSize(file_name) / Divider);
}


bool MASoundData::LoadFromFile(const std::string& file_name, MC::DoubleList& left_channel,
                               MC::DoubleList& right_channel, int compression, int bitrate)
{
  // Read the audio data
  MC::BinaryDataSPtr FileData(new MCBinaryData());
  int FileSampleRate = 0;
  int Channels = 0;

  if (boost::algorithm::iends_with(file_name, ".wav"))
  {
    WaveFile AudioFile(file_name);

    if (AudioFile.GetBitsPerSample() != 16 || (int)AudioFile.GetAudioFormat() != 1 ||
        AudioFile.GetNumChannels() < 1 || AudioFile.GetNumChannels() > 2 ||
        AudioFile.GetSampleRate() == 0)
    {
      MC_WARNING("Only 16 bit mono or stereo PCM Wave files are supported (file: %s)!", file_name.c_str());
      return false;
    }
    FileSampleRate = (int)AudioFile.GetSampleRate();
    Channels = AudioFile.GetNumChannels();
    FileData->Allocate(AudioFile.GetDataSize());
    memcpy(FileData->GetData(), AudioFile.GetData(), (int)AudioFile.GetDataSize());
  } else
  if (boost::algorithm::iends_with(file_name, ".ogg") || boost::algorithm::iends_with(file_name, ".mp3"))
  {
    MC::BinaryDataSPtr EncodedData(new MCBinaryData);

    EncodedData->LoadFromFile(file_name);
    if (boost::algorithm::iends_with(file_name, ".ogg"))
    {
      FileData.reset(MALossyConverter::DecodeFromOggVorbis(*EncodedData, FileSampleRate, Channels));
    } else
    if (boost::algorithm::iends_with(file_name, ".mp3"))
    {
      FileData.reset(MALossyConverter::DecodeFromMp3(*EncodedData, 0, FileSampleRate, Channels));
    }
    if (Channels < 1 || Channels > 2 || FileSampleRate == 0)
    {
      MC_WARNING("Only mono or stereo Ogg Vorbis/mp3 files are supported (file: %s)!", file_name.c_str());
      return false;
    }
  }
  // Convert audio data to double
  MC::BinaryDataSPtr CompressedFileData;
  MC::DoubleList FileDataDouble;

  if (compression == 1)
  {
    CompressedFileData.reset(MALossyConverter::EncodeToOggVorbis(*FileData, FileSampleRate,
                                                                 Channels, bitrate));
    if (!CompressedFileData.get())
    {
      MC_WARNING("Lossy Ogg Vorbis encoding failed: %s\n", file_name.c_str());
    } else {
      FileData.reset(MALossyConverter::DecodeFromOggVorbis(*CompressedFileData, FileSampleRate, Channels));
    }
  } else
  if (compression == 2)
  {
    CompressedFileData.reset(MALossyConverter::EncodeToMp3(*FileData, FileSampleRate,
                                                           Channels, bitrate));
    if (!CompressedFileData.get())
    {
      MC_WARNING("Lossy mp3 encoding failed: %s\n", file_name.c_str());
    } else {
      FileData.reset(MALossyConverter::DecodeFromMp3(*CompressedFileData, FileData->GetSize(),
                                                     FileSampleRate, Channels));
    }
  }
  FileDataDouble = MASoundData::ConvertToDouble(*FileData);
  // Split the channels if needs be
  if (Channels == 1)
  {
    left_channel = FileDataDouble;
    right_channel.clear();
  } else {
    left_channel = MCNthItemsFromContainer(FileDataDouble, 1, 2);
    right_channel = MCNthItemsFromContainer(FileDataDouble, 2, 2);
  }
  FileDataDouble.clear();
  // Resample the channels if needs be
  if (FileSampleRate != SampleRateOnAIBO)
  {
    left_channel = MASoundData::Resample(left_channel, FileSampleRate, SampleRateOnAIBO);
    if (!right_channel.empty())
      right_channel = MASoundData::Resample(right_channel, FileSampleRate, SampleRateOnAIBO);
  }
  return true;
}


MC::DoubleList MASoundData::ConvertToDouble(const MCBinaryData& raw_data)
{
  MC::DoubleList NewData;

  NewData.resize(raw_data.GetSize() / 2);
  for (int i = 0; i < raw_data.GetSize() / 2; ++i)
  {
    NewData[i] = (double)(((int)raw_data.GetData()[i*2+1] << 8) | (int)raw_data.GetData()[i*2]) / ((float)0x8000);
    if (NewData[i] > 1)
      NewData[i] -= 2;
  }
  return NewData;
}


MCBinaryData* MASoundData::ConvertDoubleToRaw(MC::DoubleList& left_channel, MC::DoubleList& right_channel)
{
  MCBinaryData* RawData = nullptr;
  const unsigned int Count = MCMax(left_channel.size(), right_channel.size());

  RawData = new MCBinaryData((int)(left_channel.size()+right_channel.size())*2);
  for (unsigned int i = 0; i < Count; ++i)
  {
    double Data = 0;

    if (i < left_channel.size())
    {
      Data = left_channel[i];
      if (Data < 0)
        Data += 2;
    }
    RawData->AddUChar((unsigned char)((int)(Data*32768) % 256));
    RawData->AddUChar((unsigned char)((int)(Data*32768) / 256));

    if (right_channel.size() == 0)
      continue;

    Data = 0;
    if (i < right_channel.size())
    {
      Data = right_channel[i];
      if (Data < 0)
        Data += 2;
    }
    RawData->AddUChar((unsigned char)((int)(Data*32768) % 256));
    RawData->AddUChar((unsigned char)((int)(Data*32768) / 256));
  }
  return RawData;
}


void MASoundData::RemoveLeadingTrailingSilence(MC::DoubleList& audio_data, unsigned int frequency)
{
  int WindowSize = 10*(int)frequency / 10000;
  MCSampleStatistic<double>* PowerStatistic = new MCMedian<double>;
  boost::scoped_ptr<MCSamples<double> > PowerSamples(new MCSamples<double>(WindowSize, *PowerStatistic));

  while ((int)audio_data.size() > WindowSize*2)
  {
    int DataSize = audio_data.size();
    float LeadingPower = 0;
    float TrailingPower = 0;

    for (int i = 0; i < WindowSize; ++i)
    {
      *PowerSamples << audio_data[i];
    }
    LeadingPower = PowerStatistic->GetResult();
    for (int i = 0; i < WindowSize; ++i)
    {
      *PowerSamples << audio_data[DataSize-i];
    }
    TrailingPower = PowerStatistic->GetResult();
    if (LeadingPower >= 10 && TrailingPower >= 10)
      return;
    if (LeadingPower <= 10)
      audio_data.erase(audio_data.begin(), audio_data.begin()+WindowSize);
    if (TrailingPower <= 10)
      audio_data.erase(audio_data.end()-WindowSize, audio_data.end());
  }
}


MC::DoubleList MASoundData::Resample(const MC::DoubleList& audio_data, int original_frequency, int new_frequency)
{
  if (audio_data.empty())
    return MC::DoubleList();

  // Convert the audio data to float
  MC::FloatList OldData;
  double Factor = (double)new_frequency / original_frequency;

  OldData.resize(audio_data.size());
  for (unsigned int i = 0; i < OldData.size(); ++i)
  {
    OldData[i] = (float)audio_data[i];
  }
  // Resample the data
  int MaxDataSize = (int)(ceil((float)audio_data.size()*Factor)+100);
  MC::FloatList ResampleData;
  MC::DoubleList FinalData;
  void* handle = resample_open(1, Factor, Factor);
  int UsedBytes = 0, OutputCount = 0;

  ResampleData.resize(MaxDataSize);
  OutputCount = resample_process(handle, Factor, &OldData[0], OldData.size(), 0, &UsedBytes,
                                 &ResampleData[0], ResampleData.size());
  resample_close(handle);
  FinalData.resize(OutputCount);
  for (unsigned int i = 0; i < FinalData.size(); ++i)
  {
    FinalData[i] = (float)ResampleData[i];
  }
  return FinalData;
}


unsigned int MASoundData::GetWindowSize(unsigned int frequency)
{
  unsigned int WindowSize = 0;

  for (WindowSize = 1; WindowSize < frequency*30 / 1000; WindowSize *= 2)
  { }
  return WindowSize;
}


bool MASoundData::Join(const MCBinaryData& left_channel, const MCBinaryData& right_channel,
                       MCBinaryData& stereo)
{
  if (left_channel.IsEmpty() || right_channel.IsEmpty() ||
      left_channel.GetSize() != right_channel.GetSize() || left_channel.GetSize() % 2 != 0)
  {
    MC_WARNING("The data count of the channels are not equal and divisible by 2 (left: %d, right: %d)",
               left_channel.GetSize(), right_channel.GetSize());
    return false;
  }
  stereo.Allocate(left_channel.GetSize()*2);
  char* StereoDataPtr = (char*)stereo.GetData();
  char* LeftChannelDataPtr = (char*)left_channel.GetData();
  char* RightChannelDataPtr = (char*)right_channel.GetData();

  for (int i = 0; i < stereo.GetSize() / 4; ++i)
  {
    memcpy(StereoDataPtr, LeftChannelDataPtr, 2);
    memcpy(StereoDataPtr+2, RightChannelDataPtr, 2);
    LeftChannelDataPtr += 2;
    RightChannelDataPtr += 2;
    StereoDataPtr += 4;
  }
  return true;
}


float MASoundData::CalculatePowerDb(const MC::DoubleList& audio_data)
{
  if (audio_data.empty())
    return 0;

  // This calculation is based on the Audacity sources and it was verified against
  // the SNRs of the NAR dataset (https://team.inria.fr/perception/nard) published in
  // Maxime Janvier (2014): Sound Representation and Classification Benchmark for Domestic Robots
  float Max = MCCalculateVectorStatistic(audio_data, *new MCMaximum<double>);
  float Min = MCCalculateVectorStatistic(audio_data, *new MCMinimum<double>);
  float Peak = (MCAbs(Min) > MCAbs(Max) ? MCAbs(Min) : MCAbs(Max));

  return 20*log10(Peak);
}


float MASoundData::CalculateSnr(const float signal_power_db, const float noise_power_db)
{
  if (MCIsFloatInfinity(signal_power_db) || MCIsFloatInfinity(noise_power_db))
    return MCFloatInfinity();

  return signal_power_db-noise_power_db;
}