IntelグラフィックハードウェアH264 MFT ProcessInput呼び出しは、いくつかの入力サンプルを供給した後に失敗します。NvidiaハードウェアMFTでも同じように機能します。


9

DesktopDuplication APIを使用してデスクトップをキャプチャし、サンプルをGPUでRGBAからNV12に変換して、MediaFoundationハードウェアH264 MFTにフィードしています。これは、Nvidiaグラフィックスとソフトウェアエンコーダーで正常に動作しますが、インテルグラフィックスハードウェアMFTのみが使用可能な場合は失敗します。ソフトウェアMFTにフォールバックすると、同じIntelグラフィックマシンでコードが正常に機能します。また、Nvidiaグラフィックスマシンのハードウェアでエンコードが実際に行われるようにしました。

Intelグラフィックスでは、MFTはMEError("Unspecified error")を返します。これは最初のサンプルが供給された直後にのみ発生し、後続のProcessInputの呼び出し(イベントジェネレーターがMETransformNeedInputをトリガーしたとき)は"呼び出し先は現在それ以上の入力を受け付けていません"を返します。MFTがこれらのエラーを返す前に、さらにいくつかのサンプルを消費することはまれです。この動作は混乱を招くので、イベントジェネレーターがIMFAsyncCallbackを介してMETransformNeedInputを非同期でトリガーする場合にのみサンプルをフィードし、サンプルがフィードされるとすぐにMETransformHaveOutputがトリガーされるかどうかを適切にチェックします。同じ非同期ロジックがNvidiaハードウェアMFTとMicrosoftソフトウェアエンコーダーで正常に動作するとき、これは本当に困惑します。

インテルフォーラム自体にも同様の未解決の質問があります。私のコードは、以下のようにエンコーダーにd3dデバイスマネージャーも設定しているという事実を除いて、インテルスレッドで言及されているものに似ています。

また、他に3つのスタックオーバーフロースレッドがあり、ソリューションが提供されていない同様の問題を報告しています(MFTransformエンコーダー-> ProcessInputがE_FAILを返しますIntel MFTエンコーダーのD11テクスチャからIMFSampleを作成する方法非同期MFTがMFTransformHaveOutputイベントを送信していません(インテルハードウェアMJPEGデコーダーMFT))。私はこれを改善することなく、可能なすべてのオプションを試しました。

色変換コードは、インテルメディアSDKサンプルから取得されます。ここに私の完全なコードもアップロードしました

d3dマネージャーを設定する方法:

void SetD3dManager() {

    HRESULT hr = S_OK;

    if (!deviceManager) {

        // Create device manager
        hr = MFCreateDXGIDeviceManager(&resetToken, &deviceManager);
    }

    if (SUCCEEDED(hr)) 
    {
        if (!pD3dDevice) {

            pD3dDevice = GetDeviceDirect3D(0);
        }
    }

    if (pD3dDevice) {

        // NOTE: Getting ready for multi-threaded operation
        const CComQIPtr<ID3D10Multithread> pMultithread = pD3dDevice;
        pMultithread->SetMultithreadProtected(TRUE);

        hr = deviceManager->ResetDevice(pD3dDevice, resetToken);
        CHECK_HR(_pTransform->ProcessMessage(MFT_MESSAGE_SET_D3D_MANAGER, reinterpret_cast<ULONG_PTR>(deviceManager.p)), "Failed to set device manager.");
    }
    else {
        cout << "Failed to get d3d device";
    }
}

Getd3ddevice:

