ffmpeg 视频编码二（基于 libswscale 转换视频）

最新推荐文章于 2023-12-06 21:37:16 发布

lhuann_

最新推荐文章于 2023-12-06 21:37:16 发布

阅读量2.4k

点赞数

分类专栏：音视频文章标签：音视频音视频

本文链接：https://blog.csdn.net/qq_35543489/article/details/121355180

版权

音视频专栏收录该内容

10 篇文章 3 订阅

订阅专栏

本文介绍了如何利用libswscale库解决ffmpeg在视频编码时遇到的图像拉伸和格式转换问题。通过libswscale的核心函数sws_getContext、sws_scale和sws_freeContext，实现图像像素格式转换、大小缩放和滤波处理。通过示例代码展示了从YUV420P到MP4的视频转码过程，成功避免了编码后的视频出现花边和裁剪等现象。

摘要由CSDN通过智能技术生成

1. ffmpeg 视频解码一
 2. ffmpeg 视频解码二
 3. ffmpeg 音频解码一
 4. ffmpeg 音频解码二
 5. ffmpeg 音视频解码
 6. ffmpeg 视频编码一
 7. ffmpeg 视频编码一（精简版）
8. ffmpeg 视频编码二（基于 libswscale 转换视频）
9. ffmpeg 过滤器libavfilter的使用
 10. ffmpeg 视频编码三（基于 libavfilter 转换视频）

前言

看了上篇文章的小伙伴应该都知道了编码的一些问题了，这篇文章我们就来解决它。

要解决上篇文章所述的问题，我们先了解一个扩展库 libswscale ，Libswscale里面实现了各种图像像素格式的转换（例如YUV与RGB之间的转换）；以及图像大小缩放的功能（例如640x360拉伸为1280x720）；以及前后图像的滤波处理（例如高斯模糊）。基于此，我们就可以解决我们上篇文章遇到的问题了。

libswscale的使用

要使用libswscale，我们必定要对齐有所了解，其核心函数主要有三个，下面分别介绍下他们的使用。

初始化（sws_getContext(…)）

/**
 * 分配并返回一个SwsContext。
 *
 * @param srcW 源图像的宽度
 * @param srcH 源图像的高度
 * @param srcFormat 源图像格式
 * @param dstW 目标图像宽度
 * @param dstH 目标图像高度
 * @param dstFormat 目标图像格式
 * @param flags 图像拉伸算法
 * @param srcFilter 输入图像滤波器信息
 * @param dstFilter 输出图像滤波器信息
 * @param param 扩展算法需要的参数
 * @return 返回一个指向SwsContext的指针, 出错则返回NULL
 * 
 */
struct SwsContext *sws_getContext(int srcW, int srcH, enum AVPixelFormat srcFormat,
                                  int dstW, int dstH, enum AVPixelFormat dstFormat,
                                  int flags, SwsFilter *srcFilter,
                                  SwsFilter *dstFilter, const double *param);

这里需要注意的是：

srcW，srcH，srcFormat 定义输入图像信息（宽、高、像素格式）

dstW，dstH，dstFormat 定义输出图像信息（宽、高、像素格式）

flags 定义转换的算法（只有当输入输出图像大小不同时有效）

srcFilter, dstFilter 定义输入/输出图像滤波器信息，如果不做前后图像滤波，输入NULL

param 扩展算法需要的额外参数（extra parameters to tune the used scaler For SWS_BICUBIC param[0] and [1] tune the shape of the basis function, param[0] tunes f(1) and param[1] f´(1) For SWS_GAUSS param[0] tunes the exponent and thus cutoff frequency For SWS_LANCZOS param[0] tunes the width of the window function）

转换（sws_scale(…)）
```
/**
 * 缩放图像
 *
 * @param c    之前用sws_getContext()创建的SwsContext 上下文
 * @param srcSlice  输入图像的每个颜色通道的数据指针
 * @param srcStride 数组中保存的是对应通道的数据宽度
 * @param srcSliceY 图像上处理区域的起始位置
 * @param srcSliceH 图像上需要处理的行数
 * @param dst       类比输入，输出图像的每个颜色通道的数据指针
 * @param dstStride 类比输入，数组中保存的是对应通道的数据宽度
 * @return          the height of the output slice
 */
int sws_scale(struct SwsContext *c, const uint8_t *const srcSlice[],
              const int srcStride[], int srcSliceY, int srcSliceH,
              uint8_t *const dst[], const int dstStride[]);
```
这里需要注意的是：
- srcSlice：
  
  这个其实就是 AVFrame中的data[]数组。因为不同像素的存储格式不同，所以srcSlice[]维数也有可能不同。
  以YUV420P为例，它是planar格式，它的内存中的排布如下：
  YYYY UUUU VVVV
  使用FFmpeg解码后存储在AVFrame的data[]数组中时：
  data[0] —— Y分量, Y1, Y2, Y3, Y4……
  data[1] —— U分量, U1, U2, U3, U4……
  data[2] —— V分量, V1, V2, V3, V4……
  linesize[]数组中保存的是对应通道的数据宽度，
  linesize[0] —— Y分量的宽度
  linesize[1] —— U分量的宽度
  linesize[2] —— V分量的宽度
