ffmpeg合并视频时的尺寸注意事项

最新推荐文章于 2025-10-03 23:02:08 发布
原创 最新推荐文章于 2025-10-03 23:02:08 发布 · 2.5k 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#音视频

本文详细介绍了如何利用FFmpeg库进行视频拼接和缩放操作，以适应不同的分辨率需求。首先，通过调整pad和scale滤镜参数实现了从2880x1800到1920x1080的尺寸转换，以减少带宽占用。然后，通过引入黑色背景图片，解决了第四个视频缺失的问题，确保了输出视频的完整性和正确性。整个过程涉及到FFmpeg的滤镜描述字符串构造、AVFrame数据处理以及多线程读取视频流等技术。

本人的电脑的分辨率为2880x1800，录制了下面四个视频，black.png是从网上下载的图片，背景纯黑色，分辨率为2920x1642，用于视频合并时的背景图。

在这里插入图片描述

首先按照如下尺寸进行填充，其中V1代表第一个视频
在这里插入图片描述
命令行如下：

ffmpeg -i in-d.mp4 -i in-desktop.mp4 -i in-explorer.mp4 -i in-vs.mp4  -filter_complex "pad=3680:1800[pad0];[pad0][0:v]overlay=0[pad1];[1:v]scale=w=800:h=600[scale1];[pad1][scale1]overlay=2880[pad2];[2:v]scale=w=800:h=600[scale2];[pad2][scale2]overlay=2880:600[pad3];[3:v]scale=w=800:h=600[scale3];[pad3][scale3]overlay=2880:1200" out.mp4

结果是好的，现在要进行做直播功能，希望将整体尺寸由上面的3680x1800改为1920x1080来避免带宽占用过大。对应的尺寸图如下所示：
在这里插入图片描述
命令行如下所示：

ffmpeg -i in-d.mp4 -i in-desktop.mp4 -i in-explorer.mp4 -i in-vs.mp4  -filter_complex "pad=1920:1080[pad0];[0:v]scale=w=1440:h=1080[scale0];[pad0][scale0]overlay=0[pad1];[1:v]scale=w=480:h=360[scale1];[pad1][scale1]overlay=1440[pad2];[2:v]scale=w=480:h=360[scale2];[pad2][scale2]overlay=1440:360[pad3];[3:v]scale=w=480:h=360[scale3];[pad3][scale3]overlay=1440:720" out.mp4

结果报错，错误信息如下：
在这里插入图片描述
很明显说的是输入视频尺寸大于pad尺寸(输入视频尺寸是2880x1800，pad尺寸是1920x1080)。

此时可以通过创建pad时，设置大一些尺寸进行解决，命令行如下：

ffmpeg -i in-d.mp4 -i in-desktop.mp4 -i in-explorer.mp4 -i in-vs.mp4  -filter_complex "pad=2880:1800[pad00];[pad00]scale=w=1920:h=1080[pad0];[0:v]scale=w=1440:h=1080[scale0];[pad0][scale0]overlay=0[pad1];[1:v]scale=w=480:h=360[scale1];[pad1][scale1]overlay=1440[pad2];[2:v]scale=w=480:h=360[scale2];[pad2][scale2]overlay=1440:360[pad3];[3:v]scale=w=480:h=360[scale3];[pad3][scale3]overlay=1440:720" out.mp4

这个命令行运行是成功的。
现在我们考虑下这种布局：
在这里插入图片描述
第四个视频缺失了，缺失的部分，需要底部为黑色展示。
对应的命令行如下：

ffmpeg -i in-d.mp4 -i in-desktop.mp4 -i in-explorer.mp4 -i in-vs.mp4  -filter_complex "pad=2880:1800[pad00];[pad00]scale=w=1920:h=1080[pad0];[0:v]scale=w=1440:h=1080[scale0];[pad0][scale0]overlay=0[pad1];[1:v]scale=w=480:h=360[scale1];[pad1][scale1]overlay=1440[pad2];[2:v]scale=w=480:h=360[scale2];[pad2][scale2]overlay=1440:360" out.mp4

产生的效果如下，很明显红色方框的背景图实际上是第一张图片的，不符合要去。
在这里插入图片描述

为此引入黑色背景图，输入源变为5个，命令如下：

ffmpeg -i black.png -i in-d.mp4 -i in-desktop.mp4 -i in-explorer.mp4 -filter_complex "pad=3000:1800[pad0tmp];[pad0tmp]scale=w=1920:h=1080[pad0];[1:v]scale=w=1440:h=1080[scale0];[pad0][scale0]overlay=0[pad1];[2:v]scale=w=480:h=360[scale1];[pad1][scale1]overlay=1440[pad2];[3:v]scale=w=480:h=360[scale2];[pad2][scale2]overlay=1440:360" out20.mp4

产生的效果如下：
在这里插入图片描述
很明显是ok的。

下面我们探讨下代码中如何写，首先查询到黑色背景的YUV对应的值分别为0，128,128，所以，我们可以自动构建AVFrame，使其背景色为黑色，对应的代码如下：

AVFrame *pFrameVideoPad = av_frame_alloc();
uint8_t *videoPad_buffer_yuv420 = (uint8_t *)av_malloc(m_iYuv420FrameSize);
av_image_fill_arrays(pFrameVideoPad->data, pFrameVideoPad->linesize, videoPad_buffer_yuv420, AV_PIX_FMT_YUV420P, m_pReadCodecCtx_VideoA->width, m_pReadCodecCtx_VideoA->height, 1);

memset(pFrameVideoPad->data[0], 0, m_pReadCodecCtx_VideoA->width * m_pReadCodecCtx_VideoA->height);
memset(pFrameVideoPad->data[1], 128, m_pReadCodecCtx_VideoA->width * m_pReadCodecCtx_VideoA->height / 4);
memset(pFrameVideoPad->data[2], 128, m_pReadCodecCtx_VideoA->width * m_pReadCodecCtx_VideoA->height / 4);

滤镜描述字符串如下：

const char* filter_desc = "[inpad]pad=2880:1800:0:0:black[inpad0];[inpad0]scale=w=1920:h=1080[inpad00];[in0]scale=w=1440:h=1080[scale0];[inpad00][scale0]overlay=0[x0];[in1]scale=w=480:h=360[scale1];[x0][scale1]overlay=1440[x1];[in2]scale=w=480:h=360[scale2];[x1][scale2]overlay=1440:360[out]";

其中输入源inpad为自己构建的黑色YUV数据。
in0是第一个视频，in1是第二个视频，in2是第三个视频，第四个视频特意没放进去。

代码结构如下：
在这里插入图片描述
其中FfmpegMerge4File.cpp的内容如下：

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

#ifdef	__cplusplus
extern "C"
{
#endif

#pragma comment(lib, "avcodec.lib")
#pragma comment(lib, "avformat.lib")
#pragma comment(lib, "avutil.lib")
#pragma comment(lib, "avdevice.lib")
#pragma comment(lib, "avfilter.lib")
#pragma comment(lib, "postproc.lib")
#pragma comment(lib, "swresample.lib")
#pragma comment(lib, "swscale.lib")


#ifdef __cplusplus
};
#endif





int main()
{
	CVideoMerge cVideoMerge;
	const char *pFileA = "D:\\learn\\ffmpeg\\FfmpegTest\\x64\\Release\\in-vs.mp4";
	const char *pFileB = "D:\\learn\\ffmpeg\\FfmpegTest\\x64\\Release\\in-d.mp4";
	const char *pFileC = "D:\\learn\\ffmpeg\\FfmpegTest\\x64\\Release\\in-explorer.mp4";
	const char *pFileD = "D:\\learn\\ffmpeg\\FfmpegTest\\x64\\Release\\in-desktop.mp4";


	const char *pFileOut = "D:\\learn\\ffmpeg\\FfmpegTest\\x64\\Release\\out-merge-4file.mp4";
	cVideoMerge.StartMerge(pFileA, pFileB, pFileC, pFileD, pFileOut);
	cVideoMerge.WaitFinish();
	return 0;
}

VideoMerge.h的内容如下：

#pragma once

#include <Windows.h>

