sdl.c 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright (c) 2013 Google, Inc
  4. */
  5. #include <errno.h>
  6. #include <unistd.h>
  7. #include <stdbool.h>
  8. #include <linux/input.h>
  9. #include <SDL2/SDL.h>
  10. #include <asm/state.h>
  11. /**
  12. * struct buf_info - a data buffer holding audio data
  13. *
  14. * @pos: Current position playing in audio buffer
  15. * @size: Size of data in audio buffer (0=empty)
  16. * @alloced: Allocated size of audio buffer (max size it can hold)
  17. * @data: Audio data
  18. */
  19. struct buf_info {
  20. uint pos;
  21. uint size;
  22. uint alloced;
  23. uint8_t *data;
  24. };
  25. /**
  26. * struct sdl_info - Information about our use of the SDL library
  27. *
  28. * @width: Width of simulated LCD display
  29. * @height: Height of simulated LCD display
  30. * @vis_width: Visible width (may be larger to allow for scaling up)
  31. * @vis_height: Visible height (may be larger to allow for scaling up)
  32. * @depth: Depth of the display in bits per pixel (16 or 32)
  33. * @pitch: Number of bytes per line of the display
  34. * @sample_rate: Current sample rate for audio
  35. * @audio_active: true if audio can be used
  36. * @inited: true if this module is initialised
  37. * @cur_buf: Current audio buffer being used by sandbox_sdl_fill_audio (0 or 1)
  38. * @buf: The two available audio buffers. SDL can be reading from one while we
  39. * are setting up the next
  40. * @running: true if audio is running
  41. * @stopping: true if audio will stop once it runs out of data
  42. * @texture: SDL texture to use for U-Boot display contents
  43. * @renderer: SDL renderer to use
  44. */
  45. static struct sdl_info {
  46. int width;
  47. int height;
  48. int vis_width;
  49. int vis_height;
  50. int depth;
  51. int pitch;
  52. uint sample_rate;
  53. bool audio_active;
  54. bool inited;
  55. int cur_buf;
  56. struct buf_info buf[2];
  57. bool running;
  58. bool stopping;
  59. SDL_Texture *texture;
  60. SDL_Renderer *renderer;
  61. } sdl;
  62. static void sandbox_sdl_poll_events(void)
  63. {
  64. /*
  65. * We don't want to include common.h in this file since it uses
  66. * system headers. So add a declation here.
  67. */
  68. extern void reset_cpu(unsigned long addr);
  69. SDL_Event event;
  70. while (SDL_PollEvent(&event)) {
  71. switch (event.type) {
  72. case SDL_QUIT:
  73. puts("LCD window closed - quitting\n");
  74. reset_cpu(1);
  75. break;
  76. }
  77. }
  78. }
  79. static int sandbox_sdl_ensure_init(void)
  80. {
  81. if (!sdl.inited) {
  82. if (SDL_Init(0) < 0) {
  83. printf("Unable to initialise SDL: %s\n",
  84. SDL_GetError());
  85. return -EIO;
  86. }
  87. atexit(SDL_Quit);
  88. sdl.inited = true;
  89. }
  90. return 0;
  91. }
  92. int sandbox_sdl_init_display(int width, int height, int log2_bpp,
  93. bool double_size)
  94. {
  95. struct sandbox_state *state = state_get_current();
  96. int err;
  97. if (!width || !state->show_lcd)
  98. return 0;
  99. err = sandbox_sdl_ensure_init();
  100. if (err)
  101. return err;
  102. if (SDL_InitSubSystem(SDL_INIT_VIDEO) < 0) {
  103. printf("Unable to initialise SDL LCD: %s\n", SDL_GetError());
  104. return -EPERM;
  105. }
  106. sdl.width = width;
  107. sdl.height = height;
  108. if (double_size) {
  109. sdl.vis_width = sdl.width * 2;
  110. sdl.vis_height = sdl.height * 2;
  111. } else {
  112. sdl.vis_width = sdl.width;
  113. sdl.vis_height = sdl.height;
  114. }
  115. sdl.depth = 1 << log2_bpp;
  116. sdl.pitch = sdl.width * sdl.depth / 8;
  117. SDL_Window *screen = SDL_CreateWindow("U-Boot", SDL_WINDOWPOS_UNDEFINED,
  118. SDL_WINDOWPOS_UNDEFINED,
  119. sdl.vis_width, sdl.vis_height, 0);
  120. if (!screen) {
  121. printf("Unable to initialise SDL screen: %s\n",
  122. SDL_GetError());
  123. return -EIO;
  124. }
  125. if (log2_bpp != 4 && log2_bpp != 5) {
  126. printf("U-Boot SDL does not support depth %d\n", log2_bpp);
  127. return -EINVAL;
  128. }
  129. sdl.renderer = SDL_CreateRenderer(screen, -1,
  130. SDL_RENDERER_ACCELERATED |
  131. SDL_RENDERER_PRESENTVSYNC);
  132. if (!sdl.renderer) {
  133. printf("Unable to initialise SDL renderer: %s\n",
  134. SDL_GetError());
  135. return -EIO;
  136. }
  137. sdl.texture = SDL_CreateTexture(sdl.renderer, log2_bpp == 4 ?
  138. SDL_PIXELFORMAT_RGB565 :
  139. SDL_PIXELFORMAT_RGB888,
  140. SDL_TEXTUREACCESS_STREAMING,
  141. width, height);
  142. if (!sdl.texture) {
  143. printf("Unable to initialise SDL texture: %s\n",
  144. SDL_GetError());
  145. return -EBADF;
  146. }
  147. sandbox_sdl_poll_events();
  148. return 0;
  149. }
  150. int sandbox_sdl_sync(void *lcd_base)
  151. {
  152. SDL_UpdateTexture(sdl.texture, NULL, lcd_base, sdl.pitch);
  153. SDL_RenderCopy(sdl.renderer, sdl.texture, NULL, NULL);
  154. SDL_RenderPresent(sdl.renderer);
  155. sandbox_sdl_poll_events();
  156. return 0;
  157. }
  158. static const unsigned short sdl_to_keycode[SDL_NUM_SCANCODES] = {
  159. [SDL_SCANCODE_A] = KEY_A,
  160. [SDL_SCANCODE_B] = KEY_B,
  161. [SDL_SCANCODE_C] = KEY_C,
  162. [SDL_SCANCODE_D] = KEY_D,
  163. [SDL_SCANCODE_E] = KEY_E,
  164. [SDL_SCANCODE_F] = KEY_F,
  165. [SDL_SCANCODE_G] = KEY_G,
  166. [SDL_SCANCODE_H] = KEY_H,
  167. [SDL_SCANCODE_I] = KEY_I,
  168. [SDL_SCANCODE_J] = KEY_J,
  169. [SDL_SCANCODE_K] = KEY_K,
  170. [SDL_SCANCODE_L] = KEY_L,
  171. [SDL_SCANCODE_M] = KEY_M,
  172. [SDL_SCANCODE_N] = KEY_N,
  173. [SDL_SCANCODE_O] = KEY_O,
  174. [SDL_SCANCODE_P] = KEY_P,
  175. [SDL_SCANCODE_Q] = KEY_Q,
  176. [SDL_SCANCODE_R] = KEY_R,
  177. [SDL_SCANCODE_S] = KEY_S,
  178. [SDL_SCANCODE_T] = KEY_T,
  179. [SDL_SCANCODE_U] = KEY_U,
  180. [SDL_SCANCODE_V] = KEY_V,
  181. [SDL_SCANCODE_W] = KEY_W,
  182. [SDL_SCANCODE_X] = KEY_X,
  183. [SDL_SCANCODE_Y] = KEY_Y,
  184. [SDL_SCANCODE_Z] = KEY_Z,
  185. [SDL_SCANCODE_1] = KEY_1,
  186. [SDL_SCANCODE_2] = KEY_2,
  187. [SDL_SCANCODE_3] = KEY_3,
  188. [SDL_SCANCODE_4] = KEY_4,
  189. [SDL_SCANCODE_5] = KEY_5,
  190. [SDL_SCANCODE_6] = KEY_6,
  191. [SDL_SCANCODE_7] = KEY_7,
  192. [SDL_SCANCODE_8] = KEY_8,
  193. [SDL_SCANCODE_9] = KEY_9,
  194. [SDL_SCANCODE_0] = KEY_0,
  195. [SDL_SCANCODE_RETURN] = KEY_ENTER,
  196. [SDL_SCANCODE_ESCAPE] = KEY_ESC,
  197. [SDL_SCANCODE_BACKSPACE] = KEY_BACKSPACE,
  198. [SDL_SCANCODE_TAB] = KEY_TAB,
  199. [SDL_SCANCODE_SPACE] = KEY_SPACE,
  200. [SDL_SCANCODE_MINUS] = KEY_MINUS,
  201. [SDL_SCANCODE_EQUALS] = KEY_EQUAL,
  202. [SDL_SCANCODE_BACKSLASH] = KEY_BACKSLASH,
  203. [SDL_SCANCODE_SEMICOLON] = KEY_SEMICOLON,
  204. [SDL_SCANCODE_APOSTROPHE] = KEY_APOSTROPHE,
  205. [SDL_SCANCODE_GRAVE] = KEY_GRAVE,
  206. [SDL_SCANCODE_COMMA] = KEY_COMMA,
  207. [SDL_SCANCODE_PERIOD] = KEY_DOT,
  208. [SDL_SCANCODE_SLASH] = KEY_SLASH,
  209. [SDL_SCANCODE_CAPSLOCK] = KEY_CAPSLOCK,
  210. [SDL_SCANCODE_F1] = KEY_F1,
  211. [SDL_SCANCODE_F2] = KEY_F2,
  212. [SDL_SCANCODE_F3] = KEY_F3,
  213. [SDL_SCANCODE_F4] = KEY_F4,
  214. [SDL_SCANCODE_F5] = KEY_F5,
  215. [SDL_SCANCODE_F6] = KEY_F6,
  216. [SDL_SCANCODE_F7] = KEY_F7,
  217. [SDL_SCANCODE_F8] = KEY_F8,
  218. [SDL_SCANCODE_F9] = KEY_F9,
  219. [SDL_SCANCODE_F10] = KEY_F10,
  220. [SDL_SCANCODE_F11] = KEY_F11,
  221. [SDL_SCANCODE_F12] = KEY_F12,
  222. [SDL_SCANCODE_PRINTSCREEN] = KEY_PRINT,
  223. [SDL_SCANCODE_SCROLLLOCK] = KEY_SCROLLLOCK,
  224. [SDL_SCANCODE_PAUSE] = KEY_PAUSE,
  225. [SDL_SCANCODE_INSERT] = KEY_INSERT,
  226. [SDL_SCANCODE_HOME] = KEY_HOME,
  227. [SDL_SCANCODE_PAGEUP] = KEY_PAGEUP,
  228. [SDL_SCANCODE_DELETE] = KEY_DELETE,
  229. [SDL_SCANCODE_END] = KEY_END,
  230. [SDL_SCANCODE_PAGEDOWN] = KEY_PAGEDOWN,
  231. [SDL_SCANCODE_RIGHT] = KEY_RIGHT,
  232. [SDL_SCANCODE_LEFT] = KEY_LEFT,
  233. [SDL_SCANCODE_DOWN] = KEY_DOWN,
  234. [SDL_SCANCODE_UP] = KEY_UP,
  235. [SDL_SCANCODE_NUMLOCKCLEAR] = KEY_NUMLOCK,
  236. [SDL_SCANCODE_KP_DIVIDE] = KEY_KPSLASH,
  237. [SDL_SCANCODE_KP_MULTIPLY] = KEY_KPASTERISK,
  238. [SDL_SCANCODE_KP_MINUS] = KEY_KPMINUS,
  239. [SDL_SCANCODE_KP_PLUS] = KEY_KPPLUS,
  240. [SDL_SCANCODE_KP_ENTER] = KEY_KPENTER,
  241. [SDL_SCANCODE_KP_1] = KEY_KP1,
  242. [SDL_SCANCODE_KP_2] = KEY_KP2,
  243. [SDL_SCANCODE_KP_3] = KEY_KP3,
  244. [SDL_SCANCODE_KP_4] = KEY_KP4,
  245. [SDL_SCANCODE_KP_5] = KEY_KP5,
  246. [SDL_SCANCODE_KP_6] = KEY_KP6,
  247. [SDL_SCANCODE_KP_7] = KEY_KP7,
  248. [SDL_SCANCODE_KP_8] = KEY_KP8,
  249. [SDL_SCANCODE_KP_9] = KEY_KP9,
  250. [SDL_SCANCODE_KP_0] = KEY_KP0,
  251. [SDL_SCANCODE_KP_PERIOD] = KEY_KPDOT,
  252. [SDL_SCANCODE_KP_EQUALS] = KEY_KPEQUAL,
  253. [SDL_SCANCODE_KP_COMMA] = KEY_KPCOMMA,
  254. [SDL_SCANCODE_SYSREQ] = KEY_SYSRQ,
  255. };
  256. int sandbox_sdl_scan_keys(int key[], int max_keys)
  257. {
  258. const Uint8 *keystate;
  259. int num_keys;
  260. int i, count;
  261. sandbox_sdl_poll_events();
  262. keystate = SDL_GetKeyboardState(&num_keys);
  263. for (i = count = 0; i < num_keys; i++) {
  264. if (count < max_keys && keystate[i]) {
  265. int keycode = sdl_to_keycode[i];
  266. if (keycode)
  267. key[count++] = keycode;
  268. }
  269. }
  270. return count;
  271. }
  272. int sandbox_sdl_key_pressed(int keycode)
  273. {
  274. int key[8]; /* allow up to 8 keys to be pressed at once */
  275. int count;
  276. int i;
  277. count = sandbox_sdl_scan_keys(key, sizeof(key) / sizeof(key[0]));
  278. for (i = 0; i < count; i++) {
  279. if (key[i] == keycode)
  280. return 0;
  281. }
  282. return -ENOENT;
  283. }
  284. void sandbox_sdl_fill_audio(void *udata, Uint8 *stream, int len)
  285. {
  286. struct buf_info *buf;
  287. int avail;
  288. bool have_data = false;
  289. int i;
  290. for (i = 0; i < 2; i++) {
  291. buf = &sdl.buf[sdl.cur_buf];
  292. avail = buf->size - buf->pos;
  293. if (avail <= 0) {
  294. sdl.cur_buf = 1 - sdl.cur_buf;
  295. continue;
  296. }
  297. if (avail > len)
  298. avail = len;
  299. have_data = true;
  300. SDL_MixAudio(stream, buf->data + buf->pos, avail,
  301. SDL_MIX_MAXVOLUME);
  302. buf->pos += avail;
  303. len -= avail;
  304. /* Move to next buffer if we are at the end */
  305. if (buf->pos == buf->size)
  306. buf->size = 0;
  307. else
  308. break;
  309. }
  310. sdl.stopping = !have_data;
  311. }
  312. int sandbox_sdl_sound_init(int rate, int channels)
  313. {
  314. SDL_AudioSpec wanted, have;
  315. int i;
  316. if (sandbox_sdl_ensure_init())
  317. return -1;
  318. if (sdl.audio_active)
  319. return 0;
  320. /* Set the audio format */
  321. wanted.freq = rate;
  322. wanted.format = AUDIO_S16;
  323. wanted.channels = channels;
  324. wanted.samples = 1024; /* Good low-latency value for callback */
  325. wanted.callback = sandbox_sdl_fill_audio;
  326. wanted.userdata = NULL;
  327. for (i = 0; i < 2; i++) {
  328. struct buf_info *buf = &sdl.buf[i];
  329. buf->alloced = sizeof(uint16_t) * wanted.freq * wanted.channels;
  330. buf->data = malloc(buf->alloced);
  331. if (!buf->data) {
  332. printf("%s: Out of memory\n", __func__);
  333. if (i == 1)
  334. free(sdl.buf[0].data);
  335. return -1;
  336. }
  337. buf->pos = 0;
  338. buf->size = 0;
  339. }
  340. if (SDL_InitSubSystem(SDL_INIT_AUDIO) < 0) {
  341. printf("Unable to initialise SDL audio: %s\n", SDL_GetError());
  342. goto err;
  343. }
  344. /* Open the audio device, forcing the desired format */
  345. if (SDL_OpenAudio(&wanted, &have) < 0) {
  346. printf("Couldn't open audio: %s\n", SDL_GetError());
  347. goto err;
  348. }
  349. if (have.format != wanted.format) {
  350. printf("Couldn't select required audio format\n");
  351. goto err;
  352. }
  353. sdl.audio_active = true;
  354. sdl.sample_rate = wanted.freq;
  355. sdl.cur_buf = 0;
  356. sdl.running = false;
  357. return 0;
  358. err:
  359. for (i = 0; i < 2; i++)
  360. free(sdl.buf[i].data);
  361. return -1;
  362. }
  363. int sandbox_sdl_sound_play(const void *data, uint size)
  364. {
  365. struct buf_info *buf;
  366. if (!sdl.audio_active)
  367. return 0;
  368. buf = &sdl.buf[0];
  369. if (buf->size)
  370. buf = &sdl.buf[1];
  371. while (buf->size)
  372. usleep(1000);
  373. if (size > buf->alloced)
  374. return -E2BIG;
  375. memcpy(buf->data, data, size);
  376. buf->size = size;
  377. buf->pos = 0;
  378. if (!sdl.running) {
  379. SDL_PauseAudio(0);
  380. sdl.running = true;
  381. sdl.stopping = false;
  382. }
  383. return 0;
  384. }
  385. int sandbox_sdl_sound_stop(void)
  386. {
  387. if (sdl.running) {
  388. while (!sdl.stopping)
  389. SDL_Delay(100);
  390. SDL_PauseAudio(1);
  391. sdl.running = 0;
  392. sdl.stopping = false;
  393. }
  394. return 0;
  395. }