TV Tuner DirectShow FM

// TVTuner.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
/*
 stdafx.h includes:
 #include <tchar.h>
 #include <stdio.h>
 #include <dshow.h>
 #include <ks.h>
 #include <ksmedia.h>
 #include <mmdeviceapi.h>
 */

#define INSTANCEDATA_OF_PROPERTY_PTR(x) ((PKSPROPERTY((x))) + 1)
#define INSTANCEDATA_OF_PROPERTY_SIZE(x) (sizeof((x)) - sizeof(KSPROPERTY))

IAMTVTuner *pTvTuner;

HRESULT setFreq(IAMTVTuner * tvtuner, long freq)
{
    HRESULT hr;
    IKsPropertySet *pKSProp;
    DWORD dwSupported = 0;

    hr = tvtuner->QueryInterface(IID_IKsPropertySet, (void**)&pKSProp);
    if (FAILED(hr))
    {
        return hr;
    }

    KSPROPERTY_TUNER_MODE_CAPS_S ModeCaps;
    KSPROPERTY_TUNER_FREQUENCY_S Frequency;
    memset(&ModeCaps,0,sizeof(KSPROPERTY_TUNER_MODE_CAPS_S));
    memset(&Frequency,0,sizeof(KSPROPERTY_TUNER_FREQUENCY_S));
    ModeCaps.Mode = AMTUNER_MODE_FM_RADIO;

    // Check either the Property is supported or not by the Tuner drivers
    hr = pKSProp->QuerySupported(PROPSETID_TUNER,
          KSPROPERTY_TUNER_MODE_CAPS,&dwSupported);
    if(SUCCEEDED(hr) && dwSupported&KSPROPERTY_SUPPORT_GET)
    {
        DWORD cbBytes=0;
        hr = pKSProp->Get(PROPSETID_TUNER,KSPROPERTY_TUNER_MODE_CAPS,
            INSTANCEDATA_OF_PROPERTY_PTR(&ModeCaps),
            INSTANCEDATA_OF_PROPERTY_SIZE(ModeCaps),
            &ModeCaps,
            sizeof(ModeCaps),
            &cbBytes);
    }
    else
        return E_FAIL;

    Frequency.Frequency = freq;
    if(ModeCaps.Strategy==KS_TUNER_STRATEGY_DRIVER_TUNES)
        Frequency.TuningFlags=KS_TUNER_TUNING_FINE;
    else
        Frequency.TuningFlags=KS_TUNER_TUNING_EXACT;

    // Here the real magic starts
    if(freq>=ModeCaps.MinFrequency && freq<=ModeCaps.MaxFrequency)
    {
        hr = pKSProp->Set(PROPSETID_TUNER,
            KSPROPERTY_TUNER_FREQUENCY,
            INSTANCEDATA_OF_PROPERTY_PTR(&Frequency),
            INSTANCEDATA_OF_PROPERTY_SIZE(Frequency),
            &Frequency,
            sizeof(Frequency));
        if(FAILED(hr))
            return E_FAIL;
    }
    else
        return E_FAIL;

    return S_OK;

}

int _tmain(int argc, _TCHAR* argv[])
{
    IGraphBuilder *pGraphBuilder;
    ICaptureGraphBuilder2 *pCaptureGraphBuilder2;

    ICreateDevEnum *pCreateDevEnum = NULL;
    IEnumMoniker *pEnumMoniker = NULL;
    IMoniker *pMoniker = NULL;

    ULONG nFetched = 0;
    IBaseFilter *pDeviceFilter;

    // initialize COM
    CoInitialize(NULL);

    // create FilterGraph
    CoCreateInstance(CLSID_FilterGraph,
        NULL,
        CLSCTX_INPROC,
        IID_IGraphBuilder,
        (LPVOID *)&pGraphBuilder);

    // create CaptureGraphBuilder2
    CoCreateInstance(CLSID_CaptureGraphBuilder2, NULL, CLSCTX_INPROC,
        IID_ICaptureGraphBuilder2,
        (LPVOID *)&pCaptureGraphBuilder2);

    // set FilterGraph
    pCaptureGraphBuilder2->SetFiltergraph(pGraphBuilder);

    // create CreateDevEnum to list device
    CoCreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER,
        IID_ICreateDevEnum, (PVOID *)&pCreateDevEnum);

    // create EnumMoniker to list VideoInputDevice
    pCreateDevEnum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory,
        &pEnumMoniker, 0);
    if (pEnumMoniker == NULL) {
        // this will be shown if there is no capture device
        printf("no devices\n");
        /* TODO: Cleanup COM objects */
        return 0;
    }

    // reset EnumMoniker
    pEnumMoniker->Reset();

    // get the first Moniker
    pEnumMoniker->Next(1, &pMoniker, &nFetched);

    // bind Monkier to Filter
    pMoniker->BindToObject(0, 0, IID_IBaseFilter, (void**)&pDeviceFilter);

    // add device filter to FilterGraph
    pGraphBuilder->AddFilter(pDeviceFilter, L"Device Filter");

    // Monkier and Enumerator can be freed now
    pMoniker->Release();
    pEnumMoniker->Release();
    pCreateDevEnum->Release();


    // Get IAMTVTuner from Graph.
    // If there are more than 1 TV Tuner devices,
    // you will need to use FindInterface again.
    HRESULT hr;
    hr = pCaptureGraphBuilder2->FindInterface(&LOOK_UPSTREAM_ONLY,
        NULL, pDeviceFilter,
        IID_IAMTVTuner, (LPVOID *)&pTvTuner);
    if (hr != S_OK) {
        printf("could not get TV Tuner\n");
        /* TODO: Cleanup COM objects */
        return 1;
    }

    // Check whether the mode is supported.
    long lModes = 0;
    hr = pTvTuner->GetAvailableModes(&lModes);
    if (SUCCEEDED(hr) && (lModes & AMTUNER_MODE_FM_RADIO))
    {
        // Set the FM mode.
        hr = pTvTuner->put_Mode(AMTUNER_MODE_FM_RADIO);
    }
    else
    {
        printf("Tuner doesn't support the FM mode, or it can't list the modes it supports.\n");
        /* TODO: Cleanup COM objects */
        return E_NOTIMPL;
    }

    // Build Graph
    pCaptureGraphBuilder2->RenderStream(&PIN_CATEGORY_CAPTURE,
        NULL, pDeviceFilter, NULL, NULL);

    /* Hide the Render window */
    IVideoWindow *pVidWindow;
    pGraphBuilder->QueryInterface(IID_IVideoWindow, (void**)&pVidWindow);
    pVidWindow->put_AutoShow(OAFALSE);

    // get IMediaControl to Run Graph
    IMediaControl *pMediaControl;
    pGraphBuilder->QueryInterface(IID_IMediaControl,
        (LPVOID *)&pMediaControl);


    pTvTuner->put_Channel(107900000,
        AMTUNER_SUBCHAN_DEFAULT, AMTUNER_SUBCHAN_DEFAULT);
    /* I've also tried with setFreq(107900000); (which should set an EXACT frequency)
     * but it's the same thing! */

    // Start playing
    pMediaControl->Run();

    // Block execution using MessageBox
    // The video will be played until the OK is pressed
    MessageBox(NULL, "Press OK to end", "block", MB_OK);

    // stop playing
    pMediaControl->Stop();

    // release
    pTvTuner->Release();

    pMediaControl->Release();
    pCaptureGraphBuilder2->Release();
    pGraphBuilder->Release();

    // finalize COM
    CoUninitialize();

    return 0;
}