[chronojump] Add CesarPlayer
- From: Andoni Morales Alastruey <amorales src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [chronojump] Add CesarPlayer
- Date: Tue, 1 Feb 2011 01:11:29 +0000 (UTC)
commit b68b11451a39e1d8d6c19723840e5dec71cff84b
Author: Andoni Morales Alastruey <ylatuya gmail com>
Date: Wed Dec 15 23:53:47 2010 +0100
Add CesarPlayer
CesarPlayer/AssemblyInfo.cs.in | 50 +
CesarPlayer/Capturer/CaptureProperties.cs | 39 +
CesarPlayer/Capturer/FakeCapturer.cs | 120 ++
CesarPlayer/Capturer/GstCameraCapturer.cs | 489 +++++++
CesarPlayer/Capturer/ICapturer.cs | 93 ++
CesarPlayer/Capturer/LiveSourceTimer.cs | 87 ++
CesarPlayer/Capturer/ObjectManager.cs | 39 +
CesarPlayer/CesarPlayer.dll.config.in | 3 +
CesarPlayer/Common/Constants.cs | 28 +
CesarPlayer/Common/Enum.cs | 168 +++
CesarPlayer/Common/Handlers.cs | 106 ++
CesarPlayer/Editor/EditorState.cs | 32 +
CesarPlayer/Editor/GstVideoSplitter.cs | 433 ++++++
CesarPlayer/Editor/IVideoEditor.cs | 83 ++
CesarPlayer/Editor/IVideoSplitter.cs | 84 ++
CesarPlayer/Editor/VideoSegment.cs | 70 +
CesarPlayer/Gui/CapturerBin.cs | 362 +++++
CesarPlayer/Gui/PlayerBin.cs | 619 +++++++++
CesarPlayer/Gui/VolumeWindow.cs | 70 +
CesarPlayer/Makefile.am | 113 ++
CesarPlayer/MultimediaFactory.cs | 108 ++
CesarPlayer/Player/GstDVDEvent.cs | 46 +
CesarPlayer/Player/GstPlayer.cs | 1415 ++++++++++++++++++++
CesarPlayer/Player/IPlayer.cs | 146 ++
CesarPlayer/Player/ObjectManager.cs | 38 +
CesarPlayer/Utils/Device.cs | 90 ++
CesarPlayer/Utils/FramesCapturer.cs | 111 ++
CesarPlayer/Utils/IFramesCapturer.cs | 38 +
CesarPlayer/Utils/IMetadataReader.cs | 37 +
CesarPlayer/Utils/MediaFile.cs | 170 +++
CesarPlayer/Utils/PreviewMediaFile.cs | 120 ++
CesarPlayer/Utils/TimeString.cs | 83 ++
CesarPlayer/cesarplayer.key | Bin 0 -> 596 bytes
CesarPlayer/cesarplayer.pc.in | 6 +
CesarPlayer/gtk-gui/LongoMatch.Gui.CapturerBin.cs | 169 +++
CesarPlayer/gtk-gui/LongoMatch.Gui.PlayerBin.cs | 337 +++++
CesarPlayer/gtk-gui/LongoMatch.Gui.VolumeWindow.cs | 85 ++
CesarPlayer/gtk-gui/generated.cs | 115 ++
CesarPlayer/gtk-gui/gui.stetic | 451 +++++++
CesarPlayer/gtk-gui/objects.xml | 31 +
40 files changed, 6684 insertions(+), 0 deletions(-)
---
diff --git a/CesarPlayer/AssemblyInfo.cs.in b/CesarPlayer/AssemblyInfo.cs.in
new file mode 100644
index 0000000..08721f2
--- /dev/null
+++ b/CesarPlayer/AssemblyInfo.cs.in
@@ -0,0 +1,50 @@
+// Copyright(C) 2007-2009 Andoni Morales Alastruey
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+//
+
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+// Information about this assembly is defined by the following
+// attributes.
+//
+// change them to the information which is associated with the assembly
+// you compile.
+
+[assembly: AssemblyTitle("CesarPlayer")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("")]
+[assembly: AssemblyCopyright("Andoni Morales Alastruey")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// The assembly version has following format :
+//
+// Major.Minor.Build.Revision
+//
+// You can specify all values by your own or you can build default build and revision
+// numbers with the '*' character (the default):
+
+[assembly: AssemblyVersion("@PACKAGE_VERSION@")]
+
+// The following attributes specify the key for the sign of your assembly. See the
+// .NET Framework documentation for more information about signing.
+// This is not required, if you don't want signing let these attributes like they're.
+//[assembly: AssemblyDelaySign(false)]
+//[assembly: AssemblyKeyFile("cesarplayer.key")]
diff --git a/CesarPlayer/Capturer/CaptureProperties.cs b/CesarPlayer/Capturer/CaptureProperties.cs
new file mode 100644
index 0000000..d99bab4
--- /dev/null
+++ b/CesarPlayer/Capturer/CaptureProperties.cs
@@ -0,0 +1,39 @@
+//
+// Copyright (C) 2010 Andoni Morales Alastruey
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+
+using System;
+using LongoMatch.Video.Common;
+
+namespace LongoMatch.Video.Capturer
+{
+
+
+ public struct CapturePropertiesStruct
+ {
+ public CaptureSourceType CaptureSourceType;
+ public string OutputFile;
+ public string DeviceID;
+ public uint VideoBitrate;
+ public uint AudioBitrate;
+ public VideoEncoderType VideoEncoder;
+ public AudioEncoderType AudioEncoder;
+ public VideoMuxerType Muxer;
+ public uint Height;
+ public uint Width;
+ }
+}
\ No newline at end of file
diff --git a/CesarPlayer/Capturer/FakeCapturer.cs b/CesarPlayer/Capturer/FakeCapturer.cs
new file mode 100644
index 0000000..5e3cf88
--- /dev/null
+++ b/CesarPlayer/Capturer/FakeCapturer.cs
@@ -0,0 +1,120 @@
+//
+// Copyright (C) 2010 Andoni Morales Alastruey
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+
+using System;
+using Mono.Unix;
+using GLib;
+using LongoMatch.Video.Common;
+using Gdk;
+
+namespace LongoMatch.Video.Capturer
+{
+
+
+ public class FakeCapturer : Gtk.Bin, ICapturer
+ {
+ public event EllpasedTimeHandler EllapsedTime;
+ public event ErrorHandler Error;
+ public event DeviceChangeHandler DeviceChange;
+
+ private LiveSourceTimer timer;
+
+ public FakeCapturer(): base ()
+ {
+ timer = new LiveSourceTimer();
+ timer.EllapsedTime += delegate(int ellapsedTime) {
+ if (EllapsedTime!= null)
+ EllapsedTime(ellapsedTime);
+ };
+ }
+
+ public int CurrentTime{
+ get{
+ return timer.CurrentTime;
+ }
+ }
+
+ public void Run(){
+ }
+
+ public void Close(){
+ }
+
+ public void Start(){
+ timer.Start();
+ }
+
+ public void Stop(){
+ timer.Stop();
+ }
+
+ public void TogglePause(){
+ timer.TogglePause();
+ }
+
+ public uint OutputWidth {
+ get{return 0;}
+ set{}
+ }
+
+ public uint OutputHeight {
+ get{return 0;}
+ set{}
+ }
+
+ public string OutputFile {
+ get {return Catalog.GetString("Fake live source");}
+ set {}
+ }
+
+ public uint VideoBitrate {
+ get {return 0;}
+ set {}
+ }
+
+ public uint AudioBitrate {
+ get {return 0;}
+ set {}
+ }
+
+ public Pixbuf CurrentFrame {
+ get {return null;}
+ }
+
+ public string DeviceID {
+ get {return "";}
+ set{}
+ }
+
+ public bool SetVideoEncoder(VideoEncoderType type){
+ return true;
+ }
+
+ public bool SetAudioEncoder(AudioEncoderType type){
+ return true;
+ }
+
+ public bool SetVideoMuxer(VideoMuxerType type){
+ return true;
+ }
+
+ public bool SetSource(CaptureSourceType type){
+ return true;
+ }
+ }
+}
diff --git a/CesarPlayer/Capturer/GstCameraCapturer.cs b/CesarPlayer/Capturer/GstCameraCapturer.cs
new file mode 100644
index 0000000..7f6b0d5
--- /dev/null
+++ b/CesarPlayer/Capturer/GstCameraCapturer.cs
@@ -0,0 +1,489 @@
+// Copyright (C) 2007-2009 Andoni Morales Alastruey
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+//
+
+namespace LongoMatch.Video.Capturer {
+
+ using System;
+ using System.Collections;
+ using System.Runtime.InteropServices;
+ using LongoMatch.Video.Common;
+
+#region Autogenerated code
+ public class GstCameraCapturer : Gtk.HBox, LongoMatch.Video.Capturer.ICapturer {
+
+ public event EllpasedTimeHandler EllapsedTime;
+
+ private LiveSourceTimer timer;
+
+ [Obsolete]
+ protected GstCameraCapturer(GLib.GType gtype) : base(gtype) {}
+ public GstCameraCapturer(IntPtr raw) : base(raw) {}
+
+ [DllImport("libcesarplayer.dll")]
+ static extern unsafe IntPtr gst_camera_capturer_new(IntPtr filename, out IntPtr err);
+
+ public unsafe GstCameraCapturer (string filename) : base (IntPtr.Zero)
+ {
+ if (GetType () != typeof (GstCameraCapturer)) {
+ throw new InvalidOperationException ("Can't override this constructor.");
+ }
+ IntPtr error = IntPtr.Zero;
+ Raw = gst_camera_capturer_new(GLib.Marshaller.StringToPtrGStrdup(filename), out error);
+ if (error != IntPtr.Zero) throw new GLib.GException (error);
+
+ timer = new LiveSourceTimer();
+ timer.EllapsedTime += delegate(int ellapsedTime) {
+ if (EllapsedTime!= null)
+ EllapsedTime(ellapsedTime);
+ };
+ }
+
+ [GLib.Property ("output_height")]
+ public uint OutputHeight {
+ get {
+ GLib.Value val = GetProperty ("output_height");
+ uint ret = (uint) val;
+ val.Dispose ();
+ return ret;
+ }
+ set {
+ GLib.Value val = new GLib.Value(value);
+ SetProperty("output_height", val);
+ val.Dispose ();
+ }
+ }
+
+ [GLib.Property ("output_width")]
+ public uint OutputWidth {
+ get {
+ GLib.Value val = GetProperty ("output_width");
+ uint ret = (uint) val;
+ val.Dispose ();
+ return ret;
+ }
+ set {
+ GLib.Value val = new GLib.Value(value);
+ SetProperty("output_width", val);
+ val.Dispose ();
+ }
+ }
+
+ [GLib.Property ("video_bitrate")]
+ public uint VideoBitrate {
+ get {
+ GLib.Value val = GetProperty ("video_bitrate");
+ uint ret = (uint) val;
+ val.Dispose ();
+ return ret;
+ }
+ set {
+ GLib.Value val = new GLib.Value(value);
+ SetProperty("video_bitrate", val);
+ val.Dispose ();
+ }
+ }
+
+ [GLib.Property ("output_file")]
+ public string OutputFile {
+ get {
+ GLib.Value val = GetProperty ("output_file");
+ string ret = (string) val;
+ val.Dispose ();
+ return ret;
+ }
+ set {
+ GLib.Value val = new GLib.Value(value);
+ SetProperty("output_file", val);
+ val.Dispose ();
+ }
+ }
+
+ [GLib.Property ("audio_bitrate")]
+ public uint AudioBitrate {
+ get {
+ GLib.Value val = GetProperty ("audio_bitrate");
+ uint ret = (uint) val;
+ val.Dispose ();
+ return ret;
+ }
+ set {
+ GLib.Value val = new GLib.Value(value);
+ SetProperty("audio_bitrate", val);
+ val.Dispose ();
+ }
+ }
+
+ [GLib.Property ("device_id")]
+ public string DeviceID {
+ get {
+ GLib.Value val = GetProperty ("device_id");
+ string ret = (string) val;
+ val.Dispose ();
+ return ret;
+ }
+ set {
+ GLib.Value val = new GLib.Value(value);
+ SetProperty("device_id", val);
+ val.Dispose ();
+ }
+ }
+
+#pragma warning disable 0169
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ delegate void ErrorSignalDelegate (IntPtr arg0, IntPtr arg1, IntPtr gch);
+
+ static void ErrorSignalCallback (IntPtr arg0, IntPtr arg1, IntPtr gch)
+ {
+ ErrorArgs args = new ErrorArgs ();
+ try {
+ GLib.Signal sig = ((GCHandle) gch).Target as GLib.Signal;
+ if (sig == null)
+ throw new Exception("Unknown signal GC handle received " + gch);
+
+ args.Args = new object[1];
+ args.Args[0] = GLib.Marshaller.Utf8PtrToString (arg1);
+ ErrorHandler handler = (ErrorHandler) sig.Handler;
+ handler (GLib.Object.GetObject (arg0), args);
+ } catch (Exception e) {
+ GLib.ExceptionManager.RaiseUnhandledException (e, false);
+ }
+ }
+
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ delegate void ErrorVMDelegate (IntPtr gcc, IntPtr message);
+
+ static ErrorVMDelegate ErrorVMCallback;
+
+ static void error_cb (IntPtr gcc, IntPtr message)
+ {
+ try {
+ GstCameraCapturer gcc_managed = GLib.Object.GetObject (gcc, false) as GstCameraCapturer;
+ gcc_managed.OnError (GLib.Marshaller.Utf8PtrToString (message));
+ } catch (Exception e) {
+ GLib.ExceptionManager.RaiseUnhandledException (e, false);
+ }
+ }
+
+ private static void OverrideError (GLib.GType gtype)
+ {
+ if (ErrorVMCallback == null)
+ ErrorVMCallback = new ErrorVMDelegate (error_cb);
+ OverrideVirtualMethod (gtype, "error", ErrorVMCallback);
+ }
+
+ [GLib.DefaultSignalHandler(Type=typeof(LongoMatch.Video.Capturer.GstCameraCapturer), ConnectionMethod="OverrideError")]
+ protected virtual void OnError (string message)
+ {
+ GLib.Value ret = GLib.Value.Empty;
+ GLib.ValueArray inst_and_params = new GLib.ValueArray (2);
+ GLib.Value[] vals = new GLib.Value [2];
+ vals [0] = new GLib.Value (this);
+ inst_and_params.Append (vals [0]);
+ vals [1] = new GLib.Value (message);
+ inst_and_params.Append (vals [1]);
+ g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
+ foreach (GLib.Value v in vals)
+ v.Dispose ();
+ }
+
+ [GLib.Signal("error")]
+ public event ErrorHandler Error {
+ add {
+ GLib.Signal sig = GLib.Signal.Lookup (this, "error", new ErrorSignalDelegate(ErrorSignalCallback));
+ sig.AddDelegate (value);
+ }
+ remove {
+ GLib.Signal sig = GLib.Signal.Lookup (this, "error", new ErrorSignalDelegate(ErrorSignalCallback));
+ sig.RemoveDelegate (value);
+ }
+ }
+
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ delegate void DeviceChangeSignalDelegate (IntPtr arg0, int arg1, IntPtr gch);
+
+ static void DeviceChangeSignalCallback (IntPtr arg0, int arg1, IntPtr gch)
+ {
+ DeviceChangeArgs args = new DeviceChangeArgs ();
+ try {
+ GLib.Signal sig = ((GCHandle) gch).Target as GLib.Signal;
+ if (sig == null)
+ throw new Exception("Unknown signal GC handle received " + gch);
+
+ args.Args = new object[1];
+ args.Args[0] = arg1;
+ DeviceChangeHandler handler = (DeviceChangeHandler) sig.Handler;
+ handler (GLib.Object.GetObject (arg0), args);
+ } catch (Exception e) {
+ GLib.ExceptionManager.RaiseUnhandledException (e, false);
+ }
+ }
+
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ delegate void DeviceChangeVMDelegate (IntPtr gcc, int deviceChange);
+
+ static DeviceChangeVMDelegate DeviceChangeVMCallback;
+
+ static void device_change_cb (IntPtr gcc, int deviceChange)
+ {
+ try {
+ GstCameraCapturer gcc_managed = GLib.Object.GetObject (gcc, false) as GstCameraCapturer;
+ gcc_managed.OnDeviceChange (deviceChange);
+ } catch (Exception e) {
+ GLib.ExceptionManager.RaiseUnhandledException (e, false);
+ }
+ }
+
+ private static void OverrideDeviceChange (GLib.GType gtype)
+ {
+ if (DeviceChangeVMCallback == null)
+ DeviceChangeVMCallback = new DeviceChangeVMDelegate (device_change_cb);
+ OverrideVirtualMethod (gtype, "device_change", DeviceChangeVMCallback);
+ }
+
+ [GLib.DefaultSignalHandler(Type=typeof(LongoMatch.Video.Capturer.GstCameraCapturer), ConnectionMethod="OverrideDeviceChange")]
+ protected virtual void OnDeviceChange (int deviceChange)
+ {
+ GLib.Value ret = GLib.Value.Empty;
+ GLib.ValueArray inst_and_params = new GLib.ValueArray (2);
+ GLib.Value[] vals = new GLib.Value [2];
+ vals [0] = new GLib.Value (this);
+ inst_and_params.Append (vals [0]);
+ vals [1] = new GLib.Value (deviceChange);
+ inst_and_params.Append (vals [1]);
+ g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
+ foreach (GLib.Value v in vals)
+ v.Dispose ();
+ }
+
+ [GLib.Signal("device_change")]
+ public event DeviceChangeHandler DeviceChange {
+ add {
+ GLib.Signal sig = GLib.Signal.Lookup (this, "device_change", new DeviceChangeSignalDelegate(DeviceChangeSignalCallback));
+ sig.AddDelegate (value);
+ }
+ remove {
+ GLib.Signal sig = GLib.Signal.Lookup (this, "device_change", new DeviceChangeSignalDelegate(DeviceChangeSignalCallback));
+ sig.RemoveDelegate (value);
+ }
+ }
+
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ delegate void EosVMDelegate (IntPtr gcc);
+
+ static EosVMDelegate EosVMCallback;
+
+ static void eos_cb (IntPtr gcc)
+ {
+ try {
+ GstCameraCapturer gcc_managed = GLib.Object.GetObject (gcc, false) as GstCameraCapturer;
+ gcc_managed.OnEos ();
+ } catch (Exception e) {
+ GLib.ExceptionManager.RaiseUnhandledException (e, false);
+ }
+ }
+
+ private static void OverrideEos (GLib.GType gtype)
+ {
+ if (EosVMCallback == null)
+ EosVMCallback = new EosVMDelegate (eos_cb);
+ OverrideVirtualMethod (gtype, "eos", EosVMCallback);
+ }
+
+ [GLib.DefaultSignalHandler(Type=typeof(LongoMatch.Video.Capturer.GstCameraCapturer), ConnectionMethod="OverrideEos")]
+ protected virtual void OnEos ()
+ {
+ GLib.Value ret = GLib.Value.Empty;
+ GLib.ValueArray inst_and_params = new GLib.ValueArray (1);
+ GLib.Value[] vals = new GLib.Value [1];
+ vals [0] = new GLib.Value (this);
+ inst_and_params.Append (vals [0]);
+ g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
+ foreach (GLib.Value v in vals)
+ v.Dispose ();
+ }
+
+ [GLib.Signal("eos")]
+ public event System.EventHandler Eos {
+ add {
+ GLib.Signal sig = GLib.Signal.Lookup (this, "eos");
+ sig.AddDelegate (value);
+ }
+ remove {
+ GLib.Signal sig = GLib.Signal.Lookup (this, "eos");
+ sig.RemoveDelegate (value);
+ }
+ }
+#pragma warning restore 0169
+
+ [DllImport("libcesarplayer.dll")]
+ static extern void gst_camera_capturer_init_backend(out int argc, IntPtr argv);
+
+ public static int InitBackend(string argv) {
+ int argc;
+ gst_camera_capturer_init_backend(out argc, GLib.Marshaller.StringToPtrGStrdup(argv));
+ return argc;
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern void gst_camera_capturer_stop(IntPtr raw);
+
+ public void Stop() {
+ timer.Stop();
+ gst_camera_capturer_stop(Handle);
+ }
+
+
+ [DllImport("libcesarplayer.dll")]
+ static extern void gst_camera_capturer_toggle_pause(IntPtr raw);
+
+ public void TogglePause() {
+ timer.TogglePause();
+ gst_camera_capturer_toggle_pause(Handle);
+ }
+
+ public int CurrentTime{
+ get{
+ return timer.CurrentTime;
+ }
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern void gst_camera_capturer_start(IntPtr raw);
+
+ public void Start() {
+ timer.Start();
+ gst_camera_capturer_start(Handle);
+ }
+
+
+ [DllImport("libcesarplayer.dll")]
+ static extern void gst_camera_capturer_run(IntPtr raw);
+
+ public void Run() {
+ gst_camera_capturer_run(Handle);
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern void gst_camera_capturer_close(IntPtr raw);
+
+ public void Close() {
+ gst_camera_capturer_close(Handle);
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern bool gst_camera_capturer_set_video_muxer(IntPtr raw, int type, out IntPtr error);
+
+ public bool SetVideoMuxer(VideoMuxerType type) {
+ IntPtr error = IntPtr.Zero;
+ bool raw_ret = gst_camera_capturer_set_video_muxer(Handle, (int) type, out error);
+ if (error != IntPtr.Zero) throw new GLib.GException (error);
+ bool ret = raw_ret;
+ return ret;
+ }
+
+
+ [DllImport("libcesarplayer.dll")]
+ static extern bool gst_camera_capturer_set_video_encoder(IntPtr raw, int type, out IntPtr error);
+
+ public bool SetVideoEncoder(VideoEncoderType type) {
+ IntPtr error = IntPtr.Zero;
+ bool raw_ret = gst_camera_capturer_set_video_encoder(Handle, (int) type, out error);
+ if (error != IntPtr.Zero) throw new GLib.GException (error);
+ bool ret = raw_ret;
+ return ret;
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern bool gst_camera_capturer_set_audio_encoder(IntPtr raw, int type, out IntPtr error);
+
+ public bool SetAudioEncoder(AudioEncoderType type) {
+ IntPtr error = IntPtr.Zero;
+ bool raw_ret = gst_camera_capturer_set_audio_encoder(Handle, (int) type, out error);
+ if (error != IntPtr.Zero) throw new GLib.GException (error);
+ bool ret = raw_ret;
+ return ret;
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern bool gst_camera_capturer_set_source(IntPtr raw, int type, out IntPtr error);
+
+ public bool SetSource(CaptureSourceType type) {
+ IntPtr error = IntPtr.Zero;
+ bool raw_ret = gst_camera_capturer_set_source(Handle, (int) type, out error);
+ if (error != IntPtr.Zero) throw new GLib.GException (error);
+ bool ret = raw_ret;
+ return ret;
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern IntPtr gst_camera_capturer_get_type();
+
+ public static new GLib.GType GType {
+ get {
+ IntPtr raw_ret = gst_camera_capturer_get_type();
+ GLib.GType ret = new GLib.GType(raw_ret);
+ return ret;
+ }
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern IntPtr gst_camera_capturer_enum_audio_devices();
+
+ public static string[] AudioDevices {
+ get {
+ IntPtr raw_ret = gst_camera_capturer_enum_audio_devices();
+ return (string[])GLib.Marshaller.ListPtrToArray(raw_ret, typeof(GLib.List), true, false, typeof(String));
+ }
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern IntPtr gst_camera_capturer_enum_video_devices();
+
+ public static string[] VideoDevices {
+ get {
+ IntPtr raw_ret = gst_camera_capturer_enum_video_devices();
+ return (string[])GLib.Marshaller.ListPtrToArray(raw_ret, typeof(GLib.List), true, false, typeof(String));
+ }
+ }
+
+
+ [DllImport("libcesarplayer.dll")]
+ static extern IntPtr gst_camera_capturer_get_current_frame(IntPtr raw);
+ [DllImport("libcesarplayer.dll")]
+ static extern IntPtr gst_camera_capturer_unref_pixbuf(IntPtr raw);
+
+ public Gdk.Pixbuf CurrentFrame {
+ get {
+ IntPtr raw_ret = gst_camera_capturer_get_current_frame (Handle);
+ Gdk.Pixbuf p = GLib.Object.GetObject (raw_ret) as Gdk.Pixbuf;
+ /* The refcount for p is now 2. We need to decrease the counter to 1
+ * so that p.Dipose() sets it to 0 and triggers the pixbuf destroy function
+ * that frees the associated data*/
+ gst_camera_capturer_unref_pixbuf (raw_ret);
+ return p;
+ }
+ }
+
+ static GstCameraCapturer ()
+ {
+ LongoMatch.GtkSharp.Capturer.ObjectManager.Initialize ();
+ }
+#endregion
+
+ }
+}
diff --git a/CesarPlayer/Capturer/ICapturer.cs b/CesarPlayer/Capturer/ICapturer.cs
new file mode 100644
index 0000000..4960bdb
--- /dev/null
+++ b/CesarPlayer/Capturer/ICapturer.cs
@@ -0,0 +1,93 @@
+// ICapturer.cs
+//
+// Copyright (C) 2007-2009 Andoni Morales Alastruey
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+//
+
+using System;
+using LongoMatch.Video.Common;
+using Gdk;
+
+namespace LongoMatch.Video.Capturer
+{
+
+
+ public interface ICapturer
+ {
+ event EllpasedTimeHandler EllapsedTime;
+ event ErrorHandler Error;
+ event DeviceChangeHandler DeviceChange;
+
+ uint OutputWidth {
+ get ;
+ set ;
+ }
+
+ uint OutputHeight {
+ get;
+ set ;
+ }
+
+ string OutputFile {
+ get ;
+ set ;
+ }
+
+ uint VideoBitrate {
+ get;
+ set ;
+ }
+
+ uint AudioBitrate {
+ get ;
+ set ;
+ }
+
+ int CurrentTime {
+ get ;
+ }
+
+ Pixbuf CurrentFrame {
+ get;
+ }
+
+ string DeviceID {
+ set;
+ get;
+ }
+
+ bool SetVideoEncoder(VideoEncoderType type);
+
+ bool SetAudioEncoder(AudioEncoderType type);
+
+ bool SetVideoMuxer(VideoMuxerType type);
+
+ bool SetSource(CaptureSourceType type);
+
+ void TogglePause();
+
+ void Start();
+
+ void Stop();
+
+ void Run();
+
+ void Close();
+
+ void Dispose();
+ }
+}
diff --git a/CesarPlayer/Capturer/LiveSourceTimer.cs b/CesarPlayer/Capturer/LiveSourceTimer.cs
new file mode 100644
index 0000000..47fd043
--- /dev/null
+++ b/CesarPlayer/Capturer/LiveSourceTimer.cs
@@ -0,0 +1,87 @@
+//
+// Copyright (C) 2010 Andoni Morales Alastruey
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+
+using System;
+using LongoMatch.Video.Common;
+
+
+namespace LongoMatch.Video.Capturer
+{
+
+
+ public class LiveSourceTimer
+ {
+ public event EllpasedTimeHandler EllapsedTime;
+
+ private DateTime lastStart;
+ private TimeSpan ellapsed;
+ private bool playing;
+ private bool started;
+ private uint timerID;
+
+ public LiveSourceTimer()
+ {
+ lastStart = DateTime.Now;
+ ellapsed = new TimeSpan(0,0,0);
+ playing = false;
+ started = false;
+ }
+
+ public int CurrentTime{
+ get{
+ if (!started)
+ return 0;
+ else if (playing)
+ return (int)(ellapsed + (DateTime.Now - lastStart)).TotalMilliseconds;
+ else
+ return (int)ellapsed.TotalMilliseconds;
+ }
+ }
+
+ public void TogglePause(){
+ if (!started)
+ return;
+
+ if (playing){
+ playing = false;
+ ellapsed += DateTime.Now - lastStart;
+ }
+ else{
+ playing = true;
+ lastStart = DateTime.Now;
+ }
+ }
+
+ public void Start(){
+ timerID = GLib.Timeout.Add(100, OnTick);
+ lastStart = DateTime.Now;
+ playing = true;
+ started = true;
+ }
+
+ public void Stop(){
+ GLib.Source.Remove(timerID);
+ }
+
+ protected virtual bool OnTick(){
+ if (EllapsedTime != null)
+ EllapsedTime(CurrentTime);
+ return true;
+ }
+ }
+}
diff --git a/CesarPlayer/Capturer/ObjectManager.cs b/CesarPlayer/Capturer/ObjectManager.cs
new file mode 100644
index 0000000..ed2be4c
--- /dev/null
+++ b/CesarPlayer/Capturer/ObjectManager.cs
@@ -0,0 +1,39 @@
+// ObjectManager.cs
+//
+// Copyright (C) 2007-2009 Andoni Morales Alastruey
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+//
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace LongoMatch.GtkSharp.Capturer {
+
+ public class ObjectManager {
+
+ static bool initialized = false;
+ // Call this method from the appropriate module init function.
+ public static void Initialize ()
+ {
+ if (initialized)
+ return;
+
+ initialized = true;
+
+ GLib.GType.Register (LongoMatch.Video.Capturer.GstCameraCapturer.GType, typeof (LongoMatch.Video.Capturer.GstCameraCapturer));
+ }
+ }
+}
diff --git a/CesarPlayer/CesarPlayer.dll.config.in b/CesarPlayer/CesarPlayer.dll.config.in
new file mode 100644
index 0000000..adc67da
--- /dev/null
+++ b/CesarPlayer/CesarPlayer.dll.config.in
@@ -0,0 +1,3 @@
+<configuration>
+ <dllmap dll="libcesarplayer.dll" target="@expanded_libdir@/@PACKAGE@/libcesarplayer.so.0"/>
+</configuration>
diff --git a/CesarPlayer/Common/Constants.cs b/CesarPlayer/Common/Constants.cs
new file mode 100644
index 0000000..0053eec
--- /dev/null
+++ b/CesarPlayer/Common/Constants.cs
@@ -0,0 +1,28 @@
+//
+// Copyright (C) 2010 Andoni Morales Alastruey
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+
+using System;
+
+namespace LongoMatch.Video.Common
+{
+
+ class Constants{
+ public const string DV1394SRC_PROP = "guid";
+ public const string DSHOWVIDEOSINK_PROP = "device-name";
+ }
+}
diff --git a/CesarPlayer/Common/Enum.cs b/CesarPlayer/Common/Enum.cs
new file mode 100644
index 0000000..6331834
--- /dev/null
+++ b/CesarPlayer/Common/Enum.cs
@@ -0,0 +1,168 @@
+//
+// Copyright (C) 2010 Andoni Morales Alastruey
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+
+using System;
+
+namespace LongoMatch.Video.Common
+{
+
+
+ public enum Error {
+ AudioPlugin,
+ NoPluginForFile,
+ VideoPlugin,
+ AudioBusy,
+ BrokenFile,
+ FileGeneric,
+ FilePermission,
+ FileEncrypted,
+ FileNotFound,
+ DvdEncrypted,
+ InvalidDevice,
+ UnknownHost,
+ NetworkUnreachable,
+ ConnectionRefused,
+ UnvalidLocation,
+ Generic,
+ CodecNotHandled,
+ AudioOnly,
+ CannotCapture,
+ ReadError,
+ PluginLoad,
+ EmptyFile,
+ }
+
+ public enum VideoEncoderType {
+ Mpeg4,
+ Xvid,
+ Theora,
+ H264,
+ Mpeg2,
+ VP8,
+ }
+
+ public enum AudioEncoderType {
+ Mp3,
+ Aac,
+ Vorbis,
+ }
+
+ public enum VideoMuxerType {
+ Avi,
+ Mp4,
+ Matroska,
+ Ogg,
+ MpegPS,
+ WebM,
+ }
+
+ public enum CapturerType{
+ Fake,
+ Live,
+ }
+
+ public enum VideoFormat {
+ PORTABLE=0,
+ VGA=1,
+ TV=2,
+ HD720p=3,
+ HD1080p=4
+ }
+
+ public enum VideoQuality {
+ Low = 1000,
+ Normal = 3000,
+ Good = 5000,
+ Extra = 7000,
+ }
+
+ public enum AudioQuality
+ {
+ Low = 32000,
+ Normal = 64000,
+ Good = 128000,
+ Extra = 256000,
+ copy,
+ }
+
+ public enum PlayerUseType {
+ Video,
+ Audio,
+ Capture,
+ Metadata,
+ }
+
+ public enum VideoProperty {
+ Brightness,
+ Contrast,
+ Saturation,
+ Hue,
+ }
+
+ public enum AspectRatio {
+ Auto,
+ Square,
+ Fourbythree,
+ Anamorphic,
+ Dvb,
+ }
+
+ public enum AudioOutType {
+ Stereo,
+ Channel4,
+ Channel41,
+ Channel5,
+ Channel51,
+ Ac3passthru,
+ }
+
+ public enum MetadataType {
+ Title,
+ Artist,
+ Year,
+ Comment,
+ Album,
+ Duration,
+ TrackNumber,
+ Cover,
+ HasVideo,
+ DimensionX,
+ DimensionY,
+ VideoBitrate,
+ VideoEncoderType,
+ Fps,
+ HasAudio,
+ AudioBitrate,
+ AudioEncoderType,
+ AudioSampleRate,
+ AudioChannels,
+ }
+
+ public enum DeviceType {
+ Video,
+ Audio,
+ DV
+ }
+
+ public enum CaptureSourceType {
+ None,
+ DV,
+ Raw,
+ DShow
+ }
+}
diff --git a/CesarPlayer/Common/Handlers.cs b/CesarPlayer/Common/Handlers.cs
new file mode 100644
index 0000000..ae02ad6
--- /dev/null
+++ b/CesarPlayer/Common/Handlers.cs
@@ -0,0 +1,106 @@
+//
+// Copyright (C) 2010 Andoni Morales Alastruey
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+
+using System;
+using Gdk;
+
+namespace LongoMatch.Video.Common
+{
+
+ public delegate void PlayListSegmentDoneHandler ();
+ public delegate void SegmentClosedHandler();
+ public delegate void SegmentDoneHandler();
+ public delegate void SeekEventHandler(long pos);
+ public delegate void VolumeChangedHandler (double level);
+ public delegate void NextButtonClickedHandler ();
+ public delegate void PrevButtonClickedHandler ();
+ public delegate void ProgressHandler (float progress);
+ public delegate void FramesProgressHandler (int actual, int total,Pixbuf frame);
+ public delegate void DrawFrameHandler (int time);
+ public delegate void EllpasedTimeHandler (int ellapsedTime);
+
+
+ public delegate void ErrorHandler(object o, ErrorArgs args);
+ public delegate void PercentCompletedHandler(object o, PercentCompletedArgs args);
+ public delegate void StateChangeHandler(object o, StateChangeArgs args);
+ public delegate void TickHandler(object o, TickArgs args);
+ public delegate void DeviceChangeHandler(object o, DeviceChangeArgs args);
+
+
+
+ public class ErrorArgs : GLib.SignalArgs {
+ public string Message{
+ get {
+ return (string) Args[0];
+ }
+ }
+
+ }
+
+ public class PercentCompletedArgs : GLib.SignalArgs {
+ public float Percent{
+ get {
+ return (float) Args[0];
+ }
+ }
+
+ }
+
+ public class StateChangeArgs : GLib.SignalArgs {
+ public bool Playing{
+ get {
+ return (bool) Args[0];
+ }
+ }
+ }
+
+ public class TickArgs : GLib.SignalArgs {
+ public long CurrentTime{
+ get {
+ return (long) Args[0];
+ }
+ }
+
+ public long StreamLength{
+ get {
+ return (long) Args[1];
+ }
+ }
+
+ public float CurrentPosition{
+ get {
+ return (float) Args[2];
+ }
+ }
+
+ public bool Seekable{
+ get {
+ return (bool) Args[3];
+ }
+ }
+ }
+
+ public class DeviceChangeArgs : GLib.SignalArgs {
+ public int DeviceChange{
+ get {
+ return (int) Args[0];
+ }
+ }
+
+ }
+}
diff --git a/CesarPlayer/Editor/EditorState.cs b/CesarPlayer/Editor/EditorState.cs
new file mode 100644
index 0000000..31b4438
--- /dev/null
+++ b/CesarPlayer/Editor/EditorState.cs
@@ -0,0 +1,32 @@
+//
+// Copyright (C) 2007-2009 Andoni Morales Alastruey
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+
+using System;
+
+namespace LongoMatch.Video.Editor
+{
+
+
+ public enum EditorState
+ {
+ START = 0,
+ FINISHED = 1,
+ CANCELED = -1,
+ ERROR = -2
+ }
+}
diff --git a/CesarPlayer/Editor/GstVideoSplitter.cs b/CesarPlayer/Editor/GstVideoSplitter.cs
new file mode 100644
index 0000000..c97c1cb
--- /dev/null
+++ b/CesarPlayer/Editor/GstVideoSplitter.cs
@@ -0,0 +1,433 @@
+// GstVideoSplitter.cs
+//
+// Copyright (C) 2007-2009 Andoni Morales Alastruey
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+//
+
+namespace LongoMatch.Video.Editor {
+
+ using System;
+ using System.Collections;
+ using System.Runtime.InteropServices;
+ using LongoMatch.Video.Common;
+
+
+ public class GstVideoSplitter : GLib.Object, IVideoEditor, IVideoSplitter {
+
+ [DllImport("libcesarplayer.dll")]
+ static extern unsafe IntPtr gst_video_editor_new(out IntPtr err);
+
+ public event ProgressHandler Progress;
+
+ public unsafe GstVideoSplitter () : base (IntPtr.Zero)
+ {
+ if (GetType () != typeof (GstVideoSplitter)) {
+ throw new InvalidOperationException ("Can't override this constructor.");
+ }
+ IntPtr error = IntPtr.Zero;
+ Raw = gst_video_editor_new(out error);
+ if (error != IntPtr.Zero) throw new GLib.GException (error);
+ PercentCompleted += delegate(object o, PercentCompletedArgs args) {
+ if (Progress!= null)
+ Progress (args.Percent);
+ };
+ }
+
+ #region Properties
+
+ [GLib.Property ("enable-audio")]
+ public bool EnableAudio {
+ get {
+ GLib.Value val = GetProperty ("enable-audio");
+ bool ret = (bool) val;
+ val.Dispose ();
+ return ret;
+ }
+ set {
+ GLib.Value val = new GLib.Value(value);
+ SetProperty("enable-audio", val);
+ val.Dispose ();
+ }
+ }
+
+ [GLib.Property ("enable-title")]
+ public bool EnableTitle {
+ get {
+ GLib.Value val = GetProperty ("enable-title");
+ bool ret = (bool) val;
+ val.Dispose ();
+ return ret;
+ }
+ set {
+ GLib.Value val = new GLib.Value(value);
+ SetProperty("enable-title", val);
+ val.Dispose ();
+ }
+ }
+
+ [GLib.Property ("video_bitrate")]
+ public int VideoBitrate {
+ get {
+ GLib.Value val = GetProperty ("video_bitrate");
+ int ret = (int) val;
+ val.Dispose ();
+ return ret;
+ }
+ set {
+ GLib.Value val = new GLib.Value(value);
+ SetProperty("video_bitrate", val);
+ val.Dispose ();
+ }
+ }
+
+ [GLib.Property ("audio_bitrate")]
+ public int AudioBitrate {
+ get {
+ GLib.Value val = GetProperty ("audio_bitrate");
+ int ret = (int) val;
+ val.Dispose ();
+ return ret;
+ }
+ set {
+ GLib.Value val = new GLib.Value(value);
+ SetProperty("audio_bitrate", val);
+ val.Dispose ();
+ }
+ }
+
+ [GLib.Property ("width")]
+ public int Width {
+ get {
+ GLib.Value val = GetProperty ("width");
+ int ret = (int) val;
+ val.Dispose ();
+ return ret;
+ }
+ set {
+ GLib.Value val = new GLib.Value(value);
+ SetProperty("width", val);
+ val.Dispose ();
+ }
+ }
+
+ [GLib.Property ("height")]
+ public int Height {
+ get {
+ GLib.Value val = GetProperty ("height");
+ int ret = (int) val;
+ val.Dispose ();
+ return ret;
+ }
+ set {
+ GLib.Value val = new GLib.Value(value);
+ SetProperty("height", val);
+ val.Dispose ();
+ }
+ }
+
+ [GLib.Property ("output_file")]
+ public string OutputFile {
+ get {
+ GLib.Value val = GetProperty ("output_file");
+ string ret = (string) val;
+ val.Dispose ();
+ return ret;
+ }
+ set {
+ GLib.Value val = new GLib.Value(value);
+ SetProperty("output_file", val);
+ val.Dispose ();
+ }
+ }
+
+ #endregion
+
+
+
+ #region GSignals
+#pragma warning disable 0169
+ [GLib.CDeclCallback]
+ delegate void ErrorVMDelegate (IntPtr gvc, IntPtr message);
+
+ static ErrorVMDelegate ErrorVMCallback;
+
+ static void error_cb (IntPtr gvc, IntPtr message)
+ {
+ try {
+ GstVideoSplitter gvc_managed = GLib.Object.GetObject (gvc, false) as GstVideoSplitter;
+ gvc_managed.OnError (GLib.Marshaller.Utf8PtrToString (message));
+ } catch (Exception e) {
+ GLib.ExceptionManager.RaiseUnhandledException (e, false);
+ }
+ }
+
+ private static void OverrideError (GLib.GType gtype)
+ {
+ if (ErrorVMCallback == null)
+ ErrorVMCallback = new ErrorVMDelegate (error_cb);
+ OverrideVirtualMethod (gtype, "error", ErrorVMCallback);
+ }
+
+ [GLib.DefaultSignalHandler(Type=typeof(LongoMatch.Video.Editor.GstVideoSplitter), ConnectionMethod="OverrideError")]
+ protected virtual void OnError (string message)
+ {
+ GLib.Value ret = GLib.Value.Empty;
+ GLib.ValueArray inst_and_params = new GLib.ValueArray (2);
+ GLib.Value[] vals = new GLib.Value [2];
+ vals [0] = new GLib.Value (this);
+ inst_and_params.Append (vals [0]);
+ vals [1] = new GLib.Value (message);
+ inst_and_params.Append (vals [1]);
+ g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
+ foreach (GLib.Value v in vals)
+ v.Dispose ();
+ }
+
+ [GLib.Signal("error")]
+ public event ErrorHandler Error {
+ add {
+ GLib.Signal sig = GLib.Signal.Lookup (this, "error", typeof (ErrorArgs));
+ sig.AddDelegate (value);
+ }
+ remove {
+ GLib.Signal sig = GLib.Signal.Lookup (this, "error", typeof (ErrorArgs));
+ sig.RemoveDelegate (value);
+ }
+ }
+
+
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ delegate void PercentCompletedVMDelegate (IntPtr gvc, float percent);
+
+ static PercentCompletedVMDelegate PercentCompletedVMCallback;
+
+ static void percentcompleted_cb (IntPtr gvc, float percent)
+ {
+ try {
+ GstVideoSplitter gvc_managed = GLib.Object.GetObject (gvc, false) as GstVideoSplitter;
+ gvc_managed.OnPercentCompleted (percent);
+ } catch (Exception e) {
+ GLib.ExceptionManager.RaiseUnhandledException (e, false);
+ }
+ }
+
+ private static void OverridePercentCompleted (GLib.GType gtype)
+ {
+ if (PercentCompletedVMCallback == null)
+ PercentCompletedVMCallback = new PercentCompletedVMDelegate (percentcompleted_cb);
+ OverrideVirtualMethod (gtype, "percent_completed", PercentCompletedVMCallback);
+ }
+
+ [GLib.DefaultSignalHandler(Type=typeof(LongoMatch.Video.Editor.GstVideoSplitter), ConnectionMethod="OverridePercentCompleted")]
+ protected virtual void OnPercentCompleted (float percent)
+ {
+ GLib.Value ret = GLib.Value.Empty;
+ GLib.ValueArray inst_and_params = new GLib.ValueArray (2);
+ GLib.Value[] vals = new GLib.Value [2];
+ vals [0] = new GLib.Value (this);
+ inst_and_params.Append (vals [0]);
+ vals [1] = new GLib.Value (percent);
+ inst_and_params.Append (vals [1]);
+ g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
+ foreach (GLib.Value v in vals)
+ v.Dispose ();
+ }
+
+ [GLib.Signal("percent_completed")]
+ public event PercentCompletedHandler PercentCompleted {
+ add {
+ GLib.Signal sig = GLib.Signal.Lookup (this, "percent_completed", typeof (PercentCompletedArgs));
+ sig.AddDelegate (value);
+ }
+ remove {
+ GLib.Signal sig = GLib.Signal.Lookup (this, "percent_completed", typeof (PercentCompletedArgs));
+ sig.RemoveDelegate (value);
+ }
+ }
+#pragma warning restore 0169
+ #endregion
+
+ #region Public Methods
+
+ [DllImport("libcesarplayer.dll")]
+ static extern IntPtr gst_video_editor_get_type();
+
+ public static new GLib.GType GType {
+ get {
+ IntPtr raw_ret = gst_video_editor_get_type();
+ GLib.GType ret = new GLib.GType(raw_ret);
+ return ret;
+ }
+ }
+
+
+
+ [DllImport("libcesarplayer.dll")]
+ static extern void gst_video_editor_clear_segments_list(IntPtr raw);
+
+ public void ClearList() {
+ gst_video_editor_clear_segments_list(Handle);
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern void gst_video_editor_add_segment(IntPtr raw, string file_path, long start, long duration, double rate, IntPtr title, bool hasAudio);
+
+ public void AddSegment(string filePath, long start, long duration, double rate, string title, bool hasAudio) {
+ if (Environment.OSVersion.Platform == PlatformID.Win32NT)
+ filePath="file:///"+filePath;
+ gst_video_editor_add_segment(Handle, filePath, start, duration, rate, GLib.Marshaller.StringToPtrGStrdup(title), hasAudio);
+ }
+
+
+ [DllImport("libcesarplayer.dll")]
+ static extern void gst_video_editor_start(IntPtr raw);
+
+ public void Start() {
+ gst_video_editor_start(Handle);
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern void gst_video_editor_cancel(IntPtr raw);
+
+ public void Cancel() {
+ // The handle might have already been dealocated
+ try{
+ gst_video_editor_cancel(Handle);
+ }catch{
+ }
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern void gst_video_editor_set_video_encoder(IntPtr raw, out IntPtr error_ptr, int type);
+
+ public void SetVideoEncoder(out string error, VideoEncoderType codec) {
+ IntPtr error_ptr = IntPtr.Zero;
+ gst_video_editor_set_video_encoder(Handle,out error_ptr,(int)codec);
+ if (error_ptr != IntPtr.Zero)
+ error = GLib.Marshaller.Utf8PtrToString(error_ptr);
+ else
+ error = null;
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern void gst_video_editor_set_audio_encoder(IntPtr raw, out IntPtr error_ptr, int type);
+
+ public void SetAudioEncoder(out string error, AudioEncoderType codec) {
+ IntPtr error_ptr = IntPtr.Zero;
+ gst_video_editor_set_audio_encoder(Handle,out error_ptr,(int)codec);
+ if (error_ptr != IntPtr.Zero)
+ error = GLib.Marshaller.Utf8PtrToString(error_ptr);
+ else
+ error = null;
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern void gst_video_editor_set_video_muxer(IntPtr raw, out IntPtr error_ptr, int type);
+
+ public void SetVideoMuxer(out string error, VideoMuxerType muxer) {
+ IntPtr error_ptr = IntPtr.Zero;
+ gst_video_editor_set_video_muxer(Handle,out error_ptr,(int)muxer);
+ if (error_ptr != IntPtr.Zero)
+ error = GLib.Marshaller.Utf8PtrToString(error_ptr);
+ else
+ error = null;
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern void gst_video_editor_init_backend(out int argc, IntPtr argv);
+
+ public static int InitBackend(string argv) {
+ int argc;
+ gst_video_editor_init_backend(out argc, GLib.Marshaller.StringToPtrGStrdup(argv));
+ return argc;
+ }
+
+
+ public void SetSegment (string filePath, long start, long duration, double rate, string title, bool hasAudio){
+ ClearList();
+ AddSegment(filePath, start, duration, rate, title,hasAudio);
+ }
+
+ public VideoQuality VideoQuality{
+ set{VideoBitrate=(int)value;}
+ }
+
+ public AudioQuality AudioQuality{
+ set{AudioBitrate = (int)value;}
+ }
+
+ public VideoFormat VideoFormat{
+ set{
+ if (value == VideoFormat.PORTABLE){
+ Height = 240;
+ Width = 320;
+ }
+ else if (value == VideoFormat.VGA){
+ Height = 480 ;
+ Width = 640;
+ }
+ else if (value == VideoFormat.TV){
+ Height = 576;
+ Width = 720;
+ }
+ else if (value == VideoFormat.HD720p){
+ Height = 720;
+ Width = 1280;
+ }
+ else if (value == VideoFormat.HD1080p){
+ Height = 1080;
+ Width = 1920;
+ }
+ }
+ }
+
+ public AudioEncoderType AudioEncoder{
+ set{
+ string error;
+ SetAudioEncoder(out error,value);
+ if (error != null)
+ throw new Exception(error);
+ }
+ }
+
+ public VideoEncoderType VideoEncoder{
+ set{
+ string error;
+ SetVideoEncoder(out error, value);
+ if (error != null)
+ throw new Exception(error);
+ }
+ }
+
+ public VideoMuxerType VideoMuxer{
+ set{
+ string error;
+ SetVideoMuxer(out error,value);
+ if (error != null)
+ throw new Exception(error);
+ }
+ }
+
+ public string TempDir{
+ set{;}
+ }
+
+ #endregion
+
+
+ }
+}
diff --git a/CesarPlayer/Editor/IVideoEditor.cs b/CesarPlayer/Editor/IVideoEditor.cs
new file mode 100644
index 0000000..68cc46c
--- /dev/null
+++ b/CesarPlayer/Editor/IVideoEditor.cs
@@ -0,0 +1,83 @@
+// IVideoEditor.cs
+//
+// Copyright (C) 2007-2009 Andoni Morales Alastruey
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+//
+
+using System;
+using System.Collections.Generic;
+using LongoMatch.Video.Common;
+
+namespace LongoMatch.Video.Editor
+{
+
+
+ public interface IVideoEditor
+ {
+ event ProgressHandler Progress;
+
+ VideoQuality VideoQuality{
+ set;
+ }
+
+ AudioQuality AudioQuality{
+ set;
+ }
+
+ VideoFormat VideoFormat{
+ set;
+ }
+
+ AudioEncoderType AudioEncoder{
+ set;
+ }
+
+ VideoEncoderType VideoEncoder{
+ set;
+ }
+
+ VideoMuxerType VideoMuxer{
+ set;
+ }
+
+ string OutputFile{
+ set;
+ }
+
+ string TempDir{
+ set;
+ }
+
+ bool EnableTitle{
+ set;
+ }
+
+ bool EnableAudio{
+ set;
+ }
+
+
+ void AddSegment (string filePath, long start, long duration, double rate, string title, bool hasAudio) ;
+
+ void ClearList();
+
+ void Start();
+
+ void Cancel();
+
+ }
+}
diff --git a/CesarPlayer/Editor/IVideoSplitter.cs b/CesarPlayer/Editor/IVideoSplitter.cs
new file mode 100644
index 0000000..9f5a76c
--- /dev/null
+++ b/CesarPlayer/Editor/IVideoSplitter.cs
@@ -0,0 +1,84 @@
+//
+// Copyright (C) 2007-2009 Andoni Morales Alastruey
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+
+using System;
+using LongoMatch.Video.Common;
+
+namespace LongoMatch.Video.Editor
+{
+
+
+ public interface IVideoSplitter
+ {
+ event PercentCompletedHandler PercentCompleted;
+ event ErrorHandler Error;
+
+ bool EnableAudio{
+ set;
+ get;
+ }
+
+ bool EnableTitle{
+ set;
+ get;
+ }
+
+ int VideoBitrate {
+ set;
+ get;
+ }
+
+ int AudioBitrate {
+ set;
+ get;
+ }
+
+ int Width {
+ get ;
+ set;
+ }
+
+ int Height {
+ get ;
+ set ;
+ }
+
+ string OutputFile {
+ get ;
+ set;
+ }
+
+ void SetSegment(string filePath, long start, long duration, double rate, string title, bool hasAudio);
+
+ AudioEncoderType AudioEncoder{
+ set;
+ }
+
+ VideoEncoderType VideoEncoder{
+ set;
+ }
+
+ VideoMuxerType VideoMuxer{
+ set;
+ }
+
+ void Start();
+
+ void Cancel();
+ }
+}
diff --git a/CesarPlayer/Editor/VideoSegment.cs b/CesarPlayer/Editor/VideoSegment.cs
new file mode 100644
index 0000000..542bead
--- /dev/null
+++ b/CesarPlayer/Editor/VideoSegment.cs
@@ -0,0 +1,70 @@
+//
+// Copyright (C) 2007-2009 Andoni Morales Alastruey
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+
+using System;
+
+namespace LongoMatch.Video.Editor
+{
+
+
+ public class VideoSegment
+ {
+ private string filePath;
+ private long start;
+ private long duration;
+ private double rate;
+ private string title;
+ private bool hasAudio;
+
+ public VideoSegment(string filePath, long start, long duration, double rate, string title,bool hasAudio)
+ {
+ this.filePath = filePath;
+ this.start = start;
+ this.duration = duration;
+ this.rate = rate;
+ this.title = title;
+ this.hasAudio= hasAudio;
+ }
+
+ public string FilePath{
+ get{ return filePath;}
+ }
+
+ public string Title{
+ get{ return title;}
+ }
+
+ public long Start{
+ get{ return start;}
+ }
+
+ public long Duration{
+ get { return duration;}
+ }
+
+ public double Rate{
+ get{ return rate;}
+ }
+
+ public bool HasAudio{
+ get{return hasAudio;}
+ }
+
+
+ }
+}
diff --git a/CesarPlayer/Gui/CapturerBin.cs b/CesarPlayer/Gui/CapturerBin.cs
new file mode 100644
index 0000000..30d5466
--- /dev/null
+++ b/CesarPlayer/Gui/CapturerBin.cs
@@ -0,0 +1,362 @@
+// CapturerBin.cs
+//
+// Copyright (C) 2007-2009 Andoni Morales Alastruey
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+//
+
+using System;
+using Gtk;
+using Gdk;
+using GLib;
+using LongoMatch.Video;
+using LongoMatch.Video.Common;
+using LongoMatch.Video.Capturer;
+using LongoMatch.Video.Utils;
+using Mono.Unix;
+
+namespace LongoMatch.Gui
+{
+
+
+ [System.ComponentModel.Category("CesarPlayer")]
+ [System.ComponentModel.ToolboxItem(true)]
+ public partial class CapturerBin : Gtk.Bin
+ {
+ public event EventHandler CaptureFinished;
+ public event ErrorHandler Error;
+
+ private Pixbuf logopix;
+ private CapturePropertiesStruct captureProps;
+ private CapturerType capturerType;
+ private bool captureStarted;
+ private bool capturing;
+ private const int THUMBNAIL_MAX_WIDTH = 100;
+
+ ICapturer capturer;
+
+ public CapturerBin()
+ {
+ this.Build();
+ captureProps = new CapturePropertiesStruct();
+ captureProps.Width = 320;
+ captureProps.Height = 240;
+ captureProps.VideoBitrate = 1000;
+ captureProps.AudioBitrate = 128;
+ captureProps.VideoEncoder = VideoEncoderType.H264;
+ captureProps.AudioEncoder = AudioEncoderType.Aac;
+ captureProps.Muxer = VideoMuxerType.Mp4;
+ captureProps.OutputFile = "";
+ captureProps.CaptureSourceType = CaptureSourceType.Raw;
+ Type = CapturerType.Fake;
+ }
+
+ public CapturerType Type {
+ set {
+ /* Close any previous instance of the capturer */
+ Close();
+
+ MultimediaFactory factory = new MultimediaFactory();
+ capturer = factory.getCapturer(value);
+ capturer.EllapsedTime += OnTick;
+ if (value != CapturerType.Fake){
+ capturer.Error += OnError;
+ capturer.DeviceChange += OnDeviceChange;
+ capturerhbox.Add((Widget)capturer);
+ (capturer as Widget).Visible = true;
+ capturerhbox.Visible = true;
+ logodrawingarea.Visible = false;
+ }
+ else{
+ logodrawingarea.Visible = true;
+ capturerhbox.Visible = false;
+ }
+ SetProperties();
+ capturerType = value;
+ }
+
+ }
+
+ public string Logo{
+ set{
+ try{
+ this.logopix = new Pixbuf(value);
+ }catch{
+ /* FIXME: Add log */
+ }
+ }
+ }
+
+ public int CurrentTime {
+ get {
+ if (capturer == null)
+ return -1;
+ return capturer.CurrentTime;
+ }
+ }
+
+ public bool Capturing{
+ get{
+ return capturing;
+ }
+ }
+
+ public CapturePropertiesStruct CaptureProperties{
+ set{
+ captureProps = value;
+ }
+ }
+
+ public void Start(){
+ if (capturer == null)
+ return;
+
+ capturing = true;
+ captureStarted = true;
+ recbutton.Visible = false;
+ pausebutton.Visible = true;
+ stopbutton.Visible = true;
+ capturer.Start();
+ }
+
+ public void TogglePause(){
+ if (capturer == null)
+ return;
+
+ capturing = !capturing;
+ recbutton.Visible = !capturing;
+ pausebutton.Visible = capturing;
+ capturer.TogglePause();
+ }
+
+ public void Stop() {
+ if (capturer != null){
+ capturing = false;
+ capturer.Stop();
+ }
+ }
+
+ public void Run(){
+ if (capturer != null)
+ capturer.Run();
+ }
+
+ public void Close(){
+ /* resetting common properties */
+ pausebutton.Visible = false;
+ stopbutton.Visible = false;
+ recbutton.Visible = true;
+ captureStarted = false;
+ capturing = false;
+ OnTick(0);
+
+ if (capturer == null)
+ return;
+
+ /* stopping and closing capturer */
+ try {
+ capturer.Stop();
+ capturer.Close();
+ if (capturerType == CapturerType.Live){
+ /* release and dispose live capturer */
+ capturer.Error -= OnError;
+ capturer.DeviceChange += OnDeviceChange;
+ capturerhbox.Remove(capturer as Gtk.Widget);
+ capturer.Dispose();
+ }
+ } catch (Exception e) {}
+ capturer = null;
+ }
+
+ public Pixbuf CurrentMiniatureFrame {
+ get {
+ int h, w;
+ double rate;
+ Pixbuf scaled_pix;
+ Pixbuf pix;
+
+ if (capturer == null)
+ return null;
+
+ pix = capturer.CurrentFrame;
+
+ if (pix == null)
+ return null;
+
+ w = pix.Width;
+ h = pix.Height;
+ rate = (double)w / (double)h;
+
+ if (h > w) {
+ w = (int)(THUMBNAIL_MAX_WIDTH * rate);
+ h = THUMBNAIL_MAX_WIDTH;
+ } else {
+ h = (int)(THUMBNAIL_MAX_WIDTH / rate);
+ w = THUMBNAIL_MAX_WIDTH;
+ }
+ scaled_pix = pix.ScaleSimple (w, h, Gdk.InterpType.Bilinear);
+ pix.Dispose();
+
+ return scaled_pix;
+ }
+ }
+
+ private void SetProperties(){
+ if (capturer == null)
+ return;
+
+ capturer.DeviceID = captureProps.DeviceID;
+ capturer.OutputFile = captureProps.OutputFile;
+ capturer.OutputHeight = captureProps.Height;
+ capturer.OutputWidth = captureProps.Width;
+ capturer.SetVideoEncoder(captureProps.VideoEncoder);
+ capturer.SetAudioEncoder(captureProps.AudioEncoder);
+ capturer.SetVideoMuxer(captureProps.Muxer);
+ capturer.SetSource(captureProps.CaptureSourceType);
+ capturer.VideoBitrate = captureProps.VideoBitrate;
+ capturer.AudioBitrate = captureProps.AudioBitrate;
+ }
+
+ protected virtual void OnRecbuttonClicked (object sender, System.EventArgs e)
+ {
+ if (capturer == null)
+ return;
+
+ if (captureStarted == true){
+ if (capturing)
+ return;
+ TogglePause();
+ }
+ else
+ Start();
+ }
+
+ protected virtual void OnPausebuttonClicked (object sender, System.EventArgs e)
+ {
+ if (capturer != null && capturing)
+ TogglePause();
+ }
+
+ protected virtual void OnStopbuttonClicked (object sender, System.EventArgs e)
+ {
+ int res;
+
+ if (capturer == null)
+ return;
+
+ MessageDialog md = new MessageDialog((Gtk.Window)this.Toplevel, DialogFlags.Modal, MessageType.Question, ButtonsType.YesNo,
+ Catalog.GetString("You are going to stop and finish the current capture."+"\n"+
+ "Do you want to proceed?"));
+ res = md.Run();
+ md.Destroy();
+ if (res == (int)ResponseType.Yes){
+ md = new MessageDialog((Gtk.Window)this.Toplevel, DialogFlags.Modal, MessageType.Info, ButtonsType.None,
+ Catalog.GetString("Finalizing file. This can take a while"));
+ md.Show();
+ Stop();
+ md.Destroy();
+ recbutton.Visible = true;
+ pausebutton.Visible = false;
+ stopbutton.Visible = false;
+ if (CaptureFinished != null)
+ CaptureFinished(this, new EventArgs());
+ }
+ }
+
+ protected virtual void OnTick (int ellapsedTime){
+ timelabel.Text = "Time: " + TimeString.MSecondsToSecondsString(CurrentTime);
+ }
+
+ protected virtual void OnError (object o, ErrorArgs args)
+ {
+ if (Error != null)
+ Error (o, args);
+
+ Close();
+ }
+
+ protected virtual void OnDeviceChange (object o, DeviceChangeArgs args)
+ {
+ /* device disconnected, pause capture */
+ if (args.DeviceChange == -1){
+ if (capturing)
+ TogglePause();
+
+ recbutton.Sensitive = false;
+
+ MessageDialog md = new MessageDialog((Gtk.Window)this.Toplevel, DialogFlags.Modal,
+ MessageType.Question, ButtonsType.Ok,
+ Catalog.GetString("Device disconnected. " +
+ "The capture will be paused"));
+ md.Icon=Stetic.IconLoader.LoadIcon(md, "longomatch", Gtk.IconSize.Dialog, 48);
+ md.Run();
+ md.Destroy();
+ } else {
+ recbutton.Sensitive = true;
+ MessageDialog md = new MessageDialog((Gtk.Window)this.Toplevel, DialogFlags.Modal,
+ MessageType.Question, ButtonsType.YesNo,
+ Catalog.GetString("Device reconnected." +
+ "Do you want to restart the capture?"));
+ md.Icon=Stetic.IconLoader.LoadIcon(md, "longomatch", Gtk.IconSize.Dialog, 48);
+ if (md.Run() == (int)ResponseType.Yes){
+ Console.WriteLine ("Accepted to toggle pause");
+ TogglePause();
+ }
+ md.Destroy();
+ }
+ }
+
+ protected virtual void OnLogodrawingareaExposeEvent (object o, Gtk.ExposeEventArgs args)
+ {
+ Gdk.Window win;
+ Pixbuf frame;
+ int width, height, allocWidth, allocHeight, logoX, logoY;
+ float ratio;
+
+ if (logopix == null)
+ return;
+
+ win = logodrawingarea.GdkWindow;
+ width = logopix.Width;
+ height = logopix.Height;
+ allocWidth = logodrawingarea.Allocation.Width;
+ allocHeight = logodrawingarea.Allocation.Height;
+
+ /* Checking if allocated space is smaller than our logo */
+ if ((float) allocWidth / width > (float) allocHeight / height) {
+ ratio = (float) allocHeight / height;
+ } else {
+ ratio = (float) allocWidth / width;
+ }
+ width = (int) (width * ratio);
+ height = (int) (height * ratio);
+
+ logoX = (allocWidth / 2) - (width / 2);
+ logoY = (allocHeight / 2) - (height / 2);
+
+ /* Drawing our frame */
+ frame = new Pixbuf(Colorspace.Rgb, false, 8, allocWidth, allocHeight);
+ logopix.Composite(frame, 0, 0, allocWidth, allocHeight, logoX, logoY,
+ ratio, ratio, InterpType.Bilinear, 255);
+
+ win.DrawPixbuf (this.Style.BlackGC, frame, 0, 0,
+ 0, 0, allocWidth, allocHeight,
+ RgbDither.Normal, 0, 0);
+ frame.Dispose();
+ return;
+ }
+ }
+}
diff --git a/CesarPlayer/Gui/PlayerBin.cs b/CesarPlayer/Gui/PlayerBin.cs
new file mode 100644
index 0000000..7a99fc7
--- /dev/null
+++ b/CesarPlayer/Gui/PlayerBin.cs
@@ -0,0 +1,619 @@
+// PlayerBin.cs
+//
+// Copyright (C) 2007-2009 Andoni Morales Alastruey
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+//Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+//
+using System;
+using Gtk;
+using Gdk;
+using Mono.Unix;
+using System.Runtime.InteropServices;
+using LongoMatch.Video;
+using LongoMatch.Video.Common;
+using LongoMatch.Video.Player;
+using LongoMatch.Video.Utils;
+
+namespace LongoMatch.Gui
+{
+ [System.ComponentModel.Category("LongoMatch")]
+ [System.ComponentModel.ToolboxItem(true)]
+
+ public partial class PlayerBin : Gtk.Bin
+ {
+
+ public event SegmentClosedHandler SegmentClosedEvent;
+ public event TickHandler Tick;
+ public event ErrorHandler Error;
+ public event StateChangeHandler PlayStateChanged;
+ public event NextButtonClickedHandler Next;
+ public event PrevButtonClickedHandler Prev;
+ public event DrawFrameHandler DrawFrame;
+ public event SeekEventHandler SeekEvent;
+
+ private const int THUMBNAIL_MAX_WIDTH = 100;
+ private TickHandler tickHandler;
+ private IPlayer player;
+ private long length=0;
+ private string slength;
+ private long segmentStartTime;
+ private long segmentStopTime;
+ private bool seeking=false;
+ private double[] seeksQueue;
+ private bool IsPlayingPrevState = false;
+ private float rate=1;
+ private double previousVLevel = 1;
+ private bool muted=false;
+ private object[] pendingSeek=null; //{start,stop,rate}
+ //the player.mrl is diferent from the filename as it's an uri eg:file:///foo.avi
+ private string filename = null;
+ protected VolumeWindow vwin;
+
+
+#region Constructors
+ public PlayerBin()
+ {
+ this.Build();
+ PlayerInit();
+ vwin = new VolumeWindow();
+ vwin.VolumeChanged += new VolumeChangedHandler(OnVolumeChanged);
+ controlsbox.Visible = false;
+ UnSensitive();
+ timescale.Adjustment.PageIncrement = 0.01;
+ timescale.Adjustment.StepIncrement = 0.0001;
+ playbutton.CanFocus = false;
+ prevbutton.CanFocus = false;
+ nextbutton.CanFocus = false;
+ volumebutton.CanFocus = false;
+ timescale.CanFocus = false;
+ vscale1.CanFocus = false;
+ drawbutton.CanFocus = false;
+ seeksQueue = new double[2];
+ seeksQueue [0] = -1;
+ seeksQueue [1] = -1;
+ }
+
+#endregion
+
+#region Properties
+
+ public IPlayer Player{
+ get{return player;}
+ }
+
+ public long AccurateCurrentTime{
+ get{return player.AccurateCurrentTime;}
+ }
+
+ public long CurrentTime{
+ get{return player.CurrentTime;}
+ }
+
+ public long StreamLength{
+ get{return player.StreamLength;}
+ }
+
+ public float Rate{
+ get{return rate;}
+ set{vscale1.Value = (int)(value*25);}
+ }
+
+ public bool FullScreen{
+ set{
+ if (value)
+ GdkWindow.Fullscreen();
+ else
+ GdkWindow.Unfullscreen();
+ }
+ }
+
+ public Pixbuf CurrentMiniatureFrame{
+ get{
+ Pixbuf pixbuf = player.GetCurrentFrame(THUMBNAIL_MAX_WIDTH,THUMBNAIL_MAX_WIDTH);
+ return pixbuf;
+ }
+ }
+
+ public Pixbuf CurrentFrame{
+ get{return player.GetCurrentFrame();}
+ }
+
+ public Pixbuf LogoPixbuf{
+ set{player.LogoPixbuf = value;}
+ }
+
+ public bool DrawingMode {
+ set{player.DrawingMode= value;}
+ }
+
+ public Pixbuf DrawingPixbuf {
+ set{player.DrawingPixbuf=value;}
+ }
+
+ public bool LogoMode{
+ set{player.LogoMode = value;}
+ }
+
+ public bool ExpandLogo {
+ get{return player.ExpandLogo;}
+ set{player.ExpandLogo = value;}
+ }
+
+ public bool Opened {
+ get{return filename != null;}
+ }
+
+ public Widget VideoWidget{
+ get{return ((Gtk.EventBox)player);}
+ }
+#endregion
+
+#region Public methods
+
+ public void Open (string mrl){
+ filename = mrl;
+ ResetGui();
+ CloseActualSegment();
+ try{
+ player.Open(mrl);
+ }
+ catch {
+ //We handle this error async
+ }
+ }
+
+ public void Play(){
+ player.Play();
+ float val = GetRateFromScale();
+ if (segmentStartTime == 0 && segmentStopTime==0)
+ player.SetRate(val);
+ else
+ player.SetRateInSegment(val,segmentStopTime);
+ }
+
+ public void Pause(){
+ player.Pause();
+ }
+
+ public void TogglePlay(){
+ if (player.Playing)
+ Pause();
+ else
+ Play();
+ }
+
+ public void SetLogo (string filename){
+ player.Logo=filename;
+ }
+
+ public void ResetGui(){
+ closebutton.Hide();
+ SetSensitive();
+ timescale.Value=0;
+ timelabel.Text="";
+ player.CancelProgramedStop();
+ }
+
+ public void SetPlayListElement(string fileName,long start, long stop, float rate, bool hasNext){
+ if (hasNext)
+ nextbutton.Sensitive = true;
+ else
+ nextbutton.Sensitive = false;
+
+ if (fileName != filename){
+ Open(fileName);
+ //Wait until the pipeline is prerolled and ready to seek
+ pendingSeek = new object[3] {start,stop,rate};
+ }
+ else player.SegmentSeek(start,stop,rate);
+
+ segmentStartTime = start;
+ segmentStopTime = stop;
+ player.LogoMode = false;
+ Rate = rate;
+ }
+
+ public void Close(){
+ player.Close();
+ filename = null;
+ timescale.Value = 0;
+ UnSensitive();
+ }
+
+ public void SeekTo(long time, bool accurate){
+ player.SeekTime(time,1,accurate);
+ if (SeekEvent != null)
+ SeekEvent(time);
+ }
+
+ public void SeekInSegment(long pos){
+ player.SeekInSegment(pos, GetRateFromScale());
+ if (SeekEvent != null)
+ SeekEvent(pos);
+ }
+
+ public void SeekToNextFrame(bool in_segment){
+ int currentTime = (int)player.CurrentTime;
+ if (segmentStopTime==0 | currentTime < segmentStopTime){
+ if (player.Playing)
+ player.Pause();
+ player.SeekToNextFrame( GetRateFromScale(), in_segment);
+ if (SeekEvent != null)
+ SeekEvent(currentTime );
+ }
+
+ }
+
+ public void SeekToPreviousFrame(bool in_segment){
+ long currentTime = player.CurrentTime;
+ if (currentTime> segmentStartTime){
+ if (player.Playing)
+ player.Pause();
+ player.SeekToPreviousFrame( GetRateFromScale(),in_segment);
+ if (SeekEvent != null)
+ SeekEvent(currentTime);
+ }
+ }
+
+ public void StepForward(){
+ SeekFromTimescale(timescale.Value + timescale.Adjustment.PageIncrement);
+ }
+
+ public void StepBackward(){
+ SeekFromTimescale(timescale.Value - timescale.Adjustment.PageIncrement);
+ }
+
+ public void FramerateUp(){
+ vscale1.Adjustment.Value += vscale1.Adjustment.StepIncrement;
+ }
+
+ public void FramerateDown(){
+ vscale1.Adjustment.Value -= vscale1.Adjustment.StepIncrement;
+ }
+
+ public void UpdateSegmentStartTime (long start){
+ segmentStartTime = start;
+ player.SegmentStartUpdate(start, GetRateFromScale());
+ if (SeekEvent != null)
+ SeekEvent(start);
+ }
+
+ public void UpdateSegmentStopTime (long stop){
+ segmentStopTime = stop;
+ player.SegmentStopUpdate(stop, GetRateFromScale());
+ if (SeekEvent != null)
+ SeekEvent(stop);
+ }
+
+ public void SetStartStop(long start, long stop){
+ segmentStartTime = start;
+ segmentStopTime = stop;
+ closebutton.Show();
+ vscale1.Value = 25;
+ player.SegmentSeek(start,stop, GetRateFromScale());
+ player.Play();
+ }
+
+ public void CloseActualSegment(){
+ closebutton.Hide();
+ segmentStartTime = 0;
+ segmentStopTime = 0;
+ vscale1.Value=25;
+ //timescale.Sensitive = true;
+ slength = TimeString.MSecondsToSecondsString(length);
+ SegmentClosedEvent();
+ player.CancelProgramedStop();
+ }
+
+ public void SetSensitive(){
+ controlsbox.Sensitive = true;
+ vscale1.Sensitive = true;
+ }
+
+ public void UnSensitive(){
+ controlsbox.Sensitive = false;
+ vscale1.Sensitive = false;
+ }
+
+#endregion
+
+#region Private methods
+
+ private float GetRateFromScale(){
+ VScale scale= vscale1;
+ double val = scale.Value;
+
+ if (val >25 ){
+ val = val-25 ;
+ }
+ else if (val <=25){
+ val = val/25;
+ }
+ return (float)val;
+ }
+
+ private bool InSegment(){
+ return !(segmentStopTime == 0 && segmentStartTime ==0) ;
+ }
+
+ private void PlayerInit(){
+ MultimediaFactory factory;
+ Widget playerWidget;
+
+ factory= new MultimediaFactory();
+ player = factory.getPlayer(320,280);
+
+ tickHandler = new TickHandler(OnTick);
+ player.Tick += tickHandler;
+ player.StateChange += new StateChangeHandler(OnStateChanged);
+ player.Eos += new EventHandler (OnEndOfStream);
+ player.Error += new ErrorHandler (OnError);
+ player.ReadyToSeek += new EventHandler(OnReadyToSeek);
+
+ playerWidget = (Widget)player;
+ playerWidget.ButtonPressEvent += OnVideoboxButtonPressEvent;
+ playerWidget.ScrollEvent += OnVideoboxScrollEvent;
+ playerWidget.Show();
+ videobox.Add(playerWidget);
+
+ }
+
+ private void SeekFromTimescale(double pos){
+ if (InSegment()){
+ long seekPos = segmentStartTime + (long)(pos*(segmentStopTime-segmentStartTime));
+ player.SeekInSegment(seekPos, GetRateFromScale());
+ timelabel.Text= TimeString.MSecondsToSecondsString(seekPos) + "/" +
+ TimeString.MSecondsToSecondsString(segmentStopTime-segmentStartTime);
+ }
+ else {
+ player.Position = pos;
+ timelabel.Text= TimeString.MSecondsToSecondsString(player.CurrentTime) + "/" + slength;
+ Rate = 1;
+ }
+ }
+
+#endregion
+
+#region Callbacks
+ protected virtual void OnStateChanged(object o, StateChangeArgs args){
+ if (args.Playing){
+ playbutton.Hide();
+ pausebutton.Show();
+ }
+ else{
+ playbutton.Show();
+ pausebutton.Hide();
+ }
+ if (PlayStateChanged != null)
+ PlayStateChanged(this,args);
+ }
+
+ protected void OnReadyToSeek(object o, EventArgs args){
+ if (pendingSeek != null){
+ player.SegmentSeek((long)pendingSeek[0],
+ (long)pendingSeek[1],
+ (float)pendingSeek[2]);
+ player.Play();
+ pendingSeek = null;
+
+ }
+ }
+
+ protected virtual void OnTick(object o,TickArgs args){
+ long currentTime = args.CurrentTime;
+ float currentposition = args.CurrentPosition;
+ long streamLength = args.StreamLength;
+
+ //Console.WriteLine ("Current Time:{0}\n Length:{1}\n",currentTime, streamLength);
+ if (length != streamLength){
+ length = streamLength;
+ slength = TimeString.MSecondsToSecondsString(length);
+ }
+
+ if (InSegment()){
+ currentTime -= segmentStartTime;
+ currentposition = (float)currentTime/(float)(segmentStopTime-segmentStartTime);
+ slength = TimeString.MSecondsToSecondsString(segmentStopTime-segmentStartTime);
+ }
+
+ timelabel.Text = TimeString.MSecondsToSecondsString(currentTime) + "/" + slength;
+ timescale.Value = currentposition;
+ if (Tick != null)
+ Tick(o,args);
+
+ }
+
+ protected virtual void OnTimescaleAdjustBounds(object o, Gtk.AdjustBoundsArgs args)
+ {
+ double pos;
+
+ if (!seeking){
+ seeking = true;
+ IsPlayingPrevState = player.Playing;
+ player.Tick -= tickHandler;
+ player.Pause();
+ seeksQueue [0] = -1;
+ seeksQueue [1] = -1;
+ }
+
+ pos = timescale.Value;
+ seeksQueue[0] = seeksQueue[1];
+ seeksQueue[1] = pos;
+
+ SeekFromTimescale(pos);
+ }
+
+ protected virtual void OnTimescaleValueChanged(object sender, System.EventArgs e)
+ {
+ if (seeking){
+ /* Releasing the timescale always report value different from the real one.
+ * We need to cache previous position and seek again to the this position */
+ SeekFromTimescale(seeksQueue[0] != -1 ? seeksQueue[0] : seeksQueue[1]);
+ seeking=false;
+ player.Tick += tickHandler;
+ if (IsPlayingPrevState)
+ player.Play();
+ }
+ }
+
+ protected virtual void OnPlaybuttonClicked(object sender, System.EventArgs e)
+ {
+ Play();
+ }
+
+ protected virtual void OnStopbuttonClicked(object sender, System.EventArgs e)
+ {
+ player.SeekTime(segmentStartTime,1,true);
+ }
+
+ protected virtual void OnVolumebuttonClicked(object sender, System.EventArgs e)
+ {
+ vwin.SetLevel(player.Volume);
+ vwin.Show();
+ }
+
+ protected virtual void OnDestroyEvent(object o, Gtk.DestroyEventArgs args)
+ {
+ player.Dispose();
+ }
+
+ protected virtual void OnVolumeChanged(double level){
+ player.Volume = level;
+ if (level == 0)
+ muted = true;
+ else
+ muted = false;
+ }
+
+ protected virtual void OnPausebuttonClicked (object sender, System.EventArgs e)
+ {
+ player.Pause();
+ }
+
+ protected virtual void OnEndOfStream (object o, EventArgs args){
+ player.SeekInSegment(0, GetRateFromScale());
+ player.Pause();
+ }
+
+
+ protected virtual void OnError (object o, ErrorArgs args){
+ if(Error != null)
+ Error(o,args);
+ }
+
+ protected virtual void OnClosebuttonClicked (object sender, System.EventArgs e)
+ {
+ CloseActualSegment();
+ }
+
+ protected virtual void OnPrevbuttonClicked (object sender, System.EventArgs e)
+ {
+ if (Prev != null)
+ Prev();
+ }
+
+ protected virtual void OnNextbuttonClicked (object sender, System.EventArgs e)
+ {
+ if (Next != null)
+ Next();
+ }
+
+ protected virtual void OnVscale1FormatValue (object o, Gtk.FormatValueArgs args)
+ {
+ double val = args.Value;
+ if (val >25 ){
+ val = val-25 ;
+ args.RetVal = val +"X";
+ }
+ else if (val ==25){
+ args.RetVal = "1X";
+ }
+ else if (val <25){
+ args.RetVal = "-"+val+"/25"+"X";
+ }
+ }
+
+ protected virtual void OnVscale1ValueChanged (object sender, System.EventArgs e)
+ {
+ float val = GetRateFromScale();
+
+ // Mute for rate != 1
+ if (val != 1 && player.Volume != 0){
+ previousVLevel = player.Volume;
+ player.Volume=0;
+ }
+ else if (val != 1 && muted)
+ previousVLevel = 0;
+ else if (val ==1)
+ player.Volume = previousVLevel;
+
+ if (InSegment()){
+ player.SetRateInSegment(val,segmentStopTime);
+ }
+ else
+ player.SetRate(val);
+ rate = val;
+ }
+
+ protected virtual void OnVideoboxButtonPressEvent (object o, Gtk.ButtonPressEventArgs args)
+ {
+ if(filename == null)
+ return;
+ /* FIXME: The pointer is grabbed when the event box is clicked.
+ * Make sure to ungrab it in order to avoid clicks outisde the window
+ * triggering this callback. This should be fixed properly.*/
+ Pointer.Ungrab(Gtk.Global.CurrentEventTime);
+ if (!player.Playing)
+ Play();
+ else
+ Pause();
+ }
+
+ protected virtual void OnVideoboxScrollEvent (object o, Gtk.ScrollEventArgs args)
+ {
+ switch (args.Event.Direction){
+ case ScrollDirection.Down:
+ SeekToPreviousFrame(InSegment());
+ break;
+ case ScrollDirection.Up:
+ SeekToNextFrame(InSegment());
+ break;
+ case ScrollDirection.Left:
+ StepBackward();
+ break;
+ case ScrollDirection.Right:
+ StepForward();
+ break;
+ }
+ }
+
+ protected virtual void OnDrawButtonClicked (object sender, System.EventArgs e)
+ {
+ int currentTime;
+
+ currentTime = (int)AccurateCurrentTime;
+ // If the player has reached the end of the segment the current time
+ // will be unseekable and it's not possible to get a frame at this
+ // instant. If we exceed the segment stop time, decrease in a
+ // milisecond the position.
+ if (InSegment() && currentTime >= segmentStopTime)
+ currentTime -= 1;
+ if (DrawFrame != null)
+ DrawFrame(currentTime);
+ }
+#endregion
+ }
+}
diff --git a/CesarPlayer/Gui/VolumeWindow.cs b/CesarPlayer/Gui/VolumeWindow.cs
new file mode 100644
index 0000000..6b4945e
--- /dev/null
+++ b/CesarPlayer/Gui/VolumeWindow.cs
@@ -0,0 +1,70 @@
+// VolumeWindow.cs
+//
+// Copyright (C) 2007-2009 Andoni Morales Alastruey
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+//
+using System;
+using LongoMatch.Video.Common;
+
+namespace LongoMatch.Gui
+{
+
+
+ public partial class VolumeWindow : Gtk.Window
+ {
+
+
+
+ public event VolumeChangedHandler VolumeChanged;
+
+
+ public VolumeWindow() :
+ base(Gtk.WindowType.Toplevel)
+ {
+ this.Build();
+ volumescale.Adjustment.PageIncrement = 0.0001;
+ volumescale.Adjustment.StepIncrement = 0.0001;
+ }
+
+ public void SetLevel(double level){
+ volumescale.Value = level ;
+ }
+
+ protected virtual void OnLessbuttonClicked(object sender, System.EventArgs e)
+ {
+ volumescale.Value = volumescale.Value - 0.1;
+ }
+
+ protected virtual void OnMorebuttonClicked(object sender, System.EventArgs e)
+ {
+ volumescale.Value = volumescale.Value + 0.1;
+ }
+
+ protected virtual void OnVolumescaleValueChanged(object sender, System.EventArgs e)
+ {
+ VolumeChanged(volumescale.Value);
+ }
+
+ protected virtual void OnFocusOutEvent (object o, Gtk.FocusOutEventArgs args)
+ {
+ this.Hide();
+ }
+
+
+
+ }
+}
diff --git a/CesarPlayer/Makefile.am b/CesarPlayer/Makefile.am
new file mode 100644
index 0000000..b9d4db7
--- /dev/null
+++ b/CesarPlayer/Makefile.am
@@ -0,0 +1,113 @@
+
+EXTRA_DIST =
+
+if ENABLE_DEBUG
+ASSEMBLY_COMPILER_COMMAND = $(GMCS)
+ASSEMBLY_COMPILER_FLAGS = -noconfig -codepage:utf8 -unsafe -warn:4 -optimize+ -debug -define:DEBUG
+ASSEMBLY = bin/Debug/CesarPlayer.dll
+ASSEMBLY_MDB = $(ASSEMBLY).mdb
+COMPILE_TARGET = library
+PROJECT_REFERENCES =
+BUILD_DIR = bin/Debug
+CESARPLAYER_DLL_MDB_SOURCE=bin/Debug/CesarPlayer.dll.mdb
+CESARPLAYER_DLL_MDB=$(BUILD_DIR)/CesarPlayer.dll.mdb
+CESARPLAYER_DLL_CONFIG_SOURCE = CesarPlayer.dll.config
+CESARPLAYER_DLL_CONFIG = $(BUILD_DIR)/CesarPlayer.dll.config
+
+endif
+
+if ENABLE_RELEASE
+ASSEMBLY_COMPILER_COMMAND = $(GMCS)
+ASSEMBLY_COMPILER_FLAGS = -noconfig -codepage:utf8 -unsafe -warn:4 -optimize+
+ASSEMBLY = bin/Release/CesarPlayer.dll
+ASSEMBLY_MDB = $(ASSEMBLY).mdb
+COMPILE_TARGET = library
+PROJECT_REFERENCES =
+BUILD_DIR = bin/Release
+CESARPLAYER_DLL_MDB_SOURCE=
+CESARPLAYER_DLL_MDB=
+CESARPLAYER_DLL_CONFIG_SOURCE = CesarPlayer.dll.config
+CESARPLAYER_DLL_CONFIG = $(BUILD_DIR)/CesarPlayer.dll.config
+
+
+endif
+
+AL=al2
+SATELLITE_ASSEMBLY_NAME=$(notdir $(basename $(ASSEMBLY))).resources.dll
+
+PROGRAMFILES = \
+ $(CESARPLAYER_DLL_MDB)\
+ $(CESARPLAYER_DLL_CONFIG)
+
+RESGEN=resgen2
+
+all: $(ASSEMBLY) $(PROGRAMFILES)
+
+FILES = \
+ AssemblyInfo.cs \
+ gtk-gui/generated.cs \
+ Common/Constants.cs\
+ Common/Enum.cs\
+ Common/Handlers.cs\
+ Player/GstPlayer.cs \
+ Player/IPlayer.cs \
+ Player/ObjectManager.cs \
+ gtk-gui/LongoMatch.Gui.CapturerBin.cs \
+ gtk-gui/LongoMatch.Gui.PlayerBin.cs \
+ gtk-gui/LongoMatch.Gui.VolumeWindow.cs \
+ Gui/CapturerBin.cs \
+ Gui/PlayerBin.cs \
+ Gui/VolumeWindow.cs \
+ MultimediaFactory.cs \
+ Utils/IFramesCapturer.cs \
+ Utils/FramesCapturer.cs \
+ Utils/IMetadataReader.cs \
+ Utils/TimeString.cs \
+ Capturer/CaptureProperties.cs \
+ Capturer/GstCameraCapturer.cs \
+ Capturer/FakeCapturer.cs \
+ Capturer/ICapturer.cs \
+ Capturer/LiveSourceTimer.cs \
+ Capturer/ObjectManager.cs \
+ Editor/GstVideoSplitter.cs \
+ Editor/IVideoEditor.cs \
+ Editor/IVideoSplitter.cs \
+ Editor/VideoSegment.cs \
+ Editor/EditorState.cs \
+ Utils/Device.cs \
+ Utils/MediaFile.cs \
+ Utils/PreviewMediaFile.cs
+
+DATA_FILES =
+
+RESOURCES = \
+ gtk-gui/objects.xml \
+ gtk-gui/gui.stetic
+
+EXTRAS = \
+ cesarplayer.key\
+ CesarPlayer.dll.config\
+ AssemblyInfo.cs.in
+
+REFERENCES = \
+ System \
+ Mono.Posix \
+ System.Drawing \
+ $(GTK_SHARP_20_LIBS) \
+ $(GLIB_SHARP_20_LIBS)
+
+DLL_REFERENCES =
+
+CLEANFILES = $(PROGRAMFILES)
+
+include $(top_srcdir)/Makefile.include
+
+$(eval $(call emit-deploy-target,CESARPLAYER_DLL_CONFIG))
+
+$(eval $(call emit_resgen_targets))
+$(build_xamlg_list): %.xaml.g.cs: %.xaml
+ xamlg '$<'
+
+$(ASSEMBLY) $(ASSEMBLY_MDB): $(build_sources) $(build_resources) $(build_datafiles) $(DLL_REFERENCES) $(PROJECT_REFERENCES) $(build_xamlg_list) $(build_satellite_assembly_list)
+ mkdir -p $(shell dirname $(ASSEMBLY))
+ $(ASSEMBLY_COMPILER_COMMAND) $(ASSEMBLY_COMPILER_FLAGS) -out:$(ASSEMBLY) -target:$(COMPILE_TARGET) $(build_sources_embed) $(build_resources_embed) $(build_references_ref)
diff --git a/CesarPlayer/MultimediaFactory.cs b/CesarPlayer/MultimediaFactory.cs
new file mode 100644
index 0000000..a9712c1
--- /dev/null
+++ b/CesarPlayer/MultimediaFactory.cs
@@ -0,0 +1,108 @@
+// PlayerMaker.cs
+//
+// Copyright(C) 2007-2009 Andoni Morales Alastruey
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+//Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+//
+
+using System;
+using LongoMatch.Video.Capturer;
+using LongoMatch.Video.Player;
+using LongoMatch.Video.Editor;
+using LongoMatch.Video.Utils;
+using LongoMatch.Video.Common;
+
+namespace LongoMatch.Video
+{
+
+
+ public class MultimediaFactory
+ {
+
+ OperatingSystem oS;
+
+ public MultimediaFactory()
+ {
+ oS = Environment.OSVersion;
+ }
+
+ public IPlayer getPlayer(int width, int height){
+ switch (oS.Platform) {
+ case PlatformID.Unix:
+ return new GstPlayer(width,height,PlayerUseType.Video);
+
+ case PlatformID.Win32NT:
+ return new GstPlayer(width,height,PlayerUseType.Video);
+
+ default:
+ return new GstPlayer(width,height,PlayerUseType.Video);
+ }
+ }
+
+ public IMetadataReader getMetadataReader(){
+
+ switch (oS.Platform) {
+ case PlatformID.Unix:
+ return new GstPlayer(1,1,PlayerUseType.Metadata);
+
+ case PlatformID.Win32NT:
+ return new GstPlayer(1,1,PlayerUseType.Metadata);
+
+ default:
+ return new GstPlayer(1,1,PlayerUseType.Metadata);
+ }
+ }
+
+ public IFramesCapturer getFramesCapturer(){
+ switch (oS.Platform) {
+ case PlatformID.Unix:
+ return new GstPlayer(1,1,PlayerUseType.Capture);
+
+ case PlatformID.Win32NT:
+ return new GstPlayer(1,1,PlayerUseType.Capture);
+
+ default:
+ return new GstPlayer(1,1,PlayerUseType.Capture);
+ }
+ }
+
+ public IVideoEditor getVideoEditor(){
+ switch (oS.Platform) {
+ case PlatformID.Unix:
+ return new GstVideoSplitter();
+
+ case PlatformID.Win32NT:
+ return new GstVideoSplitter();
+
+ default:
+ return new GstVideoSplitter();
+ }
+ }
+
+ public ICapturer getCapturer(CapturerType type){
+ switch (type) {
+ case CapturerType.Fake:
+ return new FakeCapturer();
+
+ case CapturerType.Live:
+ return new GstCameraCapturer("test.avi");
+
+ default:
+ return new FakeCapturer();
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/CesarPlayer/Player/GstDVDEvent.cs b/CesarPlayer/Player/GstDVDEvent.cs
new file mode 100644
index 0000000..bd66d5f
--- /dev/null
+++ b/CesarPlayer/Player/GstDVDEvent.cs
@@ -0,0 +1,46 @@
+// Copyright (C) 2007-2009 Andoni Morales Alastruey
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+//
+
+namespace LongoMatch.Video.Player {
+
+ using System;
+ using System.Runtime.InteropServices;
+
+#region Autogenerated code
+ public enum GstDVDEvent {
+
+ RootMenu,
+ TitleMenu,
+ SubpictureMenu,
+ AudioMenu,
+ AngleMenu,
+ ChapterMenu,
+ NextChapter,
+ PrevChapter,
+ NextTitle,
+ PrevTitle,
+ NextAngle,
+ PrevAngle,
+ RootMenuUp,
+ RootMenuDown,
+ RootMenuLeft,
+ RootMenuRight,
+ RootMenuSelect,
+ }
+#endregion
+}
diff --git a/CesarPlayer/Player/GstPlayer.cs b/CesarPlayer/Player/GstPlayer.cs
new file mode 100644
index 0000000..6f51e51
--- /dev/null
+++ b/CesarPlayer/Player/GstPlayer.cs
@@ -0,0 +1,1415 @@
+// Copyright(C) 2007-2009 Andoni Morales Alastruey
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+//
+
+namespace LongoMatch.Video.Player {
+
+ using System;
+ using System.Collections;
+ using System.Runtime.InteropServices;
+ using LongoMatch.Video.Common;
+ using LongoMatch.Video.Utils;
+
+#region Autogenerated code
+ public class GstPlayer : Gtk.EventBox,IPlayer, IMetadataReader, IFramesCapturer{
+
+ [Obsolete]
+ protected GstPlayer(GLib.GType gtype) : base(gtype) {}
+ public GstPlayer(IntPtr raw) : base(raw) {}
+
+ [DllImport("libcesarplayer.dll")]
+ static extern unsafe IntPtr bacon_video_widget_new(int width, int height, int type, out IntPtr error);
+
+ public unsafe GstPlayer (int width, int height, PlayerUseType type) : base (IntPtr.Zero)
+ {
+ if (GetType () != typeof (GstPlayer)) {
+ throw new InvalidOperationException ("Can't override this constructor.");
+ }
+ IntPtr error = IntPtr.Zero;
+ Raw = bacon_video_widget_new(width, height, (int) type, out error);
+ if (error != IntPtr.Zero) throw new GLib.GException (error);
+ }
+
+ [GLib.Property ("seekable")]
+ public bool Seekable {
+ get {
+ GLib.Value val = GetProperty ("seekable");
+ bool ret = (bool) val;
+ val.Dispose ();
+ return ret;
+ }
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern bool bacon_video_widget_get_logo_mode(IntPtr raw);
+
+ [DllImport("libcesarplayer.dll")]
+ static extern void bacon_video_widget_set_logo_mode(IntPtr raw, bool logo_mode);
+
+ [GLib.Property ("logo_mode")]
+ public bool LogoMode {
+ get {
+ bool raw_ret = bacon_video_widget_get_logo_mode(Handle);
+ bool ret = raw_ret;
+ return ret;
+ }
+ set {
+ bacon_video_widget_set_logo_mode(Handle, value);
+ }
+ }
+
+ [GLib.Property ("expand_logo")]
+ public bool ExpandLogo {
+ get {
+ GLib.Value val = GetProperty ("expand_logo");
+ bool ret = (bool) val;
+ val.Dispose ();
+ return ret;
+ }
+ set {
+ GLib.Value val = new GLib.Value(value);
+ SetProperty("expand_logo", val);
+ val.Dispose ();
+ }
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern long bacon_video_widget_get_stream_length(IntPtr raw);
+
+ [GLib.Property ("stream_length")]
+ public long StreamLength {
+ get {
+ long raw_ret = bacon_video_widget_get_stream_length(Handle);
+ long ret = raw_ret;
+ return ret;
+ }
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern double bacon_video_widget_get_volume(IntPtr raw);
+
+ [DllImport("libcesarplayer.dll")]
+ static extern void bacon_video_widget_set_volume(IntPtr raw, double volume);
+
+ [GLib.Property ("volume")]
+ public double Volume {
+ get {
+ double raw_ret = bacon_video_widget_get_volume(Handle);
+ double ret = raw_ret;
+ return ret;
+ }
+ set {
+ bacon_video_widget_set_volume(Handle, value);
+ }
+ }
+
+ [GLib.Property ("showcursor")]
+ public bool Showcursor {
+ get {
+ GLib.Value val = GetProperty ("showcursor");
+ bool ret = (bool) val;
+ val.Dispose ();
+ return ret;
+ }
+ set {
+ GLib.Value val = new GLib.Value(value);
+ SetProperty("showcursor", val);
+ val.Dispose ();
+ }
+ }
+
+ [GLib.Property ("playing")]
+ public bool Playing {
+ get {
+ GLib.Value val = GetProperty ("playing");
+ bool ret = (bool) val;
+ val.Dispose ();
+ return ret;
+ }
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern double bacon_video_widget_get_position(IntPtr raw);
+
+ [GLib.Property ("position")]
+ public double Position {
+ get {
+ double raw_ret = bacon_video_widget_get_position(Handle);
+ double ret = raw_ret;
+ return ret;
+ }
+ set {
+ this.Seek(value,1);
+ }
+
+ }
+
+ [GLib.Property ("mediadev")]
+ public string Mediadev {
+ get {
+ GLib.Value val = GetProperty ("mediadev");
+ string ret = (string) val;
+ val.Dispose ();
+ return ret;
+ }
+ set {
+ GLib.Value val = new GLib.Value(value);
+ SetProperty("mediadev", val);
+ val.Dispose ();
+ }
+ }
+
+#pragma warning disable 0169
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ delegate void ReadyToSeekVMDelegate (IntPtr bvw);
+
+ static ReadyToSeekVMDelegate ReadyToSeekVMCallback;
+
+ static void readytoseek_cb (IntPtr bvw)
+ {
+ try {
+ GstPlayer bvw_managed = GLib.Object.GetObject (bvw, false) as GstPlayer;
+ bvw_managed.OnReadyToSeek ();
+ } catch (Exception e) {
+ GLib.ExceptionManager.RaiseUnhandledException (e, false);
+ }
+ }
+
+ private static void OverrideReadyToSeek (GLib.GType gtype)
+ {
+ if (ReadyToSeekVMCallback == null)
+ ReadyToSeekVMCallback = new ReadyToSeekVMDelegate (readytoseek_cb);
+ OverrideVirtualMethod (gtype, "ready_to_seek", ReadyToSeekVMCallback);
+ }
+
+ [GLib.DefaultSignalHandler(Type=typeof(LongoMatch.Video.Player.GstPlayer), ConnectionMethod="OverrideReadyToSeek")]
+ protected virtual void OnReadyToSeek ()
+ {
+ GLib.Value ret = GLib.Value.Empty;
+ GLib.ValueArray inst_and_params = new GLib.ValueArray (1);
+ GLib.Value[] vals = new GLib.Value [1];
+ vals [0] = new GLib.Value (this);
+ inst_and_params.Append (vals [0]);
+ g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
+ foreach (GLib.Value v in vals)
+ v.Dispose ();
+ }
+
+ [GLib.Signal("ready_to_seek")]
+ public event System.EventHandler ReadyToSeek {
+ add {
+ GLib.Signal sig = GLib.Signal.Lookup (this, "ready_to_seek");
+ sig.AddDelegate (value);
+ }
+ remove {
+ GLib.Signal sig = GLib.Signal.Lookup (this, "ready_to_seek");
+ sig.RemoveDelegate (value);
+ }
+ }
+
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ delegate void StateChangeVMDelegate (IntPtr bvw, bool playing);
+
+ static StateChangeVMDelegate StateChangeVMCallback;
+
+ static void statechange_cb (IntPtr bvw, bool playing)
+ {
+ try {
+ GstPlayer bvw_managed = GLib.Object.GetObject (bvw, false) as GstPlayer;
+ bvw_managed.OnStateChange (playing);
+ } catch (Exception e) {
+ GLib.ExceptionManager.RaiseUnhandledException (e, false);
+ }
+ }
+
+ private static void OverrideStateChange (GLib.GType gtype)
+ {
+ if (StateChangeVMCallback == null)
+ StateChangeVMCallback = new StateChangeVMDelegate (statechange_cb);
+ OverrideVirtualMethod (gtype, "state_change", StateChangeVMCallback);
+ }
+
+ [GLib.DefaultSignalHandler(Type=typeof(LongoMatch.Video.Player.GstPlayer), ConnectionMethod="OverrideStateChange")]
+ protected virtual void OnStateChange (bool playing)
+ {
+ GLib.Value ret = GLib.Value.Empty;
+ GLib.ValueArray inst_and_params = new GLib.ValueArray (2);
+ GLib.Value[] vals = new GLib.Value [2];
+ vals [0] = new GLib.Value (this);
+ inst_and_params.Append (vals [0]);
+ vals [1] = new GLib.Value (playing);
+ inst_and_params.Append (vals [1]);
+ g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
+ foreach (GLib.Value v in vals)
+ v.Dispose ();
+ }
+
+ [GLib.Signal("state_change")]
+ public event StateChangeHandler StateChange {
+ add {
+ GLib.Signal sig = GLib.Signal.Lookup (this, "state_change", typeof (StateChangeArgs));
+ sig.AddDelegate (value);
+ }
+ remove {
+ GLib.Signal sig = GLib.Signal.Lookup (this, "state_change", typeof (StateChangeArgs));
+ sig.RemoveDelegate (value);
+ }
+ }
+
+ /*[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ delegate void GotRedirectVMDelegate (IntPtr bvw, IntPtr mrl);
+
+ static GotRedirectVMDelegate GotRedirectVMCallback;
+
+ static void gotredirect_cb (IntPtr bvw, IntPtr mrl)
+ {
+ try {
+ GstPlayer bvw_managed = GLib.Object.GetObject (bvw, false) as GstPlayer;
+ bvw_managed.OnGotRedirect (GLib.Marshaller.Utf8PtrToString (mrl));
+ } catch (Exception e) {
+ GLib.ExceptionManager.RaiseUnhandledException (e, false);
+ }
+ }
+
+ private static void OverrideGotRedirect (GLib.GType gtype)
+ {
+ if (GotRedirectVMCallback == null)
+ GotRedirectVMCallback = new GotRedirectVMDelegate (gotredirect_cb);
+ OverrideVirtualMethod (gtype, "got-redirect", GotRedirectVMCallback);
+ }
+
+ [GLib.DefaultSignalHandler(Type=typeof(LongoMatch.Video.Player.GstPlayer), ConnectionMethod="OverrideGotRedirect")]
+ protected virtual void OnGotRedirect (string mrl)
+ {
+ GLib.Value ret = GLib.Value.Empty;
+ GLib.ValueArray inst_and_params = new GLib.ValueArray (2);
+ GLib.Value[] vals = new GLib.Value [2];
+ vals [0] = new GLib.Value (this);
+ inst_and_params.Append (vals [0]);
+ vals [1] = new GLib.Value (mrl);
+ inst_and_params.Append (vals [1]);
+ g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
+ foreach (GLib.Value v in vals)
+ v.Dispose ();
+ }
+
+ [GLib.Signal("got-redirect")]
+ public event GotRedirectHandler GotRedirect {
+ add {
+ GLib.Signal sig = GLib.Signal.Lookup (this, "got-redirect", typeof (LongoMatch.GotRedirectArgs));
+ sig.AddDelegate (value);
+ }
+ remove {
+ GLib.Signal sig = GLib.Signal.Lookup (this, "got-redirect", typeof (LongoMatch.GotRedirectArgs));
+ sig.RemoveDelegate (value);
+ }
+ }*/
+
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ delegate void SegmentDoneVMDelegate (IntPtr bvw);
+
+ static SegmentDoneVMDelegate SegmentDoneVMCallback;
+
+ static void segmentdone_cb (IntPtr bvw)
+ {
+ try {
+ GstPlayer bvw_managed = GLib.Object.GetObject (bvw, false) as GstPlayer;
+ bvw_managed.OnSegmentDone ();
+ } catch (Exception e) {
+ GLib.ExceptionManager.RaiseUnhandledException (e, false);
+ }
+ }
+
+ private static void OverrideSegmentDone (GLib.GType gtype)
+ {
+ if (SegmentDoneVMCallback == null)
+ SegmentDoneVMCallback = new SegmentDoneVMDelegate (segmentdone_cb);
+ OverrideVirtualMethod (gtype, "segment_done", SegmentDoneVMCallback);
+ }
+
+ [GLib.DefaultSignalHandler(Type=typeof(LongoMatch.Video.Player.GstPlayer), ConnectionMethod="OverrideSegmentDone")]
+ protected virtual void OnSegmentDone ()
+ {
+ GLib.Value ret = GLib.Value.Empty;
+ GLib.ValueArray inst_and_params = new GLib.ValueArray (1);
+ GLib.Value[] vals = new GLib.Value [1];
+ vals [0] = new GLib.Value (this);
+ inst_and_params.Append (vals [0]);
+ g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
+ foreach (GLib.Value v in vals)
+ v.Dispose ();
+ }
+
+ [GLib.Signal("segment_done")]
+ public event System.EventHandler SegmentDone {
+ add {
+ GLib.Signal sig = GLib.Signal.Lookup (this, "segment_done");
+ sig.AddDelegate (value);
+ }
+ remove {
+ GLib.Signal sig = GLib.Signal.Lookup (this, "segment_done");
+ sig.RemoveDelegate (value);
+ }
+ }
+
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ delegate void EosVMDelegate (IntPtr bvw);
+
+ static EosVMDelegate EosVMCallback;
+
+ static void eos_cb (IntPtr bvw)
+ {
+ try {
+ GstPlayer bvw_managed = GLib.Object.GetObject (bvw, false) as GstPlayer;
+ bvw_managed.OnEos ();
+ } catch (Exception e) {
+ GLib.ExceptionManager.RaiseUnhandledException (e, false);
+ }
+ }
+
+ private static void OverrideEos (GLib.GType gtype)
+ {
+ if (EosVMCallback == null)
+ EosVMCallback = new EosVMDelegate (eos_cb);
+ OverrideVirtualMethod (gtype, "eos", EosVMCallback);
+ }
+
+ [GLib.DefaultSignalHandler(Type=typeof(LongoMatch.Video.Player.GstPlayer), ConnectionMethod="OverrideEos")]
+ protected virtual void OnEos ()
+ {
+ GLib.Value ret = GLib.Value.Empty;
+ GLib.ValueArray inst_and_params = new GLib.ValueArray (1);
+ GLib.Value[] vals = new GLib.Value [1];
+ vals [0] = new GLib.Value (this);
+ inst_and_params.Append (vals [0]);
+ g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
+ foreach (GLib.Value v in vals)
+ v.Dispose ();
+ }
+
+ [GLib.Signal("eos")]
+ public event System.EventHandler Eos {
+ add {
+ GLib.Signal sig = GLib.Signal.Lookup (this, "eos");
+ sig.AddDelegate (value);
+ }
+ remove {
+ GLib.Signal sig = GLib.Signal.Lookup (this, "eos");
+ sig.RemoveDelegate (value);
+ }
+ }
+
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ delegate void ErrorVMDelegate (IntPtr bvw, IntPtr message);
+
+ static ErrorVMDelegate ErrorVMCallback;
+
+ static void error_cb (IntPtr bvw, IntPtr message)
+ {
+ try {
+ GstPlayer bvw_managed = GLib.Object.GetObject (bvw, false) as GstPlayer;
+ bvw_managed.OnError (GLib.Marshaller.Utf8PtrToString (message));
+ } catch (Exception e) {
+ GLib.ExceptionManager.RaiseUnhandledException (e, false);
+ }
+ }
+
+ private static void OverrideError (GLib.GType gtype)
+ {
+ if (ErrorVMCallback == null)
+ ErrorVMCallback = new ErrorVMDelegate (error_cb);
+ OverrideVirtualMethod (gtype, "error", ErrorVMCallback);
+ }
+
+ [GLib.DefaultSignalHandler(Type=typeof(LongoMatch.Video.Player.GstPlayer), ConnectionMethod="OverrideError")]
+ protected virtual void OnError (string message)
+ {
+ GLib.Value ret = GLib.Value.Empty;
+ GLib.ValueArray inst_and_params = new GLib.ValueArray (2);
+ GLib.Value[] vals = new GLib.Value [2];
+ vals [0] = new GLib.Value (this);
+ inst_and_params.Append (vals [0]);
+ vals [1] = new GLib.Value (message);
+ inst_and_params.Append (vals [1]);
+ g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
+ foreach (GLib.Value v in vals)
+ v.Dispose ();
+ }
+
+ [GLib.Signal("error")]
+ public event ErrorHandler Error {
+ add {
+ GLib.Signal sig = GLib.Signal.Lookup (this, "error", typeof (ErrorArgs));
+ sig.AddDelegate (value);
+ }
+ remove {
+ GLib.Signal sig = GLib.Signal.Lookup (this, "error", typeof (ErrorArgs));
+ sig.RemoveDelegate (value);
+ }
+ }
+
+ /*[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ delegate void BufferingVMDelegate (IntPtr bvw, uint progress);
+
+ static BufferingVMDelegate BufferingVMCallback;
+
+ static void buffering_cb (IntPtr bvw, uint progress)
+ {
+ try {
+ GstPlayer bvw_managed = GLib.Object.GetObject (bvw, false) as GstPlayer;
+ bvw_managed.OnBuffering (progress);
+ } catch (Exception e) {
+ GLib.ExceptionManager.RaiseUnhandledException (e, false);
+ }
+ }
+
+ private static void OverrideBuffering (GLib.GType gtype)
+ {
+ if (BufferingVMCallback == null)
+ BufferingVMCallback = new BufferingVMDelegate (buffering_cb);
+ OverrideVirtualMethod (gtype, "buffering", BufferingVMCallback);
+ }
+
+ [GLib.DefaultSignalHandler(Type=typeof(LongoMatch.Video.Player.GstPlayer), ConnectionMethod="OverrideBuffering")]
+ protected virtual void OnBuffering (uint progress)
+ {
+ GLib.Value ret = GLib.Value.Empty;
+ GLib.ValueArray inst_and_params = new GLib.ValueArray (2);
+ GLib.Value[] vals = new GLib.Value [2];
+ vals [0] = new GLib.Value (this);
+ inst_and_params.Append (vals [0]);
+ vals [1] = new GLib.Value (progress);
+ inst_and_params.Append (vals [1]);
+ g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
+ foreach (GLib.Value v in vals)
+ v.Dispose ();
+ }
+
+ [GLib.Signal("buffering")]
+ public event LongoMatch.BufferingHandler Buffering {
+ add {
+ GLib.Signal sig = GLib.Signal.Lookup (this, "buffering", typeof (LongoMatch.BufferingArgs));
+ sig.AddDelegate (value);
+ }
+ remove {
+ GLib.Signal sig = GLib.Signal.Lookup (this, "buffering", typeof (LongoMatch.BufferingArgs));
+ sig.RemoveDelegate (value);
+ }
+ }*/
+
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ delegate void ChannelsChangeVMDelegate (IntPtr bvw);
+
+ static ChannelsChangeVMDelegate ChannelsChangeVMCallback;
+
+ static void channelschange_cb (IntPtr bvw)
+ {
+ try {
+ GstPlayer bvw_managed = GLib.Object.GetObject (bvw, false) as GstPlayer;
+ bvw_managed.OnChannelsChange ();
+ } catch (Exception e) {
+ GLib.ExceptionManager.RaiseUnhandledException (e, false);
+ }
+ }
+
+ private static void OverrideChannelsChange (GLib.GType gtype)
+ {
+ if (ChannelsChangeVMCallback == null)
+ ChannelsChangeVMCallback = new ChannelsChangeVMDelegate (channelschange_cb);
+ OverrideVirtualMethod (gtype, "channels-change", ChannelsChangeVMCallback);
+ }
+
+ [GLib.DefaultSignalHandler(Type=typeof(LongoMatch.Video.Player.GstPlayer), ConnectionMethod="OverrideChannelsChange")]
+ protected virtual void OnChannelsChange ()
+ {
+ GLib.Value ret = GLib.Value.Empty;
+ GLib.ValueArray inst_and_params = new GLib.ValueArray (1);
+ GLib.Value[] vals = new GLib.Value [1];
+ vals [0] = new GLib.Value (this);
+ inst_and_params.Append (vals [0]);
+ g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
+ foreach (GLib.Value v in vals)
+ v.Dispose ();
+ }
+
+ [GLib.Signal("channels-change")]
+ public event System.EventHandler ChannelsChange {
+ add {
+ GLib.Signal sig = GLib.Signal.Lookup (this, "channels-change");
+ sig.AddDelegate (value);
+ }
+ remove {
+ GLib.Signal sig = GLib.Signal.Lookup (this, "channels-change");
+ sig.RemoveDelegate (value);
+ }
+ }
+
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ delegate void GotMetadataVMDelegate (IntPtr bvw);
+
+ static GotMetadataVMDelegate GotMetadataVMCallback;
+
+ static void gotmetadata_cb (IntPtr bvw)
+ {
+ try {
+ GstPlayer bvw_managed = GLib.Object.GetObject (bvw, false) as GstPlayer;
+ bvw_managed.OnGotMetadata ();
+ } catch (Exception e) {
+ GLib.ExceptionManager.RaiseUnhandledException (e, false);
+ }
+ }
+
+ private static void OverrideGotMetadata (GLib.GType gtype)
+ {
+ if (GotMetadataVMCallback == null)
+ GotMetadataVMCallback = new GotMetadataVMDelegate (gotmetadata_cb);
+ OverrideVirtualMethod (gtype, "got-metadata", GotMetadataVMCallback);
+ }
+
+ [GLib.DefaultSignalHandler(Type=typeof(LongoMatch.Video.Player.GstPlayer), ConnectionMethod="OverrideGotMetadata")]
+ protected virtual void OnGotMetadata ()
+ {
+ GLib.Value ret = GLib.Value.Empty;
+ GLib.ValueArray inst_and_params = new GLib.ValueArray (1);
+ GLib.Value[] vals = new GLib.Value [1];
+ vals [0] = new GLib.Value (this);
+ inst_and_params.Append (vals [0]);
+ g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
+ foreach (GLib.Value v in vals)
+ v.Dispose ();
+ }
+
+ [GLib.Signal("got-metadata")]
+ public event System.EventHandler GotMetadata {
+ add {
+ GLib.Signal sig = GLib.Signal.Lookup (this, "got-metadata");
+ sig.AddDelegate (value);
+ }
+ remove {
+ GLib.Signal sig = GLib.Signal.Lookup (this, "got-metadata");
+ sig.RemoveDelegate (value);
+ }
+ }
+
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ delegate void TickVMDelegate (IntPtr bvw, long current_time, long stream_length, float current_position, bool seekable);
+
+ static TickVMDelegate TickVMCallback;
+
+ static void tick_cb (IntPtr bvw, long current_time, long stream_length, float current_position, bool seekable)
+ {
+ try {
+ GstPlayer bvw_managed = GLib.Object.GetObject (bvw, false) as GstPlayer;
+ bvw_managed.OnTick (current_time, stream_length, current_position, seekable);
+ } catch (Exception e) {
+ GLib.ExceptionManager.RaiseUnhandledException (e, false);
+ }
+ }
+
+ private static void OverrideTick (GLib.GType gtype)
+ {
+ if (TickVMCallback == null)
+ TickVMCallback = new TickVMDelegate (tick_cb);
+ OverrideVirtualMethod (gtype, "tick", TickVMCallback);
+ }
+
+ [GLib.DefaultSignalHandler(Type=typeof(LongoMatch.Video.Player.GstPlayer), ConnectionMethod="OverrideTick")]
+ protected virtual void OnTick (long current_time, long stream_length, float current_position, bool seekable)
+ {
+ GLib.Value ret = GLib.Value.Empty;
+ GLib.ValueArray inst_and_params = new GLib.ValueArray (5);
+ GLib.Value[] vals = new GLib.Value [5];
+ vals [0] = new GLib.Value (this);
+ inst_and_params.Append (vals [0]);
+ vals [1] = new GLib.Value (current_time);
+ inst_and_params.Append (vals [1]);
+ vals [2] = new GLib.Value (stream_length);
+ inst_and_params.Append (vals [2]);
+ vals [3] = new GLib.Value (current_position);
+ inst_and_params.Append (vals [3]);
+ vals [4] = new GLib.Value (seekable);
+ inst_and_params.Append (vals [4]);
+ g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
+ foreach (GLib.Value v in vals)
+ v.Dispose ();
+ }
+
+ [GLib.Signal("tick")]
+ public event TickHandler Tick {
+ add {
+ GLib.Signal sig = GLib.Signal.Lookup (this, "tick", typeof (TickArgs));
+ sig.AddDelegate (value);
+ }
+ remove {
+ GLib.Signal sig = GLib.Signal.Lookup (this, "tick", typeof (TickArgs));
+ sig.RemoveDelegate (value);
+ }
+ }
+
+ /*[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ delegate void TitleChangeVMDelegate (IntPtr bvw, IntPtr title);
+
+ static TitleChangeVMDelegate TitleChangeVMCallback;
+
+ static void titlechange_cb (IntPtr bvw, IntPtr title)
+ {
+ try {
+ GstPlayer bvw_managed = GLib.Object.GetObject (bvw, false) as GstPlayer;
+ bvw_managed.OnTitleChange (GLib.Marshaller.Utf8PtrToString (title));
+ } catch (Exception e) {
+ GLib.ExceptionManager.RaiseUnhandledException (e, false);
+ }
+ }
+
+ private static void OverrideTitleChange (GLib.GType gtype)
+ {
+ if (TitleChangeVMCallback == null)
+ TitleChangeVMCallback = new TitleChangeVMDelegate (titlechange_cb);
+ OverrideVirtualMethod (gtype, "title-change", TitleChangeVMCallback);
+ }
+
+ [GLib.DefaultSignalHandler(Type=typeof(LongoMatch.Video.Player.GstPlayer), ConnectionMethod="OverrideTitleChange")]
+ protected virtual void OnTitleChange (string title)
+ {
+ GLib.Value ret = GLib.Value.Empty;
+ GLib.ValueArray inst_and_params = new GLib.ValueArray (2);
+ GLib.Value[] vals = new GLib.Value [2];
+ vals [0] = new GLib.Value (this);
+ inst_and_params.Append (vals [0]);
+ vals [1] = new GLib.Value (title);
+ inst_and_params.Append (vals [1]);
+ g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
+ foreach (GLib.Value v in vals)
+ v.Dispose ();
+ }
+
+ [GLib.Signal("title-change")]
+ public event TitleChangeHandler TitleChange {
+ add {
+ GLib.Signal sig = GLib.Signal.Lookup (this, "title-change", typeof (LongoMatch.TitleChangeArgs));
+ sig.AddDelegate (value);
+ }
+ remove {
+ GLib.Signal sig = GLib.Signal.Lookup (this, "title-change", typeof (LongoMatch.TitleChangeArgs));
+ sig.RemoveDelegate (value);
+ }
+ }*/
+
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ delegate void GotDurationVMDelegate (IntPtr bvw);
+
+ static GotDurationVMDelegate GotDurationVMCallback;
+
+ static void gotduration_cb (IntPtr bvw)
+ {
+ try {
+ GstPlayer bvw_managed = GLib.Object.GetObject (bvw, false) as GstPlayer;
+ bvw_managed.OnGotDuration ();
+ } catch (Exception e) {
+ GLib.ExceptionManager.RaiseUnhandledException (e, false);
+ }
+ }
+
+ private static void OverrideGotDuration (GLib.GType gtype)
+ {
+ if (GotDurationVMCallback == null)
+ GotDurationVMCallback = new GotDurationVMDelegate (gotduration_cb);
+ OverrideVirtualMethod (gtype, "got_duration", GotDurationVMCallback);
+ }
+
+ [GLib.DefaultSignalHandler(Type=typeof(LongoMatch.Video.Player.GstPlayer), ConnectionMethod="OverrideGotDuration")]
+ protected virtual void OnGotDuration ()
+ {
+ GLib.Value ret = GLib.Value.Empty;
+ GLib.ValueArray inst_and_params = new GLib.ValueArray (1);
+ GLib.Value[] vals = new GLib.Value [1];
+ vals [0] = new GLib.Value (this);
+ inst_and_params.Append (vals [0]);
+ g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
+ foreach (GLib.Value v in vals)
+ v.Dispose ();
+ }
+
+ [GLib.Signal("got_duration")]
+ public event System.EventHandler GotDuration {
+ add {
+ GLib.Signal sig = GLib.Signal.Lookup (this, "got_duration");
+ sig.AddDelegate (value);
+ }
+ remove {
+ GLib.Signal sig = GLib.Signal.Lookup (this, "got_duration");
+ sig.RemoveDelegate (value);
+ }
+ }
+#pragma warning restore 0169
+
+ [DllImport("libcesarplayer.dll")]
+ static extern IntPtr bacon_video_widget_get_backend_name(IntPtr raw);
+
+ public string BackendName {
+ get {
+ IntPtr raw_ret = bacon_video_widget_get_backend_name(Handle);
+ string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
+ return ret;
+ }
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern bool bacon_video_widget_set_rate(IntPtr raw, float rate);
+
+ public bool SetRate(float rate) {
+ bool raw_ret = bacon_video_widget_set_rate(Handle, rate);
+ bool ret = raw_ret;
+ return ret;
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern bool bacon_video_widget_is_playing(IntPtr raw);
+
+ public bool IsPlaying {
+ get {
+ bool raw_ret = bacon_video_widget_is_playing(Handle);
+ bool ret = raw_ret;
+ return ret;
+ }
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern bool bacon_video_widget_get_auto_resize(IntPtr raw);
+
+ [DllImport("libcesarplayer.dll")]
+ static extern void bacon_video_widget_set_auto_resize(IntPtr raw, bool auto_resize);
+
+ public bool AutoResize {
+ get {
+ bool raw_ret = bacon_video_widget_get_auto_resize(Handle);
+ bool ret = raw_ret;
+ return ret;
+ }
+ set {
+ bacon_video_widget_set_auto_resize(Handle, value);
+ }
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern bool bacon_video_widget_seek(IntPtr raw, double position, float rate);
+
+ public bool Seek(double position, float rate) {
+ bool raw_ret = bacon_video_widget_seek(Handle, position, rate);
+ bool ret = raw_ret;
+ return ret;
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern bool bacon_video_widget_get_show_cursor(IntPtr raw);
+
+ [DllImport("libcesarplayer.dll")]
+ static extern void bacon_video_widget_set_show_cursor(IntPtr raw, bool show_cursor);
+
+ public bool ShowCursor {
+ get {
+ bool raw_ret = bacon_video_widget_get_show_cursor(Handle);
+ bool ret = raw_ret;
+ return ret;
+ }
+ set {
+ bacon_video_widget_set_show_cursor(Handle, value);
+ }
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern void bacon_video_widget_init_backend(out int argc, IntPtr argv);
+
+ public static int InitBackend(string argv) {
+ int argc;
+ bacon_video_widget_init_backend(out argc, GLib.Marshaller.StringToPtrGStrdup(argv));
+ return argc;
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern void bacon_video_widget_pause(IntPtr raw);
+
+ public void Pause() {
+ bacon_video_widget_pause(Handle);
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern double bacon_video_widget_get_zoom(IntPtr raw);
+
+ [DllImport("libcesarplayer.dll")]
+ static extern void bacon_video_widget_set_zoom(IntPtr raw, double zoom);
+
+ public double Zoom {
+ get {
+ double raw_ret = bacon_video_widget_get_zoom(Handle);
+ double ret = raw_ret;
+ return ret;
+ }
+ set {
+ bacon_video_widget_set_zoom(Handle, value);
+ }
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern bool bacon_video_widget_seek_in_segment(IntPtr raw, long pos, float rate);
+
+ public bool SeekInSegment(long pos, float rate) {
+ bool raw_ret = bacon_video_widget_seek_in_segment(Handle, pos, rate);
+ bool ret = raw_ret;
+ return ret;
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern bool bacon_video_widget_segment_seek(IntPtr raw, long start, long stop, float rate);
+
+ public bool SegmentSeek(long start, long stop, float rate) {
+ bool raw_ret = bacon_video_widget_segment_seek(Handle, start, stop, rate);
+ bool ret = raw_ret;
+ return ret;
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern void bacon_video_widget_stop(IntPtr raw);
+
+ public void Stop() {
+ bacon_video_widget_stop(Handle);
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern bool bacon_video_widget_has_next_track(IntPtr raw);
+
+ public bool HasNextTrack {
+ get {
+ bool raw_ret = bacon_video_widget_has_next_track(Handle);
+ bool ret = raw_ret;
+ return ret;
+ }
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern void bacon_video_widget_set_subtitle_font(IntPtr raw, IntPtr font);
+
+ public string SubtitleFont {
+ set {
+ IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
+ bacon_video_widget_set_subtitle_font(Handle, native_value);
+ GLib.Marshaller.Free (native_value);
+ }
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern bool bacon_video_widget_set_visuals(IntPtr raw, IntPtr name);
+
+ public bool SetVisuals(string name) {
+ IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
+ bool raw_ret = bacon_video_widget_set_visuals(Handle, native_name);
+ bool ret = raw_ret;
+ GLib.Marshaller.Free (native_name);
+ return ret;
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern long bacon_video_widget_get_accurate_current_time(IntPtr raw);
+
+ public long AccurateCurrentTime {
+ get {
+ long raw_ret = bacon_video_widget_get_accurate_current_time(Handle);
+ long ret = raw_ret;
+ return ret;
+ }
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern int bacon_video_widget_get_video_property(IntPtr raw, int type);
+
+ public int GetVideoProperty(VideoProperty type) {
+ int raw_ret = bacon_video_widget_get_video_property(Handle, (int) type);
+ int ret = raw_ret;
+ return ret;
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern int bacon_video_widget_get_language(IntPtr raw);
+
+ [DllImport("libcesarplayer.dll")]
+ static extern void bacon_video_widget_set_language(IntPtr raw, int language);
+
+ public int Language {
+ get {
+ int raw_ret = bacon_video_widget_get_language(Handle);
+ int ret = raw_ret;
+ return ret;
+ }
+ set {
+ bacon_video_widget_set_language(Handle, value);
+ }
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern bool bacon_video_widget_seek_time(IntPtr raw, long time, float rate, bool accurate);
+
+ public bool SeekTime(long time, float rate, bool accurate) {
+ bool raw_ret = bacon_video_widget_seek_time(Handle, time, rate, accurate);
+ bool ret = raw_ret;
+ return ret;
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern bool bacon_video_widget_is_seekable(IntPtr raw);
+
+ public bool IsSeekable {
+ get {
+ bool raw_ret = bacon_video_widget_is_seekable(Handle);
+ bool ret = raw_ret;
+ return ret;
+ }
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern unsafe bool bacon_video_widget_can_get_frames(IntPtr raw, out IntPtr error);
+
+ public unsafe bool CanGetFrames() {
+ IntPtr error = IntPtr.Zero;
+ bool raw_ret = bacon_video_widget_can_get_frames(Handle, out error);
+ bool ret = raw_ret;
+ if (error != IntPtr.Zero) throw new GLib.GException (error);
+ return ret;
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern long bacon_video_widget_get_current_time(IntPtr raw);
+
+ public long CurrentTime {
+ get {
+ long raw_ret = bacon_video_widget_get_current_time(Handle);
+ long ret = raw_ret;
+ return ret;
+ }
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern bool bacon_video_widget_seek_to_previous_frame(IntPtr raw, float rate, bool in_segment);
+
+ public bool SeekToPreviousFrame(float rate, bool in_segment) {
+ bool raw_ret = bacon_video_widget_seek_to_previous_frame(Handle, rate, in_segment);
+ bool ret = raw_ret;
+ return ret;
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern IntPtr bacon_video_widget_get_type();
+
+ public static new GLib.GType GType {
+ get {
+ IntPtr raw_ret = bacon_video_widget_get_type();
+ GLib.GType ret = new GLib.GType(raw_ret);
+ return ret;
+ }
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern IntPtr bacon_video_widget_get_languages(IntPtr raw);
+
+ public GLib.List Languages {
+ get {
+ IntPtr raw_ret = bacon_video_widget_get_languages(Handle);
+ GLib.List ret = new GLib.List(raw_ret);
+ return ret;
+ }
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern void bacon_video_widget_set_fullscreen(IntPtr raw, bool fullscreen);
+
+ public bool Fullscreen {
+ set {
+ bacon_video_widget_set_fullscreen(Handle, value);
+ }
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern bool bacon_video_widget_set_audio_out_type(IntPtr raw, int type);
+
+ public bool SetAudioOutType(AudioOutType type) {
+ bool raw_ret = bacon_video_widget_set_audio_out_type(Handle, (int) type);
+ bool ret = raw_ret;
+ return ret;
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern bool bacon_video_widget_has_previous_track(IntPtr raw);
+
+ public bool HasPreviousTrack {
+ get {
+ bool raw_ret = bacon_video_widget_has_previous_track(Handle);
+ bool ret = raw_ret;
+ return ret;
+ }
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern void bacon_video_widget_set_logo_pixbuf(IntPtr raw, IntPtr logo);
+
+ public Gdk.Pixbuf LogoPixbuf {
+ set {
+ bacon_video_widget_set_logo_pixbuf(Handle, value == null ? IntPtr.Zero : value.Handle);
+ }
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern void bacon_video_widget_set_drawing_pixbuf(IntPtr raw, IntPtr drawing_mode);
+
+ public Gdk.Pixbuf DrawingPixbuf {
+ set {
+ bacon_video_widget_set_drawing_pixbuf(Handle, value == null ? IntPtr.Zero : value.Handle);
+ }
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern void bacon_video_widget_set_drawing_mode(IntPtr raw, bool drawing_mode);
+
+ public bool DrawingMode {
+ set {
+ bacon_video_widget_set_drawing_mode(Handle, value);
+ }
+ }
+
+ /*[DllImport("libcesarplayer.dll")]
+ static extern void bacon_video_widget_set_visuals_quality(IntPtr raw, int quality);
+
+ public GstVisualsQuality VisualsQuality {
+ set {
+ bacon_video_widget_set_visuals_quality(Handle, (int) value);
+ }
+ }*/
+
+ [DllImport("libcesarplayer.dll")]
+ static extern int bacon_video_widget_get_connection_speed(IntPtr raw);
+
+ [DllImport("libcesarplayer.dll")]
+ static extern void bacon_video_widget_set_connection_speed(IntPtr raw, int speed);
+
+ public int ConnectionSpeed {
+ get {
+ int raw_ret = bacon_video_widget_get_connection_speed(Handle);
+ int ret = raw_ret;
+ return ret;
+ }
+ set {
+ bacon_video_widget_set_connection_speed(Handle, value);
+ }
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern IntPtr bacon_video_widget_get_subtitles(IntPtr raw);
+
+ public GLib.List Subtitles {
+ get {
+ IntPtr raw_ret = bacon_video_widget_get_subtitles(Handle);
+ GLib.List ret = new GLib.List(raw_ret);
+ return ret;
+ }
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern IntPtr bacon_video_widget_get_current_frame(IntPtr raw);
+
+ [DllImport("libcesarplayer.dll")]
+ static extern IntPtr bacon_video_widget_unref_pixbuf(IntPtr raw);
+
+
+ public Gdk.Pixbuf GetCurrentFrame(int outwidth, int outheight) {
+ IntPtr raw_ret = bacon_video_widget_get_current_frame(Handle);
+ Gdk.Pixbuf unmanaged = GLib.Object.GetObject(raw_ret) as Gdk.Pixbuf;
+ if (unmanaged == null)
+ return null;
+ Gdk.Pixbuf managed;
+ int h = unmanaged.Height;
+ int w = unmanaged.Width;
+ double rate = (double)w/(double)h;
+ if (outwidth == -1 || outheight == -1){
+ outwidth = w;
+ outheight = h;
+ }else if (h>w){
+ outwidth = (int)(outheight*rate);
+ }else{
+ outheight = (int)(outwidth/rate);
+ }
+ managed = unmanaged.ScaleSimple(outwidth,outheight,Gdk.InterpType.Bilinear);
+ unmanaged.Dispose();
+ bacon_video_widget_unref_pixbuf(raw_ret);
+ return managed;
+ }
+
+ public Gdk.Pixbuf GetCurrentFrame() {
+ return GetCurrentFrame(-1,-1);
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern IntPtr bacon_video_widget_get_visuals_list(IntPtr raw);
+
+ public GLib.List VisualsList {
+ get {
+ IntPtr raw_ret = bacon_video_widget_get_visuals_list(Handle);
+ GLib.List ret = new GLib.List(raw_ret);
+ return ret;
+ }
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern bool bacon_video_widget_segment_stop_update(IntPtr raw, long stop, float rate);
+
+ public bool SegmentStopUpdate(long stop, float rate) {
+ bool raw_ret = bacon_video_widget_segment_stop_update(Handle, stop, rate);
+ bool ret = raw_ret;
+ return ret;
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern void bacon_video_widget_set_subtitle_encoding(IntPtr raw, IntPtr encoding);
+
+ public string SubtitleEncoding {
+ set {
+ IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
+ bacon_video_widget_set_subtitle_encoding(Handle, native_value);
+ GLib.Marshaller.Free (native_value);
+ }
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern void bacon_video_widget_set_aspect_ratio(IntPtr raw, int ratio);
+
+ public AspectRatio AspectRatio {
+ set {
+ bacon_video_widget_set_aspect_ratio(Handle, (int) value);
+ }
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern void bacon_video_widget_set_video_property(IntPtr raw, int type, int value);
+
+ public void SetVideoProperty(VideoProperty type, int value) {
+ bacon_video_widget_set_video_property(Handle, (int) type, value);
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern bool bacon_video_widget_get_deinterlacing(IntPtr raw);
+
+ [DllImport("libcesarplayer.dll")]
+ static extern void bacon_video_widget_set_deinterlacing(IntPtr raw, bool deinterlace);
+
+ public bool Deinterlacing {
+ get {
+ bool raw_ret = bacon_video_widget_get_deinterlacing(Handle);
+ bool ret = raw_ret;
+ return ret;
+ }
+ set {
+ bacon_video_widget_set_deinterlacing(Handle, value);
+ }
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern bool bacon_video_widget_set_rate_in_segment(IntPtr raw, float rate, long stop);
+
+ public bool SetRateInSegment(float rate, long stop) {
+ bool raw_ret = bacon_video_widget_set_rate_in_segment(Handle, rate, stop);
+ bool ret = raw_ret;
+ return ret;
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern void bacon_video_widget_get_metadata(IntPtr raw, int type, IntPtr val);
+
+ public object GetMetadata(MetadataType type) {
+ GLib.Value val = new GLib.Value();
+ IntPtr native_value = GLib.Marshaller.StructureToPtrAlloc (val);
+ bacon_video_widget_get_metadata(Handle, (int) type, native_value);
+ val = (GLib.Value) Marshal.PtrToStructure (native_value, typeof (GLib.Value));
+ Marshal.FreeHGlobal (native_value);
+ return val.Val;
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern bool bacon_video_widget_can_set_volume(IntPtr raw);
+
+ public bool CanSetVolume() {
+ bool raw_ret = bacon_video_widget_can_set_volume(Handle);
+ bool ret = raw_ret;
+ return ret;
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern bool bacon_video_widget_can_direct_seek(IntPtr raw);
+
+ public bool CanDirectSeek() {
+ bool raw_ret = bacon_video_widget_can_direct_seek(Handle);
+ bool ret = raw_ret;
+ return ret;
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern void bacon_video_widget_close(IntPtr raw);
+
+ public void Close() {
+ bacon_video_widget_close(Handle);
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern bool bacon_video_widget_play(IntPtr raw);
+
+ public bool Play() {
+ bool raw_ret = bacon_video_widget_play(Handle);
+ bool ret = raw_ret;
+ return ret;
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern int bacon_video_widget_get_subtitle(IntPtr raw);
+
+ [DllImport("libcesarplayer.dll")]
+ static extern void bacon_video_widget_set_subtitle(IntPtr raw, int subtitle);
+
+ public int Subtitle {
+ get {
+ int raw_ret = bacon_video_widget_get_subtitle(Handle);
+ int ret = raw_ret;
+ return ret;
+ }
+ set {
+ bacon_video_widget_set_subtitle(Handle, value);
+ }
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern int bacon_video_widget_error_quark();
+
+ public static int ErrorQuark() {
+ int raw_ret = bacon_video_widget_error_quark();
+ int ret = raw_ret;
+ return ret;
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern unsafe bool bacon_video_widget_open(IntPtr raw, IntPtr mrl, IntPtr subtitle_uri, out IntPtr error);
+
+ public unsafe bool Open(string mrl, string subtitle_uri) {
+ IntPtr native_mrl = GLib.Marshaller.StringToPtrGStrdup (mrl);
+ IntPtr native_subtitle_uri = GLib.Marshaller.StringToPtrGStrdup (subtitle_uri);
+ IntPtr error = IntPtr.Zero;
+ bool raw_ret = bacon_video_widget_open(Handle, native_mrl, native_subtitle_uri, out error);
+ bool ret = raw_ret;
+ GLib.Marshaller.Free (native_mrl);
+ GLib.Marshaller.Free (native_subtitle_uri);
+ if (error != IntPtr.Zero) throw new GLib.GException (error);
+ return ret;
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern bool bacon_video_widget_new_file_seek(IntPtr raw, long start,long stop,float rate);
+
+ public bool NewFileSeek(long start, long stop,float rate) {
+ bool raw_ret = bacon_video_widget_new_file_seek(Handle,start,stop,rate);
+ bool ret = raw_ret;
+ return ret;
+ }
+
+
+ [DllImport("libcesarplayer.dll")]
+ static extern bool bacon_video_widget_segment_start_update(IntPtr raw, long start, float rate);
+
+ public bool SegmentStartUpdate(long start, float rate) {
+ bool raw_ret = bacon_video_widget_segment_start_update(Handle, start, rate);
+ bool ret = raw_ret;
+ return ret;
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern bool bacon_video_widget_can_deinterlace(IntPtr raw);
+
+ public bool CanDeinterlace() {
+ bool raw_ret = bacon_video_widget_can_deinterlace(Handle);
+ bool ret = raw_ret;
+ return ret;
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern void bacon_video_widget_set_show_visuals(IntPtr raw, bool show_visuals);
+
+ public bool ShowVisuals {
+ set {
+ bacon_video_widget_set_show_visuals(Handle, value);
+ }
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern void bacon_video_widget_set_logo(IntPtr raw, IntPtr filename);
+
+ public string Logo {
+ set {
+ bacon_video_widget_set_logo(Handle, GLib.Marshaller.StringToPtrGStrdup(value));
+ }
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern bool bacon_video_widget_seek_to_next_frame(IntPtr raw, float rate, bool in_segment);
+
+ public bool SeekToNextFrame(float rate, bool in_segment) {
+ bool raw_ret = bacon_video_widget_seek_to_next_frame(Handle, rate, in_segment);
+ bool ret = raw_ret;
+ return ret;
+ }
+
+ [DllImport("libcesarplayer.dll")]
+ static extern void bacon_video_widget_set_scale_ratio(IntPtr raw, float ratio);
+
+ public float ScaleRatio {
+ set {
+ bacon_video_widget_set_scale_ratio(Handle, value);
+ }
+ }
+
+ static GstPlayer ()
+ {
+ LongoMatch.GtkSharp.Video.ObjectManager.Initialize ();
+ }
+#endregion
+
+ public bool SeekTime(long time, bool accurate) {
+ return SeekTime(time,1,accurate);
+ }
+
+
+ public void TogglePlay(){
+ if(!this.Playing){
+ this.Play();
+ }
+ else{
+ this.Pause();
+ }
+ }
+
+ public bool Open(string mrl){
+ return Open(mrl, null);
+ }
+
+ public void CancelProgramedStop(){
+ this.SegmentSeek(this.CurrentTime,this.StreamLength,1);
+ }
+
+ }
+}
diff --git a/CesarPlayer/Player/IPlayer.cs b/CesarPlayer/Player/IPlayer.cs
new file mode 100644
index 0000000..0f18b51
--- /dev/null
+++ b/CesarPlayer/Player/IPlayer.cs
@@ -0,0 +1,146 @@
+// IPlayer.cs
+//
+// Copyright (C) 2007-2009 Andoni Morales Alastruey
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+//
+
+using System;
+using Gtk;
+using Gdk;
+using LongoMatch.Video.Common;
+
+
+namespace LongoMatch.Video.Player
+
+{
+ public interface IPlayer
+ {
+
+
+ // Events
+
+
+ event ErrorHandler Error;
+ event System.EventHandler Eos;
+ event StateChangeHandler StateChange;
+ event TickHandler Tick;
+ event System.EventHandler GotDuration;
+ event System.EventHandler SegmentDone;
+ event System.EventHandler ReadyToSeek;
+
+
+ long StreamLength{
+ get;
+ }
+
+
+
+ long CurrentTime{
+ get;
+
+ }
+
+ double Position{
+ get;
+ set;
+
+ }
+
+ bool LogoMode {
+ get;
+ set;
+ }
+
+ bool DrawingMode {
+ set;
+ }
+
+ Pixbuf DrawingPixbuf {
+ set;
+ }
+
+ bool ExpandLogo{
+ get;
+ set;
+ }
+
+ double Volume{
+ get;
+ set;
+ }
+
+ bool Playing {
+ get;
+ }
+
+ string Logo {
+ set;
+ }
+
+ Pixbuf LogoPixbuf{
+ set;
+ }
+
+ long AccurateCurrentTime{
+ get;
+ }
+
+ bool SeekTime(long time,float rate, bool accurate);
+
+ bool Play();
+
+ bool Open(string mrl);
+
+ bool SetRate(float rate);
+
+ bool SetRateInSegment(float rate, long stopTime);
+
+
+
+ void TogglePlay();
+
+ void Pause();
+
+ void Stop();
+
+ void Close();
+
+
+ void Dispose();
+
+ bool SegmentSeek(long start, long stop,float rate);
+
+ bool SeekInSegment(long pos,float rate);
+
+ bool NewFileSeek(long start, long stop,float rate);
+
+ bool SegmentStartUpdate(long start,float rate);
+
+ bool SegmentStopUpdate(long stop,float rate);
+
+ bool SeekToNextFrame(float rate,bool in_segment);
+
+ bool SeekToPreviousFrame(float rate,bool in_segment);
+
+ Pixbuf GetCurrentFrame(int outwidth, int outheight);
+
+ Pixbuf GetCurrentFrame();
+
+ void CancelProgramedStop();
+
+ }
+}
diff --git a/CesarPlayer/Player/ObjectManager.cs b/CesarPlayer/Player/ObjectManager.cs
new file mode 100644
index 0000000..6fdbdcc
--- /dev/null
+++ b/CesarPlayer/Player/ObjectManager.cs
@@ -0,0 +1,38 @@
+//
+// Copyright (C) 2007-2009 Andoni Morales Alastruey
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+//
+
+
+namespace LongoMatch.GtkSharp.Video {
+
+ public class ObjectManager {
+
+ static bool initialized = false;
+ // Call this method from the appropriate module init function.
+ public static void Initialize ()
+ {
+ if (initialized)
+ return;
+
+ initialized = true;
+
+ GLib.GType.Register (LongoMatch.Video.Player.GstPlayer.GType, typeof (LongoMatch.Video.Player.GstPlayer));
+
+ }
+ }
+}
diff --git a/CesarPlayer/Utils/Device.cs b/CesarPlayer/Utils/Device.cs
new file mode 100644
index 0000000..c0fde57
--- /dev/null
+++ b/CesarPlayer/Utils/Device.cs
@@ -0,0 +1,90 @@
+//
+// Copyright (C) 2010 Andoni Morales Alastruey
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+
+using System;
+using System.Collections.Generic;
+using LongoMatch.Video.Capturer;
+using LongoMatch.Video.Common;
+using Mono.Unix;
+
+namespace LongoMatch.Video.Utils
+{
+
+
+ public class Device
+ {
+ public Device () {
+
+ }
+
+ /// <summary>
+ /// Device Type among Video, Audio or DV (for dv cameras)
+ /// </summary>
+ public DeviceType DeviceType {
+ get;
+ set;
+ }
+
+ /// <summary>
+ /// Device id, can be a human friendly name (for DirectShow devices),
+ /// the de device name (/dev/video0) or the GUID (dv1394src)
+ /// </summary>
+ public string ID {
+ get;
+ set;
+ }
+
+ /// <summary>
+ /// The name of the gstreamer element property used to set the device
+ /// </summary>
+
+ public string IDProperty {
+ get;
+ set;
+ }
+
+ static public List<Device> ListVideoDevices (){
+ List<Device> devicesList = new List<Device>();
+
+ /* Generate the list of devices and add the gconf one at the bottom
+ * so that DV sources are always selected before, at least on Linux,
+ * since on Windows both raw an dv sources are listed from the same
+ * source element (dshowvideosrc) */
+ foreach (string devName in GstCameraCapturer.VideoDevices){
+ string idProp;
+
+ if (Environment.OSVersion.Platform == PlatformID.Unix)
+ idProp = Constants.DV1394SRC_PROP;
+ else
+ idProp = Constants.DSHOWVIDEOSINK_PROP;
+
+ devicesList.Add(new Device {
+ ID = devName,
+ IDProperty = idProp,
+ DeviceType = DeviceType.DV});
+ }
+ if (Environment.OSVersion.Platform == PlatformID.Unix){
+ devicesList.Add(new Device {
+ ID = Catalog.GetString("Default device"),
+ IDProperty = "",
+ DeviceType = DeviceType.Video});
+ }
+ return devicesList;
+ }
+ }
+}
diff --git a/CesarPlayer/Utils/FramesCapturer.cs b/CesarPlayer/Utils/FramesCapturer.cs
new file mode 100644
index 0000000..189bed3
--- /dev/null
+++ b/CesarPlayer/Utils/FramesCapturer.cs
@@ -0,0 +1,111 @@
+// FramesCapturer.cs
+//
+// Copyright (C) 2007-2009 Andoni Morales Alastruey
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+//
+
+using System;
+using LongoMatch.Video.Utils;
+using LongoMatch.Video;
+using Gdk;
+using Gtk;
+using System.Threading;
+using LongoMatch.Video.Common;
+
+namespace LongoMatch.Video.Utils
+{
+
+
+ public class FramesSeriesCapturer
+ {
+ IFramesCapturer capturer;
+ long start;
+ long stop;
+ uint interval;
+ int totalFrames;
+ string seriesName;
+ string outputDir;
+ bool cancel;
+ private const int THUMBNAIL_MAX_HEIGHT=250;
+ private const int THUMBNAIL_MAX_WIDTH=300;
+
+ public event FramesProgressHandler Progress;
+
+ public FramesSeriesCapturer(string videoFile,long start, long stop, uint interval, string outputDir)
+ {
+ MultimediaFactory mf= new MultimediaFactory();
+ this.capturer=mf.getFramesCapturer();
+ this.capturer.Open(videoFile);
+ this.start= start;
+ this.stop = stop;
+ this.interval = interval;
+ this.outputDir = outputDir;
+ this.seriesName = System.IO.Path.GetFileName(outputDir);
+ this.totalFrames = (int)Math.Floor((double)((stop - start ) / interval))+1;
+ }
+
+ public void Cancel(){
+ cancel = true;
+ }
+
+ public void Start(){
+ Thread thread = new Thread(new ThreadStart(CaptureFrames));
+ thread.Start();
+ }
+
+ public void CaptureFrames(){
+ long pos;
+ Pixbuf frame;
+ Pixbuf scaledFrame=null;
+ int i = 0;
+
+ System.IO.Directory.CreateDirectory(outputDir);
+
+ pos = start;
+ if (Progress != null)
+ Application.Invoke(delegate {Progress(0,totalFrames,null);});
+ while (pos <= stop){
+ if (!cancel){
+ capturer.SeekTime(pos,true);
+ capturer.Pause();
+ frame = capturer.GetCurrentFrame();
+ if (frame != null) {
+ frame.Save(System.IO.Path.Combine(outputDir,seriesName+"_" + i +".png"),"png");
+ int h = frame.Height;
+ int w = frame.Width;
+ double rate = (double)w/(double)h;
+ if (h>w)
+ scaledFrame = frame.ScaleSimple((int)(THUMBNAIL_MAX_HEIGHT*rate),THUMBNAIL_MAX_HEIGHT,InterpType.Bilinear);
+ else
+ scaledFrame = frame.ScaleSimple(THUMBNAIL_MAX_WIDTH,(int)(THUMBNAIL_MAX_WIDTH/rate),InterpType.Bilinear);
+ frame.Dispose();
+ }
+
+ if (Progress != null)
+ Application.Invoke(delegate {Progress(i+1,totalFrames,scaledFrame);});
+ pos += interval;
+ i++;
+ }
+ else {
+ System.IO.Directory.Delete(outputDir,true);
+ cancel=false;
+ break;
+ }
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/CesarPlayer/Utils/IFramesCapturer.cs b/CesarPlayer/Utils/IFramesCapturer.cs
new file mode 100644
index 0000000..38ac0f3
--- /dev/null
+++ b/CesarPlayer/Utils/IFramesCapturer.cs
@@ -0,0 +1,38 @@
+// IFramesCapturer.cs
+//
+// Copyright (C) 2007-2009 Andoni Morales Alastruey
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+//
+
+using System;
+using Gdk;
+
+namespace LongoMatch.Video.Utils
+{
+
+
+ public interface IFramesCapturer
+ {
+ bool Open(string mrl);
+ bool SeekTime(long time, bool accurate);
+ void Pause();
+ void Dispose();
+ Pixbuf GetCurrentFrame(int outwidth, int outheight);
+ Pixbuf GetCurrentFrame();
+
+ }
+}
diff --git a/CesarPlayer/Utils/IMetadataReader.cs b/CesarPlayer/Utils/IMetadataReader.cs
new file mode 100644
index 0000000..c6126b2
--- /dev/null
+++ b/CesarPlayer/Utils/IMetadataReader.cs
@@ -0,0 +1,37 @@
+// IMetadataReader.cs
+//
+// Copyright (C) 2007-2009 Andoni Morales Alastruey
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+//
+
+using System;
+using LongoMatch.Video.Player;
+using LongoMatch.Video.Common;
+
+
+namespace LongoMatch.Video.Utils
+{
+
+
+ public interface IMetadataReader
+ {
+ bool Open(string mrl);
+ void Close();
+ void Dispose();
+ object GetMetadata(MetadataType type);
+ }
+}
diff --git a/CesarPlayer/Utils/MediaFile.cs b/CesarPlayer/Utils/MediaFile.cs
new file mode 100644
index 0000000..f5d03f2
--- /dev/null
+++ b/CesarPlayer/Utils/MediaFile.cs
@@ -0,0 +1,170 @@
+// MediaFile.cs
+//
+// Copyright (C) 2007-2009 Andoni Morales Alastruey
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+//
+
+using System;
+using Mono.Unix;
+using Gdk;
+using LongoMatch.Video;
+using LongoMatch.Video.Player;
+using LongoMatch.Video.Common;
+
+namespace LongoMatch.Video.Utils
+{
+
+ [Serializable]
+
+ public class MediaFile
+ {
+
+ string filePath;
+ long length; // In MSeconds
+ ushort fps;
+ bool hasAudio;
+ bool hasVideo;
+ string videoCodec;
+ string audioCodec;
+ uint videoHeight;
+ uint videoWidth;
+
+
+ public MediaFile(){}
+
+ public MediaFile(string filePath,
+ long length,
+ ushort fps,
+ bool hasAudio,
+ bool hasVideo,
+ string videoCodec,
+ string audioCodec,
+ uint videoWidth,
+ uint videoHeight)
+ {
+ this.filePath = filePath;
+ this.length = length;
+ this.hasAudio = hasAudio;
+ this.hasVideo = hasVideo;
+ this.videoCodec = videoCodec;
+ this.audioCodec = audioCodec;
+ this.videoHeight = videoHeight;
+ this.videoWidth = videoWidth;
+ if (fps == 0)
+ //For audio Files
+ this.fps=25;
+ else
+ this.fps = fps;
+
+ }
+
+ public string FilePath{
+ get {return this.filePath;}
+ set {this.filePath = value;}
+ }
+
+ public long Length{
+ get {return this.length;}
+ set {this.length = value;}
+ }
+
+ public bool HasVideo{
+ get { return this.hasVideo;}
+ set{this.hasVideo = value;}
+ }
+
+ public bool HasAudio{
+ get { return this.hasAudio;}
+ set{this.hasAudio = value;}
+ }
+
+ public string VideoCodec{
+ get {return this.videoCodec;}
+ set {this.videoCodec = value;}
+ }
+
+ public string AudioCodec{
+ get {return this.audioCodec;}
+ set {this.audioCodec = value;}
+ }
+
+ public uint VideoWidth{
+ get {return this.videoWidth;}
+ set {this.videoWidth= value;}
+ }
+
+ public uint VideoHeight{
+ get {return this.videoHeight;}
+ set {this.videoHeight= value;}
+ }
+
+ public ushort Fps{
+ get {return this.fps;}
+ set {
+ if (value == 0)
+ //For audio Files
+ this.fps=25;
+ else
+ this.fps = value;}
+ }
+
+ public uint GetFrames(){
+ return (uint) (Fps*Length/1000);
+ }
+
+
+
+ public static MediaFile GetMediaFile(string filePath){
+ int duration, fps=0, height=0, width=0;
+ bool hasVideo, hasAudio;
+ string audioCodec = "", videoCodec = "";
+ MultimediaFactory factory;
+ IMetadataReader reader = null;
+
+ try{
+ factory = new MultimediaFactory();
+ reader = factory.getMetadataReader();
+ reader.Open(filePath);
+ duration = (int)reader.GetMetadata(MetadataType.Duration);
+ hasVideo = (bool) reader.GetMetadata(MetadataType.HasVideo);
+ hasAudio = (bool) reader.GetMetadata(MetadataType.HasAudio);
+ if (hasAudio)
+ audioCodec = (string) reader.GetMetadata(MetadataType.AudioEncoderType);
+ if (hasVideo){
+ videoCodec = (string) reader.GetMetadata(MetadataType.VideoEncoderType);
+ fps = (int) reader.GetMetadata(MetadataType.Fps);
+ }
+ height = (int) reader.GetMetadata(MetadataType.DimensionX);
+ width = (int) reader.GetMetadata (MetadataType.DimensionY);
+
+ return new MediaFile(filePath,duration*1000,(ushort)fps,
+ hasAudio,hasVideo,videoCodec,audioCodec,
+ (uint)height,(uint)width);
+
+ }
+ catch (GLib.GException ex){
+ throw new Exception (Catalog.GetString("Invalid video file:")+"\n"+ex.Message);
+ }
+ finally {
+ reader.Close();
+ reader.Dispose();
+ }
+ }
+
+
+ }
+}
diff --git a/CesarPlayer/Utils/PreviewMediaFile.cs b/CesarPlayer/Utils/PreviewMediaFile.cs
new file mode 100644
index 0000000..0fd512d
--- /dev/null
+++ b/CesarPlayer/Utils/PreviewMediaFile.cs
@@ -0,0 +1,120 @@
+//
+// Copyright (C) 2007-2009 Andoni Morales Alastruey
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+
+using System;
+using LongoMatch.Video;
+using LongoMatch.Video.Common;
+using LongoMatch.Video.Player;
+using Mono.Unix;
+using Gdk;
+
+namespace LongoMatch.Video.Utils
+{
+
+ [Serializable]
+ public class PreviewMediaFile:MediaFile
+ {
+
+ private byte[] thumbnailBuf;
+
+ const int THUMBNAIL_MAX_HEIGHT=72;
+ const int THUMBNAIL_MAX_WIDTH=96;
+
+ public PreviewMediaFile(){}
+
+ public PreviewMediaFile(string filePath,
+ long length,
+ ushort fps,
+ bool hasAudio,
+ bool hasVideo,
+ string VideoEncoderType,
+ string AudioEncoderType,
+ uint videoWidth,
+ uint videoHeight,
+ Pixbuf preview):base (filePath,length,fps,hasAudio,hasVideo,VideoEncoderType,AudioEncoderType,videoWidth,videoHeight)
+ {
+ this.Preview=preview;
+ }
+
+ public Pixbuf Preview{
+ get{
+ if (thumbnailBuf != null)
+ return new Pixbuf(thumbnailBuf);
+ else return null;
+ }
+ set{
+ if (value != null){
+ thumbnailBuf = value.SaveToBuffer("png");
+ value.Dispose();
+ }
+ else thumbnailBuf = null;
+ }
+ }
+
+ public new static PreviewMediaFile GetMediaFile(string filePath){
+ int duration=0;
+ bool hasVideo;
+ bool hasAudio;
+ string AudioEncoderType = "";
+ string VideoEncoderType = "";
+ int fps=0;
+ int height=0;
+ int width=0;
+ Pixbuf preview=null;
+ MultimediaFactory factory;
+ IMetadataReader reader;
+ IFramesCapturer thumbnailer;
+
+ try{
+ factory = new MultimediaFactory();
+ reader = factory.getMetadataReader();
+ reader.Open(filePath);
+ hasVideo = (bool) reader.GetMetadata(MetadataType.HasVideo);
+ hasAudio = (bool) reader.GetMetadata(MetadataType.HasAudio);
+ if (hasAudio){
+ AudioEncoderType = (string) reader.GetMetadata(MetadataType.AudioEncoderType);
+ }
+ if (hasVideo){
+ VideoEncoderType = (string) reader.GetMetadata(MetadataType.VideoEncoderType);
+ fps = (int) reader.GetMetadata(MetadataType.Fps);
+ thumbnailer = factory.getFramesCapturer();
+ thumbnailer.Open(filePath);
+ thumbnailer.SeekTime(1000,false);
+ preview = thumbnailer.GetCurrentFrame(THUMBNAIL_MAX_WIDTH,THUMBNAIL_MAX_HEIGHT);
+ duration =(int) ((thumbnailer as GstPlayer).StreamLength/1000); /* On Windows some formats report a 0 duration, try a last time with the reader */
+ if (duration == 0)
+ duration = (int)reader.GetMetadata(MetadataType.Duration);
+ thumbnailer.Dispose();
+ }
+ height = (int) reader.GetMetadata(MetadataType.DimensionX);
+ width = (int) reader.GetMetadata (MetadataType.DimensionY);
+ reader.Close();
+ reader.Dispose();
+
+ return new PreviewMediaFile(filePath,duration*1000,
+ (ushort)fps,hasAudio,
+ hasVideo,VideoEncoderType,
+ AudioEncoderType,(uint)height,
+ (uint)width,preview);
+ }
+ catch (GLib.GException ex){
+ throw new Exception (Catalog.GetString("Invalid video file:")+"\n"+ex.Message);
+ }
+ }
+ }
+}
diff --git a/CesarPlayer/Utils/TimeString.cs b/CesarPlayer/Utils/TimeString.cs
new file mode 100644
index 0000000..e264a0f
--- /dev/null
+++ b/CesarPlayer/Utils/TimeString.cs
@@ -0,0 +1,83 @@
+// TimeString.cs
+//
+// Copyright (C) 2007-2009 Andoni Morales Alastruey
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 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 General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+//
+
+using System;
+
+namespace LongoMatch.Video.Utils
+{
+
+
+ public class TimeString
+ {
+
+ public TimeString()
+ {
+ }
+
+ public static string SecondsToString (long time)
+ {
+ long _h, _m, _s;
+
+ _h = (time / 3600);
+ _m = ((time % 3600) / 60);
+ _s = ((time % 3600) % 60);
+
+ if (_h > 0)
+ return String.Format ("{0}:{1}:{2}", _h, _m.ToString ("d2"),
+ _s.ToString ("d2"));
+
+ return String.Format ("{0}:{1}", _m, _s.ToString ("d2"));
+ }
+ public static string MSecondsToMSecondsString (long time)
+ {
+ long _h, _m, _s,_ms,_time;
+ _time = time / 1000;
+ _h = (_time / 3600);
+ _m = ((_time % 3600) / 60);
+ _s = ((_time % 3600) % 60);
+ _ms = ((time % 3600000)%60000)%1000;
+
+ if (_h > 0)
+ return String.Format ("{0}:{1}:{2},{3}", _h, _m.ToString ("d2"),
+ _s.ToString ("d2"),_ms.ToString("d3"));
+
+ return String.Format ("{0}:{1},{2}", _m, _s.ToString ("d2"),_ms.ToString("d3"));
+ }
+ public static string MSecondsToSecondsString (long time)
+ {
+ long _h, _m, _s,_time;
+ _time = time / 1000;
+ _h = (_time / 3600);
+ _m = ((_time % 3600) / 60);
+ _s = ((_time % 3600) % 60);
+
+ if (_h > 0)
+ return String.Format ("{0}:{1}:{2}", _h, _m.ToString ("d2"),
+ _s.ToString ("d2"));
+
+ return String.Format ("{0}:{1}", _m, _s.ToString ("d2"));
+ }
+ public static string FileName( string filename){
+ return System.IO.Path.GetFileName(filename);
+ }
+
+
+ }
+}
diff --git a/CesarPlayer/cesarplayer.key b/CesarPlayer/cesarplayer.key
new file mode 100644
index 0000000..6671438
Binary files /dev/null and b/CesarPlayer/cesarplayer.key differ
diff --git a/CesarPlayer/cesarplayer.pc.in b/CesarPlayer/cesarplayer.pc.in
new file mode 100644
index 0000000..918f35c
--- /dev/null
+++ b/CesarPlayer/cesarplayer.pc.in
@@ -0,0 +1,6 @@
+Name: CesarPlayer
+Description: CesarPlayer
+Version: 0.1
+
+Requires:
+Libs: -r:@expanded_libdir@/@PACKAGE@/CesarPlayer.dll
diff --git a/CesarPlayer/gtk-gui/LongoMatch.Gui.CapturerBin.cs b/CesarPlayer/gtk-gui/LongoMatch.Gui.CapturerBin.cs
new file mode 100644
index 0000000..9c4498a
--- /dev/null
+++ b/CesarPlayer/gtk-gui/LongoMatch.Gui.CapturerBin.cs
@@ -0,0 +1,169 @@
+// ------------------------------------------------------------------------------
+// <autogenerated>
+// This code was generated by a tool.
+//
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+// </autogenerated>
+// ------------------------------------------------------------------------------
+
+namespace LongoMatch.Gui {
+
+
+ public partial class CapturerBin {
+
+ private Gtk.VBox vbox1;
+
+ private Gtk.HBox capturerhbox;
+
+ private Gtk.DrawingArea logodrawingarea;
+
+ private Gtk.HBox hbox2;
+
+ private Gtk.HBox buttonsbox;
+
+ private Gtk.Button recbutton;
+
+ private Gtk.Button pausebutton;
+
+ private Gtk.Button stopbutton;
+
+ private Gtk.Label timelabel;
+
+ protected virtual void Build() {
+ Stetic.Gui.Initialize(this);
+ // Widget LongoMatch.Gui.CapturerBin
+ Stetic.BinContainer.Attach(this);
+ this.Name = "LongoMatch.Gui.CapturerBin";
+ // Container child LongoMatch.Gui.CapturerBin.Gtk.Container+ContainerChild
+ this.vbox1 = new Gtk.VBox();
+ this.vbox1.Name = "vbox1";
+ this.vbox1.Spacing = 6;
+ // Container child vbox1.Gtk.Box+BoxChild
+ this.capturerhbox = new Gtk.HBox();
+ this.capturerhbox.Name = "capturerhbox";
+ this.capturerhbox.Spacing = 6;
+ this.vbox1.Add(this.capturerhbox);
+ Gtk.Box.BoxChild w1 = ((Gtk.Box.BoxChild)(this.vbox1[this.capturerhbox]));
+ w1.Position = 0;
+ // Container child vbox1.Gtk.Box+BoxChild
+ this.logodrawingarea = new Gtk.DrawingArea();
+ this.logodrawingarea.Name = "logodrawingarea";
+ this.vbox1.Add(this.logodrawingarea);
+ Gtk.Box.BoxChild w2 = ((Gtk.Box.BoxChild)(this.vbox1[this.logodrawingarea]));
+ w2.Position = 1;
+ // Container child vbox1.Gtk.Box+BoxChild
+ this.hbox2 = new Gtk.HBox();
+ this.hbox2.Name = "hbox2";
+ this.hbox2.Spacing = 6;
+ // Container child hbox2.Gtk.Box+BoxChild
+ this.buttonsbox = new Gtk.HBox();
+ this.buttonsbox.Name = "buttonsbox";
+ this.buttonsbox.Spacing = 6;
+ // Container child buttonsbox.Gtk.Box+BoxChild
+ this.recbutton = new Gtk.Button();
+ this.recbutton.TooltipMarkup = "Start or continue capture";
+ this.recbutton.Name = "recbutton";
+ this.recbutton.UseUnderline = true;
+ // Container child recbutton.Gtk.Container+ContainerChild
+ Gtk.Alignment w3 = new Gtk.Alignment(0.5F, 0.5F, 0F, 0F);
+ // Container child GtkAlignment.Gtk.Container+ContainerChild
+ Gtk.HBox w4 = new Gtk.HBox();
+ w4.Spacing = 2;
+ // Container child GtkHBox.Gtk.Container+ContainerChild
+ Gtk.Image w5 = new Gtk.Image();
+ w5.Pixbuf = Stetic.IconLoader.LoadIcon(this, "gtk-media-record", Gtk.IconSize.Dialog, 48);
+ w4.Add(w5);
+ // Container child GtkHBox.Gtk.Container+ContainerChild
+ Gtk.Label w7 = new Gtk.Label();
+ w4.Add(w7);
+ w3.Add(w4);
+ this.recbutton.Add(w3);
+ this.buttonsbox.Add(this.recbutton);
+ Gtk.Box.BoxChild w11 = ((Gtk.Box.BoxChild)(this.buttonsbox[this.recbutton]));
+ w11.Position = 0;
+ w11.Expand = false;
+ w11.Fill = false;
+ // Container child buttonsbox.Gtk.Box+BoxChild
+ this.pausebutton = new Gtk.Button();
+ this.pausebutton.TooltipMarkup = "Pause capture";
+ this.pausebutton.Name = "pausebutton";
+ this.pausebutton.UseUnderline = true;
+ // Container child pausebutton.Gtk.Container+ContainerChild
+ Gtk.Alignment w12 = new Gtk.Alignment(0.5F, 0.5F, 0F, 0F);
+ // Container child GtkAlignment.Gtk.Container+ContainerChild
+ Gtk.HBox w13 = new Gtk.HBox();
+ w13.Spacing = 2;
+ // Container child GtkHBox.Gtk.Container+ContainerChild
+ Gtk.Image w14 = new Gtk.Image();
+ w14.Pixbuf = Stetic.IconLoader.LoadIcon(this, "gtk-media-pause", Gtk.IconSize.Dialog, 48);
+ w13.Add(w14);
+ // Container child GtkHBox.Gtk.Container+ContainerChild
+ Gtk.Label w16 = new Gtk.Label();
+ w13.Add(w16);
+ w12.Add(w13);
+ this.pausebutton.Add(w12);
+ this.buttonsbox.Add(this.pausebutton);
+ Gtk.Box.BoxChild w20 = ((Gtk.Box.BoxChild)(this.buttonsbox[this.pausebutton]));
+ w20.Position = 1;
+ w20.Expand = false;
+ w20.Fill = false;
+ // Container child buttonsbox.Gtk.Box+BoxChild
+ this.stopbutton = new Gtk.Button();
+ this.stopbutton.TooltipMarkup = "Stop and close capture";
+ this.stopbutton.Name = "stopbutton";
+ this.stopbutton.UseUnderline = true;
+ // Container child stopbutton.Gtk.Container+ContainerChild
+ Gtk.Alignment w21 = new Gtk.Alignment(0.5F, 0.5F, 0F, 0F);
+ // Container child GtkAlignment.Gtk.Container+ContainerChild
+ Gtk.HBox w22 = new Gtk.HBox();
+ w22.Spacing = 2;
+ // Container child GtkHBox.Gtk.Container+ContainerChild
+ Gtk.Image w23 = new Gtk.Image();
+ w23.Pixbuf = Stetic.IconLoader.LoadIcon(this, "gtk-media-stop", Gtk.IconSize.Dialog, 48);
+ w22.Add(w23);
+ // Container child GtkHBox.Gtk.Container+ContainerChild
+ Gtk.Label w25 = new Gtk.Label();
+ w22.Add(w25);
+ w21.Add(w22);
+ this.stopbutton.Add(w21);
+ this.buttonsbox.Add(this.stopbutton);
+ Gtk.Box.BoxChild w29 = ((Gtk.Box.BoxChild)(this.buttonsbox[this.stopbutton]));
+ w29.Position = 2;
+ w29.Expand = false;
+ w29.Fill = false;
+ this.hbox2.Add(this.buttonsbox);
+ Gtk.Box.BoxChild w30 = ((Gtk.Box.BoxChild)(this.hbox2[this.buttonsbox]));
+ w30.Position = 0;
+ w30.Expand = false;
+ w30.Fill = false;
+ // Container child hbox2.Gtk.Box+BoxChild
+ this.timelabel = new Gtk.Label();
+ this.timelabel.Name = "timelabel";
+ this.timelabel.Xalign = 1F;
+ this.timelabel.LabelProp = "Time: 0:00:00";
+ this.hbox2.Add(this.timelabel);
+ Gtk.Box.BoxChild w31 = ((Gtk.Box.BoxChild)(this.hbox2[this.timelabel]));
+ w31.PackType = ((Gtk.PackType)(1));
+ w31.Position = 1;
+ w31.Expand = false;
+ this.vbox1.Add(this.hbox2);
+ Gtk.Box.BoxChild w32 = ((Gtk.Box.BoxChild)(this.vbox1[this.hbox2]));
+ w32.Position = 2;
+ w32.Expand = false;
+ w32.Fill = false;
+ this.Add(this.vbox1);
+ if ((this.Child != null)) {
+ this.Child.ShowAll();
+ }
+ this.pausebutton.Hide();
+ this.stopbutton.Hide();
+ this.Show();
+ this.logodrawingarea.ExposeEvent += new Gtk.ExposeEventHandler(this.OnLogodrawingareaExposeEvent);
+ this.recbutton.Clicked += new System.EventHandler(this.OnRecbuttonClicked);
+ this.pausebutton.Clicked += new System.EventHandler(this.OnPausebuttonClicked);
+ this.stopbutton.Clicked += new System.EventHandler(this.OnStopbuttonClicked);
+ }
+ }
+}
diff --git a/CesarPlayer/gtk-gui/LongoMatch.Gui.PlayerBin.cs b/CesarPlayer/gtk-gui/LongoMatch.Gui.PlayerBin.cs
new file mode 100644
index 0000000..f44aeaf
--- /dev/null
+++ b/CesarPlayer/gtk-gui/LongoMatch.Gui.PlayerBin.cs
@@ -0,0 +1,337 @@
+// ------------------------------------------------------------------------------
+// <autogenerated>
+// This code was generated by a tool.
+//
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+// </autogenerated>
+// ------------------------------------------------------------------------------
+
+namespace LongoMatch.Gui {
+
+
+ public partial class PlayerBin {
+
+ private Gtk.HBox mainbox;
+
+ private Gtk.VBox vbox2;
+
+ private Gtk.HBox videobox;
+
+ private Gtk.HBox controlsbox;
+
+ private Gtk.HBox buttonsbox;
+
+ private Gtk.Button closebutton;
+
+ private Gtk.Button drawbutton;
+
+ private Gtk.Button playbutton;
+
+ private Gtk.Button pausebutton;
+
+ private Gtk.Button prevbutton;
+
+ private Gtk.Button nextbutton;
+
+ private Gtk.Label tlabel;
+
+ private Gtk.HScale timescale;
+
+ private Gtk.Label timelabel;
+
+ private Gtk.Button volumebutton;
+
+ private Gtk.VBox vbox3;
+
+ private Gtk.VScale vscale1;
+
+ protected virtual void Build() {
+ Stetic.Gui.Initialize(this);
+ // Widget LongoMatch.Gui.PlayerBin
+ Stetic.BinContainer.Attach(this);
+ this.Name = "LongoMatch.Gui.PlayerBin";
+ // Container child LongoMatch.Gui.PlayerBin.Gtk.Container+ContainerChild
+ this.mainbox = new Gtk.HBox();
+ this.mainbox.Name = "mainbox";
+ this.mainbox.Spacing = 6;
+ // Container child mainbox.Gtk.Box+BoxChild
+ this.vbox2 = new Gtk.VBox();
+ this.vbox2.Name = "vbox2";
+ this.vbox2.Spacing = 6;
+ // Container child vbox2.Gtk.Box+BoxChild
+ this.videobox = new Gtk.HBox();
+ this.videobox.Name = "videobox";
+ this.videobox.Spacing = 6;
+ this.vbox2.Add(this.videobox);
+ Gtk.Box.BoxChild w1 = ((Gtk.Box.BoxChild)(this.vbox2[this.videobox]));
+ w1.Position = 0;
+ // Container child vbox2.Gtk.Box+BoxChild
+ this.controlsbox = new Gtk.HBox();
+ this.controlsbox.Name = "controlsbox";
+ this.controlsbox.Spacing = 6;
+ // Container child controlsbox.Gtk.Box+BoxChild
+ this.buttonsbox = new Gtk.HBox();
+ this.buttonsbox.Name = "buttonsbox";
+ this.buttonsbox.Homogeneous = true;
+ // Container child buttonsbox.Gtk.Box+BoxChild
+ this.closebutton = new Gtk.Button();
+ this.closebutton.Name = "closebutton";
+ this.closebutton.UseUnderline = true;
+ // Container child closebutton.Gtk.Container+ContainerChild
+ Gtk.Alignment w2 = new Gtk.Alignment(0.5F, 0.5F, 0F, 0F);
+ // Container child GtkAlignment.Gtk.Container+ContainerChild
+ Gtk.HBox w3 = new Gtk.HBox();
+ w3.Spacing = 2;
+ // Container child GtkHBox.Gtk.Container+ContainerChild
+ Gtk.Image w4 = new Gtk.Image();
+ w4.Pixbuf = Stetic.IconLoader.LoadIcon(this, "gtk-close", Gtk.IconSize.Dnd, 32);
+ w3.Add(w4);
+ // Container child GtkHBox.Gtk.Container+ContainerChild
+ Gtk.Label w6 = new Gtk.Label();
+ w3.Add(w6);
+ w2.Add(w3);
+ this.closebutton.Add(w2);
+ this.buttonsbox.Add(this.closebutton);
+ Gtk.Box.BoxChild w10 = ((Gtk.Box.BoxChild)(this.buttonsbox[this.closebutton]));
+ w10.Position = 0;
+ w10.Expand = false;
+ w10.Fill = false;
+ // Container child buttonsbox.Gtk.Box+BoxChild
+ this.drawbutton = new Gtk.Button();
+ this.drawbutton.Name = "drawbutton";
+ this.drawbutton.UseUnderline = true;
+ // Container child drawbutton.Gtk.Container+ContainerChild
+ Gtk.Alignment w11 = new Gtk.Alignment(0.5F, 0.5F, 0F, 0F);
+ // Container child GtkAlignment.Gtk.Container+ContainerChild
+ Gtk.HBox w12 = new Gtk.HBox();
+ w12.Spacing = 2;
+ // Container child GtkHBox.Gtk.Container+ContainerChild
+ Gtk.Image w13 = new Gtk.Image();
+ w13.Pixbuf = Stetic.IconLoader.LoadIcon(this, "gtk-select-color", Gtk.IconSize.Menu, 16);
+ w12.Add(w13);
+ // Container child GtkHBox.Gtk.Container+ContainerChild
+ Gtk.Label w15 = new Gtk.Label();
+ w12.Add(w15);
+ w11.Add(w12);
+ this.drawbutton.Add(w11);
+ this.buttonsbox.Add(this.drawbutton);
+ Gtk.Box.BoxChild w19 = ((Gtk.Box.BoxChild)(this.buttonsbox[this.drawbutton]));
+ w19.Position = 1;
+ w19.Expand = false;
+ w19.Fill = false;
+ // Container child buttonsbox.Gtk.Box+BoxChild
+ this.playbutton = new Gtk.Button();
+ this.playbutton.Name = "playbutton";
+ this.playbutton.UseUnderline = true;
+ this.playbutton.Relief = ((Gtk.ReliefStyle)(2));
+ // Container child playbutton.Gtk.Container+ContainerChild
+ Gtk.Alignment w20 = new Gtk.Alignment(0.5F, 0.5F, 0F, 0F);
+ // Container child GtkAlignment.Gtk.Container+ContainerChild
+ Gtk.HBox w21 = new Gtk.HBox();
+ w21.Spacing = 2;
+ // Container child GtkHBox.Gtk.Container+ContainerChild
+ Gtk.Image w22 = new Gtk.Image();
+ w22.Pixbuf = Stetic.IconLoader.LoadIcon(this, "gtk-media-play", Gtk.IconSize.Button, 16);
+ w21.Add(w22);
+ // Container child GtkHBox.Gtk.Container+ContainerChild
+ Gtk.Label w24 = new Gtk.Label();
+ w21.Add(w24);
+ w20.Add(w21);
+ this.playbutton.Add(w20);
+ this.buttonsbox.Add(this.playbutton);
+ Gtk.Box.BoxChild w28 = ((Gtk.Box.BoxChild)(this.buttonsbox[this.playbutton]));
+ w28.Position = 2;
+ w28.Expand = false;
+ w28.Fill = false;
+ // Container child buttonsbox.Gtk.Box+BoxChild
+ this.pausebutton = new Gtk.Button();
+ this.pausebutton.Name = "pausebutton";
+ this.pausebutton.UseUnderline = true;
+ this.pausebutton.Relief = ((Gtk.ReliefStyle)(2));
+ // Container child pausebutton.Gtk.Container+ContainerChild
+ Gtk.Alignment w29 = new Gtk.Alignment(0.5F, 0.5F, 0F, 0F);
+ // Container child GtkAlignment.Gtk.Container+ContainerChild
+ Gtk.HBox w30 = new Gtk.HBox();
+ w30.Spacing = 2;
+ // Container child GtkHBox.Gtk.Container+ContainerChild
+ Gtk.Image w31 = new Gtk.Image();
+ w31.Pixbuf = Stetic.IconLoader.LoadIcon(this, "gtk-media-pause", Gtk.IconSize.Button, 16);
+ w30.Add(w31);
+ // Container child GtkHBox.Gtk.Container+ContainerChild
+ Gtk.Label w33 = new Gtk.Label();
+ w30.Add(w33);
+ w29.Add(w30);
+ this.pausebutton.Add(w29);
+ this.buttonsbox.Add(this.pausebutton);
+ Gtk.Box.BoxChild w37 = ((Gtk.Box.BoxChild)(this.buttonsbox[this.pausebutton]));
+ w37.Position = 3;
+ w37.Expand = false;
+ w37.Fill = false;
+ // Container child buttonsbox.Gtk.Box+BoxChild
+ this.prevbutton = new Gtk.Button();
+ this.prevbutton.Name = "prevbutton";
+ this.prevbutton.UseUnderline = true;
+ this.prevbutton.Relief = ((Gtk.ReliefStyle)(2));
+ // Container child prevbutton.Gtk.Container+ContainerChild
+ Gtk.Alignment w38 = new Gtk.Alignment(0.5F, 0.5F, 0F, 0F);
+ // Container child GtkAlignment.Gtk.Container+ContainerChild
+ Gtk.HBox w39 = new Gtk.HBox();
+ w39.Spacing = 2;
+ // Container child GtkHBox.Gtk.Container+ContainerChild
+ Gtk.Image w40 = new Gtk.Image();
+ w40.Pixbuf = Stetic.IconLoader.LoadIcon(this, "gtk-media-previous", Gtk.IconSize.Button, 16);
+ w39.Add(w40);
+ // Container child GtkHBox.Gtk.Container+ContainerChild
+ Gtk.Label w42 = new Gtk.Label();
+ w39.Add(w42);
+ w38.Add(w39);
+ this.prevbutton.Add(w38);
+ this.buttonsbox.Add(this.prevbutton);
+ Gtk.Box.BoxChild w46 = ((Gtk.Box.BoxChild)(this.buttonsbox[this.prevbutton]));
+ w46.Position = 4;
+ w46.Expand = false;
+ w46.Fill = false;
+ // Container child buttonsbox.Gtk.Box+BoxChild
+ this.nextbutton = new Gtk.Button();
+ this.nextbutton.Sensitive = false;
+ this.nextbutton.Name = "nextbutton";
+ this.nextbutton.UseUnderline = true;
+ this.nextbutton.Relief = ((Gtk.ReliefStyle)(2));
+ // Container child nextbutton.Gtk.Container+ContainerChild
+ Gtk.Alignment w47 = new Gtk.Alignment(0.5F, 0.5F, 0F, 0F);
+ // Container child GtkAlignment.Gtk.Container+ContainerChild
+ Gtk.HBox w48 = new Gtk.HBox();
+ w48.Spacing = 2;
+ // Container child GtkHBox.Gtk.Container+ContainerChild
+ Gtk.Image w49 = new Gtk.Image();
+ w49.Pixbuf = Stetic.IconLoader.LoadIcon(this, "gtk-media-next", Gtk.IconSize.Button, 16);
+ w48.Add(w49);
+ // Container child GtkHBox.Gtk.Container+ContainerChild
+ Gtk.Label w51 = new Gtk.Label();
+ w48.Add(w51);
+ w47.Add(w48);
+ this.nextbutton.Add(w47);
+ this.buttonsbox.Add(this.nextbutton);
+ Gtk.Box.BoxChild w55 = ((Gtk.Box.BoxChild)(this.buttonsbox[this.nextbutton]));
+ w55.Position = 5;
+ w55.Expand = false;
+ w55.Fill = false;
+ this.controlsbox.Add(this.buttonsbox);
+ Gtk.Box.BoxChild w56 = ((Gtk.Box.BoxChild)(this.controlsbox[this.buttonsbox]));
+ w56.Position = 0;
+ w56.Expand = false;
+ w56.Fill = false;
+ // Container child controlsbox.Gtk.Box+BoxChild
+ this.tlabel = new Gtk.Label();
+ this.tlabel.Name = "tlabel";
+ this.tlabel.LabelProp = Mono.Unix.Catalog.GetString("Time:");
+ this.controlsbox.Add(this.tlabel);
+ Gtk.Box.BoxChild w57 = ((Gtk.Box.BoxChild)(this.controlsbox[this.tlabel]));
+ w57.Position = 1;
+ w57.Expand = false;
+ w57.Fill = false;
+ // Container child controlsbox.Gtk.Box+BoxChild
+ this.timescale = new Gtk.HScale(null);
+ this.timescale.Name = "timescale";
+ this.timescale.UpdatePolicy = ((Gtk.UpdateType)(1));
+ this.timescale.Adjustment.Upper = 1;
+ this.timescale.Adjustment.PageIncrement = 1;
+ this.timescale.Adjustment.StepIncrement = 1;
+ this.timescale.Adjustment.Value = 1;
+ this.timescale.DrawValue = false;
+ this.timescale.Digits = 0;
+ this.timescale.ValuePos = ((Gtk.PositionType)(2));
+ this.controlsbox.Add(this.timescale);
+ Gtk.Box.BoxChild w58 = ((Gtk.Box.BoxChild)(this.controlsbox[this.timescale]));
+ w58.Position = 2;
+ // Container child controlsbox.Gtk.Box+BoxChild
+ this.timelabel = new Gtk.Label();
+ this.timelabel.Name = "timelabel";
+ this.controlsbox.Add(this.timelabel);
+ Gtk.Box.BoxChild w59 = ((Gtk.Box.BoxChild)(this.controlsbox[this.timelabel]));
+ w59.Position = 3;
+ w59.Expand = false;
+ // Container child controlsbox.Gtk.Box+BoxChild
+ this.volumebutton = new Gtk.Button();
+ this.volumebutton.Name = "volumebutton";
+ this.volumebutton.UseUnderline = true;
+ this.volumebutton.Relief = ((Gtk.ReliefStyle)(2));
+ // Container child volumebutton.Gtk.Container+ContainerChild
+ Gtk.Alignment w60 = new Gtk.Alignment(0.5F, 0.5F, 0F, 0F);
+ // Container child GtkAlignment.Gtk.Container+ContainerChild
+ Gtk.HBox w61 = new Gtk.HBox();
+ w61.Spacing = 2;
+ // Container child GtkHBox.Gtk.Container+ContainerChild
+ Gtk.Image w62 = new Gtk.Image();
+ w62.Pixbuf = Stetic.IconLoader.LoadIcon(this, "stock_volume", Gtk.IconSize.Button, 16);
+ w61.Add(w62);
+ // Container child GtkHBox.Gtk.Container+ContainerChild
+ Gtk.Label w64 = new Gtk.Label();
+ w61.Add(w64);
+ w60.Add(w61);
+ this.volumebutton.Add(w60);
+ this.controlsbox.Add(this.volumebutton);
+ Gtk.Box.BoxChild w68 = ((Gtk.Box.BoxChild)(this.controlsbox[this.volumebutton]));
+ w68.Position = 4;
+ w68.Expand = false;
+ w68.Fill = false;
+ this.vbox2.Add(this.controlsbox);
+ Gtk.Box.BoxChild w69 = ((Gtk.Box.BoxChild)(this.vbox2[this.controlsbox]));
+ w69.Position = 1;
+ w69.Expand = false;
+ this.mainbox.Add(this.vbox2);
+ Gtk.Box.BoxChild w70 = ((Gtk.Box.BoxChild)(this.mainbox[this.vbox2]));
+ w70.Position = 0;
+ // Container child mainbox.Gtk.Box+BoxChild
+ this.vbox3 = new Gtk.VBox();
+ this.vbox3.Name = "vbox3";
+ this.vbox3.Spacing = 6;
+ // Container child vbox3.Gtk.Box+BoxChild
+ this.vscale1 = new Gtk.VScale(null);
+ this.vscale1.WidthRequest = 45;
+ this.vscale1.Sensitive = false;
+ this.vscale1.Name = "vscale1";
+ this.vscale1.UpdatePolicy = ((Gtk.UpdateType)(1));
+ this.vscale1.Inverted = true;
+ this.vscale1.Adjustment.Lower = 1;
+ this.vscale1.Adjustment.Upper = 28;
+ this.vscale1.Adjustment.PageIncrement = 3;
+ this.vscale1.Adjustment.PageSize = 1;
+ this.vscale1.Adjustment.StepIncrement = 1;
+ this.vscale1.Adjustment.Value = 25;
+ this.vscale1.DrawValue = true;
+ this.vscale1.Digits = 0;
+ this.vscale1.ValuePos = ((Gtk.PositionType)(3));
+ this.vbox3.Add(this.vscale1);
+ Gtk.Box.BoxChild w71 = ((Gtk.Box.BoxChild)(this.vbox3[this.vscale1]));
+ w71.Position = 0;
+ this.mainbox.Add(this.vbox3);
+ Gtk.Box.BoxChild w72 = ((Gtk.Box.BoxChild)(this.mainbox[this.vbox3]));
+ w72.Position = 1;
+ w72.Expand = false;
+ w72.Fill = false;
+ this.Add(this.mainbox);
+ if ((this.Child != null)) {
+ this.Child.ShowAll();
+ }
+ this.closebutton.Hide();
+ this.prevbutton.Hide();
+ this.nextbutton.Hide();
+ this.controlsbox.Hide();
+ this.Show();
+ this.closebutton.Clicked += new System.EventHandler(this.OnClosebuttonClicked);
+ this.drawbutton.Clicked += new System.EventHandler(this.OnDrawButtonClicked);
+ this.playbutton.Clicked += new System.EventHandler(this.OnPlaybuttonClicked);
+ this.pausebutton.Clicked += new System.EventHandler(this.OnPausebuttonClicked);
+ this.prevbutton.Clicked += new System.EventHandler(this.OnPrevbuttonClicked);
+ this.nextbutton.Clicked += new System.EventHandler(this.OnNextbuttonClicked);
+ this.timescale.ValueChanged += new System.EventHandler(this.OnTimescaleValueChanged);
+ this.timescale.AdjustBounds += new Gtk.AdjustBoundsHandler(this.OnTimescaleAdjustBounds);
+ this.volumebutton.Clicked += new System.EventHandler(this.OnVolumebuttonClicked);
+ this.vscale1.FormatValue += new Gtk.FormatValueHandler(this.OnVscale1FormatValue);
+ this.vscale1.ValueChanged += new System.EventHandler(this.OnVscale1ValueChanged);
+ }
+ }
+}
diff --git a/CesarPlayer/gtk-gui/LongoMatch.Gui.VolumeWindow.cs b/CesarPlayer/gtk-gui/LongoMatch.Gui.VolumeWindow.cs
new file mode 100644
index 0000000..ece41c9
--- /dev/null
+++ b/CesarPlayer/gtk-gui/LongoMatch.Gui.VolumeWindow.cs
@@ -0,0 +1,85 @@
+// ------------------------------------------------------------------------------
+// <autogenerated>
+// This code was generated by a tool.
+//
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+// </autogenerated>
+// ------------------------------------------------------------------------------
+
+namespace LongoMatch.Gui {
+
+
+ public partial class VolumeWindow {
+
+ private Gtk.VBox vbox2;
+
+ private Gtk.Button morebutton;
+
+ private Gtk.VScale volumescale;
+
+ private Gtk.Button lessbutton;
+
+ protected virtual void Build() {
+ Stetic.Gui.Initialize(this);
+ // Widget LongoMatch.Gui.VolumeWindow
+ this.Name = "LongoMatch.Gui.VolumeWindow";
+ this.Title = "";
+ this.WindowPosition = ((Gtk.WindowPosition)(2));
+ this.Decorated = false;
+ this.DestroyWithParent = true;
+ this.SkipPagerHint = true;
+ this.SkipTaskbarHint = true;
+ // Container child LongoMatch.Gui.VolumeWindow.Gtk.Container+ContainerChild
+ this.vbox2 = new Gtk.VBox();
+ this.vbox2.Name = "vbox2";
+ // Container child vbox2.Gtk.Box+BoxChild
+ this.morebutton = new Gtk.Button();
+ this.morebutton.Name = "morebutton";
+ this.morebutton.Relief = ((Gtk.ReliefStyle)(2));
+ this.morebutton.Label = "+";
+ this.vbox2.Add(this.morebutton);
+ Gtk.Box.BoxChild w1 = ((Gtk.Box.BoxChild)(this.vbox2[this.morebutton]));
+ w1.Position = 0;
+ w1.Expand = false;
+ w1.Fill = false;
+ // Container child vbox2.Gtk.Box+BoxChild
+ this.volumescale = new Gtk.VScale(null);
+ this.volumescale.CanFocus = true;
+ this.volumescale.Name = "volumescale";
+ this.volumescale.Inverted = true;
+ this.volumescale.Adjustment.Upper = 1;
+ this.volumescale.Adjustment.PageIncrement = 1;
+ this.volumescale.Adjustment.StepIncrement = 1;
+ this.volumescale.Adjustment.Value = 1;
+ this.volumescale.DrawValue = false;
+ this.volumescale.Digits = 0;
+ this.volumescale.ValuePos = ((Gtk.PositionType)(2));
+ this.vbox2.Add(this.volumescale);
+ Gtk.Box.BoxChild w2 = ((Gtk.Box.BoxChild)(this.vbox2[this.volumescale]));
+ w2.Position = 1;
+ // Container child vbox2.Gtk.Box+BoxChild
+ this.lessbutton = new Gtk.Button();
+ this.lessbutton.Name = "lessbutton";
+ this.lessbutton.Relief = ((Gtk.ReliefStyle)(2));
+ this.lessbutton.Label = "-";
+ this.vbox2.Add(this.lessbutton);
+ Gtk.Box.BoxChild w3 = ((Gtk.Box.BoxChild)(this.vbox2[this.lessbutton]));
+ w3.Position = 2;
+ w3.Expand = false;
+ w3.Fill = false;
+ this.Add(this.vbox2);
+ if ((this.Child != null)) {
+ this.Child.ShowAll();
+ }
+ this.DefaultWidth = 31;
+ this.DefaultHeight = 204;
+ this.Hide();
+ this.FocusOutEvent += new Gtk.FocusOutEventHandler(this.OnFocusOutEvent);
+ this.morebutton.Clicked += new System.EventHandler(this.OnMorebuttonClicked);
+ this.volumescale.ValueChanged += new System.EventHandler(this.OnVolumescaleValueChanged);
+ this.lessbutton.Clicked += new System.EventHandler(this.OnLessbuttonClicked);
+ }
+ }
+}
diff --git a/CesarPlayer/gtk-gui/generated.cs b/CesarPlayer/gtk-gui/generated.cs
new file mode 100644
index 0000000..35f420b
--- /dev/null
+++ b/CesarPlayer/gtk-gui/generated.cs
@@ -0,0 +1,115 @@
+// ------------------------------------------------------------------------------
+// <autogenerated>
+// This code was generated by a tool.
+//
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+// </autogenerated>
+// ------------------------------------------------------------------------------
+
+namespace Stetic {
+
+
+ internal class Gui {
+
+ private static bool initialized;
+
+ internal static void Initialize(Gtk.Widget iconRenderer) {
+ if ((Stetic.Gui.initialized == false)) {
+ Stetic.Gui.initialized = true;
+ }
+ }
+ }
+
+ internal class BinContainer {
+
+ private Gtk.Widget child;
+
+ private Gtk.UIManager uimanager;
+
+ public static BinContainer Attach(Gtk.Bin bin) {
+ BinContainer bc = new BinContainer();
+ bin.SizeRequested += new Gtk.SizeRequestedHandler(bc.OnSizeRequested);
+ bin.SizeAllocated += new Gtk.SizeAllocatedHandler(bc.OnSizeAllocated);
+ bin.Added += new Gtk.AddedHandler(bc.OnAdded);
+ return bc;
+ }
+
+ private void OnSizeRequested(object sender, Gtk.SizeRequestedArgs args) {
+ if ((this.child != null)) {
+ args.Requisition = this.child.SizeRequest();
+ }
+ }
+
+ private void OnSizeAllocated(object sender, Gtk.SizeAllocatedArgs args) {
+ if ((this.child != null)) {
+ this.child.Allocation = args.Allocation;
+ }
+ }
+
+ private void OnAdded(object sender, Gtk.AddedArgs args) {
+ this.child = args.Widget;
+ }
+
+ public void SetUiManager(Gtk.UIManager uim) {
+ this.uimanager = uim;
+ this.child.Realized += new System.EventHandler(this.OnRealized);
+ }
+
+ private void OnRealized(object sender, System.EventArgs args) {
+ if ((this.uimanager != null)) {
+ Gtk.Widget w;
+ w = this.child.Toplevel;
+ if (((w != null) && typeof(Gtk.Window).IsInstanceOfType(w))) {
+ ((Gtk.Window)(w)).AddAccelGroup(this.uimanager.AccelGroup);
+ this.uimanager = null;
+ }
+ }
+ }
+ }
+
+ internal class IconLoader {
+
+ public static Gdk.Pixbuf LoadIcon(Gtk.Widget widget, string name, Gtk.IconSize size, int sz) {
+ Gdk.Pixbuf res = widget.RenderIcon(name, size, null);
+ if ((res != null)) {
+ return res;
+ }
+ else {
+ try {
+ return Gtk.IconTheme.Default.LoadIcon(name, sz, 0);
+ }
+ catch (System.Exception ) {
+ if ((name != "gtk-missing-image")) {
+ return Stetic.IconLoader.LoadIcon(widget, "gtk-missing-image", size, sz);
+ }
+ else {
+ Gdk.Pixmap pmap = new Gdk.Pixmap(Gdk.Screen.Default.RootWindow, sz, sz);
+ Gdk.GC gc = new Gdk.GC(pmap);
+ gc.RgbFgColor = new Gdk.Color(255, 255, 255);
+ pmap.DrawRectangle(gc, true, 0, 0, sz, sz);
+ gc.RgbFgColor = new Gdk.Color(0, 0, 0);
+ pmap.DrawRectangle(gc, false, 0, 0, (sz - 1), (sz - 1));
+ gc.SetLineAttributes(3, Gdk.LineStyle.Solid, Gdk.CapStyle.Round, Gdk.JoinStyle.Round);
+ gc.RgbFgColor = new Gdk.Color(255, 0, 0);
+ pmap.DrawLine(gc, (sz / 4), (sz / 4), ((sz - 1) - (sz / 4)), ((sz - 1) - (sz / 4)));
+ pmap.DrawLine(gc, ((sz - 1) - (sz / 4)), (sz / 4), (sz / 4), ((sz - 1) - (sz / 4)));
+ return Gdk.Pixbuf.FromDrawable(pmap, pmap.Colormap, 0, 0, 0, 0, sz, sz);
+ }
+ }
+ }
+ }
+ }
+
+ internal class ActionGroups {
+
+ public static Gtk.ActionGroup GetActionGroup(System.Type type) {
+ return Stetic.ActionGroups.GetActionGroup(type.FullName);
+ }
+
+ public static Gtk.ActionGroup GetActionGroup(string name) {
+ return null;
+ }
+ }
+}
diff --git a/CesarPlayer/gtk-gui/gui.stetic b/CesarPlayer/gtk-gui/gui.stetic
new file mode 100644
index 0000000..1421d4b
--- /dev/null
+++ b/CesarPlayer/gtk-gui/gui.stetic
@@ -0,0 +1,451 @@
+<?xml version="1.0" encoding="utf-8"?>
+<stetic-interface>
+ <configuration>
+ <images-root-path>..</images-root-path>
+ <target-gtk-version>2.12</target-gtk-version>
+ </configuration>
+ <import>
+ <widget-library name="../bin/Release/CesarPlayer.dll" internal="true" />
+ </import>
+ <widget class="Gtk.Window" id="LongoMatch.Gui.VolumeWindow" design-size="31 204">
+ <property name="MemberName" />
+ <property name="Visible">False</property>
+ <property name="Title" />
+ <property name="WindowPosition">Mouse</property>
+ <property name="Decorated">False</property>
+ <property name="DestroyWithParent">True</property>
+ <property name="SkipPagerHint">True</property>
+ <property name="SkipTaskbarHint">True</property>
+ <signal name="FocusOutEvent" handler="OnFocusOutEvent" />
+ <child>
+ <widget class="Gtk.VBox" id="vbox2">
+ <property name="MemberName" />
+ <child>
+ <widget class="Gtk.Button" id="morebutton">
+ <property name="MemberName" />
+ <property name="Type">TextOnly</property>
+ <property name="Label">+</property>
+ <property name="Relief">None</property>
+ <signal name="Clicked" handler="OnMorebuttonClicked" />
+ </widget>
+ <packing>
+ <property name="Position">0</property>
+ <property name="AutoSize">True</property>
+ <property name="Expand">False</property>
+ <property name="Fill">False</property>
+ </packing>
+ </child>
+ <child>
+ <widget class="Gtk.VScale" id="volumescale">
+ <property name="MemberName" />
+ <property name="CanFocus">True</property>
+ <property name="Inverted">True</property>
+ <property name="Upper">1</property>
+ <property name="PageIncrement">1</property>
+ <property name="StepIncrement">1</property>
+ <property name="Value">1</property>
+ <property name="DrawValue">False</property>
+ <property name="Digits">0</property>
+ <property name="ValuePos">Top</property>
+ <signal name="ValueChanged" handler="OnVolumescaleValueChanged" />
+ </widget>
+ <packing>
+ <property name="Position">1</property>
+ <property name="AutoSize">True</property>
+ </packing>
+ </child>
+ <child>
+ <widget class="Gtk.Button" id="lessbutton">
+ <property name="MemberName" />
+ <property name="Type">TextOnly</property>
+ <property name="Label">-</property>
+ <property name="Relief">None</property>
+ <signal name="Clicked" handler="OnLessbuttonClicked" />
+ </widget>
+ <packing>
+ <property name="Position">2</property>
+ <property name="AutoSize">True</property>
+ <property name="Expand">False</property>
+ <property name="Fill">False</property>
+ </packing>
+ </child>
+ </widget>
+ </child>
+ </widget>
+ <widget class="Gtk.Bin" id="LongoMatch.Gui.PlayerBin" design-size="798 300">
+ <property name="MemberName" />
+ <child>
+ <widget class="Gtk.HBox" id="mainbox">
+ <property name="MemberName" />
+ <property name="Spacing">6</property>
+ <child>
+ <widget class="Gtk.VBox" id="vbox2">
+ <property name="MemberName" />
+ <property name="Spacing">6</property>
+ <child>
+ <widget class="Gtk.HBox" id="videobox">
+ <property name="MemberName" />
+ <property name="Spacing">6</property>
+ <child>
+ <placeholder />
+ </child>
+ </widget>
+ <packing>
+ <property name="Position">0</property>
+ <property name="AutoSize">True</property>
+ </packing>
+ </child>
+ <child>
+ <widget class="Gtk.HBox" id="controlsbox">
+ <property name="MemberName" />
+ <property name="Visible">False</property>
+ <property name="Spacing">6</property>
+ <child>
+ <widget class="Gtk.HBox" id="buttonsbox">
+ <property name="MemberName" />
+ <property name="Homogeneous">True</property>
+ <child>
+ <widget class="Gtk.Button" id="closebutton">
+ <property name="MemberName" />
+ <property name="Visible">False</property>
+ <property name="Type">TextAndIcon</property>
+ <property name="Icon">stock:gtk-close Dnd</property>
+ <property name="Label" translatable="yes" />
+ <property name="UseUnderline">True</property>
+ <signal name="Clicked" handler="OnClosebuttonClicked" />
+ </widget>
+ <packing>
+ <property name="Position">0</property>
+ <property name="AutoSize">True</property>
+ <property name="Expand">False</property>
+ <property name="Fill">False</property>
+ </packing>
+ </child>
+ <child>
+ <widget class="Gtk.Button" id="drawbutton">
+ <property name="MemberName" />
+ <property name="Type">TextAndIcon</property>
+ <property name="Icon">stock:gtk-select-color Menu</property>
+ <property name="Label" translatable="yes" />
+ <property name="UseUnderline">True</property>
+ <signal name="Clicked" handler="OnDrawButtonClicked" />
+ </widget>
+ <packing>
+ <property name="Position">1</property>
+ <property name="AutoSize">True</property>
+ <property name="Expand">False</property>
+ <property name="Fill">False</property>
+ </packing>
+ </child>
+ <child>
+ <widget class="Gtk.Button" id="playbutton">
+ <property name="MemberName" />
+ <property name="Type">TextAndIcon</property>
+ <property name="Icon">stock:gtk-media-play Button</property>
+ <property name="Label" translatable="yes" />
+ <property name="UseUnderline">True</property>
+ <property name="Relief">None</property>
+ <signal name="Clicked" handler="OnPlaybuttonClicked" />
+ </widget>
+ <packing>
+ <property name="Position">2</property>
+ <property name="AutoSize">True</property>
+ <property name="Expand">False</property>
+ <property name="Fill">False</property>
+ </packing>
+ </child>
+ <child>
+ <widget class="Gtk.Button" id="pausebutton">
+ <property name="MemberName" />
+ <property name="Type">TextAndIcon</property>
+ <property name="Icon">stock:gtk-media-pause Button</property>
+ <property name="Label" translatable="yes" />
+ <property name="UseUnderline">True</property>
+ <property name="Relief">None</property>
+ <signal name="Clicked" handler="OnPausebuttonClicked" />
+ </widget>
+ <packing>
+ <property name="Position">3</property>
+ <property name="AutoSize">True</property>
+ <property name="Expand">False</property>
+ <property name="Fill">False</property>
+ </packing>
+ </child>
+ <child>
+ <widget class="Gtk.Button" id="prevbutton">
+ <property name="MemberName" />
+ <property name="Visible">False</property>
+ <property name="Type">TextAndIcon</property>
+ <property name="Icon">stock:gtk-media-previous Button</property>
+ <property name="Label" translatable="yes" />
+ <property name="UseUnderline">True</property>
+ <property name="Relief">None</property>
+ <signal name="Clicked" handler="OnPrevbuttonClicked" />
+ </widget>
+ <packing>
+ <property name="Position">4</property>
+ <property name="AutoSize">True</property>
+ <property name="Expand">False</property>
+ <property name="Fill">False</property>
+ </packing>
+ </child>
+ <child>
+ <widget class="Gtk.Button" id="nextbutton">
+ <property name="MemberName" />
+ <property name="Visible">False</property>
+ <property name="Sensitive">False</property>
+ <property name="Type">TextAndIcon</property>
+ <property name="Icon">stock:gtk-media-next Button</property>
+ <property name="Label" translatable="yes" />
+ <property name="UseUnderline">True</property>
+ <property name="Relief">None</property>
+ <signal name="Clicked" handler="OnNextbuttonClicked" />
+ </widget>
+ <packing>
+ <property name="Position">5</property>
+ <property name="AutoSize">True</property>
+ <property name="Expand">False</property>
+ <property name="Fill">False</property>
+ </packing>
+ </child>
+ </widget>
+ <packing>
+ <property name="Position">0</property>
+ <property name="AutoSize">False</property>
+ <property name="Expand">False</property>
+ <property name="Fill">False</property>
+ </packing>
+ </child>
+ <child>
+ <widget class="Gtk.Label" id="tlabel">
+ <property name="MemberName" />
+ <property name="LabelProp" translatable="yes">Time:</property>
+ </widget>
+ <packing>
+ <property name="Position">1</property>
+ <property name="AutoSize">True</property>
+ <property name="Expand">False</property>
+ <property name="Fill">False</property>
+ </packing>
+ </child>
+ <child>
+ <widget class="Gtk.HScale" id="timescale">
+ <property name="MemberName" />
+ <property name="UpdatePolicy">Discontinuous</property>
+ <property name="Upper">1</property>
+ <property name="PageIncrement">1</property>
+ <property name="StepIncrement">1</property>
+ <property name="Value">1</property>
+ <property name="DrawValue">False</property>
+ <property name="Digits">0</property>
+ <property name="ValuePos">Top</property>
+ <signal name="ValueChanged" handler="OnTimescaleValueChanged" />
+ <signal name="AdjustBounds" handler="OnTimescaleAdjustBounds" />
+ </widget>
+ <packing>
+ <property name="Position">2</property>
+ <property name="AutoSize">True</property>
+ </packing>
+ </child>
+ <child>
+ <widget class="Gtk.Label" id="timelabel">
+ <property name="MemberName" />
+ </widget>
+ <packing>
+ <property name="Position">3</property>
+ <property name="AutoSize">False</property>
+ <property name="Expand">False</property>
+ </packing>
+ </child>
+ <child>
+ <widget class="Gtk.Button" id="volumebutton">
+ <property name="MemberName" />
+ <property name="Type">TextAndIcon</property>
+ <property name="Icon">stock:stock_volume Button</property>
+ <property name="Label" translatable="yes" />
+ <property name="UseUnderline">True</property>
+ <property name="Relief">None</property>
+ <signal name="Clicked" handler="OnVolumebuttonClicked" />
+ </widget>
+ <packing>
+ <property name="Position">4</property>
+ <property name="AutoSize">True</property>
+ <property name="Expand">False</property>
+ <property name="Fill">False</property>
+ </packing>
+ </child>
+ </widget>
+ <packing>
+ <property name="Position">1</property>
+ <property name="AutoSize">False</property>
+ <property name="Expand">False</property>
+ </packing>
+ </child>
+ </widget>
+ <packing>
+ <property name="Position">0</property>
+ <property name="AutoSize">False</property>
+ </packing>
+ </child>
+ <child>
+ <widget class="Gtk.VBox" id="vbox3">
+ <property name="MemberName" />
+ <property name="Spacing">6</property>
+ <child>
+ <widget class="Gtk.VScale" id="vscale1">
+ <property name="MemberName" />
+ <property name="WidthRequest">45</property>
+ <property name="Sensitive">False</property>
+ <property name="UpdatePolicy">Discontinuous</property>
+ <property name="Inverted">True</property>
+ <property name="Lower">1</property>
+ <property name="Upper">28</property>
+ <property name="PageIncrement">3</property>
+ <property name="PageSize">1</property>
+ <property name="StepIncrement">1</property>
+ <property name="Value">25</property>
+ <property name="DrawValue">True</property>
+ <property name="Digits">0</property>
+ <property name="ValuePos">Bottom</property>
+ <signal name="FormatValue" handler="OnVscale1FormatValue" />
+ <signal name="ValueChanged" handler="OnVscale1ValueChanged" />
+ </widget>
+ <packing>
+ <property name="Position">0</property>
+ <property name="AutoSize">False</property>
+ </packing>
+ </child>
+ </widget>
+ <packing>
+ <property name="Position">1</property>
+ <property name="AutoSize">False</property>
+ <property name="Expand">False</property>
+ <property name="Fill">False</property>
+ </packing>
+ </child>
+ </widget>
+ </child>
+ </widget>
+ <widget class="Gtk.Bin" id="LongoMatch.Gui.CapturerBin" design-size="356 295">
+ <property name="MemberName" />
+ <child>
+ <widget class="Gtk.VBox" id="vbox1">
+ <property name="MemberName" />
+ <property name="Spacing">6</property>
+ <child>
+ <widget class="Gtk.HBox" id="capturerhbox">
+ <property name="MemberName" />
+ <property name="Spacing">6</property>
+ <child>
+ <placeholder />
+ </child>
+ </widget>
+ <packing>
+ <property name="Position">0</property>
+ <property name="AutoSize">False</property>
+ </packing>
+ </child>
+ <child>
+ <widget class="Gtk.DrawingArea" id="logodrawingarea">
+ <property name="MemberName" />
+ <signal name="ExposeEvent" handler="OnLogodrawingareaExposeEvent" />
+ </widget>
+ <packing>
+ <property name="Position">1</property>
+ <property name="AutoSize">True</property>
+ </packing>
+ </child>
+ <child>
+ <widget class="Gtk.HBox" id="hbox2">
+ <property name="MemberName" />
+ <property name="Spacing">6</property>
+ <child>
+ <widget class="Gtk.HBox" id="buttonsbox">
+ <property name="MemberName" />
+ <property name="Spacing">6</property>
+ <child>
+ <widget class="Gtk.Button" id="recbutton">
+ <property name="MemberName" />
+ <property name="Tooltip" translatable="yes">Start or continue capture</property>
+ <property name="Type">TextAndIcon</property>
+ <property name="Icon">stock:gtk-media-record Dialog</property>
+ <property name="Label" translatable="yes" />
+ <property name="UseUnderline">True</property>
+ <signal name="Clicked" handler="OnRecbuttonClicked" />
+ </widget>
+ <packing>
+ <property name="Position">0</property>
+ <property name="AutoSize">False</property>
+ <property name="Expand">False</property>
+ <property name="Fill">False</property>
+ </packing>
+ </child>
+ <child>
+ <widget class="Gtk.Button" id="pausebutton">
+ <property name="MemberName" />
+ <property name="Visible">False</property>
+ <property name="Tooltip" translatable="yes">Pause capture</property>
+ <property name="Type">TextAndIcon</property>
+ <property name="Icon">stock:gtk-media-pause Dialog</property>
+ <property name="Label" translatable="yes" />
+ <property name="UseUnderline">True</property>
+ <signal name="Clicked" handler="OnPausebuttonClicked" />
+ </widget>
+ <packing>
+ <property name="Position">1</property>
+ <property name="AutoSize">False</property>
+ <property name="Expand">False</property>
+ <property name="Fill">False</property>
+ </packing>
+ </child>
+ <child>
+ <widget class="Gtk.Button" id="stopbutton">
+ <property name="MemberName" />
+ <property name="Visible">False</property>
+ <property name="Tooltip" translatable="yes">Stop and close capture</property>
+ <property name="Type">TextAndIcon</property>
+ <property name="Icon">stock:gtk-media-stop Dialog</property>
+ <property name="Label" translatable="yes" />
+ <property name="UseUnderline">True</property>
+ <signal name="Clicked" handler="OnStopbuttonClicked" />
+ </widget>
+ <packing>
+ <property name="Position">2</property>
+ <property name="AutoSize">False</property>
+ <property name="Expand">False</property>
+ <property name="Fill">False</property>
+ </packing>
+ </child>
+ </widget>
+ <packing>
+ <property name="Position">0</property>
+ <property name="AutoSize">True</property>
+ <property name="Expand">False</property>
+ <property name="Fill">False</property>
+ </packing>
+ </child>
+ <child>
+ <widget class="Gtk.Label" id="timelabel">
+ <property name="MemberName" />
+ <property name="Xalign">1</property>
+ <property name="LabelProp">Time: 0:00:00</property>
+ </widget>
+ <packing>
+ <property name="PackType">End</property>
+ <property name="Position">1</property>
+ <property name="AutoSize">False</property>
+ <property name="Expand">False</property>
+ </packing>
+ </child>
+ </widget>
+ <packing>
+ <property name="Position">2</property>
+ <property name="AutoSize">False</property>
+ <property name="Expand">False</property>
+ <property name="Fill">False</property>
+ </packing>
+ </child>
+ </widget>
+ </child>
+ </widget>
+</stetic-interface>
\ No newline at end of file
diff --git a/CesarPlayer/gtk-gui/objects.xml b/CesarPlayer/gtk-gui/objects.xml
new file mode 100644
index 0000000..8946adc
--- /dev/null
+++ b/CesarPlayer/gtk-gui/objects.xml
@@ -0,0 +1,31 @@
+<objects attr-sync="on">
+ <object type="LongoMatch.Gui.CapturerBin" palette-category="CesarPlayer" allow-children="false" base-type="Gtk.Bin">
+ <itemgroups />
+ <signals>
+ <itemgroup label="CapturerBin Signals">
+ <signal name="CaptureFinished" />
+ <signal name="Error" />
+ </itemgroup>
+ </signals>
+ </object>
+ <object type="LongoMatch.Gui.PlayerBin" palette-category="LongoMatch" allow-children="false" base-type="Gtk.Bin">
+ <itemgroups>
+ <itemgroup label="PlayerBin Properties">
+ <property name="Rate" />
+ <property name="ExpandLogo" />
+ </itemgroup>
+ </itemgroups>
+ <signals>
+ <itemgroup label="PlayerBin Signals">
+ <signal name="SegmentClosedEvent" />
+ <signal name="Tick" />
+ <signal name="Error" />
+ <signal name="Next" />
+ <signal name="Prev" />
+ <signal name="DrawFrame" />
+ <signal name="SeekEvent" />
+ <signal name="PlayStateChanged" />
+ </itemgroup>
+ </signals>
+ </object>
+</objects>
\ No newline at end of file
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
