reactos/dll/directx/bdaplgin/frequencyfilter.cpp

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS BDA Proxy
   4  * FILE:            dll/directx/bdaplgin/frequencyfilter.cpp
   5  * PURPOSE:         IBDA_FrequencyFilter interface
   6  *
   7  * PROGRAMMERS:     Johannes Anderwald (janderwald@reactos.org)
   8  */
   9
  10 #include "precomp.h"
  11
  12 const GUID IID_IBDA_FrequencyFilter = {0x71985f47, 0x1ca1, 0x11d3, {0x9c, 0xc8, 0x00, 0xc0, 0x4f, 0x79, 0x71, 0xe0}};
  13 const GUID KSPROPSETID_BdaFrequencyFilter = {0x71985f47, 0x1ca1, 0x11d3, {0x9c, 0xc8, 0x0, 0xc0, 0x4f, 0x79, 0x71, 0xe0}};
  14
  15 class CBDAFrequencyFilter : public IBDA_FrequencyFilter
  16 {
  17 public:
  18     STDMETHODIMP QueryInterface( REFIID InterfaceId, PVOID* Interface);
  19
  20     STDMETHODIMP_(ULONG) AddRef()
  21     {
  22         InterlockedIncrement(&m_Ref);
  23         return m_Ref;
  24     }
  25     STDMETHODIMP_(ULONG) Release()
  26     {
  27         InterlockedDecrement(&m_Ref);
  28         if (!m_Ref)
  29         {
  30             delete this;
  31             return 0;
  32         }
  33         return m_Ref;
  34     }
  35
  36     HRESULT STDMETHODCALLTYPE put_Autotune(ULONG ulTransponder);
  37     HRESULT STDMETHODCALLTYPE get_Autotune(ULONG *pulTransponder);
  38     HRESULT STDMETHODCALLTYPE put_Frequency(ULONG ulFrequency);
  39     HRESULT STDMETHODCALLTYPE get_Frequency(ULONG *pulFrequency);
  40     HRESULT STDMETHODCALLTYPE put_Polarity(Polarisation Polarity);
  41     HRESULT STDMETHODCALLTYPE get_Polarity(Polarisation *pPolarity);
  42     HRESULT STDMETHODCALLTYPE put_Range(ULONG ulRange);
  43     HRESULT STDMETHODCALLTYPE get_Range(ULONG *pulRange);
  44     HRESULT STDMETHODCALLTYPE put_Bandwidth(ULONG ulBandwidth);
  45     HRESULT STDMETHODCALLTYPE get_Bandwidth(ULONG *pulBandwidth);
  46     HRESULT STDMETHODCALLTYPE put_FrequencyMultiplier(ULONG ulMultiplier);
  47     HRESULT STDMETHODCALLTYPE get_FrequencyMultiplier(ULONG *pulMultiplier);
  48
  49     CBDAFrequencyFilter(HANDLE hFile, ULONG NodeId) : m_Ref(0), m_hFile(hFile), m_NodeId(NodeId){};
  50     virtual ~CBDAFrequencyFilter(){};
  51
  52 protected:
  53     LONG m_Ref;
  54     HANDLE m_hFile;
  55     ULONG m_NodeId;
  56 };
  57
  58 HRESULT
  59 STDMETHODCALLTYPE
  60 CBDAFrequencyFilter::QueryInterface(
  61     IN  REFIID refiid,
  62     OUT PVOID* Output)
  63 {
  64     *Output = NULL;
  65
  66     if (IsEqualGUID(refiid, IID_IUnknown))
  67     {
  68         *Output = PVOID(this);
  69         reinterpret_cast<IUnknown*>(*Output)->AddRef();
  70         return NOERROR;
  71     }
  72
  73     if (IsEqualGUID(refiid, IID_IBDA_FrequencyFilter))
  74     {
  75         *Output = (IBDA_FrequencyFilter*)(this);
  76         reinterpret_cast<IBDA_FrequencyFilter*>(*Output)->AddRef();
  77         return NOERROR;
  78     }
  79
  80 #ifdef BDAPLGIN_TRACE
  81     WCHAR Buffer[MAX_PATH];
  82     LPOLESTR lpstr;
  83     StringFromCLSID(refiid, &lpstr);
  84     swprintf(Buffer, L"CControlNode::QueryInterface: NoInterface for %s", lpstr);
  85     OutputDebugStringW(Buffer);
  86     CoTaskMemFree(lpstr);
  87 #endif
  88
  89     return E_NOINTERFACE;
  90 }
  91
  92 HRESULT
  93 STDMETHODCALLTYPE
  94 CBDAFrequencyFilter::put_Autotune(ULONG ulTransponder)
  95 {
  96     return E_NOINTERFACE;
  97 }
  98
  99 HRESULT
 100 STDMETHODCALLTYPE
 101 CBDAFrequencyFilter::get_Autotune(ULONG *pulTransponder)
 102 {
 103     return E_NOINTERFACE;
 104 }
 105
 106 HRESULT
 107 STDMETHODCALLTYPE
 108 CBDAFrequencyFilter::put_Frequency(ULONG ulFrequency)
 109 {
 110     KSP_NODE Node;
 111     HRESULT hr;
 112
 113     ULONG BytesReturned;
 114
 115     // setup request
 116     Node.Property.Set = KSPROPSETID_BdaFrequencyFilter;
 117     Node.Property.Id = KSPROPERTY_BDA_RF_TUNER_FREQUENCY;
 118     Node.Property.Flags = KSPROPERTY_TYPE_SET | KSPROPERTY_TYPE_TOPOLOGY;
 119     Node.NodeId = m_NodeId;
 120
 121     // perform request
 122     hr = KsSynchronousDeviceControl(m_hFile, IOCTL_KS_PROPERTY, (PVOID)&Node, sizeof(KSP_NODE), &ulFrequency, sizeof(ULONG), &BytesReturned);
 123
 124 #ifdef BDAPLGIN_TRACE
 125     WCHAR Buffer[100];
 126     swprintf(Buffer, L"CBDAFrequencyFilter::put_Frequency: m_NodeId %lu hr %lx, BytesReturned %lu\n", m_NodeId, hr, BytesReturned);
 127     OutputDebugStringW(Buffer);
 128 #endif
 129
 130     return hr;
 131 }
 132
 133 HRESULT
 134 STDMETHODCALLTYPE
 135 CBDAFrequencyFilter::get_Frequency(ULONG *pulFrequency)
 136 {
 137     return E_NOINTERFACE;
 138 }
 139
 140 HRESULT
 141 STDMETHODCALLTYPE
 142 CBDAFrequencyFilter::put_Polarity(Polarisation Polarity)
 143 {
 144     KSP_NODE Node;
 145     HRESULT hr;
 146     ULONG BytesReturned;
 147
 148     // setup request
 149     Node.Property.Set = KSPROPSETID_BdaFrequencyFilter;
 150     Node.Property.Id = KSPROPERTY_BDA_RF_TUNER_POLARITY;
 151     Node.Property.Flags = KSPROPERTY_TYPE_SET | KSPROPERTY_TYPE_TOPOLOGY;
 152     Node.NodeId = m_NodeId;
 153
 154     // perform request
 155     hr = KsSynchronousDeviceControl(m_hFile, IOCTL_KS_PROPERTY, (PVOID)&Node, sizeof(KSP_NODE), &Polarity, sizeof(Polarisation), &BytesReturned);
 156
 157 #ifdef BDAPLGIN_TRACE
 158     WCHAR Buffer[100];
 159     swprintf(Buffer, L"CBDAFrequencyFilter::put_Polarity: m_NodeId %lu hr %lx, BytesReturned %lu\n", m_NodeId, hr, BytesReturned);
 160     OutputDebugStringW(Buffer);
 161 #endif
 162
 163     return hr;
 164 }
 165
 166 HRESULT
 167 STDMETHODCALLTYPE
 168 CBDAFrequencyFilter::get_Polarity(Polarisation *pPolarity)
 169 {
 170     return E_NOINTERFACE;
 171 }
 172
 173 HRESULT
 174 STDMETHODCALLTYPE
 175 CBDAFrequencyFilter::put_Range(ULONG ulRange)
 176 {
 177     KSP_NODE Node;
 178     HRESULT hr;
 179     ULONG BytesReturned;
 180
 181     // setup request
 182     Node.Property.Set = KSPROPSETID_BdaFrequencyFilter;
 183     Node.Property.Id = KSPROPERTY_BDA_RF_TUNER_RANGE;
 184     Node.Property.Flags = KSPROPERTY_TYPE_SET | KSPROPERTY_TYPE_TOPOLOGY;
 185     Node.NodeId = m_NodeId;
 186
 187     // perform request
 188     hr = KsSynchronousDeviceControl(m_hFile, IOCTL_KS_PROPERTY, (PVOID)&Node, sizeof(KSP_NODE), &ulRange, sizeof(ULONG), &BytesReturned);
 189
 190 #ifdef BDAPLGIN_TRACE
 191     WCHAR Buffer[100];
 192     swprintf(Buffer, L"CBDAFrequencyFilter::put_Polarity: m_NodeId %lu hr %lx, BytesReturned %lu\n", m_NodeId, hr, BytesReturned);
 193     OutputDebugStringW(Buffer);
 194 #endif
 195
 196     return hr;
 197 }
 198
 199 HRESULT
 200 STDMETHODCALLTYPE
 201 CBDAFrequencyFilter::get_Range(ULONG *pulRange)
 202 {
 203     return E_NOINTERFACE;
 204 }
 205
 206 HRESULT
 207 STDMETHODCALLTYPE
 208 CBDAFrequencyFilter::put_Bandwidth(ULONG ulBandwidth)
 209 {
 210     KSP_NODE Node;
 211     HRESULT hr;
 212     ULONG BytesReturned;
 213
 214     // setup request
 215     Node.Property.Set = KSPROPSETID_BdaFrequencyFilter;
 216     Node.Property.Id = KSPROPERTY_BDA_RF_TUNER_BANDWIDTH;
 217     Node.Property.Flags = KSPROPERTY_TYPE_SET | KSPROPERTY_TYPE_TOPOLOGY;
 218     Node.NodeId = m_NodeId;
 219
 220     // perform request
 221     hr = KsSynchronousDeviceControl(m_hFile, IOCTL_KS_PROPERTY, (PVOID)&Node, sizeof(KSP_NODE), &ulBandwidth, sizeof(ULONG), &BytesReturned);
 222
 223 #ifdef BDAPLGIN_TRACE
 224     WCHAR Buffer[100];
 225     swprintf(Buffer, L"CBDAFrequencyFilter::put_Bandwidth: m_NodeId %lu hr %lx, BytesReturned %lu\n", m_NodeId, hr, BytesReturned);
 226     OutputDebugStringW(Buffer);
 227 #endif
 228
 229     return hr;
 230 }
 231
 232 HRESULT
 233 STDMETHODCALLTYPE
 234 CBDAFrequencyFilter::get_Bandwidth(ULONG *pulBandwidth)
 235 {
 236     return E_NOINTERFACE;
 237 }
 238 HRESULT
 239 STDMETHODCALLTYPE
 240 CBDAFrequencyFilter::put_FrequencyMultiplier(ULONG ulMultiplier)
 241 {
 242     KSP_NODE Node;
 243     HRESULT hr;
 244     ULONG BytesReturned;
 245
 246     // setup request
 247     Node.Property.Set = KSPROPSETID_BdaFrequencyFilter;
 248     Node.Property.Id = KSPROPERTY_BDA_RF_TUNER_FREQUENCY_MULTIPLIER;
 249     Node.Property.Flags = KSPROPERTY_TYPE_SET | KSPROPERTY_TYPE_TOPOLOGY;
 250     Node.NodeId = m_NodeId;
 251
 252     // perform request
 253     hr = KsSynchronousDeviceControl(m_hFile, IOCTL_KS_PROPERTY, (PVOID)&Node, sizeof(KSP_NODE), &ulMultiplier, sizeof(ULONG), &BytesReturned);
 254
 255 #ifdef BDAPLGIN_TRACE
 256     WCHAR Buffer[100];
 257     swprintf(Buffer, L"CBDAFrequencyFilter::put_FrequencyMultiplier: m_NodeId %lu hr %lx, BytesReturned %lu\n", m_NodeId, hr, BytesReturned);
 258     OutputDebugStringW(Buffer);
 259 #endif
 260
 261     return hr;
 262 }
 263
 264 HRESULT
 265 STDMETHODCALLTYPE
 266 CBDAFrequencyFilter::get_FrequencyMultiplier(ULONG *pulMultiplier)
 267 {
 268     return E_NOINTERFACE;
 269 }
 270
 271 HRESULT
 272 WINAPI
 273 CBDAFrequencyFilter_fnConstructor(
 274     HANDLE hFile,
 275     ULONG NodeId,
 276     REFIID riid,
 277     LPVOID * ppv)
 278 {
 279     // construct device control
 280     CBDAFrequencyFilter * handler = new CBDAFrequencyFilter(hFile, NodeId);
 281
 282 #ifdef BDAPLGIN_TRACE
 283     OutputDebugStringW(L"CBDAFrequencyFilter_fnConstructor\n");
 284 #endif
 285
 286     if (!handler)
 287         return E_OUTOFMEMORY;
 288
 289     if (FAILED(handler->QueryInterface(riid, ppv)))
 290     {
 291         /* not supported */
 292         delete handler;
 293         return E_NOINTERFACE;
 294     }
 295
 296     return NOERROR;
 297 }