Spell resource the English way
authorRémi Denis-Courmont <remi@remlab.net>
Sun, 1 Mar 2009 08:40:11 +0000 (10:40 +0200)
committerRémi Denis-Courmont <remi@remlab.net>
Sun, 1 Mar 2009 08:42:59 +0000 (10:42 +0200)
17 files changed:
src/Makefile.am
src/input/control.c
src/input/decoder.c
src/input/es_out.c
src/input/input.c
src/input/input_interface.h
src/input/input_internal.h
src/input/resource.c [new file with mode: 0644]
src/input/resource.h [new file with mode: 0644]
src/input/ressource.c [deleted file]
src/input/ressource.h [deleted file]
src/input/vlm.c
src/input/vlm_internal.h
src/misc/messages.c
src/playlist/engine.c
src/playlist/playlist_internal.h
src/playlist/thread.c

index 061e247..3edb9f3 100644 (file)
@@ -308,8 +308,8 @@ SOURCES_libvlc_common = \
        input/input_internal.h \
        input/input_interface.h \
        input/vlm_internal.h \
-       input/ressource.h \
-       input/ressource.c \
+       input/resource.h \
+       input/resource.c \
        input/stream.c \
        input/stream_demux.c \
        input/stream_filter.c \
index 8a45e47..8cf6add 100644 (file)
@@ -32,7 +32,7 @@
 
 #include "input_internal.h"
 #include "event.h"
-#include "ressource.h"
+#include "resource.h"
 
 
 static void UpdateBookmarksOption( input_thread_t * );
