![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to savescr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / video / displays / vga|
Return to savescr.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / video / displays / vga |
1.1 root 1: /******************************Module*Header*******************************\
2: * Module Name: savescr.c *
3: * *
4: * DrvSaveScreenBits *
5: * *
6: * Copyright (c) 1992 Microsoft Corporation *
7: \**************************************************************************/
8:
9:
10: #include <driver.h>
11:
12:
13: //**************************************************************************//
14: // Note: if this is turned on, you *MUST* make sure to invalidate and reset //
15: // this when going to/returning from fullscreen mode (in DrvAssertMode). //
16: //**************************************************************************//
17: #define OFFSCREEN_SUPPORTED 0 // 1 to support saves to offscreen memory
18: // (code currently not written)
19:
20: VOID
21: vRestoreScreenBitsFromOffscreen(
22: PDEVSURF pdsurf,
23: PRECTL prcl,
24: PBYTE pjSrcBuffer
25: );
26:
27: VOID
28: vRestoreScreenBitsFromMemory(
29: PDEVSURF pdsurf,
30: PRECTL prcl,
31: PBYTE pjSrcBuffer,
32: ULONG ulRestoreWidthInBytes,
33: ULONG ulSrcDelta
34: );
35:
36: VOID
37: vSaveScreenBitsToMemory(
38: PDEVSURF pdsurf,
39: PRECTL prcl,
40: PVOID pjDestBuffer,
41: ULONG ulSaveWidthInBytes,
42: ULONG ulSaveHeight,
43: ULONG ulDestScanWidth
44: );
45:
46: /******************************Public*Routine******************************\
47: * DrvSaveScreenBits(pso,iMode,iIdent,prcl) *
48: * *
49: * Saves and restores the specified area of the screen *
50: * *
51: \**************************************************************************/
52:
53: ULONG DrvSaveScreenBits(SURFOBJ *pso, ULONG iMode, ULONG iIdent, RECTL *prcl)
54: {
55: PDEVSURF pdsurf;
56: PPDEV ppdev;
57: PSAVED_SCREEN_BITS pSSB, *pLastSSBPtr, pSSBTemp;
58: BOOL bIdentFound;
59: ULONG ulSaveSize, ulSaveHeight;
60: ULONG ulSaveWidthInBytes, ulSaveWidthInAlignedBytes;
61:
62: // ASSERT(pso != (SURFOBJ *) NULL,"DrvSaveScreenBits invalid pso");
63:
64: pdsurf = (PDEVSURF) pso->dhsurf;
65:
66: // ASSERT(pdsurf != (PDEVSURF) NULL,"DrvSaveScreenBits invalid dhsurf");
67: // ASSERT(pdsurf->iFormat == BMF_PHYSDEVICE,
68: // "DrvSaveScreenBits DFBs not supported");
69:
70: ppdev = pdsurf->ppdev; // find the PDEV that goes with this surface
71:
72: //
73: // Save, restore, or free a block of screen bits.
74: //
75:
76: switch(iMode)
77: {
78: //
79: // Save a block of screen bits.
80: //
81:
82: case SS_SAVE:
83:
84: // ASSERT(prcl != (RECTL *) NULL,"DrvSaveScreenBits invalid prcl");
85: // Figure out how big the save area will be
86: ulSaveHeight = prcl->bottom - prcl->top;
87: ulSaveWidthInBytes =
88: ((ULONG)((prcl->right + 7) - (prcl->left & ~0x07))) >> 3;
89:
90: #if OFFSCREEN_SUPPORTED
91: // This is the size of the the save area for one plane, or the
92: // number of addresses required to save this in offscreen memory.
93: // A system memory save area would require four times as many bytes
94: ulSaveSize = ulSaveHeight * pSSB->ulSaveWidthInBytes;
95:
96: // See if there's enough memory left in the display memory heap to
97: // save this rectangle
98: if (ulSaveSize >
99: (pdsurf->pjAdapterHeapTop - pdsurf->pjAdapterHeapStart))
100: {
101: #endif
102: // Not enough offscreen memory; store in system memory.
103: // Calculate new buffer width, allowing for padding so we can
104: // dword align
105: ulSaveWidthInAlignedBytes =
106: (((ULONG)((prcl->right + 31) - (prcl->left & ~0x1F)))
107: >> 5) << 2;
108:
109: // # of bytes to hold all 4 planes of save rect in memory
110: ulSaveSize = ((ulSaveHeight * ulSaveWidthInAlignedBytes) << 2)
111: + sizeof(SAVED_SCREEN_BITS);
112:
113: // If the preallocated saved screen bits buffer is free and big
114: // enough to handle this save, we'll use that
115: if ((ppdev->flPreallocSSBBufferInUse == FALSE) &&
116: (ulSaveSize <= ppdev->ulPreallocSSBSize))
117: {
118: // Save in preallocated buffer
119:
120: pSSB = (PSAVED_SCREEN_BITS) ppdev->pjPreallocSSBBuffer;
121:
122: // Mark that we're saving in the preallocated buffer
123: pSSB->bFlags = SSB_IN_PREALLOC_BUFFER;
124:
125: // Make sure no other screen bits save tries to use the
126: // buffer
127: ppdev->flPreallocSSBBufferInUse = TRUE;
128: }
129: else
130: {
131: // Save in system memory buffer
132:
133: // Allocate a structure to contain the save info and the
134: // save buffer (four planes' worth)
135: pSSB = (PSAVED_SCREEN_BITS)
136: (LocalAlloc(LMEM_FIXED | LMEM_ZEROINIT,
137: ulSaveSize));
138: if (pSSB == NULL)
139: {
140: // Couldn't get memory, so fail this call
141: return((ULONG)0);
142: }
143:
144: // Mark that we're not saving in display memory
145: pSSB->bFlags = 0;
146: }
147:
148: // Start address at which to save, accounting for
149: // the number of bytes by which to pad on the left to dword
150: // align (assumes each scan line starts dword aligned, which is
151: // true in 640, 800, and 1024 wide cases)
152: pSSB->pjBuffer = ((PBYTE) pSSB) + sizeof(SAVED_SCREEN_BITS) +
153: ((prcl->left >> 3) & 0x03);
154:
155: pSSB->ulSaveWidthInBytes = ulSaveWidthInBytes;
156:
157: // Distance from end of one scan to start of next (number of
158: // padding bytes for dword alignment purposes)
159: pSSB->ulDelta =
160: ulSaveWidthInAlignedBytes - pSSB->ulSaveWidthInBytes;
161:
162: // Save the rectangle to system memory
163: vSaveScreenBitsToMemory(pdsurf,
164: prcl,
165: pSSB->pjBuffer,
166: pSSB->ulSaveWidthInBytes,
167: ulSaveHeight,
168: ulSaveWidthInAlignedBytes);
169: #if OFFSCREEN_SUPPORTED
170: }
171: else
172: {
173: // Store in offscreen memory
174: // Allocate a structure to contain the save info
175: pSSB = (PSAVED_SCREEN_BITS)
176: (LocalAlloc(LMEM_FIXED | LMEM_ZEROINIT,
177: sizeof(SAVED_SCREEN_BITS));
178: if (pSSB == NULL)
179: {
180: // Couldn't get memory, so fail this call
181: return(0);
182: }
183: pSSB->bFlags = SSB_IN_ADAPTER_MEMORY;
184:
185: pSSB->ulSaveWidthInBytes = ulSaveWidthInBytes;
186:
187: /***/
188:
189: }
190: #endif
191:
192: // Link the new saved screen bits block into the list
193: pSSB->pvNextSSB = pdsurf->ssbList;
194: pdsurf->ssbList = pSSB;
195:
196: return((ULONG) pSSB);
197:
198: //
199: // Restore a saved screen bits block to the screen, then free it.
200: //
201:
202: case SS_RESTORE:
203: // ASSERT(prcl != (RECTL *) NULL,"DrvSaveScreenBits invalid prcl");
204:
205: // Point to the first block in the saved screen bits list
206: pSSB = pdsurf->ssbList;
207:
208: // Try to find the specified saved screen bits block
209: bIdentFound = FALSE;
210: while ((pSSB != (PSAVED_SCREEN_BITS) NULL) && !bIdentFound)
211: {
212: if (pSSB == (PSAVED_SCREEN_BITS) iIdent)
213: {
214: // It's a match; restore this block
215:
216: // Handle copies from offscreen memory and system memory
217: // separately
218: #if OFFSCREEN_SUPPORTED
219: if (pSSB->bFlags & SSB_IN_ADAPTER_MEMORY)
220: {
221: vRestoreScreenBitsFromOffscreen(pdsurf,
222: prcl,
223: pSSB->pjBuffer);
224: }
225: else
226: {
227: #endif
228: vRestoreScreenBitsFromMemory(pdsurf,
229: prcl,
230: pSSB->pjBuffer,
231: pSSB->ulSaveWidthInBytes,
232: pSSB->ulDelta);
233: #if OFFSCREEN_SUPPORTED
234: }
235: #endif
236:
237: bIdentFound = TRUE;
238: }
239: else
240: {
241: // Not a match, so check another block, if there is one.
242: // Point to the next saved screen bits block
243: pSSB = (PSAVED_SCREEN_BITS) pSSB->pvNextSSB;
244: }
245: }
246:
247: // See if we succeeded in finding a block to restore
248: if (!bIdentFound)
249: {
250: // It was a bad identifier, so we'll return failure
251:
252: DISPDBG((0, "DrvSaveScreenBits SS_RESTORE invalid iIdent"));
253: return(FALSE);
254: }
255:
256: // Always free the saved screen bits block after restoring it
257:
258: //
259: // Free up the saved screen bits block.
260: //
261:
262: case SS_FREE:
263:
264: // Point to the first block in the saved screen bits list
265: pSSB = pdsurf->ssbList;
266:
267: // Point to the pointer to the first block, so we can unlink the
268: // first block if it's the one we're freeing
269: pLastSSBPtr = &pdsurf->ssbList;
270:
271: // Try to find the specified saved screen bits block
272: while (pSSB != (PSAVED_SCREEN_BITS) NULL)
273: {
274: if (pSSB == (PSAVED_SCREEN_BITS) iIdent)
275: {
276: // It's a match; free up this block
277:
278: // Unlink the block from the list
279: *pLastSSBPtr = (PSAVED_SCREEN_BITS) pSSB->pvNextSSB;
280:
281: // If the block is in offscreen memory, adjust the display
282: // memory heap to free up the offscreen memory allocated to
283: // the block
284: if (pSSB->bFlags & SSB_IN_ADAPTER_MEMORY)
285: {
286: if (pSSB->pjBuffer != pdsurf->pjAdapterHeapTop)
287: {
288: // The block is not on top of the heap, so compact
289: // the heap to move the newly freed space to the
290: // top of the display memory heap
291:
292: // First, adjust the pointers to all the blocks
293: // that are above the freed one in the display
294: // memory heap
295: pSSBTemp = pdsurf->ssbList;
296: while (pSSBTemp != NULL)
297: {
298: if (pSSBTemp->pjBuffer < pSSB->pjBuffer)
299: {
300: // This block is above the one we're
301: // freeing in the display memory heap, so
302: // shift its pointer down (the actual
303: // movement of the bytes happens below)
304: pSSBTemp->pjBuffer += pSSB->ulSize;
305: }
306: pSSBTemp = (PSAVED_SCREEN_BITS)
307: pSSBTemp->pvNextSSB;
308: }
309: // Now actually shift all the higher blocks to
310: // squeeze out the block we just freed
311:
312: memcpy(pdsurf->pjAdapterHeapTop + pSSB->ulSize,
313: pdsurf->pjAdapterHeapTop,
314: pSSB->pjBuffer - pdsurf->pjAdapterHeapTop);
315: }
316:
317: // Adjust the top of the used display memory heap to
318: // account for the block we just freed
319: pdsurf->pjAdapterHeapTop += pSSB->ulSize;
320: }
321: else if (pSSB->bFlags & SSB_IN_PREALLOC_BUFFER)
322: {
323: // If the block's save area is in the preallocated
324: // buffer, mark that the buffer is no longer in use
325: // and is free for reuse
326: ppdev->flPreallocSSBBufferInUse = FALSE;
327:
328: // We're done; there's nothing to free up
329: return(TRUE);
330: }
331:
332: // Deallocate the block's memory
333: LocalFree(pSSB);
334:
335: // We've successfully freed the block
336: return(TRUE);
337: }
338:
339: // Not a match, so check another block, if there is one
340: // Remember the block that points to the block we're advancing
341: // to, for unlinking later
342: pLastSSBPtr = (PSAVED_SCREEN_BITS *) &pSSB->pvNextSSB;
343:
344: // Point to the next saved screen bits block
345: pSSB = (PSAVED_SCREEN_BITS) pSSB->pvNextSSB;
346: }
347:
348: // It was a bad identifier, so we'll do nothing. We won't return
349: // FALSE because SS_FREE always returns TRUE
350:
351: DISPDBG((0, "DrvSaveScreenBits SS_FREE invalid iIdent"));
352:
353: return(TRUE);
354:
355: //
356: // An unknown mode was passed in.
357: //
358:
359: default:
360:
361: DISPDBG((0, "DrvSaveScreenBits invalid iMode"));
362:
363: return(FALSE);
364: break;
365: }
366: }
367:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.