SharedTextureHolder createSharedTextures(int width,
                                         int height,
                                         ID3D11Device1 *firstDevice,
                                         ID3D11Device1 *secondDevice,
                                         int bufferSize) {
    SharedTextureHolder holder{};

    for (size_t i = 0; i < bufferSize + 1; i++) {
        ID3D11Texture2D *tex = nullptr;

        D3D11_TEXTURE2D_DESC desc = {};
        desc.Width = width;
        desc.Height = height;
        desc.MipLevels = 1;
        desc.ArraySize = 1;
        desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
        desc.SampleDesc.Count = 1;
        desc.SampleDesc.Quality = 0;
        desc.Usage = D3D11_USAGE_DEFAULT;
        desc.CPUAccessFlags = 0;
        desc.MiscFlags = D3D11_RESOURCE_MISC_SHARED_NTHANDLE | D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX;
        desc.BindFlags = D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET;

        HRESULT hr = firstDevice->CreateTexture2D(&desc, nullptr, &tex);

        std::cout << "Pointer value tex: " << tex << std::endl;


        if (FAILED(hr)) {
            std::cerr << "Failed to create shared texture. HRESULT: 0x" << std::hex << hr << std::dec << std::endl;
        }

        IDXGIResource1 *shareableResource;
        HRESULT setShareableResource = tex->QueryInterface(__uuidof(IDXGIResource1), (void **) &shareableResource);

        if (FAILED(setShareableResource)) {
            std::cerr << "Failed to set shared resource. HRESULT: 0x" << std::hex << setShareableResource << std::dec << std::endl;
        }

        HANDLE sharedHandle;
        HRESULT createSharedRes = shareableResource->CreateSharedHandle(NULL,
                                                                        DXGI_SHARED_RESOURCE_READ | DXGI_SHARED_RESOURCE_WRITE,
                                                                        nullptr,
                                                                        &sharedHandle);

        shareableResource->Release();
        if (FAILED(createSharedRes)) {
            std::cerr << "Failed to set shared resource. HRESULT: 0x" << std::hex << createSharedRes << std::dec << std::endl;
        }

        IDXGIKeyedMutex *keyedMutex = nullptr;

        HRESULT getMutexForTex = tex->QueryInterface(__uuidof(IDXGIKeyedMutex), (void **) &keyedMutex);

        if (FAILED(getMutexForTex)) {
            std::cerr << "Failed to obtain IDXGIKeyedMutex for tex. HRESULT: 0x" << std::hex << getMutexForTex << std::dec << std::endl;
        }

        // Shared part for device 2
        ID3D11Texture2D *texDevice2 = nullptr;
        HRESULT openResource = secondDevice->OpenSharedResource1(sharedHandle, __uuidof(ID3D11Texture2D ), (void **) &texDevice2);

        if (FAILED(openResource)) {
            std::cerr << "Failed to open shared resource. HRESULT: 0x" << std::hex << openResource << std::dec << std::endl;
        }

        IDXGIKeyedMutex* keyedMutexTexDevice2 = nullptr;
        HRESULT getMutexForTexDevice2 = texDevice2->QueryInterface(__uuidof(IDXGIKeyedMutex), (void**)&keyedMutexTexDevice2);

        if (FAILED(getMutexForTexDevice2)) {
            std::cerr << "Failed to obtain IDXGIKeyedMutex for texDevice2. HRESULT: 0x" << std::hex << getMutexForTexDevice2 << std::dec << std::endl;
        }

        SharedTexture sharedTexture{};
        sharedTexture.pUnityTex = tex;
        sharedTexture.pUnityMutex = keyedMutex;
        sharedTexture.pFFmpegTex = texDevice2;
        sharedTexture.pFFmpegMutex = keyedMutexTexDevice2;

        if (i == 0) {
            holder.renderingTex = sharedTexture;
        } else {
            holder.bufferTextures.push_back(sharedTexture);
        }
    }

    return holder;
}