Inputstream.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/inputstream.h"
#include "inputstream/StreamCodec.h"
#include "inputstream/StreamConstants.h"
#include "inputstream/StreamCrypto.h"
#include "inputstream/TimingConstants.h"
 
#ifdef __cplusplus
 
#include <map>
 
namespace kodi
{
namespace addon
{
 
//¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
// "C++" Doxygen group set for the definitions
//{{{
 
//==============================================================================
 
//##############################################################################
 
//##############################################################################
 
//##############################################################################
 
//##############################################################################
 
//##############################################################################
 
//}}}
//______________________________________________________________________________
 
class CInstanceInputStream;
 
//==============================================================================
class ATTR_DLL_LOCAL InputstreamProperty
  : public CStructHdl<InputstreamProperty, INPUTSTREAM_PROPERTY>
{
  friend class CInstanceInputStream;
public:
 
 
  std::string GetURL() const { return m_cStructure->m_strURL; }
 
  std::string GetMimeType() const { return m_cStructure->m_mimeType; }
 
  unsigned int GetPropertiesAmount() const { return m_cStructure->m_nCountInfoValues; }
 
  const std::map<std::string, std::string> GetProperties() const
  {
    std::map<std::string, std::string> props;
    for (unsigned int i = 0; i < m_cStructure->m_nCountInfoValues; ++i)
    {
      props.emplace(m_cStructure->m_ListItemProperties[i].m_strKey,
                    m_cStructure->m_ListItemProperties[i].m_strValue);
    }
    return props;
  }
 
  std::string GetLibFolder() const { return m_cStructure->m_libFolder; }
 
  std::string GetProfileFolder() const { return m_cStructure->m_profileFolder; }
 
 
private:
  InputstreamProperty() = delete;
  InputstreamProperty(const InputstreamProperty& stream) = delete;
  InputstreamProperty(const INPUTSTREAM_PROPERTY* stream) : CStructHdl(stream) {}
  InputstreamProperty(INPUTSTREAM_PROPERTY* stream) : CStructHdl(stream) {}
};
//------------------------------------------------------------------------------
 
//==============================================================================
class ATTR_DLL_LOCAL InputstreamCapabilities
  : public CStructHdl<InputstreamCapabilities, INPUTSTREAM_CAPABILITIES>
{
  friend class CInstanceInputStream;
public:
  InputstreamCapabilities() = default;
  InputstreamCapabilities(const InputstreamCapabilities& stream) : CStructHdl(stream) {}
 
 
  void SetMask(uint32_t mask) const { m_cStructure->m_mask = mask; }
 
  uint32_t GetMask() const { return m_cStructure->m_mask; }
 
 
private:
  InputstreamCapabilities(const INPUTSTREAM_CAPABILITIES* stream) : CStructHdl(stream) {}
  InputstreamCapabilities(INPUTSTREAM_CAPABILITIES* stream) : CStructHdl(stream) {}
};
//------------------------------------------------------------------------------
 
//==============================================================================
class ATTR_DLL_LOCAL InputstreamMasteringMetadata
  : public CStructHdl<InputstreamMasteringMetadata, INPUTSTREAM_MASTERING_METADATA>
{
  friend class CInstanceInputStream;
  friend class InputstreamInfo;
public:
  InputstreamMasteringMetadata() = default;
  InputstreamMasteringMetadata(const InputstreamMasteringMetadata& stream) : CStructHdl(stream) {}
  InputstreamMasteringMetadata& operator=(const InputstreamMasteringMetadata&) = default;
 
 
 
  bool operator==(const kodi::addon::InputstreamMasteringMetadata& right) const
  {
    if (memcmp(m_cStructure, right.m_cStructure, sizeof(INPUTSTREAM_MASTERING_METADATA)) == 0)
      return true;
    return false;
  }
 
  void SetPrimaryR_ChromaticityX(double value) { m_cStructure->primary_r_chromaticity_x = value; }
 
  double GetPrimaryR_ChromaticityX() { return m_cStructure->primary_r_chromaticity_x; }
 
  void SetPrimaryR_ChromaticityY(double value) { m_cStructure->primary_r_chromaticity_y = value; }
 
  double GetPrimaryR_ChromaticityY() { return m_cStructure->primary_r_chromaticity_y; }
 
  void SetPrimaryG_ChromaticityX(double value) { m_cStructure->primary_g_chromaticity_x = value; }
 
  double GetPrimaryG_ChromaticityX() { return m_cStructure->primary_g_chromaticity_x; }
 
  void SetPrimaryG_ChromaticityY(double value) { m_cStructure->primary_g_chromaticity_y = value; }
 
  double GetPrimaryG_ChromaticityY() { return m_cStructure->primary_g_chromaticity_y; }
 
  void SetPrimaryB_ChromaticityX(double value) { m_cStructure->primary_b_chromaticity_x = value; }
 
  double GetPrimaryB_ChromaticityX() { return m_cStructure->primary_b_chromaticity_x; }
 
  void SetPrimaryB_ChromaticityY(double value) { m_cStructure->primary_b_chromaticity_y = value; }
 
  double GetPrimaryB_ChromaticityY() { return m_cStructure->primary_b_chromaticity_y; }
 
  void SetWhitePoint_ChromaticityX(double value)
  {
    m_cStructure->white_point_chromaticity_x = value;
  }
 
  double GetWhitePoint_ChromaticityX() { return m_cStructure->white_point_chromaticity_x; }
 
  void SetWhitePoint_ChromaticityY(double value)
  {
    m_cStructure->white_point_chromaticity_y = value;
  }
 
  double GetWhitePoint_ChromaticityY() { return m_cStructure->white_point_chromaticity_y; }
 
  void SetLuminanceMax(double value) { m_cStructure->luminance_max = value; }
 
  double GetLuminanceMax() { return m_cStructure->luminance_max; }
 
  void SetLuminanceMin(double value) { m_cStructure->luminance_min = value; }
 
  double GetLuminanceMin() { return m_cStructure->luminance_min; }
 
 
private:
  InputstreamMasteringMetadata(const INPUTSTREAM_MASTERING_METADATA* stream) : CStructHdl(stream) {}
  InputstreamMasteringMetadata(INPUTSTREAM_MASTERING_METADATA* stream) : CStructHdl(stream) {}
};
//------------------------------------------------------------------------------
 
//==============================================================================
class ATTR_DLL_LOCAL InputstreamContentlightMetadata
  : public CStructHdl<InputstreamContentlightMetadata, INPUTSTREAM_CONTENTLIGHT_METADATA>
{
  friend class CInstanceInputStream;
  friend class InputstreamInfo;
public:
  InputstreamContentlightMetadata() = default;
  InputstreamContentlightMetadata(const InputstreamContentlightMetadata& stream)
    : CStructHdl(stream)
  {
  }
  InputstreamContentlightMetadata& operator=(const InputstreamContentlightMetadata&) = default;
 
 
  bool operator==(const kodi::addon::InputstreamContentlightMetadata& right) const
  {
    if (memcmp(m_cStructure, right.m_cStructure, sizeof(INPUTSTREAM_CONTENTLIGHT_METADATA)) == 0)
      return true;
    return false;
  }
 
  void SetMaxCll(uint64_t value) { m_cStructure->max_cll = value; }
 
  uint64_t GetMaxCll() { return m_cStructure->max_cll; }
 
  void SetMaxFall(uint64_t value) { m_cStructure->max_fall = value; }
 
  uint64_t GetMaxFall() { return m_cStructure->max_fall; }
 
 
private:
  InputstreamContentlightMetadata(const INPUTSTREAM_CONTENTLIGHT_METADATA* stream)
    : CStructHdl(stream)
  {
  }
  InputstreamContentlightMetadata(INPUTSTREAM_CONTENTLIGHT_METADATA* stream) : CStructHdl(stream) {}
};
//------------------------------------------------------------------------------
 
//==============================================================================
class ATTR_DLL_LOCAL InputstreamDvccMetadata
  : public CStructHdl<InputstreamDvccMetadata, INPUTSTREAM_DVCC_METADATA>
{
  friend class CInstanceInputStream;
  friend class InputstreamInfo;
public:
  InputstreamDvccMetadata() = default;
 
  InputstreamDvccMetadata(const InputstreamDvccMetadata& stream) : CStructHdl(stream) {}
 
  InputstreamDvccMetadata& operator=(const InputstreamDvccMetadata&) = default;
 
 
  bool operator==(const kodi::addon::InputstreamDvccMetadata& right) const
  {
    if (memcmp(m_cStructure, right.m_cStructure, sizeof(INPUTSTREAM_DVCC_METADATA)) == 0)
      return true;
    return false;
  }
 
  void SetDvVersionMajor(uint8_t value) { m_cStructure->m_dvVersionMajor = value; }
  uint8_t GetDvVersionMajor() const { return m_cStructure->m_dvVersionMajor; }
 
  void SetDvVersionMinor(uint8_t value) { m_cStructure->m_dvVersionMinor = value; }
  uint8_t GetDvVersionMinor() const { return m_cStructure->m_dvVersionMinor; }
 
  void SetDvProfile(uint8_t value) { m_cStructure->m_dvProfile = value; }
  uint8_t GetDvProfile() const { return m_cStructure->m_dvProfile; }
 
  void SetDvLevel(uint8_t value) { m_cStructure->m_dvLevel = value; }
  uint8_t GetDvLevel() const { return m_cStructure->m_dvLevel; }
 
  void SetRpuPresentFlag(bool value) { m_cStructure->m_rpuPresentFlag = value; }
  bool GetRpuPresentFlag() const { return m_cStructure->m_rpuPresentFlag; }
 
  void SetElPresentFlag(bool value) { m_cStructure->m_elPresentFlag = value; }
  bool GetElPresentFlag() const { return m_cStructure->m_elPresentFlag; }
 
  void SetBlPresentFlag(bool value) { m_cStructure->m_blPresentFlag = value; }
  bool GetBlPresentFlag() const { return m_cStructure->m_blPresentFlag; }
 
  void SetBlSignalCompatibilityId(uint8_t value)
  {
    m_cStructure->m_dvBlSignalCompatibilityId = value;
  }
  uint8_t GetBlSignalCompatibilityId() const { return m_cStructure->m_dvBlSignalCompatibilityId; }
 
  void SetMdCompression(uint8_t value) { m_cStructure->m_dvMdCompression = value; }
  uint8_t GetMdCompression() const { return m_cStructure->m_dvMdCompression; }
 
private:
  InputstreamDvccMetadata(const INPUTSTREAM_DVCC_METADATA* stream) : CStructHdl(stream) {}
 
  InputstreamDvccMetadata(INPUTSTREAM_DVCC_METADATA* stream) : CStructHdl(stream) {}
};
//------------------------------------------------------------------------------
 
//==============================================================================
class ATTR_DLL_LOCAL InputstreamInfo : public CStructHdl<InputstreamInfo, INPUTSTREAM_INFO>
{
  friend class CInstanceInputStream;
public:
  InputstreamInfo() = default;
  InputstreamInfo(const InputstreamInfo& stream) : CStructHdl(stream)
  {
    SetCryptoSession(stream.GetCryptoSession());
    CopyExtraData();
  }
 
 
  void SetStreamType(INPUTSTREAM_TYPE streamType) { m_cStructure->m_streamType = streamType; }
 
