diff --git a/win32ss/gdi/eng/stubs.c b/win32ss/gdi/eng/stubs.c
index 8a91c86ff5..d76ddf5d64 100644
--- a/win32ss/gdi/eng/stubs.c
+++ b/win32ss/gdi/eng/stubs.c
@@ -889,34 +889,6 @@ NtGdiDeleteColorTransform(
     return FALSE;
 }
 
-/*
- * @unimplemented
- */
-ULONG
-APIENTRY
-NtGdiGetPerBandInfo(
-    IN HDC hdc,
-    IN OUT PERBANDINFO *ppbi)
-{
-    UNIMPLEMENTED;
-    return 0;
-}
-
-/*
- * @unimplemented
- */
-BOOL
-APIENTRY
-NtGdiDoBanding(
-    IN HDC hdc,
-    IN BOOL bStart,
-    OUT POINTL *pptl,
-    OUT PSIZE pSize)
-{
-    UNIMPLEMENTED;
-    return FALSE;
-}
-
 /*
  * @unimplemented
  */
diff --git a/win32ss/gdi/ntgdi/dc.h b/win32ss/gdi/ntgdi/dc.h
index b72ea21439..5fad510289 100644
--- a/win32ss/gdi/ntgdi/dc.h
+++ b/win32ss/gdi/ntgdi/dc.h
@@ -53,7 +53,7 @@ typedef struct _DCLEVEL
   PVOID             pColorSpace; /* COLORSPACE* */
   LONG              lIcmMode;
   LONG              lSaveDepth;
-  DWORD             unk1_00000000;
+  LONG              lSaveDepthStartDoc;
   HGDIOBJ           hdcSave;
   POINTL            ptlBrushOrigin;
   PBRUSH            pbrFill;
diff --git a/win32ss/gdi/ntgdi/print.c b/win32ss/gdi/ntgdi/print.c
index 582bfcac1c..ccaa49a9f5 100644
--- a/win32ss/gdi/ntgdi/print.c
+++ b/win32ss/gdi/ntgdi/print.c
@@ -11,278 +11,526 @@
 #define NDEBUG
 #include <debug.h>
 
