sync with upstreamMatrix

15 files changed, 2330 insertions, 771 deletions

diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/AudioDecoder.h b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/AudioDecoder.h
index a6bea7d..747225f 100644
--- a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/AudioDecoder.h
+++ b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/AudioDecoder.h
@@ -241,7 +241,7 @@ private:
 
 //==============================================================================
 ///
-/// \addtogroup cpp_kodi_addon_audiodecoder
+/// @addtogroup cpp_kodi_addon_audiodecoder
 /// @brief \cpp_class{ kodi::addon::CInstanceAudioDecoder }
 /// **Audio decoder add-on instance**
 ///
@@ -289,9 +289,11 @@ private:
 /// |:------------------------------|----------------------------------------
 /// | <b>`point`</b>                | Addon type specification<br>At all addon types and for this kind always <b>"kodi.audiodecoder"</b>.
 /// | <b>`library_@PLATFORM@`</b>   | Sets the used library name, which is automatically set by cmake at addon build.
-/// | <b>`name`</b>                 | The name of the decoder used in Kodi for display.
 /// | <b>`extension`</b>            | The file extensions / styles supported by this addon.
-/// | <b>`tags`</b>                 | Boolean to point out that addon can bring own information to replayed file, if <b>`false`</b> only the file name is used as info.<br>If <b>`true`</b>, \ref CInstanceAudioDecoder::ReadTag is used and must be implemented.
+/// | <b>`mimetype`</b>             | A stream URL mimetype where can be used to force to this addon.
+/// | <b>`name`</b>                 | The name of the decoder used in Kodi for display.
+/// | <b>`tags`</b>                 | Boolean to point out that addon can bring own information to replayed file, if <b>`false`</b> only the file name is used as info.<br>If <b>`true`</b>, @ref CInstanceAudioDecoder::ReadTag is used and must be implemented.
+/// | <b>`tracks`</b>               | Boolean to in inform one file can contains several different streams.
 ///
 /// --------------------------------------------------------------------------
 ///
diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/Inputstream.h b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/Inputstream.h
index 396b92e..c4c7aca 100644
--- a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/Inputstream.h
+++ b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/Inputstream.h
@@ -8,435 +8,1162 @@
 
 #pragma once
 
-/*
- * Parts with a comment named "internal" are only used inside header and not
- * used or accessed direct during add-on development!
- */
-
 #include "../AddonBase.h"
-#include "../StreamCodec.h"
-#include "../StreamCrypto.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
+{
 
-#ifdef BUILD_KODI_ADDON
-#include "../DemuxPacket.h"
-#include "../InputStreamConstants.h"
-#else
-#include "cores/VideoPlayer/Interface/Addon/DemuxPacket.h"
-#include "cores/VideoPlayer/Interface/Addon/InputStreamConstants.h"
-#endif
+//¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
+// "C++" Doxygen group set for the definitions
+//{{{
 
-//Increment this level always if you add features which can lead to compile failures in the addon
-#define INPUTSTREAM_VERSION_LEVEL 2
+//==============================================================================
+/// @defgroup cpp_kodi_addon_inputstream_Defs Definitions, structures and enumerators
+/// @ingroup cpp_kodi_addon_inputstream
+/// @brief **Inputstream add-on instance definition values**\n
+/// All inputstream functions associated data structures.
+///
+/// Used to exchange the available options between Kodi and addon.\n
+/// The groups described here correspond to the groups of functions on inputstream
+/// instance class.
+///
+/// In addition, some of the things described here are also used on the
+/// @ref cpp_kodi_addon_videocodec "video codec" addon.
+///
 
-#define INPUTSTREAM_MAX_STREAM_COUNT 256
-#define INPUTSTREAM_MAX_STRING_NAME_SIZE 256
-#define INPUTSTREAM_MAX_STRING_CODEC_SIZE 32
-#define INPUTSTREAM_MAX_STRING_LANGUAGE_SIZE 64
+//##############################################################################
+/// @defgroup cpp_kodi_addon_inputstream_Defs_Interface 1. Interface
+/// @ingroup cpp_kodi_addon_inputstream_Defs
+/// @brief **Inputstream add-on general variables**\n
+/// Used to exchange the available options between Kodi and addon.
+///
 
-#ifdef __cplusplus
-extern "C"
+//##############################################################################
+/// @defgroup cpp_kodi_addon_inputstream_Defs_StreamConstants 2. Stream constants
+/// @ingroup cpp_kodi_addon_inputstream_Defs
+/// @brief **Used to exchange any additional data between the caller and processor.**\n
+/// This includes the standardized values, in addition, an addon can also use
+/// its own special uses to be exchanged in the same way.
+///
+/// These values can be used by other addons (e.g. video addon) or stream files
+/// to select the respective inputstream addon and to transfer additional values.
+///
+/// ----------------------------------------------------------------------------
+///
+/// **Example:**
+///
+/// This example use the @ref STREAM_PROPERTY_INPUTSTREAM on a <b>`*.strm`</b>
+/// file to select needed addon and a additional value where related to selected
+/// addon itself.
+///
+/// ~~~~~~~~~~~~
+/// #KODIPROP:inputstream=inputstream.adaptive
+/// #KODIPROP:inputstream.adaptive.manifest_type=mpd
+/// http://rdmedia.bbc.co.uk/dash/ondemand/testcard/1/client_manifest-events-multilang.mpd
+/// ~~~~~~~~~~~~
+///
+/// These are then given to Kodi and the respectively selected addon by means of
+/// his @ref kodi::addon::CInstanceInputStream::Open "Open" call
+/// in @ref kodi::addon::InputstreamProperty::GetProperties.
+///
+/// The largest possible amount of these <b>`#KODIPROP`</b> values is defined
+/// with @ref STREAM_MAX_PROPERTY_COUNT.
+///
+
+//##############################################################################
+/// @defgroup cpp_kodi_addon_inputstream_Defs_TimingConstants 3. Stream timing
+/// @ingroup cpp_kodi_addon_inputstream_Defs
+/// @brief **Timebase and timestamp definitions.**\n
+/// Used to exchange the available options between Kodi and addon.
+///
+
+//##############################################################################
+/// @defgroup cpp_kodi_addon_inputstream_Defs_StreamCodec 4. Stream codec
+/// @ingroup cpp_kodi_addon_inputstream_Defs
+/// @brief **Inputstream codec control**\n
+/// Used to manage stream codec data.
+///
+
+//##############################################################################
+/// @defgroup cpp_kodi_addon_inputstream_Defs_StreamEncryption 5. Stream encryption
+/// @ingroup cpp_kodi_addon_inputstream_Defs
+/// @brief **Inputstream encryption control**\n
+/// Used to manage encrypted streams within addon.
+///
+
+//}}}
+//______________________________________________________________________________
+
+class CInstanceInputStream;
+
+//==============================================================================
+/// @defgroup cpp_kodi_addon_inputstream_Defs_InputstreamProperty class InputstreamProperty
+/// @ingroup cpp_kodi_addon_inputstream_Defs_Interface
+/// @brief <b>URL and Data of key/value pairs passed to addon on @ref kodi::addon::CInstanceInputStream::Open "Open".</b>\n
+/// This is used to have the necessary data of the stream to be opened.
+///
+/// ----------------------------------------------------------------------------
+///
+/// @copydetails cpp_kodi_addon_inputstream_Defs_InputstreamProperty_Help
+///
+/// @warning This data are only given from Kodi to addon and can't be used
+/// on other places on addon.
+///
+///@{
+class ATTRIBUTE_HIDDEN InputstreamProperty
+  : public CStructHdl<InputstreamProperty, INPUTSTREAM_PROPERTY>
 {
-#endif /* __cplusplus */
+  /*! \cond PRIVATE */
+  friend class CInstanceInputStream;
+  /*! \endcond */
+
+public:
+  /// @defgroup cpp_kodi_addon_inputstream_Defs_InputstreamProperty_Help Value Help
+  /// @ingroup cpp_kodi_addon_inputstream_Defs_InputstreamProperty
+  ///
+  /// <b>The following table contains values that can be set with @ref cpp_kodi_addon_inputstream_Defs_InputstreamProperty :</b>
+  /// | Name | Type | Get call
+  /// |------|------|----------
+  /// | **Stream URL** | `std::string` | @ref InputstreamProperty::GetURL "GetURL"
+  /// | **Mime type** | `std::string` | @ref InputstreamProperty::GetMimeType "GetMimeType"
+  /// | **Available amount of properties** | `unsigned int` | @ref InputstreamProperty::GetPropertiesAmount "GetPropertiesAmount"
+  /// | **List of properties** | `std::map<std::string, std::string>` | @ref InputstreamProperty::GetProperties "GetProperties"
+  /// | **Get addon library folder** | `std::string` | @ref InputstreamProperty::GetLibFolder "GetLibFolder"
+  /// | **Get addon profile/user folder** | `std::string` | @ref InputstreamProperty::GetProfileFolder "GetProfileFolder"
+
+  /// @addtogroup cpp_kodi_addon_inputstream_Defs_InputstreamProperty
+  ///@{
+
+  /// @brief Stream URL to open.
+  std::string GetURL() const { return m_cStructure->m_strURL; }
+
+  /// @brief Stream mime type.
+  std::string GetMimeType() const { return m_cStructure->m_mimeType; }
 
-  /*!
-   * @brief InputStream add-on capabilities. All capabilities are set to "false" as default.
-   */
-  struct INPUTSTREAM_CAPABILITIES
+  /// @brief Amount of available properties.
+  unsigned int GetPropertiesAmount() const
   {
-    enum MASKTYPE : uint32_t
+    return m_cStructure->m_nCountInfoValues;
+  }
+
+  /// @brief List of available properties-
+  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)
     {
-      /// supports interface IDemux
-      SUPPORTS_IDEMUX = (1 << 0),
+      props.emplace(m_cStructure->m_ListItemProperties[i].m_strKey,
+                    m_cStructure->m_ListItemProperties[i].m_strValue);
+    }
+    return props;
+  }
+
+  /// @brief Get addon library folder.
+  ///
+  /// @note As alternative can also @ref kodi::GetAddonPath used.
+  std::string GetLibFolder() const { return m_cStructure->m_libFolder; }
+
+  /// @brief Get addon profile/user folder.
+  ///
+  /// @note As alternative can also @ref kodi::GetBaseUserPath used.
+  std::string GetProfileFolder() const { return m_cStructure->m_profileFolder; }
+
+  ///@}
 
-      /// supports interface IPosTime
-      SUPPORTS_IPOSTIME = (1 << 1),
+private:
+  InputstreamProperty() = delete;
+  InputstreamProperty(const InputstreamProperty& stream) = delete;
+  InputstreamProperty(const INPUTSTREAM_PROPERTY* stream) : CStructHdl(stream) {}
+  InputstreamProperty(INPUTSTREAM_PROPERTY* stream) : CStructHdl(stream) {}
+};
+///@}
+//------------------------------------------------------------------------------
+
+//==============================================================================
+/// @defgroup cpp_kodi_addon_inputstream_Defs_Interface_InputstreamCapabilities class InputstreamCapabilities
+/// @ingroup cpp_kodi_addon_inputstream_Defs_Interface
+/// @brief **InputStream add-on capabilities. All capabilities are set to "false" as default.**\n
+/// Asked to addon on @ref kodi::addon::CInstanceInputStream::GetCapabilities "GetCapabilities".
+///
+/// ----------------------------------------------------------------------------
+///
+/// @copydetails cpp_kodi_addon_inputstream_Defs_Interface_InputstreamCapabilities_Help
+///
+///@{
+class ATTRIBUTE_HIDDEN InputstreamCapabilities
+  : public CStructHdl<InputstreamCapabilities, INPUTSTREAM_CAPABILITIES>
+{
+  /*! \cond PRIVATE */
+  friend class CInstanceInputStream;
+  /*! \endcond */
+
+public:
+  /*! \cond PRIVATE */
+  InputstreamCapabilities() = default;
+  InputstreamCapabilities(const InputstreamCapabilities& stream) : CStructHdl(stream) {}
+  /*! \endcond */
+
+  /// @defgroup cpp_kodi_addon_inputstream_Defs_Interface_InputstreamCapabilities_Help Value Help
+  /// @ingroup cpp_kodi_addon_inputstream_Defs_Interface_InputstreamCapabilities
+  ///
+  /// <b>The following table contains values that can be set with @ref cpp_kodi_addon_inputstream_Defs_Interface_InputstreamCapabilities :</b>
+  /// | Name | Type | Set call | Get call
+  /// |------|------|----------|----------
+  /// | **Capabilities bit mask** | `uint32_t` | @ref InputstreamCapabilities::SetMask "SetMask" | @ref InputstreamCapabilities::GetMask "GetMask"
+
+  /// @addtogroup cpp_kodi_addon_inputstream_Defs_Interface_InputstreamCapabilities
+  ///@{
 
-      /// supports interface IDisplayTime
-      SUPPORTS_IDISPLAYTIME = (1 << 2),
+  /// @brief Set of supported capabilities.
+  void SetMask(uint32_t mask) const { m_cStructure->m_mask = mask; }
 
-      /// supports seek
-      SUPPORTS_SEEK = (1 << 3),
+  /// @brief Get of supported capabilities.
+  uint32_t GetMask() const { return m_cStructure->m_mask; }
 
-      /// supports pause
-      SUPPORTS_PAUSE = (1 << 4),
+  ///@}
 
-      /// supports interface ITime
-      SUPPORTS_ITIME = (1 << 5),
+private:
+  InputstreamCapabilities(const INPUTSTREAM_CAPABILITIES* stream) : CStructHdl(stream) {}
+  InputstreamCapabilities(INPUTSTREAM_CAPABILITIES* stream) : CStructHdl(stream) {}
+};
+///@}
+//------------------------------------------------------------------------------
+
+//==============================================================================
+/// @defgroup cpp_kodi_addon_inputstream_Defs_Interface_InputstreamMasteringMetadata class InputstreamMasteringMetadata
+/// @ingroup cpp_kodi_addon_inputstream_Defs_Interface
+/// @brief **Mastering metadata.**\n
+/// Describes the metadata for [HDR10](https://en.wikipedia.org/wiki/High-dynamic-range_video).
+///
+/// Used when video is compressed using [High Efficiency Video Coding (HEVC)](https://en.wikipedia.org/wiki/High_Efficiency_Video_Coding).
+/// This is used to describe the capabilities  of the display used to master the
+/// content and the luminance values of the content.
+///
+/// Used on @ref kodi::addon::InputstreamInfo::SetMasteringMetadata and @ref kodi::addon::InputstreamInfo::GetMasteringMetadata.
+///
+/// ----------------------------------------------------------------------------
+///
+/// @copydetails cpp_kodi_addon_inputstream_Defs_Interface_InputstreamMasteringMetadata_Help
+///
+///@{
+class ATTRIBUTE_HIDDEN InputstreamMasteringMetadata
+  : public CStructHdl<InputstreamMasteringMetadata, INPUTSTREAM_MASTERING_METADATA>
+{
+  /*! \cond PRIVATE */
+  friend class CInstanceInputStream;
+  friend class InputstreamInfo;
+  /*! \endcond */
 
-      /// supports interface IChapter
-      SUPPORTS_ICHAPTER = (1 << 6),
-    };
+public:
+  /*! \cond PRIVATE */
+  InputstreamMasteringMetadata() = default;
+  InputstreamMasteringMetadata(const InputstreamMasteringMetadata& stream) : CStructHdl(stream) {}
+  /*! \endcond */
+
+  /// @defgroup cpp_kodi_addon_inputstream_Defs_Interface_InputstreamMasteringMetadata_Help Value Help
+  /// @ingroup cpp_kodi_addon_inputstream_Defs_Interface_InputstreamMasteringMetadata
+  ///
+  /// <b>The following table contains values that can be set with @ref cpp_kodi_addon_inputstream_Defs_Interface_InputstreamMasteringMetadata :</b>
+  /// | Name | Type | Set call | Get call
+  /// |------|------|----------|----------
+  /// | **Chromaticity X coordinates of the red** | `double` | @ref InputstreamMasteringMetadata::SetPrimaryR_ChromaticityX "SetPrimaryR_ChromaticityX" | @ref InputstreamMasteringMetadata::GetPrimaryR_ChromaticityX "GetPrimaryR_ChromaticityX"
+  /// | **Chromaticity Y coordinates of the red** | `double` | @ref InputstreamMasteringMetadata::SetPrimaryR_ChromaticityY "SetPrimaryR_ChromaticityY" | @ref InputstreamMasteringMetadata::GetPrimaryR_ChromaticityY "GetPrimaryR_ChromaticityY"
+  /// | **Chromaticity X coordinates of the green** | `double` | @ref InputstreamMasteringMetadata::SetPrimaryG_ChromaticityX "SetPrimaryG_ChromaticityX" | @ref InputstreamMasteringMetadata::GetPrimaryG_ChromaticityX "GetPrimaryG_ChromaticityX"
+  /// | **Chromaticity Y coordinates of the green** | `double` | @ref InputstreamMasteringMetadata::SetPrimaryG_ChromaticityY "SetPrimaryG_ChromaticityY" | @ref InputstreamMasteringMetadata::GetPrimaryG_ChromaticityY "GetPrimaryG_ChromaticityY"
+  /// | **Chromaticity X coordinates of the blue** | `double` | @ref InputstreamMasteringMetadata::SetPrimaryB_ChromaticityX "SetPrimaryB_ChromaticityX" | @ref InputstreamMasteringMetadata::GetPrimaryB_ChromaticityX "GetPrimaryB_ChromaticityX"
+  /// | **Chromaticity Y coordinates of the blue** | `double` | @ref InputstreamMasteringMetadata::SetPrimaryB_ChromaticityY "SetPrimaryB_ChromaticityY" | @ref InputstreamMasteringMetadata::GetPrimaryB_ChromaticityY "GetPrimaryB_ChromaticityY"
+  /// | **Chromaticity X coordinates of the white point** | `double` | @ref InputstreamMasteringMetadata::SetWhitePoint_ChromaticityX "SetWhitePoint_ChromaticityX" | @ref InputstreamMasteringMetadata::GetWhitePoint_ChromaticityX "GetWhitePoint_ChromaticityX"
+  /// | **Chromaticity Y coordinates of the white point** | `double` | @ref InputstreamMasteringMetadata::SetWhitePoint_ChromaticityY "SetWhitePoint_ChromaticityY" | @ref InputstreamMasteringMetadata::GetWhitePoint_ChromaticityY "GetWhitePoint_ChromaticityY"
+  /// | **Maximum number of bits of the display** | `double` | @ref InputstreamMasteringMetadata::SetLuminanceMax "SetLuminanceMax" | @ref InputstreamMasteringMetadata::GetLuminanceMax "GetLuminanceMax"
+  /// | **Minimum number of bits of the display** | `double` | @ref InputstreamMasteringMetadata::SetLuminanceMin "SetLuminanceMin" | @ref InputstreamMasteringMetadata::GetLuminanceMin "GetLuminanceMin"
 
-    /// set of supported capabilities
-    uint32_t m_mask;
-  };
+  /// @addtogroup cpp_kodi_addon_inputstream_Defs_Interface_InputstreamMasteringMetadata
+  ///@{
 
-  /*!
-   * @brief structure of key/value pairs passed to addon on Open()
-   */
-  struct INPUTSTREAM
+  /// @brief Metadata class compare.
+  ///
+  /// To compare the metadata with another one.
+  ///
+  /// @return true if they equal, false otherwise
+  bool operator==(const kodi::addon::InputstreamMasteringMetadata& right) const
   {
-    const char* m_strURL;
-    const char* m_mimeType;
+    if (memcmp(m_cStructure, right.m_cStructure, sizeof(INPUTSTREAM_MASTERING_METADATA)) == 0)
+      return true;
+    return false;
+  }
 
