]> git.sesse.net Git - vlc/blobdiff - src/control/core.c
Revert "Remove libvlc_free"
[vlc] / src / control / core.c
index 202bf54be910e7012868764e79dfd3b9438935e8..745c85af64a27b39ec8986d25912684ba8a73cff 100644 (file)
@@ -1,10 +1,10 @@
 /*****************************************************************************
- * core.c: Core functions : init, playlist, stream management
+ * core.c: Core libvlc new API functions : initialization
  *****************************************************************************
- * Copyright (C) 2005 VideoLAN
- * $Id: vlc.c 10786 2005-04-23 23:19:17Z zorglub $
+ * Copyright (C) 2005 the VideoLAN team
+ * $Id$
  *
- * Authors: Olivier Aubert <olivier.aubert@liris.univ-lyon1.fr>
+ * Authors: ClĂ©ment Stenac <zorglub@videolan.org>
  *
  * 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
  *
  * 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., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  *****************************************************************************/
 
-#include <vlc/control.h>
-
-#include <vlc/intf.h>
-#include <vlc/vout.h>
-#include <vlc/aout.h>
-#include <vlc_demux.h>
-
-#include <osd.h>
-
-#define HAS_SNAPSHOT 1
-
-#ifdef HAS_SNAPSHOT
-#include <snapshot.h>
+#ifdef HAVE_CONFIG_H
+# include "config.h"
 #endif
 
-#include <stdlib.h>                                      /* malloc(), free() */
-#include <string.h>
+#include "libvlc_internal.h"
+#include <vlc/libvlc.h>
 
-#include <errno.h>                                                 /* ENOMEM */
-#include <stdio.h>
-#include <ctype.h>
+#include <vlc_interface.h>
+#include <vlc_vlm.h>
 
-#ifdef HAVE_UNISTD_H
-#    include <unistd.h>
-#endif
+#include <stdarg.h>
+#include <limits.h>
+#include <assert.h>
 
-#ifdef HAVE_SYS_TIME_H
-#    include <sys/time.h>
-#endif
-#include <sys/types.h>
+static const char nomemstr[] = "Insufficient memory";
 
