Changeset 6935 for trunk/src/ddraw/OS2SURFACE.CPP

Timestamp:

Oct 3, 2001, 3:49:41 PM (24 years ago)

Author:

sandervl

Message:

take clipping info into account when blitting

File:

• trunk/src/ddraw/OS2SURFACE.CPP (modified) (23 diffs)

trunk/src/ddraw/OS2SURFACE.CPP

@@ -1 @@
-/* $Id: OS2SURFACE.CPP,v 1.33 2001-09-30 22:23:44 sandervl Exp $ */
+/* $Id: OS2SURFACE.CPP,v 1.34 2001-10-03 13:49:40 sandervl Exp $ */
 
 /*
@@ -6 +6 @@
  * Copyright 1999 Markus Montkowski
  * Copyright 2000 Michal Necasek
+ * Copyright 1998-2001 Sander van Leeuwen
  *
  * Project Odin Software License can be found in LICENSE.TXT
@@ -2162 +2163 @@
         LPRECT lpSrcRect, DWORD dwFlags, LPDDBLTFX lpDDBltFx)
 {
+ OS2IDirectDrawSurface *dest = (OS2IDirectDrawSurface *)This;
+ OS2IDirectDrawSurface *src  = (OS2IDirectDrawSurface *)lpDDSrcSurface;
+
+ DDSURFACEDESC2  DestSurfaceDesc, SrcSurfaceDesc;
+ DDRectangle    *pIRectDest,*pIRectSrc,*pIRectTest;
+ RECT            DestRect, SrcRect;
+ BOOL            Found;
+ int             i;
+ HRESULT         ret = DD_OK;
+
+  #ifdef DEBUG
+    dprintf(("DDRAW: SurfBlt4 To Surf %08X, from Surf %08X\n",dest,src));
+    if ( (NULL!=lpDestRect)&& (NULL!=lpSrcRect))
+      dprintf(("DDRAW: SurfBlt4 to (%d,%d)(%d,%d) at %08X from (%d,%d)(%d,%d) at %08X\n", lpDestRect->left, lpDestRect->top,
+               lpDestRect->right, lpDestRect->bottom, dest, lpSrcRect->left, lpSrcRect->top,
+               lpSrcRect->right, lpSrcRect->bottom, src));
+
+    _dump_DDBLT(dwFlags);
+  #endif
+
+  if (NULL!=lpDestRect)
+  {
+    // HACK: RA does pass in negative values we might be better return an error,
+    //for now we clip
+#define RA_HACK 1
+
+#ifdef RA_HACK
+    int top,left,bottom,right;
+
+    top    = lpDestRect->top;
+    left   = lpDestRect->left;
+    bottom = lpDestRect->bottom;
+    right  = lpDestRect->right;
+
+    if(top<0)
+    {
+      bottom += top;
+      top = 0;
+    }
+
+    if(top > dest->height)
+      return DDERR_INVALIDPARAMS;
+
+    if(bottom<0)
+      return DDERR_INVALIDPARAMS;
+
+    if(bottom>dest->height)
+      bottom=dest->height;
+
+    if(left<0)
+    {
+      right += left;
+      left = 0;
+    }
+
+    if(left>dest->width)
+      return DDERR_INVALIDPARAMS;
+
+    if(right<0)
+      return DDERR_INVALIDPARAMS;
+
+    if(right>dest->width)
+       right = dest->width;
+#endif    // RA_HACK
+
+    pIRectDest = new DDRectangle( left, top, right, bottom);
+#ifdef RA_HACK
+    DestRect.top    = top;
+    DestRect.left   = left;
+    DestRect.bottom = bottom;
+    DestRect.right  = right;
+#else
+    memcpy(&DestRect,lpDestRect,sizeof(RECT) );
+#endif //RA_HACK
+  }
+  else
+  {
+    pIRectDest = new DDRectangle( 0, 0, dest->width, dest->height);
+    DestRect.top    = 0;
+    DestRect.left   = 0;
+    DestRect.bottom = dest->height;
+    DestRect.right  = dest->width;
+  }
+
+  if(dest->fLocked)
+  {
+    if (NULL==lpDestRect)
+    {
+      // If anything is locked we can't blit to the complete surface as
+      // a part is locked
+      Found = TRUE;
+    }
+    else
+    {
+      // If the dest Rectangle intersects with any of the locked rectangles
+      // we can't blit to it
+
+      Found = FALSE;
+      i=0;
+      while( (i<DPA_GetPtrCount(dest->DPA_LockedRects))  && !Found)
+      {
+        pIRectTest = (DDRectangle*) DPA_FastGetPtr(dest->DPA_LockedRects,i);
+        Found = pIRectDest->intersects(*pIRectTest);
+        i++;
+      }
+
+    }
+    if (Found)
+    {
+      delete pIRectDest;
+      dprintf(("DDRAW: Blt: Dest Surface partially locked\n"));
+      return(DDERR_SURFACEBUSY);
+    }
+  }
+  delete pIRectDest;
+
+  if (NULL!=lpSrcRect)
+  {
+#ifdef RA_HACK
+    // Same as for dest rectangle now for src
+
+    int top,left,bottom,right;
+
+    top    = lpSrcRect->top;
+    left   = lpSrcRect->left;
+    bottom = lpSrcRect->bottom;
+    right  = lpSrcRect->right;
+
+    if(top<0)
+    {
+      bottom += top;
+      top = 0;
+    }
+
+    if(top > src->height)
+      return DDERR_INVALIDPARAMS;
+
+    if(bottom<0)
+      return DDERR_INVALIDPARAMS;
+
+    if(bottom>src->height)
+      bottom=src->height;
+
+    if(left<0)
+    {
+      right += left;
+      left = 0;
+    }
+
+    if(left>src->width)
+      return DDERR_INVALIDPARAMS;
+
+    if(right<0)
+      return DDERR_INVALIDPARAMS;
+
+    if(right>src->width)
+       right = src->width;
+#endif    // RA_HACK
+
+    pIRectSrc = new DDRectangle( left, top, right, bottom );
+#ifdef RA_HACK
+    SrcRect.top    = top;
+    SrcRect.left   = left;
+    SrcRect.bottom = bottom;
+    SrcRect.right  = right;
+#else
+    memcpy(&SrcRect,lpSrcRect,sizeof(RECT) );
+#endif
+  }
+  else
+  {
+    pIRectSrc = new DDRectangle( 0, 0, src->width, src->height);
+    SrcRect.top    = 0;
+    SrcRect.left   = 0;
+    SrcRect.bottom = src->height;
+    SrcRect.right  = src->width;
+  }
+
+  if(src->fLocked)
+  {
+    if (NULL==lpSrcRect)
+    {
+      // If anything is locked we can't blit from the complete surface as
+      // a part is locked
+      Found = TRUE;
+    }
+    else
+    {
+      // If the src Rectangle intersects with any of the locked rectangles of the
+      // source surface we can't blit from it
+
+      Found = FALSE;
+      i=0;
+
+      while((i<DPA_GetPtrCount(src->DPA_LockedRects) ) && !Found)
+      {
+        pIRectTest = (DDRectangle*) DPA_FastGetPtr(src->DPA_LockedRects,i);
+        Found = pIRectDest->intersects(*pIRectTest);
+        i++;
+      }
+
+    }
+
+    if (Found)
+    {
+      delete pIRectSrc;
+      dprintf(("DDRAW: Blt: Src Surface partly locked\n"));
+
+      return(DDERR_SURFACEBUSY);
+    }
+  }
+  delete pIRectSrc;
+
+  //TODO: do we need to check the source for clipping information in case
+  //      the app wants to copy from the frame buffer?
+  if(dest->lpClipper) 
+  {
+      DWORD rgnsize;
+      if(ClipGetClipList((IDirectDrawClipper*)dest->lpClipper, NULL, NULL, &rgnsize) == DD_OK) 
+      {
+          LPRGNDATA lpRgnData = (LPRGNDATA)alloca(rgnsize);
+          if(lpRgnData == NULL) {
+              DebugInt3();
+              goto doblit;
+          }
+          if(ClipGetClipList((IDirectDrawClipper*)dest->lpClipper, NULL, lpRgnData, &rgnsize) == DD_OK) 
+          {
+              RECT newdest, newsrc;
+              LPRECT lpClipRect = (LPRECT)&lpRgnData->Buffer;
+
+              for(i=0;i<lpRgnData->rdh.nCount;i++) 
+              {
+                  if(IntersectRect(&newdest, &DestRect, &lpClipRect[i]) == TRUE) 
+                  {
+                      //TODO: This is not correct for stretching blits
+                      newsrc.left   = SrcRect.left + (newdest.left - DestRect.left);
+                      newsrc.top    = SrcRect.top + (newdest.top - DestRect.top);
+                      newsrc.right  = newsrc.left + RECT_WIDTH(&newdest);
+                      newsrc.bottom = newsrc.top + RECT_HEIGHT(&newdest);
+
+                      ret = SurfDoBlt(This, &newdest, lpDDSrcSurface, &newsrc, dwFlags, lpDDBltFx);
+                      if(ret != DD_OK) {
+                          break;
+                      }
+                  }
+              }
+              return ret;
+          }
+      }
+  }
+doblit:
+  return SurfDoBlt(This, &DestRect, lpDDSrcSurface, &SrcRect, dwFlags, lpDDBltFx);
+}
+//******************************************************************************
+//******************************************************************************
+HRESULT WIN32API SurfDoBlt(THIS This, LPRECT lpDestRect, LPDIRECTDRAWSURFACE4 lpDDSrcSurface,
+                           LPRECT lpSrcRect, DWORD dwFlags, LPDDBLTFX lpDDBltFx)
+{
    // We have determine between 3 different blit senarios.
    // 1. Blitting between Divebuffers (Front/Backbuffer and primary surface)
@@ -2178 +2437 @@
 
  int                    x, i, BlitWidth, BlitHeight;
- PALETTEENTRY           SysPal[257];
- PLOGPALETTE            pLogPal = (PLOGPALETTE) SysPal;
- char                   *pBltPos, *pSrcPos;
+ char                  *pBltPos, *pSrcPos;
  DDSURFACEDESC2         DestSurfaceDesc, SrcSurfaceDesc;
- DDRectangle             *pIRectDest,*pIRectSrc,*pIRectTest;
- RECTL                  DestRect, SrcRect;
  BOOL Found;
  DWORD dwSrcColor, dwDestColor;
 
-  #ifdef DEBUG
-    dprintf(("DDRAW: SurfBlt4 To Surf %08X, from Surf %08X\n",dest,src));
-    if ( (NULL!=lpDestRect)&& (NULL!=lpSrcRect))
-      dprintf(("DDRAW: SurfBlt4 to (%d,%d)(%d,%d) at %08X from (%d,%d)(%d,%d) at %08X\n", lpDestRect->left, lpDestRect->top,
+  dprintf(("DDRAW: SurfDoBlt To Surf %08X, from Surf %08X\n",dest,src));
+  if ( (NULL!=lpDestRect)&& (NULL!=lpSrcRect))
+      dprintf(("DDRAW: SurfDoBlt to (%d,%d)(%d,%d) at %08X from (%d,%d)(%d,%d) at %08X\n", lpDestRect->left, lpDestRect->top,
                lpDestRect->right, lpDestRect->bottom, dest, lpSrcRect->left, lpSrcRect->top,
                lpSrcRect->right, lpSrcRect->bottom, src));
-
-    _dump_DDBLT(dwFlags);
-  #endif
-
-
-  if (NULL!=lpDestRect)
-  {
-    // HACK: RA does pss in negative values we might be better etrun an error,
-    //for now we clip
-#define RA_HACK 1
-
-#ifdef RA_HACK
-    int top,left,bottom,right;
-
-    top    = lpDestRect->top;
-    left   = lpDestRect->left;
-    bottom = lpDestRect->bottom;
-    right  = lpDestRect->right;
-
-    if(top<0)
-    {
-      bottom += top;
-      top = 0;
-    }
-
-    if(top > dest->height)
-      return DDERR_INVALIDPARAMS;
-
-    if(bottom<0)
-      return DDERR_INVALIDPARAMS;
-
-    if(bottom>dest->height)
-      bottom=dest->height;
-
-    if(left<0)
-    {
-      right += left;
-      left = 0;
-    }
-
-    if(left>dest->width)
-      return DDERR_INVALIDPARAMS;
-
-    if(right<0)
-      return DDERR_INVALIDPARAMS;
-
-    if(right>dest->width)
-       right = dest->width;
-#endif    // RA_HACK
-
-    pIRectDest = new DDRectangle( top,
-                                  left,
-                                  bottom,
-                                  right);
-#ifdef RA_HACK
-    DestRect.top    = top;
-    DestRect.left   = left;
-    DestRect.bottom = bottom;
-    DestRect.right  = right;
-#else
-    memcpy(&DestRect,lpDestRect,sizeof(RECTL) );
-#endif //RA_HACK
-  }
-  else
-  {
-    pIRectDest = new DDRectangle( 0, 0, dest->height, dest->width);
-    DestRect.top    = 0;
-    DestRect.left   = 0;
-    DestRect.bottom = dest->height;
-    DestRect.right  = dest->width;
-  }
-
-  if(dest->fLocked)
-  {
-    if (NULL==lpDestRect)
-    {
-      // If anything is locked we can't blit to the complete surface as
-      // a part is locked
-      Found = TRUE;
-    }
-    else
-    {
-      // If the dest Rectangle intersects with any of the locked rectangles
-      // we can't blit to it
-
-      Found = FALSE;
-      i=0;
-      while( (i<DPA_GetPtrCount(dest->DPA_LockedRects))  && !Found)
-      {
-        pIRectTest = (DDRectangle*) DPA_FastGetPtr(dest->DPA_LockedRects,i);
-        Found = pIRectDest->intersects(*pIRectTest);
-        i++;
-      }
-
-    }
-
-    if (Found)
-    {
-      delete pIRectDest;
-      dprintf(("DDRAW: Blt: Dest Surface partially locked\n"));
-      return(DDERR_SURFACEBUSY);
-    }
-  }
 
   DestSurfaceDesc.dwSize = sizeof(DDSURFACEDESC2);
@@ -2379 +2530 @@
   }
 
-  if (NULL!=lpSrcRect)
-  {
-#ifdef RA_HACK
-    // Same as for dest rectangle now for src
-
-    int top,left,bottom,right;
-
-    top    = lpSrcRect->top;
-    left   = lpSrcRect->left;
-    bottom = lpSrcRect->bottom;
-    right  = lpSrcRect->right;
-
-    if(top<0)
-    {
-      bottom += top;
-      top = 0;
-    }
-
-    if(top > src->height)
-      return DDERR_INVALIDPARAMS;
-
-    if(bottom<0)
-      return DDERR_INVALIDPARAMS;
-
-    if(bottom>src->height)
-      bottom=src->height;
-
-    if(left<0)
-    {
-      right += left;
-      left = 0;
-    }
-
-    if(left>src->width)
-      return DDERR_INVALIDPARAMS;
-
-    if(right<0)
-      return DDERR_INVALIDPARAMS;
-
-    if(right>src->width)
-       right = src->width;
-#endif    // RA_HACK
-
-    pIRectSrc = new DDRectangle( top,
-                                 left,
-                                 bottom,
-                                 right);
-#ifdef RA_HACK
-    SrcRect.top    = top;
-    SrcRect.left   = left;
-    SrcRect.bottom = bottom;
-    SrcRect.right  = right;
-#else
-    memcpy(&SrcRect,lpSrcRect,sizeof(RECTL) );
-#endif
-  }
-  else
-  {
-    pIRectSrc = new DDRectangle( 0, 0, src->height, src->width);
-    SrcRect.top    = 0;
-    SrcRect.left   = 0;
-    SrcRect.bottom = src->height;
-    SrcRect.right  = src->width;
-  }
-
-  if(src->fLocked)
-  {
-    if (NULL==lpSrcRect)
-    {
-      // If anything is locked we can't blit from the complete surface as
-      // a part is locked
-      Found = TRUE;
-    }
-    else
-    {
-      // If the src Rectangle intersects with any of the locked rectangles of the
-      // source surface we can't blit from it
-
-      Found = FALSE;
-      i=0;
-
-      while((i<DPA_GetPtrCount(src->DPA_LockedRects) ) && !Found)
-      {
-        pIRectTest = (DDRectangle*) DPA_FastGetPtr(src->DPA_LockedRects,i);
-        Found = pIRectDest->intersects(*pIRectTest);
-        i++;
-      }
-
-    }
-
-    if (Found)
-    {
-      delete pIRectSrc;
-      dprintf(("DDRAW: Blt: Src Surface partly locked\n"));
-
-      return(DDERR_SURFACEBUSY);
-    }
-  }
-
   if( ( (NULL==lpDestRect) && (NULL!=lpSrcRect) ) ||
       ( (NULL==lpSrcRect) && (NULL!=lpDestRect) ) )
@@ -2486 +2538 @@
   }
 
-  if( ( pIRectDest->width()  != pIRectSrc->width() ) ||
-      ( pIRectDest->height() != pIRectSrc->height() )
+  if( ( RECT_WIDTH(lpDestRect)  != RECT_WIDTH(lpSrcRect) ) ||
+      ( RECT_HEIGHT(lpDestRect) != RECT_HEIGHT(lpSrcRect) )
     )
   {
@@ -2505 +2557 @@
       dprintf(("DDRAW: Src is Primary Surface\n"));
 
-      if( *pIRectDest == *pIRectSrc)
+      if( RECT_EQUAL(lpDestRect, lpSrcRect))
         return DD_OK; // rects are the same => no blit needed
 
@@ -2511 +2563 @@
 
       MoveRects( dest->pDiveBuffer,
-                 (LPRECT)&DestRect,
-                 (LPRECT)&SrcRect,
+                 lpDestRect,
+                 lpSrcRect,
                  dest->dwBytesPPDive,
                  dest->dwPitchDB);
@@ -2519 +2571 @@
       {
         MoveRects( dest->pFrameBuffer,
-                   (LPRECT)&DestRect,
-                   (LPRECT)&SrcRect,
+                   lpDestRect,
+                   lpSrcRect,
                    dest->lpDraw->GetScreenBpp()>>3,
                    dest->dwPitchFB);
@@ -2554 +2606 @@
         dest->BltSolid( dest->pDiveBuffer,
                         dest->pFrameBuffer,
-                        DestRect.top,
-                        DestRect.left,
+                        lpDestRect->top,
+                        lpDestRect->left,
                         dest->dwPitchDB,
                         dest->dwPitchFB,
                         src->pDiveBuffer,
                         src->pFrameBuffer,
-                        SrcRect.top,
-                        SrcRect.left,
-                        pIRectDest->width(),
-                        pIRectDest->height(),
+                        lpSrcRect->top,
+                        lpSrcRect->left,
+                        RECT_WIDTH(lpDestRect),
+                        RECT_HEIGHT(lpDestRect),
                         src->dwPitchDB,
                         src->dwPitchFB
@@ -2571 +2623 @@
       else
       {
-        pBltPos = (char*) dest->pDiveBuffer + (DestRect.top * dest->dwPitchDB) +
-                  (DestRect.left * dest->dwBytesPPDive);
-
-        pSrcPos = (char*) src->pDiveBuffer + (SrcRect.top * src->dwPitchDB) +
-                  (SrcRect.left * src->dwBytesPPDive);
-
-        BlitHeight = pIRectDest->height();
-        BlitWidth = pIRectDest->width();
+        pBltPos = (char*) dest->pDiveBuffer + (lpDestRect->top * dest->dwPitchDB) +
+                  (lpDestRect->left * dest->dwBytesPPDive);
+
+        pSrcPos = (char*) src->pDiveBuffer + (lpSrcRect->top * src->dwPitchDB) +
+                  (lpSrcRect->left * src->dwBytesPPDive);
+
+        BlitHeight = RECT_HEIGHT(lpDestRect);
+        BlitWidth  = RECT_WIDTH(lpDestRect);
         // Transparent Blit
         if( (dwFlags &DDBLT_KEYSRC) || (dwFlags & DDBLT_KEYSRCOVERRIDE) )
@@ -2609 +2661 @@
         // DIVE => DIVE  or Mem => Dive
         // or a rectangle from streen to a buffer can be handelt in the same way
-        pBltPos = (char*) dest->pDiveBuffer + (DestRect.top * dest->dwPitchDB) +
-                  (DestRect.left * dest->dwBytesPPDive);
-
-        pSrcPos = (char*) src->pDiveBuffer + (SrcRect.top * src->dwPitchDB) +
-                  (SrcRect.left * src->dwBytesPPDive);
-
-        BlitHeight = pIRectDest->height();
-        BlitWidth = pIRectDest->width();
+        pBltPos = (char*) dest->pDiveBuffer + (lpDestRect->top * dest->dwPitchDB) +
+                  (lpDestRect->left * dest->dwBytesPPDive);
+
+        pSrcPos = (char*) src->pDiveBuffer + (lpSrcRect->top * src->dwPitchDB) +
+                  (lpSrcRect->left * src->dwBytesPPDive);
+
+        BlitHeight = RECT_HEIGHT(lpDestRect);
+        BlitWidth  = RECT_WIDTH(lpDestRect);
 
         // Check for transparent blit
@@ -2623 +2675 @@
           dest->BltSolid( dest->pDiveBuffer,
                           dest->pFrameBuffer,
-                          DestRect.top,
-                          DestRect.left,
+                          lpDestRect->top,
+                          lpDestRect->left,
                           dest->dwPitchDB,
                           dest->dwPitchFB,
                           src->pDiveBuffer,
                           src->pFrameBuffer,
-                          SrcRect.top,
-                          SrcRect.left,
-                          pIRectDest->width(),
-                          pIRectDest->height(),
+                          lpSrcRect->top,
+                          lpSrcRect->left,
+                          RECT_WIDTH(lpDestRect),
+                          RECT_HEIGHT(lpDestRect),
                           src->dwPitchDB,
                           src->dwPitchFB
@@ -2663 +2715 @@
 
       if( (src->pDiveBuffer == dest->pDiveBuffer) &&
-          (pIRectDest->intersects(*pIRectSrc) ) )
+          (intersects(lpDestRect, lpSrcRect) ) )
       {
         // Overlapping rects  on the same surface ?
@@ -2670 +2722 @@
 
         MoveRects( dest->pDiveBuffer,
-                   (LPRECT)&DestRect,
-                   (LPRECT)&SrcRect,
+                   lpDestRect,
+                   lpSrcRect,
                    dest->dwBytesPPDive,
                    dest->dwPitchDB);
@@ -2679 +2731 @@
         {
           MoveRects( dest->pFrameBuffer,
-                     (LPRECT)&DestRect,
-                     (LPRECT)&SrcRect,
+                     lpDestRect,
+                     lpSrcRect,
                      dest->lpDraw->GetScreenBpp()>>3,
                      dest->dwPitchFB);
@@ -2692 +2744 @@
         dest->BltSolid( dest->pDiveBuffer,
                         dest->pFrameBuffer,
-                        DestRect.top,
-                        DestRect.left,
+                        lpDestRect->top,
+                        lpDestRect->left,
                         dest->dwPitchDB,
                         dest->dwPitchFB,
                         src->pDiveBuffer,
                         src->pFrameBuffer,
-                        SrcRect.top,
-                        SrcRect.left,
-                        pIRectDest->width(),
-                        pIRectDest->height(),
+                        lpSrcRect->top,
+                        lpSrcRect->left,
+                        RECT_WIDTH(lpDestRect),
+                        RECT_HEIGHT(lpDestRect),
                         src->dwPitchDB,
                         src->dwPitchFB
@@ -2708 +2760 @@
       else
       {
-        pBltPos = (char*) dest->pDiveBuffer + (DestRect.top * dest->dwPitchDB) +
-                  (DestRect.left * dest->dwBytesPPDive);
-
-        pSrcPos = (char*) src->pDiveBuffer + (SrcRect.top * src->dwPitchDB) +
-                  (SrcRect.left * src->dwBytesPPDive);
-
-        BlitHeight = pIRectDest->height();
-        BlitWidth = pIRectDest->width();
+        pBltPos = (char*) dest->pDiveBuffer + (lpDestRect->top * dest->dwPitchDB) +
+                  (lpDestRect->left * dest->dwBytesPPDive);
+
+        pSrcPos = (char*) src->pDiveBuffer + (lpSrcRect->top * src->dwPitchDB) +
+                  (lpSrcRect->left * src->dwBytesPPDive);
+
+        BlitHeight = RECT_HEIGHT(lpDestRect);
+        BlitWidth  = RECT_WIDTH(lpDestRect);
         DWORD dwPitch = dest->dwPitchDB;
 
@@ -2751 +2803 @@
             dwPitch = -dwPitch;
             pBltPos = (char*) dest->pDiveBuffer +
-                      ((DestRect.top +BlitHeight)* dest->dwPitchDB) +
-                      (DestRect.left * dest->dwBytesPPDive);
+                      ((lpDestRect->top +BlitHeight)* dest->dwPitchDB) +
+                      (lpDestRect->left * dest->dwBytesPPDive);
 
             dwFx &= ~DDBLTFX_MIRRORUPDOWN;  // remove handled flag
@@ -4654 +4706 @@
   }
 
-
   return rc;
 }
@@ -5000 +5051 @@
     Found = (pIRectEnum != NULL);
 #else
-    pIRectUnlock = new DDRectangle( 0, 0, me->height, me->width);
+    pIRectUnlock = new DDRectangle( 0, 0, me->width, me->height);
 
     while(i<DPA_GetPtrCount(me->DPA_LockedRects) && !Found)
@@ -5115 +5166 @@
   {
     dprintf(("DDRAW: Unlock rectangle\n"));
-    pIRectUnlock = new DDRectangle( lpSurfaceRect->top,
-                                    lpSurfaceRect->left,
-                                    lpSurfaceRect->bottom,
-                                    lpSurfaceRect->right);
+    pIRectUnlock = new DDRectangle( lpSurfaceRect->left, lpSurfaceRect->top,
+                                    lpSurfaceRect->right, lpSurfaceRect->bottom);
   }
   else
   {
     dprintf(("DDRAW: Unlock complete surface\n"));
-    pIRectUnlock = new DDRectangle( 0, 0, me->height, me->width);
+    pIRectUnlock = new DDRectangle( 0, 0, me->width, me->height);
   }
 
@@ -5191 +5240 @@
     dprintf(("DDRAW: Unlock OK\n\n"));
     rc = DD_OK;
+
   }