FFmpeg中libavutil库简介及测试代码

最新推荐文章于 2024-08-13 13:43:58 发布
最新推荐文章于 2024-08-13 13:43:58 发布
阅读量4.2k 收藏 3
点赞数
分类专栏： VLC/FFmpeg/LIVE555
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fengbingchun/article/details/90313219
版权

libavutil是一个实用库，用于辅助多媒体编程。此库包含安全的可移植字符串函数、随机数生成器、数据结构、附加数学函数、加密和多媒体相关功能(如像素和样本格式的枚举)。libavcodec和libavformat并不依赖此库。

以下是测试代码，包括base64, aes, des, hash, log, md5, sha, sha512, tea, twofish, xteaa。

funset.hpp:

#ifndef FBC_FFMPEG_TEST_FUNSET_HPP_
#define FBC_FFMPEG_TEST_FUNSET_HPP_

// libavutil
int test_ffmpeg_libavutil_xtea(); // XTEA(eXtended Tiny Encryption Algorithm)
int test_ffmpeg_libavutil_twofish(); // Twofish crypto algorithm
int test_ffmpeg_libavutil_tea(); // TEA(Tiny Encryption Algorithm)
int test_ffmpeg_libavutil_sha512(); // SHA(Secure Hash Algorithm), SHA-512/224, SHA-512/256, SHA-384, SHA-512 
int test_ffmpeg_libavutil_sha(); // SHA(Secure Hash Algorithm), SHA-1, SHA-224, SHA-256 
int test_ffmpeg_libavutil_md5(); // MD5
int test_ffmpeg_libavutil_log(); // Log
int test_ffmpeg_libavutil_hash(); // hash function
int test_ffmpeg_libavutil_des(); // DES symmetric encryption algorithm
int test_ffmpeg_libavutil_aes(); // AES symmetric encryption algorithm
int test_ffmpeg_libavutil_base64(); // base64 codec

#endif // FBC_FFMPEG_TEST_FUNSET_HPP_

test_ffmpeg_libavutil.cpp:

#include "funset.hpp"
#include <string.h>
#include <iostream>
#include <string>
#include <memory>
#include <vector>

#ifdef __cplusplus
extern "C" {
#endif

#include <libavutil/base64.h>
#include <libavutil/aes.h>
#include <libavutil/mem.h>
#include <libavutil/des.h>
#include <libavutil/hash.h>
#include <libavutil/log.h>
#include <libavutil/md5.h>
#include <libavutil/sha.h>
#include <libavutil/sha512.h>
#include <libavutil/tea.h>
#include <libavutil/xtea.h>
#include <libavutil/twofish.h>

#ifdef __cplusplus
}
#endif

int test_ffmpeg_libavutil_xtea()
{
	const char* src = "https://blog.csdn.net/fengbingchun";
	const uint8_t key[16] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF};
	
	size_t length = strlen(src);
	int blocks_count = (length + 7) / 8; // count number of 8 byte blocks
	std::unique_ptr<uint8_t[]> cipher_text(new uint8_t[blocks_count * 8]), plain_text(new uint8_t[blocks_count * 8]);
	fprintf(stdout, "src length: %d, blocks_count: %d\n", length, blocks_count);
	
	// encrypt
	AVXTEA* ctx1 = av_xtea_alloc();
	if (!ctx1) {
		fprintf(stderr, "fail to av_xtea_alloc\n");
		return -1;
	}
	
	av_xtea_init(ctx1, key);
	av_xtea_crypt(ctx1, cipher_text.get(), (const uint8_t*)src, blocks_count, nullptr, 0);
	av_free(ctx1);

	// decrypt
	AVXTEA* ctx2 = av_xtea_alloc();
	if (!ctx2) {
		fprintf(stderr, "fail to av_xtea_alloc\n");
		return -1;
	}
	
	av_xtea_init(ctx2, key);
	av_xtea_crypt(ctx2, plain_text.get(), (const uint8_t*)cipher_text.get(), blocks_count, nullptr, 1);
	av_free(ctx2);

	fprintf(stdout, "src data: %s\n", src);
	fprintf(stdout, "cipher text: %s\n", (const char*)cipher_text.get());
	fprintf(stdout, "plain text: %s\n", (const char*)plain_text.get());
	
	if (memcmp(src, (const char*)plain_text.get(), length)) {
		fprintf(stderr, "fail to xtea encrypt/decrypt\n");
		return -1;
	}	

	return 0;
}

int test_ffmpeg_libavutil_twofish()
{
	return -1;
	
	// the execution result is incorrect, i don't know why ???
	const char* src = "https://blog.csdn.net/fengbingchun";
	const uint8_t key[32] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff};
	const int key_bits = 256; // 128, 192, 256
	size_t length = strlen(src);
	int blocks_count = (length + 15) / 16; // count number of 16 byte blocks
	std::unique_ptr<uint8_t[]> cipher_text(new uint8_t[blocks_count * 16]), plain_text(new uint8_t[blocks_count * 16]);
	fprintf(stdout, "src length: %d, blocks_count: %d\n", length, blocks_count);
	uint8_t iv[16];
	memcpy(iv, "HALLO123HALLO123", 16);
	
	// encrypt
	AVTWOFISH* ctx1 = av_twofish_alloc();
	if (!ctx1) {
		fprintf(stderr, "fail to av_twofish_alloc\n");
		return -1;
	}
	
	av_twofish_init(ctx1, key, key_bits);
	av_twofish_crypt(ctx1, cipher_text.get(), (const uint8_t*)src, blocks_count, /*iv*/nullptr, 0);
	av_free(ctx1);

	if (blocks_count * 16 > length)
		cipher_text[length] = '\0';

	// decrypt
	AVTWOFISH* ctx2 = av_twofish_alloc();
	if (!ctx2) {
		fprintf(stderr, "fail to av_twofish_alloc\n");
		return -1;
	}
	
	av_twofish_init(ctx2, key, key_bits);
	av_twofish_crypt(ctx2, plain_text.get(), (uint8_t*)cipher_text.get(), blocks_count, /*iv*/nullptr, 1);
	av_free(ctx2);

	if (blocks_count * 16 > length)
		plain_text[length] = '\0';

	fprintf(stdout, "src data: %s\n", src);
	fprintf(stdout, "cipher text: %s\n", (const char*)cipher_text.get());
	fprintf(stdout, "plain text: %s\n", (const char*)plain_text.get());
	
	if (memcmp(src, (const char*)plain_text.get(), length)) {
		fprintf(stderr, "fail to twofish encrypt/decrypt\n");
		return -1;
	}	

	return 0;
}

int test_ffmpeg_libavutil_tea()
{
	const char* src = "https://blog.csdn.net/fengbingchun";
	const uint8_t key[16] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF};
	
	size_t length = strlen(src);
	int blocks_count = (length + 7) / 8; // count number of 8 byte blocks
	std::unique_ptr<uint8_t[]> cipher_text(new uint8_t[blocks_count * 8]), plain_text(new uint8_t[blocks_count * 8]);
	fprintf(stdout, "src length: %d, blocks_count: %d\n", length, blocks_count);
	
	// encrypt
	struct AVTEA* ctx1 = av_tea_alloc();
	if (!ctx1) {
		fprintf(stderr, "fail to av_tea_alloc\n");
		return -1;
	}
	
	av_tea_init(ctx1, key, 64);
	av_tea_crypt(ctx1, cipher_text.get(), (const uint8_t*)src, blocks_count, nullptr, 0);
	av_free(ctx1);

	// decrypt
	struct AVTEA* ctx2 = av_tea_alloc();
	if (!ctx2) {
		fprintf(stderr, "fail to av_tea_alloc\n");
		return -1;
	}
	
	av_tea_init(ctx2, key, 64);
	av_tea_crypt(ctx2, plain_text.get(), (const uint8_t*)cipher_text.get(), blocks_count, nullptr, 1);
	av_free(ctx2);

	fprintf(stdout, "src data: %s\n", src);
	fprintf(stdout, "cipher text: %s\n", (const char*)cipher_text.get());
	fprintf(stdout, "plain text: %s\n", (const char*)plain_text.get());
	
	if (memcmp(src, (const char*)plain_text.get(), length)) {
		fprintf(stderr, "fail to tea encrypt/decrypt\n");
		return -1;
	}	
	
	return 0;
}

int test_ffmpeg_libavutil_sha512()
{
	const int hash_length[4] = {224, 256, 384, 512}; // SHA-512/224, SHA-512/256, SHA-384, SHA-512
	const char* src = "https://blog.csdn.net/fengbingchun";

	struct AVSHA512* ctx = av_sha512_alloc();
	if (!ctx) {
		fprintf(stderr, "fail to av_sha512_alloc\n");
		return -1;
	}

	for (int i = 0; i < 4; ++i) {
		unsigned char digest[64];

		av_sha512_init(ctx, hash_length[i]);
		av_sha512_update(ctx, (const uint8_t*)src, strlen(src));
		av_sha512_final(ctx, digest);				
	
		fprintf(stdout, "sha512: ");
		//for (int j = 0; j < 64; ++j)
		for (int j = 0; j < hash_length[i] >> 3; ++j)
			fprintf(stdout, "%02x", digest[j]);
		fprintf(stdout, "\n");
	}

	av_free(ctx);
	
	return 0;
}

int test_ffmpeg_libavutil_sha()
{
	const int hash_length[3] = {160, 224, 256}; // SHA-1, SHA-224, SHA-256
	const char* src = "https://blog.csdn.net/fengbingchun";

	struct AVSHA* ctx = av_sha_alloc();
	if (!ctx) {
		fprintf(stderr, "fail to av_sha_alloc\n");
		return -1;
	}

	for (int i = 0; i < 3; ++i) {
		unsigned char digest[32];

		av_sha_init(ctx, hash_length[i]);
		av_sha_update(ctx, (const uint8_t*)src, strlen(src));
		av_sha_final(ctx, digest);				
	
		fprintf(stdout, "sha: ");
		//for (int j = 0; j < 32; ++j)
		for (int j = 0; j < hash_length[i] >> 3; ++j)
			fprintf(stdout, "%02x", digest[j]);
		fprintf(stdout, "\n");
	}

	av_free(ctx);
	
	return 0;
}

int test_ffmpeg_libavutil_md5()
{
	const char* src = "https://blog.csdn.net/fengbingchun";
	uint8_t md5val[16];

	av_md5_sum(md5val, (const uint8_t*)src, strlen(src));

	fprintf(stdout, "md5sum: ");
	for (int i = 0; i < 16; ++i)
		fprintf(stdout, "%02x", md5val[i]);
	fprintf(stdout, "\n");

	return 0;
}

int test_ffmpeg_libavutil_log()
{
	av_log_set_level(AV_LOG_TRACE);

	av_log(nullptr, AV_LOG_TRACE, "trace message\n");
	av_log(nullptr, AV_LOG_DEBUG, "debug message\n");
	av_log(nullptr, AV_LOG_VERBOSE, "verbose message\n");
	av_log(nullptr, AV_LOG_INFO, "info message\n");
	av_log(nullptr, AV_LOG_WARNING, "warning message\n");
	av_log(nullptr, AV_LOG_ERROR, "error message\n");
	av_log(nullptr, AV_LOG_FATAL, "fatal message\n");
	av_log(nullptr, AV_LOG_PANIC, "panic message\n");

	return 0;
}

int test_ffmpeg_libavutil_hash()
{
	std::vector<const char*> hash_names;
	int index = 0;

	do {
		hash_names.push_back(av_hash_names(index));
		++index;
	} while(hash_names[hash_names.size()-1]);

	fprintf(stdout, "supported hash algorithms: ");
	for (auto name : hash_names) {
		if (name)
			fprintf(stdout, "%s,  ", name);
	}
	fprintf(stdout, "\n");

	const char* src[2] = {"https://blog.csdn.net/fengbingchun", "https://github.com/fengbingchun"};
	int dst_buf_size = AV_HASH_MAX_SIZE * 8;

	for (int i = 0; i < 2; ++i) {
		struct AVHashContext* ctx = nullptr;
		if (av_hash_alloc(&ctx, hash_names[i]) < 0) {
			fprintf(stderr, "fail to av_hash_alloc: %d\n", i);
			return -1;
		}

		av_hash_init(ctx);
	
		av_hash_update(ctx, (const uint8_t*)src[i], strlen(src[i]));

		std::unique_ptr<uint8_t[]> dst(new uint8_t[dst_buf_size]);
		memset(dst.get(), 0, dst_buf_size);

		av_hash_final_hex(ctx, dst.get(), dst_buf_size);
		fprintf(stdout, "hash name: %s, hex: %s\n", av_hash_get_name(ctx), dst.get());

		av_hash_freep(&ctx);
	}

	return 0;
}

