/*

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

*/

#include "SDL_config.h"

#include <Ph.h>

#include <photon/Pg.h>

#include "SDL_endian.h"

#include "SDL_video.h"

#include "../SDL_pixels_c.h"

#include "SDL_ph_video.h"

#include "SDL_ph_image_c.h"

#include "SDL_ph_modes_c.h"

#include "SDL_ph_gl.h"

int ph_SetupImage(_THIS, SDL_Surface *screen)

{

PgColor_t* palette=NULL;

int type=0;

int bpp;

bpp=screen->format->BitsPerPixel;

/* Determine image type */

switch(bpp)

{

case 8:{

type = Pg_IMAGE_PALETTE_BYTE;

}

break;

case 15:{

type = Pg_IMAGE_DIRECT_555;

}

break;

case 16:{

type = Pg_IMAGE_DIRECT_565;

}

break;

case 24:{

type = Pg_IMAGE_DIRECT_888;

}

break;

case 32:{

type = Pg_IMAGE_DIRECT_8888;

}

break;

default:{

SDL_SetError("ph_SetupImage(): unsupported bpp=%d !\n", bpp);

return -1;

}

break;

}

/* palette emulation code */

if ((bpp==8) && (desktoppal==SDLPH_PAL_EMULATE))

{

/* creating image palette */

palette=SDL_malloc(_Pg_MAX_PALETTE*sizeof(PgColor_t));

if (palette==NULL)

{

SDL_SetError("ph_SetupImage(): can't allocate memory for palette !\n");

return -1;

}

PgGetPalette(palette);

/* using shared memory for speed (set last param to 1) */

if ((SDL_Image = PhCreateImage(NULL, screen->w, screen->h, type, palette, _Pg_MAX_PALETTE, 1)) == NULL)

{

SDL_SetError("ph_SetupImage(): PhCreateImage() failed for bpp=8 !\n");

SDL_free(palette);

return -1;

}

}

else

{

/* using shared memory for speed (set last param to 1) */

if ((SDL_Image = PhCreateImage(NULL, screen->w, screen->h, type, NULL, 0, 1)) == NULL)

{

SDL_SetError("ph_SetupImage(): PhCreateImage() failed for bpp=%d !\n", bpp);

return -1;

}

}

screen->pixels = SDL_Image->image;

screen->pitch = SDL_Image->bpl;

this->UpdateRects = ph_NormalUpdate;

return 0;

}

int ph_SetupOCImage(_THIS, SDL_Surface *screen)

{

int type = 0;

int bpp;

OCImage.flags = screen->flags;

bpp=screen->format->BitsPerPixel;

/* Determine image type */

switch(bpp)

{

case 8: {

type = Pg_IMAGE_PALETTE_BYTE;

}

break;

case 15:{

type = Pg_IMAGE_DIRECT_555;

}

break;

case 16:{

type = Pg_IMAGE_DIRECT_565;

}

break;

case 24:{

type = Pg_IMAGE_DIRECT_888;

}

break;

case 32:{

type = Pg_IMAGE_DIRECT_8888;

}

break;

default:{

SDL_SetError("ph_SetupOCImage(): unsupported bpp=%d !\n", bpp);

return -1;

}

break;

}

/* Currently offscreen contexts with the same bit depth as display bpp only can be created */

OCImage.offscreen_context = PdCreateOffscreenContext(0, screen->w, screen->h, Pg_OSC_MEM_PAGE_ALIGN);

if (OCImage.offscreen_context == NULL)

{

SDL_SetError("ph_SetupOCImage(): PdCreateOffscreenContext() function failed !\n");

return -1;

}

screen->pitch = OCImage.offscreen_context->pitch;

OCImage.dc_ptr = (unsigned char *)PdGetOffscreenContextPtr(OCImage.offscreen_context);

if (OCImage.dc_ptr == NULL)

{

SDL_SetError("ph_SetupOCImage(): PdGetOffscreenContextPtr function failed !\n");

PhDCRelease(OCImage.offscreen_context);

return -1;

}

OCImage.FrameData0 = OCImage.dc_ptr;

OCImage.CurrentFrameData = OCImage.FrameData0;

OCImage.current = 0;

PhDCSetCurrent(OCImage.offscreen_context);

screen->pixels = OCImage.CurrentFrameData;

this->UpdateRects = ph_OCUpdate;

return 0;

}

