1. openh264进行视频编码

最新推荐文章于 2025-04-01 16:11:38 发布
最新推荐文章于 2025-04-01 16:11:38 发布
阅读量2.7k 收藏 11
点赞数 2
分类专栏： 流媒体 文章标签： openH264
原文链接：https://www.jianshu.com/p/5208f37090a9 https://blog.youkuaiyun.com/NB_vol_1/article/details/103376649
版权

文章目录

编码过程

初始化ISVCEncoder

ISVCEncoder* encoder_;
int rv = WelsCreateSVCEncoder(&encoder_);
if (0 != rv || !encoder_) {
        //error
}

  ISVCEncoder提供了一系列的编码有关的接口，如初始化编码器、设置编码参数、编码等；

设置相关参数

  openh264提供了两个结构体来设置编码参数，SEncParamBase与SEncParamExt， SEncParamBase仅通过了最基础的参数设置， 其定义如下:

typedef struct TagEncParamBase {
  EUsageType
  iUsageType;                 ///< application type;1.CAMERA_VIDEO_REAL_TIME:camera video signal; 2.SCREEN_CONTENT_REAL_TIME:screen content signal;

  int       iPicWidth;        ///< width of picture in luminance samples (the maximum of all layers if multiple spatial layers presents)
  int       iPicHeight;       ///< height of picture in luminance samples((the maximum of all layers if multiple spatial layers presents)
  int       iTargetBitrate;   ///< target bitrate desired, in unit of bps
  RC_MODES  iRCMode;          ///< rate control mode
  float     fMaxFrameRate;    ///< maximal input frame rate
} SEncParamBase, *PEncParamBase;

其中参数iUsageType指明应用的类型，类型包括:

typedef enum {
  CAMERA_VIDEO_REAL_TIME,      ///< camera video for real-time communication
  SCREEN_CONTENT_REAL_TIME,    ///< screen content signal
  CAMERA_VIDEO_NON_REAL_TIME
} EUsageType;

iRCMode指定码率控制的模式, openh264提供的模式如下:

typedef enum {
  RC_QUALITY_MODE = 0,     ///< quality mode
  RC_BITRATE_MODE = 1,     ///< bitrate mode
  RC_BUFFERBASED_MODE = 2, ///< no bitrate control,only using buffer status,adjust the video quality
  RC_TIMESTAMP_MODE = 3, //rate control based timestamp
  RC_BITRATE_MODE_POST_SKIP = 4, ///< this is in-building RC MODE, WILL BE DELETED after algorithm tuning!
  RC_OFF_MODE = -1,         ///< rate control off mode
} RC_MODES;

对编码器的初始化例子如下:

SEncParamBase paramBase;
paramBase.iPicWidth = width_;
paramBase.iPicHeight = height_;
paramBase.fMaxFrameRate = fps_;
paramBase.iTargetBitrate = 10 * width_ * height_;
paramBase.iUsageType = CAMERA_VIDEO_REAL_TIME;
paramBase.iRCMode = RC_BITRATE_MODE;
int ret = encoder_->Initialize(&paramBase);
if (0 != ret) {
        //error
}

编码

  编码需要用到SSourcePicture和SFrameBSInfo两个结构体， SSourcePicture用来保存需要编码的数据信息， 而SFrameBSInfo会保存编码完成后的数据。
SSourcePicture的定义:

typedef struct Source_Picture_s {
  int       iColorFormat;          ///< color space type
  int       iStride[4];            ///< stride for each plane pData
  unsigned char*  pData[4];        ///< plane pData
  int       iPicWidth;             ///< luma picture width in x coordinate
  int       iPicHeight;            ///< luma picture height in y coordinate
  long long uiTimeStamp;           ///< timestamp of the source picture, unit: millisecond
} SSourcePicture;
  • iColorFormat:颜色空间的类型，如videoFormatI420；
  • iStride, 每个plane的stride，对于plane和stride的理解可参考yuv 图像里的stride和plane的解释。
  • pData,指向每个plane的指针；
    SFrameBSInfo结构体在编码前只需要用memset将结构体中的数据置为0即可。其定义如下:
typedef struct {
  int           iLayerNum;
  SLayerBSInfo  sLayerInfo[MAX_LAYER_NUM_OF_FRAME];

  EVideoFrameType eFrameType;
  int iFrameSizeInBytes;
  long long uiTimeStamp;
} SFrameBSInfo, *PFrameBSInfo;

