AudioDecoder.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 "../AudioEngine.h"
#include "../c-api/addon-instance/audio_decoder.h"
 
#ifdef __cplusplus
namespace kodi
{
namespace addon
{
 
class CInstanceAudioDecoder;
 
//==============================================================================
class AudioDecoderInfoTag : public CStructHdl<AudioDecoderInfoTag, AUDIO_DECODER_INFO_TAG>
{
  friend class CInstanceAudioDecoder;
public:
  AudioDecoderInfoTag() { memset(m_cStructure, 0, sizeof(AUDIO_DECODER_INFO_TAG)); }
  AudioDecoderInfoTag(const AudioDecoderInfoTag& tag) : CStructHdl(tag) {}
 
 
  void SetTitle(const std::string& title)
  {
    strncpy(m_cStructure->title, title.c_str(), sizeof(m_cStructure->title) - 1);
  }
 
  std::string GetTitle() const { return m_cStructure->title; }
 
  void SetArtist(const std::string& artist)
  {
    strncpy(m_cStructure->artist, artist.c_str(), sizeof(m_cStructure->artist) - 1);
  }
 
  std::string GetArtist() const { return m_cStructure->artist; }
 
  void SetAlbum(const std::string& album)
  {
    strncpy(m_cStructure->album, album.c_str(), sizeof(m_cStructure->album) - 1);
  }
 
  std::string GetAlbum() const { return m_cStructure->album; }
 
  void SetAlbumArtist(const std::string& albumArtist)
  {
    strncpy(m_cStructure->album_artist, albumArtist.c_str(),
            sizeof(m_cStructure->album_artist) - 1);
  }
 
  std::string GetAlbumArtist() const { return m_cStructure->album_artist; }
 
  void SetMediaType(const std::string& mediaType)
  {
    strncpy(m_cStructure->media_type, mediaType.c_str(), sizeof(m_cStructure->media_type) - 1);
  }
 
  std::string GetMediaType() const { return m_cStructure->media_type; }
 
  void SetGenre(const std::string& genre)
  {
    strncpy(m_cStructure->genre, genre.c_str(), sizeof(m_cStructure->genre) - 1);
  }
 
  std::string GetGenre() const { return m_cStructure->genre; }
 
  void SetDuration(int duration) { m_cStructure->duration = duration; }
 
  int GetDuration() const { return m_cStructure->duration; }
 
  void SetTrack(int track) { m_cStructure->track = track; }
 
  int GetTrack() const { return m_cStructure->track; }
 
  void SetDisc(int disc) { m_cStructure->disc = disc; }
 
  int GetDisc() const { return m_cStructure->disc; }
 
  void SetDiscSubtitle(const std::string& discSubtitle)
  {
    strncpy(m_cStructure->disc_subtitle, discSubtitle.c_str(),
            sizeof(m_cStructure->disc_subtitle) - 1);
  }
 
  std::string GetDiscSubtitle() const { return m_cStructure->disc_subtitle; }
 
  void SetDiscTotal(int discTotal) { m_cStructure->disc_total = discTotal; }
 
  int GetDiscTotal() const { return m_cStructure->disc_total; }
 
  void SetReleaseDate(const std::string& releaseDate)
  {
    strncpy(m_cStructure->release_date, releaseDate.c_str(),
            sizeof(m_cStructure->release_date) - 1);
  }
 
  std::string GetReleaseDate() const { return m_cStructure->release_date; }
 
  void SetLyrics(const std::string& lyrics)
  {
    strncpy(m_cStructure->lyrics, lyrics.c_str(), sizeof(m_cStructure->lyrics) - 1);
  }
 
  std::string GetLyrics() const { return m_cStructure->lyrics; }
 
  void SetSamplerate(int samplerate) { m_cStructure->samplerate = samplerate; }
 
  int GetSamplerate() const { return m_cStructure->samplerate; }
 
  void SetChannels(int channels) { m_cStructure->channels = channels; }
 
  int GetChannels() const { return m_cStructure->channels; }
 
  void SetBitrate(int bitrate) { m_cStructure->bitrate = bitrate; }
 
  int GetBitrate() const { return m_cStructure->bitrate; }
 
  void SetComment(const std::string& comment)
  {
    strncpy(m_cStructure->comment, comment.c_str(), sizeof(m_cStructure->comment) - 1);
  }
 