@@ -415,7 +415,7 @@ int input_vaControl( input_thread_t *p_input, int i_query, va_list args )
 
         case INPUT_GET_AOUT:
         {
-            aout_instance_t *p_aout = input_ressource_HoldAout( p_input->p->p_ressource );
+            aout_instance_t *p_aout = input_resource_HoldAout( p_input->p->p_resource );
             if( !p_aout )
                 return VLC_EGENERIC;
 
@@ -429,7 +429,7 @@ int input_vaControl( input_thread_t *p_input, int i_query, va_list args )
             vout_thread_t ***ppp_vout = (vout_thread_t***)va_arg( args, vout_thread_t*** );
             int           *pi_vout = (int*)va_arg( args, int* );
 
-            input_ressource_HoldVouts( p_input->p->p_ressource, ppp_vout, pi_vout );
+            input_resource_HoldVouts( p_input->p->p_resource, ppp_vout, pi_vout );
             if( *pi_vout <= 0 )
                 return VLC_EGENERIC;
             return VLC_SUCCESS;
index adc4f69..ea0cf36 100644 (file)
@@ -48,7 +48,7 @@
 #include "clock.h"
 #include "decoder.h"
 #include "event.h"
-#include "ressource.h"
+#include "resource.h"
 
 #include "../video_output/vout_control.h"
 
@@ -1887,7 +1887,7 @@ static void DecoderProcessSpu( decoder_t *p_dec, block_t *p_block, bool b_flush
         stats_UpdateInteger( p_dec, p_input->p->counters.p_decoded_sub, 1, NULL );
         vlc_mutex_unlock( &p_input->p->counters.counters_lock );
 
-        p_vout = input_ressource_HoldVout( p_input->p->p_ressource );
+        p_vout = input_resource_HoldVout( p_input->p->p_resource );
         if( p_vout && p_owner->p_spu_vout == p_vout )
         {
             /* Preroll does not work very well with subtitle */
@@ -1912,7 +1912,7 @@ static void DecoderProcessSpu( decoder_t *p_dec, block_t *p_block, bool b_flush
 
     if( b_flush && p_owner->p_spu_vout )
     {
-        p_vout = input_ressource_HoldVout( p_input->p->p_ressource );
+        p_vout = input_resource_HoldVout( p_input->p->p_resource );
 
         if( p_vout && p_owner->p_spu_vout == p_vout )
             spu_Control( p_vout->p_spu, SPU_CHANNEL_CLEAR,
@@ -2041,7 +2041,7 @@ static void DeleteDecoder( decoder_t * p_dec )
         aout_DecDelete( p_owner->p_aout, p_owner->p_aout_input );
     if( p_owner->p_aout )
     {
-        input_ressource_RequestAout( p_owner->p_input->p->p_ressource,
+        input_resource_RequestAout( p_owner->p_input->p->p_resource,
                                      p_owner->p_aout );
         input_SendEventAout( p_owner->p_input );
         p_owner->p_aout = NULL;
@@ -2055,7 +2055,7 @@ static void DeleteDecoder( decoder_t * p_dec )
             vout_ChangePause( p_owner->p_vout, false, mdate() );
 
         /* */
-        input_ressource_RequestVout( p_owner->p_input->p->p_ressource, p_owner->p_vout, NULL, true );
+        input_resource_RequestVout( p_owner->p_input->p->p_resource, p_owner->p_vout, NULL, true );
         input_SendEventVout( p_owner->p_input );
     }
 
@@ -2071,7 +2071,7 @@ static void DeleteDecoder( decoder_t * p_dec )
     {
         vout_thread_t *p_vout;
 
-        p_vout = input_ressource_HoldVout( p_owner->p_input->p->p_ressource );
+        p_vout = input_resource_HoldVout( p_owner->p_input->p->p_resource );
         if( p_vout )
         {
             if( p_owner->p_spu_vout == p_vout )
@@ -2135,7 +2135,7 @@ static vout_thread_t *aout_request_vout( void *p_private,
     decoder_t *p_dec = p_private;
     input_thread_t *p_input = p_dec->p_owner->p_input;
 
-    p_vout = input_ressource_RequestVout( p_input->p->p_ressource, p_vout, p_fmt, b_recyle );
+    p_vout = input_resource_RequestVout( p_input->p->p_resource, p_vout, p_fmt, b_recyle );
     input_SendEventVout( p_input );
 
     return p_vout;
@@ -2199,7 +2199,7 @@ static aout_buffer_t *aout_new_buffer( decoder_t *p_dec, int i_samples )
 
         p_aout = p_owner->p_aout;
         if( !p_aout )
-            p_aout = input_ressource_RequestAout( p_owner->p_input->p->p_ressource, NULL );
+            p_aout = input_resource_RequestAout( p_owner->p_input->p->p_resource, NULL );
         p_aout_input = aout_DecNew( p_dec, &p_aout,
                                     &format, &p_dec->fmt_out.audio_replay_gain, &request_vout );
 
@@ -2313,7 +2313,7 @@ static picture_t *vout_new_buffer( decoder_t *p_dec )
         p_owner->p_vout = NULL;
         vlc_mutex_unlock( &p_owner->lock );
 
-        p_vout = input_ressource_RequestVout( p_owner->p_input->p->p_ressource,
+        p_vout = input_resource_RequestVout( p_owner->p_input->p->p_resource,
                                               p_vout, &p_dec->fmt_out.video, true );
 
         vlc_mutex_lock( &p_owner->lock );
@@ -2401,7 +2401,7 @@ static subpicture_t *spu_new_buffer( decoder_t *p_dec )
         if( p_dec->b_die || p_dec->b_error )
             break;
 
-        p_vout = input_ressource_HoldVout( p_owner->p_input->p->p_ressource );
+        p_vout = input_resource_HoldVout( p_owner->p_input->p->p_resource );
         if( p_vout )
             break;
 
@@ -2446,7 +2446,7 @@ static void spu_del_buffer( decoder_t *p_dec, subpicture_t *p_subpic )
     decoder_owner_sys_t *p_owner = p_dec->p_owner;
     vout_thread_t *p_vout = NULL;
 
-    p_vout = input_ressource_HoldVout( p_owner->p_input->p->p_ressource );
+    p_vout = input_resource_HoldVout( p_owner->p_input->p->p_resource );
     if( !p_vout || p_owner->p_spu_vout != p_vout )
     {
         if( p_vout )
index 5276412..e9d2116 100644 (file)
@@ -670,7 +670,7 @@ static void EsOutDecodersStopBuffering( es_out_t *out, bool b_forced )
               (int)(mdate() - i_decoder_buffering_start)/1000 );
 
     /* Here is a good place to destroy unused vout with every demuxer */
-    input_ressource_TerminateVout( p_sys->p_input->p->p_ressource );
+    input_resource_TerminateVout( p_sys->p_input->p->p_resource );
 
     /* */
     const mtime_t i_wakeup_delay = 10*1000; /* FIXME CLEANUP thread wake up time*/
@@ -2040,7 +2040,7 @@ static int EsOutControlLocked( es_out_t *out, int i_query, va_list args )
                         break;
                 }
                 if( i >= p_sys->i_es )
-                    input_ressource_TerminateVout( p_sys->p_input->p->p_ressource );
+                    input_resource_TerminateVout( p_sys->p_input->p->p_resource );
             }
             p_sys->b_active = b;
             return VLC_SUCCESS;
@@ -2317,7 +2317,7 @@ static int EsOutControlLocked( es_out_t *out, int i_query, va_list args )
             /* Clean up vout after user action (in active mode only).
              * FIXME it does not work well with multiple video windows */
             if( p_sys->b_active )
-                input_ressource_TerminateVout( p_sys->p_input->p->p_ressource );
+                input_resource_TerminateVout( p_sys->p_input->p->p_resource );
             return i_ret;
         }
 
index 7d05ae2..603f8d5 100644 (file)
@@ -43,7 +43,7 @@
 #include "demux.h"
 #include "stream.h"
 #include "item.h"
-#include "ressource.h"
+#include "resource.h"
 
 #include <vlc_sout.h>
 #include "../stream_output/stream_output.h"
@@ -66,7 +66,7 @@ static  void *Run            ( vlc_object_t *p_this );
 static  void *RunAndDestroy  ( vlc_object_t *p_this );
 
 static input_thread_t * Create  ( vlc_object_t *, input_item_t *,
-                                  const char *, bool, input_ressource_t * );
+                                  const char *, bool, input_resource_t * );
 static  int             Init    ( input_thread_t *p_input );
 static void             End     ( input_thread_t *p_input );
 static void             MainLoop( input_thread_t *p_input );
@@ -117,7 +117,7 @@ static void input_ChangeState( input_thread_t *p_input, int i_state ); /* TODO f
  *****************************************************************************/
 static input_thread_t *Create( vlc_object_t *p_parent, input_item_t *p_item,
                                const char *psz_header, bool b_quick,
-                               input_ressource_t *p_ressource )
+                               input_resource_t *p_resource )
 {
     static const char input_name[] = "input";
     input_thread_t *p_input = NULL;                 /* thread descriptor */
@@ -200,11 +200,11 @@ static input_thread_t *Create( vlc_object_t *p_parent, input_item_t *p_item,
     p_input->p->slave   = NULL;
 
     /* */
-    if( p_ressource )
-        p_input->p->p_ressource = p_ressource;
+    if( p_resource )
+        p_input->p->p_resource = p_resource;
     else
-        p_input->p->p_ressource = input_ressource_New();
-    input_ressource_SetInput( p_input->p->p_ressource, p_input );
+        p_input->p->p_resource = input_resource_New();
+    input_resource_SetInput( p_input->p->p_resource, p_input );
 
     /* Init control buffer */
     vlc_mutex_init( &p_input->p->lock_control );
@@ -311,8 +311,8 @@ static void Destructor( input_thread_t * p_input )
     stats_TimerDump( p_input, STATS_TIMER_INPUT_LAUNCHING );
     stats_TimerClean( p_input, STATS_TIMER_INPUT_LAUNCHING );
 
-    if( p_input->p->p_ressource )
-        input_ressource_Delete( p_input->p->p_ressource );
+    if( p_input->p->p_resource )
+        input_resource_Delete( p_input->p->p_resource );
 
     vlc_gc_decref( p_input->p->p_item );
 
@@ -340,11 +340,11 @@ input_thread_t *__input_CreateThread( vlc_object_t *p_parent,
 /* */
 input_thread_t *__input_CreateThreadExtended( vlc_object_t *p_parent,
                                               input_item_t *p_item,
-                                              const char *psz_log, input_ressource_t *p_ressource )
+                                              const char *psz_log, input_resource_t *p_resource )
 {
     input_thread_t *p_input;
 
-    p_input = Create( p_parent, p_item, psz_log, false, p_ressource );
+    p_input = Create( p_parent, p_item, psz_log, false, p_resource );
     if( !p_input )
         return NULL;
 
@@ -440,17 +440,17 @@ void input_StopThread( input_thread_t *p_input )
     input_ControlPush( p_input, INPUT_CONTROL_SET_DIE, NULL );
 }
 
-input_ressource_t *input_DetachRessource( input_thread_t *p_input )
+input_resource_t *input_DetachRessource( input_thread_t *p_input )
 {
     assert( p_input->b_dead );
 
-    input_ressource_t *p_ressource = p_input->p->p_ressource;
-    input_ressource_SetInput( p_ressource, NULL );
+    input_resource_t *p_resource = p_input->p->p_resource;
+    input_resource_SetInput( p_resource, NULL );
 
-    p_input->p->p_ressource = NULL;
+    p_input->p->p_resource = NULL;
     p_input->p->p_sout = NULL;
 
-    return p_ressource;
+    return p_resource;
 }
 
 /**
@@ -829,7 +829,7 @@ static int InitSout( input_thread_t * p_input )
     char *psz = var_GetNonEmptyString( p_input, "sout" );
     if( psz && strncasecmp( p_input->p->p_item->psz_uri, "vlc:", 4 ) )
     {
-        p_input->p->p_sout  = input_ressource_RequestSout( p_input->p->p_ressource, NULL, psz );
+        p_input->p->p_sout  = input_resource_RequestSout( p_input->p->p_resource, NULL, psz );
         if( !p_input->p->p_sout )
         {
             input_ChangeState( p_input, ERROR_S );
@@ -850,7 +850,7 @@ static int InitSout( input_thread_t * p_input )
     }
     else
     {
-        input_ressource_RequestSout( p_input->p->p_ressource, NULL, NULL );
+        input_resource_RequestSout( p_input->p->p_resource, NULL, NULL );
     }
     free( psz );
 
@@ -1215,12 +1215,12 @@ error:
         es_out_Delete( p_input->p->p_es_out );
     if( p_input->p->p_es_out_display )
         es_out_Delete( p_input->p->p_es_out_display );
-    if( p_input->p->p_ressource )
+    if( p_input->p->p_resource )
     {
         if( p_input->p->p_sout )
-            input_ressource_RequestSout( p_input->p->p_ressource,
+            input_resource_RequestSout( p_input->p->p_resource,
                                          p_input->p->p_sout, NULL );
-        input_ressource_SetInput( p_input->p->p_ressource, NULL );
+        input_resource_SetInput( p_input->p->p_resource, NULL );
     }
 
 #ifdef ENABLE_SOUT
@@ -1339,9 +1339,9 @@ static void End( input_thread_t * p_input )
     }
 
     /* */
-    input_ressource_RequestSout( p_input->p->p_ressource,
+    input_resource_RequestSout( p_input->p->p_resource,
                                  p_input->p->p_sout, NULL );
-    input_ressource_SetInput( p_input->p->p_ressource, NULL );
+    input_resource_SetInput( p_input->p->p_resource, NULL );
 }
 
 /*****************************************************************************
index e113944..cc59b5f 100644 (file)
@@ -45,44 +45,44 @@ int input_Preparse( vlc_object_t *, input_item_t * );
 input_stats_t *stats_NewInputStats( input_thread_t *p_input );
 
 /**
- * This defines an opaque input ressource handler.
+ * This defines an opaque input resource handler.
  */
-typedef struct input_ressource_t input_ressource_t;
+typedef struct input_resource_t input_resource_t;
 
 /**
- * This function releases an input_ressource_t and all associated ressources.
+ * This function releases an input_resource_t and all associated resources.
  */
-void input_ressource_Delete( input_ressource_t * );
+void input_resource_Delete( input_resource_t * );
 
 /**
- * This function deletes the current sout in the ressources.
+ * This function deletes the current sout in the resources.
  */
-void input_ressource_TerminateSout( input_ressource_t *p_ressource );
+void input_resource_TerminateSout( input_resource_t *p_resource );
 
 /**
- * This function deletes the current vout in the ressources.
+ * This function deletes the current vout in the resources.
  */
-void input_ressource_TerminateVout( input_ressource_t *p_ressource );
+void input_resource_TerminateVout( input_resource_t *p_resource );
 
 /**
- * This function return true if there is at least one vout in the ressources.
+ * This function return true if there is at least one vout in the resources.
  *
- * It can only be called on detached ressources.
+ * It can only be called on detached resources.
  */
-bool input_ressource_HasVout( input_ressource_t *p_ressource );
+bool input_resource_HasVout( input_resource_t *p_resource );
 
 /* input.c */
 #define input_CreateThreadExtended(a,b,c,d) __input_CreateThreadExtended(VLC_OBJECT(a),b,c,d)
-input_thread_t *__input_CreateThreadExtended ( vlc_object_t *, input_item_t *, const char *, input_ressource_t * );
+input_thread_t *__input_CreateThreadExtended ( vlc_object_t *, input_item_t *, const char *, input_resource_t * );
 
 /**
- * This function detaches ressources from a dead input.
+ * This function detaches resources from a dead input.
  *
  * It MUST be called on a dead input (p_input->b_dead true) otherwise
  * it will assert.
  * It does not support concurrent calls.
  */
-input_ressource_t *input_DetachRessource( input_thread_t * );
+input_resource_t *input_DetachRessource( input_thread_t * );
 
 /* */
 typedef enum
index bb49f44..118011a 100644 (file)
@@ -130,7 +130,7 @@ struct input_thread_private_t
     input_source_t **slave;
 
     /* Ressources */
-    input_ressource_t *p_ressource;
+    input_resource_t *p_resource;
 
     /* Stats counters */
     struct {
diff --git a/src/input/resource.c b/src/input/resource.c
new file mode 100644 (file)
index 0000000..b3e140f
--- /dev/null
@@ -0,0 +1,456 @@
+/*****************************************************************************
+ * resource.c
+ *****************************************************************************
+ * Copyright (C) 2008 Laurent Aimar
+ * $Id$
+ *
+ * Authors: Laurent Aimar < fenrir _AT_ videolan _DOT_ 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
+ * 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 Street, Fifth Floor, Boston MA 02110-1301, USA.
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Preamble
+ *****************************************************************************/
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <vlc_common.h>
+#include <vlc_vout.h>
+#include <vlc_osd.h>
+#include <vlc_aout.h>
+#include <vlc_sout.h>
+#include "../libvlc.h"
+#include "../stream_output/stream_output.h"
+#include "../audio_output/aout_internal.h"
+#include "../video_output/vout_control.h"
+#include "input_interface.h"
+#include "resource.h"
+
+struct input_resource_t
+{
+    /* This lock is used to serialize request and protect
+     * our variables */
+    vlc_mutex_t    lock;
+
+    /* */
+    input_thread_t *p_input;
+
+    sout_instance_t *p_sout;
+    vout_thread_t   *p_vout_free;
+    aout_instance_t *p_aout;
+
+    /* This lock is used to protect vout resources access (for hold)
+     * It is a special case because of embed video (possible deadlock
+     * between vout window request and vout holds in some(qt4) interface) */
+    vlc_mutex_t    lock_vout;
+    int             i_vout;
+    vout_thread_t   **pp_vout;
+};
+
+/* */
+static void DestroySout( input_resource_t *p_resource )
+{
+#ifdef ENABLE_SOUT
+    if( p_resource->p_sout )
+        sout_DeleteInstance( p_resource->p_sout );
+#endif
+    p_resource->p_sout = NULL;
+}
+static sout_instance_t *RequestSout( input_resource_t *p_resource,
+                                     sout_instance_t *p_sout, const char *psz_sout )
+{
+#ifdef ENABLE_SOUT
+    if( !p_sout && !psz_sout )
+    {
+        if( p_resource->p_sout )
+            msg_Dbg( p_resource->p_sout, "destroying useless sout" );
+        DestroySout( p_resource );
+        return NULL;
+    }
+
+    assert( p_resource->p_input );
+    assert( !p_sout || ( !p_resource->p_sout && !psz_sout ) );
+
+    /* Check the validity of the sout */
+    if( p_resource->p_sout &&
+        strcmp( p_resource->p_sout->psz_sout, psz_sout ) )
+    {
+        msg_Dbg( p_resource->p_input, "destroying unusable sout" );
+        DestroySout( p_resource );
+    }
+
+    if( psz_sout )
+    {
+        if( p_resource->p_sout )
+        {
+            /* Reuse it */
+            msg_Dbg( p_resource->p_input, "reusing sout" );
+            msg_Dbg( p_resource->p_input, "you probably want to use gather stream_out" );
+            vlc_object_attach( p_resource->p_sout, p_resource->p_input );
+        }
+        else
+        {
+            /* Create a new one */
+            p_resource->p_sout = sout_NewInstance( p_resource->p_input, psz_sout );
+        }
+
+        p_sout = p_resource->p_sout;
+        p_resource->p_sout = NULL;
+
+        return p_sout;
+    }
+    else
+    {
+        vlc_object_detach( p_sout );
+        p_resource->p_sout = p_sout;
+
+        return NULL;
+    }
+#else
+    return NULL;
+#endif
+}
+
+/* */
+static void DestroyVout( input_resource_t *p_resource )
+{
+    assert( p_resource->i_vout == 0 );
+
+    if( p_resource->p_vout_free )
+        vout_CloseAndRelease( p_resource->p_vout_free );
+
+    p_resource->p_vout_free = NULL;
+}
+static void DisplayVoutTitle( input_resource_t *p_resource,
+                              vout_thread_t *p_vout )
+{
+    assert( p_resource->p_input );
+
+    /* TODO display the title only one time for the same input ? */
+
+    input_item_t *p_item = input_GetItem( p_resource->p_input );
+
+    char *psz_nowplaying = input_item_GetNowPlaying( p_item );
+    if( psz_nowplaying && *psz_nowplaying )
+    {
+        vout_DisplayTitle( p_vout, psz_nowplaying );
+    }
+    else
+    {
+        char *psz_artist = input_item_GetArtist( p_item );
+        char *psz_name = input_item_GetTitle( p_item );
+
+        if( !psz_name || *psz_name == '\0' )
+        {
+            free( psz_name );
+            psz_name = input_item_GetName( p_item );
+        }
+        if( psz_artist && *psz_artist )
+        {
+            char *psz_string;
+            if( asprintf( &psz_string, "%s - %s", psz_name, psz_artist ) != -1 )
+            {
+                vout_DisplayTitle( p_vout, psz_string );
+                free( psz_string );
+            }
+        }
+        else if( psz_name )
+        {
+            vout_DisplayTitle( p_vout, psz_name );
+        }
+        free( psz_name );
+        free( psz_artist );
+    }
+    free( psz_nowplaying );
+}
+static vout_thread_t *RequestVout( input_resource_t *p_resource,
+                                   vout_thread_t *p_vout, video_format_t *p_fmt,
+                                   bool b_recycle )
+{
+    if( !p_vout && !p_fmt )
+    {
+        if( p_resource->p_vout_free )
+        {
+            msg_Dbg( p_resource->p_vout_free, "destroying useless vout" );
+            vout_CloseAndRelease( p_resource->p_vout_free );
+            p_resource->p_vout_free = NULL;
+        }
+        return NULL;
+    }
+
+    assert( p_resource->p_input );
+    if( p_fmt )
+    {
+        /* */
+        if( !p_vout && p_resource->p_vout_free )
+        {
+            msg_Dbg( p_resource->p_input, "trying to reuse free vout" );
+            p_vout = p_resource->p_vout_free;
+
+            p_resource->p_vout_free = NULL;
+        }
+        else if( p_vout )
+        {
+            assert( p_vout != p_resource->p_vout_free );
+
+            vlc_mutex_lock( &p_resource->lock_vout );
+            TAB_REMOVE( p_resource->i_vout, p_resource->pp_vout, p_vout );
+            vlc_mutex_unlock( &p_resource->lock_vout );
+        }
+
+        /* */
+        p_vout = vout_Request( p_resource->p_input, p_vout, p_fmt );
+        if( !p_vout )
+            return NULL;
+
+        DisplayVoutTitle( p_resource, p_vout );
+
+        vlc_mutex_lock( &p_resource->lock_vout );
+        TAB_APPEND( p_resource->i_vout, p_resource->pp_vout, p_vout );
+        vlc_mutex_unlock( &p_resource->lock_vout );
+
+        return p_vout;
+    }
+    else
+    {
+        assert( p_vout );
+
+        vlc_mutex_lock( &p_resource->lock_vout );
+        TAB_REMOVE( p_resource->i_vout, p_resource->pp_vout, p_vout );
+        const int i_vout_active = p_resource->i_vout;
+        vlc_mutex_unlock( &p_resource->lock_vout );
+
+        if( p_resource->p_vout_free || i_vout_active > 0 || !b_recycle )
+        {
+            if( b_recycle )
+                msg_Dbg( p_resource->p_input, "detroying vout (already one saved or active)" );
+            vout_CloseAndRelease( p_vout );
+        }
+        else
+        {
+            msg_Dbg( p_resource->p_input, "saving a free vout" );
+            vout_Flush( p_vout, 1 );
+            spu_Control( p_vout->p_spu, SPU_CHANNEL_CLEAR, -1 );
+
+            p_resource->p_vout_free = p_vout;
+        }
+        return NULL;
+    }
+}
+static vout_thread_t *HoldVout( input_resource_t *p_resource )
+{
+    if( p_resource->i_vout <= 0 )
+        return NULL;
+
+    /* TODO FIXME: p_resource->pp_vout order is NOT stable */
+    vlc_mutex_lock( &p_resource->lock_vout );
+
+    vout_thread_t *p_vout = p_resource->pp_vout[0];
+
+    vlc_object_hold( p_vout );
+
+    vlc_mutex_unlock( &p_resource->lock_vout );
+
+    return p_vout;
+}
+static void HoldVouts( input_resource_t *p_resource, vout_thread_t ***ppp_vout, int *pi_vout )
+{
+    vout_thread_t **pp_vout;
+
+    *pi_vout = 0;
+    *ppp_vout = NULL;
+
+    vlc_mutex_lock( &p_resource->lock_vout );
+
+    if( p_resource->i_vout <= 0 )
+        goto exit;
+
+    pp_vout = calloc( p_resource->i_vout, sizeof(*pp_vout) );
+    if( !pp_vout )
+        goto exit;
+
+    *ppp_vout = pp_vout;
+    *pi_vout = p_resource->i_vout;
+
+    for( int i = 0; i < p_resource->i_vout; i++ )
+    {
+        pp_vout[i] = p_resource->pp_vout[i];
+        vlc_object_hold( pp_vout[i] );
+    }
+
+exit:
+    vlc_mutex_unlock( &p_resource->lock_vout );
+}
+
+/* */
+static void DestroyAout( input_resource_t *p_resource )
+{
+    if( p_resource->p_aout )
+        vlc_object_release( p_resource->p_aout );
+    p_resource->p_aout = NULL;
+}
+static aout_instance_t *RequestAout( input_resource_t *p_resource, aout_instance_t *p_aout )
+{
+    assert( p_resource->p_input );
+
+    if( p_aout )
+    {
+        msg_Dbg( p_resource->p_input, "releasing aout" );
+        vlc_object_release( p_aout );
+        return NULL;
+    }
+    else
+    {
+        if( !p_resource->p_aout )
+        {
+            msg_Dbg( p_resource->p_input, "creating aout" );
+            p_resource->p_aout = aout_New( p_resource->p_input );
+        }
+        else
+        {
+            msg_Dbg( p_resource->p_input, "reusing aout" );
+        }
+
+        if( !p_resource->p_aout )
+            return NULL;
+
+        vlc_object_detach( p_resource->p_aout );
+        vlc_object_attach( p_resource->p_aout, p_resource->p_input );
+        vlc_object_hold( p_resource->p_aout );
+        return p_resource->p_aout;
+    }
+}
+static aout_instance_t *HoldAout( input_resource_t *p_resource )
+{
+    if( !p_resource->p_aout )
+        return NULL;
+
+    aout_instance_t *p_aout = p_resource->p_aout;
+
+    vlc_object_hold( p_aout );
+
+    return p_aout;
+}
+
+/* */
+input_resource_t *input_resource_New( void )
+{
+    input_resource_t *p_resource = calloc( 1, sizeof(*p_resource) );
+    if( !p_resource )
+        return NULL;
+
+    vlc_mutex_init( &p_resource->lock );
+    vlc_mutex_init( &p_resource->lock_vout );
+    return p_resource;
+}
+
+void input_resource_Delete( input_resource_t *p_resource )
+{
+    DestroySout( p_resource );
+    DestroyVout( p_resource );
+    DestroyAout( p_resource );
+
+    vlc_mutex_destroy( &p_resource->lock_vout );
+    vlc_mutex_destroy( &p_resource->lock );
+    free( p_resource );
+}
+
+void input_resource_SetInput( input_resource_t *p_resource, input_thread_t *p_input )
+{
+    vlc_mutex_lock( &p_resource->lock );
+
+    if( p_resource->p_input && !p_input )
+    {
+        if( p_resource->p_aout )
+            vlc_object_detach( p_resource->p_aout );
+
+        assert( p_resource->i_vout == 0 );
+        if( p_resource->p_vout_free )
+            vlc_object_detach( p_resource->p_vout_free );
+
+        if( p_resource->p_sout )
+            vlc_object_detach( p_resource->p_sout );
+    }
+
+    /* */
+    p_resource->p_input = p_input;
+
+    vlc_mutex_unlock( &p_resource->lock );
+}
+
+vout_thread_t *input_resource_RequestVout( input_resource_t *p_resource,
+                                            vout_thread_t *p_vout, video_format_t *p_fmt, bool b_recycle )
+{
+    vlc_mutex_lock( &p_resource->lock );
+    vout_thread_t *p_ret = RequestVout( p_resource, p_vout, p_fmt, b_recycle );
+    vlc_mutex_unlock( &p_resource->lock );
+
+    return p_ret;
+}
+vout_thread_t *input_resource_HoldVout( input_resource_t *p_resource )
+{
+    return HoldVout( p_resource );
+}
+void input_resource_HoldVouts( input_resource_t *p_resource, vout_thread_t ***ppp_vout, int *pi_vout )
+{
+    HoldVouts( p_resource, ppp_vout, pi_vout );
+}
+void input_resource_TerminateVout( input_resource_t *p_resource )
+{
+    input_resource_RequestVout( p_resource, NULL, NULL, false );
+}
+bool input_resource_HasVout( input_resource_t *p_resource )
+{
+    vlc_mutex_lock( &p_resource->lock );
+    assert( !p_resource->p_input );
+    const bool b_vout = p_resource->p_vout_free != NULL;
+    vlc_mutex_unlock( &p_resource->lock );
+
+    return b_vout;
+}
+
+/* */
+aout_instance_t *input_resource_RequestAout( input_resource_t *p_resource, aout_instance_t *p_aout )
+{
+    vlc_mutex_lock( &p_resource->lock );
+    aout_instance_t *p_ret = RequestAout( p_resource, p_aout );
+    vlc_mutex_unlock( &p_resource->lock );
+
+    return p_ret;
+}
+aout_instance_t *input_resource_HoldAout( input_resource_t *p_resource )
+{
+    vlc_mutex_lock( &p_resource->lock );
+    aout_instance_t *p_ret = HoldAout( p_resource );
+    vlc_mutex_unlock( &p_resource->lock );
+
+    return p_ret;
+}
+/* */
+sout_instance_t *input_resource_RequestSout( input_resource_t *p_resource, sout_instance_t *p_sout, const char *psz_sout )
+{
+    vlc_mutex_lock( &p_resource->lock );
+    sout_instance_t *p_ret = RequestSout( p_resource, p_sout, psz_sout );
+    vlc_mutex_unlock( &p_resource->lock );
+
+    return p_ret;
+}
+void input_resource_TerminateSout( input_resource_t *p_resource )
+{
+    input_resource_RequestSout( p_resource, NULL, NULL );
+}
+
diff --git a/src/input/resource.h b/src/input/resource.h
new file mode 100644 (file)
index 0000000..b5801fd
--- /dev/null
@@ -0,0 +1,80 @@
+/*****************************************************************************
+ * resource.h
+ *****************************************************************************
+ * Copyright (C) 2008 Laurent Aimar
+ * $Id$
+ *
+ * Authors: Laurent Aimar < fenrir _AT_ videolan _DOT_ 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
+ * 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 Street, Fifth Floor, Boston MA 02110-1301, USA.
+ *****************************************************************************/
+
+#if defined(__PLUGIN__) || defined(__BUILTIN__) || !defined(__LIBVLC__)
+# error This header file can only be included from LibVLC.
+#endif
+
+#ifndef _INPUT_RESSOURCE_H
+#define _INPUT_RESSOURCE_H 1
+
+#include <vlc_common.h>
+
+/**
+ * This function creates an empty input_resource_t.
+ */
+input_resource_t *input_resource_New( void );
+
+/**
+ * This function set the associated input.
+ */
+void input_resource_SetInput( input_resource_t *, input_thread_t * );
+
+/**
+ * This function handles sout request.
+ */
+sout_instance_t *input_resource_RequestSout( input_resource_t *, sout_instance_t *, const char *psz_sout );
+
+/**
+ * This function handles aout request.
+ */
+aout_instance_t *input_resource_RequestAout( input_resource_t *, aout_instance_t * );
+
+/**
+ * This function return the current aout if any.
+ *
+ * You must call vlc_object_release on the value returned (if non NULL).
+ */
+aout_instance_t *input_resource_HoldAout( input_resource_t *p_resource );
+
+/**
+ * This function handles vout request.
+ */
+vout_thread_t *input_resource_RequestVout( input_resource_t *, vout_thread_t *, video_format_t *, bool b_recycle );
+
+/**
+ * This function return one of the current vout if any.
+ *
+ * You must call vlc_object_release on the value returned (if non NULL).
+ */
+vout_thread_t *input_resource_HoldVout( input_resource_t * );
+
+/**
+ * This function return all current vouts if any.
+ *
+ * You must call vlc_object_release on all values returned (if non NULL).
+ */
+void input_resource_HoldVouts( input_resource_t *, vout_thread_t ***, int * );
+
+#endif
+
diff --git a/src/input/ressource.c b/src/input/ressource.c
deleted file mode 100644 (file)
index a1698bd..0000000
+++ /dev/null
@@ -1,456 +0,0 @@
-/*****************************************************************************
- * ressource.c
- *****************************************************************************
- * Copyright (C) 2008 Laurent Aimar
- * $Id$
- *
- * Authors: Laurent Aimar < fenrir _AT_ videolan _DOT_ 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
- * 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 Street, Fifth Floor, Boston MA 02110-1301, USA.
- *****************************************************************************/
-
-/*****************************************************************************
- * Preamble
- *****************************************************************************/
-#ifdef HAVE_CONFIG_H
-# include "config.h"
-#endif
-
-#include <vlc_common.h>
-#include <vlc_vout.h>
-#include <vlc_osd.h>
-#include <vlc_aout.h>
-#include <vlc_sout.h>
-#include "../libvlc.h"
-#include "../stream_output/stream_output.h"
-#include "../audio_output/aout_internal.h"
-#include "../video_output/vout_control.h"
-#include "input_interface.h"
-#include "ressource.h"
-
-struct input_ressource_t
-{
-    /* This lock is used to serialize request and protect
-     * our variables */
-    vlc_mutex_t    lock;
-
-    /* */
-    input_thread_t *p_input;
-
-    sout_instance_t *p_sout;
-    vout_thread_t   *p_vout_free;
-    aout_instance_t *p_aout;
-
-    /* This lock is used to protect vout ressources access (for hold)
-     * It is a special case because of embed video (possible deadlock
-     * between vout window request and vout holds in some(qt4) interface) */
-    vlc_mutex_t    lock_vout;
-    int             i_vout;
-    vout_thread_t   **pp_vout;
-};
-
-/* */
-static void DestroySout( input_ressource_t *p_ressource )
-{
-#ifdef ENABLE_SOUT
-    if( p_ressource->p_sout )
-        sout_DeleteInstance( p_ressource->p_sout );
-#endif
-    p_ressource->p_sout = NULL;
-}
-static sout_instance_t *RequestSout( input_ressource_t *p_ressource,
-                                     sout_instance_t *p_sout, const char *psz_sout )
-{
-#ifdef ENABLE_SOUT
-    if( !p_sout && !psz_sout )
-    {
-        if( p_ressource->p_sout )
-            msg_Dbg( p_ressource->p_sout, "destroying useless sout" );
-        DestroySout( p_ressource );
-        return NULL;
-    }
-
-    assert( p_ressource->p_input );
-    assert( !p_sout || ( !p_ressource->p_sout && !psz_sout ) );
-
-    /* Check the validity of the sout */
-    if( p_ressource->p_sout &&
-        strcmp( p_ressource->p_sout->psz_sout, psz_sout ) )
-    {
-        msg_Dbg( p_ressource->p_input, "destroying unusable sout" );
-        DestroySout( p_ressource );
-    }
-
-    if( psz_sout )
-    {
-        if( p_ressource->p_sout )
-        {
-            /* Reuse it */
-            msg_Dbg( p_ressource->p_input, "reusing sout" );
-            msg_Dbg( p_ressource->p_input, "you probably want to use gather stream_out" );
-            vlc_object_attach( p_ressource->p_sout, p_ressource->p_input );
-        }
-        else
-        {
-            /* Create a new one */
-            p_ressource->p_sout = sout_NewInstance( p_ressource->p_input, psz_sout );
-        }
-
-        p_sout = p_ressource->p_sout;
-        p_ressource->p_sout = NULL;
-
-        return p_sout;
-    }
-    else
-    {
-        vlc_object_detach( p_sout );
-        p_ressource->p_sout = p_sout;
-
-        return NULL;
-    }
-#else
-    return NULL;
-#endif
-}
-
-/* */
-static void DestroyVout( input_ressource_t *p_ressource )
-{
-    assert( p_ressource->i_vout == 0 );
-
-    if( p_ressource->p_vout_free )
-        vout_CloseAndRelease( p_ressource->p_vout_free );
-
-    p_ressource->p_vout_free = NULL;
-}
-static void DisplayVoutTitle( input_ressource_t *p_ressource,
-                              vout_thread_t *p_vout )
-{
-    assert( p_ressource->p_input );
-
-    /* TODO display the title only one time for the same input ? */
-
-    input_item_t *p_item = input_GetItem( p_ressource->p_input );
-
-    char *psz_nowplaying = input_item_GetNowPlaying( p_item );
-    if( psz_nowplaying && *psz_nowplaying )
-    {
-        vout_DisplayTitle( p_vout, psz_nowplaying );
-    }
-    else
-    {
-        char *psz_artist = input_item_GetArtist( p_item );
-        char *psz_name = input_item_GetTitle( p_item );
-
-        if( !psz_name || *psz_name == '\0' )
-        {
-            free( psz_name );
-            psz_name = input_item_GetName( p_item );
-        }
-        if( psz_artist && *psz_artist )
-        {
-            char *psz_string;
-            if( asprintf( &psz_string, "%s - %s", psz_name, psz_artist ) != -1 )
-            {
-                vout_DisplayTitle( p_vout, psz_string );
-                free( psz_string );
-            }
-        }
-        else if( psz_name )
-        {
-            vout_DisplayTitle( p_vout, psz_name );
-        }
-        free( psz_name );
-        free( psz_artist );
-    }
-    free( psz_nowplaying );
-}
-static vout_thread_t *RequestVout( input_ressource_t *p_ressource,
-                                   vout_thread_t *p_vout, video_format_t *p_fmt,
-                                   bool b_recycle )
-{
-    if( !p_vout && !p_fmt )
-    {
-        if( p_ressource->p_vout_free )
-        {
-            msg_Dbg( p_ressource->p_vout_free, "destroying useless vout" );
-            vout_CloseAndRelease( p_ressource->p_vout_free );
-            p_ressource->p_vout_free = NULL;
-        }
-        return NULL;
-    }
-
-    assert( p_ressource->p_input );
-    if( p_fmt )
-    {
-        /* */
-        if( !p_vout && p_ressource->p_vout_free )
-        {
-            msg_Dbg( p_ressource->p_input, "trying to reuse free vout" );
-            p_vout = p_ressource->p_vout_free;
-
-            p_ressource->p_vout_free = NULL;
-        }
-        else if( p_vout )
-        {
-            assert( p_vout != p_ressource->p_vout_free );
-
-            vlc_mutex_lock( &p_ressource->lock_vout );
-            TAB_REMOVE( p_ressource->i_vout, p_ressource->pp_vout, p_vout );
-            vlc_mutex_unlock( &p_ressource->lock_vout );
-        }
-
-        /* */
-        p_vout = vout_Request( p_ressource->p_input, p_vout, p_fmt );
-        if( !p_vout )
-            return NULL;
-
-        DisplayVoutTitle( p_ressource, p_vout );
-
-        vlc_mutex_lock( &p_ressource->lock_vout );
-        TAB_APPEND( p_ressource->i_vout, p_ressource->pp_vout, p_vout );
-        vlc_mutex_unlock( &p_ressource->lock_vout );
-
-        return p_vout;
-    }
-    else
-    {
-        assert( p_vout );
-
-        vlc_mutex_lock( &p_ressource->lock_vout );
-        TAB_REMOVE( p_ressource->i_vout, p_ressource->pp_vout, p_vout );
-        const int i_vout_active = p_ressource->i_vout;
-        vlc_mutex_unlock( &p_ressource->lock_vout );
-
-        if( p_ressource->p_vout_free || i_vout_active > 0 || !b_recycle )
-        {
-            if( b_recycle )
-                msg_Dbg( p_ressource->p_input, "detroying vout (already one saved or active)" );
-            vout_CloseAndRelease( p_vout );
-        }
-        else
-        {
-            msg_Dbg( p_ressource->p_input, "saving a free vout" );
-            vout_Flush( p_vout, 1 );
-            spu_Control( p_vout->p_spu, SPU_CHANNEL_CLEAR, -1 );
-
-            p_ressource->p_vout_free = p_vout;
-        }
-        return NULL;
-    }
-}
-static vout_thread_t *HoldVout( input_ressource_t *p_ressource )
-{
-    if( p_ressource->i_vout <= 0 )
-        return NULL;
-
-    /* TODO FIXME: p_ressource->pp_vout order is NOT stable */
-    vlc_mutex_lock( &p_ressource->lock_vout );
-
-    vout_thread_t *p_vout = p_ressource->pp_vout[0];
-
-    vlc_object_hold( p_vout );
-
-    vlc_mutex_unlock( &p_ressource->lock_vout );
-
-    return p_vout;
-}
-static void HoldVouts( input_ressource_t *p_ressource, vout_thread_t ***ppp_vout, int *pi_vout )
-{
-    vout_thread_t **pp_vout;
-
-    *pi_vout = 0;
-    *ppp_vout = NULL;
-
-    vlc_mutex_lock( &p_ressource->lock_vout );
-
-    if( p_ressource->i_vout <= 0 )
-        goto exit;
-
-    pp_vout = calloc( p_ressource->i_vout, sizeof(*pp_vout) );
-    if( !pp_vout )
-        goto exit;
-
-    *ppp_vout = pp_vout;
-    *pi_vout = p_ressource->i_vout;
-
-    for( int i = 0; i < p_ressource->i_vout; i++ )
-    {
-        pp_vout[i] = p_ressource->pp_vout[i];
-        vlc_object_hold( pp_vout[i] );
-    }
-
-exit:
-    vlc_mutex_unlock( &p_ressource->lock_vout );
-}
-
-/* */
-static void DestroyAout( input_ressource_t *p_ressource )
-{
-    if( p_ressource->p_aout )
-        vlc_object_release( p_ressource->p_aout );
-    p_ressource->p_aout = NULL;
-}
-static aout_instance_t *RequestAout( input_ressource_t *p_ressource, aout_instance_t *p_aout )
-{
-    assert( p_ressource->p_input );
-
-    if( p_aout )
-    {
-        msg_Dbg( p_ressource->p_input, "releasing aout" );
-        vlc_object_release( p_aout );
-        return NULL;
-    }
-    else
-    {
-        if( !p_ressource->p_aout )
-        {
-            msg_Dbg( p_ressource->p_input, "creating aout" );
-            p_ressource->p_aout = aout_New( p_ressource->p_input );
-        }
-        else
-        {
-            msg_Dbg( p_ressource->p_input, "reusing aout" );
-        }
-
-        if( !p_ressource->p_aout )
-            return NULL;
-
-        vlc_object_detach( p_ressource->p_aout );
-        vlc_object_attach( p_ressource->p_aout, p_ressource->p_input );
-        vlc_object_hold( p_ressource->p_aout );
-        return p_ressource->p_aout;
-    }
-}
-static aout_instance_t *HoldAout( input_ressource_t *p_ressource )
-{
-    if( !p_ressource->p_aout )
-        return NULL;
-
-    aout_instance_t *p_aout = p_ressource->p_aout;
-
-    vlc_object_hold( p_aout );
-
-    return p_aout;
-}
-
-/* */
-input_ressource_t *input_ressource_New( void )
-{
-    input_ressource_t *p_ressource = calloc( 1, sizeof(*p_ressource) );
-    if( !p_ressource )
-        return NULL;
-
-    vlc_mutex_init( &p_ressource->lock );
-    vlc_mutex_init( &p_ressource->lock_vout );
-    return p_ressource;
-}
-
-void input_ressource_Delete( input_ressource_t *p_ressource )
-{
-    DestroySout( p_ressource );
-    DestroyVout( p_ressource );
-    DestroyAout( p_ressource );
-
-    vlc_mutex_destroy( &p_ressource->lock_vout );
-    vlc_mutex_destroy( &p_ressource->lock );
-    free( p_ressource );
-}
-
-void input_ressource_SetInput( input_ressource_t *p_ressource, input_thread_t *p_input )
-{
-    vlc_mutex_lock( &p_ressource->lock );
-
-    if( p_ressource->p_input && !p_input )
-    {
-        if( p_ressource->p_aout )
-            vlc_object_detach( p_ressource->p_aout );
-
-        assert( p_ressource->i_vout == 0 );
-        if( p_ressource->p_vout_free )
-            vlc_object_detach( p_ressource->p_vout_free );
-
-        if( p_ressource->p_sout )
-            vlc_object_detach( p_ressource->p_sout );
-    }
-
-    /* */
-    p_ressource->p_input = p_input;
-
-    vlc_mutex_unlock( &p_ressource->lock );
-}
-
-vout_thread_t *input_ressource_RequestVout( input_ressource_t *p_ressource,
-                                            vout_thread_t *p_vout, video_format_t *p_fmt, bool b_recycle )
-{
-    vlc_mutex_lock( &p_ressource->lock );
-    vout_thread_t *p_ret = RequestVout( p_ressource, p_vout, p_fmt, b_recycle );
-    vlc_mutex_unlock( &p_ressource->lock );
-
-    return p_ret;
-}
-vout_thread_t *input_ressource_HoldVout( input_ressource_t *p_ressource )
-{
-    return HoldVout( p_ressource );
-}
-void input_ressource_HoldVouts( input_ressource_t *p_ressource, vout_thread_t ***ppp_vout, int *pi_vout )
-{
-    HoldVouts( p_ressource, ppp_vout, pi_vout );
-}
-void input_ressource_TerminateVout( input_ressource_t *p_ressource )
-{
-    input_ressource_RequestVout( p_ressource, NULL, NULL, false );
-}
-bool input_ressource_HasVout( input_ressource_t *p_ressource )
-{
-    vlc_mutex_lock( &p_ressource->lock );
-    assert( !p_ressource->p_input );
-    const bool b_vout = p_ressource->p_vout_free != NULL;
-    vlc_mutex_unlock( &p_ressource->lock );
-
-    return b_vout;
-}
-
-/* */
-aout_instance_t *input_ressource_RequestAout( input_ressource_t *p_ressource, aout_instance_t *p_aout )
-{
-    vlc_mutex_lock( &p_ressource->lock );
-    aout_instance_t *p_ret = RequestAout( p_ressource, p_aout );
-    vlc_mutex_unlock( &p_ressource->lock );
-
-    return p_ret;
-}
-aout_instance_t *input_ressource_HoldAout( input_ressource_t *p_ressource )
-{
-    vlc_mutex_lock( &p_ressource->lock );
-    aout_instance_t *p_ret = HoldAout( p_ressource );
-    vlc_mutex_unlock( &p_ressource->lock );
-
-    return p_ret;
-}
-/* */
-sout_instance_t *input_ressource_RequestSout( input_ressource_t *p_ressource, sout_instance_t *p_sout, const char *psz_sout )
-{
-    vlc_mutex_lock( &p_ressource->lock );
-    sout_instance_t *p_ret = RequestSout( p_ressource, p_sout, psz_sout );
-    vlc_mutex_unlock( &p_ressource->lock );
-
-    return p_ret;
-}
-void input_ressource_TerminateSout( input_ressource_t *p_ressource )
-{
-    input_ressource_RequestSout( p_ressource, NULL, NULL );
-}
-
diff --git a/src/input/ressource.h b/src/input/ressource.h
deleted file mode 100644 (file)
index f0e0aef..0000000
+++ /dev/null
@@ -1,80 +0,0 @@
-/*****************************************************************************
- * ressource.h
- *****************************************************************************
- * Copyright (C) 2008 Laurent Aimar
- * $Id$
- *
- * Authors: Laurent Aimar < fenrir _AT_ videolan _DOT_ 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
- * 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 Street, Fifth Floor, Boston MA 02110-1301, USA.
- *****************************************************************************/
-
-#if defined(__PLUGIN__) || defined(__BUILTIN__) || !defined(__LIBVLC__)
-# error This header file can only be included from LibVLC.
-#endif
-
-#ifndef _INPUT_RESSOURCE_H
-#define _INPUT_RESSOURCE_H 1
-
-#include <vlc_common.h>
-
-/**
- * This function creates an empty input_ressource_t.
- */
-input_ressource_t *input_ressource_New( void );
-
-/**
- * This function set the associated input.
- */
-void input_ressource_SetInput( input_ressource_t *, input_thread_t * );
-
-/**
- * This function handles sout request.
- */
-sout_instance_t *input_ressource_RequestSout( input_ressource_t *, sout_instance_t *, const char *psz_sout );
-
-/**
- * This function handles aout request.
- */
-aout_instance_t *input_ressource_RequestAout( input_ressource_t *, aout_instance_t * );
-
-/**
- * This function return the current aout if any.
- *
- * You must call vlc_object_release on the value returned (if non NULL).
- */
-aout_instance_t *input_ressource_HoldAout( input_ressource_t *p_ressource );
-
-/**
- * This function handles vout request.
- */
-vout_thread_t *input_ressource_RequestVout( input_ressource_t *, vout_thread_t *, video_format_t *, bool b_recycle );
-
-/**
- * This function return one of the current vout if any.
- *
- * You must call vlc_object_release on the value returned (if non NULL).
- */
-vout_thread_t *input_ressource_HoldVout( input_ressource_t * );
-
-/**
- * This function return all current vouts if any.
- *
- * You must call vlc_object_release on all values returned (if non NULL).
- */
-void input_ressource_HoldVouts( input_ressource_t *, vout_thread_t ***, int * );
-
-#endif
-
index 9816a4b..b83bdcf 100644 (file)
@@ -759,7 +759,7 @@ static vlm_media_instance_sys_t *vlm_MediaInstanceNew( vlm_t *p_vlm, const char
     p_instance->i_index = 0;
     p_instance->b_sout_keep = false;
     p_instance->p_input = NULL;
-    p_instance->p_input_ressource = NULL;
+    p_instance->p_input_resource = NULL;
 
     return p_instance;
 }
@@ -768,18 +768,18 @@ static void vlm_MediaInstanceDelete( vlm_media_instance_sys_t *p_instance )
     input_thread_t *p_input = p_instance->p_input;
     if( p_input )
     {
-        input_ressource_t *p_ressource;
+        input_resource_t *p_resource;
 
         input_StopThread( p_input );
         vlc_thread_join( p_input );
 
-        p_ressource = input_DetachRessource( p_input );
-        input_ressource_Delete( p_ressource );
+        p_resource = input_DetachRessource( p_input );
+        input_resource_Delete( p_resource );
 
         vlc_object_release( p_input );
     }
-    if( p_instance->p_input_ressource )
-        input_ressource_Delete( p_instance->p_input_ressource );
+    if( p_instance->p_input_resource )
+        input_resource_Delete( p_instance->p_input_resource );
 
     vlc_gc_decref( p_instance->p_item );
     free( p_instance->psz_name );
@@ -854,13 +854,13 @@ static int vlm_ControlMediaInstanceStart( vlm_t *p_vlm, int64_t id, const char *
         input_StopThread( p_input );
         vlc_thread_join( p_input );
 
-        p_instance->p_input_ressource = input_DetachRessource( p_input );
+        p_instance->p_input_resource = input_DetachRessource( p_input );
 
         vlc_object_release( p_input );
 
         if( !p_instance->b_sout_keep )
-            input_ressource_TerminateSout( p_instance->p_input_ressource );
-        input_ressource_TerminateVout( p_instance->p_input_ressource );
+            input_resource_TerminateSout( p_instance->p_input_resource );
+        input_resource_TerminateVout( p_instance->p_input_resource );
     }
 
     /* Start new one */
@@ -870,8 +870,8 @@ static int vlm_ControlMediaInstanceStart( vlm_t *p_vlm, int64_t id, const char *
     if( asprintf( &psz_log, _("Media: %s"), p_media->cfg.psz_name ) != -1 )
     {
         p_instance->p_input = input_CreateThreadExtended( p_vlm, p_instance->p_item,
-                                                          psz_log, p_instance->p_input_ressource );
-        p_instance->p_input_ressource = NULL;
+                                                          psz_log, p_instance->p_input_resource );
+        p_instance->p_input_resource = NULL;
 
         if( !p_instance->p_input )
         {
index 074c790..67462f5 100644 (file)
@@ -43,7 +43,7 @@ typedef struct
 
     input_item_t      *p_item;
     input_thread_t    *p_input;
-    input_ressource_t *p_input_ressource;
+    input_resource_t *p_input_resource;
 
 } vlm_media_instance_sys_t;
 
index a3462ba..190ec7d 100644 (file)
@@ -160,7 +160,7 @@ void __msg_DisableObjectPrinting (vlc_object_t *p_this, char * psz_object)
  * Destroy the message queues
  *
  * This functions prints all messages remaining in the queues,
- * then frees all the allocated ressources
+ * then frees all the allocated resources
  * No other messages interface functions should be called after this one.
  */
 void msg_Destroy (libvlc_int_t *p_libvlc)
index c25b43f..2a46459 100644 (file)
@@ -176,7 +176,7 @@ static void playlist_Destructor( vlc_object_t * p_this )
     playlist_private_t *p_sys = pl_priv(p_playlist);
 
     assert( !p_sys->p_input );
-    assert( !p_sys->p_input_ressource );
+    assert( !p_sys->p_input_resource );
     assert( !p_sys->p_preparser );
     assert( !p_sys->p_fetcher );
 
index a50c074..aed7edf 100644 (file)
@@ -59,7 +59,7 @@ typedef struct playlist_private_t
     int                   i_sds;   /**< Number of service discovery modules */
     input_thread_t *      p_input;  /**< the input thread associated
                                      * with the current item */
-    input_ressource_t *   p_input_ressource; /**< input ressources */
+    input_resource_t *   p_input_resource; /**< input resources */
     struct {
         /* Current status. These fields are readonly, only the playlist
          * main loop can touch it*/
index 5d1c60f..8fdf672 100644 (file)
@@ -102,10 +102,10 @@ void playlist_Deactivate( playlist_t *p_playlist )
     if( p_fetcher )
         playlist_fetcher_Delete( p_fetcher );
 
-    /* release input ressources */
-    if( p_sys->p_input_ressource )
-        input_ressource_Delete( p_sys->p_input_ressource );
-    p_sys->p_input_ressource = NULL;
+    /* release input resources */
+    if( p_sys->p_input_resource )
+        input_resource_Delete( p_sys->p_input_resource );
+    p_sys->p_input_resource = NULL;
 
     /* */
     playlist_MLDump( p_playlist );
@@ -252,7 +252,7 @@ static int PlayItem( playlist_t *p_playlist, playlist_item_t *p_item )
     assert( p_sys->p_input == NULL );
 
     input_thread_t *p_input_thread =
-        input_CreateThreadExtended( p_playlist, p_input, NULL, p_sys->p_input_ressource );
+        input_CreateThreadExtended( p_playlist, p_input, NULL, p_sys->p_input_resource );
 
     if( p_input_thread )
     {
@@ -261,7 +261,7 @@ static int PlayItem( playlist_t *p_playlist, playlist_item_t *p_item )
         var_AddCallback( p_input_thread, "intf-event", InputEvent, p_playlist );
     }
 
-    p_sys->p_input_ressource = NULL;
+    p_sys->p_input_resource = NULL;
 
     char *psz_uri = input_item_GetURI( p_item->p_input );
     if( psz_uri && ( !strncmp( psz_uri, "directory:", 10 ) ||
@@ -481,16 +481,16 @@ static int LoopInput( playlist_t *p_playlist )
     {
         PL_DEBUG( "dead input" );
 
-        assert( p_sys->p_input_ressource == NULL );
+        assert( p_sys->p_input_resource == NULL );
 
-        p_sys->p_input_ressource = input_DetachRessource( p_input );
+        p_sys->p_input_resource = input_DetachRessource( p_input );
 
         PL_UNLOCK;
         /* We can unlock as we return VLC_EGENERIC (no event will be lost) */
 
-        /* input_ressource_t must be manipulated without playlist lock */
+        /* input_resource_t must be manipulated without playlist lock */
         if( !var_CreateGetBool( p_input, "sout-keep" ) )
-            input_ressource_TerminateSout( p_sys->p_input_ressource );
+            input_resource_TerminateSout( p_sys->p_input_resource );
 
         /* The DelCallback must be issued without playlist lock */
         var_DelCallback( p_input, "intf-event", InputEvent, p_playlist );
@@ -537,15 +537,15 @@ static void LoopRequest( playlist_t *p_playlist )
     {
         p_sys->status.i_status = PLAYLIST_STOPPED;
 
-        if( p_sys->p_input_ressource &&
-            input_ressource_HasVout( p_sys->p_input_ressource ) )
+        if( p_sys->p_input_resource &&
+            input_resource_HasVout( p_sys->p_input_resource ) )
         {
             /* XXX We can unlock if we don't issue the wait as we will be
              * call again without anything else done between the calls */
             PL_UNLOCK;
 
-            /* input_ressource_t must be manipulated without playlist lock */
-            input_ressource_TerminateVout( p_sys->p_input_ressource );
+            /* input_resource_t must be manipulated without playlist lock */
+            input_resource_TerminateVout( p_sys->p_input_resource );
 
             PL_LOCK;
         }