typedef struct {
  unsigned char uiTemporalId;
  unsigned char uiSpatialId;
  unsigned char uiQualityId;
  EVideoFrameType eFrameType;
  unsigned char uiLayerType;

  /**
   * The sub sequence layers are ordered hierarchically based on their dependency on each other so that any picture in a layer shall not be
   * predicted from any picture on any higher layer.
  */
  int   iSubSeqId;                ///< refer to D.2.11 Sub-sequence information SEI message semantics
  int   iNalCount;              ///< count number of NAL coded already
  int*  pNalLengthInByte;       ///< length of NAL size in byte from 0 to iNalCount-1
  unsigned char*  pBsBuf;       ///< buffer of bitstream contained
} SLayerBSInfo, *PLayerBSInfo;

SFrameBSInfo结构体比较复杂， 具体使用情况下面再解释。

对于i420数据的编码过程:

  SSourcePicture pic;
  memset(&pic, 0, sizeof(pic));
  pic.iPicWidth = width_;
  pic.iPicHeight = height_;
  pic.iColorFormat = videoFormatI420;
  pic.iStride[0] = pic.iPicWidth;
  pic.iStride[1] = pic.iStride[2] = pic.iPicWidth >> 1;
  pic.pData[0] = (unsigned char *) i420Buffer;
  pic.pData[1] = pic.pData[0] + width_ * height_;
  pic.pData[2] = pic.pData[1] + (width_ * height_ >> 2);
  SFrameBSInfo info;
  memset(&info, 0, sizeof(SFrameBSInfo));
  int rv = encoder_->EncodeFrame(&pic, &info);

  int retSize = 0;
  if (rv != cmResultSuccess) {
        //error info
      return retSize;
  }
 if (info.eFrameType != videoFrameTypeSkip) {
        int type = info.eFrameType;
        for (int i = 0; i < info.iLayerNum; ++i) {
            const SLayerBSInfo &layerInfo = info.sLayerInfo[i];
            int layerSize = 0;
            for (int j = 0; j < layerInfo.iNalCount; ++j) {
                layerSize += layerInfo.pNalLengthInByte[j];
            }
            memcpy((char *) (oBuf + retSize), (char *) layerInfo.pBsBuf, layerSize);
            retSize += layerSize;
        }
    }

其中i420Buffer是指向原始yuv数据的指针，oBuf是指向h264流缓冲区的指针。由上可知，整个过程分为几步：

  • 定义SSourcePicture和SFrameBSInfo， 并给SSourcePicture赋值；
  • 编码；
  • 判断编码是否成功；
  • 判断帧类型，如果不是跳帧， 则读取编码后数据；

  SFrameBSInfo的参数iLayerNum表示编码后的NAL数量。编码后的h264数据存放在SFrameBSInfo的sLayerInfo结构数组中，其中每个结构体中的pBsBuf表示编码得到的数据，而长度是结构体pNalLengthInByteint数组加起来的和，数组长度由结构体的iNalCount成员表示。

释放

先调用ISVCEncoder的Uninitialize函数，再调用WelsDestroySVCEncoder即可。

功能实现

定义接口

在实现OpenH264编码之前，我们先定义一些常用视频编码接口：

  • 打开编码器：Open
  • 关闭编码器：Close
  • 配置编码器：Configure或者ReConfigure
  • 获取编码器配置信息：GetConfig
  • 编码：Encode
  • 请求关键帧：ForceKeyframe

根据上面的定义，可以使用C++来抽象出一个虚基类

namespace toy {
	// 编码器基类
	class VideoEncoder {
	public:
		// 参数定义
		struct Setting {
			Setting() {
				fps = 15;
				frame_skip = false;
			}
			uint32_t width; // 视频宽
			uint32_t height; // 视频高
			uint32_t bitrate_bps; // 目标码率
			uint32_t fps; // 帧率
			bool frame_skip; // 是否开启跳帧
			uint32_t qp; // qp值
		};
		
		// 创建编码器的静态接口
		static std::shared_ptr<VideoEncoder> Create(VideoCodecType type);

		virtual ~VideoEncoder() {}

		// 打开编码器
		virtual bool Open(const Setting& param) = 0;

