diff options
Diffstat (limited to 'sdk/dx8sdk/Include/DShowIDL/tuner.idl')
| -rw-r--r-- | sdk/dx8sdk/Include/DShowIDL/tuner.idl | 2254 |
1 files changed, 2254 insertions, 0 deletions
diff --git a/sdk/dx8sdk/Include/DShowIDL/tuner.idl b/sdk/dx8sdk/Include/DShowIDL/tuner.idl new file mode 100644 index 00000000..75f1beb4 --- /dev/null +++ b/sdk/dx8sdk/Include/DShowIDL/tuner.idl @@ -0,0 +1,2254 @@ +//------------------------------------------------------------------------------ +// File: Tuner.idl +// +// Desc: +// +// Copyright (c) 1999 - 2000, Microsoft Corporation. All rights reserved. +//------------------------------------------------------------------------------ + + +cpp_quote("//+-------------------------------------------------------------------------") +cpp_quote("//") +cpp_quote("// Microsoft Windows") +cpp_quote("// Copyright (C) Microsoft Corporation, 1999-2000.") +cpp_quote("//") +cpp_quote("//--------------------------------------------------------------------------") +cpp_quote("#pragma once") + +#include <olectl.h> +#ifndef DO_NO_IMPORTS +import "oaidl.idl"; +import "comcat.idl"; +import "strmif.idl"; +import "bdatypes.h"; +import "regbag.idl"; +#endif + +cpp_quote("#include <bdatypes.h>") + +interface ITuningSpaceContainer; +interface ITuningSpace; +interface IEnumTuningSpaces; +interface ITuneRequest; +interface ITuner; +interface IScanningTuner; +interface IEnumComponentTypes; +interface IComponentTypes; +interface IComponentType; +interface ILanguageComponentType; +interface IEnumComponents; +interface IComponents; +interface IComponent; +interface IMPEG2ComponentType; +interface IMPEG2Component; +interface ILocator; +interface IATSCLocator; +interface IDVBSLocator; +interface IDVBTLocator; +interface IDVBCLocator; + +// tuner.idl: +// interface ITuningSpaceContainer : IDispatch +// interface ITuningSpace : IDispatch +// interface ITuneRequest : IDispatch +// interface IComponentType : IDispatch +// interface ILanguageComponentType : IComponentType +// interface IComponentTypes : IDispatch +// interface IComponent : IDispatch +// interface IComponents : IDispatch +// interface ITVTuningSpace : ITuningSpace +// interface IFMRadioTuningSpace : ITuningSpace +// interface IAMRadioTuningSpace : ITuningSpace +// interface IAnalogTVTuningSpace : ITVTuningSpace +// interface IAnalogTVAudioComponent : IComponent +// interface IAnalogTVDataComponent : IComponent +// interface IChannelTuneRequest : ITuneRequest +// interface IDVBComponent : IComponent +// interface IDVBTuneRequest : ITuneRequest + +// DISPIDs for ITuningSpaces interface +// we don't expect to inherit from this interface and consequently there's +// no chance of collision, thus we'll allow midl to auto assign ids for this one + +// DISPIDs for ITuningSpace interface +enum { +DISPID_TUNER_TS_UNIQUENAME = 1, +DISPID_TUNER_TS_FRIENDLYNAME = 2, +DISPID_TUNER_TS_CLSID = 3, +DISPID_TUNER_TS_NETWORKTYPE = 4, +DISPID_TUNER_TS__NETWORKTYPE = 5, +DISPID_TUNER_TS_CREATETUNEREQUEST = 6, +DISPID_TUNER_TS_ENUMCATEGORYGUIDS = 7, +DISPID_TUNER_TS_ENUMDEVICEMONIKERS = 8, +DISPID_TUNER_TS_DEFAULTPREFERREDCOMPONENTTYPES = 9, +DISPID_TUNER_TS_FREQMAP = 10, +DISPID_TUNER_TS_DEFLOCATOR = 11, +DISPID_TUNER_TS_CLONE = 12, + +// DISPIDs for ITuneRequest interface +DISPID_TUNER_TR_TUNINGSPACE = 1, +DISPID_TUNER_TR_COMPONENTS = 2, +DISPID_TUNER_TR_CLONE = 3, +DISPID_TUNER_TR_LOCATOR = 4, + + +// DISPID for IComponentType interface +DISPID_TUNER_CT_CATEGORY = 1, +DISPID_TUNER_CT_MEDIAMAJORTYPE = 2, +DISPID_TUNER_CT__MEDIAMAJORTYPE = 3, +DISPID_TUNER_CT_MEDIASUBTYPE = 4, +DISPID_TUNER_CT__MEDIASUBTYPE = 5, +DISPID_TUNER_CT_MEDIAFORMATTYPE = 6, +DISPID_TUNER_CT__MEDIAFORMATTYPE = 7, +DISPID_TUNER_CT_MEDIATYPE = 8, +DISPID_TUNER_CT_CLONE = 9, + + +// DISPID for ILanguageComponentType interface +DISPID_TUNER_LCT_LANGID = 100, + +// DISPID for IMPEG2ComponentType interface +DISPID_TUNER_MP2CT_TYPE = 200, + +// DISPID for IATSCComponentType interface +DISPID_TUNER_ATSCCT_FLAGS = 300, + +// DISPID for ILocator interface +DISPID_TUNER_L_CARRFREQ = 1, +DISPID_TUNER_L_INNERFECMETHOD = 2, +DISPID_TUNER_L_INNERFECRATE = 3, +DISPID_TUNER_L_OUTERFECMETHOD = 4, +DISPID_TUNER_L_OUTERFECRATE = 5, +DISPID_TUNER_L_MOD = 6, +DISPID_TUNER_L_SYMRATE = 7, +DISPID_TUNER_L_CLONE = 8, + +// DISPID for IATSCLocator interface +DISPID_TUNER_L_ATSC_PHYS_CHANNEL = 201, +DISPID_TUNER_L_ATSC_TSID = 202, + +// DISPID for IDVBTLocator interface +DISPID_TUNER_L_DVBT_BANDWIDTH = 301, +DISPID_TUNER_L_DVBT_LPINNERFECMETHOD = 302, +DISPID_TUNER_L_DVBT_LPINNERFECRATE = 303, +DISPID_TUNER_L_DVBT_GUARDINTERVAL = 304, +DISPID_TUNER_L_DVBT_HALPHA = 305, +DISPID_TUNER_L_DVBT_TRANSMISSIONMODE = 306, +DISPID_TUNER_L_DVBT_INUSE = 307, + +// DISPID for IDVBSLocator interface +DISPID_TUNER_L_DVBS_POLARISATION = 401, +DISPID_TUNER_L_DVBS_WEST = 402, +DISPID_TUNER_L_DVBS_ORBITAL = 403, +DISPID_TUNER_L_DVBS_AZIMUTH = 404, +DISPID_TUNER_L_DVBS_ELEVATION = 405, + +// DISPID for IDVBCLocator interface + +// DISPIDs for IComponent interface +DISPID_TUNER_C_TYPE = 1, +DISPID_TUNER_C_STATUS = 2, +DISPID_TUNER_C_LANGID = 3, +DISPID_TUNER_C_DESCRIPTION = 4, +DISPID_TUNER_C_CLONE = 5, + +// DISPIDs for IMPEG2Component interface +DISPID_TUNER_C_MP2_PID = 101, +DISPID_TUNER_C_MP2_PCRPID = 102, +DISPID_TUNER_C_MP2_PROGNO = 103, + +// DISPIDs for IDVBTuningSpace interface +DISPID_TUNER_TS_DVB_SYSTEMTYPE = 101, +// DISPIDs for IDVBTuningSpace2 interface +DISPID_TUNER_TS_DVB2_NETWORK_ID = 102, +// DISPIDs for IDVBSTuningSpace interface +DISPID_TUNER_TS_DVBS_LOW_OSC_FREQ = 1001, +DISPID_TUNER_TS_DVBS_HI_OSC_FREQ = 1002, +DISPID_TUNER_TS_DVBS_LNB_SWITCH_FREQ = 1003, +DISPID_TUNER_TS_DVBS_INPUT_RANGE = 1004, +DISPID_TUNER_TS_DVBS_SPECTRAL_INVERSION = 1005, + +// DISPIDs for IAnalogRadioTuningSpace interface +DISPID_TUNER_TS_AR_MINFREQUENCY = 101, +DISPID_TUNER_TS_AR_MAXFREQUENCY = 102, +DISPID_TUNER_TS_AR_STEP = 103, + +// DISPIDs for IAnalogTVTuningSpace interface +DISPID_TUNER_TS_ATV_MINCHANNEL = 101, +DISPID_TUNER_TS_ATV_MAXCHANNEL = 102, +DISPID_TUNER_TS_ATV_INPUTTYPE = 103, +DISPID_TUNER_TS_ATV_COUNTRYCODE = 104, + +// DISPIDs for IATSCTuningSpace interface +DISPID_TUNER_TS_ATSC_MINMINORCHANNEL = 201, +DISPID_TUNER_TS_ATSC_MAXMINORCHANNEL = 202, +DISPID_TUNER_TS_ATSC_MINPHYSCHANNEL = 203, +DISPID_TUNER_TS_ATSC_MAXPHYSCHANNEL = 204, + +// DISPID for IAnalogTVAudioComponent interface +DISPID_CHTUNER_ATVAC_CHANNEL = 101, + +// DISPIDs for IAnalogTVDataComponent interface +DISPID_CHTUNER_ATVDC_SYSTEM = 101, +DISPID_CHTUNER_ATVDC_CONTENT = 102, + +// DISPID for IChannelTuneRequest interface +DISPID_CHTUNER_CTR_CHANNEL = 101, + +// DISPID IATSCChannelTuneRequest +DISPID_CHTUNER_ACTR_MINOR_CHANNEL = 201, + +// DISPIDs for IDVBComponent interface +DISPID_DVBTUNER_DVBC_ATTRIBUTESVALID = 101, +DISPID_DVBTUNER_DVBC_PID = 102, +DISPID_DVBTUNER_DVBC_TAG = 103, +DISPID_DVBTUNER_DVBC_COMPONENTTYPE = 104, + +// DISPIDs for IDVBTuneRequest interface +DISPID_DVBTUNER_ONID = 101, +DISPID_DVBTUNER_TSID = 102, +DISPID_DVBTUNER_SID = 103, + +// DISPIDs for IMPEG2TuneRequest interface +DISPID_MP2TUNER_TSID = 101, +DISPID_MP2TUNER_PROGNO = 102, + +// DISPIDs for IMPEG2TuneRequestFactory interface +DISPID_MP2TUNERFACTORY_CREATETUNEREQUEST = 1, + +}; + + +////////////////////////////////////////////////////////////////////////////////////// +// Tuning Space Container +////////////////////////////////////////////////////////////////////////////////////// +// simple read-only collection of tuning spaces for enumerating subsets of the total +// set of system tuning spaces + [ + object, + uuid(901284E4-33FE-4b69-8D63-634A596F3756), + dual, + oleautomation, + nonextensible, + helpstring("Tuning Space Collection Interface"), + pointer_default(unique) + ] + interface ITuningSpaces : IDispatch + { + + [propget, helpstring("Number of items in the collection")] + HRESULT Count( + [out, retval] long *Count + ); + + [propget, id(DISPID_NEWENUM), hidden, restricted] + HRESULT _NewEnum( + [out, retval] IEnumVARIANT** NewEnum + ); + + [id(DISPID_VALUE), + propget, + helpstring("Find the Tuning Space with the specified Index")] + HRESULT Item( + [in] VARIANT varIndex, + [out, retval] ITuningSpace** TuningSpace + ); + + [propget, hidden, restricted, + helpstring("convenience function so C++ apps don't have to unpack VARIANT")] + HRESULT EnumTuningSpaces( + [out, retval] IEnumTuningSpaces** NewEnum + ); + + } + +////////////////////////////////////////////////////////////////////////////////////// +// Tuning Space Container +////////////////////////////////////////////////////////////////////////////////////// + [ + object, + uuid(5B692E84-E2F1-11d2-9493-00C04F72D980), + dual, + oleautomation, + hidden, + nonextensible, + helpstring("Tuning Space Container Interface"), + pointer_default(unique) + ] + interface ITuningSpaceContainer : IDispatch + { + + [propget, helpstring("Number of items in the collection")] + HRESULT Count( + [out, retval] long *Count + ); + + [propget, id(DISPID_NEWENUM), hidden, restricted] + HRESULT _NewEnum( + [out, retval] IEnumVARIANT** NewEnum + ); + + [id(DISPID_VALUE), + propget, + helpstring("Find the Tuning Space with the specified Index")] + HRESULT Item( + [in] VARIANT varIndex, + [out, retval] ITuningSpace** TuningSpace + ); + [id(DISPID_VALUE), + propput, + helpstring("Change the Tuning Space with the specified Index")] + HRESULT Item([in] VARIANT varIndex, [in] ITuningSpace *TuningSpace); + + [helpstring("Returns the collection of Tuning Spaces with the same implementation")] + HRESULT TuningSpacesForCLSID( + [in] BSTR SpaceCLSID, + [out, retval] ITuningSpaces** NewColl + ); + + [hidden, restricted, + helpstring("Convenience Function for enumerating from C")] + HRESULT _TuningSpacesForCLSID( + [in] REFCLSID SpaceCLSID, + [out, retval] ITuningSpaces** NewColl + ); + + [helpstring("Returns the collection of Tuning Spaces matching the name")] + HRESULT TuningSpacesForName( + [in] BSTR Name, + [out, retval] ITuningSpaces** NewColl + ); + + [helpstring("Find Local ID Number of the specified Tuning Space")] + HRESULT FindID( + [in] ITuningSpace *TuningSpace, + [out, retval] long *ID + ); + + + [id(DISPID_ADDITEM), + helpstring("Add a new Tuning Space to the collection. This tuning space will be persisted unless removed")] + HRESULT Add( + [in] ITuningSpace* TuningSpace, + [out, retval] VARIANT* NewIndex + ); + + [propget, hidden, restricted, helpstring("Convenience Function for enumerating collection from C")] + HRESULT EnumTuningSpaces( + [out, retval] IEnumTuningSpaces **ppEnum + ); + + [id(DISPID_REMOVEITEM), + helpstring("Remove a Tuning Space from the collection. this tuning space will be deleted from the registry")] + HRESULT Remove( + [in] VARIANT Index + ); + + [propget, helpstring("Maximum number of items allowed in the collection")] + HRESULT MaxCount( + [out, retval] long *MaxCount + ); + + // we don't allow script to set this, but we do allow c code to change it. + [propput, hidden, restricted, helpstring("Maximum number of items allowed in the collection")] + HRESULT MaxCount( + [in] long MaxCount + ); + + } + +////////////////////////////////////////////////////////////////////////////////////// +// Tuning Space Interfaces +////////////////////////////////////////////////////////////////////////////////////// + +// note: the network type is the clsid of the tuning space implementation + [ + object, + uuid(061C6E30-E622-11d2-9493-00C04F72D980), + dual, + oleautomation, + nonextensible, + helpstring("Tuning Space Interface"), + pointer_default(unique) + ] + interface ITuningSpace : IDispatch + { + [propget, id(DISPID_TUNER_TS_UNIQUENAME), + helpstring("Unique name of the Tuning Space")] + HRESULT UniqueName( + [out, retval] BSTR *Name + ); + + [propput, id(DISPID_TUNER_TS_UNIQUENAME), + helpstring("Unique name of the Tuning Space")] + HRESULT UniqueName( + [in] BSTR Name + ); + + [propget, id(DISPID_TUNER_TS_FRIENDLYNAME), + helpstring("User-friendly name of the Tuning Space")] + HRESULT FriendlyName( + [out, retval] BSTR *Name + ); + + [propput, id(DISPID_TUNER_TS_FRIENDLYNAME), + helpstring("User-friendly name of the Tuning Space")] + HRESULT FriendlyName( + [in] BSTR Name + ); + + [propget, id(DISPID_TUNER_TS_CLSID), + helpstring("Returns the clsid of the tuning space implementation. provides script access to IPersist:GetClassID")] + HRESULT CLSID( + [out, retval] BSTR* SpaceCLSID + ); + + [propget, id(DISPID_TUNER_TS_NETWORKTYPE), + helpstring("Network Type (Network Proivder CLSID)")] + HRESULT NetworkType( + [out, retval] BSTR *NetworkTypeGuid + ); + [propput, id(DISPID_TUNER_TS_NETWORKTYPE), + helpstring("Network Type (Network Proivder CLSID)")] + HRESULT NetworkType( + [in] BSTR NetworkTypeGuid + ); + + [propget, id(DISPID_TUNER_TS__NETWORKTYPE), + helpstring("Network Type (Network Proivder CLSID)"), hidden, restricted] + HRESULT _NetworkType( + [out, retval] GUID* NetworkTypeGuid + ); + [propput, id(DISPID_TUNER_TS__NETWORKTYPE), + helpstring("Network Type (Network Proivder CLSID)"), hidden, restricted] + HRESULT _NetworkType( + [in] REFCLSID NetworkTypeGuid + ); + + // this method creates the "best" kind of tune request for this tuning space. + // the tuning space may support other kinds of tune requests created via + // other factory mechanisms(for example, see mpeg2tunerequestfactory). but, + // this method is the preferred way to get a tune request as it always returns + // the optimal type of tune request for this space. + [id(DISPID_TUNER_TS_CREATETUNEREQUEST), + helpstring("Create a Tune Request object")] + HRESULT CreateTuneRequest( + [out, retval] ITuneRequest **TuneRequest + ); + + [id(DISPID_TUNER_TS_ENUMCATEGORYGUIDS), hidden, restricted] + HRESULT EnumCategoryGUIDs( + [out, retval] IEnumGUID **ppEnum + ); + + [id(DISPID_TUNER_TS_ENUMDEVICEMONIKERS), hidden, restricted] + HRESULT EnumDeviceMonikers( + [out, retval] IEnumMoniker **ppEnum + ); + + [propget, id(DISPID_TUNER_TS_DEFAULTPREFERREDCOMPONENTTYPES)] + HRESULT DefaultPreferredComponentTypes( + [out, retval] IComponentTypes** ComponentTypes + ); + [propput, id(DISPID_TUNER_TS_DEFAULTPREFERREDCOMPONENTTYPES)] + HRESULT DefaultPreferredComponentTypes( + [in] IComponentTypes* NewComponentTypes + ); + + // the following property is for the network providers to store frequency/channel maps, frequency/transponder maps + // or whatever other mapping from carrier frequencies to frequency identifiers are appropriate for the tuning space + // in question. the bstr is treated as a binary blob. it is expected to contain embedded nulls, and it may be formatted + // internally in whatever fashion the network provider sees fit. + [propget, id(DISPID_TUNER_TS_FREQMAP)] + HRESULT FrequencyMapping([out, retval] BSTR *pMapping); + [propput, id(DISPID_TUNER_TS_FREQMAP)] + HRESULT FrequencyMapping(BSTR Mapping); + + // the following property provides a starting point for the initial IScanningTuner after installation + [propget, id(DISPID_TUNER_TS_DEFLOCATOR)] + HRESULT DefaultLocator([out, retval] ILocator **LocatorVal); + [propput, id(DISPID_TUNER_TS_DEFLOCATOR)] + HRESULT DefaultLocator([in]ILocator *LocatorVal); + + HRESULT Clone([out, retval] ITuningSpace **NewTS); + } + +////////////////////////////////////////////////////////////////////////////////////// + [ + hidden, + restricted, + object, + uuid(8B8EB248-FC2B-11d2-9D8C-00C04F72D980), + pointer_default(unique) + ] + interface IEnumTuningSpaces : IUnknown + { + HRESULT Next( + [in] ULONG celt, + [out, size_is(celt), length_is(*pceltFetched)] + ITuningSpace** rgelt, + [out] ULONG* pceltFetched + ); + + HRESULT Skip( + [in] ULONG celt + ); + + HRESULT Reset(void); + + HRESULT Clone( + [out] IEnumTuningSpaces** ppEnum + ); + } + +////////////////////////////////////////////////////////////////////////////////////// + [ + object, + hidden, + dual, + oleautomation, + nonextensible, + uuid(ADA0B268-3B19-4e5b-ACC4-49F852BE13BA), + pointer_default(unique) + ] + interface IDVBTuningSpace : ITuningSpace + { + [propget, id(DISPID_TUNER_TS_DVB_SYSTEMTYPE), + helpstring("Type of DVB System") + ] + HRESULT SystemType( + [out, retval] DVBSystemType *SysType + ); + [propput, id(DISPID_TUNER_TS_DVB_SYSTEMTYPE), + helpstring("Type of DVB System") + ] + HRESULT SystemType( + [in] DVBSystemType SysType + ); + + } + +////////////////////////////////////////////////////////////////////////////////////// + [ + object, + hidden, + dual, + oleautomation, + nonextensible, + uuid(843188B4-CE62-43db-966B-8145A094E040), + pointer_default(unique) + ] + interface IDVBTuningSpace2 : IDVBTuningSpace + { + [propget, id(DISPID_TUNER_TS_DVB2_NETWORK_ID), + helpstring("Network ID of DVB System") + ] + HRESULT NetworkID( + [out, retval] long *NetworkID + ); + [propput, id(DISPID_TUNER_TS_DVB2_NETWORK_ID), + helpstring("Network ID of DVB System") + ] + HRESULT NetworkID( + [in] long NetworkID + ); + + } + +////////////////////////////////////////////////////////////////////////////////////// + [ + object, + hidden, + dual, + oleautomation, + nonextensible, + uuid(CDF7BE60-D954-42fd-A972-78971958E470), + pointer_default(unique) + ] + interface IDVBSTuningSpace : IDVBTuningSpace2 + { + + [propget, id(DISPID_TUNER_TS_DVBS_LOW_OSC_FREQ), + helpstring("Low Oscillator Frequency of DVB System in KHZ units") + ] + HRESULT LowOscillator( + [out, retval] long *LowOscillator + ); + [propput, id(DISPID_TUNER_TS_DVBS_LOW_OSC_FREQ), + helpstring("Low Oscillator Frequency of DVB System in KHZ units") + ] + HRESULT LowOscillator( + [in] long LowOscillator + ); + [propget, id(DISPID_TUNER_TS_DVBS_HI_OSC_FREQ), + helpstring("High Oscillator Frequency of DVB System in KHZ units") + ] + HRESULT HighOscillator( + [out, retval] long *HighOscillator + ); + [propput, id(DISPID_TUNER_TS_DVBS_HI_OSC_FREQ), + helpstring("High Oscillator Frequency of DVB System in KHZ units") + ] + HRESULT HighOscillator( + [in] long HighOscillator + ); + [propget, id(DISPID_TUNER_TS_DVBS_LNB_SWITCH_FREQ), + helpstring("LNB Switch Frequency of DVB System in KHZ units") + ] + HRESULT LNBSwitch( + [out, retval] long *LNBSwitch + ); + [propput, id(DISPID_TUNER_TS_DVBS_LNB_SWITCH_FREQ), + helpstring("LNB Switch Frequency of DVB System in KHZ units") + ] + HRESULT LNBSwitch( + [in] long LNBSwitch + ); + [propget, id(DISPID_TUNER_TS_DVBS_INPUT_RANGE), + helpstring("Which Option/Switch contains the requested signal source") + ] + HRESULT InputRange( + [out, retval] BSTR *InputRange + ); + [propput, id(DISPID_TUNER_TS_DVBS_INPUT_RANGE), + helpstring("Which Option/Switch contains the requested signal source") + ] + HRESULT InputRange( + [in] BSTR InputRange + ); + [propget, id(DISPID_TUNER_TS_DVBS_SPECTRAL_INVERSION), + helpstring("Which Option/Switch contains the requested signal source") + ] + HRESULT SpectralInversion( + [out, retval] SpectralInversion *SpectralInversionVal + ); + [propput, id(DISPID_TUNER_TS_DVBS_SPECTRAL_INVERSION), + helpstring("Which Option/Switch contains the requested signal source") + ] + HRESULT SpectralInversion( + [in] SpectralInversion SpectralInversionVal + ); + + + } + + +////////////////////////////////////////////////////////////////////////////////////// + [ + object, + hidden, + dual, + oleautomation, + nonextensible, + uuid(E48244B8-7E17-4f76-A763-5090FF1E2F30), + pointer_default(unique) + ] + interface IAuxInTuningSpace : ITuningSpace + { + } +////////////////////////////////////////////////////////////////////////////////////// + [ + object, + hidden, + dual, + oleautomation, + nonextensible, + uuid(2A6E293C-2595-11d3-B64C-00C04F79498E), + pointer_default(unique) + ] + interface IAnalogTVTuningSpace : ITuningSpace + { + [propget, id(DISPID_TUNER_TS_ATV_MINCHANNEL), + helpstring("Smallest channel number ever provided by this tuning space") + ] + HRESULT MinChannel( + [out, retval] long *MinChannelVal + ); + [propput, id(DISPID_TUNER_TS_ATV_MINCHANNEL), + helpstring("Smallest channel number ever provided by this tuning space") + ] + HRESULT MinChannel( + [in] long NewMinChannelVal + ); + [propget, id(DISPID_TUNER_TS_ATV_MAXCHANNEL), + helpstring("Largest channel number ever provided by this tuning space") + ] + HRESULT MaxChannel( + [out, retval] long *MaxChannelVal + ); + [propput, id(DISPID_TUNER_TS_ATV_MAXCHANNEL), + helpstring("Largest channel number ever provided by this tuning space") + ] + HRESULT MaxChannel( + [in] long NewMaxChannelVal + ); + [propget, id(DISPID_TUNER_TS_ATV_INPUTTYPE), + helpstring("Input type for this tuning space") + ] + HRESULT InputType([out, retval] TunerInputType *InputTypeVal); + [propput, id(DISPID_TUNER_TS_ATV_INPUTTYPE), + helpstring("Input type for this tuning space") + ] + HRESULT InputType([in] TunerInputType NewInputTypeVal); + [propget, id(DISPID_TUNER_TS_ATV_COUNTRYCODE), + helpstring("International dialing prefix for country of physical broadcast source") + ] + HRESULT CountryCode([out, retval] long *CountryCodeVal); + [propput, id(DISPID_TUNER_TS_ATV_COUNTRYCODE), + helpstring("International dialing prefix for country of physical broadcast source") + ] + HRESULT CountryCode([in] long NewCountryCodeVal); + } + +////////////////////////////////////////////////////////////////////////////////////// + [ + object, + hidden, + dual, + oleautomation, + nonextensible, + uuid(0369B4E2-45B6-11d3-B650-00C04F79498E), + pointer_default(unique) + ] +// note: we inherit ATSC from analog because we need the same properties. +// - the definition of channel is overloaded to be the major channel, +// - input type allows us to distinguish between broadcast and cable frequencies +// which allows us to use the atsc tuning space class for "open cable". +// - country code will allow us to redefine physical channel frequencies +// if any other countries adopt ATSC which may happen in Latin America in particular. + interface IATSCTuningSpace : IAnalogTVTuningSpace + { + [propget, id(DISPID_TUNER_TS_ATSC_MINMINORCHANNEL), + helpstring("Smallest minor channel number ever provided by this tuning space") + ] + HRESULT MinMinorChannel( + [out, retval] long *MinMinorChannelVal + ); + [propput, id(DISPID_TUNER_TS_ATSC_MINMINORCHANNEL), + helpstring("Smallest minor channel number ever provided by this tuning space") + ] + HRESULT MinMinorChannel( + [in] long NewMinMinorChannelVal + ); + [propget, id(DISPID_TUNER_TS_ATSC_MAXMINORCHANNEL), + helpstring("Largest minor channel number ever provided by this tuning space") + ] + HRESULT MaxMinorChannel( + [out, retval] long *MaxMinorChannelVal + ); + [propput, id(DISPID_TUNER_TS_ATSC_MAXMINORCHANNEL), + helpstring("Largest minor channel number ever provided by this tuning space") + ] + HRESULT MaxMinorChannel( + [in] long NewMaxMinorChannelVal + ); + [propget, id(DISPID_TUNER_TS_ATSC_MINPHYSCHANNEL), + helpstring("Smallest physical channel number ever provided by this tuning space") + ] + HRESULT MinPhysicalChannel( + [out, retval] long *MinPhysicalChannelVal + ); + [propput, id(DISPID_TUNER_TS_ATSC_MINPHYSCHANNEL), + helpstring("Smallest physical channel number ever provided by this tuning space") + ] + HRESULT MinPhysicalChannel( + [in] long NewMinPhysicalChannelVal + ); + [propget, id(DISPID_TUNER_TS_ATSC_MAXPHYSCHANNEL), + helpstring("Largest physical channel number ever provided by this tuning space") + ] + HRESULT MaxPhysicalChannel( + [out, retval] long *MaxPhysicalChannelVal + ); + [propput, id(DISPID_TUNER_TS_ATSC_MAXPHYSCHANNEL), + helpstring("Largest physical channel number ever provided by this tuning space") + ] + HRESULT MaxPhysicalChannel( + [in] long NewMaxPhysicalChannelVal + ); + + } + +////////////////////////////////////////////////////////////////////////////////////// + [ + object, + hidden, + dual, + oleautomation, + nonextensible, + uuid(2A6E293B-2595-11d3-B64C-00C04F79498E), + pointer_default(unique) + ] + interface IAnalogRadioTuningSpace : ITuningSpace { + [propget, id(DISPID_TUNER_TS_AR_MINFREQUENCY), + helpstring("Smallest frequency(KHz) ever used by this tuning space") + ] + HRESULT MinFrequency( + [out, retval] long *MinFrequencyVal + ); + [propput, id(DISPID_TUNER_TS_AR_MINFREQUENCY), + helpstring("Smallest frequency(KHz) ever used by this tuning space") + ] + HRESULT MinFrequency( + [in] long NewMinFrequencyVal + ); + [propget, id(DISPID_TUNER_TS_AR_MAXFREQUENCY), + helpstring("Largest frequency(KHz) ever used by this tuning space") + ] + HRESULT MaxFrequency( + [out, retval] long *MaxFrequencyVal + ); + [propput, id(DISPID_TUNER_TS_AR_MAXFREQUENCY), + helpstring("Largest frequency(KHz) ever used by this tuning space") + ] + HRESULT MaxFrequency( + [in] long NewMaxFrequencyVal + ); + [propget, id(DISPID_TUNER_TS_AR_STEP), + helpstring("Default step value(KHz) to next frequency for this tuning space") + ] + HRESULT Step( + [out, retval] long *StepVal + ); + [propput, id(DISPID_TUNER_TS_AR_STEP), + helpstring("Default step value(KHz) to next frequency for this tuning space") + ] + HRESULT Step( + [in] long NewStepVal + ); + } + + +////////////////////////////////////////////////////////////////////////////////////// +// Tune Request Interfaces +////////////////////////////////////////////////////////////////////////////////////// +// tune requests(of any kind) can only be obtained from tune request factories such as +// ITuningSpace::CreateTuneRequest. one reason for this is that we always want to be +// certain that a tune request is bound to the right tuning space. this means we don't +// have to perform consistency checks all over the place. + [ + object, + nonextensible, + uuid(07DDC146-FC3D-11d2-9D8C-00C04F72D980), + dual, + oleautomation, + helpstring("Tune Request Interface"), + pointer_default(unique) + ] + interface ITuneRequest : IDispatch + { + [propget, id(DISPID_TUNER_TR_TUNINGSPACE), + helpstring("Tuning Space object")] + HRESULT TuningSpace( + [out, retval] ITuningSpace **TuningSpace + ); + [propget, id(DISPID_TUNER_TR_COMPONENTS), + helpstring("Components collection")] + HRESULT Components( + [out, retval] IComponents **Components + ); + [id(DISPID_TUNER_TR_CLONE), + helpstring("Create a new copy of this tune request")] + HRESULT Clone( + [out, retval] ITuneRequest **NewTuneRequest + ); + [propget, id(DISPID_TUNER_TR_LOCATOR), + helpstring("Locator Object")] + HRESULT Locator( + [out, retval] ILocator **Locator + ); + [propput, id(DISPID_TUNER_TR_LOCATOR), + helpstring("Locator Object")] + HRESULT Locator( + [in] ILocator *Locator + ); + } + +////////////////////////////////////////////////////////////////////////////////////// + [ + object, + nonextensible, + uuid(0369B4E0-45B6-11d3-B650-00C04F79498E), + dual, + oleautomation, + helpstring("Channel Tune Request Interface"), + pointer_default(unique) + ] + interface IChannelTuneRequest : ITuneRequest + { + [propget, id(DISPID_CHTUNER_CTR_CHANNEL), + helpstring("Channel")] + HRESULT Channel( + [out, retval] long *Channel + ); + [propput, id(DISPID_CHTUNER_CTR_CHANNEL), + helpstring("Channel")] + HRESULT Channel( + [in] long Channel + ); + } + +////////////////////////////////////////////////////////////////////////////////////// + [ + object, + nonextensible, + uuid(0369B4E1-45B6-11d3-B650-00C04F79498E), + dual, + oleautomation, + helpstring("ATSC Channel Tune Request Interface"), + pointer_default(unique) + ] + interface IATSCChannelTuneRequest : IChannelTuneRequest + { + [propget, id(DISPID_CHTUNER_ACTR_MINOR_CHANNEL), + helpstring("Minor Channel")] + HRESULT MinorChannel( + [out, retval] long *MinorChannel + ); + [propput, id(DISPID_CHTUNER_ACTR_MINOR_CHANNEL), + helpstring("Minor Channel")] + HRESULT MinorChannel( + [in] long MinorChannel + ); + } + +////////////////////////////////////////////////////////////////////////////////////// + [ + object, + nonextensible, + uuid(0D6F567E-A636-42bb-83BA-CE4C1704AFA2), + dual, + oleautomation, + helpstring("DVB Tune Request Interface"), + pointer_default(unique) + ] + interface IDVBTuneRequest : ITuneRequest + { + [propget, id(DISPID_DVBTUNER_ONID), + helpstring("Original Network ID")] + HRESULT ONID( + [out, retval] long *ONID + ); + [propput, id(DISPID_DVBTUNER_ONID), + helpstring("Original Network ID")] + HRESULT ONID( + [in] long ONID + ); + [propget, id(DISPID_DVBTUNER_TSID), + helpstring("Transport Stream ID")] + HRESULT TSID( + [out, retval] long *TSID + ); + [propput, id(DISPID_DVBTUNER_TSID), + helpstring("Transport Stream ID")] + HRESULT TSID( + [in] long TSID + ); + [propget, id(DISPID_DVBTUNER_SID), + helpstring("Service ID")] + HRESULT SID( + [out, retval] long *SID + ); + [propput, id(DISPID_DVBTUNER_SID), + helpstring("Service ID")] + HRESULT SID( + [in] long SID + ); + } + +////////////////////////////////////////////////////////////////////////////////////// +/// There are times(for example, reading from a file) when its useful to be able to tune +/// a basic mpeg2 transport stream that contains minimal tables. this requires the least +/// common denominator mpeg2 xport stream id information +/// the following tune request supplies these properties. it can typiclly only be obtained from +/// an mpeg2tunerequestfactory object. no known tune request(at this time) will return this +/// from their createtunerequest() method. in other words, this is not the "best" tune request +/// for any of the current tuning spaces. +////////////////////////////////////////////////////////////////////////////////////// + [ + object, + nonextensible, + uuid(EB7D987F-8A01-42ad-B8AE-574DEEE44D1A), + dual, + oleautomation, + helpstring("MPEG2 Tune Request Interface"), + pointer_default(unique) + ] + interface IMPEG2TuneRequest : ITuneRequest + { + [propget, id(DISPID_MP2TUNER_TSID), + helpstring("Transport Stream ID")] + HRESULT TSID( + [out, retval] long *TSID + ); + [propput, id(DISPID_MP2TUNER_TSID), + helpstring("Transport Stream ID")] + HRESULT TSID( + [in] long TSID + ); + [propget, id(DISPID_MP2TUNER_PROGNO), + helpstring("Program Number ID")] + HRESULT ProgNo( + [out, retval] long *ProgNo + ); + [propput, id(DISPID_MP2TUNER_PROGNO), + helpstring("Program Number ID")] + HRESULT ProgNo( + [in] long ProgNo + ); + } + + [ + object, + nonextensible, + hidden, + uuid(14E11ABD-EE37-4893-9EA1-6964DE933E39), + dual, + oleautomation, + helpstring("MPEG2 Tune Request Factory Interface"), + pointer_default(unique) + ] + interface IMPEG2TuneRequestFactory : IDispatch + { + [id(DISPID_MP2TUNERFACTORY_CREATETUNEREQUEST), + helpstring("Create MPEG2 Tune Request for specified tuning space(if possible)")] + HRESULT CreateTuneRequest( + [in] ITuningSpace *TuningSpace, + [out, retval] IMPEG2TuneRequest **TuneRequest + ); + } + + [ + object, + hidden, + restricted, + nonextensible, + uuid(1B9D5FC3-5BBC-4b6c-BB18-B9D10E3EEEBF), + helpstring("MPEG2 Tune Request Supported Interface"), + pointer_default(unique) + ] + interface IMPEG2TuneRequestSupport : IUnknown + { + } + + +////////////////////////////////////////////////////////////////////////////////////// +// Tuner Interfaces +////////////////////////////////////////////////////////////////////////////////////// + [ + object, + hidden, + nonextensible, + uuid(28C52640-018A-11d3-9D8E-00C04F72D980), + helpstring("Tuner Interface"), + pointer_default(unique) + ] + interface ITuner : IUnknown + { + [propget, helpstring("Tuning Space object")] + HRESULT TuningSpace( + [out, retval] ITuningSpace **TuningSpace + ); + + [propput, helpstring("Tuning Space object")] + HRESULT TuningSpace( + [in] ITuningSpace *TuningSpace + ); + + [hidden, restricted, helpstring("Returns an enumerator for Tuning Spaces accepted by this tuner")] + HRESULT EnumTuningSpaces( + [out, retval] IEnumTuningSpaces **ppEnum + ); + + [propget, helpstring("Tune Request object")] + HRESULT TuneRequest( + [out, retval] ITuneRequest **TuneRequest + ); + + [propput, helpstring("Tune Request object")] + HRESULT TuneRequest( + [in] ITuneRequest *TuneRequest + ); + + [helpstring("Validate the tuning request without tuning")] + HRESULT Validate( + [in] ITuneRequest *TuneRequest + ); + + [propget, helpstring("Preferred Component Types collection")] + HRESULT PreferredComponentTypes( + [out, retval] IComponentTypes **ComponentTypes + ); + + [propput, helpstring("Preferred Component Types collection")] + HRESULT PreferredComponentTypes( + [in] IComponentTypes *ComponentTypes + ); + + [propget, helpstring("Signal Strength")] + HRESULT SignalStrength( + [out, retval] long *Strength + ); + + [helpstring("Trigger Signal events (interval in milliseconds; 0 turns off trigger)")] + HRESULT TriggerSignalEvents( + [in] long Interval + ); + } + +////////////////////////////////////////////////////////////////////////////////////// + [ + object, + hidden, + nonextensible, + uuid(1DFD0A5C-0284-11d3-9D8E-00C04F72D980), + helpstring("Scanning Tuner Interface"), + pointer_default(unique) + ] + interface IScanningTuner : ITuner + { + [helpstring("Seek to the next valid selection")] + HRESULT SeekUp( + ); + + [helpstring("Seek to the previous valid selection")] + HRESULT SeekDown( + ); + + [helpstring("Scan for valid selections upward")] + HRESULT ScanUp( + [in] long MillisecondsPause + ); + + [helpstring("Scan for valid selections downward")] + HRESULT ScanDown( + [in] long MillisecondsPause + ); + + [helpstring("Enter the device's autoprogram mode")] + HRESULT AutoProgram( + ); + }; + +////////////////////////////////////////////////////////////////////////////////////// +// Component Type Interfaces +////////////////////////////////////////////////////////////////////////////////////// + + // Component Category + + [ + object, + hidden, + nonextensible, + uuid(6A340DC0-0311-11d3-9D8E-00C04F72D980), + dual, + oleautomation, + helpstring("Component Type Interface"), + pointer_default(unique) + ] + interface IComponentType : IDispatch + { + [propget, id(DISPID_TUNER_CT_CATEGORY), + helpstring("General category of component")] + HRESULT Category( + [out, retval] ComponentCategory *Category + ); + [propput, id(DISPID_TUNER_CT_CATEGORY), + helpstring("General category of component")] + HRESULT Category( + [in] ComponentCategory Category + ); + + [propget, id(DISPID_TUNER_CT_MEDIAMAJORTYPE), + helpstring("DirectShow MediaType Major Type Guid")] + HRESULT MediaMajorType( + [out, retval] BSTR *MediaMajorType + ); + [propput, id(DISPID_TUNER_CT_MEDIAMAJORTYPE), + helpstring("DirectShow MediaType Major Type Guid")] + HRESULT MediaMajorType( + [in] BSTR MediaMajorType + ); + [propget, id(DISPID_TUNER_CT__MEDIAMAJORTYPE), + helpstring("DirectShow MediaType Major Type Guid"), hidden, restricted] + HRESULT _MediaMajorType( + [out, retval] GUID* MediaMajorTypeGuid + ); + [propput, id(DISPID_TUNER_CT__MEDIAMAJORTYPE), + helpstring("DirectShow MediaType Major Type Guid"), hidden, restricted] + HRESULT _MediaMajorType( + [in] REFCLSID MediaMajorTypeGuid + ); + [propget, id(DISPID_TUNER_CT_MEDIASUBTYPE), + helpstring("DirectShow MediaType Sub Type Guid")] + HRESULT MediaSubType( + [out, retval] BSTR *MediaSubType + ); + [propput, id(DISPID_TUNER_CT_MEDIASUBTYPE), + helpstring("DirectShow MediaType Sub Type Guid")] + HRESULT MediaSubType( + [in] BSTR MediaSubType + ); + [propget, id(DISPID_TUNER_CT__MEDIASUBTYPE), + helpstring("DirectShow MediaType Sub Type Guid"), hidden, restricted] + HRESULT _MediaSubType( + [out, retval] GUID* MediaSubTypeGuid + ); + [propput, id(DISPID_TUNER_CT__MEDIASUBTYPE), + helpstring("DirectShow MediaType Sub Type Guid"), hidden, restricted] + HRESULT _MediaSubType( + [in] REFCLSID MediaSubTypeGuid + ); + [propget, id(DISPID_TUNER_CT_MEDIAFORMATTYPE), + helpstring("DirectShow MediaType Format Guid")] + HRESULT MediaFormatType( + [out, retval] BSTR *MediaFormatType + ); + [propput, id(DISPID_TUNER_CT_MEDIAFORMATTYPE), + helpstring("DirectShow MediaType Format Guid")] + HRESULT MediaFormatType( + [in] BSTR MediaFormatType + ); + [propget, id(DISPID_TUNER_CT__MEDIAFORMATTYPE), + helpstring("DirectShow MediaType Format Guid"), hidden, restricted] + HRESULT _MediaFormatType( + [out, retval] GUID* MediaFormatTypeGuid + ); + [propput, id(DISPID_TUNER_CT__MEDIAFORMATTYPE), + helpstring("DirectShow MediaType Format Guid"), hidden, restricted] + HRESULT _MediaFormatType( + [in] REFCLSID MediaFormatTypeGuid + ); + + [propget, id(DISPID_TUNER_CT_MEDIATYPE), hidden, restricted, + helpstring("DirectShow MediaType Guid, this only retrieves major, sub, format guids not the entire struct")] + HRESULT MediaType( + [out, retval] AM_MEDIA_TYPE *MediaType + ); + [propput, id(DISPID_TUNER_CT_MEDIATYPE), hidden, restricted, + helpstring("DirectShow MediaType Guid, this only retrieves major, sub, format guids not the entire struct")] + HRESULT MediaType( + [in] AM_MEDIA_TYPE *MediaType + ); + + [id(DISPID_TUNER_CT_CLONE), + helpstring("Create a copy of this component type")] + HRESULT Clone( + [out, retval] IComponentType **NewCT + ); + }; + +////////////////////////////////////////////////////////////////////////////////////// + [ + object, + hidden, + nonextensible, + uuid(B874C8BA-0FA2-11d3-9D8E-00C04F72D980), + dual, + oleautomation, + helpstring("Language Component Type Interface"), + pointer_default(unique) + ] + interface ILanguageComponentType : IComponentType + { + [propget, id(DISPID_TUNER_LCT_LANGID), + helpstring("Language Identifier for Substream Content Language")] + HRESULT LangID( + [out, retval] long *LangID + ); + + [propput, id(DISPID_TUNER_LCT_LANGID), + helpstring("Language Identifier for Substream Content Language")] + HRESULT LangID( + [in] long LangID + ); + }; + +////////////////////////////////////////////////////////////////////////////////////// + [ + object, + hidden, + nonextensible, + uuid(2C073D84-B51C-48c9-AA9F-68971E1F6E38), + dual, + oleautomation, + helpstring("MPEG2 Component Type Interface"), + pointer_default(unique) + ] + interface IMPEG2ComponentType : ILanguageComponentType + { + [propget, id(DISPID_TUNER_MP2CT_TYPE), + helpstring("MPEG2 Stream Type")] + HRESULT StreamType( + [out, retval] MPEG2StreamType *MP2StreamType + ); + + [propput, id(DISPID_TUNER_MP2CT_TYPE), + helpstring("MPEG2 Stream Type")] + HRESULT StreamType( + [in] MPEG2StreamType MP2StreamType + ); + }; + +////////////////////////////////////////////////////////////////////////////////////// + + [ + object, + hidden, + nonextensible, + uuid(FC189E4D-7BD4-4125-B3B3-3A76A332CC96), + dual, + oleautomation, + helpstring("ATSC Component Type Interface"), + pointer_default(unique) + ] + interface IATSCComponentType : IMPEG2ComponentType + { + [propget, id(DISPID_TUNER_ATSCCT_FLAGS), + helpstring("ATSC Component Type Flags")] + HRESULT Flags( + [out, retval] long *Flags + ); + + [propput, id(DISPID_TUNER_ATSCCT_FLAGS), + helpstring("ATSC Component Type Flags")] + HRESULT Flags( + [in] long flags + ); + }; + +////////////////////////////////////////////////////////////////////////////////////// + [ + hidden, restricted, + object, + uuid(8A674B4A-1F63-11d3-B64C-00C04F79498E), + pointer_default(unique) + ] + interface IEnumComponentTypes : IUnknown + { + HRESULT Next( + [in] ULONG celt, + [out, size_is(celt), length_is(*pceltFetched)] + IComponentType** rgelt, + [out] ULONG* pceltFetched + ); + + HRESULT Skip( + [in] ULONG celt + ); + + HRESULT Reset(void); + + HRESULT Clone( + [out] IEnumComponentTypes** ppEnum + ); + } + + +////////////////////////////////////////////////////////////////////////////////////// +// Component Type Container +////////////////////////////////////////////////////////////////////////////////////// + + [ + object, + hidden, + nonextensible, + uuid(0DC13D4A-0313-11d3-9D8E-00C04F72D980), + dual, + oleautomation, + helpstring("ComponentType Collection Interface"), + pointer_default(unique) + ] + interface IComponentTypes : IDispatch + { + [propget, helpstring("Number of items in the collection")] + HRESULT Count( + [out, retval] long *Count + ); + + [propget, id(DISPID_NEWENUM), hidden, restricted] + HRESULT _NewEnum( + [out, retval] IEnumVARIANT **ppNewEnum + ); + + [hidden, restricted, helpstring("Convenience Function for Use with C")] + HRESULT EnumComponentTypes( + [out, retval] IEnumComponentTypes **ppNewEnum + ); + + [id(DISPID_VALUE), + propget, + helpstring("Get the ComponentType at the specified index")] + HRESULT Item( + [in] VARIANT Index, + [out, retval] IComponentType **ComponentType + ); + + [id(DISPID_VALUE), + propput, + helpstring("Get the ComponentType at the specified index")] + HRESULT Item( + [in] VARIANT Index, + [in] IComponentType *ComponentType + ); + + [id(DISPID_ADDITEM), + helpstring("Append the ComponentType to the collection")] + HRESULT Add( + [in] IComponentType *ComponentType, + [out, retval] VARIANT *NewIndex + ); + + [id(DISPID_REMOVEITEM), + helpstring("Clear the collection")] + HRESULT Remove( + [in] VARIANT Index + ); + + [helpstring("Copy the collection")] + HRESULT Clone([out, retval] IComponentTypes **NewList); + }; + +////////////////////////////////////////////////////////////////////////////////////// +// Component Interfaces +////////////////////////////////////////////////////////////////////////////////////// + + [ + object, + nonextensible, + uuid(1A5576FC-0E19-11d3-9D8E-00C04F72D980), + dual, + oleautomation, + helpstring("Component Interface"), + pointer_default(unique) + ] + interface IComponent : IDispatch + { + [propget, id(DISPID_TUNER_C_TYPE), + helpstring("Component Type")] + HRESULT Type( + [out, retval] IComponentType** CT + ); + + // only loaders initialize components + [hidden, restricted, propput, id(DISPID_TUNER_C_TYPE), + helpstring("Component Type")] + HRESULT Type( + [in] IComponentType* CT + ); + + // NOTE: this langid is *not* the same as the langid + // in the componenttype(if the componenttype is a languagecomponenttype) + // the langid in the component type is the language of the content this + // component is describing. the following langid in the component is the + // language of the descriptive info in the component object. + [propget, id(DISPID_TUNER_C_LANGID), + helpstring("Language Identifier for Description Language")] + HRESULT DescLangID( + [out, retval] long *LangID + ); + + [propput, id(DISPID_TUNER_C_LANGID), + helpstring("Language Identifier for Description Language")] + HRESULT DescLangID( + [in] long LangID + ); + + [propget, id(DISPID_TUNER_C_STATUS), + helpstring("Component Status")] + HRESULT Status( + [out, retval] ComponentStatus *Status + ); + + [propput, id(DISPID_TUNER_C_STATUS), + helpstring("Component Status")] + HRESULT Status( + [in] ComponentStatus Status + ); + + [propget, id(DISPID_TUNER_C_DESCRIPTION), + helpstring("Component Description")] + HRESULT Description( + [out, retval] BSTR *Description + ); + + // restricted: only loaders will initialize components + [hidden, restricted, propput, id(DISPID_TUNER_C_DESCRIPTION), + helpstring("Component Description")] + HRESULT Description( + [in] BSTR Description + ); + + [id(DISPID_TUNER_C_CLONE), + helpstring("Copy Component")] + HRESULT Clone( + [out, retval] IComponent **NewComponent + ); + + }; + +////////////////////////////////////////////////////////////////////////////////////// + [ + object, + nonextensible, + uuid(1493E353-1EB6-473c-802D-8E6B8EC9D2A9), + dual, + oleautomation, + helpstring("MPEG2 Component Interface"), + pointer_default(unique) + ] + interface IMPEG2Component : IComponent + { + [propget, id(DISPID_TUNER_C_MP2_PID), + helpstring("MPEG2 Packet ID for this Substream")] + HRESULT PID( + [out, retval] long *PID + ); + + [propput, id(DISPID_TUNER_C_MP2_PID), + helpstring("MPEG2 Packet ID for this Substream")] + HRESULT PID( + [in] long PID + ); + [propget, id(DISPID_TUNER_C_MP2_PCRPID), + helpstring("MPEG2 Packet ID for this Substream's Timestamps")] + HRESULT PCRPID( + [out, retval] long *PCRPID + ); + + [propput, id(DISPID_TUNER_C_MP2_PCRPID), + helpstring("MPEG2 Packet ID for this Substream's Timestamps")] + HRESULT PCRPID( + [in] long PCRPID + ); + + // program number provides reverse lookup to PAT + [propget, id(DISPID_TUNER_C_MP2_PROGNO), + helpstring("MPEG2 Program Number")] + HRESULT ProgramNumber( + [out, retval] long *ProgramNumber + ); + + [propput, id(DISPID_TUNER_C_MP2_PROGNO), + helpstring("MPEG2 Program Number")] + HRESULT ProgramNumber( + [in] long ProgramNumber + ); + }; + +////////////////////////////////////////////////////////////////////////////////////// + [ + hidden, restricted, + object, + uuid(2A6E2939-2595-11d3-B64C-00C04F79498E), + pointer_default(unique) + ] + interface IEnumComponents : IUnknown + { + HRESULT Next( + [in] ULONG celt, + [out, size_is(celt), length_is(*pceltFetched)] + IComponent** rgelt, + [out] ULONG* pceltFetched + ); + + HRESULT Skip( + [in] ULONG celt + ); + + HRESULT Reset(void); + + HRESULT Clone( + [out] IEnumComponents** ppEnum + ); + } + + +////////////////////////////////////////////////////////////////////////////////////// +// Component Container +////////////////////////////////////////////////////////////////////////////////////// + + [ + object, + nonextensible, + uuid(FCD01846-0E19-11d3-9D8E-00C04F72D980), + dual, + oleautomation, + helpstring("Component Collection Interface"), + pointer_default(unique) + ] + interface IComponents : IDispatch + { + [propget, helpstring("Number of items in the collection")] + HRESULT Count( + [out, retval] long *Count + ); + + [propget, id(DISPID_NEWENUM), hidden, restricted] + HRESULT _NewEnum( + [out, retval] IEnumVARIANT **ppNewEnum + ); + + [hidden, restricted, helpstring("Convenience Function for Use with C")] + HRESULT EnumComponents( + [out, retval] IEnumComponents **ppNewEnum + ); + + [id(DISPID_VALUE), + propget, + helpstring("Get the Component at the specified index")] + HRESULT Item( + [in] VARIANT Index, + [out, retval] IComponent **ppComponent + ); + + [id(DISPID_ADDITEM), + helpstring("Add the Component to the collection")] + HRESULT Add( + [in] IComponent *Component, + [out, retval] VARIANT *NewIndex + ); + + [id(DISPID_REMOVEITEM), + helpstring("Remove the Component at the specified index")] + HRESULT Remove( + [in] VARIANT Index + ); + + [helpstring("Copy the collection")] + HRESULT Clone([out, retval] IComponents **NewList); + }; + +////////////////////////////////////////////////////////////////////////////////////// +// Component Container +////////////////////////////////////////////////////////////////////////////////////// +// this separates the what(general tune request properties) from the where + + + + [ + object, + nonextensible, + uuid(286D7F89-760C-4F89-80C4-66841D2507AA), + dual, + oleautomation, + helpstring("Generic Locator Information"), + pointer_default(unique) + ] + interface ILocator : IDispatch + { + + [propget, id(DISPID_TUNER_L_CARRFREQ), helpstring("Carrier Frequency(KHz)")] + HRESULT CarrierFrequency( + [out, retval] long* Frequency + ); + [propput, id(DISPID_TUNER_L_CARRFREQ), helpstring("Carrier Frequency(KHz)")] + HRESULT CarrierFrequency( + [in] long Frequency + ); + [propget, id(DISPID_TUNER_L_INNERFECMETHOD), helpstring("Inner Fec Type")] + HRESULT InnerFEC( + [out, retval] FECMethod* FEC + ); + [propput, id(DISPID_TUNER_L_INNERFECMETHOD), helpstring("Inner Fec Type")] + HRESULT InnerFEC( + [in] FECMethod FEC + ); + [propget, id(DISPID_TUNER_L_INNERFECRATE), helpstring("Inner Fec Rate")] + HRESULT InnerFECRate( + [out, retval] BinaryConvolutionCodeRate* FEC + ); + [propput, id(DISPID_TUNER_L_INNERFECRATE), helpstring("Inner Fec Rate")] + HRESULT InnerFECRate( + [in] BinaryConvolutionCodeRate FEC + ); + [propget, id(DISPID_TUNER_L_OUTERFECMETHOD), helpstring("Outer Fec Type")] + HRESULT OuterFEC( + [out, retval] FECMethod* FEC + ); + [propput, id(DISPID_TUNER_L_OUTERFECMETHOD), helpstring("Outer Fec Type")] + HRESULT OuterFEC( + [in] FECMethod FEC + ); + [propget, id(DISPID_TUNER_L_OUTERFECRATE), helpstring("Outer Fec Rate")] + HRESULT OuterFECRate( + [out, retval] BinaryConvolutionCodeRate* FEC + ); + [propput, id(DISPID_TUNER_L_OUTERFECRATE), helpstring("Outer Fec Rate")] + HRESULT OuterFECRate( + [in] BinaryConvolutionCodeRate FEC + ); + [propget, id(DISPID_TUNER_L_MOD), helpstring("Modulation Type")] + HRESULT Modulation( + [out, retval] ModulationType* Modulation + ); + [propput, id(DISPID_TUNER_L_MOD), helpstring("Modulation Type")] + HRESULT Modulation( + [in] ModulationType Modulation + ); + [propget, id(DISPID_TUNER_L_SYMRATE), helpstring("Modulation Symbol Rate")] + HRESULT SymbolRate( + [out, retval] long* Rate + ); + [propput, id(DISPID_TUNER_L_SYMRATE), helpstring("Modulation Symbol Rate")] + HRESULT SymbolRate( + [in] long Rate + ); + [id(DISPID_TUNER_L_CLONE), helpstring("Copy the Locator")] + HRESULT Clone([out, retval] ILocator **NewLocator); + }; + +////////////////////////////////////////////////////////////////////////////////////// + [ + object, + hidden, + nonextensible, + uuid(BF8D986F-8C2B-4131-94D7-4D3D9FCC21EF), + dual, + oleautomation, + helpstring("ATSC Locator Information"), + pointer_default(unique) + ] + interface IATSCLocator : ILocator + { + [propget, id(DISPID_TUNER_L_ATSC_PHYS_CHANNEL), + helpstring("Physical Channel")] + HRESULT PhysicalChannel( + [out, retval] long *PhysicalChannel + ); + [propput, id(DISPID_TUNER_L_ATSC_PHYS_CHANNEL), + helpstring("Physical Channel")] + HRESULT PhysicalChannel( + [in] long PhysicalChannel + ); + [propget, id(DISPID_TUNER_L_ATSC_TSID), + helpstring("Transport Stream ID")] + HRESULT TSID( + [out, retval] long *TSID + ); + [propput, id(DISPID_TUNER_L_ATSC_TSID), + helpstring("Transport Stream ID")] + HRESULT TSID( + [in] long TSID + ); + }; + +////////////////////////////////////////////////////////////////////////////////////// + + [ + object, + hidden, + nonextensible, + uuid(8664DA16-DDA2-42ac-926A-C18F9127C302), + dual, + oleautomation, + helpstring("DVB Terrestrial Locator Information"), + pointer_default(unique) + ] + interface IDVBTLocator : ILocator + { + [propget, id(DISPID_TUNER_L_DVBT_BANDWIDTH), helpstring("Bandwidth")] + HRESULT Bandwidth( + [out, retval] long* BandWidthVal + ); + [propput, id(DISPID_TUNER_L_DVBT_BANDWIDTH), helpstring("Bandwidth")] + HRESULT Bandwidth( + [in] long BandwidthVal + ); + + [propget, id(DISPID_TUNER_L_DVBT_LPINNERFECMETHOD), helpstring("Inner Fec Type for Low Priority Stream")] + HRESULT LPInnerFEC( + [out, retval] FECMethod* FEC + ); + [propput, id(DISPID_TUNER_L_DVBT_LPINNERFECMETHOD), helpstring("Inner Fec Type for Low Priority Stream")] + HRESULT LPInnerFEC( + [in] FECMethod FEC + ); + [propget, id(DISPID_TUNER_L_DVBT_LPINNERFECRATE), helpstring("Inner Fec Rate for Low Priority Stream")] + HRESULT LPInnerFECRate( + [out, retval] BinaryConvolutionCodeRate* FEC + ); + [propput, id(DISPID_TUNER_L_DVBT_LPINNERFECRATE), helpstring("Inner Fec Rate for Low Priority Stream")] + HRESULT LPInnerFECRate( + [in] BinaryConvolutionCodeRate FEC + ); + [propget, id(DISPID_TUNER_L_DVBT_HALPHA), helpstring("Hierarchical Alpha")] + HRESULT HAlpha( + [out, retval] HierarchyAlpha* Alpha + ); + [propput, id(DISPID_TUNER_L_DVBT_HALPHA), helpstring("Hierarchical Alpha")] + HRESULT HAlpha( + [in] HierarchyAlpha Alpha + ); + [propget, id(DISPID_TUNER_L_DVBT_GUARDINTERVAL), helpstring("Guard Interval")] + HRESULT Guard( + [out, retval] GuardInterval* GI + ); + [propput, id(DISPID_TUNER_L_DVBT_GUARDINTERVAL), helpstring("Guard Interval")] + HRESULT Guard( + [in] GuardInterval GI + ); + [propget, id(DISPID_TUNER_L_DVBT_TRANSMISSIONMODE), helpstring("Transmission Mode")] + HRESULT Mode( + [out, retval] TransmissionMode* mode + ); + [propput, id(DISPID_TUNER_L_DVBT_TRANSMISSIONMODE), helpstring("Transmission Mode")] + HRESULT Mode( + [in] TransmissionMode mode + ); + [propget, id(DISPID_TUNER_L_DVBT_INUSE), helpstring("Hierarchical Alpha")] + HRESULT OtherFrequencyInUse( + [out, retval] VARIANT_BOOL* OtherFrequencyInUseVal + ); + [propput, id(DISPID_TUNER_L_DVBT_INUSE), helpstring("Hierarchical Alpha")] + HRESULT OtherFrequencyInUse( + [in] VARIANT_BOOL OtherFrequencyInUseVal + ); + }; + +////////////////////////////////////////////////////////////////////////////////////// + [ + object, + hidden, + nonextensible, + uuid(3D7C353C-0D04-45f1-A742-F97CC1188DC8), + dual, + oleautomation, + helpstring("DVB Satellite Locator Information"), + pointer_default(unique) + ] + interface IDVBSLocator : ILocator + { + + [propget, id(DISPID_TUNER_L_DVBS_POLARISATION), helpstring("Signal Polarisation Type")] + HRESULT SignalPolarisation( + [out, retval] Polarisation* PolarisationVal + ); + [propput, id(DISPID_TUNER_L_DVBS_POLARISATION), helpstring("Signal Polarisation Type")] + HRESULT SignalPolarisation( + [in] Polarisation PolarisationVal + ); + [propget, id(DISPID_TUNER_L_DVBS_WEST), helpstring("VARIANT_TRUE means orbital position specifies west longitude")] + HRESULT WestPosition( + [out, retval] VARIANT_BOOL* WestLongitude + ); + [propput, id(DISPID_TUNER_L_DVBS_WEST), helpstring("VARIANT_TRUE means orbital position specifies west longitude")] + HRESULT WestPosition( + [in] VARIANT_BOOL WestLongitude + ); + [propget, id(DISPID_TUNER_L_DVBS_ORBITAL), helpstring("Longitude in tenths of a degree")] + HRESULT OrbitalPosition( + [out, retval] long* longitude + ); + [propput, id(DISPID_TUNER_L_DVBS_ORBITAL), helpstring("Longitude in tenths of a degree")] + HRESULT OrbitalPosition( + [in] long longitude + ); + [propget, id(DISPID_TUNER_L_DVBS_AZIMUTH), helpstring("Azimuth in tenths of a degree")] + HRESULT Azimuth( + [out, retval] long* Azimuth + ); + [propput, id(DISPID_TUNER_L_DVBS_AZIMUTH), helpstring("Azimuth in tenths of a degree")] + HRESULT Azimuth( + [in] long Azimuth + ); + [propget, id(DISPID_TUNER_L_DVBS_ELEVATION), helpstring("Elevation in tenths of a degree")] + HRESULT Elevation( + [out, retval] long* Elevation + ); + [propput, id(DISPID_TUNER_L_DVBS_ELEVATION), helpstring("Elevation in tenths of a degree")] + HRESULT Elevation( + [in] long Elevation + ); + }; + +////////////////////////////////////////////////////////////////////////////////////// + [ + object, + hidden, + nonextensible, + uuid(6E42F36E-1DD2-43c4-9F78-69D25AE39034), + dual, + oleautomation, + helpstring("DVB Cable Locator Information"), + pointer_default(unique) + ] + interface IDVBCLocator : ILocator + { + }; + +/////////////////////////////////////////////////////////////////////////////////////// +// utility interfaces +/////////////////////////////////////////////////////////////////////////////////////// + + [ + object, + hidden, + nonextensible, + uuid(3B21263F-26E8-489d-AAC4-924F7EFD9511), + helpstring("Broadcast Event Service Firing/Reflecting Interface"), + pointer_default(unique) + ] + interface IBroadcastEvent : IUnknown + { + HRESULT Fire(GUID EventID); + }; + + +////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////// +// TYPELIB & CoClasses +////////////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////////////// +[ + uuid(9B085638-018E-11d3-9D8E-00C04F72D980), + version(1.0), + helpstring("Microsoft Tuner 1.0 Type Library") +] +library TunerLib +{ + importlib("stdole2.tlb"); + + // SystemTuningSpaces class + [ + uuid(D02AAC50-027E-11d3-9D8E-00C04F72D980), + helpstring("SystemTuningSpace Class") + ] + coclass SystemTuningSpaces + { + [default] interface ITuningSpaceContainer; + }; + + // NOTE: there is no object factory for this class. the implementation for the underlying + // code is a c++ abstract base class. this coclass is only provided here to + // force vb to expose the base interface to enable polymorphic access to + // derived objects + [ + hidden, restricted, + uuid(5FFDC5E6-B83A-4b55-B6E8-C69E765FE9DB), + helpstring("dummy class to expose base tuning space i/f to VB") + ] + coclass TuningSpace + { + [default] interface ITuningSpace; + }; + + + [ + uuid(A2E30750-6C3D-11d3-B653-00C04F79498E), + helpstring("ATSC Digital Broadcast Tuning Space Class") + ] + coclass ATSCTuningSpace + { + [default] interface IATSCTuningSpace; + }; + + [ + uuid(8A674B4C-1F63-11d3-B64C-00C04F79498E), + helpstring("Analog Radio Tuning Space Class") + ] + coclass AnalogRadioTuningSpace + { + [default] interface IAnalogRadioTuningSpace; + }; + + [ + uuid(F9769A06-7ACA-4e39-9CFB-97BB35F0E77E), + helpstring("Auxiliary Inputs Tuning Space Class") + ] + coclass AuxInTuningSpace + { + [default] interface IAuxInTuningSpace; + }; + + [ + uuid(8A674B4D-1F63-11d3-B64C-00C04F79498E), + helpstring("Analog TV Tuning Space Class") + ] + coclass AnalogTVTuningSpace + { + [default] interface IAnalogTVTuningSpace; + }; + + [ + uuid(C6B14B32-76AA-4a86-A7AC-5C79AAF58DA7), + helpstring("DVB Tuning Space Class") + ] + coclass DVBTuningSpace + { + [default] interface IDVBTuningSpace2; + interface IDVBTuningSpace; + }; + + [ + uuid(B64016F3-C9A2-4066-96F0-BD9563314726), + helpstring("DVB Satellite Tuning Space Class") + ] + coclass DVBSTuningSpace + { + [default] interface IDVBSTuningSpace; + }; + + + // ComponentTypes container class + [ + uuid(A1A2B1C4-0E3A-11d3-9D8E-00C04F72D980), + helpstring("Component Types Collection Class") + ] + coclass ComponentTypes + { + [default] interface IComponentTypes; + }; + + // ComponentType class + [ + uuid(823535A0-0318-11d3-9D8E-00C04F72D980), + helpstring("ComponentType Class") + ] + coclass ComponentType + { + [default] interface IComponentType; + }; + + // Language ComponentType class + [ + uuid(1BE49F30-0E1B-11d3-9D8E-00C04F72D980), + helpstring("LanguageComponentType Class") + ] + coclass LanguageComponentType + { + [default] interface ILanguageComponentType; + }; + + // MPEG2 ComponentType class + [ + uuid(418008F3-CF67-4668-9628-10DC52BE1D08), + helpstring("MPEG2ComponentType Class") + ] + coclass MPEG2ComponentType + { + [default] interface IMPEG2ComponentType; + }; + + // ATSC ComponentType class + [ + uuid(A8DCF3D5-0780-4ef4-8A83-2CFFAACB8ACE), + helpstring("ATSCComponentType Class") + ] + coclass ATSCComponentType + { + [default] interface IATSCComponentType; + }; + + // Components class + [ + hidden, restricted, + uuid(809B6661-94C4-49e6-B6EC-3F0F862215AA), + helpstring("Components Collection Class") + ] + coclass Components + { + [default] interface IComponents; + }; + + // Component class + // the components can only be created by network provider/tif. client apps + // retrieve them from a filled-in tune request by either loading a persisted tune + // request that has been filled in by a proper guide store loader or by re-getting + // the current tune request property which will have this filled in by the network + // provider + [ + hidden, restricted, + uuid(59DC47A8-116C-11d3-9D8E-00C04F72D980), + helpstring("Component Class") + ] + coclass Component + { + [default] interface IComponent; + }; + + // MPEG2 Component class + [ + hidden, restricted, + uuid(055CB2D7-2969-45cd-914B-76890722F112), + helpstring("MPEG2 Component Class") + ] + coclass MPEG2Component + { + [default] interface IMPEG2Component; + }; + + + // NOTE: there is no object factory for this class. the implementation for the underlying + // code is a c++ abstract base class. this coclass is only provided here to + // force vb to expose the base interface to enable polymorphic access to + // derived objects + [ + hidden, restricted, + uuid(B46E0D38-AB35-4a06-A137-70576B01B39F), + helpstring("dummy class to expose base tune request i/f to VB") + ] + coclass TuneRequest + { + [default] interface ITuneRequest; + }; + + + // NOTE: the tuning request factories should not be invoked directly. + // instead apps should use ITuningSpace::CreateTuningRequest to obtain a correctly + // initialized tuning request of the appropriate type for that space. + // the object factories are provided to allow generic code to a load a previously persisted + // tune request object. + [ + hidden, + restricted, + uuid(0369B4E5-45B6-11d3-B650-00C04F79498E), + helpstring("Channel Tune Request") + ] + coclass ChannelTuneRequest + { + [default] interface IChannelTuneRequest; + }; + + [ + hidden, + restricted, + uuid(0369B4E6-45B6-11d3-B650-00C04F79498E), + helpstring("ATSC Channel Tune Request") + ] + coclass ATSCChannelTuneRequest + { + [default] interface IATSCChannelTuneRequest; + }; + + // NOTE: there is no object factory for this class. the implementation for the underlying + // code is a c++ abstract base class. this coclass is only provided here to + // force vb to expose the base interface to enable polymorphic access to + // derived objects + [ + hidden, restricted, + uuid(0955AC62-BF2E-4cba-A2B9-A63F772D46CF), + helpstring("dummy class to expose mpeg2 request i/f to VB") + ] + coclass MPEG2TuneRequest + { + [default] interface IMPEG2TuneRequest; + }; + + [ + uuid(2C63E4EB-4CEA-41b8-919C-E947EA19A77C), + helpstring("Factory for creating IMPEG2TuneRequest") + ] + coclass MPEG2TuneRequestFactory + { + [default] interface IMPEG2TuneRequestFactory; + }; + + + // NOTE: there is no object factory for this class. the implementation for the underlying + // code is a c++ abstract base class. this coclass is only provided here to + // force vb to expose the base interface to enable polymorphic access to + // derived objects + [ + hidden, restricted, + uuid(0888C883-AC4F-4943-B516-2C38D9B34562), + helpstring("dummy class to expose base locator i/f to VB") + ] + coclass Locator + { + [default] interface ILocator; + }; + + // its not intended that client apps actually create locators. the network + // provider in combination with the transport information filter(TIF) are the + // only modules in the system that actually know the correct values for these objects + // however, for testing purposes, its necessary to allow these to be created. + // instead, normally these will simply be passed around opaquely since they're a + // property of the base tune request interface. + [ + uuid(8872FF1B-98FA-4d7a-8D93-C9F1055F85BB), + helpstring("ATSC Locator") + ] + coclass ATSCLocator + { + [default] interface IATSCLocator; + }; + + [ + uuid(9CD64701-BDF3-4d14-8E03-F12983D86664), + helpstring("DVB-Terrestrial Locator") + ] + coclass DVBTLocator + { + [default] interface IDVBTLocator; + }; + + [ + uuid(1DF7D126-4050-47f0-A7CF-4C4CA9241333), + helpstring("DVB-Satellite Locator") + ] + coclass DVBSLocator + { + [default] interface IDVBSLocator; + }; + + [ + uuid(C531D9FD-9685-4028-8B68-6E1232079F1E), + helpstring("DVB-Cable Locator") + ] + coclass DVBCLocator + { + [default] interface IDVBCLocator; + }; + + [ + hidden, + restricted, + uuid(15D6504A-5494-499c-886C-973C9E53B9F1), + helpstring("DVB Tune Request") + ] + coclass DVBTuneRequest + { + [default] interface IDVBTuneRequest; + }; + +// Sample tuner class definition: +// +// [ +// uuid(<some guid>), +// helpstring("My Tuner object") +// ] +// coclass MyTuner +// { +// [default] interface ITuner; +// interface IMyTunerCustomFeatureInterface; +// }; + +/////////////////////////////////////////////////////////////////////////////////////// +// utility objects +/////////////////////////////////////////////////////////////////////////////////////// + [ + hidden, restricted, + uuid(8A674B49-1F63-11d3-B64C-00C04F79498E), + helpstring("Create property bag backed by registry") + ] + coclass CreatePropBagOnRegKey + { + interface ICreatePropBagOnRegKey; + }; + + [ + hidden, restricted, + uuid(0B3FFB92-0919-4934-9D5B-619C719D0202), + helpstring("DShow Broadcast Event Service Object") + ] + coclass BroadcastEventService + { + interface IBroadcastEvent; + }; + +cpp_quote("#define SID_SBroadcastEventService CLSID_BroadcastEventService") + +} + +// end of file -- tuner.idl |