git.sesse.net Git - vlc/blob - plugins/directx/vout_events.c

   1 /*****************************************************************************
   2  * vout_events.c: Windows DirectX video output events handler
   3  *****************************************************************************
   4  * Copyright (C) 1998, 1999, 2000 VideoLAN
   5  * $Id: vout_events.c,v 1.3 2001/07/25 08:41:21 gbazin Exp $
   6  *
   7  * Authors: Gildas Bazin <gbazin@netcourrier.com>
   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., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  22  *****************************************************************************/
  23
  24
  25 /*****************************************************************************
  26  * Preamble: This file contains the functions related to the creation of
  27  *             a window and the handling of its messages (events).
  28  *****************************************************************************/
  29 #include "defs.h"
  30
  31 #include <errno.h>                                                 /* ENOMEM */
  32 #include <stdlib.h>                                                /* free() */
  33 #include <string.h>                                            /* strerror() */
  34
  35 #include "config.h"
  36 #include "common.h"
  37 #include "threads.h"
  38 #include "mtime.h"
  39 #include "tests.h"
  40 #include "netutils.h"
  41
  42 #include "video.h"
  43 #include "video_output.h"
  44
  45 #include <windows.h>
  46 #include <windowsx.h>
  47 #include <directx.h>
  48
  49 #include "intf_msg.h"
  50 #include "interface.h"
  51 #include "main.h"
  52
  53 #include "modules.h"
  54 #include "modules_export.h"
  55
  56 #include "vout_directx.h"
  57
  58 /*****************************************************************************
  59  * Local prototypes.
  60  *****************************************************************************/
  61 static int  DirectXCreateWindow( vout_thread_t *p_vout );
  62 static void DirectXCloseWindow ( vout_thread_t *p_vout );
  63 static long FAR PASCAL DirectXEventProc ( HWND hwnd, UINT message,
  64                                           WPARAM wParam, LPARAM lParam );
  65
  66 /*****************************************************************************
  67  * Global variables.
  68  * I really hate them, but here I don't have any choice. And anyway, this
  69  * shouldn't really affect reentrancy.
  70  * This variable is used to know if we have to update the overlay position
  71  * and size. This is to fix the bug we've got when the Windows option, to show
  72  * the content of a window when you drag it, is enabled.
  73  *****************************************************************************/
  74 int b_directx_update_overlay = 0;
  75
  76 /*****************************************************************************
  77  * DirectXEventThread: Create video window & handle its messages
  78  *****************************************************************************
  79  * This function creates a video window and then enters an infinite loop
  80  * that handles the messages sent to that window.
  81  * The main goal of this thread is to isolate the Win32 PeekMessage function
  82  * because this one can block for a long time.
  83  *****************************************************************************/
  84 void DirectXEventThread( vout_thread_t *p_vout )
  85 {
  86     MSG             msg;
  87     boolean_t       b_dispatch_msg = TRUE;
  88
  89     /* Initialisation */
  90
  91     /* Create a window for the video */
  92     /* Creating a window under Windows also initializes the thread's event
  93      * message qeue */
  94     if( DirectXCreateWindow( p_vout ) )
  95     {
  96         intf_ErrMsg( "vout error: can't create window" );
  97         p_vout->p_sys->i_event_thread_status = THREAD_FATAL;
  98         /* signal the creation of the window */
  99         vlc_mutex_lock( &p_vout->p_sys->event_thread_lock );
 100         vlc_cond_signal( &p_vout->p_sys->event_thread_wait );
 101         vlc_mutex_unlock( &p_vout->p_sys->event_thread_lock );
 102         return;
 103     }
 104
 105     /* signal the creation of the window */
 106     p_vout->p_sys->i_event_thread_status = THREAD_READY;
 107     vlc_mutex_lock( &p_vout->p_sys->event_thread_lock );
 108     vlc_cond_signal( &p_vout->p_sys->event_thread_wait );
 109     vlc_mutex_unlock( &p_vout->p_sys->event_thread_lock );
 110
 111     /* Main loop */
 112     while( !p_vout->b_die && !p_vout->p_sys->b_event_thread_die )
 113     {
 114
 115         /* GetMessage will sleep if there's no message in the queue */
 116         if( GetMessage( &msg, NULL, 0, 0 ) >= 0 )
 117         {
 118             switch( msg.message )
 119             {
 120
 121             case WM_CLOSE:
 122                 intf_WarnMsg( 3, "vout: vout_Manage WM_CLOSE" );
 123                 break;
 124
 125             case WM_QUIT:
 126                 intf_WarnMsg( 3, "vout: vout_Manage WM_QUIT" );
 127                 p_vout->p_sys->b_event_thread_die = 1;
 128                 p_main->p_intf->b_die = 1;
 129                 break;
 130
 131             case WM_MOVE:
 132                 intf_WarnMsg( 3, "vout: vout_Manage WM_MOVE" );
 133                 if( !p_vout->b_need_render )
 134                 {
 135                     p_vout->p_sys->i_changes |= VOUT_SIZE_CHANGE;
 136                 }
 137                 /* don't create a never ending loop */
 138                 b_dispatch_msg = FALSE;
 139                 break;
 140
 141             case WM_APP:
 142                 intf_WarnMsg( 3, "vout: vout_Manage WM_APP" );
 143                 if( !p_vout->b_need_render )
 144                 {
 145                     p_vout->p_sys->i_changes |= VOUT_SIZE_CHANGE;
 146                 }
 147                 /* size change has been handled (to fix a bug)*/
 148                 b_directx_update_overlay = 0;
 149                 /* don't create a never ending loop */
 150                 b_dispatch_msg = FALSE;
 151                 break;
 152
 153 #if 0
 154             case WM_PAINT:
 155                 intf_WarnMsg( 4, "vout: vout_Manage WM_PAINT" );
 156                 break;
 157
 158             case WM_ERASEBKGND:
 159                 intf_WarnMsg( 4, "vout: vout_Manage WM_ERASEBKGND" );
 160                 break;
 161 #endif
 162
 163             case WM_MOUSEMOVE:
 164                 intf_WarnMsg( 4, "vout: vout_Manage WM_MOUSEMOVE" );
 165                 if( p_vout->p_sys->b_cursor )
 166                 {
 167                     if( p_vout->p_sys->b_cursor_autohidden )
 168                     {
 169                         p_vout->p_sys->b_cursor_autohidden = 0;
 170                         p_vout->p_sys->i_lastmoved = mdate();
 171                         ShowCursor( TRUE );
 172                     }
 173                     else
 174                     {
 175                         p_vout->p_sys->i_lastmoved = mdate();
 176                     }
 177                 }
 178                 break;
 179
 180             case WM_RBUTTONUP:
 181                 intf_WarnMsg( 4, "vout: vout_Manage WM_RBUTTONUP" );
 182                 p_main->p_intf->b_menu_change = 1;
 183                 break;
 184
 185             case WM_KEYDOWN:
 186                 /* the key events are first processed here. The next
 187                  * message processed by this main message loop will be the
 188                  * char translation of the key event */
 189                 intf_WarnMsg( 3, "vout: vout_Manage WM_KEYDOWN" );
 190                 switch( msg.wParam )
 191                 {
 192                 case VK_ESCAPE:
 193                 case VK_F12:
 194                     PostQuitMessage( 0 );
 195                     break;
 196                 }
 197                 TranslateMessage(&msg);
 198                 b_dispatch_msg = FALSE;
 199                 break;
 200
 201             case WM_CHAR:
 202                 intf_WarnMsg( 3, "vout: vout_Manage WM_CHAR" );
 203                 switch( msg.wParam )
 204                 {
 205                 case 'q':
 206                 case 'Q':
 207                     PostQuitMessage( 0 );
 208                     break;
 209
 210                 case 'f':                            /* switch to fullscreen */
 211                 case 'F':
 212                     p_vout->p_sys->i_changes |= VOUT_FULLSCREEN_CHANGE;
 213                     break;
 214
 215                 case 'y':                              /* switch to hard YUV */
 216                 case 'Y':
 217                     p_vout->p_sys->i_changes |= VOUT_YUV_CHANGE;
 218                     break;
 219
 220                 case 'c':                                /* toggle grayscale */
 221                 case 'C':
 222                     p_vout->b_grayscale = ! p_vout->b_grayscale;
 223                     p_vout->p_sys->i_changes |= VOUT_GRAYSCALE_CHANGE;
 224                     break;
 225
 226                 case 'i':                                     /* toggle info */
 227                 case 'I':
 228                     p_vout->b_info = ! p_vout->b_info;
 229                     p_vout->p_sys->i_changes |= VOUT_INFO_CHANGE;
 230                     break;
 231
 232                 case 's':                                  /* toggle scaling */
 233                 case 'S':
 234                     p_vout->b_scale = ! p_vout->b_scale;
 235                     p_vout->p_sys->i_changes |= VOUT_SCALE_CHANGE;
 236                     break;
 237
 238                 case ' ':                                /* toggle interface */
 239                     p_vout->b_interface = ! p_vout->b_interface;
 240                     p_vout->p_sys->i_changes |= VOUT_INTF_CHANGE;
 241                     break;
 242
 243                 case '0': network_ChannelJoin( 0 ); break;
 244                 case '1': network_ChannelJoin( 1 ); break;
 245                 case '2': network_ChannelJoin( 2 ); break;
 246                 case '3': network_ChannelJoin( 3 ); break;
 247                 case '4': network_ChannelJoin( 4 ); break;
 248                 case '5': network_ChannelJoin( 5 ); break;
 249                 case '6': network_ChannelJoin( 6 ); break;
 250                 case '7': network_ChannelJoin( 7 ); break;
 251                 case '8': network_ChannelJoin( 8 ); break;
 252                 case '9': network_ChannelJoin( 9 ); break;
 253
 254                 default:
 255                     if( intf_ProcessKey( p_main->p_intf,
 256                                          (char )msg.wParam ) )
 257                     {
 258                         intf_DbgMsg( "unhandled key '%c' (%i)",
 259                                      (char)msg.wParam, msg.wParam );
 260                     }
 261                     break;
 262                 }
 263
 264 #if 0
 265             default:
 266                 intf_WarnMsg( 4, "vout: vout_Manage WM Default %i",
 267                               msg.message );
 268                 break;
 269 #endif
 270
 271             } /* End Switch */
 272
 273             /* don't create a never ending loop */
 274             if( b_dispatch_msg )
 275             {
 276                 TranslateMessage(&msg);
 277                 DispatchMessage(&msg);
 278             }
 279             b_dispatch_msg = TRUE;
 280
 281         } /* if( GetMessage() ) */
 282         else
 283         {
 284             intf_ErrMsg("vout error: GetMessage failed in DirectXEventThread");
 285             p_vout->p_sys->b_event_thread_die = 1;
 286         } /* End if( GetMessage() ) */
 287
 288
 289     } /* End Main loop */
 290
 291     /* Destroy the window */
 292     DirectXCloseWindow( p_vout );
 293
 294     /* Set thread Status */
 295     p_vout->p_sys->i_event_thread_status = THREAD_OVER;
 296
 297 }
 298
 299
 300 /* following functions are local */
 301
 302 /*****************************************************************************
 303  * DirectXCreateWindow: create a window for the video.
 304  *****************************************************************************
 305  * Before creating a direct draw surface, we need to create a window in which
 306  * the video will be displayed. This window will also allow us to capture the
 307  * events.
 308  *****************************************************************************/
 309 static int DirectXCreateWindow( vout_thread_t *p_vout )
 310 {
 311     HINSTANCE  hInstance;
 312     WNDCLASSEX wc;                                /* window class components */
 313     RECT       rect_window;
 314     COLORREF   colorkey;
 315     HDC        hdc;
 316
 317     intf_WarnMsg( 3, "vout: DirectXCreateWindow" );
 318
 319     /* get this module's instance */
 320     hInstance = GetModuleHandle(NULL);
 321
 322     /* Create a BRUSH that will be used by Windows to paint the window
 323      * background.
 324      * This window background is important for us as it will be used by the
 325      * graphics card to display the overlay.
 326      * This is why we carefully choose the color for this background, the goal
 327      * being to choose a color which isn't complete black but nearly. We
 328      * obviously don't want to use black as a colorkey for the overlay because
 329      * black is one of the most used color and thus would give us undesirable
 330      * effects */
 331     /* the first step is to find the colorkey we want to use. The difficulty
 332      * comes from the potential dithering (depends on the display depth)
 333      * because we need to know the real RGB value of the chosen colorkey */
 334     hdc = GetDC( GetDesktopWindow() );
 335     for( colorkey = 5; colorkey < 0xFF /*all shades of red*/; colorkey++ )
 336     {
 337         if( colorkey == GetNearestColor( hdc, colorkey ) )
 338           break;
 339     }
 340     intf_WarnMsg(3,"vout: DirectXCreateWindow background color:%i", colorkey);
 341     ReleaseDC( p_vout->p_sys->hwnd, hdc );
 342
 343     /* create the actual brush */
 344     p_vout->p_sys->hbrush = CreateSolidBrush(colorkey);
 345     p_vout->p_sys->i_colorkey = (int)colorkey;
 346
 347     /* fill in the window class structure */
 348     wc.cbSize        = sizeof(WNDCLASSEX);
 349     wc.style         = 0;                               /* no special styles */
 350     wc.lpfnWndProc   = (WNDPROC)DirectXEventProc;           /* event handler */
 351     wc.cbClsExtra    = 0;                             /* no extra class data */
 352     wc.cbWndExtra    = 0;                            /* no extra window data */
 353     wc.hInstance     = hInstance;                                /* instance */
 354     wc.hIcon         = LoadIcon(NULL, IDI_APPLICATION); /* load the vlc icon */
 355     wc.hCursor       = LoadCursor(NULL, IDC_ARROW); /* load a default cursor */
 356     wc.hbrBackground = p_vout->p_sys->hbrush;            /* background color */
 357     wc.lpszMenuName  = NULL;                                      /* no menu */
 358     wc.lpszClassName = "VLC DirectX";                 /* use a special class */
 359     wc.hIconSm       = LoadIcon(NULL, IDI_APPLICATION); /* load the vlc icon */
 360
 361     /* register the window class */
 362     if (!RegisterClassEx(&wc))
 363     {
 364         intf_WarnMsg( 3, "vout: DirectXCreateWindow register window FAILED" );
 365         return (1);
 366     }
 367
 368     /* when you create a window you give the dimensions you wish it to have.
 369      * Unfortunatly these dimensions will include the borders and title bar.
 370      * We use the following function to find out the size of the window
 371      * corresponding to the useable surface we want */
 372     rect_window.top    = 10;
 373     rect_window.left   = 10;
 374     rect_window.right  = rect_window.left + p_vout->p_sys->i_window_width;
 375     rect_window.bottom = rect_window.top + p_vout->p_sys->i_window_height;
 376     AdjustWindowRect( &rect_window, WS_OVERLAPPEDWINDOW|WS_SIZEBOX, 0 );
 377
 378     /* create the window */
 379     p_vout->p_sys->hwnd = CreateWindow("VLC DirectX",/* name of window class */
 380                     "VLC DirectX",                  /* window title bar text */
 381                     WS_OVERLAPPEDWINDOW
 382                     | WS_SIZEBOX | WS_VISIBLE,               /* window style */
 383                     10,                              /* default X coordinate */
 384                     10,                              /* default Y coordinate */
 385                     rect_window.right - rect_window.left,    /* window width */
 386                     rect_window.bottom - rect_window.top,   /* window height */
 387                     NULL,                                /* no parent window */
 388                     NULL,                          /* no menu in this window */
 389                     hInstance,            /* handle of this program instance */
 390                     NULL);                        /* no additional arguments */
 391
 392     if (p_vout->p_sys->hwnd == NULL) {
 393         intf_WarnMsg( 3, "vout: DirectXCreateWindow create window FAILED" );
 394         return (1);
 395     }
 396
 397     /* now display the window */
 398     ShowWindow(p_vout->p_sys->hwnd, SW_SHOW);
 399
 400     return ( 0 );
 401 }
 402
 403 /*****************************************************************************
 404  * DirectXCloseWindow: close the window created by DirectXCreateWindow
 405  *****************************************************************************
 406  * This function returns all resources allocated by DirectXCreateWindow.
 407  *****************************************************************************/
 408 static void DirectXCloseWindow( vout_thread_t *p_vout )
 409 {
 410     HINSTANCE hInstance;
 411
 412     intf_WarnMsg( 3, "vout: DirectXCloseWindow" );
 413     if( p_vout->p_sys->hwnd != NULL )
 414     {
 415         DestroyWindow( p_vout->p_sys->hwnd);
 416         p_vout->p_sys->hwnd = NULL;
 417     }
 418
 419     hInstance = GetModuleHandle(NULL);
 420     UnregisterClass( "VLC DirectX",                            /* class name */
 421                      hInstance );          /* handle to application instance */
 422
 423     /* free window background brush */
 424     if( p_vout->p_sys->hwnd != NULL )
 425     {
 426         DeleteObject( p_vout->p_sys->hbrush );
 427         p_vout->p_sys->hbrush = NULL;
 428     }
 429 }
 430
 431 /*****************************************************************************
 432  * DirectXEventProc: This is the window event processing function.
 433  *****************************************************************************
 434  * On Windows, when you create a window you have to attach an event processing
 435  * function to it. The aim of this function is to manage "Queued Messages" and
 436  * "Nonqueued Messages".
 437  * Queued Messages are those picked up and retransmitted by vout_Manage
 438  * (using the GetMessage function).
 439  * Nonqueued Messages are those that Windows will send directly to this
 440  * function (like WM_DESTROY, WM_WINDOWPOSCHANGED...)
 441  *****************************************************************************/
 442 static long FAR PASCAL DirectXEventProc( HWND hwnd, UINT message,
 443                                          WPARAM wParam, LPARAM lParam )
 444 {
 445     switch( message )
 446     {
 447
 448 #if 0
 449     case WM_APP:
 450         intf_WarnMsg( 3, "vout: WinProc WM_APP" );
 451         break;
 452
 453     case WM_ACTIVATE:
 454         intf_WarnMsg( 4, "vout: WinProc WM_ACTIVED" );
 455         break;
 456
 457     case WM_CREATE:
 458         intf_WarnMsg( 4, "vout: WinProc WM_CREATE" );
 459         break;
 460
 461     /* the user wants to close the window */
 462     case WM_CLOSE:
 463         intf_WarnMsg( 4, "vout: WinProc WM_CLOSE" );
 464         break;
 465 #endif
 466
 467     /* the window has been closed so shut down everything now */
 468     case WM_DESTROY:
 469         intf_WarnMsg( 4, "vout: WinProc WM_DESTROY" );
 470         PostQuitMessage( 0 );
 471         break;
 472
 473     case WM_SYSCOMMAND:
 474         switch (wParam)
 475         {
 476             case SC_SCREENSAVE:                     /* catch the screensaver */
 477             case SC_MONITORPOWER:              /* catch the monitor turn-off */
 478             intf_WarnMsg( 3, "vout: WinProc WM_SYSCOMMAND" );
 479             return 0;                      /* this stops them from happening */
 480         }
 481         break;
 482
 483 #if 0
 484     case WM_MOVE:
 485         intf_WarnMsg( 4, "vout: WinProc WM_MOVE" );
 486         break;
 487
 488     case WM_SIZE:
 489         intf_WarnMsg( 4, "vout: WinProc WM_SIZE" );
 490         break;
 491
 492     case WM_MOVING:
 493         intf_WarnMsg( 4, "vout: WinProc WM_MOVING" );
 494         break;
 495
 496     case WM_ENTERSIZEMOVE:
 497         intf_WarnMsg( 4, "vout: WinProc WM_ENTERSIZEMOVE" );
 498         break;
 499
 500     case WM_SIZING:
 501         intf_WarnMsg( 4, "vout: WinProc WM_SIZING" );
 502         break;
 503 #endif
 504
 505     case WM_WINDOWPOSCHANGED:
 506         intf_WarnMsg( 3, "vout: WinProc WM_WINDOWPOSCHANGED" );
 507         b_directx_update_overlay = 1;
 508         PostMessage( hwnd, WM_APP, 0, 0);
 509         break;
 510
 511 #if 0
 512     case WM_WINDOWPOSCHANGING:
 513         intf_WarnMsg( 3, "vout: WinProc WM_WINDOWPOSCHANGING" );
 514         break;
 515
 516     case WM_PAINT:
 517         intf_WarnMsg( 4, "vout: WinProc WM_PAINT" );
 518         break;
 519
 520     case WM_ERASEBKGND:
 521         intf_WarnMsg( 4, "vout: WinProc WM_ERASEBKGND" );
 522         break;
 523
 524     default:
 525         intf_WarnMsg( 4, "vout: WinProc WM Default %i", message );
 526         break;
 527 #endif
 528     }
 529
 530     return DefWindowProc(hwnd, message, wParam, lParam);
 531 }