Mostly implement media player
[vlc.git] / bindings / cil / src / player.cs
1 /**
2  * @file player.cs
3  * @brief Media player class
4  * @ingroup API
5  *
6  * @defgroup API Managed interface to LibVLC
7  * This is the primary class library for .NET applications
8  * to embed and control LibVLC.
9  *
10  * @defgroup Internals LibVLC internals
11  * This covers internal marshalling functions to use the native LibVLC.
12  * Only VLC developpers should need to read this section.
13  */
14
15 /**********************************************************************
16  *  Copyright (C) 2009 RĂ©mi Denis-Courmont.                           *
17  *  This program is free software; you can redistribute and/or modify *
18  *  it under the terms of the GNU General Public License as published *
19  *  by the Free Software Foundation; version 2 of the license, or (at *
20  *  your option) any later version.                                   *
21  *                                                                    *
22  *  This program is distributed in the hope that it will be useful,   *
23  *  but WITHOUT ANY WARRANTY; without even the implied warranty of    *
24  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.              *
25  *  See the GNU General Public License for more details.              *
26  *                                                                    *
27  *  You should have received a copy of the GNU General Public License *
28  *  along with this program; if not, you can get it from:             *
29  *  http://www.gnu.org/copyleft/gpl.html                              *
30  **********************************************************************/
31
32 using System;
33 using System.Runtime.InteropServices;
34
35 namespace VideoLAN.LibVLC
36 {
37    /**
38      * @brief PlayerHandle: unmanaged LibVLC media player pointer
39      * @ingroup Internals
40      */
41     internal sealed class PlayerHandle : NonNullHandle
42     {
43         protected override void Destroy ()
44         {
45             LibVLC.PlayerRelease (handle);
46         }
47     };
48
49     /**
50      * @brief MediaPlayer: a simple media player
51      * @ingroup API
52      * Use this class to play a media.
53      */
54     public class Player : BaseObject
55     {
56         internal PlayerHandle Handle
57         {
58             get
59             {
60                 return handle as PlayerHandle;
61             }
62         }
63
64         Media media; /**< Active media */
65         /**
66          * The Media object that the MediaPlayer is using,
67          * or null if there is none.
68          */
69         public Media Media
70         {
71             get
72             {
73                 return media;
74             }
75             set
76             {
77                 MediaHandle mh = (value != null) ? value.Handle : null;
78
79                 LibVLC.PlayerSetMedia (Handle, mh, null);
80                 media = value;
81             }
82         }
83
84         /**
85          * Creates a player with no medias.
86          * An input media will be needed before this media player can be used.
87          *
88          * @param instance VLC instance
89          */
90         public Player (VLC instance)
91         {
92             this.media = null;
93             handle = LibVLC.PlayerCreate (instance.Handle, ex);
94             Raise ();
95         }
96
97         /**
98          * Creates a player object for a given a media.
99          *
100          * @param media media object
101          */
102         public Player (Media media)
103         {
104             this.media = media;
105             handle = LibVLC.PlayerCreateFromMedia (media.Handle, ex);
106             Raise ();
107         }
108
109         /**
110          * Whether the player is currently active.
111          */
112         public bool IsPlaying
113         {
114             get
115             {
116                 int ret = LibVLC.PlayerIsPlaying (Handle, ex);
117                 Raise ();
118                 return ret != 0;
119             }
120         }
121
122         /**
123          * Starts playing the selected media.
124          */
125         public void Play ()
126         {
127             LibVLC.PlayerPlay (Handle, ex);
128             Raise ();
129         }
130
131         /**
132          * Pauses the playback.
133          */
134         public void Pause ()
135         {
136             LibVLC.PlayerPause (Handle, ex);
137             Raise ();
138         }
139
140         /**
141          * Stops the playback.
142          */
143         public void Stop ()
144         {
145             LibVLC.PlayerStop (Handle, ex);
146             Raise ();
147         }
148
149         /**
150          * The 32-bits identifier of an X Window System window,
151          * or 0 if not specified.
152          * Video will be rendered inside that window, if the underlying VLC
153          * supports X11. Note that X pixmaps are <b>not</b> supported.
154          * Also note that you should set/change/unset the window while
155          * playback is not started or stopped; live reparenting might not
156          * work.
157          *
158          * <b>Warning:</b>
159          * If the identifier is invalid, Xlib might abort the process.
160          */
161         public int XWindow
162         {
163             get
164             {
165                 return LibVLC.PlayerGetXWindow (Handle);
166             }
167             set
168             {
169                 LibVLC.PlayerSetXWindow (Handle, value, ex);
170                 Raise ();
171             }
172         }
173
174         /**
175          * The handle of a window (HWND) from the Win32 API,
176          * or NULL if unspecified.
177          * Video will be rendered inside that window, if the underlying VLC
178          * supports one of DirectDraw, Direct3D, GDI or OpenGL/Win32.
179          * Note that you should set/change/unset the window while playback is
180          * not started or stopped; live reparenting might not work.
181          */
182         public SafeHandle HWND
183         {
184             get
185             {
186                 return LibVLC.PlayerGetHWND (Handle);
187             }
188             set
189             {
190                 LibVLC.PlayerSetHWND (Handle, value, ex);
191                 Raise ();
192             }
193         }
194
195         /**
196          * Total length in microseconds of the playback (if known).
197          */
198         public long Length
199         {
200             get
201             {
202                 long ret = LibVLC.PlayerGetLength (Handle, ex);
203                 Raise ();
204                 return ret;
205             }
206         }
207
208         /**
209          * Playback position in microseconds from the start (if applicable).
210          * Setting this value might not work depending on the underlying
211          * media capability and file format.
212          *
213          * Changing the Time will also change the Position.
214          */
215         public long Time
216         {
217             get
218             {
219                 long ret = LibVLC.PlayerGetTime (Handle, ex);
220                 Raise ();
221                 return ret;
222             }
223             set
224             {
225                 LibVLC.PlayerSetTime (Handle, value, ex);
226                 Raise ();
227             }
228         }
229
230         /**
231          * Playback position as a fraction of the total (if applicable).
232          * Setting this value might not work depending on the underlying
233          * media capability and file format.
234          *
235          * Changing the Position will also change the Time.
236          */
237         public float Position
238         {
239             get
240             {
241                 float ret = LibVLC.PlayerGetPosition (Handle, ex);
242                 Raise ();
243                 return ret;
244             }
245             set
246             {
247                 LibVLC.PlayerSetPosition (Handle, value, ex);
248                 Raise ();
249             }
250         }
251
252         /**
253          * Number of the current chapter (within the current title).
254          * This is mostly used for DVDs and the likes.
255          */
256         public int Chapter
257         {
258             get
259             {
260                 int ret = LibVLC.PlayerGetChapter (Handle, ex);
261                 Raise ();
262                 return ret;
263             }
264             set
265             {
266                 LibVLC.PlayerSetChapter (Handle, value, ex);
267                 Raise ();
268             }
269         }
270
271         /**
272          * Number of chapters within the current title,
273          */
274         public int ChapterCount
275         {
276             get
277             {
278                 int ret = LibVLC.PlayerGetChapterCount (Handle, ex);
279                 Raise ();
280                 return ret;
281             }
282         }
283
284         /**
285          * Gets the number of chapters within a given title.
286          * @param title media title number
287          */
288         public int GetChapterCountByTitle (int title)
289         {
290             int ret = LibVLC.PlayerGetChapterCountForTitle (Handle, title, ex);
291             Raise ();
292             return ret;
293         }
294
295         /**
296          * Number of the current title.
297          */
298         public int Title
299         {
300             get
301             {
302                 int ret = LibVLC.PlayerGetTitle (Handle, ex);
303                 Raise ();
304                 return ret;
305             }
306             set
307             {
308                 LibVLC.PlayerSetTitle (Handle, value, ex);
309                 Raise ();
310             }
311         }
312
313         /**
314          * Total number of titles.
315          */
316         public int TitleCount
317         {
318             get
319             {
320                 int ret = LibVLC.PlayerGetTitleCount (Handle, ex);
321                 Raise ();
322                 return ret;
323             }
324         }
325
326         /**
327          * Skips to the beginning of the next chapter.
328          */
329         public void NextChapter ()
330         {
331             LibVLC.PlayerNextChapter (Handle, ex);
332             Raise ();
333         }
334
335         /**
336          * Rewinds to the previous chapter.
337          */
338         public void PreviousChapter ()
339         {
340             LibVLC.PlayerPreviousChapter (Handle, ex);
341             Raise ();
342         }
343
344         /**
345          * Media playback rate.
346          * 1.0 is the nominal rate.
347          * Less than one is slower than nominal.
348          * More than one is faster than nominal.
349          */
350         public float Rate
351         {
352             get
353             {
354                 float ret = LibVLC.PlayerGetRate (Handle, ex);
355                 Raise ();
356                 return ret;
357             }
358             set
359             {
360                 LibVLC.PlayerSetRate (Handle, value, ex);
361                 Raise ();
362             }
363         }
364
365         /**
366          * Frame rate in unit/seconds.
367          */
368         public float FramePerSeconds
369         {
370             get
371             {
372                 float ret = LibVLC.PlayerGetFPS (Handle, ex);
373                 Raise ();
374                 return ret;
375             }
376         }
377
378         /**
379          * Whether a video track is currently active.
380          * This is false if there is no video track, or if video is discarded.
381          */
382         public bool HasVideo
383         {
384             get
385             {
386                 int ret = LibVLC.PlayerHasVout (Handle, ex);
387                 Raise ();
388                 return ret != 0;
389             }
390         }
391
392         /**
393          * Whether the media supports seeking.
394          * Note that this tells nothing about the seeking precision.
395          */
396         public bool CanSeek
397         {
398             get
399             {
400                 int ret = LibVLC.PlayerIsSeekable (Handle, ex);
401                 Raise ();
402                 return ret != 0;
403             }
404         }
405
406         /**
407          * Whether the media supports pausing.
408          * Live content cannot be paused, unless timeshifting is enabled.
409          */
410         public bool CanPause
411         {
412             get
413             {
414                 int ret = LibVLC.PlayerCanPause (Handle, ex);
415                 Raise ();
416                 return ret != 0;
417             }
418         }
419     };
420 };