ReactOS Development > Doxygen

00001 /*
00002  * COPYRIGHT:       See COPYING in the top level directory
00003  * PROJECT:         ReactOS Network Provider for MPEG2 based networks
00004  * FILE:            dll/directx/msdvbnp/networkprovider.cpp
00005  * PURPOSE:         IScanningTunner interface
00006  *
00007  * PROGRAMMERS:     Johannes Anderwald (janderwald@reactos.org)
00008  */
00009 #include "precomp.h"
00010 
00011 class CScanningTunner : public IScanningTuner
00012 {
00013 public:
00014     STDMETHODIMP QueryInterface( REFIID InterfaceId, PVOID* Interface);
00015 
00016     STDMETHODIMP_(ULONG) AddRef()
00017     {
00018         InterlockedIncrement(&m_Ref);
00019         return m_Ref;
00020     }
00021     STDMETHODIMP_(ULONG) Release()
00022     {
00023         InterlockedDecrement(&m_Ref);
00024         if (!m_Ref)
00025         {
00026             delete this;
00027             return 0;
00028         }
00029         return m_Ref;
00030     }
00031 
00032     //ITuner methods
00033     HRESULT STDMETHODCALLTYPE get_TuningSpace(ITuningSpace **TuningSpace);
00034     HRESULT STDMETHODCALLTYPE put_TuningSpace(ITuningSpace *TuningSpace);
00035     HRESULT STDMETHODCALLTYPE EnumTuningSpaces(IEnumTuningSpaces **ppEnum);
00036     HRESULT STDMETHODCALLTYPE get_TuneRequest(ITuneRequest **TuneRequest);
00037     HRESULT STDMETHODCALLTYPE put_TuneRequest(ITuneRequest *TuneRequest);
00038     HRESULT STDMETHODCALLTYPE Validate(ITuneRequest *TuneRequest);
00039     HRESULT STDMETHODCALLTYPE get_PreferredComponentTypes(IComponentTypes **ComponentTypes);
00040     HRESULT STDMETHODCALLTYPE put_PreferredComponentTypes(IComponentTypes *ComponentTypes);
00041     HRESULT STDMETHODCALLTYPE get_SignalStrength(long *Strength);
00042     HRESULT STDMETHODCALLTYPE TriggerSignalEvents(long Interval);
00043 
00044     //IScanningTuner methods
00045     HRESULT STDMETHODCALLTYPE SeekUp();
00046     HRESULT STDMETHODCALLTYPE SeekDown();
00047     HRESULT STDMETHODCALLTYPE ScanUp(long MillisecondsPause);
00048     HRESULT STDMETHODCALLTYPE ScanDown(long MillisecondsPause);
00049     HRESULT STDMETHODCALLTYPE AutoProgram();
00050 
00051     CScanningTunner(std::vector<IUnknown*> & DeviceFilters) : m_Ref(0), m_TuningSpace(0), m_DeviceFilters(DeviceFilters){};
00052     virtual ~CScanningTunner() {};
00053     HRESULT STDMETHODCALLTYPE StartChanges();
00054     HRESULT STDMETHODCALLTYPE CommitChanges();
00055     HRESULT STDMETHODCALLTYPE CheckChanges();
00056     HRESULT STDMETHODCALLTYPE SetLnbInfo(IBDA_LNBInfo * pLnbInfo, ULONG ulLOFLow, ULONG ulLOFHigh, ULONG ulSwitchFrequency);
00057     HRESULT STDMETHODCALLTYPE SetDigitalDemodulator(IBDA_DigitalDemodulator * pDigitalDemo, ModulationType ModType, FECMethod InnerFEC, BinaryConvolutionCodeRate InnerFECRate, FECMethod OuterFEC, BinaryConvolutionCodeRate OuterFECRate, ULONG SymbolRate);
00058     HRESULT SetFrequency(IBDA_FrequencyFilter * pFrequency, ULONG FrequencyMultiplier, ULONG Frequency, Polarisation Polarity, ULONG Range, ULONG Bandwidth);
00059     HRESULT STDMETHODCALLTYPE performDVBTTune(IDVBTuneRequest * pDVBTRequest, IDVBTLocator *pDVBTLocator);
00060 protected:
00061     LONG m_Ref;
00062     ITuningSpace * m_TuningSpace;
00063     std::vector<IUnknown*> & m_DeviceFilters;
00064 };
00065 
00066 HRESULT
00067 STDMETHODCALLTYPE
00068 CScanningTunner::QueryInterface(
00069     IN  REFIID refiid,
00070     OUT PVOID* Output)
00071 {
00072     if (IsEqualGUID(refiid, IID_IUnknown))
00073     {
00074         *Output = PVOID(this);
00075         reinterpret_cast<IUnknown*>(*Output)->AddRef();
00076         return NOERROR;
00077     }
00078     if (IsEqualGUID(refiid, IID_ITuner))
00079     {
00080         *Output = (ITuner*)(this);
00081         reinterpret_cast<ITuner*>(*Output)->AddRef();
00082         return NOERROR;
00083     }
00084 
00085     if (IsEqualGUID(refiid, IID_IScanningTuner))
00086     {
00087         *Output = (IScanningTuner*)(this);
00088         reinterpret_cast<IScanningTuner*>(*Output)->AddRef();
00089         return NOERROR;
00090     }
00091 
00092     WCHAR Buffer[MAX_PATH];
00093     LPOLESTR lpstr;
00094     StringFromCLSID(refiid, &lpstr);
00095     swprintf(Buffer, L"CScanningTunner::QueryInterface: NoInterface for %s\n", lpstr);
00096     OutputDebugStringW(Buffer);
00097     CoTaskMemFree(lpstr);
00098 
00099 
00100     return E_NOINTERFACE;
00101 }
00102 
00103 //-------------------------------------------------------------------
00104 //ITuner
00105 //
00106 HRESULT
00107 STDMETHODCALLTYPE
00108 CScanningTunner::get_TuningSpace(
00109     ITuningSpace **TuningSpace)
00110 {
00111     OutputDebugStringW(L"CScanningTunner::get_TuningSpace\n");
00112 
00113     *TuningSpace = m_TuningSpace;
00114     return S_OK;
00115 }
00116 
00117 HRESULT
00118 STDMETHODCALLTYPE
00119 CScanningTunner::put_TuningSpace(
00120     ITuningSpace *TuningSpace)
00121 {
00122     OutputDebugStringW(L"CScanningTunner::put_TuningSpace\n");
00123     m_TuningSpace = TuningSpace;
00124     return S_OK;
00125 }
00126 
00127 HRESULT
00128 STDMETHODCALLTYPE
00129 CScanningTunner::EnumTuningSpaces(
00130     IEnumTuningSpaces **ppEnum)
00131 {
00132     OutputDebugStringW(L"CScanningTunner::EnumTuningSpaces : NotImplemented\n");
00133     return E_NOTIMPL;
00134 }
00135 
00136 HRESULT
00137 STDMETHODCALLTYPE
00138 CScanningTunner::get_TuneRequest(
00139     ITuneRequest **TuneRequest)
00140 {
00141     OutputDebugStringW(L"CScanningTunner::get_TuneRequest : NotImplemented\n");
00142     return E_NOTIMPL;
00143 }
00144 
00145 HRESULT
00146 STDMETHODCALLTYPE
00147 CScanningTunner::put_TuneRequest(
00148     ITuneRequest *TuneRequest)
00149 {
00150     IDVBTuneRequest * pDVBTRequest;
00151     ILocator *pLocator;
00152     IDVBTLocator *pDVBTLocator;
00153     HRESULT hr;
00154     
00155 
00156     OutputDebugStringW(L"CScanningTunner::put_TuneRequest\n");
00157 
00158     // query for IDVBTuneRequest interface
00159     hr = TuneRequest->QueryInterface(IID_IDVBTuneRequest, (void**)&pDVBTRequest);
00160 
00161     // sanity check
00162     assert(hr == NOERROR);
00163 
00164     // get the IDVBTLocator
00165     hr = pDVBTRequest->get_Locator((ILocator**)&pLocator);
00166 
00167     // sanity check
00168     assert(hr == NOERROR);
00169     assert(pLocator);
00170 
00171     hr = pLocator->QueryInterface(IID_ILocator, (void**)&pDVBTLocator);
00172 
00173     // sanity check
00174     assert(hr == NOERROR);
00175 
00176 
00177     StartChanges();
00178     CommitChanges();
00179     StartChanges();
00180 
00181     hr = performDVBTTune(pDVBTRequest, pDVBTLocator);
00182 
00183 
00184     pDVBTLocator->Release();
00185     pDVBTRequest->Release();
00186 
00187     CheckChanges();
00188     CommitChanges();
00189     StartChanges();
00190 
00191     return NOERROR;
00192 }
00193 
00194 HRESULT
00195 STDMETHODCALLTYPE
00196 CScanningTunner::Validate(
00197     ITuneRequest *TuneRequest)
00198 {
00199     OutputDebugStringW(L"CScanningTunner::Validate : NotImplemented\n");
00200     return E_NOTIMPL;
00201 }
00202 
00203 HRESULT
00204 STDMETHODCALLTYPE
00205 CScanningTunner::get_PreferredComponentTypes(
00206     IComponentTypes **ComponentTypes)
00207 {
00208     OutputDebugStringW(L"CScanningTunner::get_PreferredComponentTypes : NotImplemented\n");
00209     return E_NOTIMPL;
00210 }
00211 
00212 HRESULT
00213 STDMETHODCALLTYPE
00214 CScanningTunner::put_PreferredComponentTypes(
00215     IComponentTypes *ComponentTypes)
00216 {
00217     OutputDebugStringW(L"CScanningTunner::put_PreferredComponentTypes : NotImplemented\n");
00218     return E_NOTIMPL;
00219 }
00220 
00221 HRESULT
00222 STDMETHODCALLTYPE
00223 CScanningTunner::get_SignalStrength(
00224     long *Strength)
00225 {
00226     OutputDebugStringW(L"CScanningTunner::get_SignalStrength : NotImplemented\n");
00227     return E_NOTIMPL;
00228 }
00229 
00230 HRESULT
00231 STDMETHODCALLTYPE
00232 CScanningTunner::TriggerSignalEvents(
00233     long Interval)
00234 {
00235     OutputDebugStringW(L"CScanningTunner::TriggerSignalEvents : NotImplemented\n");
00236     return E_NOTIMPL;
00237 }
00238 
00239 //-------------------------------------------------------------------
00240 //IScanningTuner
00241 HRESULT
00242 STDMETHODCALLTYPE
00243 CScanningTunner::SeekUp()
00244 {
00245     OutputDebugStringW(L"CScanningTunner::SeekUp : NotImplemented\n");
00246     return E_NOTIMPL;
00247 }
00248 
00249 HRESULT
00250 STDMETHODCALLTYPE
00251 CScanningTunner::SeekDown()
00252 {
00253     OutputDebugStringW(L"CScanningTunner::SeekDown : NotImplemented\n");
00254     return E_NOTIMPL;
00255 }
00256 
00257 HRESULT
00258 STDMETHODCALLTYPE
00259 CScanningTunner::ScanUp(
00260     long MillisecondsPause)
00261 {
00262     OutputDebugStringW(L"CScanningTunner::ScanUp : NotImplemented\n");
00263     return E_NOTIMPL;
00264 }
00265 
00266 HRESULT
00267 STDMETHODCALLTYPE
00268 CScanningTunner::ScanDown(
00269     long MillisecondsPause)
00270 {
00271     OutputDebugStringW(L"CScanningTunner::ScanDown : NotImplemented\n");
00272     return E_NOTIMPL;
00273 }
00274 
00275 HRESULT
00276 STDMETHODCALLTYPE
00277 CScanningTunner::AutoProgram()
00278 {
00279     OutputDebugStringW(L"CScanningTunner::AutoProgram : NotImplemented\n");
00280     return E_NOTIMPL;
00281 }
00282 
00283 //-------------------------------------------------------------------
00284 HRESULT
00285 STDMETHODCALLTYPE
00286 CScanningTunner::performDVBTTune(
00287     IDVBTuneRequest * pDVBTRequest,
00288     IDVBTLocator *pDVBTLocator)
00289 {
00290     HRESULT hr = S_OK;
00291     ULONG Index;
00292     IBDA_Topology *pTopo;
00293     IUnknown *pNode;
00294     IBDA_FrequencyFilter * pFrequency;
00295     IBDA_LNBInfo * pLnbInfo;
00296     IBDA_DigitalDemodulator *pDigitalDemo;
00297     LONG BandWidth;
00298     LONG Frequency;
00299     LONG SymbolRate;
00300     FECMethod InnerFEC, OuterFEC;
00301     BinaryConvolutionCodeRate InnerFECRate, OuterFECRate;
00302     ModulationType Modulation;
00303 
00304     pDVBTLocator->get_Bandwidth(&BandWidth);
00305     pDVBTLocator->get_CarrierFrequency(&Frequency);
00306     pDVBTLocator->get_InnerFEC(&InnerFEC);
00307     pDVBTLocator->get_InnerFECRate(&InnerFECRate);
00308     pDVBTLocator->get_Modulation(&Modulation);
00309     pDVBTLocator->get_OuterFEC(&OuterFEC);
00310     pDVBTLocator->get_OuterFECRate(&OuterFECRate);
00311     pDVBTLocator->get_SymbolRate(&SymbolRate);
00312 
00313 
00314     WCHAR Buffer[1000];
00315     swprintf(Buffer, L"BandWidth %lu Frequency %lu Rate %lu InnerFEC %ld OuterFEC %ld InnerFECRate %ld OuterFECRate %ld Modulation %lu\n",
00316              BandWidth, Frequency, SymbolRate, InnerFEC, OuterFEC, InnerFECRate, OuterFECRate, Modulation);
00317 
00318     OutputDebugStringW(Buffer);
00319 
00320 
00321 
00322     for(Index = 0; Index < m_DeviceFilters.size(); Index++)
00323     {
00324         // get device filter
00325         IUnknown * pFilter = m_DeviceFilters[Index];
00326 
00327         if (!pFilter)
00328             continue;
00329 
00330         hr = pFilter->QueryInterface(IID_IBDA_Topology, (void**)&pTopo);
00331         // sanity check
00332         assert(hr == NOERROR);
00333 
00334         pNode = NULL;
00335         hr = pTopo->GetControlNode(0, 1, 0, &pNode); //HACK
00336 
00337         WCHAR Buffer[100];
00338         swprintf(Buffer, L"CScanningTunner::performDVBTTune GetControlNode %lx\n", hr);
00339         OutputDebugStringW(Buffer);
00340 
00341         if (FAILED(hr))
00342             continue;
00343 
00344         // sanity check
00345         assert(hr == NOERROR);
00346         assert(pNode);
00347 
00348         hr = pNode->QueryInterface(IID_IBDA_FrequencyFilter, (void**)&pFrequency);
00349 
00350         swprintf(Buffer, L"CScanningTunner::performDVBTTune IID_IBDA_FrequencyFilter hr %lx\n", hr);
00351         OutputDebugStringW(Buffer);
00352 
00353         // sanity check
00354         assert(hr == NOERROR);
00355 
00356         hr = SetFrequency(pFrequency, 1000 /* FIXME */, Frequency, BDA_POLARISATION_NOT_DEFINED /* FIXME */, BDA_RANGE_NOT_SET /* FIXME */, BandWidth);
00357 
00358         swprintf(Buffer, L"CScanningTunner::performDVBTTune SetFrequency hr %lx\n", hr);
00359         OutputDebugStringW(Buffer);
00360 
00361         //sanity check
00362         assert(hr == NOERROR);
00363 
00364         // release interface
00365         pFrequency->Release();
00366 
00367 
00368         hr = pNode->QueryInterface(IID_IBDA_LNBInfo, (void**)&pLnbInfo);
00369 
00370         swprintf(Buffer, L"CScanningTunner::performDVBTTune IID_IBDA_LNBInfo hr %lx\n", hr);
00371         OutputDebugStringW(Buffer);
00372 
00373         // sanity check
00374         assert(hr == NOERROR);
00375 
00376         hr = SetLnbInfo(pLnbInfo, ULONG_MAX /* FIXME */, ULONG_MAX /* FIXME*/, ULONG_MAX /*FIXME*/);
00377 
00378 
00379         swprintf(Buffer, L"CScanningTunner::performDVBTTune SetLnbInfo hr %lx\n", hr);
00380         OutputDebugStringW(Buffer);
00381 
00382         // sanity check
00383         assert(hr == NOERROR);
00384 
00385         // release interface
00386         pLnbInfo->Release();
00387 
00388         hr = pNode->QueryInterface(IID_IBDA_DigitalDemodulator, (void**)&pDigitalDemo);
00389 
00390         swprintf(Buffer, L"CScanningTunner::performDVBTTune IID_IBDA_DigitalDemodulator hr %lx\n", hr);
00391         OutputDebugStringW(Buffer);
00392 
00393         // sanity check
00394         assert(hr == NOERROR);
00395 
00396         hr = SetDigitalDemodulator(pDigitalDemo, Modulation, InnerFEC, InnerFECRate, OuterFEC, OuterFECRate, SymbolRate);
00397 
00398         swprintf(Buffer, L"CScanningTunner::performDVBTTune SetDigitalDemodulator hr %lx\n", hr);
00399         OutputDebugStringW(Buffer);
00400 
00401         // sanity check
00402         assert(hr == NOERROR);
00403 
00404         // release interface
00405         pDigitalDemo->Release();
00406 
00407         // release control node
00408         pNode->Release();
00409 
00410         // release IBDA_Topology;
00411         pTopo->Release();
00412 
00413     }
00414     return hr;
00415 }
00416 
00417 
00418 
00419 HRESULT
00420 STDMETHODCALLTYPE
00421 CScanningTunner::CheckChanges()
00422 {
00423     ULONG Index;
00424     HRESULT hResult = NOERROR;
00425     IBDA_DeviceControl * pDeviceControl;
00426 
00427     for(Index = 0; Index < m_DeviceFilters.size(); Index++)
00428     {
00429         // get filter
00430         IUnknown * pFilter = m_DeviceFilters[Index];
00431 
00432         if (!pFilter)
00433             continue;
00434 
00435         // query for IBDA_DeviceControl interface
00436         hResult = pFilter->QueryInterface(IID_IBDA_DeviceControl, (void**)&pDeviceControl);
00437 
00438         // sanity check
00439         assert(hResult == NOERROR);
00440 
00441         //start changes
00442         hResult = pDeviceControl->CheckChanges();
00443 
00444         // fix for unimplemented
00445         if (hResult == E_NOTIMPL)
00446             hResult = NOERROR;
00447 
00448         // release interface
00449         pDeviceControl->Release();
00450 
00451         if (FAILED(hResult))
00452         {
00453             //shouldnt happen
00454             break;
00455         }
00456     }
00457     // done
00458     return hResult;
00459 }
00460 
00461 HRESULT
00462 STDMETHODCALLTYPE
00463 CScanningTunner::CommitChanges()
00464 {
00465     ULONG Index;
00466     HRESULT hResult = NOERROR;
00467     IBDA_DeviceControl * pDeviceControl;
00468 
00469     for(Index = 0; Index < m_DeviceFilters.size(); Index++)
00470     {
00471         // get filter
00472         IUnknown * pFilter = m_DeviceFilters[Index];
00473 
00474         if (!pFilter)
00475             continue;
00476 
00477         // query for IBDA_DeviceControl interface
00478         HRESULT hr = pFilter->QueryInterface(IID_IBDA_DeviceControl, (void**)&pDeviceControl);
00479 
00480         // sanity check
00481         assert(hr == NOERROR);
00482 
00483         //start changes
00484         hr = pDeviceControl->CommitChanges();
00485 
00486         // fix for unimplemented
00487         if (hr == E_NOTIMPL)
00488             hr = NOERROR;
00489 
00490         if (FAILED(hr))
00491         {
00492             pDeviceControl->StartChanges();
00493             pDeviceControl->CommitChanges();
00494             hResult = E_UNEXPECTED;
00495         }
00496 
00497         // release interface
00498         pDeviceControl->Release();
00499 
00500     }
00501 
00502     //done
00503     return hResult;
00504 }
00505 
00506 HRESULT
00507 STDMETHODCALLTYPE
00508 CScanningTunner::StartChanges()
00509 {
00510     ULONG Index;
00511     IBDA_DeviceControl * pDeviceControl;
00512 
00513     for(Index = 0; Index < m_DeviceFilters.size(); Index++)
00514     {
00515         // get filter
00516         IUnknown * pFilter = m_DeviceFilters[Index];
00517 
00518         if (!pFilter)
00519             continue;
00520 
00521         // query for IBDA_DeviceControl interface
00522         HRESULT hr = pFilter->QueryInterface(IID_IBDA_DeviceControl, (void**)&pDeviceControl);
00523 
00524         // sanity check
00525         assert(hr == NOERROR);
00526 
00527         //start changes
00528         hr = pDeviceControl->StartChanges();
00529 
00530         // release interface
00531         pDeviceControl->Release();
00532 
00533         // fix for unimplemented
00534         if (hr == E_NOTIMPL)
00535             hr = NOERROR;
00536 
00537         if (FAILED(hr))
00538             return hr;
00539 
00540     }
00541 
00542     // now commit the changes
00543     for(Index = 0; Index < m_DeviceFilters.size(); Index++)
00544     {
00545         // get filter
00546         IUnknown * pFilter = m_DeviceFilters[Index];
00547 
00548         if (!pFilter)
00549             continue;
00550 
00551         // query for IBDA_DeviceControl interface
00552         HRESULT hr = pFilter->QueryInterface(IID_IBDA_DeviceControl, (void**)&pDeviceControl);
00553 
00554         // sanity check
00555         assert(hr == NOERROR);
00556 
00557         hr = pDeviceControl->CommitChanges();
00558 
00559         // release interface
00560         pDeviceControl->Release();
00561     }
00562 
00563     // done
00564     return NOERROR;
00565 }
00566 
00567 HRESULT
00568 STDMETHODCALLTYPE
00569 CScanningTunner::SetLnbInfo(
00570     IBDA_LNBInfo * pLnbInfo,
00571     ULONG ulLOFLow,
00572     ULONG ulLOFHigh,
00573     ULONG ulSwitchFrequency)
00574 {
00575     HRESULT hr;
00576 
00577     hr = pLnbInfo->put_LocalOscilatorFrequencyLowBand(ulLOFLow);
00578     if (hr == MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_NOT_FOUND) || hr == MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_SET_NOT_FOUND))
00579         hr = NOERROR;
00580 
00581     if (FAILED(hr))
00582         return hr;
00583 
00584     hr = pLnbInfo->put_LocalOscilatorFrequencyHighBand(ulLOFHigh);
00585     if (hr == MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_NOT_FOUND) || hr == MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_SET_NOT_FOUND))
00586         hr = NOERROR;
00587 
00588     if (FAILED(hr))
00589         return hr;
00590 
00591     hr = pLnbInfo->put_HighLowSwitchFrequency(ulSwitchFrequency);
00592     if (hr == MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_NOT_FOUND) || hr == MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_SET_NOT_FOUND))
00593         hr = NOERROR;
00594 
00595     return hr;
00596 }
00597 
00598 HRESULT
00599 CScanningTunner::SetFrequency(
00600     IBDA_FrequencyFilter * pFrequency,
00601     ULONG FrequencyMultiplier,
00602     ULONG Frequency,
00603     Polarisation Polarity,
00604     ULONG Range,
00605     ULONG Bandwidth)
00606 {
00607     HRESULT hr;
00608 
00609     hr = pFrequency->put_FrequencyMultiplier(FrequencyMultiplier);
00610     if (FAILED(hr))
00611         return hr;
00612 
00613     hr = pFrequency->put_Frequency(Frequency);
00614     if (FAILED(hr))
00615         return hr;
00616 
00617     hr = pFrequency->put_Polarity(Polarity);
00618     if (hr == MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_NOT_FOUND))
00619         hr = NOERROR;
00620 
00621     if (FAILED(hr))
00622         return hr;
00623 
00624     hr = pFrequency->put_Range(Range);
00625     if (hr == MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_NOT_FOUND))
00626         hr = NOERROR;
00627 
00628     if (FAILED(hr))
00629         return hr;
00630 
00631     hr = pFrequency->put_Bandwidth(Bandwidth);
00632     return hr;
00633 }
00634 
00635 HRESULT
00636 STDMETHODCALLTYPE
00637 CScanningTunner::SetDigitalDemodulator(
00638     IBDA_DigitalDemodulator * pDigitalDemo,
00639     ModulationType ModType,
00640     FECMethod InnerFEC,
00641     BinaryConvolutionCodeRate InnerFECRate,
00642     FECMethod OuterFEC,
00643     BinaryConvolutionCodeRate OuterFECRate,
00644     ULONG SymbolRate)
00645 {
00646     HRESULT hr;
00647 
00648     hr = pDigitalDemo->put_ModulationType(&ModType);
00649     if (hr == MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_NOT_FOUND) || hr == MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_SET_NOT_FOUND))
00650         hr = NOERROR;
00651 
00652     if (FAILED(hr))
00653         return hr;
00654 
00655     hr = pDigitalDemo->put_InnerFECMethod(&InnerFEC);
00656     if (hr == MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_NOT_FOUND) || hr == MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_SET_NOT_FOUND))
00657         hr = NOERROR;
00658     if (FAILED(hr))
00659         return hr;
00660 
00661     hr = pDigitalDemo->put_InnerFECRate(&InnerFECRate);
00662     if (hr == MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_NOT_FOUND) || hr == MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_SET_NOT_FOUND))
00663         hr = NOERROR;
00664     if (FAILED(hr))
00665         return hr;
00666 
00667     hr = pDigitalDemo->put_OuterFECMethod(&OuterFEC);
00668     if (hr == MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_NOT_FOUND) || hr == MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_SET_NOT_FOUND))
00669         hr = NOERROR;
00670     if (FAILED(hr))
00671         return hr;
00672 
00673     hr = pDigitalDemo->put_OuterFECRate(&OuterFECRate);
00674     if (hr == MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_NOT_FOUND) || hr == MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_SET_NOT_FOUND))
00675         hr = NOERROR;
00676     if (FAILED(hr))
00677         return hr;
00678 
00679     hr = pDigitalDemo->put_SymbolRate(&SymbolRate);
00680     if (hr == MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_NOT_FOUND) || hr == MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_SET_NOT_FOUND))
00681         hr = NOERROR;
00682     if (FAILED(hr))
00683         return hr;
00684 
00685     SpectralInversion Inversion = BDA_SPECTRAL_INVERSION_NOT_DEFINED;
00686     hr = pDigitalDemo->put_SpectralInversion(&Inversion);
00687     if (hr == MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_NOT_FOUND) || hr == MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_SET_NOT_FOUND))
00688         hr = NOERROR;
00689 
00690     return hr;
00691 }
00692 
00693 
00694 HRESULT
00695 WINAPI
00696 CScanningTunner_fnConstructor(
00697     std::vector<IUnknown*> & DeviceFilter,
00698     REFIID riid,
00699     LPVOID * ppv)
00700 {
00701     CScanningTunner * handler = new CScanningTunner(DeviceFilter);
00702 
00703 #ifdef MSDVBNP_TRACE
00704     WCHAR Buffer[MAX_PATH];
00705     LPOLESTR lpstr;
00706     StringFromCLSID(riid, &lpstr);
00707     swprintf(Buffer, L"CScanningTunner_fnConstructor riid %s\n", lpstr);
00708     OutputDebugStringW(Buffer);
00709 #endif
00710 
00711     if (!handler)
00712         return E_OUTOFMEMORY;
00713 
00714     if (FAILED(handler->QueryInterface(riid, ppv)))
00715     {
00716         /* not supported */
00717         delete handler;
00718         return E_NOINTERFACE;
00719     }
00720 
00721     return NOERROR;
00722 }
Generated on Sun May 27 2012 04:21:53 for ReactOS by
1.7.6.1