filter_chain: introduce dedicated filter_chain_NewVideo() for video filters
[vlc.git] / modules / stream_out / mosaic_bridge.c
1 /*****************************************************************************
2  * mosaic_bridge.c:
3  *****************************************************************************
4  * Copyright (C) 2004-2007 VLC authors and VideoLAN
5  * $Id$
6  *
7  * Authors: Antoine Cellerier <dionoea@videolan.org>
8  *          Christophe Massiot <massiot@via.ecp.fr>
9  *
10  * This program is free software; you can redistribute it and/or modify it
11  * under the terms of the GNU Lesser General Public License as published by
12  * the Free Software Foundation; either version 2.1 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18  * GNU Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public License
21  * along with this program; if not, write to the Free Software Foundation,
22  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23  *****************************************************************************/
24
25 /*****************************************************************************
26  * Preamble
27  *****************************************************************************/
28
29 #ifdef HAVE_CONFIG_H
30 # include "config.h"
31 #endif
32
33 #include <vlc_common.h>
34 #include <vlc_plugin.h>
35 #include <vlc_sout.h>
36 #include <vlc_block.h>
37 #include <vlc_codec.h>
38 #include <vlc_meta.h>
39
40 #include <vlc_image.h>
41 #include <vlc_filter.h>
42 #include <vlc_modules.h>
43
44 #include "../video_filter/mosaic.h"
45
46 /*****************************************************************************
47  * Local structures
48  *****************************************************************************/
49 struct sout_stream_sys_t
50 {
51     bridged_es_t *p_es;
52
53     decoder_t       *p_decoder;
54     image_handler_t *p_image; /* filter for resizing */
55     int i_height, i_width;
56     unsigned int i_sar_num, i_sar_den;
57     char *psz_id;
58     bool b_inited;
59
60     int i_chroma; /* force image format chroma */
61
62     filter_chain_t *p_vf2;
63 };
64
65 struct decoder_owner_sys_t
66 {
67     /* Current format in use by the output */
68     video_format_t video;
69 };
70
71 /*****************************************************************************
72  * Local prototypes
73  *****************************************************************************/
74 static int  Open    ( vlc_object_t * );
75 static void Close   ( vlc_object_t * );
76 static sout_stream_id_sys_t *Add ( sout_stream_t *, es_format_t * );
77 static int               Del ( sout_stream_t *, sout_stream_id_sys_t * );
78 static int               Send( sout_stream_t *, sout_stream_id_sys_t *, block_t * );
79
80 inline static void video_del_buffer_decoder( decoder_t *, picture_t * );
81 inline static void video_del_buffer_filter( filter_t *, picture_t * );
82
83 inline static picture_t *video_new_buffer_decoder( decoder_t * );
84 inline static picture_t *video_new_buffer_filter( filter_t * );
85 static picture_t *video_new_buffer( vlc_object_t *, decoder_owner_sys_t *,
86                                     es_format_t * );
87
88 static void video_link_picture_decoder( decoder_t *, picture_t * );
89 static void video_unlink_picture_decoder( decoder_t *, picture_t * );
90
91 static int HeightCallback( vlc_object_t *, char const *,
92                            vlc_value_t, vlc_value_t, void * );
93 static int WidthCallback( vlc_object_t *, char const *,
94                           vlc_value_t, vlc_value_t, void * );
95 static int alphaCallback( vlc_object_t *, char const *,
96                           vlc_value_t, vlc_value_t, void * );
97 static int xCallback( vlc_object_t *, char const *,
98                       vlc_value_t, vlc_value_t, void * );
99 static int yCallback( vlc_object_t *, char const *,
100                       vlc_value_t, vlc_value_t, void * );
101
102 /*****************************************************************************
103  * Module descriptor
104  *****************************************************************************/
105 #define ID_TEXT N_("ID")
106 #define ID_LONGTEXT N_( \
107     "Specify an identifier string for this subpicture" )
108
109 #define WIDTH_TEXT N_("Video width")
110 #define WIDTH_LONGTEXT N_( \
111     "Output video width." )
112 #define HEIGHT_TEXT N_("Video height")
113 #define HEIGHT_LONGTEXT N_( \
114     "Output video height." )
115 #define RATIO_TEXT N_("Sample aspect ratio")
116 #define RATIO_LONGTEXT N_( \
117     "Sample aspect ratio of the destination (1:1, 3:4, 2:3)." )
118
119 #define VFILTER_TEXT N_("Video filter")
120 #define VFILTER_LONGTEXT N_( \
121     "Video filters will be applied to the video stream." )
122
123 #define CHROMA_TEXT N_("Image chroma")
124 #define CHROMA_LONGTEXT N_( \
125     "Force the use of a specific chroma. Use YUVA if you're planning " \
126     "to use the Alphamask or Bluescreen video filter." )
127
128 #define ALPHA_TEXT N_("Transparency")
129 #define ALPHA_LONGTEXT N_( \
130     "Transparency of the mosaic picture." )
131
132 #define X_TEXT N_("X offset")
133 #define X_LONGTEXT N_( \
134     "X coordinate of the upper left corner in the mosaic if non negative." )
135
136 #define Y_TEXT N_("Y offset")
137 #define Y_LONGTEXT N_( \
138     "Y coordinate of the upper left corner in the mosaic if non negative." )
139
140 #define CFG_PREFIX "sout-mosaic-bridge-"
141
142 vlc_module_begin ()
143     set_shortname( N_( "Mosaic bridge" ) )
144     set_description(N_("Mosaic bridge stream output") )
145     set_capability( "sout stream", 0 )
146     add_shortcut( "mosaic-bridge" )
147
148     add_string( CFG_PREFIX "id", "Id", ID_TEXT, ID_LONGTEXT,
149                 false )
150     add_integer( CFG_PREFIX "width", 0, WIDTH_TEXT,
151                  WIDTH_LONGTEXT, true )
152     add_integer( CFG_PREFIX "height", 0, HEIGHT_TEXT,
153                  HEIGHT_LONGTEXT, true )
154     add_string( CFG_PREFIX "sar", "1:1", RATIO_TEXT,
155                 RATIO_LONGTEXT, false )
156     add_string( CFG_PREFIX "chroma", NULL, CHROMA_TEXT, CHROMA_LONGTEXT,
157                 false )
158
159     add_module_list( CFG_PREFIX "vfilter", "video filter2",
160                      NULL, VFILTER_TEXT, VFILTER_LONGTEXT, false )
161
162     add_integer_with_range( CFG_PREFIX "alpha", 255, 0, 255,
163                             ALPHA_TEXT, ALPHA_LONGTEXT, false )
164     add_integer( CFG_PREFIX "x", -1, X_TEXT, X_LONGTEXT, false )
165     add_integer( CFG_PREFIX "y", -1, Y_TEXT, Y_LONGTEXT, false )
166
167     set_callbacks( Open, Close )
168 vlc_module_end ()
169
170 static const char *const ppsz_sout_options[] = {
171     "id", "width", "height", "sar", "vfilter", "chroma", "alpha", "x", "y", NULL
172 };
173
174 /*****************************************************************************
175  * Open
176  *****************************************************************************/
177 static int Open( vlc_object_t *p_this )
178 {
179     sout_stream_t        *p_stream = (sout_stream_t *)p_this;
180     sout_stream_sys_t    *p_sys;
181     vlc_value_t           val;
182
183     config_ChainParse( p_stream, CFG_PREFIX, ppsz_sout_options,
184                        p_stream->p_cfg );
185
186     p_sys = malloc( sizeof( sout_stream_sys_t ) );
187     if( !p_sys )
188         return VLC_ENOMEM;
189
190     p_stream->p_sys = p_sys;
191     p_sys->b_inited = false;
192
193     p_sys->psz_id = var_CreateGetString( p_stream, CFG_PREFIX "id" );
194
195     p_sys->i_height =
196         var_CreateGetIntegerCommand( p_stream, CFG_PREFIX "height" );
197     var_AddCallback( p_stream, CFG_PREFIX "height", HeightCallback, p_stream );
198
199     p_sys->i_width =
200         var_CreateGetIntegerCommand( p_stream, CFG_PREFIX "width" );
201     var_AddCallback( p_stream, CFG_PREFIX "width", WidthCallback, p_stream );
202
203     var_Get( p_stream, CFG_PREFIX "sar", &val );
204     if( val.psz_string )
205     {
206         char *psz_parser = strchr( val.psz_string, ':' );
207
208         if( psz_parser )
209         {
210             *psz_parser++ = '\0';
211             p_sys->i_sar_num = atoi( val.psz_string );
212             p_sys->i_sar_den = atoi( psz_parser );
213             vlc_ureduce( &p_sys->i_sar_num, &p_sys->i_sar_den,
214                          p_sys->i_sar_num, p_sys->i_sar_den, 0 );
215         }
216         else
217         {
218             msg_Warn( p_stream, "bad aspect ratio %s", val.psz_string );
219             p_sys->i_sar_num = p_sys->i_sar_den = 1;
220         }
221
222         free( val.psz_string );
223     }
224     else
225     {
226         p_sys->i_sar_num = p_sys->i_sar_den = 1;
227     }
228
229     p_sys->i_chroma = 0;
230     val.psz_string = var_GetNonEmptyString( p_stream, CFG_PREFIX "chroma" );
231     if( val.psz_string && strlen( val.psz_string ) >= 4 )
232     {
233         memcpy( &p_sys->i_chroma, val.psz_string, 4 );
234         msg_Dbg( p_stream, "Forcing image chroma to 0x%.8x (%4.4s)", p_sys->i_chroma, (char*)&p_sys->i_chroma );
235     }
236     free( val.psz_string );
237
238 #define INT_COMMAND( a ) do { \
239     var_Create( p_stream, CFG_PREFIX #a, \
240                 VLC_VAR_INTEGER | VLC_VAR_DOINHERIT | VLC_VAR_ISCOMMAND ); \
241     var_AddCallback( p_stream, CFG_PREFIX #a, a ## Callback, \
242                      p_stream ); } while(0)
243     INT_COMMAND( alpha );
244     INT_COMMAND( x );
245     INT_COMMAND( y );
246
247 #undef INT_COMMAND
248
249     p_stream->pf_add    = Add;
250     p_stream->pf_del    = Del;
251     p_stream->pf_send   = Send;
252     p_stream->pace_nocontrol = true;
253
254     return VLC_SUCCESS;
255 }
256
257 /*****************************************************************************
258  * Close
259  *****************************************************************************/
260 static void Close( vlc_object_t * p_this )
261 {
262     sout_stream_t     *p_stream = (sout_stream_t*)p_this;
263     sout_stream_sys_t *p_sys = p_stream->p_sys;
264
265     /* Delete the callbacks */
266     var_DelCallback( p_stream, CFG_PREFIX "height", HeightCallback, p_stream );
267     var_DelCallback( p_stream, CFG_PREFIX "width", WidthCallback, p_stream );
268     var_DelCallback( p_stream, CFG_PREFIX "alpha", alphaCallback, p_stream );
269     var_DelCallback( p_stream, CFG_PREFIX "x", xCallback, p_stream );
270     var_DelCallback( p_stream, CFG_PREFIX "y", yCallback, p_stream );
271
272     free( p_sys->psz_id );
273
274     free( p_sys );
275 }
276
277 static sout_stream_id_sys_t * Add( sout_stream_t *p_stream, es_format_t *p_fmt )
278 {
279     sout_stream_sys_t *p_sys = p_stream->p_sys;
280     bridge_t *p_bridge;
281     bridged_es_t *p_es;
282     char *psz_chain;
283     int i;
284
285     if( p_sys->b_inited || p_fmt->i_cat != VIDEO_ES )
286         return NULL;
287
288     /* Create decoder object */
289     p_sys->p_decoder = vlc_object_create( p_stream, sizeof( decoder_t ) );
290     if( !p_sys->p_decoder )
291         return NULL;
292     p_sys->p_decoder->p_module = NULL;
293     p_sys->p_decoder->fmt_in = *p_fmt;
294     p_sys->p_decoder->b_pace_control = false;
295     p_sys->p_decoder->fmt_out = p_sys->p_decoder->fmt_in;
296     p_sys->p_decoder->fmt_out.i_extra = 0;
297     p_sys->p_decoder->fmt_out.p_extra = 0;
298     p_sys->p_decoder->pf_decode_video = 0;
299     p_sys->p_decoder->pf_vout_buffer_new = video_new_buffer_decoder;
300     p_sys->p_decoder->pf_vout_buffer_del = video_del_buffer_decoder;
301     p_sys->p_decoder->pf_picture_link    = video_link_picture_decoder;
302     p_sys->p_decoder->pf_picture_unlink  = video_unlink_picture_decoder;
303     p_sys->p_decoder->p_owner = malloc( sizeof(decoder_owner_sys_t) );
304     if( !p_sys->p_decoder->p_owner )
305     {
306         vlc_object_release( p_sys->p_decoder );
307         return NULL;
308     }
309
310     p_sys->p_decoder->p_owner->video = p_fmt->video;
311     //p_sys->p_decoder->p_cfg = p_sys->p_video_cfg;
312
313     p_sys->p_decoder->p_module =
314         module_need( p_sys->p_decoder, "decoder", "$codec", false );
315
316     if( !p_sys->p_decoder->p_module || !p_sys->p_decoder->pf_decode_video )
317     {
318         if( p_sys->p_decoder->p_module )
319         {
320             msg_Err( p_stream, "instanciated a non video decoder" );
321             module_unneed( p_sys->p_decoder, p_sys->p_decoder->p_module );
322         }
323         else
324         {
325             msg_Err( p_stream, "cannot find decoder" );
326         }
327         free( p_sys->p_decoder->p_owner );
328         vlc_object_release( p_sys->p_decoder );
329         return NULL;
330     }
331
332     p_sys->b_inited = true;
333     vlc_global_lock( VLC_MOSAIC_MUTEX );
334
335     p_bridge = GetBridge( p_stream );
336     if ( p_bridge == NULL )
337     {
338         vlc_object_t *p_libvlc = VLC_OBJECT( p_stream->p_libvlc );
339         vlc_value_t val;
340
341         p_bridge = xmalloc( sizeof( bridge_t ) );
342
343         var_Create( p_libvlc, "mosaic-struct", VLC_VAR_ADDRESS );
344         val.p_address = p_bridge;
345         var_Set( p_libvlc, "mosaic-struct", val );
346
347         p_bridge->i_es_num = 0;
348         p_bridge->pp_es = NULL;
349     }
350
351     for ( i = 0; i < p_bridge->i_es_num; i++ )
352     {
353         if ( p_bridge->pp_es[i]->b_empty )
354             break;
355     }
356
357     if ( i == p_bridge->i_es_num )
358     {
359         p_bridge->pp_es = xrealloc( p_bridge->pp_es,
360                           (p_bridge->i_es_num + 1) * sizeof(bridged_es_t *) );
361         p_bridge->i_es_num++;
362         p_bridge->pp_es[i] = xmalloc( sizeof(bridged_es_t) );
363     }
364
365     p_sys->p_es = p_es = p_bridge->pp_es[i];
366
367     p_es->i_alpha = var_GetInteger( p_stream, CFG_PREFIX "alpha" );
368     p_es->i_x = var_GetInteger( p_stream, CFG_PREFIX "x" );
369     p_es->i_y = var_GetInteger( p_stream, CFG_PREFIX "y" );
370
371     //p_es->fmt = *p_fmt;
372     p_es->psz_id = p_sys->psz_id;
373     p_es->p_picture = NULL;
374     p_es->pp_last = &p_es->p_picture;
375     p_es->b_empty = false;
376
377     vlc_global_unlock( VLC_MOSAIC_MUTEX );
378
379     if ( p_sys->i_height || p_sys->i_width )
380     {
381         p_sys->p_image = image_HandlerCreate( p_stream );
382     }
383     else
384     {
385         p_sys->p_image = NULL;
386     }
387
388     msg_Dbg( p_stream, "mosaic bridge id=%s pos=%d", p_es->psz_id, i );
389
390     /* Create user specified video filters */
391     psz_chain = var_GetNonEmptyString( p_stream, CFG_PREFIX "vfilter" );
392     msg_Dbg( p_stream, "psz_chain: %s", psz_chain );
393     if( psz_chain )
394     {
395         filter_owner_t owner = {
396             .sys = p_sys->p_decoder->p_owner,
397             .video = {
398                 .buffer_new = video_new_buffer_filter,
399                 .buffer_del = video_del_buffer_filter,
400             },
401         };
402
403         p_sys->p_vf2 = filter_chain_NewVideo( p_stream, false, &owner );
404         es_format_t fmt;
405         es_format_Copy( &fmt, &p_sys->p_decoder->fmt_out );
406         if( p_sys->i_chroma )
407             fmt.video.i_chroma = p_sys->i_chroma;
408         filter_chain_Reset( p_sys->p_vf2, &fmt, &fmt );
409         filter_chain_AppendFromString( p_sys->p_vf2, psz_chain );
410         free( psz_chain );
411     }
412     else
413     {
414         p_sys->p_vf2 = NULL;
415     }
416
417     return (sout_stream_id_sys_t *)p_sys;
418 }
419
420 static int Del( sout_stream_t *p_stream, sout_stream_id_sys_t *id )
421 {
422     VLC_UNUSED(id);
423     sout_stream_sys_t *p_sys = p_stream->p_sys;
424     bridge_t *p_bridge;
425     bridged_es_t *p_es;
426     bool b_last_es = true;
427     int i;
428
429     if( !p_sys->b_inited )
430         return VLC_SUCCESS;
431
432     if( p_sys->p_decoder != NULL )
433     {
434         decoder_owner_sys_t *p_owner = p_sys->p_decoder->p_owner;
435
436         if( p_sys->p_decoder->p_module )
437             module_unneed( p_sys->p_decoder, p_sys->p_decoder->p_module );
438         if( p_sys->p_decoder->p_description )
439             vlc_meta_Delete( p_sys->p_decoder->p_description );
440
441         vlc_object_release( p_sys->p_decoder );
442
443         free( p_owner );
444     }
445
446     /* Destroy user specified video filters */
447     if( p_sys->p_vf2 )
448         filter_chain_Delete( p_sys->p_vf2 );
449
450     vlc_global_lock( VLC_MOSAIC_MUTEX );
451
452     p_bridge = GetBridge( p_stream );
453     p_es = p_sys->p_es;
454
455     p_es->b_empty = true;
456     while ( p_es->p_picture )
457     {
458         picture_t *p_next = p_es->p_picture->p_next;
459         picture_Release( p_es->p_picture );
460         p_es->p_picture = p_next;
461     }
462
463     for ( i = 0; i < p_bridge->i_es_num; i++ )
464     {
465         if ( !p_bridge->pp_es[i]->b_empty )
466         {
467             b_last_es = false;
468             break;
469         }
470     }
471
472     if ( b_last_es )
473     {
474         vlc_object_t *p_libvlc = VLC_OBJECT( p_stream->p_libvlc );
475         for ( i = 0; i < p_bridge->i_es_num; i++ )
476             free( p_bridge->pp_es[i] );
477         free( p_bridge->pp_es );
478         free( p_bridge );
479         var_Destroy( p_libvlc, "mosaic-struct" );
480     }
481
482     vlc_global_unlock( VLC_MOSAIC_MUTEX );
483
484     if ( p_sys->p_image )
485     {
486         image_HandlerDelete( p_sys->p_image );
487     }
488
489     p_sys->b_inited = false;
490
491     return VLC_SUCCESS;
492 }
493
494 /*****************************************************************************
495  * PushPicture : push a picture in the mosaic-struct structure
496  *****************************************************************************/
497 static void PushPicture( sout_stream_t *p_stream, picture_t *p_picture )
498 {
499     sout_stream_sys_t *p_sys = p_stream->p_sys;
500     bridged_es_t *p_es = p_sys->p_es;
501
502     vlc_global_lock( VLC_MOSAIC_MUTEX );
503
504     *p_es->pp_last = p_picture;
505     p_picture->p_next = NULL;
506     p_es->pp_last = &p_picture->p_next;
507
508     vlc_global_unlock( VLC_MOSAIC_MUTEX );
509 }
510
511 static int Send( sout_stream_t *p_stream, sout_stream_id_sys_t *id,
512                  block_t *p_buffer )
513 {
514     sout_stream_sys_t *p_sys = p_stream->p_sys;
515     picture_t *p_pic;
516
517     if ( (sout_stream_sys_t *)id != p_sys )
518     {
519         block_ChainRelease( p_buffer );
520         return VLC_SUCCESS;
521     }
522
523     while ( (p_pic = p_sys->p_decoder->pf_decode_video( p_sys->p_decoder,
524                                                         &p_buffer )) )
525     {
526         picture_t *p_new_pic;
527
528         if( p_sys->i_height || p_sys->i_width )
529         {
530             video_format_t fmt_out, fmt_in;
531
532             memset( &fmt_in, 0, sizeof(video_format_t) );
533             memset( &fmt_out, 0, sizeof(video_format_t) );
534             fmt_in = p_sys->p_decoder->fmt_out.video;
535
536
537             if( p_sys->i_chroma )
538                 fmt_out.i_chroma = p_sys->i_chroma;
539             else
540                 fmt_out.i_chroma = VLC_CODEC_I420;
541
542             const unsigned i_fmt_in_aspect =
543                 (int64_t)VOUT_ASPECT_FACTOR *
544                 fmt_in.i_sar_num * fmt_in.i_width /
545                 (fmt_in.i_sar_den * fmt_in.i_height);
546             if ( !p_sys->i_height )
547             {
548                 fmt_out.i_width = p_sys->i_width;
549                 fmt_out.i_height = (p_sys->i_width * VOUT_ASPECT_FACTOR
550                     * p_sys->i_sar_num / p_sys->i_sar_den / i_fmt_in_aspect)
551                       & ~0x1;
552             }
553             else if ( !p_sys->i_width )
554             {
555                 fmt_out.i_height = p_sys->i_height;
556                 fmt_out.i_width = (p_sys->i_height * i_fmt_in_aspect
557                     * p_sys->i_sar_den / p_sys->i_sar_num / VOUT_ASPECT_FACTOR)
558                       & ~0x1;
559             }
560             else
561             {
562                 fmt_out.i_width = p_sys->i_width;
563                 fmt_out.i_height = p_sys->i_height;
564             }
565             fmt_out.i_visible_width = fmt_out.i_width;
566             fmt_out.i_visible_height = fmt_out.i_height;
567
568             p_new_pic = image_Convert( p_sys->p_image,
569                                        p_pic, &fmt_in, &fmt_out );
570             if( p_new_pic == NULL )
571             {
572                 msg_Err( p_stream, "image conversion failed" );
573                 picture_Release( p_pic );
574                 continue;
575             }
576         }
577         else
578         {
579             /* TODO: chroma conversion if needed */
580
581             p_new_pic = picture_New( p_pic->format.i_chroma,
582                                      p_pic->format.i_width, p_pic->format.i_height,
583                                      p_sys->p_decoder->fmt_out.video.i_sar_num,
584                                      p_sys->p_decoder->fmt_out.video.i_sar_den );
585             if( !p_new_pic )
586             {
587                 picture_Release( p_pic );
588                 msg_Err( p_stream, "image allocation failed" );
589                 continue;
590             }
591
592             picture_Copy( p_new_pic, p_pic );
593         }
594         picture_Release( p_pic );
595
596         if( p_sys->p_vf2 )
597             p_new_pic = filter_chain_VideoFilter( p_sys->p_vf2, p_new_pic );
598
599         PushPicture( p_stream, p_new_pic );
600     }
601
602     return VLC_SUCCESS;
603 }
604
605 inline static picture_t *video_new_buffer_decoder( decoder_t *p_dec )
606 {
607     return video_new_buffer( VLC_OBJECT( p_dec ),
608                              (decoder_owner_sys_t *)p_dec->p_owner,
609                              &p_dec->fmt_out );
610 }
611
612 inline static picture_t *video_new_buffer_filter( filter_t *p_filter )
613 {
614     return video_new_buffer( VLC_OBJECT( p_filter ),
615                              (decoder_owner_sys_t *)p_filter->owner.sys,
616                              &p_filter->fmt_out );
617 }
618
619 static picture_t *video_new_buffer( vlc_object_t *p_this,
620                                     decoder_owner_sys_t *p_sys,
621                                     es_format_t *fmt_out )
622 {
623     VLC_UNUSED(p_this);
624     if( fmt_out->video.i_width != p_sys->video.i_width ||
625         fmt_out->video.i_height != p_sys->video.i_height ||
626         fmt_out->video.i_chroma != p_sys->video.i_chroma ||
627         (int64_t)fmt_out->video.i_sar_num * p_sys->video.i_sar_den !=
628         (int64_t)fmt_out->video.i_sar_den * p_sys->video.i_sar_num )
629     {
630         vlc_ureduce( &fmt_out->video.i_sar_num,
631                      &fmt_out->video.i_sar_den,
632                      fmt_out->video.i_sar_num,
633                      fmt_out->video.i_sar_den, 0 );
634
635         if( !fmt_out->video.i_visible_width ||
636             !fmt_out->video.i_visible_height )
637         {
638             fmt_out->video.i_visible_width = fmt_out->video.i_width;
639             fmt_out->video.i_visible_height = fmt_out->video.i_height;
640         }
641
642         fmt_out->video.i_chroma = fmt_out->i_codec;
643         p_sys->video = fmt_out->video;
644     }
645
646     /* */
647     fmt_out->video.i_chroma = fmt_out->i_codec;
648
649     return picture_NewFromFormat( &fmt_out->video );
650 }
651
652 inline static void video_del_buffer_decoder( decoder_t *p_this,
653                                              picture_t *p_pic )
654 {
655     VLC_UNUSED(p_this);
656     picture_Release( p_pic );
657 }
658
659 inline static void video_del_buffer_filter( filter_t *p_this,
660                                             picture_t *p_pic )
661 {
662     VLC_UNUSED(p_this);
663     picture_Release( p_pic );
664 }
665
666 static void video_link_picture_decoder( decoder_t *p_dec, picture_t *p_pic )
667 {
668     VLC_UNUSED(p_dec);
669     picture_Hold( p_pic );
670 }
671
672 static void video_unlink_picture_decoder( decoder_t *p_dec, picture_t *p_pic )
673 {
674     VLC_UNUSED(p_dec);
675     picture_Release( p_pic );
676 }
677
678
679 /**********************************************************************
680  * Callback to update (some) params on the fly
681  **********************************************************************/
682 static int HeightCallback( vlc_object_t *p_this, char const *psz_var,
683                            vlc_value_t oldval, vlc_value_t newval,
684                            void *p_data )
685 {
686     VLC_UNUSED(p_this); VLC_UNUSED(oldval); VLC_UNUSED(psz_var);
687     sout_stream_t *p_stream = (sout_stream_t *)p_data;
688     sout_stream_sys_t *p_sys = p_stream->p_sys;
689
690     /* We create the handler before updating the value in p_sys
691      * so we don't have to worry about locking */
692     if( !p_sys->p_image && newval.i_int )
693         p_sys->p_image = image_HandlerCreate( p_stream );
694     p_sys->i_height = newval.i_int;
695
696     return VLC_SUCCESS;
697 }
698
699 static int WidthCallback( vlc_object_t *p_this, char const *psz_var,
700                            vlc_value_t oldval, vlc_value_t newval,
701                            void *p_data )
702 {
703     VLC_UNUSED(p_this); VLC_UNUSED(oldval); VLC_UNUSED(psz_var);
704     sout_stream_t *p_stream = (sout_stream_t *)p_data;
705     sout_stream_sys_t *p_sys = p_stream->p_sys;
706
707     /* We create the handler before updating the value in p_sys
708      * so we don't have to worry about locking */
709     if( !p_sys->p_image && newval.i_int )
710         p_sys->p_image = image_HandlerCreate( p_stream );
711     p_sys->i_width = newval.i_int;
712
713     return VLC_SUCCESS;
714 }
715
716 static int alphaCallback( vlc_object_t *p_this, char const *psz_var,
717                           vlc_value_t oldval, vlc_value_t newval,
718                           void *p_data )
719 {
720     VLC_UNUSED(p_this); VLC_UNUSED(oldval); VLC_UNUSED(psz_var);
721     sout_stream_t *p_stream = (sout_stream_t *)p_data;
722     sout_stream_sys_t *p_sys = p_stream->p_sys;
723
724     if( p_sys->p_es )
725         p_sys->p_es->i_alpha = newval.i_int;
726
727     return VLC_SUCCESS;
728 }
729
730 static int xCallback( vlc_object_t *p_this, char const *psz_var,
731                       vlc_value_t oldval, vlc_value_t newval,
732                       void *p_data )
733 {
734     VLC_UNUSED(p_this); VLC_UNUSED(oldval); VLC_UNUSED(psz_var);
735     sout_stream_t *p_stream = (sout_stream_t *)p_data;
736     sout_stream_sys_t *p_sys = p_stream->p_sys;
737
738     if( p_sys->p_es )
739         p_sys->p_es->i_x = newval.i_int;
740
741     return VLC_SUCCESS;
742 }
743
744 static int yCallback( vlc_object_t *p_this, char const *psz_var,
745                       vlc_value_t oldval, vlc_value_t newval,
746                       void *p_data )
747 {
748     VLC_UNUSED(p_this); VLC_UNUSED(oldval); VLC_UNUSED(psz_var);
749     sout_stream_t *p_stream = (sout_stream_t *)p_data;
750     sout_stream_sys_t *p_sys = p_stream->p_sys;
751
752     if( p_sys->p_es )
753         p_sys->p_es->i_y = newval.i_int;
754
755     return VLC_SUCCESS;
756 }