重构XEncode添加基类XCodec并完成XDecode封装

已于 2022-04-22 22:02:40 修改
阅读量1.9k 收藏 1
点赞数
分类专栏： 音视频 文章标签： 音视频
于 2022-04-22 22:02:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52484093/article/details/124355907
版权

XCodec 封装重构

XDecode 封装

XCodec.h

#pragma once

#include <mutex>
#include <vector>

struct AVCodec;
struct AVCodecContext;
struct AVFrame;
struct AVPacket;

void PrintError(int err);

class XCodec
{
public:
	XCodec();
	//
	/// 创建编码上下文
	/// @para codec_id 编码器ID号，对应ffmpeg
	/// @return 编码上下文 ,失败返回nullptr
	static AVCodecContext* Create(int codec_id, bool is_encoder = true);

	//
	/// 设置对象的编码器上下文 上下文传递到对象中，资源由XEncode维护
	/// 加锁 线程安全
	/// @para context 编码器上下文 如果context不为nullptr，则先清理资源
	void setContext(AVCodecContext* context);

	/
	/// 设置编码参数，线程安全
	bool setOpt(const char* key, const char* value);
	bool setOpt(const char* key, int value);

	//
	/// 打开编码器 线程安全
	bool open();

	///
	//根据AVCodecContext 创建一个AVFrame，需要调用者释放av_frame_free
	AVFrame* createFrame();

protected:
	std::mutex m_mtx;			// 编码器上下文锁
	AVCodecContext* m_context;	// 编码器上下文
};

 XCodec.cpp

#include "XCodec.h"
#include <iostream>

extern "C"  // 指定函数是 C 语言函数，函数目标名不包含重载标识，C++ 中调用 C 函数需要使用 extern "C"
{
	// 引用 ffmpeg 头文件
#include "libavcodec/avcodec.h"
#include "libavutil/opt.h"
}

// 预处理指令导入库
#pragma comment(lib, "avcodec.lib")
#pragma comment(lib, "avutil.lib")

using namespace std;

void PrintError(int err)
{
	char buf[1024] = { 0 };

	av_strerror(err, buf, sizeof(buf) - 1);
	cerr << buf << endl;
}

XCodec::XCodec()
{
	m_context = nullptr;
}

AVCodecContext* XCodec::Create(int codec_id, bool is_encoder)
{
	AVCodec* codec = nullptr;
	AVCodecContext* context = nullptr;

	if (is_encoder)
	{
		codec = avcodec_find_encoder(static_cast<AVCodecID>(codec_id));
	}
	else
	{
		codec = avcodec_find_decoder(static_cast<AVCodecID>(codec_id));
	}

	if (codec != nullptr)
	{
		context = avcodec_alloc_context3(codec);

		if (context != nullptr)
		{
			context->pix_fmt = AV_PIX_FMT_YUV420P;  // 源数据像素格式，与编码算法相关
			context->time_base = { 1, 25 };  // 帧时间戳的时间单位  pts*time_base = 播放时间（秒） 分数 1/25
			context->thread_count = 16;  // 编码线程数，可以通过调用系统接口获取cpu核心数量
		}
		else
		{
			cerr << "avcodec_alloc_context3 failed!" << endl;
		}
	}
	else
	{
		cerr << "avcodec_find_encoder failed! " << "avcodec_id = " << codec_id << endl;
	}

	return context;
}

void XCodec::setContext(AVCodecContext* context)
{
	if (context != nullptr)
	{
		unique_lock<mutex> context_mtx(m_mtx);

		if (m_context != nullptr)
		{
			avcodec_free_context(&m_context);
		}

		m_context = context;
	}
}

bool XCodec::setOpt(const char* key, const char* value)
{
	bool ret = false;
	int err = 0;
	unique_lock<mutex> context_mtx(m_mtx);

	if ((m_context != nullptr) && (key != nullptr) && (value != nullptr))
	{
		err = av_opt_set(m_context->priv_data, key, value, 0);

		if (err == 0)
		{
			ret = true;
		}
		else
		{
			PrintError(err);
		}
	}

	return ret;
}

bool XCodec::setOpt(const char* key, int value)
{
	bool ret = false;
	int err = 0;
	unique_lock<mutex> context_mtx(m_mtx);

	if ((m_context != nullptr) && (key != nullptr))
	{
		err = av_opt_set_int(m_context->priv_data, key, value, 0);

		if (err == 0)
		{
			ret = true;
		}
		else
		{
			PrintError(err);
		}
	}

	return ret;
}