-#define RAISE( c, m )  exception->code = c; \
-                       exception->message = strdup(m);
-
-
-mediacontrol_Instance* mediacontrol_new_from_object( vlc_object_t* p_object,
-                                                     mediacontrol_Exception *exception )
+libvlc_instance_t * libvlc_new( int argc, const char *const *argv )
 {
-    mediacontrol_Instance* retval;
-    vlc_object_t *p_vlc;
-
-    p_vlc = vlc_object_find( p_object, VLC_OBJECT_ROOT, FIND_PARENT );
-    if( ! p_vlc )
-    {
-        RAISE( mediacontrol_InternalException, "Unable to initialize VLC" );
+    libvlc_instance_t *p_new = malloc (sizeof (*p_new));
+    if (unlikely(p_new == NULL))
         return NULL;
-    }
-    retval = ( mediacontrol_Instance* )malloc( sizeof( mediacontrol_Instance ) );
-    retval->p_vlc = p_vlc;
-    retval->vlc_object_id = p_vlc->i_object_id;
 
-    /* We can keep references on these, which should not change. Is it true ? */
-    retval->p_playlist = vlc_object_find( p_vlc, VLC_OBJECT_PLAYLIST, FIND_ANYWHERE );
-    retval->p_intf = vlc_object_find( p_vlc, VLC_OBJECT_INTF, FIND_ANYWHERE );
+    libvlc_init_threads ();
 
-    if( ! retval->p_playlist || ! retval->p_intf )
-    {
-        RAISE( mediacontrol_InternalException, "No available interface" );
-        return NULL;
-    }
-    return retval;
-};
-
-
-/**************************************************************************
- * Playback management
- **************************************************************************/
-mediacontrol_Position*
-mediacontrol_get_media_position( mediacontrol_Instance *self,
-                                 const mediacontrol_PositionOrigin an_origin,
-                                 const mediacontrol_PositionKey a_key,
-                                 mediacontrol_Exception *exception )
-{
-    mediacontrol_Position* retval;
-    vlc_value_t val;
-    input_thread_t * p_input = self->p_playlist->p_input;
-
-    exception = mediacontrol_exception_init( exception );
-
-    retval = ( mediacontrol_Position* )malloc( sizeof( mediacontrol_Position ) );
-    retval->origin = an_origin;
-    retval->key = a_key;
+    const char *my_argv[argc + 2];
+    my_argv[0] = "libvlc"; /* dummy arg0, skipped by getopt() et al */
+    for( int i = 0; i < argc; i++ )
+         my_argv[i + 1] = argv[i];
+    my_argv[argc + 1] = NULL; /* C calling conventions require a NULL */
 
-    if( ! p_input )
-    {
-        /*
-           RAISE( mediacontrol_InternalException, "No input thread." );
-           return( NULL );
-        */
-        retval->value = 0;
-        return retval;
-    }
+    libvlc_int_t *p_libvlc_int = libvlc_InternalCreate();
+    if (unlikely (p_libvlc_int == NULL))
+        goto error;
 
-    if(  an_origin == mediacontrol_RelativePosition
-         || an_origin == mediacontrol_ModuloPosition )
+    if (libvlc_InternalInit( p_libvlc_int, argc + 1, my_argv ))
     {
-        /* Relative or ModuloPosition make no sense */
-        retval->value = 0;
-        return retval;
+        libvlc_InternalDestroy( p_libvlc_int );
+        goto error;
     }
 
-    /* We are asked for an AbsolutePosition. */
-    val.i_time = 0;
-    var_Get( p_input, "time", &val );
-    /* FIXME: check val.i_time > 0 */
+    p_new->p_libvlc_int = p_libvlc_int;
+    p_new->libvlc_vlm.p_vlm = NULL;
+    p_new->libvlc_vlm.p_event_manager = NULL;
+    p_new->libvlc_vlm.pf_release = NULL;
+    p_new->ref_count = 1;
+    p_new->verbosity = 1;
+    p_new->p_callback_list = NULL;
+    vlc_mutex_init(&p_new->instance_lock);
+    var_Create( p_libvlc_int, "http-user-agent",
+                VLC_VAR_STRING|VLC_VAR_DOINHERIT );
+    return p_new;
 
-    retval->value = mediacontrol_unit_convert( p_input,
-                                               mediacontrol_MediaTime,
-                                               a_key,
-                                               val.i_time / 1000 );
-    return retval;
+error:
+    libvlc_deinit_threads ();
+    free (p_new);
+    return NULL;
 }
 
-/* Sets the media position */
-void
-mediacontrol_set_media_position( mediacontrol_Instance *self,
-                                 const mediacontrol_Position * a_position,
-                                 mediacontrol_Exception *exception )
+void libvlc_retain( libvlc_instance_t *p_instance )
 {
-    vlc_value_t val;
-    input_thread_t * p_input = self->p_playlist->p_input;
+    assert( p_instance != NULL );
+    assert( p_instance->ref_count < UINT_MAX );
 
-    exception=mediacontrol_exception_init( exception );
-    if( ! p_input )
-    {
-        RAISE( mediacontrol_InternalException, "No input thread." );
-        return;
-    }
-
-    if( !var_GetBool( p_input, "seekable" ) )
-    {
-        RAISE( mediacontrol_InvalidPosition, "Stream not seekable" );
-        return;
-    }
-
-    val.i_time = mediacontrol_position2microsecond( p_input, a_position );
-    var_Set( p_input, "time", val );
-    return;
+    vlc_mutex_lock( &p_instance->instance_lock );
+    p_instance->ref_count++;
+    vlc_mutex_unlock( &p_instance->instance_lock );
 }
 
