DirectShow вывод видео в текстуру для отображения его в окне игры - C/C++ - Ответ 12985282

class CAllocator : public IVMRSurfaceAllocator9, IVMRImagePresenter9 {
private:
    IDirect3DSurface9* surface;
    IVMRSurfaceAllocatorNotify9 *pAllocNotify;
    ULONG RefCount;
    IDirect3DTexture9* ptex;
 
public:
    IDirect3DTexture9* tex;
 
    CAllocator() {
        RefCount = 1;
        surface = nullptr;
        pAllocNotify = nullptr;
        tex = nullptr;
        ptex = nullptr;
    }
 
    ULONG _stdcall AddRef() {
        return ++RefCount;
    }
 
    ULONG _stdcall Release() {
        if (--RefCount == 0) {
            TerminateDevice(0);
            if (pAllocNotify) {
                pAllocNotify->Release();
                pAllocNotify = nullptr;
            }
        }
        return RefCount;
    }
 
    HRESULT _stdcall QueryInterface(const IID &riid, void** ppvObject) {
        HRESULT hr = E_NOINTERFACE;
        if (ppvObject == nullptr) {
            hr = E_POINTER;
        } else if (riid == IID_IVMRSurfaceAllocator9) {
            *ppvObject = static_cast<IVMRSurfaceAllocator9*>(this);
            AddRef();
            hr = S_OK;
        } else if (riid == IID_IVMRImagePresenter9) {
            *ppvObject = static_cast<IVMRImagePresenter9*>(this);
            AddRef();
            hr = S_OK;
        } else if (riid == IID_IUnknown) {
            *ppvObject = static_cast<IUnknown*>(static_cast<IVMRSurfaceAllocator9*>(this));
            AddRef();
            hr = S_OK;
        }
        return hr;
    }
 
    HRESULT _stdcall InitializeDevice(DWORD_PTR dwUserID, VMR9AllocationInfo *lpAllocInfo, DWORD *lpNumBuffers) {
        dlog(" InitializeDevice.", DL_INIT);
        
        HRESULT hr;
        //Set the device
        //hr = pAllocNotify->SetD3DDevice(d3d9Device, d3d9->GetAdapterMonitor(0));
        //if(hr != S_OK) return hr;
 
        lpAllocInfo->dwFlags |= VMR9AllocFlag_TextureSurface;
        lpAllocInfo->Pool = D3DPOOL_DEFAULT; //D3DPOOL_SYSTEMMEM;
 
        // Ask the VMR-9 to allocate the surfaces for us.
        hr = pAllocNotify->AllocateSurfaceHelper(lpAllocInfo, lpNumBuffers, &surface);
        if (FAILED(hr)) return hr;
 
        hr = surface->GetContainer(IID_IDirect3DTexture9, (void**)&ptex);
        if (FAILED(hr)) {
            TerminateDevice(0);
            return hr;
        }
 
        if (d3d9Device->CreateTexture(lpAllocInfo->dwWidth, lpAllocInfo->dwHeight, 1, 0, lpAllocInfo->Format, D3DPOOL_DEFAULT, &tex, nullptr) != D3D_OK) {
            dlog(" Fail CreateTexture.", DL_INIT);
        }
        return S_OK;
    }
 
    HRESULT _stdcall TerminateDevice(DWORD_PTR dwID) {
        SAFERELEASE(ptex);
        SAFERELEASE(surface);
        SAFERELEASE(tex);
        return S_OK;
    }
 
    HRESULT _stdcall GetSurface(DWORD_PTR dwUserID, DWORD SurfaceIndex, DWORD SurfaceFlags, IDirect3DSurface9 **lplpSurface) {
        if (SurfaceIndex != 0) return E_FAIL;
        *lplpSurface = surface;
        surface->AddRef();
        return S_OK;
    }
 
    HRESULT _stdcall AdviseNotify(IVMRSurfaceAllocatorNotify9 *lpIVMRSurfAllocNotify) {
        if (lpIVMRSurfAllocNotify) {
            dlog(" AdviseNotify.", DL_INIT);
            pAllocNotify = lpIVMRSurfAllocNotify;
            pAllocNotify->AddRef();
 
            HMONITOR hMonitor = d3d9->GetAdapterMonitor(D3DADAPTER_DEFAULT);
            return pAllocNotify->SetD3DDevice(d3d9Device, hMonitor);
        } else {
            return E_FAIL;
        }
    }
 
    HRESULT _stdcall StartPresenting(DWORD_PTR dwUserID) {
        return S_OK;
    }
 
    HRESULT _stdcall StopPresenting(DWORD_PTR dwUserID) {
        return S_OK;
    }
 
    HRESULT _stdcall PresentImage(DWORD_PTR dwUserID, VMR9PresentationInfo *lpPresInfo) {
        d3d9Device->UpdateTexture(ptex, tex);
        return S_OK;
    }
};

struct sDSTexture {
    IGraphBuilder *pGraph;
    ICaptureGraphBuilder2 *pBuild;
    IBaseFilter *pVmr;
    IVMRFilterConfig9 *pConfig;
    IVMRSurfaceAllocatorNotify9 *pAlloc;
    IMediaControl *pControl;
    CAllocator *pMyAlloc;
    IMediaSeeking *pSeek;
};
 
DWORD CreateDSGraph(wchar_t* path, IDirect3DTexture9** tex, sDSTexture* result) {
    memset(result, 0, sizeof(sDSTexture));
 
    // Create the Capture Graph Builder.
    HRESULT hr = CoCreateInstance(CLSID_CaptureGraphBuilder2, 0, CLSCTX_INPROC_SERVER, IID_ICaptureGraphBuilder2, (void**)&result->pBuild);
    if (hr != S_OK) return FreeMovie(result);
 
    // Create the Filter Graph Manager.
    hr = CoCreateInstance(CLSID_FilterGraph, 0, CLSCTX_INPROC_SERVER, IID_IGraphBuilder, (void**)&result->pGraph);
    if (hr != S_OK) return FreeMovie(result);
 
    // Initialize the Capture Graph Builder.
    hr = result->pBuild->SetFiltergraph(result->pGraph);
    if (hr != S_OK) return FreeMovie(result);
    
    hr = CoCreateInstance(CLSID_VideoMixingRenderer9, 0, CLSCTX_INPROC_SERVER, IID_IBaseFilter, (void**)&result->pVmr);
    if (hr != S_OK) return FreeMovie(result);
 
    result->pMyAlloc = new CAllocator();
    
    /* 
        Supplying a Custom Allocator-Presenter for VMR-9 
        https://docs.microsoft.com/ru-ru/windows/desktop/DirectShow/supplying-a-custom-allocator-presenter-for-vmr-9
    */
    hr = result->pVmr->QueryInterface(IID_IVMRFilterConfig9, (void**)&result->pConfig);
 
    hr = result->pConfig->SetRenderingMode(VMR9Mode_Renderless);
 
    hr = result->pVmr->QueryInterface(IID_IVMRSurfaceAllocatorNotify9, (void**)&result->pAlloc);
 
    hr = result->pAlloc->AdviseSurfaceAllocator(0, (IVMRSurfaceAllocator9*)result->pMyAlloc);
 
    hr = result->pMyAlloc->AdviseNotify(result->pAlloc);
 
    /****************************************************/
 
    hr = result->pGraph->AddFilter(result->pVmr, L"VMR9");
    if (hr != S_OK) return FreeMovie(result);
 
    hr = result->pGraph->QueryInterface(IID_IMediaControl, (void**)&result->pControl);
    hr |= result->pGraph->QueryInterface(IID_IMediaSeeking, (void**)&result->pSeek);
    if (hr != S_OK) return FreeMovie(result);
    
    dlog_f(" pMyAlloc->tex: %d", DL_INIT, result->pMyAlloc->tex);
    *tex = result->pMyAlloc->tex;
 
    result->pGraph->RenderFile(path, nullptr);
    result->pControl->Run();
 
    return *(DWORD*)tex;
}