ffmpeg利用滤镜合并两个视频，一左一右---avfilter_link实现

已于 2022-01-21 15:37:15 修改
阅读量1.9k 收藏 1
点赞数
文章标签： 音视频
于 2022-01-17 22:14:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tusong86/article/details/122549507
版权

之前写过一篇博客ffmpeg利用滤镜合并两个视频，一左一右

用的是滤镜字符串解析avfilter_graph_parse_ptr实现滤镜的连接，查看了avfilter_graph_parse_ptr的实现，里面调用了avfilter_link进行滤镜的连接。
今天直接用avfilter_link的方式进行实现。
需要说明的是，针对之前的滤镜配置字符串而言。

[in0]split[main][tmp];[tmp]scale=w=960:h=1080[inn0];[main][inn0]overlay=0:0[x1];[in1]scale=w=960:h=1080[inn1];[x1][inn1]overlay=960:0[out]

split滤镜分裂成main和tmp，其中main对应的pad index为0。tmp对应的pad index为1。
对于[main][inn0]overlay=0:0[x1]这种overlay滤镜而言，main对应的pad index为0，inn0对应的pad index为1.

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

// FfmpegFilterTest.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#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 = "E:\\learn\\ffmpeg\\FfmpegFilterTest\\x64\\Release\\in-vs.mp4";
	const char *pFileB = "E:\\learn\\ffmpeg\\FfmpegFilterTest\\x64\\Release\\in-e.mp4";

	const char *pFileOut = "E:\\learn\\ffmpeg\\FfmpegFilterTest\\x64\\Release\\out-merge.mp4";
	cVideoMerge.StartMerge(pFileA, pFileB, 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 *pFileOut);
	int WaitFinish();
private:
	int OpenFileA(const char *pFileA);
	int OpenFileB(const char *pFileB);
	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 VideoMergeProc(LPVOID lpParam);
	void VideoMerge();
private:
	AVFormatContext *m_pFormatCtx_FileA = NULL;
	AVFormatContext *m_pFormatCtx_FileB = NULL;

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

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

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

	AVFifoBuffer *m_pVideoAFifo = NULL;
	AVFifoBuffer *m_pVideoBFifo = NULL;

	AVFilterGraph* m_pFilterGraph = NULL;
	AVFilterContext* m_pFilterCtxSrcVideoPad = NULL;
	AVFilterContext* m_pFilterCtxSrcVideoA = NULL;
	AVFilterContext* m_pFilterCtxSrcVideoB = 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;
	HANDLE m_hVideoAReadThread = NULL;
	HANDLE m_hVideoBReadThread = NULL;
	HANDLE m_hVideoMergeThread = NULL;
};

VideoMerge.cpp的代码如下：


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





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

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

