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

#include "sound/MASoundData.hpp"

#include <MCLog.hpp>
#include <MCThreadLocalData.hpp>

#if defined(LIBARCHIVE_USE_INTERNAL)
#include <archive.h> //krazy:exclude=includes
#include <archive_entry.h> //krazy:exclude=includes
// Hack to include private headers from libarchive
#define __LIBARCHIVE_BUILD
#include <archive_private.h>
#else
#include <archive.h>
#include <archive_entry.h>
#endif

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

namespace
{
// Temporary write buffer
MCThreadLocalData<MCBinaryData> WriteBuffer(true);

void CheckStaticVariables()
{
  if (unlikely(!WriteBuffer.get()))
    WriteBuffer.reset(new MCBinaryData(20000));
}
}

MASkit::MASkit() : AudioStart(0)
{
}


MASkit::MASkit(const std::string& name, MA::MotionSkitSPtr motion, MA::LedSkitSPtr led,
               MC::BinaryDataSPtr sound) : Name(name), MotionSkit(motion), LedSkit(led),
  SoundData(sound), AudioStart(0)
{
}


std::string MASkit::GetName() const
{
  return Name;
}


int MASkit::GetAudioStart() const
{
  return AudioStart;
}


int MASkit::GetAudioDuration() const
{
  return (!SoundData.get() ? 0 : SoundData->GetSize() / 16);
}


int MASkit::GetDuration() const
{
  int Duration = 0;

  Duration = MCMax(Duration, GetAudioStart()+GetAudioDuration());
  if (MotionSkit.get())
    Duration = MCMax(Duration, MotionSkit->GetDuration());
  if (LedSkit.get())
    Duration = MCMax(Duration, LedSkit->GetDuration());

  return Duration;
}


void MASkit::Dump() const
{
  MC_LOG("++ %s skit content ++", Name.c_str());
  MC_LOG("++ Overall duration: %d msec ++", GetDuration());
  // Dump motion skit
  if (MotionSkit.get())
  {
    MotionSkit->Dump();
  } else {
    MC_LOG("No motion data");
  }
  // Dump LED skit
  if (LedSkit.get())
  {
    LedSkit->Dump();
  } else {
    MC_LOG("No LED data");
  }
  // Dump sound skit
  if (SoundData.get())
  {
    MC_LOG("-- %s sound --", Name.c_str());
    MC_LOG("Start: %d msec", AudioStart);
    MC_LOG("Duration: %d msec", GetAudioDuration());
  } else {
    MC_LOG("No sound data");
  }
}


MA::MotionSkitSPtr MASkit::GetMotionSkit()
{
  return MotionSkit;
}


MA::LedSkitSPtr MASkit::GetLedSkit()
{
  return LedSkit;
}


MC::BinaryDataSPtr MASkit::GetSoundData()
{
  return SoundData;
}


MA::SkitSPtr MASkit::CloneMirrored(const std::string& mirrored_name)
{
  if (!MotionSkit.get())
  {
    MC_WARNING("This skit (%s) has no motions inside to be mirrored", Name.c_str());
    return MA::SkitSPtr();
  }
  if (mirrored_name.empty())
  {
    MC_WARNING("Cannot create a noname mirrored skit from %s", Name.c_str());
    return MA::SkitSPtr();
  }
  MA::MotionSkitSPtr NewMotion(MotionSkit->CloneMirrored());

  return MA::SkitSPtr(new MASkit(mirrored_name, NewMotion, LedSkit, SoundData));
}


MCBinaryData* MASkit::EncodeMtnToAibFormat(const MCBinaryData& motion_data)
{
  boost::scoped_ptr<MAMotionSkit> MotionSkit(MAMotionSkit::DecodeMtnData(motion_data));

  if (!MotionSkit.get())
  {
    MC_WARNING("Invalid motion data cannot be converted to aib format");
    return nullptr;
  }
  archive* Archive(archive_write_new());
  archive_entry* ArchiveEntry = nullptr;
  size_t FinalSize = 0;

  archive_write_set_format_zip(Archive);
  archive_write_add_filter_none(Archive);
  CheckStaticVariables();
  archive_write_open_memory(Archive, WriteBuffer->GetData(), WriteBuffer->GetSize(),
                            &FinalSize);

  ArchiveEntry = archive_entry_new();
  archive_entry_copy_pathname(ArchiveEntry,
                              std::string("Motion/"+MotionSkit->GetSkitName()+".mtn").c_str());
  archive_entry_set_mode(ArchiveEntry, AE_IFREG | 0755);
  archive_entry_set_size(ArchiveEntry, motion_data.GetSize());
  archive_write_header(Archive, ArchiveEntry);
  archive_entry_free(ArchiveEntry);
  archive_write_data(Archive, motion_data.GetData(), motion_data.GetSize());

  archive_write_close(Archive);
  archive_write_free(Archive);
  // Get the final data out
  MCBinaryData* FinalData = new MCBinaryData((int)FinalSize);

  memcpy(FinalData->GetData(), WriteBuffer->GetData(), FinalData->GetSize());
  return FinalData;
}


