modules/access/screen/win32.c

   1 /*****************************************************************************
   2  * win32.c: Screen capture module.
   3  *****************************************************************************
   4  * Copyright (C) 2004-2011 VLC authors and VideoLAN
   5  * $Id$
   6  *
   7  * Authors: Gildas Bazin <gbazin@videolan.org>
   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
  34 #include "screen.h"
  35
  36 struct screen_data_t
  37 {
  38     HDC hdc_src;
  39     HDC hdc_dst;
  40     BITMAPINFO bmi;
  41     HGDIOBJ hgdi_backup;
  42     POINT ptl;             /* Coordinates of the primary display's top left, when the origin
  43                             * is taken to be the top left of the entire virtual screen */
  44
  45     int i_fragment_size;
  46     int i_fragment;
  47     block_t *p_block;
  48 };
  49
  50 /*
  51  * In screen coordinates the origin is the upper-left corner of the primary
  52  * display, and points can have negative x/y when other displays are located
  53  * to the left/top of the primary.
  54  *
  55  * Windows may supply these coordinates in physical or logical units
  56  * depending on the version of Windows and the DPI awareness of the application.
  57  * I have noticed that even different interfaces of VLC (qt, rc...) can lead
  58  * to differences in DPI awareness. The choice of physical vs logical seems
  59  * to be universal though (it applies to everything we use, from GetCursorPos
  60  * to GetSystemMetrics and BitBlt) so we don't have to worry about anything.
  61  *
  62  * The only issue here is that it can be confusing to users when setting e.g.
  63  * subscreen position and dimensions. This however can be controlled by
  64  * disabling display scaling in the compatibility settings of the VLC executable.
  65  */
  66 static inline void FromScreenCoordinates( demux_t *p_demux, POINT *p_point )
  67 {
  68     demux_sys_t *p_sys = p_demux->p_sys;
  69     screen_data_t *p_data = p_sys->p_data;
  70     p_point->x += p_data->ptl.x;
  71     p_point->y += p_data->ptl.y;
  72 }
  73
  74 static inline void ToScreenCoordinates( demux_t *p_demux, POINT *p_point )
  75 {
  76     demux_sys_t *p_sys = p_demux->p_sys;
  77     screen_data_t *p_data = p_sys->p_data;
  78     p_point->x -= p_data->ptl.x;
  79     p_point->y -= p_data->ptl.y;
  80 }
  81
  82 int screen_InitCapture( demux_t *p_demux )
  83 {
  84     demux_sys_t *p_sys = p_demux->p_sys;
  85     screen_data_t *p_data;
  86     int i_chroma, i_bits_per_pixel;
  87
  88     p_sys->p_data = p_data = calloc( 1, sizeof( screen_data_t ) );
  89     if( !p_data )
  90         return VLC_ENOMEM;
  91
  92     /* Get the device context for the whole screen */
  93     p_data->hdc_src = CreateDC( TEXT("DISPLAY"), NULL, NULL, NULL );
  94     if( !p_data->hdc_src )
  95     {
  96         msg_Err( p_demux, "cannot get device context" );
  97         free( p_data );
  98         return VLC_EGENERIC;
  99     }
 100
 101     p_data->hdc_dst = CreateCompatibleDC( p_data->hdc_src );
 102     if( !p_data->hdc_dst )
 103     {
 104         msg_Err( p_demux, "cannot get compat device context" );
 105         ReleaseDC( 0, p_data->hdc_src );
 106         free( p_data );
 107         return VLC_EGENERIC;
 108     }
 109
 110     i_bits_per_pixel = GetDeviceCaps( p_data->hdc_src, BITSPIXEL );
 111     switch( i_bits_per_pixel )
 112     {
 113     case 8: /* FIXME: set the palette */
 114         i_chroma = VLC_CODEC_RGB8; break;
 115     case 15:
 116     case 16:    /* Yes it is really 15 bits (when using BI_RGB) */
 117         i_chroma = VLC_CODEC_RGB15; break;
 118     case 24:
 119         i_chroma = VLC_CODEC_RGB24; break;
 120     case 32:
 121         i_chroma = VLC_CODEC_RGB32; break;
 122     default:
 123         msg_Err( p_demux, "unknown screen depth %i", i_bits_per_pixel );
 124         DeleteDC( p_data->hdc_dst );
 125         ReleaseDC( 0, p_data->hdc_src );
 126         free( p_data );
 127         return VLC_EGENERIC;
 128     }
 129
 130     es_format_Init( &p_sys->fmt, VIDEO_ES, i_chroma );
 131     p_sys->fmt.video.i_visible_width  =
 132     p_sys->fmt.video.i_width          = GetSystemMetrics( SM_CXVIRTUALSCREEN );
 133     p_sys->fmt.video.i_visible_height =
 134     p_sys->fmt.video.i_height         = GetSystemMetrics( SM_CYVIRTUALSCREEN );
 135     p_sys->fmt.video.i_bits_per_pixel = i_bits_per_pixel;
 136     p_sys->fmt.video.i_sar_num = p_sys->fmt.video.i_sar_den = 1;
 137     p_sys->fmt.video.i_chroma         = i_chroma;
 138     p_sys->fmt.video.transfer         = TRANSFER_FUNC_SRGB;
 139     p_sys->fmt.video.b_color_range_full = true;
 140
 141     switch( i_chroma )
 142     {
 143     case VLC_CODEC_RGB15:
 144         p_sys->fmt.video.i_rmask = 0x7c00;
 145         p_sys->fmt.video.i_gmask = 0x03e0;
 146         p_sys->fmt.video.i_bmask = 0x001f;
 147         break;
 148     case VLC_CODEC_RGB24:
 149         p_sys->fmt.video.i_rmask = 0x00ff0000;
 150         p_sys->fmt.video.i_gmask = 0x0000ff00;
 151         p_sys->fmt.video.i_bmask = 0x000000ff;
 152         break;
 153     case VLC_CODEC_RGB32:
 154         p_sys->fmt.video.i_rmask = 0x00ff0000;
 155         p_sys->fmt.video.i_gmask = 0x0000ff00;
 156         p_sys->fmt.video.i_bmask = 0x000000ff;
 157         break;
 158     default:
 159         msg_Warn( p_demux, "Unknown RGB masks" );
 160         break;
 161     }
 162
 163     p_data->ptl.x = - GetSystemMetrics( SM_XVIRTUALSCREEN );
 164     p_data->ptl.y = - GetSystemMetrics( SM_YVIRTUALSCREEN );
 165
 166     return VLC_SUCCESS;
 167 }
 168
 169 int screen_CloseCapture( demux_t *p_demux )
 170 {
 171     demux_sys_t *p_sys = p_demux->p_sys;
 172     screen_data_t *p_data = p_sys->p_data;
 173
 174     if( p_data->p_block ) block_Release( p_data->p_block );
 175
 176     if( p_data->hgdi_backup)
 177         SelectObject( p_data->hdc_dst, p_data->hgdi_backup );
 178
 179     DeleteDC( p_data->hdc_dst );
 180     ReleaseDC( 0, p_data->hdc_src );
 181     free( p_data );
 182
 183     return VLC_SUCCESS;
 184 }
 185
 186 struct block_sys_t
 187 {
 188     block_t self;
 189     HBITMAP hbmp;
 190 };
 191
 192 static void CaptureBlockRelease( block_t *p_block )
 193 {
 194     DeleteObject( ((struct block_sys_t *)p_block)->hbmp );
 195     free( p_block );
 196 }
 197
 198 static const struct vlc_block_callbacks CaptureBlockCallbacks =
 199 {
 200     CaptureBlockRelease,
 201 };
 202
 203 static block_t *CaptureBlockNew( demux_t *p_demux )
 204 {
 205     demux_sys_t *p_sys = p_demux->p_sys;
 206     screen_data_t *p_data = p_sys->p_data;
 207     struct block_sys_t *p_block;
 208     void *p_buffer;
 209     int i_buffer;
 210     HBITMAP hbmp;
 211
 212     if( p_data->bmi.bmiHeader.biSize == 0 )
 213     {
 214         int i_val;
 215         /* Create the bitmap info header */
 216         p_data->bmi.bmiHeader.biSize          = sizeof(BITMAPINFOHEADER);
 217         p_data->bmi.bmiHeader.biWidth         = p_sys->fmt.video.i_width;
 218         p_data->bmi.bmiHeader.biHeight        = - p_sys->fmt.video.i_height;
 219         p_data->bmi.bmiHeader.biPlanes        = 1;
 220         p_data->bmi.bmiHeader.biBitCount      = p_sys->fmt.video.i_bits_per_pixel;
 221         p_data->bmi.bmiHeader.biCompression   = BI_RGB;
 222         p_data->bmi.bmiHeader.biSizeImage     = 0;
 223         p_data->bmi.bmiHeader.biXPelsPerMeter = 0;
 224         p_data->bmi.bmiHeader.biYPelsPerMeter = 0;
 225         p_data->bmi.bmiHeader.biClrUsed       = 0;
 226         p_data->bmi.bmiHeader.biClrImportant  = 0;
 227
 228         i_val = var_CreateGetInteger( p_demux, "screen-fragment-size" );
 229         p_data->i_fragment_size = i_val > 0 ? i_val : (int)p_sys->fmt.video.i_height;
 230         p_data->i_fragment_size = i_val > (int)p_sys->fmt.video.i_height ?
 231                                             (int)p_sys->fmt.video.i_height :
 232                                             p_data->i_fragment_size;
 233         p_sys->f_fps *= (p_sys->fmt.video.i_height/p_data->i_fragment_size);
 234         p_sys->i_incr = vlc_tick_rate_duration( p_sys->f_fps );
 235         p_data->i_fragment = 0;
 236         p_data->p_block = 0;
 237     }
 238
 239
 240     /* Create the bitmap storage space */
 241     hbmp = CreateDIBSection( p_data->hdc_dst, &p_data->bmi, DIB_RGB_COLORS,
 242                              &p_buffer, NULL, 0 );
 243     if( !hbmp || !p_buffer )
 244     {
 245         msg_Err( p_demux, "cannot create bitmap" );
 246         goto error;
 247     }
 248
 249     /* Select the bitmap into the compatible DC */
 250     if( !p_data->hgdi_backup )
 251         p_data->hgdi_backup = SelectObject( p_data->hdc_dst, hbmp );
 252     else
 253         SelectObject( p_data->hdc_dst, hbmp );
 254
 255     if( !p_data->hgdi_backup )
 256     {
 257         msg_Err( p_demux, "cannot select bitmap" );
 258         goto error;
 259     }
 260
 261     /* Build block */
 262     if( !(p_block = malloc( sizeof( struct block_sys_t ) )) )
 263         goto error;
 264
 265     /* Fill all fields */
 266     int i_stride =
 267         ( ( ( ( p_sys->fmt.video.i_width * p_sys->fmt.video.i_bits_per_pixel ) + 31 ) & ~31 ) >> 3 );
 268     i_buffer = i_stride * p_sys->fmt.video.i_height;
 269     block_Init( &p_block->self, &CaptureBlockCallbacks, p_buffer, i_buffer );
 270     p_block->hbmp            = hbmp;
 271
 272     return &p_block->self;
 273
 274 error:
 275     if( hbmp ) DeleteObject( hbmp );
 276     return NULL;
 277 }
 278
 279 block_t *screen_Capture( demux_t *p_demux )
 280 {
 281     demux_sys_t *p_sys = p_demux->p_sys;
 282     screen_data_t *p_data = p_sys->p_data;
 283
 284     if( !p_data->i_fragment )
 285     {
 286         if( !( p_data->p_block = CaptureBlockNew( p_demux ) ) )
 287         {
 288             msg_Warn( p_demux, "cannot get block" );
 289             return NULL;
 290         }
 291     }
 292
 293     if( p_sys->b_follow_mouse )
 294     {
 295         POINT pos;
 296         GetCursorPos( &pos );
 297         FromScreenCoordinates( p_demux, &pos );
 298         FollowMouse( p_sys, pos.x, pos.y );
 299     }
 300
 301     POINT top_left = { p_sys->i_left, p_sys->i_top };
 302     ToScreenCoordinates( p_demux, &top_left );
 303
 304     if( !BitBlt( p_data->hdc_dst, 0,
 305                  p_data->i_fragment * p_data->i_fragment_size,
 306                  p_sys->fmt.video.i_width, p_data->i_fragment_size,
 307                  p_data->hdc_src, top_left.x, top_left.y +
 308                  p_data->i_fragment * p_data->i_fragment_size,
 309                  SRCCOPY | CAPTUREBLT ) )
 310     {
 311         msg_Err( p_demux, "error during BitBlt()" );
 312         return NULL;
 313     }
 314
 315     p_data->i_fragment++;
 316
 317     if( !( p_data->i_fragment %
 318            (p_sys->fmt.video.i_height/p_data->i_fragment_size) ) )
 319     {
 320         block_t *p_block = p_data->p_block;
 321         p_data->i_fragment = 0;
 322         p_data->p_block = 0;
 323
 324         if( p_sys->p_mouse )
 325         {
 326             POINT pos;
 327
 328             GetCursorPos( &pos );
 329             FromScreenCoordinates( p_demux, &pos );
 330             RenderCursor( p_demux, pos.x, pos.y,
 331                           p_block->p_buffer );
 332         }
 333
 334         return p_block;
 335     }
 336
 337     return NULL;
 338 }