		// 重新配置编码器
		virtual void ReConfigure(const Setting& param) = 0;

		// 返回编码器的参数
		virtual Setting GetConfig() = 0;

		// 编码
		virtual bool Encode(
			const uint8_t** yuv_data,// uint8_t* yuv_data[3]
			uint8_t* pkt,
			size_t& pkt_size,
			bool& is_keyframe,
			bool& got_output
		) = 0;

		// 编码
		virtual bool Encode(
			const uint8_t* yuv_data,
			uint8_t* pkt,
			size_t& pkt_size,
			bool& is_keyframe,
			bool& got_output
		) = 0;

		// 请求关键帧
		virtual void ForceKeyframe() = 0;

		// 关闭编码器
		virtual void Close() = 0;
	};
}

OpenH264的一些概念

  • ISVCEncoder：表示一个编码器
  • TagEncParamExt：表示编码器参数
  • Source_Picture_s：表示一个图像
  • 关键帧：即I帧（其他的两种帧类型是：P帧和B帧）。在实时音视频领域，一般只用到I帧和P帧
  • 图像组（GOP）：一般来说，两个关键帧之间即为一个图像组

使用OpenH264进行视频编码

一些注意事项：

  • 本实现没有使用时域编码（如果你需要svc，那么可以开启）；也没有使用空间分层（即只有一个分辨率）
  • GOP设置得大一些，目的是节省码率，因为I帧通常比较大；有需要的时候编码器会自行检测场景切换然后编码一个关键帧；当然也可以调用接口强制编码一个I帧。

头文件定义：

// OpenH264Encoder
#ifndef __VIDEO_OPENH264_ENCODER_H__
#define __VIDEO_OPENH264_ENCODER_H__
#include "video_codec.h"

class ISVCEncoder;
struct TagEncParamExt;
struct Source_Picture_s;

class OpenH264Encoder :public toy::VideoEncoder
{
public:
	OpenH264Encoder();
	~OpenH264Encoder();

	//初始化编解码
	virtual bool Open(const Setting& param) override;

	//结束释放
	virtual void Close() override;

	//编码
	virtual bool Encode(
		const uint8_t** yuv_data,
		uint8_t* pkt,
		size_t& pkt_size,
		bool& is_keyframe,
		bool& got_output
	) override;

	virtual bool Encode(
		const uint8_t* yuv_data,
		uint8_t* pkt,
		size_t& pkt_size,
		bool& is_keyframe,
		bool& got_output
	) override;

	//调整码率
	virtual void ReConfigure(const Setting& param) override;

	//强制i帧
	virtual void ForceKeyframe() override;

	virtual Setting GetConfig() override;

private:
	void SetOption(const Setting& param);
private:
	ISVCEncoder* encoder_;
	TagEncParamExt* encode_param_;
	Source_Picture_s* picture_;
	Setting setting_;
	uint8_t* picture_buffer_;
	bool is_open_;
	bool temporal_;
	unsigned int gop_size_;
	bool enable_fixed_gop_;
	uint64_t encoded_frame_count_;
	uint64_t timestamp_;
};

#endif __VIDEO_OPENH264_ENCODER_H__

源文件实现

#include "openh264_encoder.h"
#include "openh264/wels/codec_api.h"
#include <cstdio>
#include <memory>

// 最大和最小的码率
#define kVideoBitrateMin 80000
#define kVideoBitrateMax 6000000

OpenH264Encoder::OpenH264Encoder()
{
	encoder_ = nullptr;
	encode_param_ = new SEncParamExt;
	picture_ = new SSourcePicture;
	picture_buffer_ = nullptr;
	is_open_ = false;
	temporal_ = false;
	gop_size_ = 400;
	enable_fixed_gop_ = true;
	encoded_frame_count_ = 0;
	timestamp_ = 0;
}

OpenH264Encoder::~OpenH264Encoder()
{
	Close();
	if (encode_param_)
	{
		delete encode_param_;
		encode_param_ = nullptr;
	}
	if (picture_)
	{
		delete picture_;
		picture_ = nullptr;
	}
}

