9d41808a93c563314586cb3e60948598e0b7c6a7
[vlc.git] / modules / spu / mosaic.c
1 /*****************************************************************************
2  * mosaic.c : Mosaic video plugin for vlc
3  *****************************************************************************
4  * Copyright (C) 2004-2008 VLC authors and VideoLAN
5  *
6  * Authors: Antoine Cellerier <dionoea at videolan dot org>
7  *          Christophe Massiot <massiot@via.ecp.fr>
8  *
9  * This program is free software; you can redistribute it and/or modify it
10  * under the terms of the GNU Lesser General Public License as published by
11  * the Free Software Foundation; either version 2.1 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17  * GNU Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public License
20  * along with this program; if not, write to the Free Software Foundation,
21  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22 *****************************************************************************/
23
24 /*****************************************************************************
25  * Preamble
26  *****************************************************************************/
27 #ifdef HAVE_CONFIG_H
28 # include "config.h"
29 #endif
30
31 #include <math.h>
32 #include <limits.h> /* INT_MAX */
33
34 #include <vlc_common.h>
35 #include <vlc_plugin.h>
36 #include <vlc_filter.h>
37 #include <vlc_image.h>
38 #include <vlc_subpicture.h>
39
40 #include "mosaic.h"
41
42 #define BLANK_DELAY  VLC_TICK_FROM_SEC(1)
43
44 /*****************************************************************************
45  * Local prototypes
46  *****************************************************************************/
47 static int  CreateFilter    ( filter_t * );
48 static void DestroyFilter   ( filter_t * );
49 static subpicture_t *Filter ( filter_t *, vlc_tick_t );
50
51 static int MosaicCallback   ( vlc_object_t *, char const *, vlc_value_t,
52                               vlc_value_t, void * );
53
54 /*****************************************************************************
55  * filter_sys_t : filter descriptor
56  *****************************************************************************/
57 typedef struct
58 {
59     vlc_mutex_t lock;         /* Internal filter lock */
60
61     image_handler_t *p_image;
62
63     int i_position;           /* Mosaic positioning method */
64     bool b_ar;          /* Do we keep the aspect ratio ? */
65     bool b_keep;        /* Do we keep the original picture format ? */
66     int i_width, i_height;    /* Mosaic height and width */
67     int i_cols, i_rows;       /* Mosaic rows and cols */
68     int i_align;              /* Mosaic alignment in background video */
69     int i_xoffset, i_yoffset; /* Top left corner offset */
70     int i_borderw, i_borderh; /* Border width/height between miniatures */
71     int i_alpha;              /* Subfilter alpha blending */
72
73     char **ppsz_order;        /* List of picture-ids */
74     int i_order_length;
75
76     int *pi_x_offsets;        /* List of substreams x offsets */
77     int *pi_y_offsets;        /* List of substreams y offsets */
78     int i_offsets_length;
79
80     vlc_tick_t i_delay;
81 } filter_sys_t;
82
83 /*****************************************************************************
84  * Module descriptor
85  *****************************************************************************/
86 #define ALPHA_TEXT N_("Transparency")
87 #define ALPHA_LONGTEXT N_( \
88         "Transparency of the mosaic foreground pictures. " \
89         "0 means transparent, 255 opaque (default)." )
90
91 #define HEIGHT_TEXT N_("Height")
92 #define HEIGHT_LONGTEXT N_( "Total height of the mosaic, in pixels." )
93 #define WIDTH_TEXT N_("Width")
94 #define WIDTH_LONGTEXT N_( "Total width of the mosaic, in pixels." )
95
96 #define XOFFSET_TEXT N_("Top left corner X coordinate")
97 #define XOFFSET_LONGTEXT N_( \
98         "X Coordinate of the top-left corner of the mosaic.")
99 #define YOFFSET_TEXT N_("Top left corner Y coordinate")
100 #define YOFFSET_LONGTEXT N_( \
101         "Y Coordinate of the top-left corner of the mosaic.")
102
103 #define BORDERW_TEXT N_("Border width")
104 #define BORDERW_LONGTEXT N_( \
105         "Width in pixels of the border between miniatures." )
106 #define BORDERH_TEXT N_("Border height")
107 #define BORDERH_LONGTEXT N_( \
108         "Height in pixels of the border between miniatures." )
109
110 #define ALIGN_TEXT N_("Mosaic alignment" )
111 #define ALIGN_LONGTEXT N_( \
112         "You can enforce the mosaic alignment on the video " \
113         "(0=center, 1=left, 2=right, 4=top, 8=bottom, you can " \
114         "also use combinations of these values, eg 6 = top-right).")
115
116 #define POS_TEXT N_("Positioning method")
117 #define POS_LONGTEXT N_( \
118         "Positioning method for the mosaic. auto: " \
119         "automatically choose the best number of rows and columns. " \
120         "fixed: use the user-defined number of rows and columns. " \
121         "offsets: use the user-defined offsets for each image." )
122
123 #define ROWS_TEXT N_("Number of rows")
124 #define ROWS_LONGTEXT N_( \
125         "Number of image rows in the mosaic (only used if " \
126         "positioning method is set to \"fixed\")." )
127
128 #define COLS_TEXT N_("Number of columns")
129 #define COLS_LONGTEXT N_( \
130         "Number of image columns in the mosaic (only used if " \
131         "positioning method is set to \"fixed\")." )
132
133 #define AR_TEXT N_("Keep aspect ratio")
134 #define AR_LONGTEXT N_( \
135         "Keep the original aspect ratio when resizing " \
136         "mosaic elements." )
137 #define KEEP_TEXT N_("Keep original size")
138 #define KEEP_LONGTEXT N_( \
139         "Keep the original size of mosaic elements." )
140
141 #define ORDER_TEXT N_("Elements order" )
142 #define ORDER_LONGTEXT N_( \
143         "You can enforce the order of the elements on " \
144         "the mosaic. You must give a comma-separated list of picture ID(s). " \
145         "These IDs are assigned in the \"mosaic-bridge\" module." )
146
147 #define OFFSETS_TEXT N_("Offsets in order" )
148 #define OFFSETS_LONGTEXT N_( \
149         "You can enforce the (x,y) offsets of the elements on the mosaic " \
150         "(only used if positioning method is set to \"offsets\"). You " \
151         "must give a comma-separated list of coordinates (eg: 10,10,150,10)." )
152
153 #define DELAY_TEXT N_("Delay")
154 #define DELAY_LONGTEXT N_( \
155         "Pictures coming from the mosaic elements will be delayed " \
156         "according to this value (in milliseconds). For high " \
157         "values you will need to raise caching at input.")
158
159 enum
160 {
161     position_auto = 0, position_fixed = 1, position_offsets = 2
162 };
163 static const int pi_pos_values[] = { 0, 1, 2 };
164 static const char *const ppsz_pos_descriptions[] =
165     { N_("auto"), N_("fixed"), N_("offsets") };
166
167 static const int pi_align_values[] = { 0, 1, 2, 4, 8, 5, 6, 9, 10 };
168 static const char *const ppsz_align_descriptions[] =
169      { N_("Center"), N_("Left"), N_("Right"), N_("Top"), N_("Bottom"),
170      N_("Top-Left"), N_("Top-Right"), N_("Bottom-Left"), N_("Bottom-Right") };
171
172 #define CFG_PREFIX "mosaic-"
173
174 vlc_module_begin ()
175     set_description( N_("Mosaic video sub source") )
176     set_shortname( N_("Mosaic") )
177     set_category( CAT_VIDEO )
178     set_subcategory( SUBCAT_VIDEO_SUBPIC)
179     set_callback_sub_source( CreateFilter, 0 )
180
181     add_integer_with_range( CFG_PREFIX "alpha", 255, 0, 255,
182                             ALPHA_TEXT, ALPHA_LONGTEXT, false )
183
184     add_integer( CFG_PREFIX "height", 100,
185                  HEIGHT_TEXT, HEIGHT_LONGTEXT, false )
186     add_integer( CFG_PREFIX "width", 100,
187                  WIDTH_TEXT, WIDTH_LONGTEXT, false )
188
189     add_integer( CFG_PREFIX "align", 5,
190                  ALIGN_TEXT, ALIGN_LONGTEXT, true)
191         change_integer_list( pi_align_values, ppsz_align_descriptions )
192
193     add_integer( CFG_PREFIX "xoffset", 0,
194                  XOFFSET_TEXT, XOFFSET_LONGTEXT, true )
195     add_integer( CFG_PREFIX "yoffset", 0,
196                  YOFFSET_TEXT, YOFFSET_LONGTEXT, true )
197
198     add_integer( CFG_PREFIX "borderw", 0,
199                  BORDERW_TEXT, BORDERW_LONGTEXT, true )
200     add_integer( CFG_PREFIX "borderh", 0,
201                  BORDERH_TEXT, BORDERH_LONGTEXT, true )
202
203     add_integer( CFG_PREFIX "position", 0,
204                  POS_TEXT, POS_LONGTEXT, false )
205         change_integer_list( pi_pos_values, ppsz_pos_descriptions )
206     add_integer( CFG_PREFIX "rows", 2,
207                  ROWS_TEXT, ROWS_LONGTEXT, false )
208     add_integer( CFG_PREFIX "cols", 2,
209                  COLS_TEXT, COLS_LONGTEXT, false )
210
211     add_bool( CFG_PREFIX "keep-aspect-ratio", false,
212               AR_TEXT, AR_LONGTEXT, false )
213     add_bool( CFG_PREFIX "keep-picture", false,
214               KEEP_TEXT, KEEP_LONGTEXT, false )
215
216     add_string( CFG_PREFIX "order", "",
217                 ORDER_TEXT, ORDER_LONGTEXT, false )
218
219     add_string( CFG_PREFIX "offsets", "",
220                 OFFSETS_TEXT, OFFSETS_LONGTEXT, false )
221
222     add_integer( CFG_PREFIX "delay", 0, DELAY_TEXT, DELAY_LONGTEXT,
223                  false )
224 vlc_module_end ()
225
226 static const char *const ppsz_filter_options[] = {
227     "alpha", "height", "width", "align", "xoffset", "yoffset",
228     "borderw", "borderh", "position", "rows", "cols",
229     "keep-aspect-ratio", "keep-picture", "order", "offsets",
230     "delay", NULL
231 };
232
233 /*****************************************************************************
234  * mosaic_ParseSetOffsets:
235  * parse the "--mosaic-offsets x1,y1,x2,y2,x3,y3" parameter
236  * and set the corresponding struct filter_sys_t entries.
237  *****************************************************************************/
238 static void mosaic_ParseSetOffsets( vlc_object_t *p_this,
239                                       filter_sys_t *p_sys,
240                                       char *psz_offsets )
241 {
242     if( *psz_offsets )
243     {
244         char *psz_end = NULL;
245         int i_index = 0;
246         do
247         {
248             i_index++;
249
250             p_sys->pi_x_offsets = xrealloc( p_sys->pi_x_offsets,
251                                                    i_index * sizeof(int) );
252             p_sys->pi_x_offsets[i_index - 1] = atoi( psz_offsets );
253             psz_end = strchr( psz_offsets, ',' );
254             psz_offsets = psz_end + 1;
255
256             p_sys->pi_y_offsets = xrealloc( p_sys->pi_y_offsets,
257                                                    i_index * sizeof(int) );
258             p_sys->pi_y_offsets[i_index - 1] = atoi( psz_offsets );
259             psz_end = strchr( psz_offsets, ',' );
260             psz_offsets = psz_end + 1;
261
262             msg_Dbg( p_this, CFG_PREFIX "offset: id %d, x=%d, y=%d",
263                      i_index, p_sys->pi_x_offsets[i_index - 1],
264                               p_sys->pi_y_offsets[i_index - 1]  );
265
266         } while( psz_end );
267         p_sys->i_offsets_length = i_index;
268     }
269 }
270 #define mosaic_ParseSetOffsets( a, b, c ) \
271             mosaic_ParseSetOffsets( VLC_OBJECT( a ), b, c )
272
273 static const struct vlc_filter_operations filter_ops = {
274     .source_sub = Filter, .close = DestroyFilter,
275 };
276
277 /*****************************************************************************
278  * CreateFiler: allocate mosaic video filter
279  *****************************************************************************/
280 static int CreateFilter( filter_t *p_filter )
281 {
282     filter_sys_t *p_sys;
283     char *psz_order, *_psz_order;
284     char *psz_offsets;
285     int i_index;
286     int i_command;
287
288     /* Allocate structure */
289     p_sys = p_filter->p_sys = malloc( sizeof( filter_sys_t ) );
290     if( p_sys == NULL )
291         return VLC_ENOMEM;
292
293     p_filter->ops = &filter_ops;
294
295     vlc_mutex_init( &p_sys->lock );
296     vlc_mutex_lock( &p_sys->lock );
297
298     config_ChainParse( p_filter, CFG_PREFIX, ppsz_filter_options,
299                        p_filter->p_cfg );
300
301 #define GET_VAR( name, min, max )                                           \
302     i_command = var_CreateGetIntegerCommand( p_filter, CFG_PREFIX #name );  \
303     p_sys->i_##name = VLC_CLIP( i_command, min, max );                \
304     var_AddCallback( p_filter, CFG_PREFIX #name, MosaicCallback, p_sys );
305
306     GET_VAR( width, 0, INT_MAX );
307     GET_VAR( height, 0, INT_MAX );
308     GET_VAR( xoffset, 0, INT_MAX );
309     GET_VAR( yoffset, 0, INT_MAX );
310
311     GET_VAR( align, 0, 10 );
312     if( p_sys->i_align == 3 || p_sys->i_align == 7 )
313         p_sys->i_align = 5;
314
315     GET_VAR( borderw, 0, INT_MAX );
316     GET_VAR( borderh, 0, INT_MAX );
317     GET_VAR( rows, 1, INT_MAX );
318     GET_VAR( cols, 1, INT_MAX );
319     GET_VAR( alpha, 0, 255 );
320     GET_VAR( position, 0, 2 );
321 #undef GET_VAR
322     i_command = var_CreateGetIntegerCommand( p_filter, CFG_PREFIX "delay" );
323     p_sys->i_delay = VLC_TICK_FROM_MS(VLC_CLIP( i_command, 0, INT_MAX ));
324     var_AddCallback( p_filter, CFG_PREFIX "delay", MosaicCallback, p_sys );
325
326     p_sys->b_ar = var_CreateGetBoolCommand( p_filter,
327                                             CFG_PREFIX "keep-aspect-ratio" );
328     var_AddCallback( p_filter, CFG_PREFIX "keep-aspect-ratio", MosaicCallback,
329                      p_sys );
330
331     p_sys->b_keep = var_CreateGetBoolCommand( p_filter,
332                                               CFG_PREFIX "keep-picture" );
333     if ( !p_sys->b_keep )
334     {
335         p_sys->p_image = image_HandlerCreate( p_filter );
336     }
337
338     p_sys->i_order_length = 0;
339     p_sys->ppsz_order = NULL;
340     psz_order = var_CreateGetStringCommand( p_filter, CFG_PREFIX "order" );
341     _psz_order = psz_order;
342     var_AddCallback( p_filter, CFG_PREFIX "order", MosaicCallback, p_sys );
343
344     if( *psz_order )
345     {
346         char *psz_end = NULL;
347         i_index = 0;
348         do
349         {
350             psz_end = strchr( psz_order, ',' );
351             i_index++;
352             p_sys->ppsz_order = xrealloc( p_sys->ppsz_order,
353                                                  i_index * sizeof(char *) );
354             p_sys->ppsz_order[i_index - 1] = strndup( psz_order,
355                                            psz_end - psz_order );
356             psz_order = psz_end+1;
357         } while( psz_end );
358         p_sys->i_order_length = i_index;
359     }
360
361     free( _psz_order );
362
363     /* Manage specific offsets for substreams */
364     psz_offsets = var_CreateGetStringCommand( p_filter, CFG_PREFIX "offsets" );
365     p_sys->i_offsets_length = 0;
366     p_sys->pi_x_offsets = NULL;
367     p_sys->pi_y_offsets = NULL;
368     mosaic_ParseSetOffsets( p_filter, p_sys, psz_offsets );
369     free( psz_offsets );
370     var_AddCallback( p_filter, CFG_PREFIX "offsets", MosaicCallback, p_sys );
371
372     vlc_mutex_unlock( &p_sys->lock );
373
374     return VLC_SUCCESS;
375 }
376
377 /*****************************************************************************
378  * DestroyFilter: destroy mosaic video filter
379  *****************************************************************************/
380 static void DestroyFilter( filter_t *p_filter )
381 {
382     filter_sys_t *p_sys = p_filter->p_sys;
383
384 #define DEL_CB( name ) \
385     var_DelCallback( p_filter, CFG_PREFIX #name, MosaicCallback, p_sys )
386     DEL_CB( width );
387     DEL_CB( height );
388     DEL_CB( xoffset );
389     DEL_CB( yoffset );
390
391     DEL_CB( align );
392
393     DEL_CB( borderw );
394     DEL_CB( borderh );
395     DEL_CB( rows );
396     DEL_CB( cols );
397     DEL_CB( alpha );
398     DEL_CB( position );
399     DEL_CB( delay );
400
401     DEL_CB( keep-aspect-ratio );
402     DEL_CB( order );
403 #undef DEL_CB
404
405     if( !p_sys->b_keep )
406     {
407         image_HandlerDelete( p_sys->p_image );
408     }
409
410     if( p_sys->i_order_length )
411     {
412         for( int i_index = 0; i_index < p_sys->i_order_length; i_index++ )
413         {
414             free( p_sys->ppsz_order[i_index] );
415         }
416         free( p_sys->ppsz_order );
417     }
418     if( p_sys->i_offsets_length )
419     {
420         free( p_sys->pi_x_offsets );
421         free( p_sys->pi_y_offsets );
422         p_sys->i_offsets_length = 0;
423     }
424
425     free( p_sys );
426 }
427
428 /*****************************************************************************
429  * Filter
430  *****************************************************************************/
431 static subpicture_t *Filter( filter_t *p_filter, vlc_tick_t date )
432 {
433     filter_sys_t *p_sys = p_filter->p_sys;
434     bridge_t *p_bridge;
435
436     int i_real_index, i_row, i_col;
437     int i_greatest_real_index_used = p_sys->i_order_length - 1;
438
439     unsigned int col_inner_width, row_inner_height;
440
441     subpicture_region_t *p_region;
442     subpicture_region_t *p_region_prev = NULL;
443
444     /* Allocate the subpicture internal data. */
445     subpicture_t *p_spu = filter_NewSubpicture( p_filter );
446     if( !p_spu )
447         return NULL;
448
449     /* Initialize subpicture */
450     p_spu->i_channel = 0;
451     p_spu->i_start  = date;
452     p_spu->i_stop = 0;
453     p_spu->b_ephemer = true;
454     p_spu->i_alpha = p_sys->i_alpha;
455     p_spu->b_absolute = false;
456
457     p_spu->i_original_picture_width = p_sys->i_width;
458     p_spu->i_original_picture_height = p_sys->i_height;
459
460     vlc_mutex_lock( &p_sys->lock );
461     vlc_global_lock( VLC_MOSAIC_MUTEX );
462
463     p_bridge = GetBridge( p_filter );
464     if ( p_bridge == NULL )
465     {
466         vlc_global_unlock( VLC_MOSAIC_MUTEX );
467         vlc_mutex_unlock( &p_sys->lock );
468         return p_spu;
469     }
470
471     if ( p_sys->i_position == position_offsets )
472     {
473         /* If we have either too much or not enough offsets, fall-back
474          * to automatic positioning. */
475         if ( p_sys->i_offsets_length != p_sys->i_order_length )
476         {
477             msg_Err( p_filter,
478                      "Number of specified offsets (%d) does not match number "
479                      "of input substreams in mosaic-order (%d), falling back "
480                      "to mosaic-position=0",
481                      p_sys->i_offsets_length, p_sys->i_order_length );
482             p_sys->i_position = position_auto;
483         }
484     }
485
486     if ( p_sys->i_position == position_auto )
487     {
488         int i_numpics = p_sys->i_order_length; /* keep slots and all */
489         for( int i_index = 0; i_index < p_bridge->i_es_num; i_index++ )
490         {
491             bridged_es_t *p_es = p_bridge->pp_es[i_index];
492             if ( !p_es->b_empty )
493             {
494                 i_numpics ++;
495                 if( p_sys->i_order_length && p_es->psz_id != NULL )
496                 {
497                     /* We also want to leave slots for images given in
498                      * mosaic-order that are not available in p_vout_picture */
499                     for( int i = 0; i < p_sys->i_order_length ; i++ )
500                     {
501                         if( !strcmp( p_sys->ppsz_order[i], p_es->psz_id ) )
502                         {
503                             i_numpics--;
504                             break;
505                         }
506                     }
507
508                 }
509             }
510         }
511         p_sys->i_rows = ceil(sqrt( (double)i_numpics ));
512         p_sys->i_cols = ( i_numpics % p_sys->i_rows == 0 ?
513                             i_numpics / p_sys->i_rows :
514                             i_numpics / p_sys->i_rows + 1 );
515     }
516
517     col_inner_width  = ( ( p_sys->i_width - ( p_sys->i_cols - 1 )
518                        * p_sys->i_borderw ) / p_sys->i_cols );
519     row_inner_height = ( ( p_sys->i_height - ( p_sys->i_rows - 1 )
520                        * p_sys->i_borderh ) / p_sys->i_rows );
521
522     i_real_index = 0;
523
524     for( int i_index = 0; i_index < p_bridge->i_es_num; i_index++ )
525     {
526         bridged_es_t *p_es = p_bridge->pp_es[i_index];
527         video_format_t fmt_in, fmt_out;
528         picture_t *p_converted;
529
530         if ( p_es->b_empty )
531             continue;
532
533         while ( !vlc_picture_chain_IsEmpty( &p_es->pictures ) )
534         {
535             picture_t *front = vlc_picture_chain_PeekFront( &p_es->pictures );
536             if ( front->date + p_sys->i_delay >= date )
537                 break; // front picture not late
538
539             if ( vlc_picture_chain_HasNext( &p_es->pictures ) )
540             {
541                 // front picture is late and has more pictures chained, skip it
542                 front = vlc_picture_chain_PopFront( &p_es->pictures );
543                 picture_Release( front );
544                 continue;
545             }
546
547             if ( front->date + p_sys->i_delay + BLANK_DELAY < date )
548             {
549                 // front picture is late and too old, don't display it
550                 front = vlc_picture_chain_PopFront( &p_es->pictures );
551                 // the picture chain is empty as the front didn't have chained pics
552                 picture_Release( front );
553                 break;
554             }
555             else
556             {
557                 // front picture is a little late, display it
558                 msg_Dbg( p_filter, "too late picture for %s (%"PRId64 ")",
559                          p_es->psz_id,
560                          date - front->date - p_sys->i_delay );
561                 break;
562             }
563         }
564
565         if ( vlc_picture_chain_IsEmpty( &p_es->pictures ) )
566             continue;
567
568         if ( p_sys->i_order_length == 0 )
569         {
570             i_real_index++;
571         }
572         else
573         {
574             int i;
575             for ( i = 0; i <= p_sys->i_order_length; i++ )
576             {
577                 if ( i == p_sys->i_order_length ) break;
578                 if ( strcmp( p_es->psz_id, p_sys->ppsz_order[i] ) == 0 )
579                 {
580                     i_real_index = i;
581                     break;
582                 }
583             }
584             if ( i == p_sys->i_order_length )
585                 i_real_index = ++i_greatest_real_index_used;
586         }
587         i_row = ( i_real_index / p_sys->i_cols ) % p_sys->i_rows;
588         i_col = i_real_index % p_sys->i_cols ;
589
590         video_format_Init( &fmt_in, 0 );
591         video_format_Init( &fmt_out, 0 );
592
593         p_converted = vlc_picture_chain_PeekFront( &p_es->pictures );
594         if ( !p_sys->b_keep )
595         {
596             /* Convert the images */
597             fmt_in.i_chroma = p_converted->format.i_chroma;
598             fmt_in.i_height = p_converted->format.i_height;
599             fmt_in.i_width = p_converted->format.i_width;
600
601             if( fmt_in.i_chroma == VLC_CODEC_YUVA ||
602                 fmt_in.i_chroma == VLC_CODEC_RGBA )
603                 fmt_out.i_chroma = VLC_CODEC_YUVA;
604             else
605                 fmt_out.i_chroma = VLC_CODEC_I420;
606             fmt_out.i_width = col_inner_width;
607             fmt_out.i_height = row_inner_height;
608
609             if( p_sys->b_ar ) /* keep aspect ratio */
610             {
611                 if( (float)fmt_out.i_width / (float)fmt_out.i_height
612                       > (float)fmt_in.i_width / (float)fmt_in.i_height )
613                 {
614                     fmt_out.i_width = ( fmt_out.i_height * fmt_in.i_width )
615                                          / fmt_in.i_height;
616                 }
617                 else
618                 {
619                     fmt_out.i_height = ( fmt_out.i_width * fmt_in.i_height )
620                                         / fmt_in.i_width;
621                 }
622              }
623
624             fmt_out.i_visible_width = fmt_out.i_width;
625             fmt_out.i_visible_height = fmt_out.i_height;
626
627             p_converted = image_Convert( p_sys->p_image, p_converted,
628                                          &fmt_in, &fmt_out );
629             if( !p_converted )
630             {
631                 msg_Warn( p_filter,
632                            "image resizing and chroma conversion failed" );
633                 video_format_Clean( &fmt_in );
634                 video_format_Clean( &fmt_out );
635                 continue;
636             }
637         }
638         else
639         {
640             fmt_in.i_width = fmt_out.i_width = p_converted->format.i_width;
641             fmt_in.i_height = fmt_out.i_height = p_converted->format.i_height;
642             fmt_in.i_chroma = fmt_out.i_chroma = p_converted->format.i_chroma;
643             fmt_out.i_visible_width = fmt_out.i_width;
644             fmt_out.i_visible_height = fmt_out.i_height;
645         }
646
647         p_region = subpicture_region_New( &fmt_out );
648         /* FIXME the copy is probably not needed anymore */
649         if( p_region )
650             picture_Copy( p_region->p_picture, p_converted );
651         if( !p_sys->b_keep )
652             picture_Release( p_converted );
653
654         if( !p_region )
655         {
656             video_format_Clean( &fmt_in );
657             video_format_Clean( &fmt_out );
658             msg_Err( p_filter, "cannot allocate SPU region" );
659             subpicture_Delete( p_spu );
660             vlc_global_unlock( VLC_MOSAIC_MUTEX );
661             vlc_mutex_unlock( &p_sys->lock );
662             return NULL;
663         }
664
665         if( p_es->i_x >= 0 && p_es->i_y >= 0 )
666         {
667             p_region->i_x = p_es->i_x;
668             p_region->i_y = p_es->i_y;
669         }
670         else if( p_sys->i_position == position_offsets )
671         {
672             p_region->i_x = p_sys->pi_x_offsets[i_real_index];
673             p_region->i_y = p_sys->pi_y_offsets[i_real_index];
674         }
675         else
676         {
677             if( fmt_out.i_width > col_inner_width ||
678                 p_sys->b_ar || p_sys->b_keep )
679             {
680                 /* we don't have to center the video since it takes the
681                 whole rectangle area or it's larger than the rectangle */
682                 p_region->i_x = p_sys->i_xoffset
683                             + i_col * ( p_sys->i_width / p_sys->i_cols )
684                             + ( i_col * p_sys->i_borderw ) / p_sys->i_cols;
685             }
686             else
687             {
688                 /* center the video in the dedicated rectangle */
689                 p_region->i_x = p_sys->i_xoffset
690                         + i_col * ( p_sys->i_width / p_sys->i_cols )
691                         + ( i_col * p_sys->i_borderw ) / p_sys->i_cols
692                         + ( col_inner_width - fmt_out.i_width ) / 2;
693             }
694
695             if( fmt_out.i_height > row_inner_height
696                 || p_sys->b_ar || p_sys->b_keep )
697             {
698                 /* we don't have to center the video since it takes the
699                 whole rectangle area or it's taller than the rectangle */
700                 p_region->i_y = p_sys->i_yoffset
701                         + i_row * ( p_sys->i_height / p_sys->i_rows )
702                         + ( i_row * p_sys->i_borderh ) / p_sys->i_rows;
703             }
704             else
705             {
706                 /* center the video in the dedicated rectangle */
707                 p_region->i_y = p_sys->i_yoffset
708                         + i_row * ( p_sys->i_height / p_sys->i_rows )
709                         + ( i_row * p_sys->i_borderh ) / p_sys->i_rows
710                         + ( row_inner_height - fmt_out.i_height ) / 2;
711             }
712         }
713         p_region->i_align = p_sys->i_align;
714         p_region->i_alpha = p_es->i_alpha;
715
716         if( p_region_prev == NULL )
717         {
718             p_spu->p_region = p_region;
719         }
720         else
721         {
722             p_region_prev->p_next = p_region;
723         }
724
725         video_format_Clean( &fmt_in );
726         video_format_Clean( &fmt_out );
727
728         p_region_prev = p_region;
729     }
730
731     vlc_global_unlock( VLC_MOSAIC_MUTEX );
732     vlc_mutex_unlock( &p_sys->lock );
733
734     return p_spu;
735 }
736
737 /*****************************************************************************
738 * Callback to update params on the fly
739 *****************************************************************************/
740 static int MosaicCallback( vlc_object_t *p_this, char const *psz_var,
741                             vlc_value_t oldval, vlc_value_t newval,
742                             void *p_data )
743 {
744     VLC_UNUSED(oldval);
745     filter_sys_t *p_sys = (filter_sys_t *) p_data;
746
747 #define VAR_IS( a ) !strcmp( psz_var, CFG_PREFIX a )
748     if( VAR_IS( "alpha" ) )
749     {
750         vlc_mutex_lock( &p_sys->lock );
751         msg_Dbg( p_this, "changing alpha from %d/255 to %d/255",
752                          p_sys->i_alpha, (int)newval.i_int);
753         p_sys->i_alpha = VLC_CLIP( newval.i_int, 0, 255 );
754         vlc_mutex_unlock( &p_sys->lock );
755     }
756     else if( VAR_IS( "height" ) )
757     {
758         vlc_mutex_lock( &p_sys->lock );
759         msg_Dbg( p_this, "changing height from %dpx to %dpx",
760                           p_sys->i_height, (int)newval.i_int );
761         p_sys->i_height = __MAX( newval.i_int, 0 );
762         vlc_mutex_unlock( &p_sys->lock );
763     }
764     else if( VAR_IS( "width" ) )
765     {
766         vlc_mutex_lock( &p_sys->lock );
767         msg_Dbg( p_this, "changing width from %dpx to %dpx",
768                          p_sys->i_width, (int)newval.i_int );
769         p_sys->i_width = __MAX( newval.i_int, 0 );
770         vlc_mutex_unlock( &p_sys->lock );
771     }
772     else if( VAR_IS( "xoffset" ) )
773     {
774         vlc_mutex_lock( &p_sys->lock );
775         msg_Dbg( p_this, "changing x offset from %dpx to %dpx",
776                          p_sys->i_xoffset, (int)newval.i_int );
777         p_sys->i_xoffset = __MAX( newval.i_int, 0 );
778         vlc_mutex_unlock( &p_sys->lock );
779     }
780     else if( VAR_IS( "yoffset" ) )
781     {
782         vlc_mutex_lock( &p_sys->lock );
783         msg_Dbg( p_this, "changing y offset from %dpx to %dpx",
784                          p_sys->i_yoffset, (int)newval.i_int );
785         p_sys->i_yoffset = __MAX( newval.i_int, 0 );
786         vlc_mutex_unlock( &p_sys->lock );
787     }
788     else if( VAR_IS( "align" ) )
789     {
790         int i_old = 0, i_new = 0;
791         vlc_mutex_lock( &p_sys->lock );
792         newval.i_int = VLC_CLIP( newval.i_int, 0, 10 );
793         if( newval.i_int == 3 || newval.i_int == 7 )
794             newval.i_int = 5;
795         while( pi_align_values[i_old] != p_sys->i_align ) i_old++;
796         while( pi_align_values[i_new] != newval.i_int ) i_new++;
797         msg_Dbg( p_this, "changing alignment from %d (%s) to %d (%s)",
798                      p_sys->i_align, ppsz_align_descriptions[i_old],
799                      (int)newval.i_int, ppsz_align_descriptions[i_new] );
800         p_sys->i_align = newval.i_int;
801         vlc_mutex_unlock( &p_sys->lock );
802     }
803     else if( VAR_IS( "borderw" ) )
804     {
805         vlc_mutex_lock( &p_sys->lock );
806         msg_Dbg( p_this, "changing border width from %dpx to %dpx",
807                          p_sys->i_borderw, (int)newval.i_int );
808         p_sys->i_borderw = __MAX( newval.i_int, 0 );
809         vlc_mutex_unlock( &p_sys->lock );
810     }
811     else if( VAR_IS( "borderh" ) )
812     {
813         vlc_mutex_lock( &p_sys->lock );
814         msg_Dbg( p_this, "changing border height from %dpx to %dpx",
815                          p_sys->i_borderh, (int)newval.i_int );
816         p_sys->i_borderh = __MAX( newval.i_int, 0 );
817         vlc_mutex_unlock( &p_sys->lock );
818     }
819     else if( VAR_IS( "position" ) )
820     {
821         if( newval.i_int > 2 || newval.i_int < 0 )
822         {
823             msg_Err( p_this,
824                      "Position is either 0 (%s), 1 (%s) or 2 (%s)",
825                      ppsz_pos_descriptions[0],
826                      ppsz_pos_descriptions[1],
827                      ppsz_pos_descriptions[2] );
828         }
829         else
830         {
831             vlc_mutex_lock( &p_sys->lock );
832             msg_Dbg( p_this, "changing position method from %d (%s) to %d (%s)",
833                     p_sys->i_position, ppsz_pos_descriptions[p_sys->i_position],
834                      (int)newval.i_int, ppsz_pos_descriptions[newval.i_int]);
835             p_sys->i_position = newval.i_int;
836             vlc_mutex_unlock( &p_sys->lock );
837         }
838     }
839     else if( VAR_IS( "rows" ) )
840     {
841         vlc_mutex_lock( &p_sys->lock );
842         msg_Dbg( p_this, "changing number of rows from %d to %d",
843                          p_sys->i_rows, (int)newval.i_int );
844         p_sys->i_rows = __MAX( newval.i_int, 1 );
845         vlc_mutex_unlock( &p_sys->lock );
846     }
847     else if( VAR_IS( "cols" ) )
848     {
849         vlc_mutex_lock( &p_sys->lock );
850         msg_Dbg( p_this, "changing number of columns from %d to %d",
851                          p_sys->i_cols, (int)newval.i_int );
852         p_sys->i_cols = __MAX( newval.i_int, 1 );
853         vlc_mutex_unlock( &p_sys->lock );
854     }
855     else if( VAR_IS( "order" ) )
856     {
857         char *psz_order;
858         int i_index;
859         vlc_mutex_lock( &p_sys->lock );
860         msg_Dbg( p_this, "Changing mosaic order to %s", newval.psz_string );
861
862         psz_order = newval.psz_string;
863
864         while( p_sys->i_order_length-- )
865         {
866             free( p_sys->ppsz_order[p_sys->i_order_length] );
867         }
868         free( p_sys->ppsz_order );
869         p_sys->ppsz_order = NULL;
870
871         if( *psz_order )
872         {
873             char *psz_end = NULL;
874             i_index = 0;
875             do
876             {
877                 psz_end = strchr( psz_order, ',' );
878                 i_index++;
879                 p_sys->ppsz_order = xrealloc( p_sys->ppsz_order,
880                                                    i_index * sizeof(char *) );
881                 p_sys->ppsz_order[i_index - 1] = strndup( psz_order,
882                                            psz_end - psz_order );
883                 psz_order = psz_end+1;
884             } while( psz_end );
885             p_sys->i_order_length = i_index;
886         }
887
888         vlc_mutex_unlock( &p_sys->lock );
889     }
890     else if( VAR_IS( "offsets" ) )
891     {
892         vlc_mutex_lock( &p_sys->lock );
893         msg_Info( p_this, "Changing mosaic-offsets to %s", newval.psz_string );
894
895         if( p_sys->i_offsets_length != 0 )
896         {
897             p_sys->i_offsets_length = 0;
898             free( p_sys->pi_x_offsets );
899             free( p_sys->pi_y_offsets );
900             p_sys->pi_x_offsets = NULL;
901             p_sys->pi_y_offsets = NULL;
902         }
903
904         mosaic_ParseSetOffsets( p_this, p_sys, newval.psz_string );
905
906         vlc_mutex_unlock( &p_sys->lock );
907     }
908     else if( VAR_IS( "keep-aspect-ratio" ) )
909     {
910         vlc_mutex_lock( &p_sys->lock );
911         if( newval.i_int )
912         {
913             msg_Dbg( p_this, "keeping aspect ratio" );
914             p_sys->b_ar = 1;
915         }
916         else
917         {
918             msg_Dbg( p_this, "won't keep aspect ratio" );
919             p_sys->b_ar = 0;
920         }
921         vlc_mutex_unlock( &p_sys->lock );
922     }
923     else if( VAR_IS( "keep-picture" ) )
924     {
925         vlc_mutex_lock( &p_sys->lock );
926         p_sys->b_keep = newval.b_bool;
927         if ( !p_sys->b_keep && !p_sys->p_image )
928         {
929             p_sys->p_image = image_HandlerCreate( p_this );
930         }
931         vlc_mutex_unlock( &p_sys->lock );
932     }
933
934     return VLC_SUCCESS;
935 }