initial GDI driver skeleton

Makefile.common

@@ -1164,6 +1164,11 @@ ifneq ($(findstring Win32,$(OS)),)
           input/drivers_keyboard/keyboard_event_win32.o \
           gfx/common/win32_common.o \
           frontend/drivers/platform_win32.o
+
+   OBJ += gfx/drivers/gdi_gfx.o \
+          gfx/drivers_context/gdi_ctx.o \
+          gfx/drivers_font/gdi_font.o \
+          menu/drivers_display/menu_display_gdi.o
 endif
 
 ifeq ($(HAVE_AVFOUNDATION), 1)

config.def.h

@@ -51,6 +51,8 @@ enum video_driver_enum
    VIDEO_EXYNOS,
    VIDEO_SUNXI,
    VIDEO_DISPMANX,
+   VIDEO_CACA,
+   VIDEO_GDI,
    VIDEO_NULL
 };
 
@@ -209,6 +211,8 @@ enum record_driver_enum
 #define VIDEO_DEFAULT_DRIVER VIDEO_SDL
 #elif defined(HAVE_SDL2)
 #define VIDEO_DEFAULT_DRIVER VIDEO_SDL2
+#elif defined(_WIN32) && !defined(_XBOX)
+#define VIDEO_DEFAULT_DRIVER VIDEO_GDI
 #elif defined(HAVE_DYLIB) && !defined(ANDROID)
 #define VIDEO_DEFAULT_DRIVER VIDEO_EXT
 #else

configuration.c

@@ -310,6 +310,10 @@ const char *config_get_default_video(void)
          return "dispmanx";
       case VIDEO_SUNXI:
          return "sunxi";
+      case VIDEO_CACA:
+         return "caca";
+      case VIDEO_GDI:
+         return "gdi";
       case VIDEO_NULL:
          break;
    }

gfx/common/gdi_common.h