- srcStride
  
  这个其实就是 AVFrame中的linesize[]数组。存储的也就是每个通道的行字节数。比较特殊的是，这个大小和图像的宽度并不一定一直。
  1.由于数据帧存储的对齐，有可能会向每行后面增加一些填充字节这样 stride = width + N；
  
  2.packet存错模式下，每个像素几个通道数据混合在一起，例如RGB24，每个像素3字节连续存放，因此下一行的位置需要跳过3*width字节。
  
  srcSlice和srcStride的维数相同，由srcFormat值来。
  
  p 维数宽width 跨度stride 高
  20 3 w, w/2, w/2 s, s/2, s/2 h, h/2, h/2
  1 w, w/2, w/2 2s, 0, 0 h, h, h
  2 w, w/2, w/2 s, s, 0 h, h/2
  4 1 w, w, w 3s, 0, 0 h, 0, 0
- srcSliceY 与 srcSliceH
  这两个参数组合，既可以定义图像的处理区域，例如srcSliceY =0，srcSliceH =height,即代表一次性处理完整个图像。
  
  这种设置是为了多线程并行，例如可以创建两个线程，第一个线程处理 [0, h/2-1]行，第二个线程处理 [h/2, h-1]行。并行处理加快速度。
- dst 与 dstStride
  类比srcSlice和srcStride ，这里不多做解释。
释放（sws_freeContext(SwsContext*)）
这个没什么说的，释放之前用sws_getContext()创建的SwsContext 上下文

p	维数	宽width	跨度stride	高
20	3	w, w/2, w/2	s, s/2, s/2	h, h/2, h/2
1	w, w/2, w/2	2s, 0, 0	h, h, h
2	w, w/2, w/2	s, s, 0	h, h/2
4	1	w, w, w	3s, 0, 0	h, 0, 0

流程图

流程图其实并不是完整代码逻辑，部分代码没在里面体现出来，主要是展示个大概流程。

在这里插入图片描述

源代码


#pragma once
#define __STDC_CONSTANT_MACROS
#define _CRT_SECURE_NO_WARNINGS

extern "C"
{
#include <libavformat/avformat.h>
#include "libavcodec/avcodec.h"
#include <libswscale/swscale.h>
#include "libavutil/imgutils.h"
}

using namespace std;

#define INPUT_FILE_NAME "lh_online.yuv"
#define OUTPUT_FILE_NAME "lh_online.mp4"

//mp4
#define L_AVCODEID AV_CODEC_ID_MPEG4
 //带编码视频类型
#define ENC_AV_PIX_FMT_YUV AV_PIX_FMT_YUV420P 
//编码之后的视频宽度
#define ENC_VIDEO_WIDTH 800
//编码之后的视频高度
#define ENC_VIDEO_HEIGHT 600
#define ENC_VIDEO_BITRATE 400000
//time_base  AVRational{1,15}
//一秒多少张图片（原视频是15。）
#define ENC_TIME_BASE_DEN 15

AVFormatContext* i_fmt_ctx = NULL, * o_fmt_ctx = NULL;
AVCodecContext* enc_c = NULL;;

AVStream* out_stream;
AVFrame* frame, * tmp_frame;
AVPacket* enc_pkt;
int ret;

struct SwsContext* sws_ctx;

static void encode()
{
	//发送待编码数据到编码器
	ret = avcodec_send_frame(enc_c, tmp_frame);
	if (ret < 0) {
		fprintf(stderr, "Error sending a frame for encoding\n");
		exit(1);
	}

	while (ret >= 0) {
		//编码一帧视频
		ret = avcodec_receive_packet(enc_c, enc_pkt);
		if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
			return;
		else if (ret < 0) {
			fprintf(stderr, "Error during encoding\n");
			exit(1);
		}
		//写入文件时流序号（这里只编码了视频流，而且也只实例化了一个输出流（avformat_new_stream），序号直接就是0）
		//多输出流的时候需要注意，后面音视频同时处理的时候，再说这个吧
		enc_pkt->stream_index = 0;
		//时间基转换（编码器->输出流）
		av_packet_rescale_ts(enc_pkt,
			enc_c->time_base,
			out_stream->time_base);
		printf("Write packet %d (size=%d)\n", enc_pkt->pts, enc_pkt->size);
		//写文件
		ret = av_interleaved_write_frame(o_fmt_ctx, enc_pkt);
		av_packet_unref(enc_pkt);
	}
}