-    unsigned int m_nCountInfoValues;
-    struct LISTITEMPROPERTY
-    {
-      const char* m_strKey;
-      const char* m_strValue;
-    } m_ListItemProperties[STREAM_MAX_PROPERTY_COUNT];
+  /// @brief Set the chromaticity coordinates of the red value in the
+  /// [CIE1931](https://en.wikipedia.org/wiki/CIE_1931_color_space) color space.
+  ///
+  /// X coordinate. The values are normalized to 50,000.
+  void SetPrimaryR_ChromaticityX(double value) { m_cStructure->primary_r_chromaticity_x = value; }
 
-    const char* m_libFolder;
-    const char* m_profileFolder;
-  };
+  /// @brief Get the chromaticity X coordinates of the red value.
+  double GetPrimaryR_ChromaticityX() { return m_cStructure->primary_r_chromaticity_x; }
 
-  /*!
-   * @brief Array of stream IDs
-   */
-  struct INPUTSTREAM_IDS
+  /// @brief The chromaticity coordinates of the red value in the
+  /// [CIE1931](https://en.wikipedia.org/wiki/CIE_1931_color_space) color space.
+  ///
+  /// Y coordinate. The values are normalized to 50,000.
+  void SetPrimaryR_ChromaticityY(double value) { m_cStructure->primary_r_chromaticity_y = value; }
+
+  /// @brief Get the chromaticity Y coordinates of the red value.
+  double GetPrimaryR_ChromaticityY() { return m_cStructure->primary_r_chromaticity_y; }
+
+  /// @brief Set the chromaticity coordinates of the green value in the
+  /// [CIE1931](https://en.wikipedia.org/wiki/CIE_1931_color_space) color space.
+  ///
+  /// X coordinate. The values are normalized to 50,000.
+  void SetPrimaryG_ChromaticityX(double value) { m_cStructure->primary_g_chromaticity_x = value; }
+
+  /// @brief Get the chromaticity X coordinates of the green value.
+  double GetPrimaryG_ChromaticityX() { return m_cStructure->primary_g_chromaticity_x; }
+
+  /// @brief Set the chromaticity coordinates of the green value in the
+  /// [CIE1931](https://en.wikipedia.org/wiki/CIE_1931_color_space) color space.
+  ///
+  /// Y coordinate. The values are normalized to 50,000.
+  void SetPrimaryG_ChromaticityY(double value) { m_cStructure->primary_g_chromaticity_y = value; }
+
+  /// @brief Get the chromaticity Y coordinates of the green value.
+  double GetPrimaryG_ChromaticityY() { return m_cStructure->primary_g_chromaticity_y; }
+
+  /// @brief The chromaticity coordinates of the blue value in the
+  /// [CIE1931](https://en.wikipedia.org/wiki/CIE_1931_color_space) color space.
+  ///
+  /// X coordinate. The values are normalized to 50,000.
+  void SetPrimaryB_ChromaticityX(double value) { m_cStructure->primary_b_chromaticity_x = value; }
+
+  /// @brief Get the chromaticity X coordinates of the blue value.
+  double GetPrimaryB_ChromaticityX() { return m_cStructure->primary_b_chromaticity_x; }
+
+  /// @brief The chromaticity coordinates of the blue value in the
+  /// [CIE1931](https://en.wikipedia.org/wiki/CIE_1931_color_space) color space.
+  ///
+  /// Y coordinate. The values are normalized to 50,000.
+  void SetPrimaryB_ChromaticityY(double value) { m_cStructure->primary_b_chromaticity_y = value; }
+
+  /// @brief Get the chromaticity Y coordinates of the blue value.
+  double GetPrimaryB_ChromaticityY() { return m_cStructure->primary_b_chromaticity_y; }
+
+  /// @brief Set the chromaticity coordinates of the white point in the
+  /// [CIE1931](https://en.wikipedia.org/wiki/CIE_1931_color_space) color space.
+  ///
+  /// X coordinate. The values are normalized to 50,000.
+  void SetWhitePoint_ChromaticityX(double value)
   {
-    unsigned int m_streamCount;
-    unsigned int m_streamIds[INPUTSTREAM_MAX_STREAM_COUNT];
-  };
+    m_cStructure->white_point_chromaticity_x = value;
+  }
+
+  /// @brief Get the chromaticity X coordinates of the white point
+  double GetWhitePoint_ChromaticityX() { return m_cStructure->white_point_chromaticity_x; }
 
-  /*!
-   * @brief MASTERING Metadata
-   */
-  struct INPUTSTREAM_MASTERING_METADATA
+  /// @brief Set the chromaticity coordinates of the white point in the
+  /// [CIE1931](https://en.wikipedia.org/wiki/CIE_1931_color_space) color space.
+  ///
+  /// Y coordinate. The values are normalized to 50,000.
+  void SetWhitePoint_ChromaticityY(double value)
   {
-    double primary_r_chromaticity_x;
-    double primary_r_chromaticity_y;
-    double primary_g_chromaticity_x;
-    double primary_g_chromaticity_y;
-    double primary_b_chromaticity_x;
-    double primary_b_chromaticity_y;
-    double white_point_chromaticity_x;
-    double white_point_chromaticity_y;
-    double luminance_max;
-    double luminance_min;
-  };
+    m_cStructure->white_point_chromaticity_y = value;
+  }
+
+  /// @brief Get the chromaticity Y coordinates of the white point.
+  double GetWhitePoint_ChromaticityY() { return m_cStructure->white_point_chromaticity_y; }
+
+  /// @brief Set the maximum number of bits of the display used to master the content.
+  ///
+  /// Values are normalized to 10,000.
+  void SetLuminanceMax(double value) { m_cStructure->luminance_max = value; }
+
+  /// @brief Get the maximum number of bits of the display.
+  double GetLuminanceMax() { return m_cStructure->luminance_max; }
 
-  /*!
-  * @brief CONTENTLIGHT Metadata
-  */
-  struct INPUTSTREAM_CONTENTLIGHT_METADATA
+  /// @brief Set the minimum number of bits of the display used to master the content.
+  ///
+  /// Values are normalized to 10,000.
+  void SetLuminanceMin(double value) { m_cStructure->luminance_min = value; }
+
+  /// @brief Get the minimum number of bits of the display.
+  double GetLuminanceMin() { return m_cStructure->luminance_min; }
+
+  ///@}
+
+private:
+  InputstreamMasteringMetadata(const INPUTSTREAM_MASTERING_METADATA* stream) : CStructHdl(stream) {}
+  InputstreamMasteringMetadata(INPUTSTREAM_MASTERING_METADATA* stream) : CStructHdl(stream) {}
+};
+///@}
+//------------------------------------------------------------------------------
+
+//==============================================================================
+/// @defgroup cpp_kodi_addon_inputstream_Defs_Interface_InputstreamContentlightMetadata class InputstreamContentlightMetadata
+/// @ingroup cpp_kodi_addon_inputstream_Defs_Interface
+/// @brief **Contentlight metadata**\n
+/// Describes the metadata for [HDR10](https://en.wikipedia.org/wiki/High-dynamic-range_video).
+/// See also @ref cpp_kodi_addon_inputstream_Defs_Interface_InputstreamMasteringMetadata "InputstreamMasteringMetadata".
+///
+/// Used on @ref kodi::addon::InputstreamInfo::SetContentLightMetadata and @ref kodi::addon::InputstreamInfo::GetContentLightMetadata.
+///
+/// ----------------------------------------------------------------------------
+///
+/// @copydetails cpp_kodi_addon_inputstream_Defs_Interface_InputstreamContentlightMetadata_Help
+///
+///@{
+class ATTRIBUTE_HIDDEN InputstreamContentlightMetadata
+  : public CStructHdl<InputstreamContentlightMetadata, INPUTSTREAM_CONTENTLIGHT_METADATA>
+{
+  /*! \cond PRIVATE */
+  friend class CInstanceInputStream;
+  friend class InputstreamInfo;
+  /*! \endcond */
+
+public:
+  /*! \cond PRIVATE */
+  InputstreamContentlightMetadata() = default;
+  InputstreamContentlightMetadata(const InputstreamContentlightMetadata& stream)
+    : CStructHdl(stream)
   {
-    uint64_t max_cll;
-    uint64_t max_fall;
-  };
+  }
+  /*! \endcond */
+
+  /// @defgroup cpp_kodi_addon_inputstream_Defs_Interface_InputstreamContentlightMetadata_Help Value Help
+  /// @ingroup cpp_kodi_addon_inputstream_Defs_Interface_InputstreamContentlightMetadata
+  ///
+  /// <b>The following table contains values that can be set with @ref cpp_kodi_addon_inputstream_Defs_Interface_InputstreamContentlightMetadata :</b>
+  /// | Name | Type | Set call | Get call
+  /// |------|------|----------|----------
+  /// | **Maximum content light level** | `double` | @ref InputstreamContentlightMetadata::SetMaxCll "SetMaxCll" | @ref InputstreamContentlightMetadata::GetMaxCll "GetMaxCll"
+  /// | **Maximum frame average light level** | `double` | @ref InputstreamContentlightMetadata::SetMaxFall "SetMaxFall" | @ref InputstreamContentlightMetadata::GetMaxFall "GetMaxFall"
+
+  /// @addtogroup cpp_kodi_addon_inputstream_Defs_Interface_InputstreamContentlightMetadata
+  ///@{
 
-  /*!
-   * @brief stream properties
-   */
-  struct INPUTSTREAM_INFO
+  /// @brief Metadata class compare.
+  ///
+  /// To compare the metadata with another one.
+  ///
+  /// @return true if they equal, false otherwise
+  bool operator==(const kodi::addon::InputstreamContentlightMetadata& right) const
   {
-    enum STREAM_TYPE
-    {
-      TYPE_NONE = 0,
-      TYPE_VIDEO,
-      TYPE_AUDIO,
-      TYPE_SUBTITLE,
-      TYPE_TELETEXT,
-      TYPE_RDS,
-    } m_streamType;
+    if (memcmp(m_cStructure, right.m_cStructure, sizeof(INPUTSTREAM_CONTENTLIGHT_METADATA)) == 0)
+      return true;
+    return false;
+  }
 
-    enum Codec_FEATURES : uint32_t
-    {
-      FEATURE_DECODE = 1
-    };
-    uint32_t m_features;
+  /// @brief Set the maximum content light level (MaxCLL).
+  ///
+  /// This is the bit value corresponding to the brightest pixel used anywhere
+  /// in the content.
+  void SetMaxCll(uint64_t value) { m_cStructure->max_cll = value; }
 
-    enum STREAM_FLAGS : uint32_t
-    {
-      FLAG_NONE = 0x0000,
-      FLAG_DEFAULT = 0x0001,
-      FLAG_DUB = 0x0002,
-      FLAG_ORIGINAL = 0x0004,
-      FLAG_COMMENT = 0x0008,
-      FLAG_LYRICS = 0x0010,
-      FLAG_KARAOKE = 0x0020,
-      FLAG_FORCED = 0x0040,
-      FLAG_HEARING_IMPAIRED = 0x0080,
-      FLAG_VISUAL_IMPAIRED = 0x0100,
-    };
+  /// @brief Get the maximum content light level (MaxCLL).
+  uint64_t GetMaxCll() { return m_cStructure->max_cll; }
 
-    // Keep in sync with AVColorSpace
-    enum COLORSPACE
-    {
-      COLORSPACE_RGB = 0,
-      COLORSPACE_BT709 = 1,
-      COLORSPACE_UNSPECIFIED = 2,
-      COLORSPACE_UNKNOWN = COLORSPACE_UNSPECIFIED, // compatibility
-      COLORSPACE_RESERVED = 3,
-      COLORSPACE_FCC = 4,
-      COLORSPACE_BT470BG = 5,
-      COLORSPACE_SMPTE170M = 6,
-      COLORSPACE_SMPTE240M = 7,
-      COLORSPACE_YCGCO = 8,
-      COLORSPACE_YCOCG = COLORSPACE_YCGCO,
-      COLORSPACE_BT2020_NCL = 9,
-      COLORSPACE_BT2020_CL = 10,
-      COLORSPACE_SMPTE2085 = 11,
-      COLORSPACE_CHROMA_DERIVED_NCL = 12,
-      COLORSPACE_CHROMA_DERIVED_CL = 13,
-      COLORSPACE_ICTCP = 14,
-      COLORSPACE_MAX
-    };
+  /// @brief Set the maximum frame average light level (MaxFALL).
+  ///
+  /// This is the bit value corresponding to the average luminance of the frame
+  /// which has the brightest average luminance anywhere in the content.
+  void SetMaxFall(uint64_t value) { m_cStructure->max_fall = value; }
 
-    // Keep in sync with AVColorPrimaries
-    enum COLORPRIMARIES : int32_t
-    {
-      COLORPRIMARY_RESERVED0 = 0,
-      COLORPRIMARY_BT709 = 1,
-      COLORPRIMARY_UNSPECIFIED = 2,
-      COLORPRIMARY_RESERVED = 3,
-      COLORPRIMARY_BT470M = 4,
-      COLORPRIMARY_BT470BG = 5,
-      COLORPRIMARY_SMPTE170M = 6,
-      COLORPRIMARY_SMPTE240M = 7,
-      COLORPRIMARY_FILM = 8,
-      COLORPRIMARY_BT2020 = 9,
-      COLORPRIMARY_SMPTE428 = 10,
-      COLORPRIMARY_SMPTEST428_1 = COLORPRIMARY_SMPTE428,
-      COLORPRIMARY_SMPTE431 = 11,
-      COLORPRIMARY_SMPTE432 = 12,
-      COLORPRIMARY_JEDEC_P22 = 22,
-      COLORPRIMARY_MAX
-    };
+  /// @brief Get the maximum frame average light level (MaxFALL).
+  uint64_t GetMaxFall() { return m_cStructure->max_fall; }
 
-    // Keep in sync with AVColorRange
-    enum COLORRANGE
-    {
-      COLORRANGE_UNKNOWN = 0,
-      COLORRANGE_LIMITED,
-      COLORRANGE_FULLRANGE,
-      COLORRANGE_MAX
-    };
+  ///@}
 
-    // keep in sync with AVColorTransferCharacteristic
-    enum COLORTRC : int32_t
-    {
-      COLORTRC_RESERVED0 = 0,
-      COLORTRC_BT709 = 1,
-      COLORTRC_UNSPECIFIED = 2,
-      COLORTRC_RESERVED = 3,
-      COLORTRC_GAMMA22 = 4,
-      COLORTRC_GAMMA28 = 5,
-      COLORTRC_SMPTE170M = 6,
-      COLORTRC_SMPTE240M = 7,
-      COLORTRC_LINEAR = 8,
-      COLORTRC_LOG = 9,
-      COLORTRC_LOG_SQRT = 10,
-      COLORTRC_IEC61966_2_4 = 11,
-      COLORTRC_BT1361_ECG = 12,
-      COLORTRC_IEC61966_2_1 = 13,
-      COLORTRC_BT2020_10 = 14,
-      COLORTRC_BT2020_12 = 15,
-      COLORTRC_SMPTE2084 = 16,
-      COLORTRC_SMPTEST2084 = COLORTRC_SMPTE2084,
-      COLORTRC_SMPTE428 = 17,
-      COLORTRC_SMPTEST428_1 = COLORTRC_SMPTE428,
-      COLORTRC_ARIB_STD_B67 = 18,
-      COLORTRC_MAX
-    };
+private:
+  InputstreamContentlightMetadata(const INPUTSTREAM_CONTENTLIGHT_METADATA* stream)
+    : CStructHdl(stream)
+  {
+  }
+  InputstreamContentlightMetadata(INPUTSTREAM_CONTENTLIGHT_METADATA* stream) : CStructHdl(stream) {}
+};
+///@}
+//------------------------------------------------------------------------------
 
