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

#include <ml/MACollectedData.hpp>
#include <network/MAStreamPacketCoder.hpp>
#include <types/MAHead.hpp>
#include <types/MARobotState.hpp>
#include <types/MATorso.hpp>

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

#include <MEImage.hpp>

#include <qjsonobject.h>
#include <qstringlist.h>
#include <qtextstream.h>
#include <qthread.h>

#include <boost/scoped_ptr.hpp>

namespace
{
// Backward compatibility for old sessions
bool BackwardCompatibility = false;
}

MCBinaryData* MPDecodeImage(const MCBinaryData& binary_data)
{
  MEImage Image;

  if (Image.Decompress(binary_data))
    return Image.ExportRawImageData();

  return nullptr;
}


QJsonObject* MPConvertCollectedDataToJson(MACollectedData& collected_data)
{
  QJsonObject* Object = new QJsonObject;
  MC::BinaryDataSPtr BinaryData(collected_data.Encode());

  Object->insert("objectType", QString("objects.")+QString::fromStdString(collected_data.GetName()));
  Object->insert("sessionId", collected_data.GetSessionID());
  Object->insert("collectionId", collected_data.GetCollectionID());
  Object->insert("data", QString::fromStdString(BinaryData->ToBase64()));
  return Object;
}


QJsonObject* MPConvertCollectedDataToJsonQuery(MACollectedData& collected_data)
{
  QJsonObject* QueryObject = new QJsonObject;
  QJsonObject Object;
  MC::BinaryDataSPtr BinaryData(collected_data.Encode());

  Object["sessionId"] = collected_data.GetSessionID();
  Object["collectionId"] = collected_data.GetCollectionID();
  QueryObject->insert("objectType", QString("objects.")+QString::fromStdString(collected_data.GetName()));
  QueryObject->insert("query", Object);
  return QueryObject;
}


MACollectedData* MPConvertJsonToCollectedData(QJsonObject& json_object)
{
  MC::BinaryDataSPtr BinaryData(new MCBinaryData);

  BinaryData->FromBase64(json_object.value("data").toString().toStdString());
  return MACollectedData::Decode(*BinaryData);
}


MPLogEntryMap::MPLogEntryMap() : MSData("MPLogEntryMap"), MP::LogEntryMap()
{
}


MPCursorPosition::MPCursorPosition() : MSData("MPCursorPosition"), Position(0)
{
}


MPRecord::MPRecord() : ID(-1)
{
}


MCBinaryData* MPRecord::DecodeJpegImage() const
{
  if (!Image.get())
    return nullptr;

  return MPDecodeImage(*Image);
}

std::string MPRecordsContainer::RobotStateVariableMap;

MPRecordsContainer::MPRecordsContainer() : MSData("MPRecordsContainer")
{
}


const MP::RecordPtrList& MPRecordsContainer::GetRecords() const
{
  return Records;
}


const MP::PacketPtrList& MPRecordsContainer::GetPackets() const
{
  return Packets;
}


bool MPRecordsContainer::IsEmpty() const
{
  return Records.empty();
}


void MPRecordsContainer::Clear()
{
  Records.clear();
  Packets.clear();
}


MA::IntIntSortedMap MPRecordsContainer::AddDataFromPacket(MCBinaryData& packet)
{
  boost::scoped_ptr<MAStreamPacketCoder> Coder(MAStreamPacketCoder::Decode(packet));
  MA::IntIntSortedMap RecordIDsTimestamps;

  if (Coder.get() == nullptr)
  {
    MC_WARNING("Cannot decode packet into robot state record (packet size: %d)", packet.GetSize());
    return RecordIDsTimestamps;
  }
  // Clone the packet
  MCBinaryData* Packet = new MCBinaryData;

  Packet->Clone(packet);
  Packets.push_back(MP::PacketPtr(Packet));
  // Note: With low vector sizes, no performance difference between the iterating and [] usage
  MA::BinaryDataSPtrList RobotStates = Coder->GetRobotStates();
  MA::BinaryDataSPtrList Images = Coder->GetImages();
  MA::BinaryDataSPtrList LogMessages = Coder->GetLogMessages();
  MA::BinaryDataSPtrList Sounds = Coder->GetSounds();

  for (int i = 0; i < Coder->GetPacketCapacity(); ++i)
  {
    MPRecord* Record = new MPRecord;

    Record->ID = -1;
    if (Images[i])
    {
      MCBinaryData* ImageData = new MCBinaryData;

      ImageData->Clone(*Images[i]);
      Record->Image = MP::ImagePtr(ImageData);
    }
    if (RobotStates[i])
    {
      // This is left for backward compatibility of old saved sessions (it may lead to crashes)
      if (BackwardCompatibility)
      {
        MCBinaryData FinalPacket;

        MCZipper::DecompressQuickLz(*RobotStates[i], FinalPacket, true);
        *RobotStates[i] = FinalPacket;
      }
      if (RobotStateVariableMap.empty())
      {
        Record->RobotState = MP::RobotStatePtr(MARobotState::Decode(*RobotStates[i]));
        if (Record->RobotState.get() != nullptr)
        {
          RobotStateVariableMap = Record->RobotState->GetDecodedVariableMap();
        } else {
          // Check if the packet can be decoded to enable the backward compatibility mode
          MCBinaryData FinalPacket;

          MCZipper::DecompressQuickLz(*RobotStates[i], FinalPacket, true);
          Record->RobotState = MP::RobotStatePtr(MARobotState::Decode(FinalPacket));
          *RobotStates[i] = FinalPacket;
          if (Record->RobotState.get() != nullptr)
          {
            RobotStateVariableMap = Record->RobotState->GetDecodedVariableMap();
            BackwardCompatibility = true;
          }
        }
      } else {
        Record->RobotState = MP::RobotStatePtr(MARobotState::Decode(*RobotStates[i], RobotStateVariableMap));
      }
      if (Record->RobotState)
      {
        int Milliseconds = Record->RobotState->Torso->Timestamp.ToMilliseconds();

        Record->ID = Record->RobotState->Torso->CycleID;
        RecordIDsTimestamps.insert(std::pair<int, int>(Record->ID, Milliseconds));
        MCBinaryData* RobotStateData = new MCBinaryData;

        RobotStateData->Clone(*RobotStates[i]);
        Record->RobotStateBinaryData = MC::BinaryDataSPtr(RobotStateData);
      }
    }
    if (LogMessages[i])
    {
      QStringList* Messages = new QStringList;

      // Decode log messages
      QByteArray LogMessageData((const char*)LogMessages[i]->GetData(), LogMessages[i]->GetSize());
      QTextStream Stream(&LogMessageData);
      QString Line;

      do
      {
        Line = Stream.readLine();
        if (!Line.isNull())
        {
          *Messages += Line;
        }
      } while (!Line.isNull());
      Record->LogMessages = MP::LogMessagesPtr(Messages);
    }
    if (Sounds[i])
    {
      MCBinaryData* SoundData = new MCBinaryData;

      SoundData->Clone(*Sounds[i]);
      Record->SoundData = MC::BinaryDataSPtr(SoundData);
    }
    Records.push_back(MP::RecordPtr(Record));
  }
  return RecordIDsTimestamps;
}


MPMissingPackets::MPMissingPackets() : MSData("MPMissingPackets")
{
}


MPRecoveredPackets::MPRecoveredPackets() : MSData("MPRecoveredPackets")
{
}


MPStreamMarkers::MPStreamMarkers() : MSData("MPStreamMarkers")
{
}


MPTimestampList::MPTimestampList() : MSData("MPTimestampList"), MC::IntList()
{
}