bool XCodec::open()
{
	bool ret = false;
	int err = 0;
	unique_lock<mutex> context_mtx(m_mtx);

	if (m_context != nullptr)
	{
		err = avcodec_open2(m_context, nullptr, nullptr);;

		if (err == 0)
		{
			ret = true;
		}
		else
		{
			PrintError(err);
		}
	}

	return ret;
}

AVFrame* XCodec::createFrame()
{
	AVFrame* ret = nullptr;
	int err = 0;
	unique_lock<mutex> context_mtx(m_mtx);

	if (m_context != nullptr)
	{
		ret = av_frame_alloc();
		ret->width = m_context->width;
		ret->height = m_context->height;
		ret->format = m_context->pix_fmt;
		err = av_frame_get_buffer(ret, 0);

		if (err != 0)
		{
			PrintError(err);
			av_frame_free(&ret);
		}
	}

	return ret;
}

XEncode.h

#pragma once

#include "XCodec.h"

struct AVCodec;
struct AVCodecContext;
struct AVFrame;
struct AVPacket;

class XEncode : public XCodec
{
public:
	//
	/// 编码数据 线程安全 每次新创建AVPacket
	/// @para frame 空间由用户维护
	/// @return 失败范围nullptr 返回的AVPacket用户需要通过av_packet_free 清理
	AVPacket* encode(AVFrame* frame);

	//
	//返回所有编码缓存中AVPacket
	std::vector<AVPacket*> end();
};

XEncode.cpp

#include "XEncode.h"
#include <iostream>

extern "C"  // 指定函数是 C 语言函数，函数目标名不包含重载标识，C++ 中调用 C 函数需要使用 extern "C"
{
	// 引用 ffmpeg 头文件
#include "libavcodec/avcodec.h"
#include "libavutil/opt.h"
}

using namespace std;

AVPacket* XEncode::encode(AVFrame* frame)
{
	AVPacket* ret = nullptr;
	int err = 0;
	unique_lock<mutex> context_mtx(m_mtx);

	if ((m_context != nullptr))
	{	
		err = avcodec_send_frame(m_context, frame);

		if (err == 0)
		{
			ret = av_packet_alloc();
			err = avcodec_receive_packet(m_context, ret);


			// 没能够获取编码数据
			if (err != 0)
			{
				if ((err != AVERROR(EAGAIN)) && (err != AVERROR_EOF))
				{
					PrintError(err);
				}

				av_packet_free(&ret);
			}
		}
		else
		{
			PrintError(err);
		}
	}

	return ret;
}

vector<AVPacket*> XEncode::end()
{
	vector<AVPacket*> ret;
	int err = 0;
	unique_lock<mutex> context_mtx(m_mtx);

	if (m_context != nullptr)
	{
		AVPacket* packet = nullptr;

		err = avcodec_send_frame(m_context, nullptr);  // 发送NULL 获取缓冲

		if (err == 0)
		{
			while (err == 0)
			{
				packet = av_packet_alloc();
				err = avcodec_receive_packet(m_context, packet);

				if (err == 0)
				{
					ret.push_back(packet);
				}
				else
				{
					if ((err != AVERROR(EAGAIN)) && (err != AVERROR_EOF))
					{
						PrintError(err);
					}

					av_packet_free(&packet);
				}
			}
		}
		else
		{
			PrintError(err);
		}
	}

	return ret;
}

XDecode.h

#pragma once
#include "XCodec.h"
#include <vector>

struct AVFrame;
struct AVPacket;

class XDecode : public XCodec
{
public:

	
	 初始化硬件加速  4 AV_HWDEVICE_TYPE_DXVA2
	bool initHW(int type = 4);
	bool send(AVPacket* packet);
	bool recv(AVFrame* frame);
	std::vector<AVFrame*> end();
};

XDecode.cpp

#include "XDecode.h"
#include <iostream>

extern "C"  // 指定函数是 C 语言函数，函数目标名不包含重载标识，C++ 中调用 C 函数需要使用 extern "C"
{
	// 引用 ffmpeg 头文件
#include "libavcodec/avcodec.h"
#include "libavutil/opt.h"
}

using namespace std;

