Skip to content

Instantly share code, notes, and snippets.

@Yardanico

Yardanico/libvlc.nim Secret

Created March 27, 2020 04:54
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save Yardanico/0af5164651914ab17d37daa49af0af41 to your computer and use it in GitHub Desktop.
Save Yardanico/0af5164651914ab17d37daa49af0af41 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
libvlc.nim
# Generated at 2020-03-27T07:43:15+03:00
# Command line:
# /home/dian/.nimble/pkgs/nimterop-0.4.4/nimterop/toast --preprocess --recurse --includeDirs+=/home/dian/projects/nim-libvlc/build/include --pnim --dynlib=dynvlc --nim:/home/dian/.nim/bin/nim --pluginSourcePath=/home/dian/.cache/nim/nimterop/cPlugins/nimterop_1348660332.nim /home/dian/projects/nim-libvlc/build/include/vlc/vlc.h
{.hint[ConvFromXtoItselfNotNeeded]: off.}
import nimterop/types
# * @}
# * \defgroup libvlc_log LibVLC logging
# * libvlc_log_* functions provide access to the LibVLC messages log.
# * This is used for logging and debugging.
# * @{
#
# *
# * Logging messages level.
# * \note Future LibVLC versions may define new levels.
#
defineEnum(log_level)
defineEnum(picture_type_t)
# * Meta data types
defineEnum(meta_t)
# *
# * Note the order of libvlc_state_t enum must match exactly the order of
# * \see mediacontrol_PlayerStatus, \see input_state_e enums,
# * and VideoLAN.LibVLC.State (at bindings/cil/src/media.cs).
# *
# * Expected states by web plugins are:
# * IDLE/CLOSE=0, OPENING=1, PLAYING=3, PAUSED=4,
# * STOPPING=5, ENDED=6, ERROR=7
#
defineEnum(state_t)
defineEnum(Enum_vlch1)
defineEnum(track_type_t)
defineEnum(video_orient_t)
defineEnum(video_projection_t)
defineEnum(video_multiview_t)
# *
# * Media type
# *
# * \see libvlc_media_get_type
#
defineEnum(media_type_t)
# *
# * Parse flags used by libvlc_media_parse_with_options()
# *
# * \see libvlc_media_parse_with_options
#
defineEnum(media_parse_flag_t)
# *
# * Parse status used sent by libvlc_media_parse_with_options() or returned by
# * libvlc_media_get_parsed_status()
# *
# * \see libvlc_media_parse_with_options
# * \see libvlc_media_get_parsed_status
#
defineEnum(media_parsed_status_t)
# *
# * Type of a media slave: subtitle or audio.
#
defineEnum(media_slave_type_t)
defineEnum(thumbnailer_seek_speed_t)
# *
# * Description for titles
#
defineEnum(Enum_vlch2)
# *
# * Marq options definition
#
defineEnum(video_marquee_option_t)
# *
# * Navigation mode
#
defineEnum(navigate_mode_t)
# *
# * Enumeration of values used to set position (e.g. of video title).
#
defineEnum(position_t)
# *
# * Enumeration of teletext keys than can be passed via
# * libvlc_video_set_teletext()
#
defineEnum(teletext_key_t)
# *
# * Enumeration of the Video color primaries.
#
defineEnum(video_color_primaries_t)
# *
# * Enumeration of the Video color spaces.
#
defineEnum(video_color_space_t)
# *
# * Enumeration of the Video transfer functions.
#
defineEnum(video_transfer_func_t)
defineEnum(video_metadata_type_t)
# *
# * Enumeration of the Video engine to be used on output.
# * can be passed to @a libvlc_video_set_output_callbacks
#
defineEnum(video_engine_t)
# * option values for libvlc_video_{get,set}_logo_{int,string}
defineEnum(video_logo_option_t)
# * option values for libvlc_video_{get,set}_adjust_{int,float,bool}
defineEnum(video_adjust_option_t)
# * @} video
# * \defgroup libvlc_audio LibVLC audio controls
# * @{
#
# *
# * Audio channels
#
defineEnum(audio_output_channel_t)
# *
# * Defines playback modes for playlist.
#
defineEnum(playback_mode_t)
# *
# * Category of a media discoverer
# * \see libvlc_media_discoverer_list_get()
#
defineEnum(media_discoverer_category_t)
# *
# * \file
# * This file defines libvlc_event external API
#
# *
# * \ingroup libvlc_event
# * @{
#
# *
# * Event types
#
defineEnum(event_e)
# *
# * @defgroup libvlc_dialog LibVLC dialog
# * @ingroup libvlc
# * @{
# * @file
# * LibVLC dialog external API
#
defineEnum(dialog_question_type)
const
# ****************************************************************************
# * vlc.h: global header for libvlc
# *****************************************************************************
# * Copyright (C) 1998-2008 VLC authors and VideoLAN
# *
# * Authors: Vincent Seguin <seguin@via.ecp.fr>
# * Samuel Hocevar <sam@zoy.org>
# * Gildas Bazin <gbazin@netcourrier.com>
# * Derk-Jan Hartman <hartman at videolan dot org>
# * Pierre d'Herbemont <pdherbemont@videolan.org>
# *
# * This program is free software; you can redistribute it and/or modify it
# * under the terms of the GNU Lesser General Public License as published by
# * the Free Software Foundation; either version 2.1 of the License, 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 Lesser General Public License for more details.
# *
# * You should have received a copy of the GNU Lesser General Public License
# * along with this program; if not, write to the Free Software Foundation,
# * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
# ****************************************************************************
VLC_VLC_H* = 1
# *
# * \file
# * This file defines libvlc new external API
#
# ****************************************************************************
# * libvlc.h: libvlc external API
# *****************************************************************************
# * Copyright (C) 1998-2009 VLC authors and VideoLAN
# *
# * Authors: Clément Stenac <zorglub@videolan.org>
# * Jean-Paul Saman <jpsaman@videolan.org>
# * Pierre d'Herbemont <pdherbemont@videolan.org>
# *
# * This program is free software; you can redistribute it and/or modify it
# * under the terms of the GNU Lesser General Public License as published by
# * the Free Software Foundation; either version 2.1 of the License, 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 Lesser General Public License for more details.
# *
# * You should have received a copy of the GNU Lesser General Public License
# * along with this program; if not, write to the Free Software Foundation,
# * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
# ****************************************************************************
# *
# * \defgroup libvlc LibVLC
# * LibVLC is the external programming interface of the VLC media player.
# * It is used to embed VLC into other applications or frameworks.
# * @{
# * \file
# * LibVLC core external API
#
VLC_LIBVLC_H* = 1
LIBVLC_DEBUG* = (0).log_level
LIBVLC_NOTICE* = (2).log_level
LIBVLC_WARNING* = (3).log_level
LIBVLC_ERROR* = (4).log_level
# {
# return pts - libvlc_clock();
# }
# * @}
# ****************************************************************************
# * libvlc_renderer_discoverer.h: libvlc external API
# *****************************************************************************
# * Copyright © 2016 VLC authors and VideoLAN
# *
# * This program is free software; you can redistribute it and/or modify it
# * under the terms of the GNU Lesser General Public License as published by
# * the Free Software Foundation; either version 2.1 of the License, 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 Lesser General Public License for more details.
# *
# * You should have received a copy of the GNU Lesser General Public License
# * along with this program; if not, write to the Free Software Foundation,
# * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
# ****************************************************************************
VLC_LIBVLC_RENDERER_DISCOVERER_H* = 1
# * The renderer can render audio
LIBVLC_RENDERER_CAN_AUDIO* = 0x0001
# * The renderer can render video
LIBVLC_RENDERER_CAN_VIDEO* = 0x0002
# * @}
# ****************************************************************************
# * libvlc_picture.h: libvlc external API
# *****************************************************************************
# * Copyright (C) 2018 VLC authors and VideoLAN
# *
# * Authors: Hugo Beauzée-Luyssen <hugo@beauzee.fr>
# *
# * This program is free software; you can redistribute it and/or modify it
# * under the terms of the GNU Lesser General Public License as published by
# * the Free Software Foundation; either version 2.1 of the License, 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 Lesser General Public License for more details.
# *
# * You should have received a copy of the GNU Lesser General Public License
# * along with this program; if not, write to the Free Software Foundation,
# * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
# ****************************************************************************
VLC_LIBVLC_PICTURE_H* = 1
picture_Argb* = 0.picture_type_t
picture_Png* = 1.picture_type_t
picture_Jpg* = 2.picture_type_t
# ****************************************************************************
# * libvlc_media.h: libvlc external API
# *****************************************************************************
# * Copyright (C) 1998-2009 VLC authors and VideoLAN
# *
# * Authors: Clément Stenac <zorglub@videolan.org>
# * Jean-Paul Saman <jpsaman@videolan.org>
# * Pierre d'Herbemont <pdherbemont@videolan.org>
# *
# * This program is free software; you can redistribute it and/or modify it
# * under the terms of the GNU Lesser General Public License as published by
# * the Free Software Foundation; either version 2.1 of the License, 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 Lesser General Public License for more details.
# *
# * You should have received a copy of the GNU Lesser General Public License
# * along with this program; if not, write to the Free Software Foundation,
# * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
# ****************************************************************************
VLC_LIBVLC_MEDIA_H* = 1
meta_Title* = 0.meta_t
meta_Artist* = 1.meta_t
meta_Genre* = 2.meta_t
meta_Copyright* = 3.meta_t
meta_Album* = 4.meta_t
meta_TrackNumber* = 5.meta_t
meta_Description* = 6.meta_t
meta_Rating* = 7.meta_t
meta_Date* = 8.meta_t
meta_Setting* = 9.meta_t
meta_URL* = 10.meta_t
meta_Language* = 11.meta_t
meta_NowPlaying* = 12.meta_t
meta_Publisher* = 13.meta_t
meta_EncodedBy* = 14.meta_t
meta_ArtworkURL* = 15.meta_t
meta_TrackID* = 16.meta_t
meta_TrackTotal* = 17.meta_t
meta_Director* = 18.meta_t
meta_Season* = 19.meta_t
meta_Episode* = 20.meta_t
meta_ShowName* = 21.meta_t
meta_Actors* = 22.meta_t
meta_AlbumArtist* = 23.meta_t
meta_DiscNumber* = 24.meta_t
meta_DiscTotal* = 25.meta_t
NothingSpecial* = (0).state_t
Opening* = 1.state_t
Buffering* = 2.state_t
Playing* = 3.state_t
Paused* = 4.state_t
Stopped* = 5.state_t
Ended* = 6.state_t
Error* = 7.state_t
media_option_trusted* = (0x2).Enum_vlch1
media_option_unique* = (0x100).Enum_vlch1
track_unknown* = (-1).track_type_t
track_audio* = (0).track_type_t
track_video* = (1).track_type_t
track_text* = (2).track_type_t
video_orient_top_left* = 0.video_orient_t
video_orient_top_right* = 1.video_orient_t
video_orient_bottom_left* = 2.video_orient_t
video_orient_bottom_right* = 3.video_orient_t
video_orient_left_top* = 4.video_orient_t
video_orient_left_bottom* = 5.video_orient_t
video_orient_right_top* = 6.video_orient_t
video_orient_right_bottom* = 7.video_orient_t
video_projection_rectangular* = 0.video_projection_t
video_projection_equirectangular* = 1.video_projection_t
video_projection_cubemap_layout_standard* = (0x100).video_projection_t
video_multiview_2d* = 0.video_multiview_t
video_multiview_stereo_sbs* = 1.video_multiview_t
video_multiview_stereo_tb* = 2.video_multiview_t
video_multiview_stereo_row* = 3.video_multiview_t
video_multiview_stereo_col* = 4.video_multiview_t
video_multiview_stereo_frame* = 5.video_multiview_t
video_multiview_stereo_checkerboard* = 6.video_multiview_t
media_type_unknown* = 0.media_type_t
media_type_file* = 1.media_type_t
media_type_directory* = 2.media_type_t
media_type_disc* = 3.media_type_t
media_type_stream* = 4.media_type_t
media_type_playlist* = 5.media_type_t
media_parse_local* = (0x00).media_parse_flag_t
media_parse_network* = (0x01).media_parse_flag_t
media_fetch_local* = (0x02).media_parse_flag_t
media_fetch_network* = (0x04).media_parse_flag_t
media_do_interact* = (0x08).media_parse_flag_t
media_parsed_status_skipped* = (1).media_parsed_status_t
media_parsed_status_failed* = 2.media_parsed_status_t
media_parsed_status_timeout* = 3.media_parsed_status_t
media_parsed_status_done* = 4.media_parsed_status_t
media_slave_type_subtitle* = 0.media_slave_type_t
media_slave_type_audio* = 1.media_slave_type_t
media_thumbnail_seek_precise* = 0.thumbnailer_seek_speed_t
media_thumbnail_seek_fast* = 1.thumbnailer_seek_speed_t
# * @}
# ****************************************************************************
# * libvlc_media_player.h: libvlc_media_player external API
# *****************************************************************************
# * Copyright (C) 1998-2015 VLC authors and VideoLAN
# *
# * Authors: Clément Stenac <zorglub@videolan.org>
# * Jean-Paul Saman <jpsaman@videolan.org>
# * Pierre d'Herbemont <pdherbemont@videolan.org>
# *
# * This program is free software; you can redistribute it and/or modify it
# * under the terms of the GNU Lesser General Public License as published by
# * the Free Software Foundation; either version 2.1 of the License, 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 Lesser General Public License for more details.
# *
# * You should have received a copy of the GNU Lesser General Public License
# * along with this program; if not, write to the Free Software Foundation,
# * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
# ****************************************************************************
VLC_LIBVLC_MEDIA_PLAYER_H* = 1
title_menu* = (0x01).Enum_vlch2
title_interactive* = (0x02).Enum_vlch2
marquee_Enable* = (0).video_marquee_option_t
marquee_Text* = 1.video_marquee_option_t
marquee_Color* = 2.video_marquee_option_t
marquee_Opacity* = 3.video_marquee_option_t
marquee_Position* = 4.video_marquee_option_t
marquee_Refresh* = 5.video_marquee_option_t
marquee_Size* = 6.video_marquee_option_t
marquee_Timeout* = 7.video_marquee_option_t
marquee_X* = 8.video_marquee_option_t
marquee_Y* = 9.video_marquee_option_t
navigate_activate* = (0).navigate_mode_t
navigate_up* = 1.navigate_mode_t
navigate_down* = 2.navigate_mode_t
navigate_left* = 3.navigate_mode_t
navigate_right* = 4.navigate_mode_t
navigate_popup* = 5.navigate_mode_t
position_disable* = (-1).position_t
position_center* = 0.position_t
position_left* = 1.position_t
position_right* = 2.position_t
position_top* = 3.position_t
position_top_left* = 4.position_t
position_top_right* = 5.position_t
position_bottom* = 6.position_t
position_bottom_left* = 7.position_t
position_bottom_right* = 8.position_t
teletext_key_red* = ('r').teletext_key_t
'r' << 16* = 1.teletext_key_t
teletext_key_green* = ('g').teletext_key_t
'g' << 16* = 3.teletext_key_t
teletext_key_yellow* = ('y').teletext_key_t
'y' << 16* = 5.teletext_key_t
teletext_key_blue* = ('b').teletext_key_t
'b' << 16* = 7.teletext_key_t
teletext_key_index* = ('i').teletext_key_t
'i' << 16* = 9.teletext_key_t
video_primaries_BT601_525* = (1).video_color_primaries_t
video_primaries_BT601_625* = (2).video_color_primaries_t
video_primaries_BT709* = (3).video_color_primaries_t
video_primaries_BT2020* = (4).video_color_primaries_t
video_primaries_DCI_P3* = (5).video_color_primaries_t
video_primaries_BT470_M* = (6).video_color_primaries_t
video_colorspace_BT601* = (1).video_color_space_t
video_colorspace_BT709* = (2).video_color_space_t
video_colorspace_BT2020* = (3).video_color_space_t
video_transfer_func_LINEAR* = (1).video_transfer_func_t
video_transfer_func_SRGB* = (2).video_transfer_func_t
video_transfer_func_BT470_BG* = (3).video_transfer_func_t
video_transfer_func_BT470_M* = (4).video_transfer_func_t
video_transfer_func_BT709* = (5).video_transfer_func_t
video_transfer_func_PQ* = (6).video_transfer_func_t
video_transfer_func_SMPTE_240* = (7).video_transfer_func_t
video_transfer_func_HLG* = (8).video_transfer_func_t
video_metadata_frame_hdr10* = 0.video_metadata_type_t
video_engine_disable* = 0.video_engine_t
video_engine_opengl* = 1.video_engine_t
video_engine_gles2* = 2.video_engine_t
video_engine_d3d11* = 3.video_engine_t
video_engine_d3d9* = 4.video_engine_t
logo_enable* = 0.video_logo_option_t
logo_file* = 1.video_logo_option_t
logo_x* = 2.video_logo_option_t
logo_y* = 3.video_logo_option_t
logo_delay* = 4.video_logo_option_t
logo_repeat* = 5.video_logo_option_t
logo_opacity* = 6.video_logo_option_t
logo_position* = 7.video_logo_option_t
adjust_Enable* = (0).video_adjust_option_t
adjust_Contrast* = 1.video_adjust_option_t
adjust_Brightness* = 2.video_adjust_option_t
adjust_Hue* = 3.video_adjust_option_t
adjust_Saturation* = 4.video_adjust_option_t
adjust_Gamma* = 5.video_adjust_option_t
AudioChannel_Error* = (-1).audio_output_channel_t
AudioChannel_Stereo* = (1).audio_output_channel_t
AudioChannel_RStereo* = (2).audio_output_channel_t
AudioChannel_Left* = (3).audio_output_channel_t
AudioChannel_Right* = (4).audio_output_channel_t
AudioChannel_Dolbys* = (5).audio_output_channel_t
# * @} audio
# * @} media_player
# ****************************************************************************
# * libvlc_media_list.h: libvlc_media_list API
# *****************************************************************************
# * Copyright (C) 1998-2008 VLC authors and VideoLAN
# *
# * Authors: Pierre d'Herbemont
# *
# * This program is free software; you can redistribute it and/or modify it
# * under the terms of the GNU Lesser General Public License as published by
# * the Free Software Foundation; either version 2.1 of the License, 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 Lesser General Public License for more details.
# *
# * You should have received a copy of the GNU Lesser General Public License
# * along with this program; if not, write to the Free Software Foundation,
# * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
# ****************************************************************************
LIBVLC_MEDIA_LIST_H* = 1
# * @} media_list
# ****************************************************************************
# * libvlc_media_list_player.h: libvlc_media_list API
# *****************************************************************************
# * Copyright (C) 1998-2008 VLC authors and VideoLAN
# *
# * Authors: Pierre d'Herbemont
# *
# * This program is free software; you can redistribute it and/or modify it
# * under the terms of the GNU Lesser General Public License as published by
# * the Free Software Foundation; either version 2.1 of the License, 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 Lesser General Public License for more details.
# *
# * You should have received a copy of the GNU Lesser General Public License
# * along with this program; if not, write to the Free Software Foundation,
# * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
# ****************************************************************************
LIBVLC_MEDIA_LIST_PLAYER_H* = 1
playback_mode_default* = 0.playback_mode_t
playback_mode_loop* = 1.playback_mode_t
playback_mode_repeat* = 2.playback_mode_t
# * @} media_list_player
# ****************************************************************************
# * libvlc_media_discoverer.h: libvlc external API
# *****************************************************************************
# * Copyright (C) 1998-2009 VLC authors and VideoLAN
# *
# * Authors: Clément Stenac <zorglub@videolan.org>
# * Jean-Paul Saman <jpsaman@videolan.org>
# * Pierre d'Herbemont <pdherbemont@videolan.org>
# *
# * This program is free software; you can redistribute it and/or modify it
# * under the terms of the GNU Lesser General Public License as published by
# * the Free Software Foundation; either version 2.1 of the License, 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 Lesser General Public License for more details.
# *
# * You should have received a copy of the GNU Lesser General Public License
# * along with this program; if not, write to the Free Software Foundation,
# * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
# ****************************************************************************
VLC_LIBVLC_MEDIA_DISCOVERER_H* = 1
media_discoverer_devices* = 0.media_discoverer_category_t
media_discoverer_lan* = 1.media_discoverer_category_t
media_discoverer_podcasts* = 2.media_discoverer_category_t
media_discoverer_localdirs* = 3.media_discoverer_category_t
# *@}
# ****************************************************************************
# * libvlc_events.h: libvlc_events external API structure
# *****************************************************************************
# * Copyright (C) 1998-2010 VLC authors and VideoLAN
# *
# * Authors: Filippo Carone <littlejohn@videolan.org>
# * Pierre d'Herbemont <pdherbemont@videolan.org>
# *
# * This program is free software; you can redistribute it and/or modify it
# * under the terms of the GNU Lesser General Public License as published by
# * the Free Software Foundation; either version 2.1 of the License, 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 Lesser General Public License for more details.
# *
# * You should have received a copy of the GNU Lesser General Public License
# * along with this program; if not, write to the Free Software Foundation,
# * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
# ****************************************************************************
LIBVLC_EVENTS_H* = 1
MediaMetaChanged* = (0).event_e
MediaSubItemAdded* = 1.event_e
MediaDurationChanged* = 2.event_e
MediaParsedChanged* = 3.event_e
MediaFreed* = 4.event_e
MediaStateChanged* = 5.event_e
MediaSubItemTreeAdded* = 6.event_e
MediaThumbnailGenerated* = 7.event_e
MediaPlayerMediaChanged* = (0x100).event_e
MediaPlayerNothingSpecial* = 9.event_e
MediaPlayerOpening* = 10.event_e
MediaPlayerBuffering* = 11.event_e
MediaPlayerPlaying* = 12.event_e
MediaPlayerPaused* = 13.event_e
MediaPlayerStopped* = 14.event_e
MediaPlayerForward* = 15.event_e
MediaPlayerBackward* = 16.event_e
MediaPlayerEndReached* = 17.event_e
MediaPlayerEncounteredError* = 18.event_e
MediaPlayerTimeChanged* = 19.event_e
MediaPlayerPositionChanged* = 20.event_e
MediaPlayerSeekableChanged* = 21.event_e
MediaPlayerPausableChanged* = 22.event_e
MediaPlayerTitleChanged* = 23.event_e
MediaPlayerSnapshotTaken* = 24.event_e
MediaPlayerLengthChanged* = 25.event_e
MediaPlayerVout* = 26.event_e
MediaPlayerScrambledChanged* = 27.event_e
MediaPlayerESAdded* = 28.event_e
MediaPlayerESDeleted* = 29.event_e
MediaPlayerESSelected* = 30.event_e
MediaPlayerCorked* = 31.event_e
MediaPlayerUncorked* = 32.event_e
MediaPlayerMuted* = 33.event_e
MediaPlayerUnmuted* = 34.event_e
MediaPlayerAudioVolume* = 35.event_e
MediaPlayerAudioDevice* = 36.event_e
MediaPlayerChapterChanged* = 37.event_e
MediaListItemAdded* = (0x200).event_e
MediaListWillAddItem* = 39.event_e
MediaListItemDeleted* = 40.event_e
MediaListWillDeleteItem* = 41.event_e
MediaListEndReached* = 42.event_e
MediaListViewItemAdded* = (0x300).event_e
MediaListViewWillAddItem* = 44.event_e
MediaListViewItemDeleted* = 45.event_e
MediaListViewWillDeleteItem* = 46.event_e
MediaListPlayerPlayed* = (0x400).event_e
MediaListPlayerNextItemSet* = 48.event_e
MediaListPlayerStopped* = 49.event_e
RendererDiscovererItemAdded* = (0x502).event_e
RendererDiscovererItemDeleted* = 51.event_e
# *@}
# ****************************************************************************
# * libvlc_dialog.h: libvlc dialog API
# *****************************************************************************
# * Copyright © 2016 VLC authors and VideoLAN
# *
# * This program is free software; you can redistribute it and/or modify it
# * under the terms of the GNU Lesser General Public License as published by
# * the Free Software Foundation; either version 2.1 of the License, 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 Lesser General Public License for more details.
# *
# * You should have received a copy of the GNU Lesser General Public License
# * along with this program; if not, write to the Free Software Foundation,
# * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
# ****************************************************************************
LIBVLC_DIALOG_H* = 1
LIBVLC_DIALOG_QUESTION_NORMAL* = 0.dialog_question_type
LIBVLC_DIALOG_QUESTION_WARNING* = 1.dialog_question_type
LIBVLC_DIALOG_QUESTION_CRITICAL* = 2.dialog_question_type
# * @}
# ****************************************************************************
# * deprecated.h: libvlc deprecated API
# *****************************************************************************
# * Copyright (C) 1998-2008 VLC authors and VideoLAN
# *
# * Authors: Clément Stenac <zorglub@videolan.org>
# * Jean-Paul Saman <jpsaman@videolan.org>
# *
# * This program is free software; you can redistribute it and/or modify it
# * under the terms of the GNU Lesser General Public License as published by
# * the Free Software Foundation; either version 2.1 of the License, 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 Lesser General Public License for more details.
# *
# * You should have received a copy of the GNU Lesser General Public License
# * along with this program; if not, write to the Free Software Foundation,
# * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
# ****************************************************************************
LIBVLC_DEPRECATED_H* = 1
{.pragma: impvlc, importc.}
{.pragma: impvlcC, impvlc, cdecl, dynlib: dynvlc.}
type
# * \defgroup libvlc_core LibVLC core
# * \ingroup libvlc
# * Before it can do anything useful, LibVLC must be initialized.
# * You can create one (or more) instance(s) of LibVLC in a given process,
# * with libvlc_new() and destroy them with libvlc_release().
# *
# * \version Unless otherwise stated, these functions are available
# * from LibVLC versions numbered 1.1.0 or more.
# * Earlier versions (0.9.x and 1.0.x) are <b>not</b> compatible.
# * @{
#
# * This structure is opaque. It represents a libvlc instance
instance_t* {.incompleteStruct.} = object
time_t* = int64
# * \defgroup libvlc_event LibVLC asynchronous events
# * LibVLC emits asynchronous events.
# *
# * Several LibVLC objects (such @ref libvlc_instance_t as
# * @ref libvlc_media_player_t) generate events asynchronously. Each of them
# * provides @ref libvlc_event_manager_t event manager. You can subscribe to
# * events with libvlc_event_attach() and unsubscribe with
# * libvlc_event_detach().
# * @{
#
# *
# * Event manager that belongs to a libvlc object, and from whom events can
# * be received.
#
event_manager_t* {.incompleteStruct.} = object
event_t* {.bycopy.} = object
# *
# * Type of a LibVLC event.
#
event_type_t* = cint
# *
# * Callback function notification
# * \param p_event the event triggering the callback
#
callback_t* = proc(p_event: ptr event_t, p_data: pointer) {.cdecl.}
log_t* = vlc_log_t
# *
# * Callback prototype for LibVLC log message handler.
# *
# * \param data data pointer as given to libvlc_log_set()
# * \param level message level (@ref libvlc_log_level)
# * \param ctx message context (meta-information about the message)
# * \param fmt printf() format string (as defined by ISO C11)
# * \param args variable argument list for the format
# * \note Log message handlers <b>must</b> be thread-safe.
# * \warning The message context pointer, the format string parameters and the
# * variable arguments are only valid until the callback returns.
#
log_cb* = proc(data: pointer, level: cint, ctx: ptr log_t, fmt: cstring, args: va_list) {.cdecl.}
# * @}
# *
# * Description of a module.
#
module_description_t* {.bycopy.} = object
psz_name*: cstring
psz_shortname*: cstring
psz_longname*: cstring
psz_help*: cstring
p_next*: ptr module_description_t
# *
# * @defgroup libvlc_renderer_discoverer LibVLC renderer discoverer
# * @ingroup libvlc
# * LibVLC renderer discoverer finds available renderers available on the local
# * network
# * @{
# * @file
# * LibVLC renderer discoverer external API
#
renderer_discoverer_t* {.incompleteStruct.} = object
# *
# * Renderer discoverer description
# *
# * \see libvlc_renderer_discoverer_list_get()
#
rd_description_t* {.bycopy.} = object
psz_name*: cstring
psz_longname*: cstring
# *
# * Renderer item
# *
# * This struct is passed by a @ref libvlc_event_t when a new renderer is added
# * or deleted.
# *
# * An item is valid until the @ref libvlc_RendererDiscovererItemDeleted event
# * is called with the same pointer.
# *
# * \see libvlc_renderer_discoverer_event_manager()
#
renderer_item_t* {.incompleteStruct.} = object
picture_t* {.incompleteStruct.} = object
# * \defgroup libvlc_media LibVLC media
# * \ingroup libvlc
# * @ref libvlc_media_t is an abstract representation of a playable media.
# * It consists of a media location and various optional meta data.
# * @{
# * \file
# * LibVLC media item/descriptor external API
#
media_t* {.incompleteStruct.} = object
media_stats_t* {.bycopy.} = object
i_read_bytes*: cint
f_input_bitrate*: cfloat
i_demux_read_bytes*: cint
f_demux_bitrate*: cfloat
i_demux_corrupted*: cint
i_demux_discontinuity*: cint
i_decoded_video*: cint
i_decoded_audio*: cint
i_displayed_pictures*: cint
i_lost_pictures*: cint
i_played_abuffers*: cint
i_lost_abuffers*: cint
audio_track_t* {.bycopy.} = object
i_channels*: cuint
i_rate*: cuint
# *
# * Viewpoint
# *
# * \warning allocate using libvlc_video_new_viewpoint()
#
video_viewpoint_t* {.bycopy.} = object
f_yaw*: cfloat
f_pitch*: cfloat
f_roll*: cfloat
f_field_of_view*: cfloat
video_track_t* {.bycopy.} = object
i_height*: cuint
i_width*: cuint
i_sar_num*: cuint
i_sar_den*: cuint
i_frame_rate_num*: cuint
i_frame_rate_den*: cuint
i_orientation*: video_orient_t
i_projection*: video_projection_t
pose*: video_viewpoint_t
i_multiview*: video_multiview_t
subtitle_track_t* {.bycopy.} = object
psz_encoding*: cstring
# Type 'libvlc_media_track_t' skipped
# Type 'libvlc_track_type_t' skipped
# Type 'libvlc_media_track_t' skipped
# Type 'libvlc_track_type_t' skipped
# Type 'libvlc_audio_track_t' skipped
# Type 'libvlc_video_track_t' skipped
# Type 'libvlc_subtitle_track_t' skipped
# Type 'libvlc_media_track_t' skipped
# *
# * A slave of a libvlc_media_t
# * \see libvlc_media_slaves_get
#
media_slave_t* {.bycopy.} = object
psz_uri*: cstring
i_type*: media_slave_type_t
i_priority*: cuint
# *
# * Callback prototype to open a custom bitstream input media.
# *
# * The same media item can be opened multiple times. Each time, this callback
# * is invoked. It should allocate and initialize any instance-specific
# * resources, then store them in *datap. The instance resources can be freed
# * in the @ref libvlc_media_close_cb callback.
# *
# * \param opaque private pointer as passed to libvlc_media_new_callbacks()
# * \param datap storage space for a private data pointer [OUT]
# * \param sizep byte length of the bitstream or UINT64_MAX if unknown [OUT]
# *
# * \note For convenience, *datap is initially NULL and *sizep is initially 0.
# *
# * \return 0 on success, non-zero on error. In case of failure, the other
# * callbacks will not be invoked and any value stored in *datap and *sizep is
# * discarded.
#
media_open_cb* = proc(opaque: pointer, datap: ptr pointer, sizep: ptr uint64): cint {.cdecl.}
# *
# * Callback prototype to read data from a custom bitstream input media.
# *
# * \param opaque private pointer as set by the @ref libvlc_media_open_cb
# * callback
# * \param buf start address of the buffer to read data into
# * \param len bytes length of the buffer
# *
# * \return strictly positive number of bytes read, 0 on end-of-stream,
# * or -1 on non-recoverable error
# *
# * \note If no data is immediately available, then the callback should sleep.
# * \warning The application is responsible for avoiding deadlock situations.
#
media_read_cb* = proc(opaque: pointer, buf: ptr cuchar, len: uint): cint {.cdecl.}
# *
# * Callback prototype to seek a custom bitstream input media.
# *
# * \param opaque private pointer as set by the @ref libvlc_media_open_cb
# * callback
# * \param offset absolute byte offset to seek to
# * \return 0 on success, -1 on error.
#
media_seek_cb* = proc(opaque: pointer, offset: uint64): cint {.cdecl.}
# *
# * Callback prototype to close a custom bitstream input media.
# *
# * \param opaque private pointer as set by the @ref libvlc_media_open_cb
# * callback
#
media_close_cb* = proc(opaque: pointer) {.cdecl.}
# *
# * \brief libvlc_media_thumbnail_request_t An opaque thumbnail request object
#
media_thumbnail_request_t* {.incompleteStruct.} = object
# * \defgroup libvlc_media_player LibVLC media player
# * \ingroup libvlc
# * A LibVLC media player plays one media (usually in a custom drawable).
# * @{
# * \file
# * LibVLC simple media player external API
#
media_player_t* {.incompleteStruct.} = object
# *
# * Description for video, audio tracks and subtitles. It contains
# * id, name (description string) and pointer to next record.
#
track_description_t* {.bycopy.} = object
i_id*: cint
psz_name*: cstring
p_next*: ptr track_description_t
title_description_t* {.bycopy.} = object
i_duration*: int64
psz_name*: cstring
i_flags*: cuint
# *
# * Description for chapters
#
chapter_description_t* {.bycopy.} = object
i_time_offset*: int64
i_duration*: int64
psz_name*: cstring
# *
# * Description for audio output. It contains
# * name, description and pointer to next record.
#
audio_output_t* {.bycopy.} = object
psz_name*: cstring
psz_description*: cstring
p_next*: ptr audio_output_t
# *
# * Description for audio output device.
#
audio_output_device_t* {.bycopy.} = object
p_next*: ptr audio_output_device_t
psz_device*: cstring
psz_description*: cstring
# *
# * Opaque equalizer handle.
# *
# * Equalizer settings can be applied to a media player.
#
equalizer_t* {.incompleteStruct.} = object
# *
# * Callback prototype to allocate and lock a picture buffer.
# *
# * Whenever a new video frame needs to be decoded, the lock callback is
# * invoked. Depending on the video chroma, one or three pixel planes of
# * adequate dimensions must be returned via the second parameter. Those
# * planes must be aligned on 32-bytes boundaries.
# *
# * \param opaque private pointer as passed to libvlc_video_set_callbacks() [IN]
# * \param planes start address of the pixel planes (LibVLC allocates the array
# * of void pointers, this callback must initialize the array) [OUT]
# * \return a private pointer for the display and unlock callbacks to identify
# * the picture buffers
#
video_lock_cb* = proc(opaque: pointer, planes: ptr pointer) {.cdecl.}
# *
# * Callback prototype to unlock a picture buffer.
# *
# * When the video frame decoding is complete, the unlock callback is invoked.
# * This callback might not be needed at all. It is only an indication that the
# * application can now read the pixel values if it needs to.
# *
# * \note A picture buffer is unlocked after the picture is decoded,
# * but before the picture is displayed.
# *
# * \param opaque private pointer as passed to libvlc_video_set_callbacks() [IN]
# * \param picture private pointer returned from the @ref libvlc_video_lock_cb
# * callback [IN]
# * \param planes pixel planes as defined by the @ref libvlc_video_lock_cb
# * callback (this parameter is only for convenience) [IN]
#
video_unlock_cb* = proc(opaque: pointer, picture: pointer, planes: ptr pointer) {.cdecl.}
# *
# * Callback prototype to display a picture.
# *
# * When the video frame needs to be shown, as determined by the media playback
# * clock, the display callback is invoked.
# *
# * \param opaque private pointer as passed to libvlc_video_set_callbacks() [IN]
# * \param picture private pointer returned from the @ref libvlc_video_lock_cb
# * callback [IN]
#
video_display_cb* = proc(opaque: pointer, picture: pointer) {.cdecl.}
# *
# * Callback prototype to configure picture buffers format.
# * This callback gets the format of the video as output by the video decoder
# * and the chain of video filters (if any). It can opt to change any parameter
# * as it needs. In that case, LibVLC will attempt to convert the video format
# * (rescaling and chroma conversion) but these operations can be CPU intensive.
# *
# * \param opaque pointer to the private pointer passed to
# * libvlc_video_set_callbacks() [IN/OUT]
# * \param chroma pointer to the 4 bytes video format identifier [IN/OUT]
# * \param width pointer to the buffer width in pixels[IN/OUT]
# * \param height pointer to the buffer height in pixels[IN/OUT]
# * \param pitches table of scanline pitches in bytes for each pixel plane
# * (the table is allocated by LibVLC) [OUT]
# * \param lines table of scanlines count for each plane [OUT]
# * \return the number of picture buffers allocated, 0 indicates failure
# *
# * \version LibVLC 4.0.0 and later.
# * \param (width+1) - pointer to display width in pixels[IN]
# * \param (height+1) - pointer to display height in pixels[IN]
# *
# * \note
# * For each pixels plane, the scanline pitch must be bigger than or equal to
# * the number of bytes per pixel multiplied by the pixel width.
# * Similarly, the number of scanlines must be bigger than of equal to
# * the pixel height.
# * Furthermore, we recommend that pitches and lines be multiple of 32
# * to not break assumptions that might be held by optimized code
# * in the video decoders, video filters and/or video converters.
#
video_format_cb* = proc(opaque: ptr pointer, chroma: cstring, width: ptr cuint, height: ptr cuint, pitches: ptr cuint, lines: ptr cuint): cuint {.cdecl.}
# *
# * Callback prototype to configure picture buffers format.
# *
# * \param opaque private pointer as passed to libvlc_video_set_format_callbacks()
# * (and possibly modified by @ref libvlc_video_format_cb) [IN]
#
video_cleanup_cb* = proc(opaque: pointer) {.cdecl.}
video_setup_device_cfg_t* {.bycopy.} = object
hardware_decoding*: bool
# Type 'libvlc_video_setup_device_info_t' skipped
# *
# * Callback prototype called to initialize user data.
# * Setup the rendering environment.
# *
# * \param opaque private pointer passed to the @a libvlc_video_set_output_callbacks()
# * on input. The callback can change this value on output to be
# * passed to all the other callbacks set on @a libvlc_video_set_output_callbacks().
# * [IN/OUT]
# * \param cfg requested configuration of the video device [IN]
# * \param out libvlc_video_setup_device_info_t* to fill [OUT]
# * \return true on success
# * \version LibVLC 4.0.0 or later
# *
# * For \ref libvlc_video_engine_d3d9 the output must be a IDirect3D9*.
# * A reference to this object is held until the \ref LIBVLC_VIDEO_DEVICE_CLEANUP is called.
# * the device must be created with D3DPRESENT_PARAMETERS.hDeviceWindow set to 0.
# *
# * For \ref libvlc_video_engine_d3d11 the output must be a ID3D11DeviceContext*.
# * A reference to this object is held until the \ref LIBVLC_VIDEO_DEVICE_CLEANUP is called.
# * The ID3D11Device used to create ID3D11DeviceContext must have multithreading enabled.
#
video_output_setup_cb* = proc(opaque: ptr pointer, cfg: ptr video_setup_device_cfg_t, `out`: ptr video_setup_device_info_t): bool {.cdecl.}
# *
# * Callback prototype called to release user data
# *
# * \param opaque private pointer set on the opaque parameter of @a libvlc_video_output_setup_cb() [IN]
# * \version LibVLC 4.0.0 or later
#
video_output_cleanup_cb* = proc(opaque: pointer) {.cdecl.}
video_render_cfg_t* {.bycopy.} = object
width*: cuint
height*: cuint
bitdepth*: cuint
full_range*: bool
colorspace*: video_color_space_t
primaries*: video_color_primaries_t
transfer*: video_transfer_func_t
device*: pointer
# Type 'libvlc_video_color_space_t' skipped
# Type 'libvlc_video_color_primaries_t' skipped
# Type 'libvlc_video_transfer_func_t' skipped
# Type 'libvlc_video_output_cfg_t' skipped
# *
# * Callback prototype called on video size changes.
# * Update the rendering output setup.
# *
# * \param opaque private pointer set on the opaque parameter of @a libvlc_video_output_setup_cb() [IN]
# * \param cfg configuration of the video that will be rendered [IN]
# * \param output configuration describing with how the rendering is setup [OUT]
# * \version LibVLC 4.0.0 or later
# *
# * \note the configuration device for Direct3D9 is the IDirect3DDevice9 that VLC
# * uses to render. The host must set a Render target and call Present()
# * when it needs the drawing from VLC to be done. This object is not valid
# * anymore after Cleanup is called.
# *
# * Tone mapping, range and color conversion will be done depending on the values
# * set in the output structure.
#
video_update_output_cb* = proc(opaque: pointer, cfg: ptr video_render_cfg_t, output: ptr video_output_cfg_t): bool {.cdecl.}
# *
# * Callback prototype called after performing drawing calls.
# *
# * \param opaque private pointer set on the opaque parameter of @a libvlc_video_output_setup_cb() [IN]
# * \version LibVLC 4.0.0 or later
#
video_swap_cb* = proc(opaque: pointer) {.cdecl.}
# *
# * Callback prototype to set up the OpenGL context for rendering.
# * Tell the host the rendering is about to start/has finished.
# *
# * \param opaque private pointer set on the opaque parameter of @a libvlc_video_output_setup_cb() [IN]
# * \param enter true to set the context as current, false to unset it [IN]
# * \return true on success
# * \version LibVLC 4.0.0 or later
# *
# * On Direct3D11 the following may change on the provided ID3D11DeviceContext*
# * between \ref enter being true and \ref enter being false:
# * - IASetPrimitiveTopology()
# * - IASetInputLayout()
# * - IASetVertexBuffers()
# * - IASetIndexBuffer()
# * - VSSetConstantBuffers()
# * - VSSetShader()
# * - PSSetSamplers()
# * - PSSetConstantBuffers()
# * - PSSetShaderResources()
# * - PSSetShader()
# * - RSSetViewports()
# * - DrawIndexed()
#
video_makeCurrent_cb* = proc(opaque: pointer, enter: bool): bool {.cdecl.}
# *
# * Callback prototype to load opengl functions
# *
# * \param opaque private pointer set on the opaque parameter of @a libvlc_video_output_setup_cb() [IN]
# * \param fct_name name of the opengl function to load
# * \return a pointer to the named OpenGL function the NULL otherwise
# * \version LibVLC 4.0.0 or later
#
video_getProcAddress_cb* = proc(opaque: pointer, fct_name: cstring) {.cdecl.}
video_frame_hdr10_metadata_t* {.bycopy.} = object
RedPrimary*: array[2, uint16]
GreenPrimary*: array[2, uint16]
BluePrimary*: array[2, uint16]
WhitePoint*: array[2, uint16]
MaxMasteringLuminance*: cuint
MinMasteringLuminance*: cuint
MaxContentLightLevel*: uint16
MaxFrameAverageLightLevel*: uint16
# *
# * Callback prototype to receive metadata before rendering.
# *
# * \param opaque private pointer passed to the @a libvlc_video_set_output_callbacks() [IN]
# * \param type type of data passed in metadata [IN]
# * \param metadata the type of metadata [IN]
# * \version LibVLC 4.0.0 or later
#
video_frameMetadata_cb* = proc(opaque: pointer, `type`: video_metadata_type_t, metadata: pointer) {.cdecl.}
# * Set the callback to call when the host app resizes the rendering area.
# *
# * This allows text rendering and aspect ratio to be handled properly when the host
# * rendering size changes.
# *
# * It may be called before the \ref libvlc_video_output_setup_cb callback.
# *
# * \param opaque private pointer set on the opaque parameter of @a libvlc_video_output_setup_cb() [IN]
# * \param report_size_change callback which must be called when the host size changes. [IN]
# * The callback is valid until another call to \ref libvlc_video_output_set_resize_cb
# * is done. This may be called from any thread.
# * \param report_opaque private pointer to pass to the \ref report_size_change callback. [IN]
#
# Type 'libvlc_video_output_set_resize_cb' skipped
# Type 'libvlc_video_output_set_resize_cb' skipped
# * Tell the host the rendering for the given plane is about to start
# *
# * \param opaque private pointer set on the opaque parameter of @a libvlc_video_output_setup_cb() [IN]
# * \param plane number of the rendering plane to select
# * \return true on success
# * \version LibVLC 4.0.0 or later
# *
# * \note This is only used with \ref libvlc_video_engine_d3d11.
# *
# * The host should call OMSetRenderTargets for Direct3D11. If this callback is
# * not used (set to NULL in @a libvlc_video_set_output_callbacks()) OMSetRenderTargets
# * has to be set during the @a libvlc_video_makeCurrent_cb()
# * entering call.
# *
# * The number of planes depend on the DXGI_FORMAT returned during the
# * \ref LIBVLC_VIDEO_UPDATE_OUTPUT call. It's usually one plane except for
# * semi-planar formats like DXGI_FORMAT_NV12 or DXGI_FORMAT_P010.
#
video_output_select_plane_cb* = proc(opaque: pointer, plane: uint): bool {.cdecl.}
# *
# * Callback prototype for audio playback.
# *
# * The LibVLC media player decodes and post-processes the audio signal
# * asynchronously (in an internal thread). Whenever audio samples are ready
# * to be queued to the output, this callback is invoked.
# *
# * The number of samples provided per invocation may depend on the file format,
# * the audio coding algorithm, the decoder plug-in, the post-processing
# * filters and timing. Application must not assume a certain number of samples.
# *
# * The exact format of audio samples is determined by libvlc_audio_set_format()
# * or libvlc_audio_set_format_callbacks() as is the channels layout.
# *
# * Note that the number of samples is per channel. For instance, if the audio
# * track sampling rate is 48000 Hz, then 1200 samples represent 25 milliseconds
# * of audio signal - regardless of the number of audio channels.
# *
# * \param data data pointer as passed to libvlc_audio_set_callbacks() [IN]
# * \param samples pointer to a table of audio samples to play back [IN]
# * \param count number of audio samples to play back
# * \param pts expected play time stamp (see libvlc_delay())
#
audio_play_cb* = proc(data: pointer, samples: pointer, count: cuint, pts: int64) {.cdecl.}
# *
# * Callback prototype for audio pause.
# *
# * LibVLC invokes this callback to pause audio playback.
# *
# * \note The pause callback is never called if the audio is already paused.
# * \param data data pointer as passed to libvlc_audio_set_callbacks() [IN]
# * \param pts time stamp of the pause request (should be elapsed already)
#
audio_pause_cb* = proc(data: pointer, pts: int64) {.cdecl.}
# *
# * Callback prototype for audio resumption.
# *
# * LibVLC invokes this callback to resume audio playback after it was
# * previously paused.
# *
# * \note The resume callback is never called if the audio is not paused.
# * \param data data pointer as passed to libvlc_audio_set_callbacks() [IN]
# * \param pts time stamp of the resumption request (should be elapsed already)
#
audio_resume_cb* = proc(data: pointer, pts: int64) {.cdecl.}
# *
# * Callback prototype for audio buffer flush.
# *
# * LibVLC invokes this callback if it needs to discard all pending buffers and
# * stop playback as soon as possible. This typically occurs when the media is
# * stopped.
# *
# * \param data data pointer as passed to libvlc_audio_set_callbacks() [IN]
#
audio_flush_cb* = proc(data: pointer, pts: int64) {.cdecl.}
# *
# * Callback prototype for audio buffer drain.
# *
# * LibVLC may invoke this callback when the decoded audio track is ending.
# * There will be no further decoded samples for the track, but playback should
# * nevertheless continue until all already pending buffers are rendered.
# *
# * \param data data pointer as passed to libvlc_audio_set_callbacks() [IN]
#
audio_drain_cb* = proc(data: pointer) {.cdecl.}
# *
# * Callback prototype for audio volume change.
# * \param data data pointer as passed to libvlc_audio_set_callbacks() [IN]
# * \param volume software volume (1. = nominal, 0. = mute)
# * \param mute muted flag
#
audio_set_volume_cb* = proc(data: pointer, volume: cfloat, mute: bool) {.cdecl.}
# *
# * Callback prototype to setup the audio playback.
# *
# * This is called when the media player needs to create a new audio output.
# * \param opaque pointer to the data pointer passed to
# * libvlc_audio_set_callbacks() [IN/OUT]
# * \param format 4 bytes sample format [IN/OUT]
# * \param rate sample rate [IN/OUT]
# * \param channels channels count [IN/OUT]
# * \return 0 on success, anything else to skip audio playback
#
audio_setup_cb* = proc(opaque: ptr pointer, format: cstring, rate: ptr cuint, channels: ptr cuint): cint {.cdecl.}
# *
# * Callback prototype for audio playback cleanup.
# *
# * This is called when the media player no longer needs an audio output.
# * \param opaque data pointer as passed to libvlc_audio_set_callbacks() [IN]
#
audio_cleanup_cb* = proc(data: pointer) {.cdecl.}
# *
# * Media player roles.
# *
# * \version LibVLC 3.0.0 and later.
# *
# * See \ref libvlc_media_player_set_role()
#
# Type 'libvlc_media_player_role' skipped
# Type 'libvlc_media_player_role' skipped
# Type 'libvlc_media_player_role_t' skipped
# * \defgroup libvlc_media_list LibVLC media list
# * \ingroup libvlc
# * A LibVLC media list holds multiple @ref libvlc_media_t media descriptors.
# * @{
# * \file
# * LibVLC media list (playlist) external API
#
media_list_t* {.incompleteStruct.} = object
# * \defgroup libvlc_media_list_player LibVLC media list player
# * \ingroup libvlc
# * The LibVLC media list player plays a @ref libvlc_media_list_t list of media,
# * in a certain order.
# * This is required to especially support playlist files.
# * The normal @ref libvlc_media_player_t LibVLC media player can only play a
# * single media, and does not handle playlist files properly.
# * @{
# * \file
# * LibVLC media list player external API
#
media_list_player_t* {.incompleteStruct.} = object
# *
# * Media discoverer description
# * \see libvlc_media_discoverer_list_get()
#
media_discoverer_description_t* {.bycopy.} = object
psz_name*: cstring
psz_longname*: cstring
i_cat*: media_discoverer_category_t
# * \defgroup libvlc_media_discoverer LibVLC media discovery
# * \ingroup libvlc
# * LibVLC media discovery finds available media via various means.
# * This corresponds to the service discovery functionality in VLC media player.
# * Different plugins find potential medias locally (e.g. user media directory),
# * from peripherals (e.g. video capture device), on the local network
# * (e.g. SAP) or on the Internet (e.g. Internet radios).
# * @{
# * \file
# * LibVLC media discovery external API
#
media_discoverer_t* {.incompleteStruct.} = object
# *
# * A LibVLC event
#
# Type 'libvlc_event_t' skipped
# Type 'libvlc_event_t' skipped
# Type 'libvlc_meta_t' skipped
# Type 'libvlc_media_t' skipped
# Type 'libvlc_media_t' skipped
# Type 'libvlc_picture_t' skipped
# Type 'libvlc_media_t' skipped
# Type 'libvlc_time_t' skipped
# Type 'libvlc_media_t' skipped
# Type 'libvlc_media_t' skipped
# Type 'libvlc_media_t' skipped
# Type 'libvlc_media_t' skipped
# Type 'libvlc_media_t' skipped
# Type 'libvlc_time_t' skipped
# Type 'libvlc_media_t' skipped
# Type 'libvlc_track_type_t' skipped
# Type 'libvlc_renderer_item_t' skipped
# Type 'libvlc_renderer_item_t' skipped
# Type 'libvlc_event_t' skipped
dialog_id* {.incompleteStruct.} = object
# *
# * Dialog callbacks to be implemented
#
dialog_cbs* {.bycopy.} = object
pf_display_error*: proc(p_data: pointer, psz_title: cstring, psz_text: cstring) {.cdecl.}
pf_display_login*: proc(p_data: pointer, p_id: ptr dialog_id, psz_title: cstring, psz_text: cstring, psz_default_username: cstring, b_ask_store: bool) {.cdecl.}
pf_display_question*: proc(p_data: pointer, p_id: ptr dialog_id, psz_title: cstring, psz_text: cstring, i_type: dialog_question_type, psz_cancel: cstring, psz_action1: cstring, psz_action2: cstring) {.cdecl.}
pf_display_progress*: proc(p_data: pointer, p_id: ptr dialog_id, psz_title: cstring, psz_text: cstring, b_indeterminate: bool, f_position: cfloat, psz_cancel: cstring) {.cdecl.}
pf_cancel*: proc(p_data: pointer, p_id: ptr dialog_id) {.cdecl.}
pf_update_progress*: proc(p_data: pointer, p_id: ptr dialog_id, f_position: cfloat, psz_text: cstring) {.cdecl.}
# * \defgroup libvlc_error LibVLC error handling
# * @{
#
# *
# * A human-readable error message for the last LibVLC error in the calling
# * thread. The resulting string is valid until another error occurs (at least
# * until the next LibVLC call).
# *
# * @warning
# * This will be NULL if there was no error.
#
proc errmsg*(): cstring {.importc: "libvlc_errmsg", cdecl, dynlib: dynvlc.}
# *
# * Clears the LibVLC error status for the current thread. This is optional.
# * By default, the error status is automatically overridden when a new error
# * occurs, and destroyed when the thread exits.
#
proc clearerr*() {.importc: "libvlc_clearerr", cdecl, dynlib: dynvlc.}
# *
# * Sets the LibVLC error status and message for the current thread.
# * Any previous error is overridden.
# * \param fmt the format string
# * \param ap the arguments
# * \return a nul terminated string in any case
#
proc vprinterr*(fmt: cstring, ap: va_list): cstring {.importc: "libvlc_vprinterr", cdecl, dynlib: dynvlc.}
# *
# * Sets the LibVLC error status and message for the current thread.
# * Any previous error is overridden.
# * \param fmt the format string
# * \param args the arguments
# * \return a nul terminated string in any case
#
proc printerr*(fmt: cstring): cstring {.importc: "libvlc_printerr", cdecl, dynlib: dynvlc.}
# *@}
# *
# * Create and initialize a libvlc instance.
# * This functions accept a list of "command line" arguments similar to the
# * main(). These arguments affect the LibVLC instance default configuration.
# *
# * \note
# * LibVLC may create threads. Therefore, any thread-unsafe process
# * initialization must be performed before calling libvlc_new(). In particular
# * and where applicable:
# * - setlocale() and textdomain(),
# * - setenv(), unsetenv() and putenv(),
# * - with the X11 display system, XInitThreads()
# * (see also libvlc_media_player_set_xwindow()) and
# * - on Microsoft Windows, SetErrorMode().
# * - sigprocmask() shall never be invoked; pthread_sigmask() can be used.
# *
# * On POSIX systems, the SIGCHLD signal <b>must not</b> be ignored, i.e. the
# * signal handler must set to SIG_DFL or a function pointer, not SIG_IGN.
# * Also while LibVLC is active, the wait() function shall not be called, and
# * any call to waitpid() shall use a strictly positive value for the first
# * parameter (i.e. the PID). Failure to follow those rules may lead to a
# * deadlock or a busy loop.
# * Also on POSIX systems, it is recommended that the SIGPIPE signal be blocked,
# * even if it is not, in principles, necessary, e.g.:
# * @code
# sigset_t set;
# signal(SIGCHLD, SIG_DFL);
# sigemptyset(&set);
# sigaddset(&set, SIGPIPE);
# pthread_sigmask(SIG_BLOCK, &set, NULL);
# * @endcode
# *
# * On Microsoft Windows, setting the default DLL directories to SYSTEM32
# * exclusively is strongly recommended for security reasons:
# * @code
# SetDefaultDllDirectories(LOAD_LIBRARY_SEARCH_SYSTEM32);
# * @endcode
# *
# * \version
# * Arguments are meant to be passed from the command line to LibVLC, just like
# * VLC media player does. The list of valid arguments depends on the LibVLC
# * version, the operating system and platform, and set of available LibVLC
# * plugins. Invalid or unsupported arguments will cause the function to fail
# * (i.e. return NULL). Also, some arguments may alter the behaviour or
# * otherwise interfere with other LibVLC functions.
# *
# * \warning
# * There is absolutely no warranty or promise of forward, backward and
# * cross-platform compatibility with regards to libvlc_new() arguments.
# * We recommend that you do not use them, other than when debugging.
# *
# * \param argc the number of arguments (should be 0)
# * \param argv list of arguments (should be NULL)
# * \return the libvlc instance or NULL in case of error
#
proc new*(argc: cint, argv: ptr cstring): ptr instance_t {.importc: "libvlc_new", cdecl, dynlib: dynvlc.}
# *
# * Decrement the reference count of a libvlc instance, and destroy it
# * if it reaches zero.
# *
# * \param p_instance the instance to destroy
#
proc release*(p_instance: ptr instance_t) {.importc: "libvlc_release", cdecl, dynlib: dynvlc.}
# *
# * Increments the reference count of a libvlc instance.
# * The initial reference count is 1 after libvlc_new() returns.
# *
# * \param p_instance the instance to reference
#
proc retain*(p_instance: ptr instance_t) {.importc: "libvlc_retain", cdecl, dynlib: dynvlc.}
# *
# * Try to start a user interface for the libvlc instance.
# *
# * \param p_instance the instance
# * \param name interface name, or NULL for default
# * \return 0 on success, -1 on error.
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_add_intf' skipped
# Declaration 'p_instance' skipped
# Declaration 'name' skipped
# *
# * Registers a callback for the LibVLC exit event. This is mostly useful if
# * the VLC playlist and/or at least one interface are started with
# * libvlc_playlist_play() or libvlc_add_intf() respectively.
# * Typically, this function will wake up your application main loop (from
# * another thread).
# *
# * \note This function should be called before the playlist or interface are
# * started. Otherwise, there is a small race condition: the exit event could
# * be raised before the handler is registered.
# *
# * \param p_instance LibVLC instance
# * \param cb callback to invoke when LibVLC wants to exit,
# * or NULL to disable the exit handler (as by default)
# * \param opaque data pointer for the callback
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_set_exit_handler' skipped
# Declaration 'p_instance' skipped
# Declaration 'cb' skipped
# Declaration 'opaque' skipped
# *
# * Sets the application name. LibVLC passes this as the user agent string
# * when a protocol requires it.
# *
# * \param p_instance LibVLC instance
# * \param name human-readable application name, e.g. "FooBar player 1.2.3"
# * \param http HTTP User Agent, e.g. "FooBar/1.2.3 Python/2.6.0"
# * \version LibVLC 1.1.1 or later
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_set_user_agent' skipped
# Declaration 'p_instance' skipped
# Declaration 'name' skipped
# Declaration 'http' skipped
# *
# * Sets some meta-information about the application.
# * See also libvlc_set_user_agent().
# *
# * \param p_instance LibVLC instance
# * \param id Java-style application identifier, e.g. "com.acme.foobar"
# * \param version application version numbers, e.g. "1.2.3"
# * \param icon application icon name, e.g. "foobar"
# * \version LibVLC 2.1.0 or later.
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_set_app_id' skipped
# Declaration 'p_instance' skipped
# Declaration 'id' skipped
# Declaration 'version' skipped
# Declaration 'icon' skipped
# *
# * Retrieve libvlc version.
# *
# * Example: "1.1.0-git The Luggage"
# *
# * \return a string containing the libvlc version
#
proc get_version*(): cstring {.importc: "libvlc_get_version", cdecl, dynlib: dynvlc.}
# *
# * Retrieve libvlc compiler version.
# *
# * Example: "gcc version 4.2.3 (Ubuntu 4.2.3-2ubuntu6)"
# *
# * \return a string containing the libvlc compiler version
#
proc get_compiler*(): cstring {.importc: "libvlc_get_compiler", cdecl, dynlib: dynvlc.}
# *
# * Retrieve libvlc changeset.
# *
# * Example: "aa9bce0bc4"
# *
# * \return a string containing the libvlc changeset
#
proc get_changeset*(): cstring {.importc: "libvlc_get_changeset", cdecl, dynlib: dynvlc.}
# *
# * Frees an heap allocation returned by a LibVLC function.
# * If you know you're using the same underlying C run-time as the LibVLC
# * implementation, then you can call ANSI C free() directly instead.
# *
# * \param ptr the pointer
#
proc free*(`ptr`: pointer) {.importc: "libvlc_free", cdecl, dynlib: dynvlc.}
# *
# * Register for an event notification.
# *
# * \param p_event_manager the event manager to which you want to attach to.
# * Generally it is obtained by vlc_my_object_event_manager() where
# * my_object is the object you want to listen to.
# * \param i_event_type the desired event to which we want to listen
# * \param f_callback the function to call when i_event_type occurs
# * \param user_data user provided data to carry with the event
# * \return 0 on success, ENOMEM on error
#
proc event_attach*(p_event_manager: ptr event_manager_t, i_event_type: event_type_t, f_callback: callback_t, user_data: pointer): cint {.importc: "libvlc_event_attach", cdecl, dynlib: dynvlc.}
# *
# * Unregister an event notification.
# *
# * \param p_event_manager the event manager
# * \param i_event_type the desired event to which we want to unregister
# * \param f_callback the function to call when i_event_type occurs
# * \param p_user_data user provided data to carry with the event
#
proc event_detach*(p_event_manager: ptr event_manager_t, i_event_type: event_type_t, f_callback: callback_t, p_user_data: pointer) {.importc: "libvlc_event_detach", cdecl, dynlib: dynvlc.}
# *
# * Gets log message debug infos.
# *
# * This function retrieves self-debug information about a log message:
# * - the name of the VLC module emitting the message,
# * - the name of the source code module (i.e. file) and
# * - the line number within the source code module.
# *
# * The returned module name and file name will be NULL if unknown.
# * The returned line number will similarly be zero if unknown.
# *
# * \param ctx message context (as passed to the @ref libvlc_log_cb callback)
# * \param module module name storage (or NULL) [OUT]
# * \param file source code file name storage (or NULL) [OUT]
# * \param line source code file line number storage (or NULL) [OUT]
# * \warning The returned module name and source code file name, if non-NULL,
# * are only valid until the logging callback returns.
# *
# * \version LibVLC 2.1.0 or later
#
proc log_get_context*(ctx: ptr log_t, module: ptr cstring, file: ptr cstring, line: ptr cuint) {.importc: "libvlc_log_get_context", cdecl, dynlib: dynvlc.}
# *
# * Gets log message info.
# *
# * This function retrieves meta-information about a log message:
# * - the type name of the VLC object emitting the message,
# * - the object header if any, and
# * - a temporaly-unique object identifier.
# *
# * This information is mainly meant for <b>manual</b> troubleshooting.
# *
# * The returned type name may be "generic" if unknown, but it cannot be NULL.
# * The returned header will be NULL if unset; in current versions, the header
# * is used to distinguish for VLM inputs.
# * The returned object ID will be zero if the message is not associated with
# * any VLC object.
# *
# * \param ctx message context (as passed to the @ref libvlc_log_cb callback)
# * \param name object name storage (or NULL) [OUT]
# * \param header object header (or NULL) [OUT]
# * \param line source code file line number storage (or NULL) [OUT]
# * \warning The returned module name and source code file name, if non-NULL,
# * are only valid until the logging callback returns.
# *
# * \version LibVLC 2.1.0 or later
#
proc log_get_object*(ctx: ptr log_t, name: ptr cstring, header: ptr cstring, id: ptr ptr uint) {.importc: "libvlc_log_get_object", cdecl, dynlib: dynvlc.}
# *
# * Unsets the logging callback.
# *
# * This function deregisters the logging callback for a LibVLC instance.
# * This is rarely needed as the callback is implicitly unset when the instance
# * is destroyed.
# *
# * \note This function will wait for any pending callbacks invocation to
# * complete (causing a deadlock if called from within the callback).
# *
# * \param p_instance libvlc instance
# * \version LibVLC 2.1.0 or later
#
proc log_unset*(p_instance: ptr instance_t) {.importc: "libvlc_log_unset", cdecl, dynlib: dynvlc.}
# *
# * Sets the logging callback for a LibVLC instance.
# *
# * This function is thread-safe: it will wait for any pending callbacks
# * invocation to complete.
# *
# * \param cb callback function pointer
# * \param data opaque data pointer for the callback function
# *
# * \note Some log messages (especially debug) are emitted by LibVLC while
# * is being initialized. These messages cannot be captured with this interface.
# *
# * \warning A deadlock may occur if this function is called from the callback.
# *
# * \param p_instance libvlc instance
# * \version LibVLC 2.1.0 or later
#
proc log_set*(p_instance: ptr instance_t, cb: log_cb, data: pointer) {.importc: "libvlc_log_set", cdecl, dynlib: dynvlc.}
# *
# * Sets up logging to a file.
# * \param p_instance libvlc instance
# * \param stream FILE pointer opened for writing
# * (the FILE pointer must remain valid until libvlc_log_unset())
# * \version LibVLC 2.1.0 or later
#
proc log_set_file*(p_instance: ptr instance_t, stream: ptr FILE) {.importc: "libvlc_log_set_file", cdecl, dynlib: dynvlc.}
# *
# * Release a list of module descriptions.
# *
# * \param p_list the list to be released
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_module_description_list_release' skipped
# Declaration 'p_list' skipped
# *
# * Returns a list of audio filters that are available.
# *
# * \param p_instance libvlc instance
# *
# * \return a list of module descriptions. It should be freed with libvlc_module_description_list_release().
# * In case of an error, NULL is returned.
# *
# * \see libvlc_module_description_t
# * \see libvlc_module_description_list_release
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_audio_filter_list_get' skipped
# Declaration 'p_instance' skipped
# *
# * Returns a list of video filters that are available.
# *
# * \param p_instance libvlc instance
# *
# * \return a list of module descriptions. It should be freed with libvlc_module_description_list_release().
# * In case of an error, NULL is returned.
# *
# * \see libvlc_module_description_t
# * \see libvlc_module_description_list_release
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_video_filter_list_get' skipped
# Declaration 'p_instance' skipped
# * @}
# * \defgroup libvlc_clock LibVLC time
# * These functions provide access to the LibVLC time/clock.
# * @{
#
# *
# * Return the current time as defined by LibVLC. The unit is the microsecond.
# * Time increases monotonically (regardless of time zone changes and RTC
# * adjustements).
# * The origin is arbitrary but consistent across the whole system
# * (e.g. the system uptim, the time since the system was booted).
# * \note On systems that support it, the POSIX monotonic clock is used.
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_clock' skipped
# *
# * Return the delay (in microseconds) until a certain timestamp.
# * \param pts timestamp
# * \return negative if timestamp is in the past,
# * positive if it is in the future
#
proc delay*(pts: int64): int64 {.importc: "libvlc_delay", cdecl, dynlib: dynvlc.}
# *
# * Hold a renderer item, i.e. creates a new reference
# *
# * This functions need to called from the libvlc_RendererDiscovererItemAdded
# * callback if the libvlc user wants to use this item after. (for display or
# * for passing it to the mediaplayer for example).
# *
# * \version LibVLC 3.0.0 or later
# *
# * \return the current item
#
proc renderer_item_hold*(p_item: ptr renderer_item_t): ptr renderer_item_t {.importc: "libvlc_renderer_item_hold", cdecl, dynlib: dynvlc.}
# *
# * Releases a renderer item, i.e. decrements its reference counter
# *
# * \version LibVLC 3.0.0 or later
#
proc renderer_item_release*(p_item: ptr renderer_item_t) {.importc: "libvlc_renderer_item_release", cdecl, dynlib: dynvlc.}
# *
# * Get the human readable name of a renderer item
# *
# * \version LibVLC 3.0.0 or later
# *
# * \return the name of the item (can't be NULL, must *not* be freed)
#
proc renderer_item_name*(p_item: ptr renderer_item_t): cstring {.importc: "libvlc_renderer_item_name", cdecl, dynlib: dynvlc.}
# *
# * Get the type (not translated) of a renderer item. For now, the type can only
# * be "chromecast" ("upnp", "airplay" may come later).
# *
# * \version LibVLC 3.0.0 or later
# *
# * \return the type of the item (can't be NULL, must *not* be freed)
#
proc renderer_item_type*(p_item: ptr renderer_item_t): cstring {.importc: "libvlc_renderer_item_type", cdecl, dynlib: dynvlc.}
# *
# * Get the icon uri of a renderer item
# *
# * \version LibVLC 3.0.0 or later
# *
# * \return the uri of the item's icon (can be NULL, must *not* be freed)
#
proc renderer_item_icon_uri*(p_item: ptr renderer_item_t): cstring {.importc: "libvlc_renderer_item_icon_uri", cdecl, dynlib: dynvlc.}
# *
# * Get the flags of a renderer item
# *
# * \see LIBVLC_RENDERER_CAN_AUDIO
# * \see LIBVLC_RENDERER_CAN_VIDEO
# *
# * \version LibVLC 3.0.0 or later
# *
# * \return bitwise flag: capabilities of the renderer, see
#
proc renderer_item_flags*(p_item: ptr renderer_item_t): cint {.importc: "libvlc_renderer_item_flags", cdecl, dynlib: dynvlc.}
# *
# * Create a renderer discoverer object by name
# *
# * After this object is created, you should attach to events in order to be
# * notified of the discoverer events.
# *
# * You need to call libvlc_renderer_discoverer_start() in order to start the
# * discovery.
# *
# * \see libvlc_renderer_discoverer_event_manager()
# * \see libvlc_renderer_discoverer_start()
# *
# * \version LibVLC 3.0.0 or later
# *
# * \param p_inst libvlc instance
# * \param psz_name service name; use libvlc_renderer_discoverer_list_get() to
# * get a list of the discoverer names available in this libVLC instance
# * \return media discover object or NULL in case of error
#
proc renderer_discoverer_new*(p_inst: ptr instance_t, psz_name: cstring): ptr renderer_discoverer_t {.importc: "libvlc_renderer_discoverer_new", cdecl, dynlib: dynvlc.}
# *
# * Release a renderer discoverer object
# *
# * \version LibVLC 3.0.0 or later
# *
# * \param p_rd renderer discoverer object
#
proc renderer_discoverer_release*(p_rd: ptr renderer_discoverer_t) {.importc: "libvlc_renderer_discoverer_release", cdecl, dynlib: dynvlc.}
# *
# * Start renderer discovery
# *
# * To stop it, call libvlc_renderer_discoverer_stop() or
# * libvlc_renderer_discoverer_release() directly.
# *
# * \see libvlc_renderer_discoverer_stop()
# *
# * \version LibVLC 3.0.0 or later
# *
# * \param p_rd renderer discoverer object
# * \return -1 in case of error, 0 otherwise
#
proc renderer_discoverer_start*(p_rd: ptr renderer_discoverer_t): cint {.importc: "libvlc_renderer_discoverer_start", cdecl, dynlib: dynvlc.}
# *
# * Stop renderer discovery.
# *
# * \see libvlc_renderer_discoverer_start()
# *
# * \version LibVLC 3.0.0 or later
# *
# * \param p_rd renderer discoverer object
#
proc renderer_discoverer_stop*(p_rd: ptr renderer_discoverer_t) {.importc: "libvlc_renderer_discoverer_stop", cdecl, dynlib: dynvlc.}
# *
# * Get the event manager of the renderer discoverer
# *
# * The possible events to attach are @ref libvlc_RendererDiscovererItemAdded
# * and @ref libvlc_RendererDiscovererItemDeleted.
# *
# * The @ref libvlc_renderer_item_t struct passed to event callbacks is owned by
# * VLC, users should take care of holding/releasing this struct for their
# * internal usage.
# *
# * \see libvlc_event_t.u.renderer_discoverer_item_added.item
# * \see libvlc_event_t.u.renderer_discoverer_item_removed.item
# *
# * \version LibVLC 3.0.0 or later
# *
# * \return a valid event manager (can't fail)
#
proc renderer_discoverer_event_manager*(p_rd: ptr renderer_discoverer_t): ptr event_manager_t {.importc: "libvlc_renderer_discoverer_event_manager", cdecl, dynlib: dynvlc.}
# *
# * Get media discoverer services
# *
# * \see libvlc_renderer_list_release()
# *
# * \version LibVLC 3.0.0 and later
# *
# * \param p_inst libvlc instance
# * \param ppp_services address to store an allocated array of renderer
# * discoverer services (must be freed with libvlc_renderer_list_release() by
# * the caller) [OUT]
# *
# * \return the number of media discoverer services (0 on error)
#
# Declaration 'libvlc_renderer_discoverer_list_get' skipped
# Declaration 'p_inst' skipped
# Declaration 'libvlc_renderer_discoverer_list_get' skipped
# Declaration 'p_inst' skipped
# Declaration 'ppp_services' skipped
# *
# * Release an array of media discoverer services
# *
# * \see libvlc_renderer_discoverer_list_get()
# *
# * \version LibVLC 3.0.0 and later
# *
# * \param pp_services array to release
# * \param i_count number of elements in the array
#
proc renderer_discoverer_list_release*(pp_services: ptr ptr rd_description_t, i_count: uint) {.importc: "libvlc_renderer_discoverer_list_release", cdecl, dynlib: dynvlc.}
# *
# * Increment the reference count of this picture.
# *
# * \see libvlc_picture_release()
# * \param pic A picture object
#
proc picture_retain*(pic: ptr picture_t) {.importc: "libvlc_picture_retain", cdecl, dynlib: dynvlc.}
# *
# * Decrement the reference count of this picture.
# * When the reference count reaches 0, the picture will be released.
# * The picture must not be accessed after calling this function.
# *
# * \see libvlc_picture_retain
# * \param pic A picture object
#
proc picture_release*(pic: ptr picture_t) {.importc: "libvlc_picture_release", cdecl, dynlib: dynvlc.}
# *
# * Saves this picture to a file. The image format is the same as the one
# * returned by \link libvlc_picture_type \endlink
# *
# * \param pic A picture object
# * \param path The path to the generated file
# * \return 0 in case of success, -1 otherwise
#
proc picture_save*(pic: ptr picture_t, path: cstring): cint {.importc: "libvlc_picture_save", cdecl, dynlib: dynvlc.}
# *
# * Returns the image internal buffer, including potential padding.
# * The libvlc_picture_t owns the returned buffer, which must not be modified nor
# * freed.
# *
# * \param pic A picture object
# * \param size A pointer to a size_t that will hold the size of the buffer [required]
# * \return A pointer to the internal buffer.
#
proc picture_get_buffer*(pic: ptr picture_t, size: ptr uint): ptr cuchar {.importc: "libvlc_picture_get_buffer", cdecl, dynlib: dynvlc.}
# *
# * Returns the picture type
# *
# * \param pic A picture object
# * \see libvlc_picture_type_t
#
proc picture_type*(pic: ptr picture_t): picture_type_t {.importc: "libvlc_picture_type", cdecl, dynlib: dynvlc.}
# *
# * Returns the image stride, ie. the number of bytes per line.
# * This can only be called on images of type libvlc_picture_Argb
# *
# * \param pic A picture object
#
proc picture_get_stride*(pic: ptr picture_t): cuint {.importc: "libvlc_picture_get_stride", cdecl, dynlib: dynvlc.}
# *
# * Returns the width of the image in pixels
# *
# * \param pic A picture object
#
proc picture_get_width*(pic: ptr picture_t): cuint {.importc: "libvlc_picture_get_width", cdecl, dynlib: dynvlc.}
# *
# * Returns the height of the image in pixels
# *
# * \param pic A picture object
#
proc picture_get_height*(pic: ptr picture_t): cuint {.importc: "libvlc_picture_get_height", cdecl, dynlib: dynvlc.}
# *
# * Returns the time at which this picture was generated, in milliseconds
# * \param pic A picture object
#
proc picture_get_time*(pic: ptr picture_t): time_t {.importc: "libvlc_picture_get_time", cdecl, dynlib: dynvlc.}
# *
# * Create a media with a certain given media resource location,
# * for instance a valid URL.
# *
# * \note To refer to a local file with this function,
# * the file:... URI syntax <b>must</b> be used (see IETF RFC3986).
# * We recommend using libvlc_media_new_path() instead when dealing with
# * local files.
# *
# * \see libvlc_media_release
# *
# * \param p_instance the instance
# * \param psz_mrl the media location
# * \return the newly created media or NULL on error
#
proc media_new_location*(p_instance: ptr instance_t, psz_mrl: cstring): ptr media_t {.importc: "libvlc_media_new_location", cdecl, dynlib: dynvlc.}
# *
# * Create a media for a certain file path.
# *
# * \see libvlc_media_release
# *
# * \param p_instance the instance
# * \param path local filesystem path
# * \return the newly created media or NULL on error
#
proc media_new_path*(p_instance: ptr instance_t, path: cstring): ptr media_t {.importc: "libvlc_media_new_path", cdecl, dynlib: dynvlc.}
# *
# * Create a media for an already open file descriptor.
# * The file descriptor shall be open for reading (or reading and writing).
# *
# * Regular file descriptors, pipe read descriptors and character device
# * descriptors (including TTYs) are supported on all platforms.
# * Block device descriptors are supported where available.
# * Directory descriptors are supported on systems that provide fdopendir().
# * Sockets are supported on all platforms where they are file descriptors,
# * i.e. all except Windows.
# *
# * \note This library will <b>not</b> automatically close the file descriptor
# * under any circumstance. Nevertheless, a file descriptor can usually only be
# * rendered once in a media player. To render it a second time, the file
# * descriptor should probably be rewound to the beginning with lseek().
# *
# * \see libvlc_media_release
# *
# * \version LibVLC 1.1.5 and later.
# *
# * \param p_instance the instance
# * \param fd open file descriptor
# * \return the newly created media or NULL on error
#
proc media_new_fd*(p_instance: ptr instance_t, fd: cint): ptr media_t {.importc: "libvlc_media_new_fd", cdecl, dynlib: dynvlc.}
# *
# * Create a media with custom callbacks to read the data from.
# *
# * \param instance LibVLC instance
# * \param open_cb callback to open the custom bitstream input media
# * \param read_cb callback to read data (must not be NULL)
# * \param seek_cb callback to seek, or NULL if seeking is not supported
# * \param close_cb callback to close the media, or NULL if unnecessary
# * \param opaque data pointer for the open callback
# *
# * \return the newly created media or NULL on error
# *
# * \note If open_cb is NULL, the opaque pointer will be passed to read_cb,
# * seek_cb and close_cb, and the stream size will be treated as unknown.
# *
# * \note The callbacks may be called asynchronously (from another thread).
# * A single stream instance need not be reentrant. However the open_cb needs to
# * be reentrant if the media is used by multiple player instances.
# *
# * \warning The callbacks may be used until all or any player instances
# * that were supplied the media item are stopped.
# *
# * \see libvlc_media_release
# *
# * \version LibVLC 3.0.0 and later.
#
proc media_new_callbacks*(instance: ptr instance_t, open_cb: media_open_cb, read_cb: media_read_cb, seek_cb: media_seek_cb, close_cb: media_close_cb, opaque: pointer): ptr media_t {.importc: "libvlc_media_new_callbacks", cdecl, dynlib: dynvlc.}
# *
# * Create a media as an empty node with a given name.
# *
# * \see libvlc_media_release
# *
# * \param p_instance the instance
# * \param psz_name the name of the node
# * \return the new empty media or NULL on error
#
proc media_new_as_node*(p_instance: ptr instance_t, psz_name: cstring): ptr media_t {.importc: "libvlc_media_new_as_node", cdecl, dynlib: dynvlc.}
# *
# * Add an option to the media.
# *
# * This option will be used to determine how the media_player will
# * read the media. This allows to use VLC's advanced
# * reading/streaming options on a per-media basis.
# *
# * \note The options are listed in 'vlc --longhelp' from the command line,
# * e.g. "--sout-all". Keep in mind that available options and their semantics
# * vary across LibVLC versions and builds.
# * \warning Not all options affects libvlc_media_t objects:
# * Specifically, due to architectural issues most audio and video options,
# * such as text renderer options, have no effects on an individual media.
# * These options must be set through libvlc_new() instead.
# *
# * \param p_md the media descriptor
# * \param psz_options the options (as a string)
#
proc media_add_option*(p_md: ptr media_t, psz_options: cstring) {.importc: "libvlc_media_add_option", cdecl, dynlib: dynvlc.}
# *
# * Add an option to the media with configurable flags.
# *
# * This option will be used to determine how the media_player will
# * read the media. This allows to use VLC's advanced
# * reading/streaming options on a per-media basis.
# *
# * The options are detailed in vlc --longhelp, for instance
# * "--sout-all". Note that all options are not usable on medias:
# * specifically, due to architectural issues, video-related options
# * such as text renderer options cannot be set on a single media. They
# * must be set on the whole libvlc instance instead.
# *
# * \param p_md the media descriptor
# * \param psz_options the options (as a string)
# * \param i_flags the flags for this option
#
proc media_add_option_flag*(p_md: ptr media_t, psz_options: cstring, i_flags: cuint) {.importc: "libvlc_media_add_option_flag", cdecl, dynlib: dynvlc.}
# *
# * Retain a reference to a media descriptor object (libvlc_media_t). Use
# * libvlc_media_release() to decrement the reference count of a
# * media descriptor object.
# *
# * \param p_md the media descriptor
#
proc media_retain*(p_md: ptr media_t) {.importc: "libvlc_media_retain", cdecl, dynlib: dynvlc.}
# *
# * Decrement the reference count of a media descriptor object. If the
# * reference count is 0, then libvlc_media_release() will release the
# * media descriptor object. It will send out an libvlc_MediaFreed event
# * to all listeners. If the media descriptor object has been released it
# * should not be used again.
# *
# * \param p_md the media descriptor
#
proc media_release*(p_md: ptr media_t) {.importc: "libvlc_media_release", cdecl, dynlib: dynvlc.}
# *
# * Get the media resource locator (mrl) from a media descriptor object
# *
# * \param p_md a media descriptor object
# * \return string with mrl of media descriptor object
#
proc media_get_mrl*(p_md: ptr media_t): cstring {.importc: "libvlc_media_get_mrl", cdecl, dynlib: dynvlc.}
# *
# * Duplicate a media descriptor object.
# *
# * \param p_md a media descriptor object.
#
proc media_duplicate*(p_md: ptr media_t): ptr media_t {.importc: "libvlc_media_duplicate", cdecl, dynlib: dynvlc.}
# *
# * Read the meta of the media.
# *
# * Note, you need to call libvlc_media_parse_with_options() or play the media
# * at least once before calling this function.
# * If the media has not yet been parsed this will return NULL.
# *
# * \see libvlc_media_parse_with_options
# * \see libvlc_MediaMetaChanged
# *
# * \param p_md the media descriptor
# * \param e_meta the meta to read
# * \return the media's meta
#
proc media_get_meta*(p_md: ptr media_t, e_meta: meta_t): cstring {.importc: "libvlc_media_get_meta", cdecl, dynlib: dynvlc.}
# *
# * Set the meta of the media (this function will not save the meta, call
# * libvlc_media_save_meta in order to save the meta)
# *
# * \param p_md the media descriptor
# * \param e_meta the meta to write
# * \param psz_value the media's meta
#
proc media_set_meta*(p_md: ptr media_t, e_meta: meta_t, psz_value: cstring) {.importc: "libvlc_media_set_meta", cdecl, dynlib: dynvlc.}
# *
# * Save the meta previously set
# *
# * \param p_md the media desriptor
# * \return true if the write operation was successful
#
proc media_save_meta*(p_md: ptr media_t): cint {.importc: "libvlc_media_save_meta", cdecl, dynlib: dynvlc.}
# *
# * Get current state of media descriptor object. Possible media states are
# * libvlc_NothingSpecial=0, libvlc_Opening, libvlc_Playing, libvlc_Paused,
# * libvlc_Stopped, libvlc_Ended, libvlc_Error.
# *
# * \see libvlc_state_t
# * \param p_md a media descriptor object
# * \return state of media descriptor object
#
proc media_get_state*(p_md: ptr media_t): state_t {.importc: "libvlc_media_get_state", cdecl, dynlib: dynvlc.}
# *
# * Get the current statistics about the media
# * \param p_md: media descriptor object
# * \param p_stats: structure that contain the statistics about the media
# * (this structure must be allocated by the caller)
# * \retval true statistics are available
# * \retval false otherwise
#
proc media_get_stats*(p_md: ptr media_t, p_stats: ptr media_stats_t): bool {.importc: "libvlc_media_get_stats", cdecl, dynlib: dynvlc.}
# The following method uses libvlc_media_list_t, however, media_list usage is optionnal
# * and this is here for convenience
# *
# * Get subitems of media descriptor object. This will increment
# * the reference count of supplied media descriptor object. Use
# * libvlc_media_list_release() to decrement the reference counting.
# *
# * \param p_md media descriptor object
# * \return list of media descriptor subitems or NULL
#
proc media_subitems*(p_md: ptr media_t): ptr media_list_t {.importc: "libvlc_media_subitems", cdecl, dynlib: dynvlc.}
# *
# * Get event manager from media descriptor object.
# * NOTE: this function doesn't increment reference counting.
# *
# * \param p_md a media descriptor object
# * \return event manager object
#
proc media_event_manager*(p_md: ptr media_t): ptr event_manager_t {.importc: "libvlc_media_event_manager", cdecl, dynlib: dynvlc.}
# *
# * Get duration (in ms) of media descriptor object item.
# *
# * Note, you need to call libvlc_media_parse_with_options() or play the media
# * at least once before calling this function.
# * Not doing this will result in an undefined result.
# *
# * \see libvlc_media_parse_with_options
# *
# * \param p_md media descriptor object
# * \return duration of media item or -1 on error
#
proc media_get_duration*(p_md: ptr media_t): time_t {.importc: "libvlc_media_get_duration", cdecl, dynlib: dynvlc.}
# *
# * Parse the media asynchronously with options.
# *
# * This fetches (local or network) art, meta data and/or tracks information.
# *
# * To track when this is over you can listen to libvlc_MediaParsedChanged
# * event. However if this functions returns an error, you will not receive any
# * events.
# *
# * It uses a flag to specify parse options (see libvlc_media_parse_flag_t). All
# * these flags can be combined. By default, media is parsed if it's a local
# * file.
# *
# * \note Parsing can be aborted with libvlc_media_parse_stop().
# *
# * \see libvlc_MediaParsedChanged
# * \see libvlc_media_get_meta
# * \see libvlc_media_tracks_get
# * \see libvlc_media_get_parsed_status
# * \see libvlc_media_parse_flag_t
# *
# * \param p_md media descriptor object
# * \param parse_flag parse options:
# * \param timeout maximum time allowed to preparse the media. If -1, the
# * default "preparse-timeout" option will be used as a timeout. If 0, it will
# * wait indefinitely. If > 0, the timeout will be used (in milliseconds).
# * \return -1 in case of error, 0 otherwise
# * \version LibVLC 3.0.0 or later
#
proc media_parse_with_options*(p_md: ptr media_t, parse_flag: media_parse_flag_t, timeout: cint): cint {.importc: "libvlc_media_parse_with_options", cdecl, dynlib: dynvlc.}
# *
# * Stop the parsing of the media
# *
# * When the media parsing is stopped, the libvlc_MediaParsedChanged event will
# * be sent with the libvlc_media_parsed_status_timeout status.
# *
# * \see libvlc_media_parse_with_options
# *
# * \param p_md media descriptor object
# * \version LibVLC 3.0.0 or later
#
proc media_parse_stop*(p_md: ptr media_t) {.importc: "libvlc_media_parse_stop", cdecl, dynlib: dynvlc.}
# *
# * Get Parsed status for media descriptor object.
# *
# * \see libvlc_MediaParsedChanged
# * \see libvlc_media_parsed_status_t
# * \see libvlc_media_parse_with_options
# *
# * \param p_md media descriptor object
# * \return a value of the libvlc_media_parsed_status_t enum
# * \version LibVLC 3.0.0 or later
#
proc media_get_parsed_status*(p_md: ptr media_t): media_parsed_status_t {.importc: "libvlc_media_get_parsed_status", cdecl, dynlib: dynvlc.}
# *
# * Sets media descriptor's user_data. user_data is specialized data
# * accessed by the host application, VLC.framework uses it as a pointer to
# * an native object that references a libvlc_media_t pointer
# *
# * \param p_md media descriptor object
# * \param p_new_user_data pointer to user data
#
proc media_set_user_data*(p_md: ptr media_t, p_new_user_data: pointer) {.importc: "libvlc_media_set_user_data", cdecl, dynlib: dynvlc.}
# *
# * Get media descriptor's user_data. user_data is specialized data
# * accessed by the host application, VLC.framework uses it as a pointer to
# * an native object that references a libvlc_media_t pointer
# *
# * \see libvlc_media_set_user_data
# *
# * \param p_md media descriptor object
#
proc media_get_user_data*(p_md: ptr media_t): pointer {.importc: "libvlc_media_get_user_data", cdecl, dynlib: dynvlc.}
# *
# * Get media descriptor's elementary streams description
# *
# * Note, you need to call libvlc_media_parse_with_options() or play the media
# * at least once before calling this function.
# * Not doing this will result in an empty array.
# *
# * \version LibVLC 2.1.0 and later.
# * \see libvlc_media_parse_with_options
# *
# * \param p_md media descriptor object
# * \param tracks address to store an allocated array of Elementary Streams
# * descriptions (must be freed with libvlc_media_tracks_release
# by the caller) [OUT]
# *
# * \return the number of Elementary Streams (zero on error)
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_media_tracks_get' skipped
# Declaration 'p_md' skipped
# Declaration 'tracks' skipped
# *
# * Get codec description from media elementary stream
# *
# * Note, you need to call libvlc_media_parse_with_options() or play the media
# * at least once before calling this function.
# *
# * \version LibVLC 3.0.0 and later.
# *
# * \see libvlc_media_track_t
# * \see libvlc_media_parse_with_options
# *
# * \param i_type i_type from libvlc_media_track_t
# * \param i_codec i_codec or i_original_fourcc from libvlc_media_track_t
# *
# * \return codec description
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_media_get_codec_description' skipped
# Declaration 'i_type' skipped
# Declaration 'i_codec' skipped
# *
# * Release media descriptor's elementary streams description array
# *
# * \version LibVLC 2.1.0 and later.
# *
# * \param p_tracks tracks info array to release
# * \param i_count number of elements in the array
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_media_tracks_release' skipped
# Declaration 'p_tracks' skipped
# Declaration 'i_count' skipped
# *
# * Get the media type of the media descriptor object
# *
# * \version LibVLC 3.0.0 and later.
# *
# * \see libvlc_media_type_t
# *
# * \param p_md media descriptor object
# *
# * \return media type
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_media_get_type' skipped
# Declaration 'p_md' skipped
# *
# * \brief libvlc_media_get_thumbnail_by_time Start an asynchronous thumbnail generation
# *
# * If the request is successfuly queued, the libvlc_MediaThumbnailGenerated
# * is guaranteed to be emited.
# *
# * \param md media descriptor object
# * \param time The time at which the thumbnail should be generated
# * \param speed The seeking speed \sa{libvlc_thumbnailer_seek_speed_t}
# * \param width The thumbnail width
# * \param height the thumbnail height
# * \param picture_type The thumbnail picture type \sa{libvlc_picture_type_t}
# * \param timeout A timeout value in ms, or 0 to disable timeout
# *
# * \return A valid opaque request object, or NULL in case of failure.
# * It may be cancelled by libvlc_media_thumbnail_request_cancel().
# * It must be released by libvlc_media_thumbnail_request_destroy().
# *
# * \version libvlc 4.0 or later
# *
# * \see libvlc_picture_t
# * \see libvlc_picture_type_t
#
proc media_thumbnail_request_by_time*(md: ptr media_t, time: time_t, speed: thumbnailer_seek_speed_t, width: cuint, height: cuint, crop: bool, picture_type: picture_type_t, timeout: time_t): ptr media_thumbnail_request_t {.importc: "libvlc_media_thumbnail_request_by_time", cdecl, dynlib: dynvlc.}
# *
# * \brief libvlc_media_get_thumbnail_by_pos Start an asynchronous thumbnail generation
# *
# * If the request is successfuly queued, the libvlc_MediaThumbnailGenerated
# * is guaranteed to be emited.
# *
# * \param md media descriptor object
# * \param pos The position at which the thumbnail should be generated
# * \param speed The seeking speed \sa{libvlc_thumbnailer_seek_speed_t}
# * \param width The thumbnail width
# * \param height the thumbnail height
# * \param picture_type The thumbnail picture type \sa{libvlc_picture_type_t}
# * \param timeout A timeout value in ms, or 0 to disable timeout
# *
# * \return A valid opaque request object, or NULL in case of failure.
# * It may be cancelled by libvlc_media_thumbnail_request_cancel().
# * It must be released by libvlc_media_thumbnail_request_destroy().
# *
# * \version libvlc 4.0 or later
# *
# * \see libvlc_picture_t
# * \see libvlc_picture_type_t
#
proc media_thumbnail_request_by_pos*(md: ptr media_t, pos: cfloat, speed: thumbnailer_seek_speed_t, width: cuint, height: cuint, crop: bool, picture_type: picture_type_t, timeout: time_t): ptr media_thumbnail_request_t {.importc: "libvlc_media_thumbnail_request_by_pos", cdecl, dynlib: dynvlc.}
# *
# * @brief libvlc_media_thumbnail_cancel cancels a thumbnailing request
# * @param p_req An opaque thumbnail request object.
# *
# * Cancelling the request will still cause libvlc_MediaThumbnailGenerated event
# * to be emited, with a NULL libvlc_picture_t
# * If the request is cancelled after its completion, the behavior is undefined.
#
proc media_thumbnail_request_cancel*(p_req: ptr media_thumbnail_request_t) {.importc: "libvlc_media_thumbnail_request_cancel", cdecl, dynlib: dynvlc.}
# *
# * @brief libvlc_media_thumbnail_destroy destroys a thumbnail request
# * @param p_req An opaque thumbnail request object.
# *
# * If the request has not completed or hasn't been cancelled yet, the behavior
# * is undefined
#
proc media_thumbnail_request_destroy*(p_req: ptr media_thumbnail_request_t) {.importc: "libvlc_media_thumbnail_request_destroy", cdecl, dynlib: dynvlc.}
# *
# * Add a slave to the current media.
# *
# * A slave is an external input source that may contains an additional subtitle
# * track (like a .srt) or an additional audio track (like a .ac3).
# *
# * \note This function must be called before the media is parsed (via
# * libvlc_media_parse_with_options()) or before the media is played (via
# * libvlc_media_player_play())
# *
# * \version LibVLC 3.0.0 and later.
# *
# * \param p_md media descriptor object
# * \param i_type subtitle or audio
# * \param i_priority from 0 (low priority) to 4 (high priority)
# * \param psz_uri Uri of the slave (should contain a valid scheme).
# *
# * \return 0 on success, -1 on error.
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_media_slaves_add' skipped
# Declaration 'p_md' skipped
# Declaration 'i_type' skipped
# Declaration 'i_priority' skipped
# Declaration 'psz_uri' skipped
# *
# * Clear all slaves previously added by libvlc_media_slaves_add() or
# * internally.
# *
# * \version LibVLC 3.0.0 and later.
# *
# * \param p_md media descriptor object
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_media_slaves_clear' skipped
# Declaration 'p_md' skipped
# *
# * Get a media descriptor's slave list
# *
# * The list will contain slaves parsed by VLC or previously added by
# * libvlc_media_slaves_add(). The typical use case of this function is to save
# * a list of slave in a database for a later use.
# *
# * \version LibVLC 3.0.0 and later.
# *
# * \see libvlc_media_slaves_add
# *
# * \param p_md media descriptor object
# * \param ppp_slaves address to store an allocated array of slaves (must be
# * freed with libvlc_media_slaves_release()) [OUT]
# *
# * \return the number of slaves (zero on error)
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_media_slaves_get' skipped
# Declaration 'p_md' skipped
# Declaration 'ppp_slaves' skipped
# *
# * Release a media descriptor's slave list
# *
# * \version LibVLC 3.0.0 and later.
# *
# * \param pp_slaves slave array to release
# * \param i_count number of elements in the array
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_media_slaves_release' skipped
# Declaration 'pp_slaves' skipped
# Declaration 'i_count' skipped
# *
# * Create an empty Media Player object
# *
# * \param p_libvlc_instance the libvlc instance in which the Media Player
# * should be created.
# * \return a new media player object, or NULL on error.
# * It must be released by libvlc_media_player_release().
#
proc media_player_new*(p_instance: ptr instance_t): ptr media_player_t {.importc: "libvlc_media_player_new", cdecl, dynlib: dynvlc.}
# *
# * Create a Media Player object from a Media
# *
# * \param p_md the media. Afterwards the p_md can be safely
# * destroyed.
# * \return a new media player object, or NULL on error.
# * It must be released by libvlc_media_player_release().
#
proc media_player_new_from_media*(p_md: ptr media_t): ptr media_player_t {.importc: "libvlc_media_player_new_from_media", cdecl, dynlib: dynvlc.}
# *
# * Release a media_player after use
# * Decrement the reference count of a media player object. If the
# * reference count is 0, then libvlc_media_player_release() will
# * release the media player object. If the media player object
# * has been released, then it should not be used again.
# *
# * \param p_mi the Media Player to free
#
proc media_player_release*(p_mi: ptr media_player_t) {.importc: "libvlc_media_player_release", cdecl, dynlib: dynvlc.}
# *
# * Retain a reference to a media player object. Use
# * libvlc_media_player_release() to decrement reference count.
# *
# * \param p_mi media player object
#
proc media_player_retain*(p_mi: ptr media_player_t) {.importc: "libvlc_media_player_retain", cdecl, dynlib: dynvlc.}
# *
# * Set the media that will be used by the media_player. If any,
# * previous md will be released.
# *
# * \param p_mi the Media Player
# * \param p_md the Media. Afterwards the p_md can be safely
# * destroyed.
#
proc media_player_set_media*(p_mi: ptr media_player_t, p_md: ptr media_t) {.importc: "libvlc_media_player_set_media", cdecl, dynlib: dynvlc.}
# *
# * Get the media used by the media_player.
# *
# * \param p_mi the Media Player
# * \return the media associated with p_mi, or NULL if no
# * media is associated
#
proc media_player_get_media*(p_mi: ptr media_player_t): ptr media_t {.importc: "libvlc_media_player_get_media", cdecl, dynlib: dynvlc.}
# *
# * Get the Event Manager from which the media player send event.
# *
# * \param p_mi the Media Player
# * \return the event manager associated with p_mi
#
proc media_player_event_manager*(p_mi: ptr media_player_t): ptr event_manager_t {.importc: "libvlc_media_player_event_manager", cdecl, dynlib: dynvlc.}
# *
# * is_playing
# *
# * \param p_mi the Media Player
# * \retval true media player is playing
# * \retval false media player is not playing
#
proc media_player_is_playing*(p_mi: ptr media_player_t): bool {.importc: "libvlc_media_player_is_playing", cdecl, dynlib: dynvlc.}
# *
# * Play
# *
# * \param p_mi the Media Player
# * \return 0 if playback started (and was already started), or -1 on error.
#
proc media_player_play*(p_mi: ptr media_player_t): cint {.importc: "libvlc_media_player_play", cdecl, dynlib: dynvlc.}
# *
# * Pause or resume (no effect if there is no media)
# *
# * \param mp the Media Player
# * \param do_pause play/resume if zero, pause if non-zero
# * \version LibVLC 1.1.1 or later
#
proc media_player_set_pause*(mp: ptr media_player_t, do_pause: cint) {.importc: "libvlc_media_player_set_pause", cdecl, dynlib: dynvlc.}
# *
# * Toggle pause (no effect if there is no media)
# *
# * \param p_mi the Media Player
#
proc media_player_pause*(p_mi: ptr media_player_t) {.importc: "libvlc_media_player_pause", cdecl, dynlib: dynvlc.}
# *
# * Stop asynchronously
# *
# * \note This function is asynchronous. In case of success, the user should
# * wait for the libvlc_MediaPlayerStopped event to know when the stop is
# * finished.
# *
# * \param p_mi the Media Player
# * \return 0 if the player is being stopped, -1 otherwise (no-op)
# * \version LibVLC 4.0.0 or later
#
proc media_player_stop_async*(p_mi: ptr media_player_t): cint {.importc: "libvlc_media_player_stop_async", cdecl, dynlib: dynvlc.}
# *
# * Set a renderer to the media player
# *
# * \note must be called before the first call of libvlc_media_player_play() to
# * take effect.
# *
# * \see libvlc_renderer_discoverer_new
# *
# * \param p_mi the Media Player
# * \param p_item an item discovered by libvlc_renderer_discoverer_start()
# * \return 0 on success, -1 on error.
# * \version LibVLC 3.0.0 or later
#
proc media_player_set_renderer*(p_mi: ptr media_player_t, p_item: ptr renderer_item_t): cint {.importc: "libvlc_media_player_set_renderer", cdecl, dynlib: dynvlc.}
# *
# * Set callbacks and private data to render decoded video to a custom area
# * in memory.
# * Use libvlc_video_set_format() or libvlc_video_set_format_callbacks()
# * to configure the decoded format.
# *
# * \warning Rendering video into custom memory buffers is considerably less
# * efficient than rendering in a custom window as normal.
# *
# * For optimal perfomances, VLC media player renders into a custom window, and
# * does not use this function and associated callbacks. It is <b>highly
# * recommended</b> that other LibVLC-based application do likewise.
# * To embed video in a window, use libvlc_media_player_set_xid() or equivalent
# * depending on the operating system.
# *
# * If window embedding does not fit the application use case, then a custom
# * LibVLC video output display plugin is required to maintain optimal video
# * rendering performances.
# *
# * The following limitations affect performance:
# * - Hardware video decoding acceleration will either be disabled completely,
# * or require (relatively slow) copy from video/DSP memory to main memory.
# * - Sub-pictures (subtitles, on-screen display, etc.) must be blent into the
# * main picture by the CPU instead of the GPU.
# * - Depending on the video format, pixel format conversion, picture scaling,
# * cropping and/or picture re-orientation, must be performed by the CPU
# * instead of the GPU.
# * - Memory copying is required between LibVLC reference picture buffers and
# * application buffers (between lock and unlock callbacks).
# *
# * \param mp the media player
# * \param lock callback to lock video memory (must not be NULL)
# * \param unlock callback to unlock video memory (or NULL if not needed)
# * \param display callback to display video (or NULL if not needed)
# * \param opaque private pointer for the three callbacks (as first parameter)
# * \version LibVLC 1.1.1 or later
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_video_set_callbacks' skipped
# Declaration 'mp' skipped
# Declaration 'lock' skipped
# Declaration 'unlock' skipped
# Declaration 'display' skipped
# Declaration 'opaque' skipped
# *
# * Set decoded video chroma and dimensions.
# * This only works in combination with libvlc_video_set_callbacks(),
# * and is mutually exclusive with libvlc_video_set_format_callbacks().
# *
# * \param mp the media player
# * \param chroma a four-characters string identifying the chroma
# * (e.g. "RV32" or "YUYV")
# * \param width pixel width
# * \param height pixel height
# * \param pitch line pitch (in bytes)
# * \version LibVLC 1.1.1 or later
# * \bug All pixel planes are expected to have the same pitch.
# * To use the YCbCr color space with chrominance subsampling,
# * consider using libvlc_video_set_format_callbacks() instead.
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_video_set_format' skipped
# Declaration 'mp' skipped
# Declaration 'chroma' skipped
# Declaration 'width' skipped
# Declaration 'height' skipped
# Declaration 'pitch' skipped
# *
# * Set decoded video chroma and dimensions. This only works in combination with
# * libvlc_video_set_callbacks().
# *
# * \param mp the media player
# * \param setup callback to select the video format (cannot be NULL)
# * \param cleanup callback to release any allocated resources (or NULL)
# * \version LibVLC 2.0.0 or later
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_video_set_format_callbacks' skipped
# Declaration 'mp' skipped
# Declaration 'setup' skipped
# Declaration 'cleanup' skipped
# *
# * Set callbacks and data to render decoded video to a custom texture
# *
# * \warning VLC will perform video rendering in its own thread and at its own rate,
# * You need to provide your own synchronisation mechanism.
# *
# * \param mp the media player
# * \param engine the GPU engine to use
# * \param setup_cb callback called to initialize user data
# * \param cleanup_cb callback called to clean up user data
# * \param resize_cb callback to set the resize callback
# * \param update_output_cb callback to get the rendering format of the host (cannot be NULL)
# * \param swap_cb callback called after rendering a video frame (cannot be NULL)
# * \param makeCurrent_cb callback called to enter/leave the rendering context (cannot be NULL)
# * \param getProcAddress_cb opengl function loading callback (cannot be NULL for \ref libvlc_video_engine_opengl and for \ref libvlc_video_engine_gles2)
# * \param metadata_cb callback to provide frame metadata (D3D11 only)
# * \param select_plane_cb callback to select different D3D11 rendering targets
# * \param opaque private pointer passed to callbacks
# *
# * \retval true engine selected and callbacks set
# * \retval false engine type unknown, callbacks not set
# * \version LibVLC 4.0.0 or later
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_video_set_output_callbacks' skipped
# Declaration 'mp' skipped
# Declaration 'engine' skipped
# Declaration 'setup_cb' skipped
# Declaration 'cleanup_cb' skipped
# Declaration 'resize_cb' skipped
# Declaration 'update_output_cb' skipped
# Declaration 'swap_cb' skipped
# Declaration 'makeCurrent_cb' skipped
# Declaration 'getProcAddress_cb' skipped
# Declaration 'metadata_cb' skipped
# Declaration 'select_plane_cb' skipped
# Declaration 'opaque' skipped
# *
# * Set the NSView handler where the media player should render its video output.
# *
# * Use the vout called "macosx".
# *
# * The drawable is an NSObject that follow the VLCVideoViewEmbedding
# * protocol:
# *
# * @code{.m}
# * @protocol VLCVideoViewEmbedding <NSObject>
# * - (void)addVoutSubview:(NSView *)view;
# * - (void)removeVoutSubview:(NSView *)view;
# * @end
# * @endcode
# *
# * Or it can be an NSView object.
# *
# * If you want to use it along with Qt see the QMacCocoaViewContainer. Then
# * the following code should work:
# * @code{.mm}
# * {
# * NSView *video = [[NSView alloc] init];
# * QMacCocoaViewContainer *container = new QMacCocoaViewContainer(video, parent);
# * libvlc_media_player_set_nsobject(mp, video);
# * [video release];
# * }
# * @endcode
# *
# * You can find a live example in VLCVideoView in VLCKit.framework.
# *
# * \param p_mi the Media Player
# * \param drawable the drawable that is either an NSView or an object following
# * the VLCVideoViewEmbedding protocol.
#
proc media_player_set_nsobject*(p_mi: ptr media_player_t, drawable: pointer) {.importc: "libvlc_media_player_set_nsobject", cdecl, dynlib: dynvlc.}
# *
# * Get the NSView handler previously set with libvlc_media_player_set_nsobject().
# *
# * \param p_mi the Media Player
# * \return the NSView handler or 0 if none where set
#
proc media_player_get_nsobject*(p_mi: ptr media_player_t): pointer {.importc: "libvlc_media_player_get_nsobject", cdecl, dynlib: dynvlc.}
# *
# * Set an X Window System drawable where the media player should render its
# * video output. The call takes effect when the playback starts. If it is
# * already started, it might need to be stopped before changes apply.
# * If LibVLC was built without X11 output support, then this function has no
# * effects.
# *
# * By default, LibVLC will capture input events on the video rendering area.
# * Use libvlc_video_set_mouse_input() and libvlc_video_set_key_input() to
# * disable that and deliver events to the parent window / to the application
# * instead. By design, the X11 protocol delivers input events to only one
# * recipient.
# *
# * \warning
# * The application must call the XInitThreads() function from Xlib before
# * libvlc_new(), and before any call to XOpenDisplay() directly or via any
# * other library. Failure to call XInitThreads() will seriously impede LibVLC
# * performance. Calling XOpenDisplay() before XInitThreads() will eventually
# * crash the process. That is a limitation of Xlib.
# *
# * \param p_mi media player
# * \param drawable X11 window ID
# *
# * \note
# * The specified identifier must correspond to an existing Input/Output class
# * X11 window. Pixmaps are <b>not</b> currently supported. The default X11
# * server is assumed, i.e. that specified in the DISPLAY environment variable.
# *
# * \warning
# * LibVLC can deal with invalid X11 handle errors, however some display drivers
# * (EGL, GLX, VA and/or VDPAU) can unfortunately not. Thus the window handle
# * must remain valid until playback is stopped, otherwise the process may
# * abort or crash.
# *
# * \bug
# * No more than one window handle per media player instance can be specified.
# * If the media has multiple simultaneously active video tracks, extra tracks
# * will be rendered into external windows beyond the control of the
# * application.
#
proc media_player_set_xwindow*(p_mi: ptr media_player_t, drawable: uint32) {.importc: "libvlc_media_player_set_xwindow", cdecl, dynlib: dynvlc.}
# *
# * Get the X Window System window identifier previously set with
# * libvlc_media_player_set_xwindow(). Note that this will return the identifier
# * even if VLC is not currently using it (for instance if it is playing an
# * audio-only input).
# *
# * \param p_mi the Media Player
# * \return an X window ID, or 0 if none where set.
#
proc media_player_get_xwindow*(p_mi: ptr media_player_t): uint32 {.importc: "libvlc_media_player_get_xwindow", cdecl, dynlib: dynvlc.}
# *
# * Set a Win32/Win64 API window handle (HWND) where the media player should
# * render its video output. If LibVLC was built without Win32/Win64 API output
# * support, then this has no effects.
# *
# * \param p_mi the Media Player
# * \param drawable windows handle of the drawable
#
proc media_player_set_hwnd*(p_mi: ptr media_player_t, drawable: pointer) {.importc: "libvlc_media_player_set_hwnd", cdecl, dynlib: dynvlc.}
# *
# * Get the Windows API window handle (HWND) previously set with
# * libvlc_media_player_set_hwnd(). The handle will be returned even if LibVLC
# * is not currently outputting any video to it.
# *
# * \param p_mi the Media Player
# * \return a window handle or NULL if there are none.
#
proc media_player_get_hwnd*(p_mi: ptr media_player_t): pointer {.importc: "libvlc_media_player_get_hwnd", cdecl, dynlib: dynvlc.}
# *
# * Set the android context.
# *
# * \version LibVLC 3.0.0 and later.
# *
# * \param p_mi the media player
# * \param p_awindow_handler org.videolan.libvlc.AWindow jobject owned by the
# * org.videolan.libvlc.MediaPlayer class from the libvlc-android project.
#
proc media_player_set_android_context*(p_mi: ptr media_player_t, p_awindow_handler: pointer) {.importc: "libvlc_media_player_set_android_context", cdecl, dynlib: dynvlc.}
# *
# * Sets callbacks and private data for decoded audio.
# *
# * Use libvlc_audio_set_format() or libvlc_audio_set_format_callbacks()
# * to configure the decoded audio format.
# *
# * \note The audio callbacks override any other audio output mechanism.
# * If the callbacks are set, LibVLC will <b>not</b> output audio in any way.
# *
# * \param mp the media player
# * \param play callback to play audio samples (must not be NULL)
# * \param pause callback to pause playback (or NULL to ignore)
# * \param resume callback to resume playback (or NULL to ignore)
# * \param flush callback to flush audio buffers (or NULL to ignore)
# * \param drain callback to drain audio buffers (or NULL to ignore)
# * \param opaque private pointer for the audio callbacks (as first parameter)
# * \version LibVLC 2.0.0 or later
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_audio_set_callbacks' skipped
# Declaration 'mp' skipped
# Declaration 'play' skipped
# Declaration 'pause' skipped
# Declaration 'resume' skipped
# Declaration 'flush' skipped
# Declaration 'drain' skipped
# Declaration 'opaque' skipped
# *
# * Set callbacks and private data for decoded audio. This only works in
# * combination with libvlc_audio_set_callbacks().
# * Use libvlc_audio_set_format() or libvlc_audio_set_format_callbacks()
# * to configure the decoded audio format.
# *
# * \param mp the media player
# * \param set_volume callback to apply audio volume,
# * or NULL to apply volume in software
# * \version LibVLC 2.0.0 or later
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_audio_set_volume_callback' skipped
# Declaration 'mp' skipped
# Declaration 'set_volume' skipped
# *
# * Sets decoded audio format via callbacks.
# *
# * This only works in combination with libvlc_audio_set_callbacks().
# *
# * \param mp the media player
# * \param setup callback to select the audio format (cannot be NULL)
# * \param cleanup callback to release any allocated resources (or NULL)
# * \version LibVLC 2.0.0 or later
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_audio_set_format_callbacks' skipped
# Declaration 'mp' skipped
# Declaration 'setup' skipped
# Declaration 'cleanup' skipped
# *
# * Sets a fixed decoded audio format.
# *
# * This only works in combination with libvlc_audio_set_callbacks(),
# * and is mutually exclusive with libvlc_audio_set_format_callbacks().
# *
# * \param mp the media player
# * \param format a four-characters string identifying the sample format
# * (e.g. "S16N" or "f32l")
# * \param rate sample rate (expressed in Hz)
# * \param channels channels count
# * \version LibVLC 2.0.0 or later
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_audio_set_format' skipped
# Declaration 'mp' skipped
# Declaration 'format' skipped
# Declaration 'rate' skipped
# Declaration 'channels' skipped
# * \bug This might go away ... to be replaced by a broader system
# *
# * Get the current movie length (in ms).
# *
# * \param p_mi the Media Player
# * \return the movie length (in ms), or -1 if there is no media.
#
proc media_player_get_length*(p_mi: ptr media_player_t): time_t {.importc: "libvlc_media_player_get_length", cdecl, dynlib: dynvlc.}
# *
# * Get the current movie time (in ms).
# *
# * \param p_mi the Media Player
# * \return the movie time (in ms), or -1 if there is no media.
#
proc media_player_get_time*(p_mi: ptr media_player_t): time_t {.importc: "libvlc_media_player_get_time", cdecl, dynlib: dynvlc.}
# *
# * Set the movie time (in ms). This has no effect if no media is being played.
# * Not all formats and protocols support this.
# *
# * \param p_mi the Media Player
# * \param b_fast prefer fast seeking or precise seeking
# * \param i_time the movie time (in ms).
# * \return 0 on success, -1 on error
#
proc media_player_set_time*(p_mi: ptr media_player_t, i_time: time_t, b_fast: bool): cint {.importc: "libvlc_media_player_set_time", cdecl, dynlib: dynvlc.}
# *
# * Get movie position as percentage between 0.0 and 1.0.
# *
# * \param p_mi the Media Player
# * \return movie position, or -1. in case of error
#
proc media_player_get_position*(p_mi: ptr media_player_t): cfloat {.importc: "libvlc_media_player_get_position", cdecl, dynlib: dynvlc.}
# *
# * Set movie position as percentage between 0.0 and 1.0.
# * This has no effect if playback is not enabled.
# * This might not work depending on the underlying input format and protocol.
# *
# * \param p_mi the Media Player
# * \param b_fast prefer fast seeking or precise seeking
# * \param f_pos the position
# * \return 0 on success, -1 on error
#
proc media_player_set_position*(p_mi: ptr media_player_t, f_pos: cfloat, b_fast: bool): cint {.importc: "libvlc_media_player_set_position", cdecl, dynlib: dynvlc.}
# *
# * Set movie chapter (if applicable).
# *
# * \param p_mi the Media Player
# * \param i_chapter chapter number to play
#
proc media_player_set_chapter*(p_mi: ptr media_player_t, i_chapter: cint) {.importc: "libvlc_media_player_set_chapter", cdecl, dynlib: dynvlc.}
# *
# * Get movie chapter.
# *
# * \param p_mi the Media Player
# * \return chapter number currently playing, or -1 if there is no media.
#
proc media_player_get_chapter*(p_mi: ptr media_player_t): cint {.importc: "libvlc_media_player_get_chapter", cdecl, dynlib: dynvlc.}
# *
# * Get movie chapter count
# *
# * \param p_mi the Media Player
# * \return number of chapters in movie, or -1.
#
proc media_player_get_chapter_count*(p_mi: ptr media_player_t): cint {.importc: "libvlc_media_player_get_chapter_count", cdecl, dynlib: dynvlc.}
# *
# * Get title chapter count
# *
# * \param p_mi the Media Player
# * \param i_title title
# * \return number of chapters in title, or -1
#
proc media_player_get_chapter_count_for_title*(p_mi: ptr media_player_t, i_title: cint): cint {.importc: "libvlc_media_player_get_chapter_count_for_title", cdecl, dynlib: dynvlc.}
# *
# * Set movie title
# *
# * \param p_mi the Media Player
# * \param i_title title number to play
#
proc media_player_set_title*(p_mi: ptr media_player_t, i_title: cint) {.importc: "libvlc_media_player_set_title", cdecl, dynlib: dynvlc.}
# *
# * Get movie title
# *
# * \param p_mi the Media Player
# * \return title number currently playing, or -1
#
proc media_player_get_title*(p_mi: ptr media_player_t): cint {.importc: "libvlc_media_player_get_title", cdecl, dynlib: dynvlc.}
# *
# * Get movie title count
# *
# * \param p_mi the Media Player
# * \return title number count, or -1
#
proc media_player_get_title_count*(p_mi: ptr media_player_t): cint {.importc: "libvlc_media_player_get_title_count", cdecl, dynlib: dynvlc.}
# *
# * Set previous chapter (if applicable)
# *
# * \param p_mi the Media Player
#
proc media_player_previous_chapter*(p_mi: ptr media_player_t) {.importc: "libvlc_media_player_previous_chapter", cdecl, dynlib: dynvlc.}
# *
# * Set next chapter (if applicable)
# *
# * \param p_mi the Media Player
#
proc media_player_next_chapter*(p_mi: ptr media_player_t) {.importc: "libvlc_media_player_next_chapter", cdecl, dynlib: dynvlc.}
# *
# * Get the requested movie play rate.
# * @warning Depending on the underlying media, the requested rate may be
# * different from the real playback rate.
# *
# * \param p_mi the Media Player
# * \return movie play rate
#
proc media_player_get_rate*(p_mi: ptr media_player_t): cfloat {.importc: "libvlc_media_player_get_rate", cdecl, dynlib: dynvlc.}
# *
# * Set movie play rate
# *
# * \param p_mi the Media Player
# * \param rate movie play rate to set
# * \return -1 if an error was detected, 0 otherwise (but even then, it might
# * not actually work depending on the underlying media protocol)
#
proc media_player_set_rate*(p_mi: ptr media_player_t, rate: cfloat): cint {.importc: "libvlc_media_player_set_rate", cdecl, dynlib: dynvlc.}
# *
# * Get current movie state
# *
# * \param p_mi the Media Player
# * \return the current state of the media player (playing, paused, ...) \see libvlc_state_t
#
proc media_player_get_state*(p_mi: ptr media_player_t): state_t {.importc: "libvlc_media_player_get_state", cdecl, dynlib: dynvlc.}
# *
# * How many video outputs does this media player have?
# *
# * \param p_mi the media player
# * \return the number of video outputs
#
proc media_player_has_vout*(p_mi: ptr media_player_t): cuint {.importc: "libvlc_media_player_has_vout", cdecl, dynlib: dynvlc.}
# *
# * Is this media player seekable?
# *
# * \param p_mi the media player
# * \retval true media player can seek
# * \retval false media player cannot seek
#
proc media_player_is_seekable*(p_mi: ptr media_player_t): bool {.importc: "libvlc_media_player_is_seekable", cdecl, dynlib: dynvlc.}
# *
# * Can this media player be paused?
# *
# * \param p_mi the media player
# * \retval true media player can be paused
# * \retval false media player cannot be paused
#
proc media_player_can_pause*(p_mi: ptr media_player_t): bool {.importc: "libvlc_media_player_can_pause", cdecl, dynlib: dynvlc.}
# *
# * Check if the current program is scrambled
# *
# * \param p_mi the media player
# * \retval true current program is scrambled
# * \retval false current program is not scrambled
# *
# * \version LibVLC 2.2.0 or later
#
proc media_player_program_scrambled*(p_mi: ptr media_player_t): bool {.importc: "libvlc_media_player_program_scrambled", cdecl, dynlib: dynvlc.}
# *
# * Display the next frame (if supported)
# *
# * \param p_mi the media player
#
proc media_player_next_frame*(p_mi: ptr media_player_t) {.importc: "libvlc_media_player_next_frame", cdecl, dynlib: dynvlc.}
# *
# * Navigate through DVD Menu
# *
# * \param p_mi the Media Player
# * \param navigate the Navigation mode
# * \version libVLC 2.0.0 or later
#
proc media_player_navigate*(p_mi: ptr media_player_t, navigate: cuint) {.importc: "libvlc_media_player_navigate", cdecl, dynlib: dynvlc.}
# *
# * Set if, and how, the video title will be shown when media is played.
# *
# * \param p_mi the media player
# * \param position position at which to display the title, or libvlc_position_disable to prevent the title from being displayed
# * \param timeout title display timeout in milliseconds (ignored if libvlc_position_disable)
# * \version libVLC 2.1.0 or later
#
proc media_player_set_video_title_display*(p_mi: ptr media_player_t, position: position_t, timeout: cuint) {.importc: "libvlc_media_player_set_video_title_display", cdecl, dynlib: dynvlc.}
# *
# * Add a slave to the current media player.
# *
# * \note If the player is playing, the slave will be added directly. This call
# * will also update the slave list of the attached libvlc_media_t.
# *
# * \version LibVLC 3.0.0 and later.
# *
# * \see libvlc_media_slaves_add
# *
# * \param p_mi the media player
# * \param i_type subtitle or audio
# * \param psz_uri Uri of the slave (should contain a valid scheme).
# * \param b_select True if this slave should be selected when it's loaded
# *
# * \return 0 on success, -1 on error.
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_media_player_add_slave' skipped
# Declaration 'p_mi' skipped
# Declaration 'i_type' skipped
# Declaration 'psz_uri' skipped
# Declaration 'b_select' skipped
# *
# * Release (free) libvlc_track_description_t
# *
# * \param p_track_description the structure to release
#
proc track_description_list_release*(p_track_description: ptr track_description_t) {.importc: "libvlc_track_description_list_release", cdecl, dynlib: dynvlc.}
# * \defgroup libvlc_video LibVLC video controls
# * @{
#
# *
# * Toggle fullscreen status on non-embedded video outputs.
# *
# * @warning The same limitations applies to this function
# * as to libvlc_set_fullscreen().
# *
# * \param p_mi the media player
#
proc toggle_fullscreen*(p_mi: ptr media_player_t) {.importc: "libvlc_toggle_fullscreen", cdecl, dynlib: dynvlc.}
# *
# * Enable or disable fullscreen.
# *
# * @warning With most window managers, only a top-level windows can be in
# * full-screen mode. Hence, this function will not operate properly if
# * libvlc_media_player_set_xwindow() was used to embed the video in a
# * non-top-level window. In that case, the embedding window must be reparented
# * to the root window <b>before</b> fullscreen mode is enabled. You will want
# * to reparent it back to its normal parent when disabling fullscreen.
# *
# * \note This setting applies to any and all current or future active video
# * tracks and windows for the given media player. The choice of fullscreen
# * output for each window is left to the operating system.
# *
# * \param p_mi the media player
# * \param b_fullscreen boolean for fullscreen status
#
proc set_fullscreen*(p_mi: ptr media_player_t, b_fullscreen: bool) {.importc: "libvlc_set_fullscreen", cdecl, dynlib: dynvlc.}
# *
# * Get current fullscreen status.
# *
# * \param p_mi the media player
# * \return the fullscreen status (boolean)
# *
# * \retval false media player is windowed
# * \retval true media player is in fullscreen mode
#
proc get_fullscreen*(p_mi: ptr media_player_t): bool {.importc: "libvlc_get_fullscreen", cdecl, dynlib: dynvlc.}
# *
# * Enable or disable key press events handling, according to the LibVLC hotkeys
# * configuration. By default and for historical reasons, keyboard events are
# * handled by the LibVLC video widget.
# *
# * \note On X11, there can be only one subscriber for key press and mouse
# * click events per window. If your application has subscribed to those events
# * for the X window ID of the video widget, then LibVLC will not be able to
# * handle key presses and mouse clicks in any case.
# *
# * \warning This function is only implemented for X11 and Win32 at the moment.
# *
# * \param p_mi the media player
# * \param on true to handle key press events, false to ignore them.
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_video_set_key_input' skipped
# Declaration 'p_mi' skipped
# Declaration 'on' skipped
# *
# * Enable or disable mouse click events handling. By default, those events are
# * handled. This is needed for DVD menus to work, as well as a few video
# * filters such as "puzzle".
# *
# * \see libvlc_video_set_key_input().
# *
# * \warning This function is only implemented for X11 and Win32 at the moment.
# *
# * \param p_mi the media player
# * \param on true to handle mouse click events, false to ignore them.
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_video_set_mouse_input' skipped
# Declaration 'p_mi' skipped
# Declaration 'on' skipped
# *
# * Get the pixel dimensions of a video.
# *
# * \param p_mi media player
# * \param num number of the video (starting from, and most commonly 0)
# * \param px pointer to get the pixel width [OUT]
# * \param py pointer to get the pixel height [OUT]
# * \return 0 on success, -1 if the specified video does not exist
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_video_get_size' skipped
# Declaration 'p_mi' skipped
# Declaration 'num' skipped
# Declaration 'px' skipped
# Declaration 'py' skipped
# *
# * Get the mouse pointer coordinates over a video.
# * Coordinates are expressed in terms of the decoded video resolution,
# * <b>not</b> in terms of pixels on the screen/viewport (to get the latter,
# * you can query your windowing system directly).
# *
# * Either of the coordinates may be negative or larger than the corresponding
# * dimension of the video, if the cursor is outside the rendering area.
# *
# * @warning The coordinates may be out-of-date if the pointer is not located
# * on the video rendering area. LibVLC does not track the pointer if it is
# * outside of the video widget.
# *
# * @note LibVLC does not support multiple pointers (it does of course support
# * multiple input devices sharing the same pointer) at the moment.
# *
# * \param p_mi media player
# * \param num number of the video (starting from, and most commonly 0)
# * \param px pointer to get the abscissa [OUT]
# * \param py pointer to get the ordinate [OUT]
# * \return 0 on success, -1 if the specified video does not exist
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_video_get_cursor' skipped
# Declaration 'p_mi' skipped
# Declaration 'num' skipped
# Declaration 'px' skipped
# Declaration 'py' skipped
# *
# * Get the current video scaling factor.
# * See also libvlc_video_set_scale().
# *
# * \param p_mi the media player
# * \return the currently configured zoom factor, or 0. if the video is set
# * to fit to the output window/drawable automatically.
#
proc video_get_scale*(p_mi: ptr media_player_t): cfloat {.importc: "libvlc_video_get_scale", cdecl, dynlib: dynvlc.}
# *
# * Set the video scaling factor. That is the ratio of the number of pixels on
# * screen to the number of pixels in the original decoded video in each
# * dimension. Zero is a special value; it will adjust the video to the output
# * window/drawable (in windowed mode) or the entire screen.
# *
# * Note that not all video outputs support scaling.
# *
# * \param p_mi the media player
# * \param f_factor the scaling factor, or zero
#
proc video_set_scale*(p_mi: ptr media_player_t, f_factor: cfloat) {.importc: "libvlc_video_set_scale", cdecl, dynlib: dynvlc.}
# *
# * Get current video aspect ratio.
# *
# * \param p_mi the media player
# * \return the video aspect ratio or NULL if unspecified
# * (the result must be released with free() or libvlc_free()).
#
proc video_get_aspect_ratio*(p_mi: ptr media_player_t): cstring {.importc: "libvlc_video_get_aspect_ratio", cdecl, dynlib: dynvlc.}
# *
# * Set new video aspect ratio.
# *
# * \param p_mi the media player
# * \param psz_aspect new video aspect-ratio or NULL to reset to default
# * \note Invalid aspect ratios are ignored.
#
proc video_set_aspect_ratio*(p_mi: ptr media_player_t, psz_aspect: cstring) {.importc: "libvlc_video_set_aspect_ratio", cdecl, dynlib: dynvlc.}
# *
# * Create a video viewpoint structure.
# *
# * \version LibVLC 3.0.0 and later
# *
# * \return video viewpoint or NULL
# * (the result must be released with free()).
#
proc video_new_viewpoint*(): ptr video_viewpoint_t {.importc: "libvlc_video_new_viewpoint", cdecl, dynlib: dynvlc.}
# *
# * Update the video viewpoint information.
# *
# * \note It is safe to call this function before the media player is started.
# *
# * \version LibVLC 3.0.0 and later
# *
# * \param p_mi the media player
# * \param p_viewpoint video viewpoint allocated via libvlc_video_new_viewpoint()
# * \param b_absolute if true replace the old viewpoint with the new one. If
# * false, increase/decrease it.
# * \return -1 in case of error, 0 otherwise
# *
# * \note the values are set asynchronously, it will be used by the next frame displayed.
#
proc video_update_viewpoint*(p_mi: ptr media_player_t, p_viewpoint: ptr video_viewpoint_t, b_absolute: bool): cint {.importc: "libvlc_video_update_viewpoint", cdecl, dynlib: dynvlc.}
# *
# * Get current video subtitle.
# *
# * \param p_mi the media player
# * \return the video subtitle selected, or -1 if none
#
proc video_get_spu*(p_mi: ptr media_player_t): cint {.importc: "libvlc_video_get_spu", cdecl, dynlib: dynvlc.}
# *
# * Get the number of available video subtitles.
# *
# * \param p_mi the media player
# * \return the number of available video subtitles
#
proc video_get_spu_count*(p_mi: ptr media_player_t): cint {.importc: "libvlc_video_get_spu_count", cdecl, dynlib: dynvlc.}
# *
# * Get the description of available video subtitles.
# *
# * \param p_mi the media player
# * \return list containing description of available video subtitles.
# * It must be freed with libvlc_track_description_list_release()
#
proc video_get_spu_description*(p_mi: ptr media_player_t): ptr track_description_t {.importc: "libvlc_video_get_spu_description", cdecl, dynlib: dynvlc.}
# *
# * Set new video subtitle.
# *
# * \param p_mi the media player
# * \param i_spu video subtitle track to select (i_id from track description)
# * \return 0 on success, -1 if out of range
#
proc video_set_spu*(p_mi: ptr media_player_t, i_spu: cint): cint {.importc: "libvlc_video_set_spu", cdecl, dynlib: dynvlc.}
# *
# * Get the current subtitle delay. Positive values means subtitles are being
# * displayed later, negative values earlier.
# *
# * \param p_mi media player
# * \return time (in microseconds) the display of subtitles is being delayed
# * \version LibVLC 2.0.0 or later
#
proc video_get_spu_delay*(p_mi: ptr media_player_t): int64 {.importc: "libvlc_video_get_spu_delay", cdecl, dynlib: dynvlc.}
# *
# * Set the subtitle delay. This affects the timing of when the subtitle will
# * be displayed. Positive values result in subtitles being displayed later,
# * while negative values will result in subtitles being displayed earlier.
# *
# * The subtitle delay will be reset to zero each time the media changes.
# *
# * \param p_mi media player
# * \param i_delay time (in microseconds) the display of subtitles should be delayed
# * \return 0 on success, -1 on error
# * \version LibVLC 2.0.0 or later
#
proc video_set_spu_delay*(p_mi: ptr media_player_t, i_delay: int64): cint {.importc: "libvlc_video_set_spu_delay", cdecl, dynlib: dynvlc.}
# *
# * Get the full description of available titles
# *
# * \version LibVLC 3.0.0 and later.
# *
# * \param p_mi the media player
# * \param titles address to store an allocated array of title descriptions
# * descriptions (must be freed with libvlc_title_descriptions_release()
# * by the caller) [OUT]
# *
# * \return the number of titles (-1 on error)
#
# Declaration 'libvlc_media_player_get_full_title_descriptions' skipped
# Declaration 'p_mi' skipped
# Declaration 'libvlc_media_player_get_full_title_descriptions' skipped
# Declaration 'p_mi' skipped
# Declaration 'titles' skipped
# *
# * Release a title description
# *
# * \version LibVLC 3.0.0 and later
# *
# * \param p_titles title description array to release
# * \param i_count number of title descriptions to release
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_title_descriptions_release' skipped
# Declaration 'p_titles' skipped
# Declaration 'i_count' skipped
# *
# * Get the full description of available chapters
# *
# * \version LibVLC 3.0.0 and later.
# *
# * \param p_mi the media player
# * \param i_chapters_of_title index of the title to query for chapters (uses current title if set to -1)
# * \param pp_chapters address to store an allocated array of chapter descriptions
# * descriptions (must be freed with libvlc_chapter_descriptions_release()
# * by the caller) [OUT]
# *
# * \return the number of chapters (-1 on error)
#
# Declaration 'libvlc_media_player_get_full_chapter_descriptions' skipped
# Declaration 'p_mi' skipped
# Declaration 'i_chapters_of_title' skipped
# Declaration 'libvlc_media_player_get_full_chapter_descriptions' skipped
# Declaration 'p_mi' skipped
# Declaration 'i_chapters_of_title' skipped
# Declaration 'pp_chapters' skipped
# *
# * Release a chapter description
# *
# * \version LibVLC 3.0.0 and later
# *
# * \param p_chapters chapter description array to release
# * \param i_count number of chapter descriptions to release
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_chapter_descriptions_release' skipped
# Declaration 'p_chapters' skipped
# Declaration 'i_count' skipped
# *
# * Set/unset the video crop ratio.
# *
# * This function forces a crop ratio on any and all video tracks rendered by
# * the media player. If the display aspect ratio of a video does not match the
# * crop ratio, either the top and bottom, or the left and right of the video
# * will be cut out to fit the crop ratio.
# *
# * For instance, a ratio of 1:1 will force the video to a square shape.
# *
# * To disable video crop, set a crop ratio with zero as denominator.
# *
# * A call to this function overrides any previous call to any of
# * libvlc_video_set_crop_ratio(), libvlc_video_set_crop_border() and/or
# * libvlc_video_set_crop_window().
# *
# * \see libvlc_video_set_aspect_ratio()
# *
# * \param mp the media player
# * \param num crop ratio numerator (ignored if denominator is 0)
# * \param den crop ratio denominator (or 0 to unset the crop ratio)
# *
# * \version LibVLC 4.0.0 and later
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_video_set_crop_ratio' skipped
# Declaration 'mp' skipped
# Declaration 'num' skipped
# Declaration 'den' skipped
# *
# * Set the video crop window.
# *
# * This function selects a sub-rectangle of video to show. Any pixels outside
# * the rectangle will not be shown.
# *
# * To unset the video crop window, use libvlc_video_set_crop_ratio() or
# * libvlc_video_set_crop_border().
# *
# * A call to this function overrides any previous call to any of
# * libvlc_video_set_crop_ratio(), libvlc_video_set_crop_border() and/or
# * libvlc_video_set_crop_window().
# *
# * \param mp the media player
# * \param x abscissa (i.e. leftmost sample column offset) of the crop window
# * \param y ordinate (i.e. topmost sample row offset) of the crop window
# * \param width sample width of the crop window (cannot be zero)
# * \param height sample height of the crop window (cannot be zero)
# *
# * \version LibVLC 4.0.0 and later
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_video_set_crop_window' skipped
# Declaration 'mp' skipped
# Declaration 'x' skipped
# Declaration 'y' skipped
# Declaration 'width' skipped
# Declaration 'height' skipped
# *
# * Set the video crop borders.
# *
# * This function selects the size of video edges to be cropped out.
# *
# * To unset the video crop borders, set all borders to zero.
# *
# * A call to this function overrides any previous call to any of
# * libvlc_video_set_crop_ratio(), libvlc_video_set_crop_border() and/or
# * libvlc_video_set_crop_window().
# *
# * \param mp the media player
# * \param left number of sample columns to crop on the left
# * \param right number of sample columns to crop on the right
# * \param top number of sample rows to crop on the top
# * \param bottom number of sample rows to corp on the bottom
# *
# * \version LibVLC 4.0.0 and later
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_video_set_crop_border' skipped
# Declaration 'mp' skipped
# Declaration 'left' skipped
# Declaration 'right' skipped
# Declaration 'top' skipped
# Declaration 'bottom' skipped
# *
# * Get current teletext page requested or 0 if it's disabled.
# *
# * Teletext is disabled by default, call libvlc_video_set_teletext() to enable
# * it.
# *
# * \param p_mi the media player
# * \return the current teletext page requested.
#
proc video_get_teletext*(p_mi: ptr media_player_t): cint {.importc: "libvlc_video_get_teletext", cdecl, dynlib: dynvlc.}
# *
# * Set new teletext page to retrieve.
# *
# * This function can also be used to send a teletext key.
# *
# * \param p_mi the media player
# * \param i_page teletex page number requested. This value can be 0 to disable
# * teletext, a number in the range ]0;1000[ to show the requested page, or a
# * \ref libvlc_teletext_key_t. 100 is the default teletext page.
#
proc video_set_teletext*(p_mi: ptr media_player_t, i_page: cint) {.importc: "libvlc_video_set_teletext", cdecl, dynlib: dynvlc.}
# *
# * Get number of available video tracks.
# *
# * \param p_mi media player
# * \return the number of available video tracks (int)
#
proc video_get_track_count*(p_mi: ptr media_player_t): cint {.importc: "libvlc_video_get_track_count", cdecl, dynlib: dynvlc.}
# *
# * Get the description of available video tracks.
# *
# * \param p_mi media player
# * \return list with description of available video tracks, or NULL on error.
# * It must be freed with libvlc_track_description_list_release()
#
proc video_get_track_description*(p_mi: ptr media_player_t): ptr track_description_t {.importc: "libvlc_video_get_track_description", cdecl, dynlib: dynvlc.}
# *
# * Get current video track.
# *
# * \param p_mi media player
# * \return the video track ID (int) or -1 if no active input
#
proc video_get_track*(p_mi: ptr media_player_t): cint {.importc: "libvlc_video_get_track", cdecl, dynlib: dynvlc.}
# *
# * Set video track.
# *
# * \param p_mi media player
# * \param i_track the track ID (i_id field from track description)
# * \return 0 on success, -1 if out of range
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_video_set_track' skipped
# Declaration 'p_mi' skipped
# Declaration 'i_track' skipped
# *
# * Take a snapshot of the current video window.
# *
# * If i_width AND i_height is 0, original size is used.
# * If i_width XOR i_height is 0, original aspect-ratio is preserved.
# *
# * \param p_mi media player instance
# * \param num number of video output (typically 0 for the first/only one)
# * \param psz_filepath the path of a file or a folder to save the screenshot into
# * \param i_width the snapshot's width
# * \param i_height the snapshot's height
# * \return 0 on success, -1 if the video was not found
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_video_take_snapshot' skipped
# Declaration 'p_mi' skipped
# Declaration 'num' skipped
# Declaration 'psz_filepath' skipped
# Declaration 'i_width' skipped
# Declaration 'i_height' skipped
# *
# * Enable or disable deinterlace filter
# *
# * \param p_mi libvlc media player
# * \param deinterlace state -1: auto (default), 0: disabled, 1: enabled
# * \param psz_mode type of deinterlace filter, NULL for current/default filter
# * \version LibVLC 4.0.0 and later
#
proc video_set_deinterlace*(p_mi: ptr media_player_t, deinterlace: cint, psz_mode: cstring) {.importc: "libvlc_video_set_deinterlace", cdecl, dynlib: dynvlc.}
# *
# * Get an integer marquee option value
# *
# * \param p_mi libvlc media player
# * \param option marq option to get \see libvlc_video_marquee_option_t
#
proc video_get_marquee_int*(p_mi: ptr media_player_t, option: cuint): cint {.importc: "libvlc_video_get_marquee_int", cdecl, dynlib: dynvlc.}
# *
# * Enable, disable or set an integer marquee option
# *
# * Setting libvlc_marquee_Enable has the side effect of enabling (arg !0)
# * or disabling (arg 0) the marq filter.
# *
# * \param p_mi libvlc media player
# * \param option marq option to set \see libvlc_video_marquee_option_t
# * \param i_val marq option value
#
proc video_set_marquee_int*(p_mi: ptr media_player_t, option: cuint, i_val: cint) {.importc: "libvlc_video_set_marquee_int", cdecl, dynlib: dynvlc.}
# *
# * Set a marquee string option
# *
# * \param p_mi libvlc media player
# * \param option marq option to set \see libvlc_video_marquee_option_t
# * \param psz_text marq option value
#
proc video_set_marquee_string*(p_mi: ptr media_player_t, option: cuint, psz_text: cstring) {.importc: "libvlc_video_set_marquee_string", cdecl, dynlib: dynvlc.}
# *
# * Get integer logo option.
# *
# * \param p_mi libvlc media player instance
# * \param option logo option to get, values of libvlc_video_logo_option_t
#
proc video_get_logo_int*(p_mi: ptr media_player_t, option: cuint): cint {.importc: "libvlc_video_get_logo_int", cdecl, dynlib: dynvlc.}
# *
# * Set logo option as integer. Options that take a different type value
# * are ignored.
# * Passing libvlc_logo_enable as option value has the side effect of
# * starting (arg !0) or stopping (arg 0) the logo filter.
# *
# * \param p_mi libvlc media player instance
# * \param option logo option to set, values of libvlc_video_logo_option_t
# * \param value logo option value
#
proc video_set_logo_int*(p_mi: ptr media_player_t, option: cuint, value: cint) {.importc: "libvlc_video_set_logo_int", cdecl, dynlib: dynvlc.}
# *
# * Set logo option as string. Options that take a different type value
# * are ignored.
# *
# * \param p_mi libvlc media player instance
# * \param option logo option to set, values of libvlc_video_logo_option_t
# * \param psz_value logo option value
#
proc video_set_logo_string*(p_mi: ptr media_player_t, option: cuint, psz_value: cstring) {.importc: "libvlc_video_set_logo_string", cdecl, dynlib: dynvlc.}
# *
# * Get integer adjust option.
# *
# * \param p_mi libvlc media player instance
# * \param option adjust option to get, values of libvlc_video_adjust_option_t
# * \version LibVLC 1.1.1 and later.
#
proc video_get_adjust_int*(p_mi: ptr media_player_t, option: cuint): cint {.importc: "libvlc_video_get_adjust_int", cdecl, dynlib: dynvlc.}
# *
# * Set adjust option as integer. Options that take a different type value
# * are ignored.
# * Passing libvlc_adjust_enable as option value has the side effect of
# * starting (arg !0) or stopping (arg 0) the adjust filter.
# *
# * \param p_mi libvlc media player instance
# * \param option adust option to set, values of libvlc_video_adjust_option_t
# * \param value adjust option value
# * \version LibVLC 1.1.1 and later.
#
proc video_set_adjust_int*(p_mi: ptr media_player_t, option: cuint, value: cint) {.importc: "libvlc_video_set_adjust_int", cdecl, dynlib: dynvlc.}
# *
# * Get float adjust option.
# *
# * \param p_mi libvlc media player instance
# * \param option adjust option to get, values of libvlc_video_adjust_option_t
# * \version LibVLC 1.1.1 and later.
#
proc video_get_adjust_float*(p_mi: ptr media_player_t, option: cuint): cfloat {.importc: "libvlc_video_get_adjust_float", cdecl, dynlib: dynvlc.}
# *
# * Set adjust option as float. Options that take a different type value
# * are ignored.
# *
# * \param p_mi libvlc media player instance
# * \param option adust option to set, values of libvlc_video_adjust_option_t
# * \param value adjust option value
# * \version LibVLC 1.1.1 and later.
#
proc video_set_adjust_float*(p_mi: ptr media_player_t, option: cuint, value: cfloat) {.importc: "libvlc_video_set_adjust_float", cdecl, dynlib: dynvlc.}
# *
# * Gets the list of available audio output modules.
# *
# * \param p_instance libvlc instance
# * \return list of available audio outputs. It must be freed with
# * \see libvlc_audio_output_list_release \see libvlc_audio_output_t .
# * In case of error, NULL is returned.
#
proc audio_output_list_get*(p_instance: ptr instance_t): ptr audio_output_t {.importc: "libvlc_audio_output_list_get", cdecl, dynlib: dynvlc.}
# *
# * Frees the list of available audio output modules.
# *
# * \param p_list list with audio outputs for release
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_audio_output_list_release' skipped
# Declaration 'p_list' skipped
# *
# * Selects an audio output module.
# * \note Any change will take be effect only after playback is stopped and
# * restarted. Audio output cannot be changed while playing.
# *
# * \param p_mi media player
# * \param psz_name name of audio output,
# * use psz_name of \see libvlc_audio_output_t
# * \return 0 if function succeeded, -1 on error
#
proc audio_output_set*(p_mi: ptr media_player_t, psz_name: cstring): cint {.importc: "libvlc_audio_output_set", cdecl, dynlib: dynvlc.}
# *
# * Gets a list of potential audio output devices,
# * \see libvlc_audio_output_device_set().
# *
# * \note Not all audio outputs support enumerating devices.
# * The audio output may be functional even if the list is empty (NULL).
# *
# * \note The list may not be exhaustive.
# *
# * \warning Some audio output devices in the list might not actually work in
# * some circumstances. By default, it is recommended to not specify any
# * explicit audio device.
# *
# * \param mp media player
# * \return A NULL-terminated linked list of potential audio output devices.
# * It must be freed with libvlc_audio_output_device_list_release()
# * \version LibVLC 2.2.0 or later.
#
proc audio_output_device_enum*(mp: ptr media_player_t): ptr audio_output_device_t {.importc: "libvlc_audio_output_device_enum", cdecl, dynlib: dynvlc.}
# *
# * Gets a list of audio output devices for a given audio output module,
# * \see libvlc_audio_output_device_set().
# *
# * \note Not all audio outputs support this. In particular, an empty (NULL)
# * list of devices does <b>not</b> imply that the specified audio output does
# * not work.
# *
# * \note The list might not be exhaustive.
# *
# * \warning Some audio output devices in the list might not actually work in
# * some circumstances. By default, it is recommended to not specify any
# * explicit audio device.
# *
# * \param p_instance libvlc instance
# * \param aout audio output name
# * (as returned by libvlc_audio_output_list_get())
# * \return A NULL-terminated linked list of potential audio output devices.
# * It must be freed with libvlc_audio_output_device_list_release()
# * \version LibVLC 2.1.0 or later.
#
proc audio_output_device_list_get*(p_instance: ptr instance_t, aout: cstring): ptr audio_output_device_t {.importc: "libvlc_audio_output_device_list_get", cdecl, dynlib: dynvlc.}
# *
# * Frees a list of available audio output devices.
# *
# * \param p_list list with audio outputs for release
# * \version LibVLC 2.1.0 or later.
#
proc audio_output_device_list_release*(p_list: ptr audio_output_device_t) {.importc: "libvlc_audio_output_device_list_release", cdecl, dynlib: dynvlc.}
# *
# * Configures an explicit audio output device.
# *
# * If the module paramater is NULL, audio output will be moved to the device
# * specified by the device identifier string immediately. This is the
# * recommended usage.
# *
# * A list of adequate potential device strings can be obtained with
# * libvlc_audio_output_device_enum().
# *
# * However passing NULL is supported in LibVLC version 2.2.0 and later only;
# * in earlier versions, this function would have no effects when the module
# * parameter was NULL.
# *
# * If the module parameter is not NULL, the device parameter of the
# * corresponding audio output, if it exists, will be set to the specified
# * string. Note that some audio output modules do not have such a parameter
# * (notably MMDevice and PulseAudio).
# *
# * A list of adequate potential device strings can be obtained with
# * libvlc_audio_output_device_list_get().
# *
# * \note This function does not select the specified audio output plugin.
# * libvlc_audio_output_set() is used for that purpose.
# *
# * \warning The syntax for the device parameter depends on the audio output.
# *
# * Some audio output modules require further parameters (e.g. a channels map
# * in the case of ALSA).
# *
# * \param mp media player
# * \param module If NULL, current audio output module.
# * if non-NULL, name of audio output module
# (\see libvlc_audio_output_t)
# * \param device_id device identifier string
# * \return Nothing. Errors are ignored (this is a design bug).
#
proc audio_output_device_set*(mp: ptr media_player_t, module: cstring, device_id: cstring) {.importc: "libvlc_audio_output_device_set", cdecl, dynlib: dynvlc.}
# *
# * Get the current audio output device identifier.
# *
# * This complements libvlc_audio_output_device_set().
# *
# * \warning The initial value for the current audio output device identifier
# * may not be set or may be some unknown value. A LibVLC application should
# * compare this value against the known device identifiers (e.g. those that
# * were previously retrieved by a call to libvlc_audio_output_device_enum or
# * libvlc_audio_output_device_list_get) to find the current audio output device.
# *
# * It is possible that the selected audio output device changes (an external
# * change) without a call to libvlc_audio_output_device_set. That may make this
# * method unsuitable to use if a LibVLC application is attempting to track
# * dynamic audio device changes as they happen.
# *
# * \param mp media player
# * \return the current audio output device identifier
# * NULL if no device is selected or in case of error
# * (the result must be released with free()).
# * \version LibVLC 3.0.0 or later.
#
proc audio_output_device_get*(mp: ptr media_player_t): cstring {.importc: "libvlc_audio_output_device_get", cdecl, dynlib: dynvlc.}
# *
# * Toggle mute status.
# *
# * \param p_mi media player
# * \warning Toggling mute atomically is not always possible: On some platforms,
# * other processes can mute the VLC audio playback stream asynchronously. Thus,
# * there is a small race condition where toggling will not work.
# * See also the limitations of libvlc_audio_set_mute().
#
proc audio_toggle_mute*(p_mi: ptr media_player_t) {.importc: "libvlc_audio_toggle_mute", cdecl, dynlib: dynvlc.}
# *
# * Get current mute status.
# *
# * \param p_mi media player
# * \return the mute status (boolean) if defined, -1 if undefined/unapplicable
#
proc audio_get_mute*(p_mi: ptr media_player_t): cint {.importc: "libvlc_audio_get_mute", cdecl, dynlib: dynvlc.}
# *
# * Set mute status.
# *
# * \param p_mi media player
# * \param status If status is true then mute, otherwise unmute
# * \warning This function does not always work. If there are no active audio
# * playback stream, the mute status might not be available. If digital
# * pass-through (S/PDIF, HDMI...) is in use, muting may be unapplicable. Also
# * some audio output plugins do not support muting at all.
# * \note To force silent playback, disable all audio tracks. This is more
# * efficient and reliable than mute.
#
proc audio_set_mute*(p_mi: ptr media_player_t, status: cint) {.importc: "libvlc_audio_set_mute", cdecl, dynlib: dynvlc.}
# *
# * Get current software audio volume.
# *
# * \param p_mi media player
# * \return the software volume in percents
# * (0 = mute, 100 = nominal / 0dB)
#
proc audio_get_volume*(p_mi: ptr media_player_t): cint {.importc: "libvlc_audio_get_volume", cdecl, dynlib: dynvlc.}
# *
# * Set current software audio volume.
# *
# * \param p_mi media player
# * \param i_volume the volume in percents (0 = mute, 100 = 0dB)
# * \return 0 if the volume was set, -1 if it was out of range
#
proc audio_set_volume*(p_mi: ptr media_player_t, i_volume: cint): cint {.importc: "libvlc_audio_set_volume", cdecl, dynlib: dynvlc.}
# *
# * Get number of available audio tracks.
# *
# * \param p_mi media player
# * \return the number of available audio tracks (int), or -1 if unavailable
#
proc audio_get_track_count*(p_mi: ptr media_player_t): cint {.importc: "libvlc_audio_get_track_count", cdecl, dynlib: dynvlc.}
# *
# * Get the description of available audio tracks.
# *
# * \param p_mi media player
# * \return list with description of available audio tracks, or NULL.
# * It must be freed with libvlc_track_description_list_release()
#
proc audio_get_track_description*(p_mi: ptr media_player_t): ptr track_description_t {.importc: "libvlc_audio_get_track_description", cdecl, dynlib: dynvlc.}
# *
# * Get current audio track.
# *
# * \param p_mi media player
# * \return the audio track ID or -1 if no active input.
#
proc audio_get_track*(p_mi: ptr media_player_t): cint {.importc: "libvlc_audio_get_track", cdecl, dynlib: dynvlc.}
# *
# * Set current audio track.
# *
# * \param p_mi media player
# * \param i_track the track ID (i_id field from track description)
# * \return 0 on success, -1 on error
#
proc audio_set_track*(p_mi: ptr media_player_t, i_track: cint): cint {.importc: "libvlc_audio_set_track", cdecl, dynlib: dynvlc.}
# *
# * Get current audio channel.
# *
# * \param p_mi media player
# * \return the audio channel \see libvlc_audio_output_channel_t
#
proc audio_get_channel*(p_mi: ptr media_player_t): cint {.importc: "libvlc_audio_get_channel", cdecl, dynlib: dynvlc.}
# *
# * Set current audio channel.
# *
# * \param p_mi media player
# * \param channel the audio channel, \see libvlc_audio_output_channel_t
# * \return 0 on success, -1 on error
#
proc audio_set_channel*(p_mi: ptr media_player_t, channel: cint): cint {.importc: "libvlc_audio_set_channel", cdecl, dynlib: dynvlc.}
# *
# * Get current audio delay.
# *
# * \param p_mi media player
# * \return the audio delay (microseconds)
# * \version LibVLC 1.1.1 or later
#
proc audio_get_delay*(p_mi: ptr media_player_t): int64 {.importc: "libvlc_audio_get_delay", cdecl, dynlib: dynvlc.}
# *
# * Set current audio delay. The audio delay will be reset to zero each time the media changes.
# *
# * \param p_mi media player
# * \param i_delay the audio delay (microseconds)
# * \return 0 on success, -1 on error
# * \version LibVLC 1.1.1 or later
#
proc audio_set_delay*(p_mi: ptr media_player_t, i_delay: int64): cint {.importc: "libvlc_audio_set_delay", cdecl, dynlib: dynvlc.}
# *
# * Get the number of equalizer presets.
# *
# * \return number of presets
# * \version LibVLC 2.2.0 or later
#
proc audio_equalizer_get_preset_count*(): cuint {.importc: "libvlc_audio_equalizer_get_preset_count", cdecl, dynlib: dynvlc.}
# *
# * Get the name of a particular equalizer preset.
# *
# * This name can be used, for example, to prepare a preset label or menu in a user
# * interface.
# *
# * \param u_index index of the preset, counting from zero
# * \return preset name, or NULL if there is no such preset
# * \version LibVLC 2.2.0 or later
#
proc audio_equalizer_get_preset_name*(u_index: cuint): cstring {.importc: "libvlc_audio_equalizer_get_preset_name", cdecl, dynlib: dynvlc.}
# *
# * Get the number of distinct frequency bands for an equalizer.
# *
# * \return number of frequency bands
# * \version LibVLC 2.2.0 or later
#
proc audio_equalizer_get_band_count*(): cuint {.importc: "libvlc_audio_equalizer_get_band_count", cdecl, dynlib: dynvlc.}
# *
# * Get a particular equalizer band frequency.
# *
# * This value can be used, for example, to create a label for an equalizer band control
# * in a user interface.
# *
# * \param u_index index of the band, counting from zero
# * \return equalizer band frequency (Hz), or -1 if there is no such band
# * \version LibVLC 2.2.0 or later
#
proc audio_equalizer_get_band_frequency*(u_index: cuint): cfloat {.importc: "libvlc_audio_equalizer_get_band_frequency", cdecl, dynlib: dynvlc.}
# *
# * Create a new default equalizer, with all frequency values zeroed.
# *
# * The new equalizer can subsequently be applied to a media player by invoking
# * libvlc_media_player_set_equalizer().
# *
# * The returned handle should be freed via libvlc_audio_equalizer_release() when
# * it is no longer needed.
# *
# * \return opaque equalizer handle, or NULL on error
# * \version LibVLC 2.2.0 or later
#
proc audio_equalizer_new*(): ptr equalizer_t {.importc: "libvlc_audio_equalizer_new", cdecl, dynlib: dynvlc.}
# *
# * Create a new equalizer, with initial frequency values copied from an existing
# * preset.
# *
# * The new equalizer can subsequently be applied to a media player by invoking
# * libvlc_media_player_set_equalizer().
# *
# * The returned handle should be freed via libvlc_audio_equalizer_release() when
# * it is no longer needed.
# *
# * \param u_index index of the preset, counting from zero
# * \return opaque equalizer handle, or NULL on error
# * (it must be released with libvlc_audio_equalizer_release())
# * \version LibVLC 2.2.0 or later
#
proc audio_equalizer_new_from_preset*(u_index: cuint): ptr equalizer_t {.importc: "libvlc_audio_equalizer_new_from_preset", cdecl, dynlib: dynvlc.}
# *
# * Release a previously created equalizer instance.
# *
# * The equalizer was previously created by using libvlc_audio_equalizer_new() or
# * libvlc_audio_equalizer_new_from_preset().
# *
# * It is safe to invoke this method with a NULL p_equalizer parameter for no effect.
# *
# * \param p_equalizer opaque equalizer handle, or NULL
# * \version LibVLC 2.2.0 or later
#
proc audio_equalizer_release*(p_equalizer: ptr equalizer_t) {.importc: "libvlc_audio_equalizer_release", cdecl, dynlib: dynvlc.}
# *
# * Set a new pre-amplification value for an equalizer.
# *
# * The new equalizer settings are subsequently applied to a media player by invoking
# * libvlc_media_player_set_equalizer().
# *
# * The supplied amplification value will be clamped to the -20.0 to +20.0 range.
# *
# * \param p_equalizer valid equalizer handle, must not be NULL
# * \param f_preamp preamp value (-20.0 to 20.0 Hz)
# * \return zero on success, -1 on error
# * \version LibVLC 2.2.0 or later
#
proc audio_equalizer_set_preamp*(p_equalizer: ptr equalizer_t, f_preamp: cfloat): cint {.importc: "libvlc_audio_equalizer_set_preamp", cdecl, dynlib: dynvlc.}
# *
# * Get the current pre-amplification value from an equalizer.
# *
# * \param p_equalizer valid equalizer handle, must not be NULL
# * \return preamp value (Hz)
# * \version LibVLC 2.2.0 or later
#
proc audio_equalizer_get_preamp*(p_equalizer: ptr equalizer_t): cfloat {.importc: "libvlc_audio_equalizer_get_preamp", cdecl, dynlib: dynvlc.}
# *
# * Set a new amplification value for a particular equalizer frequency band.
# *
# * The new equalizer settings are subsequently applied to a media player by invoking
# * libvlc_media_player_set_equalizer().
# *
# * The supplied amplification value will be clamped to the -20.0 to +20.0 range.
# *
# * \param p_equalizer valid equalizer handle, must not be NULL
# * \param f_amp amplification value (-20.0 to 20.0 Hz)
# * \param u_band index, counting from zero, of the frequency band to set
# * \return zero on success, -1 on error
# * \version LibVLC 2.2.0 or later
#
proc audio_equalizer_set_amp_at_index*(p_equalizer: ptr equalizer_t, f_amp: cfloat, u_band: cuint): cint {.importc: "libvlc_audio_equalizer_set_amp_at_index", cdecl, dynlib: dynvlc.}
# *
# * Get the amplification value for a particular equalizer frequency band.
# *
# * \param p_equalizer valid equalizer handle, must not be NULL
# * \param u_band index, counting from zero, of the frequency band to get
# * \return amplification value (Hz); NaN if there is no such frequency band
# * \version LibVLC 2.2.0 or later
#
proc audio_equalizer_get_amp_at_index*(p_equalizer: ptr equalizer_t, u_band: cuint): cfloat {.importc: "libvlc_audio_equalizer_get_amp_at_index", cdecl, dynlib: dynvlc.}
# *
# * Apply new equalizer settings to a media player.
# *
# * The equalizer is first created by invoking libvlc_audio_equalizer_new() or
# * libvlc_audio_equalizer_new_from_preset().
# *
# * It is possible to apply new equalizer settings to a media player whether the media
# * player is currently playing media or not.
# *
# * Invoking this method will immediately apply the new equalizer settings to the audio
# * output of the currently playing media if there is any.
# *
# * If there is no currently playing media, the new equalizer settings will be applied
# * later if and when new media is played.
# *
# * Equalizer settings will automatically be applied to subsequently played media.
# *
# * To disable the equalizer for a media player invoke this method passing NULL for the
# * p_equalizer parameter.
# *
# * The media player does not keep a reference to the supplied equalizer so it is safe
# * for an application to release the equalizer reference any time after this method
# * returns.
# *
# * \param p_mi opaque media player handle
# * \param p_equalizer opaque equalizer handle, or NULL to disable the equalizer for this media player
# * \return zero on success, -1 on error
# * \version LibVLC 2.2.0 or later
#
proc media_player_set_equalizer*(p_mi: ptr media_player_t, p_equalizer: ptr equalizer_t): cint {.importc: "libvlc_media_player_set_equalizer", cdecl, dynlib: dynvlc.}
# *
# * Gets the media role.
# *
# * \version LibVLC 3.0.0 and later.
# *
# * \param p_mi media player
# * \return the media player role (\ref libvlc_media_player_role_t)
#
proc media_player_get_role*(p_mi: ptr media_player_t): cint {.importc: "libvlc_media_player_get_role", cdecl, dynlib: dynvlc.}
# *
# * Sets the media role.
# *
# * \param p_mi media player
# * \param role the media player role (\ref libvlc_media_player_role_t)
# * \return 0 on success, -1 on error
#
proc media_player_set_role*(p_mi: ptr media_player_t, role: cuint): cint {.importc: "libvlc_media_player_set_role", cdecl, dynlib: dynvlc.}
# *
# * Create an empty media list.
# *
# * \param p_instance libvlc instance
# * \return empty media list, or NULL on error
#
proc media_list_new*(p_instance: ptr instance_t): ptr media_list_t {.importc: "libvlc_media_list_new", cdecl, dynlib: dynvlc.}
# *
# * Release media list created with libvlc_media_list_new().
# *
# * \param p_ml a media list created with libvlc_media_list_new()
#
proc media_list_release*(p_ml: ptr media_list_t) {.importc: "libvlc_media_list_release", cdecl, dynlib: dynvlc.}
# *
# * Retain reference to a media list
# *
# * \param p_ml a media list created with libvlc_media_list_new()
#
proc media_list_retain*(p_ml: ptr media_list_t) {.importc: "libvlc_media_list_retain", cdecl, dynlib: dynvlc.}
# *
# * Associate media instance with this media list instance.
# * If another media instance was present it will be released.
# * The libvlc_media_list_lock should NOT be held upon entering this function.
# *
# * \param p_ml a media list instance
# * \param p_md media instance to add
#
proc media_list_set_media*(p_ml: ptr media_list_t, p_md: ptr media_t) {.importc: "libvlc_media_list_set_media", cdecl, dynlib: dynvlc.}
# *
# * Get media instance from this media list instance. This action will increase
# * the refcount on the media instance.
# * The libvlc_media_list_lock should NOT be held upon entering this function.
# *
# * \param p_ml a media list instance
# * \return media instance
#
proc media_list_media*(p_ml: ptr media_list_t): ptr media_t {.importc: "libvlc_media_list_media", cdecl, dynlib: dynvlc.}
# *
# * Add media instance to media list
# * The libvlc_media_list_lock should be held upon entering this function.
# *
# * \param p_ml a media list instance
# * \param p_md a media instance
# * \return 0 on success, -1 if the media list is read-only
#
proc media_list_add_media*(p_ml: ptr media_list_t, p_md: ptr media_t): cint {.importc: "libvlc_media_list_add_media", cdecl, dynlib: dynvlc.}
# *
# * Insert media instance in media list on a position
# * The libvlc_media_list_lock should be held upon entering this function.
# *
# * \param p_ml a media list instance
# * \param p_md a media instance
# * \param i_pos position in array where to insert
# * \return 0 on success, -1 if the media list is read-only
#
proc media_list_insert_media*(p_ml: ptr media_list_t, p_md: ptr media_t, i_pos: cint): cint {.importc: "libvlc_media_list_insert_media", cdecl, dynlib: dynvlc.}
# *
# * Remove media instance from media list on a position
# * The libvlc_media_list_lock should be held upon entering this function.
# *
# * \param p_ml a media list instance
# * \param i_pos position in array where to insert
# * \return 0 on success, -1 if the list is read-only or the item was not found
#
proc media_list_remove_index*(p_ml: ptr media_list_t, i_pos: cint): cint {.importc: "libvlc_media_list_remove_index", cdecl, dynlib: dynvlc.}
# *
# * Get count on media list items
# * The libvlc_media_list_lock should be held upon entering this function.
# *
# * \param p_ml a media list instance
# * \return number of items in media list
#
proc media_list_count*(p_ml: ptr media_list_t): cint {.importc: "libvlc_media_list_count", cdecl, dynlib: dynvlc.}
# *
# * List media instance in media list at a position
# * The libvlc_media_list_lock should be held upon entering this function.
# *
# * \param p_ml a media list instance
# * \param i_pos position in array where to insert
# * \return media instance at position i_pos, or NULL if not found.
# * In case of success, libvlc_media_retain() is called to increase the refcount
# * on the media.
#
proc media_list_item_at_index*(p_ml: ptr media_list_t, i_pos: cint): ptr media_t {.importc: "libvlc_media_list_item_at_index", cdecl, dynlib: dynvlc.}
# *
# * Find index position of List media instance in media list.
# * Warning: the function will return the first matched position.
# * The libvlc_media_list_lock should be held upon entering this function.
# *
# * \param p_ml a media list instance
# * \param p_md media instance
# * \return position of media instance or -1 if media not found
#
proc media_list_index_of_item*(p_ml: ptr media_list_t, p_md: ptr media_t): cint {.importc: "libvlc_media_list_index_of_item", cdecl, dynlib: dynvlc.}
# *
# * This indicates if this media list is read-only from a user point of view
# *
# * \param p_ml media list instance
# * \retval true read-only
# * \retval false read/write
#
proc media_list_is_readonly*(p_ml: ptr media_list_t): bool {.importc: "libvlc_media_list_is_readonly", cdecl, dynlib: dynvlc.}
# *
# * Get lock on media list items
# *
# * \param p_ml a media list instance
#
proc media_list_lock*(p_ml: ptr media_list_t) {.importc: "libvlc_media_list_lock", cdecl, dynlib: dynvlc.}
# *
# * Release lock on media list items
# * The libvlc_media_list_lock should be held upon entering this function.
# *
# * \param p_ml a media list instance
#
proc media_list_unlock*(p_ml: ptr media_list_t) {.importc: "libvlc_media_list_unlock", cdecl, dynlib: dynvlc.}
# *
# * Get libvlc_event_manager from this media list instance.
# * The p_event_manager is immutable, so you don't have to hold the lock
# *
# * \param p_ml a media list instance
# * \return libvlc_event_manager
#
proc media_list_event_manager*(p_ml: ptr media_list_t): ptr event_manager_t {.importc: "libvlc_media_list_event_manager", cdecl, dynlib: dynvlc.}
# *
# * Create new media_list_player.
# *
# * \param p_instance libvlc instance
# * \return media list player instance or NULL on error
# * (it must be released by libvlc_media_list_player_release())
#
proc media_list_player_new*(p_instance: ptr instance_t): ptr media_list_player_t {.importc: "libvlc_media_list_player_new", cdecl, dynlib: dynvlc.}
# *
# * Release a media_list_player after use
# * Decrement the reference count of a media player object. If the
# * reference count is 0, then libvlc_media_list_player_release() will
# * release the media player object. If the media player object
# * has been released, then it should not be used again.
# *
# * \param p_mlp media list player instance
#
proc media_list_player_release*(p_mlp: ptr media_list_player_t) {.importc: "libvlc_media_list_player_release", cdecl, dynlib: dynvlc.}
# *
# * Retain a reference to a media player list object. Use
# * libvlc_media_list_player_release() to decrement reference count.
# *
# * \param p_mlp media player list object
#
proc media_list_player_retain*(p_mlp: ptr media_list_player_t) {.importc: "libvlc_media_list_player_retain", cdecl, dynlib: dynvlc.}
# *
# * Return the event manager of this media_list_player.
# *
# * \param p_mlp media list player instance
# * \return the event manager
#
proc media_list_player_event_manager*(p_mlp: ptr media_list_player_t): ptr event_manager_t {.importc: "libvlc_media_list_player_event_manager", cdecl, dynlib: dynvlc.}
# *
# * Replace media player in media_list_player with this instance.
# *
# * \param p_mlp media list player instance
# * \param p_mi media player instance
#
proc media_list_player_set_media_player*(p_mlp: ptr media_list_player_t, p_mi: ptr media_player_t) {.importc: "libvlc_media_list_player_set_media_player", cdecl, dynlib: dynvlc.}
# *
# * Get media player of the media_list_player instance.
# *
# * \param p_mlp media list player instance
# * \return media player instance
# * \note the caller is responsible for releasing the returned instance
# with libvlc_media_list_player_set_media_player().
#
proc media_list_player_get_media_player*(p_mlp: ptr media_list_player_t): ptr media_player_t {.importc: "libvlc_media_list_player_get_media_player", cdecl, dynlib: dynvlc.}
# *
# * Set the media list associated with the player
# *
# * \param p_mlp media list player instance
# * \param p_mlist list of media
#
proc media_list_player_set_media_list*(p_mlp: ptr media_list_player_t, p_mlist: ptr media_list_t) {.importc: "libvlc_media_list_player_set_media_list", cdecl, dynlib: dynvlc.}
# *
# * Play media list
# *
# * \param p_mlp media list player instance
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_media_list_player_play' skipped
# Declaration 'p_mlp' skipped
# *
# * Toggle pause (or resume) media list
# *
# * \param p_mlp media list player instance
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_media_list_player_pause' skipped
# Declaration 'p_mlp' skipped
# *
# * Pause or resume media list
# *
# * \param p_mlp media list player instance
# * \param do_pause play/resume if zero, pause if non-zero
# * \version LibVLC 3.0.0 or later
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_media_list_player_set_pause' skipped
# Declaration 'p_mlp' skipped
# Declaration 'do_pause' skipped
# *
# * Is media list playing?
# *
# * \param p_mlp media list player instance
# *
# * \retval true playing
# * \retval false not playing
#
proc media_list_player_is_playing*(p_mlp: ptr media_list_player_t): bool {.importc: "libvlc_media_list_player_is_playing", cdecl, dynlib: dynvlc.}
# *
# * Get current libvlc_state of media list player
# *
# * \param p_mlp media list player instance
# * \return libvlc_state_t for media list player
#
proc media_list_player_get_state*(p_mlp: ptr media_list_player_t): state_t {.importc: "libvlc_media_list_player_get_state", cdecl, dynlib: dynvlc.}
# *
# * Play media list item at position index
# *
# * \param p_mlp media list player instance
# * \param i_index index in media list to play
# * \return 0 upon success -1 if the item wasn't found
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_media_list_player_play_item_at_index' skipped
# Declaration 'p_mlp' skipped
# Declaration 'i_index' skipped
# *
# * Play the given media item
# *
# * \param p_mlp media list player instance
# * \param p_md the media instance
# * \return 0 upon success, -1 if the media is not part of the media list
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_media_list_player_play_item' skipped
# Declaration 'p_mlp' skipped
# Declaration 'p_md' skipped
# *
# * Stop playing media list
# *
# * \param p_mlp media list player instance
#
proc media_list_player_stop_async*(p_mlp: ptr media_list_player_t) {.importc: "libvlc_media_list_player_stop_async", cdecl, dynlib: dynvlc.}
# *
# * Play next item from media list
# *
# * \param p_mlp media list player instance
# * \return 0 upon success -1 if there is no next item
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_media_list_player_next' skipped
# Declaration 'p_mlp' skipped
# *
# * Play previous item from media list
# *
# * \param p_mlp media list player instance
# * \return 0 upon success -1 if there is no previous item
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_media_list_player_previous' skipped
# Declaration 'p_mlp' skipped
# *
# * Sets the playback mode for the playlist
# *
# * \param p_mlp media list player instance
# * \param e_mode playback mode specification
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_media_list_player_set_playback_mode' skipped
# Declaration 'p_mlp' skipped
# Declaration 'e_mode' skipped
# *
# * Create a media discoverer object by name.
# *
# * After this object is created, you should attach to media_list events in
# * order to be notified of new items discovered.
# *
# * You need to call libvlc_media_discoverer_start() in order to start the
# * discovery.
# *
# * \see libvlc_media_discoverer_media_list
# * \see libvlc_media_discoverer_event_manager
# * \see libvlc_media_discoverer_start
# *
# * \param p_inst libvlc instance
# * \param psz_name service name; use libvlc_media_discoverer_list_get() to get
# * a list of the discoverer names available in this libVLC instance
# * \return media discover object or NULL in case of error
# * \version LibVLC 3.0.0 or later
#
proc media_discoverer_new*(p_inst: ptr instance_t, psz_name: cstring): ptr media_discoverer_t {.importc: "libvlc_media_discoverer_new", cdecl, dynlib: dynvlc.}
# *
# * Start media discovery.
# *
# * To stop it, call libvlc_media_discoverer_stop() or
# * libvlc_media_discoverer_list_release() directly.
# *
# * \see libvlc_media_discoverer_stop
# *
# * \param p_mdis media discover object
# * \return -1 in case of error, 0 otherwise
# * \version LibVLC 3.0.0 or later
#
proc media_discoverer_start*(p_mdis: ptr media_discoverer_t): cint {.importc: "libvlc_media_discoverer_start", cdecl, dynlib: dynvlc.}
# *
# * Stop media discovery.
# *
# * \see libvlc_media_discoverer_start
# *
# * \param p_mdis media discover object
# * \version LibVLC 3.0.0 or later
#
proc media_discoverer_stop*(p_mdis: ptr media_discoverer_t) {.importc: "libvlc_media_discoverer_stop", cdecl, dynlib: dynvlc.}
# *
# * Release media discover object. If the reference count reaches 0, then
# * the object will be released.
# *
# * \param p_mdis media service discover object
#
proc media_discoverer_release*(p_mdis: ptr media_discoverer_t) {.importc: "libvlc_media_discoverer_release", cdecl, dynlib: dynvlc.}
# *
# * Get media service discover media list.
# *
# * \param p_mdis media service discover object
# * \return list of media items
#
proc media_discoverer_media_list*(p_mdis: ptr media_discoverer_t): ptr media_list_t {.importc: "libvlc_media_discoverer_media_list", cdecl, dynlib: dynvlc.}
# *
# * Query if media service discover object is running.
# *
# * \param p_mdis media service discover object
# *
# * \retval true running
# * \retval false not running
#
proc media_discoverer_is_running*(p_mdis: ptr media_discoverer_t): bool {.importc: "libvlc_media_discoverer_is_running", cdecl, dynlib: dynvlc.}
# *
# * Get media discoverer services by category
# *
# * \version LibVLC 3.0.0 and later.
# *
# * \param p_inst libvlc instance
# * \param i_cat category of services to fetch
# * \param ppp_services address to store an allocated array of media discoverer
# * services (must be freed with libvlc_media_discoverer_list_release() by
# * the caller) [OUT]
# *
# * \return the number of media discoverer services (0 on error)
#
# Declaration 'libvlc_media_discoverer_list_get' skipped
# Declaration 'p_inst' skipped
# Declaration 'i_cat' skipped
# Declaration 'libvlc_media_discoverer_list_get' skipped
# Declaration 'p_inst' skipped
# Declaration 'i_cat' skipped
# Declaration 'ppp_services' skipped
# *
# * Release an array of media discoverer services
# *
# * \version LibVLC 3.0.0 and later.
# *
# * \see libvlc_media_discoverer_list_get()
# *
# * \param pp_services array to release
# * \param i_count number of elements in the array
#
proc media_discoverer_list_release*(pp_services: ptr ptr media_discoverer_description_t, i_count: uint) {.importc: "libvlc_media_discoverer_list_release", cdecl, dynlib: dynvlc.}
# *
# * Register callbacks in order to handle VLC dialogs
# *
# * @version LibVLC 3.0.0 and later.
# *
# * @param p_cbs a pointer to callbacks, or NULL to unregister callbacks.
# * @param p_data opaque pointer for the callback
#
proc dialog_set_callbacks*(p_instance: ptr instance_t, p_cbs: ptr dialog_cbs, p_data: pointer) {.importc: "libvlc_dialog_set_callbacks", cdecl, dynlib: dynvlc.}
# *
# * Associate an opaque pointer with the dialog id
# *
# * @version LibVLC 3.0.0 and later.
#
proc dialog_set_context*(p_id: ptr dialog_id, p_context: pointer) {.importc: "libvlc_dialog_set_context", cdecl, dynlib: dynvlc.}
# *
# * Return the opaque pointer associated with the dialog id
# * \see libvlc_dialog_set_context
# * @version LibVLC 3.0.0 and later.
#
proc dialog_get_context*(p_id: ptr dialog_id): pointer {.importc: "libvlc_dialog_get_context", cdecl, dynlib: dynvlc.}
# *
# * Post a login answer
# *
# * After this call, p_id won't be valid anymore
# *
# * @see libvlc_dialog_cbs.pf_display_login
# *
# * @version LibVLC 3.0.0 and later.
# *
# * @param p_id id of the dialog
# * @param psz_username valid and non empty string
# * @param psz_password valid string (can be empty)
# * @param b_store if true, store the credentials
# * @return 0 on success, or -1 on error
#
proc dialog_post_login*(p_id: ptr dialog_id, psz_username: cstring, psz_password: cstring, b_store: bool): cint {.importc: "libvlc_dialog_post_login", cdecl, dynlib: dynvlc.}
# *
# * Post a question answer
# *
# * After this call, p_id won't be valid anymore
# *
# * @see libvlc_dialog_cbs.pf_display_question
# *
# * @version LibVLC 3.0.0 and later.
# *
# * @param p_id id of the dialog
# * @param i_action 1 for action1, 2 for action2
# * @return 0 on success, or -1 on error
#
proc dialog_post_action*(p_id: ptr dialog_id, i_action: cint): cint {.importc: "libvlc_dialog_post_action", cdecl, dynlib: dynvlc.}
# *
# * Dismiss a dialog
# *
# * After this call, p_id won't be valid anymore
# *
# * @see libvlc_dialog_cbs.pf_cancel
# *
# * @version LibVLC 3.0.0 and later.
# *
# * @param p_id id of the dialog
# * @return 0 on success, or -1 on error
#
proc dialog_dismiss*(p_id: ptr dialog_id): cint {.importc: "libvlc_dialog_dismiss", cdecl, dynlib: dynvlc.}
# *
# * \ingroup libvlc libvlc_media
# * @{
#
# *
# * Parse a media.
# *
# * This fetches (local) art, meta data and tracks information.
# * The method is synchronous.
# *
# * \deprecated This function could block indefinitely.
# * Use libvlc_media_parse_with_options() instead
# *
# * \see libvlc_media_parse_with_options
# * \see libvlc_media_get_meta
# *
# * \param p_md media descriptor object
#
proc media_parse*(p_md: ptr media_t) {.importc: "libvlc_media_parse", cdecl, dynlib: dynvlc.}
# *
# * Parse a media.
# *
# * This fetches (local) art, meta data and tracks information.
# * The method is the asynchronous of libvlc_media_parse().
# *
# * To track when this is over you can listen to libvlc_MediaParsedChanged
# * event. However if the media was already parsed you will not receive this
# * event.
# *
# * \deprecated You can't be sure to receive the libvlc_MediaParsedChanged
# * event (you can wait indefinitely for this event).
# * Use libvlc_media_parse_with_options() instead
# *
# * \see libvlc_media_parse
# * \see libvlc_MediaParsedChanged
# * \see libvlc_media_get_meta
# *
# * \param p_md media descriptor object
#
proc media_parse_async*(p_md: ptr media_t) {.importc: "libvlc_media_parse_async", cdecl, dynlib: dynvlc.}
# *
# * Return true is the media descriptor object is parsed
# *
# * \deprecated This can return true in case of failure.
# * Use libvlc_media_get_parsed_status() instead
# *
# * \see libvlc_MediaParsedChanged
# *
# * \param p_md media descriptor object
# * \retval true media object has been parsed
# * \retval false otherwise
#
proc media_is_parsed*(p_md: ptr media_t): bool {.importc: "libvlc_media_is_parsed", cdecl, dynlib: dynvlc.}
# * @}
# *
# * \ingroup libvlc
# * \defgroup libvlc_playlist LibVLC playlist (legacy)
# * @deprecated Use @ref libvlc_media_list instead.
# * @{
# * \file
# * LibVLC deprecated playlist API
#
# *
# * Start playing (if there is any item in the playlist).
# *
# * Additionnal playlist item options can be specified for addition to the
# * item before it is played.
# *
# * \param p_instance the playlist instance
#
# Declaration 'visibility' skipped
# Declaration 'libvlc_playlist_play' skipped
# Declaration 'p_instance' skipped
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment