05ba39223e53d5e8f50d03e223c27d880f3a05b2
[vlc.git] / modules / access / screen / win32.c
1 /*****************************************************************************
2  * win32.c: Screen capture module.
3  *****************************************************************************
4  * Copyright (C) 2004 the VideoLAN team
5  * $Id$
6  *
7  * Authors: Gildas Bazin <gbazin@videolan.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
34 #include "screen.h"
35
36 #ifndef CAPTUREBLT
37 #   define CAPTUREBLT (DWORD)0x40000000 /* Include layered windows */
38 #endif
39
40 struct screen_data_t
41 {
42     HDC hdc_src;
43     HDC hdc_dst;
44     BITMAPINFO bmi;
45     HGDIOBJ hgdi_backup;
46
47     int i_fragment_size;
48     int i_fragment;
49     block_t *p_block;
50 };
51
52 int screen_InitCapture( demux_t *p_demux )
53 {
54     demux_sys_t *p_sys = p_demux->p_sys;
55     screen_data_t *p_data;
56     int i_chroma, i_bits_per_pixel;
57
58     p_sys->p_data = p_data = malloc( sizeof( screen_data_t ) );
59     if( !p_data )
60         return VLC_ENOMEM;
61     memset( p_data, 0, sizeof( screen_data_t ) );
62
63     /* Get the device context for the whole screen */
64     p_data->hdc_src = CreateDC( "DISPLAY", NULL, NULL, NULL );
65     if( !p_data->hdc_src )
66     {
67         msg_Err( p_demux, "cannot get device context" );
68         return VLC_EGENERIC;
69     }
70
71     p_data->hdc_dst = CreateCompatibleDC( p_data->hdc_src );
72     if( !p_data->hdc_dst )
73     {
74         msg_Err( p_demux, "cannot get compat device context" );
75         ReleaseDC( 0, p_data->hdc_src );
76         return VLC_EGENERIC;
77     }
78
79     i_bits_per_pixel = GetDeviceCaps( p_data->hdc_src, BITSPIXEL );
80     switch( i_bits_per_pixel )
81     {
82     case 8: /* FIXME: set the palette */
83         i_chroma = VLC_FOURCC('R','G','B','2'); break;
84     case 15:
85     case 16:    /* Yes it is really 15 bits (when using BI_RGB) */
86         i_chroma = VLC_FOURCC('R','V','1','5'); break;
87     case 24:
88         i_chroma = VLC_FOURCC('R','V','2','4'); break;
89     case 32:
90         i_chroma = VLC_FOURCC('R','V','3','2'); break;
91     default:
92         msg_Err( p_demux, "unknown screen depth %i",
93                  p_sys->fmt.video.i_bits_per_pixel );
94         ReleaseDC( 0, p_data->hdc_src );
95         ReleaseDC( 0, p_data->hdc_dst );
96         return VLC_EGENERIC;
97     }
98
99     es_format_Init( &p_sys->fmt, VIDEO_ES, i_chroma );
100     p_sys->fmt.video.i_width  = GetDeviceCaps( p_data->hdc_src, HORZRES );
101     p_sys->fmt.video.i_height = GetDeviceCaps( p_data->hdc_src, VERTRES );
102     p_sys->fmt.video.i_bits_per_pixel = i_bits_per_pixel;
103
104     switch( i_chroma )
105     {
106     case VLC_FOURCC('R','V','1','5'):
107         p_sys->fmt.video.i_rmask = 0x7c00;
108         p_sys->fmt.video.i_gmask = 0x03e0;
109         p_sys->fmt.video.i_bmask = 0x001f;
110         break;
111     case VLC_FOURCC('R','V','2','4'):
112         p_sys->fmt.video.i_rmask = 0x00ff0000;
113         p_sys->fmt.video.i_gmask = 0x0000ff00;
114         p_sys->fmt.video.i_bmask = 0x000000ff;
115         break;
116     case VLC_FOURCC('R','V','3','2'):
117         p_sys->fmt.video.i_rmask = 0x00ff0000;
118         p_sys->fmt.video.i_gmask = 0x0000ff00;
119         p_sys->fmt.video.i_bmask = 0x000000ff;
120         break;
121     default:
122         msg_Warn( p_demux, "Unknown RGB masks" );
123         break;
124     }
125
126
127     return VLC_SUCCESS;
128 }
129
130 int screen_CloseCapture( demux_t *p_demux )
131 {
132     demux_sys_t *p_sys = p_demux->p_sys;
133     screen_data_t *p_data = p_sys->p_data;
134
135     if( p_data->p_block ) block_Release( p_data->p_block );
136
137     if( p_data->hgdi_backup)
138         SelectObject( p_data->hdc_dst, p_data->hgdi_backup );
139
140     DeleteDC( p_data->hdc_dst );
141     ReleaseDC( 0, p_data->hdc_src );
142     free( p_data );
143
144     return VLC_SUCCESS;
145 }
146
147 struct block_sys_t
148 {
149     block_t self;
150     HBITMAP hbmp;
151 };
152
153 static void CaptureBlockRelease( block_t *p_block )
154 {
155     DeleteObject( ((block_sys_t *)p_block)->hbmp );
156     free( p_block );
157 }
158
159 static block_t *CaptureBlockNew( demux_t *p_demux )
160 {
161     demux_sys_t *p_sys = p_demux->p_sys;
162     screen_data_t *p_data = p_sys->p_data;
163     block_sys_t *p_block;
164     void *p_buffer;
165     int i_buffer;
166     HBITMAP hbmp;
167
168     if( p_data->bmi.bmiHeader.biSize == 0 )
169     {
170         vlc_value_t val;
171         /* Create the bitmap info header */
172         p_data->bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
173         p_data->bmi.bmiHeader.biWidth = p_sys->fmt.video.i_width;
174         p_data->bmi.bmiHeader.biHeight = - p_sys->fmt.video.i_height;
175         p_data->bmi.bmiHeader.biPlanes = 1;
176         p_data->bmi.bmiHeader.biBitCount = p_sys->fmt.video.i_bits_per_pixel;
177         p_data->bmi.bmiHeader.biCompression = BI_RGB;
178         p_data->bmi.bmiHeader.biSizeImage = 0;
179         p_data->bmi.bmiHeader.biXPelsPerMeter =
180             p_data->bmi.bmiHeader.biYPelsPerMeter = 0;
181         p_data->bmi.bmiHeader.biClrUsed = 0;
182         p_data->bmi.bmiHeader.biClrImportant = 0;
183
184         var_Create( p_demux, "screen-fragment-size",
185                     VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
186         var_Get( p_demux, "screen-fragment-size", &val );
187         p_data->i_fragment_size =
188             val.i_int > 0 ? val.i_int : p_sys->fmt.video.i_height;
189         p_data->i_fragment_size =
190             val.i_int > p_sys->fmt.video.i_height ? p_sys->fmt.video.i_height :
191             p_data->i_fragment_size;
192         p_sys->f_fps *= (p_sys->fmt.video.i_height/p_data->i_fragment_size);
193         p_sys->i_incr = 1000000 / p_sys->f_fps;
194         p_data->i_fragment = 0;
195         p_data->p_block = 0;
196     }
197
198
199     /* Create the bitmap storage space */
200     hbmp = CreateDIBSection( p_data->hdc_dst, &p_data->bmi, DIB_RGB_COLORS,
201                              &p_buffer, NULL, 0 );
202     if( !hbmp || !p_buffer )
203     {
204         msg_Err( p_demux, "cannot create bitmap" );
205         if( hbmp ) DeleteObject( hbmp );
206         return NULL;
207     }
208
209     /* Select the bitmap into the compatible DC */
210     if( !p_data->hgdi_backup )
211         p_data->hgdi_backup = SelectObject( p_data->hdc_dst, hbmp );
212     else
213         SelectObject( p_data->hdc_dst, hbmp );
214
215     if( !p_data->hgdi_backup )
216     {
217         msg_Err( p_demux, "cannot select bitmap" );
218         DeleteObject( hbmp );
219         return NULL;
220     }
221
222     /* Build block */
223     if( !(p_block = malloc( sizeof( block_t ) + sizeof( block_sys_t ) )) )
224     {
225         DeleteObject( hbmp );
226         return NULL;
227     }
228     /* Fill all fields */
229     i_buffer = (p_sys->fmt.video.i_bits_per_pixel + 7) / 8 *
230         p_sys->fmt.video.i_width * p_sys->fmt.video.i_height;
231     block_Init( &p_block->self, p_buffer, i_buffer );
232     p_block->self.pf_release = CaptureBlockRelease;
233     p_block->hbmp            = hbmp;
234
235     return &p_block->self;
236 }
237
238 block_t *screen_Capture( demux_t *p_demux )
239 {
240     demux_sys_t *p_sys = p_demux->p_sys;
241     screen_data_t *p_data = p_sys->p_data;
242
243     if( !p_data->i_fragment )
244     {
245         if( !( p_data->p_block = CaptureBlockNew( p_demux ) ) )
246         {
247             msg_Warn( p_demux, "cannot get block" );
248             return 0;
249         }
250     }
251
252     if( p_sys->b_follow_mouse )
253     {
254         POINT pos;
255         GetCursorPos( &pos );
256         FollowMouse( p_sys, pos.x, pos.y );
257     }
258
259     if( !BitBlt( p_data->hdc_dst, 0,
260                  p_data->i_fragment * p_data->i_fragment_size,
261                  p_sys->fmt.video.i_width, p_data->i_fragment_size,
262                  p_data->hdc_src, p_sys->i_left, p_sys->i_top +
263                  p_data->i_fragment * p_data->i_fragment_size,
264                  IS_WINNT ? SRCCOPY | CAPTUREBLT : SRCCOPY ) )
265     {
266         msg_Err( p_demux, "error during BitBlt()" );
267         return NULL;
268     }
269
270     p_data->i_fragment++;
271
272     if( !( p_data->i_fragment %
273            (p_sys->fmt.video.i_height/p_data->i_fragment_size) ) )
274     {
275         block_t *p_block = p_data->p_block;
276         p_data->i_fragment = 0;
277         p_data->p_block = 0;
278         return p_block;
279     }
280
281     return NULL;
282 }