sync with upstream

11 files changed, 5838 insertions, 1 deletions

diff --git a/xbmc/addons/kodi-addon-dev-kit/include/kodi/addon-instance/AudioDSP.h b/xbmc/addons/kodi-addon-dev-kit/include/kodi/addon-instance/AudioDSP.h
new file mode 100644
index 0000000..c508f80
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/include/kodi/addon-instance/AudioDSP.h
@@ -0,0 +1,1288 @@
+#pragma once
+
+/*
+ *      Copyright (C) 2005-2015 Team Kodi
+ *      http://kodi.tv
+ *
+ *  This Program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This Program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Kodi; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "../AddonBase.h"
+
+#define AE_DSP_STREAM_MAX_STREAMS               8
+#define AE_DSP_STREAM_MAX_MODES                 32
+
+/*!
+ * @file Addon.h
+ * @section sec1 Basic audio dsp addon interface description
+ * @author Team Kodi
+ * @date 10. May 2014
+ * @version 0.1.5
+ *
+ * @subsection sec1_1 General
+ * @li The basic support on the addon is supplied with the
+ * AE_DSP_ADDON_CAPABILITIES data which becomes asked over
+ * GetCapabilities(...), further the addon must register his available
+ * modes on startup with the RegisterMode(...) callback function.
+ * If one of this two points is not set the addon becomes
+ * ignored for the chain step.
+ *
+ * @subsection sec1_2 Processing
+ * @li On start of new stream the addon becomes called with StreamCreate(...)
+ * to check about given values that it support it basically and can create
+ * his structure, if nothing is supported it can return AE_DSP_ERROR_IGNORE_ME.
+ *
+ * @li As next step StreamIsModeSupported(...) becomes called for every
+ * available and enabled modes, is separated due to more as one available mode
+ * on the addon is possible, if the mode is not supported it can also be return
+ * AE_DSP_ERROR_IGNORE_ME.
+ *   - If mode is a resample mode and returns no error it becomes asked with
+ *     InputResampleSampleRate(...) or OutputResampleSampleRate(...) (relevant
+ *     to his type) about his given sample rate.
+ *   - About the from user selected master processing mode the related addon
+ *     becomes called now with MasterProcessSetMode(...) to handle it's
+ *     selectionon the addon given by the own addon type identifier or by
+ *     KODI's useddatabase id, also the currently used stream type (e.g.
+ *     Music or Video) is send.
+ *     - If the addon supports only one master mode it can ignore this function
+ *       and return always AE_DSP_ERROR_NO_ERROR.
+ *     - If the master mode is set the addon becomes asked about the from him
+ *       given output channel layout related to up- or downmix modes, if
+ *       nothing becomes changed on the layout it can return -1.
+ *     - The MasterProcessSetMode(...) is also called if from user a another
+ *       mode becomes selected.
+ *
+ * @li Then as last step shortly before the first process call becomes executed
+ * the addon is called one time with StreamInitialize(...) to inform that
+ * processing is started on the given settings.
+ *   - This function becomes also called on all add-ons if the master process
+ *     becomes changed.
+ *   - Also every process after StreamInitialize on the addon mode becomes asked
+ *     with _..._ProcessNeededSamplesize(...) about required memory size for the
+ *     output of his data, if no other size is required it can return 0.
+ *
+ * @li From now the processing becomes handled for the different steps with
+ * _..._Process(...).
+ *   - Further it becomes asked with _..._GetDelay(...) about his processing
+ *     time as float value in seconds, needed for video and audio alignment.
+ *
+ * @li On the end of the processing if the source becomes stopped the
+ * StreamDestroy(...) function becomes called on all active processing add-ons.
+ *
+ * @note
+ * The StreamCreate(...) can be becomes called for a new stream before the
+ * previous was closed with StreamDestroy(...) ! To have a speed improve.
+ */
+
+namespace kodi { namespace addon { class CInstanceAudioDSP; }}
+
+extern "C" {
+
+  typedef void* ADSPHANDLE;
+
+  typedef unsigned int AE_DSP_STREAM_ID;
+
+  /*!
+   * @brief Audio DSP add-on error codes
+   */
+  typedef enum
+  {
+    AE_DSP_ERROR_NO_ERROR             = 0,      /*!< @brief no error occurred */
+    AE_DSP_ERROR_UNKNOWN              = -1,     /*!< @brief an unknown error occurred */
+    AE_DSP_ERROR_IGNORE_ME            = -2,     /*!< @brief the used input stream can not processed and add-on want to ignore */
+    AE_DSP_ERROR_NOT_IMPLEMENTED      = -3,     /*!< @brief the method that KODI called is not implemented by the add-on */
+    AE_DSP_ERROR_REJECTED             = -4,     /*!< @brief the command was rejected by the DSP */
+    AE_DSP_ERROR_INVALID_PARAMETERS   = -5,     /*!< @brief the parameters of the method that was called are invalid for this operation */
+    AE_DSP_ERROR_INVALID_SAMPLERATE   = -6,     /*!< @brief the processed samplerate is not supported */
+    AE_DSP_ERROR_INVALID_IN_CHANNELS  = -7,     /*!< @brief the processed input channel format is not supported */
+    AE_DSP_ERROR_INVALID_OUT_CHANNELS = -8,     /*!< @brief the processed output channel format is not supported */
+    AE_DSP_ERROR_FAILED               = -9,     /*!< @brief the command failed */
+  } AE_DSP_ERROR;
+
+  /*!
+   * @brief The possible DSP channels (used as pointer inside arrays)
+   */
+  typedef enum
+  {
+    AE_DSP_CH_INVALID = -1,
+    AE_DSP_CH_FL = 0,
+    AE_DSP_CH_FR,
+    AE_DSP_CH_FC,
+    AE_DSP_CH_LFE,
+    AE_DSP_CH_BL,
+    AE_DSP_CH_BR,
+    AE_DSP_CH_FLOC,
+    AE_DSP_CH_FROC,
+    AE_DSP_CH_BC,
+    AE_DSP_CH_SL,
+    AE_DSP_CH_SR,
+    AE_DSP_CH_TFL,
+    AE_DSP_CH_TFR,
+    AE_DSP_CH_TFC,
+    AE_DSP_CH_TC,
+    AE_DSP_CH_TBL,
+    AE_DSP_CH_TBR,
+    AE_DSP_CH_TBC,
+    AE_DSP_CH_BLOC,
+    AE_DSP_CH_BROC,
+
+    AE_DSP_CH_MAX
+  } AE_DSP_CHANNEL;
+
+  /*!
+   * @brief Present channel flags
+   */
+  typedef enum
+  {
+    AE_DSP_PRSNT_CH_UNDEFINED = 0,
+    AE_DSP_PRSNT_CH_FL        = 1<<AE_DSP_CH_FL,
+    AE_DSP_PRSNT_CH_FR        = 1<<AE_DSP_CH_FR,
+    AE_DSP_PRSNT_CH_FC        = 1<<AE_DSP_CH_FC,
+    AE_DSP_PRSNT_CH_LFE       = 1<<AE_DSP_CH_LFE,
+    AE_DSP_PRSNT_CH_BL        = 1<<AE_DSP_CH_BL,
+    AE_DSP_PRSNT_CH_BR        = 1<<AE_DSP_CH_BR,
+    AE_DSP_PRSNT_CH_FLOC      = 1<<AE_DSP_CH_FLOC,
+    AE_DSP_PRSNT_CH_FROC      = 1<<AE_DSP_CH_FROC,
+    AE_DSP_PRSNT_CH_BC        = 1<<AE_DSP_CH_BC,
+    AE_DSP_PRSNT_CH_SL        = 1<<AE_DSP_CH_SL,
+    AE_DSP_PRSNT_CH_SR        = 1<<AE_DSP_CH_SR,
+    AE_DSP_PRSNT_CH_TFL       = 1<<AE_DSP_CH_TFL,
+    AE_DSP_PRSNT_CH_TFR       = 1<<AE_DSP_CH_TFR,
+    AE_DSP_PRSNT_CH_TFC       = 1<<AE_DSP_CH_TFC,
+    AE_DSP_PRSNT_CH_TC        = 1<<AE_DSP_CH_TC,
+    AE_DSP_PRSNT_CH_TBL       = 1<<AE_DSP_CH_TBL,
+    AE_DSP_PRSNT_CH_TBR       = 1<<AE_DSP_CH_TBR,
+    AE_DSP_PRSNT_CH_TBC       = 1<<AE_DSP_CH_TBC,
+    AE_DSP_PRSNT_CH_BLOC      = 1<<AE_DSP_CH_BLOC,
+    AE_DSP_PRSNT_CH_BROC      = 1<<AE_DSP_CH_BROC
+  } AE_DSP_CHANNEL_PRESENT;
+
+  /**
+   * @brief The various stream type formats
+   * Used for audio DSP processing to know input audio type
+   */
+  typedef enum
+  {
+    AE_DSP_ASTREAM_INVALID = -1,
+    AE_DSP_ASTREAM_BASIC = 0,
+    AE_DSP_ASTREAM_MUSIC,
+    AE_DSP_ASTREAM_MOVIE,
+    AE_DSP_ASTREAM_GAME,
+    AE_DSP_ASTREAM_APP,
+    AE_DSP_ASTREAM_PHONE,
+    AE_DSP_ASTREAM_MESSAGE,
+
+    AE_DSP_ASTREAM_AUTO,
+    AE_DSP_ASTREAM_MAX
+  } AE_DSP_STREAMTYPE;
+
+  /*!
+   * @brief Add-ons supported audio stream type flags
+   * used on master mode information on AE_DSP_MODES to know
+   * on which audio stream the master mode is supported
+   */
+  typedef enum
+  {
+    AE_DSP_PRSNT_ASTREAM_BASIC    = 1<<AE_DSP_ASTREAM_BASIC,
+    AE_DSP_PRSNT_ASTREAM_MUSIC    = 1<<AE_DSP_ASTREAM_MUSIC,
+    AE_DSP_PRSNT_ASTREAM_MOVIE    = 1<<AE_DSP_ASTREAM_MOVIE,
+    AE_DSP_PRSNT_ASTREAM_GAME     = 1<<AE_DSP_ASTREAM_GAME,
+    AE_DSP_PRSNT_ASTREAM_APP      = 1<<AE_DSP_ASTREAM_APP,
+    AE_DSP_PRSNT_ASTREAM_PHONE    = 1<<AE_DSP_ASTREAM_PHONE,
+    AE_DSP_PRSNT_ASTREAM_MESSAGE  = 1<<AE_DSP_ASTREAM_MESSAGE,
+  } AE_DSP_ASTREAM_PRESENT;
+
+  /**
+   * @brief The various base type formats
+   * Used for audio DSP processing to know input audio source
+   */
+  typedef enum
+  {
+    AE_DSP_ABASE_INVALID = -1,
+    AE_DSP_ABASE_STEREO = 0,
+    AE_DSP_ABASE_MONO,
+    AE_DSP_ABASE_MULTICHANNEL,
+    AE_DSP_ABASE_AC3,
+    AE_DSP_ABASE_EAC3,
+    AE_DSP_ABASE_DTS,
+    AE_DSP_ABASE_DTSHD_MA,
+    AE_DSP_ABASE_DTSHD_HRA,
+    AE_DSP_ABASE_TRUEHD,
+    AE_DSP_ABASE_MLP,
+    AE_DSP_ABASE_FLAC,
+
+    AE_DSP_ABASE_MAX
+  } AE_DSP_BASETYPE;
+
+
+  /**
+   * @brief The from KODI in settings requested audio process quality.
+   * The KODI internal used quality levels is translated to this values
+   * for usage on DSP processing add-ons. Is present on iQualityLevel
+   * inside AE_DSP_SETTINGS.
+   */
+  typedef enum
+  {
+    AE_DSP_QUALITY_UNKNOWN    = -1,             /*!< @brief  Unset, unknown or incorrect quality level */
+    AE_DSP_QUALITY_DEFAULT    =  0,             /*!< @brief  Engine's default quality level */
+
+    /* Basic quality levels */
+    AE_DSP_QUALITY_LOW        = 20,             /*!< @brief  Low quality level */
+    AE_DSP_QUALITY_MID        = 30,             /*!< @brief  Standard quality level */
+    AE_DSP_QUALITY_HIGH       = 50,             /*!< @brief  Best sound processing quality */
+
+    /* Optional quality levels */
+    AE_DSP_QUALITY_REALLYHIGH = 100             /*!< @brief  Uncompromising optional quality level, usually with unmeasurable and unnoticeable improvement */
+  } AE_DSP_QUALITY;
+
+  /*!
+   * @brief Audio DSP menu hook categories.
+   * Used to identify on AE_DSP_MENUHOOK given add-on related skin dialog/windows.
+   * Except AE_DSP_MENUHOOK_ALL and AE_DSP_MENUHOOK_SETTING are the menus available
+   * from DSP playback dialogue which can be opened over KODI file context menu and over
+   * button on full screen OSD window.
+   *
+   * Menu hook AE_DSP_MENUHOOK_SETTING is available from DSP processing setup dialogue.
+   */
+  typedef enum
+  {
+    AE_DSP_MENUHOOK_UNKNOWN         =-1,        /*!< @brief unknown menu hook */
+    AE_DSP_MENUHOOK_ALL             = 0,        /*!< @brief all categories */
+    AE_DSP_MENUHOOK_PRE_PROCESS     = 1,        /*!< @brief for pre processing */
+    AE_DSP_MENUHOOK_MASTER_PROCESS  = 2,        /*!< @brief for master processing */
+    AE_DSP_MENUHOOK_POST_PROCESS    = 3,        /*!< @brief for post processing */
+    AE_DSP_MENUHOOK_RESAMPLE        = 4,        /*!< @brief for re sample */
+    AE_DSP_MENUHOOK_MISCELLANEOUS   = 5,        /*!< @brief for miscellaneous dialogues */
+    AE_DSP_MENUHOOK_INFORMATION     = 6,        /*!< @brief dialogue to show processing information */
+    AE_DSP_MENUHOOK_SETTING         = 7,        /*!< @brief for settings */
+  } AE_DSP_MENUHOOK_CAT;
+
+  /*!
+   * @brief Menu hooks that are available in the menus while playing a stream via this add-on.
+   */
+  typedef struct AE_DSP_MENUHOOK
+  {
+    unsigned int        iHookId;                /*!< @brief (required) this hook's identifier */
+    unsigned int        iLocalizedStringId;     /*!< @brief (required) the id of the label for this hook in g_localizeStrings */
+    AE_DSP_MENUHOOK_CAT category;               /*!< @brief (required) category of menu hook */
+    unsigned int        iRelevantModeId;        /*!< @brief (required) except category AE_DSP_MENUHOOK_SETTING and AE_DSP_MENUHOOK_ALL must be the related mode id present here */
+    bool                bNeedPlayback;          /*!< @brief (required) set to true if menu hook need playback and active processing */
+  } ATTRIBUTE_PACKED AE_DSP_MENUHOOK;
+
+  /*!
+   * @brief Audio DSP add-on capabilities. All capabilities are set to "false" as default.
+   * If a capability is set to true, then the corresponding methods from kodi_audiodsp_dll.h need to be implemented.
+   */
+  typedef struct AE_DSP_ADDON_CAPABILITIES
+  {
+    bool bSupportsInputProcess;                 /*!< @brief true if this add-on provides audio input processing */
+    bool bSupportsInputResample;                /*!< @brief true if this add-on provides audio resample before master handling */
+    bool bSupportsPreProcess;                   /*!< @brief true if this add-on provides audio pre processing */
+    bool bSupportsMasterProcess;                /*!< @brief true if this add-on provides audio master processing */
+    bool bSupportsPostProcess;                  /*!< @brief true if this add-on provides audio post processing */
+    bool bSupportsOutputResample;               /*!< @brief true if this add-on provides audio re sample after master handling */
+  } ATTRIBUTE_PACKED AE_DSP_ADDON_CAPABILITIES;
+
+  /*!
+   * @brief Audio processing settings for in and out arrays
+   * Send on creation and before first processed audio packet to add-on
+   */
+  typedef struct AE_DSP_SETTINGS
+  {
+    AE_DSP_STREAM_ID  iStreamID;                /*!< @brief id of the audio stream packets */
+    AE_DSP_STREAMTYPE iStreamType;              /*!< @brief the input stream type source eg, Movie or Music */
+    int               iInChannels;              /*!< @brief the amount of input channels */
+    unsigned long     lInChannelPresentFlags;   /*!< @brief the exact channel mapping flags of input */
+    int               iInFrames;                /*!< @brief the input frame size from KODI */
+    unsigned int      iInSamplerate;            /*!< @brief the basic sample rate of the audio packet */
+    int               iProcessFrames;           /*!< @brief the processing frame size inside add-on's */
+    unsigned int      iProcessSamplerate;       /*!< @brief the sample rate after input resample present in master processing */
+    int               iOutChannels;             /*!< @brief the amount of output channels */
+    unsigned long     lOutChannelPresentFlags;  /*!< @brief the exact channel mapping flags for output */
+    int               iOutFrames;               /*!< @brief the final out frame size for KODI */
+    unsigned int      iOutSamplerate;           /*!< @brief the final sample rate of the audio packet */
+    bool              bInputResamplingActive;   /*!< @brief if a re-sampling is performed before master processing this flag is set to true */
+    bool              bStereoUpmix;             /*!< @brief true if the stereo upmix setting on kodi is set */
+    int               iQualityLevel;            /*!< @brief the from KODI selected quality level for signal processing */
+    /*!
+     * @note about "iProcessSamplerate" and "iProcessFrames" is set from KODI after call of StreamCreate on input re sample add-on, if re-sampling
+     * and processing is handled inside the same add-on, this value must be ignored!
+     */
+  } ATTRIBUTE_PACKED AE_DSP_SETTINGS;
+
+  /*!
+   * @brief Stream profile properties
+   * Can be used to detect best master processing mode and for post processing methods.
+   */
+//@{
+
+  /*!
+   * @brief Dolby profile types. Given from several formats, e.g. Dolby Digital or TrueHD
+   * Used on AE_DSP_PROFILE_AC3_EAC3 and AE_DSP_PROFILE_MLP_TRUEHD
+   */
+  #define AE_DSP_PROFILE_DOLBY_NONE             0
+  #define AE_DSP_PROFILE_DOLBY_SURROUND         1
+  #define AE_DSP_PROFILE_DOLBY_PLII             2
+  #define AE_DSP_PROFILE_DOLBY_PLIIX            3
+  #define AE_DSP_PROFILE_DOLBY_PLIIZ            4
+  #define AE_DSP_PROFILE_DOLBY_EX               5
+  #define AE_DSP_PROFILE_DOLBY_HEADPHONE        6
+
+  /*!
+   * @brief DTS/DTS HD profile types
+   * Used on AE_DSP_PROFILE_DTS_DTSHD
+   */
+  #define AE_DSP_PROFILE_DTS                    0
+  #define AE_DSP_PROFILE_DTS_ES                 1
+  #define AE_DSP_PROFILE_DTS_96_24              2
+  #define AE_DSP_PROFILE_DTS_HD_HRA             3
+  #define AE_DSP_PROFILE_DTS_HD_MA              4
+
+  /*!
+   * @brief AC3/EAC3 based service types
+   * Used on AE_DSP_PROFILE_AC3_EAC3
+   */
+  #define AE_DSP_SERVICE_TYPE_MAIN              0
+  #define AE_DSP_SERVICE_TYPE_EFFECTS           1
+  #define AE_DSP_SERVICE_TYPE_VISUALLY_IMPAIRED 2
+  #define AE_DSP_SERVICE_TYPE_HEARING_IMPAIRED  3
+  #define AE_DSP_SERVICE_TYPE_DIALOGUE          4
+  #define AE_DSP_SERVICE_TYPE_COMMENTARY        5
+  #define AE_DSP_SERVICE_TYPE_EMERGENCY         6
+  #define AE_DSP_SERVICE_TYPE_VOICE_OVER        7
+  #define AE_DSP_SERVICE_TYPE_KARAOKE           8
+
+  /*!
+   * @brief AC3/EAC3 based room types
+   * Present on AE_DSP_PROFILE_AC3_EAC3 and can be used for frequency corrections
+   * at post processing, e.g. THX Re-Equalization
+   */
+  #define AE_DSP_ROOM_TYPE_UNDEFINED            0
+  #define AE_DSP_ROOM_TYPE_SMALL                1
+  #define AE_DSP_ROOM_TYPE_LARGE                2
+
+  /*!
+   * @brief AC3/EAC3 stream profile properties
+   */
+  //! @todo add handling for it (currently never becomes set)
+  typedef struct AE_DSP_PROFILE_AC3_EAC3
+  {
+    unsigned int iProfile;                      /*!< defined by AE_DSP_PROFILE_DOLBY_* */
+    unsigned int iServiceType;                  /*!< defined by AE_DSP_SERVICE_TYPE_* */
+    unsigned int iRoomType;                     /*!< defined by AE_DSP_ROOM_TYPE_* (NOTICE: Information about it currently not supported from ffmpeg and must be implemented) */
+  } ATTRIBUTE_PACKED AE_DSP_PROFILE_AC3_EAC3;
+
+  /*!
+   * @brief MLP/Dolby TrueHD stream profile properties
+   */
+  //! @todo add handling for it (currently never becomes set)
+  typedef struct AE_DSP_PROFILE_MLP_TRUEHD
+  {
+    unsigned int iProfile;                      /*!< defined by AE_DSP_PROFILE_DOLBY_* */
+  } ATTRIBUTE_PACKED AE_DSP_PROFILE_MLP_TRUEHD;
+
+  /*!
+   * @brief DTS/DTS HD stream profile properties
+   */
+  //! @todo add handling for it (currently never becomes set)
+  typedef struct AE_DSP_PROFILE_DTS_DTSHD
+  {
+    unsigned int iProfile;                      /*!< defined by AE_DSP_PROFILE_DTS* */
+    bool bSurroundMatrix;                       /*!< if set to true given 2.0 stream is surround encoded */
+  } ATTRIBUTE_PACKED AE_DSP_PROFILE_DTS_DTSHD;
+
+  union AE_DSP_PROFILE
+  {
+    AE_DSP_PROFILE_AC3_EAC3   ac3_eac3;         /*!< Dolby Digital/Digital+ profile data */
+    AE_DSP_PROFILE_MLP_TRUEHD mlp_truehd;       /*!< MLP or Dolby TrueHD profile data */
+    AE_DSP_PROFILE_DTS_DTSHD  dts_dtshd;        /*!< DTS/DTS-HD profile data */
+  };
+  //@}
+
+  /*!
+   * @brief Audio DSP stream properties
+   * Used to check for the DSP add-on that the stream is supported,
+   * as example Dolby Digital Ex processing is only required on Dolby Digital with 5.1 layout
+   */
+  typedef struct AE_DSP_STREAM_PROPERTIES
+  {
+    AE_DSP_STREAM_ID  iStreamID;                  /*!< @brief stream id of the audio stream packets */
+    AE_DSP_STREAMTYPE iStreamType;                /*!< @brief the input stream type source eg, Movie or Music */
+    int               iBaseType;                  /*!< @brief the input stream base type source eg, Dolby Digital */
+    const char*       strName;                    /*!< @brief the audio stream name */
+    const char*       strCodecId;                 /*!< @brief codec id string of the audio stream */
+    const char*       strLanguage;                /*!< @brief language id of the audio stream */
+    int               iIdentifier;                /*!< @brief audio stream id inside player */
+    int               iChannels;                  /*!< @brief amount of basic channels */
+    int               iSampleRate;                /*!< @brief sample rate */
+    AE_DSP_PROFILE    Profile;                    /*!< @brief current running stream profile data */
+  } ATTRIBUTE_PACKED AE_DSP_STREAM_PROPERTIES;
+
+  /*!
+   * @brief Audio DSP mode categories
+   */
+  typedef enum
+  {
+    AE_DSP_MODE_TYPE_UNDEFINED       = -1,       /*!< @brief undefined type, never be used from add-on! */
+    AE_DSP_MODE_TYPE_INPUT_RESAMPLE  = 0,        /*!< @brief for input re sample */
+    AE_DSP_MODE_TYPE_PRE_PROCESS     = 1,        /*!< @brief for preprocessing */
+    AE_DSP_MODE_TYPE_MASTER_PROCESS  = 2,        /*!< @brief for master processing */
+    AE_DSP_MODE_TYPE_POST_PROCESS    = 3,        /*!< @brief for post processing */
+    AE_DSP_MODE_TYPE_OUTPUT_RESAMPLE = 4,        /*!< @brief for output re sample */
+    AE_DSP_MODE_TYPE_MAX             = 5
+  } AE_DSP_MODE_TYPE;
+
+  /*!
+   * @brief Audio DSP master mode information
+   * Used to get all available modes for current input stream
+   */
+  typedef struct AE_DSP_MODES
+  {
+    unsigned int iModesCount;                                             /*!< @brief (required) count of how much modes are in AE_DSP_MODES */
+    struct AE_DSP_MODE
+    {
+      int               iUniqueDBModeId;                                  /*!< @brief (required) the inside add-on used identifier for the mode, set by KODI's audio DSP database */
+      AE_DSP_MODE_TYPE  iModeType;                                        /*!< @brief (required) the processong mode type, see AE_DSP_MODE_TYPE */
+      char              strModeName[ADDON_STANDARD_STRING_LENGTH];        /*!< @brief (required) the addon name of the mode, used on KODI's logs  */
+
+      unsigned int      iModeNumber;                                      /*!< @brief (required) number of this mode on the add-on, is used on process functions with value "mode_id" */
+      unsigned int      iModeSupportTypeFlags;                            /*!< @brief (required) flags about supported input types for this mode, see AE_DSP_ASTREAM_PRESENT */
+      bool              bHasSettingsDialog;                               /*!< @brief (required) if setting dialog(s) are available it must be set to true */
+      bool              bIsDisabled;                                      /*!< @brief (optional) true if this mode is marked as disabled and not enabled default, only relevant for master processes, all other types always disabled as default */
+
+      unsigned int      iModeName;                                        /*!< @brief (required) the name id of the mode for this hook in g_localizeStrings */
+      unsigned int      iModeSetupName;                                   /*!< @brief (optional) the name id of the mode inside settings for this hook in g_localizeStrings */
+      unsigned int      iModeDescription;                                 /*!< @brief (optional) the description id of the mode for this hook in g_localizeStrings */
+      unsigned int      iModeHelp;                                        /*!< @brief (optional) help string id for inside DSP settings dialog of the mode for this hook in g_localizeStrings */
+
+      char              strOwnModeImage[ADDON_STANDARD_STRING_LENGTH];    /*!< @brief (optional) flag image for the mode */
+      char              strOverrideModeImage[ADDON_STANDARD_STRING_LENGTH];/*!< @brief (optional) image to override KODI Image for the mode, eg. Dolby Digital with Dolby Digital Ex (only used on master modes) */
+    } mode[AE_DSP_STREAM_MAX_MODES];                                      /*!< @brief Modes array storage */
+  } ATTRIBUTE_PACKED AE_DSP_MODES;
+
+  /*!
+   * @brief Audio DSP menu hook data
+   */
+  typedef struct AE_DSP_MENUHOOK_DATA
+  {
+    AE_DSP_MENUHOOK_CAT category;                                         /*!< @brief (required) related menuhook data category */
+    union data {
+      AE_DSP_STREAM_ID  iStreamId;                                        /*!< @brief currently only stream id is used, is used as union to have extension possibility */
+    } data;                                                               /*!< @brief related category related data */
+  } ATTRIBUTE_PACKED AE_DSP_MENUHOOK_DATA;
+
+  /*!
+   * @brief Properties passed to the Create() method of an add-on.
+   */
+  typedef struct AddonProps_AudioDSP
+  {
+    const char* strUserPath;                    /*!< @brief path to the user profile */
+    const char* strAddonPath;                   /*!< @brief path to this add-on */
+  } AddonProps_AudioDSP;
+
+  typedef struct AddonToKodiFuncTable_AudioDSP
+  {
+    void* kodiInstance;
+    void (*add_menu_hook)(void* kodiInstance, AE_DSP_MENUHOOK *hook);
+    void (*remove_menu_hook)(void* kodiInstance, AE_DSP_MENUHOOK *hook);
+    void (*register_mode)(void* kodiInstance, AE_DSP_MODES::AE_DSP_MODE *mode);
+    void (*unregister_mode)(void* kodiInstance, AE_DSP_MODES::AE_DSP_MODE *mode);
+  } AddonToKodiFuncTable_AudioDSP;
+
+  struct AddonInstance_AudioDSP;
+  typedef struct KodiToAddonFuncTable_AudioDSP
+  {
+    kodi::addon::CInstanceAudioDSP* addonInstance;
+    void (__cdecl* get_capabilities)(AddonInstance_AudioDSP const* addonInstance, AE_DSP_ADDON_CAPABILITIES*);
+    const char* (__cdecl* get_dsp_name)(AddonInstance_AudioDSP const* addonInstance);
+    const char* (__cdecl* get_dsp_version)(AddonInstance_AudioDSP const* addonInstance);
+    AE_DSP_ERROR (__cdecl* menu_hook)(AddonInstance_AudioDSP const* addonInstance, const AE_DSP_MENUHOOK*, const AE_DSP_MENUHOOK_DATA*);
+
+    AE_DSP_ERROR (__cdecl* stream_create)(AddonInstance_AudioDSP const* addonInstance, const AE_DSP_SETTINGS*, const AE_DSP_STREAM_PROPERTIES*, ADDON_HANDLE);
+    AE_DSP_ERROR (__cdecl* stream_destroy)(AddonInstance_AudioDSP const* addonInstance, const ADDON_HANDLE);
+    AE_DSP_ERROR (__cdecl* stream_is_mode_supported)(AddonInstance_AudioDSP const* addonInstance, const ADDON_HANDLE, AE_DSP_MODE_TYPE, unsigned int, int);
+    AE_DSP_ERROR (__cdecl* stream_initialize)(AddonInstance_AudioDSP const* addonInstance, const ADDON_HANDLE, const AE_DSP_SETTINGS*);
+
+    bool (__cdecl* input_process)(AddonInstance_AudioDSP const* addonInstance, const ADDON_HANDLE, const float**, unsigned int);
+
+    unsigned int (__cdecl* input_resample_process_needed_samplesize)(AddonInstance_AudioDSP const* addonInstance, const ADDON_HANDLE);
+    unsigned int (__cdecl* input_resample_process)(AddonInstance_AudioDSP const* addonInstance, const ADDON_HANDLE, const float**, float**, unsigned int);
+    float (__cdecl* input_resample_get_delay)(AddonInstance_AudioDSP const* addonInstance, const ADDON_HANDLE);
+    int (__cdecl* input_resample_samplerate)(AddonInstance_AudioDSP const* addonInstance, const ADDON_HANDLE);
+
+    unsigned int (__cdecl* pre_process_needed_samplesize)(AddonInstance_AudioDSP const* addonInstance, const ADDON_HANDLE, unsigned int);
+    float (__cdecl* pre_process_get_delay)(AddonInstance_AudioDSP const* addonInstance, const ADDON_HANDLE, unsigned int);
+    unsigned int (__cdecl* pre_process)(AddonInstance_AudioDSP const* addonInstance, const ADDON_HANDLE, unsigned int, const float**, float**, unsigned int);
+
+    AE_DSP_ERROR (__cdecl* master_process_set_mode)(AddonInstance_AudioDSP const* addonInstance, const ADDON_HANDLE, AE_DSP_STREAMTYPE, unsigned int, int);
+    unsigned int (__cdecl* master_process_needed_samplesize)(AddonInstance_AudioDSP const* addonInstance, const ADDON_HANDLE);
+    float (__cdecl* master_process_get_delay)(AddonInstance_AudioDSP const* addonInstance, const ADDON_HANDLE);
+    int (__cdecl* master_process_get_out_channels)(AddonInstance_AudioDSP const* addonInstance, const ADDON_HANDLE, unsigned long*);
+    unsigned int (__cdecl* master_process)(AddonInstance_AudioDSP const* addonInstance, const ADDON_HANDLE, const float**, float**, unsigned int);
+    const char* (__cdecl* master_process_get_stream_info_string)(AddonInstance_AudioDSP const* addonInstance, const ADDON_HANDLE);
+
+    unsigned int (__cdecl* post_process_needed_samplesize)(AddonInstance_AudioDSP const* addonInstance, const ADDON_HANDLE, unsigned int);
+    float (__cdecl* post_process_get_delay)(AddonInstance_AudioDSP const* addonInstance, const ADDON_HANDLE, unsigned int);
+    unsigned int (__cdecl* post_process)(AddonInstance_AudioDSP const* addonInstance, const ADDON_HANDLE, unsigned int, const float**, float**, unsigned int);
+
+    unsigned int (__cdecl* output_resample_process_needed_samplesize)(AddonInstance_AudioDSP const* addonInstance, const ADDON_HANDLE);
+    unsigned int (__cdecl* output_resample_process)(AddonInstance_AudioDSP const* addonInstance, const ADDON_HANDLE, const float**, float**, unsigned int);
+    float (__cdecl* output_resample_get_delay)(AddonInstance_AudioDSP const* addonInstance, const ADDON_HANDLE);
+    int (__cdecl* output_resample_samplerate)(AddonInstance_AudioDSP const* addonInstance, const ADDON_HANDLE);
+  } KodiToAddonFuncTable_AudioDSP;
+
+  typedef struct AddonInstance_AudioDSP
+  {
+    AddonProps_AudioDSP props;
+    AddonToKodiFuncTable_AudioDSP toKodi;
+    KodiToAddonFuncTable_AudioDSP toAddon;
+  } AddonInstance_AudioDSP;
+
+} /* extern "C" */
+
+namespace kodi {
+namespace addon {
+
+  class CInstanceAudioDSP : public IAddonInstance
+  {
+  public:
+    //==========================================================================
+    /// @brief Class constructor
+    ///
+    CInstanceAudioDSP()
+      : IAddonInstance(ADDON_INSTANCE_ADSP)
+    {
+      if (CAddonBase::m_interface->globalSingleInstance != nullptr)
+        throw std::logic_error("kodi::addon::CInstanceAudioDSP: Creation of more as one in single instance way is not allowed!");
+
+      SetAddonStruct(CAddonBase::m_interface->firstKodiInstance);
+      CAddonBase::m_interface->globalSingleInstance = this;
+    }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    /// @brief Class constructor
+    ///
+    /// @param[in] instance             The from Kodi given instance given be
+    ///                                 add-on CreateInstance call with instance
+    ///                                 id ADDON_INSTANCE_ADSP.
+    ///
+    CInstanceAudioDSP(KODI_HANDLE instance)
+      : IAddonInstance(ADDON_INSTANCE_ADSP)
+    {
+      if (CAddonBase::m_interface->globalSingleInstance != nullptr)
+        throw std::logic_error("kodi::addon::CInstanceAudioDSP: Creation of multiple together with single instance way is not allowed!");
+
+      SetAddonStruct(instance);
+    }
+    //--------------------------------------------------------------------------
+
+    /*! @name Audio DSP add-on methods */
+    //@{
+    //==========================================================================
+    ///
+    /// @brief Get the list of features that this add-on provides.
+    /// Called by KODI to query the add-ons capabilities.
+    /// Used to check which options should be presented in the DSP, which methods
+    /// to call, etc.
+    /// All capabilities that the add-on supports should be set to true.
+    /// @param capabilities The add-ons capabilities.
+    /// @remarks Valid implementation required.
+    ///
+    virtual void GetCapabilities(AE_DSP_ADDON_CAPABILITIES& capabilities) = 0;
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @return The name reported by the back end that will be displayed in the
+    /// UI.
+    /// @remarks Valid implementation required.
+    ///
+    virtual std::string GetDSPName() = 0;
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @return The version string reported by the back end that will be displayed
+    /// in the UI.
+    /// @remarks Valid implementation required.
+    ///
+    virtual std::string GetDSPVersion() = 0;
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @brief Call one of the menu hooks (if supported).
+    /// Supported AE_DSP_MENUHOOK instances have to be added in ADDON_Create(),
+    /// by calling AddMenuHook() on the callback.
+    /// @param menuhook The hook to call.
+    /// @param item The selected item for which the hook was called.
+    /// @return AE_DSP_ERROR_NO_ERROR if the hook was called successfully.
+    /// @remarks Optional. Return AE_DSP_ERROR_NOT_IMPLEMENTED if this add-on
+    /// won't provide this function.
+    ///
+    virtual AE_DSP_ERROR MenuHook(const AE_DSP_MENUHOOK& menuhook, const AE_DSP_MENUHOOK_DATA& item) { return AE_DSP_ERROR_NOT_IMPLEMENTED; }
+    //--------------------------------------------------------------------------
+    //@}
+
+    //==========================================================================
+    /// @name DSP processing control, used to open and close a stream
+    ///  @remarks Valid implementation required.
+    ///
+    //@{
+    ///
+    /// @brief Set up Audio DSP with selected audio settings (use the basic
+    /// present audio stream data format).
+    /// Used to detect available add-ons for present stream, as example stereo
+    /// surround upmix not needed on 5.1 audio stream.
+    /// @param addonSettings The add-ons audio settings.
+    /// @param properties The properties of the currently playing stream.
+    /// @param handle On this becomes addon informated about stream id and can set function addresses which need on calls
+    /// @return AE_DSP_ERROR_NO_ERROR if the properties were fetched successfully
+    /// and data can be performed. AE_DSP_ERROR_IGNORE_ME if format is not
+    /// supported, but without fault.
+    /// @remarks Valid implementation required.
+    ///
+    virtual AE_DSP_ERROR StreamCreate(const AE_DSP_SETTINGS& addonSettings, const AE_DSP_STREAM_PROPERTIES& properties, ADDON_HANDLE handle) = 0;
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// Remove the selected id from currently used DSP processes
+    /// @param handle identification data for stream
+    /// @return AE_DSP_ERROR_NO_ERROR if the becomes found and removed
+    /// @remarks Valid implementation required.
+    ///
+    virtual AE_DSP_ERROR StreamDestroy(const ADDON_HANDLE handle) = 0;
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @brief Ask the add-on about a requested processing mode that it is
+    /// supported on the current stream. Is called about every add-on mode after
+    /// successed StreamCreate.
+    /// @param handle identification data for stream
+    /// @param type The processing mode type, see AE_DSP_MODE_TYPE for definitions
+    /// @param mode_id The mode inside add-on which must be performed on call. Id
+    /// is set from add-on by iModeNumber on AE_DSP_MODE structure during
+    /// RegisterMode callback,
+    /// @param unique_db_mode_id The Mode unique id generated from dsp database.
+    /// @return AE_DSP_ERROR_NO_ERROR if the properties were fetched successfully
+    /// or if the stream is not supported the add-on must return
+    /// AE_DSP_ERROR_IGNORE_ME.
+    /// @remarks Valid implementation required.
+    ///
+    virtual AE_DSP_ERROR StreamIsModeSupported(const ADDON_HANDLE handle, AE_DSP_MODE_TYPE type, unsigned int mode_id, int unique_db_mode_id) = 0;
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @brief Set up Audio DSP with selected audio settings (detected on data of
+    /// first present audio packet)
+    /// @param addonSettings The add-ons audio settings.
+    /// @return AE_DSP_ERROR_NO_ERROR if the properties were fetched successfully.
+    /// @remarks Valid implementation required.
+    ///
+    virtual AE_DSP_ERROR StreamInitialize(const ADDON_HANDLE handle, const AE_DSP_SETTINGS& addonSettings) = 0;
+    //--------------------------------------------------------------------------
+
+    //@}
+
+    /// @name DSP input processing
+    ///  @remarks Only used by KODI if bSupportsInputProcess is set to true.
+    ///
+    //@{
+    //==========================================================================
+    ///
+    /// @brief DSP input processing
+    /// Can be used to have unchanged stream..
+    /// All DSP add-ons allowed to-do this.
+    /// @param handle identification data for stream
+    /// @param array_in Pointer to data memory
+    /// @param samples Amount of samples inside array_in
+    /// @return true if work was OK
+    /// @remarks Optional. Is set by AE_DSP_ADDON_CAPABILITIES and asked with
+    /// GetCapabilities
+    ///
+    virtual bool InputProcess(const ADDON_HANDLE handle, const float** array_in, unsigned int samples) { return true; }
+    //--------------------------------------------------------------------------
+    //@}
+
+    /// @name DSP pre-resampling
+    ///  @remarks Only used by KODI if bSupportsInputResample is set to true.
+    ///
+    //@{
+    //==========================================================================
+    ///
+    /// @brief If the add-on operate with buffered arrays and the output size can
+    /// be higher as the input it becomes asked about needed size before any
+    /// InputResampleProcess call.
+    /// @param handle identification data for stream
+    /// @return The needed size of output array or 0 if no changes within it
+    /// @remarks Optional. Is set by AE_DSP_ADDON_CAPABILITIES and asked with
+    /// GetCapabilities
+    ///
+    virtual unsigned int InputResampleProcessNeededSamplesize(const ADDON_HANDLE handle) { return 0; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @brief DSP re sample processing before master.
+    /// Here a high quality resample can be performed.
+    /// Only one DSP add-on is allowed to-do this!
+    /// @param handle identification data for stream
+    /// @param array_in Pointer to input data memory
+    /// @param array_out Pointer to output data memory
+    /// @param samples Amount of samples inside array_in
+    /// @return Amount of samples processed
+    /// @remarks Optional. Is set by AE_DSP_ADDON_CAPABILITIES and asked with
+    /// GetCapabilities
+    ///
+    virtual unsigned int InputResampleProcess(const ADDON_HANDLE handle, const float** array_in, float** array_out, unsigned int samples) { return 0; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @brief Returns the re-sampling generated new sample rate used before the
+    /// master process
+    /// @param handle identification data for stream
+    /// @return The new sample rate
+    /// @remarks Optional. Is set by AE_DSP_ADDON_CAPABILITIES and asked with
+    /// GetCapabilities
+    ///
+    virtual int InputResampleSampleRate(const ADDON_HANDLE handle) { return 0; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @brief Returns the time in seconds that it will take
+    /// for the next added packet to be returned to KODI.
+    /// @param handle identification data for stream
+    /// @return the delay in seconds
+    /// @remarks Optional. Is set by AE_DSP_ADDON_CAPABILITIES and asked with
+    /// GetCapabilities
+    ///
+    virtual float InputResampleGetDelay(const ADDON_HANDLE handle) { return 0.0f; }
+    //--------------------------------------------------------------------------
+    //@}
+
+    /** @name DSP Pre processing
+    *  @remarks Only used by KODI if bSupportsPreProcess is set to true.
+    */
+    //@{
+    //==========================================================================
+    ///
+    /// @brief If the addon operate with buffered arrays and the output size can
+    /// be higher as the input it becomes asked about needed size before any
+    /// PreProcess call.
+    /// @param handle identification data for stream
+    /// @param mode_id The mode inside add-on which must be performed on call. Id
+    /// is set from add-on by iModeNumber on AE_DSP_MODE structure during
+    /// RegisterMode callback and can be defined from add-on as a structure
+    /// pointer or anything else what is needed to find it.
+    /// @return The needed size of output array or 0 if no changes within it
+    /// @remarks Optional. Is set by AE_DSP_ADDON_CAPABILITIES and asked with
+    /// GetCapabilities
+    ///
+    virtual unsigned int PreProcessNeededSamplesize(const ADDON_HANDLE handle, unsigned int mode_id) { return 0; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @brief Returns the time in seconds that it will take
+    /// for the next added packet to be returned to KODI.
+    /// @param handle identification data for stream
+    /// @param mode_id The mode inside add-on which must be performed on call. Id
+    /// is set from add-on by iModeNumber on AE_DSP_MODE structure during
+    /// RegisterMode callback and can be defined from add-on as a structure
+    /// pointer or anything else what is needed to find it.
+    /// @return the delay in seconds
+    /// @remarks Optional. Is set by AE_DSP_ADDON_CAPABILITIES and asked with
+    /// GetCapabilities
+    ///
+    virtual float PreProcessGetDelay(const ADDON_HANDLE handle, unsigned int mode_id) { return 0.0f; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @brief DSP preprocessing
+    /// All DSP add-ons allowed to-do this.
+    /// @param handle identification data for stream
+    /// @param mode_id The mode inside add-on which must be performed on call. Id
+    /// is set from add-on by iModeNumber on AE_DSP_MODE structure during
+    /// RegisterMode callback and can be defined from add-on as a structure
+    /// pointer or anything else what is needed to find it.
+    /// @param array_in Pointer to input data memory
+    /// @param array_out Pointer to output data memory
+    /// @param samples Amount of samples inside array_in
+    /// @return Amount of samples processed
+    /// @remarks Optional. Is set by AE_DSP_ADDON_CAPABILITIES and asked with
+    /// GetCapabilities
+    ///
+    virtual unsigned int PreProcess(const ADDON_HANDLE handle, unsigned int mode_id, const float** array_in, float** array_out, unsigned int samples) { return 0; }
+    //--------------------------------------------------------------------------
+    //@}
+
+    /** @name DSP Master processing
+    *  @remarks Only used by KODI if bSupportsMasterProcess is set to true.
+    */
+    //@{
+    //==========================================================================
+    ///
+    /// @brief Set the active master process mode
+    /// @param handle identification data for stream
+    /// @param type Requested stream type for the selected master mode
+    /// @param mode_id The Mode identifier.
+    /// @param unique_db_mode_id The Mode unique id generated from DSP database.
+    /// @return AE_DSP_ERROR_NO_ERROR if the setup was successful
+    /// @remarks Optional. Is set by AE_DSP_ADDON_CAPABILITIES and asked with
+    /// GetCapabilities
+    ///
+    virtual AE_DSP_ERROR MasterProcessSetMode(const ADDON_HANDLE handle, AE_DSP_STREAMTYPE type, unsigned int mode_id, int unique_db_mode_id) { return AE_DSP_ERROR_NOT_IMPLEMENTED; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @brief If the add-on operate with buffered arrays and the output size can
+    /// be higher as the input it becomes asked about needed size before any
+    /// MasterProcess call.
+    /// @param handle identification data for stream
+    /// @return The needed size of output array or 0 if no changes within it
+    /// @remarks Optional. Is set by AE_DSP_ADDON_CAPABILITIES and asked with
+    /// GetCapabilities
+    ///
+    virtual unsigned int MasterProcessNeededSamplesize(const ADDON_HANDLE handle) { return 0; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @brief Returns the time in seconds that it will take
+    /// for the next added packet to be returned to KODI.
+    /// @param handle identification data for stream
+    /// @return the delay in seconds
+    /// @remarks Optional. Is set by AE_DSP_ADDON_CAPABILITIES and asked with
+    /// GetCapabilities
+    ///
+    virtual float MasterProcessGetDelay(const ADDON_HANDLE handle) { return 0.0f; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @brief Returns the from selected master mode performed channel alignment
+    /// @param handle identification data for stream
+    /// @retval out_channel_present_flags the exact channel present flags after
+    /// performed up-/downmix
+    /// @return the amount channels
+    /// @remarks Optional. Must be used and set if a channel up- or downmix is
+    /// processed from the active master mode
+    ///
+    virtual int MasterProcessGetOutChannels(const ADDON_HANDLE handle, unsigned long& out_channel_present_flags) { return 0; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @brief Master processing becomes performed with it
+    /// Here a channel up-mix/down-mix for stereo surround sound can be performed
+    /// Only one DSP add-on is allowed to-do this!
+    /// @param handle identification data for stream
+    /// @param array_in Pointer to input data memory
+    /// @param array_out Pointer to output data memory
+    /// @param samples Amount of samples inside array_in
+    /// @return Amount of samples processed
+    /// @remarks Optional. Is set by AE_DSP_ADDON_CAPABILITIES and asked with
+    /// GetCapabilities
+    ///
+    virtual unsigned int MasterProcess(const ADDON_HANDLE handle, const float** array_in, float** array_out, unsigned int samples) { return 0; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// Used to get a information string about the processed work to show on skin
+    /// @return A string to show
+    /// @remarks Optional. Is set by AE_DSP_ADDON_CAPABILITIES and asked with
+    /// GetCapabilities
+    ///
+    virtual std::string MasterProcessGetStreamInfoString(const ADDON_HANDLE handle) { return ""; }
+    //--------------------------------------------------------------------------
+    //@}
+
+    /** @name DSP Post processing
+    *  @remarks Only used by KODI if bSupportsPostProcess is set to true.
+    */
+    //@{
+    //==========================================================================
+    ///
+    /// If the add-on operate with buffered arrays and the output size can be
+    /// higher as the input it becomes asked about needed size before any
+    /// PostProcess call.
+    /// @param handle identification data for stream
+    /// @param mode_id The mode inside add-on which must be performed on call. Id
+    /// is set from add-on by iModeNumber on AE_DSP_MODE structure during
+    /// RegisterMode callback, and can be defined from add-on as a structure
+    /// pointer or anything else what is needed to find it.
+    /// @return The needed size of output array or 0 if no changes within it
+    /// @remarks Optional. Is set by AE_DSP_ADDON_CAPABILITIES and asked with
+    /// GetCapabilities
+    ///
+    virtual unsigned int PostProcessNeededSamplesize(const ADDON_HANDLE handle, unsigned int mode_id) { return 0; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// Returns the time in seconds that it will take
+    /// for the next added packet to be returned to KODI.
+    /// @param handle identification data for stream
+    /// @param mode_id The mode inside add-on which must be performed on call. Id
+    /// is set from add-on by iModeNumber on AE_DSP_MODE structure during
+    /// RegisterMode callback, and can be defined from add-on as a structure
+    /// pointer or anything else what is needed to find it.
+    /// @return the delay in seconds
+    /// @remarks Optional. Is set by AE_DSP_ADDON_CAPABILITIES and asked with
+    /// GetCapabilities
+    ///
+    virtual float PostProcessGetDelay(const ADDON_HANDLE handle, unsigned int mode_id) { return 0.0f; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+
+    ///
+    /// @brief DSP post processing
+    /// On the post processing can be things performed with additional channel
+    /// upmix like 6.1 to 7.1
+    /// or frequency/volume corrections, speaker distance handling, equalizer... .
+    /// All DSP add-ons allowed to-do this.
+    /// @param handle identification data for stream
+    /// @param mode_id The mode inside add-on which must be performed on call. Id
+    /// is set from add-on by iModeNumber on AE_DSP_MODE structure during
+    /// RegisterMode callback, and can be defined from add-on as a structure
+    /// pointer or anything else what is needed to find it.
+    /// @param array_in Pointer to input data memory
+    /// @param array_out Pointer to output data memory
+    /// @param samples Amount of samples inside array_in
+    /// @return Amount of samples processed
+    /// @remarks Optional. Is set by AE_DSP_ADDON_CAPABILITIES and asked with
+    /// GetCapabilities
+    ///
+    virtual unsigned int PostProcess(const ADDON_HANDLE handle, unsigned int mode_id, const float** array_in, float** array_out, unsigned int samples) { return 0; }
+
+    //--------------------------------------------------------------------------
+    //@}
+
+    /** @name DSP Post re-sampling
+    *  @remarks Only used by KODI if bSupportsOutputResample is set to true.
+    */
+    //@{
+    //==========================================================================
+    ///
+    /// @brief If the add-on operate with buffered arrays and the output size
+    /// can be higher as the input
+    /// it becomes asked about needed size before any OutputResampleProcess call.
+    /// @param handle identification data for stream
+    /// @return The needed size of output array or 0 if no changes within it
+    /// @remarks Optional. Is set by AE_DSP_ADDON_CAPABILITIES and asked with
+    /// GetCapabilities
+    ///
+    virtual unsigned int OutputResampleProcessNeededSamplesize(const ADDON_HANDLE handle) { return 0; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @brief Re-sampling after master processing becomes performed with it if
+    /// needed, only
+    /// one add-on can perform it.
+    /// @param handle identification data for stream
+    /// @param array_in Pointer to input data memory
+    /// @param array_out Pointer to output data memory
+    /// @param samples Amount of samples inside array_in
+    /// @return Amount of samples processed
+    /// @remarks Optional. Is set by AE_DSP_ADDON_CAPABILITIES and asked with
+    /// GetCapabilities
+    ///
+    virtual unsigned int OutputResampleProcess(const ADDON_HANDLE handle, const float** array_in, float** array_out, unsigned int samples) { return 0; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @brief Returns the re-sampling generated new sample rate used after the
+    /// master process.
+    /// @param handle identification data for stream
+    /// @return The new sample rate
+    /// @remarks Optional. Is set by AE_DSP_ADDON_CAPABILITIES and asked with
+    /// GetCapabilities
+    ///
+    virtual int OutputResampleSampleRate(const ADDON_HANDLE handle) { return 0; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @brief Returns the time in seconds that it will take for the next added
+    /// packet to be returned to KODI.
+    /// @param handle identification data for stream
+    /// @return the delay in seconds
+    /// @remarks Optional. Is set by AE_DSP_ADDON_CAPABILITIES and asked with
+    /// GetCapabilities
+    ///
+    virtual float OutputResampleGetDelay(const ADDON_HANDLE handle) { return 0.0f; }
+    //--------------------------------------------------------------------------
+    //@}
+
+    //==========================================================================
+    ///
+    /// @brief Add or replace a menu hook for the context menu for this add-on
+    /// @param hook The hook to add
+    ///
+    void AddMenuHook(AE_DSP_MENUHOOK* hook)
+    {
+      return m_instanceData->toKodi.add_menu_hook(m_instanceData->toKodi.kodiInstance, hook);
+    }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @brief Remove a menu hook for the context menu for this add-on
+    /// @param hook The hook to remove
+    ///
+    void RemoveMenuHook(AE_DSP_MENUHOOK* hook)
+    {
+      return m_instanceData->toKodi.remove_menu_hook(m_instanceData->toKodi.kodiInstance, hook);
+    }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @brief Add or replace master mode information inside audio dsp database.
+    /// Becomes identifier written inside mode to iModeID if it was 0 (undefined)
+    /// @param mode The master mode to add or update inside database
+    ///
+    void RegisterMode(AE_DSP_MODES::AE_DSP_MODE* mode)
+    {
+      return m_instanceData->toKodi.register_mode(m_instanceData->toKodi.kodiInstance, mode);
+    }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @brief Remove a master mode from audio dsp database
+    /// @param mode The Mode to remove
+    ///
+    void UnregisterMode(AE_DSP_MODES::AE_DSP_MODE* mode)
+    {
+      return m_instanceData->toKodi.unregister_mode(m_instanceData->toKodi.kodiInstance, mode);
+    }
+    //--------------------------------------------------------------------------
+
+  private:
+    void SetAddonStruct(KODI_HANDLE instance)
+    {
+      if (instance == nullptr)
+        throw std::logic_error("kodi::addon::CInstanceAudioDSP: Null pointer instance passed.");
+
+      m_instanceData = static_cast<AddonInstance_AudioDSP*>(instance);
+
+      m_instanceData->toAddon.get_capabilities = ADDON_GetCapabilities;
+      m_instanceData->toAddon.get_dsp_name = ADDON_GetDSPName;
+      m_instanceData->toAddon.get_dsp_version = ADDON_GetDSPVersion;
+      m_instanceData->toAddon.menu_hook = ADDON_MenuHook;
+
+      m_instanceData->toAddon.stream_create = ADDON_StreamCreate;
+      m_instanceData->toAddon.stream_destroy = ADDON_StreamDestroy;
+      m_instanceData->toAddon.stream_is_mode_supported = ADDON_StreamIsModeSupported;
+      m_instanceData->toAddon.stream_initialize = ADDON_StreamInitialize;
+
+      m_instanceData->toAddon.input_process = ADDON_InputProcess;
+
+      m_instanceData->toAddon.input_resample_process_needed_samplesize = ADDON_InputResampleProcessNeededSamplesize;
+      m_instanceData->toAddon.input_resample_process = ADDON_InputResampleProcess;
+      m_instanceData->toAddon.input_resample_get_delay = ADDON_InputResampleGetDelay;
+      m_instanceData->toAddon.input_resample_samplerate = ADDON_InputResampleSampleRate;
+
+      m_instanceData->toAddon.pre_process_needed_samplesize = ADDON_PreProcessNeededSamplesize;
+      m_instanceData->toAddon.pre_process_get_delay = ADDON_PreProcessGetDelay;
+      m_instanceData->toAddon.pre_process = ADDON_PreProcess;
+
+      m_instanceData->toAddon.master_process_set_mode = ADDON_MasterProcessSetMode;
+      m_instanceData->toAddon.master_process_needed_samplesize = ADDON_MasterProcessNeededSamplesize;
+      m_instanceData->toAddon.master_process_get_delay = ADDON_MasterProcessGetDelay;
+      m_instanceData->toAddon.master_process_get_out_channels = ADDON_MasterProcessGetOutChannels;
+      m_instanceData->toAddon.master_process = ADDON_MasterProcess;
+      m_instanceData->toAddon.master_process_get_stream_info_string = ADDON_MasterProcessGetStreamInfoString;
+
+      m_instanceData->toAddon.post_process_needed_samplesize = ADDON_PostProcessNeededSamplesize;
+      m_instanceData->toAddon.post_process_get_delay = ADDON_PostProcessGetDelay;
+      m_instanceData->toAddon.post_process = ADDON_PostProcess;
+
+      m_instanceData->toAddon.output_resample_process_needed_samplesize = ADDON_OutputResampleProcessNeededSamplesize;
+      m_instanceData->toAddon.output_resample_process = ADDON_OutputResampleProcess;
+      m_instanceData->toAddon.output_resample_get_delay = ADDON_OutputResampleGetDelay;
+      m_instanceData->toAddon.output_resample_samplerate = ADDON_OutputResampleSampleRate;
+    }
+
+    static inline void ADDON_GetCapabilities(AddonInstance_AudioDSP const* instance, AE_DSP_ADDON_CAPABILITIES *capabilities)
+    {
+      instance->toAddon.addonInstance->GetCapabilities(*capabilities);
+    }
+
+    static inline const char* ADDON_GetDSPName(AddonInstance_AudioDSP const* instance)
+    {
+      instance->toAddon.addonInstance->m_dspName = instance->toAddon.addonInstance->GetDSPName();
+      return instance->toAddon.addonInstance->m_dspName.c_str();
+    }
+
+    static inline const char* ADDON_GetDSPVersion(AddonInstance_AudioDSP const* instance)
+    {
+      instance->toAddon.addonInstance->m_dspVersion = instance->toAddon.addonInstance->GetDSPVersion();
+      return instance->toAddon.addonInstance->m_dspVersion.c_str();
+    }
+
+    static inline AE_DSP_ERROR ADDON_MenuHook(AddonInstance_AudioDSP const* instance, const AE_DSP_MENUHOOK* menuhook, const AE_DSP_MENUHOOK_DATA* item)
+    {
+      return instance->toAddon.addonInstance->MenuHook(*menuhook, *item);
+    }
+
+    static inline AE_DSP_ERROR ADDON_StreamCreate(AddonInstance_AudioDSP const* instance, const AE_DSP_SETTINGS *addonSettings, const AE_DSP_STREAM_PROPERTIES* properties, ADDON_HANDLE handle)
+    {
+      return instance->toAddon.addonInstance->StreamCreate(*addonSettings, *properties, handle);
+    }
+
+    static inline AE_DSP_ERROR ADDON_StreamDestroy(AddonInstance_AudioDSP const* instance, const ADDON_HANDLE handle)
+    {
+      return instance->toAddon.addonInstance->StreamDestroy(handle);
+    }
+
+    static inline AE_DSP_ERROR ADDON_StreamIsModeSupported(AddonInstance_AudioDSP const* instance, const ADDON_HANDLE handle, AE_DSP_MODE_TYPE type, unsigned int mode_id, int unique_db_mode_id)
+    {
+      return instance->toAddon.addonInstance->StreamIsModeSupported(handle, type, mode_id, unique_db_mode_id);
+    }
+
+    static inline AE_DSP_ERROR ADDON_StreamInitialize(AddonInstance_AudioDSP const* instance, const ADDON_HANDLE handle, const AE_DSP_SETTINGS *addonSettings)
+    {
+      return instance->toAddon.addonInstance->StreamInitialize(handle, *addonSettings);
+    }
+
+    static inline bool ADDON_InputProcess(AddonInstance_AudioDSP const* instance, const ADDON_HANDLE handle, const float** array_in, unsigned int samples)
+    {
+      return instance->toAddon.addonInstance->InputProcess(handle, array_in, samples);
+    }
+
+    static inline unsigned int ADDON_InputResampleProcessNeededSamplesize(AddonInstance_AudioDSP const* instance, const ADDON_HANDLE handle)
+    {
+      return instance->toAddon.addonInstance->InputResampleProcessNeededSamplesize(handle);
+    }
+
+    static inline unsigned int ADDON_InputResampleProcess(AddonInstance_AudioDSP const* instance, const ADDON_HANDLE handle, const float** array_in, float** array_out, unsigned int samples)
+    {
+      return instance->toAddon.addonInstance->InputResampleProcess(handle, array_in, array_out, samples);
+    }
+
+    static inline int ADDON_InputResampleSampleRate(AddonInstance_AudioDSP const* instance, const ADDON_HANDLE handle)
+    {
+      return instance->toAddon.addonInstance->InputResampleSampleRate(handle);
+    }
+
+    static inline float ADDON_InputResampleGetDelay(AddonInstance_AudioDSP const* instance, const ADDON_HANDLE handle)
+    {
+      return instance->toAddon.addonInstance->InputResampleGetDelay(handle);
+    }
+
+    static inline unsigned int ADDON_PreProcessNeededSamplesize(AddonInstance_AudioDSP const* instance, const ADDON_HANDLE handle, unsigned int mode_id)
+    {
+      return instance->toAddon.addonInstance->PreProcessNeededSamplesize(handle, mode_id);
+    }
+
+    static inline float ADDON_PreProcessGetDelay(AddonInstance_AudioDSP const* instance, const ADDON_HANDLE handle, unsigned int mode_id)
+    {
+      return instance->toAddon.addonInstance->PreProcessGetDelay(handle, mode_id);
+    }
+
+    static inline unsigned int ADDON_PreProcess(AddonInstance_AudioDSP const* instance, const ADDON_HANDLE handle, unsigned int mode_id, const float** array_in, float** array_out, unsigned int samples)
+    {
+      return instance->toAddon.addonInstance->PreProcess(handle, mode_id, array_in, array_out, samples);
+    }
+
+    static inline AE_DSP_ERROR ADDON_MasterProcessSetMode(AddonInstance_AudioDSP const* instance, const ADDON_HANDLE handle, AE_DSP_STREAMTYPE type, unsigned int mode_id, int unique_db_mode_id)
+    {
+      return instance->toAddon.addonInstance->MasterProcessSetMode(handle, type, mode_id, unique_db_mode_id);
+    }
+
+    static inline unsigned int ADDON_MasterProcessNeededSamplesize(AddonInstance_AudioDSP const* instance, const ADDON_HANDLE handle)
+    {
+      return instance->toAddon.addonInstance->MasterProcessNeededSamplesize(handle);
+    }
+
+    static inline float ADDON_MasterProcessGetDelay(AddonInstance_AudioDSP const* instance, const ADDON_HANDLE handle)
+    {
+      return instance->toAddon.addonInstance->MasterProcessGetDelay(handle);
+    }
+
+    static inline int ADDON_MasterProcessGetOutChannels(AddonInstance_AudioDSP const* instance, const ADDON_HANDLE handle, unsigned long* out_channel_present_flags)
+    {
+      return instance->toAddon.addonInstance->MasterProcessGetOutChannels(handle, *out_channel_present_flags);
+    }
+
+    static inline unsigned int ADDON_MasterProcess(AddonInstance_AudioDSP const* instance, const ADDON_HANDLE handle, const float** array_in, float** array_out, unsigned int samples)
+    {
+      return instance->toAddon.addonInstance->MasterProcess(handle, array_in, array_out, samples);
+    }
+
+    static inline const char* ADDON_MasterProcessGetStreamInfoString(AddonInstance_AudioDSP const* instance, const ADDON_HANDLE handle)
+    {
+      instance->toAddon.addonInstance->m_streamInfoString = instance->toAddon.addonInstance->MasterProcessGetStreamInfoString(handle);
+      return instance->toAddon.addonInstance->m_streamInfoString.c_str();
+    }
+
+    static inline unsigned int ADDON_PostProcessNeededSamplesize(AddonInstance_AudioDSP const* instance, const ADDON_HANDLE handle, unsigned int mode_id)
+    {
+      return instance->toAddon.addonInstance->PostProcessNeededSamplesize(handle, mode_id);
+    }
+
+    static inline float ADDON_PostProcessGetDelay(AddonInstance_AudioDSP const* instance, const ADDON_HANDLE handle, unsigned int mode_id)
+    {
+      return instance->toAddon.addonInstance->PostProcessGetDelay(handle, mode_id);
+    }
+
+    static inline unsigned int ADDON_PostProcess(AddonInstance_AudioDSP const* instance, const ADDON_HANDLE handle, unsigned int mode_id, const float** array_in, float** array_out, unsigned int samples)
+    {
+      return instance->toAddon.addonInstance->PostProcess(handle, mode_id, array_in, array_out, samples);
+    }
+
+    static inline unsigned int ADDON_OutputResampleProcessNeededSamplesize(AddonInstance_AudioDSP const* instance, const ADDON_HANDLE handle)
+    {
+      return instance->toAddon.addonInstance->OutputResampleProcessNeededSamplesize(handle);
+    }
+
+    static inline unsigned int ADDON_OutputResampleProcess(AddonInstance_AudioDSP const* instance, const ADDON_HANDLE handle, const float** array_in, float** array_out, unsigned int samples)
+    {
+      return instance->toAddon.addonInstance->OutputResampleProcess(handle, array_in, array_out, samples);
+    }
+
+    static inline int ADDON_OutputResampleSampleRate(AddonInstance_AudioDSP const* instance, const ADDON_HANDLE handle)
+    {
+      return instance->toAddon.addonInstance->OutputResampleSampleRate(handle);
+    }
+
+    static inline float ADDON_OutputResampleGetDelay(AddonInstance_AudioDSP const* instance, const ADDON_HANDLE handle)
+    {
+      return instance->toAddon.addonInstance->OutputResampleGetDelay(handle);
+    }
+
+    std::string m_dspName;
+    std::string m_dspVersion;
+    std::string m_streamInfoString;
+    AddonInstance_AudioDSP* m_instanceData;
+  };
+
+} /* namespace addon */
+} /* namespace kodi */
diff --git a/xbmc/addons/kodi-addon-dev-kit/include/kodi/addon-instance/AudioDecoder.h b/xbmc/addons/kodi-addon-dev-kit/include/kodi/addon-instance/AudioDecoder.h
new file mode 100644
index 0000000..f56f8ae
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/include/kodi/addon-instance/AudioDecoder.h
@@ -0,0 +1,240 @@
+#pragma once
+/*
+ *      Copyright (C) 2005-2017 Team Kodi
+ *      http://kodi.tv
+ *
+ *  This Program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This Program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Kodi; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "../AddonBase.h"
+#ifdef BUILD_KODI_ADDON
+#include "../AEChannelData.h"
+#else
+#include "cores/AudioEngine/Utils/AEChannelData.h"
+#endif
+#include <stdint.h>
+
+namespace kodi { namespace addon { class CInstanceAudioDecoder; }}
+
+extern "C"
+{
+
+  typedef struct AddonProps_AudioDecoder
+  {
+    int dummy;
+  } AddonProps_AudioDecoder;
+
+  typedef struct AddonToKodiFuncTable_AudioDecoder
+  {
+    void* kodiInstance;
+  } AddonToKodiFuncTable_AudioDecoder;
+
+  struct AddonInstance_AudioDecoder;
+  typedef struct KodiToAddonFuncTable_AudioDecoder
+  {
+    kodi::addon::CInstanceAudioDecoder* addonInstance;
+    bool (__cdecl* init) (const AddonInstance_AudioDecoder* instance,
+                          const char* file, unsigned int filecache,
+                          int* channels, int* samplerate,
+                          int* bitspersample, int64_t* totaltime,
+                          int* bitrate, AEDataFormat* format,
+                          const AEChannel** info);
+    int  (__cdecl* read_pcm) (const AddonInstance_AudioDecoder* instance, uint8_t* buffer, int size, int* actualsize);
+    int64_t  (__cdecl* seek) (const AddonInstance_AudioDecoder* instance, int64_t time);
+    bool (__cdecl* read_tag) (const AddonInstance_AudioDecoder* instance,
+                              const char* file, char* title,
+                              char* artist, int* length);
+    int  (__cdecl* track_count) (const AddonInstance_AudioDecoder* instance, const char* file);
+  } KodiToAddonFuncTable_AudioDecoder;
+
+  typedef struct AddonInstance_AudioDecoder
+  {
+    AddonProps_AudioDecoder props;
+    AddonToKodiFuncTable_AudioDecoder toKodi;
+    KodiToAddonFuncTable_AudioDecoder toAddon;
+  } AddonInstance_AudioDecoder;
+
+} /* extern "C" */
+
+namespace kodi
+{
+namespace addon
+{
+
+  class CInstanceAudioDecoder : public IAddonInstance
+  {
+  public:
+    //==========================================================================
+    /// @brief Class constructor
+    ///
+    /// @param[in] instance             The from Kodi given instance given be
+    ///                                 add-on CreateInstance call with instance
+    ///                                 id ADDON_INSTANCE_AUDIODECODER.
+    CInstanceAudioDecoder(KODI_HANDLE instance)
+      : IAddonInstance(ADDON_INSTANCE_AUDIODECODER)
+    {
+      if (CAddonBase::m_interface->globalSingleInstance != nullptr)
+        throw std::logic_error("kodi::addon::CInstanceAudioDecoder: Creation of multiple together with single instance way is not allowed!");
+
+      SetAddonStruct(instance);
+    }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    /// @ingroup cpp_kodi_addon_audiodecoder
+    /// @brief Initialize a decoder
+    ///
+    /// @param[in] filename             The file to read
+    /// @param[in] filecache            The file cache size
+    /// @param[out] channels            Number of channels in output stream
+    /// @param[out] samplerate          Samplerate of output stream
+    /// @param[out] bitspersample       Bits per sample in output stream
+    /// @param[out] totaltime           Total time for stream
+    /// @param[out] bitrate             Average bitrate of input stream
+    /// @param[out] format              Data format for output stream
+    /// @param[out] channellist         Channel mapping for output stream
+    /// @return                         true if successfully done, otherwise
+    ///                                 false
+    ///
+    virtual bool Init(const std::string& filename, unsigned int filecache,
+                      int& channels, int& samplerate,
+                      int& bitspersample, int64_t& totaltime,
+                      int& bitrate, AEDataFormat& format,
+                      std::vector<AEChannel>& channellist) = 0;
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    /// @ingroup cpp_kodi_addon_audiodecoder
+    /// @brief Produce some noise
+    ///
+    /// @param[in] buffer               Output buffer
+    /// @param[in] size                 Size of output buffer
+    /// @param[out] actualsize          Actual number of bytes written to output buffer
+    /// @return                         Return with following possible values:
+    ///                                 | Value | Description                  |
+    ///                                 |:-----:|:-----------------------------|
+    ///                                 |   0   | on success
+    ///                                 |  -1   | on end of stream
+    ///                                 |   1   | on failure
+    ///
+    virtual int ReadPCM(uint8_t* buffer, int size, int& actualsize) = 0;
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    /// @ingroup cpp_kodi_addon_audiodecoder
+    /// @brief Seek in output stream
+    ///
+    /// @param[in] time                 Time position to seek to in milliseconds
+    /// @return                         Time position seek ended up on
+    ///
+    virtual int64_t Seek(int64_t time) { return time; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    /// @ingroup cpp_kodi_addon_audiodecoder
+    /// @brief Read tag of a file
+    ///
+    /// @param[in] file                 File to read tag for
+    /// @param[out] title               Title of file
+    /// @param[out] artist              Artist of file
+    /// @param[out] length              Length of file
+    /// @return                         True on success, false on failure
+    ///
+    virtual bool ReadTag(const std::string& file, std::string& title, std::string& artist, int& length) { return false; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    /// @ingroup cpp_kodi_addon_audiodecoder
+    /// @brief Get number of tracks in a file
+    ///
+    /// @param[in] file                 File to read tag for
+    /// @return                         Number of tracks in file
+    ///
+    virtual int TrackCount(const std::string& file) { return 1; }
+    //--------------------------------------------------------------------------
+
+  private:
+    void SetAddonStruct(KODI_HANDLE instance)
+    {
+      if (instance == nullptr)
+        throw std::logic_error("kodi::addon::CInstanceAudioDecoder: Creation with empty addon structure not allowed, table must be given from Kodi!");
+
+      m_instanceData = static_cast<AddonInstance_AudioDecoder*>(instance);
+
+      m_instanceData->toAddon.addonInstance = this;
+      m_instanceData->toAddon.init = ADDON_Init;
+      m_instanceData->toAddon.read_pcm = ADDON_ReadPCM;
+      m_instanceData->toAddon.seek = ADDON_Seek;
+      m_instanceData->toAddon.read_tag = ADDON_ReadTag;
+      m_instanceData->toAddon.track_count = ADDON_TrackCount;
+    }
+
+    inline static bool ADDON_Init(const AddonInstance_AudioDecoder* instance, const char* file, unsigned int filecache,
+                                  int* channels, int* samplerate,
+                                  int* bitspersample, int64_t* totaltime,
+                                  int* bitrate, AEDataFormat* format,
+                                  const AEChannel** info)
+    {
+      instance->toAddon.addonInstance->m_channelList.clear();
+      bool ret = instance->toAddon.addonInstance->Init(file, filecache, *channels,
+                                                           *samplerate, *bitspersample,
+                                                           *totaltime, *bitrate, *format,
+                                                           instance->toAddon.addonInstance->m_channelList);
+      if (!instance->toAddon.addonInstance->m_channelList.empty())
+      {
+        if (instance->toAddon.addonInstance->m_channelList.back() != AE_CH_NULL)
+          instance->toAddon.addonInstance->m_channelList.push_back(AE_CH_NULL);
+        *info = instance->toAddon.addonInstance->m_channelList.data();
+      }
+      else
+        *info = nullptr;
+      return ret;
+    }
+
+    inline static int ADDON_ReadPCM(const AddonInstance_AudioDecoder* instance, uint8_t* buffer, int size, int* actualsize)
+    {
+      return instance->toAddon.addonInstance->ReadPCM(buffer, size, *actualsize);
+    }
+
+    inline static int64_t ADDON_Seek(const AddonInstance_AudioDecoder* instance, int64_t time)
+    {
+      return instance->toAddon.addonInstance->Seek(time);
+    }
+
+    inline static bool ADDON_ReadTag(const AddonInstance_AudioDecoder* instance, const char* file, char* title, char* artist, int* length)
+    {
+      std::string intTitle;
+      std::string intArtist;
+      bool ret = instance->toAddon.addonInstance->ReadTag(file, intTitle, intArtist, *length);
+      if (ret)
+      {
+        strncpy(title, intTitle.c_str(), ADDON_STANDARD_STRING_LENGTH_SMALL-1);
+        strncpy(artist, intArtist.c_str(), ADDON_STANDARD_STRING_LENGTH_SMALL-1);
+      }
+      return ret;
+    }
+
+    inline static int ADDON_TrackCount(const AddonInstance_AudioDecoder* instance, const char* file)
+    {
+      return instance->toAddon.addonInstance->TrackCount(file);
+    }
+
+    std::vector<AEChannel> m_channelList;
+    AddonInstance_AudioDecoder* m_instanceData;
+  };
+
+} /* namespace addon */
+} /* namespace kodi */
diff --git a/xbmc/addons/kodi-addon-dev-kit/include/kodi/addon-instance/AudioEncoder.h b/xbmc/addons/kodi-addon-dev-kit/include/kodi/addon-instance/AudioEncoder.h
new file mode 100644
index 0000000..3d59a99
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/include/kodi/addon-instance/AudioEncoder.h
@@ -0,0 +1,223 @@
+#pragma once
+/*
+ *      Copyright (C) 2005-2017 Team Kodi
+ *      http://kodi.tv
+ *
+ *  This Program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This Program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Kodi; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "../AddonBase.h"
+
+namespace kodi { namespace addon { class CInstanceAudioEncoder; }}
+
+extern "C"
+{
+
+  typedef struct AddonProps_AudioEncoder
+  {
+    int dummy;
+  } AddonProps_AudioEncoder;
+
+  typedef struct AddonToKodiFuncTable_AudioEncoder
+  {
+    void* kodiInstance;
+    int (*write) (void* kodiInstance, const uint8_t* data, int len);
+    int64_t (*seek)(void* kodiInstance, int64_t pos, int whence);
+  } AddonToKodiFuncTable_AudioEncoder;
+
+  struct AddonInstance_AudioEncoder;
+  typedef struct KodiToAddonFuncTable_AudioEncoder
+  {
+    kodi::addon::CInstanceAudioEncoder* addonInstance;
+    bool (__cdecl* start) (const AddonInstance_AudioEncoder* instance, int in_channels, int in_rate, int in_bits,
+                           const char* title, const char* artist,
+                           const char* albumartist, const char* album,
+                           const char* year, const char* track,
+                           const char* genre, const char* comment,
+                           int track_length);
+    int  (__cdecl* encode) (const AddonInstance_AudioEncoder* instance, int num_bytes_read, const uint8_t* pbt_stream);
+    bool (__cdecl* finish) (const AddonInstance_AudioEncoder* instance);
+  } KodiToAddonFuncTable_AudioEncoder;
+
+  typedef struct AddonInstance_AudioEncoder
+  {
+    AddonProps_AudioEncoder props;
+    AddonToKodiFuncTable_AudioEncoder toKodi;
+    KodiToAddonFuncTable_AudioEncoder toAddon;
+  } AddonInstance_AudioEncoder;
+
+} /* extern "C" */
+
+namespace kodi
+{
+namespace addon
+{
+
+  class CInstanceAudioEncoder : public IAddonInstance
+  {
+  public:
+    //==========================================================================
+    /// @brief Class constructor
+    ///
+    /// @param[in] instance             The from Kodi given instance given be
+    ///                                 add-on CreateInstance call with instance
+    ///                                 id ADDON_INSTANCE_AUDIOENCODER.
+    CInstanceAudioEncoder(KODI_HANDLE instance)
+      : IAddonInstance(ADDON_INSTANCE_AUDIOENCODER)
+    {
+      if (CAddonBase::m_interface->globalSingleInstance != nullptr)
+        throw std::logic_error("kodi::addon::CInstanceAudioEncoder: Creation of multiple together with single instance way is not allowed!");
+
+      SetAddonStruct(instance);
+    }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    /// \brief Start encoder (**required**)
+    ///
+    /// \param[in] inChannels           Number of channels
+    /// \param[in] inRate               Sample rate of input data
+    /// \param[in] inBits               Bits per sample in input data
+    /// \param[in] title                The title of the song
+    /// \param[in] artist               The artist of the song
+    /// \param[in] albumartist          The albumartist of the song
+    /// \param[in] year                 The year of the song
+    /// \param[in] track                The track number of the song
+    /// \param[in] genre                The genre of the song
+    /// \param[in] comment              A comment to attach to the song
+    /// \param[in] trackLength          Total track length in seconds
+    /// \return                         True on success, false on failure.
+    ///
+    virtual bool Start(int inChannels,
+                       int inRate,
+                       int inBits,
+                       const std::string& title,
+                       const std::string& artist,
+                       const std::string& albumartist,
+                       const std::string& album,
+                       const std::string& year,
+                       const std::string& track,
+                       const std::string& genre,
+                       const std::string& comment,
+                       int trackLength) = 0;
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    /// \brief Encode a chunk of audio (**required**)
+    ///
+    /// \param[in] numBytesRead         Number of bytes in input buffer
+    /// \param[in] pbtStream            the input buffer
+    /// \return                         Number of bytes consumed
+    ///
+    virtual int Encode(int numBytesRead, const uint8_t* pbtStream) = 0;
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    /// \brief Finalize encoding (**optional**)
+    ///
+    /// \return                         True on success, false on failure.
+    ///
+    virtual bool Finish() { return true; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    /// \brief Write block of data
+    ///
+    /// \param[in] data                 Pointer to the array of elements to be 
+    ///                                 written
+    /// \param[in] length               Size in bytes to be written.
+    /// \return                         The total number of bytes 
+    ///                                 successfully written is returned.
+    int Write(const uint8_t* data, int length)
+    {
+      return m_instanceData->toKodi.write(m_instanceData->toKodi.kodiInstance, data, length);
+    }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    /// \brief Set the file's current position.
+    ///
+    /// The whence argument is optional and defaults to SEEK_SET (0)
+    ///
+    /// \param[in] position             the position that you want to seek to
+    /// \param[in] whence               [optional] offset relative to
+    ///                                 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.
+    int64_t Seek(int64_t position, int whence = SEEK_SET)
+    {
+      return m_instanceData->toKodi.seek(m_instanceData->toKodi.kodiInstance, position, whence);
+    }
+    //--------------------------------------------------------------------------
+
+  private:
+    void SetAddonStruct(KODI_HANDLE instance)
+    {
+      if (instance == nullptr)
+        throw std::logic_error("kodi::addon::CInstanceAudioEncoder: Creation with empty addon structure not allowed, table must be given from Kodi!");
+
+      m_instanceData = static_cast<AddonInstance_AudioEncoder*>(instance);
+      m_instanceData->toAddon.addonInstance = this;
+      m_instanceData->toAddon.start = ADDON_Start;
+      m_instanceData->toAddon.encode = ADDON_Encode;
+      m_instanceData->toAddon.finish = ADDON_Finish;
+    }
+
+    inline static bool ADDON_Start(const AddonInstance_AudioEncoder* instance, int inChannels, int inRate, int inBits,
+                                   const char* title, const char* artist,
+                                   const char* albumartist, const char* album,
+                                   const char* year, const char* track,
+                                   const char* genre, const char* comment,
+                                   int trackLength)
+    {
+      return instance->toAddon.addonInstance->Start(inChannels,
+                                                    inRate,
+                                                    inBits,
+                                                    title,
+                                                    artist,
+                                                    albumartist,
+                                                    album,
+                                                    year,
+                                                    track,
+                                                    genre,
+                                                    comment,
+                                                    trackLength);
+    }
+
+    inline static int ADDON_Encode(const AddonInstance_AudioEncoder* instance, int numBytesRead, const uint8_t* pbtStream)
+    {
+      return instance->toAddon.addonInstance->Encode(numBytesRead, pbtStream);
+    }
+
+    inline static bool ADDON_Finish(const AddonInstance_AudioEncoder* instance)
+    {
+      return instance->toAddon.addonInstance->Finish();
+    }
+
+    AddonInstance_AudioEncoder* m_instanceData;
+  };
+
+} /* namespace addon */
+} /* namespace kodi */
diff --git a/xbmc/addons/kodi-addon-dev-kit/include/kodi/addon-instance/ImageDecoder.h b/xbmc/addons/kodi-addon-dev-kit/include/kodi/addon-instance/ImageDecoder.h
new file mode 100644
index 0000000..a854711
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/include/kodi/addon-instance/ImageDecoder.h
@@ -0,0 +1,163 @@
+#pragma once
+/*
+ *      Copyright (C) 2005-2017 Team Kodi
+ *      http://kodi.tv
+ *
+ *  This Program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This Program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Kodi; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "../AddonBase.h"
+
+namespace kodi { namespace addon { class CInstanceImageDecoder; }}
+
+extern "C"
+{
+
+  typedef struct AddonProps_ImageDecoder
+  {
+    const char* mimetype;
+  } AddonProps_ImageDecoder;
+
+  typedef struct AddonToKodiFuncTable_ImageDecoder
+  {
+    KODI_HANDLE kodi_instance;
+  } AddonToKodiFuncTable_ImageDecoder;
+
+  struct AddonInstance_ImageDecoder;
+  typedef struct KodiToAddonFuncTable_ImageDecoder
+  {
+    kodi::addon::CInstanceImageDecoder* addonInstance;
+    bool (__cdecl* load_image_from_memory) (const AddonInstance_ImageDecoder* instance,
+                                            unsigned char* buffer, unsigned int buf_size,
+                                            unsigned int* width, unsigned int* height);
+
+    bool (__cdecl* decode) (const AddonInstance_ImageDecoder* instance,
+                            unsigned char* pixels,
+                            unsigned int width, unsigned int height,
+                            unsigned int pitch, unsigned int format);
+  } KodiToAddonFuncTable_ImageDecoder;
+
+  typedef struct AddonInstance_ImageDecoder
+  {
+    AddonProps_ImageDecoder props;
+    AddonToKodiFuncTable_ImageDecoder toKodi;
+    KodiToAddonFuncTable_ImageDecoder toAddon;
+  } AddonInstance_ImageDecoder;
+
+} /* extern "C" */
+
+typedef enum ImageFormat : unsigned int
+{
+  ADDON_IMG_FMT_A8R8G8B8 = 1,
+  ADDON_IMG_FMT_A8 = 2,
+  ADDON_IMG_FMT_RGBA8 = 3,
+  ADDON_IMG_FMT_RGB8 = 4
+} ImageFormat;
+
+namespace kodi
+{
+namespace addon
+{
+
+  class CInstanceImageDecoder : public IAddonInstance
+  {
+  public:
+    //==========================================================================
+    /// @brief Class constructor
+    ///
+    /// @param[in] instance             The from Kodi given instance given be
+    ///                                 add-on CreateInstance call with instance
+    ///                                 id ADDON_INSTANCE_IMAGEDECODER.
+    CInstanceImageDecoder(KODI_HANDLE instance)
+      : IAddonInstance(ADDON_INSTANCE_IMAGEDECODER)
+    {
+      if (CAddonBase::m_interface->globalSingleInstance != nullptr)
+        throw std::logic_error("kodi::addon::CInstanceImageDecoder: Creation of multiple together with single instance way is not allowed!");
+
+      SetAddonStruct(instance);
+    }
+    //--------------------------------------------------------------------------
+
+    ~CInstanceImageDecoder() override = default;
+
+    //==========================================================================
+    /// @brief Initialize an encoder
+    ///
+    /// @param[in] buffer The data to read from memory
+    /// @param[in] bufSize The buffer size
+    /// @param[in,out] width The optimal width of image on entry, obtained width on return
+    /// @param[in,out] height The optimal height of image, actual obtained height on return
+    /// @return true if successful done, false on error
+    ///
+    virtual bool LoadImageFromMemory(unsigned char* buffer, unsigned int bufSize,
+                                     unsigned int& width, unsigned int& height) = 0;
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    /// @brief Decode previously loaded image
+    ///
+    /// @param[in] pixels Output buffer
+    /// @param[in] width Width of output image
+    /// @param[in] height Height of output image
+    /// @param[in] pitch Pitch of output image
+    /// @param[in] format Format of output image
+    /// @return true if successful done, false on error
+    ///
+    virtual bool Decode(unsigned char* pixels,
+                        unsigned int width, unsigned int height,
+                        unsigned int pitch, ImageFormat format) = 0;
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    /// @brief Get the wanted mime type from Kodi
+    ///
+    /// @return the mimetype wanted from Kodi
+    ///
+    inline std::string MimeType() { return m_instanceData->props.mimetype; }
+    //--------------------------------------------------------------------------
+
+  private:
+    void SetAddonStruct(KODI_HANDLE instance)
+    {
+      if (instance == nullptr)
+        throw std::logic_error("kodi::addon::CInstanceImageDecoder: Creation with empty addon structure not allowed, table must be given from Kodi!");
+
+      m_instanceData = static_cast<AddonInstance_ImageDecoder*>(instance);
+      m_instanceData->toAddon.addonInstance = this;
+      m_instanceData->toAddon.load_image_from_memory = ADDON_LoadImageFromMemory;
+      m_instanceData->toAddon.decode = ADDON_Decode;
+    }
+
+    inline static bool ADDON_LoadImageFromMemory(const AddonInstance_ImageDecoder* instance,
+                                                 unsigned char* buffer, unsigned int bufSize,
+                                                 unsigned int* width, unsigned int* height)
+    {
+      return instance->toAddon.addonInstance->LoadImageFromMemory(buffer, bufSize, *width, *height);
+    }
+
+    inline static bool ADDON_Decode(const AddonInstance_ImageDecoder* instance,
+                                    unsigned char* pixels,
+                                    unsigned int width, unsigned int height,
+                                    unsigned int pitch, unsigned int format)
+    {
+      return instance->toAddon.addonInstance->Decode(pixels, width, height, pitch, static_cast<ImageFormat>(format));
+    }
+
+    AddonInstance_ImageDecoder* m_instanceData;
+  };
+
+} /* namespace addon */
+} /* namespace kodi */
diff --git a/xbmc/addons/kodi-addon-dev-kit/include/kodi/addon-instance/Inputstream.h b/xbmc/addons/kodi-addon-dev-kit/include/kodi/addon-instance/Inputstream.h
new file mode 100644
index 0000000..76cfe92
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/include/kodi/addon-instance/Inputstream.h
@@ -0,0 +1,621 @@
+#pragma once
+/*
+ *      Copyright (C) 2005-2017 Team Kodi
+ *      http://kodi.tv
+ *
+ *  This Program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This Program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Kodi; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+/*
+ * 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 "../StreamCrypto.h"
+#include "../StreamCodec.h"
+
+#ifdef BUILD_KODI_ADDON
+#include "../DVDDemuxPacket.h"
+#else
+#include "cores/VideoPlayer/DVDDemuxers/DVDDemuxPacket.h"
+#endif
+
+namespace kodi { namespace addon { class CInstanceInputStream; }}
+
+extern "C" {
+
+  /*!
+   * @brief InputStream add-on capabilities. All capabilities are set to "false" as default.
+   */
+  typedef struct INPUTSTREAM_CAPABILITIES
+  {
+    enum MASKTYPE: uint32_t
+    {
+      /// supports interface IDemux
+      SUPPORTS_IDEMUX = (1 << 0),
+
+      /// supports interface IPosTime
+      SUPPORTS_IPOSTIME = (1 << 1),
+
+      /// supports interface IDisplayTime
+      SUPPORTS_IDISPLAYTIME = (1 << 2),
+
+      /// supports seek
+      SUPPORTS_SEEK = (1 << 3),
+
+      /// supports pause
+      SUPPORTS_PAUSE = (1 << 4)
+    };
+
+    /// set of supported capabilities
+    uint32_t m_mask;
+  } INPUTSTREAM_CAPABILITIES;
+
+  /*!
+   * @brief structure of key/value pairs passed to addon on Open()
+   */
+  typedef struct INPUTSTREAM
+  {
+    static const unsigned int MAX_INFO_COUNT = 8;
+
+    const char *m_strURL;
+
+    unsigned int m_nCountInfoValues;
+    struct LISTITEMPROPERTY
+    {
+      const char *m_strKey;
+      const char *m_strValue;
+    } m_ListItemProperties[MAX_INFO_COUNT];
+
+    const char *m_libFolder;
+    const char *m_profileFolder;
+  } INPUTSTREAM;
+
+  /*!
+   * @brief Array of stream IDs
+   */
+  typedef struct INPUTSTREAM_IDS
+  {
+    static const unsigned int MAX_STREAM_COUNT = 32;
+    unsigned int m_streamCount;
+    unsigned int m_streamIds[MAX_STREAM_COUNT];
+  } INPUTSTREAM_IDS;
+
+  /*!
+   * @brief stream properties
+   */
+  typedef struct INPUTSTREAM_INFO
+  {
+    enum STREAM_TYPE
+    {
+      TYPE_NONE,
+      TYPE_VIDEO,
+      TYPE_AUDIO,
+      TYPE_SUBTITLE,
+      TYPE_TELETEXT
+    } m_streamType;
+
+    enum Codec_FEATURES
+    {
+      FEATURE_DECODE = 1
+    };
+    unsigned int m_features;
+
+    char m_codecName[32];                /*!< @brief (required) name of codec according to ffmpeg */
+    char m_codecInternalName[32];        /*!< @brief (optional) internal name of codec (selectionstream info) */
+    STREAMCODEC_PROFILE m_codecProfile;  /*!< @brief (optional) the profile of the codec */
+    unsigned int m_pID;                  /*!< @brief (required) physical index */
+
+    const uint8_t *m_ExtraData;
+    unsigned int m_ExtraSize;
+
+    char m_language[4];                  /*!< @brief ISO 639 3-letter language code (empty string if undefined) */
+
+    unsigned int m_FpsScale;             /*!< @brief Scale of 1000 and a rate of 29970 will result in 29.97 fps */
+    unsigned int m_FpsRate;
+    unsigned int m_Height;               /*!< @brief height of the stream reported by the demuxer */
+    unsigned int m_Width;                /*!< @brief width of the stream reported by the demuxer */
+    float m_Aspect;                      /*!< @brief display aspect of stream */
+
+    unsigned int m_Channels;             /*!< @brief (required) amount of channels */
+    unsigned int m_SampleRate;           /*!< @brief (required) sample rate */
+    unsigned int m_BitRate;              /*!< @brief (required) bit rate */
+    unsigned int m_BitsPerSample;        /*!< @brief (required) bits per sample */
+    unsigned int m_BlockAlign;
+
+    CRYPTO_INFO m_cryptoInfo;
+  } INPUTSTREAM_INFO;
+
+  /*!
+   * @brief Structure to transfer the methods from xbmc_inputstream_dll.h to XBMC
+   */
+
+  // this are properties given to the addon on create
+  // at this time we have no parameters for the addon
+  typedef struct AddonProps_InputStream /* internal */
+  {
+    int dummy;
+  } AddonProps_InputStream;
+
+  typedef struct AddonToKodiFuncTable_InputStream /* internal */
+  {
+    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;
+
+  struct AddonInstance_InputStream;
+  typedef struct KodiToAddonFuncTable_InputStream /* internal */
+  {
+    kodi::addon::CInstanceInputStream* addonInstance;
+
+    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);
+
+    // 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);
+    void(__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);
+
+    // IDisplayTime
+    int (__cdecl* get_total_time)(const AddonInstance_InputStream* instance);
+    int (__cdecl* get_time)(const AddonInstance_InputStream* instance);
+
+    // IPosTime
+    bool (__cdecl* pos_time)(const AddonInstance_InputStream* instance, int ms);
+
+    // Seekable (mandatory)
+    bool (__cdecl* can_pause_stream)(const AddonInstance_InputStream* instance);
+    bool (__cdecl* can_seek_stream)(const AddonInstance_InputStream* instance);
+
+    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);
+    void (__cdecl* pause_stream)(const AddonInstance_InputStream* instance, double time);
+    bool (__cdecl* is_real_time_stream)(const AddonInstance_InputStream* instance);
+  } KodiToAddonFuncTable_InputStream;
+
+  typedef struct AddonInstance_InputStream /* internal */
+  {
+    AddonProps_InputStream props;
+    AddonToKodiFuncTable_InputStream toKodi;
+    KodiToAddonFuncTable_InputStream toAddon;
+  } AddonInstance_InputStream;
+
+} /* extern "C" */
+
+namespace kodi
+{
+namespace addon
+{
+
+  class CInstanceInputStream : public IAddonInstance
+  {
+  public:
+    CInstanceInputStream(KODI_HANDLE instance)
+      : IAddonInstance(ADDON_INSTANCE_INPUTSTREAM)
+    {
+      if (CAddonBase::m_interface->globalSingleInstance != nullptr)
+        throw std::logic_error("kodi::addon::CInstanceInputStream: Creation of multiple together with single instance way is not allowed!");
+
+      SetAddonStruct(instance);
+    }
+
+    ~CInstanceInputStream() override = default;
+
+    /*!
+     * Open a stream.
+     * @param props
+     * @return True if the stream has been opened successfully, false otherwise.
+     * @remarks
+     */
+    virtual bool Open(INPUTSTREAM& props) = 0;
+
+    /*!
+     * Close an open stream.
+     * @remarks
+     */
+    virtual void Close() = 0;
+
+    /*!
+     * Get Capabilities of this addon.
+     * @param capabilities The add-on's capabilities.
+     * @remarks
+     */
+    virtual void GetCapabilities(INPUTSTREAM_CAPABILITIES& capabilities) = 0;
+
+    /*!
+     * Get IDs of available streams
+     * @remarks
+     */
+    virtual INPUTSTREAM_IDS GetStreamIds() = 0;
+
+    /*!
+     * 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;
+
+    /*!
+     * 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;
+
+    /*!
+    * Opens a stream for playback.
+    * @param streamid unique id of stream
+    * @remarks
+    */
+    virtual void OpenStream(int streamid) = 0;
+
+    /*!
+     * Reset the demultiplexer in the add-on.
+     * @remarks Required if bHandlesDemuxing is set to true.
+     */
+    virtual void DemuxReset() { }
+
+    /*!
+     * Abort the demultiplexer thread in the add-on.
+     * @remarks Required if bHandlesDemuxing is set to true.
+     */
+    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.
+     */
+    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 occured.
+     * @remarks Return NULL if this add-on won't provide this function.
+     */
+    virtual DemuxPacket* 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.
+     */
+    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.
+     */
+    virtual void DemuxSetSpeed(int speed) { }
+
+    /*!
+     * Sets desired width / height
+     * @param width / hight
+     */
+    virtual void SetVideoResolution(int width, int height) { }
+
+    /*!
+     * Totel time in ms
+     * @remarks
+     */
+    virtual int GetTotalTime() { return -1; }
+
+    /*!
+     * Playing time in ms
+     * @remarks
+     */
+    virtual int GetTime() { return -1; }
+
+    /*!
+     * Positions inputstream to playing time given in ms
+     * @remarks
+     */
+    virtual bool PosTime(int ms) { return false; }
+
+
+    /*!
+     * Check if the backend support pausing the currently playing stream
+     * This will enable/disable the pause button in Kodi based on the return value
+     * @return false if the InputStream addon/backend does not support pausing, true if possible
+     */
+    virtual bool CanPauseStream() { return false; }
+
+    /*!
+     * Check if the backend supports seeking for the currently playing stream
+     * This will enable/disable the rewind/forward buttons in Kodi based on the return value
+     * @return false if the InputStream addon/backend does not support seeking, true if possible
+     */
+    virtual bool CanSeekStream() { return false; }
+
+    /*!
+     * 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; }
+
+    /*!
+     * 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; }
+
+    /*!
+     * @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 Notify the InputStream addon that Kodi (un)paused the currently playing stream
+     */
+    virtual void PauseStream(double time) { }
+
+
+    /*!
+     *  Check for real-time streaming
+     *  @return true if current stream is real-time
+     */
+    virtual bool IsRealTimeStream() { return true; }
+
+    /*!
+     * @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 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 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);
+    }
+
+  private:
+    void SetAddonStruct(KODI_HANDLE instance)
+    {
+      if (instance == nullptr)
+        throw std::logic_error("kodi::addon::CInstanceInputStream: Creation with empty addon structure not allowed, table must be given from Kodi!");
+
+      m_instanceData = static_cast<AddonInstance_InputStream*>(instance);
+      m_instanceData->toAddon.addonInstance = this;
+      m_instanceData->toAddon.open = ADDON_Open;
+      m_instanceData->toAddon.close = ADDON_Close;
+      m_instanceData->toAddon.get_capabilities = ADDON_GetCapabilities;
+
+      m_instanceData->toAddon.get_stream_ids = ADDON_GetStreamIds;
+      m_instanceData->toAddon.get_stream = ADDON_GetStream;
+      m_instanceData->toAddon.enable_stream = ADDON_EnableStream;
+      m_instanceData->toAddon.open_stream = ADDON_OpenStream;
+      m_instanceData->toAddon.demux_reset = ADDON_DemuxReset;
+      m_instanceData->toAddon.demux_abort = ADDON_DemuxAbort;
+      m_instanceData->toAddon.demux_flush = ADDON_DemuxFlush;
+      m_instanceData->toAddon.demux_read = ADDON_DemuxRead;
+      m_instanceData->toAddon.demux_seek_time = ADDON_DemuxSeekTime;
+      m_instanceData->toAddon.demux_set_speed = ADDON_DemuxSetSpeed;
+      m_instanceData->toAddon.set_video_resolution = ADDON_SetVideoResolution;
+
+      m_instanceData->toAddon.get_total_time = ADDON_GetTotalTime;
+      m_instanceData->toAddon.get_time = ADDON_GetTime;
+
+      m_instanceData->toAddon.pos_time = ADDON_PosTime;
+
+      m_instanceData->toAddon.can_pause_stream = ADDON_CanPauseStream;
+      m_instanceData->toAddon.can_seek_stream = ADDON_CanSeekStream;
+
+      m_instanceData->toAddon.read_stream = ADDON_ReadStream;
+      m_instanceData->toAddon.seek_stream = ADDON_SeekStream;
+      m_instanceData->toAddon.position_stream = ADDON_PositionStream;
+      m_instanceData->toAddon.length_stream = ADDON_LengthStream;
+      m_instanceData->toAddon.pause_stream = ADDON_PauseStream;
+      m_instanceData->toAddon.is_real_time_stream = ADDON_IsRealTimeStream;
+    }
+
+    inline static bool ADDON_Open(const AddonInstance_InputStream* instance, INPUTSTREAM* props)
+    {
+      return instance->toAddon.addonInstance->Open(*props);
+    }
+
+    inline static void ADDON_Close(const AddonInstance_InputStream* instance)
+    {
+      instance->toAddon.addonInstance->Close();
+    }
+
+    inline static void ADDON_GetCapabilities(const AddonInstance_InputStream* instance, INPUTSTREAM_CAPABILITIES* capabilities)
+    {
+      instance->toAddon.addonInstance->GetCapabilities(*capabilities);
+    }
+
+
+    // IDemux
+    inline static struct INPUTSTREAM_IDS ADDON_GetStreamIds(const AddonInstance_InputStream* instance)
+    {
+      return instance->toAddon.addonInstance->GetStreamIds();
+    }
+
+    inline static struct INPUTSTREAM_INFO ADDON_GetStream(const AddonInstance_InputStream* instance, int streamid)
+    {
+      return instance->toAddon.addonInstance->GetStream(streamid);
+    }
+
+    inline static void ADDON_EnableStream(const AddonInstance_InputStream* instance, int streamid, bool enable)
+    {
+      instance->toAddon.addonInstance->EnableStream(streamid, enable);
+    }
+
+    inline static void ADDON_OpenStream(const AddonInstance_InputStream* instance, int streamid)
+    {
+      instance->toAddon.addonInstance->OpenStream(streamid);
+    }
+
+    inline static void ADDON_DemuxReset(const AddonInstance_InputStream* instance)
+    {
+      instance->toAddon.addonInstance->DemuxReset();
+    }
+
+    inline static void ADDON_DemuxAbort(const AddonInstance_InputStream* instance)
+    {
+      instance->toAddon.addonInstance->DemuxAbort();
+    }
+
+    inline static void ADDON_DemuxFlush(const AddonInstance_InputStream* instance)
+    {
+      instance->toAddon.addonInstance->DemuxFlush();
+    }
+
+    inline static DemuxPacket* ADDON_DemuxRead(const AddonInstance_InputStream* instance)
+    {
+      return instance->toAddon.addonInstance->DemuxRead();
+    }
+
+    inline static bool ADDON_DemuxSeekTime(const AddonInstance_InputStream* instance, double time, bool backwards, double *startpts)
+    {
+      return instance->toAddon.addonInstance->DemuxSeekTime(time, backwards, *startpts);
+    }
+
+    inline static void ADDON_DemuxSetSpeed(const AddonInstance_InputStream* instance, int speed)
+    {
+      instance->toAddon.addonInstance->DemuxSetSpeed(speed);
+    }
+
+    inline static void ADDON_SetVideoResolution(const AddonInstance_InputStream* instance, int width, int height)
+    {
+      instance->toAddon.addonInstance->SetVideoResolution(width, height);
+    }
+
+
+    // IDisplayTime
+    inline static int ADDON_GetTotalTime(const AddonInstance_InputStream* instance)
+    {
+      return instance->toAddon.addonInstance->GetTotalTime();
+    }
+
+    inline static int ADDON_GetTime(const AddonInstance_InputStream* instance)
+    {
+      return instance->toAddon.addonInstance->GetTime();
+    }
+
+
+    // IPosTime
+    inline static bool ADDON_PosTime(const AddonInstance_InputStream* instance, int ms)
+    {
+      return instance->toAddon.addonInstance->PosTime(ms);
+    }
+
+    // Seekable (mandatory)
+    inline static bool ADDON_CanPauseStream(const AddonInstance_InputStream* instance)
+    {
+      return instance->toAddon.addonInstance->CanPauseStream();
+    }
+
+    inline static bool ADDON_CanSeekStream(const AddonInstance_InputStream* instance)
+    {
+      return instance->toAddon.addonInstance->CanSeekStream();
+    }
+
+
+    inline static int ADDON_ReadStream(const AddonInstance_InputStream* instance, uint8_t* buffer, unsigned int bufferSize)
+    {
+      return instance->toAddon.addonInstance->ReadStream(buffer, bufferSize);
+    }
+
+    inline static int64_t ADDON_SeekStream(const AddonInstance_InputStream* instance, int64_t position, int whence)
+    {
+      return instance->toAddon.addonInstance->SeekStream(position, whence);
+    }
+
+    inline static int64_t ADDON_PositionStream(const AddonInstance_InputStream* instance)
+    {
+      return instance->toAddon.addonInstance->PositionStream();
+    }
+
+    inline static int64_t ADDON_LengthStream(const AddonInstance_InputStream* instance)
+    {
+      return instance->toAddon.addonInstance->LengthStream();
+    }
+
+    inline static void ADDON_PauseStream(const AddonInstance_InputStream* instance, double time)
+    {
+      instance->toAddon.addonInstance->PauseStream(time);
+    }
+
+    inline static bool ADDON_IsRealTimeStream(const AddonInstance_InputStream* instance)
+    {
+      return instance->toAddon.addonInstance->IsRealTimeStream();
+    }
+
+    AddonInstance_InputStream* m_instanceData;
+  };
+
+} /* namespace addon */
+} /* namespace kodi */
diff --git a/xbmc/addons/kodi-addon-dev-kit/include/kodi/addon-instance/Peripheral.h b/xbmc/addons/kodi-addon-dev-kit/include/kodi/addon-instance/Peripheral.h
new file mode 100644
index 0000000..631b9b4
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/include/kodi/addon-instance/Peripheral.h
@@ -0,0 +1,682 @@
+#pragma once
+/*
+ *      Copyright (C) 2014-2017 Team Kodi
+ *      http://kodi.tv
+ *
+ *  This Program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This Program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this Program; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "../AddonBase.h"
+
+namespace kodi { namespace addon { class CInstancePeripheral; }}
+
+/* indicates a joystick has no preference for port number */
+#define NO_PORT_REQUESTED     (-1)
+
+/* joystick's driver button/hat/axis index is unknown */
+#define DRIVER_INDEX_UNKNOWN  (-1)
+
+extern "C"
+{
+
+  /// @name Peripheral types
+  ///{
+  typedef enum PERIPHERAL_ERROR
+  {
+    PERIPHERAL_NO_ERROR                      =  0, // no error occurred
+    PERIPHERAL_ERROR_UNKNOWN                 = -1, // an unknown error occurred
+    PERIPHERAL_ERROR_FAILED                  = -2, // the command failed
+    PERIPHERAL_ERROR_INVALID_PARAMETERS      = -3, // the parameters of the method are invalid for this operation
+    PERIPHERAL_ERROR_NOT_IMPLEMENTED         = -4, // the method that the frontend called is not implemented
+    PERIPHERAL_ERROR_NOT_CONNECTED           = -5, // no peripherals are connected
+    PERIPHERAL_ERROR_CONNECTION_FAILED       = -6, // peripherals are connected, but command was interrupted
+  } PERIPHERAL_ERROR;
+
+  typedef enum PERIPHERAL_TYPE
+  {
+    PERIPHERAL_TYPE_UNKNOWN,
+    PERIPHERAL_TYPE_JOYSTICK,
+    PERIPHERAL_TYPE_KEYBOARD,
+  } PERIPHERAL_TYPE;
+
+  typedef struct PERIPHERAL_INFO
+  {
+    PERIPHERAL_TYPE type;           /*!< @brief type of peripheral */
+    char*           name;           /*!< @brief name of peripheral */
+    uint16_t        vendor_id;      /*!< @brief vendor ID of peripheral, 0x0000 if unknown */
+    uint16_t        product_id;     /*!< @brief product ID of peripheral, 0x0000 if unknown */
+    unsigned int    index;          /*!< @brief the order in which the add-on identified this peripheral */
+  } ATTRIBUTE_PACKED PERIPHERAL_INFO;
+
+  /*!
+   * @brief Peripheral add-on capabilities.
+   * If a capability is set to true, then the corresponding methods from
+   * kodi_peripheral_dll.h need to be implemented.
+   */
+  typedef struct PERIPHERAL_CAPABILITIES
+  {
+    bool provides_joysticks;            /*!< @brief true if the add-on provides joysticks */
+    bool provides_joystick_rumble;
+    bool provides_joystick_power_off;
+    bool provides_buttonmaps;           /*!< @brief true if the add-on provides button maps */
+  } ATTRIBUTE_PACKED PERIPHERAL_CAPABILITIES;
+  ///}
+
+  /// @name Event types
+  ///{
+  typedef enum PERIPHERAL_EVENT_TYPE
+  {
+    PERIPHERAL_EVENT_TYPE_NONE,           /*!< @brief unknown event */
+    PERIPHERAL_EVENT_TYPE_DRIVER_BUTTON,  /*!< @brief state changed for joystick driver button */
+    PERIPHERAL_EVENT_TYPE_DRIVER_HAT,     /*!< @brief state changed for joystick driver hat */
+    PERIPHERAL_EVENT_TYPE_DRIVER_AXIS,    /*!< @brief state changed for joystick driver axis */
+    PERIPHERAL_EVENT_TYPE_SET_MOTOR,      /*!< @brief set the state for joystick rumble motor */
+  } PERIPHERAL_EVENT_TYPE;
+
+  typedef enum JOYSTICK_STATE_BUTTON
+  {
+    JOYSTICK_STATE_BUTTON_UNPRESSED = 0x0,    /*!< @brief button is released */
+    JOYSTICK_STATE_BUTTON_PRESSED   = 0x1,    /*!< @brief button is pressed */
+  } JOYSTICK_STATE_BUTTON;
+
+  typedef enum JOYSTICK_STATE_HAT
+  {
+    JOYSTICK_STATE_HAT_UNPRESSED  = 0x0,    /*!< @brief no directions are pressed */
+    JOYSTICK_STATE_HAT_LEFT       = 0x1,    /*!< @brief only left is pressed */
+    JOYSTICK_STATE_HAT_RIGHT      = 0x2,    /*!< @brief only right is pressed */
+    JOYSTICK_STATE_HAT_UP         = 0x4,    /*!< @brief only up is pressed */
+    JOYSTICK_STATE_HAT_DOWN       = 0x8,    /*!< @brief only down is pressed */
+    JOYSTICK_STATE_HAT_LEFT_UP    = JOYSTICK_STATE_HAT_LEFT  | JOYSTICK_STATE_HAT_UP,
+    JOYSTICK_STATE_HAT_LEFT_DOWN  = JOYSTICK_STATE_HAT_LEFT  | JOYSTICK_STATE_HAT_DOWN,
+    JOYSTICK_STATE_HAT_RIGHT_UP   = JOYSTICK_STATE_HAT_RIGHT | JOYSTICK_STATE_HAT_UP,
+    JOYSTICK_STATE_HAT_RIGHT_DOWN = JOYSTICK_STATE_HAT_RIGHT | JOYSTICK_STATE_HAT_DOWN,
+  } JOYSTICK_STATE_HAT;
+
+  /*!
+   * @brief value in the closed interval [-1.0, 1.0]
+   *
+   * The axis state uses the XInput coordinate system:
+   *   - Negative values signify down or to the left
+   *   - Positive values signify up or to the right
+   */
+  typedef float JOYSTICK_STATE_AXIS;
+
+  typedef float JOYSTICK_STATE_MOTOR;
+
+  typedef struct PERIPHERAL_EVENT
+  {
+    unsigned int             peripheral_index;
+    PERIPHERAL_EVENT_TYPE    type;
+    unsigned int             driver_index;
+    JOYSTICK_STATE_BUTTON    driver_button_state;
+    JOYSTICK_STATE_HAT       driver_hat_state;
+    JOYSTICK_STATE_AXIS      driver_axis_state;
+    JOYSTICK_STATE_MOTOR     motor_state;
+  } ATTRIBUTE_PACKED PERIPHERAL_EVENT;
+  ///}
+
+  /// @name Joystick types
+  ///{
+  typedef struct JOYSTICK_INFO
+  {
+    PERIPHERAL_INFO peripheral;         /*!< @brief peripheral info for this joystick */
+    char*           provider;           /*!< @brief name of the driver or interface providing the joystick */
+    int             requested_port;     /*!< @brief requested port number (such as for 360 controllers), or NO_PORT_REQUESTED */
+    unsigned int    button_count;       /*!< @brief number of buttons reported by the driver */
+    unsigned int    hat_count;          /*!< @brief number of hats reported by the driver */
+    unsigned int    axis_count;         /*!< @brief number of axes reported by the driver */
+    unsigned int    motor_count;        /*!< @brief number of motors reported by the driver */
+    bool            supports_poweroff;  /*!< @brief whether the joystick supports being powered off */
+  } ATTRIBUTE_PACKED JOYSTICK_INFO;
+
+  typedef enum JOYSTICK_DRIVER_PRIMITIVE_TYPE
+  {
+    JOYSTICK_DRIVER_PRIMITIVE_TYPE_UNKNOWN,
+    JOYSTICK_DRIVER_PRIMITIVE_TYPE_BUTTON,
+    JOYSTICK_DRIVER_PRIMITIVE_TYPE_HAT_DIRECTION,
+    JOYSTICK_DRIVER_PRIMITIVE_TYPE_SEMIAXIS,
+    JOYSTICK_DRIVER_PRIMITIVE_TYPE_MOTOR,
+  } JOYSTICK_DRIVER_PRIMITIVE_TYPE;
+
+  typedef struct JOYSTICK_DRIVER_BUTTON
+  {
+    int              index;
+  } ATTRIBUTE_PACKED JOYSTICK_DRIVER_BUTTON;
+
+  typedef enum JOYSTICK_DRIVER_HAT_DIRECTION
+  {
+    JOYSTICK_DRIVER_HAT_UNKNOWN,
+    JOYSTICK_DRIVER_HAT_LEFT,
+    JOYSTICK_DRIVER_HAT_RIGHT,
+    JOYSTICK_DRIVER_HAT_UP,
+    JOYSTICK_DRIVER_HAT_DOWN,
+  } JOYSTICK_DRIVER_HAT_DIRECTION;
+
+  typedef struct JOYSTICK_DRIVER_HAT
+  {
+    int                           index;
+    JOYSTICK_DRIVER_HAT_DIRECTION direction;
+  } ATTRIBUTE_PACKED JOYSTICK_DRIVER_HAT;
+
+  typedef enum JOYSTICK_DRIVER_SEMIAXIS_DIRECTION
+  {
+    JOYSTICK_DRIVER_SEMIAXIS_NEGATIVE = -1, /*!< @brief negative half of the axis */
+    JOYSTICK_DRIVER_SEMIAXIS_UNKNOWN  =  0, /*!< @brief unknown direction */
+    JOYSTICK_DRIVER_SEMIAXIS_POSITIVE =  1, /*!< @brief positive half of the axis */
+  } JOYSTICK_DRIVER_SEMIAXIS_DIRECTION;
+
+  typedef struct JOYSTICK_DRIVER_SEMIAXIS
+  {
+    int                                index;
+    int                                center;
+    JOYSTICK_DRIVER_SEMIAXIS_DIRECTION direction;
+    unsigned int                       range;
+  } ATTRIBUTE_PACKED JOYSTICK_DRIVER_SEMIAXIS;
+
+  typedef struct JOYSTICK_DRIVER_MOTOR
+  {
+    int              index;
+  } ATTRIBUTE_PACKED JOYSTICK_DRIVER_MOTOR;
+
+  typedef struct JOYSTICK_DRIVER_PRIMITIVE
+  {
+    JOYSTICK_DRIVER_PRIMITIVE_TYPE    type;
+    union
+    {
+      struct JOYSTICK_DRIVER_BUTTON   button;
+      struct JOYSTICK_DRIVER_HAT      hat;
+      struct JOYSTICK_DRIVER_SEMIAXIS semiaxis;
+      struct JOYSTICK_DRIVER_MOTOR    motor;
+    };
+  } ATTRIBUTE_PACKED JOYSTICK_DRIVER_PRIMITIVE;
+
+  typedef enum JOYSTICK_FEATURE_TYPE
+  {
+    JOYSTICK_FEATURE_TYPE_UNKNOWN,
+    JOYSTICK_FEATURE_TYPE_SCALAR,
+    JOYSTICK_FEATURE_TYPE_ANALOG_STICK,
+    JOYSTICK_FEATURE_TYPE_ACCELEROMETER,
+    JOYSTICK_FEATURE_TYPE_MOTOR,
+  } JOYSTICK_FEATURE_TYPE;
+
+  typedef enum JOYSTICK_FEATURE_PRIMITIVE
+  {
+    // Scalar feature
+    JOYSTICK_SCALAR_PRIMITIVE = 0,
+
+    // Analog stick
+    JOYSTICK_ANALOG_STICK_UP = 0,
+    JOYSTICK_ANALOG_STICK_DOWN = 1,
+    JOYSTICK_ANALOG_STICK_RIGHT = 2,
+    JOYSTICK_ANALOG_STICK_LEFT = 3,
+
+    // Accelerometer
+    JOYSTICK_ACCELEROMETER_POSITIVE_X = 0,
+    JOYSTICK_ACCELEROMETER_POSITIVE_Y = 1,
+    JOYSTICK_ACCELEROMETER_POSITIVE_Z = 2,
+
+    // Motor
+    JOYSTICK_MOTOR_PRIMITIVE = 0,
+
+    // Maximum number of primitives
+    JOYSTICK_PRIMITIVE_MAX = 4,
+  } JOYSTICK_FEATURE_PRIMITIVE;
+
+  typedef struct JOYSTICK_FEATURE
+  {
+    char*                                   name;
+    JOYSTICK_FEATURE_TYPE                   type;
+    struct JOYSTICK_DRIVER_PRIMITIVE        primitives[JOYSTICK_PRIMITIVE_MAX];
+  } ATTRIBUTE_PACKED JOYSTICK_FEATURE;
+  ///}
+
+  typedef struct AddonProps_Peripheral
+  {
+    const char* user_path;              /*!< @brief path to the user profile */
+    const char* addon_path;             /*!< @brief path to this add-on */
+  } ATTRIBUTE_PACKED AddonProps_Peripheral;
+
+  struct AddonInstance_Peripheral;
+
+  typedef struct AddonToKodiFuncTable_Peripheral
+  {
+    KODI_HANDLE kodiInstance;
+    void (*trigger_scan)(void* kodiInstance);
+    void (*refresh_button_maps)(void* kodiInstance, const char* device_name, const char* controller_id);
+    unsigned int (*feature_count)(void* kodiInstance, const char* controller_id, JOYSTICK_FEATURE_TYPE type);
+  } AddonToKodiFuncTable_Peripheral;
+
+  //! @todo Mouse, light gun, multitouch
+
+  typedef struct KodiToAddonFuncTable_Peripheral
+  {
+    kodi::addon::CInstancePeripheral* addonInstance;
+
+    void (__cdecl* get_capabilities)(const AddonInstance_Peripheral* addonInstance, PERIPHERAL_CAPABILITIES* capabilities);
+    PERIPHERAL_ERROR (__cdecl* perform_device_scan)(const AddonInstance_Peripheral* addonInstance, unsigned int* peripheral_count, PERIPHERAL_INFO** scan_results);
+    void (__cdecl* free_scan_results)(const AddonInstance_Peripheral* addonInstance, unsigned int peripheral_count, PERIPHERAL_INFO* scan_results);
+    PERIPHERAL_ERROR (__cdecl* get_events)(const AddonInstance_Peripheral* addonInstance, unsigned int* event_count, PERIPHERAL_EVENT** events);
+    void (__cdecl* free_events)(const AddonInstance_Peripheral* addonInstance, unsigned int event_count, PERIPHERAL_EVENT* events);
+    bool (__cdecl* send_event)(const AddonInstance_Peripheral* addonInstance, const PERIPHERAL_EVENT* event);
+
+    /// @name Joystick operations
+    ///{
+    PERIPHERAL_ERROR (__cdecl* get_joystick_info)(const AddonInstance_Peripheral* addonInstance, unsigned int index, JOYSTICK_INFO* info);
+    void (__cdecl* free_joystick_info)(const AddonInstance_Peripheral* addonInstance, JOYSTICK_INFO* info);
+    PERIPHERAL_ERROR (__cdecl* get_features)(const AddonInstance_Peripheral* addonInstance, const JOYSTICK_INFO* joystick, const char* controller_id, unsigned int* feature_count, JOYSTICK_FEATURE** features);
+    void (__cdecl* free_features)(const AddonInstance_Peripheral* addonInstance, unsigned int feature_count, JOYSTICK_FEATURE* features);
+    PERIPHERAL_ERROR (__cdecl* map_features)(const AddonInstance_Peripheral* addonInstance, const JOYSTICK_INFO* joystick, const char* controller_id, unsigned int feature_count, const JOYSTICK_FEATURE* features);
+    PERIPHERAL_ERROR (__cdecl* get_ignored_primitives)(const AddonInstance_Peripheral* addonInstance, const JOYSTICK_INFO* joystick, unsigned int* feature_count, JOYSTICK_DRIVER_PRIMITIVE** primitives);
+    void (__cdecl* free_primitives)(const AddonInstance_Peripheral* addonInstance, unsigned int, JOYSTICK_DRIVER_PRIMITIVE* primitives);
+    PERIPHERAL_ERROR (__cdecl* set_ignored_primitives)(const AddonInstance_Peripheral* addonInstance, const JOYSTICK_INFO* joystick, unsigned int primitive_count, const JOYSTICK_DRIVER_PRIMITIVE* primitives);
+    void (__cdecl* save_button_map)(const AddonInstance_Peripheral* addonInstance, const JOYSTICK_INFO* joystick);
+    void (__cdecl* revert_button_map)(const AddonInstance_Peripheral* addonInstance, const JOYSTICK_INFO* joystick);
+    void (__cdecl* reset_button_map)(const AddonInstance_Peripheral* addonInstance, const JOYSTICK_INFO* joystick, const char* controller_id);
+    void (__cdecl* power_off_joystick)(const AddonInstance_Peripheral* addonInstance, unsigned int index);
+    ///}
+  } KodiToAddonFuncTable_Peripheral;
+
+  typedef struct AddonInstance_Peripheral
+  {
+    AddonProps_Peripheral props;
+    AddonToKodiFuncTable_Peripheral toKodi;
+    KodiToAddonFuncTable_Peripheral toAddon;
+  } AddonInstance_Peripheral;
+
+} /* extern "C" */
+
+namespace kodi
+{
+namespace addon
+{
+
+  class CInstancePeripheral : public IAddonInstance
+  {
+  public:
+    CInstancePeripheral()
+      : IAddonInstance(ADDON_INSTANCE_PERIPHERAL)
+    {
+      if (CAddonBase::m_interface->globalSingleInstance != nullptr)
+        throw std::logic_error("kodi::addon::CInstancePeripheral: Creation of more as one in single instance way is not allowed!");
+
+      SetAddonStruct(CAddonBase::m_interface->firstKodiInstance);
+      CAddonBase::m_interface->globalSingleInstance = this;
+    }
+
+    CInstancePeripheral(KODI_HANDLE instance)
+      : IAddonInstance(ADDON_INSTANCE_PERIPHERAL)
+    {
+      if (CAddonBase::m_interface->globalSingleInstance != nullptr)
+        throw std::logic_error("kodi::addon::CInstancePeripheral: Creation of multiple together with single instance way is not allowed!");
+
+      SetAddonStruct(instance);
+    }
+
+    ~CInstancePeripheral() override = default;
+
+    /// @name Peripheral operations
+    ///{
+    /*!
+     * @brief Get the list of features that this add-on provides
+     * @param capabilities The add-on's capabilities.
+     * @remarks Valid implementation required.
+     *
+     * Called by the frontend to query the add-on's capabilities and supported
+     * peripherals. All capabilities that the add-on supports should be set to true.
+     *
+     */
+    virtual void GetCapabilities(PERIPHERAL_CAPABILITIES &capabilities) { }
+
+    /*!
+     * @brief Perform a scan for joysticks
+     * @param peripheral_count  Assigned to the number of peripherals allocated
+     * @param scan_results      Assigned to allocated memory
+     * @return PERIPHERAL_NO_ERROR if successful; peripherals must be freed using
+     * FreeScanResults() in this case
+     *
+     * The frontend calls this when a hardware change is detected. If an add-on
+     * detects a hardware change, it can trigger this function using the
+     * TriggerScan() callback.
+     */
+    virtual PERIPHERAL_ERROR PerformDeviceScan(unsigned int* peripheral_count, PERIPHERAL_INFO** scan_results) { return PERIPHERAL_ERROR_NOT_IMPLEMENTED; }
+
+    /*!
+     * @brief Free the memory allocated in PerformDeviceScan()
+     *
+     * Must be called if PerformDeviceScan() returns PERIPHERAL_NO_ERROR.
+     *
+     * @param peripheral_count  The number of events allocated for the events array
+     * @param scan_results      The array of allocated peripherals
+     */
+    virtual void FreeScanResults(unsigned int peripheral_count, PERIPHERAL_INFO* scan_results) { }
+
+    /*!
+     * @brief Get all events that have occurred since the last call to GetEvents()
+     * @return PERIPHERAL_NO_ERROR if successful; events must be freed using
+     * FreeEvents() in this case
+     */
+    virtual PERIPHERAL_ERROR GetEvents(unsigned int* event_count, PERIPHERAL_EVENT** events) { return PERIPHERAL_ERROR_NOT_IMPLEMENTED; }
+
+    /*!
+     * @brief Free the memory allocated in GetEvents()
+     *
+     * Must be called if GetEvents() returns PERIPHERAL_NO_ERROR.
+     *
+     * @param event_count  The number of events allocated for the events array
+     * @param events       The array of allocated events
+     */
+    virtual void FreeEvents(unsigned int event_count, PERIPHERAL_EVENT* events) { }
+
+    /*!
+     * @brief Send an input event to the specified peripheral
+     * @param peripheralIndex The index of the device receiving the input event
+     * @param event The input event
+     * @return true if the event was handled, false otherwise
+     */
+    virtual bool SendEvent(const PERIPHERAL_EVENT* event) { return false; }
+    ///}
+
+    /// @name Joystick operations
+    /*!
+     * @note #define PERIPHERAL_ADDON_JOYSTICKS before including kodi_peripheral_dll.h
+     * in the add-on if the add-on provides joysticks and add provides_joysticks="true"
+     * to the kodi.peripheral extension point node in addon.xml.
+     */
+    ///{
+    /*!
+     * @brief Get extended info about an attached joystick
+     * @param index  The joystick's driver index
+     * @param info   The container for the allocated joystick info
+     * @return PERIPHERAL_NO_ERROR if successful; array must be freed using
+     *         FreeJoystickInfo() in this case
+     */
+    virtual PERIPHERAL_ERROR GetJoystickInfo(unsigned int index, JOYSTICK_INFO* info) { return PERIPHERAL_ERROR_NOT_IMPLEMENTED; }
+
+    /*!
+     * @brief Free the memory allocated in GetJoystickInfo()
+     */
+    virtual void FreeJoystickInfo(JOYSTICK_INFO* info) { }
+
+    /*!
+     * @brief Get the features that allow translating the joystick into the controller profile
+     * @param joystick      The device's joystick properties; unknown values may be left at their default
+     * @param controller_id The controller profile being requested, e.g. game.controller.default
+     * @param feature_count The number of features allocated for the features array
+     * @param features      The array of allocated features
+     * @return PERIPHERAL_NO_ERROR if successful; array must be freed using
+     *         FreeButtonMap() in this case
+     */
+    virtual PERIPHERAL_ERROR GetFeatures(const JOYSTICK_INFO* joystick, const char* controller_id,
+                                         unsigned int* feature_count, JOYSTICK_FEATURE** features) { return PERIPHERAL_ERROR_NOT_IMPLEMENTED; }
+
+    /*!
+     * @brief Free the memory allocated in GetFeatures()
+     *
+     * Must be called if GetFeatures() returns PERIPHERAL_NO_ERROR.
+     *
+     * @param feature_count  The number of features allocated for the features array
+     * @param features       The array of allocated features
+     */
+    virtual void FreeFeatures(unsigned int feature_count, JOYSTICK_FEATURE* features) { }
+
+    /*!
+     * @brief Add or update joystick features
+     * @param joystick      The device's joystick properties; unknown values may be left at their default
+     * @param controller_id The game controller profile being updated
+     * @param feature_count The number of features in the features array
+     * @param features      The array of features
+     * @return PERIPHERAL_NO_ERROR if successful
+     */
+    virtual PERIPHERAL_ERROR MapFeatures(const JOYSTICK_INFO* joystick, const char* controller_id,
+                                         unsigned int feature_count, const JOYSTICK_FEATURE* features) { return PERIPHERAL_ERROR_NOT_IMPLEMENTED; }
+
+    /*!
+     * @brief Get the driver primitives that should be ignored while mapping the device
+     * @param joystick        The device's joystick properties; unknown values may be left at their default
+     * @param primitive_count The number of features allocated for the primitives array
+     * @param primitives      The array of allocated driver primitives to be ignored
+     * @return PERIPHERAL_NO_ERROR if successful; array must be freed using
+     *         FreePrimitives() in this case
+     */
+    virtual PERIPHERAL_ERROR GetIgnoredPrimitives(const JOYSTICK_INFO* joystick,
+                                                  unsigned int* primitive_count,
+                                                  JOYSTICK_DRIVER_PRIMITIVE** primitives) { return PERIPHERAL_ERROR_NOT_IMPLEMENTED; }
+
+    /*!
+     * @brief Free the memory allocated in GetIgnoredPrimitives()
+     *
+     * Must be called if GetIgnoredPrimitives() returns PERIPHERAL_NO_ERROR.
+     *
+     * @param primitive_count  The number of driver primitives allocated for the primitives array
+     * @param primitives       The array of allocated driver primitives
+     */
+    virtual void FreePrimitives(unsigned int primitive_count, JOYSTICK_DRIVER_PRIMITIVE* primitives) { }
+
+    /*!
+     * @brief Set the list of driver primitives that are ignored for the device
+     * @param joystick         The device's joystick properties; unknown values may be left at their default
+     * @param primitive_count  The number of driver features in the primitives array
+     * @param primitives       The array of driver primitives to ignore
+     * @return PERIPHERAL_NO_ERROR if successful
+     */
+    virtual PERIPHERAL_ERROR SetIgnoredPrimitives(const JOYSTICK_INFO* joystick,
+                                                  unsigned int primitive_count,
+                                                  const JOYSTICK_DRIVER_PRIMITIVE* primitives) { return PERIPHERAL_ERROR_NOT_IMPLEMENTED; }
+
+    /*!
+     * @brief Save the button map for the given joystick
+     * @param joystick      The device's joystick properties
+     */
+    virtual void SaveButtonMap(const JOYSTICK_INFO* joystick) { }
+
+    /*!
+     * @brief Revert the button map to the last time it was loaded or committed to disk
+     * @param joystick      The device's joystick properties
+     */
+    virtual void RevertButtonMap(const JOYSTICK_INFO* joystick) { }
+
+    /*!
+     * @brief Reset the button map for the given joystick and controller profile ID
+     * @param joystick      The device's joystick properties
+     * @param controller_id The game controller profile being reset
+     */
+    virtual void ResetButtonMap(const JOYSTICK_INFO* joystick, const char* controller_id) { }
+
+    /*!
+     * @brief Powers off the given joystick if supported
+     * @param index  The joystick's driver index
+     */
+    virtual void PowerOffJoystick(unsigned int index) { }
+
+    const std::string AddonPath() const
+    {
+      return m_instanceData->props.addon_path;
+    }
+
+    const std::string UserPath() const
+    {
+      return m_instanceData->props.user_path;
+    }
+
+    /*!
+     * @brief Trigger a scan for peripherals
+     *
+     * The add-on calls this if a change in hardware is detected.
+     */
+    void TriggerScan(void)
+    {
+      return m_instanceData->toKodi.trigger_scan(m_instanceData->toKodi.kodiInstance);
+    }
+
+    /*!
+     * @brief Notify the frontend that button maps have changed
+     *
+     * @param[optional] deviceName The name of the device to refresh, or empty/null for all devices
+     * @param[optional] controllerId The controller ID to refresh, or empty/null for all controllers
+     */
+    void RefreshButtonMaps(const std::string& strDeviceName = "", const std::string& strControllerId = "")
+    {
+      return m_instanceData->toKodi.refresh_button_maps(m_instanceData->toKodi.kodiInstance, strDeviceName.c_str(), strControllerId.c_str());
+    }
+
+    /*!
+     * @brief Return the number of features belonging to the specified controller
+     *
+     * @param controllerId    The controller ID to enumerate
+     * @param type[optional]  Type to filter by, or JOYSTICK_FEATURE_TYPE_UNKNOWN for all features
+     *
+     * @return The number of features matching the request parameters
+     */
+    unsigned int FeatureCount(const std::string& strControllerId, JOYSTICK_FEATURE_TYPE type = JOYSTICK_FEATURE_TYPE_UNKNOWN)
+    {
+      return m_instanceData->toKodi.feature_count(m_instanceData->toKodi.kodiInstance, strControllerId.c_str(), type);
+    }
+
+  private:
+    void SetAddonStruct(KODI_HANDLE instance)
+    {
+      if (instance == nullptr)
+        throw std::logic_error("kodi::addon::CInstancePeripheral: Creation with empty addon structure not allowed, table must be given from Kodi!");
+
+      m_instanceData = static_cast<AddonInstance_Peripheral*>(instance);
+      m_instanceData->toAddon.addonInstance = this;
+
+      m_instanceData->toAddon.get_capabilities = ADDON_GetCapabilities;
+      m_instanceData->toAddon.perform_device_scan = ADDON_PerformDeviceScan;
+      m_instanceData->toAddon.free_scan_results = ADDON_FreeScanResults;
+      m_instanceData->toAddon.get_events = ADDON_GetEvents;
+      m_instanceData->toAddon.free_events = ADDON_FreeEvents;
+      m_instanceData->toAddon.send_event = ADDON_SendEvent;
+
+      m_instanceData->toAddon.get_joystick_info = ADDON_GetJoystickInfo;
+      m_instanceData->toAddon.free_joystick_info = ADDON_FreeJoystickInfo;
+      m_instanceData->toAddon.get_features = ADDON_GetFeatures;
+      m_instanceData->toAddon.free_features = ADDON_FreeFeatures;
+      m_instanceData->toAddon.map_features = ADDON_MapFeatures;
+      m_instanceData->toAddon.get_ignored_primitives = ADDON_GetIgnoredPrimitives;
+      m_instanceData->toAddon.free_primitives = ADDON_FreePrimitives;
+      m_instanceData->toAddon.set_ignored_primitives = ADDON_SetIgnoredPrimitives;
+      m_instanceData->toAddon.save_button_map = ADDON_SaveButtonMap;
+      m_instanceData->toAddon.revert_button_map = ADDON_RevertButtonMap;
+      m_instanceData->toAddon.reset_button_map = ADDON_ResetButtonMap;
+      m_instanceData->toAddon.power_off_joystick = ADDON_PowerOffJoystick;
+    }
+
+    inline static void ADDON_GetCapabilities(const AddonInstance_Peripheral* addonInstance, PERIPHERAL_CAPABILITIES *capabilities)
+    {
+      addonInstance->toAddon.addonInstance->GetCapabilities(*capabilities);
+    }
+
+    inline static PERIPHERAL_ERROR ADDON_PerformDeviceScan(const AddonInstance_Peripheral* addonInstance, unsigned int* peripheral_count, PERIPHERAL_INFO** scan_results)
+    {
+      return addonInstance->toAddon.addonInstance->PerformDeviceScan(peripheral_count, scan_results);
+    }
+
+    inline static void ADDON_FreeScanResults(const AddonInstance_Peripheral* addonInstance, unsigned int peripheral_count, PERIPHERAL_INFO* scan_results)
+    {
+      addonInstance->toAddon.addonInstance->FreeScanResults(peripheral_count, scan_results);
+    }
+
+    inline static PERIPHERAL_ERROR ADDON_GetEvents(const AddonInstance_Peripheral* addonInstance, unsigned int* event_count, PERIPHERAL_EVENT** events)
+    {
+      return addonInstance->toAddon.addonInstance->GetEvents(event_count, events);
+    }
+
+    inline static void ADDON_FreeEvents(const AddonInstance_Peripheral* addonInstance, unsigned int event_count, PERIPHERAL_EVENT* events)
+    {
+      addonInstance->toAddon.addonInstance->FreeEvents(event_count, events);
+    }
+
+    inline static bool ADDON_SendEvent(const AddonInstance_Peripheral* addonInstance, const PERIPHERAL_EVENT* event)
+    {
+      return addonInstance->toAddon.addonInstance->SendEvent(event);
+    }
+
+    
+    inline static PERIPHERAL_ERROR ADDON_GetJoystickInfo(const AddonInstance_Peripheral* addonInstance, unsigned int index, JOYSTICK_INFO* info)
+    {
+      return addonInstance->toAddon.addonInstance->GetJoystickInfo(index, info);
+    }
+
+    inline static void ADDON_FreeJoystickInfo(const AddonInstance_Peripheral* addonInstance, JOYSTICK_INFO* info)
+    {
+      addonInstance->toAddon.addonInstance->FreeJoystickInfo(info);
+    }
+
+    inline static PERIPHERAL_ERROR ADDON_GetFeatures(const AddonInstance_Peripheral* addonInstance,
+                                                     const JOYSTICK_INFO* joystick, const char* controller_id,
+                                                     unsigned int* feature_count, JOYSTICK_FEATURE** features)
+    {
+      return addonInstance->toAddon.addonInstance->GetFeatures(joystick, controller_id, feature_count, features);
+    }
+
+    inline static void ADDON_FreeFeatures(const AddonInstance_Peripheral* addonInstance, unsigned int feature_count, JOYSTICK_FEATURE* features)
+    {
+      addonInstance->toAddon.addonInstance->FreeFeatures(feature_count, features);
+    }
+
+    inline static PERIPHERAL_ERROR ADDON_MapFeatures(const AddonInstance_Peripheral* addonInstance,
+                                                     const JOYSTICK_INFO* joystick, const char* controller_id,
+                                                     unsigned int feature_count, const JOYSTICK_FEATURE* features)
+    {
+      return addonInstance->toAddon.addonInstance->MapFeatures(joystick, controller_id, feature_count, features);
+    }
+
+    inline static PERIPHERAL_ERROR ADDON_GetIgnoredPrimitives(const AddonInstance_Peripheral* addonInstance,
+                                                              const JOYSTICK_INFO* joystick, unsigned int* primitive_count,
+                                                              JOYSTICK_DRIVER_PRIMITIVE** primitives)
+    {
+      return addonInstance->toAddon.addonInstance->GetIgnoredPrimitives(joystick, primitive_count, primitives);
+    }
+
+    inline static void ADDON_FreePrimitives(const AddonInstance_Peripheral* addonInstance,
+                                            unsigned int primitive_count, JOYSTICK_DRIVER_PRIMITIVE* primitives)
+    {
+      addonInstance->toAddon.addonInstance->FreePrimitives(primitive_count, primitives);
+    }
+
+    inline static PERIPHERAL_ERROR ADDON_SetIgnoredPrimitives(const AddonInstance_Peripheral* addonInstance,
+                                                              const JOYSTICK_INFO* joystick, unsigned int primitive_count,
+                                                              const JOYSTICK_DRIVER_PRIMITIVE* primitives)
+    {
+      return addonInstance->toAddon.addonInstance->SetIgnoredPrimitives(joystick, primitive_count, primitives);
+    }
+
+    inline static void ADDON_SaveButtonMap(const AddonInstance_Peripheral* addonInstance, const JOYSTICK_INFO* joystick)
+    {
+      addonInstance->toAddon.addonInstance->SaveButtonMap(joystick);
+    }
+
+    inline static void ADDON_RevertButtonMap(const AddonInstance_Peripheral* addonInstance, const JOYSTICK_INFO* joystick)
+    {
+      addonInstance->toAddon.addonInstance->RevertButtonMap(joystick);
+    }
+
+    inline static void ADDON_ResetButtonMap(const AddonInstance_Peripheral* addonInstance, const JOYSTICK_INFO* joystick, const char* controller_id)
+    {
+      addonInstance->toAddon.addonInstance->ResetButtonMap(joystick, controller_id);
+    }
+
+    inline static void ADDON_PowerOffJoystick(const AddonInstance_Peripheral* addonInstance, unsigned int index)
+    {
+      addonInstance->toAddon.addonInstance->PowerOffJoystick(index);
+    }
+
+    AddonInstance_Peripheral* m_instanceData;
+  };
+
+} /* namespace addon */
+} /* namespace kodi */
diff --git a/xbmc/addons/kodi-addon-dev-kit/include/kodi/addon-instance/PeripheralUtils.h b/xbmc/addons/kodi-addon-dev-kit/include/kodi/addon-instance/PeripheralUtils.h
new file mode 100644
index 0000000..8cfa91b
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/include/kodi/addon-instance/PeripheralUtils.h
@@ -0,0 +1,668 @@
+/*
+ *      Copyright (C) 2014-2017 Team Kodi
+ *      http://kodi.tv
+ *
+ *  This Program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This Program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this Program; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+#pragma once
+
+#include "Peripheral.h"
+
+#include <array> // Requires c++11
+#include <cstring>
+#include <map>
+#include <string>
+#include <vector>
+
+#define PERIPHERAL_SAFE_DELETE(x)        do { delete   (x); (x) = NULL; } while (0)
+#define PERIPHERAL_SAFE_DELETE_ARRAY(x)  do { delete[] (x); (x) = NULL; } while (0)
+
+namespace kodi
+{
+namespace addon
+{
+  /*!
+   * Utility class to manipulate arrays of peripheral types.
+   */
+  template <class THE_CLASS, typename THE_STRUCT>
+  class PeripheralVector
+  {
+  public:
+    static void ToStructs(const std::vector<THE_CLASS>& vecObjects, THE_STRUCT** pStructs)
+    {
+      if (!pStructs)
+        return;
+
+      if (vecObjects.empty())
+      {
+        *pStructs = NULL;
+      }
+      else
+      {
+        (*pStructs) = new THE_STRUCT[vecObjects.size()];
+        for (unsigned int i = 0; i < vecObjects.size(); i++)
+          vecObjects.at(i).ToStruct((*pStructs)[i]);
+      }
+    }
+
+    static void ToStructs(const std::vector<THE_CLASS*>& vecObjects, THE_STRUCT** pStructs)
+    {
+      if (!pStructs)
+        return;
+
+      if (vecObjects.empty())
+      {
+        *pStructs = NULL;
+      }
+      else
+      {
+        *pStructs = new THE_STRUCT[vecObjects.size()];
+        for (unsigned int i = 0; i < vecObjects.size(); i++)
+          vecObjects.at(i)->ToStruct((*pStructs)[i]);
+      }
+    }
+
+    static void FreeStructs(unsigned int structCount, THE_STRUCT* structs)
+    {
+      if (structs)
+      {
+        for (unsigned int i = 0; i < structCount; i++)
+          THE_CLASS::FreeStruct(structs[i]);
+      }
+      PERIPHERAL_SAFE_DELETE_ARRAY(structs);
+    }
+  };
+
+  /*!
+   * ADDON::Peripheral
+   *
+   * Wrapper class providing peripheral information. Classes can extend
+   * Peripheral to inherit peripheral properties.
+   */
+  class Peripheral
+  {
+  public:
+    Peripheral(PERIPHERAL_TYPE type = PERIPHERAL_TYPE_UNKNOWN, const std::string& strName = "") :
+      m_type(type),
+      m_strName(strName),
+      m_vendorId(0),
+      m_productId(0),
+      m_index(0)
+    {
+    }
+
+    Peripheral(const PERIPHERAL_INFO& info) :
+      m_type(info.type),
+      m_strName(info.name ? info.name : ""),
+      m_vendorId(info.vendor_id),
+      m_productId(info.product_id),
+      m_index(info.index)
+    {
+    }
+
+    virtual ~Peripheral(void) = default;
+
+    PERIPHERAL_TYPE    Type(void) const      { return m_type; }
+    const std::string& Name(void) const      { return m_strName; }
+    uint16_t           VendorID(void) const  { return m_vendorId; }
+    uint16_t           ProductID(void) const { return m_productId; }
+    unsigned int       Index(void) const     { return m_index; }
+
+    // Derived property: VID and PID are 0x0000 if unknown
+    bool IsVidPidKnown(void) const { return m_vendorId != 0 || m_productId != 0; }
+
+    void SetType(PERIPHERAL_TYPE type)       { m_type      = type; }
+    void SetName(const std::string& strName) { m_strName   = strName; }
+    void SetVendorID(uint16_t vendorId)      { m_vendorId  = vendorId; }
+    void SetProductID(uint16_t productId)    { m_productId = productId; }
+    void SetIndex(unsigned int index)        { m_index     = index; }
+
+    void ToStruct(PERIPHERAL_INFO& info) const
+    {
+      info.type       = m_type;
+      info.name       = new char[m_strName.size() + 1];
+      info.vendor_id  = m_vendorId;
+      info.product_id = m_productId;
+      info.index      = m_index;
+
+      std::strcpy(info.name, m_strName.c_str());
+    }
+
+    static void FreeStruct(PERIPHERAL_INFO& info)
+    {
+      PERIPHERAL_SAFE_DELETE_ARRAY(info.name);
+    }
+
+  private:
+    PERIPHERAL_TYPE  m_type;
+    std::string      m_strName;
+    uint16_t         m_vendorId;
+    uint16_t         m_productId;
+    unsigned int     m_index;
+  };
+
+  typedef PeripheralVector<Peripheral, PERIPHERAL_INFO> Peripherals;
+
+  /*!
+   * ADDON::PeripheralEvent
+   *
+   * Wrapper class for peripheral events.
+   */
+  class PeripheralEvent
+  {
+  public:
+    PeripheralEvent(void) :
+      m_event()
+    {
+    }
+
+    PeripheralEvent(unsigned int peripheralIndex, unsigned int buttonIndex, JOYSTICK_STATE_BUTTON state) :
+      m_event()
+    {
+      SetType(PERIPHERAL_EVENT_TYPE_DRIVER_BUTTON);
+      SetPeripheralIndex(peripheralIndex);
+      SetDriverIndex(buttonIndex);
+      SetButtonState(state);
+    }
+
+    PeripheralEvent(unsigned int peripheralIndex, unsigned int hatIndex, JOYSTICK_STATE_HAT state) :
+      m_event()
+    {
+      SetType(PERIPHERAL_EVENT_TYPE_DRIVER_HAT);
+      SetPeripheralIndex(peripheralIndex);
+      SetDriverIndex(hatIndex);
+      SetHatState(state);
+    }
+
+    PeripheralEvent(unsigned int peripheralIndex, unsigned int axisIndex, JOYSTICK_STATE_AXIS state) :
+      m_event()
+    {
+      SetType(PERIPHERAL_EVENT_TYPE_DRIVER_AXIS);
+      SetPeripheralIndex(peripheralIndex);
+      SetDriverIndex(axisIndex);
+      SetAxisState(state);
+    }
+
+    PeripheralEvent(const PERIPHERAL_EVENT& event) :
+      m_event(event)
+    {
+    }
+
+    PERIPHERAL_EVENT_TYPE Type(void) const            { return m_event.type; }
+    unsigned int          PeripheralIndex(void) const { return m_event.peripheral_index; }
+    unsigned int          DriverIndex(void) const     { return m_event.driver_index; }
+    JOYSTICK_STATE_BUTTON ButtonState(void) const     { return m_event.driver_button_state; }
+    JOYSTICK_STATE_HAT    HatState(void) const        { return m_event.driver_hat_state; }
+    JOYSTICK_STATE_AXIS   AxisState(void) const       { return m_event.driver_axis_state; }
+    JOYSTICK_STATE_MOTOR  MotorState(void) const      { return m_event.motor_state; }
+
+    void SetType(PERIPHERAL_EVENT_TYPE type)         { m_event.type                = type; }
+    void SetPeripheralIndex(unsigned int index)      { m_event.peripheral_index    = index; }
+    void SetDriverIndex(unsigned int index)          { m_event.driver_index        = index; }
+    void SetButtonState(JOYSTICK_STATE_BUTTON state) { m_event.driver_button_state = state; }
+    void SetHatState(JOYSTICK_STATE_HAT state)       { m_event.driver_hat_state    = state; }
+    void SetAxisState(JOYSTICK_STATE_AXIS state)     { m_event.driver_axis_state   = state; }
+    void SetMotorState(JOYSTICK_STATE_MOTOR state)   { m_event.motor_state         = state; }
+
+    void ToStruct(PERIPHERAL_EVENT& event) const
+    {
+      event = m_event;
+    }
+
+    static void FreeStruct(PERIPHERAL_EVENT& event)
+    {
+      (void)event;
+    }
+
+  private:
+    PERIPHERAL_EVENT m_event;
+  };
+
+  typedef PeripheralVector<PeripheralEvent, PERIPHERAL_EVENT> PeripheralEvents;
+
+  /*!
+   * kodi::addon::Joystick
+   *
+   * Wrapper class providing additional joystick information not provided by
+   * ADDON::Peripheral.
+   */
+  class Joystick : public Peripheral
+  {
+  public:
+    Joystick(const std::string& provider = "", const std::string& strName = "") :
+      Peripheral(PERIPHERAL_TYPE_JOYSTICK, strName),
+      m_provider(provider),
+      m_requestedPort(NO_PORT_REQUESTED),
+      m_buttonCount(0),
+      m_hatCount(0),
+      m_axisCount(0),
+      m_motorCount(0),
+      m_supportsPowerOff(false)
+    {
+    }
+
+    Joystick(const Joystick& other)
+    {
+      *this = other;
+    }
+
+    Joystick(const JOYSTICK_INFO& info) :
+      Peripheral(info.peripheral),
+      m_provider(info.provider ? info.provider : ""),
+      m_requestedPort(info.requested_port),
+      m_buttonCount(info.button_count),
+      m_hatCount(info.hat_count),
+      m_axisCount(info.axis_count),
+      m_motorCount(info.motor_count),
+      m_supportsPowerOff(info.supports_poweroff)
+    {
+    }
+
+    ~Joystick(void) override = default;
+
+    Joystick& operator=(const Joystick& rhs)
+    {
+      if (this != &rhs)
+      {
+        Peripheral::operator=(rhs);
+
+        m_provider      = rhs.m_provider;
+        m_requestedPort = rhs.m_requestedPort;
+        m_buttonCount   = rhs.m_buttonCount;
+        m_hatCount      = rhs.m_hatCount;
+        m_axisCount     = rhs.m_axisCount;
+        m_motorCount    = rhs.m_motorCount;
+        m_supportsPowerOff = rhs.m_supportsPowerOff;
+      }
+      return *this;
+    }
+
+    const std::string& Provider(void) const      { return m_provider; }
+    int                RequestedPort(void) const { return m_requestedPort; }
+    unsigned int       ButtonCount(void) const   { return m_buttonCount; }
+    unsigned int       HatCount(void) const      { return m_hatCount; }
+    unsigned int       AxisCount(void) const     { return m_axisCount; }
+    unsigned int       MotorCount(void) const    { return m_motorCount; }
+    bool               SupportsPowerOff(void) const { return m_supportsPowerOff; }
+
+    // Derived property: Counts are unknown if all are zero
+    bool AreElementCountsKnown(void) const { return m_buttonCount != 0 || m_hatCount != 0 || m_axisCount != 0; }
+
+    void SetProvider(const std::string& provider)     { m_provider      = provider; }
+    void SetRequestedPort(int requestedPort)          { m_requestedPort = requestedPort; }
+    void SetButtonCount(unsigned int buttonCount)     { m_buttonCount   = buttonCount; }
+    void SetHatCount(unsigned int hatCount)           { m_hatCount      = hatCount; }
+    void SetAxisCount(unsigned int axisCount)         { m_axisCount     = axisCount; }
+    void SetMotorCount(unsigned int motorCount)       { m_motorCount    = motorCount; }
+    void SetSupportsPowerOff(bool supportsPowerOff)   { m_supportsPowerOff = supportsPowerOff; }
+
+    void ToStruct(JOYSTICK_INFO& info) const
+    {
+      Peripheral::ToStruct(info.peripheral);
+
+      info.provider       = new char[m_provider.size() + 1];
+      info.requested_port = m_requestedPort;
+      info.button_count   = m_buttonCount;
+      info.hat_count      = m_hatCount;
+      info.axis_count     = m_axisCount;
+      info.motor_count    = m_motorCount;
+      info.supports_poweroff = m_supportsPowerOff;
+
+      std::strcpy(info.provider, m_provider.c_str());
+    }
+
+    static void FreeStruct(JOYSTICK_INFO& info)
+    {
+      Peripheral::FreeStruct(info.peripheral);
+
+      PERIPHERAL_SAFE_DELETE_ARRAY(info.provider);
+    }
+
+  private:
+    std::string                   m_provider;
+    int                           m_requestedPort;
+    unsigned int                  m_buttonCount;
+    unsigned int                  m_hatCount;
+    unsigned int                  m_axisCount;
+    unsigned int                  m_motorCount;
+    bool                          m_supportsPowerOff;
+  };
+
+  typedef PeripheralVector<Joystick, JOYSTICK_INFO> Joysticks;
+
+  /*!
+   * ADDON::DriverPrimitive
+   *
+   * Base class for joystick driver primitives. A driver primitive can be:
+   *
+   *   1) a button
+   *   2) a hat direction
+   *   3) a semiaxis (either the positive or negative half of an axis)
+   *   4) a motor
+   *
+   * The type determines the fields in use:
+   *
+   *    Button:
+   *       - driver index
+   *
+   *    Hat direction:
+   *       - driver index
+   *       - hat direction
+   *
+   *    Semiaxis:
+   *       - driver index
+   *       - center
+   *       - semiaxis direction
+   *       - range
+   *
+   *    Motor:
+   *       - driver index
+   */
+  struct DriverPrimitive
+  {
+  protected:
+    /*!
+     * \brief Construct a driver primitive of the specified type
+     */
+    DriverPrimitive(JOYSTICK_DRIVER_PRIMITIVE_TYPE type, unsigned int driverIndex) :
+      m_type(type),
+      m_driverIndex(driverIndex),
+      m_hatDirection(JOYSTICK_DRIVER_HAT_UNKNOWN),
+      m_center(0),
+      m_semiAxisDirection(JOYSTICK_DRIVER_SEMIAXIS_UNKNOWN),
+      m_range(1)
+    {
+    }
+
+  public:
+    /*!
+     * \brief Construct an invalid driver primitive
+     */
+    DriverPrimitive(void) :
+      m_type(JOYSTICK_DRIVER_PRIMITIVE_TYPE_UNKNOWN),
+      m_driverIndex(0),
+      m_hatDirection(JOYSTICK_DRIVER_HAT_UNKNOWN),
+      m_center(0),
+      m_semiAxisDirection(JOYSTICK_DRIVER_SEMIAXIS_UNKNOWN),
+      m_range(1)
+    {
+    }
+
+    /*!
+     * \brief Construct a driver primitive representing a button
+     */
+    static DriverPrimitive CreateButton(unsigned int buttonIndex)
+    {
+      return DriverPrimitive(JOYSTICK_DRIVER_PRIMITIVE_TYPE_BUTTON, buttonIndex);
+    }
+
+    /*!
+     * \brief Construct a driver primitive representing one of the four direction
+     *        arrows on a dpad
+     */
+    DriverPrimitive(unsigned int hatIndex, JOYSTICK_DRIVER_HAT_DIRECTION direction) :
+      m_type(JOYSTICK_DRIVER_PRIMITIVE_TYPE_HAT_DIRECTION),
+      m_driverIndex(hatIndex),
+      m_hatDirection(direction),
+      m_center(0),
+      m_semiAxisDirection(JOYSTICK_DRIVER_SEMIAXIS_UNKNOWN),
+      m_range(1)
+    {
+    }
+
+    /*!
+     * \brief Construct a driver primitive representing the positive or negative
+     *        half of an axis
+     */
+    DriverPrimitive(unsigned int axisIndex, int center, JOYSTICK_DRIVER_SEMIAXIS_DIRECTION direction, unsigned int range) :
+      m_type(JOYSTICK_DRIVER_PRIMITIVE_TYPE_SEMIAXIS),
+      m_driverIndex(axisIndex),
+      m_hatDirection(JOYSTICK_DRIVER_HAT_UNKNOWN),
+      m_center(center),
+      m_semiAxisDirection(direction),
+      m_range(range)
+    {
+    }
+
+    /*!
+     * \brief Construct a driver primitive representing a motor
+     */
+    static DriverPrimitive CreateMotor(unsigned int motorIndex)
+    {
+      return DriverPrimitive(JOYSTICK_DRIVER_PRIMITIVE_TYPE_MOTOR, motorIndex);
+    }
+
+    DriverPrimitive(const JOYSTICK_DRIVER_PRIMITIVE& primitive) :
+      m_type(primitive.type),
+      m_driverIndex(0),
+      m_hatDirection(JOYSTICK_DRIVER_HAT_UNKNOWN),
+      m_center(0),
+      m_semiAxisDirection(JOYSTICK_DRIVER_SEMIAXIS_UNKNOWN),
+      m_range(1)
+    {
+      switch (m_type)
+      {
+        case JOYSTICK_DRIVER_PRIMITIVE_TYPE_BUTTON:
+        {
+          m_driverIndex = primitive.button.index;
+          break;
+        }
+        case JOYSTICK_DRIVER_PRIMITIVE_TYPE_HAT_DIRECTION:
+        {
+          m_driverIndex  = primitive.hat.index;
+          m_hatDirection = primitive.hat.direction;
+          break;
+        }
+        case JOYSTICK_DRIVER_PRIMITIVE_TYPE_SEMIAXIS:
+        {
+          m_driverIndex       = primitive.semiaxis.index;
+          m_center            = primitive.semiaxis.center;
+          m_semiAxisDirection = primitive.semiaxis.direction;
+          m_range             = primitive.semiaxis.range;
+          break;
+        }
+        case JOYSTICK_DRIVER_PRIMITIVE_TYPE_MOTOR:
+        {
+          m_driverIndex = primitive.motor.index;
+          break;
+        }
+        default:
+          break;
+      }
+    }
+
+    JOYSTICK_DRIVER_PRIMITIVE_TYPE     Type(void) const { return m_type; }
+    unsigned int                       DriverIndex(void) const { return m_driverIndex; }
+    JOYSTICK_DRIVER_HAT_DIRECTION      HatDirection(void) const { return m_hatDirection; }
+    int                                Center(void) const { return m_center; }
+    JOYSTICK_DRIVER_SEMIAXIS_DIRECTION SemiAxisDirection(void) const { return m_semiAxisDirection; }
+    unsigned int                       Range(void) const { return m_range; }
+
+    bool operator==(const DriverPrimitive& other) const
+    {
+      if (m_type == other.m_type)
+      {
+        switch (m_type)
+        {
+          case JOYSTICK_DRIVER_PRIMITIVE_TYPE_BUTTON:
+          case JOYSTICK_DRIVER_PRIMITIVE_TYPE_MOTOR:
+          {
+            return m_driverIndex == other.m_driverIndex;
+          }
+          case JOYSTICK_DRIVER_PRIMITIVE_TYPE_HAT_DIRECTION:
+          {
+            return m_driverIndex  == other.m_driverIndex &&
+                   m_hatDirection == other.m_hatDirection;
+          }
+          case JOYSTICK_DRIVER_PRIMITIVE_TYPE_SEMIAXIS:
+          {
+            return m_driverIndex       == other.m_driverIndex &&
+                   m_center            == other.m_center &&
+                   m_semiAxisDirection == other.m_semiAxisDirection &&
+                   m_range             == other.m_range;
+          }
+          default:
+            break;
+        }
+      }
+      return false;
+    }
+
+    void ToStruct(JOYSTICK_DRIVER_PRIMITIVE& driver_primitive) const
+    {
+      driver_primitive.type = m_type;
+      switch (m_type)
+      {
+        case JOYSTICK_DRIVER_PRIMITIVE_TYPE_BUTTON:
+        {
+          driver_primitive.button.index = m_driverIndex;
+          break;
+        }
+        case JOYSTICK_DRIVER_PRIMITIVE_TYPE_HAT_DIRECTION:
+        {
+          driver_primitive.hat.index     = m_driverIndex;
+          driver_primitive.hat.direction = m_hatDirection;
+          break;
+        }
+        case JOYSTICK_DRIVER_PRIMITIVE_TYPE_SEMIAXIS:
+        {
+          driver_primitive.semiaxis.index     = m_driverIndex;
+          driver_primitive.semiaxis.center    = m_center;
+          driver_primitive.semiaxis.direction = m_semiAxisDirection;
+          driver_primitive.semiaxis.range     = m_range;
+          break;
+        }
+        case JOYSTICK_DRIVER_PRIMITIVE_TYPE_MOTOR:
+        {
+          driver_primitive.motor.index = m_driverIndex;
+          break;
+        }
+        default:
+          break;
+      }
+    }
+
+    static void FreeStruct(JOYSTICK_DRIVER_PRIMITIVE& primitive)
+    {
+      (void)primitive;
+    }
+
+  private:
+    JOYSTICK_DRIVER_PRIMITIVE_TYPE     m_type;
+    unsigned int                       m_driverIndex;
+    JOYSTICK_DRIVER_HAT_DIRECTION      m_hatDirection;
+    int                                m_center;
+    JOYSTICK_DRIVER_SEMIAXIS_DIRECTION m_semiAxisDirection;
+    unsigned int                       m_range;
+  };
+
+  typedef PeripheralVector<DriverPrimitive, JOYSTICK_DRIVER_PRIMITIVE> DriverPrimitives;
+
+  /*!
+   * kodi::addon::JoystickFeature
+   *
+   * Class for joystick features. A feature can be:
+   *
+   *   1) scalar[1]
+   *   2) analog stick
+   *   3) accelerometer
+   *   4) motor
+   *
+   * [1] All three driver primitives (buttons, hats and axes) have a state that
+   *     can be represented using a single scalar value. For this reason,
+   *     features that map to a single primitive are called "scalar features".
+   */
+  class JoystickFeature
+  {
+  public:
+    JoystickFeature(const std::string& name = "", JOYSTICK_FEATURE_TYPE type = JOYSTICK_FEATURE_TYPE_UNKNOWN) :
+      m_name(name),
+      m_type(type),
+      m_primitives()
+    {
+    }
+
+    JoystickFeature(const JoystickFeature& other)
+    {
+      *this = other;
+    }
+
+    JoystickFeature(const JOYSTICK_FEATURE& feature) :
+      m_name(feature.name ? feature.name : ""),
+      m_type(feature.type)
+    {
+      for (unsigned int i = 0; i < JOYSTICK_PRIMITIVE_MAX; i++)
+        m_primitives[i] = feature.primitives[i];
+    }
+
+    JoystickFeature& operator=(const JoystickFeature& rhs)
+    {
+      if (this != &rhs)
+      {
+        m_name = rhs.m_name;
+        m_type = rhs.m_type;
+        m_primitives = rhs.m_primitives;
+      }
+      return *this;
+    }
+
+    bool operator==(const JoystickFeature& other) const
+    {
+      return m_name == other.m_name &&
+             m_type == other.m_type &&
+             m_primitives == other.m_primitives;
+    }
+
+    const std::string& Name(void) const { return m_name; }
+    JOYSTICK_FEATURE_TYPE Type(void) const { return m_type; }
+    bool IsValid() const { return m_type != JOYSTICK_FEATURE_TYPE_UNKNOWN; }
+
+    void SetName(const std::string& name) { m_name = name; }
+    void SetType(JOYSTICK_FEATURE_TYPE type) { m_type = type; }
+    void SetInvalid(void) { m_type = JOYSTICK_FEATURE_TYPE_UNKNOWN; }
+
+    const DriverPrimitive& Primitive(JOYSTICK_FEATURE_PRIMITIVE which) const { return m_primitives[which]; }
+    void SetPrimitive(JOYSTICK_FEATURE_PRIMITIVE which, const DriverPrimitive& primitive) { m_primitives[which] = primitive; }
+
+    std::array<DriverPrimitive, JOYSTICK_PRIMITIVE_MAX>& Primitives() { return m_primitives; }
+    const std::array<DriverPrimitive, JOYSTICK_PRIMITIVE_MAX>& Primitives() const { return m_primitives; }
+
+    void ToStruct(JOYSTICK_FEATURE& feature) const
+    {
+      feature.name = new char[m_name.length() + 1];
+      feature.type = m_type;
+      for (unsigned int i = 0; i < JOYSTICK_PRIMITIVE_MAX; i++)
+        m_primitives[i].ToStruct(feature.primitives[i]);
+
+      std::strcpy(feature.name, m_name.c_str());
+    }
+
+    static void FreeStruct(JOYSTICK_FEATURE& feature)
+    {
+      PERIPHERAL_SAFE_DELETE_ARRAY(feature.name);
+    }
+
+  private:
+    std::string                  m_name;
+    JOYSTICK_FEATURE_TYPE        m_type;
+    std::array<DriverPrimitive, JOYSTICK_PRIMITIVE_MAX> m_primitives;
+  };
+
+  typedef PeripheralVector<JoystickFeature, JOYSTICK_FEATURE> JoystickFeatures;
+
+} /* namespace addon */
+} /* namespace kodi */
+
diff --git a/xbmc/addons/kodi-addon-dev-kit/include/kodi/addon-instance/Screensaver.h b/xbmc/addons/kodi-addon-dev-kit/include/kodi/addon-instance/Screensaver.h
index 39baae7..85cd7bc 100644
--- a/xbmc/addons/kodi-addon-dev-kit/include/kodi/addon-instance/Screensaver.h
+++ b/xbmc/addons/kodi-addon-dev-kit/include/kodi/addon-instance/Screensaver.h
@@ -28,6 +28,11 @@ extern "C"
 
 struct AddonInstance_Screensaver;
 
+/*!
+ * @brief Screensaver properties
+ *
+ * Not to be used outside this header.
+ */
 typedef struct AddonProps_Screensaver
 {
   void *device;
@@ -41,11 +46,21 @@ typedef struct AddonProps_Screensaver
   const char *profile;
 } AddonProps_Screensaver;
 
+/*!
+ * @brief Screensaver callbacks
+ *
+ * Not to be used outside this header.
+ */
 typedef struct AddonToKodiFuncTable_Screensaver
 {
   KODI_HANDLE kodiInstance;
 } AddonToKodiFuncTable_Screensaver;
 
+/*!
+ * @brief Screensaver function hooks
+ *
+ * Not to be used outside this header.
+ */
 typedef struct KodiToAddonFuncTable_Screensaver
 {
   kodi::addon::CInstanceScreensaver* addonInstance;
@@ -54,6 +69,11 @@ typedef struct KodiToAddonFuncTable_Screensaver
   void (__cdecl* Render) (AddonInstance_Screensaver* instance);
 } KodiToAddonFuncTable_Screensaver;
 
+/*!
+ * @brief Screensaver instance
+ *
+ * Not to be used outside this header.
+ */
 typedef struct AddonInstance_Screensaver
 {
   AddonProps_Screensaver props;
@@ -68,9 +88,157 @@ namespace kodi
 namespace addon
 {
 
+  //============================================================================
+  ///
+  /// \addtogroup cpp_kodi_addon_screensaver
+  /// @brief \cpp_class{ kodi::addon::CInstanceScreensaver }
+  /// **Screensaver add-on instance**
+  ///
+  /// A screensaver is a Kodi addon that fills the screen with moving images or
+  /// patterns when the computer is not in use. Initially designed to prevent
+  /// phosphor burn-in on CRT and plasma computer monitors (hence the name),
+  /// screensavers are now used primarily for entertainment, security or to
+  /// display system status information.
+  ///
+  /// Include the header \ref ScreenSaver.h "#include <kodi/addon-instance/ScreenSaver.h>"
+  /// to use this class.
+  ///
+  /// This interface allows the creating of screensavers for Kodi, based upon
+  /// **DirectX** or/and **OpenGL** rendering with `C++` code.
+  ///
+  /// The interface is small and easy usable. It has three functions:
+  ///
+  /// * <b><c>Start()</c></b> - Called on creation
+  /// * <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"
+  /// available in which the child class can ask about the current hardware,
+  /// including the device, display and several other parts.
+  ///
+  ///
+  /// --------------------------------------------------------------------------
+  ///
+  ///
+  /// **Here is an example of the minimum required code to start a screensaver:**
+  /// ~~~~~~~~~~~~~{.cpp}
+  /// #include <kodi/addon-instance/Screensaver.h>
+  ///
+  /// class CMyScreenSaver : public kodi::addon::CAddonBase,
+  ///                        public kodi::addon::CInstanceScreensaver
+  /// {
+  /// public:
+  ///   CMyScreenSaver();
+  ///
+  ///   bool Start() override;
+  ///   void Render() override;
+  /// };
+  ///
+  /// CMyScreenSaver::CMyScreenSaver()
+  /// {
+  ///   ...
+  /// }
+  ///
+  /// bool CMyScreenSaver::Start()
+  /// {
+  ///   ...
+  ///   return true;
+  /// }
+  ///
+  /// void CMyScreenSaver::Render()
+  /// {
+  ///   ...
+  /// }
+  ///
+  /// ADDONCREATOR(CMyScreenSaver)
+  /// ~~~~~~~~~~~~~
+  ///
+  ///
+  /// --------------------------------------------------------------------------
+  ///
+  ///
+  /// **Here is another example where the screensaver is used together with
+  /// other instance types:**
+  ///
+  /// ~~~~~~~~~~~~~{.cpp}
+  /// #include <kodi/addon-instance/Screensaver.h>
+  ///
+  /// class CMyScreenSaver : public ::kodi::addon::CInstanceScreensaver
+  /// {
+  /// public:
+  ///   CMyScreenSaver(KODI_HANDLE instance);
+  ///
+  ///   bool Start() override;
+  ///   void Render() override;
+  /// };
+  ///
+  /// CMyScreenSaver::CMyScreenSaver(KODI_HANDLE instance)
+  ///   : CInstanceScreensaver(instance)
+  /// {
+  ///   ...
+  /// }
+  ///
+  /// bool CMyScreenSaver::Start()
+  /// {
+  ///   ...
+  ///   return true;
+  /// }
+  ///
+  /// void CMyScreenSaver::Render()
+  /// {
+  ///   ...
+  /// }
+  ///
+  ///
+  /// /*----------------------------------------------------------------------*/
+  ///
+  /// class CMyAddon : public ::kodi::addon::CAddonBase
+  /// {
+  /// public:
+  ///   CMyAddon() { }
+  ///   ADDON_STATUS CreateInstance(int instanceType,
+  ///                               std::string instanceID,
+  ///                               KODI_HANDLE instance,
+  ///                               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,
+  ///                                       KODI_HANDLE& addonInstance)
+  /// {
+  ///   if (instanceType == ADDON_INSTANCE_SCREENSAVER)
+  ///   {
+  ///     kodi::Log(ADDON_LOG_NOTICE, "Creating my Screensaver");
+  ///     addonInstance = new CMyScreenSaver(instance);
+  ///     return ADDON_STATUS_OK;
+  ///   }
+  ///   else if (...)
+  ///   {
+  ///     ...
+  ///   }
+  ///   return ADDON_STATUS_UNKNOWN;
+  /// }
+  ///
+  /// ADDONCREATOR(CMyAddon)
+  /// ~~~~~~~~~~~~~
+  ///
+  /// The destruction of the example class `CMyScreenSaver` is called from
+  /// Kodi's header. Manually deleting the add-on instance is not required.
+  ///
+  //----------------------------------------------------------------------------
   class CInstanceScreensaver : public IAddonInstance
   {
   public:
+    //==========================================================================
+    ///
+    /// @ingroup cpp_kodi_addon_screensaver
+    /// @brief Screensaver class constructor
+    ///
+    /// Used by an add-on that only supports screensavers.
+    ///
     CInstanceScreensaver()
       : IAddonInstance(ADDON_INSTANCE_SCREENSAVER)
     {
@@ -80,7 +248,19 @@ namespace addon
       SetAddonStruct(CAddonBase::m_interface->firstKodiInstance);
       CAddonBase::m_interface->globalSingleInstance = this;
     }
+    //--------------------------------------------------------------------------
 
+    //==========================================================================
+    ///
+    /// @ingroup cpp_kodi_addon_screensaver
+    /// @brief Screensaver class constructor used to support multiple instance
+    /// types
+    ///
+    /// @param[in] instance               The instance value given to
+    ///                                   <b>`kodi::addon::CAddonBase::CreateInstance(...)`</b>.
+    ///
+    /// @warning Only use `instance` from the CreateInstance call
+    ///
     CInstanceScreensaver(KODI_HANDLE instance)
       : IAddonInstance(ADDON_INSTANCE_SCREENSAVER)
     {
@@ -89,22 +269,150 @@ namespace addon
 
       SetAddonStruct(instance);
     }
+    //--------------------------------------------------------------------------
 
-    virtual ~CInstanceScreensaver() { }
+    //==========================================================================
+    ///
+    /// @ingroup cpp_kodi_addon_screensaver
+    /// @brief Destructor
+    ///
+    ~CInstanceScreensaver() override = default;
+    //--------------------------------------------------------------------------
 
+    //==========================================================================
+    ///
+    /// @ingroup cpp_kodi_addon_screensaver
+    /// @brief Used to notify the screensaver that it has been started
+    ///
+    /// @return                         true if the screensaver was started
+    ///                                 successfully, false otherwise
+    ///
     virtual bool Start() { return true; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @ingroup cpp_kodi_addon_screensaver
+    /// @brief Used to inform the screensaver that the rendering control was
+    /// stopped
+    ///
     virtual void Stop() {}
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @ingroup cpp_kodi_addon_screensaver
+    /// @brief Used to indicate when the add-on should render
+    ///
     virtual void Render() {}
+    //--------------------------------------------------------------------------
 
+    //==========================================================================
+    ///
+    /// \defgroup cpp_kodi_addon_screensaver_CB Information functions
+    /// \ingroup cpp_kodi_addon_screensaver
+    /// @brief **To get info about the device, display and several other parts**
+    ///
+    //@{
+
+    //==========================================================================
+    ///
+    /// @ingroup cpp_kodi_addon_screensaver_CB
+    /// @brief Device that represents the display adapter
+    ///
+    /// @return A pointer to the device
+    ///
+    /// @note This is only available on **DirectX**, It us unused (`nullptr`) on
+    /// **OpenGL**
+    ///
     inline void* Device() { return m_instanceData->props.device; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @ingroup cpp_kodi_addon_screensaver_CB
+    /// @brief Returns the X position of the rendering window
+    ///
+    /// @return The X position, in pixels
+    ///
     inline int X() { return m_instanceData->props.x; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @ingroup cpp_kodi_addon_screensaver_CB
+    /// @brief Returns the Y position of the rendering window
+    ///
+    /// @return The Y position, in pixels
+    ///
     inline int Y() { return m_instanceData->props.y; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @ingroup cpp_kodi_addon_screensaver_CB
+    /// @brief Returns the width of the rendering window
+    ///
+    /// @return The width, in pixels
+    ///
     inline int Width() { return m_instanceData->props.width; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @ingroup cpp_kodi_addon_screensaver_CB
+    /// @brief Returns the height of the rendering window
+    ///
+    /// @return The height, in pixels
+    ///
     inline int Height() { return m_instanceData->props.height; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @ingroup cpp_kodi_addon_screensaver_CB
+    /// @brief Pixel aspect ratio (often abbreviated PAR) is a ratio that
+    /// describes how the width of a pixel compares to the height of that pixel.
+    ///
+    /// @return The pixel aspect ratio used by the display
+    ///
     inline float PixelRatio() { return m_instanceData->props.pixelRatio; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @ingroup cpp_kodi_addon_screensaver_CB
+    /// @brief Used to get the name of the add-on defined in `addon.xml`
+    ///
+    /// @return The add-on name
+    ///
     inline std::string Name() { return m_instanceData->props.name; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @ingroup cpp_kodi_addon_screensaver_CB
+    /// @brief Used to get the full path where the add-on is installed
+    ///
+    /// @return The add-on installation path
+    ///
     inline std::string Presets() { return m_instanceData->props.presets; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @ingroup cpp_kodi_addon_screensaver_CB
+    /// @brief Used to get the full path to the add-on's user profile
+    ///
+    /// @note The trailing folder (consisting of the add-on's ID) is not created
+    /// by default. If it is needed, you must call kodi::vfs::CreateDirectory()
+    /// to create the folder.
+    ///
+    /// @return Path to the user profile
+    ///
     inline std::string Profile() { return m_instanceData->props.profile; }
+    //--------------------------------------------------------------------------
+    //@}
 
   private:
     void SetAddonStruct(KODI_HANDLE instance)
diff --git a/xbmc/addons/kodi-addon-dev-kit/include/kodi/addon-instance/VFS.h b/xbmc/addons/kodi-addon-dev-kit/include/kodi/addon-instance/VFS.h
new file mode 100644
index 0000000..4bb3e69
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/include/kodi/addon-instance/VFS.h
@@ -0,0 +1,622 @@
+#pragma once
+/*
+ *      Copyright (C) 2015 Team Kodi
+ *
+ *  This Program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This Program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Kodi; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "../AddonBase.h"
+#include "../Filesystem.h"
+
+#ifdef BUILD_KODI_ADDON
+#include "../IFileTypes.h"
+#else
+#include "filesystem/IFileTypes.h"
+#include "PlatformDefs.h"
+#endif
+
+namespace kodi { namespace addon { class CInstanceVFS; }}
+
+extern "C"
+{
+
+  struct VFSURL
+  {
+    const char* url;
+    const char* domain;
+    const char* hostname;
+    const char* filename;
+    unsigned int port;
+    const char* options;
+    const char* username;
+    const char* password;
+    const char* redacted;
+    const char* sharename;
+  };
+
+  typedef struct VFSGetDirectoryCallbacks /* internal */
+  {
+    bool (__cdecl* get_keyboard_input)(void* ctx, const char* heading, char** input, bool hidden_input);
+    void (__cdecl* set_error_dialog)(void* ctx, const char* heading, const char* line1, const char* line2, const char* line3);
+    void (__cdecl* require_authentication)(void* ctx, const char* url);
+    void* ctx;
+  } VFSGetDirectoryCallbacks;
+
+  typedef struct AddonProps_VFSEntry /* internal */
+  {
+    int dummy;
+  } AddonProps_VFSEntry;
+
+  typedef struct AddonToKodiFuncTable_VFSEntry /* internal */
+  {
+    KODI_HANDLE kodiInstance;
+  } AddonToKodiFuncTable_VFSEntry;
+
+  struct AddonInstance_VFSEntry;
+  typedef struct KodiToAddonFuncTable_VFSEntry /* internal */
+  {
+    kodi::addon::CInstanceVFS* addonInstance;
+
+    void* (__cdecl* open) (const AddonInstance_VFSEntry* instance, const VFSURL* url);
+    void* (__cdecl* open_for_write) (const AddonInstance_VFSEntry* instance, const VFSURL* url, bool overwrite);
+    ssize_t (__cdecl* read) (const AddonInstance_VFSEntry* instance, void* context, void* buffer, size_t buf_size);
+    ssize_t (__cdecl* write) (const AddonInstance_VFSEntry* instance, void* context, const void* buffer, size_t buf_size);
+    int64_t (__cdecl* seek) (const AddonInstance_VFSEntry* instance, void* context, int64_t position, int whence);
+    int (__cdecl* truncate) (const AddonInstance_VFSEntry* instance, void* context, int64_t size);
+    int64_t (__cdecl* get_length) (const AddonInstance_VFSEntry* instance, void* context);
+    int64_t (__cdecl* get_position) (const AddonInstance_VFSEntry* instance, void* context);
+    int (__cdecl* get_chunk_size) (const AddonInstance_VFSEntry* instance, void* context);
+    int (__cdecl* io_control) (const AddonInstance_VFSEntry* instance, void* context, XFILE::EIoControl request, void* param);
+    int (__cdecl* stat) (const AddonInstance_VFSEntry* instance, const VFSURL* url, struct __stat64* buffer);
+    bool (__cdecl* close) (const AddonInstance_VFSEntry* instance, void* context);
+    bool (__cdecl* exists) (const AddonInstance_VFSEntry* instance, const VFSURL* url);
+    void (__cdecl* clear_out_idle) (const AddonInstance_VFSEntry* instance);
+    void (__cdecl* disconnect_all) (const AddonInstance_VFSEntry* instance);
+    bool (__cdecl* delete_it) (const AddonInstance_VFSEntry* instance, const VFSURL* url);
+    bool (__cdecl* rename) (const AddonInstance_VFSEntry* instance, const VFSURL* url, const VFSURL* url2);
+    bool (__cdecl* directory_exists) (const AddonInstance_VFSEntry* instance, const VFSURL* url);
+    bool (__cdecl* remove_directory) (const AddonInstance_VFSEntry* instance, const VFSURL* url);
+    bool (__cdecl* create_directory) (const AddonInstance_VFSEntry* instance, const VFSURL* url);
+    bool (__cdecl* get_directory) (const AddonInstance_VFSEntry* instance,
+                                  const VFSURL* url,
+                                  VFSDirEntry** entries,
+                                  int* num_entries,
+                                  VFSGetDirectoryCallbacks* callbacks);
+    bool (__cdecl* contains_files) (const AddonInstance_VFSEntry* instance,
+                                   const VFSURL* url,
+                                   VFSDirEntry** entries,
+                                   int* num_entries,
+                                   char* rootpath);
+    void (__cdecl* free_directory) (const AddonInstance_VFSEntry* instance, VFSDirEntry* entries, int num_entries);
+  } KodiToAddonFuncTable_VFSEntry;
+
+  typedef struct AddonInstance_VFSEntry /* internal */
+  {
+    AddonProps_VFSEntry props;
+    AddonToKodiFuncTable_VFSEntry toKodi;
+    KodiToAddonFuncTable_VFSEntry toAddon;
+  } AddonInstance_VFSEntry;
+
+} /* extern "C" */
+
+namespace kodi
+{
+namespace addon
+{
+  class CInstanceVFS : public IAddonInstance
+  {
+  public:
+    CInstanceVFS(KODI_HANDLE instance)
+      : IAddonInstance(ADDON_INSTANCE_VFS)
+    {
+      if (CAddonBase::m_interface->globalSingleInstance != nullptr)
+        throw std::logic_error("kodi::addon::CInstanceVFS: Creation of multiple together with single instance way is not allowed!");
+
+      SetAddonStruct(instance);
+    }
+
+    ~CInstanceVFS() override = default;
+
+    /// @brief Open a file for input
+    ///
+    /// @param[in] url The URL of the file
+    /// @return Context for the opened file
+    virtual void* Open(const VFSURL& url) { return nullptr; }
+
+    /// @brief Open a file for output
+    ///
+    /// @param[in] url The URL of the file
+    /// @param[in] overWrite Whether or not to overwrite an existing file
+    /// @return Context for the opened file
+    ///
+    virtual void* OpenForWrite(const VFSURL& url, bool overWrite) { return nullptr; }
+
+    /// @brief Read from a file
+    ///
+    /// @param[in] context The context of the file
+    /// @param[out] buffer The buffer to read data into
+    /// @param[in] uiBufSize Number of bytes to read
+    /// @return Number of bytes read
+    ///
+    virtual ssize_t Read(void* context, void* buffer, size_t uiBufSize) { return -1; }
+
+    /// @brief Write to a file
+    ///
+    /// @param[in] context The context of the file
+    /// @param[in] buffer The buffer to read data from
+    /// @param[in] uiBufSize Number of bytes to write
+    /// @return Number of bytes written
+    ///
+    virtual ssize_t Write(void* context, const void* buffer, size_t uiBufSize) { return -1; }
+
+    /// @brief Seek in a file
+    ///
+    /// @param[in] context The context of the file
+    /// @param[in] position The position to seek to
+    /// @param[in] whence Position in file 'position' is relative to (SEEK_CUR, SEEK_SET, SEEK_END)
+    /// @return Offset in file after seek
+    ///
+    virtual int64_t Seek(void* context, int64_t position, int whence) { return -1; }
+
+    /// @brief Truncate a file
+    ///
+    /// @param[in] context The context of the file
+    /// @param[in] size The size to truncate the file to
+    /// @return 0 on success, -1 on error
+    ///
+    virtual int Truncate(void* context, int64_t size) { return -1; }
+
+    /// @brief Get total size of a file
+    ///
+    /// @param[in] context The context of the file
+    /// @return Total file size
+    ///
+    virtual int64_t GetLength(void* context) { return 0; }
+
+    /// @brief Get current position in a file
+    ///
+    /// @param[in] context The context of the file
+    /// @return Current position
+    ///
+    virtual int64_t GetPosition(void* context) { return 0; }
+
+    /// @brief Get chunk size of a file
+    ///
+    /// @param[in] context The context of the file
+    /// @return Chunk size
+    ///
+    virtual int GetChunkSize(void* context) { return 1; }
+
+    /// @brief Perform an IO-control on the file
+    ///
+    /// @param[in] context The context of the file
+    /// @param[in] request The requested IO-control
+    /// @param[in] param Parameter attached to the IO-control
+    /// @return -1 on error, >= 0 on success
+    ///
+    virtual int IoControl(void* context, XFILE::EIoControl request, void* param) { return -1; }
+
+    /// @brief Close a file
+    ///
+    /// @param[in] context The context of the file
+    /// @return True on success, false on failure
+    ///
+    virtual bool Close(void* context) { return false; }
+
+    /// @brief Stat a file
+    ///
+    /// @param[in] url The URL of the file
+    /// @param[in] buffer The buffer to store results in
+    /// @return -1 on error, 0 otherwise
+    ///
+    virtual int Stat(const VFSURL& url, struct __stat64* buffer) { return 0; }
+
+    /// @brief Check for file existence
+    ///
+    /// @param[in] url The URL of the file
+    /// @return True if file exists, false otherwise
+    ///
+    virtual bool Exists(const VFSURL& url) { return false; }
+
+    /// @brief Clear out any idle connections
+    ///
+    virtual void ClearOutIdle() { }
+
+    /// @brief Disconnect all connections
+    ///
+    virtual void DisconnectAll() { }
+
+    /// @brief Delete a file
+    ///
+    /// @param[in] url The URL of the file
+    /// @return True if deletion was successful, false otherwise
+    ///
+    virtual bool Delete(const VFSURL& url) { return false; }
+
+    /// @brief Rename a file
+    ///
+    /// @param[in] url The URL of the source file
+    /// @param[in] url2 The URL of the destination file
+    /// @return True if deletion was successful, false otherwise
+    ///
+    virtual bool Rename(const VFSURL& url, const VFSURL& url2) { return false; }
+
+    /// @brief Check for directory existence
+    ///
+    /// @param[in] url The URL of the file
+    /// @return True if directory exists, false otherwise
+    ///
+    virtual bool DirectoryExists(const VFSURL& url) { return false; }
+
+    /// @brief Remove a directory
+    ///
+    /// @param[in] url The URL of the directory
+    /// @return True if removal was successful, false otherwise
+    ///
+    virtual bool RemoveDirectory(const VFSURL& url) { return false; }
+
+    /// @brief Create a directory
+    ///
+    /// @param[in] url The URL of the file
+    /// @return True if creation was successful, false otherwise
+    ///
+    virtual bool CreateDirectory(const VFSURL& url) { return false; }
+
+    /// @brief Callback functions on GetDirectory()
+    ///
+    /// This functions becomes available during call of GetDirectory() from
+    /// Kodi.
+    ///
+    /// If GetDirectory() returns false becomes the parts from here used on
+    /// next call of the function.
+    ///
+    /// **Example:**
+    /// ~~~~~~~~~~~~~{.cpp}
+    ///
+    /// #include <kodi/addon-instance/VFS.h>
+    ///
+    /// ...
+    ///
+    /// bool CMyFile::GetDirectory(const VFSURL& url, std::vector<kodi::vfs::CDirEntry>& items, CVFSCallbacks callbacks)
+    /// {
+    ///   std::string neededString;
+    ///   callbacks.GetKeyboardInput("Test", neededString, true);
+    ///   if (neededString.empty())
+    ///     return false;
+    ///
+    ///   /* Do the work */
+    ///   ...
+    ///   return true;
+    /// }
+    /// ~~~~~~~~~~~~~
+    ///
+    //@{
+    class CVFSCallbacks
+    {
+    public:
+      /// @brief Require keyboard input
+      ///
+      /// Becomes called if GetDirectory() returns false and GetDirectory()
+      /// becomes after entry called again.
+      ///
+      /// @param[in] heading      The heading of the keyboard dialog
+      /// @param[out] input       The resulting string. Returns string after
+      ///                         second call!
+      /// @param[in] hiddenInput  To show input only as "*" on dialog
+      /// @return                 True if input was received, false otherwise
+      ///
+      bool GetKeyboardInput(const std::string& heading, std::string& input, bool hiddenInput = false)
+      {
+        char* cInput = nullptr;
+        bool ret = m_cb->get_keyboard_input(m_cb->ctx, heading.c_str(), &cInput, hiddenInput);
+        if (cInput)
+        {
+          input = cInput;
+          ::kodi::addon::CAddonBase::m_interface->toKodi->free_string(::kodi::addon::CAddonBase::m_interface->toKodi->kodiBase, cInput);
+        }
+        return ret;
+      }
+
+      /// @brief Display an error dialog
+      ///
+      /// @param[in] heading      The heading of the error dialog
+      /// @param[in] line1        The first line of the error dialog
+      /// @param[in] line2        [opt] The second line of the error dialog
+      /// @param[in] line3        [opt] The third line of the error dialog
+      ///
+      void SetErrorDialog(const std::string& heading, const std::string& line1, const std::string& line2 = "", const std::string& line3 = "")
+      {
+        m_cb->set_error_dialog(m_cb->ctx, heading.c_str(), line1.c_str(), line2.c_str(), line3.c_str());
+      }
+
+      /// @brief Prompt the user for authentication of a URL
+      ///
+      /// @param[in] url The URL
+      void RequireAuthentication(const std::string& url)
+      {
+        m_cb->require_authentication(m_cb->ctx, url.c_str());
+      }
+
+      CVFSCallbacks(const VFSGetDirectoryCallbacks* cb) : m_cb(cb) { }
+
+    private:
+      const VFSGetDirectoryCallbacks* m_cb;
+    };
+    //@}
+
+    /// @brief List a directory
+    ///
+    /// @param[in] url The URL of the directory
+    /// @param[out] entries The entries in the directory
+    /// @param[in] callbacks A callback structure
+    /// @return Context for the directory listing
+    ///
+    virtual bool GetDirectory(const VFSURL& url,
+                              std::vector<kodi::vfs::CDirEntry>& entries,
+                              CVFSCallbacks callbacks) { return false; }
+
+    /// @brief Check if file should be presented as a directory (multiple streams)
+    ///
+    /// @param[in] url The URL of the file
+    /// @param[out] entries The entries in the directory
+    /// @param[out] rootPath Path to root directory if multiple entries
+    /// @return Context for the directory listing
+    ///
+    virtual bool ContainsFiles(const VFSURL& url,
+                               std::vector<kodi::vfs::CDirEntry>& entries,
+                               std::string& rootPath) { return false; }
+
+  private:
+    void SetAddonStruct(KODI_HANDLE instance)
+    {
+      if (instance == nullptr)
+        throw std::logic_error("kodi::addon::CInstanceVFS: Creation with empty addon structure not allowed, table must be given from Kodi!");
+
+      m_instanceData = static_cast<AddonInstance_VFSEntry*>(instance);
+      m_instanceData->toAddon.addonInstance = this;
+      m_instanceData->toAddon.open = ADDON_Open;
+      m_instanceData->toAddon.open_for_write = ADDON_OpenForWrite;
+      m_instanceData->toAddon.read = ADDON_Read;
+      m_instanceData->toAddon.write = ADDON_Write;
+      m_instanceData->toAddon.seek = ADDON_Seek;
+      m_instanceData->toAddon.truncate = ADDON_Truncate;
+      m_instanceData->toAddon.get_length = ADDON_GetLength;
+      m_instanceData->toAddon.get_position = ADDON_GetPosition;
+      m_instanceData->toAddon.get_chunk_size = ADDON_GetChunkSize;
+      m_instanceData->toAddon.io_control = ADDON_IoControl;
+      m_instanceData->toAddon.stat = ADDON_Stat;
+      m_instanceData->toAddon.close = ADDON_Close;
+      m_instanceData->toAddon.exists = ADDON_Exists;
+      m_instanceData->toAddon.clear_out_idle = ADDON_ClearOutIdle;
+      m_instanceData->toAddon.disconnect_all = ADDON_DisconnectAll;
+      m_instanceData->toAddon.delete_it = ADDON_Delete;
+      m_instanceData->toAddon.rename = ADDON_Rename;
+      m_instanceData->toAddon.directory_exists = ADDON_DirectoryExists;
+      m_instanceData->toAddon.remove_directory = ADDON_RemoveDirectory;
+      m_instanceData->toAddon.create_directory = ADDON_CreateDirectory;
+      m_instanceData->toAddon.get_directory = ADDON_GetDirectory;
+      m_instanceData->toAddon.free_directory = ADDON_FreeDirectory;
+      m_instanceData->toAddon.contains_files = ADDON_ContainsFiles;
+    }
+
+    inline static void* ADDON_Open(const AddonInstance_VFSEntry* instance, const VFSURL* url)
+    {
+      return instance->toAddon.addonInstance->Open(*url);
+    }
+
+    inline static void* ADDON_OpenForWrite(const AddonInstance_VFSEntry* instance, const VFSURL* url, bool overWrite)
+    {
+      return instance->toAddon.addonInstance->OpenForWrite(*url, overWrite);
+    }
+
+    inline static ssize_t ADDON_Read(const AddonInstance_VFSEntry* instance, void* context, void* buffer, size_t uiBufSize)
+    {
+      return instance->toAddon.addonInstance->Read(context, buffer, uiBufSize);
+    }
+
+    inline static ssize_t ADDON_Write(const AddonInstance_VFSEntry* instance, void* context, const void* buffer, size_t uiBufSize)
+    {
+      return instance->toAddon.addonInstance->Write(context, buffer, uiBufSize);
+    }
+
+    inline static int64_t ADDON_Seek(const AddonInstance_VFSEntry* instance, void* context, int64_t position, int whence)
+    {
+      return instance->toAddon.addonInstance->Seek(context, position, whence);
+    }
+
+    inline static int ADDON_Truncate(const AddonInstance_VFSEntry* instance, void* context, int64_t size)
+    {
+      return instance->toAddon.addonInstance->Truncate(context, size);
+    }
+
+    inline static int64_t ADDON_GetLength(const AddonInstance_VFSEntry* instance, void* context)
+    {
+      return instance->toAddon.addonInstance->GetLength(context);
+    }
+
+    inline static int64_t ADDON_GetPosition(const AddonInstance_VFSEntry* instance, void* context)
+    {
+      return instance->toAddon.addonInstance->GetPosition(context);
+    }
+
+    inline static int ADDON_GetChunkSize(const AddonInstance_VFSEntry* instance, void* context)
+    {
+      return instance->toAddon.addonInstance->GetChunkSize(context);
+    }
+
+    inline static int ADDON_IoControl(const AddonInstance_VFSEntry* instance, void* context, XFILE::EIoControl request, void* param)
+    {
+      return instance->toAddon.addonInstance->IoControl(context, request, param);
+    }
+
+    inline static int ADDON_Stat(const AddonInstance_VFSEntry* instance, const VFSURL* url, struct __stat64* buffer)
+    {
+      return instance->toAddon.addonInstance->Stat(*url, buffer);
+    }
+
+    inline static bool ADDON_Close(const AddonInstance_VFSEntry* instance, void* context)
+    {
+      return instance->toAddon.addonInstance->Close(context);
+    }
+
+    inline static bool ADDON_Exists(const AddonInstance_VFSEntry* instance, const VFSURL* url)
+    {
+      return instance->toAddon.addonInstance->Exists(*url);
+    }
+
+    inline static void ADDON_ClearOutIdle(const AddonInstance_VFSEntry* instance)
+    {
+      return instance->toAddon.addonInstance->ClearOutIdle();
+    }
+
+    inline static void ADDON_DisconnectAll(const AddonInstance_VFSEntry* instance)
+    {
+      return instance->toAddon.addonInstance->DisconnectAll();
+    }
+
+    inline static bool ADDON_Delete(const AddonInstance_VFSEntry* instance, const VFSURL* url)
+    {
+      return instance->toAddon.addonInstance->Delete(*url);
+    }
+
+    inline static bool ADDON_Rename(const AddonInstance_VFSEntry* instance, const VFSURL* url, const VFSURL* url2)
+    {
+      return instance->toAddon.addonInstance->Rename(*url, *url2);
+    }
+
+    inline static bool ADDON_DirectoryExists(const AddonInstance_VFSEntry* instance, const VFSURL* url)
+    {
+      return instance->toAddon.addonInstance->DirectoryExists(*url);
+    }
+
+    inline static bool ADDON_RemoveDirectory(const AddonInstance_VFSEntry* instance, const VFSURL* url)
+    {
+      return instance->toAddon.addonInstance->RemoveDirectory(*url);
+    }
+
+    inline static bool ADDON_CreateDirectory(const AddonInstance_VFSEntry* instance, const VFSURL* url)
+    {
+      return instance->toAddon.addonInstance->CreateDirectory(*url);
+    }
+
+    inline static bool ADDON_GetDirectory(const AddonInstance_VFSEntry* instance,
+                                          const VFSURL* url,
+                                          VFSDirEntry** retEntries,
+                                          int* num_entries,
+                                          VFSGetDirectoryCallbacks* callbacks)
+    {
+      std::vector<kodi::vfs::CDirEntry> addonEntries;
+      bool ret = instance->toAddon.addonInstance->GetDirectory(*url, addonEntries, callbacks);
+      if (ret)
+      {
+        VFSDirEntry* entries = static_cast<VFSDirEntry*>(malloc(sizeof(VFSDirEntry) * addonEntries.size()));
+        for (unsigned int i = 0; i < addonEntries.size(); ++i)
+        {
+          entries[i].label = strdup(addonEntries[i].Label().c_str());
+          entries[i].title = strdup(addonEntries[i].Title().c_str());
+          entries[i].path = strdup(addonEntries[i].Path().c_str());
+          entries[i].folder = addonEntries[i].IsFolder();
+          entries[i].size = addonEntries[i].Size();
+
+          entries[i].num_props = 0;
+          const std::map<std::string, std::string>& props = addonEntries[i].GetProperties();
+          if (!props.empty())
+          {
+            entries[i].properties = static_cast<VFSProperty*>(malloc(sizeof(VFSProperty)*props.size()));
+            for (const auto& prop : props)
+            {
+              entries[i].properties[entries[i].num_props].name = strdup(prop.first.c_str());
+              entries[i].properties[entries[i].num_props].val = strdup(prop.second.c_str());
+              ++entries[i].num_props;
+            }
+          }
+          else
+            entries[i].properties = nullptr;
+        }
+        *retEntries = entries;
+        *num_entries = addonEntries.size();
+      }
+      return ret;
+    }
+
+    inline static void ADDON_FreeDirectory(const AddonInstance_VFSEntry* instance, VFSDirEntry* entries, int num_entries)
+    {
+      for (int i = 0; i < num_entries; ++i)
+      {
+        if (entries[i].properties)
+        {
+          for (unsigned int j = 0; j < entries[i].num_props; ++j)
+          {
+            free(entries[i].properties[j].name);
+            free(entries[i].properties[j].val);
+          }
+          free(entries[i].properties);
+        }
+        free(entries[i].label);
+        free(entries[i].title);
+        free(entries[i].path);
+      }
+      free(entries);
+    }
+
+    inline static bool ADDON_ContainsFiles(const AddonInstance_VFSEntry* instance,
+                                           const VFSURL* url,
+                                           VFSDirEntry** retEntries,
+                                           int* num_entries,
+                                           char* rootpath)
+    {
+      std::string cppRootPath; 
+      std::vector<kodi::vfs::CDirEntry> addonEntries;
+      bool ret = instance->toAddon.addonInstance->ContainsFiles(*url, addonEntries, cppRootPath);
+      if (ret)
+      {
+        strncpy(rootpath, cppRootPath.c_str(), ADDON_STANDARD_STRING_LENGTH);
+
+        VFSDirEntry* entries = static_cast<VFSDirEntry*>(malloc(sizeof(VFSDirEntry) * addonEntries.size()));
+        for (unsigned int i = 0; i < addonEntries.size(); ++i)
+        {
+          entries[i].label = strdup(addonEntries[i].Label().c_str());
+          entries[i].title = strdup(addonEntries[i].Title().c_str());
+          entries[i].path = strdup(addonEntries[i].Path().c_str());
+          entries[i].folder = addonEntries[i].IsFolder();
+          entries[i].size = addonEntries[i].Size();
+
+          entries[i].num_props = 0;
+          const std::map<std::string, std::string>& props = addonEntries[i].GetProperties();
+          if (!props.empty())
+          {
+            entries[i].properties = static_cast<VFSProperty*>(malloc(sizeof(VFSProperty)*props.size()));
+            for (const auto& prop : props)
+            {
+              entries[i].properties[entries[i].num_props].name = strdup(prop.first.c_str());
+              entries[i].properties[entries[i].num_props].val = strdup(prop.second.c_str());
+              ++entries[i].num_props;
+            }
+          }
+          else
+            entries[i].properties = nullptr;
+        }
+        *retEntries = entries;
+        *num_entries = addonEntries.size();
+      }
+      return ret;
+    }
+
+    AddonInstance_VFSEntry* m_instanceData;
+  };
+
+} /* namespace addon */
+} /* namespace kodi */
diff --git a/xbmc/addons/kodi-addon-dev-kit/include/kodi/addon-instance/VideoCodec.h b/xbmc/addons/kodi-addon-dev-kit/include/kodi/addon-instance/VideoCodec.h
new file mode 100644
index 0000000..710fda0
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/include/kodi/addon-instance/VideoCodec.h
@@ -0,0 +1,256 @@
+/*
+ *      Copyright (C) 2017 Team XBMC
+ *      http://xbmc.org
+ *
+ *  This Program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This Program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with XBMC; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#pragma once
+
+#include "../AddonBase.h"
+#include "../StreamCrypto.h"
+#include "../StreamCodec.h"
+
+#ifdef BUILD_KODI_ADDON
+#include "../DVDDemuxPacket.h"
+#else
+#include "cores/VideoPlayer/DVDDemuxers/DVDDemuxPacket.h"
+#endif
+
+namespace kodi { namespace addon { class CInstanceVideoCodec; } }
+
+extern "C"
+{
+  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;
+
+    uint32_t planeOffsets[VideoPlane::MaxPlanes];
+    uint32_t stride[VideoPlane::MaxPlanes];
+
+    int64_t pts;
+
+    void *buffer; //< will be passed in release_frame_buffer
+  };
+
+  enum VIDEOCODEC_RETVAL
+  {
+    VC_NONE = 0,        //< noop
+    VC_ERROR,           //< an error occured, 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
+  };
+
+  // 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;
+
+  struct AddonInstance_VideoCodec;
+  typedef struct KodiToAddonFuncTable_VideoCodec
+  {
+    kodi::addon::CInstanceVideoCodec* addonInstance;
+
+    //! \brief Opens a codec
+    bool (__cdecl* open) (const AddonInstance_VideoCodec* instance, VIDEOCODEC_INITDATA *initData);
+
+    //! \brief Reconfigures a codec
+    bool (__cdecl* reconfigure) (const AddonInstance_VideoCodec* instance, VIDEOCODEC_INITDATA *initData);
+
+    //! \brief Feed codec if requested from GetPicture() (return VC_BUFFER)
+    bool (__cdecl* add_data) (const AddonInstance_VideoCodec* instance, const DemuxPacket *packet);
+
+    //! \brief Get a decoded picture / request new data
+    VIDEOCODEC_RETVAL (__cdecl* get_picture) (const AddonInstance_VideoCodec* instance, VIDEOCODEC_PICTURE *picture);
+
+    //! \brief Get the name of this video decoder
+    const char *(__cdecl* get_name) (const AddonInstance_VideoCodec* instance);
+
+    //! \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;
+
+  typedef struct AddonInstance_VideoCodec
+  {
+    AddonProps_VideoCodec props;
+    AddonToKodiFuncTable_VideoCodec toKodi;
+    KodiToAddonFuncTable_VideoCodec toAddon;
+  } AddonInstance_VideoCodec;
+}
+
+namespace kodi
+{
+  namespace addon
+  {
+
+    class CInstanceVideoCodec : public IAddonInstance
+    {
+    public:
+      CInstanceVideoCodec(KODI_HANDLE instance)
+        : IAddonInstance(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);
+      }
+
+      ~CInstanceVideoCodec() override = default;
+
+      //! \copydoc CInstanceVideoCodec::Open
+      virtual bool Open(VIDEOCODEC_INITDATA &initData) { return false; };
+
+      //! \copydoc CInstanceVideoCodec::Reconfigure
+      virtual bool Reconfigure(VIDEOCODEC_INITDATA &initData) { return false; };
+
+      //! \copydoc CInstanceVideoCodec::AddData
+      virtual bool AddData(const DemuxPacket &packet) { return false; };
+
+      //! \copydoc CInstanceVideoCodec::GetPicture
+      virtual VIDEOCODEC_RETVAL GetPicture(VIDEOCODEC_PICTURE &picture) { return VC_ERROR; };
+
+      //! \copydoc CInstanceVideoCodec::GetName
+      virtual const char *GetName() { return nullptr; };
+
+      //! \copydoc CInstanceVideoCodec::Reset
+      virtual void Reset() {};
+
+      /*!
+      * @brief AddonToKodi interface
+      */
+
+      //! \copydoc CInstanceVideoCodec::GetFrameBuffer
+      bool GetFrameBuffer(VIDEOCODEC_PICTURE &picture)
+      {
+        return m_instanceData->toKodi.get_frame_buffer(m_instanceData->toKodi.kodiInstance, &picture);
+      }
+
+      //! \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!");
+
+        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;
+      }
+
+      inline static bool ADDON_Open(const AddonInstance_VideoCodec* instance, VIDEOCODEC_INITDATA *initData)
+      {
+        return instance->toAddon.addonInstance->Open(*initData);
+      }
+
+      inline static bool ADDON_Reconfigure(const AddonInstance_VideoCodec* instance, VIDEOCODEC_INITDATA *initData)
+      {
+        return instance->toAddon.addonInstance->Reconfigure(*initData);
+      }
+
+      inline static bool ADDON_AddData(const AddonInstance_VideoCodec* instance, const DemuxPacket *packet)
+      {
+        return instance->toAddon.addonInstance->AddData(*packet);
+      }
+
+      inline static VIDEOCODEC_RETVAL ADDON_GetPicture(const AddonInstance_VideoCodec* instance, VIDEOCODEC_PICTURE *picture)
+      {
+        return instance->toAddon.addonInstance->GetPicture(*picture);
+      }
+
+      inline static const char *ADDON_GetName(const AddonInstance_VideoCodec* instance)
+      {
+        return instance->toAddon.addonInstance->GetName();
+      }
+
+      inline static void ADDON_Reset(const AddonInstance_VideoCodec* instance)
+      {
+        return instance->toAddon.addonInstance->Reset();
+      }
+
+      AddonInstance_VideoCodec* m_instanceData;
+    };
+  } // namespace addon
+} // namespace kodi
diff --git a/xbmc/addons/kodi-addon-dev-kit/include/kodi/addon-instance/Visualization.h b/xbmc/addons/kodi-addon-dev-kit/include/kodi/addon-instance/Visualization.h
new file mode 100644
index 0000000..b1ded64
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/include/kodi/addon-instance/Visualization.h
@@ -0,0 +1,766 @@
+#pragma once
+/*
+ *      Copyright (C) 2005-2017 Team Kodi
+ *      http://kodi.tv
+ *
+ *  This Program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This Program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Kodi; see the file COPYING.  If not, see
+ *  <http://www.gnu.org/licenses/>.
+ *
+ */
+
+/*
+ * Parts with a comment named "internal" are only used inside header and not
+ * used or accessed direct during add-on development!
+ */
+
+#include "../AddonBase.h"
+
+namespace kodi { namespace addon { class CInstanceVisualization; }}
+
+extern "C"
+{
+
+struct AddonInstance_Visualization;
+
+typedef enum VIS_ACTION : unsigned int /* internal */
+{ 
+  VIS_ACTION_NONE = 0,
+  VIS_ACTION_NEXT_PRESET,
+  VIS_ACTION_PREV_PRESET,
+  VIS_ACTION_LOAD_PRESET,
+  VIS_ACTION_RANDOM_PRESET,
+  VIS_ACTION_LOCK_PRESET,
+  VIS_ACTION_RATE_PRESET_PLUS,
+  VIS_ACTION_RATE_PRESET_MINUS,
+  VIS_ACTION_UPDATE_ALBUMART,
+  VIS_ACTION_UPDATE_TRACK
+} VIS_ACTION;
+
+struct VIS_INFO /* internal */
+{
+  bool bWantsFreq;
+  int iSyncDelay;
+};
+
+typedef struct AddonProps_Visualization /* internal */
+{
+  void *device;
+  int x;
+  int y;
+  int width;
+  int height;
+  float pixelRatio;
+  const char *name;
+  const char *presets;
+  const char *profile;
+} AddonProps_Visualization;
+
+typedef struct AddonToKodiFuncTable_Visualization /* internal */
+{
+  KODI_HANDLE kodiInstance;
+  void (__cdecl* transfer_preset) (void* kodiInstance, const char* preset);
+} AddonToKodiFuncTable_Visualization;
+
+typedef struct KodiToAddonFuncTable_Visualization /* internal */
+{
+  kodi::addon::CInstanceVisualization* addonInstance;
+  bool (__cdecl* start)(const AddonInstance_Visualization* instance, int channels, int samples_per_sec, int bits_per_sample, const char* song_name);
+  void (__cdecl* stop)(const AddonInstance_Visualization* instance);
+  void (__cdecl* audio_data)(const AddonInstance_Visualization* instance, const float* audio_data, int audio_data_length, float *freq_data, int freq_data_length);
+  bool (__cdecl* is_dirty)(const AddonInstance_Visualization* instance);
+  void (__cdecl* render)(const AddonInstance_Visualization* instance);
+  void (__cdecl* get_info)(const AddonInstance_Visualization* instance, VIS_INFO *info);
+  bool (__cdecl* on_action)(const AddonInstance_Visualization* instance, VIS_ACTION action, const void *param);
+  unsigned int (__cdecl *get_presets)(const AddonInstance_Visualization* instance);
+  int (__cdecl *get_active_preset)(const AddonInstance_Visualization* instance);
+  bool (__cdecl* is_locked)(const AddonInstance_Visualization* instance);
+} KodiToAddonFuncTable_Visualization;
+
+typedef struct AddonInstance_Visualization /* internal */
+{
+  AddonProps_Visualization props;
+  AddonToKodiFuncTable_Visualization toKodi;
+  KodiToAddonFuncTable_Visualization toAddon;
+} AddonInstance_Visualization;
+
+//============================================================================
+/// \defgroup cpp_kodi_addon_visualization_VisTrack class VisTrack
+/// \ingroup cpp_kodi_addon_visualization
+/// @brief **Visualization track information structure**
+///
+/// Called from kodi::addon::CInstanceVisualization::UpdateTrack() with the
+/// information of the currently-playing song.
+///
+//@{
+struct VisTrack
+{
+  /// @brief Title of the current song.
+  const char *title;
+
+  /// @brief Artist names, as a single string
+  const char *artist;
+
+  /// @brief Album that the current song is from.
+  const char *album;
+
+  /// @brief Album artist names, as a single string
+  const char *albumArtist;
+
+  /// @brief The genre name from the music tag, if present.
+  const char *genre;
+
+  /// @brief Comment of the current song stored in the ID tag info.
+  const char *comment;
+
+  /// @brief Lyrics of the current song, if available.
+  const char *lyrics;
+
+  const char *reserved1;
+  const char *reserved2;
+
+  /// @brief Track number of the current song.
+  int trackNumber;
+
+  /// @brief Disc number of the current song stored in the ID tag info.
+  int discNumber;
+
+  /// @brief Duration of the current song, in seconds.
+  int duration;
+
+  /// @brief Year that the current song was released.
+  int year;
+
+  /// @brief The user-defined rating of the current song.
+  int rating;
+
+  int reserved3;
+  int reserved4;
+};
+//@}
+//----------------------------------------------------------------------------
+
+} /* extern "C" */
+
+namespace kodi
+{
+namespace addon
+{
+
+  //============================================================================
+  ///
+  /// \addtogroup cpp_kodi_addon_visualization
+  /// @brief \cpp_class{ kodi::addon::CInstanceVisualization }
+  /// **Visualization add-on instance**
+  ///
+  /// [Music visualization](https://en.wikipedia.org/wiki/Music_visualization),
+  /// or music visualisation, is a feature in Kodi that generates animated
+  /// imagery based on a piece of music. The imagery is usually generated and
+  /// rendered in real time synchronized to the music.
+  ///
+  /// Visualization techniques range from simple ones (e.g., a simulation of an
+  /// oscilloscope display) to elaborate ones, which often include a plurality
+  /// of composited effects. The changes in the music's loudness and frequency
+  /// spectrum are among the properties used as input to the visualization.
+  ///
+  /// Include the header \ref Visualization.h "#include <kodi/addon-instance/Visualization.h>"
+  /// to use this class.
+  ///
+  /// This interface allows the creation of visualizations for Kodi, based upon
+  /// **DirectX** or/and **OpenGL** rendering with `C++` code.
+  ///
+  /// Additionally, there are several \ref cpp_kodi_addon_visualization_CB "other functions"
+  /// available in which the child class can ask about the current hardware,
+  /// including the device, display and several other parts.
+  ///
+  /// --------------------------------------------------------------------------
+  ///
+  ///
+  /// **Here is an example of the minimum required code to start a visualization:**
+  /// ~~~~~~~~~~~~~{.cpp}
+  /// #include <kodi/addon-instance/Visualization.h>
+  ///
+  /// class CMyVisualization : public kodi::addon::CAddonBase,
+  ///                          public kodi::addon::CInstanceVisualization
+  /// {
+  /// public:
+  ///   CMyVisualization();
+  ///
+  ///   bool Start(int channels, int samplesPerSec, int bitsPerSample, std::string songName) override;
+  ///   void AudioData(const float* audioData, int audioDataLength, float* freqData, int freqDataLength) override;
+  ///   void Render() override;
+  /// };
+  ///
+  /// CMyVisualization::CMyVisualization()
+  /// {
+  ///   ...
+  /// }
+  ///
+  /// bool CMyVisualization::Start(int channels, int samplesPerSec, int bitsPerSample, std::string songName)
+  /// {
+  ///   ...
+  ///   return true;
+  /// }
+  ///
+  /// void CMyVisualization::AudioData(const float* audioData, int audioDataLength, float* freqData, int freqDataLength)
+  /// {
+  ///   ...
+  /// }
+  ///
+  /// void CMyVisualization::Render()
+  /// {
+  ///   ...
+  /// }
+  ///
+  /// ADDONCREATOR(CMyVisualization)
+  /// ~~~~~~~~~~~~~
+  ///
+  ///
+  /// --------------------------------------------------------------------------
+  ///
+  ///
+  /// **Here is another example where the visualization is used together with
+  /// other instance types:**
+  ///
+  /// ~~~~~~~~~~~~~{.cpp}
+  /// #include <kodi/addon-instance/Visualization.h>
+  ///
+  /// class CMyVisualization : public ::kodi::addon::CInstanceVisualization
+  /// {
+  /// public:
+  ///   CMyVisualization(KODI_HANDLE instance);
+  ///
+  ///   bool Start(int channels, int samplesPerSec, int bitsPerSample, std::string songName) override;
+  ///   void AudioData(const float* audioData, int audioDataLength, float* freqData, int freqDataLength) override;
+  ///   void Render() override;
+  /// };
+  ///
+  /// CMyVisualization::CMyVisualization(KODI_HANDLE instance)
+  ///   : CInstanceVisualization(instance)
+  /// {
+  ///   ...
+  /// }
+  ///
+  /// bool CMyVisualization::Start(int channels, int samplesPerSec, int bitsPerSample, std::string songName)
+  /// {
+  ///   ...
+  ///   return true;
+  /// }
+  ///
+  /// void CMyVisualization::AudioData(const float* audioData, int audioDataLength, float* freqData, int freqDataLength)
+  /// {
+  ///   ...
+  /// }
+  ///
+  /// void CMyVisualization::Render()
+  /// {
+  ///   ...
+  /// }
+  ///
+  ///
+  /// /*----------------------------------------------------------------------*/
+  ///
+  /// class CMyAddon : public ::kodi::addon::CAddonBase
+  /// {
+  /// public:
+  ///   CMyAddon() { }
+  ///   ADDON_STATUS CreateInstance(int instanceType,
+  ///                               std::string instanceID,
+  ///                               KODI_HANDLE instance,
+  ///                               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,
+  ///                                       KODI_HANDLE& addonInstance)
+  /// {
+  ///   if (instanceType == ADDON_INSTANCE_VISUALIZATION)
+  ///   {
+  ///     kodi::Log(ADDON_LOG_NOTICE, "Creating my Visualization");
+  ///     addonInstance = new CMyVisualization(instance);
+  ///     return ADDON_STATUS_OK;
+  ///   }
+  ///   else if (...)
+  ///   {
+  ///     ...
+  ///   }
+  ///   return ADDON_STATUS_UNKNOWN;
+  /// }
+  ///
+  /// ADDONCREATOR(CMyAddon)
+  /// ~~~~~~~~~~~~~
+  ///
+  /// The destruction of the example class `CMyVisualization` is called from
+  /// Kodi's header. Manually deleting the add-on instance is not required.
+  ///
+  //----------------------------------------------------------------------------
+  class CInstanceVisualization : public IAddonInstance
+  {
+  public:
+    //==========================================================================
+    ///
+    /// @ingroup cpp_kodi_addon_visualization
+    /// @brief Visualization class constructor
+    ///
+    /// Used by an add-on that only supports visualizations.
+    ///
+    CInstanceVisualization()
+      : IAddonInstance(ADDON_INSTANCE_VISUALIZATION),
+        m_presetLockedByUser(false)
+    {
+      if (CAddonBase::m_interface->globalSingleInstance != nullptr)
+        throw std::logic_error("kodi::addon::CInstanceVisualization: Cannot create multiple instances of add-on.");
+
+      SetAddonStruct(CAddonBase::m_interface->firstKodiInstance);
+      CAddonBase::m_interface->globalSingleInstance = this;
+    }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @ingroup cpp_kodi_addon_visualization
+    /// @brief Visualization class constructor used to support multiple instance
+    /// types
+    ///
+    /// @param[in] instance               The instance value given to
+    ///                                   <b>`kodi::addon::CAddonBase::CreateInstance(...)`</b>.
+    ///
+    /// @warning Only use `instance` from the CreateInstance call
+    ///
+    CInstanceVisualization(KODI_HANDLE instance)
+      : IAddonInstance(ADDON_INSTANCE_VISUALIZATION),
+        m_presetLockedByUser(false)
+    {
+      if (CAddonBase::m_interface->globalSingleInstance != nullptr)
+        throw std::logic_error("kodi::addon::CInstanceVisualization: Creation of multiple together with single instance way is not allowed!");
+
+      SetAddonStruct(instance);
+    }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @ingroup cpp_kodi_addon_visualization
+    /// @brief Destructor
+    ///
+    ~CInstanceVisualization() override = default;
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @ingroup cpp_kodi_addon_visualization
+    /// @brief Used to notify the visualization that a new song has been started
+    ///
+    /// @param[in] channels             Number of channels in the stream
+    /// @param[in] samplesPerSec        Samples per second of stream
+    /// @param[in] bitsPerSample        Number of bits in one sample
+    /// @param[in] songName             The name of the currently-playing song
+    /// @return                         true if start successful done
+    ///
+    virtual bool Start(int channels, int samplesPerSec, int bitsPerSample, std::string songName) { return true; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @ingroup cpp_kodi_addon_visualization
+    /// @brief Used to inform the visualization that the rendering control was
+    /// stopped
+    ///
+    virtual void Stop() {}
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @ingroup cpp_kodi_addon_visualization
+    /// @brief Pass audio data to the visualization
+    ///
+    /// @param[in] audioData            The raw audio data
+    /// @param[in] audioDataLength      Length of the audioData array
+    /// @param[in] freqData             The [FFT](https://en.wikipedia.org/wiki/Fast_Fourier_transform)
+    ///                                 of the audio data
+    /// @param[in] freqDataLength       Length of frequency data array
+    ///
+    /// Values **freqData** and **freqDataLength** are used if GetInfo() returns
+    /// true for the `wantsFreq` parameter. Otherwise, **freqData** is set to
+    /// `nullptr` and **freqDataLength** is `0`.
+    ///
+    virtual void AudioData(const float* audioData, int audioDataLength, float* freqData, int freqDataLength) {}
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @ingroup cpp_kodi_addon_visualization
+    /// @brief Used to inform Kodi that the rendered region is dirty and need an
+    /// update
+    ///
+    /// @return True if dirty
+    ///
+    virtual bool IsDirty() { return true; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @ingroup cpp_kodi_addon_visualization
+    /// @brief Used to indicate when the add-on should render
+    ///
+    virtual void Render() {}
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @ingroup cpp_kodi_addon_visualization
+    /// @brief Used to get the number of buffers from the current visualization
+    ///
+    /// @param[out] wantsFreq           Indicates whether the add-on wants FFT
+    ///                                 data. If set to true, the **freqData**
+    ///                                 and **freqDataLength** parameters of
+    ///                                 AudioData() are used
+    /// @param[out] syncDelay           The number of buffers to delay before
+    ///                                 calling AudioData()
+    ///
+    /// @note If this function is not implemented, it will default to
+    /// `wantsFreq` = false and `syncDelay` = 0.
+    ///
+    virtual void GetInfo(bool& wantsFreq, int& syncDelay) { wantsFreq = false; syncDelay = 0; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @ingroup cpp_kodi_addon_visualization
+    /// @brief Used to get a list of visualization presets the user can select
+    /// from
+    ///
+    /// @param[out] presets             The vector list containing the names of
+    ///                                 presets that the user can select
+    /// @return                         Return true if successful, or false if
+    ///                                 there are no presets to choose from
+    ///
+    virtual bool GetPresets(std::vector<std::string>& presets) { return false; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @ingroup cpp_kodi_addon_visualization
+    /// @brief Get the index of the current preset
+    ///
+    /// @return                         Index number of the current preset
+    ///
+    virtual int GetActivePreset() { return -1; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @ingroup cpp_kodi_addon_visualization
+    /// @brief Check if the add-on is locked to the current preset
+    ///
+    /// @return                         True if locked to the current preset
+    ///
+    virtual bool IsLocked() { return false; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @ingroup cpp_kodi_addon_visualization
+    /// @brief Load the previous visualization preset
+    ///
+    /// @return                 Return true if the previous preset was loaded
+    virtual bool PrevPreset() { return false; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @ingroup cpp_kodi_addon_visualization
+    /// @brief Load the next visualization preset
+    ///
+    /// @return                 Return true if the next preset was loaded
+    virtual bool NextPreset() { return false; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @ingroup cpp_kodi_addon_visualization
+    /// @brief Load a visualization preset
+    ///
+    /// This function is called after a new preset is selected.
+    ///
+    /// @param[in] select       Preset index to use
+    /// @return                 Return true if the preset is loaded
+    virtual bool LoadPreset(int select) { return false; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @ingroup cpp_kodi_addon_visualization
+    /// @brief Switch to a new random preset
+    ///
+    /// @return                 Return true if a random preset was loaded
+    virtual bool RandomPreset() { return false; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @ingroup cpp_kodi_addon_visualization
+    /// @brief Lock the current visualization preset, preventing it from changing
+    ///
+    /// @param[in] lockUnlock   If set to true, the preset should be locked
+    /// @return                 Return true if the current preset is locked
+    virtual bool LockPreset(bool lockUnlock) { return false; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @ingroup cpp_kodi_addon_visualization
+    /// @brief Used to increase/decrease the visualization preset rating
+    ///
+    /// @param[in] plusMinus    If set to true the rating is increased, otherwise
+    ///                         decreased
+    /// @return                 Return true if the rating is modified
+    virtual bool RatePreset(bool plusMinus) { return false; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @ingroup cpp_kodi_addon_visualization
+    /// @brief Inform the visualization of the current album art image
+    ///
+    /// @param[in] albumart     Path to the current album art image
+    /// @return                 Return true if the image is used
+    virtual bool UpdateAlbumart(std::string albumart) { return false; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @ingroup cpp_kodi_addon_visualization
+    /// @brief Inform the visualization of the current track's tag information
+    ///
+    /// @param[in] track        Visualization track information structure
+    /// @return                 Return true if the track information is used
+    virtual bool UpdateTrack(const VisTrack &track) { return false; }
+
+    //==========================================================================
+    ///
+    /// \defgroup cpp_kodi_addon_visualization_CB Information functions
+    /// \ingroup cpp_kodi_addon_visualization
+    /// @brief **To get info about the device, display and several other parts**
+    ///
+    //@{
+
+    //==========================================================================
+    ///
+    /// @ingroup cpp_kodi_addon_visualization_CB
+    /// @brief Device that represents the display adapter
+    ///
+    /// @return A pointer to the used device
+    ///
+    /// @note This is only available on **DirectX**, It us unused (`nullptr`) on
+    /// **OpenGL**
+    ///
+    inline void* Device() { return m_instanceData->props.device; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @ingroup cpp_kodi_addon_visualization_CB
+    /// @brief Returns the X position of the rendering window
+    ///
+    /// @return The X position, in pixels
+    ///
+    inline int X() { return m_instanceData->props.x; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @ingroup cpp_kodi_addon_visualization_CB
+    /// @brief Returns the Y position of the rendering window
+    ///
+    /// @return The Y position, in pixels
+    ///
+    inline int Y() { return m_instanceData->props.y; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @ingroup cpp_kodi_addon_visualization_CB
+    /// @brief Returns the width of the rendering window
+    ///
+    /// @return The width, in pixels
+    ///
+    inline int Width() { return m_instanceData->props.width; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @ingroup cpp_kodi_addon_visualization_CB
+    /// @brief Returns the height of the rendering window
+    ///
+    /// @return The height, in pixels
+    ///
+    inline int Height() { return m_instanceData->props.height; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @ingroup cpp_kodi_addon_visualization_CB
+    /// @brief Pixel aspect ratio (often abbreviated PAR) is a ratio that
+    /// describes how the width of a pixel compares to the height of that pixel.
+    ///
+    /// @return The pixel aspect ratio used by the display
+    ///
+    inline float PixelRatio() { return m_instanceData->props.pixelRatio; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @ingroup cpp_kodi_addon_visualization_CB
+    /// @brief Used to get the name of the add-on defined in `addon.xml`
+    ///
+    /// @return The add-on name
+    ///
+    inline std::string Name() { return m_instanceData->props.name; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @ingroup cpp_kodi_addon_visualization_CB
+    /// @brief Used to get the full path where the add-on is installed
+    ///
+    /// @return The add-on installation path
+    ///
+    inline std::string Presets() { return m_instanceData->props.presets; }
+    //--------------------------------------------------------------------------
+
+    //==========================================================================
+    ///
+    /// @ingroup cpp_kodi_addon_visualization_CB
+    /// @brief Used to get the full path to the add-on's user profile
+    ///
+    /// @note The trailing folder (consisting of the add-on's ID) is not created
+    /// by default. If it is needed, you must call kodi::vfs::CreateDirectory()
+    /// to create the folder.
+    ///
+    /// @return Path to the user profile
+    ///
+    inline std::string Profile() { return m_instanceData->props.profile; }
+    //--------------------------------------------------------------------------
+    //@}
+
+  private:
+    void SetAddonStruct(KODI_HANDLE instance)
+    {
+      if (instance == nullptr)
+        throw std::logic_error("kodi::addon::CInstanceVisualization: Null pointer instance passed.");
+
+      m_instanceData = static_cast<AddonInstance_Visualization*>(instance);
+      m_instanceData->toAddon.addonInstance = this;
+      m_instanceData->toAddon.start = ADDON_Start;
+      m_instanceData->toAddon.stop = ADDON_Stop;
+      m_instanceData->toAddon.audio_data = ADDON_AudioData;
+      m_instanceData->toAddon.render = ADDON_Render;
+      m_instanceData->toAddon.get_info = ADDON_GetInfo;
+      m_instanceData->toAddon.on_action = ADDON_OnAction;
+      m_instanceData->toAddon.get_presets = ADDON_GetPresets;
+      m_instanceData->toAddon.get_active_preset = ADDON_GetActivePreset;
+      m_instanceData->toAddon.is_locked = ADDON_IsLocked;
+    }
+
+    inline static bool ADDON_Start(const AddonInstance_Visualization* addon, int channels, int samplesPerSec, int bitsPerSample, const char* songName)
+    {
+      return addon->toAddon.addonInstance->Start(channels, samplesPerSec, bitsPerSample, songName);
+    }
+
+    inline static void ADDON_Stop(const AddonInstance_Visualization* addon)
+    {
+      addon->toAddon.addonInstance->Stop();
+    }
+
+    inline static void ADDON_AudioData(const AddonInstance_Visualization* addon, const float* audioData, int audioDataLength, float *freqData, int freqDataLength)
+    {
+      addon->toAddon.addonInstance->AudioData(audioData, audioDataLength, freqData, freqDataLength);
+    }
+    
+    inline static bool ADDON_IsDirty(const AddonInstance_Visualization* addon)
+    {
+      return addon->toAddon.addonInstance->IsDirty();
+    }
+
+    inline static void ADDON_Render(const AddonInstance_Visualization* addon)
+    {
+      addon->toAddon.addonInstance->Render();
+    }
+
+    inline static void ADDON_GetInfo(const AddonInstance_Visualization* addon, VIS_INFO *info)
+    {
+      addon->toAddon.addonInstance->GetInfo(info->bWantsFreq, info->iSyncDelay);
+    }
+
+    inline static bool ADDON_OnAction(const AddonInstance_Visualization* addon, VIS_ACTION action, const void *param)
+    {
+      switch (action)
+      {
+        case VIS_ACTION_NEXT_PRESET:
+          return addon->toAddon.addonInstance->NextPreset();
+        case VIS_ACTION_PREV_PRESET:
+          return addon->toAddon.addonInstance->PrevPreset();
+        case VIS_ACTION_LOAD_PRESET:
+          return addon->toAddon.addonInstance->LoadPreset(*static_cast<const int*>(param));
+        case VIS_ACTION_RANDOM_PRESET:
+          return addon->toAddon.addonInstance->RandomPreset();
+        case VIS_ACTION_LOCK_PRESET:
+          addon->toAddon.addonInstance->m_presetLockedByUser = !addon->toAddon.addonInstance->m_presetLockedByUser;
+          return addon->toAddon.addonInstance->LockPreset(addon->toAddon.addonInstance->m_presetLockedByUser);
+        case VIS_ACTION_RATE_PRESET_PLUS:
+          return addon->toAddon.addonInstance->RatePreset(true);
+        case VIS_ACTION_RATE_PRESET_MINUS:
+          return addon->toAddon.addonInstance->RatePreset(false);
+        case VIS_ACTION_UPDATE_ALBUMART:
+          return addon->toAddon.addonInstance->UpdateAlbumart(static_cast<const char*>(param));
+        case VIS_ACTION_UPDATE_TRACK:
+          return addon->toAddon.addonInstance->UpdateTrack(*static_cast<const VisTrack*>(param));
+        case VIS_ACTION_NONE:
+        default:
+          break;
+      }
+      return false;
+    }
+
+    inline static unsigned int ADDON_GetPresets(const AddonInstance_Visualization* addon)
+    {
+      std::vector<std::string> presets;
+      if (addon->toAddon.addonInstance->GetPresets(presets))
+      {
+        for (auto it : presets)
+          addon->toAddon.addonInstance->m_instanceData->toKodi.transfer_preset(addon->toKodi.kodiInstance, it.c_str());
+      }
+
+      return presets.size();
+    }
+
+    inline static int ADDON_GetActivePreset(const AddonInstance_Visualization* addon)
+    {
+      return addon->toAddon.addonInstance->GetActivePreset();
+    }
+
+    inline static bool ADDON_IsLocked(const AddonInstance_Visualization* addon)
+    {
+      return addon->toAddon.addonInstance->IsLocked();
+    }
+
+    bool m_presetLockedByUser;
+    AddonInstance_Visualization* m_instanceData;
+  };
+
+} /* namespace addon */
+} /* namespace kodi */