git.sesse.net Git - vlc/blob - plugins/filter/distort.c

   1 /*****************************************************************************
   2  * distort.c : Misc video effects plugin for vlc
   3  *****************************************************************************
   4  * Copyright (C) 2000, 2001 VideoLAN
   5  * $Id: distort.c,v 1.11 2002/05/19 12:57:32 gbazin Exp $
   6  *
   7  * Authors: Samuel Hocevar <sam@zoy.org>
   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 <errno.h>
  28 #include <stdlib.h>                                      /* malloc(), free() */
  29 #include <string.h>
  30
  31 #include <math.h>                                            /* sin(), cos() */
  32
  33 #include <videolan/vlc.h>
  34
  35 #include "video.h"
  36 #include "video_output.h"
  37
  38 #include "filter_common.h"
  39
  40 #define DISTORT_MODE_WAVE    1
  41 #define DISTORT_MODE_RIPPLE  2
  42
  43 /*****************************************************************************
  44  * Capabilities defined in the other files.
  45  *****************************************************************************/
  46 static void vout_getfunctions( function_list_t * p_function_list );
  47
  48 /*****************************************************************************
  49  * Build configuration tree.
  50  *****************************************************************************/
  51 MODULE_CONFIG_START
  52 MODULE_CONFIG_STOP
  53
  54 MODULE_INIT_START
  55     SET_DESCRIPTION( _("miscellaneous video effects module") )
  56     /* Capability score set to 0 because we don't want to be spawned
  57      * as a video output unless explicitly requested to */
  58     ADD_CAPABILITY( VOUT, 0 )
  59     ADD_SHORTCUT( "distort" )
  60 MODULE_INIT_STOP
  61
  62 MODULE_ACTIVATE_START
  63     vout_getfunctions( &p_module->p_functions->vout );
  64 MODULE_ACTIVATE_STOP
  65
  66 MODULE_DEACTIVATE_START
  67 MODULE_DEACTIVATE_STOP
  68
  69 /*****************************************************************************
  70  * vout_sys_t: Distort video output method descriptor
  71  *****************************************************************************
  72  * This structure is part of the video output thread descriptor.
  73  * It describes the Distort specific properties of an output thread.
  74  *****************************************************************************/
  75 typedef struct vout_sys_s
  76 {
  77     int i_mode;
  78     struct vout_thread_s *p_vout;
  79
  80     /* For the wave mode */
  81     double  f_angle;
  82     mtime_t last_date;
  83
  84 } vout_sys_t;
  85
  86 /*****************************************************************************
  87  * Local prototypes
  88  *****************************************************************************/
  89 static int  vout_Create    ( struct vout_thread_s * );
  90 static int  vout_Init      ( struct vout_thread_s * );
  91 static void vout_End       ( struct vout_thread_s * );
  92 static void vout_Destroy   ( struct vout_thread_s * );
  93 static int  vout_Manage    ( struct vout_thread_s * );
  94 static void vout_Render    ( struct vout_thread_s *, struct picture_s * );
  95 static void vout_Display   ( struct vout_thread_s *, struct picture_s * );
  96
  97 static void DistortWave    ( struct vout_thread_s *, struct picture_s *,
  98                                                      struct picture_s * );
  99 static void DistortRipple  ( struct vout_thread_s *, struct picture_s *,
 100                                                      struct picture_s * );
 101
 102 /*****************************************************************************
 103  * Functions exported as capabilities. They are declared as static so that
 104  * we don't pollute the namespace too much.
 105  *****************************************************************************/
 106 static void vout_getfunctions( function_list_t * p_function_list )
 107 {
 108     p_function_list->functions.vout.pf_create     = vout_Create;
 109     p_function_list->functions.vout.pf_init       = vout_Init;
 110     p_function_list->functions.vout.pf_end        = vout_End;
 111     p_function_list->functions.vout.pf_destroy    = vout_Destroy;
 112     p_function_list->functions.vout.pf_manage     = vout_Manage;
 113     p_function_list->functions.vout.pf_render     = vout_Render;
 114     p_function_list->functions.vout.pf_display    = vout_Display;
 115 }
 116
 117 /*****************************************************************************
 118  * vout_Create: allocates Distort video thread output method
 119  *****************************************************************************
 120  * This function allocates and initializes a Distort vout method.
 121  *****************************************************************************/
 122 static int vout_Create( vout_thread_t *p_vout )
 123 {
 124     char *psz_method, *psz_method_tmp;
 125
 126     /* Allocate structure */
 127     p_vout->p_sys = malloc( sizeof( vout_sys_t ) );
 128     if( p_vout->p_sys == NULL )
 129     {
 130         intf_ErrMsg("error: %s", strerror(ENOMEM) );
 131         return( 1 );
 132     }
 133
 134     /* Look what method was requested */
 135     if( !(psz_method = psz_method_tmp
 136           = config_GetPszVariable( "filter" )) )
 137     {
 138         intf_ErrMsg( "vout error: configuration variable %s empty",
 139                      "filter" );
 140         return( 1 );
 141     }
 142
 143     while( *psz_method && *psz_method != ':' )
 144     {
 145         psz_method++;
 146     }
 147
 148     if( !strcmp( psz_method, ":wave" ) )
 149     {
 150         p_vout->p_sys->i_mode = DISTORT_MODE_WAVE;
 151     }
 152     else if( !strcmp( psz_method, ":ripple" ) )
 153     {
 154         p_vout->p_sys->i_mode = DISTORT_MODE_RIPPLE;
 155     }
 156     else
 157     {
 158         intf_ErrMsg( "filter error: no valid distort mode provided, "
 159                      "using distort:wave" );
 160         p_vout->p_sys->i_mode = DISTORT_MODE_WAVE;
 161     }
 162
 163     free( psz_method_tmp );
 164
 165     return( 0 );
 166 }
 167
 168 /*****************************************************************************
 169  * vout_Init: initialize Distort video thread output method
 170  *****************************************************************************/
 171 static int vout_Init( vout_thread_t *p_vout )
 172 {
 173     int i_index;
 174     char *psz_filter;
 175     picture_t *p_pic;
 176
 177     I_OUTPUTPICTURES = 0;
 178
 179     /* Initialize the output structure */
 180     p_vout->output.i_chroma = p_vout->render.i_chroma;
 181     p_vout->output.i_width  = p_vout->render.i_width;
 182     p_vout->output.i_height = p_vout->render.i_height;
 183     p_vout->output.i_aspect = p_vout->render.i_aspect;
 184
 185     /* Try to open the real video output */
 186     psz_filter = config_GetPszVariable( "filter" );
 187     config_PutPszVariable( "filter", NULL );
 188
 189     intf_WarnMsg( 1, "filter: spawning the real video output" );
 190
 191     p_vout->p_sys->p_vout =
 192         vout_CreateThread( NULL,
 193                            p_vout->render.i_width, p_vout->render.i_height,
 194                            p_vout->render.i_chroma, p_vout->render.i_aspect );
 195
 196     config_PutPszVariable( "filter", psz_filter );
 197     if( psz_filter ) free( psz_filter );
 198
 199     /* Everything failed */
 200     if( p_vout->p_sys->p_vout == NULL )
 201     {
 202         intf_ErrMsg( "filter error: can't open vout, aborting" );
 203
 204         return( 0 );
 205     }
 206
 207     ALLOCATE_DIRECTBUFFERS( VOUT_MAX_PICTURES );
 208
 209     p_vout->p_sys->f_angle = 0.0;
 210     p_vout->p_sys->last_date = 0;
 211
 212     return( 0 );
 213 }
 214
 215 /*****************************************************************************
 216  * vout_End: terminate Distort video thread output method
 217  *****************************************************************************/
 218 static void vout_End( vout_thread_t *p_vout )
 219 {
 220     int i_index;
 221
 222     /* Free the fake output buffers we allocated */
 223     for( i_index = I_OUTPUTPICTURES ; i_index ; )
 224     {
 225         i_index--;
 226         free( PP_OUTPUTPICTURE[ i_index ]->p_data_orig );
 227     }
 228 }
 229
 230 /*****************************************************************************
 231  * vout_Destroy: destroy Distort video thread output method
 232  *****************************************************************************
 233  * Terminate an output method created by DistortCreateOutputMethod
 234  *****************************************************************************/
 235 static void vout_Destroy( vout_thread_t *p_vout )
 236 {
 237     vout_DestroyThread( p_vout->p_sys->p_vout, NULL );
 238
 239     free( p_vout->p_sys );
 240 }
 241
 242 /*****************************************************************************
 243  * vout_Manage: handle Distort events
 244  *****************************************************************************
 245  * This function should be called regularly by video output thread. It manages
 246  * console events. It returns a non null value on error.
 247  *****************************************************************************/
 248 static int vout_Manage( vout_thread_t *p_vout )
 249 {
 250     return( 0 );
 251 }
 252
 253 /*****************************************************************************
 254  * vout_Render: displays previously rendered output
 255  *****************************************************************************
 256  * This function send the currently rendered image to Distort image, waits
 257  * until it is displayed and switch the two rendering buffers, preparing next
 258  * frame.
 259  *****************************************************************************/
 260 static void vout_Render( vout_thread_t *p_vout, picture_t *p_pic )
 261 {
 262     picture_t *p_outpic;
 263
 264     /* This is a new frame. Get a structure from the video_output. */
 265     while( ( p_outpic = vout_CreatePicture( p_vout->p_sys->p_vout, 0, 0, 0 ) )
 266               == NULL )
 267     {
 268         if( p_vout->b_die || p_vout->b_error )
 269         {
 270             return;
 271         }
 272         msleep( VOUT_OUTMEM_SLEEP );
 273     }
 274
 275     vout_DatePicture( p_vout->p_sys->p_vout, p_outpic, p_pic->date );
 276
 277     switch( p_vout->p_sys->i_mode )
 278     {
 279         case DISTORT_MODE_WAVE:
 280             DistortWave( p_vout, p_pic, p_outpic );
 281             break;
 282
 283         case DISTORT_MODE_RIPPLE:
 284             DistortRipple( p_vout, p_pic, p_outpic );
 285             break;
 286
 287         default:
 288             break;
 289     }
 290
 291     vout_DisplayPicture( p_vout->p_sys->p_vout, p_outpic );
 292 }
 293
 294 /*****************************************************************************
 295  * vout_Display: displays previously rendered output
 296  *****************************************************************************
 297  * This function send the currently rendered image to Invert image, waits
 298  * until it is displayed and switch the two rendering buffers, preparing next
 299  * frame.
 300  *****************************************************************************/
 301 static void vout_Display( vout_thread_t *p_vout, picture_t *p_pic )
 302 {
 303     ;
 304 }
 305
 306 /*****************************************************************************
 307  * DistortWave: draw a wave effect on the picture
 308  *****************************************************************************/
 309 static void DistortWave( vout_thread_t *p_vout, picture_t *p_inpic,
 310                                                 picture_t *p_outpic )
 311 {
 312     int i_index;
 313     double f_angle;
 314     mtime_t new_date = mdate();
 315
 316     p_vout->p_sys->f_angle += (new_date - p_vout->p_sys->last_date) / 200000.0;
 317     p_vout->p_sys->last_date = new_date;
 318     f_angle = p_vout->p_sys->f_angle;
 319
 320     for( i_index = 0 ; i_index < p_inpic->i_planes ; i_index++ )
 321     {
 322         int i_line, i_num_lines, i_offset;
 323         u8 black_pixel;
 324         u8 *p_in, *p_out;
 325
 326         p_in = p_inpic->p[i_index].p_pixels;
 327         p_out = p_outpic->p[i_index].p_pixels;
 328
 329         i_num_lines = p_inpic->p[i_index].i_lines;
 330
 331         black_pixel = ( i_index == Y_PLANE ) ? 0x00 : 0x80;
 332
 333         /* Ok, we do 3 times the sin() calculation for each line. So what ? */
 334         for( i_line = 0 ; i_line < i_num_lines ; i_line++ )
 335         {
 336             /* Calculate today's offset, don't go above 1/20th of the screen */
 337             i_offset = (double)(p_inpic->p[i_index].i_pitch)
 338                          * sin( f_angle + 10.0 * (double)i_line
 339                                                / (double)i_num_lines )
 340                          / 20.0;
 341
 342             if( i_offset )
 343             {
 344                 if( i_offset < 0 )
 345                 {
 346                     FAST_MEMCPY( p_out, p_in - i_offset,
 347                                  p_inpic->p[i_index].i_pitch + i_offset );
 348                     p_in += p_inpic->p[i_index].i_pitch;
 349                     p_out += p_outpic->p[i_index].i_pitch;
 350                     memset( p_out + i_offset, black_pixel, -i_offset );
 351                 }
 352                 else
 353                 {
 354                     FAST_MEMCPY( p_out + i_offset, p_in,
 355                                  p_inpic->p[i_index].i_pitch - i_offset );
 356                     memset( p_out, black_pixel, i_offset );
 357                     p_in += p_inpic->p[i_index].i_pitch;
 358                     p_out += p_outpic->p[i_index].i_pitch;
 359                 }
 360             }
 361             else
 362             {
 363                 FAST_MEMCPY( p_out, p_in, p_inpic->p[i_index].i_pitch );
 364                 p_in += p_inpic->p[i_index].i_pitch;
 365                 p_out += p_outpic->p[i_index].i_pitch;
 366             }
 367
 368         }
 369     }
 370 }
 371
 372 /*****************************************************************************
 373  * DistortRipple: draw a ripple effect at the bottom of the picture
 374  *****************************************************************************/
 375 static void DistortRipple( vout_thread_t *p_vout, picture_t *p_inpic,
 376                                                   picture_t *p_outpic )
 377 {
 378     int i_index;
 379     double f_angle;
 380     mtime_t new_date = mdate();
 381
 382     p_vout->p_sys->f_angle -= (p_vout->p_sys->last_date - new_date) / 100000.0;
 383     p_vout->p_sys->last_date = new_date;
 384     f_angle = p_vout->p_sys->f_angle;
 385
 386     for( i_index = 0 ; i_index < p_inpic->i_planes ; i_index++ )
 387     {
 388         int i_line, i_first_line, i_num_lines, i_offset;
 389         u8 black_pixel;
 390         u8 *p_in, *p_out;
 391
 392         black_pixel = ( i_index == Y_PLANE ) ? 0x00 : 0x80;
 393
 394         i_num_lines = p_inpic->p[i_index].i_lines;
 395
 396         i_first_line = i_num_lines * 4 / 5;
 397
 398         p_in = p_inpic->p[i_index].p_pixels;
 399         p_out = p_outpic->p[i_index].p_pixels;
 400
 401         FAST_MEMCPY( p_out, p_in, i_first_line * p_inpic->p[i_index].i_pitch );
 402
 403         p_in += i_first_line * p_inpic->p[i_index].i_pitch;
 404         p_out += i_first_line * p_outpic->p[i_index].i_pitch;
 405
 406         /* Ok, we do 3 times the sin() calculation for each line. So what ? */
 407         for( i_line = i_first_line ; i_line < i_num_lines ; i_line++ )
 408         {
 409             /* Calculate today's offset, don't go above 1/20th of the screen */
 410             i_offset = (double)(p_inpic->p[i_index].i_pitch)
 411                          * sin( f_angle + 2.0 * (double)i_line
 412                                               / (double)( 1 + i_line
 413                                                             - i_first_line) )
 414                          * (double)(i_line - i_first_line)
 415                          / (double)i_num_lines
 416                          / 8.0;
 417
 418             if( i_offset )
 419             {
 420                 if( i_offset < 0 )
 421                 {
 422                     FAST_MEMCPY( p_out, p_in - i_offset,
 423                                  p_inpic->p[i_index].i_pitch + i_offset );
 424                     p_in -= p_inpic->p[i_index].i_pitch;
 425                     p_out += p_outpic->p[i_index].i_pitch;
 426                     memset( p_out + i_offset, black_pixel, -i_offset );
 427                 }
 428                 else
 429                 {
 430                     FAST_MEMCPY( p_out + i_offset, p_in,
 431                                  p_inpic->p[i_index].i_pitch - i_offset );
 432                     memset( p_out, black_pixel, i_offset );
 433                     p_in -= p_inpic->p[i_index].i_pitch;
 434                     p_out += p_outpic->p[i_index].i_pitch;
 435                 }
 436             }
 437             else
 438             {
 439                 FAST_MEMCPY( p_out, p_in, p_inpic->p[i_index].i_pitch );
 440                 p_in -= p_inpic->p[i_index].i_pitch;
 441                 p_out += p_outpic->p[i_index].i_pitch;
 442             }
 443
 444         }
 445     }
 446 }
 447