-    uint32_t m_flags;
+//==============================================================================
+/// @defgroup cpp_kodi_addon_inputstream_Defs_Interface_InputstreamInfo class InputstreamInfo
+/// @ingroup cpp_kodi_addon_inputstream_Defs_Interface
+/// @brief **Inputstream add-on stream info**\n
+/// This is used to give Kodi the associated and necessary data for an open stream.
+///
+/// Used on @ref kodi::addon::CInstanceInputStream::GetStream().
+///
+/// ----------------------------------------------------------------------------
+///
+/// @copydetails cpp_kodi_addon_inputstream_Defs_Interface_InputstreamInfo_Help
+///
+///@{
+class ATTRIBUTE_HIDDEN InputstreamInfo : public CStructHdl<InputstreamInfo, INPUTSTREAM_INFO>
+{
+  /*! \cond PRIVATE */
+  friend class CInstanceInputStream;
+  /*! \endcond */
 
-    //! @brief (optional) name of the stream, \0 for default handling
-    char m_name[INPUTSTREAM_MAX_STRING_NAME_SIZE];
+public:
+  /*! \cond PRIVATE */
+  InputstreamInfo() = default;
+  InputstreamInfo(const InputstreamInfo& stream) : CStructHdl(stream)
+  {
+    SetCryptoSession(stream.GetCryptoSession());
+    CopyExtraData();
+  }
+  /*! \endcond */
 
-    //! @brief (required) name of codec according to ffmpeg
-    char m_codecName[INPUTSTREAM_MAX_STRING_CODEC_SIZE];
+  /// @defgroup cpp_kodi_addon_inputstream_Defs_Interface_InputstreamInfo_Help Value Help
+  /// @ingroup cpp_kodi_addon_inputstream_Defs_Interface_InputstreamInfo
+  ///
+  /// <b>The following table contains values that can be set with @ref cpp_kodi_addon_inputstream_Defs_Interface_InputstreamInfo :</b>
+  /// | Name | Type used | Required | Set call | Get call
+  /// |------|-----------|----------|----------|---------
+  /// | **Stream type** | all | yes | @ref InputstreamInfo::SetStreamType "SetStreamType" | @ref InputstreamInfo::GetStreamType "GetStreamType"
+  /// | **Feature flags** | all | yes | @ref InputstreamInfo::SetFeatures "SetFeatures" | @ref InputstreamInfo::GetFeatures "GetFeatures"
+  /// | **Flags** | all | yes | @ref InputstreamInfo::SetFlags "SetFlags" | @ref InputstreamInfo::GetFlags "GetFlags"
+  /// | **Name** | all | no | @ref InputstreamInfo::SetName "SetName" | @ref InputstreamInfo::GetName "GetName"
+  /// | **Codec name** | all | yes | @ref InputstreamInfo::SetCodecName "SetCodecName" | @ref InputstreamInfo::GetCodecName "GetCodecName"
+  /// | **Codec internal name** | all | no | @ref InputstreamInfo::SetCodecInternalName "SetCodecInternalName" | @ref InputstreamInfo::GetCodecInternalName "GetCodecInternalName"
+  /// | **Codec Profile** | all | no | @ref InputstreamInfo::SetCodecProfile "SetCodecProfile" | @ref InputstreamInfo::GetCodecProfile "GetCodecProfile"
+  /// | **Physical index** | all | yes | @ref InputstreamInfo::SetPhysicalIndex "SetPhysicalIndex" | @ref InputstreamInfo::GetPhysicalIndex "GetPhysicalIndex"
+  /// | **Extra data** | Subtitle / all | Type related required | @ref InputstreamInfo::SetExtraData "SetExtraData" | @ref InputstreamInfo::GetExtraData "GetExtraData"
+  /// | **RFC 5646 language code** | all | no | @ref InputstreamInfo::SetLanguage "SetLanguage" | @ref InputstreamInfo::GetLanguage "GetLanguage"
+  /// | **FPS scale** | Video | Type related required | @ref InputstreamInfo::SetFpsScale "SetFpsScale" | @ref InputstreamInfo::GetFpsScale "GetFpsScale"
+  /// | **FPS rate** | Video | Type related required | @ref InputstreamInfo::SetFpsRate "SetFpsRate" | @ref InputstreamInfo::GetFpsRate "GetFpsRate"
+  /// | **Height** | Video | Type related required | @ref InputstreamInfo::SetHeight "SetHeight" | @ref InputstreamInfo::GetHeight "GetHeight"
+  /// | **Width** | Video | Type related required | @ref InputstreamInfo::SetWidth "SetWidth" | @ref InputstreamInfo::GetWidth "GetWidth"
+  /// | **Aspect** | Video | Type related required | @ref InputstreamInfo::SetAspect "SetAspect" | @ref InputstreamInfo::GetAspect "GetAspect"
+  /// | **Channel quantity** | Audio | Type related required | @ref InputstreamInfo::SetChannels "SetChannels" | @ref InputstreamInfo::GetChannels "GetChannels"
+  /// | **Sample rate** | Audio | Type related required | @ref InputstreamInfo::SetSampleRate "SetSampleRate" | @ref InputstreamInfo::GetSampleRate "GetSampleRate"
+  /// | **Bit rate** | Audio | Type related required | @ref InputstreamInfo::SetBitRate "SetBitRate" | @ref InputstreamInfo::GetBitRate "GetBitRate"
+  /// | **Bits per sample** | Audio | Type related required | @ref InputstreamInfo::SetBitsPerSample "SetBitsPerSample" | @ref InputstreamInfo::GetBitsPerSample "GetBitsPerSample"
+  /// | **Block align** |  | no | @ref InputstreamInfo::SetBlockAlign "SetBlockAlign" | @ref InputstreamInfo::GetBlockAlign "GetBlockAlign"
+  /// | **Crypto session info** |  | no | @ref InputstreamInfo::SetCryptoSession "SetCryptoSession" | @ref InputstreamInfo::GetCryptoSession "GetCryptoSession"
+  /// | **Four CC code** |  | no | @ref InputstreamInfo::SetCodecFourCC "SetCodecFourCC" | @ref InputstreamInfo::GetCodecFourCC "GetCodecFourCC"
+  /// | **Color space** |  | no | @ref InputstreamInfo::SetColorSpace "SetColorSpace" | @ref InputstreamInfo::GetColorSpace "GetColorSpace"
+  /// | **Color range** |  | no | @ref InputstreamInfo::SetColorRange "SetColorRange" | @ref InputstreamInfo::GetColorRange "GetColorRange"
+  /// | **Color primaries** |  | no | @ref InputstreamInfo::SetColorPrimaries "SetColorPrimaries" | @ref InputstreamInfo::GetColorPrimaries "GetColorPrimaries"
+  /// | **Color transfer characteristic** |  | no | @ref InputstreamInfo::SetColorTransferCharacteristic "SetColorTransferCharacteristic" | @ref InputstreamInfo::GetColorTransferCharacteristic "GetColorTransferCharacteristic"
+  /// | **Mastering metadata** |  | no | @ref InputstreamInfo::SetMasteringMetadata "SetMasteringMetadata" | @ref InputstreamInfo::GetMasteringMetadata "GetMasteringMetadata"
+  /// | **Content light metadata** |  | no | @ref InputstreamInfo::SetContentLightMetadata "SetContentLightMetadata" | @ref InputstreamInfo::GetContentLightMetadata "GetContentLightMetadata"
+  ///
 
-    //! @brief (optional) internal name of codec (selectionstream info)
-    char m_codecInternalName[INPUTSTREAM_MAX_STRING_CODEC_SIZE];
+  /// @addtogroup cpp_kodi_addon_inputstream_Defs_Interface_InputstreamInfo
+  ///@{
 
-    //! @brief (optional) the profile of the codec
-    STREAMCODEC_PROFILE m_codecProfile;
+  /// @brief Set the wanted stream type.
+  ///
+  /// @param[in] streamType By @ref INPUTSTREAM_TYPE defined type
+  void SetStreamType(INPUTSTREAM_TYPE streamType) { m_cStructure->m_streamType = streamType; }
 
-    //! @brief (required) physical index
-    unsigned int m_pID;
+  /// @brief To get with @ref SetStreamType changed values.
+  INPUTSTREAM_TYPE GetStreamType() const { return m_cStructure->m_streamType; }
 
-    const uint8_t* m_ExtraData;
-    unsigned int m_ExtraSize;
+  /// @brief Set special supported feature flags of inputstream.
+  ///
+  /// @param[in] features By @ref INPUTSTREAM_CODEC_FEATURES defined type
+  void SetFeatures(uint32_t features) { m_cStructure->m_features = features; }
 
-    //! @brief RFC 5646 language code (empty string if undefined)
-    char m_language[INPUTSTREAM_MAX_STRING_LANGUAGE_SIZE];
+  /// @brief To get with @ref SetFeatures changed values.
+  uint32_t GetFeatures() const { return m_cStructure->m_features; }
 
-    //! Video stream related data
-    //@{
+  /// @brief Set supported flags of inputstream.
+  ///
+  /// @param[in] flags The on @ref INPUTSTREAM_FLAGS defined flags to set
+  void SetFlags(uint32_t flags) { m_cStructure->m_flags = flags; }
 
-    //! @brief Scale of 1000 and a rate of 29970 will result in 29.97 fps
-    unsigned int m_FpsScale;
+  /// @brief To get with @ref SetFeatures changed values.
+  uint32_t GetFlags() const { return m_cStructure->m_flags; }
 
-    unsigned int m_FpsRate;
+  /// @brief (optional) Name of the stream, leave empty for default handling.
+  ///
+  /// @param[in] name Stream name
+  void SetName(const std::string& name)
+  {
+    strncpy(m_cStructure->m_name, name.c_str(), INPUTSTREAM_MAX_STRING_NAME_SIZE);
+  }
 
-    //! @brief height of the stream reported by the demuxer
-    unsigned int m_Height;
+  /// @brief To get with @ref SetName changed values.
+  std::string GetName() const { return m_cStructure->m_name; }
 
-    //! @brief width of the stream reported by the demuxer
-    unsigned int m_Width;
+  /// @brief (required) Name of codec according to ffmpeg.
+  ///
+  /// See https://github.com/FFmpeg/FFmpeg/blob/master/libavcodec/codec_desc.c about
+  /// available names.
+  ///
+  /// @remark On @ref INPUTSTREAM_TYPE_TELETEXT and @ref INPUTSTREAM_TYPE_RDS
+  /// this can be ignored and leaved empty.
+  ///
+  /// @param[in] codeName Codec name
+  void SetCodecName(const std::string& codecName)
+  {
+    strncpy(m_cStructure->m_codecName, codecName.c_str(), INPUTSTREAM_MAX_STRING_CODEC_SIZE);
+  }
 
-    //! @brief display aspect of stream
-    float m_Aspect;
+  /// @brief To get with @ref SetCodecName changed values.
+  std::string GetCodecName() const { return m_cStructure->m_codecName; }
 
-    //@}
+  /// @brief (optional) Internal name of codec (selectionstream info).
+  ///
+  /// @param[in] codecName Internal codec name
+  void SetCodecInternalName(const std::string& codecName)
+  {
+    strncpy(m_cStructure->m_codecInternalName, codecName.c_str(),
+            INPUTSTREAM_MAX_STRING_CODEC_SIZE);
+  }
+
+  /// @brief To get with @ref SetCodecInternalName changed values.
+  std::string GetCodecInternalName() const { return m_cStructure->m_codecInternalName; }
+
+  /// @brief (optional) The profile of the codec.
+  ///
+  /// @param[in] codecProfile Values with @ref STREAMCODEC_PROFILE to use
+  void SetCodecProfile(STREAMCODEC_PROFILE codecProfile)
+  {
+    m_cStructure->m_codecProfile = codecProfile;
+  }
+
+  /// @brief To get with @ref SetCodecProfile changed values.
+  STREAMCODEC_PROFILE GetCodecProfile() const { return m_cStructure->m_codecProfile; }
+
+  /// @brief (required) Physical index.
+  ///
+  /// @param[in] id Index identifier
+  void SetPhysicalIndex(unsigned int id) { m_cStructure->m_pID = id; }
+
+  /// @brief To get with @ref SetPhysicalIndex changed values.
+  unsigned int GetPhysicalIndex() const { return m_cStructure->m_pID; }
+
+  /// @brief Additional data where can needed on streams.
+  ///
+  /// @param[in] extraData List with memory of extra data
+  void SetExtraData(const std::vector<uint8_t>& extraData)
+  {
+    m_extraData = extraData;
+    m_cStructure->m_ExtraData = m_extraData.data();
+    m_cStructure->m_ExtraSize = m_extraData.size();
+  }
+
+  /// @brief Additional data where can needed on streams.
+  ///
+  /// @param[in] extraData Pointer with memory of extra data
+  /// @param[in] extraSize Size to store
+  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 = m_extraData.size();
+  }
+
+  /// @brief To get with @ref SetExtraData changed values.
+  const std::vector<uint8_t>& GetExtraData() { return m_extraData; }
+
+  /// @brief To get size with @ref SetExtraData changed values.
+  size_t GetExtraDataSize() { return m_extraData.size(); }
+
+  /// @brief Compare extra data from outside with class
+  ///
+  /// @param[in] extraData Pointer with memory of extra data for compare
+  /// @param[in] extraSize Size to compare
+  /// @return true if they equal, false otherwise
+  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;
+  }
+
+  /// @brief Clear additional data.
+  void ClearExtraData()
+  {
+    m_extraData.clear();
+    m_cStructure->m_ExtraData = m_extraData.data();
+    m_cStructure->m_ExtraSize = m_extraData.size();
+  }
+
+  /// @brief RFC 5646 language code (empty string if undefined).
+  ///
+  /// @param[in] language The language to set
+  void SetLanguage(const std::string& language)
+  {
+    strncpy(m_cStructure->m_language, language.c_str(), INPUTSTREAM_MAX_STRING_LANGUAGE_SIZE);
+  }
 
-    //! Audio stream related data
-    //@{
+  /// @brief To get with @ref SetLanguage changed values.
+  std::string GetLanguage() const { return m_cStructure->m_language; }
 
-    //! @brief (required) amount of channels
-    unsigned int m_Channels;
+  /// @brief Scale of 1000 and a rate of 29970 will result in 29.97 fps.
+  ///
+  /// @param[in] fpsScale Scale rate
+  void SetFpsScale(unsigned int fpsScale) { m_cStructure->m_FpsScale = fpsScale; }
 
-    //! @brief (required) sample rate
-    unsigned int m_SampleRate;
+  /// @brief To get with @ref SetFpsScale changed values.
+  unsigned int GetFpsScale() const { return m_cStructure->m_FpsScale; }
 
-    //! @brief (required) bit rate
-    unsigned int m_BitRate;
+  /// @brief Rate to use for stream.
+  ///
+  /// @param[in] fpsRate Rate to use
+  void SetFpsRate(unsigned int fpsRate) { m_cStructure->m_FpsRate = fpsRate; }
 
-    //! @brief (required) bits per sample
-    unsigned int m_BitsPerSample;
+  /// @brief To get with @ref SetFpsRate changed values.
+  unsigned int GetFpsRate() const { return m_cStructure->m_FpsRate; }
 
-    unsigned int m_BlockAlign;
+  /// @brief Height of the stream reported by the demuxer.
+  ///
+  /// @param[in] height Height to use
+  void SetHeight(unsigned int height) { m_cStructure->m_Height = height; }
 
-    //@}
+  /// @brief To get with @ref SetHeight changed values.
+  unsigned int GetHeight() const { return m_cStructure->m_Height; }
 
-    CRYPTO_INFO m_cryptoInfo;
+  /// @brief Width of the stream reported by the demuxer.
+  ///
+  /// @param[in] width Width to use
+  void SetWidth(unsigned int width) { m_cStructure->m_Width = width; }
 
-    // new in API version 2.0.8
-    //@{
-    //! @brief Codec If available, the fourcc code codec
-    unsigned int m_codecFourCC;
+  /// @brief To get with @ref SetWidth changed values.
+  unsigned int GetWidth() const { return m_cStructure->m_Width; }
 
-    //! @brief definition of colorspace
-    COLORSPACE m_colorSpace;
+  /// @brief Display aspect of stream.
+  ///
+  /// @param[in] aspect Aspect ratio to use
+  void SetAspect(float aspect) { m_cStructure->m_Aspect = aspect; }
 
-    //! @brief color range if available
-    COLORRANGE m_colorRange;
-    //@}
+  /// @brief To get with @ref SetAspect changed values.
+  float GetAspect() const { return m_cStructure->m_Aspect; }
 
-    //new in API 2.0.9 / INPUTSTREAM_VERSION_LEVEL 1
-    //@{
-    COLORPRIMARIES m_colorPrimaries;
-    COLORTRC m_colorTransferCharacteristic;
-    //@}
+  /// @brief (required) Amount of channels.
+  ///
+  /// @param[in] sampleRate Channels to use
+  void SetChannels(unsigned int channels) { m_cStructure->m_Channels = channels; }
 
-    //! @brief mastering static Metadata
-    INPUTSTREAM_MASTERING_METADATA* m_masteringMetadata;
+  /// @brief To get with @ref SetChannels changed values.
+  unsigned int GetChannels() const { return m_cStructure->m_Channels; }
 
-    //! @brief content light static Metadata
-    INPUTSTREAM_CONTENTLIGHT_METADATA* m_contentLightMetadata;
-  };
+  /// @brief (required) Sample rate.
+  ///
+  /// @param[in] sampleRate Rate to use
+  void SetSampleRate(unsigned int sampleRate) { m_cStructure->m_SampleRate = sampleRate; }
 
-  struct INPUTSTREAM_TIMES
+  /// @brief To get with @ref SetSampleRate changed values.
+  unsigned int GetSampleRate() const { return m_cStructure->m_SampleRate; }
+
+  /// @brief Bit rate.
+  ///
+  /// @param[in] bitRate Rate to use
+  void SetBitRate(unsigned int bitRate) { m_cStructure->m_BitRate = bitRate; }
+
+  /// @brief To get with @ref SetBitRate changed values.
+  unsigned int GetBitRate() const { return m_cStructure->m_BitRate; }
+
+  /// @brief (required) Bits per sample.
+  ///
+  /// @param[in] bitsPerSample Bits per sample to use
+  void SetBitsPerSample(unsigned int bitsPerSample)
   {
-    time_t startTime;
-    double ptsStart;
-    double ptsBegin;
-    double ptsEnd;
-  };
+    m_cStructure->m_BitsPerSample = bitsPerSample;
+  }
 
-  /*!
-   * @brief "C" ABI Structures to transfer the methods from this to Kodi
-   */
+  /// @brief To get with @ref SetBitsPerSample changed values.
+  unsigned int GetBitsPerSample() const { return m_cStructure->m_BitsPerSample; }
 
-  // this are properties given to the addon on create
-  // at this time we have no parameters for the addon
-  typedef struct AddonProps_InputStream /* internal */
+  /// @brief To set the necessary stream block alignment size.
+  ///
+  /// @param[in] blockAlign Block size in byte
+  void SetBlockAlign(unsigned int blockAlign) { m_cStructure->m_BlockAlign = blockAlign; }
+
+  /// @brief To get with @ref SetBlockAlign changed values.
+  unsigned int GetBlockAlign() const { return m_cStructure->m_BlockAlign; }
+
+  /// @brief To set stream crypto session informations.
+  ///
+  /// @param[in] cryptoSession The with @ref cpp_kodi_addon_inputstream_Defs_Interface_StreamCryptoSession setable info
+  ///
+  void SetCryptoSession(const kodi::addon::StreamCryptoSession& cryptoSession)
   {
-    int dummy;
-  } AddonProps_InputStream;
+    m_cryptoSession = cryptoSession;
+    memcpy(&m_cStructure->m_cryptoSession, m_cryptoSession.GetCStructure(),
+           sizeof(STREAM_CRYPTO_SESSION));
+  }
+
+  /// @brief To get with @ref GetCryptoSession changed values.
+  const kodi::addon::StreamCryptoSession& GetCryptoSession() const { return m_cryptoSession; }
 
-  typedef struct AddonToKodiFuncTable_InputStream /* internal */
+  /// @brief Codec If available, the fourcc code codec.
+  ///
+  /// @param[in] codecFourCC Codec four CC code
+  void SetCodecFourCC(unsigned int codecFourCC) { m_cStructure->m_codecFourCC = codecFourCC; }
+
+  /// @brief To get with @ref SetCodecFourCC changed values
+  unsigned int GetCodecFourCC() const { return m_cStructure->m_codecFourCC; }
+
+  /// @brief Definition of colorspace.
+  ///
+  /// @param[in] colorSpace The with @ref INPUTSTREAM_COLORSPACE setable color space
+  void SetColorSpace(INPUTSTREAM_COLORSPACE colorSpace) { m_cStructure->m_colorSpace = colorSpace; }
+
+  /// @brief To get with @ref SetColorSpace changed values.
+  INPUTSTREAM_COLORSPACE GetColorSpace() const { return m_cStructure->m_colorSpace; }
+
+  /// @brief Color range if available.
+  ///
+  /// @param[in] colorRange The with @ref INPUTSTREAM_COLORRANGE setable color space
+  void SetColorRange(INPUTSTREAM_COLORRANGE colorRange) { m_cStructure->m_colorRange = colorRange; }
+
+  /// @brief To get with @ref SetColorRange changed values.
+  INPUTSTREAM_COLORRANGE GetColorRange() const { return m_cStructure->m_colorRange; }
+
+  /// @brief Chromaticity coordinates of the source primaries. These values match the ones defined by ISO/IEC 23001-8_2013 § 7.1.
+  ///
+  /// @param[in] colorPrimaries The with @ref INPUTSTREAM_COLORPRIMARIES setable values
+  void SetColorPrimaries(INPUTSTREAM_COLORPRIMARIES colorPrimaries)
   {
-    KODI_HANDLE kodiInstance;
-    DemuxPacket* (*allocate_demux_packet)(void* kodiInstance, int data_size);
-    DemuxPacket* (*allocate_encrypted_demux_packet)(void* kodiInstance,
-                                                    unsigned int data_size,
-                                                    unsigned int encrypted_subsample_count);
-    void (*free_demux_packet)(void* kodiInstance, DemuxPacket* packet);
-  } AddonToKodiFuncTable_InputStream;
+    m_cStructure->m_colorPrimaries = colorPrimaries;
+  }
+
+  /// @brief To get with @ref SetColorPrimaries changed values.
+  INPUTSTREAM_COLORPRIMARIES GetColorPrimaries() const { return m_cStructure->m_colorPrimaries; }
 
-  struct AddonInstance_InputStream;
-  typedef struct KodiToAddonFuncTable_InputStream /* internal */
+  /// @brief Color Transfer Characteristic. These values match the ones defined by ISO/IEC 23001-8_2013 § 7.2.
+  ///
+  /// @param[in] colorTransferCharacteristic The with @ref INPUTSTREAM_COLORTRC setable characteristic
+  void SetColorTransferCharacteristic(INPUTSTREAM_COLORTRC colorTransferCharacteristic)
   {
-    KODI_HANDLE addonInstance;
+    m_cStructure->m_colorTransferCharacteristic = colorTransferCharacteristic;
+  }
 