int CVideoMerge::StartMerge(const char *pFileA, const char *pFileB, const char *pFileOut)
{
	avdevice_register_all();

	int ret = -1;
	do
	{
		ret = OpenFileA(pFileA);
		if (ret != 0)
		{
			break;
		}

		ret = OpenFileB(pFileB);
		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];[tmp]scale=w=960:h=1080[inn0];[main][inn0]overlay=0:0[x1];[in1]scale=w=960:h=1080[inn1];[x1][inn1]overlay=960:0[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_hVideoAReadThread = CreateThread(NULL, 0, VideoAReadProc, this, 0, NULL);
		m_hVideoBReadThread = CreateThread(NULL, 0, VideoBReadProc, 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);

		CloseHandle(m_hVideoAReadThread);
		m_hVideoAReadThread = NULL;
		CloseHandle(m_hVideoBReadThread);
		m_hVideoBReadThread = 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::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;
}

//const char* filter_desc = "[in0]split[main][tmp];[tmp]scale=w=960:h=1080[inn0];[main][inn0]overlay=0:0[x1];[in1]scale=w=960:h=1080[inn1];[x1][inn1]overlay=960:0[out]";
int CVideoMerge::InitFilter(const char* filter_desc)
{
	int ret = 0;

	char args_pad[512];
	const char* pad_name_videoPad = "pad0";

	char args_videoA[512];
	const char* pad_name_videoA = "in0";
	char args_videoB[512];
	const char* pad_name_videoB = "in1";

	const char* scale_Tmp = "tmp";

	AVFilter* filter_src_videoPad = (AVFilter *)avfilter_get_by_name("pad");
	AVFilter* filter_src_videoA = (AVFilter *)avfilter_get_by_name("buffer");
	AVFilter* filter_src_videoB = (AVFilter *)avfilter_get_by_name("buffer");
	AVFilter* filter_sink = (AVFilter *)avfilter_get_by_name("buffersink");
	AVFilter *filter_split = (AVFilter *)avfilter_get_by_name("split");
	AVFilter *filter_overlayVideoA = (AVFilter *)avfilter_get_by_name("overlay");
	AVFilter *filter_overlayVideoB = (AVFilter *)avfilter_get_by_name("overlay");

	AVFilter *filter_scaleTmp = (AVFilter *)avfilter_get_by_name("scale");
	AVFilter *filter_scaleVideoB = (AVFilter *)avfilter_get_by_name("scale");


	AVFilterInOut* filter_output_videoPad = avfilter_inout_alloc();
	AVFilterInOut* filter_output_videoA = avfilter_inout_alloc();
	AVFilterInOut* filter_output_videoB = 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_pad, sizeof(args_pad), "width=%d:height=%d", 1920, 1080);


	_snprintf(args_videoA, sizeof(args_videoA),
		"video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
		1920, 1080, 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",
		1920, 1080, AV_PIX_FMT_YUV420P,
		timeBase.num, timeBase.den,
		timeAspect.num,
		timeAspect.den);


	AVFilterInOut* filter_outputs[3];
	do
	{
		AVFilterContext *splitFilter_ctx;
		ret = avfilter_graph_create_filter(&splitFilter_ctx, filter_split, "split", "outputs=2", NULL, m_pFilterGraph);
		if (ret < 0)
		{
			break;
		}

		AVFilterContext *overlayVideoAFilter_ctx;
		ret = avfilter_graph_create_filter(&overlayVideoAFilter_ctx, filter_overlayVideoA, "overlayVideoA", "x=0:y=0", NULL, m_pFilterGraph);
		if (ret < 0) 
		{
			break;
		}

		AVFilterContext *overlayVideoBFilter_ctx;
		ret = avfilter_graph_create_filter(&overlayVideoBFilter_ctx, filter_overlayVideoB, "overlayVideoB", "x=960:y=0", NULL, m_pFilterGraph);
		if (ret < 0)
		{
			break;
		}

		AVFilterContext *scaleTmpFilter_ctx;
		ret = avfilter_graph_create_filter(&scaleTmpFilter_ctx, filter_scaleTmp, "tmp", "w=960:h=1080", NULL, m_pFilterGraph);
		if (ret < 0)
		{
			break;
		}

		AVFilterContext *scaleVideoBFilter_ctx;
		ret = avfilter_graph_create_filter(&scaleVideoBFilter_ctx, filter_scaleVideoB, "in1", "w=960:h=1080", 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_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);



		//const char* filter_desc = "[in0]split[main][tmp];[tmp]scale=w=960:h=1080[inn0];[main][inn0]overlay=0:0[x1];[in1]scale=w=960:h=1080[inn1];[x1][inn1]overlay=960:0[out]";
		ret = avfilter_link(m_pFilterCtxSrcVideoA, 0, splitFilter_ctx, 0);
		if (ret != 0) 
		{
			break;
		}

		ret = avfilter_link(splitFilter_ctx, 1, scaleTmpFilter_ctx, 0);
		if (ret != 0) 
		{
			break;
		}

		ret = avfilter_link(splitFilter_ctx, 0, overlayVideoAFilter_ctx, 0);
		if (ret != 0)
		{
			break;
		}

		ret = avfilter_link(scaleTmpFilter_ctx, 0, overlayVideoAFilter_ctx, 1);
		if (ret != 0)
		{
			break;
		}


		ret = avfilter_link(m_pFilterCtxSrcVideoB, 0, scaleVideoBFilter_ctx, 0);
		if (ret != 0)
		{
			break;
		}


		ret = avfilter_link(overlayVideoAFilter_ctx, 0, overlayVideoBFilter_ctx, 0);
		if (ret != 0)
		{
			break;
		}
		ret = avfilter_link(scaleVideoBFilter_ctx, 0, overlayVideoBFilter_ctx, 1);
		if (ret != 0)
		{
			break;
		}

		ret = avfilter_link(overlayVideoBFilter_ctx, 0, m_pFilterCtxSink, 0);
		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_videoA);
	av_free(filter_src_videoB);
	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;
	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)
				{
					EnterCriticalSection(&m_csVideoASection);
					av_fifo_generic_write(m_pVideoAFifo, pFrame->data[0], y_size, NULL);
					av_fifo_generic_write(m_pVideoAFifo, pFrame->data[1], y_size / 4, NULL);
					av_fifo_generic_write(m_pVideoAFifo, pFrame->data[2], y_size / 4, NULL);
					LeaveCriticalSection(&m_csVideoASection);

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

		}


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

	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;

	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)
				{
					EnterCriticalSection(&m_csVideoBSection);
					av_fifo_generic_write(m_pVideoBFifo, pFrame->data[0], y_size, NULL);
					av_fifo_generic_write(m_pVideoBFifo, pFrame->data[1], y_size / 4, NULL);
					av_fifo_generic_write(m_pVideoBFifo, pFrame->data[2], y_size / 4, NULL);
					LeaveCriticalSection(&m_csVideoBSection);

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


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

	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 *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);


	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;
		}

		int iVideoASize = av_fifo_size(m_pVideoAFifo);
		int iVideoBSize = av_fifo_size(m_pVideoBFifo);

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


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


			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;

			//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_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;
				}
			}

			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 = iOutVideoWidth;
					pFrame_out->height = iOutVideoHeight;
					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);
}
tusong86
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
ffmpeg综合应用示例（五）——多路视频合并（Linux版本）
deroy
08-02 1738
本文的目的为方便Linux下编译运行多路视频合成Demo
两个视频左右拼接成一个视频，且两个视频音频都保留
2401_84009300的博客
03-31 340
既已说到spring cloud alibaba，那对于整个微服务架构，如果想要进一步地向上提升自己，到底应该掌握哪些核心技能呢？就个人而言，对于整个微服务架构，像RPC、Dubbo、Spring Boot、Spring Cloud Alibaba、Docker、kubernetes、Spring Cloud Netflix、Service Mesh等这些都是最最核心的知识，架构师必经之路！下图，是自绘的微服务架构路线体系大纲，如果有还不知道自己该掌握些啥技术的朋友，可根据小编手绘的大纲进行一个参考。
AVFilterLink的channels设置
最新发布
qq_15255121的专栏
05-09 422
我们通过上面代码可以知道link的channel来自于link->incfg.channel_layouts->channel_layouts[0]的转化。我们知道link的输入是link->src对应filter，那么这个配置也应该是src对应的filter进行配置。将相应的占位符进行替换后会发现channel_layouts取的是OutputFilter的是channel_layout字段。现在的问题就成了ost->enc_ctx->channels怎么来的？我们将相应占位符带入后发现其实找的是。
使用ffmpeg合并视频文件的三种方法
热门推荐
爱自在的专栏
06-14 5万+
原文  http://itindex.net/detail/52379-ffmpeg-合并-视频 主题 FFmpeg ffmpeg合并视频的方法有三种。国内大多数仅介绍了其中之一。于是觉得有必要翻译一下。其实在ffmpeg的 FAQ文档中有比较详细的说明。 使用concat协议进行视频文件的合并 这种方式的适用场景是：视频容器是MPEG-1, MPEG-2
ffmpeg api实现将音视频混合
paokuflying的博客
05-09 2077
将AVPacket写入输出环境时，音频和视频的stream_index不能相等，如果音频的stream_index等于0，那么视频的stream_index需要等于1，可以手动改。出现这种情况的原因是输入的xxx1.mp3可能包含2个流，一个是音频，另一个是视频，音频流索引是0，视频流索引是1。输入的xxx2.mp4至少包含2个流，一个是音频，另一个是视频，而这里视频流索引是0，音频流索引是1。将从输入流解析出的AVPacket的跟时间相关字段，从当前的输入流时基对应的值转为输出流时基对应的值。
FFMpeg-10、完成两个mp4文件的视频拼接输出yuv及mp4
zw1996的博客
08-05 1209
主要是完成解码两个mp4文件将其视频帧进行尺寸转换后进行拼接输出到YUV文件中，其实后续还可以完成将拼接后的视频帧进行编码输出mp4文件的形式。并且代码进行封装将解码步骤封装成一个类。 完成输出mp4文件，存在诸多问题 1、视频播放很卡顿，不确定是帧匹配的时候锁加多了导致编码的时候太慢了，还是解码原视频帧的时候拼接存在一个等待时间导致的 2、优化声音部分未加入可以进一步优化， 代码实践； 解码一个类EncodeVideoFrame、创建两个对象就可以解码两个文件了 编码一个类DecodeVideoFrame
ffmpeg如何批量拼接视频（简单便捷）
javemalloc的博客
01-07 2102
将多个音视频拼接
通过 ffmpeg 无损剪切/拼接视频
kailon0103的专栏
05-06 1092
剪切/拼接视频文件是一种常见需求。在线视频网站现在往往将一个视频文件分割成 n 段，以减少流量消耗。使用 DownloadHelper/DownThemAll 这类工具下载下来的往往就是分割后的文件。能实现剪切/拼接视频文件的工具多种多样，但往往都需要进行视频重编码（transcoding），这就不可避免的带来了视频质量上的损耗，更不用提那长的令人发指的转换时间了… 其实借助 ffmpeg
FFmpeg实现多段小视频合成
欢迎关注公众号：【码农突围】，回复9999，可以获取一份LeetCode刷题笔记
05-17 1708
这里主要实现一下多视频合成，主要困难是手机前置摄像头和后置摄像头录制的视频合成问题，我这里主要实现了功能，但是效率不优，暂时记录一下，如果有更好的方式再更新。1.新建Se...
FFmpeg-master.zip_FFmpeg-master_ffmpeg_ffmpeg 播放
09-14
FFmpeg 是一个开源的多媒体处理框架，用于处理音频和视频数据。它包含了多个库，如 libavcodec（编码器库）、libavformat（容器格式库）、libavfilter（过滤器库）和 libavutil（通用工具库）等，提供了解码、编码、...
ffmpeg-0.5.rar_264_dvd_ffmpeg 264_ffmpeg-full-sdk-3.2_ffmpeg压缩视频
09-19
一套新的视频压缩代码，支持263，264，dvd等等，c语言写的大作
ffmpeg-0.6.3.zip_ffmpeg 0.6_ffmpeg 0.6.3_ffmpeg-0.6.3
09-14
这个压缩包"ffmpeg-0.6.3.zip"包含的是FFmpeg的0.6.3版本源代码，是该软件的一个特定历史版本，主要面向开发者和研究者，便于学习、研究和定制。 FFmpeg 的核心功能包括： 1. 视频编码与解码：FFmpeg 支持多种视频...
ffmpeg-0.4.8_src_20070726.rar_GM8180_ffmpeg_ffmpeg-0.11_ffmpeg-4
09-21
这个压缩包"ffmpeg-0.4.8_src_20070726.rar_GM8180_ffmpeg_ffmpeg-0.11_ffmpeg-4"包含了FFmpeg的一个早期版本——0.4.8的源代码，特别针对GM8120和GM8180设备进行了优化。这些设备可能是指某些特定的嵌入式硬件或...
ffmpeg-0.6.1.rar_ffmpeg 0.6.1下载_ffmpeg-0.6.1_ffmpeg0.6.1
09-24
这个压缩包"ffmpeg-0.6.1.rar"包含的是FFmpeg的0.6.1版本，它是一个历史版本，但对开发者和研究者来说仍然具有价值，因为它们可以深入理解FFmpeg的早期功能和架构。 FFmpeg的核心功能包括： 1. 视频和音频编码：...
使用ffmepg实现多路视频流合并
m0_60259116的博客
06-28 2684
使用ffmepg实现多路视频流合并
FFmpeg进阶:视频滤镜大全
yang1fei2的博客
11-19 4073
在做视频特效的时候，很多特效其实不用自己写，FFmpeg的视频滤镜里面提供了很丰富的滤镜特效。这里翻译了一下FFmpeg官方文档的所有视频滤镜的介绍，供大家参考。由于很多地方概念比较生疏，翻译的可能不恰当，欢迎反馈修改意见。
FFMPEG学习【libavfilter】（一）
一世豁然的专栏
06-10 5025
此模块用于获取流的属性。 一、Buffer sink accessors模块 一）、函数 enum AVMediaType  av_buffersink_get_type (const AVFilterContext *ctx) AVRational  av_buffersink_get_time_base
FFMPEG学习【libavfilter】（二）
一世豁然的专栏
06-13 2765
一、函数 unsigned  avfilter_version (void) 返回LIBAVFILTER_VERSION_INT常量。 const char *  avfilter_configuration (void) 返回libavfilter构建时配置。 con
ffmpeg的新东东:AVFilter
yhm45的博客
07-13 592
利用ffmpeg做图像的pixel format转换你还在用libswscale吗?嘿嘿,过时啦! ffmpeg中有了新东西:libavfilter.使用它,可以完全代替libswscale,并且可以自动完成一些复杂的转换操作呢.libavfilter啊,用了都说好!但就是太复杂... 如果你仅仅是做图像的pixel format处理,用libswscale是相当简单,可以看看最新的ffpla
ffmpeg多个视频流同时推向一个地址参数-i如何设置
03-01
如果您要将多个视频流同时推送到一个地址，您可以在FFmpeg的-i参数中使用多个输入源，并使用"-map"选项将每个输入流映射到输出流中。 下面是一个使用FFmpeg将两个视频流推送到同一个地址的示例命令： ``` ffmpeg -i input1.mp4 -i input2.mp4 -filter_complex "[0:v][0:a][1:v][1:a]concat=n=2:v=1:a=1[v][a]" -map "[v]" -map "[a]" -f rtp rtp://destination_address:port ``` 在这个命令中，"-i"参数用于指定两个输入文件，即"input1.mp4"和"input2.mp4"。接下来，我们使用"filter_complex"选项将这两个输入流合并成一个输出流。在本例中，我们使用concat滤镜将两个视频流合并，并将输出视频流的数量设置为1。我们还将输出音频流的数量设置为1。 最后，我们使用"-map"选项将合并的视频流和音频流映射到输出流中，并使用"-f"选项指定输出流的格式为RTP。请将"destination_address"替换为目标地址，将"port"替换为目标端口。 请注意，合并多个视频流需要考虑多个因素，例如视频流的分辨率、帧率和编码格式等。确保所有输入流具有相同的属性，以获得最佳结果。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值