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

#include "core/MACoreTypes.hpp"
#include "MASoundFile.hpp"

#include <MCLog.hpp>

#include <boost/algorithm/string/join.hpp>
#include <boost/algorithm/string/split.hpp>

namespace MA
{
MCThreadLocalData<MASoundDatabase> SoundDatabase(true);

std::string SoundProfileConfigName("SOUND_PROFILE");
}

MASoundDatabase::MASoundDatabase() : DatabaseFileHandler(nullptr), SoundProfile("csaba")
{
}


MASoundDatabase::~MASoundDatabase()
{
  if (DatabaseFileHandler)
  {
    fclose(DatabaseFileHandler);
    DatabaseFileHandler = nullptr;
  }
}


void MASoundDatabase::SwitchProfile()
{
  if (SoundProfile == "tts")
  {
    SoundProfile = "csaba";
  } else
  if (SoundProfile == "csaba")
  {
    SoundProfile = "marissa";
  } else
  if (SoundProfile == "marissa")
  {
    SoundProfile = "gillian";
  } else
  if (SoundProfile == "gillian")
  {
    SoundProfile = "tts";
  }
  MC_LOG("New sound profile: %s", SoundProfile.c_str());
}


std::string MASoundDatabase::GetProfileName() const
{
  return SoundProfile;
}


void MASoundDatabase::SetProfileName(const std::string& profile_name)
{
  if (profile_name == "tts" || profile_name == "csaba" || profile_name == "marissa" ||
      profile_name == "gillian")
  {
    SoundProfile = profile_name;
  } else {
    SoundProfile = "csaba";
  }
  MC_LOG("New sound profile: %s", SoundProfile.c_str());
}


std::string MASoundDatabase::GetSoundFileName(const std::string& sound_name)
{
  std::string JokerName = sound_name+"_all.raw";
  std::string ExpectedName = sound_name+'_'+SoundProfile+".raw";
  std::string FallbackName = sound_name+"_tts.raw";

  if (Files.find(JokerName) != Files.end())
  {
    return JokerName;
  } else
  if (Files.find(ExpectedName) != Files.end())
  {
    return ExpectedName;
  } else
  if (Files.find(FallbackName) != Files.end())
  {
    return FallbackName;
  }
  return "";
}


MA::SoundBaseSPtr MASoundDatabase::GetSoundFile(const std::string& file_name, bool caching)
{
  const auto Iter = Files.find(file_name);

  if (Iter != Files.end())
  {
    MASoundFile* SoundFile = nullptr;
    MC::StringList StrParts;
    std::string DisplayName;

    boost::split(StrParts, Iter->first, boost::is_any_of("_"));
    StrParts.pop_back();
    DisplayName = boost::algorithm::join(StrParts, "");
    SoundFile = new MASoundFile(DisplayName, DatabaseFileHandler, Iter->second.first, Iter->second.second, caching);
    return MA::SoundBaseSPtr(SoundFile);
  }
  return MA::SoundBaseSPtr();
}


bool MASoundDatabase::SaveToFile(const std::string& file_name, const MC::StringList& sound_file_names,
                                 const MA::BinaryDataSPtrList& sounds)
{
  // Safety checks
  if (file_name.empty() || sound_file_names.size() != sounds.size() || sounds.size() == 0)
    return false;

  for (unsigned int i = 0; i < sounds.size(); ++i)
  {
    if (sound_file_names[i].empty() || !sounds[i].get() || sounds[i]->GetSize() <= 0)
      return false;
  }
  // Build the header
  MC::BinaryDataSPtr HeaderData(new MCBinaryData(30000));
  int HeaderSize = 0;

  HeaderData->IncrementPosition(4);
  for (unsigned int i = 0; i < sounds.size(); ++i)
  {
    HeaderData->AddInt16(sound_file_names[i].size());
    HeaderData->AddString(sound_file_names[i]);
    HeaderData->AddInt32(sounds[i]->GetSize());
  }
  HeaderSize = HeaderData->GetPosition();
  HeaderData->ResetPosition();
  HeaderData->AddInt32(HeaderSize-4);
  // Write the sound database to the file
  FILE* FileHandler = fopen(file_name.c_str(), "wb+");

  fwrite(HeaderData->GetData(), HeaderSize, 1, FileHandler);
  for (unsigned int i = 0; i < sounds.size(); ++i)
  {
    fwrite(sounds[i]->GetData(), sounds[i]->GetSize(), 1, FileHandler);
  }
  fclose(FileHandler);
  return true;
}


