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

#include "MAMotionSkit.hpp"
#include "MASkit.hpp"

#include <MCBinaryData.hpp>
#include <MCLog.hpp>
#include <MCZipper.hpp>

#include <boost/scoped_ptr.hpp>

namespace MA
{
MCThreadLocalData<MASkitDatabase> SkitDatabase(true);
}

namespace
{
static std::string SkitDatabaseID = "SkitDatabase";
}

void MASkitDatabase::AddSkit(MA::SkitSPtr skit)
{
  if (!skit.get())
  {
    MC_WARNING("Cannot add a skit. Empty pointer.");
    return;
  }
  if (GetSkit(skit->GetName()).get())
  {
    MC_WARNING("Cannot add a skit (%s). An other skit with the same name is already in the database.",
               skit->GetName().c_str());
    return;
  }
  Skits.push_back(skit);
}


MA::SkitSPtr MASkitDatabase::GetSkit(const std::string& name)
{
  if (name.empty())
  {
    MC_WARNING("Cannot get a noname skit.");
    return MA::SkitSPtr();
  }
  for (auto& skit : Skits)
  {
//    MC_LOG("Skit query: %s", Skits[i]->GetName().c_str());
    if (skit->GetName() == name)
    {
      return skit;
    }
  }
  return MA::SkitSPtr();
}


void MASkitDatabase::MirrorSkit(const std::string& name, const std::string& mirrored_name)
{
  if (name.empty())
  {
    MC_WARNING("Cannot mirror a noname skit.");
    return;
  }
  if (mirrored_name.empty())
  {
    MC_WARNING("Noname mirrored skit cannot be created.");
    return;
  }
  if (GetSkit(mirrored_name).get())
  {
    MC_WARNING("Cannot add a new mirrored skit (%s) because it is already in the database.",
               mirrored_name.c_str());
    return;
  }
  MA::SkitSPtr Skit(GetSkit(name));

  if (!Skit.get())
  {
    MC_WARNING("Cannot find the skit (%s) to be mirrored.", name.c_str());
    return;
  }
  MA::SkitSPtr NewSkit(Skit->CloneMirrored(mirrored_name));

  // MASkit::CloneMirrored() already drops a warning thus it is not needed here again
  if (NewSkit.get())
    AddSkit(NewSkit);
}


void MASkitDatabase::RemoveSkit(const std::string& name)
{
  if (name.empty())
    return;

  for (auto iter = Skits.begin(); iter != Skits.end(); ++iter)
  {
    if ((*iter)->GetName() == name)
    {
      Skits.erase(iter);
      return;
    }
  }
  MC_WARNING("Cannot remove a non-existing skit (%s)", name.c_str());
}


void MASkitDatabase::CreateMirroredSkits()
{
  MirrorSkit("turn_right", "turn_left");
  MirrorSkit("lie_exercise1", "lie_exercise1_reverse");
  MirrorSkit("lie_exercise2", "lie_exercise2_reverse");
  MirrorSkit("lie_exercise3", "lie_exercise3_reverse");
  MirrorSkit("stand_fart1", "stand_fart1_reverse");
  MirrorSkit("stand_fart2", "stand_fart2_reverse");
}


bool MASkitDatabase::SaveToFile(const std::string& file_name, const MA::BinaryDataSPtrList& skits)
{
  int OverallDataSize = 0;

  // Verify that the motion data is valid and calculate their overall size
  for (unsigned int i = 0; i < skits.size(); ++i)
  {
    boost::scoped_ptr<MASkit> Skit(MASkit::DecodeAibData(*skits[i]));

    if (!Skit.get())
    {
      return false;
    }
    OverallDataSize += skits[i]->GetSize();
  }
  int FinalDataSize = SkitDatabaseID.size()+OverallDataSize+skits.size()*4;
  MC::BinaryDataSPtr FinalData(new MCBinaryData(FinalDataSize));

  FinalData->AddString(SkitDatabaseID);
  for (unsigned int i = 0; i < skits.size(); ++i)
  {
    MCBinaryData& MotionData = const_cast<MCBinaryData&>(*skits[i]);
    int OldPosition = MotionData.GetPosition();

    FinalData->AddInt32(skits[i]->GetSize());
    MotionData.SetPosition(0);
    MotionData.WriteData(*FinalData, MotionData.GetSize());
    MotionData.SetPosition(OldPosition);
  }
  MC::BinaryDataSPtr CompressedData(new MCBinaryData);

  MCZipper::CompressZlib(*FinalData, *CompressedData, MC::FastCompression);
  return CompressedData->SaveToFile(file_name);
}


MASkitDatabase* MASkitDatabase::LoadFromFile(const std::string& file_name)
{
  MC::BinaryDataSPtr FileData(new MCBinaryData);
  MC::BinaryDataSPtr UncompressedData(new MCBinaryData);

  if (!FileData->LoadFromFile(file_name))
  {
    return nullptr;
  }
  MCZipper::DecompressZlib(*FileData, *UncompressedData);
  if (UncompressedData->GetString(SkitDatabaseID.size()) != SkitDatabaseID)
  {
    return nullptr;
  }
  MASkitDatabase* SkitDatabase = new MASkitDatabase;

  while (!UncompressedData->IsPositionAtEnd())
  {
    int SliceSize = UncompressedData->GetInt32();

    if (SliceSize < 0 || SliceSize > UncompressedData->GetSize()-UncompressedData->GetPosition())
    {
      delete SkitDatabase;
      return nullptr;
    }
    MC::BinaryDataSPtr SkitData(new MCBinaryData(SliceSize));

    UncompressedData->WriteData(*SkitData, SliceSize);
    SkitData->ResetPosition();
    SkitDatabase->AddSkit(MA::SkitSPtr(MASkit::DecodeAibData(*SkitData)));
  }
  return SkitDatabase;
}