modules/video_filter/vhs.c

   1 /*****************************************************************************
   2  * vhs.c : VHS effect video filter
   3  *****************************************************************************
   4  * Copyright (C) 2013      Vianney Boyer
   5  * $Id$
   6  *
   7  * Authors: Vianney Boyer <vlcvboyer -at- gmail -dot- com>
   8  *
   9  * This program is free software; you can redistribute it and/or modify it
  10  * under the terms of the GNU Lesser General Public License as published by
  11  * the Free Software Foundation; either version 2.1 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  17  * GNU Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public License
  20  * along with this program; if not, write to the Free Software Foundation,
  21  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24 /*****************************************************************************
  25  * Preamble
  26  *****************************************************************************/
  27
  28 #ifdef HAVE_CONFIG_H
  29 #   include "config.h"
  30 #endif
  31
  32 #include <vlc_common.h>
  33 #include <vlc_plugin.h>
  34 #include <vlc_filter.h>
  35 #include <vlc_picture.h>
  36 #include <vlc_rand.h>
  37 #include <vlc_mtime.h>
  38
  39 #include "filter_picture.h"
  40
  41 static inline int64_t MOD(int64_t a, int64_t b) {
  42     return ( ( a % b ) + b ) % b; }
  43
  44 #define MAX_BLUE_RED_LINES 100
  45
  46 typedef struct {
  47     int32_t  i_offset;
  48     uint16_t i_intensity;
  49     bool     b_blue_red;
  50     mtime_t  i_stop_trigger;
  51 } blue_red_line_t;
  52
  53 struct filter_sys_t {
  54
  55     /* general data */
  56     bool b_init;
  57     int32_t  i_planes;
  58     int32_t *i_height; /* note: each plane may have different dimensions */
  59     int32_t *i_width;
  60     int32_t *i_visible_pitch;
  61     mtime_t  i_start_time;
  62     mtime_t  i_last_time;
  63     mtime_t  i_cur_time;
  64
  65     /* sliding & offset effect */
  66     int32_t  i_phase_speed;
  67     int32_t  i_phase_ofs;
  68     int32_t  i_offset_ofs;
  69     int32_t  i_sliding_ofs;
  70     int32_t  i_sliding_speed;
  71     mtime_t  i_offset_trigger;
  72     mtime_t  i_sliding_trigger;
  73     mtime_t  i_sliding_stop_trig;
  74     bool     i_sliding_type_duplicate;
  75
  76     /* blue red lines effect */
  77     mtime_t  i_BR_line_trigger;
  78     blue_red_line_t *p_BR_lines[MAX_BLUE_RED_LINES];
  79
  80 };
  81
  82 /*****************************************************************************
  83  * Prototypes
  84  *****************************************************************************/
  85
  86 static picture_t *Filter( filter_t *, picture_t * );
  87
  88 static int  vhs_allocate_data( filter_t *, picture_t * );
  89 static void vhs_free_allocated_data( filter_t * );
  90
  91 static int  vhs_blue_red_line_effect( filter_t *, picture_t * );
  92 static void vhs_blue_red_dots_effect( filter_t *, picture_t * );
  93 static int  vhs_sliding_effect( filter_t *, picture_t * );
  94
  95 static int  vhs_sliding_effect_apply( filter_t *, picture_t * );
  96
  97 /*****************************************************************************
  98  * Module descriptor
  99  *****************************************************************************/
 100
 101 static int  Open ( vlc_object_t * );
 102 static void Close( vlc_object_t * );
 103
 104 vlc_module_begin()
 105     set_description( N_("VHS movie effect video filter") )
 106     set_shortname(   N_("VHS movie" ) )
 107     set_capability( "video filter", 0 )
 108     set_category( CAT_VIDEO )
 109     set_subcategory( SUBCAT_VIDEO_VFILTER )
 110
 111     set_callbacks( Open, Close )
 112 vlc_module_end()
 113
 114 /**
 115  * Open the filter
 116  */
 117 static int Open( vlc_object_t *p_this )
 118 {
 119     filter_t *p_filter = (filter_t*)p_this;
 120     filter_sys_t *p_sys;
 121
 122     /* Assert video in match with video out */
 123     if( !es_format_IsSimilar( &p_filter->fmt_in, &p_filter->fmt_out ) ) {
 124         msg_Err( p_filter, "Input and output format does not match" );
 125         return VLC_EGENERIC;
 126     }
 127
 128     /* Reject 0 bpp and unsupported chroma */
 129     const vlc_fourcc_t fourcc = p_filter->fmt_in.video.i_chroma;
 130     const vlc_chroma_description_t *p_chroma =
 131         vlc_fourcc_GetChromaDescription( p_filter->fmt_in.video.i_chroma );
 132     if( !p_chroma || p_chroma->pixel_size == 0
 133         || p_chroma->plane_count < 3 || p_chroma->pixel_size > 1
 134         || !vlc_fourcc_IsYUV( fourcc ) )
 135     {
 136         msg_Err( p_filter, "Unsupported chroma (%4.4s)", (char*)&fourcc );
 137         return VLC_EGENERIC;
 138     }
 139
 140     /* Allocate structure */
 141     p_filter->p_sys = p_sys = calloc(1, sizeof(*p_sys) );
 142     if( unlikely( !p_sys ) )
 143         return VLC_ENOMEM;
 144
 145     /* init data */
 146     p_filter->pf_video_filter = Filter;
 147     p_sys->i_start_time = p_sys->i_cur_time = p_sys->i_last_time = mdate();
 148
 149     return VLC_SUCCESS;
 150 }
 151
 152 /**
 153  * Close the filter
 154  */
 155 static void Close( vlc_object_t *p_this ) {
 156     filter_t *p_filter = (filter_t*)p_this;
 157     filter_sys_t *p_sys = p_filter->p_sys;
 158
 159     /* Free allocated memory */
 160     vhs_free_allocated_data( p_filter );
 161     free( p_sys );
 162 }
 163
 164 /**
 165  * Filter a picture
 166  */
 167 static picture_t *Filter( filter_t *p_filter, picture_t *p_pic_in ) {
 168     if( unlikely( !p_pic_in || !p_filter) )
 169         return NULL;
 170
 171     filter_sys_t *p_sys = p_filter->p_sys;
 172
 173     picture_t *p_pic_out = filter_NewPicture( p_filter );
 174     if( unlikely( !p_pic_out ) ) {
 175         picture_Release( p_pic_in );
 176         return NULL;
 177     }
 178
 179    /*
 180     * manage time
 181     */
 182     p_sys->i_last_time = p_sys->i_cur_time;
 183     p_sys->i_cur_time = mdate();
 184
 185    /*
 186     * allocate data
 187     */
 188     if ( unlikely( !p_sys->b_init ) )
 189         if ( unlikely( vhs_allocate_data( p_filter, p_pic_in ) != VLC_SUCCESS ) ) {
 190             picture_Release( p_pic_in );
 191             return NULL;
 192         }
 193     p_sys->b_init = true;
 194
 195    /*
 196     * preset output pic: raw copy src to dst
 197     */
 198     picture_CopyPixels(p_pic_out, p_pic_in);
 199
 200    /*
 201     * apply effects on picture
 202     */
 203     if ( unlikely( vhs_blue_red_line_effect( p_filter, p_pic_out ) != VLC_SUCCESS ) )
 204         return CopyInfoAndRelease( p_pic_out, p_pic_in );
 205
 206     if ( unlikely( vhs_sliding_effect(p_filter, p_pic_out ) != VLC_SUCCESS ) )
 207         return CopyInfoAndRelease( p_pic_out, p_pic_in );
 208
 209     vhs_blue_red_dots_effect( p_filter, p_pic_out );
 210
 211     return CopyInfoAndRelease( p_pic_out, p_pic_in );
 212 }
 213
 214 /*
 215  * Allocate data
 216  */
 217 static int vhs_allocate_data( filter_t *p_filter, picture_t *p_pic_in ) {
 218     filter_sys_t *p_sys = p_filter->p_sys;
 219
 220     vhs_free_allocated_data( p_filter );
 221
 222    /*
 223     * take into account different characteristics for each plane
 224     */
 225     p_sys->i_planes = p_pic_in->i_planes;
 226     p_sys->i_height = calloc( p_sys->i_planes, sizeof(int32_t) );
 227     p_sys->i_width  = calloc( p_sys->i_planes, sizeof(int32_t) );
 228     p_sys->i_visible_pitch = calloc( p_sys->i_planes, sizeof(int32_t) );
 229
 230     if( unlikely( !p_sys->i_height || !p_sys->i_width || !p_sys->i_visible_pitch ) ) {
 231         vhs_free_allocated_data( p_filter );
 232         return VLC_ENOMEM;
 233     }
 234
 235     for ( int32_t i_p = 0; i_p < p_sys->i_planes; i_p++) {
 236         p_sys->i_visible_pitch [i_p] = (int) p_pic_in->p[i_p].i_visible_pitch;
 237         p_sys->i_height[i_p] = (int) p_pic_in->p[i_p].i_visible_lines;
 238         p_sys->i_width [i_p] = (int) p_pic_in->p[i_p].i_visible_pitch / p_pic_in->p[i_p].i_pixel_pitch;
 239     }
 240     return VLC_SUCCESS;
 241 }
 242
 243 /**
 244  * Free allocated data
 245  */
 246 static void vhs_free_allocated_data( filter_t *p_filter ) {
 247     filter_sys_t *p_sys = p_filter->p_sys;
 248
 249     for ( uint32_t i_b = 0; i_b < MAX_BLUE_RED_LINES; i_b++ )
 250         FREENULL( p_sys->p_BR_lines[i_b] );
 251
 252     p_sys->i_planes = 0;
 253     FREENULL( p_sys->i_height );
 254     FREENULL( p_sys->i_width );
 255     FREENULL( p_sys->i_visible_pitch );
 256 }
 257
 258
 259 /**
 260  * Horizontal blue or red lines random management and effect
 261  */
 262 static int vhs_blue_red_line_effect( filter_t *p_filter, picture_t *p_pic_out ) {
 263     filter_sys_t *p_sys = p_filter->p_sys;
 264
 265 #define BR_LINES_GENERATOR_PERIOD ( CLOCK_FREQ * 50 )
 266 #define BR_LINES_DURATION         ( CLOCK_FREQ * 1/50 )
 267
 268     /* generate new blue or red lines */
 269     if ( p_sys->i_BR_line_trigger <= p_sys->i_cur_time ) {
 270         for ( uint32_t i_b = 0; i_b < MAX_BLUE_RED_LINES; i_b++ )
 271             if (p_sys->p_BR_lines[i_b] == NULL) {
 272                 /* allocate data */
 273                 p_sys->p_BR_lines[i_b] = calloc( 1, sizeof(blue_red_line_t) );
 274                 if ( unlikely( !p_sys->p_BR_lines[i_b] ) )
 275                     return VLC_ENOMEM;
 276
 277                 /* set random parameters */
 278                 p_sys->p_BR_lines[i_b]->i_offset = (unsigned)vlc_mrand48()
 279                                                  % __MAX( 1, p_sys->i_height[Y_PLANE] - 10 )
 280                                                  + 5;
 281
 282                 p_sys->p_BR_lines[i_b]->b_blue_red = (unsigned)vlc_mrand48() & 0x01;
 283
 284                 p_sys->p_BR_lines[i_b]->i_stop_trigger = p_sys->i_cur_time
 285                                                        + (uint64_t)vlc_mrand48() % BR_LINES_DURATION
 286                                                        + BR_LINES_DURATION / 2;
 287
 288                 break;
 289             }
 290         p_sys->i_BR_line_trigger = p_sys->i_cur_time
 291                                  + (uint64_t)vlc_mrand48() % BR_LINES_GENERATOR_PERIOD
 292                                  + BR_LINES_GENERATOR_PERIOD / 2;
 293     }
 294
 295
 296     /* manage and apply current blue/red lines */
 297     for ( uint8_t i_b = 0; i_b < MAX_BLUE_RED_LINES; i_b++ )
 298         if ( p_sys->p_BR_lines[i_b] ) {
 299             /* remove outdated ones */
 300             if ( p_sys->p_BR_lines[i_b]->i_stop_trigger <= p_sys->i_cur_time ) {
 301                 FREENULL( p_sys->p_BR_lines[i_b] );
 302                 continue;
 303             }
 304
 305             /* otherwise apply */
 306             for ( int32_t i_p=0; i_p < p_sys->i_planes; i_p++ ) {
 307                 uint32_t i_pix_ofs = p_sys->p_BR_lines[i_b]->i_offset
 308                                    * p_pic_out->p[i_p].i_visible_lines
 309                                    / p_sys->i_height[Y_PLANE]
 310                                    * p_pic_out->p[i_p].i_pitch;
 311
 312                 switch ( i_p ) {
 313                   case Y_PLANE:
 314                     memset( &p_pic_out->p[i_p].p_pixels[i_pix_ofs], 127,
 315                             p_pic_out->p[i_p].i_visible_pitch);
 316                     break;
 317                   case U_PLANE:
 318                     memset( &p_pic_out->p[i_p].p_pixels[i_pix_ofs],
 319                             (p_sys->p_BR_lines[i_b]->b_blue_red?255:0),
 320                             p_pic_out->p[i_p].i_visible_pitch);
 321                     break;
 322                   case V_PLANE:
 323                     memset( &p_pic_out->p[i_p].p_pixels[i_pix_ofs],
 324                             (p_sys->p_BR_lines[i_b]->b_blue_red?0:255),
 325                             p_pic_out->p[i_p].i_visible_pitch);
 326                     break;
 327                 }
 328
 329             }
 330         }
 331     return VLC_SUCCESS;
 332 }
 333
 334 /**
 335  * insert randomly blue and red dots on the picture
 336  */
 337 static void vhs_blue_red_dots_effect( filter_t *p_filter, picture_t *p_pic_out ) {
 338 #define BR_DOTS_RATIO 10000
 339
 340     filter_sys_t *p_sys = p_filter->p_sys;
 341
 342     for ( int32_t i_dots = 0;
 343           i_dots < p_sys->i_width[Y_PLANE] * p_sys->i_height[Y_PLANE] / BR_DOTS_RATIO;
 344           i_dots++) {
 345
 346         uint32_t i_length = (unsigned)vlc_mrand48()
 347                           % __MAX( 1, p_sys->i_width[Y_PLANE] / 30 ) + 1;
 348
 349         uint16_t i_x = (unsigned)vlc_mrand48()
 350                      % __MAX( 1, p_sys->i_width[Y_PLANE] - i_length );
 351         uint16_t i_y = (unsigned)vlc_mrand48() % p_sys->i_height[Y_PLANE];
 352         bool b_color = ( ( (unsigned)vlc_mrand48() % 2 ) == 0);
 353
 354         for ( int32_t i_p = 0; i_p < p_sys->i_planes; i_p++ ) {
 355             uint32_t i_pix_ofs = i_y
 356                                * p_pic_out->p[i_p].i_visible_lines
 357                                / p_sys->i_height[Y_PLANE]
 358                                * p_pic_out->p[i_p].i_pitch
 359                                + i_x
 360                                * p_pic_out->p[i_p].i_pixel_pitch;
 361
 362             uint32_t i_length_in_plane = i_length
 363                                        * p_pic_out->p[i_p].i_visible_pitch
 364                                        / p_pic_out->p[Y_PLANE].i_visible_pitch;
 365
 366             switch ( i_p ) {
 367               case Y_PLANE:
 368                 memset( &p_pic_out->p[i_p].p_pixels[i_pix_ofs], 127,
 369                         i_length_in_plane );
 370                 break;
 371               case U_PLANE:
 372                 memset( &p_pic_out->p[i_p].p_pixels[i_pix_ofs],
 373                         (b_color?255:0),
 374                         i_length_in_plane );
 375                 break;
 376               case V_PLANE:
 377                 memset( &p_pic_out->p[i_p].p_pixels[i_pix_ofs],
 378                         (b_color?0:255),
 379                         i_length_in_plane );
 380                 break;
 381             }
 382         }
 383     }
 384 }
 385
 386 /**
 387 * sliding effects
 388 */
 389 static int vhs_sliding_effect( filter_t *p_filter, picture_t *p_pic_out ) {
 390     filter_sys_t *p_sys = p_filter->p_sys;
 391
 392     /**
 393     * one shot offset section
 394     */
 395
 396 #define OFFSET_AVERAGE_PERIOD   (10 * CLOCK_FREQ)
 397
 398     /* start trigger to be (re)initialized */
 399     if ( p_sys->i_offset_trigger == 0
 400          || p_sys->i_sliding_speed != 0 ) { /* do not mix sliding and offset */
 401
 402         /* random trigger for offset effect */
 403         p_sys->i_offset_trigger = p_sys->i_cur_time
 404                                 + ((uint64_t) vlc_mrand48() ) % OFFSET_AVERAGE_PERIOD
 405                                 + OFFSET_AVERAGE_PERIOD / 2;
 406         p_sys->i_offset_ofs = 0;
 407     } else if (p_sys->i_offset_trigger <= p_sys->i_cur_time) {
 408         /* trigger for offset effect occurs */
 409         p_sys->i_offset_trigger = 0;
 410         p_sys->i_offset_ofs = (uint32_t)vlc_mrand48()
 411                             % p_sys->i_height[Y_PLANE];
 412     }
 413     else
 414         p_sys->i_offset_ofs = 0;
 415
 416
 417     /**
 418     * phase section
 419     */
 420
 421 #define MAX_PHASE_OFS (p_sys->i_height[Y_PLANE]*100/15)
 422
 423     p_sys->i_phase_speed += MOD( (int32_t)vlc_mrand48(), 3) - 1;
 424     p_sys->i_phase_ofs   += p_sys->i_phase_speed;
 425     p_sys->i_phase_ofs    = VLC_CLIP( p_sys->i_phase_ofs, -MAX_PHASE_OFS, +MAX_PHASE_OFS);
 426     if ( abs( p_sys->i_phase_ofs ) >= MAX_PHASE_OFS )
 427         p_sys->i_phase_speed = 0;
 428
 429
 430     /**
 431     * sliding section
 432     */
 433
 434 #define SLIDING_AVERAGE_PERIOD   (20 * CLOCK_FREQ)
 435 #define SLIDING_AVERAGE_DURATION ( 3 * CLOCK_FREQ)
 436
 437     /* start trigger to be (re)initialized */
 438     if ( ( p_sys->i_sliding_stop_trig  == 0 ) &&
 439          ( p_sys->i_sliding_trigger    == 0 ) &&
 440          ( p_sys->i_sliding_speed      == 0 ) ) {
 441
 442         /* random trigger which enable sliding effect */
 443         p_sys->i_sliding_trigger = p_sys->i_cur_time
 444                                  + (uint64_t)vlc_mrand48() % SLIDING_AVERAGE_PERIOD
 445                                  + SLIDING_AVERAGE_PERIOD / 2;
 446     }
 447
 448     /* start trigger just occurs */
 449     else if ( ( p_sys->i_sliding_stop_trig  == 0 ) &&
 450               ( p_sys->i_sliding_trigger    <= p_sys->i_cur_time ) &&
 451               ( p_sys->i_sliding_speed      == 0 ) ) {
 452
 453         /* init sliding parameters */
 454         p_sys->i_sliding_trigger = 0;
 455         p_sys->i_sliding_stop_trig = p_sys->i_cur_time
 456                                    + (uint64_t)vlc_mrand48() % SLIDING_AVERAGE_DURATION
 457                                    + SLIDING_AVERAGE_DURATION / 2;
 458         p_sys->i_sliding_ofs = 0;
 459         /* note: sliding speed unit = image per 100 s */
 460         p_sys->i_sliding_speed = MOD( (int32_t)vlc_mrand48(), 1001 ) - 500;
 461         p_sys->i_sliding_type_duplicate = (unsigned)vlc_mrand48() & 0x01;
 462     }
 463
 464     /* stop trigger disabling sliding effect occurs */
 465     else if ( ( p_sys->i_sliding_stop_trig  <= p_sys->i_cur_time )
 466               && ( p_sys->i_sliding_trigger == 0 ) ) {
 467
 468         /* first increase speed to ensure we will stop sliding on plain pict */
 469         if ( abs( p_sys->i_sliding_speed ) < 5 )
 470             p_sys->i_sliding_speed += 1;
 471
 472         /* check if offset is close to 0 and then ready to stop */
 473         if ( abs( p_sys->i_sliding_ofs ) < abs( p_sys->i_sliding_speed
 474              * p_sys->i_height[Y_PLANE]
 475              * ( p_sys->i_cur_time - p_sys->i_last_time ) / CLOCK_FREQ )
 476              || abs( p_sys->i_sliding_ofs ) < p_sys->i_height[Y_PLANE] * 100 / 20 ) {
 477
 478             /* reset sliding parameters */
 479             p_sys->i_sliding_ofs = p_sys->i_sliding_speed = 0;
 480             p_sys->i_sliding_trigger = p_sys->i_sliding_stop_trig = 0;
 481             p_sys->i_sliding_type_duplicate = false;
 482         }
 483     }
 484
 485     /* update offset */
 486     p_sys->i_sliding_ofs = MOD( p_sys->i_sliding_ofs
 487                                 + p_sys->i_sliding_speed * p_sys->i_height[Y_PLANE]
 488                                 * ( p_sys->i_cur_time - p_sys->i_last_time)
 489                                 / CLOCK_FREQ,
 490                                 p_sys->i_height[Y_PLANE] * 100 );
 491
 492     return vhs_sliding_effect_apply( p_filter, p_pic_out );
 493 }
 494
 495 /**
 496 * apply both sliding and offset effect
 497 */
 498 static int vhs_sliding_effect_apply( filter_t *p_filter, picture_t *p_pic_out )
 499 {
 500     filter_sys_t *p_sys = p_filter->p_sys;
 501
 502     for ( uint8_t i_p = 0; i_p < p_pic_out->i_planes; i_p++ ) {
 503         /* first allocate temporary buffer for swap operation */
 504         uint8_t *p_temp_buf;
 505         if ( !p_sys->i_sliding_type_duplicate ) {
 506             p_temp_buf= calloc( p_pic_out->p[i_p].i_lines
 507                                 * p_pic_out->p[i_p].i_pitch, sizeof(uint8_t) );
 508             if ( unlikely( !p_temp_buf ) )
 509                 return VLC_ENOMEM;
 510             memcpy( p_temp_buf, p_pic_out->p[i_p].p_pixels,
 511                     p_pic_out->p[i_p].i_lines * p_pic_out->p[i_p].i_pitch );
 512         }
 513         else
 514             p_temp_buf = p_pic_out->p[i_p].p_pixels;
 515
 516         /* copy lines to output_pic */
 517         for ( int32_t i_y = 0; i_y < p_pic_out->p[i_p].i_visible_lines; i_y++ )
 518         {
 519             int32_t i_ofs = p_sys->i_offset_ofs + p_sys->i_sliding_ofs;
 520
 521             if ( ( p_sys->i_sliding_speed == 0 ) || !p_sys->i_sliding_type_duplicate )
 522                 i_ofs += p_sys->i_phase_ofs;
 523
 524             i_ofs  = MOD( i_ofs / 100, p_sys->i_height[Y_PLANE] );
 525             i_ofs *= p_pic_out->p[i_p].i_visible_lines;
 526             i_ofs /= p_sys->i_height[Y_PLANE];
 527
 528             memcpy( &p_pic_out->p[i_p].p_pixels[ i_y * p_pic_out->p[i_p].i_pitch ],
 529                     &p_temp_buf[ ( ( i_y + i_ofs ) % p_pic_out->p[i_p].i_visible_lines ) * p_pic_out->p[i_p].i_pitch ],
 530                     p_pic_out->p[i_p].i_visible_pitch );
 531         }
 532         if ( !p_sys->i_sliding_type_duplicate )
 533             free(p_temp_buf);
 534     }
 535
 536     return VLC_SUCCESS;
 537 }