Use Mediafoundation with d3d11 to read video file, D3DKMTWaitForVerticalBlankEvent exception

I read video file by use mediafoundation(IMFSourceReader), and i create d3d11 device and dxgi manager set to reader.
then decoding every frame in loop.
then I the debug output window print info like “Exception at 0x7ffe85ba4f99, code: 0xe06d7363: c++ exception, flag=0x1 in d3d11 D3DKMTWaitForVerticalBlankEvent.”
but the app work well if i ignore this exception:

The exception is only on nvidia gpu(My GPU is 1050 and 1030),I test the sample code in amd and intel GPU ,there are no expection output !!!.

Code:
#include
#include
#include
#include <atlbase.h>
#include <d3d11.h>
#include <mfapi.h>
#include <mfidl.h>
#include <mfreadwrite.h>
#include <windows.h>

#pragma comment(lib, “d3d11.lib”)
#pragma comment(lib, “mf.lib”)
#pragma comment(lib, “mfplat.lib”)
#pragma comment(lib, “mfreadwrite.lib”)
#pragma comment(lib, “mfuuid.lib”)

#define ENABLE_HW_ACCELERATION
#define ENABLE_HW_DRIVER

void handle_result(HRESULT hr)
{
if (SUCCEEDED(hr))
return;

WCHAR message[512];

FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, nullptr, hr,
    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), message, ARRAYSIZE(message), nullptr);

printf("%ls", message);
abort();

}

int main(int argc, char *argv)
{
QCoreApplication a(argc, argv);
handle_result(CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE));
handle_result(MFStartup(MF_VERSION));

    {
        CComPtr<IMFAttributes> attributes;

        handle_result(MFCreateAttributes(&attributes, 3));

#if defined(ENABLE_HW_ACCELERATION)
        CComPtr<ID3D11Device> device;
        D3D_FEATURE_LEVEL levels[] = { D3D_FEATURE_LEVEL_11_1, D3D_FEATURE_LEVEL_11_0 };

#if defined(ENABLE_HW_DRIVER)
        handle_result(D3D11CreateDevice(
            nullptr,
            D3D_DRIVER_TYPE_HARDWARE,
            nullptr,
            0,
            levels,
            ARRAYSIZE(levels),
            D3D11_SDK_VERSION,
            &device,
            nullptr,
            nullptr));
#else
        handle_result(D3D11CreateDevice(nullptr, D3D_DRIVER_TYPE_NULL, nullptr, D3D11_CREATE_DEVICE_SINGLETHREADED,
            levels, ARRAYSIZE(levels), D3D11_SDK_VERSION, &device, nullptr, nullptr));
#endif

        CComPtr<ID3D10Multithread> multithread = nullptr;
        handle_result(device->QueryInterface(__uuidof(ID3D10Multithread), (LPVOID*)&multithread));
        handle_result(multithread->SetMultithreadProtected(true));

        UINT token;
        CComPtr<IMFDXGIDeviceManager> manager;

        handle_result(MFCreateDXGIDeviceManager(&token, &manager));
        handle_result(manager->ResetDevice(device, token));

        handle_result(attributes->SetUnknown(MF_SOURCE_READER_D3D_MANAGER, manager));
        handle_result(attributes->SetUINT32(MF_READWRITE_ENABLE_HARDWARE_TRANSFORMS, TRUE));
        handle_result(attributes->SetUINT32(MF_SOURCE_READER_ENABLE_ADVANCED_VIDEO_PROCESSING, TRUE));
#else
        handle_result(attributes->SetUINT32(MF_SOURCE_READER_ENABLE_VIDEO_PROCESSING, TRUE));
#endif

        CComPtr<IMFSourceReader> reader;
        handle_result(MFCreateSourceReaderFromURL(L"C:\\111\\4K5min.mp4", attributes, &reader));

        CComPtr<IMFMediaType> output_type;
        handle_result(MFCreateMediaType(&output_type));
        handle_result(output_type->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Video));
        handle_result(output_type->SetGUID(MF_MT_SUBTYPE, MFVideoFormat_NV12));
        handle_result(reader->SetCurrentMediaType(MF_SOURCE_READER_FIRST_VIDEO_STREAM, nullptr, output_type));

        unsigned int frame_count{};
        std::cout << "Started processing frames" << std::endl;

        while (true)
        {
            CComPtr<IMFSample> sample;
            DWORD flags;
            handle_result(reader->ReadSample(
                MF_SOURCE_READER_FIRST_VIDEO_STREAM,
                0,
                nullptr,
                &flags,
                nullptr,
                &sample));

            if (flags & MF_SOURCE_READERF_ENDOFSTREAM || sample == nullptr)
                break;
            int64_t ts = 0;
            sample->GetSampleTime(&ts);
            std::cout << "Read sample pts =  " <<ts <<"."<< std::endl;
            sample.Release();
        }

        std::cout << "Finished processing frames" << std::endl;
    }

    MFShutdown();
    CoUninitialize();
return a.exec();

}