bool XDecode::initHW(int type)
{
	bool ret = false;
	int err = 0;
	AVBufferRef* ctx_ref = nullptr;
	unique_lock<mutex> context_mtx(m_mtx);

	err = av_hwdevice_ctx_create(&ctx_ref, static_cast<AVHWDeviceType>(type), nullptr, nullptr, 0);

	if (err == 0)
	{
		m_context->hw_device_ctx = ctx_ref;
	}
	else
	{
		PrintError(err);
	}

	return ret;
}

bool XDecode::send(AVPacket* packet)
{
	bool ret = false;
	int err = 0;
	unique_lock<mutex> context_mtx(m_mtx);

	if (m_context != nullptr)
	{
		err = avcodec_send_packet(m_context, packet);

		if (err == 0)
		{
			ret = true;
		}
		else
		{
			PrintError(err);
		}
	}

	return ret;
}

bool XDecode::recv(AVFrame* frame)
{
	bool ret = false;
	int err = 0;
	unique_lock<mutex> context_mtx(m_mtx);

	if ((m_context != nullptr) && (frame != nullptr))
	{

		if (m_context->hw_device_ctx == nullptr)
		{
			err = avcodec_receive_frame(m_context, frame);
		}
		else  // GPU 解码
		{
			AVFrame* tmp = av_frame_alloc();

			err = avcodec_receive_frame(m_context, tmp);

			if (err == 0)
			{
				err = av_hwframe_transfer_data(frame, tmp, 0);  // 显存转内存 GPU =》 CPU
			}

			av_frame_free(&tmp);
		}

		if (err == 0)
		{
			ret = true;
		}
		else
		{
			if ((err != AVERROR(EAGAIN)) && (err != AVERROR_EOF))
			{
				PrintError(err);
			}
		}
	}

	return ret;
}

std::vector<AVFrame*> XDecode::end()
{
	vector<AVFrame*> ret;
	int err = 0;
	unique_lock<mutex> context_mtx(m_mtx);

	if (m_context != nullptr)
	{
		AVFrame* frame = nullptr;

		err = avcodec_send_packet(m_context, nullptr);  // 发送NULL 获取缓冲

		if (err == 0)
		{
			while (err == 0)
			{
				frame = av_frame_alloc();

				if (m_context->hw_device_ctx == nullptr)
				{
					err = avcodec_receive_frame(m_context, frame);
				}
				else  // GPU 解码
				{
					AVFrame* tmp = av_frame_alloc();

					err = avcodec_receive_frame(m_context, tmp);

					if (err == 0)
					{
						err = av_hwframe_transfer_data(frame, tmp, 0);
					}

					av_frame_free(&tmp);
				}

				if (err == 0)
				{
					ret.push_back(frame);
				}
				else
				{
					if ((err != AVERROR(EAGAIN)) && (err != AVERROR_EOF))
					{
						PrintError(err);
					}

					av_frame_free(&frame);
				}
			}
		}
		else
		{
			PrintError(err);
		}
	}

	return ret;
}

120_test_xdecode.cpp

#include <iostream>
#include <fstream>
#include "XVideoView.h"
#include "XSDL.h"
#include "XDecode.h"

using namespace std;

extern "C"  // 指定函数是 C 语言函数，函数目标名不包含重载标识，C++ 中调用 C 函数需要使用 extern "C"
{
	// 引用 ffmpeg 头文件
	#include "libavcodec/avcodec.h"
}

// 预处理指令导入库
#pragma comment(lib, "avcodec.lib")
#pragma comment(lib, "avutil.lib")