  INPUTSTREAM_TYPE GetStreamType() const { return m_cStructure->m_streamType; }
 
  void SetFeatures(uint32_t features) { m_cStructure->m_features = features; }
 
  uint32_t GetFeatures() const { return m_cStructure->m_features; }
 
  void SetFlags(uint32_t flags) { m_cStructure->m_flags = flags; }
 
  uint32_t GetFlags() const { return m_cStructure->m_flags; }
 
  void SetName(const std::string& name)
  {
    strncpy(m_cStructure->m_name, name.c_str(), INPUTSTREAM_MAX_STRING_NAME_SIZE);
  }
 
  std::string GetName() const { return m_cStructure->m_name; }
 
  void SetCodecName(const std::string& codecName)
  {
    strncpy(m_cStructure->m_codecName, codecName.c_str(), INPUTSTREAM_MAX_STRING_CODEC_SIZE);
  }
 
  std::string GetCodecName() const { return m_cStructure->m_codecName; }
 
  void SetCodecInternalName(const std::string& codecName)
  {
    strncpy(m_cStructure->m_codecInternalName, codecName.c_str(),
            INPUTSTREAM_MAX_STRING_CODEC_SIZE);
  }
 
  std::string GetCodecInternalName() const { return m_cStructure->m_codecInternalName; }
 