@@ -0,0 +1,26 @@
+/*  RetroArch - A frontend for libretro.
+ *  Copyright (C) 2010-2014 - Hans-Kristian Arntzen
+ *  copyright (c) 2011-2015 - Daniel De Matteis
+ *  copyright (c) 2016 - Brad Parker
+ *
+ *  RetroArch is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  RetroArch is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ *  PURPOSE.  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with RetroArch.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __GDI_COMMON_H
+#define __GDI_COMMON_H
+
+typedef struct gdi
+{
+   bool test;
+} gdi_t;
+
+#endif

gfx/common/win32_common.cpp

@@ -57,6 +57,7 @@ LRESULT win32_menu_loop(HWND owner, WPARAM wparam);
 
 extern "C" bool dinput_handle_message(void *dinput, UINT message,
       WPARAM wParam, LPARAM lParam);
+extern void *dinput_gdi;
 extern void *dinput_wgl;
 extern void *dinput;
 

gfx/drivers/gdi_gfx.c

@@ -0,0 +1,304 @@
+/*  RetroArch - A frontend for libretro.
+ *  Copyright (C) 2010-2014 - Hans-Kristian Arntzen
+ *  Copyright (C) 2011-2016 - Daniel De Matteis
+ *  Copyright (C) 2016 - Brad Parker
+ *
+ *  RetroArch is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  RetroArch is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ *  PURPOSE.  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with RetroArch.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <retro_miscellaneous.h>
+
+#include "../../driver.h"
+#include "../../configuration.h"
+#include "../../verbosity.h"
+#include "../../menu/menu_driver.h"
+#include "../common/gdi_common.h"
+
+static unsigned char *gdi_menu_frame = NULL;
+static unsigned gdi_menu_width = 0;
+static unsigned gdi_menu_height = 0;
+static unsigned gdi_menu_pitch = 0;
+static unsigned gdi_video_width = 0;
+static unsigned gdi_video_height = 0;
+static unsigned gdi_video_pitch = 0;
+static bool gdi_rgb32 = 0;
+
+static void gdi_gfx_free(void *data);
+
+static void gdi_gfx_create()
+{
+   if(!gdi_video_width || !gdi_video_height)
+   {
+      printf("***** GDI: no width or height!\n");
+   }
+
+   //video_driver_set_size(&gdi_video_width, &gdi_video_height);
+}
+
+static void *gdi_gfx_init(const video_info_t *video,
+      const input_driver_t **input, void **input_data)
+{
+   settings_t *settings = config_get_ptr();
+   gdi_t *gdi = (gdi_t*)calloc(1, sizeof(*gdi));
+
+   *input = NULL;
+   *input_data = NULL;
+
+   gdi_video_width = video->width;
+   gdi_video_height = video->height;
+   gdi_rgb32 = video->rgb32;
+
+   if (video->rgb32)
+      gdi_video_pitch = video->width * 4;
+   else
+      gdi_video_pitch = video->width * 2;
+
+   gdi_gfx_create();
+
+   if (settings->video.font_enable)
+      font_driver_init_osd(NULL, false, FONT_DRIVER_RENDER_GDI);
+
+   return gdi;
+}
+
+static bool gdi_gfx_frame(void *data, const void *frame,
+      unsigned frame_width, unsigned frame_height, uint64_t frame_count,
+      unsigned pitch, const char *msg)
+{
+   const void *frame_to_copy = frame;
+   unsigned width = 0;
+   unsigned height = 0;
+   bool draw = true;
+
+   (void)data;
+   (void)frame;
+   (void)frame_width;
+   (void)frame_height;
+   (void)pitch;
+   (void)msg;
+
+   if (!frame || !frame_width || !frame_height)
+      return true;
+
+   if (gdi_video_width != frame_width || gdi_video_height != frame_height || gdi_video_pitch != pitch)
+   {
+      if (frame_width > 4 && frame_height > 4)
+      {
+         gdi_video_width = frame_width;
+         gdi_video_height = frame_height;
+         gdi_video_pitch = pitch;
+         gdi_gfx_free(NULL);
+         gdi_gfx_create();
+      }
+   }
+
+   if (gdi_menu_frame)
+      frame_to_copy = gdi_menu_frame;
+
+   //width = gdi_get_canvas_width(gdi_cv);
+   //height = gdi_get_canvas_height(gdi_cv);
+   width = frame_width;
+   height = frame_height;
+
+   if (frame_to_copy == frame && frame_width == 4 && frame_height == 4 && (frame_width < width && frame_height < height))
+      draw = false;
+
+#ifdef HAVE_MENU
+   menu_driver_ctl(RARCH_MENU_CTL_FRAME, NULL);
+#endif
+
+   if (msg)
+      font_driver_render_msg(NULL, msg, NULL);
+
+   if (draw)
+   {
+      /*gdi_dither_bitmap(gdi_cv, 0, 0,
+                         width,
+                         height,
+                         gdi_dither, frame_to_copy);*/
+   }
+
+   return true;
+}
+
+static void gdi_gfx_set_nonblock_state(void *data, bool toggle)
+{
+   (void)data;
+   (void)toggle;
+}
+
+static bool gdi_gfx_alive(void *data)
+{
+   (void)data;
+   video_driver_set_size(&gdi_video_width, &gdi_video_height);
+   return true;
+}
+
+static bool gdi_gfx_focus(void *data)
+{
+   (void)data;
+   return true;
+}
+
+static bool gdi_gfx_suppress_screensaver(void *data, bool enable)
+{
+   (void)data;
+   (void)enable;
+   return false;
+}
+
+static bool gdi_gfx_has_windowed(void *data)
+{
+   (void)data;
+   return true;
+}
+
+static void gdi_gfx_free(void *data)
+{
+   (void)data;
+
+   if (gdi_menu_frame)
+   {
+      free(gdi_menu_frame);
+      gdi_menu_frame = NULL;
+   }
+}
+
+static bool gdi_gfx_set_shader(void *data,
+      enum rarch_shader_type type, const char *path)
+{
+   (void)data;
+   (void)type;
+   (void)path;
+
+   return false;
+}
+
+static void gdi_gfx_set_rotation(void *data,
+      unsigned rotation)
+{
+   (void)data;
+   (void)rotation;
+}
+
+static void gdi_gfx_viewport_info(void *data,
+      struct video_viewport *vp)
+{
+   (void)data;
+   (void)vp;
+}
+
+static bool gdi_gfx_read_viewport(void *data, uint8_t *buffer)
+{
+   (void)data;
+   (void)buffer;
+
+   return true;
+}
+
+static void gdi_set_texture_frame(void *data,
+      const void *frame, bool rgb32, unsigned width, unsigned height,
+      float alpha)
+{
+   unsigned pitch = width * 2;
+
+   if (rgb32)
+      pitch = width * 4;
+
+   if (gdi_menu_frame)
+   {
+      free(gdi_menu_frame);
+      gdi_menu_frame = NULL;
+   }
+
+   if (!gdi_menu_frame || gdi_menu_width != width || gdi_menu_height != height || gdi_menu_pitch != pitch)
+      if (pitch && height)
+         gdi_menu_frame = (unsigned char*)malloc(pitch * height);
+
+   if (gdi_menu_frame && frame && pitch && height)
+      memcpy(gdi_menu_frame, frame, pitch * height);
+}
+
+static void gdi_set_osd_msg(void *data, const char *msg,
+      const struct font_params *params, void *font)
+{
+   font_driver_render_msg(font, msg, params);
+}
+
+static const video_poke_interface_t gdi_poke_interface = {
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+#ifdef HAVE_FBO
+   NULL,
+#else
+   NULL,
+#endif
+   NULL,
+   NULL,
+   NULL,
+#if defined(HAVE_MENU)
+   gdi_set_texture_frame,
+   NULL,
+   gdi_set_osd_msg,
+   NULL,
+#else
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+#endif
+
+   NULL,
+#ifdef HAVE_MENU
+   NULL,
+#endif
+};
+
+static void gdi_gfx_get_poke_interface(void *data,
+      const video_poke_interface_t **iface)
+{
+   (void)data;
+   *iface = &gdi_poke_interface;
+}
+
+static void gdi_gfx_set_viewport(void *data, unsigned viewport_width,
+      unsigned viewport_height, bool force_full, bool allow_rotate)
+{
+}
+
+video_driver_t video_gdi = {
+   gdi_gfx_init,
+   gdi_gfx_frame,
+   gdi_gfx_set_nonblock_state,
+   gdi_gfx_alive,
+   gdi_gfx_focus,
+   gdi_gfx_suppress_screensaver,
+   gdi_gfx_has_windowed,
+   gdi_gfx_set_shader,
+   gdi_gfx_free,
+   "gdi",
+   gdi_gfx_set_viewport,
+   gdi_gfx_set_rotation,
+   gdi_gfx_viewport_info,
+   gdi_gfx_read_viewport,
+   NULL, /* read_frame_raw */
+
+#ifdef HAVE_OVERLAY
+  NULL, /* overlay_interface */
+#endif
+  gdi_gfx_get_poke_interface,
+};