+/*
+static
+VOID
+DC_Pop_Locks(PDC pdc)
+{
+    GDIOBJ_vUnlockObject(&pdc->BaseObject);
+    PDEVOBJ_vReference(pdc->ppdev);
+    SURFACE_ShareLockByPointer(pdc->dclevel.pSurface);
+}
+
+static
+VOID
+DC_Push_Locks(PDC pdc)
+{
+    SURFACE_ShareUnlockSurface(pdc->dclevel.pSurface);
+    PDEVOBJ_vRelease(pdc->ppdev);
+    GDIOBJ_LockObject(pdc->BaseObject.hHmgr, GDIObjType_DC_TYPE);
+}
+*/
+BOOL
+FASTCALL
+IntEndDoc(
+    HDC  hDC,
+    DWORD doAbort
+)
+{
+    PPDEVOBJ ppdev;
+    PDC pdc;
+    INT Ret = FALSE;
+
+    pdc = DC_LockDc(hDC);
+    if (pdc == NULL)
+    {
+        EngSetLastError(ERROR_INVALID_HANDLE);
+        return FALSE;
+    }
+
+    if ( !pdc->dclevel.pSurface ||
+         !(ppdev = pdc->ppdev)  ||
+          ppdev->flFlags & PDEV_DISPLAY ||
+         !ppdev->hSpooler )
+    {
+        if (pdc) DC_UnlockDc( pdc );
+        EngSetLastError(ERROR_CAN_NOT_COMPLETE);
+        return FALSE;
+    }
+
+    if ( pdc->dclevel.lSaveDepth > pdc->dclevel.lSaveDepthStartDoc )
+    {
+        DC_vRestoreDC( pdc, pdc->dclevel.lSaveDepthStartDoc );
+    }
+
+    if (ppdev->DriverFunctions.EndDoc)
+    {
+        SURFOBJ *pSurfObj = &pdc->dclevel.pSurface->SurfObj;
+
+        Ret = ppdev->DriverFunctions.EndDoc(pSurfObj, doAbort);
+    }
+
+    pdc->dclevel.pSurface = NULL; // This DC has no surface (empty mem or info DC).
+    pdc->ipfdDevMax = -1;
+
+    PDEVOBJ_vRelease(ppdev);
+
+    DC_UnlockDc( pdc );
+    return Ret;
+
+}
+
 INT
 APIENTRY
 NtGdiAbortDoc(HDC  hDC)
 {
-  UNIMPLEMENTED;
-  return 0;
+    return IntEndDoc(hDC, ED_ABORTDOC);
+}
+
+/*
+ * @implemented
+ */
+BOOL
+APIENTRY
+NtGdiDoBanding(
+    IN HDC hdc,
+    IN BOOL bStart,
+    OUT POINTL *pptl,
+    OUT PSIZE pSize)
+{
+    PPDEVOBJ ppdev;
+    PDC pdc;
+    SURFOBJ *pSurfObj;
+    POINTL ptlSafe;
+    SIZEL sizeSafe;
+    INT Ret = FALSE;
+
+    pdc = DC_LockDc(hdc);
+    if ( !pdc                   ||
+         !pdc->dclevel.pSurface ||
+         !(ppdev = pdc->ppdev)  ||
+         !ppdev->hSpooler       ||
+         !(pdc->dclevel.pSurface->flags & BANDING_SURFACE) )
+    {
+        if (pdc) DC_UnlockDc(pdc);
+        return FALSE;
+    }
+
+    pSurfObj = &pdc->dclevel.pSurface->SurfObj;
+
+    if (bStart)
+    {
+        Ret = ppdev->DriverFunctions.StartBanding( pSurfObj, &ptlSafe );
+        sizeSafe.cx = pSurfObj->sizlBitmap.cx;
+        sizeSafe.cy = pSurfObj->sizlBitmap.cy;
+        pdc->ptlDoBanding.x = ptlSafe.x;
+        pdc->ptlDoBanding.y = ptlSafe.y;
+    }
+    else
+    {
+        Ret = ppdev->DriverFunctions.NextBand( pSurfObj, &ptlSafe );
+        if (Ret)
+        {
+            if ( ptlSafe.x == -1 &&          // physical page's bands have been drawn.
+                 ppdev->flFlags & PDEV_UMPD )
+            {
+                pdc->fs &= ~DC_RESET;
+                if (pdc->dclevel.pSurface->pWinObj)
+                {
+                    EngDeleteWnd((WNDOBJ *)pdc->dclevel.pSurface->pWinObj); // See UserGethWnd.
+                    pdc->dclevel.pSurface->pWinObj = NULL;
+                }
+                pdc->ipfdDevMax = 0;
+            }
+            else
+            {
+                pdc->ptlDoBanding.x = ptlSafe.x;
+                pdc->ptlDoBanding.y = ptlSafe.y;
+            }
+        }
+    }
+    if (Ret)
+    {
+        _SEH2_TRY
+        {
+            ProbeForWrite(pptl, sizeof(POINT), 1);
+            *pptl = ptlSafe;
+
+            ProbeForWrite(pSize, sizeof(SIZE), 1);
+            *pSize = sizeSafe;
+        }
+        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+        {
+            Ret = FALSE;
+        }
+        _SEH2_END;
+    }
+    DC_UnlockDc(pdc);
+    return Ret;
 }
 
 INT
 APIENTRY
 NtGdiEndDoc(HDC  hDC)
 {
-  UNIMPLEMENTED;
-  return 0;
+  return IntEndDoc(hDC, 0);
 }
 
 INT
 APIENTRY
 NtGdiEndPage(HDC  hDC)
 {
-  UNIMPLEMENTED;
-  return 0;
+    PPDEVOBJ ppdev;
+    PDC pdc;
+    INT Ret = 0;
+
+    pdc = DC_LockDc(hDC);
+    if (!pdc || !pdc->dclevel.pSurface)
+    {
+        if (pdc) DC_UnlockDc(pdc);
+        EngSetLastError(ERROR_INVALID_HANDLE);
+        return 0;
+    }
+
+    if ( (ppdev = pdc->ppdev) && !(ppdev->flFlags & PDEV_DISPLAY) )
+    {
+        if ( ppdev->flFlags & PDEV_UMPD &&
+             ppdev->hSpooler &&
+             ppdev->DriverFunctions.SendPage)
+        {
+           SURFOBJ *pSurfObj = &pdc->dclevel.pSurface->SurfObj;
+
+           if (ppdev->DriverFunctions.SendPage(pSurfObj))
+           {
+               pdc->fs &= ~DC_RESET;
+               if (pdc->dclevel.pSurface->pWinObj)
+               {
+                  EngDeleteWnd((WNDOBJ *)pdc->dclevel.pSurface->pWinObj); // See UserGethWnd.
+                  pdc->dclevel.pSurface->pWinObj = NULL;
+               }
+               pdc->ipfdDevMax = -1;
+               Ret = 1;
+           }
+        }
+    }
+    DC_UnlockDc(pdc);
+    return Ret;
 }
 
 INT
 FASTCALL