  void SetCodecProfile(STREAMCODEC_PROFILE codecProfile)
  {
    m_cStructure->m_codecProfile = codecProfile;
  }
 
  STREAMCODEC_PROFILE GetCodecProfile() const { return m_cStructure->m_codecProfile; }
 
  void SetPhysicalIndex(unsigned int id) { m_cStructure->m_pID = id; }
 
  unsigned int GetPhysicalIndex() const { return m_cStructure->m_pID; }
 
  void SetExtraData(const std::vector<uint8_t>& extraData)
  {
    m_extraData = extraData;
    m_cStructure->m_ExtraData = m_extraData.data();
    m_cStructure->m_ExtraSize = static_cast<unsigned int>(m_extraData.size());
  }
 
  void SetExtraData(const uint8_t* extraData, size_t extraSize)
  {
    m_extraData.clear();
    if (extraData && extraSize > 0)
    {
      for (size_t i = 0; i < extraSize; ++i)
        m_extraData.emplace_back(extraData[i]);
    }
 
    m_cStructure->m_ExtraData = m_extraData.data();
    m_cStructure->m_ExtraSize = static_cast<unsigned int>(m_extraData.size());
  }
 
  const std::vector<uint8_t>& GetExtraData() { return m_extraData; }
 
  size_t GetExtraDataSize() { return m_extraData.size(); }
 
  bool CompareExtraData(const uint8_t* extraData, size_t extraSize) const
  {
    if (!extraData || m_extraData.size() != extraSize)
      return false;
    for (size_t i = 0; i < extraSize; ++i)
    {
      if (m_extraData[i] != extraData[i])
        return false;
    }
    return true;
  }
 
  void ClearExtraData()
  {
    m_extraData.clear();
    m_cStructure->m_ExtraData = m_extraData.data();
    m_cStructure->m_ExtraSize = static_cast<unsigned int>(m_extraData.size());
  }
 
