EasyRTSPLive高效转码之EasyVideoEncoder高效硬件编码解决方案(附源码)

在之前的《EasyRTSPLive高效转码之EasyVideoDecoder高效解码》系列文章中我们已经将视频解码成了原始图像数据(YUV/RGB),然后根据不同的转码需求进行编码。如视频分辨率缩放,调整码率,多码率输出等;为了解决转码过程中编码高分辨率高质量或者高压缩率(如H265)耗时的问题,我们采用Nvidia硬件驱动编码器进行编码,以追求最高效率的转码和最低的推送延迟。

EasyVideoEncoder基Nvidia独立显卡的硬件编码库EasyNvEncoder

1. 接口声明如下:
class EasyNvEncoder
{
public:
	//codec: 编码格式 0=h264, 1=h265/hevc
	int InitNvEncoder(int width,int height,int fps=25, int bitrate=4096, int gop=50, int qp=28, int rcMode=/*NV_ENC_PARAMS_RC_2_PASS_QUALITY*/NV_ENC_PARAMS_RC_CONSTQP, 
		char* encoderPreset = "Default", int codec = 0,int nDeviceType=0, int nDeviceID=0 );
		
	//H264获取SPS和PPS	
	int GetSPSAndPPS(unsigned char*sps,long&spslen,unsigned char*pps,long&ppslen);
	
	//H265获取VPS,SPS和PPS	
	int GetH265VPSSPSAndPPS(unsigned char*vps, long&vpslen, unsigned char*sps, long&spslen, unsigned char*pps, long&ppslen);

	// 编码InputFormat我们固定为YUV420PL(I420),可修改为NV12, YUY2 等等在Init()时进行格式转换, [12/18/2016 dingshuai]
	unsigned char* NvEncodeSync(unsigned char* pYUV420, int inLenth, int& outLenth, bool& bKeyFrame);

	//关闭编码器,停止编码
	int CloseNvEncoder();
};
2. EasyNvEncoder编码库调用流程
  • 第一步,初始化编码器及其参数
