control/media_instance.c: Remove an unused variable. (Pointed by jb).
[vlc.git] / src / control / media_instance.c
1 /*****************************************************************************
2  * media_instance.c: Libvlc API Media Instance management functions
3  *****************************************************************************
4  * Copyright (C) 2005 the VideoLAN team
5  * $Id$
6  *
7  * Authors: ClĂ©ment Stenac <zorglub@videolan.org>
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22  *****************************************************************************/
23
24 #include <vlc/libvlc.h>
25 #include <vlc_demux.h>
26 #include <vlc_input.h>
27 #include "libvlc_internal.h"
28 #include "libvlc.h"
29
30 /*
31  * Release the associated input thread
32  *
33  * Object lock is NOT held.
34  */
35 static void release_input_thread( libvlc_media_instance_t *p_mi )
36 {
37     input_thread_t *p_input_thread;
38
39     if( !p_mi || p_mi->i_input_id == -1 )
40         return;
41
42     p_input_thread = (input_thread_t*)vlc_object_get(
43                                              p_mi->p_libvlc_instance->p_libvlc_int,
44                                              p_mi->i_input_id );
45
46     p_mi->i_input_id = -1;
47
48     if( !p_input_thread )
49         return;
50  
51     /* release for previous vlc_object_get */
52     vlc_object_release( p_input_thread );
53
54     /* release for initial p_input_thread yield (see _new()) */
55     vlc_object_release( p_input_thread );
56
57     /* No one is tracking this input_thread appart us. Destroy it */
58     if( p_mi->b_own_its_input_thread )
59     {
60         /* We owned this one */
61         input_StopThread( p_input_thread );
62         var_Destroy( p_input_thread, "drawable" );
63         input_DestroyThread( p_input_thread );
64     }
65     else
66     {
67         /* XXX: hack the playlist doesn't retain the input thread,
68          * so we did it for the playlist (see _new_from_input_thread),
69          * revert that here. This will be deleted with the playlist API */
70         vlc_object_release( p_input_thread );
71     }
72 }
73
74 /*
75  * Retrieve the input thread. Be sure to release the object
76  * once you are done with it. (libvlc Internal)
77  *
78  * Object lock is held.
79  */
80 input_thread_t *libvlc_get_input_thread( libvlc_media_instance_t *p_mi,
81                                          libvlc_exception_t *p_e )
82 {
83     input_thread_t *p_input_thread;
84
85     vlc_mutex_lock( &p_mi->object_lock );
86
87     if( !p_mi || p_mi->i_input_id == -1 )
88     {
89         vlc_mutex_unlock( &p_mi->object_lock );
90         RAISENULL( "Input is NULL" );
91     }
92
93     p_input_thread = (input_thread_t*)vlc_object_get(
94                                              p_mi->p_libvlc_instance->p_libvlc_int,
95                                              p_mi->i_input_id );
96     if( !p_input_thread )
97     {
98         vlc_mutex_unlock( &p_mi->object_lock );
99         RAISENULL( "Input does not exist" );
100     }
101
102     vlc_mutex_unlock( &p_mi->object_lock );
103     return p_input_thread;
104 }
105
106 /*
107  * input_state_changed (Private) (input var "state" Callback)
108  */
109 static int
110 input_state_changed( vlc_object_t * p_this, char const * psz_cmd,
111                      vlc_value_t oldval, vlc_value_t newval,
112                      void * p_userdata )
113 {
114     libvlc_media_instance_t * p_mi = p_userdata;
115     libvlc_event_t event;
116
117     if( newval.i_int == oldval.i_int )
118         return VLC_SUCCESS; /* No change since last time, don't propagate */
119
120     switch ( newval.i_int )
121     {
122         case END_S:
123             event.type = libvlc_MediaInstanceReachedEnd;
124             break;
125         case PAUSE_S:
126             event.type = libvlc_MediaInstancePaused;
127             break;
128         case PLAYING_S:
129             event.type = libvlc_MediaInstancePlayed;
130             break;
131         default:
132             return VLC_SUCCESS;
133     }
134
135     libvlc_event_send( p_mi->p_event_manager, &event );
136     return VLC_SUCCESS;
137 }
138
139 /*
140  * input_position_changed (Private) (input var "intf-change" Callback)
141  */
142 static int
143 input_position_changed( vlc_object_t * p_this, char const * psz_cmd,
144                      vlc_value_t oldval, vlc_value_t newval,
145                      void * p_userdata )
146 {
147     libvlc_media_instance_t * p_mi = p_userdata;
148     vlc_value_t val;
149  
150     if (!strcmp(psz_cmd, "intf" /* "-change" no need to go further */))
151     {
152         input_thread_t * p_input = (input_thread_t *)p_this;
153         var_Get( p_input, "position", &val );
154
155         if ((val.i_time % I64C(500000)) != 0)
156             return VLC_SUCCESS; /* No need to have a better precision */
157         var_Get( p_input, "state", &val );
158
159         if( val.i_int != PLAYING_S )
160             return VLC_SUCCESS; /* Don't send the position while stopped */
161     }
162     else
163         val.i_time = newval.i_time;
164
165     libvlc_event_t event;
166     event.type = libvlc_MediaInstancePositionChanged;
167     event.u.media_instance_position_changed.new_position = val.i_time;
168
169     libvlc_event_send( p_mi->p_event_manager, &event );
170     return VLC_SUCCESS;
171 }
172
173 /**************************************************************************
174  * Create a Media Instance object
175  **************************************************************************/
176 libvlc_media_instance_t *
177 libvlc_media_instance_new( libvlc_instance_t * p_libvlc_instance,
178                            libvlc_exception_t * p_e )
179 {
180     libvlc_media_instance_t * p_mi;
181
182     if( !p_libvlc_instance )
183     {
184         libvlc_exception_raise( p_e, "invalid libvlc instance" );
185         return NULL;
186     }
187
188     p_mi = malloc( sizeof(libvlc_media_instance_t) );
189     p_mi->p_md = NULL;
190     p_mi->drawable = 0;
191     p_mi->p_libvlc_instance = p_libvlc_instance;
192     p_mi->i_input_id = -1;
193     /* refcount strategy:
194      * - All items created by _new start with a refcount set to 1
195      * - Accessor _release decrease the refcount by 1, if after that
196      *   operation the refcount is 0, the object is destroyed.
197      * - Accessor _retain increase the refcount by 1 (XXX: to implement) */
198     p_mi->i_refcount = 1;
199     p_mi->b_own_its_input_thread = VLC_TRUE;
200     /* object_lock strategy:
201      * - No lock held in constructor
202      * - Lock when accessing all variable this lock is held
203      * - Lock when attempting to destroy the object the lock is also held */
204     vlc_mutex_init( p_mi->p_libvlc_instance->p_libvlc_int,
205                     &p_mi->object_lock );
206     p_mi->p_event_manager = libvlc_event_manager_new( p_mi,
207             p_libvlc_instance, p_e );
208     if( libvlc_exception_raised( p_e ) )
209     {
210         free( p_mi );
211         return NULL;
212     }
213  
214     libvlc_event_manager_register_event_type( p_mi->p_event_manager,
215             libvlc_MediaInstanceReachedEnd, p_e );
216     libvlc_event_manager_register_event_type( p_mi->p_event_manager,
217             libvlc_MediaInstancePaused, p_e );
218     libvlc_event_manager_register_event_type( p_mi->p_event_manager,
219             libvlc_MediaInstancePlayed, p_e );
220     libvlc_event_manager_register_event_type( p_mi->p_event_manager,
221             libvlc_MediaInstancePositionChanged, p_e );
222
223     return p_mi;
224 }
225
226 /**************************************************************************
227  * Create a Media Instance object with a media descriptor
228  **************************************************************************/
229 libvlc_media_instance_t *
230 libvlc_media_instance_new_from_media_descriptor(
231                                     libvlc_media_descriptor_t * p_md,
232                                     libvlc_exception_t *p_e )
233 {
234     libvlc_media_instance_t * p_mi;
235     p_mi = libvlc_media_instance_new( p_md->p_libvlc_instance, p_e );
236
237     if( !p_mi )
238         return NULL;
239
240     libvlc_media_descriptor_retain( p_md );
241     p_mi->p_md = p_md;
242
243     return p_mi;
244 }
245
246 /**************************************************************************
247  * Create a new media instance object from an input_thread (Libvlc Internal)
248  **************************************************************************/
249 libvlc_media_instance_t * libvlc_media_instance_new_from_input_thread(
250                                    struct libvlc_instance_t *p_libvlc_instance,
251                                    input_thread_t *p_input,
252                                    libvlc_exception_t *p_e )
253 {
254     libvlc_media_instance_t * p_mi;
255
256     if( !p_input )
257     {
258         libvlc_exception_raise( p_e, "invalid input thread" );
259         return NULL;
260     }
261
262     p_mi = libvlc_media_instance_new( p_libvlc_instance, p_e );
263
264     if( !p_mi )
265         return NULL;
266
267     p_mi->p_md = libvlc_media_descriptor_new_from_input_item(
268                     p_libvlc_instance,
269                     input_GetItem( p_input ), p_e );
270
271     if( !p_mi->p_md )
272     {
273         libvlc_media_instance_destroy( p_mi );
274         return NULL;
275     }
276
277     p_mi->i_input_id = p_input->i_object_id;
278     p_mi->b_own_its_input_thread = VLC_FALSE;
279
280     /* will be released in media_instance_release() */
281     vlc_object_yield( p_input );
282
283     /* XXX: Hack as the playlist doesn't yield the input thread we retain
284      * the input for the playlist. (see corresponding hack in _release) */
285     vlc_object_yield( p_input );
286
287     return p_mi;
288 }
289
290 /**************************************************************************
291  * Destroy a Media Instance object (libvlc internal)
292  *
293  * Warning: No lock held here, but hey, this is internal.
294  **************************************************************************/
295 void libvlc_media_instance_destroy( libvlc_media_instance_t *p_mi )
296 {
297     input_thread_t *p_input_thread;
298     libvlc_exception_t p_e;
299
300     libvlc_exception_init( &p_e );
301
302     if( !p_mi )
303         return;
304
305     p_input_thread = libvlc_get_input_thread( p_mi, &p_e );
306
307     if( libvlc_exception_raised( &p_e ) )
308     {
309         libvlc_event_manager_release( p_mi->p_event_manager );
310         free( p_mi );
311         return; /* no need to worry about no input thread */
312     }
313     vlc_mutex_destroy( &p_mi->object_lock );
314
315     input_DestroyThread( p_input_thread );
316
317     libvlc_media_descriptor_release( p_mi->p_md );
318
319     free( p_mi );
320 }
321
322 /**************************************************************************
323  * Release a Media Instance object
324  **************************************************************************/
325 void libvlc_media_instance_release( libvlc_media_instance_t *p_mi )
326 {
327     if( !p_mi )
328         return;
329
330     vlc_mutex_lock( &p_mi->object_lock );
331  
332     p_mi->i_refcount--;
333
334     if( p_mi->i_refcount > 0 )
335     {
336         vlc_mutex_unlock( &p_mi->object_lock );
337         return;
338     }
339     vlc_mutex_unlock( &p_mi->object_lock );
340     vlc_mutex_destroy( &p_mi->object_lock );
341
342     release_input_thread( p_mi );
343
344     libvlc_event_manager_release( p_mi->p_event_manager );
345  
346     libvlc_media_descriptor_release( p_mi->p_md );
347
348     free( p_mi );
349 }
350
351 /**************************************************************************
352  * Retain a Media Instance object
353  **************************************************************************/
354 void libvlc_media_instance_retain( libvlc_media_instance_t *p_mi )
355 {
356     if( !p_mi )
357         return;
358
359     p_mi->i_refcount++;
360 }
361
362 /**************************************************************************
363  * Set the Media descriptor associated with the instance
364  **************************************************************************/
365 void libvlc_media_instance_set_media_descriptor(
366                             libvlc_media_instance_t *p_mi,
367                             libvlc_media_descriptor_t *p_md,
368                             libvlc_exception_t *p_e )
369 {
370     (void)p_e;
371
372     if( !p_mi )
373         return;
374
375     vlc_mutex_lock( &p_mi->object_lock );
376
377     release_input_thread( p_mi );
378
379     libvlc_media_descriptor_release( p_mi->p_md );
380
381     if( !p_md )
382     {
383         p_mi->p_md = NULL;
384         vlc_mutex_unlock( &p_mi->object_lock );
385         return; /* It is ok to pass a NULL md */
386     }
387
388     libvlc_media_descriptor_retain( p_md );
389     p_mi->p_md = p_md;
390  
391     /* The policy here is to ignore that we were created using a different
392      * libvlc_instance, because we don't really care */
393     p_mi->p_libvlc_instance = p_md->p_libvlc_instance;
394
395     vlc_mutex_unlock( &p_mi->object_lock );
396 }
397
398 /**************************************************************************
399  * Get the Media descriptor associated with the instance
400  **************************************************************************/
401 libvlc_media_descriptor_t *
402 libvlc_media_instance_get_media_descriptor(
403                             libvlc_media_instance_t *p_mi,
404                             libvlc_exception_t *p_e )
405 {
406     (void)p_e;
407
408     if( !p_mi->p_md )
409         return NULL;
410
411     libvlc_media_descriptor_retain( p_mi->p_md );
412     return p_mi->p_md;
413 }
414
415 /**************************************************************************
416  * Get the event Manager
417  **************************************************************************/
418 libvlc_event_manager_t *
419 libvlc_media_instance_event_manager(
420                             libvlc_media_instance_t *p_mi,
421                             libvlc_exception_t *p_e )
422 {
423     (void)p_e;
424
425     return p_mi->p_event_manager;
426 }
427
428 /**************************************************************************
429  * Play
430  **************************************************************************/
431 void libvlc_media_instance_play( libvlc_media_instance_t *p_mi,
432                                  libvlc_exception_t *p_e )
433 {
434     input_thread_t * p_input_thread;
435
436     if( (p_input_thread = libvlc_get_input_thread( p_mi, p_e )) )
437     {
438         /* A thread alread exists, send it a play message */
439         input_Control( p_input_thread, INPUT_SET_STATE, PLAYING_S );
440         vlc_object_release( p_input_thread );
441         return;
442     }
443
444     /* Ignore previous exception */
445     libvlc_exception_clear( p_e );
446
447     vlc_mutex_lock( &p_mi->object_lock );
448  
449     if( !p_mi->p_md )
450     {
451         libvlc_exception_raise( p_e, "no associated media descriptor" );
452         vlc_mutex_unlock( &p_mi->object_lock );
453         return;
454     }
455
456     p_input_thread = input_CreateThread( p_mi->p_libvlc_instance->p_libvlc_int,
457                                          p_mi->p_md->p_input_item );
458     p_mi->i_input_id = p_input_thread->i_object_id;
459
460     if( p_mi->drawable )
461     {
462         vlc_value_t val;
463         val.i_int = p_mi->drawable;
464         var_Create( p_input_thread, "drawable", VLC_VAR_DOINHERIT );
465         var_Set( p_input_thread, "drawable", val );
466     }
467     var_AddCallback( p_input_thread, "state", input_state_changed, p_mi );
468     var_AddCallback( p_input_thread, "intf-change", input_position_changed, p_mi );
469
470     /* will be released in media_instance_release() */
471     vlc_object_yield( p_input_thread );
472
473     vlc_mutex_unlock( &p_mi->object_lock );
474 }
475
476 /**************************************************************************
477  * Pause
478  **************************************************************************/
479 void libvlc_media_instance_pause( libvlc_media_instance_t *p_mi,
480                                   libvlc_exception_t *p_e )
481 {
482     input_thread_t * p_input_thread = libvlc_get_input_thread( p_mi, p_e );
483
484     if( !p_input_thread )
485         return;
486
487     input_Control( p_input_thread, INPUT_SET_STATE, PAUSE_S );
488     vlc_object_release( p_input_thread );
489 }
490
491 /**************************************************************************
492  * Stop
493  **************************************************************************/
494 void libvlc_media_instance_stop( libvlc_media_instance_t *p_mi,
495                                  libvlc_exception_t *p_e )
496 {
497     //libvlc_exception_raise( p_e, "Not implemented" );
498 }
499
500 /**************************************************************************
501  * Set Drawable
502  **************************************************************************/
503 void libvlc_media_instance_set_drawable( libvlc_media_instance_t *p_mi,
504                                          libvlc_drawable_t drawable,
505                                          libvlc_exception_t *p_e )
506 {
507     p_mi->drawable = drawable;
508 }
509
510 /**************************************************************************
511  * Getters for stream information
512  **************************************************************************/
513 vlc_int64_t libvlc_media_instance_get_length(
514                              libvlc_media_instance_t *p_mi,
515                              libvlc_exception_t *p_e )
516 {
517     input_thread_t *p_input_thread;
518     vlc_value_t val;
519
520     p_input_thread = libvlc_get_input_thread ( p_mi, p_e);
521     if( !p_input_thread )
522         return -1;
523
524     var_Get( p_input_thread, "length", &val );
525     vlc_object_release( p_input_thread );
526
527     return (val.i_time+500LL)/1000LL;
528 }
529
530 vlc_int64_t libvlc_media_instance_get_time(
531                                    libvlc_media_instance_t *p_mi,
532                                    libvlc_exception_t *p_e )
533 {
534     input_thread_t *p_input_thread;
535     vlc_value_t val;
536
537     p_input_thread = libvlc_get_input_thread ( p_mi, p_e );
538     if( !p_input_thread )
539         return -1;
540
541     var_Get( p_input_thread , "time", &val );
542     vlc_object_release( p_input_thread );
543     return (val.i_time+500LL)/1000LL;
544 }
545
546 void libvlc_media_instance_set_time(
547                                  libvlc_media_instance_t *p_mi,
548                                  vlc_int64_t time,
549                                  libvlc_exception_t *p_e )
550 {
551     input_thread_t *p_input_thread;
552     vlc_value_t value;
553
554     p_input_thread = libvlc_get_input_thread ( p_mi, p_e );
555     if( !p_input_thread )
556         return;
557
558     value.i_time = time*1000LL;
559     var_Set( p_input_thread, "time", value );
560     vlc_object_release( p_input_thread );
561 }
562
563 void libvlc_media_instance_set_position(
564                                 libvlc_media_instance_t *p_mi,
565                                 float position,
566                                 libvlc_exception_t *p_e )
567 {
568     input_thread_t *p_input_thread;
569     vlc_value_t val;
570     val.f_float = position;
571
572     p_input_thread = libvlc_get_input_thread ( p_mi, p_e);
573     if( !p_input_thread )
574         return;
575
576     var_Set( p_input_thread, "position", val );
577     vlc_object_release( p_input_thread );
578 }
579
580 float libvlc_media_instance_get_position(
581                                  libvlc_media_instance_t *p_mi,
582                                  libvlc_exception_t *p_e )
583 {
584     input_thread_t *p_input_thread;
585     vlc_value_t val;
586
587     p_input_thread = libvlc_get_input_thread ( p_mi, p_e );
588     if( !p_input_thread )
589         return -1.0;
590
591     var_Get( p_input_thread, "position", &val );
592     vlc_object_release( p_input_thread );
593
594     return val.f_float;
595 }
596
597 float libvlc_media_instance_get_fps(
598                                  libvlc_media_instance_t *p_mi,
599                                  libvlc_exception_t *p_e)
600 {
601     input_thread_t *p_input_thread = libvlc_get_input_thread ( p_mi, p_e );
602     double f_fps = 0.0;
603
604     if( p_input_thread )
605     {
606         if( input_Control( p_input_thread, INPUT_GET_VIDEO_FPS, &f_fps ) )
607             f_fps = 0.0;
608         vlc_object_release( p_input_thread );
609     }
610     return f_fps;
611 }
612
613 vlc_bool_t libvlc_media_instance_will_play(
614                                  libvlc_media_instance_t *p_mi,
615                                  libvlc_exception_t *p_e)
616 {
617     input_thread_t *p_input_thread =
618                             libvlc_get_input_thread ( p_mi, p_e);
619     if ( !p_input_thread )
620         return VLC_FALSE;
621
622     if ( !p_input_thread->b_die && !p_input_thread->b_dead )
623     {
624         vlc_object_release( p_input_thread );
625         return VLC_TRUE;
626     }
627     vlc_object_release( p_input_thread );
628     return VLC_FALSE;
629 }
630
631 void libvlc_media_instance_set_rate(
632                                  libvlc_media_instance_t *p_mi,
633                                  float rate,
634                                  libvlc_exception_t *p_e )
635 {
636     input_thread_t *p_input_thread;
637     vlc_value_t val;
638
639     if( rate <= 0 )
640         RAISEVOID( "Rate value is invalid" );
641
642     val.i_int = 1000.0f/rate;
643
644     p_input_thread = libvlc_get_input_thread ( p_mi, p_e);
645     if ( !p_input_thread )
646         return;
647
648     var_Set( p_input_thread, "rate", val );
649     vlc_object_release( p_input_thread );
650 }
651
652 float libvlc_media_instance_get_rate(
653                                  libvlc_media_instance_t *p_mi,
654                                  libvlc_exception_t *p_e )
655 {
656     input_thread_t *p_input_thread;
657     vlc_value_t val;
658
659     p_input_thread = libvlc_get_input_thread ( p_mi, p_e);
660     if ( !p_input_thread )
661         return -1.0;
662
663     var_Get( p_input_thread, "rate", &val );
664     vlc_object_release( p_input_thread );
665
666     return (float)1000.0f/val.i_int;
667 }
668
669 static libvlc_state_t vlc_to_libvlc_state[] =
670 {
671     [INIT_S]        = libvlc_Opening,
672     [OPENING_S]     = libvlc_Opening,
673     [BUFFERING_S]   = libvlc_Buffering,    
674     [PLAYING_S]     = libvlc_Playing,    
675     [PAUSE_S]       = libvlc_Paused,    
676     [END_S]         = libvlc_Ended,    
677     [ERROR_S]       = libvlc_Error,    
678 };
679
680 libvlc_state_t libvlc_media_instance_get_state(
681                                  libvlc_media_instance_t *p_mi,
682                                  libvlc_exception_t *p_e )
683 {
684     input_thread_t *p_input_thread;
685     vlc_value_t val;
686
687     p_input_thread = libvlc_get_input_thread ( p_mi, p_e );
688     if ( !p_input_thread )
689         return libvlc_Stopped;
690
691     var_Get( p_input_thread, "state", &val );
692     vlc_object_release( p_input_thread );
693
694     if( val.i_int < 0 || val.i_int > 6 )
695         return libvlc_Stopped;
696
697     return vlc_to_libvlc_state[val.i_int];
698 }