void OpenH264Encoder::Close()
{
	if (encoder_) {
		encoder_->Uninitialize();
		WelsDestroySVCEncoder(encoder_);
		encoder_ = NULL;
	}
	if (picture_buffer_)
	{
		delete[] picture_buffer_;
		picture_buffer_ = nullptr;
	}
	is_open_ = false;
}
bool OpenH264Encoder::Open(const Setting& param){
	Close();
	// 创建编码器对象
	int err = WelsCreateSVCEncoder(&encoder_);
	if (cmResultSuccess != err) {
		Close();
		return false;
	}
	temporal_ = false;

	// 获取默认参数
	encoder_->GetDefaultParams(encode_param_);
	// 复杂度
	ECOMPLEXITY_MODE complexityMode = HIGH_COMPLEXITY;
	// 码控模式
	RC_MODES rc_mode = RC_BITRATE_MODE;
	//int iMaxQp = qp_;
	//int iMinQp = 0;
	bool bEnableAdaptiveQuant = false;

	rc_mode = RC_BITRATE_MODE;//RC_QUALITY_MODE

	// 其他的参数：分辨率、码率、帧率等等
	encode_param_->iPicWidth = param.width;
	encode_param_->iPicHeight = param.height;
	encode_param_->iTargetBitrate = param.bitrate_bps;
	encode_param_->iMaxBitrate = kVideoBitrateMax;
	encode_param_->bEnableAdaptiveQuant = bEnableAdaptiveQuant;
	encode_param_->iRCMode = rc_mode;
	encode_param_->fMaxFrameRate = param.fps;
	encode_param_->iComplexityMode = complexityMode;
	encode_param_->iNumRefFrame = -1;
	encode_param_->bEnableFrameSkip = param.frame_skip;
	encode_param_->eSpsPpsIdStrategy = CONSTANT_ID;

	encode_param_->iEntropyCodingModeFlag = 0;//1;
	//encode_param_->bEnablePsnr = false;
	encode_param_->bEnableSSEI = true;
	encode_param_->bEnableSceneChangeDetect = true;

	// 设置QP，可以根据自己的需要来，QP越大码率越小（图像的质量越差）
	encode_param_->iMaxQp = 38;
	encode_param_->iMinQp = 16;
	// 当前不支持时域编码
	if (temporal_)
	{
		encode_param_->iTemporalLayerNum = 4;
	}

	SetOption(param);

	// 空间层
	SSpatialLayerConfig *spaticalLayerCfg = &(encode_param_->sSpatialLayers[SPATIAL_LAYER_0]);
	spaticalLayerCfg->iVideoWidth = param.width;
	spaticalLayerCfg->iVideoHeight = param.height;
	spaticalLayerCfg->fFrameRate = param.fps;
	spaticalLayerCfg->iSpatialBitrate = encode_param_->iTargetBitrate;
	spaticalLayerCfg->iMaxSpatialBitrate = encode_param_->iMaxBitrate;
	//spaticalLayerCfg->uiProfileIdc= PRO_SCALABLE_BASELINE;
	
	// 单slice，有的解码器无法解码多slice
	spaticalLayerCfg->sSliceArgument.uiSliceMode = SM_SINGLE_SLICE;

	// 初始化
	if (cmResultSuccess != (err = encoder_->InitializeExt(encode_param_))) {
		Close();
		return false;
	}
	
	// 日志级别
	int log_level = WELS_LOG_ERROR;
	encoder_->SetOption(ENCODER_OPTION_TRACE_LEVEL, &log_level);

	// 初始化图片对象
	memset(picture_, 0, sizeof(SSourcePicture));
	picture_->iPicWidth = param.width;
	picture_->iPicHeight = param.height;
	// 只支持yuv420p
	picture_->iColorFormat = videoFormatI420;
	picture_->iStride[0] = picture_->iPicWidth;
	picture_->iStride[1] = picture_->iStride[2] = picture_->iPicWidth >> 1;
	//yuvData = CFDataCreateMutable(kCFAllocatorDefault, inputSize.width * inputSize.height * 3 >> 1);
	picture_buffer_ = new uint8_t[picture_->iPicWidth * picture_->iPicHeight * 3 >> 1];
	picture_->pData[0] = (unsigned char*)picture_buffer_;//CFDataGetMutableBytePtr(yuvData);
	picture_->pData[1] = picture_->pData[0] + picture_->iPicWidth * picture_->iPicHeight;
	picture_->pData[2] = picture_->pData[1] + (picture_->iPicWidth * picture_->iPicHeight >> 2);

	is_open_ = true;

	setting_ = param;

	return true;
}