-    bool(__cdecl* open)(const AddonInstance_InputStream* instance, INPUTSTREAM* props);
-    void(__cdecl* close)(const AddonInstance_InputStream* instance);
-    const char*(__cdecl* get_path_list)(const AddonInstance_InputStream* instance);
-    void(__cdecl* get_capabilities)(const AddonInstance_InputStream* instance,
-                                    INPUTSTREAM_CAPABILITIES* capabilities);
+  /// @brief To get with @ref SetColorTransferCharacteristic changed values.
+  INPUTSTREAM_COLORTRC GetColorTransferCharacteristic() const
+  {
+    return m_cStructure->m_colorTransferCharacteristic;
+  }
 
-    // IDemux
-    struct INPUTSTREAM_IDS(__cdecl* get_stream_ids)(const AddonInstance_InputStream* instance);
-    struct INPUTSTREAM_INFO(__cdecl* get_stream)(const AddonInstance_InputStream* instance,
-                                                 int streamid);
-    void(__cdecl* enable_stream)(const AddonInstance_InputStream* instance,
-                                 int streamid,
-                                 bool enable);
-    bool(__cdecl* open_stream)(const AddonInstance_InputStream* instance, int streamid);
-    void(__cdecl* demux_reset)(const AddonInstance_InputStream* instance);
-    void(__cdecl* demux_abort)(const AddonInstance_InputStream* instance);
-    void(__cdecl* demux_flush)(const AddonInstance_InputStream* instance);
-    DemuxPacket*(__cdecl* demux_read)(const AddonInstance_InputStream* instance);
-    bool(__cdecl* demux_seek_time)(const AddonInstance_InputStream* instance,
-                                   double time,
-                                   bool backwards,
-                                   double* startpts);
-    void(__cdecl* demux_set_speed)(const AddonInstance_InputStream* instance, int speed);
-    void(__cdecl* set_video_resolution)(const AddonInstance_InputStream* instance,
-                                        int width,
-                                        int height);
+  /// @brief Mastering static Metadata.
+  ///
+  /// Describes the metadata for HDR10, used when video is compressed using High
+  /// Efficiency Video Coding (HEVC). This is used to describe the capabilities
+  /// of the display used to master the content and the luminance values of the
+  /// content.
+  ///
+  /// @param[in] masteringMetadata The with @ref cpp_kodi_addon_inputstream_Defs_Interface_InputstreamMasteringMetadata setable metadata
+  void SetMasteringMetadata(const kodi::addon::InputstreamMasteringMetadata& masteringMetadata)
+  {
+    m_masteringMetadata = masteringMetadata;
+    m_cStructure->m_masteringMetadata = m_masteringMetadata;
+  }
 
-    // IDisplayTime
-    int(__cdecl* get_total_time)(const AddonInstance_InputStream* instance);
-    int(__cdecl* get_time)(const AddonInstance_InputStream* instance);
+  /// @brief To get with @ref SetMasteringMetadata changed values.
+  const kodi::addon::InputstreamMasteringMetadata& GetMasteringMetadata() const
+  {
+    return m_masteringMetadata;
+  }
 
-    // ITime
-    bool(__cdecl* get_times)(const AddonInstance_InputStream* instance, INPUTSTREAM_TIMES* times);
+  /// @brief Clear mastering static Metadata.
+  void ClearMasteringMetadata() { m_cStructure->m_masteringMetadata = nullptr; }
 
-    // IPosTime
-    bool(__cdecl* pos_time)(const AddonInstance_InputStream* instance, int ms);
+  /// @brief Content light static Metadata.
+  ///
+  /// The maximum content light level (MaxCLL) and frame average light level
+  /// (MaxFALL) for the metadata for HDR10.
+  ///
+  /// @param[in] contentLightMetadata The with @ref cpp_kodi_addon_inputstream_Defs_Interface_InputstreamContentlightMetadata setable metadata
+  void SetContentLightMetadata(
+      const kodi::addon::InputstreamContentlightMetadata& contentLightMetadata)
+  {
+    m_contentLightMetadata = contentLightMetadata;
+    m_cStructure->m_contentLightMetadata = m_contentLightMetadata;
+  }
 
-    int(__cdecl* read_stream)(const AddonInstance_InputStream* instance,
-                              uint8_t* buffer,
-                              unsigned int bufferSize);
-    int64_t(__cdecl* seek_stream)(const AddonInstance_InputStream* instance,
-                                  int64_t position,
-                                  int whence);
-    int64_t(__cdecl* position_stream)(const AddonInstance_InputStream* instance);
-    int64_t(__cdecl* length_stream)(const AddonInstance_InputStream* instance);
-    bool(__cdecl* is_real_time_stream)(const AddonInstance_InputStream* instance);
+  /// @brief To get with @ref SetContentLightMetadata changed values.
+  const kodi::addon::InputstreamContentlightMetadata& GetContentLightMetadata() const
+  {
+    return m_contentLightMetadata;
+  }
 
-    // IChapter
-    int(__cdecl* get_chapter)(const AddonInstance_InputStream* instance);
-    int(__cdecl* get_chapter_count)(const AddonInstance_InputStream* instance);
-    const char*(__cdecl* get_chapter_name)(const AddonInstance_InputStream* instance, int ch);
-    int64_t(__cdecl* get_chapter_pos)(const AddonInstance_InputStream* instance, int ch);
-    bool(__cdecl* seek_chapter)(const AddonInstance_InputStream* instance, int ch);
+  /// @brief Clear content light static Metadata.
+  void ClearContentLightMetadata() { m_cStructure->m_contentLightMetadata = nullptr; }
 
-    int(__cdecl* block_size_stream)(const AddonInstance_InputStream* instance);
-  } KodiToAddonFuncTable_InputStream;
+  ///@}
 
-  typedef struct AddonInstance_InputStream /* internal */
+private:
+  InputstreamInfo(const INPUTSTREAM_INFO* stream) : CStructHdl(stream)
   {
-    AddonProps_InputStream* props;
-    AddonToKodiFuncTable_InputStream* toKodi;
-    KodiToAddonFuncTable_InputStream* toAddon;
-  } AddonInstance_InputStream;
+    SetCryptoSession(StreamCryptoSession(&stream->m_cryptoSession));
+    CopyExtraData();
+  }
+  InputstreamInfo(INPUTSTREAM_INFO* stream) : CStructHdl(stream)
+  {
+    SetCryptoSession(StreamCryptoSession(&stream->m_cryptoSession));
+    CopyExtraData();
+  }
 
-#ifdef __cplusplus
-} /* extern "C" */
+  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;
+};
+///@}
+//------------------------------------------------------------------------------
 