CComPtr<ID3D11Device> GetDeviceDirect3D(UINT idxVideoAdapter)
{
    // Create DXGI factory:
    CComPtr<IDXGIFactory1> dxgiFactory;
    DXGI_ADAPTER_DESC1 dxgiAdapterDesc;

    // Direct3D feature level codes and names:

    struct KeyValPair { int code; const char* name; };

    const KeyValPair d3dFLevelNames[] =
    {
        KeyValPair{ D3D_FEATURE_LEVEL_9_1, "Direct3D 9.1" },
        KeyValPair{ D3D_FEATURE_LEVEL_9_2, "Direct3D 9.2" },
        KeyValPair{ D3D_FEATURE_LEVEL_9_3, "Direct3D 9.3" },
        KeyValPair{ D3D_FEATURE_LEVEL_10_0, "Direct3D 10.0" },
        KeyValPair{ D3D_FEATURE_LEVEL_10_1, "Direct3D 10.1" },
        KeyValPair{ D3D_FEATURE_LEVEL_11_0, "Direct3D 11.0" },
        KeyValPair{ D3D_FEATURE_LEVEL_11_1, "Direct3D 11.1" },
    };

    // Feature levels for Direct3D support
    const D3D_FEATURE_LEVEL d3dFeatureLevels[] =
    {
        D3D_FEATURE_LEVEL_11_1,
        D3D_FEATURE_LEVEL_11_0,
        D3D_FEATURE_LEVEL_10_1,
        D3D_FEATURE_LEVEL_10_0,
        D3D_FEATURE_LEVEL_9_3,
        D3D_FEATURE_LEVEL_9_2,
        D3D_FEATURE_LEVEL_9_1,
    };

    constexpr auto nFeatLevels = static_cast<UINT> ((sizeof d3dFeatureLevels) / sizeof(D3D_FEATURE_LEVEL));

    CComPtr<IDXGIAdapter1> dxgiAdapter;
    D3D_FEATURE_LEVEL featLevelCodeSuccess;
    CComPtr<ID3D11Device> d3dDx11Device;

    std::wstring_convert<std::codecvt_utf8<wchar_t>> transcoder;

    HRESULT hr = CreateDXGIFactory1(IID_PPV_ARGS(&dxgiFactory));
    CHECK_HR(hr, "Failed to create DXGI factory");

    // Get a video adapter:
    dxgiFactory->EnumAdapters1(idxVideoAdapter, &dxgiAdapter);

    // Get video adapter description:
    dxgiAdapter->GetDesc1(&dxgiAdapterDesc);

    CHECK_HR(hr, "Failed to retrieve DXGI video adapter description");

    std::cout << "Selected DXGI video adapter is \'"
        << transcoder.to_bytes(dxgiAdapterDesc.Description) << '\'' << std::endl;

    // Create Direct3D device:
    hr = D3D11CreateDevice(
        dxgiAdapter,
        D3D_DRIVER_TYPE_UNKNOWN,
        nullptr,
        (0 * D3D11_CREATE_DEVICE_SINGLETHREADED) | D3D11_CREATE_DEVICE_VIDEO_SUPPORT,
        d3dFeatureLevels,
        nFeatLevels,
        D3D11_SDK_VERSION,
        &d3dDx11Device,
        &featLevelCodeSuccess,
        nullptr
    );

    // Might have failed for lack of Direct3D 11.1 runtime:
    if (hr == E_INVALIDARG)
    {
        // Try again without Direct3D 11.1:
        hr = D3D11CreateDevice(
            dxgiAdapter,
            D3D_DRIVER_TYPE_UNKNOWN,
            nullptr,
            (0 * D3D11_CREATE_DEVICE_SINGLETHREADED) | D3D11_CREATE_DEVICE_VIDEO_SUPPORT,
            d3dFeatureLevels + 1,
            nFeatLevels - 1,
            D3D11_SDK_VERSION,
            &d3dDx11Device,
            &featLevelCodeSuccess,
            nullptr
        );
    }

    // Get name of Direct3D feature level that succeeded upon device creation:
    std::cout << "Hardware device supports " << std::find_if(
        d3dFLevelNames,
        d3dFLevelNames + nFeatLevels,
        [featLevelCodeSuccess](const KeyValPair& entry)
        {
            return entry.code == featLevelCodeSuccess;
        }
    )->name << std::endl;

done:

    return d3dDx11Device;
}

非同期コールバックの実装:

struct EncoderCallbacks : IMFAsyncCallback
{
    EncoderCallbacks(IMFTransform* encoder)
    {
        TickEvent = CreateEvent(0, FALSE, FALSE, 0);
        _pEncoder = encoder;
    }

    ~EncoderCallbacks()
    {
        eventGen = nullptr;
        CloseHandle(TickEvent);
    }

    bool Initialize() {

        _pEncoder->QueryInterface(IID_PPV_ARGS(&eventGen));

        if (eventGen) {

            eventGen->BeginGetEvent(this, 0);
            return true;
        }

        return false;
    }