-IntGdiEscape(PDC    dc,
-             INT    Escape,
-             INT    InSize,
-             LPCSTR InData,
-             LPVOID OutData)
+IntExtEscape(
+    PDC    pdc,
+    INT    iEsc,
+    INT    cjIn,
+    LPSTR  pjIn,
+    INT    cjOut,
+    LPSTR  pjOut
+)
 {
-  if (Escape == QUERYESCSUPPORT)
-    return FALSE;
+    INT ret;
+    PPDEVOBJ ppdev;
+    BOOL bQOGLGI = FALSE;
+
+    if ( iEsc == QUERYESCSUPPORT && cjIn < sizeof(ULONG) )
+        return 0;
+
+    if ( iEsc == QUERYESCSUPPORT )
+    {
+         DWORD dwIn = *(PDWORD)pjIn;
 
-  UNIMPLEMENTED;
-  return SP_ERROR;
+         if ( dwIn == OPENGL_GETINFO || dwIn == OPENGL_CMD )
+         {
+             DPRINT1("QUERYESCSUPPORT OPENGL_GETINFO or OPENGL_CMD\n");
+             bQOGLGI = TRUE;
+         }
+    } 
+
+    ppdev = pdc->ppdev;
+
+    if ( !ppdev || !ppdev->DriverFunctions.Escape )
+        return 0;
+
+    // Fix part of CORE-16465.
+    if ( bQOGLGI || iEsc == OPENGL_CMD || iEsc == OPENGL_GETINFO )
+    {
+        if ( pdc->dctype != DCTYPE_DIRECT /*|| ppdev->DxDd_Flags & */ ) // Not Direct or DxDD
+            return 0;
+
+        DPRINT1("OPENGL_GETINFO or OPENGL_CMD\n");
+        ret = ppdev->DriverFunctions.Escape( &pdc->dclevel.pSurface->SurfObj, iEsc, cjIn, pjIn, cjOut, pjOut );
+
+        return ret;
+    }
+
+    if ( iEsc == DCICOMMAND )
+    {
+        return 0;
+    }
+
+    if ( iEsc == WNDOBJ_SETUP )
+    {
+        if ( pdc->dctype != DCTYPE_DIRECT ) return 0;
+
+        ret = ppdev->DriverFunctions.Escape( &pdc->dclevel.pSurface->SurfObj, iEsc, cjIn, pjIn, cjOut, pjOut );
+        // FIXME: Do EWndObj stuff. See eng/engwindow.c.
+        /*if ( gbWndobjUpdate )
+        {
+            gbWndobjUpdate = 0;
+            //Force a Client Region Update
+        }*/
+        return ret;
+    }
+
+    if ( !pdc->dclevel.pSurface && cjIn > sizeof(WORD) )
+    {
+        SURFOBJ sTemp;
+
+        RtlZeroMemory( &sTemp, sizeof(SURFACE) );
+
+        sTemp.hdev = (HDEV)ppdev;
+        sTemp.dhpdev = pdc->dhpdev;
+        sTemp.iType = STYPE_DEVICE;
+
+        switch ( iEsc )
+        {
+            case SETCOPYCOUNT:
+            {
+                pdc->ulCopyCount = (*(PUSHORT)pjIn); // Save copy count in DC
+
+                return ppdev->DriverFunctions.Escape( &sTemp, iEsc, cjIn, pjIn, cjOut, pjOut );
+            }
+
+            case EPSPRINTING:
+            {
+                if ((*(PUSHORT)pjIn))
+                {
+                   pdc->fs |= DC_EPSPRINTINGESCAPE;
+                }
+                else
+                {
+                   pdc->fs &= ~DC_EPSPRINTINGESCAPE;
+                }
+                return 1;
+            }
+
+            default:
+                return 0; // Must have a surface!
+        }
+    }
+
+    // Have a surface. So fall through.
+
+    DPRINT1("ExtEscape Code %d\n",iEsc);
+    DC_vPrepareDCsForBlit(pdc, NULL, NULL, NULL);
+    ret = ppdev->DriverFunctions.Escape( &pdc->dclevel.pSurface->SurfObj, iEsc, cjIn, pjIn, cjOut, pjOut );
+    DC_vFinishBlit(pdc, NULL);
+    return ret;
 }
 
 INT
