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 VIS_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 ATTRIBUTE_HIDDEN CInstanceVisualization : public IAddonInstance
{
public:
  //============================================================================
  CInstanceVisualization()
    : IAddonInstance(ADDON_INSTANCE_VISUALIZATION, GetKodiTypeVersion(ADDON_INSTANCE_VISUALIZATION))
  {
    if (CAddonBase::m_interface->globalSingleInstance != nullptr)
      throw std::logic_error(
          "kodi::addon::CInstanceVisualization: Cannot create multiple instances of add-on.");
 
    SetAddonStruct(CAddonBase::m_interface->firstKodiInstance);
    CAddonBase::m_interface->globalSingleInstance = this;
  }
  //----------------------------------------------------------------------------
 
  //==========================================================================
  explicit CInstanceVisualization(KODI_HANDLE instance, const std::string& kodiVersion = "")
    : IAddonInstance(ADDON_INSTANCE_VISUALIZATION,
                     !kodiVersion.empty() ? kodiVersion
                                          : GetKodiTypeVersion(ADDON_INSTANCE_VISUALIZATION))
  {
    if (CAddonBase::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, std::string songName)
  {
    return true;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual void Stop() {}
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual void AudioData(const float* audioData,
                         int audioDataLength,
                         float* freqData,
                         int freqDataLength)
  {
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual bool IsDirty() { return true; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual void Render() {}
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual void GetInfo(bool& wantsFreq, int& syncDelay)
  {
    wantsFreq = false;
    syncDelay = 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(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->toKodi->clear_presets(m_instanceData->toKodi->kodiInstance);
    for (const auto& it : presets)
      m_instanceData->toKodi->transfer_preset(m_instanceData->toKodi->kodiInstance, it.c_str());
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  inline kodi::HardwareContext Device() { return m_instanceData->props->device; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  inline int X() { return m_instanceData->props->x; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  inline int Y() { return m_instanceData->props->y; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  inline int Width() { return m_instanceData->props->width; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  inline int Height() { return m_instanceData->props->height; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  inline float PixelRatio() { return m_instanceData->props->pixelRatio; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  inline std::string Name() { return m_instanceData->props->name; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  inline std::string Presets() { return m_instanceData->props->presets; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  inline std::string Profile() { return m_instanceData->props->profile; }
  //----------------------------------------------------------------------------
 
 
private:
  void SetAddonStruct(KODI_HANDLE instance)
  {
    if (instance == nullptr)
      throw std::logic_error("kodi::addon::CInstanceVisualization: Null pointer instance passed.");
 
    m_instanceData = static_cast<AddonInstance_Visualization*>(instance);
    m_instanceData->toAddon->addonInstance = this;
    m_instanceData->toAddon->start = ADDON_Start;
    m_instanceData->toAddon->stop = ADDON_Stop;
    m_instanceData->toAddon->audio_data = ADDON_AudioData;
    m_instanceData->toAddon->is_dirty = ADDON_IsDirty;
    m_instanceData->toAddon->render = ADDON_Render;
    m_instanceData->toAddon->get_info = ADDON_GetInfo;
    m_instanceData->toAddon->prev_preset = ADDON_PrevPreset;
    m_instanceData->toAddon->next_preset = ADDON_NextPreset;
    m_instanceData->toAddon->load_preset = ADDON_LoadPreset;
    m_instanceData->toAddon->random_preset = ADDON_RandomPreset;
    m_instanceData->toAddon->lock_preset = ADDON_LockPreset;
    m_instanceData->toAddon->rate_preset = ADDON_RatePreset;
    m_instanceData->toAddon->update_albumart = ADDON_UpdateAlbumart;
    m_instanceData->toAddon->update_track = ADDON_UpdateTrack;
    m_instanceData->toAddon->get_presets = ADDON_GetPresets;
    m_instanceData->toAddon->get_active_preset = ADDON_GetActivePreset;
    m_instanceData->toAddon->is_locked = ADDON_IsLocked;
  }
 
  inline static bool ADDON_Start(const AddonInstance_Visualization* addon,
                                 int channels,
                                 int samplesPerSec,
                                 int bitsPerSample,
                                 const char* songName)
  {
    CInstanceVisualization* thisClass =
        static_cast<CInstanceVisualization*>(addon->toAddon->addonInstance);
    thisClass->m_renderHelper = kodi::gui::GetRenderHelper();
    return thisClass->Start(channels, samplesPerSec, bitsPerSample, songName);
  }
 
  inline static void ADDON_Stop(const AddonInstance_Visualization* addon)
  {
    CInstanceVisualization* thisClass =
        static_cast<CInstanceVisualization*>(addon->toAddon->addonInstance);
    thisClass->Stop();
    thisClass->m_renderHelper = nullptr;
  }
 
  inline static void ADDON_AudioData(const AddonInstance_Visualization* addon,
                                     const float* audioData,
                                     int audioDataLength,
                                     float* freqData,
                                     int freqDataLength)
  {
    static_cast<CInstanceVisualization*>(addon->toAddon->addonInstance)
        ->AudioData(audioData, audioDataLength, freqData, freqDataLength);
  }
 
  inline static bool ADDON_IsDirty(const AddonInstance_Visualization* addon)
  {
    return static_cast<CInstanceVisualization*>(addon->toAddon->addonInstance)->IsDirty();
  }
 
  inline static void ADDON_Render(const AddonInstance_Visualization* addon)
  {
    CInstanceVisualization* thisClass =
        static_cast<CInstanceVisualization*>(addon->toAddon->addonInstance);
    if (!thisClass->m_renderHelper)
      return;
    thisClass->m_renderHelper->Begin();
    thisClass->Render();
    thisClass->m_renderHelper->End();
  }
 
  inline static void ADDON_GetInfo(const AddonInstance_Visualization* addon, VIS_INFO* info)
  {
    static_cast<CInstanceVisualization*>(addon->toAddon->addonInstance)
        ->GetInfo(info->bWantsFreq, info->iSyncDelay);
  }
 
  inline static unsigned int ADDON_GetPresets(const AddonInstance_Visualization* addon)
  {
    CInstanceVisualization* thisClass =
        static_cast<CInstanceVisualization*>(addon->toAddon->addonInstance);
    std::vector<std::string> presets;
    if (thisClass->GetPresets(presets))
    {
      for (const auto& it : presets)
        thisClass->m_instanceData->toKodi->transfer_preset(addon->toKodi->kodiInstance, it.c_str());
    }
 
    return static_cast<unsigned int>(presets.size());
  }
 
  inline static int ADDON_GetActivePreset(const AddonInstance_Visualization* addon)
  {
    return static_cast<CInstanceVisualization*>(addon->toAddon->addonInstance)->GetActivePreset();
  }
 
  inline static bool ADDON_PrevPreset(const AddonInstance_Visualization* addon)
  {
    return static_cast<CInstanceVisualization*>(addon->toAddon->addonInstance)->PrevPreset();
  }
 
  inline static bool ADDON_NextPreset(const AddonInstance_Visualization* addon)
  {
    return static_cast<CInstanceVisualization*>(addon->toAddon->addonInstance)->NextPreset();
  }
 
  inline static bool ADDON_LoadPreset(const AddonInstance_Visualization* addon, int select)
 
  {
    return static_cast<CInstanceVisualization*>(addon->toAddon->addonInstance)->LoadPreset(select);
  }
 
  inline static bool ADDON_RandomPreset(const AddonInstance_Visualization* addon)
  {
    return static_cast<CInstanceVisualization*>(addon->toAddon->addonInstance)->RandomPreset();
  }
 
  inline static bool ADDON_LockPreset(const AddonInstance_Visualization* addon)
  {
    CInstanceVisualization* thisClass =
        static_cast<CInstanceVisualization*>(addon->toAddon->addonInstance);
    thisClass->m_presetLockedByUser = !thisClass->m_presetLockedByUser;
    return thisClass->LockPreset(thisClass->m_presetLockedByUser);
  }
 
  inline static bool ADDON_RatePreset(const AddonInstance_Visualization* addon, bool plus_minus)
  {
    return static_cast<CInstanceVisualization*>(addon->toAddon->addonInstance)
        ->RatePreset(plus_minus);
  }
 
  inline static bool ADDON_IsLocked(const AddonInstance_Visualization* addon)
  {
    return static_cast<CInstanceVisualization*>(addon->toAddon->addonInstance)->IsLocked();
  }
 
  inline static bool ADDON_UpdateAlbumart(const AddonInstance_Visualization* addon,
                                          const char* albumart)
  {
    return static_cast<CInstanceVisualization*>(addon->toAddon->addonInstance)
        ->UpdateAlbumart(albumart);
  }
 
  inline static bool ADDON_UpdateTrack(const AddonInstance_Visualization* addon,
                                       const VIS_TRACK* track)
  {
    VisualizationTrack cppTrack(track);
    return static_cast<CInstanceVisualization*>(addon->toAddon->addonInstance)
        ->UpdateTrack(cppTrack);
  }
 
  std::shared_ptr<kodi::gui::IRenderHelper> m_renderHelper;
  bool m_presetLockedByUser = false;
  AddonInstance_Visualization* m_instanceData;
};
 
} /* namespace addon */
} /* namespace kodi */
#endif /* __cplusplus */