xorg: work on offscreen bitmaps

common/xrdp_constants.h

@@ -429,6 +429,7 @@
 #define WND_TYPE_COMBO   7
 #define WND_TYPE_SPECIAL 8
 #define WND_TYPE_LISTBOX 9
+#define WND_TYPE_OFFSCREEN 10
 
 /* button states */
 #define BUTTON_STATE_UP   0

libxrdp/libxrdp.c

@@ -754,3 +754,20 @@ libxrdp_orders_send_brush(struct xrdp_session* session,
                                 width, height, bpp, type, size, data,
                                 cache_id);
 }
+
+/*****************************************************************************/
+int EXPORT_CC
+libxrdp_orders_send_create_os_surface(struct xrdp_session* session, int id,
+                                      int width, int height)
+{
+  return xrdp_orders_send_create_os_surface
+               ((struct xrdp_orders*)(session->orders), id, width, height);
+}
+
+/*****************************************************************************/
+int EXPORT_CC
+libxrdp_orders_send_switch_os_surface(struct xrdp_session* session, int id)
+{
+  return xrdp_orders_send_switch_os_surface
+                     ((struct xrdp_orders*)(session->orders), id);
+}

libxrdp/libxrdpinc.h

@@ -176,5 +176,10 @@ int DEFAULT_CC
 libxrdp_orders_send_brush(struct xrdp_session* session,
                           int width, int height, int bpp, int type,
                           int size, char* data, int cache_id);
+int EXPORT_CC
+libxrdp_orders_send_create_os_surface(struct xrdp_session* session, int id,
+                                      int width, int height);
+int EXPORT_CC
+libxrdp_orders_send_switch_os_surface(struct xrdp_session* session, int id);
 
 #endif

libxrdp/xrdp_orders.c

