/*

    SDL - Simple DirectMedia Layer

    Copyright (C) 1997-2009 Sam Lantinga

    This library is free software; you can redistribute it and/or

    modify it under the terms of the GNU Lesser General Public

    License as published by the Free Software Foundation; either

    version 2.1 of the License, or (at your option) any later version.

    This library 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

    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public

    License along with this library; if not, write to the Free Software

    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    Sam Lantinga

    slouken@libsdl.org

    QNX Graphics Framework SDL driver

    Copyright (C) 2009 Mike Gorchak

    (mike@malva.ua, lestat@i.com.ua)

*/

#include "SDL_config.h"

#include "../SDL_sysvideo.h"

#include "SDL_version.h"

#include "SDL_syswm.h"

#include "SDL_loadso.h"

/* Include QNX Graphics Framework declarations */

#include <gf/gf.h>

#include "SDL_qnxgf.h"

#include "SDL_gf_render.h"

#include "SDL_gf_pixelfmt.h"

#include "SDL_gf_opengles.h"

#include "SDL_gf_input.h"

/******************************************************************************/

/* SDL Generic video modes, which could provide GF                            */

/* This is real pain in the ass. GF is just wrapper around a selected driver  */

/* some drivers could support double scan modes, like 320x200, 512x384, etc   */

/* but some drivers are not. Later we can distinguish one driver from another */

/* Feel free to add any new custom graphics mode                              */

/******************************************************************************/

static SDL_DisplayMode generic_mode[]=

{

   {0, 320,  200,  70,  NULL}, /* 320x200 modes are 70Hz and 85Hz          */

   {0, 320,  200,  85,  NULL},

   {0, 320,  240,  70,  NULL}, /* 320x240 modes are 70Hz and 85Hz          */

   {0, 320,  240,  85,  NULL},

   {0, 512,  384,  60,  NULL}, /* 512x384 modes are 60Hz and 70Hz          */

   {0, 512,  384,  70,  NULL},

   {0, 640,  480,  60,  NULL}, /* 640x480 modes are 60Hz, 75Hz, 85Hz       */

   {0, 640,  480,  75,  NULL},

   {0, 640,  480,  85,  NULL},

   {0, 800,  600,  60,  NULL}, /* 800x600 modes are 60Hz, 75Hz, 85Hz       */

   {0, 800,  600,  75,  NULL},

   {0, 800,  600,  85,  NULL},

   {0, 800,  480,  60,  NULL}, /* 800x480 mode is 60Hz only                */

   {0, 1024, 640,  60,  NULL}, /* 1024x640 mode is 60Hz only               */

   {0, 1024, 768,  60,  NULL}, /* 1024x768 modes are 60Hz, 70Hz, 75Hz      */

   {0, 1024, 768,  70,  NULL},

   {0, 1024, 768,  75,  NULL},

   {0, 1280, 720,  60,  NULL}, /* 1280x720 mode is 60Hz only               */

   {0, 1280, 768,  60,  NULL}, /* 1280x768 mode is 60Hz only               */

   {0, 1280, 800,  60,  NULL}, /* 1280x800 mode is 60Hz only               */

   {0, 1280, 960,  60,  NULL}, /* 1280x960 mode is 60Hz only               */

   {0, 1280, 1024, 60,  NULL}, /* 1280x1024 modes are 60Hz, 75Hz, 85Hz and */

   {0, 1280, 1024, 75,  NULL}, /* 100 Hz                                   */

   {0, 1280, 1024, 85,  NULL}, /*                                          */

   {0, 1280, 1024, 100, NULL}, /*                                          */

   {0, 1400, 1050, 60,  NULL}, /* 1400x1050 mode is 60Hz only              */

   {0, 1440, 900,  60,  NULL}, /* 1440x900 mode is 60Hz only               */

   {0, 1440, 960,  60,  NULL}, /* 1440x960 mode is 60Hz only               */

   {0, 1600, 1200, 60,  NULL}, /* 1600x1200 mode is 60Hz only              */

   {0, 1680, 1050, 60,  NULL}, /* 1680x1050 mode is 60Hz only              */

   {0, 1920, 1080, 60,  NULL}, /* 1920x1080 mode is 60Hz only              */

   {0, 1920, 1200, 60,  NULL}, /* 1920x1200 mode is 60Hz only              */

   {0, 2048, 1536, 60,  NULL}, /* 2048x1536 mode is 60Hz only              */

   {0, 2048, 1080, 60,  NULL}, /* 2048x1080 mode is 60Hz only              */

   {0,    0,    0,  0,  NULL}  /* End of generic mode list                 */

};