//初始化编码器参数
int InitNvEncoder(int width,int height,int fps, int bitrate, int gop,  
	int qp, int rcMode,  char* encoderPreset , int codec, int nDeviceType, int nDeviceID)
{
	//初始化设置参数 -- Start
	memset(&m_encodeConfig, 0, sizeof(EncodeConfig));
	m_encodeConfig.width = width;
	m_encodeConfig.height = height;
	m_nVArea = width*height;
	m_nCheckyuvsize = m_nVArea*3/2;

	//编码器识别的码率是bps, 但是我们输入的是kbps, so*1024
	m_encodeConfig.bitrate = bitrate*1024;

	//多通道编码优化图像质量只有在低延迟模式下工作(LOW_LATENCY)
	m_encodeConfig.rcMode = rcMode;//NV_ENC_PARAMS_RC_2_PASS_QUALITY

	m_encodeConfig.encoderPreset = encoderPreset;	//NV_ENC_PARAMS_RC_2_PASS_QUALITY;
	//默认指定低延时模式以及图像的压缩格式(HQ,HP,LOSSLESS ......)
	m_encodeConfig.presetGUID = NV_ENC_PRESET_LOW_LATENCY_HQ_GUID;

	// I帧间隔 [12/16/2016 dingshuai]
	m_encodeConfig.gopLength = gop;//NVENC_INFINITE_GOPLENGTH;

	//CUDA 
	m_encodeConfig.deviceType = nDeviceType;
	m_encodeConfig.deviceID = nDeviceID;

	m_encodeConfig.codec =  codec;//NV_ENC_H264;
	m_encodeConfig.fps = fps;
	m_encodeConfig.qp = qp;
	m_encodeConfig.i_quant_factor = DEFAULT_I_QFACTOR;
	m_encodeConfig.b_quant_factor = DEFAULT_B_QFACTOR;  
	m_encodeConfig.i_quant_offset = DEFAULT_I_QOFFSET;
	m_encodeConfig.b_quant_offset = DEFAULT_B_QOFFSET; 

	m_encodeConfig.pictureStruct = NV_ENC_PIC_STRUCT_FRAME;

	//编码异步输出模式, 1-异步 0-同步
	m_encodeConfig.enableAsyncMode = 0;
	//默认输入给编码器的格式为NV12(所以需要格式转换:YUV420->NV12)
	m_encodeConfig.inputFormat = NV_ENC_BUFFER_FORMAT_NV12;

	//暂不知道这些参数什么用
	m_encodeConfig.invalidateRefFramesEnableFlag = 0;
	m_encodeConfig.endFrameIdx = INT_MAX;

	//没有B帧,且目前编码器也不支持B帧,设了也没用
	m_encodeConfig.numB = 0;
	if (m_encodeConfig.numB > 0)
	{
		//PRINTERR("B-frames are not supported\n");
		return -1;
	}

	// 其他参数,欢迎补充...... [12/18/2016 dingshuai]
	//
	// 
	//初始化设置参数 -- END

	//初始化编码器 -- Start
	NVENCSTATUS nvStatus = NV_ENC_SUCCESS;
	switch (m_encodeConfig.deviceType)
	{
#if defined(NV_WINDOWS)
	case NV_ENC_DX9:
		nvStatus = InitD3D9(m_encodeConfig.deviceID);
		break;

	case NV_ENC_DX10:
		nvStatus = InitD3D10(m_encodeConfig.deviceID);
		break;

	case NV_ENC_DX11:
		nvStatus = InitD3D11(m_encodeConfig.deviceID);
		break;
#endif
	// initialize Cuda
	case NV_ENC_CUDA:
		InitCuda(m_encodeConfig.deviceID,0);
		break;
	}
	if (nvStatus != NV_ENC_SUCCESS)
		return -1;

	if (m_encodeConfig.deviceType != NV_ENC_CUDA)
		nvStatus = m_pNvHWEncoder->Initialize(m_pDevice, NV_ENC_DEVICE_TYPE_DIRECTX);
	else
		nvStatus = m_pNvHWEncoder->Initialize(m_pDevice, NV_ENC_DEVICE_TYPE_CUDA);

	if (nvStatus != NV_ENC_SUCCESS)
		return 1;
	//nvStatus = InitCuda(m_encodeConfig.deviceID, 0);

	//nvStatus = m_pNvHWEncoder->Initialize((void*)m_cuContext, NV_ENC_DEVICE_TYPE_CUDA);
	//if (nvStatus != NV_ENC_SUCCESS)
	//	return -2;

	m_encodeConfig.presetGUID = m_pNvHWEncoder->GetPresetGUID(m_encodeConfig.encoderPreset, m_encodeConfig.codec);
	
	nvStatus = m_pNvHWEncoder->CreateEncoder(&m_encodeConfig);
	if (nvStatus != NV_ENC_SUCCESS)
	{
		Deinitialize();
		return -3;
	}

	// 编码缓存帧数 [12/16/2016 dingshuai]
	uint32_t uEncodeBufferCount = 1;
	//分配编码缓冲区
	nvStatus = AllocateIOBuffers(m_pNvHWEncoder->m_uMaxWidth, m_pNvHWEncoder->m_uMaxHeight, uEncodeBufferCount);
	if (nvStatus != NV_ENC_SUCCESS)
		return -4;

	m_spslen = 0;
	m_ppslen = 0;
	memset(m_sps, 0x00, 100);
	memset(m_pps, 0x00, 100);
	m_bWorking = true;
	return 1;
}

其中,我们需要设置编码格式(0=H264,1=H265目前只支持这两种格式),视频分辨率,帧率,码率和I帧间隔(Gop),编码质量以及硬件编码器相关参数,参数详解如下:

//rcMode: Rate Control Modes(编码码率/质量控制模式),详见如下枚举:
					// 	typedef enum _NV_ENC_PARAMS_RC_MODE
					// 	{
					// 		NV_ENC_PARAMS_RC_CONSTQP                = 0x0,       /**< Constant QP mode */
					// 		NV_ENC_PARAMS_RC_VBR                    = 0x1,       /**< Variable bitrate mode */
					// 		NV_ENC_PARAMS_RC_CBR                    = 0x2,       /**< Constant bitrate mode */
					// 		NV_ENC_PARAMS_RC_VBR_MINQP              = 0x4,       /**< Variable bitrate mode with MinQP */
					// 		NV_ENC_PARAMS_RC_2_PASS_QUALITY         = 0x8,       /**< Multi pass encoding optimized for image quality and works only with low latency mode */
					// 		NV_ENC_PARAMS_RC_2_PASS_FRAMESIZE_CAP   = 0x10,      /**< Multi pass encoding optimized for maintaining frame size and works only with low latency mode */
					// 	}
					
//encoderPreset: 编码预设
					// 预设编码器编码图像的延时和清晰度
					// if (encoderPreset && (stricmp(encoderPreset, "HQ") == 0))
					// else if (encoderPreset && (stricmp(encoderPreset, "LowLatencyHP") == 0))
					// else if (encoderPreset && (stricmp(encoderPreset, "HP") == 0))
					// else if (encoderPreset && (stricmp(encoderPreset, "LowLatencyHQ") == 0))
					// else if (encoderPreset && (stricmp(encoderPreset, "BD") == 0))
					// else if (encoderPreset && (stricmp(encoderPreset, "LOSSLESS") == 0))
					// 	else if (encoderPreset && (stricmp(encoderPreset, "LowLatencyDefault") == 0))
					// else if (encoderPreset && (stricmp(encoderPreset, "LosslessDefault") == 0))
					//	详见nvEncoderAPI.h  /*   Preset GUIDS supported by the NvEncodeAPI interface.  */		
  • 第二步,获取编码信息参数
    如果编码格式为H264,我们通过GetSPSAndPPS获取编码信息头SPS和PPS,如下代码段所示:
//获取SPS和PPS	
int GetSPSAndPPS(unsigned char*sps,long&spslen,unsigned char*pps,long&ppslen)
{
		if (!m_bWorking)
		{
			return -1;
		}

		if (m_spslen == 0 || m_ppslen == 0)
		{
			unsigned char* pEncData = NULL;
			int nDataSize = 0;
			bool bKeyFrame = false;
			unsigned char* pTempBuffer = new unsigned char[m_nCheckyuvsize];
			memset(pTempBuffer, 0x00, m_nCheckyuvsize);
			pEncData = NvEncodeSync(pTempBuffer, m_nCheckyuvsize, nDataSize, bKeyFrame);
			if (pEncData && nDataSize>0)
			{
				GetH264SPSandPPS((char*)pEncData, nDataSize, (char*)m_sps, (int*)&m_spslen, (char*)m_pps, (int*)&m_ppslen);
			}
			m_encPicCommand.bForceIDR = 1;
			if (pTempBuffer)
			{
				delete[] pTempBuffer;
				pTempBuffer = NULL;
			}
		}

		if (m_spslen>0&&m_ppslen>0)
		{
			memcpy(sps, m_sps, m_spslen);
			memcpy(pps, m_pps, m_ppslen);
			spslen = m_spslen;
			ppslen = m_ppslen;
		}
		return 1;
}

如果编码格式为H265,我们通过GetH265VPSSPSAndPPS获取编码信息头VPS,SPS和PPS,如下代码段所示:

