尝试使用NvEncInitializeEncoder初始化nvencoder时，参数无效错误代码8

问题描述

我正在尝试直接从NVIDIA的C ++ API使用NVIDIA的nvenc。 我正在使用一些API包装器来简化它，但在其中使用了直接的nvenc API。

当包装器尝试使用NvEncInitializeEncoder初始化编码器时，我用来尝试创建编码器的代码导致INVALID PARAMS错误（错误代码8）

    NvEncoderCuda * encoder = NULL;
    try
    {
        CUresult err = cuInit(0);

        int n = 0;
        cuDeviceGetCount(&n);
        printf("%d\r\n",n);
        CUdevice cuDevice;
        cuDeviceGet(&cuDevice,0);


        // Create context
        CUcontext cuContext;
        cuCtxCreate(&cuContext,cuDevice);
        cuCtxSetCurrent(cuContext);

        CUstream stream1,stream2;
        cuStreamCreate(&stream1,CU_STREAM_DEFAULT);
        cuStreamCreate(&stream2,CU_STREAM_DEFAULT);

        encoder = new NvEncoderCuda(cuContext,targetW,targetH,NV_ENC_BUFFER_FORMAT_ABGR,0);
        NV_ENC_INITIALIZE_PARAMS initializeParams = { NV_ENC_INITIALIZE_PARAMS_VER };
        NV_ENC_CONFIG encodeConfig = { NV_ENC_CONFIG_VER };
        initializeParams.encodeConfig = &encodeConfig;
        encoder->CreateDefaultEncoderParams(&initializeParams,NV_ENC_CODEC_H264_GUID,NV_ENC_PRESET_P1_GUID);

        initializeParams.encodeGUID = NV_ENC_CODEC_H264_GUID;
        initializeParams.encodeWidth = targetW;
        initializeParams.encodeHeight = targetH;
        encoder->CreateEncoder(&initializeParams);
    }
    catch (NVENCException& e)
    {
        //EncErrorCodeToString
        std::string err = "Failed to create encoder (" + e.getErrorString() + ",error " + std::to_string(e.getErrorCode()) + " = " +std::to_string(e.getErrorCode()) + ")";
        printf("%s(%s)\r\n",err.c_str(),std::to_string(NV_ENC_ERR_INVALID_PARAM).c_str());
    }

打印的错误如下：

Failed to create encoder (NvEncoder::CreateEncoder : m_nvenc.nvEncInitializeEncoder(m_hEncoder,&m_initializeParams) returned error 8 at e:\tetavi_main2\tetavi_main\tv_apps\plyconvert\nvencoder\nvencoder.cpp:245,error 8 = 8)(8)

包装器API中的代码如下，并且从nvEncInitializeEncoder抛出异常