MASoundDatabase* MASoundDatabase::LoadFromFile(const std::string& file_name)
{
  // Load sound database from the file
  FILE* FileHandler = fopen(file_name.c_str(), "rb");
  
  if (!FileHandler)
  {
    MC_WARNING("Unable to open a sound database file (%s)... :-|", file_name.c_str());
    return nullptr;
  }
  MASoundDatabase* Database = new MASoundDatabase;
  int FileSize = 0;
  int HeaderSize = 0;
  MC::BinaryDataSPtr FileData(new MCBinaryData(4));

  // Determinate the file size
  fseek(FileHandler, 0, SEEK_END);
  FileSize = (int)ftell(FileHandler);
  // Empty file is an error
  if (FileSize == 0)
  {
    delete Database;
    Database = nullptr;
    fclose(FileHandler);
    FileHandler = nullptr;
    MC_WARNING("Empty sound database file (%s)... :-|", file_name.c_str());
    return nullptr;
  }
  // Go back to the beginning of the file
  fseek(FileHandler, 0, SEEK_SET);
  int Ret = fread(FileData->GetData(), 4, 1, FileHandler);

  HeaderSize = FileData->GetInt32();
  if (HeaderSize > FileSize && Ret != 4)
  {
    delete Database;
    Database = nullptr;
    fclose(FileHandler);
    FileHandler = nullptr;
    MC_WARNING("Corrupt header in the sound database file (%s)... :-|", file_name.c_str());
    return nullptr;
  }
  // Read the header
  FileData->Allocate(HeaderSize);
  Ret = fread(FileData->GetData(), HeaderSize, 1, FileHandler);
  if (HeaderSize > FileSize && Ret != HeaderSize)
  {
    delete Database;
    Database = nullptr;
    fclose(FileHandler);
    FileHandler = nullptr;
    MC_WARNING("Can't read the header in the sound database file (%s)... :-|", file_name.c_str());
    return nullptr;
  }
  while (!FileData->IsPositionAtEnd())
  {
    int StrSize = FileData->GetInt16();
    int FileSize = 0;
    std::string FileName;

    if (StrSize > 0 && StrSize < 100)
    {
      FileName = FileData->GetString(StrSize, "_.");
      FileSize = FileData->GetInt32();
    }
    if (FileName.empty() || FileSize <= 0)
    {
      delete Database;
      Database = nullptr;
      fclose(FileHandler);
      FileHandler = nullptr;
      MC_WARNING("Corrupt header in the sound database file (%s)... :-|", file_name.c_str());
      return nullptr;
    }
    Database->Files.insert(std::make_pair(FileName, MA::SoundFileInfo(0, FileSize)));
  }
  // Parse the rest of the database
  for (auto& file : Database->Files)
  {
    file.second.first = (int)ftell(FileHandler);
    if (fseek(FileHandler, file.second.second, SEEK_CUR) == 0 && (int)ftell(FileHandler) > FileSize)
    {
      delete Database;
      Database = nullptr;
      fclose(FileHandler);
      FileHandler = nullptr;
      MC_WARNING("Unexpected EOF in the sound database file (%s)... :-|", file_name.c_str());
      return nullptr;
    }
  }
  if ((int)ftell(FileHandler) < FileSize)
  {
    delete Database;
    Database = nullptr;
    fclose(FileHandler);
    FileHandler = nullptr;
    MC_WARNING("Too much data in the sound database file (%s)... :-|", file_name.c_str());
    return nullptr;
  }
  Database->DatabaseFileHandler = FileHandler;
  return Database;
}