Visualization.h

/*
 *  Copyright (C) 2005-2018 Team Kodi
 *  This file is part of Kodi - https://kodi.tv
 *
 *  SPDX-License-Identifier: GPL-2.0-or-later
 *  See LICENSES/README.md for more information.
 */
 
#pragma once
 
#include "../AddonBase.h"
#include "../c-api/addon-instance/visualization.h"
#include "../gui/renderHelper.h"
 
#ifdef __cplusplus
namespace kodi
{
namespace addon
{
 
//==============================================================================
class VisualizationTrack
{
  friend class CInstanceVisualization;
public:
  VisualizationTrack() = default;
  VisualizationTrack(const VisualizationTrack& tag) { *this = tag; }
 
  VisualizationTrack& operator=(const VisualizationTrack& right)
  {
    if (&right == this)
      return *this;
 
    m_title = right.m_title;
    m_artist = right.m_artist;
    m_album = right.m_album;
    m_albumArtist = right.m_albumArtist;
    m_genre = right.m_genre;
    m_comment = right.m_comment;
    m_lyrics = right.m_lyrics;
 
    m_trackNumber = right.m_trackNumber;
    m_discNumber = right.m_discNumber;
    m_duration = right.m_duration;
    m_year = right.m_year;
    m_rating = right.m_rating;
    return *this;
  }
 
 
  void SetTitle(const std::string& title) { m_title = title; }
 
  const std::string& GetTitle() const { return m_title; }
 
  void SetArtist(const std::string& artist) { m_artist = artist; }
 
  const std::string& GetArtist() const { return m_artist; }
 
  void SetAlbum(const std::string& album) { m_album = album; }
 
  const std::string& GetAlbum() const { return m_album; }
 
  void SetAlbumArtist(const std::string& albumArtist) { m_albumArtist = albumArtist; }
 
  const std::string& GetAlbumArtist() const { return m_albumArtist; }
 
  void SetGenre(const std::string& genre) { m_genre = genre; }
 
  const std::string& GetGenre() const { return m_genre; }
 
  void SetDuration(int duration) { m_duration = duration; }
 
  int GetDuration() const { return m_duration; }
 
  void SetTrack(int trackNumber) { m_trackNumber = trackNumber; }
 
  int GetTrack() const { return m_trackNumber; }
 
  void SetDisc(int discNumber) { m_discNumber = discNumber; }
 
  int GetDisc() const { return m_discNumber; }
 
  void SetYear(int year) { m_year = year; }
 
  int GetYear() const { return m_year; }
 
  void SetLyrics(const std::string& lyrics) { m_lyrics = lyrics; }
 
  const std::string& GetLyrics() const { return m_lyrics; }
 
  void SetRating(int rating) { m_rating = rating; }
 
  int GetRating() const { return m_rating; }
 
  void SetComment(const std::string& comment) { m_comment = comment; }
 
  const std::string& GetComment() const { return m_comment; }
 
 
private:
  VisualizationTrack(const KODI_ADDON_VISUALIZATION_TRACK* tag)
  {
    if (!tag)
      return;
 
    m_title = tag->title ? tag->title : "";
    m_artist = tag->artist ? tag->artist : "";
    m_album = tag->album ? tag->album : "";
    m_albumArtist = tag->albumArtist ? tag->albumArtist : "";
    m_genre = tag->genre ? tag->genre : "";
    m_comment = tag->comment ? tag->comment : "";
    m_lyrics = tag->lyrics ? tag->lyrics : "";
 
    m_trackNumber = tag->trackNumber;
    m_discNumber = tag->discNumber;
    m_duration = tag->duration;
    m_year = tag->year;
    m_rating = tag->rating;
  }
 
  std::string m_title;
  std::string m_artist;
  std::string m_album;
  std::string m_albumArtist;
  std::string m_genre;
  std::string m_comment;
  std::string m_lyrics;
 
  int m_trackNumber = 0;
  int m_discNumber = 0;
  int m_duration = 0;
  int m_year = 0;
  int m_rating = 0;
};
//------------------------------------------------------------------------------
 
//==============================================================================
 
//==============================================================================
class ATTR_DLL_LOCAL CInstanceVisualization : public IAddonInstance
{
public:
  //============================================================================
  CInstanceVisualization()
    : IAddonInstance(IInstanceInfo(CPrivateBase::m_interface->firstKodiInstance))
  {
    if (CPrivateBase::m_interface->globalSingleInstance != nullptr)
      throw std::logic_error(
          "kodi::addon::CInstanceVisualization: Cannot create multiple instances of add-on.");
 
    SetAddonStruct(CPrivateBase::m_interface->firstKodiInstance);
    CPrivateBase::m_interface->globalSingleInstance = this;
  }
  //----------------------------------------------------------------------------
 
