SDL  2.0
SDL_vivantevideo.c
Go to the documentation of this file.
1 /*
2  Simple DirectMedia Layer
3  Copyright (C) 1997-2018 Sam Lantinga <slouken@libsdl.org>
4 
5  This software is provided 'as-is', without any express or implied
6  warranty. In no event will the authors be held liable for any damages
7  arising from the use of this software.
8 
9  Permission is granted to anyone to use this software for any purpose,
10  including commercial applications, and to alter it and redistribute it
11  freely, subject to the following restrictions:
12 
13  1. The origin of this software must not be misrepresented; you must not
14  claim that you wrote the original software. If you use this software
15  in a product, an acknowledgment in the product documentation would be
16  appreciated but is not required.
17  2. Altered source versions must be plainly marked as such, and must not be
18  misrepresented as being the original software.
19  3. This notice may not be removed or altered from any source distribution.
20 */
21 #include "../../SDL_internal.h"
22 
23 #if SDL_VIDEO_DRIVER_VIVANTE
24 
25 /* SDL internals */
26 #include "../SDL_sysvideo.h"
27 #include "SDL_version.h"
28 #include "SDL_syswm.h"
29 #include "SDL_loadso.h"
30 #include "SDL_events.h"
31 #include "../../events/SDL_events_c.h"
32 
33 #ifdef SDL_INPUT_LINUXEV
34 #include "../../core/linux/SDL_evdev.h"
35 #endif
36 
37 #include "SDL_vivantevideo.h"
38 #include "SDL_vivanteplatform.h"
39 #include "SDL_vivanteopengles.h"
40 
41 
42 static int
43 VIVANTE_Available(void)
44 {
45  return 1;
46 }
47 
48 static void
49 VIVANTE_Destroy(SDL_VideoDevice * device)
50 {
51  if (device->driverdata != NULL) {
52  SDL_free(device->driverdata);
53  device->driverdata = NULL;
54  }
55 }
56 
57 static SDL_VideoDevice *
58 VIVANTE_Create()
59 {
62 
63  /* Initialize SDL_VideoDevice structure */
65  if (device == NULL) {
67  return NULL;
68  }
69 
70  /* Initialize internal data */
71  data = (SDL_VideoData *) SDL_calloc(1, sizeof(SDL_VideoData));
72  if (data == NULL) {
75  return NULL;
76  }
77 
78  device->driverdata = data;
79 
80  /* Setup amount of available displays */
81  device->num_displays = 0;
82 
83  /* Set device free function */
84  device->free = VIVANTE_Destroy;
85 
86  /* Setup all functions which we can handle */
87  device->VideoInit = VIVANTE_VideoInit;
88  device->VideoQuit = VIVANTE_VideoQuit;
89  device->GetDisplayModes = VIVANTE_GetDisplayModes;
90  device->SetDisplayMode = VIVANTE_SetDisplayMode;
91  device->CreateSDLWindow = VIVANTE_CreateWindow;
92  device->SetWindowTitle = VIVANTE_SetWindowTitle;
93  device->SetWindowPosition = VIVANTE_SetWindowPosition;
94  device->SetWindowSize = VIVANTE_SetWindowSize;
95  device->ShowWindow = VIVANTE_ShowWindow;
96  device->HideWindow = VIVANTE_HideWindow;
97  device->DestroyWindow = VIVANTE_DestroyWindow;
98  device->GetWindowWMInfo = VIVANTE_GetWindowWMInfo;
99 
100 #if SDL_VIDEO_OPENGL_EGL
101  device->GL_LoadLibrary = VIVANTE_GLES_LoadLibrary;
102  device->GL_GetProcAddress = VIVANTE_GLES_GetProcAddress;
103  device->GL_UnloadLibrary = VIVANTE_GLES_UnloadLibrary;
104  device->GL_CreateContext = VIVANTE_GLES_CreateContext;
105  device->GL_MakeCurrent = VIVANTE_GLES_MakeCurrent;
106  device->GL_SetSwapInterval = VIVANTE_GLES_SetSwapInterval;
107  device->GL_GetSwapInterval = VIVANTE_GLES_GetSwapInterval;
108  device->GL_SwapWindow = VIVANTE_GLES_SwapWindow;
109  device->GL_DeleteContext = VIVANTE_GLES_DeleteContext;
110 #endif
111 
112  device->PumpEvents = VIVANTE_PumpEvents;
113 
114  return device;
115 }
116 
118  "vivante",
119  "Vivante EGL Video Driver",
120  VIVANTE_Available,
121  VIVANTE_Create
122 };
123 
124 /*****************************************************************************/
125 /* SDL Video and Display initialization/handling functions */
126 /*****************************************************************************/
127 
128 static int
129 VIVANTE_AddVideoDisplays(_THIS)
130 {
131  SDL_VideoData *videodata = _this->driverdata;
132  SDL_VideoDisplay display;
133  SDL_DisplayMode current_mode;
135  int pitch = 0, bpp = 0;
136  unsigned long pixels = 0;
137 
139  if (data == NULL) {
140  return SDL_OutOfMemory();
141  }
142 
143  SDL_zero(current_mode);
144 #if SDL_VIDEO_DRIVER_VIVANTE_VDK
145  data->native_display = vdkGetDisplay(videodata->vdk_private);
146 
147  vdkGetDisplayInfo(data->native_display, &current_mode.w, &current_mode.h, &pixels, &pitch, &bpp);
148 #else
149  data->native_display = videodata->fbGetDisplayByIndex(0);
150 
151  videodata->fbGetDisplayInfo(data->native_display, &current_mode.w, &current_mode.h, &pixels, &pitch, &bpp);
152 #endif /* SDL_VIDEO_DRIVER_VIVANTE_VDK */
153 
154  switch (bpp)
155  {
156  default: /* Is another format used? */
157  case 32:
158  current_mode.format = SDL_PIXELFORMAT_ARGB8888;
159  break;
160  case 16:
161  current_mode.format = SDL_PIXELFORMAT_RGB565;
162  break;
163  }
164  /* FIXME: How do we query refresh rate? */
165  current_mode.refresh_rate = 60;
166 
167  SDL_zero(display);
168  display.name = VIVANTE_GetDisplayName(_this);
169  display.desktop_mode = current_mode;
170  display.current_mode = current_mode;
171  display.driverdata = data;
172  SDL_AddVideoDisplay(&display);
173  return 0;
174 }
175 
176 int
178 {
179  SDL_VideoData *videodata = (SDL_VideoData *)_this->driverdata;
180 
181 #if SDL_VIDEO_DRIVER_VIVANTE_VDK
182  videodata->vdk_private = vdkInitialize();
183  if (!videodata->vdk_private) {
184  return SDL_SetError("vdkInitialize() failed");
185  }
186 #else
187  videodata->egl_handle = SDL_LoadObject("libEGL.so.1");
188  if (!videodata->egl_handle) {
189  videodata->egl_handle = SDL_LoadObject("libEGL.so");
190  if (!videodata->egl_handle) {
191  return -1;
192  }
193  }
194 #define LOAD_FUNC(NAME) \
195  videodata->NAME = SDL_LoadFunction(videodata->egl_handle, #NAME); \
196  if (!videodata->NAME) return -1;
197 
198  LOAD_FUNC(fbGetDisplay);
199  LOAD_FUNC(fbGetDisplayByIndex);
200  LOAD_FUNC(fbGetDisplayGeometry);
201  LOAD_FUNC(fbGetDisplayInfo);
202  LOAD_FUNC(fbDestroyDisplay);
203  LOAD_FUNC(fbCreateWindow);
204  LOAD_FUNC(fbGetWindowGeometry);
205  LOAD_FUNC(fbGetWindowInfo);
206  LOAD_FUNC(fbDestroyWindow);
207 #endif
208 
209  if (VIVANTE_SetupPlatform(_this) < 0) {
210  return -1;
211  }
212 
213  if (VIVANTE_AddVideoDisplays(_this) < 0) {
214  return -1;
215  }
216 
217  VIVANTE_UpdateDisplayScale(_this);
218 
219 #ifdef SDL_INPUT_LINUXEV
220  if (SDL_EVDEV_Init() < 0) {
221  return -1;
222  }
223 #endif
224 
225  return 0;
226 }
227 
228 void
230 {
231  SDL_VideoData *videodata = (SDL_VideoData *)_this->driverdata;
232 
233 #ifdef SDL_INPUT_LINUXEV
234  SDL_EVDEV_Quit();
235 #endif
236 
237  VIVANTE_CleanupPlatform(_this);
238 
239 #if SDL_VIDEO_DRIVER_VIVANTE_VDK
240  if (videodata->vdk_private) {
241  vdkExit(videodata->vdk_private);
242  videodata->vdk_private = NULL;
243  }
244 #else
245  if (videodata->egl_handle) {
246  SDL_UnloadObject(videodata->egl_handle);
247  videodata->egl_handle = NULL;
248  }
249 #endif
250 }
251 
252 void
254 {
255  /* Only one display mode available, the current one */
256  SDL_AddDisplayMode(display, &display->current_mode);
257 }
258 
259 int
261 {
262  return 0;
263 }
264 
265 int
267 {
268  SDL_VideoData *videodata = (SDL_VideoData *)_this->driverdata;
269  SDL_DisplayData *displaydata;
271 
272  displaydata = SDL_GetDisplayDriverData(0);
273 
274  /* Allocate window internal data */
275  data = (SDL_WindowData *) SDL_calloc(1, sizeof(SDL_WindowData));
276  if (data == NULL) {
277  return SDL_OutOfMemory();
278  }
279 
280  /* Setup driver data for this window */
281  window->driverdata = data;
282 
283 #if SDL_VIDEO_DRIVER_VIVANTE_VDK
284  data->native_window = vdkCreateWindow(displaydata->native_display, window->x, window->y, window->w, window->h);
285 #else
286  data->native_window = videodata->fbCreateWindow(displaydata->native_display, window->x, window->y, window->w, window->h);
287 #endif
288  if (!data->native_window) {
289  return SDL_SetError("VIVANTE: Can't create native window");
290  }
291 
292 #if SDL_VIDEO_OPENGL_EGL
293  if (window->flags & SDL_WINDOW_OPENGL) {
294  data->egl_surface = SDL_EGL_CreateSurface(_this, data->native_window);
295  if (data->egl_surface == EGL_NO_SURFACE) {
296  return SDL_SetError("VIVANTE: Can't create EGL surface");
297  }
298  } else {
299  data->egl_surface = EGL_NO_SURFACE;
300  }
301 #endif
302 
303  /* Window has been successfully created */
304  return 0;
305 }
306 
307 void
309 {
310  SDL_VideoData *videodata = (SDL_VideoData *)_this->driverdata;
312 
313  data = window->driverdata;
314  if (data) {
315 #if SDL_VIDEO_OPENGL_EGL
316  if (data->egl_surface != EGL_NO_SURFACE) {
317  SDL_EGL_DestroySurface(_this, data->egl_surface);
318  }
319 #endif
320 
321  if (data->native_window) {
322 #if SDL_VIDEO_DRIVER_VIVANTE_VDK
323  vdkDestroyWindow(data->native_window);
324 #else
325  videodata->fbDestroyWindow(data->native_window);
326 #endif
327  }
328 
329  SDL_free(data);
330  }
331  window->driverdata = NULL;
332 }
333 
334 void
336 {
337 #if SDL_VIDEO_DRIVER_VIVANTE_VDK
338  SDL_WindowData *data = window->driverdata;
339  vdkSetWindowTitle(data->native_window, window->title);
340 #endif
341 }
342 
343 void
345 {
346  /* FIXME */
347 }
348 
349 void
351 {
352  /* FIXME */
353 }
354 
355 void
357 {
358 #if SDL_VIDEO_DRIVER_VIVANTE_VDK
359  SDL_WindowData *data = window->driverdata;
360  vdkShowWindow(data->native_window);
361 #endif
364 }
365 
366 void
368 {
369 #if SDL_VIDEO_DRIVER_VIVANTE_VDK
370  SDL_WindowData *data = window->driverdata;
371  vdkHideWindow(data->native_window);
372 #endif
373 }
374 
375 /*****************************************************************************/
376 /* SDL Window Manager function */
377 /*****************************************************************************/
378 SDL_bool
380 {
381  SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
382  SDL_DisplayData *displaydata = SDL_GetDisplayDriverData(0);
383 
384  if (info->version.major == SDL_MAJOR_VERSION &&
385  info->version.minor == SDL_MINOR_VERSION) {
387  info->info.vivante.display = displaydata->native_display;
388  info->info.vivante.window = data->native_window;
389  return SDL_TRUE;
390  } else {
391  SDL_SetError("Application not compiled with SDL %d.%d",
393  return SDL_FALSE;
394  }
395 }
396 
397 /*****************************************************************************/
398 /* SDL event functions */
399 /*****************************************************************************/
401 {
402 #ifdef SDL_INPUT_LINUXEV
403  SDL_EVDEV_Poll();
404 #endif
405 }
406 
407 #endif /* SDL_VIDEO_DRIVER_VIVANTE */
408 
409 /* vi: set ts=4 sw=4 expandtab: */
SDL_zero
#define SDL_zero(x)
Definition: SDL_stdinc.h:416
SDL_PIXELFORMAT_ARGB8888
@ SDL_PIXELFORMAT_ARGB8888
Definition: SDL_pixels.h:248
SDL_DisplayMode::format
Uint32 format
Definition: SDL_video.h:55
SDL_events.h
VIVANTE_GetWindowWMInfo
SDL_bool VIVANTE_GetWindowWMInfo(_THIS, SDL_Window *window, struct SDL_SysWMinfo *info)
SDL_VideoDevice::driverdata
void * driverdata
Definition: SDL_sysvideo.h:381
SDL_SysWMinfo::display
Display * display
Definition: SDL_syswm.h:217
SDL_VideoDisplay::name
char * name
Definition: SDL_sysvideo.h:127
NULL
#define NULL
Definition: begin_code.h:164
VIVANTE_DestroyWindow
void VIVANTE_DestroyWindow(_THIS, SDL_Window *window)
mode
GLenum mode
Definition: SDL_opengl_glext.h:1122
SDL_SysWMinfo
Definition: SDL_syswm.h:195
SDL_WindowData
Definition: SDL_androidwindow.h:36
SDL_version::minor
Uint8 minor
Definition: SDL_version.h:54
SDL_SysWMinfo::window
Window window
Definition: SDL_syswm.h:218
SDL_WINDOW_OPENGL
@ SDL_WINDOW_OPENGL
Definition: SDL_video.h:101
VIVANTE_VideoQuit
void VIVANTE_VideoQuit(_THIS)
SDL_SetKeyboardFocus
void SDL_SetKeyboardFocus(SDL_Window *window)
Definition: SDL_keyboard.c:630
SDL_UnloadObject
#define SDL_UnloadObject
Definition: SDL_dynapi_overrides.h:234
SDL_VideoDisplay::desktop_mode
SDL_DisplayMode desktop_mode
Definition: SDL_sysvideo.h:131
SDL_GetDisplayDriverData
void * SDL_GetDisplayDriverData(int displayIndex)
Definition: SDL_video.c:660
SDL_SetMouseFocus
void SDL_SetMouseFocus(SDL_Window *window)
Definition: SDL_mouse.c:177
VIVANTE_SetWindowSize
void VIVANTE_SetWindowSize(_THIS, SDL_Window *window)
SDL_DisplayMode::h
int h
Definition: SDL_video.h:57
SDL_LoadObject
#define SDL_LoadObject
Definition: SDL_dynapi_overrides.h:232
data
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: SDL_opengl.h:1974
SDL_Window
The type used to identify a window.
Definition: SDL_sysvideo.h:74
SDL_DisplayMode
The structure that defines a display mode.
Definition: SDL_video.h:54
SDL_AddDisplayMode
SDL_bool SDL_AddDisplayMode(SDL_VideoDisplay *display, const SDL_DisplayMode *mode)
Definition: SDL_video.c:754
SDL_vivantevideo.h
VIVANTE_GetDisplayModes
void VIVANTE_GetDisplayModes(_THIS, SDL_VideoDisplay *display)
_this
static SDL_VideoDevice * _this
Definition: SDL_video.c:121
VIVANTE_SetWindowTitle
void VIVANTE_SetWindowTitle(_THIS, SDL_Window *window)
SDL_MINOR_VERSION
#define SDL_MINOR_VERSION
Definition: SDL_version.h:61
SDL_SysWMinfo::subsystem
SDL_SYSWM_TYPE subsystem
Definition: SDL_syswm.h:197
window
EGLSurface EGLNativeWindowType * window
Definition: eglext.h:1025
EGL_NO_SURFACE
#define EGL_NO_SURFACE
Definition: egl.h:100
SDL_free
#define SDL_free
Definition: SDL_dynapi_overrides.h:377
SDL_SysWMinfo::info
union SDL_SysWMinfo::@18 info
SDL_DisplayMode::refresh_rate
int refresh_rate
Definition: SDL_video.h:58
VIVANTE_VideoInit
int VIVANTE_VideoInit(_THIS)
_THIS
#define _THIS
Definition: SDL_alsa_audio.h:31
VIVANTE_ShowWindow
void VIVANTE_ShowWindow(_THIS, SDL_Window *window)
VIVANTE_HideWindow
void VIVANTE_HideWindow(_THIS, SDL_Window *window)
SDL_TRUE
@ SDL_TRUE
Definition: SDL_stdinc.h:164
SDL_DisplayMode::w
int w
Definition: SDL_video.h:56
SDL_AddVideoDisplay
int SDL_AddVideoDisplay(const SDL_VideoDisplay *display)
Definition: SDL_video.c:606
VIVANTE_bootstrap
VideoBootStrap VIVANTE_bootstrap
SDL_VideoDisplay::driverdata
void * driverdata
Definition: SDL_sysvideo.h:139
pixels
GLint GLint GLsizei GLsizei GLsizei GLint GLenum GLenum const GLvoid * pixels
Definition: SDL_opengl.h:1572
VIVANTE_SetWindowPosition
void VIVANTE_SetWindowPosition(_THIS, SDL_Window *window)
SDL_DisplayData
Definition: SDL_cocoamodes.h:27
SDL_VideoDevice
Definition: SDL_sysvideo.h:149
SDL_OutOfMemory
#define SDL_OutOfMemory()
Definition: SDL_error.h:52
SDL_VideoData::egl_handle
void * egl_handle
Definition: SDL_vivantevideo.h:41
SDL_calloc
#define SDL_calloc
Definition: SDL_dynapi_overrides.h:375
SDL_INPUT_LINUXEV
#define SDL_INPUT_LINUXEV
Definition: SDL_config.h:274
SDL_SysWMinfo::version
SDL_version version
Definition: SDL_syswm.h:196
SDL_VideoDisplay
Definition: SDL_sysvideo.h:126
SDL_SetError
#define SDL_SetError
Definition: SDL_dynapi_overrides.h:30
SDL_vivanteopengles.h
SDL_PIXELFORMAT_RGB565
@ SDL_PIXELFORMAT_RGB565
Definition: SDL_pixels.h:224
VIVANTE_PumpEvents
void VIVANTE_PumpEvents(_THIS)
VIVANTE_CreateWindow
int VIVANTE_CreateWindow(_THIS, SDL_Window *window)
SDL_bool
SDL_bool
Definition: SDL_stdinc.h:162
SDL_FALSE
@ SDL_FALSE
Definition: SDL_stdinc.h:163
SDL_version.h
SDL_VideoDisplay::current_mode
SDL_DisplayMode current_mode
Definition: SDL_sysvideo.h:132
SDL_version::major
Uint8 major
Definition: SDL_version.h:53
VideoBootStrap
Definition: SDL_sysvideo.h:398
VIVANTE_SetDisplayMode
int VIVANTE_SetDisplayMode(_THIS, SDL_VideoDisplay *display, SDL_DisplayMode *mode)
SDL_MAJOR_VERSION
#define SDL_MAJOR_VERSION
Definition: SDL_version.h:60
device
static SDL_AudioDeviceID device
Definition: loopwave.c:37
SDL_vivanteplatform.h
SDL_SYSWM_VIVANTE
@ SDL_SYSWM_VIVANTE
Definition: SDL_syswm.h:128
SDL_loadso.h
SDL_VideoData
Definition: SDL_androidvideo.h:36
SDL_syswm.h