added Xserver files

1 files changed, 528 insertions, 0 deletions

diff --git a/Xserver/hw/rdp/rdpmain.c b/Xserver/hw/rdp/rdpmain.c
new file mode 100644
index 00000000..b3a0491f
--- /dev/null
+++ b/Xserver/hw/rdp/rdpmain.c
@@ -0,0 +1,528 @@
+/*
+Copyright 2005-2006 Jay Sorg
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+This is the main file called from main.c
+Sets up the  functions
+
+*/
+
+#include "rdp.h"
+
+rdpScreenInfo g_rdpScreen; /* the one screen */
+ScreenPtr g_pScreen = 0;
+int g_rdpGCIndex = -1;
+int g_firstTime = 1;
+
+/* set all these at once, use function set_bpp */
+/* only allow 8 and 16 bpp for not, adding 32 later */
+int g_bpp = 16;
+int g_Bpp = 2;
+int g_Bpp_mask = 0xffff;
+static int g_redBits = 5;
+static int g_greenBits = 6;
+static int g_blueBits = 5;
+
+extern int monitorResolution;
+extern int defaultColorVisualClass;
+extern char* display;
+
+/*static HWEventQueueType alwaysCheckForInput[2] = { 0, 1 };
+static HWEventQueueType* mieqCheckForInput[2];*/
+
+static int g_initOutputCalled = 0;
+
+/******************************************************************************/
+/* returns error, zero is good */
+static int
+set_bpp(int bpp)
+{
+  int rv;
+
+  rv = 0;
+  g_bpp = bpp;
+  if (g_bpp == 8)
+  {
+    g_Bpp = 1;
+    g_Bpp_mask = 0xff;
+    g_redBits = 3;
+    g_greenBits = 3;
+    g_blueBits = 2;
+  }
+  else if (g_bpp == 16)
+  {
+    g_Bpp = 2;
+    g_Bpp_mask = 0xffff;
+    g_redBits = 5;
+    g_greenBits = 6;
+    g_blueBits = 5;
+  }
+  else if (g_bpp == 32)
+  {
+    g_Bpp = 4;
+    g_Bpp_mask = 0xffffff;
+    g_redBits = 8;
+    g_greenBits = 8;
+    g_blueBits = 8;
+  }
+  else
+  {
+    rv = 1;
+  }
+  return rv;
+}
+
+/******************************************************************************/
+/* these are in rdpkbptr.c */
+static miPointerSpriteFuncRec rdpSpritePointerFuncs =
+{
+  rdpSpriteRealizeCursor,
+  rdpSpriteUnrealizeCursor,
+  rdpSpriteSetCursor,
+  rdpSpriteMoveCursor,
+};
+
+/******************************************************************************/
+/* these are in rdpkbptr.c */
+static miPointerScreenFuncRec rdpPointerCursorFuncs =
+{
+  rdpCursorOffScreen,
+  rdpCrossScreen,
+  miPointerWarpCursor /* don't need to set last 2 funcs
+                         EnqueueEvent and NewEventScreen */
+};
+
+/******************************************************************************/
+static void
+rdpWakeupHandler(int i, pointer blockData, unsigned long err,
+                 pointer pReadmask)
+{
+  int e;
+
+  /*ErrorF("rdpWakeupHandler %d\n", err);*/
+  e = (int)err;
+  if (e < 0)
+  {
+    g_pScreen->WakeupHandler = g_rdpScreen.WakeupHandler;
+    g_pScreen->WakeupHandler(i, blockData, err, pReadmask);
+    g_pScreen->WakeupHandler = rdpWakeupHandler;
+    return;
+  }
+  rdpup_check();
+  g_pScreen->WakeupHandler = g_rdpScreen.WakeupHandler;
+  g_pScreen->WakeupHandler(i, blockData, err, pReadmask);
+  g_pScreen->WakeupHandler = rdpWakeupHandler;
+}
+
+/******************************************************************************/
+/* returns boolean, true if everything is ok */
+static Bool
+rdpScreenInit(int index, ScreenPtr pScreen, int argc, char** argv)
+{
+  int dpix;
+  int dpiy;
+  int ret;
+  VisualPtr vis;
+  PictureScreenPtr ps;
+
+  g_pScreen = pScreen;
+
+  /*ErrorF("hi rdpScreenInit\n");*/
+  /*dpix = 75;
+  dpiy = 75;*/
+  dpix = 100;
+  dpiy = 100;
+  if (monitorResolution != 0)
+  {
+    dpix = monitorResolution;
+    dpiy = monitorResolution;
+  }
+  g_rdpScreen.paddedWidthInBytes = PixmapBytePad(g_rdpScreen.width,
+                                                 g_rdpScreen.depth);
+  g_rdpScreen.bitsPerPixel = rdpBitsPerPixel(g_rdpScreen.depth);
+  ErrorF("screen width %d height %d depth %d bpp %d\n", g_rdpScreen.width,
+         g_rdpScreen.height, g_rdpScreen.depth, g_rdpScreen.bitsPerPixel);
+  ErrorF("dpix %d dpiy %d\n", dpix, dpiy);
+  if (g_rdpScreen.pfbMemory == 0)
+  {
+    g_rdpScreen.sizeInBytes =
+           (g_rdpScreen.paddedWidthInBytes * g_rdpScreen.height);
+    ErrorF("buffer size %d\n", g_rdpScreen.sizeInBytes);
+    g_rdpScreen.pfbMemory = (char*)Xalloc(g_rdpScreen.sizeInBytes);
+    memset(g_rdpScreen.pfbMemory, 0, g_rdpScreen.sizeInBytes);
+  }
+  if (g_rdpScreen.pfbMemory == 0)
+  {
+    return 0;
+  }
+  miClearVisualTypes();
+  if (defaultColorVisualClass == -1)
+  {
+    defaultColorVisualClass = TrueColor;
+  }
+  if (!miSetVisualTypes(g_rdpScreen.depth,
+                         miGetDefaultVisualMask(g_rdpScreen.depth),
+                         8, defaultColorVisualClass))
+  {
+    return 0;
+  }
+  miSetPixmapDepths();
+  switch (g_rdpScreen.bitsPerPixel)
+  {
+    case 8:
+      ret = fbScreenInit(pScreen, g_rdpScreen.pfbMemory,
+                          g_rdpScreen.width, g_rdpScreen.height,
+                          dpix, dpiy, g_rdpScreen.paddedWidthInBytes);
+      break;
+    case 16:
+      ret = fbScreenInit(pScreen, g_rdpScreen.pfbMemory,
+                          g_rdpScreen.width, g_rdpScreen.height,
+                          dpix, dpiy, g_rdpScreen.paddedWidthInBytes / 2);
+      break;
+    case 32:
+      ret = fbScreenInit(pScreen, g_rdpScreen.pfbMemory,
+                          g_rdpScreen.width, g_rdpScreen.height,
+                          dpix, dpiy, g_rdpScreen.paddedWidthInBytes / 4);
+      break;
+    default:
+      return 0;
+  }
+  if (!ret)
+  {
+    return 0;
+  }
+
+  miInitializeBackingStore(pScreen);
+
+  /* this is for rgb, not bgr, just doing rgb for now */
+  vis = g_pScreen->visuals + g_pScreen->numVisuals;
+  while (--vis >= pScreen->visuals)
+  {
+    if ((vis->class | DynamicClass) == DirectColor)
+    {
+      vis->offsetBlue = 0;
+      vis->blueMask = (1 << g_blueBits) - 1;
+      vis->offsetGreen = g_blueBits;
+      vis->greenMask = ((1 << g_greenBits) - 1) << vis->offsetGreen;
+      vis->offsetRed = g_blueBits + g_greenBits;
+      vis->redMask = ((1 << g_redBits) - 1) << vis->offsetRed;
+    }
+  }
+
+  if (g_rdpScreen.bitsPerPixel > 4)
+  {
+    fbPictureInit(pScreen, 0, 0);
+  }
+
+  if (!AllocateGCPrivate(pScreen, g_rdpGCIndex, sizeof(rdpGCRec)))
+  {
+    FatalError("rdpScreenInit: AllocateGCPrivate failed\n");
+  }
+  /* Random screen procedures */
+  g_rdpScreen.CloseScreen = pScreen->CloseScreen;
+  /* GC procedures */
+  g_rdpScreen.CreateGC = pScreen->CreateGC;
+  /* Window Procedures */
+  g_rdpScreen.PaintWindowBackground = pScreen->PaintWindowBackground;
+  g_rdpScreen.PaintWindowBorder = pScreen->PaintWindowBorder;
+  g_rdpScreen.CopyWindow = pScreen->CopyWindow;
+  g_rdpScreen.ClearToBackground = pScreen->ClearToBackground;
+  /* Backing store procedures */
+  g_rdpScreen.RestoreAreas = pScreen->RestoreAreas;
+  g_rdpScreen.WakeupHandler = pScreen->WakeupHandler;
+  ps = GetPictureScreenIfSet(pScreen);
+  if (ps)
+  {
+    g_rdpScreen.Composite = ps->Composite;
+  }
+
+  /* testing something here */
+  /*rdpScreen.InstallColormap = pScreen->InstallColormap;*/
+
+  pScreen->blackPixel = g_rdpScreen.blackPixel;
+  pScreen->whitePixel = g_rdpScreen.whitePixel;
+
+  /* Random screen procedures */
+  pScreen->CloseScreen = rdpCloseScreen;
+  pScreen->WakeupHandler = rdpWakeupHandler;
+  if (ps)
+  {
+    ps->Composite = rdpComposite;
+  }
+  pScreen->SaveScreen = rdpSaveScreen;
+  /* GC procedures */
+  pScreen->CreateGC = rdpCreateGC;
+  /* Window Procedures */
+  pScreen->PaintWindowBackground = rdpPaintWindowBackground;
+  pScreen->PaintWindowBorder = rdpPaintWindowBorder;
+  pScreen->CopyWindow = rdpCopyWindow;
+  pScreen->ClearToBackground = rdpClearToBackground;
+  /* Backing store procedures */
+  pScreen->RestoreAreas = rdpRestoreAreas;
+  /* Colormap procedures */
+  /*pScreen->InstallColormap = rdpInstallColormap;*/
+  /*pScreen->UninstallColormap = rdpUninstallColormap;*/
+  /*pScreen->ListInstalledColormaps = rdpListInstalledColormaps;*/
+  /*pScreen->StoreColors = rdpStoreColors;*/
+  miPointerInitialize(pScreen, &rdpSpritePointerFuncs,
+                      &rdpPointerCursorFuncs, 1);
+  vis = pScreen->visuals;
+  while (vis->vid != pScreen->rootVisual)
+  {
+    vis++;
+  }
+  if (vis == 0)
+  {
+    rdpLog("rdpScreenInit: couldn't find root visual\n");
+    exit(1);
+  }
+
+  /*vis->offsetBlue = 0;*/
+  /*vis->blueMask = (1 << blueBits) - 1;*/
+  /*vis->offsetGreen = blueBits;*/
+  /*vis->greenMask = ((1 << greenBits) - 1) << vis->offsetGreen;*/
+  /*vis->offsetRed = vis->offsetGreen + greenBits;*/
+  /*vis->redMask = ((1 << redBits) - 1) << vis->offsetRed;*/
+  if (g_rdpScreen.bitsPerPixel == 1)
+  {
+    ret = mfbCreateDefColormap(pScreen);
+  }
+  else
+  {
+    ret = fbCreateDefColormap(pScreen);
+  }
+  if (ret)
+  {
+    ret = rdpup_init();
+  }
+  return ret;
+}
+
+/******************************************************************************/
+/* this is the first function called, it can be called many times
+   returns the number or parameters processed
+   if it dosen't apply to the rdp part, return 0 */
+int
+ddxProcessArgument(int argc, char** argv, int i)
+{
+  /*ErrorF("hi ddxProcessArgument %s\n", argv[i]);*/
+  if (g_firstTime)
+  {
+    memset(&g_rdpScreen, 0, sizeof(g_rdpScreen));
+    g_rdpScreen.width  = 800;
+    g_rdpScreen.height = 600;
+    g_rdpScreen.depth = 8;
+    set_bpp(8);
+    /*rdpScreen.whitePixel = 0xffff;*/
+    g_rdpScreen.blackPixel = 1;
+    /*rdpScreen.blackPixel = 0xffff;*/
+    g_firstTime = 0;
+  }
+  if (strcmp (argv[i], "-geometry") == 0)
+  {
+    if (i + 1 >= argc)
+    {
+      UseMsg();
+    }
+    if (sscanf(argv[i + 1], "%dx%d", &g_rdpScreen.width,
+               &g_rdpScreen.height) != 2)
+    {
+      ErrorF("Invalid geometry %s\n", argv[i + 1]);
+      UseMsg();
+    }
+    return 2;
+  }
+  if (strcmp (argv[i], "-depth") == 0)
+  {
+    if (i + 1 >= argc)
+    {
+      UseMsg();
+    }
+    g_rdpScreen.depth = atoi(argv[i + 1]);
+    if (set_bpp(g_rdpScreen.depth) != 0)
+    {
+      UseMsg();
+    }
+    return 2;
+  }
+  return 0;
+}
+
+/******************************************************************************/
+void
+OsVendorInit(void)
+{
+  /*ErrorF("hi OsVendorInit\n");*/
+}
+
+/******************************************************************************/
+CARD32
+GetTimeInMillis(void)
+{
+  struct timeval tp;
+
+  /*ErrorF("hi GetTimeInMillis\n");*/
+  X_GETTIMEOFDAY(&tp);
+  return (tp.tv_sec * 1000) + (tp.tv_usec / 1000);
+}
+
+/* Common pixmap formats */
+static PixmapFormatRec formats[MAXFORMATS] =
+{
+  { 1, 1, BITMAP_SCANLINE_PAD },
+  { 4, 8, BITMAP_SCANLINE_PAD },
+  { 8, 8, BITMAP_SCANLINE_PAD },
+  { 15, 16, BITMAP_SCANLINE_PAD },
+  { 16, 16, BITMAP_SCANLINE_PAD },
+  { 24, 32, BITMAP_SCANLINE_PAD },
+  { 32, 32, BITMAP_SCANLINE_PAD },
+};
+static int numFormats = 7;
+
+/******************************************************************************/
+/* InitOutput is called every time the server resets.  It should call
+   AddScreen for each screen (but we only ever have one), and in turn this
+   will call rdpScreenInit. */
+void
+InitOutput(ScreenInfo* screenInfo, int argc, char** argv)
+{
+  int i;
+
+  /*ErrorF("hi InitOutput\n");*/
+  g_initOutputCalled = 1;
+  /* initialize pixmap formats */
+  screenInfo->imageByteOrder = IMAGE_BYTE_ORDER;
+  screenInfo->bitmapScanlineUnit = BITMAP_SCANLINE_UNIT;
+  screenInfo->bitmapScanlinePad = BITMAP_SCANLINE_PAD;
+  screenInfo->bitmapBitOrder = BITMAP_BIT_ORDER;
+  screenInfo->numPixmapFormats = numFormats;
+  for (i = 0; i < numFormats; i++)
+  {
+    screenInfo->formats[i] = formats[i];
+  }
+  g_rdpGCIndex = AllocateGCPrivateIndex();
+  if (g_rdpGCIndex < 0)
+  {
+    FatalError("InitOutput: AllocateGCPrivateIndex failed\n");
+  }
+  if (!AddCallback(&ClientStateCallback, rdpClientStateChange, NULL))
+  {
+    rdpLog("InitOutput: AddCallback failed\n");
+    return;
+  }
+  /* initialize screen */
+  if (AddScreen(rdpScreenInit, argc, argv) == -1)
+  {
+    FatalError("Couldn't add screen\n");
+  }
+}
+
+/******************************************************************************/
+void
+InitInput(int argc, char** argv)
+{
+  DeviceIntPtr p;
+  DeviceIntPtr k;
+
+  /*ErrorF("hi InitInput\n");*/
+  k = AddInputDevice(rdpKeybdProc, 1);
+  p = AddInputDevice(rdpMouseProc, 1);
+  RegisterKeyboardDevice(k);
+  RegisterPointerDevice(p);
+  miRegisterPointerDevice(screenInfo.screens[0], p);
+  mieqInit(k, p);
+/*
+  mieqCheckForInput[0] = checkForInput[0];
+  mieqCheckForInput[1] = checkForInput[1];
+  SetInputCheck(&alwaysCheckForInput[0], &alwaysCheckForInput[1]);
+*/
+}
+
+/******************************************************************************/
+void
+ddxGiveUp(void)
+{
+  char unixSocketName[32];
+
+  /*ErrorF("hi ddxGiveUp\n");*/
+  Xfree(g_rdpScreen.pfbMemory);
+  if (g_initOutputCalled)
+  {
+    sprintf(unixSocketName, "/tmp/.X11-unix/X%s", display);
+    unlink(unixSocketName);
+  }
+}
+
+/******************************************************************************/
+Bool
+LegalModifier(unsigned int key, DevicePtr pDev)
+{
+  /*ErrorF("hi LegalModifier\n");*/
+  return 1; /* true */
+}
+
+/******************************************************************************/
+void
+ProcessInputEvents(void)
+{
+  /*ErrorF("hi ProcessInputEvents\n");*/
+  /*rdpup_check();*/
+  /*if (*mieqCheckForInput[0] != *mieqCheckForInput[1])*/
+  {
+    /*ErrorF("hi ProcessInputEvents2 \n");*/
+    mieqProcessInputEvents();
+    miPointerUpdate();
+  }
+}
+
+/******************************************************************************/
+/* needed for some reason? todo
+   needs to be rfb */
+void
+rfbRootPropertyChange(PropertyPtr pProp)
+{
+  /*ErrorF("hi rdpRootPropertyChange\n");*/
+}
+
+/******************************************************************************/
+void
+AbortDDX(void)
+{
+  /*ErrorF("hi AbortDDX\n");*/
+  ddxGiveUp();
+}
+
+/******************************************************************************/
+void
+OsVendorFatalError(void)
+{
+  /*ErrorF("hi OsVendorFatalError\n");*/
+}
+
+/******************************************************************************/
+/* print the command list parameters and exit the program */
+void
+ddxUseMsg(void)
+{
+  ErrorF("\n");
+  ErrorF("Xrdp specific options\n");
+  ErrorF("-geometry WxH          set framebuffer width & height\n");
+  ErrorF("-depth D               set framebuffer depth\n");
+  ErrorF("\n");
+  exit(1);
+}