1HEADmaster

1 files changed, 1146 insertions, 0 deletions

diff --git a/common/quicktime_win32/Video.h b/common/quicktime_win32/Video.h
new file mode 100644
index 0000000..5667e99
--- /dev/null
+++ b/common/quicktime_win32/Video.h
@@ -0,0 +1,1146 @@
+/*
+     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__ */
+