modules/video_filter/magnify.c

   1 /*****************************************************************************
   2  * magnify.c : Magnify/Zoom interactive effect
   3  *****************************************************************************
   4  * Copyright (C) 2005-2009 VLC authors and VideoLAN
   5  *
   6  * Authors: Antoine Cellerier <dionoea -at- videolan -dot- org>
   7  *
   8  * This program is free software; you can redistribute it and/or modify it
   9  * under the terms of the GNU Lesser General Public License as published by
  10  * the Free Software Foundation; either version 2.1 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16  * GNU Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public License
  19  * along with this program; if not, write to the Free Software Foundation,
  20  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  21  *****************************************************************************/
  22
  23 /*****************************************************************************
  24  * Preamble
  25  *****************************************************************************/
  26
  27 #ifdef HAVE_CONFIG_H
  28 # include "config.h"
  29 #endif
  30 #include <math.h>
  31 #include <assert.h>
  32
  33 #include <vlc_common.h>
  34 #include <vlc_plugin.h>
  35 #include <vlc_image.h>
  36 #include <vlc_filter.h>
  37 #include <vlc_mouse.h>
  38 #include <vlc_picture.h>
  39 #include "filter_picture.h"
  40
  41 /*****************************************************************************
  42  * Module descriptor
  43  *****************************************************************************/
  44 static int  Create    ( vlc_object_t * );
  45 static void Destroy   ( vlc_object_t * );
  46
  47 vlc_module_begin ()
  48     set_description( N_("Magnify/Zoom interactive video filter") )
  49     set_shortname( N_( "Magnify" ))
  50     set_capability( "video filter", 0 )
  51     set_category( CAT_VIDEO )
  52     set_subcategory( SUBCAT_VIDEO_VFILTER )
  53
  54     set_callbacks( Create, Destroy )
  55 vlc_module_end ()
  56
  57
  58 /*****************************************************************************
  59  * Local prototypes
  60  *****************************************************************************/
  61 static picture_t *Filter( filter_t *, picture_t * );
  62 static int Mouse( filter_t *, vlc_mouse_t *, const vlc_mouse_t * );
  63
  64 /* */
  65 static void DrawZoomStatus( uint8_t *, int i_pitch, int i_width, int i_height,
  66                             int i_offset_x, int i_offset_y, bool b_visible );
  67 static void DrawRectangle( uint8_t *, int i_pitch, int i_width, int i_height,
  68                            int x, int y, int i_w, int i_h );
  69
  70 /* */
  71 typedef struct
  72 {
  73     image_handler_t *p_image;
  74
  75     vlc_tick_t i_hide_timeout;
  76
  77     int i_zoom; /* zoom level in percent */
  78     int i_x, i_y; /* top left corner coordinates in original image */
  79
  80     bool b_visible; /* is "interface" visible ? */
  81
  82     vlc_tick_t i_last_activity;
  83 } filter_sys_t;
  84
  85 #define VIS_ZOOM 4
  86 #define ZOOM_FACTOR 8
  87
  88 /*****************************************************************************
  89  * Create:
  90  *****************************************************************************/
  91 static int Create( vlc_object_t *p_this )
  92 {
  93     filter_t *p_filter = (filter_t *)p_this;
  94     filter_sys_t *p_sys;
  95
  96     /* */
  97     switch( p_filter->fmt_in.i_codec )
  98     {
  99     CASE_PLANAR_YUV
 100     case VLC_CODEC_GREY:
 101         break;
 102     default:
 103         msg_Err( p_filter, "Unsupported chroma %4.4s", (char *)&p_filter->fmt_in.i_codec );
 104         return VLC_EGENERIC;
 105     }
 106     if( !es_format_IsSimilar( &p_filter->fmt_in, &p_filter->fmt_out ) )
 107     {
 108         msg_Err( p_filter, "Input and output format does not match" );
 109         return VLC_EGENERIC;
 110     }
 111
 112     /* Allocate structure */
 113     p_filter->p_sys = p_sys = malloc( sizeof( *p_sys ) );
 114     if( !p_filter->p_sys )
 115         return VLC_ENOMEM;
 116
 117     p_sys->p_image = image_HandlerCreate( p_filter );
 118     if( !p_sys->p_image )
 119     {
 120         free( p_sys );
 121         return VLC_EGENERIC;
 122     }
 123
 124     p_sys->i_x = 0;
 125     p_sys->i_y = 0;
 126     p_sys->i_zoom = 2*ZOOM_FACTOR;
 127     p_sys->b_visible = true;
 128     p_sys->i_last_activity = vlc_tick_now();
 129     p_sys->i_hide_timeout = VLC_TICK_FROM_MS( var_InheritInteger( p_filter, "mouse-hide-timeout" ) );
 130
 131     /* */
 132     p_filter->pf_video_filter = Filter;
 133     p_filter->pf_video_mouse = Mouse;
 134     return VLC_SUCCESS;
 135 }
 136
 137 /*****************************************************************************
 138  * Destroy:
 139  *****************************************************************************/
 140 static void Destroy( vlc_object_t *p_this )
 141 {
 142     filter_t *p_filter = (filter_t *)p_this;
 143     filter_sys_t *p_sys = p_filter->p_sys;
 144
 145     image_HandlerDelete( p_sys->p_image );
 146
 147     free( p_sys );
 148 }
 149
 150 /*****************************************************************************
 151  * Render: displays previously rendered output
 152  *****************************************************************************/
 153 static picture_t *Filter( filter_t *p_filter, picture_t *p_pic )
 154 {
 155     filter_sys_t *p_sys = p_filter->p_sys;
 156     picture_t *p_outpic;
 157
 158     int v_w, v_h;
 159     picture_t *p_converted;
 160     plane_t *p_oyp;
 161
 162     p_outpic = filter_NewPicture( p_filter );
 163     if( !p_outpic )
 164     {
 165         picture_Release( p_pic );
 166         return NULL;
 167     }
 168
 169     /* */
 170     const bool b_visible = p_sys->b_visible;
 171     const int o_x = p_sys->i_x;
 172     const int o_y = p_sys->i_y;
 173     const int o_zoom = p_sys->i_zoom;
 174
 175     /* background magnified image */
 176     if( o_zoom != ZOOM_FACTOR )
 177     {
 178         video_format_t fmt_in;
 179         video_format_t fmt_out;
 180         plane_t orig_planes[PICTURE_PLANE_MAX];
 181         memcpy(orig_planes, p_pic->p, sizeof orig_planes);
 182
 183         for( int i_plane = 0; i_plane < p_pic->i_planes; i_plane++ )
 184         {
 185             const int o_yp = o_y * p_outpic->p[i_plane].i_visible_lines / p_outpic->p[Y_PLANE].i_visible_lines;
 186             const int o_xp = o_x * p_outpic->p[i_plane].i_visible_pitch / p_outpic->p[Y_PLANE].i_visible_pitch;
 187
 188             p_pic->p[i_plane].p_pixels += o_yp * p_pic->p[i_plane].i_pitch + o_xp;
 189         }
 190
 191         /* */
 192         fmt_in = p_filter->fmt_in.video;
 193         fmt_in.i_width  = fmt_in.i_visible_width  = (fmt_in.i_visible_width  * ZOOM_FACTOR / o_zoom) & ~1;
 194         fmt_in.i_height = fmt_in.i_visible_height = (fmt_in.i_visible_height * ZOOM_FACTOR / o_zoom) & ~1;
 195
 196         /* */
 197         fmt_out = p_filter->fmt_out.video;
 198         p_converted = image_Convert( p_sys->p_image, p_pic, &fmt_in, &fmt_out );
 199         memcpy(p_pic->p, orig_planes, sizeof orig_planes);
 200
 201         picture_CopyPixels( p_outpic, p_converted );
 202
 203         picture_Release( p_converted );
 204     }
 205     else
 206     {
 207         picture_CopyPixels( p_outpic, p_pic );
 208     }
 209
 210     /* zoom area selector */
 211     p_oyp = &p_outpic->p[Y_PLANE];
 212     if( b_visible )
 213     {
 214         video_format_t fmt_out;
 215
 216         /* image visualization */
 217         fmt_out = p_filter->fmt_out.video;
 218         fmt_out.i_width  = fmt_out.i_visible_width  = (fmt_out.i_visible_width /VIS_ZOOM) & ~1;
 219         fmt_out.i_height = fmt_out.i_visible_height = (fmt_out.i_visible_height/VIS_ZOOM) & ~1;
 220         p_converted = image_Convert( p_sys->p_image, p_pic,
 221                                      &p_pic->format, &fmt_out );
 222
 223         /* It will put only what can be copied at the top left */
 224         picture_CopyPixels( p_outpic, p_converted );
 225
 226         picture_Release( p_converted );
 227
 228         /* white rectangle on visualization */
 229         v_w = __MIN( fmt_out.i_visible_width  * ZOOM_FACTOR / o_zoom, fmt_out.i_visible_width - 1 );
 230         v_h = __MIN( fmt_out.i_visible_height * ZOOM_FACTOR / o_zoom, fmt_out.i_visible_height - 1 );
 231
 232         DrawRectangle( p_oyp->p_pixels, p_oyp->i_pitch,
 233                        p_oyp->i_visible_pitch, p_oyp->i_visible_lines,
 234                        o_x/VIS_ZOOM, o_y/VIS_ZOOM,
 235                        v_w, v_h );
 236
 237         /* */
 238         v_h = fmt_out.i_visible_height + 1;
 239     }
 240     else
 241     {
 242         v_h = 1;
 243     }
 244
 245     /* print a small hide/show toggle text control */
 246
 247     if( b_visible || p_sys->i_last_activity + p_sys->i_hide_timeout > vlc_tick_now() )
 248         DrawZoomStatus( p_oyp->p_pixels, p_oyp->i_pitch, p_oyp->i_visible_pitch, p_oyp->i_lines,
 249                         1, v_h, b_visible );
 250
 251     /* zoom gauge */
 252     if( b_visible )
 253     {
 254         memset( p_oyp->p_pixels + (v_h+9)*p_oyp->i_pitch, 0xff, 41 );
 255         for( int y = v_h + 10; y < v_h + 90; y++ )
 256         {
 257             int i_width = v_h + 90 - y;
 258             i_width = i_width * i_width / 160;
 259             if( (80 - y + v_h)*ZOOM_FACTOR/10 < o_zoom )
 260             {
 261                 memset( p_oyp->p_pixels + y*p_oyp->i_pitch, 0xff, i_width );
 262             }
 263             else
 264             {
 265                 p_oyp->p_pixels[y*p_oyp->i_pitch] = 0xff;
 266                 p_oyp->p_pixels[y*p_oyp->i_pitch + i_width - 1] = 0xff;
 267             }
 268         }
 269     }
 270
 271     return CopyInfoAndRelease( p_outpic, p_pic );
 272 }
 273
 274 static void DrawZoomStatus( uint8_t *pb_dst, int i_pitch, int i_width, int i_height,
 275                             int i_offset_x, int i_offset_y, bool b_visible )
 276 {
 277     static const char *p_hide =
 278         "X   X XXXXX XXXX  XXXXX   XXXXX  XXX   XXX  XX XXL"
 279         "X   X   X   X   X X          X  X   X X   X X X XL"
 280         "XXXXX   X   X   X XXXX      X   X   X X   X X   XL"
 281         "X   X   X   X   X X        X    X   X X   X X   XL"
 282         "X   X XXXXX XXXX  XXXXX   XXXXX  XXX   XXX  X   XL";
 283     static const char *p_show =
 284         " XXXX X   X  XXX  X   X   XXXXX  XXX   XXX  XX XXL"
 285         "X     X   X X   X X   X      X  X   X X   X X X XL"
 286         " XXX  XXXXX X   X X X X     X   X   X X   X X   XL"
 287         "    X X   X X   X X X X    X    X   X X   X X   XL"
 288         "XXXX  X   X  XXX   X X    XXXXX  XXX   XXX  X   XL";
 289     const char *p_draw = b_visible ? p_hide : p_show;
 290
 291     for( int i = 0, x = i_offset_x, y = i_offset_y; p_draw[i] != '\0'; i++ )
 292     {
 293         if( p_draw[i] == 'X' )
 294         {
 295             if( x < i_width && y < i_height )
 296                 pb_dst[y*i_pitch + x] = 0xff;
 297             x++;
 298         }
 299         else if( p_draw[i] == ' ' )
 300         {
 301             x++;
 302         }
 303         else if( p_draw[i] == 'L' )
 304         {
 305             x = i_offset_x;
 306             y++;
 307         }
 308     }
 309 }
 310 static void DrawRectangle( uint8_t *pb_dst, int i_pitch, int i_width, int i_height,
 311                            int x, int y, int i_w, int i_h )
 312 {
 313     if( x + i_w > i_width || y + i_h > i_height )
 314         return;
 315
 316     /* top line */
 317     memset( &pb_dst[y * i_pitch + x], 0xff, i_w );
 318
 319     /* left and right */
 320     for( int dy = 1; dy < i_h-1; dy++ )
 321     {
 322         pb_dst[(y+dy) * i_pitch + x +     0] = 0xff;
 323         pb_dst[(y+dy) * i_pitch + x + i_w-1] = 0xff;
 324     }
 325
 326     /* bottom line */
 327     memset( &pb_dst[(y+i_h-1) * i_pitch + x], 0xff, i_w );
 328 }
 329
 330 static int Mouse( filter_t *p_filter, vlc_mouse_t *p_new, const vlc_mouse_t *p_old )
 331 {
 332     filter_sys_t *p_sys = p_filter->p_sys;
 333     const video_format_t *p_fmt = &p_filter->fmt_in.video;
 334
 335     /* */
 336     const bool b_click = vlc_mouse_HasPressed( p_old, p_new, MOUSE_BUTTON_LEFT );
 337     const bool b_pressed = vlc_mouse_IsLeftPressed( p_new );
 338
 339     bool b_grab = false;
 340
 341     /* Find the mouse position */
 342     if( p_sys->b_visible )
 343     {
 344         const int i_visu_width  = p_fmt->i_visible_width  / VIS_ZOOM;
 345         const int i_visu_height = p_fmt->i_visible_height / VIS_ZOOM;
 346
 347         if( p_new->i_x >= 0 && p_new->i_x < i_visu_width &&
 348             p_new->i_y >= 0 && p_new->i_y < i_visu_height )
 349         {
 350             /* Visualization */
 351             if( b_pressed )
 352             {
 353                 const int v_w = p_fmt->i_visible_width  * ZOOM_FACTOR / p_sys->i_zoom;
 354                 const int v_h = p_fmt->i_visible_height * ZOOM_FACTOR / p_sys->i_zoom;
 355
 356                 p_sys->i_x = VLC_CLIP( p_new->i_x * VIS_ZOOM - v_w/2, 0,
 357                                            (int)p_fmt->i_visible_width  - v_w - 1);
 358                 p_sys->i_y = VLC_CLIP( p_new->i_y * VIS_ZOOM - v_h/2, 0,
 359                                            (int)p_fmt->i_visible_height - v_h - 1);
 360
 361                 b_grab = true;
 362             }
 363         }
 364         else if( p_new->i_x >= 0 && p_new->i_x < 80 &&
 365                  p_new->i_y >= i_visu_height &&
 366                  p_new->i_y <  i_visu_height + 9 )
 367         {
 368             /* Hide text */
 369             if( b_click )
 370             {
 371                 p_sys->b_visible = false;
 372                 b_grab = true;
 373             }
 374         }
 375         else if( p_new->i_x >= 0 &&
 376                  p_new->i_x <= ( i_visu_height + 90 - p_new->i_y ) *
 377                                ( i_visu_height + 90 - p_new->i_y ) / 160 &&
 378                  p_new->i_y >= i_visu_height + 9 &&
 379                  p_new->i_y <= i_visu_height + 90 )
 380         {
 381             /* Zoom gauge */
 382             if( b_pressed )
 383             {
 384                 p_sys->i_zoom = __MAX( ZOOM_FACTOR,
 385                                        (80 + i_visu_height - p_new->i_y + 2) *
 386                                            ZOOM_FACTOR / 10 );
 387
 388                 const int v_w = p_fmt->i_visible_width  * ZOOM_FACTOR / p_sys->i_zoom;
 389                 const int v_h = p_fmt->i_visible_height * ZOOM_FACTOR / p_sys->i_zoom;
 390                 p_sys->i_x = VLC_CLIP( p_sys->i_x, 0, (int)p_fmt->i_visible_width  - v_w - 1 );
 391                 p_sys->i_y = VLC_CLIP( p_sys->i_y, 0, (int)p_fmt->i_visible_height - v_h - 1 );
 392
 393                 b_grab = true;
 394             }
 395         }
 396     }
 397     else
 398     {
 399         if( p_new->i_x >= 0 && p_new->i_x <  80 &&
 400             p_new->i_y >= 0 && p_new->i_y <= 10 )
 401         {
 402             /* Show text */
 403             if( b_click )
 404             {
 405                 p_sys->b_visible = true;
 406                 b_grab = true;
 407             }
 408         }
 409     }
 410
 411     if( vlc_mouse_HasMoved( p_old, p_new ) )
 412         p_sys->i_last_activity = vlc_tick_now();
 413
 414     if( b_grab )
 415         return VLC_EGENERIC;
 416
 417     /* */
 418     p_new->i_x = p_sys->i_x + p_new->i_x * ZOOM_FACTOR / p_sys->i_zoom;
 419     p_new->i_y = p_sys->i_y + p_new->i_y * ZOOM_FACTOR / p_sys->i_zoom;
 420     return VLC_SUCCESS;
 421 }
 422