-/* Starts playing a stream */
-void
-mediacontrol_start( mediacontrol_Instance *self,
-                    const mediacontrol_Position * a_position,
-                    mediacontrol_Exception *exception )
+void libvlc_release( libvlc_instance_t *p_instance )
 {
-    playlist_t * p_playlist = self->p_playlist;
-
-    exception = mediacontrol_exception_init( exception );
-    if( ! p_playlist )
-    {
-        RAISE( mediacontrol_PlaylistException, "No available playlist" );
-        return;
-    }
-
-    vlc_mutex_lock( &p_playlist->object_lock );
-    if( p_playlist->i_size )
-    {
-        vlc_value_t val;
-
-        vlc_mutex_unlock( &p_playlist->object_lock );
+    vlc_mutex_t *lock = &p_instance->instance_lock;
+    int refs;
 
-        /* Set start time */
-        val.i_int = mediacontrol_position2microsecond( p_playlist->p_input, a_position ) / 1000000;
-        var_Set( p_playlist, "start-time", val );
+    vlc_mutex_lock( lock );
+    assert( p_instance->ref_count > 0 );
+    refs = --p_instance->ref_count;
+    vlc_mutex_unlock( lock );
 
-        playlist_Play( p_playlist );
-    }
-    else
+    if( refs == 0 )
     {
-        RAISE( mediacontrol_PlaylistException, "Empty playlist." );
-        vlc_mutex_unlock( &p_playlist->object_lock );
-        return;
+        vlc_mutex_destroy( lock );
+        if( p_instance->libvlc_vlm.pf_release )
+            p_instance->libvlc_vlm.pf_release( p_instance );
+        libvlc_InternalCleanup( p_instance->p_libvlc_int );
+        libvlc_InternalDestroy( p_instance->p_libvlc_int );
+        free( p_instance );
+        libvlc_deinit_threads ();
     }
-
-    return;
 }
 
-void
-mediacontrol_pause( mediacontrol_Instance *self,
-                    const mediacontrol_Position * a_position,
-                    mediacontrol_Exception *exception )
+int libvlc_add_intf( libvlc_instance_t *p_i, const char *name )
 {
-    input_thread_t *p_input = self->p_playlist->p_input;;
-
-    /* FIXME: use the a_position parameter */
-    exception=mediacontrol_exception_init( exception );
-    if( p_input != NULL )
-    {
-        var_SetInteger( p_input, "state", PAUSE_S );
-    }
-    else
-    {
-        RAISE( mediacontrol_InternalException, "No input" );
-    }
-
-    return;
+    return libvlc_InternalAddIntf( p_i->p_libvlc_int, name ) ? -1 : 0;
 }
 
-void
-mediacontrol_resume( mediacontrol_Instance *self,
-                     const mediacontrol_Position * a_position,
-                     mediacontrol_Exception *exception )
+void libvlc_set_exit_handler( libvlc_instance_t *p_i, void (*cb) (void *),
+                              void *data )
 {
-    input_thread_t *p_input = self->p_playlist->p_input;
-
-    /* FIXME: use the a_position parameter */
-    exception=mediacontrol_exception_init( exception );
-    if( p_input != NULL )
-    {
-        var_SetInteger( p_input, "state", PAUSE_S );
-    }
-    else
-    {
-        RAISE( mediacontrol_InternalException, "No input" );
-    }
+    libvlc_int_t *p_libvlc = p_i->p_libvlc_int;
+    libvlc_SetExitHandler( p_libvlc, cb, data );
 }
 
-void
-mediacontrol_stop( mediacontrol_Instance *self,
-                   const mediacontrol_Position * a_position,
-                   mediacontrol_Exception *exception )
+void libvlc_wait( libvlc_instance_t *p_i )
 {
-    /* FIXME: use the a_position parameter */
-    exception=mediacontrol_exception_init( exception );
-    if( !self->p_playlist )
-    {
-        RAISE( mediacontrol_PlaylistException, "No playlist" );
-        return;
-    }
-
-    playlist_Stop( self->p_playlist );
+    libvlc_int_t *p_libvlc = p_i->p_libvlc_int;
+    libvlc_InternalWait( p_libvlc );
 }
 
-/**************************************************************************
- * Playlist management
- **************************************************************************/
-
-void
-mediacontrol_playlist_add_item( mediacontrol_Instance *self,
-                                const char * psz_file,
-                                mediacontrol_Exception *exception )
+void libvlc_set_user_agent (libvlc_instance_t *p_i,
+                            const char *name, const char *http)
 {
-    exception=mediacontrol_exception_init( exception );
-    if( !self->p_playlist )
+    libvlc_int_t *p_libvlc = p_i->p_libvlc_int;
+    char *str;
+
+    var_SetString (p_libvlc, "user-agent", name);
+    if ((http != NULL)
+     && (asprintf (&str, "%s LibVLC/"PACKAGE_VERSION, http) != -1))
     {
-        RAISE( mediacontrol_InternalException, "No playlist" );
-        return;
+        var_SetString (p_libvlc, "http-user-agent", str);
+        free (str);
     }
-
-    playlist_Add( self->p_playlist, psz_file, psz_file , PLAYLIST_REPLACE, 0 );
 }
 