@@ -1976,7 +1976,7 @@ xrdp_orders_send_create_os_surface(struct xrdp_orders* self, int id,
   int order_flags;
   int cache_id;
 
-  g_writeln("xrdp_orders_send_create_os_surface:");
+  //g_writeln("xrdp_orders_send_create_os_surface:");
   xrdp_orders_check(self, 7);
   self->order_count++;
   order_flags = RDP_ORDER_SECONDARY;
@@ -1997,7 +1997,7 @@ xrdp_orders_send_switch_os_surface(struct xrdp_orders* self, int id)
   int order_flags;
   int cache_id;
 
-  g_writeln("xrdp_orders_send_switch_os_surface:");
+  //g_writeln("xrdp_orders_send_switch_os_surface:");
   xrdp_orders_check(self, 3);
   self->order_count++;
   order_flags = RDP_ORDER_SECONDARY;

xorg/X11R7.6/rdp/rdp.h

@@ -136,6 +136,7 @@ struct _rdpScreenInfoRec
   ClearToBackgroundProcPtr ClearToBackground;
   ScreenWakeupHandlerProcPtr WakeupHandler;
   CompositeProcPtr Composite;
+  GlyphsProcPtr Glyphs;
   /* Backing store procedures */
   RestoreAreasProcPtr RestoreAreas;
 
@@ -292,6 +293,11 @@ void
 rdpComposite(CARD8 op, PicturePtr pSrc, PicturePtr pMask, PicturePtr pDst,
              INT16 xSrc, INT16 ySrc, INT16 xMask, INT16 yMask, INT16 xDst,
              INT16 yDst, CARD16 width, CARD16 height);
+void
+rdpGlyphs(CARD8 op, PicturePtr pSrc, PicturePtr pDst,
+          PictFormatPtr maskFormat,
+          INT16 xSrc, INT16 ySrc, int nlists, GlyphListPtr lists,
+          GlyphPtr* glyphs);
 
 
 /* rdpinput.c */
@@ -378,6 +384,8 @@ rdpup_delete_os_surface(int rdpid);
 void
 rdpup_paint_rect_os(int x, int y, int cx, int cy,
                     int rdpid, int srcx, int srcy);
+void
+rdpup_set_hints(int hints, int mask);
 
 #if defined(X_BYTE_ORDER)
 #  if X_BYTE_ORDER == X_LITTLE_ENDIAN

xorg/X11R7.6/rdp/rdpdraw.c

@@ -68,8 +68,15 @@ extern int g_Bpp; /* from rdpmain.c */
 extern ScreenPtr g_pScreen; /* from rdpmain.c */
 extern Bool g_wrapPixmap; /* from rdpmain.c */
 
+extern int g_con_number; /* in rdpup.c */
+extern int g_connected; /* in rdpup.c */
+
 ColormapPtr g_rdpInstalledColormap;
 
+static int g_pixmap_rdpid = 1;
+int g_pixmap_byte_total = 0;
+int g_pixmap_num_used = 0;
+
 GCFuncs g_rdpGCFuncs =
 {
   rdpValidateGC, rdpChangeGC, rdpCopyGC, rdpDestroyGC, rdpChangeClip,
@@ -395,14 +402,29 @@ rdpCreatePixmap(ScreenPtr pScreen, int width, int height, int depth,
   int org_width;
 
   org_width = width;
+  /* width must be a multiple of 4 in rdp */
   width = (width + 3) & ~3;
   LLOGLN(10, ("rdpCreatePixmap: width %d org_width %d", width, org_width));
   pScreen->CreatePixmap = g_rdpScreen.CreatePixmap;
   rv = pScreen->CreatePixmap(pScreen, width, height, depth, usage_hint);
   priv = GETPIXPRIV(rv);
+  if ((g_rdpScreen.client_info.offscreen_support_level > 0) &&
+      (rv->drawable.depth == g_rdpScreen.depth) &&
+      (org_width > 1) && (height > 1) && g_connected)
+  {
+    priv->allocBytes = width * height * 4;
+    g_pixmap_byte_total += priv->allocBytes;
+    g_pixmap_num_used++;
     priv->status = 1;
-  pScreen->CreatePixmap = rdpCreatePixmap;
+    priv->rdpid = g_pixmap_rdpid;
+    g_pixmap_rdpid++;
+    priv->con_number = g_con_number;
+    rdpup_create_os_surface(priv->rdpid, width, height);
+    LLOGLN(0, ("rdpCreatePixmap: g_pixmap_byte_total %d g_pixmap_num_used %d",
+           g_pixmap_byte_total, g_pixmap_num_used));
+  }
   pScreen->ModifyPixmapHeader(rv, org_width, 0, 0, 0, 0, 0);
+  pScreen->CreatePixmap = rdpCreatePixmap;
   return rv;
 }
 
@@ -414,9 +436,22 @@ rdpDestroyPixmap(PixmapPtr pPixmap)
   ScreenPtr pScreen;
   rdpPixmapRec* priv;
 
-  //ErrorF("rdpDestroyPixmap:\n");
+  LLOGLN(10, ("rdpDestroyPixmap:"));
   priv = GETPIXPRIV(pPixmap);
-  //ErrorF("  refcnt %d\n", pPixmap->refcnt);
+  LLOGLN(10, ("status %d refcnt %d", priv->status, pPixmap->refcnt));
+  if (pPixmap->refcnt < 2)
+  {
+    if (XRDP_IS_OS(priv) && g_connected)
+    {
+      g_pixmap_byte_total -= priv->allocBytes;
+      g_pixmap_num_used--;
+      LLOGLN(0, ("rdpDestroyPixmap: id 0x%x "
+             "rdpid 0x%x g_pixmap_byte_total %d g_pixmap_num_used %d",
+             pPixmap->drawable.id, priv->rdpid,
+             g_pixmap_byte_total, g_pixmap_num_used));
+      rdpup_delete_os_surface(priv->rdpid);
+    }
+  }
   pScreen = pPixmap->drawable.pScreen;
   pScreen->DestroyPixmap = g_rdpScreen.DestroyPixmap;
   rv = pScreen->DestroyPixmap(pPixmap);
@@ -691,15 +726,50 @@ rdpComposite(CARD8 op, PicturePtr pSrc, PicturePtr pMask, PicturePtr pDst,
   DrawablePtr p;
   int j;
   int num_clips;
+  int got_id;
+  WindowPtr pDstWnd;
+  PixmapPtr pDstPixmap;
+  rdpPixmapRec* pDstPriv;
+  struct image_data id;
 
-  DEBUG_OUT_OPS(("in rdpComposite\n"));
+  LLOGLN(10, ("rdpComposite:"));
   ps = GetPictureScreen(g_pScreen);
   ps->Composite = g_rdpScreen.Composite;
   ps->Composite(op, pSrc, pMask, pDst, xSrc, ySrc,
                 xMask, yMask, xDst, yDst, width, height);
+  ps->Composite = rdpComposite;
+
   p = pDst->pDrawable;
+
+  got_id = 0;
+  if (p->type == DRAWABLE_PIXMAP)
+  {
+    pDstPixmap = (PixmapPtr)p;
+    pDstPriv = GETPIXPRIV(pDstPixmap);
+    if (XRDP_IS_OS(pDstPriv))
+    {
+      rdpup_switch_os_surface(pDstPriv->rdpid);
+      rdpup_get_pixmap_image_rect(pDstPixmap, &id);
+      got_id = 1;
+    }
+  }
+  else
+  {
     if (p->type == DRAWABLE_WINDOW)
     {
+      pDstWnd = (WindowPtr)p;
+      if (pDstWnd->viewable)
+      {
+        rdpup_get_screen_image_rect(&id);
+        got_id = 1;
+      }
+    }
+  }
+  if (!got_id)
+  {
+    return;
+  }
+
   if (pDst->clientClipType == CT_REGION)
   {
     box.x1 = p->x + xDst;
@@ -719,7 +789,7 @@ rdpComposite(CARD8 op, PicturePtr pSrc, PicturePtr pMask, PicturePtr pDst,
       for (j = num_clips - 1; j >= 0; j--)
       {
         box = REGION_RECTS(&reg1)[j];
-          rdpup_send_area(0, box.x1, box.y1, box.x2 - box.x1, box.y2 - box.y1);
+        rdpup_send_area(&id, box.x1, box.y1, box.x2 - box.x1, box.y2 - box.y1);
       }
       rdpup_end_update();
     }
@@ -733,9 +803,42 @@ rdpComposite(CARD8 op, PicturePtr pSrc, PicturePtr pMask, PicturePtr pDst,
     box.x2 = box.x1 + width;
     box.y2 = box.y1 + height;
     rdpup_begin_update();
-      rdpup_send_area(0, box.x1, box.y1, box.x2 - box.x1, box.y2 - box.y1);
+    rdpup_send_area(&id, box.x1, box.y1, box.x2 - box.x1, box.y2 - box.y1);
     rdpup_end_update();
   }
+  rdpup_switch_os_surface(-1);
 }
-  ps->Composite = rdpComposite;
+
+/******************************************************************************/
+void
+rdpGlyphs(CARD8 op, PicturePtr pSrc, PicturePtr pDst,
+          PictFormatPtr maskFormat,
+          INT16 xSrc, INT16 ySrc, int nlists, GlyphListPtr lists,
+          GlyphPtr* glyphs)
+{
+  PictureScreenPtr ps;
+  int index;
+
+  LLOGLN(10, ("rdpGlyphs:"));
+  LLOGLN(10, ("rdpGlyphs: nlists %d len %d", nlists, lists->len));
+  if (g_rdpScreen.client_info.jpeg)
+  {
+    rdpup_set_hints(1, 1);
+  }
+  for (index = 0; index < lists->len; index++)
+  {
+    LLOGLN(10, ("  index %d size %d refcnt %d width %d height %d",
+           index, glyphs[index]->size, glyphs[index]->refcnt,
+           glyphs[index]->info.width, glyphs[index]->info.height));
+  }
+  ps = GetPictureScreen(g_pScreen);
+  ps->Glyphs = g_rdpScreen.Glyphs;
+  ps->Glyphs(op, pSrc, pDst, maskFormat, xSrc, ySrc,
+             nlists, lists, glyphs);
+  ps->Glyphs = rdpGlyphs;
+  if (g_rdpScreen.client_info.jpeg)
+  {
+    rdpup_set_hints(0, 1);
+  }
+  LLOGLN(10, ("rdpGlyphs: out"));
 }

xorg/X11R7.6/rdp/rdpmain.c

@@ -361,6 +361,8 @@ rdpScreenInit(int index, ScreenPtr pScreen, int argc, char** argv)
   if (ps)
   {
     g_rdpScreen.Composite = ps->Composite;
+    g_rdpScreen.Glyphs = ps->Glyphs;
+
   }
   pScreen->blackPixel = g_rdpScreen.blackPixel;
   pScreen->whitePixel = g_rdpScreen.whitePixel;
@@ -370,6 +372,7 @@ rdpScreenInit(int index, ScreenPtr pScreen, int argc, char** argv)
   if (ps)
   {
     ps->Composite = rdpComposite;
+    ps->Glyphs = rdpGlyphs;
   }
   pScreen->SaveScreen = rdpSaveScreen;
   /* GC procedures */

xorg/X11R7.6/rdp/rdpup.c

@@ -38,7 +38,8 @@ int g_con_number = 0; /* increments for each connection */
 static int g_listen_sck = 0;
 static int g_sck = 0;
 static int g_sck_closed = 0;
-static int g_connected = 0;
+
+int g_connected = 0;
 
 static int g_dis_listen_sck = 0;
 //static int g_dis_sck = 0;
@@ -65,6 +66,9 @@ extern rdpScreenInfoRec g_rdpScreen; /* from rdpmain.c */
 extern int g_use_uds; /* in rdpmain.c */
 extern char g_uds_data[]; /* in rdpmain.c */
 
+extern int g_pixmap_byte_total; /* in rdpdraw.c */
+extern int g_pixmap_num_used; /* in rdpdraw.c */
+
 /*
 0 GXclear,        0
 1 GXnor,          DPon
@@ -189,6 +193,7 @@ rdpup_send_pending(void)
   {
     DEBUG_OUT_UP(("end %d\n", g_count));
     out_uint16_le(g_out_s, 2);
+    out_uint16_le(g_out_s, 4);
     g_count++;
     s_mark_end(g_out_s);
     rdpup_send_msg(g_out_s);
@@ -202,16 +207,7 @@ rdpup_send_pending(void)
 static CARD32
 rdpDeferredUpdateCallback(OsTimerPtr timer, CARD32 now, pointer arg)
 {
-  if (g_connected && g_begin)
+  rdpup_send_pending();
-  {
-    DEBUG_OUT_UP(("end %d\n", g_count));
-    out_uint16_le(g_out_s, 2);
-    g_count++;
-    s_mark_end(g_out_s);
-    rdpup_send_msg(g_out_s);
-  }
-  g_count = 0;
-  g_begin = 0;
   g_scheduled = 0;
   return 0;
 }
@@ -254,6 +250,8 @@ rdpup_recv(char* data, int len)
         g_tcp_close(g_sck);
         g_sck = 0;
         g_sck_closed = 1;
+        g_pixmap_byte_total = 0;
+        g_pixmap_num_used = 0;
         return 1;
       }
     }
@@ -264,6 +262,8 @@ rdpup_recv(char* data, int len)
       g_tcp_close(g_sck);
       g_sck = 0;
       g_sck_closed = 1;
+      g_pixmap_byte_total = 0;
+      g_pixmap_num_used = 0;
       return 1;
     }
     else
@@ -568,7 +568,7 @@ rdpup_get_pixmap_image_rect(PixmapPtr pPixmap, struct image_data* id)
   id->height = pPixmap->drawable.height;
   id->bpp = g_rdpScreen.rdp_bpp;
   id->Bpp = g_rdpScreen.rdp_Bpp;
-  id->lineBytes = id->width * id->Bpp;
+  id->lineBytes = pPixmap->devKind;
   id->pixels = (char*)(pPixmap->devPrivate.ptr);
 }
 
@@ -1087,11 +1087,13 @@ rdpup_set_cursor(short x, short y, char* cur_data, char* cur_mask)
 int
 rdpup_create_os_surface(int rdpid, int width, int height)
 {
+  LLOGLN(10, ("rdpup_create_os_surface:"));
   if (g_connected)
   {
     DEBUG_OUT_UP(("  rdpup_create_os_surface\n"));
-    rdpup_pre_check(10);
+    rdpup_pre_check(12);
     out_uint16_le(g_out_s, 20);
+    out_uint16_le(g_out_s, 12);
     g_count++;
     out_uint32_le(g_out_s, rdpid);
     out_uint16_le(g_out_s, width);
@@ -1112,15 +1114,19 @@ rdpup_switch_os_surface(int rdpid)
       return 0;
     }
     g_rdpid = rdpid;
-    rdpup_send_pending();
+    rdpup_send_pending(); // TODO: do we need this ?
-    LLOGLN(0, ("rdpup_switch_os_surface: rdpid %d", rdpid));
+    // the protocol allows switch the surface anytime
+
+    LLOGLN(10, ("rdpup_switch_os_surface: rdpid %d", rdpid));
 
     /* switch surface */
     out_uint16_le(g_out_s, 21);
+    out_uint16_le(g_out_s, 8);
     out_uint32_le(g_out_s, rdpid);
 
     /* begin update */
     out_uint16_le(g_out_s, 1);
+    out_uint16_le(g_out_s, 4);
     g_begin = 1;
     g_count = 2;
 
@@ -1132,15 +1138,17 @@ rdpup_switch_os_surface(int rdpid)
 int
 rdpup_delete_os_surface(int rdpid)
 {
+  LLOGLN(10, ("rdpup_delete_os_surface: rdpid %d", rdpid));
   if (g_connected)
   {
-    DEBUG_OUT_UP(("  rdpup_delete_os_surface\n"));
+    LLOGLN(10, ("rdpup_delete_os_surface: rdpid %d", rdpid));
     //if (g_current_surface == rdpid)
     //{
     //  g_current_surface = -1;
     //}
-    rdpup_pre_check(6);
+    rdpup_pre_check(8);
     out_uint16_le(g_out_s, 22);
+    out_uint16_le(g_out_s, 8);
     g_count++;
     out_uint32_le(g_out_s, rdpid);
   }
@@ -1149,7 +1157,7 @@ rdpup_delete_os_surface(int rdpid)
 
 /******************************************************************************/
 static int
-get_single_color(int x, int y, int w, int h)
+get_single_color(struct image_data* id, int x, int y, int w, int h)
 {
   int rv;
   int i;
@@ -1165,8 +1173,8 @@ get_single_color(int x, int y, int w, int h)
   {
     for (i = 0; i < h; i++)
     {
-      i8 = (unsigned char*)(g_rdpScreen.pfbMemory +
+      i8 = (unsigned char*)(id->pixels +
-               ((y + i) * g_rdpScreen.paddedWidthInBytes) + (x * g_Bpp));
+               ((y + i) * id->lineBytes) + (x * g_Bpp));
       if (i == 0)
       {
         p = *i8;
@@ -1185,8 +1193,8 @@ get_single_color(int x, int y, int w, int h)
   {
     for (i = 0; i < h; i++)
     {
-      i16 = (unsigned short*)(g_rdpScreen.pfbMemory +
+      i16 = (unsigned short*)(id->pixels +
-               ((y + i) * g_rdpScreen.paddedWidthInBytes) + (x * g_Bpp));
+               ((y + i) * id->lineBytes) + (x * g_Bpp));
       if (i == 0)
       {
         p = *i16;
@@ -1205,8 +1213,8 @@ get_single_color(int x, int y, int w, int h)
   {
     for (i = 0; i < h; i++)
     {
-      i32 = (unsigned int*)(g_rdpScreen.pfbMemory +
+      i32 = (unsigned int*)(id->pixels +
-               ((y + i) * g_rdpScreen.paddedWidthInBytes) + (x * g_Bpp));
+               ((y + i) * id->lineBytes) + (x * g_Bpp));
       if (i == 0)
       {
         p = *i32;
@@ -1237,12 +1245,20 @@ rdpup_send_area(struct image_data* id, int x, int y, int w, int h)
   int lh;
   int lw;
   int size;
+  struct image_data lid;
 
-  if (x >= g_rdpScreen.width)
+  LLOGLN(10, ("rdpup_send_area: id %p x %d y %d w %d h %d", id, x, y, w, h));
+  if (id == 0)
+  {
+    rdpup_get_screen_image_rect(&lid);
+    id = &lid;
+  }
+
+  if (x >= id->width)
   {
     return;
   }
-  if (y >= g_rdpScreen.height)
+  if (y >= id->height)
   {
     return;
   }
@@ -1264,13 +1280,13 @@ rdpup_send_area(struct image_data* id, int x, int y, int w, int h)
   {
     return;
   }
-  if (x + w > g_rdpScreen.width)
+  if (x + w > id->width)
   {
-    w = g_rdpScreen.width - x;
+    w = id->width - x;
   }
-  if (y + h > g_rdpScreen.height)
+  if (y + h > id->height)
   {
-    h = g_rdpScreen.height - y;
+    h = id->height - y;
   }
   DEBUG_OUT_UP(("%d\n", w * h));
   if (g_connected && g_begin)
@@ -1284,7 +1300,7 @@ rdpup_send_area(struct image_data* id, int x, int y, int w, int h)
       {
         lw = MIN(64, (x + w) - lx);
         lh = MIN(64, (y + h) - ly);
-        single_color = get_single_color(lx, ly, lw, lh);
+        single_color = get_single_color(id, lx, ly, lw, lh);
         if (single_color != -1)
         {
           DEBUG_OUT_UP(("%d sending single color\n", g_count));
@@ -1293,7 +1309,7 @@ rdpup_send_area(struct image_data* id, int x, int y, int w, int h)
         }
         else
         {
-          size = lw * lh * g_rdpScreen.rdp_Bpp + 24;
+          size = lw * lh * id->Bpp + 24;
           rdpup_pre_check(size);
           out_uint16_le(g_out_s, 5);
           out_uint16_le(g_out_s, size);
@@ -1302,13 +1318,13 @@ rdpup_send_area(struct image_data* id, int x, int y, int w, int h)
           out_uint16_le(g_out_s, ly);
           out_uint16_le(g_out_s, lw);
           out_uint16_le(g_out_s, lh);
-          out_uint32_le(g_out_s, lw * lh * g_rdpScreen.rdp_Bpp);
+          out_uint32_le(g_out_s, lw * lh * id->Bpp);
           for (i = 0; i < lh; i++)
           {
-            s = (g_rdpScreen.pfbMemory +
+            s = (id->pixels +
-                  ((ly + i) * g_rdpScreen.paddedWidthInBytes) + (lx * g_Bpp));
+                  ((ly + i) * id->lineBytes) + (lx * g_Bpp));
             convert_pixels(s, g_out_s->p, lw);
-            g_out_s->p += lw * g_rdpScreen.rdp_Bpp;
+            g_out_s->p += lw * id->Bpp;
           }
           out_uint16_le(g_out_s, lw);
           out_uint16_le(g_out_s, lh);
@@ -1329,8 +1345,9 @@ rdpup_paint_rect_os(int x, int y, int cx, int cy,
 {
   if (g_connected)
   {
-    rdpup_pre_check(18);
+    rdpup_pre_check(20);
     out_uint16_le(g_out_s, 23);
+    out_uint16_le(g_out_s, 20);
     g_count++;
     out_uint16_le(g_out_s, x);
     out_uint16_le(g_out_s, y);
@@ -1341,3 +1358,17 @@ rdpup_paint_rect_os(int x, int y, int cx, int cy,
     out_uint16_le(g_out_s, srcy);
   }
 }
+
+/******************************************************************************/
+void
+rdpup_set_hints(int hints, int mask)
+{
+  if (g_connected)
+  {
+    rdpup_pre_check(6);
+    out_uint16_le(g_out_s, 24);
+    g_count++;
+    out_uint32_le(g_out_s, hints);
+    out_uint32_le(g_out_s, mask);
+  }
+}

xrdp/xrdp.h

@@ -64,7 +64,8 @@ int APP_CC
 xrdp_cache_reset(struct xrdp_cache* self,
                  struct xrdp_client_info* client_info);
 int APP_CC
-xrdp_cache_add_bitmap(struct xrdp_cache* self, struct xrdp_bitmap* bitmap);
+xrdp_cache_add_bitmap(struct xrdp_cache* self, struct xrdp_bitmap* bitmap,
+                      int hints);
 int APP_CC
 xrdp_cache_add_palette(struct xrdp_cache* self, int* palette);
 int APP_CC
@@ -422,3 +423,15 @@ int DEFAULT_CC
 server_send_to_channel(struct xrdp_mod* mod, int channel_id,
                        char* data, int data_len,
                        int total_data_len, int flags);
+int DEFAULT_CC
+server_create_os_surface(struct xrdp_mod* mod, int id,
+                         int width, int height);
+int DEFAULT_CC
+server_switch_os_surface(struct xrdp_mod* mod, int id);
+int DEFAULT_CC
+server_delete_os_surface(struct xrdp_mod* mod, int id);
+int DEFAULT_CC
+server_paint_rect_os(struct xrdp_mod* mod, int x, int y, int cx, int cy,
+                     int id, int srcx, int srcy);
+int DEFAULT_CC
+server_set_hints(struct xrdp_mod* mod, int hints, int mask);

xrdp/xrdp_cache.c

@@ -73,6 +73,7 @@ xrdp_cache_delete(struct xrdp_cache* self)
       g_free(self->char_items[i][j].font_item.data);
     }
   }
+  /* free all the off screen bitmaps */
   for (i = 0; i < 2000; i++)
   {
     xrdp_bitmap_delete(self->os_bitmap_items[i].bitmap);
@@ -131,7 +132,8 @@ xrdp_cache_reset(struct xrdp_cache* self,
 /*****************************************************************************/
 /* returns cache id */
 int APP_CC
-xrdp_cache_add_bitmap(struct xrdp_cache* self, struct xrdp_bitmap* bitmap)
+xrdp_cache_add_bitmap(struct xrdp_cache* self, struct xrdp_bitmap* bitmap,
+                      int hints)
 {
   int i = 0;
   int j = 0;

xrdp/xrdp_mm.c

@@ -351,6 +351,11 @@ xrdp_mm_setup_mod1(struct xrdp_mm* self)
       self->mod->server_query_channel = server_query_channel;
       self->mod->server_get_channel_id = server_get_channel_id;
       self->mod->server_send_to_channel = server_send_to_channel;
+      self->mod->server_create_os_surface = server_create_os_surface;
+      self->mod->server_switch_os_surface = server_switch_os_surface;
+      self->mod->server_delete_os_surface = server_delete_os_surface;
+      self->mod->server_paint_rect_os = server_paint_rect_os;
+      self->mod->server_set_hints = server_set_hints;
     }
   }
   /* id self->mod is null, there must be a problem */
@@ -1223,7 +1228,7 @@ server_fill_rect(struct xrdp_mod* mod, int x, int y, int cx, int cy)
     return 0;
   }
   wm = (struct xrdp_wm*)(mod->wm);
-  xrdp_painter_fill_rect(p, wm->screen, x, y, cx, cy);
+  xrdp_painter_fill_rect(p, wm->target_surface, x, y, cx, cy);
   return 0;
 }
 
@@ -1242,7 +1247,7 @@ server_screen_blt(struct xrdp_mod* mod, int x, int y, int cx, int cy,
   }
   wm = (struct xrdp_wm*)(mod->wm);
   p->rop = 0xcc;
-  xrdp_painter_copy(p, wm->screen, wm->screen, x, y, cx, cy, srcx, srcy);
+  xrdp_painter_copy(p, wm->screen, wm->target_surface, x, y, cx, cy, srcx, srcy);
   return 0;
 }
 
@@ -1262,7 +1267,7 @@ server_paint_rect(struct xrdp_mod* mod, int x, int y, int cx, int cy,
   }
   wm = (struct xrdp_wm*)(mod->wm);
   b = xrdp_bitmap_create_with_data(width, height, wm->screen->bpp, data, wm);
-  xrdp_painter_copy(p, b, wm->screen, x, y, cx, cy, srcx, srcy);
+  xrdp_painter_copy(p, b, wm->target_surface, x, y, cx, cy, srcx, srcy);
   xrdp_bitmap_delete(b);
   return 0;
 }
@@ -1453,7 +1458,7 @@ server_draw_line(struct xrdp_mod* mod, int x1, int y1, int x2, int y2)
     return 0;
   }
   wm = (struct xrdp_wm*)(mod->wm);
-  return xrdp_painter_line(p, wm->screen, x1, y1, x2, y2);
+  return xrdp_painter_line(p, wm->target_surface, x1, y1, x2, y2);
 }
 
 /*****************************************************************************/
@@ -1492,7 +1497,7 @@ server_draw_text(struct xrdp_mod* mod, int font,
     return 0;
   }
   wm = (struct xrdp_wm*)(mod->wm);
-  return xrdp_painter_draw_text2(p, wm->screen, font, flags,
+  return xrdp_painter_draw_text2(p, wm->target_surface, font, flags,
                                  mixmode, clip_left, clip_top,
                                  clip_right, clip_bottom,
                                  box_left, box_top,
@@ -1586,3 +1591,126 @@ server_send_to_channel(struct xrdp_mod* mod, int channel_id,
   return libxrdp_send_to_channel(wm->session, channel_id, data, data_len,
                                  total_data_len, flags);
 }
+
+/*****************************************************************************/
+int DEFAULT_CC
+server_create_os_surface(struct xrdp_mod* mod, int id,
+                         int width, int height)
+{
+  struct xrdp_wm* wm;
+  struct xrdp_bitmap* bitmap;
+  int index;
+
+  //g_writeln("server_create_os_surface: id 0x%x, width %d height %d",
+  //          id, width, height);
+  wm = (struct xrdp_wm*)(mod->wm);
+  bitmap = xrdp_bitmap_create(width, height, wm->screen->bpp,
+                              WND_TYPE_OFFSCREEN, wm);
+  bitmap->id = id;
+  index = xrdp_cache_add_os_bitmap(wm->cache, bitmap, id);
+  if (index < 0)
+  {
+    g_writeln("server_create_os_surface: xrdp_cache_add_os_bitmap failed");
+    return 1;
+  }
+  bitmap->item_index = index;
+  return 0;
+}
+
+/*****************************************************************************/
+int DEFAULT_CC
+server_switch_os_surface(struct xrdp_mod* mod, int id)
+{
+  struct xrdp_wm* wm;
+  struct xrdp_os_bitmap_item* bi;
+
+  //g_writeln("server_switch_os_surface: id 0x%x", id);
+  wm = (struct xrdp_wm*)(mod->wm);
+  if (id == -1)
+  {
+    //g_writeln("server_switch_os_surface: setting target_surface to screen");
+    wm->target_surface = wm->screen;
+    return 0;
+  }
+  bi = xrdp_cache_get_os_bitmap(wm->cache, id);
+  if (bi != 0)
+  {
+    //g_writeln("server_switch_os_surface: setting target_surface to rdpid %d", id);
+    wm->target_surface = bi->bitmap;
+  }
+  else
+  {
+    g_writeln("server_switch_os_surface: error finding id 0x%x", id);
+  }
+  return 0;
+}
+
+/*****************************************************************************/
+int DEFAULT_CC
+server_delete_os_surface(struct xrdp_mod* mod, int id)
+{
+  struct xrdp_wm* wm;
+
+  //g_writeln("server_delete_os_surface: id 0x%x", id);
+  wm = (struct xrdp_wm*)(mod->wm);
+  if (wm->target_surface->type == WND_TYPE_OFFSCREEN)
+  {
+    if (wm->target_surface->id == id)
+    {
+      g_writeln("server_delete_os_surface: setting target_surface to screen");
+      wm->target_surface = wm->screen;
+    }
+  }
+  xrdp_cache_remove_os_bitmap(wm->cache, id);
+  return 0;
+}
+
+/*****************************************************************************/
+int DEFAULT_CC
+server_paint_rect_os(struct xrdp_mod* mod, int x, int y, int cx, int cy,
+                     int id, int srcx, int srcy)
+{
+  struct xrdp_wm* wm;
+  struct xrdp_bitmap* b;
+  struct xrdp_painter* p;
+  struct xrdp_os_bitmap_item* bi;
+
+  p = (struct xrdp_painter*)(mod->painter);
+  if (p == 0)
+  {
+    return 0;
+  }
+  wm = (struct xrdp_wm*)(mod->wm);
+  bi = xrdp_cache_get_os_bitmap(wm->cache, id);
+  if (bi != 0)
+  {
+    b = bi->bitmap;
+    xrdp_painter_copy(p, b, wm->target_surface, x, y, cx, cy, srcx, srcy);
+  }
+  else
+  {
+    g_writeln("server_paint_rect_os: error finding id 0x%x", id);
+  }
+  return 0;
+}
+
+/*****************************************************************************/
+int DEFAULT_CC
+server_set_hints(struct xrdp_mod* mod, int hints, int mask)
+{
+  struct xrdp_wm* wm;
+
+  wm = (struct xrdp_wm*)(mod->wm);
+  if (mask & 1)
+  {
+    if (hints & 1)
+    {
+      wm->hints |= 1;
+    }
+    else
+    {
+      wm->hints &= ~1;
+    }
+  }
+  return 0;
+}

xrdp/xrdp_painter.c

@@ -14,7 +14,7 @@
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
    xrdp: A Remote Desktop Protocol server.
-   Copyright (C) Jay Sorg 2004-2010
+   Copyright (C) Jay Sorg 2004-2012
 
    painter, gc
 
@@ -51,11 +51,42 @@ xrdp_painter_delete(struct xrdp_painter* self)
 int APP_CC
 xrdp_painter_begin_update(struct xrdp_painter* self)
 {
+  int surface_index;
+
   if (self == 0)
   {
     return 0;
   }
   libxrdp_orders_init(self->session);
+
+  if (self->wm->target_surface->type == WND_TYPE_SCREEN)
+  {
+    if (self->wm->current_surface_index != 0xffff)
+    {
+      libxrdp_orders_send_switch_os_surface(self->session, 0xffff);
+      self->wm->current_surface_index = 0xffff;
+    }
+  }
+  else if (self->wm->target_surface->type == WND_TYPE_OFFSCREEN)
+  {
+    surface_index = self->wm->target_surface->item_index;
+    if (surface_index != self->wm->current_surface_index)
+    {
+      if (self->wm->target_surface->tab_stop == 0) /* tab_stop is hack */
+      {
+        libxrdp_orders_send_create_os_surface(self->session, surface_index,
+                                              self->wm->target_surface->width,
+                                              self->wm->target_surface->height);
+        self->wm->target_surface->tab_stop = 1;
+      }
+      libxrdp_orders_send_switch_os_surface(self->session, surface_index);
+      self->wm->current_surface_index = surface_index;
+    }
+  }
+  else
+  {
+    g_writeln("xrdp_painter_begin_update: bad target_surface");
+  }
   return 0;
 }
 
@@ -271,7 +302,7 @@ xrdp_painter_setup_brush(struct xrdp_painter* self,
 /* fill in an area of the screen with one color */
 int APP_CC
 xrdp_painter_fill_rect(struct xrdp_painter* self,
-                       struct xrdp_bitmap* bitmap,
+                       struct xrdp_bitmap* dst,
                        int x, int y, int cx, int cy)
 {
   struct xrdp_rect clip_rect;
@@ -291,14 +322,21 @@ xrdp_painter_fill_rect(struct xrdp_painter* self,
 
   /* todo data */
 
-  if (bitmap->type == WND_TYPE_BITMAP) /* 0 */
+  if (dst->type == WND_TYPE_BITMAP) /* 0 */
   {
     return 0;
   }
-  xrdp_bitmap_get_screen_clip(bitmap, self, &clip_rect, &dx, &dy);
+  xrdp_bitmap_get_screen_clip(dst, self, &clip_rect, &dx, &dy);
   region = xrdp_region_create(self->wm);
-  xrdp_wm_get_vis_region(self->wm, bitmap, x, y, cx, cy, region,
+  if (dst->type != WND_TYPE_OFFSCREEN)
+  {
+    xrdp_wm_get_vis_region(self->wm, dst, x, y, cx, cy, region,
                            self->clip_children);
+  }
+  else
+  {
+    xrdp_region_add_rect(region, &clip_rect);
+  }
   x += dx;
   y += dy;
   if (self->mix_mode == 0 && self->rop == 0xcc)
@@ -372,7 +410,7 @@ xrdp_painter_fill_rect(struct xrdp_painter* self,
 /*****************************************************************************/
 int APP_CC
 xrdp_painter_draw_text(struct xrdp_painter* self,
-                       struct xrdp_bitmap* bitmap,
+                       struct xrdp_bitmap* dst,
                        int x, int y, const char* text)
 {
   int i;
@@ -409,7 +447,7 @@ xrdp_painter_draw_text(struct xrdp_painter* self,
 
   /* todo data */
 
-  if (bitmap->type == 0)
+  if (dst->type == 0)
   {
     return 0;
   }
@@ -439,10 +477,17 @@ xrdp_painter_draw_text(struct xrdp_painter* self,
     total_width += k;
     total_height = MAX(total_height, font_item->height);
   }
-  xrdp_bitmap_get_screen_clip(bitmap, self, &clip_rect, &dx, &dy);
+  xrdp_bitmap_get_screen_clip(dst, self, &clip_rect, &dx, &dy);
   region = xrdp_region_create(self->wm);
-  xrdp_wm_get_vis_region(self->wm, bitmap, x, y, total_width, total_height,
+  if (dst->type != WND_TYPE_OFFSCREEN)
+  {
+    xrdp_wm_get_vis_region(self->wm, dst, x, y, total_width, total_height,
                            region, self->clip_children);
+  }
+  else
+  {
+    xrdp_region_add_rect(region, &clip_rect);
+  }
   x += dx;
   y += dy;
   k = 0;
@@ -470,7 +515,7 @@ xrdp_painter_draw_text(struct xrdp_painter* self,
 /*****************************************************************************/
 int APP_CC
 xrdp_painter_draw_text2(struct xrdp_painter* self,
-                        struct xrdp_bitmap* bitmap,
+                        struct xrdp_bitmap* dst,
                         int font, int flags, int mixmode,
                         int clip_left, int clip_top,
                         int clip_right, int clip_bottom,
@@ -493,24 +538,32 @@ xrdp_painter_draw_text2(struct xrdp_painter* self,
 
   /* todo data */
 
-  if (bitmap->type == WND_TYPE_BITMAP)
+  if (dst->type == WND_TYPE_BITMAP)
   {
     return 0;
   }
-  xrdp_bitmap_get_screen_clip(bitmap, self, &clip_rect, &dx, &dy);
+  xrdp_bitmap_get_screen_clip(dst, self, &clip_rect, &dx, &dy);
   region = xrdp_region_create(self->wm);
+  if (dst->type != WND_TYPE_OFFSCREEN)
+  {
     if (box_right - box_left > 1)
     {
-    xrdp_wm_get_vis_region(self->wm, bitmap, box_left, box_top,
+      xrdp_wm_get_vis_region(self->wm, dst, box_left, box_top,
                             box_right - box_left, box_bottom - box_top,
                             region, self->clip_children);
     }
     else
     {
-    xrdp_wm_get_vis_region(self->wm, bitmap, clip_left, clip_top,
+      xrdp_wm_get_vis_region(self->wm, dst, clip_left, clip_top,
                             clip_right - clip_left, clip_bottom - clip_top,
                             region, self->clip_children);
     }
+  }
+  else
+  {
+    xrdp_region_add_rect(region, &clip_rect);
+  }
+
   clip_left += dx;
   clip_top += dy;
   clip_right += dx;
@@ -577,12 +630,19 @@ xrdp_painter_copy(struct xrdp_painter* self,
   {
     return 0;
   }
-  if (src == dst && src->wm->screen == src)
+  if (src->type == WND_TYPE_SCREEN)
   {
     xrdp_bitmap_get_screen_clip(dst, self, &clip_rect, &dx, &dy);
     region = xrdp_region_create(self->wm);
+    if (dst->type != WND_TYPE_OFFSCREEN)
+    {
       xrdp_wm_get_vis_region(self->wm, dst, x, y, cx, cy,
                              region, self->clip_children);
+    }
+    else
+    {
+      xrdp_region_add_rect(region, &clip_rect);
+    }
     x += dx;
     y += dy;
     srcx += dx;
@@ -599,13 +659,61 @@ xrdp_painter_copy(struct xrdp_painter* self,
     }
     xrdp_region_delete(region);
   }
+  else if (src->type == WND_TYPE_OFFSCREEN)
+  {
+    //g_writeln("xrdp_painter_copy: todo");
+
+    xrdp_bitmap_get_screen_clip(dst, self, &clip_rect, &dx, &dy);
+    region = xrdp_region_create(self->wm);
+    if (dst->type != WND_TYPE_OFFSCREEN)
+    {
+      g_writeln("off screen to screen");
+      xrdp_wm_get_vis_region(self->wm, dst, x, y, cx, cy,
+                             region, self->clip_children);
+    }
+    else
+    {
+      g_writeln("off screen to off screen");
+      xrdp_region_add_rect(region, &clip_rect);
+    }
+    x += dx;
+    y += dy;
+
+    palette_id = 0;
+    cache_id = 255; // todo
+    cache_idx = src->item_index; // todo
+
+    k = 0;
+    while (xrdp_region_get_rect(region, k, &rect1) == 0)
+    {
+      if (rect_intersect(&rect1, &clip_rect, &rect2))
+      {
+        MAKERECT(rect1, x, y, cx, cy);
+        if (rect_intersect(&rect2, &rect1, &draw_rect))
+        {
+          libxrdp_orders_mem_blt(self->session, cache_id, palette_id,
+                                 x, y, cx, cy, self->rop, srcx, srcy,
+                                 cache_idx, &draw_rect);
+        }
+      }
+      k++;
+    }
+    xrdp_region_delete(region);
+  }
   else if (src->data != 0)
   /* todo, the non bitmap cache part is gone, it should be put back */
   {
     xrdp_bitmap_get_screen_clip(dst, self, &clip_rect, &dx, &dy);
     region = xrdp_region_create(self->wm);
+    if (dst->type != WND_TYPE_OFFSCREEN)
+    {
       xrdp_wm_get_vis_region(self->wm, dst, x, y, cx, cy,
                              region, self->clip_children);
+    }
+    else
+    {
+      xrdp_region_add_rect(region, &clip_rect);
+    }
     x += dx;
     y += dy;
     palette_id = 0;
@@ -615,11 +723,11 @@ xrdp_painter_copy(struct xrdp_painter* self,
       i = srcx;
       while (i < (srcx + cx))
       {
-        w = MIN(64, (srcx + cx) - i);
+        w = MIN(64, ((srcx + cx) - i));
-        h = MIN(64, (srcy + cy) - j);
+        h = MIN(64, ((srcy + cy) - j));
         b = xrdp_bitmap_create(w, h, self->wm->screen->bpp, 0, self->wm);
         xrdp_bitmap_copy_box_with_crc(src, b, i, j, w, h);
-        bitmap_id = xrdp_cache_add_bitmap(self->wm->cache, b);
+        bitmap_id = xrdp_cache_add_bitmap(self->wm->cache, b, self->wm->hints);
         cache_id = HIWORD(bitmap_id);
         cache_idx = LOWORD(bitmap_id);
         dstx = (x + i) - srcx;
@@ -651,7 +759,7 @@ xrdp_painter_copy(struct xrdp_painter* self,
 /*****************************************************************************/
 int APP_CC
 xrdp_painter_line(struct xrdp_painter* self,
-                  struct xrdp_bitmap* bitmap,
+                  struct xrdp_bitmap* dst,
                   int x1, int y1, int x2, int y2)
 {
   struct xrdp_rect clip_rect;
@@ -670,15 +778,22 @@ xrdp_painter_line(struct xrdp_painter* self,
 
   /* todo data */
 
-  if (bitmap->type == WND_TYPE_BITMAP)
+  if (dst->type == WND_TYPE_BITMAP)
   {
     return 0;
   }
-  xrdp_bitmap_get_screen_clip(bitmap, self, &clip_rect, &dx, &dy);
+  xrdp_bitmap_get_screen_clip(dst, self, &clip_rect, &dx, &dy);
   region = xrdp_region_create(self->wm);
-  xrdp_wm_get_vis_region(self->wm, bitmap, MIN(x1, x2), MIN(y1, y2),
+  if (dst->type != WND_TYPE_OFFSCREEN)
+  {
+    xrdp_wm_get_vis_region(self->wm, dst, MIN(x1, x2), MIN(y1, y2),
                            g_abs(x1 - x2) + 1, g_abs(y1 - y2) + 1,
                            region, self->clip_children);
+  }
+  else
+  {
+    xrdp_region_add_rect(region, &clip_rect);
+  }
   x1 += dx;
   y1 += dy;
   x2 += dx;

xrdp/xrdp_types.h

@@ -80,7 +80,15 @@ struct xrdp_mod
                                 char* data, int data_len,
                                 int total_data_len, int flags);
   int (*server_bell_trigger)(struct xrdp_mod* v);
-  long server_dumby[100 - 25]; /* align, 100 minus the number of server
+  int (*server_create_os_surface)(struct xrdp_mod* v, int id,
+                                  int width, int height);
+  int (*server_switch_os_surface)(struct xrdp_mod* v, int id);
+  int (*server_delete_os_surface)(struct xrdp_mod* v, int id);
+  int (*server_paint_rect_os)(struct xrdp_mod* mod, int x, int y,
+                              int cx, int cy,
+                              int id, int srcx, int srcy);
+  int (*server_set_hints)(struct xrdp_mod* mod, int hints, int mask);
+  long server_dumby[100 - 30]; /* align, 100 minus the number of server
                                   functions above */
   /* common */
   long handle; /* pointer to self as int */
@@ -274,6 +282,9 @@ struct xrdp_wm
   struct xrdp_font* default_font;
   struct xrdp_keymap keymap;
   int hide_log_window;
+  struct xrdp_bitmap* target_surface; /* either screen or os surface */
+  int current_surface_index;
+  int hints;
 };
 
 /* rdp process */

xrdp/xrdp_wm.c

@@ -56,6 +56,8 @@ xrdp_wm_create(struct xrdp_process* owner,
   /* this will use built in keymap or load from file */
   get_keymaps(self->session->client_info->keylayout, &(self->keymap));
   xrdp_wm_set_login_mode(self, 0);
+  self->target_surface = self->screen;
+  self->current_surface_index = 0xffff; /* screen */
   return self;
 }
 

xup/xup.c

@@ -377,6 +377,9 @@ lib_mod_process_orders(struct mod* mod, int type, struct stream* s)
   int y1;
   int x2;
   int y2;
+  int rdpid;
+  int hints;
+  int mask;
   int width;
   int height;
   int fgcolor;
@@ -462,6 +465,36 @@ lib_mod_process_orders(struct mod* mod, int type, struct stream* s)
       in_uint8a(s, cur_mask, 32 * (32 / 8));
       rv = mod->server_set_cursor(mod, x, y, cur_data, cur_mask);
       break;
+    case 20:
+      in_uint32_le(s, rdpid);
+      in_uint16_le(s, width);
+      in_uint16_le(s, height);
+      rv = mod->server_create_os_surface(mod, rdpid, width, height);
+      break;
+    case 21:
+      in_uint32_le(s, rdpid);
+      rv = mod->server_switch_os_surface(mod, rdpid);
+      break;
+    case 22:
+      in_uint32_le(s, rdpid);
+      rv = mod->server_delete_os_surface(mod, rdpid);
+      break;
+    case 23: /* server_paint_rect_os */
+      in_sint16_le(s, x);
+      in_sint16_le(s, y);
+      in_uint16_le(s, cx);
+      in_uint16_le(s, cy);
+      in_uint32_le(s, rdpid);
+      in_sint16_le(s, srcx);
+      in_sint16_le(s, srcy);
+      rv = mod->server_paint_rect_os(mod, x, y, cx, cy,
+                                     rdpid, srcx, srcy);
+      break;
+    case 24: /* server_set_hints */
+      in_uint32_le(s, hints);
+      in_uint32_le(s, mask);
+      rv = mod->server_set_hints(mod, hints, mask);
+      break;
     default:
       g_writeln("lib_mod_process_orders: unknown order type %d", type);
       rv = 0;

xup/xup.h

@@ -88,7 +88,15 @@ struct mod
                                 char* data, int data_len,
                                 int total_data_len, int flags);
   int (*server_bell_trigger)(struct mod* v);
-  tbus server_dumby[100 - 25]; /* align, 100 minus the number of server
+  int (*server_create_os_surface)(struct mod* v, int id,
+                                  int width, int height);
+  int (*server_switch_os_surface)(struct mod* v, int id);
+  int (*server_delete_os_surface)(struct mod* v, int id);
+  int (*server_paint_rect_os)(struct mod* v, int x, int y,
+                              int cx, int cy,
+                              int id, int srcx, int srcy);
+  int (*server_set_hints)(struct mod* v, int hints, int mask);
+  tbus server_dumby[100 - 30]; /* align, 100 minus the number of server
                                   functions above */
   /* common */
   tbus handle; /* pointer to self as long */