![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to screen.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 / xga|
Return to screen.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / video / displays / xga |
1.1 root 1: /******************************Module*Header*******************************\
2: * Module Name: screen.c
3: *
4: * Initializes the GDIINFO and DEVINFO structures for DrvEnablePDEV.
5: *
6: * Copyright (c) 1992 Microsoft Corporation
7: \**************************************************************************/
8:
9: #include "driver.h"
10:
11: #define SYSTM_LOGFONT {16,7,0,0,700,0,0,0,ANSI_CHARSET,OUT_DEFAULT_PRECIS,CLIP_DEFAULT_PRECIS,DEFAULT_QUALITY,VARIABLE_PITCH | FF_DONTCARE,L"System"}
12: #define HELVE_LOGFONT {12,9,0,0,400,0,0,0,ANSI_CHARSET,OUT_DEFAULT_PRECIS,CLIP_STROKE_PRECIS,PROOF_QUALITY,VARIABLE_PITCH | FF_DONTCARE,L"MS Sans Serif"}
13: #define COURI_LOGFONT {12,9,0,0,400,0,0,0,ANSI_CHARSET,OUT_DEFAULT_PRECIS,CLIP_STROKE_PRECIS,PROOF_QUALITY,FIXED_PITCH | FF_DONTCARE, L"Courier"}
14:
15: // This is the basic devinfo for a default driver. This is used as a base and customized based
16: // on information passed back from the miniport driver.
17:
18: const DEVINFO gDevInfoFrameBuffer = {
19: GCAPS_OPAQUERECT | GCAPS_MONO_DITHER, /* Graphics capabilities */
20: SYSTM_LOGFONT, /* Default font description */
21: HELVE_LOGFONT, /* ANSI variable font description */
22: COURI_LOGFONT, /* ANSI fixed font description */
23: 0, /* Count of device fonts */
24: 0, /* Preferred DIB format */
25: 8, /* Width of color dither */
26: 8, /* Height of color dither */
27: 0 /* Default palette to use for this device */
28: };
29:
30: /******************************Public*Routine******************************\
31: * bInitSURF
32: *
33: * Enables the surface. Maps the frame buffer into memory.
34: *
35: \**************************************************************************/
36:
37: BOOL bInitSURF(PPDEV ppdev, BOOL bFirst)
38: {
39:
40: VIDEO_MEMORY VideoMemory;
41: VIDEO_MEMORY_INFORMATION VideoMemoryInfo;
42: DWORD ReturnedDataLength;
43: DWORD XGAPixelOp;
44:
45: VIDEO_XGA_COPROCESSOR_INFORMATION CoProcessorInfo;
46:
47: if (!DeviceIoControl(ppdev->hDriver,
48: IOCTL_VIDEO_SET_CURRENT_MODE,
49: &ppdev->ulMode, // input buffer
50: sizeof(VIDEO_MODE),
51: NULL,
52: 0,
53: &ReturnedDataLength,
54: NULL)) {
55:
56: RIP("XGA.DLL: Initialization error-Set mode\n");
57:
58: }
59:
60: if (bFirst) {
61:
62: VideoMemory.RequestedVirtualAddress = NULL;
63:
64: if (!DeviceIoControl(ppdev->hDriver,
65: IOCTL_VIDEO_MAP_VIDEO_MEMORY,
66: (PVOID) &VideoMemory, // input buffer
67: sizeof (VIDEO_MEMORY),
68: (PVOID) &VideoMemoryInfo, // output buffer
69: sizeof (VideoMemoryInfo),
70: &ReturnedDataLength,
71: NULL)) {
72:
73: RIP("XGA.DLL: Initialization error-Map buffer address\n");
74:
75: }
76:
77: ppdev->pjScreen = VideoMemoryInfo.FrameBufferBase;
78: ppdev->ulScreenSize = VideoMemoryInfo.FrameBufferLength;
79: ppdev->ulVideoMemorySize = VideoMemoryInfo.VideoRamLength;
80:
81: if (!DeviceIoControl(ppdev->hDriver,
82: IOCTL_VIDEO_XGA_MAP_COPROCESSOR,
83: NULL, // input buffer
84: 0,
85: &CoProcessorInfo, // output buffer
86: sizeof (VIDEO_XGA_COPROCESSOR_INFORMATION),
87: &ReturnedDataLength,
88: NULL)) {
89:
90: RIP("XGA.DLL: Initialization error-Map Coprocessor buffer address\n");
91:
92: }
93:
94: // Set the globals, we will need these almost everywhere.
95:
96: ppdev->pXgaCpRegs = CoProcessorInfo.CoProcessorVirtualAddress;
97: ppdev->ulPhysFrameBuffer = (ULONG) CoProcessorInfo.PhysicalVideoMemoryAddress;
98: ppdev->ulXgaIoRegsBase = CoProcessorInfo.XgaIoRegisterBaseAddress;
99:
100: // Set the coprocessor defaults (Target pel map).
101: // The conventions for this driver will have the Target
102: // Pel map as map A.
103:
104: ppdev->pXgaCpRegs->XGAPixelMapIndex = PEL_MAP_A;
105: ppdev->pXgaCpRegs->XGAPixMapBasePtr = ppdev->ulPhysFrameBuffer;
106: ppdev->pXgaCpRegs->XGAPixMapWidth = (USHORT) ppdev->cxScreen - 1;
107: ppdev->pXgaCpRegs->XGAPixMapHeight = (USHORT) ppdev->cyScreen - 1;
108: ppdev->pXgaCpRegs->XGAPixMapFormat = PEL_MAP_FORMAT;
109:
110: ppdev->pXgaCpRegs->XGADestColCompCond = CCCC_FALSE;
111: ppdev->pXgaCpRegs->XGAPixelBitMask = 0xFF;
112:
113: //
114: // Init the XGA memory manager.
115: //
116:
117: bCpMmInitHeap(ppdev);
118:
119: //
120: // Determine if the coprocessor is working properly.
121: // Try a solid fill; if it fails, then disable all accelerations.
122: //
123:
124: ppdev->pXgaCpRegs->XGAOpDim1 = 1;
125: ppdev->pXgaCpRegs->XGAOpDim2 = 1;
126:
127: ppdev->pXgaCpRegs->XGADestMapX = 0;
128: ppdev->pXgaCpRegs->XGADestMapY = 0;
129:
130: ppdev->pXgaCpRegs->XGAForeGrMix = XGA_S;
131: ppdev->pXgaCpRegs->XGABackGrMix = XGA_S;
132:
133: ppdev->pXgaCpRegs->XGAForeGrColorReg = 0x55;
134:
135: //
136: // Now build the Pel Operation Register Op Code;
137: //
138:
139: XGAPixelOp = BS_BACK_COLOR | FS_FORE_COLOR | STEP_PX_BLT |
140: SRC_PEL_MAP_A | DST_PEL_MAP_A | PATT_FOREGROUND;
141:
142: ppdev->pXgaCpRegs->XGAPixelOp = XGAPixelOp;
143:
144: //
145: // Wait for the coprocessor.
146: //
147:
148: vWaitForCoProcessor(ppdev, 10) ;
149:
150: //
151: // Read the byte back to see if it was blit to the screen properly.
152: // BUGBUG !!!
153: // This is to allow the driver to treat the hardware as a frame buffer
154: // in the case where the IBM hardware is broken !
155: //
156:
157: if (*(ppdev->pjScreen) == 0x55) {
158:
159: //
160: // private flag used for determining driver capabilities.
161: //
162:
163:
164: ppdev->ulfAccelerations_debug = CACHED_FONTS;
165: ppdev->ulfBlitAccelerations_debug = SCRN_TO_SCRN_CPY | SOLID_PATTERN;
166:
167: } else {
168:
169: //
170: // !!! Turn off all accelerations for broken hardware !
171: //
172:
173: ppdev->ulfAccelerations_debug = 0;
174: ppdev->ulfBlitAccelerations_debug = 0;
175:
176: }
177: }
178:
179: return(TRUE);
180: }
181:
182: /******************************Public*Routine******************************\
183: * vDisableSURF
184: *
185: * Disable the surface. Un-Maps the frame in memory.
186: *
187: \**************************************************************************/
188:
189: VOID vDisableSURF(PPDEV ppdev)
190: {
191: DWORD returnedDataLength;
192: VIDEO_MEMORY videoMemory;
193:
194: videoMemory.RequestedVirtualAddress = (PVOID) ppdev->pjScreen;
195:
196: if (!DeviceIoControl(ppdev->hDriver,
197: IOCTL_VIDEO_UNMAP_VIDEO_MEMORY,
198: &videoMemory,
199: sizeof(VIDEO_MEMORY),
200: NULL,
201: 0,
202: &returnedDataLength,
203: NULL))
204: {
205: DISPDBG((0, "DISP vDisableSURF failed IOCTL_VIDEO_UNMAP\n"));
206: }
207: }
208:
209: /******************************Public*Routine******************************\
210: * bInitPDEV
211: *
212: * Determine the mode we should be in based on the DEVMODE passed in.
213: * Query mini-port to get information needed to fill in the DevInfo and the
214: * GdiInfo .
215: *
216: \**************************************************************************/
217:
218: BOOL bInitPDEV(
219: PPDEV ppdev,
220: DEVMODEW *pDevMode,
221: GDIINFO *pGdiInfo,
222: DEVINFO *pDevInfo)
223: {
224: ULONG cModes;
225: PVIDEO_MODE_INFORMATION pVideoBuffer, pVideoModeSelected, pVideoTemp;
226: VIDEO_COLOR_CAPABILITIES colorCapabilities;
227: ULONG ulTemp;
228: BOOL bSelectDefault;
229: ULONG cbModeSize;
230:
231: //
232: // calls the miniport to get mode information.
233: //
234:
235: cModes = getAvailableModes(ppdev->hDriver, &pVideoBuffer, &cbModeSize);
236:
237: if (cModes == 0)
238: {
239: return(FALSE);
240: }
241:
242: //
243: // Determine if we are looking for a default mode.
244: //
245:
246: if ( ((pDevMode->dmPelsWidth) ||
247: (pDevMode->dmPelsHeight) ||
248: (pDevMode->dmBitsPerPel) ||
249: (pDevMode->dmDisplayFlags) ||
250: (pDevMode->dmDisplayFrequency)) == 0)
251: {
252: bSelectDefault = TRUE;
253: }
254: else
255: {
256: bSelectDefault = FALSE;
257: }
258:
259: //
260: // Now see if the requested mode has a match in that table.
261: //
262:
263: pVideoModeSelected = NULL;
264: pVideoTemp = pVideoBuffer;
265:
266: while (cModes--)
267: {
268: if (pVideoTemp->Length != 0)
269: {
270: if (bSelectDefault ||
271: ((pVideoTemp->VisScreenWidth == pDevMode->dmPelsWidth) &&
272: (pVideoTemp->VisScreenHeight == pDevMode->dmPelsHeight) &&
273: (pVideoTemp->BitsPerPlane *
274: pVideoTemp->NumberOfPlanes == pDevMode->dmBitsPerPel) &&
275: ((pVideoTemp->Frequency == pDevMode->dmDisplayFrequency) ||
276: (pDevMode->dmDisplayFrequency == 0)) &&
277: (((pVideoTemp->AttributeFlags &
278: VIDEO_MODE_INTERLACED) ? 1:0) ==
279: ((pDevMode->dmDisplayFlags & DM_INTERLACED) ? 1:0)) ) )
280:
281: {
282: pVideoModeSelected = pVideoTemp;
283: DISPDBG((3, "XGA: Found a match\n"));
284: break;
285: }
286: }
287:
288: pVideoTemp = (PVIDEO_MODE_INFORMATION)
289: (((PUCHAR)pVideoTemp) + cbModeSize);
290: }
291:
292: //
293: // If no mode has been found, return an error
294: //
295:
296: if (pVideoModeSelected == NULL)
297: {
298: LocalFree(pVideoBuffer);
299: return(FALSE);
300: }
301:
302: //
303: // Fill in the GDIINFO data structure with the information returned from
304: // the kernel driver.
305: //
306:
307: ppdev->ulMode = pVideoModeSelected->ModeIndex;
308: ppdev->cxScreen = pVideoModeSelected->VisScreenWidth;
309: ppdev->cyScreen = pVideoModeSelected->VisScreenHeight;
310: ppdev->ulBitCount = pVideoModeSelected->BitsPerPlane *
311: pVideoModeSelected->NumberOfPlanes;
312: ppdev->lDeltaScreen = pVideoModeSelected->ScreenStride;
313:
314: ppdev->flRed = pVideoModeSelected->RedMask;
315: ppdev->flGreen = pVideoModeSelected->GreenMask;
316: ppdev->flBlue = pVideoModeSelected->BlueMask;
317:
318:
319: pGdiInfo->ulVersion = 0x1000; // Our driver is verion 1.000
320: pGdiInfo->ulTechnology = DT_RASDISPLAY;
321: pGdiInfo->ulHorzSize = pVideoModeSelected->XMillimeter;
322: pGdiInfo->ulVertSize = pVideoModeSelected->YMillimeter;
323:
324: pGdiInfo->ulHorzRes = ppdev->cxScreen;
325: pGdiInfo->ulVertRes = ppdev->cyScreen;
326: pGdiInfo->cBitsPixel = pVideoModeSelected->BitsPerPlane;
327: pGdiInfo->cPlanes = pVideoModeSelected->NumberOfPlanes;
328:
329: pGdiInfo->ulLogPixelsX = 96;
330: pGdiInfo->ulLogPixelsY = 96;
331:
332: pGdiInfo->flTextCaps = TC_RA_ABLE;
333: pGdiInfo->flRaster = 0; // DDI reserves flRaster
334:
335: pGdiInfo->ulDACRed = pVideoModeSelected->NumberRedBits;
336: pGdiInfo->ulDACGreen = pVideoModeSelected->NumberGreenBits;
337: pGdiInfo->ulDACBlue = pVideoModeSelected->NumberBlueBits;
338:
339: pGdiInfo->ulAspectX = 0x24; // One-to-one aspect ratio
340: pGdiInfo->ulAspectY = 0x24;
341: pGdiInfo->ulAspectXY = 0x33;
342:
343: pGdiInfo->xStyleStep = 1; // A style unit is 3 pels
344: pGdiInfo->yStyleStep = 1;
345: pGdiInfo->denStyleStep = 3;
346:
347: pGdiInfo->ptlPhysOffset.x = 0;
348: pGdiInfo->ptlPhysOffset.y = 0;
349: pGdiInfo->szlPhysSize.cx = 0;
350: pGdiInfo->szlPhysSize.cy = 0;
351:
352: // RGB and CMY color info.
353:
354: // try to get it from the miniport.
355: // if the miniport doesn ot support this feature, use defaults.
356:
357: if (!DeviceIoControl(ppdev->hDriver,
358: IOCTL_VIDEO_QUERY_COLOR_CAPABILITIES,
359: NULL,
360: 0,
361: &colorCapabilities,
362: sizeof(VIDEO_COLOR_CAPABILITIES),
363: &ulTemp,
364: NULL))
365: {
366: DISPDBG((1, "XGA DISP getcolorCapabilities failed \n"));
367:
368: pGdiInfo->ciDevice.Red.x = 6700;
369: pGdiInfo->ciDevice.Red.y = 3300;
370: pGdiInfo->ciDevice.Red.Y = 0;
371: pGdiInfo->ciDevice.Green.x = 2100;
372: pGdiInfo->ciDevice.Green.y = 7100;
373: pGdiInfo->ciDevice.Green.Y = 0;
374: pGdiInfo->ciDevice.Blue.x = 1400;
375: pGdiInfo->ciDevice.Blue.y = 800;
376: pGdiInfo->ciDevice.Blue.Y = 0;
377: pGdiInfo->ciDevice.AlignmentWhite.x = 3127;
378: pGdiInfo->ciDevice.AlignmentWhite.y = 3290;
379: pGdiInfo->ciDevice.AlignmentWhite.Y = 0;
380:
381: pGdiInfo->ciDevice.RedGamma = 20000;
382: pGdiInfo->ciDevice.GreenGamma = 20000;
383: pGdiInfo->ciDevice.BlueGamma = 20000;
384:
385: }
386: else
387: {
388:
389: pGdiInfo->ciDevice.Red.x = colorCapabilities.RedChromaticity_x;
390: pGdiInfo->ciDevice.Red.y = colorCapabilities.RedChromaticity_y;
391: pGdiInfo->ciDevice.Red.Y = 0;
392: pGdiInfo->ciDevice.Green.x = colorCapabilities.GreenChromaticity_x;
393: pGdiInfo->ciDevice.Green.y = colorCapabilities.GreenChromaticity_y;
394: pGdiInfo->ciDevice.Green.Y = 0;
395: pGdiInfo->ciDevice.Blue.x = colorCapabilities.BlueChromaticity_x;
396: pGdiInfo->ciDevice.Blue.y = colorCapabilities.BlueChromaticity_y;
397: pGdiInfo->ciDevice.Blue.Y = 0;
398: pGdiInfo->ciDevice.AlignmentWhite.x = colorCapabilities.WhiteChromaticity_x;
399: pGdiInfo->ciDevice.AlignmentWhite.y = colorCapabilities.WhiteChromaticity_y;
400: pGdiInfo->ciDevice.AlignmentWhite.Y = colorCapabilities.WhiteChromaticity_Y;
401:
402: // if we have a color device store the three color gamma values,
403: // otherwise store the unique gamma value in all three.
404:
405: if (colorCapabilities.AttributeFlags & VIDEO_DEVICE_COLOR)
406: {
407: pGdiInfo->ciDevice.RedGamma = colorCapabilities.RedGamma;
408: pGdiInfo->ciDevice.GreenGamma = colorCapabilities.GreenGamma;
409: pGdiInfo->ciDevice.BlueGamma = colorCapabilities.BlueGamma;
410: }
411: else
412: {
413: pGdiInfo->ciDevice.RedGamma = colorCapabilities.WhiteGamma;
414: pGdiInfo->ciDevice.GreenGamma = colorCapabilities.WhiteGamma;
415: pGdiInfo->ciDevice.BlueGamma = colorCapabilities.WhiteGamma;
416: }
417:
418: };
419:
420: pGdiInfo->ciDevice.Cyan.x = 0;
421: pGdiInfo->ciDevice.Cyan.y = 0;
422: pGdiInfo->ciDevice.Cyan.Y = 0;
423: pGdiInfo->ciDevice.Magenta.x = 0;
424: pGdiInfo->ciDevice.Magenta.y = 0;
425: pGdiInfo->ciDevice.Magenta.Y = 0;
426: pGdiInfo->ciDevice.Yellow.x = 0;
427: pGdiInfo->ciDevice.Yellow.y = 0;
428: pGdiInfo->ciDevice.Yellow.Y = 0;
429:
430: // No dye correction for raster displays.
431:
432: pGdiInfo->ciDevice.MagentaInCyanDye = 0;
433: pGdiInfo->ciDevice.YellowInCyanDye = 0;
434: pGdiInfo->ciDevice.CyanInMagentaDye = 0;
435: pGdiInfo->ciDevice.YellowInMagentaDye = 0;
436: pGdiInfo->ciDevice.CyanInYellowDye = 0;
437: pGdiInfo->ciDevice.MagentaInYellowDye = 0;
438:
439: pGdiInfo->ulDevicePelsDPI = 0; // For printers only
440: pGdiInfo->ulPrimaryOrder = PRIMARY_ORDER_CBA;
441:
442: // BUGBUG this should be modified to take into account the size
443: // of the display and the resolution.
444:
445: pGdiInfo->ulHTPatternSize = HT_PATSIZE_4x4_M;
446:
447: pGdiInfo->flHTFlags = HT_FLAG_ADDITIVE_PRIMS;
448:
449: // Fill in the basic devinfo structure
450:
451: *pDevInfo = gDevInfoFrameBuffer;
452:
453: // Fill in the rest of the devinfo and GdiInfo structures.
454:
455: if (ppdev->ulBitCount == 8)
456: {
457:
458: // BUGBUG check if we have a palette managed device.
459: // BUGBUG why is ulNumColors set to 20 ?
460:
461: // It is Palette Managed.
462:
463: pGdiInfo->ulNumColors = 20;
464: pGdiInfo->ulNumPalReg = 1 << ppdev->ulBitCount;
465:
466: pGdiInfo->flRaster |= RC_PALETTE;
467: pGdiInfo->ulHTOutputFormat = HT_FORMAT_8BPP;
468:
469: pDevInfo->iDitherFormat = BMF_8BPP;
470: pDevInfo->flGraphicsCaps |= (GCAPS_PALMANAGED | GCAPS_COLOR_DITHER);
471:
472: }
473: else
474: {
475: pGdiInfo->ulNumColors = 1 << ppdev->ulBitCount;
476: pGdiInfo->ulNumPalReg = 0;
477:
478: pDevInfo->iDitherFormat = BMF_16BPP;
479: pGdiInfo->ulHTOutputFormat = HT_FORMAT_16BPP;
480: }
481:
482: LocalFree(pVideoBuffer);
483:
484: return(TRUE);
485: }
486:
487:
488: /******************************Public*Routine******************************\
489: * getAvailableModes
490: *
491: * Calls the miniport to get the list of modes supported by the kernel driver,
492: * and returns the list of modes supported by the diplay driver among those
493: *
494: * returns the number of entries in the videomode buffer.
495: * 0 means no modes are supported by the miniport or that an error occured.
496: *
497: * NOTE: the buffer must be freed up by the caller.
498: *
499: \**************************************************************************/
500:
501: DWORD getAvailableModes(
502: HANDLE hDriver,
503: PVIDEO_MODE_INFORMATION *modeInformation,
504: DWORD *cbModeSize)
505: {
506: ULONG ulTemp;
507: VIDEO_NUM_MODES modes;
508: PVIDEO_MODE_INFORMATION pVideoTemp;
509:
510: //
511: // Get the number of modes supported by the mini-port
512: //
513:
514: if (!DeviceIoControl(hDriver,
515: IOCTL_VIDEO_QUERY_NUM_AVAIL_MODES,
516: NULL,
517: 0,
518: &modes,
519: sizeof(VIDEO_NUM_MODES),
520: &ulTemp,
521: NULL))
522: {
523: DISPDBG((0, "xga.dll getAvailableModes failed VIDEO_QUERY_NUM_AVAIL_MODES\n"));
524: return(0);
525: }
526:
527: *cbModeSize = modes.ModeInformationLength;
528:
529: //
530: // Allocate the buffer for the mini-port to write the modes in.
531: //
532:
533: *modeInformation = (PVIDEO_MODE_INFORMATION)
534: LocalAlloc(LMEM_FIXED | LMEM_ZEROINIT,
535: modes.NumModes *
536: modes.ModeInformationLength);
537:
538: if (*modeInformation == (PVIDEO_MODE_INFORMATION) NULL)
539: {
540: DISPDBG((0, "xga.dll getAvailableModes failed LocalAlloc\n"));
541:
542: return 0;
543: }
544:
545: //
546: // Ask the mini-port to fill in the available modes.
547: //
548:
549: if (!DeviceIoControl(hDriver,
550: IOCTL_VIDEO_QUERY_AVAIL_MODES,
551: NULL,
552: 0,
553: *modeInformation,
554: modes.NumModes * modes.ModeInformationLength,
555: &ulTemp,
556: NULL))
557: {
558:
559: DISPDBG((0, "xga.dll getAvailableModes failed VIDEO_QUERY_AVAIL_MODES\n"));
560:
561: LocalFree(*modeInformation);
562: *modeInformation = (PVIDEO_MODE_INFORMATION) NULL;
563:
564: return(0);
565: }
566:
567: //
568: // Now see which of these modes are supported by the display driver.
569: // As an internal mechanism, set the length to 0 for the modes we
570: // DO NOT support.
571: //
572:
573: ulTemp = modes.NumModes;
574: pVideoTemp = *modeInformation;
575:
576: //
577: // Mode is rejected if it is not one plane, or not graphics, or is not
578: // one of 8 bits per pel.
579: //
580:
581: while (ulTemp--)
582: {
583: if ((pVideoTemp->NumberOfPlanes != 1 ) ||
584: !(pVideoTemp->AttributeFlags & VIDEO_MODE_GRAPHICS) ||
585: (pVideoTemp->BitsPerPlane != 8))
586: {
587: pVideoTemp->Length = 0;
588: }
589:
590: pVideoTemp = (PVIDEO_MODE_INFORMATION)
591: (((PUCHAR)pVideoTemp) + modes.ModeInformationLength);
592: }
593:
594: return modes.NumModes;
595:
596: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.