//==========================================================================; // // THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY // KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE // IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR // PURPOSE. // // Copyright (c) 1992 - 1996 Microsoft Corporation. All Rights Reserved. // //==========================================================================; #ifndef __CAPMAIN_H__ #define __CAPMAIN_H__ #ifdef __cplusplus extern "C" { #endif // __cplusplus #ifdef TOSHIBA //#define _FPS_COUNT_ // For FPS confirm #endif//TOSHIBA #ifndef FIELDOFFSET #define FIELDOFFSET(type, field) (int)((INT_PTR)(&((type *)1)->field)-1) #endif #ifndef mmioFOURCC #define mmioFOURCC( ch0, ch1, ch2, ch3 ) \ ( (DWORD)(BYTE)(ch0) | ( (DWORD)(BYTE)(ch1) << 8 ) | \ ( (DWORD)(BYTE)(ch2) << 16 ) | ( (DWORD)(BYTE)(ch3) << 24 ) ) #endif #ifdef TOSHIBA #define FOURCC_YVU9 mmioFOURCC('Y', 'V', 'U', '9') #define FOURCC_YUV12 mmioFOURCC('I', '4', '2', '0') #else //TOSHIBA #define FOURCC_YUV422 mmioFOURCC('U', 'Y', 'V', 'Y') #endif//TOSHIBA typedef struct _STREAMX; typedef struct _STREAMX *PSTREAMX; #ifdef TOSHIBA #define MAX_TSBVCAP_STREAMS 2 #else //TOSHIBA #define MAX_TSBVCAP_STREAMS 4 #endif//TOSHIBA #ifdef TOSHIBA /* possible capture formats */ typedef enum _CAPTUREFORMAT { FmtInvalid = 0, // default fmt is 'not set yet' FmtYUV12, // yuv12 planar FmtYUV9, // yuv9 planar MaxCaptureFormat } CAPTUREFORMAT; #endif//TOSHIBA typedef struct _COMPRESSION_SETTINGS { LONG CompressionKeyFrameRate; LONG CompressionPFramesPerKeyFrame; LONG CompressionQuality; } COMPRESSION_SETTINGS, *PCOMPRESSION_SETTINGS; // // definition of the full HW device extension structure This is the structure // that will be allocated in HW_INITIALIZATION by the stream class driver // Any information that is used in processing a device request (as opposed to // a STREAM based request) should be in this structure. A pointer to this // structure will be passed in all requests to the minidriver. (See // HW_STREAM_REQUEST_BLOCK in STRMINI.H) // typedef struct _HW_DEVICE_EXTENSION { PULONG ioBaseLocal; // board base address USHORT Irq; // IRQ level BOOLEAN IRQExpected; // IRQ expected PSTREAMX pStrmEx [MAX_TSBVCAP_STREAMS]; // Pointers to each stream UINT ActualInstances [MAX_TSBVCAP_STREAMS]; // Counter of instances per stream PDEVICE_OBJECT PDO; // Physical Device Object DEVICE_POWER_STATE DeviceState; // D0 ... D3 // Spinlock and Queue for the Adapter BOOL AdapterQueueInitialized; // Stays TRUE after first init KSPIN_LOCK AdapterSpinLock; // Multiprocessor safe access to AdapterSRBList LIST_ENTRY AdapterSRBList; // List of pending adapter commands BOOL ProcessingAdapterSRB; // Master flag which prevents reentry // Spinlocks and Queues for each data stream LIST_ENTRY StreamSRBList[MAX_TSBVCAP_STREAMS]; // List of pending read requests KSPIN_LOCK StreamSRBSpinLock[MAX_TSBVCAP_STREAMS];// Multiprocessor safe access to StreamSRBList int StreamSRBListSize[MAX_TSBVCAP_STREAMS];// Number of entries in the list // Control Queues for each data stream LIST_ENTRY StreamControlSRBList[MAX_TSBVCAP_STREAMS]; BOOL ProcessingControlSRB[MAX_TSBVCAP_STREAMS]; #ifdef TOSHIBA // VideoProcAmp settings LONG Brightness; LONG BrightnessFlags; LONG Contrast; LONG ContrastFlags; LONG Hue; LONG HueFlags; LONG Saturation; LONG SaturationFlags; LONG ColorEnable; LONG ColorEnableFlags; // VideoControl settings (these are set if a pin is not opened, // otherwise, the STREAMEX values are used. LONG VideoControlMode; // Compressor settings (these are set if a pin is not opened, // otherwise, the STREAMEX values are used. COMPRESSION_SETTINGS CompressionSettings; #ifdef TOSHIBA // '98-12-09 Added, for Bug-Report 253529 KSPROPERTY_BOUNDS_LONG BrightnessRange; KSPROPERTY_BOUNDS_LONG ContrastRange; KSPROPERTY_BOUNDS_LONG HueRange; KSPROPERTY_BOUNDS_LONG SaturationRange; #endif//TOSHIBA // Misc volatile BOOL bVideoIn; // are we actually doing video in ? CAPTUREFORMAT Format; // format of destination DIB DWORD dwAsicRev; // source rectangle data RECT SrcRect; RECT MaxRect; // driver DMA structures for direct io PVOID pRpsDMABuf; // pointer to the RPS DMA buffer STREAM_PHYSICAL_ADDRESS pPhysRpsDMABuf;// physical address of RPS DMA buffer // driver capture buffer information PVOID pCaptureBufferY; PVOID pCaptureBufferU; PVOID pCaptureBufferV; STREAM_PHYSICAL_ADDRESS pPhysCaptureBufferY; STREAM_PHYSICAL_ADDRESS pPhysCaptureBufferU; STREAM_PHYSICAL_ADDRESS pPhysCaptureBufferV; PVOID pCapBuf2Y; PVOID pCapBuf2U; PVOID pCapBuf2V; STREAM_PHYSICAL_ADDRESS pPhysCapBuf2Y; STREAM_PHYSICAL_ADDRESS pPhysCapBuf2U; STREAM_PHYSICAL_ADDRESS pPhysCapBuf2V; BOOL dblBufflag; // configuration parameters for the video source and the format ULONG ulWidth; ULONG ulHeight; ULONG BufferSize; // RequestDpc flag for CaptureService BOOL bRequestDpc; volatile BOOLEAN DpcRequested; unsigned uiFramePerSecond; volatile DWORD s_physDmaActiveFlag; DWORD YoffsetOdd; DWORD UoffsetOdd; DWORD VoffsetOdd; DWORD YoffsetEven; DWORD UoffsetEven; DWORD VoffsetEven; DWORD Ystride; DWORD Ustride; DWORD Vstride; BOOL NeedCameraON; BOOL NeedCameraOFF; BOOL NeedHWInit; BOOL IsRPSReady; #else //TOSHIBA // Unique identifier for the analog video input pin KSPIN_MEDIUM AnalogVideoInputMedium; // Crossbar settings LONG VideoInputConnected; // which input is the video out connected to? LONG AudioInputConnected; // which input is the audio out connected to? // TV Tuner settings ULONG Frequency; ULONG VideoStandard; ULONG TuningQuality; ULONG TunerInput; ULONG Busy; // TV Audio settings ULONG TVAudioMode; // VideoProcAmp settings LONG Brightness; LONG BrightnessFlags; LONG Contrast; LONG ContrastFlags; LONG ColorEnable; LONG ColorEnableFlags; // CameraControl settings LONG Focus; LONG FocusFlags; LONG Zoom; LONG ZoomFlags; // AnalogVideoDecoder settings LONG VideoDecoderVideoStandard; LONG VideoDecoderOutputEnable; LONG VideoDecoderVCRTiming; // VideoControl settings (these are set if a pin is not opened, // otherwise, the STREAMEX values are used. LONG VideoControlMode; // Compressor settings (these are set if a pin is not opened, // otherwise, the STREAMEX values are used. COMPRESSION_SETTINGS CompressionSettings; // Channel Change information KS_TVTUNER_CHANGE_INFO TVTunerChangeInfo; #endif//TOSHIBA } HW_DEVICE_EXTENSION, *PHW_DEVICE_EXTENSION; // // this structure is our per stream extension structure. This stores // information that is relevant on a per stream basis. Whenever a new stream // is opened, the stream class driver will allocate whatever extension size // is specified in the HwInitData.PerStreamExtensionSize. // typedef struct _STREAMEX { PHW_DEVICE_EXTENSION pHwDevExt; // For timer use PHW_STREAM_OBJECT pStreamObject; // For timer use KS_VIDEOINFOHEADER *pVideoInfoHeader; // format (variable size!) KS_FRAME_INFO FrameInfo; // PictureNumber, etc. ULONG fDiscontinuity; // Discontinuity since last valid KSSTATE KSState; // Run, Stop, Pause UCHAR LineBuffer[720 * 3];// working buffer (RGB24) // Clock HANDLE hMasterClock; // Master clock to use REFERENCE_TIME QST_Now; // KeQuerySystemTime currently REFERENCE_TIME QST_NextFrame; // When to capture the next frame REFERENCE_TIME QST_StreamTime; // Stream time reported by master clock // Compressor settings (note these are duplicated in the // HW_DEVICE_EXTENSION to allow setting these before a pin is created) COMPRESSION_SETTINGS CompressionSettings; // VideoControl settings (note these are duplicated in the // HW_DEVICE_EXTENSION to allow setting these before a pin is created) LONG VideoControlMode; // Kernel DDraw interface BOOL KernelDirectDrawRegistered; HANDLE UserDirectDrawHandle; // DD itself HANDLE KernelDirectDrawHandle; BOOL PreEventOccurred; BOOL PostEventOccurred; } STREAMEX, *PSTREAMEX; // // this structure defines the per request extension. It defines any storage // space that the mini driver may need in each request packet. // typedef struct _SRB_EXTENSION { LIST_ENTRY ListEntry; PHW_STREAM_REQUEST_BLOCK pSrb; HANDLE UserSurfaceHandle; // DDraw HANDLE KernelSurfaceHandle; // DDraw } SRB_EXTENSION, * PSRB_EXTENSION; // ------------------------------------------------------------------- // // Adapter level prototypes // // These functions affect the device as a whole, as opposed to // affecting individual streams. // // ------------------------------------------------------------------- // // DriverEntry: // // This routine is called when the mini driver is first loaded. The driver // should then call the StreamClassRegisterAdapter function to register with // the stream class driver // ULONG DriverEntry (PVOID Context1, PVOID Context2); #ifdef TOSHIBA VOID GetPCIConfigSpace(PHW_STREAM_REQUEST_BLOCK pSrb); #endif//TOSHIBA // // This routine is called by the stream class driver with configuration // information for an adapter that the mini driver should load on. The mini // driver should still perform a small verification to determine that the // adapter is present at the specified addresses, but should not attempt to // find an adapter as it would have with previous NT miniports. // // All initialization of the adapter should also be performed at this time. // BOOL STREAMAPI HwInitialize (IN OUT PHW_STREAM_REQUEST_BLOCK pSrb); // // This routine is called when the system is going to remove or disable the // device. // // The mini-driver should free any system resources that it allocated at this // time. Note that system resources allocated for the mini-driver by the // stream class driver will be free'd by the stream driver, and should not be // free'd in this routine. (Such as the HW_DEVICE_EXTENSION) // BOOL STREAMAPI HwUnInitialize ( PHW_STREAM_REQUEST_BLOCK pSrb); // // This is the prototype for the Hardware Interrupt Handler. This routine // will be called whenever the minidriver receives an interrupt // BOOLEAN HwInterrupt ( IN PHW_DEVICE_EXTENSION pDeviceExtension ); // // This is the prototype for the stream enumeration function. This routine // provides the stream class driver with the information on data stream types // supported // VOID STREAMAPI AdapterStreamInfo(PHW_STREAM_REQUEST_BLOCK pSrb); // // This is the prototype for the stream open function // VOID STREAMAPI AdapterOpenStream(PHW_STREAM_REQUEST_BLOCK pSrb); // // This is the prototype for the stream close function // VOID STREAMAPI AdapterCloseStream(PHW_STREAM_REQUEST_BLOCK pSrb); // // This is the prototype for the AdapterReceivePacket routine. This is the // entry point for command packets that are sent to the adapter (not to a // specific open stream) // VOID STREAMAPI AdapterReceivePacket(IN PHW_STREAM_REQUEST_BLOCK Srb); // // This is the protoype for the cancel packet routine. This routine enables // the stream class driver to cancel an outstanding packet. // VOID STREAMAPI AdapterCancelPacket(IN PHW_STREAM_REQUEST_BLOCK Srb); // // This is the packet timeout function. The adapter may choose to ignore a // packet timeout, or rest the adapter and cancel the requests, as required. // VOID STREAMAPI AdapterTimeoutPacket(IN PHW_STREAM_REQUEST_BLOCK Srb); // // Adapter level property set handling // VOID STREAMAPI AdapterGetCrossbarProperty(IN PHW_STREAM_REQUEST_BLOCK pSrb); VOID STREAMAPI AdapterSetCrossbarProperty(IN PHW_STREAM_REQUEST_BLOCK pSrb); VOID STREAMAPI AdapterSetTunerProperty(IN PHW_STREAM_REQUEST_BLOCK pSrb); VOID STREAMAPI AdapterGetTunerProperty(IN PHW_STREAM_REQUEST_BLOCK pSrb); VOID STREAMAPI AdapterSetVideoProcAmpProperty(IN PHW_STREAM_REQUEST_BLOCK pSrb); VOID STREAMAPI AdapterGetVideoProcAmpProperty(IN PHW_STREAM_REQUEST_BLOCK pSrb); VOID STREAMAPI AdapterSetCameraControlProperty(IN PHW_STREAM_REQUEST_BLOCK pSrb); VOID STREAMAPI AdapterGetCameraControlProperty(IN PHW_STREAM_REQUEST_BLOCK pSrb); VOID STREAMAPI AdapterSetTVAudioProperty(IN PHW_STREAM_REQUEST_BLOCK pSrb); VOID STREAMAPI AdapterGetTVAudioProperty(IN PHW_STREAM_REQUEST_BLOCK pSrb); VOID STREAMAPI AdapterSetAnalogVideoDecoderProperty(IN PHW_STREAM_REQUEST_BLOCK pSrb); VOID STREAMAPI AdapterGetAnalogVideoDecoderProperty(IN PHW_STREAM_REQUEST_BLOCK pSrb); VOID STREAMAPI AdapterSetVideoControlProperty(IN PHW_STREAM_REQUEST_BLOCK pSrb); VOID STREAMAPI AdapterGetVideoControlProperty(IN PHW_STREAM_REQUEST_BLOCK pSrb); VOID STREAMAPI AdapterGetVideoCompressionProperty(IN PHW_STREAM_REQUEST_BLOCK pSrb); VOID STREAMAPI AdapterSetVideoCompressionProperty(IN PHW_STREAM_REQUEST_BLOCK pSrb); VOID STREAMAPI AdapterSetProperty(IN PHW_STREAM_REQUEST_BLOCK pSrb); VOID STREAMAPI AdapterGetProperty(IN PHW_STREAM_REQUEST_BLOCK pSrb); BOOL STREAMAPI AdapterVerifyFormat( PKSDATAFORMAT pKSDataFormatToVerify, int StreamNumber); BOOL STREAMAPI AdapterFormatFromRange( IN PHW_STREAM_REQUEST_BLOCK pSrb); VOID STREAMAPI CompleteDeviceSRB ( IN PHW_STREAM_REQUEST_BLOCK pSrb ); VOID STREAMAPI AdapterSetInstance ( PHW_STREAM_REQUEST_BLOCK pSrb ); // // prototypes for general queue management using a busy flag // BOOL STREAMAPI AddToListIfBusy ( IN PHW_STREAM_REQUEST_BLOCK pSrb, IN KSPIN_LOCK *SpinLock, IN OUT BOOL *BusyFlag, IN LIST_ENTRY *ListHead ); BOOL STREAMAPI RemoveFromListIfAvailable ( IN OUT PHW_STREAM_REQUEST_BLOCK *pSrb, IN KSPIN_LOCK *SpinLock, IN OUT BOOL *BusyFlag, IN LIST_ENTRY *ListHead ); // ------------------------------------------------------------------- // // Stream level prototypes // // These functions affect individual streams, as opposed to // affecting the device as a whole. // // ------------------------------------------------------------------- // // Routines to manage the SRB queue on a per stream basis // VOID STREAMAPI VideoQueueAddSRB ( IN PHW_STREAM_REQUEST_BLOCK pSrb ); PHW_STREAM_REQUEST_BLOCK STREAMAPI VideoQueueRemoveSRB ( PHW_DEVICE_EXTENSION pHwDevExt, int StreamNumber ); VOID STREAMAPI VideoQueueCancelAllSRBs ( PSTREAMEX pStrmEx ); BOOL STREAMAPI VideoQueueCancelOneSRB ( PSTREAMEX pStrmEx, PHW_STREAM_REQUEST_BLOCK pSrbToCancel ); // // Data packet handlers // // // prototypes for data handling routines // VOID STREAMAPI CompleteStreamSRB (IN PHW_STREAM_REQUEST_BLOCK pSrb); BOOL STREAMAPI VideoSetFormat(IN PHW_STREAM_REQUEST_BLOCK pSrb); VOID STREAMAPI VideoReceiveDataPacket(IN PHW_STREAM_REQUEST_BLOCK pSrb); VOID STREAMAPI VideoReceiveCtrlPacket(IN PHW_STREAM_REQUEST_BLOCK pSrb); VOID STREAMAPI AnalogVideoReceiveDataPacket(IN PHW_STREAM_REQUEST_BLOCK pSrb); VOID STREAMAPI AnalogVideoReceiveCtrlPacket(IN PHW_STREAM_REQUEST_BLOCK pSrb); VOID STREAMAPI EnableIRQ(PHW_STREAM_OBJECT pstrm); VOID STREAMAPI DisableIRQ(PHW_STREAM_OBJECT pstrm); // // prototypes for properties and states // VOID STREAMAPI VideoSetState(PHW_STREAM_REQUEST_BLOCK pSrb); VOID STREAMAPI VideoGetState(PHW_STREAM_REQUEST_BLOCK pSrb); VOID STREAMAPI VideoSetProperty(PHW_STREAM_REQUEST_BLOCK pSrb); VOID STREAMAPI VideoGetProperty(PHW_STREAM_REQUEST_BLOCK pSrb); VOID STREAMAPI VideoStreamGetConnectionProperty (PHW_STREAM_REQUEST_BLOCK pSrb); VOID STREAMAPI VideoStreamGetDroppedFramesProperty(PHW_STREAM_REQUEST_BLOCK pSrb); // // stream clock functions // VOID STREAMAPI VideoIndicateMasterClock (PHW_STREAM_REQUEST_BLOCK pSrb); ULONGLONG STREAMAPI VideoGetSystemTime(); // // The point of it all // VOID STREAMAPI VideoCaptureRoutine( IN PSTREAMEX pStrmEx ); #ifdef TOSHIBA VOID DeferredRoutine( PKDPC pDpc, PDEVICE_OBJECT pDeviceObject, PIRP pIrpNotUsed, PVOID Context ); ULONG get_AblFilter ( PHW_DEVICE_EXTENSION pHwDevExt ); ULONG get_filtering ( PHW_DEVICE_EXTENSION pHwDevExt ); VOID set_filtering ( PHW_DEVICE_EXTENSION pHwDevExt, BOOL bFlag ); NTKERNELAPI PHYSICAL_ADDRESS MmGetPhysicalAddress ( IN PVOID BaseAddress ); NTKERNELAPI PVOID MmAllocateContiguousMemory ( IN ULONG NumberOfBytes, IN PHYSICAL_ADDRESS HighestAcceptableAddress ); NTKERNELAPI VOID MmFreeContiguousMemory ( IN PVOID BaseAddress ); #endif//TOSHIBA #ifdef __cplusplus } #endif // __cplusplus #endif //__CAPMAIN_H__