1 /*****************************************************************************
2 * mosaic.c : Mosaic video plugin for vlc
3 *****************************************************************************
4 * Copyright (C) 2004-2008 VLC authors and VideoLAN
7 * Authors: Antoine Cellerier <dionoea at videolan dot org>
8 * Christophe Massiot <massiot@via.ecp.fr>
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.
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.
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 *****************************************************************************/
25 /*****************************************************************************
27 *****************************************************************************/
32 #include <vlc_common.h>
33 #include <vlc_plugin.h>
36 #include <limits.h> /* INT_MAX */
38 #include <vlc_filter.h>
39 #include <vlc_image.h>
43 #define BLANK_DELAY INT64_C(1000000)
45 /*****************************************************************************
47 *****************************************************************************/
48 static int CreateFilter ( vlc_object_t
* );
49 static void DestroyFilter ( vlc_object_t
* );
50 static subpicture_t
*Filter ( filter_t
*, mtime_t
);
52 static int MosaicCallback ( vlc_object_t
*, char const *, vlc_value_t
,
53 vlc_value_t
, void * );
55 /*****************************************************************************
56 * filter_sys_t : filter descriptor
57 *****************************************************************************/
60 vlc_mutex_t lock
; /* Internal filter lock */
62 image_handler_t
*p_image
;
64 int i_position
; /* Mosaic positioning method */
65 bool b_ar
; /* Do we keep the aspect ratio ? */
66 bool b_keep
; /* Do we keep the original picture format ? */
67 int i_width
, i_height
; /* Mosaic height and width */
68 int i_cols
, i_rows
; /* Mosaic rows and cols */
69 int i_align
; /* Mosaic alignment in background video */
70 int i_xoffset
, i_yoffset
; /* Top left corner offset */
71 int i_borderw
, i_borderh
; /* Border width/height between miniatures */
72 int i_alpha
; /* Subfilter alpha blending */
74 char **ppsz_order
; /* List of picture-ids */
77 int *pi_x_offsets
; /* List of substreams x offsets */
78 int *pi_y_offsets
; /* List of substreams y offsets */
84 /*****************************************************************************
86 *****************************************************************************/
87 #define ALPHA_TEXT N_("Transparency")
88 #define ALPHA_LONGTEXT N_( \
89 "Transparency of the mosaic foreground pictures. " \
90 "0 means transparent, 255 opaque (default)." )
92 #define HEIGHT_TEXT N_("Height")
93 #define HEIGHT_LONGTEXT N_( "Total height of the mosaic, in pixels." )
94 #define WIDTH_TEXT N_("Width")
95 #define WIDTH_LONGTEXT N_( "Total width of the mosaic, in pixels." )
97 #define XOFFSET_TEXT N_("Top left corner X coordinate")
98 #define XOFFSET_LONGTEXT N_( \
99 "X Coordinate of the top-left corner of the mosaic.")
100 #define YOFFSET_TEXT N_("Top left corner Y coordinate")
101 #define YOFFSET_LONGTEXT N_( \
102 "Y Coordinate of the top-left corner of the mosaic.")
104 #define BORDERW_TEXT N_("Border width")
105 #define BORDERW_LONGTEXT N_( \
106 "Width in pixels of the border between miniatures." )
107 #define BORDERH_TEXT N_("Border height")
108 #define BORDERH_LONGTEXT N_( \
109 "Height in pixels of the border between miniatures." )
111 #define ALIGN_TEXT N_("Mosaic alignment" )
112 #define ALIGN_LONGTEXT N_( \
113 "You can enforce the mosaic alignment on the video " \
114 "(0=center, 1=left, 2=right, 4=top, 8=bottom, you can " \
115 "also use combinations of these values, eg 6 = top-right).")
117 #define POS_TEXT N_("Positioning method")
118 #define POS_LONGTEXT N_( \
119 "Positioning method for the mosaic. auto: " \
120 "automatically choose the best number of rows and columns. " \
121 "fixed: use the user-defined number of rows and columns. " \
122 "offsets: use the user-defined offsets for each image." )
124 #define ROWS_TEXT N_("Number of rows")
125 #define ROWS_LONGTEXT N_( \
126 "Number of image rows in the mosaic (only used if " \
127 "positioning method is set to \"fixed\")." )
129 #define COLS_TEXT N_("Number of columns")
130 #define COLS_LONGTEXT N_( \
131 "Number of image columns in the mosaic (only used if " \
132 "positioning method is set to \"fixed\"." )
134 #define AR_TEXT N_("Keep aspect ratio")
135 #define AR_LONGTEXT N_( \
136 "Keep the original aspect ratio when resizing " \
138 #define KEEP_TEXT N_("Keep original size")
139 #define KEEP_LONGTEXT N_( \
140 "Keep the original size of mosaic elements." )
142 #define ORDER_TEXT N_("Elements order" )
143 #define ORDER_LONGTEXT N_( \
144 "You can enforce the order of the elements on " \
145 "the mosaic. You must give a comma-separated list of picture ID(s)." \
146 "These IDs are assigned in the \"mosaic-bridge\" module." )
148 #define OFFSETS_TEXT N_("Offsets in order" )
149 #define OFFSETS_LONGTEXT N_( \
150 "You can enforce the (x,y) offsets of the elements on the mosaic " \
151 "(only used if positioning method is set to \"offsets\"). You " \
152 "must give a comma-separated list of coordinates (eg: 10,10,150,10)." )
154 #define DELAY_TEXT N_("Delay")
155 #define DELAY_LONGTEXT N_( \
156 "Pictures coming from the mosaic elements will be delayed " \
157 "according to this value (in milliseconds). For high " \
158 "values you will need to raise caching at input.")
162 position_auto
= 0, position_fixed
= 1, position_offsets
= 2
164 static const int pi_pos_values
[] = { 0, 1, 2 };
165 static const char *const ppsz_pos_descriptions
[] =
166 { N_("auto"), N_("fixed"), N_("offsets") };
168 static const int pi_align_values
[] = { 0, 1, 2, 4, 8, 5, 6, 9, 10 };
169 static const char *const ppsz_align_descriptions
[] =
170 { N_("Center"), N_("Left"), N_("Right"), N_("Top"), N_("Bottom"),
171 N_("Top-Left"), N_("Top-Right"), N_("Bottom-Left"), N_("Bottom-Right") };
173 #define CFG_PREFIX "mosaic-"
176 set_description( N_("Mosaic video sub source") )
177 set_shortname( N_("Mosaic") )
178 set_category( CAT_VIDEO
)
179 set_subcategory( SUBCAT_VIDEO_SUBPIC
)
180 set_capability( "sub source", 0 )
181 set_callbacks( CreateFilter
, DestroyFilter
)
183 add_integer_with_range( CFG_PREFIX
"alpha", 255, 0, 255,
184 ALPHA_TEXT
, ALPHA_LONGTEXT
, false )
186 add_integer( CFG_PREFIX
"height", 100,
187 HEIGHT_TEXT
, HEIGHT_LONGTEXT
, false )
188 add_integer( CFG_PREFIX
"width", 100,
189 WIDTH_TEXT
, WIDTH_LONGTEXT
, false )
191 add_integer( CFG_PREFIX
"align", 5,
192 ALIGN_TEXT
, ALIGN_LONGTEXT
, true)
193 change_integer_list( pi_align_values
, ppsz_align_descriptions
)
195 add_integer( CFG_PREFIX
"xoffset", 0,
196 XOFFSET_TEXT
, XOFFSET_LONGTEXT
, true )
197 add_integer( CFG_PREFIX
"yoffset", 0,
198 YOFFSET_TEXT
, YOFFSET_LONGTEXT
, true )
200 add_integer( CFG_PREFIX
"borderw", 0,
201 BORDERW_TEXT
, BORDERW_LONGTEXT
, true )
202 add_integer( CFG_PREFIX
"borderh", 0,
203 BORDERH_TEXT
, BORDERH_LONGTEXT
, true )
205 add_integer( CFG_PREFIX
"position", 0,
206 POS_TEXT
, POS_LONGTEXT
, false )
207 change_integer_list( pi_pos_values
, ppsz_pos_descriptions
)
208 add_integer( CFG_PREFIX
"rows", 2,
209 ROWS_TEXT
, ROWS_LONGTEXT
, false )
210 add_integer( CFG_PREFIX
"cols", 2,
211 COLS_TEXT
, COLS_LONGTEXT
, false )
213 add_bool( CFG_PREFIX
"keep-aspect-ratio", false,
214 AR_TEXT
, AR_LONGTEXT
, false )
215 add_bool( CFG_PREFIX
"keep-picture", false,
216 KEEP_TEXT
, KEEP_LONGTEXT
, false )
218 add_string( CFG_PREFIX
"order", "",
219 ORDER_TEXT
, ORDER_LONGTEXT
, false )
221 add_string( CFG_PREFIX
"offsets", "",
222 OFFSETS_TEXT
, OFFSETS_LONGTEXT
, false )
224 add_integer( CFG_PREFIX
"delay", 0, DELAY_TEXT
, DELAY_LONGTEXT
,
228 static const char *const ppsz_filter_options
[] = {
229 "alpha", "height", "width", "align", "xoffset", "yoffset",
230 "borderw", "borderh", "position", "rows", "cols",
231 "keep-aspect-ratio", "keep-picture", "order", "offsets",
235 /*****************************************************************************
236 * mosaic_ParseSetOffsets:
237 * parse the "--mosaic-offsets x1,y1,x2,y2,x3,y3" parameter
238 * and set the corresponding struct filter_sys_t entries.
239 *****************************************************************************/
240 static void mosaic_ParseSetOffsets( vlc_object_t
*p_this
,
246 char *psz_end
= NULL
;
252 p_sys
->pi_x_offsets
= xrealloc( p_sys
->pi_x_offsets
,
253 i_index
* sizeof(int) );
254 p_sys
->pi_x_offsets
[i_index
- 1] = atoi( psz_offsets
);
255 psz_end
= strchr( psz_offsets
, ',' );
256 psz_offsets
= psz_end
+ 1;
258 p_sys
->pi_y_offsets
= xrealloc( p_sys
->pi_y_offsets
,
259 i_index
* sizeof(int) );
260 p_sys
->pi_y_offsets
[i_index
- 1] = atoi( psz_offsets
);
261 psz_end
= strchr( psz_offsets
, ',' );
262 psz_offsets
= psz_end
+ 1;
264 msg_Dbg( p_this
, CFG_PREFIX
"offset: id %d, x=%d, y=%d",
265 i_index
, p_sys
->pi_x_offsets
[i_index
- 1],
266 p_sys
->pi_y_offsets
[i_index
- 1] );
269 p_sys
->i_offsets_length
= i_index
;
272 #define mosaic_ParseSetOffsets( a, b, c ) \
273 mosaic_ParseSetOffsets( VLC_OBJECT( a ), b, c )
275 /*****************************************************************************
276 * CreateFiler: allocate mosaic video filter
277 *****************************************************************************/
278 static int CreateFilter( vlc_object_t
*p_this
)
280 filter_t
*p_filter
= (filter_t
*)p_this
;
282 char *psz_order
, *_psz_order
;
287 /* Allocate structure */
288 p_sys
= p_filter
->p_sys
= malloc( sizeof( filter_sys_t
) );
292 p_filter
->pf_sub_source
= Filter
;
294 vlc_mutex_init( &p_sys
->lock
);
295 vlc_mutex_lock( &p_sys
->lock
);
297 config_ChainParse( p_filter
, CFG_PREFIX
, ppsz_filter_options
,
300 #define GET_VAR( name, min, max ) \
301 i_command = var_CreateGetIntegerCommand( p_filter, CFG_PREFIX #name ); \
302 p_sys->i_##name = VLC_CLIP( i_command, min, max ); \
303 var_AddCallback( p_filter, CFG_PREFIX #name, MosaicCallback, p_sys );
305 GET_VAR( width
, 0, INT_MAX
);
306 GET_VAR( height
, 0, INT_MAX
);
307 GET_VAR( xoffset
, 0, INT_MAX
);
308 GET_VAR( yoffset
, 0, INT_MAX
);
310 GET_VAR( align
, 0, 10 );
311 if( p_sys
->i_align
== 3 || p_sys
->i_align
== 7 )
314 GET_VAR( borderw
, 0, INT_MAX
);
315 GET_VAR( borderh
, 0, INT_MAX
);
316 GET_VAR( rows
, 1, INT_MAX
);
317 GET_VAR( cols
, 1, INT_MAX
);
318 GET_VAR( alpha
, 0, 255 );
319 GET_VAR( position
, 0, 2 );
320 GET_VAR( delay
, 100, INT_MAX
);
322 p_sys
->i_delay
*= 1000;
324 p_sys
->b_ar
= var_CreateGetBoolCommand( p_filter
,
325 CFG_PREFIX
"keep-aspect-ratio" );
326 var_AddCallback( p_filter
, CFG_PREFIX
"keep-aspect-ratio", MosaicCallback
,
329 p_sys
->b_keep
= var_CreateGetBoolCommand( p_filter
,
330 CFG_PREFIX
"keep-picture" );
331 if ( !p_sys
->b_keep
)
333 p_sys
->p_image
= image_HandlerCreate( p_filter
);
336 p_sys
->i_order_length
= 0;
337 p_sys
->ppsz_order
= NULL
;
338 psz_order
= var_CreateGetStringCommand( p_filter
, CFG_PREFIX
"order" );
339 _psz_order
= psz_order
;
340 var_AddCallback( p_filter
, CFG_PREFIX
"order", MosaicCallback
, p_sys
);
344 char *psz_end
= NULL
;
348 psz_end
= strchr( psz_order
, ',' );
350 p_sys
->ppsz_order
= xrealloc( p_sys
->ppsz_order
,
351 i_index
* sizeof(char *) );
352 p_sys
->ppsz_order
[i_index
- 1] = strndup( psz_order
,
353 psz_end
- psz_order
);
354 psz_order
= psz_end
+1;
356 p_sys
->i_order_length
= i_index
;
361 /* Manage specific offsets for substreams */
362 psz_offsets
= var_CreateGetStringCommand( p_filter
, CFG_PREFIX
"offsets" );
363 p_sys
->i_offsets_length
= 0;
364 p_sys
->pi_x_offsets
= NULL
;
365 p_sys
->pi_y_offsets
= NULL
;
366 mosaic_ParseSetOffsets( p_filter
, p_sys
, psz_offsets
);
368 var_AddCallback( p_filter
, CFG_PREFIX
"offsets", MosaicCallback
, p_sys
);
370 vlc_mutex_unlock( &p_sys
->lock
);
375 /*****************************************************************************
376 * DestroyFilter: destroy mosaic video filter
377 *****************************************************************************/
378 static void DestroyFilter( vlc_object_t
*p_this
)
380 filter_t
*p_filter
= (filter_t
*)p_this
;
381 filter_sys_t
*p_sys
= p_filter
->p_sys
;
383 #define DEL_CB( name ) \
384 var_DelCallback( p_filter, CFG_PREFIX #name, MosaicCallback, p_sys )
400 DEL_CB( keep
-aspect
-ratio
);
406 image_HandlerDelete( p_sys
->p_image
);
409 if( p_sys
->i_order_length
)
411 for( int i_index
= 0; i_index
< p_sys
->i_order_length
; i_index
++ )
413 free( p_sys
->ppsz_order
[i_index
] );
415 free( p_sys
->ppsz_order
);
417 if( p_sys
->i_offsets_length
)
419 free( p_sys
->pi_x_offsets
);
420 free( p_sys
->pi_y_offsets
);
421 p_sys
->i_offsets_length
= 0;
424 vlc_mutex_destroy( &p_sys
->lock
);
428 /*****************************************************************************
430 *****************************************************************************/
431 static subpicture_t
*Filter( filter_t
*p_filter
, mtime_t date
)
433 filter_sys_t
*p_sys
= p_filter
->p_sys
;
436 int i_index
, i_real_index
, i_row
, i_col
;
437 int i_greatest_real_index_used
= p_sys
->i_order_length
- 1;
439 unsigned int col_inner_width
, row_inner_height
;
441 subpicture_region_t
*p_region
;
442 subpicture_region_t
*p_region_prev
= NULL
;
444 /* Allocate the subpicture internal data. */
445 subpicture_t
*p_spu
= filter_NewSubpicture( p_filter
);
449 /* Initialize subpicture */
450 p_spu
->i_channel
= 0;
451 p_spu
->i_start
= date
;
453 p_spu
->b_ephemer
= true;
454 p_spu
->i_alpha
= p_sys
->i_alpha
;
455 p_spu
->b_absolute
= false;
457 p_spu
->i_original_picture_width
= p_sys
->i_width
;
458 p_spu
->i_original_picture_height
= p_sys
->i_height
;
460 vlc_mutex_lock( &p_sys
->lock
);
461 vlc_global_lock( VLC_MOSAIC_MUTEX
);
463 p_bridge
= GetBridge( p_filter
);
464 if ( p_bridge
== NULL
)
466 vlc_global_unlock( VLC_MOSAIC_MUTEX
);
467 vlc_mutex_unlock( &p_sys
->lock
);
471 if ( p_sys
->i_position
== position_offsets
)
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
)
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
;
486 if ( p_sys
->i_position
== position_auto
)
488 int i_numpics
= p_sys
->i_order_length
; /* keep slots and all */
489 for ( i_index
= 0; i_index
< p_bridge
->i_es_num
; i_index
++ )
491 bridged_es_t
*p_es
= p_bridge
->pp_es
[i_index
];
492 if ( !p_es
->b_empty
)
495 if( p_sys
->i_order_length
&& p_es
->psz_id
!= NULL
)
497 /* We also want to leave slots for images given in
498 * mosaic-order that are not available in p_vout_picture */
500 for( i
= 0; i
< p_sys
->i_order_length
; i
++ )
502 if( !strcmp( p_sys
->ppsz_order
[i
], p_es
->psz_id
) )
512 p_sys
->i_rows
= ceil(sqrt( (double)i_numpics
));
513 p_sys
->i_cols
= ( i_numpics
% p_sys
->i_rows
== 0 ?
514 i_numpics
/ p_sys
->i_rows
:
515 i_numpics
/ p_sys
->i_rows
+ 1 );
518 col_inner_width
= ( ( p_sys
->i_width
- ( p_sys
->i_cols
- 1 )
519 * p_sys
->i_borderw
) / p_sys
->i_cols
);
520 row_inner_height
= ( ( p_sys
->i_height
- ( p_sys
->i_rows
- 1 )
521 * p_sys
->i_borderh
) / p_sys
->i_rows
);
525 for ( i_index
= 0; i_index
< p_bridge
->i_es_num
; i_index
++ )
527 bridged_es_t
*p_es
= p_bridge
->pp_es
[i_index
];
528 video_format_t fmt_in
, fmt_out
;
529 picture_t
*p_converted
;
531 memset( &fmt_in
, 0, sizeof( video_format_t
) );
532 memset( &fmt_out
, 0, sizeof( video_format_t
) );
537 while ( p_es
->p_picture
!= NULL
538 && p_es
->p_picture
->date
+ p_sys
->i_delay
< date
)
540 if ( p_es
->p_picture
->p_next
!= NULL
)
542 picture_t
*p_next
= p_es
->p_picture
->p_next
;
543 picture_Release( p_es
->p_picture
);
544 p_es
->p_picture
= p_next
;
546 else if ( p_es
->p_picture
->date
+ p_sys
->i_delay
+ BLANK_DELAY
<
550 picture_Release( p_es
->p_picture
);
551 p_es
->p_picture
= NULL
;
552 p_es
->pp_last
= &p_es
->p_picture
;
557 msg_Dbg( p_filter
, "too late picture for %s (%"PRId64
")",
559 date
- p_es
->p_picture
->date
- p_sys
->i_delay
);
564 if ( p_es
->p_picture
== NULL
)
567 if ( p_sys
->i_order_length
== 0 )
574 for ( i
= 0; i
<= p_sys
->i_order_length
; i
++ )
576 if ( i
== p_sys
->i_order_length
) break;
577 if ( strcmp( p_es
->psz_id
, p_sys
->ppsz_order
[i
] ) == 0 )
583 if ( i
== p_sys
->i_order_length
)
584 i_real_index
= ++i_greatest_real_index_used
;
586 i_row
= ( i_real_index
/ p_sys
->i_cols
) % p_sys
->i_rows
;
587 i_col
= i_real_index
% p_sys
->i_cols
;
589 if ( !p_sys
->b_keep
)
591 /* Convert the images */
592 fmt_in
.i_chroma
= p_es
->p_picture
->format
.i_chroma
;
593 fmt_in
.i_height
= p_es
->p_picture
->format
.i_height
;
594 fmt_in
.i_width
= p_es
->p_picture
->format
.i_width
;
596 if( fmt_in
.i_chroma
== VLC_CODEC_YUVA
||
597 fmt_in
.i_chroma
== VLC_CODEC_RGBA
)
598 fmt_out
.i_chroma
= VLC_CODEC_YUVA
;
600 fmt_out
.i_chroma
= VLC_CODEC_I420
;
601 fmt_out
.i_width
= col_inner_width
;
602 fmt_out
.i_height
= row_inner_height
;
604 if( p_sys
->b_ar
) /* keep aspect ratio */
606 if( (float)fmt_out
.i_width
/ (float)fmt_out
.i_height
607 > (float)fmt_in
.i_width
/ (float)fmt_in
.i_height
)
609 fmt_out
.i_width
= ( fmt_out
.i_height
* fmt_in
.i_width
)
614 fmt_out
.i_height
= ( fmt_out
.i_width
* fmt_in
.i_height
)
619 fmt_out
.i_visible_width
= fmt_out
.i_width
;
620 fmt_out
.i_visible_height
= fmt_out
.i_height
;
622 p_converted
= image_Convert( p_sys
->p_image
, p_es
->p_picture
,
627 "image resizing and chroma conversion failed" );
633 p_converted
= p_es
->p_picture
;
634 fmt_in
.i_width
= fmt_out
.i_width
= p_converted
->format
.i_width
;
635 fmt_in
.i_height
= fmt_out
.i_height
= p_converted
->format
.i_height
;
636 fmt_in
.i_chroma
= fmt_out
.i_chroma
= p_converted
->format
.i_chroma
;
637 fmt_out
.i_visible_width
= fmt_out
.i_width
;
638 fmt_out
.i_visible_height
= fmt_out
.i_height
;
641 p_region
= subpicture_region_New( &fmt_out
);
642 /* FIXME the copy is probably not needed anymore */
644 picture_Copy( p_region
->p_picture
, p_converted
);
646 picture_Release( p_converted
);
650 msg_Err( p_filter
, "cannot allocate SPU region" );
651 filter_DeleteSubpicture( p_filter
, p_spu
);
652 vlc_global_unlock( VLC_MOSAIC_MUTEX
);
653 vlc_mutex_unlock( &p_sys
->lock
);
657 if( p_es
->i_x
>= 0 && p_es
->i_y
>= 0 )
659 p_region
->i_x
= p_es
->i_x
;
660 p_region
->i_y
= p_es
->i_y
;
662 else if( p_sys
->i_position
== position_offsets
)
664 p_region
->i_x
= p_sys
->pi_x_offsets
[i_real_index
];
665 p_region
->i_y
= p_sys
->pi_y_offsets
[i_real_index
];
669 if( fmt_out
.i_width
> col_inner_width
||
670 p_sys
->b_ar
|| p_sys
->b_keep
)
672 /* we don't have to center the video since it takes the
673 whole rectangle area or it's larger than the rectangle */
674 p_region
->i_x
= p_sys
->i_xoffset
675 + i_col
* ( p_sys
->i_width
/ p_sys
->i_cols
)
676 + ( i_col
* p_sys
->i_borderw
) / p_sys
->i_cols
;
680 /* center the video in the dedicated rectangle */
681 p_region
->i_x
= p_sys
->i_xoffset
682 + i_col
* ( p_sys
->i_width
/ p_sys
->i_cols
)
683 + ( i_col
* p_sys
->i_borderw
) / p_sys
->i_cols
684 + ( col_inner_width
- fmt_out
.i_width
) / 2;
687 if( fmt_out
.i_height
> row_inner_height
688 || p_sys
->b_ar
|| p_sys
->b_keep
)
690 /* we don't have to center the video since it takes the
691 whole rectangle area or it's taller than the rectangle */
692 p_region
->i_y
= p_sys
->i_yoffset
693 + i_row
* ( p_sys
->i_height
/ p_sys
->i_rows
)
694 + ( i_row
* p_sys
->i_borderh
) / p_sys
->i_rows
;
698 /* center the video in the dedicated rectangle */
699 p_region
->i_y
= p_sys
->i_yoffset
700 + i_row
* ( p_sys
->i_height
/ p_sys
->i_rows
)
701 + ( i_row
* p_sys
->i_borderh
) / p_sys
->i_rows
702 + ( row_inner_height
- fmt_out
.i_height
) / 2;
705 p_region
->i_align
= p_sys
->i_align
;
706 p_region
->i_alpha
= p_es
->i_alpha
;
708 if( p_region_prev
== NULL
)
710 p_spu
->p_region
= p_region
;
714 p_region_prev
->p_next
= p_region
;
717 p_region_prev
= p_region
;
720 vlc_global_unlock( VLC_MOSAIC_MUTEX
);
721 vlc_mutex_unlock( &p_sys
->lock
);
726 /*****************************************************************************
727 * Callback to update params on the fly
728 *****************************************************************************/
729 static int MosaicCallback( vlc_object_t
*p_this
, char const *psz_var
,
730 vlc_value_t oldval
, vlc_value_t newval
,
734 filter_sys_t
*p_sys
= (filter_sys_t
*) p_data
;
736 #define VAR_IS( a ) !strcmp( psz_var, CFG_PREFIX a )
737 if( VAR_IS( "alpha" ) )
739 vlc_mutex_lock( &p_sys
->lock
);
740 msg_Dbg( p_this
, "changing alpha from %d/255 to %d/255",
741 p_sys
->i_alpha
, (int)newval
.i_int
);
742 p_sys
->i_alpha
= VLC_CLIP( newval
.i_int
, 0, 255 );
743 vlc_mutex_unlock( &p_sys
->lock
);
745 else if( VAR_IS( "height" ) )
747 vlc_mutex_lock( &p_sys
->lock
);
748 msg_Dbg( p_this
, "changing height from %dpx to %dpx",
749 p_sys
->i_height
, (int)newval
.i_int
);
750 p_sys
->i_height
= __MAX( newval
.i_int
, 0 );
751 vlc_mutex_unlock( &p_sys
->lock
);
753 else if( VAR_IS( "width" ) )
755 vlc_mutex_lock( &p_sys
->lock
);
756 msg_Dbg( p_this
, "changing width from %dpx to %dpx",
757 p_sys
->i_width
, (int)newval
.i_int
);
758 p_sys
->i_width
= __MAX( newval
.i_int
, 0 );
759 vlc_mutex_unlock( &p_sys
->lock
);
761 else if( VAR_IS( "xoffset" ) )
763 vlc_mutex_lock( &p_sys
->lock
);
764 msg_Dbg( p_this
, "changing x offset from %dpx to %dpx",
765 p_sys
->i_xoffset
, (int)newval
.i_int
);
766 p_sys
->i_xoffset
= __MAX( newval
.i_int
, 0 );
767 vlc_mutex_unlock( &p_sys
->lock
);
769 else if( VAR_IS( "yoffset" ) )
771 vlc_mutex_lock( &p_sys
->lock
);
772 msg_Dbg( p_this
, "changing y offset from %dpx to %dpx",
773 p_sys
->i_yoffset
, (int)newval
.i_int
);
774 p_sys
->i_yoffset
= __MAX( newval
.i_int
, 0 );
775 vlc_mutex_unlock( &p_sys
->lock
);
777 else if( VAR_IS( "align" ) )
779 int i_old
= 0, i_new
= 0;
780 vlc_mutex_lock( &p_sys
->lock
);
781 newval
.i_int
= VLC_CLIP( newval
.i_int
, 0, 10 );
782 if( newval
.i_int
== 3 || newval
.i_int
== 7 )
784 while( pi_align_values
[i_old
] != p_sys
->i_align
) i_old
++;
785 while( pi_align_values
[i_new
] != newval
.i_int
) i_new
++;
786 msg_Dbg( p_this
, "changing alignment from %d (%s) to %d (%s)",
787 p_sys
->i_align
, ppsz_align_descriptions
[i_old
],
788 (int)newval
.i_int
, ppsz_align_descriptions
[i_new
] );
789 p_sys
->i_align
= newval
.i_int
;
790 vlc_mutex_unlock( &p_sys
->lock
);
792 else if( VAR_IS( "borderw" ) )
794 vlc_mutex_lock( &p_sys
->lock
);
795 msg_Dbg( p_this
, "changing border width from %dpx to %dpx",
796 p_sys
->i_borderw
, (int)newval
.i_int
);
797 p_sys
->i_borderw
= __MAX( newval
.i_int
, 0 );
798 vlc_mutex_unlock( &p_sys
->lock
);
800 else if( VAR_IS( "borderh" ) )
802 vlc_mutex_lock( &p_sys
->lock
);
803 msg_Dbg( p_this
, "changing border height from %dpx to %dpx",
804 p_sys
->i_borderh
, (int)newval
.i_int
);
805 p_sys
->i_borderh
= __MAX( newval
.i_int
, 0 );
806 vlc_mutex_unlock( &p_sys
->lock
);
808 else if( VAR_IS( "position" ) )
810 if( newval
.i_int
> 2 || newval
.i_int
< 0 )
813 "Position is either 0 (%s), 1 (%s) or 2 (%s)",
814 ppsz_pos_descriptions
[0],
815 ppsz_pos_descriptions
[1],
816 ppsz_pos_descriptions
[2] );
820 vlc_mutex_lock( &p_sys
->lock
);
821 msg_Dbg( p_this
, "changing position method from %d (%s) to %d (%s)",
822 p_sys
->i_position
, ppsz_pos_descriptions
[p_sys
->i_position
],
823 (int)newval
.i_int
, ppsz_pos_descriptions
[newval
.i_int
]);
824 p_sys
->i_position
= newval
.i_int
;
825 vlc_mutex_unlock( &p_sys
->lock
);
828 else if( VAR_IS( "rows" ) )
830 vlc_mutex_lock( &p_sys
->lock
);
831 msg_Dbg( p_this
, "changing number of rows from %d to %d",
832 p_sys
->i_rows
, (int)newval
.i_int
);
833 p_sys
->i_rows
= __MAX( newval
.i_int
, 1 );
834 vlc_mutex_unlock( &p_sys
->lock
);
836 else if( VAR_IS( "cols" ) )
838 vlc_mutex_lock( &p_sys
->lock
);
839 msg_Dbg( p_this
, "changing number of columns from %d to %d",
840 p_sys
->i_cols
, (int)newval
.i_int
);
841 p_sys
->i_cols
= __MAX( newval
.i_int
, 1 );
842 vlc_mutex_unlock( &p_sys
->lock
);
844 else if( VAR_IS( "order" ) )
848 vlc_mutex_lock( &p_sys
->lock
);
849 msg_Dbg( p_this
, "Changing mosaic order to %s", newval
.psz_string
);
851 psz_order
= newval
.psz_string
;
853 while( p_sys
->i_order_length
-- )
855 free( p_sys
->ppsz_order
[p_sys
->i_order_length
] );
857 free( p_sys
->ppsz_order
);
858 p_sys
->ppsz_order
= NULL
;
862 char *psz_end
= NULL
;
866 psz_end
= strchr( psz_order
, ',' );
868 p_sys
->ppsz_order
= xrealloc( p_sys
->ppsz_order
,
869 i_index
* sizeof(char *) );
870 p_sys
->ppsz_order
[i_index
- 1] = strndup( psz_order
,
871 psz_end
- psz_order
);
872 psz_order
= psz_end
+1;
874 p_sys
->i_order_length
= i_index
;
877 vlc_mutex_unlock( &p_sys
->lock
);
879 else if( VAR_IS( "offsets" ) )
881 vlc_mutex_lock( &p_sys
->lock
);
882 msg_Info( p_this
, "Changing mosaic-offsets to %s", newval
.psz_string
);
884 if( p_sys
->i_offsets_length
!= 0 )
886 p_sys
->i_offsets_length
= 0;
887 free( p_sys
->pi_x_offsets
);
888 free( p_sys
->pi_y_offsets
);
889 p_sys
->pi_x_offsets
= NULL
;
890 p_sys
->pi_y_offsets
= NULL
;
893 mosaic_ParseSetOffsets( p_this
, p_sys
, newval
.psz_string
);
895 vlc_mutex_unlock( &p_sys
->lock
);
897 else if( VAR_IS( "keep-aspect-ratio" ) )
899 vlc_mutex_lock( &p_sys
->lock
);
902 msg_Dbg( p_this
, "keeping aspect ratio" );
907 msg_Dbg( p_this
, "won't keep aspect ratio" );
910 vlc_mutex_unlock( &p_sys
->lock
);
912 else if( VAR_IS( "keep-picture" ) )
914 vlc_mutex_lock( &p_sys
->lock
);
915 p_sys
->b_keep
= newval
.b_bool
;
916 if ( !p_sys
->b_keep
&& !p_sys
->p_image
)
918 p_sys
->p_image
= image_HandlerCreate( p_this
);
920 vlc_mutex_unlock( &p_sys
->lock
);