-APIENTRY
-NtGdiEscape(HDC  hDC,
-            INT  Escape,
-            INT  InSize,
-            LPCSTR  InData,
-            LPVOID  OutData)
+FASTCALL
+IntNameExtEscape(
+    PWCHAR pDriver,
+    INT    iEsc,
+    INT    cjIn,
+    LPSTR  pjIn,
+    INT    cjOut,
+    LPSTR  pjOut
+)
 {
-  PDC dc;
-  INT ret;
-
-  dc = DC_LockDc(hDC);
-  if (dc == NULL)
-  {
-    EngSetLastError(ERROR_INVALID_HANDLE);
-    return SP_ERROR;
-  }
-
-  /* TODO: FIXME: Don't pass umode buffer to an Int function */
-  ret = IntGdiEscape(dc, Escape, InSize, InData, OutData);
-
-  DC_UnlockDc( dc );
-  return ret;
+    PPDEVOBJ ppdev;
+    UNICODE_STRING usDriver;
+    WCHAR awcBuffer[MAX_PATH];
+    RtlInitEmptyUnicodeString(&usDriver, awcBuffer, sizeof(awcBuffer));
+    RtlAppendUnicodeToString(&usDriver, L"\\SystemRoot\\System32\\");
+    RtlAppendUnicodeToString(&usDriver, pDriver);
+
+    ppdev = EngpGetPDEV(&usDriver);
+    if ( ppdev && ppdev->DriverFunctions.Escape )
+    {
+       return ppdev->DriverFunctions.Escape( &ppdev->pSurface->SurfObj, iEsc, cjIn, pjIn, cjOut, pjOut );
+    }
+    return 0;
 }
 
 INT
 APIENTRY
 NtGdiExtEscape(
-   HDC    hDC,
-   IN OPTIONAL PWCHAR pDriver,
-   IN INT nDriver,
-   INT    Escape,
-   INT    InSize,
-   OPTIONAL LPSTR UnsafeInData,
-   INT    OutSize,
-   OPTIONAL LPSTR  UnsafeOutData)
+    _In_opt_ HDC hdc,
+    _In_reads_opt_(cwcDriver) PWCHAR pDriver,
+    _In_ INT cwcDriver,
+    _In_ INT iEsc,
+    _In_ INT cjIn,
+    _In_reads_bytes_opt_(cjIn) LPSTR pjIn,
+    _In_ INT cjOut,
+    _Out_writes_bytes_opt_(cjOut) LPSTR pjOut
+)
 {
-   LPVOID   SafeInData = NULL;
-   LPVOID   SafeOutData = NULL;
-   NTSTATUS Status = STATUS_SUCCESS;
-   INT      Result;
-   PPDEVOBJ ppdev;
-   PSURFACE psurf;
-
-   if (hDC == NULL)
+    PDC pdc;
+    LPSTR SafeInData = NULL;
+    LPSTR SafeOutData = NULL;
+    PWCHAR psafeDriver = NULL;
+    INT Ret = 0;
+
+    if ( pDriver )
+    {
+        psafeDriver = ExAllocatePoolWithTag( PagedPool, (cwcDriver + 1) * sizeof(WCHAR), GDITAG_TEMP );
+        RtlZeroMemory( psafeDriver, (cwcDriver + 1) * sizeof(WCHAR) );
+    }
+
+    if ( cjIn )
+    {
+       SafeInData = ExAllocatePoolWithTag( PagedPool, cjIn + 1, GDITAG_TEMP );
+    }
+
+    if ( cjOut )
+    {
+       SafeOutData = ExAllocatePoolWithTag( PagedPool, cjOut + 1, GDITAG_TEMP );
+    }
+
+    _SEH2_TRY
+    {
+        if ( psafeDriver )
+        {
+            ProbeForRead(pDriver, cwcDriver * sizeof(WCHAR), 1);
+            RtlCopyMemory(psafeDriver, pDriver, cwcDriver * sizeof(WCHAR));
+        }
+        if ( SafeInData )
+        {
+            ProbeForRead(pjIn, cjIn, 1);
+            RtlCopyMemory(SafeInData, pjIn, cjIn);
+        }
+    }
+    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+    {
+        SetLastNtError(_SEH2_GetExceptionCode());
+        _SEH2_YIELD(goto Exit);
+    }
+    _SEH2_END;
+
+
+   if ( pDriver )
    {
-      if (pDriver)
-      {
-         /* FIXME : Get the pdev from its name */
-         UNIMPLEMENTED;
-         return -1;
-      }
-
-      ppdev = EngpGetPDEV(NULL);
-      if (!ppdev)
-      {
-         EngSetLastError(ERROR_BAD_DEVICE);
-         return -1;
-      }
-
-      /* We're using the primary surface of the pdev. Lock it */
-      EngAcquireSemaphore(ppdev->hsemDevLock);
-
-      psurf = ppdev->pSurface;
-      if (!psurf)
-      {
-         EngReleaseSemaphore(ppdev->hsemDevLock);
-         PDEVOBJ_vRelease(ppdev);
-         return 0;
-      }
-      SURFACE_ShareLockByPointer(psurf);
+       Ret = IntNameExtEscape( psafeDriver, iEsc, cjIn, SafeInData, cjOut, SafeOutData );
    }
    else
    {
-      PDC pDC = DC_LockDc(hDC);
-      if ( pDC == NULL )
-      {
-         EngSetLastError(ERROR_INVALID_HANDLE);
-         return -1;
-      }
-
-      /* Get the PDEV from the DC */
-      ppdev = pDC->ppdev;
-      PDEVOBJ_vReference(ppdev);
-
-      /* Check if we have a surface */
-      psurf = pDC->dclevel.pSurface;
-      if (!psurf)
-      {
-         DC_UnlockDc(pDC);
-         PDEVOBJ_vRelease(ppdev);
-         return 0;
-      }
-      SURFACE_ShareLockByPointer(psurf);
-
-      /* We're done with the DC */
-      DC_UnlockDc(pDC);
-   }
-
-   /* See if we actually have a driver function to call */
-   if (ppdev->DriverFunctions.Escape == NULL)
-   {
-      Result = 0;
-      goto Exit;
-   }
-
-   if ( InSize && UnsafeInData )
-   {
-      _SEH2_TRY
-      {
-        ProbeForRead(UnsafeInData,
-                     InSize,
-                     1);
-      }
-      _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
-      {
-        Status = _SEH2_GetExceptionCode();
-      }
-      _SEH2_END;
-
-      if (!NT_SUCCESS(Status))
-      {
-         Result = -1;
-         goto Exit;
-      }
-
-      SafeInData = ExAllocatePoolWithTag ( PagedPool, InSize, GDITAG_TEMP );
-      if ( !SafeInData )
-      {
-         EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
-         Result = -1;
-         goto Exit;
-      }
-
-      _SEH2_TRY
-      {
-        /* Pointers were already probed! */
-        RtlCopyMemory(SafeInData,
-                      UnsafeInData,
-                      InSize);
-      }
-      _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
-      {
-        Status = _SEH2_GetExceptionCode();
-      }
-      _SEH2_END;
-
-      if ( !NT_SUCCESS(Status) )
-      {
-         SetLastNtError(Status);
-         Result = -1;
-         goto Exit;
-      }
-   }
-
-   if ( OutSize && UnsafeOutData )
-   {
-      _SEH2_TRY
-      {
-        ProbeForWrite(UnsafeOutData,
-                      OutSize,
-                      1);
-      }
-      _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
-      {
-        Status = _SEH2_GetExceptionCode();
-      }
-      _SEH2_END;
+       pdc = DC_LockDc(hdc);
+       if ( pdc )
+       {
+           Ret = IntExtEscape( pdc, iEsc, cjIn, SafeInData, cjOut, SafeOutData );
 
-      if (!NT_SUCCESS(Status))
-      {
-         SetLastNtError(Status);
-         Result = -1;
-         goto Exit;
-      }
-
-      SafeOutData = ExAllocatePoolWithTag ( PagedPool, OutSize, GDITAG_TEMP );
-      if ( !SafeOutData )
-      {
-         EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
-         Result = -1;
-         goto Exit;
-      }
-   }
-
-   /* Finally call the driver */
-   Result = ppdev->DriverFunctions.Escape(
-         &psurf->SurfObj,
-         Escape,
-         InSize,
-         SafeInData,
-         OutSize,
-         SafeOutData );
-
-Exit:
-   if (hDC == NULL)
-   {
-      EngReleaseSemaphore(ppdev->hsemDevLock);
+           DC_UnlockDc(pdc);
+       }
    }
-   SURFACE_ShareUnlockSurface(psurf);
-   PDEVOBJ_vRelease(ppdev);
 
-   if ( SafeInData )
+   if ( Ret )
    {
-      ExFreePoolWithTag ( SafeInData ,GDITAG_TEMP );
-   }
-
-   if ( SafeOutData )
-   {
-      if (Result > 0)
+      if ( SafeOutData )
       {
          _SEH2_TRY
          {
-            /* Pointers were already probed! */
-            RtlCopyMemory(UnsafeOutData, SafeOutData, OutSize);
+            ProbeForWrite(pjOut, cjOut, 1);
+            RtlCopyMemory(pjOut, SafeOutData, cjOut);
          }
          _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
          {
-            Status = _SEH2_GetExceptionCode();
+            SetLastNtError(_SEH2_GetExceptionCode());
+            Ret = 0;
          }
          _SEH2_END;
-
-         if ( !NT_SUCCESS(Status) )
-         {
-            SetLastNtError(Status);
-            Result = -1;
-         }
       }
-
-      ExFreePoolWithTag ( SafeOutData, GDITAG_TEMP );
    }
+Exit:
+   if ( psafeDriver ) ExFreePoolWithTag ( psafeDriver, GDITAG_TEMP );
+   if ( SafeInData ) ExFreePoolWithTag ( SafeInData, GDITAG_TEMP );
+   if ( SafeOutData ) ExFreePoolWithTag ( SafeOutData, GDITAG_TEMP );
+
+   return Ret;
+}
+
 