int main()
{
	//1 分割h264 存入AVPacket
	// ffmpeg -i v1080.mp4 -s 400x300 test.h264
	string file_name = "test.h264";
	ifstream ifs;
	AVCodec* codec = nullptr;
	AVCodecID codec_id = AV_CODEC_ID_H264;
	AVCodecContext* context = nullptr;
	AVCodecParserContext* parser = nullptr;
	AVPacket* packet = nullptr;
	AVFrame* frame = nullptr;
	unsigned char inbuf[4096] = { 0 };
	int inbuf_len = 0;
	int ret = 0;
	long long begin = 0;
	int cnt = 0;  // 解码的帧率
	XVideoView* view = XVideoView::Create();
	bool first_init = false;
	AVHWDeviceType dev_type = AV_HWDEVICE_TYPE_DXVA2;  // 硬件加速格式 DXVA2
	XDecode de;
	vector<AVFrame*> vec;

	ifs.open(file_name, ios::in | ios::binary);

	if (!ifs)
	{
		return -1;
	}

	context = de.Create(codec_id, false);

	if (context != nullptr)
	{
		de.setContext(context);
		de.initHW();
		de.open();
	}

	// 分割上下文
	parser = av_parser_init(codec_id);

	if (parser == nullptr)
	{
		cerr << "av_parser_init failed!" << endl;

		return -1;
	}

	packet = av_packet_alloc();

	frame = av_frame_alloc();

	begin = NowMs();

	while (!ifs.eof())
	{
		int len = 0;
		unsigned char* data = inbuf;

		ifs.read((char*)inbuf, sizeof(inbuf));
		len = ifs.gcount();  // 读取的字节数

		if (ifs.eof())
		{
			// ifs.clear();
			// ifs.seekg(0, ios::beg);
		}

		while (len > 0)
		{
			// 通过 0001 截断输出到AVPacket 如果满足一个 AVPackret 则返回这个 AVPacket 的大小 不足一个AVPactet 则返回余下的数据大小 不足一个AVPactet的数据会被缓存起来
			int in_len = av_parser_parse2(parser, context,
				&packet->data, &packet->size,  // 输出
				data, len,					   // 输入
				AV_NOPTS_VALUE, AV_NOPTS_VALUE, 0
			);

			data += in_len;
			len -= in_len;

			if (packet->size > 0)
			{
				// cout << packet->size << " " << flush;

				//发送packet到解码线程
				if (!de.send(packet))
				{
					cerr << "avcodec_send_packet failed!" << endl;
					break;
				}

				/* 获取多帧解码数据 */
				while (de.recv(frame))
				{
					long long curr = NowMs();

					cnt++;

					if (curr - begin >= 1000)
					{
						cout << "FPS = " << cnt << endl;
						cnt = 0;
						begin = curr;
					}

					if (!first_init)
					{
						view->init(frame->width, frame->height, static_cast<XVideoView::PixelFormat>(frame->format));
						first_init = true;
					}

					view->drawAVFrame(frame);  // 渲染
				}
			}
		}
	}

	/* 取出缓存数据 */
	vec = de.end();

	for (int i = 0; i < vec.size(); i++)
	{
		view->drawAVFrame(vec[i]);
		av_frame_free(&vec[i]);
	}

	av_frame_free(&frame);
	av_packet_free(&packet);
	av_parser_close(parser);
	avcodec_free_context(&context);
	ifs.close();
	view->close();
	delete view;

	return 0;
}

该测试程序将 .h264 文件解析出一个个 AVPacket，然后解码出 AVFrame，并进行渲染。