void NvEncoder::CreateEncoder(const NV_ENC_INITIALIZE_PARAMS* pEncoderParams)
{
    if (!m_hEncoder)
    {
        NVENC_THROW_ERROR("Encoder Initialization failed",NV_ENC_ERR_NO_ENCODE_DEVICE);
    }

    if (!pEncoderParams)
    {
        NVENC_THROW_ERROR("Invalid NV_ENC_INITIALIZE_PARAMS ptr",NV_ENC_ERR_INVALID_PTR);
    }

    if (pEncoderParams->encodeWidth == 0 || pEncoderParams->encodeHeight == 0)
    {
        NVENC_THROW_ERROR("Invalid encoder width and height",NV_ENC_ERR_INVALID_PARAM);
    }

    if (pEncoderParams->encodeGUID != NV_ENC_CODEC_H264_GUID && pEncoderParams->encodeGUID != NV_ENC_CODEC_HEVC_GUID)
    {
        NVENC_THROW_ERROR("Invalid codec guid",NV_ENC_ERR_INVALID_PARAM);
    }

    if (pEncoderParams->encodeGUID == NV_ENC_CODEC_H264_GUID)
    {
        if (m_eBufferFormat == NV_ENC_BUFFER_FORMAT_YUV420_10BIT || m_eBufferFormat == NV_ENC_BUFFER_FORMAT_YUV444_10BIT)
        {
            NVENC_THROW_ERROR("10-bit format isn't supported by H264 encoder",NV_ENC_ERR_INVALID_PARAM);
        }
    }

    // set other necessary params if not set yet
    if (pEncoderParams->encodeGUID == NV_ENC_CODEC_H264_GUID)
    {
        if ((m_eBufferFormat == NV_ENC_BUFFER_FORMAT_YUV444) &&
            (pEncoderParams->encodeConfig->encodeCodecConfig.h264Config.chromaFormatIDC != 3))
        {
            NVENC_THROW_ERROR("Invalid ChromaFormatIDC",NV_ENC_ERR_INVALID_PARAM);
        }
    }

    if (pEncoderParams->encodeGUID == NV_ENC_CODEC_HEVC_GUID)
    {
        bool yuv10BitFormat = (m_eBufferFormat == NV_ENC_BUFFER_FORMAT_YUV420_10BIT || m_eBufferFormat == NV_ENC_BUFFER_FORMAT_YUV444_10BIT) ? true : false;
        if (yuv10BitFormat && pEncoderParams->encodeConfig->encodeCodecConfig.hevcConfig.pixelBitDepthMinus8 != 2)
        {
            NVENC_THROW_ERROR("Invalid PixelBitdepth",NV_ENC_ERR_INVALID_PARAM);
        }

        if ((m_eBufferFormat == NV_ENC_BUFFER_FORMAT_YUV444 || m_eBufferFormat == NV_ENC_BUFFER_FORMAT_YUV444_10BIT) &&
            (pEncoderParams->encodeConfig->encodeCodecConfig.hevcConfig.chromaFormatIDC != 3))
        {
            NVENC_THROW_ERROR("Invalid ChromaFormatIDC",NV_ENC_ERR_INVALID_PARAM);
        }
    }

    memcpy(&m_initializeParams,pEncoderParams,sizeof(m_initializeParams));
    m_initializeParams.version = NV_ENC_INITIALIZE_PARAMS_VER;

    if (pEncoderParams->encodeConfig)
    {
        memcpy(&m_encodeConfig,pEncoderParams->encodeConfig,sizeof(m_encodeConfig));
        m_encodeConfig.version = NV_ENC_CONFIG_VER;
    }
    else
    {
        NV_ENC_PRESET_CONFIG presetConfig = { NV_ENC_PRESET_CONFIG_VER,{ NV_ENC_CONFIG_VER } };
        if (!m_bMotionEstimationOnly)
        {
            m_nvenc.nvEncGetEncodePresetConfigEx(m_hEncoder,pEncoderParams->encodeGUID,pEncoderParams->presetGUID,pEncoderParams->tuningInfo,&presetConfig);
            memcpy(&m_encodeConfig,&presetConfig.presetCfg,sizeof(NV_ENC_CONFIG));
        }
        else
        {
            m_encodeConfig.version = NV_ENC_CONFIG_VER;
            m_encodeConfig.rcParams.rateControlMode = NV_ENC_PARAMS_RC_CONSTQP;
            m_encodeConfig.rcParams.constQP = { 28,31,25 };
        }
    }
    m_initializeParams.encodeConfig = &m_encodeConfig;

    NVENC_API_CALL(m_nvenc.nvEncInitializeEncoder(m_hEncoder,&m_initializeParams));

    m_bEncoderInitialized = true;
    m_nWidth = m_initializeParams.encodeWidth;
    m_nHeight = m_initializeParams.encodeHeight;
    m_nMaxEncodeWidth = m_initializeParams.maxEncodeWidth;
    m_nMaxEncodeHeight = m_initializeParams.maxEncodeHeight;

    m_nEncoderBuffer = m_encodeConfig.frameIntervalP + m_encodeConfig.rcParams.lookaheadDepth + m_nExtraOutputDelay;
    m_nOutputDelay = m_nEncoderBuffer - 1;
    m_vMappedInputBuffers.resize(m_nEncoderBuffer,nullptr);

    if (!m_bOutputInVideoMemory)
    {
        m_vpCompletionEvent.resize(m_nEncoderBuffer,nullptr);
    }

#if defined(_WIN32)
    for (uint32_t i = 0; i < m_vpCompletionEvent.size(); i++) 
    {
        m_vpCompletionEvent[i] = CreateEvent(NULL,FALSE,NULL);
        NV_ENC_EVENT_PARAMS eventParams = { NV_ENC_EVENT_PARAMS_VER };
        eventParams.completionEvent = m_vpCompletionEvent[i];
        m_nvenc.nvEncRegisterAsyncEvent(m_hEncoder,&eventParams);
    }
#endif

    if (m_bMotionEstimationOnly)
    {
        m_vMappedRefBuffers.resize(m_nEncoderBuffer,nullptr);

        if (!m_bOutputInVideoMemory)
        {
            InitializeMVOutputBuffer();
        }
    }
    else
    {
        if (!m_bOutputInVideoMemory)
        {
            m_vBitstreamOutputBuffer.resize(m_nEncoderBuffer,nullptr);
            InitializeBitstreamBuffer();
        }
    }

    AllocateInputBuffers(m_nEncoderBuffer);
}

我传递错误的参数吗？为什么说无效参数？ （targetW和targetH都等于2048）

解决方法

暂无找到可以解决该程序问题的有效方法，小编努力寻找整理中！

如果你已经找到好的解决方法，欢迎将解决方案带上本链接一起发送给小编。

小编邮箱:dio#foxmail.com (将#修改为@）