  //==========================================================================
  explicit CInstanceVisualization(const IInstanceInfo& instance) : IAddonInstance(instance)
  {
    if (CPrivateBase::m_interface->globalSingleInstance != nullptr)
      throw std::logic_error("kodi::addon::CInstanceVisualization: Creation of multiple together "
                             "with single instance way is not allowed!");
 
    SetAddonStruct(instance);
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  ~CInstanceVisualization() override = default;
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual bool Start(int channels,
                     int samplesPerSec,
                     int bitsPerSample,
                     const std::string& songName)
  {
    return true;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual void Stop() {}
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual void AudioData(const float* audioData, size_t audioDataLength) {}
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual bool IsDirty() { return true; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual void Render() {}
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual int GetSyncDelay() { return 0; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual bool GetPresets(std::vector<std::string>& presets) { return false; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual int GetActivePreset() { return -1; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual bool IsLocked() { return false; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual bool PrevPreset() { return false; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual bool NextPreset() { return false; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual bool LoadPreset(int select) { return false; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual bool RandomPreset() { return false; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual bool LockPreset(bool lockUnlock) { return false; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual bool RatePreset(bool plusMinus) { return false; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual bool UpdateAlbumart(const std::string& albumart) { return false; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual bool UpdateTrack(const kodi::addon::VisualizationTrack& track) { return false; }
  //----------------------------------------------------------------------------
 
  //============================================================================
 
  //============================================================================
  inline void TransferPresets(const std::vector<std::string>& presets)
  {
    m_instanceData->visualization->toKodi->clear_presets(m_instanceData->info->kodi);
    for (const auto& it : presets)
      m_instanceData->visualization->toKodi->transfer_preset(m_instanceData->info->kodi,
                                                             it.c_str());
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  inline kodi::HardwareContext Device() { return m_props.device; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  inline int X() { return m_props.x; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  inline int Y() { return m_props.y; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  inline int Width() { return m_props.width; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  inline int Height() { return m_props.height; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  inline float PixelRatio() { return m_props.pixelRatio; }
  //----------------------------------------------------------------------------
 
 
private:
  void SetAddonStruct(KODI_ADDON_INSTANCE_STRUCT* instance)
  {
    m_instanceData = instance;
    m_instanceData->hdl = this;
    m_instanceData->visualization->toAddon->start = ADDON_start;
    m_instanceData->visualization->toAddon->stop = ADDON_stop;
    m_instanceData->visualization->toAddon->audio_data = ADDON_audio_data;
    m_instanceData->visualization->toAddon->is_dirty = ADDON_is_dirty;
    m_instanceData->visualization->toAddon->render = ADDON_render;
    m_instanceData->visualization->toAddon->get_sync_delay = ADDON_get_sync_delay;
    m_instanceData->visualization->toAddon->prev_preset = ADDON_prev_preset;
    m_instanceData->visualization->toAddon->next_preset = ADDON_next_preset;
    m_instanceData->visualization->toAddon->load_preset = ADDON_load_preset;
    m_instanceData->visualization->toAddon->random_preset = ADDON_random_preset;
    m_instanceData->visualization->toAddon->lock_preset = ADDON_lock_preset;
    m_instanceData->visualization->toAddon->rate_preset = ADDON_rate_preset;
    m_instanceData->visualization->toAddon->update_albumart = ADDON_update_albumart;
    m_instanceData->visualization->toAddon->update_track = ADDON_update_track;
    m_instanceData->visualization->toAddon->get_presets = ADDON_get_presets;
    m_instanceData->visualization->toAddon->get_active_preset = ADDON_get_active_preset;
    m_instanceData->visualization->toAddon->is_locked = ADDON_is_locked;
 
    m_instanceData->visualization->toKodi->get_properties(instance->info->kodi, &m_props);
  }
 
  inline static bool ADDON_start(const KODI_ADDON_VISUALIZATION_HDL hdl,
                                 int channels,
                                 int samplesPerSec,
                                 int bitsPerSample,
                                 const char* songName)
  {
    CInstanceVisualization* thisClass = static_cast<CInstanceVisualization*>(hdl);
    thisClass->m_renderHelper = kodi::gui::GetRenderHelper();
    return thisClass->Start(channels, samplesPerSec, bitsPerSample, songName);
  }
 
  inline static void ADDON_stop(const KODI_ADDON_VISUALIZATION_HDL hdl)
  {
    CInstanceVisualization* thisClass = static_cast<CInstanceVisualization*>(hdl);
    thisClass->Stop();
    thisClass->m_renderHelper = nullptr;
  }
 
  inline static void ADDON_audio_data(const KODI_ADDON_VISUALIZATION_HDL hdl,
                                      const float* audioData,
                                      size_t audioDataLength)
  {
    static_cast<CInstanceVisualization*>(hdl)->AudioData(audioData, audioDataLength);
  }
 
  inline static bool ADDON_is_dirty(const KODI_ADDON_VISUALIZATION_HDL hdl)
  {
    return static_cast<CInstanceVisualization*>(hdl)->IsDirty();
  }
 
  inline static void ADDON_render(const KODI_ADDON_VISUALIZATION_HDL hdl)
  {
    CInstanceVisualization* thisClass = static_cast<CInstanceVisualization*>(hdl);
    if (!thisClass->m_renderHelper)
      return;
    thisClass->m_renderHelper->Begin();
    thisClass->Render();
    thisClass->m_renderHelper->End();
  }
 
  inline static int ADDON_get_sync_delay(const KODI_ADDON_VISUALIZATION_HDL hdl)
  {
    return static_cast<CInstanceVisualization*>(hdl)->GetSyncDelay();
  }
 
  inline static unsigned int ADDON_get_presets(const KODI_ADDON_VISUALIZATION_HDL hdl)
  {
    CInstanceVisualization* thisClass = static_cast<CInstanceVisualization*>(hdl);
    std::vector<std::string> presets;
    if (thisClass->GetPresets(presets))
    {
      for (const auto& it : presets)
        thisClass->m_instanceData->visualization->toKodi->transfer_preset(
            thisClass->m_instanceData->info->kodi, it.c_str());
    }
 
    return static_cast<unsigned int>(presets.size());
  }
 
  inline static int ADDON_get_active_preset(const KODI_ADDON_VISUALIZATION_HDL hdl)
  {
    return static_cast<CInstanceVisualization*>(hdl)->GetActivePreset();
  }
 
  inline static bool ADDON_prev_preset(const KODI_ADDON_VISUALIZATION_HDL hdl)
  {
    return static_cast<CInstanceVisualization*>(hdl)->PrevPreset();
  }
 
  inline static bool ADDON_next_preset(const KODI_ADDON_VISUALIZATION_HDL hdl)
  {
    return static_cast<CInstanceVisualization*>(hdl)->NextPreset();
  }
 
  inline static bool ADDON_load_preset(const KODI_ADDON_VISUALIZATION_HDL hdl, int select)
 
  {
    return static_cast<CInstanceVisualization*>(hdl)->LoadPreset(select);
  }
 
  inline static bool ADDON_random_preset(const KODI_ADDON_VISUALIZATION_HDL hdl)
  {
    return static_cast<CInstanceVisualization*>(hdl)->RandomPreset();
  }
 
  inline static bool ADDON_lock_preset(const KODI_ADDON_VISUALIZATION_HDL hdl)
  {
    CInstanceVisualization* thisClass = static_cast<CInstanceVisualization*>(hdl);
    thisClass->m_presetLockedByUser = !thisClass->m_presetLockedByUser;
    return thisClass->LockPreset(thisClass->m_presetLockedByUser);
  }
 
  inline static bool ADDON_rate_preset(const KODI_ADDON_VISUALIZATION_HDL hdl, bool plus_minus)
  {
    return static_cast<CInstanceVisualization*>(hdl)->RatePreset(plus_minus);
  }
 
  inline static bool ADDON_is_locked(const KODI_ADDON_VISUALIZATION_HDL hdl)
  {
    return static_cast<CInstanceVisualization*>(hdl)->IsLocked();
  }
 
  inline static bool ADDON_update_albumart(const KODI_ADDON_VISUALIZATION_HDL hdl,
                                           const char* albumart)
  {
    return static_cast<CInstanceVisualization*>(hdl)->UpdateAlbumart(albumart);
  }
 
  inline static bool ADDON_update_track(const KODI_ADDON_VISUALIZATION_HDL hdl,
                                        const KODI_ADDON_VISUALIZATION_TRACK* track)
  {
    VisualizationTrack cppTrack(track);
    return static_cast<CInstanceVisualization*>(hdl)->UpdateTrack(cppTrack);
  }
 
  std::shared_ptr<kodi::gui::IRenderHelper> m_renderHelper;
  bool m_presetLockedByUser = false;
  KODI_ADDON_INSTANCE_STRUCT* m_instanceData{nullptr};
  KODI_ADDON_VISUALIZATION_PROPS m_props = {};
};
 
} /* namespace addon */
} /* namespace kodi */
#endif /* __cplusplus */