-   return Result;
+INT
+APIENTRY
+IntStartDoc(
+    IN HDC hdc,
+    IN DOCINFOW *pdi,
+    OUT BOOL *pbBanding,
+    IN INT iJob)
+{
+    PPDEVOBJ ppdev;
+    PDC pdc;
+    SURFOBJ *pSurfObj;
+    INT Ret = 0;
+
+    pdc = DC_LockDc(hdc);
+    if ( !pdc                   ||
+          pdc->dclevel.pSurface ||
+          pdc->dctype           ||
+         !(ppdev = pdc->ppdev)  ||
+         !ppdev->hSpooler       ||
+          (ppdev->flFlags & PDEV_DISPLAY) ||
+         !(ppdev->flFlags & PDEV_UMPD) )
+    {
+        if (pdc) DC_UnlockDc(pdc);
+        return FALSE;
+    }
+
+    if ( !(pdc->dclevel.pSurface = PDEVOBJ_pSurface( ppdev )) )
+    {
+        DC_UnlockDc(pdc);
+        return FALSE;
+    }
+
+    if ( pdc->dclevel.pSurface )
+    {
+        pdc->dclevel.sizl.cx = ppdev->pSurface->SurfObj.sizlBitmap.cx;
+        pdc->dclevel.sizl.cy = ppdev->pSurface->SurfObj.sizlBitmap.cy;
+        IntSetDefaultRegion(pdc);
+    }
+
+    pSurfObj = &pdc->dclevel.pSurface->SurfObj;
+
+    *pbBanding = !!(pdc->dclevel.pSurface->flags & BANDING_SURFACE);
+
+    Ret = ppdev->pfn.StartDoc(pSurfObj, (LPWSTR)pdi->lpszDocName, iJob );
+
+    if (  pdc->ulCopyCount != -1 )
+    {
+        ULONG ulCopyCount = pdc->ulCopyCount;
+
+        IntExtEscape( pdc,
+                      SETCOPYCOUNT,
+                      sizeof(ULONG),
+                      (LPSTR)&ulCopyCount,
+                      0,
+                      NULL );
+
+        pdc->ulCopyCount = -1;
+    }
+
+    if ( pdc->fs & DC_EPSPRINTINGESCAPE )
+    {
+        WORD Temp = 1;
+
+        IntExtEscape( pdc,
+                      EPSPRINTING,
+                      sizeof(WORD),
+                      (LPSTR)&Temp,
+                      0,
+                      NULL );
+
+        pdc->fs &= ~DC_EPSPRINTINGESCAPE;
+    }
+
+    if ( Ret )
+    {
+        pdc->dclevel.lSaveDepthStartDoc = pdc->dclevel.lSaveDepth;
+    }
+
+    DC_UnlockDc(pdc);
+    return Ret;
 }
 
 INT
