windows-nt/Source/XPSP1/NT/drivers/wdm/vbi/cc/codmain.h

369 lines
14 KiB
C
Raw Permalink Normal View History

2020-09-26 03:20:57 -05:00
//==========================================================================;
//
// 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 - 1998 Microsoft Corporation. All Rights Reserved.
//
//==========================================================================;
#ifndef __CODMAIN_H__
#define __CODMAIN_H__
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus
#include "ccdecode.h"
#include "defaults.h"
#define ENTRIES(a) (sizeof(a)/sizeof(*(a)))
/**************************************************************/
/* Driver Name - Change this to reflect your executable name! */
/**************************************************************/
#define CODECNAME "CCDecode"
// ------------------------------------------------------------------------
// The master list of all streams supported by this driver
// ------------------------------------------------------------------------
typedef enum {
STREAM_VBI = 0, // VBI samples in
STREAM_CC, // Decoded VBI out (Should be less "generic")
#ifdef CCINPUTPIN
STREAM_CCINPUT, // H/W decoded CC in
#endif // CCINPUTPIN
MAX_STREAM_COUNT
};
// The MAX_STREAM_COUNT value must be equal to DRIVER_STREAM_COUNT
// This particular value must be defined here to avoid circular references
// We manage multiple instances of each pin up to this limit
#define MAX_PIN_INSTANCES 8
#define BIT(n) (((unsigned long)1)<<(n))
#define BITSIZE(v) (sizeof(v)*8)
#define SETBIT(array,n) (array[(n)/BITSIZE(*array)] |= BIT((n)%BITSIZE(*array)))
#define CLEARBIT(array,n) (array[(n)/BITSIZE(*array)] &= ~BIT((n)%BITSIZE(*array)))
#define TESTBIT(array,n) (BIT((n)%BITSIZE(*array)) == (array[(n)/BITSIZE(*array)] & BIT(n%BITSIZE(*array))))
/*****************************************************************************
*
* The following structures are samples of information that could be used in
* a device extension structure
*
*****************************************************************************/
//
// Result of DSP operation
//
typedef struct _DSPRESULT
{
CHAR Decoded[2];
int Confidence;
}DSPRESULT, *PDSPRESULT;
//
// 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 {
struct _STREAMEX * pStrmEx[MAX_STREAM_COUNT][MAX_PIN_INSTANCES]; // Pointers to each stream
UINT ActualInstances[MAX_STREAM_COUNT]; // Counter of instances per stream
// Clock
REFERENCE_TIME QST_Start; // KeQuerySystemTime at run
REFERENCE_TIME QST_Now; // KeQuerySystemTime currently
REFERENCE_TIME WallTime100ns; // elapsed time based on KeQueryPerformanceCounter
// The following VBICODECFILTERING_* fields are defaults for newly created output pins(copied)
VBICODECFILTERING_SCANLINES ScanlinesRequested; // Bitmask of requested scanlines
VBICODECFILTERING_SCANLINES ScanlinesDiscovered;// Bitmask of discovered scanlines
VBICODECFILTERING_CC_SUBSTREAMS SubstreamsRequested;// Bitmask of requested substream IDs
VBICODECFILTERING_CC_SUBSTREAMS SubstreamsDiscovered;// Bitmask of discovered substream IDs
// This is the global version of the STATISTICS property
VBICODECFILTERING_STATISTICS_CC Statistics;
PDSPRESULT DSPResult; // Pointer to result array
ULONG DSPResultStartLine;
ULONG DSPResultEndLine;
ULONG SubStreamState[CC_MAX_HW_DECODE_LINES][2];
ALL_STREAM_INFO * Streams;
ULONG fTunerChange; // TV Tuner channel change in progress
LIST_ENTRY AdapterSRBQueue;
KSPIN_LOCK AdapterSRBSpinLock;
BOOL bAdapterQueueInitialized;
#ifdef CCINPUTPIN
// Last pictureNumber that decoded VBI data was processed
// (used for coordination of multiple input pins)
FAST_MUTEX LastPictureMutex;
LONGLONG LastPictureNumber;
#endif // CCINPUTPIN
} 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_VBI_FRAME_INFO FrameInfo; // PictureNumber, etc.
ULONG fDiscontinuity; // Discontinuity since last valid
ULONG StreamInstance; // 0..NumberOfPossibleInstances-1
LONGLONG LastPictureNumber; // Last received picture number
KSSTATE KSState; // Run, Stop, Pause
REFERENCE_TIME FrameTime100ns; // elapsed time based on frames captured
HANDLE hMasterClock;
HANDLE hClock;
KSDATAFORMAT OpenedFormat; // Based on the actual open request.
KSDATAFORMAT MatchedFormat; // Format that matched the open format.
VBICODECFILTERING_SCANLINES ScanlinesRequested; // Bitmask of requested scanlines
VBICODECFILTERING_SCANLINES ScanlinesDiscovered; // Bitmask of discovered scanlines
VBICODECFILTERING_SCANLINES LastOddScanlinesDiscovered; // Bitmask of scanlines last discovered
VBICODECFILTERING_SCANLINES LastEvenScanlinesDiscovered; // Bitmask of scanlines last discovered
VBICODECFILTERING_CC_SUBSTREAMS SubstreamsRequested; // Bitmask of requested substream IDs
VBICODECFILTERING_CC_SUBSTREAMS SubstreamsDiscovered; // Bitmask of discovered substream IDs
VBICODECFILTERING_STATISTICS_CC_PIN PinStats; // CC Pin version of statistics property
CCState State; // State variable for DSP
KS_VBIINFOHEADER CurrentVBIInfoHeader;
KSPIN_LOCK StreamControlSpinLock, // Command queue spin lock
StreamDataSpinLock; // Data queue spin lock
LIST_ENTRY StreamDataQueue, // Stream data queue
StreamControlQueue; // Stream command queue
#ifdef CCINPUTPIN
// For when the VBI input pin is waiting for the HWCC input pin to catch up
PHW_STREAM_REQUEST_BLOCK pVBISrbOnHold;
KSPIN_LOCK VBIOnHoldSpinLock;
#endif // CCINPUTPIN
} STREAMEX, *PSTREAMEX;
//
// This structure is our per SRB extension, and carries the forward and backward
// links for the pending SRB queue.
//
typedef struct _SRB_EXTENSION
{
LIST_ENTRY ListEntry;
PHW_STREAM_REQUEST_BLOCK pSrb;
}SRB_EXTENSION, *PSRB_EXTENSION;
/*****************************************************************************
*
* the following section defines prototypes for the minidriver initialization
* routines
*
******************************************************************************/
//
// 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);
//
// 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 codec should also be performed at this time.
//
BOOLEAN CodecInitialize (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)
//
BOOLEAN CodecUnInitialize( PHW_STREAM_REQUEST_BLOCK pSrb);
BOOLEAN CodecQueryUnload ( PHW_STREAM_REQUEST_BLOCK pSrb); // Not implemented currently
//
// This is the prototype for the Hardware Interrupt Handler. This routine
// will be called if the minidriver registers for and 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 CodecStreamInfo(PHW_STREAM_REQUEST_BLOCK pSrb);
//
// This is the prototype for the stream open function
//
VOID CodecOpenStream(PHW_STREAM_REQUEST_BLOCK pSrb);
//
// This is the prototype for the stream close function
//
VOID CodecCloseStream(PHW_STREAM_REQUEST_BLOCK pSrb);
//
// This is the prototype for the CodecReceivePacket routine. This is the
// entry point for command packets that are sent to the codec (not to a
// specific open stream)
//
VOID STREAMAPI CodecReceivePacket(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 CodecCancelPacket(IN PHW_STREAM_REQUEST_BLOCK Srb);
//
// This is the packet timeout function. The codec may choose to ignore a
// packet timeout, or reset the codec and cancel the requests, as required.
//
VOID STREAMAPI CodecTimeoutPacket(IN PHW_STREAM_REQUEST_BLOCK Srb);
VOID STREAMAPI CodecGetProperty(IN PHW_STREAM_REQUEST_BLOCK Srb);
VOID STREAMAPI CodecSetProperty(IN PHW_STREAM_REQUEST_BLOCK Srb);
BOOL
CodecCompareGUIDsAndFormatSize( IN PKSDATARANGE DataRange1,
IN PKSDATARANGE DataRange2,
BOOLEAN bCheckSize );
BOOL
CodecVerifyFormat(IN KSDATAFORMAT *pKSDataFormat,
IN UINT StreamNumber,
IN PKSDATARANGE pMatchedFormat );
BOOL
CodecVBIFormatFromRange(
IN PHW_STREAM_REQUEST_BLOCK pSrb);
BOOL
CodecCCFormatFromRange(
IN PHW_STREAM_REQUEST_BLOCK pSrb );
void
CompleteStreamSRB (
IN PHW_STREAM_REQUEST_BLOCK pSrb,
STREAM_MINIDRIVER_STREAM_NOTIFICATION_TYPE NotificationType1,
BOOL fUseNotification2,
STREAM_MINIDRIVER_STREAM_NOTIFICATION_TYPE NotificationType2
);
void
CompleteDeviceSRB (
IN PHW_STREAM_REQUEST_BLOCK pSrb,
IN STREAM_MINIDRIVER_DEVICE_NOTIFICATION_TYPE NotificationType,
BOOL fReadyForNext
);
//
// prototypes for data handling routines
//
void CompleteStreamIRP (IN PHW_STREAM_REQUEST_BLOCK pSrb, BOOLEAN ReadyForNext);
VOID STREAMAPI VBIReceiveDataPacket(IN PHW_STREAM_REQUEST_BLOCK pSrb);
VOID STREAMAPI VBIReceiveCtrlPacket(IN PHW_STREAM_REQUEST_BLOCK pSrb);
void EnableIRQ(PHW_STREAM_OBJECT pstrm);
void DisableIRQ(PHW_STREAM_OBJECT pstrm);
//
// prototypes for properties and states
//
VOID VideoSetState(PHW_STREAM_REQUEST_BLOCK pSrb);
VOID VideoGetState(PHW_STREAM_REQUEST_BLOCK pSrb);
VOID VideoSetProperty(PHW_STREAM_REQUEST_BLOCK pSrb);
VOID VideoGetProperty(PHW_STREAM_REQUEST_BLOCK pSrb);
//VOID VideoStreamSetConnectionProperty (PHW_STREAM_REQUEST_BLOCK pSrb); // Not implemented
VOID VideoStreamGetConnectionProperty (PHW_STREAM_REQUEST_BLOCK pSrb);
VOID VideoStreamSetVBIFilteringProperty (PHW_STREAM_REQUEST_BLOCK pSrb);
VOID VideoStreamGetVBIFilteringProperty (PHW_STREAM_REQUEST_BLOCK pSrb);
//
// system time functions
//
ULONGLONG VideoGetSystemTime();
//
// stream clock functions
//
VOID VideoIndicateMasterClock(PHW_STREAM_REQUEST_BLOCK pSrb);
//
// SRB Queue Management functions
//
BOOL STREAMAPI QueueAddIfNotEmpty(
IN PHW_STREAM_REQUEST_BLOCK,
IN PKSPIN_LOCK,
IN PLIST_ENTRY
);
BOOL STREAMAPI QueueAdd(
IN PHW_STREAM_REQUEST_BLOCK,
IN PKSPIN_LOCK,
IN PLIST_ENTRY
);
BOOL STREAMAPI QueueRemove(
IN OUT PHW_STREAM_REQUEST_BLOCK *,
IN PKSPIN_LOCK,
IN PLIST_ENTRY
);
BOOL STREAMAPI QueueRemoveSpecific(
IN PHW_STREAM_REQUEST_BLOCK,
IN PKSPIN_LOCK,
IN PLIST_ENTRY
);
BOOL STREAMAPI QueueEmpty(
IN PKSPIN_LOCK,
IN PLIST_ENTRY
);
#ifdef __cplusplus
}
#endif // __cplusplus
#endif //__CODMAIN_H__