cmake/sdlchecks.cmake

   1 macro(FindLibraryAndSONAME _LIB)
   2   string(TOUPPER ${_LIB} _UPPERLNAME)
   3   string(REGEX REPLACE "\\-" "_" _LNAME "${_UPPERLNAME}")
   4
   5   find_library(${_LNAME}_LIB ${_LIB})
   6   if(${_LNAME}_LIB)
   7     # reduce the library name for shared linking
   8
   9     get_filename_component(_LIB_REALPATH ${${_LNAME}_LIB} REALPATH)  # resolves symlinks
  10     get_filename_component(_LIB_JUSTNAME ${_LIB_REALPATH} NAME)
  11
  12     if(APPLE)
  13       string(REGEX REPLACE "(\\.[0-9]*)\\.[0-9\\.]*dylib$" "\\1.dylib" _LIB_REGEXD "${_LIB_JUSTNAME}")
  14     else()
  15       string(REGEX REPLACE "(\\.[0-9]*)\\.[0-9\\.]*$" "\\1" _LIB_REGEXD "${_LIB_JUSTNAME}")
  16     endif()
  17
  18     SET(_DEBUG_FindSONAME FALSE)
  19     if(_DEBUG_FindSONAME)
  20       message_warn("DYNLIB OUTPUTVAR: ${_LIB} ... ${_LNAME}_LIB")
  21       message_warn("DYNLIB ORIGINAL LIB: ${_LIB} ... ${${_LNAME}_LIB}")
  22       message_warn("DYNLIB REALPATH LIB: ${_LIB} ... ${_LIB_REALPATH}")
  23       message_warn("DYNLIB JUSTNAME LIB: ${_LIB} ... ${_LIB_JUSTNAME}")
  24       message_warn("DYNLIB REGEX'd LIB: ${_LIB} ... ${_LIB_REGEXD}")
  25     endif()
  26
  27     message(STATUS "dynamic lib${_LIB} -> ${_LIB_REGEXD}")
  28     set(${_LNAME}_LIB_SONAME ${_LIB_REGEXD})
  29   endif()
  30 endmacro()
  31
  32 macro(CheckDLOPEN)
  33   check_function_exists(dlopen HAVE_DLOPEN)
  34   if(NOT HAVE_DLOPEN)
  35     foreach(_LIBNAME dl tdl)
  36       check_library_exists("${_LIBNAME}" "dlopen" "" DLOPEN_LIB)
  37       if(DLOPEN_LIB)
  38         list(APPEND EXTRA_LIBS ${_LIBNAME})
  39         set(_DLLIB ${_LIBNAME})
  40         set(HAVE_DLOPEN TRUE)
  41         break()
  42       endif()
  43     endforeach()
  44   endif()
  45
  46   if(HAVE_DLOPEN)
  47     if(_DLLIB)
  48       set(CMAKE_REQUIRED_LIBRARIES ${_DLLIB})
  49     endif()
  50     check_c_source_compiles("
  51        #include <dlfcn.h>
  52        int main(int argc, char **argv) {
  53          void *handle = dlopen(\"\", RTLD_NOW);
  54          const char *loaderror = (char *) dlerror();
  55        }" HAVE_DLOPEN)
  56     set(CMAKE_REQUIRED_LIBRARIES)
  57   endif()
  58
  59   if (HAVE_DLOPEN)
  60     set(SDL_LOADSO_DLOPEN 1)
  61     set(HAVE_SDL_DLOPEN TRUE)
  62     file(GLOB DLOPEN_SOURCES ${SDL2_SOURCE_DIR}/src/loadso/dlopen/*.c)
  63     set(SOURCE_FILES ${SOURCE_FILES} ${DLOPEN_SOURCES})
  64     set(HAVE_SDL_LOADSO TRUE)
  65   endif()
  66 endmacro()
  67
  68 # Requires:
  69 # - n/a
  70 macro(CheckOSS)
  71   if(OSS)
  72     set(OSS_HEADER_FILE "sys/soundcard.h")
  73     check_c_source_compiles("
  74         #include <sys/soundcard.h>
  75         int main() { int arg = SNDCTL_DSP_SETFRAGMENT; }" OSS_FOUND)
  76     if(NOT OSS_FOUND)
  77       set(OSS_HEADER_FILE "soundcard.h")
  78       check_c_source_compiles("
  79           #include <soundcard.h>
  80           int main() { int arg = SNDCTL_DSP_SETFRAGMENT; }" OSS_FOUND)
  81     endif()
  82
  83     if(OSS_FOUND)
  84       set(HAVE_OSS TRUE)
  85       file(GLOB OSS_SOURCES ${SDL2_SOURCE_DIR}/src/audio/dsp/*.c)
  86       if(OSS_HEADER_FILE STREQUAL "soundcard.h")
  87         set(SDL_AUDIO_DRIVER_OSS_SOUNDCARD_H 1)
  88       endif()
  89       set(SDL_AUDIO_DRIVER_OSS 1)
  90       set(SOURCE_FILES ${SOURCE_FILES} ${OSS_SOURCES})
  91       if(NETBSD OR OPENBSD)
  92         list(APPEND EXTRA_LIBS ossaudio)
  93       endif()
  94       set(HAVE_SDL_AUDIO TRUE)
  95     endif()
  96   endif()
  97 endmacro()
  98
  99 # Requires:
 100 # - n/a
 101 # Optional:
 102 # - ALSA_SHARED opt
 103 # - HAVE_DLOPEN opt
 104 macro(CheckALSA)
 105   if(ALSA)
 106     CHECK_INCLUDE_FILE(alsa/asoundlib.h HAVE_ASOUNDLIB_H)
 107     if(HAVE_ASOUNDLIB_H)
 108       CHECK_LIBRARY_EXISTS(asound snd_pcm_recover "" HAVE_LIBASOUND)
 109     endif()
 110     if(HAVE_LIBASOUND)
 111       set(HAVE_ALSA TRUE)
 112       file(GLOB ALSA_SOURCES ${SDL2_SOURCE_DIR}/src/audio/alsa/*.c)
 113       set(SOURCE_FILES ${SOURCE_FILES} ${ALSA_SOURCES})
 114       set(SDL_AUDIO_DRIVER_ALSA 1)
 115       if(ALSA_SHARED)
 116         if(NOT HAVE_DLOPEN)
 117           message_warn("You must have SDL_LoadObject() support for dynamic ALSA loading")
 118         else()
 119           FindLibraryAndSONAME("asound")
 120           set(SDL_AUDIO_DRIVER_ALSA_DYNAMIC "\"${ASOUND_LIB_SONAME}\"")
 121           set(HAVE_ALSA_SHARED TRUE)
 122         endif()
 123       else()
 124         list(APPEND EXTRA_LIBS asound)
 125       endif()
 126       set(HAVE_SDL_AUDIO TRUE)
 127     endif()
 128   endif()
 129 endmacro()
 130
 131 # Requires:
 132 # - PkgCheckModules
 133 # Optional:
 134 # - PULSEAUDIO_SHARED opt
 135 # - HAVE_DLOPEN opt
 136 macro(CheckPulseAudio)
 137   if(PULSEAUDIO)
 138     pkg_check_modules(PKG_PULSEAUDIO libpulse-simple)
 139     if(PKG_PULSEAUDIO_FOUND)
 140       set(HAVE_PULSEAUDIO TRUE)
 141       file(GLOB PULSEAUDIO_SOURCES ${SDL2_SOURCE_DIR}/src/audio/pulseaudio/*.c)
 142       set(SOURCE_FILES ${SOURCE_FILES} ${PULSEAUDIO_SOURCES})
 143       set(SDL_AUDIO_DRIVER_PULSEAUDIO 1)
 144       list(APPEND EXTRA_CFLAGS ${PKG_PULSEAUDIO_CFLAGS})
 145       if(PULSEAUDIO_SHARED)
 146         if(NOT HAVE_DLOPEN)
 147           message_warn("You must have SDL_LoadObject() support for dynamic PulseAudio loading")
 148         else()
 149           FindLibraryAndSONAME("pulse-simple")
 150           set(SDL_AUDIO_DRIVER_PULSEAUDIO_DYNAMIC "\"${PULSE_SIMPLE_LIB_SONAME}\"")
 151           set(HAVE_PULSEAUDIO_SHARED TRUE)
 152         endif()
 153       else()
 154         list(APPEND EXTRA_LDFLAGS ${PKG_PULSEAUDIO_LDFLAGS})
 155       endif()
 156       set(HAVE_SDL_AUDIO TRUE)
 157     endif()
 158   endif()
 159 endmacro()
 160
 161 # Requires:
 162 # - PkgCheckModules
 163 # Optional:
 164 # - JACK_SHARED opt
 165 # - HAVE_DLOPEN opt
 166 macro(CheckJACK)
 167   if(JACK)
 168     pkg_check_modules(PKG_JACK jack)
 169     if(PKG_JACK_FOUND)
 170       set(HAVE_JACK TRUE)
 171       file(GLOB JACK_SOURCES ${SDL2_SOURCE_DIR}/src/audio/jack/*.c)
 172       set(SOURCE_FILES ${SOURCE_FILES} ${JACK_SOURCES})
 173       set(SDL_AUDIO_DRIVER_JACK 1)
 174       list(APPEND EXTRA_CFLAGS ${PKG_JACK_CFLAGS})
 175       if(JACK_SHARED)
 176         if(NOT HAVE_DLOPEN)
 177           message_warn("You must have SDL_LoadObject() support for dynamic JACK audio loading")
 178         else()
 179           FindLibraryAndSONAME("jack")
 180           set(SDL_AUDIO_DRIVER_JACK_DYNAMIC "\"${JACK_LIB_SONAME}\"")
 181           set(HAVE_JACK_SHARED TRUE)
 182         endif()
 183       else()
 184         list(APPEND EXTRA_LDFLAGS ${PKG_JACK_LDFLAGS})
 185       endif()
 186       set(HAVE_SDL_AUDIO TRUE)
 187     endif()
 188   endif()
 189 endmacro()
 190
 191 # Requires:
 192 # - PkgCheckModules
 193 # Optional:
 194 # - ESD_SHARED opt
 195 # - HAVE_DLOPEN opt
 196 macro(CheckESD)
 197   if(ESD)
 198     pkg_check_modules(PKG_ESD esound)
 199     if(PKG_ESD_FOUND)
 200       set(HAVE_ESD TRUE)
 201       file(GLOB ESD_SOURCES ${SDL2_SOURCE_DIR}/src/audio/esd/*.c)
 202       set(SOURCE_FILES ${SOURCE_FILES} ${ESD_SOURCES})
 203       set(SDL_AUDIO_DRIVER_ESD 1)
 204       list(APPEND EXTRA_CFLAGS ${PKG_ESD_CFLAGS})
 205       if(ESD_SHARED)
 206         if(NOT HAVE_DLOPEN)
 207           message_warn("You must have SDL_LoadObject() support for dynamic ESD loading")
 208         else()
 209           FindLibraryAndSONAME(esd)
 210           set(SDL_AUDIO_DRIVER_ESD_DYNAMIC "\"${ESD_LIB_SONAME}\"")
 211           set(HAVE_ESD_SHARED TRUE)
 212         endif()
 213       else()
 214         list(APPEND EXTRA_LDFLAGS ${PKG_ESD_LDFLAGS})
 215       endif()
 216       set(HAVE_SDL_AUDIO TRUE)
 217     endif()
 218   endif()
 219 endmacro()
 220
 221 # Requires:
 222 # - n/a
 223 # Optional:
 224 # - ARTS_SHARED opt
 225 # - HAVE_DLOPEN opt
 226 macro(CheckARTS)
 227   if(ARTS)
 228     find_program(ARTS_CONFIG arts-config)
 229     if(ARTS_CONFIG)
 230       execute_process(CMD_ARTSCFLAGS ${ARTS_CONFIG} --cflags
 231         OUTPUT_VARIABLE ARTS_CFLAGS OUTPUT_STRIP_TRAILING_WHITESPACE)
 232       list(APPEND EXTRA_CFLAGS ${ARTS_CFLAGS})
 233       execute_process(CMD_ARTSLIBS ${ARTS_CONFIG} --libs
 234         OUTPUT_VARIABLE ARTS_LIBS OUTPUT_STRIP_TRAILING_WHITESPACE)
 235       file(GLOB ARTS_SOURCES ${SDL2_SOURCE_DIR}/src/audio/arts/*.c)
 236       set(SOURCE_FILES ${SOURCE_FILES} ${ARTS_SOURCES})
 237       set(SDL_AUDIO_DRIVER_ARTS 1)
 238       set(HAVE_ARTS TRUE)
 239       if(ARTS_SHARED)
 240         if(NOT HAVE_DLOPEN)
 241           message_warn("You must have SDL_LoadObject() support for dynamic ARTS loading")
 242         else()
 243           # TODO
 244           FindLibraryAndSONAME(artsc)
 245           set(SDL_AUDIO_DRIVER_ARTS_DYNAMIC "\"${ARTSC_LIB_SONAME}\"")
 246           set(HAVE_ARTS_SHARED TRUE)
 247         endif()
 248       else()
 249         list(APPEND EXTRA_LDFLAGS ${ARTS_LIBS})
 250       endif()
 251       set(HAVE_SDL_AUDIO TRUE)
 252     endif()
 253   endif()
 254 endmacro()
 255
 256 # Requires:
 257 # - n/a
 258 # Optional:
 259 # - NAS_SHARED opt
 260 # - HAVE_DLOPEN opt
 261 macro(CheckNAS)
 262   if(NAS)
 263     # TODO: set include paths properly, so the NAS headers are found
 264     check_include_file(audio/audiolib.h HAVE_NAS_H)
 265     find_library(D_NAS_LIB audio)
 266     if(HAVE_NAS_H AND D_NAS_LIB)
 267       set(HAVE_NAS TRUE)
 268       file(GLOB NAS_SOURCES ${SDL2_SOURCE_DIR}/src/audio/nas/*.c)
 269       set(SOURCE_FILES ${SOURCE_FILES} ${NAS_SOURCES})
 270       set(SDL_AUDIO_DRIVER_NAS 1)
 271       if(NAS_SHARED)
 272         if(NOT HAVE_DLOPEN)
 273           message_warn("You must have SDL_LoadObject() support for dynamic NAS loading")
 274         else()
 275           FindLibraryAndSONAME("audio")
 276           set(SDL_AUDIO_DRIVER_NAS_DYNAMIC "\"${AUDIO_LIB_SONAME}\"")
 277           set(HAVE_NAS_SHARED TRUE)
 278         endif()
 279       else()
 280         list(APPEND EXTRA_LIBS ${D_NAS_LIB})
 281       endif()
 282       set(HAVE_SDL_AUDIO TRUE)
 283     endif()
 284   endif()
 285 endmacro()
 286
 287 # Requires:
 288 # - n/a
 289 # Optional:
 290 # - SNDIO_SHARED opt
 291 # - HAVE_DLOPEN opt
 292 macro(CheckSNDIO)
 293   if(SNDIO)
 294     # TODO: set include paths properly, so the sndio headers are found
 295     check_include_file(sndio.h HAVE_SNDIO_H)
 296     find_library(D_SNDIO_LIB sndio)
 297     if(HAVE_SNDIO_H AND D_SNDIO_LIB)
 298       set(HAVE_SNDIO TRUE)
 299       file(GLOB SNDIO_SOURCES ${SDL2_SOURCE_DIR}/src/audio/sndio/*.c)
 300       set(SOURCE_FILES ${SOURCE_FILES} ${SNDIO_SOURCES})
 301       set(SDL_AUDIO_DRIVER_SNDIO 1)
 302       if(SNDIO_SHARED)
 303         if(NOT HAVE_DLOPEN)
 304           message_warn("You must have SDL_LoadObject() support for dynamic sndio loading")
 305         else()
 306           FindLibraryAndSONAME("sndio")
 307           set(SDL_AUDIO_DRIVER_SNDIO_DYNAMIC "\"${SNDIO_LIB_SONAME}\"")
 308           set(HAVE_SNDIO_SHARED TRUE)
 309         endif()
 310       else()
 311         list(APPEND EXTRA_LIBS ${D_SNDIO_LIB})
 312       endif()
 313       set(HAVE_SDL_AUDIO TRUE)
 314     endif()
 315   endif()
 316 endmacro()
 317
 318 # Requires:
 319 # - PkgCheckModules
 320 # Optional:
 321 # - FUSIONSOUND_SHARED opt
 322 # - HAVE_DLOPEN opt
 323 macro(CheckFusionSound)
 324   if(FUSIONSOUND)
 325     pkg_check_modules(PKG_FUSIONSOUND fusionsound>=1.0.0)
 326     if(PKG_FUSIONSOUND_FOUND)
 327       set(HAVE_FUSIONSOUND TRUE)
 328       file(GLOB FUSIONSOUND_SOURCES ${SDL2_SOURCE_DIR}/src/audio/fusionsound/*.c)
 329       set(SOURCE_FILES ${SOURCE_FILES} ${FUSIONSOUND_SOURCES})
 330       set(SDL_AUDIO_DRIVER_FUSIONSOUND 1)
 331       list(APPEND EXTRA_CFLAGS ${PKG_FUSIONSOUND_CFLAGS})
 332       if(FUSIONSOUND_SHARED)
 333         if(NOT HAVE_DLOPEN)
 334           message_warn("You must have SDL_LoadObject() support for dynamic FusionSound loading")
 335         else()
 336           FindLibraryAndSONAME("fusionsound")
 337           set(SDL_AUDIO_DRIVER_FUSIONSOUND_DYNAMIC "\"${FUSIONSOUND_LIB_SONAME}\"")
 338           set(HAVE_FUSIONSOUND_SHARED TRUE)
 339         endif()
 340       else()
 341         list(APPEND EXTRA_LDFLAGS ${PKG_FUSIONSOUND_LDFLAGS})
 342       endif()
 343       set(HAVE_SDL_AUDIO TRUE)
 344     endif()
 345   endif()
 346 endmacro()
 347
 348 # Requires:
 349 # - LIBSAMPLERATE
 350 # Optional:
 351 # - LIBSAMPLERATE_SHARED opt
 352 # - HAVE_DLOPEN opt
 353 macro(CheckLibSampleRate)
 354   if(LIBSAMPLERATE)
 355     check_include_file(samplerate.h HAVE_LIBSAMPLERATE_H)
 356     if(HAVE_LIBSAMPLERATE_H)
 357       set(HAVE_LIBSAMPLERATE TRUE)
 358       if(LIBSAMPLERATE_SHARED)
 359         if(NOT HAVE_DLOPEN)
 360           message_warn("You must have SDL_LoadObject() support for dynamic libsamplerate loading")
 361         else()
 362           FindLibraryAndSONAME("samplerate")
 363           set(SDL_LIBSAMPLERATE_DYNAMIC "\"${SAMPLERATE_LIB_SONAME}\"")
 364           set(HAVE_LIBSAMPLERATE_SHARED TRUE)
 365         endif()
 366       else()
 367         list(APPEND EXTRA_LDFLAGS -lsamplerate)
 368       endif()
 369     endif()
 370   endif()
 371 endmacro()
 372
 373 # Requires:
 374 # - n/a
 375 # Optional:
 376 # - X11_SHARED opt
 377 # - HAVE_DLOPEN opt
 378 macro(CheckX11)
 379   if(VIDEO_X11)
 380     foreach(_LIB X11 Xext Xcursor Xinerama Xi Xrandr Xrender Xss Xxf86vm)
 381         FindLibraryAndSONAME("${_LIB}")
 382     endforeach()
 383
 384     find_path(X_INCLUDEDIR X11/Xlib.h)
 385     if(X_INCLUDEDIR)
 386       set(X_CFLAGS "-I${X_INCLUDEDIR}")
 387     endif()
 388
 389     check_include_file(X11/Xcursor/Xcursor.h HAVE_XCURSOR_H)
 390     check_include_file(X11/extensions/Xinerama.h HAVE_XINERAMA_H)
 391     check_include_file(X11/extensions/XInput2.h HAVE_XINPUT_H)
 392     check_include_file(X11/extensions/Xrandr.h HAVE_XRANDR_H)
 393     check_include_file(X11/extensions/Xrender.h HAVE_XRENDER_H)
 394     check_include_file(X11/extensions/scrnsaver.h HAVE_XSS_H)
 395     check_include_file(X11/extensions/shape.h HAVE_XSHAPE_H)
 396     check_include_files("X11/Xlib.h;X11/extensions/xf86vmode.h" HAVE_XF86VM_H)
 397     check_include_files("X11/Xlib.h;X11/Xproto.h;X11/extensions/Xext.h" HAVE_XEXT_H)
 398
 399     if(X11_LIB)
 400       if(NOT HAVE_XEXT_H)
 401         message_error("Missing Xext.h, maybe you need to install the libxext-dev package?")
 402       endif()
 403
 404       set(HAVE_VIDEO_X11 TRUE)
 405       set(HAVE_SDL_VIDEO TRUE)
 406
 407       file(GLOB X11_SOURCES ${SDL2_SOURCE_DIR}/src/video/x11/*.c)
 408       set(SOURCE_FILES ${SOURCE_FILES} ${X11_SOURCES})
 409       set(SDL_VIDEO_DRIVER_X11 1)
 410
 411       if(APPLE)
 412         set(X11_SHARED OFF)
 413       endif()
 414
 415       check_function_exists("shmat" HAVE_SHMAT)
 416       if(NOT HAVE_SHMAT)
 417         check_library_exists(ipc shmat "" HAVE_SHMAT)
 418         if(HAVE_SHMAT)
 419           list(APPEND EXTRA_LIBS ipc)
 420         endif()
 421         if(NOT HAVE_SHMAT)
 422           add_definitions(-DNO_SHARED_MEMORY)
 423           set(X_CFLAGS "${X_CFLAGS} -DNO_SHARED_MEMORY")
 424         endif()
 425       endif()
 426
 427       if(X11_SHARED)
 428         if(NOT HAVE_DLOPEN)
 429           message_warn("You must have SDL_LoadObject() support for dynamic X11 loading")
 430           set(HAVE_X11_SHARED FALSE)
 431         else()
 432           set(HAVE_X11_SHARED TRUE)
 433         endif()
 434         if(HAVE_X11_SHARED)
 435           set(SDL_VIDEO_DRIVER_X11_DYNAMIC "\"${X11_LIB_SONAME}\"")
 436           set(SDL_VIDEO_DRIVER_X11_DYNAMIC_XEXT "\"${XEXT_LIB_SONAME}\"")
 437         else()
 438           list(APPEND EXTRA_LIBS ${X11_LIB} ${XEXT_LIB})
 439         endif()
 440       endif()
 441
 442       set(SDL_CFLAGS "${SDL_CFLAGS} ${X_CFLAGS}")
 443
 444       set(CMAKE_REQUIRED_LIBRARIES ${X11_LIB} ${X11_LIB})
 445       check_c_source_compiles("
 446           #include <X11/Xlib.h>
 447           #include <X11/Xproto.h>
 448           #include <X11/extensions/Xext.h>
 449           #include <X11/extensions/extutil.h>
 450           extern XExtDisplayInfo* XextAddDisplay(XExtensionInfo* a,Display* b,_Xconst char* c,XExtensionHooks* d,int e,XPointer f);
 451           int main(int argc, char **argv) {}" HAVE_CONST_XEXT_ADDDISPLAY)
 452       if(HAVE_CONST_XEXT_ADDDISPLAY)
 453         set(SDL_VIDEO_DRIVER_X11_CONST_PARAM_XEXTADDDISPLAY 1)
 454       endif()
 455
 456       check_c_source_compiles("
 457           #include <X11/Xlib.h>
 458           int main(int argc, char **argv) {
 459             Display *display;
 460             XEvent event;
 461             XGenericEventCookie *cookie = &event.xcookie;
 462             XNextEvent(display, &event);
 463             XGetEventData(display, cookie);
 464             XFreeEventData(display, cookie); }" HAVE_XGENERICEVENT)
 465       if(HAVE_XGENERICEVENT)
 466         set(SDL_VIDEO_DRIVER_X11_SUPPORTS_GENERIC_EVENTS 1)
 467       endif()
 468
 469       check_function_exists(XkbKeycodeToKeysym SDL_VIDEO_DRIVER_X11_HAS_XKBKEYCODETOKEYSYM)
 470
 471       if(VIDEO_X11_XCURSOR AND HAVE_XCURSOR_H)
 472         set(HAVE_VIDEO_X11_XCURSOR TRUE)
 473         if(HAVE_X11_SHARED AND XCURSOR_LIB)
 474           set(SDL_VIDEO_DRIVER_X11_DYNAMIC_XCURSOR "\"${XCURSOR_LIB_SONAME}\"")
 475         else()
 476           list(APPEND EXTRA_LIBS ${XCURSOR_LIB})
 477         endif()
 478         set(SDL_VIDEO_DRIVER_X11_XCURSOR 1)
 479       endif()
 480
 481       if(VIDEO_X11_XINERAMA AND HAVE_XINERAMA_H)
 482         set(HAVE_VIDEO_X11_XINERAMA TRUE)
 483         if(HAVE_X11_SHARED AND XINERAMA_LIB)
 484           set(SDL_VIDEO_DRIVER_X11_DYNAMIC_XINERAMA "\"${XINERAMA_LIB_SONAME}\"")
 485         else()
 486           list(APPEND EXTRA_LIBS ${XINERAMA_LIB})
 487         endif()
 488         set(SDL_VIDEO_DRIVER_X11_XINERAMA 1)
 489       endif()
 490
 491       if(VIDEO_X11_XINPUT AND HAVE_XINPUT_H)
 492         set(HAVE_VIDEO_X11_XINPUT TRUE)
 493         if(HAVE_X11_SHARED AND XI_LIB)
 494           set(SDL_VIDEO_DRIVER_X11_DYNAMIC_XINPUT2 "\"${XI_LIB_SONAME}\"")
 495         else()
 496           list(APPEND EXTRA_LIBS ${XI_LIB})
 497         endif()
 498         set(SDL_VIDEO_DRIVER_X11_XINPUT2 1)
 499
 500         # Check for multitouch
 501         check_c_source_compiles("
 502             #include <X11/Xlib.h>
 503             #include <X11/Xproto.h>
 504             #include <X11/extensions/XInput2.h>
 505             int event_type = XI_TouchBegin;
 506             XITouchClassInfo *t;
 507             Status XIAllowTouchEvents(Display *a,int b,unsigned int c,Window d,int f)
 508             {
 509               return (Status)0;
 510             }
 511             int main(int argc, char **argv) {}" HAVE_XINPUT2_MULTITOUCH)
 512         if(HAVE_XINPUT2_MULTITOUCH)
 513           set(SDL_VIDEO_DRIVER_X11_XINPUT2_SUPPORTS_MULTITOUCH 1)
 514         endif()
 515       endif()
 516
 517       if(VIDEO_X11_XRANDR AND HAVE_XRANDR_H)
 518         if(HAVE_X11_SHARED AND XRANDR_LIB)
 519           set(SDL_VIDEO_DRIVER_X11_DYNAMIC_XRANDR "\"${XRANDR_LIB_SONAME}\"")
 520         else()
 521           list(APPEND EXTRA_LIBS ${XRANDR_LIB})
 522         endif()
 523         set(SDL_VIDEO_DRIVER_X11_XRANDR 1)
 524         set(HAVE_VIDEO_X11_XRANDR TRUE)
 525       endif()
 526
 527       if(VIDEO_X11_XSCRNSAVER AND HAVE_XSS_H)
 528         if(HAVE_X11_SHARED AND XSS_LIB)
 529           set(SDL_VIDEO_DRIVER_X11_DYNAMIC_XSS "\"${XSS_LIB_SONAME}\"")
 530         else()
 531           list(APPEND EXTRA_LIBS ${XSS_LIB})
 532         endif()
 533         set(SDL_VIDEO_DRIVER_X11_XSCRNSAVER 1)
 534         set(HAVE_VIDEO_X11_XSCRNSAVER TRUE)
 535       endif()
 536
 537       if(VIDEO_X11_XSHAPE AND HAVE_XSHAPE_H)
 538         set(SDL_VIDEO_DRIVER_X11_XSHAPE 1)
 539         set(HAVE_VIDEO_X11_XSHAPE TRUE)
 540       endif()
 541
 542       if(VIDEO_X11_XVM AND HAVE_XF86VM_H)
 543         if(HAVE_X11_SHARED AND XXF86VM_LIB)
 544           set(SDL_VIDEO_DRIVER_X11_DYNAMIC_XVIDMODE "\"${XXF86VM_LIB_SONAME}\"")
 545         else()
 546           list(APPEND EXTRA_LIBS ${XXF86VM_LIB})
 547         endif()
 548         set(SDL_VIDEO_DRIVER_X11_XVIDMODE 1)
 549         set(HAVE_VIDEO_X11_XVM TRUE)
 550       endif()
 551
 552       set(CMAKE_REQUIRED_LIBRARIES)
 553     endif()
 554   endif()
 555 endmacro()
 556
 557 # Requires:
 558 # - EGL
 559 # - PkgCheckModules
 560 # Optional:
 561 # - MIR_SHARED opt
 562 # - HAVE_DLOPEN opt
 563 macro(CheckMir)
 564     if(VIDEO_MIR)
 565         find_library(MIR_LIB mirclient mircommon egl)
 566         pkg_check_modules(MIR_TOOLKIT mirclient>=0.26 mircommon)
 567         pkg_check_modules(EGL egl)
 568         pkg_check_modules(XKB xkbcommon)
 569
 570         if (MIR_LIB AND MIR_TOOLKIT_FOUND AND EGL_FOUND AND XKB_FOUND)
 571             set(HAVE_VIDEO_MIR TRUE)
 572             set(HAVE_SDL_VIDEO TRUE)
 573
 574             file(GLOB MIR_SOURCES ${SDL2_SOURCE_DIR}/src/video/mir/*.c)
 575             set(SOURCE_FILES ${SOURCE_FILES} ${MIR_SOURCES})
 576             set(SDL_VIDEO_DRIVER_MIR 1)
 577
 578             list(APPEND EXTRA_CFLAGS ${MIR_TOOLKIT_CFLAGS} ${EGL_CFLAGS} ${XKB_CFLAGS})
 579
 580             if(MIR_SHARED)
 581                 if(NOT HAVE_DLOPEN)
 582                     message_warn("You must have SDL_LoadObject() support for dynamic Mir loading")
 583                 else()
 584                     FindLibraryAndSONAME(mirclient)
 585                     FindLibraryAndSONAME(xkbcommon)
 586                     set(SDL_VIDEO_DRIVER_MIR_DYNAMIC "\"${MIRCLIENT_LIB_SONAME}\"")
 587                     set(SDL_VIDEO_DRIVER_MIR_DYNAMIC_XKBCOMMON "\"${XKBCOMMON_LIB_SONAME}\"")
 588                     set(HAVE_MIR_SHARED TRUE)
 589                 endif()
 590             else()
 591                 set(EXTRA_LIBS ${MIR_TOOLKIT_LIBRARIES} ${EXTRA_LIBS})
 592             endif()
 593         endif()
 594     endif()
 595 endmacro()
 596
 597 macro(WaylandProtocolGen _SCANNER _XML _PROTL)
 598     set(_WAYLAND_PROT_C_CODE "${CMAKE_CURRENT_BINARY_DIR}/wayland-generated-protocols/${_PROTL}-protocol.c")
 599     set(_WAYLAND_PROT_H_CODE "${CMAKE_CURRENT_BINARY_DIR}/wayland-generated-protocols/${_PROTL}-client-protocol.h")
 600
 601     add_custom_command(
 602         OUTPUT "${_WAYLAND_PROT_H_CODE}"
 603         DEPENDS "${_XML}"
 604         COMMAND "${_SCANNER}"
 605         ARGS client-header "${_XML}" "${_WAYLAND_PROT_H_CODE}"
 606     )
 607
 608     add_custom_command(
 609         OUTPUT "${_WAYLAND_PROT_C_CODE}"
 610         DEPENDS "${_WAYLAND_PROT_H_CODE}"
 611         COMMAND "${_SCANNER}"
 612         ARGS code "${_XML}" "${_WAYLAND_PROT_C_CODE}"
 613     )
 614
 615     set(SOURCE_FILES ${SOURCE_FILES} "${_WAYLAND_PROT_C_CODE}")
 616 endmacro()
 617
 618 # Requires:
 619 # - EGL
 620 # - PkgCheckModules
 621 # Optional:
 622 # - WAYLAND_SHARED opt
 623 # - HAVE_DLOPEN opt
 624 macro(CheckWayland)
 625   if(VIDEO_WAYLAND)
 626     pkg_check_modules(WAYLAND wayland-client wayland-scanner wayland-protocols wayland-egl wayland-cursor egl xkbcommon xdg-shell-client text-client tizen-extension-client)
 627
 628     # We have to generate some protocol interface code for some various Wayland features.
 629     if(WAYLAND_FOUND)
 630       execute_process(
 631         COMMAND ${PKG_CONFIG_EXECUTABLE} --variable=pkgdatadir wayland-client
 632         WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
 633         RESULT_VARIABLE WAYLAND_CORE_PROTOCOL_DIR_RC
 634         OUTPUT_VARIABLE WAYLAND_CORE_PROTOCOL_DIR
 635         ERROR_QUIET
 636         OUTPUT_STRIP_TRAILING_WHITESPACE
 637       )
 638       if(NOT WAYLAND_CORE_PROTOCOL_DIR_RC EQUAL 0)
 639         set(WAYLAND_FOUND FALSE)
 640       endif()
 641     endif()
 642
 643     if(WAYLAND_FOUND)
 644       execute_process(
 645         COMMAND ${PKG_CONFIG_EXECUTABLE} --variable=pkgdatadir wayland-protocols
 646         WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
 647         RESULT_VARIABLE WAYLAND_PROTOCOLS_DIR_RC
 648         OUTPUT_VARIABLE WAYLAND_PROTOCOLS_DIR
 649         ERROR_QUIET
 650         OUTPUT_STRIP_TRAILING_WHITESPACE
 651       )
 652       if(NOT WAYLAND_PROTOCOLS_DIR_RC EQUAL 0)
 653         set(WAYLAND_FOUND FALSE)
 654       endif()
 655     endif()
 656
 657     if(WAYLAND_FOUND)
 658       execute_process(
 659         COMMAND ${PKG_CONFIG_EXECUTABLE} --variable=wayland_scanner wayland-scanner
 660         WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
 661         RESULT_VARIABLE WAYLAND_SCANNER_RC
 662         OUTPUT_VARIABLE WAYLAND_SCANNER
 663         ERROR_QUIET
 664         OUTPUT_STRIP_TRAILING_WHITESPACE
 665       )
 666       if(NOT WAYLAND_SCANNER_RC EQUAL 0)
 667         set(WAYLAND_FOUND FALSE)
 668       endif()
 669     endif()
 670
 671     if(WAYLAND_FOUND)
 672       link_directories(
 673           ${WAYLAND_LIBRARY_DIRS}
 674       )
 675       include_directories(
 676           ${WAYLAND_INCLUDE_DIRS}
 677       )
 678       set(HAVE_VIDEO_WAYLAND TRUE)
 679       set(HAVE_SDL_VIDEO TRUE)
 680
 681       file(GLOB WAYLAND_SOURCES ${SDL2_SOURCE_DIR}/src/video/wayland/*.c)
 682       set(SOURCE_FILES ${SOURCE_FILES} ${WAYLAND_SOURCES})
 683
 684       # We have to generate some protocol interface code for some unstable Wayland features.
 685       file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/wayland-generated-protocols")
 686       include_directories("${CMAKE_CURRENT_BINARY_DIR}/wayland-generated-protocols")
 687
 688       WaylandProtocolGen("${WAYLAND_SCANNER}" "${WAYLAND_CORE_PROTOCOL_DIR}/wayland.xml" "wayland")
 689
 690       foreach(_PROTL relative-pointer-unstable-v1 pointer-constraints-unstable-v1 xdg-shell-unstable-v6)
 691         string(REGEX REPLACE "\\-unstable\\-.*$" "" PROTSUBDIR ${_PROTL})
 692         WaylandProtocolGen("${WAYLAND_SCANNER}" "${WAYLAND_PROTOCOLS_DIR}/unstable/${PROTSUBDIR}/${_PROTL}.xml" "${_PROTL}")
 693       endforeach()
 694
 695       if(VIDEO_WAYLAND_QT_TOUCH)
 696           set(SDL_VIDEO_DRIVER_WAYLAND_QT_TOUCH 1)
 697       endif()
 698
 699       if(WAYLAND_SHARED)
 700         if(NOT HAVE_DLOPEN)
 701           message_warn("You must have SDL_LoadObject() support for dynamic Wayland loading")
 702         else()
 703           FindLibraryAndSONAME(wayland-client)
 704           FindLibraryAndSONAME(wayland-egl)
 705           FindLibraryAndSONAME(wayland-cursor)
 706           FindLibraryAndSONAME(xkbcommon)
 707           FindLibraryAndSONAME(xdg-shell-client)
 708           FindLibraryAndSONAME(text-client)
 709           FindLibraryAndSONAME(tizen-extension-client)
 710           set(SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC "\"${WAYLAND_CLIENT_LIB_SONAME}\"")
 711           set(SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_EGL "\"${WAYLAND_EGL_LIB_SONAME}\"")
 712           set(SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_CURSOR "\"${WAYLAND_CURSOR_LIB_SONAME}\"")
 713           set(SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_XKBCOMMON "\"${XKBCOMMON_LIB_SONAME}\"")
 714           set(SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_XDGSHELLCLIENT "\"${XDGSHELLCLIENT_LIB_SONAME}\"")
 715           set(SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_TEXTCLIENT "\"${TEXTCLIENT_LIB_SONAME}\"")
 716           set(SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_TIZENEXTENSIONCLIENT "\"${TIZENEXTENSIONCLIENT_LIB_SONAME}\"")
 717           set(HAVE_WAYLAND_SHARED TRUE)
 718         endif()
 719       else()
 720         set(EXTRA_LIBS ${WAYLAND_LIBRARIES} ${EXTRA_LIBS})
 721       endif()
 722
 723       set(SDL_VIDEO_DRIVER_WAYLAND 1)
 724     endif()
 725   endif()
 726 endmacro()
 727
 728 macro(CheckTizen)
 729   if(VIDEO_TIZEN)
 730     pkg_check_modules(TIZEN wayland-client wayland-egl ecore ecore-wl2 eina capi-appfw-application capi-appfw-application dlog ecore-imf)
 731     if(TIZEN_FOUND)
 732       link_directories(
 733           ${TIZEN_LIBRARY_DIRS}
 734       )
 735       include_directories(
 736           ${TIZEN_INCLUDE_DIRS}
 737       )
 738       set(HAVE_VIDEO_TIZEN TRUE)
 739       set(HAVE_SDL_VIDEO TRUE)
 740
 741       file(GLOB TIZEN_SOURCES ${SDL2_SOURCE_DIR}/src/video/tizen/*.c)
 742       set(SOURCE_FILES ${SOURCE_FILES} ${TIZEN_SOURCES})
 743
 744       if(TIZEN_SHARED)
 745         if(NOT HAVE_DLOPEN)
 746           message_warn("You must have SDL_LoadObject() support for dynamic Tizen loading")
 747         else()
 748           FindLibraryAndSONAME(ecore)
 749           FindLibraryAndSONAME(ecore-wl2)
 750           FindLibraryAndSONAME(eina)
 751           FindLibraryAndSONAME(evas)
 752           FindLibraryAndSONAME(capi-appfw-application)
 753           FindLibraryAndSONAME(capi-system-system-settings)
 754           FindLibraryAndSONAME(dlog)
 755           set(SDL_VIDEO_DRIVER_TIZEN_DYNAMIC_ECORE "\"${ECORE_LIB_SONAME}\"")
 756           set(SDL_VIDEO_DRIVER_TIZEN_DYNAMIC_ECORE_WL2 "\"${ECORE_WL2_LIB_SONAME}\"")
 757           set(SDL_VIDEO_DRIVER_TIZEN_DYNAMIC_EINA "\"${EINA_LIB_SONAME}\"")
 758           set(SDL_VIDEO_DRIVER_TIZEN_DYNAMIC_EVAS "\"${EVAS_LIB_SONAME}\"")
 759           set(SDL_VIDEO_DRIVER_TIZEN_DYNAMIC_CAPI_APPFW_APPLICATION "\"${CAPI_APPFW_APPLICATION_LIB_SONAME}\"")
 760           set(SDL_VIDEO_DRIVER_TIZEN_DYNAMIC_CAPI_SYSTEM_SYSTEM_SETTINGS "\"${CAPI_SYSTEM_SYSTEM_SETTINGS_LIB_SONAME}\"")
 761           set(SDL_VIDEO_DRIVER_TIZEN_DYNAMIC_DLOG "\"${DLOG_LIB_SONAME}\"")
 762           set(HAVE_TIZEN_SHARED TRUE)
 763         endif()
 764       else()
 765         set(EXTRA_LIBS ${TIZEN_LIBRARIES} ${EXTRA_LIBS})
 766       endif()
 767
 768       set(SDL_VIDEO_DRIVER_TIZEN 1)
 769     endif()
 770   endif()
 771 endmacro()
 772
 773 # Requires:
 774 # - n/a
 775 #
 776 macro(CheckCOCOA)
 777   if(VIDEO_COCOA)
 778     if(APPLE) # Apple always has Cocoa.
 779       set(HAVE_VIDEO_COCOA TRUE)
 780     endif()
 781     if(HAVE_VIDEO_COCOA)
 782       file(GLOB COCOA_SOURCES ${SDL2_SOURCE_DIR}/src/video/cocoa/*.m)
 783       set_source_files_properties(${COCOA_SOURCES} PROPERTIES LANGUAGE C)
 784       set(SOURCE_FILES ${SOURCE_FILES} ${COCOA_SOURCES})
 785       set(SDL_VIDEO_DRIVER_COCOA 1)
 786       set(HAVE_SDL_VIDEO TRUE)
 787     endif()
 788   endif()
 789 endmacro()
 790
 791 # Requires:
 792 # - PkgCheckModules
 793 # Optional:
 794 # - DIRECTFB_SHARED opt
 795 # - HAVE_DLOPEN opt
 796 macro(CheckDirectFB)
 797   if(VIDEO_DIRECTFB)
 798     pkg_check_modules(PKG_DIRECTFB directfb>=1.0.0)
 799     if(PKG_DIRECTFB_FOUND)
 800       set(HAVE_VIDEO_DIRECTFB TRUE)
 801       file(GLOB DIRECTFB_SOURCES ${SDL2_SOURCE_DIR}/src/video/directfb/*.c)
 802       set(SOURCE_FILES ${SOURCE_FILES} ${DIRECTFB_SOURCES})
 803       set(SDL_VIDEO_DRIVER_DIRECTFB 1)
 804       set(SDL_VIDEO_RENDER_DIRECTFB 1)
 805       list(APPEND EXTRA_CFLAGS ${PKG_DIRECTFB_CFLAGS})
 806       if(DIRECTFB_SHARED)
 807         if(NOT HAVE_DLOPEN)
 808           message_warn("You must have SDL_LoadObject() support for dynamic DirectFB loading")
 809         else()
 810           FindLibraryAndSONAME("directfb")
 811           set(SDL_VIDEO_DRIVER_DIRECTFB_DYNAMIC "\"${DIRECTFB_LIB_SONAME}\"")
 812           set(HAVE_DIRECTFB_SHARED TRUE)
 813         endif()
 814       else()
 815         list(APPEND EXTRA_LDFLAGS ${PKG_DIRECTFB_LDFLAGS})
 816       endif()
 817       set(HAVE_SDL_VIDEO TRUE)
 818     endif()
 819   endif()
 820 endmacro()
 821
 822 # Requires:
 823 # - n/a
 824 macro(CheckVivante)
 825   if(VIDEO_VIVANTE)
 826     check_c_source_compiles("
 827         #include <gc_vdk.h>
 828         int main(int argc, char** argv) {}" HAVE_VIDEO_VIVANTE_VDK)
 829     check_c_source_compiles("
 830         #define LINUX
 831         #define EGL_API_FB
 832         #include <EGL/eglvivante.h>
 833         int main(int argc, char** argv) {}" HAVE_VIDEO_VIVANTE_EGL_FB)
 834     if(HAVE_VIDEO_VIVANTE_VDK OR HAVE_VIDEO_VIVANTE_EGL_FB)
 835       set(HAVE_VIDEO_VIVANTE TRUE)
 836       set(HAVE_SDL_VIDEO TRUE)
 837
 838       file(GLOB VIVANTE_SOURCES ${SDL2_SOURCE_DIR}/src/video/vivante/*.c)
 839       set(SOURCE_FILES ${SOURCE_FILES} ${VIVANTE_SOURCES})
 840       set(SDL_VIDEO_DRIVER_VIVANTE 1)
 841       if(HAVE_VIDEO_VIVANTE_VDK)
 842         set(SDL_VIDEO_DRIVER_VIVANTE_VDK 1)
 843         list(APPEND EXTRA_LIBS VDK VIVANTE)
 844       else()
 845         set(SDL_CFLAGS "${SDL_CFLAGS} -DLINUX -DEGL_API_FB")
 846         list(APPEND EXTRA_LIBS EGL)
 847       endif(HAVE_VIDEO_VIVANTE_VDK)
 848     endif(HAVE_VIDEO_VIVANTE_VDK OR HAVE_VIDEO_VIVANTE_EGL_FB)
 849   endif(VIDEO_VIVANTE)
 850 endmacro(CheckVivante)
 851
 852 # Requires:
 853 # - nada
 854 macro(CheckOpenGLX11)
 855   if(VIDEO_OPENGL)
 856     check_c_source_compiles("
 857         #include <GL/gl.h>
 858         #include <GL/glx.h>
 859         int main(int argc, char** argv) {}" HAVE_VIDEO_OPENGL)
 860
 861     if(HAVE_VIDEO_OPENGL)
 862       set(HAVE_VIDEO_OPENGL TRUE)
 863       set(SDL_VIDEO_OPENGL 1)
 864       set(SDL_VIDEO_OPENGL_GLX 1)
 865       set(SDL_VIDEO_RENDER_OGL 1)
 866     endif()
 867   endif()
 868 endmacro()
 869
 870 # Requires:
 871 # - nada
 872 macro(CheckOpenGLESX11)
 873   if(VIDEO_OPENGLES)
 874     check_c_source_compiles("
 875         #define EGL_API_FB
 876         #include <EGL/egl.h>
 877         int main (int argc, char** argv) {}" HAVE_VIDEO_OPENGL_EGL)
 878     if(HAVE_VIDEO_OPENGL_EGL)
 879         set(SDL_VIDEO_OPENGL_EGL 1)
 880     endif()
 881     check_c_source_compiles("
 882       #include <GLES/gl.h>
 883       #include <GLES/glext.h>
 884       int main (int argc, char** argv) {}" HAVE_VIDEO_OPENGLES_V1)
 885     if(HAVE_VIDEO_OPENGLES_V1)
 886         set(HAVE_VIDEO_OPENGLES TRUE)
 887         set(SDL_VIDEO_OPENGL_ES 1)
 888         set(SDL_VIDEO_RENDER_OGL_ES 1)
 889     endif()
 890     check_c_source_compiles("
 891       #include <GLES2/gl2.h>
 892       #include <GLES2/gl2ext.h>
 893       int main (int argc, char** argv) {}" HAVE_VIDEO_OPENGLES_V2)
 894     if(HAVE_VIDEO_OPENGLES_V2)
 895         set(HAVE_VIDEO_OPENGLES TRUE)
 896         set(SDL_VIDEO_OPENGL_ES2 1)
 897         set(SDL_VIDEO_RENDER_OGL_ES2 1)
 898     endif()
 899
 900   endif()
 901 endmacro()
 902
 903 macro(CheckVulkan)
 904   if(VIDEO_VULKAN)
 905     check_c_source_compiles("
 906        #include <vulkan/vulkan.h>
 907       int main (int argc, char** argv) {}" HAVE_VIDEO_VULKAN)
 908     if(HAVE_VIDEO_VULKAN)
 909         set(SDL_VIDEO_VULKAN 1)
 910         set(VULKAN_LDFLAGS "-lvulkan")
 911         list(APPEND EXTRA_LDFLAGS ${VULKAN_LDFLAGS})
 912         list(APPEND SDL_LIBS ${VULKAN_LDFLAGS})
 913     endif()
 914
 915   endif()
 916 endmacro()
 917
 918 # Requires:
 919 # - nada
 920 # Optional:
 921 # - THREADS opt
 922 # Sets:
 923 # PTHREAD_CFLAGS
 924 # PTHREAD_LIBS
 925 macro(CheckPTHREAD)
 926   if(PTHREADS)
 927     if(ANDROID)
 928       # the android libc provides built-in support for pthreads, so no
 929       # additional linking or compile flags are necessary
 930     elseif(LINUX)
 931       set(PTHREAD_CFLAGS "-D_REENTRANT")
 932       set(PTHREAD_LDFLAGS "-pthread")
 933     elseif(BSDI)
 934       set(PTHREAD_CFLAGS "-D_REENTRANT -D_THREAD_SAFE")
 935       set(PTHREAD_LDFLAGS "")
 936     elseif(DARWIN)
 937       set(PTHREAD_CFLAGS "-D_THREAD_SAFE")
 938       # causes Carbon.p complaints?
 939       # set(PTHREAD_CFLAGS "-D_REENTRANT -D_THREAD_SAFE")
 940       set(PTHREAD_LDFLAGS "")
 941     elseif(FREEBSD)
 942       set(PTHREAD_CFLAGS "-D_REENTRANT -D_THREAD_SAFE")
 943       set(PTHREAD_LDFLAGS "-pthread")
 944     elseif(NETBSD)
 945       set(PTHREAD_CFLAGS "-D_REENTRANT -D_THREAD_SAFE")
 946       set(PTHREAD_LDFLAGS "-lpthread")
 947     elseif(OPENBSD)
 948       set(PTHREAD_CFLAGS "-D_REENTRANT")
 949       set(PTHREAD_LDFLAGS "-pthread")
 950     elseif(SOLARIS)
 951       set(PTHREAD_CFLAGS "-D_REENTRANT")
 952       set(PTHREAD_LDFLAGS "-pthread -lposix4")
 953     elseif(SYSV5)
 954       set(PTHREAD_CFLAGS "-D_REENTRANT -Kthread")
 955       set(PTHREAD_LDFLAGS "")
 956     elseif(AIX)
 957       set(PTHREAD_CFLAGS "-D_REENTRANT -mthreads")
 958       set(PTHREAD_LDFLAGS "-pthread")
 959     elseif(HPUX)
 960       set(PTHREAD_CFLAGS "-D_REENTRANT")
 961       set(PTHREAD_LDFLAGS "-L/usr/lib -pthread")
 962     elseif(HAIKU)
 963       set(PTHREAD_CFLAGS "-D_REENTRANT")
 964       set(PTHREAD_LDFLAGS "")
 965     else()
 966       set(PTHREAD_CFLAGS "-D_REENTRANT")
 967       set(PTHREAD_LDFLAGS "-lpthread")
 968     endif()
 969
 970     # Run some tests
 971     set(ORIG_CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS}")
 972     set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} ${PTHREAD_CFLAGS} ${PTHREAD_LDFLAGS}")
 973     if(CMAKE_CROSSCOMPILING)
 974       set(HAVE_PTHREADS 1)
 975     else()
 976       check_c_source_runs("
 977         #include <pthread.h>
 978         int main(int argc, char** argv) {
 979           pthread_attr_t type;
 980           pthread_attr_init(&type);
 981           return 0;
 982         }" HAVE_PTHREADS)
 983     endif()
 984     if(HAVE_PTHREADS)
 985       set(SDL_THREAD_PTHREAD 1)
 986       list(APPEND EXTRA_CFLAGS ${PTHREAD_CFLAGS})
 987       list(APPEND EXTRA_LDFLAGS ${PTHREAD_LDFLAGS})
 988       set(SDL_CFLAGS "${SDL_CFLAGS} ${PTHREAD_CFLAGS}")
 989       list(APPEND SDL_LIBS ${PTHREAD_LDFLAGS})
 990
 991       check_c_source_compiles("
 992         #include <pthread.h>
 993         int main(int argc, char **argv) {
 994           pthread_mutexattr_t attr;
 995           pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
 996           return 0;
 997         }" HAVE_RECURSIVE_MUTEXES)
 998       if(HAVE_RECURSIVE_MUTEXES)
 999         set(SDL_THREAD_PTHREAD_RECURSIVE_MUTEX 1)
1000       else()
1001         check_c_source_compiles("
1002             #include <pthread.h>
1003             int main(int argc, char **argv) {
1004               pthread_mutexattr_t attr;
1005               pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE_NP);
1006               return 0;
1007             }" HAVE_RECURSIVE_MUTEXES_NP)
1008         if(HAVE_RECURSIVE_MUTEXES_NP)
1009           set(SDL_THREAD_PTHREAD_RECURSIVE_MUTEX_NP 1)
1010         endif()
1011       endif()
1012
1013       if(PTHREADS_SEM)
1014         check_c_source_compiles("#include <pthread.h>
1015                                  #include <semaphore.h>
1016                                  int main(int argc, char **argv) { return 0; }" HAVE_PTHREADS_SEM)
1017         if(HAVE_PTHREADS_SEM)
1018           check_c_source_compiles("
1019               #include <pthread.h>
1020               #include <semaphore.h>
1021               int main(int argc, char **argv) {
1022                   sem_timedwait(NULL, NULL);
1023                   return 0;
1024               }" HAVE_SEM_TIMEDWAIT)
1025         endif()
1026       endif()
1027
1028       check_c_source_compiles("
1029           #include <pthread.h>
1030           #include <pthread_np.h>
1031           int main(int argc, char** argv) { return 0; }" HAVE_PTHREAD_NP_H)
1032       check_function_exists(pthread_setname_np HAVE_PTHREAD_SETNAME_NP)
1033       check_function_exists(pthread_set_name_np HAVE_PTHREAD_SET_NAME_NP)
1034
1035       set(SOURCE_FILES ${SOURCE_FILES}
1036           ${SDL2_SOURCE_DIR}/src/thread/pthread/SDL_systhread.c
1037           ${SDL2_SOURCE_DIR}/src/thread/pthread/SDL_sysmutex.c   # Can be faked, if necessary
1038           ${SDL2_SOURCE_DIR}/src/thread/pthread/SDL_syscond.c    # Can be faked, if necessary
1039           ${SDL2_SOURCE_DIR}/src/thread/pthread/SDL_systls.c
1040           )
1041       if(HAVE_PTHREADS_SEM)
1042         set(SOURCE_FILES ${SOURCE_FILES}
1043             ${SDL2_SOURCE_DIR}/src/thread/pthread/SDL_syssem.c)
1044       else()
1045         set(SOURCE_FILES ${SOURCE_FILES}
1046             ${SDL2_SOURCE_DIR}/src/thread/generic/SDL_syssem.c)
1047       endif()
1048       set(HAVE_SDL_THREADS TRUE)
1049     endif()
1050     set(CMAKE_REQUIRED_FLAGS "${ORIG_CMAKE_REQUIRED_FLAGS}")
1051   endif()
1052 endmacro()
1053
1054 # Requires
1055 # - nada
1056 # Optional:
1057 # Sets:
1058 # USB_LIBS
1059 # USB_CFLAGS
1060 macro(CheckUSBHID)
1061   check_library_exists(usbhid hid_init "" LIBUSBHID)
1062   if(LIBUSBHID)
1063     check_include_file(usbhid.h HAVE_USBHID_H)
1064     if(HAVE_USBHID_H)
1065       set(USB_CFLAGS "-DHAVE_USBHID_H")
1066     endif()
1067
1068     check_include_file(libusbhid.h HAVE_LIBUSBHID_H)
1069     if(HAVE_LIBUSBHID_H)
1070       set(USB_CFLAGS "${USB_CFLAGS} -DHAVE_LIBUSBHID_H")
1071     endif()
1072     set(USB_LIBS ${USB_LIBS} usbhid)
1073   else()
1074     check_include_file(usb.h HAVE_USB_H)
1075     if(HAVE_USB_H)
1076       set(USB_CFLAGS "-DHAVE_USB_H")
1077     endif()
1078     check_include_file(libusb.h HAVE_LIBUSB_H)
1079     if(HAVE_LIBUSB_H)
1080       set(USB_CFLAGS "${USB_CFLAGS} -DHAVE_LIBUSB_H")
1081     endif()
1082     check_library_exists(usb hid_init "" LIBUSB)
1083     if(LIBUSB)
1084       set(USB_LIBS ${USB_LIBS} usb)
1085     endif()
1086   endif()
1087
1088   set(ORIG_CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS}")
1089   set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} ${USB_CFLAGS}")
1090   set(CMAKE_REQUIRED_LIBRARIES "${USB_LIBS}")
1091   check_c_source_compiles("
1092        #include <sys/types.h>
1093         #if defined(HAVE_USB_H)
1094         #include <usb.h>
1095         #endif
1096         #ifdef __DragonFly__
1097         # include <bus/usb/usb.h>
1098         # include <bus/usb/usbhid.h>
1099         #else
1100         # include <dev/usb/usb.h>
1101         # include <dev/usb/usbhid.h>
1102         #endif
1103         #if defined(HAVE_USBHID_H)
1104         #include <usbhid.h>
1105         #elif defined(HAVE_LIBUSB_H)
1106         #include <libusb.h>
1107         #elif defined(HAVE_LIBUSBHID_H)
1108         #include <libusbhid.h>
1109         #endif
1110         int main(int argc, char **argv) {
1111           struct report_desc *repdesc;
1112           struct usb_ctl_report *repbuf;
1113           hid_kind_t hidkind;
1114           return 0;
1115         }" HAVE_USBHID)
1116   if(HAVE_USBHID)
1117     check_c_source_compiles("
1118           #include <sys/types.h>
1119           #if defined(HAVE_USB_H)
1120           #include <usb.h>
1121           #endif
1122           #ifdef __DragonFly__
1123           # include <bus/usb/usb.h>
1124           # include <bus/usb/usbhid.h>
1125           #else
1126           # include <dev/usb/usb.h>
1127           # include <dev/usb/usbhid.h>
1128           #endif
1129           #if defined(HAVE_USBHID_H)
1130           #include <usbhid.h>
1131           #elif defined(HAVE_LIBUSB_H)
1132           #include <libusb.h>
1133           #elif defined(HAVE_LIBUSBHID_H)
1134           #include <libusbhid.h>
1135           #endif
1136           int main(int argc, char** argv) {
1137             struct usb_ctl_report buf;
1138             if (buf.ucr_data) { }
1139             return 0;
1140           }" HAVE_USBHID_UCR_DATA)
1141     if(HAVE_USBHID_UCR_DATA)
1142       set(USB_CFLAGS "${USB_CFLAGS} -DUSBHID_UCR_DATA")
1143     endif()
1144
1145     check_c_source_compiles("
1146           #include <sys/types.h>
1147           #if defined(HAVE_USB_H)
1148           #include <usb.h>
1149           #endif
1150           #ifdef __DragonFly__
1151           #include <bus/usb/usb.h>
1152           #include <bus/usb/usbhid.h>
1153           #else
1154           #include <dev/usb/usb.h>
1155           #include <dev/usb/usbhid.h>
1156           #endif
1157           #if defined(HAVE_USBHID_H)
1158           #include <usbhid.h>
1159           #elif defined(HAVE_LIBUSB_H)
1160           #include <libusb.h>
1161           #elif defined(HAVE_LIBUSBHID_H)
1162           #include <libusbhid.h>
1163           #endif
1164           int main(int argc, char **argv) {
1165             report_desc_t d;
1166             hid_start_parse(d, 1, 1);
1167             return 0;
1168           }" HAVE_USBHID_NEW)
1169     if(HAVE_USBHID_NEW)
1170       set(USB_CFLAGS "${USB_CFLAGS} -DUSBHID_NEW")
1171     endif()
1172
1173     check_c_source_compiles("
1174         #include <machine/joystick.h>
1175         int main(int argc, char** argv) {
1176             struct joystick t;
1177             return 0;
1178         }" HAVE_MACHINE_JOYSTICK)
1179     if(HAVE_MACHINE_JOYSTICK)
1180       set(SDL_JOYSTICK_USBHID_MACHINE_JOYSTICK_H 1)
1181     endif()
1182     set(SDL_JOYSTICK_USBHID 1)
1183     file(GLOB BSD_JOYSTICK_SOURCES ${SDL2_SOURCE_DIR}/src/joystick/bsd/*.c)
1184     set(SOURCE_FILES ${SOURCE_FILES} ${BSD_JOYSTICK_SOURCES})
1185     list(APPEND EXTRA_CFLAGS ${USB_CFLAGS})
1186     list(APPEND EXTRA_LIBS ${USB_LIBS})
1187     set(HAVE_SDL_JOYSTICK TRUE)
1188
1189     set(CMAKE_REQUIRED_LIBRARIES)
1190     set(CMAKE_REQUIRED_FLAGS "${ORIG_CMAKE_REQUIRED_FLAGS}")
1191   endif()
1192 endmacro()
1193
1194 # Requires:
1195 # - n/a
1196 macro(CheckRPI)
1197   if(VIDEO_RPI)
1198     pkg_check_modules(VIDEO_RPI bcm_host brcmegl)
1199     if (NOT VIDEO_RPI_FOUND)
1200       set(VIDEO_RPI_INCLUDE_DIRS "/opt/vc/include" "/opt/vc/include/interface/vcos/pthreads" "/opt/vc/include/interface/vmcs_host/linux/" )
1201       set(VIDEO_RPI_LIBRARY_DIRS "/opt/vc/lib" )
1202       set(VIDEO_RPI_LIBRARIES bcm_host )
1203       set(VIDEO_RPI_LDFLAGS "-Wl,-rpath,/opt/vc/lib")
1204     endif()
1205     listtostr(VIDEO_RPI_INCLUDE_DIRS VIDEO_RPI_INCLUDE_FLAGS "-I")
1206     listtostr(VIDEO_RPI_LIBRARY_DIRS VIDEO_RPI_LIBRARY_FLAGS "-L")
1207
1208     set(ORIG_CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS}")
1209     set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} ${VIDEO_RPI_INCLUDE_FLAGS} ${VIDEO_RPI_LIBRARY_FLAGS}")
1210     set(CMAKE_REQUIRED_LIBRARIES "${VIDEO_RPI_LIBRARIES}")
1211     check_c_source_compiles("
1212         #include <bcm_host.h>
1213         int main(int argc, char **argv) {}" HAVE_VIDEO_RPI)
1214     set(CMAKE_REQUIRED_FLAGS "${ORIG_CMAKE_REQUIRED_FLAGS}")
1215     set(CMAKE_REQUIRED_LIBRARIES)
1216
1217     if(SDL_VIDEO AND HAVE_VIDEO_RPI)
1218       set(HAVE_SDL_VIDEO TRUE)
1219       set(SDL_VIDEO_DRIVER_RPI 1)
1220       file(GLOB VIDEO_RPI_SOURCES ${SDL2_SOURCE_DIR}/src/video/raspberry/*.c)
1221       set(SOURCE_FILES ${SOURCE_FILES} ${VIDEO_RPI_SOURCES})
1222       list(APPEND EXTRA_LIBS ${VIDEO_RPI_LIBRARIES})
1223       set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${VIDEO_RPI_INCLUDE_FLAGS} ${VIDEO_RPI_LIBRARY_FLAGS}")
1224       list(APPEND EXTRA_LDFLAGS ${VIDEO_RPI_LDFLAGS})
1225     endif(SDL_VIDEO AND HAVE_VIDEO_RPI)
1226   endif(VIDEO_RPI)
1227 endmacro(CheckRPI)
1228
1229 # Requires:
1230 # - EGL
1231 # - PkgCheckModules
1232 # Optional:
1233 # - KMSDRM_SHARED opt
1234 # - HAVE_DLOPEN opt
1235 macro(CheckKMSDRM)
1236   if(VIDEO_KMSDRM)
1237     pkg_check_modules(KMSDRM libdrm gbm egl)
1238     if(KMSDRM_FOUND)
1239       link_directories(
1240         ${KMSDRM_LIBRARY_DIRS}
1241       )
1242       include_directories(
1243         ${KMSDRM_INCLUDE_DIRS}
1244       )
1245       set(HAVE_VIDEO_KMSDRM TRUE)
1246       set(HAVE_SDL_VIDEO TRUE)
1247
1248       file(GLOB KMSDRM_SOURCES ${SDL2_SOURCE_DIR}/src/video/kmsdrm/*.c)
1249       set(SOURCE_FILES ${SOURCE_FILES} ${KMSDRM_SOURCES})
1250
1251       list(APPEND EXTRA_CFLAGS ${KMSDRM_CFLAGS})
1252
1253       set(SDL_VIDEO_DRIVER_KMSDRM 1)
1254
1255       if(KMSDRM_SHARED)
1256         if(NOT HAVE_DLOPEN)
1257           message_warn("You must have SDL_LoadObject() support for dynamic KMS/DRM loading")
1258         else()
1259           FindLibraryAndSONAME(drm)
1260           FindLibraryAndSONAME(gbm)
1261           set(SDL_VIDEO_DRIVER_KMSDRM_DYNAMIC "\"${DRM_LIB_SONAME}\"")
1262           set(SDL_VIDEO_DRIVER_KMSDRM_DYNAMIC_GBM "\"${GBM_LIB_SONAME}\"")
1263           set(HAVE_KMSDRM_SHARED TRUE)
1264         endif()
1265       else()
1266         set(EXTRA_LIBS ${KMSDRM_LIBRARIES} ${EXTRA_LIBS})
1267       endif()
1268     endif()
1269   endif()
1270 endmacro()