void OpenH264Encoder::SetOption(const Setting& param) {
	// 码率重设
	if (param.bitrate_bps != setting_.bitrate_bps) {

		setting_.bitrate_bps = param.bitrate_bps;

		encode_param_->iTargetBitrate = setting_.bitrate_bps;
		encode_param_->sSpatialLayers[SPATIAL_LAYER_0].iSpatialBitrate = setting_.bitrate_bps;

		SBitrateInfo bitrate_info;
		bitrate_info.iLayer = SPATIAL_LAYER_0;
		bitrate_info.iBitrate = setting_.bitrate_bps;
		int err = encoder_->SetOption(ENCODER_OPTION_BITRATE, &bitrate_info);
		if (err != 0) {
			// TODO
		}
	}

	// 帧率重设
	if (param.fps != setting_.fps) {
		int err = 0;

		setting_.fps = param.fps;

		// 注意：如果没有设置固定的I帧间隔，那么默认一个fps就输出一个I帧
		int uiIntraPeriod = param.fps;

		if (temporal_)
		{
			uiIntraPeriod = 16;
			if (param.fps > 16)
			{
				uiIntraPeriod = 32;
			}
		}

		// 如果设置了固定的I帧间隔，那么使用默认的I帧间隔，默认是400个
		if (enable_fixed_gop_)
		{
			uiIntraPeriod = gop_size_;
		}

		SSpatialLayerConfig *spaticalLayerCfg = &(encode_param_->sSpatialLayers[SPATIAL_LAYER_0]);

		// 设置I帧间隔
		if (encode_param_->uiIntraPeriod != uiIntraPeriod)
		{
			encode_param_->uiIntraPeriod = uiIntraPeriod;
			err = encoder_->SetOption(ENCODER_OPTION_IDR_INTERVAL, &uiIntraPeriod);
			if (err != 0)
			{
				printf("Apply new video idr interval %d code %d\n", uiIntraPeriod, err);
			}
		}

		// 设置帧率
		if (spaticalLayerCfg->fFrameRate != param.fps)
		{
			float fps = param.fps;
			err = encoder_->SetOption(ENCODER_OPTION_FRAME_RATE, (void*)&fps);
			if (err != 0)
			{
				printf("Apply new video frame rate %d code %d\n", (int)param.fps, err);
			}
		}

		encode_param_->uiIntraPeriod = uiIntraPeriod;
		spaticalLayerCfg->fFrameRate = setting_.fps;
	}

	// 跳帧操作
	if (encode_param_->bEnableFrameSkip != param.frame_skip)
	{
		setting_.frame_skip = param.frame_skip;

		int err = encoder_->SetOption(ENCODER_OPTION_RC_FRAME_SKIP, &setting_.frame_skip);
		if (err != 0)
		{
			printf("SetFrameSkip %d code %d \r\n", setting_.frame_skip, err);
			return;
		}
		encode_param_->bEnableFrameSkip = setting_.frame_skip;
	}

	// TODO:QP
}

void OpenH264Encoder::ReConfigure(const Setting& param) {
	if (is_open_ == false) {
		Open(param);
		return;
	}

	// 分辨率改变了，重启编码器
	if (param.width != setting_.width || param.height != setting_.height) {
		Close();
		if (Open(param) == false) {
			// TODO:
		}
		return;
	}

	SetOption(param);

	setting_ = param;

	return ;
}

