Changeset 33004 in vbox for trunk

Timestamp:

Oct 8, 2010 10:23:59 AM (14 years ago)

Author:

vboxsync

Message:

Renamed VBox-VRDP interface to VRDE.

Location:

trunk

Files:

• include/VBox/VRDPOrders.h (deleted)
• include/VBox/vrdpapi.h (deleted)
• src/VBox/Additions/WINNT/Graphics/Display/vrdp.c (modified) (38 diffs)
• src/VBox/Additions/WINNT/Graphics/Display/vrdpbmp.c (modified) (2 diffs)
• src/VBox/Additions/WINNT/Graphics/Display/vrdptext.c (modified) (7 diffs)
• src/VBox/Frontends/VBoxHeadless/VBoxHeadless.cpp (modified) (1 diff)
• src/VBox/Main/AudioSnifferInterface.cpp (modified) (2 diffs)
• src/VBox/Main/ConsoleImpl.cpp (modified) (5 diffs)
• src/VBox/Main/ConsoleVRDPServer.cpp (modified) (41 diffs)
• src/VBox/Main/RemoteUSBBackend.cpp (modified) (42 diffs)
• src/VBox/Main/RemoteUSBDeviceImpl.cpp (modified) (2 diffs)
• src/VBox/Main/include/ConsoleImpl.h (modified) (2 diffs)
• src/VBox/Main/include/ConsoleVRDPServer.h (modified) (5 diffs)
• src/VBox/Main/include/RemoteUSBBackend.h (modified) (3 diffs)
• src/VBox/Main/include/RemoteUSBDeviceImpl.h (modified) (2 diffs)

trunk/src/VBox/Additions/WINNT/Graphics/Display/vrdp.c

@@ -20 +20 @@
 #include "driver.h"
 #include "vrdpbmp.h"
-#include <VBox/VRDPOrders.h>
+#include <VBox/RemoteDesktop/VRDEOrders.h>
 
 #define VRDP_MAKE_OP(__c) (__c)
@@ -372 +372 @@
     BOOL bRc = FALSE;
 
-    VRDPDATABITS bits;
+    VRDEDATABITS bits;
 
     bits.cb      = cHeight * cWidth * bytesPerPixel;
@@ -436 +436 @@
     if (bytesPerPixel > 0)
     {
-        bRc = vrdpWriteHdr (ppdev, VRDP_MAKE_OP(VRDP_ORDER_DIRTY_RECT));
+        bRc = vrdpWriteHdr (ppdev, VRDP_MAKE_OP(VRDE_ORDER_DIRTY_RECT));
 
         if (bRc)
@@ -512 +512 @@
                               const RECTL *prcl)
 {
-    VRDPORDERBOUNDS bounds;
+    VRDEORDERBOUNDS bounds;
 
     bounds.pt1.x = (int16_t)(prcl->left);
@@ -519 +519 @@
     bounds.pt2.y = (int16_t)(prcl->bottom);
 
-    return vrdpReportOrder (ppdev, &bounds, sizeof (bounds), VRDP_ORDER_BOUNDS);
+    return vrdpReportOrder (ppdev, &bounds, sizeof (bounds), VRDE_ORDER_BOUNDS);
 }
 
@@ -535 +535 @@
         for (; i < pRects->c; i++, prcl++)
         {
-            VRDPORDERREPEAT repeat;
+            VRDEORDERREPEAT repeat;
 
             repeat.bounds.pt1.x = (int16_t)(prcl->left);
@@ -542 +542 @@
             repeat.bounds.pt2.y = (int16_t)(prcl->bottom);
 
-            bRc = vrdpReportOrder (ppdev, &repeat, sizeof (repeat), VRDP_ORDER_REPEAT);
+            bRc = vrdpReportOrder (ppdev, &repeat, sizeof (repeat), VRDE_ORDER_REPEAT);
 
             if (!bRc)
@@ -556 +556 @@
 static BOOL vrdpIntersectRectWithBounds (RECTL *prclIntersect,
                                          const RECTL *prcl,
-                                         const VRDPORDERBOUNDS *pBounds)
+                                         const VRDEORDERBOUNDS *pBounds)
 {
     if (   prcl->left   < pBounds->pt2.x     /* left < bounds_right */
@@ -582 +582 @@
 static BOOL vrdpGetIntersectingRects (CLIPRECTS *pRects,
                                       const VRDPCLIPRECTS *pClipRects,
-                                      const VRDPORDERBOUNDS *pBounds)
+                                      const VRDEORDERBOUNDS *pBounds)
 {
     BOOL fReportOrder = TRUE;
@@ -663 +663 @@
 static void vrdpReportOrderGenericBounds (PPDEV ppdev,
                                           const VRDPCLIPRECTS *pClipRects,
-                                          const VRDPORDERBOUNDS *pBounds,
+                                          const VRDEORDERBOUNDS *pBounds,
                                           const void *pvOrder,
                                           unsigned cbOrder,
@@ -681 +681 @@
                                  ULONG rgb)
 {
-    VRDPORDERSOLIDRECT order;
+    VRDEORDERSOLIDRECT order;
 
     order.x     = (int16_t)prclTrg->left;
@@ -689 +689 @@
     order.rgb   = rgb;
 
-    vrdpReportOrderGeneric (ppdev, pClipRects, &order, sizeof (order), VRDP_ORDER_SOLIDRECT);
+    vrdpReportOrderGeneric (ppdev, pClipRects, &order, sizeof (order), VRDE_ORDER_SOLIDRECT);
 }
 
@@ -698 +698 @@
                                 uint8_t rop3)
 {
-    VRDPORDERSOLIDBLT order;
+    VRDEORDERSOLIDBLT order;
 
     order.x     = (int16_t)prclTrg->left;
@@ -707 +707 @@
     order.rop   = rop3;
 
-    vrdpReportOrderGeneric (ppdev, pClipRects, &order, sizeof (order), VRDP_ORDER_SOLIDBLT);
+    vrdpReportOrderGeneric (ppdev, pClipRects, &order, sizeof (order), VRDE_ORDER_SOLIDBLT);
 }
 
@@ -717 +717 @@
                               uint8_t rop3)
 {
-    VRDPORDERPATBLTBRUSH order;
+    VRDEORDERPATBLTBRUSH order;
 
     int8_t xSrc = 0;
@@ -757 +757 @@
     memcpy (order.pattern, pBrush->u.pat.au8Pattern, sizeof (order.pattern));
 
-    vrdpReportOrderGeneric (ppdev, pClipRects, &order, sizeof (order), VRDP_ORDER_PATBLTBRUSH);
+    vrdpReportOrderGeneric (ppdev, pClipRects, &order, sizeof (order), VRDE_ORDER_PATBLTBRUSH);
 }
 
@@ -765 +765 @@
                               uint8_t rop3)
 {
-    VRDPORDERDSTBLT order;
+    VRDEORDERDSTBLT order;
 
     order.x     = (int16_t)prclTrg->left;
@@ -773 +773 @@
     order.rop   = rop3;
 
-    vrdpReportOrderGeneric (ppdev, pClipRects, &order, sizeof (order), VRDP_ORDER_DSTBLT);
+    vrdpReportOrderGeneric (ppdev, pClipRects, &order, sizeof (order), VRDE_ORDER_DSTBLT);
 }
 
@@ -782 +782 @@
                                  uint8_t rop3)
 {
-    VRDPORDERSCREENBLT order;
+    VRDEORDERSCREENBLT order;
 
     order.x     = (int16_t)prclTrg->left;
@@ -792 +792 @@
     order.rop   = rop3;
 
-    vrdpReportOrderGeneric (ppdev, pClipRects, &order, sizeof (order), VRDP_ORDER_SCREENBLT);
+    vrdpReportOrderGeneric (ppdev, pClipRects, &order, sizeof (order), VRDE_ORDER_SCREENBLT);
 }
 
@@ -802 +802 @@
                                   const VRDPBCHASH *phash)
 {
-    VRDPORDERMEMBLT order;
+    VRDEORDERMEMBLT order;
 
     order.x    = (int16_t)prcl->left;
@@ -815 +815 @@
     memcpy (order.hash, phash, sizeof (*phash));
 
-    vrdpReportOrder (ppdev, &order, sizeof (order), VRDP_ORDER_MEMBLT);
+    vrdpReportOrder (ppdev, &order, sizeof (order), VRDE_ORDER_MEMBLT);
 }
 
@@ -854 +854 @@
     BOOL bRc;
 
-    VRDPORDERCACHEDBITMAP order;
+    VRDEORDERCACHEDBITMAP order;
 
     VBVA_ASSERT(sizeof (*phash) == sizeof (order.hash));
     memcpy (order.hash, phash, sizeof (*phash));
 
-    bRc = vrdpReportOrder (ppdev, &order, sizeof (order), VRDP_ORDER_CACHED_BITMAP);
+    bRc = vrdpReportOrder (ppdev, &order, sizeof (order), VRDE_ORDER_CACHED_BITMAP);
 
     if (bRc)
@@ -879 +879 @@
                                      const VRDPBCHASH *phash)
 {
-    VRDPORDERDELETEDBITMAP order;
+    VRDEORDERDELETEDBITMAP order;
 
     VBVA_ASSERT(sizeof (*phash) == sizeof (order.hash));
     memcpy (order.hash, phash, sizeof (*phash));
 
-    vrdpReportOrder (ppdev, &order, sizeof (order), VRDP_ORDER_DELETED_BITMAP);
+    vrdpReportOrder (ppdev, &order, sizeof (order), VRDE_ORDER_DELETED_BITMAP);
 }
 
