git.sesse.net Git - vlc/blob - modules/video_output/sdl.c

   1 /*****************************************************************************
   2  * sdl.c: SDL video output display method
   3  *****************************************************************************
   4  * Copyright (C) 1998-2009 VLC authors and VideoLAN
   5  * $Id$
   6  *
   7  * Authors: Samuel Hocevar <sam@zoy.org>
   8  *          Pierre Baillet <oct@zoy.org>
   9  *          Arnaud de Bossoreille de Ribou <bozo@via.ecp.fr>
  10  *          Laurent Aimar <fenrir _AT_ videolan _DOT_ org>
  11  *
  12  * This program is free software; you can redistribute it and/or modify it
  13  * under the terms of the GNU Lesser General Public License as published by
  14  * the Free Software Foundation; either version 2.1 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  20  * GNU Lesser General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * along with this program; if not, write to the Free Software Foundation,
  24  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  25  *****************************************************************************/
  26
  27 /*****************************************************************************
  28  * Preamble
  29  *****************************************************************************/
  30 #ifdef HAVE_CONFIG_H
  31 # include "config.h"
  32 #endif
  33
  34 #include <vlc_common.h>
  35 #include <vlc_plugin.h>
  36 #include <vlc_vout_display.h>
  37 #include <vlc_picture_pool.h>
  38
  39 #include <assert.h>
  40
  41 #include <SDL.h>
  42
  43 #if !defined(_WIN32) && !defined(__OS2__)
  44 # ifdef X_DISPLAY_MISSING
  45 #  error Xlib required due to XInitThreads
  46 # endif
  47 # include <vlc_xlib.h>
  48 #endif
  49
  50 /*****************************************************************************
  51  * Module descriptor
  52  *****************************************************************************/
  53 static int  Open (vlc_object_t *);
  54 static void Close(vlc_object_t *);
  55
  56 #define CHROMA_TEXT N_("SDL chroma format")
  57 #define CHROMA_LONGTEXT N_(\
  58     "Force the SDL renderer to use a specific chroma format instead of " \
  59     "trying to improve performances by using the most efficient one.")
  60
  61 vlc_module_begin()
  62     set_shortname("SDL")
  63     set_category(CAT_VIDEO)
  64     set_subcategory(SUBCAT_VIDEO_VOUT)
  65     set_description(N_("Simple DirectMedia Layer video output"))
  66     set_capability("vout display", 70)
  67     add_shortcut("sdl")
  68     add_string("sdl-chroma", NULL, CHROMA_TEXT, CHROMA_LONGTEXT, true)
  69     add_obsolete_string("sdl-video-driver") /* obsolete since 1.1.0 */
  70     set_callbacks(Open, Close)
  71 #if defined(__i386__) || defined(__x86_64__)
  72     /* On i386, SDL is linked against svgalib */
  73     cannot_unload_broken_library()
  74 #endif
  75 vlc_module_end()
  76
  77
  78 /*****************************************************************************
  79  * Local prototypes
  80  *****************************************************************************/
  81 static picture_pool_t *Pool  (vout_display_t *, unsigned);
  82 static void           PictureDisplay(vout_display_t *, picture_t *, subpicture_t *);
  83 static int            Control(vout_display_t *, int, va_list);
  84 static void           Manage(vout_display_t *);
  85
  86 /* */
  87 static int ConvertKey(SDLKey);
  88
  89 /* */
  90 static vlc_mutex_t sdl_lock = VLC_STATIC_MUTEX;
  91
  92 /* */
  93 struct vout_display_sys_t {
  94     vout_display_place_t place;
  95
  96     SDL_Surface          *display;
  97     int                  display_bpp;
  98     uint32_t             display_flags;
  99
 100     unsigned int         desktop_width;
 101     unsigned int         desktop_height;
 102
 103     /* For YUV output */
 104     SDL_Overlay          *overlay;
 105     bool                 is_uv_swapped;
 106
 107     /* */
 108     picture_pool_t       *pool;
 109 };
 110
 111 /**
 112  * This function initializes SDL vout method.
 113  */
 114 static int Open(vlc_object_t *object)
 115 {
 116     vout_display_t *vd = (vout_display_t *)object;
 117     vout_display_sys_t *sys;
 118
 119 #if !defined(_WIN32) && !defined(__OS2__)
 120     if (!vlc_xlib_init (object))
 121         return VLC_EGENERIC;
 122 #endif
 123
 124     /* XXX: check for conflicts with the SDL audio output */
 125     vlc_mutex_lock(&sdl_lock);
 126
 127     /* Check if SDL video module has been initialized */
 128     if (SDL_WasInit(SDL_INIT_VIDEO) != 0) {
 129         vlc_mutex_unlock(&sdl_lock);
 130         return VLC_EGENERIC;
 131     }
 132
 133     vd->sys = sys = calloc(1, sizeof(*sys));
 134     if (!sys) {
 135         vlc_mutex_unlock(&sdl_lock);
 136         return VLC_ENOMEM;
 137     }
 138
 139     /* */
 140     int sdl_flags = SDL_INIT_VIDEO;
 141 #ifndef _WIN32
 142     /* Win32 SDL implementation doesn't support SDL_INIT_EVENTTHREAD yet*/
 143     sdl_flags |= SDL_INIT_EVENTTHREAD;
 144 #endif
 145     /* In debug mode you may want vlc to dump a core instead of staying stuck */
 146     sdl_flags |= SDL_INIT_NOPARACHUTE;
 147
 148     /* Initialize library */
 149     if (SDL_Init(sdl_flags) < 0) {
 150         vlc_mutex_unlock(&sdl_lock);
 151
 152         msg_Err(vd, "cannot initialize SDL (%s)", SDL_GetError());
 153         free(sys);
 154         return VLC_EGENERIC;
 155     }
 156     vlc_mutex_unlock(&sdl_lock);
 157
 158     /* Translate keys into unicode */
 159     SDL_EnableUNICODE(1);
 160
 161     /* Get the desktop resolution */
 162     /* FIXME: SDL has a problem with virtual desktop */
 163     sys->desktop_width  = SDL_GetVideoInfo()->current_w;
 164     sys->desktop_height = SDL_GetVideoInfo()->current_h;
 165
 166     /* */
 167     video_format_t fmt;
 168     video_format_ApplyRotation(&fmt, &vd->fmt);
 169
 170     /* */
 171     vout_display_info_t info = vd->info;
 172
 173     /* Set main window's size */
 174     int display_width;
 175     int display_height;
 176     if (vd->cfg->is_fullscreen) {
 177         display_width  = sys->desktop_width;
 178         display_height = sys->desktop_height;
 179     } else {
 180         display_width  = vd->cfg->display.width;
 181         display_height = vd->cfg->display.height;
 182     }
 183
 184     /* Initialize flags and cursor */
 185     sys->display_flags = SDL_ANYFORMAT | SDL_HWPALETTE | SDL_HWSURFACE | SDL_DOUBLEBUF;
 186     sys->display_flags |= vd->cfg->is_fullscreen ? SDL_FULLSCREEN : SDL_RESIZABLE;
 187
 188     sys->display_bpp = SDL_VideoModeOK(display_width, display_height,
 189                                        16, sys->display_flags);
 190     if (sys->display_bpp == 0) {
 191         msg_Err(vd, "no video mode available");
 192         goto error;
 193     }
 194     vout_display_DeleteWindow(vd, NULL);
 195
 196     sys->display = SDL_SetVideoMode(display_width, display_height,
 197                                     sys->display_bpp, sys->display_flags);
 198     if (!sys->display) {
 199         msg_Err(vd, "cannot set video mode");
 200         goto error;
 201     }
 202
 203     /* We keep the surface locked forever */
 204     SDL_LockSurface(sys->display);
 205
 206     /* */
 207     vlc_fourcc_t forced_chroma = 0;
 208     char *psz_chroma = var_InheritString(vd, "sdl-chroma");
 209     if (psz_chroma) {
 210         forced_chroma = vlc_fourcc_GetCodecFromString(VIDEO_ES, psz_chroma);
 211         if (forced_chroma)
 212             msg_Dbg(vd, "Forcing chroma to 0x%.8x (%4.4s)",
 213                     forced_chroma, (const char*)&forced_chroma);
 214         free(psz_chroma);
 215     }
 216
 217     /* Try to open an overlay if requested */
 218     sys->overlay = NULL;
 219     const bool is_overlay = var_InheritBool(vd, "overlay");
 220     if (is_overlay) {
 221         static const struct
 222         {
 223             vlc_fourcc_t vlc;
 224             uint32_t     sdl;
 225         } vlc_to_sdl[] = {
 226             { VLC_CODEC_YV12, SDL_YV12_OVERLAY },
 227             { VLC_CODEC_I420, SDL_IYUV_OVERLAY },
 228             { VLC_CODEC_YUYV, SDL_YUY2_OVERLAY },
 229             { VLC_CODEC_UYVY, SDL_UYVY_OVERLAY },
 230             { VLC_CODEC_YVYU, SDL_YVYU_OVERLAY },
 231
 232             { 0, 0 }
 233         };
 234         const vlc_fourcc_t forced_chromas[] = {
 235             forced_chroma, 0
 236         };
 237         const vlc_fourcc_t *fallback_chromas =
 238             vlc_fourcc_GetYUVFallback(fmt.i_chroma);
 239         const vlc_fourcc_t *chromas = forced_chroma ? forced_chromas : fallback_chromas;
 240
 241         for (int pass = forced_chroma ? 1 : 0; pass < 2 && !sys->overlay; pass++) {
 242             for (int i = 0; chromas[i] != 0; i++) {
 243                 const vlc_fourcc_t vlc = chromas[i];
 244
 245                 uint32_t sdl = 0;
 246                 for (int j = 0; vlc_to_sdl[j].vlc != 0 && !sdl; j++) {
 247                     if (vlc_to_sdl[j].vlc == vlc)
 248                         sdl = vlc_to_sdl[j].sdl;
 249                 }
 250                 if (!sdl)
 251                     continue;
 252
 253                 sys->overlay = SDL_CreateYUVOverlay(fmt.i_width, fmt.i_height,
 254                                                     sdl, sys->display);
 255                 if (sys->overlay && !sys->overlay->hw_overlay && pass == 0) {
 256                     /* Ignore non hardware overlay surface in first pass */
 257                     SDL_FreeYUVOverlay(sys->overlay);
 258                     sys->overlay = NULL;
 259                 }
 260                 if (sys->overlay) {
 261                     /* We keep the surface locked forever */
 262                     SDL_LockYUVOverlay(sys->overlay);
 263
 264                     fmt.i_chroma = vlc;
 265                     sys->is_uv_swapped = vlc_fourcc_AreUVPlanesSwapped(fmt.i_chroma,
 266                                                                        vd->fmt.i_chroma);
 267                     if (sys->is_uv_swapped)
 268                         fmt.i_chroma = vd->fmt.i_chroma;
 269                     break;
 270                 }
 271             }
 272         }
 273     } else {
 274         msg_Warn(vd, "SDL overlay disabled by the user");
 275     }
 276
 277     /* */
 278     vout_display_cfg_t place_cfg = *vd->cfg;
 279     place_cfg.display.width  = display_width;
 280     place_cfg.display.height = display_height;
 281     vout_display_PlacePicture(&sys->place, &vd->source, &place_cfg, !sys->overlay);
 282
 283     /* If no overlay, fallback to software output */
 284     if (!sys->overlay) {
 285         /* */
 286         switch (sys->display->format->BitsPerPixel) {
 287         case 8:
 288             fmt.i_chroma = VLC_CODEC_RGB8;
 289             break;
 290         case 15:
 291             fmt.i_chroma = VLC_CODEC_RGB15;
 292             break;
 293         case 16:
 294             fmt.i_chroma = VLC_CODEC_RGB16;
 295             break;
 296         case 24:
 297             fmt.i_chroma = VLC_CODEC_RGB24;
 298             break;
 299         case 32:
 300             fmt.i_chroma = VLC_CODEC_RGB32;
 301             break;
 302         default:
 303             msg_Err(vd, "unknown screen depth %i",
 304                     sys->display->format->BitsPerPixel);
 305             goto error;
 306         }
 307
 308         /* All we have is an RGB image with square pixels */
 309         fmt.i_width  = display_width;
 310         fmt.i_height = display_height;
 311         fmt.i_rmask = sys->display->format->Rmask;
 312         fmt.i_gmask = sys->display->format->Gmask;
 313         fmt.i_bmask = sys->display->format->Bmask;
 314
 315         info.has_pictures_invalid = true;
 316     }
 317
 318     if (vd->cfg->display.title)
 319         SDL_WM_SetCaption(vd->cfg->display.title,
 320                           vd->cfg->display.title);
 321     else if (!sys->overlay)
 322         SDL_WM_SetCaption(VOUT_TITLE " (software RGB SDL output)",
 323                           VOUT_TITLE " (software RGB SDL output)");
 324     else if (sys->overlay->hw_overlay)
 325         SDL_WM_SetCaption(VOUT_TITLE " (hardware YUV SDL output)",
 326                           VOUT_TITLE " (hardware YUV SDL output)");
 327     else
 328         SDL_WM_SetCaption(VOUT_TITLE " (software YUV SDL output)",
 329                           VOUT_TITLE " (software YUV SDL output)");
 330
 331     /* Setup events */
 332     SDL_EventState(SDL_KEYUP, SDL_IGNORE);               /* ignore keys up */
 333
 334     /* Setup vout_display now that everything is fine */
 335     vd->fmt = fmt;
 336     vd->info = info;
 337
 338     vd->pool    = Pool;
 339     vd->prepare = NULL;
 340     vd->display = PictureDisplay;
 341     vd->control = Control;
 342     vd->manage  = Manage;
 343
 344     /* */
 345     vout_display_SendEventDisplaySize(vd, display_width, display_height);
 346     return VLC_SUCCESS;
 347
 348 error:
 349     msg_Err(vd, "cannot set up SDL (%s)", SDL_GetError());
 350
 351     if (sys->display) {
 352         SDL_UnlockSurface(sys->display);
 353         SDL_FreeSurface(sys->display);
 354     }
 355
 356     vlc_mutex_lock(&sdl_lock);
 357     SDL_QuitSubSystem(SDL_INIT_VIDEO);
 358     vlc_mutex_unlock(&sdl_lock);
 359
 360     free(sys);
 361     return VLC_EGENERIC;
 362 }
 363
 364 /**
 365  * Close a SDL video output
 366  */
 367 static void Close(vlc_object_t *object)
 368 {
 369     vout_display_t *vd = (vout_display_t *)object;
 370     vout_display_sys_t *sys = vd->sys;
 371
 372     if (sys->pool)
 373         picture_pool_Delete(sys->pool);
 374
 375     if (sys->overlay) {
 376         SDL_LockYUVOverlay(sys->overlay);
 377         SDL_FreeYUVOverlay(sys->overlay);
 378     }
 379     SDL_UnlockSurface (sys->display);
 380     SDL_FreeSurface(sys->display);
 381
 382     vlc_mutex_lock(&sdl_lock);
 383     SDL_QuitSubSystem(SDL_INIT_VIDEO);
 384     vlc_mutex_unlock(&sdl_lock);
 385
 386     free(sys);
 387 }
 388
 389 /**
 390  * Return a pool of direct buffers
 391  */
 392 static picture_pool_t *Pool(vout_display_t *vd, unsigned count)
 393 {
 394     vout_display_sys_t *sys = vd->sys;
 395     VLC_UNUSED(count);
 396
 397     if (!sys->pool) {
 398         picture_resource_t rsc;
 399
 400         memset(&rsc, 0, sizeof(rsc));
 401
 402         if (sys->overlay) {
 403             SDL_Overlay *ol = sys->overlay;
 404
 405             for (int i = 0; i < ol->planes; i++) {
 406                 rsc.p[i].p_pixels = ol->pixels[ i > 0 && sys->is_uv_swapped ? (3-i) : i];
 407                 rsc.p[i].i_pitch  = ol->pitches[i > 0 && sys->is_uv_swapped ? (3-i) : i];
 408                 rsc.p[i].i_lines  = ol->h;
 409                 if (ol->format == SDL_YV12_OVERLAY ||
 410                     ol->format == SDL_IYUV_OVERLAY)
 411                     rsc.p[i].i_lines /= 2;
 412
 413             }
 414         } else {
 415             const int x = sys->place.x;
 416             const int y = sys->place.y;
 417
 418             SDL_Surface *sf = sys->display;
 419             SDL_FillRect(sf, NULL, 0);
 420
 421             assert(x >= 0 && y >= 0);
 422             rsc.p[0].p_pixels = (uint8_t*)sf->pixels + y * sf->pitch + x * ((sf->format->BitsPerPixel + 7) / 8);
 423             rsc.p[0].i_pitch  = sf->pitch;
 424             rsc.p[0].i_lines  = vd->fmt.i_height;
 425         }
 426
 427         picture_t *picture = picture_NewFromResource(&vd->fmt, &rsc);;
 428         if (!picture)
 429             return NULL;
 430
 431         sys->pool = picture_pool_New(1, &picture);
 432     }
 433
 434     return sys->pool;
 435 }
 436
 437 /**
 438  * Display a picture
 439  */
 440 static void PictureDisplay(vout_display_t *vd, picture_t *p_pic, subpicture_t *p_subpicture)
 441 {
 442     vout_display_sys_t *sys = vd->sys;
 443
 444     if (sys->overlay) {
 445         SDL_Rect disp;
 446         disp.x = sys->place.x;
 447         disp.y = sys->place.y;
 448         disp.w = sys->place.width;
 449         disp.h = sys->place.height;
 450
 451         SDL_UnlockYUVOverlay(sys->overlay);
 452         SDL_DisplayYUVOverlay(sys->overlay , &disp);
 453         SDL_LockYUVOverlay(sys->overlay);
 454     } else {
 455         SDL_Flip(sys->display);
 456     }
 457
 458     picture_Release(p_pic);
 459     VLC_UNUSED(p_subpicture);
 460 }
 461
 462
 463 /**
 464  * Control for vout display
 465  */
 466 static int Control(vout_display_t *vd, int query, va_list args)
 467 {
 468     vout_display_sys_t *sys = vd->sys;
 469
 470     switch (query)
 471     {
 472     case VOUT_DISPLAY_HIDE_MOUSE:
 473         SDL_ShowCursor(0);
 474         return VLC_SUCCESS;
 475
 476     case VOUT_DISPLAY_CHANGE_DISPLAY_SIZE: {
 477         const vout_display_cfg_t *cfg = va_arg(args, const vout_display_cfg_t *);
 478
 479         /* */
 480         sys->display = SDL_SetVideoMode(cfg->display.width,
 481                                         cfg->display.height,
 482                                         sys->display_bpp, sys->display_flags);
 483         if (!sys->display) {
 484             sys->display = SDL_SetVideoMode(vd->cfg->display.width,
 485                                             vd->cfg->display.height,
 486                                             sys->display_bpp, sys->display_flags);
 487             return VLC_EGENERIC;
 488         }
 489         if (sys->overlay)
 490             vout_display_PlacePicture(&sys->place, &vd->source, cfg, !sys->overlay);
 491         else
 492             vout_display_SendEventPicturesInvalid(vd);
 493         return VLC_SUCCESS;
 494     }
 495     case VOUT_DISPLAY_CHANGE_FULLSCREEN: {
 496         vout_display_cfg_t cfg = *va_arg(args, const vout_display_cfg_t *);
 497
 498         /* Fix flags */
 499         sys->display_flags &= ~(SDL_FULLSCREEN | SDL_RESIZABLE);
 500         sys->display_flags |= cfg.is_fullscreen ? SDL_FULLSCREEN : SDL_RESIZABLE;
 501
 502         if (cfg.is_fullscreen) {
 503             cfg.display.width = sys->desktop_width;
 504             cfg.display.height = sys->desktop_height;
 505         }
 506
 507         if (sys->overlay) {
 508             sys->display = SDL_SetVideoMode(cfg.display.width, cfg.display.height,
 509                                             sys->display_bpp, sys->display_flags);
 510
 511             vout_display_PlacePicture(&sys->place, &vd->source, &cfg, !sys->overlay);
 512         }
 513         vout_display_SendEventDisplaySize(vd, cfg.display.width, cfg.display.height);
 514         return VLC_SUCCESS;
 515     }
 516     case VOUT_DISPLAY_CHANGE_ZOOM:
 517     case VOUT_DISPLAY_CHANGE_DISPLAY_FILLED:
 518     case VOUT_DISPLAY_CHANGE_SOURCE_ASPECT: {
 519         const vout_display_cfg_t *cfg;
 520         const video_format_t *source;
 521
 522         if (query == VOUT_DISPLAY_CHANGE_SOURCE_ASPECT) {
 523             source = va_arg(args, const video_format_t *);
 524             cfg = vd->cfg;
 525         } else {
 526             source = &vd->source;
 527             cfg = va_arg(args, const vout_display_cfg_t *);
 528         }
 529         if (sys->overlay) {
 530             sys->display = SDL_SetVideoMode(cfg->display.width, cfg->display.height,
 531                                             sys->display_bpp, sys->display_flags);
 532
 533             vout_display_PlacePicture(&sys->place, source, cfg, !sys->overlay);
 534         } else {
 535             vout_display_SendEventPicturesInvalid(vd);
 536         }
 537         return VLC_SUCCESS;
 538     }
 539
 540     case VOUT_DISPLAY_RESET_PICTURES: {
 541         /* */
 542         assert(!sys->overlay);
 543
 544         /* */
 545         if (sys->pool)
 546             picture_pool_Delete(sys->pool);
 547         sys->pool = NULL;
 548
 549         vout_display_PlacePicture(&sys->place, &vd->source, vd->cfg, !sys->overlay);
 550
 551         /* */
 552         vd->fmt.i_width  = sys->place.width;
 553         vd->fmt.i_height = sys->place.height;
 554         return VLC_SUCCESS;
 555     }
 556
 557     case VOUT_DISPLAY_CHANGE_SOURCE_CROP:
 558     case VOUT_DISPLAY_CHANGE_WINDOW_STATE:
 559         /* I don't think it is possible to support with SDL:
 560          * - crop
 561          * - on top
 562          */
 563         return VLC_EGENERIC;
 564
 565     default:
 566         msg_Err(vd, "Unsupported query in vout display SDL");
 567         return VLC_EGENERIC;
 568     }
 569 }
 570
 571 /**
 572  * Proccess pending event
 573  */
 574 static void Manage(vout_display_t *vd)
 575 {
 576     vout_display_sys_t *sys = vd->sys;
 577     SDL_Event event;
 578
 579     /* */
 580     while (SDL_PollEvent(&event)) {
 581         switch (event.type) {
 582         case SDL_QUIT:
 583             vout_display_SendEventClose(vd);
 584             break;
 585
 586         case SDL_KEYDOWN: {
 587             /* convert the key if possible */
 588             int key = ConvertKey(event.key.keysym.sym);
 589
 590             if (!key) {
 591                 /* Find the right caracter */
 592                 if ((event.key.keysym.unicode & 0xff80) == 0) {
 593                     key = event.key.keysym.unicode & 0x7f;
 594                     /* FIXME: find a better solution than this
 595                               hack to find the right caracter */
 596                     if (key >= 1 && key <= 26)
 597                         key += 96;
 598                     else if (key >= 65 && key <= 90)
 599                         key += 32;
 600                 }
 601             }
 602             if (!key)
 603                 break;
 604
 605             if (event.key.keysym.mod & KMOD_SHIFT)
 606                 key |= KEY_MODIFIER_SHIFT;
 607             if (event.key.keysym.mod & KMOD_CTRL)
 608                 key |= KEY_MODIFIER_CTRL;
 609             if (event.key.keysym.mod & KMOD_ALT)
 610                 key |= KEY_MODIFIER_ALT;
 611             vout_display_SendEventKey(vd, key);
 612             break;
 613         }
 614
 615         case SDL_MOUSEBUTTONDOWN:
 616         case SDL_MOUSEBUTTONUP: {
 617             static const struct { int sdl; int vlc; } buttons[] = {
 618                 { SDL_BUTTON_LEFT,      MOUSE_BUTTON_LEFT },
 619                 { SDL_BUTTON_MIDDLE,    MOUSE_BUTTON_CENTER },
 620                 { SDL_BUTTON_RIGHT,     MOUSE_BUTTON_RIGHT },
 621                 { SDL_BUTTON_WHEELUP,   MOUSE_BUTTON_WHEEL_UP },
 622                 { SDL_BUTTON_WHEELDOWN, MOUSE_BUTTON_WHEEL_DOWN },
 623                 { -1, -1 },
 624             };
 625
 626             SDL_ShowCursor(1);
 627             for (int i = 0; buttons[i].sdl != -1; i++) {
 628                 if (buttons[i].sdl == event.button.button) {
 629                     if (event.type == SDL_MOUSEBUTTONDOWN)
 630                         vout_display_SendEventMousePressed(vd, buttons[i].vlc);
 631                     else
 632                         vout_display_SendEventMouseReleased(vd, buttons[i].vlc);
 633                 }
 634             }
 635             break;
 636         }
 637
 638         case SDL_MOUSEMOTION: {
 639             if (sys->place.width <= 0 || sys->place.height <= 0)
 640                 break;
 641
 642             SDL_ShowCursor(1);
 643
 644             vout_display_SendMouseMovedDisplayCoordinates(vd, ORIENT_NORMAL,
 645                                                           event.motion.x, event.motion.y,
 646                                                           &sys->place);
 647             break;
 648         }
 649
 650         case SDL_VIDEORESIZE:
 651             vout_display_SendEventDisplaySize(vd, event.resize.w, event.resize.h);
 652             break;
 653
 654         default:
 655             break;
 656         }
 657     }
 658
 659 }
 660
 661 static const struct {
 662     SDLKey sdl_key;
 663     int    vlckey;
 664
 665 } sdlkeys_to_vlckeys[] = {
 666     { SDLK_F1,  KEY_F1 },
 667     { SDLK_F2,  KEY_F2 },
 668     { SDLK_F3,  KEY_F3 },
 669     { SDLK_F4,  KEY_F4 },
 670     { SDLK_F5,  KEY_F5 },
 671     { SDLK_F6,  KEY_F6 },
 672     { SDLK_F7,  KEY_F7 },
 673     { SDLK_F8,  KEY_F8 },
 674     { SDLK_F9,  KEY_F9 },
 675     { SDLK_F10, KEY_F10 },
 676     { SDLK_F11, KEY_F11 },
 677     { SDLK_F12, KEY_F12 },
 678
 679     { SDLK_RETURN, KEY_ENTER },
 680     { SDLK_KP_ENTER, KEY_ENTER },
 681     { SDLK_SPACE, ' ' },
 682     { SDLK_ESCAPE, KEY_ESC },
 683
 684     { SDLK_MENU, KEY_MENU },
 685     { SDLK_LEFT, KEY_LEFT },
 686     { SDLK_RIGHT, KEY_RIGHT },
 687     { SDLK_UP, KEY_UP },
 688     { SDLK_DOWN, KEY_DOWN },
 689
 690     { SDLK_HOME, KEY_HOME },
 691     { SDLK_END, KEY_END },
 692     { SDLK_PAGEUP, KEY_PAGEUP },
 693     { SDLK_PAGEDOWN,  KEY_PAGEDOWN },
 694
 695     { SDLK_INSERT, KEY_INSERT },
 696     { SDLK_DELETE, KEY_DELETE },
 697     /*TODO: find a equivalent for SDL
 698     { , KEY_MEDIA_NEXT_TRACK }
 699     { , KEY_MEDIA_PREV_TRACK }
 700     { , KEY_VOLUME_MUTE }
 701     { , KEY_VOLUME_DOWN }
 702     { , KEY_VOLUME_UP }
 703     { , KEY_MEDIA_PLAY_PAUSE }
 704     { , KEY_MEDIA_PLAY_PAUSE }*/
 705
 706     { 0, 0 }
 707 };
 708
 709 static int ConvertKey(SDLKey sdl_key)
 710 {
 711     for (int i = 0; sdlkeys_to_vlckeys[i].sdl_key != 0; i++) {
 712         if (sdlkeys_to_vlckeys[i].sdl_key == sdl_key)
 713             return sdlkeys_to_vlckeys[i].vlckey;
 714     }
 715     return 0;
 716 }
 717