gfx/drivers_context/gdi_ctx.cpp

@@ -0,0 +1,325 @@
+/*  RetroArch - A frontend for libretro.
+ *  Copyright (C) 2010-2014 - Hans-Kristian Arntzen
+ *  Copyright (C) 2011-2016 - Daniel De Matteis
+ *  Copyright (C) 2016 - Brad Parker
+ * 
+ *  RetroArch is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  RetroArch is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ *  PURPOSE.  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with RetroArch.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/* Win32/GDI context. */
+
+/* necessary for mingw32 multimon defines: */
+#ifndef _WIN32_WINNT
+#define _WIN32_WINNT 0x0500 //_WIN32_WINNT_WIN2K
+#endif
+
+#include <string.h>
+#include <math.h>
+
+#include <windows.h>
+#include <commdlg.h>
+
+#ifdef HAVE_CONFIG_H
+#include "../../config.h"
+#endif
+
+#include "../../configuration.h"
+#include "../../dynamic.h"
+#include "../../runloop.h"
+#include "../../verbosity.h"
+#include "../video_context_driver.h"
+
+#include "../common/win32_common.h"
+
+static HDC   win32_hdc;
+
+static unsigned         win32_major       = 0;
+static unsigned         win32_minor       = 0;
+static unsigned         win32_interval    = 0;
+static enum gfx_ctx_api win32_api         = GFX_CTX_NONE;
+
+void *dinput_gdi;
+
+/*static void setup_pixel_format(HDC hdc)
+{
+   PIXELFORMATDESCRIPTOR pfd = {0};
+   pfd.nSize        = sizeof(PIXELFORMATDESCRIPTOR);
+   pfd.nVersion     = 1;
+   pfd.dwFlags      = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
+   pfd.iPixelType   = PFD_TYPE_RGBA;
+   pfd.cColorBits   = 32;
+   pfd.cDepthBits   = 0;
+   pfd.cStencilBits = 0;
+   pfd.iLayerType   = PFD_MAIN_PLANE;
+
+   SetPixelFormat(hdc, ChoosePixelFormat(hdc, &pfd), &pfd);
+}*/
+
+static void gfx_ctx_gdi_check_window(void *data, bool *quit,
+      bool *resize, unsigned *width, unsigned *height, unsigned frame_count)
+{
+   win32_check_window(quit, resize, width, height);
+}
+
+static bool gfx_ctx_gdi_set_resize(void *data,
+      unsigned width, unsigned height)
+{
+   (void)data;
+   (void)width;
+   (void)height;
+
+   switch (win32_api)
+   {
+      case GFX_CTX_NONE:
+      default:
+         break;
+   }
+
+   return false;
+}
+
+static void gfx_ctx_gdi_update_window_title(void *data)
+{
+   char buf[128];
+   char buf_fps[128];
+   settings_t      *settings = config_get_ptr();
+   const ui_window_t *window = ui_companion_driver_get_window_ptr();
+
+   buf[0] = buf_fps[0] = '\0';
+
+   if (window && video_monitor_get_fps(buf, sizeof(buf),
+            buf_fps, sizeof(buf_fps)))
+      window->set_title(&main_window, buf);
+   if (settings->fps_show)
+      runloop_msg_queue_push(buf_fps, 1, 1, false);
+}
+
+static void gfx_ctx_gdi_get_video_size(void *data,
+      unsigned *width, unsigned *height)
+{
+   (void)data;
+   HWND         window  = win32_get_window();
+
+   if (!window)
+   {
+      RECT mon_rect;
+      MONITORINFOEX current_mon;
+      unsigned mon_id           = 0;
+      HMONITOR hm_to_use        = NULL;
+
+      win32_monitor_info(&current_mon, &hm_to_use, &mon_id);
+      mon_rect = current_mon.rcMonitor;
+      *width  = mon_rect.right - mon_rect.left;
+      *height = mon_rect.bottom - mon_rect.top;
+   }
+   else
+   {
+      *width  = g_resize_width;
+      *height = g_resize_height;
+   }
+}
+
+static void *gfx_ctx_gdi_init(void *video_driver)
+{
+   WNDCLASSEX wndclass = {0};
+
+   (void)video_driver;
+
+   if (g_inited)
+      return NULL;
+   
+   win32_window_reset();
+   win32_monitor_init();
+
+   wndclass.lpfnWndProc   = WndProcGL;
+   if (!win32_window_init(&wndclass, true, NULL))
+           return NULL;
+
+   switch (win32_api)
+   {
+      case GFX_CTX_NONE:
+      default:
+         break;
+   }
+
+   return (void*)"gdi";
+}
+
+static void gfx_ctx_gdi_destroy(void *data)
+{
+   HWND     window  = win32_get_window();
+
+   (void)data;
+
+   switch (win32_api)
+   {
+      case GFX_CTX_NONE:
+      default:
+         break;
+   }
+
+   if (window && win32_hdc)
+   {
+      ReleaseDC(window, win32_hdc);
+      win32_hdc = NULL;
+   }
+
+   if (window)
+   {
+      win32_monitor_from_window();
+      win32_destroy_window();
+   }
+
+   if (g_restore_desktop)
+   {
+      win32_monitor_get_info();
+      g_restore_desktop     = false;
+   }
+
+   g_inited                     = false;
+   win32_major                  = 0;
+   win32_minor                  = 0;
+}
+
+static bool gfx_ctx_gdi_set_video_mode(void *data,
+      unsigned width, unsigned height,
+      bool fullscreen)
+{
+   if (!win32_set_video_mode(NULL, width, height, fullscreen))
+   {
+      RARCH_ERR("[GDI]: win32_set_video_mode failed.\n");
+      goto error;
+   }
+
+   switch (win32_api)
+   {
+      case GFX_CTX_NONE:
+      default:
+         break;
+   }
+
+   return true;
+
+error:
+   gfx_ctx_gdi_destroy(data);
+   return false;
+}
+
+
+static void gfx_ctx_gdi_input_driver(void *data,
+      const input_driver_t **input, void **input_data)
+{
+   (void)data;
+
+   dinput_gdi   = input_dinput.init();
+
+   *input       = dinput_gdi ? &input_dinput : NULL;
+   *input_data  = dinput_gdi;
+}
+
+static bool gfx_ctx_gdi_has_focus(void *data)
+{
+   return win32_has_focus();
+}
+
+static bool gfx_ctx_gdi_suppress_screensaver(void *data, bool enable)
+{
+   return win32_suppress_screensaver(data, enable);
+}
+
+static bool gfx_ctx_gdi_has_windowed(void *data)
+{
+   (void)data;
+
+   return true;
+}
+
+static bool gfx_ctx_gdi_get_metrics(void *data,
+	enum display_metric_types type, float *value)
+{
+   return win32_get_metrics(data, type, value);
+}
+
+static bool gfx_ctx_gdi_bind_api(void *data,
+      enum gfx_ctx_api api, unsigned major, unsigned minor)
+{
+   (void)data;
+
+   win32_major = major;
+   win32_minor = minor;
+   win32_api   = api;
+
+   return true;
+}
+
+static void gfx_ctx_gdi_show_mouse(void *data, bool state)
+{
+   (void)data;
+   win32_show_cursor(state);
+}
+
+static void gfx_ctx_gdi_swap_interval(void *data, unsigned interval)
+{
+   (void)data;
+   (void)interval;
+}
+
+static void gfx_ctx_gdi_set_flags(void *data, uint32_t flags)
+{
+   (void)data;
+   (void)flags;
+}
+
+static uint32_t gfx_ctx_gdi_get_flags(void *data)
+{
+   uint32_t flags = 0;
+   BIT32_SET(flags, GFX_CTX_FLAGS_NONE);
+   return flags;
+}
+
+static void gfx_ctx_gdi_swap_buffers(void *data)
+{
+   (void)data;
+}
+
+const gfx_ctx_driver_t gfx_ctx_gdi = {
+   gfx_ctx_gdi_init,
+   gfx_ctx_gdi_destroy,
+   gfx_ctx_gdi_bind_api,
+   gfx_ctx_gdi_swap_interval,
+   gfx_ctx_gdi_set_video_mode,
+   gfx_ctx_gdi_get_video_size,
+   NULL, /* get_video_output_size */
+   NULL, /* get_video_output_prev */
+   NULL, /* get_video_output_next */
+   gfx_ctx_gdi_get_metrics,
+   NULL,
+   gfx_ctx_gdi_update_window_title,
+   gfx_ctx_gdi_check_window,
+   gfx_ctx_gdi_set_resize,
+   gfx_ctx_gdi_has_focus,
+   gfx_ctx_gdi_suppress_screensaver,
+   gfx_ctx_gdi_has_windowed,
+   gfx_ctx_gdi_swap_buffers,
+   gfx_ctx_gdi_input_driver,
+   NULL,
+   NULL,
+   NULL,
+   gfx_ctx_gdi_show_mouse,
+   "gdi",
+   gfx_ctx_gdi_get_flags,
+   gfx_ctx_gdi_set_flags,
+   NULL,
+   NULL,
+   NULL
+};
+