int GetH265VPSSPSAndPPS(unsigned char*vps, long&vpslen, unsigned char*sps, 
	long&spslen, unsigned char*pps, long&ppslen)
{
	if (!m_bWorking)
	{
		return -1;
	}

	if (m_spslen == 0 || m_ppslen == 0)
	{
		unsigned char* pEncData = NULL;
		int nDataSize = 0;
		bool bKeyFrame = false;
		unsigned char* pTempBuffer = new unsigned char[m_nCheckyuvsize];
		memset(pTempBuffer, 0x00, m_nCheckyuvsize);
		pEncData = NvEncodeSync(pTempBuffer, m_nCheckyuvsize, nDataSize, bKeyFrame);
		if (pEncData && nDataSize>0)
		{
			GetH265VPSandSPSandPPS((char*)pEncData, nDataSize, (char*)m_vps, (int*)&m_vpslen, (char*)m_sps, (int*)&m_spslen, (char*)m_pps, (int*)&m_ppslen);
		}
		m_encPicCommand.bForceIDR = 1;
		if (pTempBuffer)
		{
			delete[] pTempBuffer;
			pTempBuffer = NULL;
		}
	}

	spslen = m_spslen;
	ppslen = m_ppslen;
	vpslen = m_vpslen;
	if (m_spslen > 0)
		memcpy(sps, m_sps, m_spslen);

	if(m_ppslen>0)
		memcpy(pps, m_pps, m_ppslen);
	if(m_vpslen)
		memcpy(vps, m_vps, m_vpslen);

	return 1;
}
  • 第三步,调用编码函数进行视频帧编码
    编码输入格式InputFormat我们固定为YUV420PL(I420),如源图像色彩格式为NV12, YUY2 等,需要在传入编码器时进行格式转换。