  void SetLanguage(const std::string& language)
  {
    strncpy(m_cStructure->m_language, language.c_str(), INPUTSTREAM_MAX_STRING_LANGUAGE_SIZE);
  }
 
  std::string GetLanguage() const { return m_cStructure->m_language; }
 
  void SetFpsScale(unsigned int fpsScale) { m_cStructure->m_FpsScale = fpsScale; }
 
  unsigned int GetFpsScale() const { return m_cStructure->m_FpsScale; }
 
  void SetFpsRate(unsigned int fpsRate) { m_cStructure->m_FpsRate = fpsRate; }
 
  unsigned int GetFpsRate() const { return m_cStructure->m_FpsRate; }
 
  void SetHeight(unsigned int height) { m_cStructure->m_Height = height; }
 
  unsigned int GetHeight() const { return m_cStructure->m_Height; }
 
  void SetWidth(unsigned int width) { m_cStructure->m_Width = width; }
 
  unsigned int GetWidth() const { return m_cStructure->m_Width; }
 
  void SetAspect(float aspect) { m_cStructure->m_Aspect = aspect; }
 
  float GetAspect() const { return m_cStructure->m_Aspect; }
 
  void SetChannels(unsigned int channels) { m_cStructure->m_Channels = channels; }
 
  unsigned int GetChannels() const { return m_cStructure->m_Channels; }
 
  void SetSampleRate(unsigned int sampleRate) { m_cStructure->m_SampleRate = sampleRate; }
 
  unsigned int GetSampleRate() const { return m_cStructure->m_SampleRate; }
 
  void SetBitRate(unsigned int bitRate) { m_cStructure->m_BitRate = bitRate; }
 
  unsigned int GetBitRate() const { return m_cStructure->m_BitRate; }
 
  void SetBitsPerSample(unsigned int bitsPerSample)
  {
    m_cStructure->m_BitsPerSample = bitsPerSample;
  }
 
  unsigned int GetBitsPerSample() const { return m_cStructure->m_BitsPerSample; }
 
  void SetBlockAlign(unsigned int blockAlign) { m_cStructure->m_BlockAlign = blockAlign; }
 
  unsigned int GetBlockAlign() const { return m_cStructure->m_BlockAlign; }
 
  void SetCryptoSession(const kodi::addon::StreamCryptoSession& cryptoSession)
  {
    m_cryptoSession = cryptoSession;
    memcpy(&m_cStructure->m_cryptoSession, m_cryptoSession.GetCStructure(),
           sizeof(STREAM_CRYPTO_SESSION));
  }
 
  const kodi::addon::StreamCryptoSession& GetCryptoSession() const { return m_cryptoSession; }
 
  void SetCodecFourCC(unsigned int codecFourCC) { m_cStructure->m_codecFourCC = codecFourCC; }
 
  unsigned int GetCodecFourCC() const { return m_cStructure->m_codecFourCC; }
 
  void SetColorSpace(INPUTSTREAM_COLORSPACE colorSpace) { m_cStructure->m_colorSpace = colorSpace; }
 
  INPUTSTREAM_COLORSPACE GetColorSpace() const { return m_cStructure->m_colorSpace; }
 
  void SetColorRange(INPUTSTREAM_COLORRANGE colorRange) { m_cStructure->m_colorRange = colorRange; }
 
  INPUTSTREAM_COLORRANGE GetColorRange() const { return m_cStructure->m_colorRange; }
 
  void SetColorPrimaries(INPUTSTREAM_COLORPRIMARIES colorPrimaries)
  {
    m_cStructure->m_colorPrimaries = colorPrimaries;
  }
 
  INPUTSTREAM_COLORPRIMARIES GetColorPrimaries() const { return m_cStructure->m_colorPrimaries; }
 
  void SetColorTransferCharacteristic(INPUTSTREAM_COLORTRC colorTransferCharacteristic)
  {
    m_cStructure->m_colorTransferCharacteristic = colorTransferCharacteristic;
  }
 
  INPUTSTREAM_COLORTRC GetColorTransferCharacteristic() const
  {
    return m_cStructure->m_colorTransferCharacteristic;
  }
 
  void SetMasteringMetadata(const kodi::addon::InputstreamMasteringMetadata& masteringMetadata)
  {
    m_masteringMetadata = masteringMetadata;
    m_cStructure->m_masteringMetadata = m_masteringMetadata;
  }
 
  const kodi::addon::InputstreamMasteringMetadata& GetMasteringMetadata() const
  {
    return m_masteringMetadata;
  }
 
  void ClearMasteringMetadata() { m_cStructure->m_masteringMetadata = nullptr; }
 
  void SetContentLightMetadata(
      const kodi::addon::InputstreamContentlightMetadata& contentLightMetadata)
  {
    m_contentLightMetadata = contentLightMetadata;
    m_cStructure->m_contentLightMetadata = m_contentLightMetadata;
  }
 
  const kodi::addon::InputstreamContentlightMetadata& GetContentLightMetadata() const
  {
    return m_contentLightMetadata;
  }
 
