// // Sent Bitmap Cache // #ifndef _H_SBC #define _H_SBC #include #include #include #include #include // // // Constants // // #define SBC_NUM_THRASHERS 8 // The number of bitmaps we monitor for // "thrashiness" at any given time. #define SBC_THRASH_INTERVAL 50 // The interval (in centi-seconds) at // which bitmaps have to change in // order to be classified as thrashers // // Eviction categories // #define SBC_NUM_CATEGORIES 3 // // Specific values for OSI escape codes // #define SBC_ESC(code) (OSI_SBC_ESC_FIRST + code) #define SBC_ESC_NEW_CAPABILITIES SBC_ESC(0) // // Value indicating that a bitmap should not be fast pathed // #define SBC_DONT_FASTPATH 0xffffffff // // Index into sbcTileWorkInfo at which the data for various tile sizes is // stored. // #define SBC_MEDIUM_TILE_INDEX SHM_MEDIUM_TILE_INDEX #define SBC_LARGE_TILE_INDEX SHM_LARGE_TILE_INDEX #define SBC_NUM_TILE_SIZES SHM_NUM_TILE_SIZES // // // Macros // // // // Calculate the number of bytes required for a tile entry of the given // dimensions. // #define SBC_BYTES_PER_TILE(WIDTH, HEIGHT, BPP) \ (BYTES_IN_BITMAP((WIDTH), (HEIGHT), (BPP)) \ + sizeof(SBC_TILE_DATA)) \ // // SBC_TILE_TYPE // // Given an SBC tile Id, return the tile type. // // Returns one of: // SBC_SMALL_TILE // SBC_LARGE_TILE // // The top bit of the Id is clear for small tiles, and set for large tiles. // #define SBC_TILE_TYPE(TILEID) \ (((TILEID) & 0x8000) ? SBC_LARGE_TILE_INDEX : SBC_MEDIUM_TILE_INDEX) // // // Structures // // // // Structure: SBC_SHM_CACHE_INFO // // Description: Structure which is used to pass information about a bitmap // cache from the share core to the display driver. // // typedef struct tagSBC_SHM_CACHE_INFO { WORD cEntries; // The number of entries in this cache. WORD cCellSize; // The maximum bytes available for each cache entry. } SBC_SHM_CACHE_INFO; typedef SBC_SHM_CACHE_INFO FAR * LPSBC_SHM_CACHE_INFO; // // Structure: SBC_TILE_DATA // // Description: Structure used to pass the DIB bits for tile in a MEMBLT // order from the driver to the share core. There is an array of these // structures in each SBC shunt buffer. // // Notes: The inUse field should only be set to TRUE by the driver when it // has finished filling in the entry, and to FALSE by the share core when // it has finished processing the data held in the entry. When inUse is // FALSE, the remaining data is not valid, and should not be accessed by // the share core. // // The width and height fields give the dimensions of the data which is // held in the bitData field. If the tile is set up to hold a maximum // of 32x32, the scanlines in bitData will always be 32 even if width is // set to less than 32 - there will just be unused data at the end of each // scanline. // // typedef struct tagSBC_TILE_DATA { WORD inUse; // Is this entry in use? WORD tileId; // An identifier for this entry. This // matches an ID stored in the // cacheId field of a MEMBLT order // passed from the driver to the // share core in the order buffer. DWORD bytesUsed; // The number of bytes of data in // bitData which is actually used for // this entry. WORD srcX; // The source coordinates of the Mem(3)Blt WORD srcY; WORD width; // The dimensions of the data in bitData WORD height; WORD tilingWidth; // The dimensions at which tiling was WORD tilingHeight; // carried out. This is not // necessarily the same as the // dimensions of the tiles in this // shunt buffer. DWORD_PTR majorCacheInfo; // Information which the share core can DWORD minorCacheInfo; // use to optimize cache handling. // A value of SBC_DONT_FASTPATH for // majorCacheInfo indicates that the // optimization should not be used. // DWORD_PTR majorPalette; // Palette information for the fast DWORD minorPalette; // pathing. These two fields // uniquely identify the colour // conversion object associated with // the bitmap. BYTE bitData[4]; // Start of the bit data. The total // number of bits is given by the // numBits field of the // SBC_SHUNT_BUFFER structure at the // head of the shunt buffer which // this entry is placed in. } SBC_TILE_DATA; typedef SBC_TILE_DATA FAR * LPSBC_TILE_DATA; // // Structure: SBC_SHUNT_BUFFER // // Description: Structure placed at the head of a shunt buffer used to pass // bit data from the driver to the share core. It is followed by an array // of SBC_TILE_DATA structures. // // Note: The SBC_TILE_DATA structures are all the same size, but the size // is not fixed at compile time (there are a variable number of bits), so // do not use array notation to reference them. // // typedef struct tagSBC_SHUNT_BUFFER { DWORD numBytes; // The number of bytes in the bitData // fields of the SBC_TILE_DATA stryct DWORD structureSize; // The total size of each SBC_TILE_DATA // structure DWORD numEntries; // The number of SBC_TILE_DATA // structures in the shunt buffer SBC_TILE_DATA firstEntry; // The first SBC_TILE_DATA entry } SBC_SHUNT_BUFFER; typedef SBC_SHUNT_BUFFER FAR * LPSBC_SHUNT_BUFFER; // // Structure: SBC_NEW_CAPABILITIES // // Description: // // Structure to pass new capabilities down to the display driver from the // Share Core. // // typedef struct tagSBC_NEW_CAPABILITIES { OSI_ESCAPE_HEADER header; // Common header DWORD sendingBpp; // Bpp at which bitmaps are sent LPSBC_SHM_CACHE_INFO cacheInfo; // Caching details } SBC_NEW_CAPABILITIES; typedef SBC_NEW_CAPABILITIES FAR * LPSBC_NEW_CAPABILITIES; // // Structure: SBC_ORDER_INFO // // Description: This structure holds all the information SBC needs about // the two internal orders which it stores to hold data color table and bit // data for a MEMBLT order. // // pColorTableOrder is allocated with enough color table entries for // usrSendingbpp bitmaps. // // pBitmapBitsOrder is allocated with enough room for the maximum tile size // which we will send out at usrSendingbpp. // // If sentColorTable is TRUE, the data in pColorTableOrder may not be // valid. // // If sentBitmapBits is TRUE, the data in pBitmapBitsOrder may not be // valid. // // typedef struct tagSBC_ORDER_INFO { LPINT_ORDER pColorTableOrder; // Pointer to a color table order. LPINT_ORDER pBitmapBitsOrder; // Pointer to a bitmap bits order. DWORD bitmapBitsDataSize; // The number of bytes allocated // for the data field of the // bitmap bits order. LPINT_ORDER pOrder; // Pointer to the MEMBLT order for // which we currently hold data. // DO NOT DEREFERENCE THIS - IT // IS FOR NUMERICAL COMPARISON // ONLY DWORD validData; // Do we have valid data for // pOrder ? DWORD sentColorTable; // Has the color table been sent // over the wire ? DWORD sentBitmapBits; // Have the bitmap bits been sent // over the wire ? DWORD sentMemBlt; // Has the MEMBLT order itself been // sent over the wire ? } SBC_ORDER_INFO, FAR * LPSBC_ORDER_INFO; // // Structure: SBC_TILE_WORK_INFO // // Description: This structure contains all the elements required for // manipulating tiles of a given size. There should be an array of these // structures - one per tile size. // // typedef struct tagSBC_TILE_WORK_INFO { LPSBC_SHUNT_BUFFER pShuntBuffer; // Pointer to the shunt buffer to // containing tiles of this tile // size. UINT mruIndex; // The last entry accessed in // the shunt buffer pointed to by // pShuntBuffer. HBITMAP workBitmap; // The bitmap to use for processing // this tile size. This is // tileWidth x tileHeight at // native bpp. #ifndef DLL_DISP LPBYTE pWorkBitmapBits;// Pointer to the start of the bits #endif // DLL_DISP // in the bitmap. UINT tileWidth; // The width of workBitmap. UINT tileHeight; // The height of workBitmap. } SBC_TILE_WORK_INFO, FAR * LPSBC_TILE_WORK_INFO; // // Structure: SBC_FASTPATH_ENTRY // // Description: Structure holding one entry in the SBC fast path. // // typedef struct tagSBC_FASTPATH_ENTRY { BASEDLIST list; // Offsets to the next / prev entries in // the fast path DWORD_PTR majorInfo; // Major cache info field passed up in the // shunt buffer for this cache entry DWORD minorInfo; // Minor cache info field passed up in the // shunt buffer for this cache entry DWORD_PTR majorPalette; // Major palette info from the shunt buffer // This is the pointer to the XLATEOBJ DWORD minorPalette; // Minor palette info from the shunt buffer // This is the iUniq of the XLATEOBJ LONG srcX; // The coordinate in the source bitmap of LONG srcY; // the source of the MemBlt DWORD width; // The width / height of the entry in the DWORD height; // cache. WORD cache; // The cache and index at which the bitmap WORD cacheIndex; // stored. WORD colorIndex; WORD pad; } SBC_FASTPATH_ENTRY, FAR * LPSBC_FASTPATH_ENTRY; // // Structure: SBC_FASTPATH // // Description: Structure holding the SBC fast pathing information. // // #define SBC_FASTPATH_ENTRIES 100 typedef struct tagSBC_FASTPATH { STRUCTURE_STAMP BASEDLIST usedList; // Offsets to the first / last used // entries in the fast path. BASEDLIST freeList; // Offsets to the first / last free // entries in the fast path. SBC_FASTPATH_ENTRY entry[SBC_FASTPATH_ENTRIES]; } SBC_FASTPATH; typedef SBC_FASTPATH FAR * LPSBC_FASTPATH; #ifdef DLL_DISP // Structure: SBC_THRASHERS // // Description: Structure which is used to hold information about when a // source surface (bitmap) last changed, in order to determine whether the // surface will cause thrashing in the bitmap cache. // typedef struct tagSBC_THRASHERS { #ifdef IS_16 HBITMAP hsurf; #else HSURF hsurf; // The hsurf of the surface object being // monitored. DWORD iUniq; // The last noted iUniq field from the // surface object being monitored. #endif // IS_16 DWORD tickCount; // The system tick count (in centi-seconds) // at which we last saw this surface // change } SBC_THRASHERS; typedef SBC_THRASHERS FAR * LPSBC_THRASHERS; // // // Function prototypes // // void SBCDDSetNewCapabilities(LPSBC_NEW_CAPABILITIES pRequest); BOOL SBCDDGetNextFreeTile(int tileSize, LPSBC_TILE_DATA FAR * ppTileData); DWORD SBCDDGetTickCount(void); #ifdef IS_16 BOOL SBCDDCreateShuntBuffers(void); #else BOOL SBCDDCreateShuntBuffers(LPOSI_PDEV ppDev, LPBYTE psbcMem, DWORD sbcMem); #endif #ifndef IS_16 BOOL SBCDDIsBitmapThrasher(SURFOBJ * pSurfObj); #endif // !IS_16 #endif // DLL_DISP // // SBC_TILE_PTR_FROM_INDEX // // Given a pointer to a shunt buffer and a tile index, return a pointer to // the tile at the given index. // // Get a pointer to the first entry in the shunt buffer, and add INDEX // times the size of each entry. // __inline LPSBC_TILE_DATA SBCTilePtrFromIndex(LPSBC_SHUNT_BUFFER pBuffer, UINT index) { LPSBC_TILE_DATA lpsbc; lpsbc = (LPSBC_TILE_DATA)((LPBYTE)&pBuffer->firstEntry + index * pBuffer->structureSize); return(lpsbc); } #ifdef DLL_DISP // // // Typedefs // // #ifdef IS_16 typedef struct tagMEMBLT_ORDER_EXTRA_INFO { HDC hdcSrc; UINT fuColorUse; LPVOID lpBits; LPBITMAPINFO lpbmi; HPALETTE hpalDst; UINT uPad; } MEMBLT_ORDER_EXTRA_INFO, FAR* LPMEMBLT_ORDER_EXTRA_INFO; #else // // Structure: MEMBLT_ORDER_EXTRA_INFO // // Description: Extra information required by SBC to process a MEMBLT // order. // // typedef struct tagMEMBLT_ORDER_EXTRA_INFO { SURFOBJ* pSource; // Pointer to the source surface of the // MemBlt SURFOBJ* pDest; // Pointer to the destination surface of // the MemBlt XLATEOBJ* pXlateObj; // Pointer to the XlateObj used in the // MemBlt } MEMBLT_ORDER_EXTRA_INFO, FAR * LPMEMBLT_ORDER_EXTRA_INFO; #endif // !IS_16 // // Name: SBC_DDProcessRequest // // Purpose: Process a request from the share core // // Returns: TRUE if the request is processed successfully, // FALSE otherwise. // // Params: IN pso - Pointer to surface object for our driver // IN cjIn - Size of the input data // IN pvIn - Pointer to the input data // IN cjOut - Size of the output data // IN/OUT pvOut - Pointer to the output data // #ifdef IS_16 BOOL SBC_DDProcessRequest(UINT fnEscape, LPOSI_ESCAPE_HEADER pResult, DWORD cbResult); void SBC_DDTossFromCache(HBITMAP); #else BOOL SBC_DDProcessRequest(SURFOBJ* pso, DWORD fnEscape, LPOSI_ESCAPE_HEADER pRequest, LPOSI_ESCAPE_HEADER pResult, DWORD cbResult); #endif // // Name: SBC_DDInit // // Purpose: Initialize the device driver SBC specific "stuff". // #ifdef IS_16 BOOL SBC_DDInit(HDC hdc, LPDWORD ppShuntBuffers, LPDWORD pBitmasks); #else BOOL SBC_DDInit(LPOSI_PDEV ppDev, LPBYTE pRestOfMemory, DWORD cbRestOfMemory, LPOSI_INIT_REQUEST pResult); #endif // // Name: SBC_DDTerm // // Purpose: Terminate the device driver SBC specific "stuff" // // Returns: Nothing // // Params: None // void SBC_DDTerm(void); // // Name: SBC_DDIsMemScreenBltCachable // // Purpose: Check to see whether a MemBlt is cachable. // // Returns: TRUE if the MemBlt is cachable, FALSE otherwise. // // Params: IN pMemBltInfo - Info about the MEMBLT to be cached. // // Operation: Note that if this function returns TRUE, it DOES NOT // guarantee that SBC_DDCacheMemScreenBlt will succeed. // However, a FALSE return code does guarantee that // SBC_DDCacheMemScreenBlt would fail. // BOOL SBC_DDIsMemScreenBltCachable(LPMEMBLT_ORDER_EXTRA_INFO pMemBltInfo); // // Name: SBC_DDCacheMemScreenBlt // // Purpose: Try to cache a memory to screen blt operation // // Returns: TRUE if the memory to screen blt was handled as an order // (i.e. the src bitmap could be cached) // // FALSE if the memory to screen blt could not be handled as an // order. In this case the caller should add the destination // rectangle of the blt into the Screen Data Area. // // Params: IN pOrder - Pointer to either a MEMBLT order or a // MEM3BLT order. This order must be // initialized before calling this function. // IN pMemBltInfo - Extra info about the MEMBLT to be cached. // // Operation: Before calling this function, the caller should call // SBC_DDMaybeQueueColorTable() to queue a color table for the // MemBlt (if required). // BOOL SBC_DDCacheMemScreenBlt(LPINT_ORDER pOrder, LPMEMBLT_ORDER_EXTRA_INFO pMemBltInfo); // // THIS CAN GO WHEN 2.x COMPAT DOES -- the SEND TILE SIZES WON'T BE // NEGOTIATED. // BOOL SBC_DDQueryBitmapTileSize(UINT bmpWidth, UINT bmpHeight, UINT * pTileWidth, UINT * pTileHeight); // // Name: SBC_DDSyncUpdatesNow // // Purpose: Discard any pending orders. // // Returns: Nothing // // Params: IN ppDev - Pointer to our device PDEV // // Operation: This function will mark all entries in the shunt buffers as // being free. It is vital that this operation is synched with // the share core operation of removing all orders from the // order buffer to ensure that there are no MemBlt orders left // which refer to freed shunt buffer entries. // #ifdef IS_16 void SBC_DDSyncUpdatesNow(void); #else void SBC_DDSyncUpdatesNow(LPOSI_PDEV ppDev); #endif // IS_16 // // Name: SBC_DDOrderSpoiltNotification // // Purpose: Called to notify SBC that a Mem(3)Blt order has been spoilt // before being passed to the share core. This function marks // the corresponding shunt buffer entry as being free. // // Returns: Nothing // // Params: IN pOrder - Pointer to the Mem(3)Blt order being spoilt. // void SBC_DDOrderSpoiltNotification(LPINT_ORDER pOrder); // // Name: SBC_DDMaybeQueueColorTable // // Purpose: If our device palette has changed since the last time we // queued a color table order to the share core, queue a new // color table order with details of the new palette. // // Returns: TRUE if the color table was queued, or no color table was // required. // // FALSE if a color table is required, but could not be queued. // // Params: IN ppDev - a pointer to our device PDEV // // Operation: This function should be called before SBC_DDCacheMemScreenBlt // to queue the color table used for the Mem(3)Blt. If this // function fails (returns FALSE), the caller should not call // SBC_DDCacheMemScreenBlt, but add the area covered by the // Mem(3)Blt to the screen data area instead. // // This function is required to work round a limitation in the // order heap which means that we cannot have more than one // OA_AllocOrderMem outstanding waiting for an OA_AddOrder. // // i.e. We cannot queue the color table order from // SBC_DDCacheMemScreenBlt because this gives the following // sequence of calls. // // OA_AllocOrderMem for Mem(3)Blt // OA_AllocOrderMem for color table // OA_AddOrder for color table // OA_AddOrder for Mem(3)Blt // #ifdef IS_16 BOOL SBC_DDMaybeQueueColorTable(void); #else BOOL SBC_DDMaybeQueueColorTable(LPOSI_PDEV ppDev); #endif #endif // DLL_DISP #endif // _H_SBC