bool OpenH264Encoder::Encode( 
	const uint8_t** yuv_data, 
	uint8_t* pkt, 
	size_t& pkt_size, 
	bool& is_keyframe, 
	bool& got_output )
{
	got_output = false;
	pkt_size = 0;

	if (!is_open_) {
		return false;
	}

	if (!encoder_)
	{
		return false;
	}

	encoded_frame_count_++;

	picture_->uiTimeStamp = timestamp_++; 

	int y_size = picture_->iPicWidth * picture_->iPicHeight;
	memcpy(picture_->pData[0] + 0,				yuv_data[0], y_size);
	memcpy(picture_->pData[0] + y_size,			yuv_data[1], y_size / 4);
	memcpy(picture_->pData[0] + y_size * 5 / 4, yuv_data[2], y_size / 4);

	int iFrameSize = 0;

	SFrameBSInfo encoded_frame_info;

	int err = encoder_->EncodeFrame(picture_, &encoded_frame_info);

	if (err) {
		Close();
		return 0;
	}

	if (encoded_frame_info.eFrameType == videoFrameTypeInvalid) {
		return 0;
	}

	int temporal_id = 0;

	if (encoded_frame_info.eFrameType != videoFrameTypeSkip) {
		int iLayer = 0;
		while (iLayer < encoded_frame_info.iLayerNum) {
			SLayerBSInfo* pLayerBsInfo = &(encoded_frame_info.sLayerInfo[iLayer]);
			if (pLayerBsInfo != NULL) {
				int iLayerSize = 0;
				temporal_id = pLayerBsInfo->uiTemporalId;
				int iNalIdx = pLayerBsInfo->iNalCount - 1;
				do {
					iLayerSize += pLayerBsInfo->pNalLengthInByte[iNalIdx];
					--iNalIdx;
				} while (iNalIdx >= 0);
				memcpy(pkt + iFrameSize, pLayerBsInfo->pBsBuf, iLayerSize);
				iFrameSize += iLayerSize;
			}
			++iLayer;
		}

		got_output = true;
	}
	else {
#ifdef _DEBUG
		printf("!!!!videoFrameTypeSkip---!\n");
#endif
		is_keyframe = false;
	}
	if (iFrameSize > 0)
	{
		pkt_size = iFrameSize;

		EVideoFrameType ft_temp = encoded_frame_info.eFrameType;
		if (ft_temp == 1 || ft_temp == 2)
		{
			is_keyframe = true;
		}
		else if (ft_temp == 3)
		{
			is_keyframe = false;
			if (temporal_)
			{
				if (temporal_id == 0 || temporal_id == 1)
				{
					is_keyframe = true;
				}
			}
		}
		else
		{
			is_keyframe = false;
		}
	}

	return iFrameSize;
}

bool OpenH264Encoder::Encode(
	const uint8_t* yuv_data,
	uint8_t* pkt,
	size_t& pkt_size,
	bool& is_keyframe,
	bool& got_output
)
{
	const uint8_t* yuv[3] = { 0 };
	if (yuv_data == NULL) {
		return Encode(yuv, pkt, pkt_size, is_keyframe, got_output);
	}
	else {
		int y_size = setting_.width * setting_.height;
		yuv[0] = yuv_data;
		yuv[1] = yuv_data + y_size;
		yuv[2] = yuv_data + y_size * 5 / 4;
		return Encode(yuv, pkt, pkt_size, is_keyframe, got_output);
	}

}

//强制i帧
void OpenH264Encoder::ForceKeyframe()
{
	if (!is_open_) {
		return;
	}
	
	encoder_->ForceIntraFrame(true);
}

toy::VideoEncoder::Setting OpenH264Encoder::GetConfig() {
	return setting_;
}

//是否使用分层
//bool OpenH264Encoder::IsTemporal()
//{
//	return temporal_used_;
//}

转载文章链接：
讲解：https://www.jianshu.com/p/5208f37090a9
使用：https://blog.youkuaiyun.com/NB_vol_1/article/details/103376649