int test_ffmpeg_libavutil_des()
{
	const uint8_t key[16] = { 0x10, 0xa5, 0x88, 0x69, 0xd7, 0x4b, 0xe5, 0xa3, 0x74, 0xcf, 0x86, 0x7c, 0xfb, 0x47, 0x38, 0x59 };
	const std::string src = "https://blog.csdn.net/fengbingchun";
	size_t length = src.length();
	int blocks_count = (length + 7) / 8; // count number of 8 byte blocks
	std::unique_ptr<uint8_t[]> cipher_text(new uint8_t[blocks_count * 8]), plain_text(new uint8_t[blocks_count * 8]);
	fprintf(stdout, "src length: %d, blocks_count: %d\n", length, blocks_count);

	// encryption
	struct AVDES b1;
	av_des_init(&b1, key, 64, 0);
	av_des_crypt(&b1, cipher_text.get(), (const uint8_t*)src.c_str(), blocks_count, nullptr, 0);
	fprintf(stdout, "src data: %s\n", src.c_str());
	fprintf(stdout, "cipher text: %s\n", (const char*)cipher_text.get());

	// decryption
	struct AVDES b2;
	av_des_init(&b2, key, 64, 1);
	av_des_crypt(&b2, plain_text.get(), (const uint8_t*)cipher_text.get(), blocks_count, nullptr, 1);
	fprintf(stdout, "plain text: %s\n", (const char*)plain_text.get());

	if (memcmp(src.c_str(), (const char*)plain_text.get(), length)) {
		fprintf(stderr, "fail to des encrypt/decrypt\n");
		return -1;
	
	}

	return 0;
}

int test_ffmpeg_libavutil_aes()
{
	const uint8_t key[16] = { 0x10, 0xa5, 0x88, 0x69, 0xd7, 0x4b, 0xe5, 0xa3, 0x74, 0xcf, 0x86, 0x7c, 0xfb, 0x47, 0x38, 0x59 };
	const std::string src = "https://blog.csdn.net/fengbingchun";
	size_t length = src.length();
	int blocks_count = (length + 15) / 16; // count number of 16 byte blocks
	std::unique_ptr<uint8_t[]> cipher_text(new uint8_t[blocks_count * 16]), plain_text(new uint8_t[blocks_count * 16]);
	fprintf(stdout, "src length: %d, blocks_count: %d\n", length, blocks_count);

	// encryption
	struct AVAES* b1 = av_aes_alloc();
	if (!b1) {
		fprintf(stderr, "fail to av_aes_alloc\n");
		return -1;
	}
	av_aes_init(b1, key, 128, 0);
	av_aes_crypt(b1, cipher_text.get(), (const uint8_t*)src.c_str(), blocks_count, nullptr, 0);
	av_free(b1);
	fprintf(stdout, "src data: %s\n", src.c_str());
	fprintf(stdout, "cipher text: %s\n", (const char*)cipher_text.get());

	// decryption
	struct AVAES* b2 = av_aes_alloc();
	if (!b2) {
		fprintf(stderr, "fail to av_aes_alloc\n");
		return -1;
	}
	av_aes_init(b2, key, 128, 1);
	av_aes_crypt(b2, plain_text.get(), (const uint8_t*)cipher_text.get(), blocks_count, nullptr, 1);
	av_free(b2);
	fprintf(stdout, "plain text: %s\n", (const char*)plain_text.get());

	if (memcmp(src.c_str(), (const char*)plain_text.get(), length)) {
		fprintf(stderr, "fail to aes encrypt/decrypt\n");
		return -1;
	
	}

	return 0;
}

int test_ffmpeg_libavutil_base64()
{
	const std::string blog_addr = "https://blog.csdn.net/fengbingchun";
	int length_src = blog_addr.length();
	int length_dst = AV_BASE64_SIZE(length_src);
	std::unique_ptr<char[]> dst1(new char[length_dst]);

	char* tmp = av_base64_encode(dst1.get(), length_dst, (const uint8_t*)blog_addr.c_str(), length_src);
	if (!tmp) {
		fprintf(stderr, "fail to av_base64_encode\n");
		return -1;
	}

	int length_dst2 = AV_BASE64_DECODE_SIZE(length_dst);
	std::unique_ptr<uint8_t[]> dst2(new uint8_t[length_dst2]);
	int size = av_base64_decode(dst2.get(), dst1.get(), length_dst2);
	if (size < 0) {
		fprintf(stderr, "fail to av_base64_decode");
		return -1;
	}

	if (memcmp(blog_addr.c_str(), (const char*)dst2.get(), size)) {
		fprintf(stderr, "fail to base64 encode/decode\n");
		return -1;
	}

	if (length_dst2 > size)
		dst2.get()[size] = '\0';

	fprintf(stdout, "src string: %s\n", blog_addr.c_str());
	fprintf(stdout, "encode result: %s\n", dst1.get());
	fprintf(stdout, "decode result: %s\n", (char*)dst2.get());

	return 0;
}

其中test_ffmpeg_libavutil_xtea的执行结果如下：

GitHub： https://github.com/fengbingchun/OpenCV_Test 