-namespace kodi
-{
-namespace addon
+//==============================================================================
+/// @defgroup cpp_kodi_addon_inputstream_Defs_Interface_InputstreamTimes class InputstreamTimes
+/// @ingroup cpp_kodi_addon_inputstream_Defs_Interface
+/// @brief **Inputstream add-on times**\n
+/// Used on @ref kodi::addon::CInstanceInputStream::GetTimes().
+///
+/// ----------------------------------------------------------------------------
+///
+/// @copydetails cpp_kodi_addon_inputstream_Defs_Interface_InputstreamTimes_Help
+///
+///@{
+class ATTRIBUTE_HIDDEN InputstreamTimes : public CStructHdl<InputstreamTimes, INPUTSTREAM_TIMES>
 {
+  /*! \cond PRIVATE */
+  friend class CInstanceInputStream;
+  /*! \endcond */
+
+public:
+  /*! \cond PRIVATE */
+  InputstreamTimes() = default;
+  InputstreamTimes(const InputstreamTimes& stream) : CStructHdl(stream) {}
+  /*! \endcond */
+
+  /// @defgroup cpp_kodi_addon_inputstream_Defs_Interface_InputstreamTimes_Help Value Help
+  /// @ingroup cpp_kodi_addon_inputstream_Defs_Interface_InputstreamTimes
+  ///
+  /// <b>The following table contains values that can be set with @ref cpp_kodi_addon_inputstream_Defs_Interface_InputstreamTimes :</b>
+  /// | Name | Type | Set call | Get call
+  /// |------|------|----------|--------------------
+  /// | **Start time** | `time_t` | @ref InputstreamTimes::SetStartTime "SetStartTime" | @ref InputstreamTimes::GetStartTime "GetStartTime"
+  /// | **PTS start** | `double` | @ref InputstreamTimes::SetPtsStart "SetPtsStart" | @ref InputstreamTimes::GetPtsStart "GetPtsStart"
+  /// | **PTS begin** | `double` | @ref InputstreamTimes::SetPtsBegin "SetPtsBegin" | @ref InputstreamTimes::GetPtsBegin "GetPtsBegin"
+  /// | **PTS end** | `double` | @ref InputstreamTimes::SetPtsEnd "SetPtsEnd" | @ref InputstreamTimes::GetPtsEnd "GetPtsEnd"
+  ///
+
+  /// @addtogroup cpp_kodi_addon_inputstream_Defs_Interface_InputstreamTimes
+  ///@{
+
+  /// @brief Start time in milliseconds
+  void SetStartTime(time_t startTime) const { m_cStructure->startTime = startTime; }
+
+  /// @brief To get with @ref SetStartTime changed values
+  time_t GetStartTime() const { return m_cStructure->startTime; }
+
+  /// @brief Start PTS
+  void SetPtsStart(double ptsStart) const { m_cStructure->ptsStart = ptsStart; }
+
+  /// @brief To get with @ref SetPtsStart changed values
+  double GetPtsStart() const { return m_cStructure->ptsStart; }
 
+  /// @brief Begin PTS
+  void SetPtsBegin(double ptsBegin) const { m_cStructure->ptsBegin = ptsBegin; }
+
+  /// @brief To get with @ref SetPtsBegin changed values
+  double GetPtsBegin() const { return m_cStructure->ptsBegin; }
+
+  /// @brief End PTS
+  void SetPtsEnd(double ptsEnd) const { m_cStructure->ptsEnd = ptsEnd; }
+
+  /// @brief To get with @ref SetPtsEnd changed values
+  double GetPtsEnd() const { return m_cStructure->ptsEnd; }
+
+  ///@}
+
+private:
+  InputstreamTimes(const INPUTSTREAM_TIMES* stream) : CStructHdl(stream) {}
+  InputstreamTimes(INPUTSTREAM_TIMES* stream) : CStructHdl(stream) {}
+};
+///@}
+//------------------------------------------------------------------------------
+
+//============================================================================
+///
+/// @addtogroup cpp_kodi_addon_inputstream
+/// @brief \cpp_class{ kodi::addon::CInstanceInputStream }
+/// **Inputstream add-on instance**
+///
+/// This instance type is for using input streams to video and audio, to process
+/// and then give them to Kodi.
+///
+/// This usage can be requested under various conditions, for example explicitly
+/// by another addon, by a Mimetype protocol defined in `addon.xml` or supported
+/// file extensions.
+///
+/// In addition, stream files (* .strm) can be linked to an inputstream addon
+/// using <b>`#KODIPROP:inputstream=<ADDON_NAME>`</b>.
+///
+/// Include the header @ref Inputstream.h "#include <kodi/addon-instance/Inputstream.h>"
+/// to use this class.
+///
+/// ----------------------------------------------------------------------------
+///
+/// Here is an example of what the <b>`addon.xml.in`</b> would look like for an inputstream addon:
+///
+/// ~~~~~~~~~~~~~{.xml}
+/// <?xml version="1.0" encoding="UTF-8"?>
+/// <addon
+///   id="inputstream.myspecialnamefor"
+///   version="1.0.0"
+///   name="My InputStream addon"
+///   provider-name="Your Name">
+///   <requires>@ADDON_DEPENDS@</requires>
+///   <extension
+///     point="kodi.inputstream"
+///     extension=".xyz|.zyx"
+///     listitemprops="license_type|license_key|license_data|license_flags"
+///     protocols="myspecialnamefor|myspecialnamefors"
+///     library_@PLATFORM@="@LIBRARY_FILENAME@"/>
+///   <extension point="xbmc.addon.metadata">
+///     <summary lang="en_GB">My InputStream addon</summary>
+///     <description lang="en_GB">My InputStream description</description>
+///     <platform>@PLATFORM@</platform>
+///   </extension>
+/// </addon>
+/// ~~~~~~~~~~~~~
+///
+///
+/// At <b>`<extension point="kodi.inputstream" ...>`</b> the basic instance definition is declared, this is intended to identify the addon as an input stream and to see its supported types:
+/// | Name | Description
+/// |------|----------------------
+/// | <b>`point`</b> | The identification of the addon instance to inputstream is mandatory <b>`kodi.inputstream`</b>. In addition, the instance declared in the first <b>`<extension ... />`</b> is also
+/// | <b>`extension`</b> | A filename extension is an identifier specified as a suffix to the name of a computer file where supported by addon.
+/// | <b>`listitemprops`</b> | Values that are available to the addon at @ref InputstreamProperty::GetProperties() and that can be passed to @ref CInstanceInputStream::Open() ith the respective values.
+/// | <b>`protocols`</b> | The streaming protocol is a special protocol supported by the addon for the transmission of streaming media data over a network.
+/// | <b>`library_@PLATFORM@`</b> | The runtime library used for the addon. This is usually declared by cmake and correctly displayed in the translated `addon.xml`.
+///
+///
+/// @remark For more detailed description of the <b>`addon.xml`</b>, see also https://kodi.wiki/view/Addon.xml.
+///
+///
+/// --------------------------------------------------------------------------
+///
+///
+/// **Example:**
+///
+/// ~~~~~~~~~~~~~{.cpp}
+/// #include <kodi/addon-instance/Inputstream.h>
+///
+/// class CMyInputstream : public kodi::addon::CInstanceInputStream
+/// {
+/// public:
+///   CMyInputstream(KODI_HANDLE instance, const std::string& kodiVersion);
+///
+///   void GetCapabilities(kodi::addon::InputstreamCapabilities& capabilities) override;
+///   bool Open(const kodi::addon::InputstreamProperty& props) override;
+///   void Close() override;
+///   ...
+/// };
+///
+/// CMyInputstream::CMyInputstream(KODI_HANDLE instance, const std::string& kodiVersion)
+///   : kodi::addon::CInstanceInputStream(instance, kodiVersion)
+/// {
+///   ...
+/// }
+///
+/// void CMyInputstream::GetCapabilities(kodi::addon::InputstreamCapabilities& capabilities)
+/// {
+///   capabilities.SetMask(INPUTSTREAM_SUPPORTS_IDEMUX | INPUTSTREAM_SUPPORTS_PAUSE);
+/// }
+///
+/// void CMyInputstream::Open(const kodi::addon::InputstreamProperty& props)
+/// {
+///   std::string url = props.GetURL();
+///   ...
+/// }
+///
+/// void CMyInputstream::Close()
+/// {
+///   ...
+/// }
+///
+/// ...
+///
+/// //----------------------------------------------------------------------
+///
+/// class CMyAddon : public kodi::addon::CAddonBase
+/// {
+/// public:
+///   CMyAddon() = default;
+///   ADDON_STATUS CreateInstance(int instanceType,
+///                               std::string instanceID,
+///                               KODI_HANDLE instance,
+///                               const std::string& version,
+///                               KODI_HANDLE& addonInstance) override;
+/// };
+///
+/// // If you use only one instance in your add-on, can be instanceType and
+/// // instanceID ignored
+/// ADDON_STATUS CMyAddon::CreateInstance(int instanceType,
+///                                       std::string instanceID,
+///                                       KODI_HANDLE instance,
+///                                       const std::string& version,
+///                                       KODI_HANDLE& addonInstance)
+/// {
+///   if (instanceType == ADDON_INSTANCE_INPUTSTREAM)
+///   {
+///     kodi::Log(ADDON_LOG_NOTICE, "Creating my Inputstream");
+///     addonInstance = new CMyInputstream(instance, version);
+///     return ADDON_STATUS_OK;
+///   }
+///   else if (...)
+///   {
+///     ...
+///   }
+///   return ADDON_STATUS_UNKNOWN;
+/// }
+///
+/// ADDONCREATOR(CMyAddon)
+/// ~~~~~~~~~~~~~
+///
+/// The destruction of the example class `CMyInputstream` is called from
+/// Kodi's header. Manually deleting the add-on instance is not required.
+///
+//------------------------------------------------------------------------------
 class ATTRIBUTE_HIDDEN CInstanceInputStream : public IAddonInstance
 {
 public:
+  //============================================================================
+  /// @ingroup cpp_kodi_addon_inputstream
+  /// @brief Inputstream class constructor used to support multiple instance
+  /// types
+  ///
+  /// @param[in] instance The instance value given to <b>`kodi::addon::CAddonBase::CreateInstance(...)`</b>
+  /// @param[in] kodiVersion [opt] Version used in Kodi for this instance, to
+  ///                        allow compatibility to older Kodi versions.
+  ///
+  /// @warning Only use `instance` from the @ref CAddonBase::CreateInstance call.
+  ///
   explicit CInstanceInputStream(KODI_HANDLE instance, const std::string& kodiVersion = "")
     : IAddonInstance(ADDON_INSTANCE_INPUTSTREAM,
                      !kodiVersion.empty() ? kodiVersion
@@ -448,242 +1175,590 @@ public:
 
     SetAddonStruct(instance, m_kodiVersion);
   }
+  //----------------------------------------------------------------------------
 
+  //============================================================================
+  /// @ingroup cpp_kodi_addon_inputstream
+  /// @brief Destructor
+  ///
   ~CInstanceInputStream() override = default;
+  //----------------------------------------------------------------------------
 
-  /*!
-     * Open a stream.
-     * @param props
-     * @return True if the stream has been opened successfully, false otherwise.
-     * @remarks
-     */
-  virtual bool Open(INPUTSTREAM& props) = 0;
+  //============================================================================
+  /// @ingroup cpp_kodi_addon_inputstream
+  /// @brief Get the list of features that this add-on provides.
+  ///
+  /// Called by Kodi to query the add-on's capabilities.
+  /// Used to check which options should be presented in the UI, which methods to call, etc.
+  /// All capabilities that the add-on supports should be set to true.
+  ///
+  /// @param[out] capabilities The with @ref cpp_kodi_addon_inputstream_Defs_Capabilities defined add-on's capabilities.
+  ///
+  ///
+  /// --------------------------------------------------------------------------
+  ///
+  /// @copydetails cpp_kodi_addon_inputstream_Defs_Interface_InputstreamCapabilities_Help
+  ///
+  /// --------------------------------------------------------------------------
+  /// @note Valid implementation required.
+  ///
+  ///
+  /// --------------------------------------------------------------------------
+  ///
+  /// **Example:**
+  ///
+  /// ~~~~~~~~~~~~~{.cpp}
+  /// void CMyInputstream::GetCapabilities(kodi::addon::InputstreamCapabilities& capabilities)
+  /// {
+  ///   capabilities.SetMask(INPUTSTREAM_SUPPORTS_IDEMUX | INPUTSTREAM_SUPPORTS_PAUSE);
+  /// }
+  /// ~~~~~~~~~~~~~
+  ///
+  virtual void GetCapabilities(kodi::addon::InputstreamCapabilities& capabilities) = 0;
+  //----------------------------------------------------------------------------
 
-  /*!
-     * Close an open stream.
-     * @remarks
-     */
+  //============================================================================
+  /// @ingroup cpp_kodi_addon_inputstream
+  /// @brief Open a stream.
+  ///
+  /// @param[in] props The used properties about the stream
+  /// @return True if the stream has been opened successfully, false otherwise.
+  ///
+  ///
+  /// --------------------------------------------------------------------------
+  ///
+  /// @copydetails cpp_kodi_addon_inputstream_Defs_InputstreamProperty_Help
+  ///
+  /// --------------------------------------------------------------------------
+  /// @note Valid implementation required.
+  ///
+  ///
+  /// --------------------------------------------------------------------------
+  ///
+  /// **Example:**
+  ///
+  /// ~~~~~~~~~~~~~{.cpp}
+  /// void CMyInputstream::Open(const kodi::addon::InputstreamProperty& props)
+  /// {
+  ///   std::string url = props.GetURL();
+  ///   std::string license_key = props.GetProperties()["inputstream.myspecialnamefor.license_key"];
+  ///   ...
+  /// }
+  /// ~~~~~~~~~~~~~
+  ///
+  virtual bool Open(const kodi::addon::InputstreamProperty& props) = 0;
+  //----------------------------------------------------------------------------
+
+  //============================================================================
+  /// @ingroup cpp_kodi_addon_inputstream
+  /// @brief Close an open stream.
+  ///
+  /// @remarks
+  ///
+  ///
+  /// --------------------------------------------------------------------------
+  /// @note Valid implementation required.
+  ///
   virtual void Close() = 0;
+  //----------------------------------------------------------------------------
 
-  /*!
-     * Get Capabilities of this addon.
-     * @param capabilities The add-on's capabilities.
-     * @remarks
-     */
-  virtual void GetCapabilities(INPUTSTREAM_CAPABILITIES& capabilities) = 0;
+  //============================================================================
+  /// @ingroup cpp_kodi_addon_inputstream
+  /// @brief Check for real-time streaming
+  ///
+  /// @return true if current stream is real-time
+  ///
+  virtual bool IsRealTimeStream() { return true; }
+  //----------------------------------------------------------------------------
 
-  /*!
-     * Get IDs of available streams
-     * @remarks
-     */
-  virtual INPUTSTREAM_IDS GetStreamIds() = 0;
+  //############################################################################
+  /// @defgroup cpp_kodi_addon_inputstream_Read 1. Stream read
+  /// @brief **Functions required to read streams direct and demux inside Kodi.**
+  ///
+  /// This part contains at least the functions necessary for addon that have to
+  /// be supported. This can only be ignored if you use your own demux.
+  ///
+  /// The data loaded by Kodi is then processed in it itself. The source does not
+  /// matter, only Kodi must be able to process this stream data itself and is
+  /// therefore limited in some things.
+  ///
+  /// For more complex things, the addon must integrate its own demuxer and,
+  /// if necessary, even its own codec processing (see @ref cpp_kodi_addon_codec "Codec").
+  ///
+  /// @note These are used and must be set by the addon if the @ref INPUTSTREAM_SUPPORTS_IDEMUX
+  /// is <em><b>undefined</b></em> in the capabilities (see @ref GetCapabilities()).
+  /// Otherwise becomes @ref cpp_kodi_addon_inputstream_Demux "demuxing" used.
+  ///
+  /// @ingroup cpp_kodi_addon_inputstream
+  ///@{
 
-  /*!
-     * Get stream properties of a stream.
-     * @param streamid unique id of stream
-     * @return struc of stream properties
-     * @remarks
-     */
-  virtual INPUTSTREAM_INFO GetStream(int streamid) = 0;
+  //============================================================================
+  /// @brief Read from an open stream.
+  ///
+  /// @param[in] buffer The buffer to store the data in.
+  /// @param[in] bufferSize The amount of bytes to read.
+  /// @return The amount of bytes that were actually read from the stream.
+  ///
+  virtual int ReadStream(uint8_t* buffer, unsigned int bufferSize) { return -1; }
+  //----------------------------------------------------------------------------
 
-  /*!
-     * Enable or disable a stream.
-     * A disabled stream does not send demux packets
-     * @param streamid unique id of stream
-     * @param enable true for enable, false for disable
-     * @remarks
-     */
-  virtual void EnableStream(int streamid, bool enable) = 0;
+  //============================================================================
+  /// @brief Seek in a stream.
+  ///
+  /// @param[in] position The position to seek to
+  /// @param[in] whence offset relative to<br>
+  /// You can set the value of whence to one of three things:
+  /// |     Value    |  int  | Description                                         |
+  /// |:------------:|:-----:|:----------------------------------------------------|
+  /// | **SEEK_SET** |  `0`  | position is relative to the beginning of the file. This is probably what you had in mind anyway, and is the most commonly used value for whence.
+  /// | **SEEK_CUR** |  `1`  | position is relative to the current file pointer position. So, in effect, you can say, "Move to my current position plus 30 bytes," or, "move to my current position minus 20 bytes."
+  /// | **SEEK_END** |  `2`  | position is relative to the end of the file. Just like SEEK_SET except from the other end of the file. Be sure to use negative values for offset if you want to back up from the end of the file, instead of going past the end into oblivion.
+  ///
+  /// @return Returns the resulting offset location as measured in bytes from
+  /// the beginning of the file. On error, the value -1 is returned.
+  ///
+  /// @remarks Optional and can leaved away or return -1 if this add-on won't
+  /// provide this function.
+  ///
+  virtual int64_t SeekStream(int64_t position, int whence = SEEK_SET) { return -1; }
+  //----------------------------------------------------------------------------
 
-  /*!
-    * Opens a stream for playback.
-    * @param streamid unique id of stream
-    * @remarks
-    */
-  virtual bool OpenStream(int streamid) = 0;
+  //============================================================================
+  /// @brief The position in the stream that's currently being read.
+  ///
+  /// @return Stream position
+  ///
+  /// @remarks Optional and can leaved away or return -1 if this add-on won't
+  /// provide this function.
+  ///
+  virtual int64_t PositionStream() { return -1; }
+  //----------------------------------------------------------------------------
+
+  //============================================================================
+  /// @brief The Total length of the stream that's currently being read.
+  ///
+  /// @return Length of the stream
+  ///
+  /// @remarks Optional and can leaved away or return -1 if this add-on won't
+  /// provide this function.
+  ///
+  virtual int64_t LengthStream() { return -1; }
+  //--------------------------------------------------------------------------
+
+  //==========================================================================
+  /// @brief Obtain the chunk size to use when reading streams.
+  ///
+  /// @return Block chunk size
+  ///
+  /// @remarks Optional and can leaved away or return 0 if this add-on won't
+  /// provide this function.
+  ///
+  virtual int GetBlockSize() { return 0; }
+  //--------------------------------------------------------------------------
+
+  ///@}
+
+  //############################################################################
+  /// @defgroup cpp_kodi_addon_inputstream_Demux 2. Stream demuxing (optional)
+  /// @brief **Read demux streams.**
+  ///
+  /// @note These are used and must be set by the addon if the @ref INPUTSTREAM_SUPPORTS_IDEMUX is set in the capabilities (see @ref GetCapabilities()).
+  ///
+  /// @ingroup cpp_kodi_addon_inputstream
+  ///@{
+
+  //============================================================================
+  /// @brief Get IDs of available streams
+  ///
+  /// @param[in] ids list of used identifications
+  /// @return true if successfully done, otherwise false
+  ///
+  /// @remarks This id's are used to identify wanted data on @ref GetStream call.
+  ///
+  ///
+  /// --------------------------------------------------------------------------
+  ///
+  /// **Example:**
+  ///
+  /// ~~~~~~~~~~~~~{.cpp}
+  ///
+  /// bool CMyInputstream::GetStreamIds(std::vector<unsigned int>& ids)
+  /// {
+  ///   kodi::Log(ADDON_LOG_DEBUG, "GetStreamIds(...)");
+  ///
+  ///   if (m_opened)
+  ///   {
+  ///     // This check not needed to have, the ABI checks also about, but make
+  ///     // sure you not give more as 32 streams.
+  ///     if (m_myStreams.size() > MAX_STREAM_COUNT)
+  ///     {
+  ///       kodi::Log(ADDON_LOG_ERROR, "Too many streams, only %u supported", MAX_STREAM_COUNT);
+  ///       return false;
+  ///     }
+  ///
+  ///     ids.emplace_back(m_myAudioStreamId);
+  ///
+  ///     for (const auto& streamPair : m_myOtherStreams)
+  ///     {
+  ///       ids.emplace_back(streamPair.second->uniqueId);
+  ///     }
+  ///   }
+  ///
+  ///   return !ids.empty();
+  /// }
+  /// ~~~~~~~~~~~~~
+  ///
+  virtual bool GetStreamIds(std::vector<unsigned int>& ids) { return false; }
+  //----------------------------------------------------------------------------
+
+  //============================================================================
+  /// @brief Function for giving detailed stream information
+  ///
+  /// The associated information is set here for IDs previously given with
+  /// @ref GetStreamIds.
+  ///
+  /// This data is required to identify the associated codec and, if necessary,
+  /// to refer to your own codec (if available in the addon).
+  ///
+  /// @param[in] streamid unique id of stream
+  /// @param[out] stream Information data of wanted stream
+  /// @return true if successfully done, otherwise false
+  ///
+  /// @remarks Available stream id's previously asked by @ref GetStreamIds
+  ///
+  ///
+  /// --------------------------------------------------------------------------
+  ///
+  /// @copydetails cpp_kodi_addon_inputstream_Defs_Interface_InputstreamInfo_Help
+  ///
+  /// --------------------------------------------------------------------------
+  ///
+  /// **Example:**
+  ///
+  /// ~~~~~~~~~~~~~{.cpp}
+  /// bool CMyInputstream::GetStream(int streamid, kodi::addon::InputstreamInfo& stream)
+  /// {
+  ///   // This is just a small example, this type will be significantly larger
+  ///   // for larger and more complex streams.
+  ///   if (streamid == m_myAudioStreamId)
+  ///   {
+  ///     // This only a minimal exampl
+  ///     stream.SetStreamType(INPUTSTREAM_TYPE_AUDIO);
+  ///     stream.SetFeatures(INPUTSTREAM_FEATURE_NONE); // Only added to example, INPUTSTREAM_FEATURE_NONE is default and no need to call
+  ///     stream.SetFlags(INPUTSTREAM_FLAG_NONE); // Only added to example, INPUTSTREAM_FLAG_NONE is default and no need to call
+  ///     stream.SetCodecName("mp2"); // Codec name, string must by equal with FFmpeg, see https://github.com/FFmpeg/FFmpeg/blob/master/libavcodec/codec_desc.c
+  ///     stream.SetPhysicalIndex(1); // Identifier required to set
+  ///     stream.SetLanguage("en");
+  ///     stream.SetChannels(2);
+  ///     stream.SetSampleRate(48000);
+  ///     stream.SetBitRate(0);
+  ///     stream.SetBitsPerSample(16);
+  ///   }
+  ///   else ...
+  ///   ...
+  ///   return true;
+  /// }
+  /// ~~~~~~~~~~~~~
+  ///
+  virtual bool GetStream(int streamid, kodi::addon::InputstreamInfo& stream) { return false; }
+  //----------------------------------------------------------------------------
+
+  //============================================================================
+  /// @brief Enable or disable a stream.
+  ///
+  /// A disabled stream does not send demux packets
+  ///
+  /// @param[in] streamid unique id of stream
+  /// @param[in] enable true for enable, false for disable
+  ///
+  /// @remarks Available stream id's previously asked by @ref GetStreamIds
+  ///
+  ///
+  /// --------------------------------------------------------------------------
+  /// @note Valid implementation required.
+  ///
+  virtual void EnableStream(int streamid, bool enable) {}
+  //----------------------------------------------------------------------------
 
-  /*!
-     * Reset the demultiplexer in the add-on.
-     * @remarks Required if bHandlesDemuxing is set to true.
-     */
+  //============================================================================
+  /// @brief Opens a stream for playback.
+  ///
+  /// @param[in] streamid unique id of stream
+  ///
+  /// @remarks Available stream id's previously asked by @ref GetStreamIds
+  ///
+  ///
+  /// --------------------------------------------------------------------------
+  /// @note Valid implementation required.
+  ///
+  virtual bool OpenStream(int streamid) { return false; }
+  //----------------------------------------------------------------------------
+
+  //============================================================================
+  /// @brief Reset the demultiplexer in the add-on.
+  ///
+  /// @remarks Optional, and only used if addon has its own demuxer.
+  ///
   virtual void DemuxReset() {}
+  //----------------------------------------------------------------------------
 
-  /*!
-     * Abort the demultiplexer thread in the add-on.
-     * @remarks Required if bHandlesDemuxing is set to true.
-     */
+  //============================================================================
+  /// @brief Abort the demultiplexer thread in the add-on.
+  ///
+  /// @remarks Optional, and only used if addon has its own demuxer.
+  ///
   virtual void DemuxAbort() {}
+  //----------------------------------------------------------------------------
 
-  /*!
-     * Flush all data that's currently in the demultiplexer buffer in the add-on.
-     * @remarks Required if bHandlesDemuxing is set to true.
-     */
+  //============================================================================
+  /// @brief Flush all data that's currently in the demultiplexer buffer in the add-on.
+  ///
+  /// @remarks Optional, and only used if addon has its own demuxer.
+  ///
   virtual void DemuxFlush() {}
+  //----------------------------------------------------------------------------
 
-  /*!
-     * Read the next packet from the demultiplexer, if there is one.
-     * @return The next packet.
-     *         If there is no next packet, then the add-on should return the
-     *         packet created by calling AllocateDemuxPacket(0) on the callback.
-     *         If the stream changed and Kodi's player needs to be reinitialised,
-     *         then, the add-on should call AllocateDemuxPacket(0) on the
-     *         callback, and set the streamid to DMX_SPECIALID_STREAMCHANGE and
-     *         return the value.
-     *         The add-on should return NULL if an error occurred.
-     * @remarks Return NULL if this add-on won't provide this function.
-     */
-  virtual DemuxPacket* DemuxRead() { return nullptr; }
+  //============================================================================
+  /// @brief Read the next packet from the demultiplexer, if there is one.
+  ///
+  /// @return The next packet.
+  ///         If there is no next packet, then the add-on should return the
+  ///         packet created by calling @ref AllocateDemuxPacket "AllocateDemuxPacket(0)" on the callback.
+  ///         If the stream changed and Kodi's player needs to be reinitialised,
+  ///         then, the add-on should call @ref AllocateDemuxPacket "AllocateDemuxPacket(0)" on the
+  ///         callback, and set the streamid to DMX_SPECIALID_STREAMCHANGE and
+  ///         return the value.
+  ///         The add-on should return <b>`nullptr`</b> if an error occured.
+  ///
+  /// @remarks Return <b>`nullptr`</b> if this add-on won't provide this function.
+  ///
+  virtual DEMUX_PACKET* DemuxRead() { return nullptr; }
+  //----------------------------------------------------------------------------
 
-  /*!
-     * Notify the InputStream addon/demuxer that Kodi wishes to seek the stream by time
-     * Demuxer is required to set stream to an IDR frame
-     * @param time The absolute time since stream start
-     * @param backwards True to seek to keyframe BEFORE time, else AFTER
-     * @param startpts can be updated to point to where display should start
-     * @return True if the seek operation was possible
-     * @remarks Optional, and only used if addon has its own demuxer.
-     */
+  //============================================================================
+  /// @brief Notify the InputStream addon/demuxer that Kodi wishes to seek the stream by time
+  ///
+  /// Demuxer is required to set stream to an IDR frame
+  ///
+  /// @param[in] time The absolute time since stream start
+  /// @param[in] backwards True to seek to keyframe BEFORE time, else AFTER
+  /// @param[in] startpts can be updated to point to where display should start
+  /// @return True if the seek operation was possible
+  ///
+  /// @remarks Optional, and only used if addon has its own demuxer.
+  ///
   virtual bool DemuxSeekTime(double time, bool backwards, double& startpts) { return false; }
+  //----------------------------------------------------------------------------
 
-  /*!
-     * Notify the InputStream addon/demuxer that Kodi wishes to change playback speed
-     * @param speed The requested playback speed
-     * @remarks Optional, and only used if addon has its own demuxer.
-     */
+  //============================================================================
+  /// @brief Notify the InputStream addon/demuxer that Kodi wishes to change playback speed
+  ///
+  /// @param[in] speed The requested playback speed
+  ///
+  /// @remarks Optional, and only used if addon has its own demuxer.
+  ///
   virtual void DemuxSetSpeed(int speed) {}
+  //----------------------------------------------------------------------------
 
-  /*!
-     * Sets desired width / height
-     * @param width / hight
-     */
+  //============================================================================
+  /// @brief Sets desired width / height
+  ///
+  /// @param[in] width Width to set
+  /// @param[in] height Height to set
+  ///
   virtual void SetVideoResolution(int width, int height) {}
+  //----------------------------------------------------------------------------
 
-  /*!
-     * Totel time in ms
-     * @remarks
-     */
-  virtual int GetTotalTime() { return -1; }
+  //=============================================================================
+  /// @brief Allocate a demux packet. Free with @ref FreeDemuxPacket
+  ///
+  /// @param[in] dataSize The size of the data that will go into the packet
+  /// @return The allocated packet
+  ///
+  /// @remarks Only called from addon itself
+  ///
+  DEMUX_PACKET* AllocateDemuxPacket(int dataSize)
+  {
+    return m_instanceData->toKodi->allocate_demux_packet(m_instanceData->toKodi->kodiInstance,
+                                                         dataSize);
+  }
+  //----------------------------------------------------------------------------
 
-  /*!
-     * Playing time in ms
-     * @remarks
-     */
-  virtual int GetTime() { return -1; }
+  //============================================================================
+  /// @brief Allocate a encrypted demux packet. Free with @ref FreeDemuxPacket
+  ///
+  /// @param[in] dataSize The size of the data that will go into the packet
+  /// @param[in] encryptedSubsampleCount The encrypted subsample count
+  /// @return The allocated packet
+  ///
+  /// @remarks Only called from addon itself
+  ///
+  DEMUX_PACKET* AllocateEncryptedDemuxPacket(int dataSize, unsigned int encryptedSubsampleCount)
+  {
+    return m_instanceData->toKodi->allocate_encrypted_demux_packet(
+        m_instanceData->toKodi->kodiInstance, dataSize, encryptedSubsampleCount);
+  }
+  //----------------------------------------------------------------------------
 
-  /*!
-    * Get current timing values in PTS scale
-    * @remarks
-    */
-  virtual bool GetTimes(INPUTSTREAM_TIMES& times) { return false; }
+  //============================================================================
+  /// @brief Free a packet that was allocated with AllocateDemuxPacket
+  ///
+  /// @param[in] packet The packet to free
+  ///
+  /// @remarks Only called from addon itself
+  ///
+  void FreeDemuxPacket(DEMUX_PACKET* packet)
+  {
+    return m_instanceData->toKodi->free_demux_packet(m_instanceData->toKodi->kodiInstance, packet);
+  }
+  //----------------------------------------------------------------------------
 
-  /*!
-     * Positions inputstream to playing time given in ms
-     * @remarks
-     */
-  virtual bool PosTime(int ms) { return false; }
+  ///@}
 
-  /*!
-  * Return currently selected chapter
-  * @remarks
-  */
-  virtual int GetChapter() { return -1; };
+  //############################################################################
+  /// @defgroup cpp_kodi_addon_inputstream_Time 3. Time (optional)
+  /// @brief **To get stream position time.**
+  ///
+  /// @note These are used and must be set by the addon if the @ref INPUTSTREAM_SUPPORTS_IDISPLAYTIME is set in the capabilities (see @ref GetCapabilities()).
+  ///
+  /// @ingroup cpp_kodi_addon_inputstream
+  ///@{
 
-  /*!
-  * Return number of available chapters
-  * @remarks
-  */
-  virtual int GetChapterCount() { return 0; };
+  //==========================================================================
+  /// @brief Totel time in ms
+  ///
+  /// @return Total time in milliseconds
+  ///
+  /// @remarks
+  ///
+  virtual int GetTotalTime() { return -1; }
+  //--------------------------------------------------------------------------
 
-  /*!
-  * Return name of chapter # ch
-  * @remarks
-  */
-  virtual const char* GetChapterName(int ch) { return nullptr; };
+  //==========================================================================
+  /// @brief Playing time in ms
+  ///
+  /// @return Playing time in milliseconds
+  ///
+  /// @remarks
+  ///
+  virtual int GetTime() { return -1; }
+  //--------------------------------------------------------------------------
 
-  /*!
-  * Return position if chapter # ch in milliseconds
-  * @remarks
-  */
-  virtual int64_t GetChapterPos(int ch) { return 0; };
+  ///@}
 
-  /*!
-  * Seek to the beginning of chapter # ch
-  * @remarks
-  */
-  virtual bool SeekChapter(int ch) { return false; };
+  //############################################################################
+  /// @defgroup cpp_kodi_addon_inputstream_Times 4. Times (optional)
+  /// @brief **Another way to get stream position time.**
+  ///
+  /// @note These are used and must be set by the addon if the @ref INPUTSTREAM_SUPPORTS_ITIME is set in the capabilities (see @ref GetCapabilities()).
+  ///
+  /// @ingroup cpp_kodi_addon_inputstream
+  ///@{
 
-  /*!
-     * Read from an open stream.
-     * @param buffer The buffer to store the data in.
-     * @param bufferSize The amount of bytes to read.
-     * @return The amount of bytes that were actually read from the stream.
-     * @remarks Return -1 if this add-on won't provide this function.
-     */
-  virtual int ReadStream(uint8_t* buffer, unsigned int bufferSize) { return -1; }
+  //============================================================================
+  /// @brief Get current timing values in PTS scale
+  ///
+  /// @param[out] times The with @ref InputstreamTimes to given times
+  /// @return true if successfully done, false if not
+  ///
+  /// @copydetails cpp_kodi_addon_inputstream_Defs_Times_Help
+  ///
+  /// @remarks
+  ///
+  virtual bool GetTimes(InputstreamTimes& times) { return false; }
+  //----------------------------------------------------------------------------
 
-  /*!
-     * Seek in a stream.
-     * @param position The position to seek to.
-     * @param whence ?
-     * @return The new position.
-     * @remarks Return -1 if this add-on won't provide this function.
-     */
-  virtual int64_t SeekStream(int64_t position, int whence = SEEK_SET) { return -1; }
+  ///@}
 
-  /*!
-     * @return The position in the stream that's currently being read.
-     * @remarks Return -1 if this add-on won't provide this function.
-     */
-  virtual int64_t PositionStream() { return -1; }
+  //############################################################################
+  /// @defgroup cpp_kodi_addon_inputstream_PosTime 5. Position time (optional)
+  /// @brief **Third way get stream position time.**
+  ///
+  /// @note These are used and must be set by the addon if the @ref INPUTSTREAM_SUPPORTS_IPOSTIME is set in the capabilities (see @ref GetCapabilities()).
+  ///
+  /// @ingroup cpp_kodi_addon_inputstream
+  ///@{
 
-  /*!
-     * @return The total length of the stream that's currently being read.
-     * @remarks Return -1 if this add-on won't provide this function.
-     */
-  virtual int64_t LengthStream() { return -1; }
+  //============================================================================
+  /// @brief Positions inputstream to playing time given in ms
+  ///
+  /// @param[in] ms Position time in milliseconds
+  ///
+  /// @remarks
+  ///
+  virtual bool PosTime(int ms) { return false; }
+  //----------------------------------------------------------------------------
 
-  /*!
-     * @return Obtain the chunk size to use when reading streams.
-     * @remarks Return 0 if this add-on won't provide this function.
-     */
-  virtual int GetBlockSize() { return 0; }
+  ///@}
 
-  /*!
-     *  Check for real-time streaming
-     *  @return true if current stream is real-time
-     */
-  virtual bool IsRealTimeStream() { return true; }
+  //############################################################################
+  /// @defgroup cpp_kodi_addon_inputstream_Chapter 6. Chapter (optional)
+  /// @brief **Used to get available chapters.**
+  ///
+  /// @note These are used and must be set by the addon if the @ref INPUTSTREAM_SUPPORTS_ICHAPTER is set in the capabilities (see @ref GetCapabilities()).
+  ///
+  /// @ingroup cpp_kodi_addon_inputstream
+  ///@{
 
-  /*!
-     * @brief Allocate a demux packet. Free with FreeDemuxPacket
-     * @param dataSize The size of the data that will go into the packet
-     * @return The allocated packet
-     */
-  DemuxPacket* AllocateDemuxPacket(int dataSize)
-  {
-    return m_instanceData->toKodi->allocate_demux_packet(m_instanceData->toKodi->kodiInstance,
-                                                         dataSize);
-  }
+  //==========================================================================
+  ///
+  /// @brief Return currently selected chapter
+  ///
+  /// @return Chapter number
+  ///
+  /// @remarks
+  ///
+  virtual int GetChapter() { return -1; };
+  //--------------------------------------------------------------------------
 
-  /*!
-     * @brief Allocate a demux packet. Free with FreeDemuxPacket
-     * @param dataSize The size of the data that will go into the packet
-     * @return The allocated packet
-     */
-  DemuxPacket* AllocateEncryptedDemuxPacket(int dataSize, unsigned int encryptedSubsampleCount)
-  {
-    return m_instanceData->toKodi->allocate_encrypted_demux_packet(
-        m_instanceData->toKodi->kodiInstance, dataSize, encryptedSubsampleCount);
-  }
+  //==========================================================================
+  ///
+  /// @brief Return number of available chapters
+  ///
+  /// @return Chapter count
+  ///
+  /// @remarks
+  ///
+  virtual int GetChapterCount() { return 0; };
+  //--------------------------------------------------------------------------
 
-  /*!
-     * @brief Free a packet that was allocated with AllocateDemuxPacket
-     * @param packet The packet to free
-     */
-  void FreeDemuxPacket(DemuxPacket* packet)
-  {
-    return m_instanceData->toKodi->free_demux_packet(m_instanceData->toKodi->kodiInstance, packet);
-  }
+  //==========================================================================
+  ///
+  /// @brief Return name of chapter
+  ///
+  /// @param[in] ch Chapter identifier
+  /// @return Chapter name
+  ///
+  /// @remarks
+  ///
+  virtual const char* GetChapterName(int ch) { return nullptr; };
+  //--------------------------------------------------------------------------
+
+  //==========================================================================
+  ///
+  /// @brief Return position if chapter # ch in milliseconds
+  ///
+  /// @param[in] ch Chapter to get position from
+  /// @return Position in milliseconds
+  ///
+  /// @remarks
+  ///
+  virtual int64_t GetChapterPos(int ch) { return 0; };
+  //--------------------------------------------------------------------------
+
+  //==========================================================================
+  ///
+  /// @brief Seek to the beginning of chapter # ch
+  ///
+  /// @param[in] ch Chapter to seek
+  /// @return True if successfully done, false if not
+  ///
+  /// @remarks
+  ///
+  virtual bool SeekChapter(int ch) { return false; };
+  //--------------------------------------------------------------------------
+
+  ///@}
 
 private:
   static int compareVersion(const int v1[3], const int v2[3])
@@ -752,9 +1827,10 @@ private:
     */
   }
 
-  inline static bool ADDON_Open(const AddonInstance_InputStream* instance, INPUTSTREAM* props)
+  inline static bool ADDON_Open(const AddonInstance_InputStream* instance,
+                                INPUTSTREAM_PROPERTY* props)
   {
-    return static_cast<CInstanceInputStream*>(instance->toAddon->addonInstance)->Open(*props);
+    return static_cast<CInstanceInputStream*>(instance->toAddon->addonInstance)->Open(props);
   }
 
   inline static void ADDON_Close(const AddonInstance_InputStream* instance)
@@ -765,22 +1841,48 @@ private:
   inline static void ADDON_GetCapabilities(const AddonInstance_InputStream* instance,
                                            INPUTSTREAM_CAPABILITIES* capabilities)
   {
-    static_cast<CInstanceInputStream*>(instance->toAddon->addonInstance)
-        ->GetCapabilities(*capabilities);
+    InputstreamCapabilities caps(capabilities);
+    static_cast<CInstanceInputStream*>(instance->toAddon->addonInstance)->GetCapabilities(caps);
   }
 
 
   // IDemux
-  inline static struct INPUTSTREAM_IDS ADDON_GetStreamIds(const AddonInstance_InputStream* instance)
+  inline static bool ADDON_GetStreamIds(const AddonInstance_InputStream* instance,
+                                        struct INPUTSTREAM_IDS* ids)
   {
-    return static_cast<CInstanceInputStream*>(instance->toAddon->addonInstance)->GetStreamIds();
+    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 struct INPUTSTREAM_INFO ADDON_GetStream(const AddonInstance_InputStream* instance,
-                                                        int streamid)
+  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))
   {
-    return static_cast<CInstanceInputStream*>(instance->toAddon->addonInstance)
-        ->GetStream(streamid);
+    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,
@@ -812,7 +1914,7 @@ private:
     static_cast<CInstanceInputStream*>(instance->toAddon->addonInstance)->DemuxFlush();
   }
 