@@ -1252 +1252 @@
     else
     {
-        VRDPORDERLINE order;
+        VRDEORDERLINE order;
 
         order.x1 = (int16_t)x1;
@@ -1271 +1271 @@
                     prclBounds->left, prclBounds->right, prclBounds->top, prclBounds->bottom, clipRects.rects.c));
 
-        vrdpReportOrderGeneric (ppdev, &clipRects, &order, sizeof (order), VRDP_ORDER_LINE);
+        vrdpReportOrderGeneric (ppdev, &clipRects, &order, sizeof (order), VRDE_ORDER_LINE);
     }
 }
@@ -1335 +1335 @@
 }
 
-static void vrdpPointFX2Point (const POINTFIX *pptfx, VRDPORDERPOINT *ppt)
+static void vrdpPointFX2Point (const POINTFIX *pptfx, VRDEORDERPOINT *ppt)
 {
     ppt->x = (int16_t)FXTOLROUND(pptfx->x);
@@ -1341 +1341 @@
 }
 
-static void vrdpPolyPointsAdd (VRDPORDERPOLYPOINTS *pPoints, const VRDPORDERPOINT *ppt)
+static void vrdpPolyPointsAdd (VRDEORDERPOLYPOINTS *pPoints, const VRDEORDERPOINT *ppt)
 {
     VBVA_ASSERT(pPoints->c < RT_ELEMENTS(pPoints->a));
@@ -1350 +1350 @@
 }
 