-void
-mediacontrol_playlist_clear( mediacontrol_Instance *self,
-                             mediacontrol_Exception *exception )
+const char * libvlc_get_version(void)
 {
-    exception=mediacontrol_exception_init( exception );
-    if( !self->p_playlist )
-    {
-        RAISE( mediacontrol_PlaylistException, "No playlist" );
-        return;
-    }
-
-    playlist_Clear( self->p_playlist );
-
-    return;
+    return VLC_Version();
 }
 
-mediacontrol_PlaylistSeq *
-mediacontrol_playlist_get_list( mediacontrol_Instance *self,
-                                mediacontrol_Exception *exception )
+const char * libvlc_get_compiler(void)
 {
-    mediacontrol_PlaylistSeq *retval;
-    int i_index;
-    playlist_t * p_playlist = self->p_playlist;;
-    int i_playlist_size;
-
-    exception=mediacontrol_exception_init( exception );
-    if( !p_playlist )
-    {
-        RAISE( mediacontrol_PlaylistException, "No playlist" );
-        return NULL;
-    }
-
-    vlc_mutex_lock( &p_playlist->object_lock );
-    i_playlist_size = p_playlist->i_size;
-
-    retval = mediacontrol_PlaylistSeq__alloc( i_playlist_size );
-
-    for( i_index = 0 ; i_index < i_playlist_size ; i_index++ )
-    {
-        retval->data[i_index] = strdup( p_playlist->pp_items[i_index]->input.psz_uri );
-    }
-    vlc_mutex_unlock( &p_playlist->object_lock );
-
-    return retval;
+    return VLC_Compiler();
 }
 
-/***************************************************************************
- * Status feedback
- ***************************************************************************/
-
-mediacontrol_StreamInformation *
-mediacontrol_get_stream_information( mediacontrol_Instance *self,
-                                     mediacontrol_PositionKey a_key,
-                                     mediacontrol_Exception *exception )
+const char * libvlc_get_changeset(void)
 {
-    mediacontrol_StreamInformation *retval;
-    input_thread_t *p_input = self->p_playlist->p_input;
-    vlc_value_t val;
-
-    retval = ( mediacontrol_StreamInformation* )malloc( sizeof( mediacontrol_StreamInformation ) );
-    if( ! retval )
-    {
-        RAISE( mediacontrol_InternalException, "Out of memory" );
-        return NULL;
-    }
-
-    if( ! p_input )
-    {
-        /* No p_input defined */
-        retval->streamstatus = mediacontrol_UndefinedStatus;
-        retval->url          = strdup( "None" );
-        retval->position     = 0;
-        retval->length       = 0;
-    }
-    else
-    {
-        switch( var_GetInteger( p_input, "state" ) )
-        {
-        case PLAYING_S     :
-            retval->streamstatus = mediacontrol_PlayingStatus;
-            break;
-        case PAUSE_S       :
-            retval->streamstatus = mediacontrol_PauseStatus;
-            break;
-        case INIT_S        :
-            retval->streamstatus = mediacontrol_InitStatus;
-            break;
-        case END_S         :
-            retval->streamstatus = mediacontrol_EndStatus;
-            break;
-        default :
-            retval->streamstatus = mediacontrol_UndefinedStatus;
-            break;
-        }
-
-        retval->url = strdup( p_input->input.p_item->psz_uri );
-
-        /* TIME and LENGTH are in microseconds. We want them in ms */
-        var_Get( p_input, "time", &val);
-        retval->position = val.i_time / 1000;
-
-        var_Get( p_input, "length", &val);
-        retval->length = val.i_time / 1000;
+    extern const char psz_vlc_changeset[];
+    return psz_vlc_changeset;
+}
 
-        retval->position = mediacontrol_unit_convert( p_input,
-                                                      mediacontrol_MediaTime, a_key,
-                                                      retval->position );
-        retval->length   = mediacontrol_unit_convert( p_input,
-                                                      mediacontrol_MediaTime, a_key,
-                                                      retval->length );
-    }
-    return retval;
+void libvlc_free( void *ptr )
+{
+    free( ptr );
 }