1 /*****************************************************************************
2 * mosaic.c : Mosaic video plugin for vlc
3 *****************************************************************************
4 * Copyright (C) 2004-2008 the VideoLAN team
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
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 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 General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, 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 */
61 vlc_mutex_t
*p_lock
; /* Pointer to mosaic bridge lock */
63 image_handler_t
*p_image
;
65 int i_position
; /* Mosaic positioning method */
66 bool b_ar
; /* Do we keep the aspect ratio ? */
67 bool b_keep
; /* Do we keep the original picture format ? */
68 int i_width
, i_height
; /* Mosaic height and width */
69 int i_cols
, i_rows
; /* Mosaic rows and cols */
70 int i_align
; /* Mosaic alignment in background video */
71 int i_xoffset
, i_yoffset
; /* Top left corner offset */
72 int i_borderw
, i_borderh
; /* Border width/height between miniatures */
73 int i_alpha
; /* Subfilter alpha blending */
75 char **ppsz_order
; /* List of picture-ids */
78 int *pi_x_offsets
; /* List of substreams x offsets */
79 int *pi_y_offsets
; /* List of substreams y offsets */
85 /*****************************************************************************
87 *****************************************************************************/
88 #define ALPHA_TEXT N_("Transparency")
89 #define ALPHA_LONGTEXT N_( \
90 "Transparency of the mosaic foreground pictures. " \
91 "0 means transparent, 255 opaque (default)." )
93 #define HEIGHT_TEXT N_("Height")
94 #define HEIGHT_LONGTEXT N_( "Total height of the mosaic, in pixels." )
95 #define WIDTH_TEXT N_("Width")
96 #define WIDTH_LONGTEXT N_( "Total width of the mosaic, in pixels." )
98 #define XOFFSET_TEXT N_("Top left corner X coordinate")
99 #define XOFFSET_LONGTEXT N_( \
100 "X Coordinate of the top-left corner of the mosaic.")
101 #define YOFFSET_TEXT N_("Top left corner Y coordinate")
102 #define YOFFSET_LONGTEXT N_( \
103 "Y Coordinate of the top-left corner of the mosaic.")
105 #define BORDERW_TEXT N_("Border width")
106 #define BORDERW_LONGTEXT N_( \
107 "Width in pixels of the border between miniatures." )
108 #define BORDERH_TEXT N_("Border height")
109 #define BORDERH_LONGTEXT N_( \
110 "Height in pixels of the border between miniatures." )
112 #define ALIGN_TEXT N_("Mosaic alignment" )
113 #define ALIGN_LONGTEXT N_( \
114 "You can enforce the mosaic alignment on the video " \
115 "(0=center, 1=left, 2=right, 4=top, 8=bottom, you can " \
116 "also use combinations of these values, eg 6 = top-right).")
118 #define POS_TEXT N_("Positioning method")
119 #define POS_LONGTEXT N_( \
120 "Positioning method for the mosaic. auto: " \
121 "automatically choose the best number of rows and columns. " \
122 "fixed: use the user-defined number of rows and columns. " \
123 "offsets: use the user-defined offsets for each image." )
125 #define ROWS_TEXT N_("Number of rows")
126 #define ROWS_LONGTEXT N_( \
127 "Number of image rows in the mosaic (only used if " \
128 "positionning method is set to \"fixed\")." )
130 #define COLS_TEXT N_("Number of columns")
131 #define COLS_LONGTEXT N_( \
132 "Number of image columns in the mosaic (only used if " \
133 "positionning method is set to \"fixed\"." )
135 #define AR_TEXT N_("Keep aspect ratio")
136 #define AR_LONGTEXT N_( \
137 "Keep the original aspect ratio when resizing " \
139 #define KEEP_TEXT N_("Keep original size")
140 #define KEEP_LONGTEXT N_( \
141 "Keep the original size of mosaic elements." )
143 #define ORDER_TEXT N_("Elements order" )
144 #define ORDER_LONGTEXT N_( \
145 "You can enforce the order of the elements on " \
146 "the mosaic. You must give a comma-separated list of picture ID(s)." \
147 "These IDs are assigned in the \"mosaic-bridge\" module." )
149 #define OFFSETS_TEXT N_("Offsets in order" )
150 #define OFFSETS_LONGTEXT N_( \
151 "You can enforce the (x,y) offsets of the elements on the mosaic " \
152 "(only used if positioning method is set to \"offsets\"). You " \
153 "must give a comma-separated list of coordinates (eg: 10,10,150,10)." )
155 #define DELAY_TEXT N_("Delay")
156 #define DELAY_LONGTEXT N_( \
157 "Pictures coming from the mosaic elements will be delayed " \
158 "according to this value (in milliseconds). For high " \
159 "values you will need to raise caching at input.")
163 position_auto
= 0, position_fixed
= 1, position_offsets
= 2
165 static const int pi_pos_values
[] = { 0, 1, 2 };
166 static const char *const ppsz_pos_descriptions
[] =
167 { N_("auto"), N_("fixed"), N_("offsets") };
169 static const int pi_align_values
[] = { 0, 1, 2, 4, 8, 5, 6, 9, 10 };
170 static const char *const ppsz_align_descriptions
[] =
171 { N_("Center"), N_("Left"), N_("Right"), N_("Top"), N_("Bottom"),
172 N_("Top-Left"), N_("Top-Right"), N_("Bottom-Left"), N_("Bottom-Right") };
174 #define CFG_PREFIX "mosaic-"
177 set_description( N_("Mosaic video sub filter") )
178 set_shortname( N_("Mosaic") )
179 set_category( CAT_VIDEO
)
180 set_subcategory( SUBCAT_VIDEO_SUBPIC
)
181 set_capability( "sub filter", 0 )
182 set_callbacks( CreateFilter
, DestroyFilter
)
184 add_integer_with_range( CFG_PREFIX
"alpha", 255, 0, 255, NULL
,
185 ALPHA_TEXT
, ALPHA_LONGTEXT
, false )
187 add_integer( CFG_PREFIX
"height", 100,
188 HEIGHT_TEXT
, HEIGHT_LONGTEXT
, false )
189 add_integer( CFG_PREFIX
"width", 100,
190 WIDTH_TEXT
, WIDTH_LONGTEXT
, false )
192 add_integer( CFG_PREFIX
"align", 5,
193 ALIGN_TEXT
, ALIGN_LONGTEXT
, true)
194 change_integer_list( pi_align_values
, ppsz_align_descriptions
)
196 add_integer( CFG_PREFIX
"xoffset", 0,
197 XOFFSET_TEXT
, XOFFSET_LONGTEXT
, true )
198 add_integer( CFG_PREFIX
"yoffset", 0,
199 YOFFSET_TEXT
, YOFFSET_LONGTEXT
, true )
201 add_integer( CFG_PREFIX
"borderw", 0,
202 BORDERW_TEXT
, BORDERW_LONGTEXT
, true )
203 add_deprecated_alias( CFG_PREFIX
"vborder" )
204 add_integer( CFG_PREFIX
"borderh", 0,
205 BORDERH_TEXT
, BORDERH_LONGTEXT
, true )
206 add_deprecated_alias( CFG_PREFIX
"hborder" )
208 add_integer( CFG_PREFIX
"position", 0,
209 POS_TEXT
, POS_LONGTEXT
, false )
210 change_integer_list( pi_pos_values
, ppsz_pos_descriptions
)
211 add_integer( CFG_PREFIX
"rows", 2,
212 ROWS_TEXT
, ROWS_LONGTEXT
, false )
213 add_integer( CFG_PREFIX
"cols", 2,
214 COLS_TEXT
, COLS_LONGTEXT
, false )
216 add_bool( CFG_PREFIX
"keep-aspect-ratio", false, NULL
,
217 AR_TEXT
, AR_LONGTEXT
, false )
218 add_bool( CFG_PREFIX
"keep-picture", false, NULL
,
219 KEEP_TEXT
, KEEP_LONGTEXT
, false )
221 add_string( CFG_PREFIX
"order", "",
222 ORDER_TEXT
, ORDER_LONGTEXT
, false )
224 add_string( CFG_PREFIX
"offsets", "",
225 OFFSETS_TEXT
, OFFSETS_LONGTEXT
, false )
227 add_integer( CFG_PREFIX
"delay", 0, DELAY_TEXT
, DELAY_LONGTEXT
,
231 static const char *const ppsz_filter_options
[] = {
232 "alpha", "height", "width", "align", "xoffset", "yoffset",
233 "borderw", "borderh", "position", "rows", "cols",
234 "keep-aspect-ratio", "keep-picture", "order", "offsets",
238 /*****************************************************************************
239 * mosaic_ParseSetOffsets:
240 * parse the "--mosaic-offsets x1,y1,x2,y2,x3,y3" parameter
241 * and set the corresponding struct filter_sys_t entries.
242 *****************************************************************************/
243 #define mosaic_ParseSetOffsets( a, b, c ) \
244 __mosaic_ParseSetOffsets( VLC_OBJECT( a ), b, c )
245 static void __mosaic_ParseSetOffsets( vlc_object_t
*p_this
,
251 char *psz_end
= NULL
;
257 p_sys
->pi_x_offsets
= xrealloc( p_sys
->pi_x_offsets
,
258 i_index
* sizeof(int) );
259 p_sys
->pi_x_offsets
[i_index
- 1] = atoi( psz_offsets
);
260 psz_end
= strchr( psz_offsets
, ',' );
261 psz_offsets
= psz_end
+ 1;
263 p_sys
->pi_y_offsets
= xrealloc( p_sys
->pi_y_offsets
,
264 i_index
* sizeof(int) );
265 p_sys
->pi_y_offsets
[i_index
- 1] = atoi( psz_offsets
);
266 psz_end
= strchr( psz_offsets
, ',' );
267 psz_offsets
= psz_end
+ 1;
269 msg_Dbg( p_this
, CFG_PREFIX
"offset: id %d, x=%d, y=%d",
270 i_index
, p_sys
->pi_x_offsets
[i_index
- 1],
271 p_sys
->pi_y_offsets
[i_index
- 1] );
274 p_sys
->i_offsets_length
= i_index
;
278 /*****************************************************************************
279 * CreateFiler: allocate mosaic video filter
280 *****************************************************************************/
281 static int CreateFilter( vlc_object_t
*p_this
)
283 filter_t
*p_filter
= (filter_t
*)p_this
;
285 vlc_object_t
*p_libvlc
= VLC_OBJECT( p_filter
->p_libvlc
);
286 char *psz_order
, *_psz_order
;
292 /* The mosaic thread is more important than the decoder threads */
293 vlc_thread_set_priority( p_this
, VLC_THREAD_PRIORITY_OUTPUT
);
295 /* Allocate structure */
296 p_sys
= p_filter
->p_sys
= malloc( sizeof( filter_sys_t
) );
300 p_filter
->pf_sub_filter
= Filter
;
302 vlc_mutex_init( &p_sys
->lock
);
303 vlc_mutex_lock( &p_sys
->lock
);
305 var_Create( p_libvlc
, "mosaic-lock", VLC_VAR_MUTEX
);
306 var_Get( p_libvlc
, "mosaic-lock", &val
);
307 p_sys
->p_lock
= val
.p_address
;
309 config_ChainParse( p_filter
, CFG_PREFIX
, ppsz_filter_options
,
312 #define GET_VAR( name, min, max ) \
313 i_command = var_CreateGetIntegerCommand( p_filter, CFG_PREFIX #name ); \
314 p_sys->i_##name = __MIN( max, __MAX( min, i_command ) ); \
315 var_AddCallback( p_filter, CFG_PREFIX #name, MosaicCallback, p_sys );
317 GET_VAR( width
, 0, INT_MAX
);
318 GET_VAR( height
, 0, INT_MAX
);
319 GET_VAR( xoffset
, 0, INT_MAX
);
320 GET_VAR( yoffset
, 0, INT_MAX
);
322 GET_VAR( align
, 0, 10 );
323 if( p_sys
->i_align
== 3 || p_sys
->i_align
== 7 )
326 GET_VAR( borderw
, 0, INT_MAX
);
327 GET_VAR( borderh
, 0, INT_MAX
);
328 GET_VAR( rows
, 1, INT_MAX
);
329 GET_VAR( cols
, 1, INT_MAX
);
330 GET_VAR( alpha
, 0, 255 );
331 GET_VAR( position
, 0, 2 );
332 GET_VAR( delay
, 100, INT_MAX
);
334 p_sys
->i_delay
*= 1000;
336 p_sys
->b_ar
= var_CreateGetBoolCommand( p_filter
,
337 CFG_PREFIX
"keep-aspect-ratio" );
338 var_AddCallback( p_filter
, CFG_PREFIX
"keep-aspect-ratio", MosaicCallback
,
341 p_sys
->b_keep
= var_CreateGetBoolCommand( p_filter
,
342 CFG_PREFIX
"keep-picture" );
343 if ( !p_sys
->b_keep
)
345 p_sys
->p_image
= image_HandlerCreate( p_filter
);
348 p_sys
->i_order_length
= 0;
349 p_sys
->ppsz_order
= NULL
;
350 psz_order
= var_CreateGetStringCommand( p_filter
, CFG_PREFIX
"order" );
351 _psz_order
= psz_order
;
352 var_AddCallback( p_filter
, CFG_PREFIX
"order", MosaicCallback
, p_sys
);
356 char *psz_end
= NULL
;
360 psz_end
= strchr( psz_order
, ',' );
362 p_sys
->ppsz_order
= xrealloc( p_sys
->ppsz_order
,
363 i_index
* sizeof(char *) );
364 p_sys
->ppsz_order
[i_index
- 1] = strndup( psz_order
,
365 psz_end
- psz_order
);
366 psz_order
= psz_end
+1;
368 p_sys
->i_order_length
= i_index
;
373 /* Manage specific offsets for substreams */
374 psz_offsets
= var_CreateGetStringCommand( p_filter
, CFG_PREFIX
"offsets" );
375 p_sys
->i_offsets_length
= 0;
376 p_sys
->pi_x_offsets
= NULL
;
377 p_sys
->pi_y_offsets
= NULL
;
378 mosaic_ParseSetOffsets( p_filter
, p_sys
, psz_offsets
);
380 var_AddCallback( p_filter
, CFG_PREFIX
"offsets", MosaicCallback
, p_sys
);
382 vlc_mutex_unlock( &p_sys
->lock
);
387 /*****************************************************************************
388 * DestroyFilter: destroy mosaic video filter
389 *****************************************************************************/
390 static void DestroyFilter( vlc_object_t
*p_this
)
392 filter_t
*p_filter
= (filter_t
*)p_this
;
393 filter_sys_t
*p_sys
= p_filter
->p_sys
;
395 #define DEL_CB( name ) \
396 var_DelCallback( p_filter, CFG_PREFIX #name, MosaicCallback, p_sys )
412 DEL_CB( keep
-aspect
-ratio
);
418 image_HandlerDelete( p_sys
->p_image
);
421 if( p_sys
->i_order_length
)
423 for( int i_index
= 0; i_index
< p_sys
->i_order_length
; i_index
++ )
425 free( p_sys
->ppsz_order
[i_index
] );
427 free( p_sys
->ppsz_order
);
429 if( p_sys
->i_offsets_length
)
431 free( p_sys
->pi_x_offsets
);
432 free( p_sys
->pi_y_offsets
);
433 p_sys
->i_offsets_length
= 0;
436 vlc_mutex_destroy( &p_sys
->lock
);
440 /*****************************************************************************
442 *****************************************************************************/
443 static subpicture_t
*Filter( filter_t
*p_filter
, mtime_t date
)
445 filter_sys_t
*p_sys
= p_filter
->p_sys
;
450 int i_index
, i_real_index
, i_row
, i_col
;
451 int i_greatest_real_index_used
= p_sys
->i_order_length
- 1;
453 unsigned int col_inner_width
, row_inner_height
;
455 subpicture_region_t
*p_region
;
456 subpicture_region_t
*p_region_prev
= NULL
;
458 /* Allocate the subpicture internal data. */
459 p_spu
= filter_NewSubpicture( p_filter
);
463 /* Initialize subpicture */
464 p_spu
->i_channel
= 0;
465 p_spu
->i_start
= date
;
467 p_spu
->b_ephemer
= true;
468 p_spu
->i_alpha
= p_sys
->i_alpha
;
469 p_spu
->b_absolute
= false;
471 vlc_mutex_lock( &p_sys
->lock
);
472 vlc_mutex_lock( p_sys
->p_lock
);
474 p_bridge
= GetBridge( p_filter
);
475 if ( p_bridge
== NULL
)
477 vlc_mutex_unlock( p_sys
->p_lock
);
478 vlc_mutex_unlock( &p_sys
->lock
);
482 if ( p_sys
->i_position
== position_offsets
)
484 /* If we have either too much or not enough offsets, fall-back
485 * to automatic positioning. */
486 if ( p_sys
->i_offsets_length
!= p_sys
->i_order_length
)
489 "Number of specified offsets (%d) does not match number "
490 "of input substreams in mosaic-order (%d), falling back "
491 "to mosaic-position=0",
492 p_sys
->i_offsets_length
, p_sys
->i_order_length
);
493 p_sys
->i_position
= position_auto
;
497 if ( p_sys
->i_position
== position_auto
)
499 int i_numpics
= p_sys
->i_order_length
; /* keep slots and all */
500 for ( i_index
= 0; i_index
< p_bridge
->i_es_num
; i_index
++ )
502 bridged_es_t
*p_es
= p_bridge
->pp_es
[i_index
];
503 if ( !p_es
->b_empty
)
506 if( p_sys
->i_order_length
&& p_es
->psz_id
!= NULL
)
508 /* We also want to leave slots for images given in
509 * mosaic-order that are not available in p_vout_picture */
511 for( i
= 0; i
< p_sys
->i_order_length
; i
++ )
513 if( !strcmp( p_sys
->ppsz_order
[i
], p_es
->psz_id
) )
523 p_sys
->i_rows
= ceil(sqrt( (double)i_numpics
));
524 p_sys
->i_cols
= ( i_numpics
% p_sys
->i_rows
== 0 ?
525 i_numpics
/ p_sys
->i_rows
:
526 i_numpics
/ p_sys
->i_rows
+ 1 );
529 col_inner_width
= ( ( p_sys
->i_width
- ( p_sys
->i_cols
- 1 )
530 * p_sys
->i_borderw
) / p_sys
->i_cols
);
531 row_inner_height
= ( ( p_sys
->i_height
- ( p_sys
->i_rows
- 1 )
532 * p_sys
->i_borderh
) / p_sys
->i_rows
);
536 for ( i_index
= 0; i_index
< p_bridge
->i_es_num
; i_index
++ )
538 bridged_es_t
*p_es
= p_bridge
->pp_es
[i_index
];
539 video_format_t fmt_in
, fmt_out
;
540 picture_t
*p_converted
;
542 memset( &fmt_in
, 0, sizeof( video_format_t
) );
543 memset( &fmt_out
, 0, sizeof( video_format_t
) );
548 while ( p_es
->p_picture
!= NULL
549 && p_es
->p_picture
->date
+ p_sys
->i_delay
< date
)
551 if ( p_es
->p_picture
->p_next
!= NULL
)
553 picture_t
*p_next
= p_es
->p_picture
->p_next
;
554 picture_Release( p_es
->p_picture
);
555 p_es
->p_picture
= p_next
;
557 else if ( p_es
->p_picture
->date
+ p_sys
->i_delay
+ BLANK_DELAY
<
561 picture_Release( p_es
->p_picture
);
562 p_es
->p_picture
= NULL
;
563 p_es
->pp_last
= &p_es
->p_picture
;
568 msg_Dbg( p_filter
, "too late picture for %s (%"PRId64
")",
570 date
- p_es
->p_picture
->date
- p_sys
->i_delay
);
575 if ( p_es
->p_picture
== NULL
)
578 if ( p_sys
->i_order_length
== 0 )
585 for ( i
= 0; i
<= p_sys
->i_order_length
; i
++ )
587 if ( i
== p_sys
->i_order_length
) break;
588 if ( strcmp( p_es
->psz_id
, p_sys
->ppsz_order
[i
] ) == 0 )
594 if ( i
== p_sys
->i_order_length
)
595 i_real_index
= ++i_greatest_real_index_used
;
597 i_row
= ( i_real_index
/ p_sys
->i_cols
) % p_sys
->i_rows
;
598 i_col
= i_real_index
% p_sys
->i_cols
;
600 if ( !p_sys
->b_keep
)
602 /* Convert the images */
603 fmt_in
.i_chroma
= p_es
->p_picture
->format
.i_chroma
;
604 fmt_in
.i_height
= p_es
->p_picture
->format
.i_height
;
605 fmt_in
.i_width
= p_es
->p_picture
->format
.i_width
;
607 if( fmt_in
.i_chroma
== VLC_CODEC_YUVA
||
608 fmt_in
.i_chroma
== VLC_CODEC_RGBA
)
609 fmt_out
.i_chroma
= VLC_CODEC_YUVA
;
611 fmt_out
.i_chroma
= VLC_CODEC_I420
;
612 fmt_out
.i_width
= col_inner_width
;
613 fmt_out
.i_height
= row_inner_height
;
615 if( p_sys
->b_ar
) /* keep aspect ratio */
617 if( (float)fmt_out
.i_width
/ (float)fmt_out
.i_height
618 > (float)fmt_in
.i_width
/ (float)fmt_in
.i_height
)
620 fmt_out
.i_width
= ( fmt_out
.i_height
* fmt_in
.i_width
)
625 fmt_out
.i_height
= ( fmt_out
.i_width
* fmt_in
.i_height
)
630 fmt_out
.i_visible_width
= fmt_out
.i_width
;
631 fmt_out
.i_visible_height
= fmt_out
.i_height
;
633 p_converted
= image_Convert( p_sys
->p_image
, p_es
->p_picture
,
638 "image resizing and chroma conversion failed" );
644 p_converted
= p_es
->p_picture
;
645 fmt_in
.i_width
= fmt_out
.i_width
= p_converted
->format
.i_width
;
646 fmt_in
.i_height
= fmt_out
.i_height
= p_converted
->format
.i_height
;
647 fmt_in
.i_chroma
= fmt_out
.i_chroma
= p_converted
->format
.i_chroma
;
648 fmt_out
.i_visible_width
= fmt_out
.i_width
;
649 fmt_out
.i_visible_height
= fmt_out
.i_height
;
652 p_region
= subpicture_region_New( &fmt_out
);
653 /* FIXME the copy is probably not needed anymore */
655 picture_Copy( p_region
->p_picture
, p_converted
);
657 picture_Release( p_converted
);
661 msg_Err( p_filter
, "cannot allocate SPU region" );
662 p_filter
->pf_sub_buffer_del( p_filter
, p_spu
);
663 vlc_mutex_unlock( p_sys
->p_lock
);
664 vlc_mutex_unlock( &p_sys
->lock
);
668 if( p_es
->i_x
>= 0 && p_es
->i_y
>= 0 )
670 p_region
->i_x
= p_es
->i_x
;
671 p_region
->i_y
= p_es
->i_y
;
673 else if( p_sys
->i_position
== position_offsets
)
675 p_region
->i_x
= p_sys
->pi_x_offsets
[i_real_index
];
676 p_region
->i_y
= p_sys
->pi_y_offsets
[i_real_index
];
680 if( fmt_out
.i_width
> col_inner_width
||
681 p_sys
->b_ar
|| p_sys
->b_keep
)
683 /* we don't have to center the video since it takes the
684 whole rectangle area or it's larger than the rectangle */
685 p_region
->i_x
= p_sys
->i_xoffset
686 + i_col
* ( p_sys
->i_width
/ p_sys
->i_cols
)
687 + ( i_col
* p_sys
->i_borderw
) / p_sys
->i_cols
;
691 /* center the video in the dedicated rectangle */
692 p_region
->i_x
= p_sys
->i_xoffset
693 + i_col
* ( p_sys
->i_width
/ p_sys
->i_cols
)
694 + ( i_col
* p_sys
->i_borderw
) / p_sys
->i_cols
695 + ( col_inner_width
- fmt_out
.i_width
) / 2;
698 if( fmt_out
.i_height
> row_inner_height
699 || p_sys
->b_ar
|| p_sys
->b_keep
)
701 /* we don't have to center the video since it takes the
702 whole rectangle area or it's taller than the rectangle */
703 p_region
->i_y
= p_sys
->i_yoffset
704 + i_row
* ( p_sys
->i_height
/ p_sys
->i_rows
)
705 + ( i_row
* p_sys
->i_borderh
) / p_sys
->i_rows
;
709 /* center the video in the dedicated rectangle */
710 p_region
->i_y
= p_sys
->i_yoffset
711 + i_row
* ( p_sys
->i_height
/ p_sys
->i_rows
)
712 + ( i_row
* p_sys
->i_borderh
) / p_sys
->i_rows
713 + ( row_inner_height
- fmt_out
.i_height
) / 2;
716 p_region
->i_align
= p_sys
->i_align
;
717 p_region
->i_alpha
= p_es
->i_alpha
;
719 if( p_region_prev
== NULL
)
721 p_spu
->p_region
= p_region
;
725 p_region_prev
->p_next
= p_region
;
728 p_region_prev
= p_region
;
731 vlc_mutex_unlock( p_sys
->p_lock
);
732 vlc_mutex_unlock( &p_sys
->lock
);
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
,
745 filter_sys_t
*p_sys
= (filter_sys_t
*) p_data
;
747 #define VAR_IS( a ) !strcmp( psz_var, CFG_PREFIX a )
748 if( VAR_IS( "alpha" ) )
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
= __MIN( __MAX( newval
.i_int
, 0 ), 255 );
754 vlc_mutex_unlock( &p_sys
->lock
);
756 else if( VAR_IS( "height" ) )
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
);
764 else if( VAR_IS( "width" ) )
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
);
772 else if( VAR_IS( "xoffset" ) )
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
);
780 else if( VAR_IS( "yoffset" ) )
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
);
788 else if( VAR_IS( "align" ) )
790 int i_old
= 0, i_new
= 0;
791 vlc_mutex_lock( &p_sys
->lock
);
792 newval
.i_int
= __MIN( __MAX( newval
.i_int
, 0 ), 10 );
793 if( newval
.i_int
== 3 || newval
.i_int
== 7 )
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
);
803 else if( VAR_IS( "borderw" ) )
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
);
811 else if( VAR_IS( "borderh" ) )
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
);
819 else if( VAR_IS( "position" ) )
821 if( newval
.i_int
> 2 || newval
.i_int
< 0 )
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] );
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
);
839 else if( VAR_IS( "rows" ) )
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
);
847 else if( VAR_IS( "cols" ) )
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
);
855 else if( VAR_IS( "order" ) )
859 vlc_mutex_lock( &p_sys
->lock
);
860 msg_Dbg( p_this
, "Changing mosaic order to %s", newval
.psz_string
);
862 psz_order
= newval
.psz_string
;
864 while( p_sys
->i_order_length
-- )
866 free( p_sys
->ppsz_order
[p_sys
->i_order_length
] );
868 free( p_sys
->ppsz_order
);
869 p_sys
->ppsz_order
= NULL
;
873 char *psz_end
= NULL
;
877 psz_end
= strchr( psz_order
, ',' );
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;
885 p_sys
->i_order_length
= i_index
;
888 vlc_mutex_unlock( &p_sys
->lock
);
890 else if( VAR_IS( "offsets" ) )
892 vlc_mutex_lock( &p_sys
->lock
);
893 msg_Info( p_this
, "Changing mosaic-offsets to %s", newval
.psz_string
);
895 if( p_sys
->i_offsets_length
!= 0 )
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
;
904 mosaic_ParseSetOffsets( p_this
, p_sys
, newval
.psz_string
);
906 vlc_mutex_unlock( &p_sys
->lock
);
908 else if( VAR_IS( "keep-aspect-ratio" ) )
910 vlc_mutex_lock( &p_sys
->lock
);
913 msg_Dbg( p_this
, "keeping aspect ratio" );
918 msg_Dbg( p_this
, "won't keep aspect ratio" );
921 vlc_mutex_unlock( &p_sys
->lock
);
923 else if( VAR_IS( "keep-picture" ) )
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
)
929 p_sys
->p_image
= image_HandlerCreate( p_this
);
931 vlc_mutex_unlock( &p_sys
->lock
);