git.sesse.net Git - vlc/blob - src/control/mediacontrol_core.c

   1 /*****************************************************************************
   2  * core.c: Core functions : init, playlist, stream management
   3  *****************************************************************************
   4  * Copyright (C) 2005 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Olivier Aubert <olivier.aubert@liris.univ-lyon1.fr>
   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 <mediacontrol_internal.h>
  25 #include <vlc/mediacontrol.h>
  26
  27 #include <vlc/intf.h>
  28 #include <vlc/vout.h>
  29 #include <vlc/aout.h>
  30 #include <vlc_demux.h>
  31
  32 #include <vlc_osd.h>
  33
  34 #define HAS_SNAPSHOT 1
  35
  36 #ifdef HAS_SNAPSHOT
  37 #include <snapshot.h>
  38 #endif
  39
  40 #include <stdlib.h>                                      /* malloc(), free() */
  41 #include <string.h>
  42
  43 #include <errno.h>                                                 /* ENOMEM */
  44 #include <stdio.h>
  45 #include <ctype.h>
  46
  47 #ifdef HAVE_UNISTD_H
  48 #    include <unistd.h>
  49 #endif
  50 #ifdef HAVE_SYS_TIME_H
  51 #    include <sys/time.h>
  52 #endif
  53 #ifdef HAVE_SYS_TYPES_H
  54 #    include <sys/types.h>
  55 #endif
  56
  57 #define RAISE( c, m )  exception->code = c; \
  58                        exception->message = strdup(m);
  59
  60 mediacontrol_Instance* mediacontrol_new_from_object( int vlc_object_id,
  61                                                      mediacontrol_Exception *exception )
  62 {
  63     mediacontrol_Instance* retval = NULL;
  64     vlc_object_t *p_vlc;
  65     vlc_object_t *p_object;
  66
  67     p_object = ( vlc_object_t* )vlc_current_object( vlc_object_id );
  68     if( ! p_object )
  69     {
  70         RAISE( mediacontrol_InternalException, "unable to find vlc object" );
  71         return NULL;
  72     }
  73
  74     p_vlc = vlc_object_find( p_object, VLC_OBJECT_ROOT, FIND_PARENT );
  75     if( ! p_vlc )
  76     {
  77         RAISE( mediacontrol_InternalException, "unable to initialize VLC" );
  78         return NULL;
  79     }
  80     retval = ( mediacontrol_Instance* )malloc( sizeof( mediacontrol_Instance ) );
  81     retval->p_vlc = p_vlc;
  82     retval->vlc_object_id = p_vlc->i_object_id;
  83
  84     /* We can keep references on these, which should not change. Is it true ? */
  85     retval->p_playlist = vlc_object_find( p_vlc,
  86                                         VLC_OBJECT_PLAYLIST, FIND_ANYWHERE );
  87     retval->p_intf = vlc_object_find( p_vlc, VLC_OBJECT_INTF, FIND_ANYWHERE );
  88
  89     if( ! retval->p_playlist || ! retval->p_intf )
  90     {
  91         RAISE( mediacontrol_InternalException, "no interface available" );
  92         return NULL;
  93     }
  94     return retval;
  95 };
  96
  97
  98 /**************************************************************************
  99  * Playback management
 100  **************************************************************************/
 101 mediacontrol_Position*
 102 mediacontrol_get_media_position( mediacontrol_Instance *self,
 103                                  const mediacontrol_PositionOrigin an_origin,
 104                                  const mediacontrol_PositionKey a_key,
 105                                  mediacontrol_Exception *exception )
 106 {
 107     mediacontrol_Position* retval = NULL;
 108     vlc_value_t val;
 109     input_thread_t * p_input = self->p_playlist->p_input;
 110
 111     exception = mediacontrol_exception_init( exception );
 112
 113     retval = ( mediacontrol_Position* )malloc( sizeof( mediacontrol_Position ) );
 114     retval->origin = an_origin;
 115     retval->key = a_key;
 116
 117     if( ! p_input )
 118     {
 119         RAISE( mediacontrol_InternalException, "No input thread." );
 120         return NULL;
 121     }
 122
 123     if(  an_origin != mediacontrol_AbsolutePosition )
 124     {
 125         /* Relative or ModuloPosition make no sense */
 126         RAISE( mediacontrol_PositionOriginNotSupported,
 127                                         "Only absolute position is valid." );
 128         return NULL;
 129     }
 130
 131     /* We are asked for an AbsolutePosition. */
 132     val.i_time = 0;
 133     var_Get( p_input, "time", &val );
 134     /* FIXME: check val.i_time > 0 */
 135
 136     retval->value = mediacontrol_unit_convert( p_input,
 137                                                mediacontrol_MediaTime,
 138                                                a_key,
 139                                                val.i_time / 1000 );
 140     return retval;
 141 }
 142
 143 /* Sets the media position */
 144 void
 145 mediacontrol_set_media_position( mediacontrol_Instance *self,
 146                                  const mediacontrol_Position * a_position,
 147                                  mediacontrol_Exception *exception )
 148 {
 149     vlc_value_t val;
 150     input_thread_t * p_input = self->p_playlist->p_input;
 151
 152     exception=mediacontrol_exception_init( exception );
 153     if( ! p_input )
 154     {
 155         RAISE( mediacontrol_InternalException, "No input thread." );
 156     }
 157     else if( !var_GetBool( p_input, "seekable" ) )
 158     {
 159         RAISE( mediacontrol_InvalidPosition, "Stream not seekable" );
 160     }
 161     else
 162     {
 163         val.i_time = mediacontrol_position2microsecond( p_input, a_position );
 164         var_Set( p_input, "time", val );
 165     }
 166 }
 167
 168 /* Starts playing a stream */
 169 /*
 170  * Known issues: since moving in the playlist using playlist_Next
 171  * or playlist_Prev implies starting to play items, the a_position
 172  * argument will be only honored for the 1st item in the list.
 173  *
 174  * XXX:FIXME split moving in the playlist and playing items two
 175  * different actions or make playlist_<Next|Prev> accept a time
 176  * value to start to play from.
 177  */
 178 void
 179 mediacontrol_start( mediacontrol_Instance *self,
 180                     const mediacontrol_Position * a_position,
 181                     mediacontrol_Exception *exception )
 182 {
 183     playlist_t * p_playlist = self->p_playlist;
 184
 185     exception = mediacontrol_exception_init( exception );
 186     if( ! p_playlist )
 187     {
 188         RAISE( mediacontrol_PlaylistException, "No available playlist" );
 189         return;
 190     }
 191
 192     vlc_mutex_lock( &p_playlist->object_lock );
 193     if( p_playlist->i_size )
 194     {
 195         int i_from;
 196         char *psz_from = NULL;
 197
 198         psz_from = ( char * )malloc( 20 * sizeof( char ) );
 199         if( psz_from && p_playlist->status.p_item )
 200         {
 201             i_from = mediacontrol_position2microsecond( p_playlist->p_input, a_position ) / 1000000;
 202
 203             /* Set start time */
 204             snprintf( psz_from, 20, "start-time=%i", i_from );
 205             vlc_input_item_AddOption( p_playlist->status.p_item->p_input, psz_from );
 206             free( psz_from );
 207         }
 208
 209         vlc_mutex_unlock( &p_playlist->object_lock );
 210         playlist_Play( p_playlist );
 211     }
 212     else
 213     {
 214         RAISE( mediacontrol_PlaylistException, "Empty playlist." );
 215         vlc_mutex_unlock( &p_playlist->object_lock );
 216     }
 217 }
 218
 219 void
 220 mediacontrol_pause( mediacontrol_Instance *self,
 221                     const mediacontrol_Position * a_position,
 222                     mediacontrol_Exception *exception )
 223 {
 224     input_thread_t *p_input = self->p_playlist->p_input;
 225
 226     /* FIXME: use the a_position parameter */
 227     exception=mediacontrol_exception_init( exception );
 228     if( p_input != NULL )
 229     {
 230         var_SetInteger( p_input, "state", PAUSE_S );
 231     }
 232     else
 233     {
 234         RAISE( mediacontrol_InternalException, "No input" );
 235     }
 236 }
 237
 238 void
 239 mediacontrol_resume( mediacontrol_Instance *self,
 240                      const mediacontrol_Position * a_position,
 241                      mediacontrol_Exception *exception )
 242 {
 243     input_thread_t *p_input = self->p_playlist->p_input;
 244
 245     /* FIXME: use the a_position parameter */
 246     exception=mediacontrol_exception_init( exception );
 247     if( p_input != NULL )
 248     {
 249         var_SetInteger( p_input, "state", PAUSE_S );
 250     }
 251     else
 252     {
 253         RAISE( mediacontrol_InternalException, "No input" );
 254     }
 255 }
 256
 257 void
 258 mediacontrol_stop( mediacontrol_Instance *self,
 259                    const mediacontrol_Position * a_position,
 260                    mediacontrol_Exception *exception )
 261 {
 262     /* FIXME: use the a_position parameter */
 263     exception=mediacontrol_exception_init( exception );
 264     if( !self->p_playlist )
 265     {
 266         RAISE( mediacontrol_PlaylistException, "No playlist" );
 267     }
 268     else
 269         playlist_Stop( self->p_playlist );
 270 }
 271
 272 /**************************************************************************
 273  * Playlist management
 274  **************************************************************************/
 275
 276 void
 277 mediacontrol_playlist_add_item( mediacontrol_Instance *self,
 278                                 const char * psz_file,
 279                                 mediacontrol_Exception *exception )
 280 {
 281     exception=mediacontrol_exception_init( exception );
 282     if( !self->p_playlist )
 283     {
 284         RAISE( mediacontrol_InternalException, "No playlist" );
 285     }
 286     else
 287         playlist_PlaylistAdd( self->p_playlist, psz_file, psz_file , PLAYLIST_INSERT,
 288                       PLAYLIST_END );
 289 }
 290
 291 void
 292 mediacontrol_playlist_next_item( mediacontrol_Instance *self,
 293                                  mediacontrol_Exception *exception )
 294 {
 295     exception=mediacontrol_exception_init( exception );
 296     if ( !self->p_playlist )
 297     {
 298         RAISE( mediacontrol_InternalException, "No playlist" );
 299     }
 300     else
 301         playlist_Next( self->p_playlist );
 302 }
 303
 304 void
 305 mediacontrol_playlist_clear( mediacontrol_Instance *self,
 306                              mediacontrol_Exception *exception )
 307 {
 308     exception=mediacontrol_exception_init( exception );
 309     if( !self->p_playlist )
 310     {
 311         RAISE( mediacontrol_PlaylistException, "No playlist" );
 312     }
 313     else
 314         playlist_Clear( self->p_playlist );
 315 }
 316
 317 mediacontrol_PlaylistSeq *
 318 mediacontrol_playlist_get_list( mediacontrol_Instance *self,
 319                                 mediacontrol_Exception *exception )
 320 {
 321     mediacontrol_PlaylistSeq *retval = NULL;
 322     int i_index;
 323     playlist_t * p_playlist = self->p_playlist;
 324     int i_playlist_size;
 325
 326     exception=mediacontrol_exception_init( exception );
 327     if( !p_playlist )
 328     {
 329         RAISE( mediacontrol_PlaylistException, "No playlist" );
 330         return NULL;
 331     }
 332
 333     vlc_mutex_lock( &p_playlist->object_lock );
 334     i_playlist_size = p_playlist->i_size;
 335
 336     retval = mediacontrol_PlaylistSeq__alloc( i_playlist_size );
 337
 338     for( i_index = 0 ; i_index < i_playlist_size ; i_index++ )
 339     {
 340         retval->data[i_index] = strdup( p_playlist->pp_items[i_index]->p_input->psz_uri );
 341     }
 342     vlc_mutex_unlock( &p_playlist->object_lock );
 343
 344     return retval;
 345 }
 346
 347 /***************************************************************************
 348  * Status feedback
 349  ***************************************************************************/
 350
 351 mediacontrol_StreamInformation *
 352 mediacontrol_get_stream_information( mediacontrol_Instance *self,
 353                                      mediacontrol_PositionKey a_key,
 354                                      mediacontrol_Exception *exception )
 355 {
 356     mediacontrol_StreamInformation *retval = NULL;
 357     input_thread_t *p_input = self->p_playlist->p_input;
 358     vlc_value_t val;
 359
 360     retval = ( mediacontrol_StreamInformation* )
 361                             malloc( sizeof( mediacontrol_StreamInformation ) );
 362     if( ! retval )
 363     {
 364         RAISE( mediacontrol_InternalException, "Out of memory" );
 365         return NULL;
 366     }
 367
 368     if( ! p_input )
 369     {
 370         /* No p_input defined */
 371         retval->streamstatus = mediacontrol_UndefinedStatus;
 372         retval->url          = strdup( "None" );
 373         retval->position     = 0;
 374         retval->length       = 0;
 375     }
 376     else
 377     {
 378         switch( var_GetInteger( p_input, "state" ) )
 379         {
 380         case PLAYING_S     :
 381             retval->streamstatus = mediacontrol_PlayingStatus;
 382             break;
 383         case PAUSE_S       :
 384             retval->streamstatus = mediacontrol_PauseStatus;
 385             break;
 386         case INIT_S        :
 387             retval->streamstatus = mediacontrol_InitStatus;
 388             break;
 389         case END_S         :
 390             retval->streamstatus = mediacontrol_EndStatus;
 391             break;
 392         default :
 393             retval->streamstatus = mediacontrol_UndefinedStatus;
 394             break;
 395         }
 396
 397         retval->url = strdup( p_input->input.p_item->psz_uri );
 398
 399         /* TIME and LENGTH are in microseconds. We want them in ms */
 400         var_Get( p_input, "time", &val);
 401         retval->position = val.i_time / 1000;
 402
 403         var_Get( p_input, "length", &val);
 404         retval->length = val.i_time / 1000;
 405
 406         retval->position = mediacontrol_unit_convert( p_input,
 407                                          mediacontrol_MediaTime, a_key,
 408                                          retval->position );
 409         retval->length   = mediacontrol_unit_convert( p_input,
 410                                          mediacontrol_MediaTime, a_key,
 411                                          retval->length );
 412     }
 413     return retval;
 414 }