linux/io.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <stdarg.h>
   5
   6 #include "../common/emu.h"
   7 #include "../common/menu.h"
   8 #include "sndout_oss.h"
   9 #include "version.h"
  10
  11 #include "log_io.h"
  12
  13 int current_keys;
  14 unsigned char *PicoDraw2FB;
  15
  16 #ifdef FBDEV
  17
  18 #include "fbdev.h"
  19
  20 #else
  21
  22 #include <pthread.h>
  23 #include <semaphore.h>
  24
  25 static int current_bpp = 16;
  26 static int current_pal[256];
  27 static const char *verstring = "PicoDrive " VERSION;
  28 static int scr_changed = 0, scr_w = SCREEN_WIDTH, scr_h = SCREEN_HEIGHT;
  29
  30 /* faking GP2X pad */
  31 enum  { GP2X_UP=0x1,       GP2X_LEFT=0x4,       GP2X_DOWN=0x10,  GP2X_RIGHT=0x40,
  32         GP2X_START=1<<8,   GP2X_SELECT=1<<9,    GP2X_L=1<<10,    GP2X_R=1<<11,
  33         GP2X_A=1<<12,      GP2X_B=1<<13,        GP2X_X=1<<14,    GP2X_Y=1<<15,
  34         GP2X_VOL_UP=1<<23, GP2X_VOL_DOWN=1<<22, GP2X_PUSH=1<<27 };
  35
  36 static void key_press_event(int keycode)
  37 {
  38         switch (keycode)
  39         {
  40                 case 111:
  41                 case 0x62: current_keys |= GP2X_UP;    break;
  42                 case 116:
  43                 case 0x68: current_keys |= GP2X_DOWN;  break;
  44                 case 113:
  45                 case 0x64: current_keys |= GP2X_LEFT;  break;
  46                 case 114:
  47                 case 0x66: current_keys |= GP2X_RIGHT; break;
  48                 case 0x24: current_keys |= GP2X_START; break; // enter
  49                 case 0x23: current_keys |= GP2X_SELECT;break; // ]
  50                 case 0x34: current_keys |= GP2X_A;     break; // z
  51                 case 0x35: current_keys |= GP2X_X;     break; // x
  52                 case 0x36: current_keys |= GP2X_B;     break; // c
  53                 case 0x37: current_keys |= GP2X_Y;     break; // v
  54                 case 0x27: current_keys |= GP2X_L;     break; // s
  55                 case 0x28: current_keys |= GP2X_R;     break; // d
  56                 case 0x29: current_keys |= GP2X_PUSH;  break; // f
  57                 case 0x18: current_keys |= GP2X_VOL_DOWN;break; // q
  58                 case 0x19: current_keys |= GP2X_VOL_UP;break; // w
  59                 case 0x2d: log_io_clear(); break; // k
  60                 case 0x2e: log_io_dump();  break; // l
  61                 case 0x17: { // tab
  62                         extern int PicoReset(void);
  63                         PicoReset();
  64                         break;
  65                 }
  66         }
  67 }
  68
  69 static void key_release_event(int keycode)
  70 {
  71         switch (keycode)
  72         {
  73                 case 111:
  74                 case 0x62: current_keys &= ~GP2X_UP;    break;
  75                 case 116:
  76                 case 0x68: current_keys &= ~GP2X_DOWN;  break;
  77                 case 113:
  78                 case 0x64: current_keys &= ~GP2X_LEFT;  break;
  79                 case 114:
  80                 case 0x66: current_keys &= ~GP2X_RIGHT; break;
  81                 case 0x24: current_keys &= ~GP2X_START; break; // enter
  82                 case 0x23: current_keys &= ~GP2X_SELECT;break; // ]
  83                 case 0x34: current_keys &= ~GP2X_A;     break; // z
  84                 case 0x35: current_keys &= ~GP2X_X;     break; // x
  85                 case 0x36: current_keys &= ~GP2X_B;     break; // c
  86                 case 0x37: current_keys &= ~GP2X_Y;     break; // v
  87                 case 0x27: current_keys &= ~GP2X_L;     break; // s
  88                 case 0x28: current_keys &= ~GP2X_R;     break; // d
  89                 case 0x29: current_keys &= ~GP2X_PUSH;  break; // f
  90                 case 0x18: current_keys &= ~GP2X_VOL_DOWN;break; // q
  91                 case 0x19: current_keys &= ~GP2X_VOL_UP;break; // w
  92         }
  93 }
  94
  95 /* --- */
  96
  97 #include <X11/Xlib.h>
  98 #include <X11/Xutil.h>
  99
 100 static Display *xlib_display;
 101 static Window xlib_window;
 102 static XImage *ximage;
 103
 104 static void ximage_realloc(Display *display, Visual *visual)
 105 {
 106         void *xlib_screen;
 107
 108         XLockDisplay(xlib_display);
 109
 110         if (ximage != NULL)
 111                 XDestroyImage(ximage);
 112         ximage = NULL;
 113
 114         xlib_screen = calloc(scr_w * scr_h, 4);
 115         if (xlib_screen != NULL)
 116                 ximage = XCreateImage(display, visual, 24, ZPixmap, 0,
 117                                 xlib_screen, scr_w, scr_h, 32, 0);
 118         if (ximage == NULL)
 119                 fprintf(stderr, "failed to alloc ximage\n");
 120
 121         XUnlockDisplay(xlib_display);
 122 }
 123
 124 static void xlib_update(void)
 125 {
 126         Status xstatus;
 127
 128         XLockDisplay(xlib_display);
 129
 130         xstatus = XPutImage(xlib_display, xlib_window, DefaultGC(xlib_display, 0), ximage,
 131                 0, 0, 0, 0, g_screen_width, g_screen_height);
 132         if (xstatus != 0)
 133                 fprintf(stderr, "XPutImage %d\n", xstatus);
 134
 135         XUnlockDisplay(xlib_display);
 136 }
 137
 138 static void *xlib_threadf(void *targ)
 139 {
 140         unsigned int width, height, display_width, display_height;
 141         sem_t *sem = targ;
 142         XTextProperty windowName;
 143         Window win;
 144         XEvent report;
 145         Display *display;
 146         Visual *visual;
 147         int screen;
 148
 149         XInitThreads();
 150
 151         xlib_display = display = XOpenDisplay(NULL);
 152         if (display == NULL)
 153         {
 154                 fprintf(stderr, "cannot connect to X server %s\n",
 155                                 XDisplayName(NULL));
 156                 sem_post(sem);
 157                 return NULL;
 158         }
 159
 160         visual = DefaultVisual(display, 0);
 161         if (visual->class != TrueColor)
 162         {
 163                 fprintf(stderr, "cannot handle non true color visual\n");
 164                 XCloseDisplay(display);
 165                 sem_post(sem);
 166                 return NULL;
 167         }
 168
 169         printf("X vendor: %s, rel: %d, display: %s, protocol ver: %d.%d\n", ServerVendor(display),
 170                 VendorRelease(display), DisplayString(display), ProtocolVersion(display),
 171                 ProtocolRevision(display));
 172
 173         screen = DefaultScreen(display);
 174
 175         ximage_realloc(display, visual);
 176         sem_post(sem);
 177
 178         display_width = DisplayWidth(display, screen);
 179         display_height = DisplayHeight(display, screen);
 180
 181         xlib_window = win = XCreateSimpleWindow(display,
 182                         RootWindow(display, screen),
 183                         display_width / 2 - scr_w / 2,
 184                         display_height / 2 - scr_h / 2,
 185                         scr_w + 2, scr_h + 2, 1,
 186                         BlackPixel(display, screen),
 187                         BlackPixel(display, screen));
 188
 189         XStringListToTextProperty((char **)&verstring, 1, &windowName);
 190         XSetWMName(display, win, &windowName);
 191
 192         XSelectInput(display, win, ExposureMask |
 193                         KeyPressMask | KeyReleaseMask |
 194                         StructureNotifyMask);
 195
 196         XMapWindow(display, win);
 197
 198         while (1)
 199         {
 200                 XNextEvent(display, &report);
 201                 switch (report.type)
 202                 {
 203                         case Expose:
 204                                 while (XCheckTypedEvent(display, Expose, &report))
 205                                         ;
 206                                 xlib_update();
 207                                 break;
 208
 209                         case ConfigureNotify:
 210                                 width = report.xconfigure.width;
 211                                 height = report.xconfigure.height;
 212                                 if (scr_w != width - 2 || scr_h != height - 2) {
 213                                         scr_w = width - 2;
 214                                         scr_h = height - 2;
 215                                         scr_changed = 1;
 216                                 }
 217                                 break;
 218
 219                         case ButtonPress:
 220                                 break;
 221
 222                         case KeyPress:
 223                                 key_press_event(report.xkey.keycode);
 224                                 break;
 225
 226                         case KeyRelease:
 227                                 key_release_event(report.xkey.keycode);
 228                                 break;
 229
 230                         default:
 231                                 break;
 232                 }
 233         }
 234 }
 235
 236 static void xlib_init(void)
 237 {
 238         pthread_t x_thread;
 239         sem_t xlib_sem;
 240
 241         sem_init(&xlib_sem, 0, 0);
 242
 243         pthread_create(&x_thread, NULL, xlib_threadf, &xlib_sem);
 244         pthread_detach(x_thread);
 245
 246         sem_wait(&xlib_sem);
 247         sem_destroy(&xlib_sem);
 248 }
 249
 250 /* --- */
 251
 252 static void realloc_screen(void)
 253 {
 254         int size = scr_w * scr_h * 2;
 255         g_screen_width = scr_w;
 256         g_screen_height = scr_h;
 257         g_screen_ptr = realloc(g_screen_ptr, size);
 258         g_menubg_ptr = realloc(g_menubg_ptr, size);
 259         memset(g_screen_ptr, 0, size);
 260         memset(g_menubg_ptr, 0, size);
 261         PicoDraw2FB = g_menubg_ptr;
 262         scr_changed = 0;
 263 }
 264
 265 void plat_video_flip(void)
 266 {
 267         unsigned int *image;
 268         int pixel_count, i;
 269
 270         if (ximage == NULL)
 271                 return;
 272
 273         pixel_count = g_screen_width * g_screen_height;
 274         image = (void *)ximage->data;
 275
 276         if (current_bpp == 8)
 277         {
 278                 unsigned char *pixels = g_screen_ptr;
 279                 int pix;
 280
 281                 for (i = 0; i < pixel_count; i++)
 282                 {
 283                         pix = current_pal[pixels[i]];
 284                         image[i] = pix;
 285                 }
 286         }
 287         else
 288         {
 289                 unsigned short *pixels = g_screen_ptr;
 290
 291                 for (i = 0; i < pixel_count; i++)
 292                 {
 293                         /*  in:           rrrr rggg gggb bbbb */
 294                         /* out: rrrr r000 gggg gg00 bbbb b000 */
 295                         image[i]  = (pixels[i] << 8) & 0xf80000;
 296                         image[i] |= (pixels[i] << 5) & 0x00fc00;
 297                         image[i] |= (pixels[i] << 3) & 0x0000f8;
 298                 }
 299         }
 300         xlib_update();
 301
 302         if (scr_changed) {
 303                 realloc_screen();
 304                 ximage_realloc(xlib_display, DefaultVisual(xlib_display, 0));
 305         }
 306 }
 307
 308 void plat_video_wait_vsync(void)
 309 {
 310 }
 311
 312 #endif // !FBDEV
 313
 314 void plat_early_init(void)
 315 {
 316 }
 317
 318 void plat_init(void)
 319 {
 320 #ifdef FBDEV
 321         int ret, w, h;
 322         ret = vout_fbdev_init(&w, &h);
 323         if (ret != 0)
 324                 exit(1);
 325         g_screen_width = w;
 326         g_menubg_ptr = realloc(g_menubg_ptr, w * g_screen_height * 2);
 327         PicoDraw2FB = g_menubg_ptr;
 328 #else
 329         realloc_screen();
 330         memset(g_screen_ptr, 0, g_screen_width * g_screen_height * 2);
 331         xlib_init();
 332 #endif
 333
 334         // snd
 335         sndout_oss_init();
 336 }
 337
 338 void plat_finish(void)
 339 {
 340 #ifdef FBDEV
 341         vout_fbdev_finish();
 342 #else
 343         free(g_screen_ptr);
 344 #endif
 345         sndout_oss_exit();
 346 }
 347
 348 /* misc */
 349 int mp3_get_bitrate(FILE *f, int size)
 350 {
 351         return 128;
 352 }
 353
 354 void mp3_start_play(FILE *f, int pos)
 355 {
 356 }
 357
 358 void mp3_update(int *buffer, int length, int stereo)
 359 {
 360 }
 361
 362 /* lprintf */
 363 void lprintf(const char *fmt, ...)
 364 {
 365         va_list vl;
 366
 367         va_start(vl, fmt);
 368         vprintf(fmt, vl);
 369         va_end(vl);
 370 }
 371