/* Low level device graphics driver names, which they are reporting */

GF_DeviceCaps gf_devicename[]=

{

   /* ATI Rage 128 graphics driver (devg-ati_rage128)      */

   {"ati_rage128", SDL_GF_ACCELERATED | SDL_GF_NOLOWRESOLUTION |

                   SDL_GF_UNACCELERATED_3D | SDL_GF_VIDEOMEMORY},

   /* Fujitsu Carmine graphics driver (devg-carmine.so)    */

   {"carmine",     SDL_GF_ACCELERATED | SDL_GF_NOLOWRESOLUTION |

                   SDL_GF_ACCELERATED_3D | SDL_GF_VIDEOMEMORY},

   /* C&T graphics driver (devg-chips.so)                  */

   {"chips",       SDL_GF_ACCELERATED | SDL_GF_NOLOWRESOLUTION | 

                   SDL_GF_UNACCELERATED_3D | SDL_GF_VIDEOMEMORY},

   /* Fujitsu Coral graphics driver (devg-coral.so)        */

   {"coral",       SDL_GF_ACCELERATED | SDL_GF_NOLOWRESOLUTION |

                   SDL_GF_ACCELERATED_3D | SDL_GF_VIDEOMEMORY},

   /* Intel integrated graphics driver (devg-extreme2.so)  */

   {"extreme2",    SDL_GF_ACCELERATED | SDL_GF_NOLOWRESOLUTION |

                   SDL_GF_ACCELERATED_3D | SDL_GF_VIDEOMEMORY},

   /* Unaccelerated FB driver (devg-flat.so)               */

   {"flat",        SDL_GF_UNACCELERATED | SDL_GF_LOWRESOLUTION |

                   SDL_GF_UNACCELERATED_3D | SDL_GF_NOVIDEOMEMORY},

   /* NS Geode graphics driver (devg-geode.so)             */

   {"geode",       SDL_GF_ACCELERATED | SDL_GF_NOLOWRESOLUTION |

                   SDL_GF_UNACCELERATED_3D | SDL_GF_VIDEOMEMORY},

   /* Geode LX graphics driver (devg-geodelx.so)           */

   {"geodelx",     SDL_GF_ACCELERATED | SDL_GF_LOWRESOLUTION |

                   SDL_GF_UNACCELERATED_3D | SDL_GF_VIDEOMEMORY},

   /* Intel integrated graphics driver (devg-gma9xx.so)    */

   {"gma",         SDL_GF_ACCELERATED | SDL_GF_NOLOWRESOLUTION |

                   SDL_GF_ACCELERATED_3D | SDL_GF_VIDEOMEMORY},

   /* Intel integrated graphics driver (devg-i810.so)      */

   {"i810",        SDL_GF_ACCELERATED | SDL_GF_NOLOWRESOLUTION |

                   SDL_GF_UNACCELERATED_3D | SDL_GF_VIDEOMEMORY},

   /* Intel integrated graphics driver (devg-i830.so)      */

   {"i830",        SDL_GF_ACCELERATED | SDL_GF_NOLOWRESOLUTION |

                   SDL_GF_UNACCELERATED_3D | SDL_GF_VIDEOMEMORY},

   /* Geode LX graphics driver (devg-lx800.so)             */

   {"lx800",       SDL_GF_ACCELERATED | SDL_GF_NOLOWRESOLUTION |

                   SDL_GF_UNACCELERATED_3D | SDL_GF_VIDEOMEMORY},

   /* Matrox Gxx graphics driver (devg-matroxg.so)         */

   {"matroxg",     SDL_GF_ACCELERATED | SDL_GF_NOLOWRESOLUTION |

                   SDL_GF_UNACCELERATED_3D | SDL_GF_VIDEOMEMORY},

   /* Intel Poulsbo graphics driver (devg-poulsbo.so)      */

   {"poulsbo",     SDL_GF_ACCELERATED | SDL_GF_NOLOWRESOLUTION |

                   SDL_GF_ACCELERATED_3D | SDL_GF_VIDEOMEMORY},

   /* ATI Radeon driver (devg-radeon.so)                   */

   {"radeon",      SDL_GF_ACCELERATED | SDL_GF_NOLOWRESOLUTION |

                   SDL_GF_UNACCELERATED_3D | SDL_GF_VIDEOMEMORY},

   /* ATI Rage driver (devg-rage.so)                       */

   {"rage",        SDL_GF_ACCELERATED | SDL_GF_NOLOWRESOLUTION |

                   SDL_GF_UNACCELERATED_3D | SDL_GF_VIDEOMEMORY},

   /* S3 Savage graphics driver (devg-s3_savage.so)        */

   {"s3_savage",   SDL_GF_ACCELERATED | SDL_GF_NOLOWRESOLUTION |

                   SDL_GF_UNACCELERATED_3D | SDL_GF_VIDEOMEMORY},

   /* SiS630 integrated graphics driver (devg-sis630.so)   */

   {"sis630",      SDL_GF_ACCELERATED | SDL_GF_NOLOWRESOLUTION |

                   SDL_GF_UNACCELERATED_3D | SDL_GF_VIDEOMEMORY},

   /* PowerVR SGX 535 graphics driver (devg-poulsbo.so)    */

   {"sgx",         SDL_GF_ACCELERATED | SDL_GF_NOLOWRESOLUTION |

                   SDL_GF_ACCELERATED_3D | SDL_GF_VIDEOMEMORY},

   /* SM Voyager GX graphics driver (devg-smi5xx.so)       */

   {"smi5xx",      SDL_GF_ACCELERATED | SDL_GF_NOLOWRESOLUTION |

                   SDL_GF_UNACCELERATED_3D | SDL_GF_VIDEOMEMORY},

   /* Silicon Motion graphics driver (devg-smi7xx.so)      */

   {"smi7xx",      SDL_GF_ACCELERATED | SDL_GF_NOLOWRESOLUTION |

                   SDL_GF_UNACCELERATED_3D | SDL_GF_VIDEOMEMORY},

   /* SVGA unaccelerated gfx driver (devg-svga.so)         */

   {"svga",        SDL_GF_UNACCELERATED | SDL_GF_LOWRESOLUTION |

                   SDL_GF_UNACCELERATED_3D | SDL_GF_NOVIDEOMEMORY},

   /* nVidia TNT graphics driver (devg-tnt.so)             */

   {"tnt",         SDL_GF_ACCELERATED | SDL_GF_NOLOWRESOLUTION |

                   SDL_GF_UNACCELERATED_3D | SDL_GF_VIDEOMEMORY},

   /* VIA integrated graphics driver (devg-tvia.so)        */

   {"tvia",        SDL_GF_ACCELERATED | SDL_GF_NOLOWRESOLUTION |

                   SDL_GF_UNACCELERATED_3D | SDL_GF_VIDEOMEMORY},

   /* VIA UniChrome graphics driver (devg-unichrome.so)    */

   {"unichrome",   SDL_GF_ACCELERATED | SDL_GF_NOLOWRESOLUTION | 

                   SDL_GF_UNACCELERATED_3D | SDL_GF_VIDEOMEMORY},

   /* VESA unaccelerated gfx driver (devg-vesa.so)         */

   {"vesa",        SDL_GF_UNACCELERATED | SDL_GF_LOWRESOLUTION |

                   SDL_GF_UNACCELERATED_3D | SDL_GF_NOVIDEOMEMORY},

   /* VmWare graphics driver (devg-volari.so)              */

   {"vmware",      SDL_GF_ACCELERATED | SDL_GF_LOWRESOLUTION |

                   SDL_GF_UNACCELERATED_3D | SDL_GF_NOVIDEOMEMORY},

   /* XGI XP10 graphics driver (devg-volari.so)            */

   {"volari",      SDL_GF_ACCELERATED | SDL_GF_LOWRESOLUTION |

                   SDL_GF_UNACCELERATED_3D | SDL_GF_VIDEOMEMORY},

   /* End of list */

   {NULL,          0x00000000}

};

