git.sesse.net Git - vlc/blob - modules/video_filter/mosaic.c

   1 /*****************************************************************************
   2 * mosaic.c : Mosaic video plugin for vlc
   3 *****************************************************************************
   4 * Copyright (C) 2004-2005 VideoLAN
   5 * $Id: $
   6 *
   7 * Authors: Antoine Cellerier <dionoea@via.ecp.fr>
   8 *
   9 * This program is free software; you can redistribute it and/or modify
  10 * it under the terms of the GNU General Public License as published by
  11 * the Free Software Foundation; either version 2 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 General Public License for more details.
  18 *
  19 * You should have received a copy of the GNU General Public License
  20 * along with this program; if not, write to the Free Software
  21 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  22 *****************************************************************************/
  23
  24 /*****************************************************************************
  25 * Preamble
  26 *****************************************************************************/
  27 #include <stdlib.h>                                      /* malloc(), free() */
  28 #include <string.h>
  29 #include <math.h>
  30
  31 #include <vlc/vlc.h>
  32 #include <vlc/vout.h>
  33
  34 #include "vlc_filter.h"
  35 #include "vlc_input.h"
  36
  37 #include "vlc_image.h"
  38
  39 /*****************************************************************************
  40 * Local prototypes
  41 *****************************************************************************/
  42
  43 static int  CreateFilter    ( vlc_object_t * );
  44 static void DestroyFilter   ( vlc_object_t * );
  45
  46 static subpicture_t *Filter( filter_t *, mtime_t );
  47
  48 static int MosaicCallback( vlc_object_t *, char const *, vlc_value_t,
  49                             vlc_value_t, void * );
  50
  51 /*****************************************************************************
  52 * filter_sys_t : filter desriptor
  53 *****************************************************************************/
  54
  55 #include "../video_output/picture.h"
  56
  57 struct filter_sys_t
  58 {
  59
  60     image_handler_t *p_image;
  61     image_handler_t *p_image2;
  62     picture_t *p_pic;
  63
  64     int i_pos; /* mosaic positioning method */
  65     int i_ar; /* do we keep aspect ratio ? */
  66     int i_width, i_height; /* mosaic height and width */
  67     int i_cols, i_rows; /* mosaic rows and cols */
  68     int i_xoffset, i_yoffset; /* top left corner offset */
  69     int i_vborder, i_hborder; /* border width/height between miniatures */
  70     int i_alpha; /* subfilter alpha blending */
  71
  72 };
  73
  74 /*****************************************************************************
  75 * Module descriptor
  76 *****************************************************************************/
  77
  78 #define ALPHA_TEXT N_("Mosaic alpha blending (0 -> 255)")
  79 #define ALPHA_LONGTEXT N_("Mosaic alpha blending (0 -> 255). default is 255")
  80
  81 #define HEIGHT_TEXT N_("Mosaic height in pixels")
  82 #define WIDTH_TEXT N_("Mosaic width in pixels")
  83 #define XOFFSET_TEXT N_("Mosaic top left corner x coordinate")
  84 #define YOFFSET_TEXT N_("Mosaic top left corner y coordinate")
  85 #define VBORDER_TEXT N_("Mosaic vertical border width in pixels")
  86 #define HBORDER_TEXT N_("Mosaic horizontal border width in pixels")
  87
  88 #define POS_TEXT N_("Mosaic positioning method")
  89 #define POS_LONGTEXT N_("Mosaic positioning method. auto : automatically chose the best number of rows and columns. fixed : used the user defined number of rows and columns.")
  90 #define ROWS_TEXT N_("Mosaic number of rows")
  91 #define COLS_TEXT N_("Mosaic number of columns")
  92 #define AR_TEXT N_("Keep aspect ratio when resizing")
  93
  94 static int pi_pos_values[] = { 0, 1 };
  95 static char * ppsz_pos_descriptions[] =
  96 { N_("auto"), N_("fixed") };
  97
  98
  99 vlc_module_begin();
 100     set_description( _("Mosaic video sub filter") );
 101     set_shortname( N_("Mosaic") );
 102     set_capability( "sub filter", 0 );
 103     set_category( CAT_VIDEO );
 104     set_subcategory( SUBCAT_VIDEO_SUBPIC );
 105     set_callbacks( CreateFilter, DestroyFilter );
 106
 107     add_integer( "mosaic-alpha", 255, NULL, ALPHA_TEXT, ALPHA_LONGTEXT, VLC_FALSE );
 108     add_integer( "mosaic-height", 100, NULL, HEIGHT_TEXT, HEIGHT_TEXT, VLC_FALSE );
 109     add_integer( "mosaic-width", 100, NULL, WIDTH_TEXT, WIDTH_TEXT, VLC_FALSE );
 110     add_integer( "mosaic-xoffset", 0, NULL, XOFFSET_TEXT, XOFFSET_TEXT, VLC_TRUE );
 111     add_integer( "mosaic-yoffset", 0, NULL, YOFFSET_TEXT, YOFFSET_TEXT, VLC_TRUE );
 112     add_integer( "mosaic-vborder", 0, NULL, VBORDER_TEXT, VBORDER_TEXT, VLC_TRUE );
 113     add_integer( "mosaic-hborder", 0, NULL, HBORDER_TEXT, HBORDER_TEXT, VLC_TRUE );
 114
 115     add_integer( "mosaic-position", 0, NULL, POS_TEXT, POS_LONGTEXT, VLC_FALSE );
 116         change_integer_list( pi_pos_values, ppsz_pos_descriptions, 0 );
 117     add_integer( "mosaic-rows", 2, NULL, ROWS_TEXT, ROWS_TEXT, VLC_FALSE );
 118     add_integer( "mosaic-cols", 2, NULL, COLS_TEXT, COLS_TEXT, VLC_FALSE );
 119     add_bool( "mosaic-keep-aspect-ratio", 0, NULL, AR_TEXT, AR_TEXT, VLC_FALSE );
 120 vlc_module_end();
 121
 122
 123 /*****************************************************************************
 124 * CreateFiler: allocates mosaic video filter
 125 *****************************************************************************/
 126
 127 static int CreateFilter( vlc_object_t *p_this )
 128 {
 129     filter_t *p_filter = (filter_t *)p_this;
 130     filter_sys_t *p_sys;
 131
 132     /* Allocate structure */
 133     p_sys = p_filter->p_sys = malloc( sizeof( filter_sys_t ) );
 134     if( p_sys == NULL )
 135     {
 136         msg_Err( p_filter, "out of memory" );
 137         return VLC_ENOMEM;
 138     }
 139     p_sys->p_image = image_HandlerCreate( p_filter );
 140     p_sys->p_image2 = image_HandlerCreate( p_filter );
 141
 142     p_filter->pf_sub_filter = Filter;
 143     p_sys->p_pic = NULL;
 144
 145     p_sys->i_width = __MAX( 0, var_CreateGetInteger( p_filter->p_libvlc, "mosaic-width" ) );
 146     p_sys->i_height = __MAX( 0, var_CreateGetInteger( p_filter->p_libvlc, "mosaic-height" ) );
 147
 148     p_sys->i_xoffset = __MAX( 0, var_CreateGetInteger( p_filter->p_libvlc, "mosaic-xoffset" ) );
 149     p_sys->i_yoffset = __MAX( 0, var_CreateGetInteger( p_filter->p_libvlc, "mosaic-yoffset" ) );
 150
 151     p_sys->i_vborder = __MAX( 0, var_CreateGetInteger( p_filter->p_libvlc, "mosaic-vborder" ) );
 152     p_sys->i_hborder = __MAX( 0, var_CreateGetInteger( p_filter->p_libvlc, "mosaic-hborder" ) );
 153
 154     p_sys->i_rows = __MAX( 1, var_CreateGetInteger( p_filter->p_libvlc, "mosaic-rows") );
 155     p_sys->i_cols = __MAX( 1, var_CreateGetInteger( p_filter->p_libvlc, "mosaic-cols") );
 156
 157     p_sys->i_alpha = var_CreateGetInteger( p_filter->p_libvlc, "mosaic-alpha" );
 158     p_sys->i_alpha = __MIN( 255, __MAX( 0, p_sys->i_alpha ) );
 159
 160     p_sys->i_pos = var_CreateGetInteger( p_filter->p_libvlc, "mosaic-position" );
 161     if( p_sys->i_pos > 1 || p_sys->i_pos < 0 ) p_sys->i_pos = 0;
 162
 163     p_sys->i_ar = var_CreateGetInteger( p_filter->p_libvlc, "mosaic-keep-aspect-ratio" );
 164
 165     var_AddCallback( p_filter->p_libvlc, "mosaic-alpha",
 166                      MosaicCallback, p_sys );
 167     var_AddCallback( p_filter->p_libvlc, "mosaic-height",
 168                      MosaicCallback, p_sys );
 169     var_AddCallback( p_filter->p_libvlc, "mosaic-width",
 170                      MosaicCallback, p_sys );
 171     var_AddCallback( p_filter->p_libvlc, "mosaic-xoffset",
 172                      MosaicCallback, p_sys );
 173     var_AddCallback( p_filter->p_libvlc, "mosaic-yoffset",
 174                      MosaicCallback, p_sys );
 175     var_AddCallback( p_filter->p_libvlc, "mosaic-vborder",
 176                      MosaicCallback, p_sys );
 177     var_AddCallback( p_filter->p_libvlc, "mosaic-hborder",
 178                      MosaicCallback, p_sys );
 179     var_AddCallback( p_filter->p_libvlc, "mosaic-position",
 180                      MosaicCallback, p_sys );
 181     var_AddCallback( p_filter->p_libvlc, "mosaic-rows",
 182                      MosaicCallback, p_sys );
 183     var_AddCallback( p_filter->p_libvlc, "mosaic-cols",
 184                      MosaicCallback, p_sys );
 185     var_AddCallback( p_filter->p_libvlc, "mosaic-keep-aspect-ratio",
 186                      MosaicCallback, p_sys );
 187
 188     return VLC_SUCCESS;
 189 }
 190
 191 /*****************************************************************************
 192 * DestroyFilter: destroy mosaic video filter
 193 *****************************************************************************/
 194
 195 static void DestroyFilter( vlc_object_t *p_this )
 196 {
 197     filter_t *p_filter = (filter_t*)p_this;
 198     filter_sys_t *p_sys = p_filter->p_sys;
 199
 200     image_HandlerDelete( p_sys->p_image );
 201     image_HandlerDelete( p_sys->p_image2 );
 202
 203     var_Destroy( p_filter->p_libvlc, "mosaic-alpha" );
 204     var_Destroy( p_filter->p_libvlc, "mosaic-height" );
 205     var_Destroy( p_filter->p_libvlc, "mosaic-width" );
 206     var_Destroy( p_filter->p_libvlc, "mosaic-xoffset" );
 207     var_Destroy( p_filter->p_libvlc, "mosaic-yoffset" );
 208     var_Destroy( p_filter->p_libvlc, "mosaic-vborder" );
 209     var_Destroy( p_filter->p_libvlc, "mosaic-hborder" );
 210     var_Destroy( p_filter->p_libvlc, "mosaic-position" );
 211     var_Destroy( p_filter->p_libvlc, "mosaic-rows" );
 212     var_Destroy( p_filter->p_libvlc, "mosaic-cols" );
 213     var_Destroy( p_filter->p_libvlc, "mosaic-keep-aspect-ratio" );
 214     if( p_sys->p_pic ) p_sys->p_pic->pf_release( p_sys->p_pic );
 215     free( p_sys );
 216 }
 217
 218 /*****************************************************************************
 219 * Filter
 220 *****************************************************************************/
 221
 222 static subpicture_t *Filter( filter_t *p_filter, mtime_t date )
 223 {
 224
 225     filter_sys_t *p_sys = p_filter->p_sys;
 226     subpicture_t *p_spu;
 227
 228     libvlc_t *p_libvlc = p_filter->p_libvlc;
 229     vlc_value_t val;
 230     int i_index;
 231
 232     subpicture_region_t *p_region;
 233     subpicture_region_t *p_region_prev = NULL;
 234
 235     struct picture_vout_t *p_picture_vout;
 236
 237     if( var_Get( p_libvlc, "p_picture_vout", &val ) )
 238     {
 239         return NULL;
 240     }
 241
 242     /* Allocate the subpicture internal data. */
 243     p_spu = p_filter->pf_sub_buffer_new( p_filter );
 244     if( !p_spu )
 245     {
 246         return NULL;
 247     }
 248
 249     p_picture_vout = val.p_address;
 250
 251     vlc_mutex_lock( &p_picture_vout->lock );
 252
 253     if( p_sys->i_pos == 0 ) /* use automatic positioning */
 254     {
 255         int i_numpics = 0;
 256         for( i_index = 0 ;
 257              i_index < p_picture_vout->i_picture_num ;
 258              i_index ++ )
 259         {
 260             if( p_picture_vout->p_pic[i_index].i_status
 261                            == PICTURE_VOUT_E_OCCUPIED ) {
 262                 i_numpics ++;
 263             }
 264         }
 265         p_sys->i_rows = ((int)ceil(sqrt( (float)i_numpics )));
 266         p_sys->i_cols = ( i_numpics%p_sys->i_rows == 0 ?
 267                             i_numpics/p_sys->i_rows :
 268                             i_numpics/p_sys->i_rows + 1 );
 269     }
 270
 271     for( i_index = 0 ; i_index < p_picture_vout->i_picture_num ; i_index ++ )
 272     {
 273
 274         video_format_t fmt_in = {0}, fmt_middle = {0}, fmt_out = {0};
 275
 276         picture_t *p_converted, *p_middle;
 277
 278         if(  p_picture_vout->p_pic[i_index].p_picture == NULL )
 279         {
 280             break;
 281         }
 282
 283         if(  p_picture_vout->p_pic[i_index].i_status
 284                == PICTURE_VOUT_E_AVAILABLE )
 285         {
 286             msg_Dbg( p_filter, "Picture Vout Element is empty");
 287             break;
 288         }
 289
 290
 291         /* Convert the images */
 292 /*        fprintf (stderr, "Input image %ix%i %4.4s\n",
 293                   p_picture_vout->p_pic[i_index].p_picture->format.i_width,
 294                   p_picture_vout->p_pic[i_index].p_picture->format.i_height,
 295                   (char *)&p_picture_vout->p_pic[i_index].p_picture->format.i_chroma );*/
 296
 297         fmt_in.i_chroma = p_picture_vout->p_pic[i_index].
 298                                                 p_picture->format.i_chroma;
 299         fmt_in.i_height = p_picture_vout->p_pic[i_index].
 300                                                 p_picture->format.i_height;
 301         fmt_in.i_width = p_picture_vout->p_pic[i_index].
 302                                                 p_picture->format.i_width;
 303
 304
 305         fmt_out.i_chroma = VLC_FOURCC('Y','U','V','A');
 306         fmt_out.i_width = fmt_in.i_width *( p_sys->i_width / p_sys->i_cols ) / fmt_in.i_width;
 307         fmt_out.i_height = fmt_in.i_height*( p_sys->i_height / p_sys->i_rows ) / fmt_in.i_height;
 308         if( p_sys->i_ar ) /* keep aspect ratio */
 309         {
 310             if( (float)fmt_out.i_width/(float)fmt_out.i_height
 311                 > (float)fmt_in.i_width/(float)fmt_in.i_height )
 312             {
 313                 fmt_out.i_width = ( fmt_out.i_height * fmt_in.i_width ) / fmt_in.i_height ;
 314             } else {
 315                 fmt_out.i_height = ( fmt_out.i_width * fmt_in.i_height ) / fmt_in.i_width ;
 316             }
 317          }
 318
 319         fmt_out.i_visible_width = fmt_out.i_width;
 320         fmt_out.i_visible_height = fmt_out.i_height;
 321
 322         fmt_middle.i_chroma = fmt_in.i_chroma;
 323         fmt_middle.i_visible_width = fmt_middle.i_width = fmt_out.i_width;
 324         fmt_middle.i_visible_height = fmt_middle.i_height = fmt_out.i_height;
 325
 326         p_middle = image_Convert( p_sys->p_image,
 327             p_picture_vout->p_pic[i_index].p_picture, &fmt_in, &fmt_middle );
 328         if( !p_middle )
 329         {
 330             vlc_mutex_unlock( &p_picture_vout->lock );
 331             return NULL;
 332         }
 333
 334         p_converted = image_Convert( p_sys->p_image2,
 335                  p_middle, &fmt_middle, &fmt_out );
 336         if( !p_converted )
 337         {
 338             vlc_mutex_unlock( &p_picture_vout->lock );
 339             return NULL;
 340         }
 341
 342 /*        fprintf( stderr, "Converted %ix%i %4.4s\n", p_converted->format.i_width, p_converted->format.i_height, (char *)&p_converted->format.i_chroma);*/
 343
 344
 345         p_region = p_spu->pf_create_region( VLC_OBJECT(p_filter), &fmt_out);
 346         if( !p_region )
 347         {
 348             msg_Err( p_filter, "cannot allocate SPU region" );
 349             p_filter->pf_sub_buffer_del( p_filter, p_spu );
 350             vlc_mutex_unlock( &p_picture_vout->lock );
 351             return NULL;
 352         }
 353
 354         if( p_sys->i_ar ) /* keep aspect ratio */
 355         {
 356             /* center the video in the dedicated rectangle */
 357             p_region->i_x = p_sys->i_xoffset + ( i_index % p_sys->i_cols )
 358                             * ( p_sys->i_width / p_sys->i_cols
 359                                 + p_sys->i_vborder )
 360                         + ( fmt_in.i_width *( p_sys->i_width / p_sys->i_cols )
 361                             / fmt_in.i_width - fmt_out.i_width ) / 2;
 362             p_region->i_y = p_sys->i_yoffset
 363                         + ( ( i_index / p_sys->i_cols ) % p_sys->i_rows )
 364                             * ( p_sys->i_height / p_sys->i_rows
 365                                 + p_sys->i_hborder )
 366                         + ( fmt_in.i_height*( p_sys->i_height / p_sys->i_rows )
 367                         / fmt_in.i_height - fmt_out.i_height ) / 2;
 368         } else {
 369             /* we don't have to center the video since it takes the
 370             whole rectangle area */
 371             p_region->i_x = p_sys->i_xoffset + ( i_index % p_sys->i_cols )
 372                             * ( p_sys->i_width / p_sys->i_cols
 373                                 + p_sys->i_vborder );
 374             p_region->i_y = p_sys->i_yoffset
 375                         + ( ( i_index / p_sys->i_cols ) % p_sys->i_rows )
 376                             * ( p_sys->i_height / p_sys->i_rows
 377                                 + p_sys->i_hborder );
 378         }
 379         if( p_region_prev == NULL ){
 380             p_spu->p_region = p_region;
 381         } else {
 382             p_region_prev->p_next = p_region;
 383         }
 384
 385         p_region_prev = p_region;
 386
 387         vout_CopyPicture( p_filter, &p_region->picture, p_converted );
 388
 389         p_middle->pf_release( p_middle );
 390         p_converted->pf_release( p_converted );
 391     }
 392
 393     vlc_mutex_unlock( &p_picture_vout->lock );
 394
 395     /* Initialize subpicture */
 396     p_spu->i_channel = 0;
 397     p_spu->i_start  = date;
 398     p_spu->i_stop = 0;
 399     p_spu->b_ephemer = VLC_TRUE;
 400     p_spu->i_alpha = p_sys->i_alpha;
 401
 402     return p_spu;
 403 }
 404
 405 /*****************************************************************************
 406 * Callback to update params on the fly
 407 *****************************************************************************/
 408
 409
 410 static int MosaicCallback( vlc_object_t *p_this, char const *psz_var,
 411                             vlc_value_t oldval, vlc_value_t newval,
 412                             void *p_data )
 413 {
 414     filter_sys_t *p_sys = (filter_sys_t *) p_data;
 415     fprintf( stderr, "Callback" );
 416     if( !strcmp( psz_var, "mosaic-alpha" ) )
 417     {
 418         msg_Dbg( p_this, "Changing alpha from %d/255 to %d/255",
 419                          p_sys->i_alpha, newval.i_int);
 420         p_sys->i_alpha = __MIN( __MAX( newval.i_int, 0 ), 255 );
 421     }
 422     else if( !strcmp( psz_var, "mosaic-height" ) )
 423     {
 424         msg_Dbg( p_this, "Changing height from %dpx to %dpx",
 425                           p_sys->i_height, newval.i_int );
 426         p_sys->i_height = __MAX( newval.i_int, 0 );
 427     }
 428     else if( !strcmp( psz_var, "mosaic-width" ) )
 429     {
 430         msg_Dbg( p_this, "Changing width from %dpx to %dpx",
 431                          p_sys->i_width, newval.i_int );
 432         p_sys->i_width = __MAX( newval.i_int, 0 );
 433     }
 434     else if( !strcmp( psz_var, "mosaic-xoffset" ) )
 435     {
 436         msg_Dbg( p_this, "Changing x offset from %dpx to %dpx",
 437                          p_sys->i_xoffset, newval.i_int );
 438         p_sys->i_xoffset = __MAX( newval.i_int, 0 );
 439     }
 440     else if( !strcmp( psz_var, "mosaic-yoffset" ) )
 441     {
 442         msg_Dbg( p_this, "Changing y offset from %dpx to %dpx",
 443                          p_sys->i_yoffset, newval.i_int );
 444         p_sys->i_yoffset = __MAX( newval.i_int, 0 );
 445     }
 446     else if( !strcmp( psz_var, "mosaic-vborder" ) )
 447     {
 448         msg_Dbg( p_this, "Changing vertical border from %dpx to %dpx",
 449                          p_sys->i_vborder, newval.i_int );
 450         p_sys->i_vborder = __MAX( newval.i_int, 0 );
 451     }
 452     else if( !strcmp( psz_var, "mosaic-hborder" ) )
 453     {
 454         msg_Dbg( p_this, "Changing horizontal border from %dpx to %dpx",
 455                          p_sys->i_vborder, newval.i_int );
 456         p_sys->i_hborder = __MAX( newval.i_int, 0 );
 457     }
 458     else if( !strcmp( psz_var, "mosaic-position" ) )
 459     {
 460         if( newval.i_int > 1 || newval.i_int < 0 )
 461         {
 462             msg_Err( p_this, "Position is either 0 (auto) or 1 (fixed)" );
 463         }
 464         else
 465         {
 466             msg_Dbg( p_this, "Changing position method from %d (%s) to %d (%s)",
 467                              p_sys->i_pos, ppsz_pos_descriptions[p_sys->i_pos],
 468                              newval.i_int, ppsz_pos_descriptions[newval.i_int]);
 469             p_sys->i_pos = newval.i_int;
 470         }
 471     }
 472     else if( !strcmp( psz_var, "mosaic-rows" ) )
 473     {
 474         msg_Dbg( p_this, "Changing number of rows from %d to %d",
 475                          p_sys->i_rows, newval.i_int );
 476         p_sys->i_rows = __MAX( newval.i_int, 1 );
 477     }
 478     else if( !strcmp( psz_var, "mosaic-cols" ) )
 479     {
 480         msg_Dbg( p_this, "Changing number of columns from %d to %d",
 481                          p_sys->i_cols, newval.i_int );
 482         p_sys->i_cols = __MAX( newval.i_int, 1 );
 483     }
 484     else if( !strcmp( psz_var, "mosaic-keep-aspect-ratio" ) )
 485     {
 486         if( newval.i_int )
 487         {
 488             msg_Dbg( p_this, "Keep aspect ratio" );
 489             p_sys->i_ar = 1;
 490         }
 491         else
 492         {
 493             msg_Dbg( p_this, "Don't keep aspect ratio" );
 494             p_sys->i_ar = 0;
 495         }
 496     }
 497     return VLC_SUCCESS;
 498 }