@@ -293,15 +541,199 @@ NtGdiStartDoc(
     OUT BOOL *pbBanding,
     IN INT iJob)
 {
-  UNIMPLEMENTED;
-  return 0;
+   DOCINFOW diSafe;
+   BOOL bBanding;
+   INT size, Ret = 0;
+
+   diSafe.cbSize = 0;
+   diSafe.lpszDocName = NULL;
+   diSafe.lpszOutput = NULL; 
+   diSafe.lpszDatatype = NULL;
+   diSafe.fwType = 0;
+
+   if ( pdi )
+   {
+       _SEH2_TRY
+       {
+           ProbeForRead(pdi, sizeof(DOCINFOW), 1);
+           diSafe.cbSize = pdi->cbSize;
+           diSafe.fwType = pdi->fwType;
+
+           if ( pdi->lpszDocName )
+           {
+               size = (wcslen(pdi->lpszDocName) + 1) * sizeof(WCHAR);
+
+               diSafe.lpszDocName = (LPCWSTR)ExAllocatePoolWithTag(PagedPool, size, GDITAG_TEMP);
+
+               RtlCopyMemory((PVOID)diSafe.lpszDocName, (PVOID)pdi->lpszDocName, size);
+           }
+           if ( pdi->lpszOutput )
+           {
+               size = (wcslen(pdi->lpszOutput) + 1) * sizeof(WCHAR);
+
+               diSafe.lpszOutput = (LPCWSTR)ExAllocatePoolWithTag(PagedPool, size, GDITAG_TEMP);
+
+               RtlCopyMemory((PVOID)diSafe.lpszOutput, (PVOID)pdi->lpszOutput, size);
+           }
+           if ( pdi->lpszDatatype )
+           {
+               size = (wcslen(pdi->lpszDatatype) + 1) * sizeof(WCHAR);
+
+               diSafe.lpszDatatype = (LPCWSTR)ExAllocatePoolWithTag(PagedPool, size, GDITAG_TEMP);
+
+               RtlCopyMemory((PVOID)diSafe.lpszDatatype, (PVOID)pdi->lpszDatatype, size);
+           }
+       }
+       _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+       {
+           SetLastNtError(_SEH2_GetExceptionCode());
+           _SEH2_YIELD(goto Exit);
+       }
+       _SEH2_END;
+   }
+
+   Ret = IntStartDoc( hdc, &diSafe, &bBanding, iJob );
+
+   if (Ret)
+   {
+       _SEH2_TRY
+       {
+           ProbeForWrite(pbBanding, sizeof(BOOL), 1);
+           *pbBanding = bBanding;
+       }
+       _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+       {
+           SetLastNtError(_SEH2_GetExceptionCode());
+           Ret = FALSE;
+       }
+       _SEH2_END;
+  }
+Exit:
+  if ( diSafe.lpszDocName ) ExFreePoolWithTag((PVOID)diSafe.lpszDocName, GDITAG_TEMP);
+
+  if ( diSafe.lpszOutput ) ExFreePoolWithTag((PVOID)diSafe.lpszOutput, GDITAG_TEMP);
+
+  if ( diSafe.lpszDatatype ) ExFreePoolWithTag((PVOID)diSafe.lpszDatatype, GDITAG_TEMP);
+
+  return Ret;
 }
 
 INT
 APIENTRY