#ifdef	__cplusplus
extern "C"
{
#endif
#include "libavcodec/avcodec.h"
#include "libavformat/avformat.h"
#include "libswscale/swscale.h"
#include "libswresample/swresample.h"
#include "libavdevice/avdevice.h"
#include "libavutil/audio_fifo.h"
#include "libavutil/avutil.h"
#include "libavutil/fifo.h"
#include "libavutil/frame.h"
#include "libavutil/imgutils.h"

#include "libavfilter/avfilter.h"
#include "libavfilter/buffersink.h"
#include "libavfilter/buffersrc.h"


#ifdef __cplusplus
};
#endif

class CVideoMerge
{
public:
	CVideoMerge();
	~CVideoMerge();
public:
	int StartMerge(const char *pFileA, const char *pFileB, const char *pFileC, const char *pFileD, const char *pFileOut);
	int WaitFinish();
private:
	int OpenFileA(const char *pFileA);
	int OpenFileB(const char *pFileB);
	int OpenFileC(const char *pFileC);
	int OpenFileD(const char *pFileD);
	int OpenOutPut(const char *pFileOut);
	int InitFilter(const char* filter_desc);
private:
	static DWORD WINAPI VideoAReadProc(LPVOID lpParam);
	void VideoARead();

	static DWORD WINAPI VideoBReadProc(LPVOID lpParam);
	void VideoBRead();

	static DWORD WINAPI VideoCReadProc(LPVOID lpParam);
	void VideoCRead();

	static DWORD WINAPI VideoDReadProc(LPVOID lpParam);
	void VideoDRead();

	static DWORD WINAPI VideoMergeProc(LPVOID lpParam);
	void VideoMerge();
private:
	AVFormatContext *m_pFormatCtx_FileA = NULL;
	AVFormatContext *m_pFormatCtx_FileB = NULL;
	AVFormatContext *m_pFormatCtx_FileC = NULL;
	AVFormatContext *m_pFormatCtx_FileD = NULL;

	AVCodecContext *m_pReadCodecCtx_VideoA = NULL;
	AVCodec *m_pReadCodec_VideoA = NULL;

	AVCodecContext *m_pReadCodecCtx_VideoB = NULL;
	AVCodec *m_pReadCodec_VideoB = NULL;

	AVCodecContext *m_pReadCodecCtx_VideoC = NULL;
	AVCodec *m_pReadCodec_VideoC = NULL;

	AVCodecContext *m_pReadCodecCtx_VideoD = NULL;
	AVCodec *m_pReadCodec_VideoD = NULL;

	AVCodecContext	*m_pCodecEncodeCtx_Video = NULL;
	AVFormatContext *m_pFormatCtx_Out = NULL;

	AVFifoBuffer *m_pVideoAFifo = NULL;
	AVFifoBuffer *m_pVideoBFifo = NULL;
	AVFifoBuffer *m_pVideoCFifo = NULL;
	AVFifoBuffer *m_pVideoDFifo = NULL;

	AVFilterGraph* m_pFilterGraph = NULL;
	AVFilterContext* m_pFilterCtxSrcVideoPad = NULL;
	AVFilterContext* m_pFilterCtxSrcVideoA = NULL;
	AVFilterContext* m_pFilterCtxSrcVideoB = NULL;
	AVFilterContext* m_pFilterCtxSrcVideoC = NULL;
	AVFilterContext* m_pFilterCtxSrcVideoD = NULL;
	AVFilterContext* m_pFilterCtxSink = NULL;

	int m_iMergeWidth = 1920;
	int m_iMergeHeight = 1080;
	int m_iYuv420FrameSize = 0;
private:
	CRITICAL_SECTION m_csVideoASection;
	CRITICAL_SECTION m_csVideoBSection;
	CRITICAL_SECTION m_csVideoCSection;
	CRITICAL_SECTION m_csVideoDSection;
	HANDLE m_hVideoAReadThread = NULL;
	HANDLE m_hVideoBReadThread = NULL;
	HANDLE m_hVideoCReadThread = NULL;
	HANDLE m_hVideoDReadThread = NULL;
	HANDLE m_hVideoMergeThread = NULL;
};

VideoMerge.cpp的代码如下：


#include "VideoMerge.h"
#include "log/log.h"





CVideoMerge::CVideoMerge()
{
	InitializeCriticalSection(&m_csVideoASection);
	InitializeCriticalSection(&m_csVideoBSection);
	InitializeCriticalSection(&m_csVideoCSection);
	InitializeCriticalSection(&m_csVideoDSection);
}

CVideoMerge::~CVideoMerge()
{
	DeleteCriticalSection(&m_csVideoASection);
	DeleteCriticalSection(&m_csVideoBSection);
	DeleteCriticalSection(&m_csVideoCSection);
	DeleteCriticalSection(&m_csVideoDSection);
}

int CVideoMerge::StartMerge(const char *pFileA, const char *pFileB, const char *pFileC, const char *pFileD, const char *pFileOut)
{
	int ret = -1;
	do 
	{
		ret = OpenFileA(pFileA);
		if (ret != 0)
		{
			break;
		}

		ret = OpenFileB(pFileB);
		if (ret != 0)
		{
			break;
		}

		ret = OpenFileC(pFileC);
		if (ret != 0)
		{
			break;
		}

		ret = OpenFileD(pFileD);
		if (ret != 0)
		{
			break;
		}

		ret = OpenOutPut(pFileOut);
		if (ret != 0)
		{
			break;
		}

		///这个滤镜的效果是以第一个视频做模板，且第一个视频的铺满全屏，第二个视频覆盖在第一个视频的右半部分
		//const char* filter_desc = "[in0]pad=1920:1080[x1];[in1]scale=w=960:h=1080[inn1];[x1][inn1]overlay=960:0[out]";


		//const char* filter_desc = "[in0]split[main][tmp];[main]scale=w=3840:h=1800[base];[base][tmp]overlay=0[x0];[in1]scale=w=960:h=600[scale1];[x0][scale1]overlay=2880[x1];[in2]scale=w=960:h=600[scale2];[x1][scale2]overlay=2880:600[x2];[in3]scale=w=960:h=600[scale3];[x2][scale3]overlay=2880:1200[out]";
		//const char* filter_desc = "[inpad]pad=2880:1800[inpad0];[inpad0]scale=w=1920:h=1080[inpad00];[in0]scale=w=1440:h=1080[scale0];[inpad00][scale0]overlay=0[x0];[in1]scale=w=480:h=360[scale1];[x0][scale1]overlay=1440[x1];[in2]scale=w=480:h=360[scale2];[x1][scale2]overlay=1440:360[x2];[in3]scale=w=480:h=360[scale3];[x2][scale3]overlay=1440:720[out]";
		const char* filter_desc = "[inpad]pad=2880:1800:0:0:black[inpad0];[inpad0]scale=w=1920:h=1080[inpad00];[in0]scale=w=1440:h=1080[scale0];[inpad00][scale0]overlay=0[x0];[in1]scale=w=480:h=360[scale1];[x0][scale1]overlay=1440[x1];[in2]scale=w=480:h=360[scale2];[x1][scale2]overlay=1440:360[out]";
		//const char* filter_desc = "[in0]split[main][tmp];[main]scale=w=1920:h=1080[base];[tmp]scale=w=1440:h=1080[tmp0];[base][tmp0]overlay=0[x0];[in1]scale=w=480:h=360[scale1];[x0][scale1]overlay=1440[x1];[in2]scale=w=480:h=360[scale2];[x1][scale2]overlay=1440:360[x2];[in3]scale=w=480:h=360[scale3];[x2][scale3]overlay=1440:720[out]";
		//const char* filter_desc = "[in0]split[main][tmp];[main]scale=w=1920:h=1080[base];[tmp]scale=w=1440:h=1080[tmp0];[base][tmp0]overlay=0[x0];[in1]scale=w=480:h=360[scale1];[x0][scale1]overlay=1440[x1];[in2]scale=w=480:h=360[scale2];[x1][scale2]overlay=1440:360[out]";

		ret = InitFilter(filter_desc);
		if (ret < 0)
		{
			break;
		}

		m_iYuv420FrameSize = av_image_get_buffer_size(AV_PIX_FMT_YUV420P, m_pReadCodecCtx_VideoA->width, m_pReadCodecCtx_VideoA->height, 1);
		//申请30帧缓存
		m_pVideoAFifo = av_fifo_alloc(30 * m_iYuv420FrameSize);
		m_pVideoBFifo = av_fifo_alloc(30 * m_iYuv420FrameSize);
		m_pVideoCFifo = av_fifo_alloc(30 * m_iYuv420FrameSize);
		m_pVideoDFifo = av_fifo_alloc(30 * m_iYuv420FrameSize);

		m_hVideoAReadThread = CreateThread(NULL, 0, VideoAReadProc, this, 0, NULL);
		m_hVideoBReadThread = CreateThread(NULL, 0, VideoBReadProc, this, 0, NULL);
		m_hVideoCReadThread = CreateThread(NULL, 0, VideoCReadProc, this, 0, NULL);
		m_hVideoDReadThread = CreateThread(NULL, 0, VideoDReadProc, this, 0, NULL);

		m_hVideoMergeThread = CreateThread(NULL, 0, VideoMergeProc, this, 0, NULL);

	} while (0);

	return ret;
}

