32 files changed, 4902 insertions, 151 deletions

diff --git a/xbmc/addons/addon-bindings.mk b/xbmc/addons/addon-bindings.mk
index e7185a7..49978b7 100644
--- a/xbmc/addons/addon-bindings.mk
+++ b/xbmc/addons/addon-bindings.mk
@@ -1,22 +1,31 @@
-BINDINGS =xbmc/addons/include/xbmc_addon_cpp_dll.h
-BINDINGS+=xbmc/addons/include/xbmc_addon_dll.h
-BINDINGS+=xbmc/addons/include/xbmc_addon_types.h
-BINDINGS+=xbmc/addons/include/xbmc_audioenc_dll.h
-BINDINGS+=xbmc/addons/include/xbmc_audioenc_types.h
-BINDINGS+=xbmc/addons/include/kodi_audiodec_dll.h
-BINDINGS+=xbmc/addons/include/kodi_audiodec_types.h
-BINDINGS+=xbmc/addons/include/xbmc_codec_types.h
-BINDINGS+=xbmc/addons/include/xbmc_epg_types.h
-BINDINGS+=xbmc/addons/include/xbmc_pvr_dll.h
-BINDINGS+=xbmc/addons/include/xbmc_pvr_types.h
-BINDINGS+=xbmc/addons/include/xbmc_scr_dll.h
-BINDINGS+=xbmc/addons/include/xbmc_scr_types.h
-BINDINGS+=xbmc/addons/include/xbmc_vis_dll.h
-BINDINGS+=xbmc/addons/include/xbmc_vis_types.h
-BINDINGS+=xbmc/addons/include/xbmc_stream_utils.hpp
-BINDINGS+=addons/library.xbmc.addon/libXBMC_addon.h
-BINDINGS+=addons/library.kodi.guilib/libKODI_guilib.h
-BINDINGS+=addons/library.xbmc.pvr/libXBMC_pvr.h
-BINDINGS+=addons/library.xbmc.codec/libXBMC_codec.h
-BINDINGS+=xbmc/cores/dvdplayer/DVDDemuxers/DVDDemuxPacket.h
+BINDINGS =xbmc/addons/kodi-addon-dev-kit/include/kodi/xbmc_addon_cpp_dll.h
+BINDINGS+=xbmc/addons/kodi-addon-dev-kit/include/kodi/xbmc_addon_dll.h
+BINDINGS+=xbmc/addons/kodi-addon-dev-kit/include/kodi/xbmc_addon_types.h
+BINDINGS+=xbmc/addons/kodi-addon-dev-kit/include/kodi/kodi_adsp_dll.h
+BINDINGS+=xbmc/addons/kodi-addon-dev-kit/include/kodi/kodi_adsp_types.h
+BINDINGS+=xbmc/addons/kodi-addon-dev-kit/include/kodi/kodi_audioengine_types.h
+BINDINGS+=xbmc/addons/kodi-addon-dev-kit/include/kodi/xbmc_audioenc_dll.h
+BINDINGS+=xbmc/addons/kodi-addon-dev-kit/include/kodi/xbmc_audioenc_types.h
+BINDINGS+=xbmc/addons/kodi-addon-dev-kit/include/kodi/kodi_audiodec_dll.h
+BINDINGS+=xbmc/addons/kodi-addon-dev-kit/include/kodi/kodi_audiodec_types.h
+BINDINGS+=xbmc/addons/kodi-addon-dev-kit/include/kodi/xbmc_codec_types.h
+BINDINGS+=xbmc/addons/kodi-addon-dev-kit/include/kodi/xbmc_epg_types.h
+BINDINGS+=xbmc/addons/kodi-addon-dev-kit/include/kodi/kodi_inputstream_dll.h
+BINDINGS+=xbmc/addons/kodi-addon-dev-kit/include/kodi/kodi_inputstream_types.h
+BINDINGS+=xbmc/addons/kodi-addon-dev-kit/include/kodi/xbmc_pvr_dll.h
+BINDINGS+=xbmc/addons/kodi-addon-dev-kit/include/kodi/xbmc_pvr_types.h
+BINDINGS+=xbmc/addons/kodi-addon-dev-kit/include/kodi/xbmc_scr_dll.h
+BINDINGS+=xbmc/addons/kodi-addon-dev-kit/include/kodi/xbmc_scr_types.h
+BINDINGS+=xbmc/addons/kodi-addon-dev-kit/include/kodi/xbmc_vis_dll.h
+BINDINGS+=xbmc/addons/kodi-addon-dev-kit/include/kodi/xbmc_vis_types.h
+BINDINGS+=xbmc/addons/kodi-addon-dev-kit/include/kodi/xbmc_stream_utils.hpp
+BINDINGS+=xbmc/addons/kodi-addon-dev-kit/include/kodi/libXBMC_addon.h
+BINDINGS+=xbmc/addons/kodi-addon-dev-kit/include/kodi/libKODI_adsp.h
+BINDINGS+=xbmc/addons/kodi-addon-dev-kit/include/kodi/libKODI_audioengine.h
+BINDINGS+=xbmc/addons/kodi-addon-dev-kit/include/kodi/libKODI_guilib.h
+BINDINGS+=xbmc/addons/kodi-addon-dev-kit/include/kodi/libXBMC_pvr.h
+BINDINGS+=xbmc/addons/kodi-addon-dev-kit/include/kodi/libXBMC_codec.h
+BINDINGS+=xbmc/addons/kodi-addon-dev-kit/include/kodi/libKODI_inputstream.h
+BINDINGS+=xbmc/cores/VideoPlayer/DVDDemuxers/DVDDemuxPacket.h
 BINDINGS+=xbmc/cores/AudioEngine/Utils/AEChannelData.h