int ph_SetupFullScreenImage(_THIS, SDL_Surface* screen)

{

OCImage.flags = screen->flags;

/* Begin direct and fullscreen mode */

if (!ph_EnterFullScreen(this, screen, PH_ENTER_DIRECTMODE))

{

return -1;

}

/* store palette for fullscreen */

if ((screen->format->BitsPerPixel==8) && (desktopbpp!=8))

{

PgGetPalette(savedpal);

PgGetPalette(syspalph);

}

OCImage.offscreen_context = PdCreateOffscreenContext(0, 0, 0, Pg_OSC_MAIN_DISPLAY | Pg_OSC_MEM_PAGE_ALIGN | Pg_OSC_CRTC_SAFE);

if (OCImage.offscreen_context == NULL)

{

SDL_SetError("ph_SetupFullScreenImage(): PdCreateOffscreenContext() function failed !\n");

return -1;

}

if ((screen->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF)

{

OCImage.offscreen_backcontext = PdDupOffscreenContext(OCImage.offscreen_context, Pg_OSC_MEM_PAGE_ALIGN | Pg_OSC_CRTC_SAFE);

if (OCImage.offscreen_backcontext == NULL)

{

SDL_SetError("ph_SetupFullScreenImage(): PdCreateOffscreenContext(back) function failed !\n");

return -1;

}

}

OCImage.FrameData0 = (unsigned char *)PdGetOffscreenContextPtr(OCImage.offscreen_context);

if (OCImage.FrameData0 == NULL)

{

SDL_SetError("ph_SetupFullScreenImage(): PdGetOffscreenContextPtr() function failed !\n");

ph_DestroyImage(this, screen);

return -1;

}

if ((screen->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF)

{

OCImage.FrameData1 = (unsigned char *)PdGetOffscreenContextPtr(OCImage.offscreen_backcontext);

if (OCImage.FrameData1 == NULL)

{

SDL_SetError("ph_SetupFullScreenImage(back): PdGetOffscreenContextPtr() function failed !\n");

ph_DestroyImage(this, screen);

return -1;

}

}

/* wait for the hardware */

PgFlush();

PgWaitHWIdle();

if ((screen->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF)

{

OCImage.current = 0;

PhDCSetCurrent(OCImage.offscreen_context);

screen->pitch = OCImage.offscreen_context->pitch;

screen->pixels = OCImage.FrameData0;

/* emulate 640x400 videomode */

if (videomode_emulatemode==1)

{

int i;

for (i=0; i<40; i++)

{

SDL_memset(screen->pixels+screen->pitch*i, 0x00, screen->pitch);

}

for (i=440; i<480; i++)

{

SDL_memset(screen->pixels+screen->pitch*i, 0x00, screen->pitch);

}

screen->pixels+=screen->pitch*40;

}

PgSwapDisplay(OCImage.offscreen_backcontext, 0);

}

else

{

OCImage.current = 0;

PhDCSetCurrent(OCImage.offscreen_context);

screen->pitch = OCImage.offscreen_context->pitch;

screen->pixels = OCImage.FrameData0;

/* emulate 640x400 videomode */

if (videomode_emulatemode==1)

{

int i;

for (i=0; i<40; i++)

{

SDL_memset(screen->pixels+screen->pitch*i, 0x00, screen->pitch);

}

for (i=440; i<480; i++)

{

SDL_memset(screen->pixels+screen->pitch*i, 0x00, screen->pitch);

}

screen->pixels+=screen->pitch*40;

}

}

this->UpdateRects = ph_OCDCUpdate;

/* wait for the hardware */

PgFlush();

PgWaitHWIdle();

return 0;

}

#if SDL_VIDEO_OPENGL

int ph_SetupOpenGLImage(_THIS, SDL_Surface* screen)

{

this->UpdateRects = ph_OpenGLUpdate;

screen->pixels=NULL;

screen->pitch=NULL;

#if (_NTO_VERSION >= 630)

if ((screen->flags & SDL_FULLSCREEN) == SDL_FULLSCREEN)

{

if (!ph_EnterFullScreen(this, screen, PH_IGNORE_DIRECTMODE))

{

screen->flags &= ~SDL_FULLSCREEN;

return -1;

}

}

#endif /* 6.3.0 */

if (ph_SetupOpenGLContext(this, screen->w, screen->h, screen->format->BitsPerPixel, screen->flags)!=0)

{

screen->flags &= ~SDL_OPENGL;

return -1;

}

return 0;

}

#endif /* SDL_VIDEO_OPENGL */

void ph_DestroyImage(_THIS, SDL_Surface* screen)

{

#if SDL_VIDEO_OPENGL

if ((screen->flags & SDL_OPENGL)==SDL_OPENGL)

{

if (oglctx)

{

#if (_NTO_VERSION < 630)

PhDCSetCurrent(NULL);

PhDCRelease(oglctx);

#else

qnxgl_context_destroy(oglctx);

qnxgl_buffers_destroy(oglbuffers);

qnxgl_finish();

#endif /* 6.3.0 */

oglctx=NULL;

oglbuffers=NULL;

oglflags=0;

oglbpp=0;

}

#if (_NTO_VERSION >= 630)

if (currently_fullscreen)

{

ph_LeaveFullScreen(this);

}

#endif /* 6.3.0 */

return;

}

#endif /* SDL_VIDEO_OPENGL */

if (currently_fullscreen)

{

/* if we right now in 8bpp fullscreen we must release palette */

if ((screen->format->BitsPerPixel==8) && (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_LeaveFullScreen(this);

}

if (OCImage.offscreen_context != NULL)

{

PhDCRelease(OCImage.offscreen_context);

OCImage.offscreen_context = NULL;

OCImage.FrameData0 = NULL;

}

if (OCImage.offscreen_backcontext != NULL)

{

PhDCRelease(OCImage.offscreen_backcontext);

OCImage.offscreen_backcontext = NULL;

OCImage.FrameData1 = NULL;

}

OCImage.CurrentFrameData = NULL;

if (SDL_Image)

{

/* if palette allocated, free it */

if (SDL_Image->palette)

{

SDL_free(SDL_Image->palette);

}

PgShmemDestroy(SDL_Image->image);

SDL_free(SDL_Image);

}

/* Must be zeroed everytime */

SDL_Image = NULL;

if (screen)

{

screen->pixels = NULL;

}

}

int ph_UpdateHWInfo(_THIS)

{

PgVideoModeInfo_t vmode;

PgHWCaps_t hwcaps;

/* Update video ram amount */

if (PgGetGraphicsHWCaps(&hwcaps) < 0)

{

SDL_SetError("ph_UpdateHWInfo(): GetGraphicsHWCaps() function failed !\n");

return -1;

}

this->info.video_mem=hwcaps.currently_available_video_ram/1024;

/* obtain current mode capabilities */

if (PgGetVideoModeInfo(hwcaps.current_video_mode, &vmode) < 0)

{

SDL_SetError("ph_UpdateHWInfo(): GetVideoModeInfo() function failed !\n");

return -1;

}

if ((vmode.mode_capabilities1 & PgVM_MODE_CAP1_OFFSCREEN) == PgVM_MODE_CAP1_OFFSCREEN)

{

/* this is a special test for drivers which tries to lie about offscreen capability */

if (hwcaps.currently_available_video_ram!=0)

{

this->info.hw_available = 1;

}

else

{

this->info.hw_available = 0;

}

}

else

{

this->info.hw_available = 0;

}

if ((vmode.mode_capabilities2 & PgVM_MODE_CAP2_RECTANGLE) == PgVM_MODE_CAP2_RECTANGLE)

{

this->info.blit_fill = 1;

}

else

{

this->info.blit_fill = 0;

}

if ((vmode.mode_capabilities2 & PgVM_MODE_CAP2_BITBLT) == PgVM_MODE_CAP2_BITBLT)

{

this->info.blit_hw = 1;

}

else

{

this->info.blit_hw = 0;

}

if ((vmode.mode_capabilities2 & PgVM_MODE_CAP2_ALPHA_BLEND) == PgVM_MODE_CAP2_ALPHA_BLEND)

{

this->info.blit_hw_A = 1;

}

else

{

this->info.blit_hw_A = 0;

}

if ((vmode.mode_capabilities2 & PgVM_MODE_CAP2_CHROMA) == PgVM_MODE_CAP2_CHROMA)

{

this->info.blit_hw_CC = 1;

}

else

{

this->info.blit_hw_CC = 0;

}

return 0;

}

int ph_SetupUpdateFunction(_THIS, SDL_Surface* screen, Uint32 flags)

{

int setupresult=-1;

ph_DestroyImage(this, screen);

#if SDL_VIDEO_OPENGL

if ((flags & SDL_OPENGL)==SDL_OPENGL)

{

setupresult=ph_SetupOpenGLImage(this, screen);

}

else

{

#endif

if ((flags & SDL_FULLSCREEN)==SDL_FULLSCREEN)

{

setupresult=ph_SetupFullScreenImage(this, screen);

}

else

{

if ((flags & SDL_HWSURFACE)==SDL_HWSURFACE)

{

setupresult=ph_SetupOCImage(this, screen);

}

else

{

setupresult=ph_SetupImage(this, screen);

}

}

#if SDL_VIDEO_OPENGL

}

#endif

if (setupresult!=-1)

{

ph_UpdateHWInfo(this);

}

return setupresult;

}

int ph_AllocHWSurface(_THIS, SDL_Surface* surface)

{

PgHWCaps_t hwcaps;

if (surface->hwdata!=NULL)

{

SDL_SetError("ph_AllocHWSurface(): hwdata already exists!\n");

return -1;

}

surface->hwdata=SDL_malloc(sizeof(struct private_hwdata));

SDL_memset(surface->hwdata, 0x00, sizeof(struct private_hwdata));

surface->hwdata->offscreenctx=PdCreateOffscreenContext(0, surface->w, surface->h, Pg_OSC_MEM_PAGE_ALIGN);

if (surface->hwdata->offscreenctx == NULL)

{

SDL_SetError("ph_AllocHWSurface(): PdCreateOffscreenContext() function failed !\n");

return -1;

}

surface->pixels=PdGetOffscreenContextPtr(surface->hwdata->offscreenctx);

if (surface->pixels==NULL)

{

PhDCRelease(surface->hwdata->offscreenctx);

SDL_SetError("ph_AllocHWSurface(): PdGetOffscreenContextPtr() function failed !\n");

return -1;

}

surface->pitch=surface->hwdata->offscreenctx->pitch;

surface->flags|=SDL_HWSURFACE;

surface->flags|=SDL_PREALLOC;

#if 0 /* FIXME */

/* create simple offscreen lock */

surface->hwdata->crlockparam.flags=0;

if (PdCreateOffscreenLock(surface->hwdata->offscreenctx, &surface->hwdata->crlockparam)!=EOK)

{

PhDCRelease(surface->hwdata->offscreenctx);

SDL_SetError("ph_AllocHWSurface(): Can't create offscreen lock !\n");

return -1;

}

#endif /* 0 */

/* Update video ram amount */

if (PgGetGraphicsHWCaps(&hwcaps) < 0)

{

PdDestroyOffscreenLock(surface->hwdata->offscreenctx);

PhDCRelease(surface->hwdata->offscreenctx);

SDL_SetError("ph_AllocHWSurface(): GetGraphicsHWCaps() function failed !\n");

return -1;

}

this->info.video_mem=hwcaps.currently_available_video_ram/1024;

return 0;

}

void ph_FreeHWSurface(_THIS, SDL_Surface* surface)

{

PgHWCaps_t hwcaps;

if (surface->hwdata==NULL)

{

SDL_SetError("ph_FreeHWSurface(): no hwdata!\n");

return;

}

if (surface->hwdata->offscreenctx == NULL)

{

SDL_SetError("ph_FreeHWSurface(): no offscreen context to delete!\n");

return;

}

#if 0 /* FIXME */

/* unlock the offscreen context if it has been locked before destroy it */

if (PdIsOffscreenLocked(surface->hwdata->offscreenctx)==Pg_OSC_LOCKED)

{

PdUnlockOffscreen(surface->hwdata->offscreenctx);

}

PdDestroyOffscreenLock(surface->hwdata->offscreenctx);

#endif /* 0 */

PhDCRelease(surface->hwdata->offscreenctx);

SDL_free(surface->hwdata);

surface->hwdata=NULL;

/* Update video ram amount */

if (PgGetGraphicsHWCaps(&hwcaps) < 0)

{

SDL_SetError("ph_FreeHWSurface(): GetGraphicsHWCaps() function failed !\n");

return;

}

this->info.video_mem=hwcaps.currently_available_video_ram/1024;

return;

}

int ph_CheckHWBlit(_THIS, SDL_Surface *src, SDL_Surface *dst)

{

if ((src->hwdata==NULL) && (src != this->screen))

{

SDL_SetError("ph_CheckHWBlit(): Source surface haven't hardware specific data.\n");

src->flags&=~SDL_HWACCEL;

return -1;

}

if ((src->flags & SDL_HWSURFACE) != SDL_HWSURFACE)

{

SDL_SetError("ph_CheckHWBlit(): Source surface isn't a hardware surface.\n");

src->flags&=~SDL_HWACCEL;

return -1;

}

if ((src->flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY)

{

if (this->info.blit_hw_CC!=1)

{

src->flags&=~SDL_HWACCEL;

src->map->hw_blit=NULL;

return -1;

}

}

if ((src->flags & SDL_SRCALPHA) == SDL_SRCALPHA)

{

if (this->info.blit_hw_A!=1)

{

src->flags&=~SDL_HWACCEL;

src->map->hw_blit=NULL;

return -1;

}

}

src->flags|=SDL_HWACCEL;

src->map->hw_blit = ph_HWAccelBlit;

return 1;

}

PgColor_t ph_ExpandColor(_THIS, SDL_Surface* surface, Uint32 color)

{

Uint32 truecolor;

/* Photon API accepts true colors only during hw filling operations */

switch(surface->format->BitsPerPixel)

{

case 8:

{

if ((surface->format->palette) && (color<=surface->format->palette->ncolors))

{

truecolor=PgRGB(surface->format->palette->colors[color].r,

surface->format->palette->colors[color].g,

surface->format->palette->colors[color].b);

}

else

{

SDL_SetError("ph_ExpandColor(): Color out of range for the 8bpp mode !\n");

return 0xFFFFFFFFUL;

}

}

break;

case 15:

{

truecolor = ((color & 0x00007C00UL) << 9) | /* R */

((color & 0x000003E0UL) << 6) | /* G */

((color & 0x0000001FUL) << 3) | /* B */

((color & 0x00007000UL) << 4) | /* R compensation */

((color & 0x00000380UL) << 1) | /* G compensation */

((color & 0x0000001CUL) >> 2); /* B compensation */

}

break;

case 16:

{

truecolor = ((color & 0x0000F800UL) << 8) | /* R */

((color & 0x000007E0UL) << 5) | /* G */

((color & 0x0000001FUL) << 3) | /* B */

((color & 0x0000E000UL) << 3) | /* R compensation */

((color & 0x00000600UL) >> 1) | /* G compensation */

((color & 0x0000001CUL) >> 2); /* B compensation */

}

break;

case 24:

{

truecolor=color & 0x00FFFFFFUL;

}

break;

case 32:

{

truecolor=color;

}

break;

default:

{

SDL_SetError("ph_ExpandColor(): Unsupported depth for the hardware operations !\n");

return 0xFFFFFFFFUL;

}

}

return truecolor;

}

int ph_FillHWRect(_THIS, SDL_Surface* surface, SDL_Rect* rect, Uint32 color)

{

PgColor_t oldcolor;

Uint32 truecolor;

int ydisp=0;

if (this->info.blit_fill!=1)

{

return -1;

}

truecolor=ph_ExpandColor(this, surface, color);

if (truecolor==0xFFFFFFFFUL)

{

return -1;

}

oldcolor=PgSetFillColor(truecolor);

/* 640x400 videomode emulation */

if (videomode_emulatemode==1)

{

ydisp+=40;

}

PgDrawIRect(rect->x, rect->y+ydisp, rect->w+rect->x-1, rect->h+rect->y+ydisp-1, Pg_DRAW_FILL);

PgSetFillColor(oldcolor);

PgFlush();

PgWaitHWIdle();

return 0;

}

int ph_FlipHWSurface(_THIS, SDL_Surface* screen)

{

PhArea_t farea;

if ((screen->flags & SDL_FULLSCREEN) == SDL_FULLSCREEN)

{

/* flush all drawing ops before blitting */

PgFlush();

PgWaitHWIdle();

farea.pos.x=0;

farea.pos.y=0;

farea.size.w=screen->w;

farea.size.h=screen->h;

/* emulate 640x400 videomode */

if (videomode_emulatemode==1)

{

farea.pos.y+=40;

}

PgContextBlitArea(OCImage.offscreen_context, &farea, OCImage.offscreen_backcontext, &farea);

/* flush the blitting */

PgFlush();

PgWaitHWIdle();

}

return 0;

}

int ph_LockHWSurface(_THIS, SDL_Surface* surface)

{

#if 0 /* FIXME */

int lockresult;

if (surface->hwdata == NULL)

{

return;

}

surface->hwdata->lockparam.flags=0;

surface->hwdata->lockparam.time_out=NULL;

lockresult=PdLockOffscreen(surface->hwdata->offscreenctx, &surface->hwdata->lockparam);

switch (lockresult)

{

case EOK:

break;

case Pg_OSC_LOCK_DEADLOCK:

SDL_SetError("ph_LockHWSurface(): Deadlock detected !\n");

return -1;

case Pg_OSC_LOCK_INVALID:

SDL_SetError("ph_LockHWSurface(): Lock invalid !\n");

return -1;

default:

SDL_SetError("ph_LockHWSurface(): Can't lock the surface !\n");

return -1;

}

#endif /* 0 */

return 0;

}

void ph_UnlockHWSurface(_THIS, SDL_Surface* surface)

{

#if 0 /* FIXME */

int unlockresult;

if ((surface == NULL) || (surface->hwdata == NULL))

{

return;

}

if (PdIsOffscreenLocked(surface->hwdata->offscreenctx)==Pg_OSC_LOCKED)

{

unlockresult=PdUnlockOffscreen(surface->hwdata->offscreenctx);

}

#endif /* 0 */

return;

}

int ph_HWAccelBlit(SDL_Surface* src, SDL_Rect* srcrect, SDL_Surface* dst, SDL_Rect* dstrect)

{

SDL_VideoDevice* this=current_video;

PhArea_t srcarea;

PhArea_t dstarea;

int ydisp=0;

/* 640x400 videomode emulation */

if (videomode_emulatemode==1)

{

ydisp+=40;

}

srcarea.pos.x=srcrect->x;

srcarea.pos.y=srcrect->y;

srcarea.size.w=srcrect->w;

srcarea.size.h=srcrect->h;

dstarea.pos.x=dstrect->x;

dstarea.pos.y=dstrect->y;

dstarea.size.w=dstrect->w;

dstarea.size.h=dstrect->h;

if (((src == this->screen) || (src->hwdata!=NULL)) && ((dst == this->screen) || (dst->hwdata!=NULL)))

{

if ((src->flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY)

{

ph_SetHWColorKey(this, src, src->format->colorkey);

PgChromaOn();

}

if ((src->flags & SDL_SRCALPHA) == SDL_SRCALPHA)

{

ph_SetHWAlpha(this, src, src->format->alpha);

PgAlphaOn();

}

if (dst == this->screen)

{

if (src == this->screen)

{

/* blitting from main screen to main screen */

dstarea.pos.y+=ydisp;

srcarea.pos.y+=ydisp;

PgContextBlitArea(OCImage.offscreen_context, &srcarea, OCImage.offscreen_context, &dstarea);

}

else

{

/* blitting from offscreen to main screen */

dstarea.pos.y+=ydisp;

PgContextBlitArea(src->hwdata->offscreenctx, &srcarea, OCImage.offscreen_context, &dstarea);

}

}

else

{

if (src == this->screen)

{

/* blitting from main screen to offscreen */

srcarea.pos.y+=ydisp;

PgContextBlitArea(OCImage.offscreen_context, &srcarea, dst->hwdata->offscreenctx, &dstarea);

}

else

{

/* blitting offscreen to offscreen */

PgContextBlitArea(src->hwdata->offscreenctx, &srcarea, dst->hwdata->offscreenctx, &dstarea);

}

}

if ((src->flags & SDL_SRCALPHA) == SDL_SRCALPHA)

{

PgAlphaOff();

}

if ((src->flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY)

{

PgChromaOff();

}

}

else

{

SDL_SetError("ph_HWAccelBlit(): Source or target surface is not a hardware surface !\n");

return -1;

}

PgFlush();

PgWaitHWIdle();

return 0;

}

int ph_SetHWColorKey(_THIS, SDL_Surface *surface, Uint32 key)

{

if (this->info.blit_hw_CC!=1)

{

return -1;

}

if (surface->hwdata!=NULL)

{

surface->hwdata->colorkey=ph_ExpandColor(this, surface, key);

if (surface->hwdata->colorkey==0xFFFFFFFFUL)

{

return -1;

}

}

PgSetChroma(surface->hwdata->colorkey, Pg_CHROMA_SRC_MATCH | Pg_CHROMA_NODRAW);

return 0;

}

int ph_SetHWAlpha(_THIS, SDL_Surface* surface, Uint8 alpha)

{

if (this->info.blit_hw_A!=1)

{

return -1;

}

PgSetAlphaBlend(NULL, alpha);

return 0;

}

#if SDL_VIDEO_OPENGL

void ph_OpenGLUpdate(_THIS, int numrects, SDL_Rect* rects)

{

this->GL_SwapBuffers(this);

return;

}

#endif /* SDL_VIDEO_OPENGL */

void ph_NormalUpdate(_THIS, int numrects, SDL_Rect *rects)

{

PhPoint_t ph_pos;

PhRect_t ph_rect;

int i;

for (i=0; i<numrects; ++i)

{

if (rects[i].w==0) /* Clipped? dunno why but this occurs sometime. */

{

continue;

}

if (rects[i].h==0) /* Clipped? dunno why but this occurs sometime. */

{

continue;

}

ph_pos.x = rects[i].x;

ph_pos.y = rects[i].y;

ph_rect.ul.x = rects[i].x;

ph_rect.ul.y = rects[i].y;

ph_rect.lr.x = rects[i].x + rects[i].w;

ph_rect.lr.y = rects[i].y + rects[i].h;

if (PgDrawPhImageRectmx(&ph_pos, SDL_Image, &ph_rect, 0) < 0)

{

SDL_SetError("ph_NormalUpdate(): PgDrawPhImageRectmx failed!\n");

return;

}

}

if (PgFlush() < 0)

{