/*****************************************************************************/

/* SDL Video Device initialization functions                                 */

/*****************************************************************************/

static int qnxgf_available(void)

{

   gf_dev_t gfdev;

   gf_dev_info_t gfdev_info;

   int status;

   /* Try to attach to graphics device driver */

   status=gf_dev_attach(&gfdev, GF_DEVICE_INDEX(0), &gfdev_info);

   if (status!=GF_ERR_OK)

   {

      return 0;

   }

   /* Detach from graphics device driver for now */

   gf_dev_detach(gfdev);

   return 1;

}

static void qnxgf_destroy(SDL_VideoDevice* device)

{

   SDL_VideoData* gfdata=(SDL_VideoData*) device->driverdata;

   /* Detach from graphics device driver, if it was initialized */

   if (gfdata->gfinitialized!=SDL_FALSE)

   {

      gf_dev_detach(gfdata->gfdev);

   }

   if (device->driverdata!=NULL)

   {

      device->driverdata=NULL;

   }

}

static SDL_VideoDevice* qnxgf_create(int devindex)

{

   SDL_VideoDevice* device;

   SDL_VideoData*   gfdata;

   int              status;

   /* Initialize SDL_VideoDevice structure */

   device=(SDL_VideoDevice*)SDL_calloc(1, sizeof(SDL_VideoDevice));

   if (device==NULL)

   {

      SDL_OutOfMemory();

      return NULL;

   }

   /* Initialize internal GF specific data */

   gfdata=(SDL_VideoData*)SDL_calloc(1, sizeof(SDL_VideoData));

   if (gfdata==NULL)

   {

      SDL_OutOfMemory();

      SDL_free(device);

      return NULL;

   }

   device->driverdata=gfdata;

   /* Try to attach to graphics device driver */

   status=gf_dev_attach(&gfdata->gfdev, GF_DEVICE_INDEX(devindex), &gfdata->gfdev_info);

   if (status!=GF_ERR_OK)

   {

      SDL_OutOfMemory();

      SDL_free(gfdata);

      SDL_free(device);

      return NULL;

   }

   if (gfdata->gfdev_info.description==NULL)

   {

      gf_dev_detach(gfdata->gfdev);

      SDL_SetError("GF: Failed to initialize graphics driver");

      return NULL;

   }

   /* Setup amount of available displays and current display */

   device->num_displays=0;

   device->current_display=0;

   /* Setup device shutdown function */

   gfdata->gfinitialized=SDL_TRUE;

   device->free=qnxgf_destroy;

   /* Setup all functions which we can handle */

   device->VideoInit=qnxgf_videoinit;

   device->VideoQuit=qnxgf_videoquit;

   device->GetDisplayModes=qnxgf_getdisplaymodes;

   device->SetDisplayMode=qnxgf_setdisplaymode;

   device->SetDisplayPalette=qnxgf_setdisplaypalette;

   device->GetDisplayPalette=qnxgf_getdisplaypalette;

   device->SetDisplayGammaRamp=qnxgf_setdisplaygammaramp;

   device->GetDisplayGammaRamp=qnxgf_getdisplaygammaramp;

   device->CreateWindow=qnxgf_createwindow;

   device->CreateWindowFrom=qnxgf_createwindowfrom;

   device->SetWindowTitle=qnxgf_setwindowtitle;

   device->SetWindowIcon=qnxgf_setwindowicon;

   device->SetWindowPosition=qnxgf_setwindowposition;

   device->SetWindowSize=qnxgf_setwindowsize;

   device->ShowWindow=qnxgf_showwindow;

   device->HideWindow=qnxgf_hidewindow;

   device->RaiseWindow=qnxgf_raisewindow;

   device->MaximizeWindow=qnxgf_maximizewindow;

   device->MinimizeWindow=qnxgf_minimizewindow;

   device->RestoreWindow=qnxgf_restorewindow;

   device->SetWindowGrab=qnxgf_setwindowgrab;

   device->DestroyWindow=qnxgf_destroywindow;

   device->GetWindowWMInfo=qnxgf_getwindowwminfo;

   device->GL_LoadLibrary=qnxgf_gl_loadlibrary;

   device->GL_GetProcAddress=qnxgf_gl_getprocaddres;

   device->GL_UnloadLibrary=qnxgf_gl_unloadlibrary;

   device->GL_CreateContext=qnxgf_gl_createcontext;

   device->GL_MakeCurrent=qnxgf_gl_makecurrent;

   device->GL_SetSwapInterval=qnxgf_gl_setswapinterval;

   device->GL_GetSwapInterval=qnxgf_gl_getswapinterval;

   device->GL_SwapWindow=qnxgf_gl_swapwindow;

   device->GL_DeleteContext=qnxgf_gl_deletecontext;

   device->PumpEvents=qnxgf_pumpevents;

   device->SuspendScreenSaver=qnxgf_suspendscreensaver;

   return device;

}