基于OpenH264Encoder实现WebRTC的视频编码器
FdviAutoit的博客
09-22 339
在Init()方法中，我们初始化了OpenH264Encoder对象，并在EncodeFrame()方法中调用了OpenH264Encoder的编码函数进行编码操作。最后，在Release()方法中释放了OpenH264Encoder的资源。在编写具体的WebRTC视频编码器之前，我们需要定义一个VideoEncoder接口，该接口将规定了视频编码器需要实现的方法。在这个接口中，Init()方法用于初始化编码器，EncodeFrame()方法用于对视频帧进行编码，Release()方法用于释放编码器资源。
openh264 编解码器源码分析综述
世界那么大，我想去看看～
06-21 781
openh264 编解码器源码分析综述
H.264编码解析与C++实现详解
最新发布
weixin_44727517的博客
04-01 569
本文从H.264编码原理出发，详细讲解了C++实现中的关键技术点。通过FFmpeg库的灵活运用，结合多线程和SIMD等优化手段，可构建高性能的视频处理系统。实际开发中建议参考ITU-T H.264标准文档，并结合具体应用场景进行参数调优。
使用openh264进行视频编码
NB_vol_1的专栏
12-03 4475
先定义编码器类型 // 编码器类型 enum VideoCodecType { kVideoCodecGeneric = 0, kVideoCodecVP8, kVideoCodecVP9, kVideoCodecH264, kVideoCodecI420, kVideoCodecMultiplex, }; 定义编码器基类 namespace toy { ...
【openh264】编码例子
突围
03-03 1156
例子 大神音视频文章： https://github.com/gongluck/AnalysisAVP/blob/5cd6313263850dcb7d04fe83e249f30460096852/%E9%9F%B3%E8%A7%86%E9%A2%91%E6%A1%86%E6%9E%B6.md#windows%E7%BC%96%E8%AF%91-2 提供了一个openh264的使用例子： /* * @Author: gongluck * @Date: 2021-05-26 11:51:14 .
openh264编码知识.pdf
08-09
文档描述了I帧、P帧和B帧的区别，I帧和IDR帧的区别与联系，参考帧列表的创建和重排序、长期参考帧和短期参考帧的标记
openh264 编码参数详细介绍
世界那么大，我想去看看～
06-05 2109
openh264 编码参数详细介绍
【openh264】编码器 编码 SPS NALU 的流程
突围
04-24 414
调用路径 G:\LAS\A264\cc_openh264\meson_x86_vs2022\codec\console\enc\src\welsenc.cpp svc 核心编码： WelsWriteOneSPS 的调用 写入所有的SPS writing parasets for simulcast avc :WriteSavcParaset G:\LAS\A264\cc_openh264\meson_x86_vs2022\codec\encoder\core\src\enc.
openH264编码流程
kuaixiangmekan的专栏
12-31 4056
openH264编码流程之前在项目中用过openH264进行h264编码，本文介绍一下编码流程，算是做一个总结。
openh264(openh264.lib)
09-21
6. **示例应用**：OpenH264通常会提供示例程序，演示如何使用API进行编码和解码，开发者可以通过这些示例了解如何在实际项目中集成OpenH264。 7. **跨平台支持**：尽管这里提到的是在VS2013下的编译，但OpenH264也...
openh264 帧间预测编码过程源码分析
世界那么大，我想去看看～
06-17 580
openh264 帧间预测编码过程源码分析
基于h264视频的编码器
04-20
项目是开源x264的工程，日期为20091006 本人在文件添加了x264_20091006_windows版本，供大家在win32开发 更新如下： 1.修改内存泄露，x264_encoder_close中释放x264_free(nal_buffer)，不然会造成100025个字节泄露。 2.修改不用B帧和快速编码等参数，可以用来实时采集图像编码。 3.添加win32版本静态库,生成后可以在windows上开发。 4.修改wind32版本静态库链接中相同obj，例如：common中set和encode中set文件编译生成的obj是同一名称，在引用lib的时候会报无法解析函数的错误。 所以修改common中set文件为setc，这样才不会导致生成相同的obj导致覆盖。 本人是经过两天调试和修改，希望和大家一起分享，不喜勿喷
思科的H.264编码器OpenH264.zip
07-17
OpenH264 是思科公司发布的一个开源的 H.264 编码和解码器。编码器特性Constrained Baseline Profile up to Level 5.2 (4096x2304)Arbitrary resolution, not constrained to multiples of 16x16Rate control with adaptive quantization, or constant quantizationSlice options: 1 slice per frame, N slices per frame, N macroblocks per slice, or N bytes per sliceMultiple threads automatically used for multiple slicesTemporal scalability up to 4 layers in a dyadic hierarchySpatial simulcast up to 4 resolutions from a single inputLong Term Reference (LTR) framesMemory Management Control Operation (MMCO)Reference picture list modificationSingle reference frame for inter predictionMultiple reference frames when using LTR and/or 3-4 temporal layersPeriodic and on-demand Instantaneous Decoder Refresh (IDR) frame insertionDynamic changes to bit rate, frame rate, and resolutionAnnex B byte stream outputYUV 4:2:0 planar input解码器特性Constrained Baseline Profile up to Level 5.2 (4096x2304)Arbitrary resolution, not constrained to multiples of 16x16Single thread for all slicesLong Term Reference (LTR) framesMemory Management Control Operation (MMCO)Reference picture list modificationMultiple reference frames when specified in Sequence Parameter Set (SPS)Annex B byte stream inputYUV 4:2:0 planar output支持的操作系统Windows 64-bit and 32-bit (initial release is only 32-bit, 64-bit will follow soon)Mac OS X 64-bit (initial release does not include this target, will follow soon)Linux 64-bit and 32-bit (initial release is only 32-bit, 64-bit will follow soon)Android 32-bit (initial release does not include this target, will follow soon)iOS 64-bit and 32-bit (not supported yet, may be added in the future)支持的处理器Intel x86 optionally with MMX/SSE (no AVX yet, help is welcome)ARMv7 optionally with NEON (initial release does not include this target, will follow later)Any architecture using C/C fallback functions 标签：OpenH264
openh264源码
07-05
openh264源码，直接使用vs2010可以编译通过，可以得到相应编码，解码库文件
OpenH264 编解码器介绍
世界那么大，我想去看看～
05-25 2270
OpenH264 编解码器介绍
开源项目推荐：OpenH264——高效可靠的H.264编码解码库
gitblog_00051的博客
05-09 1157
开源项目推荐：OpenH264——高效可靠的H.264编码解码库 项目地址:https://gitcode.com/gh_mirrors/op/openh264 项目介绍 OpenH264是一个强大的开源H.264编解码库，专为实时应用程序如WebRTC设计。其由思科系统开发并维护，并提供了从基础到高级特性的广泛支持，旨在满足各种复杂场景的需求。 项目技术分析 OpenH264的编码器特性包括： ...
OpenH264：实时视频编解码的利器
gitblog_00736的博客
08-08 631
OpenH264：实时视频编解码的利器 openh264Open Source H.264 Codec 项目地址:https://gitcode.com/gh_mirrors/op/openh264 项目介绍 OpenH264 是一个支持 H.264 编码和解码的音视频编解码库，适用于实时应用场景，如 WebRTC。该项目由 Cisco 开发并维护，旨在提供一个高效、稳定的 H.264 编解码解...
openh264 编码器源码分析：AnalyzePictureComplexity 函数
世界那么大，我想去看看～
06-12 1237
openh264 编码器源码分析：AnalyzePictureComplexity 函数
视频知识点（15）- 一文搞懂 OpenH264 编码库
liuzhen007的专栏
04-17 1071
目录 前言 正文 1. 下载OpenH264源码 2. Windows平台编译环境搭建 2.1 安装vs2019 2.2 安装windows SDK 2.3 安装MinGW-w64 2.4 安装nasm 3. 正式编译 4. 疑难问题 4.1 报错：bash: make: command not found 4.2 报错：./gmp-api: No such file or directory. 5. 参考评价 5.1官方脚本： 5.2自定义命令 《音视频开发》系列-..
通过 OpenH264 启用 H.264 编码
09-12
OpenH264 是一个开源的 H.264 视频编码库，它提供了一种高效的方式来启用 H.264 编码。H.264 是一种广泛应用于视频压缩的标准，支持高清晰度和更高效的比特率利用。下面是启用 OpenH264 进行 H.264 编码的基本步骤： 1. **下载和集成**：首先，你需要从 OpenH264 的 GitHub 仓库 (https://github.com/cisco/openh264) 下载源代码并将其集成到你的项目中。 2. **配置编译选项**：在构建过程中，确保包含必要的编译标志，如 `-DHAVE_LIBopenh264=ON` 或 `-DWITH_OPENH264=ON`，以便编译时链接 OpenH264 库。 3. **初始化编码器**：在程序中，创建 `AVCodecContext` 对象，并设置其编码器类型为 `AV_CODEC_ID_H264`。例如： ```cpp AVCodec *codec = avcodec_find_encoder(AV_CODEC_ID_H264); if (!codec) { // 处理找不到编码器的情况 } AVCodecContext *ctx = avcodec_alloc_context3(codec); ctx->codec_id = AV_CODEC_ID_H264; ``` 4. **初始化帧**：创建帧结构体 `AVFrame`，用于存储视频数据，并设置编码参数。 5. **编码过程**：调用 `avcodec_encode_video2()` 函数来进行实际的编码操作，传入编码上下文、帧指针以及编码参数。 ```cpp int ret; while ((ret = avcodec_encode_video2(ctx, outbuf, &frame, frame_flags)) >= 0) { // 编码成功，处理编码后的数据 } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值