PVR.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 "../c-api/addon-instance/pvr.h"
#include "pvr/ChannelGroups.h"
#include "pvr/Channels.h"
#include "pvr/EDL.h"
#include "pvr/EPG.h"
#include "pvr/General.h"
#include "pvr/MenuHook.h"
#include "pvr/Providers.h"
#include "pvr/Recordings.h"
#include "pvr/Stream.h"
#include "pvr/Timers.h"
 
#ifdef __cplusplus
 
namespace kodi
{
namespace addon
{
 
//¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
// "C++" Doxygen group set for the definitions
//{{{
 
//==============================================================================
 
//##############################################################################
//##############################################################################
//------------------------------------------------------------------------------
 
//##############################################################################
//------------------------------------------------------------------------------
 
//##############################################################################
//------------------------------------------------------------------------------
 
//##############################################################################
//------------------------------------------------------------------------------
 
//##############################################################################
//------------------------------------------------------------------------------
 
//##############################################################################
//------------------------------------------------------------------------------
 
//##############################################################################
//------------------------------------------------------------------------------
 
//##############################################################################
//------------------------------------------------------------------------------
 
//##############################################################################
//------------------------------------------------------------------------------
 
//##############################################################################
//------------------------------------------------------------------------------
 
//}}}
//______________________________________________________________________________
 
//¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
// "C++" PVR addon instance class
//{{{
 
//==============================================================================
class ATTR_DLL_LOCAL CInstancePVRClient : public IAddonInstance
{
public:
  //============================================================================
 
