Export (0) Print
Expand All

Custom Topology Loaders

When an application queues a partial topology on the Media Session, the Media Session uses a topology loader to resolve the topology. By default, the Media Session uses the standard Media Foundation implementation of the topology loader, but you can also provide a custom implementation. This gives you more control over the final topology. A custom topology loader must implement the IMFTopoLoader interface.

To set a custom topology loader on the Media Session, do the following:

  1. Create an empty attribute store by calling MFCreateAttributes.
  2. Set the MF_SESSION_TOPOLOADER attribute on the attribute store. The value of the attribute is the CLSID of your custom loader.
  3. Call MFCreateMediaSession to create the Media Session for unprotected content, or MFCreatePMPMediaSession to create the Media Session inside the protected media path (PMP).
Note  To use a custom topology loader inside the PMP, the topology loader must be a trusted component. For more information, see Protected Media Path.

The following code shows how to set a custom topology loader on the Media Session.


HRESULT CreateSession_CustomTopoLoader(REFCLSID clsid, IMFMediaSession **ppSession)
{
    *ppSession = NULL;

    IMFMediaSession *pSession = NULL;
    IMFAttributes *pConfig = NULL;

    // Create an attribute store to configure the media session.
    HRESULT hr = MFCreateAttributes(&pConfig, 1);

    // Set the CLSID of the custom topology loader.
    if (SUCCEEDED(hr))
    {
        hr = pConfig->SetGUID(MF_SESSION_TOPOLOADER, clsid);
    }

    // Create the media session.
    if (SUCCEEDED(hr))
    {
        hr = MFCreateMediaSession(pConfig, &pSession);
    }

    // Return the pointer to the caller.
    if (SUCCEEDED(hr))
    {
        *ppSession = pSession;
        (*ppSession)->AddRef();
    }

    SafeRelease(&pSession);
    SafeRelease(&pConfig);

    return hr;
}


It is not necessary to implement the entire topology-loading algorithm in your topology loader. As an alternative, you can wrap the standard Media Foundation topology loader. In your implementation of the IMFTopoLoader::Load method, modify the topology as needed and pass the modified topology to the standard topology loader. Then the standard topology loader completes the topology. You can also modify the completed topology before passing it back to the Media Session.

The following code shows the general outline of this approach. It does not show any details of the Load method, because these will depend on the particular requirements of your application.


class CTopoLoader : public IMFTopoLoader
{
public:

    static HRESULT CreateInstance(REFIID iid, void **ppv)
    {
        HRESULT hr = S_OK;

        CTopoLoader *pTopoLoader = new (std::nothrow) CTopoLoader(&hr);
        
        if (pTopoLoader == NULL)
        {
            return E_OUTOFMEMORY;
        }

        if (SUCCEEDED(hr))
        {
            hr = pTopoLoader->QueryInterface(iid, ppv);
        }

        SafeRelease(&pTopoLoader);
        return hr;
    }

    // IUnknown methods.
    STDMETHODIMP QueryInterface(REFIID riid, void** ppv)
    {
        static const QITAB qit[] = 
        {
            QITABENT(CTopoLoader, IMFTopoLoader),
            { 0 },
        };
        return QISearch(this, qit, riid, ppv);
    }

    STDMETHODIMP_(ULONG) AddRef()
    {
        return InterlockedIncrement(&m_cRef);
    }

    STDMETHODIMP_(ULONG) Release()
    {
        long cRef = InterlockedDecrement(&m_cRef);
        if (cRef == 0)
        {
            delete this;
        }
        return cRef;
    }

    // IMTopoLoader methods.
    STDMETHODIMP Load(
        IMFTopology *pInput, 
        IMFTopology **ppOutput, 
        IMFTopology *pCurrent
        )
    {
        HRESULT hr = S_OK;

        // TODO: Add custom topology-building code here.
        //       Modify pInput as needed.

        if (SUCCEEDED(hr))
        {
            hr = m_pTopoLoader->Load(pInput, ppOutput, pCurrent);
        }

        // TODO: Add custom topology-building code here.
        //       Modify ppOutput as needed.

        return hr;
    }

private:
    CTopoLoader(HRESULT *phr) : m_cRef(1), m_pTopoLoader(NULL)
    {
        *phr = MFCreateTopoLoader(&m_pTopoLoader);
    }

    virtual ~CTopoLoader()
    {
        SafeRelease(&m_pTopoLoader);
    }

private:
    long            m_cRef;          // Reference count.
    IMFTopoLoader   *m_pTopoLoader;  // Standard topoloader.
};


Related topics

MFCreateTopoLoader
Advanced Topology Building

 

 

Community Additions

ADD
Show:
© 2015 Microsoft