unsigned char* NvEncodeSync(unsigned char* pYUV420, int inLenth, int& outLenth, bool& bKeyFrame)
{
	if(	!m_bWorking  || inLenth !=m_nCheckyuvsize)//初始化尚未完成,或者传入的数据不满足YUV数据的长度,则返回错误
	{
		outLenth = 0;
		return NULL;
	}

	NVENCSTATUS nvStatus = NV_ENC_SUCCESS;
	bool bError = false;
	EncodeBuffer* pEncodeBuffer = m_EncodeBufferQueue.GetAvailable();

	EncodeFrameConfig stEncodeFrame;
	memset(&stEncodeFrame, 0, sizeof(stEncodeFrame));
	stEncodeFrame.yuv[0] = pYUV420;//Y
	stEncodeFrame.yuv[1] = pYUV420+m_nVArea;//U
	stEncodeFrame.yuv[2] = pYUV420+m_nVArea+(m_nVArea>>2);//V

	int nHelfWidth = m_encodeConfig.width >> 1;
	stEncodeFrame.stride[0] = m_encodeConfig.width;
	stEncodeFrame.stride[1] = nHelfWidth;
	stEncodeFrame.stride[2] = nHelfWidth;
	stEncodeFrame.width = m_encodeConfig.width;
	stEncodeFrame.height = m_encodeConfig.height;

	if (m_encodeConfig.deviceType == 0)//CUDA
	{
		//CUDA Lock 
		CCudaAutoLock cuLock((CUcontext)m_pDevice);//m_cuContext

		nvStatus = PreProcessInput(pEncodeBuffer, stEncodeFrame.yuv, stEncodeFrame.width, stEncodeFrame.height,
			m_pNvHWEncoder->m_uCurWidth, m_pNvHWEncoder->m_uCurHeight,
			m_pNvHWEncoder->m_uMaxWidth, m_pNvHWEncoder->m_uMaxHeight);
		if (nvStatus != NV_ENC_SUCCESS)
		{
			outLenth = 0;
			return NULL;
		}
		nvStatus = m_pNvHWEncoder->NvEncMapInputResource(pEncodeBuffer->stInputBfr.nvRegisteredResource, &pEncodeBuffer->stInputBfr.hInputSurface);
		if (nvStatus != NV_ENC_SUCCESS)
		{
			PRINTERR("Failed to Map input buffer %p\n", pEncodeBuffer->stInputBfr.hInputSurface);
			bError = true;
			outLenth = 0;
			return NULL;
		}
	}
	else//DirectX or any others
	{
		unsigned char *pInputSurface = NULL;
		uint32_t lockedPitch = 0;
		while (pInputSurface == NULL)
		{
			nvStatus = m_pNvHWEncoder->NvEncLockInputBuffer(pEncodeBuffer->stInputBfr.hInputSurface, (void**)&pInputSurface, &lockedPitch);
			if (nvStatus != NV_ENC_SUCCESS)
				return NULL;
			if (pInputSurface == NULL)
			{
				nvStatus = m_pNvHWEncoder->NvEncUnlockInputBuffer(pEncodeBuffer->stInputBfr.hInputSurface);
				if (nvStatus != NV_ENC_SUCCESS)
					return NULL;
				Sleep(1);
			}
		}
		if (pEncodeBuffer->stInputBfr.bufferFmt == NV_ENC_BUFFER_FORMAT_NV12_PL)
		{
			unsigned char *pInputSurfaceCh = pInputSurface + (pEncodeBuffer->stInputBfr.dwHeight*lockedPitch);
			CmnConvertYUVtoNV12(stEncodeFrame.yuv[0], stEncodeFrame.yuv[1], stEncodeFrame.yuv[2], pInputSurface, 
				pInputSurfaceCh, stEncodeFrame.width, stEncodeFrame.height, stEncodeFrame.width, lockedPitch);
		}

	}
	nvStatus = m_pNvHWEncoder->NvEncEncodeFrame(pEncodeBuffer, &m_encPicCommand, m_encodeConfig.width, m_encodeConfig.height,
		NV_ENC_PIC_STRUCT_FRAME, m_qpDeltaMapArray, m_qpDeltaMapArraySize);
	if (nvStatus != NV_ENC_SUCCESS)
	{
		bError = true;
		outLenth= 0;
		return NULL;
	}

	pEncodeBuffer = m_EncodeBufferQueue.GetAvailable();
	if (!pEncodeBuffer)
	{
		pEncodeBuffer = m_EncodeBufferQueue.GetPending();

		// 获取编码的h264/h265数据 [12/15/2016 dingshuai]
		nvStatus = m_pNvHWEncoder->ProcessOutput(pEncodeBuffer, m_pOutputBuffer, m_nOutputBufLen);
		if(nvStatus != NV_ENC_SUCCESS)
		{
			bError = true;
			outLenth= 0;
		}

		if (m_encodeConfig.deviceType == 0)//CUDA
		{
			// UnMap the input buffer after frame done
			if (pEncodeBuffer->stInputBfr.hInputSurface)
			{
				nvStatus = m_pNvHWEncoder->NvEncUnmapInputResource(pEncodeBuffer->stInputBfr.hInputSurface);
				pEncodeBuffer->stInputBfr.hInputSurface = NULL;
			}
			//pEncodeBuffer = m_EncodeBufferQueue.GetAvailable();
		}
		else
		{
			nvStatus = m_pNvHWEncoder->NvEncUnlockInputBuffer(pEncodeBuffer->stInputBfr.hInputSurface);
			if (nvStatus != NV_ENC_SUCCESS)
				return NULL;
		}
	}
	else
	{
		outLenth= 0;
		return NULL;
	}
	
	if (m_encPicCommand.bForceIDR)
	{
		m_encPicCommand.bForceIDR = 0;
	}

	outLenth = m_nOutputBufLen;
	return m_pOutputBuffer;
}
  • 第四步,关闭编码器,释放编码器申请的内存和显卡资源
int CloseNvEncoder()
{
	m_bWorking = false; 
    NVENCSTATUS nvStatus = NV_ENC_SUCCESS;

    ReleaseIOBuffers();

    m_pNvHWEncoder->NvEncDestroyEncoder();

	if (m_cuContext)
	{
		__cu(cuCtxDestroy(m_cuContext));
	}

    return nvStatus;
}

有任何技术问题,欢迎大家和我技术交流:
[email protected]

大家也可以加入EasyPlayer流媒体播放器 QQ群进行讨论:
544917793

你可能感兴趣的:(EasyRTSPLive)