public void Release()
{
Logger.Debug("release()");
// if(released.compareAndSet(false, true)) {
LibVlc.libvlc_media_release(media);
// }
}
/**
* Create a new native media instance.
*
* @param media media resource locator
* @param mediaOptions zero or more media options
* @return native media instance
*/
private IntPtr newMediaDescriptor(string media, params string[] mediaOptions)
{
Logger.Debug("newMediaDescriptor(media={},mediaOptions={})", media, mediaOptions);
IntPtr mediaPointer = NativeString.StringPointer(media);
IntPtr mediaInstance = IntPtr.Zero;
if (mediaPointer != IntPtr.Zero)
{
try {
mediaInstance = LibVlc.libvlc_media_new_path(instance, mediaPointer);
Logger.Debug("mediaDescriptor={}", mediaInstance);
if (mediaListInstance != IntPtr.Zero)
{
// Set the standard media options (if any)...
AddMediaOptions(mediaInstance, standardMediaOptions); // FIXME handle return false?
// Set the particular media options (if any)...
AddMediaOptions(mediaInstance, mediaOptions); // FIXME handle return false?
}
}
finally {
NativeString.Release(mediaPointer);
}
}
return(mediaInstance);
}
/**
* Add native media options.
*
* @param mediaInstance native media instance
* @param options options to add
* @return <code>true</code> if the options were added; <code>false</code> if they were not
*/
private bool AddMediaOptions(IntPtr mediaInstance, params string[] options)
{
Logger.Debug("AddMediaOptions(options={})", options);
if (options != null)
{
IntPtr optionPtr = IntPtr.Zero;
foreach (string option in options)
{
Logger.Debug("option={}", option);
optionPtr = NativeString.StringPointer(option);
if (optionPtr != IntPtr.Zero)
{
try {
LibVlc.libvlc_media_add_option(mediaInstance, optionPtr);
}
finally {
NativeString.Release(optionPtr);
}
}
else
{
return(false);
}
}
}
return(true);
}
protected virtual void Dispose(bool disposing)
{
// Check to see if Dispose has already been called.
if (!this.disposed)
{
// If disposing equals true, dispose all managed
// and unmanaged resources.
if (disposing)
{
// Dispose managed resources.
}
// Release unmanaged resources. If disposing is false,
// only the following code is executed.
if (playing)
{
Stop();
}
LibVlc.libvlc_release(instance);
instance = IntPtr.Zero;
// Note that this is not thread safe.
// Another thread could start disposing the object
// after the managed resources are disposed,
// but before the disposed flag is set to true.
// If thread safety is necessary, it must be
// implemented by the client.
}
disposed = true;
}
/**
* Create a new media list item for a give native media instance.
*
* @param mediaInstance native media instance
* @return media list item
*/
private MediaListItem NewMediaListItem(IntPtr mediaInstance)
{
string name = NativeString.GetNativeString(LibVlc.libvlc_media_get_meta(mediaInstance, (int)libvlc_meta_e.libvlc_meta_Title));
string mrl = NativeString.GetNativeString(LibVlc.libvlc_media_get_mrl(mediaInstance));
List <MediaListItem> subItems;
IntPtr subItemList = LibVlc.libvlc_media_subitems(mediaInstance);
if (subItemList != IntPtr.Zero)
{
try {
LibVlc.libvlc_media_list_lock(subItemList);
subItems = new List <MediaListItem>();
for (int i = 0; i < LibVlc.libvlc_media_list_count(subItemList); i++)
{
IntPtr subItemInstance = LibVlc.libvlc_media_list_item_at_index(subItemList, i);
subItems.Add(NewMediaListItem(subItemInstance));
LibVlc.libvlc_media_release(subItemInstance);
}
}
finally {
LibVlc.libvlc_media_list_unlock(subItemList);
}
LibVlc.libvlc_media_list_release(subItemList);
}
else
{
subItems = new List <MediaListItem>(0);
}
return(new MediaListItem(name, mrl, subItems));
}
/**
* Release the native resources associated with this factory.
*/
public void Release()
{
Logger.Debug("Release()");
if (instance != IntPtr.Zero)
{
LibVlc.libvlc_release(instance);
}
}
/**
* Get the available video filters.
*
* @return collection of video filter descriptions
*
* @since libvlc 2.0.0
*/
public List <ModuleDescription> GetVideoFilters()
{
Logger.Debug("GetVideoFilters()");
IntPtr moduleDescriptions = LibVlc.libvlc_video_filter_list_get(instance);
List <ModuleDescription> result = GetModuleDescriptions(moduleDescriptions);
LibVlc.libvlc_module_description_list_release(moduleDescriptions);
return(result);
}
public void Play()
{
Logger.Debug("Play()");
// If there is an associated media player then make sure the video surface
// is attached
if (mediaPlayer is EmbeddedMediaPlayer)
{
((EmbeddedMediaPlayer)mediaPlayer).AttachVideoSurface();
}
LibVlc.libvlc_media_list_player_play(mediaListPlayerInstance);
}
/**
* Get the number of items currently in the list.
*
* @return item count
*/
public int Size()
{
Logger.Debug("Size()");
try {
LockList();
int size = LibVlc.libvlc_media_list_count(mediaListInstance);
return(size);
}
finally {
UnlockList();
}
}
/**
* Set a local meta data value for a media instance.
* <p>
* Setting meta does not affect the underlying media file until {@link #save()} is called.
*
* @param metaType type of meta data
* @param media media instance
* @param value meta data value
*/
private void SetMeta(libvlc_meta_e metaType, string metaValue)
{
Logger.Trace("SetMeta(metaType={},media={},value={})", metaType, media, metaValue);
IntPtr metaValuePtr = NativeString.StringPointer(metaValue);
try {
LibVlc.libvlc_media_set_meta(media, (int)metaType, metaValuePtr);
}
finally {
NativeString.Release(metaValuePtr);
}
}
/**
*
*/
private void CreateInstance()
{
Logger.Debug("CreateInstance()");
mediaListPlayerInstance = LibVlc.libvlc_media_list_player_new(instance);
mediaListPlayerEventManager = LibVlc.libvlc_media_list_player_event_manager(mediaListPlayerInstance);
Logger.Debug("mediaListPlayerEventManager={}", mediaListPlayerEventManager);
RegisterEventListener();
// AddMediaListPlayerEventListener(new NextItemHandler());
}
/**
* De-register the call-back used to receive native media player events.
*/
private void DeregisterEventListener()
{
Logger.Debug("DeregisterEventListener()");
IntPtr callbackPtr = Marshal.GetFunctionPointerForDelegate(callback);
foreach (int value in Enum.GetValues(typeof(libvlc_event_e)))
{
if (value >= (int)libvlc_event_e.libvlc_MediaListItemAdded && value <= (int)libvlc_event_e.libvlc_MediaListWillDeleteItem)
{
Logger.Debug("event={}", value);
LibVlc.libvlc_event_detach(mediaListEventManager, value, callbackPtr, IntPtr.Zero);
}
}
}
public void Stop()
{
if (playing)
{
LibVlc.libvlc_media_player_stop(player);
LibVlc.libvlc_media_player_release(player);
playing = false;
player = IntPtr.Zero;
}
else
{
throw new InvalidOperationException("VLC is not currently playing media");
}
}
/**
* Clean up and free the media list instance.
*/
private void DestroyInstance()
{
Logger.Debug("DestroyInstance()");
DeregisterEventListener();
if (mediaListInstance != IntPtr.Zero)
{
LibVlc.libvlc_media_list_release(mediaListInstance);
}
Logger.Debug("Shut down listeners...");
listenersService.Shutdown();
Logger.Debug("Listeners shut down.");
}
/**
* Clear the list.
*/
public void Clear()
{
Logger.Debug("Clear()");
try {
LockList();
// Traverse the list from the end back to the start...
for (int i = LibVlc.libvlc_media_list_count(mediaListInstance) - 1; i >= 0; i--)
{
LibVlc.libvlc_media_list_remove_index(mediaListInstance, i);
}
}
finally {
UnlockList();
}
}
/**
* Create and initialise a new media list instance.
*/
private void CreateInstance(IntPtr mediaListInstance)
{
Logger.Debug("CreateInstance()");
if (mediaListInstance == IntPtr.Zero)
{
mediaListInstance = LibVlc.libvlc_media_list_new(instance);
}
this.mediaListInstance = mediaListInstance;
Logger.Debug("mediaListInstance={}", mediaListInstance);
mediaListEventManager = LibVlc.libvlc_media_list_event_manager(mediaListInstance);
Logger.Debug("mediaListEventManager={}", mediaListEventManager);
RegisterEventListener();
}
/**
* Insert a media item, with options, to the play-list.
*
* @param index position at which to insert the media item (counting from zero)
* @param mrl media resource locator
* @param mediaOptions zero or more media item options
*/
public void InsertMedia(int index, string mrl, params string[] mediaOptions)
{
Logger.Debug("InsertMedia(index={},mrl={},mediaOptions={})", index, mrl, mediaOptions);
try {
LockList();
// Create a new native media descriptor
IntPtr mediaDescriptor = newMediaDescriptor(mrl, mediaOptions);
// Insert the media descriptor into the media list
LibVlc.libvlc_media_list_insert_media(mediaListInstance, mediaDescriptor, index);
// Release the native reference
ReleaseMediaDescriptor(mediaDescriptor);
}
finally {
UnlockList();
}
}
/**
* Get the available audio outputs.
* <p>
* Each audio output has zero or more audio devices, each device having it's own unique
* identifier that can be used on a media player to set the select the required output device.
*
* @return collection of audio outputs
*/
public List <AudioOutput> GetAudioOutputs()
{
Logger.Debug("GetAudioOutputs()");
List <AudioOutput> result = new List <AudioOutput>();
IntPtr audioOutputsPtr = LibVlc.libvlc_audio_output_list_get(instance);
IntPtr audioOutputPtr = audioOutputsPtr;
while (audioOutputPtr != IntPtr.Zero)
{
libvlc_audio_output_t audioOutput = (libvlc_audio_output_t)Marshal.PtrToStructure(audioOutputPtr, typeof(libvlc_audio_output_t));
string name = NativeString.String(audioOutput.psz_name);
result.Add(new AudioOutput(name, NativeString.String(audioOutput.psz_description), GetAudioOutputDevices(name)));
audioOutputPtr = audioOutput.p_next;
}
LibVlc.libvlc_audio_output_list_release(audioOutputsPtr);
return(result);
}
/**
* Get the devices associated with an audio output.
*
* @param outputName output
* @return collection of audio output devices
*/
private List <AudioDevice> GetAudioOutputDevices(string outputName)
{
Logger.Debug("GetAudioOutputDevices(outputName={})", outputName);
IntPtr outputNamePtr = NativeString.StringPointer(outputName);
int deviceCount = LibVlc.libvlc_audio_output_device_count(instance, outputNamePtr);
Logger.Debug("deviceCount={}", deviceCount);
List <AudioDevice> result = new List <AudioDevice>(deviceCount);
for (int i = 0; i < deviceCount; i++)
{
string deviceId = NativeString.GetNativeString(LibVlc.libvlc_audio_output_device_id(instance, outputNamePtr, i));
string longName = NativeString.GetNativeString(LibVlc.libvlc_audio_output_device_longname(instance, outputNamePtr, i));
result.Add(new AudioDevice(deviceId, longName));
}
return(result);
}
/**
*
*/
private void RegisterEventListener()
{
Logger.Debug("RegisterEventListener()");
callback = new VlcVideoPlayerCallbackDelegate(HandleEvent);
IntPtr callbackPtr = Marshal.GetFunctionPointerForDelegate(callback);
foreach (int value in Enum.GetValues(typeof(libvlc_event_e)))
{
// The native event manager reports that it does not support
// libvlc_MediaListPlayerPlayed or libvlc_MediaListPlayerStopped
if (value >= (int)libvlc_event_e.libvlc_MediaListPlayerNextItemSet && value <= (int)libvlc_event_e.libvlc_MediaListPlayerNextItemSet)
{
Logger.Debug("event={}", (libvlc_event_e)value);
int result = LibVlc.libvlc_event_attach(mediaListPlayerEventManager, value, callbackPtr, IntPtr.Zero);
Logger.Debug("result={}", result);
}
}
}
/**
* Get the list of items.
*
* @return list of items
*/
// FIXME readonly collection?
public List <MediaListItem> Items()
{
Logger.Debug("Items()");
List <MediaListItem> result = new List <MediaListItem>();
try {
LockList();
for (int i = 0; i < LibVlc.libvlc_media_list_count(mediaListInstance); i++)
{
IntPtr mediaInstance = LibVlc.libvlc_media_list_item_at_index(mediaListInstance, i);
result.Add(NewMediaListItem(mediaInstance));
}
}
finally {
UnlockList();
}
return(result);
}
public void Play(string mediaPath, IntPtr hWnd)
{
if (!playing)
{
IntPtr media = LibVlc.libvlc_media_new_path(instance, mediaPath);
player = LibVlc.libvlc_media_player_new_from_media(media);
LibVlc.libvlc_media_release(media);
LibVlc.libvlc_media_player_set_hwnd(player, hWnd);
LibVlc.libvlc_media_player_play(player);
playing = true;
}
else
{
throw new InvalidOperationException("VLC is currently playing media");
}
}
/**
* Remove a media item from the play-list.
*
* @param index item to remove (counting from zero)
*/
public void RemoveMedia(int index)
{
Logger.Debug("RemoveMedia(index={})", index);
try {
LockList();
IntPtr oldMediaInstance = LibVlc.libvlc_media_list_item_at_index(mediaListInstance, index);
if (oldMediaInstance != IntPtr.Zero)
{
// Remove the media descriptor from the media list
LibVlc.libvlc_media_list_remove_index(mediaListInstance, index);
// Release the native media instance
LibVlc.libvlc_media_release(oldMediaInstance);
}
}
finally {
UnlockList();
}
}
/**
*
*/
private void DeregisterEventListener()
{
Logger.Debug("DeregisterEventListener()");
if (callback != null)
{
IntPtr callbackPtr = Marshal.GetFunctionPointerForDelegate(callback);
foreach (int value in Enum.GetValues(typeof(libvlc_event_e)))
{
// The native event manager reports that it does not support
// libvlc_MediaListPlayerPlayed or libvlc_MediaListPlayerStopped
if (value >= (int)libvlc_event_e.libvlc_MediaListPlayerNextItemSet && value <= (int)libvlc_event_e.libvlc_MediaListPlayerNextItemSet)
{
Logger.Debug("event={}", (libvlc_event_e)value);
LibVlc.libvlc_event_detach(mediaListPlayerEventManager, value, callbackPtr, IntPtr.Zero);
}
}
callback = null;
}
}
/**
* Set the application name.
*
* @param userAgent application name
* @param httpUserAgent application name for HTTP
*/
public void SetUserAgent(string userAgent, string httpUserAgent)
{
Logger.Debug("SetUserAgent(userAgent={},httpUserAgent)", userAgent, httpUserAgent);
IntPtr userAgentPtr = IntPtr.Zero;
IntPtr httpUserAgentPtr = IntPtr.Zero;
try {
userAgentPtr = NativeString.StringPointer(userAgent);
if (httpUserAgent != null)
{
httpUserAgentPtr = NativeString.StringPointer(httpUserAgent);
}
LibVlc.libvlc_set_user_agent(instance, userAgentPtr, httpUserAgentPtr);
}
finally {
NativeString.Release(httpUserAgentPtr);
NativeString.Release(userAgentPtr);
}
}
/**
*
*/
private void DestroyInstance()
{
Logger.Debug("DestroyInstance()");
Logger.Debug("Detach events...");
DeregisterEventListener();
Logger.Debug("Events detached.");
eventListenerList.Clear();
if (mediaListPlayerInstance != IntPtr.Zero)
{
Logger.Debug("Release media list player...");
LibVlc.libvlc_media_list_player_release(mediaListPlayerInstance);
Logger.Debug("Media list player released");
}
Logger.Debug("Shut down listeners...");
listenersService.Shutdown();
Logger.Debug("Listeners shut down.");
}
public void SetMode(MediaListPlayerMode mode)
{
Logger.Debug("SetMode(mode={})", mode);
libvlc_playback_mode_e playbackMode;
switch (mode)
{
case MediaListPlayerMode.DEFAULT:
playbackMode = libvlc_playback_mode_e.libvlc_playback_mode_default;
break;
case MediaListPlayerMode.LOOP:
playbackMode = libvlc_playback_mode_e.libvlc_playback_mode_loop;
break;
case MediaListPlayerMode.REPEAT:
playbackMode = libvlc_playback_mode_e.libvlc_playback_mode_repeat;
break;
default:
throw new ArgumentException("Invalid mode " + mode);
}
LibVlc.libvlc_media_list_player_set_playback_mode(mediaListPlayerInstance, (int)playbackMode);
}
public void Parse()
{
Logger.Debug("parse()");
LibVlc.libvlc_media_parse(media);
}
/**
* Create media meta.
*
* @param media media instance
*/
public DefaultMediaMeta(IntPtr media)
{
this.media = media;
// Keep a native reference
LibVlc.libvlc_media_retain(media);
}
/* protected void finalize() throws Throwable {
* Logger.Debug("finalize()");
* Logger.Debug("Meta data has been garbage collected");
* // FIXME should this invoke release()?
* }*/
/**
* Get a local meta data value for a media instance.
*
* @param metaType type of meta data
* @return meta data value
*/
private string GetMeta(libvlc_meta_e metaType)
{
Logger.Trace("GetMeta(metaType={},media={})", metaType, media);
return(NativeString.GetNativeString(LibVlc.libvlc_media_get_meta(media, (int)metaType)));
}