int CVideoMerge::WaitFinish()
{
	int ret = 0;
	do 
	{
		if (NULL == m_hVideoAReadThread || NULL == m_hVideoBReadThread)
		{
			break;
		}
		WaitForSingleObject(m_hVideoAReadThread, INFINITE);
		WaitForSingleObject(m_hVideoBReadThread, INFINITE);
		WaitForSingleObject(m_hVideoCReadThread, INFINITE);
		WaitForSingleObject(m_hVideoDReadThread, INFINITE);

		CloseHandle(m_hVideoAReadThread);
		m_hVideoAReadThread = NULL;
		CloseHandle(m_hVideoBReadThread);
		m_hVideoBReadThread = NULL;
		CloseHandle(m_hVideoCReadThread);
		m_hVideoCReadThread = NULL;
		CloseHandle(m_hVideoDReadThread);
		m_hVideoDReadThread = NULL;

		WaitForSingleObject(m_hVideoMergeThread, INFINITE);
		CloseHandle(m_hVideoMergeThread);
		m_hVideoMergeThread = NULL;
	} while (0);

	return ret;
}

int CVideoMerge::OpenFileA(const char *pFileA)
{
	int ret = -1;

	do
	{
		if ((ret = avformat_open_input(&m_pFormatCtx_FileA, pFileA, 0, 0)) < 0) {
			printf("Could not open input file.");
			break;
		}
		if ((ret = avformat_find_stream_info(m_pFormatCtx_FileA, 0)) < 0) {
			printf("Failed to retrieve input stream information");
			break;
		}

		if (m_pFormatCtx_FileA->streams[0]->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
		{
			break;
		}
		m_pReadCodec_VideoA = (AVCodec *)avcodec_find_decoder(m_pFormatCtx_FileA->streams[0]->codecpar->codec_id);

		m_pReadCodecCtx_VideoA = avcodec_alloc_context3(m_pReadCodec_VideoA);

		if (m_pReadCodecCtx_VideoA == NULL)
		{
			break;
		}
		avcodec_parameters_to_context(m_pReadCodecCtx_VideoA, m_pFormatCtx_FileA->streams[0]->codecpar);

		m_pReadCodecCtx_VideoA->framerate = m_pFormatCtx_FileA->streams[0]->r_frame_rate;

		if (avcodec_open2(m_pReadCodecCtx_VideoA, m_pReadCodec_VideoA, NULL) < 0)
		{
			break;
		}

		ret = 0;
	} while (0);


	return ret;
}

int CVideoMerge::OpenFileB(const char *pFileB)
{
	int ret = -1;

	do 
	{
		if ((ret = avformat_open_input(&m_pFormatCtx_FileB, pFileB, 0, 0)) < 0) {
			printf("Could not open input file.");
			break;
		}
		if ((ret = avformat_find_stream_info(m_pFormatCtx_FileB, 0)) < 0) {
			printf("Failed to retrieve input stream information");
			break;
		}

		if (m_pFormatCtx_FileB->streams[0]->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
		{
			break;
		}
		m_pReadCodec_VideoB = (AVCodec *)avcodec_find_decoder(m_pFormatCtx_FileB->streams[0]->codecpar->codec_id);

		m_pReadCodecCtx_VideoB = avcodec_alloc_context3(m_pReadCodec_VideoB);

		if (m_pReadCodecCtx_VideoB == NULL)
		{
			break;
		}
		avcodec_parameters_to_context(m_pReadCodecCtx_VideoB, m_pFormatCtx_FileB->streams[0]->codecpar);

		m_pReadCodecCtx_VideoB->framerate = m_pFormatCtx_FileB->streams[0]->r_frame_rate;

		if (avcodec_open2(m_pReadCodecCtx_VideoB, m_pReadCodec_VideoB, NULL) < 0)
		{
			break;
		}

		ret = 0;
	} while (0);
	

	return ret;
}

int CVideoMerge::OpenFileC(const char *pFileC)
{
	int ret = -1;

	do
	{
		if ((ret = avformat_open_input(&m_pFormatCtx_FileC, pFileC, 0, 0)) < 0) {
			printf("Could not open input file.");
			break;
		}
		if ((ret = avformat_find_stream_info(m_pFormatCtx_FileC, 0)) < 0) {
			printf("Failed to retrieve input stream information");
			break;
		}

		if (m_pFormatCtx_FileC->streams[0]->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
		{
			break;
		}
		m_pReadCodec_VideoC = (AVCodec *)avcodec_find_decoder(m_pFormatCtx_FileC->streams[0]->codecpar->codec_id);

		m_pReadCodecCtx_VideoC = avcodec_alloc_context3(m_pReadCodec_VideoC);

		if (m_pReadCodecCtx_VideoC == NULL)
		{
			break;
		}
		avcodec_parameters_to_context(m_pReadCodecCtx_VideoC, m_pFormatCtx_FileC->streams[0]->codecpar);

		m_pReadCodecCtx_VideoC->framerate = m_pFormatCtx_FileC->streams[0]->r_frame_rate;

		if (avcodec_open2(m_pReadCodecCtx_VideoC, m_pReadCodec_VideoC, NULL) < 0)
		{
			break;
		}

		ret = 0;
	} while (0);


	return ret;
}

int CVideoMerge::OpenFileD(const char *pFileD)
{
	int ret = -1;

	do
	{
		if ((ret = avformat_open_input(&m_pFormatCtx_FileD, pFileD, 0, 0)) < 0) {
			printf("Could not open input file.");
			break;
		}
		if ((ret = avformat_find_stream_info(m_pFormatCtx_FileD, 0)) < 0) {
			printf("Failed to retrieve input stream information");
			break;
		}

		if (m_pFormatCtx_FileD->streams[0]->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
		{
			break;
		}
		m_pReadCodec_VideoD = (AVCodec *)avcodec_find_decoder(m_pFormatCtx_FileD->streams[0]->codecpar->codec_id);

		m_pReadCodecCtx_VideoD = avcodec_alloc_context3(m_pReadCodec_VideoD);

		if (m_pReadCodecCtx_VideoD == NULL)
		{
			break;
		}
		avcodec_parameters_to_context(m_pReadCodecCtx_VideoD, m_pFormatCtx_FileD->streams[0]->codecpar);

		m_pReadCodecCtx_VideoD->framerate = m_pFormatCtx_FileD->streams[0]->r_frame_rate;

		if (avcodec_open2(m_pReadCodecCtx_VideoD, m_pReadCodec_VideoD, NULL) < 0)
		{
			break;
		}

		ret = 0;
	} while (0);


	return ret;
}


int CVideoMerge::OpenOutPut(const char *pFileOut)
{
	int iRet = -1;

	AVStream *pAudioStream = NULL;
	AVStream *pVideoStream = NULL;

	do
	{
		avformat_alloc_output_context2(&m_pFormatCtx_Out, NULL, NULL, pFileOut);

		{
			AVCodec* pCodecEncode_Video = (AVCodec *)avcodec_find_encoder(m_pFormatCtx_Out->oformat->video_codec);

			m_pCodecEncodeCtx_Video = avcodec_alloc_context3(pCodecEncode_Video);
			if (!m_pCodecEncodeCtx_Video)
			{
				break;
			}

			pVideoStream = avformat_new_stream(m_pFormatCtx_Out, pCodecEncode_Video);
			if (!pVideoStream)
			{
				break;
			}

			int frameRate = 10;
			m_pCodecEncodeCtx_Video->flags |= AV_CODEC_FLAG_QSCALE;
			m_pCodecEncodeCtx_Video->bit_rate = 4000000;
			m_pCodecEncodeCtx_Video->rc_min_rate = 4000000;
			m_pCodecEncodeCtx_Video->rc_max_rate = 4000000;

			m_pCodecEncodeCtx_Video->bit_rate_tolerance = 4000000;
			m_pCodecEncodeCtx_Video->time_base.den = frameRate;
			m_pCodecEncodeCtx_Video->time_base.num = 1;

			m_pCodecEncodeCtx_Video->width = m_iMergeWidth;
			m_pCodecEncodeCtx_Video->height = m_iMergeHeight;
			//pH264Encoder->pCodecCtx->frame_number = 1;
			m_pCodecEncodeCtx_Video->gop_size = 12;
			m_pCodecEncodeCtx_Video->max_b_frames = 0;
			m_pCodecEncodeCtx_Video->thread_count = 4;
			m_pCodecEncodeCtx_Video->pix_fmt = AV_PIX_FMT_YUV420P;
			m_pCodecEncodeCtx_Video->codec_id = AV_CODEC_ID_H264;
			m_pCodecEncodeCtx_Video->codec_type = AVMEDIA_TYPE_VIDEO;

			av_opt_set(m_pCodecEncodeCtx_Video->priv_data, "b-pyramid", "none", 0);
			av_opt_set(m_pCodecEncodeCtx_Video->priv_data, "preset", "superfast", 0);
			av_opt_set(m_pCodecEncodeCtx_Video->priv_data, "tune", "zerolatency", 0);

			if (m_pFormatCtx_Out->oformat->flags & AVFMT_GLOBALHEADER)
				m_pCodecEncodeCtx_Video->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;

			if (avcodec_open2(m_pCodecEncodeCtx_Video, pCodecEncode_Video, 0) < 0)
			{
				//编码器打开失败，退出程序
				break;
			}
		}

		if (!(m_pFormatCtx_Out->oformat->flags & AVFMT_NOFILE))
		{
			if (avio_open(&m_pFormatCtx_Out->pb, pFileOut, AVIO_FLAG_WRITE) < 0)
			{
				break;
			}
		}

		avcodec_parameters_from_context(pVideoStream->codecpar, m_pCodecEncodeCtx_Video);

		if (avformat_write_header(m_pFormatCtx_Out, NULL) < 0)
		{
			break;
		}

		iRet = 0;
	} while (0);


	if (iRet != 0)
	{
		if (m_pCodecEncodeCtx_Video != NULL)
		{
			avcodec_free_context(&m_pCodecEncodeCtx_Video);
			m_pCodecEncodeCtx_Video = NULL;
		}

		if (m_pFormatCtx_Out != NULL)
		{
			avformat_free_context(m_pFormatCtx_Out);
			m_pFormatCtx_Out = NULL;
		}
	}

	return iRet;
}


int CVideoMerge::InitFilter(const char* filter_desc)
{
	int ret = 0;

	char args_videoPad[512];
	const char* pad_name_videoPad = "inpad";

	char args_videoA[512];
	const char* pad_name_videoA = "in0";
	char args_videoB[512];
	const char* pad_name_videoB = "in1";
	char args_videoC[512];
	const char* pad_name_videoC = "in2";
	char args_videoD[512];
	const char* pad_name_videoD = "in3";

	AVFilter* filter_src_videoPad = (AVFilter *)avfilter_get_by_name("buffer");
	AVFilter* filter_src_videoA = (AVFilter *)avfilter_get_by_name("buffer");
	AVFilter* filter_src_videoB = (AVFilter *)avfilter_get_by_name("buffer");
	AVFilter* filter_src_videoC = (AVFilter *)avfilter_get_by_name("buffer");
	AVFilter* filter_src_videoD = (AVFilter *)avfilter_get_by_name("buffer");
	AVFilter* filter_sink = (AVFilter *)avfilter_get_by_name("buffersink");

	AVFilterInOut* filter_output_videoPad = avfilter_inout_alloc();
	AVFilterInOut* filter_output_videoA = avfilter_inout_alloc();
	AVFilterInOut* filter_output_videoB = avfilter_inout_alloc();
	AVFilterInOut* filter_output_videoC = avfilter_inout_alloc();
	AVFilterInOut* filter_output_videoD = avfilter_inout_alloc();

	AVFilterInOut* filter_input = avfilter_inout_alloc();
	m_pFilterGraph = avfilter_graph_alloc();

	AVRational timeBase;
	timeBase.num = 1;
	timeBase.den = 10;


	AVRational timeAspect;
	timeAspect.num = 0;
	timeAspect.den = 1;


	_snprintf(args_videoPad, sizeof(args_videoPad),
		"video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
		m_pReadCodecCtx_VideoA->width, m_pReadCodecCtx_VideoA->height, AV_PIX_FMT_YUV420P,
		timeBase.num, timeBase.den,
		timeAspect.num,
		timeAspect.den);

	_snprintf(args_videoA, sizeof(args_videoA),
		"video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
		m_pReadCodecCtx_VideoA->width, m_pReadCodecCtx_VideoA->height, AV_PIX_FMT_YUV420P,
		timeBase.num, timeBase.den,
		timeAspect.num,
		timeAspect.den);


	_snprintf(args_videoB, sizeof(args_videoB),
		"video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
		m_pReadCodecCtx_VideoB->width, m_pReadCodecCtx_VideoB->height, AV_PIX_FMT_YUV420P,
		timeBase.num, timeBase.den,
		timeAspect.num,
		timeAspect.den);

	_snprintf(args_videoC, sizeof(args_videoC),
		"video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
		m_pReadCodecCtx_VideoC->width, m_pReadCodecCtx_VideoC->height, AV_PIX_FMT_YUV420P,
		timeBase.num, timeBase.den,
		timeAspect.num,
		timeAspect.den);

	_snprintf(args_videoD, sizeof(args_videoD),
		"video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
		m_pReadCodecCtx_VideoD->width, m_pReadCodecCtx_VideoD->height, AV_PIX_FMT_YUV420P,
		timeBase.num, timeBase.den,
		timeAspect.num,
		timeAspect.den);


	AVFilterInOut* filter_outputs[4];
	do
	{
		ret = avfilter_graph_create_filter(&m_pFilterCtxSrcVideoPad, filter_src_videoPad, pad_name_videoPad, args_videoPad, NULL, m_pFilterGraph);
		if (ret < 0)
		{
			break;
		}

		ret = avfilter_graph_create_filter(&m_pFilterCtxSrcVideoA, filter_src_videoA, pad_name_videoA, args_videoA, NULL, m_pFilterGraph);
		if (ret < 0)
		{
			break;
		}
		ret = avfilter_graph_create_filter(&m_pFilterCtxSrcVideoB, filter_src_videoB, pad_name_videoB, args_videoB, NULL, m_pFilterGraph);
		if (ret < 0)
		{
			break;
		}

		ret = avfilter_graph_create_filter(&m_pFilterCtxSrcVideoC, filter_src_videoC, pad_name_videoC, args_videoC, NULL, m_pFilterGraph);
		if (ret < 0)
		{
			break;
		}
		/*ret = avfilter_graph_create_filter(&m_pFilterCtxSrcVideoD, filter_src_videoD, pad_name_videoD, args_videoD, NULL, m_pFilterGraph);
		if (ret < 0)
		{
			break;
		}*/

		ret = avfilter_graph_create_filter(&m_pFilterCtxSink, filter_sink, "out", NULL, NULL, m_pFilterGraph);
		if (ret < 0)
		{
			break;
		}

		ret = av_opt_set_bin(m_pFilterCtxSink, "pix_fmts", (uint8_t*)&m_pCodecEncodeCtx_Video->pix_fmt, sizeof(m_pCodecEncodeCtx_Video->pix_fmt), AV_OPT_SEARCH_CHILDREN);

		filter_output_videoPad->name = av_strdup(pad_name_videoPad);
		filter_output_videoPad->filter_ctx = m_pFilterCtxSrcVideoPad;
		filter_output_videoPad->pad_idx = 0;
		filter_output_videoPad->next = filter_output_videoA;

		filter_output_videoPad->name = av_strdup(pad_name_videoPad);
		filter_output_videoPad->filter_ctx = m_pFilterCtxSrcVideoPad;
		filter_output_videoPad->pad_idx = 0;
		filter_output_videoPad->next = filter_output_videoA;

		filter_output_videoA->name = av_strdup(pad_name_videoA);
		filter_output_videoA->filter_ctx = m_pFilterCtxSrcVideoA;
		filter_output_videoA->pad_idx = 0;
		filter_output_videoA->next = filter_output_videoB;

		filter_output_videoB->name = av_strdup(pad_name_videoB);
		filter_output_videoB->filter_ctx = m_pFilterCtxSrcVideoB;
		filter_output_videoB->pad_idx = 0;
		filter_output_videoB->next = filter_output_videoC;

		filter_output_videoC->name = av_strdup(pad_name_videoC);
		filter_output_videoC->filter_ctx = m_pFilterCtxSrcVideoC;
		filter_output_videoC->pad_idx = 0;
		filter_output_videoC->next = NULL;

		filter_output_videoD->name = av_strdup(pad_name_videoD);
		filter_output_videoD->filter_ctx = m_pFilterCtxSrcVideoD;
		filter_output_videoD->pad_idx = 0;
		filter_output_videoD->next = NULL;

		filter_input->name = av_strdup("out");
		filter_input->filter_ctx = m_pFilterCtxSink;
		filter_input->pad_idx = 0;
		filter_input->next = NULL;

		filter_outputs[0] = filter_output_videoPad;
		filter_outputs[1] = filter_output_videoA;
		filter_outputs[2] = filter_output_videoB;
		filter_outputs[3] = filter_output_videoC;
		//filter_outputs[4] = filter_output_videoD;

		ret = avfilter_graph_parse_ptr(m_pFilterGraph, filter_desc, &filter_input, filter_outputs, NULL);
		if (ret < 0)
		{ 
			break;
		}

		ret = avfilter_graph_config(m_pFilterGraph, NULL);
		if (ret < 0)
		{
			break;
		}

		ret = 0;

	} while (0);


	avfilter_inout_free(&filter_input);
	av_free(filter_src_videoPad);
	av_free(filter_src_videoA);
	av_free(filter_src_videoB);
	av_free(filter_src_videoC);
	av_free(filter_src_videoD);
	avfilter_inout_free(filter_outputs);

	char* temp = avfilter_graph_dump(m_pFilterGraph, NULL);

	return ret;
}


DWORD WINAPI CVideoMerge::VideoAReadProc(LPVOID lpParam)
{
	CVideoMerge *pVideoMerge = (CVideoMerge *)lpParam;
	if (pVideoMerge != NULL)
	{
		pVideoMerge->VideoARead();
	}
	return 0;
}

void CVideoMerge::VideoARead()
{
	AVFrame *pFrame;
	pFrame = av_frame_alloc();

	int y_size = m_pReadCodecCtx_VideoA->width * m_pReadCodecCtx_VideoA->height;

	AVPacket packet = { 0 };
	int ret = 0;

	char *pY = new char[y_size];
	char *pU = new char[y_size / 4];
	char *pV = new char[y_size / 4];


	while (1)
	{
		av_packet_unref(&packet);

		ret = av_read_frame(m_pFormatCtx_FileA, &packet);
		if (ret == AVERROR(EAGAIN))
		{
			continue;
		}
		else if (ret == AVERROR_EOF)
		{
			break;
		}
		else if (ret < 0) 
		{
			break;
		}

		ret = avcodec_send_packet(m_pReadCodecCtx_VideoA, &packet);

		if (ret >= 0)
		{
			ret = avcodec_receive_frame(m_pReadCodecCtx_VideoA, pFrame);
			if (ret == AVERROR(EAGAIN))
			{
				continue;
			}
			else if (ret == AVERROR_EOF)
			{
				break;
			}
			else if (ret < 0) {
				break;
			}
			while (1)
			{
				if (av_fifo_space(m_pVideoAFifo) >= m_iYuv420FrameSize)
				{
					///Y
					int contY = 0;
					for (int i = 0; i < pFrame->height; i++)
					{
						memcpy(pY + contY, pFrame->data[0] + i * pFrame->linesize[0], pFrame->width);
						contY += pFrame->width;
					}


					///U
					int contU = 0;
					for (int i = 0; i < pFrame->height / 2; i++)
					{
						memcpy(pU + contU, pFrame->data[1] + i * pFrame->linesize[1], pFrame->width / 2);
						contU += pFrame->width / 2;
					}


					///V
					int contV = 0;
					for (int i = 0; i < pFrame->height / 2; i++)
					{
						memcpy(pV + contV, pFrame->data[2] + i * pFrame->linesize[2], pFrame->width / 2);
						contV += pFrame->width / 2;
					}


					EnterCriticalSection(&m_csVideoASection);
					av_fifo_generic_write(m_pVideoAFifo, pY, y_size, NULL);
					av_fifo_generic_write(m_pVideoAFifo, pU, y_size / 4, NULL);
					av_fifo_generic_write(m_pVideoAFifo, pV, y_size / 4, NULL);
					LeaveCriticalSection(&m_csVideoASection);

					break;
				}
				else
				{
					Sleep(100);
				}
			}

		}


		if (ret == AVERROR(EAGAIN))
		{
			continue;
		}
	}

	delete[] pY;
	delete[] pU;
	delete[] pV;

	av_frame_free(&pFrame);
}

DWORD WINAPI CVideoMerge::VideoBReadProc(LPVOID lpParam)
{
	CVideoMerge *pVideoMerge = (CVideoMerge *)lpParam;
	if (pVideoMerge != NULL)
	{
		pVideoMerge->VideoBRead();
	}
	return 0;
}

void CVideoMerge::VideoBRead()
{
	AVFrame *pFrame;
	pFrame = av_frame_alloc();

	int y_size = m_pReadCodecCtx_VideoB->width * m_pReadCodecCtx_VideoB->height;

	AVPacket packet = { 0 };
	int ret = 0;

	int iCount = 0;

	char *pY = new char[y_size];
	char *pU = new char[y_size / 4];
	char *pV = new char[y_size / 4];

	while (1)
	{
		av_packet_unref(&packet);

		ret = av_read_frame(m_pFormatCtx_FileB, &packet);
		if (ret == AVERROR(EAGAIN))
		{
			continue;
		}
		else if (ret == AVERROR_EOF)
		{
			break;
		}
		else if (ret < 0)
		{
			break;
		}

		ret = avcodec_send_packet(m_pReadCodecCtx_VideoB, &packet);

		if (ret >= 0)
		{
			ret = avcodec_receive_frame(m_pReadCodecCtx_VideoB, pFrame);
			if (ret == AVERROR(EAGAIN))
			{
				continue;
			}
			else if (ret == AVERROR_EOF)
			{
				break;
			}
			else if (ret < 0) {
				break;
			}

			while (1)
			{
				if (av_fifo_space(m_pVideoBFifo) >= m_iYuv420FrameSize)
				{
					///Y
					int contY = 0;
					for (int i = 0; i < pFrame->height; i++)
					{
						memcpy(pY + contY, pFrame->data[0] + i * pFrame->linesize[0], pFrame->width);
						contY += pFrame->width;
					}


					///U
					int contU = 0;
					for (int i = 0; i < pFrame->height / 2; i++)
					{
						memcpy(pU + contU, pFrame->data[1] + i * pFrame->linesize[1], pFrame->width / 2);
						contU += pFrame->width / 2;
					}


					///V
					int contV = 0;
					for (int i = 0; i < pFrame->height / 2; i++)
					{
						memcpy(pV + contV, pFrame->data[2] + i * pFrame->linesize[2], pFrame->width / 2);
						contV += pFrame->width / 2;
					}


					EnterCriticalSection(&m_csVideoBSection);
					av_fifo_generic_write(m_pVideoBFifo, pY, y_size, NULL);
					av_fifo_generic_write(m_pVideoBFifo, pU, y_size / 4, NULL);
					av_fifo_generic_write(m_pVideoBFifo, pV, y_size / 4, NULL);
					LeaveCriticalSection(&m_csVideoBSection);

					break;
				}
				else
				{
					Sleep(100);
				}
			}
		}


		if (ret == AVERROR(EAGAIN))
		{
			continue;
		}
	}

	delete[] pY;
	delete[] pU;
	delete[] pV;

	av_frame_free(&pFrame);
}

DWORD WINAPI CVideoMerge::VideoCReadProc(LPVOID lpParam)
{
	CVideoMerge *pVideoMerge = (CVideoMerge *)lpParam;
	if (pVideoMerge != NULL)
	{
		pVideoMerge->VideoCRead();
	}
	return 0;
}

void CVideoMerge::VideoCRead()
{
	AVFrame *pFrame;
	pFrame = av_frame_alloc();

	int y_size = m_pReadCodecCtx_VideoC->width * m_pReadCodecCtx_VideoC->height;

	AVPacket packet = { 0 };
	int ret = 0;

	int iCount = 0;

	char *pY = new char[y_size];
	char *pU = new char[y_size / 4];
	char *pV = new char[y_size / 4];

	while (1)
	{
		av_packet_unref(&packet);

		ret = av_read_frame(m_pFormatCtx_FileC, &packet);
		if (ret == AVERROR(EAGAIN))
		{
			continue;
		}
		else if (ret == AVERROR_EOF)
		{
			break;
		}
		else if (ret < 0)
		{
			break;
		}

		ret = avcodec_send_packet(m_pReadCodecCtx_VideoC, &packet);

		if (ret >= 0)
		{
			ret = avcodec_receive_frame(m_pReadCodecCtx_VideoC, pFrame);
			if (ret == AVERROR(EAGAIN))
			{
				continue;
			}
			else if (ret == AVERROR_EOF)
			{
				break;
			}
			else if (ret < 0) {
				break;
			}

			while (1)
			{
				if (av_fifo_space(m_pVideoCFifo) >= m_iYuv420FrameSize)
				{
					///Y
					int contY = 0;
					for (int i = 0; i < pFrame->height; i++)
					{
						memcpy(pY + contY, pFrame->data[0] + i * pFrame->linesize[0], pFrame->width);
						contY += pFrame->width;
					}


					///U
					int contU = 0;
					for (int i = 0; i < pFrame->height / 2; i++)
					{
						memcpy(pU + contU, pFrame->data[1] + i * pFrame->linesize[1], pFrame->width / 2);
						contU += pFrame->width / 2;
					}


					///V
					int contV = 0;
					for (int i = 0; i < pFrame->height / 2; i++)
					{
						memcpy(pV + contV, pFrame->data[2] + i * pFrame->linesize[2], pFrame->width / 2);
						contV += pFrame->width / 2;
					}

					EnterCriticalSection(&m_csVideoCSection);
					av_fifo_generic_write(m_pVideoCFifo, pY, y_size, NULL);
					av_fifo_generic_write(m_pVideoCFifo, pU, y_size / 4, NULL);
					av_fifo_generic_write(m_pVideoCFifo, pV, y_size / 4, NULL);
					LeaveCriticalSection(&m_csVideoCSection);

					break;
				}
				else
				{
					Sleep(100);
				}
			}
		}


		if (ret == AVERROR(EAGAIN))
		{
			continue;
		}
	}

	delete[] pY;
	delete[] pU;
	delete[] pV;

	av_frame_free(&pFrame);
}

DWORD WINAPI CVideoMerge::VideoDReadProc(LPVOID lpParam)
{
	CVideoMerge *pVideoMerge = (CVideoMerge *)lpParam;
	if (pVideoMerge != NULL)
	{
		pVideoMerge->VideoDRead();
	}
	return 0;
}

void CVideoMerge::VideoDRead()
{
	AVFrame *pFrame;
	pFrame = av_frame_alloc();

	int y_size = m_pReadCodecCtx_VideoD->width * m_pReadCodecCtx_VideoD->height;

	AVPacket packet = { 0 };
	int ret = 0;

	int iCount = 0;

	char *pY = new char[y_size];
	char *pU = new char[y_size / 4];
	char *pV = new char[y_size / 4];

	while (1)
	{
		av_packet_unref(&packet);

		ret = av_read_frame(m_pFormatCtx_FileD, &packet);
		if (ret == AVERROR(EAGAIN))
		{
			continue;
		}
		else if (ret == AVERROR_EOF)
		{
			break;
		}
		else if (ret < 0)
		{
			break;
		}

		ret = avcodec_send_packet(m_pReadCodecCtx_VideoD, &packet);

		if (ret >= 0)
		{
			ret = avcodec_receive_frame(m_pReadCodecCtx_VideoD, pFrame);
			if (ret == AVERROR(EAGAIN))
			{
				continue;
			}
			else if (ret == AVERROR_EOF)
			{
				break;
			}
			else if (ret < 0) {
				break;
			}

			while (1)
			{
				if (av_fifo_space(m_pVideoDFifo) >= m_iYuv420FrameSize)
				{
					///Y
					int contY = 0;
					for (int i = 0; i < pFrame->height; i++)
					{
						memcpy(pY + contY, pFrame->data[0] + i * pFrame->linesize[0], pFrame->width);
						contY += pFrame->width;
					}


					///U
					int contU = 0;
					for (int i = 0; i < pFrame->height / 2; i++)
					{
						memcpy(pU + contU, pFrame->data[1] + i * pFrame->linesize[1], pFrame->width / 2);
						contU += pFrame->width / 2;
					}


					///V
					int contV = 0;
					for (int i = 0; i < pFrame->height / 2; i++)
					{
						memcpy(pV + contV, pFrame->data[2] + i * pFrame->linesize[2], pFrame->width / 2);
						contV += pFrame->width / 2;
					}


					EnterCriticalSection(&m_csVideoDSection);
					av_fifo_generic_write(m_pVideoDFifo, pY, y_size, NULL);
					av_fifo_generic_write(m_pVideoDFifo, pU, y_size / 4, NULL);
					av_fifo_generic_write(m_pVideoDFifo, pV, y_size / 4, NULL);
					LeaveCriticalSection(&m_csVideoDSection);

					break;
				}
				else
				{
					Sleep(100);
				}
			}
		}


		if (ret == AVERROR(EAGAIN))
		{
			continue;
		}
	}

	delete[] pY;
	delete[] pU;
	delete[] pV;

	av_frame_free(&pFrame);
}



DWORD WINAPI CVideoMerge::VideoMergeProc(LPVOID lpParam)
{
	CVideoMerge *pVideoMerge = (CVideoMerge *)lpParam;
	if (pVideoMerge != NULL)
	{
		pVideoMerge->VideoMerge();
	}
	return 0;
}


void CVideoMerge::VideoMerge()
{
	int ret = 0;


	AVFrame *pFrameVideoPad = av_frame_alloc();
	uint8_t *videoPad_buffer_yuv420 = (uint8_t *)av_malloc(m_iYuv420FrameSize);
	av_image_fill_arrays(pFrameVideoPad->data, pFrameVideoPad->linesize, videoPad_buffer_yuv420, AV_PIX_FMT_YUV420P, m_pReadCodecCtx_VideoA->width, m_pReadCodecCtx_VideoA->height, 1);

	memset(pFrameVideoPad->data[0], 0, m_pReadCodecCtx_VideoA->width * m_pReadCodecCtx_VideoA->height);
	memset(pFrameVideoPad->data[1], 128, m_pReadCodecCtx_VideoA->width * m_pReadCodecCtx_VideoA->height / 4);
	memset(pFrameVideoPad->data[2], 128, m_pReadCodecCtx_VideoA->width * m_pReadCodecCtx_VideoA->height / 4);

	AVFrame *pFrameVideoA = av_frame_alloc();
	uint8_t *videoA_buffer_yuv420 = (uint8_t *)av_malloc(m_iYuv420FrameSize);
	av_image_fill_arrays(pFrameVideoA->data, pFrameVideoA->linesize, videoA_buffer_yuv420, AV_PIX_FMT_YUV420P, m_pReadCodecCtx_VideoA->width, m_pReadCodecCtx_VideoA->height, 1);


	AVFrame *pFrameVideoB = av_frame_alloc();
	uint8_t *videoB_buffer_yuv420 = (uint8_t *)av_malloc(m_iYuv420FrameSize);
	av_image_fill_arrays(pFrameVideoB->data, pFrameVideoB->linesize, videoB_buffer_yuv420, AV_PIX_FMT_YUV420P, m_pReadCodecCtx_VideoB->width, m_pReadCodecCtx_VideoB->height, 1);

	AVFrame *pFrameVideoC = av_frame_alloc();
	uint8_t *videoC_buffer_yuv420 = (uint8_t *)av_malloc(m_iYuv420FrameSize);
	av_image_fill_arrays(pFrameVideoC->data, pFrameVideoC->linesize, videoC_buffer_yuv420, AV_PIX_FMT_YUV420P, m_pReadCodecCtx_VideoC->width, m_pReadCodecCtx_VideoC->height, 1);

	AVFrame *pFrameVideoD = av_frame_alloc();
	uint8_t *videoD_buffer_yuv420 = (uint8_t *)av_malloc(m_iYuv420FrameSize);
	av_image_fill_arrays(pFrameVideoD->data, pFrameVideoD->linesize, videoD_buffer_yuv420, AV_PIX_FMT_YUV420P, m_pReadCodecCtx_VideoD->width, m_pReadCodecCtx_VideoD->height, 1);


	int iOutVideoWidth = m_pReadCodecCtx_VideoB->width;
	int iOutVideoHeight = m_pReadCodecCtx_VideoB->height;

	AVPacket packet = { 0 };
	int iPicCount = 0;

	AVFrame* pFrame_out = av_frame_alloc();
	uint8_t *out_buffer_yuv420 = (uint8_t *)av_malloc(m_iYuv420FrameSize);
	av_image_fill_arrays(pFrame_out->data, pFrame_out->linesize, out_buffer_yuv420, AV_PIX_FMT_YUV420P, m_pReadCodecCtx_VideoA->width, m_pReadCodecCtx_VideoA->height, 1);

	while (1)
	{
		if (NULL == m_pVideoAFifo)
		{
			break;
		}
		if (NULL == m_pVideoBFifo)
		{
			break;
		}
		if (NULL == m_pVideoCFifo)
		{
			break;
		}
		if (NULL == m_pVideoDFifo)
		{
			break;
		}

		int iVideoASize = av_fifo_size(m_pVideoAFifo);
		int iVideoBSize = av_fifo_size(m_pVideoBFifo);
		int iVideoCSize = av_fifo_size(m_pVideoCFifo);
		int iVideoDSize = av_fifo_size(m_pVideoDFifo);

		if (iVideoASize >= m_iYuv420FrameSize && iVideoBSize >= m_iYuv420FrameSize && iVideoCSize >= m_iYuv420FrameSize && iVideoDSize >= m_iYuv420FrameSize)
		{
			EnterCriticalSection(&m_csVideoASection);
			av_fifo_generic_read(m_pVideoAFifo, videoA_buffer_yuv420, m_iYuv420FrameSize, NULL);
			LeaveCriticalSection(&m_csVideoASection);

			//memcpy(videoPad_buffer_yuv420, videoA_buffer_yuv420, m_iYuv420FrameSize);


			EnterCriticalSection(&m_csVideoBSection);
			av_fifo_generic_read(m_pVideoBFifo, videoB_buffer_yuv420, m_iYuv420FrameSize, NULL);
			LeaveCriticalSection(&m_csVideoBSection);

			EnterCriticalSection(&m_csVideoCSection);
			av_fifo_generic_read(m_pVideoCFifo, videoC_buffer_yuv420, m_iYuv420FrameSize, NULL);
			LeaveCriticalSection(&m_csVideoCSection);

			EnterCriticalSection(&m_csVideoDSection);
			av_fifo_generic_read(m_pVideoDFifo, videoD_buffer_yuv420, m_iYuv420FrameSize, NULL);
			LeaveCriticalSection(&m_csVideoDSection);



			pFrameVideoPad->pkt_dts = pFrameVideoPad->pts = av_rescale_q_rnd(iPicCount, m_pCodecEncodeCtx_Video->time_base, m_pFormatCtx_Out->streams[0]->time_base, (AVRounding)(AV_ROUND_NEAR_INF | AV_ROUND_PASS_MINMAX));
			pFrameVideoPad->pkt_duration = 0;
			pFrameVideoPad->pkt_pos = -1;

			pFrameVideoPad->width = iOutVideoWidth;
			pFrameVideoPad->height = iOutVideoHeight;
			pFrameVideoPad->format = AV_PIX_FMT_YUV420P;


			pFrameVideoA->pkt_dts = pFrameVideoA->pts = av_rescale_q_rnd(iPicCount, m_pCodecEncodeCtx_Video->time_base, m_pFormatCtx_Out->streams[0]->time_base, (AVRounding)(AV_ROUND_NEAR_INF | AV_ROUND_PASS_MINMAX));
			pFrameVideoA->pkt_duration = 0;
			pFrameVideoA->pkt_pos = -1;

			pFrameVideoA->width = iOutVideoWidth;
			pFrameVideoA->height = iOutVideoHeight;
			pFrameVideoA->format = AV_PIX_FMT_YUV420P;



			pFrameVideoB->pkt_dts = pFrameVideoB->pts = av_rescale_q_rnd(iPicCount, m_pCodecEncodeCtx_Video->time_base, m_pFormatCtx_Out->streams[0]->time_base, (AVRounding)(AV_ROUND_NEAR_INF | AV_ROUND_PASS_MINMAX));
			pFrameVideoB->pkt_duration = 0;
			pFrameVideoB->pkt_pos = -1;

			pFrameVideoB->width = iOutVideoWidth;
			pFrameVideoB->height = iOutVideoHeight;
			pFrameVideoB->format = AV_PIX_FMT_YUV420P;

			pFrameVideoC->pkt_dts = pFrameVideoC->pts = av_rescale_q_rnd(iPicCount, m_pCodecEncodeCtx_Video->time_base, m_pFormatCtx_Out->streams[0]->time_base, (AVRounding)(AV_ROUND_NEAR_INF | AV_ROUND_PASS_MINMAX));
			pFrameVideoC->pkt_duration = 0;
			pFrameVideoC->pkt_pos = -1;

			pFrameVideoC->width = iOutVideoWidth;
			pFrameVideoC->height = iOutVideoHeight;
			pFrameVideoC->format = AV_PIX_FMT_YUV420P;


			pFrameVideoD->pkt_dts = pFrameVideoD->pts = av_rescale_q_rnd(iPicCount, m_pCodecEncodeCtx_Video->time_base, m_pFormatCtx_Out->streams[0]->time_base, (AVRounding)(AV_ROUND_NEAR_INF | AV_ROUND_PASS_MINMAX));
			pFrameVideoD->pkt_duration = 0;
			pFrameVideoD->pkt_pos = -1;

			pFrameVideoD->width = iOutVideoWidth;
			pFrameVideoD->height = iOutVideoHeight;
			pFrameVideoD->format = AV_PIX_FMT_YUV420P;

			//if (iPicCount == 0)
			{
				LOG_INFO("begin av_buffersrc_add_frame");
				//ret = av_buffersrc_add_frame_flags(m_pFilterCtxSrcVideoA, pFrameVideoA, 0);

				ret = av_buffersrc_add_frame(m_pFilterCtxSrcVideoPad, pFrameVideoPad);
				if (ret < 0)
				{
					break;
				}

				ret = av_buffersrc_add_frame(m_pFilterCtxSrcVideoA, pFrameVideoA);
				if (ret < 0)
				{
					break;
				}

				//ret = av_buffersrc_add_frame_flags(m_pFilterCtxSrcVideoB, pFrameVideoB, 0);
				ret = av_buffersrc_add_frame(m_pFilterCtxSrcVideoB, pFrameVideoB);
				if (ret < 0)
				{
					break;
				}

				ret = av_buffersrc_add_frame(m_pFilterCtxSrcVideoC, pFrameVideoC);
				if (ret < 0)
				{
					break;
				}

				/*ret = av_buffersrc_add_frame(m_pFilterCtxSrcVideoD, pFrameVideoD);
				if (ret < 0)
				{
					break;
				}*/
			}
			
			do
			{
				//while (1)
				{
					ret = av_buffersink_get_frame(m_pFilterCtxSink, pFrame_out);
					if (ret < 0)
					{
						//printf("Mixer: failed to call av_buffersink_get_frame_flags\n");
						break;
					}

					LOG_INFO("end av_buffersink_get_frame_flags");

					pFrame_out->pkt_dts = pFrame_out->pts = av_rescale_q_rnd(iPicCount, m_pCodecEncodeCtx_Video->time_base, m_pFormatCtx_Out->streams[0]->time_base, (AVRounding)(AV_ROUND_NEAR_INF | AV_ROUND_PASS_MINMAX));
					pFrame_out->pkt_duration = 0;
					pFrame_out->pkt_pos = -1;

					pFrame_out->width = m_iMergeWidth;
					pFrame_out->height = m_iMergeHeight;
					pFrame_out->format = AV_PIX_FMT_YUV420P;

					ret = avcodec_send_frame(m_pCodecEncodeCtx_Video, pFrame_out);

					ret = avcodec_receive_packet(m_pCodecEncodeCtx_Video, &packet);

					av_write_frame(m_pFormatCtx_Out, &packet);

					iPicCount++;

					av_frame_unref(pFrame_out);
				}

			} while (0);
		}
		else
		{
			if (m_hVideoAReadThread == NULL && m_hVideoBReadThread == NULL)
			{
				break;
			}
			Sleep(1);
		}
	}

	av_write_trailer(m_pFormatCtx_Out);
	avio_close(m_pFormatCtx_Out->pb);

	av_frame_free(&pFrame_out);

	av_frame_free(&pFrameVideoA);
	av_frame_free(&pFrameVideoB);
	av_frame_free(&pFrameVideoC);
	av_frame_free(&pFrameVideoD);
}
tusong86
关注
FFmpeg合并多个分辨率不同的视频时遇到的问题
weixin_44821368的博客
07-29 1395
使用ffmpeg开发混剪视频工具的时候遇到了下面的问题
ffmpeg把宽视频（1920*1080）叠加成长（上中下）视频（1280*720）
追求卓越，成功就在不经意间追上你
07-14 6941
背景 以前我们看视频都是通过电脑，或者手机横屏来看，但是目前短视频的平台都是长视频（竖型视频），主流的分辨率是7201280。所以很多人想19201080的宽视频，变成长视频，但是如果不多个视频叠加，那么上下会为空白，很是不好看。为了能让视觉效果更好，一般我们采用上中下三个叠加在一起的办法，那么下面我们就通过ffmpeg来实现这个想法。 准备 我们先去西瓜下载一个1920*1080的李子柒的视频，通过简单的ffmpeg命令截取前10s，方便我们快速合成。 ffmpeg -t 10 -i liziqi_10
FFmpeg 图片合成视频
06-12 2万+
ffmpeg -f image2 -i /images/%d.jpg -vcodec libx264 -r 25 -b 200k test.mp4 （1）-r 25 表示每秒播放25帧 （2）-b 200k 指定码率为200k 视频码率是数据传输时单位时间传送的数据单位 码率就是取样率，单位时间内取样率越大，精度就越高，做出来的文件就越接近原始文件但是文件体积与取样率是
FFmpeg 全面教程：从安装到高级应用
最新发布
qq_56591814的博客
10-03 2055
安装：mp4调整大小-t 1800-c copy视频转gifffmpeg -i 密室6.mp4 -ss 431 -to 442 -vf “fps=10,scale=640:-1” -c:v gif video1.gifffmpeg -i “水果缤纷.mp4” -ss 00:00:20 -to 00:00:28 -vf “fps=10,scale=640:-1” -loop 0 output.gif。
ffmpeg将png/jpg图片序列转成mp4/avi
07-15
C++代码将图片序列（png、jpg等格式）合成为视频（mp4、avi等格式）
使用 FFmpeg 轻松调整视频的大小/缩放/更改分辨率
m0_73443478的博客
01-19 1万+
使用 FFmpeg 轻松调整视频的大小/缩放/更改分辨率
ffmpeg视频合并
anbinger2013的专栏
10-12 1001
有如下2种方法： 前提，合并文件需要分辨率，格式等参数严格相同。 一、    /ffmpeg -y -i 1.3gp -i 2.3gp -filter_complex 'concat' -c:v libx264 -c:a aac -strict -2 out.3gp   ---这种方式需要重新编码 二、    ffmpeg -f concat -i list.txt -c copy 
精选资源
FFmpeg_Joiner视频无损合并工具3.0
08-15
3. Readme-说明.htm：这个文件包含了关于如何使用FFmpeg_Joiner的详细指南和注意事项，包括如何添加视频文件、设置输出格式以及开始合并等步骤。 4. filelist.txt：用户可以在这个文本文件中列出要合并的视频文件...
ffmpeg 视频剪切与合并，时间不精确的问题
only_a_Heroic_car的博客
09-25 3229
ffmpeg 时间不精准
FFmpeg 音视频同步问题
llhllq2015的博客
11-25 1756
在使用 FFmpeg 进行开发时，音视频同步问题是一个常见且复杂的问题，涉及到时间戳管理、帧率处理、以及容器格式的支持等多个方面。
精选资源
FFMPEG视频反向解码-倒放.zip
04-07
4. **注意事项**：视频倒放可能会增加文件大小，因为时间戳的反转可能导致编码效率降低。此外，如果视频包含无法倒放的元素（如文字滚动或人物动作），倒放可能造成不连贯的视觉效果。 5. **实际应用**：这种倒放...
借助ffmpeg实现Windows下 视频转码视频，截取视频，合并视频，调整播放速度，改变视频文件大小（分辨率）。 安装方法、使用命令如下：
09-06
本文详细描述以下过程，都是亲自验证过有效的，Windows 上安装 FFmpeg 程序，实现视频转码，截取，合并视频，比如截取 10 秒的视频，还可调整播放速度， 还可从 mp4 文件中提取出 MP3 音频，去掉视频里的声音（静音），改变视频文件大小（分辨率）
ffmpeg无损合并视频
11-12
ffmpeg无损合并视频
qt 基于ffmpeg 实现视频的拼接、合并
10-16
qt 基于ffmpeg 实现视频的拼接、合并，只针对同格式，同分辨率的视频，不同格式不通过分辨率的视频需要从新进行解码和编码，附带FFmepg第三方库，windos和linux都有
java使用ffmpeg合并视频
03-28
#### 注意事项 - 确保 FFmpeg 可执行文件已安装并且可以在系统的 PATH 环境变量中找到，或者提供完整的可执行文件路径。 - 输入视频应具有相同的分辨率、帧率和其他编解码器参数；否则可能需要先统一转换再进行拼接...
ffmpeg libx264_编程小短文：FFmpeg视频画面尺寸调整，必知必会
weixin_39926639的博客
11-30 480
引言FFmpeg是音视频处理领域，应用范围最广的一个项目。我们日常使用的大小桌面版视频播放器，或者命令行使用的播放器，大多数是基于 ffmpeg 开发的。如果说它是音视频编解码处理中的老大哥，这一点都不为过。本文主要从一个小知识点作为切入面，深入介绍一下，如何有效地压缩和降低视频文件的体积。问题的提出有一位题主遇到下面的情况，他有一个视频文件，宽高比是 1024x576，现在想要将尺寸调整为 72...
使用ffmpeg合并视频文件的三种方法
热门推荐
爱自在的专栏
06-14 6万+
原文  http://itindex.net/detail/52379-ffmpeg-合并-视频 主题 FFmpeg ffmpeg合并视频的方法有三种。国内大多数仅介绍了其中之一。于是觉得有必要翻译一下。其实在ffmpeg的 FAQ文档中有比较详细的说明。 使用concat协议进行视频文件的合并 这种方式的适用场景是：视频容器是MPEG-1, MPEG-2
FFmpeg之——获取上传视频的尺寸（长、宽）
run__ning的博客
01-03 2133
获取视频尺寸通常需要借助第三方库FFmpeg。首先，确保你的系统中已安装了FFmpeg，并且FFmpeg的可执行文件路径已经添加到你的系统环境变量中。
ffmpeg缩放视频尺寸
小小的熊的博客
08-05 1万+
FFmpeg有一个非常强大的缩放过滤器，可用于完成各种任务。其中一些列在这里。更多信息可以在官方文档中找到。 在所有示例中，起始图像（input.jpg）将是这一个（535⨉346像素）： 简单重新缩放 如果您只需将视频大小调整为特定大小（例如320⨉240），则可以使用最基本形式的缩放滤镜： ffmpeg -i input.avi -vf scale = 320：240 output.avi 同样适用于图像： ffmpeg -i input.jpg -vf scale = 320：.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值