git.sesse.net Git - vlc/blob - bindings/cil/src/marshal.cs

   1 /**
   2  * @file marshal.cs
   3  * @brief Common LibVLC objects marshalling utilities
   4  * @ingroup Internals
   5  */
   6
   7 /**********************************************************************
   8  *  Copyright (C) 2007-2009 Rémi Denis-Courmont.                      *
   9  *  This program is free software; you can redistribute and/or modify *
  10  *  it under the terms of the GNU General Public License as published *
  11  *  by the Free Software Foundation; version 2 of the license, or (at *
  12  *  your option) any later version.                                   *
  13  *                                                                    *
  14  *  This program is distributed in the hope that it will be useful,   *
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of    *
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.              *
  17  *  See the GNU General Public License for more details.              *
  18  *                                                                    *
  19  *  You should have received a copy of the GNU General Public License *
  20  *  along with this program; if not, you can get it from:             *
  21  *  http://www.gnu.org/copyleft/gpl.html                              *
  22  **********************************************************************/
  23
  24 using System;
  25 using System.Collections;
  26 using System.Collections.Generic;
  27 using System.Runtime.InteropServices;
  28
  29 namespace VideoLAN.LibVLC
  30 {
  31     /**
  32      * @brief NonNullHandle: abstract safe handle class for non-NULL pointers
  33      * @ingroup Internals
  34      * Microsoft.* namespace has a similar class. However we want to use the
  35      * System.* namespace only.
  36      */
  37     internal abstract class NonNullHandle : SafeHandle
  38     {
  39         protected NonNullHandle ()
  40             : base (IntPtr.Zero, true)
  41         {
  42         }
  43
  44         /**
  45          * System.Runtime.InteropServices.SafeHandle::IsInvalid.
  46          */
  47         public override bool IsInvalid
  48         {
  49             get
  50             {
  51                 return handle == IntPtr.Zero;
  52             }
  53         }
  54
  55         /**
  56          * Destroys an handle. Cannot fail.
  57          */
  58         protected abstract void Destroy ();
  59
  60         /**
  61          * System.Runtime.InteropServices.SafeHandle::ReleaseHandle.
  62          */
  63         protected override bool ReleaseHandle ()
  64         {
  65             Destroy ();
  66             return true;
  67         }
  68     };
  69
  70     /**
  71      * @brief BaseObject: generic wrapper around a safe LibVLC handle.
  72      * @ingroup Internals
  73      *
  74      * This is the baseline for all managed LibVLC objects. It wraps:
  75      *  - an unmanaged LibVLC pointer,
  76      *  - a native exception structure.
  77      */
  78     public class BaseObject : IDisposable
  79     {
  80         internal NativeException ex; /**< buffer for LibVLC exceptions */
  81         internal SafeHandle handle; /**< wrapped safe handle */
  82
  83         internal BaseObject ()
  84         {
  85             ex = new NativeException ();
  86             this.handle = null;
  87         }
  88
  89         /**
  90          * Checks if the LibVLC run-time raised an exception
  91          * If so, raises a CIL exception.
  92          */
  93         internal void Raise ()
  94         {
  95             ex.Raise ();
  96         }
  97
  98         /**
  99          * IDisposable::Dispose.
 100          */
 101         public void Dispose ()
 102         {
 103             Dispose (true);
 104             GC.SuppressFinalize (this);
 105         }
 106
 107         /**
 108          * Releases unmanaged resources associated with the object.
 109          * @param disposing true if the disposing the object explicitly,
 110          *                  false if finalizing the object inside the GC.
 111          */
 112         protected virtual void Dispose (bool disposing)
 113         {
 114             if (disposing)
 115             {
 116                 ex.Dispose ();
 117                 if (handle != null)
 118                     handle.Close ();
 119             }
 120             ex = null;
 121             handle = null;
 122         }
 123     };
 124
 125     internal class EventManagerHandle : NonNullHandle
 126     {
 127         protected override void Destroy ()
 128         {
 129         }
 130     };
 131
 132
 133     /**
 134      * @brief EventingObject: wrapper around an eventing LibVLC handle.
 135      * @ingroup Internals
 136      *
 137      * This is the base class for all managed LibVLC objects which do have an
 138      * event manager.
 139      */
 140     public abstract class EventingObject : BaseObject
 141     {
 142         private Dictionary<Delegate, IntPtr> events;
 143         /**< references to our unmanaged function pointers */
 144
 145         internal EventingObject () : base ()
 146         {
 147             events = new Dictionary<Delegate, IntPtr> ();
 148         }
 149
 150         /**
 151          * Releases unmanaged resources associated with the object.
 152          * @param disposing true if the disposing the object explicitly,
 153          *                  false if finalizing the object inside the GC.
 154          */
 155         protected override void Dispose (bool disposing)
 156         {
 157             events = null;
 158             base.Dispose (disposing);
 159         }
 160
 161         /**
 162          * @return the unmanaged event manager for this object
 163          */
 164         internal abstract EventManagerHandle GetManager ();
 165
 166         /**
 167          * Registers an event handler.
 168          * @param type event type to register to
 169          * @param callback callback to invoke when the event occurs
 170          *
 171          * @note
 172          * For simplicity, we require distinct callbacks for each event type.
 173          * This is hardly an issue since most events have different formats.
 174          */
 175         internal void Attach (EventType type, Delegate callback)
 176         {
 177             EventManagerHandle manager;
 178             IntPtr cb = Marshal.GetFunctionPointerForDelegate (callback);
 179             bool unref = false;
 180
 181             /* If things go wrong, we will leak the callback thunk... until
 182              * this object is destroyed anyway. If we added the thunk _after_
 183              * the critical section, the native code could try to jump to a
 184              * non-existent address, which is much worse. */
 185             events.Add (callback, cb);
 186             try
 187             {
 188                 handle.DangerousAddRef (ref unref);
 189                 manager = GetManager ();
 190                 LibVLC.EventAttach (manager, type, cb, IntPtr.Zero, ex);
 191             }
 192             finally
 193             {
 194                 if (unref)
 195                     handle.DangerousRelease ();
 196             }
 197             Raise ();
 198         }
 199
 200         internal void Detach (EventType type, Delegate callback)
 201         {
 202             EventManagerHandle manager;
 203             IntPtr cb = events[callback];
 204             bool unref = false;
 205
 206             try
 207             {
 208                 handle.DangerousAddRef (ref unref);
 209                 manager = GetManager ();
 210                 LibVLC.EventDetach (manager, type, cb, IntPtr.Zero, ex);
 211             }
 212             finally
 213             {
 214                 if (unref)
 215                     handle.DangerousRelease ();
 216             }
 217             Raise ();
 218             events.Remove (callback);
 219         }
 220     };
 221 };