    // dummy IUnknown impl
    virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void** ppvObject) override { return E_NOTIMPL; }
    virtual ULONG STDMETHODCALLTYPE AddRef(void) override { return 1; }
    virtual ULONG STDMETHODCALLTYPE Release(void) override { return 1; }

    virtual HRESULT STDMETHODCALLTYPE GetParameters(DWORD* pdwFlags, DWORD* pdwQueue) override
    {
        // we return immediately and don't do anything except signaling another thread
        *pdwFlags = MFASYNC_SIGNAL_CALLBACK;
        *pdwQueue = MFASYNC_CALLBACK_QUEUE_IO;
        return S_OK;
    }

    virtual HRESULT STDMETHODCALLTYPE Invoke(IMFAsyncResult* pAsyncResult) override
    {
        IMFMediaEvent* event = 0;
        eventGen->EndGetEvent(pAsyncResult, &event);
        if (event)
        {
            MediaEventType type;
            event->GetType(&type);
            switch (type)
            {
            case METransformNeedInput: InterlockedIncrement(&NeedsInput); break;
            case METransformHaveOutput: InterlockedIncrement(&HasOutput); break;
            }
            event->Release();
            SetEvent(TickEvent);
        }

        eventGen->BeginGetEvent(this, 0);
        return S_OK;
    }

    CComQIPtr<IMFMediaEventGenerator> eventGen = nullptr;
    HANDLE TickEvent;
    IMFTransform* _pEncoder = nullptr;

    unsigned int NeedsInput = 0;
    unsigned int HasOutput = 0;
};

サンプルメソッドの生成:

bool GenerateSampleAsync() {

    DWORD processOutputStatus = 0;
    HRESULT mftProcessOutput = S_OK;
    bool frameSent = false;

    // Create sample
    CComPtr<IMFSample> currentVideoSample = nullptr;

    MFT_OUTPUT_STREAM_INFO StreamInfo;

    // wait for any callback to come in
    WaitForSingleObject(_pEventCallback->TickEvent, INFINITE);

    while (_pEventCallback->NeedsInput) {

        if (!currentVideoSample) {

            (pDesktopDuplication)->releaseBuffer();
            (pDesktopDuplication)->cleanUpCurrentFrameObjects();

            bool bTimeout = false;

            if (pDesktopDuplication->GetCurrentFrameAsVideoSample((void**)& currentVideoSample, waitTime, bTimeout, deviceRect, deviceRect.Width(), deviceRect.Height())) {

                prevVideoSample = currentVideoSample;
            }
            // Feed the previous sample to the encoder in case of no update in display
            else {
                currentVideoSample = prevVideoSample;
            }
        }

        if (currentVideoSample)
        {
            InterlockedDecrement(&_pEventCallback->NeedsInput);
            _frameCount++;

            CHECK_HR(currentVideoSample->SetSampleTime(mTimeStamp), "Error setting the video sample time.");
            CHECK_HR(currentVideoSample->SetSampleDuration(VIDEO_FRAME_DURATION), "Error getting video sample duration.");

            CHECK_HR(_pTransform->ProcessInput(inputStreamID, currentVideoSample, 0), "The resampler H264 ProcessInput call failed.");

            mTimeStamp += VIDEO_FRAME_DURATION;
        }
    }

    while (_pEventCallback->HasOutput) {

        CComPtr<IMFSample> mftOutSample = nullptr;
        CComPtr<IMFMediaBuffer> pOutMediaBuffer = nullptr;

        InterlockedDecrement(&_pEventCallback->HasOutput);

        CHECK_HR(_pTransform->GetOutputStreamInfo(outputStreamID, &StreamInfo), "Failed to get output stream info from H264 MFT.");

        CHECK_HR(MFCreateSample(&mftOutSample), "Failed to create MF sample.");
        CHECK_HR(MFCreateMemoryBuffer(StreamInfo.cbSize, &pOutMediaBuffer), "Failed to create memory buffer.");
        CHECK_HR(mftOutSample->AddBuffer(pOutMediaBuffer), "Failed to add sample to buffer.");

        MFT_OUTPUT_DATA_BUFFER _outputDataBuffer;
        memset(&_outputDataBuffer, 0, sizeof _outputDataBuffer);
        _outputDataBuffer.dwStreamID = outputStreamID;
        _outputDataBuffer.dwStatus = 0;
        _outputDataBuffer.pEvents = nullptr;
        _outputDataBuffer.pSample = mftOutSample;

        mftProcessOutput = _pTransform->ProcessOutput(0, 1, &_outputDataBuffer, &processOutputStatus);

        if (mftProcessOutput != MF_E_TRANSFORM_NEED_MORE_INPUT)
        {
            if (_outputDataBuffer.pSample) {

                CComPtr<IMFMediaBuffer> buf = NULL;
                DWORD bufLength;
                CHECK_HR(_outputDataBuffer.pSample->ConvertToContiguousBuffer(&buf), "ConvertToContiguousBuffer failed.");

                if (buf) {

                    CHECK_HR(buf->GetCurrentLength(&bufLength), "Get buffer length failed.");
                    BYTE* rawBuffer = NULL;

                    fFrameSize = bufLength;
                    fDurationInMicroseconds = 0;
                    gettimeofday(&fPresentationTime, NULL);

                    buf->Lock(&rawBuffer, NULL, NULL);
                    memmove(fTo, rawBuffer, fFrameSize > fMaxSize ? fMaxSize : fFrameSize);

                    bytesTransfered += bufLength;

                    FramedSource::afterGetting(this);

                    buf->Unlock();

                    frameSent = true;
                }
            }

            if (_outputDataBuffer.pEvents)
                _outputDataBuffer.pEvents->Release();
        }
        else if (MF_E_TRANSFORM_STREAM_CHANGE == mftProcessOutput) {

            // some encoders want to renegotiate the output format. 
            if (_outputDataBuffer.dwStatus & MFT_OUTPUT_DATA_BUFFER_FORMAT_CHANGE)
            {
                CComPtr<IMFMediaType> pNewOutputMediaType = nullptr;
                HRESULT res = _pTransform->GetOutputAvailableType(outputStreamID, 1, &pNewOutputMediaType);

                res = _pTransform->SetOutputType(0, pNewOutputMediaType, 0);//setting the type again
                CHECK_HR(res, "Failed to set output type during stream change");
            }
        }
        else {
            HandleFailure();
        }
    }

    return frameSent;
}

