diff options
Diffstat (limited to 'distrib/sdl-1.2.15/src/video/photon/SDL_ph_video.c')
| -rw-r--r-- | distrib/sdl-1.2.15/src/video/photon/SDL_ph_video.c | 648 |
1 files changed, 648 insertions, 0 deletions
diff --git a/distrib/sdl-1.2.15/src/video/photon/SDL_ph_video.c b/distrib/sdl-1.2.15/src/video/photon/SDL_ph_video.c new file mode 100644 index 0000000..5e1a82b --- /dev/null +++ b/distrib/sdl-1.2.15/src/video/photon/SDL_ph_video.c @@ -0,0 +1,648 @@ +/* + SDL - Simple DirectMedia Layer + Copyright (C) 1997-2012 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 +*/ +#include "SDL_config.h" + +#include <unistd.h> +#include <sys/ioctl.h> + +#include "SDL_endian.h" +#include "SDL_timer.h" +#include "SDL_thread.h" +#include "SDL_video.h" +#include "SDL_mouse.h" +#include "../SDL_sysvideo.h" +#include "../SDL_pixels_c.h" +#include "../../events/SDL_events_c.h" +#include "SDL_ph_video.h" +#include "SDL_ph_modes_c.h" +#include "SDL_ph_image_c.h" +#include "SDL_ph_events_c.h" +#include "SDL_ph_mouse_c.h" +#include "SDL_ph_wm_c.h" +#include "SDL_ph_gl.h" +#include "SDL_phyuv_c.h" +#include "../blank_cursor.h" + +static int ph_VideoInit(_THIS, SDL_PixelFormat *vformat); +static SDL_Surface *ph_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags); +static int ph_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors); +static void ph_VideoQuit(_THIS); +static void ph_DeleteDevice(SDL_VideoDevice *device); + +static int phstatus=-1; + +static int ph_Available(void) +{ + if (phstatus!=0) + { + phstatus=PtInit(NULL); + if (phstatus==0) + { + return 1; + } + else + { + return 0; + } + } + return 1; +} + +static SDL_VideoDevice* ph_CreateDevice(int devindex) +{ + SDL_VideoDevice* device; + + /* Initialize all variables that we clean on shutdown */ + device = (SDL_VideoDevice *)SDL_malloc(sizeof(SDL_VideoDevice)); + if (device) + { + SDL_memset(device, 0, (sizeof *device)); + device->hidden = (struct SDL_PrivateVideoData*)SDL_malloc((sizeof *device->hidden)); + device->gl_data = NULL; + } + if ((device == NULL) || (device->hidden == NULL)) + { + SDL_OutOfMemory(); + ph_DeleteDevice(device); + return NULL; + } + SDL_memset(device->hidden, 0, (sizeof *device->hidden)); + + /* Set the driver flags */ + device->handles_any_size = 1; + + /* Set the function pointers */ + device->CreateYUVOverlay = ph_CreateYUVOverlay; + device->VideoInit = ph_VideoInit; + device->ListModes = ph_ListModes; + device->SetVideoMode = ph_SetVideoMode; + device->ToggleFullScreen = ph_ToggleFullScreen; + device->UpdateMouse = ph_UpdateMouse; + device->SetColors = ph_SetColors; + device->UpdateRects = NULL; /* set up in ph_SetupUpdateFunction */ + device->VideoQuit = ph_VideoQuit; + device->AllocHWSurface = ph_AllocHWSurface; + device->CheckHWBlit = ph_CheckHWBlit; + device->FillHWRect = ph_FillHWRect; + device->SetHWColorKey = ph_SetHWColorKey; + device->SetHWAlpha = ph_SetHWAlpha; + device->LockHWSurface = ph_LockHWSurface; + device->UnlockHWSurface = ph_UnlockHWSurface; + device->FlipHWSurface = ph_FlipHWSurface; + device->FreeHWSurface = ph_FreeHWSurface; + device->SetCaption = ph_SetCaption; + device->SetIcon = NULL; + device->IconifyWindow = ph_IconifyWindow; + device->GrabInput = ph_GrabInput; + device->GetWMInfo = ph_GetWMInfo; + device->FreeWMCursor = ph_FreeWMCursor; + device->CreateWMCursor = ph_CreateWMCursor; + device->ShowWMCursor = ph_ShowWMCursor; + device->WarpWMCursor = ph_WarpWMCursor; + device->MoveWMCursor = NULL; + device->CheckMouseMode = ph_CheckMouseMode; + device->InitOSKeymap = ph_InitOSKeymap; + device->PumpEvents = ph_PumpEvents; + + /* OpenGL support. */ +#if SDL_VIDEO_OPENGL + device->GL_MakeCurrent = ph_GL_MakeCurrent; + device->GL_SwapBuffers = ph_GL_SwapBuffers; + device->GL_GetAttribute = ph_GL_GetAttribute; + device->GL_LoadLibrary = ph_GL_LoadLibrary; + device->GL_GetProcAddress = ph_GL_GetProcAddress; +#endif /* SDL_VIDEO_OPENGL */ + + device->free = ph_DeleteDevice; + + return device; +} + +VideoBootStrap ph_bootstrap = { + "photon", "QNX Photon video output", + ph_Available, ph_CreateDevice +}; + +static void ph_DeleteDevice(SDL_VideoDevice *device) +{ + if (device) + { + if (device->hidden) + { + SDL_free(device->hidden); + device->hidden = NULL; + } + if (device->gl_data) + { + SDL_free(device->gl_data); + device->gl_data = NULL; + } + SDL_free(device); + device = NULL; + } +} + +static PtWidget_t *ph_CreateWindow(_THIS) +{ + PtWidget_t *widget; + + widget = PtCreateWidget(PtWindow, NULL, 0, NULL); + + return widget; +} + +static int ph_SetupWindow(_THIS, int w, int h, int flags) +{ + PtArg_t args[32]; + PhPoint_t pos = {0, 0}; + PhDim_t* olddim; + PhDim_t dim = {w, h}; + PhRect_t desktopextent; + int nargs = 0; + const char* windowpos; + const char* iscentered; + int x, y; + + /* check if window size has been changed by Window Manager */ + PtGetResource(window, Pt_ARG_DIM, &olddim, 0); + if ((olddim->w!=w) || (olddim->h!=h)) + { + PtSetArg(&args[nargs++], Pt_ARG_DIM, &dim, 0); + } + + if ((flags & SDL_RESIZABLE) == SDL_RESIZABLE) + { + PtSetArg(&args[nargs++], Pt_ARG_WINDOW_MANAGED_FLAGS, Pt_FALSE, Ph_WM_CLOSE); + PtSetArg(&args[nargs++], Pt_ARG_WINDOW_MANAGED_FLAGS, Pt_TRUE, Ph_WM_MAX | Ph_WM_RESTORE | Ph_WM_RESIZE); + PtSetArg(&args[nargs++], Pt_ARG_WINDOW_NOTIFY_FLAGS, Pt_TRUE, Ph_WM_RESIZE | Ph_WM_MOVE | Ph_WM_CLOSE | Ph_WM_MAX | Ph_WM_RESTORE); + PtSetArg(&args[nargs++], Pt_ARG_WINDOW_RENDER_FLAGS, Pt_TRUE, Ph_WM_RENDER_RESIZE | Ph_WM_RENDER_MAX | Ph_WM_RENDER_COLLAPSE | Ph_WM_RENDER_RETURN); + PtSetArg(&args[nargs++], Pt_ARG_RESIZE_FLAGS, Pt_TRUE, Pt_RESIZE_XY_AS_REQUIRED); + } + else + { + PtSetArg(&args[nargs++], Pt_ARG_WINDOW_MANAGED_FLAGS, Pt_FALSE, Ph_WM_RESIZE | Ph_WM_MAX | Ph_WM_RESTORE | Ph_WM_CLOSE); + PtSetArg(&args[nargs++], Pt_ARG_WINDOW_NOTIFY_FLAGS, Pt_FALSE, Ph_WM_RESIZE | Ph_WM_MAX | Ph_WM_RESTORE); + PtSetArg(&args[nargs++], Pt_ARG_WINDOW_NOTIFY_FLAGS, Pt_TRUE, Ph_WM_MOVE | Ph_WM_CLOSE); + PtSetArg(&args[nargs++], Pt_ARG_WINDOW_RENDER_FLAGS, Pt_FALSE, Ph_WM_RENDER_RESIZE | Ph_WM_RENDER_MAX | Ph_WM_RENDER_COLLAPSE | Ph_WM_RENDER_RETURN); + PtSetArg(&args[nargs++], Pt_ARG_RESIZE_FLAGS, Pt_FALSE, Pt_RESIZE_XY_AS_REQUIRED); + } + + if (((flags & SDL_NOFRAME)==SDL_NOFRAME) || ((flags & SDL_FULLSCREEN)==SDL_FULLSCREEN)) + { + if ((flags & SDL_RESIZABLE) != SDL_RESIZABLE) + { + PtSetArg(&args[nargs++], Pt_ARG_WINDOW_RENDER_FLAGS, Pt_FALSE, Pt_TRUE); + } + else + { + PtSetArg(&args[nargs++], Pt_ARG_WINDOW_RENDER_FLAGS, Pt_FALSE, Pt_TRUE); + PtSetArg(&args[nargs++], Pt_ARG_WINDOW_RENDER_FLAGS, Pt_TRUE, Ph_WM_RENDER_RESIZE | Ph_WM_RENDER_BORDER); + } + } + else + { + PtSetArg(&args[nargs++], Pt_ARG_WINDOW_RENDER_FLAGS, Pt_TRUE, Ph_WM_RENDER_BORDER | Ph_WM_RENDER_TITLE | + Ph_WM_RENDER_CLOSE | Ph_WM_RENDER_MENU | Ph_WM_RENDER_MIN); + } + + if ((flags & SDL_FULLSCREEN) == SDL_FULLSCREEN) + { + PtSetArg(&args[nargs++], Pt_ARG_POS, &pos, 0); + PtSetArg(&args[nargs++], Pt_ARG_BASIC_FLAGS, Pt_TRUE, Pt_BASIC_PREVENT_FILL); + PtSetArg(&args[nargs++], Pt_ARG_WINDOW_MANAGED_FLAGS, Pt_TRUE, Ph_WM_FFRONT | Ph_WM_MAX | Ph_WM_TOFRONT | Ph_WM_CONSWITCH); + PtSetArg(&args[nargs++], Pt_ARG_WINDOW_STATE, Pt_TRUE, Ph_WM_STATE_ISFRONT | Ph_WM_STATE_ISFOCUS | Ph_WM_STATE_ISALTKEY); + } + else + { + PtSetArg(&args[nargs++], Pt_ARG_WINDOW_MANAGED_FLAGS, Pt_FALSE, Ph_WM_FFRONT | Ph_WM_CONSWITCH); + PtSetArg(&args[nargs++], Pt_ARG_WINDOW_STATE, Pt_FALSE, Ph_WM_STATE_ISFRONT); + PtSetArg(&args[nargs++], Pt_ARG_WINDOW_STATE, Pt_TRUE, Ph_WM_STATE_ISALTKEY); + + if ((flags & SDL_HWSURFACE) == SDL_HWSURFACE) + { + PtSetArg(&args[nargs++], Pt_ARG_BASIC_FLAGS, Pt_TRUE, Pt_BASIC_PREVENT_FILL); + } + else + { + PtSetArg(&args[nargs++], Pt_ARG_FILL_COLOR, Pg_BLACK, 0); + } + if (!currently_maximized) + { + windowpos = SDL_getenv("SDL_VIDEO_WINDOW_POS"); + iscentered = SDL_getenv("SDL_VIDEO_CENTERED"); + + if ((iscentered) || ((windowpos) && (SDL_strcmp(windowpos, "center")==0))) + { + PhWindowQueryVisible(Ph_QUERY_CONSOLE, 0, 0, &desktopextent); + if (desktop_mode.width>w) + { + pos.x = (desktop_mode.width - w)/2; + } + if (desktop_mode.height>h) + { + pos.y = (desktop_mode.height - h)/2; + } + + pos.x+=desktopextent.ul.x; + pos.y+=desktopextent.ul.y; + PtSetArg(&args[nargs++], Pt_ARG_POS, &pos, 0); + } + else + { + if (windowpos) + { + if (SDL_sscanf(windowpos, "%d,%d", &x, &y) == 2) + { + if ((x<desktop_mode.width) && (y<desktop_mode.height)) + { + PhWindowQueryVisible(Ph_QUERY_CONSOLE, 0, 0, &desktopextent); + pos.x=x+desktopextent.ul.x; + pos.y=y+desktopextent.ul.y; + } + PtSetArg(&args[nargs++], Pt_ARG_POS, &pos, 0); + } + } + } + } + + /* if window is maximized render it as maximized */ + if (currently_maximized) + { + PtSetArg(&args[nargs++], Pt_ARG_WINDOW_STATE, Pt_TRUE, Ph_WM_STATE_ISMAX); + } + else + { + PtSetArg(&args[nargs++], Pt_ARG_WINDOW_STATE, Pt_FALSE, Ph_WM_STATE_ISMAX); + } + + /* do not grab the keyboard by default */ + PtSetArg(&args[nargs++], Pt_ARG_WINDOW_STATE, Pt_FALSE, Ph_WM_STATE_ISALTKEY); + + /* bring the focus to the window */ + PtSetArg(&args[nargs++], Pt_ARG_WINDOW_STATE, Pt_TRUE, Ph_WM_STATE_ISFOCUS); + + /* allow to catch hide event */ + PtSetArg(&args[nargs++], Pt_ARG_WINDOW_MANAGED_FLAGS, Pt_TRUE, Ph_WM_HIDE); + PtSetArg(&args[nargs++], Pt_ARG_WINDOW_NOTIFY_FLAGS, Pt_TRUE, Ph_WM_HIDE); + } + + PtSetResources(window, nargs, args); + PtRealizeWidget(window); + PtWindowToFront(window); + +#if 0 /* FIXME */ + PtGetResource(window, Pt_ARG_POS, &olddim, 0); + fprintf(stderr, "POSITION: %d, %d\n", olddim->w, olddim->h); +#endif + + return 0; +} + +static const struct ColourMasks* ph_GetColourMasks(int bpp) +{ + /* The alpha mask doesn't appears to be needed */ + static const struct ColourMasks phColorMasks[5] = { + /* 8 bit */ {0, 0, 0, 0, 8}, + /* 15 bit ARGB */ {0x7C00, 0x03E0, 0x001F, 0x8000, 15}, + /* 16 bit RGB */ {0xF800, 0x07E0, 0x001F, 0x0000, 16}, + /* 24 bit RGB */ {0xFF0000, 0x00FF00, 0x0000FF, 0x000000, 24}, + /* 32 bit ARGB */ {0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000, 32}, + }; + + switch (bpp) + { + case 8: + return &phColorMasks[0]; + case 15: + return &phColorMasks[1]; + case 16: + return &phColorMasks[2]; + case 24: + return &phColorMasks[3]; + case 32: + return &phColorMasks[4]; + } + return NULL; +} + +static int ph_VideoInit(_THIS, SDL_PixelFormat* vformat) +{ + PgHWCaps_t hwcaps; + int i; + + window=NULL; + desktoppal=SDLPH_PAL_NONE; + +#if SDL_VIDEO_OPENGL + oglctx=NULL; + oglbuffers=NULL; + oglflags=0; + oglbpp=0; +#endif + + old_video_mode=-1; + old_refresh_rate=-1; + + if (NULL == (phevent = SDL_malloc(EVENT_SIZE))) + { + SDL_OutOfMemory(); + return -1; + } + SDL_memset(phevent, 0x00, EVENT_SIZE); + + window = ph_CreateWindow(this); + if (window == NULL) + { + SDL_SetError("ph_VideoInit(): Couldn't create video window !\n"); + return -1; + } + + /* Create the blank cursor */ + SDL_BlankCursor = this->CreateWMCursor(this, blank_cdata, blank_cmask, + (int)BLANK_CWIDTH, (int)BLANK_CHEIGHT, + (int)BLANK_CHOTX, (int)BLANK_CHOTY); + + if (SDL_BlankCursor == NULL) + { + return -1; + } + + if (PgGetGraphicsHWCaps(&hwcaps) < 0) + { + SDL_SetError("ph_VideoInit(): GetGraphicsHWCaps function failed !\n"); + this->FreeWMCursor(this, SDL_BlankCursor); + return -1; + } + + if (PgGetVideoModeInfo(hwcaps.current_video_mode, &desktop_mode) < 0) + { + SDL_SetError("ph_VideoInit(): PgGetVideoModeInfo function failed !\n"); + this->FreeWMCursor(this, SDL_BlankCursor); + return -1; + } + + /* Determine the current screen size */ + this->info.current_w = desktop_mode.width; + this->info.current_h = desktop_mode.height; + + /* We need to return BytesPerPixel as it in used by CreateRGBsurface */ + vformat->BitsPerPixel = desktop_mode.bits_per_pixel; + vformat->BytesPerPixel = desktop_mode.bytes_per_scanline/desktop_mode.width; + desktopbpp = desktop_mode.bits_per_pixel; + + /* save current palette */ + if (desktopbpp==8) + { + PgGetPalette(savedpal); + PgGetPalette(syspalph); + } + else + { + for(i=0; i<_Pg_MAX_PALETTE; i++) + { + savedpal[i]=PgRGB(0, 0, 0); + syspalph[i]=PgRGB(0, 0, 0); + } + } + + currently_fullscreen = 0; + currently_hided = 0; + currently_maximized = 0; + current_overlay = NULL; + + OCImage.direct_context = NULL; + OCImage.offscreen_context = NULL; + OCImage.offscreen_backcontext = NULL; + OCImage.oldDC = NULL; + OCImage.CurrentFrameData = NULL; + OCImage.FrameData0 = NULL; + OCImage.FrameData1 = NULL; + videomode_emulatemode = 0; + + this->info.wm_available = 1; + + ph_UpdateHWInfo(this); + + return 0; +} + +static SDL_Surface* ph_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags) +{ + const struct ColourMasks* mask; + + /* Lock the event thread, in multi-threading environments */ + SDL_Lock_EventThread(); + + current->flags = flags; + + /* if we do not have desired fullscreen mode, then fallback into window mode */ + if (((current->flags & SDL_FULLSCREEN) == SDL_FULLSCREEN) && (ph_GetVideoMode(width, height, bpp)==0)) + { + current->flags &= ~SDL_FULLSCREEN; + current->flags &= ~SDL_NOFRAME; + current->flags &= ~SDL_RESIZABLE; + } + + ph_SetupWindow(this, width, height, current->flags); + + mask = ph_GetColourMasks(bpp); + if (mask != NULL) + { + SDL_ReallocFormat(current, mask->bpp, mask->red, mask->green, mask->blue, 0); + } + else + { + SDL_SetError("ph_SetVideoMode(): desired bpp is not supported by photon !\n"); + return NULL; + } + + if ((current->flags & SDL_OPENGL)==SDL_OPENGL) + { +#if !SDL_VIDEO_OPENGL + /* if no built-in OpenGL support */ + SDL_SetError("ph_SetVideoMode(): no OpenGL support, you need to recompile SDL.\n"); + current->flags &= ~SDL_OPENGL; + return NULL; +#endif /* SDL_VIDEO_OPENGL */ + } + else + { + /* Initialize internal variables */ + if ((current->flags & SDL_FULLSCREEN) == SDL_FULLSCREEN) + { + if (bpp==8) + { + desktoppal=SDLPH_PAL_SYSTEM; + } + + current->flags &= ~SDL_RESIZABLE; /* no resize for Direct Context */ + current->flags |= SDL_HWSURFACE; + } + else + { + /* remove this if we'll have support for the non-fullscreen sw/hw+doublebuf one day */ + current->flags &= ~SDL_DOUBLEBUF; + + /* Use offscreen memory if SDL_HWSURFACE flag is set */ + if ((current->flags & SDL_HWSURFACE) == SDL_HWSURFACE) + { + if (desktopbpp!=bpp) + { + current->flags &= ~SDL_HWSURFACE; + } + } + + /* using palette emulation code in window mode */ + if (bpp==8) + { + if (desktopbpp>=15) + { + desktoppal = SDLPH_PAL_EMULATE; + } + else + { + desktoppal = SDLPH_PAL_SYSTEM; + } + } + else + { + desktoppal = SDLPH_PAL_NONE; + } + } + } + + current->w = width; + current->h = height; + + if (desktoppal==SDLPH_PAL_SYSTEM) + { + current->flags|=SDL_HWPALETTE; + } + + /* Must call at least once for setup image planes */ + if (ph_SetupUpdateFunction(this, current, current->flags)==-1) + { + /* Error string was filled in the ph_SetupUpdateFunction() */ + return NULL; + } + + /* finish window drawing, if we are not in fullscreen, of course */ + if ((current->flags & SDL_FULLSCREEN) != SDL_FULLSCREEN) + { + PtFlush(); + } + else + { + PgFlush(); + } + + visualbpp=bpp; + + ph_UpdateHWInfo(this); + + SDL_Unlock_EventThread(); + + /* We've done! */ + return (current); +} + +static void ph_VideoQuit(_THIS) +{ + /* restore palette */ + if (desktopbpp==8) + { + PgSetPalette(syspalph, 0, -1, 0, 0, 0); + PgSetPalette(savedpal, 0, 0, _Pg_MAX_PALETTE, Pg_PALSET_GLOBAL | Pg_PALSET_FORCE_EXPOSE, 0); + PgFlush(); + } + + ph_DestroyImage(this, SDL_VideoSurface); + + if (window) + { + PtUnrealizeWidget(window); + PtDestroyWidget(window); + window=NULL; + } + + if (phevent!=NULL) + { + SDL_free(phevent); + phevent=NULL; + } +} + +static int ph_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors) +{ + int i; + SDL_Rect updaterect; + + updaterect.x = updaterect.y = 0; + updaterect.w = this->screen->w; + updaterect.h = this->screen->h; + + /* palette emulation code, using palette of the PhImage_t struct */ + if (desktoppal==SDLPH_PAL_EMULATE) + { + if ((SDL_Image) && (SDL_Image->palette)) + { + for (i=firstcolor; i<firstcolor+ncolors; i++) + { + syspalph[i] = PgRGB(colors[i-firstcolor].r, colors[i-firstcolor].g, colors[i-firstcolor].b); + SDL_Image->palette[i] = syspalph[i]; + } + + /* image needs to be redrawn */ + this->UpdateRects(this, 1, &updaterect); + } + } + else + { + if (desktoppal==SDLPH_PAL_SYSTEM) + { + for (i=firstcolor; i<firstcolor+ncolors; i++) + { + syspalph[i] = PgRGB(colors[i-firstcolor].r, colors[i-firstcolor].g, colors[i-firstcolor].b); + } + + if ((this->screen->flags & SDL_FULLSCREEN) != SDL_FULLSCREEN) + { + /* window mode must use soft palette */ + PgSetPalette(&syspalph[firstcolor], 0, firstcolor, ncolors, Pg_PALSET_GLOBAL, 0); + /* image needs to be redrawn */ + this->UpdateRects(this, 1, &updaterect); + } + else + { + /* fullscreen mode must use hardware palette */ + PgSetPalette(&syspalph[firstcolor], 0, firstcolor, ncolors, Pg_PALSET_GLOBAL, 0); + } + } + else + { + /* SDLPH_PAL_NONE do nothing */ + } + } + + return 1; +} + |