MASkit* MASkit::DecodeAibData(const MCBinaryData& binary_data)
{
  MCBinaryData& BinaryData = const_cast<MCBinaryData&>(binary_data);
  archive* Archive(archive_read_new());
  archive_entry* ArchiveEntry = nullptr;

#if __cplusplus >= 201103L
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
  archive_read_support_format_zip(Archive);
  archive_read_support_compression_gzip(Archive);
  archive_read_support_compression_none(Archive);
#if __cplusplus >= 201103L
#pragma GCC diagnostic pop
#endif
  int result = archive_read_open_memory(Archive, BinaryData.GetData(), BinaryData.GetSize());

  // Data can not be read as zip format
  if (result != 0)
  {
    MC_WARNING("Binary data can not be read as aib (zip) format (error: %d)", result);
    archive_read_free(Archive);
    return nullptr;
  }
  MASkit* Skit = new MASkit;

  // Process the file headers inside the zip format
  while (archive_read_next_header(Archive, &ArchiveEntry) == 0)
  {
    std::string FileName(archive_entry_pathname(ArchiveEntry));

//    MC_LOG("Extract %s", FileName.c_str());
    if (Skit->Name.empty() &&
        (boost::algorithm::iends_with(FileName, ".mtn") ||
         boost::algorithm::iends_with(FileName, ".wav") ||
         boost::algorithm::iends_with(FileName, ".mid") ||
         boost::algorithm::iends_with(FileName, ".info") ||
         boost::algorithm::iends_with(FileName, ".led")))
    {
      MC::StringList Strs;

      Skit->Name = FileName;
      boost::split(Strs, Skit->Name, boost::is_any_of("/"));
      if (Strs.size() == 2)
      {
        Skit->Name = Strs[1];
        Skit->Name.erase(Skit->Name.size()-4, 4);
      }
    }
    boost::scoped_ptr<MCBinaryData> FileData(new MCBinaryData((int)archive_entry_size(ArchiveEntry)));

    result = archive_read_data(Archive, FileData->GetData(), FileData->GetSize());
    if (result != FileData->GetSize())
    {
      continue;
    } else
    if (boost::algorithm::iends_with(FileName, ".mtn"))
    {
      Skit->MotionSkit.reset(MAMotionSkit::DecodeMtnData(*FileData));
    } else
    if (boost::algorithm::iends_with(FileName, ".info"))
    {
      Skit->AudioStart = MASkit::GetAudioStartFromSkitterInfo(*FileData);
    } else
    if (boost::algorithm::iends_with(FileName, ".wav"))
    {
      // Convert the audio data from 8 bit, 8 kHz -> 16 bit, 16 kHz
      MC::BinaryDataSPtr TempData(new MCBinaryData((FileData->GetSize()-44)*2, 0));
      MC::DoubleList ResampleData, RightChannel;

      for (int i = 0; i < TempData->GetSize() / 2; ++i)
        ((int16_t*)(void*)TempData->GetData())[i] = ((int16_t)FileData->GetData()[44+i]-128)*253;

      ResampleData = MASoundData::ConvertToDouble(*TempData);
      ResampleData = MASoundData::Resample(ResampleData, 8000, MASoundData::SampleRateOnAIBO);
      Skit->SoundData.reset(MASoundData::ConvertDoubleToRaw(ResampleData, RightChannel));
    } else
    if (boost::algorithm::iends_with(FileName, ".led"))
    {
      MC::StringList Strs;

      boost::split(Strs, FileName, boost::is_any_of("/"));
      boost::split(Strs, Strs.back(), boost::is_any_of("."));
      Skit->LedSkit.reset(MALedSkit::DecodeLedData(*FileData, Strs[0]));
    }
  }
  archive_read_close(Archive);
  archive_read_free(Archive);
  if (!Skit->MotionSkit.get() && !Skit->SoundData.get() && !Skit->LedSkit.get())
  {
    MC_WARNING("No motion/LED/sound skit found in aib decoding");
    delete Skit;
    return nullptr;
  }
  MC_LOG("Decoded skit: %s", Skit->Name.c_str());
  return Skit;
}


int MASkit::GetAudioStartFromSkitterInfo(const MCBinaryData& binary_data)
{
  std::istringstream Stream;

  Stream.rdbuf()->pubsetbuf((char*)binary_data.GetData(), binary_data.GetSize());
  while (Stream.good())
  {
    std::string Line;

    std::getline(Stream, Line);
    if (boost::algorithm::istarts_with(Line, "SOUNDSTART"))
    {
      MC::StringList Strs;

      boost::split(Strs, Line, boost::is_any_of(" "));
      if (Strs.size() >= 2)
      {
        return MCStrConvert<int>(Strs[1])*16;
      }
      break;
    }
  }
  return -1;
}