--- a/src/video/photon/SDL_ph_image.c	Sat Feb 14 10:12:27 2004 +0000
+++ b/src/video/photon/SDL_ph_image.c	Sat Feb 14 20:22:21 2004 +0000
@@ -164,7 +164,7 @@
 
     screen->pitch = OCImage.offscreen_context->pitch;
 
-    OCImage.dc_ptr = (unsigned char *) PdGetOffscreenContextPtr(OCImage.offscreen_context);
+    OCImage.dc_ptr = (unsigned char *)PdGetOffscreenContextPtr(OCImage.offscreen_context);
 
     if (OCImage.dc_ptr == NULL)
     {
@@ -212,7 +212,7 @@
     
     if ((screen->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF)
     {
-        OCImage.offscreen_backcontext = PdDupOffscreenContext(OCImage.offscreen_context, Pg_OSC_CRTC_SAFE | Pg_OSC_MEM_PAGE_ALIGN);
+        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");
@@ -240,15 +240,32 @@
     }
 
     /* wait for the hardware */
+    PgFlush();
     PgWaitHWIdle();
 
     if ((screen->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF)
     {
-        OCImage.current = 1;
-        PhDCSetCurrent(OCImage.offscreen_backcontext);
-        screen->pitch = OCImage.offscreen_backcontext->pitch;
-        screen->pixels = OCImage.FrameData1;
-        PgSwapDisplay(OCImage.offscreen_context, 0);
+        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++)
+           {
+              memset(screen->pixels+screen->pitch*i, 0x00, screen->pitch);
+           }
+           for (i=440; i<480; i++)
+           {
+              memset(screen->pixels+screen->pitch*i, 0x00, screen->pitch);
+           }
+           screen->pixels+=screen->pitch*40;
+        }
+        PgSwapDisplay(OCImage.offscreen_backcontext, 0);
     }
     else
     {
@@ -256,11 +273,29 @@
         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++)
+           {
+              memset(screen->pixels+screen->pitch*i, 0x00, screen->pitch);
+           }
+           for (i=440; i<480; i++)
+           {
+              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;
 }
@@ -427,73 +462,495 @@
     }
 }
 
+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;
+    }
+
+    this->info.blit_hw = 1;
+
+    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);
     
 #ifdef HAVE_OPENGL
     if ((flags & SDL_OPENGL)==SDL_OPENGL)
     {
-        return ph_SetupOpenGLImage(this, screen);
+        setupresult=ph_SetupOpenGLImage(this, screen);
+    }
+    else
+    {
+#endif /* HAVE_OPENGL */
+       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);
+          }
+       }
+#ifdef HAVE_OPENGL
     }
 #endif /* HAVE_OPENGL */
-    if ((flags & SDL_FULLSCREEN)==SDL_FULLSCREEN)
+    if (setupresult!=-1)
     {
-        return ph_SetupFullScreenImage(this, screen);
+       ph_UpdateHWInfo(this);
     }
-    if ((flags & SDL_HWSURFACE)==SDL_HWSURFACE)
-    {
-        return ph_SetupOCImage(this, screen);
-    }
-
-    return ph_SetupImage(this, screen);
+    
+    return setupresult;
 }
 
 int ph_AllocHWSurface(_THIS, SDL_Surface* surface)
 {
-    return(-1);
+    PgHWCaps_t hwcaps;
+
+    if (surface->hwdata!=NULL)
+    {
+       SDL_SetError("ph_AllocHWSurface(): hwdata already exists!\n");
+       return -1;
+    }
+    surface->hwdata=malloc(sizeof(struct private_hwdata));
+    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);
+    
+    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;
+
+    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();
-        if (OCImage.current==0)
+
+        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)
         {
-            PgSwapDisplay(OCImage.offscreen_context, 0);
-            OCImage.current=1;
-            screen->pitch = OCImage.offscreen_backcontext->pitch;
-            screen->pixels = OCImage.FrameData1;
-            PhDCSetCurrent(OCImage.offscreen_backcontext);
-            PgFlush();
+            farea.pos.y+=40;
         }
-        else
-        {
-            PgSwapDisplay(OCImage.offscreen_backcontext, 0);
-            OCImage.current=0;
-            screen->pitch = OCImage.offscreen_context->pitch;
-            screen->pixels = OCImage.FrameData0;
-            PhDCSetCurrent(OCImage.offscreen_context);
-            PgFlush();
-        }
+
+        PgContextBlitArea(OCImage.offscreen_context, &farea, OCImage.offscreen_backcontext, &farea);
+
+        /* flush the blitting */
+        PgFlush();
+        PgWaitHWIdle();
     }
     return 0;
 }
 
-int ph_LockHWSurface(_THIS, SDL_Surface *surface)
+int ph_LockHWSurface(_THIS, SDL_Surface* surface)
 {
-    return(0);
+
+#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;
 }
 
-void ph_UnlockHWSurface(_THIS, SDL_Surface *surface)
+int ph_HWAccelBlit(SDL_Surface* src, SDL_Rect* srcrect, SDL_Surface* dst, SDL_Rect* dstrect)
 {
-    return;
+    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 (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_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 (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)
+{
+    return -1;
 }
 
 #ifdef HAVE_OPENGL
@@ -513,12 +970,12 @@
 
     for (i=0; i<numrects; ++i) 
     {
-    	if (rects[i].w==0) /* Clipped? */
+    	if (rects[i].w==0) /* Clipped? dunno why but this occurs sometime. */
         { 
             continue;
         }
 
-    	if (rects[i].h==0) /* Clipped? */
+    	if (rects[i].h==0) /* Clipped? dunno why but this occurs sometime. */
         { 
             continue;
         }
@@ -532,13 +989,14 @@
 
         if (PgDrawPhImageRectmx(&ph_pos, SDL_Image, &ph_rect, 0) < 0)
         {
-            SDL_SetError("ph_NormalUpdate(): PgDrawPhImageRectmx failed !\n");
+            SDL_SetError("ph_NormalUpdate(): PgDrawPhImageRectmx failed!\n");
+            return;
         }
     }
 
     if (PgFlush() < 0)
     {
-    	SDL_SetError("ph_NormalUpdate(): PgFlush failed.\n");
+    	SDL_SetError("ph_NormalUpdate(): PgFlush() function failed!\n");
     }
 }
 
@@ -546,12 +1004,15 @@
 {
     int i;
 
-    PhPoint_t zero = {0};
+    PhPoint_t zero = {0, 0};
     PhArea_t src_rect;
     PhArea_t dest_rect;
 
+    PgSetTranslation(&zero, 0);
     PgSetRegion(PtWidgetRid(window));
     PgSetClipping(0, NULL);
+
+    PgFlush();
     PgWaitHWIdle();
 
     for (i=0; i<numrects; ++i)
@@ -565,7 +1026,7 @@
         {
             continue;
         }
-
+        
         src_rect.pos.x=rects[i].x;
         src_rect.pos.y=rects[i].y;
         dest_rect.pos.x=rects[i].x;
@@ -575,12 +1036,7 @@
         src_rect.size.h=rects[i].h;
         dest_rect.size.w=rects[i].w;
         dest_rect.size.h=rects[i].h;
-
-        zero.x = 0;
-        zero.y = 0;
-        PgSetTranslation(&zero, 0);
-        PgSetRegion(PtWidgetRid(window));
-        PgSetClipping(0, NULL);
+        
         PgContextBlitArea(OCImage.offscreen_context, &src_rect, NULL, &dest_rect);
     }