X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;ds=sidebyside;f=modules%2Fstream_out%2Ftranscode.c;h=b4bf89136ab1126212cc4a0286783aac5d89a22c;hb=80ba00a8101b3c8213d9f560a791457a54ec8a12;hp=ae717d996019793c8d325b3f31c24b7b5c258c37;hpb=ecc787cdac7b327be6a97f65627972a8c1556977;p=vlc

diff --git a/modules/stream_out/transcode.c b/modules/stream_out/transcode.c
index ae717d9960..b4bf89136a 100644
--- a/modules/stream_out/transcode.c
+++ b/modules/stream_out/transcode.c
@@ -7,6 +7,7 @@
  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
  *          Gildas Bazin <gbazin@videolan.org>
  *          Jean-Paul Saman <jpsaman #_at_# m2x dot nl>
+ *          Antoine Cellerier <dionoea 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
@@ -37,6 +38,7 @@
 #include <vlc_aout.h>
 #include <vlc_vout.h>
 #include <vlc_codec.h>
+#include <vlc_meta.h>
 #include <vlc_block.h>
 #include <vlc_filter.h>
 #include <vlc_osd.h>
@@ -156,84 +158,84 @@ static void Close( vlc_object_t * );
 
 #define SOUT_CFG_PREFIX "sout-transcode-"
 
-vlc_module_begin();
-    set_shortname( N_("Transcode"));
-    set_description( N_("Transcode stream output") );
-    set_capability( "sout stream", 50 );
-    add_shortcut( "transcode" );
-    set_callbacks( Open, Close );
-    set_category( CAT_SOUT );
-    set_subcategory( SUBCAT_SOUT_STREAM );
-    set_section( N_("Video"), NULL );
-    add_string( SOUT_CFG_PREFIX "venc", NULL, NULL, VENC_TEXT,
-                VENC_LONGTEXT, false );
+vlc_module_begin ()
+    set_shortname( N_("Transcode"))
+    set_description( N_("Transcode stream output") )
+    set_capability( "sout stream", 50 )
+    add_shortcut( "transcode" )
+    set_callbacks( Open, Close )
+    set_category( CAT_SOUT )
+    set_subcategory( SUBCAT_SOUT_STREAM )
+    set_section( N_("Video"), NULL )
+    add_module( SOUT_CFG_PREFIX "venc", "encoder", NULL, NULL, VENC_TEXT,
+                VENC_LONGTEXT, false )
     add_string( SOUT_CFG_PREFIX "vcodec", NULL, NULL, VCODEC_TEXT,
-                VCODEC_LONGTEXT, false );
+                VCODEC_LONGTEXT, false )
     add_integer( SOUT_CFG_PREFIX "vb", 800 * 1000, NULL, VB_TEXT,
-                 VB_LONGTEXT, false );
+                 VB_LONGTEXT, false )
     add_float( SOUT_CFG_PREFIX "scale", 1, NULL, SCALE_TEXT,
-               SCALE_LONGTEXT, false );
+               SCALE_LONGTEXT, false )
     add_float( SOUT_CFG_PREFIX "fps", 0, NULL, FPS_TEXT,
-               FPS_LONGTEXT, false );
+               FPS_LONGTEXT, false )
     add_bool( SOUT_CFG_PREFIX "hurry-up", true, NULL, HURRYUP_TEXT,
-               HURRYUP_LONGTEXT, false );
+               HURRYUP_LONGTEXT, false )
     add_bool( SOUT_CFG_PREFIX "deinterlace", 0, NULL, DEINTERLACE_TEXT,
-              DEINTERLACE_LONGTEXT, false );
+              DEINTERLACE_LONGTEXT, false )
     add_string( SOUT_CFG_PREFIX "deinterlace-module", "deinterlace", NULL,
                 DEINTERLACE_MODULE_TEXT, DEINTERLACE_MODULE_LONGTEXT,
-                false );
-        change_string_list( ppsz_deinterlace_type, 0, 0 );
+                false )
+        change_string_list( ppsz_deinterlace_type, 0, 0 )
     add_integer( SOUT_CFG_PREFIX "width", 0, NULL, WIDTH_TEXT,
-                 WIDTH_LONGTEXT, true );
+                 WIDTH_LONGTEXT, true )
     add_integer( SOUT_CFG_PREFIX "height", 0, NULL, HEIGHT_TEXT,
-                 HEIGHT_LONGTEXT, true );
+                 HEIGHT_LONGTEXT, true )
     add_integer( SOUT_CFG_PREFIX "maxwidth", 0, NULL, MAXWIDTH_TEXT,
-                 MAXWIDTH_LONGTEXT, true );
+                 MAXWIDTH_LONGTEXT, true )
     add_integer( SOUT_CFG_PREFIX "maxheight", 0, NULL, MAXHEIGHT_TEXT,
-                 MAXHEIGHT_LONGTEXT, true );
+                 MAXHEIGHT_LONGTEXT, true )
     add_module_list( SOUT_CFG_PREFIX "vfilter", "video filter2",
                      NULL, NULL,
-                     VFILTER_TEXT, VFILTER_LONGTEXT, false );
+                     VFILTER_TEXT, VFILTER_LONGTEXT, false )
 
-    set_section( N_("Audio"), NULL );
-    add_string( SOUT_CFG_PREFIX "aenc", NULL, NULL, AENC_TEXT,
-                AENC_LONGTEXT, false );
+    set_section( N_("Audio"), NULL )
+    add_module( SOUT_CFG_PREFIX "aenc", "encoder", NULL, NULL, AENC_TEXT,
+                AENC_LONGTEXT, false )
     add_string( SOUT_CFG_PREFIX "acodec", NULL, NULL, ACODEC_TEXT,
-                ACODEC_LONGTEXT, false );
+                ACODEC_LONGTEXT, false )
     add_integer( SOUT_CFG_PREFIX "ab", 0, NULL, AB_TEXT,
-                 AB_LONGTEXT, false );
+                 AB_LONGTEXT, false )
     add_integer( SOUT_CFG_PREFIX "channels", 0, NULL, ACHANS_TEXT,
-                 ACHANS_LONGTEXT, false );
+                 ACHANS_LONGTEXT, false )
     add_integer( SOUT_CFG_PREFIX "samplerate", 0, NULL, ARATE_TEXT,
-                 ARATE_LONGTEXT, true );
+                 ARATE_LONGTEXT, true )
     add_bool( SOUT_CFG_PREFIX "audio-sync", 0, NULL, ASYNC_TEXT,
-              ASYNC_LONGTEXT, false );
+              ASYNC_LONGTEXT, false )
     add_module_list( SOUT_CFG_PREFIX "afilter",  "audio filter2",
                      NULL, NULL,
-                     AFILTER_TEXT, AFILTER_LONGTEXT, false );
+                     AFILTER_TEXT, AFILTER_LONGTEXT, false )
 
-    set_section( N_("Overlays/Subtitles"), NULL );
-    add_string( SOUT_CFG_PREFIX "senc", NULL, NULL, SENC_TEXT,
-                SENC_LONGTEXT, false );
+    set_section( N_("Overlays/Subtitles"), NULL )
+    add_module( SOUT_CFG_PREFIX "senc", "encoder", NULL, NULL, SENC_TEXT,
+                SENC_LONGTEXT, false )
     add_string( SOUT_CFG_PREFIX "scodec", NULL, NULL, SCODEC_TEXT,
-                SCODEC_LONGTEXT, false );
+                SCODEC_LONGTEXT, false )
     add_bool( SOUT_CFG_PREFIX "soverlay", 0, NULL, SCODEC_TEXT,
-               SCODEC_LONGTEXT, false );
+               SCODEC_LONGTEXT, false )
     add_module_list( SOUT_CFG_PREFIX "sfilter", "video filter",
                      NULL, NULL,
-                     SFILTER_TEXT, SFILTER_LONGTEXT, false );
+                     SFILTER_TEXT, SFILTER_LONGTEXT, false )
 
-    set_section( N_("On Screen Display"), NULL );
+    set_section( N_("On Screen Display"), NULL )
     add_bool( SOUT_CFG_PREFIX "osd", 0, NULL, OSD_TEXT,
-              OSD_LONGTEXT, false );
+              OSD_LONGTEXT, false )
 
-    set_section( N_("Miscellaneous"), NULL );
+    set_section( N_("Miscellaneous"), NULL )
     add_integer( SOUT_CFG_PREFIX "threads", 0, NULL, THREADS_TEXT,
-                 THREADS_LONGTEXT, true );
+                 THREADS_LONGTEXT, true )
     add_bool( SOUT_CFG_PREFIX "high-priority", 0, NULL, HP_TEXT, HP_LONGTEXT,
-              true );
+              true )
 
