Remove object type field

include/vlc_objects.h

@@ -31,11 +31,6 @@
  * @{
  */
 
-/* Object types */
-/* Please add new object types below -34 */
-/* Please do not add new object types anyway */
-#define VLC_OBJECT_GENERIC     (-666)
-
 /* Object flags */
 #define OBJECT_FLAGS_NODBG       0x0001
 #define OBJECT_FLAGS_QUIET       0x0002

src/audio_output/common.c

@@ -51,8 +51,7 @@ aout_instance_t * __aout_New( vlc_object_t * p_parent )
     aout_instance_t * p_aout;
 
     /* Allocate descriptor. */
-    p_aout = vlc_custom_create( p_parent, sizeof( *p_aout ),
-                                VLC_OBJECT_GENERIC, "audio output" );
+    p_aout = vlc_custom_create( p_parent, sizeof( *p_aout ), "audio output" );
     if( p_aout == NULL )
     {
         return NULL;

src/audio_output/filters.c

@@ -55,8 +55,7 @@ static filter_t * FindFilter( aout_instance_t * p_aout,
     static const char typename[] = "audio filter";
     filter_t * p_filter;
 
-    p_filter = vlc_custom_create( p_aout, sizeof(*p_filter),
-                                  VLC_OBJECT_GENERIC, typename );
+    p_filter = vlc_custom_create( p_aout, sizeof(*p_filter), typename );
 
     if ( p_filter == NULL ) return NULL;
 

src/audio_output/input.c

@@ -265,9 +265,8 @@ int aout_InputNew( aout_instance_t * p_aout, aout_input_t * p_input, const aout_
             }
 
             /* Create a VLC object */
-            static const char typename[] = "audio filter";
             p_filter = vlc_custom_create( p_aout, sizeof(*p_filter),
-                                          VLC_OBJECT_GENERIC, typename );
+                                          "audio filter" );
             if( p_filter == NULL )
             {
                 msg_Err( p_aout, "cannot add user filter %s (skipped)",

src/input/access.c

@@ -54,7 +54,7 @@ access_t *__access_New( vlc_object_t *p_obj, input_thread_t *p_parent_input,
                         const char *psz_location )
 {
     access_t *p_access = vlc_custom_create( p_obj, sizeof (*p_access),
-                                            VLC_OBJECT_GENERIC, "access" );
+                                            "access" );
 
     if( p_access == NULL )
         return NULL;

src/input/decoder.c

@@ -750,8 +750,7 @@ static decoder_t * CreateDecoder( vlc_object_t *p_parent,
     decoder_owner_sys_t *p_owner;
     es_format_t null_es_format;
 
-    p_dec = vlc_custom_create( p_parent, sizeof( *p_dec ), VLC_OBJECT_GENERIC,
-                               "decoder" );
+    p_dec = vlc_custom_create( p_parent, sizeof( *p_dec ), "decoder" );
     if( p_dec == NULL )
         return NULL;
 
@@ -826,8 +825,7 @@ static decoder_t * CreateDecoder( vlc_object_t *p_parent,
         p_dec->b_need_packetized && !p_dec->fmt_in.b_packetized )
     {
         p_owner->p_packetizer =
-            vlc_custom_create( p_parent, sizeof( decoder_t ),
-                               VLC_OBJECT_GENERIC, "packetizer" );
+            vlc_custom_create( p_parent, sizeof( decoder_t ), "packetizer" );
         if( p_owner->p_packetizer )
         {
             es_format_Copy( &p_owner->p_packetizer->fmt_in,

src/input/demux.c

@@ -62,9 +62,7 @@ demux_t *__demux_New( vlc_object_t *p_obj, input_thread_t *p_parent_input,
                        const char *psz_location,
                        stream_t *s, es_out_t *out, bool b_quick )
 {
-    static const char typename[] = "demux";
-    demux_t *p_demux = vlc_custom_create( p_obj, sizeof( *p_demux ),
-                                          VLC_OBJECT_GENERIC, typename );
+    demux_t *p_demux = vlc_custom_create( p_obj, sizeof( *p_demux ), "demux" );
     const char *psz_module;
 
     if( p_demux == NULL ) return NULL;
@@ -334,7 +332,7 @@ decoder_t *demux_PacketizerNew( demux_t *p_demux, es_format_t *p_fmt, const char
 {
     decoder_t *p_packetizer;
     p_packetizer = vlc_custom_create( p_demux, sizeof( *p_packetizer ),
-                                      VLC_OBJECT_GENERIC, "demux packetizer" );
+                                      "demux packetizer" );
     if( !p_packetizer )
     {
         es_format_Clean( p_fmt );

src/input/input.c

@@ -292,17 +292,15 @@ input_item_t *input_GetItem( input_thread_t *p_input )
 static void ObjectKillChildrens( input_thread_t *p_input, vlc_object_t *p_obj )
 {
     vlc_list_t *p_list;
-    int i;
 
     /* FIXME ObjectKillChildrens seems a very bad idea in fact */
-    i = vlc_internals( p_obj )->i_object_type;
     if( p_obj == VLC_OBJECT(p_input->p->p_sout) )
         return;
 
     vlc_object_kill( p_obj );
 
     p_list = vlc_list_children( p_obj );
-    for( i = 0; i < p_list->i_count; i++ )
+    for( int i = 0; i < p_list->i_count; i++ )
         ObjectKillChildrens( p_input, p_list->p_values[i].p_object );
     vlc_list_release( p_list );
 }
@@ -317,13 +315,11 @@ static input_thread_t *Create( vlc_object_t *p_parent, input_item_t *p_item,
                                const char *psz_header, bool b_quick,
                                input_resource_t *p_resource )
 {
-    static const char input_name[] = "input";
     input_thread_t *p_input = NULL;                 /* thread descriptor */
     int i;
 
     /* Allocate descriptor */
-    p_input = vlc_custom_create( p_parent, sizeof( *p_input ),
-                                 VLC_OBJECT_GENERIC, input_name );
+    p_input = vlc_custom_create( p_parent, sizeof( *p_input ), "input" );
     if( p_input == NULL )
         return NULL;
 
@@ -2742,8 +2738,7 @@ static void InputSourceMeta( input_thread_t *p_input,
         return;
 
     demux_meta_t *p_demux_meta =
-        vlc_custom_create( p_demux, sizeof( *p_demux_meta ),
-                           VLC_OBJECT_GENERIC, "demux meta" );
+        vlc_custom_create( p_demux, sizeof( *p_demux_meta ), "demux meta" );
     if( !p_demux_meta )
         return;
     p_demux_meta->p_demux = p_demux;

src/input/meta.c

@@ -263,8 +263,7 @@ exit:
 int input_item_WriteMeta( vlc_object_t *obj, input_item_t *p_item )
 {
     meta_export_t *p_export =
-        vlc_custom_create( obj, sizeof( *p_export ), VLC_OBJECT_GENERIC,
-                           "meta writer" );
+        vlc_custom_create( obj, sizeof( *p_export ), "meta writer" );
     if( p_export == NULL )
         return VLC_ENOMEM;
     p_export->p_item = p_item;

src/input/stream.c

@@ -208,8 +208,7 @@ static int  ASeek( stream_t *s, uint64_t i_pos );
  ****************************************************************************/
 stream_t *stream_CommonNew( vlc_object_t *p_obj )
 {
-    stream_t *s = (stream_t *)vlc_custom_create( p_obj, sizeof(*s),
-                                                 VLC_OBJECT_GENERIC, "stream" );
+    stream_t *s = (stream_t *)vlc_custom_create( p_obj, sizeof(*s), "stream" );
 
     if( !s )
         return NULL;

src/input/vlm.c

@@ -131,7 +131,6 @@ vlm_t *vlm_New ( vlc_object_t *p_this )
 {
     vlm_t *p_vlm = NULL, **pp_vlm = &(libvlc_priv (p_this->p_libvlc)->p_vlm);
     char *psz_vlmconf;
-    static const char vlm_object_name[] = "vlm daemon";
 
     /* Avoid multiple creation */
     vlc_mutex_lock( &vlm_mutex );
@@ -150,7 +149,7 @@ vlm_t *vlm_New ( vlc_object_t *p_this )
     msg_Dbg( p_this, "creating VLM" );
 
     p_vlm = vlc_custom_create( p_this->p_libvlc, sizeof( *p_vlm ),
-                               VLC_OBJECT_GENERIC, vlm_object_name );
+                               "vlm daemon" );
     if( !p_vlm )
     {
         vlc_mutex_unlock( &vlm_mutex );
@@ -765,7 +764,7 @@ static int vlm_ControlMediaAdd( vlm_t *p_vlm, vlm_media_t *p_cfg, int64_t *p_id
     if( p_cfg->b_vod && !p_vlm->p_vod )
     {
         p_vlm->p_vod = vlc_custom_create( VLC_OBJECT(p_vlm), sizeof( vod_t ),
-                                          VLC_OBJECT_GENERIC, "vod server" );
+                                          "vod server" );
         p_vlm->p_vod->p_module = module_need( p_vlm->p_vod, "vod server", "$vod-server", false );
         if( !p_vlm->p_vod->p_module )
         {

src/interface/interface.c

@@ -71,11 +71,9 @@ int intf_Create( vlc_object_t *p_this, const char *chain )
 {
     libvlc_int_t *p_libvlc = p_this->p_libvlc;
     intf_thread_t * p_intf;
-    static const char psz_type[] = "interface";
 
     /* Allocate structure */
-    p_intf = vlc_custom_create( p_libvlc, sizeof( *p_intf ),
-                                VLC_OBJECT_GENERIC, psz_type );
+    p_intf = vlc_custom_create( p_libvlc, sizeof( *p_intf ), "interface" );
     if( !p_intf )
         return VLC_ENOMEM;
 

src/libvlc.c

@@ -198,7 +198,7 @@ libvlc_int_t * libvlc_InternalCreate( void )
 
     /* Allocate a libvlc instance object */
     p_libvlc = vlc_custom_create( (vlc_object_t *)NULL, sizeof (*priv),
-                                  VLC_OBJECT_GENERIC, "libvlc" );
+                                  "libvlc" );
     if( p_libvlc != NULL )
         i_instances++;
     vlc_mutex_unlock( &global_lock );

src/libvlc.h

@@ -106,15 +106,13 @@ void vlc_ExitDestroy( vlc_exit_t * );
  *
  * @param p_this an existing VLC object
  * @param i_size byte size of the object structure
- * @param i_type object type, usually VLC_OBJECT_CUSTOM
  * @param psz_type object type name
  * @return the created object, or NULL.
  */
 extern void *
-vlc_custom_create (vlc_object_t *p_this, size_t i_size, int i_type,
-                     const char *psz_type);
-#define vlc_custom_create(o, s, t, n) \
-        vlc_custom_create(VLC_OBJECT(o), s, t, n)
+vlc_custom_create (vlc_object_t *p_this, size_t i_size, const char *psz_type);
+#define vlc_custom_create(o, s, n) \
+        vlc_custom_create(VLC_OBJECT(o), s, n)
 
 /**
  * Assign a name to an object for vlc_object_find_name().
@@ -142,7 +140,6 @@ typedef struct vlc_object_internals vlc_object_internals_t;
 
 struct vlc_object_internals
 {
-    int             i_object_type; /* Object type, deprecated */
     char           *psz_name; /* given name */
 
     /* Object variables */

src/misc/filter.c

@@ -33,8 +33,7 @@
 filter_t *filter_NewBlend( vlc_object_t *p_this,
                            const video_format_t *p_dst_chroma )
 {
-    filter_t *p_blend = vlc_custom_create( p_this, sizeof(*p_blend),
-                                           VLC_OBJECT_GENERIC, "blend" );
+    filter_t *p_blend = vlc_custom_create( p_this, sizeof(*p_blend), "blend" );
     if( !p_blend )
         return NULL;
 
@@ -119,8 +118,8 @@ video_splitter_t *video_splitter_New( vlc_object_t *p_this,
                                       const char *psz_name,
                                       const video_format_t *p_fmt )
 {
-    video_splitter_t *p_splitter = vlc_custom_create( p_this, sizeof(*p_splitter),
-                                           VLC_OBJECT_GENERIC, "video splitter" );
+    video_splitter_t *p_splitter = vlc_custom_create( p_this,
+                                       sizeof(*p_splitter), "video splitter" );
     if( !p_splitter )
         return NULL;
 

src/misc/filter_chain.c

@@ -373,8 +373,7 @@ static filter_t *filter_chain_AppendFilterInternal( filter_chain_t *p_chain,
                                                     const es_format_t *p_fmt_out )
 {
     chained_filter_t *p_chained =
-        vlc_custom_create( p_chain->p_this, sizeof(*p_chained),
-                           VLC_OBJECT_GENERIC, "filter" );
+        vlc_custom_create( p_chain->p_this, sizeof(*p_chained), "filter" );
     filter_t *p_filter = &p_chained->filter;
     if( !p_filter )
         return NULL;

src/misc/image.c

@@ -656,8 +656,7 @@ static decoder_t *CreateDecoder( vlc_object_t *p_this, video_format_t *fmt )
 {
     decoder_t *p_dec;
 
-    p_dec = vlc_custom_create( p_this, sizeof( *p_dec ), VLC_OBJECT_GENERIC,
-                               "image decoder" );
+    p_dec = vlc_custom_create( p_this, sizeof( *p_dec ), "image decoder" );
     if( p_dec == NULL )
         return NULL;
 
@@ -781,11 +780,9 @@ static filter_t *CreateFilter( vlc_object_t *p_this, es_format_t *p_fmt_in,
                                video_format_t *p_fmt_out,
                                const char *psz_module )
 {
-    static const char typename[] = "filter";
     filter_t *p_filter;
 
-    p_filter = vlc_custom_create( p_this, sizeof(filter_t),
-                                  VLC_OBJECT_GENERIC, typename );
+    p_filter = vlc_custom_create( p_this, sizeof(filter_t), "filter" );
     p_filter->pf_video_buffer_new =
         (picture_t *(*)(filter_t *))video_new_buffer;
     p_filter->pf_video_buffer_del =

src/misc/media_library.c

@@ -79,7 +79,7 @@ media_library_t *ml_Create( vlc_object_t *p_this, char *psz_name )
 
     p_ml = ( media_library_t * ) vlc_custom_create(
                                 p_this, sizeof( media_library_t ),
-                                VLC_OBJECT_GENERIC, "media-library" );
+                                "media-library" );
     if( !p_ml )
     {
         msg_Err( p_this, "unable to create media library object" );

src/misc/objects.c

@@ -108,7 +108,7 @@ static void libvlc_unlock (libvlc_int_t *p_libvlc)
 
 #undef vlc_custom_create
 void *vlc_custom_create (vlc_object_t *parent, size_t length,
-                         int type, const char *typename)
+                         const char *typename)
 {
     /* NOTE:
      * VLC objects are laid out as follow:
@@ -124,7 +124,6 @@ void *vlc_custom_create (vlc_object_t *parent, size_t length,
     vlc_object_internals_t *priv = malloc (sizeof (*priv) + length);
     if (unlikely(priv == NULL))
         return NULL;
-    priv->i_object_type = type;
     priv->psz_name = NULL;
     priv->var_root = NULL;
     vlc_mutex_init (&priv->var_lock);
@@ -193,7 +192,7 @@ void *vlc_custom_create (vlc_object_t *parent, size_t length,
  */
 void *vlc_object_create( vlc_object_t *p_this, size_t i_size )
 {
-    return vlc_custom_create( p_this, i_size, VLC_OBJECT_GENERIC, "generic" );
+    return vlc_custom_create( p_this, i_size, "generic" );
 }
 
 #undef vlc_object_set_destructor

src/misc/probe.c

@@ -31,8 +31,7 @@
 void *vlc_probe (vlc_object_t *obj,
                  const char *capability, size_t *restrict pcount)
 {
-    vlc_probe_t *probe = vlc_custom_create (obj, sizeof(*probe),
-                                            VLC_OBJECT_GENERIC, "probe");
+    vlc_probe_t *probe = vlc_custom_create (obj, sizeof(*probe), "probe");
     if (unlikely(probe == NULL))
     {
         *pcount = 0;

src/misc/sql.c

@@ -38,8 +38,7 @@ sql_t *sql_Create( vlc_object_t *p_this, const char *psz_name,
 {
     sql_t *p_sql;
 
-    p_sql = ( sql_t * ) vlc_custom_create( p_this, sizeof( sql_t ),
-                                           VLC_OBJECT_GENERIC, "sql" );
+    p_sql = ( sql_t * ) vlc_custom_create( p_this, sizeof( sql_t ), "sql" );
     if( !p_sql )
     {
         msg_Err( p_this, "unable to create sql object" );

src/misc/update.c

@@ -509,7 +509,7 @@ void update_Download( update_t *p_update, const char *psz_destdir )
 
     update_download_thread_t *p_udt =
         vlc_custom_create( p_update->p_libvlc, sizeof( *p_udt ),
-                           VLC_OBJECT_GENERIC, "update download" );
+                           "update download" );
     if( !p_udt )
         return;
 

src/misc/xml.c

@@ -40,8 +40,7 @@ xml_t *xml_Create( vlc_object_t *p_this )
 {
     xml_t *p_xml;
 
-    p_xml = vlc_custom_create( p_this, sizeof( *p_xml ), VLC_OBJECT_GENERIC,
-                               "xml" );
+    p_xml = vlc_custom_create( p_this, sizeof( *p_xml ), "xml" );
 
     p_xml->p_module = module_need( p_xml, "xml", NULL, false );
     if( !p_xml->p_module )
@@ -75,8 +74,7 @@ xml_reader_t *xml_ReaderCreate(vlc_object_t *obj, stream_t *stream)
 {
     xml_reader_t *reader;
 
-    reader = vlc_custom_create(obj, sizeof(*reader), VLC_OBJECT_GENERIC,
-                               "xml reader");
+    reader = vlc_custom_create(obj, sizeof(*reader), "xml reader");
 
     reader->p_stream = stream;
     reader->p_module = module_need(reader, "xml reader", NULL, false);

src/network/httpd.c

@@ -973,7 +973,6 @@ httpd_host_t *httpd_HostNew( vlc_object_t *p_this, const char *psz_host,
                            );
 }
 
-static const char psz_object_type[] = "http server";
 static vlc_mutex_t httpd_mutex = VLC_STATIC_MUTEX;
 
 httpd_host_t *httpd_TLSHostNew( vlc_object_t *p_this, const char *psz_hostname,
@@ -1002,8 +1001,7 @@ httpd_host_t *httpd_TLSHostNew( vlc_object_t *p_this, const char *psz_hostname,
     {
         msg_Info( p_this, "creating httpd" );
         httpd = (httpd_t *)vlc_custom_create( p_this, sizeof (*httpd),
-                                              VLC_OBJECT_GENERIC,
-                                              psz_object_type );
+                                              "http server" );
         if( httpd == NULL )
         {
             vlc_mutex_unlock( &httpd_mutex );
@@ -1069,8 +1067,7 @@ httpd_host_t *httpd_TLSHostNew( vlc_object_t *p_this, const char *psz_hostname,
 
     /* create the new host */
     host = (httpd_host_t *)vlc_custom_create( p_this, sizeof (*host),
-                                              VLC_OBJECT_GENERIC,
-                                              psz_object_type );
+                                              "http host" );
     if (host == NULL)
         goto error;
 

src/network/tls.c

@@ -52,9 +52,7 @@ tls_ServerCreate (vlc_object_t *obj, const char *cert_path,
 {
     tls_server_t *srv;
 
-    srv = (tls_server_t *)vlc_custom_create (obj, sizeof (*srv),
-                                             VLC_OBJECT_GENERIC,
-                                             "tls server");
+    srv = (tls_server_t *)vlc_custom_create (obj, sizeof (*srv), "tls server");
     if (srv == NULL)
         return NULL;
 
@@ -162,9 +160,7 @@ tls_ClientCreate (vlc_object_t *obj, int fd, const char *psz_hostname)
     tls_session_t *cl;
     int val;
 
-    cl = (tls_session_t *)vlc_custom_create (obj, sizeof (*cl),
-                                             VLC_OBJECT_GENERIC,
-                                             "tls client");
+    cl = (tls_session_t *)vlc_custom_create (obj, sizeof (*cl), "tls client");
     if (cl == NULL)
         return NULL;
 

src/osd/osd.c

@@ -158,10 +158,8 @@ osd_menu_t *osd_MenuCreate( vlc_object_t *p_this, const char *psz_file )
     var_Get( p_this->p_libvlc, "osd-object", &val );
     if( val.p_address == NULL )
     {
-        static const char osdmenu_name[] = "osd menu";
-
         p_osd = vlc_custom_create( p_this->p_libvlc, sizeof( *p_osd ),
-                                   VLC_OBJECT_GENERIC, osdmenu_name );
+                                   "osd menu" );
         if( !p_osd )
             return NULL;
 

src/playlist/engine.c

@@ -152,13 +152,11 @@ static int VideoSplitterCallback( vlc_object_t *p_this, char const *psz_cmd,
  */
 playlist_t * playlist_Create( vlc_object_t *p_parent )
 {
-    static const char playlist_name[] = "playlist";
     playlist_t *p_playlist;
     playlist_private_t *p;
 
     /* Allocate structure */
-    p = vlc_custom_create( p_parent, sizeof( *p ),
-                           VLC_OBJECT_GENERIC, playlist_name );
+    p = vlc_custom_create( p_parent, sizeof( *p ), "playlist" );
     if( !p )
         return NULL;
 

src/playlist/fetcher.c

@@ -218,8 +218,7 @@ static int FindArt( playlist_fetcher_t *p_fetcher, input_item_t *p_item )
 
     vlc_object_t *p_parent = VLC_OBJECT(p_fetcher->p_playlist);
     art_finder_t *p_finder =
-        vlc_custom_create( p_parent, sizeof( *p_finder ), VLC_OBJECT_GENERIC,
-                           "art finder" );
+        vlc_custom_create( p_parent, sizeof( *p_finder ), "art finder" );
     if( p_finder != NULL)
     {
         module_t *p_module;
@@ -333,8 +332,7 @@ error:
 static void FetchMeta( playlist_fetcher_t *p_fetcher, input_item_t *p_item )
 {
     demux_meta_t *p_demux_meta = vlc_custom_create(p_fetcher->p_playlist,
-                                       sizeof(*p_demux_meta),
-                                       VLC_OBJECT_GENERIC, "demux meta" );
+                                         sizeof(*p_demux_meta), "demux meta" );
     if( !p_demux_meta )
         return;
 

src/playlist/loadsave.c

@@ -43,8 +43,7 @@ int playlist_Export( playlist_t * p_playlist, const char *psz_filename,
     if( p_export_root == NULL ) return VLC_EGENERIC;
 
     playlist_export_t *p_export =
-        vlc_custom_create( p_playlist, sizeof( *p_export ), VLC_OBJECT_GENERIC,
-                           "playlist export" );
+        vlc_custom_create( p_playlist, sizeof( *p_export ), "playlist export" );
     if( !p_export )
         return VLC_ENOMEM;
 

src/playlist/services_discovery.c

@@ -111,8 +111,7 @@ services_discovery_t *vlc_sd_Create( vlc_object_t *p_super,
 {
     services_discovery_t *p_sd;
 
-    p_sd = vlc_custom_create( p_super, sizeof( *p_sd ), VLC_OBJECT_GENERIC,
-                              "services discovery" );
+    p_sd = vlc_custom_create( p_super, sizeof( *p_sd ), "services discovery" );
     if( !p_sd )
         return NULL;
     free(config_ChainCreate( &p_sd->psz_name, &p_sd->p_cfg, cfg ));

src/stream_output/sap.c

@@ -103,8 +103,7 @@ sap_handler_t *SAP_Create (vlc_object_t *p_announce)
 {
     sap_handler_t *p_sap;
 
-    p_sap = vlc_custom_create (p_announce, sizeof (*p_sap),
-                               VLC_OBJECT_GENERIC, "sap sender");
+    p_sap = vlc_custom_create (p_announce, sizeof (*p_sap), "sap sender");
     if (p_sap == NULL)
         return NULL;
 

src/stream_output/stream_output.c

@@ -82,7 +82,6 @@ static void mrl_Clean( mrl_t *p_mrl );
  *****************************************************************************/
 sout_instance_t *sout_NewInstance( vlc_object_t *p_parent, const char *psz_dest )
 {
-    static const char typename[] = "stream output";
     sout_instance_t *p_sout;
 
     char *psz_chain;
@@ -99,8 +98,7 @@ sout_instance_t *sout_NewInstance( vlc_object_t *p_parent, const char *psz_dest
         return NULL;
 
     /* *** Allocate descriptor *** */
-    p_sout = vlc_custom_create( p_parent, sizeof( *p_sout ),
-                                VLC_OBJECT_GENERIC, typename );
+    p_sout = vlc_custom_create( p_parent, sizeof( *p_sout ), "stream output" );
     if( p_sout == NULL )
         return NULL;
 
@@ -250,12 +248,10 @@ int sout_InputSendBuffer( sout_packetizer_input_t *p_input,
 sout_access_out_t *sout_AccessOutNew( vlc_object_t *p_sout,
                                       const char *psz_access, const char *psz_name )
 {
-    static const char typename[] = "access out";
     sout_access_out_t *p_access;
     char              *psz_next;
 
-    p_access = vlc_custom_create( p_sout, sizeof( *p_access ),
-                                  VLC_OBJECT_GENERIC, typename );
+    p_access = vlc_custom_create( p_sout, sizeof( *p_access ), "access out" );
     if( !p_access )
         return NULL;
 
@@ -352,12 +348,10 @@ int sout_AccessOutControl (sout_access_out_t *access, int query, ...)
 sout_mux_t * sout_MuxNew( sout_instance_t *p_sout, const char *psz_mux,
                           sout_access_out_t *p_access )
 {
-    static const char typename[] = "mux";
     sout_mux_t *p_mux;
     char       *psz_next;
 
-    p_mux = vlc_custom_create( p_sout, sizeof( *p_mux ), VLC_OBJECT_GENERIC,
-                               typename);
+    p_mux = vlc_custom_create( p_sout, sizeof( *p_mux ), "mux" );
     if( p_mux == NULL )
         return NULL;
 
@@ -771,13 +765,11 @@ void sout_StreamChainDelete(sout_stream_t *p_first, sout_stream_t *p_last)
 static sout_stream_t *sout_StreamNew( sout_instance_t *p_sout, char *psz_name,
                                config_chain_t *p_cfg, sout_stream_t *p_next)
 {
-    static const char typename[] = "stream out";
     sout_stream_t *p_stream;
 
     assert(psz_name);
 
-    p_stream = vlc_custom_create( p_sout, sizeof( *p_stream ),
-                                  VLC_OBJECT_GENERIC, typename );
+    p_stream = vlc_custom_create( p_sout, sizeof( *p_stream ), "stream out" );
     if( !p_stream )
         return NULL;
 
@@ -955,7 +947,5 @@ rtp:
 #undef sout_EncoderCreate
 encoder_t *sout_EncoderCreate( vlc_object_t *p_this )
 {
-    static const char type[] = "encoder";
-    return vlc_custom_create( p_this, sizeof( encoder_t ), VLC_OBJECT_GENERIC,
-                              type );
+    return vlc_custom_create( p_this, sizeof( encoder_t ), "encoder" );
 }

src/video_output/display.c

@@ -100,8 +100,7 @@ static vout_display_t *vout_display_New(vlc_object_t *obj,
                                         vout_display_owner_t *owner)
 {
     /* */
-    vout_display_t *vd = vlc_custom_create(obj, sizeof(*vd),
-                                           VLC_OBJECT_GENERIC, "vout display");
+    vout_display_t *vd = vlc_custom_create(obj, sizeof(*vd), "vout display" );
 
     /* */
     video_format_Copy(&vd->source, fmt);

src/video_output/inhibit.c

@@ -36,9 +36,7 @@ typedef struct
 
 vlc_inhibit_t *vlc_inhibit_Create (vlc_object_t *parent, int_fast32_t wid)
 {
-    static char const typename[] = "inhibit";
-    inhibit_t *priv = vlc_custom_create (parent, sizeof (*priv),
-                                         VLC_OBJECT_GENERIC, typename);
+    inhibit_t *priv = vlc_custom_create (parent, sizeof (*priv), "inhibit" );
     if (priv == NULL)
         return NULL;
 

src/video_output/opengl.c

@@ -60,7 +60,7 @@ vlc_gl_t *vlc_gl_Create(struct vout_window_t *wnd, unsigned flags,
             return NULL;
     }
 
-    gl = vlc_custom_create(parent, sizeof (*gl), VLC_OBJECT_GENERIC, "gl");
+    gl = vlc_custom_create(parent, sizeof (*gl), "gl");
     if (unlikely(gl == NULL))
         return NULL;
 

src/video_output/video_output.c

@@ -120,7 +120,7 @@ static vout_thread_t *VoutCreate(vlc_object_t *object,
     /* Allocate descriptor */
     vout_thread_t *vout = vlc_custom_create(object,
                                             sizeof(*vout) + sizeof(*vout->p),
-                                            VLC_OBJECT_GENERIC, "video output");
+                                            "video output");
     if (!vout) {
         video_format_Clean(&original);
         return NULL;

src/video_output/vout_subpictures.c

@@ -200,8 +200,7 @@ static int spu_get_attachments(filter_t *filter,
 
 static filter_t *SpuRenderCreateAndLoadText(spu_t *spu)
 {
-    filter_t *text = vlc_custom_create(spu, sizeof(*text),
-                                       VLC_OBJECT_GENERIC, "spu text");
+    filter_t *text = vlc_custom_create(spu, sizeof(*text), "spu text");
     if (!text)
         return NULL;
 
@@ -232,8 +231,7 @@ static filter_t *SpuRenderCreateAndLoadScale(vlc_object_t *object,
                                              vlc_fourcc_t dst_chroma,
                                              bool require_resize)
 {
-    filter_t *scale = vlc_custom_create(object, sizeof(*scale),
-                                        VLC_OBJECT_GENERIC, "scale");
+    filter_t *scale = vlc_custom_create(object, sizeof(*scale), "scale");
     if (!scale)
         return NULL;
 
@@ -1205,8 +1203,9 @@ static void SubSourceAllocationClean(filter_t *filter)
  */
 spu_t *spu_Create(vlc_object_t *object)
 {
-    spu_t *spu = vlc_custom_create(object, sizeof(spu_t) + sizeof(spu_private_t),
-                                   VLC_OBJECT_GENERIC, "subpicture");
+    spu_t *spu = vlc_custom_create(object,
+                                   sizeof(spu_t) + sizeof(spu_private_t),
+                                   "subpicture");
     if (!spu)
         return NULL;
 

src/video_output/window.c

@@ -55,8 +55,7 @@ vout_window_t *vout_window_New(vlc_object_t *obj,
                                const char *module,
                                const vout_window_cfg_t *cfg)
 {
-    static char const name[] = "window";
-    window_t *w = vlc_custom_create(obj, sizeof(*w), VLC_OBJECT_GENERIC, name);
+    window_t *w = vlc_custom_create(obj, sizeof(*w), "window");
     vout_window_t *window = &w->wnd;
 
     memset(&window->handle, 0, sizeof(window->handle));

src/win32/specific.c

@@ -176,10 +176,8 @@ void system_Configure( libvlc_int_t *p_this, int i_argc, const char *const ppsz_
         if( GetLastError() != ERROR_ALREADY_EXISTS )
         {
             /* We are the 1st instance. */
-            static const char typename[] = "ipc helper";
             p_helper =
-                vlc_custom_create( p_this, sizeof(vlc_object_t),
-                                   VLC_OBJECT_GENERIC, typename );
+                vlc_custom_create( p_this, sizeof(*p_helper), "ipc helper" );
 
             /* Run the helper thread */
             hIPCHelperReady = CreateEvent( NULL, FALSE, FALSE, NULL );