ビデオサンプルと色変換を作成します。

bool GetCurrentFrameAsVideoSample(void **videoSample, int waitTime, bool &isTimeout, CRect &deviceRect, int surfaceWidth, int surfaceHeight)
{

FRAME_DATA currentFrameData;

m_LastErrorCode = m_DuplicationManager.GetFrame(&currentFrameData, waitTime, &isTimeout);

if (!isTimeout && SUCCEEDED(m_LastErrorCode)) {

    m_CurrentFrameTexture = currentFrameData.Frame;

    if (!pDstTexture) {

        D3D11_TEXTURE2D_DESC desc;
        ZeroMemory(&desc, sizeof(D3D11_TEXTURE2D_DESC));

        desc.Format = DXGI_FORMAT_NV12;
        desc.Width = surfaceWidth;
        desc.Height = surfaceHeight;
        desc.MipLevels = 1;
        desc.ArraySize = 1;
        desc.SampleDesc.Count = 1;
        desc.CPUAccessFlags = 0;
        desc.Usage = D3D11_USAGE_DEFAULT;
        desc.BindFlags = D3D11_BIND_RENDER_TARGET;

        m_LastErrorCode = m_Id3d11Device->CreateTexture2D(&desc, NULL, &pDstTexture);
    }

    if (m_CurrentFrameTexture && pDstTexture) {

        // Copy diff area texels to new temp texture
        //m_Id3d11DeviceContext->CopySubresourceRegion(pNewTexture, D3D11CalcSubresource(0, 0, 1), 0, 0, 0, m_CurrentFrameTexture, 0, NULL);

        HRESULT hr = pColorConv->Convert(m_CurrentFrameTexture, pDstTexture);

        if (SUCCEEDED(hr)) { 

            CComPtr<IMFMediaBuffer> pMediaBuffer = nullptr;

            MFCreateDXGISurfaceBuffer(__uuidof(ID3D11Texture2D), pDstTexture, 0, FALSE, (IMFMediaBuffer**)&pMediaBuffer);

            if (pMediaBuffer) {

                CComPtr<IMF2DBuffer> p2DBuffer = NULL;
                DWORD length = 0;
                (((IMFMediaBuffer*)pMediaBuffer))->QueryInterface(__uuidof(IMF2DBuffer), reinterpret_cast<void**>(&p2DBuffer));
                p2DBuffer->GetContiguousLength(&length);
                (((IMFMediaBuffer*)pMediaBuffer))->SetCurrentLength(length);

                //MFCreateVideoSampleFromSurface(NULL, (IMFSample**)videoSample);
                MFCreateSample((IMFSample * *)videoSample);

                if (videoSample) {

                    (*((IMFSample **)videoSample))->AddBuffer((((IMFMediaBuffer*)pMediaBuffer)));
                }

                return true;
            }
        }
    }
}

return false;
}