-NtGdiStartPage(HDC  hDC)
+NtGdiStartPage(
+    HDC  hDC
+)
 {
-  UNIMPLEMENTED;
-  return 0;
+    PPDEVOBJ ppdev;
+    PDC pdc;
+    INT Ret = 0;
+
+    pdc = DC_LockDc(hDC);
+    if (!pdc || !pdc->dclevel.pSurface)
+    {
+        if (pdc) DC_UnlockDc(pdc);
+        EngSetLastError(ERROR_INVALID_HANDLE);
+        return 0;
+    }
+
+    if ( (ppdev = pdc->ppdev) )
+    {
+        if ( ppdev->flFlags & PDEV_UMPD &&
+             ppdev->hSpooler &&
+             ppdev->DriverFunctions.StartPage )
+        {
+           SURFOBJ *pSurfObj = &pdc->dclevel.pSurface->SurfObj;
+
+           if (ppdev->DriverFunctions.StartPage(pSurfObj))
+           {
+               pdc->fs |= DC_RESET;
+               pdc->ptlDoBanding.x = pdc->ptlDoBanding.y = 0;
+               Ret = 1;
+           }
+           else
+           {
+               DC_UnlockDc(pdc);
+               IntEndDoc(hDC, ED_ABORTDOC);
+               return Ret;
+           }
+        }
+    }
+    DC_UnlockDc(pdc);
+    return Ret;
 }