qq_52484093
关注
专栏目录
xdecode32.obj
09-01
xdecode32.obj
X-Decoder
whaosoft143ai的博客
05-23 285
本文提供了一种广义的解码器X-Decoder，能够无缝支持像素级和图像级视觉-语言理解的模型。通过简洁而通用的设计，X-Decoder 可以轻松地统一和支持通用分割、引用分割和视觉-语言任务，实现了强大的泛化能力和竞争性甚至是最先进的性能。 作者希望这项工作能够为下一代通用视觉系统的设计提供启示，但就目前来看，X-Decoder虽然在实现像素级和图像级视觉-语言理解方面具有很大的潜力，并在多个任务中展现了强大的性能和泛化能力，但是笔者认为。whaosoft aiot http://143ai.com
X-Decoder：像素、图像与语言的通用解码器
最新发布
gitblog_00722的博客
08-12 253
X-Decoder：像素、图像与语言的通用解码器 X-Decoder[CVPR 2023] Official Implementation of X-Decoder for generalized decoding for pixel, image and language项目地址:https://gitcode.com/gh_mirrors/xd/X-Decoder 项目介绍 X-Decode...
Python-XDecoder是一种轻型ASR自动语音识别解码器框架
08-11
XDecoder是一种轻型ASR（自动语音识别）解码器框架。 X意味着增强，快速和便携。 我们的目标是在低资源系统上运行LVCSR（大词汇量连续语音识别），特别是在移动电话和其他嵌入设备上。
微软提出通用解码器 X-Decoder，支持图像分割和语言分词
ZILLIZ
01-09 790
微软提出通用解码器 X-Decoder，支持图像分割和语言分词
论文阅读——X-Decoder
weixin_43575791的博客
12-25 1468
对于mask classification，包括“background”在内C个类别编码为C个文本查询，提取每个查询最后一个有效特征作为概念表示，然后取对应前（m-1）个潜在查询的decoder输出，计算这些输出和概念表示的点乘，得到。其中，对第一个公式，所有查询和视觉特征做交叉注意力，对于潜在查询，使用masked cross-attention mechanism，对文本查询使用全部注意力。对，m个潜在查询输出mask，对于语义输出，为潜在查询和文本查询预测输出，，文本T经过text encoder。
封装ef基类框架
04-03
分享一下 使用EF时，对增删改查基本操作的封装代码 ef重构基类;抛砖引玉,仅供参考; ef增删改差扩展方法!
一个规范flutter生命周期的Widget基类并且封装了基本属性加快开发速度
08-10
`flutter_BaseWidget-master`这个压缩包可能包含了一个自定义的Widget基类，它旨在优化Flutter应用的生命周期管理并提供一些基本属性的预设，以提升开发效率。下面我们将深入探讨Flutter中的Widget生命周期、基类的...
C#基类 常用工具类等等。封装的特别好。
02-08
在C#中，基类通过`:`后接类名并使用`public`或`protected`关键字声明继承关系。例如，`class DerivedClass : BaseClass`表示`DerivedClass`继承自`BaseClass`。基类可以包含虚方法（`virtual`），子类可以通过`...
EF增删改查封装基类
12-26
这是我写的Entityframework的增删该查封装基类，如果你要使用EF开发项目，只要把需要增删改查的类继承这个基类，就可以轻松做到。敬请参考，不到之处请多多指正。
C抽象基类和纯虚成员函数-C教程共3页.pdf.zip
11-22
本教程“C抽象基类和纯虚成员函数”共3页，将深入讲解这些主题，帮助开发者更好地理解和运用这些高级特性。 首先，让我们理解抽象基类。抽象基类是一种特殊的类，它定义了一个接口，但不能被实例化。在C++中，一个...
Xencode Postbuild 2010 for .NET.rar
10-26
.net程序混淆器，保护.net程序源代码不被翻译。
xenocode解码工具
04-19
xenocode解码工具EnXenoCode xenocode解码工具EnXenoCode
Xenocode+Postbuild+2010+授权码（已测试）
09-06
已测试过，可用，可以将.net工程打包成为一个exe程序，脱离.net framework框架.
播放器实战16 xdecode类
qq_42567607的博客
02-06 1151
音频与视频解封装用一个同一个类，解码各用各的类，因此实例化了两个decode，以视频解码器为例： 01.先实例化：xdecode vdecode; 02.再将解封装获得的视频参数复制一份，做为参数传给vdecode：vdecode.open(demux.CopyVPara())
CVPR 2023 | X-Decoder: 下一代通用编解码视觉架构设计范式
CV_Autobot的博客
05-20 505
作者|派派星 编辑|CVHub点击下方卡片，关注“自动驾驶之心”公众号ADAS巨卷干货，即可获取点击进入→自动驾驶之心【全栈算法】技术交流群Title: X-Decoder: Generalized Decoding for Pixel, Image and LanguagePaper: https://arxiv.org/pdf/2212.11270.pdfCode: https://...
XenoCode 使用方法
蓝叶菱的专栏
01-07 4090
http://www.cnblogs.com/swjm119/archive/2011/12/08/2280655.html 文章转载自网络   用法一：           1、导入要加密的dotNET程序或assembly文件(.dll/.exe)      2、选择第二个选项卡“Protect”      3、点击“Select   Pattern”
Xenocode Postbuild 2010 for .NET 混淆工具的详细使用步骤
热门推荐
李艳平
09-19 1万+
1，首先我们需要去下载这个工具去，我这里倒是有一个下载的网址，已经被破解了，而且有序列号 http://download.csdn.net/tag/Xenocode+Postbuild+2010+for+.NET/orderbydownloads           下载的时候选择第一个，带序列号的！           下载到本地---解压：如下
EF基类封装：增删改查操作实践
这个基类名为`Parent<T>`，适用于任何继承自`class`的类型`T`，并利用EF的DbContext进行数据库操作。" 在.NET开发中，Entity Framework是一种常见的对象关系映射（ORM）工具，它允许开发者使用面向对象的方式来操作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值