static int open_output_file()
{
	int ret;
	AVCodec* codec;
	o_fmt_ctx = avformat_alloc_context();
	avformat_alloc_output_context2(&o_fmt_ctx, NULL, NULL, OUTPUT_FILE_NAME);
	if (!o_fmt_ctx) {
		av_log(NULL, AV_LOG_ERROR, "Could not create output context\n");
		return AVERROR_UNKNOWN;
	}

	//获取编码器
	codec = avcodec_find_encoder(L_AVCODEID);
	if (!codec) {
		av_log(NULL, AV_LOG_FATAL, "encoder Codec not found\n");
		return AVERROR_INVALIDDATA;
	}

	enc_c = avcodec_alloc_context3(codec);
	if (!enc_c) {
		av_log(NULL, AV_LOG_FATAL, "Failed to allocate the encoder context\n");
		return AVERROR(ENOMEM);
	}
	//一些默认参数的设置
	enc_c->codec_id = codec->id;
	enc_c->pix_fmt = ENC_AV_PIX_FMT_YUV;
	enc_c->bit_rate = ENC_VIDEO_BITRATE;
	enc_c->width = ENC_VIDEO_WIDTH;
	enc_c->height = ENC_VIDEO_HEIGHT;
	enc_c->time_base.num = 1;
	enc_c->time_base.den = ENC_TIME_BASE_DEN;
	enc_c->gop_size = 12;
	enc_c->max_b_frames = 4;

	if (o_fmt_ctx->oformat->flags & AVFMT_GLOBALHEADER)
		enc_c->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;

	//实例化输出流
	out_stream = avformat_new_stream(o_fmt_ctx, NULL);
	if (!out_stream) {
		av_log(NULL, AV_LOG_ERROR, "Failed allocating output stream\n");
		return AVERROR_UNKNOWN;
	}

	//复制编码器参数到输出流
	ret = avcodec_parameters_from_context(out_stream->codecpar, enc_c);
	if (0 != ret)
	{
		fprintf(stderr, "Failed to copy codec parameters\n");
		return -1;
	}

	out_stream->time_base = enc_c->time_base;

	//打开编码器
	ret = avcodec_open2(enc_c, codec, NULL);
	if (ret < 0) {
		av_log(NULL, AV_LOG_ERROR, "Cannot open video encoder for stream\n");
		return ret;
	}

	//打开输出文件
	if (!(o_fmt_ctx->oformat->flags & AVFMT_NOFILE)) {
		ret = avio_open(&o_fmt_ctx->pb, OUTPUT_FILE_NAME, AVIO_FLAG_WRITE);
		if (ret < 0) {
			av_log(NULL, AV_LOG_ERROR, "Could not open output file\n", OUTPUT_FILE_NAME);
			return ret;
		}
	}

	//写文件头
	ret = avformat_write_header(o_fmt_ctx, NULL);
	if (ret < 0) {
		av_log(NULL, AV_LOG_ERROR, "Error occurred when opening output file\n");
		return ret;
	}
	return 0;
}

