diff --git a/gstreamer-sharp/Gstreamer.metadata b/gstreamer-sharp/Gstreamer.metadata index 4c2c7dfa0c..15e927a3ce 100644 --- a/gstreamer-sharp/Gstreamer.metadata +++ b/gstreamer-sharp/Gstreamer.metadata @@ -1002,6 +1002,8 @@ 1 GstMixerTrack GstMixerTrack + + MixerType @@ -1009,7 +1011,16 @@ MixerMessageType - 1 + MixerTrack + 1 + + MixerOptions + 1 + 1 + gchar* + gchar* + /api/namespace/interface[@cname='GstMixer'] + 1 1 1 diff --git a/gstreamer-sharp/Makefile.am b/gstreamer-sharp/Makefile.am index 4c4174f73b..1c948c57c8 100644 --- a/gstreamer-sharp/Makefile.am +++ b/gstreamer-sharp/Makefile.am @@ -49,13 +49,16 @@ sources = \ PadQueryTypeFunction.cs \ TypeFindDelegates.cs \ PresetDefault.cs \ + MixerMessage.cs \ coreplugins/*.cs \ baseplugins/*.cs overrides = \ override/URIHandlerAdapter.cs \ override/ColorBalanceAdapter.cs \ - override/ColorBalance.cs + override/ColorBalance.cs \ + override/Mixer.cs \ + override/MixerAdapter.cs build_sources = $(addprefix $(srcdir)/, $(sources)) @@ -87,7 +90,8 @@ customs = \ Tag.custom \ TagList.custom \ TypeFind.custom \ - TypeFindFactory.custom + TypeFindFactory.custom \ + MixerTrack.custom build_customs = $(addprefix $(srcdir)/, $(customs)) diff --git a/gstreamer-sharp/MixerMessage.cs b/gstreamer-sharp/MixerMessage.cs new file mode 100644 index 0000000000..e19450d479 --- /dev/null +++ b/gstreamer-sharp/MixerMessage.cs @@ -0,0 +1,81 @@ +namespace Gst.Interfaces { + + using System; + using System.Runtime.InteropServices; + using System.Reflection; + using GLib; + using Gst; + using Gst.Interfaces; + + public static class MixerMessage { + [DllImport("gstreamer-0.10.dll")] + static extern int gst_mixer_message_get_type(IntPtr message); + + public static Gst.Interfaces.MixerMessageType MessageGetType(Gst.Message message) { + int raw_ret = gst_mixer_message_get_type(message == null ? IntPtr.Zero : message.Handle); + Gst.Interfaces.MixerMessageType ret = (Gst.Interfaces.MixerMessageType) raw_ret; + return ret; + } + + [DllImport("gstreamer-0.10.dll")] + static extern void gst_mixer_message_parse_mute_toggled(IntPtr message, out IntPtr track, out bool mute); + + public static void ParseMuteToggled(Gst.Message message, out Gst.Interfaces.MixerTrack track, out bool mute) { + IntPtr native_ptr; + + gst_mixer_message_parse_mute_toggled (message == null ? IntPtr.Zero : message.Handle, out native_ptr, out mute); + + track = (MixerTrack) GLib.Object.GetObject (native_ptr, false); + } + + [DllImport("gstreamer-0.10.dll")] + static extern void gst_mixer_message_parse_option_changed(IntPtr message, out IntPtr options, out IntPtr value); + + public static void MessageParseOptionChanged(Gst.Message message, out Gst.Interfaces.MixerOptions options, out string value) { + IntPtr native_value; + IntPtr native_options; + + gst_mixer_message_parse_option_changed(message == null ? IntPtr.Zero : message.Handle, out native_options, out native_value); + + options = (MixerOptions) GLib.Object.GetObject (native_options, false); + value = GLib.Marshaller.Utf8PtrToString (native_value); + } + + [DllImport("gstreamer-0.10.dll")] + static extern void gst_mixer_message_parse_record_toggled(IntPtr message, out IntPtr track, out bool record); + + public static void MessageParseRecordToggled(Gst.Message message, out Gst.Interfaces.MixerTrack track, out bool record) { + IntPtr native_ptr; + + gst_mixer_message_parse_record_toggled(message == null ? IntPtr.Zero : message.Handle, out native_ptr, out record); + track = (MixerTrack) GLib.Object.GetObject (native_ptr, false); + } + + [DllImport("gstreamer-0.10.dll")] + static extern void gst_mixer_message_parse_volume_changed(IntPtr message, out IntPtr track, out IntPtr volumes, out int num_channels); + + public static void MessageParseVolumeChanged(Gst.Message message, out Gst.Interfaces.MixerTrack track, out int[] volumes) { + IntPtr native_track; + IntPtr native_volumes; + int n_native_volumes; + + gst_mixer_message_parse_volume_changed(message == null ? IntPtr.Zero : message.Handle, out native_track, out native_volumes, out n_native_volumes); + + track = (MixerTrack) GLib.Object.GetObject (native_track, false); + volumes = new int[n_native_volumes]; + for (int i = 0; i < n_native_volumes; i++) + volumes[i] = Marshal.ReadInt32 (native_volumes, i * 4); + GLib.Marshaller.Free (native_volumes); + } + + [DllImport("gstreamer-0.10.dll")] + static extern void gst_mixer_message_parse_options_list_changed(IntPtr message, out IntPtr options); + + public static void MessageParseOptionsListChanged(Gst.Message message, out Gst.Interfaces.MixerOptions options) { + IntPtr native_options; + + gst_mixer_message_parse_options_list_changed(message == null ? IntPtr.Zero : message.Handle, out native_options); + options = (MixerOptions) GLib.Object.GetObject (native_options, false); + } + } +} diff --git a/gstreamer-sharp/MixerTrack.custom b/gstreamer-sharp/MixerTrack.custom new file mode 100644 index 0000000000..28581d9854 --- /dev/null +++ b/gstreamer-sharp/MixerTrack.custom @@ -0,0 +1,45 @@ +[DllImport ("gstreamersharpglue-0.10") ] +extern static uint gst__interfacessharp_gst__interfaces_mixertrack_get_label_offset (); +static uint label_offset = gst__interfacessharp_gst__interfaces_mixertrack_get_label_offset (); +[DllImport ("gstreamersharpglue-0.10") ] +extern static uint gst__interfacessharp_gst__interfaces_mixertrack_get_flags_offset (); +static uint flags_offset = gst__interfacessharp_gst__interfaces_mixertrack_get_flags_offset (); +[DllImport ("gstreamersharpglue-0.10") ] +extern static uint gst__interfacessharp_gst__interfaces_mixertrack_get_num_channels_offset (); +static uint num_channels_offset = gst__interfacessharp_gst__interfaces_mixertrack_get_num_channels_offset (); +[DllImport ("gstreamersharpglue-0.10") ] +extern static uint gst__interfacessharp_gst__interfaces_mixertrack_get_min_volume_offset (); +static uint min_volume_offset = gst__interfacessharp_gst__interfaces_mixertrack_get_min_volume_offset (); +[DllImport ("gstreamersharpglue-0.10") ] +extern static uint gst__interfacessharp_gst__interfaces_mixertrack_get_max_volume_offset (); +static uint max_volume_offset = gst__interfacessharp_gst__interfaces_mixertrack_get_max_volume_offset (); + +public MixerTrack (uint index, string untranslated_label, string label, MixerTrackFlags flags, int num_channels, int min_volume, int max_volume) : base (IntPtr.Zero) { + CreateNativeObject (new string [] {"index", "untranslated-label"}, new GLib.Value [] { new GLib.Value (index), new GLib.Value (untranslated_label) }); + + unsafe { + IntPtr* raw_ptr = (IntPtr*) ( ( (byte*) Handle) + label_offset); + *raw_ptr = GLib.Marshaller.StringToPtrGStrdup (label); + } + + unsafe { + int* raw_ptr = (int*) ( ( (byte*) Handle) + flags_offset); + *raw_ptr = (int) flags; + } + + unsafe { + int* raw_ptr = (int*) ( ( (byte*) Handle) + num_channels_offset); + *raw_ptr = num_channels; + } + + unsafe { + int* raw_ptr = (int*) ( ( (byte*) Handle) + min_volume_offset); + *raw_ptr = min_volume; + } + + unsafe { + int* raw_ptr = (int*) ( ( (byte*) Handle) + max_volume_offset); + *raw_ptr = max_volume; + } + +} diff --git a/gstreamer-sharp/glue/Makefile.am b/gstreamer-sharp/glue/Makefile.am index 98f3371055..98fe6cd239 100644 --- a/gstreamer-sharp/glue/Makefile.am +++ b/gstreamer-sharp/glue/Makefile.am @@ -15,7 +15,8 @@ libgstreamersharpglue_0_10_la_SOURCES = \ gobject.c \ typefind.c \ indexentry.c \ - indexfactory.c + indexfactory.c \ + mixertrack.c nodist_libgstreamersharpglue_0_10_la_SOURCES = generated.c diff --git a/gstreamer-sharp/glue/mixertrack.c b/gstreamer-sharp/glue/mixertrack.c new file mode 100644 index 0000000000..787ed8bb23 --- /dev/null +++ b/gstreamer-sharp/glue/mixertrack.c @@ -0,0 +1,28 @@ +#include +#include + +uint +gst__interfacessharp_gst__interfaces_mixertrack_get_label_offset (void) { + return (uint) G_STRUCT_OFFSET (GstMixerTrack, label); +} + +uint +gst__interfacessharp_gst__interfaces_mixertrack_get_flags_offset (void) { + return (uint) G_STRUCT_OFFSET (GstMixerTrack, flags); +} + +uint +gst__interfacessharp_gst__interfaces_mixertrack_get_num_channels_offset (void) { + return (uint) G_STRUCT_OFFSET (GstMixerTrack, num_channels); +} + +uint +gst__interfacessharp_gst__interfaces_mixertrack_get_min_volume_offset (void) { + return (uint) G_STRUCT_OFFSET (GstMixerTrack, min_volume); +} + +uint +gst__interfacessharp_gst__interfaces_mixertrack_get_max_volume_offset (void) { + return (uint) G_STRUCT_OFFSET (GstMixerTrack, max_volume); +} + diff --git a/gstreamer-sharp/override/Mixer.cs b/gstreamer-sharp/override/Mixer.cs new file mode 100644 index 0000000000..b807043f66 --- /dev/null +++ b/gstreamer-sharp/override/Mixer.cs @@ -0,0 +1,44 @@ +// This file was generated by the Gtk# code generator. +// Changed to include the MixerType property + +namespace Gst.Interfaces { + + using System; + +#region Autogenerated code + public interface Mixer : GLib.IWrapper { + Gst.Interfaces.MixerType MixerType { + get; + } + void VolumeChanged(Gst.Interfaces.MixerTrack track, int[] volumes); + Gst.Interfaces.MixerTrack[] ListTracks(); + void SetOption(Gst.Interfaces.MixerOptions opts, string value); + void SetVolume(Gst.Interfaces.MixerTrack track, int[] volumes); + void MuteToggled(Gst.Interfaces.MixerTrack track, bool mute); + void OptionChanged(Gst.Interfaces.MixerOptions opts, string value); + void OptionsListChanged(Gst.Interfaces.MixerOptions opts); + string GetOption(Gst.Interfaces.MixerOptions opts); + void SetRecord(Gst.Interfaces.MixerTrack track, bool record); + void RecordToggled(Gst.Interfaces.MixerTrack track, bool record); + int[] GetVolume(Gst.Interfaces.MixerTrack track); + Gst.Interfaces.MixerFlags MixerFlags { + get; + } + void MixerChanged(); + void SetMute(Gst.Interfaces.MixerTrack track, bool mute); + } + + [GLib.GInterface (typeof (MixerAdapter))] + public interface MixerImplementor : GLib.IWrapper { + + Gst.Interfaces.MixerTrack[] ListTracks (); + void SetVolume (Gst.Interfaces.MixerTrack track, int[] volumes); + int[] GetVolume (Gst.Interfaces.MixerTrack track); + void SetMute (Gst.Interfaces.MixerTrack track, bool mute); + void SetRecord (Gst.Interfaces.MixerTrack track, bool record); + void SetOption (Gst.Interfaces.MixerOptions opts, string value); + string GetOption (Gst.Interfaces.MixerOptions opts); + Gst.Interfaces.MixerFlags MixerFlags { get; } + } +#endregion +} diff --git a/gstreamer-sharp/override/MixerAdapter.cs b/gstreamer-sharp/override/MixerAdapter.cs new file mode 100644 index 0000000000..d873dd70cf --- /dev/null +++ b/gstreamer-sharp/override/MixerAdapter.cs @@ -0,0 +1,413 @@ +// This file was generated by the Gtk# code generator. +// Any changes made will be lost if regenerated. + +namespace Gst.Interfaces { + + using System; + using System.Runtime.InteropServices; + using System.Reflection; + +#region Autogenerated code + public class MixerAdapter : GLib.GInterfaceAdapter, Gst.Interfaces.Mixer { + + [StructLayout (LayoutKind.Sequential)] + struct GstMixerClass { + public Gst.Interfaces.MixerType MixerType; + public ListTracksNativeDelegate ListTracks; + public SetVolumeNativeDelegate SetVolume; + public GetVolumeNativeDelegate GetVolume; + public SetMuteNativeDelegate SetMute; + public SetRecordNativeDelegate SetRecord; + IntPtr MuteToggled; + IntPtr RecordToggled; + IntPtr VolumeChanged; + public SetOptionNativeDelegate SetOption; + public GetOptionNativeDelegate GetOption; + IntPtr OptionChanged; + public GetMixerFlagsNativeDelegate GetMixerFlags; + [MarshalAs (UnmanagedType.ByValArray, SizeConst=3)] + public IntPtr[] GstReserved; + } + + static GstMixerClass iface; + + static MixerAdapter () + { + GLib.GType.Register (_gtype, typeof(MixerAdapter)); + iface.ListTracks = new ListTracksNativeDelegate (ListTracks_cb); + iface.SetVolume = new SetVolumeNativeDelegate (SetVolume_cb); + iface.GetVolume = new GetVolumeNativeDelegate (GetVolume_cb); + iface.SetMute = new SetMuteNativeDelegate (SetMute_cb); + iface.SetRecord = new SetRecordNativeDelegate (SetRecord_cb); + iface.SetOption = new SetOptionNativeDelegate (SetOption_cb); + iface.GetOption = new GetOptionNativeDelegate (GetOption_cb); + iface.GetMixerFlags = new GetMixerFlagsNativeDelegate (GetMixerFlags_cb); + } + + [GLib.CDeclCallback] + delegate IntPtr ListTracksNativeDelegate (IntPtr inst); + + static IntPtr ListTracks_cb (IntPtr inst) + { + try { + MixerImplementor __obj = GLib.Object.GetObject (inst, false) as MixerImplementor; + Gst.Interfaces.MixerTrack[] __result = __obj.ListTracks (); + GLib.List ret = new GLib.List(__result, typeof (Gst.Interfaces.MixerTrack), false, false); + if (ret == null) + return IntPtr.Zero; + return ret.Handle; + } catch (Exception e) { + GLib.ExceptionManager.RaiseUnhandledException (e, true); + // NOTREACHED: above call does not return. + throw e; + } + } + + [GLib.CDeclCallback] + delegate void SetVolumeNativeDelegate (IntPtr inst, IntPtr track, IntPtr volumes); + + static void SetVolume_cb (IntPtr inst, IntPtr track, IntPtr volumes) + { + try { + MixerImplementor __obj = GLib.Object.GetObject (inst, false) as MixerImplementor; + MixerTrack managed_track = GLib.Object.GetObject (track) as MixerTrack; + int[] managed_volumes = new int[managed_track.NumChannels]; + Marshal.Copy (volumes, managed_volumes, 0, managed_track.NumChannels); + __obj.SetVolume (managed_track, managed_volumes); + } catch (Exception e) { + GLib.ExceptionManager.RaiseUnhandledException (e, true); + // NOTREACHED: above call does not return. + throw e; + } + } + + [GLib.CDeclCallback] + delegate void GetVolumeNativeDelegate (IntPtr inst, IntPtr track, out IntPtr volumes); + + static void GetVolume_cb (IntPtr inst, IntPtr track, out IntPtr volumes) + { + try { + MixerImplementor __obj = GLib.Object.GetObject (inst, false) as MixerImplementor; + MixerTrack managed_track = GLib.Object.GetObject (track) as MixerTrack; + + int[] managed_volumes = __obj.GetVolume (managed_track); + + volumes = GLib.Marshaller.Malloc ((ulong) (4 * managed_track.NumChannels)); + Marshal.Copy (managed_volumes, 0, volumes, managed_track.NumChannels); + } catch (Exception e) { + GLib.ExceptionManager.RaiseUnhandledException (e, true); + // NOTREACHED: above call does not return. + throw e; + } + } + + [GLib.CDeclCallback] + delegate void SetMuteNativeDelegate (IntPtr inst, IntPtr track, bool mute); + + static void SetMute_cb (IntPtr inst, IntPtr track, bool mute) + { + try { + MixerImplementor __obj = GLib.Object.GetObject (inst, false) as MixerImplementor; + __obj.SetMute (GLib.Object.GetObject(track) as Gst.Interfaces.MixerTrack, mute); + } catch (Exception e) { + GLib.ExceptionManager.RaiseUnhandledException (e, false); + } + } + + [GLib.CDeclCallback] + delegate void SetRecordNativeDelegate (IntPtr inst, IntPtr track, bool record); + + static void SetRecord_cb (IntPtr inst, IntPtr track, bool record) + { + try { + MixerImplementor __obj = GLib.Object.GetObject (inst, false) as MixerImplementor; + __obj.SetRecord (GLib.Object.GetObject(track) as Gst.Interfaces.MixerTrack, record); + } catch (Exception e) { + GLib.ExceptionManager.RaiseUnhandledException (e, false); + } + } + + [GLib.CDeclCallback] + delegate void SetOptionNativeDelegate (IntPtr inst, IntPtr opts, IntPtr value); + + static void SetOption_cb (IntPtr inst, IntPtr opts, IntPtr value) + { + try { + MixerImplementor __obj = GLib.Object.GetObject (inst, false) as MixerImplementor; + __obj.SetOption (GLib.Object.GetObject(opts) as Gst.Interfaces.MixerOptions, GLib.Marshaller.PtrToStringGFree(value)); + } catch (Exception e) { + GLib.ExceptionManager.RaiseUnhandledException (e, false); + } + } + + [GLib.CDeclCallback] + delegate IntPtr GetOptionNativeDelegate (IntPtr inst, IntPtr opts); + + static IntPtr GetOption_cb (IntPtr inst, IntPtr opts) + { + try { + MixerImplementor __obj = GLib.Object.GetObject (inst, false) as MixerImplementor; + string __result = __obj.GetOption (GLib.Object.GetObject(opts) as Gst.Interfaces.MixerOptions); + return GLib.Marshaller.StringToPtrGStrdup(__result); + } catch (Exception e) { + GLib.ExceptionManager.RaiseUnhandledException (e, true); + // NOTREACHED: above call does not return. + throw e; + } + } + + [GLib.CDeclCallback] + delegate int GetMixerFlagsNativeDelegate (IntPtr inst); + + static int GetMixerFlags_cb (IntPtr inst) + { + try { + MixerImplementor __obj = GLib.Object.GetObject (inst, false) as MixerImplementor; + Gst.Interfaces.MixerFlags __result = __obj.MixerFlags; + return (int) __result; + } catch (Exception e) { + GLib.ExceptionManager.RaiseUnhandledException (e, true); + // NOTREACHED: above call does not return. + throw e; + } + } + + static int class_offset = 2 * IntPtr.Size; + + static void Initialize (IntPtr ptr, IntPtr data) + { + IntPtr ifaceptr = new IntPtr (ptr.ToInt64 () + class_offset); + GstMixerClass native_iface = (GstMixerClass) Marshal.PtrToStructure (ifaceptr, typeof (GstMixerClass)); + native_iface.ListTracks = iface.ListTracks; + native_iface.SetVolume = iface.SetVolume; + native_iface.GetVolume = iface.GetVolume; + native_iface.SetMute = iface.SetMute; + native_iface.SetRecord = iface.SetRecord; + native_iface.SetOption = iface.SetOption; + native_iface.GetOption = iface.GetOption; + native_iface.GetMixerFlags = iface.GetMixerFlags; + + GCHandle gch = (GCHandle) data; + MixerAdapter adapter = gch.Target as MixerAdapter; + PropertyInfo pi = adapter.Type.GetProperty ("MixerType", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.FlattenHierarchy); + if (pi != null && pi.PropertyType == typeof (Gst.Interfaces.MixerType)) + native_iface.MixerType = (Gst.Interfaces.MixerType) pi.GetValue (null, null); + + Marshal.StructureToPtr (native_iface, ifaceptr, false); + gch.Free (); + } + + public MixerAdapter () + { + InitHandler = new GLib.GInterfaceInitHandler (Initialize); + } + + MixerImplementor implementor; + + public MixerAdapter (MixerImplementor implementor) + { + if (implementor == null) + throw new ArgumentNullException ("implementor"); + this.implementor = implementor; + } + + public MixerAdapter (IntPtr handle) + { + if (!_gtype.IsInstance (handle)) + throw new ArgumentException ("The gobject doesn't implement the GInterface of this adapter", "handle"); + this.handle = handle; + } + + [DllImport("gstreamer-0.10.dll")] + static extern IntPtr gst_mixer_get_type(); + + private static GLib.GType _gtype = new GLib.GType (gst_mixer_get_type ()); + + public override GLib.GType GType { + get { + return _gtype; + } + } + + IntPtr handle; + public override IntPtr Handle { + get { + if (handle != IntPtr.Zero) + return handle; + return implementor == null ? IntPtr.Zero : implementor.Handle; + } + } + + public static Mixer GetObject (IntPtr handle, bool owned) + { + GLib.Object obj = GLib.Object.GetObject (handle, owned); + return GetObject (obj); + } + + public static Mixer GetObject (GLib.Object obj) + { + if (obj == null) + return null; + else if (obj is MixerImplementor) + return new MixerAdapter (obj as MixerImplementor); + else if (obj as Mixer == null) + return new MixerAdapter (obj.Handle); + else + return obj as Mixer; + } + + public MixerImplementor Implementor { + get { + return implementor; + } + } + + [DllImport("gstreamer-0.10.dll")] + static extern void gst_mixer_volume_changed(IntPtr raw, IntPtr track, IntPtr volumes); + + public void VolumeChanged(Gst.Interfaces.MixerTrack track, int[] volumes) { + if (track == null) + return; + + if (volumes.Length != track.NumChannels) + throw new ArgumentOutOfRangeException (); + + IntPtr native_volumes = GLib.Marshaller.Malloc ((ulong) (4 * track.NumChannels)); + Marshal.Copy (volumes, 0, native_volumes, track.NumChannels); + gst_mixer_volume_changed(Handle, track.Handle, native_volumes); + GLib.Marshaller.Free (native_volumes); + } + + [DllImport("gstreamer-0.10.dll")] + static extern IntPtr gst_mixer_list_tracks(IntPtr raw); + + public Gst.Interfaces.MixerTrack[] ListTracks() { + IntPtr raw_ret = gst_mixer_list_tracks(Handle); + Gst.Interfaces.MixerTrack[] ret = (Gst.Interfaces.MixerTrack[]) GLib.Marshaller.ListPtrToArray (raw_ret, typeof(GLib.List), false, false, typeof(Gst.Interfaces.MixerTrack)); + return ret; + } + + [DllImport("gstreamer-0.10.dll")] + static extern void gst_mixer_set_option(IntPtr raw, IntPtr opts, IntPtr value); + + public void SetOption(Gst.Interfaces.MixerOptions opts, string value) { + gst_mixer_set_option(Handle, opts == null ? IntPtr.Zero : opts.Handle, GLib.Marshaller.StringToPtrGStrdup(value)); + } + + [DllImport("gstreamer-0.10.dll")] + static extern void gst_mixer_set_volume(IntPtr raw, IntPtr track, IntPtr volumes); + + public void SetVolume(Gst.Interfaces.MixerTrack track, int[] volumes) { + if (track == null) + return; + + if (volumes.Length != track.NumChannels) + throw new ArgumentOutOfRangeException (); + + IntPtr volumes_native = GLib.Marshaller.Malloc ((ulong) (4 * track.NumChannels)); + Marshal.Copy (volumes, 0, volumes_native, track.NumChannels); + + gst_mixer_set_volume(Handle, track.Handle, volumes_native); + GLib.Marshaller.Free (volumes_native); + } + + [DllImport("gstreamer-0.10.dll")] + static extern void gst_mixer_mute_toggled(IntPtr raw, IntPtr track, bool mute); + + public void MuteToggled(Gst.Interfaces.MixerTrack track, bool mute) { + gst_mixer_mute_toggled(Handle, track == null ? IntPtr.Zero : track.Handle, mute); + } + + [DllImport("gstreamer-0.10.dll")] + static extern void gst_mixer_option_changed(IntPtr raw, IntPtr opts, IntPtr value); + + public void OptionChanged(Gst.Interfaces.MixerOptions opts, string value) { + gst_mixer_option_changed(Handle, opts == null ? IntPtr.Zero : opts.Handle, GLib.Marshaller.StringToPtrGStrdup(value)); + } + + [DllImport("gstreamer-0.10.dll")] + static extern void gst_mixer_options_list_changed(IntPtr raw, IntPtr opts); + + public void OptionsListChanged(Gst.Interfaces.MixerOptions opts) { + gst_mixer_options_list_changed(Handle, opts == null ? IntPtr.Zero : opts.Handle); + } + + [DllImport("gstreamer-0.10.dll")] + static extern IntPtr gst_mixer_get_option(IntPtr raw, IntPtr opts); + + public string GetOption(Gst.Interfaces.MixerOptions opts) { + IntPtr raw_ret = gst_mixer_get_option(Handle, opts == null ? IntPtr.Zero : opts.Handle); + string ret = GLib.Marshaller.Utf8PtrToString (raw_ret); + return ret; + } + + [DllImport("gstreamer-0.10.dll")] + static extern void gst_mixer_set_record(IntPtr raw, IntPtr track, bool record); + + public void SetRecord(Gst.Interfaces.MixerTrack track, bool record) { + gst_mixer_set_record(Handle, track == null ? IntPtr.Zero : track.Handle, record); + } + + [DllImport("gstreamer-0.10.dll")] + static extern void gst_mixer_record_toggled(IntPtr raw, IntPtr track, bool record); + + public void RecordToggled(Gst.Interfaces.MixerTrack track, bool record) { + gst_mixer_record_toggled(Handle, track == null ? IntPtr.Zero : track.Handle, record); + } + + [DllImport("gstreamer-0.10.dll")] + static extern void gst_mixer_get_volume(IntPtr raw, IntPtr track, ref IntPtr volumes); + + public int[] GetVolume(Gst.Interfaces.MixerTrack track) { + if (track == null) + return null; + + IntPtr native_volumes = GLib.Marshaller.Malloc ((ulong) (4 * track.NumChannels)); + gst_mixer_get_volume(Handle, track.Handle, ref native_volumes); + + int[] volumes = new int[track.NumChannels]; + Marshal.Copy (native_volumes, volumes, 0, track.NumChannels); + GLib.Marshaller.Free (native_volumes); + return volumes; + } + + [DllImport("gstreamer-0.10.dll")] + static extern int gst_mixer_get_mixer_flags(IntPtr raw); + + public Gst.Interfaces.MixerFlags MixerFlags { + get { + int raw_ret = gst_mixer_get_mixer_flags(Handle); + Gst.Interfaces.MixerFlags ret = (Gst.Interfaces.MixerFlags) raw_ret; + return ret; + } + } + + [DllImport("gstreamer-0.10.dll")] + static extern void gst_mixer_mixer_changed(IntPtr raw); + + public void MixerChanged() { + gst_mixer_mixer_changed(Handle); + } + + [DllImport("gstreamer-0.10.dll")] + static extern void gst_mixer_set_mute(IntPtr raw, IntPtr track, bool mute); + + public void SetMute(Gst.Interfaces.MixerTrack track, bool mute) { + gst_mixer_set_mute(Handle, track == null ? IntPtr.Zero : track.Handle, mute); + } + + [DllImport("libgobject-2.0-0.dll")] + static extern IntPtr g_type_interface_peek (IntPtr klass, IntPtr iface_gtype); + public Gst.Interfaces.MixerType MixerType { + get { + IntPtr gclass = Marshal.ReadIntPtr (Handle); + IntPtr ifaceptr = g_type_interface_peek (gclass, _gtype.Val); + GstMixerClass native_iface = (GstMixerClass) Marshal.PtrToStructure (ifaceptr, typeof (GstMixerClass)); + + return native_iface.MixerType; + } + } + +#endregion + } +}