-static void vrdpExtendOrderBounds (VRDPORDERBOUNDS *pBounds, const VRDPORDERPOINT *ppt)
+static void vrdpExtendOrderBounds (VRDEORDERBOUNDS *pBounds, const VRDEORDERPOINT *ppt)
 {
     /* Bounds have inclusive pt1 and exclusive pt2. */
@@ -1434 +1434 @@
     else if (ppo->fl & PO_ELLIPSE)
     {
-        if (vboxOrderSupported (ppdev, VRDP_ORDER_ELLIPSE))
-        {
-            VRDPORDERELLIPSE order;
+        if (vboxOrderSupported (ppdev, VRDE_ORDER_ELLIPSE))
+        {
+            VRDEORDERELLIPSE order;
 
             order.pt1.x = (int16_t)FXTOLROUND(rcfxBounds.xLeft   + 4);
@@ -1447 +1447 @@
             order.rgb = vrdpColor2RGB (pso, pbo->iSolidColor);
 
-            vrdpReportOrderGeneric (ppdev, &clipRects, &order, sizeof (order), VRDP_ORDER_ELLIPSE);
+            vrdpReportOrderGeneric (ppdev, &clipRects, &order, sizeof (order), VRDE_ORDER_ELLIPSE);
         }
         else
@@ -1462 +1462 @@
         PATHDATA pd;
         BOOL bMore;
-        VRDPORDERPOLYLINE order;
-        VRDPORDERPOINT ptStart;
-        VRDPORDERBOUNDS bounds;
+        VRDEORDERPOLYLINE order;
+        VRDEORDERPOINT ptStart;
+        VRDEORDERBOUNDS bounds;
 
         order.rgb = vrdpColor2RGB (pso, pbo->iSolidColor);
@@ -1475 +1475 @@
         do {
             POINTFIX *pptfx;
-            VRDPORDERPOINT pt;
+            VRDEORDERPOINT pt;
 
             bMore = PATHOBJ_bEnum (ppo, &pd);
@@ -1520 +1520 @@
                     DISPDBG((1, "vrdpStrokePath: Report order, points overflow.\n"));
 
-                    vrdpReportOrderGenericBounds (ppdev, &clipRects, &bounds, &order, sizeof (order), VRDP_ORDER_POLYLINE);
+                    vrdpReportOrderGenericBounds (ppdev, &clipRects, &bounds, &order, sizeof (order), VRDE_ORDER_POLYLINE);
 
                     order.points.c = 0;
@@ -1550 +1550 @@
                 if (order.points.c > 0)
                 {
-                    vrdpReportOrderGenericBounds (ppdev, &clipRects, &bounds, &order, sizeof (order), VRDP_ORDER_POLYLINE);
+                    vrdpReportOrderGenericBounds (ppdev, &clipRects, &bounds, &order, sizeof (order), VRDE_ORDER_POLYLINE);
                 }
 
@@ -1727 +1727 @@
         case SS_SAVE:
         {
-            VRDPORDERSAVESCREEN order;
+            VRDEORDERSAVESCREEN order;
 
             order.pt1.x = (int16_t)prcl->left;
@@ -1737 +1737 @@
             order.restore = 0;
 
-            vrdpReportOrderGeneric (ppdev, NULL, &order, sizeof (order), VRDP_ORDER_SAVESCREEN);
+            vrdpReportOrderGeneric (ppdev, NULL, &order, sizeof (order), VRDE_ORDER_SAVESCREEN);
         } break;
 
         case SS_RESTORE:
         {
-            VRDPORDERSAVESCREEN order;
+            VRDEORDERSAVESCREEN order;
 
             order.pt1.x = (int16_t)prcl->left;
@@ -1752 +1752 @@
             order.restore = 1;
 
-            if (vrdpReportOrderGeneric (ppdev, NULL, &order, sizeof (order), VRDP_ORDER_SAVESCREEN))
+            if (vrdpReportOrderGeneric (ppdev, NULL, &order, sizeof (order), VRDE_ORDER_SAVESCREEN))
             {
                 uint8_t *pu8Bits;

trunk/src/VBox/Additions/WINNT/Graphics/Display/vrdpbmp.c

@@ -22 +22 @@
 #include "vrdpbmp.h"
 #include <iprt/crc.h>
-#include <VBox/VRDPOrders.h>
+#include <VBox/RemoteDesktop/VRDEOrders.h>
 
 /*
@@ -211 +211 @@
     int i;
 
-    VBVA_ASSERT(sizeof (VRDPBCHASH) == sizeof (VRDPBITMAPHASH));
+    VBVA_ASSERT(sizeof (VRDPBCHASH) == sizeof (VRDEBITMAPHASH));
 
     /* Reinitialize the cache structure. */

trunk/src/VBox/Additions/WINNT/Graphics/Display/vrdptext.c

@@ -19 +19 @@
 
 #include "driver.h"
-#include <VBox/VRDPOrders.h>
+#include <VBox/RemoteDesktop/VRDEOrders.h>
 #include <iprt/crc.h>
 
@@ -71 +71 @@
  *       represents a 'space' character might allow some optimizations.
  *
- * The VRDPORDERTEXT consists of the string info and glyph infos.
+ * The VRDEORDERTEXT consists of the string info and glyph infos.
  *
  */
@@ -80 +80 @@
     uint32_t cbBitmap;
 
-    VRDPORDERGLYPH *pOrder = (VRDPORDERGLYPH *)*ppu8Ptr;
+    VRDEORDERGLYPH *pOrder = (VRDEORDERGLYPH *)*ppu8Ptr;
 
     GLYPHBITS *pgb = pGlyphPos->pgdf->pgb;
@@ -124 +124 @@
 static uint32_t vboxSizeofTextOrder (ULONG cGlyphs, ULONG cbMaxGlyph)
 {
-    uint32_t cb = sizeof (VRDPORDERTEXT);
-
-    cb += cGlyphs * (sizeof (VRDPORDERGLYPH) + cbMaxGlyph);
+    uint32_t cb = sizeof (VRDEORDERTEXT);
+
+    cb += cGlyphs * (sizeof (VRDEORDERGLYPH) + cbMaxGlyph);
 
     return cb;
@@ -142 +142 @@
     FONTINFO fi;
     uint32_t cbOrderMax;
-    VRDPORDERTEXT *pOrder;
+    VRDEORDERTEXT *pOrder;
     BOOL fResult;
     uint8_t *pu8GlyphPtr;
@@ -180 +180 @@
     DISPDBG((1, "VRDP::vrdpReportText: pstro->cGlyphs = %d, fi.cjMaxGlyph1 = 0x%x, cbOrderMax = 0x%x.\n", pstro->cGlyphs, fi.cjMaxGlyph1, cbOrderMax));
 
-    pOrder = (VRDPORDERTEXT *)EngAllocMem (0, cbOrderMax, ALLOC_TAG);
+    pOrder = (VRDEORDERTEXT *)EngAllocMem (0, cbOrderMax, ALLOC_TAG);
 
     if (!pOrder)
@@ -261 +261 @@
         pOrder->cbOrder = (uint32_t)(pu8GlyphPtr - (uint8_t *)pOrder);
 
-        vrdpReportOrderGeneric (ppdev, pClipRects, pOrder, pOrder->cbOrder, VRDP_ORDER_TEXT);
+        vrdpReportOrderGeneric (ppdev, pClipRects, pOrder, pOrder->cbOrder, VRDE_ORDER_TEXT);
     }
 

trunk/src/VBox/Frontends/VBoxHeadless/VBoxHeadless.cpp

@@ -32 +32 @@
 #include <VBox/log.h>
 #include <VBox/version.h>
-#ifdef VBOX_WITH_VRDP
-# include <VBox/vrdpapi.h>
-#endif
 #include <iprt/buildconfig.h>
 #include <iprt/ctype.h>

trunk/src/VBox/Main/AudioSnifferInterface.cpp

@@ -23 +23 @@
 
 #include <VBox/pdmdrv.h>
-#include <VBox/vrdpapi.h>
+#include <VBox/RemoteDesktop/VRDE.h>
 #include <VBox/cfgm.h>
 #include <VBox/err.h>
@@ -99 +99 @@
      * Just call the VRDP server with the data.
      */
-    VRDPAUDIOFORMAT format = VRDP_AUDIO_FMT_MAKE(samplesPerSec, nChannels, bitsPerSample, !fUnsigned);
+    VRDEAUDIOFORMAT format = VRDE_AUDIO_FMT_MAKE(samplesPerSec, nChannels, bitsPerSample, !fUnsigned);
     pDrv->pAudioSniffer->getParent()->consoleVRDPServer()->SendAudioSamples(pvSamples, cSamples, format);
 }

trunk/src/VBox/Main/ConsoleImpl.cpp

@@ -1021 +1021 @@
 #endif /* VBOX_WITH_VRDP */
 
-    if (fu32Intercepted & VRDP_CLIENT_INTERCEPT_USB)
+    if (fu32Intercepted & VRDE_CLIENT_INTERCEPT_USB)
     {
         mConsoleVRDPServer->USBBackendDelete(u32ClientId);
@@ -1027 +1027 @@
 
 #ifdef VBOX_WITH_VRDP
-    if (fu32Intercepted & VRDP_CLIENT_INTERCEPT_CLIPBOARD)
+    if (fu32Intercepted & VRDE_CLIENT_INTERCEPT_CLIPBOARD)
     {
         mConsoleVRDPServer->ClipboardDelete(u32ClientId);
     }
 
-    if (fu32Intercepted & VRDP_CLIENT_INTERCEPT_AUDIO)
+    if (fu32Intercepted & VRDE_CLIENT_INTERCEPT_AUDIO)
     {
         mcAudioRefs--;
@@ -7174 +7174 @@
  * @note Locks this object for writing.
  */
-void Console::processRemoteUSBDevices(uint32_t u32ClientId, VRDPUSBDEVICEDESC *pDevList, uint32_t cbDevList)
+void Console::processRemoteUSBDevices(uint32_t u32ClientId, VRDEUSBDEVICEDESC *pDevList, uint32_t cbDevList)
 {
     LogFlowThisFuncEnter();
@@ -7205 +7205 @@
      */
     /** @todo (sunlover) REMOTE_USB Strict validation of the pDevList. */
-    VRDPUSBDEVICEDESC *e = pDevList;
+    VRDEUSBDEVICEDESC *e = pDevList;
 
     /* The cbDevList condition must be checked first, because the function can
@@ -7277 +7277 @@
         cbDevList -= e->oNext;
 
-        e = (VRDPUSBDEVICEDESC *)((uint8_t *)e + e->oNext);
+        e = (VRDEUSBDEVICEDESC *)((uint8_t *)e + e->oNext);
     }
 

trunk/src/VBox/Main/ConsoleVRDPServer.cpp

@@ -34 +34 @@
 #include <VBox/err.h>
 #ifdef VBOX_WITH_VRDP
-#include <VBox/VRDPOrders.h>
+#include <VBox/RemoteDesktop/VRDEOrders.h>
 #endif /* VBOX_WITH_VRDP */
 
@@ -454 +454 @@
             const uint32_t dstheight = 32;
 
-            VRDPCOLORPOINTER *pointer = NULL;
+            VRDECOLORPOINTER *pointer = NULL;
 
             uint32_t dstmaskwidth = (dstwidth + 7) / 8;
@@ -464 +464 @@
             uint32_t rdpdatalen = dstheight * rdpdatawidth;
 
-            pointer = (VRDPCOLORPOINTER *)RTMemTmpAlloc(sizeof(VRDPCOLORPOINTER) + rdpmasklen + rdpdatalen);
+            pointer = (VRDECOLORPOINTER *)RTMemTmpAlloc(sizeof(VRDECOLORPOINTER) + rdpmasklen + rdpdatalen);
 
             if (pointer)
             {
-                uint8_t *maskarray = (uint8_t*)pointer + sizeof(VRDPCOLORPOINTER);
+                uint8_t *maskarray = (uint8_t*)pointer + sizeof(VRDECOLORPOINTER);
                 uint8_t *dataarray = maskarray + rdpmasklen;
 
@@ -551 +551 @@
 RTLDRMOD ConsoleVRDPServer::mVRDPLibrary;
 
-PFNVRDPCREATESERVER ConsoleVRDPServer::mpfnVRDPCreateServer = NULL;
-
-VRDPENTRYPOINTS_1 *ConsoleVRDPServer::mpEntryPoints = NULL;
-
-VRDPCALLBACKS_1 ConsoleVRDPServer::mCallbacks =
-{
-    { VRDP_INTERFACE_VERSION_1, sizeof(VRDPCALLBACKS_1) },
+PFNVRDECREATESERVER ConsoleVRDPServer::mpfnVRDPCreateServer = NULL;
+
+VRDEENTRYPOINTS_1 *ConsoleVRDPServer::mpEntryPoints = NULL;
+
+VRDECALLBACKS_1 ConsoleVRDPServer::mCallbacks =
+{
+    { VRDE_INTERFACE_VERSION_1, sizeof(VRDECALLBACKS_1) },
     ConsoleVRDPServer::VRDPCallbackQueryProperty,
     ConsoleVRDPServer::VRDPCallbackClientLogon,
@@ -580 +580 @@
     switch (index)
     {
-        case VRDP_QP_NETWORK_PORT:
-        {
-            /* This is obsolete, the VRDP server uses VRDP_QP_NETWORK_PORT_RANGE instead. */
+        case VRDE_QP_NETWORK_PORT:
+        {
+            /* This is obsolete, the VRDP server uses VRDE_QP_NETWORK_PORT_RANGE instead. */
             ULONG port = 0;
 
@@ -598 +598 @@
         } break;
 
-        case VRDP_QP_NETWORK_ADDRESS:
+        case VRDE_QP_NETWORK_ADDRESS:
         {
             com::Bstr bstr;
@@ -628 +628 @@
         } break;
 
-        case VRDP_QP_NUMBER_MONITORS:
+        case VRDE_QP_NUMBER_MONITORS:
         {
             ULONG cMonitors = 1;
@@ -647 +647 @@
         } break;
 
-        case VRDP_QP_NETWORK_PORT_RANGE:
+        case VRDE_QP_NETWORK_PORT_RANGE:
         {
             com::Bstr bstr;
@@ -688 +688 @@
 
 #ifdef VBOX_WITH_VRDP_VIDEO_CHANNEL
-        case VRDP_QP_VIDEO_CHANNEL:
+        case VRDE_QP_VIDEO_CHANNEL:
         {
             BOOL fVideoEnabled = FALSE;
@@ -707 +707 @@
         } break;
 
-        case VRDP_QP_VIDEO_CHANNEL_QUALITY:
+        case VRDE_QP_VIDEO_CHANNEL_QUALITY:
         {
             ULONG ulQuality = 0;
@@ -726 +726 @@
         } break;
 
-        case VRDP_QP_VIDEO_CHANNEL_SUNFLSH:
+        case VRDE_QP_VIDEO_CHANNEL_SUNFLSH:
         {
             ULONG ulSunFlsh = 1;
@@ -756 +756 @@
 #endif /* VBOX_WITH_VRDP_VIDEO_CHANNEL */
 
-        case VRDP_QP_FEATURE:
-        {
-            if (cbBuffer < sizeof(VRDPFEATURE))
+        case VRDE_QP_FEATURE:
+        {
+            if (cbBuffer < sizeof(VRDEFEATURE))
             {
                 rc = VERR_INVALID_PARAMETER;
@@ -764 +764 @@
             }
 
-            size_t cbInfo = cbBuffer - RT_OFFSETOF(VRDPFEATURE, achInfo);
-
-            VRDPFEATURE *pFeature = (VRDPFEATURE *)pvBuffer;
+            size_t cbInfo = cbBuffer - RT_OFFSETOF(VRDEFEATURE, achInfo);
+
+            VRDEFEATURE *pFeature = (VRDEFEATURE *)pvBuffer;
 
             size_t cchInfo = 0;
@@ -825 +825 @@
         } break;
 
-        case VRDP_SP_NETWORK_BIND_PORT:
+        case VRDE_SP_NETWORK_BIND_PORT:
         {
             if (cbBuffer != sizeof(uint32_t))
@@ -885 +885 @@
     switch (fu32Intercept)
     {
-        case VRDP_CLIENT_INTERCEPT_AUDIO:
+        case VRDE_CLIENT_INTERCEPT_AUDIO:
         {
             server->mConsole->VRDPInterceptAudio(u32ClientId);
@@ -895 +895 @@
         } break;
 
-        case VRDP_CLIENT_INTERCEPT_USB:
+        case VRDE_CLIENT_INTERCEPT_USB:
         {
             server->mConsole->VRDPInterceptUSB(u32ClientId, ppvIntercept);
@@ -901 +901 @@
         } break;
 
-        case VRDP_CLIENT_INTERCEPT_CLIPBOARD:
+        case VRDE_CLIENT_INTERCEPT_CLIPBOARD:
         {
             server->mConsole->VRDPInterceptClipboard(u32ClientId);
@@ -932 +932 @@
 }
 
-DECLCALLBACK(bool) ConsoleVRDPServer::VRDPCallbackFramebufferQuery(void *pvCallback, unsigned uScreenId, VRDPFRAMEBUFFERINFO *pInfo)
+DECLCALLBACK(bool) ConsoleVRDPServer::VRDPCallbackFramebufferQuery(void *pvCallback, unsigned uScreenId, VRDEFRAMEBUFFERINFO *pInfo)
 {
     ConsoleVRDPServer *server = static_cast<ConsoleVRDPServer*>(pvCallback);
@@ -1032 +1032 @@
     switch (type)
     {
-        case VRDP_INPUT_SCANCODE:
-        {
-            if (cbInput == sizeof(VRDPINPUTSCANCODE))
+        case VRDE_INPUT_SCANCODE:
+        {
+            if (cbInput == sizeof(VRDEINPUTSCANCODE))
             {
                 IKeyboard *pKeyboard = pConsole->getKeyboard();
 
-                const VRDPINPUTSCANCODE *pInputScancode = (VRDPINPUTSCANCODE *)pvInput;
+                const VRDEINPUTSCANCODE *pInputScancode = (VRDEINPUTSCANCODE *)pvInput;
 
                 /* Track lock keys. */
@@ -1063 +1063 @@
         } break;
 
-        case VRDP_INPUT_POINT:
-        {
-            if (cbInput == sizeof(VRDPINPUTPOINT))
-            {
-                const VRDPINPUTPOINT *pInputPoint = (VRDPINPUTPOINT *)pvInput;
+        case VRDE_INPUT_POINT:
+        {
+            if (cbInput == sizeof(VRDEINPUTPOINT))
+            {
+                const VRDEINPUTPOINT *pInputPoint = (VRDEINPUTPOINT *)pvInput;
 
                 int mouseButtons = 0;
                 int iWheel = 0;
 
-                if (pInputPoint->uButtons & VRDP_INPUT_POINT_BUTTON1)
+                if (pInputPoint->uButtons & VRDE_INPUT_POINT_BUTTON1)
                 {
                     mouseButtons |= MouseButtonState_LeftButton;
                 }
-                if (pInputPoint->uButtons & VRDP_INPUT_POINT_BUTTON2)
+                if (pInputPoint->uButtons & VRDE_INPUT_POINT_BUTTON2)
                 {
                     mouseButtons |= MouseButtonState_RightButton;
                 }
-                if (pInputPoint->uButtons & VRDP_INPUT_POINT_BUTTON3)
+                if (pInputPoint->uButtons & VRDE_INPUT_POINT_BUTTON3)
                 {
                     mouseButtons |= MouseButtonState_MiddleButton;
                 }
-                if (pInputPoint->uButtons & VRDP_INPUT_POINT_WHEEL_UP)
+                if (pInputPoint->uButtons & VRDE_INPUT_POINT_WHEEL_UP)
                 {
                     mouseButtons |= MouseButtonState_WheelUp;
                     iWheel = -1;
                 }
-                if (pInputPoint->uButtons & VRDP_INPUT_POINT_WHEEL_DOWN)
+                if (pInputPoint->uButtons & VRDE_INPUT_POINT_WHEEL_DOWN)
                 {
                     mouseButtons |= MouseButtonState_WheelDown;
@@ -1109 +1109 @@
         } break;
 
-        case VRDP_INPUT_CAD:
+        case VRDE_INPUT_CAD:
         {
             pConsole->getKeyboard()->PutCAD();
         } break;
 
-        case VRDP_INPUT_RESET:
+        case VRDE_INPUT_RESET:
         {
             pConsole->Reset();
         } break;
 
-        case VRDP_INPUT_SYNCH:
-        {
-            if (cbInput == sizeof(VRDPINPUTSYNCH))
+        case VRDE_INPUT_SYNCH:
+        {
+            if (cbInput == sizeof(VRDEINPUTSYNCH))
             {
                 IKeyboard *pKeyboard = pConsole->getKeyboard();
 
-                const VRDPINPUTSYNCH *pInputSynch = (VRDPINPUTSYNCH *)pvInput;
-
-                server->m_InputSynch.fClientNumLock    = (pInputSynch->uLockStatus & VRDP_INPUT_SYNCH_NUMLOCK) != 0;
-                server->m_InputSynch.fClientCapsLock   = (pInputSynch->uLockStatus & VRDP_INPUT_SYNCH_CAPITAL) != 0;
-                server->m_InputSynch.fClientScrollLock = (pInputSynch->uLockStatus & VRDP_INPUT_SYNCH_SCROLL) != 0;
+                const VRDEINPUTSYNCH *pInputSynch = (VRDEINPUTSYNCH *)pvInput;
+
+                server->m_InputSynch.fClientNumLock    = (pInputSynch->uLockStatus & VRDE_INPUT_SYNCH_NUMLOCK) != 0;
+                server->m_InputSynch.fClientCapsLock   = (pInputSynch->uLockStatus & VRDE_INPUT_SYNCH_CAPITAL) != 0;
+                server->m_InputSynch.fClientScrollLock = (pInputSynch->uLockStatus & VRDE_INPUT_SYNCH_SCROLL) != 0;
 
                 /* The client initiated synchronization. Always make the guest to reflect the client state.
@@ -1267 +1267 @@
         if (loadVRDPLibrary())
         {
-            rc = mpfnVRDPCreateServer(&mCallbacks.header, this, (VRDPINTERFACEHDR **)&mpEntryPoints, &mhServer);
+            rc = mpfnVRDPCreateServer(&mCallbacks.header, this, (VRDEINTERFACEHDR **)&mpEntryPoints, &mhServer);
 
             if (RT_SUCCESS(rc))
@@ -1296 +1296 @@
     if (mpEntryPoints && mhServer)
     {
-        mpEntryPoints->VRDPEnableConnections(mhServer, true);
+        mpEntryPoints->VRDEEnableConnections(mhServer, true);
     }
 #endif /* VBOX_WITH_VRDP */
@@ -1306 +1306 @@
     if (mpEntryPoints && mhServer)
     {
-        mpEntryPoints->VRDPDisconnect(mhServer, u32ClientId, fReconnect);
+        mpEntryPoints->VRDEDisconnect(mhServer, u32ClientId, fReconnect);
     }
 #endif /* VBOX_WITH_VRDP */
 }
 
-void ConsoleVRDPServer::MousePointerUpdate(const VRDPCOLORPOINTER *pPointer)
+void ConsoleVRDPServer::MousePointerUpdate(const VRDECOLORPOINTER *pPointer)
 {
 #ifdef VBOX_WITH_VRDP
     if (mpEntryPoints && mhServer)
     {
-        mpEntryPoints->VRDPColorPointer(mhServer, pPointer);
+        mpEntryPoints->VRDEColorPointer(mhServer, pPointer);
     }
 #endif /* VBOX_WITH_VRDP */
@@ -1326 +1326 @@
     if (mpEntryPoints && mhServer)
     {
-        mpEntryPoints->VRDPHidePointer(mhServer);
+        mpEntryPoints->VRDEHidePointer(mhServer);
     }
 #endif /* VBOX_WITH_VRDP */
@@ -1338 +1338 @@
     if (mhServer)
     {
-        HVRDPSERVER hServer = mhServer;
+        HVRDESERVER hServer = mhServer;
 
         /* Reset the handle to avoid further calls to the server. */
@@ -1345 +1345 @@
         if (mpEntryPoints && hServer)
         {
-            mpEntryPoints->VRDPDestroy(hServer);
+            mpEntryPoints->VRDEDestroy(hServer);
         }
     }
@@ -1649 +1649 @@
     switch (u32Function)
     {
-        case VRDP_CLIPBOARD_FUNCTION_FORMAT_ANNOUNCE:
+        case VRDE_CLIPBOARD_FUNCTION_FORMAT_ANNOUNCE:
         {
             if (pServer->mpfnClipboardCallback)
@@ -1660 +1660 @@
         } break;
 
-        case VRDP_CLIPBOARD_FUNCTION_DATA_READ:
+        case VRDE_CLIPBOARD_FUNCTION_DATA_READ:
         {
             if (pServer->mpfnClipboardCallback)
@@ -1705 +1705 @@
             if (mpEntryPoints && pServer->mhServer)
             {
-                mpEntryPoints->VRDPClipboard(pServer->mhServer,
-                                             VRDP_CLIPBOARD_FUNCTION_FORMAT_ANNOUNCE,
+                mpEntryPoints->VRDEClipboard(pServer->mhServer,
+                                             VRDE_CLIPBOARD_FUNCTION_FORMAT_ANNOUNCE,
                                              pParms->u32Format,
                                              NULL,
@@ -1722 +1722 @@
             if (mpEntryPoints && pServer->mhServer)
             {
-                mpEntryPoints->VRDPClipboard(pServer->mhServer,
-                                             VRDP_CLIPBOARD_FUNCTION_DATA_READ,
+                mpEntryPoints->VRDEClipboard(pServer->mhServer,
+                                             VRDE_CLIPBOARD_FUNCTION_DATA_READ,
                                              pParms->u32Format,
                                              pParms->u.pvData,
@@ -1735 +1735 @@
             if (mpEntryPoints && pServer->mhServer)
             {
-                mpEntryPoints->VRDPClipboard(pServer->mhServer,
-                                             VRDP_CLIPBOARD_FUNCTION_DATA_WRITE,
+                mpEntryPoints->VRDEClipboard(pServer->mhServer,
+                                             VRDE_CLIPBOARD_FUNCTION_DATA_WRITE,
                                              pParms->u32Format,
                                              pParms->u.pvData,
@@ -2050 +2050 @@
     if (mpEntryPoints && mhServer)
     {
-        mpEntryPoints->VRDPUpdate(mhServer, uScreenId, pvUpdate, cbUpdate);
+        mpEntryPoints->VRDEUpdate(mhServer, uScreenId, pvUpdate, cbUpdate);
     }
 #endif
@@ -2060 +2060 @@
     if (mpEntryPoints && mhServer)
     {
-        mpEntryPoints->VRDPResize(mhServer);
+        mpEntryPoints->VRDEResize(mhServer);
     }
 #endif
@@ -2068 +2068 @@
 {
 #ifdef VBOX_WITH_VRDP
-    VRDPORDERHDR update;
+    VRDEORDERHDR update;
     update.x = x;
     update.y = y;
@@ -2075 +2075 @@
     if (mpEntryPoints && mhServer)
     {
-        mpEntryPoints->VRDPUpdate(mhServer, uScreenId, &update, sizeof(update));
+        mpEntryPoints->VRDEUpdate(mhServer, uScreenId, &update, sizeof(update));
     }
 #endif
 }
 
-void ConsoleVRDPServer::SendAudioSamples(void *pvSamples, uint32_t cSamples, VRDPAUDIOFORMAT format) const
+void ConsoleVRDPServer::SendAudioSamples(void *pvSamples, uint32_t cSamples, VRDEAUDIOFORMAT format) const
 {
 #ifdef VBOX_WITH_VRDP
     if (mpEntryPoints && mhServer)
     {
-        mpEntryPoints->VRDPAudioSamples(mhServer, pvSamples, cSamples, format);
+        mpEntryPoints->VRDEAudioSamples(mhServer, pvSamples, cSamples, format);
     }
 #endif
@@ -2095 +2095 @@
     if (mpEntryPoints && mhServer)
     {
-        mpEntryPoints->VRDPAudioVolume(mhServer, left, right);
+        mpEntryPoints->VRDEAudioVolume(mhServer, left, right);
     }
 #endif
@@ -2105 +2105 @@
     if (mpEntryPoints && mhServer)
     {
-        mpEntryPoints->VRDPUSBRequest(mhServer, u32ClientId, pvParms, cbParms);
+        mpEntryPoints->VRDEUSBRequest(mhServer, u32ClientId, pvParms, cbParms);
     }
 #endif
@@ -2113 +2113 @@
 {
 #ifdef VBOX_WITH_VRDP
-    if (index == VRDP_QI_PORT)
+    if (index == VRDE_QI_PORT)
     {
         uint32_t cbOut = sizeof(int32_t);
@@ -2125 +2125 @@
     else if (mpEntryPoints && mhServer)
     {
-        mpEntryPoints->VRDPQueryInfo(mhServer, index, pvBuffer, cbBuffer, pcbOut);
+        mpEntryPoints->VRDEQueryInfo(mhServer, index, pvBuffer, cbBuffer, pcbOut);
     }
 #endif
@@ -2357 +2357 @@
     extern void IMPL_GETTER_BSTR_DUMMY(void)
 
-IMPL_GETTER_BOOL   (BOOL,    Active,             VRDP_QI_ACTIVE);
-IMPL_GETTER_SCALAR (LONG,    Port,               VRDP_QI_PORT,                  0);
-IMPL_GETTER_SCALAR (ULONG,   NumberOfClients,    VRDP_QI_NUMBER_OF_CLIENTS,     0);
-IMPL_GETTER_SCALAR (LONG64,  BeginTime,          VRDP_QI_BEGIN_TIME,            0);
-IMPL_GETTER_SCALAR (LONG64,  EndTime,            VRDP_QI_END_TIME,              0);
-IMPL_GETTER_SCALAR (LONG64,  BytesSent,          VRDP_QI_BYTES_SENT,            INT64_MAX);
-IMPL_GETTER_SCALAR (LONG64,  BytesSentTotal,     VRDP_QI_BYTES_SENT_TOTAL,      INT64_MAX);
-IMPL_GETTER_SCALAR (LONG64,  BytesReceived,      VRDP_QI_BYTES_RECEIVED,        INT64_MAX);
-IMPL_GETTER_SCALAR (LONG64,  BytesReceivedTotal, VRDP_QI_BYTES_RECEIVED_TOTAL,  INT64_MAX);
-IMPL_GETTER_BSTR   (BSTR,    User,               VRDP_QI_USER);
-IMPL_GETTER_BSTR   (BSTR,    Domain,             VRDP_QI_DOMAIN);
-IMPL_GETTER_BSTR   (BSTR,    ClientName,         VRDP_QI_CLIENT_NAME);
-IMPL_GETTER_BSTR   (BSTR,    ClientIP,           VRDP_QI_CLIENT_IP);
-IMPL_GETTER_SCALAR (ULONG,   ClientVersion,      VRDP_QI_CLIENT_VERSION,        0);
-IMPL_GETTER_SCALAR (ULONG,   EncryptionStyle,    VRDP_QI_ENCRYPTION_STYLE,      0);
+IMPL_GETTER_BOOL   (BOOL,    Active,             VRDE_QI_ACTIVE);
+IMPL_GETTER_SCALAR (LONG,    Port,               VRDE_QI_PORT,                  0);
+IMPL_GETTER_SCALAR (ULONG,   NumberOfClients,    VRDE_QI_NUMBER_OF_CLIENTS,     0);
+IMPL_GETTER_SCALAR (LONG64,  BeginTime,          VRDE_QI_BEGIN_TIME,            0);
+IMPL_GETTER_SCALAR (LONG64,  EndTime,            VRDE_QI_END_TIME,              0);
+IMPL_GETTER_SCALAR (LONG64,  BytesSent,          VRDE_QI_BYTES_SENT,            INT64_MAX);
+IMPL_GETTER_SCALAR (LONG64,  BytesSentTotal,     VRDE_QI_BYTES_SENT_TOTAL,      INT64_MAX);
+IMPL_GETTER_SCALAR (LONG64,  BytesReceived,      VRDE_QI_BYTES_RECEIVED,        INT64_MAX);
+IMPL_GETTER_SCALAR (LONG64,  BytesReceivedTotal, VRDE_QI_BYTES_RECEIVED_TOTAL,  INT64_MAX);
+IMPL_GETTER_BSTR   (BSTR,    User,               VRDE_QI_USER);
+IMPL_GETTER_BSTR   (BSTR,    Domain,             VRDE_QI_DOMAIN);
+IMPL_GETTER_BSTR   (BSTR,    ClientName,         VRDE_QI_CLIENT_NAME);
+IMPL_GETTER_BSTR   (BSTR,    ClientIP,           VRDE_QI_CLIENT_IP);
+IMPL_GETTER_SCALAR (ULONG,   ClientVersion,      VRDE_QI_CLIENT_VERSION,        0);
+IMPL_GETTER_SCALAR (ULONG,   EncryptionStyle,    VRDE_QI_ENCRYPTION_STYLE,      0);
 
 #undef IMPL_GETTER_BSTR

trunk/src/VBox/Main/RemoteUSBBackend.cpp

@@ -22 +22 @@
 #include "RemoteUSBDeviceImpl.h"
 
-#include <VBox/vrdpapi.h>
+#include <VBox/RemoteDesktop/VRDE.h>
 #include <VBox/vrdpusb.h>
 #include <VBox/err.h>
@@ -93 +93 @@
     bool      fInput;                  /* This URB receives data from the client. */
 
-    uint32_t  u32TransferredLen;       /* For VRDP_USB_DIRECTION_OUT URBs = bytes written.
-                                        * For VRDP_USB_DIRECTION_IN URBs = bytes received.
+    uint32_t  u32TransferredLen;       /* For VRDE_USB_DIRECTION_OUT URBs = bytes written.
+                                        * For VRDE_USB_DIRECTION_IN URBs = bytes received.
                                         */
 } REMOTEUSBQURB;
@@ -106 +106 @@
     RemoteUSBBackend *pOwner;
 
-    VRDPUSBDEVID      id;              /* The remote identifier, assigned by client. */
+    VRDEUSBDEVID      id;              /* The remote identifier, assigned by client. */
 
     uint32_t          u32ClientId;     /* The identifier of the remote client. */
@@ -163 +163 @@
     switch (code)
     {
-        case VRDP_USB_REQ_DEVICE_LIST:
+        case VRDE_USB_REQ_DEVICE_LIST:
         {
             rc = pThis->saveDeviceList (pvRet, cbRet);
         } break;
 
-        case VRDP_USB_REQ_NEGOTIATE:
-        {
-            if (pvRet && cbRet >= sizeof (VRDPUSBREQNEGOTIATERET))
-            {
-                VRDPUSBREQNEGOTIATERET *pret = (VRDPUSBREQNEGOTIATERET *)pvRet;
+        case VRDE_USB_REQ_NEGOTIATE:
+        {
+            if (pvRet && cbRet >= sizeof (VRDEUSBREQNEGOTIATERET))
+            {
+                VRDEUSBREQNEGOTIATERET *pret = (VRDEUSBREQNEGOTIATERET *)pvRet;
 
                 rc = pThis->negotiateResponse (pret, cbRet);
@@ -179 +179 @@
             {
                 Log(("USBClientResponseCallback: WARNING: not enough data in response: pv = %p, cb = %d, expected %d.\n",
-                     pvRet, cbRet, sizeof (VRDPUSBREQNEGOTIATERET)));
+                     pvRet, cbRet, sizeof (VRDEUSBREQNEGOTIATERET)));
 
                 rc = VERR_INVALID_PARAMETER;
@@ -185 +185 @@
         } break;
 
-        case VRDP_USB_REQ_REAP_URB:
+        case VRDE_USB_REQ_REAP_URB:
         {
             rc = pThis->reapURB (pvRet, cbRet);
@@ -192 +192 @@
         } break;
 
-        case VRDP_USB_REQ_QUEUE_URB:
-        case VRDP_USB_REQ_CLOSE:
-        case VRDP_USB_REQ_CANCEL_URB:
+        case VRDE_USB_REQ_QUEUE_URB:
+        case VRDE_USB_REQ_CLOSE:
+        case VRDE_USB_REQ_CANCEL_URB:
         {
             /* Do nothing, actually this should not happen. */
@@ -200 +200 @@
         } break;
 
-        case VRDP_USB_REQ_OPEN:
-        case VRDP_USB_REQ_RESET:
-        case VRDP_USB_REQ_SET_CONFIG:
-        case VRDP_USB_REQ_CLAIM_INTERFACE:
-        case VRDP_USB_REQ_RELEASE_INTERFACE:
-        case VRDP_USB_REQ_INTERFACE_SETTING:
-        case VRDP_USB_REQ_CLEAR_HALTED_EP:
+        case VRDE_USB_REQ_OPEN:
+        case VRDE_USB_REQ_RESET:
+        case VRDE_USB_REQ_SET_CONFIG:
+        case VRDE_USB_REQ_CLAIM_INTERFACE:
+        case VRDE_USB_REQ_RELEASE_INTERFACE:
+        case VRDE_USB_REQ_INTERFACE_SETTING:
+        case VRDE_USB_REQ_CLEAR_HALTED_EP:
         {
             /*
              * Device specific responses with status codes.
              */
-            if (pvRet && cbRet >= sizeof (VRDPUSBREQRETHDR))
-            {
-                VRDPUSBREQRETHDR *pret = (VRDPUSBREQRETHDR *)pvRet;
-
-                if (pret->status != VRDP_USB_STATUS_SUCCESS)
+            if (pvRet && cbRet >= sizeof (VRDEUSBREQRETHDR))
+            {
+                VRDEUSBREQRETHDR *pret = (VRDEUSBREQRETHDR *)pvRet;
+
+                if (pret->status != VRDE_USB_STATUS_SUCCESS)
                 {
                     REMOTEUSBDEVICE *pDevice = pThis->deviceFromId (pret->id);
@@ -234 +234 @@
             {
                 Log(("USBClientResponseCallback: WARNING: not enough data in response: pv = %p, cb = %d, expected %d.\n",
-                     pvRet, cbRet, sizeof (VRDPUSBREQRETHDR)));
+                     pvRet, cbRet, sizeof (VRDEUSBREQRETHDR)));
             }
         } break;
@@ -308 +308 @@
                 if (RT_SUCCESS(rc))
                 {
-                    VRDP_USB_REQ_OPEN_PARM parm;
-
-                    parm.code = VRDP_USB_REQ_OPEN;
+                    VRDE_USB_REQ_OPEN_PARM parm;
+
+                    parm.code = VRDE_USB_REQ_OPEN;
                     parm.id = pDevice->id;
 
@@ -337 +337 @@
     RemoteUSBBackend *pThis = pDevice->pOwner;
 
-    VRDP_USB_REQ_CLOSE_PARM parm;
-
-    parm.code = VRDP_USB_REQ_CLOSE;
+    VRDE_USB_REQ_CLOSE_PARM parm;
+
+    parm.code = VRDE_USB_REQ_CLOSE;
     parm.id = pDevice->id;
 
@@ -365 +365 @@
     }
 
-    VRDP_USB_REQ_RESET_PARM parm;
-
-    parm.code = VRDP_USB_REQ_RESET;
+    VRDE_USB_REQ_RESET_PARM parm;
+
+    parm.code = VRDE_USB_REQ_RESET;
     parm.id = pDevice->id;
 
@@ -384 +384 @@
     }
 
-    VRDP_USB_REQ_SET_CONFIG_PARM parm;
-
-    parm.code = VRDP_USB_REQ_SET_CONFIG;
+    VRDE_USB_REQ_SET_CONFIG_PARM parm;
+
+    parm.code = VRDE_USB_REQ_SET_CONFIG;
     parm.id = pDevice->id;
     parm.configuration = u8Cfg;
@@ -404 +404 @@
     }
 
-    VRDP_USB_REQ_CLAIM_INTERFACE_PARM parm;
-
-    parm.code = VRDP_USB_REQ_CLAIM_INTERFACE;
+    VRDE_USB_REQ_CLAIM_INTERFACE_PARM parm;
+
+    parm.code = VRDE_USB_REQ_CLAIM_INTERFACE;
     parm.id = pDevice->id;
     parm.iface = u8Ifnum;
@@ -424 +424 @@
     }
 
-    VRDP_USB_REQ_RELEASE_INTERFACE_PARM parm;
-
-    parm.code = VRDP_USB_REQ_RELEASE_INTERFACE;
+    VRDE_USB_REQ_RELEASE_INTERFACE_PARM parm;
+
+    parm.code = VRDE_USB_REQ_RELEASE_INTERFACE;
     parm.id = pDevice->id;
     parm.iface = u8Ifnum;
@@ -444 +444 @@
     }
 
-    VRDP_USB_REQ_INTERFACE_SETTING_PARM parm;
-
-    parm.code = VRDP_USB_REQ_INTERFACE_SETTING;
+    VRDE_USB_REQ_INTERFACE_SETTING_PARM parm;
+
+    parm.code = VRDE_USB_REQ_INTERFACE_SETTING;
     parm.id = pDevice->id;
     parm.iface = u8Ifnum;
@@ -465 +465 @@
     }
 
-    VRDP_USB_REQ_CLEAR_HALTED_EP_PARM parm;
-
-    parm.code = VRDP_USB_REQ_CLEAR_HALTED_EP;
+    VRDE_USB_REQ_CLEAR_HALTED_EP_PARM parm;
+
+    parm.code = VRDE_USB_REQ_CLEAR_HALTED_EP;
     parm.id = pDevice->id;
     parm.ep = u8Ep;
@@ -480 +480 @@
     RemoteUSBBackend *pThis = pDevice->pOwner;
 
-    VRDP_USB_REQ_CANCEL_URB_PARM parm;
-
-    parm.code = VRDP_USB_REQ_CANCEL_URB;
+    VRDE_USB_REQ_CANCEL_URB_PARM parm;
+
+    parm.code = VRDE_USB_REQ_CANCEL_URB;
     parm.id = pDevice->id;
     parm.handle = pRemoteURB->u32Handle;
@@ -534 +534 @@
     RemoteUSBBackend *pThis = pDevice->pOwner;
 
-    VRDP_USB_REQ_QUEUE_URB_PARM parm;
+    VRDE_USB_REQ_QUEUE_URB_PARM parm;
     uint32_t u32Handle = 0;
     uint32_t u32DataLen = 0;
@@ -573 +573 @@
     }
 
-    parm.code = VRDP_USB_REQ_QUEUE_URB;
+    parm.code = VRDE_USB_REQ_QUEUE_URB;
     parm.id = pDevice->id;
 
@@ -588 +588 @@
     switch(u8Type)
     {
-        case VUSBXFERTYPE_CTRL: parm.type = VRDP_USB_TRANSFER_TYPE_CTRL; break;
-        case VUSBXFERTYPE_ISOC: parm.type = VRDP_USB_TRANSFER_TYPE_ISOC; break;
-        case VUSBXFERTYPE_BULK: parm.type = VRDP_USB_TRANSFER_TYPE_BULK; break;
-        case VUSBXFERTYPE_INTR: parm.type = VRDP_USB_TRANSFER_TYPE_INTR; break;
-        case VUSBXFERTYPE_MSG:  parm.type = VRDP_USB_TRANSFER_TYPE_MSG;  break;
+        case VUSBXFERTYPE_CTRL: parm.type = VRDE_USB_TRANSFER_TYPE_CTRL; break;
+        case VUSBXFERTYPE_ISOC: parm.type = VRDE_USB_TRANSFER_TYPE_ISOC; break;
+        case VUSBXFERTYPE_BULK: parm.type = VRDE_USB_TRANSFER_TYPE_BULK; break;
+        case VUSBXFERTYPE_INTR: parm.type = VRDE_USB_TRANSFER_TYPE_INTR; break;
+        case VUSBXFERTYPE_MSG:  parm.type = VRDE_USB_TRANSFER_TYPE_MSG;  break;
         default: AssertFailed(); rc = VERR_INVALID_PARAMETER; goto l_leave;
     }
@@ -600 +600 @@
     switch(u8Direction)
     {
-        case VUSB_DIRECTION_SETUP: AssertFailed(); parm.direction = VRDP_USB_DIRECTION_SETUP; break;
-        case VUSB_DIRECTION_IN:    parm.direction = VRDP_USB_DIRECTION_IN;    break;
-        case VUSB_DIRECTION_OUT:   parm.direction = VRDP_USB_DIRECTION_OUT;   break;
+        case VUSB_DIRECTION_SETUP: AssertFailed(); parm.direction = VRDE_USB_DIRECTION_SETUP; break;
+        case VUSB_DIRECTION_IN:    parm.direction = VRDE_USB_DIRECTION_IN;    break;
+        case VUSB_DIRECTION_OUT:   parm.direction = VRDE_USB_DIRECTION_OUT;   break;
         default: AssertFailed(); rc = VERR_INVALID_PARAMETER; goto l_leave;
     }
@@ -619 +619 @@
     qurb->next       = NULL;
     qurb->prev       = pDevice->pTailQURBs;
-    qurb->u32Err     = VRDP_USB_XFER_OK;
+    qurb->u32Err     = VRDE_USB_XFER_OK;
     qurb->u32Len     = u32Len;
     qurb->pvData     = pvData;
@@ -678 +678 @@
     if (pThis->pollingEnabledURB ())
     {
-        VRDP_USB_REQ_REAP_URB_PARM parm;
-
-        parm.code = VRDP_USB_REQ_REAP_URB;
+        VRDE_USB_REQ_REAP_URB_PARM parm;
+
+        parm.code = VRDE_USB_REQ_REAP_URB;
 
         pThis->VRDPServer()->SendUSBRequest (pDevice->u32ClientId, &parm, sizeof (parm));
@@ -748 +748 @@
         if (pThis->pollingEnabledURB ())
         {
-            VRDP_USB_REQ_REAP_URB_PARM parm;
-
-            parm.code = VRDP_USB_REQ_REAP_URB;
+            VRDE_USB_REQ_REAP_URB_PARM parm;
+
+            parm.code = VRDE_USB_REQ_REAP_URB;
 
             pThis->VRDPServer()->SendUSBRequest (u32ClientId, &parm, sizeof (parm));
@@ -818 +818 @@
         case PollRemoteDevicesStatus_Negotiate:
         {
-            VRDPUSBREQNEGOTIATEPARM parm;
-
-            parm.code = VRDP_USB_REQ_NEGOTIATE;
-            parm.version = VRDP_USB_VERSION;
+            VRDEUSBREQNEGOTIATEPARM parm;
+
+            parm.code = VRDE_USB_REQ_NEGOTIATE;
+            parm.version = VRDE_USB_VERSION;
             parm.flags = 0;
 
@@ -849 +849 @@
 
             /* Send a request for device list. */
-            VRDP_USB_REQ_DEVICE_LIST_PARM parm;
-
-            parm.code = VRDP_USB_REQ_DEVICE_LIST;
+            VRDE_USB_REQ_DEVICE_LIST_PARM parm;
+
+            parm.code = VRDE_USB_REQ_DEVICE_LIST;
 
             mServer->SendUSBRequest (mu32ClientId, &parm, sizeof (parm));
@@ -864 +864 @@
             if (mfHasDeviceList)
             {
-                mConsole->processRemoteUSBDevices (mu32ClientId, (VRDPUSBDEVICEDESC *)mpvDeviceList, mcbDeviceList);
+                mConsole->processRemoteUSBDevices (mu32ClientId, (VRDEUSBDEVICEDESC *)mpvDeviceList, mcbDeviceList);
                 LogFlow(("USB::PollRemoteDevices: WaitResponse after process\n"));
 
@@ -950 +950 @@
     mpDevices (NULL),
     mfWillBeDeleted (false),
-    mClientVersion (0)                   /* VRDP_USB_VERSION_2: the client version. */
+    mClientVersion (0)                   /* VRDE_USB_VERSION_2: the client version. */
 {
     Assert(console);
@@ -991 +991 @@
 }
 
-int RemoteUSBBackend::negotiateResponse (const VRDPUSBREQNEGOTIATERET *pret, uint32_t cbRet)
+int RemoteUSBBackend::negotiateResponse (const VRDEUSBREQNEGOTIATERET *pret, uint32_t cbRet)
 {
     int rc = VINF_SUCCESS;
@@ -1000 +1000 @@
              pret->flags));
 
-    if (pret->flags & VRDP_USB_CAPS_FLAG_POLL)
+    if (pret->flags & VRDE_USB_CAPS_FLAG_POLL)
     {
         Log(("RemoteUSBBackend::negotiateResponse: client requested URB polling.\n"));
@@ -1010 +1010 @@
     }
 
-    /* VRDP_USB_VERSION_2: check the client version. */
-    if (pret->flags & VRDP_USB_CAPS2_FLAG_VERSION)
+    /* VRDE_USB_VERSION_2: check the client version. */
+    if (pret->flags & VRDE_USB_CAPS2_FLAG_VERSION)
     {
         /* This could be a client version > 1. */
-        if (cbRet >= sizeof (VRDPUSBREQNEGOTIATERET_2))
-        {
-            VRDPUSBREQNEGOTIATERET_2 *pret2 = (VRDPUSBREQNEGOTIATERET_2 *)pret;
-
-            if (pret2->u32Version <= VRDP_USB_VERSION)
+        if (cbRet >= sizeof (VRDEUSBREQNEGOTIATERET_2))
+        {
+            VRDEUSBREQNEGOTIATERET_2 *pret2 = (VRDEUSBREQNEGOTIATERET_2 *)pret;
+
+            if (pret2->u32Version <= VRDE_USB_VERSION)
             {
                 /* This is OK. The client wants a version supported by the server. */
@@ -1038 +1038 @@
     {
         /* This is a client version 1. */
-        mClientVersion = VRDP_USB_VERSION_1;
+        mClientVersion = VRDE_USB_VERSION_1;
     }
 
@@ -1085 +1085 @@
 }
 
-PREMOTEUSBDEVICE RemoteUSBBackend::deviceFromId (VRDPUSBDEVID id)
+PREMOTEUSBDEVICE RemoteUSBBackend::deviceFromId (VRDEUSBDEVID id)
 {
     request ();
@@ -1144 +1144 @@
     LogFlow(("RemoteUSBBackend::reapURB: pvBody = %p, cbBody = %d\n", pvBody, cbBody));
 
-    VRDPUSBREQREAPURBBODY *pBody = (VRDPUSBREQREAPURBBODY *)pvBody;
-
-    while (cbBody >= sizeof (VRDPUSBREQREAPURBBODY))
+    VRDEUSBREQREAPURBBODY *pBody = (VRDEUSBREQREAPURBBODY *)pvBody;
+
+    while (cbBody >= sizeof (VRDEUSBREQREAPURBBODY))
     {
         Log(("RemoteUSBBackend::reapURB: id = %d,  flags = %02X, error = %d, handle %d, len = %d.\n",
@@ -1153 +1153 @@
         uint8_t fu8ReapValidFlags;
 
-        if (mClientVersion == VRDP_USB_VERSION_1 || mClientVersion == VRDP_USB_VERSION_2)
-        {
-            fu8ReapValidFlags = VRDP_USB_REAP_VALID_FLAGS;
+        if (mClientVersion == VRDE_USB_VERSION_1 || mClientVersion == VRDE_USB_VERSION_2)
+        {
+            fu8ReapValidFlags = VRDE_USB_REAP_VALID_FLAGS;
         }
         else
         {
-            fu8ReapValidFlags = VRDP_USB_REAP_VALID_FLAGS_3;
+            fu8ReapValidFlags = VRDE_USB_REAP_VALID_FLAGS_3;
         }
 
         /* Verify client's data. */
         if (   (pBody->flags & ~fu8ReapValidFlags) != 0
-            || sizeof (VRDPUSBREQREAPURBBODY) > cbBody
+            || sizeof (VRDEUSBREQREAPURBBODY) > cbBody
             || pBody->handle == 0)
         {
@@ -1203 +1203 @@
 
             /* Update the URB error field. */
-            if (mClientVersion == VRDP_USB_VERSION_1)
+            if (mClientVersion == VRDE_USB_VERSION_1)
             {
                 switch(pBody->error)
                 {
-                    case VRDP_USB_XFER_OK:    qurb->u32Err = VUSBSTATUS_OK;    break;
-                    case VRDP_USB_XFER_STALL: qurb->u32Err = VUSBSTATUS_STALL; break;
-                    case VRDP_USB_XFER_DNR:   qurb->u32Err = VUSBSTATUS_DNR;   break;
-                    case VRDP_USB_XFER_CRC:   qurb->u32Err = VUSBSTATUS_CRC;   break;
+                    case VRDE_USB_XFER_OK:    qurb->u32Err = VUSBSTATUS_OK;    break;
+                    case VRDE_USB_XFER_STALL: qurb->u32Err = VUSBSTATUS_STALL; break;
+                    case VRDE_USB_XFER_DNR:   qurb->u32Err = VUSBSTATUS_DNR;   break;
+                    case VRDE_USB_XFER_CRC:   qurb->u32Err = VUSBSTATUS_CRC;   break;
                     default: Log(("RemoteUSBBackend::reapURB: Invalid error %d\n", pBody->error));
                                               qurb->u32Err = VUSBSTATUS_DNR;   break;
                 }
             }
-            else if (   mClientVersion == VRDP_USB_VERSION_2
-                     || mClientVersion == VRDP_USB_VERSION_3)
+            else if (   mClientVersion == VRDE_USB_VERSION_2
+                     || mClientVersion == VRDE_USB_VERSION_3)
             {
                 switch(pBody->error)
                 {
-                    case VRDP_USB_XFER_OK:    qurb->u32Err = VUSBSTATUS_OK;            break;
-                    case VRDP_USB_XFER_STALL: qurb->u32Err = VUSBSTATUS_STALL;         break;
-                    case VRDP_USB_XFER_DNR:   qurb->u32Err = VUSBSTATUS_DNR;           break;
-                    case VRDP_USB_XFER_CRC:   qurb->u32Err = VUSBSTATUS_CRC;           break;
-                    case VRDP_USB_XFER_DO:    qurb->u32Err = VUSBSTATUS_DATA_OVERRUN;  break;
-                    case VRDP_USB_XFER_DU:    qurb->u32Err = VUSBSTATUS_DATA_UNDERRUN; break;
+                    case VRDE_USB_XFER_OK:    qurb->u32Err = VUSBSTATUS_OK;            break;
+                    case VRDE_USB_XFER_STALL: qurb->u32Err = VUSBSTATUS_STALL;         break;
+                    case VRDE_USB_XFER_DNR:   qurb->u32Err = VUSBSTATUS_DNR;           break;
+                    case VRDE_USB_XFER_CRC:   qurb->u32Err = VUSBSTATUS_CRC;           break;
+                    case VRDE_USB_XFER_DO:    qurb->u32Err = VUSBSTATUS_DATA_OVERRUN;  break;
+                    case VRDE_USB_XFER_DU:    qurb->u32Err = VUSBSTATUS_DATA_UNDERRUN; break;
 
                     /* Unmapped errors. */
-                    case VRDP_USB_XFER_BS:
-                    case VRDP_USB_XFER_DTM:
-                    case VRDP_USB_XFER_PCF:
-                    case VRDP_USB_XFER_UPID:
-                    case VRDP_USB_XFER_BO:
-                    case VRDP_USB_XFER_BU:
-                    case VRDP_USB_XFER_ERR:
+                    case VRDE_USB_XFER_BS:
+                    case VRDE_USB_XFER_DTM:
+                    case VRDE_USB_XFER_PCF:
+                    case VRDE_USB_XFER_UPID:
+                    case VRDE_USB_XFER_BO:
+                    case VRDE_USB_XFER_BU:
+                    case VRDE_USB_XFER_ERR:
                     default: Log(("RemoteUSBBackend::reapURB: Invalid error %d\n", pBody->error));
                                               qurb->u32Err = VUSBSTATUS_DNR;   break;
@@ -1249 +1249 @@
             if (qurb->fInput)
             {
-                cbBodyData = pBody->len; /* VRDP_USB_DIRECTION_IN URBs include some data. */
+                cbBodyData = pBody->len; /* VRDE_USB_DIRECTION_IN URBs include some data. */
             }
 
@@ -1272 +1272 @@
 
                 if (   qurb->u32Err == VUSBSTATUS_OK
-                    && (pBody->flags & VRDP_USB_REAP_FLAG_FRAGMENT) != 0)
+                    && (pBody->flags & VRDE_USB_REAP_FLAG_FRAGMENT) != 0)
                 {
                     /* If the client sends fragmented packets, accumulate the URB data. */
@@ -1312 +1312 @@
         releaseDevice (pDevice);
 
-        if (pBody->flags & VRDP_USB_REAP_FLAG_LAST)
+        if (pBody->flags & VRDE_USB_REAP_FLAG_LAST)
         {
             break;
@@ -1318 +1318 @@
 
         /* There is probably a further URB body. */
-        uint32_t cbBodySize = sizeof (VRDPUSBREQREAPURBBODY) + cbBodyData;
+        uint32_t cbBodySize = sizeof (VRDEUSBREQREAPURBBODY) + cbBodyData;
 
         if (cbBodySize > cbBody)
@@ -1326 +1326 @@
         }
 
-        pBody = (VRDPUSBREQREAPURBBODY *)((uint8_t *)pBody + cbBodySize);
+        pBody = (VRDEUSBREQREAPURBBODY *)((uint8_t *)pBody + cbBodySize);
         cbBody -= cbBodySize;
     }

trunk/src/VBox/Main/RemoteUSBDeviceImpl.cpp

@@ -28 +28 @@
 #include <VBox/err.h>
 
-#include <VBox/vrdpapi.h>
+#include <VBox/RemoteDesktop/VRDE.h>
 #include <VBox/vrdpusb.h>
 
@@ -54 +54 @@
  * Initializes the remote USB device object.
  */
-HRESULT RemoteUSBDevice::init (uint32_t u32ClientId, VRDPUSBDEVICEDESC *pDevDesc)
+HRESULT RemoteUSBDevice::init (uint32_t u32ClientId, VRDEUSBDEVICEDESC *pDevDesc)
 {
     LogFlowThisFunc(("u32ClientId=%d,pDevDesc=%p\n", u32ClientId, pDevDesc));

trunk/src/VBox/Main/include/ConsoleImpl.h

@@ -39 +39 @@
 class Progress;
 
-#include <VBox/vrdpapi.h>
+#include <VBox/RemoteDesktop/VRDE.h>
 #include <VBox/pdmdrv.h>
 #ifdef VBOX_WITH_GUEST_PROPS
@@ -211 +211 @@
     void VRDPInterceptClipboard(uint32_t u32ClientId);
 
-    void processRemoteUSBDevices(uint32_t u32ClientId, VRDPUSBDEVICEDESC *pDevList, uint32_t cbDevList);
+    void processRemoteUSBDevices(uint32_t u32ClientId, VRDEUSBDEVICEDESC *pDevList, uint32_t cbDevList);
 
     // callback callers (partly; for some events console callbacks are notified

trunk/src/VBox/Main/include/ConsoleVRDPServer.h

@@ -97 +97 @@
     void EnableConnections (void);
     void DisconnectClient (uint32_t u32ClientId, bool fReconnect);
-    void MousePointerUpdate (const VRDPCOLORPOINTER *pPointer);
+    void MousePointerUpdate (const VRDECOLORPOINTER *pPointer);
     void MousePointerHide (void);
 
@@ -134 +134 @@
     void SendUpdateBitmap (unsigned uScreenId, uint32_t x, uint32_t y, uint32_t w, uint32_t h) const;
 
-    void SendAudioSamples (void *pvSamples, uint32_t cSamples, VRDPAUDIOFORMAT format) const;
+    void SendAudioSamples (void *pvSamples, uint32_t cSamples, VRDEAUDIOFORMAT format) const;
     void SendAudioVolume (uint16_t left, uint16_t right) const;
     void SendUSBRequest (uint32_t u32ClientId, void *pvParms, uint32_t cbParms) const;
@@ -147 +147 @@
 
 #ifdef VBOX_WITH_VRDP
-    HVRDPSERVER mhServer;
+    HVRDESERVER mhServer;
 
     static bool loadVRDPLibrary (void);
@@ -154 +154 @@
     static RTLDRMOD mVRDPLibrary;
 
-    static PFNVRDPCREATESERVER mpfnVRDPCreateServer;
-
-    static VRDPENTRYPOINTS_1 *mpEntryPoints;
-    static VRDPCALLBACKS_1 mCallbacks;
+    static PFNVRDECREATESERVER mpfnVRDPCreateServer;
+
+    static VRDEENTRYPOINTS_1 *mpEntryPoints;
+    static VRDECALLBACKS_1 mCallbacks;
 
     static DECLCALLBACK(int)  VRDPCallbackQueryProperty     (void *pvCallback, uint32_t index, void *pvBuffer, uint32_t cbBuffer, uint32_t *pcbOut);
@@ -166 +166 @@
     static DECLCALLBACK(int)  VRDPCallbackUSB               (void *pvCallback, void *pvIntercept, uint32_t u32ClientId, uint8_t u8Code, const void *pvRet, uint32_t cbRet);
     static DECLCALLBACK(int)  VRDPCallbackClipboard         (void *pvCallback, void *pvIntercept, uint32_t u32ClientId, uint32_t u32Function, uint32_t u32Format, const void *pvData, uint32_t cbData);
-    static DECLCALLBACK(bool) VRDPCallbackFramebufferQuery  (void *pvCallback, unsigned uScreenId, VRDPFRAMEBUFFERINFO *pInfo);
+    static DECLCALLBACK(bool) VRDPCallbackFramebufferQuery  (void *pvCallback, unsigned uScreenId, VRDEFRAMEBUFFERINFO *pInfo);
     static DECLCALLBACK(void) VRDPCallbackFramebufferLock   (void *pvCallback, unsigned uScreenId);
     static DECLCALLBACK(void) VRDPCallbackFramebufferUnlock (void *pvCallback, unsigned uScreenId);

trunk/src/VBox/Main/include/RemoteUSBBackend.h

@@ -21 +21 @@
 #include "RemoteUSBDeviceImpl.h"
 
-#include <VBox/vrdpapi.h>
+#include <VBox/RemoteDesktop/VRDE.h>
 #include <VBox/vrdpusb.h>
 
@@ -78 +78 @@
         int saveDeviceList (const void *pvList, uint32_t cbList);
 
-        int negotiateResponse (const VRDPUSBREQNEGOTIATERET *pret, uint32_t cbRet);
+        int negotiateResponse (const VRDEUSBREQNEGOTIATERET *pret, uint32_t cbRet);
 
         int reapURB (const void *pvBody, uint32_t cbBody);
@@ -85 +85 @@
         void release (void);
 
-        PREMOTEUSBDEVICE deviceFromId (VRDPUSBDEVID id);
+        PREMOTEUSBDEVICE deviceFromId (VRDEUSBDEVID id);
 
         void addDevice (PREMOTEUSBDEVICE pDevice);

trunk/src/VBox/Main/include/RemoteUSBDeviceImpl.h

@@ -24 +24 @@
 #include "VirtualBoxBase.h"
 
-struct _VRDPUSBDEVICEDESC;
-typedef _VRDPUSBDEVICEDESC VRDPUSBDEVICEDESC;
+struct _VRDEUSBDEVICEDESC;
+typedef _VRDEUSBDEVICEDESC VRDEUSBDEVICEDESC;
 
 class ATL_NO_VTABLE RemoteUSBDevice :
@@ -52 +52 @@
 
     // public initializer/uninitializer for internal purposes only
-    HRESULT init(uint32_t u32ClientId, VRDPUSBDEVICEDESC *pDevDesc);
+    HRESULT init(uint32_t u32ClientId, VRDEUSBDEVICEDESC *pDevDesc);
     void uninit();