fengbingchun
关注
专栏目录
FFmpeg入门详解之58：Libavutil详解：理论与实战
福优学苑@音视频+流媒体
09-28 931
libavutil是一个实用库，用于辅助多媒体编程。此库包含安全的可移植字符串函数、随机数生成器、数据结构、附加数学函数、加密和多媒体相关功能(如像素和样本格式的枚举)。libavcodec和libavformat并不依赖此库。从FFmpeg官网的文档-libavutil来看，avutil主要有一下几种功能：数学函数字符串操作内存管理相关数据结构相关错误码及错误处理日志输出其他辅助信息，比如密钥、哈希值、宏、库版本、常量等AVLogParseUtil。
以FLV解复用为例详解开源库FFmpeg中解复用器的源码逻辑及处理流程
最新发布
dvlinker的技术专栏
08-20 1万+
本文以FLV音视频解复用为例，详细讲解开源库FFmpeg中解复用器的源码逻辑及处理流程。
FFMPEG学习【libavutil】：视频相关
一世豁然的专栏
07-24 892
一、显示变换矩阵函数 显示变换矩阵指定应适用于视频帧以进行正确预处理的仿射变换。 它与存储在ISO / IEC 14496-12容器格式中的矩阵兼容。 数据是一个3x3矩阵，表示为9元素数组： | a b u | (a, b, u, c, d, v, x, y, w) -> | c d v |
avutil-56.dll文件丢失？深度解析印象笔记avutil-56.dll文件丢失原因及修复方法
czl922的博客
08-13 458
文件是印象笔记（Evernote）或某些相关软件依赖的动态链接库文件，它包含了许多程序运行所需的函数和资源。：在进行系统更新或软件升级时，有时新版本的软件会更改或替换旧的DLL文件，如果升级过程发生异常，可能会导致。：在安装印象笔记或其他相关软件时，如果安装过程被中断或安装包本身存在问题，可能会导致。：虽然较为罕见，但硬盘的物理损伤或逻辑问题也可能导致DLL文件的丢失或损坏。：用户在清理系统或进行其他操作时，可能会不小心删除重要的DLL文件，包括。：某些恶意软件可能会删除或破坏系统中的DLL文件，包括。
Libavutil详解：理论与实战
明天你好的博客
11-29 1630
libavutil 是一个实用库，用于辅助多媒体编程，本文记录 libavutil 库学习及 demo 例程展示。libavutil 是一个实用库，用于辅助多媒体编程。此库包含安全的可移植字符串函数、随机数生成器、数据结构、附加数学函数、加密和多媒体相关功能（如像素和样本格式的枚举）。libavcodec 和 libavformat 并不依赖此库。数学函数字符串操作内存管理相关数据结构相关错误码及错误处理日志输出其他辅助信息，比如密钥、哈希值、宏、库版本、常量等AVLog。
使用 FFmpeg 的 libavutil 库来处理图像数据，对图像进行缩放和改变像素格式
weixin_37718867的博客
08-07 597
*
编译FFMPEG错误对策
dhixes4080的博客
08-12 173
在MINGW32下编译ffmpeg-2.1.1.tar.bz2 step1: ./configure --prefix=/home/Administrator/install --extra-cflags=-I/home/Administrator/install/include --extra-ldflags=-L/home/Administrator/install/lib -...
支持xp的ffmpeg动态库及说明—-FFMPEG_XP.rar
03-24
动态链接库（dll）在运行时提供函数实现，而静态链接库（lib）则在编译时将FFmpeg的代码合并到你的应用程序中。确保正确配置你的编译环境，将这些库路径添加到系统路径或者项目配置中，以保证程序能够找到并使用它们...
FFmpeg_4.3.2 支持Android的音视频处理库
05-17
在Android中使用FFmpeg，通常需要将预编译的so库（静态库）复制到项目的jniLibs目录下，然后在Java代码中通过JNI（Java Native Interface）调用C/C++接口。你可以创建Java类，声明native方法，并使用NDK的javah工具...
FFmpeg_x64动态库测试程序
03-25
2. **包含头文件**：在源代码中，我们需要包含FFmpeg的头文件，以访问其提供的函数和结构体。例如： ```cpp #include #include #include <libavutil/avutil.h> ``` 3. **初始化FFmpeg**：在程序开始时，调用...
ffmpeg3.2.4_Win32开发库文件
06-03
2. **包含头文件**：在你的源代码中通过`#include`指令引入相应的头文件，以便使用FFmpeg的API。 3. **链接库**：在编译过程中，指定需要链接的静态库文件，确保编译器能够找到并连接库函数。 4. **编写代码**：...
vaapi ffmpeg
11-12
ffmpeg vaapi 需要的下载吧
Libavutil 7.0 文档
宋志辉的博客
04-06 88
libavutil 库是一个便携式多媒体编程的实用工具库。它包含安全的可移植字符串函数、随机数生成器、数据结构、额外的数学函数、密码学和多媒体相关功能（如像素和采样格式的枚举）。它不是一个同时被 libavcodec 和 libavformat 所需的代码库。有关作者的详细信息，请参阅项目的 Git 历史记录 (https://git.ffmpeg.org/ffmpeg)，例如在 FFmpeg 源代码目录中键入。命令，或在 https://git.ffmpeg.org/ffmpeg 浏览在线存储库。
FFMPEG学习【libavutil】：Memory Management（二）
一世豁然的专栏
07-18 891
负责分配，释放和复制内存的功能。 一、函数 void *  av_malloc (size_t size) av_malloc_attrib 1(1) 分配一个适合所有存储器访问的定向存储块（包括CPU上可用的向量）。 void *  av_mallocz (size_t size) av_mall
FFMPEG学习【libavutil】：Crypto and Hashing(三)
一世豁然的专栏
07-04 769
一、LZO 一)、宏 #define  AV_LZO_INPUT_PADDING   8 #define  AV_LZO_OUTPUT_PADDING   12 二）、函数 int  av_lzo1x_decode (void *out, int *outlen,
FFMPEG学习【libavutil】：Crypto and Hashing(二)
一世豁然的专栏
07-04 425
一、函数 struct AVCAST5 *  av_cast5_alloc (void) 分配AVCAST5上下文要释放结构体：av_free（ptr） int  av_cast5_init (struct AVCAST5 *ctx, const uint8_t *key, int key_bits)
FFMPEG学习【libavutil】：String Manipulation
一世豁然的专栏
07-17 1371
一、宏 #define  AV_ESCAPE_FLAG_WHITESPACE   (1 考虑空间特别，甚至在字符串的中间逃避他们。 #define  AV_ESCAPE_FLAG_STRICT   (1 仅转义指定的特殊字符。 #define  AV_UTF8
FFMPEG学习【libavutil】：数据结构（一）
一世豁然的专栏
07-20 1084
一、AvBuffer AVBuffer是用于引用计数数据缓冲区的API。 这个API有两个核心对象 - AVBuffer和AVBufferRef。 AVBuffer表示数据缓冲区本身; 它是不透明的，并不意味着直接由调用者访问，而只能通过AVBufferRef。 然而，呼叫者可以例如 比较两个AVBuffer指针，以检查两个不同的引用是否描述相同的数据缓冲区。 AVBufferRef表示对
FFMPEG学习【libavutil】：数据结构（三）
一世豁然的专栏
07-23 913
AVOptions提供了一个通用的系统来声明任意结构（“对象”）上的选项。 一、模块 一）、Evaluating option strings 这组函数可用于评估选项字符串并从中获取数字。 它们与av_opt_set（）执行相同的操作，除了将结果写入到调用者提供的指针中。 参数：obj：一个结构体，其第一个元素是指向AVClass的指针。    o：要评估字符串的选
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值