  void ClearContentLightMetadata() { m_cStructure->m_contentLightMetadata = nullptr; }
 
  void SetDvccMetadata(const kodi::addon::InputstreamDvccMetadata& dvccMetadata)
  {
    m_dvccMetadata = dvccMetadata;
    m_cStructure->m_dvccMetadata = m_dvccMetadata;
  }
 
  const kodi::addon::InputstreamDvccMetadata& GetDvccMetadata() const { return m_dvccMetadata; }
 
  void ClearDvccMetadata() { m_cStructure->m_dvccMetadata = nullptr; }
 
 
private:
  InputstreamInfo(const INPUTSTREAM_INFO* stream) : CStructHdl(stream)
  {
    SetCryptoSession(StreamCryptoSession(&stream->m_cryptoSession));
    CopyExtraData();
  }
  InputstreamInfo(INPUTSTREAM_INFO* stream) : CStructHdl(stream)
  {
    SetCryptoSession(StreamCryptoSession(&stream->m_cryptoSession));
    CopyExtraData();
  }
 
  void CopyExtraData()
  {
    if (m_cStructure->m_ExtraData && m_cStructure->m_ExtraSize > 0)
    {
      for (unsigned int i = 0; i < m_cStructure->m_ExtraSize; ++i)
        m_extraData.emplace_back(m_cStructure->m_ExtraData[i]);
    }
    if (m_cStructure->m_masteringMetadata)
      m_masteringMetadata = m_cStructure->m_masteringMetadata;
    if (m_cStructure->m_contentLightMetadata)
      m_contentLightMetadata = m_cStructure->m_contentLightMetadata;
  }
  std::vector<uint8_t> m_extraData;
  StreamCryptoSession m_cryptoSession;
  InputstreamMasteringMetadata m_masteringMetadata;
  InputstreamContentlightMetadata m_contentLightMetadata;
  InputstreamDvccMetadata m_dvccMetadata;
};
//------------------------------------------------------------------------------
 
//==============================================================================
class ATTR_DLL_LOCAL InputstreamTimes : public CStructHdl<InputstreamTimes, INPUTSTREAM_TIMES>
{
  friend class CInstanceInputStream;
public:
  InputstreamTimes() = default;
  InputstreamTimes(const InputstreamTimes& stream) : CStructHdl(stream) {}
 
 
  void SetStartTime(time_t startTime) const { m_cStructure->startTime = startTime; }
 
  time_t GetStartTime() const { return m_cStructure->startTime; }
 
  void SetPtsStart(double ptsStart) const { m_cStructure->ptsStart = ptsStart; }
 
  double GetPtsStart() const { return m_cStructure->ptsStart; }
 
  void SetPtsBegin(double ptsBegin) const { m_cStructure->ptsBegin = ptsBegin; }
 
  double GetPtsBegin() const { return m_cStructure->ptsBegin; }
 
  void SetPtsEnd(double ptsEnd) const { m_cStructure->ptsEnd = ptsEnd; }
 