int main(int argc, char* argv[])
{

	//-------初始化一些配置---start
	int i = 0;
	size_t  data_size;
	uint8_t* temp_buffer;
	uint8_t* src_data[4];
	int src_linesize[4];

	//输入视频基本信息
	const int src_w = 512, src_h = 288;
	AVPixelFormat src_pixfmt = AV_PIX_FMT_YUV420P;
	//获得YUV420P像素格式每个像素占用的比特数（Bit Per Pixel）
	int src_bpp = av_get_bits_per_pixel(av_pix_fmt_desc_get(src_pixfmt));

	//打开输入文件
	FILE* src_file = fopen(INPUT_FILE_NAME, "rb");

	//分配AVFrame
	tmp_frame = av_frame_alloc();
	if (!tmp_frame) {
		fprintf(stderr, "Could not allocate video tmp_frame\n");
		exit(1);
	}
	tmp_frame->format = ENC_AV_PIX_FMT_YUV;
	tmp_frame->width = ENC_VIDEO_WIDTH;
	tmp_frame->height = ENC_VIDEO_HEIGHT;

	//计算 YUV420P 格式的图像需要占用的空间大小，分配内存空间
	temp_buffer = (uint8_t*)av_malloc(av_image_get_buffer_size(src_pixfmt, src_w, src_h, 1));

	//分配缓冲区并填入dst_data dst_linesize
	if ((ret = av_image_alloc(src_data, src_linesize,
		src_w, src_h, src_pixfmt, 1)) < 0) {
		fprintf(stderr, "Could not allocate source image\n");
		goto end;
	}
	//分配缓冲区并填入dst_data dst_linesize
	if ((ret = av_image_alloc(tmp_frame->data, tmp_frame->linesize,
		ENC_VIDEO_WIDTH, ENC_VIDEO_HEIGHT, ENC_AV_PIX_FMT_YUV, 1)) < 0) {
		fprintf(stderr, "Could not allocate source image\n");
		goto end;
	}

	//数初始化SwsContext结构体
	//这里你可能发现我们源图像和目标图像的格式是一致的
	//这里的话是正常的，因为我们只是拉伸图像的宽高
	sws_ctx = sws_getContext(src_w,  //源图像的宽度
		src_h,						 //源图像的高度
		src_pixfmt,					 //源图像格式
		ENC_VIDEO_WIDTH,			 //目标图像宽度
		ENC_VIDEO_HEIGHT,			 //目标图像高度
		ENC_AV_PIX_FMT_YUV,			 //目标图像格式
		SWS_BILINEAR,				 //图像拉伸算法
		NULL,						 //输入图像滤波器信息
		NULL,                        //输出图像滤波器信息
		NULL                         //扩展算法需要的参数
	);
	if (!sws_ctx) {
		fprintf(stderr, "could not allocate SwsContext.\n");
		goto end;
	}

	//分配一个AVPacket
	enc_pkt = av_packet_alloc();
	if (!enc_pkt) {
		goto end;
	}
	//-------初始化一些配置---end

	//输出处理
	if ((ret = open_output_file()) < 0) {
		av_log(NULL, AV_LOG_ERROR, "could not open output file \s.\n", OUTPUT_FILE_NAME);
		goto end;
	}

	while (!feof(src_file)) {
		//读取数据 ，这里根据视频宽高和像素大小填充temp_buffer
		data_size = fread(temp_buffer, 1, src_w * src_h * src_bpp / 8, src_file);
		if (!data_size)
			break;
		//填充 frame
		memcpy(src_data[0], temp_buffer, src_w * src_h);                    //Y
		memcpy(src_data[1], temp_buffer + src_w * src_h, src_w * src_h / 4);      //U
		memcpy(src_data[2], temp_buffer + src_w * src_h * 5 / 4, src_w * src_h / 4);  //V
		//转换一帧图像。
		sws_scale(sws_ctx,        // 转换格式的上下文。也就是 sws_getContext 函数返回的结果
			src_data,			  //输入图像的每个颜色通道的数据指针。其实就是解码后的AVFrame中的data[]数组
			src_linesize,         //数组中保存的是对应通道的数据宽度
			0,					  //图像上处理区域的起始位置
			src_h,				  //图像上需要处理的行数
			tmp_frame->data,	  //类比输入，输出图像的每个颜色通道的数据指针
			tmp_frame->linesize   //类比输入，数组中保存的是对应通道的数据宽度
		);
		//添加pts
		tmp_frame->pts = i++;
		//送往编码
		encode();
	}

	//写文件尾
	av_write_trailer(o_fmt_ctx);

end:
	//资源释放
	sws_freeContext(sws_ctx);
	avcodec_free_context(&enc_c);
	av_frame_free(&frame);
	av_packet_free(&enc_pkt);
	avformat_close_input(&i_fmt_ctx);
	avformat_free_context(o_fmt_ctx);
	return 0;
}

这个程序里，我们把源视频（512 * 288也就是16:9）的视频，转码成640 * 360（16:9）的视频，并编码成MP4，下面来对比一下两个视频的差异：
在这里插入图片描述
你可以发现，我们把图像拉伸成640*360之后，没有出现 ffmpeg 视频编码一（精简版）当中所展示的问题。

如果我们设置的比例不一致呢，我们实验一下，我们修改宏

//编码之后的视频宽度
#define ENC_VIDEO_WIDTH 800
//编码之后的视频高度
#define ENC_VIDEO_HEIGHT 600

为800*600，下面看下差异：
在这里插入图片描述
这里发现编码之后的视频，也没有出现花边和裁剪之类的问题，而且根据我们设置的宽高，自动的把视频拉伸了。

所以使用 libswscale 完美解决了ffmpeg 视频编码一（精简版）当中所展示的问题。

到此使用 libswscale的方式就介绍完了。

参考链接：
sws_scale概念讲解
 最简单的基于FFmpeg的libswscale的示例（YUV转RGB）