Home | History | Annotate | Download | only in nanox
      1 /*
      2     SDL - Simple DirectMedia Layer
      3     Copyright (C) 1997-2012 Sam Lantinga
      4     Copyright (C) 2001  Hsieh-Fu Tsai
      5     Copyright (C) 2002  Greg Haerr <greg (at) censoft.com>
      6 
      7     This library is free software; you can redistribute it and/or
      8     modify it under the terms of the GNU Library General Public
      9     License as published by the Free Software Foundation; either
     10     version 2 of the License, or (at your option) any later version.
     11 
     12     This library is distributed in the hope that it will be useful,
     13     but WITHOUT ANY WARRANTY; without even the implied warranty of
     14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     15     Library General Public License for more details.
     16 
     17     You should have received a copy of the GNU Library General Public
     18     License along with this library; if not, write to the Free
     19     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
     20 
     21     Sam Lantinga
     22     slouken (at) libsdl.org
     23 
     24     Hsieh-Fu Tsai
     25     clare (at) setabox.com
     26 */
     27 #include "SDL_config.h"
     28 
     29 #include "SDL_thread.h"
     30 #include "SDL_video.h"
     31 #include "../SDL_pixels_c.h"
     32 #include "../../events/SDL_events_c.h"
     33 
     34 #define MWINCLUDECOLORS
     35 #include "SDL_nxvideo.h"
     36 #include "SDL_nxmodes_c.h"
     37 #include "SDL_nxwm_c.h"
     38 #include "SDL_nxmouse_c.h"
     39 #include "SDL_nximage_c.h"
     40 #include "SDL_nxevents_c.h"
     41 
     42 // Initialization/Query functions
     43 static int NX_VideoInit (_THIS, SDL_PixelFormat * vformat) ;
     44 static SDL_Surface * NX_SetVideoMode (_THIS, SDL_Surface * current, int width, int height, int bpp, Uint32 flags) ;
     45 static int NX_SetColors (_THIS, int firstcolor, int ncolors, SDL_Color * colors) ;
     46 static void NX_VideoQuit (_THIS) ;
     47 static void NX_DestroyWindow (_THIS, SDL_Surface * screen) ;
     48 static int NX_ToggleFullScreen (_THIS, int on) ;
     49 static void NX_UpdateMouse (_THIS) ;
     50 static int NX_SetGammaRamp (_THIS, Uint16 * ramp) ;
     51 static int NX_GetGammaRamp (_THIS, Uint16 * ramp) ;
     52 
     53 // Microwin driver bootstrap functions
     54 static int NX_Available ()
     55 {
     56     Dprintf ("enter NX_Available\n") ;
     57 
     58     if (GrOpen () < 0) return 0 ;
     59         GrClose () ;
     60 
     61     Dprintf ("leave NX_Available\n") ;
     62     return 1 ;
     63 }
     64 
     65 static void NX_DeleteDevice (SDL_VideoDevice * device)
     66 {
     67     Dprintf ("enter NX_DeleteDevice\n") ;
     68 
     69     if (device) {
     70         if (device -> hidden) SDL_free (device -> hidden) ;
     71         if (device -> gl_data) SDL_free (device -> gl_data) ;
     72             SDL_free (device) ;
     73     }
     74 
     75     Dprintf ("leave NX_DeleteDevice\n") ;
     76 }
     77 
     78 static SDL_VideoDevice * NX_CreateDevice (int devindex)
     79 {
     80     SDL_VideoDevice * device ;
     81 
     82     Dprintf ("enter NX_CreateDevice\n") ;
     83 
     84     // Initialize all variables that we clean on shutdown
     85     device = (SDL_VideoDevice *) SDL_malloc (sizeof (SDL_VideoDevice)) ;
     86     if (device) {
     87         SDL_memset (device, 0, (sizeof * device)) ;
     88         device -> hidden = (struct SDL_PrivateVideoData *)
     89                 SDL_malloc ((sizeof * device -> hidden)) ;
     90         device -> gl_data = NULL ;
     91     }
     92     if ((device == NULL) || (device -> hidden == NULL)) {
     93         SDL_OutOfMemory () ;
     94         NX_DeleteDevice (device) ;
     95         return 0 ;
     96     }
     97     SDL_memset (device -> hidden, 0, (sizeof * device -> hidden)) ;
     98 
     99     // Set the function pointers
    100     device -> VideoInit = NX_VideoInit ;
    101     device -> ListModes = NX_ListModes ;
    102     device -> SetVideoMode = NX_SetVideoMode ;
    103     device -> ToggleFullScreen = NX_ToggleFullScreen ;
    104     device -> UpdateMouse = NX_UpdateMouse ;
    105     device -> CreateYUVOverlay = NULL ;
    106     device -> SetColors = NX_SetColors ;
    107     device -> UpdateRects = NULL ;
    108     device -> VideoQuit = NX_VideoQuit;
    109     device -> AllocHWSurface = NULL ;
    110     device -> CheckHWBlit = NULL ;
    111     device -> FillHWRect = NULL ;
    112     device -> SetHWColorKey = NULL ;
    113     device -> SetHWAlpha = NULL ;
    114     device -> LockHWSurface = NULL ;
    115     device -> UnlockHWSurface = NULL ;
    116     device -> FlipHWSurface = NULL ;
    117     device -> FreeHWSurface = NULL ;
    118     device -> SetGamma = NULL ;
    119     device -> GetGamma = NULL ;
    120     device -> SetGammaRamp = NX_SetGammaRamp ;
    121     device -> GetGammaRamp = NX_GetGammaRamp ;
    122 
    123 #if SDL_VIDEO_OPENGL
    124     device -> GL_LoadLibrary = NULL ;
    125     device -> GL_GetProcAddress = NULL ;
    126     device -> GL_GetAttribute = NULL ;
    127     device -> GL_MakeCurrent = NULL ;
    128     device -> GL_SwapBuffers = NULL ;
    129 #endif
    130 
    131     device -> SetIcon = NULL ;
    132     device -> SetCaption = NX_SetCaption;
    133     device -> IconifyWindow = NULL ;
    134     device -> GrabInput = NULL ;
    135     device -> GetWMInfo = NX_GetWMInfo ;
    136     device -> FreeWMCursor =  NX_FreeWMCursor ;
    137     device -> CreateWMCursor = NX_CreateWMCursor ;
    138     device -> ShowWMCursor = NX_ShowWMCursor ;
    139     device -> WarpWMCursor = NX_WarpWMCursor ;
    140     device -> CheckMouseMode = NULL ;
    141     device -> InitOSKeymap = NX_InitOSKeymap ;
    142     device -> PumpEvents = NX_PumpEvents ;
    143 
    144     device -> free = NX_DeleteDevice ;
    145 
    146     Dprintf ("leave NX_CreateDevice\n") ;
    147     return device ;
    148 }
    149 
    150 VideoBootStrap NX_bootstrap = {
    151     "nanox", "nanox", NX_Available, NX_CreateDevice
    152 } ;
    153 
    154 static void create_aux_windows (_THIS)
    155 {
    156     GR_WM_PROPERTIES props ;
    157 
    158     Dprintf ("enter create_aux_windows\n") ;
    159 
    160     // Don't create any extra windows if we are being managed
    161     if (SDL_windowid) {
    162         FSwindow = 0 ;
    163         return ;
    164     }
    165 
    166     if (FSwindow && FSwindow != GR_ROOT_WINDOW_ID) {
    167         GrDestroyWindow (FSwindow) ;
    168     }
    169 
    170     FSwindow = GrNewWindow (GR_ROOT_WINDOW_ID, 0, 0, 1, 1, 0, BLACK, BLACK) ;
    171     props.flags = GR_WM_FLAGS_PROPS ;
    172     props.props = GR_WM_PROPS_NODECORATE ;
    173     GrSetWMProperties (FSwindow, & props) ;
    174 
    175     GrSelectEvents (FSwindow, (GR_EVENT_MASK_EXPOSURE         |
    176         GR_EVENT_MASK_BUTTON_DOWN  | GR_EVENT_MASK_BUTTON_UP  |
    177         GR_EVENT_MASK_FOCUS_IN     | GR_EVENT_MASK_FOCUS_OUT  |
    178         GR_EVENT_MASK_KEY_DOWN     | GR_EVENT_MASK_KEY_UP     |
    179         GR_EVENT_MASK_MOUSE_ENTER  | GR_EVENT_MASK_MOUSE_EXIT |
    180         GR_EVENT_MASK_MOUSE_MOTION | GR_EVENT_MASK_UPDATE     |
    181         GR_EVENT_MASK_CLOSE_REQ)) ;
    182 
    183     Dprintf ("leave create_aux_windows\n") ;
    184 }
    185 
    186 int NX_VideoInit (_THIS, SDL_PixelFormat * vformat)
    187 {
    188     GR_SCREEN_INFO si ;
    189 
    190     Dprintf ("enter NX_VideoInit\n") ;
    191 
    192     if (GrOpen () < 0) {
    193         SDL_SetError ("GrOpen() fail") ;
    194         return -1 ;
    195     }
    196 
    197     // use share memory to speed up
    198 #ifdef NANOX_SHARE_MEMORY
    199     GrReqShmCmds (0xFFFF);
    200 #endif
    201 
    202     SDL_Window = 0 ;
    203     FSwindow = 0 ;
    204 
    205     GammaRamp_R = NULL ;
    206     GammaRamp_G = NULL ;
    207     GammaRamp_B = NULL ;
    208 
    209     GrGetScreenInfo (& si) ;
    210     SDL_Visual.bpp = si.bpp ;
    211 
    212     /* Determine the current screen size */
    213     this->info.current_w = si.cols ;
    214     this->info.current_h = si.rows ;
    215 
    216     // GetVideoMode
    217     SDL_modelist = (SDL_Rect **) SDL_malloc (sizeof (SDL_Rect *) * 2) ;
    218     if (SDL_modelist) {
    219         SDL_modelist [0] = (SDL_Rect *) SDL_malloc (sizeof(SDL_Rect)) ;
    220         if (SDL_modelist [0]) {
    221             SDL_modelist [0] -> x = 0 ;
    222             SDL_modelist [0] -> y = 0 ;
    223             SDL_modelist [0] -> w = si.cols ;
    224             SDL_modelist [0] -> h = si.rows ;
    225         }
    226         SDL_modelist [1] = NULL ;
    227     }
    228 
    229     pixel_type = si.pixtype;
    230     SDL_Visual.red_mask = si.rmask;
    231     SDL_Visual.green_mask = si.gmask;
    232     SDL_Visual.blue_mask = si.bmask;
    233 
    234     vformat -> BitsPerPixel = SDL_Visual.bpp ;
    235     if (vformat -> BitsPerPixel > 8) {
    236         vformat -> Rmask = SDL_Visual.red_mask ;
    237         vformat -> Gmask = SDL_Visual.green_mask ;
    238         vformat -> Bmask = SDL_Visual.blue_mask ;
    239     }
    240 
    241     // See if we have been passed a window to use
    242     SDL_windowid = getenv ("SDL_WINDOWID") ;
    243 
    244     // Create the fullscreen (and managed windows : no implement)
    245     create_aux_windows (this) ;
    246 
    247     Dprintf ("leave NX_VideoInit\n") ;
    248     return 0 ;
    249 }
    250 
    251 void NX_VideoQuit (_THIS)
    252 {
    253     Dprintf ("enter NX_VideoQuit\n") ;
    254 
    255     // Start shutting down the windows
    256     NX_DestroyImage (this, this -> screen) ;
    257     NX_DestroyWindow (this, this -> screen) ;
    258     if (FSwindow && FSwindow != GR_ROOT_WINDOW_ID) {
    259         GrDestroyWindow (FSwindow) ;
    260     }
    261     NX_FreeVideoModes (this) ;
    262     SDL_free (GammaRamp_R) ;
    263     SDL_free (GammaRamp_G) ;
    264     SDL_free (GammaRamp_B) ;
    265 
    266 #ifdef ENABLE_NANOX_DIRECT_FB
    267     if (Clientfb)
    268         GrCloseClientFramebuffer();
    269 #endif
    270     GrClose () ;
    271 
    272     Dprintf ("leave NX_VideoQuit\n") ;
    273 }
    274 
    275 static void NX_DestroyWindow (_THIS, SDL_Surface * screen)
    276 {
    277     Dprintf ("enter NX_DestroyWindow\n") ;
    278 
    279     if (! SDL_windowid) {
    280         if (screen && (screen -> flags & SDL_FULLSCREEN)) {
    281             screen -> flags &= ~ SDL_FULLSCREEN ;
    282             NX_LeaveFullScreen (this) ;
    283         }
    284 
    285         // Destroy the output window
    286         if (SDL_Window && SDL_Window != GR_ROOT_WINDOW_ID) {
    287             GrDestroyWindow (SDL_Window) ;
    288         }
    289     }
    290 
    291     // Free the graphics context
    292     if (! SDL_GC) {
    293         GrDestroyGC (SDL_GC) ;
    294         SDL_GC = 0;
    295     }
    296 
    297     Dprintf ("leave NX_DestroyWindow\n") ;
    298 }
    299 
    300 static int NX_CreateWindow (_THIS, SDL_Surface * screen,
    301                 int w, int h, int bpp, Uint32 flags)
    302 {
    303     Dprintf ("enter NX_CreateWindow\n") ;
    304 
    305     // If a window is already present, destroy it and start fresh
    306     if (SDL_Window && SDL_Window != GR_ROOT_WINDOW_ID) {
    307         NX_DestroyWindow (this, screen) ;
    308     }
    309 
    310     // See if we have been given a window id
    311     if (SDL_windowid) {
    312         SDL_Window = SDL_strtol (SDL_windowid, NULL, 0) ;
    313     } else {
    314         SDL_Window = 0 ;
    315     }
    316 
    317     if ( ! SDL_ReallocFormat (screen, bpp, SDL_Visual.red_mask,
    318         SDL_Visual.green_mask, SDL_Visual.blue_mask, 0))
    319         return -1;
    320 
    321     // Create (or use) the nanox display window
    322     if (! SDL_windowid) {
    323 
    324         SDL_Window = GrNewWindow (GR_ROOT_WINDOW_ID, 0, 0, w, h, 0, BLACK, WHITE) ;
    325 
    326         GrSelectEvents (SDL_Window, (GR_EVENT_MASK_EXPOSURE       |
    327             GR_EVENT_MASK_BUTTON_DOWN  | GR_EVENT_MASK_BUTTON_UP  |
    328             GR_EVENT_MASK_FOCUS_IN     | GR_EVENT_MASK_FOCUS_OUT  |
    329             GR_EVENT_MASK_KEY_DOWN     | GR_EVENT_MASK_KEY_UP     |
    330             GR_EVENT_MASK_MOUSE_ENTER  | GR_EVENT_MASK_MOUSE_EXIT |
    331             GR_EVENT_MASK_MOUSE_MOTION | GR_EVENT_MASK_UPDATE     |
    332             GR_EVENT_MASK_CLOSE_REQ)) ;
    333     }
    334 
    335     /* Create the graphics context here, once we have a window */
    336     SDL_GC = GrNewGC () ;
    337     if (SDL_GC == 0) {
    338         SDL_SetError("Couldn't create graphics context");
    339         return(-1);
    340     }
    341 
    342     // Map them both and go fullscreen, if requested
    343     if (! SDL_windowid) {
    344         GrMapWindow (SDL_Window) ;
    345         if (flags & SDL_FULLSCREEN) {
    346             screen -> flags |= SDL_FULLSCREEN ;
    347             NX_EnterFullScreen (this) ;
    348         } else {
    349             screen -> flags &= ~ SDL_FULLSCREEN ;
    350         }
    351     }
    352 
    353 #ifdef ENABLE_NANOX_DIRECT_FB
    354     /* attempt allocating the client side framebuffer */
    355     Clientfb = GrOpenClientFramebuffer();
    356     /* NULL return will default to using GrArea()*/
    357 #endif
    358 
    359     Dprintf ("leave NX_CreateWindow\n") ;
    360     return 0 ;
    361 }
    362 
    363 SDL_Surface * NX_SetVideoMode (_THIS, SDL_Surface * current,
    364                 int width, int height, int bpp, Uint32 flags)
    365 {
    366     Dprintf ("enter NX_SetVideoMode\n") ;
    367 
    368     // Lock the event thread, in multi-threading environments
    369     SDL_Lock_EventThread () ;
    370 
    371     bpp = SDL_Visual.bpp ;
    372     if (NX_CreateWindow (this, current, width, height, bpp, flags) < 0) {
    373         current = NULL;
    374         goto done;
    375     }
    376 
    377     if (current -> w != width || current -> h != height) {
    378         current -> w = width ;
    379         current -> h = height ;
    380         current -> pitch = SDL_CalculatePitch (current) ;
    381         NX_ResizeImage (this, current, flags) ;
    382     }
    383 
    384     /* Clear these flags and set them only if they are in the new set. */
    385     current -> flags &= ~(SDL_RESIZABLE|SDL_NOFRAME);
    386     current -> flags |= (flags & (SDL_RESIZABLE | SDL_NOFRAME)) ;
    387 
    388   done:
    389     SDL_Unlock_EventThread () ;
    390 
    391     Dprintf ("leave NX_SetVideoMode\n") ;
    392 
    393     // We're done!
    394     return current ;
    395 }
    396 
    397 // ncolors <= 256
    398 int NX_SetColors (_THIS, int firstcolor, int ncolors, SDL_Color * colors)
    399 {
    400     int        i ;
    401     GR_PALETTE pal ;
    402 
    403     Dprintf ("enter NX_SetColors\n") ;
    404 
    405     if (ncolors > 256) return 0 ;
    406 
    407     pal.count = ncolors ;
    408     for (i = 0; i < ncolors; ++ i) {
    409         pal.palette [i].r = colors [i].r ;
    410         pal.palette [i].g = colors [i].g ;
    411         pal.palette [i].b = colors [i].b ;
    412     }
    413     GrSetSystemPalette (firstcolor, & pal) ;
    414 
    415     Dprintf ("leave NX_SetColors\n") ;
    416     return 1 ;
    417 }
    418 
    419 static int NX_ToggleFullScreen (_THIS, int on)
    420 {
    421     SDL_Rect rect ;
    422     Uint32   event_thread ;
    423 
    424     Dprintf ("enter NX_ToggleFullScreen\n") ;
    425 
    426     // Don't switch if we don't own the window
    427     if (SDL_windowid) return 0 ;
    428 
    429     // Don't lock if we are the event thread
    430     event_thread = SDL_EventThreadID () ;
    431     if (event_thread && (SDL_ThreadID () == event_thread)) {
    432         event_thread = 0 ;
    433     }
    434     if (event_thread) {
    435         SDL_Lock_EventThread() ;
    436     }
    437 
    438     if (on) {
    439         NX_EnterFullScreen (this) ;
    440     } else {
    441         this -> screen -> flags &= ~ SDL_FULLSCREEN ;
    442         NX_LeaveFullScreen (this) ;
    443     }
    444 
    445     rect.x = rect.y = 0 ;
    446     rect.w = this -> screen -> w, rect.h = this -> screen -> h ;
    447     NX_NormalUpdate (this, 1, & rect) ;
    448 
    449     if (event_thread) {
    450         SDL_Unlock_EventThread () ;
    451     }
    452 
    453     Dprintf ("leave NX_ToggleFullScreen\n") ;
    454     return 1 ;
    455 }
    456 
    457 // Update the current mouse state and position
    458 static void NX_UpdateMouse (_THIS)
    459 {
    460     int            x, y ;
    461     GR_WINDOW_INFO info ;
    462     GR_SCREEN_INFO si ;
    463 
    464 
    465     Dprintf ("enter NX_UpdateMouse\n") ;
    466 
    467     // Lock the event thread, in multi-threading environments
    468     SDL_Lock_EventThread () ;
    469 
    470     GrGetScreenInfo (& si) ;
    471     GrGetWindowInfo (SDL_Window, & info) ;
    472     x = si.xpos - info.x ;
    473     y = si.ypos - info.y ;
    474     if (x >= 0 && x <= info.width && y >= 0 && y <= info.height) {
    475         SDL_PrivateAppActive (1, SDL_APPMOUSEFOCUS) ;
    476         SDL_PrivateMouseMotion (0, 0, x, y);
    477     } else {
    478         SDL_PrivateAppActive (0, SDL_APPMOUSEFOCUS) ;
    479     }
    480 
    481     SDL_Unlock_EventThread () ;
    482     Dprintf ("leave NX_UpdateMouse\n") ;
    483 }
    484 
    485 static int NX_SetGammaRamp (_THIS, Uint16 * ramp)
    486 {
    487     int i ;
    488     Uint16 * red, * green, * blue ;
    489 
    490     Dprintf ("enter NX_SetGammaRamp\n") ;
    491 
    492     if (SDL_Visual.bpp != 32 && SDL_Visual.bpp != 24) return -1 ;
    493 
    494     if (! GammaRamp_R) GammaRamp_R = (Uint16 *) SDL_malloc (sizeof (Uint16) * CI_SIZE) ;
    495     if (! GammaRamp_G) GammaRamp_G = (Uint16 *) SDL_malloc (sizeof (Uint16) * CI_SIZE) ;
    496     if (! GammaRamp_B) GammaRamp_B = (Uint16 *) SDL_malloc (sizeof (Uint16) * CI_SIZE) ;
    497     if ((! GammaRamp_R) || (! GammaRamp_G) || (! GammaRamp_B)) {
    498         SDL_OutOfMemory () ;
    499         return -1 ;
    500     }
    501 
    502     for (i = 0; i < CI_SIZE; ++ i)
    503         GammaRamp_R [i] = GammaRamp_G [i] = GammaRamp_B [i] = i ;
    504 
    505     red   = ramp ;
    506     green = ramp + CI_SIZE ;
    507     blue  = green + CI_SIZE ;
    508 
    509     for (i = 0; i < CI_SIZE; ++ i) {
    510         GammaRamp_R [i] = red   [i] ;
    511         GammaRamp_G [i] = green [i] ;
    512         GammaRamp_B [i] = blue  [i] ;
    513     }
    514     SDL_UpdateRect(this->screen, 0, 0, 0, 0);
    515 
    516     Dprintf ("leave NX_SetGammaRamp\n") ;
    517     return 0 ;
    518 }
    519 
    520 static int NX_GetGammaRamp (_THIS, Uint16 * ramp)
    521 {
    522     int i ;
    523     Uint16 * red, * green, * blue ;
    524 
    525     Dprintf ("enter NX_GetGammaRamp\n") ;
    526 
    527     if (SDL_Visual.bpp != 32 && SDL_Visual.bpp != 24) return -1 ;
    528     red   = ramp ;
    529     green = ramp  + CI_SIZE ;
    530     blue  = green + CI_SIZE ;
    531     if (GammaRamp_R && GammaRamp_G && GammaRamp_B) {
    532         for (i = 0; i < CI_SIZE; ++ i) {
    533             red   [i] = GammaRamp_R [i] ;
    534             green [i] = GammaRamp_G [i] ;
    535             blue  [i] = GammaRamp_B [i] ;
    536         }
    537     } else {
    538         for (i = 0; i < CI_SIZE; ++ i)
    539             red [i] = green [i] = blue [i] = i ;
    540     }
    541 
    542     Dprintf ("leave NX_GetGammaRamp\n") ;
    543     return 0 ;
    544 }
    545