マシンのインテルグラフィックスドライバーはすでに最新です。

ここに画像の説明を入力してください ここに画像の説明を入力してください ここに画像の説明を入力してください

TransformNeedInputイベントだけが常にトリガーされますが、エンコーダーはそれ以上の入力を受け入れることができないと不平を言います。TransformHaveOutputイベントがトリガーされたことはありません。

ここに画像の説明を入力してください

インテルおよびMSDNフォーラムで報告された同様の問題:1)https://software.intel.com/en-us/forums/intel-media-sdk/topic/607189 2)https://social.msdn.microsoft.com/フォーラム/セキュリティ/ en-US / fe051dd5-b522-4e4b-9cbb-2c06a5450e40 / imfsinkwriter-merit-validation-failed-for-mft-intel-quick-sync-video-h264-encoder-mft?forum = mediafoundationdevelopment

更新: 入力ソースのみをモックしようとしました(プログラムでアニメーションの四角形のNV12サンプルを作成することにより)。今回は、Intelエンコーダーは何も文句を言わず、出力サンプルも取得しました。インテルエンコーダーの出力ビデオが歪んでいるのに対し、Nvidiaエンコーダーは完全に正常に動作するという事実を除いて。

さらに、インテルエンコーダーを使用した元のNV12ソースのProcessInputエラーが引き続き発生します。Nvidia MFTとソフトウェアエンコーダーには何の問題もありません。

IntelハードウェアMFTの出力:(Nvidiaエンコーダーの出力をご覧ください) ここに画像の説明を入力してください

NvidiaハードウェアMFTの出力: ここに画像の説明を入力してください

Nvidiaグラフィックの使用統計: ここに画像の説明を入力してください

Intelグラフィックスの使用統計(GPUエンジンがビデオデコードとして表示される理由がわかりません): ここに画像の説明を入力してください


関連するコードは表示されません。「必要な入力」を受け取り、それを提供することに関して正確に何かがうまくいかない可能性がありますProcessInput
ローマンR.

@RomanR。その場合、ソフトウェアとNvidiaハードウェアMFTでも失敗する可能性がありますね。インテルフォーラム(software.intel.com / en-us / forums / intel-media-sdk / topic / 681571)。このスレッドを必要なコードブロックで更新してみます。
Ram

いいえそうではありません。AMD、Intel、NVIDIAのハードウェアMFTは同じように実装されますが、同時に動作が少し異なります。3つすべては主に非同期MFTとして機能するので、あなたの質問はあなたが何か間違ったことをしていることを明らかに示しています。コードがなければ、それは正確に当て推量です。マイクロソフトのソフトウェアエンコーダーは同期MFT AFAIRであるため、非同期MFTとの通信の一部である可能性が高いため、問題があります。
ローマンR.

ところで、そのIntelフォーラムリンクからのコードは私にとっては機能し、ビデオを生成します。
ローマンR.

@RomanR。IMFAsyncCallbackの実装、サンプルの作成と色の変換、ProcessInputとProcessOutputでスレッドを更新しました。カラーコンバーターは、ここから簡単に取得できます(github.com/NVIDIA/video-sdk-samples/blob/master/…)。
Ram

回答:


2

私はあなたのコードを見ました。

あなたの投稿によると、私はIntelビデオプロセッサの問題を疑っています。

私のOSはWin7なので、NvidiaカードのD3D9Deviceでビデオプロセッサの動作をテストし、次にIntel HD Graphics 4000でテストすることにしました。

ビデオプロセッサの機能は、D3D9DeviceでもD3D11Deviceと同じように動作すると思います。もちろん確認する必要があります。

だから私はこのプログラムをチェックするようにした:https : //github.com/mofo7777/DirectXVideoScreen(D3D9VideoProcessorサブプロジェクトを参照)

ビデオプロセッサの機能について十分なチェックをしていないようです。

IDXVAHD_Device :: GetVideoProcessorDeviceCapsを使用して、次のことを確認します。

DXVAHD_VPDEVCAPS.MaxInputStreams> 0

DXVAHD_VPDEVCAPS.VideoProcessorCount> 0

DXVAHD_VPDEVCAPS.OutputFormatCount> 0

DXVAHD_VPDEVCAPS.InputFormatCount> 0

DXVAHD_VPDEVCAPS.InputPool == D3DPOOL_DEFAULT