-vlc_module_end();
+vlc_module_end ()
 
 static const char *const ppsz_sout_options[] = {
     "venc", "vcodec", "vb",
@@ -261,6 +263,7 @@ static void audio_del_buffer( decoder_t *, aout_buffer_t * );
 
 static int  transcode_video_new    ( sout_stream_t *, sout_stream_id_t * );
 static void transcode_video_close  ( sout_stream_t *, sout_stream_id_t * );
+static void transcode_video_encoder_init( sout_stream_t *, sout_stream_id_t *);
 static int  transcode_video_encoder_open( sout_stream_t *, sout_stream_id_t *);
 static int  transcode_video_process( sout_stream_t *, sout_stream_id_t *,
                                      block_t *, block_t ** );
@@ -283,9 +286,9 @@ static void transcode_osd_close  ( sout_stream_t *, sout_stream_id_t * );
 static int  transcode_osd_process( sout_stream_t *, sout_stream_id_t *,
                                    block_t *, block_t ** );
 
-static int  EncoderThread( struct sout_stream_sys_t * p_sys );
+static void* EncoderThread( vlc_object_t * p_this );
 
-static int pi_channels_maps[6] =
+static const int pi_channels_maps[6] =
 {
     0,
     AOUT_CHAN_CENTER,   AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
@@ -298,7 +301,6 @@ static int pi_channels_maps[6] =
 
 #define PICTURE_RING_SIZE 64
 #define SUBPICTURE_RING_SIZE 20
-#define TRANSCODE_FILTERS 10
 
 #define ENC_FRAMERATE (25 * 1000 + .5)
 #define ENC_FRAMERATE_BASE 1000
@@ -322,9 +324,8 @@ struct sout_stream_sys_t
     uint32_t        i_sample_rate;
     uint32_t        i_channels;
     int             i_abitrate;
-    char            *psz_afilters[TRANSCODE_FILTERS];
-    config_chain_t  *p_afilters_cfg[TRANSCODE_FILTERS];
-    int             i_afilters;
+
+    char            *psz_af2;
 
     /* Video */
     vlc_fourcc_t    i_vcodec;   /* codec video (0 if not transcode) */
@@ -335,20 +336,19 @@ struct sout_stream_sys_t
     double          f_fps;
     unsigned int    i_width, i_maxwidth;
     unsigned int    i_height, i_maxheight;
-    bool      b_deinterlace;
+    bool            b_deinterlace;
     char            *psz_deinterlace;
     config_chain_t  *p_deinterlace_cfg;
     int             i_threads;
-    bool      b_high_priority;
-    bool      b_hurry_up;
-    char            *psz_vfilters[TRANSCODE_FILTERS];
-    config_chain_t  *p_vfilters_cfg[TRANSCODE_FILTERS];
-    int             i_vfilters;
+    bool            b_high_priority;
+    bool            b_hurry_up;
+
+    char            *psz_vf2;
 
     /* SPU */
     vlc_fourcc_t    i_scodec;   /* codec spu (0 if not transcode) */
     char            *psz_senc;
-    bool      b_soverlay;
+    bool            b_soverlay;
     config_chain_t  *p_spu_cfg;
     spu_t           *p_spu;
 
@@ -356,10 +356,10 @@ struct sout_stream_sys_t
     vlc_fourcc_t    i_osdcodec; /* codec osd menu (0 if not transcode) */
     char            *psz_osdenc;
     config_chain_t  *p_osd_cfg;
-    bool      b_osd;   /* true when osd es is registered */
+    bool            b_osd;   /* true when osd es is registered */
 
     /* Sync */
-    bool      b_master_sync;
+    bool            b_master_sync;
     mtime_t         i_master_drift;
 };
 
@@ -446,27 +446,12 @@ static int Open( vlc_object_t *p_this )
     }
 
     var_Get( p_stream, SOUT_CFG_PREFIX "afilter", &val );
-    p_sys->i_afilters = 0;
     if( val.psz_string && *val.psz_string )
+        p_sys->psz_af2 = val.psz_string;
+    else
     {
-        char *psz_parser = val.psz_string;
-
-        while( (psz_parser != NULL) && (*psz_parser != '\0')
-                && (p_sys->i_afilters < TRANSCODE_FILTERS) )
-        {
-            psz_parser = config_ChainCreate(
-                                   &p_sys->psz_afilters[p_sys->i_afilters],
-                                   &p_sys->p_afilters_cfg[p_sys->i_afilters],
-                                   psz_parser );
-            p_sys->i_afilters++;
-            if( (psz_parser != NULL) && (*psz_parser != '\0') ) psz_parser++;
-        }
-    }
-    free( val.psz_string );
-    if( p_sys->i_afilters < TRANSCODE_FILTERS-1 )
-    {
-        p_sys->psz_afilters[p_sys->i_afilters] = NULL;
-        p_sys->p_afilters_cfg[p_sys->i_afilters] = NULL;
+        free( val.psz_string );
+        p_sys->psz_af2 = NULL;
     }
 
     /* Video transcoding parameters */
@@ -518,27 +503,12 @@ static int Open( vlc_object_t *p_this )
     p_sys->i_maxheight = val.i_int;
 
     var_Get( p_stream, SOUT_CFG_PREFIX "vfilter", &val );
-    p_sys->i_vfilters = 0;
     if( val.psz_string && *val.psz_string )
+        p_sys->psz_vf2 = val.psz_string;
+    else
     {
-        char *psz_parser = val.psz_string;
-
-        while( (psz_parser != NULL) && (*psz_parser != '\0')
-                && (p_sys->i_vfilters < TRANSCODE_FILTERS) )
-        {
-            psz_parser = config_ChainCreate(
-                                   &p_sys->psz_vfilters[p_sys->i_vfilters],
-                                   &p_sys->p_vfilters_cfg[p_sys->i_vfilters],
-                                   psz_parser );
-            p_sys->i_vfilters++;
-            if( psz_parser != NULL && *psz_parser != '\0' ) psz_parser++;
-        }
-    }
-    free( val.psz_string );
-    if( p_sys->i_vfilters < TRANSCODE_FILTERS-1 )
-    {
-        p_sys->psz_vfilters[p_sys->i_vfilters] = NULL;
-        p_sys->p_vfilters_cfg[p_sys->i_vfilters] = NULL;
+        free( val.psz_string );
+        p_sys->psz_vf2 = NULL;
     }
 
     var_Get( p_stream, SOUT_CFG_PREFIX "deinterlace", &val );
@@ -672,80 +642,25 @@ static void Close( vlc_object_t * p_this )
 
     sout_StreamDelete( p_sys->p_out );
 
-    while( p_sys->i_afilters )
-    {
-        p_sys->i_afilters--;
-        free( p_sys->psz_afilters[p_sys->i_afilters] );
-        free( p_sys->p_afilters_cfg[p_sys->i_afilters] );
-    }
-
-    while( p_sys->p_audio_cfg != NULL )
-    {
-        config_chain_t *p_next = p_sys->p_audio_cfg->p_next;
-
-        free( p_sys->p_audio_cfg->psz_name );
-        free( p_sys->p_audio_cfg->psz_value );
-        free( p_sys->p_audio_cfg );
+    free( p_sys->psz_af2 );
 
-        p_sys->p_audio_cfg = p_next;
-    }
+    config_ChainDestroy( p_sys->p_audio_cfg );
     free( p_sys->psz_aenc );
 
-    while( p_sys->i_vfilters )
-    {
-        p_sys->i_vfilters--;
-        free( p_sys->psz_vfilters[p_sys->i_vfilters] );
-        free( p_sys->p_vfilters_cfg[p_sys->i_vfilters] );
-    }
-
-    while( p_sys->p_video_cfg != NULL )
-    {
-        config_chain_t *p_next = p_sys->p_video_cfg->p_next;
-
-        free( p_sys->p_video_cfg->psz_name );
-        free( p_sys->p_video_cfg->psz_value );
-        free( p_sys->p_video_cfg );
+    free( p_sys->psz_vf2 );
 
-        p_sys->p_video_cfg = p_next;
-    }
+    config_ChainDestroy( p_sys->p_video_cfg );
     free( p_sys->psz_venc );
 
-    while( p_sys->p_deinterlace_cfg != NULL )
-    {
-        config_chain_t *p_next = p_sys->p_deinterlace_cfg->p_next;
-
-        free( p_sys->p_deinterlace_cfg->psz_name );
-        free( p_sys->p_deinterlace_cfg->psz_value );
-        free( p_sys->p_deinterlace_cfg );
-
-        p_sys->p_deinterlace_cfg = p_next;
-    }
+    config_ChainDestroy( p_sys->p_deinterlace_cfg );
     free( p_sys->psz_deinterlace );
 
-    while( p_sys->p_spu_cfg != NULL )
-    {
-        config_chain_t *p_next = p_sys->p_spu_cfg->p_next;
-
-        free( p_sys->p_spu_cfg->psz_name );
-        free( p_sys->p_spu_cfg->psz_value );
-        free( p_sys->p_spu_cfg );
-
-        p_sys->p_spu_cfg = p_next;
-    }
+    config_ChainDestroy( p_sys->p_spu_cfg );
     free( p_sys->psz_senc );
 
     if( p_sys->p_spu ) spu_Destroy( p_sys->p_spu );
 
-    while( p_sys->p_osd_cfg != NULL )
-    {
-        config_chain_t *p_next = p_sys->p_osd_cfg->p_next;
-
-        free( p_sys->p_osd_cfg->psz_name );
-        free( p_sys->p_osd_cfg->psz_value );
-        free( p_sys->p_osd_cfg );
-
-        p_sys->p_osd_cfg = p_next;
-    }
+    config_ChainDestroy( p_sys->p_osd_cfg );
     free( p_sys->psz_osdenc );
 
     vlc_object_release( p_sys );
@@ -753,7 +668,7 @@ static void Close( vlc_object_t * p_this )
 
 struct sout_stream_id_t
 {
-    vlc_fourcc_t  b_transcode;
+    bool            b_transcode;
 
     /* id of the out stream */
     void *id;
@@ -762,11 +677,9 @@ struct sout_stream_id_t
     decoder_t       *p_decoder;
 
     /* Filters */
-    filter_t        *pp_filter[TRANSCODE_FILTERS];
-    int             i_filter;
+    filter_chain_t  *p_f_chain;
     /* User specified filters */
-    filter_t        *pp_ufilter[TRANSCODE_FILTERS];
-    int             i_ufilter;
+    filter_chain_t  *p_uf_chain;
 
     /* Encoder */
     encoder_t       *p_encoder;
@@ -780,13 +693,9 @@ static sout_stream_id_t *Add( sout_stream_t *p_stream, es_format_t *p_fmt )
     sout_stream_sys_t *p_sys = p_stream->p_sys;
     sout_stream_id_t *id;
 
-    id = malloc( sizeof( sout_stream_id_t ) );
+    id = calloc( 1, sizeof( sout_stream_id_t ) );
     if( !id )
-    {
-        msg_Err( p_stream, "out of memory" );
         goto error;
-    }
-    memset( id, 0, sizeof(sout_stream_id_t) );
 
     id->id = NULL;
     id->p_decoder = NULL;
@@ -795,22 +704,16 @@ static sout_stream_id_t *Add( sout_stream_t *p_stream, es_format_t *p_fmt )
     /* Create decoder object */
     id->p_decoder = vlc_object_create( p_stream, VLC_OBJECT_DECODER );
     if( !id->p_decoder )
-    {
-        msg_Err( p_stream, "out of memory" );
         goto error;
-    }
     vlc_object_attach( id->p_decoder, p_stream );
     id->p_decoder->p_module = NULL;
     id->p_decoder->fmt_in = *p_fmt;
     id->p_decoder->b_pace_control = true;
 
     /* Create encoder object */
-    id->p_encoder = vlc_object_create( p_stream, VLC_OBJECT_ENCODER );
+    id->p_encoder = sout_EncoderCreate( p_stream );
     if( !id->p_encoder )
-    {
-        msg_Err( p_stream, "out of memory" );
         goto error;
-    }
     vlc_object_attach( id->p_encoder, p_stream );
     id->p_encoder->p_module = NULL;
 
@@ -862,7 +765,7 @@ static sout_stream_id_t *Add( sout_stream_t *p_stream, es_format_t *p_fmt )
         }
 
         /* Open output stream */
