#include "precomp.h" // // OA.C // Order Accumulation, both cpi32 and display driver sides // // Copyright(c) Microsoft 1997- // // // OA_DDProcessRequest - see oa.h // BOOL OA_DDProcessRequest ( UINT fnEscape, LPOSI_ESCAPE_HEADER pRequest, DWORD cbRequest ) { BOOL rc; DebugEntry(OA_DDProcessRequest); // // Get the request number. // switch (fnEscape) { case OA_ESC_FLOW_CONTROL: { if (cbRequest != sizeof(OA_FLOW_CONTROL)) { ERROR_OUT(("OA_DDProcessRequest: Invalid size %d for OA_ESC_FLOW_CONTROL", cbRequest)); rc = FALSE; DC_QUIT; } // // Save new order accum throughput value // g_oaFlow = ((LPOA_FLOW_CONTROL)pRequest)->oaFlow; rc = TRUE; } break; default: { ERROR_OUT(("Unrecognized OA escape")); rc = FALSE; } break; } DC_EXIT_POINT: DebugExitBOOL(OA_DDProcessRequest, rc); return(rc); } // // // OA_DDAddOrder(..) // // Adds an order to the queue for transmission. // // If the new order is completetly covered by the current SDA then // it is spoilt. // // If the order is opaque and overlaps earlier orders it may clip // or spoil them. // // Called by the GDI interception code. // // void OA_DDAddOrder(LPINT_ORDER pNewOrder, void FAR * pExtraInfo) { RECT SDARects[BA_NUM_RECTS*2]; UINT cBounds; UINT spoilingBounds; UINT totalBounds; UINT i; RECT SrcRect; RECT tmpRect; BOOL gotBounds = FALSE; int dx; int dy; RECT IntersectedSrcRect; RECT InvalidDstRect; LPINT_ORDER pTmpOrder; LPEXTTEXTOUT_ORDER pExtTextOut; LPOA_SHARED_DATA lpoaShared; LPOA_FAST_DATA lpoaFast; DebugEntry(OA_DDAddOrder); lpoaShared = OA_SHM_START_WRITING; lpoaFast = OA_FST_START_WRITING; // // Accumulate order accumulation rate. We are interested in how // quickly orders are being added to the buffer, so that we can tell // DCS scheduling whether frequent sends are advisable // SHM_CheckPointer(&lpoaFast->ordersAccumulated); lpoaFast->ordersAccumulated++; // // If the order is a private one, then we just add it to the Order // List and return immediately. // // Private Orders are used to send bitmap cache information (bitmap // bits and color tables). // // Private Orders never spoil any others and must never be spoilt. // if (pNewOrder->OrderHeader.Common.fOrderFlags & OF_PRIVATE) { TRACE_OUT(("Add private order (%lx)", pNewOrder)); OADDAppendToOrderList(lpoaShared, pNewOrder); DC_QUIT; } // // If this order is spoilable and its is completely enclosed by the // current screen data area, we can spoil it. Unless... // // PM - Performance // // We have observed in usability testing that clipping orders always // degrades the end-user's perceived performance. This is because the // orders flow much faster than the screendata and tend to relate to // text, which is what the user really wants to see. For example, text // overwriting a bitmap will be delayed because we want to send the // bitmap as screendata. // // Also, word documents tend to contain sections of screendata due to // mismatched fonts, intelliquotes, spelling annotation, current line // memblit. Nothing we can do about this, but if we page down two or // three times, or down and up again we get an accumulation of the // screendata on all the pages spoiling the orders and the end result // is that we have to wait longer than we would if we had not spoiled // the orders. // // So, what we can do instead is leave the text orders in and overwrite // them with screendata when it gets through. However, to make this // really effective what we also do is convert any transparent text // (as WEB browsers tend to use) into opaque text on a default // background. // // if ((pNewOrder->OrderHeader.Common.fOrderFlags & OF_SPOILABLE) != 0) { // // Get the driver's current bounds. // BA_CopyBounds(SDARects, &cBounds, FALSE); gotBounds = TRUE; for (i = 0; i < cBounds ; i++) { if ( OADDCompleteOverlapRect(&pNewOrder->OrderHeader.Common.rcsDst, &(SDARects[i])) ) { // // The destination of the order is completely covered by // the SDA. Check for a text order. // pExtTextOut = (LPEXTTEXTOUT_ORDER)pNewOrder->abOrderData; if (pExtTextOut->type == ORD_EXTTEXTOUT_TYPE) { // // The order is going to be completely overwritten so // we can play around with it all we like. // Just make it opaque so the user can read it while // waiting for the screendata to follow on. // pExtTextOut->fuOptions |= ETO_OPAQUE; // // pExtTextOut->rectangle is a TSHR_RECT32 // pExtTextOut->rectangle.left = pNewOrder->OrderHeader.Common.rcsDst.left; pExtTextOut->rectangle.top = pNewOrder->OrderHeader.Common.rcsDst.top; pExtTextOut->rectangle.right = pNewOrder->OrderHeader.Common.rcsDst.right; pExtTextOut->rectangle.bottom = pNewOrder->OrderHeader.Common.rcsDst.bottom; TRACE_OUT(("Converted text order to opaque")); break; } else { TRACE_OUT(("Spoiling order by SDA")); OA_DDFreeOrderMem(pNewOrder); DC_QUIT; } } } } // // Pass the order onto the Bitmap Cache Controller to try to cache the // src bitmap. // if (ORDER_IS_MEMBLT(pNewOrder) || ORDER_IS_MEM3BLT(pNewOrder)) { if (!SBC_DDCacheMemScreenBlt(pNewOrder, pExtraInfo)) { // // The memory to screen blt cannot be handled as an order (the // source bitmap could not cached). Add the destination of the // blt into the SDA and discard the order. // TRACE_OUT(("Failed to cache mem->screen blt")); TRACE_OUT(("Add rect to SDA (%d,%d)(%d,%d)", pNewOrder->OrderHeader.Common.rcsDst.left, pNewOrder->OrderHeader.Common.rcsDst.top, pNewOrder->OrderHeader.Common.rcsDst.right, pNewOrder->OrderHeader.Common.rcsDst.bottom )); RECT_FROM_TSHR_RECT16(&tmpRect, pNewOrder->OrderHeader.Common.rcsDst); OA_DDFreeOrderMem(pNewOrder); BA_AddScreenData(&tmpRect); DC_QUIT; } else { TRACE_OUT(("Cached MEMBLT targetted at (%d,%d)(%d,%d)", pNewOrder->OrderHeader.Common.rcsDst.left, pNewOrder->OrderHeader.Common.rcsDst.top, pNewOrder->OrderHeader.Common.rcsDst.right, pNewOrder->OrderHeader.Common.rcsDst.bottom )); } } if (ORDER_IS_SCRBLT(pNewOrder)) { // // // Handle Screen to Screen (SS) bitblts. // // The basic plan // -------------- // // If the source of a screen to screen blt intersects with the // current SDA then we have to do some additional work because all // orders are always executed before the SDA is copied. This means // that the data within the SDA will not be available at the time // we want to do the SS blt. // // In this situation we adjust the SS blt to remove all overlap // from the src rectangle. The destination rectangle is adjusted // accordingly. The area removed from the destination rectangle is // added into the SDA. // // TRACE_OUT(("Handle SS blt(%lx)", pNewOrder)); // // Make the order non-spoilable because we don't want the adding // of screen data to delete the order. // pNewOrder->OrderHeader.Common.fOrderFlags &= ~OF_SPOILABLE; // // Calculate the src rect. // SrcRect.left = ((LPSCRBLT_ORDER)&pNewOrder->abOrderData)->nXSrc; SrcRect.right = SrcRect.left + ((LPSCRBLT_ORDER)&pNewOrder->abOrderData)->nWidth - 1; SrcRect.top = ((LPSCRBLT_ORDER)&pNewOrder->abOrderData)->nYSrc; SrcRect.bottom = SrcRect.top + ((LPSCRBLT_ORDER)&pNewOrder->abOrderData)->nHeight - 1; // // // ORIGINAL SCRBLT SCHEME // ---------------------- // // If the source rectangle intersects the current Screen Data Area // (SDA) then the src rectangle is modified so that no there is no // intersection with the SDA, and the dst rectangle adjusted // accordingly (this is the theory - in practice the operation // remains the same and we just adjust the dst clip rectangle). // The destination area that is removed is added into the SDA. // // The code works, but can result in more screen data being sent // than is required. // // e.g. // // Operation: // // SSSSSS DDDDDD // SSSSSS -> DDDDDD // SSSSSS DDDDDD // SxSSSS DDDDDD // // S - src rect // D - dst rect // x - SDA overlap // // The bottom edge of the blt is trimmed off, and the corresponding // destination area added into the SDA. // // SSSSSS DDDDDD // SSSSSS -> DDDDDD // SSSSSS DDDDDD // xxxxxx // // // // NEW SCRBLT SCHEME // ------------------ // // The new scheme does not modify the blt rectangles, and just // maps the SDA overlap to the destination rect and adds that // area back into the SDA. // // e.g. (as above) // // Operation: // // SSSSSS DDDDDD // SSSSSS -> DDDDDD // SSSSSS DDDDDD // SxSSSS DDDDDD // // S - src rect // D - dst rect // x - SDA overlap // // The blt operation remains the same, but the overlap area is // mapped to the destination rectangle and added into the SDA. // // SSSSSS DDDDDD // SSSSSS -> DDDDDD // SSSSSS DDDDDD // SxSSSS DxDDDD // // // This scheme results in a smaller SDA area. However, this scheme // does blt potentially invalid data to the destination - which // may briefly be visible at the remote machine (because orders // are replayed before Screen Data). This has not (yet) proved to // be a problem. // // The main benefit of the new scheme is when scrolling an area // that includes a small SDA. // // new old // scheme scheme // // AAAAAAAA AAAAAAAA AAAAAAAA // AAAAAAAA AAAxAAAA xxxxxxxx // AAAAAAAA scroll up 3 times -> AAAxAAAA xxxxxxxx // AAAAAAAA AAAxAAAA xxxxxxxx // AAAxAAAA AAAxAAAA xxxxxxxx // // // if (!gotBounds) { // // Get the driver's current bounds. // BA_CopyBounds(SDARects, &cBounds, FALSE); } // // Now get any bounds which the share core is currently processing. // We have to include these bounds when we are doing the above // processing to avoid a situation where the core grabs the screen // data from the source of a ScrBlt after the source has been // updated by another order. // // e.g. If there is no driver SDA, but the core is processing the // area marked 'c'... // // If we ignore the core SDA, we queue a ScrBlt order which does // the following. // // SSSSSS DDDDDD // SccccS -> DDDDDD // SccccS DDDDDD // SSSSSS DDDDDD // // However, if another order (marked 'N') is accumulated before // the core grabs the SDA, we end up with the shadow doing the // following // // SSSSSS DDDDDD // ScNNcS -> DDNNDD // ScNNcS DDNNDD // SSSSSS DDDDDD // // i.e. the new order gets copied to the destination of the ScrBlt. // So, the ScrBlt order must be processed as // // SSSSSS DDDDDD // SccccS -> DxxxxD // SccccS DxxxxD // SSSSSS DDDDDD // // BA_QuerySpoilingBounds(&SDARects[cBounds], &spoilingBounds); totalBounds = cBounds + spoilingBounds; // // // This is the new SCRBLT handler. // // for (i = 0; i < totalBounds ; i++) { if ( (SrcRect.left >= SDARects[i].left) && (SrcRect.right <= SDARects[i].right) && (SrcRect.top >= SDARects[i].top) && (SrcRect.bottom <= SDARects[i].bottom) ) { // // The src of the SS blt is completely within the SDA. We // must add in the whole destination rectangle into the SDA // and spoil the SS blt. // TRACE_OUT(("SS blt src within SDA - spoil it")); RECT_FROM_TSHR_RECT16(&tmpRect, pNewOrder->OrderHeader.Common.rcsDst); OA_DDFreeOrderMem(pNewOrder); BA_AddScreenData(&tmpRect); DC_QUIT; } // // Intersect the src rect with the SDA rect. // IntersectedSrcRect.left = max( SrcRect.left, SDARects[i].left ); IntersectedSrcRect.right = min( SrcRect.right, SDARects[i].right ); IntersectedSrcRect.top = max( SrcRect.top, SDARects[i].top ); IntersectedSrcRect.bottom = min( SrcRect.bottom, SDARects[i].bottom ); dx = ((LPSCRBLT_ORDER)&pNewOrder->abOrderData)->nLeftRect - ((LPSCRBLT_ORDER)&pNewOrder->abOrderData)->nXSrc; dy = ((LPSCRBLT_ORDER)&pNewOrder->abOrderData)->nTopRect - ((LPSCRBLT_ORDER)&pNewOrder->abOrderData)->nYSrc; InvalidDstRect.left = IntersectedSrcRect.left + dx; InvalidDstRect.right = IntersectedSrcRect.right + dx; InvalidDstRect.top = IntersectedSrcRect.top + dy; InvalidDstRect.bottom = IntersectedSrcRect.bottom + dy; // // Intersect the invalid destination rectangle with the // destination clip rectangle. // InvalidDstRect.left = max( InvalidDstRect.left, pNewOrder->OrderHeader.Common.rcsDst.left ); InvalidDstRect.right = min( InvalidDstRect.right, pNewOrder->OrderHeader.Common.rcsDst.right ); InvalidDstRect.top = max( InvalidDstRect.top, pNewOrder->OrderHeader.Common.rcsDst.top ); InvalidDstRect.bottom = min( InvalidDstRect.bottom, pNewOrder->OrderHeader.Common.rcsDst.bottom ); if ( (InvalidDstRect.left <= InvalidDstRect.right) && (InvalidDstRect.top <= InvalidDstRect.bottom) ) { // // Add the invalid area into the SDA. // BA_AddScreenData(&InvalidDstRect); } } // for (i = 0; i < totalBounds ; i++) // // Make the order spoilable again (this assumes that all SS blts // are spoilable. // pNewOrder->OrderHeader.Common.fOrderFlags |= OF_SPOILABLE; } // if (ORDER_IS_SCRBLT(pNewOrder)) else if ((pNewOrder->OrderHeader.Common.fOrderFlags & OF_DESTROP) != 0) { // // This is the case where the output of the order depends on the // existing contents of the target area (e.g. an invert). // // What we have to do here is to add any parts of the destination // of this order which intersect the SDA which the share core is // processing to the driver SDA. The reason for this is the same // as the SCRBLT case - the share core may grab the data from the // screen after we have applied this order (e.g. after we have // inverted an area of the screen), then send the order as well // (re-inverting the area of the screen). // // Note that we only have to worry about the SDA which the share // core is processing - we can ignore the driver's SDA. // TRACE_OUT(("Handle dest ROP (%#.8lx)", pNewOrder)); BA_QuerySpoilingBounds(SDARects, &spoilingBounds); for (i = 0; i < spoilingBounds ; i++) { // // Intersect the dest rect with the share core SDA rect. // InvalidDstRect.left = max( SDARects[i].left, pNewOrder->OrderHeader.Common.rcsDst.left ); InvalidDstRect.right = min( SDARects[i].right, pNewOrder->OrderHeader.Common.rcsDst.right ); InvalidDstRect.top = max( SDARects[i].top, pNewOrder->OrderHeader.Common.rcsDst.top ); InvalidDstRect.bottom = min( SDARects[i].bottom, pNewOrder->OrderHeader.Common.rcsDst.bottom ); if ( (InvalidDstRect.left <= InvalidDstRect.right) && (InvalidDstRect.top <= InvalidDstRect.bottom) ) { // // Add the invalid area into the SDA. // TRACE_OUT(("Adding to SDA (%d,%d) (%d,%d)", InvalidDstRect.left, InvalidDstRect.top, InvalidDstRect.right, InvalidDstRect.bottom)); BA_AddScreenData(&InvalidDstRect); } } } // // Add the new order to the end of the Order List. // OADDAppendToOrderList(lpoaShared, pNewOrder); TRACE_OUT(("Append order(%lx) to list", pNewOrder)); // // Now see if this order spoils any existing orders // if ((pNewOrder->OrderHeader.Common.fOrderFlags & OF_SPOILER) != 0) { // // Its a spoiler, so try to spoil with it. // // We have to pass in the bounding rectangle of the order, and the // first order to try to spoil to OADDSpoilFromOrder. The first // order to try to spoil is the one before the new order. // RECT_FROM_TSHR_RECT16(&tmpRect, pNewOrder->OrderHeader.Common.rcsDst); pTmpOrder = COM_BasedListPrev(&lpoaShared->orderListHead, pNewOrder, FIELD_OFFSET(INT_ORDER, OrderHeader.list)); OADDSpoilFromOrder(lpoaShared, pTmpOrder, &tmpRect); } // // This is where the Win95 product would call DCS_TriggerEarlyTimer. // DC_EXIT_POINT: OA_FST_STOP_WRITING; OA_SHM_STOP_WRITING; DebugExitVOID(OA_DDAddOrder); } // // // FUNCTION: OA_DDAllocOrderMem // // DESCRIPTION: // // Allocates memory for an internal order structure from our own private // Order Heap. // // Allocates any Additional Order Memory from global memory. A pointer to // the Additional Order Memory is stored within the allocated order's // header (pOrder->OrderHeader.pAdditionalOrderData). // // // PARAMETERS: // // cbOrderDataLength - length in bytes of the order data to be allocated // from the Order Heap. // // cbAdditionalOrderDataLength - length in bytes of additional order data // to be allocated from Global Memory. If this parameter is zero no // additional order memory is allocated. // // // RETURNS: // // A pointer to the allocated order memory. NULL if the memory allocation // failed. // // // LPINT_ORDER OA_DDAllocOrderMem(UINT cbOrderDataLength, UINT cbAdditionalOrderDataLength) { LPINT_ORDER pOrder = NULL; LPINT_ORDER pFirstOrder; LPINT_ORDER pTailOrder; RECT tferRect; int targetSize; UINT moveOffset; UINT moveBytes; LPINT_ORDER pColorTableOrder = NULL; LPBYTE pNextOrderPos; LPOA_SHARED_DATA lpoaShared; DebugEntry(OA_DDAllocOrderMem); lpoaShared = OA_SHM_START_WRITING; // // PM Performance // // Although turning order accumulation off does clear the pipe, ready // for us to get the screendata over the wire as soon as we can, it // actually hinders end-user responsiveness because they see a longer // interval when nothing is happening, rather than getting feedback // that we are busy and the whole thing taking longer! // // So, what we do when we fill up the order buffer is we discard half // the orders in the buffer, adding them to the screendata. In this // way we will always keep between 50 and 100% of the orders for the // final updates to the window, which hopefully will be what the user // really wants to see. // // If the orders keep coming then we will keep on accumulating some, // sending them, discarding others until things quiet down, at which // point we will flush out our order buffer. // // When we come to flush the order buffer we also spoil the early ones // against screendata, so that we only have the final set of orders to // replay. We control the size of this final non-spoiled set depending // on whether we are running over a high or low speed connection. // Also, if we did not encounter any back pressure during the session // then we do not purge any orders at all, preferring to send // everything we possibly can as orders. // // Note that this approach assumes that we do not spoil all orders // against screendata on the fly because that leads to us generally // sending out-of-data orders followed by up-to-date screendata, which // is exactly what we do not want to see. // // // // First check that we have not already exceeded our high water mark // recommended by flow control. If we have then purge half the queue // so we have space to accumulate the later, more valuable, orders // // Note that this does not guarantee that we will have less orders // accumulated than the limit set by flow control. However, if enough // orders are generated, we will come through this branch on each order // and finally reduce to below the imposed limit. // SHM_CheckPointer(&lpoaShared->totalOrderBytes); if (g_oaPurgeAllowed && (lpoaShared->totalOrderBytes > (DWORD)(g_oaFlow == OAFLOW_FAST ? OA_FAST_HEAP : OA_SLOW_HEAP))) { RECT aRects[BA_NUM_RECTS]; UINT numRects; UINT i; WARNING_OUT(("Purging orders; total 0x%08x is greater than heap 0x%08x", lpoaShared->totalOrderBytes, (g_oaFlow == OAFLOW_FAST ? OA_FAST_HEAP : OA_SLOW_HEAP))); // // // If we need to make room for the new order then purge half the // current queue. We do this so we end up with the most recent // orders on the queue, rather than the oldest. // SHM_CheckPointer(&lpoaShared->totalOrderBytes); targetSize = lpoaShared->totalOrderBytes / 2; TRACE_OUT(("Target size %ld", targetSize)); // // Iterate through the list until we have found the first order // beyond the limit to be destroyed. Once we have got this order, // we can shuffle the list over the useless orders. // SHM_CheckPointer(&lpoaShared->orderListHead); pOrder = COM_BasedListFirst(&lpoaShared->orderListHead, FIELD_OFFSET(INT_ORDER, OrderHeader.list)); pTailOrder = (LPINT_ORDER)COM_BasedPrevListField(&lpoaShared->orderListHead); // // If we hit this condition, we have to have at least one order // pending, so these both must be non NULL. // SHM_CheckPointer(pOrder); SHM_CheckPointer(pTailOrder); TRACE_OUT(("Order 0x%08lx, tail 0x%08lx", pOrder, pTailOrder)); // // Disable spoiling of existing orders by screen data while we do // the purge otherwise we may try to spoil an order which we are // purging ! // g_baSpoilByNewSDAEnabled = FALSE; while ((pOrder != NULL) && (targetSize > 0)) { // // Can't check at end; COM_BasedListNext may return NULL and // SHM_CheckPointer doesn't like that. // SHM_CheckPointer(pOrder); // // Check to see if this is an internal color table order. If // it is, the OF_INTERNAL flag will be set. // // MemBlt orders rely on being preceeded by a color table order // to set up the colors correctly. If we purge all the color // table orders, the following Mem(3)Blts will get the wrong // colors. So, we have to keep track of the last color table // order to be purged and then add it back into the order heap // later. // if ((pOrder->OrderHeader.Common.fOrderFlags & OF_INTERNAL) != 0) { TRACE_OUT(("Found color table order at %#.8lx", pOrder)); pColorTableOrder = pOrder; } else { // // Add the order to the Screen Data Area // TRACE_OUT(("Purging orders. Add rect to SDA (%d,%d)(%d,%d)", pOrder->OrderHeader.Common.rcsDst.left, pOrder->OrderHeader.Common.rcsDst.top, pOrder->OrderHeader.Common.rcsDst.right, pOrder->OrderHeader.Common.rcsDst.bottom)); RECT_FROM_TSHR_RECT16(&tferRect, pOrder->OrderHeader.Common.rcsDst); BA_AddScreenData(&tferRect); } // // Keep track of how much data still needs removing. // targetSize -= INT_ORDER_SIZE(pOrder); lpoaShared->totalHeapOrderBytes -= INT_ORDER_SIZE(pOrder); lpoaShared->totalOrderBytes -= MAX_ORDER_SIZE(pOrder); // // If the order is a Mem(3)Blt, we have to tell SBC that we are // getting rid of it. // if (ORDER_IS_MEMBLT(pOrder) || ORDER_IS_MEM3BLT(pOrder)) { SBC_DDOrderSpoiltNotification(pOrder); } // // Get the next order to be removed. // pOrder = COM_BasedListNext(&lpoaShared->orderListHead, pOrder, FIELD_OFFSET(INT_ORDER, OrderHeader.list)); } TRACE_OUT(("Stopped at order %#.8lx", pOrder)); // // Orders have been transferred to SDA, so now we have to // - move the last purged color table order (if there is one) to // the start of the order heap // - shuffle up the heap // - reset the pointers. // // pOrder points to the first non-purged order. // if (pOrder != NULL) { SHM_CheckPointer(&lpoaShared->orderHeap); SHM_CheckPointer(&lpoaShared->orderListHead); pNextOrderPos = lpoaShared->orderHeap; // // If we purged (at least) one color table order, move the last // color table order to the start of the order heap. // if (pColorTableOrder != NULL) { TRACE_OUT(("Moving color table from %#.8lx to start", pColorTableOrder)); RtlMoveMemory(pNextOrderPos, pColorTableOrder, INT_ORDER_SIZE(pColorTableOrder)); pColorTableOrder = (LPINT_ORDER)pNextOrderPos; lpoaShared->totalHeapOrderBytes += INT_ORDER_SIZE(pColorTableOrder); lpoaShared->totalOrderBytes += MAX_ORDER_SIZE(pColorTableOrder); pNextOrderPos += INT_ORDER_SIZE(pColorTableOrder); // // Chain the order into the start of the order list. Just // do the pointers to and from the list head for now, we // will do the rest later. // lpoaShared->orderListHead.next = PTRBASE_TO_OFFSET(pColorTableOrder, &lpoaShared->orderListHead); pColorTableOrder->OrderHeader.list.prev = PTRBASE_TO_OFFSET(&lpoaShared->orderListHead, pColorTableOrder); } // // Move the heap up to the top of the buffer. The following // diagram illustrates how the order heap is split up at the // moment. // // OA_SHM_NEXTORDER // |<컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴�>| // // moveOffset moveBytes // |<컴컴컴컴컴컴컴�>|<컴컴컴컴컴컴컴컴�>| // // �袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴敲 // � � � � � // � � purged � remaining � unused � // � � orders � orders � � // � � � � � � // 훤妄袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴� // ^ � ^ ^ // � � � � // � � � � // � � � 읕� pOrder // � � � // � � 읕컴 pNextOrderPos // � � // � 읕컴컴 color table order // � // 읕컴컴컴 lpoaShared->orderHeap (pColorTableOrder) // // If there is no color table order, pNextOrderPos is equal to // lpoaShared->orderHeap. // // moveOffset is the number of bytes to move the remaining // orders by. // // moveBytes is the number of bytes to be moved. // // moveOffset = (UINT)((UINT_PTR)pOrder - (UINT_PTR)pNextOrderPos); moveBytes = (UINT)(lpoaShared->nextOrder - moveOffset - (pNextOrderPos - lpoaShared->orderHeap)); TRACE_OUT(("Moving %d bytes", moveBytes)); RtlMoveMemory(pNextOrderPos, pOrder, moveBytes); // // Update the head and tail pointers to reflect their new // positions. // pFirstOrder = (LPINT_ORDER)pNextOrderPos; pTailOrder = (LPINT_ORDER)((LPBYTE)pTailOrder - moveOffset); SHM_CheckPointer(pFirstOrder); SHM_CheckPointer(pTailOrder); TRACE_OUT(("New first unpurged %#.8lx, tail %#.8lx", pFirstOrder, pTailOrder)); // // Since the offsets are relative to the order pointer, we only // need to modify the start and end offsets. // // Unfortunately, the possibility of a color table order at the // start of the heap complicates the chaining of pFirstOrder. // If there is a color table order, we chain pFirstOrder to the // color table order, otherwise we chain it to the start of the // order list. // lpoaShared->orderListHead.prev = PTRBASE_TO_OFFSET(pTailOrder, &lpoaShared->orderListHead); pTailOrder->OrderHeader.list.next = PTRBASE_TO_OFFSET(&lpoaShared->orderListHead, pTailOrder); if (pColorTableOrder != NULL) { pColorTableOrder->OrderHeader.list.next = PTRBASE_TO_OFFSET(pFirstOrder, pColorTableOrder); pFirstOrder->OrderHeader.list.prev = PTRBASE_TO_OFFSET(pColorTableOrder, pFirstOrder); } else { lpoaShared->orderListHead.next = PTRBASE_TO_OFFSET(pFirstOrder, &lpoaShared->orderListHead); pFirstOrder->OrderHeader.list.prev = PTRBASE_TO_OFFSET(&lpoaShared->orderListHead, pFirstOrder); } // // Sort out where the next order to be allocated will go // lpoaShared->nextOrder -= moveOffset; } else { // // No orders left - this happens if we've had lots of spoiling. // We have now cleared out all the valid orders so let's // re-initialise the heap for next time. // OA_DDResetOrderList(); } // // Now re-enable the spoiling of orders by SDA. // g_baSpoilByNewSDAEnabled = TRUE; WARNING_OUT(("Purged orders, total is now 0x%08x", lpoaShared->totalOrderBytes)); // // Lastly, spoil the remaining orders by the screen data. // If we've gotten this far, there's a lot of data being sent // and/or we're slow. So nuke 'em. // BA_CopyBounds(aRects, &numRects, FALSE); for (i = 0; i < numRects; i++) { OA_DDSpoilOrdersByRect(aRects+i); } WARNING_OUT(("Spoiled remaining orders by SDA, total is now 0x%08x", lpoaShared->totalOrderBytes)); TRACE_OUT(("Next 0x%08lx", lpoaShared->nextOrder)); TRACE_OUT(("Head 0x%08lx", lpoaShared->orderListHead.next)); TRACE_OUT(("Tail 0x%08lx", lpoaShared->orderListHead.prev)); TRACE_OUT(("Total heap bytes 0x%08lx", lpoaShared->totalHeapOrderBytes)); TRACE_OUT(("Total order bytes 0x%08lx", lpoaShared->totalOrderBytes)); } pOrder = OADDAllocOrderMemInt(lpoaShared, cbOrderDataLength, cbAdditionalOrderDataLength); if ( pOrder != NULL ) { // // Update the count of total order data. // SHM_CheckPointer(&lpoaShared->totalHeapOrderBytes); lpoaShared->totalHeapOrderBytes += sizeof(INT_ORDER_HEADER) + cbOrderDataLength; SHM_CheckPointer(&lpoaShared->totalAdditionalOrderBytes); lpoaShared->totalAdditionalOrderBytes += cbAdditionalOrderDataLength; } TRACE_OUT(("Alloc order, addr %lx, size %u", pOrder, cbOrderDataLength)); OA_SHM_STOP_WRITING; DebugExitPVOID(OA_DDAllocOrderMem, pOrder); return(pOrder); } // // // FUNCTION: OA_DDFreeOrderMem // // // DESCRIPTION: // // Frees order memory from our own private heap. // Frees any Additional Order Memory associated with this order. // // // PARAMETERS: // // pOrder - pointer to the order to be freed. // // // RETURNS: // // Nothing. // // void OA_DDFreeOrderMem(LPINT_ORDER pOrder) { LPOA_SHARED_DATA lpoaShared; DebugEntry(OA_DDFreeOrderMem); ASSERT(pOrder); lpoaShared = OA_SHM_START_WRITING; TRACE_OUT(("Free order %lx", pOrder)); // // Update the data totals. // SHM_CheckPointer(&lpoaShared->totalHeapOrderBytes); lpoaShared->totalHeapOrderBytes -= (sizeof(INT_ORDER_HEADER) + pOrder->OrderHeader.Common.cbOrderDataLength); SHM_CheckPointer(&lpoaShared->totalAdditionalOrderBytes); lpoaShared->totalAdditionalOrderBytes -= pOrder->OrderHeader.cbAdditionalOrderDataLength; // // Do the work. // OADDFreeOrderMemInt(lpoaShared, pOrder); OA_SHM_STOP_WRITING; DebugExitVOID(OA_DDFreeOrderMem); } // // // FUNCTION: OA_DDResetOrderList // // // DESCRIPTION: // // Frees all Orders and Additional Order Data in the Order List. // Frees up the Order Heap memory. // // // PARAMETERS: // // None. // // // RETURNS: // // Nothing. // // void OA_DDResetOrderList(void) { LPOA_SHARED_DATA lpoaShared; DebugEntry(OA_DDResetOrderList); lpoaShared = OA_SHM_START_WRITING; // // First free all the orders on the list. // OADDFreeAllOrders(lpoaShared); // // Ensure that the list pointers are NULL. // SHM_CheckPointer(&lpoaShared->orderListHead); if ((lpoaShared->orderListHead.next != 0) || (lpoaShared->orderListHead.prev != 0)) { ERROR_OUT(("Non-NULL list pointers (%lx)(%lx)", lpoaShared->orderListHead.next, lpoaShared->orderListHead.prev)); SHM_CheckPointer(&lpoaShared->orderListHead); COM_BasedListInit(&lpoaShared->orderListHead); } OA_SHM_STOP_WRITING; DebugExitVOID(OA_DDResetOrderList); } // // OA_DDSyncUpdatesNow // // Called when a sync operation is required. // // Discards all outstanding orders. // void OA_DDSyncUpdatesNow(void) { DebugEntry(OA_SyncUpdatesNow); OADDFreeAllOrders(g_poaData[g_asSharedMemory->displayToCore.currentBuffer]); DebugExitVOID(OA_DDSyncUpdatesNow); } // // // OA_DDRemoveListOrder(..) // // Removes the specified order from the Order List by marking it as spoilt. // // Returns: // Pointer to the order following the removed order. // // LPINT_ORDER OA_DDRemoveListOrder(LPINT_ORDER pCondemnedOrder) { LPINT_ORDER pSaveOrder; LPOA_SHARED_DATA lpoaShared; DebugEntry(OA_DDRemoveListOrder); TRACE_OUT(("Remove list order (%lx)", pCondemnedOrder)); lpoaShared = OA_SHM_START_WRITING; SHM_CheckPointer(pCondemnedOrder); // // Check for a valid order. // if (pCondemnedOrder->OrderHeader.Common.fOrderFlags & OF_SPOILT) { TRACE_OUT(("Invalid order")); DC_QUIT; } // // Get the offset value of this order. // SHM_CheckPointer(&lpoaShared->orderHeap); // // Mark the order as spoilt. // pCondemnedOrder->OrderHeader.Common.fOrderFlags |= OF_SPOILT; // // Update the count of bytes currently in the Order List. // SHM_CheckPointer(&lpoaShared->totalOrderBytes); lpoaShared->totalOrderBytes -= (UINT)MAX_ORDER_SIZE(pCondemnedOrder); // // SAve the order so we can remove it from the linked list after having // got the next element in the chain. // pSaveOrder = pCondemnedOrder; // // Return the next order in the list. // SHM_CheckPointer(&lpoaShared->orderListHead); pCondemnedOrder = COM_BasedListNext(&lpoaShared->orderListHead, pCondemnedOrder, FIELD_OFFSET(INT_ORDER, OrderHeader.list)); if (pSaveOrder == pCondemnedOrder) { ERROR_OUT(("Order list has gone circular !")); } // // Delete the unwanted order from the linked list. // COM_BasedListRemove(&pSaveOrder->OrderHeader.list); // // Check that the list is still consistent with the total number of // order bytes. // if ( (lpoaShared->orderListHead.next != 0) && (lpoaShared->orderListHead.prev != 0) && (lpoaShared->totalOrderBytes == 0) ) { ERROR_OUT(("List head wrong: %ld %ld", lpoaShared->orderListHead.next, lpoaShared->orderListHead.prev)); COM_BasedListInit(&lpoaShared->orderListHead); pCondemnedOrder = NULL; } DC_EXIT_POINT: OA_SHM_STOP_WRITING; DebugExitPVOID(OA_DDRemoveListOrder, pCondemnedOrder); return(pCondemnedOrder); } // // OA_DDSpoilOrdersByRect - see oa.h // void OA_DDSpoilOrdersByRect(LPRECT pRect) { LPOA_SHARED_DATA lpoaShared; LPINT_ORDER pOrder; DebugEntry(OA_DDSpoilOrdersByRect); lpoaShared = OA_SHM_START_WRITING; // // We want to start spoiling from the newest order i.e. the one at the // end of the order list. // pOrder = COM_BasedListLast(&lpoaShared->orderListHead, FIELD_OFFSET(INT_ORDER, OrderHeader.list)); if (pOrder != NULL) { OADDSpoilFromOrder(lpoaShared, pOrder, pRect); } OA_SHM_STOP_WRITING; DebugExitVOID(OA_DDSpoilOrdersByRect); } // // // OADDAppendToOrderList(..) // // Commits an allocated order to the end of the Order List. The order must // NOT be freed once it has been added. The whole list must be invalidated // to free the committed orders. // // void OADDAppendToOrderList(LPOA_SHARED_DATA lpoaShared, LPINT_ORDER pNewOrder) { DebugEntry(OADDAppendToOrderList); // // Chain entry is already set up so all we do is keep track of // committed orders. // // // Store the total number of order bytes used. // SHM_CheckPointer(&lpoaShared->totalOrderBytes); lpoaShared->totalOrderBytes += (UINT)MAX_ORDER_SIZE(pNewOrder); DebugExitVOID(OADDAppendToOrderList); } // // // FUNCTION: OADDAllocOrderMemInt // // DESCRIPTION: // // Allocates memory for an internal order structure from our order heap. // // // PARAMETERS: // // cbOrderDataLength - length in bytes of the order data to be allocated // from the Order Heap. // // cbAdditionalOrderDataLength - length in bytes of additional order data // to be allocated. If this parameter is zero no additional order memory // is allocated. // // // RETURNS: // // A pointer to the allocated order memory. NULL if the memory allocation // failed. // // // LPINT_ORDER OADDAllocOrderMemInt ( LPOA_SHARED_DATA lpoaShared, UINT cbOrderDataLength, UINT cbAdditionalOrderDataLength ) { LPINT_ORDER pOrder = NULL; UINT cbOrderSize; DebugEntry(OADDAllocOrderMemInt); // // If the additional data will take us over our Additional Data Limit // then fail the memory allocation. // SHM_CheckPointer(&lpoaShared->totalAdditionalOrderBytes); if ((lpoaShared->totalAdditionalOrderBytes + cbAdditionalOrderDataLength) > MAX_ADDITIONAL_DATA_BYTES) { TRACE_OUT(("Hit Additional Data Limit, current %lu addint %u", lpoaShared->totalAdditionalOrderBytes, cbAdditionalOrderDataLength)); DC_QUIT; } // // Calculate the number of bytes we need to allocate (including the // order header). Round up to the nearest 4 bytes to keep the 4 byte // alignment for the next order. // cbOrderSize = sizeof(INT_ORDER_HEADER) + cbOrderDataLength; cbOrderSize = (cbOrderSize + 3) & 0xFFFFFFFC; // // Make sure we don't overrun our heap limit // SHM_CheckPointer(&lpoaShared->nextOrder); if (lpoaShared->nextOrder + cbOrderSize > OA_HEAP_MAX) { TRACE_OUT(("Heap limit hit")); DC_QUIT; } // // Construct a far pointer to the allocated memory, and fill in the // length field in the Order Header. // SHM_CheckPointer(&lpoaShared->orderHeap); pOrder = (LPINT_ORDER)(lpoaShared->orderHeap + lpoaShared->nextOrder); pOrder->OrderHeader.Common.cbOrderDataLength = (TSHR_UINT16)cbOrderDataLength; // // Update the order header to point to the next section of free heap. // SHM_CheckPointer(&lpoaShared->nextOrder); lpoaShared->nextOrder += cbOrderSize; // // Allocate any Additional Order Memory from Global Memory. // if (cbAdditionalOrderDataLength > 0) { // // Make sure we don't overrun our heap limit // SHM_CheckPointer(&lpoaShared->nextOrder); if (lpoaShared->nextOrder + cbAdditionalOrderDataLength > OA_HEAP_MAX) { TRACE_OUT(("Heap limit hit for additional data")); // // Clear the allocated order and quit. // SHM_CheckPointer(&lpoaShared->nextOrder); lpoaShared->nextOrder -= cbOrderSize; pOrder = NULL; DC_QUIT; } // // Store the space for the additional data. // SHM_CheckPointer(&lpoaShared->nextOrder); pOrder->OrderHeader.additionalOrderData = lpoaShared->nextOrder; pOrder->OrderHeader.cbAdditionalOrderDataLength = (WORD)cbAdditionalOrderDataLength; // // Update the next order pointer to point to the next 4-byte // boundary. // SHM_CheckPointer(&lpoaShared->nextOrder); lpoaShared->nextOrder += cbAdditionalOrderDataLength + 3; lpoaShared->nextOrder &= 0xFFFFFFFC; } else { pOrder->OrderHeader.additionalOrderData = 0; pOrder->OrderHeader.cbAdditionalOrderDataLength = 0; } // // Create the chain entry. // SHM_CheckPointer(&lpoaShared->orderListHead); COM_BasedListInsertBefore(&lpoaShared->orderListHead, &pOrder->OrderHeader.list); DC_EXIT_POINT: DebugExitPVOID(OADDAllocOrderMemInit, pOrder); return(pOrder); } // // // FUNCTION: OADDFreeOrderMemInt // // // DESCRIPTION: // // Frees order memory from our orders heap. Frees any Additional Order // Memory associated with this order. This must NOT be used on an order // that has been committed to the order list. // // // PARAMETERS: // // pOrder - pointer to the order to be freed. // // // RETURNS: // // Nothing. // // void OADDFreeOrderMemInt(LPOA_SHARED_DATA lpoaShared, LPINT_ORDER pOrder) { LPINT_ORDER pOrderTail; DebugEntry(OADDFreeOrderMemInt); // // The order heap is real a misnomer. We know that the memory is only // allocated in a purely sequential manner and deallocated as one large // lump of memory. // // So we do not need to implement a full memory heap allocation // mechanism. Instead, we just need to keep track of where the // previous high water mark was before this order was freed. // // // Find the tail of the current chain. // pOrderTail = COM_BasedListLast(&lpoaShared->orderListHead, FIELD_OFFSET(INT_ORDER, OrderHeader.list)); SHM_CheckPointer(pOrderTail); // // We wont necessarily be freeing the last item in the order heap. // if (pOrder == pOrderTail) { // // This is the last item in the heap, so we can set the pointer to // the next order to be used back to the start of the order being // freed. // SHM_CheckPointer(&lpoaShared->nextOrder); lpoaShared->nextOrder = (LONG)((LPBYTE)pOrder - (LPBYTE)(lpoaShared->orderHeap)); } else { // // This is not the last item in the heap - we must not reset the // pointer to the next item to be used. // TRACE_OUT(("Not resetting next order (not last item in heap)")); } // // Delete the item from the chain. // COM_BasedListRemove(&pOrder->OrderHeader.list); DebugExitVOID(OADDFreeOrderMemInt); } // // OADDFreeAllOrders // // Free the all the individual orders on the orders list, without // discarding the list itself. // void OADDFreeAllOrders(LPOA_SHARED_DATA lpoaShared) { DebugEntry(OADDFreeAllOrders); // // Simply clear the list head. // COM_BasedListInit(&lpoaShared->orderListHead); SHM_CheckPointer(&lpoaShared->orderListHead); lpoaShared->totalHeapOrderBytes = 0; lpoaShared->totalOrderBytes = 0; lpoaShared->totalAdditionalOrderBytes = 0; lpoaShared->nextOrder = 0; DebugExitVOID(OADDFreeAllOrders); } // // // OADDOrderIsValid(..) // // Determines if a pointer points to a valid order. // // Returns: // TRUE if valid order, FALSE if invalid. // // BOOL OADDOrderIsValid(LPINT_ORDER pOrder) { BOOL rc; DebugEntry(OADDOrderIsValid); // // Check the order is not already spoilt // rc = ((pOrder->OrderHeader.Common.fOrderFlags & OF_SPOILT) == 0); DebugExitBOOL(OADDOrderIsValid, rc); return(rc); } BOOL OADDCompleteOverlapRect(LPTSHR_RECT16 prcsSrc, LPRECT prcsOverlap) { // // Return TRUE if the source is completely enclosed by the overlap // rectangle. // return( (prcsSrc->left >= prcsOverlap->left) && (prcsSrc->right <= prcsOverlap->right) && (prcsSrc->top >= prcsOverlap->top) && (prcsSrc->bottom <= prcsOverlap->bottom) ); } // // Name: OADDSpoilFromOrder // // Purpose: Remove any orders from the order heap which should be spoiled // by a given rectangle.. // // Returns: Nothing // // Params: IN pTargetOrder - Pointer to the first order to try to // spoil. // IN pRect - Pointer to the spoiling rectangle. // // Operation: pTargetOrder may be spoiled by this function, so be careful // on return. // void OADDSpoilFromOrder ( LPOA_SHARED_DATA lpoaShared, LPINT_ORDER pTargetOrder, LPRECT pSpoilRect ) { UINT nonProductiveScanDepth = 0; UINT scanExitDepth; BOOL reachedBlocker = FALSE; DebugEntry(OADDSpoilFromOrder); TRACE_OUT(("Spoiling rect is {%d, %d, %d, %d}", pSpoilRect->left, pSpoilRect->top, pSpoilRect->right, pSpoilRect->bottom)); // // Work out how deep we will scan if the spoiling is non-productive. // We go further for bigger orders over PSTN. (ie Irrespective of the // bandwidth we do not want to do much work when the app is blasting // out a lot of single pel orders!) // if (((pSpoilRect->right - pSpoilRect->left) < FULL_SPOIL_WIDTH) && ((pSpoilRect->bottom - pSpoilRect->top) < FULL_SPOIL_HEIGHT)) { TRACE_OUT(("Small order so reducing spoil depth")); scanExitDepth = OA_FAST_SCAN_DEPTH; } else { // // Use the current default scan depth (this is based on the // current network throughput). // scanExitDepth = (g_oaFlow == OAFLOW_FAST) ? OA_FAST_SCAN_DEPTH : OA_SLOW_SCAN_DEPTH; } // // Loop backwards from the base order until we have one of the // following occurs. // - We spoil all the preceeding orders. // - We reach a blocker which we can't spoil. // - We find scanExitDepth orders which we can't spoil. // while ((pTargetOrder != NULL) && !reachedBlocker && (nonProductiveScanDepth < scanExitDepth)) { // // We do not exit immediately when we reach a blocker because it is // possible that we will spoil it. If we do spoil it, then we can // quite happily try spoiling the orders which preceed it. // // So, just set a flag here which we will reset if we spoil the // order. // reachedBlocker = ((pTargetOrder->OrderHeader.Common.fOrderFlags & OF_BLOCKER) != 0); // // Only try to spoil spoilable orders. // if ((pTargetOrder->OrderHeader.Common.fOrderFlags & OF_SPOILABLE) != 0) { if (OADDCompleteOverlapRect( &pTargetOrder->OrderHeader.Common.rcsDst, pSpoilRect)) { // // The order can be spoilt. If the order is a MemBlt or a // Mem3Blt, we have to notify SBC to allow it to free up // associated data. // if (ORDER_IS_MEMBLT(pTargetOrder) || ORDER_IS_MEM3BLT(pTargetOrder)) { SBC_DDOrderSpoiltNotification(pTargetOrder); } TRACE_OUT(("Spoil by order (%hd, %hd) (%hd, %hd)", pTargetOrder->OrderHeader.Common.rcsDst.left, pTargetOrder->OrderHeader.Common.rcsDst.top, pTargetOrder->OrderHeader.Common.rcsDst.right, pTargetOrder->OrderHeader.Common.rcsDst.bottom)); pTargetOrder = OA_DDRemoveListOrder(pTargetOrder); // // Reset the blocker flag - we spoiled the order, so if it // was a blocker we can now try to spoil earlier orders. // reachedBlocker = FALSE; } else { nonProductiveScanDepth++; } } else { nonProductiveScanDepth++; } // // Get the previous order in the list. We have to be careful // because we may have just removed the last item in the list, in // which case pTargetOrder will be NULL. // if (pTargetOrder == NULL) { pTargetOrder = COM_BasedListLast(&lpoaShared->orderListHead, FIELD_OFFSET(INT_ORDER, OrderHeader.list)); } else { pTargetOrder = COM_BasedListPrev(&lpoaShared->orderListHead, pTargetOrder, FIELD_OFFSET(INT_ORDER, OrderHeader.list)); } } DebugExitVOID(OADDSpoilFromOrder); }