gfx/drivers_font/gdi_font.c

@@ -0,0 +1,133 @@
+/*  RetroArch - A frontend for libretro.
+ *  Copyright (C) 2010-2014 - Hans-Kristian Arntzen
+ *  Copyright (C) 2011-2016 - Daniel De Matteis
+ *  Copyright (C) 2016 - Brad Parker
+ * 
+ *  RetroArch is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  RetroArch is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ *  PURPOSE.  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with RetroArch.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdlib.h>
+#include <string/stdstring.h>
+
+#ifdef HAVE_CONFIG_H
+#include "../../config.h"
+#endif
+
+#include "../font_driver.h"
+#include "../../configuration.h"
+#include "../../verbosity.h"
+#include "../common/gdi_common.h"
+
+typedef struct
+{
+   const font_renderer_driver_t *gdi_font_driver;
+   void *gdi_font_data;
+   gdi_t *gdi;
+} gdi_raster_t;
+
+static void *gdi_init_font(void *data,
+      const char *font_path, float font_size)
+{
+   gdi_raster_t *font  = (gdi_raster_t*)calloc(1, sizeof(*font));
+
+   if (!font)
+      return NULL;
+
+   font->gdi = (gdi_t*)data;
+
+   font_size = 1;
+
+   if (!font_renderer_create_default((const void**)&font->gdi_font_driver,
+            &font->gdi_font_data, font_path, font_size))
+   {
+      RARCH_WARN("Couldn't initialize font renderer.\n");
+      return NULL;
+   }
+
+   return font;
+}
+
+static void gdi_render_free_font(void *data)
+{
+
+}
+
+static int gdi_get_message_width(void *data, const char *msg,
+      unsigned msg_len, float scale)
+{
+   return 0;
+}
+
+static const struct font_glyph *gdi_font_get_glyph(
+      void *data, uint32_t code)
+{
+   return NULL;
+}
+
+static void gdi_render_msg(void *data, const char *msg,
+      const void *userdata)
+{
+   gdi_raster_t *font = (gdi_raster_t*)data;
+   float x, y;
+   unsigned width = 0, height = 0;
+   unsigned newX, newY;
+   settings_t *settings = config_get_ptr();
+   const struct font_params *params = (const struct font_params*)userdata;
+
+   if (!font || string_is_empty(msg))
+      return;
+
+   if (params)
+   {
+      x = params->x;
+      y = params->y;
+   }
+   else
+   {
+      x = settings->video.msg_pos_x;
+      y = settings->video.msg_pos_y;
+   }
+
+   if (!font->gdi)
+      return;
+
+   newX = x * width;
+   newY = height - (y * height);
+
+   if (strlen(msg) + newX > width)
+      newX -= strlen(msg) + newX - width;
+
+   //gdi_put_str(*font->gdi->gdi_cv, newX, newY, msg);
+
+   //gdi_refresh_display(*font->gdi->gdi_display);
+}
+
+static void gdi_font_flush_block(void* data)
+{
+   (void)data;
+}
+
+static void gdi_font_bind_block(void* data, void* userdata)
+{
+   (void)data;
+}
+
+font_renderer_t gdi_font = {
+   gdi_init_font,
+   gdi_render_free_font,
+   gdi_render_msg,
+   "gdi font",
+   gdi_font_get_glyph,       /* get_glyph */
+   gdi_font_bind_block,      /* bind_block */
+   gdi_font_flush_block,     /* flush */
+   gdi_get_message_width     /* get_message_width */
+};

