desc stringlengths 3 26.7k | decl stringlengths 11 7.89k | bodies stringlengths 8 553k |
|---|---|---|
'Decrement the reference count of a libvlc instance, and destroy it
if it reaches zero.'
| def release(self):
| return libvlc_release(self)
|
'Increments the reference count of a libvlc instance.
The initial reference count is 1 after L{new}() returns.'
| def retain(self):
| return libvlc_retain(self)
|
'Try to start a user interface for the libvlc instance.
@param name: interface name, or None for default.
@return: 0 on success, -1 on error.'
| def add_intf(self, name):
| return libvlc_add_intf(self, str_to_bytes(name))
|
'Sets the application name. LibVLC passes this as the user agent string
when a protocol requires it.
@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.'
| def set_user_agent(self, name, http):
| return libvlc_set_user_agent(self, str_to_bytes(name), str_to_bytes(http))
|
'Sets some meta-information about the application.
See also L{set_user_agent}().
@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.'
| def set_app_id(self, id, version, icon):
| return libvlc_set_app_id(self, str_to_bytes(id), str_to_bytes(version), str_to_bytes(icon))
|
'Unsets the logging callback for a LibVLC instance. This is rarely needed:
the callback is implicitly unset when the instance is destroyed.
This function will wait for any pending callbacks invocation to complete
(causing a deadlock if called from within the callback).
@version: LibVLC 2.1.0 or later.'
| def log_unset(self):
| return libvlc_log_unset(self)
|
'Sets the logging callback for a LibVLC instance.
This function is thread-safe: it will wait for any pending callbacks
invocation to complete.
@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 ... | def log_set(self, data, p_instance):
| return libvlc_log_set(self, data, p_instance)
|
'Sets up logging to a file.
@param stream: FILE pointer opened for writing (the FILE pointer must remain valid until L{log_unset}()).
@version: LibVLC 2.1.0 or later.'
| def log_set_file(self, stream):
| return libvlc_log_set_file(self, stream)
|
'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} be used (see IETF RFC3986).
We recommend using L{media_new_path}() instead when dealing with
local files.
See L{media_release}.
@param psz_mrl: th... | def media_new_location(self, psz_mrl):
| return libvlc_media_new_location(self, str_to_bytes(psz_mrl))
|
'Create a media for a certain file path.
See L{media_release}.
@param path: local filesystem path.
@return: the newly created media or None on error.'
| def media_new_path(self, path):
| return libvlc_media_new_path(self, str_to_bytes(path))
|
'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... | def media_new_fd(self, fd):
| return libvlc_media_new_fd(self, fd)
|
'Create a media with custom callbacks to read the data from.
@param open_cb: callback to open the custom bitstream input media.
@param read_cb: callback to read data (must not be None).
@param seek_cb: callback to seek, or None if seeking is not supported.
@param close_cb: callback to close the media, or None if unnece... | def media_new_callbacks(self, open_cb, read_cb, seek_cb, close_cb, opaque):
| return libvlc_media_new_callbacks(self, open_cb, read_cb, seek_cb, close_cb, opaque)
|
'Create a media as an empty node with a given name.
See L{media_release}.
@param psz_name: the name of the node.
@return: the new empty media or None on error.'
| def media_new_as_node(self, psz_name):
| return libvlc_media_new_as_node(self, str_to_bytes(psz_name))
|
'Create a media discoverer object by name.
After this object is created, you should attach to events in order to be
notified of the discoverer state.
You should also attach to media_list events in order to be notified of new
items discovered.
You need to call L{media_discoverer_start}() in order to start the
discovery.... | def media_discoverer_new(self, psz_name):
| return libvlc_media_discoverer_new(self, str_to_bytes(psz_name))
|
'Create an new Media Library object.
@return: a new object or None on error.'
| def media_library_new(self):
| return libvlc_media_library_new(self)
|
'Gets the list of available audio output modules.
@return: list of available audio outputs. It must be freed with In case of error, None is returned.'
| def audio_output_list_get(self):
| return libvlc_audio_output_list_get(self)
|
'Gets a list of audio output devices for a given audio output module,
See L{audio_output_device_set}().
@note: Not all audio outputs support this. In particular, an empty (None)
list of devices does B{not} imply that the specified audio output does
not work.
@note: The list might not be exhaustive.
@warning: Some audio... | def audio_output_device_list_get(self, aout):
| return libvlc_audio_output_device_list_get(self, str_to_bytes(aout))
|
'Release the vlm instance related to the given L{Instance}.'
| def vlm_release(self):
| return libvlc_vlm_release(self)
|
'Add a broadcast, with one input.
@param psz_name: the name of the new broadcast.
@param psz_input: the input MRL.
@param psz_output: the output MRL (the parameter to the "sout" variable).
@param i_options: number of additional options.
@param ppsz_options: additional options.
@param b_enabled: boolean for enabling the... | def vlm_add_broadcast(self, psz_name, psz_input, psz_output, i_options, ppsz_options, b_enabled, b_loop):
| return libvlc_vlm_add_broadcast(self, str_to_bytes(psz_name), str_to_bytes(psz_input), str_to_bytes(psz_output), i_options, ppsz_options, b_enabled, b_loop)
|
'Add a vod, with one input.
@param psz_name: the name of the new vod media.
@param psz_input: the input MRL.
@param i_options: number of additional options.
@param ppsz_options: additional options.
@param b_enabled: boolean for enabling the new vod.
@param psz_mux: the muxer of the vod media.
@return: 0 on success, -1 ... | def vlm_add_vod(self, psz_name, psz_input, i_options, ppsz_options, b_enabled, psz_mux):
| return libvlc_vlm_add_vod(self, str_to_bytes(psz_name), str_to_bytes(psz_input), i_options, ppsz_options, b_enabled, str_to_bytes(psz_mux))
|
'Delete a media (VOD or broadcast).
@param psz_name: the media to delete.
@return: 0 on success, -1 on error.'
| def vlm_del_media(self, psz_name):
| return libvlc_vlm_del_media(self, str_to_bytes(psz_name))
|
'Enable or disable a media (VOD or broadcast).
@param psz_name: the media to work on.
@param b_enabled: the new status.
@return: 0 on success, -1 on error.'
| def vlm_set_enabled(self, psz_name, b_enabled):
| return libvlc_vlm_set_enabled(self, str_to_bytes(psz_name), b_enabled)
|
'Set the output for a media.
@param psz_name: the media to work on.
@param psz_output: the output MRL (the parameter to the "sout" variable).
@return: 0 on success, -1 on error.'
| def vlm_set_output(self, psz_name, psz_output):
| return libvlc_vlm_set_output(self, str_to_bytes(psz_name), str_to_bytes(psz_output))
|
'Set a media\'s input MRL. This will delete all existing inputs and
add the specified one.
@param psz_name: the media to work on.
@param psz_input: the input MRL.
@return: 0 on success, -1 on error.'
| def vlm_set_input(self, psz_name, psz_input):
| return libvlc_vlm_set_input(self, str_to_bytes(psz_name), str_to_bytes(psz_input))
|
'Add a media\'s input MRL. This will add the specified one.
@param psz_name: the media to work on.
@param psz_input: the input MRL.
@return: 0 on success, -1 on error.'
| def vlm_add_input(self, psz_name, psz_input):
| return libvlc_vlm_add_input(self, str_to_bytes(psz_name), str_to_bytes(psz_input))
|
'Set a media\'s loop status.
@param psz_name: the media to work on.
@param b_loop: the new status.
@return: 0 on success, -1 on error.'
| def vlm_set_loop(self, psz_name, b_loop):
| return libvlc_vlm_set_loop(self, str_to_bytes(psz_name), b_loop)
|
'Set a media\'s vod muxer.
@param psz_name: the media to work on.
@param psz_mux: the new muxer.
@return: 0 on success, -1 on error.'
| def vlm_set_mux(self, psz_name, psz_mux):
| return libvlc_vlm_set_mux(self, str_to_bytes(psz_name), str_to_bytes(psz_mux))
|
'Edit the parameters of a media. This will delete all existing inputs and
add the specified one.
@param psz_name: the name of the new broadcast.
@param psz_input: the input MRL.
@param psz_output: the output MRL (the parameter to the "sout" variable).
@param i_options: number of additional options.
@param ppsz_options:... | def vlm_change_media(self, psz_name, psz_input, psz_output, i_options, ppsz_options, b_enabled, b_loop):
| return libvlc_vlm_change_media(self, str_to_bytes(psz_name), str_to_bytes(psz_input), str_to_bytes(psz_output), i_options, ppsz_options, b_enabled, b_loop)
|
'Play the named broadcast.
@param psz_name: the name of the broadcast.
@return: 0 on success, -1 on error.'
| def vlm_play_media(self, psz_name):
| return libvlc_vlm_play_media(self, str_to_bytes(psz_name))
|
'Stop the named broadcast.
@param psz_name: the name of the broadcast.
@return: 0 on success, -1 on error.'
| def vlm_stop_media(self, psz_name):
| return libvlc_vlm_stop_media(self, str_to_bytes(psz_name))
|
'Pause the named broadcast.
@param psz_name: the name of the broadcast.
@return: 0 on success, -1 on error.'
| def vlm_pause_media(self, psz_name):
| return libvlc_vlm_pause_media(self, str_to_bytes(psz_name))
|
'Seek in the named broadcast.
@param psz_name: the name of the broadcast.
@param f_percentage: the percentage to seek to.
@return: 0 on success, -1 on error.'
| def vlm_seek_media(self, psz_name, f_percentage):
| return libvlc_vlm_seek_media(self, str_to_bytes(psz_name), f_percentage)
|
'Return information about the named media as a JSON
string representation.
This function is mainly intended for debugging use,
if you want programmatic access to the state of
a vlm_media_instance_t, please use the corresponding
libvlc_vlm_get_media_instance_xxx -functions.
Currently there are no such functions availabl... | def vlm_show_media(self, psz_name):
| return libvlc_vlm_show_media(self, str_to_bytes(psz_name))
|
'Get vlm_media instance position by name or instance id.
@param psz_name: name of vlm media instance.
@param i_instance: instance id.
@return: position as float or -1. on error.'
| def vlm_get_media_instance_position(self, psz_name, i_instance):
| return libvlc_vlm_get_media_instance_position(self, str_to_bytes(psz_name), i_instance)
|
'Get vlm_media instance time by name or instance id.
@param psz_name: name of vlm media instance.
@param i_instance: instance id.
@return: time as integer or -1 on error.'
| def vlm_get_media_instance_time(self, psz_name, i_instance):
| return libvlc_vlm_get_media_instance_time(self, str_to_bytes(psz_name), i_instance)
|
'Get vlm_media instance length by name or instance id.
@param psz_name: name of vlm media instance.
@param i_instance: instance id.
@return: length of media item or -1 on error.'
| def vlm_get_media_instance_length(self, psz_name, i_instance):
| return libvlc_vlm_get_media_instance_length(self, str_to_bytes(psz_name), i_instance)
|
'Get vlm_media instance playback rate by name or instance id.
@param psz_name: name of vlm media instance.
@param i_instance: instance id.
@return: playback rate or -1 on error.'
| def vlm_get_media_instance_rate(self, psz_name, i_instance):
| return libvlc_vlm_get_media_instance_rate(self, str_to_bytes(psz_name), i_instance)
|
'Get vlm_media instance title number by name or instance id.
@param psz_name: name of vlm media instance.
@param i_instance: instance id.
@return: title as number or -1 on error.
@bug: will always return 0.'
| def vlm_get_media_instance_title(self, psz_name, i_instance):
| return libvlc_vlm_get_media_instance_title(self, str_to_bytes(psz_name), i_instance)
|
'Get vlm_media instance chapter number by name or instance id.
@param psz_name: name of vlm media instance.
@param i_instance: instance id.
@return: chapter as number or -1 on error.
@bug: will always return 0.'
| def vlm_get_media_instance_chapter(self, psz_name, i_instance):
| return libvlc_vlm_get_media_instance_chapter(self, str_to_bytes(psz_name), i_instance)
|
'Is libvlc instance seekable ?
@param psz_name: name of vlm media instance.
@param i_instance: instance id.
@return: 1 if seekable, 0 if not, -1 if media does not exist.
@bug: will always return 0.'
| def vlm_get_media_instance_seekable(self, psz_name, i_instance):
| return libvlc_vlm_get_media_instance_seekable(self, str_to_bytes(psz_name), i_instance)
|
'Get libvlc_event_manager from a vlm media.
The p_event_manager is immutable, so you don\'t have to hold the lock.
@return: libvlc_event_manager.'
| @memoize_parameterless
def vlm_get_event_manager(self):
| return libvlc_vlm_get_event_manager(self)
|
'Add a list of options to the media.
Options must be written without the double-dash. Warning: most
audio and video options, such as text renderer, have no
effects on an individual media. These options must be set at
the vlc.Instance or vlc.MediaPlayer instanciation.
@param options: optional media option=value strings'... | def add_options(self, *options):
| for o in options:
self.add_option(o)
|
'Get media descriptor\'s elementary streams description
Note, you need to call L{parse}() or play the media at least once
before calling this function.
Not doing this will result in an empty array.
The result must be freed with L{tracks_release}.
@version: LibVLC 2.1.0 and later.'
| def tracks_get(self):
| mediaTrack_pp = ctypes.POINTER(MediaTrack)()
n = libvlc_media_tracks_get(self, ctypes.byref(mediaTrack_pp))
info = ctypes.cast(ctypes.mediaTrack_pp, ctypes.POINTER((ctypes.POINTER(MediaTrack) * n)))
return info
|
'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 --long-help\' from the command line,
e.g. "-sout-all". Keep in mind that available option... | def add_option(self, psz_options):
| return libvlc_media_add_option(self, str_to_bytes(psz_options))
|
'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 --long-help, for instance
"--sout-all". Note that all options are not us... | def add_option_flag(self, psz_options, i_flags):
| return libvlc_media_add_option_flag(self, str_to_bytes(psz_options), i_flags)
|
'Retain a reference to a media descriptor object (libvlc_media_t). Use
L{release}() to decrement the reference count of a
media descriptor object.'
| def retain(self):
| return libvlc_media_retain(self)
|
'Decrement the reference count of a media descriptor object. If the
reference count is 0, then L{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.'
| def release(self):
| return libvlc_media_release(self)
|
'Get the media resource locator (mrl) from a media descriptor object.
@return: string with mrl of media descriptor object.'
| def get_mrl(self):
| return libvlc_media_get_mrl(self)
|
'Duplicate a media descriptor object.'
| def duplicate(self):
| return libvlc_media_duplicate(self)
|
'Read the meta of the media.
If the media has not yet been parsed this will return None.
This methods automatically calls L{parse_async}(), so after calling
it you may receive a libvlc_MediaMetaChanged event. If you prefer a synchronous
version ensure that you call L{parse}() before get_meta().
See L{parse}
See L{parse... | def get_meta(self, e_meta):
| return libvlc_media_get_meta(self, e_meta)
|
'Set the meta of the media (this function will not save the meta, call
L{save_meta} in order to save the meta).
@param e_meta: the meta to write.
@param psz_value: the media\'s meta.'
| def set_meta(self, e_meta, psz_value):
| return libvlc_media_set_meta(self, e_meta, str_to_bytes(psz_value))
|
'Save the meta previously set.
@return: true if the write operation was successful.'
| def save_meta(self):
| return libvlc_media_save_meta(self)
|
'Get current state of media descriptor object. Possible media states
are defined in libvlc_structures.c ( libvlc_NothingSpecial=0,
libvlc_Opening, libvlc_Buffering, libvlc_Playing, libvlc_Paused,
libvlc_Stopped, libvlc_Ended,
libvlc_Error).
See libvlc_state_t.
@return: state of media descriptor object.'
| def get_state(self):
| return libvlc_media_get_state(self)
|
'Get the current statistics about the media.
@param p_stats:: structure that contain the statistics about the media (this structure must be allocated by the caller).
@return: true if the statistics are available, false otherwise \libvlc_return_bool.'
| def get_stats(self, p_stats):
| return libvlc_media_get_stats(self, p_stats)
|
'Get subitems of media descriptor object. This will increment
the reference count of supplied media descriptor object. Use
L{list_release}() to decrement the reference counting.
@return: list of media descriptor subitems or None.'
| def subitems(self):
| return libvlc_media_subitems(self)
|
'Get event manager from media descriptor object.
NOTE: this function doesn\'t increment reference counting.
@return: event manager object.'
| @memoize_parameterless
def event_manager(self):
| return libvlc_media_event_manager(self)
|
'Get duration (in ms) of media descriptor object item.
@return: duration of media item or -1 on error.'
| def get_duration(self):
| return libvlc_media_get_duration(self)
|
'Parse a media.
This fetches (local) art, meta data and tracks information.
The method is synchronous.
See L{parse_async}
See L{get_meta}
See libvlc_media_get_tracks_info.'
| def parse(self):
| return libvlc_media_parse(self)
|
'Parse a media.
This fetches (local) art, meta data and tracks information.
The method is the asynchronous of L{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.
See L{parse}
See libvlc_MediaParsedChanged
See ... | def parse_async(self):
| return libvlc_media_parse_async(self)
|
'Parse the media asynchronously with options.
This fetches (local or network) art, meta data and/or tracks information.
This method is the extended version of L{parse_async}().
To track when this is over you can listen to libvlc_MediaParsedChanged
event. However if this functions returns an error, you will not receive ... | def parse_with_options(self, parse_flag):
| return libvlc_media_parse_with_options(self, parse_flag)
|
'Get Parsed status for media descriptor object.
See libvlc_MediaParsedChanged.
@return: true if media object has been parsed otherwise it returns false \libvlc_return_bool.'
| def is_parsed(self):
| return libvlc_media_is_parsed(self)
|
'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 L{Media} pointer.
@param p_new_user_data: pointer to user data.'
| def set_user_data(self, p_new_user_data):
| return libvlc_media_set_user_data(self, p_new_user_data)
|
'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 L{Media} pointer.'
| def get_user_data(self):
| return libvlc_media_get_user_data(self)
|
'Get the media type of the media descriptor object.
@return: media type.
@version: LibVLC 3.0.0 and later. See libvlc_media_type_t.'
| def get_type(self):
| return libvlc_media_get_type(self)
|
'Create a Media Player object from a Media.
@return: a new media player object, or None on error.'
| def player_new_from_media(self):
| return libvlc_media_player_new_from_media(self)
|
'(INTERNAL) ctypes wrapper constructor.'
| def __new__(cls, ptr=_internal_guard):
| return _Constructor(cls, ptr)
|
'Start media discovery.
To stop it, call L{stop}() or
L{release}() directly.
See L{stop}.
@return: -1 in case of error, 0 otherwise.
@version: LibVLC 3.0.0 or later.'
| def start(self):
| return libvlc_media_discoverer_start(self)
|
'Stop media discovery.
See L{start}.
@version: LibVLC 3.0.0 or later.'
| def stop(self):
| return libvlc_media_discoverer_stop(self)
|
'Release media discover object. If the reference count reaches 0, then
the object will be released.'
| def release(self):
| return libvlc_media_discoverer_release(self)
|
'Get media service discover object its localized name.
@return: localized name.'
| def localized_name(self):
| return libvlc_media_discoverer_localized_name(self)
|
'Get media service discover media list.
@return: list of media items.'
| def media_list(self):
| return libvlc_media_discoverer_media_list(self)
|
'Get event manager from media service discover object.
@return: event manager object.'
| @memoize_parameterless
def event_manager(self):
| return libvlc_media_discoverer_event_manager(self)
|
'Query if media service discover object is running.
@return: true if running, false if not \libvlc_return_bool.'
| def is_running(self):
| return libvlc_media_discoverer_is_running(self)
|
'(INTERNAL) ctypes wrapper constructor.'
| def __new__(cls, ptr=_internal_guard):
| return _Constructor(cls, ptr)
|
'Release media library object. This functions decrements the
reference count of the media library object. If it reaches 0,
then the object will be released.'
| def release(self):
| return libvlc_media_library_release(self)
|
'Retain a reference to a media library object. This function will
increment the reference counting for this object. Use
L{release}() to decrement the reference count.'
| def retain(self):
| return libvlc_media_library_retain(self)
|
'Load media library.
@return: 0 on success, -1 on error.'
| def load(self):
| return libvlc_media_library_load(self)
|
'Get media library subitems.
@return: media list subitems.'
| def media_list(self):
| return libvlc_media_library_media_list(self)
|
'Add media instance to media list.
The L{lock} should be held upon entering this function.
@param mrl: a media instance or a MRL.
@return: 0 on success, -1 if the media list is read-only.'
| def add_media(self, mrl):
| if isinstance(mrl, basestring):
mrl = (self.get_instance() or get_default_instance()).media_new(mrl)
return libvlc_media_list_add_media(self, mrl)
|
'Release media list created with L{new}().'
| def release(self):
| return libvlc_media_list_release(self)
|
'Retain reference to a media list.'
| def retain(self):
| return libvlc_media_list_retain(self)
|
'Associate media instance with this media list instance.
If another media instance was present it will be released.
The L{lock} should NOT be held upon entering this function.
@param p_md: media instance to add.'
| def set_media(self, p_md):
| return libvlc_media_list_set_media(self, p_md)
|
'Get media instance from this media list instance. This action will increase
the refcount on the media instance.
The L{lock} should NOT be held upon entering this function.
@return: media instance.'
| def media(self):
| return libvlc_media_list_media(self)
|
'Insert media instance in media list on a position
The L{lock} should be held upon entering this function.
@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.'
| def insert_media(self, p_md, i_pos):
| return libvlc_media_list_insert_media(self, p_md, i_pos)
|
'Remove media instance from media list on a position
The L{lock} should be held upon entering this function.
@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.'
| def remove_index(self, i_pos):
| return libvlc_media_list_remove_index(self, i_pos)
|
'Get count on media list items
The L{lock} should be held upon entering this function.
@return: number of items in media list.'
| def count(self):
| return libvlc_media_list_count(self)
|
'List media instance in media list at a position
The L{lock} should be held upon entering this function.
@param i_pos: position in array where to insert.
@return: media instance at position i_pos, or None if not found. In case of success, L{media_retain}() is called to increase the refcount on the media.'
| def item_at_index(self, i_pos):
| return libvlc_media_list_item_at_index(self, i_pos)
|
'Find index position of List media instance in media list.
Warning: the function will return the first matched position.
The L{lock} should be held upon entering this function.
@param p_md: media instance.
@return: position of media instance or -1 if media not found.'
| def index_of_item(self, p_md):
| return libvlc_media_list_index_of_item(self, p_md)
|
'This indicates if this media list is read-only from a user point of view.
@return: 1 on readonly, 0 on readwrite \libvlc_return_bool.'
| def is_readonly(self):
| return libvlc_media_list_is_readonly(self)
|
'Get lock on media list items.'
| def lock(self):
| return libvlc_media_list_lock(self)
|
'Release lock on media list items
The L{lock} should be held upon entering this function.'
| def unlock(self):
| return libvlc_media_list_unlock(self)
|
'Get libvlc_event_manager from this media list instance.
The p_event_manager is immutable, so you don\'t have to hold the lock.
@return: libvlc_event_manager.'
| @memoize_parameterless
def event_manager(self):
| return libvlc_media_list_event_manager(self)
|
'Return the associated Instance.'
| def get_instance(self):
| return self._instance
|
'Release a media_list_player after use
Decrement the reference count of a media player object. If the
reference count is 0, then L{release}() will
release the media player object. If the media player object
has been released, then it should not be used again.'
| def release(self):
| return libvlc_media_list_player_release(self)
|
'Retain a reference to a media player list object. Use
L{release}() to decrement reference count.'
| def retain(self):
| return libvlc_media_list_player_retain(self)
|
'Return the event manager of this media_list_player.
@return: the event manager.'
| @memoize_parameterless
def event_manager(self):
| return libvlc_media_list_player_event_manager(self)
|
'Replace media player in media_list_player with this instance.
@param p_mi: media player instance.'
| def set_media_player(self, p_mi):
| return libvlc_media_list_player_set_media_player(self, p_mi)
|
'Get media player of the media_list_player instance.
@return: media player instance @note the caller is responsible for releasing the returned instance.'
| def get_media_player(self):
| return libvlc_media_list_player_get_media_player(self)
|
'Set the media list associated with the player.
@param p_mlist: list of media.'
| def set_media_list(self, p_mlist):
| return libvlc_media_list_player_set_media_list(self, p_mlist)
|
'Play media list.'
| def play(self):
| return libvlc_media_list_player_play(self)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.