+BINDINGS+=xbmc/filesystem/IFileTypes.h
diff --git a/xbmc/addons/kodi-addon-dev-kit/include/kodi/kodi_adsp_dll.h b/xbmc/addons/kodi-addon-dev-kit/include/kodi/kodi_adsp_dll.h
new file mode 100644
index 0000000..c1d8238
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/include/kodi/kodi_adsp_dll.h
@@ -0,0 +1,564 @@
+#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/>.
+ *
+ */
+
+/*!
+ * @file kodi_adsp_dll.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
+ * GetAddonCapabilities(...), further the addon must register his available
+ * modes on startup with the RegisterMode(...) callback function (see
+ * libKODI_adsp.h). 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.
+ */
+
+#include "xbmc_addon_dll.h"
+#include "kodi_adsp_types.h"
+
+/*!
+ * Functions that the Audio DSP add-on must implement, but some can be empty.
+ *
+ * The 'remarks' field indicates which methods should be implemented, and which
+ * ones are optional.
+ */
+
+extern "C"
+{
+  /*! @name Audio DSP add-on methods */
+  //@{
+  /*!
+   * Get the KODI_AE_DSP_API_VERSION that was used to compile this add-on.
+   * Used to check if this add-on is compatible with KODI.
+   * @return The KODI_AE_DSP_API_VERSION that was used to compile this add-on.
+   * @remarks Valid implementation required.
+   */
+  const char* GetAudioDSPAPIVersion(void);
+
+  /*!
+   * Get the KODI_AE_DSP_MIN_API_VERSION that was used to compile this add-on.
+   * Used to check if this add-on is compatible with KODI.
+   * @return The KODI_AE_DSP_MIN_API_VERSION that was used to compile this add-on.
+   * @remarks Valid implementation required.
+   */
+  const char* GetMinimumAudioDSPAPIVersion(void);
+
+  /*!
+   * @brief Get the KODI_GUI_API_VERSION that was used to compile this add-on.
+   * Used to check if this add-on is compatible with KODI.
+   * @return The KODI_GUI_API_VERSION that was used to compile this add-on.
+   * @remarks Valid implementation required.
+   */
+  const char* GetGUIAPIVersion(void);
+
+  /*!
+   * @brief Get the KODI_GUI_MIN_API_VERSION that was used to compile this
+   * add-on.
+   * Used to check if this add-on is compatible with KODI.
+   * @return The KODI_GUI_MIN_API_VERSION that was used to compile this add-on.
+   * @remarks Valid implementation required.
+   */
+  const char* GetMinimumGUIAPIVersion(void);
+
+  /*!
+   * @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 pCapabilities The add-ons capabilities.
+   * @return AE_DSP_ERROR_NO_ERROR if the properties were fetched successfully.
+   * @remarks Valid implementation required.
+   */
+  AE_DSP_ERROR GetAddonCapabilities(AE_DSP_ADDON_CAPABILITIES *pCapabilities);
+
+  /*!
+   * @return The name reported by the back end that will be displayed in the
+   * UI.
+   * @remarks Valid implementation required.
+   */
+  const char* GetDSPName(void);
+
+  /*!
+   * @return The version string reported by the back end that will be displayed
+   * in the UI.
+   * @remarks Valid implementation required.
+   */
+  const char* GetDSPVersion(void);
+
+  /*!
+   * @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.
+   */
+  AE_DSP_ERROR CallMenuHook(const AE_DSP_MENUHOOK& menuhook, const AE_DSP_MENUHOOK_DATA &item);
+  //@}
+
+  /** @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 pProperties 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.
+   */
+  AE_DSP_ERROR StreamCreate(const AE_DSP_SETTINGS *addonSettings, const AE_DSP_STREAM_PROPERTIES* pProperties, ADDON_HANDLE handle);
+
+  /*!
+   * 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.
+   */
+  AE_DSP_ERROR StreamDestroy(const ADDON_HANDLE handle);
+
+  /*!
+   * @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.
+   */
+  AE_DSP_ERROR StreamIsModeSupported(const ADDON_HANDLE handle, AE_DSP_MODE_TYPE type, unsigned int mode_id, int unique_db_mode_id);
+
+  /*!
+   * @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.
+   */
+  AE_DSP_ERROR StreamInitialize(const ADDON_HANDLE handle, const AE_DSP_SETTINGS *addonSettings);
+  //@}
+
+  /** @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
+   * GetAddonCapabilities
+   */
+  bool InputProcess(const ADDON_HANDLE handle, const float **array_in, unsigned int samples);
+  //@}
+
+  /** @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
+   * GetAddonCapabilities
+   */
+  unsigned int InputResampleProcessNeededSamplesize(const ADDON_HANDLE handle);
+
+  /*!
+   * @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
+   * GetAddonCapabilities
+   */
+  unsigned int InputResampleProcess(const ADDON_HANDLE handle, float **array_in, float **array_out, unsigned int samples);
+
+  /*!
+   * @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
+   * GetAddonCapabilities
+   */
+  int InputResampleSampleRate(const ADDON_HANDLE handle);
+
+  /*!
+   * @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
+   * GetAddonCapabilities
+   */
+  float InputResampleGetDelay(const ADDON_HANDLE handle);
+  //@}
+
+  /** @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
+   * GetAddonCapabilities
+   */
+  unsigned int PreProcessNeededSamplesize(const ADDON_HANDLE handle, unsigned int mode_id);
+
+  /*!
+   * @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
+   * GetAddonCapabilities
+   */
+  float PreProcessGetDelay(const ADDON_HANDLE handle, unsigned int mode_id);
+
+  /*!
+   * @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
+   * GetAddonCapabilities
+   */
+  unsigned int PreProcess(const ADDON_HANDLE handle, unsigned int mode_id, float **array_in, float **array_out, unsigned int samples);
+  //@}
+
+  /** @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
+   * GetAddonCapabilities
+   */
+  AE_DSP_ERROR MasterProcessSetMode(const ADDON_HANDLE handle, AE_DSP_STREAMTYPE type, unsigned int mode_id, int unique_db_mode_id);
+
+  /*!
+   * @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
+   * GetAddonCapabilities
+   */
+  unsigned int MasterProcessNeededSamplesize(const ADDON_HANDLE handle);
+
+  /*!
+   * @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
+   * GetAddonCapabilities
+   */
+  float MasterProcessGetDelay(const ADDON_HANDLE handle);
+
+  /*!
+   * @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
+   */
+  int MasterProcessGetOutChannels(const ADDON_HANDLE handle, unsigned long &out_channel_present_flags);
+
+  /*!
+   * @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
+   * GetAddonCapabilities
+   */
+  unsigned int MasterProcess(const ADDON_HANDLE handle, float **array_in, float **array_out, unsigned int samples);
+
+  /*!
+   * 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
+   * GetAddonCapabilities
+   */
+  const char *MasterProcessGetStreamInfoString(const ADDON_HANDLE handle);
+  //@}
+
+  /** @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
+   * GetAddonCapabilities
+   */
+  unsigned int PostProcessNeededSamplesize(const ADDON_HANDLE handle, unsigned int mode_id);
+
+  /*!
+   * 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
+   * GetAddonCapabilities
+   */
+  float PostProcessGetDelay(const ADDON_HANDLE handle, unsigned int mode_id);
+
+  /*!
+   * @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
+   * GetAddonCapabilities
+   */
+  unsigned int PostProcess(const ADDON_HANDLE handle, unsigned int mode_id, float **array_in, float **array_out, unsigned int samples);
+  //@}
+
+  /** @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
+   * GetAddonCapabilities
+   */
+  unsigned int OutputResampleProcessNeededSamplesize(const ADDON_HANDLE handle);
+
+  /*!
+   * @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
+   * GetAddonCapabilities
+   */
+  unsigned int OutputResampleProcess(const ADDON_HANDLE handle, float **array_in, float **array_out, unsigned int samples);
+
+  /*!
+   * @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
+   * GetAddonCapabilities
+   */
+  int OutputResampleSampleRate(const ADDON_HANDLE handle);
+
+  /*!
+   * @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
+   * GetAddonCapabilities
+   */
+  float OutputResampleGetDelay(const ADDON_HANDLE handle);
+  //@}
+
+  // function to export the above structure to KODI
+  void __declspec(dllexport) get_addon(struct AudioDSP* pDSP)
+  {
+    pDSP->GetAudioDSPAPIVersion                 = GetAudioDSPAPIVersion;
+    pDSP->GetMinimumAudioDSPAPIVersion          = GetMinimumAudioDSPAPIVersion;
+    pDSP->GetGUIAPIVersion                      = GetGUIAPIVersion;
+    pDSP->GetMinimumGUIAPIVersion               = GetMinimumGUIAPIVersion;
+    pDSP->GetAddonCapabilities                  = GetAddonCapabilities;
+    pDSP->GetDSPName                            = GetDSPName;
+    pDSP->GetDSPVersion                         = GetDSPVersion;
+    pDSP->MenuHook                              = CallMenuHook;
+
+    pDSP->StreamCreate                          = StreamCreate;
+    pDSP->StreamDestroy                         = StreamDestroy;
+    pDSP->StreamIsModeSupported                 = StreamIsModeSupported;
+    pDSP->StreamInitialize                      = StreamInitialize;
+
+    pDSP->InputProcess                          = InputProcess;
+
+    pDSP->InputResampleProcessNeededSamplesize  = InputResampleProcessNeededSamplesize;
+    pDSP->InputResampleProcess                  = InputResampleProcess;
+    pDSP->InputResampleGetDelay                 = InputResampleGetDelay;
+    pDSP->InputResampleSampleRate               = InputResampleSampleRate;
+
+    pDSP->PreProcessNeededSamplesize            = PreProcessNeededSamplesize;
+    pDSP->PreProcessGetDelay                    = PreProcessGetDelay;
+    pDSP->PreProcess                            = PreProcess;
+
+    pDSP->MasterProcessSetMode                  = MasterProcessSetMode;
+    pDSP->MasterProcessNeededSamplesize         = MasterProcessNeededSamplesize;
+    pDSP->MasterProcessGetDelay                 = MasterProcessGetDelay;
+    pDSP->MasterProcessGetOutChannels           = MasterProcessGetOutChannels;
+    pDSP->MasterProcess                         = MasterProcess;
+    pDSP->MasterProcessGetStreamInfoString      = MasterProcessGetStreamInfoString;
+
+    pDSP->PostProcessNeededSamplesize           = PostProcessNeededSamplesize;
+    pDSP->PostProcessGetDelay                   = PostProcessGetDelay;
+    pDSP->PostProcess                           = PostProcess;
+
+    pDSP->OutputResampleProcessNeededSamplesize = OutputResampleProcessNeededSamplesize;
+    pDSP->OutputResampleProcess                 = OutputResampleProcess;
+    pDSP->OutputResampleSampleRate              = OutputResampleSampleRate;
+    pDSP->OutputResampleGetDelay                = OutputResampleGetDelay;
+  };
+};
+
diff --git a/xbmc/addons/kodi-addon-dev-kit/include/kodi/kodi_adsp_types.h b/xbmc/addons/kodi-addon-dev-kit/include/kodi/kodi_adsp_types.h
new file mode 100644
index 0000000..6e492c8
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/include/kodi/kodi_adsp_types.h
@@ -0,0 +1,524 @@
+#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/>.
+ *
+ */
+
+/*!
+ * Common data structures shared between KODI and KODI's audio DSP add-ons
+ */
+
+#ifdef TARGET_WINDOWS
+#include <windows.h>
+#else
+#ifndef __cdecl
+#define __cdecl
+#endif
+#ifndef __declspec
+#define __declspec(X)
+#endif
+#endif
+
+#include <cstddef>
+
+#include "xbmc_addon_types.h"
+#include "xbmc_codec_types.h"
+
+#undef ATTRIBUTE_PACKED
+#undef PRAGMA_PACK_BEGIN
+#undef PRAGMA_PACK_END
+
+#if defined(__GNUC__)
+#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
+#define ATTRIBUTE_PACKED __attribute__ ((packed))
+#define PRAGMA_PACK 0
+#endif
+#endif
+
+#if !defined(ATTRIBUTE_PACKED)
+#define ATTRIBUTE_PACKED
+#define PRAGMA_PACK 1
+#endif
+
+#define AE_DSP_ADDON_STRING_LENGTH              1024
+
+#define AE_DSP_STREAM_MAX_STREAMS               8
+#define AE_DSP_STREAM_MAX_MODES                 32
+
+/* current Audio DSP API version */
+#define KODI_AE_DSP_API_VERSION                 "0.1.8"
+
+/* min. Audio DSP API version */
+#define KODI_AE_DSP_MIN_API_VERSION             "0.1.8"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+  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<<0,
+    AE_DSP_PRSNT_CH_FR        = 1<<1,
+    AE_DSP_PRSNT_CH_FC        = 1<<2,
+    AE_DSP_PRSNT_CH_LFE       = 1<<3,
+    AE_DSP_PRSNT_CH_BL        = 1<<4,
+    AE_DSP_PRSNT_CH_BR        = 1<<5,
+    AE_DSP_PRSNT_CH_FLOC      = 1<<6,
+    AE_DSP_PRSNT_CH_FROC      = 1<<7,
+    AE_DSP_PRSNT_CH_BC        = 1<<8,
+    AE_DSP_PRSNT_CH_SL        = 1<<9,
+    AE_DSP_PRSNT_CH_SR        = 1<<10,
+    AE_DSP_PRSNT_CH_TFL       = 1<<11,
+    AE_DSP_PRSNT_CH_TFR       = 1<<12,
+    AE_DSP_PRSNT_CH_TFC       = 1<<13,
+    AE_DSP_PRSNT_CH_TC        = 1<<14,
+    AE_DSP_PRSNT_CH_TBL       = 1<<15,
+    AE_DSP_PRSNT_CH_TBR       = 1<<16,
+    AE_DSP_PRSNT_CH_TBC       = 1<<17,
+    AE_DSP_PRSNT_CH_BLOC      = 1<<18,
+    AE_DSP_PRSNT_CH_BROC      = 1<<19
+  } 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<<0,
+    AE_DSP_PRSNT_ASTREAM_MUSIC    = 1<<1,
+    AE_DSP_PRSNT_ASTREAM_MOVIE    = 1<<2,
+    AE_DSP_PRSNT_ASTREAM_GAME     = 1<<3,
+    AE_DSP_PRSNT_ASTREAM_APP      = 1<<4,
+    AE_DSP_PRSNT_ASTREAM_MESSAGE  = 1<<5,
+    AE_DSP_PRSNT_ASTREAM_PHONE    = 1<<6,
+  } 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 Properties passed to the Create() method of an add-on.
+   */
+  typedef struct AE_DSP_PROPERTIES
+  {
+    const char* strUserPath;                    /*!< @brief path to the user profile */
+    const char* strAddonPath;                   /*!< @brief path to this add-on */
+  } AE_DSP_PROPERTIES;
+
+  /*!
+   * @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[AE_DSP_ADDON_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[AE_DSP_ADDON_STRING_LENGTH];      /*!< @brief (optional) flag image for the mode */
+      char              strOverrideModeImage[AE_DSP_ADDON_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 Structure to transfer the methods from kodi_audiodsp_dll.h to KODI
+   */
+  struct AudioDSP
+  {
+    const char*  (__cdecl* GetAudioDSPAPIVersion)                (void);
+    const char*  (__cdecl* GetMinimumAudioDSPAPIVersion)         (void);
+    const char*  (__cdecl* GetGUIAPIVersion)                     (void);
+    const char*  (__cdecl* GetMinimumGUIAPIVersion)              (void);
+    AE_DSP_ERROR (__cdecl* GetAddonCapabilities)                 (AE_DSP_ADDON_CAPABILITIES*);
+    const char*  (__cdecl* GetDSPName)                           (void);
+    const char*  (__cdecl* GetDSPVersion)                        (void);
+    AE_DSP_ERROR (__cdecl* MenuHook)                             (const AE_DSP_MENUHOOK&, const AE_DSP_MENUHOOK_DATA&);
+
+    AE_DSP_ERROR (__cdecl* StreamCreate)                         (const AE_DSP_SETTINGS*, const AE_DSP_STREAM_PROPERTIES*, ADDON_HANDLE);
+    AE_DSP_ERROR (__cdecl* StreamDestroy)                        (const ADDON_HANDLE);
+    AE_DSP_ERROR (__cdecl* StreamIsModeSupported)                (const ADDON_HANDLE, AE_DSP_MODE_TYPE, unsigned int, int);
+    AE_DSP_ERROR (__cdecl* StreamInitialize)                     (const ADDON_HANDLE, const AE_DSP_SETTINGS*);
+
+    bool         (__cdecl* InputProcess)                         (const ADDON_HANDLE, const float**, unsigned int);
+
+    unsigned int (__cdecl* InputResampleProcessNeededSamplesize) (const ADDON_HANDLE);
+    unsigned int (__cdecl* InputResampleProcess)                 (const ADDON_HANDLE, float**, float**, unsigned int);
+    float        (__cdecl* InputResampleGetDelay)                (const ADDON_HANDLE);
+    int          (__cdecl* InputResampleSampleRate)              (const ADDON_HANDLE);
+
+    unsigned int (__cdecl* PreProcessNeededSamplesize)           (const ADDON_HANDLE, unsigned int);
+    float        (__cdecl* PreProcessGetDelay)                   (const ADDON_HANDLE, unsigned int);
+    unsigned int (__cdecl* PreProcess)                           (const ADDON_HANDLE, unsigned int, float**, float**, unsigned int);
+
+    AE_DSP_ERROR (__cdecl* MasterProcessSetMode)                 (const ADDON_HANDLE, AE_DSP_STREAMTYPE, unsigned int, int);
+    unsigned int (__cdecl* MasterProcessNeededSamplesize)        (const ADDON_HANDLE);
+    float        (__cdecl* MasterProcessGetDelay)                (const ADDON_HANDLE);
+    int          (__cdecl* MasterProcessGetOutChannels)          (const ADDON_HANDLE, unsigned long&);
+    unsigned int (__cdecl* MasterProcess)                        (const ADDON_HANDLE, float**, float**, unsigned int);
+    const char*  (__cdecl* MasterProcessGetStreamInfoString)     (const ADDON_HANDLE);
+
+    unsigned int (__cdecl* PostProcessNeededSamplesize)          (const ADDON_HANDLE, unsigned int);
+    float        (__cdecl* PostProcessGetDelay)                  (const ADDON_HANDLE, unsigned int);
+    unsigned int (__cdecl* PostProcess)                          (const ADDON_HANDLE, unsigned int, float**, float**, unsigned int);
+
+    unsigned int (__cdecl* OutputResampleProcessNeededSamplesize)(const ADDON_HANDLE);
+    unsigned int (__cdecl* OutputResampleProcess)                (const ADDON_HANDLE, float**, float**, unsigned int);
+    float        (__cdecl* OutputResampleGetDelay)               (const ADDON_HANDLE);
+    int          (__cdecl* OutputResampleSampleRate)             (const ADDON_HANDLE);
+  };
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/xbmc/addons/include/kodi_audiodec_dll.h b/xbmc/addons/kodi-addon-dev-kit/include/kodi/kodi_audiodec_dll.h
index 78bc3cc..78bc3cc 100644
--- a/xbmc/addons/include/kodi_audiodec_dll.h
+++ b/xbmc/addons/kodi-addon-dev-kit/include/kodi/kodi_audiodec_dll.h
diff --git a/xbmc/addons/include/kodi_audiodec_types.h b/xbmc/addons/kodi-addon-dev-kit/include/kodi/kodi_audiodec_types.h
index 50c4cc4..82d71e5 100644
--- a/xbmc/addons/include/kodi_audiodec_types.h
+++ b/xbmc/addons/kodi-addon-dev-kit/include/kodi/kodi_audiodec_types.h
@@ -22,7 +22,7 @@
 
 #include <stdint.h>
 #ifdef BUILD_KODI_ADDON
-#include "kodi/AEChannelData.h"
+#include "AEChannelData.h"
 #else
 #include "cores/AudioEngine/Utils/AEChannelData.h"
 #endif
diff --git a/xbmc/addons/kodi-addon-dev-kit/include/kodi/kodi_audioengine_types.h b/xbmc/addons/kodi-addon-dev-kit/include/kodi/kodi_audioengine_types.h
new file mode 100644
index 0000000..0402ace
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/include/kodi/kodi_audioengine_types.h
@@ -0,0 +1,165 @@
+#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/>.
+ *
+ */
+
+/*!
+ * Common data structures shared between KODI and KODI's binary add-ons
+ */
+
+#ifdef BUILD_KODI_ADDON
+  #include "kodi/AudioEngine/AEChannelInfo.h"
+#else
+  #include "cores/AudioEngine/Utils/AEChannelInfo.h"
+#endif
+
+#ifdef TARGET_WINDOWS
+#include <windows.h>
+#else
+#ifndef __cdecl
+#define __cdecl
+#endif
+#ifndef __declspec
+#define __declspec(X)
+#endif
+#endif
+
+#include <cstddef>
+
+#undef ATTRIBUTE_PACKED
+#undef PRAGMA_PACK_BEGIN
+#undef PRAGMA_PACK_END
+
+#if defined(__GNUC__)
+#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
+#define ATTRIBUTE_PACKED __attribute__ ((packed))
+#define PRAGMA_PACK 0
+#endif
+#endif
+
+#if !defined(ATTRIBUTE_PACKED)
+#define ATTRIBUTE_PACKED
+#define PRAGMA_PACK 1
+#endif
+
+/* current Audio DSP API version */
+#define KODI_AUDIOENGINE_API_VERSION                 "0.0.1"
+
+/* min. Audio DSP API version */
+#define KODI_AUDIOENGINE_MIN_API_VERSION             "0.0.1"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+  /**
+   * A stream handle pointer, which is only used internally by the addon stream handle
+   */
+  typedef void AEStreamHandle;
+
+  /**
+   * The audio format structure that fully defines a stream's audio information
+   */
+  typedef struct AudioEngineFormat
+  {
+    /**
+     * The stream's data format (eg, AE_FMT_S16LE)
+     */
+    enum AEDataFormat m_dataFormat;
+
+    /**
+     * The stream's sample rate (eg, 48000)
+     */
+    unsigned int m_sampleRate;
+
+    /**
+     * The encoded streams sample rate if a bitstream, otherwise undefined
+     */
+    unsigned int m_encodedRate;
+
+    /**
+     * The amount of used speaker channels
+     */
+    unsigned int   m_channelCount;
+
+    /**
+     * The stream's channel layout
+     */
+    enum AEChannel m_channels[AE_CH_MAX];
+
+    /**
+     * The number of frames per period
+     */
+    unsigned int m_frames;
+
+    /**
+     * The size of one frame in bytes
+     */
+    unsigned int m_frameSize;
+
+    AudioEngineFormat()
+    {
+      m_dataFormat = AE_FMT_INVALID;
+      m_sampleRate = 0;
+      m_encodedRate = 0;
+      m_frames = 0;
+      m_frameSize = 0;
+      m_channelCount = 0;
+
+      for (unsigned int ch = 0; ch < AE_CH_MAX; ch++)
+      {
+        m_channels[ch] = AE_CH_NULL;
+      }
+    }
+
+    bool compareFormat(const AudioEngineFormat *fmt)
+    {
+      if (!fmt)
+      {
+        return false;
+      }
+
+      if (m_dataFormat    != fmt->m_dataFormat    ||
+          m_sampleRate    != fmt->m_sampleRate    ||
+          m_encodedRate   != fmt->m_encodedRate   ||
+          m_frames        != fmt->m_frames        ||
+          m_frameSize     != fmt->m_frameSize     ||
+          m_channelCount  != fmt->m_channelCount)
+      {
+        return false;
+      }
+      
+      for (unsigned int ch = 0; ch < AE_CH_MAX; ch++)
+      {
+        if (fmt->m_channels[ch] != m_channels[ch])
+        {
+          return false;
+        }
+      }
+
+      return  true;
+    }
+  } AudioEngineFormat;
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/xbmc/addons/kodi-addon-dev-kit/include/kodi/kodi_inputstream_dll.h b/xbmc/addons/kodi-addon-dev-kit/include/kodi/kodi_inputstream_dll.h
new file mode 100644
index 0000000..6ecf566
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/include/kodi/kodi_inputstream_dll.h
@@ -0,0 +1,257 @@
+#pragma once
+
+/*
+*      Copyright (C) 2005-2016 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 "kodi_inputstream_types.h"
+#include "xbmc_addon_dll.h"
+
+/*!
+* Functions that the InputStream client add-on must implement, but some can be empty.
+*
+* The 'remarks' field indicates which methods should be implemented, and which ones are optional.
+*/
+
+extern "C"
+{
+  /*!
+   * Open a stream.
+   * @param props
+   * @return True if the stream has been opened successfully, false otherwise.
+   * @remarks
+   */
+  bool Open(INPUTSTREAM& props);
+
+  /*!
+   * Close an open stream.
+   * @remarks
+   */
+  void Close(void);
+
+  /*!
+   * Get path/url for this addon.
+   * @remarks
+   */
+  const char* GetPathList(void);
+
+  /*!
+  * Get Capabilities of this addon.
+  * @remarks
+  */
+  struct INPUTSTREAM_CAPABILITIES GetCapabilities();
+
+
+  /*!
+   * Get IDs of available streams
+   * @remarks
+   */
+  INPUTSTREAM_IDS GetStreamIds();
+
+  /*!
+   * Get stream properties of a stream.
+   * @param streamId unique id of stream
+   * @return struc of stream properties
+   * @remarks
+   */
+  INPUTSTREAM_INFO GetStream(int streamid);
+
+  /*!
+   * 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
+   */
+  void EnableStream(int streamid, bool enable);
+
+  /*!
+  * Enables a stream at the given PTS.
+  * @param streamId unique id of stream
+  * @param pts position in stream in microseconds 
+  * @remarks will only be called if CAPABILITIES::m_supportsEnableAtPTS is set to true
+  */
+  void EnableStreamAtPTS(int streamid, uint64_t pts);
+
+  /*!
+   * Reset the demultiplexer in the add-on.
+   * @remarks Required if bHandlesDemuxing is set to true.
+   */
+  void DemuxReset(void);
+
+  /*!
+   * Abort the demultiplexer thread in the add-on.
+   * @remarks Required if bHandlesDemuxing is set to true.
+   */
+  void DemuxAbort(void);
+
+  /*!
+   * Flush all data that's currently in the demultiplexer buffer in the add-on.
+   * @remarks Required if bHandlesDemuxing is set to true.
+   */
+  void DemuxFlush(void);
+
+  /*!
+   * 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 XBMC'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.
+   */
+  DemuxPacket* DemuxRead(void);
+
+  /*!
+   * Notify the InputStream addon/demuxer that XBMC 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.
+   */
+  bool DemuxSeekTime(int time, bool backwards, double *startpts);
+
+  /*!
+   * Notify the InputStream addon/demuxer that XBMC wishes to change playback speed
+   * @param speed The requested playback speed
+   * @remarks Optional, and only used if addon has its own demuxer.
+   */
+  void DemuxSetSpeed(int speed);
+
+
+  /*!
+   * Totel time in ms
+   * @remarks
+   */
+  int GetTotalTime();
+
+  /*!
+   * Playing time in ms
+   * @remarks
+   */
+  int GetTime();
+
+  /*!
+   * Positions inputstream to playing time given in ms
+   * @remarks
+   */
+  bool PosTime(int ms);
+
+
+  /*!
+   * Check if the backend support pausing the currently playing stream
+   * This will enable/disable the pause button in XBMC based on the return value
+   * @return false if the InputStream addon/backend does not support pausing, true if possible
+   */
+  bool CanPauseStream();
+
+  /*!
+   * Check if the backend supports seeking for the currently playing stream
+   * This will enable/disable the rewind/forward buttons in XBMC based on the return value
+   * @return false if the InputStream addon/backend does not support seeking, true if possible
+   */
+  bool CanSeekStream();
+
+  
+  /*!
+  * Read from an open stream.
+  * @param pBuffer The buffer to store the data in.
+  * @param iBufferSize 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.
+  */
+  int ReadStream(uint8_t* pBuffer, unsigned int iBufferSize);
+
+  /*!
+  * Seek in a stream.
+  * @param iPosition The position to seek to.
+  * @param iWhence ?
+  * @return The new position.
+  * @remarks Return -1 if this add-on won't provide this function.
+  */
+  int64_t SeekStream(int64_t iPosition, int iWhence = SEEK_SET);
+
+  /*!
+  * @return The position in the stream that's currently being read.
+  * @remarks Return -1 if this add-on won't provide this function.
+  */
+  int64_t PositionStream(void);
+
+  /*!
+  * @return The total length of the stream that's currently being read.
+  * @remarks Return -1 if this add-on won't provide this function.
+  */
+  int64_t LengthStream(void);
+
+
+  /*!
+  * @brief Notify the InputStream addon that XBMC (un)paused the currently playing stream
+  */
+  void PauseStream(double time);
+
+
+  /*!
+  *  Check for real-time streaming
+  *  @return true if current stream is real-time
+  */
+  bool IsRealTimeStream();
+
+  /*!
+  * Called by XBMC to assign the function pointers of this add-on to pClient.
+  * @param pClient The struct to assign the function pointers to.
+  */
+  void __declspec(dllexport) get_addon(struct InputStreamAddonFunctions* pClient)
+  {
+    pClient->Open = Open;
+    pClient->Close = Close;
+    pClient->GetPathList = GetPathList;
+    pClient->GetCapabilities = GetCapabilities;
+
+    pClient->GetStreamIds = GetStreamIds;
+    pClient->GetStream = GetStream;
+    pClient->EnableStream = EnableStream;
+    pClient->EnableStreamAtPTS = EnableStreamAtPTS;
+    pClient->DemuxReset = DemuxReset;
+    pClient->DemuxAbort = DemuxAbort;
+    pClient->DemuxFlush = DemuxFlush;
+    pClient->DemuxRead = DemuxRead;
+    pClient->DemuxSeekTime = DemuxSeekTime;
+    pClient->DemuxSetSpeed = DemuxSetSpeed;
+
+    pClient->GetTotalTime = GetTotalTime;
+    pClient->GetTime = GetTime;
+
+    pClient->PosTime = PosTime;
+
+    pClient->CanPauseStream = CanPauseStream;
+    pClient->CanSeekStream = CanSeekStream;
+
+    pClient->ReadStream = ReadStream;
+    pClient->SeekStream = SeekStream;
+    pClient->PositionStream = PositionStream;
+    pClient->LengthStream = LengthStream;
+    pClient->PauseStream = PauseStream;
+    pClient->IsRealTimeStream = IsRealTimeStream;
+  };
+};
diff --git a/xbmc/addons/kodi-addon-dev-kit/include/kodi/kodi_inputstream_types.h b/xbmc/addons/kodi-addon-dev-kit/include/kodi/kodi_inputstream_types.h
new file mode 100644
index 0000000..33741d8
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/include/kodi/kodi_inputstream_types.h
@@ -0,0 +1,161 @@
+#pragma once
+
+/*
+ *      Copyright (C) 2005-2016 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/>.
+ *
+ */
+
+#ifndef __cdecl
+#define __cdecl
+#endif
+
+#ifdef BUILD_KODI_ADDON
+#include "DVDDemuxPacket.h"
+#else
+#include "cores/VideoPlayer/DVDDemuxers/DVDDemuxPacket.h"
+#endif
+
+extern "C" {
+
+  // this are properties given to the addon on create
+  // at this time we have no parameters for the addon
+  typedef struct INPUTSTREAM_PROPS
+  {
+    int dummy;
+  } INPUTSTREAM_PROPS;
+
+  /*!
+   * @brief InputStream add-on capabilities. All capabilities are set to "false" as default.
+   */
+  typedef struct INPUTSTREAM_CAPABILITIES
+  {
+    bool m_supportsIDemux;                  /*!< @brief supports interface IDemux */
+    bool m_supportsIPosTime;                /*!< @brief supports interface IPosTime */
+    bool m_supportsIDisplayTime;            /*!< @brief supports interface IDisplayTime */
+    bool m_supportsSeek;                    /*!< @brief supports seek */
+    bool m_supportsPause;                   /*!< @brief supports pause */
+    bool m_supportsEnableAtPTS;             /*!< @brief supports enabling streams at a given PTS time */
+  } 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];
+  } 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;
+
+    char m_codecName[32];                /*!< @brief (required) name of codec according to ffmpeg */
+    char m_codecInternalName[32];        /*!< @brief (optional) internal name of codec (selectionstream info) */
+    unsigned int m_pID;                  /*!< @brief (required) physical index */
+    unsigned int m_Bandwidth;            /*!< @brief (optional) bandwidth of the stream (selectionstream info) */
+
+    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;
+  } INPUTSTREAM_INFO;
+
+  /*!
+   * @brief Structure to transfer the methods from xbmc_inputstream_dll.h to XBMC
+   */
+  typedef struct InputStreamAddonFunctions
+  {
+    bool (__cdecl* Open)(INPUTSTREAM&);
+    void (__cdecl* Close)(void);
+    const char* (__cdecl* GetPathList)(void);
+    struct INPUTSTREAM_CAPABILITIES (__cdecl* GetCapabilities)(void);
+
+    // IDemux
+    struct INPUTSTREAM_IDS (__cdecl* GetStreamIds)();
+    struct INPUTSTREAM_INFO (__cdecl* GetStream)(int);
+    void (__cdecl* EnableStream)(int, bool);
+    void (__cdecl* EnableStreamAtPTS)(int, uint64_t);
+    void (__cdecl* DemuxReset)(void);
+    void (__cdecl* DemuxAbort)(void);
+    void (__cdecl* DemuxFlush)(void);
+    DemuxPacket* (__cdecl* DemuxRead)(void);
+    bool (__cdecl* DemuxSeekTime)(int, bool, double*);
+    void (__cdecl* DemuxSetSpeed)(int);
+
+    // IDisplayTime
+    int (__cdecl* GetTotalTime)(void);
+    int (__cdecl* GetTime)(void);
+
+    // IPosTime
+    bool (__cdecl* PosTime)(int);
+
+    // Seekable (mandatory)
+    bool (__cdecl* CanPauseStream)(void);
+    bool (__cdecl* CanSeekStream)(void);
+
+    int (__cdecl* ReadStream)(uint8_t*, unsigned int);
+    int64_t(__cdecl* SeekStream)(int64_t, int);
+    int64_t (__cdecl* PositionStream)(void);
+    int64_t (__cdecl* LengthStream)(void);
+    void (__cdecl* PauseStream)(double);
+    bool (__cdecl* IsRealTimeStream)(void);
+  } InputStreamAddonFunctions;
+}
+
+
diff --git a/xbmc/addons/kodi-addon-dev-kit/include/kodi/libKODI_adsp.h b/xbmc/addons/kodi-addon-dev-kit/include/kodi/libKODI_adsp.h
new file mode 100644
index 0000000..46e34a6
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/include/kodi/libKODI_adsp.h
@@ -0,0 +1,232 @@
+#pragma once
+/*
+ *      Copyright (C) 2005-2014 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 <string>
+#include <vector>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include "kodi_adsp_types.h"
+#include "libXBMC_addon.h"
+
+typedef void* ADSPHANDLE;
+
+#ifdef _WIN32
+#define ADSP_HELPER_DLL "\\library.kodi.adsp\\libKODI_adsp" ADDON_HELPER_EXT
+#else
+#define ADSP_HELPER_DLL_NAME "libKODI_adsp-" ADDON_HELPER_ARCH ADDON_HELPER_EXT
+#define ADSP_HELPER_DLL "/library.kodi.adsp/" ADSP_HELPER_DLL_NAME
+#endif
+
+class CAddonSoundPlay;
+
+class CHelper_libKODI_adsp
+{
+public:
+  CHelper_libKODI_adsp(void)
+  {
+    m_libKODI_adsp = NULL;
+    m_Handle      = NULL;
+  }
+
+  ~CHelper_libKODI_adsp(void)
+  {
+    if (m_libKODI_adsp)
+    {
+      ADSP_unregister_me(m_Handle, m_Callbacks);
+      dlclose(m_libKODI_adsp);
+    }
+  }
+
+  /*!
+   * @brief Resolve all callback methods
+   * @param handle Pointer to the add-on
+   * @return True when all methods were resolved, false otherwise.
+   */
+  bool RegisterMe(void* handle)
+  {
+    m_Handle = handle;
+
+    std::string libBasePath;
+    libBasePath  = ((cb_array*)m_Handle)->libPath;
+    libBasePath += ADSP_HELPER_DLL;
+
+#if defined(ANDROID)
+      struct stat st;
+      if(stat(libBasePath.c_str(),&st) != 0)
+      {
+        std::string tempbin = getenv("XBMC_ANDROID_LIBS");
+        libBasePath = tempbin + "/" + ADSP_HELPER_DLL_NAME;
+      }
+#endif
+
+    m_libKODI_adsp = dlopen(libBasePath.c_str(), RTLD_LAZY);
+    if (m_libKODI_adsp == NULL)
+    {
+      fprintf(stderr, "Unable to load %s\n", dlerror());
+      return false;
+    }
+
+    ADSP_register_me = (void* (*)(void *HANDLE))
+      dlsym(m_libKODI_adsp, "ADSP_register_me");
+    if (ADSP_register_me == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    ADSP_unregister_me = (void (*)(void* HANDLE, void* CB))
+      dlsym(m_libKODI_adsp, "ADSP_unregister_me");
+    if (ADSP_unregister_me == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    ADSP_add_menu_hook = (void (*)(void* HANDLE, void* CB, AE_DSP_MENUHOOK *hook))
+      dlsym(m_libKODI_adsp, "ADSP_add_menu_hook");
+    if (ADSP_add_menu_hook == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    ADSP_remove_menu_hook = (void (*)(void* HANDLE, void* CB, AE_DSP_MENUHOOK *hook))
+      dlsym(m_libKODI_adsp, "ADSP_remove_menu_hook");
+    if (ADSP_remove_menu_hook == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    ADSP_register_mode = (void (*)(void *HANDLE, void* CB, AE_DSP_MODES::AE_DSP_MODE *modes))
+      dlsym(m_libKODI_adsp, "ADSP_register_mode");
+    if (ADSP_register_mode == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    ADSP_unregister_mode = (void (*)(void* HANDLE, void* CB, AE_DSP_MODES::AE_DSP_MODE *modes))
+      dlsym(m_libKODI_adsp, "ADSP_unregister_mode");
+    if (ADSP_unregister_mode == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    ADSP_get_sound_play = (CAddonSoundPlay* (*)(void *HANDLE, void *CB, const char *filename))
+      dlsym(m_libKODI_adsp, "ADSP_get_sound_play");
+    if (ADSP_get_sound_play == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    ADSP_release_sound_play = (void (*)(CAddonSoundPlay* p))
+      dlsym(m_libKODI_adsp, "ADSP_release_sound_play");
+    if (ADSP_release_sound_play == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    m_Callbacks = ADSP_register_me(m_Handle);
+    return m_Callbacks != NULL;
+  }
+
+  /*!
+   * @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 ADSP_add_menu_hook(m_Handle, m_Callbacks, 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 ADSP_remove_menu_hook(m_Handle, m_Callbacks, 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 ADSP_register_mode(m_Handle, m_Callbacks, 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 ADSP_unregister_mode(m_Handle, m_Callbacks, mode);
+  }
+
+  /*!
+   * @brief Open a sound playing class
+   * @param filename The wav filename to open
+   */
+  CAddonSoundPlay* GetSoundPlay(const char *filename)
+  {
+    return ADSP_get_sound_play(m_Handle, m_Callbacks, filename);
+  }
+
+  /*!
+   * @brief Remove a played file class
+   * @param p The playback to remove
+   */
+  void ReleaseSoundPlay(CAddonSoundPlay* p)
+  {
+    return ADSP_release_sound_play(p);
+  }
+
+protected:
+  void* (*ADSP_register_me)(void*);
+
+  void (*ADSP_unregister_me)(void*, void*);
+  void (*ADSP_add_menu_hook)(void*, void*, AE_DSP_MENUHOOK*);
+  void (*ADSP_remove_menu_hook)(void*, void*, AE_DSP_MENUHOOK*);
+  void (*ADSP_register_mode)(void*, void*, AE_DSP_MODES::AE_DSP_MODE*);
+  void (*ADSP_unregister_mode)(void*, void*, AE_DSP_MODES::AE_DSP_MODE*);
+  CAddonSoundPlay* (*ADSP_get_sound_play)(void*, void*, const char *);
+  void (*ADSP_release_sound_play)(CAddonSoundPlay*);
+
+private:
+  void* m_libKODI_adsp;
+  void* m_Handle;
+  void* m_Callbacks;
+  struct cb_array
+  {
+    const char* libPath;
+  };
+};
+
+class CAddonSoundPlay
+{
+public:
+  CAddonSoundPlay(void *hdl, void *cb, const char *filename);
+  virtual ~CAddonSoundPlay();
+
+  /*! play the sound this object represents */
+  virtual void Play();
+
+  /*! stop playing the sound this object represents */
+  virtual void Stop();
+
+  /*! return true if the sound is currently playing */
+  virtual bool IsPlaying();
+
+  /*! set the playback channel position of this sound, AE_DSP_CH_INVALID for all */
+  virtual void SetChannel(AE_DSP_CHANNEL channel);
+
+  /*! get the current playback volume of this sound, AE_DSP_CH_INVALID for all */
+  virtual AE_DSP_CHANNEL GetChannel();
+
+  /*! set the playback volume of this sound */
+  virtual void SetVolume(float volume);
+
+  /*! get the current playback volume of this sound */
+  virtual float GetVolume();
+
+private:
+  std::string m_Filename;
+  void       *m_Handle;
+  void       *m_cb;
+  ADSPHANDLE  m_PlayHandle;
+};
diff --git a/xbmc/addons/kodi-addon-dev-kit/include/kodi/libKODI_audioengine.h b/xbmc/addons/kodi-addon-dev-kit/include/kodi/libKODI_audioengine.h
new file mode 100644
index 0000000..f541637
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/include/kodi/libKODI_audioengine.h
@@ -0,0 +1,324 @@
+#pragma once
+/*
+ *      Copyright (C) 2005-2014 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 <stdio.h>
+#include <stdlib.h>
+#include <string>
+#include <string.h>
+#include <vector>
+
+#include "kodi_audioengine_types.h"
+#ifdef BUILD_KODI_ADDON
+  #include "kodi/AudioEngine/AEChannelData.h"
+  #include "kodi/AudioEngine/AEChannelInfo.h"
+  #include "kodi/AudioEngine/AEStreamData.h"
+#else
+  #include "cores/AudioEngine/Utils/AEChannelData.h"
+  #include "cores/AudioEngine/Utils/AEChannelInfo.h"
+  #include "cores/AudioEngine/Utils/AEStreamData.h"
+#endif
+
+#include "libXBMC_addon.h"
+
+#ifdef _WIN32
+#define AUDIOENGINE_HELPER_DLL "\\library.kodi.audioengine\\libKODI_audioengine" ADDON_HELPER_EXT
+#else
+#define AUDIOENGINE_HELPER_DLL_NAME "libKODI_audioengine-" ADDON_HELPER_ARCH ADDON_HELPER_EXT
+#define AUDIOENGINE_HELPER_DLL "/library.kodi.audioengine/" AUDIOENGINE_HELPER_DLL_NAME
+#endif
+
+class CAddonAEStream;
+
+class CHelper_libKODI_audioengine
+{
+public:
+  CHelper_libKODI_audioengine(void)
+  {
+    m_libKODI_audioengine = NULL;
+    m_Handle              = NULL;
+  }
+
+  ~CHelper_libKODI_audioengine(void)
+  {
+    if (m_libKODI_audioengine)
+    {
+      AudioEngine_unregister_me(m_Handle, m_Callbacks);
+      dlclose(m_libKODI_audioengine);
+    }
+  }
+
+  /*!
+   * @brief Resolve all callback methods
+   * @param handle Pointer to the add-on
+   * @return True when all methods were resolved, false otherwise.
+   */
+  bool RegisterMe(void* handle)
+  {
+    m_Handle = handle;
+
+    std::string libBasePath;
+    libBasePath  = ((cb_array*)m_Handle)->libPath;
+    libBasePath += AUDIOENGINE_HELPER_DLL;
+
+#if defined(ANDROID)
+      struct stat st;
+      if(stat(libBasePath.c_str(),&st) != 0)
+      {
+        std::string tempbin = getenv("XBMC_ANDROID_LIBS");
+        libBasePath = tempbin + "/" + AUDIOENGINE_HELPER_DLL;
+      }
+#endif
+
+    m_libKODI_audioengine = dlopen(libBasePath.c_str(), RTLD_LAZY);
+    if (m_libKODI_audioengine == NULL)
+    {
+      fprintf(stderr, "Unable to load %s\n", dlerror());
+      return false;
+    }
+
+    AudioEngine_register_me = (void* (*)(void *HANDLE))
+      dlsym(m_libKODI_audioengine, "AudioEngine_register_me");
+    if (AudioEngine_register_me == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    AudioEngine_unregister_me = (void(*)(void* HANDLE, void* CB))
+      dlsym(m_libKODI_audioengine, "AudioEngine_unregister_me");
+    if (AudioEngine_unregister_me == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    AudioEngine_MakeStream = (CAddonAEStream* (*)(void*, void*, AudioEngineFormat, unsigned int))
+      dlsym(m_libKODI_audioengine, "AudioEngine_make_stream");
+    if (AudioEngine_MakeStream == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    AudioEngine_FreeStream = (void(*)(CAddonAEStream*))
+      dlsym(m_libKODI_audioengine, "AudioEngine_free_stream");
+    if (AudioEngine_FreeStream == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    AudioEngine_GetCurrentSinkFormat = (bool(*)(void*, void*, AudioEngineFormat*))
+      dlsym(m_libKODI_audioengine, "AudioEngine_get_current_sink_Format");
+    if (AudioEngine_GetCurrentSinkFormat == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    m_Callbacks = AudioEngine_register_me(m_Handle);
+    return m_Callbacks != NULL;
+  }
+
+  /**
+   * Creates and returns a new handle to an IAEStream in the format specified, this function should never fail
+   * @param DataFormat The data format the incoming audio will be in (eg, AE_FMT_S16LE)
+   * @param SampleRate The sample rate of the audio data (eg, 48000)
+   * @param ChannelLayout The order of the channels in the audio data
+   * @param Options A bit field of stream options (see: enum AEStreamOptions)
+   * @return a new Handle to an IAEStream that will accept data in the requested format
+   */
+  CAddonAEStream* MakeStream(AudioEngineFormat Format, unsigned int Options = 0)
+  {
+    return AudioEngine_MakeStream(m_Handle, m_Callbacks, Format, Options);
+  }
+
+  /**
+  * This method will remove the specifyed stream from the engine.
+  * For OSX/IOS this is essential to reconfigure the audio output.
+  * @param stream The stream to be altered
+  * @return NULL
+  */
+  void FreeStream(CAddonAEStream **Stream)
+  {
+    AudioEngine_FreeStream(*Stream);
+    *Stream = NULL;
+  }
+
+  /**
+   * Get the current sink data format
+   *
+   * @param Current sink data format. For more details see AudioEngineFormat.
+   * @return Returns true on success, else false.
+   */
+  bool GetCurrentSinkFormat(AudioEngineFormat &SinkFormat)
+  {
+    return AudioEngine_GetCurrentSinkFormat(m_Handle, m_Callbacks, &SinkFormat);
+  }
+
+protected:
+  void* (*AudioEngine_register_me)(void*);
+  void (*AudioEngine_unregister_me)(void*, void*);
+  CAddonAEStream* (*AudioEngine_MakeStream)(void*, void*, AudioEngineFormat, unsigned int);
+  bool (*AudioEngine_GetCurrentSinkFormat)(void*, void*, AudioEngineFormat *SinkFormat);
+  void (*AudioEngine_FreeStream)(CAddonAEStream*);
+
+private:
+  void* m_libKODI_audioengine;
+  void* m_Handle;
+  void* m_Callbacks;
+  struct cb_array
+  {
+    const char* libPath;
+  };
+};
+
+// Audio Engine Stream Class
+class CAddonAEStream
+{
+public:
+  CAddonAEStream(void *Addon, void *Callbacks, AEStreamHandle *StreamHandle);
+  virtual ~CAddonAEStream();
+
+  /**
+  * Returns the amount of space available in the stream
+  * @return The number of bytes AddData will consume
+  */
+  virtual unsigned int GetSpace();
+
+  /**
+  * Add planar or interleaved PCM data to the stream
+  * @param Data array of pointers to the planes
+  * @param Offset to frame in frames
+  * @param Frames number of frames
+  * @return The number of frames consumed
+  */
+  virtual unsigned int AddData(uint8_t* const *Data, unsigned int Offset, unsigned int Frames);
+
+  /**
+  * Returns the time in seconds that it will take
+  * for the next added packet to be heard from the speakers.
+  * @return seconds
+  */
+  virtual double GetDelay();
+
+  /**
+  * Returns if the stream is buffering
+  * @return True if the stream is buffering
+  */
+  virtual bool IsBuffering();
+
+  /**
+  * Returns the time in seconds that it will take
+  * to underrun the cache if no sample is added.
+  * @return seconds
+  */
+  virtual double GetCacheTime();
+
+  /**
+  * Returns the total time in seconds of the cache
+  * @return seconds
+  */
+  virtual double GetCacheTotal();
+
+  /**
+  * Pauses the stream playback
+  */
+  virtual void Pause();
+
+  /**
+  * Resumes the stream after pausing
+  */
+  virtual void Resume();
+
+  /**
+  * Start draining the stream
+  * @note Once called AddData will not consume more data.
+  */
+  virtual void Drain(bool Wait);
+
+  /**
+  * Returns true if the is stream draining
+  */
+  virtual bool IsDraining();
+
+  /**
+  * Returns true if the is stream has finished draining
+  */
+  virtual bool IsDrained();
+
+  /**
+  * Flush all buffers dropping the audio data
+  */
+  virtual void Flush();
+
+  /**
+  * Return the stream's current volume level
+  * @return The volume level between 0.0 and 1.0
+  */
+  virtual float GetVolume();
+
+  /**
+  * Set the stream's volume level
+  * @param volume The new volume level between 0.0 and 1.0
+  */
+  virtual void  SetVolume(float Volume);
+
+  /**
+  * Gets the stream's volume amplification in linear units.
+  * @return The volume amplification factor between 1.0 and 1000.0
+  */
+  virtual float GetAmplification();
+
+  /**
+  * Sets the stream's volume amplification in linear units.
+  * @param The volume amplification factor between 1.0 and 1000.0
+  */
+  virtual void SetAmplification(float Amplify);
+
+  /**
+  * Returns the size of one audio frame in bytes (channelCount * resolution)
+  * @return The size in bytes of one frame
+  */
+  virtual const unsigned int GetFrameSize() const;
+
+  /**
+  * Returns the number of channels the stream is configured to accept
+  * @return The channel count
+  */
+  virtual const unsigned int GetChannelCount() const;
+
+  /**
+  * Returns the stream's sample rate, if the stream is using a dynamic sample rate, this value will NOT reflect any changes made by calls to SetResampleRatio()
+  * @return The stream's sample rate (eg, 48000)
+  */
+  virtual const unsigned int GetSampleRate() const;
+
+  /**
+  * Return the data format the stream has been configured with
+  * @return The stream's data format (eg, AE_FMT_S16LE)
+  */
+  virtual const AEDataFormat GetDataFormat() const;
+
+  /**
+  * Return the resample ratio
+  * @note This will return an undefined value if the stream is not resampling
+  * @return the current resample ratio or undefined if the stream is not resampling
+  */
+  virtual double GetResampleRatio();
+
+  /**
+  * Sets the resample ratio
+  * @note This function may return false if the stream is not resampling, if you wish to use this be sure to set the AESTREAM_FORCE_RESAMPLE option
+  * @param ratio the new sample rate ratio, calculated by ((double)desiredRate / (double)GetSampleRate())
+  */
+  virtual void SetResampleRatio(double Ratio);
+  
+  /**
+  * Sginal a clock change
+  */
+  virtual void Discontinuity();
+
+  private:
+    AEStreamHandle  *m_StreamHandle;
+    void            *m_Callbacks;
+    void            *m_AddonHandle;
+};
diff --git a/xbmc/addons/kodi-addon-dev-kit/include/kodi/libKODI_guilib.h b/xbmc/addons/kodi-addon-dev-kit/include/kodi/libKODI_guilib.h
new file mode 100644
index 0000000..bdaeb4c
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/include/kodi/libKODI_guilib.h
@@ -0,0 +1,845 @@
+#pragma once
+/*
+ *      Copyright (C) 2005-2013 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/>.
+ *
+ */
+
+#include <string>
+#include <vector>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include "libXBMC_addon.h"
+
+typedef void* GUIHANDLE;
+
+#ifdef _WIN32
+#define GUI_HELPER_DLL "\\library.kodi.guilib\\libKODI_guilib" ADDON_HELPER_EXT
+#else
+#define GUI_HELPER_DLL_NAME "libKODI_guilib-" ADDON_HELPER_ARCH ADDON_HELPER_EXT
+#define GUI_HELPER_DLL "/library.kodi.guilib/" GUI_HELPER_DLL_NAME
+#endif
+
+/* current ADDONGUI API version */
+#define KODI_GUILIB_API_VERSION "5.11.0"
+
+/* min. ADDONGUI API version */
+#define KODI_GUILIB_MIN_API_VERSION "5.10.0"
+
+#define ADDON_ACTION_PREVIOUS_MENU          10
+#define ADDON_ACTION_CLOSE_DIALOG           51
+#define ADDON_ACTION_NAV_BACK               92
+
+class CAddonGUIWindow;
+class CAddonGUISpinControl;
+class CAddonGUIRadioButton;
+class CAddonGUIProgressControl;
+class CAddonListItem;
+class CAddonGUIRenderingControl;
+class CAddonGUISliderControl;
+class CAddonGUISettingsSliderControl;
+
+class CHelper_libKODI_guilib
+{
+public:
+  CHelper_libKODI_guilib()
+  {
+    m_libKODI_guilib = NULL;
+    m_Handle = NULL;
+  }
+
+  ~CHelper_libKODI_guilib()
+  {
+    if (m_libKODI_guilib)
+    {
+      GUI_unregister_me(m_Handle, m_Callbacks);
+      dlclose(m_libKODI_guilib);
+    }
+  }
+
+  bool RegisterMe(void *Handle)
+  {
+    m_Handle = Handle;
+
+    std::string libBasePath;
+    libBasePath  = ((cb_array*)m_Handle)->libPath;
+    libBasePath += GUI_HELPER_DLL;
+
+#if defined(ANDROID)
+      struct stat st;
+      if(stat(libBasePath.c_str(),&st) != 0)
+      {
+        std::string tempbin = getenv("XBMC_ANDROID_LIBS");
+        libBasePath = tempbin + "/" + GUI_HELPER_DLL_NAME;
+      }
+#endif
+
+    m_libKODI_guilib = dlopen(libBasePath.c_str(), RTLD_LAZY);
+    if (m_libKODI_guilib == NULL)
+    {
+      fprintf(stderr, "Unable to load %s\n", dlerror());
+      return false;
+    }
+
+    GUI_register_me = (void* (*)(void *HANDLE))
+      dlsym(m_libKODI_guilib, "GUI_register_me");
+    if (GUI_register_me == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_unregister_me = (void (*)(void *HANDLE, void *CB))
+      dlsym(m_libKODI_guilib, "GUI_unregister_me");
+    if (GUI_unregister_me == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_lock = (void (*)(void *HANDLE, void *CB))
+      dlsym(m_libKODI_guilib, "GUI_lock");
+    if (GUI_lock == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_unlock = (void (*)(void *HANDLE, void *CB))
+      dlsym(m_libKODI_guilib, "GUI_unlock");
+    if (GUI_unlock == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_get_screen_height = (int (*)(void *HANDLE, void *CB))
+      dlsym(m_libKODI_guilib, "GUI_get_screen_height");
+    if (GUI_get_screen_height == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_get_screen_width = (int (*)(void *HANDLE, void *CB))
+      dlsym(m_libKODI_guilib, "GUI_get_screen_width");
+    if (GUI_get_screen_width == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_get_video_resolution = (int (*)(void *HANDLE, void *CB))
+      dlsym(m_libKODI_guilib, "GUI_get_video_resolution");
+    if (GUI_get_video_resolution == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_Window_create = (CAddonGUIWindow* (*)(void *HANDLE, void *CB, const char *xmlFilename, const char *defaultSkin, bool forceFallback, bool asDialog))
+      dlsym(m_libKODI_guilib, "GUI_Window_create");
+    if (GUI_Window_create == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_Window_destroy = (void (*)(CAddonGUIWindow* p))
+      dlsym(m_libKODI_guilib, "GUI_Window_destroy");
+    if (GUI_Window_destroy == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_control_get_spin = (CAddonGUISpinControl* (*)(void *HANDLE, void *CB, CAddonGUIWindow *window, int controlId))
+      dlsym(m_libKODI_guilib, "GUI_control_get_spin");
+    if (GUI_control_get_spin == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_control_release_spin = (void (*)(CAddonGUISpinControl* p))
+      dlsym(m_libKODI_guilib, "GUI_control_release_spin");
+    if (GUI_control_release_spin == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_control_get_radiobutton  = (CAddonGUIRadioButton* (*)(void *HANDLE, void *CB, CAddonGUIWindow *window, int controlId))
+      dlsym(m_libKODI_guilib, "GUI_control_get_radiobutton");
+    if (GUI_control_get_radiobutton == NULL)      { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_control_release_radiobutton = (void (*)(CAddonGUIRadioButton* p))
+      dlsym(m_libKODI_guilib, "GUI_control_release_radiobutton");
+    if (GUI_control_release_radiobutton == NULL)  { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_control_get_progress     = (CAddonGUIProgressControl* (*)(void *HANDLE, void *CB, CAddonGUIWindow *window, int controlId))
+      dlsym(m_libKODI_guilib, "GUI_control_get_progress");
+    if (GUI_control_get_progress == NULL)  { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_control_release_progress = (void (*)(CAddonGUIProgressControl* p))
+      dlsym(m_libKODI_guilib, "GUI_control_release_progress");
+    if (GUI_control_release_progress == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_ListItem_create = (CAddonListItem* (*)(void *HANDLE, void *CB, const char *label, const char *label2, const char *iconImage, const char *thumbnailImage, const char *path))
+      dlsym(m_libKODI_guilib, "GUI_ListItem_create");
+    if (GUI_ListItem_create == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_ListItem_destroy = (void (*)(CAddonListItem* p))
+      dlsym(m_libKODI_guilib, "GUI_ListItem_destroy");
+    if (GUI_ListItem_destroy == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_control_get_rendering = (CAddonGUIRenderingControl* (*)(void *HANDLE, void *CB, CAddonGUIWindow *window, int controlId))
+      dlsym(m_libKODI_guilib, "GUI_control_get_rendering");
+    if (GUI_control_get_rendering == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_control_release_rendering = (void (*)(CAddonGUIRenderingControl* p))
+      dlsym(m_libKODI_guilib, "GUI_control_release_rendering");
+    if (GUI_control_release_rendering == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_control_get_slider = (CAddonGUISliderControl* (*)(void *HANDLE, void *CB, CAddonGUIWindow *window, int controlId))
+      dlsym(m_libKODI_guilib, "GUI_control_get_slider");
+    if (GUI_control_get_slider == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_control_release_slider = (void (*)(CAddonGUISliderControl* p))
+      dlsym(m_libKODI_guilib, "GUI_control_release_slider");
+    if (GUI_control_release_slider == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_control_get_settings_slider = (CAddonGUISettingsSliderControl* (*)(void *HANDLE, void *CB, CAddonGUIWindow *window, int controlId))
+      dlsym(m_libKODI_guilib, "GUI_control_get_settings_slider");
+    if (GUI_control_get_settings_slider == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_control_release_settings_slider = (void (*)(CAddonGUISettingsSliderControl* p))
+      dlsym(m_libKODI_guilib, "GUI_control_release_settings_slider");
+    if (GUI_control_release_settings_slider == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_dialog_keyboard_show_and_get_input_with_head = (bool (*)(void *HANDLE, void *CB, char &aTextString, unsigned int iMaxStringSize, const char *heading, bool allowEmptyResult, bool hiddenInput, unsigned int autoCloseMs))
+      dlsym(m_libKODI_guilib, "GUI_dialog_keyboard_show_and_get_input_with_head");
+    if (GUI_dialog_keyboard_show_and_get_input_with_head == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_dialog_keyboard_show_and_get_input = (bool (*)(void *HANDLE, void *CB, char &aTextString, unsigned int iMaxStringSize, bool allowEmptyResult, unsigned int autoCloseMs))
+      dlsym(m_libKODI_guilib, "GUI_dialog_keyboard_show_and_get_input");
+    if (GUI_dialog_keyboard_show_and_get_input == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_dialog_keyboard_show_and_get_new_password_with_head = (bool (*)(void *HANDLE, void *CB, char &newPassword, unsigned int iMaxStringSize, const char *heading, bool allowEmptyResult, unsigned int autoCloseMs))
+      dlsym(m_libKODI_guilib, "GUI_dialog_keyboard_show_and_get_new_password_with_head");
+    if (GUI_dialog_keyboard_show_and_get_new_password_with_head == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_dialog_keyboard_show_and_get_new_password = (bool (*)(void *HANDLE, void *CB, char &strNewPassword, unsigned int iMaxStringSize, unsigned int autoCloseMs))
+      dlsym(m_libKODI_guilib, "GUI_dialog_keyboard_show_and_get_new_password");
+    if (GUI_dialog_keyboard_show_and_get_new_password == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_dialog_keyboard_show_and_verify_new_password_with_head = (bool (*)(void *HANDLE, void *CB, char &strNewPassword, unsigned int iMaxStringSize, const char *heading, bool allowEmptyResult, unsigned int autoCloseMs))
+      dlsym(m_libKODI_guilib, "GUI_dialog_keyboard_show_and_verify_new_password_with_head");
+    if (GUI_dialog_keyboard_show_and_verify_new_password_with_head == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_dialog_keyboard_show_and_verify_new_password = (bool (*)(void *HANDLE, void *CB, char &strNewPassword, unsigned int iMaxStringSize, unsigned int autoCloseMs))
+      dlsym(m_libKODI_guilib, "GUI_dialog_keyboard_show_and_verify_new_password");
+    if (GUI_dialog_keyboard_show_and_verify_new_password == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_dialog_keyboard_show_and_verify_password = (int (*)(void *HANDLE, void *CB, char &strPassword, unsigned int iMaxStringSize, const char *strHeading, int iRetries, unsigned int autoCloseMs))
+      dlsym(m_libKODI_guilib, "GUI_dialog_keyboard_show_and_verify_password");
+    if (GUI_dialog_keyboard_show_and_verify_password == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_dialog_keyboard_show_and_get_filter = (bool (*)(void *HANDLE, void *CB, char &aTextString, unsigned int iMaxStringSize, bool searching, unsigned int autoCloseMs))
+      dlsym(m_libKODI_guilib, "GUI_dialog_keyboard_show_and_get_filter");
+    if (GUI_dialog_keyboard_show_and_get_filter == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_dialog_keyboard_send_text_to_active_keyboard = (bool (*)(void *HANDLE, void *CB, const char *aTextString, bool closeKeyboard))
+      dlsym(m_libKODI_guilib, "GUI_dialog_keyboard_send_text_to_active_keyboard");
+    if (GUI_dialog_keyboard_send_text_to_active_keyboard == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_dialog_keyboard_is_activated = (bool (*)(void *HANDLE, void *CB))
+      dlsym(m_libKODI_guilib, "GUI_dialog_keyboard_is_activated");
+    if (GUI_dialog_keyboard_is_activated == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_dialog_numeric_show_and_verify_new_password = (bool (*)(void *HANDLE, void *CB, char &strNewPassword, unsigned int iMaxStringSize))
+      dlsym(m_libKODI_guilib, "GUI_dialog_numeric_show_and_verify_new_password");
+    if (GUI_dialog_numeric_show_and_verify_new_password == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_dialog_numeric_show_and_verify_password = (int (*)(void *HANDLE, void *CB, char &strPassword, unsigned int iMaxStringSize, const char *strHeading, int iRetries))
+      dlsym(m_libKODI_guilib, "GUI_dialog_numeric_show_and_verify_password");
+    if (GUI_dialog_numeric_show_and_verify_password == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_dialog_numeric_show_and_verify_input = (bool (*)(void *HANDLE, void *CB, char &strPassword, unsigned int iMaxStringSize, const char *strHeading, bool bGetUserInput))
+      dlsym(m_libKODI_guilib, "GUI_dialog_numeric_show_and_verify_input");
+    if (GUI_dialog_numeric_show_and_verify_input == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_dialog_numeric_show_and_get_time = (bool (*)(void *HANDLE, void *CB, tm &time, const char *strHeading))
+      dlsym(m_libKODI_guilib, "GUI_dialog_numeric_show_and_get_time");
+    if (GUI_dialog_numeric_show_and_get_time == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_dialog_numeric_show_and_get_date = (bool (*)(void *HANDLE, void *CB, tm &date, const char *strHeading))
+      dlsym(m_libKODI_guilib, "GUI_dialog_numeric_show_and_get_date");
+    if (GUI_dialog_numeric_show_and_get_date == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_dialog_numeric_show_and_get_ipaddress = (bool (*)(void *HANDLE, void *CB, char &IPAddress, unsigned int iMaxStringSize, const char *strHeading))
+      dlsym(m_libKODI_guilib, "GUI_dialog_numeric_show_and_get_ipaddress");
+    if (GUI_dialog_numeric_show_and_get_ipaddress == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_dialog_numeric_show_and_get_number = (bool (*)(void *HANDLE, void *CB, char &strInput, unsigned int iMaxStringSize, const char *strHeading, unsigned int iAutoCloseTimeoutMs))
+      dlsym(m_libKODI_guilib, "GUI_dialog_numeric_show_and_get_number");
+    if (GUI_dialog_numeric_show_and_get_number == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_dialog_numeric_show_and_get_seconds = (bool (*)(void *HANDLE, void *CB, char &strTime, unsigned int iMaxStringSize, const char *strHeading))
+      dlsym(m_libKODI_guilib, "GUI_dialog_numeric_show_and_get_seconds");
+    if (GUI_dialog_numeric_show_and_get_seconds == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_dialog_filebrowser_show_and_get_file = (bool (*)(void *HANDLE, void *CB, const char *directory, const char *mask, const char *heading, char &path, unsigned int iMaxStringSize, bool useThumbs, bool useFileDirectories, bool singleList))
+      dlsym(m_libKODI_guilib, "GUI_dialog_filebrowser_show_and_get_file");
+    if (GUI_dialog_filebrowser_show_and_get_file == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_dialog_ok_show_and_get_input_single_text = (void (*)(void *HANDLE, void *CB, const char *heading, const char *text))
+      dlsym(m_libKODI_guilib, "GUI_dialog_ok_show_and_get_input_single_text");
+    if (GUI_dialog_ok_show_and_get_input_single_text == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_dialog_ok_show_and_get_input_line_text = (void (*)(void *HANDLE, void *CB, const char *heading, const char *line0, const char *line1, const char *line2))
+      dlsym(m_libKODI_guilib, "GUI_dialog_ok_show_and_get_input_line_text");
+    if (GUI_dialog_ok_show_and_get_input_line_text == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_dialog_yesno_show_and_get_input_singletext = (bool (*)(void *HANDLE, void *CB, const char *heading, const char *text, bool& bCanceled, const char *noLabel, const char *yesLabel))
+      dlsym(m_libKODI_guilib, "GUI_dialog_yesno_show_and_get_input_singletext");
+    if (GUI_dialog_yesno_show_and_get_input_singletext == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_dialog_yesno_show_and_get_input_linetext = (bool (*)(void *HANDLE, void *CB, const char *heading, const char *line0, const char *line1, const char *line2, const char *noLabel, const char *yesLabel))
+      dlsym(m_libKODI_guilib, "GUI_dialog_yesno_show_and_get_input_linetext");
+    if (GUI_dialog_yesno_show_and_get_input_linetext == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_dialog_yesno_show_and_get_input_linebuttontext = (bool (*)(void *HANDLE, void *CB, const char *heading, const char *line0, const char *line1, const char *line2, bool &bCanceled, const char *noLabel, const char *yesLabel))
+      dlsym(m_libKODI_guilib, "GUI_dialog_yesno_show_and_get_input_linebuttontext");
+    if (GUI_dialog_yesno_show_and_get_input_linebuttontext == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_dialog_text_viewer = (void (*)(void *hdl, void *cb, const char *heading, const char *text))
+      dlsym(m_libKODI_guilib, "GUI_dialog_text_viewer");
+    if (GUI_dialog_text_viewer == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    GUI_dialog_select = (int (*)(void *hdl, void *cb, const char *heading, const char *entries[], unsigned int size, int selected))
+      dlsym(m_libKODI_guilib, "GUI_dialog_select");
+    if (GUI_dialog_select == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    m_Callbacks = GUI_register_me(m_Handle);
+    return m_Callbacks != NULL;
+  }
+
+  void Lock()
+  {
+    return GUI_lock(m_Handle, m_Callbacks);
+  }
+
+  void Unlock()
+  {
+    return GUI_unlock(m_Handle, m_Callbacks);
+  }
+
+  int GetScreenHeight()
+  {
+    return GUI_get_screen_height(m_Handle, m_Callbacks);
+  }
+
+  int GetScreenWidth()
+  {
+    return GUI_get_screen_width(m_Handle, m_Callbacks);
+  }
+
+  int GetVideoResolution()
+  {
+    return GUI_get_video_resolution(m_Handle, m_Callbacks);
+  }
+
+  CAddonGUIWindow* Window_create(const char *xmlFilename, const char *defaultSkin, bool forceFallback, bool asDialog)
+  {
+    return GUI_Window_create(m_Handle, m_Callbacks, xmlFilename, defaultSkin, forceFallback, asDialog);
+  }
+
+  void Window_destroy(CAddonGUIWindow* p)
+  {
+    return GUI_Window_destroy(p);
+  }
+
+  CAddonGUISpinControl* Control_getSpin(CAddonGUIWindow *window, int controlId)
+  {
+    return GUI_control_get_spin(m_Handle, m_Callbacks, window, controlId);
+  }
+
+  void Control_releaseSpin(CAddonGUISpinControl* p)
+  {
+    return GUI_control_release_spin(p);
+  }
+
+  CAddonGUIRadioButton* Control_getRadioButton(CAddonGUIWindow *window, int controlId)
+  {
+    return GUI_control_get_radiobutton(m_Handle, m_Callbacks, window, controlId);
+  }
+
+  void Control_releaseRadioButton(CAddonGUIRadioButton* p)
+  {
+    return GUI_control_release_radiobutton(p);
+  }
+
+  CAddonGUIProgressControl* Control_getProgress(CAddonGUIWindow *window, int controlId)
+  {
+    return GUI_control_get_progress(m_Handle, m_Callbacks, window, controlId);
+  }
+
+  void Control_releaseProgress(CAddonGUIProgressControl* p)
+  {
+    return GUI_control_release_progress(p);
+  }
+
+  CAddonListItem* ListItem_create(const char *label, const char *label2, const char *iconImage, const char *thumbnailImage, const char *path)
+  {
+    return GUI_ListItem_create(m_Handle, m_Callbacks, label, label2, iconImage, thumbnailImage, path);
+  }
+
+  void ListItem_destroy(CAddonListItem* p)
+  {
+    return GUI_ListItem_destroy(p);
+  }
+
+  CAddonGUIRenderingControl* Control_getRendering(CAddonGUIWindow *window, int controlId)
+  {
+    return GUI_control_get_rendering(m_Handle, m_Callbacks, window, controlId);
+  }
+
+  void Control_releaseRendering(CAddonGUIRenderingControl* p)
+  {
+    return GUI_control_release_rendering(p);
+  }
+
+  CAddonGUISliderControl* Control_getSlider(CAddonGUIWindow *window, int controlId)
+  {
+    return GUI_control_get_slider(m_Handle, m_Callbacks, window, controlId);
+  }
+
+  void Control_releaseSlider(CAddonGUISliderControl* p)
+  {
+    return GUI_control_release_slider(p);
+  }
+
+  CAddonGUISettingsSliderControl* Control_getSettingsSlider(CAddonGUIWindow *window, int controlId)
+  {
+    return GUI_control_get_settings_slider(m_Handle, m_Callbacks, window, controlId);
+  }
+
+  void Control_releaseSettingsSlider(CAddonGUISettingsSliderControl* p)
+  {
+    return GUI_control_release_settings_slider(p);
+  }
+
+  /*! @name GUI Keyboard functions */
+  //@{
+  bool Dialog_Keyboard_ShowAndGetInput(char &strText, unsigned int iMaxStringSize, const char *strHeading, bool allowEmptyResult, bool hiddenInput, unsigned int autoCloseMs = 0)
+  {
+    return GUI_dialog_keyboard_show_and_get_input_with_head(m_Handle, m_Callbacks, strText, iMaxStringSize, strHeading, allowEmptyResult, hiddenInput, autoCloseMs);
+  }
+
+  bool Dialog_Keyboard_ShowAndGetInput(char &strText, unsigned int iMaxStringSize, bool allowEmptyResult, unsigned int autoCloseMs = 0)
+  {
+    return GUI_dialog_keyboard_show_and_get_input(m_Handle, m_Callbacks, strText, iMaxStringSize, allowEmptyResult, autoCloseMs);
+  }
+
+  bool Dialog_Keyboard_ShowAndGetNewPassword(char &strNewPassword, unsigned int iMaxStringSize, const char *strHeading, bool allowEmptyResult, unsigned int autoCloseMs = 0)
+  {
+    return GUI_dialog_keyboard_show_and_get_new_password_with_head(m_Handle, m_Callbacks, strNewPassword, iMaxStringSize, strHeading, allowEmptyResult, autoCloseMs);
+  }
+
+  bool Dialog_Keyboard_ShowAndGetNewPassword(char &strNewPassword, unsigned int iMaxStringSize, unsigned int autoCloseMs = 0)
+  {
+    return GUI_dialog_keyboard_show_and_get_new_password(m_Handle, m_Callbacks, strNewPassword, iMaxStringSize, autoCloseMs);
+  }
+
+  bool Dialog_Keyboard_ShowAndVerifyNewPassword(char &strNewPassword, unsigned int iMaxStringSize, const char *strHeading, bool allowEmptyResult, unsigned int autoCloseMs = 0)
+  {
+    return GUI_dialog_keyboard_show_and_verify_new_password_with_head(m_Handle, m_Callbacks, strNewPassword, iMaxStringSize, strHeading, allowEmptyResult, autoCloseMs);
+  }
+
+  bool Dialog_Keyboard_ShowAndVerifyNewPassword(char &strNewPassword, unsigned int iMaxStringSize, unsigned int autoCloseMs = 0)
+  {
+    return GUI_dialog_keyboard_show_and_verify_new_password(m_Handle, m_Callbacks, strNewPassword, iMaxStringSize, autoCloseMs);
+  }
+
+  int Dialog_Keyboard_ShowAndVerifyPassword(char &strPassword, unsigned int iMaxStringSize, const char *strHeading, int iRetries, unsigned int autoCloseMs = 0)
+  {
+    return GUI_dialog_keyboard_show_and_verify_password(m_Handle, m_Callbacks, strPassword, iMaxStringSize, strHeading, iRetries, autoCloseMs);
+  }
+
+  bool Dialog_Keyboard_ShowAndGetFilter(char &strText, unsigned int iMaxStringSize, bool searching, unsigned int autoCloseMs = 0)
+  {
+    return GUI_dialog_keyboard_show_and_get_filter(m_Handle, m_Callbacks, strText, iMaxStringSize, searching, autoCloseMs);
+  }
+
+  bool Dialog_Keyboard_SendTextToActiveKeyboard(const char *aTextString, bool closeKeyboard = false)
+  {
+    return GUI_dialog_keyboard_send_text_to_active_keyboard(m_Handle, m_Callbacks, aTextString, closeKeyboard);
+  }
+
+  bool Dialog_Keyboard_isKeyboardActivated()
+  {
+    return GUI_dialog_keyboard_is_activated(m_Handle, m_Callbacks);
+  }
+  //@}
+
+  /*! @name GUI Numeric functions */
+  //@{
+  bool Dialog_Numeric_ShowAndVerifyNewPassword(char &strNewPassword, unsigned int iMaxStringSize)
+  {
+    return GUI_dialog_numeric_show_and_verify_new_password(m_Handle, m_Callbacks, strNewPassword, iMaxStringSize);
+  }
+
+  int Dialog_Numeric_ShowAndVerifyPassword(char &strPassword, unsigned int iMaxStringSize, const char *strHeading, int iRetries)
+  {
+    return GUI_dialog_numeric_show_and_verify_password(m_Handle, m_Callbacks, strPassword, iMaxStringSize, strHeading, iRetries);
+  }
+
+  bool Dialog_Numeric_ShowAndVerifyInput(char &strPassword, unsigned int iMaxStringSize, const char *strHeading, bool bGetUserInput)
+  {
+    return GUI_dialog_numeric_show_and_verify_input(m_Handle, m_Callbacks, strPassword, iMaxStringSize, strHeading, bGetUserInput);
+  }
+
+  bool Dialog_Numeric_ShowAndGetTime(tm &time, const char *strHeading)
+  {
+    return GUI_dialog_numeric_show_and_get_time(m_Handle, m_Callbacks, time, strHeading);
+  }
+
+  bool Dialog_Numeric_ShowAndGetDate(tm &date, const char *strHeading)
+  {
+    return GUI_dialog_numeric_show_and_get_date(m_Handle, m_Callbacks, date, strHeading);
+  }
+
+  bool Dialog_Numeric_ShowAndGetIPAddress(char &strIPAddress, unsigned int iMaxStringSize, const char *strHeading)
+  {
+    return GUI_dialog_numeric_show_and_get_ipaddress(m_Handle, m_Callbacks, strIPAddress, iMaxStringSize, strHeading);
+  }
+
+  bool Dialog_Numeric_ShowAndGetNumber(char &strInput, unsigned int iMaxStringSize, const char *strHeading, unsigned int iAutoCloseTimeoutMs = 0)
+  {
+    return GUI_dialog_numeric_show_and_get_number(m_Handle, m_Callbacks, strInput, iMaxStringSize, strHeading, iAutoCloseTimeoutMs);
+  }
+
+  bool Dialog_Numeric_ShowAndGetSeconds(char &strTime, unsigned int iMaxStringSize, const char *strHeading)
+  {
+    return GUI_dialog_numeric_show_and_get_seconds(m_Handle, m_Callbacks, strTime, iMaxStringSize, strHeading);
+  }
+  //@}
+
+  /*! @name GUI File browser functions */
+  //@{
+  bool Dialog_FileBrowser_ShowAndGetFile(const char *directory, const char *mask, const char *heading, char &strPath, unsigned int iMaxStringSize, bool useThumbs = false, bool useFileDirectories = false, bool singleList = false)
+  {
+    return GUI_dialog_filebrowser_show_and_get_file(m_Handle, m_Callbacks, directory, mask, heading, strPath, iMaxStringSize, useThumbs, useFileDirectories, singleList);
+  }
+  //@}
+
+  /*! @name GUI OK Dialog functions */
+  //@{
+  void Dialog_OK_ShowAndGetInput(const char *heading, const char *text)
+  {
+    GUI_dialog_ok_show_and_get_input_single_text(m_Handle, m_Callbacks, heading, text);
+  }
+
+  void Dialog_OK_ShowAndGetInput(const char *heading, const char *line0, const char *line1, const char *line2)
+  {
+    GUI_dialog_ok_show_and_get_input_line_text(m_Handle, m_Callbacks, heading, line0, line1, line2);
+  }
+  //@}
+
+  /*! @name GUI Yes No Dialog functions */
+  //@{
+  bool Dialog_YesNo_ShowAndGetInput(const char *heading, const char *text, bool& bCanceled, const char *noLabel = "", const char *yesLabel = "")
+  {
+    return GUI_dialog_yesno_show_and_get_input_singletext(m_Handle, m_Callbacks, heading, text, bCanceled, noLabel, yesLabel);
+  }
+
+  bool Dialog_YesNo_ShowAndGetInput(const char *heading, const char *line0, const char *line1, const char *line2, const char *noLabel = "", const char *yesLabel = "")
+  {
+    return GUI_dialog_yesno_show_and_get_input_linetext(m_Handle, m_Callbacks, heading, line0, line1, line2, noLabel, yesLabel);
+  }
+
+  bool Dialog_YesNo_ShowAndGetInput(const char *heading, const char *line0, const char *line1, const char *line2, bool &bCanceled, const char *noLabel = "", const char *yesLabel = "")
+  {
+    return GUI_dialog_yesno_show_and_get_input_linebuttontext(m_Handle, m_Callbacks, heading, line0, line1, line2, bCanceled, noLabel, yesLabel);
+  }
+  //@}
+
+  /*! @name GUI Text viewer Dialog */
+  //@{
+  void Dialog_TextViewer(const char *heading, const char *text)
+  {
+    return GUI_dialog_text_viewer(m_Handle, m_Callbacks, heading, text);
+  }
+  //@}
+
+  /*! @name GUI select Dialog */
+  //@{
+  int Dialog_Select(const char *heading, const char *entries[], unsigned int size, int selected = -1)
+  {
+    return GUI_dialog_select(m_Handle, m_Callbacks, heading, entries, size, selected);
+  }
+  //@}
+
+protected:
+  void* (*GUI_register_me)(void *HANDLE);
+  void (*GUI_unregister_me)(void *HANDLE, void* CB);
+  void (*GUI_lock)(void *HANDLE, void* CB);
+  void (*GUI_unlock)(void *HANDLE, void* CB);
+  int (*GUI_get_screen_height)(void *HANDLE, void* CB);
+  int (*GUI_get_screen_width)(void *HANDLE, void* CB);
+  int (*GUI_get_video_resolution)(void *HANDLE, void* CB);
+  CAddonGUIWindow* (*GUI_Window_create)(void *HANDLE, void* CB, const char *xmlFilename, const char *defaultSkin, bool forceFallback, bool asDialog);
+  void (*GUI_Window_destroy)(CAddonGUIWindow* p);
+  CAddonGUISpinControl* (*GUI_control_get_spin)(void *HANDLE, void* CB, CAddonGUIWindow *window, int controlId);
+  void (*GUI_control_release_spin)(CAddonGUISpinControl* p);
+  CAddonGUIRadioButton* (*GUI_control_get_radiobutton)(void *HANDLE, void* CB, CAddonGUIWindow *window, int controlId);
+  void (*GUI_control_release_radiobutton)(CAddonGUIRadioButton* p);
+  CAddonGUIProgressControl* (*GUI_control_get_progress)(void *HANDLE, void* CB, CAddonGUIWindow *window, int controlId);
+  void (*GUI_control_release_progress)(CAddonGUIProgressControl* p);
+  CAddonListItem* (*GUI_ListItem_create)(void *HANDLE, void* CB, const char *label, const char *label2, const char *iconImage, const char *thumbnailImage, const char *path);
+  void (*GUI_ListItem_destroy)(CAddonListItem* p);
+  CAddonGUIRenderingControl* (*GUI_control_get_rendering)(void *HANDLE, void* CB, CAddonGUIWindow *window, int controlId);
+  void (*GUI_control_release_rendering)(CAddonGUIRenderingControl* p);
+  CAddonGUISliderControl* (*GUI_control_get_slider)(void *HANDLE, void* CB, CAddonGUIWindow *window, int controlId);
+  void (*GUI_control_release_slider)(CAddonGUISliderControl* p);
+  CAddonGUISettingsSliderControl* (*GUI_control_get_settings_slider)(void *HANDLE, void* CB, CAddonGUIWindow *window, int controlId);
+  void (*GUI_control_release_settings_slider)(CAddonGUISettingsSliderControl* p);
+  bool (*GUI_dialog_keyboard_show_and_get_input_with_head)(void *HANDLE, void *CB, char &aTextString, unsigned int iMaxStringSize, const char *heading, bool allowEmptyResult, bool hiddenInput, unsigned int autoCloseMs);
+  bool (*GUI_dialog_keyboard_show_and_get_input)(void *HANDLE, void *CB, char &aTextString, unsigned int iMaxStringSize, bool allowEmptyResult, unsigned int autoCloseMs);
+  bool (*GUI_dialog_keyboard_show_and_get_new_password_with_head)(void *HANDLE, void *CB, char &newPassword, unsigned int iMaxStringSize, const char *heading, bool allowEmptyResult, unsigned int autoCloseMs);
+  bool (*GUI_dialog_keyboard_show_and_get_new_password)(void *HANDLE, void *CB, char &strNewPassword, unsigned int iMaxStringSize, unsigned int autoCloseMs);
+  bool (*GUI_dialog_keyboard_show_and_verify_new_password_with_head)(void *HANDLE, void *CB, char &strNewPassword, unsigned int iMaxStringSize, const char *heading, bool allowEmptyResult, unsigned int autoCloseMs);
+  bool (*GUI_dialog_keyboard_show_and_verify_new_password)(void *HANDLE, void *CB, char &strNewPassword, unsigned int iMaxStringSize, unsigned int autoCloseMs);
+  int (*GUI_dialog_keyboard_show_and_verify_password)(void *HANDLE, void *CB, char &strPassword, unsigned int iMaxStringSize, const char *strHeading, int iRetries, unsigned int autoCloseMs);
+  bool (*GUI_dialog_keyboard_show_and_get_filter)(void *HANDLE, void *CB, char &aTextString, unsigned int iMaxStringSize, bool searching, unsigned int autoCloseMs);
+  bool (*GUI_dialog_keyboard_send_text_to_active_keyboard)(void *HANDLE, void *CB, const char *aTextString, bool closeKeyboard);
+  bool (*GUI_dialog_keyboard_is_activated)(void *HANDLE, void *CB);
+  bool (*GUI_dialog_numeric_show_and_verify_new_password)(void *HANDLE, void *CB, char &strNewPassword, unsigned int iMaxStringSize);
+  int (*GUI_dialog_numeric_show_and_verify_password)(void *HANDLE, void *CB, char &strPassword, unsigned int iMaxStringSize, const char *strHeading, int iRetries);
+  bool (*GUI_dialog_numeric_show_and_verify_input)(void *HANDLE, void *CB, char &strPassword, unsigned int iMaxStringSize, const char *strHeading, bool bGetUserInput);
+  bool (*GUI_dialog_numeric_show_and_get_time)(void *HANDLE, void *CB, tm &time, const char *strHeading);
+  bool (*GUI_dialog_numeric_show_and_get_date)(void *HANDLE, void *CB, tm &date, const char *strHeading);
+  bool (*GUI_dialog_numeric_show_and_get_ipaddress)(void *HANDLE, void *CB, char &IPAddress, unsigned int iMaxStringSize, const char *strHeading);
+  bool (*GUI_dialog_numeric_show_and_get_number)(void *HANDLE, void *CB, char &strInput, unsigned int iMaxStringSize, const char *strHeading, unsigned int iAutoCloseTimeoutMs);
+  bool (*GUI_dialog_numeric_show_and_get_seconds)(void *HANDLE, void *CB, char &strTime, unsigned int iMaxStringSize, const char *strHeading);
+  bool (*GUI_dialog_filebrowser_show_and_get_file)(void *HANDLE, void *CB, const char *directory, const char *mask, const char *heading, char &path, unsigned int iMaxStringSize, bool useThumbs, bool useFileDirectories, bool singleList);
+  void (*GUI_dialog_ok_show_and_get_input_single_text)(void *HANDLE, void *CB, const char *heading, const char *text);
+  void (*GUI_dialog_ok_show_and_get_input_line_text)(void *HANDLE, void *CB, const char *heading, const char *line0, const char *line1, const char *line2);
+  bool (*GUI_dialog_yesno_show_and_get_input_singletext)(void *HANDLE, void *CB, const char *heading, const char *text, bool& bCanceled, const char *noLabel, const char *yesLabel);
+  bool (*GUI_dialog_yesno_show_and_get_input_linetext)(void *HANDLE, void *CB, const char *heading, const char *line0, const char *line1, const char *line2, const char *noLabel, const char *yesLabel);
+  bool (*GUI_dialog_yesno_show_and_get_input_linebuttontext)(void *HANDLE, void *CB, const char *heading, const char *line0, const char *line1, const char *line2, bool &bCanceled, const char *noLabel, const char *yesLabel);
+  void (*GUI_dialog_text_viewer)(void *hdl, void *cb, const char *heading, const char *text);
+  int (*GUI_dialog_select)(void *hdl, void *cb, const char *heading, const char *entries[], unsigned int size, int selected);
+
+private:
+  void *m_libKODI_guilib;
+  void *m_Handle;
+  void *m_Callbacks;
+  struct cb_array
+  {
+    const char* libPath;
+  };
+};
+
+class CAddonGUISpinControl
+{
+public:
+  CAddonGUISpinControl(void *hdl, void *cb, CAddonGUIWindow *window, int controlId);
+  virtual ~CAddonGUISpinControl(void) {}
+
+  virtual void SetVisible(bool yesNo);
+  virtual void SetText(const char *label);
+  virtual void Clear();
+  virtual void AddLabel(const char *label, int iValue);
+  virtual int GetValue();
+  virtual void SetValue(int iValue);
+
+private:
+  CAddonGUIWindow *m_Window;
+  int         m_ControlId;
+  GUIHANDLE   m_SpinHandle;
+  void *m_Handle;
+  void *m_cb;
+};
+
+class CAddonGUIRadioButton
+{
+public:
+  CAddonGUIRadioButton(void *hdl, void *cb, CAddonGUIWindow *window, int controlId);
+  virtual ~CAddonGUIRadioButton() {}
+
+  virtual void SetVisible(bool yesNo);
+  virtual void SetText(const char *label);
+  virtual void SetSelected(bool yesNo);
+  virtual bool IsSelected();
+
+private:
+  CAddonGUIWindow *m_Window;
+  int         m_ControlId;
+  GUIHANDLE   m_ButtonHandle;
+  void *m_Handle;
+  void *m_cb;
+};
+
+class CAddonGUIProgressControl
+{
+public:
+  CAddonGUIProgressControl(void *hdl, void *cb, CAddonGUIWindow *window, int controlId);
+  virtual ~CAddonGUIProgressControl(void) {}
+
+  virtual void SetPercentage(float fPercent);
+  virtual float GetPercentage() const;
+  virtual void SetInfo(int iInfo);
+  virtual int GetInfo() const;
+  virtual std::string GetDescription() const;
+
+private:
+  CAddonGUIWindow *m_Window;
+  int         m_ControlId;
+  GUIHANDLE   m_ProgressHandle;
+  void *m_Handle;
+  void *m_cb;
+};
+
+class CAddonGUISliderControl
+{
+public:
+  CAddonGUISliderControl(void *hdl, void *cb, CAddonGUIWindow *window, int controlId);
+  virtual ~CAddonGUISliderControl(void) {}
+
+  virtual void        SetVisible(bool yesNo);
+  virtual std::string GetDescription() const;
+
+  virtual void        SetIntRange(int iStart, int iEnd);
+  virtual void        SetIntValue(int iValue);
+  virtual int         GetIntValue() const;
+  virtual void        SetIntInterval(int iInterval);
+
+  virtual void        SetPercentage(float fPercent);
+  virtual float       GetPercentage() const;
+
+  virtual void        SetFloatRange(float fStart, float fEnd);
+  virtual void        SetFloatValue(float fValue);
+  virtual float       GetFloatValue() const;
+  virtual void        SetFloatInterval(float fInterval);
+
+private:
+  CAddonGUIWindow *m_Window;
+  int         m_ControlId;
+  GUIHANDLE   m_SliderHandle;
+  void *m_Handle;
+  void *m_cb;
+};
+
+class CAddonGUISettingsSliderControl
+{
+public:
+  CAddonGUISettingsSliderControl(void *hdl, void *cb, CAddonGUIWindow *window, int controlId);
+  virtual ~CAddonGUISettingsSliderControl(void) {}
+
+  virtual void        SetVisible(bool yesNo);
+  virtual void        SetText(const char *label);
+  virtual std::string GetDescription() const;
+
+  virtual void        SetIntRange(int iStart, int iEnd);
+  virtual void        SetIntValue(int iValue);
+  virtual int         GetIntValue() const;
+  virtual void        SetIntInterval(int iInterval);
+
+  virtual void        SetPercentage(float fPercent);
+  virtual float       GetPercentage() const;
+
+  virtual void        SetFloatRange(float fStart, float fEnd);
+  virtual void        SetFloatValue(float fValue);
+  virtual float       GetFloatValue() const;
+  virtual void        SetFloatInterval(float fInterval);
+
+private:
+  CAddonGUIWindow *m_Window;
+  int         m_ControlId;
+  GUIHANDLE   m_SettingsSliderHandle;
+  void *m_Handle;
+  void *m_cb;
+};
+
+class CAddonListItem
+{
+friend class CAddonGUIWindow;
+
+public:
+  CAddonListItem(void *hdl, void *cb, const char *label, const char *label2, const char *iconImage, const char *thumbnailImage, const char *path);
+  virtual ~CAddonListItem(void) {}
+
+  virtual const char  *GetLabel();
+  virtual void         SetLabel(const char *label);
+  virtual const char  *GetLabel2();
+  virtual void         SetLabel2(const char *label);
+  virtual void         SetIconImage(const char *image);
+  virtual void         SetThumbnailImage(const char *image);
+  virtual void         SetInfo(const char *Info);
+  virtual void         SetProperty(const char *key, const char *value);
+  virtual const char  *GetProperty(const char *key) const;
+  virtual void         SetPath(const char *Path);
+
+//    {(char*)"select();
+//    {(char*)"isSelected();
+protected:
+  GUIHANDLE   m_ListItemHandle;
+  void *m_Handle;
+  void *m_cb;
+};
+
+class CAddonGUIWindow
+{
+friend class CAddonGUISpinControl;
+friend class CAddonGUIRadioButton;
+friend class CAddonGUIProgressControl;
+friend class CAddonGUIRenderingControl;
+friend class CAddonGUISliderControl;
+friend class CAddonGUISettingsSliderControl;
+
+public:
+  CAddonGUIWindow(void *hdl, void *cb, const char *xmlFilename, const char *defaultSkin, bool forceFallback, bool asDialog);
+  virtual ~CAddonGUIWindow();
+
+  virtual bool         Show();
+  virtual void         Close();
+  virtual void         DoModal();
+  virtual bool         SetFocusId(int iControlId);
+  virtual int          GetFocusId();
+  virtual bool         SetCoordinateResolution(int res);
+  virtual void         SetProperty(const char *key, const char *value);
+  virtual void         SetPropertyInt(const char *key, int value);
+  virtual void         SetPropertyBool(const char *key, bool value);
+  virtual void         SetPropertyDouble(const char *key, double value);
+  virtual const char  *GetProperty(const char *key) const;
+  virtual int          GetPropertyInt(const char *key) const;
+  virtual bool         GetPropertyBool(const char *key) const;
+  virtual double       GetPropertyDouble(const char *key) const;
+  virtual void         ClearProperties();
+  virtual int          GetListSize();
+  virtual void         ClearList();
+  virtual GUIHANDLE    AddStringItem(const char *name, int itemPosition = -1);
+  virtual void         AddItem(GUIHANDLE item, int itemPosition = -1);
+  virtual void         AddItem(CAddonListItem *item, int itemPosition = -1);
+  virtual void         RemoveItem(int itemPosition);
+  virtual GUIHANDLE    GetListItem(int listPos);
+  virtual void         SetCurrentListPosition(int listPos);
+  virtual int          GetCurrentListPosition();
+  virtual void         SetControlLabel(int controlId, const char *label);
+  virtual void         MarkDirtyRegion();
+
+  virtual bool         OnClick(int controlId);
+  virtual bool         OnFocus(int controlId);
+  virtual bool         OnInit();
+  virtual bool         OnAction(int actionId);
+
+  GUIHANDLE m_cbhdl;
+  bool (*CBOnInit)(GUIHANDLE cbhdl);
+  bool (*CBOnFocus)(GUIHANDLE cbhdl, int controlId);
+  bool (*CBOnClick)(GUIHANDLE cbhdl, int controlId);
+  bool (*CBOnAction)(GUIHANDLE cbhdl, int actionId);
+
+protected:
+  GUIHANDLE m_WindowHandle;
+  void *m_Handle;
+  void *m_cb;
+};
+
+class CAddonGUIRenderingControl
+{
+public:
+  CAddonGUIRenderingControl(void *hdl, void *cb, CAddonGUIWindow *window, int controlId);
+  virtual ~CAddonGUIRenderingControl();
+  virtual void Init();
+
+  virtual bool Create(int x, int y, int w, int h, void *device);
+  virtual void Render();
+  virtual void Stop();
+  virtual bool Dirty();
+
+  GUIHANDLE m_cbhdl;
+  bool (*CBCreate)(GUIHANDLE cbhdl, int x, int y, int w, int h, void *device);
+  void (*CBRender)(GUIHANDLE cbhdl);
+  void (*CBStop)(GUIHANDLE cbhdl);
+  bool (*CBDirty)(GUIHANDLE cbhdl);
+
+private:
+  CAddonGUIWindow *m_Window;
+  int         m_ControlId;
+  GUIHANDLE   m_RenderingHandle;
+  void *m_Handle;
+  void *m_cb;
+};
diff --git a/xbmc/addons/kodi-addon-dev-kit/include/kodi/libKODI_inputstream.h b/xbmc/addons/kodi-addon-dev-kit/include/kodi/libKODI_inputstream.h
new file mode 100644
index 0000000..e0dc881
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/include/kodi/libKODI_inputstream.h
@@ -0,0 +1,150 @@
+/*
+ *      Copyright (C) 2005-2016 Team XBMC
+ *      http://www.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 <string>
+#include <vector>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include "libXBMC_addon.h"
+
+#ifdef BUILD_KODI_ADDON
+#include "DVDDemuxPacket.h"
+#else
+#include "cores/VideoPlayer/DVDDemuxers/DVDDemuxPacket.h"
+#endif
+
+#ifdef _WIN32
+#define INPUTSTREAM_HELPER_DLL "\\library.kodi.inputstream\\libKODI_inputstream" ADDON_HELPER_EXT
+#else
+#define INPUTSTREAM_HELPER_DLL_NAME "libKODI_inputstream-" ADDON_HELPER_ARCH ADDON_HELPER_EXT
+#define INPUTSTREAM_HELPER_DLL "/library.kodi.inputstream/" INPUTSTREAM_HELPER_DLL_NAME
+#endif
+
+class CHelper_libKODI_inputstream
+{
+public:
+  CHelper_libKODI_inputstream(void)
+  {
+    m_libKODI_inputstream = nullptr;
+    m_Handle = nullptr;
+  }
+
+  ~CHelper_libKODI_inputstream(void)
+  {
+    if (m_libKODI_inputstream)
+    {
+      INPUTSTREAM_unregister_me(m_Handle, m_Callbacks);
+      dlclose(m_libKODI_inputstream);
+    }
+  }
+
+  /*!
+   * @brief Resolve all callback methods
+   * @param handle Pointer to the add-on
+   * @return True when all methods were resolved, false otherwise.
+   */
+  bool RegisterMe(void* handle)
+  {
+    m_Handle = handle;
+
+    std::string libBasePath;
+    libBasePath  = ((cb_array*)m_Handle)->libPath;
+    libBasePath += INPUTSTREAM_HELPER_DLL;
+
+    m_libKODI_inputstream = dlopen(libBasePath.c_str(), RTLD_LAZY);
+    if (m_libKODI_inputstream == nullptr)
+    {
+      fprintf(stderr, "Unable to load %s\n", dlerror());
+      return false;
+    }
+
+    INPUTSTREAM_register_me = (void* (*)(void *HANDLE))
+      dlsym(m_libKODI_inputstream, "INPUTSTREAM_register_me");
+    if (INPUTSTREAM_register_me == nullptr)
+    {
+      fprintf(stderr, "Unable to assign function %s\n", dlerror());
+      return false;
+    }
+
+    INPUTSTREAM_unregister_me = (void (*)(void* HANDLE, void* CB))
+      dlsym(m_libKODI_inputstream, "INPUTSTREAM_unregister_me");
+    if (INPUTSTREAM_unregister_me == nullptr)
+    {
+      fprintf(stderr, "Unable to assign function %s\n", dlerror());
+      return false;
+    }
+
+    INPUTSTREAM_free_demux_packet = (void (*)(void* HANDLE, void* CB, DemuxPacket* pPacket))
+      dlsym(m_libKODI_inputstream, "INPUTSTREAM_free_demux_packet");
+    if (INPUTSTREAM_free_demux_packet == NULL)
+    {
+      fprintf(stderr, "Unable to assign function %s\n", dlerror());
+      return false;
+    }
+
+    INPUTSTREAM_allocate_demux_packet = (DemuxPacket* (*)(void* HANDLE, void* CB, int iDataSize))
+      dlsym(m_libKODI_inputstream, "INPUTSTREAM_allocate_demux_packet");
+    if (INPUTSTREAM_allocate_demux_packet == NULL)
+    {
+      fprintf(stderr, "Unable to assign function %s\n", dlerror());
+      return false;
+    }
+
+    m_Callbacks = INPUTSTREAM_register_me(m_Handle);
+    return m_Callbacks != nullptr;
+  }
+
+  /*!
+   * @brief Allocate a demux packet. Free with FreeDemuxPacket
+   * @param iDataSize The size of the data that will go into the packet
+   * @return The allocated packet
+   */
+  DemuxPacket* AllocateDemuxPacket(int iDataSize)
+  {
+    return INPUTSTREAM_allocate_demux_packet(m_Handle, m_Callbacks, iDataSize);
+  }
+
+  /*!
+   * @brief Free a packet that was allocated with AllocateDemuxPacket
+   * @param pPacket The packet to free
+   */
+  void FreeDemuxPacket(DemuxPacket* pPacket)
+  {
+    return INPUTSTREAM_free_demux_packet(m_Handle, m_Callbacks, pPacket);
+  }
+
+protected:
+  void* (*INPUTSTREAM_register_me)(void*);
+  void (*INPUTSTREAM_unregister_me)(void*, void*);
+  void (*INPUTSTREAM_free_demux_packet)(void*, void*, DemuxPacket*);
+  DemuxPacket* (*INPUTSTREAM_allocate_demux_packet)(void*, void*, int);
+
+private:
+  void* m_libKODI_inputstream;
+  void* m_Handle;
+  void* m_Callbacks;
+  struct cb_array
+  {
+    const char* libPath;
+  };
+};
diff --git a/xbmc/addons/kodi-addon-dev-kit/include/kodi/libXBMC_addon.h b/xbmc/addons/kodi-addon-dev-kit/include/kodi/libXBMC_addon.h
new file mode 100644
index 0000000..e8d5ec7
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/include/kodi/libXBMC_addon.h
@@ -0,0 +1,710 @@
+#pragma once
+/*
+ *      Copyright (C) 2005-2013 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/>.
+ *
+ */
+
+#include <string>
+#include <vector>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdarg.h>
+
+#if defined(BUILD_KODI_ADDON)
+#include "IFileTypes.h"
+#else
+#include "filesystem/IFileTypes.h"
+#endif
+
+struct VFSDirEntry;
+
+#ifdef _WIN32                   // windows
+#ifndef _SSIZE_T_DEFINED
+typedef intptr_t      ssize_t;
+#define _SSIZE_T_DEFINED
+#endif // !_SSIZE_T_DEFINED
+
+#if defined(BUILD_KODI_ADDON)
+#include "p8-platform/windows/dlfcn-win32.h"
+#else
+#include "dlfcn-win32.h"
+#endif
+
+#define ADDON_DLL               "\\library.xbmc.addon\\libXBMC_addon" ADDON_HELPER_EXT
+#define ADDON_HELPER_EXT        ".dll"
+#else // windows
+// the ADDON_HELPER_ARCH is the platform dependend name which is used
+// as part of the name of dynamic addon libraries. It has to match the 
+// strings which are set in configure.ac for the "ARCH" variable.
+#if defined(__APPLE__)          // osx
+#if defined(__arm__) || defined(__aarch64__)
+#define ADDON_HELPER_ARCH       "arm-osx"
+#else
+#define ADDON_HELPER_ARCH       "x86-osx"
+#endif
+#define ADDON_HELPER_EXT        ".dylib"
+#else                           // linux
+#if defined(__x86_64__)
+#define ADDON_HELPER_ARCH       "x86_64-linux"
+#elif defined(_POWERPC)
+#define ADDON_HELPER_ARCH       "powerpc-linux"
+#elif defined(_POWERPC64)
+#define ADDON_HELPER_ARCH       "powerpc64-linux"
+#elif defined(__ARMEL__)
+#define ADDON_HELPER_ARCH       "arm"
+#elif defined(__aarch64__)
+#define ADDON_HELPER_ARCH       "aarch64"
+#elif defined(__mips__)
+#define ADDON_HELPER_ARCH       "mips"
+#else
+#define ADDON_HELPER_ARCH       "i486-linux"
+#endif
+#define ADDON_HELPER_EXT        ".so"
+#endif
+#include <dlfcn.h>              // linux+osx
+#define ADDON_DLL_NAME "libXBMC_addon-" ADDON_HELPER_ARCH ADDON_HELPER_EXT
+#define ADDON_DLL "/library.xbmc.addon/" ADDON_DLL_NAME
+#endif
+#if defined(ANDROID)
+#include <sys/stat.h>
+#endif
+
+#ifdef LOG_DEBUG
+#undef LOG_DEBUG
+#endif
+#ifdef LOG_INFO
+#undef LOG_INFO
+#endif
+#ifdef LOG_NOTICE
+#undef LOG_NOTICE
+#endif
+#ifdef LOG_ERROR
+#undef LOG_ERROR
+#endif
+
+namespace ADDON
+{
+  typedef enum addon_log
+  {
+    LOG_DEBUG,
+    LOG_INFO,
+    LOG_NOTICE,
+    LOG_ERROR
+  } addon_log_t;
+
+  typedef enum queue_msg
+  {
+    QUEUE_INFO,
+    QUEUE_WARNING,
+    QUEUE_ERROR
+  } queue_msg_t;
+
+  class CHelper_libXBMC_addon
+  {
+  public:
+    CHelper_libXBMC_addon()
+    {
+      m_libXBMC_addon = NULL;
+      m_Handle        = NULL;
+    }
+
+    ~CHelper_libXBMC_addon()
+    {
+      if (m_libXBMC_addon)
+      {
+        XBMC_unregister_me(m_Handle, m_Callbacks);
+        dlclose(m_libXBMC_addon);
+      }
+    }
+
+    bool RegisterMe(void *Handle)
+    {
+      m_Handle = Handle;
+
+      std::string libBasePath;
+      libBasePath  = ((cb_array*)m_Handle)->libPath;
+      libBasePath += ADDON_DLL;
+
+#if defined(ANDROID)
+      struct stat st;
+      if(stat(libBasePath.c_str(),&st) != 0)
+      {
+        std::string tempbin = getenv("XBMC_ANDROID_LIBS");
+        libBasePath = tempbin + "/" + ADDON_DLL_NAME;
+      }
+#endif
+
+      m_libXBMC_addon = dlopen(libBasePath.c_str(), RTLD_LAZY);
+      if (m_libXBMC_addon == NULL)
+      {
+        fprintf(stderr, "Unable to load %s\n", dlerror());
+        return false;
+      }
+
+      XBMC_register_me = (void* (*)(void *HANDLE))
+        dlsym(m_libXBMC_addon, "XBMC_register_me");
+      if (XBMC_register_me == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+      XBMC_unregister_me = (void (*)(void* HANDLE, void* CB))
+        dlsym(m_libXBMC_addon, "XBMC_unregister_me");
+      if (XBMC_unregister_me == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+      XBMC_log = (void (*)(void* HANDLE, void* CB, const addon_log_t loglevel, const char *msg))
+        dlsym(m_libXBMC_addon, "XBMC_log");
+      if (XBMC_log == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+      XBMC_get_setting = (bool (*)(void* HANDLE, void* CB, const char* settingName, void *settingValue))
+        dlsym(m_libXBMC_addon, "XBMC_get_setting");
+      if (XBMC_get_setting == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+      XBMC_queue_notification = (void (*)(void* HANDLE, void* CB, const queue_msg_t loglevel, const char *msg))
+        dlsym(m_libXBMC_addon, "XBMC_queue_notification");
+      if (XBMC_queue_notification == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+      XBMC_wake_on_lan = (bool (*)(void* HANDLE, void *CB, const char *mac))
+        dlsym(m_libXBMC_addon, "XBMC_wake_on_lan");
+      if (XBMC_wake_on_lan == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+      XBMC_unknown_to_utf8 = (char* (*)(void* HANDLE, void* CB, const char* str))
+        dlsym(m_libXBMC_addon, "XBMC_unknown_to_utf8");
+      if (XBMC_unknown_to_utf8 == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+      XBMC_get_localized_string = (char* (*)(void* HANDLE, void* CB, int dwCode))
+        dlsym(m_libXBMC_addon, "XBMC_get_localized_string");
+      if (XBMC_get_localized_string == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+      XBMC_free_string = (void (*)(void* HANDLE, void* CB, char* str))
+        dlsym(m_libXBMC_addon, "XBMC_free_string");
+      if (XBMC_free_string == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+      XBMC_get_dvd_menu_language = (char* (*)(void* HANDLE, void* CB))
+        dlsym(m_libXBMC_addon, "XBMC_get_dvd_menu_language");
+      if (XBMC_get_dvd_menu_language == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+      XBMC_open_file = (void* (*)(void* HANDLE, void* CB, const char* strFileName, unsigned int flags))
+        dlsym(m_libXBMC_addon, "XBMC_open_file");
+      if (XBMC_open_file == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+      XBMC_open_file_for_write = (void* (*)(void* HANDLE, void* CB, const char* strFileName, bool bOverWrite))
+        dlsym(m_libXBMC_addon, "XBMC_open_file_for_write");
+      if (XBMC_open_file_for_write == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+      XBMC_read_file = (ssize_t (*)(void* HANDLE, void* CB, void* file, void* lpBuf, size_t uiBufSize))
+        dlsym(m_libXBMC_addon, "XBMC_read_file");
+      if (XBMC_read_file == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+      XBMC_read_file_string = (bool (*)(void* HANDLE, void* CB, void* file, char *szLine, int iLineLength))
+        dlsym(m_libXBMC_addon, "XBMC_read_file_string");
+      if (XBMC_read_file_string == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+      XBMC_write_file = (ssize_t (*)(void* HANDLE, void* CB, void* file, const void* lpBuf, size_t uiBufSize))
+        dlsym(m_libXBMC_addon, "XBMC_write_file");
+      if (XBMC_write_file == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+      XBMC_flush_file = (void (*)(void* HANDLE, void* CB, void* file))
+        dlsym(m_libXBMC_addon, "XBMC_flush_file");
+      if (XBMC_flush_file == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+      XBMC_seek_file = (int64_t (*)(void* HANDLE, void* CB, void* file, int64_t iFilePosition, int iWhence))
+        dlsym(m_libXBMC_addon, "XBMC_seek_file");
+      if (XBMC_seek_file == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+      XBMC_truncate_file = (int (*)(void* HANDLE, void* CB, void* file, int64_t iSize))
+        dlsym(m_libXBMC_addon, "XBMC_truncate_file");
+      if (XBMC_truncate_file == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+      XBMC_get_file_position = (int64_t (*)(void* HANDLE, void* CB, void* file))
+        dlsym(m_libXBMC_addon, "XBMC_get_file_position");
+      if (XBMC_get_file_position == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+      XBMC_get_file_length = (int64_t (*)(void* HANDLE, void* CB, void* file))
+        dlsym(m_libXBMC_addon, "XBMC_get_file_length");
+      if (XBMC_get_file_length == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+      XBMC_get_file_download_speed = (double(*)(void* HANDLE, void* CB, void* file))
+        dlsym(m_libXBMC_addon, "XBMC_get_file_download_speed");
+      if (XBMC_get_file_download_speed == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+      XBMC_close_file = (void (*)(void* HANDLE, void* CB, void* file))
+        dlsym(m_libXBMC_addon, "XBMC_close_file");
+      if (XBMC_close_file == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+      XBMC_get_file_chunk_size = (int (*)(void* HANDLE, void* CB, void* file))
+        dlsym(m_libXBMC_addon, "XBMC_get_file_chunk_size");
+      if (XBMC_get_file_chunk_size == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+      XBMC_file_exists = (bool (*)(void* HANDLE, void* CB, const char *strFileName, bool bUseCache))
+        dlsym(m_libXBMC_addon, "XBMC_file_exists");
+      if (XBMC_file_exists == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+      XBMC_stat_file = (int (*)(void* HANDLE, void* CB, const char *strFileName, struct __stat64* buffer))
+        dlsym(m_libXBMC_addon, "XBMC_stat_file");
+      if (XBMC_stat_file == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+      XBMC_delete_file = (bool (*)(void* HANDLE, void* CB, const char *strFileName))
+        dlsym(m_libXBMC_addon, "XBMC_delete_file");
+      if (XBMC_delete_file == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+      XBMC_can_open_directory = (bool (*)(void* HANDLE, void* CB, const char* strURL))
+        dlsym(m_libXBMC_addon, "XBMC_can_open_directory");
+      if (XBMC_can_open_directory == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+      XBMC_create_directory = (bool (*)(void* HANDLE, void* CB, const char* strPath))
+        dlsym(m_libXBMC_addon, "XBMC_create_directory");
+      if (XBMC_create_directory == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+      XBMC_directory_exists = (bool (*)(void* HANDLE, void* CB, const char* strPath))
+        dlsym(m_libXBMC_addon, "XBMC_directory_exists");
+      if (XBMC_directory_exists == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+      XBMC_remove_directory = (bool (*)(void* HANDLE, void* CB, const char* strPath))
+        dlsym(m_libXBMC_addon, "XBMC_remove_directory");
+      if (XBMC_remove_directory == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+      XBMC_get_directory = (bool (*)(void* HANDLE, void* CB, const char* strPath, const char* mask, VFSDirEntry** items, unsigned int* num_items))
+        dlsym(m_libXBMC_addon, "XBMC_get_directory");
+      if (XBMC_get_directory == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+      XBMC_free_directory = (void (*)(void* HANDLE, void* CB, VFSDirEntry* items, unsigned int num_items))
+        dlsym(m_libXBMC_addon, "XBMC_free_directory");
+      if (XBMC_free_directory == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+      XBMC_curl_create = (void* (*)(void *HANDLE, void* CB, const char* strURL))
+        dlsym(m_libXBMC_addon, "XBMC_curl_create");
+      if (XBMC_curl_create == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+      XBMC_curl_add_option = (bool (*)(void *HANDLE, void* CB, void *file, XFILE::CURLOPTIONTYPE type, const char* name, const char *value))
+        dlsym(m_libXBMC_addon, "XBMC_curl_add_option");
+      if (XBMC_curl_add_option == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+      XBMC_curl_open = (bool (*)(void *HANDLE, void* CB, void *file, unsigned int flags))
+        dlsym(m_libXBMC_addon, "XBMC_curl_open");
+      if (XBMC_curl_open == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+      m_Callbacks = XBMC_register_me(m_Handle);
+      return m_Callbacks != NULL;
+    }
+
+    /*!
+     * @brief Add a message to XBMC's log.
+     * @param loglevel The log level of the message.
+     * @param format The format of the message to pass to XBMC.
+     */
+    void Log(const addon_log_t loglevel, const char *format, ... )
+    {
+      char buffer[16384];
+      va_list args;
+      va_start (args, format);
+      vsprintf (buffer, format, args);
+      va_end (args);
+      return XBMC_log(m_Handle, m_Callbacks, loglevel, buffer);
+    }
+
+    /*!
+     * @brief Get a settings value for this add-on.
+     * @param settingName The name of the setting to get.
+     * @param settingValue The value.
+     * @return True if the settings was fetched successfully, false otherwise.
+     */
+    bool GetSetting(const char* settingName, void *settingValue)
+    {
+      return XBMC_get_setting(m_Handle, m_Callbacks, settingName, settingValue);
+    }
+
+    /*!
+     * @brief Queue a notification in the GUI.
+     * @param type The message type.
+     * @param format The format of the message to pass to display in XBMC.
+     */
+    void QueueNotification(const queue_msg_t type, const char *format, ... )
+    {
+      char buffer[16384];
+      va_list args;
+      va_start (args, format);
+      vsprintf (buffer, format, args);
+      va_end (args);
+      return XBMC_queue_notification(m_Handle, m_Callbacks, type, buffer);
+    }
+
+    /*!
+     * @brief Send WakeOnLan magic packet.
+     * @param mac Network address of the host to wake.
+     * @return True if the magic packet was successfully sent, false otherwise.
+     */
+    bool WakeOnLan(const char* mac)
+    {
+      return XBMC_wake_on_lan(m_Handle, m_Callbacks, mac);
+    }
+
+    /*!
+     * @brief Translate a string with an unknown encoding to UTF8.
+     * @param str The string to translate.
+     * @return The string translated to UTF8. Must be freed by calling FreeString() when done.
+     */
+    char* UnknownToUTF8(const char* str)
+    {
+      return XBMC_unknown_to_utf8(m_Handle, m_Callbacks, str);
+    }
+
+    /*!
+     * @brief Get a localised message.
+     * @param dwCode The code of the message to get.
+     * @return The message. Must be freed by calling FreeString() when done.
+     */
+    char* GetLocalizedString(int dwCode)
+    {
+      return XBMC_get_localized_string(m_Handle, m_Callbacks, dwCode);
+    }
+
+
+    /*!
+     * @brief Get the DVD menu language.
+     * @return The language. Must be freed by calling FreeString() when done.
+     */
+    char* GetDVDMenuLanguage()
+    {
+      return XBMC_get_dvd_menu_language(m_Handle, m_Callbacks);
+    }
+
+    /*!
+     * @brief Free the memory used by str
+     * @param str The string to free
+     */
+    void FreeString(char* str)
+    {
+      return XBMC_free_string(m_Handle, m_Callbacks, str);
+    }
+
+    /*!
+     * @brief Open the file with filename via XBMC's CFile. Needs to be closed by calling CloseFile() when done.
+     * @param strFileName The filename to open.
+     * @param flags The flags to pass. Documented in XBMC's File.h
+     * @return A handle for the file, or NULL if it couldn't be opened.
+     */
+    void* OpenFile(const char* strFileName, unsigned int flags)
+    {
+      return XBMC_open_file(m_Handle, m_Callbacks, strFileName, flags);
+    }
+
+    /*!
+     * @brief Open the file with filename via XBMC's CFile in write mode. Needs to be closed by calling CloseFile() when done.
+     * @param strFileName The filename to open.
+     * @param bOverWrite True to overwrite, false otherwise.
+     * @return A handle for the file, or NULL if it couldn't be opened.
+     */
+    void* OpenFileForWrite(const char* strFileName, bool bOverWrite)
+    {
+      return XBMC_open_file_for_write(m_Handle, m_Callbacks, strFileName, bOverWrite);
+    }
+
+    /*!
+     * @brief Read from an open file.
+     * @param file The file handle to read from.
+     * @param lpBuf The buffer to store the data in.
+     * @param uiBufSize The size of the buffer.
+     * @return number of successfully read bytes if any bytes were read and stored in
+     *         buffer, zero if no bytes are available to read (end of file was reached)
+     *         or undetectable error occur, -1 in case of any explicit error
+     */
+    ssize_t ReadFile(void* file, void* lpBuf, size_t uiBufSize)
+    {
+      return XBMC_read_file(m_Handle, m_Callbacks, file, lpBuf, uiBufSize);
+    }
+
+    /*!
+     * @brief Read a string from an open file.
+     * @param file The file handle to read from.
+     * @param szLine The buffer to store the data in.
+     * @param iLineLength The size of the buffer.
+     * @return True when a line was read, false otherwise.
+     */
+    bool ReadFileString(void* file, char *szLine, int iLineLength)
+    {
+      return XBMC_read_file_string(m_Handle, m_Callbacks, file, szLine, iLineLength);
+    }
+
+    /*!
+     * @brief Write to a file opened in write mode.
+     * @param file The file handle to write to.
+     * @param lpBuf The data to write.
+     * @param uiBufSize Size of the data to write.
+     * @return number of successfully written bytes if any bytes were written,
+     *         zero if no bytes were written and no detectable error occur,
+     *         -1 in case of any explicit error
+     */
+    ssize_t WriteFile(void* file, const void* lpBuf, size_t uiBufSize)
+    {
+      return XBMC_write_file(m_Handle, m_Callbacks, file, lpBuf, uiBufSize);
+    }
+
+    /*!
+     * @brief Flush buffered data.
+     * @param file The file handle to flush the data for.
+     */
+    void FlushFile(void* file)
+    {
+       return XBMC_flush_file(m_Handle, m_Callbacks, file);
+    }
+
+    /*!
+     * @brief Seek in an open file.
+     * @param file The file handle to see in.
+     * @param iFilePosition The new position.
+     * @param iWhence Seek argument. See stdio.h for possible values.
+     * @return The new position.
+     */
+    int64_t SeekFile(void* file, int64_t iFilePosition, int iWhence)
+    {
+      return XBMC_seek_file(m_Handle, m_Callbacks, file, iFilePosition, iWhence);
+    }
+
+    /*!
+     * @brief Truncate a file to the requested size.
+     * @param file The file handle to truncate.
+     * @param iSize The new max size.
+     * @return New size?
+     */
+    int TruncateFile(void* file, int64_t iSize)
+    {
+      return XBMC_truncate_file(m_Handle, m_Callbacks, file, iSize);
+    }
+
+    /*!
+     * @brief The current position in an open file.
+     * @param file The file handle to get the position for.
+     * @return The requested position.
+     */
+    int64_t GetFilePosition(void* file)
+    {
+      return XBMC_get_file_position(m_Handle, m_Callbacks, file);
+    }
+
+    /*!
+     * @brief Get the file size of an open file.
+     * @param file The file to get the size for.
+     * @return The requested size.
+     */
+    int64_t GetFileLength(void* file)
+    {
+      return XBMC_get_file_length(m_Handle, m_Callbacks, file);
+    }
+
+    /*!
+    * @brief Get the download speed of an open file if available.
+    * @param file The file to get the size for.
+    * @return The download speed in seconds.
+    */
+    double GetFileDownloadSpeed(void* file)
+    {
+      return XBMC_get_file_download_speed(m_Handle, m_Callbacks, file);
+    }
+
+    /*!
+     * @brief Close an open file.
+     * @param file The file handle to close.
+     */
+    void CloseFile(void* file)
+    {
+      return XBMC_close_file(m_Handle, m_Callbacks, file);
+    }
+
+    /*!
+     * @brief Get the chunk size for an open file.
+     * @param file the file handle to get the size for.
+     * @return The requested size.
+     */
+    int GetFileChunkSize(void* file)
+    {
+      return XBMC_get_file_chunk_size(m_Handle, m_Callbacks, file);
+    }
+
+    /*!
+     * @brief Check if a file exists.
+     * @param strFileName The filename to check.
+     * @param bUseCache Check in file cache.
+     * @return true if the file exists false otherwise.
+     */
+    bool FileExists(const char *strFileName, bool bUseCache)
+    {
+      return XBMC_file_exists(m_Handle, m_Callbacks, strFileName, bUseCache);
+    }
+
+    /*!
+     * @brief Reads file status.
+     * @param strFileName The filename to read the status from.
+     * @param buffer The file status is written into this buffer.
+     * @return The file status was successfully read.
+     */
+    int StatFile(const char *strFileName, struct __stat64* buffer)
+    {
+      return XBMC_stat_file(m_Handle, m_Callbacks, strFileName, buffer);
+    }
+
+    /*!
+     * @brief Deletes a file.
+     * @param strFileName The filename to delete.
+     * @return The file was successfully deleted.
+     */
+    bool DeleteFile(const char *strFileName)
+    {
+      return XBMC_delete_file(m_Handle, m_Callbacks, strFileName);
+    }
+
+    /*!
+     * @brief Checks whether a directory can be opened.
+     * @param strUrl The URL of the directory to check.
+     * @return True when it can be opened, false otherwise.
+     */
+    bool CanOpenDirectory(const char* strUrl)
+    {
+      return XBMC_can_open_directory(m_Handle, m_Callbacks, strUrl);
+    }
+
+    /*!
+     * @brief Creates a directory.
+     * @param strPath Path to the directory.
+     * @return True when it was created, false otherwise.
+     */
+    bool CreateDirectory(const char *strPath)
+    {
+      return XBMC_create_directory(m_Handle, m_Callbacks, strPath);
+    }
+
+    /*!
+     * @brief Checks if a directory exists.
+     * @param strPath Path to the directory.
+     * @return True when it exists, false otherwise.
+     */
+    bool DirectoryExists(const char *strPath)
+    {
+      return XBMC_directory_exists(m_Handle, m_Callbacks, strPath);
+    }
+
+    /*!
+     * @brief Removes a directory.
+     * @param strPath Path to the directory.
+     * @return True when it was removed, false otherwise.
+     */
+    bool RemoveDirectory(const char *strPath)
+    {
+      return XBMC_remove_directory(m_Handle, m_Callbacks, strPath);
+    }
+
+    /*!
+     * @brief Lists a directory.
+     * @param strPath Path to the directory.
+     * @param mask File mask
+     * @param items The directory entries
+     * @param num_items Number of entries in directory
+     * @return True if listing was successful, false otherwise.
+     */
+    bool GetDirectory(const char *strPath, const char* mask, VFSDirEntry** items, unsigned int* num_items)
+    {
+      return XBMC_get_directory(m_Handle, m_Callbacks, strPath, mask, items, num_items);
+    }
+
+    /*!
+     * @brief Free a directory list
+     * @param items The directory entries
+     * @param num_items Number of entries in directory
+     */
+    void FreeDirectory(VFSDirEntry* items, unsigned int num_items)
+    {
+      return XBMC_free_directory(m_Handle, m_Callbacks, items, num_items);
+    }
+
+    /*!
+    * @brief Create a Curl representation
+    * @param strURL the URL of the Type.
+    */
+    void* CURLCreate(const char* strURL)
+    {
+      return XBMC_curl_create(m_Handle, m_Callbacks, strURL);
+    }
+
+    /*!
+    * @brief Adds options to the curl file created with CURLCeate
+    * @param file file pointer to the file returned by CURLCeate
+    * @param type option type to set
+    * @param name name of the option
+    * @param value value of the option
+    */
+    bool CURLAddOption(void* file, XFILE::CURLOPTIONTYPE type, const char* name, const char * value)
+    {
+      return XBMC_curl_add_option(m_Handle, m_Callbacks, file, type, name, value);
+    }
+
+    /*!
+    * @brief Opens the curl file created with CURLCeate
+    * @param file file pointer to the file returned by CURLCeate
+    * @param flags one or more bitwise or combinded flags form XFILE
+    */
+    bool CURLOpen(void* file, unsigned int flags)
+    {
+      return XBMC_curl_open(m_Handle, m_Callbacks, file, flags);
+    }
+
+  protected:
+    void* (*XBMC_register_me)(void *HANDLE);
+    void (*XBMC_unregister_me)(void *HANDLE, void* CB);
+    void (*XBMC_log)(void *HANDLE, void* CB, const addon_log_t loglevel, const char *msg);
+    bool (*XBMC_get_setting)(void *HANDLE, void* CB, const char* settingName, void *settingValue);
+    void (*XBMC_queue_notification)(void *HANDLE, void* CB, const queue_msg_t type, const char *msg);
+    bool (*XBMC_wake_on_lan)(void *HANDLE, void* CB, const char* mac);
+    char* (*XBMC_unknown_to_utf8)(void *HANDLE, void* CB, const char* str);
+    char* (*XBMC_get_localized_string)(void *HANDLE, void* CB, int dwCode);
+    char* (*XBMC_get_dvd_menu_language)(void *HANDLE, void* CB);
+    void (*XBMC_free_string)(void *HANDLE, void* CB, char* str);
+    void* (*XBMC_open_file)(void *HANDLE, void* CB, const char* strFileName, unsigned int flags);
+    void* (*XBMC_open_file_for_write)(void *HANDLE, void* CB, const char* strFileName, bool bOverWrite);
+    ssize_t (*XBMC_read_file)(void *HANDLE, void* CB, void* file, void* lpBuf, size_t uiBufSize);
+    bool (*XBMC_read_file_string)(void *HANDLE, void* CB, void* file, char *szLine, int iLineLength);
+    ssize_t(*XBMC_write_file)(void *HANDLE, void* CB, void* file, const void* lpBuf, size_t uiBufSize);
+    void (*XBMC_flush_file)(void *HANDLE, void* CB, void* file);
+    int64_t (*XBMC_seek_file)(void *HANDLE, void* CB, void* file, int64_t iFilePosition, int iWhence);
+    int (*XBMC_truncate_file)(void *HANDLE, void* CB, void* file, int64_t iSize);
+    int64_t (*XBMC_get_file_position)(void *HANDLE, void* CB, void* file);
+    int64_t (*XBMC_get_file_length)(void *HANDLE, void* CB, void* file);
+    double(*XBMC_get_file_download_speed)(void *HANDLE, void* CB, void* file);
+    void (*XBMC_close_file)(void *HANDLE, void* CB, void* file);
+    int (*XBMC_get_file_chunk_size)(void *HANDLE, void* CB, void* file);
+    bool (*XBMC_file_exists)(void *HANDLE, void* CB, const char *strFileName, bool bUseCache);
+    int (*XBMC_stat_file)(void *HANDLE, void* CB, const char *strFileName, struct __stat64* buffer);
+    bool (*XBMC_delete_file)(void *HANDLE, void* CB, const char *strFileName);
+    bool (*XBMC_can_open_directory)(void *HANDLE, void* CB, const char* strURL);
+    bool (*XBMC_create_directory)(void *HANDLE, void* CB, const char* strPath);
+    bool (*XBMC_directory_exists)(void *HANDLE, void* CB, const char* strPath);
+    bool (*XBMC_remove_directory)(void *HANDLE, void* CB, const char* strPath);
+    bool (*XBMC_get_directory)(void *HANDLE, void* CB, const char* strPath, const char* mask, VFSDirEntry** items, unsigned int* num_items);
+    void (*XBMC_free_directory)(void *HANDLE, void* CB, VFSDirEntry* items, unsigned int num_items);
+    void* (*XBMC_curl_create)(void *HANDLE, void* CB, const char* strURL);
+    bool (*XBMC_curl_add_option)(void *HANDLE, void* CB, void *file, XFILE::CURLOPTIONTYPE type, const char* name, const char *value);
+    bool (*XBMC_curl_open)(void *m_Handle, void *m_Callbacks, void *file, unsigned int flags);
+
+  private:
+    void *m_libXBMC_addon;
+    void *m_Handle;
+    void *m_Callbacks;
+    struct cb_array
+    {
+      const char* libPath;
+    };
+  };
+};
diff --git a/xbmc/addons/kodi-addon-dev-kit/include/kodi/libXBMC_codec.h b/xbmc/addons/kodi-addon-dev-kit/include/kodi/libXBMC_codec.h
new file mode 100644
index 0000000..3853f08
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/include/kodi/libXBMC_codec.h
@@ -0,0 +1,124 @@
+#pragma once
+/*
+ *      Copyright (C) 2005-2013 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/>.
+ *
+ */
+
+#include <string>
+#include <vector>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include "xbmc_codec_types.h"
+#include "libXBMC_addon.h"
+
+#ifdef _WIN32
+#define CODEC_HELPER_DLL "\\library.xbmc.codec\\libXBMC_codec" ADDON_HELPER_EXT
+#else
+#define CODEC_HELPER_DLL_NAME "libXBMC_codec-" ADDON_HELPER_ARCH ADDON_HELPER_EXT
+#define CODEC_HELPER_DLL "/library.xbmc.codec/" CODEC_HELPER_DLL_NAME
+#endif
+
+class CHelper_libXBMC_codec
+{
+public:
+  CHelper_libXBMC_codec(void)
+  {
+    m_libXBMC_codec = NULL;
+    m_Handle        = NULL;
+  }
+
+  ~CHelper_libXBMC_codec(void)
+  {
+    if (m_libXBMC_codec)
+    {
+      CODEC_unregister_me(m_Handle, m_Callbacks);
+      dlclose(m_libXBMC_codec);
+    }
+  }
+
+  /*!
+   * @brief Resolve all callback methods
+   * @param handle Pointer to the add-on
+   * @return True when all methods were resolved, false otherwise.
+   */
+  bool RegisterMe(void* handle)
+  {
+    m_Handle = handle;
+
+    std::string libBasePath;
+    libBasePath  = ((cb_array*)m_Handle)->libPath;
+    libBasePath += CODEC_HELPER_DLL;
+
+#if defined(ANDROID)
+      struct stat st;
+      if(stat(libBasePath.c_str(),&st) != 0)
+      {
+        std::string tempbin = getenv("XBMC_ANDROID_LIBS");
+        libBasePath = tempbin + "/" + CODEC_HELPER_DLL_NAME;
+      }
+#endif
+
+    m_libXBMC_codec = dlopen(libBasePath.c_str(), RTLD_LAZY);
+    if (m_libXBMC_codec == NULL)
+    {
+      fprintf(stderr, "Unable to load %s\n", dlerror());
+      return false;
+    }
+
+    CODEC_register_me = (void* (*)(void *HANDLE))
+      dlsym(m_libXBMC_codec, "CODEC_register_me");
+    if (CODEC_register_me == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    CODEC_unregister_me = (void (*)(void* HANDLE, void* CB))
+      dlsym(m_libXBMC_codec, "CODEC_unregister_me");
+    if (CODEC_unregister_me == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    CODEC_get_codec_by_name = (xbmc_codec_t (*)(void* HANDLE, void* CB, const char* strCodecName))
+        dlsym(m_libXBMC_codec, "CODEC_get_codec_by_name");
+    if (CODEC_get_codec_by_name == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    m_Callbacks = CODEC_register_me(m_Handle);
+    return m_Callbacks != NULL;
+  }
+
+  /*!
+   * @brief Get the codec id used by XBMC
+   * @param strCodecName The name of the codec
+   * @return The codec_id, or a codec_id with 0 values when not supported
+   */
+  xbmc_codec_t GetCodecByName(const char* strCodecName)
+  {
+    return CODEC_get_codec_by_name(m_Handle, m_Callbacks, strCodecName);
+  }
+
+protected:
+  void* (*CODEC_register_me)(void*);
+  void (*CODEC_unregister_me)(void*, void*);
+  xbmc_codec_t (*CODEC_get_codec_by_name)(void *HANDLE, void* CB, const char* strCodecName);
+
+private:
+  void* m_libXBMC_codec;
+  void* m_Handle;
+  void* m_Callbacks;
+  struct cb_array
+  {
+    const char* libPath;
+  };
+};
+
diff --git a/xbmc/addons/kodi-addon-dev-kit/include/kodi/libXBMC_pvr.h b/xbmc/addons/kodi-addon-dev-kit/include/kodi/libXBMC_pvr.h
new file mode 100644
index 0000000..3e3d479
--- /dev/null
+++ b/xbmc/addons/kodi-addon-dev-kit/include/kodi/libXBMC_pvr.h
@@ -0,0 +1,366 @@
+#pragma once
+/*
+ *      Copyright (C) 2005-2013 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/>.
+ *
+ */
+
+#include <string>
+#include <vector>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include "xbmc_pvr_types.h"
+#include "libXBMC_addon.h"
+
+#ifdef _WIN32
+#define PVR_HELPER_DLL "\\library.xbmc.pvr\\libXBMC_pvr" ADDON_HELPER_EXT
+#else
+#define PVR_HELPER_DLL_NAME "libXBMC_pvr-" ADDON_HELPER_ARCH ADDON_HELPER_EXT
+#define PVR_HELPER_DLL "/library.xbmc.pvr/" PVR_HELPER_DLL_NAME
+#endif
+
+#define DVD_TIME_BASE 1000000
+#define DVD_NOPTS_VALUE    (-1LL<<52) // should be possible to represent in both double and __int64
+
+class CHelper_libXBMC_pvr
+{
+public:
+  CHelper_libXBMC_pvr(void)
+  {
+    m_libXBMC_pvr = NULL;
+    m_Handle      = NULL;
+  }
+
+  ~CHelper_libXBMC_pvr(void)
+  {
+    if (m_libXBMC_pvr)
+    {
+      PVR_unregister_me(m_Handle, m_Callbacks);
+      dlclose(m_libXBMC_pvr);
+    }
+  }
+
+  /*!
+   * @brief Resolve all callback methods
+   * @param handle Pointer to the add-on
+   * @return True when all methods were resolved, false otherwise.
+   */
+  bool RegisterMe(void* handle)
+  {
+    m_Handle = handle;
+
+    std::string libBasePath;
+    libBasePath  = ((cb_array*)m_Handle)->libPath;
+    libBasePath += PVR_HELPER_DLL;
+
+#if defined(ANDROID)
+      struct stat st;
+      if(stat(libBasePath.c_str(),&st) != 0)
+      {
+        std::string tempbin = getenv("XBMC_ANDROID_LIBS");
+        libBasePath = tempbin + "/" + PVR_HELPER_DLL_NAME;
+      }
+#endif
+
+    m_libXBMC_pvr = dlopen(libBasePath.c_str(), RTLD_LAZY);
+    if (m_libXBMC_pvr == NULL)
+    {
+      fprintf(stderr, "Unable to load %s\n", dlerror());
+      return false;
+    }
+
+    PVR_register_me = (void* (*)(void *HANDLE))
+      dlsym(m_libXBMC_pvr, "PVR_register_me");
+    if (PVR_register_me == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    PVR_unregister_me = (void (*)(void* HANDLE, void* CB))
+      dlsym(m_libXBMC_pvr, "PVR_unregister_me");
+    if (PVR_unregister_me == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    PVR_transfer_epg_entry = (void (*)(void* HANDLE, void* CB, const ADDON_HANDLE handle, const EPG_TAG *epgentry))
+      dlsym(m_libXBMC_pvr, "PVR_transfer_epg_entry");
+    if (PVR_transfer_epg_entry == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    PVR_transfer_channel_entry = (void (*)(void* HANDLE, void* CB, const ADDON_HANDLE handle, const PVR_CHANNEL *chan))
+      dlsym(m_libXBMC_pvr, "PVR_transfer_channel_entry");
+    if (PVR_transfer_channel_entry == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    PVR_transfer_timer_entry = (void (*)(void* HANDLE, void* CB, const ADDON_HANDLE handle, const PVR_TIMER *timer))
+      dlsym(m_libXBMC_pvr, "PVR_transfer_timer_entry");
+    if (PVR_transfer_timer_entry == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    PVR_transfer_recording_entry = (void (*)(void* HANDLE, void* CB, const ADDON_HANDLE handle, const PVR_RECORDING *recording))
+      dlsym(m_libXBMC_pvr, "PVR_transfer_recording_entry");
+    if (PVR_transfer_recording_entry == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    PVR_add_menu_hook = (void (*)(void* HANDLE, void* CB, PVR_MENUHOOK *hook))
+      dlsym(m_libXBMC_pvr, "PVR_add_menu_hook");
+    if (PVR_add_menu_hook == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    PVR_recording = (void (*)(void* HANDLE, void* CB, const char *Name, const char *FileName, bool On))
+      dlsym(m_libXBMC_pvr, "PVR_recording");
+    if (PVR_recording == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    PVR_trigger_timer_update = (void (*)(void* HANDLE, void* CB))
+      dlsym(m_libXBMC_pvr, "PVR_trigger_timer_update");
+    if (PVR_trigger_timer_update == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    PVR_trigger_recording_update = (void (*)(void* HANDLE, void* CB))
+      dlsym(m_libXBMC_pvr, "PVR_trigger_recording_update");
+    if (PVR_trigger_recording_update == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    PVR_trigger_channel_update = (void (*)(void* HANDLE, void* CB))
+      dlsym(m_libXBMC_pvr, "PVR_trigger_channel_update");
+    if (PVR_trigger_channel_update == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    PVR_trigger_channel_groups_update = (void (*)(void* HANDLE, void* CB))
+      dlsym(m_libXBMC_pvr, "PVR_trigger_channel_groups_update");
+    if (PVR_trigger_channel_groups_update == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    PVR_trigger_epg_update = (void (*)(void* HANDLE, void* CB, unsigned int iChannelUid))
+      dlsym(m_libXBMC_pvr, "PVR_trigger_epg_update");
+    if (PVR_trigger_epg_update == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    PVR_transfer_channel_group  = (void (*)(void* HANDLE, void* CB, const ADDON_HANDLE handle, const PVR_CHANNEL_GROUP *group))
+      dlsym(m_libXBMC_pvr, "PVR_transfer_channel_group");
+    if (PVR_transfer_channel_group == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    PVR_transfer_channel_group_member = (void (*)(void* HANDLE, void* CB, const ADDON_HANDLE handle, const PVR_CHANNEL_GROUP_MEMBER *member))
+      dlsym(m_libXBMC_pvr, "PVR_transfer_channel_group_member");
+    if (PVR_transfer_channel_group_member == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+#ifdef USE_DEMUX
+    PVR_free_demux_packet = (void (*)(void* HANDLE, void* CB, DemuxPacket* pPacket))
+      dlsym(m_libXBMC_pvr, "PVR_free_demux_packet");
+    if (PVR_free_demux_packet == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    PVR_allocate_demux_packet = (DemuxPacket* (*)(void* HANDLE, void* CB, int iDataSize))
+      dlsym(m_libXBMC_pvr, "PVR_allocate_demux_packet");
+    if (PVR_allocate_demux_packet == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+#endif
+
+    PVR_connection_state_change = (void (*)(void* HANDLE, void* CB, const char *strConnectionString, PVR_CONNECTION_STATE newState, const char *strMessage))
+      dlsym(m_libXBMC_pvr, "PVR_connection_state_change");
+    if (PVR_connection_state_change == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    PVR_epg_event_state_change = (void (*)(void* HANDLE, void* CB, EPG_TAG* tag, unsigned int iUniqueChannelId, EPG_EVENT_STATE newState))
+      dlsym(m_libXBMC_pvr, "PVR_epg_event_state_change");
+    if (PVR_epg_event_state_change == NULL) { fprintf(stderr, "Unable to assign function %s\n", dlerror()); return false; }
+
+    m_Callbacks = PVR_register_me(m_Handle);
+    return m_Callbacks != NULL;
+  }
+
+  /*!
+   * @brief Transfer an EPG tag from the add-on to XBMC
+   * @param handle The handle parameter that XBMC used when requesting the EPG data
+   * @param entry The entry to transfer to XBMC
+   */
+  void TransferEpgEntry(const ADDON_HANDLE handle, const EPG_TAG* entry)
+  {
+    return PVR_transfer_epg_entry(m_Handle, m_Callbacks, handle, entry);
+  }
+
+  /*!
+   * @brief Transfer a channel entry from the add-on to XBMC
+   * @param handle The handle parameter that XBMC used when requesting the channel list
+   * @param entry The entry to transfer to XBMC
+   */
+  void TransferChannelEntry(const ADDON_HANDLE handle, const PVR_CHANNEL* entry)
+  {
+    return PVR_transfer_channel_entry(m_Handle, m_Callbacks, handle, entry);
+  }
+
+  /*!
+   * @brief Transfer a timer entry from the add-on to XBMC
+   * @param handle The handle parameter that XBMC used when requesting the timers list
+   * @param entry The entry to transfer to XBMC
+   */
+  void TransferTimerEntry(const ADDON_HANDLE handle, const PVR_TIMER* entry)
+  {
+    return PVR_transfer_timer_entry(m_Handle, m_Callbacks, handle, entry);
+  }
+
+  /*!
+   * @brief Transfer a recording entry from the add-on to XBMC
+   * @param handle The handle parameter that XBMC used when requesting the recordings list
+   * @param entry The entry to transfer to XBMC
+   */
+  void TransferRecordingEntry(const ADDON_HANDLE handle, const PVR_RECORDING* entry)
+  {
+    return PVR_transfer_recording_entry(m_Handle, m_Callbacks, handle, entry);
+  }
+
+  /*!
+   * @brief Transfer a channel group from the add-on to XBMC. The group will be created if it doesn't exist.
+   * @param handle The handle parameter that XBMC used when requesting the channel groups list
+   * @param entry The entry to transfer to XBMC
+   */
+  void TransferChannelGroup(const ADDON_HANDLE handle, const PVR_CHANNEL_GROUP* entry)
+  {
+    return PVR_transfer_channel_group(m_Handle, m_Callbacks, handle, entry);
+  }
+
+  /*!
+   * @brief Transfer a channel group member entry from the add-on to XBMC. The channel will be added to the group if the group can be found.
+   * @param handle The handle parameter that XBMC used when requesting the channel group members list
+   * @param entry The entry to transfer to XBMC
+   */
+  void TransferChannelGroupMember(const ADDON_HANDLE handle, const PVR_CHANNEL_GROUP_MEMBER* entry)
+  {
+    return PVR_transfer_channel_group_member(m_Handle, m_Callbacks, handle, entry);
+  }
+
+  /*!
+   * @brief Add or replace a menu hook for the context menu for this add-on
+   * @param hook The hook to add
+   */
+  void AddMenuHook(PVR_MENUHOOK* hook)
+  {
+    return PVR_add_menu_hook(m_Handle, m_Callbacks, hook);
+  }
+
+  /*!
+   * @brief Display a notification in XBMC that a recording started or stopped on the server
+   * @param strRecordingName The name of the recording to display
+   * @param strFileName The filename of the recording
+   * @param bOn True when recording started, false when it stopped
+   */
+  void Recording(const char* strRecordingName, const char* strFileName, bool bOn)
+  {
+    return PVR_recording(m_Handle, m_Callbacks, strRecordingName, strFileName, bOn);
+  }
+
+  /*!
+   * @brief Request XBMC to update it's list of timers
+   */
+  void TriggerTimerUpdate(void)
+  {
+    return PVR_trigger_timer_update(m_Handle, m_Callbacks);
+  }
+
+  /*!
+   * @brief Request XBMC to update it's list of recordings
+   */
+  void TriggerRecordingUpdate(void)
+  {
+    return PVR_trigger_recording_update(m_Handle, m_Callbacks);
+  }
+
+  /*!
+   * @brief Request XBMC to update it's list of channels
+   */
+  void TriggerChannelUpdate(void)
+  {
+    return PVR_trigger_channel_update(m_Handle, m_Callbacks);
+  }
+
+  /*!
+   * @brief Schedule an EPG update for the given channel channel
+   * @param iChannelUid The unique id of the channel for this add-on
+   */
+  void TriggerEpgUpdate(unsigned int iChannelUid)
+  {
+    return PVR_trigger_epg_update(m_Handle, m_Callbacks, iChannelUid);
+  }
+
+  /*!
+   * @brief Request XBMC to update it's list of channel groups
+   */
+  void TriggerChannelGroupsUpdate(void)
+  {
+    return PVR_trigger_channel_groups_update(m_Handle, m_Callbacks);
+  }
+
+#ifdef USE_DEMUX
+  /*!
+   * @brief Free a packet that was allocated with AllocateDemuxPacket
+   * @param pPacket The packet to free
+   */
+  void FreeDemuxPacket(DemuxPacket* pPacket)
+  {
+    return PVR_free_demux_packet(m_Handle, m_Callbacks, pPacket);
+  }
+
+  /*!
+   * @brief Allocate a demux packet. Free with FreeDemuxPacket
+   * @param iDataSize The size of the data that will go into the packet
+   * @return The allocated packet
+   */
+  DemuxPacket* AllocateDemuxPacket(int iDataSize)
+  {
+    return PVR_allocate_demux_packet(m_Handle, m_Callbacks, iDataSize);
+  }
+#endif
+
+  /*!
+   * @brief Notify a state change for a PVR backend connection
+   * @param strConnectionString The connection string reported by the backend that can be displayed in the UI.
+   * @param newState The new state.
+   * @param strMessage A localized addon-defined string representing the new state, that can be displayed
+   *        in the UI or NULL if the Kodi-defined default string for the new state shall be displayed.
+   */
+  void ConnectionStateChange(const char *strConnectionString, PVR_CONNECTION_STATE newState, const char *strMessage)
+  {
+    return PVR_connection_state_change(m_Handle, m_Callbacks, strConnectionString, newState, strMessage);
+  }
+
+  /*!
+   * @brief Notify a state change for an EPG event
+   * @param tag The EPG event.
+   * @param iUniqueChannelId The unique id of the channel for the EPG event
+   * @param newState The new state. For EPG_EVENT_CREATED and EPG_EVENT_UPDATED, tag must be filled with all available
+   *        event data, not just a delta. For EPG_EVENT_DELETED, it is sufficient to fill EPG_TAG.iUniqueBroadcastId
+   */
+  void EpgEventStateChange(EPG_TAG *tag, unsigned int iUniqueChannelId, EPG_EVENT_STATE newState)
+  {
+    return PVR_epg_event_state_change(m_Handle, m_Callbacks, tag, iUniqueChannelId, newState);
+  }
+
+protected:
+  void* (*PVR_register_me)(void*);
+  void (*PVR_unregister_me)(void*, void*);
+  void (*PVR_transfer_epg_entry)(void*, void*, const ADDON_HANDLE, const EPG_TAG*);
+  void (*PVR_transfer_channel_entry)(void*, void*, const ADDON_HANDLE, const PVR_CHANNEL*);
+  void (*PVR_transfer_timer_entry)(void*, void*, const ADDON_HANDLE, const PVR_TIMER*);
+  void (*PVR_transfer_recording_entry)(void*, void*, const ADDON_HANDLE, const PVR_RECORDING*);
+  void (*PVR_add_menu_hook)(void*, void*, PVR_MENUHOOK*);
+  void (*PVR_recording)(void*, void*, const char*, const char*, bool);
+  void (*PVR_trigger_channel_update)(void*, void*);
+  void (*PVR_trigger_channel_groups_update)(void*, void*);
+  void (*PVR_trigger_timer_update)(void*, void*);
+  void (*PVR_trigger_recording_update)(void* , void*);
+  void (*PVR_trigger_epg_update)(void*, void*, unsigned int);
+  void (*PVR_transfer_channel_group)(void*, void*, const ADDON_HANDLE, const PVR_CHANNEL_GROUP*);
+  void (*PVR_transfer_channel_group_member)(void*, void*, const ADDON_HANDLE, const PVR_CHANNEL_GROUP_MEMBER*);
+#ifdef USE_DEMUX
+  void (*PVR_free_demux_packet)(void*, void*, DemuxPacket*);
+  DemuxPacket* (*PVR_allocate_demux_packet)(void*, void*, int);
+#endif
+  void (*PVR_connection_state_change)(void*, void*, const char*, PVR_CONNECTION_STATE, const char*);
+  void (*PVR_epg_event_state_change)(void*, void*, EPG_TAG*, unsigned int, EPG_EVENT_STATE);
+
+private:
+  void* m_libXBMC_pvr;
+  void* m_Handle;
+  void* m_Callbacks;
+  struct cb_array
+  {
+    const char* libPath;
+  };
+};
diff --git a/xbmc/addons/include/xbmc_addon_cpp_dll.h b/xbmc/addons/kodi-addon-dev-kit/include/kodi/xbmc_addon_cpp_dll.h
index 3944525..2eb972e 100644
--- a/xbmc/addons/include/xbmc_addon_cpp_dll.h
+++ b/xbmc/addons/kodi-addon-dev-kit/include/kodi/xbmc_addon_cpp_dll.h
@@ -1,9 +1,8 @@
-#ifndef __XBMC_ADDON_CPP_H__
-#define __XBMC_ADDON_CPP_H__
+#pragma once
 
 /*
- *      Copyright (C) 2005-2013 Team XBMC
- *      http://xbmc.org
+ *      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
@@ -16,7 +15,7 @@
  *  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
+ *  along with Kodi; see the file COPYING.  If not, see
  *  <http://www.gnu.org/licenses/>.
  *
  */
@@ -105,7 +104,7 @@ public:
   static unsigned int VecToStruct(std::vector<DllSetting> &vecSet, ADDON_StructSetting*** sSet) 
   {
     *sSet = NULL;
-    if(vecSet.size() == 0)
+    if (vecSet.empty())
       return 0;
 
     unsigned int uiElements=0;
@@ -127,7 +126,7 @@ public:
         (*sSet)[i]->current = vecSet[i].current;
         (*sSet)[i]->entry_elements = 0;
         (*sSet)[i]->entry = NULL;
-        if(vecSet[i].type == DllSetting::SPIN && vecSet[i].entry.size() > 0)
+        if(vecSet[i].type == DllSetting::SPIN && !vecSet[i].entry.empty())
         {
           (*sSet)[i]->entry = (char**)malloc(vecSet[i].entry.size()*sizeof(char**));
           for(unsigned int j=0;j<vecSet[i].entry.size();j++)
@@ -188,4 +187,3 @@ public:
   }
 };
 
-#endif
diff --git a/xbmc/addons/include/xbmc_addon_dll.h b/xbmc/addons/kodi-addon-dev-kit/include/kodi/xbmc_addon_dll.h
index fa6415f..ff7194f 100644
--- a/xbmc/addons/include/xbmc_addon_dll.h
+++ b/xbmc/addons/kodi-addon-dev-kit/include/kodi/xbmc_addon_dll.h
@@ -1,9 +1,8 @@
-#ifndef __XBMC_ADDON_DLL_H__
-#define __XBMC_ADDON_DLL_H__
+#pragma once
 
 /*
- *      Copyright (C) 2005-2013 Team XBMC
- *      http://xbmc.org
+ *      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
@@ -16,7 +15,7 @@
  *  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
+ *  along with Kodi; see the file COPYING.  If not, see
  *  <http://www.gnu.org/licenses/>.
  *
  */
@@ -51,5 +50,3 @@ extern "C" {
 #ifdef __cplusplus
 };
 #endif
-
-#endif
diff --git a/xbmc/addons/include/xbmc_addon_types.h b/xbmc/addons/kodi-addon-dev-kit/include/kodi/xbmc_addon_types.h
index bd6cbe8..2ceb5c5 100644
--- a/xbmc/addons/include/xbmc_addon_types.h
+++ b/xbmc/addons/kodi-addon-dev-kit/include/kodi/xbmc_addon_types.h
@@ -1,9 +1,8 @@
-#ifndef __XBMC_ADDON_TYPES_H__
-#define __XBMC_ADDON_TYPES_H__
+#pragma once
 
 /*
- *      Copyright (C) 2005-2013 Team XBMC
- *      http://xbmc.org
+ *      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
@@ -16,7 +15,7 @@
  *  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
+ *  along with Kodi; see the file COPYING.  If not, see
  *  <http://www.gnu.org/licenses/>.
  *
  */
@@ -61,4 +60,3 @@ typedef ADDON_HANDLE_STRUCT *ADDON_HANDLE;
 };
 #endif
 
-#endif
diff --git a/xbmc/addons/include/xbmc_audioenc_dll.h b/xbmc/addons/kodi-addon-dev-kit/include/kodi/xbmc_audioenc_dll.h
index 01e8d12..932d34f 100644
--- a/xbmc/addons/include/xbmc_audioenc_dll.h
+++ b/xbmc/addons/kodi-addon-dev-kit/include/kodi/xbmc_audioenc_dll.h
@@ -1,7 +1,8 @@
 #pragma once
+
 /*
- *      Copyright (C) 2005-2013 Team XBMC
- *      http://xbmc.org
+ *      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
@@ -14,14 +15,11 @@
  *  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
+ *  along with Kodi; see the file COPYING.  If not, see
  *  <http://www.gnu.org/licenses/>.
  *
  */
 
-#ifndef __XBMC_AUDIOENC_H__
-#define __XBMC_AUDIOENC_H__
-
 #include <stdint.h>
 #include "xbmc_addon_dll.h"
 #include "xbmc_audioenc_types.h"
@@ -58,4 +56,3 @@ extern "C"
   };
 };
 
-#endif
diff --git a/xbmc/addons/include/xbmc_audioenc_types.h b/xbmc/addons/kodi-addon-dev-kit/include/kodi/xbmc_audioenc_types.h
index aa527db..df5164e 100644
--- a/xbmc/addons/include/xbmc_audioenc_types.h
+++ b/xbmc/addons/kodi-addon-dev-kit/include/kodi/xbmc_audioenc_types.h
@@ -1,7 +1,8 @@
 #pragma once
+
 /*
- *      Copyright (C) 2005-2013 Team XBMC
- *      http://xbmc.org
+ *      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
@@ -14,14 +15,11 @@
  *  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
+ *  along with Kodi; see the file COPYING.  If not, see
  *  <http://www.gnu.org/licenses/>.
  *
  */
 
-#ifndef __AUDIOENC_TYPES_H__
-#define __AUDIOENC_TYPES_H__
-
 #ifdef TARGET_WINDOWS
 #include <windows.h>
 #else
@@ -110,4 +108,3 @@ extern "C"
   };
 }
 
-#endif
diff --git a/xbmc/addons/include/xbmc_codec_types.h b/xbmc/addons/kodi-addon-dev-kit/include/kodi/xbmc_codec_types.h
index 98003e0..01e7548 100644
--- a/xbmc/addons/include/xbmc_codec_types.h
+++ b/xbmc/addons/kodi-addon-dev-kit/include/kodi/xbmc_codec_types.h
@@ -1,9 +1,8 @@
-#ifndef __XBMC_CODEC_TYPES_H__
-#define __XBMC_CODEC_TYPES_H__
+#pragma once
 
 /*
- *      Copyright (C) 2005-2013 Team XBMC
- *      http://xbmc.org
+ *      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
@@ -16,7 +15,7 @@
  *  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
+ *  along with Kodi; see the file COPYING.  If not, see
  *  <http://www.gnu.org/licenses/>.
  *
  */
@@ -51,5 +50,3 @@ typedef struct
 };
 #endif
 
-#endif
-
diff --git a/xbmc/addons/include/xbmc_epg_types.h b/xbmc/addons/kodi-addon-dev-kit/include/kodi/xbmc_epg_types.h
index efd7d13..9460952 100644
--- a/xbmc/addons/include/xbmc_epg_types.h
+++ b/xbmc/addons/kodi-addon-dev-kit/include/kodi/xbmc_epg_types.h
@@ -59,17 +59,38 @@
 //@}
 
 /* Set EPGTAG.iGenreType to EPG_GENRE_USE_STRING to transfer genre strings to XBMC */
-#define EPG_GENRE_USE_STRING                          0x100
+#define EPG_GENRE_USE_STRING                           0x100
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+  /* EPG_TAG.iFlags values */
+  const unsigned int EPG_TAG_FLAG_UNDEFINED = 0x00000000; /*!< @brief nothing special to say about this entry */
+  const unsigned int EPG_TAG_FLAG_IS_SERIES = 0x00000001; /*!< @brief this EPG entry is part of a series */
+
+  /* Special EPG_TAG.iUniqueBroadcastId value */
+
+  /*!
+   * @brief special EPG_TAG.iUniqueBroadcastId value to indicate that a tag has not a valid EPG event uid.
+   */
+  const unsigned int EPG_TAG_INVALID_UID = 0;
+
+  /*!
+   * @brief EPG event states. Used with EpgEventStateChange callback.
+   */
+  typedef enum
+  {
+    EPG_EVENT_CREATED = 0,  /*!< @brief event created */
+    EPG_EVENT_UPDATED = 1,  /*!< @brief event updated */
+    EPG_EVENT_DELETED = 2,  /*!< @brief event deleted */
+  } EPG_EVENT_STATE;
+
   /*!
    * @brief Representation of an EPG event.
    */
   typedef struct EPG_TAG {
-    unsigned int  iUniqueBroadcastId;  /*!< @brief (required) identifier for this event */
+    unsigned int  iUniqueBroadcastId;  /*!< @brief (required) identifier for this event. Valid uids must be greater than EPG_TAG_INVALID_UID. */
     const char *  strTitle;            /*!< @brief (required) this event's title */
     unsigned int  iChannelNumber;      /*!< @brief (required) the number of the channel this event occurs on */
     time_t        startTime;           /*!< @brief (required) start time in UTC */
@@ -94,6 +115,7 @@ extern "C" {
     int           iEpisodeNumber;      /*!< @brief (optional) episode number */
     int           iEpisodePartNumber;  /*!< @brief (optional) episode part number */
     const char *  strEpisodeName;      /*!< @brief (optional) episode name */
+    unsigned int  iFlags;              /*!< @brief (optional) bit field of independent flags associated with the EPG entry */
   } ATTRIBUTE_PACKED EPG_TAG;
 
 #ifdef __cplusplus
diff --git a/xbmc/addons/include/xbmc_pvr_dll.h b/xbmc/addons/kodi-addon-dev-kit/include/kodi/xbmc_pvr_dll.h
index 5280399..8b54ea6 100644
--- a/xbmc/addons/include/xbmc_pvr_dll.h
+++ b/xbmc/addons/kodi-addon-dev-kit/include/kodi/xbmc_pvr_dll.h
@@ -1,6 +1,8 @@
+#pragma once
+
 /*
- *      Copyright (C) 2005-2013 Team XBMC
- *      http://xbmc.org
+ *      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
@@ -13,14 +15,11 @@
  *  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
+ *  along with Kodi; see the file COPYING.  If not, see
  *  <http://www.gnu.org/licenses/>.
  *
  */
 
-#ifndef __XBMC_PVR_H__
-#define __XBMC_PVR_H__
-
 #include "xbmc_addon_dll.h"
 #include "xbmc_pvr_types.h"
 
@@ -53,16 +52,18 @@ extern "C"
   /*!
    * Get the XBMC_GUI_API_VERSION that was used to compile this add-on.
    * Used to check if this add-on is compatible with XBMC.
-   * @return The XBMC_GUI_API_VERSION that was used to compile this add-on.
+   * @return The XBMC_GUI_API_VERSION that was used to compile this add-on or empty string if this add-on does not depend on Kodi GUI API.
    * @remarks Valid implementation required.
+   * @note see libKODI_guilib.h about related parts
    */
   const char* GetGUIAPIVersion(void);
 
   /*!
    * Get the XBMC_GUI_MIN_API_VERSION that was used to compile this add-on.
    * Used to check if this add-on is compatible with XBMC.
-   * @return The XBMC_GUI_MIN_API_VERSION that was used to compile this add-on.
+   * @return The XBMC_GUI_MIN_API_VERSION that was used to compile this add-on or empty string if this add-on does not depend on Kodi GUI API.
    * @remarks Valid implementation required.
+   * @note see libKODI_guilib.h about related parts
    */
   const char* GetMininumGUIAPIVersion(void);
 
@@ -330,6 +331,15 @@ extern "C"
   */
   PVR_ERROR GetRecordingEdl(const PVR_RECORDING&, PVR_EDL_ENTRY edl[], int *size);
 
+  /*!
+  * Retrieve the timer types supported by the backend.
+  * @param types out: The function has to write the definition of the supported timer types into this array.
+  * @param typesCount in: The maximum size of the list, out: the actual size of the list. default: PVR_ADDON_TIMERTYPE_ARRAY_SIZE
+  * @return PVR_ERROR_NO_ERROR if the types were successfully written to the array.
+  * @remarks Required if bSupportsTimers is set to true. Return PVR_ERROR_NOT_IMPLEMENTED if this add-on won't provide this function.
+  */
+  PVR_ERROR GetTimerTypes(PVR_TIMER_TYPE types[], int *typesCount);
+
   //@}
   /** @name PVR timer methods
    *  @remarks Only used by XBMC is bSupportsTimers is set to true.
@@ -426,12 +436,6 @@ extern "C"
   long long LengthLiveStream(void);
 
   /*!
-   * @return The channel number on the backend of the live stream that's currently being read.
-   * @remarks Required if bHandlesInputStream or bHandlesDemuxing is set to true. Return -1 if this add-on won't provide this function.
-   */
-  int GetCurrentClientChannel(void);
-
-  /*!
    * Switch to another channel. Only to be called when a live stream has already been opened.
    * @param channel The channel to switch to.
    * @return True if the switch was successful, false otherwise.
@@ -621,6 +625,29 @@ extern "C"
   const char* GetBackendHostname();
 
   /*!
+   *  Check if timeshift is active
+   *  @return true if timeshift is active
+   */
+  bool IsTimeshifting();
+
+  /*!
+   *  Check for real-time streaming
+   *  @return true if current stream is real-time
+   */
+  bool IsRealTimeStream();
+
+  /*!
+   * Tell the client the time frame to use when notifying epg events back to Kodi. The client might push epg events asynchronously
+   * to Kodi using the callback function EpgEventStateChange. To be able to only push events that are actually of interest for Kodi,
+   * client needs to know about the epg time frame Kodi uses. Kodi calls this function once after the client add-on has been sucessfully
+   * initialized and then everytime the time frame value changes.
+   * @param iDays number of days from "now". EPG_TIMEFRAME_UNLIMITED means that Kodi is interested in all epg events, regardless of event times.
+   * @return PVR_ERROR_NO_ERROR if new value was successfully set.
+   * @remarks Required if bSupportsEPG is set to true. Return PVR_ERROR_NOT_IMPLEMENTED if this add-on won't provide this function.
+   */
+  PVR_ERROR SetEPGTimeFrame(int iDays);
+
+  /*!
    * Called by XBMC to assign the function pointers of this add-on to pClient.
    * @param pClient The struct to assign the function pointers to.
    */
@@ -664,6 +691,7 @@ extern "C"
     pClient->GetRecordingLastPlayedPosition = GetRecordingLastPlayedPosition;
     pClient->GetRecordingEdl                = GetRecordingEdl;
 
+    pClient->GetTimerTypes                  = GetTimerTypes;
     pClient->GetTimersAmount                = GetTimersAmount;
     pClient->GetTimers                      = GetTimers;
     pClient->AddTimer                       = AddTimer;
@@ -676,7 +704,6 @@ extern "C"
     pClient->SeekLiveStream                 = SeekLiveStream;
     pClient->PositionLiveStream             = PositionLiveStream;
     pClient->LengthLiveStream               = LengthLiveStream;
-    pClient->GetCurrentClientChannel        = GetCurrentClientChannel;
     pClient->SwitchChannel                  = SwitchChannel;
     pClient->SignalStatus                   = SignalStatus;
     pClient->GetLiveStreamURL               = GetLiveStreamURL;
@@ -704,7 +731,11 @@ extern "C"
     pClient->GetBufferTimeEnd               = GetBufferTimeEnd;
 
     pClient->GetBackendHostname             = GetBackendHostname;
+
+    pClient->IsTimeshifting                 = IsTimeshifting;
+    pClient->IsRealTimeStream               = IsRealTimeStream;
+
+    pClient->SetEPGTimeFrame                = SetEPGTimeFrame;
   };
 };
 
-#endif
diff --git a/xbmc/addons/include/xbmc_pvr_types.h b/xbmc/addons/kodi-addon-dev-kit/include/kodi/xbmc_pvr_types.h
index a2e4882..83bb13a 100644
--- a/xbmc/addons/include/xbmc_pvr_types.h
+++ b/xbmc/addons/kodi-addon-dev-kit/include/kodi/xbmc_pvr_types.h
@@ -1,7 +1,8 @@
 #pragma once
+
 /*
- *      Copyright (C) 2005-2013 Team XBMC
- *      http://xbmc.org
+ *      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
@@ -14,14 +15,11 @@
  *  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
+ *  along with Kodi; see the file COPYING.  If not, see
  *  <http://www.gnu.org/licenses/>.
  *
  */
 
-#ifndef __PVRCLIENT_TYPES_H__
-#define __PVRCLIENT_TYPES_H__
-
 #ifdef TARGET_WINDOWS
 #include <windows.h>
 #else
@@ -65,26 +63,111 @@ struct DemuxPacket;
 #define PRAGMA_PACK 1
 #endif
 
-#define PVR_ADDON_NAME_STRING_LENGTH         1024
-#define PVR_ADDON_URL_STRING_LENGTH          1024
-#define PVR_ADDON_DESC_STRING_LENGTH         1024
-#define PVR_ADDON_INPUT_FORMAT_STRING_LENGTH 32
-#define PVR_ADDON_EDL_LENGTH                 32
+#define PVR_ADDON_NAME_STRING_LENGTH          1024
+#define PVR_ADDON_URL_STRING_LENGTH           1024
+#define PVR_ADDON_DESC_STRING_LENGTH          1024
+#define PVR_ADDON_INPUT_FORMAT_STRING_LENGTH  32
+#define PVR_ADDON_EDL_LENGTH                  32
+#define PVR_ADDON_TIMERTYPE_ARRAY_SIZE        32
+#define PVR_ADDON_TIMERTYPE_VALUES_ARRAY_SIZE 512
+#define PVR_ADDON_TIMERTYPE_VALUES_ARRAY_SIZE_SMALL 128
+#define PVR_ADDON_TIMERTYPE_STRING_LENGTH     64
 
 /* using the default avformat's MAX_STREAMS value to be safe */
 #define PVR_STREAM_MAX_STREAMS 20
 
 /* current PVR API version */
-#define XBMC_PVR_API_VERSION "1.9.6"
+#define XBMC_PVR_API_VERSION "5.0.0"
 
 /* min. PVR API version */
-#define XBMC_PVR_MIN_API_VERSION "1.9.6"
+#define XBMC_PVR_MIN_API_VERSION "5.0.0"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
   /*!
+   * @brief numeric PVR timer type definitions (PVR_TIMER.iTimerType values)
+   */
+  const unsigned int PVR_TIMER_TYPE_NONE = 0; /*!< @brief "Null" value for a numeric timer type. */
+
+  /*!
+   * @brief special PVR_TIMER.iClientIndex value to indicate that a timer has not (yet) a valid client index.
+   */
+  const unsigned int PVR_TIMER_NO_CLIENT_INDEX = 0; /*!< @brief timer has not (yet) a valid client index. */
+
+  /*!
+   * @brief special PVR_TIMER.iParentClientIndex value to indicate that a timer has no parent.
+   */
+  const unsigned int PVR_TIMER_NO_PARENT = PVR_TIMER_NO_CLIENT_INDEX; /*!< @brief timer has no parent; it was not scheduled by a repeating timer. */
+
+  /*!
+   * @brief special PVR_TIMER.iEpgUid value to indicate that a timer has no EPG event uid.
+   */
+  const unsigned int PVR_TIMER_NO_EPG_UID = EPG_TAG_INVALID_UID; /*!< @brief timer has no EPG event uid. */
+
+  /*!
+   * @brief special PVR_TIMER.iClientChannelUid value to indicate "any channel". Useful for some repeating timer types.
+   */
+  const int PVR_TIMER_ANY_CHANNEL = -1; /*!< @brief denotes "any channel", not a specific one. */
+
+  /*!
+   * @brief PVR timer type attributes (PVR_TIMER_TYPE.iAttributes values)
+   */
+  const unsigned int PVR_TIMER_TYPE_ATTRIBUTE_NONE                    = 0x00000000;
+
+  const unsigned int PVR_TIMER_TYPE_IS_MANUAL                         = 0x00000001; /*!< @brief defines whether this is a type for manual (time-based) or epg-based timers */
+  const unsigned int PVR_TIMER_TYPE_IS_REPEATING                      = 0x00000002; /*!< @brief defines whether this is a type for repeating or one-shot timers */
+  const unsigned int PVR_TIMER_TYPE_IS_READONLY                       = 0x00000004; /*!< @brief timers of this type must not be edited by Kodi */
+  const unsigned int PVR_TIMER_TYPE_FORBIDS_NEW_INSTANCES             = 0x00000008; /*!< @brief timers of this type must not be created by Kodi. All other operations are allowed, though */
+
+  const unsigned int PVR_TIMER_TYPE_SUPPORTS_ENABLE_DISABLE           = 0x00000010; /*!< @brief this type supports enabling/disabling of the timer (PVR_TIMER.state SCHEDULED|DISBALED) */
+  const unsigned int PVR_TIMER_TYPE_SUPPORTS_CHANNELS                 = 0x00000020; /*!< @brief this type supports channels (PVR_TIMER.iClientChannelUid) */
+  const unsigned int PVR_TIMER_TYPE_SUPPORTS_START_TIME               = 0x00000040; /*!< @brief this type supports a recording start time (PVR_TIMER.startTime) */
+  const unsigned int PVR_TIMER_TYPE_SUPPORTS_TITLE_EPG_MATCH          = 0x00000080; /*!< @brief this type supports matching epg episode title using PVR_TIMER.strEpgSearchString */
+  const unsigned int PVR_TIMER_TYPE_SUPPORTS_FULLTEXT_EPG_MATCH       = 0x00000100; /*!< @brief this type supports matching "more" epg data (not just episode title) using PVR_TIMER.strEpgSearchString. Setting FULLTEXT_EPG_MATCH implies TITLE_EPG_MATCH */
+  const unsigned int PVR_TIMER_TYPE_SUPPORTS_FIRST_DAY                = 0x00000200; /*!< @brief this type supports a first day the timer gets active (PVR_TIMER.firstday) */
+  const unsigned int PVR_TIMER_TYPE_SUPPORTS_WEEKDAYS                 = 0x00000400; /*!< @brief this type supports weekdays for defining the recording schedule (PVR_TIMER.iWeekdays) */
+  const unsigned int PVR_TIMER_TYPE_SUPPORTS_RECORD_ONLY_NEW_EPISODES = 0x00000800; /*!< @brief this type supports the "record only new episodes" feature (PVR_TIMER.iPreventDuplicateEpisodes) */
+  const unsigned int PVR_TIMER_TYPE_SUPPORTS_START_END_MARGIN         = 0x00001000; /*!< @brief this type supports pre and post record time (PVR_TIMER.iMarginStart, PVR_TIMER.iMarginEnd) */
+  const unsigned int PVR_TIMER_TYPE_SUPPORTS_PRIORITY                 = 0x00002000; /*!< @brief this type supports recording priority (PVR_TIMER.iPriority) */
+  const unsigned int PVR_TIMER_TYPE_SUPPORTS_LIFETIME                 = 0x00004000; /*!< @brief this type supports recording lifetime (PVR_TIMER.iLifetime) */
+  const unsigned int PVR_TIMER_TYPE_SUPPORTS_RECORDING_FOLDERS        = 0x00008000; /*!< @brief this type supports placing recordings in user defined folders (PVR_TIMER.strDirectory) */
+  const unsigned int PVR_TIMER_TYPE_SUPPORTS_RECORDING_GROUP          = 0x00010000; /*!< @brief this type supports a list of recording groups (PVR_TIMER.iRecordingGroup) */
+  const unsigned int PVR_TIMER_TYPE_SUPPORTS_END_TIME                 = 0x00020000; /*!< @brief this type supports a recording end time (PVR_TIMER.endTime) */
+  const unsigned int PVR_TIMER_TYPE_SUPPORTS_START_ANYTIME            = 0x00040000; /*!< @brief enables an 'Any Time' over-ride option for startTime (using PVR_TIMER.bStartAnyTime) */
+  const unsigned int PVR_TIMER_TYPE_SUPPORTS_END_ANYTIME              = 0x00080000; /*!< @brief enables a separate 'Any Time' over-ride for endTime (using PVR_TIMER.bEndAnyTime) */
+  const unsigned int PVR_TIMER_TYPE_SUPPORTS_MAX_RECORDINGS           = 0x00100000; /*!< @brief this type supports specifying a maximum recordings setting' (PVR_TIMER.iMaxRecordings) */
+  const unsigned int PVR_TIMER_TYPE_REQUIRES_EPG_TAG_ON_CREATE        = 0x00200000; /*!< @brief this type shold not appear on any create menus which don't provide an associated EPG tag */
+  const unsigned int PVR_TIMER_TYPE_FORBIDS_EPG_TAG_ON_CREATE         = 0x00400000; /*!< @brief this type should not appear on any create menus which provide an associated EPG tag */
+  const unsigned int PVR_TIMER_TYPE_REQUIRES_EPG_SERIES_ON_CREATE     = 0x00800000; /*!< @brief this type should not appear on any create menus unless associated with an EPG tag with 'series' attributes (EPG_TAG.iFlags & EPG_TAG_FLAG_IS_SERIES || EPG_TAG.iSeriesNumber > 0 || EPG_TAG.iEpisodeNumber > 0 || EPG_TAG.iEpisodePartNumber > 0). Implies PVR_TIMER_TYPE_REQUIRES_EPG_TAG_ON_CREATE */
+
+  /*!
+   * @brief PVR timer weekdays (PVR_TIMER.iWeekdays values)
+   */
+  const unsigned int PVR_WEEKDAY_NONE      = 0x00;
+  const unsigned int PVR_WEEKDAY_MONDAY    = 0x01;
+  const unsigned int PVR_WEEKDAY_TUESDAY   = 0x02;
+  const unsigned int PVR_WEEKDAY_WEDNESDAY = 0x04;
+  const unsigned int PVR_WEEKDAY_THURSDAY  = 0x08;
+  const unsigned int PVR_WEEKDAY_FRIDAY    = 0x10;
+  const unsigned int PVR_WEEKDAY_SATURDAY  = 0x20;
+  const unsigned int PVR_WEEKDAY_SUNDAY    = 0x40;
+  const unsigned int PVR_WEEKDAY_ALLDAYS   = PVR_WEEKDAY_MONDAY   | PVR_WEEKDAY_TUESDAY | PVR_WEEKDAY_WEDNESDAY |
+                                             PVR_WEEKDAY_THURSDAY | PVR_WEEKDAY_FRIDAY  | PVR_WEEKDAY_SATURDAY  |
+                                             PVR_WEEKDAY_SUNDAY;
+
+  /*!
+   * @brief timeframe value for use with SetEPGTimeFrame function to indicate "no timeframe".
+   */
+  const int EPG_TIMEFRAME_UNLIMITED = -1;
+
+  /*!
+   * @brief special PVR_TIMER.iClientChannelUid and PVR_RECORDING.iChannelUid value to indicate that no channel uid is available.
+   */
+  const int PVR_CHANNEL_INVALID_UID = -1; /*!< @brief denotes that no channel uid is avaliable. */
+
+  /*!
    * @brief PVR add-on error codes
    */
   typedef enum
@@ -106,7 +189,7 @@ extern "C" {
    */
   typedef enum
   {
-    PVR_TIMER_STATE_NEW          = 0, /*!< @brief a new, unsaved timer */
+    PVR_TIMER_STATE_NEW          = 0, /*!< @brief the timer was just created on the backend and is not yet active. This state must not be used for timers just created on the client side. */
     PVR_TIMER_STATE_SCHEDULED    = 1, /*!< @brief the timer is scheduled for recording */
     PVR_TIMER_STATE_RECORDING    = 2, /*!< @brief the timer is currently recordings */
     PVR_TIMER_STATE_COMPLETED    = 3, /*!< @brief the recording completed successfully */
@@ -114,7 +197,8 @@ extern "C" {
     PVR_TIMER_STATE_CANCELLED    = 5, /*!< @brief the timer was scheduled, but was canceled */
     PVR_TIMER_STATE_CONFLICT_OK  = 6, /*!< @brief the scheduled timer conflicts with another one, but will be recorded */
     PVR_TIMER_STATE_CONFLICT_NOK = 7, /*!< @brief the scheduled timer conflicts with another one and won't be recorded */
-    PVR_TIMER_STATE_ERROR        = 8  /*!< @brief the timer is scheduled, but can't be recorded for some reason */
+    PVR_TIMER_STATE_ERROR        = 8, /*!< @brief the timer is scheduled, but can't be recorded for some reason */
+    PVR_TIMER_STATE_DISABLED     = 9, /*!< @brief the timer was disabled by the user, can be enabled via setting the state to PVR_TIMER_STATE_SCHEDULED */
   } PVR_TIMER_STATE;
 
   /*!
@@ -133,6 +217,20 @@ extern "C" {
   } PVR_MENUHOOK_CAT;
 
   /*!
+   * @brief PVR backend connection states. Used with ConnectionStateChange callback.
+   */
+  typedef enum
+  {
+    PVR_CONNECTION_STATE_UNKNOWN            = 0,  /*!< @brief unknown state (e.g. not yet tried to connect) */
+    PVR_CONNECTION_STATE_SERVER_UNREACHABLE = 1,  /*!< @brief backend server is not reachable (e.g. server not existing or network down)*/
+    PVR_CONNECTION_STATE_SERVER_MISMATCH    = 2,  /*!< @brief backend server is reachable, but there is not the expected type of server running (e.g. HTSP required, but FTP running at given server:port) */
+    PVR_CONNECTION_STATE_VERSION_MISMATCH   = 3,  /*!< @brief backend server is reachable, but server version does not match client requirements */
+    PVR_CONNECTION_STATE_ACCESS_DENIED      = 4,  /*!< @brief backend server is reachable, but denies client access (e.g. due to wrong credentials) */
+    PVR_CONNECTION_STATE_CONNECTED          = 5,  /*!< @brief connection to backend server is established */
+    PVR_CONNECTION_STATE_DISCONNECTED       = 6,  /*!< @brief no connection to backend server (e.g. due to network errors or client initiated disconnect)*/
+  } PVR_CONNECTION_STATE;
+
+  /*!
    * @brief Properties passed to the Create() method of an add-on.
    */
   typedef struct PVR_PROPERTIES
@@ -158,7 +256,6 @@ extern "C" {
     bool bSupportsChannelSettings;      /*!< @brief true if this add-on supports the following functions: DeleteChannel, RenameChannel, MoveChannel, DialogChannelSettings and DialogAddChannel */
     bool bHandlesInputStream;           /*!< @brief true if this add-on provides an input stream. false if XBMC handles the stream. */
     bool bHandlesDemuxing;              /*!< @brief true if this add-on demultiplexes packets. */
-    bool bSupportsRecordingFolders;     /*!< @brief true if the backend supports timers / recordings in folders. */
     bool bSupportsRecordingPlayCount;   /*!< @brief true if the backend supports play count for recordings. */
     bool bSupportsLastPlayedPosition;   /*!< @brief true if the backend supports store/retrieve of last played position for recordings. */
     bool bSupportsRecordingEdl;         /*!< @brief true if the backend supports retrieving an edit decision list for recordings. */
@@ -204,9 +301,6 @@ extern "C" {
     int    iSignal;                                        /*!< @brief (optional) signal strength */
     long   iBER;                                           /*!< @brief (optional) bit error rate */
     long   iUNC;                                           /*!< @brief (optional) uncorrected blocks */
-    double dVideoBitrate;                                  /*!< @brief (optional) video bitrate */
-    double dAudioBitrate;                                  /*!< @brief (optional) audio bitrate */
-    double dDolbyBitrate;                                  /*!< @brief (optional) dolby bitrate */
   } ATTRIBUTE_PACKED PVR_SIGNAL_STATUS;
 
   /*!
@@ -255,34 +349,117 @@ extern "C" {
   } ATTRIBUTE_PACKED PVR_CHANNEL_GROUP_MEMBER;
 
   /*!
+   * @brief Representation of a timer's attribute integer value.
+   */
+  typedef struct PVR_TIMER_TYPE_ATTRIBUTE_INT_VALUE
+  {
+    int iValue;                                              /*!< @brief (required) an integer value for a certain timer attribute */
+    char strDescription[PVR_ADDON_TIMERTYPE_STRING_LENGTH];  /*!< @brief (optional) a localized string describing the value. If left blank, Kodi will
+                                                               generate a suitable representation (like the integer value as string) */
+  } ATTRIBUTE_PACKED PVR_TIMER_TYPE_ATTRIBUTE_INT_VALUE;
+
+  /*!
+   * @brief Representation of a timer type.
+   */
+  typedef struct PVR_TIMER_TYPE
+  {
+    unsigned int iId;                                       /*!< @brief (required) this type's identifier. Ids must be > PVR_TIMER_TYPE_NONE. */
+    unsigned int iAttributes;                               /*!< @brief (required) defines the attributes for this type (PVR_TIMER_TYPE_* constants). */
+    char strDescription[PVR_ADDON_TIMERTYPE_STRING_LENGTH]; /*!< @brief (optional) a short localized string describing the purpose of the type. (e.g.
+                                                              "Any time at this channel if title matches"). If left blank, Kodi will generate a
+                                                              description based on the attributes REPEATING and MANUAL. (e.g. "Repeating EPG-based." */
+    /* priority value definitions */
+    unsigned int iPrioritiesSize;                           /*!< @brief (required) Count of possible values for PVR_TMER.iPriority. 0 means priority
+                                                              is not supported by this timer type or no own value definition wanted, but to use Kodi defaults
+                                                              of 1..100. */
+    PVR_TIMER_TYPE_ATTRIBUTE_INT_VALUE
+      priorities[PVR_ADDON_TIMERTYPE_VALUES_ARRAY_SIZE];    /*!< @brief (optional) Array containing the possible values for PVR_TMER.iPriority. Must be
+                                                              filled if iPrioritiesSize > 0 */
+    int          iPrioritiesDefault;                        /*!< @brief (optional) The default value for PVR_TMER.iPriority. Must be filled if iPrioritiesSize > 0 */
+
+    /* lifetime value definitions */
+    unsigned int iLifetimesSize;                            /*!< @brief (required) Count of possible values for PVR_TMER.iLifetime. 0 means lifetime
+                                                              is not supported by this timer type or no own value definition wanted, but to use Kodi defaults
+                                                              of 1..365. */
+    PVR_TIMER_TYPE_ATTRIBUTE_INT_VALUE
+      lifetimes[PVR_ADDON_TIMERTYPE_VALUES_ARRAY_SIZE];     /*!< @brief (optional) Array containing the possible values for PVR_TMER.iLifetime. Must be
+                                                              filled if iLifetimesSize > 0 */
+    int          iLifetimesDefault;                         /*!< @brief (optional) The default value for PVR_TMER.iLifetime. Must be filled if iLifetimesSize > 0 */
+
+    /* prevent duplicate episodes value definitions */
+    unsigned int iPreventDuplicateEpisodesSize;             /*!< @brief (required) Count of possible values for PVR_TMER.iPreventDuplicateEpisodes. 0 means duplicate
+                                                              episodes prevention is not supported by this timer type or no own value definition wanted, but to use
+                                                              Kodi defaults. */
+    PVR_TIMER_TYPE_ATTRIBUTE_INT_VALUE
+      preventDuplicateEpisodes[PVR_ADDON_TIMERTYPE_VALUES_ARRAY_SIZE];
+                                                            /*!< @brief (optional) Array containing the possible values for PVR_TMER.iPreventDuplicateEpisodes.. Must
+                                                              be filled if iPreventDuplicateEpisodesSize > 0 */
+    unsigned int iPreventDuplicateEpisodesDefault;          /*!< @brief (optional) The default value for PVR_TMER.iPreventDuplicateEpisodesSize. Must be filled if iPreventDuplicateEpisodesSize > 0 */
+
+    /* recording folder list value definitions */
+    unsigned int iRecordingGroupSize;                       /*!< @brief (required) Count of possible values of PVR_TIMER.iRecordingGroup. 0 means folder lists are not supported by this timer type */
+    PVR_TIMER_TYPE_ATTRIBUTE_INT_VALUE
+      recordingGroup[PVR_ADDON_TIMERTYPE_VALUES_ARRAY_SIZE];
+                                                            /*!< @brief (optional) Array containing the possible values of PVR_TMER.iRecordingGroup. Must be filled if iRecordingGroupSize > 0 */
+    unsigned int iRecordingGroupDefault;                    /*!< @brief (optional) The default value for PVR_TIMER.iRecordingGroup. Must be filled in if PVR_TIMER.iRecordingGroupSize > 0 */
+
+    /* max recordings value definitions */
+    unsigned int iMaxRecordingsSize;                        /*!< @brief (required) Count of possible values of PVR_TIMER.iMaxRecordings. 0 means max recordings are not supported by this timer type */
+    PVR_TIMER_TYPE_ATTRIBUTE_INT_VALUE
+      maxRecordings[PVR_ADDON_TIMERTYPE_VALUES_ARRAY_SIZE_SMALL];
+                                                            /*!< @brief (optional) Array containing the possible values of PVR_TMER.iMaxRecordings. */
+    int iMaxRecordingsDefault;                              /*!< @brief (optional) The default value for PVR_TIMER.iMaxRecordings. Must be filled in if PVR_TIMER.iMaxRecordingsSize > 0 */
+
+  } ATTRIBUTE_PACKED PVR_TIMER_TYPE;
+
+  /*!
    * @brief Representation of a timer event.
    */
   typedef struct PVR_TIMER {
-    unsigned int    iClientIndex;                              /*!< @brief (required) the index of this timer given by the client */
-    int             iClientChannelUid;                         /*!< @brief (required) unique identifier of the channel to record on */
-    time_t          startTime;                                 /*!< @brief (required) start time of the recording in UTC. instant timers that are sent to the add-on by xbmc will have this value set to 0 */
-    time_t          endTime;                                   /*!< @brief (required) end time of the recording in UTC */
+    unsigned int    iClientIndex;                              /*!< @brief (required) the index of this timer given by the client. PVR_TIMER_NO_CLIENT_INDEX indicates that the index was not yet set by the client, for example for new timers created by
+                                                                    Kodi and passed the first time to the client. A valid index must be greater than PVR_TIMER_NO_CLIENT_INDEX. */
+    unsigned int    iParentClientIndex;                        /*!< @brief (optional) for timers scheduled by a repeating timer, the index of the repeating timer that scheduled this timer (it's PVR_TIMER.iClientIndex value). Use PVR_TIMER_NO_PARENT
+                                                                    to indicate that this timer was no scheduled by a repeating timer. */
+    int             iClientChannelUid;                         /*!< @brief (optional) unique identifier of the channel to record on. PVR_TIMER_ANY_CHANNEL will denote "any channel", not a specific one. PVR_CHANNEL_INVALID_UID denotes that channel uid is not available.*/
+    time_t          startTime;                                 /*!< @brief (optional) start time of the recording in UTC. Instant timers that are sent to the add-on by Kodi will have this value set to 0.*/
+    time_t          endTime;                                   /*!< @brief (optional) end time of the recording in UTC. */
+    bool            bStartAnyTime;                             /*!< @brief (optional) for EPG based (not Manual) timers indicates startTime does not apply. Default = false */
+    bool            bEndAnyTime;                               /*!< @brief (optional) for EPG based (not Manual) timers indicates endTime does not apply. Default = false */
     PVR_TIMER_STATE state;                                     /*!< @brief (required) the state of this timer */
-    char            strTitle[PVR_ADDON_NAME_STRING_LENGTH];    /*!< @brief (optional) title of this timer */
-    char            strDirectory[PVR_ADDON_URL_STRING_LENGTH]; /*!< @brief (optional) the directory where the recording will be stored in */
+    unsigned int    iTimerType;                                /*!< @brief (required) the type of this timer. It is private to the addon and can be freely defined by the addon. The value must be greater than PVR_TIMER_TYPE_NONE.
+                                                                    Kodi does not interpret this value (except for checking for PVR_TIMER_TYPE_NONE), but will pass the right id to the addon with every PVR_TIMER instance, thus the addon easily can determine
+                                                                    the timer type. */
+    char            strTitle[PVR_ADDON_NAME_STRING_LENGTH];    /*!< @brief (required) a title for this timer */
+    char            strEpgSearchString[PVR_ADDON_NAME_STRING_LENGTH]; /*!< @brief (optional) a string used to search epg data for repeating epg-based timers. Format is backend-dependent, for example regexp */
+    bool            bFullTextEpgSearch;                        /*!< @brief (optional) indicates, whether strEpgSearchString is to match against the epg episode title only or also against "other" epg data (backend-dependent) */
+    char            strDirectory[PVR_ADDON_URL_STRING_LENGTH]; /*!< @brief (optional) the (relative) directory where the recording will be stored in */
     char            strSummary[PVR_ADDON_DESC_STRING_LENGTH];  /*!< @brief (optional) the summary for this timer */
     int             iPriority;                                 /*!< @brief (optional) the priority of this timer */
-    int             iLifetime;                                 /*!< @brief (optional) lifetimer of this timer in days */
-    bool            bIsRepeating;                              /*!< @brief (optional) true if this is a recurring timer */
-    time_t          firstDay;                                  /*!< @brief (optional) the first day this recording is active in case of a repeating event */
-    int             iWeekdays;                                 /*!< @brief (optional) weekday mask */
-    int             iEpgUid;                                   /*!< @brief (optional) epg event id */
+    int             iLifetime;                                 /*!< @brief (optional) lifetime of recordings created by this timer. > 0 days after which recordings will be deleted by the backend, < 0 addon defined integer list reference, == 0 disabled */
+    int             iMaxRecordings;                            /*!< @brief (optional) maximum number of recordings this timer shall create. > 0 number of recordings, < 0 addon defined integer list reference, == 0 disabled */
+    unsigned int    iRecordingGroup;                           /*!< @brief (optional) integer ref to addon/backend defined list of recording groups*/
+    time_t          firstDay;                                  /*!< @brief (optional) the first day this timer is active, for repeating timers */
+    unsigned int    iWeekdays;                                 /*!< @brief (optional) week days, for repeating timers */
+    unsigned int    iPreventDuplicateEpisodes;                 /*!< @brief (optional) 1 if backend should only record new episodes in case of a repeating epg-based timer, 0 if all episodes shall be recorded (no duplicate detection). Actual algorithm for
+                                                                    duplicate detection is defined by the backend. Addons may define own values for different duplicate detection algorithms, thus this is not just a bool.*/
+    unsigned int    iEpgUid;                                   /*!< @brief (optional) EPG event id associated with this timer. Valid ids must be greater than EPG_TAG_INVALID_UID. */
     unsigned int    iMarginStart;                              /*!< @brief (optional) if set, the backend starts the recording iMarginStart minutes before startTime. */
     unsigned int    iMarginEnd;                                /*!< @brief (optional) if set, the backend ends the recording iMarginEnd minutes after endTime. */
     int             iGenreType;                                /*!< @brief (optional) genre type */
     int             iGenreSubType;                             /*!< @brief (optional) genre sub type */
   } ATTRIBUTE_PACKED PVR_TIMER;
+
   /*!
    * @brief Representation of a recording.
    */
   typedef struct PVR_RECORDING {
     char   strRecordingId[PVR_ADDON_NAME_STRING_LENGTH];  /*!< @brief (required) unique id of the recording on the client. */
     char   strTitle[PVR_ADDON_NAME_STRING_LENGTH];        /*!< @brief (required) the title of this recording */
+    char   strEpisodeName[PVR_ADDON_NAME_STRING_LENGTH];  /*!< @brief (optional) episode name (also known as subtitle) */
+    int    iSeriesNumber;                                 /*!< @brief (optional) series number (usually called season). Set to "0" for specials/pilot. For 'invalid' see iEpisodeNumber or set to -1 */
+    int    iEpisodeNumber;                                /*!< @brief (optional) episode number within the "iSeriesNumber" season. For 'invalid' set to -1 or iSeriesNumber=iEpisodeNumber=0 to show both are invalid */
+    int    iYear;                                         /*!< @brief (optional) year of first release (use to identify a specific movie re-make) / first airing for TV shows. Set to '0' for invalid. */
+
     char   strStreamURL[PVR_ADDON_URL_STRING_LENGTH];     /*!< @brief (required) stream URL to access this recording */
     char   strDirectory[PVR_ADDON_URL_STRING_LENGTH];     /*!< @brief (optional) directory of this recording on the client */
     char   strPlotOutline[PVR_ADDON_DESC_STRING_LENGTH];  /*!< @brief (optional) plot outline */
@@ -300,7 +477,8 @@ extern "C" {
     int    iPlayCount;                                    /*!< @brief (optional) play count of this recording on the client */
     int    iLastPlayedPosition;                           /*!< @brief (optional) last played position of this recording on the client */
     bool   bIsDeleted;                                    /*!< @brief (optional) shows this recording is deleted and can be undelete */
-    unsigned int iEpgEventId;                             /*!< @brief (optional) EPG event id associated with this recording */
+    unsigned int iEpgEventId;                             /*!< @brief (optional) EPG event id associated with this recording. Valid ids must be greater than EPG_TAG_INVALID_UID. */
+    int    iChannelUid;                                   /*!< @brief (optional) unique identifier of the channel for this recording. PVR_CHANNEL_INVALID_UID denotes that channel uid is not available. */
   } ATTRIBUTE_PACKED PVR_RECORDING;
 
   /*!
@@ -373,6 +551,7 @@ extern "C" {
     PVR_ERROR    (__cdecl* SetRecordingLastPlayedPosition)(const PVR_RECORDING&, int);
     int          (__cdecl* GetRecordingLastPlayedPosition)(const PVR_RECORDING&);
     PVR_ERROR    (__cdecl* GetRecordingEdl)(const PVR_RECORDING&, PVR_EDL_ENTRY[], int*);
+    PVR_ERROR    (__cdecl* GetTimerTypes)(PVR_TIMER_TYPE[], int*);
     int          (__cdecl* GetTimersAmount)(void);
     PVR_ERROR    (__cdecl* GetTimers)(ADDON_HANDLE);
     PVR_ERROR    (__cdecl* AddTimer)(const PVR_TIMER&);
@@ -384,7 +563,6 @@ extern "C" {
     long long    (__cdecl* SeekLiveStream)(long long, int);
     long long    (__cdecl* PositionLiveStream)(void);
     long long    (__cdecl* LengthLiveStream)(void);
-    int          (__cdecl* GetCurrentClientChannel)(void);
     bool         (__cdecl* SwitchChannel)(const PVR_CHANNEL&);
     PVR_ERROR    (__cdecl* SignalStatus)(PVR_SIGNAL_STATUS&);
     const char*  (__cdecl* GetLiveStreamURL)(const PVR_CHANNEL&);
@@ -408,10 +586,12 @@ extern "C" {
     time_t       (__cdecl* GetBufferTimeStart)(void);
     time_t       (__cdecl* GetBufferTimeEnd)(void);
     const char*  (__cdecl* GetBackendHostname)(void);
+    bool         (__cdecl* IsTimeshifting)(void);
+    bool         (__cdecl* IsRealTimeStream)(void);
+    PVR_ERROR    (__cdecl* SetEPGTimeFrame)(int);
   } PVRClient;
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif //__PVRCLIENT_TYPES_H__
diff --git a/xbmc/addons/include/xbmc_scr_dll.h b/xbmc/addons/kodi-addon-dev-kit/include/kodi/xbmc_scr_dll.h
index c4257b4..8652a0a 100644
--- a/xbmc/addons/include/xbmc_scr_dll.h
+++ b/xbmc/addons/kodi-addon-dev-kit/include/kodi/xbmc_scr_dll.h
@@ -1,7 +1,8 @@
 #pragma once
+
 /*
- *      Copyright (C) 2005-2013 Team XBMC
- *      http://xbmc.org
+ *      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
@@ -14,14 +15,11 @@
  *  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
+ *  along with Kodi; see the file COPYING.  If not, see
  *  <http://www.gnu.org/licenses/>.
  *
  */
 
-#ifndef __XBMC_SCR_H__
-#define __XBMC_SCR_H__
-
 #include "xbmc_addon_dll.h"
 #include "xbmc_scr_types.h"
 
@@ -42,4 +40,3 @@ extern "C"
   };
 };
 
-#endif
diff --git a/xbmc/addons/include/xbmc_scr_types.h b/xbmc/addons/kodi-addon-dev-kit/include/kodi/xbmc_scr_types.h
index fec3040..5785b25 100644
--- a/xbmc/addons/include/xbmc_scr_types.h
+++ b/xbmc/addons/kodi-addon-dev-kit/include/kodi/xbmc_scr_types.h
@@ -1,7 +1,8 @@
 #pragma once
+
 /*
- *      Copyright (C) 2005-2013 Team XBMC
- *      http://xbmc.org
+ *      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
@@ -14,14 +15,11 @@
  *  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
+ *  along with Kodi; see the file COPYING.  If not, see
  *  <http://www.gnu.org/licenses/>.
  *
  */
 
-#ifndef __SCREENSAVER_TYPES_H__
-#define __SCREENSAVER_TYPES_H__
-
 extern "C"
 {
   struct SCR_INFO
@@ -50,4 +48,3 @@ extern "C"
   };
 }
 
-#endif // __SCREENSAVER_TYPES_H__
diff --git a/xbmc/addons/include/xbmc_stream_utils.hpp b/xbmc/addons/kodi-addon-dev-kit/include/kodi/xbmc_stream_utils.hpp
index 927fe33..099776a 100644
--- a/xbmc/addons/include/xbmc_stream_utils.hpp
+++ b/xbmc/addons/kodi-addon-dev-kit/include/kodi/xbmc_stream_utils.hpp
@@ -160,7 +160,7 @@ namespace ADDON
     {
       XbmcPvrStream *foundStream = GetStreamById(iPhysicalId);
       if (foundStream)
-        stream = foundStream;
+        *stream = *foundStream;
       else
       {
         stream->iIdentifier = -1;
diff --git a/xbmc/addons/include/xbmc_vis_dll.h b/xbmc/addons/kodi-addon-dev-kit/include/kodi/xbmc_vis_dll.h
index c65f844..50452c2 100644
--- a/xbmc/addons/include/xbmc_vis_dll.h
+++ b/xbmc/addons/kodi-addon-dev-kit/include/kodi/xbmc_vis_dll.h
@@ -1,9 +1,8 @@
-#ifndef __XBMC_VIS_H__
-#define __XBMC_VIS_H__
+#pragma once
 
 /*
- *      Copyright (C) 2005-2013 Team XBMC
- *      http://xbmc.org
+ *      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
@@ -16,7 +15,7 @@
  *  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
+ *  along with Kodi; see the file COPYING.  If not, see
  *  <http://www.gnu.org/licenses/>.
  *
  */
@@ -52,4 +51,3 @@ extern "C"
   };
 };
 
-#endif
diff --git a/xbmc/addons/include/xbmc_vis_types.h b/xbmc/addons/kodi-addon-dev-kit/include/kodi/xbmc_vis_types.h
index e6b0ccd..708ffef 100644
--- a/xbmc/addons/include/xbmc_vis_types.h
+++ b/xbmc/addons/kodi-addon-dev-kit/include/kodi/xbmc_vis_types.h
@@ -1,6 +1,8 @@
+#pragma once
+
 /*
- *      Copyright (C) 2005-2013 Team XBMC
- *      http://xbmc.org
+ *      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
@@ -13,17 +15,15 @@
  *  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
+ *  along with Kodi; see the file COPYING.  If not, see
  *  <http://www.gnu.org/licenses/>.
  *
  */
 
 /*
-  Common data structures shared between XBMC and XBMC's visualisations
+  Common data structures shared between Kodi and Kodi's visualisations
  */
 
-#ifndef __VISUALISATION_TYPES_H__
-#define __VISUALISATION_TYPES_H__
 #include <cstddef>
 
 extern "C"
@@ -108,4 +108,3 @@ extern "C"
   };
 }
 
-#endif //__VISUALISATION_TYPES_H__
diff --git a/xbmc/cores/AudioEngine/Utils/AEChannelData.h b/xbmc/cores/AudioEngine/Utils/AEChannelData.h
index 9993c84..c74aabb 100644
--- a/xbmc/cores/AudioEngine/Utils/AEChannelData.h
+++ b/xbmc/cores/AudioEngine/Utils/AEChannelData.h
@@ -105,14 +105,8 @@ enum AEDataFormat
   AE_FMT_DOUBLE,
   AE_FMT_FLOAT,
 
-  /* Bitstream formats */
-  AE_FMT_AAC,
-  AE_FMT_AC3,
-  AE_FMT_DTS,
-  AE_FMT_EAC3,
-  AE_FMT_TRUEHD,
-  AE_FMT_DTSHD,
-  AE_FMT_LPCM,
+  // Bitstream
+  AE_FMT_RAW,
 
   /* planar formats */
   AE_FMT_U8P,
diff --git a/xbmc/cores/VideoPlayer/DVDDemuxers/DVDDemuxPacket.h b/xbmc/cores/VideoPlayer/DVDDemuxers/DVDDemuxPacket.h
new file mode 100644
index 0000000..d64fbb3
--- /dev/null
+++ b/xbmc/cores/VideoPlayer/DVDDemuxers/DVDDemuxPacket.h
@@ -0,0 +1,36 @@
+#pragma once
+
+/*
+ *      Copyright (C) 2012-2013 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/>.
+ *
+ */
+
+#define DMX_SPECIALID_STREAMINFO    -10
+#define DMX_SPECIALID_STREAMCHANGE  -11
+
+ typedef struct DemuxPacket
+{
+  unsigned char* pData;   // data
+  int iSize;     // data size
+  int iStreamId; // integer representing the stream index
+  int iGroupId;  // the group this data belongs to, used to group data from different streams together
+
+  double pts; // pts in DVD_TIME_BASE
+  double dts; // dts in DVD_TIME_BASE
+  double duration; // duration in DVD_TIME_BASE if available
+} DemuxPacket;
diff --git a/xbmc/filesystem/IFileTypes.h b/xbmc/filesystem/IFileTypes.h
new file mode 100644
index 0000000..d2d77eb
--- /dev/null
+++ b/xbmc/filesystem/IFileTypes.h
@@ -0,0 +1,82 @@
+/*
+ *      Copyright (C) 2005-2013 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 <stdint.h>
+
+namespace XFILE
+{
+
+/* indicate that caller can handle truncated reads, where function returns before entire buffer has been filled */
+  static const unsigned int READ_TRUNCATED = 0x01;
+
+/* indicate that that caller support read in the minimum defined chunk size, this disables internal cache then */
+  static const unsigned int READ_CHUNKED = 0x02;
+
+/* use cache to access this file */
+  static const unsigned int READ_CACHED = 0x04;
+
+/* open without caching. regardless to file type. */
+  static const unsigned int READ_NO_CACHE = 0x08;
+
+/* calcuate bitrate for file while reading */
+  static const unsigned int READ_BITRATE = 0x10;
+
+/* indicate to the caller we will seek between multiple streams in the file frequently */
+  static const unsigned int READ_MULTI_STREAM = 0x20;
+
+/* indicate to the caller file is audio and/or video (and e.g. may grow) */
+  static const unsigned int READ_AUDIO_VIDEO = 0x40;
+
+/* indicate that caller will do write operations before reading  */
+  static const unsigned int READ_AFTER_WRITE = 0x80;
+
+struct SNativeIoControl
+{
+  unsigned long int   request;
+  void*               param;
+};
+
+struct SCacheStatus
+{
+  uint64_t forward;  /**< number of bytes cached forward of current position */
+  unsigned maxrate;  /**< maximum number of bytes per second cache is allowed to fill */
+  unsigned currate;  /**< average read rate from source file since last position change */
+  bool     full;     /**< is the cache full */
+};
+
+typedef enum {
+  IOCTRL_NATIVE        = 1, /**< SNativeIoControl structure, containing what should be passed to native ioctrl */
+  IOCTRL_SEEK_POSSIBLE = 2, /**< return 0 if known not to work, 1 if it should work */
+  IOCTRL_CACHE_STATUS  = 3, /**< SCacheStatus structure */
+  IOCTRL_CACHE_SETRATE = 4, /**< unsigned int with speed limit for caching in bytes per second */
+  IOCTRL_SET_CACHE    = 8, /** <CFileCache */
+} EIoControl;
+
+enum CURLOPTIONTYPE
+{
+  CURL_OPTION_OPTION,     /**< Set a general option   */
+  CURL_OPTION_PROTOCOL,   /**< Set a protocol option  */
+  CURL_OPTION_CREDENTIALS,/**< Set User and password  */
+  CURL_OPTION_HEADER      /**< Add a Header           */
+};
+
+}