-  inline static DemuxPacket* ADDON_DemuxRead(const AddonInstance_InputStream* instance)
+  inline static DEMUX_PACKET* ADDON_DemuxRead(const AddonInstance_InputStream* instance)
   {
     return static_cast<CInstanceInputStream*>(instance->toAddon->addonInstance)->DemuxRead();
   }
@@ -855,7 +1957,8 @@ private:
   inline static bool ADDON_GetTimes(const AddonInstance_InputStream* instance,
                                     INPUTSTREAM_TIMES* times)
   {
-    return static_cast<CInstanceInputStream*>(instance->toAddon->addonInstance)->GetTimes(*times);
+    InputstreamTimes cppTimes(times);
+    return static_cast<CInstanceInputStream*>(instance->toAddon->addonInstance)->GetTimes(cppTimes);
   }
 
   // IPosTime
@@ -927,6 +2030,7 @@ private:
 
   AddonInstance_InputStream* m_instanceData;
 };
+//------------------------------------------------------------------------------
 
 } /* namespace addon */
 } /* namespace kodi */
diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/PVR.h b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/PVR.h
index d5977a7..61e294f 100644
--- a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/PVR.h
+++ b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/PVR.h
@@ -36,7 +36,7 @@
  * Only must be min version increased if a new compile of addon breaks after
  * changes here.
  *
- * Have by add of new parts a look about **Doxygen** `\\ingroup`, so that
+ * Have by add of new parts a look about **Doxygen** `\@ingroup`, so that
  * added parts included in documentation.
  *
  * If you add addon side related documentation, where his dev need know, use `///`.
@@ -1477,22 +1477,39 @@ public:
   //----------------------------------------------------------------------------
 
   //============================================================================
-  /// @brief Tell the client the time frame to use when notifying epg events back to Kodi
+  /// @brief Tell the client the past time frame to use when notifying epg events back to Kodi
   ///
   /// The client might push epg events asynchronously to Kodi using the callback function
   /// @ref EpgEventStateChange. To be able to only push events that are actually of
-  /// interest for Kodi, client needs to know about the epg time frame Kodi uses. Kodi
-  /// supplies the current epg time frame value in @ref EpgMaxDays() when creating the
-  /// addon and calls @ref SetEPGTimeFrame later whenever Kodi's epg time frame value
-  /// changes.
+  /// interest for Kodi, client needs to know about the epg time frame Kodi uses. Kodi supplies
+  /// the current epg max past time frame value @ref EpgMaxPastDays() when creating the addon
+  /// and calls @ref SetEPGMaxPastDays later whenever Kodi's epg time frame value changes.
   ///
-  /// @param[in] days number of days from "now". @ref EPG_TIMEFRAME_UNLIMITED means that Kodi
-  ///                 is interested in all epg events, regardless of event times.
+  /// @param[in] pastDays number of days before "now". @ref EPG_TIMEFRAME_UNLIMITED means that Kodi
+  ///                     is interested in all epg events, regardless of event times.
   /// @return @ref PVR_ERROR_NO_ERROR if new value was successfully set.
   ///
   /// @remarks Required if @ref PVRCapabilities::SetSupportsEPG "supportsEPG" is set to true.
   ///
-  virtual PVR_ERROR SetEPGTimeFrame(int days) { return PVR_ERROR_NOT_IMPLEMENTED; }
+  virtual PVR_ERROR SetEPGMaxPastDays(int pastDays) { return PVR_ERROR_NOT_IMPLEMENTED; }
+  //----------------------------------------------------------------------------
+
+  //============================================================================
+  /// @brief Tell the client the future time frame to use when notifying epg events back to Kodi
+  ///
+  /// The client might push epg events asynchronously to Kodi using the callback function
+  /// @ref EpgEventStateChange. To be able to only push events that are actually of
+  /// interest for Kodi, client needs to know about the epg time frame Kodi uses. Kodi supplies
+  /// the current epg max future time frame value @ref EpgMaxFutureDays() when creating the addon
+  /// and calls @ref SetEPGMaxFutureDays later whenever Kodi's epg time frame value changes.
+  ///
+  /// @param[in] futureDays number of days from "now". @ref EPG_TIMEFRAME_UNLIMITED means that Kodi
+  ///                       is interested in all epg events, regardless of event times.
+  /// @return @ref PVR_ERROR_NO_ERROR if new value was successfully set.
+  ///
+  /// @remarks Required if @ref PVRCapabilities::SetSupportsEPG "supportsEPG" is set to true.
+  ///
+  virtual PVR_ERROR SetEPGMaxFutureDays(int futureDays) { return PVR_ERROR_NOT_IMPLEMENTED; }
   //----------------------------------------------------------------------------
 
   //==========================================================================
@@ -1518,15 +1535,28 @@ public:
 
   //==========================================================================
   /// @brief **Callback to Kodi Function**\n
-  /// Get the Max days handled by Kodi.
+  /// Get the Max past days handled by Kodi.
   ///
-  /// If > @ref EPG_TIMEFRAME_UNLIMITED, in async epg mode, deliver only events
-  /// in the range from 'end time > now' to 'start time < now + EpgMaxDays().
+  /// If > @ref EPG_TIMEFRAME_UNLIMITED, in async epg mode, deliver only events in the
+  /// range from 'end time > now - EpgMaxPastDays()' to 'start time < now + EpgMaxFutureDays().
   /// @ref EPG_TIMEFRAME_UNLIMITED, notify all events.
   ///
-  /// @return The Max days handled by Kodi
+  /// @return The Max past days handled by Kodi
   ///
-  inline int EpgMaxDays() const { return m_instanceData->props->iEpgMaxDays; }
+  inline int EpgMaxPastDays() const { return m_instanceData->props->iEpgMaxPastDays; }
+  //----------------------------------------------------------------------------
+
+  //==========================================================================
+  /// @brief **Callback to Kodi Function**\n
+  /// Get the Max future days handled by Kodi.
+  ///
+  /// If > @ref EPG_TIMEFRAME_UNLIMITED, in async epg mode, deliver only events in the
+  /// range from 'end time > now - EpgMaxPastDays()' to 'start time < now + EpgMaxFutureDays().
+  /// @ref EPG_TIMEFRAME_UNLIMITED, notify all events.
+  ///
+  /// @return The Max future days handled by Kodi
+  ///
+  inline int EpgMaxFutureDays() const { return m_instanceData->props->iEpgMaxFutureDays; }
   //----------------------------------------------------------------------------
 
   //==========================================================================
@@ -2324,7 +2354,7 @@ public:
   /// @remarks Required, and only used if addon has its own demuxer.
   /// Return `nullptr` if this add-on won't provide this function.
   ///
-  virtual DemuxPacket* DemuxRead() { return nullptr; }
+  virtual DEMUX_PACKET* DemuxRead() { return nullptr; }
   //----------------------------------------------------------------------------
 
   //============================================================================
@@ -2413,7 +2443,7 @@ public:
   ///
   /// @remarks Only called from addon itself
   ///
-  inline DemuxPacket* AllocateDemuxPacket(int iDataSize)
+  inline DEMUX_PACKET* AllocateDemuxPacket(int iDataSize)
   {
     return m_instanceData->toKodi->AllocateDemuxPacket(m_instanceData->toKodi->kodiInstance,
                                                        iDataSize);
@@ -2428,7 +2458,7 @@ public:
   ///
   /// @remarks Only called from addon itself.
   ///
-  inline void FreeDemuxPacket(DemuxPacket* pPacket)
+  inline void FreeDemuxPacket(DEMUX_PACKET* pPacket)
   {
     m_instanceData->toKodi->FreeDemuxPacket(m_instanceData->toKodi->kodiInstance, pPacket);
   }
@@ -2662,7 +2692,8 @@ private:
     m_instanceData->toAddon->IsEPGTagPlayable = ADDON_IsEPGTagPlayable;
     m_instanceData->toAddon->GetEPGTagEdl = ADDON_GetEPGTagEdl;
     m_instanceData->toAddon->GetEPGTagStreamProperties = ADDON_GetEPGTagStreamProperties;
-    m_instanceData->toAddon->SetEPGTimeFrame = ADDON_SetEPGTimeFrame;
+    m_instanceData->toAddon->SetEPGMaxPastDays = ADDON_SetEPGMaxPastDays;
+    m_instanceData->toAddon->SetEPGMaxFutureDays = ADDON_SetEPGMaxFutureDays;
     m_instanceData->toAddon->CallEPGMenuHook = ADDON_CallEPGMenuHook;
     //--==----==----==----==----==----==----==----==----==----==----==----==----==
     m_instanceData->toAddon->GetRecordingsAmount = ADDON_GetRecordingsAmount;
@@ -2998,10 +3029,17 @@ private:
     return error;
   }
 
-  inline static PVR_ERROR ADDON_SetEPGTimeFrame(const AddonInstance_PVR* instance, int days)
+  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)
-        ->SetEPGTimeFrame(days);
+        ->SetEPGMaxFutureDays(futureDays);
   }
 
   inline static PVR_ERROR ADDON_CallEPGMenuHook(const AddonInstance_PVR* instance,
@@ -3364,7 +3402,7 @@ private:
     static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)->DemuxFlush();
   }
 
-  inline static DemuxPacket* ADDON_DemuxRead(const AddonInstance_PVR* instance)
+  inline static DEMUX_PACKET* ADDON_DemuxRead(const AddonInstance_PVR* instance)
   {
     return static_cast<CInstancePVRClient*>(instance->toAddon->addonInstance)->DemuxRead();
   }
diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/Screensaver.h b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/Screensaver.h
index 4902fcb..d4ac1aa 100644
--- a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/Screensaver.h
+++ b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/Screensaver.h
@@ -41,7 +41,7 @@ namespace addon
 /// * <b><c>Render()</c></b> - Called at render time
 /// * <b><c>Stop()</c></b> - Called when the screensaver has no work
 ///
-/// Additionally, there are several \ref cpp_kodi_addon_screensaver_CB "other functions"
+/// Additionally, there are several @ref cpp_kodi_addon_screensaver_CB "other functions"
 /// available in which the child class can ask about the current hardware,
 /// including the device, display and several other parts.
 ///
diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/VFS.h b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/VFS.h
index 177bf72..dbfb833 100644
--- a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/VFS.h
+++ b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/VFS.h
@@ -152,7 +152,7 @@ private:
 
 //##############################################################################
 /// @defgroup cpp_kodi_addon_vfs_Defs Definitions, structures and enumerators
-/// \ingroup cpp_kodi_addon_vfs
+/// @ingroup cpp_kodi_addon_vfs
 /// @brief **VFS add-on general variables**
 ///
 /// Used to exchange the available options between Kodi and addon.
@@ -161,7 +161,7 @@ private:
 
 //==============================================================================
 ///
-/// \addtogroup cpp_kodi_addon_vfs
+/// @addtogroup cpp_kodi_addon_vfs
 /// @brief \cpp_class{ kodi::addon::CInstanceVFS }
 /// **Virtual Filesystem (VFS) add-on instance**
 ///
diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/VideoCodec.h b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/VideoCodec.h
index 12893db..7cf58a0 100644
--- a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/VideoCodec.h
+++ b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/VideoCodec.h
@@ -9,241 +9,456 @@
 #pragma once
 
 #include "../AddonBase.h"
-#include "../StreamCrypto.h"
-#include "../StreamCodec.h"
+#include "../c-api/addon-instance/video_codec.h"
+#include "inputstream/DemuxPacket.h"
+#include "inputstream/StreamCodec.h"
+#include "inputstream/StreamCrypto.h"
 
-#ifdef BUILD_KODI_ADDON
-#include "../DemuxPacket.h"
-#else
-#include "cores/VideoPlayer/Interface/Addon/DemuxPacket.h"
-#endif
+#ifdef __cplusplus
 
-extern "C"
+namespace kodi
+{
+namespace addon
 {
-  enum VIDEOCODEC_FORMAT
-  {
-    UnknownVideoFormat = 0,
-    VideoFormatYV12,
-    VideoFormatI420,
-    MaxVideoFormats
-  };
-
-
-  struct VIDEOCODEC_INITDATA
-  {
-    enum Codec {
-      CodecUnknown = 0,
-      CodecVp8,
-      CodecH264,
-      CodecVp9
-    } codec;
-
-    STREAMCODEC_PROFILE codecProfile;
-
-    //UnknownVideoFormat is terminator
-    VIDEOCODEC_FORMAT *videoFormats;
-
-    uint32_t width, height;
-
-    const uint8_t *extraData;
-    unsigned int extraDataSize;
-
-    CRYPTO_INFO cryptoInfo;
-  };
-
-  struct VIDEOCODEC_PICTURE
-  {
-    enum VideoPlane {
-      YPlane = 0,
-      UPlane,
-      VPlane,
-      MaxPlanes = 3,
-    };
-
-    enum Flags : uint32_t {
-      FLAG_DROP,
-      FLAG_DRAIN
-    };
-
-    VIDEOCODEC_FORMAT videoFormat;
-    uint32_t flags;
-
-    uint32_t width, height;
 
-    uint8_t *decodedData;
-    size_t decodedDataSize;
+class CInstanceVideoCodec;
 
-    uint32_t planeOffsets[VideoPlane::MaxPlanes];
-    uint32_t stride[VideoPlane::MaxPlanes];
+//==============================================================================
+/// @defgroup cpp_kodi_addon_videocodec_Defs_VideoCodecInitdata class VideoCodecInitdata
+/// @ingroup cpp_kodi_addon_videocodec_Defs
+/// @brief Initialization data to open a video codec stream.
+///
+/// ----------------------------------------------------------------------------
+///
+/// @copydetails cpp_kodi_addon_videocodec_Defs_VideoCodecInitdata_Help
+///
+///@{
+class ATTRIBUTE_HIDDEN VideoCodecInitdata
+  : public CStructHdl<VideoCodecInitdata, VIDEOCODEC_INITDATA>
+{
+  /*! \cond PRIVATE */
+  friend class CInstanceVideoCodec;
+  /*! \endcond */
 
-    int64_t pts;
+public:
+  /// @defgroup cpp_kodi_addon_videocodec_Defs_VideoCodecInitdata_Help Value Help
+  /// @ingroup cpp_kodi_addon_videocodec_Defs_VideoCodecInitdata
+  ///
+  /// <b>The following table contains values that can be set with @ref cpp_kodi_addon_videocodec_Defs_VideoCodecInitdata :</b>
+  /// | Name | Type | Get call
+  /// |------|------|----------
+  /// | **Codec type** | `VIDEOCODEC_TYPE` | @ref VideoCodecInitdata::GetCodecType "GetCodecType"
+  /// | **Codec profile** | `STREAMCODEC_PROFILE` | @ref VideoCodecInitdata::GetCodecProfile "GetCodecProfile"
+  /// | **Video formats** | `std::vector<VIDEOCODEC_FORMAT>` | @ref VideoCodecInitdata::GetVideoFormats "GetVideoFormats"
+  /// | **Width** | `uint32_t` | @ref VideoCodecInitdata::GetWidth "GetWidth"
+  /// | **Height** | `uint32_t` | @ref VideoCodecInitdata::GetHeight "GetHeight"
+  /// | **Extra data** | `const uint8_t*` | @ref VideoCodecInitdata::GetExtraData "GetExtraData"
+  /// | **Extra data size** | `unsigned int` | @ref VideoCodecInitdata::GetExtraDataSize "GetExtraDataSize"
+  /// | **Crypto session** | `kodi::addon::StreamCryptoSession` | @ref VideoCodecInitdata::GetCryptoSession "GetCryptoSession"
+  ///
 
-    KODI_HANDLE videoBufferHandle; //< will be passed in release_frame_buffer
-  };
+  /// @addtogroup cpp_kodi_addon_videocodec_Defs_VideoCodecInitdata
+  ///@{
 
-  enum VIDEOCODEC_RETVAL
-  {
-    VC_NONE = 0,        //< noop
-    VC_ERROR,           //< an error occurred, no other messages will be returned
-    VC_BUFFER,          //< the decoder needs more data
-    VC_PICTURE,         //< the decoder got a picture
-    VC_EOF,             //< the decoder signals EOF
-  };
+  /// @brief The codec type required by Kodi to process the stream.
+  ///
+  /// See @ref VIDEOCODEC_TYPE for possible values.
+  VIDEOCODEC_TYPE GetCodecType() const { return m_cStructure->codec; }
 
-  // this are properties given to the addon on create
-  // at this time we have no parameters for the addon
-  typedef struct AddonProps_VideoCodec
-  {
-    int dummy;
-  } AddonProps_VideoCodec;
+  /// @brief Used profiles for non-scalable 2D video
+  STREAMCODEC_PROFILE GetCodecProfile() const { return m_cStructure->codecProfile; }
 
-  struct AddonInstance_VideoCodec;
-  typedef struct KodiToAddonFuncTable_VideoCodec
+  /// @brief The video stream representations requested by Kodi
+  ///
+  /// This contains a list of the required video formats. One of them has to
+  /// select the addon to return the created image.
+  ///
+  std::vector<VIDEOCODEC_FORMAT> GetVideoFormats() const
   {
-    KODI_HANDLE addonInstance;
+    std::vector<VIDEOCODEC_FORMAT> formats;
+    unsigned int i = 0;
+    while (i < VIDEOCODEC_FORMAT_MAXFORMATS &&
+           m_cStructure->videoFormats[i] != VIDEOCODEC_FORMAT_UNKNOWN)
+      formats.emplace_back(m_cStructure->videoFormats[i++]);
+    if (formats.empty())
+      formats.emplace_back(VIDEOCODEC_FORMAT_UNKNOWN);
+    return formats;
+  }
 
-    //! \brief Opens a codec
-    bool (__cdecl* open) (const AddonInstance_VideoCodec* instance, VIDEOCODEC_INITDATA *initData);
+  /// @brief Picture width.
+  uint32_t GetWidth() const { return m_cStructure->width; }
 
-    //! \brief Reconfigures a codec
-    bool (__cdecl* reconfigure) (const AddonInstance_VideoCodec* instance, VIDEOCODEC_INITDATA *initData);
+  /// @brief Picture height.
+  uint32_t GetHeight() const { return m_cStructure->height; }
 
-    //! \brief Feed codec if requested from GetPicture() (return VC_BUFFER)
-    bool (__cdecl* add_data) (const AddonInstance_VideoCodec* instance, const DemuxPacket *packet);
+  /// @brief Depending on the required decoding, additional data given by the stream.
+  const uint8_t* GetExtraData() const { return m_cStructure->extraData; }
 
-    //! \brief Get a decoded picture / request new data
-    VIDEOCODEC_RETVAL (__cdecl* get_picture) (const AddonInstance_VideoCodec* instance, VIDEOCODEC_PICTURE *picture);
+  /// @brief Size of the data given with @ref extraData.
+  unsigned int GetExtraDataSize() const { return m_cStructure->extraDataSize; }
 
-    //! \brief Get the name of this video decoder
-    const char *(__cdecl* get_name) (const AddonInstance_VideoCodec* instance);
+  /// @brief **Data to manage stream cryptography**\n
+  /// To get class structure manages any encryption values required in order to have
+  /// them available in their stream processing.
+  ///
+  /// ----------------------------------------------------------------------------
+  ///
+  /// @copydetails cpp_kodi_addon_inputstream_Defs_Info_StreamCryptoSession_Help
+  ///
+  kodi::addon::StreamCryptoSession GetCryptoSession() const { return &m_cStructure->cryptoSession; }
 
-    //! \brief Reset the codec
-    void (__cdecl* reset)(const AddonInstance_VideoCodec* instance);
-  } KodiToAddonFuncTable_VideoCodec;
+  ///@}
 
-  typedef struct AddonToKodiFuncTable_VideoCodec
-  {
-    KODI_HANDLE kodiInstance;
-    bool(*get_frame_buffer)(void* kodiInstance, VIDEOCODEC_PICTURE *picture);
-    void(*release_frame_buffer)(void* kodiInstance, void *buffer);
-  } AddonToKodiFuncTable_VideoCodec;
+private:
+  VideoCodecInitdata() = delete;
+  VideoCodecInitdata(const VideoCodecInitdata& session) : CStructHdl(session) {}
+  VideoCodecInitdata(const VIDEOCODEC_INITDATA* session) : CStructHdl(session) {}
+  VideoCodecInitdata(VIDEOCODEC_INITDATA* session) : CStructHdl(session) {}
+};
+///@}
+//------------------------------------------------------------------------------
 
-  typedef struct AddonInstance_VideoCodec
-  {
-    AddonProps_VideoCodec* props;
-    AddonToKodiFuncTable_VideoCodec* toKodi;
-    KodiToAddonFuncTable_VideoCodec* toAddon;
-  } AddonInstance_VideoCodec;
-}
+//##############################################################################
+/// @defgroup cpp_kodi_addon_videocodec_Defs Definitions, structures and enumerators
+/// @ingroup cpp_kodi_addon_videocodec
+/// @brief **Video codec add-on general variables**
+///
+/// Used to exchange the available options between Kodi and addon.
+///
+///
 
