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

   1 /*****************************************************************************
   2  * magnify.c : Magnify/Zoom interactive effect
   3  *****************************************************************************
   4  * Copyright (C) 2005 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Antoine Cellerier <dionoea -at- videolan -dot- 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., 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_vout.h>
  35
  36 #include <math.h>
  37
  38 #include "filter_common.h"
  39 #include "filter_picture.h"
  40
  41 #include "vlc_image.h"
  42
  43 /*****************************************************************************
  44  * Module descriptor
  45  *****************************************************************************/
  46 static int  Create    ( vlc_object_t * );
  47 static void Destroy   ( vlc_object_t * );
  48
  49 vlc_module_begin ()
  50     set_description( N_("Magnify/Zoom interactive video filter") )
  51     set_shortname( N_( "Magnify" ))
  52     set_capability( "video filter", 0 )
  53     set_category( CAT_VIDEO )
  54     set_subcategory( SUBCAT_VIDEO_VFILTER )
  55
  56     set_callbacks( Create, Destroy )
  57 vlc_module_end ()
  58
  59
  60 /*****************************************************************************
  61  * Local prototypes
  62  *****************************************************************************/
  63 static int  Init      ( vout_thread_t * );
  64 static void End       ( vout_thread_t * );
  65 static void Render    ( vout_thread_t *, picture_t * );
  66
  67 static int  SendEvents   ( vlc_object_t *, char const *,
  68                            vlc_value_t, vlc_value_t, void * );
  69 static int  MouseEvent   ( vlc_object_t *, char const *,
  70                            vlc_value_t, vlc_value_t, void * );
  71
  72 static void DrawZoomStatus( uint8_t *, int i_pitch, int i_width, int i_height,
  73                             int i_offset_x, int i_offset_y, bool b_visible );
  74 static void DrawRectangle( uint8_t *, int i_pitch, int i_width, int i_height,
  75                            int x, int y, int i_w, int i_h );
  76
  77 /*****************************************************************************
  78  * vout_sys_t: Magnify video output method descriptor
  79  *****************************************************************************/
  80 struct vout_sys_t
  81 {
  82     vout_thread_t *p_vout;
  83
  84     image_handler_t *p_image;
  85
  86     int64_t i_hide_timeout;
  87
  88     vlc_mutex_t lock;
  89     int i_zoom; /* zoom level in percent */
  90     int i_x, i_y; /* top left corner coordinates in original image */
  91
  92     bool b_visible; /* is "interface" visible ? */
  93
  94     int64_t i_last_activity;
  95 };
  96
  97 #define VIS_ZOOM 4
  98 #define ZOOM_FACTOR 8
  99
 100 /*****************************************************************************
 101  * Control: control facility for the vout (forwards to child vout)
 102  *****************************************************************************/
 103 static int Control( vout_thread_t *p_vout, int i_query, va_list args )
 104 {
 105     return vout_vaControl( p_vout->p_sys->p_vout, i_query, args );
 106 }
 107
 108 /*****************************************************************************
 109  * Create: allocates Magnify video thread output method
 110  *****************************************************************************/
 111 static int Create( vlc_object_t *p_this )
 112 {
 113     vout_thread_t *p_vout = (vout_thread_t *)p_this;
 114
 115     switch( p_vout->fmt_in.i_chroma )
 116     {
 117         CASE_PLANAR_YUV
 118         case VLC_FOURCC('G','R','E','Y'):
 119             break;
 120         default:
 121             msg_Err( p_vout, "Unsupported chroma" );
 122             return VLC_EGENERIC;
 123     }
 124
 125     /* Allocate structure */
 126     p_vout->p_sys = malloc( sizeof( vout_sys_t ) );
 127     if( p_vout->p_sys == NULL )
 128         return VLC_ENOMEM;
 129
 130     p_vout->p_sys->p_image = image_HandlerCreate( p_vout );
 131
 132     p_vout->pf_init = Init;
 133     p_vout->pf_end = End;
 134     p_vout->pf_manage = NULL;
 135     p_vout->pf_render = Render;
 136     p_vout->pf_display = NULL;
 137     p_vout->pf_control = Control;
 138
 139     return VLC_SUCCESS;
 140 }
 141
 142 /*****************************************************************************
 143  * Init: initialize Magnify video thread output method
 144  *****************************************************************************/
 145 static int Init( vout_thread_t *p_vout )
 146 {
 147     int i_index;
 148     picture_t *p_pic;
 149     video_format_t fmt;
 150
 151     memset( &fmt, 0, sizeof(video_format_t) );
 152     I_OUTPUTPICTURES = 0;
 153
 154     /* Initialize the output structure */
 155     p_vout->output.i_chroma = p_vout->render.i_chroma;
 156     p_vout->output.i_width  = p_vout->render.i_width;
 157     p_vout->output.i_height = p_vout->render.i_height;
 158     p_vout->output.i_aspect = p_vout->render.i_aspect;
 159
 160     p_vout->fmt_out = p_vout->fmt_in;
 161     fmt = p_vout->fmt_out;
 162
 163     /* Try to open the real video output */
 164     msg_Dbg( p_vout, "spawning the real video output" );
 165
 166     p_vout->p_sys->p_vout = vout_Create( p_vout, &fmt );
 167
 168     /* Everything failed */
 169     if( p_vout->p_sys->p_vout == NULL )
 170     {
 171         msg_Err( p_vout, "cannot open vout, aborting" );
 172         return VLC_EGENERIC;
 173     }
 174
 175     vlc_mutex_init( &p_vout->p_sys->lock );
 176     p_vout->p_sys->i_x = 0;
 177     p_vout->p_sys->i_y = 0;
 178     p_vout->p_sys->i_zoom = 2*ZOOM_FACTOR;
 179     p_vout->p_sys->b_visible = true;
 180     p_vout->p_sys->i_last_activity = mdate();
 181     p_vout->p_sys->i_hide_timeout = 1000 * var_GetInteger( p_vout, "mouse-hide-timeout" );
 182
 183     var_AddCallback( p_vout->p_sys->p_vout, "mouse-x", MouseEvent, p_vout );
 184     var_AddCallback( p_vout->p_sys->p_vout, "mouse-y", MouseEvent, p_vout );
 185     var_AddCallback( p_vout->p_sys->p_vout, "mouse-clicked",
 186                      MouseEvent, p_vout);
 187
 188     ALLOCATE_DIRECTBUFFERS( VOUT_MAX_PICTURES );
 189     ADD_CALLBACKS( p_vout->p_sys->p_vout, SendEvents );
 190     ADD_PARENT_CALLBACKS( SendEventsToChild );
 191
 192     return VLC_SUCCESS;
 193 }
 194
 195 /*****************************************************************************
 196  * End: terminate Magnify video thread output method
 197  *****************************************************************************/
 198 static void End( vout_thread_t *p_vout )
 199 {
 200     int i_index;
 201
 202     DEL_PARENT_CALLBACKS( SendEventsToChild );
 203
 204     DEL_CALLBACKS( p_vout->p_sys->p_vout, SendEvents );
 205
 206     /* Free the fake output buffers we allocated */
 207     for( i_index = I_OUTPUTPICTURES ; i_index ; )
 208     {
 209         i_index--;
 210         free( PP_OUTPUTPICTURE[ i_index ]->p_data_orig );
 211     }
 212
 213     var_DelCallback( p_vout->p_sys->p_vout, "mouse-x", MouseEvent, p_vout);
 214     var_DelCallback( p_vout->p_sys->p_vout, "mouse-y", MouseEvent, p_vout);
 215     var_DelCallback( p_vout->p_sys->p_vout, "mouse-clicked", MouseEvent, p_vout);
 216
 217     vlc_mutex_destroy( &p_vout->p_sys->lock );
 218
 219     vout_CloseAndRelease( p_vout->p_sys->p_vout );
 220 }
 221
 222 /*****************************************************************************
 223  * Destroy: destroy Magnify video thread output method
 224  *****************************************************************************/
 225 static void Destroy( vlc_object_t *p_this )
 226 {
 227     vout_thread_t *p_vout = (vout_thread_t *)p_this;
 228
 229     image_HandlerDelete( p_vout->p_sys->p_image );
 230
 231
 232     free( p_vout->p_sys );
 233 }
 234
 235 /*****************************************************************************
 236  * Render: displays previously rendered output
 237  *****************************************************************************/
 238 static void Render( vout_thread_t *p_vout, picture_t *p_pic )
 239 {
 240     vout_sys_t *p_sys = p_vout->p_sys;
 241     picture_t *p_outpic;
 242
 243     int v_w, v_h;
 244     picture_t *p_converted;
 245     plane_t *p_oyp;
 246     int i_plane;
 247
 248     /* This is a new frame. Get a structure from the video_output. */
 249     while( ( p_outpic = vout_CreatePicture( p_sys->p_vout, 0, 0, 0 ) )
 250               == NULL )
 251     {
 252         if( !vlc_object_alive (p_vout) || p_vout->b_error )
 253         {
 254             return;
 255         }
 256         msleep( VOUT_OUTMEM_SLEEP );
 257     }
 258
 259     p_outpic->date = p_pic->date;
 260
 261     vlc_mutex_lock( &p_sys->lock );
 262     const bool b_visible = p_sys->b_visible;
 263     const int o_x = p_sys->i_x;
 264     const int o_y = p_sys->i_y;
 265     const int o_zoom = p_sys->i_zoom;
 266     const int64_t i_last_activity = p_sys->i_last_activity;
 267     vlc_mutex_unlock( &p_sys->lock );
 268
 269     /* background magnified image */
 270     if( o_zoom != ZOOM_FACTOR )
 271     {
 272         video_format_t fmt_in;
 273         video_format_t fmt_out;
 274         picture_t crop;
 275
 276         crop = *p_pic;
 277         for( i_plane = 0; i_plane < p_pic->i_planes; i_plane++ )
 278         {
 279             const int o_yp = o_y * p_outpic->p[i_plane].i_lines / p_outpic->p[Y_PLANE].i_lines;
 280             const int o_xp = o_x * p_outpic->p[i_plane].i_pitch / p_outpic->p[Y_PLANE].i_pitch;
 281
 282             crop.p[i_plane].p_pixels += o_yp * p_outpic->p[i_plane].i_pitch + o_xp;
 283         }
 284
 285         /* */
 286         fmt_in = p_vout->fmt_out;
 287         fmt_in.i_width  = (fmt_in.i_width  * ZOOM_FACTOR / o_zoom) & ~1;
 288         fmt_in.i_height = (fmt_in.i_height * ZOOM_FACTOR / o_zoom) & ~1;
 289
 290         /* */
 291         fmt_out = p_vout->fmt_out;
 292
 293         p_converted = image_Convert( p_sys->p_image, &crop, &fmt_in, &fmt_out );
 294
 295         picture_CopyPixels( p_outpic, p_converted );
 296
 297         picture_Release( p_converted );
 298     }
 299     else
 300     {
 301         picture_CopyPixels( p_outpic, p_pic );
 302     }
 303
 304     /* */
 305     p_oyp = &p_outpic->p[Y_PLANE];
 306     if( b_visible )
 307     {
 308         video_format_t fmt_out;
 309
 310         /* image visualization */
 311         fmt_out = p_vout->fmt_out;
 312         fmt_out.i_width  = (p_vout->render.i_width/VIS_ZOOM ) & ~1;
 313         fmt_out.i_height = (p_vout->render.i_height/VIS_ZOOM) & ~1;
 314         p_converted = image_Convert( p_sys->p_image, p_pic,
 315                                      &p_pic->format, &fmt_out );
 316         for( i_plane = 0; i_plane < p_pic->i_planes; i_plane++ )
 317         {
 318             int y;
 319             for( y = 0; y < p_converted->p[i_plane].i_visible_lines; y++)
 320             {
 321                 vlc_memcpy(
 322                     &p_outpic->p[i_plane].p_pixels[y*p_outpic->p[i_plane].i_pitch],
 323                     p_converted->p[i_plane].p_pixels+y*p_converted->p[i_plane].i_pitch,
 324                     p_converted->p[i_plane].i_visible_pitch );
 325             }
 326         }
 327         picture_Release( p_converted );
 328
 329         /* white rectangle on visualization */
 330         v_w = __MIN( fmt_out.i_width  * ZOOM_FACTOR / o_zoom, fmt_out.i_width - 1 );
 331         v_h = __MIN( fmt_out.i_height * ZOOM_FACTOR / o_zoom, fmt_out.i_height - 1 );
 332
 333         DrawRectangle( p_oyp->p_pixels, p_oyp->i_pitch,
 334                        p_oyp->i_pitch, p_oyp->i_lines,
 335                        o_x/VIS_ZOOM, o_y/VIS_ZOOM,
 336                        v_w, v_h );
 337
 338         /* */
 339         v_h = fmt_out.i_height + 1;
 340     }
 341     else
 342     {
 343         v_h = 1;
 344     }
 345
 346     /* print a small "VLC ZOOM" */
 347     if( b_visible || i_last_activity + p_sys->i_hide_timeout > mdate() )
 348         DrawZoomStatus( p_oyp->p_pixels, p_oyp->i_pitch, p_oyp->i_pitch, p_oyp->i_lines,
 349                         1, v_h, b_visible );
 350
 351     if( b_visible )
 352     {
 353         int y;
 354
 355         /* zoom gauge */
 356         vlc_memset( p_oyp->p_pixels + (v_h+9)*p_oyp->i_pitch, 0xff, 41 );
 357         for( y = v_h + 10; y < v_h + 90; y++ )
 358         {
 359             int width = v_h + 90 - y;
 360             width = (width*width)/160;
 361             if( (80 - y + v_h)*ZOOM_FACTOR/10 < o_zoom )
 362             {
 363                 vlc_memset( p_oyp->p_pixels + y*p_oyp->i_pitch, 0xff, width );
 364             }
 365             else
 366             {
 367                 p_oyp->p_pixels[y*p_oyp->i_pitch] = 0xff;
 368                 p_oyp->p_pixels[y*p_oyp->i_pitch + width - 1] = 0xff;
 369             }
 370         }
 371     }
 372
 373     vout_DisplayPicture( p_sys->p_vout, p_outpic );
 374 }
 375
 376 static void DrawZoomStatus( uint8_t *pb_dst, int i_pitch, int i_width, int i_height,
 377                             int i_offset_x, int i_offset_y, bool b_visible )
 378 {
 379     static const char *p_hide =
 380         "X   X X      XXXX   XXXXX  XXX   XXX  XX XX   X   X XXXXX XXXX  XXXXXL"
 381         "X   X X     X          X  X   X X   X X X X   X   X   X   X   X X    L"
 382         " X X  X     X         X   X   X X   X X   X   XXXXX   X   X   X XXXX L"
 383         " X X  X     X        X    X   X X   X X   X   X   X   X   X   X X    L"
 384         "  X   XXXXX  XXXX   XXXXX  XXX   XXX  X   X   X   X XXXXX XXXX  XXXXXL";
 385     static const char *p_show =
 386         "X   X X      XXXX   XXXXX  XXX   XXX  XX XX    XXXX X   X  XXX  X   XL"
 387         "X   X X     X          X  X   X X   X X X X   X     X   X X   X X   XL"
 388         " X X  X     X         X   X   X X   X X   X    XXX  XXXXX X   X X X XL"
 389         " X X  X     X        X    X   X X   X X   X       X X   X X   X X X XL"
 390         "  X   XXXXX  XXXX   XXXXX  XXX   XXX  X   X   XXXX  X   X  XXX   X X L";
 391     const char *p_draw = b_visible ? p_hide : p_show;
 392     int i, y, x;
 393
 394     for( i = 0, x = i_offset_x, y = i_offset_y; p_draw[i] != '\0'; i++ )
 395     {
 396         if( p_draw[i] == 'X' )
 397         {
 398             if( x < i_width && y < i_height )
 399                 pb_dst[y*i_pitch + x] = 0xff;
 400             x++;
 401         }
 402         else if( p_draw[i] == ' ' )
 403         {
 404             x++;
 405         }
 406         else if( p_draw[i] == 'L' )
 407         {
 408             x = i_offset_x;
 409             y++;
 410         }
 411     }
 412 }
 413 static void DrawRectangle( uint8_t *pb_dst, int i_pitch, int i_width, int i_height,
 414                            int x, int y, int i_w, int i_h )
 415 {
 416     int dy;
 417
 418     if( x + i_w > i_width || y + i_h > i_height )
 419         return;
 420
 421     /* top line */
 422     vlc_memset( &pb_dst[y * i_pitch + x], 0xff, i_w );
 423
 424     /* left and right */
 425     for( dy = 1; dy < i_h-1; dy++ )
 426     {
 427         pb_dst[(y+dy) * i_pitch + x +     0] = 0xff;
 428         pb_dst[(y+dy) * i_pitch + x + i_w-1] = 0xff;
 429     }
 430
 431     /* bottom line */
 432     vlc_memset( &pb_dst[(y+i_h-1) * i_pitch + x], 0xff, i_w );
 433 }
 434
 435 /*****************************************************************************
 436  * SendEvents: forward mouse and keyboard events to the parent p_vout
 437  *****************************************************************************/
 438 static int SendEvents( vlc_object_t *p_this, char const *psz_var,
 439                        vlc_value_t oldval, vlc_value_t newval, void *p_data )
 440 {
 441     VLC_UNUSED(p_this); VLC_UNUSED(oldval);
 442     var_Set( (vlc_object_t *)p_data, psz_var, newval );
 443
 444     return VLC_SUCCESS;
 445 }
 446
 447 /*****************************************************************************
 448  * SendEventsToChild: forward events to the child/children vout
 449  *****************************************************************************/
 450 static int SendEventsToChild( vlc_object_t *p_this, char const *psz_var,
 451                        vlc_value_t oldval, vlc_value_t newval, void *p_data )
 452 {
 453     VLC_UNUSED(p_data); VLC_UNUSED(oldval);
 454     vout_thread_t *p_vout = (vout_thread_t *)p_this;
 455     var_Set( p_vout->p_sys->p_vout, psz_var, newval );
 456     return VLC_SUCCESS;
 457 }
 458
 459 /*****************************************************************************
 460  * MouseEvent: callback for mouse events
 461  *****************************************************************************/
 462 static int MouseEvent( vlc_object_t *p_this, char const *psz_var,
 463                        vlc_value_t oldval, vlc_value_t newval, void *p_data )
 464 {
 465     vout_thread_t *p_vout = (vout_thread_t*)p_data;
 466     vlc_value_t vald,valx,valy;
 467
 468     VLC_UNUSED(p_this);
 469
 470 #define MOUSE_DOWN    1
 471 #define MOUSE_CLICKED 2
 472 #define MOUSE_MOVE_X  4
 473 #define MOUSE_MOVE_Y  8
 474 #define MOUSE_MOVE    12
 475     uint8_t mouse= 0;
 476
 477     if( psz_var[6] == 'x' ) mouse |= MOUSE_MOVE_X;
 478     if( psz_var[6] == 'y' ) mouse |= MOUSE_MOVE_Y;
 479     if( psz_var[6] == 'c' ) mouse |= MOUSE_CLICKED;
 480
 481     var_Get( p_vout->p_sys->p_vout, "mouse-button-down", &vald );
 482     if( vald.i_int & 0x1 ) mouse |= MOUSE_DOWN;
 483     var_Get( p_vout->p_sys->p_vout, "mouse-y", &valy );
 484     var_Get( p_vout->p_sys->p_vout, "mouse-x", &valx );
 485
 486     vlc_mutex_lock( &p_vout->p_sys->lock );
 487
 488     const int v_h = p_vout->output.i_height*ZOOM_FACTOR/p_vout->p_sys->i_zoom;
 489     const int v_w = p_vout->output.i_width*ZOOM_FACTOR/p_vout->p_sys->i_zoom;
 490
 491     if( ( mouse&MOUSE_MOVE && mouse&MOUSE_DOWN)
 492         || mouse&MOUSE_CLICKED )
 493     {
 494     /* (mouse moved and mouse button is down) or (mouse clicked) */
 495         if( p_vout->p_sys->b_visible )
 496         {
 497             if(    0 <= valy.i_int
 498                 && valy.i_int < (int)p_vout->output.i_height/VIS_ZOOM
 499                 && 0 <= valx.i_int
 500                 && valx.i_int < (int)p_vout->output.i_width/VIS_ZOOM )
 501             {
 502             /* mouse is over visualisation */
 503                 p_vout->p_sys->i_x = __MIN( __MAX( valx.i_int*VIS_ZOOM - v_w/2, 0 ),
 504                                             p_vout->output.i_width - v_w - 1);
 505                 p_vout->p_sys->i_y = __MIN( __MAX( valy.i_int * VIS_ZOOM - v_h/2,
 506                                         0 ), p_vout->output.i_height - v_h - 1);
 507             }
 508             else if( valx.i_int >= 0 && valx.i_int < 80
 509                 && valy.i_int >= (int)p_vout->output.i_height/VIS_ZOOM
 510                 && valy.i_int < (int)p_vout->output.i_height/VIS_ZOOM + 9
 511                 && mouse&MOUSE_CLICKED )
 512             {
 513             /* mouse is over the "VLC ZOOM HIDE" text */
 514                 p_vout->p_sys->b_visible = false;
 515             }
 516             else if(    (int)p_vout->output.i_height/VIS_ZOOM + 9 <= valy.i_int
 517                      && valy.i_int <= (int)p_vout->output.i_height/VIS_ZOOM + 90
 518                      && 0 <= valx.i_int
 519                      && valx.i_int <=
 520                      (( (int)p_vout->output.i_height/VIS_ZOOM + 90 -  valy.i_int)
 521                *( (int)p_vout->output.i_height/VIS_ZOOM + 90 -  valy.i_int))/160 )
 522             {
 523             /* mouse is over zoom gauge */
 524                 p_vout->p_sys->i_zoom = __MAX( ZOOM_FACTOR,
 525                                 ( 80 + (int)p_vout->output.i_height/VIS_ZOOM
 526                                    - valy.i_int + 2) * ZOOM_FACTOR/10 );
 527             }
 528             else if( mouse&MOUSE_MOVE_X && !(mouse&MOUSE_CLICKED) )
 529             {
 530                 p_vout->p_sys->i_x -= (newval.i_int - oldval.i_int)
 531                                       *ZOOM_FACTOR/p_vout->p_sys->i_zoom;
 532             }
 533             else if( mouse&MOUSE_MOVE_Y && !(mouse&MOUSE_CLICKED) )
 534             {
 535                 p_vout->p_sys->i_y -= (newval.i_int - oldval.i_int)
 536                                       *ZOOM_FACTOR/p_vout->p_sys->i_zoom;
 537             }
 538         }
 539         else
 540         {
 541             if( valx.i_int >= 0 && valx.i_int < 80 && valy.i_int >= 0
 542                 && valy.i_int <= 10 && mouse&MOUSE_CLICKED )
 543             {
 544             /* mouse is over the "VLC ZOOM SHOW" text */
 545                 p_vout->p_sys->b_visible = true;
 546             }
 547             else if( mouse&MOUSE_MOVE_X && !(mouse&MOUSE_CLICKED) )
 548             {
 549                 p_vout->p_sys->i_x -= (newval.i_int - oldval.i_int)
 550                                       *ZOOM_FACTOR/p_vout->p_sys->i_zoom;
 551             }
 552             else if( mouse&MOUSE_MOVE_Y && !(mouse&MOUSE_CLICKED) )
 553             {
 554                 p_vout->p_sys->i_y -= (newval.i_int - oldval.i_int)
 555                                       *ZOOM_FACTOR/p_vout->p_sys->i_zoom;
 556             }
 557         }
 558     }
 559
 560     p_vout->p_sys->i_x =
 561          __MAX( 0, __MIN( p_vout->p_sys->i_x, (int)p_vout->output.i_width
 562          - (int)p_vout->output.i_width*ZOOM_FACTOR/p_vout->p_sys->i_zoom - 1 ));
 563     p_vout->p_sys->i_y =
 564          __MAX( 0, __MIN( p_vout->p_sys->i_y, (int)p_vout->output.i_height
 565         - (int)p_vout->output.i_height*ZOOM_FACTOR/p_vout->p_sys->i_zoom - 1 ));
 566
 567     p_vout->p_sys->i_last_activity = mdate();
 568     vlc_mutex_unlock( &p_vout->p_sys->lock );
 569
 570     return VLC_SUCCESS;
 571 }