linux/gp2x.c

   1 /* faking/emulating gp2x by using gtk */
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4 #include <string.h>
   5 #include <pthread.h>
   6 #include <semaphore.h>
   7 #include <gtk/gtk.h>
   8
   9 #include <unistd.h>
  10 #include <sys/types.h>
  11 #include <sys/stat.h>
  12 #include <fcntl.h>
  13 #include <errno.h>
  14
  15 #include "../gp2x/version.h"
  16 #include "../common/emu.h"
  17 #include "../common/menu.h"
  18 #include "../common/readpng.h"
  19 #include "sndout_oss.h"
  20
  21 #include "log_io.h"
  22
  23 unsigned long current_keys = 0;
  24 static int current_bpp = 8;
  25 static int current_pal[256];
  26 static const char *verstring = "PicoDrive " VERSION;
  27 static int scr_changed = 0, scr_w = SCREEN_WIDTH, scr_h = SCREEN_HEIGHT;
  28
  29 // dummies
  30 int mix_32_to_16l_level;
  31 int crashed_940 = 0;
  32 int default_cpu_clock = 123;
  33
  34 /* gtk */
  35 struct gtk_global_struct
  36 {
  37         GtkWidget *window;
  38         GtkWidget *pixmap1;
  39 } gtk_items;
  40
  41
  42 static gboolean delete_event (GtkWidget *widget, GdkEvent *event, gpointer data)
  43 {
  44         return FALSE;
  45 }
  46
  47 static void destroy (GtkWidget *widget, gpointer data)
  48 {
  49         gtk_main_quit ();
  50 }
  51
  52 /* faking GP2X pad */
  53 enum  { GP2X_UP=0x1,       GP2X_LEFT=0x4,       GP2X_DOWN=0x10,  GP2X_RIGHT=0x40,
  54         GP2X_START=1<<8,   GP2X_SELECT=1<<9,    GP2X_L=1<<10,    GP2X_R=1<<11,
  55         GP2X_A=1<<12,      GP2X_B=1<<13,        GP2X_X=1<<14,    GP2X_Y=1<<15,
  56         GP2X_VOL_UP=1<<23, GP2X_VOL_DOWN=1<<22, GP2X_PUSH=1<<27 };
  57
  58 static gint key_press_event (GtkWidget *widget, GdkEventKey *event)
  59 {
  60         switch (event->hardware_keycode)
  61         {
  62                 case 111:
  63                 case 0x62: current_keys |= GP2X_UP;    break;
  64                 case 116:
  65                 case 0x68: current_keys |= GP2X_DOWN;  break;
  66                 case 113:
  67                 case 0x64: current_keys |= GP2X_LEFT;  break;
  68                 case 114:
  69                 case 0x66: current_keys |= GP2X_RIGHT; break;
  70                 case 0x24: current_keys |= GP2X_START; break; // enter
  71                 case 0x23: current_keys |= GP2X_SELECT;break; // ]
  72                 case 0x34: current_keys |= GP2X_A;     break; // z
  73                 case 0x35: current_keys |= GP2X_X;     break; // x
  74                 case 0x36: current_keys |= GP2X_B;     break; // c
  75                 case 0x37: current_keys |= GP2X_Y;     break; // v
  76                 case 0x27: current_keys |= GP2X_L;     break; // s
  77                 case 0x28: current_keys |= GP2X_R;     break; // d
  78                 case 0x29: current_keys |= GP2X_PUSH;  break; // f
  79                 case 0x18: current_keys |= GP2X_VOL_DOWN;break; // q
  80                 case 0x19: current_keys |= GP2X_VOL_UP;break; // w
  81                 case 0x2d: log_io_clear(); break; // k
  82                 case 0x2e: log_io_dump();  break; // l
  83                 case 0x17: { // tab
  84                         extern int PicoReset(void);
  85                         PicoReset();
  86                         break;
  87                 }
  88         }
  89
  90         return 0;
  91 }
  92
  93 static gint key_release_event (GtkWidget *widget, GdkEventKey *event)
  94 {
  95         switch (event->hardware_keycode)
  96         {
  97                 case 111:
  98                 case 0x62: current_keys &= ~GP2X_UP;    break;
  99                 case 116:
 100                 case 0x68: current_keys &= ~GP2X_DOWN;  break;
 101                 case 113:
 102                 case 0x64: current_keys &= ~GP2X_LEFT;  break;
 103                 case 114:
 104                 case 0x66: current_keys &= ~GP2X_RIGHT; break;
 105                 case 0x24: current_keys &= ~GP2X_START; break; // enter
 106                 case 0x23: current_keys &= ~GP2X_SELECT;break; // ]
 107                 case 0x34: current_keys &= ~GP2X_A;     break; // z
 108                 case 0x35: current_keys &= ~GP2X_X;     break; // x
 109                 case 0x36: current_keys &= ~GP2X_B;     break; // c
 110                 case 0x37: current_keys &= ~GP2X_Y;     break; // v
 111                 case 0x27: current_keys &= ~GP2X_L;     break; // s
 112                 case 0x28: current_keys &= ~GP2X_R;     break; // d
 113                 case 0x29: current_keys &= ~GP2X_PUSH;  break; // f
 114                 case 0x18: current_keys &= ~GP2X_VOL_DOWN;break; // q
 115                 case 0x19: current_keys &= ~GP2X_VOL_UP;break; // w
 116         }
 117
 118         return 0;
 119 }
 120
 121 static void size_allocate_event(GtkWidget *widget, GtkAllocation *allocation, gpointer user_data)
 122 {
 123         // printf("%dx%d\n", allocation->width, allocation->height);
 124         if (scr_w != allocation->width - 2 || scr_h != allocation->height - 2) {
 125                 scr_w = allocation->width - 2;
 126                 scr_h = allocation->height - 2;
 127                 scr_changed = 1;
 128         }
 129 }
 130
 131 static void *gtk_threadf(void *targ)
 132 {
 133         int argc = 0;
 134         char *argv[] = { "" };
 135         GtkWidget *box;
 136         sem_t *sem = targ;
 137
 138         g_thread_init (NULL);
 139         gdk_threads_init ();
 140         gdk_set_locale ();
 141         gtk_init (&argc, (char ***) &argv);
 142
 143         /* create new window */
 144         gtk_items.window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 145         g_signal_connect (G_OBJECT (gtk_items.window), "delete_event",
 146                         G_CALLBACK (delete_event), NULL);
 147
 148         g_signal_connect (G_OBJECT (gtk_items.window), "destroy",
 149                         G_CALLBACK (destroy), NULL);
 150
 151         g_signal_connect (G_OBJECT (gtk_items.window), "key_press_event",
 152                         G_CALLBACK (key_press_event), NULL);
 153
 154         g_signal_connect (G_OBJECT (gtk_items.window), "key_release_event",
 155                         G_CALLBACK (key_release_event), NULL);
 156
 157         g_signal_connect (G_OBJECT (gtk_items.window), "size_allocate",
 158                         G_CALLBACK (size_allocate_event), NULL);
 159
 160         gtk_container_set_border_width (GTK_CONTAINER (gtk_items.window), 1);
 161         gtk_window_set_title ((GtkWindow *) gtk_items.window, verstring);
 162
 163         box = gtk_hbox_new(FALSE, 0);
 164         gtk_widget_show(box);
 165         gtk_container_add (GTK_CONTAINER (gtk_items.window), box);
 166
 167         /* live pixmap */
 168         gtk_items.pixmap1 = gtk_image_new ();
 169         gtk_container_add (GTK_CONTAINER (box), gtk_items.pixmap1);
 170         gtk_widget_show (gtk_items.pixmap1);
 171         gtk_widget_set_size_request (gtk_items.pixmap1, 320, 240);
 172
 173         gtk_widget_show  (gtk_items.window);
 174
 175         sem_post(sem);
 176
 177         gtk_main();
 178
 179         printf("linux: gtk thread finishing\n");
 180         exit(1);
 181
 182         return NULL;
 183 }
 184
 185 static void gtk_initf(void)
 186 {
 187         pthread_t gtk_thread;
 188         sem_t sem;
 189         sem_init(&sem, 0, 0);
 190
 191         pthread_create(&gtk_thread, NULL, gtk_threadf, &sem);
 192         pthread_detach(gtk_thread);
 193
 194         sem_wait(&sem);
 195         sem_close(&sem);
 196 }
 197
 198 void finalize_image(guchar *pixels, gpointer data)
 199 {
 200         free(pixels);
 201 }
 202
 203 /* --- */
 204
 205 static void realloc_screen(void)
 206 {
 207         void *old = g_screen_ptr;
 208         g_screen_width = scr_w;
 209         g_screen_height = scr_h;
 210         g_screen_ptr = calloc(g_screen_width * g_screen_height * 2, 1);
 211         free(old);
 212         scr_changed = 0;
 213 }
 214
 215 /* gp2x/emu.c stuff, most to be rm'd */
 216 static void gp2x_video_flip_(void)
 217 {
 218         GdkPixbuf       *pixbuf;
 219         unsigned char   *image;
 220         int             pixel_count, i;
 221
 222         pixel_count = g_screen_width * g_screen_height;
 223
 224         gdk_threads_enter();
 225
 226         image = malloc(pixel_count * 3);
 227         if (image == NULL)
 228         {
 229                 gdk_threads_leave();
 230                 return;
 231         }
 232
 233         if (current_bpp == 8)
 234         {
 235                 unsigned char *pixels = g_screen_ptr;
 236                 int pix;
 237
 238                 for (i = 0; i < pixel_count; i++)
 239                 {
 240                         pix = current_pal[pixels[i]];
 241                         image[3 * i + 0] = pix >> 16;
 242                         image[3 * i + 1] = pix >>  8;
 243                         image[3 * i + 2] = pix;
 244                 }
 245         }
 246         else
 247         {
 248                 unsigned short *pixels = g_screen_ptr;
 249
 250                 for (i = 0; i < pixel_count; i++)
 251                 {
 252                         /*  in:           rrrr rggg gggb bbbb */
 253                         /* out: rrrr r000 gggg gg00 bbbb b000 */
 254                         image[3 * i + 0] = (pixels[i] >> 8) & 0xf8;
 255                         image[3 * i + 1] = (pixels[i] >> 3) & 0xfc;
 256                         image[3 * i + 2] = (pixels[i] << 3);
 257                 }
 258         }
 259
 260         pixbuf = gdk_pixbuf_new_from_data (image, GDK_COLORSPACE_RGB,
 261                         FALSE, 8, g_screen_width, g_screen_height,
 262                         g_screen_width * 3, finalize_image, NULL);
 263         gtk_image_set_from_pixbuf (GTK_IMAGE (gtk_items.pixmap1), pixbuf);
 264         g_object_unref (pixbuf);
 265
 266         gdk_threads_leave();
 267
 268         if (scr_changed)
 269                 realloc_screen();
 270 }
 271
 272 static void gp2x_video_changemode_ll_(int bpp)
 273 {
 274         current_bpp = bpp;
 275 }
 276
 277 static void gp2x_video_setpalette_(int *pal, int len)
 278 {
 279         memcpy(current_pal, pal, len*4);
 280 }
 281
 282 void gp2x_memcpy_all_buffers(void *data, int offset, int len)
 283 {
 284 }
 285
 286 void gp2x_memset_all_buffers(int offset, int byte, int len)
 287 {
 288         memset((char *)g_screen_ptr + offset, byte, len);
 289 }
 290
 291 void gp2x_video_changemode(int bpp)
 292 {
 293         gp2x_video_changemode_ll_(bpp);
 294 }
 295
 296 void gp2x_make_fb_bufferable(int yes)
 297 {
 298 }
 299
 300 int soc_detect(void)
 301 {
 302         return 0;
 303 }
 304
 305 /* plat */
 306 static char menu_bg_buffer[320*240*2];
 307 char cpu_clk_name[16] = "GP2X CPU clocks";
 308
 309 void plat_video_menu_enter(int is_rom_loaded)
 310 {
 311         if (is_rom_loaded)
 312         {
 313                 // darken the active framebuffer
 314                 memset(g_screen_ptr, 0, 320*8*2);
 315                 menu_darken_bg((char *)g_screen_ptr + 320*8*2, 320*224, 1);
 316                 memset((char *)g_screen_ptr + 320*232*2, 0, 320*8*2);
 317         }
 318         else
 319         {
 320                 // should really only happen once, on startup..
 321                 readpng(g_screen_ptr, "skin/background.png", READPNG_BG);
 322         }
 323
 324         memcpy(menu_bg_buffer, g_screen_ptr, 320*240*2);
 325
 326         // switch to 16bpp
 327         gp2x_video_changemode_ll_(16);
 328         gp2x_video_flip_();
 329 }
 330
 331 void plat_video_menu_begin(void)
 332 {
 333         memcpy(g_screen_ptr, menu_bg_buffer, 320*240*2);
 334 }
 335
 336 void plat_video_menu_end(void)
 337 {
 338         gp2x_video_flip_();
 339 }
 340
 341 void plat_validate_config(void)
 342 {
 343 //      PicoOpt &= ~POPT_EXT_FM;
 344 }
 345
 346 void plat_early_init(void)
 347 {
 348 }
 349
 350 void plat_init(void)
 351 {
 352         realloc_screen();
 353         memset(g_screen_ptr, 0, g_screen_width * g_screen_height * 2);
 354
 355         // snd
 356         sndout_oss_init();
 357
 358         gtk_initf();
 359 }
 360
 361 void plat_finish(void)
 362 {
 363         free(g_screen_ptr);
 364         sndout_oss_exit();
 365 }
 366
 367 /* nasty */
 368 static void do_nothing()
 369 {
 370 }
 371
 372 void *gp2x_video_flip = gp2x_video_flip_;
 373 void *gp2x_video_flip2 = gp2x_video_flip_;
 374 void *gp2x_video_changemode_ll = gp2x_video_changemode_ll_;
 375 void *gp2x_video_setpalette = gp2x_video_setpalette_;
 376
 377 void *gp2x_video_RGB_setscaling = do_nothing;
 378 void *gp2x_video_wait_vsync = do_nothing;
 379 void *gp2x_set_cpuclk = do_nothing;
 380 void *set_lcd_custom_rate = do_nothing;
 381 void *unset_lcd_custom_rate = do_nothing;
 382 void *set_lcd_gamma = do_nothing;
 383 void *set_ram_timings = do_nothing;
 384 void *unset_ram_timings = do_nothing;
 385
 386 /* joy */
 387 int gp2x_touchpad_read(int *x, int *y)
 388 {
 389         return -1;
 390 }
 391
 392 /* misc */
 393 void spend_cycles(int c)
 394 {
 395         usleep(c/200);
 396 }
 397
 398 int mp3_get_bitrate(FILE *f, int size)
 399 {
 400         return 128;
 401 }
 402
 403 void mp3_start_play(FILE *f, int pos)
 404 {
 405 }
 406
 407 void mp3_update(int *buffer, int length, int stereo)
 408 {
 409 }
 410
 411 /* lprintf */
 412 void lprintf(const char *fmt, ...)
 413 {
 414         va_list vl;
 415
 416         va_start(vl, fmt);
 417         vprintf(fmt, vl);
 418         va_end(vl);
 419 }
 420