-namespace kodi
+//============================================================================
+///
+/// @addtogroup cpp_kodi_addon_videocodec
+/// @brief \cpp_class{ kodi::addon::CInstanceVideoCodec }
+/// **Video codec add-on instance**
+///
+/// This is an addon instance class to add an additional video decoder to Kodi
+/// using addon.
+///
+/// This means that either a new type of decoding can be introduced to an input
+/// stream add-on that requires special types of decoding.
+///
+/// When using the inputstream addon, @ref cpp_kodi_addon_inputstream_Defs_Interface_InputstreamInfo
+/// to @ref cpp_kodi_addon_inputstream_Defs_Info is used to declare that the
+/// decoder stored in the addon is used.
+///
+/// @note At the moment this can only be used together with input stream addons,
+/// independent use as a codec addon is not yet possible.
+///
+/// Include the header @ref VideoCodec.h "#include <kodi/addon-instance/VideoCodec.h>"
+/// to use this class.
+///
+/// --------------------------------------------------------------------------
+///
+/// **Example:**
+/// This as an example when used together with @ref cpp_kodi_addon_inputstream "kodi::addon::CInstanceInputStream".
+///
+/// ~~~~~~~~~~~~~{.cpp}
+/// #include <kodi/addon-instance/Inputstream.h>
+/// #include <kodi/addon-instance/VideoCodec.h>
+///
+/// class CMyVideoCodec : public kodi::addon::CInstanceVideoCodec
+/// {
+/// public:
+///   CMyVideoCodec(KODI_HANDLE instance, CMyInputstream* inputstream);
+///   ...
+///
+/// private:
+///   CMyInputstream* m_inputstream;
+/// };
+///
+/// CMyVideoCodec::CMyVideoCodec(KODI_HANDLE instance,
+///                              const std::string& version,
+///                              CMyInputstream* inputstream)
+///   : kodi::addon::CInstanceVideoCodec(instance, version),
+///     m_inputstream(inputstream)
+/// {
+///   ...
+/// }
+/// ...
+///
+/// //----------------------------------------------------------------------
+///
+/// class CMyInputstream : public kodi::addon::CInstanceInputStream
+/// {
+/// public:
+///   CMyInputstream(KODI_HANDLE instance, const std::string& kodiVersion);
+///
+///   ADDON_STATUS CreateInstance(int instanceType,
+///                               std::string instanceID,
+///                               KODI_HANDLE instance,
+///                               const std::string& version,
+///                               KODI_HANDLE& addonInstance) override;
+///   ...
+/// };
+///
+/// CMyInputstream::CMyInputstream(KODI_HANDLE instance, const std::string& kodiVersion)
+///   : kodi::addon::CInstanceInputStream(instance, kodiVersion)
+/// {
+///   ...
+/// }
+///
+/// ADDON_STATUS CMyInputstream::CreateInstance(int instanceType,
+///                                             std::string instanceID,
+///                                             KODI_HANDLE instance,
+///                                             const std::string& version,
+///                                             KODI_HANDLE& addonInstance)
+/// {
+///   if (instanceType == ADDON_INSTANCE_VIDEOCODEC)
+///   {
+///     addonInstance = new CMyVideoCodec(instance, version, this);
+///     return ADDON_STATUS_OK;
+///   }
+///   return ADDON_STATUS_NOT_IMPLEMENTED;
+/// }
+///
+/// ...
+///
+/// //----------------------------------------------------------------------
+///
+/// class CMyAddon : public kodi::addon::CAddonBase
+/// {
+/// public:
+///   CMyAddon() { }
+///   ADDON_STATUS CreateInstance(int instanceType,
+///                               std::string instanceID,
+///                               KODI_HANDLE instance,
+///                               const std::string& version,
+///                               KODI_HANDLE& addonInstance) override;
+/// };
+///
+/// // If you use only one instance in your add-on, can be instanceType and
+/// // instanceID ignored
+/// ADDON_STATUS CMyAddon::CreateInstance(int instanceType,
+///                                       std::string instanceID,
+///                                       KODI_HANDLE instance,
+///                                       const std::string& version,
+///                                       KODI_HANDLE& addonInstance)
+/// {
+///   if (instanceType == ADDON_INSTANCE_INPUTSTREAM)
+///   {
+///     kodi::Log(ADDON_LOG_NOTICE, "Creating my Inputstream");
+///     addonInstance = new CMyInputstream(instance, version);
+///     return ADDON_STATUS_OK;
+///   }
+///   else if (...)
+///   {
+///     ...
+///   }
+///   return ADDON_STATUS_UNKNOWN;
+/// }
+///
+/// ADDONCREATOR(CMyAddon)
+/// ~~~~~~~~~~~~~
+///
+/// The destruction of the example class `CMyInputstream` is called from
+/// Kodi's header. Manually deleting the add-on instance is not required.
+///
+///
+class ATTRIBUTE_HIDDEN CInstanceVideoCodec : public IAddonInstance
 {
-  namespace addon
+public:
+  //============================================================================
+  /// @ingroup cpp_kodi_addon_videocodec
+  /// @brief Video codec class constructor used to support multiple instance
+  /// types
+  ///
+  /// @param[in] instance The instance value given to <b>`kodi::addon::CAddonBase::CreateInstance(...)`</b>,
+  ///                     or by a inputstream instance if them declared as parent.
+  /// @param[in] kodiVersion [opt] Version used in Kodi for this instance, to
+  ///                        allow compatibility to older Kodi versions.
+  ///
+  explicit CInstanceVideoCodec(KODI_HANDLE instance, const std::string& kodiVersion = "")
+    : IAddonInstance(ADDON_INSTANCE_VIDEOCODEC,
+                     !kodiVersion.empty() ? kodiVersion
+                                          : GetKodiTypeVersion(ADDON_INSTANCE_VIDEOCODEC))
   {
+    if (CAddonBase::m_interface->globalSingleInstance != nullptr)
+      throw std::logic_error("kodi::addon::CInstanceVideoCodec: Creation of multiple together with "
+                             "single instance way is not allowed!");
 
-    class ATTRIBUTE_HIDDEN CInstanceVideoCodec : public IAddonInstance
-    {
-    public:
-      explicit CInstanceVideoCodec(KODI_HANDLE instance, const std::string& kodiVersion = "")
-        : IAddonInstance(ADDON_INSTANCE_VIDEOCODEC,
-                         !kodiVersion.empty() ? kodiVersion
-                                              : GetKodiTypeVersion(ADDON_INSTANCE_VIDEOCODEC))
-      {
-        if (CAddonBase::m_interface->globalSingleInstance != nullptr)
-          throw std::logic_error("kodi::addon::CInstanceVideoCodec: Creation of multiple together with single instance way is not allowed!");
+    SetAddonStruct(instance);
+  }
+  //----------------------------------------------------------------------------
 
-        SetAddonStruct(instance);
-      }
+  //============================================================================
+  /// @ingroup cpp_kodi_addon_videocodec
+  /// @brief Destructor
+  ///
+  ~CInstanceVideoCodec() override = default;
+  //----------------------------------------------------------------------------
 
-      ~CInstanceVideoCodec() override = default;
+  //============================================================================
+  /// @ingroup cpp_kodi_addon_videocodec
+  /// @brief Open the decoder, returns true on success
+  ///
+  /// Decoders not capable of running multiple instances should return false in case
+  /// there is already a instance open.
+  ///
+  /// @param[in] initData Video codec init data
+  /// @return true if successfully done
+  ///
+  ///
+  /// ----------------------------------------------------------------------------
+  ///
+  /// @copydetails cpp_kodi_addon_videocodec_Defs_VideoCodecInitdata_Help
+  ///
+  virtual bool Open(const kodi::addon::VideoCodecInitdata& initData) { return false; }
+  //----------------------------------------------------------------------------
 
-      //! \copydoc CInstanceVideoCodec::Open
-      virtual bool Open(VIDEOCODEC_INITDATA &initData) { return false; };
+  //============================================================================
+  /// @ingroup cpp_kodi_addon_videocodec
+  /// @brief Reconfigure the decoder, returns true on success
+  ///
+  /// Decoders not capable of runnung multiple instances may be capable of reconfiguring
+  /// the running instance. If Reconfigure returns false, player will close / open
+  /// the decoder
+  ///
+  /// @param[in] initData Video codec reconfigure data
+  /// @return true if successfully done
+  ///
+  virtual bool Reconfigure(const kodi::addon::VideoCodecInitdata& initData) { return false; }
+  //----------------------------------------------------------------------------
 
-      //! \copydoc CInstanceVideoCodec::Reconfigure
-      virtual bool Reconfigure(VIDEOCODEC_INITDATA &initData) { return false; };
+  //============================================================================
+  /// @ingroup cpp_kodi_addon_videocodec
+  /// @brief add data, decoder has to consume the entire packet
+  ///
+  /// @param[in] packet Data to process for decode
+  /// @return true if the packet was consumed or if resubmitting it is useless
+  ///
+  virtual bool AddData(const DEMUX_PACKET& packet) { return false; }
+  //----------------------------------------------------------------------------
 
-      //! \copydoc CInstanceVideoCodec::AddData
-      virtual bool AddData(const DemuxPacket &packet) { return false; };
+  //============================================================================
+  /// @ingroup cpp_kodi_addon_videocodec
+  /// @brief GetPicture controls decoding.
+  ///
+  /// Player calls it on every cycle it can signal a picture, request a buffer,
+  /// or return none, if nothing applies the data is valid until the next
+  /// GetPicture return @ref VC_PICTURE
+  ///
+  /// @param[in,out] Structure which contains the necessary data
+  /// @return The with @ref VIDEOCODEC_RETVAL return values
+  ///
+  virtual VIDEOCODEC_RETVAL GetPicture(VIDEOCODEC_PICTURE& picture) { return VC_ERROR; }
+  //----------------------------------------------------------------------------
 
-      //! \copydoc CInstanceVideoCodec::GetPicture
-      virtual VIDEOCODEC_RETVAL GetPicture(VIDEOCODEC_PICTURE &picture) { return VC_ERROR; };
+  //============================================================================
+  /// @ingroup cpp_kodi_addon_videocodec
+  /// @brief should return codecs name
+  ///
+  /// @return Codec name
+  ///
+  virtual const char* GetName() { return nullptr; }
+  //----------------------------------------------------------------------------
 
-      //! \copydoc CInstanceVideoCodec::GetName
-      virtual const char *GetName() { return nullptr; };
+  //============================================================================
+  /// @ingroup cpp_kodi_addon_videocodec
+  /// @brief Reset the decoder
+  ///
+  virtual void Reset() {}
+  //----------------------------------------------------------------------------
 
-      //! \copydoc CInstanceVideoCodec::Reset
-      virtual void Reset() {};
+  /*!
+   * @brief AddonToKodi interface
+   */
 
-      /*!
-      * @brief AddonToKodi interface
-      */
+  //============================================================================
+  /// @ingroup cpp_kodi_addon_videocodec
+  /// @brief All picture members can be expected to be set correctly except
+  /// decodedData and pts.
+  ///
+  /// GetFrameBuffer has to set decodedData to a valid memory address and return true.
+  ///
+  /// @param[out] picture The buffer, or unmodified if false is returned
+  /// @return In case buffer allocation fails, it return false.
+  ///
+  /// @note If this returns true, buffer must be freed using @ref ReleaseFrameBuffer().
+  ///
+  /// @remarks Only called from addon itself
+  ///
+  bool GetFrameBuffer(VIDEOCODEC_PICTURE& picture)
+  {
+    return m_instanceData->toKodi->get_frame_buffer(m_instanceData->toKodi->kodiInstance, &picture);
+  }
+  //----------------------------------------------------------------------------
 
-      //! \copydoc CInstanceVideoCodec::GetFrameBuffer
-      bool GetFrameBuffer(VIDEOCODEC_PICTURE &picture)
-      {
-        return m_instanceData->toKodi->get_frame_buffer(m_instanceData->toKodi->kodiInstance,
-                                                        &picture);
-      }
+  //============================================================================
+  ///
+  /// @ingroup cpp_kodi_addon_videocodec
+  /// @brief Release the with @ref GetFrameBuffer() given framebuffer.
+  ///
+  /// @param[in] handle the on @ref VIDEOCODEC_PICTURE.videoBufferHandle defined buffer handle
+  ///
+  /// @remarks Only called from addon itself
+  ///
+  void ReleaseFrameBuffer(void* buffer)
+  {
+    return m_instanceData->toKodi->release_frame_buffer(m_instanceData->toKodi->kodiInstance,
+                                                        buffer);
+  }
+  //----------------------------------------------------------------------------
 
-      //! \copydoc CInstanceVideoCodec::ReleaseFrameBuffer
-      void ReleaseFrameBuffer(void *buffer)
-      {
-        return m_instanceData->toKodi->release_frame_buffer(m_instanceData->toKodi->kodiInstance,
-                                                            buffer);
-      }
+private:
+  void SetAddonStruct(KODI_HANDLE instance)
+  {
+    if (instance == nullptr)
+      throw std::logic_error("kodi::addon::CInstanceVideoCodec: Creation with empty addon "
+                             "structure not allowed, table must be given from Kodi!");
 
-    private:
-      void SetAddonStruct(KODI_HANDLE instance)
-      {
-        if (instance == nullptr)
-          throw std::logic_error("kodi::addon::CInstanceVideoCodec: Creation with empty addon structure not allowed, table must be given from Kodi!");
+    m_instanceData = static_cast<AddonInstance_VideoCodec*>(instance);
 
-        m_instanceData = static_cast<AddonInstance_VideoCodec*>(instance);
+    m_instanceData->toAddon->addonInstance = this;
+    m_instanceData->toAddon->open = ADDON_Open;
+    m_instanceData->toAddon->reconfigure = ADDON_Reconfigure;
+    m_instanceData->toAddon->add_data = ADDON_AddData;
+    m_instanceData->toAddon->get_picture = ADDON_GetPicture;
+    m_instanceData->toAddon->get_name = ADDON_GetName;
+    m_instanceData->toAddon->reset = ADDON_Reset;
+  }
 
-        m_instanceData->toAddon->addonInstance = this;
-        m_instanceData->toAddon->open = ADDON_Open;
-        m_instanceData->toAddon->reconfigure = ADDON_Reconfigure;
-        m_instanceData->toAddon->add_data = ADDON_AddData;
-        m_instanceData->toAddon->get_picture = ADDON_GetPicture;
-        m_instanceData->toAddon->get_name = ADDON_GetName;
-        m_instanceData->toAddon->reset = ADDON_Reset;
-      }
+  inline static bool ADDON_Open(const AddonInstance_VideoCodec* instance,
+                                VIDEOCODEC_INITDATA* initData)
+  {
+    return static_cast<CInstanceVideoCodec*>(instance->toAddon->addonInstance)->Open(initData);
+  }
 
-      inline static bool ADDON_Open(const AddonInstance_VideoCodec* instance, VIDEOCODEC_INITDATA *initData)
-      {
-        return static_cast<CInstanceVideoCodec*>(instance->toAddon->addonInstance)->Open(*initData);
-      }
+  inline static bool ADDON_Reconfigure(const AddonInstance_VideoCodec* instance,
+                                       VIDEOCODEC_INITDATA* initData)
+  {
+    return static_cast<CInstanceVideoCodec*>(instance->toAddon->addonInstance)
+        ->Reconfigure(initData);
+  }
 
-      inline static bool ADDON_Reconfigure(const AddonInstance_VideoCodec* instance, VIDEOCODEC_INITDATA *initData)
-      {
-        return static_cast<CInstanceVideoCodec*>(instance->toAddon->addonInstance)
-            ->Reconfigure(*initData);
-      }
+  inline static bool ADDON_AddData(const AddonInstance_VideoCodec* instance,
+                                   const DEMUX_PACKET* packet)
+  {
+    return static_cast<CInstanceVideoCodec*>(instance->toAddon->addonInstance)->AddData(*packet);
+  }
 
-      inline static bool ADDON_AddData(const AddonInstance_VideoCodec* instance, const DemuxPacket *packet)
-      {
-        return static_cast<CInstanceVideoCodec*>(instance->toAddon->addonInstance)
-            ->AddData(*packet);
-      }
+  inline static VIDEOCODEC_RETVAL ADDON_GetPicture(const AddonInstance_VideoCodec* instance,
+                                                   VIDEOCODEC_PICTURE* picture)
+  {
+    return static_cast<CInstanceVideoCodec*>(instance->toAddon->addonInstance)
+        ->GetPicture(*picture);
+  }
 
-      inline static VIDEOCODEC_RETVAL ADDON_GetPicture(const AddonInstance_VideoCodec* instance, VIDEOCODEC_PICTURE *picture)
-      {
-        return static_cast<CInstanceVideoCodec*>(instance->toAddon->addonInstance)
-            ->GetPicture(*picture);
-      }
+  inline static const char* ADDON_GetName(const AddonInstance_VideoCodec* instance)
+  {
+    return static_cast<CInstanceVideoCodec*>(instance->toAddon->addonInstance)->GetName();
+  }
 
-      inline static const char *ADDON_GetName(const AddonInstance_VideoCodec* instance)
-      {
-        return static_cast<CInstanceVideoCodec*>(instance->toAddon->addonInstance)->GetName();
-      }
+  inline static void ADDON_Reset(const AddonInstance_VideoCodec* instance)
+  {
+    return static_cast<CInstanceVideoCodec*>(instance->toAddon->addonInstance)->Reset();
+  }
 
-      inline static void ADDON_Reset(const AddonInstance_VideoCodec* instance)
-      {
-        return static_cast<CInstanceVideoCodec*>(instance->toAddon->addonInstance)->Reset();
-      }
+  AddonInstance_VideoCodec* m_instanceData;
+};
 
-      AddonInstance_VideoCodec* m_instanceData;
-    };
-  } // namespace addon
+} // namespace addon
 } // namespace kodi
+
+#endif /* __cplusplus */
diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/Visualization.h b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/Visualization.h
index 7b1db65..1dddea2 100644
--- a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/Visualization.h
+++ b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/Visualization.h
@@ -721,7 +721,7 @@ public:
   inline void TransferPresets(const std::vector<std::string>& presets)
   {
     m_instanceData->toKodi->clear_presets(m_instanceData->toKodi->kodiInstance);
-    for (auto it : presets)
+    for (const auto& it : presets)
       m_instanceData->toKodi->transfer_preset(m_instanceData->toKodi->kodiInstance, it.c_str());
   }
   //----------------------------------------------------------------------------
@@ -915,7 +915,7 @@ private:
     std::vector<std::string> presets;
     if (thisClass->GetPresets(presets))
     {
-      for (auto it : presets)
+      for (const auto& it : presets)
         thisClass->m_instanceData->toKodi->transfer_preset(addon->toKodi->kodiInstance, it.c_str());
     }
 
diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/inputstream/CMakeLists.txt b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/inputstream/CMakeLists.txt
new file mode 100644
index 0000000..a551b4b
--- /dev/null
+++ b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/inputstream/CMakeLists.txt
@@ -0,0 +1,8 @@
+set(HEADERS DemuxPacket.h
+            StreamCodec.h
+            StreamConstants.h
+            TimingConstants.h)
+
+if(NOT ENABLE_STATIC_LIBS)
+  core_add_library(addons_kodi-dev-kit_include_kodi_addon-instance_inputstream)
+endif()
diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/inputstream/DemuxPacket.h b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/inputstream/DemuxPacket.h
new file mode 100644
index 0000000..f965b9f
--- /dev/null
+++ b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/inputstream/DemuxPacket.h
@@ -0,0 +1,12 @@
+/*
+ *  Copyright (C) 2005-2020 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 "TimingConstants.h"
+#include "../../c-api/addon-instance/inputstream/demux_packet.h"
diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/inputstream/StreamCodec.h b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/inputstream/StreamCodec.h
new file mode 100644
index 0000000..e80e2ca
--- /dev/null
+++ b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/inputstream/StreamCodec.h
@@ -0,0 +1,11 @@
+/*
+ *  Copyright (C) 2005-2020 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/inputstream/stream_codec.h"
diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/inputstream/StreamConstants.h b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/inputstream/StreamConstants.h
new file mode 100644
index 0000000..200631b
--- /dev/null
+++ b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/inputstream/StreamConstants.h
@@ -0,0 +1,11 @@
+/*
+ *  Copyright (C) 2005-2020 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/inputstream/stream_constants.h"
diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/inputstream/StreamCrypto.h b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/inputstream/StreamCrypto.h
new file mode 100644
index 0000000..8a85121
--- /dev/null
+++ b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/inputstream/StreamCrypto.h
@@ -0,0 +1,99 @@
+/*
+ *  Copyright (C) 2005-2020 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/inputstream/stream_crypto.h"
+#include "../../AddonBase.h"
+
+#ifdef __cplusplus
+
+namespace kodi
+{
+namespace addon
+{
+
+class CInstanceInputStream;
+class InputstreamInfo;
+class VideoCodecInitdata;
+
+//==============================================================================
+/// @defgroup cpp_kodi_addon_inputstream_Defs_StreamEncryption_StreamCryptoSession class StreamCryptoSession
+/// @ingroup cpp_kodi_addon_inputstream_Defs_StreamEncryption
+/// @brief **Data to manage stream cryptography**\n
+/// This class structure manages any encryption values required in order to have
+/// them available in their stream processing.
+///
+/// Used on inputstream by @ref kodi::addon::InputstreamInfo::SetCryptoSession /
+/// @ref kodi::addon::InputstreamInfo::GetCryptoSession and are given to the
+/// used video codec to decrypt related data.
+///
+/// ----------------------------------------------------------------------------
+///
+/// @copydetails cpp_kodi_addon_inputstream_Defs_Info_StreamCryptoSession_Help
+///
+///@{
+class ATTRIBUTE_HIDDEN StreamCryptoSession
+  : public CStructHdl<StreamCryptoSession, STREAM_CRYPTO_SESSION>
+{
+  /*! \cond PRIVATE */
+  friend class CInstanceInputStream;
+  friend class InputstreamInfo;
+  friend class VideoCodecInitdata;
+  /*! \endcond */
+
+public:
+  /*! \cond PRIVATE */
+  StreamCryptoSession() { memset(m_cStructure, 0, sizeof(STREAM_CRYPTO_SESSION)); }
+  StreamCryptoSession(const StreamCryptoSession& session) : CStructHdl(session) {}
+  /*! \endcond */
+
+  /// @defgroup cpp_kodi_addon_inputstream_Defs_Info_StreamCryptoSession_Help Value Help
+  /// @ingroup cpp_kodi_addon_inputstream_Defs_Info_StreamCryptoSession
+  ///
+  /// <b>The following table contains values that can be set with @ref cpp_kodi_addon_inputstream_Defs_Info_StreamCryptoSession :</b>
+  /// | Name | Type | Set call | Get call
+  /// |------|------|----------|----------
+  /// | **Keysystem for encrypted media** | @ref STREAM_CRYPTO_KEY_SYSTEM | @ref StreamCryptoSession::SetKeySystem "SetKeySystem" | @ref StreamCryptoSession::GetKeySystem "GetKeySystem"
+  /// | **Flags for special conditions** | `uint8_t` | @ref StreamCryptoSession::SetFlags "SetFlags" | @ref StreamCryptoSession::GetFlags "GetFlags"
+  /// | **Crypto session key id** | `std::string` | @ref StreamCryptoSession::SetSessionId "SetSessionId" | @ref StreamCryptoSession::GetSessionId "GetSessionId"
+
+  /// @brief To set keysystem for encrypted media, @ref STREAM_CRYPTO_KEY_SYSTEM_NONE for
+  /// unencrypted media.
+  ///
+  /// See @ref STREAM_CRYPTO_KEY_SYSTEM for available options.
+  void SetKeySystem(STREAM_CRYPTO_KEY_SYSTEM keySystem) { m_cStructure->keySystem = keySystem; }
+
+  /// @brief Get keysystem for encrypted media.
+  STREAM_CRYPTO_KEY_SYSTEM GetKeySystem() const { return m_cStructure->keySystem; }
+
+  /// @brief Set bit flags to use special conditions, see @ref STREAM_CRYPTO_FLAGS
+  /// for available flags.
+  void SetFlags(uint8_t flags) { m_cStructure->flags = flags; }
+
+  /// @brief Get flags for special conditions.
+  uint8_t GetFlags() const { return m_cStructure->flags; }
+
+  /// @brief To set the crypto session key identifier.
+  void SetSessionId(const std::string& sessionId)
+  {
+    strncpy(m_cStructure->sessionId, sessionId.c_str(), sizeof(m_cStructure->sessionId) - 1);
+  }
+
+  /// @brief To get the crypto session key identifier.
+  std::string GetSessionId() const { return m_cStructure->sessionId; }
+
+private:
+  StreamCryptoSession(const STREAM_CRYPTO_SESSION* session) : CStructHdl(session) {}
+  StreamCryptoSession(STREAM_CRYPTO_SESSION* session) : CStructHdl(session) {}
+};
+
+} /* namespace addon */
+} /* namespace kodi */
+
+#endif /* __cplusplus */
diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/inputstream/TimingConstants.h b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/inputstream/TimingConstants.h
new file mode 100644
index 0000000..22f8952
--- /dev/null
+++ b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/inputstream/TimingConstants.h
@@ -0,0 +1,59 @@
+/*
+ *  Copyright (C) 2005-2020 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/inputstream/timing_constants.h"
+
+#ifdef __cplusplus
+
+// Unset the on timing_constants.h given defines
+#undef STREAM_TIME_TO_MSEC
+#undef STREAM_SEC_TO_TIME
+#undef STREAM_MSEC_TO_TIME
+
+/// @ingroup cpp_kodi_addon_inputstream_Defs_TimingConstants
+/// @brief Converts a stream time to milliseconds as an integer value.
+///
+/// @param[in] x Stream time
+/// @return Milliseconds
+///
+/// @note Within "C" code this is used as `#define`.
+///
+constexpr int STREAM_TIME_TO_MSEC(double x)
+{
+  return static_cast<int>(x * 1000 / STREAM_TIME_BASE);
+}
+
+/// @ingroup cpp_kodi_addon_inputstream_Defs_TimingConstants
+/// @brief Converts a time in seconds to the used stream time format.
+///
+/// @param[in] x Seconds
+/// @return Stream time
+///
+/// @note Within "C" code this is used as `#define`.
+///
+constexpr double STREAM_SEC_TO_TIME(double x)
+{
+  return x * STREAM_TIME_BASE;
+}
+
+/// @ingroup cpp_kodi_addon_inputstream_Defs_TimingConstants
+/// @brief Converts a time in milliseconds to the used stream time format.
+///
+/// @param[in] x Milliseconds
+/// @return Stream time
+///
+/// @note Within "C" code this is used as `#define`.
+///
+constexpr double STREAM_MSEC_TO_TIME(double x)
+{
+  return x * STREAM_TIME_BASE / 1000;
+}
+
+#endif /* __cplusplus */
diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/peripheral/PeripheralUtils.h b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/peripheral/PeripheralUtils.h
index febaeb9..1a6cc63 100644
--- a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/peripheral/PeripheralUtils.h
+++ b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/peripheral/PeripheralUtils.h
@@ -806,7 +806,7 @@ struct DriverPrimitive
 {
 protected:
   /*!
-   * \brief Construct a driver primitive of the specified type
+   * @brief Construct a driver primitive of the specified type
    */
   DriverPrimitive(JOYSTICK_DRIVER_PRIMITIVE_TYPE type, unsigned int driverIndex)
     : m_type(type), m_driverIndex(driverIndex)
diff --git a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/pvr/Stream.h b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/pvr/Stream.h
index 5613947..4241c23 100644
--- a/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/pvr/Stream.h
+++ b/xbmc/addons/kodi-dev-kit/include/kodi/addon-instance/pvr/Stream.h
@@ -166,7 +166,7 @@ public:
     m_cStructure->strLanguage[0] = language[0];
     m_cStructure->strLanguage[1] = language[1];
     m_cStructure->strLanguage[2] = language[2];
-    m_cStructure->strLanguage[2] = 0;
+    m_cStructure->strLanguage[3] = 0;
   }
 
   /// @brief To get with @ref SetLanguage() changed values.