-        id->id = p_sys->p_out->pf_add( p_sys->p_out, &id->p_encoder->fmt_out );
+        id->id = sout_StreamIdAdd( p_sys->p_out, &id->p_encoder->fmt_out );
         id->b_transcode = true;
 
         if( !id->id )
@@ -923,7 +826,7 @@ static sout_stream_id_t *Add( sout_stream_t *p_stream, es_format_t *p_fmt )
         }
 
         /* open output stream */
-        id->id = p_sys->p_out->pf_add( p_sys->p_out, &id->p_encoder->fmt_out );
+        id->id = sout_StreamIdAdd( p_sys->p_out, &id->p_encoder->fmt_out );
         id->b_transcode = true;
 
         if( !id->id )
@@ -966,7 +869,7 @@ static sout_stream_id_t *Add( sout_stream_t *p_stream, es_format_t *p_fmt )
     {
         msg_Dbg( p_stream, "not transcoding a stream (fcc=`%4.4s')",
                  (char*)&p_fmt->i_codec );
-        id->id = p_sys->p_out->pf_add( p_sys->p_out, p_fmt );
+        id->id = sout_StreamIdAdd( p_sys->p_out, p_fmt );
         id->b_transcode = false;
 
         if( !id->id ) goto error;
@@ -974,23 +877,26 @@ static sout_stream_id_t *Add( sout_stream_t *p_stream, es_format_t *p_fmt )
 
     return id;
 
- error:
-    if( id->p_decoder )
+error:
+    if( id )
     {
-        vlc_object_detach( id->p_decoder );
-        vlc_object_release( id->p_decoder );
-        id->p_decoder = NULL;
-    }
+        if( id->p_decoder )
+        {
+            vlc_object_detach( id->p_decoder );
+            vlc_object_release( id->p_decoder );
+            id->p_decoder = NULL;
+        }
 
-    if( id->p_encoder )
-    {
-        vlc_object_detach( id->p_encoder );
-        es_format_Clean( &id->p_encoder->fmt_out );
-        vlc_object_release( id->p_encoder );
-        id->p_encoder = NULL;
-    }
+        if( id->p_encoder )
+        {
+            vlc_object_detach( id->p_encoder );
+            es_format_Clean( &id->p_encoder->fmt_out );
+            vlc_object_release( id->p_encoder );
+            id->p_encoder = NULL;
+        }
 
-    free( id );
+        free( id );
+    }
     return NULL;
 }
 
@@ -1017,7 +923,7 @@ static int Del( sout_stream_t *p_stream, sout_stream_id_t *id )
         }
     }
 