  std::string GetComment() const { return m_cStructure->comment; }
 
 
private:
  AudioDecoderInfoTag(const AUDIO_DECODER_INFO_TAG* tag) : CStructHdl(tag) {}
  AudioDecoderInfoTag(AUDIO_DECODER_INFO_TAG* tag) : CStructHdl(tag) {}
};
//------------------------------------------------------------------------------
 
//==============================================================================
 
//==============================================================================
class ATTRIBUTE_HIDDEN CInstanceAudioDecoder : public IAddonInstance
{
public:
  //==========================================================================
  explicit CInstanceAudioDecoder(KODI_HANDLE instance, const std::string& kodiVersion = "")
    : IAddonInstance(ADDON_INSTANCE_AUDIODECODER,
                     !kodiVersion.empty() ? kodiVersion
                                          : GetKodiTypeVersion(ADDON_INSTANCE_AUDIODECODER))
  {
    if (CAddonBase::m_interface->globalSingleInstance != nullptr)
      throw std::logic_error("kodi::addon::CInstanceAudioDecoder: Creation of multiple together with single instance way is not allowed!");
 
    SetAddonStruct(instance);
  }
  //--------------------------------------------------------------------------
 
  //==========================================================================
  virtual bool Init(const std::string& filename,
                    unsigned int filecache,
                    int& channels,
                    int& samplerate,
                    int& bitspersample,
                    int64_t& totaltime,
                    int& bitrate,
                    AudioEngineDataFormat& format,
                    std::vector<AudioEngineChannel>& channellist) = 0;
  //--------------------------------------------------------------------------
 
  //==========================================================================
  virtual int ReadPCM(uint8_t* buffer, int size, int& actualsize) = 0;
  //--------------------------------------------------------------------------
 
  //==========================================================================
  virtual int64_t Seek(int64_t time) { return time; }
  //--------------------------------------------------------------------------
 
  //==========================================================================
  virtual bool ReadTag(const std::string& file, kodi::addon::AudioDecoderInfoTag& tag)
  {
    return false;
  }
  //--------------------------------------------------------------------------
 
  //==========================================================================
  virtual int TrackCount(const std::string& file) { return 1; }
  //--------------------------------------------------------------------------
 
private:
  void SetAddonStruct(KODI_HANDLE instance)
  {
    if (instance == nullptr)
      throw std::logic_error("kodi::addon::CInstanceAudioDecoder: Creation with empty addon structure not allowed, table must be given from Kodi!");
 
    m_instanceData = static_cast<AddonInstance_AudioDecoder*>(instance);
 
    m_instanceData->toAddon->addonInstance = this;
    m_instanceData->toAddon->init = ADDON_Init;
    m_instanceData->toAddon->read_pcm = ADDON_ReadPCM;
    m_instanceData->toAddon->seek = ADDON_Seek;
    m_instanceData->toAddon->read_tag = ADDON_ReadTag;
    m_instanceData->toAddon->track_count = ADDON_TrackCount;
  }
 
  inline static bool ADDON_Init(const AddonInstance_AudioDecoder* instance,
                                const char* file,
                                unsigned int filecache,
                                int* channels,
                                int* samplerate,
                                int* bitspersample,
                                int64_t* totaltime,
                                int* bitrate,
                                AudioEngineDataFormat* format,
                                const AudioEngineChannel** info)
  {
    CInstanceAudioDecoder* thisClass =
        static_cast<CInstanceAudioDecoder*>(instance->toAddon->addonInstance);
 
    thisClass->m_channelList.clear();
    bool ret = thisClass->Init(file, filecache, *channels, *samplerate, *bitspersample, *totaltime,
                               *bitrate, *format, thisClass->m_channelList);
    if (!thisClass->m_channelList.empty())
    {
      if (thisClass->m_channelList.back() != AUDIOENGINE_CH_NULL)
        thisClass->m_channelList.push_back(AUDIOENGINE_CH_NULL);
      *info = thisClass->m_channelList.data();
    }
    else
      *info = nullptr;
    return ret;
  }
 
  inline static int ADDON_ReadPCM(const AddonInstance_AudioDecoder* instance, uint8_t* buffer, int size, int* actualsize)
  {
    return static_cast<CInstanceAudioDecoder*>(instance->toAddon->addonInstance)
        ->ReadPCM(buffer, size, *actualsize);
  }
 
  inline static int64_t ADDON_Seek(const AddonInstance_AudioDecoder* instance, int64_t time)
  {
    return static_cast<CInstanceAudioDecoder*>(instance->toAddon->addonInstance)->Seek(time);
  }
 
  inline static bool ADDON_ReadTag(const AddonInstance_AudioDecoder* instance,
                                   const char* file,
                                   struct AUDIO_DECODER_INFO_TAG* tag)
  {
    kodi::addon::AudioDecoderInfoTag cppTag(tag);
    return static_cast<CInstanceAudioDecoder*>(instance->toAddon->addonInstance)
        ->ReadTag(file, cppTag);
  }
 
  inline static int ADDON_TrackCount(const AddonInstance_AudioDecoder* instance, const char* file)
  {
    return static_cast<CInstanceAudioDecoder*>(instance->toAddon->addonInstance)->TrackCount(file);
  }
 
  std::vector<AudioEngineChannel> m_channelList;
  AddonInstance_AudioDecoder* m_instanceData;
};
 
} /* namespace addon */
} /* namespace kodi */
#endif /* __cplusplus */