Use _WIN32 rather than WIN32 (same for WIN64)
[vlc.git] / 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 = vd->fmt;
168
169     /* */
170     vout_display_info_t info = vd->info;
171
172     /* Set main window's size */
173     int display_width;
174     int display_height;
175     if (vd->cfg->is_fullscreen) {
176         display_width  = sys->desktop_width;
177         display_height = sys->desktop_height;
178     } else {
179         display_width  = vd->cfg->display.width;
180         display_height = vd->cfg->display.height;
181     }
182
183     /* Initialize flags and cursor */
184     sys->display_flags = SDL_ANYFORMAT | SDL_HWPALETTE | SDL_HWSURFACE | SDL_DOUBLEBUF;
185     sys->display_flags |= vd->cfg->is_fullscreen ? SDL_FULLSCREEN : SDL_RESIZABLE;
186
187     sys->display_bpp = SDL_VideoModeOK(display_width, display_height,
188                                        16, sys->display_flags);
189     if (sys->display_bpp == 0) {
190         msg_Err(vd, "no video mode available");
191         goto error;
192     }
193     vout_display_DeleteWindow(vd, NULL);
194
195     sys->display = SDL_SetVideoMode(display_width, display_height,
196                                     sys->display_bpp, sys->display_flags);
197     if (!sys->display) {
198         msg_Err(vd, "cannot set video mode");
199         goto error;
200     }
201
202     /* We keep the surface locked forever */
203     SDL_LockSurface(sys->display);
204
205     /* */
206     vlc_fourcc_t forced_chroma = 0;
207     char *psz_chroma = var_InheritString(vd, "sdl-chroma");
208     if (psz_chroma) {
209         forced_chroma = vlc_fourcc_GetCodecFromString(VIDEO_ES, psz_chroma);
210         if (forced_chroma)
211             msg_Dbg(vd, "Forcing chroma to 0x%.8x (%4.4s)",
212                     forced_chroma, (const char*)&forced_chroma);
213         free(psz_chroma);
214     }
215
216     /* Try to open an overlay if requested */
217     sys->overlay = NULL;
218     const bool is_overlay = var_InheritBool(vd, "overlay");
219     if (is_overlay) {
220         static const struct
221         {
222             vlc_fourcc_t vlc;
223             uint32_t     sdl;
224         } vlc_to_sdl[] = {
225             { VLC_CODEC_YV12, SDL_YV12_OVERLAY },
226             { VLC_CODEC_I420, SDL_IYUV_OVERLAY },
227             { VLC_CODEC_YUYV, SDL_YUY2_OVERLAY },
228             { VLC_CODEC_UYVY, SDL_UYVY_OVERLAY },
229             { VLC_CODEC_YVYU, SDL_YVYU_OVERLAY },
230
231             { 0, 0 }
232         };
233         const vlc_fourcc_t forced_chromas[] = {
234             forced_chroma, 0
235         };
236         const vlc_fourcc_t *fallback_chromas =
237             vlc_fourcc_GetYUVFallback(fmt.i_chroma);
238         const vlc_fourcc_t *chromas = forced_chroma ? forced_chromas : fallback_chromas;
239
240         for (int pass = forced_chroma ? 1 : 0; pass < 2 && !sys->overlay; pass++) {
241             for (int i = 0; chromas[i] != 0; i++) {
242                 const vlc_fourcc_t vlc = chromas[i];
243
244                 uint32_t sdl = 0;
245                 for (int j = 0; vlc_to_sdl[j].vlc != 0 && !sdl; j++) {
246                     if (vlc_to_sdl[j].vlc == vlc)
247                         sdl = vlc_to_sdl[j].sdl;
248                 }
249                 if (!sdl)
250                     continue;
251
252                 sys->overlay = SDL_CreateYUVOverlay(fmt.i_width, fmt.i_height,
253                                                     sdl, sys->display);
254                 if (sys->overlay && !sys->overlay->hw_overlay && pass == 0) {
255                     /* Ignore non hardware overlay surface in first pass */
256                     SDL_FreeYUVOverlay(sys->overlay);
257                     sys->overlay = NULL;
258                 }
259                 if (sys->overlay) {
260                     /* We keep the surface locked forever */
261                     SDL_LockYUVOverlay(sys->overlay);
262
263                     fmt.i_chroma = vlc;
264                     sys->is_uv_swapped = vlc_fourcc_AreUVPlanesSwapped(fmt.i_chroma,
265                                                                        vd->fmt.i_chroma);
266                     if (sys->is_uv_swapped)
267                         fmt.i_chroma = vd->fmt.i_chroma;
268                     break;
269                 }
270             }
271         }
272     } else {
273         msg_Warn(vd, "SDL overlay disabled by the user");
274     }
275
276     /* */
277     vout_display_cfg_t place_cfg = *vd->cfg;
278     place_cfg.display.width  = display_width;
279     place_cfg.display.height = display_height;
280     vout_display_PlacePicture(&sys->place, &vd->source, &place_cfg, !sys->overlay);
281
282     /* If no overlay, fallback to software output */
283     if (!sys->overlay) {
284         /* */
285         switch (sys->display->format->BitsPerPixel) {
286         case 8:
287             fmt.i_chroma = VLC_CODEC_RGB8;
288             break;
289         case 15:
290             fmt.i_chroma = VLC_CODEC_RGB15;
291             break;
292         case 16:
293             fmt.i_chroma = VLC_CODEC_RGB16;
294             break;
295         case 24:
296             fmt.i_chroma = VLC_CODEC_RGB24;
297             break;
298         case 32:
299             fmt.i_chroma = VLC_CODEC_RGB32;
300             break;
301         default:
302             msg_Err(vd, "unknown screen depth %i",
303                     sys->display->format->BitsPerPixel);
304             goto error;
305         }
306
307         /* All we have is an RGB image with square pixels */
308         fmt.i_width  = display_width;
309         fmt.i_height = display_height;
310         fmt.i_rmask = sys->display->format->Rmask;
311         fmt.i_gmask = sys->display->format->Gmask;
312         fmt.i_bmask = sys->display->format->Bmask;
313
314         info.has_pictures_invalid = true;
315     }
316
317     if (vd->cfg->display.title)
318         SDL_WM_SetCaption(vd->cfg->display.title,
319                           vd->cfg->display.title);
320     else if (!sys->overlay)
321         SDL_WM_SetCaption(VOUT_TITLE " (software RGB SDL output)",
322                           VOUT_TITLE " (software RGB SDL output)");
323     else if (sys->overlay->hw_overlay)
324         SDL_WM_SetCaption(VOUT_TITLE " (hardware YUV SDL output)",
325                           VOUT_TITLE " (hardware YUV SDL output)");
326     else
327         SDL_WM_SetCaption(VOUT_TITLE " (software YUV SDL output)",
328                           VOUT_TITLE " (software YUV SDL output)");
329
330     /* Setup events */
331     SDL_EventState(SDL_KEYUP, SDL_IGNORE);               /* ignore keys up */
332
333     /* Setup vout_display now that everything is fine */
334     vd->fmt = fmt;
335     vd->info = info;
336
337     vd->pool    = Pool;
338     vd->prepare = NULL;
339     vd->display = PictureDisplay;
340     vd->control = Control;
341     vd->manage  = Manage;
342
343     /* */
344     vout_display_SendEventDisplaySize(vd, display_width, display_height, vd->cfg->is_fullscreen);
345     return VLC_SUCCESS;
346
347 error:
348     msg_Err(vd, "cannot set up SDL (%s)", SDL_GetError());
349
350     if (sys->display) {
351         SDL_UnlockSurface(sys->display);
352         SDL_FreeSurface(sys->display);
353     }
354
355     vlc_mutex_lock(&sdl_lock);
356     SDL_QuitSubSystem(SDL_INIT_VIDEO);
357     vlc_mutex_unlock(&sdl_lock);
358
359     free(sys);
360     return VLC_EGENERIC;
361 }
362
363 /**
364  * Close a SDL video output
365  */
366 static void Close(vlc_object_t *object)
367 {
368     vout_display_t *vd = (vout_display_t *)object;
369     vout_display_sys_t *sys = vd->sys;
370
371     if (sys->pool)
372         picture_pool_Delete(sys->pool);
373
374     if (sys->overlay) {
375         SDL_LockYUVOverlay(sys->overlay);
376         SDL_FreeYUVOverlay(sys->overlay);
377     }
378     SDL_UnlockSurface (sys->display);
379     SDL_FreeSurface(sys->display);
380
381     vlc_mutex_lock(&sdl_lock);
382     SDL_QuitSubSystem(SDL_INIT_VIDEO);
383     vlc_mutex_unlock(&sdl_lock);
384
385     free(sys);
386 }
387
388 /**
389  * Return a pool of direct buffers
390  */
391 static picture_pool_t *Pool(vout_display_t *vd, unsigned count)
392 {
393     vout_display_sys_t *sys = vd->sys;
394     VLC_UNUSED(count);
395
396     if (!sys->pool) {
397         picture_resource_t rsc;
398
399         memset(&rsc, 0, sizeof(rsc));
400
401         if (sys->overlay) {
402             SDL_Overlay *ol = sys->overlay;
403
404             for (int i = 0; i < ol->planes; i++) {
405                 rsc.p[i].p_pixels = ol->pixels[ i > 0 && sys->is_uv_swapped ? (3-i) : i];
406                 rsc.p[i].i_pitch  = ol->pitches[i > 0 && sys->is_uv_swapped ? (3-i) : i];
407                 rsc.p[i].i_lines  = ol->h;
408                 if (ol->format == SDL_YV12_OVERLAY ||
409                     ol->format == SDL_IYUV_OVERLAY)
410                     rsc.p[i].i_lines /= 2;
411
412             }
413         } else {
414             const int x = sys->place.x;
415             const int y = sys->place.y;
416
417             SDL_Surface *sf = sys->display;
418             SDL_FillRect(sf, NULL, 0);
419
420             assert(x >= 0 && y >= 0);
421             rsc.p[0].p_pixels = (uint8_t*)sf->pixels + y * sf->pitch + x * ((sf->format->BitsPerPixel + 7) / 8);
422             rsc.p[0].i_pitch  = sf->pitch;
423             rsc.p[0].i_lines  = vd->fmt.i_height;
424         }
425
426         picture_t *picture = picture_NewFromResource(&vd->fmt, &rsc);;
427         if (!picture)
428             return NULL;
429
430         sys->pool = picture_pool_New(1, &picture);
431     }
432
433     return sys->pool;
434 }
435
436 /**
437  * Display a picture
438  */
439 static void PictureDisplay(vout_display_t *vd, picture_t *p_pic, subpicture_t *p_subpicture)
440 {
441     vout_display_sys_t *sys = vd->sys;
442
443     if (sys->overlay) {
444         SDL_Rect disp;
445         disp.x = sys->place.x;
446         disp.y = sys->place.y;
447         disp.w = sys->place.width;
448         disp.h = sys->place.height;
449
450         SDL_UnlockYUVOverlay(sys->overlay);
451         SDL_DisplayYUVOverlay(sys->overlay , &disp);
452         SDL_LockYUVOverlay(sys->overlay);
453     } else {
454         SDL_Flip(sys->display);
455     }
456
457     picture_Release(p_pic);
458     VLC_UNUSED(p_subpicture);
459 }
460
461
462 /**
463  * Control for vout display
464  */
465 static int Control(vout_display_t *vd, int query, va_list args)
466 {
467     vout_display_sys_t *sys = vd->sys;
468
469     switch (query)
470     {
471     case VOUT_DISPLAY_HIDE_MOUSE:
472         SDL_ShowCursor(0);
473         return VLC_SUCCESS;
474
475     case VOUT_DISPLAY_CHANGE_DISPLAY_SIZE: {
476         const vout_display_cfg_t *cfg = va_arg(args, const vout_display_cfg_t *);
477
478         /* */
479         sys->display = SDL_SetVideoMode(cfg->display.width,
480                                         cfg->display.height,
481                                         sys->display_bpp, sys->display_flags);
482         if (!sys->display) {
483             sys->display = SDL_SetVideoMode(vd->cfg->display.width,
484                                             vd->cfg->display.height,
485                                             sys->display_bpp, sys->display_flags);
486             return VLC_EGENERIC;
487         }
488         if (sys->overlay)
489             vout_display_PlacePicture(&sys->place, &vd->source, cfg, !sys->overlay);
490         else
491             vout_display_SendEventPicturesInvalid(vd);
492         return VLC_SUCCESS;
493     }
494     case VOUT_DISPLAY_CHANGE_FULLSCREEN: {
495         vout_display_cfg_t cfg = *va_arg(args, const vout_display_cfg_t *);
496
497         /* Fix flags */
498         sys->display_flags &= ~(SDL_FULLSCREEN | SDL_RESIZABLE);
499         sys->display_flags |= cfg.is_fullscreen ? SDL_FULLSCREEN : SDL_RESIZABLE;
500
501         if (cfg.is_fullscreen) {
502             cfg.display.width = sys->desktop_width;
503             cfg.display.height = sys->desktop_height;
504         }
505
506         if (sys->overlay) {
507             sys->display = SDL_SetVideoMode(cfg.display.width, cfg.display.height,
508                                             sys->display_bpp, sys->display_flags);
509
510             vout_display_PlacePicture(&sys->place, &vd->source, &cfg, !sys->overlay);
511         }
512         vout_display_SendEventDisplaySize(vd, cfg.display.width, cfg.display.height, cfg.is_fullscreen);
513         return VLC_SUCCESS;
514     }
515     case VOUT_DISPLAY_CHANGE_ZOOM:
516     case VOUT_DISPLAY_CHANGE_DISPLAY_FILLED:
517     case VOUT_DISPLAY_CHANGE_SOURCE_ASPECT: {
518         const vout_display_cfg_t *cfg;
519         const video_format_t *source;
520
521         if (query == VOUT_DISPLAY_CHANGE_SOURCE_ASPECT) {
522             source = va_arg(args, const video_format_t *);
523             cfg = vd->cfg;
524         } else {
525             source = &vd->source;
526             cfg = va_arg(args, const vout_display_cfg_t *);
527         }
528         if (sys->overlay) {
529             sys->display = SDL_SetVideoMode(cfg->display.width, cfg->display.height,
530                                             sys->display_bpp, sys->display_flags);
531
532             vout_display_PlacePicture(&sys->place, source, cfg, !sys->overlay);
533         } else {
534             vout_display_SendEventPicturesInvalid(vd);
535         }
536         return VLC_SUCCESS;
537     }
538
539     case VOUT_DISPLAY_RESET_PICTURES: {
540         /* */
541         assert(!sys->overlay);
542
543         /* */
544         if (sys->pool)
545             picture_pool_Delete(sys->pool);
546         sys->pool = NULL;
547
548         vout_display_PlacePicture(&sys->place, &vd->source, vd->cfg, !sys->overlay);
549
550         /* */
551         vd->fmt.i_width  = sys->place.width;
552         vd->fmt.i_height = sys->place.height;
553         return VLC_SUCCESS;
554     }
555
556     case VOUT_DISPLAY_CHANGE_SOURCE_CROP:
557     case VOUT_DISPLAY_CHANGE_WINDOW_STATE:
558         /* I don't think it is possible to support with SDL:
559          * - crop
560          * - on top
561          */
562         return VLC_EGENERIC;
563
564     default:
565         msg_Err(vd, "Unsupported query in vout display SDL");
566         return VLC_EGENERIC;
567     }
568 }
569
570 /**
571  * Proccess pending event
572  */
573 static void Manage(vout_display_t *vd)
574 {
575     vout_display_sys_t *sys = vd->sys;
576     SDL_Event event;
577
578     /* */
579     while (SDL_PollEvent(&event)) {
580         switch (event.type) {
581         case SDL_QUIT:
582             vout_display_SendEventClose(vd);
583             break;
584
585         case SDL_KEYDOWN: {
586             /* convert the key if possible */
587             int key = ConvertKey(event.key.keysym.sym);
588
589             if (!key) {
590                 /* Find the right caracter */
591                 if ((event.key.keysym.unicode & 0xff80) == 0) {
592                     key = event.key.keysym.unicode & 0x7f;
593                     /* FIXME: find a better solution than this
594                               hack to find the right caracter */
595                     if (key >= 1 && key <= 26)
596                         key += 96;
597                     else if (key >= 65 && key <= 90)
598                         key += 32;
599                 }
600             }
601             if (!key)
602                 break;
603
604             if (event.key.keysym.mod & KMOD_SHIFT)
605                 key |= KEY_MODIFIER_SHIFT;
606             if (event.key.keysym.mod & KMOD_CTRL)
607                 key |= KEY_MODIFIER_CTRL;
608             if (event.key.keysym.mod & KMOD_ALT)
609                 key |= KEY_MODIFIER_ALT;
610             vout_display_SendEventKey(vd, key);
611             break;
612         }
613
614         case SDL_MOUSEBUTTONDOWN:
615         case SDL_MOUSEBUTTONUP: {
616             static const struct { int sdl; int vlc; } buttons[] = {
617                 { SDL_BUTTON_LEFT,      MOUSE_BUTTON_LEFT },
618                 { SDL_BUTTON_MIDDLE,    MOUSE_BUTTON_CENTER },
619                 { SDL_BUTTON_RIGHT,     MOUSE_BUTTON_RIGHT },
620                 { SDL_BUTTON_WHEELUP,   MOUSE_BUTTON_WHEEL_UP },
621                 { SDL_BUTTON_WHEELDOWN, MOUSE_BUTTON_WHEEL_DOWN },
622                 { -1, -1 },
623             };
624
625             SDL_ShowCursor(1);
626             for (int i = 0; buttons[i].sdl != -1; i++) {
627                 if (buttons[i].sdl == event.button.button) {
628                     if (event.type == SDL_MOUSEBUTTONDOWN)
629                         vout_display_SendEventMousePressed(vd, buttons[i].vlc);
630                     else
631                         vout_display_SendEventMouseReleased(vd, buttons[i].vlc);
632                 }
633             }
634             break;
635         }
636
637         case SDL_MOUSEMOTION: {
638             if (sys->place.width <= 0 || sys->place.height <= 0)
639                 break;
640
641             const int x = (int64_t)(event.motion.x - sys->place.x) * vd->source.i_width  / sys->place.width;
642             const int y = (int64_t)(event.motion.y - sys->place.y) * vd->source.i_height / sys->place.height;
643
644             SDL_ShowCursor(1);
645             vout_display_SendEventMouseMoved(vd, x, y);
646             break;
647         }
648
649         case SDL_VIDEORESIZE:
650             vout_display_SendEventDisplaySize(vd, event.resize.w, event.resize.h, vd->cfg->is_fullscreen);
651             break;
652
653         default:
654             break;
655         }
656     }
657
658 }
659
660 static const struct {
661     SDLKey sdl_key;
662     int    vlckey;
663
664 } sdlkeys_to_vlckeys[] = {
665     { SDLK_F1,  KEY_F1 },
666     { SDLK_F2,  KEY_F2 },
667     { SDLK_F3,  KEY_F3 },
668     { SDLK_F4,  KEY_F4 },
669     { SDLK_F5,  KEY_F5 },
670     { SDLK_F6,  KEY_F6 },
671     { SDLK_F7,  KEY_F7 },
672     { SDLK_F8,  KEY_F8 },
673     { SDLK_F9,  KEY_F9 },
674     { SDLK_F10, KEY_F10 },
675     { SDLK_F11, KEY_F11 },
676     { SDLK_F12, KEY_F12 },
677
678     { SDLK_RETURN, KEY_ENTER },
679     { SDLK_KP_ENTER, KEY_ENTER },
680     { SDLK_SPACE, ' ' },
681     { SDLK_ESCAPE, KEY_ESC },
682
683     { SDLK_MENU, KEY_MENU },
684     { SDLK_LEFT, KEY_LEFT },
685     { SDLK_RIGHT, KEY_RIGHT },
686     { SDLK_UP, KEY_UP },
687     { SDLK_DOWN, KEY_DOWN },
688
689     { SDLK_HOME, KEY_HOME },
690     { SDLK_END, KEY_END },
691     { SDLK_PAGEUP, KEY_PAGEUP },
692     { SDLK_PAGEDOWN,  KEY_PAGEDOWN },
693
694     { SDLK_INSERT, KEY_INSERT },
695     { SDLK_DELETE, KEY_DELETE },
696     /*TODO: find a equivalent for SDL 
697     { , KEY_MEDIA_NEXT_TRACK }
698     { , KEY_MEDIA_PREV_TRACK }
699     { , KEY_VOLUME_MUTE }
700     { , KEY_VOLUME_DOWN }
701     { , KEY_VOLUME_UP }
702     { , KEY_MEDIA_PLAY_PAUSE }
703     { , KEY_MEDIA_PLAY_PAUSE }*/
704
705     { 0, 0 }
706 };
707
708 static int ConvertKey(SDLKey sdl_key)
709 {
710     for (int i = 0; sdlkeys_to_vlckeys[i].sdl_key != 0; i++) {
711         if (sdlkeys_to_vlckeys[i].sdl_key == sdl_key)
712             return sdlkeys_to_vlckeys[i].vlckey;
713     }
714     return 0;
715 }
716