VideoBootStrap qnxgf_bootstrap=

{

   "qnxgf",

   "SDL QNX Graphics Framework (GF) video driver",

   qnxgf_available,

   qnxgf_create

};

/*****************************************************************************/

/* SDL Video and Display initialization/handling functions                   */

/*****************************************************************************/

int qnxgf_videoinit(_THIS)

{

   SDL_VideoData* gfdata=(SDL_VideoData*)_this->driverdata;

   uint32_t it;

   uint32_t jt;

   char* override;

   int32_t status;

   /* By default GF uses buffer swap on vsync */

   gfdata->swapinterval=1;

   /* Add each detected output to SDL */

   for (it=0; it<gfdata->gfdev_info.ndisplays; it++)

   {

      SDL_VideoDisplay  display;

      SDL_DisplayMode   current_mode;

      SDL_DisplayData*  didata;

      didata=(SDL_DisplayData*)SDL_calloc(1, sizeof(SDL_DisplayData));

      if (didata==NULL)

      {

         /* memory allocation problem */

         SDL_OutOfMemory();

         return -1;

      }

      /* Set default cursor settings, maximum 128x128 cursor */

      didata->cursor_visible=SDL_FALSE;

      didata->cursor.type=GF_CURSOR_BITMAP;

      didata->cursor.hotspot.x=0;

      didata->cursor.hotspot.y=0;

      didata->cursor.cursor.bitmap.w=SDL_VIDEO_GF_MAX_CURSOR_SIZE;

      didata->cursor.cursor.bitmap.h=SDL_VIDEO_GF_MAX_CURSOR_SIZE;

      didata->cursor.cursor.bitmap.stride=(didata->cursor.cursor.bitmap.w+7)/

                                          (sizeof(uint8_t)*8);

      didata->cursor.cursor.bitmap.color0=0x00000000;

      didata->cursor.cursor.bitmap.color1=0x00000000;

      didata->cursor.cursor.bitmap.image0=SDL_calloc(sizeof(uint8_t), (didata->cursor.cursor.bitmap.w+7)*

                                          didata->cursor.cursor.bitmap.h/(sizeof(uint8_t)*8));

      if (didata->cursor.cursor.bitmap.image0==NULL)

      {

         SDL_free(didata);

         SDL_OutOfMemory();

         return -1;

      }

      didata->cursor.cursor.bitmap.image1=SDL_calloc(sizeof(uint8_t), (didata->cursor.cursor.bitmap.w+7)*

                                   didata->cursor.cursor.bitmap.h/(sizeof(uint8_t)*8));

      if (didata->cursor.cursor.bitmap.image1==NULL)

      {

         SDL_OutOfMemory();

         SDL_free((void*)didata->cursor.cursor.bitmap.image0);

         SDL_free(didata);

         return -1;

      }

      /* Query current display settings */

      status=gf_display_query(gfdata->gfdev, it, &didata->display_info);

      if (status==GF_ERR_OK)

      {

         SDL_zero(current_mode);

         current_mode.w=didata->display_info.xres;

         current_mode.h=didata->display_info.yres;

         current_mode.refresh_rate=didata->display_info.refresh;

         current_mode.format=qnxgf_gf_to_sdl_pixelformat(didata->display_info.format);

         current_mode.driverdata=NULL;

      }

      else

      {

         /* video initialization problem */

         SDL_free((void*)didata->cursor.cursor.bitmap.image0);

         SDL_free((void*)didata->cursor.cursor.bitmap.image1);

         SDL_free(didata);

         SDL_SetError("GF: Display query failed");

         return -1;

      }

      /* Attach GF to selected display */

      status=gf_display_attach(&didata->display, gfdata->gfdev, it, NULL);

      if (status!=GF_ERR_OK)

      {

         /* video initialization problem */

         SDL_free((void*)didata->cursor.cursor.bitmap.image0);

         SDL_free((void*)didata->cursor.cursor.bitmap.image1);

         SDL_free(didata);

         SDL_SetError("GF: Couldn't attach to display");

         return -1;

      }

      /* Initialize status variables */

      didata->layer_attached=SDL_FALSE;

      /* Attach to main display layer */

      status=gf_layer_attach(&didata->layer, didata->display, didata->display_info.main_layer_index, 0);

      if (status!=GF_ERR_OK)

      {

         /* Failed to attach to main layer */

         SDL_free((void*)didata->cursor.cursor.bitmap.image0);

         SDL_free((void*)didata->cursor.cursor.bitmap.image1);

         SDL_free(didata);

         SDL_SetError("GF: Couldn't attach to main layer, it could be busy");

         return -1;

      }

      /* Mark main display layer is attached */

      didata->layer_attached=SDL_TRUE;

      /* Set layer source and destination viewport */

      gf_layer_set_src_viewport(didata->layer, 0, 0, current_mode.w-1, current_mode.h-1);

      gf_layer_set_dst_viewport(didata->layer, 0, 0, current_mode.w-1, current_mode.h-1);

      /* Create main visible on display surface */

      status=gf_surface_create_layer(&didata->surface[0], &didata->layer,

             1, 0, current_mode.w, current_mode.h,

             qnxgf_sdl_to_gf_pixelformat(current_mode.format),

             NULL, GF_SURFACE_CREATE_2D_ACCESSIBLE | GF_SURFACE_CREATE_3D_ACCESSIBLE |

             GF_SURFACE_CREATE_SHAREABLE);

      if (status!=GF_ERR_OK)

      {

         gf_layer_disable(didata->layer);

         gf_layer_detach(didata->layer);

         didata->layer_attached=SDL_FALSE;

         SDL_free((void*)didata->cursor.cursor.bitmap.image0);

         SDL_free((void*)didata->cursor.cursor.bitmap.image1);

         SDL_free(didata);

         SDL_SetError("GF: Can't create main layer surface at init (%d)\n", status);

         return -1;

      }

      /* Set just created surface as main visible on the layer */

//      gf_layer_set_surfaces(didata->layer, &didata->surface[0], 1);

      /* Update layer parameters */

      status=gf_layer_update(didata->layer, GF_LAYER_UPDATE_NO_WAIT_IDLE);

      if (status!=GF_ERR_OK)

      {

         /* Free allocated surface */

         gf_surface_free(didata->surface[0]);

         didata->surface[0]=NULL;

         /* Disable and detach from layer */

         gf_layer_disable(didata->layer);

         gf_layer_detach(didata->layer);

         didata->layer_attached=SDL_FALSE;

         SDL_free((void*)didata->cursor.cursor.bitmap.image0);

         SDL_free((void*)didata->cursor.cursor.bitmap.image1);

         SDL_free(didata);

         SDL_SetError("GF: Can't update layer parameters\n");

         return -1;

      }

      /* Enable layer in case if hardware supports layer enable/disable */

      gf_layer_enable(didata->layer);

      /* Copy device name for each display */

      SDL_strlcpy(didata->description, gfdata->gfdev_info.description, SDL_VIDEO_GF_DEVICENAME_MAX-1);

      /* Search device capabilities and possible workarounds */

      jt=0;

      do {

         if (gf_devicename[jt].name==NULL)

         {

            break;

         }

         if (SDL_strncmp(gf_devicename[jt].name, didata->description, SDL_strlen(gf_devicename[jt].name))==0)

         {

            didata->caps=gf_devicename[jt].caps;

         }

         jt++;

      } while(1);

      /* Initialize display structure */