You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1146 lines
59 KiB
1146 lines
59 KiB
/* |
|
File: Video.h |
|
|
|
Contains: Video Driver Interfaces. |
|
|
|
Version: QuickTime 7.3 |
|
|
|
Copyright: (c) 2007 (c) 1986-2001 by Apple Computer, Inc., all rights reserved |
|
|
|
Bugs?: For bug reports, consult the following page on |
|
the World Wide Web: |
|
|
|
http://developer.apple.com/bugreporter/ |
|
|
|
*/ |
|
#ifndef __VIDEO__ |
|
#define __VIDEO__ |
|
|
|
#ifndef __QUICKDRAW__ |
|
#include <Quickdraw.h> |
|
#endif |
|
|
|
|
|
|
|
|
|
#if PRAGMA_ONCE |
|
#pragma once |
|
#endif |
|
|
|
#if PRAGMA_IMPORT |
|
#pragma import on |
|
#endif |
|
|
|
#if PRAGMA_STRUCT_ALIGN |
|
#pragma options align=mac68k |
|
#elif PRAGMA_STRUCT_PACKPUSH |
|
#pragma pack(push, 2) |
|
#elif PRAGMA_STRUCT_PACK |
|
#pragma pack(2) |
|
#endif |
|
|
|
enum { |
|
mBaseOffset = 1, /*Id of mBaseOffset.*/ |
|
mRowBytes = 2, /*Video sResource parameter Id's */ |
|
mBounds = 3, /*Video sResource parameter Id's */ |
|
mVersion = 4, /*Video sResource parameter Id's */ |
|
mHRes = 5, /*Video sResource parameter Id's */ |
|
mVRes = 6, /*Video sResource parameter Id's */ |
|
mPixelType = 7, /*Video sResource parameter Id's */ |
|
mPixelSize = 8, /*Video sResource parameter Id's */ |
|
mCmpCount = 9, /*Video sResource parameter Id's */ |
|
mCmpSize = 10, /*Video sResource parameter Id's */ |
|
mPlaneBytes = 11, /*Video sResource parameter Id's */ |
|
mVertRefRate = 14, /*Video sResource parameter Id's */ |
|
mVidParams = 1, /*Video parameter block id.*/ |
|
mTable = 2, /*Offset to the table.*/ |
|
mPageCnt = 3, /*Number of pages*/ |
|
mDevType = 4, /*Device Type*/ |
|
oneBitMode = 128, /*Id of OneBitMode Parameter list.*/ |
|
twoBitMode = 129, /*Id of TwoBitMode Parameter list.*/ |
|
fourBitMode = 130, /*Id of FourBitMode Parameter list.*/ |
|
eightBitMode = 131 /*Id of EightBitMode Parameter list.*/ |
|
}; |
|
|
|
enum { |
|
sixteenBitMode = 132, /*Id of SixteenBitMode Parameter list.*/ |
|
thirtyTwoBitMode = 133, /*Id of ThirtyTwoBitMode Parameter list.*/ |
|
firstVidMode = 128, /*The new, better way to do the above. */ |
|
secondVidMode = 129, /* QuickDraw only supports six video */ |
|
thirdVidMode = 130, /* at this time. */ |
|
fourthVidMode = 131, |
|
fifthVidMode = 132, |
|
sixthVidMode = 133, |
|
spGammaDir = 64, |
|
spVidNamesDir = 65 |
|
}; |
|
|
|
|
|
/* csTimingFormat values in VDTimingInfo */ |
|
/* look in the declaration rom for timing info */ |
|
enum { |
|
kDeclROMtables = FOUR_CHAR_CODE('decl'), |
|
kDetailedTimingFormat = FOUR_CHAR_CODE('arba') /* Timing is a detailed timing*/ |
|
}; |
|
|
|
/* Size of a block of EDID (Extended Display Identification Data) */ |
|
enum { |
|
kDDCBlockSize = 128 |
|
}; |
|
|
|
/* ddcBlockType constants*/ |
|
enum { |
|
kDDCBlockTypeEDID = 0 /* EDID block type. */ |
|
}; |
|
|
|
/* ddcFlags constants*/ |
|
enum { |
|
kDDCForceReadBit = 0, /* Force a new read of the EDID. */ |
|
kDDCForceReadMask = (1 << kDDCForceReadBit) /* Mask for kddcForceReadBit. */ |
|
}; |
|
|
|
|
|
/* Timing mode constants for Display Manager MultiMode support |
|
Corresponding .h equates are in Video.h |
|
.a equates are in Video.a |
|
.r equates are in DepVideoEqu.r |
|
|
|
The second enum is the old names (for compatibility). |
|
The first enum is the new names. |
|
*/ |
|
enum { |
|
timingInvalid = 0, /* Unknown timing... force user to confirm. */ |
|
timingInvalid_SM_T24 = 8, /* Work around bug in SM Thunder24 card.*/ |
|
timingApple_FixedRateLCD = 42, /* Lump all fixed-rate LCDs into one category.*/ |
|
timingApple_512x384_60hz = 130, /* 512x384 (60 Hz) Rubik timing. */ |
|
timingApple_560x384_60hz = 135, /* 560x384 (60 Hz) Rubik-560 timing. */ |
|
timingApple_640x480_67hz = 140, /* 640x480 (67 Hz) HR timing. */ |
|
timingApple_640x400_67hz = 145, /* 640x400 (67 Hz) HR-400 timing. */ |
|
timingVESA_640x480_60hz = 150, /* 640x480 (60 Hz) VGA timing. */ |
|
timingVESA_640x480_72hz = 152, /* 640x480 (72 Hz) VGA timing. */ |
|
timingVESA_640x480_75hz = 154, /* 640x480 (75 Hz) VGA timing. */ |
|
timingVESA_640x480_85hz = 158, /* 640x480 (85 Hz) VGA timing. */ |
|
timingGTF_640x480_120hz = 159, /* 640x480 (120 Hz) VESA Generalized Timing Formula */ |
|
timingApple_640x870_75hz = 160, /* 640x870 (75 Hz) FPD timing.*/ |
|
timingApple_640x818_75hz = 165, /* 640x818 (75 Hz) FPD-818 timing.*/ |
|
timingApple_832x624_75hz = 170, /* 832x624 (75 Hz) GoldFish timing.*/ |
|
timingVESA_800x600_56hz = 180, /* 800x600 (56 Hz) SVGA timing. */ |
|
timingVESA_800x600_60hz = 182, /* 800x600 (60 Hz) SVGA timing. */ |
|
timingVESA_800x600_72hz = 184, /* 800x600 (72 Hz) SVGA timing. */ |
|
timingVESA_800x600_75hz = 186, /* 800x600 (75 Hz) SVGA timing. */ |
|
timingVESA_800x600_85hz = 188, /* 800x600 (85 Hz) SVGA timing. */ |
|
timingVESA_1024x768_60hz = 190, /* 1024x768 (60 Hz) VESA 1K-60Hz timing. */ |
|
timingVESA_1024x768_70hz = 200, /* 1024x768 (70 Hz) VESA 1K-70Hz timing. */ |
|
timingVESA_1024x768_75hz = 204, /* 1024x768 (75 Hz) VESA 1K-75Hz timing (very similar to timingApple_1024x768_75hz). */ |
|
timingVESA_1024x768_85hz = 208, /* 1024x768 (85 Hz) VESA timing. */ |
|
timingApple_1024x768_75hz = 210, /* 1024x768 (75 Hz) Apple 19" RGB. */ |
|
timingApple_1152x870_75hz = 220, /* 1152x870 (75 Hz) Apple 21" RGB. */ |
|
timingAppleNTSC_ST = 230, /* 512x384 (60 Hz, interlaced, non-convolved). */ |
|
timingAppleNTSC_FF = 232, /* 640x480 (60 Hz, interlaced, non-convolved). */ |
|
timingAppleNTSC_STconv = 234, /* 512x384 (60 Hz, interlaced, convolved). */ |
|
timingAppleNTSC_FFconv = 236, /* 640x480 (60 Hz, interlaced, convolved). */ |
|
timingApplePAL_ST = 238, /* 640x480 (50 Hz, interlaced, non-convolved). */ |
|
timingApplePAL_FF = 240, /* 768x576 (50 Hz, interlaced, non-convolved). */ |
|
timingApplePAL_STconv = 242, /* 640x480 (50 Hz, interlaced, convolved). */ |
|
timingApplePAL_FFconv = 244, /* 768x576 (50 Hz, interlaced, convolved). */ |
|
timingVESA_1280x960_75hz = 250, /* 1280x960 (75 Hz) */ |
|
timingVESA_1280x960_60hz = 252, /* 1280x960 (60 Hz) */ |
|
timingVESA_1280x960_85hz = 254, /* 1280x960 (85 Hz) */ |
|
timingVESA_1280x1024_60hz = 260, /* 1280x1024 (60 Hz) */ |
|
timingVESA_1280x1024_75hz = 262, /* 1280x1024 (75 Hz) */ |
|
timingVESA_1280x1024_85hz = 268, /* 1280x1024 (85 Hz) */ |
|
timingVESA_1600x1200_60hz = 280, /* 1600x1200 (60 Hz) VESA timing. */ |
|
timingVESA_1600x1200_65hz = 282, /* 1600x1200 (65 Hz) VESA timing. */ |
|
timingVESA_1600x1200_70hz = 284, /* 1600x1200 (70 Hz) VESA timing. */ |
|
timingVESA_1600x1200_75hz = 286, /* 1600x1200 (75 Hz) VESA timing (pixel clock is 189.2 Mhz dot clock). */ |
|
timingVESA_1600x1200_80hz = 288, /* 1600x1200 (80 Hz) VESA timing (pixel clock is 216>? Mhz dot clock) - proposed only. */ |
|
timingVESA_1600x1200_85hz = 289, /* 1600x1200 (85 Hz) VESA timing (pixel clock is 229.5 Mhz dot clock). */ |
|
timingVESA_1792x1344_60hz = 296, /* 1792x1344 (60 Hz) VESA timing (204.75 Mhz dot clock). */ |
|
timingVESA_1792x1344_75hz = 298, /* 1792x1344 (75 Hz) VESA timing (261.75 Mhz dot clock). */ |
|
timingVESA_1856x1392_60hz = 300, /* 1856x1392 (60 Hz) VESA timing (218.25 Mhz dot clock). */ |
|
timingVESA_1856x1392_75hz = 302, /* 1856x1392 (75 Hz) VESA timing (288 Mhz dot clock). */ |
|
timingVESA_1920x1440_60hz = 304, /* 1920x1440 (60 Hz) VESA timing (234 Mhz dot clock). */ |
|
timingVESA_1920x1440_75hz = 306, /* 1920x1440 (75 Hz) VESA timing (297 Mhz dot clock). */ |
|
timingSMPTE240M_60hz = 400, /* 60Hz V, 33.75KHz H, interlaced timing, 16:9 aspect, typical resolution of 1920x1035. */ |
|
timingFilmRate_48hz = 410, /* 48Hz V, 25.20KHz H, non-interlaced timing, typical resolution of 640x480. */ |
|
timingSony_1600x1024_76hz = 500, /* 1600x1024 (76 Hz) Sony timing (pixel clock is 170.447 Mhz dot clock). */ |
|
timingSony_1920x1080_60hz = 510, /* 1920x1080 (60 Hz) Sony timing (pixel clock is 159.84 Mhz dot clock). */ |
|
timingSony_1920x1080_72hz = 520, /* 1920x1080 (72 Hz) Sony timing (pixel clock is 216.023 Mhz dot clock). */ |
|
timingSony_1920x1200_76hz = 540, /* 1900x1200 (76 Hz) Sony timing (pixel clock is 243.20 Mhz dot clock). */ |
|
timingApple_0x0_0hz_Offline = 550 /* Indicates that this timing will take the display off-line and remove it from the system. */ |
|
}; |
|
|
|
|
|
/* Deprecated timing names.*/ |
|
enum { |
|
timingApple12 = timingApple_512x384_60hz, |
|
timingApple12x = timingApple_560x384_60hz, |
|
timingApple13 = timingApple_640x480_67hz, |
|
timingApple13x = timingApple_640x400_67hz, |
|
timingAppleVGA = timingVESA_640x480_60hz, |
|
timingApple15 = timingApple_640x870_75hz, |
|
timingApple15x = timingApple_640x818_75hz, |
|
timingApple16 = timingApple_832x624_75hz, |
|
timingAppleSVGA = timingVESA_800x600_56hz, |
|
timingApple1Ka = timingVESA_1024x768_60hz, |
|
timingApple1Kb = timingVESA_1024x768_70hz, |
|
timingApple19 = timingApple_1024x768_75hz, |
|
timingApple21 = timingApple_1152x870_75hz, |
|
timingSony_1900x1200_74hz = 530, /* 1900x1200 (74 Hz) Sony timing (pixel clock is 236.25 Mhz dot clock). */ |
|
timingSony_1900x1200_76hz = timingSony_1920x1200_76hz /* 1900x1200 (76 Hz) Sony timing (pixel clock is 245.48 Mhz dot clock). */ |
|
}; |
|
|
|
/* csConnectFlags values in VDDisplayConnectInfo */ |
|
enum { |
|
kAllModesValid = 0, /* All modes not trimmed by primary init are good close enough to try */ |
|
kAllModesSafe = 1, /* All modes not trimmed by primary init are know to be safe */ |
|
kReportsTagging = 2, /* Can detect tagged displays (to identify smart monitors) */ |
|
kHasDirectConnection = 3, /* True implies that driver can talk directly to device (e.g. serial data link via sense lines) */ |
|
kIsMonoDev = 4, /* Says whether there's an RGB (0) or Monochrome (1) connection. */ |
|
kUncertainConnection = 5, /* There may not be a display (no sense lines?). */ |
|
kTaggingInfoNonStandard = 6, /* Set when csConnectTaggedType/csConnectTaggedData are non-standard (i.e., not the Apple CRT sense codes). */ |
|
kReportsDDCConnection = 7, /* Card can do ddc (set kHasDirectConnect && kHasDDCConnect if you actually found a ddc display). */ |
|
kHasDDCConnection = 8, /* Card has ddc connect now. */ |
|
kConnectionInactive = 9, /* Set when the connection is NOT currently active (generally used in a multiconnection environment). */ |
|
kDependentConnection = 10, /* Set when some ascpect of THIS connection depends on another (will generally be set in a kModeSimulscan environment). */ |
|
kBuiltInConnection = 11, /* Set when connection is KNOWN to be built-in (this is not the same as kHasDirectConnection). */ |
|
kOverrideConnection = 12, /* Set when the reported connection is not the true one, but is one that has been forced through a SetConnection call */ |
|
kFastCheckForDDC = 13, /* Set when all 3 are true: 1) sense codes indicate DDC display could be attached 2) attempted fast check 3) DDC failed */ |
|
kReportsHotPlugging = 14 /* Detects and reports hot pluggging on connector (via VSL also implies DDC will be up to date w/o force read) */ |
|
}; |
|
|
|
|
|
/* csDisplayType values in VDDisplayConnectInfo */ |
|
enum { |
|
kUnknownConnect = 1, /* Not sure how we'll use this, but seems like a good idea. */ |
|
kPanelConnect = 2, /* For use with fixed-in-place LCD panels. */ |
|
kPanelTFTConnect = 2, /* Alias for kPanelConnect */ |
|
kFixedModeCRTConnect = 3, /* For use with fixed-mode (i.e., very limited range) displays. */ |
|
kMultiModeCRT1Connect = 4, /* 320x200 maybe, 12" maybe, 13" (default), 16" certain, 19" maybe, 21" maybe */ |
|
kMultiModeCRT2Connect = 5, /* 320x200 maybe, 12" maybe, 13" certain, 16" (default), 19" certain, 21" maybe */ |
|
kMultiModeCRT3Connect = 6, /* 320x200 maybe, 12" maybe, 13" certain, 16" certain, 19" default, 21" certain */ |
|
kMultiModeCRT4Connect = 7, /* Expansion to large multi mode (not yet used) */ |
|
kModelessConnect = 8, /* Expansion to modeless model (not yet used) */ |
|
kFullPageConnect = 9, /* 640x818 (to get 8bpp in 512K case) and 640x870 (these two only) */ |
|
kVGAConnect = 10, /* 640x480 VGA default -- question everything else */ |
|
kNTSCConnect = 11, /* NTSC ST (default), FF, STconv, FFconv */ |
|
kPALConnect = 12, /* PAL ST (default), FF, STconv, FFconv */ |
|
kHRConnect = 13, /* Straight-6 connect -- 640x480 and 640x400 (to get 8bpp in 256K case) (these two only) */ |
|
kPanelFSTNConnect = 14, /* For use with fixed-in-place LCD FSTN (aka "Supertwist") panels */ |
|
kMonoTwoPageConnect = 15, /* 1152x870 Apple color two-page display */ |
|
kColorTwoPageConnect = 16, /* 1152x870 Apple B&W two-page display */ |
|
kColor16Connect = 17, /* 832x624 Apple B&W two-page display */ |
|
kColor19Connect = 18, /* 1024x768 Apple B&W two-page display */ |
|
kGenericCRT = 19, /* Indicates nothing except that connection is CRT in nature. */ |
|
kGenericLCD = 20, /* Indicates nothing except that connection is LCD in nature. */ |
|
kDDCConnect = 21, /* DDC connection, always set kHasDDCConnection */ |
|
kNoConnect = 22 /* No display is connected - load sensing or similar level of hardware detection is assumed (used by resident drivers that support hot plugging when nothing is currently connected) */ |
|
}; |
|
|
|
/* csTimingFlags values in VDTimingInfoRec */ |
|
enum { |
|
kModeValid = 0, /* Says that this mode should NOT be trimmed. */ |
|
kModeSafe = 1, /* This mode does not need confirmation */ |
|
kModeDefault = 2, /* This is the default mode for this type of connection */ |
|
kModeShowNow = 3, /* This mode should always be shown (even though it may require a confirm) */ |
|
kModeNotResize = 4, /* This mode should not be used to resize the display (eg. mode selects a different connector on card) */ |
|
kModeRequiresPan = 5, /* This mode has more pixels than are actually displayed */ |
|
kModeInterlaced = 6, /* This mode is interlaced (single pixel lines look bad). */ |
|
kModeShowNever = 7, /* This mode should not be shown in the user interface. */ |
|
kModeSimulscan = 8, /* Indicates that more than one display connection can be driven from a single framebuffer controller. */ |
|
kModeNotPreset = 9, /* Indicates that the timing is not a factory preset for the current display (geometry may need correction) */ |
|
kModeBuiltIn = 10, /* Indicates that the display mode is for the built-in connect only (on multiconnect devices like the PB 3400) Only the driver is quieried */ |
|
kModeStretched = 11 /* Indicates that the display mode will be stretched/distorted to match the display aspect ratio */ |
|
}; |
|
|
|
/* csDepthFlags in VDVideoParametersInfoRec */ |
|
enum { |
|
kDepthDependent = 0 /* Says that this depth mode may cause dependent changes in other framebuffers (and . */ |
|
}; |
|
|
|
/* csResolutionFlags bit flags for VDResolutionInfoRec */ |
|
enum { |
|
kResolutionHasMultipleDepthSizes = 0 /* Says that this mode has different csHorizontalPixels, csVerticalLines at different depths (usually slightly larger at lower depths) */ |
|
}; |
|
|
|
|
|
enum { |
|
/* Power Mode constants for VDPowerStateRec.powerState. Note the numeric order does not match the power state order */ |
|
kAVPowerOff = 0, /* Power fully off*/ |
|
kAVPowerStandby = 1, |
|
kAVPowerSuspend = 2, |
|
kAVPowerOn = 3, |
|
kHardwareSleep = 128, |
|
kHardwareWake = 129, |
|
kHardwareWakeFromSuspend = 130, |
|
kHardwareWakeToDoze = 131, |
|
kHardwareWakeToDozeFromSuspend = 132 |
|
}; |
|
|
|
enum { |
|
/* Power Mode masks and bits for VDPowerStateRec.powerFlags. */ |
|
kPowerStateNeedsRefresh = 0, /* When leaving this power mode, a display will need refreshing */ |
|
kPowerStateSleepAwareBit = 1, /* if gestaltPCCardDockingSelectorFix, Docking mgr checks this bit before checking kPowerStateSleepAllowedBit */ |
|
kPowerStateSleepForbiddenBit = 2, /* if kPowerStateSleepAwareBit, Docking mgr checks this bit before sleeping */ |
|
kPowerStateSleepCanPowerOffBit = 3, /* supports power down sleep (ie PCI power off)*/ |
|
kPowerStateSleepNoDPMSBit = 4, /* Bug #2425210. Do not use DPMS with this display.*/ |
|
kPowerStateSleepWaketoDozeBit = 5, /* Supports Wake to Doze */ |
|
kPowerStateNeedsRefreshMask = (1L << kPowerStateNeedsRefresh), |
|
kPowerStateSleepAwareMask = (1L << kPowerStateSleepAwareBit), |
|
kPowerStateSleepForbiddenMask = (1L << kPowerStateSleepForbiddenBit), |
|
kPowerStateSleepCanPowerOffMask = (1L << kPowerStateSleepCanPowerOffBit), |
|
kPowerStateSleepNoDPMSMask = (1L << kPowerStateSleepNoDPMSBit), |
|
kPowerStateSleepWaketoDozeMask = (1L << kPowerStateSleepWaketoDozeBit) |
|
}; |
|
|
|
|
|
enum { |
|
/* Control Codes */ |
|
cscReset = 0, |
|
cscKillIO = 1, |
|
cscSetMode = 2, |
|
cscSetEntries = 3, |
|
cscSetGamma = 4, |
|
cscGrayPage = 5, |
|
cscGrayScreen = 5, |
|
cscSetGray = 6, |
|
cscSetInterrupt = 7, |
|
cscDirectSetEntries = 8, |
|
cscSetDefaultMode = 9, |
|
cscSwitchMode = 10, /* Takes a VDSwitchInfoPtr */ |
|
cscSetSync = 11, /* Takes a VDSyncInfoPtr */ |
|
cscSavePreferredConfiguration = 16, /* Takes a VDSwitchInfoPtr */ |
|
cscSetHardwareCursor = 22, /* Takes a VDSetHardwareCursorPtr */ |
|
cscDrawHardwareCursor = 23, /* Takes a VDDrawHardwareCursorPtr */ |
|
cscSetConvolution = 24, /* Takes a VDConvolutionInfoPtr */ |
|
cscSetPowerState = 25, /* Takes a VDPowerStatePtr */ |
|
cscPrivateControlCall = 26, /* Takes a VDPrivateSelectorDataPtr */ |
|
cscSetMultiConnect = 28, /* Takes a VDMultiConnectInfoPtr */ |
|
cscSetClutBehavior = 29, /* Takes a VDClutBehavior */ |
|
cscSetDetailedTiming = 31, /* Takes a VDDetailedTimingPtr */ |
|
cscDoCommunication = 33, /* Takes a VDCommunicationPtr */ |
|
cscProbeConnection = 34, /* Takes nil pointer (may generate a kFBConnectInterruptServiceType service interrupt)*/ |
|
cscUnusedCall = 127 /* This call used to expend the scrn resource. Its imbedded data contains more control info */ |
|
}; |
|
|
|
enum { |
|
/* Status Codes */ |
|
cscGetMode = 2, |
|
cscGetEntries = 3, |
|
cscGetPageCnt = 4, |
|
cscGetPages = 4, /* This is what C&D 2 calls it. */ |
|
cscGetPageBase = 5, |
|
cscGetBaseAddr = 5, /* This is what C&D 2 calls it. */ |
|
cscGetGray = 6, |
|
cscGetInterrupt = 7, |
|
cscGetGamma = 8, |
|
cscGetDefaultMode = 9, |
|
cscGetCurMode = 10, /* Takes a VDSwitchInfoPtr */ |
|
cscGetSync = 11, /* Takes a VDSyncInfoPtr */ |
|
cscGetConnection = 12, /* Return information about the connection to the display */ |
|
cscGetModeTiming = 13, /* Return timing info for a mode */ |
|
cscGetModeBaseAddress = 14, /* Return base address information about a particular mode */ |
|
cscGetScanProc = 15, /* QuickTime scan chasing routine */ |
|
cscGetPreferredConfiguration = 16, /* Takes a VDSwitchInfoPtr */ |
|
cscGetNextResolution = 17, /* Takes a VDResolutionInfoPtr */ |
|
cscGetVideoParameters = 18, /* Takes a VDVideoParametersInfoPtr */ |
|
cscGetGammaInfoList = 20, /* Takes a VDGetGammaListPtr */ |
|
cscRetrieveGammaTable = 21, /* Takes a VDRetrieveGammaPtr */ |
|
cscSupportsHardwareCursor = 22, /* Takes a VDSupportsHardwareCursorPtr */ |
|
cscGetHardwareCursorDrawState = 23, /* Takes a VDHardwareCursorDrawStatePtr */ |
|
cscGetConvolution = 24, /* Takes a VDConvolutionInfoPtr */ |
|
cscGetPowerState = 25, /* Takes a VDPowerStatePtr */ |
|
cscPrivateStatusCall = 26, /* Takes a VDPrivateSelectorDataPtr */ |
|
cscGetDDCBlock = 27, /* Takes a VDDDCBlockPtr */ |
|
cscGetMultiConnect = 28, /* Takes a VDMultiConnectInfoPtr */ |
|
cscGetClutBehavior = 29, /* Takes a VDClutBehaviorPtr */ |
|
cscGetTimingRanges = 30, /* Takes a VDDisplayTimingRangePtr */ |
|
cscGetDetailedTiming = 31, /* Takes a VDDetailedTimingPtr */ |
|
cscGetCommunicationInfo = 32 /* Takes a VDCommunicationInfoPtr */ |
|
}; |
|
|
|
/* Bit definitions for the Get/Set Sync call*/ |
|
enum { |
|
kDisableHorizontalSyncBit = 0, |
|
kDisableVerticalSyncBit = 1, |
|
kDisableCompositeSyncBit = 2, |
|
kEnableSyncOnBlue = 3, |
|
kEnableSyncOnGreen = 4, |
|
kEnableSyncOnRed = 5, |
|
kNoSeparateSyncControlBit = 6, |
|
kTriStateSyncBit = 7, |
|
kHorizontalSyncMask = 0x01, |
|
kVerticalSyncMask = 0x02, |
|
kCompositeSyncMask = 0x04, |
|
kDPMSSyncMask = 0x07, |
|
kTriStateSyncMask = 0x80, |
|
kSyncOnBlueMask = 0x08, |
|
kSyncOnGreenMask = 0x10, |
|
kSyncOnRedMask = 0x20, |
|
kSyncOnMask = 0x38 |
|
}; |
|
|
|
enum { |
|
/* Power Mode constants for translating DPMS modes to Get/SetSync calls. */ |
|
kDPMSSyncOn = 0, |
|
kDPMSSyncStandby = 1, |
|
kDPMSSyncSuspend = 2, |
|
kDPMSSyncOff = 7 |
|
}; |
|
|
|
/* Bit definitions for the Get/Set Convolution call*/ |
|
enum { |
|
kConvolved = 0, |
|
kLiveVideoPassThru = 1, |
|
kConvolvedMask = 0x01, |
|
kLiveVideoPassThruMask = 0x02 |
|
}; |
|
|
|
|
|
struct VPBlock { |
|
long vpBaseOffset; /*Offset to page zero of video RAM (From minorBaseOS).*/ |
|
short vpRowBytes; /*Width of each row of video memory.*/ |
|
Rect vpBounds; /*BoundsRect for the video display (gives dimensions).*/ |
|
short vpVersion; /*PixelMap version number.*/ |
|
short vpPackType; |
|
long vpPackSize; |
|
long vpHRes; /*Horizontal resolution of the device (pixels per inch).*/ |
|
long vpVRes; /*Vertical resolution of the device (pixels per inch).*/ |
|
short vpPixelType; /*Defines the pixel type.*/ |
|
short vpPixelSize; /*Number of bits in pixel.*/ |
|
short vpCmpCount; /*Number of components in pixel.*/ |
|
short vpCmpSize; /*Number of bits per component*/ |
|
long vpPlaneBytes; /*Offset from one plane to the next.*/ |
|
}; |
|
typedef struct VPBlock VPBlock; |
|
typedef VPBlock * VPBlockPtr; |
|
struct VDEntryRecord { |
|
Ptr csTable; /*(long) pointer to color table entry=value, r,g,b:INTEGER*/ |
|
}; |
|
typedef struct VDEntryRecord VDEntryRecord; |
|
typedef VDEntryRecord * VDEntRecPtr; |
|
/* Parm block for SetGray control call */ |
|
struct VDGrayRecord { |
|
Boolean csMode; /*Same as GDDevType value (0=color, 1=mono)*/ |
|
SInt8 filler; |
|
}; |
|
typedef struct VDGrayRecord VDGrayRecord; |
|
typedef VDGrayRecord * VDGrayPtr; |
|
/* Parm block for SetInterrupt call */ |
|
struct VDFlagRecord { |
|
SInt8 csMode; |
|
SInt8 filler; |
|
}; |
|
typedef struct VDFlagRecord VDFlagRecord; |
|
typedef VDFlagRecord * VDFlagRecPtr; |
|
/* Parm block for SetEntries control call */ |
|
struct VDSetEntryRecord { |
|
ColorSpec * csTable; /*Pointer to an array of color specs*/ |
|
short csStart; /*Which spec in array to start with, or -1*/ |
|
short csCount; /*Number of color spec entries to set*/ |
|
}; |
|
typedef struct VDSetEntryRecord VDSetEntryRecord; |
|
typedef VDSetEntryRecord * VDSetEntryPtr; |
|
/* Parm block for SetGamma control call */ |
|
struct VDGammaRecord { |
|
Ptr csGTable; /*pointer to gamma table*/ |
|
}; |
|
typedef struct VDGammaRecord VDGammaRecord; |
|
typedef VDGammaRecord * VDGamRecPtr; |
|
struct VDBaseAddressInfoRec { |
|
long csDevData; /* LONGINT - (long) timing mode */ |
|
long csDevBase; /* LONGINT - (long) base address of the mode */ |
|
short csModeReserved; /* INTEGER - (short) will some day be the depth */ |
|
long csModeBase; /* LONGINT - (long) reserved */ |
|
}; |
|
typedef struct VDBaseAddressInfoRec VDBaseAddressInfoRec; |
|
typedef VDBaseAddressInfoRec * VDBaseAddressInfoPtr; |
|
struct VDSwitchInfoRec { |
|
unsigned short csMode; /*(word) mode depth*/ |
|
unsigned long csData; /*(long) functional sResource of mode*/ |
|
unsigned short csPage; /*(word) page to switch in*/ |
|
Ptr csBaseAddr; /*(long) base address of page (return value)*/ |
|
unsigned long csReserved; /*(long) Reserved (set to 0) */ |
|
}; |
|
typedef struct VDSwitchInfoRec VDSwitchInfoRec; |
|
typedef VDSwitchInfoRec * VDSwitchInfoPtr; |
|
struct VDTimingInfoRec { |
|
unsigned long csTimingMode; /* LONGINT - (long) timing mode (a la InitGDevice) */ |
|
unsigned long csTimingReserved; /* LONGINT - (long) reserved */ |
|
unsigned long csTimingFormat; /* LONGINT - (long) what format is the timing info */ |
|
unsigned long csTimingData; /* LONGINT - (long) data supplied by driver */ |
|
unsigned long csTimingFlags; /* LONGINT - (long) mode within device */ |
|
}; |
|
typedef struct VDTimingInfoRec VDTimingInfoRec; |
|
typedef VDTimingInfoRec * VDTimingInfoPtr; |
|
struct VDDisplayConnectInfoRec { |
|
unsigned short csDisplayType; /* INTEGER - (word) Type of display connected */ |
|
unsigned char csConnectTaggedType; /* BYTE - type of tagging */ |
|
unsigned char csConnectTaggedData; /* BYTE - tagging data */ |
|
unsigned long csConnectFlags; /* LONGINT - (long) tell us about the connection */ |
|
unsigned long csDisplayComponent; /* LONGINT - (long) if the card has a direct connection to the display, it returns the display component here (FUTURE) */ |
|
unsigned long csConnectReserved; /* LONGINT - (long) reserved */ |
|
}; |
|
typedef struct VDDisplayConnectInfoRec VDDisplayConnectInfoRec; |
|
typedef VDDisplayConnectInfoRec * VDDisplayConnectInfoPtr; |
|
struct VDMultiConnectInfoRec { |
|
unsigned long csDisplayCountOrNumber; /* For GetMultiConnect, returns count n of 1..n connections; otherwise, indicates the ith connection.*/ |
|
VDDisplayConnectInfoRec csConnectInfo; /* Standard VDDisplayConnectionInfo for connection i.*/ |
|
}; |
|
typedef struct VDMultiConnectInfoRec VDMultiConnectInfoRec; |
|
typedef VDMultiConnectInfoRec * VDMultiConnectInfoPtr; |
|
/* RawSenseCode |
|
This abstract data type is not exactly abstract. Rather, it is merely enumerated constants |
|
for the possible raw sense code values when 'standard' sense code hardware is implemented. |
|
|
|
For 'standard' sense code hardware, the raw sense is obtained as follows: |
|
o Instruct the frame buffer controller NOT to actively drive any of the monitor sense lines |
|
o Read the state of the monitor sense lines 2, 1, and 0. (2 is the MSB, 0 the LSB) |
|
|
|
IMPORTANT Note: |
|
When the 'kTaggingInfoNonStandard' bit of 'csConnectFlags' is FALSE, then these constants |
|
are valid 'csConnectTaggedType' values in 'VDDisplayConnectInfo' |
|
|
|
*/ |
|
typedef unsigned char RawSenseCode; |
|
enum { |
|
kRSCZero = 0, |
|
kRSCOne = 1, |
|
kRSCTwo = 2, |
|
kRSCThree = 3, |
|
kRSCFour = 4, |
|
kRSCFive = 5, |
|
kRSCSix = 6, |
|
kRSCSeven = 7 |
|
}; |
|
|
|
|
|
/* ExtendedSenseCode |
|
This abstract data type is not exactly abstract. Rather, it is merely enumerated constants |
|
for the values which are possible when the extended sense algorithm is applied to hardware |
|
which implements 'standard' sense code hardware. |
|
|
|
For 'standard' sense code hardware, the extended sense code algorithm is as follows: |
|
(Note: as described here, sense line 'A' corresponds to '2', 'B' to '1', and 'C' to '0') |
|
o Drive sense line 'A' low and read the values of 'B' and 'C'. |
|
o Drive sense line 'B' low and read the values of 'A' and 'C'. |
|
o Drive sense line 'C' low and read the values of 'A' and 'B'. |
|
|
|
In this way, a six-bit number of the form BC/AC/AB is generated. |
|
|
|
IMPORTANT Note: |
|
When the 'kTaggingInfoNonStandard' bit of 'csConnectFlags' is FALSE, then these constants |
|
are valid 'csConnectTaggedData' values in 'VDDisplayConnectInfo' |
|
|
|
*/ |
|
typedef unsigned char ExtendedSenseCode; |
|
enum { |
|
kESCZero21Inch = 0x00, /* 21" RGB */ |
|
kESCOnePortraitMono = 0x14, /* Portrait Monochrome */ |
|
kESCTwo12Inch = 0x21, /* 12" RGB */ |
|
kESCThree21InchRadius = 0x31, /* 21" RGB (Radius) */ |
|
kESCThree21InchMonoRadius = 0x34, /* 21" Monochrome (Radius) */ |
|
kESCThree21InchMono = 0x35, /* 21" Monochrome */ |
|
kESCFourNTSC = 0x0A, /* NTSC */ |
|
kESCFivePortrait = 0x1E, /* Portrait RGB */ |
|
kESCSixMSB1 = 0x03, /* MultiScan Band-1 (12" thru 1Six") */ |
|
kESCSixMSB2 = 0x0B, /* MultiScan Band-2 (13" thru 19") */ |
|
kESCSixMSB3 = 0x23, /* MultiScan Band-3 (13" thru 21") */ |
|
kESCSixStandard = 0x2B, /* 13"/14" RGB or 12" Monochrome */ |
|
kESCSevenPAL = 0x00, /* PAL */ |
|
kESCSevenNTSC = 0x14, /* NTSC */ |
|
kESCSevenVGA = 0x17, /* VGA */ |
|
kESCSeven16Inch = 0x2D, /* 16" RGB (GoldFish) */ |
|
kESCSevenPALAlternate = 0x30, /* PAL (Alternate) */ |
|
kESCSeven19Inch = 0x3A, /* Third-Party 19" */ |
|
kESCSevenDDC = 0x3E, /* DDC display */ |
|
kESCSevenNoDisplay = 0x3F /* No display connected */ |
|
}; |
|
|
|
/* DepthMode |
|
This abstract data type is used to to reference RELATIVE pixel depths. |
|
Its definition is largely derived from its past usage, analogous to 'xxxVidMode' |
|
|
|
Bits per pixel DOES NOT directly map to 'DepthMode' For example, on some |
|
graphics hardware, 'kDepthMode1' may represent 1 BPP, whereas on other |
|
hardware, 'kDepthMode1' may represent 8BPP. |
|
|
|
DepthMode IS considered to be ordinal, i.e., operations such as <, >, ==, etc. |
|
behave as expected. The values of the constants which comprise the set are such |
|
that 'kDepthMode4 < kDepthMode6' behaves as expected. |
|
*/ |
|
typedef unsigned short DepthMode; |
|
enum { |
|
kDepthMode1 = 128, |
|
kDepthMode2 = 129, |
|
kDepthMode3 = 130, |
|
kDepthMode4 = 131, |
|
kDepthMode5 = 132, |
|
kDepthMode6 = 133 |
|
}; |
|
|
|
enum { |
|
kFirstDepthMode = 128, /* These constants are obsolete, and just included */ |
|
kSecondDepthMode = 129, /* for clients that have converted to the above */ |
|
kThirdDepthMode = 130, /* kDepthModeXXX constants. */ |
|
kFourthDepthMode = 131, |
|
kFifthDepthMode = 132, |
|
kSixthDepthMode = 133 |
|
}; |
|
|
|
|
|
struct VDPageInfo { |
|
short csMode; /*(word) mode within device*/ |
|
long csData; /*(long) data supplied by driver*/ |
|
short csPage; /*(word) page to switch in*/ |
|
Ptr csBaseAddr; /*(long) base address of page*/ |
|
}; |
|
typedef struct VDPageInfo VDPageInfo; |
|
typedef VDPageInfo * VDPgInfoPtr; |
|
struct VDSizeInfo { |
|
short csHSize; /*(word) desired/returned h size*/ |
|
short csHPos; /*(word) desired/returned h position*/ |
|
short csVSize; /*(word) desired/returned v size*/ |
|
short csVPos; /*(word) desired/returned v position*/ |
|
}; |
|
typedef struct VDSizeInfo VDSizeInfo; |
|
typedef VDSizeInfo * VDSzInfoPtr; |
|
struct VDSettings { |
|
short csParamCnt; /*(word) number of params*/ |
|
short csBrightMax; /*(word) max brightness*/ |
|
short csBrightDef; /*(word) default brightness*/ |
|
short csBrightVal; /*(word) current brightness*/ |
|
short csCntrstMax; /*(word) max contrast*/ |
|
short csCntrstDef; /*(word) default contrast*/ |
|
short csCntrstVal; /*(word) current contrast*/ |
|
short csTintMax; /*(word) max tint*/ |
|
short csTintDef; /*(word) default tint*/ |
|
short csTintVal; /*(word) current tint*/ |
|
short csHueMax; /*(word) max hue*/ |
|
short csHueDef; /*(word) default hue*/ |
|
short csHueVal; /*(word) current hue*/ |
|
short csHorizDef; /*(word) default horizontal*/ |
|
short csHorizVal; /*(word) current horizontal*/ |
|
short csHorizMax; /*(word) max horizontal*/ |
|
short csVertDef; /*(word) default vertical*/ |
|
short csVertVal; /*(word) current vertical*/ |
|
short csVertMax; /*(word) max vertical*/ |
|
}; |
|
typedef struct VDSettings VDSettings; |
|
typedef VDSettings * VDSettingsPtr; |
|
struct VDDefMode { |
|
UInt8 csID; |
|
SInt8 filler; |
|
}; |
|
typedef struct VDDefMode VDDefMode; |
|
typedef VDDefMode * VDDefModePtr; |
|
struct VDSyncInfoRec { |
|
UInt8 csMode; |
|
UInt8 csFlags; |
|
}; |
|
typedef struct VDSyncInfoRec VDSyncInfoRec; |
|
typedef VDSyncInfoRec * VDSyncInfoPtr; |
|
typedef UInt32 AVIDType; |
|
typedef AVIDType DisplayIDType; |
|
typedef UInt32 DisplayModeID; |
|
typedef UInt32 VideoDeviceType; |
|
typedef UInt32 GammaTableID; |
|
/* |
|
All displayModeID values from 0x80000000 to 0xFFFFFFFF and 0x00 |
|
are reserved for Apple Computer. |
|
*/ |
|
/* Constants for the cscGetNextResolution call */ |
|
enum { |
|
kDisplayModeIDCurrent = 0x00, /* Reference the Current DisplayModeID */ |
|
kDisplayModeIDInvalid = (long)0xFFFFFFFF, /* A bogus DisplayModeID in all cases */ |
|
kDisplayModeIDFindFirstResolution = (long)0xFFFFFFFE, /* Used in cscGetNextResolution to reset iterator */ |
|
kDisplayModeIDNoMoreResolutions = (long)0xFFFFFFFD, /* Used in cscGetNextResolution to indicate End Of List */ |
|
kDisplayModeIDFindFirstProgrammable = (long)0xFFFFFFFC, /* Used in cscGetNextResolution to find unused programmable timing */ |
|
kDisplayModeIDBootProgrammable = (long)0xFFFFFFFB, /* This is the ID given at boot time by the OF driver to a programmable timing */ |
|
kDisplayModeIDReservedBase = (long)0x80000000 /* Lowest (unsigned) DisplayModeID reserved by Apple */ |
|
}; |
|
|
|
/* Constants for the GetGammaInfoList call */ |
|
enum { |
|
kGammaTableIDFindFirst = (long)0xFFFFFFFE, /* Get the first gamma table ID */ |
|
kGammaTableIDNoMoreTables = (long)0xFFFFFFFD, /* Used to indicate end of list */ |
|
kGammaTableIDSpecific = 0x00 /* Return the info for the given table id */ |
|
}; |
|
|
|
/* Constants for GetMultiConnect call*/ |
|
enum { |
|
kGetConnectionCount = (long)0xFFFFFFFF, /* Used to get the number of possible connections in a "multi-headed" framebuffer environment.*/ |
|
kActivateConnection = (0 << kConnectionInactive), /* Used for activating a connection (csConnectFlags value).*/ |
|
kDeactivateConnection = (1 << kConnectionInactive) /* Used for deactivating a connection (csConnectFlags value.)*/ |
|
}; |
|
|
|
/* VDCommunicationRec.csBusID values*/ |
|
enum { |
|
kVideoDefaultBus = 0 |
|
}; |
|
|
|
|
|
/* VDCommunicationInfoRec.csBusType values*/ |
|
enum { |
|
kVideoBusTypeInvalid = 0, |
|
kVideoBusTypeI2C = 1 |
|
}; |
|
|
|
|
|
/* VDCommunicationRec.csSendType and VDCommunicationRec.csReplyType values and bits in VDCommunicationInfoRec.csSupportedTypes.*/ |
|
enum { |
|
kVideoNoTransactionType = 0, /* No transaction*/ |
|
kVideoSimpleI2CType = 1, /* Simple I2C message*/ |
|
kVideoDDCciReplyType = 2 /* DDC/ci message (with imbedded length)*/ |
|
}; |
|
|
|
/* VDCommunicationRec.csCommFlags and VDCommunicationInfoRec.csSupportedCommFlags*/ |
|
enum { |
|
kVideoReplyMicroSecDelayMask = (1 << 0) /* If set, the driver should delay csMinReplyDelay micro seconds between send and recieve*/ |
|
}; |
|
|
|
|
|
|
|
struct VDResolutionInfoRec { |
|
DisplayModeID csPreviousDisplayModeID; /* ID of the previous resolution in a chain */ |
|
DisplayModeID csDisplayModeID; /* ID of the next resolution */ |
|
unsigned long csHorizontalPixels; /* # of pixels in a horizontal line at the max depth */ |
|
unsigned long csVerticalLines; /* # of lines in a screen at the max depth */ |
|
Fixed csRefreshRate; /* Vertical Refresh Rate in Hz */ |
|
DepthMode csMaxDepthMode; /* 0x80-based number representing max bit depth */ |
|
unsigned long csResolutionFlags; /* Reserved - flag bits */ |
|
unsigned long csReserved; /* Reserved */ |
|
}; |
|
typedef struct VDResolutionInfoRec VDResolutionInfoRec; |
|
typedef VDResolutionInfoRec * VDResolutionInfoPtr; |
|
struct VDVideoParametersInfoRec { |
|
DisplayModeID csDisplayModeID; /* the ID of the resolution we want info on */ |
|
DepthMode csDepthMode; /* The bit depth we want the info on (0x80 based) */ |
|
VPBlockPtr csVPBlockPtr; /* Pointer to a video parameter block */ |
|
unsigned long csPageCount; /* Number of pages supported by the resolution */ |
|
VideoDeviceType csDeviceType; /* Device Type: Direct, Fixed or CLUT; */ |
|
UInt32 csDepthFlags; /* Flags */ |
|
}; |
|
typedef struct VDVideoParametersInfoRec VDVideoParametersInfoRec; |
|
typedef VDVideoParametersInfoRec * VDVideoParametersInfoPtr; |
|
struct VDGammaInfoRec { |
|
GammaTableID csLastGammaID; /* the ID of the previous gamma table */ |
|
GammaTableID csNextGammaID; /* the ID of the next gamma table */ |
|
Ptr csGammaPtr; /* Ptr to a gamma table data */ |
|
unsigned long csReserved; /* Reserved */ |
|
}; |
|
typedef struct VDGammaInfoRec VDGammaInfoRec; |
|
typedef VDGammaInfoRec * VDGammaInfoPtr; |
|
struct VDGetGammaListRec { |
|
GammaTableID csPreviousGammaTableID; /* ID of the previous gamma table */ |
|
GammaTableID csGammaTableID; /* ID of the gamma table following csPreviousDisplayModeID */ |
|
unsigned long csGammaTableSize; /* Size of the gamma table in bytes */ |
|
char * csGammaTableName; /* Gamma table name (c-string) */ |
|
}; |
|
typedef struct VDGetGammaListRec VDGetGammaListRec; |
|
typedef VDGetGammaListRec * VDGetGammaListPtr; |
|
struct VDRetrieveGammaRec { |
|
GammaTableID csGammaTableID; /* ID of gamma table to retrieve */ |
|
GammaTbl * csGammaTablePtr; /* Location to copy desired gamma to */ |
|
}; |
|
typedef struct VDRetrieveGammaRec VDRetrieveGammaRec; |
|
typedef VDRetrieveGammaRec * VDRetrieveGammaPtr; |
|
struct VDSetHardwareCursorRec { |
|
void * csCursorRef; /* reference to cursor data */ |
|
UInt32 csReserved1; /* reserved for future use */ |
|
UInt32 csReserved2; /* should be ignored */ |
|
}; |
|
typedef struct VDSetHardwareCursorRec VDSetHardwareCursorRec; |
|
typedef VDSetHardwareCursorRec * VDSetHardwareCursorPtr; |
|
struct VDDrawHardwareCursorRec { |
|
SInt32 csCursorX; /* x coordinate */ |
|
SInt32 csCursorY; /* y coordinate */ |
|
UInt32 csCursorVisible; /* true if cursor is must be visible */ |
|
UInt32 csReserved1; /* reserved for future use */ |
|
UInt32 csReserved2; /* should be ignored */ |
|
}; |
|
typedef struct VDDrawHardwareCursorRec VDDrawHardwareCursorRec; |
|
typedef VDDrawHardwareCursorRec * VDDrawHardwareCursorPtr; |
|
struct VDSupportsHardwareCursorRec { |
|
UInt32 csSupportsHardwareCursor; |
|
/* true if hardware cursor is supported */ |
|
UInt32 csReserved1; /* reserved for future use */ |
|
UInt32 csReserved2; /* must be zero */ |
|
}; |
|
typedef struct VDSupportsHardwareCursorRec VDSupportsHardwareCursorRec; |
|
typedef VDSupportsHardwareCursorRec * VDSupportsHardwareCursorPtr; |
|
struct VDHardwareCursorDrawStateRec { |
|
SInt32 csCursorX; /* x coordinate */ |
|
SInt32 csCursorY; /* y coordinate */ |
|
UInt32 csCursorVisible; /* true if cursor is visible */ |
|
UInt32 csCursorSet; /* true if cursor successfully set by last set control call */ |
|
UInt32 csReserved1; /* reserved for future use */ |
|
UInt32 csReserved2; /* must be zero */ |
|
}; |
|
typedef struct VDHardwareCursorDrawStateRec VDHardwareCursorDrawStateRec; |
|
typedef VDHardwareCursorDrawStateRec * VDHardwareCursorDrawStatePtr; |
|
struct VDConvolutionInfoRec { |
|
DisplayModeID csDisplayModeID; /* the ID of the resolution we want info on */ |
|
DepthMode csDepthMode; /* The bit depth we want the info on (0x80 based) */ |
|
unsigned long csPage; |
|
UInt32 csFlags; |
|
UInt32 csReserved; |
|
}; |
|
typedef struct VDConvolutionInfoRec VDConvolutionInfoRec; |
|
typedef VDConvolutionInfoRec * VDConvolutionInfoPtr; |
|
struct VDPowerStateRec { |
|
unsigned long powerState; |
|
unsigned long powerFlags; |
|
|
|
unsigned long powerReserved1; |
|
unsigned long powerReserved2; |
|
}; |
|
typedef struct VDPowerStateRec VDPowerStateRec; |
|
typedef VDPowerStateRec * VDPowerStatePtr; |
|
/* |
|
Private Data to video drivers. |
|
|
|
In versions of MacOS with multiple address spaces (System 8), the OS |
|
must know the extent of parameters in order to move them between the caller |
|
and driver. The old private-selector model for video drivers does not have |
|
this information so: |
|
|
|
For post-7.x Systems private calls should be implemented using the cscPrivateCall |
|
*/ |
|
struct VDPrivateSelectorDataRec { |
|
LogicalAddress privateParameters; /* Caller's parameters*/ |
|
ByteCount privateParametersSize; /* Size of data sent from caller to driver*/ |
|
LogicalAddress privateResults; /* Caller's return area. Can be nil, or same as privateParameters.*/ |
|
ByteCount privateResultsSize; /* Size of data driver returns to caller. Can be nil, or same as privateParametersSize.*/ |
|
}; |
|
typedef struct VDPrivateSelectorDataRec VDPrivateSelectorDataRec; |
|
|
|
struct VDPrivateSelectorRec { |
|
UInt32 reserved; /* Reserved (set to 0). */ |
|
VDPrivateSelectorDataRec data[1]; |
|
}; |
|
typedef struct VDPrivateSelectorRec VDPrivateSelectorRec; |
|
struct VDDDCBlockRec { |
|
UInt32 ddcBlockNumber; /* Input -- DDC EDID (Extended Display Identification Data) number (1-based) */ |
|
ResType ddcBlockType; /* Input -- DDC block type (EDID/VDIF) */ |
|
UInt32 ddcFlags; /* Input -- DDC Flags*/ |
|
UInt32 ddcReserved; /* Reserved */ |
|
Byte ddcBlockData[128]; /* Output -- DDC EDID/VDIF data (kDDCBlockSize) */ |
|
}; |
|
typedef struct VDDDCBlockRec VDDDCBlockRec; |
|
typedef VDDDCBlockRec * VDDDCBlockPtr; |
|
|
|
enum { |
|
/* timingSyncConfiguration*/ |
|
kSyncInterlaceMask = (1 << 7), |
|
kSyncAnalogCompositeMask = 0, |
|
kSyncAnalogCompositeSerrateMask = (1 << 2), |
|
kSyncAnalogCompositeRGBSyncMask = (1 << 1), |
|
kSyncAnalogBipolarMask = (1 << 3), |
|
kSyncAnalogBipolarSerrateMask = (1 << 2), |
|
kSyncAnalogBipolarSRGBSyncMask = (1 << 1), |
|
kSyncDigitalCompositeMask = (1 << 4), |
|
kSyncDigitalCompositeSerrateMask = (1 << 2), |
|
kSyncDigitalCompositeMatchHSyncMask = (1 << 2), |
|
kSyncDigitalSeperateMask = (1 << 4) + (1 << 3), |
|
kSyncDigitalVSyncPositiveMask = (1 << 2), |
|
kSyncDigitalHSyncPositiveMask = (1 << 1) |
|
}; |
|
|
|
|
|
|
|
struct VDDisplayTimingRangeRec { |
|
UInt32 csRangeSize; /* Init to sizeof(VDDisplayTimingRangeRec) */ |
|
UInt32 csRangeType; /* Init to 0 */ |
|
UInt32 csRangeVersion; /* Init to 0 */ |
|
UInt32 csRangeReserved; /* Init to 0 */ |
|
|
|
UInt32 csRangeBlockIndex; /* Requested block (first index is 0)*/ |
|
UInt32 csRangeGroup; /* set to 0 */ |
|
UInt32 csRangeBlockCount; /* # blocks */ |
|
UInt32 csRangeFlags; /* dependent video */ |
|
|
|
UInt64 csMinPixelClock; /* Min dot clock in Hz */ |
|
UInt64 csMaxPixelClock; /* Max dot clock in Hz */ |
|
|
|
UInt32 csMaxPixelError; /* Max dot clock error */ |
|
UInt32 csTimingRangeSyncFlags; |
|
UInt32 csTimingRangeSignalLevels; |
|
UInt32 csReserved0; |
|
|
|
UInt32 csMinFrameRate; /* Hz */ |
|
UInt32 csMaxFrameRate; /* Hz */ |
|
UInt32 csMinLineRate; /* Hz */ |
|
UInt32 csMaxLineRate; /* Hz */ |
|
|
|
|
|
UInt32 csMaxHorizontalTotal; /* Clocks - Maximum total (active + blanking) */ |
|
UInt32 csMaxVerticalTotal; /* Clocks - Maximum total (active + blanking) */ |
|
UInt32 csMaxTotalReserved1; /* Reserved */ |
|
UInt32 csMaxTotalReserved2; /* Reserved */ |
|
|
|
|
|
|
|
/* Some cards require that some timing elements*/ |
|
/* be multiples of a "character size" (often 8*/ |
|
/* clocks). The "xxxxCharSize" fields document*/ |
|
/* those requirements.*/ |
|
|
|
|
|
UInt8 csCharSizeHorizontalActive; /* Character size */ |
|
UInt8 csCharSizeHorizontalBlanking; /* Character size */ |
|
UInt8 csCharSizeHorizontalSyncOffset; /* Character size */ |
|
UInt8 csCharSizeHorizontalSyncPulse; /* Character size */ |
|
|
|
UInt8 csCharSizeVerticalActive; /* Character size */ |
|
UInt8 csCharSizeVerticalBlanking; /* Character size */ |
|
UInt8 csCharSizeVerticalSyncOffset; /* Character size */ |
|
UInt8 csCharSizeVerticalSyncPulse; /* Character size */ |
|
|
|
UInt8 csCharSizeHorizontalBorderLeft; /* Character size */ |
|
UInt8 csCharSizeHorizontalBorderRight; /* Character size */ |
|
UInt8 csCharSizeVerticalBorderTop; /* Character size */ |
|
UInt8 csCharSizeVerticalBorderBottom; /* Character size */ |
|
|
|
UInt8 csCharSizeHorizontalTotal; /* Character size for active + blanking */ |
|
UInt8 csCharSizeVerticalTotal; /* Character size for active + blanking */ |
|
UInt16 csCharSizeReserved1; /* Reserved (Init to 0) */ |
|
|
|
|
|
UInt32 csMinHorizontalActiveClocks; |
|
UInt32 csMaxHorizontalActiveClocks; |
|
UInt32 csMinHorizontalBlankingClocks; |
|
UInt32 csMaxHorizontalBlankingClocks; |
|
|
|
UInt32 csMinHorizontalSyncOffsetClocks; |
|
UInt32 csMaxHorizontalSyncOffsetClocks; |
|
UInt32 csMinHorizontalPulseWidthClocks; |
|
UInt32 csMaxHorizontalPulseWidthClocks; |
|
|
|
UInt32 csMinVerticalActiveClocks; |
|
UInt32 csMaxVerticalActiveClocks; |
|
UInt32 csMinVerticalBlankingClocks; |
|
UInt32 csMaxVerticalBlankingClocks; |
|
|
|
UInt32 csMinVerticalSyncOffsetClocks; |
|
UInt32 csMaxVerticalSyncOffsetClocks; |
|
UInt32 csMinVerticalPulseWidthClocks; |
|
UInt32 csMaxVerticalPulseWidthClocks; |
|
|
|
|
|
UInt32 csMinHorizontalBorderLeft; |
|
UInt32 csMaxHorizontalBorderLeft; |
|
UInt32 csMinHorizontalBorderRight; |
|
UInt32 csMaxHorizontalBorderRight; |
|
|
|
UInt32 csMinVerticalBorderTop; |
|
UInt32 csMaxVerticalBorderTop; |
|
UInt32 csMinVerticalBorderBottom; |
|
UInt32 csMaxVerticalBorderBottom; |
|
|
|
UInt32 csReserved1; /* Reserved (Init to 0)*/ |
|
UInt32 csReserved2; /* Reserved (Init to 0)*/ |
|
UInt32 csReserved3; /* Reserved (Init to 0)*/ |
|
UInt32 csReserved4; /* Reserved (Init to 0)*/ |
|
|
|
UInt32 csReserved5; /* Reserved (Init to 0)*/ |
|
UInt32 csReserved6; /* Reserved (Init to 0)*/ |
|
UInt32 csReserved7; /* Reserved (Init to 0)*/ |
|
UInt32 csReserved8; /* Reserved (Init to 0)*/ |
|
}; |
|
typedef struct VDDisplayTimingRangeRec VDDisplayTimingRangeRec; |
|
typedef VDDisplayTimingRangeRec * VDDisplayTimingRangePtr; |
|
|
|
enum { |
|
/* csDisplayModeState*/ |
|
kDMSModeReady = 0, /* Display Mode ID is configured and ready*/ |
|
kDMSModeNotReady = 1, /* Display Mode ID is is being programmed*/ |
|
kDMSModeFree = 2 /* Display Mode ID is not associated with a timing*/ |
|
}; |
|
|
|
|
|
/* Video driver Errors -10930 to -10959 */ |
|
enum { |
|
kTimingChangeRestrictedErr = -10930, |
|
kVideoI2CReplyPendingErr = -10931, |
|
kVideoI2CTransactionErr = -10932, |
|
kVideoI2CBusyErr = -10933, |
|
kVideoI2CTransactionTypeErr = -10934, |
|
kVideoBufferSizeErr = -10935 |
|
}; |
|
|
|
|
|
enum { |
|
/* csTimingRangeSignalLevels*/ |
|
kRangeSupportsSignal_0700_0300_Bit = 0, |
|
kRangeSupportsSignal_0714_0286_Bit = 1, |
|
kRangeSupportsSignal_1000_0400_Bit = 2, |
|
kRangeSupportsSignal_0700_0000_Bit = 3, |
|
kRangeSupportsSignal_0700_0300_Mask = (1 << kRangeSupportsSignal_0700_0300_Bit), |
|
kRangeSupportsSignal_0714_0286_Mask = (1 << kRangeSupportsSignal_0714_0286_Bit), |
|
kRangeSupportsSignal_1000_0400_Mask = (1 << kRangeSupportsSignal_1000_0400_Bit), |
|
kRangeSupportsSignal_0700_0000_Mask = (1 << kRangeSupportsSignal_0700_0000_Bit) |
|
}; |
|
|
|
|
|
enum { |
|
/* csSignalConfig*/ |
|
kDigitalSignalBit = 0, /* Do not set. Mac OS does not currently support arbitrary digital timings*/ |
|
kAnalogSetupExpectedBit = 1, /* Analog displays - display expects a blank-to-black setup or pedestal. See VESA signal standards.*/ |
|
kDigitalSignalMask = (1 << kDigitalSignalBit), |
|
kAnalogSetupExpectedMask = (1 << kAnalogSetupExpectedBit) |
|
}; |
|
|
|
|
|
enum { |
|
/* csSignalLevels for analog*/ |
|
kAnalogSignalLevel_0700_0300 = 0, |
|
kAnalogSignalLevel_0714_0286 = 1, |
|
kAnalogSignalLevel_1000_0400 = 2, |
|
kAnalogSignalLevel_0700_0000 = 3 |
|
}; |
|
|
|
|
|
enum { |
|
/* csTimingRangeSyncFlags*/ |
|
kRangeSupportsSeperateSyncsBit = 0, |
|
kRangeSupportsSyncOnGreenBit = 1, |
|
kRangeSupportsCompositeSyncBit = 2, |
|
kRangeSupportsVSyncSerrationBit = 3, |
|
kRangeSupportsSeperateSyncsMask = (1 << kRangeSupportsSeperateSyncsBit), |
|
kRangeSupportsSyncOnGreenMask = (1 << kRangeSupportsSyncOnGreenBit), |
|
kRangeSupportsCompositeSyncMask = (1 << kRangeSupportsCompositeSyncBit), |
|
kRangeSupportsVSyncSerrationMask = (1 << kRangeSupportsVSyncSerrationBit) |
|
}; |
|
|
|
|
|
|
|
enum { |
|
/* csHorizontalSyncConfig and csVerticalSyncConfig*/ |
|
kSyncPositivePolarityBit = 0, /* Digital separate sync polarity for analog interfaces (0 => negative polarity)*/ |
|
kSyncPositivePolarityMask = (1 << kSyncPositivePolarityBit) |
|
}; |
|
|
|
|
|
|
|
|
|
/* For timings with kDetailedTimingFormat.*/ |
|
struct VDDetailedTimingRec { |
|
UInt32 csTimingSize; /* Init to sizeof(VDDetailedTimingRec)*/ |
|
UInt32 csTimingType; /* Init to 0*/ |
|
UInt32 csTimingVersion; /* Init to 0*/ |
|
UInt32 csTimingReserved; /* Init to 0*/ |
|
|
|
DisplayModeID csDisplayModeID; /* Init to 0*/ |
|
UInt32 csDisplayModeSeed; /* */ |
|
UInt32 csDisplayModeState; /* Display Mode state*/ |
|
UInt32 csDisplayModeAlias; /* Mode to use when programmed.*/ |
|
|
|
UInt32 csSignalConfig; |
|
UInt32 csSignalLevels; |
|
|
|
UInt64 csPixelClock; /* Hz*/ |
|
|
|
UInt64 csMinPixelClock; /* Hz - With error what is slowest actual clock */ |
|
UInt64 csMaxPixelClock; /* Hz - With error what is fasted actual clock */ |
|
|
|
|
|
UInt32 csHorizontalActive; /* Pixels*/ |
|
UInt32 csHorizontalBlanking; /* Pixels*/ |
|
UInt32 csHorizontalSyncOffset; /* Pixels*/ |
|
UInt32 csHorizontalSyncPulseWidth; /* Pixels*/ |
|
|
|
UInt32 csVerticalActive; /* Lines*/ |
|
UInt32 csVerticalBlanking; /* Lines*/ |
|
UInt32 csVerticalSyncOffset; /* Lines*/ |
|
UInt32 csVerticalSyncPulseWidth; /* Lines*/ |
|
|
|
UInt32 csHorizontalBorderLeft; /* Pixels*/ |
|
UInt32 csHorizontalBorderRight; /* Pixels*/ |
|
UInt32 csVerticalBorderTop; /* Lines*/ |
|
UInt32 csVerticalBorderBottom; /* Lines*/ |
|
|
|
UInt32 csHorizontalSyncConfig; |
|
UInt32 csHorizontalSyncLevel; /* Future use (init to 0)*/ |
|
UInt32 csVerticalSyncConfig; |
|
UInt32 csVerticalSyncLevel; /* Future use (init to 0)*/ |
|
|
|
UInt32 csReserved1; /* Init to 0*/ |
|
UInt32 csReserved2; /* Init to 0*/ |
|
UInt32 csReserved3; /* Init to 0*/ |
|
UInt32 csReserved4; /* Init to 0*/ |
|
|
|
UInt32 csReserved5; /* Init to 0*/ |
|
UInt32 csReserved6; /* Init to 0*/ |
|
UInt32 csReserved7; /* Init to 0*/ |
|
UInt32 csReserved8; /* Init to 0*/ |
|
}; |
|
typedef struct VDDetailedTimingRec VDDetailedTimingRec; |
|
typedef VDDetailedTimingRec * VDDetailedTimingPtr; |
|
typedef UInt32 VDClutBehavior; |
|
typedef VDClutBehavior * VDClutBehaviorPtr; |
|
enum { |
|
kSetClutAtSetEntries = 0, /* SetEntries behavior is to update clut during SetEntries call*/ |
|
kSetClutAtVBL = 1 /* SetEntries behavior is to upate clut at next vbl*/ |
|
}; |
|
|
|
|
|
struct VDCommunicationRec { |
|
SInt32 csBusID; /* kVideoDefaultBus for single headed cards.*/ |
|
UInt32 csCommFlags; /* Always zero*/ |
|
UInt32 csMinReplyDelay; /* Minimum delay between send and reply transactions (units depend on csCommFlags)*/ |
|
UInt32 csReserved2; /* Always zero*/ |
|
|
|
UInt32 csSendAddress; /* Usually I2C address (eg 0x6E)*/ |
|
UInt32 csSendType; /* See kVideoSimpleI2CType etc.*/ |
|
LogicalAddress csSendBuffer; /* Pointer to the send buffer*/ |
|
ByteCount csSendSize; /* Number of bytes to send*/ |
|
|
|
UInt32 csReplyAddress; /* Address from which to read (eg 0x6F for kVideoDDCciReplyType I2C address)*/ |
|
UInt32 csReplyType; /* See kVideoDDCciReplyType etc.*/ |
|
LogicalAddress csReplyBuffer; /* Pointer to the reply buffer*/ |
|
ByteCount csReplySize; /* Max bytes to reply (size of csReplyBuffer)*/ |
|
|
|
UInt32 csReserved3; |
|
UInt32 csReserved4; |
|
UInt32 csReserved5; /* Always zero*/ |
|
UInt32 csReserved6; /* Always zero*/ |
|
}; |
|
typedef struct VDCommunicationRec VDCommunicationRec; |
|
typedef VDCommunicationRec * VDCommunicationPtr; |
|
struct VDCommunicationInfoRec { |
|
SInt32 csBusID; /* kVideoDefaultBus for single headed cards. */ |
|
UInt32 csBusType; /* See kVideoBusI2C etc.*/ |
|
SInt32 csMinBus; /* Minimum bus (usually kVideoDefaultBus). Used to probe additional busses*/ |
|
SInt32 csMaxBus; /* Max bus (usually kVideoDefaultBus). Used to probe additional busses*/ |
|
|
|
UInt32 csSupportedTypes; /* Bit field for first 32 supported transaction types. Eg. 0x07 => support for kVideoNoTransactionType, kVideoSimpleI2CType and kVideoDDCciReplyType.*/ |
|
UInt32 csSupportedCommFlags; /* Return the flags csCommFlags understood by this driver.*/ |
|
UInt32 csReserved2; /* Always zero*/ |
|
UInt32 csReserved3; /* Always zero*/ |
|
|
|
UInt32 csReserved4; /* Always zero*/ |
|
UInt32 csReserved5; /* Always zero*/ |
|
UInt32 csReserved6; /* Always zero*/ |
|
UInt32 csReserved7; /* Always zero*/ |
|
}; |
|
typedef struct VDCommunicationInfoRec VDCommunicationInfoRec; |
|
typedef VDCommunicationInfoRec * VDCommunicationInfoPtr; |
|
|
|
#if PRAGMA_STRUCT_ALIGN |
|
#pragma options align=reset |
|
#elif PRAGMA_STRUCT_PACKPUSH |
|
#pragma pack(pop) |
|
#elif PRAGMA_STRUCT_PACK |
|
#pragma pack() |
|
#endif |
|
|
|
#ifdef PRAGMA_IMPORT_OFF |
|
#pragma import off |
|
#elif PRAGMA_IMPORT |
|
#pragma import reset |
|
#endif |
|
|
|
|
|
#endif /* __VIDEO__ */ |
|
|
|
|