-    if( id->id ) p_sys->p_out->pf_del( p_sys->p_out, id->id );
+    if( id->id ) sout_StreamIdDel( p_sys->p_out, id->id );
 
     if( id->p_decoder )
     {
@@ -1044,12 +950,11 @@ static int Send( sout_stream_t *p_stream, sout_stream_id_t *id,
     sout_stream_sys_t *p_sys = p_stream->p_sys;
     block_t *p_out = NULL;
 
-    if( !id->b_transcode && id->id )
-    {
-        return p_sys->p_out->pf_send( p_sys->p_out, id->id, p_buffer );
-    }
-    else if( !id->b_transcode )
+    if( !id->b_transcode )
     {
+        if( id->id )
+            return sout_StreamIdSend( p_sys->p_out, id->id, p_buffer );
+
         block_Release( p_buffer );
         return VLC_EGENERIC;
     }
@@ -1091,7 +996,8 @@ static int Send( sout_stream_t *p_stream, sout_stream_id_t *id,
         break;
     }
 
-    if( p_out ) return p_sys->p_out->pf_send( p_sys->p_out, id->id, p_out );
+    if( p_out )
+        return sout_StreamIdSend( p_sys->p_out, id->id, p_out );
     return VLC_SUCCESS;
 }
 
@@ -1136,79 +1042,114 @@ static inline void audio_timer_close( encoder_t * p_encoder )
  * decoder reencoder part
  ****************************************************************************/
 
-static int audio_BitsPerSample( vlc_fourcc_t i_format )
+static block_t *transcode_audio_alloc( filter_t *p_filter, int size )
 {
-    switch( i_format )
-    {
-    case VLC_FOURCC('u','8',' ',' '):
-    case VLC_FOURCC('s','8',' ',' '):
-        return 8;
+    VLC_UNUSED( p_filter );
+    return block_Alloc( size );
+}
 
-    case VLC_FOURCC('u','1','6','l'):
-    case VLC_FOURCC('s','1','6','l'):
-    case VLC_FOURCC('u','1','6','b'):
-    case VLC_FOURCC('s','1','6','b'):
-        return 16;
+static int transcode_audio_filter_allocation_init( filter_t *p_filter,
+                                                   void *data )
+{
+    VLC_UNUSED(data);
+    p_filter->pf_audio_buffer_new = transcode_audio_alloc;
+    return VLC_SUCCESS;
+}
 
-    case VLC_FOURCC('u','2','4','l'):
-    case VLC_FOURCC('s','2','4','l'):
-    case VLC_FOURCC('u','2','4','b'):
-    case VLC_FOURCC('s','2','4','b'):
-        return 24;
+static bool transcode_audio_filter_needed( const es_format_t *p_fmt1, const es_format_t *p_fmt2 )
+{
+    if( p_fmt1->i_codec != p_fmt2->i_codec ||
+        p_fmt1->audio.i_channels != p_fmt2->audio.i_channels ||
+        p_fmt1->audio.i_rate != p_fmt2->audio.i_rate )
+        return true;
+    return false;
+}
+static int transcode_audio_filter_chain_build( sout_stream_t *p_stream, filter_chain_t *p_chain,
+                                               const es_format_t *p_dst, const es_format_t *p_src )
+{
+    if( !transcode_audio_filter_needed( p_dst, p_src ) )
+        return VLC_SUCCESS;
 
-    case VLC_FOURCC('u','3','2','l'):
-    case VLC_FOURCC('s','3','2','l'):
-    case VLC_FOURCC('u','3','2','b'):
-    case VLC_FOURCC('s','3','2','b'):
-    case VLC_FOURCC('f','l','3','2'):
-    case VLC_FOURCC('f','i','3','2'):
-        return 32;
+    es_format_t current = *p_src;
 
-    case VLC_FOURCC('f','l','6','4'):
-        return 64;
-    }
+    msg_Dbg( p_stream, "Looking for filter "
+             "(%4.4s->%4.4s, channels %d->%d, rate %d->%d)",
+         (const char *)&p_src->i_codec,
+         (const char *)&p_dst->i_codec,
+         p_src->audio.i_channels,
+         p_dst->audio.i_channels,
+         p_src->audio.i_rate,
+         p_dst->audio.i_rate );
 
-    return 0;
-}
+    /* If any filter is needed, convert to fl32 */
+    if( current.i_codec != VLC_FOURCC('f','l','3','2') )
+    {
+        /* First step, convert to fl32 */
+        current.i_codec =
+        current.audio.i_format = VLC_FOURCC('f','l','3','2');
 
-static block_t *transcode_audio_alloc (filter_t *filter, int size)
-{
-    return block_New (filter, size);
-}
+        if( !filter_chain_AppendFilter( p_chain, NULL, NULL, NULL, &current ) )
+        {
+            msg_Err( p_stream, "Failed to find conversion filter to fl32" );
+            return VLC_EGENERIC;
+        }
+        current = *filter_chain_GetFmtOut( p_chain );
+    }
 
-static filter_t *transcode_audio_filter_new( sout_stream_t *p_stream,
-                                             sout_stream_id_t *id,
-                                             es_format_t *p_fmt_in,
-                                             es_format_t *p_fmt_out,
-                                             char *psz_name )
-{
-    sout_stream_sys_t *p_sys = p_stream->p_sys;
-    filter_t *p_filter = vlc_object_create( p_stream, VLC_OBJECT_FILTER );
+    /* Fix sample rate */
+    if( current.audio.i_rate != p_dst->audio.i_rate )
+    {
+        current.audio.i_rate = p_dst->audio.i_rate;
+        if( !filter_chain_AppendFilter( p_chain, NULL, NULL, NULL, &current ) )
+        {
+            msg_Err( p_stream, "Failed to find conversion filter for resampling" );
+            return VLC_EGENERIC;
+        }
+        current = *filter_chain_GetFmtOut( p_chain );
+    }
 
-    vlc_object_attach( p_filter, p_stream );
-    p_filter->pf_audio_buffer_new = transcode_audio_alloc;
+    /* Fix channels */
+    if( current.audio.i_channels != p_dst->audio.i_channels )
+    {
+        current.audio.i_channels = p_dst->audio.i_channels;
+        current.audio.i_physical_channels = p_dst->audio.i_physical_channels;
+        current.audio.i_original_channels = p_dst->audio.i_original_channels;
 
-    p_filter->fmt_in = *p_fmt_in;
-    p_filter->fmt_out = *p_fmt_out;
-    if( psz_name )
-        p_filter->p_cfg = p_sys->p_afilters_cfg[id->i_ufilter];
+        if( ( !current.audio.i_physical_channels || !current.audio.i_original_channels ) &&
+            current.audio.i_channels < 6 )
+            current.audio.i_physical_channels =
+            current.audio.i_original_channels = pi_channels_maps[current.audio.i_channels];
 
-    p_filter->p_module = module_Need( p_filter, "audio filter2", psz_name,
-                                      true );
-    if( p_filter->p_module )
+        if( !filter_chain_AppendFilter( p_chain, NULL, NULL, NULL, &current ) )
+        {
+            msg_Err( p_stream, "Failed to find conversion filter for channel mixing" );
+            return VLC_EGENERIC;
+        }
+        current = *filter_chain_GetFmtOut( p_chain );
+    }
+
+    /* And last step, convert to the requested codec */
+    if( current.i_codec != p_dst->i_codec )
     {
-        p_filter->fmt_out.audio.i_bitspersample =
-            audio_BitsPerSample( p_filter->fmt_out.i_codec );
-        *p_fmt_in = p_filter->fmt_out;
+        current.i_codec = p_dst->i_codec;
+        if( !filter_chain_AppendFilter( p_chain, NULL, NULL, NULL, &current ) )
+        {
+            msg_Err( p_stream, "Failed to find conversion filter to %4.4s",
+                     (const char*)&p_dst->i_codec);
+            return VLC_EGENERIC;
+        }
+        current = *filter_chain_GetFmtOut( p_chain );
     }
-    else
+
+    if( transcode_audio_filter_needed( p_dst, &current ) )
     {
-        vlc_object_detach( p_filter );
-        vlc_object_release( p_filter );
-        p_filter = 0;
+        /* Weird case, a filter has side effects, doomed */
+        msg_Err( p_stream, "Failed to create a valid audio filter chain" );
+        return VLC_EGENERIC;
     }
 
-    return p_filter;
+    msg_Dbg( p_stream, "Got complete audio filter chain" );
+    return VLC_SUCCESS;
 }
 
 static int transcode_audio_new( sout_stream_t *p_stream,
@@ -1216,7 +1157,6 @@ static int transcode_audio_new( sout_stream_t *p_stream,
 {
     sout_stream_sys_t *p_sys = p_stream->p_sys;
     es_format_t fmt_last;
-    int i;
 
     /*
      * Open decoder
@@ -1232,14 +1172,14 @@ static int transcode_audio_new( sout_stream_t *p_stream,
     /* id->p_decoder->p_cfg = p_sys->p_audio_cfg; */
 
     id->p_decoder->p_module =
-        module_Need( id->p_decoder, "decoder", "$codec", 0 );
+        module_need( id->p_decoder, "decoder", "$codec", false );
     if( !id->p_decoder->p_module )
     {
         msg_Err( p_stream, "cannot find audio decoder" );
         return VLC_EGENERIC;
     }
     id->p_decoder->fmt_out.audio.i_bitspersample =
-        audio_BitsPerSample( id->p_decoder->fmt_out.i_codec );
+        aout_BitsPerSample( id->p_decoder->fmt_out.i_codec );
     fmt_last = id->p_decoder->fmt_out;
     /* Fix AAC SBR changing number of channels and sampling rate */
     if( !(id->p_decoder->fmt_in.i_codec == VLC_FOURCC('m','p','4','a') &&
@@ -1256,11 +1196,7 @@ static int transcode_audio_new( sout_stream_t *p_stream,
                     id->p_decoder->fmt_out.i_codec );
     id->p_encoder->fmt_in.audio.i_format = id->p_decoder->fmt_out.i_codec;
 
-    if( ( id->p_encoder->fmt_out.i_codec == VLC_FOURCC('s','a','m','r') ) ||
-        ( id->p_encoder->fmt_out.i_codec == VLC_FOURCC('s','a','w','b') ) )
-         id->p_encoder->fmt_in.audio.i_rate = id->p_encoder->fmt_out.audio.i_rate;
-    else
-        id->p_encoder->fmt_in.audio.i_rate = fmt_last.audio.i_rate;
+    id->p_encoder->fmt_in.audio.i_rate = id->p_encoder->fmt_out.audio.i_rate;
     id->p_encoder->fmt_in.audio.i_physical_channels =
         id->p_encoder->fmt_out.audio.i_physical_channels;
     id->p_encoder->fmt_in.audio.i_original_channels =
@@ -1268,142 +1204,57 @@ static int transcode_audio_new( sout_stream_t *p_stream,
     id->p_encoder->fmt_in.audio.i_channels =
         id->p_encoder->fmt_out.audio.i_channels;
     id->p_encoder->fmt_in.audio.i_bitspersample =
-        audio_BitsPerSample( id->p_encoder->fmt_in.i_codec );
+        aout_BitsPerSample( id->p_encoder->fmt_in.i_codec );
 
     id->p_encoder->p_cfg = p_stream->p_sys->p_audio_cfg;
     id->p_encoder->p_module =
-        module_Need( id->p_encoder, "encoder", p_sys->psz_aenc, true );
+        module_need( id->p_encoder, "encoder", p_sys->psz_aenc, true );
     if( !id->p_encoder->p_module )
     {
         msg_Err( p_stream, "cannot find audio encoder (module:%s fourcc:%4.4s)",
                  p_sys->psz_aenc ? p_sys->psz_aenc : "any",
                  (char *)&p_sys->i_acodec );
-        module_Unneed( id->p_decoder, id->p_decoder->p_module );
+        module_unneed( id->p_decoder, id->p_decoder->p_module );
         id->p_decoder->p_module = NULL;
         return VLC_EGENERIC;
     }
     id->p_encoder->fmt_in.audio.i_format = id->p_encoder->fmt_in.i_codec;
     id->p_encoder->fmt_in.audio.i_bitspersample =
-        audio_BitsPerSample( id->p_encoder->fmt_in.i_codec );
-
-    /* Load conversion filters */
-    if( fmt_last.audio.i_channels != id->p_encoder->fmt_in.audio.i_channels ||
-        fmt_last.audio.i_rate != id->p_encoder->fmt_in.audio.i_rate )
-    {
-        /* We'll have to go through fl32 first */
-        es_format_t fmt_out = id->p_encoder->fmt_in;
-        fmt_out.i_codec = fmt_out.audio.i_format = VLC_FOURCC('f','l','3','2');
+        aout_BitsPerSample( id->p_encoder->fmt_in.i_codec );
 
-        id->pp_filter[id->i_filter] =
-            transcode_audio_filter_new( p_stream, id, &fmt_last, &fmt_out, NULL );
-
-        if( id->pp_filter[id->i_filter] ) id->i_filter++;
-    }
-
-    for( i = 0; i < TRANSCODE_FILTERS; i++ )
+    /* Load user specified audio filters */
+    if( p_sys->psz_af2 )
     {
-        if( (fmt_last.audio.i_channels !=
-            id->p_encoder->fmt_in.audio.i_channels) ||
-            (fmt_last.audio.i_rate != id->p_encoder->fmt_in.audio.i_rate) ||
-            (fmt_last.i_codec != id->p_encoder->fmt_in.i_codec) )
+        es_format_t fmt_fl32 = fmt_last;
+        fmt_fl32.i_codec =
+        fmt_fl32.audio.i_format = VLC_FOURCC('f','l','3','2');
+        if( transcode_audio_filter_chain_build( p_stream, id->p_uf_chain,
+                                                &fmt_fl32, &fmt_last ) )
         {
-            id->pp_filter[id->i_filter] =
-                transcode_audio_filter_new( p_stream, id, &fmt_last,
-                                            &id->p_encoder->fmt_in, NULL );
-
-            if( id->pp_filter[id->i_filter] )
-                id->i_filter++;
-            else
-                break;
-        }
-    }
-
-    /* Final checks to see if conversions were successful */
-    if( fmt_last.i_codec != id->p_encoder->fmt_in.i_codec )
-    {
-        msg_Err( p_stream, "no audio filter found (%4.4s->%4.4s)",
-                 (char *)&fmt_last.i_codec,
-                 (char *)&id->p_encoder->fmt_in.i_codec );
-        transcode_audio_close( id );
-        return VLC_EGENERIC;
-    }
-
-    /* Load user specified audio filters now */
-    for( i = 0; (i < p_sys->i_afilters) &&
-                (id->i_ufilter < TRANSCODE_FILTERS); i++ )
-    {
-        id->pp_ufilter[id->i_ufilter] =
-            transcode_audio_filter_new( p_stream, id, &fmt_last,
-                                        &id->p_encoder->fmt_in,
-                                        p_sys->psz_afilters[i] );
-
-        if( id->pp_ufilter[id->i_ufilter] )
-            id->i_ufilter++;
-        else
-            break;
-    }
-
-    if( fmt_last.audio.i_channels != id->p_encoder->fmt_in.audio.i_channels )
-    {
-#if 1
-        module_Unneed( id->p_encoder, id->p_encoder->p_module );
-        id->p_encoder->p_module = NULL;
-
-        /* This might work, but only if the encoder is restarted */
-        id->p_encoder->fmt_in.audio.i_channels = fmt_last.audio.i_channels;
-        id->p_encoder->fmt_out.audio.i_channels = fmt_last.audio.i_channels;
-
-        id->p_encoder->fmt_in.audio.i_physical_channels =
-            id->p_encoder->fmt_in.audio.i_original_channels =
-                fmt_last.audio.i_physical_channels;
-        id->p_encoder->fmt_out.audio.i_physical_channels =
-            id->p_encoder->fmt_out.audio.i_original_channels =
-                fmt_last.audio.i_physical_channels;
-
-        msg_Dbg( p_stream, "number of audio channels for mixing changed, "
-                 "trying to reopen the encoder for mixing %i to %i channels",
-                 fmt_last.audio.i_channels,
-                 id->p_encoder->fmt_in.audio.i_channels );
-
-        /* reload encoder */
-        id->p_encoder->p_cfg = p_stream->p_sys->p_audio_cfg;
-        id->p_encoder->p_module =
-            module_Need( id->p_encoder, "encoder", p_sys->psz_aenc, true );
-        if( !id->p_encoder->p_module )
-        {
-            msg_Err( p_stream, "cannot find audio encoder (module:%s fourcc:%4.4s)",
-                     p_sys->psz_aenc ? p_sys->psz_aenc : "any",
-                     (char *)&p_sys->i_acodec );
             transcode_audio_close( id );
             return VLC_EGENERIC;
         }
-        id->p_encoder->fmt_in.audio.i_format = id->p_encoder->fmt_in.i_codec;
-        id->p_encoder->fmt_in.audio.i_bitspersample =
-            audio_BitsPerSample( id->p_encoder->fmt_in.i_codec );
-#else
-        msg_Err( p_stream, "no audio filter found for mixing from"
-                 " %i to %i channels", fmt_last.audio.i_channels,
-                 id->p_encoder->fmt_in.audio.i_channels );
+        fmt_last = fmt_fl32;
 
-        transcode_audio_close( id );
-        return VLC_EGENERIC;
-#endif
+        id->p_uf_chain = filter_chain_New( p_stream, "audio filter2", false,
+                                           transcode_audio_filter_allocation_init, NULL, NULL );
+        filter_chain_Reset( id->p_uf_chain, &fmt_last, &fmt_fl32 );
+        if( filter_chain_AppendFromString( id->p_uf_chain, p_sys->psz_af2 ) > 0 )
+            fmt_last = *filter_chain_GetFmtOut( id->p_uf_chain );
     }
 
-    if( fmt_last.audio.i_rate != id->p_encoder->fmt_in.audio.i_rate )
+    /* Load conversion filters */
+    id->p_f_chain = filter_chain_New( p_stream, "audio filter2", true,
+                    transcode_audio_filter_allocation_init, NULL, NULL );
+    filter_chain_Reset( id->p_f_chain, &fmt_last, &id->p_encoder->fmt_in );
+
+    if( transcode_audio_filter_chain_build( p_stream, id->p_f_chain,
+                                            &id->p_encoder->fmt_in, &fmt_last ) )
     {
-        msg_Err( p_stream, "no audio filter found for resampling from"
-                 " %iHz to %iHz", fmt_last.audio.i_rate,
-                 id->p_encoder->fmt_in.audio.i_rate );
-#if 0
-        /* FIXME : this might work, but only if the encoder is restarted */
-        id->p_encoder->fmt_in.audio.i_rate = fmt_last.audio.i_rate;
-        id->p_encoder->fmt_out.audio.i_rate = fmt_last.audio.i_rate;
-#else
         transcode_audio_close( id );
         return VLC_EGENERIC;
-#endif
     }
+    fmt_last = id->p_encoder->fmt_in;
 
     /* FIXME: Hack for mp3 transcoding support */
     if( id->p_encoder->fmt_out.i_codec == VLC_FOURCC( 'm','p','3',' ' ) )
@@ -1414,38 +1265,27 @@ static int transcode_audio_new( sout_stream_t *p_stream,
 
 static void transcode_audio_close( sout_stream_id_t *id )
 {
-    int i;
-
     audio_timer_close( id->p_encoder );
 
     /* Close decoder */
     if( id->p_decoder->p_module )
-        module_Unneed( id->p_decoder, id->p_decoder->p_module );
+        module_unneed( id->p_decoder, id->p_decoder->p_module );
     id->p_decoder->p_module = NULL;
 
+    if( id->p_decoder->p_description )
+        vlc_meta_Delete( id->p_decoder->p_description );
+    id->p_decoder->p_description = NULL;
+
     /* Close encoder */
     if( id->p_encoder->p_module )
-        module_Unneed( id->p_encoder, id->p_encoder->p_module );
+        module_unneed( id->p_encoder, id->p_encoder->p_module );
     id->p_encoder->p_module = NULL;
 
     /* Close filters */
-    for( i = 0; i < id->i_filter; i++ )
-    {
-        vlc_object_detach( id->pp_filter[i] );
-        if( id->pp_filter[i]->p_module )
-            module_Unneed( id->pp_filter[i], id->pp_filter[i]->p_module );
-        vlc_object_release( id->pp_filter[i] );
-    }
-    id->i_filter = 0;
-
-    for( i = 0; i < id->i_ufilter; i++ )
-    {
-        vlc_object_detach( id->pp_ufilter[i] );
-        if( id->pp_ufilter[i]->p_module )
-            module_Unneed( id->pp_ufilter[i], id->pp_ufilter[i]->p_module );
-        vlc_object_release( id->pp_ufilter[i] );
-    }
-    id->i_ufilter = 0;
+    if( id->p_uf_chain )
+        filter_chain_Delete( id->p_uf_chain );
+    if( id->p_f_chain )
+        filter_chain_Delete( id->p_f_chain );
 }
 
 static int transcode_audio_process( sout_stream_t *p_stream,
@@ -1455,7 +1295,6 @@ static int transcode_audio_process( sout_stream_t *p_stream,
     sout_stream_sys_t *p_sys = p_stream->p_sys;
     aout_buffer_t *p_audio_buf;
     block_t *p_block, *p_audio_block;
-    int i;
     *out = NULL;
 
     while( (p_audio_buf = id->p_decoder->pf_decode_audio( id->p_decoder,
@@ -1487,21 +1326,13 @@ static int transcode_audio_process( sout_stream_t *p_stream,
         p_audio_block->i_samples = p_audio_buf->i_nb_samples;
 
         /* Run filter chain */
-        for( i = 0; i < id->i_filter; i++ )
+        if( id->p_uf_chain )
         {
-            p_audio_block =
-                id->pp_filter[i]->pf_audio_filter( id->pp_filter[i],
-                                                   p_audio_block );
-        }
-
-        /* Run user specified filter chain */
-        for( i = 0; i < id->i_ufilter; i++ )
-        {
-            p_audio_block =
-                id->pp_ufilter[i]->pf_audio_filter( id->pp_ufilter[i],
-                                                    p_audio_block );
+            p_audio_block = filter_chain_AudioFilter( id->p_uf_chain, p_audio_block );
+            assert( p_audio_block );
         }
 
+        p_audio_block = filter_chain_AudioFilter( id->p_f_chain, p_audio_block );
         assert( p_audio_block );
 
         p_audio_buf->p_buffer = p_audio_block->p_buffer;
@@ -1575,65 +1406,30 @@ static void audio_del_buffer( decoder_t *p_dec, aout_buffer_t *p_buffer )
  * video
  */
 
-static filter_t *transcode_video_filter_new( sout_stream_t *p_stream,
-                                             es_format_t *p_fmt_in,
-                                             es_format_t *p_fmt_out,
-                                             config_chain_t  *p_cfg,
-                                             const char *psz_name )
+static int transcode_video_filter_allocation_init( filter_t *p_filter,
+                                                   void *p_data )
 {
-    sout_stream_sys_t *p_sys = p_stream->p_sys;
-    filter_t *p_filter;
+    sout_stream_sys_t *p_sys = (sout_stream_sys_t*)p_data;
     int i;
 
-    if( !p_stream || !p_fmt_in || !p_fmt_out ) return NULL;
-
-    p_filter = vlc_object_create( p_stream, VLC_OBJECT_FILTER );
-    vlc_object_attach( p_filter, p_stream );
-
     p_filter->pf_vout_buffer_new = video_new_buffer_filter;
     p_filter->pf_vout_buffer_del = video_del_buffer_filter;
 
-    es_format_Copy( &p_filter->fmt_in,  p_fmt_in );
-    es_format_Copy( &p_filter->fmt_out, p_fmt_out );
-    p_filter->p_cfg = p_cfg;
-
-    p_filter->p_module = module_Need( p_filter, "video filter2",
-                                      psz_name, true );
-    if( !p_filter->p_module )
-    {
-        msg_Dbg( p_stream, "no video filter found" );
-        vlc_object_detach( p_filter );
-        vlc_object_release( p_filter );
-        return NULL;
-    }
-
     p_filter->p_owner = malloc( sizeof(filter_owner_sys_t) );
     if( !p_filter->p_owner )
-    {
-        module_Unneed( p_filter,p_filter->p_module );
-        vlc_object_detach( p_filter );
-        vlc_object_release( p_filter );
-        return NULL;
-    }
+        return VLC_EGENERIC;
 
     for( i = 0; i < PICTURE_RING_SIZE; i++ )
         p_filter->p_owner->pp_pics[i] = 0;
     p_filter->p_owner->p_sys = p_sys;
 
-    return p_filter;
+    return VLC_SUCCESS;
 }
 
-static void transcode_video_filter_close( sout_stream_t *p_stream,
-                                          filter_t *p_filter )
+static void transcode_video_filter_allocation_clear( filter_t *p_filter )
 {
     int j;
 
-    if( !p_stream || !p_filter ) return;
-
-    vlc_object_detach( p_filter );
-    if( p_filter->p_module )
-        module_Unneed( p_filter, p_filter->p_module );
-
     /* Clean-up pictures ring buffer */
     for( j = 0; j < PICTURE_RING_SIZE; j++ )
     {
@@ -1642,8 +1438,6 @@ static void transcode_video_filter_close( sout_stream_t *p_stream,
                               p_filter->p_owner->pp_pics[j] );
     }
     free( p_filter->p_owner );
-    vlc_object_release( p_filter );
-    p_filter = NULL;
 }
 
 static int transcode_video_new( sout_stream_t *p_stream, sout_stream_id_t *id )
@@ -1665,17 +1459,21 @@ static int transcode_video_new( sout_stream_t *p_stream, sout_stream_id_t *id )
     id->p_decoder->pf_picture_link    = video_link_picture_decoder;
     id->p_decoder->pf_picture_unlink  = video_unlink_picture_decoder;
     id->p_decoder->p_owner = malloc( sizeof(decoder_owner_sys_t) );
+    if( !id->p_decoder->p_owner )
+        return VLC_EGENERIC;
+
     for( i = 0; i < PICTURE_RING_SIZE; i++ )
         id->p_decoder->p_owner->pp_pics[i] = 0;
     id->p_decoder->p_owner->p_sys = p_sys;
     /* id->p_decoder->p_cfg = p_sys->p_video_cfg; */
 
     id->p_decoder->p_module =
-        module_Need( id->p_decoder, "decoder", "$codec", 0 );
+        module_need( id->p_decoder, "decoder", "$codec", false );
 
     if( !id->p_decoder->p_module )
     {
         msg_Err( p_stream, "cannot find video decoder" );
+        free( id->p_decoder->p_owner );
         return VLC_EGENERIC;
     }
 
@@ -1694,11 +1492,15 @@ static int transcode_video_new( sout_stream_t *p_stream, sout_stream_id_t *id )
     /* The dimensions will be set properly later on.
      * Just put sensible values so we can test an encoder is available. */
     id->p_encoder->fmt_in.video.i_width =
-        id->p_encoder->fmt_out.video.i_width ?:
-        id->p_decoder->fmt_in.video.i_width ?: 16;
+        id->p_encoder->fmt_out.video.i_width
+          ? id->p_encoder->fmt_out.video.i_width
+          : id->p_decoder->fmt_in.video.i_width
+            ? id->p_decoder->fmt_in.video.i_width : 16;
     id->p_encoder->fmt_in.video.i_height =
-        id->p_encoder->fmt_out.video.i_height ?:
-        id->p_decoder->fmt_in.video.i_height ?: 16;
+        id->p_encoder->fmt_out.video.i_height
+          ? id->p_encoder->fmt_out.video.i_height
+          : id->p_decoder->fmt_in.video.i_height
+            ? id->p_decoder->fmt_in.video.i_height : 16;
     id->p_encoder->fmt_in.video.i_frame_rate = ENC_FRAMERATE;
     id->p_encoder->fmt_in.video.i_frame_rate_base = ENC_FRAMERATE_BASE;
 
@@ -1706,20 +1508,21 @@ static int transcode_video_new( sout_stream_t *p_stream, sout_stream_id_t *id )
     id->p_encoder->p_cfg = p_sys->p_video_cfg;
 
     id->p_encoder->p_module =
-        module_Need( id->p_encoder, "encoder", p_sys->psz_venc, true );
+        module_need( id->p_encoder, "encoder", p_sys->psz_venc, true );
     if( !id->p_encoder->p_module )
     {
         msg_Err( p_stream, "cannot find video encoder (module:%s fourcc:%4.4s)",
                  p_sys->psz_venc ? p_sys->psz_venc : "any",
                  (char *)&p_sys->i_vcodec );
-        module_Unneed( id->p_decoder, id->p_decoder->p_module );
+        module_unneed( id->p_decoder, id->p_decoder->p_module );
         id->p_decoder->p_module = 0;
+        free( id->p_decoder->p_owner );
         return VLC_EGENERIC;
     }
 
     /* Close the encoder.
      * We'll open it only when we have the first frame. */
-    module_Unneed( id->p_encoder, id->p_encoder->p_module );
+    module_unneed( id->p_encoder, id->p_encoder->p_module );
     if( id->p_encoder->fmt_out.p_extra )
     {
         free( id->p_encoder->fmt_out.p_extra );
@@ -1734,18 +1537,18 @@ static int transcode_video_new( sout_stream_t *p_stream, sout_stream_id_t *id )
                            VLC_THREAD_PRIORITY_VIDEO;
         p_sys->id_video = id;
         vlc_mutex_init( &p_sys->lock_out );
-        vlc_cond_init( p_stream, &p_sys->cond );
+        vlc_cond_init( &p_sys->cond );
         memset( p_sys->pp_pics, 0, sizeof(p_sys->pp_pics) );
         p_sys->i_first_pic = 0;
         p_sys->i_last_pic = 0;
         p_sys->p_buffers = NULL;
         p_sys->b_die = p_sys->b_error = 0;
-        if( vlc_thread_create( p_sys, "encoder", EncoderThread, i_priority,
-                               false ) )
+        if( vlc_thread_create( p_sys, "encoder", EncoderThread, i_priority ) )
         {
             msg_Err( p_stream, "cannot spawn encoder thread" );
-            module_Unneed( id->p_decoder, id->p_decoder->p_module );
+            module_unneed( id->p_decoder, id->p_decoder->p_module );
             id->p_decoder->p_module = 0;
+            free( id->p_decoder->p_owner );
             return VLC_EGENERIC;
         }
     }
@@ -1753,34 +1556,34 @@ static int transcode_video_new( sout_stream_t *p_stream, sout_stream_id_t *id )
     return VLC_SUCCESS;
 }
 
-static int transcode_video_encoder_open( sout_stream_t *p_stream,
-                                         sout_stream_id_t *id )
+static void transcode_video_encoder_init( sout_stream_t *p_stream,
+                                          sout_stream_id_t *id )
 {
-     sout_stream_sys_t *p_sys = p_stream->p_sys;
+    sout_stream_sys_t *p_sys = p_stream->p_sys;
 
-     /* Calculate scaling
-      * width/height of source */
-     int i_src_width = id->p_decoder->fmt_out.video.i_width;
-     int i_src_height = id->p_decoder->fmt_out.video.i_height;
+    /* Calculate scaling
+     * width/height of source */
+    int i_src_width = id->p_decoder->fmt_out.video.i_width;
+    int i_src_height = id->p_decoder->fmt_out.video.i_height;
 
-     /* with/height scaling */
-     float f_scale_width = 1;
-     float f_scale_height = 1;
+    /* with/height scaling */
+    float f_scale_width = 1;
+    float f_scale_height = 1;
 
-     /* width/height of output stream */
-     int i_dst_width;
-     int i_dst_height;
+    /* width/height of output stream */
+    int i_dst_width;
+    int i_dst_height;
 
-     /* aspect ratio */
-     float f_aspect = (float)id->p_decoder->fmt_out.video.i_aspect /
-                             VOUT_ASPECT_FACTOR;
+    /* aspect ratio */
+    float f_aspect = (float)id->p_decoder->fmt_out.video.i_aspect /
+                            VOUT_ASPECT_FACTOR;
 
-     msg_Dbg( p_stream, "decoder aspect is %i:%i",
-                  id->p_decoder->fmt_out.video.i_aspect, VOUT_ASPECT_FACTOR );
+    msg_Dbg( p_stream, "decoder aspect is %i:%i",
+                 id->p_decoder->fmt_out.video.i_aspect, VOUT_ASPECT_FACTOR );
 
-     /* Change f_aspect from source frame to source pixel */
-     f_aspect = f_aspect * i_src_height / i_src_width;
-     msg_Dbg( p_stream, "source pixel aspect is %f:1", f_aspect );
+    /* Change f_aspect from source frame to source pixel */
+    f_aspect = f_aspect * i_src_height / i_src_width;
+    msg_Dbg( p_stream, "source pixel aspect is %f:1", f_aspect );
 
     /* Calculate scaling factor for specified parameters */
     if( id->p_encoder->fmt_out.video.i_width <= 0 &&
@@ -1855,11 +1658,15 @@ static int transcode_video_encoder_open( sout_stream_t *p_stream,
      f_aspect = f_aspect * i_dst_width / i_dst_height;
 
      /* Store calculated values */
-     id->p_encoder->fmt_out.video.i_width = i_dst_width;
-     id->p_encoder->fmt_out.video.i_height = i_dst_height;
+     id->p_encoder->fmt_out.video.i_width =
+     id->p_encoder->fmt_out.video.i_visible_width = i_dst_width;
+     id->p_encoder->fmt_out.video.i_height =
+     id->p_encoder->fmt_out.video.i_visible_height = i_dst_height;
 
-     id->p_encoder->fmt_in.video.i_width = i_dst_width;
-     id->p_encoder->fmt_in.video.i_height = i_dst_height;
+     id->p_encoder->fmt_in.video.i_width =
+     id->p_encoder->fmt_in.video.i_visible_width = i_dst_width;
+     id->p_encoder->fmt_in.video.i_height =
+     id->p_encoder->fmt_in.video.i_visible_height = i_dst_height;
 
      msg_Dbg( p_stream, "source %ix%i, destination %ix%i",
          i_src_width, i_src_height,
@@ -1907,8 +1714,21 @@ static int transcode_video_encoder_open( sout_stream_t *p_stream,
     msg_Dbg( p_stream, "encoder aspect is %i:%i",
              id->p_encoder->fmt_out.video.i_aspect, VOUT_ASPECT_FACTOR );
 
+    id->p_encoder->fmt_in.video.i_chroma = id->p_encoder->fmt_in.i_codec;
+}
+
+static int transcode_video_encoder_open( sout_stream_t *p_stream,
+                                         sout_stream_id_t *id )
+{
+    sout_stream_sys_t *p_sys = p_stream->p_sys;
+
+
+    msg_Dbg( p_stream, "destination (after video filters) %ix%i",
+             id->p_encoder->fmt_in.video.i_width,
+             id->p_encoder->fmt_in.video.i_height );
+
     id->p_encoder->p_module =
-        module_Need( id->p_encoder, "encoder", p_sys->psz_venc, true );
+        module_need( id->p_encoder, "encoder", p_sys->psz_venc, true );
     if( !id->p_encoder->p_module )
     {
         msg_Err( p_stream, "cannot find video encoder (module:%s fourcc:%4.4s)",
@@ -1926,8 +1746,8 @@ static int transcode_video_encoder_open( sout_stream_t *p_stream,
         id->p_encoder->fmt_out.i_codec = VLC_FOURCC('m','p','g','v');
     }
 
-    id->id = p_stream->p_sys->p_out->pf_add( p_stream->p_sys->p_out,
-                                             &id->p_encoder->fmt_out );
+    id->id = sout_StreamIdAdd( p_stream->p_sys->p_out,
+                               &id->p_encoder->fmt_out );
     if( !id->id )
     {
         msg_Err( p_stream, "cannot add this stream" );
@@ -1957,7 +1777,9 @@ static void transcode_video_close( sout_stream_t *p_stream,
 
     /* Close decoder */
     if( id->p_decoder->p_module )
-        module_Unneed( id->p_decoder, id->p_decoder->p_module );
+        module_unneed( id->p_decoder, id->p_decoder->p_module );
+    if( id->p_decoder->p_description )
+        vlc_meta_Delete( id->p_decoder->p_description );
 
     if( id->p_decoder->p_owner )
     {
@@ -1973,22 +1795,13 @@ static void transcode_video_close( sout_stream_t *p_stream,
 
     /* Close encoder */
     if( id->p_encoder->p_module )
-        module_Unneed( id->p_encoder, id->p_encoder->p_module );
+        module_unneed( id->p_encoder, id->p_encoder->p_module );
 
     /* Close filters */
-    for( i = 0; i < id->i_filter; i++ )
-    {
-        transcode_video_filter_close( p_stream, id->pp_filter[i] );
-        id->pp_filter[i] = NULL;
-    }
-    id->i_filter = 0;
-
-    for( i = 0; i < id->i_ufilter; i++ )
-    {
-        transcode_video_filter_close( p_stream, id->pp_ufilter[i] );
-        id->pp_ufilter[i] = NULL;
-    }
-    id->i_ufilter = 0;
+    if( id->p_f_chain )
+        filter_chain_Delete( id->p_f_chain );
+    if( id->p_uf_chain )
+        filter_chain_Delete( id->p_uf_chain );
 }
 
 static int transcode_video_process( sout_stream_t *p_stream,
@@ -1996,7 +1809,7 @@ static int transcode_video_process( sout_stream_t *p_stream,
                                     block_t *in, block_t **out )
 {
     sout_stream_sys_t *p_sys = p_stream->p_sys;
-    int i_duplicate = 1, i;
+    int i_duplicate = 1;
     picture_t *p_pic, *p_pic2 = NULL;
     *out = NULL;
 
@@ -2059,26 +1872,22 @@ static int transcode_video_process( sout_stream_t *p_stream,
 
         if( !id->p_encoder->p_module )
         {
-            if( transcode_video_encoder_open( p_stream, id ) != VLC_SUCCESS )
-            {
-                p_pic->pf_release( p_pic );
-                transcode_video_close( p_stream, id );
-                id->b_transcode = false;
-                return VLC_EGENERIC;
-            }
+            transcode_video_encoder_init( p_stream, id );
+
+            id->p_f_chain = filter_chain_New( p_stream, "video filter2",
+                                              false,
+                               transcode_video_filter_allocation_init,
+                               transcode_video_filter_allocation_clear,
+                               p_stream->p_sys );
 
             /* Deinterlace */
             if( p_stream->p_sys->b_deinterlace )
             {
-                id->pp_filter[id->i_filter] =
-                    transcode_video_filter_new( p_stream,
-                            &id->p_decoder->fmt_out,
-                            &id->p_decoder->fmt_out,
-                            p_sys->p_deinterlace_cfg,
-                            p_sys->psz_deinterlace );
-
-                if( id->pp_filter[id->i_filter] )
-                    id->i_filter++;
+                filter_chain_AppendFilter( id->p_f_chain,
+                                           p_sys->psz_deinterlace,
+                                           p_sys->p_deinterlace_cfg,
+                                           &id->p_decoder->fmt_out,
+                                           &id->p_decoder->fmt_out );
             }
 
             /* Take care of the scaling and chroma conversions */
@@ -2089,38 +1898,45 @@ static int transcode_video_process( sout_stream_t *p_stream,
                 ( id->p_decoder->fmt_out.video.i_height !=
                   id->p_encoder->fmt_in.video.i_height ) )
             {
-                id->pp_filter[id->i_filter] =
-                    transcode_video_filter_new( p_stream,
-                        &id->p_decoder->fmt_out, &id->p_encoder->fmt_in,
-                        NULL, NULL );
-                if( !id->pp_filter[id->i_filter] )
-                {
-                    p_pic->pf_release( p_pic );
-                    transcode_video_close( p_stream, id );
-                    id->b_transcode = false;
-                    return VLC_EGENERIC;
-                }
-                id->i_filter++;
+                filter_chain_AppendFilter( id->p_f_chain,
+                                           NULL, NULL,
+                                           &id->p_decoder->fmt_out,
+                                           &id->p_encoder->fmt_in );
             }
 
-            for( i = 0; (i < p_sys->i_vfilters) && (id->i_ufilter < TRANSCODE_FILTERS); i++ )
+            if( p_sys->psz_vf2 )
             {
-                id->pp_ufilter[id->i_ufilter] =
-                    transcode_video_filter_new( p_stream,
-                            &id->p_decoder->fmt_out, &id->p_encoder->fmt_in,
-                            p_sys->p_vfilters_cfg[i], p_sys->psz_vfilters[i] );
-                if( id->pp_ufilter[id->i_filter] )
-                    id->i_ufilter++;
-                else
-                    id->pp_ufilter[id->i_ufilter] = NULL;
+                const es_format_t *p_fmt_out;
+                id->p_uf_chain = filter_chain_New( p_stream, "video filter2",
+                                                   true,
+                                   transcode_video_filter_allocation_init,
+                                   transcode_video_filter_allocation_clear,
+                                   p_stream->p_sys );
+                filter_chain_Reset( id->p_uf_chain, &id->p_encoder->fmt_in,
+                                    &id->p_encoder->fmt_in );
+                filter_chain_AppendFromString( id->p_uf_chain, p_sys->psz_vf2 );
+                p_fmt_out = filter_chain_GetFmtOut( id->p_uf_chain );
+                es_format_Copy( &id->p_encoder->fmt_in, p_fmt_out );
+                id->p_encoder->fmt_out.video.i_width =
+                    id->p_encoder->fmt_in.video.i_width;
+                id->p_encoder->fmt_out.video.i_height =
+                    id->p_encoder->fmt_in.video.i_height;
+                id->p_encoder->fmt_out.video.i_aspect =
+                    id->p_encoder->fmt_in.video.i_aspect;
+            }
+
+            if( transcode_video_encoder_open( p_stream, id ) != VLC_SUCCESS )
+            {
+                p_pic->pf_release( p_pic );
+                transcode_video_close( p_stream, id );
+                id->b_transcode = false;
+                return VLC_EGENERIC;
             }
         }
 
         /* Run filter chain */
-        for( i = 0; i < id->i_filter; i++ )
-        {
-            p_pic = id->pp_filter[i]->pf_video_filter(id->pp_filter[i], p_pic);
-        }
+        if( id->p_f_chain )
+            p_pic = filter_chain_VideoFilter( id->p_f_chain, p_pic );
 
         /*
          * Encoding
@@ -2130,53 +1946,43 @@ static int transcode_video_process( sout_stream_t *p_stream,
         if( p_sys->p_spu )
         {
             p_subpic = spu_SortSubpictures( p_sys->p_spu, p_pic->date,
-                       false /* Fixme: check if stream is paused */ );
+                       false /* Fixme: check if stream is paused */, false );
             /* TODO: get another pic */
         }
 
         /* Overlay subpicture */
         if( p_subpic )
         {
-            int i_scale_width, i_scale_height;
-            video_format_t *p_fmt;
+            video_format_t fmt;
 
-            i_scale_width = id->p_encoder->fmt_in.video.i_width * 1000 /
-                id->p_decoder->fmt_out.video.i_width;
-            i_scale_height = id->p_encoder->fmt_in.video.i_height * 1000 /
-                id->p_decoder->fmt_out.video.i_height;
-
-            if( p_pic->i_refcount && !id->i_filter )
+            if( p_pic->i_refcount && !filter_chain_GetLength( id->p_f_chain ) )
             {
                 /* We can't modify the picture, we need to duplicate it */
                 picture_t *p_tmp = video_new_buffer_decoder( id->p_decoder );
                 if( p_tmp )
                 {
-                    vout_CopyPicture( p_stream, p_tmp, p_pic );
+                    picture_Copy( p_tmp, p_pic );
                     p_pic->pf_release( p_pic );
                     p_pic = p_tmp;
                 }
             }
 
-            if( id->i_filter )
-                p_fmt = &id->pp_filter[id->i_filter -1]->fmt_out.video;
+            if( filter_chain_GetLength( id->p_f_chain ) > 0 )
+                fmt = filter_chain_GetFmtOut( id->p_f_chain )->video;
             else
-                p_fmt = &id->p_decoder->fmt_out.video;
+                fmt = id->p_decoder->fmt_out.video;
 
             /* FIXME (shouldn't have to be done here) */
-            p_fmt->i_sar_num = p_fmt->i_aspect *
-                p_fmt->i_height / p_fmt->i_width;
-            p_fmt->i_sar_den = VOUT_ASPECT_FACTOR;
+            fmt.i_sar_num = fmt.i_aspect * fmt.i_height / fmt.i_width;
+            fmt.i_sar_den = VOUT_ASPECT_FACTOR;
 
-            spu_RenderSubpictures( p_sys->p_spu, p_fmt, p_pic, p_pic, p_subpic,
-                                   i_scale_width, i_scale_height );
+            spu_RenderSubpictures( p_sys->p_spu, p_pic, &fmt,
+                                   p_subpic, &id->p_decoder->fmt_out.video, false );
         }
 
         /* Run user specified filter chain */
-        for( i = 0; i < id->i_ufilter; i++ )
-        {
-            p_pic = id->pp_ufilter[i]->pf_video_filter( id->pp_ufilter[i],
-                                                        p_pic );
-        }
+        if( id->p_uf_chain )
+            p_pic = filter_chain_VideoFilter( id->p_uf_chain, p_pic );
 
         if( p_sys->i_threads == 0 )
         {
@@ -2220,7 +2026,7 @@ static int transcode_video_process( sout_stream_t *p_stream,
                 p_pic2 = video_new_buffer_decoder( id->p_decoder );
                 if( p_pic2 != NULL )
                 {
-                    vout_CopyPicture( p_stream, p_pic2, p_pic );
+                    picture_Copy( p_pic2, p_pic );
                     p_pic2->date = i_pts;
                 }
             }
@@ -2259,12 +2065,14 @@ static int transcode_video_process( sout_stream_t *p_stream,
     return VLC_SUCCESS;
 }
 
-static int EncoderThread( sout_stream_sys_t *p_sys )
+static void* EncoderThread( vlc_object_t* p_this )
 {
+    sout_stream_sys_t *p_sys = (sout_stream_sys_t*)p_this;
     sout_stream_id_t *id = p_sys->id_video;
     picture_t *p_pic;
+    int canc = vlc_savecancel ();
 
-    while( !p_sys->b_die && !p_sys->b_error )
+    while( vlc_object_alive (p_sys) && !p_sys->b_error )
     {
         block_t *p_block;
 
@@ -2272,9 +2080,9 @@ static int EncoderThread( sout_stream_sys_t *p_sys )
         while( p_sys->i_last_pic == p_sys->i_first_pic )
         {
             vlc_cond_wait( &p_sys->cond, &p_sys->lock_out );
-            if( p_sys->b_die || p_sys->b_error ) break;
+            if( !vlc_object_alive (p_sys) || p_sys->b_error ) break;
         }
-        if( p_sys->b_die || p_sys->b_error )
+        if( !vlc_object_alive (p_sys) || p_sys->b_error )
         {
             vlc_mutex_unlock( &p_sys->lock_out );
             break;
@@ -2303,7 +2111,8 @@ static int EncoderThread( sout_stream_sys_t *p_sys )
     }
     block_ChainRelease( p_sys->p_buffers );
 
-    return 0;
+    vlc_restorecancel (canc);
+    return NULL;
 }
 
 struct picture_sys_t
@@ -2330,7 +2139,7 @@ static picture_t *video_new_buffer( vlc_object_t *p_this, picture_t **pp_ring,
     /* Find an empty space in the picture ring buffer */
     for( i = 0; i < PICTURE_RING_SIZE; i++ )
     {
-        if( pp_ring[i] != 0 && pp_ring[i]->i_status == DESTROYED_PICTURE )
+        if( pp_ring[i] != NULL && pp_ring[i]->i_status == DESTROYED_PICTURE )
         {
             pp_ring[i]->i_status = RESERVED_PICTURE;
             return pp_ring[i];
@@ -2338,7 +2147,7 @@ static picture_t *video_new_buffer( vlc_object_t *p_this, picture_t **pp_ring,
     }
     for( i = 0; i < PICTURE_RING_SIZE; i++ )
     {
-        if( pp_ring[i] == 0 ) break;
+        if( pp_ring[i] == NULL ) break;
     }
 
     if( i == PICTURE_RING_SIZE && p_sys->i_threads >= 1 )
@@ -2355,7 +2164,7 @@ static picture_t *video_new_buffer( vlc_object_t *p_this, picture_t **pp_ring,
         /* Find an empty space in the picture ring buffer */
         for( i = 0; i < PICTURE_RING_SIZE; i++ )
         {
-            if( pp_ring[i] != 0 && pp_ring[i]->i_status == DESTROYED_PICTURE )
+            if( pp_ring[i] != NULL && pp_ring[i]->i_status == DESTROYED_PICTURE )
             {
                 pp_ring[i]->i_status = RESERVED_PICTURE;
                 return pp_ring[i];
@@ -2363,7 +2172,7 @@ static picture_t *video_new_buffer( vlc_object_t *p_this, picture_t **pp_ring,
         }
         for( i = 0; i < PICTURE_RING_SIZE; i++ )
         {
-            if( pp_ring[i] == 0 ) break;
+            if( pp_ring[i] == NULL ) break;
         }
     }
 
@@ -2380,31 +2189,20 @@ static picture_t *video_new_buffer( vlc_object_t *p_this, picture_t **pp_ring,
         i = 0;
     }
 
-    p_pic = malloc( sizeof(picture_t) );
-    if( !p_pic ) return NULL;
     p_dec->fmt_out.video.i_chroma = p_dec->fmt_out.i_codec;
-    vout_AllocatePicture( VLC_OBJECT(p_dec), p_pic,
-                          p_dec->fmt_out.video.i_chroma,
-                          p_dec->fmt_out.video.i_width,
-                          p_dec->fmt_out.video.i_height,
-                          p_dec->fmt_out.video.i_aspect );
-
-    if( !p_pic->i_planes )
-    {
-        free( p_pic );
-        return NULL;
-    }
-
-    p_pic->pf_release = video_release_buffer;
-    p_pic->p_sys = malloc( sizeof(picture_sys_t) );
+    p_pic = picture_New( p_dec->fmt_out.video.i_chroma,
+                         p_dec->fmt_out.video.i_width,
+                         p_dec->fmt_out.video.i_height,
+                         p_dec->fmt_out.video.i_aspect );
+    if( !p_pic ) return NULL;
+    p_pic->p_sys = calloc( 1, sizeof(picture_sys_t) );
     if( !p_pic->p_sys )
     {
-        free( p_pic );
+        picture_Release( p_pic );
         return NULL;
     }
-
-    p_pic->p_sys->p_owner = p_this;
-    p_pic->i_status = RESERVED_PICTURE;
+    p_pic->pf_release = video_release_buffer;
+    p_pic->i_refcount = 0;
 
     pp_ring[i] = p_pic;
     return p_pic;
@@ -2428,6 +2226,7 @@ static void video_del_buffer( vlc_object_t *p_this, picture_t *p_pic )
     VLC_UNUSED(p_this);
     if( p_pic )
     {
+        free( p_pic->p_q );
         free( p_pic->p_data_orig );
         free( p_pic->p_sys );
         free( p_pic );
@@ -2439,6 +2238,7 @@ static void video_del_buffer_decoder( decoder_t *p_decoder, picture_t *p_pic )
     VLC_UNUSED(p_decoder);
     p_pic->i_refcount = 0;
     p_pic->i_status = DESTROYED_PICTURE;
+    picture_CleanupQuant( p_pic );
 }
 
 static void video_del_buffer_filter( filter_t *p_filter, picture_t *p_pic )
@@ -2446,6 +2246,7 @@ static void video_del_buffer_filter( filter_t *p_filter, picture_t *p_pic )
     VLC_UNUSED(p_filter);
     p_pic->i_refcount = 0;
     p_pic->i_status = DESTROYED_PICTURE;
+    picture_CleanupQuant( p_pic );
 }
 
 static void video_link_picture_decoder( decoder_t *p_dec, picture_t *p_pic )
@@ -2482,7 +2283,7 @@ static int transcode_spu_new( sout_stream_t *p_stream, sout_stream_id_t *id )
     /* id->p_decoder->p_cfg = p_sys->p_spu_cfg; */
 
     id->p_decoder->p_module =
-        module_Need( id->p_decoder, "decoder", "$codec", 0 );
+        module_need( id->p_decoder, "decoder", "$codec", false );
 
     if( !id->p_decoder->p_module )
     {
@@ -2500,11 +2301,11 @@ static int transcode_spu_new( sout_stream_t *p_stream, sout_stream_id_t *id )
         id->p_encoder->p_cfg = p_sys->p_spu_cfg;
 
         id->p_encoder->p_module =
-            module_Need( id->p_encoder, "encoder", p_sys->psz_senc, true );
+            module_need( id->p_encoder, "encoder", p_sys->psz_senc, true );
 
         if( !id->p_encoder->p_module )
         {
-            module_Unneed( id->p_decoder, id->p_decoder->p_module );
+            module_unneed( id->p_decoder, id->p_decoder->p_module );
             msg_Err( p_stream, "cannot find spu encoder (%s)", p_sys->psz_senc );
             return VLC_EGENERIC;
         }
@@ -2523,11 +2324,13 @@ static void transcode_spu_close( sout_stream_id_t *id)
 {
     /* Close decoder */
     if( id->p_decoder->p_module )
-        module_Unneed( id->p_decoder, id->p_decoder->p_module );
+        module_unneed( id->p_decoder, id->p_decoder->p_module );
+    if( id->p_decoder->p_description )
+        vlc_meta_Delete( id->p_decoder->p_description );
 
     /* Close encoder */
     if( id->p_encoder->p_module )
-        module_Unneed( id->p_encoder, id->p_encoder->p_module );
+        module_unneed( id->p_encoder, id->p_encoder->p_module );
 }
 
 static int transcode_spu_process( sout_stream_t *p_stream,
@@ -2572,14 +2375,14 @@ static int transcode_spu_process( sout_stream_t *p_stream,
 
 static subpicture_t *spu_new_buffer( decoder_t *p_dec )
 {
-    sout_stream_t *p_stream = (sout_stream_t *)p_dec->p_owner;
-    return spu_CreateSubpicture( p_stream->p_sys->p_spu );
+    VLC_UNUSED( p_dec );
+    return subpicture_New();
 }
 
 static void spu_del_buffer( decoder_t *p_dec, subpicture_t *p_subpic )
 {
-    sout_stream_t *p_stream = (sout_stream_t *)p_dec->p_owner;
-    spu_DestroySubpicture( p_stream->p_sys->p_spu, p_subpic );
+    VLC_UNUSED( p_dec );
+    subpicture_Delete( p_subpic );
 }
 
 /*
@@ -2609,7 +2412,7 @@ static int transcode_osd_new( sout_stream_t *p_stream, sout_stream_id_t *id )
         id->p_encoder->p_cfg = p_sys->p_osd_cfg;
 
         id->p_encoder->p_module =
-            module_Need( id->p_encoder, "encoder", p_sys->psz_osdenc, true );
+            module_need( id->p_encoder, "encoder", p_sys->psz_osdenc, true );
 
         if( !id->p_encoder->p_module )
         {
@@ -2618,7 +2421,7 @@ static int transcode_osd_new( sout_stream_t *p_stream, sout_stream_id_t *id )
         }
 
         /* open output stream */
-        id->id = p_sys->p_out->pf_add( p_sys->p_out, &id->p_encoder->fmt_out );
+        id->id = sout_StreamIdAdd( p_sys->p_out, &id->p_encoder->fmt_out );
         id->b_transcode = true;
 
         if( !id->id ) goto error;
@@ -2627,7 +2430,7 @@ static int transcode_osd_new( sout_stream_t *p_stream, sout_stream_id_t *id )
     {
         msg_Dbg( p_stream, "not transcoding a stream (fcc=`%4.4s')",
                  (char*)&id->p_decoder->fmt_out.i_codec );
-        id->id = p_sys->p_out->pf_add( p_sys->p_out, &id->p_decoder->fmt_out );
+        id->id = sout_StreamIdAdd( p_sys->p_out, &id->p_decoder->fmt_out );
         id->b_transcode = false;
 
         if( !id->id ) goto error;
@@ -2644,7 +2447,7 @@ static int transcode_osd_new( sout_stream_t *p_stream, sout_stream_id_t *id )
  error:
     msg_Err( p_stream, "starting osd encoding thread failed" );
     if( id->p_encoder->p_module )
-            module_Unneed( id->p_encoder, id->p_encoder->p_module );
+            module_unneed( id->p_encoder, id->p_encoder->p_module );
     p_sys->b_osd = false;
     return VLC_EGENERIC;
 }
@@ -2657,7 +2460,7 @@ static void transcode_osd_close( sout_stream_t *p_stream, sout_stream_id_t *id)
     if( id )
     {
         if( id->p_encoder->p_module )
-            module_Unneed( id->p_encoder, id->p_encoder->p_module );
+            module_unneed( id->p_encoder, id->p_encoder->p_module );
     }
     p_sys->b_osd = false;
 }
@@ -2672,7 +2475,7 @@ static int transcode_osd_process( sout_stream_t *p_stream,
     /* Check if we have a subpicture to send */
     if( p_sys->p_spu && in->i_dts > 0)
     {
-        p_subpic = spu_SortSubpictures( p_sys->p_spu, in->i_dts, false );
+        p_subpic = spu_SortSubpictures( p_sys->p_spu, in->i_dts, false, false );
     }
     else
     {
@@ -2695,7 +2498,7 @@ static int transcode_osd_process( sout_stream_t *p_stream,
         }
 
         p_block = id->p_encoder->pf_encode_sub( id->p_encoder, p_subpic );
-        spu_DestroySubpicture( p_sys->p_spu, p_subpic );
+        subpicture_Delete( p_subpic );
         if( p_block )
         {
             p_block->i_dts = p_block->i_pts = in->i_dts;