ReactOS 0.4.15-dev-5666-gc548b97
scanningtuner.cpp
Go to the documentation of this file.
1/*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS Network Provider for MPEG2 based networks
4 * FILE: dll/directx/msdvbnp/scanningtuner.cpp
5 * PURPOSE: IScanningTunner interface
6 *
7 * PROGRAMMERS: Johannes Anderwald (johannes.anderwald@reactos.org)
8 */
9#include "precomp.h"
10
12{
13public:
15
17 {
19 return m_Ref;
20 }
22 {
24 if (!m_Ref)
25 {
26 delete this;
27 return 0;
28 }
29 return m_Ref;
30 }
31
32 //ITuner methods
43
44 //IScanningTuner methods
47 HRESULT STDMETHODCALLTYPE ScanUp(long MillisecondsPause);
48 HRESULT STDMETHODCALLTYPE ScanDown(long MillisecondsPause);
50
51 CScanningTunner(std::vector<IUnknown*> & DeviceFilters) : m_Ref(0), m_TuningSpace(0), m_DeviceFilters(DeviceFilters){};
52 virtual ~CScanningTunner() {};
56 HRESULT STDMETHODCALLTYPE SetLnbInfo(IBDA_LNBInfo * pLnbInfo, ULONG ulLOFLow, ULONG ulLOFHigh, ULONG ulSwitchFrequency);
57 HRESULT STDMETHODCALLTYPE SetDigitalDemodulator(IBDA_DigitalDemodulator * pDigitalDemo, ModulationType ModType, FECMethod InnerFEC, BinaryConvolutionCodeRate InnerFECRate, FECMethod OuterFEC, BinaryConvolutionCodeRate OuterFECRate, ULONG SymbolRate);
58 HRESULT SetFrequency(IBDA_FrequencyFilter * pFrequency, ULONG FrequencyMultiplier, ULONG Frequency, Polarisation Polarity, ULONG Range, ULONG Bandwidth);
60protected:
63 std::vector<IUnknown*> & m_DeviceFilters;
64};
65
69 IN REFIID refiid,
71{
72 if (IsEqualGUID(refiid, IID_IUnknown))
73 {
74 *Output = PVOID(this);
75 reinterpret_cast<IUnknown*>(*Output)->AddRef();
76 return NOERROR;
77 }
78 if (IsEqualGUID(refiid, IID_ITuner))
79 {
80 *Output = (ITuner*)(this);
81 reinterpret_cast<ITuner*>(*Output)->AddRef();
82 return NOERROR;
83 }
84
85 if (IsEqualGUID(refiid, IID_IScanningTuner))
86 {
87 *Output = (IScanningTuner*)(this);
88 reinterpret_cast<IScanningTuner*>(*Output)->AddRef();
89 return NOERROR;
90 }
91
94 StringFromCLSID(refiid, &lpstr);
95 swprintf(Buffer, L"CScanningTunner::QueryInterface: NoInterface for %s\n", lpstr);
98
99
100 return E_NOINTERFACE;
101}
102
103//-------------------------------------------------------------------
104//ITuner
105//
109 ITuningSpace **TuningSpace)
110{
111 OutputDebugStringW(L"CScanningTunner::get_TuningSpace\n");
112
113 *TuningSpace = m_TuningSpace;
114 return S_OK;
115}
116
120 ITuningSpace *TuningSpace)
121{
122 OutputDebugStringW(L"CScanningTunner::put_TuningSpace\n");
123 m_TuningSpace = TuningSpace;
124 return S_OK;
125}
126
130 IEnumTuningSpaces **ppEnum)
131{
132 OutputDebugStringW(L"CScanningTunner::EnumTuningSpaces : NotImplemented\n");
133 return E_NOTIMPL;
134}
135
139 ITuneRequest **TuneRequest)
140{
141 OutputDebugStringW(L"CScanningTunner::get_TuneRequest : NotImplemented\n");
142 return E_NOTIMPL;
143}
144
148 ITuneRequest *TuneRequest)
149{
150 IDVBTuneRequest * pDVBTRequest;
151 ILocator *pLocator;
152 IDVBTLocator *pDVBTLocator;
153 HRESULT hr;
154
155
156 OutputDebugStringW(L"CScanningTunner::put_TuneRequest\n");
157
158 // query for IDVBTuneRequest interface
159 hr = TuneRequest->QueryInterface(IID_IDVBTuneRequest, (void**)&pDVBTRequest);
160
161 // sanity check
162 assert(hr == NOERROR);
163
164 // get the IDVBTLocator
165 hr = pDVBTRequest->get_Locator((ILocator**)&pLocator);
166
167 // sanity check
168 assert(hr == NOERROR);
169 assert(pLocator);
170
171 hr = pLocator->QueryInterface(IID_ILocator, (void**)&pDVBTLocator);
172
173 // sanity check
174 assert(hr == NOERROR);
175
176
177 StartChanges();
179 StartChanges();
180
181 hr = performDVBTTune(pDVBTRequest, pDVBTLocator);
182
183
184 pDVBTLocator->Release();
185 pDVBTRequest->Release();
186
187 CheckChanges();
189 StartChanges();
190
191 return NOERROR;
192}
193
197 ITuneRequest *TuneRequest)
198{
199 OutputDebugStringW(L"CScanningTunner::Validate : NotImplemented\n");
200 return E_NOTIMPL;
201}
202
206 IComponentTypes **ComponentTypes)
207{
208 OutputDebugStringW(L"CScanningTunner::get_PreferredComponentTypes : NotImplemented\n");
209 return E_NOTIMPL;
210}
211
215 IComponentTypes *ComponentTypes)
216{
217 OutputDebugStringW(L"CScanningTunner::put_PreferredComponentTypes : NotImplemented\n");
218 return E_NOTIMPL;
219}
220
224 long *Strength)
225{
226 OutputDebugStringW(L"CScanningTunner::get_SignalStrength : NotImplemented\n");
227 return E_NOTIMPL;
228}
229
233 long Interval)
234{
235 OutputDebugStringW(L"CScanningTunner::TriggerSignalEvents : NotImplemented\n");
236 return E_NOTIMPL;
237}
238
239//-------------------------------------------------------------------
240//IScanningTuner
244{
245 OutputDebugStringW(L"CScanningTunner::SeekUp : NotImplemented\n");
246 return E_NOTIMPL;
247}
248
252{
253 OutputDebugStringW(L"CScanningTunner::SeekDown : NotImplemented\n");
254 return E_NOTIMPL;
255}
256
260 long MillisecondsPause)
261{
262 OutputDebugStringW(L"CScanningTunner::ScanUp : NotImplemented\n");
263 return E_NOTIMPL;
264}
265
269 long MillisecondsPause)
270{
271 OutputDebugStringW(L"CScanningTunner::ScanDown : NotImplemented\n");
272 return E_NOTIMPL;
273}
274
278{
279 OutputDebugStringW(L"CScanningTunner::AutoProgram : NotImplemented\n");
280 return E_NOTIMPL;
281}
282
283//-------------------------------------------------------------------
287 IDVBTuneRequest * pDVBTRequest,
288 IDVBTLocator *pDVBTLocator)
289{
290 HRESULT hr = S_OK;
291 ULONG Index;
292 IBDA_Topology *pTopo;
293 IUnknown *pNode;
294 IBDA_FrequencyFilter * pFrequency;
295 IBDA_LNBInfo * pLnbInfo;
296 IBDA_DigitalDemodulator *pDigitalDemo;
297 LONG BandWidth;
299 LONG SymbolRate;
300 FECMethod InnerFEC, OuterFEC;
301 BinaryConvolutionCodeRate InnerFECRate, OuterFECRate;
302 ModulationType Modulation;
303
304 pDVBTLocator->get_Bandwidth(&BandWidth);
305 pDVBTLocator->get_CarrierFrequency(&Frequency);
306 pDVBTLocator->get_InnerFEC(&InnerFEC);
307 pDVBTLocator->get_InnerFECRate(&InnerFECRate);
308 pDVBTLocator->get_Modulation(&Modulation);
309 pDVBTLocator->get_OuterFEC(&OuterFEC);
310 pDVBTLocator->get_OuterFECRate(&OuterFECRate);
311 pDVBTLocator->get_SymbolRate(&SymbolRate);
312
313
314 WCHAR Buffer[1000];
315 swprintf(Buffer, L"BandWidth %lu Frequency %lu Rate %lu InnerFEC %ld OuterFEC %ld InnerFECRate %ld OuterFECRate %ld Modulation %lu\n",
316 BandWidth, Frequency, SymbolRate, InnerFEC, OuterFEC, InnerFECRate, OuterFECRate, Modulation);
317
319
320
321
322 for(Index = 0; Index < m_DeviceFilters.size(); Index++)
323 {
324 // get device filter
325 IUnknown * pFilter = m_DeviceFilters[Index];
326
327 if (!pFilter)
328 continue;
329
330 hr = pFilter->QueryInterface(IID_IBDA_Topology, (void**)&pTopo);
331 // sanity check
332 assert(hr == NOERROR);
333
334 pNode = NULL;
335 hr = pTopo->GetControlNode(0, 1, 0, &pNode); //HACK
336
337 WCHAR Buffer[100];
338 swprintf(Buffer, L"CScanningTunner::performDVBTTune GetControlNode %lx\n", hr);
340
341 if (FAILED(hr))
342 continue;
343
344 // sanity check
345 assert(hr == NOERROR);
346 assert(pNode);
347
348 hr = pNode->QueryInterface(IID_IBDA_FrequencyFilter, (void**)&pFrequency);
349
350 swprintf(Buffer, L"CScanningTunner::performDVBTTune IID_IBDA_FrequencyFilter hr %lx\n", hr);
352
353 // sanity check
354 assert(hr == NOERROR);
355
356 hr = SetFrequency(pFrequency, 1000 /* FIXME */, Frequency, BDA_POLARISATION_NOT_DEFINED /* FIXME */, BDA_RANGE_NOT_SET /* FIXME */, BandWidth);
357
358 swprintf(Buffer, L"CScanningTunner::performDVBTTune SetFrequency hr %lx\n", hr);
360
361 //sanity check
362 assert(hr == NOERROR);
363
364 // release interface
365 pFrequency->Release();
366
367
368 hr = pNode->QueryInterface(IID_IBDA_LNBInfo, (void**)&pLnbInfo);
369
370 swprintf(Buffer, L"CScanningTunner::performDVBTTune IID_IBDA_LNBInfo hr %lx\n", hr);
372
373 // sanity check
374 assert(hr == NOERROR);
375
376 hr = SetLnbInfo(pLnbInfo, ULONG_MAX /* FIXME */, ULONG_MAX /* FIXME*/, ULONG_MAX /*FIXME*/);
377
378
379 swprintf(Buffer, L"CScanningTunner::performDVBTTune SetLnbInfo hr %lx\n", hr);
381
382 // sanity check
383 assert(hr == NOERROR);
384
385 // release interface
386 pLnbInfo->Release();
387
388 hr = pNode->QueryInterface(IID_IBDA_DigitalDemodulator, (void**)&pDigitalDemo);
389
390 swprintf(Buffer, L"CScanningTunner::performDVBTTune IID_IBDA_DigitalDemodulator hr %lx\n", hr);
392
393 // sanity check
394 assert(hr == NOERROR);
395
396 hr = SetDigitalDemodulator(pDigitalDemo, Modulation, InnerFEC, InnerFECRate, OuterFEC, OuterFECRate, SymbolRate);
397
398 swprintf(Buffer, L"CScanningTunner::performDVBTTune SetDigitalDemodulator hr %lx\n", hr);
400
401 // sanity check
402 assert(hr == NOERROR);
403
404 // release interface
405 pDigitalDemo->Release();
406
407 // release control node
408 pNode->Release();
409
410 // release IBDA_Topology;
411 pTopo->Release();
412
413 }
414 return hr;
415}
416
417
418
422{
423 ULONG Index;
424 HRESULT hResult = NOERROR;
425 IBDA_DeviceControl * pDeviceControl;
426
427 for(Index = 0; Index < m_DeviceFilters.size(); Index++)
428 {
429 // get filter
430 IUnknown * pFilter = m_DeviceFilters[Index];
431
432 if (!pFilter)
433 continue;
434
435 // query for IBDA_DeviceControl interface
436 hResult = pFilter->QueryInterface(IID_IBDA_DeviceControl, (void**)&pDeviceControl);
437
438 // sanity check
439 assert(hResult == NOERROR);
440
441 //start changes
442 hResult = pDeviceControl->CheckChanges();
443
444 // fix for unimplemented
445 if (hResult == E_NOTIMPL)
446 hResult = NOERROR;
447
448 // release interface
449 pDeviceControl->Release();
450
451 if (FAILED(hResult))
452 {
453 //shouldnt happen
454 break;
455 }
456 }
457 // done
458 return hResult;
459}
460
464{
465 ULONG Index;
466 HRESULT hResult = NOERROR;
467 IBDA_DeviceControl * pDeviceControl;
468
469 for(Index = 0; Index < m_DeviceFilters.size(); Index++)
470 {
471 // get filter
472 IUnknown * pFilter = m_DeviceFilters[Index];
473
474 if (!pFilter)
475 continue;
476
477 // query for IBDA_DeviceControl interface
478 HRESULT hr = pFilter->QueryInterface(IID_IBDA_DeviceControl, (void**)&pDeviceControl);
479
480 // sanity check
481 assert(hr == NOERROR);
482
483 //start changes
484 hr = pDeviceControl->CommitChanges();
485
486 // fix for unimplemented
487 if (hr == E_NOTIMPL)
488 hr = NOERROR;
489
490 if (FAILED(hr))
491 {
492 pDeviceControl->StartChanges();
493 pDeviceControl->CommitChanges();
494 hResult = E_UNEXPECTED;
495 }
496
497 // release interface
498 pDeviceControl->Release();
499
500 }
501
502 //done
503 return hResult;
504}
505
509{
510 ULONG Index;
511 IBDA_DeviceControl * pDeviceControl;
512
513 for(Index = 0; Index < m_DeviceFilters.size(); Index++)
514 {
515 // get filter
516 IUnknown * pFilter = m_DeviceFilters[Index];
517
518 if (!pFilter)
519 continue;
520
521 // query for IBDA_DeviceControl interface
522 HRESULT hr = pFilter->QueryInterface(IID_IBDA_DeviceControl, (void**)&pDeviceControl);
523
524 // sanity check
525 assert(hr == NOERROR);
526
527 //start changes
528 hr = pDeviceControl->StartChanges();
529
530 // release interface
531 pDeviceControl->Release();
532
533 // fix for unimplemented
534 if (hr == E_NOTIMPL)
535 hr = NOERROR;
536
537 if (FAILED(hr))
538 return hr;
539
540 }
541
542 // now commit the changes
543 for(Index = 0; Index < m_DeviceFilters.size(); Index++)
544 {
545 // get filter
546 IUnknown * pFilter = m_DeviceFilters[Index];
547
548 if (!pFilter)
549 continue;
550
551 // query for IBDA_DeviceControl interface
552 HRESULT hr = pFilter->QueryInterface(IID_IBDA_DeviceControl, (void**)&pDeviceControl);
553
554 // sanity check
555 assert(hr == NOERROR);
556
557 hr = pDeviceControl->CommitChanges();
558
559 // release interface
560 pDeviceControl->Release();
561 }
562
563 // done
564 return NOERROR;
565}
566
570 IBDA_LNBInfo * pLnbInfo,
571 ULONG ulLOFLow,
572 ULONG ulLOFHigh,
573 ULONG ulSwitchFrequency)
574{
575 HRESULT hr;
576
577 hr = pLnbInfo->put_LocalOscillatorFrequencyLowBand(ulLOFLow);
579 hr = NOERROR;
580
581 if (FAILED(hr))
582 return hr;
583
584 hr = pLnbInfo->put_LocalOscillatorFrequencyHighBand(ulLOFHigh);
586 hr = NOERROR;
587
588 if (FAILED(hr))
589 return hr;
590
591 hr = pLnbInfo->put_HighLowSwitchFrequency(ulSwitchFrequency);
593 hr = NOERROR;
594
595 return hr;
596}
597
600 IBDA_FrequencyFilter * pFrequency,
601 ULONG FrequencyMultiplier,
603 Polarisation Polarity,
604 ULONG Range,
605 ULONG Bandwidth)
606{
607 HRESULT hr;
608
609 hr = pFrequency->put_FrequencyMultiplier(FrequencyMultiplier);
610 if (FAILED(hr))
611 return hr;
612
613 hr = pFrequency->put_Frequency(Frequency);
614 if (FAILED(hr))
615 return hr;
616
617 hr = pFrequency->put_Polarity(Polarity);
619 hr = NOERROR;
620
621 if (FAILED(hr))
622 return hr;
623
624 hr = pFrequency->put_Range(Range);
626 hr = NOERROR;
627
628 if (FAILED(hr))
629 return hr;
630
631 hr = pFrequency->put_Bandwidth(Bandwidth);
632 return hr;
633}
634
638 IBDA_DigitalDemodulator * pDigitalDemo,
639 ModulationType ModType,
640 FECMethod InnerFEC,
641 BinaryConvolutionCodeRate InnerFECRate,
642 FECMethod OuterFEC,
643 BinaryConvolutionCodeRate OuterFECRate,
644 ULONG SymbolRate)
645{
646 HRESULT hr;
647
648 hr = pDigitalDemo->put_ModulationType(&ModType);
650 hr = NOERROR;
651
652 if (FAILED(hr))
653 return hr;
654
655 hr = pDigitalDemo->put_InnerFECMethod(&InnerFEC);
657 hr = NOERROR;
658 if (FAILED(hr))
659 return hr;
660
661 hr = pDigitalDemo->put_InnerFECRate(&InnerFECRate);
663 hr = NOERROR;
664 if (FAILED(hr))
665 return hr;
666
667 hr = pDigitalDemo->put_OuterFECMethod(&OuterFEC);
669 hr = NOERROR;
670 if (FAILED(hr))
671 return hr;
672
673 hr = pDigitalDemo->put_OuterFECRate(&OuterFECRate);
675 hr = NOERROR;
676 if (FAILED(hr))
677 return hr;
678
679 hr = pDigitalDemo->put_SymbolRate(&SymbolRate);
681 hr = NOERROR;
682 if (FAILED(hr))
683 return hr;
684
686 hr = pDigitalDemo->put_SpectralInversion(&Inversion);
688 hr = NOERROR;
689
690 return hr;
691}
692
693
695WINAPI
697 std::vector<IUnknown*> & DeviceFilter,
698 REFIID riid,
699 LPVOID * ppv)
700{
701 CScanningTunner * handler = new CScanningTunner(DeviceFilter);
702
703#ifdef MSDVBNP_TRACE
707 swprintf(Buffer, L"CScanningTunner_fnConstructor riid %s\n", lpstr);
709#endif
710
711 if (!handler)
712 return E_OUTOFMEMORY;
713
714 if (FAILED(handler->QueryInterface(riid, ppv)))
715 {
716 /* not supported */
717 delete handler;
718 return E_NOINTERFACE;
719 }
720
721 return NOERROR;
722}
#define InterlockedIncrement
Definition: armddk.h:53
#define InterlockedDecrement
Definition: armddk.h:52
#define STDMETHODIMP
Definition: basetyps.h:43
const GUID IID_IUnknown
#define STDMETHODCALLTYPE
Definition: bdasup.h:9
Polarisation
Definition: bdatypes.h:301
@ BDA_POLARISATION_NOT_DEFINED
Definition: bdatypes.h:303
BinaryConvolutionCodeRate
Definition: bdatypes.h:230
#define BDA_RANGE_NOT_SET
Definition: bdatypes.h:31
ModulationType
Definition: bdatypes.h:261
SpectralInversion
Definition: bdatypes.h:244
@ BDA_SPECTRAL_INVERSION_NOT_DEFINED
Definition: bdatypes.h:246
FECMethod
Definition: bdatypes.h:253
Definition: bufpool.h:45
HRESULT STDMETHODCALLTYPE CommitChanges()
HRESULT STDMETHODCALLTYPE performDVBTTune(IDVBTuneRequest *pDVBTRequest, IDVBTLocator *pDVBTLocator)
HRESULT STDMETHODCALLTYPE ScanDown(long MillisecondsPause)
HRESULT STDMETHODCALLTYPE ScanUp(long MillisecondsPause)
HRESULT STDMETHODCALLTYPE SetLnbInfo(IBDA_LNBInfo *pLnbInfo, ULONG ulLOFLow, ULONG ulLOFHigh, ULONG ulSwitchFrequency)
HRESULT STDMETHODCALLTYPE put_TuneRequest(ITuneRequest *TuneRequest)
HRESULT STDMETHODCALLTYPE StartChanges()
HRESULT STDMETHODCALLTYPE EnumTuningSpaces(IEnumTuningSpaces **ppEnum)
HRESULT STDMETHODCALLTYPE get_PreferredComponentTypes(IComponentTypes **ComponentTypes)
virtual ~CScanningTunner()
CScanningTunner(std::vector< IUnknown * > &DeviceFilters)
STDMETHODIMP_(ULONG) AddRef()
STDMETHODIMP_(ULONG) Release()
HRESULT STDMETHODCALLTYPE Validate(ITuneRequest *TuneRequest)
HRESULT STDMETHODCALLTYPE get_SignalStrength(long *Strength)
HRESULT STDMETHODCALLTYPE CheckChanges()
std::vector< IUnknown * > & m_DeviceFilters
HRESULT STDMETHODCALLTYPE put_TuningSpace(ITuningSpace *TuningSpace)
HRESULT STDMETHODCALLTYPE TriggerSignalEvents(long Interval)
HRESULT STDMETHODCALLTYPE put_PreferredComponentTypes(IComponentTypes *ComponentTypes)
HRESULT STDMETHODCALLTYPE AutoProgram()
STDMETHODIMP QueryInterface(REFIID InterfaceId, PVOID *Interface)
HRESULT STDMETHODCALLTYPE SeekUp()
HRESULT SetFrequency(IBDA_FrequencyFilter *pFrequency, ULONG FrequencyMultiplier, ULONG Frequency, Polarisation Polarity, ULONG Range, ULONG Bandwidth)
HRESULT STDMETHODCALLTYPE SetDigitalDemodulator(IBDA_DigitalDemodulator *pDigitalDemo, ModulationType ModType, FECMethod InnerFEC, BinaryConvolutionCodeRate InnerFECRate, FECMethod OuterFEC, BinaryConvolutionCodeRate OuterFECRate, ULONG SymbolRate)
HRESULT STDMETHODCALLTYPE get_TuningSpace(ITuningSpace **TuningSpace)
HRESULT STDMETHODCALLTYPE SeekDown()
ITuningSpace * m_TuningSpace
HRESULT STDMETHODCALLTYPE get_TuneRequest(ITuneRequest **TuneRequest)
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
#define E_NOTIMPL
Definition: ddrawi.h:99
const GUID IID_IBDA_DeviceControl
const GUID IID_IBDA_Topology
const GUID IID_IBDA_DigitalDemodulator
Definition: digitaldemo.cpp:13
#define NULL
Definition: types.h:112
#define MAX_PATH
Definition: compat.h:34
UINT(* handler)(MSIPACKAGE *)
Definition: action.c:7482
HRESULT WINAPI StringFromCLSID(REFCLSID id, LPOLESTR *idstr)
Definition: compobj.c:2412
#define swprintf
Definition: precomp.h:40
#define assert(x)
Definition: debug.h:53
#define MAKE_HRESULT(sev, fac, code)
Definition: dmerror.h:30
const GUID IID_IBDA_FrequencyFilter
VOID WINAPI CoTaskMemFree(LPVOID ptr)
Definition: ifs.c:442
void WINAPI SHIM_OBJ_NAME() OutputDebugStringW(LPCWSTR lpOutputString)
Definition: ignoredbgout.c:23
#define ULONG_MAX
Definition: limits.h:44
REFIID riid
Definition: atlbase.h:39
REFIID LPVOID * ppv
Definition: atlbase.h:39
HRESULT put_Frequency([in] ULONG ulFrequency)
HRESULT put_Polarity([in] Polarisation Polarity)
HRESULT put_FrequencyMultiplier([in] ULONG ulMultiplier)
HRESULT put_Bandwidth([in] ULONG ulBandwidth)
HRESULT put_Range([in] ULONG ulRange)
HRESULT put_HighLowSwitchFrequency([in] ULONG ulSwitchFrequency)
HRESULT get_Bandwidth([out] long *BandWidthVal)
HRESULT get_InnerFEC([out] FECMethod *FEC)
HRESULT get_Modulation([out] ModulationType *Modulation)
HRESULT get_InnerFECRate([out] BinaryConvolutionCodeRate *FEC)
HRESULT get_CarrierFrequency([out] long *Frequency)
HRESULT get_SymbolRate([out] long *Rate)
HRESULT get_OuterFECRate([out] BinaryConvolutionCodeRate *FEC)
HRESULT get_OuterFEC([out] FECMethod *FEC)
HRESULT get_Locator([out] ILocator **Locator)
ULONG AddRef()
HRESULT QueryInterface([in] REFIID riid, [out, iid_is(riid)] void **ppvObject)
ULONG Release()
nsrefcnt Release()
#define S_OK
Definition: intsafe.h:52
#define FAILED(hr)
Definition: intsafe.h:51
const GUID IID_IBDA_LNBInfo
Definition: lnbinfo.cpp:13
void * PVOID
Definition: retypes.h:9
unsigned int ULONG
Definition: retypes.h:1
static LPCSTR lpstr
Definition: font.c:51
static LPOLESTR
Definition: stg_prop.c:27
DWORD Interval
Definition: netstat.c:33
#define L(x)
Definition: ntvdm.h:50
long LONG
Definition: pedump.c:60
#define IsEqualGUID(rguid1, rguid2)
Definition: guiddef.h:147
#define REFIID
Definition: guiddef.h:118
HRESULT WINAPI CScanningTunner_fnConstructor(std::vector< IUnknown * > &DeviceFilter, REFIID riid, LPVOID *ppv)
@ Output
Definition: arc.h:85
HRESULT hr
Definition: shlfolder.c:183
Definition: range.c:39
static LARGE_INTEGER Frequency
Definition: clock.c:41
#define IN
Definition: typedefs.h:39
#define OUT
Definition: typedefs.h:40
_In_ WDFCOLLECTION _In_ ULONG Index
_Must_inspect_result_ _In_ WDFDEVICE _In_ LPCGUID _Out_ PINTERFACE Interface
Definition: wdffdo.h:465
#define WINAPI
Definition: msvc.h:6
#define E_NOINTERFACE
Definition: winerror.h:2364
#define ERROR_SET_NOT_FOUND
Definition: winerror.h:692
#define NOERROR
Definition: winerror.h:2354
#define SEVERITY_ERROR
Definition: winerror.h:65
#define E_UNEXPECTED
Definition: winerror.h:2456
#define FACILITY_WIN32
Definition: winerror.h:27
#define ERROR_NOT_FOUND
Definition: winerror.h:690
__wchar_t WCHAR
Definition: xmlstorage.h:180