+
+/*
+ * @implemented
+ */
+ULONG
+APIENTRY
+NtGdiGetPerBandInfo(
+    IN HDC hdc,
+    IN OUT PERBANDINFO *ppbi)
+{
+    PPDEVOBJ ppdev;
+    PDC pdc;
+    PERBANDINFO pbi;
+    INT Ret = DDI_ERROR;
+
+    _SEH2_TRY
+    {
+        ProbeForRead( ppbi, sizeof(PERBANDINFO), 1 );
+        RtlCopyMemory( &pbi, ppbi, sizeof(PERBANDINFO) );
+    }
+    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+    {
+        SetLastNtError(_SEH2_GetExceptionCode());
+        _SEH2_YIELD(return Ret);
+    }
+    _SEH2_END;
+
+    pbi.bRepeatThisBand = FALSE;
+
+    pdc = DC_LockDc(hdc);
+    if (!pdc )
+    {
+        EngSetLastError(ERROR_INVALID_HANDLE);
+        return Ret;
+    }
+
+    if ( pdc->dclevel.pSurface && 
+         (ppdev = pdc->ppdev) )
+    {
+        if ( ppdev->hSpooler &&
+             pdc->dclevel.pSurface->flags & BANDING_SURFACE )
+        {
+            if ( ppdev->DriverFunctions.QueryPerBandInfo )
+            {
+                SURFOBJ *pSurfObj = &pdc->dclevel.pSurface->SurfObj;
+
+                Ret = ppdev->DriverFunctions.QueryPerBandInfo(pSurfObj, &pbi);
+            }
+            else
+            {
+                Ret = 0;
+            }
+        }
+    }
+
+    if ( Ret != DDI_ERROR )
+    {
+        _SEH2_TRY
+        {
+            ProbeForWrite( ppbi, sizeof(PERBANDINFO), 1 );
+            RtlCopyMemory( ppbi, &pbi, sizeof(PERBANDINFO) );
+        }
+        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+        {
+            SetLastNtError(_SEH2_GetExceptionCode());
+        }
+        _SEH2_END;
+    }
+
+    DC_UnlockDc(pdc);
+    return Ret;
+}
+
 /* EOF */
+
+
