?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Refactor: rename "sub-filter" to "sub-source" this includes capability, functions...
[vlc/solaris.git] / modules / video_filter / remoteosd.c
blob29270ab4b35ef53af4d9d9893e1a06866848d8f2
1 /*****************************************************************************
2 * remoteosd.c: remote osd over vnc filter module
3 *****************************************************************************
4 * Copyright (C) 2007-2008 Matthias Bauer
5 * $Id$
6 *
7 * Authors: Matthias Bauer <matthias dot bauer #_at_# gmx dot ch>
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 implid 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 * RemoteOSD uses the RFB-Protocol of VNC to display an On-Screen-Display
26 * menu generated by a streaming server as overlay for the streamed video.
27 *
28 * The streaming server that implements this is the ffnetdev plugin for VDR.
29 * VDR (VideoDiskRecorder) is an Linux based OpenSource harddisk recorder
30 * software.
31 * The VDR ffnetdev plugin emulates the hardware MPEG decoder and streams the
32 * video over the network instead of hardware video outputs.
33 * The OSD menu of VDR is offered with the RFB protocol to a VNC client.
34 *
35 * In fact this video-filter is a simple VNC client that could be also used to
36 * connect to a real VNC host.
37 * Only 8-bit color is supported at the moment.
38 * Using password protected VNC hosts is supported but not recommended, because
39 * you need to insert the used password in the plugin configuration page of
40 * VLC configuration in plain text and it's saved in plain text.
41 *****************************************************************************/
42
43 //#define VNC_DEBUG
44
45 /*****************************************************************************
46 * Preamble
47 *****************************************************************************/
48
49 #ifdef HAVE_CONFIG_H
50 # include "config.h"
51 #endif
52
53 #include <vlc_common.h>
54 #include <vlc_plugin.h>
55 #include <vlc_vout.h>
56
57 #include <vlc_filter.h>
58 #include <vlc_image.h>
59 #include <vlc_keys.h>
60
61 #include <vlc_network.h>
62 #include <gcrypt.h> /* to encrypt password */
63 #include <vlc_gcrypt.h>
64
65 #include "remoteosd_rfbproto.h" /* type definitions of the RFB protocol for VNC */
66
67 /*****************************************************************************
68 * Module descriptor
69 *****************************************************************************/
70 #define READ_BUFFER_SIZE 1000000
71
72 #define RMTOSD_HOST_TEXT N_("VNC Host")
73 #define RMTOSD_HOST_LONGTEXT N_( \
74 "VNC hostname or IP address." )
75
76 #define RMTOSD_PORT_TEXT N_("VNC Port")
77 #define RMTOSD_PORT_LONGTEXT N_( \
78 "VNC port number." )
79
80 #define RMTOSD_PASSWORD_TEXT N_("VNC Password")
81 #define RMTOSD_PASSWORD_LONGTEXT N_( \
82 "VNC password." )
83
84 #define RMTOSD_UPDATE_TEXT N_("VNC poll interval" )
85 #define RMTOSD_UPDATE_LONGTEXT N_( \
86 "In this interval an update from VNC is requested, default every 300 ms. ")
87
88 #define RMTOSD_POLL_TEXT N_("VNC polling")
89 #define RMTOSD_POLL_LONGTEXT N_( \
90 "Activate VNC polling. Do NOT activate for use as VDR ffnetdev client." )
91
92 #define RMTOSD_MOUSE_TEXT N_("Mouse events")
93 #define RMTOSD_MOUSE_LONGTEXT N_( \
94 "Send mouse events to VNC host. Not needed for use as VDR ffnetdev client." )
95
96 #define RMTOSD_KEYS_TEXT N_("Key events")
97 #define RMTOSD_KEYS_LONGTEXT N_( \
98 "Send key events to VNC host." )
99
100 #define RMTOSD_ALPHA_TEXT N_("Alpha transparency value (default 255)")
101 #define RMTOSD_ALPHA_LONGTEXT N_( \
102 "The transparency of the OSD VNC can be changed by giving a value " \
103 "between 0 and 255. A lower value specifies more transparency a higher " \
104 "means less transparency. The default is being not transparent " \
105 "(value 255) the minimum is fully transparent (value 0)." )
106
107 #define RMTOSD_CFG "rmtosd-"
108
109 #define RMTOSD_UPDATE_MIN 200
110 #define RMTOSD_UPDATE_DEFAULT 1000
111 #define RMTOSD_UPDATE_MAX 300
112
113 static int CreateFilter ( vlc_object_t * );
114 static void DestroyFilter( vlc_object_t * );
115
116 vlc_module_begin ()
117 set_description( N_("Remote-OSD over VNC") )
118 set_capability( "sub source", 100 )
119 set_shortname( N_("Remote-OSD") )
120 set_category( CAT_VIDEO )
121 set_subcategory( SUBCAT_VIDEO_SUBPIC )
122 add_shortcut( "rmtosd" )
123 set_callbacks( CreateFilter, DestroyFilter )
124
125 add_string( RMTOSD_CFG "host", "myvdr", RMTOSD_HOST_TEXT,
126 RMTOSD_HOST_LONGTEXT, false )
127 add_integer_with_range( RMTOSD_CFG "port", 20001, 1, 0xFFFF, NULL,
128 RMTOSD_PORT_TEXT, RMTOSD_PORT_LONGTEXT, false )
129 add_password( RMTOSD_CFG "password", "", RMTOSD_PASSWORD_TEXT,
130 RMTOSD_PASSWORD_LONGTEXT, false )
131 add_integer_with_range( RMTOSD_CFG "update", RMTOSD_UPDATE_DEFAULT,
132 RMTOSD_UPDATE_MIN, RMTOSD_UPDATE_MAX, NULL, RMTOSD_UPDATE_TEXT,
133 RMTOSD_UPDATE_LONGTEXT, true )
134 add_bool( RMTOSD_CFG "vnc-polling", false,
135 RMTOSD_POLL_TEXT , RMTOSD_POLL_LONGTEXT, false )
136 add_bool( RMTOSD_CFG "mouse-events", false,
137 RMTOSD_MOUSE_TEXT , RMTOSD_MOUSE_LONGTEXT, false )
138 add_bool( RMTOSD_CFG "key-events", false,
139 RMTOSD_KEYS_TEXT , RMTOSD_KEYS_LONGTEXT, false )
140 add_integer_with_range( RMTOSD_CFG "alpha", 255, 0, 255, NULL,
141 RMTOSD_ALPHA_TEXT, RMTOSD_ALPHA_LONGTEXT, true )
142
143 vlc_module_end ()
144
145
146 /*****************************************************************************
147 * Local prototypes
148 *****************************************************************************/
149 #define CHALLENGESIZE 16
150 #define MAX_VNC_SERVER_NAME_LENGTH 255
151
152 /* subsource functions */
153 static subpicture_t *Filter( filter_t *, mtime_t );
154
155 static int MouseEvent( filter_t *,
156 const vlc_mouse_t *,
157 const vlc_mouse_t *,
158 const video_format_t * );
159
160 static int KeyEvent( vlc_object_t *p_this, char const *psz_var,
161 vlc_value_t oldval, vlc_value_t newval, void *p_data );
162
163 static void stop_osdvnc ( filter_t *p_filter );
164
165 static void* vnc_worker_thread ( vlc_object_t *p_thread_obj );
166
167 static void* update_request_thread( vlc_object_t *p_thread_obj );
168
169 static bool open_vnc_connection ( filter_t *p_filter );
170
171 static bool handshaking ( filter_t *p_filter );
172
173 static bool process_server_message ( filter_t *p_filter,
174 rfbServerToClientMsg *msg );
175
176 static inline void rgb_to_yuv( uint8_t *y, uint8_t *u, uint8_t *v,
177 int r, int g, int b );
178
179 static inline bool fill_rect( filter_sys_t* p_sys,
180 uint16_t i_x, uint16_t i_y,
181 uint16_t i_w, uint16_t i_h,
182 uint8_t i_color );
183 static inline bool copy_rect( filter_sys_t* p_sys,
184 uint16_t i_x, uint16_t i_y,
185 uint16_t i_w, uint16_t i_h,
186 uint16_t i_sx, uint16_t i_sy );
187
188
189 static inline bool raw_line( filter_sys_t* p_sys,
190 uint16_t i_x, uint16_t i_y,
191 uint16_t i_w );
192
193 static void vnc_encrypt_bytes( unsigned char *bytes, char *passwd );
194
195
196 /*****************************************************************************
197 * Sub source code
198 *****************************************************************************/
199
200 /*****************************************************************************
201 * Local prototypes
202 *****************************************************************************/
203 struct filter_sys_t
204 {
205 bool b_need_update; /* VNC picture is updated, do update the OSD*/
206 mtime_t i_vnc_poll_interval; /* Update the OSD menu every n ms */
207
208 uint8_t i_alpha; /* alpha transparency value */
209
210 char *psz_host; /* VNC host */
211 int i_port;
212
213 char *psz_passwd; /* VNC password */
214
215 bool b_vnc_poll; /* Activate VNC polling ? */
216 bool b_vnc_mouse_events; /* Send MouseEvents ? */
217 bool b_vnc_key_events; /* Send KeyEvents ? */
218
219 bool b_connection_active; /* Handshaking finished ? */
220
221 vlc_mutex_t lock; /* To lock for read/write on picture */
222
223 picture_t *p_pic; /* The picture with OSD data from VNC */
224
225 int i_socket; /* Socket used for VNC */
226
227 uint16_t i_vnc_width; /* The with of the VNC screen */
228 uint16_t i_vnc_height; /* The height of the VNC screen */
229 uint32_t i_vnc_pixels; /* The pixels of the VNC screen */
230
231 bool b_alpha_from_vnc; /* Special ffnetdev alpha feature enabled ? */
232
233 char read_buffer[READ_BUFFER_SIZE];
234
235 bool b_continue;
236
237 vlc_object_t* p_worker_thread;
238
239 uint8_t ar_color_table_yuv[256][4];
240 };
241
242 /*****************************************************************************
243 * CreateFilter: Create the filter and open the definition file
244 *****************************************************************************/
245 static int CreateFilter ( vlc_object_t *p_this )
246 {
247 filter_t *p_filter = (filter_t *)p_this;
248 filter_sys_t *p_sys = NULL;
249
250 msg_Dbg( p_filter, "Creating vnc osd filter..." );
251
252 p_filter->p_sys = p_sys = calloc( 1, sizeof(*p_sys) );
253 if( !p_filter->p_sys )
254 return VLC_ENOMEM;
255
256 /* Populating struct */
257 vlc_mutex_init( &p_sys->lock );
258 p_sys->b_continue = true;
259 p_sys->i_socket = -1;
260 p_sys->p_pic = NULL;
261
262 p_sys->psz_host = var_CreateGetString( p_this, RMTOSD_CFG "host" );
263 if( EMPTY_STR(p_sys->psz_host) )
264 {
265 msg_Err( p_filter, "unable to get vnc host" );
266 goto error;
267 }
268
269 p_sys->psz_passwd = var_CreateGetString( p_this, RMTOSD_CFG "password" );
270 if( !p_sys->psz_passwd )
271 {
272 msg_Err( p_filter, "unable to get vnc password" );
273 goto error;
274 }
275
276 p_sys->i_port = var_CreateGetIntegerCommand( p_this, RMTOSD_CFG "port" );
277
278 p_sys->i_alpha = var_CreateGetIntegerCommand( p_this, RMTOSD_CFG "alpha" );
279
280 /* in milliseconds, 0 disables polling, should not be lower than 100 */
281 p_sys->i_vnc_poll_interval = var_CreateGetIntegerCommand( p_this,
282 RMTOSD_CFG "update" );
283 if ( p_sys->i_vnc_poll_interval < 100)
284 {
285 p_sys->i_vnc_poll_interval = 100;
286 }
287
288 for ( int i = 0; i < 256; i++ )
289 {
290 p_sys->ar_color_table_yuv[i][0] = 255;
291 p_sys->ar_color_table_yuv[i][1] = 255;
292 p_sys->ar_color_table_yuv[i][2] = 255;
293 p_sys->ar_color_table_yuv[i][3] = 255;
294 }
295
296 p_sys->b_vnc_poll = var_CreateGetBoolCommand( p_this,
297 RMTOSD_CFG "vnc-polling" );
298 p_sys->b_vnc_mouse_events = var_CreateGetBoolCommand( p_this,
299 RMTOSD_CFG "mouse-events" );
300 p_sys->b_vnc_key_events = var_CreateGetBoolCommand( p_this,
301 RMTOSD_CFG "key-events" );
302
303 /* Keep track of OSD Events */
304 p_sys->b_need_update = false;
305
306 /* Attach subpicture source callback */
307 p_filter->pf_sub_source = Filter;
308 p_filter->pf_sub_mouse = MouseEvent;
309
310 var_AddCallback( p_filter->p_libvlc, "key-pressed", KeyEvent, p_this );
311
312 es_format_Init( &p_filter->fmt_out, SPU_ES, VLC_CODEC_SPU );
313 p_filter->fmt_out.i_priority = 0;
314
315 vlc_gcrypt_init();
316
317 /* create the vnc worker thread */
318 p_sys->p_worker_thread = vlc_object_create( p_this,
319 sizeof( vlc_object_t ) );
320 vlc_object_attach( p_sys->p_worker_thread, p_this );
321 if( vlc_thread_create( p_sys->p_worker_thread,
322 vnc_worker_thread, VLC_THREAD_PRIORITY_LOW ) )
323 {
324 vlc_object_release( p_sys->p_worker_thread );
325 msg_Err( p_filter, "cannot spawn vnc message reader thread" );
326 goto error;
327 }
328
329 msg_Dbg( p_filter, "osdvnc filter started" );
330
331 return VLC_SUCCESS;
332
333 error:
334 msg_Err( p_filter, "osdvnc filter discarded" );
335
336 stop_osdvnc( p_filter );
337
338 vlc_mutex_destroy( &p_sys->lock );
339 free( p_sys->psz_host );
340 free( p_sys->psz_passwd );
341 free( p_sys );
342
343 return VLC_EGENERIC;
344 }
345
346 /*****************************************************************************
347 * DestroyFilter: Make a clean exit of this plugin
348 *****************************************************************************/
349 static void DestroyFilter( vlc_object_t *p_this )
350 {
351 filter_t *p_filter = (filter_t*)p_this;
352 filter_sys_t *p_sys = p_filter->p_sys;
353
354 msg_Dbg( p_filter, "DestroyFilter called." );
355
356 stop_osdvnc( p_filter );
357
358 var_DelCallback( p_filter->p_libvlc, "key-pressed", KeyEvent, p_this );
359
360 var_Destroy( p_this, RMTOSD_CFG "host" );
361 var_Destroy( p_this, RMTOSD_CFG "port" );
362 var_Destroy( p_this, RMTOSD_CFG "password" );
363 var_Destroy( p_this, RMTOSD_CFG "update" );
364 var_Destroy( p_this, RMTOSD_CFG "vnc-polling" );
365 var_Destroy( p_this, RMTOSD_CFG "mouse-events" );
366 var_Destroy( p_this, RMTOSD_CFG "key-events" );
367 var_Destroy( p_this, RMTOSD_CFG "alpha" );
368
369 vlc_mutex_destroy( &p_sys->lock );
370 free( p_sys->psz_host );
371 free( p_sys->psz_passwd );
372 free( p_sys );
373 }
374
375 static void stop_osdvnc ( filter_t *p_filter )
376 {
377 filter_sys_t *p_sys = p_filter->p_sys;
378
379 /* It will unlock socket reading */
380 vlc_object_kill( p_filter );
381
382 /* */
383 if( p_sys->p_worker_thread )
384 {
385 msg_Dbg( p_filter, "joining worker_thread" );
386 vlc_object_kill( p_sys->p_worker_thread );
387 vlc_thread_join( p_sys->p_worker_thread );
388 vlc_object_release( p_sys->p_worker_thread );
389 msg_Dbg( p_filter, "released worker_thread" );
390 }
391
392 msg_Dbg( p_filter, "osdvnc stopped" );
393 }
394
395 static bool read_exact( filter_t *p_filter,
396 int i_socket,
397 char* p_readbuf,
398 int i_bytes )
399 {
400 return i_bytes == net_Read( p_filter, i_socket, NULL,
401 (unsigned char*)p_readbuf,
402 i_bytes, true );
403 }
404
405
406 static bool write_exact( filter_t *p_filter,
407 int i_socket,
408 char* p_writebuf,
409 int i_bytes )
410 {
411 return i_bytes == net_Write( p_filter, i_socket, NULL,
412 (unsigned char*)p_writebuf, i_bytes );
413 }
414
415 static bool open_vnc_connection ( filter_t *p_filter )
416 {
417 filter_sys_t *p_sys = p_filter->p_sys;
418
419 msg_Dbg( p_filter, "Open socket to vnc server on %s:%u.",
420 p_sys->psz_host, p_sys->i_port );
421
422 p_sys->i_socket = net_ConnectTCP( p_filter, p_sys->psz_host, p_sys->i_port );
423
424 if( p_sys->i_socket < 0 )
425 {
426 msg_Err( p_filter, "Could not open socket" );
427 return false;
428 }
429
430 msg_Dbg( p_filter, "socket is open." );
431
432 return true;
433 }
434
435 static bool handshaking ( filter_t *p_filter )
436 {
437 filter_sys_t *p_sys = p_filter->p_sys;
438
439 msg_Dbg( p_filter, "Reading protocol version" );
440
441 rfbProtocolVersionMsg pv;
442 if ( !read_exact( p_filter, p_sys->i_socket, pv,
443 sz_rfbProtocolVersionMsg ) )
444 {
445 msg_Err( p_filter, "Could not read version message" );
446 return false;
447 }
448 pv[sz_rfbProtocolVersionMsg] = '\0'; /* pv size is sz_rfbProtocolVersionMsg+1 */
449
450 msg_Dbg( p_filter, "Server version is %s", pv );
451
452 strncpy(pv, "RFB 003.003\n", sz_rfbProtocolVersionMsg);
453
454 if( !write_exact(p_filter, p_sys->i_socket, pv,
455 sz_rfbProtocolVersionMsg) )
456 {
457 msg_Err( p_filter, "Could not write version message" );
458 return false;
459 }
460
461 msg_Dbg( p_filter, "Reading authentication scheme" );
462 uint32_t i_authScheme;
463 if( !read_exact( p_filter, p_sys->i_socket, (char*)&i_authScheme, 4 ) )
464 {
465 msg_Err( p_filter, "Could not read authentication scheme" );
466 return false;
467 }
468 i_authScheme = htonl(i_authScheme);
469
470 msg_Dbg( p_filter, "Authentication scheme = %x", i_authScheme );
471 if ( i_authScheme == rfbConnFailed )
472 {
473 msg_Err( p_filter, "Connection rejected by server" );
474 return false;
475 }
476 if (i_authScheme == rfbVncAuth)
477 {
478 unsigned char challenge[CHALLENGESIZE];
479 if ( !read_exact( p_filter, p_sys->i_socket,
480 (char*)challenge, CHALLENGESIZE ) )
481 {
482 msg_Err( p_filter, "Could not read password challenge" );
483 return false;
484 }
485
486 vnc_encrypt_bytes( challenge, p_sys->psz_passwd );
487
488 if( !write_exact(p_filter, p_sys->i_socket,
489 (char*)challenge, CHALLENGESIZE ) )
490 {
491 msg_Err( p_filter, "Could not write password" );
492 return false;
493 }
494 uint32_t i_authResult;
495 if( !read_exact( p_filter, p_sys->i_socket, (char*)&i_authResult, 4 ) )
496 {
497 msg_Err( p_filter, "Could not read authentication result" );
498 return false;
499 }
500 i_authResult = htonl(i_authResult);
501 if (i_authResult != rfbVncAuthOK)
502 {
503 msg_Err( p_filter, "VNC authentication failed" );
504 return false;
505 }
506 }
507
508 msg_Dbg( p_filter, "Writing client init message" );
509 rfbClientInitMsg ci;
510 ci.shared = 1;
511 if( !write_exact( p_filter, p_sys->i_socket,
512 (char*)&ci, sz_rfbClientInitMsg ) )
513 {
514 msg_Err( p_filter, "Could not write client init message" );
515 return false;
516 }
517
518 msg_Dbg( p_filter, "Reading server init message" );
519 rfbServerInitMsg si;
520 if( !read_exact( p_filter, p_sys->i_socket,
521 (char*)&si, sz_rfbServerInitMsg ) )
522 {
523 msg_Err( p_filter, "Could not read server init message" );
524 return false;
525 }
526 si.framebufferWidth = htons(si.framebufferWidth);
527 si.framebufferHeight = htons(si.framebufferHeight);
528 si.format.redMax = htons(si.format.redMax);
529 si.format.greenMax = htons(si.format.greenMax);
530 si.format.blueMax = htons(si.format.blueMax);
531
532 p_sys->i_vnc_width = si.framebufferWidth;
533 p_sys->i_vnc_height = si.framebufferHeight;
534
535 msg_Dbg( p_filter, "Servers preferred pixelformat: "
536 "%ux%u, R(%u),G(%u),B(%u), %u bit, depht=%u, %s",
537 si.framebufferWidth,
538 si.framebufferHeight,
539 si.format.redMax,
540 si.format.greenMax,
541 si.format.blueMax,
542 si.format.bitsPerPixel,
543 si.format.depth,
544 si.format.trueColour ? "TrueColor" : "Not-TrueColor");
545
546 uint32_t i_nameLength = htonl(si.nameLength);
547 if( i_nameLength > MAX_VNC_SERVER_NAME_LENGTH )
548 {
549 msg_Err( p_filter, "Server name too long" );
550 return false;
551 }
552 char s_ServerName[MAX_VNC_SERVER_NAME_LENGTH+1];
553
554 msg_Dbg( p_filter, "Reading server name with size = %u", i_nameLength );
555 if( !read_exact( p_filter, p_sys->i_socket, s_ServerName, i_nameLength ) )
556 {
557 msg_Err( p_filter, "Could not read server name" );
558 return false;
559 }
560 s_ServerName[i_nameLength] = '\0';
561
562 if( strcmp( s_ServerName, "VDR-OSD") == 0 )
563 {
564 msg_Dbg( p_filter, "Server is a VDR" );
565 p_sys->b_alpha_from_vnc = true;
566 }
567 else
568 {
569 msg_Dbg( p_filter, "Server is a normal VNC" );
570 p_sys->b_alpha_from_vnc = false;
571 }
572
573
574 msg_Dbg( p_filter, "Server init message read properly" );
575 msg_Dbg( p_filter, "Server name is %s", s_ServerName );
576
577 msg_Dbg( p_filter, "Writing SetPixelFormat message" );
578
579 rfbSetPixelFormatMsg sp;
580 sp.type = rfbSetPixelFormat;
581 sp.pad1 = sp.pad2 = 0;
582 sp.format.bitsPerPixel = 8;
583 sp.format.depth = 8 ;
584 sp.format.bigEndian = 1;
585 sp.format.trueColour = 0;
586 sp.format.redMax = htons(31);
587 sp.format.greenMax = htons(31);
588 sp.format.blueMax = htons(31);
589 sp.format.redShift = 10;
590 sp.format.greenShift = 5;
591 sp.format.blueShift = 0;
592 sp.format.pad1 = sp.format.pad2 = 0;
593
594 if( !write_exact( p_filter, p_sys->i_socket,
595 (char*)&sp, sz_rfbSetPixelFormatMsg) )
596 {
597 msg_Err( p_filter, "Could not write SetPixelFormat message" );
598 return false;
599 }
600
601 msg_Dbg( p_filter, "Writing SetEncodings message" );
602
603 rfbSetEncodingsMsg se;
604 se.type = rfbSetEncodings;
605 se.pad = 0;
606 se.nEncodings = htons( p_sys->b_alpha_from_vnc ? 3 : 2 );
607
608 if( !write_exact( p_filter, p_sys->i_socket,
609 (char*)&se, sz_rfbSetEncodingsMsg) )
610 {
611 msg_Err( p_filter, "Could not write SetEncodings message begin" );
612 return false;
613 }
614
615 uint32_t i_encoding;
616
617 msg_Dbg( p_filter, "Writing SetEncodings rfbEncodingCopyRect" );
618 i_encoding = htonl(rfbEncodingCopyRect);
619 if( !write_exact( p_filter, p_sys->i_socket, (char*)&i_encoding, 4) )
620 {
621 msg_Err( p_filter, "Could not write encoding type rfbEncodingCopyRect." );
622 return false;
623 }
624
625 msg_Dbg( p_filter, "Writing SetEncodings rfbEncodingRRE" );
626 i_encoding = htonl(rfbEncodingRRE);
627 if( !write_exact(p_filter, p_sys->i_socket, (char*)&i_encoding, 4) )
628 {
629 msg_Err( p_filter, "Could not write encoding type rfbEncodingRRE." );
630 return false;
631 }
632
633 if( p_sys->b_alpha_from_vnc )
634 {
635 msg_Dbg( p_filter, "Writing SetEncodings rfbEncSpecialUseAlpha" );
636 i_encoding = 0x00F0FFFF; /* rfbEncSpecialUseAlpha is 0xFFFFF000
637 * before we swap it */
638 if( !write_exact(p_filter, p_sys->i_socket, (char*)&i_encoding, 4) )
639 {
640 msg_Err( p_filter, "Could not write encoding type rfbEncSpecialUseAlpha." );
641 return false;
642 }
643 }
644 return true;
645
646 }
647
648 static void* vnc_worker_thread( vlc_object_t *p_thread_obj )
649 {
650 filter_t* p_filter = (filter_t*)(p_thread_obj->p_parent);
651 filter_sys_t *p_sys = p_filter->p_sys;
652 vlc_object_t *p_update_request_thread;
653 int canc = vlc_savecancel ();
654
655 msg_Dbg( p_filter, "VNC worker thread started" );
656
657 if( !open_vnc_connection ( p_filter ) )
658 {
659 msg_Err( p_filter, "Could not connect to vnc host" );
660 goto exit;
661 }
662
663 if( !handshaking ( p_filter ) )
664 {
665 msg_Err( p_filter, "Error occured while handshaking vnc host" );
666 goto exit;
667 }
668
669 p_sys->b_connection_active = true; /* to enable sending key
670 * and mouse events to host */
671
672 /* Create an empty picture for VNC the data */
673 vlc_mutex_lock( &p_sys->lock );
674 p_sys->p_pic = picture_New( VLC_CODEC_YUVA,
675 p_sys->i_vnc_width, p_sys->i_vnc_height, 1, 1 );
676 if( !p_sys->p_pic )
677 {
678 vlc_mutex_unlock( &p_sys->lock );
679 goto exit;
680 }
681 p_sys->i_vnc_pixels = p_sys->i_vnc_width * p_sys->i_vnc_height;
682
683 vlc_mutex_unlock( &p_sys->lock );
684
685 /* create the update request thread */
686 p_update_request_thread = vlc_object_create( p_filter,
687 sizeof( vlc_object_t ) );
688 vlc_object_attach( p_update_request_thread, p_filter );
689 if( vlc_thread_create( p_update_request_thread,
690 update_request_thread, VLC_THREAD_PRIORITY_LOW ) )
691 {
692 vlc_object_release( p_update_request_thread );
693 msg_Err( p_filter, "cannot spawn vnc update request thread" );
694 goto exit;
695 }
696
697 /* connection is initialized, now read and handle server messages */
698 while( vlc_object_alive( p_thread_obj ) )
699 {
700 rfbServerToClientMsg msg;
701 int i_msgSize;
702
703 memset( &msg, 0, sizeof(msg) );
704
705 if( !read_exact(p_filter, p_sys->i_socket, (char*)&msg, 1 ) )
706 {
707 msg_Err( p_filter, "Error while waiting for next server message");
708 break;
709 }
710 switch (msg.type)
711 {
712 case rfbFramebufferUpdate:
713 i_msgSize = sz_rfbFramebufferUpdateMsg;
714 break;
715 case rfbSetColourMapEntries:
716 i_msgSize = sz_rfbSetColourMapEntriesMsg;
717 break;
718 case rfbBell:
719 i_msgSize = sz_rfbBellMsg;
720 break;
721 case rfbServerCutText:
722 i_msgSize = sz_rfbServerCutTextMsg;
723 break;
724 case rfbReSizeFrameBuffer:
725 i_msgSize = sz_rfbReSizeFrameBufferMsg;
726 break;
727 default:
728 i_msgSize = 0;
729 msg_Err( p_filter, "Invalid message %u received", msg.type );
730 break;
731 }
732
733 if( i_msgSize <= 0 )
734 break;
735
736 if( --i_msgSize > 0 )
737 {
738 if ( !read_exact( p_filter, p_sys->i_socket,
739 ((char*)&msg)+1, i_msgSize ) )
740 {
741 msg_Err( p_filter, "Error while reading message of type %u",
742 msg.type );
743 break;
744 }
745 }
746 process_server_message( p_filter, &msg);
747 }
748
749 msg_Dbg( p_filter, "joining update_request_thread" );
750 vlc_object_kill( p_update_request_thread );
751 vlc_thread_join( p_update_request_thread );
752 vlc_object_release( p_update_request_thread );
753 msg_Dbg( p_filter, "released update_request_thread" );
754
755 exit:
756
757 vlc_mutex_lock( &p_sys->lock );
758 p_sys->b_connection_active = false;
759
760 if (p_sys->i_socket >= 0)
761 net_Close(p_sys->i_socket);
762
763 if( p_sys->p_pic )
764 picture_Release( p_sys->p_pic );
765
766 /* It will hide the subtitle */
767 p_sys->b_continue = false;
768 p_sys->b_need_update = true;
769 vlc_mutex_unlock( &p_sys->lock );
770
771 msg_Dbg( p_filter, "VNC message reader thread ended" );
772 vlc_restorecancel (canc);
773 return NULL;
774 }
775
776 static void* update_request_thread( vlc_object_t *p_thread_obj )
777 {
778 filter_t* p_filter = (filter_t*)(p_thread_obj->p_parent);
779 filter_sys_t *p_sys = p_filter->p_sys;
780 int canc = vlc_savecancel ();
781
782 msg_Dbg( p_filter, "VNC update request thread started" );
783
784 rfbFramebufferUpdateRequestMsg udr;
785 udr.type = rfbFramebufferUpdateRequest;
786 udr.incremental = 0;
787 udr.x = 0;
788 udr.y = 0;
789 udr.w = htons(p_sys->i_vnc_width);
790 udr.h = htons(p_sys->i_vnc_height);
791
792 if( !write_exact(p_filter, p_sys->i_socket, (char*)&udr,
793 sz_rfbFramebufferUpdateRequestMsg) )
794 {
795 msg_Err( p_filter, "Could not write rfbFramebufferUpdateRequestMsg." );
796 p_sys->b_continue = false;
797 return NULL;
798 }
799
800 udr.incremental = 1;
801 mtime_t i_poll_interval_microsec = p_sys->i_vnc_poll_interval * 1000;
802
803 if( p_sys->b_vnc_poll)
804 {
805 while( vlc_object_alive( p_thread_obj ) )
806 {
807 msleep( i_poll_interval_microsec );
808 if( !write_exact(p_filter, p_sys->i_socket, (char*)&udr,
809 sz_rfbFramebufferUpdateRequestMsg))
810 {
811 msg_Err( p_filter, "Could not write rfbFramebufferUpdateRequestMsg." );
812 break;
813 }
814 }
815 p_sys->b_continue = false;
816 }
817 else
818 {
819 msg_Dbg( p_filter, "VNC polling disabled." );
820 }
821
822 msg_Dbg( p_filter, "VNC update request thread ended" );
823 vlc_restorecancel (canc);
824 return NULL;
825 }
826
827 static bool process_server_message ( filter_t *p_filter,
828 rfbServerToClientMsg *msg )
829 {
830 filter_sys_t *p_sys = p_filter->p_sys;
831
832 switch (msg->type)
833 {
834 case rfbFramebufferUpdate:
835 {
836 msg->fu.nRects = htons(msg->fu.nRects);
837 rfbFramebufferUpdateRectHeader hdr;
838
839 for (int i_rect = 0; i_rect < msg->fu.nRects; i_rect++)
840 {
841 if (!read_exact(p_filter, p_sys->i_socket, (char*)&hdr,
842 sz_rfbFramebufferUpdateRectHeader ) )
843 {
844 msg_Err( p_filter, "Could not read FrameBufferUpdate header" );
845 return false;
846 }
847 hdr.r.x = htons(hdr.r.x);
848 hdr.r.y = htons(hdr.r.y);
849 hdr.r.w = htons(hdr.r.w);
850 hdr.r.h = htons(hdr.r.h);
851 hdr.encoding = htonl(hdr.encoding);
852
853 switch (hdr.encoding)
854 {
855 case rfbEncodingRaw:
856 {
857 int i_line;
858 for (i_line = 0; i_line < hdr.r.h; i_line++)
859 {
860 if ( !read_exact( p_filter, p_sys->i_socket,
861 p_sys->read_buffer, hdr.r.w ) )
862 {
863 msg_Err( p_filter,
864 "Could not read FrameBufferUpdate line data" );
865 return false;
866 }
867 vlc_mutex_lock( &p_sys->lock );
868 if ( !raw_line( p_sys, hdr.r.x,
869 hdr.r.y + i_line,
870 hdr.r.w ) )
871 {
872 msg_Err( p_filter, "raw_line failed." );
873 vlc_mutex_unlock( &p_sys->lock );
874 return false;
875 }
876 vlc_mutex_unlock( &p_sys->lock );
877 }
878 }
879 break;
880
881 case rfbEncodingCopyRect:
882 {
883 rfbCopyRect rect;
884
885 if ( !read_exact( p_filter, p_sys->i_socket,
886 (char*)&rect,
887 sz_rfbCopyRect ) )
888 {
889 msg_Err( p_filter, "Could not read rfbCopyRect" );
890 return false;
891 }
892 rect.srcX = htons( rect.srcX );
893 rect.srcY = htons( rect.srcY );
894
895 vlc_mutex_lock( &p_sys->lock );
896 if ( !copy_rect( p_sys,
897 hdr.r.x, hdr.r.y,
898 hdr.r.w, hdr.r.h,
899 rect.srcX, rect.srcY ) )
900 {
901 msg_Err( p_filter, "copy_rect failed." );
902 vlc_mutex_unlock( &p_sys->lock );
903 return false;
904 }
905 vlc_mutex_unlock( &p_sys->lock );
906 }
907 break;
908
909 case rfbEncodingRRE:
910 {
911 rfbRREHeader rrehdr;
912 if ( !read_exact( p_filter, p_sys->i_socket,
913 (char*)&rrehdr,
914 sz_rfbRREHeader ) )
915 {
916 msg_Err( p_filter, "Could not read rfbRREHeader" );
917 return false;
918 }
919 uint8_t i_pixcolor;
920 if ( !read_exact(p_filter, p_sys->i_socket,
921 (char*)&i_pixcolor, 1 ) )
922 {
923 msg_Err( p_filter, "Could not read RRE pixcolor" );
924 return false;
925 }
926
927 vlc_mutex_lock( &p_sys->lock );
928 if ( !fill_rect( p_sys,
929 hdr.r.x, hdr.r.y,
930 hdr.r.w, hdr.r.h,
931 i_pixcolor) )
932 {
933 msg_Err( p_filter, "main fill_rect failed." );
934 vlc_mutex_unlock( &p_sys->lock );
935 return false;
936 }
937 vlc_mutex_unlock( &p_sys->lock );
938
939 rrehdr.nSubrects = htonl(rrehdr.nSubrects);
940
941 int i_datasize = rrehdr.nSubrects *
942 ( sizeof(i_pixcolor) + sz_rfbRectangle ) ;
943 if ( i_datasize > READ_BUFFER_SIZE )
944 {
945 msg_Err( p_filter, "Buffer too small, "
946 "need %u bytes", i_datasize );
947 return false;
948 }
949 if ( !read_exact( p_filter, p_sys->i_socket,
950 p_sys->read_buffer, i_datasize ) )
951 {
952 msg_Err( p_filter,
953 "Could not read RRE subrect data" );
954 return false;
955 }
956
957 uint32_t i_subrect;
958 rfbRectangle* p_subrect;
959 int i_offset = 0;
960 vlc_mutex_lock( &p_sys->lock );
961 for ( i_subrect = 0;
962 i_subrect < rrehdr.nSubrects; i_subrect++)
963 {
964 i_pixcolor = p_sys->read_buffer[i_offset];
965 i_offset += sizeof(i_pixcolor);
966 p_subrect =
967 (rfbRectangle*)(p_sys->read_buffer + i_offset);
968 i_offset += sz_rfbRectangle;
969
970 if (!fill_rect( p_sys,
971 htons(p_subrect->x) + hdr.r.x,
972 htons(p_subrect->y) + hdr.r.y,
973 htons(p_subrect->w),
974 htons(p_subrect->h),
975 i_pixcolor) )
976 {
977 msg_Err( p_filter,
978 "subrect %u fill_rect failed.", i_subrect );
979 vlc_mutex_unlock( &p_sys->lock );
980 return false;
981 }
982 }
983 vlc_mutex_unlock( &p_sys->lock );
984 }
985 break;
986
987 }
988
989 }
990 vlc_mutex_lock( &p_sys->lock );
991 p_sys->b_need_update = true;
992 vlc_mutex_unlock( &p_sys->lock );
993 }
994 return true;
995
996 case rfbSetColourMapEntries:
997 {
998 msg->scme.nColours = htons(msg->scme.nColours);
999 msg->scme.firstColour = htons(msg->scme.firstColour);
1000 int i_datasize;
1001 if ( p_sys->b_alpha_from_vnc )
1002 {
1003 i_datasize = 2 * msg->scme.nColours * 4;
1004 }
1005 else
1006 {
1007 i_datasize = 2 * msg->scme.nColours * 3;
1008 }
1009 if ( i_datasize > READ_BUFFER_SIZE )
1010 {
1011 msg_Err( p_filter, "Buffer too small, need %u bytes",
1012 i_datasize );
1013 return false;
1014 }
1015
1016 if ( !read_exact( p_filter, p_sys->i_socket,
1017 p_sys->read_buffer, i_datasize ) )
1018 {
1019 msg_Err( p_filter, "Could not read color map data" );
1020 return false;
1021 }
1022
1023 uint8_t i_red, i_green, i_blue, i_alpha, i_color_index;
1024 uint16_t i_offset = 0;
1025 i_alpha = 255;
1026
1027 for (int i = 0; i < msg->scme.nColours; i++)
1028 {
1029 i_color_index = i+msg->scme.firstColour;
1030 if ( p_sys->b_alpha_from_vnc )
1031 {
1032 i_alpha = p_sys->read_buffer[i_offset];
1033 i_offset += 2;
1034 }
1035 i_red = p_sys->read_buffer[i_offset];
1036 i_offset += 2;
1037 i_green = p_sys->read_buffer[i_offset];
1038 i_offset += 2;
1039 i_blue = p_sys->read_buffer[i_offset];
1040 i_offset += 2;
1041 rgb_to_yuv( &p_sys->ar_color_table_yuv[i_color_index][0],
1042 &p_sys->ar_color_table_yuv[i_color_index][1],
1043 &p_sys->ar_color_table_yuv[i_color_index][2],
1044 i_red,
1045 i_green,
1046 i_blue );
1047 p_sys->ar_color_table_yuv[i][3] = i_alpha;
1048 }
1049 }
1050 return true;
1051
1052 case rfbBell:
1053 msg_Err( p_filter, "rfbBell received" );
1054 return true;
1055
1056 case rfbServerCutText:
1057 msg->sct.length = htons(msg->sct.length);
1058 if ( msg->sct.length > READ_BUFFER_SIZE )
1059 {
1060 msg_Err( p_filter, "Buffer too small, need %u bytes", msg->sct.length );
1061 return false;
1062 }
1063 if ( !read_exact(p_filter, p_sys->i_socket,
1064 p_sys->read_buffer, msg->sct.length ) )
1065 {
1066 msg_Err( p_filter, "Could not read Reading rfbServerCutText data" );
1067 return false;
1068 }
1069 return true;
1070
1071 case rfbReSizeFrameBuffer:
1072 msg_Err( p_filter, "Reading rfbReSizeFrameBuffer not implemented" );
1073 return false;
1074
1075 default:
1076 msg_Err( p_filter, "Invalid message %u received", msg->type );
1077 return false;
1078 }
1079 return false;
1080 }
1081
1082 /****************************************************************************
1083 * Filter: the whole thing
1084 ****************************************************************************
1085 * This function outputs subpictures at regular time intervals.
1086 ****************************************************************************/
1087 static subpicture_t *Filter( filter_t *p_filter, mtime_t date )
1088 {
1089 filter_sys_t *p_sys = p_filter->p_sys;
1090 subpicture_t *p_spu;
1091 subpicture_region_t *p_region;
1092 video_format_t fmt;
1093 picture_t *p_pic;
1094
1095 if( !p_sys->b_need_update )
1096 {
1097 return NULL;
1098 }
1099
1100 vlc_mutex_lock( &p_sys->lock );
1101
1102 p_pic = p_sys->p_pic;
1103
1104 if( !p_pic )
1105 {
1106 vlc_mutex_unlock( &p_sys->lock );
1107 return NULL;
1108 }
1109
1110 /* Allocate the subpicture internal data. */
1111 p_spu = filter_NewSubpicture( p_filter );
1112 if( !p_spu )
1113 {
1114 vlc_mutex_unlock( &p_sys->lock );
1115 return NULL;
1116 }
1117
1118 p_spu->b_absolute = false;
1119 p_spu->i_start = date;
1120 p_spu->i_stop = 0;
1121 p_spu->b_ephemer = true;
1122
1123 if( !p_sys->b_continue )
1124 p_spu->i_stop = p_spu->i_start + 1;
1125
1126 /* Create new SPU region */
1127 memset( &fmt, 0, sizeof(video_format_t) );
1128 fmt.i_chroma = VLC_CODEC_YUVA;
1129 fmt.i_sar_num = fmt.i_sar_den = 1;
1130 fmt.i_width = fmt.i_visible_width = p_pic->p[Y_PLANE].i_visible_pitch;
1131 fmt.i_height = fmt.i_visible_height = p_pic->p[Y_PLANE].i_visible_lines;
1132 fmt.i_x_offset = fmt.i_y_offset = 0;
1133 p_region = subpicture_region_New( &fmt );
1134 if( !p_region )
1135 {
1136 msg_Err( p_filter, "cannot allocate SPU region" );
1137 p_filter->pf_sub_buffer_del( p_filter, p_spu );
1138 vlc_mutex_unlock( &p_sys->lock );
1139 return NULL;
1140 }
1141
1142 /* FIXME the copy is probably not needed anymore */
1143 picture_Copy( p_region->p_picture, p_pic );
1144
1145 p_sys->b_need_update = false;
1146
1147 vlc_mutex_unlock( &p_sys->lock );
1148
1149 /* set to one of the 9 relative locations */
1150 p_region->i_align = 0; /* Center */
1151 p_spu->b_absolute = false;
1152
1153
1154 p_spu->i_original_picture_width = 0; /*Let vout core do the horizontal scaling */
1155 p_spu->i_original_picture_height = fmt.i_height;
1156
1157 p_spu->p_region = p_region;
1158
1159 p_spu->i_alpha = ( p_sys->i_alpha );
1160
1161 return p_spu;
1162 }
1163
1164
1165 static inline void rgb_to_yuv( uint8_t *y, uint8_t *u, uint8_t *v,
1166 int r, int g, int b )
1167 {
1168 *y = ( ( ( 66 * r + 129 * g + 25 * b + 128 ) >> 8 ) + 16 );
1169 *u = ( ( -38 * r - 74 * g + 112 * b + 128 ) >> 8 ) + 128 ;
1170 *v = ( ( 112 * r - 94 * g - 18 * b + 128 ) >> 8 ) + 128 ;
1171 }
1172
1173 static inline bool fill_rect( filter_sys_t* p_sys,
1174 uint16_t i_x, uint16_t i_y,
1175 uint16_t i_w, uint16_t i_h,
1176 uint8_t i_color)
1177 {
1178 plane_t *p_outY = p_sys->p_pic->p+Y_PLANE;
1179 plane_t *p_outU = p_sys->p_pic->p+U_PLANE;
1180 plane_t *p_outV = p_sys->p_pic->p+V_PLANE;
1181 plane_t *p_outA = p_sys->p_pic->p+A_PLANE;
1182 int i_pitch = p_outY->i_pitch;
1183 int i_lines = p_outY->i_lines;
1184 if ( i_x + i_w > i_pitch)
1185 return false;
1186 if ( i_y + i_h > i_lines)
1187 return false;
1188 int i_line_offset = i_y * i_pitch;
1189 uint8_t i_yuv_y = p_sys->ar_color_table_yuv[i_color][0];
1190 uint8_t i_yuv_u = p_sys->ar_color_table_yuv[i_color][1];
1191 uint8_t i_yuv_v = p_sys->ar_color_table_yuv[i_color][2];
1192 uint8_t i_alpha = p_sys->ar_color_table_yuv[i_color][3];
1193 for( int i_line = 0; i_line < i_h; i_line++ )
1194 {
1195 for( int i_column = 0; i_column < i_w; i_column++ )
1196 {
1197 int i_total_offset = i_line_offset + i_x + i_column;
1198 p_outY->p_pixels[ i_total_offset ] = i_yuv_y;
1199 p_outU->p_pixels[ i_total_offset ] = i_yuv_u;
1200 p_outV->p_pixels[ i_total_offset ] = i_yuv_v;
1201 p_outA->p_pixels[ i_total_offset ] = i_alpha;
1202 }
1203 i_line_offset += i_pitch;
1204 }
1205 return true;
1206 }
1207
1208 static inline bool copy_rect( filter_sys_t* p_sys,
1209 uint16_t i_x, uint16_t i_y,
1210 uint16_t i_w, uint16_t i_h,
1211 uint16_t i_sx, uint16_t i_sy )
1212 {
1213 plane_t *p_Y = p_sys->p_pic->p+Y_PLANE;
1214 plane_t *p_U = p_sys->p_pic->p+U_PLANE;
1215 plane_t *p_V = p_sys->p_pic->p+V_PLANE;
1216 plane_t *p_A = p_sys->p_pic->p+A_PLANE;
1217
1218 int i_pitch = p_Y->i_pitch;
1219 int i_lines = p_Y->i_lines;
1220
1221 fprintf( stderr, "copy_rect: (%d,%d)+(%d,%d) -> (%d,%d)\n", i_x, i_y, i_w, i_h, i_sx, i_sy );
1222
1223 if( i_x + i_w > i_pitch || i_sx + i_w > i_pitch )
1224 return false;
1225 if( i_y + i_h > i_lines || i_sy + i_h > i_lines)
1226 return false;
1227
1228 if( i_w <= 0 || i_h <= 0 )
1229 return true;
1230
1231 uint8_t *pb_buffer = calloc( i_w * i_h, 4 );
1232 if( !pb_buffer )
1233 return false;
1234
1235 for( int i_line = 0; i_line < i_h; i_line++ )
1236 {
1237 for( int i_column = 0; i_column < i_w; i_column++ )
1238 {
1239 const int i_src_offset = ( i_sy + i_line ) * i_pitch + i_sx + i_column;
1240 const int i_tmp_offset = ( 0 + i_line ) * i_w + 0 + i_column;
1241
1242 pb_buffer[4*i_tmp_offset + 0] = p_Y->p_pixels[i_src_offset];
1243 pb_buffer[4*i_tmp_offset + 1] = p_U->p_pixels[i_src_offset];
1244 pb_buffer[4*i_tmp_offset + 2] = p_V->p_pixels[i_src_offset];
1245 pb_buffer[4*i_tmp_offset + 3] = p_A->p_pixels[i_src_offset];
1246 }
1247 }
1248
1249 for( int i_line = 0; i_line < i_h; i_line++ )
1250 {
1251 for( int i_column = 0; i_column < i_w; i_column++ )
1252 {
1253 const int i_tmp_offset = ( 0 + i_line ) * i_w + 0 + i_column;
1254 const int i_dst_offset = ( i_y + i_line ) * i_pitch + i_x + i_column;
1255
1256 p_Y->p_pixels[i_dst_offset] = pb_buffer[4*i_tmp_offset + 0];
1257 p_U->p_pixels[i_dst_offset] = pb_buffer[4*i_tmp_offset + 1];
1258 p_V->p_pixels[i_dst_offset] = pb_buffer[4*i_tmp_offset + 2];
1259 p_A->p_pixels[i_dst_offset] = pb_buffer[4*i_tmp_offset + 3];
1260 }
1261 }
1262 free( pb_buffer );
1263 return true;
1264
1265 }
1266
1267 static inline bool raw_line( filter_sys_t* p_sys,
1268 uint16_t i_x, uint16_t i_y,
1269 uint16_t i_w )
1270 {
1271 plane_t *p_outY = p_sys->p_pic->p+Y_PLANE;
1272 plane_t *p_outU = p_sys->p_pic->p+U_PLANE;
1273 plane_t *p_outV = p_sys->p_pic->p+V_PLANE;
1274 plane_t *p_outA = p_sys->p_pic->p+A_PLANE;
1275 int i_pitch = p_outY->i_pitch;
1276 int i_lines = p_outY->i_lines;
1277 if ( i_x + i_w > i_pitch)
1278 return false;
1279 if ( i_y > i_lines)
1280 return false;
1281
1282 int i_line_offset = i_y * i_pitch + i_x;
1283
1284 for( int i_column = 0; i_column < i_w; i_column++ )
1285 {
1286 int i_offset = i_line_offset + i_column;
1287 uint8_t i_color = p_sys->read_buffer[i_column];
1288 p_outY->p_pixels[ i_offset ] = p_sys->ar_color_table_yuv[i_color][0];
1289 p_outU->p_pixels[ i_offset ] = p_sys->ar_color_table_yuv[i_color][1];
1290 p_outV->p_pixels[ i_offset ] = p_sys->ar_color_table_yuv[i_color][2];
1291 p_outA->p_pixels[ i_offset ] = p_sys->ar_color_table_yuv[i_color][3];
1292 }
1293
1294 return true;
1295 }
1296
1297
1298 /*****************************************************************************
1299 * MouseEvent: callback for mouse events
1300 *****************************************************************************/
1301 static int MouseEvent( filter_t *p_filter,
1302 const vlc_mouse_t *p_old,
1303 const vlc_mouse_t *p_new,
1304 const video_format_t *p_fmt )
1305 {
1306 filter_sys_t *p_sys = p_filter->p_sys;
1307 VLC_UNUSED(p_old);
1308
1309 if( !p_sys->b_vnc_mouse_events )
1310 return VLC_SUCCESS;
1311
1312 int i_v = p_new->i_pressed;
1313 int i_x = p_new->i_x;
1314 int i_y = p_new->i_y;
1315
1316 vlc_mutex_lock( &p_sys->lock );
1317
1318 const int v_h = p_fmt->i_visible_height;
1319 const int v_w = p_sys->i_vnc_width * v_h / p_sys->i_vnc_height;
1320 const int v_x = (p_fmt->i_visible_width-v_w)/2;
1321
1322 i_x -= v_x;
1323
1324 if( i_y < 0 || i_x < 0 || i_y >= v_h || i_x >= v_w )
1325 {
1326 vlc_mutex_unlock( &p_sys->lock );
1327 msg_Dbg( p_filter, "invalid mouse event? x=%d y=%d btn=%x", i_x, i_y, i_v );
1328 return VLC_SUCCESS;
1329 }
1330 if( !p_sys->b_connection_active )
1331 {
1332 vlc_mutex_unlock( &p_sys->lock );
1333 return VLC_SUCCESS;
1334 }
1335
1336 #ifdef VNC_DEBUG
1337 msg_Dbg( p_filter, "mouse event x=%d y=%d btn=%x", i_x, i_y, i_v );
1338 #endif
1339
1340 /* */
1341 i_x = i_x * p_sys->i_vnc_width / v_w;
1342 i_y = i_y * p_sys->i_vnc_height / v_h;
1343
1344 /* buttonMask bits 0-7 are buttons 1-8, 0=up, 1=down */
1345 rfbPointerEventMsg ev;
1346 ev.type = rfbPointerEvent;
1347 ev.buttonMask = i_v;
1348 ev.x = htons(i_x);
1349 ev.y = htons(i_y);
1350
1351 write_exact( p_filter, p_sys->i_socket,
1352 (char*)&ev, sz_rfbPointerEventMsg);
1353
1354 vlc_mutex_unlock( &p_sys->lock );
1355
1356 return VLC_EGENERIC;
1357 }
1358
1359 /*****************************************************************************
1360 * KeyEvent: callback for keyboard events
1361 *****************************************************************************/
1362 static int KeyEvent( vlc_object_t *p_this, char const *psz_var,
1363 vlc_value_t oldval, vlc_value_t newval, void *p_data )
1364 {
1365 VLC_UNUSED(psz_var); VLC_UNUSED(oldval);
1366
1367 filter_t *p_filter = (filter_t *)p_data;
1368 filter_sys_t *p_sys = p_filter->p_sys;
1369
1370 if( !p_sys->b_vnc_key_events )
1371 return VLC_SUCCESS;
1372
1373 msg_Dbg( p_this, "key pressed (%"PRId64") ", newval.i_int );
1374
1375 if ( !newval.i_int )
1376 {
1377 msg_Err( p_this, "Received invalid key event 0" );
1378 return VLC_EGENERIC;
1379 }
1380
1381 vlc_mutex_lock( &p_sys->lock );
1382 if( !p_sys->b_connection_active )
1383 {
1384 vlc_mutex_unlock( &p_sys->lock );
1385 return VLC_SUCCESS;
1386 }
1387
1388 uint32_t i_key32 = newval.i_int;
1389 i_key32 = htonl(i_key32);
1390 rfbKeyEventMsg ev;
1391
1392 ev.type = rfbKeyEvent;
1393 ev.down = 1;
1394 ev.pad = 0;
1395
1396 /* first key-down for modifier-keys */
1397 if (newval.i_int & KEY_MODIFIER_CTRL)
1398 {
1399 ev.key = 0xffe3;
1400 write_exact( p_filter, p_sys->i_socket,
1401 (char*)&ev, sz_rfbKeyEventMsg);
1402 }
1403 if (newval.i_int & KEY_MODIFIER_SHIFT)
1404 {
1405 ev.key = 0xffe1;
1406 write_exact( p_filter, p_sys->i_socket,
1407 (char*)&ev, sz_rfbKeyEventMsg);
1408 }
1409 if (newval.i_int & KEY_MODIFIER_ALT)
1410 {
1411 ev.key = 0xffe9;
1412 write_exact( p_filter, p_sys->i_socket,
1413 (char*)&ev, sz_rfbKeyEventMsg);
1414 }
1415
1416 /* then key-down for the pressed key */
1417 ev.key = i_key32;
1418 write_exact( p_filter, p_sys->i_socket,
1419 (char*)&ev, sz_rfbKeyEventMsg);
1420
1421 ev.down = 0;
1422
1423 /* then key-up for the pressed key */
1424 write_exact( p_filter, p_sys->i_socket,
1425 (char*)&ev, sz_rfbKeyEventMsg);
1426
1427 /* last key-down for modifier-keys */
1428 if (newval.i_int & KEY_MODIFIER_CTRL)
1429 {
1430 ev.key = 0xffe3;
1431 write_exact( p_filter, p_sys->i_socket,
1432 (char*)&ev, sz_rfbKeyEventMsg);
1433 }
1434 if (newval.i_int & KEY_MODIFIER_SHIFT)
1435 {
1436 ev.key = 0xffe1;
1437 write_exact( p_filter, p_sys->i_socket,
1438 (char*)&ev, sz_rfbKeyEventMsg);
1439 }
1440 if (newval.i_int & KEY_MODIFIER_ALT)
1441 {
1442 ev.key = 0xffe9;
1443 write_exact( p_filter, p_sys->i_socket,
1444 (char*)&ev, sz_rfbKeyEventMsg);
1445 }
1446 vlc_mutex_unlock( &p_sys->lock );
1447
1448 return VLC_SUCCESS;
1449 }
1450
1451 static void vnc_encrypt_bytes( unsigned char *bytes, char *passwd )
1452 {
1453 unsigned char key[8];
1454 unsigned int i;
1455
1456 for (i = 0; i < 8; i++)
1457 key[i] = i < strlen( passwd ) ? passwd[i] : '\0';
1458
1459 gcry_cipher_hd_t ctx;
1460 gcry_cipher_open( &ctx, GCRY_CIPHER_DES, GCRY_CIPHER_MODE_ECB,0);
1461
1462 /* reverse bits of the key */
1463 for( i = 0 ; i < 8 ; i ++ )
1464 key[i] =
1465 (key[i] >> 7) +
1466 (((key[i] >> 6) & 0x01 ) << 1 ) +
1467 (((key[i] >> 5) & 0x01 ) << 2 ) +
1468 (((key[i] >> 4) & 0x01 ) << 3 ) +
1469 (((key[i] >> 3) & 0x01 ) << 4 ) +
1470 (((key[i] >> 2) & 0x01 ) << 5 ) +
1471 (((key[i] >> 1) & 0x01 ) << 6 ) +
1472 ((key[i] & 0x01) << 7 );
1473
1474 gcry_cipher_setkey( ctx, key, 8 );
1475 gcry_cipher_encrypt( ctx, bytes, CHALLENGESIZE, bytes, CHALLENGESIZE );
1476 gcry_cipher_close( ctx );
1477 }
1478
VLC Solaris and OpenSolaris fixes