gfx/font_driver.c

@@ -178,6 +178,35 @@ static bool caca_font_init_first(
 }
 #endif
 
+#if defined(_WIN32) && !defined(_XBOX)
+static const font_renderer_t *gdi_font_backends[] = {
+   &gdi_font,
+   NULL,
+};
+
+static bool gdi_font_init_first(
+      const void **font_driver, void **font_handle,
+      void *video_data, const char *font_path, float font_size)
+{
+   unsigned i;
+
+   for (i = 0; gdi_font_backends[i]; i++)
+   {
+      void *data = gdi_font_backends[i]->init(
+            video_data, font_path, font_size);
+
+      if (!data)
+         continue;
+
+      *font_driver = gdi_font_backends[i];
+      *font_handle = data;
+      return true;
+   }
+
+   return false;
+}
+#endif
+
 #ifdef HAVE_VULKAN
 static const font_renderer_t *vulkan_font_backends[] = {
    &vulkan_raster_font,
@@ -301,6 +330,11 @@ static bool font_init_first(
       case FONT_DRIVER_RENDER_CACA:
          return caca_font_init_first(font_driver, font_handle,
                video_data, font_path, font_size);
+#endif
+#if defined(_WIN32) && !defined(_XBOX)
+      case FONT_DRIVER_RENDER_GDI:
+         return gdi_font_init_first(font_driver, font_handle,
+               video_data, font_path, font_size);
 #endif
       case FONT_DRIVER_RENDER_DONT_CARE:
          /* TODO/FIXME - lookup graphics driver's 'API' */

gfx/font_driver.h

@@ -32,7 +32,8 @@ enum font_driver_render_api
    FONT_DRIVER_RENDER_VITA2D,
    FONT_DRIVER_RENDER_CTR,
    FONT_DRIVER_RENDER_VULKAN_API,
-   FONT_DRIVER_RENDER_CACA
+   FONT_DRIVER_RENDER_CACA,
+   FONT_DRIVER_RENDER_GDI
 };
 
 enum text_alignment
@@ -164,6 +165,7 @@ extern font_renderer_t vita2d_vita_font;
 extern font_renderer_t ctr_font;
 extern font_renderer_t vulkan_raster_font;
 extern font_renderer_t caca_font;
+extern font_renderer_t gdi_font;
 
 extern font_renderer_driver_t stb_font_renderer;
 extern font_renderer_driver_t stb_unicode_font_renderer;

gfx/video_context_driver.c

@@ -88,6 +88,9 @@ static const gfx_ctx_driver_t *gfx_ctx_drivers[] = {
 #endif
 #if defined(HAVE_VULKAN) && defined(HAVE_VULKAN_DISPLAY)
    &gfx_ctx_khr_display,
+#endif
+#if defined(_WIN32) && !defined(_XBOX)
+   &gfx_ctx_gdi,
 #endif
    &gfx_ctx_null,
    NULL

gfx/video_context_driver.h

@@ -249,6 +249,7 @@ extern const gfx_ctx_driver_t gfx_ctx_cocoagl;
 extern const gfx_ctx_driver_t gfx_ctx_emscripten;
 extern const gfx_ctx_driver_t gfx_ctx_opendingux_fbdev;
 extern const gfx_ctx_driver_t gfx_ctx_khr_display;
+extern const gfx_ctx_driver_t gfx_ctx_gdi;
 extern const gfx_ctx_driver_t gfx_ctx_null;
 
 /**

gfx/video_driver.c

@@ -227,6 +227,9 @@ static const video_driver_t *video_drivers[] = {
 #ifdef HAVE_XSHM
    &video_xshm,
 #endif
+#if defined(_WIN32) && !defined(_XBOX)
+   &video_gdi,
+#endif
 #ifdef HAVE_CACA
    &video_caca,
 #endif

gfx/video_driver.h

@@ -563,6 +563,7 @@ extern video_driver_t video_sunxi;
 extern video_driver_t video_drm;
 extern video_driver_t video_xshm;
 extern video_driver_t video_caca;
+extern video_driver_t video_gdi;
 extern video_driver_t video_null;
 
 extern const void *frame_cache_data;

griffin/griffin.c

@@ -402,6 +402,9 @@ FONTS
 #include "../gfx/drivers_font/caca_font.c"
 #endif
 
+#if defined(_WIN32) && !defined(_XBOX)
+#include "../gfx/drivers_font/gdi_font.c"
+#endif
 
 #if defined(HAVE_VULKAN)
 #include "../gfx/drivers_font/vulkan_raster_font.c"
@@ -994,6 +997,10 @@ MENU
 #include "../menu/drivers_display/menu_display_caca.c"
 #endif
 
+#if defined(_WIN32) && !defined(_XBOX)
+#include "../menu/drivers_display/menu_display_gdi.c"
+#endif
+
 #endif
 
 

menu/drivers_display/menu_display_gdi.c

@@ -0,0 +1,101 @@
+/*  RetroArch - A frontend for libretro.
+ *  Copyright (C) 2011-2016 - Daniel De Matteis
+ *  Copyright (C) 2016 - Brad Parker
+ *
+ *  RetroArch is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  RetroArch is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ *  PURPOSE.  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with RetroArch.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <time.h>
+
+#include <queues/message_queue.h>
+#include <retro_miscellaneous.h>
+
+#include "../../config.def.h"
+#include "../../gfx/font_driver.h"
+#include "../../gfx/video_context_driver.h"
+
+#include "../menu_display.h"
+
+static void *menu_display_gdi_get_default_mvp(void)
+{
+   return NULL;
+}
+
+static void menu_display_gdi_blend_begin(void)
+{
+}
+
+static void menu_display_gdi_blend_end(void)
+{
+}
+
+static void menu_display_gdi_draw(void *data)
+{
+   (void)data;
+}
+
+static void menu_display_gdi_draw_pipeline(void *data)
+{
+   (void)data;
+}
+
+static void menu_display_gdi_viewport(void *data)
+{
+   (void)data;
+}
+
+static void menu_display_gdi_restore_clear_color(void)
+{
+}
+
+static void menu_display_gdi_clear_color(menu_display_ctx_clearcolor_t *clearcolor)
+{
+   (void)clearcolor;
+}
+
+static bool menu_display_gdi_font_init_first(
+      void **font_handle, void *video_data,
+      const char *font_path, float font_size)
+{
+   font_data_t **handle = (font_data_t**)font_handle;
+   *handle = font_driver_init_first(video_data,
+         font_path, font_size, true, FONT_DRIVER_RENDER_GDI);
+   return *handle;
+}
+
+static const float *menu_display_gdi_get_default_vertices(void)
+{
+   static float dummy[16] = {0.0f};
+   return &dummy[0];
+}
+
+static const float *menu_display_gdi_get_default_tex_coords(void)
+{
+   static float dummy[16] = {0.0f};
+   return &dummy[0];
+}
+
+menu_display_ctx_driver_t menu_display_ctx_gdi = {
+   menu_display_gdi_draw,
+   menu_display_gdi_draw_pipeline,
+   menu_display_gdi_viewport,
+   menu_display_gdi_blend_begin,
+   menu_display_gdi_blend_end,
+   menu_display_gdi_restore_clear_color,
+   menu_display_gdi_clear_color,
+   menu_display_gdi_get_default_mvp,
+   menu_display_gdi_get_default_vertices,
+   menu_display_gdi_get_default_tex_coords,
+   menu_display_gdi_font_init_first,
+   MENU_VIDEO_DRIVER_GDI,
+   "menu_display_gdi",
+};

menu/menu_display.c

@@ -82,6 +82,9 @@ static menu_display_ctx_driver_t *menu_display_ctx_drivers[] = {
 #endif
 #ifdef HAVE_CACA
    &menu_display_ctx_caca,
+#endif
+#if defined(_WIN32) && !defined(_XBOX)
+   &menu_display_ctx_gdi,
 #endif
    &menu_display_ctx_null,
    NULL,
@@ -140,6 +143,10 @@ static bool menu_display_check_compatibility(
          if (string_is_equal(video_driver, "caca"))
             return true;
          break;
+      case MENU_VIDEO_DRIVER_GDI:
+         if (string_is_equal(video_driver, "gdi"))
+            return true;
+         break;
    }
 
    return false;

menu/menu_display.h

@@ -95,7 +95,8 @@ enum menu_display_driver_type
    MENU_VIDEO_DRIVER_DIRECT3D,
    MENU_VIDEO_DRIVER_VITA2D,
    MENU_VIDEO_DRIVER_CTR,
-   MENU_VIDEO_DRIVER_CACA
+   MENU_VIDEO_DRIVER_CACA,
+   MENU_VIDEO_DRIVER_GDI
 };
 
 typedef struct menu_display_ctx_clearcolor
@@ -294,6 +295,7 @@ extern menu_display_ctx_driver_t menu_display_ctx_d3d;
 extern menu_display_ctx_driver_t menu_display_ctx_vita2d;
 extern menu_display_ctx_driver_t menu_display_ctx_ctr;
 extern menu_display_ctx_driver_t menu_display_ctx_caca;
+extern menu_display_ctx_driver_t menu_display_ctx_gdi;
 extern menu_display_ctx_driver_t menu_display_ctx_null;
 
 RETRO_END_DECLS