  //============================================================================
  CInstancePVRClient() : IAddonInstance(IInstanceInfo(CPrivateBase::m_interface->firstKodiInstance))
  {
    if (CPrivateBase::m_interface->globalSingleInstance != nullptr)
      throw std::logic_error("kodi::addon::CInstancePVRClient: Creation of more as one in single "
                             "instance way is not allowed!");
 
    SetAddonStruct(CPrivateBase::m_interface->firstKodiInstance);
    CPrivateBase::m_interface->globalSingleInstance = this;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  explicit CInstancePVRClient(const IInstanceInfo& instance) : IAddonInstance(instance)
  {
    if (CPrivateBase::m_interface->globalSingleInstance != nullptr)
      throw std::logic_error("kodi::addon::CInstancePVRClient: Creation of multiple together with "
                             "single instance way is not allowed!");
 
    SetAddonStruct(instance);
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  ~CInstancePVRClient() override = default;
  //----------------------------------------------------------------------------
 
  //--==----==----==----==----==----==----==----==----==----==----==----==----==
 
  //============================================================================
  virtual PVR_ERROR GetCapabilities(kodi::addon::PVRCapabilities& capabilities) = 0;
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR GetBackendName(std::string& name) = 0;
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR GetBackendVersion(std::string& version) = 0;
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR GetBackendHostname(std::string& hostname) { return PVR_ERROR_NOT_IMPLEMENTED; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR GetConnectionString(std::string& connection)
  {
    return PVR_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR GetDriveSpace(uint64_t& total, uint64_t& used)
  {
    return PVR_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR CallSettingsMenuHook(const kodi::addon::PVRMenuhook& menuhook)
  {
    return PVR_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //==========================================================================
  inline void AddMenuHook(const kodi::addon::PVRMenuhook& hook)
  {
    m_instanceData->toKodi->AddMenuHook(m_instanceData->toKodi->kodiInstance, hook);
  }
  //----------------------------------------------------------------------------
 
  //==========================================================================
  inline void ConnectionStateChange(const std::string& connectionString,
                                    PVR_CONNECTION_STATE newState,
                                    const std::string& message)
  {
    m_instanceData->toKodi->ConnectionStateChange(
        m_instanceData->toKodi->kodiInstance, connectionString.c_str(), newState, message.c_str());
  }
  //----------------------------------------------------------------------------
 
  //==========================================================================
  inline std::string UserPath() const { return m_instanceData->props->strUserPath; }
  //----------------------------------------------------------------------------
 
  //==========================================================================
  inline std::string ClientPath() const { return m_instanceData->props->strClientPath; }
  //----------------------------------------------------------------------------
 
  //--==----==----==----==----==----==----==----==----==----==----==----==----==
 
  //============================================================================
 
  //============================================================================
  virtual PVR_ERROR GetProvidersAmount(int& amount) { return PVR_ERROR_NOT_IMPLEMENTED; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR GetProviders(kodi::addon::PVRProvidersResultSet& results)
  {
    return PVR_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  inline void TriggerProvidersUpdate()
  {
    m_instanceData->toKodi->TriggerProvidersUpdate(m_instanceData->toKodi->kodiInstance);
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR GetChannelsAmount(int& amount) { return PVR_ERROR_NOT_IMPLEMENTED; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR GetChannels(bool radio, kodi::addon::PVRChannelsResultSet& results)
  {
    return PVR_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR GetChannelStreamProperties(
      const kodi::addon::PVRChannel& channel,
      PVR_SOURCE source,
      std::vector<kodi::addon::PVRStreamProperty>& properties)
  {
    return PVR_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR GetSignalStatus(int channelUid, kodi::addon::PVRSignalStatus& signalStatus)
  {
    return PVR_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR GetDescrambleInfo(int channelUid,
                                      kodi::addon::PVRDescrambleInfo& descrambleInfo)
  {
    return PVR_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  inline void TriggerChannelUpdate()
  {
    m_instanceData->toKodi->TriggerChannelUpdate(m_instanceData->toKodi->kodiInstance);
  }
  //----------------------------------------------------------------------------
 
  //--==----==----==----==----==----==----==----==----==----==----==----==----==
 
  //============================================================================
 
  //============================================================================
  virtual PVR_ERROR GetChannelGroupsAmount(int& amount) { return PVR_ERROR_NOT_IMPLEMENTED; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR GetChannelGroups(bool radio, kodi::addon::PVRChannelGroupsResultSet& results)
  {
    return PVR_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR GetChannelGroupMembers(const kodi::addon::PVRChannelGroup& group,
                                           kodi::addon::PVRChannelGroupMembersResultSet& results)
  {
    return PVR_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  inline void TriggerChannelGroupsUpdate()
  {
    m_instanceData->toKodi->TriggerChannelGroupsUpdate(m_instanceData->toKodi->kodiInstance);
  }
  //----------------------------------------------------------------------------
 
  //--==----==----==----==----==----==----==----==----==----==----==----==----==
 
  //============================================================================
 
  //============================================================================
  virtual PVR_ERROR DeleteChannel(const kodi::addon::PVRChannel& channel)
  {
    return PVR_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //==========================================================================
  virtual PVR_ERROR RenameChannel(const kodi::addon::PVRChannel& channel)
  {
    return PVR_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //==========================================================================
  virtual PVR_ERROR OpenDialogChannelSettings(const kodi::addon::PVRChannel& channel)
  {
    return PVR_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //==========================================================================
  virtual PVR_ERROR OpenDialogChannelAdd(const kodi::addon::PVRChannel& channel)
  {
    return PVR_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //==========================================================================
  virtual PVR_ERROR OpenDialogChannelScan() { return PVR_ERROR_NOT_IMPLEMENTED; }
  //----------------------------------------------------------------------------
 
  //==========================================================================
  virtual PVR_ERROR CallChannelMenuHook(const kodi::addon::PVRMenuhook& menuhook,
                                        const kodi::addon::PVRChannel& item)
  {
    return PVR_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //--==----==----==----==----==----==----==----==----==----==----==----==----==
 
  //============================================================================
 
  //============================================================================
  virtual PVR_ERROR GetEPGForChannel(int channelUid,
                                     time_t start,
                                     time_t end,
                                     kodi::addon::PVREPGTagsResultSet& results)
  {
    return PVR_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR IsEPGTagRecordable(const kodi::addon::PVREPGTag& tag, bool& isRecordable)
  {
    return PVR_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR IsEPGTagPlayable(const kodi::addon::PVREPGTag& tag, bool& isPlayable)
  {
    return PVR_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR GetEPGTagEdl(const kodi::addon::PVREPGTag& tag,
                                 std::vector<kodi::addon::PVREDLEntry>& edl)
  {
    return PVR_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR GetEPGTagStreamProperties(
      const kodi::addon::PVREPGTag& tag, std::vector<kodi::addon::PVRStreamProperty>& properties)
  {
    return PVR_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR SetEPGMaxPastDays(int pastDays) { return PVR_ERROR_NOT_IMPLEMENTED; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR SetEPGMaxFutureDays(int futureDays) { return PVR_ERROR_NOT_IMPLEMENTED; }
  //----------------------------------------------------------------------------
 
  //==========================================================================
  virtual PVR_ERROR CallEPGMenuHook(const kodi::addon::PVRMenuhook& menuhook,
                                    const kodi::addon::PVREPGTag& tag)
  {
    return PVR_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //==========================================================================
  inline int EpgMaxPastDays() const { return m_instanceData->props->iEpgMaxPastDays; }
  //----------------------------------------------------------------------------
 
  //==========================================================================
  inline int EpgMaxFutureDays() const { return m_instanceData->props->iEpgMaxFutureDays; }
  //----------------------------------------------------------------------------
 
  //==========================================================================
  inline void TriggerEpgUpdate(unsigned int channelUid)
  {
    m_instanceData->toKodi->TriggerEpgUpdate(m_instanceData->toKodi->kodiInstance, channelUid);
  }
  //----------------------------------------------------------------------------
 
  //==========================================================================
  inline void EpgEventStateChange(kodi::addon::PVREPGTag& tag, EPG_EVENT_STATE newState)
  {
    m_instanceData->toKodi->EpgEventStateChange(m_instanceData->toKodi->kodiInstance, tag,
                                                newState);
  }
  //----------------------------------------------------------------------------
 
  //--==----==----==----==----==----==----==----==----==----==----==----==----==
 
  //============================================================================
 
  //============================================================================
  virtual PVR_ERROR GetRecordingsAmount(bool deleted, int& amount)
  {
    return PVR_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR GetRecordings(bool deleted, kodi::addon::PVRRecordingsResultSet& results)
  {
    return PVR_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR DeleteRecording(const kodi::addon::PVRRecording& recording)
  {
    return PVR_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR UndeleteRecording(const kodi::addon::PVRRecording& recording)
  {
    return PVR_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR DeleteAllRecordingsFromTrash() { return PVR_ERROR_NOT_IMPLEMENTED; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR RenameRecording(const kodi::addon::PVRRecording& recording)
  {
    return PVR_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR SetRecordingLifetime(const kodi::addon::PVRRecording& recording)
  {
    return PVR_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR SetRecordingPlayCount(const kodi::addon::PVRRecording& recording, int count)
  {
    return PVR_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR SetRecordingLastPlayedPosition(const kodi::addon::PVRRecording& recording,
                                                   int lastplayedposition)
  {
    return PVR_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR GetRecordingLastPlayedPosition(const kodi::addon::PVRRecording& recording,
                                                   int& position)
  {
    return PVR_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR GetRecordingEdl(const kodi::addon::PVRRecording& recording,
                                    std::vector<kodi::addon::PVREDLEntry>& edl)
  {
    return PVR_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR GetRecordingSize(const kodi::addon::PVRRecording& recording, int64_t& size)
  {
    return PVR_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR GetRecordingStreamProperties(
      const kodi::addon::PVRRecording& recording,
      std::vector<kodi::addon::PVRStreamProperty>& properties)
  {
    return PVR_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //==========================================================================
  virtual PVR_ERROR CallRecordingMenuHook(const kodi::addon::PVRMenuhook& menuhook,
                                          const kodi::addon::PVRRecording& item)
  {
    return PVR_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  inline void RecordingNotification(const std::string& recordingName,
                                    const std::string& fileName,
                                    bool on)
  {
    m_instanceData->toKodi->RecordingNotification(m_instanceData->toKodi->kodiInstance,
                                                  recordingName.c_str(), fileName.c_str(), on);
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  inline void TriggerRecordingUpdate()
  {
    m_instanceData->toKodi->TriggerRecordingUpdate(m_instanceData->toKodi->kodiInstance);
  }
  //----------------------------------------------------------------------------
 
  //--==----==----==----==----==----==----==----==----==----==----==----==----==
 
  //============================================================================
 
  //============================================================================
  virtual PVR_ERROR GetTimerTypes(std::vector<kodi::addon::PVRTimerType>& types)
  {
    return PVR_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR GetTimersAmount(int& amount) { return PVR_ERROR_NOT_IMPLEMENTED; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR GetTimers(kodi::addon::PVRTimersResultSet& results)
  {
    return PVR_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR AddTimer(const kodi::addon::PVRTimer& timer)
  {
    return PVR_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR DeleteTimer(const kodi::addon::PVRTimer& timer, bool forceDelete)
  {
    return PVR_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR UpdateTimer(const kodi::addon::PVRTimer& timer)
  {
    return PVR_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR CallTimerMenuHook(const kodi::addon::PVRMenuhook& menuhook,
                                      const kodi::addon::PVRTimer& item)
  {
    return PVR_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  inline void TriggerTimerUpdate()
  {
    m_instanceData->toKodi->TriggerTimerUpdate(m_instanceData->toKodi->kodiInstance);
  }
  //----------------------------------------------------------------------------
 
  //--==----==----==----==----==----==----==----==----==----==----==----==----==
 
  //============================================================================
 
  //============================================================================
  virtual PVR_ERROR OnSystemSleep() { return PVR_ERROR_NOT_IMPLEMENTED; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR OnSystemWake() { return PVR_ERROR_NOT_IMPLEMENTED; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR OnPowerSavingActivated() { return PVR_ERROR_NOT_IMPLEMENTED; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR OnPowerSavingDeactivated() { return PVR_ERROR_NOT_IMPLEMENTED; }
  //----------------------------------------------------------------------------
 
  //--==----==----==----==----==----==----==----==----==----==----==----==----==
 
  //============================================================================
 
  //============================================================================
 
  //============================================================================
  virtual bool OpenLiveStream(const kodi::addon::PVRChannel& channel) { return false; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual void CloseLiveStream() {}
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual int ReadLiveStream(unsigned char* buffer, unsigned int size) { return 0; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual int64_t SeekLiveStream(int64_t position, int whence) { return 0; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual int64_t LengthLiveStream() { return 0; }
  //----------------------------------------------------------------------------
 
  //============================================================================
 
  //============================================================================
  virtual PVR_ERROR GetStreamProperties(std::vector<kodi::addon::PVRStreamProperties>& properties)
  {
    return PVR_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR StreamClosed() { return PVR_ERROR_NOT_IMPLEMENTED; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual DEMUX_PACKET* DemuxRead() { return nullptr; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual void DemuxReset() {}
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual void DemuxAbort() {}
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual void DemuxFlush() {}
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual void SetSpeed(int speed) {}
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual void FillBuffer(bool mode) {}
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual bool SeekTime(double time, bool backwards, double& startpts) { return false; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  inline PVRCodec GetCodecByName(const std::string& codecName) const
  {
    return PVRCodec(m_instanceData->toKodi->GetCodecByName(m_instanceData->toKodi->kodiInstance,
                                                           codecName.c_str()));
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  inline DEMUX_PACKET* AllocateDemuxPacket(int iDataSize)
  {
    return m_instanceData->toKodi->AllocateDemuxPacket(m_instanceData->toKodi->kodiInstance,
                                                       iDataSize);
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  inline void FreeDemuxPacket(DEMUX_PACKET* pPacket)
  {
    m_instanceData->toKodi->FreeDemuxPacket(m_instanceData->toKodi->kodiInstance, pPacket);
  }
  //----------------------------------------------------------------------------
 
  //--==----==----==----==----==----==----==----==----==----==----==----==----==
 
  //============================================================================
 
  //============================================================================
  virtual bool OpenRecordedStream(const kodi::addon::PVRRecording& recording, int64_t& streamId)
  {
    return false;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual void CloseRecordedStream(int64_t streamId) {}
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual int ReadRecordedStream(int64_t streamId, unsigned char* buffer, unsigned int size)
  {
    return 0;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual int64_t SeekRecordedStream(int64_t streamId, int64_t position, int whence) { return 0; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual int64_t LengthRecordedStream(int64_t streamId) { return 0; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR IsRecordedStreamRealTime(int64_t streamId, bool& isRealTime)
  {
    return PVR_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR PauseRecordedStream(int64_t streamId, bool paused)
  {
    return PVR_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR GetRecordedStreamTimes(int64_t streamId, kodi::addon::PVRStreamTimes& times)
  {
    return PVR_ERROR_NOT_IMPLEMENTED;
  }
  //--==----==----==----==----==----==----==----==----==----==----==----==----==
 
  //============================================================================
 
  //============================================================================
  virtual bool CanPauseStream() { return false; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual bool CanSeekStream() { return false; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual void PauseStream(bool paused) {}
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual bool IsRealTimeStream() { return false; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR GetStreamTimes(kodi::addon::PVRStreamTimes& times)
  {
    return PVR_ERROR_NOT_IMPLEMENTED;
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual PVR_ERROR GetStreamReadChunkSize(int& chunksize) { return PVR_ERROR_NOT_IMPLEMENTED; }
  //----------------------------------------------------------------------------
 
  //--==----==----==----==----==----==----==----==----==----==----==----==----==
 
private:
  void SetAddonStruct(KODI_ADDON_INSTANCE_STRUCT* instance)
  {
    instance->hdl = this;
 
    //--==----==----==----==----==----==----==----==----==----==----==----==----==
    instance->pvr->toAddon->GetCapabilities = ADDON_GetCapabilities;
    instance->pvr->toAddon->GetConnectionString = ADDON_GetConnectionString;
    instance->pvr->toAddon->GetBackendName = ADDON_GetBackendName;
    instance->pvr->toAddon->GetBackendVersion = ADDON_GetBackendVersion;
    instance->pvr->toAddon->GetBackendHostname = ADDON_GetBackendHostname;
    instance->pvr->toAddon->GetDriveSpace = ADDON_GetDriveSpace;
    instance->pvr->toAddon->CallSettingsMenuHook = ADDON_CallSettingsMenuHook;
    //--==----==----==----==----==----==----==----==----==----==----==----==----==
    instance->pvr->toAddon->GetChannelsAmount = ADDON_GetChannelsAmount;
    instance->pvr->toAddon->GetChannels = ADDON_GetChannels;
    instance->pvr->toAddon->GetChannelStreamProperties = ADDON_GetChannelStreamProperties;
    instance->pvr->toAddon->GetSignalStatus = ADDON_GetSignalStatus;
    instance->pvr->toAddon->GetDescrambleInfo = ADDON_GetDescrambleInfo;
    //--==----==----==----==----==----==----==----==----==----==----==----==----==
    instance->pvr->toAddon->GetProvidersAmount = ADDON_GetProvidersAmount;
    instance->pvr->toAddon->GetProviders = ADDON_GetProviders;
    //--==----==----==----==----==----==----==----==----==----==----==----==----==
    instance->pvr->toAddon->GetChannelGroupsAmount = ADDON_GetChannelGroupsAmount;
    instance->pvr->toAddon->GetChannelGroups = ADDON_GetChannelGroups;
    instance->pvr->toAddon->GetChannelGroupMembers = ADDON_GetChannelGroupMembers;
    //--==----==----==----==----==----==----==----==----==----==----==----==----==
    instance->pvr->toAddon->DeleteChannel = ADDON_DeleteChannel;
    instance->pvr->toAddon->RenameChannel = ADDON_RenameChannel;
    instance->pvr->toAddon->OpenDialogChannelSettings = ADDON_OpenDialogChannelSettings;
    instance->pvr->toAddon->OpenDialogChannelAdd = ADDON_OpenDialogChannelAdd;
    instance->pvr->toAddon->OpenDialogChannelScan = ADDON_OpenDialogChannelScan;
    instance->pvr->toAddon->CallChannelMenuHook = ADDON_CallChannelMenuHook;
    //--==----==----==----==----==----==----==----==----==----==----==----==----==
    instance->pvr->toAddon->GetEPGForChannel = ADDON_GetEPGForChannel;
    instance->pvr->toAddon->IsEPGTagRecordable = ADDON_IsEPGTagRecordable;
    instance->pvr->toAddon->IsEPGTagPlayable = ADDON_IsEPGTagPlayable;
    instance->pvr->toAddon->GetEPGTagEdl = ADDON_GetEPGTagEdl;
    instance->pvr->toAddon->GetEPGTagStreamProperties = ADDON_GetEPGTagStreamProperties;
    instance->pvr->toAddon->SetEPGMaxPastDays = ADDON_SetEPGMaxPastDays;
    instance->pvr->toAddon->SetEPGMaxFutureDays = ADDON_SetEPGMaxFutureDays;
    instance->pvr->toAddon->CallEPGMenuHook = ADDON_CallEPGMenuHook;
    //--==----==----==----==----==----==----==----==----==----==----==----==----==
    instance->pvr->toAddon->GetRecordingsAmount = ADDON_GetRecordingsAmount;
    instance->pvr->toAddon->GetRecordings = ADDON_GetRecordings;
    instance->pvr->toAddon->DeleteRecording = ADDON_DeleteRecording;
    instance->pvr->toAddon->UndeleteRecording = ADDON_UndeleteRecording;
    instance->pvr->toAddon->DeleteAllRecordingsFromTrash = ADDON_DeleteAllRecordingsFromTrash;
    instance->pvr->toAddon->RenameRecording = ADDON_RenameRecording;
    instance->pvr->toAddon->SetRecordingLifetime = ADDON_SetRecordingLifetime;
    instance->pvr->toAddon->SetRecordingPlayCount = ADDON_SetRecordingPlayCount;
    instance->pvr->toAddon->SetRecordingLastPlayedPosition = ADDON_SetRecordingLastPlayedPosition;
    instance->pvr->toAddon->GetRecordingLastPlayedPosition = ADDON_GetRecordingLastPlayedPosition;
    instance->pvr->toAddon->GetRecordingEdl = ADDON_GetRecordingEdl;
    instance->pvr->toAddon->GetRecordingSize = ADDON_GetRecordingSize;
    instance->pvr->toAddon->GetRecordingStreamProperties = ADDON_GetRecordingStreamProperties;
    instance->pvr->toAddon->CallRecordingMenuHook = ADDON_CallRecordingMenuHook;
    //--==----==----==----==----==----==----==----==----==----==----==----==----==
    instance->pvr->toAddon->GetTimerTypes = ADDON_GetTimerTypes;
    instance->pvr->toAddon->GetTimersAmount = ADDON_GetTimersAmount;
    instance->pvr->toAddon->GetTimers = ADDON_GetTimers;
    instance->pvr->toAddon->AddTimer = ADDON_AddTimer;
    instance->pvr->toAddon->DeleteTimer = ADDON_DeleteTimer;
    instance->pvr->toAddon->UpdateTimer = ADDON_UpdateTimer;
    instance->pvr->toAddon->CallTimerMenuHook = ADDON_CallTimerMenuHook;
    //--==----==----==----==----==----==----==----==----==----==----==----==----==
    instance->pvr->toAddon->OnSystemSleep = ADDON_OnSystemSleep;
    instance->pvr->toAddon->OnSystemWake = ADDON_OnSystemWake;
    instance->pvr->toAddon->OnPowerSavingActivated = ADDON_OnPowerSavingActivated;
    instance->pvr->toAddon->OnPowerSavingDeactivated = ADDON_OnPowerSavingDeactivated;
    //--==----==----==----==----==----==----==----==----==----==----==----==----==
    instance->pvr->toAddon->OpenLiveStream = ADDON_OpenLiveStream;
    instance->pvr->toAddon->CloseLiveStream = ADDON_CloseLiveStream;
    instance->pvr->toAddon->ReadLiveStream = ADDON_ReadLiveStream;
    instance->pvr->toAddon->SeekLiveStream = ADDON_SeekLiveStream;
    instance->pvr->toAddon->LengthLiveStream = ADDON_LengthLiveStream;
    instance->pvr->toAddon->GetStreamProperties = ADDON_GetStreamProperties;
    instance->pvr->toAddon->StreamClosed = ADDON_StreamClosed;
    instance->pvr->toAddon->GetStreamReadChunkSize = ADDON_GetStreamReadChunkSize;
    instance->pvr->toAddon->IsRealTimeStream = ADDON_IsRealTimeStream;
    //--==----==----==----==----==----==----==----==----==----==----==----==----==
    instance->pvr->toAddon->OpenRecordedStream = ADDON_OpenRecordedStream;
    instance->pvr->toAddon->CloseRecordedStream = ADDON_CloseRecordedStream;
    instance->pvr->toAddon->ReadRecordedStream = ADDON_ReadRecordedStream;
    instance->pvr->toAddon->SeekRecordedStream = ADDON_SeekRecordedStream;
    instance->pvr->toAddon->LengthRecordedStream = ADDON_LengthRecordedStream;
    instance->pvr->toAddon->IsRecordedStreamRealTime = ADDON_IsRecordedStreamRealTime;
    instance->pvr->toAddon->PauseRecordedStream = ADDON_PauseRecordedStream;
    instance->pvr->toAddon->GetRecordedStreamTimes = ADDON_GetRecordedStreamTimes;
    //--==----==----==----==----==----==----==----==----==----==----==----==----==
    instance->pvr->toAddon->DemuxReset = ADDON_DemuxReset;
    instance->pvr->toAddon->DemuxAbort = ADDON_DemuxAbort;
    instance->pvr->toAddon->DemuxFlush = ADDON_DemuxFlush;
    instance->pvr->toAddon->DemuxRead = ADDON_DemuxRead;
    //--==----==----==----==----==----==----==----==----==----==----==----==----==
    instance->pvr->toAddon->CanPauseStream = ADDON_CanPauseStream;
    instance->pvr->toAddon->PauseStream = ADDON_PauseStream;
    instance->pvr->toAddon->CanSeekStream = ADDON_CanSeekStream;
    instance->pvr->toAddon->SeekTime = ADDON_SeekTime;
    instance->pvr->toAddon->SetSpeed = ADDON_SetSpeed;
    instance->pvr->toAddon->FillBuffer = ADDON_FillBuffer;
    instance->pvr->toAddon->GetStreamTimes = ADDON_GetStreamTimes;
    //--==----==----==----==----==----==----==----==----==----==----==----==----==
    instance->pvr->toAddon->FreeCapabilities = ADDON_FreeCapabilities;
    instance->pvr->toAddon->FreeTimerTypes = ADDON_FreeTimerTypes;
    instance->pvr->toAddon->FreeProperties = ADDON_FreeProperties;
    instance->pvr->toAddon->FreeDescrambleInfo = ADDON_FreeDescrambleInfo;
    instance->pvr->toAddon->FreeSignalStatus = ADDON_FreeSignalStatus;
    instance->pvr->toAddon->FreeEdlEntries = ADDON_FreeEdlEntries;
    instance->pvr->toAddon->FreeString = ADDON_FreeString;
 
    m_instanceData = instance->pvr;
    m_instanceData->toAddon->addonInstance = this;
  }
 
  inline static PVR_ERROR ADDON_GetCapabilities(const AddonInstance_PVR* instance,
                                                PVR_ADDON_CAPABILITIES* capabilities)
  {
    PVRCapabilities cppCapabilities(capabilities);
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->GetCapabilities(cppCapabilities);
  }
 
  inline static PVR_ERROR ADDON_FreeCapabilities(const AddonInstance_PVR* instance,
                                                 PVR_ADDON_CAPABILITIES* capabilities)
  {
    PVRCapabilities::FreeResources(capabilities);
    return PVR_ERROR_NO_ERROR;
  }
 
  inline static PVR_ERROR ADDON_GetBackendName(const AddonInstance_PVR* instance, char** str)
  {
    std::string backendName;
    PVR_ERROR err = static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
                        ->GetBackendName(backendName);
    if (err == PVR_ERROR_NO_ERROR)
      *str = AllocAndCopyString(backendName.c_str());
    return err;
  }
 
  inline static PVR_ERROR ADDON_GetBackendVersion(const AddonInstance_PVR* instance, char** str)
  {
    std::string backendVersion;
    PVR_ERROR err = static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
                        ->GetBackendVersion(backendVersion);
    if (err == PVR_ERROR_NO_ERROR)
      *str = AllocAndCopyString(backendVersion.c_str());
    return err;
  }
 
  inline static PVR_ERROR ADDON_GetBackendHostname(const AddonInstance_PVR* instance, char** str)
  {
    std::string backendHostname;
    PVR_ERROR err = static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
                        ->GetBackendHostname(backendHostname);
    if (err == PVR_ERROR_NO_ERROR)
      *str = AllocAndCopyString(backendHostname.c_str());
    return err;
  }
 
  inline static PVR_ERROR ADDON_GetConnectionString(const AddonInstance_PVR* instance, char** str)
  {
    std::string connectionString;
    PVR_ERROR err = static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
                        ->GetConnectionString(connectionString);
    if (err == PVR_ERROR_NO_ERROR)
      *str = AllocAndCopyString(connectionString.c_str());
    return err;
  }
 
  inline static PVR_ERROR ADDON_GetDriveSpace(const AddonInstance_PVR* instance,
                                              uint64_t* total,
                                              uint64_t* used)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->GetDriveSpace(*total, *used);
  }
 
  inline static PVR_ERROR ADDON_CallSettingsMenuHook(const AddonInstance_PVR* instance,
                                                     const PVR_MENUHOOK* menuhook)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->CallSettingsMenuHook(menuhook);
  }
 
  //--==----==----==----==----==----==----==----==----==----==----==----==----==
 
  inline static PVR_ERROR ADDON_GetChannelsAmount(const AddonInstance_PVR* instance, int* amount)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->GetChannelsAmount(*amount);
  }
 
  inline static PVR_ERROR ADDON_GetChannels(const AddonInstance_PVR* instance,
                                            PVR_HANDLE handle,
                                            bool radio)
  {
    PVRChannelsResultSet result(instance, handle);
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->GetChannels(radio, result);
  }
 
  inline static PVR_ERROR ADDON_GetChannelStreamProperties(const AddonInstance_PVR* instance,
                                                           const PVR_CHANNEL* channel,
                                                           PVR_SOURCE source,
                                                           PVR_NAMED_VALUE*** properties,
                                                           unsigned int* propertiesCount)
  {
    *propertiesCount = 0;
    std::vector<PVRStreamProperty> propertiesList;
    PVR_ERROR error = static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
                          ->GetChannelStreamProperties(channel, source, propertiesList);
    if (error == PVR_ERROR_NO_ERROR && !propertiesList.empty())
    {
      *properties = AllocAndCopyPointerArray<PVRStreamProperty, PVR_NAMED_VALUE>(propertiesList,
                                                                                 *propertiesCount);
    }
    return error;
  }
 
  inline static PVR_ERROR ADDON_GetSignalStatus(const AddonInstance_PVR* instance,
                                                int channelUid,
                                                PVR_SIGNAL_STATUS* signalStatus)
  {
    PVRSignalStatus cppSignalStatus(signalStatus);
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->GetSignalStatus(channelUid, cppSignalStatus);
  }
 
  inline static PVR_ERROR ADDON_FreeSignalStatus(const AddonInstance_PVR* instance,
                                                 PVR_SIGNAL_STATUS* signalStatus)
  {
    PVRSignalStatus::FreeResources(signalStatus);
    return PVR_ERROR_NO_ERROR;
  }
 
  inline static PVR_ERROR ADDON_GetDescrambleInfo(const AddonInstance_PVR* instance,
                                                  int channelUid,
                                                  PVR_DESCRAMBLE_INFO* descrambleInfo)
  {
    PVRDescrambleInfo cppDescrambleInfo(descrambleInfo);
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->GetDescrambleInfo(channelUid, cppDescrambleInfo);
  }
 
  inline static PVR_ERROR ADDON_FreeDescrambleInfo(const AddonInstance_PVR* instance,
                                                   PVR_DESCRAMBLE_INFO* descrambleInfo)
  {
    PVRDescrambleInfo::FreeResources(descrambleInfo);
    return PVR_ERROR_NO_ERROR;
  }
 
  //--==----==----==----==----==----==----==----==----==----==----==----==----==
 
  inline static PVR_ERROR ADDON_GetProvidersAmount(const AddonInstance_PVR* instance, int* amount)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->GetProvidersAmount(*amount);
  }
 
  inline static PVR_ERROR ADDON_GetProviders(const AddonInstance_PVR* instance, PVR_HANDLE handle)
  {
    PVRProvidersResultSet result(instance, handle);
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)->GetProviders(result);
  }
 
  //--==----==----==----==----==----==----==----==----==----==----==----==----==
 
  inline static PVR_ERROR ADDON_GetChannelGroupsAmount(const AddonInstance_PVR* instance,
                                                       int* amount)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->GetChannelGroupsAmount(*amount);
  }
 
  inline static PVR_ERROR ADDON_GetChannelGroups(const AddonInstance_PVR* instance,
                                                 PVR_HANDLE handle,
                                                 bool radio)
  {
    PVRChannelGroupsResultSet result(instance, handle);
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->GetChannelGroups(radio, result);
  }
 
  inline static PVR_ERROR ADDON_GetChannelGroupMembers(const AddonInstance_PVR* instance,
                                                       PVR_HANDLE handle,
                                                       const PVR_CHANNEL_GROUP* group)
  {
    PVRChannelGroupMembersResultSet result(instance, handle);
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->GetChannelGroupMembers(group, result);
  }
 
  //--==----==----==----==----==----==----==----==----==----==----==----==----==
 
  inline static PVR_ERROR ADDON_DeleteChannel(const AddonInstance_PVR* instance,
                                              const PVR_CHANNEL* channel)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->DeleteChannel(channel);
  }
 
  inline static PVR_ERROR ADDON_RenameChannel(const AddonInstance_PVR* instance,
                                              const PVR_CHANNEL* channel)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->RenameChannel(channel);
  }
 
  inline static PVR_ERROR ADDON_OpenDialogChannelSettings(const AddonInstance_PVR* instance,
                                                          const PVR_CHANNEL* channel)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->OpenDialogChannelSettings(channel);
  }
 
  inline static PVR_ERROR ADDON_OpenDialogChannelAdd(const AddonInstance_PVR* instance,
                                                     const PVR_CHANNEL* channel)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->OpenDialogChannelAdd(channel);
  }
 
  inline static PVR_ERROR ADDON_OpenDialogChannelScan(const AddonInstance_PVR* instance)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->OpenDialogChannelScan();
  }
 
  inline static PVR_ERROR ADDON_CallChannelMenuHook(const AddonInstance_PVR* instance,
                                                    const PVR_MENUHOOK* menuhook,
                                                    const PVR_CHANNEL* channel)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->CallChannelMenuHook(menuhook, channel);
  }
 
  //--==----==----==----==----==----==----==----==----==----==----==----==----==
 
  inline static PVR_ERROR ADDON_GetEPGForChannel(const AddonInstance_PVR* instance,
                                                 PVR_HANDLE handle,
                                                 int channelUid,
                                                 time_t start,
                                                 time_t end)
  {
    PVREPGTagsResultSet result(instance, handle);
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->GetEPGForChannel(channelUid, start, end, result);
  }
 
  inline static PVR_ERROR ADDON_IsEPGTagRecordable(const AddonInstance_PVR* instance,
                                                   const EPG_TAG* tag,
                                                   bool* isRecordable)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->IsEPGTagRecordable(tag, *isRecordable);
  }
 
  inline static PVR_ERROR ADDON_IsEPGTagPlayable(const AddonInstance_PVR* instance,
                                                 const EPG_TAG* tag,
                                                 bool* isPlayable)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->IsEPGTagPlayable(tag, *isPlayable);
  }
 
  inline static PVR_ERROR ADDON_GetEPGTagEdl(const AddonInstance_PVR* instance,
                                             const EPG_TAG* tag,
                                             PVR_EDL_ENTRY*** edls,
                                             unsigned int* size)
  {
    *size = 0;
    std::vector<PVREDLEntry> edlList;
    PVR_ERROR error = static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
                          ->GetEPGTagEdl(tag, edlList);
    if (error == PVR_ERROR_NO_ERROR && !edlList.empty())
    {
      *edls = AllocAndCopyPointerArray<PVREDLEntry, PVR_EDL_ENTRY>(edlList, *size);
    }
    return error;
  }
 
  inline static PVR_ERROR ADDON_GetEPGTagStreamProperties(const AddonInstance_PVR* instance,
                                                          const EPG_TAG* tag,
                                                          PVR_NAMED_VALUE*** properties,
                                                          unsigned int* propertiesCount)
  {
    *propertiesCount = 0;
    std::vector<PVRStreamProperty> propertiesList;
    PVR_ERROR error = static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
                          ->GetEPGTagStreamProperties(tag, propertiesList);
    if (error == PVR_ERROR_NO_ERROR && !propertiesList.empty())
    {
      *properties = AllocAndCopyPointerArray<PVRStreamProperty, PVR_NAMED_VALUE>(propertiesList,
                                                                                 *propertiesCount);
    }
    return error;
  }
 
  inline static PVR_ERROR ADDON_SetEPGMaxPastDays(const AddonInstance_PVR* instance, int pastDays)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->SetEPGMaxPastDays(pastDays);
  }
 
  inline static PVR_ERROR ADDON_SetEPGMaxFutureDays(const AddonInstance_PVR* instance,
                                                    int futureDays)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->SetEPGMaxFutureDays(futureDays);
  }
 
  inline static PVR_ERROR ADDON_CallEPGMenuHook(const AddonInstance_PVR* instance,
                                                const PVR_MENUHOOK* menuhook,
                                                const EPG_TAG* tag)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->CallEPGMenuHook(menuhook, tag);
  }
 
  //--==----==----==----==----==----==----==----==----==----==----==----==----==
 
  inline static PVR_ERROR ADDON_GetRecordingsAmount(const AddonInstance_PVR* instance,
                                                    bool deleted,
                                                    int* amount)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->GetRecordingsAmount(deleted, *amount);
  }
 
  inline static PVR_ERROR ADDON_GetRecordings(const AddonInstance_PVR* instance,
                                              PVR_HANDLE handle,
                                              bool deleted)
  {
    PVRRecordingsResultSet result(instance, handle);
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->GetRecordings(deleted, result);
  }
 
  inline static PVR_ERROR ADDON_DeleteRecording(const AddonInstance_PVR* instance,
                                                const PVR_RECORDING* recording)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->DeleteRecording(recording);
  }
 
  inline static PVR_ERROR ADDON_UndeleteRecording(const AddonInstance_PVR* instance,
                                                  const PVR_RECORDING* recording)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->UndeleteRecording(recording);
  }
 
  inline static PVR_ERROR ADDON_DeleteAllRecordingsFromTrash(const AddonInstance_PVR* instance)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->DeleteAllRecordingsFromTrash();
  }
 
  inline static PVR_ERROR ADDON_RenameRecording(const AddonInstance_PVR* instance,
                                                const PVR_RECORDING* recording)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->RenameRecording(recording);
  }
 
  inline static PVR_ERROR ADDON_SetRecordingLifetime(const AddonInstance_PVR* instance,
                                                     const PVR_RECORDING* recording)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->SetRecordingLifetime(recording);
  }
 
  inline static PVR_ERROR ADDON_SetRecordingPlayCount(const AddonInstance_PVR* instance,
                                                      const PVR_RECORDING* recording,
                                                      int count)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->SetRecordingPlayCount(recording, count);
  }
 
  inline static PVR_ERROR ADDON_SetRecordingLastPlayedPosition(const AddonInstance_PVR* instance,
                                                               const PVR_RECORDING* recording,
                                                               int lastplayedposition)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->SetRecordingLastPlayedPosition(recording, lastplayedposition);
  }
 
  inline static PVR_ERROR ADDON_GetRecordingLastPlayedPosition(const AddonInstance_PVR* instance,
                                                               const PVR_RECORDING* recording,
                                                               int* position)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->GetRecordingLastPlayedPosition(recording, *position);
  }
 
  inline static PVR_ERROR ADDON_GetRecordingEdl(const AddonInstance_PVR* instance,
                                                const PVR_RECORDING* recording,
                                                PVR_EDL_ENTRY*** edls,
                                                unsigned int* size)
  {
    *size = 0;
    std::vector<PVREDLEntry> edlList;
    PVR_ERROR error = static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
                          ->GetRecordingEdl(recording, edlList);
    if (error == PVR_ERROR_NO_ERROR && !edlList.empty())
    {
      *edls = AllocAndCopyPointerArray<PVREDLEntry, PVR_EDL_ENTRY>(edlList, *size);
    }
    return error;
  }
 
  inline static PVR_ERROR ADDON_FreeEdlEntries(const AddonInstance_PVR* instance,
                                               PVR_EDL_ENTRY** edls,
                                               unsigned int size)
  {
    FreeStaticPointerArray<PVREDLEntry, PVR_EDL_ENTRY>(edls, size);
    return PVR_ERROR_NO_ERROR;
  }
 
  inline static PVR_ERROR ADDON_GetRecordingSize(const AddonInstance_PVR* instance,
                                                 const PVR_RECORDING* recording,
                                                 int64_t* size)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->GetRecordingSize(recording, *size);
  }
 
  inline static PVR_ERROR ADDON_GetRecordingStreamProperties(const AddonInstance_PVR* instance,
                                                             const PVR_RECORDING* recording,
                                                             PVR_NAMED_VALUE*** properties,
                                                             unsigned int* propertiesCount)
  {
    *propertiesCount = 0;
    std::vector<PVRStreamProperty> propertiesList;
    PVR_ERROR error = static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
                          ->GetRecordingStreamProperties(recording, propertiesList);
    if (error == PVR_ERROR_NO_ERROR && !propertiesList.empty())
    {
      *properties = AllocAndCopyPointerArray<PVRStreamProperty, PVR_NAMED_VALUE>(propertiesList,
                                                                                 *propertiesCount);
    }
    return error;
  }
 
  inline static PVR_ERROR ADDON_FreeProperties(const AddonInstance_PVR* instance,
                                               PVR_NAMED_VALUE** properties,
                                               unsigned int propertiesCount)
  {
    FreeDynamicPointerArray<PVRStreamProperty, PVR_NAMED_VALUE>(properties, propertiesCount);
    return PVR_ERROR_NO_ERROR;
  }
 
  inline static PVR_ERROR ADDON_CallRecordingMenuHook(const AddonInstance_PVR* instance,
                                                      const PVR_MENUHOOK* menuhook,
                                                      const PVR_RECORDING* recording)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->CallRecordingMenuHook(menuhook, recording);
  }
 
  //--==----==----==----==----==----==----==----==----==----==----==----==----==
 
  inline static PVR_ERROR ADDON_GetTimerTypes(const AddonInstance_PVR* instance,
                                              PVR_TIMER_TYPE*** types,
                                              unsigned int* typesCount)
  {
    *typesCount = 0;
    std::vector<PVRTimerType> timerTypes;
    PVR_ERROR error = static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
                          ->GetTimerTypes(timerTypes);
    if (error == PVR_ERROR_NO_ERROR && !timerTypes.empty())
    {
      *types = AllocAndCopyPointerArray<PVRTimerType, PVR_TIMER_TYPE>(timerTypes, *typesCount);
    }
    return error;
  }
 
  inline static PVR_ERROR ADDON_FreeTimerTypes(const AddonInstance_PVR* instance,
                                               PVR_TIMER_TYPE** types,
                                               unsigned int typesCount)
  {
    FreeDynamicPointerArray<PVRTimerType, PVR_TIMER_TYPE>(types, typesCount);
    return PVR_ERROR_NO_ERROR;
  }
 
  inline static PVR_ERROR ADDON_GetTimersAmount(const AddonInstance_PVR* instance, int* amount)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->GetTimersAmount(*amount);
  }
 
  inline static PVR_ERROR ADDON_GetTimers(const AddonInstance_PVR* instance, PVR_HANDLE handle)
  {
    PVRTimersResultSet result(instance, handle);
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)->GetTimers(result);
  }
 
  inline static PVR_ERROR ADDON_AddTimer(const AddonInstance_PVR* instance, const PVR_TIMER* timer)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)->AddTimer(timer);
  }
 
  inline static PVR_ERROR ADDON_DeleteTimer(const AddonInstance_PVR* instance,
                                            const PVR_TIMER* timer,
                                            bool forceDelete)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->DeleteTimer(timer, forceDelete);
  }
 
  inline static PVR_ERROR ADDON_UpdateTimer(const AddonInstance_PVR* instance,
                                            const PVR_TIMER* timer)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)->UpdateTimer(timer);
  }
 
  inline static PVR_ERROR ADDON_CallTimerMenuHook(const AddonInstance_PVR* instance,
                                                  const PVR_MENUHOOK* menuhook,
                                                  const PVR_TIMER* timer)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->CallTimerMenuHook(menuhook, timer);
  }
 
  //--==----==----==----==----==----==----==----==----==----==----==----==----==
 
  inline static PVR_ERROR ADDON_OnSystemSleep(const AddonInstance_PVR* instance)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)->OnSystemSleep();
  }
 
  inline static PVR_ERROR ADDON_OnSystemWake(const AddonInstance_PVR* instance)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)->OnSystemWake();
  }
 
  inline static PVR_ERROR ADDON_OnPowerSavingActivated(const AddonInstance_PVR* instance)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->OnPowerSavingActivated();
  }
 
  inline static PVR_ERROR ADDON_OnPowerSavingDeactivated(const AddonInstance_PVR* instance)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->OnPowerSavingDeactivated();
  }
 
  // obsolete parts below
 
  inline static bool ADDON_OpenLiveStream(const AddonInstance_PVR* instance,
                                          const PVR_CHANNEL* channel)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->OpenLiveStream(channel);
  }
 
  inline static void ADDON_CloseLiveStream(const AddonInstance_PVR* instance)
  {
    static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)->CloseLiveStream();
  }
 
  inline static int ADDON_ReadLiveStream(const AddonInstance_PVR* instance,
                                         unsigned char* buffer,
                                         unsigned int size)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->ReadLiveStream(buffer, size);
  }
 
  inline static int64_t ADDON_SeekLiveStream(const AddonInstance_PVR* instance,
                                             int64_t position,
                                             int whence)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->SeekLiveStream(position, whence);
  }
 
  inline static int64_t ADDON_LengthLiveStream(const AddonInstance_PVR* instance)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)->LengthLiveStream();
  }
 
  inline static PVR_ERROR ADDON_GetStreamProperties(const AddonInstance_PVR* instance,
                                                    PVR_STREAM_PROPERTIES* properties)
  {
    properties->iStreamCount = 0;
    std::vector<PVRStreamProperties> cppProperties;
    PVR_ERROR err = static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
                        ->GetStreamProperties(cppProperties);
    if (err == PVR_ERROR_NO_ERROR)
    {
      for (unsigned int i = 0; i < cppProperties.size(); ++i)
      {
        memcpy(&properties->stream[i],
               static_cast<PVR_STREAM_PROPERTIES::PVR_STREAM*>(cppProperties[i]),
               sizeof(PVR_STREAM_PROPERTIES::PVR_STREAM));
        ++properties->iStreamCount;
 
        if (properties->iStreamCount >= PVR_STREAM_MAX_STREAMS)
        {
          kodi::Log(
              ADDON_LOG_ERROR,
              "CInstancePVRClient::%s: Addon given with '%li' more allowed streams where '%i'",
              __func__, cppProperties.size(), PVR_STREAM_MAX_STREAMS);
          break;
        }
      }
    }
 
    return err;
  }
 
  inline static PVR_ERROR ADDON_StreamClosed(const AddonInstance_PVR* instance)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)->StreamClosed();
  }
 
  inline static PVR_ERROR ADDON_GetStreamReadChunkSize(const AddonInstance_PVR* instance,
                                                       int* chunksize)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->GetStreamReadChunkSize(*chunksize);
  }
 
  inline static bool ADDON_IsRealTimeStream(const AddonInstance_PVR* instance)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)->IsRealTimeStream();
  }
 
  inline static bool ADDON_OpenRecordedStream(const AddonInstance_PVR* instance,
                                              const PVR_RECORDING* recording,
                                              int64_t* streamId)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->OpenRecordedStream(recording, *streamId);
  }
 
  inline static void ADDON_CloseRecordedStream(const AddonInstance_PVR* instance, int64_t streamId)
  {
    static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->CloseRecordedStream(streamId);
  }
 
  inline static int ADDON_ReadRecordedStream(const AddonInstance_PVR* instance,
                                             int64_t streamId,
                                             unsigned char* buffer,
                                             unsigned int size)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->ReadRecordedStream(streamId, buffer, size);
  }
 
  inline static int64_t ADDON_SeekRecordedStream(const AddonInstance_PVR* instance,
                                                 int64_t streamId,
                                                 int64_t position,
                                                 int whence)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->SeekRecordedStream(streamId, position, whence);
  }
 
  inline static int64_t ADDON_LengthRecordedStream(const AddonInstance_PVR* instance,
                                                   int64_t streamId)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->LengthRecordedStream(streamId);
  }
 
  inline static PVR_ERROR ADDON_IsRecordedStreamRealTime(const AddonInstance_PVR* instance,
                                                         int64_t streamId,
                                                         bool* isRealTime)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->IsRecordedStreamRealTime(streamId, *isRealTime);
  }
 
  inline static PVR_ERROR ADDON_PauseRecordedStream(const AddonInstance_PVR* instance,
                                                    int64_t streamId,
                                                    bool paused)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->PauseRecordedStream(streamId, paused);
  }
 
  inline static PVR_ERROR ADDON_GetRecordedStreamTimes(const AddonInstance_PVR* instance,
                                                       int64_t streamId,
                                                       PVR_STREAM_TIMES* times)
  {
    PVRStreamTimes cppTimes(times);
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->GetRecordedStreamTimes(streamId, cppTimes);
  }
 
  inline static void ADDON_DemuxReset(const AddonInstance_PVR* instance)
  {
    static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)->DemuxReset();
  }
 
  inline static void ADDON_DemuxAbort(const AddonInstance_PVR* instance)
  {
    static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)->DemuxAbort();
  }
 
  inline static void ADDON_DemuxFlush(const AddonInstance_PVR* instance)
  {
    static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)->DemuxFlush();
  }
 
  inline static DEMUX_PACKET* ADDON_DemuxRead(const AddonInstance_PVR* instance)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)->DemuxRead();
  }
 
  inline static bool ADDON_CanPauseStream(const AddonInstance_PVR* instance)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)->CanPauseStream();
  }
 
  inline static bool ADDON_CanSeekStream(const AddonInstance_PVR* instance)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)->CanSeekStream();
  }
 
  inline static void ADDON_PauseStream(const AddonInstance_PVR* instance, bool bPaused)
  {
    static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)->PauseStream(bPaused);
  }
 
  inline static bool ADDON_SeekTime(const AddonInstance_PVR* instance,
                                    double time,
                                    bool backwards,
                                    double* startpts)
  {
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->SeekTime(time, backwards, *startpts);
  }
 
  inline static void ADDON_SetSpeed(const AddonInstance_PVR* instance, int speed)
  {
    static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)->SetSpeed(speed);
  }
 
  inline static void ADDON_FillBuffer(const AddonInstance_PVR* instance, bool mode)
  {
    static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)->FillBuffer(mode);
  }
 
  inline static PVR_ERROR ADDON_GetStreamTimes(const AddonInstance_PVR* instance,
                                               PVR_STREAM_TIMES* times)
  {
    PVRStreamTimes cppTimes(times);
    return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)
        ->GetStreamTimes(cppTimes);
  }
 
  inline static PVR_ERROR ADDON_FreeString(const AddonInstance_PVR* instance, char* str)
  {
    FreeString(str);
    return PVR_ERROR_NO_ERROR;
  }
 
  AddonInstance_PVR* m_instanceData = nullptr;
};
//}}}
//______________________________________________________________________________
 
} /* namespace addon */
} /* namespace kodi */
 
#endif /* __cplusplus */