  double GetPtsEnd() const { return m_cStructure->ptsEnd; }
 
 
private:
  InputstreamTimes(const INPUTSTREAM_TIMES* stream) : CStructHdl(stream) {}
  InputstreamTimes(INPUTSTREAM_TIMES* stream) : CStructHdl(stream) {}
};
//------------------------------------------------------------------------------
 
//============================================================================
//------------------------------------------------------------------------------
class ATTR_DLL_LOCAL CInstanceInputStream : public IAddonInstance
{
public:
  //============================================================================
  explicit CInstanceInputStream(const IInstanceInfo& instance) : IAddonInstance(instance)
  {
    if (CPrivateBase::m_interface->globalSingleInstance != nullptr)
      throw std::logic_error("kodi::addon::CInstanceInputStream: Creation of multiple together "
                             "with single instance way is not allowed!");
 
    SetAddonStruct(instance);
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  ~CInstanceInputStream() override = default;
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual void GetCapabilities(kodi::addon::InputstreamCapabilities& capabilities) = 0;
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual bool Open(const kodi::addon::InputstreamProperty& props) = 0;
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual void Close() = 0;
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual bool IsRealTimeStream() { return true; }
  //----------------------------------------------------------------------------
 
  //############################################################################
 
  //============================================================================
  virtual int ReadStream(uint8_t* buffer, unsigned int bufferSize) { return -1; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual int64_t SeekStream(int64_t position, int whence = SEEK_SET) { return -1; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual int64_t PositionStream() { return -1; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual int64_t LengthStream() { return -1; }
  //--------------------------------------------------------------------------
 
  //==========================================================================
  virtual int GetBlockSize() { return 0; }
  //--------------------------------------------------------------------------
 
 
  //############################################################################
 
  //============================================================================
  virtual bool GetStreamIds(std::vector<unsigned int>& ids) { return false; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual bool GetStream(int streamid, kodi::addon::InputstreamInfo& stream) { return false; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual void EnableStream(int streamid, bool enable) {}
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual bool OpenStream(int streamid) { return false; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual void DemuxReset() {}
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual void DemuxAbort() {}
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual void DemuxFlush() {}
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual DEMUX_PACKET* DemuxRead() { return nullptr; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual bool DemuxSeekTime(double time, bool backwards, double& startpts) { return false; }
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual void DemuxSetSpeed(int speed) {}
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual void SetVideoResolution(unsigned int width, unsigned int height) {}
  //----------------------------------------------------------------------------
 
  //============================================================================
  virtual void SetVideoResolution(unsigned int width,
                                  unsigned int height,
                                  unsigned int maxWidth,
                                  unsigned int maxHeight)
  {
  }
  //----------------------------------------------------------------------------
 
  //=============================================================================
  DEMUX_PACKET* AllocateDemuxPacket(int dataSize)
  {
    return m_instanceData->toKodi->allocate_demux_packet(m_instanceData->toKodi->kodiInstance,
                                                         dataSize);
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  DEMUX_PACKET* AllocateEncryptedDemuxPacket(int dataSize, unsigned int encryptedSubsampleCount)
  {
    return m_instanceData->toKodi->allocate_encrypted_demux_packet(
        m_instanceData->toKodi->kodiInstance, dataSize, encryptedSubsampleCount);
  }
  //----------------------------------------------------------------------------
 
  //============================================================================
  void FreeDemuxPacket(DEMUX_PACKET* packet)
  {
    return m_instanceData->toKodi->free_demux_packet(m_instanceData->toKodi->kodiInstance, packet);
  }
  //----------------------------------------------------------------------------
 
 
  //############################################################################
 
  //==========================================================================
  virtual int GetTotalTime() { return -1; }
  //--------------------------------------------------------------------------
 
  //==========================================================================
  virtual int GetTime() { return -1; }
  //--------------------------------------------------------------------------
 
 
  //############################################################################
 
  //============================================================================
  virtual bool GetTimes(InputstreamTimes& times) { return false; }
  //----------------------------------------------------------------------------
 
 
  //############################################################################
 
  //============================================================================
  virtual bool PosTime(int ms) { return false; }
  //----------------------------------------------------------------------------
 
 
  //############################################################################
 
  //==========================================================================
  virtual int GetChapter() { return -1; }
  //--------------------------------------------------------------------------
 
  //==========================================================================
  virtual int GetChapterCount() { return 0; }
  //--------------------------------------------------------------------------
 
  //==========================================================================
  virtual const char* GetChapterName(int ch) { return nullptr; }
  //--------------------------------------------------------------------------
 
  //==========================================================================
  virtual int64_t GetChapterPos(int ch) { return 0; }
  //--------------------------------------------------------------------------
 
  //==========================================================================
  virtual bool SeekChapter(int ch) { return false; }
  //--------------------------------------------------------------------------
 
 
private:
  static int compareVersion(const int v1[3], const int v2[3])
  {
    for (unsigned i(0); i < 3; ++i)
      if (v1[i] != v2[i])
        return v1[i] - v2[i];
    return 0;
  }
 
  void SetAddonStruct(KODI_ADDON_INSTANCE_STRUCT* instance)
  {
    int api[3] = {0, 0, 0};
    sscanf(GetInstanceAPIVersion().c_str(), "%d.%d.%d", &api[0], &api[1], &api[2]);
 
    instance->hdl = this;
    instance->inputstream->toAddon->open = ADDON_Open;
    instance->inputstream->toAddon->close = ADDON_Close;
    instance->inputstream->toAddon->get_capabilities = ADDON_GetCapabilities;
 
    instance->inputstream->toAddon->get_stream_ids = ADDON_GetStreamIds;
    instance->inputstream->toAddon->get_stream = ADDON_GetStream;
    instance->inputstream->toAddon->enable_stream = ADDON_EnableStream;
    instance->inputstream->toAddon->open_stream = ADDON_OpenStream;
    instance->inputstream->toAddon->demux_reset = ADDON_DemuxReset;
    instance->inputstream->toAddon->demux_abort = ADDON_DemuxAbort;
    instance->inputstream->toAddon->demux_flush = ADDON_DemuxFlush;
    instance->inputstream->toAddon->demux_read = ADDON_DemuxRead;
    instance->inputstream->toAddon->demux_seek_time = ADDON_DemuxSeekTime;
    instance->inputstream->toAddon->demux_set_speed = ADDON_DemuxSetSpeed;
    instance->inputstream->toAddon->set_video_resolution = ADDON_SetVideoResolution;
 
    instance->inputstream->toAddon->get_total_time = ADDON_GetTotalTime;
    instance->inputstream->toAddon->get_time = ADDON_GetTime;
 
    instance->inputstream->toAddon->get_times = ADDON_GetTimes;
    instance->inputstream->toAddon->pos_time = ADDON_PosTime;
 
    instance->inputstream->toAddon->read_stream = ADDON_ReadStream;
    instance->inputstream->toAddon->seek_stream = ADDON_SeekStream;
    instance->inputstream->toAddon->position_stream = ADDON_PositionStream;
    instance->inputstream->toAddon->length_stream = ADDON_LengthStream;
    instance->inputstream->toAddon->is_real_time_stream = ADDON_IsRealTimeStream;
 
    // Added on 2.0.10
    instance->inputstream->toAddon->get_chapter = ADDON_GetChapter;
    instance->inputstream->toAddon->get_chapter_count = ADDON_GetChapterCount;
    instance->inputstream->toAddon->get_chapter_name = ADDON_GetChapterName;
    instance->inputstream->toAddon->get_chapter_pos = ADDON_GetChapterPos;
    instance->inputstream->toAddon->seek_chapter = ADDON_SeekChapter;
 
    // Added on 2.0.12
    instance->inputstream->toAddon->block_size_stream = ADDON_GetBlockSize;
 
    /*
    // Way to include part on new API version
    int minPartVersion[3] = { 3, 0, 0 };
    if (compareVersion(api, minPartVersion) >= 0)
    {
 
    }
    */
 
    m_instanceData = instance->inputstream;
    m_instanceData->toAddon->addonInstance = this;
  }
 
  inline static bool ADDON_Open(const AddonInstance_InputStream* instance,
                                INPUTSTREAM_PROPERTY* props)
  {
    return static_cast<CInstanceInputStream*>(instance->toAddon->addonInstance)->Open(props);
  }
 
  inline static void ADDON_Close(const AddonInstance_InputStream* instance)
  {
    static_cast<CInstanceInputStream*>(instance->toAddon->addonInstance)->Close();
  }
 
  inline static void ADDON_GetCapabilities(const AddonInstance_InputStream* instance,
                                           INPUTSTREAM_CAPABILITIES* capabilities)
  {
    InputstreamCapabilities caps(capabilities);
    static_cast<CInstanceInputStream*>(instance->toAddon->addonInstance)->GetCapabilities(caps);
  }
 
  // IDemux
  inline static bool ADDON_GetStreamIds(const AddonInstance_InputStream* instance,
                                        struct INPUTSTREAM_IDS* ids)
  {
    std::vector<unsigned int> idList;
    bool ret =
        static_cast<CInstanceInputStream*>(instance->toAddon->addonInstance)->GetStreamIds(idList);
    if (ret)
    {
      for (size_t i = 0; i < idList.size() && i < INPUTSTREAM_MAX_STREAM_COUNT; ++i)
      {
        ids->m_streamCount++;
        ids->m_streamIds[i] = idList[i];
      }
    }
    return ret;
  }
 
  inline static bool ADDON_GetStream(
      const AddonInstance_InputStream* instance,
      int streamid,
      struct INPUTSTREAM_INFO* info,
      KODI_HANDLE* demuxStream,
      KODI_HANDLE (*transfer_stream)(KODI_HANDLE handle,
                                     int streamId,
                                     struct INPUTSTREAM_INFO* stream))
  {
    InputstreamInfo infoData(info);
    bool ret = static_cast<CInstanceInputStream*>(instance->toAddon->addonInstance)
                   ->GetStream(streamid, infoData);
    if (ret && transfer_stream)
    {
      // Do this with given callback to prevent memory problems and leaks. This
      // then create on Kodi the needed class where then given back on demuxStream.
      *demuxStream = transfer_stream(instance->toKodi->kodiInstance, streamid, info);
    }
    return ret;
  }
 
  inline static void ADDON_EnableStream(const AddonInstance_InputStream* instance,
                                        int streamid,
                                        bool enable)
  {
    static_cast<CInstanceInputStream*>(instance->toAddon->addonInstance)
        ->EnableStream(streamid, enable);
  }
 
  inline static bool ADDON_OpenStream(const AddonInstance_InputStream* instance, int streamid)
  {
    return static_cast<CInstanceInputStream*>(instance->toAddon->addonInstance)
        ->OpenStream(streamid);
  }
 
  inline static void ADDON_DemuxReset(const AddonInstance_InputStream* instance)
  {
    static_cast<CInstanceInputStream*>(instance->toAddon->addonInstance)->DemuxReset();
  }
 
  inline static void ADDON_DemuxAbort(const AddonInstance_InputStream* instance)
  {
    static_cast<CInstanceInputStream*>(instance->toAddon->addonInstance)->DemuxAbort();
  }
 
  inline static void ADDON_DemuxFlush(const AddonInstance_InputStream* instance)
  {
    static_cast<CInstanceInputStream*>(instance->toAddon->addonInstance)->DemuxFlush();
  }
 
  inline static DEMUX_PACKET* ADDON_DemuxRead(const AddonInstance_InputStream* instance)
  {
    return static_cast<CInstanceInputStream*>(instance->toAddon->addonInstance)->DemuxRead();
  }
 
  inline static bool ADDON_DemuxSeekTime(const AddonInstance_InputStream* instance,
                                         double time,
                                         bool backwards,
                                         double* startpts)
  {
    return static_cast<CInstanceInputStream*>(instance->toAddon->addonInstance)
        ->DemuxSeekTime(time, backwards, *startpts);
  }
 
  inline static void ADDON_DemuxSetSpeed(const AddonInstance_InputStream* instance, int speed)
  {
    static_cast<CInstanceInputStream*>(instance->toAddon->addonInstance)->DemuxSetSpeed(speed);
  }
 
  inline static void ADDON_SetVideoResolution(const AddonInstance_InputStream* instance,
                                              unsigned int width,
                                              unsigned int height,
                                              unsigned int maxWidth,
                                              unsigned int maxHeight)
  {
    static_cast<CInstanceInputStream*>(instance->toAddon->addonInstance)
        ->SetVideoResolution(width, height);
    static_cast<CInstanceInputStream*>(instance->toAddon->addonInstance)
        ->SetVideoResolution(width, height, maxWidth, maxHeight);
  }
 
  // IDisplayTime
  inline static int ADDON_GetTotalTime(const AddonInstance_InputStream* instance)
  {
    return static_cast<CInstanceInputStream*>(instance->toAddon->addonInstance)->GetTotalTime();
  }
 
  inline static int ADDON_GetTime(const AddonInstance_InputStream* instance)
  {
    return static_cast<CInstanceInputStream*>(instance->toAddon->addonInstance)->GetTime();
  }
 
  // ITime
  inline static bool ADDON_GetTimes(const AddonInstance_InputStream* instance,
                                    INPUTSTREAM_TIMES* times)
  {
    InputstreamTimes cppTimes(times);
    return static_cast<CInstanceInputStream*>(instance->toAddon->addonInstance)->GetTimes(cppTimes);
  }
 
  // IPosTime
  inline static bool ADDON_PosTime(const AddonInstance_InputStream* instance, int ms)
  {
    return static_cast<CInstanceInputStream*>(instance->toAddon->addonInstance)->PosTime(ms);
  }
 
  inline static int ADDON_GetChapter(const AddonInstance_InputStream* instance)
  {
    return static_cast<CInstanceInputStream*>(instance->toAddon->addonInstance)->GetChapter();
  }
 
  inline static int ADDON_GetChapterCount(const AddonInstance_InputStream* instance)
  {
    return static_cast<CInstanceInputStream*>(instance->toAddon->addonInstance)->GetChapterCount();
  }
 
  inline static const char* ADDON_GetChapterName(const AddonInstance_InputStream* instance, int ch)
  {
    return static_cast<CInstanceInputStream*>(instance->toAddon->addonInstance)->GetChapterName(ch);
  }
 
  inline static int64_t ADDON_GetChapterPos(const AddonInstance_InputStream* instance, int ch)
  {
    return static_cast<CInstanceInputStream*>(instance->toAddon->addonInstance)->GetChapterPos(ch);
  }
 
  inline static bool ADDON_SeekChapter(const AddonInstance_InputStream* instance, int ch)
  {
    return static_cast<CInstanceInputStream*>(instance->toAddon->addonInstance)->SeekChapter(ch);
  }
 
  inline static int ADDON_ReadStream(const AddonInstance_InputStream* instance,
                                     uint8_t* buffer,
                                     unsigned int bufferSize)
  {
    return static_cast<CInstanceInputStream*>(instance->toAddon->addonInstance)
        ->ReadStream(buffer, bufferSize);
  }
 
  inline static int64_t ADDON_SeekStream(const AddonInstance_InputStream* instance,
                                         int64_t position,
                                         int whence)
  {
    return static_cast<CInstanceInputStream*>(instance->toAddon->addonInstance)
        ->SeekStream(position, whence);
  }
 
  inline static int64_t ADDON_PositionStream(const AddonInstance_InputStream* instance)
  {
    return static_cast<CInstanceInputStream*>(instance->toAddon->addonInstance)->PositionStream();
  }
 
  inline static int64_t ADDON_LengthStream(const AddonInstance_InputStream* instance)
  {
    return static_cast<CInstanceInputStream*>(instance->toAddon->addonInstance)->LengthStream();
  }
 
  inline static int ADDON_GetBlockSize(const AddonInstance_InputStream* instance)
  {
    return static_cast<CInstanceInputStream*>(instance->toAddon->addonInstance)->GetBlockSize();
  }
 
  inline static bool ADDON_IsRealTimeStream(const AddonInstance_InputStream* instance)
  {
    return static_cast<CInstanceInputStream*>(instance->toAddon->addonInstance)->IsRealTimeStream();
  }
 
  AddonInstance_InputStream* m_instanceData;
};
//------------------------------------------------------------------------------
 
} /* namespace addon */
} /* namespace kodi */
 
#endif /* __cplusplus */