815 lines
29 KiB
C++
815 lines
29 KiB
C++
#include "precomp.h"
|
|
|
|
|
|
//
|
|
// SDG.CPP
|
|
// Screen Data Grabber
|
|
// Sends OUTGOING screen data when hosting
|
|
//
|
|
// Copyright(c) Microsoft 1997-
|
|
//
|
|
|
|
#define MLZ_FILE_ZONE ZONE_CORE
|
|
|
|
//
|
|
// SDG_SendScreenDataArea()
|
|
//
|
|
void ASHost::SDG_SendScreenDataArea(LPBOOL pBackPressure, UINT * pcPackets)
|
|
{
|
|
UINT i;
|
|
BOOL fBltOK = TRUE;
|
|
RECT sdaRect[BA_NUM_RECTS];
|
|
UINT cRects;
|
|
BOOL backPressure = FALSE;
|
|
BOOL secondaryTransmit = FALSE;
|
|
|
|
DebugEntry(ASHost::SDG_SendScreenDataArea);
|
|
|
|
//
|
|
// Get the bounds of the screen data area. At entry this is always
|
|
// our primary transmission area. Even if we had already flushed
|
|
// the primary region and were in the middle of the secondary region
|
|
// we will switch back to the primary region if any more SD
|
|
// accumulates. In this way we keep our spoiling of the secondary
|
|
// screendata maximized.
|
|
//
|
|
BA_CopyBounds(sdaRect, &cRects, TRUE);
|
|
|
|
//
|
|
// If there is a pending rectangle that was unable to be sent on a
|
|
// previous transmission then try to send it first.
|
|
//
|
|
// Leave the lossy flag as it was at the last pass
|
|
//
|
|
if (m_sdgRectIsPending)
|
|
{
|
|
TRACE_OUT(( "Sending pending rectangle"));
|
|
m_sdgRectIsPending = FALSE;
|
|
|
|
//
|
|
// Try to send the pending rectangle. SDGSplitBlt... will remove
|
|
// any portions of it that are sent successfully. We will add all
|
|
// the rest of the SDA back to the bounds in the loop below
|
|
//
|
|
if (!SDGSplitBltToNetwork(&m_sdgPendingRect, pcPackets))
|
|
{
|
|
fBltOK = FALSE;
|
|
m_sdgRectIsPending = TRUE;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// The pending rectangle was successfully sent.
|
|
//
|
|
TRACE_OUT(( "Sent pending rect"));
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
// We have copied the primary transmit region so now move the secondary
|
|
// transmit bounds into the screendata bounds because when we send data
|
|
// in the primary transmission we want to accumulate any rectangles
|
|
// that need subsequent retransmission. The retransmit bounds are
|
|
// generally different from the original SD bounds because the
|
|
// compression function is permitted to override our lossy request for
|
|
// any portion of the data if it finds that the data is pretty
|
|
// compressible anyway. In this way we end up with retransmission of
|
|
// embedded photos etc, but the toolbars/buttons are only sent once.
|
|
//
|
|
// For the non-lossy case the secondary bounds will always be null,
|
|
// so there is no point in special casing here.
|
|
//
|
|
if (fBltOK)
|
|
{
|
|
for (i = 0; i < m_sdgcLossy; i++)
|
|
{
|
|
TRACE_OUT(("Setting up pseudo-primary bounds {%d, %d, %d, %d}",
|
|
m_asdgLossyRect[i].left, m_asdgLossyRect[i].top,
|
|
m_asdgLossyRect[i].right, m_asdgLossyRect[i].bottom ));
|
|
|
|
//
|
|
// Add the rectangle into the bounds.
|
|
//
|
|
BA_AddRect(&m_asdgLossyRect[i]);
|
|
}
|
|
|
|
//
|
|
// If there is no primary bitmap data to send then send the
|
|
// secondary data. If none of that either then just exit
|
|
//
|
|
if (cRects == 0)
|
|
{
|
|
|
|
BA_CopyBounds(sdaRect, &cRects, TRUE);
|
|
if (cRects == 0)
|
|
{
|
|
DC_QUIT;
|
|
}
|
|
else
|
|
{
|
|
TRACE_OUT(("Starting secondary transmission now"));
|
|
secondaryTransmit = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Process each of the supplied rectangles in turn.
|
|
//
|
|
TRACE_OUT(( "%d SDA rectangles", cRects));
|
|
|
|
for (i = 0; i < cRects; i++)
|
|
{
|
|
TRACE_OUT(("Rect %d: {%d, %d, %d, %d}", i,
|
|
sdaRect[i].left, sdaRect[i].top, sdaRect[i].right, sdaRect[i].bottom ));
|
|
|
|
//
|
|
// Clip the rectangle to the physical screen and reject totally
|
|
// any rectangle that refers to data that has now been scrolled off
|
|
// the physical screen as a result of a desktop scroll between the
|
|
// time the rectangle was accumulated and now.
|
|
//
|
|
if (sdaRect[i].left < 0)
|
|
{
|
|
if (sdaRect[i].right < 0)
|
|
{
|
|
//
|
|
// This was scrolled off the physical screen by a desktop
|
|
// scroll.
|
|
//
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Partially off screen - just clip the left edge.
|
|
//
|
|
sdaRect[i].left = 0;
|
|
}
|
|
|
|
if (sdaRect[i].top < 0)
|
|
{
|
|
if (sdaRect[i].bottom < 0)
|
|
{
|
|
//
|
|
// This was scrolled off the physical screen by a desktop
|
|
// scroll.
|
|
//
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Partially off screen - just clip the top edge.
|
|
//
|
|
sdaRect[i].top = 0;
|
|
}
|
|
|
|
if (sdaRect[i].right >= m_pShare->m_pasLocal->cpcCaps.screen.capsScreenWidth)
|
|
{
|
|
if (sdaRect[i].left >= m_pShare->m_pasLocal->cpcCaps.screen.capsScreenWidth)
|
|
{
|
|
//
|
|
// This was scrolled off the physical screen by a desktop
|
|
// scroll.
|
|
//
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Partially off screen - just clip the right edge.
|
|
//
|
|
sdaRect[i].right = m_pShare->m_pasLocal->cpcCaps.screen.capsScreenWidth-1;
|
|
}
|
|
|
|
if (sdaRect[i].bottom >= m_pShare->m_pasLocal->cpcCaps.screen.capsScreenHeight)
|
|
{
|
|
if (sdaRect[i].top >= m_pShare->m_pasLocal->cpcCaps.screen.capsScreenHeight)
|
|
{
|
|
//
|
|
// This was scrolled off the physical screen by a desktop
|
|
// scroll.
|
|
//
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Partially off screen - just clip the bottom edge.
|
|
//
|
|
sdaRect[i].bottom = m_pShare->m_pasLocal->cpcCaps.screen.capsScreenHeight-1;
|
|
}
|
|
|
|
|
|
//
|
|
// If all of the previous rectangles have been successfully sent
|
|
// then try to send this rectangle.
|
|
// If a previous rectangle failed to be sent then we don't bother
|
|
// trying to send the rest of the rectangles in the same batch -
|
|
// they are added back into the SDA so that they will be sent later.
|
|
//
|
|
if (fBltOK)
|
|
{
|
|
fBltOK = SDGSplitBltToNetwork(&(sdaRect[i]), pcPackets);
|
|
|
|
//
|
|
// On the first blit failure we must transfer the posible
|
|
// secondary transmit bounds over to the save area for next
|
|
// time because down below we are going to add back any unsent
|
|
// transmit rectangles to the primary SD area.
|
|
//
|
|
// Dont worry if this was a secondary transmit because these
|
|
// bounds will be zero and will be overwritten when we copy
|
|
// the current SDA region to the secondary area for our next
|
|
// pass
|
|
//
|
|
if (!fBltOK && !secondaryTransmit)
|
|
{
|
|
TRACE_OUT(("Send failed so getting new secondary bounds"));
|
|
BA_CopyBounds(m_asdgLossyRect, &m_sdgcLossy, TRUE);
|
|
}
|
|
}
|
|
|
|
if (!fBltOK)
|
|
{
|
|
//
|
|
// The blt to network failed - probably because a network
|
|
// packet could not be allocated.
|
|
// We add the rectangle back into the SDA so that we will try
|
|
// to retransmit the area later.
|
|
//
|
|
|
|
TRACE_OUT(("Blt failed - add back rect {%d, %d, %d, %d}",
|
|
sdaRect[i].left,
|
|
sdaRect[i].top,
|
|
sdaRect[i].right,
|
|
sdaRect[i].bottom ));
|
|
|
|
//
|
|
// Add the rectangle into the bounds.
|
|
//
|
|
BA_AddRect(&(sdaRect[i]));
|
|
|
|
backPressure = TRUE;
|
|
|
|
}
|
|
}
|
|
|
|
//
|
|
// If all went fine and we were sending primary transmit data then we
|
|
// should just go back and send secondary data, using the bounds which
|
|
// are located in the SD area at the moment. We can do this by copying
|
|
// these secondary bounds to the save area, where they will be used at
|
|
// the next schedule pass. It is a good idea to yield, because we may
|
|
// be about to accumulate some more primary data.
|
|
//
|
|
if (fBltOK || secondaryTransmit)
|
|
{
|
|
TRACE_OUT(("Done with the primary bounds so getting pseudo-primary to secondary"));
|
|
BA_CopyBounds(m_asdgLossyRect, &m_sdgcLossy, TRUE);
|
|
}
|
|
|
|
DC_EXIT_POINT:
|
|
*pBackPressure = backPressure;
|
|
DebugExitVOID(ASHost::SDG_SendScreenDataArea);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
// SDGSplitBltToNetwork(..)
|
|
//
|
|
// Sends the specified rectangle over the network.
|
|
//
|
|
// The Screen Data rects that we can send over the network are limited
|
|
// to certain sizes (determined by the sizes of the Transfer Bitmaps).
|
|
// If necessary, this function splits the rect into smaller sub-rectangles
|
|
// for transmission.
|
|
//
|
|
// PARAMETERS:
|
|
//
|
|
// pRect - pointer to the rectangle to send.
|
|
//
|
|
// RETURNS:
|
|
//
|
|
// TRUE - rectangle was successfully sent. Supplied rectangle is updated
|
|
// to be NULL.
|
|
//
|
|
// FALSE - rectangle was not completely sent. Supplied rectangle is
|
|
// updated to contain the area that was NOT sent.
|
|
//
|
|
//
|
|
BOOL ASHost::SDGSplitBltToNetwork(LPRECT pRect, UINT * pcPackets)
|
|
{
|
|
RECT smallRect;
|
|
UINT maxHeight;
|
|
BOOL rc;
|
|
|
|
DebugEntry(ASHost::SDGSplitBltToNetwork);
|
|
|
|
//
|
|
// Loop processing strips.
|
|
//
|
|
while (pRect->top <= pRect->bottom)
|
|
{
|
|
smallRect = *pRect;
|
|
|
|
//
|
|
// Split the given rectangles into multiple smaller rects if
|
|
// necessary. If it is wider than our 256 byte work bitmap then
|
|
// switch to the mega 1024 byte one first.
|
|
//
|
|
|
|
// Note that the calculations don't work for VGA...
|
|
maxHeight = max(8, m_usrSendingBPP);
|
|
|
|
if ((smallRect.right-smallRect.left+1) > MEGA_X_SIZE)
|
|
{
|
|
maxHeight = MaxBitmapHeight(MEGA_WIDE_X_SIZE, maxHeight);
|
|
}
|
|
else
|
|
{
|
|
maxHeight = MaxBitmapHeight(MEGA_X_SIZE, maxHeight);
|
|
}
|
|
|
|
if ((unsigned)(smallRect.bottom - smallRect.top + 1) > maxHeight)
|
|
{
|
|
//
|
|
// Split the rectangle to bring the height within the correct
|
|
// range.
|
|
//
|
|
TRACE_OUT(( "Split Y size(%d) by maxHeight(%d)",
|
|
smallRect.bottom - smallRect.top,
|
|
maxHeight));
|
|
smallRect.bottom = smallRect.top + maxHeight - 1;
|
|
}
|
|
|
|
|
|
while ((pRect->right - smallRect.left + 1) > 0)
|
|
{
|
|
if (!SDGSmallBltToNetwork(&smallRect))
|
|
{
|
|
TRACE_OUT(( "Small blt failed"));
|
|
rc = FALSE;
|
|
DC_QUIT;
|
|
}
|
|
else
|
|
{
|
|
++(*pcPackets);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Move to the next strip.
|
|
//
|
|
pRect->top = smallRect.bottom+1;
|
|
|
|
}
|
|
|
|
rc = TRUE;
|
|
|
|
DC_EXIT_POINT:
|
|
if (!rc)
|
|
{
|
|
//
|
|
// A small blt failed. If we return FALSE then the supplied
|
|
// rectangle will be added back into the SDA bounds so that it will
|
|
// be retransmitted later.
|
|
//
|
|
// However, we want to avoid the situation where we have sent the
|
|
// top left-hand corner of a rectangle and then add the remainder
|
|
// back into the SDA bounds, because this could cause the original
|
|
// bounding rectangle to be regenerated (because the bounds are
|
|
// stored in a fixed number of rectangles).
|
|
//
|
|
// Therefore if we are not on the last strip of the rectangle then
|
|
// we keep the current strip as a "pending" rectangle. The
|
|
// supplied rectangle is adjusted to remove the whole of this
|
|
// strip. Next time this function is called the pending rectangle
|
|
// will be sent before anything else.
|
|
//
|
|
// If we are on the last strip (which will be the normal case -
|
|
// there will usually only be one strip) then we update the
|
|
// supplied rectangle to be the area that has not been sent and
|
|
// return FALSE to indicate that it must be added back into the
|
|
// SDA.
|
|
//
|
|
if (m_sdgRectIsPending)
|
|
{
|
|
ERROR_OUT(( "Unexpected small blt failure with pending rect"));
|
|
}
|
|
else
|
|
{
|
|
if (smallRect.bottom == pRect->bottom)
|
|
{
|
|
//
|
|
// This is the last strip. Adjust the supplied rect to
|
|
// contain the area that has not been sent.
|
|
//
|
|
pRect->top = smallRect.top;
|
|
pRect->left = smallRect.left;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// This is not the last strip Copy the remainder of the
|
|
// current strip into the pending rect.
|
|
//
|
|
smallRect.right = pRect->right;
|
|
m_sdgPendingRect = smallRect;
|
|
m_sdgRectIsPending = TRUE;
|
|
|
|
//
|
|
// Adjust the supplied rectangle to contain the remaining
|
|
// area that we have not sent and is not covered by the
|
|
// pending rect.
|
|
//
|
|
pRect->top = smallRect.bottom+1;
|
|
}
|
|
}
|
|
}
|
|
|
|
DebugExitBOOL(ASHost::SDGSplitBltToNetwork, rc);
|
|
return(rc);
|
|
}
|
|
|
|
|
|
//
|
|
// FUNCTION: SDGSmallBltToNetwork
|
|
//
|
|
// DESCRIPTION:
|
|
//
|
|
// Sends the screen data within the specified rectangle across the network.
|
|
//
|
|
// PARAMETERS:
|
|
//
|
|
// pRect - pointer to the rectangle (in screen coords) to send as Screen
|
|
// Data.
|
|
//
|
|
// RETURNS:
|
|
//
|
|
// TRUE - screen data successfully sent
|
|
//
|
|
// FALSE - screen data could not be sent. Caller should retry later.
|
|
//
|
|
//
|
|
|
|
//
|
|
// BOGUS BUGBUG LAURABU!
|
|
// This function affects the results on the screen! If drawing happens
|
|
// between the time we realize the palette then unrealize it, it will look
|
|
// messed up. You can easily see this in Visio 4.5 when it is in the
|
|
// foreground (in the background, NM controls the colors so no effect).
|
|
//
|
|
BOOL ASHost::SDGSmallBltToNetwork(LPRECT pRect)
|
|
{
|
|
BOOL fLossy = FALSE;
|
|
HDC hdcDesktop;
|
|
HBITMAP hBitmap = NULL;
|
|
HBITMAP hOldBitmap = NULL;
|
|
UINT width;
|
|
UINT height;
|
|
UINT fixedWidth;
|
|
PSDPACKET pSDPacket = NULL;
|
|
BITMAPINFO_ours bitmapInfo;
|
|
UINT sizeBitmapPkt;
|
|
UINT sizeBitmap;
|
|
HPALETTE hpalOldDIB = NULL;
|
|
HPALETTE hpalOldDesktop = NULL;
|
|
HPALETTE hpalLocal;
|
|
BOOL fPacketSent = FALSE;
|
|
RECT smallRect;
|
|
int useWidth;
|
|
#ifdef _DEBUG
|
|
UINT sentSize;
|
|
#endif // _DEBUG
|
|
|
|
DebugEntry(ASHost::SDGSmallBltToNetwork);
|
|
|
|
hdcDesktop = GetDC(NULL);
|
|
if (!hdcDesktop)
|
|
{
|
|
DC_QUIT;
|
|
}
|
|
width = pRect->right - pRect->left + 1;
|
|
height = pRect->bottom - pRect->top + 1;
|
|
|
|
//
|
|
// Determine the width of the work buffer and the width that we
|
|
// will be sending this time
|
|
//
|
|
fixedWidth = ((width + 15) / 16) * 16;
|
|
useWidth = width;
|
|
if (fixedWidth > MAX_X_SIZE)
|
|
{
|
|
if (fixedWidth > MEGA_X_SIZE)
|
|
{
|
|
fixedWidth = MEGA_WIDE_X_SIZE;
|
|
if (width > MEGA_WIDE_X_SIZE)
|
|
{
|
|
useWidth = fixedWidth;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
fixedWidth = MEGA_X_SIZE;
|
|
if (width > MEGA_X_SIZE)
|
|
{
|
|
useWidth = fixedWidth;
|
|
}
|
|
}
|
|
}
|
|
|
|
switch (fixedWidth)
|
|
{
|
|
case 16:
|
|
hBitmap = m_pShare->m_usrBmp16;
|
|
break;
|
|
|
|
case 32:
|
|
hBitmap = m_pShare->m_usrBmp32;
|
|
break;
|
|
|
|
case 48:
|
|
hBitmap = m_pShare->m_usrBmp48;
|
|
break;
|
|
|
|
case 64:
|
|
hBitmap = m_pShare->m_usrBmp64;
|
|
break;
|
|
|
|
case 80:
|
|
hBitmap = m_pShare->m_usrBmp80;
|
|
break;
|
|
|
|
case 96:
|
|
hBitmap = m_pShare->m_usrBmp96;
|
|
break;
|
|
|
|
case 112:
|
|
hBitmap = m_pShare->m_usrBmp112;
|
|
break;
|
|
|
|
case 128:
|
|
hBitmap = m_pShare->m_usrBmp128;
|
|
break;
|
|
|
|
case 256:
|
|
hBitmap = m_pShare->m_usrBmp256;
|
|
break;
|
|
|
|
case 1024:
|
|
hBitmap = m_pShare->m_usrBmp1024;
|
|
break;
|
|
|
|
default:
|
|
ERROR_OUT(( "Invalid bitmap size(%d)", fixedWidth));
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Initialise the BITMAPINFO_ours local structure header contents.
|
|
// This structure will be used in the GetDIBits calls but only the
|
|
// header part of the structure will be sent across the network, the
|
|
// color table is sent via the Palette Manager.
|
|
//
|
|
m_pShare->USR_InitDIBitmapHeader((BITMAPINFOHEADER *)&bitmapInfo, m_usrSendingBPP);
|
|
|
|
bitmapInfo.bmiHeader.biWidth = fixedWidth;
|
|
bitmapInfo.bmiHeader.biHeight = height;
|
|
|
|
//
|
|
// Calculate the size of the bitmap packet in BYTES.
|
|
//
|
|
sizeBitmap = BYTES_IN_BITMAP(fixedWidth, height, bitmapInfo.bmiHeader.biBitCount);
|
|
|
|
sizeBitmapPkt = sizeof(SDPACKET) + sizeBitmap - 1;
|
|
ASSERT(sizeBitmapPkt <= TSHR_MAX_SEND_PKT);
|
|
|
|
//
|
|
// Allocate a packet for the bitmap data.
|
|
//
|
|
// *** NB. This assumes that this code is called ONLY when there ***
|
|
// *** no unacknowledged bitmaps packets floating around the ***
|
|
// *** network layer. This means, at the moment, if this code is ***
|
|
// *** called due to anything other than a WM_TIMER ***
|
|
// *** message we're in trouble. ***
|
|
//
|
|
//
|
|
pSDPacket = (PSDPACKET)m_pShare->SC_AllocPkt(PROT_STR_UPDATES, g_s20BroadcastID,
|
|
sizeBitmapPkt);
|
|
if (!pSDPacket)
|
|
{
|
|
//
|
|
// Failed to allocate the bitmap packet - clear up and exit adding
|
|
// the rectangle back into the bounds.
|
|
//
|
|
TRACE_OUT(("Failed to alloc SDG packet, size %u", sizeBitmapPkt));
|
|
DC_QUIT;
|
|
}
|
|
|
|
//
|
|
// Since we are bltting off the screen, which by definition is using
|
|
// the system palette, we place the system palette in both DC's (so
|
|
// that the bitblt we are about to do will not do any color
|
|
// conversion).
|
|
//
|
|
|
|
//
|
|
// This will determine if the palette changed since the last time we
|
|
// sent one to the remote.
|
|
//
|
|
if (m_usrSendingBPP <= 8)
|
|
{
|
|
hpalLocal = PM_GetLocalPalette();
|
|
}
|
|
|
|
hOldBitmap = SelectBitmap(m_usrWorkDC, hBitmap);
|
|
|
|
if (m_usrSendingBPP <= 8)
|
|
{
|
|
hpalOldDIB = SelectPalette(m_usrWorkDC, hpalLocal, FALSE);
|
|
RealizePalette(m_usrWorkDC);
|
|
}
|
|
|
|
//
|
|
// We can now do a bitblt from the screen (hpDesktop) to memory and the
|
|
// bits are untranslated.
|
|
//
|
|
// We then do a GetDIBits using the local palette which returns us the
|
|
// bits at the correct bits per pel, (and with properly translated
|
|
// colors) in order to transmit the data.
|
|
//
|
|
BitBlt(m_usrWorkDC, 0, 0, useWidth, height, hdcDesktop,
|
|
pRect->left, pRect->top, SRCCOPY);
|
|
|
|
//
|
|
// Zero any unused space on the right side to aid compression.
|
|
//
|
|
if (width < fixedWidth)
|
|
{
|
|
PatBlt(m_usrWorkDC, width, 0, fixedWidth - width, height, BLACKNESS);
|
|
}
|
|
|
|
//
|
|
// Do a GetDIBits into our global stash of memory for now. We will try
|
|
// and compress this data into our packet after.
|
|
//
|
|
GetDIBits(m_usrWorkDC, hBitmap, 0, height, m_pShare->m_usrPBitmapBuffer,
|
|
(PBITMAPINFO)&bitmapInfo, DIB_RGB_COLORS);
|
|
|
|
//
|
|
// Deselect the bitmap
|
|
//
|
|
SelectBitmap(m_usrWorkDC, hOldBitmap);
|
|
|
|
//
|
|
// Get the color table directly from the system since we can't trust
|
|
// any palette realization color stuff via the messages at this stage.
|
|
// We only need to do this on an 8bpp host sending 8bpp data.
|
|
//
|
|
if ((g_usrScreenBPP == 8) && (m_usrSendingBPP == 8))
|
|
{
|
|
PM_GetSystemPaletteEntries(bitmapInfo.bmiColors);
|
|
}
|
|
|
|
if (m_usrSendingBPP <= 8)
|
|
{
|
|
//
|
|
// Whack old palettes back.
|
|
//
|
|
SelectPalette(m_usrWorkDC, hpalOldDIB, FALSE);
|
|
}
|
|
|
|
//
|
|
// Fill in packet contents and send it.
|
|
//
|
|
pSDPacket->header.header.data.dataType = DT_UP;
|
|
pSDPacket->header.updateType = UPD_SCREEN_DATA;
|
|
|
|
//
|
|
// Send Virtual desktop coordinates.
|
|
//
|
|
pSDPacket->position.left = (TSHR_INT16)(pRect->left);
|
|
pSDPacket->position.right = (TSHR_INT16)(pRect->left + useWidth - 1);
|
|
|
|
pSDPacket->position.top = (TSHR_INT16)(pRect->top);
|
|
pSDPacket->position.bottom = (TSHR_INT16)(pRect->bottom);
|
|
|
|
pSDPacket->realWidth = (TSHR_UINT16)fixedWidth;
|
|
pSDPacket->realHeight = (TSHR_UINT16)height;
|
|
|
|
pSDPacket->format = (TSHR_UINT16)m_usrSendingBPP;
|
|
pSDPacket->compressed = FALSE;
|
|
|
|
//
|
|
// Compress the bitmap data
|
|
//
|
|
if (m_pShare->BC_CompressBitmap(m_pShare->m_usrPBitmapBuffer,
|
|
pSDPacket->data,
|
|
&sizeBitmap,
|
|
fixedWidth,
|
|
height,
|
|
bitmapInfo.bmiHeader.biBitCount,
|
|
&fLossy) )
|
|
{
|
|
//
|
|
// We have successfully compressed the bitmap data into our packet
|
|
// data buffer.
|
|
//
|
|
pSDPacket->compressed = TRUE;
|
|
|
|
//
|
|
// Write the updated size of the data into the header.
|
|
//
|
|
pSDPacket->dataSize = (TSHR_UINT16)sizeBitmap;
|
|
|
|
//
|
|
// Now update the size of the total data (including header)
|
|
//
|
|
sizeBitmapPkt = sizeof(SDPACKET) + sizeBitmap - 1;
|
|
pSDPacket->header.header.dataLength = sizeBitmapPkt - sizeof(S20DATAPACKET)
|
|
+ sizeof(DATAPACKETHEADER);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// The compression failed so just copy the uncompressed data from
|
|
// the global buffer to the packet and send it uncompressed.
|
|
//
|
|
TRACE_OUT(("Failed to compress bitmap of size %d cx(%d) cy(%d) bpp(%d)",
|
|
sizeBitmap, fixedWidth, height, bitmapInfo.bmiHeader.biBitCount));
|
|
|
|
memcpy(pSDPacket->data,
|
|
m_pShare->m_usrPBitmapBuffer,
|
|
sizeBitmap );
|
|
|
|
//
|
|
// Write the size of the data into the header.
|
|
//
|
|
pSDPacket->dataSize = (TSHR_UINT16)sizeBitmap;
|
|
}
|
|
|
|
TRACE_OUT(("Sending %d bytes of screen data", sizeBitmap));
|
|
|
|
if (m_pShare->m_scfViewSelf)
|
|
m_pShare->UP_ReceivedPacket(m_pShare->m_pasLocal, &(pSDPacket->header.header));
|
|
|
|
#ifdef _DEBUG
|
|
sentSize =
|
|
#endif // _DEBUG
|
|
m_pShare->DCS_CompressAndSendPacket(PROT_STR_UPDATES, g_s20BroadcastID,
|
|
&(pSDPacket->header.header), sizeBitmapPkt);
|
|
|
|
TRACE_OUT(("SDG packet size: %08d, sent: %08d", sizeBitmapPkt, sentSize));
|
|
|
|
//
|
|
// We have sent the packet.
|
|
//
|
|
fPacketSent = TRUE;
|
|
|
|
//
|
|
// If it was lossy then we must accumulate the area for resend. We
|
|
// accumulate it into the current SDA because we know this was cleared
|
|
// before the transmission started. We will then move the accumulated
|
|
// non-lossy rectangles to a save area before we return.
|
|
//
|
|
if (fLossy)
|
|
{
|
|
//
|
|
// Convert the rect back into Virtual Desktop coords.
|
|
//
|
|
smallRect = *pRect;
|
|
smallRect.right = smallRect.left + useWidth - 1;
|
|
WARNING_OUT(( "Lossy send so add non-lossy area (%d,%d)(%d,%d)",
|
|
smallRect.left,
|
|
smallRect.top,
|
|
smallRect.right,
|
|
smallRect.bottom ));
|
|
|
|
//
|
|
// Add the rectangle into the bounds.
|
|
//
|
|
BA_AddRect(&(smallRect));
|
|
}
|
|
|
|
//
|
|
// Now we modify the supplied rectangle to exclude the area just sent
|
|
//
|
|
pRect->left = pRect->left + useWidth;
|
|
TRACE_OUT(("Rect now {%d, %d, %d, %d}", pRect->left, pRect->top,
|
|
pRect->right,
|
|
pRect->bottom ));
|
|
|
|
DC_EXIT_POINT:
|
|
if (hdcDesktop != NULL)
|
|
{
|
|
ReleaseDC(NULL, hdcDesktop);
|
|
}
|
|
|
|
DebugExitBOOL(ASHost::SDGSmallBltToNetwork, fPacketSent);
|
|
return(fPacketSent);
|
|
}
|
|
|
|
|
|
|