また、IDXVAHD_Device :: GetVideoProcessorOutputFormatsとIDXVAHD_Device :: GetVideoProcessorInputFormatsでサポートされている入出力形式も確認します。

ここで、Nvidia GPUとIntel GPUの違いを発見しました。

NVIDIA:4出力フォーマット

  • D3DFMT_A8R8G8B8
  • D3DFMT_X8R8G8B8
  • D3DFMT_YUY2
  • D3DFMT_NV12

INTEL:3出力フォーマット

  • D3DFMT_A8R8G8B8
  • D3DFMT_X8R8G8B8
  • D3DFMT_YUY2

Intel HD Graphics 4000では、NV12出力形式はサポートされていません。

また、プログラムが正しく機能するために、VideoProcessBltHDを使用する前にストリーム状態をセットアップする必要があります。

  • DXVAHD_STREAM_STATE_D3DFORMAT
  • DXVAHD_STREAM_STATE_FRAME_FORMAT
  • DXVAHD_STREAM_STATE_INPUT_COLOR_SPACE
  • DXVAHD_STREAM_STATE_SOURCE_RECT
  • DXVAHD_STREAM_STATE_DESTINATION_RECT

D3D11の場合:

ID3D11VideoProcessorEnumerator :: GetVideoProcessorCaps == IDXVAHD_Device :: GetVideoProcessorDeviceCaps

(D3D11_VIDEO_PROCESSOR_FORMAT_SUPPORT_OUTPUT)ID3D11VideoProcessorEnumerator :: CheckVideoProcessorFormat == IDXVAHD_Device :: GetVideoProcessorOutputFormats

(D3D11_VIDEO_PROCESSOR_FORMAT_SUPPORT_INPUT)ID3D11VideoProcessorEnumerator :: CheckVideoProcessorFormat == IDXVAHD_Device :: GetVideoProcessorInputFormats

ID3D11VideoContext ::(...)== IDXVAHD_VideoProcessor :: SetVideoProcessStreamState

まず、GPUのビデオプロセッサ機能を確認してください。私と同じ違いがありますか?

これは私たちが知る必要がある最初のことであり、あなたのプログラムは私があなたのgithubプロジェクトで見たものからこれをチェックしないようです。


あなたが正しいです。IntelグラフィックスのGetVideoProcessorOutputFormatsは、RGBバリアントとYUY2のみを返しました。
Ram

IntelプロセッサでRGBAテクスチャをYUY2に簡単に変換できます。しかし、問題は、IntelグラフィックスがNV12入力形式のみをサポートしているようだということです。現在、カラーコンバーターとビデオエンコーダーは互換性がありません。なぜIntelがこのようにすることを決めたのか、まだ疑問に思っています。RGBからNV12への変換を効率的に行う他の方法はありますか?十分なパフォーマンスを提供しないソフトウェアアプローチをすでに試しました。
Ram

シェーダーまたは計算シェーダーがあります。
mofo77

1
私はシェーダーアプローチに取り組んでいます。github.com/mofo7777/DirectXVideoScreenで更新を確認してください 。
mofo77

すごい!共有してくれてありがとう、それは本当に役に立ちます。
ラム

1

投稿で述べたように、エラーMEError( "Unspecified error")は、Intelハードウェアの最初の入力サンプルを供給した直後にTransformのイベントジェネレーターによって返され、さらに呼び出しは "Transform Need more input"を返しましたが、出力は生成されませんでした。同じコードはNvidiaマシンでも問題なく動作しました。多くの実験と調査の結果、D3d11Deviceのインスタンスを作成しすぎていることに気付きました。私の場合、キャプチャ、カラー変換、ハードウェアエンコーダー用にそれぞれ2〜3個のデバイスを作成しました。一方、単一のD3dDeviceインスタンスを再利用するだけで済みます。ただし、複数のD3d11Deviceインスタンスを作成すると、ハイエンドマシンで機能する場合があります。これはどこにも文書化されていません。「MEError」エラーの原因の手掛かりすら見つけることができませんでした。それはどこにも言及されていません。

D3D11Deviceインスタンスを再利用することで問題は解決しました。この解決策を投稿することは、私の解決策と同じ問題に直面している人々に役立つ可能性があるためです。


E_UNEXPECTEDエラーが
言及さ

@ mofo77、申し訳ありませんが、投稿で言及されているように、MEError = 1( "Unspecified error")でした。ちょっと迷ってしまいました。私の答えを修正しました。ご指摘ありがとうございます。
Ram
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.