FFMpeg-10、完成两个mp4文件的视频拼接输出yuv及mp4

最新推荐文章于 2024-05-24 10:43:23 发布
最新推荐文章于 2024-05-24 10:43:23 发布
阅读量1.2k 收藏 2
点赞数
分类专栏： 音视频 文章标签： 视频拼接 合成两个mp4文件视频部分 ffmpeg编解码及视频拼接
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zw1996/article/details/119427678
版权

效果图
在这里插入图片描述

主要是完成解码两个mp4文件将其视频帧进行尺寸转换后进行拼接输出到YUV文件中，
其实后续还可以完成将拼接后的视频帧进行编码输出mp4文件的形式。并且代码进行封装将解码步骤封装成一个类。

完成输出mp4文件，存在诸多问题
1、视频播放很卡顿，不确定是帧匹配的时候锁加多了导致编码的时候太慢了，还是解码原视频帧的时候拼接存在一个等待时间导致的
2、优化声音部分未加入可以进一步优化，
在这里插入图片描述

代码实践；
解码一个类EncodeVideoFrame、创建两个对象就可以解码两个文件了
编码一个类DecodeVideoFrame，就是将拼接好的帧放入队列中，从里面去取然后编码
mian函数中进行视频帧拼接以及开启解码和编码以及帧的存储

EncodeVideoFrame

头文件
#pragma once
#include <iostream>
#include <queue>
#include <mutex>
#include <thread>
using namespace std;
class AVFrame;
class AVFormatContext;
class AVCodecContext;
class AVCodec;
class AVCodecContext;
class EncodeVideoFrame
{
public:
	EncodeVideoFrame();
	~EncodeVideoFrame();
	void startEncode();
	void doEncode();

	string path;
	bool m_bFlagStart = false;
	mutex m_muxVideo1;
	std::thread	 *m_pVideoThread = NULL;
	queue<AVFrame *> m_qAVFrameVideo1;
	queue<uint8_t *> m_qAVFrameBuffer1;
private:
	AVFormatContext *ic = NULL;
	AVCodecContext *vc = NULL;
	AVCodec *acodec = NULL;
	AVCodecContext *ac = NULL;
	int videoStream;
	int audioStream;
};

cpp文件
#include "EncodeVideoFrame.h"
#include<windows.h>
#ifdef __cplusplus
extern "C"
{
#endif // !__cplusplus
#include "libavutil/opt.h"
#include <libavutil/imgutils.h>
#include <libavformat/avformat.h>
#include <libavformat/avio.h>
#include "libavutil/time.h"
#include <libavcodec/avcodec.h>
#include <libswscale/swscale.h>
#include "libswresample/swresample.h"//包含头文件
#include <libavutil/imgutils.h>
#ifdef __cplusplus
}
#endif // !__cplusplus

static int XError(int errNum)
{
	char buf[1024] = { 0 };
	av_strerror(errNum, buf, sizeof(buf));//ffmpeg中打印错误信息
	cout << buf << endl;
	getchar();
	return -1;
}

EncodeVideoFrame::EncodeVideoFrame()
{
}


EncodeVideoFrame::~EncodeVideoFrame()
{
}
void LocalVideoThread(void *param)
{
	EncodeVideoFrame *pMan = (EncodeVideoFrame *)param;
	if (pMan)
		pMan->doEncode();
}
void EncodeVideoFrame::doEncode()
{
	AVPacket *pkt = av_packet_alloc();
	AVFrame *frame2 = av_frame_alloc();
	AVFrame *m_pFrameEncodeYUV1 = NULL;
	uint8_t *m_VideoEncodebuffer1 = NULL;
	struct SwsContext *m_pAddVideoConvert_ctx1 = NULL;
	int m_iOutWidth = 1280;
	int m_iOutHeight = 720;
	for (;;)
	{
		int re = av_read_frame(ic, pkt);
		if (re != 0)
		{
			break;
		}
		AVCodecContext *cc = 0;
		if (pkt->stream_index == videoStream)
		{
			cc = vc;
		}
		if (pkt->stream_index == audioStream)
		{
			cc = ac;
		}

		///解码视频
		//发送packet到解码线程  send传NULL后调用多次receive取出所有缓冲帧
		re = avcodec_send_packet(cc, pkt);
		if (re != 0)
		{
			XError(re);
			continue;
		}
		av_packet_unref(pkt);
		long long startTime = av_gettime();
		for (;;)
		{
			//从线程中获取解码接口,一次send可能对应多次receive
			re = avcodec_receive_frame(cc, frame2);
			if (re != 0) {
				break;
			}
			//视频
			if (cc == vc)
			{

				m_pFrameEncodeYUV1 = av_frame_alloc();
				m_VideoEncodebuffer1 = (uint8_t *)av_malloc(avpicture_get_size(AV_PIX_FMT_YUV420P, m_iOutWidth, m_iOutHeight));
				avpicture_fill((AVPicture *)m_pFrameEncodeYUV1, m_VideoEncodebuffer1, AV_PIX_FMT_YUV420P, m_iOutWidth, m_iOutHeight);
				m_pFrameEncodeYUV1->width = m_iOutWidth;
				m_pFrameEncodeYUV1->height = m_iOutHeight;
				m_pFrameEncodeYUV1->format = AV_PIX_FMT_YUV420P;

				if (!m_pAddVideoConvert_ctx1)
				{
					m_pAddVideoConvert_ctx1 = sws_getContext(frame2->width, frame2->height,
						AV_PIX_FMT_YUV420P, m_iOutWidth, m_iOutHeight, AV_PIX_FMT_YUV420P, SWS_BICUBIC, NULL, NULL, NULL);
				}
				sws_scale(m_pAddVideoConvert_ctx1, frame2->data, frame2->linesize, 0, frame2->height, m_pFrameEncodeYUV1->data, m_pFrameEncodeYUV1->linesize);

				//自测
				//int y_size = frame2->width*frame2->height;
				//fwrite(frame2->data[0], 1, y_size, yuv_file2);    //Y   
				//fwrite(frame2->data[1], 1, y_size / 4, yuv_file2);  //U  
				//fwrite(frame2->data[2], 1, y_size / 4, yuv_file2);  //V  
				//Sleep(20);

				m_muxVideo1.lock();
				m_qAVFrameVideo1.push(m_pFrameEncodeYUV1);
				m_qAVFrameBuffer1.push(m_VideoEncodebuffer1);
				m_bFlagStart = true;
				m_muxVideo1.unlock();
				Sleep(200);
			}
			else if (cc == ac)//音频
			{
				//cout << "Audio" << endl;
			}
		}
	}
	cout << "m_qAVFrameVideo end" << endl;
}
void EncodeVideoFrame::startEncode()
{
	AVDictionary *opts = NULL;
	int re = avformat_open_input(&ic, path.c_str(), 0, &opts);
	if (re != 0)
	{
		XError(re);
		return;
	}
	re = avformat_find_stream_info(ic, 0);
	int totalMs = ic->duration / (AV_TIME_BASE / 1000);
	videoStream = av_find_best_stream(ic, AVMEDIA_TYPE_VIDEO, -1, -1, NULL, 0);;
	 audioStream = av_find_best_stream(ic, AVMEDIA_TYPE_AUDIO, -1, -1, NULL, 0);;

	AVCodec *vcodec = avcodec_find_decoder(ic->streams[videoStream]->codecpar->codec_id);
	if (!vcodec)
	{
		cout << "can't find the codec id " << ic->streams[videoStream]->codecpar->codec_id;
		getchar();
		return;
	}
	cout << "find the AVCodec " << ic->streams[videoStream]->codecpar->codec_id << endl;
	vc = avcodec_alloc_context3(vcodec);
	///配置解码器上下文参数
	avcodec_parameters_to_context(vc, ic->streams[videoStream]->codecpar);
	//八线程解码
	vc->thread_count = 8;
	///打开解码器上下文
	re = avcodec_open2(vc, 0, 0);
	if (re != 0)
	{
		XError(re);
		getchar();
		return;
	}
	///音频解码器打开
	acodec = avcodec_find_decoder(ic->streams[audioStream]->codecpar->codec_id);
	if (!acodec)
	{
		cout << "can't find the codec id " << ic->streams[audioStream]->codecpar->codec_id;
		getchar();
		return;
	}
	cout << "find the AVCodec " << ic->streams[audioStream]->codecpar->codec_id << endl;
	///创建解码器上下文呢
	ac = avcodec_alloc_context3(acodec);

	///配置解码器上下文参数
	avcodec_parameters_to_context(ac, ic->streams[audioStream]->codecpar);
	//八线程解码
	ac->thread_count = 8;

	///打开解码器上下文
	re = avcodec_open2(ac, 0, 0);
	if (re != 0)
	{
		XError(re);
		return;
	}
	cout << "audio avcodec_open2 success!" << endl;

	m_pVideoThread = new std::thread(LocalVideoThread, this);
	
	return;
}

DecodeVideoFrame编码类

头文件
#pragma once
#include <iostream>
#include <queue>
#include <mutex>
#include <thread>
using namespace std;
class AVFrame;
class AVFormatContext;
class AVCodecContext;
class AVCodec;
class AVCodecContext;
class AVStream;
/*
完成视频帧的编码
*/
class DecodeVideoFrame
{
public:
	DecodeVideoFrame();
	~DecodeVideoFrame();
	bool m_bencode_video = false;
	bool m_bencodeEnd_video = false;
	int initVideo();
	void DoDecodeVideo();
	std::thread	 *m_pVideoDecodeThread = NULL;
	mutex m_muxDecodeVideo;
	queue<AVFrame *> m_qAVFrameDecodeVideo;
	queue<uint8_t *> m_qAVFrameDecodeBuffer;
private:
	AVFormatContext	*m_pFormatCtx = NULL;
	AVCodecContext	*m_pVideoCodecCtx = NULL;
	AVCodec			*m_pVideoCodec = NULL;
	
	AVStream		*m_pVideo_st = NULL;
	int64_t			m_first_vid_time1 = -1;
	int64_t			m_first_vid_time2 = -1;
	AVFrame *m_pFrameDecodeYUV2 = NULL;
	uint8_t * m_VideoDecodebuffer = NULL;
	struct SwsContext *m_pAddVideoConvert_ctx1 = NULL;
	int m_iOutWidth = 1280;
	int m_iOutHeight = 720;
	std::string		m_strRecordPath = "111.mp4";
};

cpp文件
#include "DecodeVideoFrame.h"
#include<windows.h>
#ifdef __cplusplus
extern "C"
{
#endif // !__cplusplus
#include "libavutil/opt.h"
#include <libavutil/imgutils.h>
#include <libavformat/avformat.h>
#include <libavformat/avio.h>
#include "libavutil/time.h"
#include <libavcodec/avcodec.h>
#include <libswscale/swscale.h>
#include "libswresample/swresample.h"//包含头文件
#include <libavutil/imgutils.h>
#ifdef __cplusplus
}
#endif // !__cplusplus

DecodeVideoFrame::DecodeVideoFrame()
{
}


DecodeVideoFrame::~DecodeVideoFrame()
{
}
void VideoEncodeThread(void *param)
{
	DecodeVideoFrame *pMan = (DecodeVideoFrame *)param;
	if (pMan)
		pMan->DoDecodeVideo();
}
int DecodeVideoFrame::initVideo()
{
	av_register_all();
	avcodec_register_all();
	AVCodecID		m_video_codec_id = AV_CODEC_ID_H264;
	avformat_alloc_output_context2(&m_pFormatCtx, NULL, NULL, m_strRecordPath.c_str());
	m_pVideoCodec = avcodec_find_encoder(m_video_codec_id);
	if (!m_pVideoCodec)
	{
		return false;
	}

	m_pVideoCodecCtx = avcodec_alloc_context3(m_pVideoCodec);
	m_pVideoCodecCtx->pix_fmt = AV_PIX_FMT_YUV420P;
	m_pVideoCodecCtx->codec_id = m_pVideoCodec->id;
	m_pVideoCodecCtx->width = m_iOutWidth;// 1280;
	m_pVideoCodecCtx->height = m_iOutHeight;// 720;
	m_pVideoCodecCtx->time_base.num = 1;
	m_pVideoCodecCtx->time_base.den = 25;
	m_pVideoCodecCtx->bit_rate = 2000000;
	m_pVideoCodecCtx->gop_size = 60;
	m_pVideoCodecCtx->max_b_frames = 0;
	m_pVideoCodecCtx->b_frame_strategy = 0;

	AVDictionary *param = NULL;
	if (m_video_codec_id == AV_CODEC_ID_H264)
	{
		m_pVideoCodecCtx->qmin = 10;
		m_pVideoCodecCtx->qmax = 51;

		av_dict_set(&param, "preset", "ultrafast", 0);
		av_dict_set(&param, "tune", "zerolatency", 0);
	}

	if (avcodec_open2(m_pVideoCodecCtx, m_pVideoCodec, &param) < 0)
	{
		return false;
	}

	m_pVideo_st = avformat_new_stream(m_pFormatCtx, m_pVideoCodec);
	if (m_pVideo_st == NULL)
	{
		return false;
	}

	avcodec_parameters_from_context(m_pVideo_st->codecpar, m_pVideoCodecCtx);

	m_pVideo_st->time_base.num = 1;
	m_pVideo_st->time_base.den = 25;
	m_pVideo_st->codec = m_pVideoCodecCtx;

	if (avio_open(&m_pFormatCtx->pb, m_strRecordPath.c_str(), AVIO_FLAG_READ_WRITE) < 0)
	{
		return false;
	}
	m_first_vid_time1 = -1;//要进行初始化 否则第二次时间戳会有问题
	m_first_vid_time2 = -1;


	m_pFrameDecodeYUV2 = av_frame_alloc();
	m_VideoDecodebuffer = (uint8_t *)av_malloc(avpicture_get_size(AV_PIX_FMT_YUV420P, m_iOutWidth, m_iOutHeight));
	avpicture_fill((AVPicture *)m_pFrameDecodeYUV2, m_VideoDecodebuffer, AV_PIX_FMT_YUV420P, m_iOutWidth, m_iOutHeight);
	m_pFrameDecodeYUV2->width = m_iOutWidth;
	m_pFrameDecodeYUV2->height = m_iOutHeight;
	m_pFrameDecodeYUV2->format = AV_PIX_FMT_YUV420P;

	AVDictionary* opt = NULL;
	if (avformat_write_header(m_pFormatCtx, &opt) < 0)
	{
		return false;
	}

	m_pVideoDecodeThread = new std::thread(VideoEncodeThread, this);
}

void DecodeVideoFrame::DoDecodeVideo()
{
	int ret;
	AVFrame *frameTemp = NULL;
	uint8_t	*Video1bufferTemp = NULL;
	int nCount = 0;
	AVRational time_base_q = { 1, AV_TIME_BASE };
	AVPacket enc_pkt;
	while (1)
	{
		//编码
		m_first_vid_time1 = av_gettime();
		m_muxDecodeVideo.lock();
		if (m_bencodeEnd_video)
		{
			break;
		}
		if (m_bencode_video == false || m_qAVFrameDecodeVideo.size() == 0)
		{
			m_muxDecodeVideo.unlock();
			Sleep(1000);
			continue;
		}
		
		frameTemp = m_qAVFrameDecodeVideo.front();
		Video1bufferTemp = m_qAVFrameDecodeBuffer.front();
		m_qAVFrameDecodeVideo.pop();
		m_qAVFrameDecodeBuffer.pop();
		m_muxDecodeVideo.unlock();

		

		

		if (!m_pAddVideoConvert_ctx1)
		{
			m_pAddVideoConvert_ctx1 = sws_getContext(frameTemp->width, frameTemp->height,
				AV_PIX_FMT_YUV420P, m_iOutWidth, m_iOutHeight, AV_PIX_FMT_YUV420P, SWS_BICUBIC, NULL, NULL, NULL);
		}
		sws_scale(m_pAddVideoConvert_ctx1, frameTemp->data, frameTemp->linesize, 0, frameTemp->height, m_pFrameDecodeYUV2->data, m_pFrameDecodeYUV2->linesize);
		av_frame_free(&frameTemp);
		av_free(Video1bufferTemp);

		enc_pkt.data = NULL;
		enc_pkt.size = 0;
		av_init_packet(&enc_pkt);
		int enc_got_frame = 0;
		ret = avcodec_encode_video2(m_pVideoCodecCtx, &enc_pkt, m_pFrameDecodeYUV2, &enc_got_frame);

		if (enc_got_frame == 1)
		{
			if (m_first_vid_time2 == -1)
				m_first_vid_time2 = m_first_vid_time1;

			enc_pkt.stream_index = m_pVideo_st->index;
			enc_pkt.dts = enc_pkt.pts = (int64_t)(m_pVideo_st->time_base.den * (m_first_vid_time1 - m_first_vid_time2) / AV_TIME_BASE);
			
			//m_muxFormat.lock(); 有音频有视频的时候裸流时需要
			ret = av_interleaved_write_frame(m_pFormatCtx, &enc_pkt);
			//m_muxFormat.unlock();
			if (ret < 0)
			{
				av_packet_unref(&enc_pkt);
			}

			av_free_packet(&enc_pkt);
		}
		else
		{
			av_free_packet(&enc_pkt);
		}
		//av_frame_unref(m_pFrameFilterYUV);
		//std::cout << "视频拼接视频" << enc_pkt.pts << endl;
	}
	if (m_pFormatCtx != NULL)
	{
		av_write_trailer(m_pFormatCtx);
	}
	Sleep(200);
	return;
}

main函数

#include <iostream>
#include <mutex>
#include<windows.h>
#ifdef __cplusplus
extern "C"
{
#endif // !__cplusplus
#include "libavutil/opt.h"
#include <libavutil/imgutils.h>
#include <libavformat/avformat.h>
#include <libavformat/avio.h>
#include "libavutil/time.h"
#include <libavcodec/avcodec.h>
#include <libswscale/swscale.h>
#include "libswresample/swresample.h"//包含头文件
#include <libavutil/imgutils.h>
#ifdef __cplusplus
}
#endif // !__cplusplus
#pragma comment(lib,"avformat.lib")//添加库文件，也可以在属性处添加
#pragma comment(lib,"avutil.lib")
#pragma comment(lib,"avcodec.lib")
#pragma comment(lib,"swresample.lib")
#pragma comment(lib,"swscale.lib")
#include <thread>
#include <queue>
#include "EncodeVideoFrame.h"
#include "DecodeVideoFrame.h"
using namespace std;
#define _CRT_SECURE_NO_WARNINGS；
int XError(int errNum)
{
	char buf[1024] = { 0 };
	av_strerror(errNum, buf, sizeof(buf));//ffmpeg中打印错误信息
	cout << buf << endl;
	getchar();
	return -1;
}
static double r2d(AVRational r)
{
	return r.num == 0 || r.den == 0 ? 0. : (double)r.num / (double)r.den;
}
FILE *yuv_file3 = fopen("D:\\yuv_file13.yuv", "wb");

int main(int argc, char *argv[])
{
	av_register_all();
	avformat_network_init();
	avcodec_register_all();
	DecodeVideoFrame decodeVideo;
	decodeVideo.initVideo();
	//m_pVideo1Thread = new std::thread(LocalVideoThread);
	//m_pVideo2Thread = new std::thread(LocalVideo2Thread);
	EncodeVideoFrame encodeVideo1;
	encodeVideo1.path = "01.mp4";
	encodeVideo1.startEncode();
	Sleep(200);
	EncodeVideoFrame encodeVideo2;
	encodeVideo2.path = "lane.avi";
	encodeVideo2.startEncode();
	//Sleep(200);
	
	int m_iOutWidth = 2560;
	int m_iOutHeight = 720;
	
	uint8_t *tempBuff1 = NULL;
	uint8_t *tempBuff2 = NULL;
	//用这种方法保证队列中都有解码好的视频帧
	cout << "Audio0" << endl;
	for (; ; )
	{
		encodeVideo1.m_muxVideo1.lock();
		if (encodeVideo1.m_bFlagStart == false)
		{
			encodeVideo1.m_muxVideo1.unlock();
			Sleep(200);
			continue;
		}
		encodeVideo1.m_muxVideo1.unlock();
		break;
	}
	cout << "Audio1" << endl;
	for (; ; )
	{
		encodeVideo2.m_muxVideo1.lock();
		if (encodeVideo2.m_bFlagStart == false)
		{
			encodeVideo2.m_muxVideo1.unlock();
			Sleep(200);
			
			continue;
		}
		encodeVideo2.m_muxVideo1.unlock();
		break;
	}
	cout << "Audio2" << endl;
	for (;;)
	{
		cout << "Audio3" << endl;

		Sleep(200);
		encodeVideo1.m_muxVideo1.lock();
		encodeVideo2.m_muxVideo1.lock();
		if (encodeVideo1.m_qAVFrameVideo1.size() == 0 || encodeVideo2.m_qAVFrameVideo1.size() == 0)//视频帧都没了则表示有文件拼接结束了
		{
			encodeVideo2.m_muxVideo1.unlock();
			encodeVideo1.m_muxVideo1.unlock();
			decodeVideo.m_muxDecodeVideo.lock();
			decodeVideo.m_bencodeEnd_video = true;
			decodeVideo.m_muxDecodeVideo.unlock();
			break;
		}

		tempBuff2 = encodeVideo2.m_qAVFrameBuffer1.front();
		AVFrame * frame2 = encodeVideo2.m_qAVFrameVideo1.front();
		encodeVideo2.m_qAVFrameBuffer1.pop();
		encodeVideo2.m_qAVFrameVideo1.pop();
		encodeVideo2.m_muxVideo1.unlock();

		tempBuff1 = encodeVideo1.m_qAVFrameBuffer1.front();
		AVFrame * frame = encodeVideo1.m_qAVFrameVideo1.front();
		encodeVideo1.m_qAVFrameBuffer1.pop();
		encodeVideo1.m_qAVFrameVideo1.pop();
		encodeVideo1.m_muxVideo1.unlock();

		AVFrame *m_pFrameEncodeYUV2 = av_frame_alloc();
		uint8_t * m_VideoEncodebuffer = (uint8_t *)av_malloc(avpicture_get_size(AV_PIX_FMT_YUV420P, m_iOutWidth, m_iOutHeight));
		avpicture_fill((AVPicture *)m_pFrameEncodeYUV2, m_VideoEncodebuffer, AV_PIX_FMT_YUV420P, m_iOutWidth, m_iOutHeight);
		m_pFrameEncodeYUV2->width = m_iOutWidth;
		m_pFrameEncodeYUV2->height = m_iOutHeight;
		m_pFrameEncodeYUV2->format = AV_PIX_FMT_YUV420P;

		cout << "Audio4" << endl;
		for (int i = 0; i < m_iOutHeight; i++)
		{
			memcpy(m_pFrameEncodeYUV2->data[0] + (i)*m_iOutWidth, frame->data[0] + i*frame->width, frame->width);
			memcpy(m_pFrameEncodeYUV2->data[0] + (i)*m_iOutWidth + frame->width, frame2->data[0] + i*frame2->width, frame2->width);
			
		}
		int iHeightHlaf = m_iOutHeight / 2;
		int iWidthHlaf = m_iOutWidth / 2;
		int iWidth1Hlaf = frame->width / 2;
		int iWidth2Hlaf = frame2->width / 2;
		for (int i = 0; i < iHeightHlaf; i++)
		{
			memcpy(m_pFrameEncodeYUV2->data[1] + (i)*(iWidthHlaf), frame->data[1] + i*(iWidth1Hlaf), (iWidth1Hlaf));
			memcpy(m_pFrameEncodeYUV2->data[1] + (i)*(iWidthHlaf)+(iWidth1Hlaf), frame2->data[1] + i*(iWidth2Hlaf), (iWidth2Hlaf));

			memcpy(m_pFrameEncodeYUV2->data[2] + (i)*(iWidthHlaf), frame->data[2] + i*(iWidth1Hlaf), (iWidth1Hlaf));
			memcpy(m_pFrameEncodeYUV2->data[2] + (i)*(iWidthHlaf)+(iWidth1Hlaf), frame2->data[2] + i*(iWidth2Hlaf), (iWidth2Hlaf));
		}
		av_frame_free(&frame);
		av_frame_free(&frame2);
		av_free(tempBuff1);
		av_free(tempBuff2);
		cout << "Audio6" << endl;

		decodeVideo.m_muxDecodeVideo.lock();
		decodeVideo.m_qAVFrameDecodeVideo.push(m_pFrameEncodeYUV2);
		decodeVideo.m_qAVFrameDecodeBuffer.push(m_VideoEncodebuffer);
		decodeVideo.m_bencode_video = true;
		decodeVideo.m_muxDecodeVideo.unlock();
		//int y_size = m_pFrameEncodeYUV2->width*m_pFrameEncodeYUV2->height;
		//fwrite(m_pFrameEncodeYUV2->data[0], 1, y_size, yuv_file3);    //Y   
		//fwrite(m_pFrameEncodeYUV2->data[1], 1, y_size / 4, yuv_file3);  //U  
		//fwrite(m_pFrameEncodeYUV2->data[2], 1, y_size / 4, yuv_file3);  //V 	
	}
	//fclose(yuv_file3);
	//m_pVideoThread = new std::thread(VideoReadThread);

	system("pause");
	return 0;
}
卖酒的小码农
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
ffmpeg转码多路输出(二)
朱韦刚(zhuweigangzwg)的技术博客
05-18 1万+
ffmpeg转码多路输出(二) 本程序支持一路输入多路输出，可根据map配置自行添加，第1路为纯拷贝，其他2路经过编解码，格式转换缩放和重采样，纯拷贝方面不同格式适应方面还没做全，以后补充。本程序适合多分辨率切换等方面内容。注意重采样等方面的注释内容。 具体看代码： //main.cpp #include "ffmpeg_transcode.h" /* int main() { AV
FFmpeg工具进行快速的视频拼接
weixin_46085748的博客
04-10 1万+
文章目录拼接mp4格式的视频准备复杂的设置（使用挺方便）这种先要设置环境变量使用简单的设置直接使用ffmpeg工具 拼接mp4格式的视频 用FFmpeg工具对视频进行处理，FFmpeg有非常强大的功能包括视频采集功能、视频格式转换、视频抓图、给视频加水印等。 准备 下载FFmpeg视频工具。 直接搜索下载，根据电脑选择不同的资源。 下载完解压，可以解压到任何盘，可以改一下文件夹名称。 复杂的设置（使用挺方便） 这种先要设置环境变量 先找到解压后的bin路径 然后进行设置环境变量 将解压后的bin路径填
使用ffmpeg 将多个mp4 文件拼接
Liberty1010的博客
08-19 1703
创建一个文本文件：在任意文本编辑器中创建一个文本文件（例如，命名为 “filelist.txt”），并将要拼接的视频文件列表按顺序写入该文件。每个文件名应位于单独的一行。确保提供正确的文件路径。
【FFMPEG应用篇】MP4转YUV存储
最新发布
用可见的方式来记录和分享每一次收获
05-24 440
【FFMPEG应用篇】MP4转YUV存储。
Android多媒体（二） 多段Mp4文件拼接 我用双手成就你的梦想
qq_18612815的博客
05-26 3016
上一篇中讲了音轨合成Android多媒体（一） 音轨合成 我用双手成就你的梦想 ，今天要实现的是将多个Mp4文件合并。 两者相同点在于都是将多个音频合并成一个，不同点在于前者是同时播放多个音频，后者是按合成的顺序播放。 这里使用的是mp4parser来实现的 官网地址：https://code.google.com/p/mp4parser/ GitHub: https://git
ffmpeg合并多个MP4视频
first_shun的博客
09-09 2万+
使用ffmpeg合并多个MP4视频的方式有多种，主要分为以下两类： 一、将MP4格式的视频转为其他格式，合并起来之后再转回MP4 1、将mp4转成mpeg（也是一种视频格式）文件，然后利用ffmpeg命令合并起来，然后再转为mp4格式 ffmpeg -i test.mp4 -qscale 4 1.mpg ffmpeg -i test2.mp4 -qscale 4 2.mpg ffmpeg -i "concat:1.mpg|2.mpg" -c copy output.mpg ffmpeg -i out
使用ffmpeg合并mp4文件
xdg15294969271的博客
06-07 3153
mp4文件合并
FFmpeg - 对mp4视频按时间剪切，生成新的mp4文件
04-16
■ 本源码运行环境为Vs+FFmpeg，主要功能对mp4视频按时间剪切，生成新的mp4文件 ■ 本源码对应的文章介绍：https://blog.csdn.net/automoblie0/article/details/126056455 ■ 本源码对应的运行效果介绍：...
FFmpeg - 代码方式将mp4文件转为avi无损文件（附源码）
04-16
■ 本源码运行环境为vs+ffmpeg，主要功能代码方式将mp4文件转为avi无损文件 ■ 本源码对应的文章介绍：https://blog.csdn.net/automoblie0/article/details/122819627 ■ 如需协助，csdn私信或添加wx沟通：...
Mp4Cat.rar_MP4cat_MP4拼接工具_ffmpeg 多文件_mp4拼接_文件拼接
07-15
只需将需要拼接的MP4文件拖入程序，设置好输出文件名，即可一键完成拼接。 尽管FFmpeg本身已经足够强大，但Mp4Cat这样的工具为非程序员用户提供了更便捷的途径。在实际应用中，根据个人需求和技能水平，选择合适的...
FFmpeg - 通过修改yuv，将视频转为黑白并输出
02-08
本资源包含完整的Vs+Qt+FFmpeg代码。 资源介绍：https://blog.csdn.net/automoblie0/article/details/126098571 资源视频介绍：https://www.bilibili.com/video/BV1nT41177NE/?spm_id_from=333.999.0.0 【视频中展示...
FFmpeg - 录制Windows屏幕与麦克风(音视频同步)，生成Mp4文件（附源码）
04-16
■ 本源码运行环境为Vs+FFmpeg，主要功能录制Windows屏幕与麦克风(音视频同步)，生成Mp4文件 ■ 本源码对应的文章介绍：https://blog.csdn.net/automoblie0/article/details/126056946 ■ 如需协助，csdn私信或...
ffmpeg拼接视频
yinshipin007的博客
07-14 2357
ffmpeg这单个指令功能看着挺简单，但是一组合就可以变化万千，实现各种各样的功能。假如我想让左右两个视频中间有个分界，留点空隙，就100个像素吧，颜色为绿色。有的小可爱要的可能不是时间线上的拼接，而是类似分屏显示的那种，安排。videolist.txt中写入待拼接的视频文件相对路径。想拼接视频的话，找两个视频文件，随便放在一个目录。当然，还有其他不少的拼接方法，这只是其中的一种。2、两段视频同时播放，左右或上下同时显示。假如想让两个视频上下显示，比如这样。，因为好多软件里都已经自带了。
如何使用 ffmpeg 对视频进行切分、合并
u014443884的专栏
05-11 2102
3. 去除水印（指定区域模糊化，以 (x,y) 为左上角，长宽为 w、h 的矩形区域）1. 按照视频时间点进行截取, 起止点：00:00:06 ~ 00:20:36。2. 分离视频和音频。
使用ffmpeg简单合并视频（2个以上）
weixin_44027937的博客
10-23 6518
简要步骤 1、下载ffmpeg，并解压 2、进入bin文件夹 3、在当前路径下创建file.txt,并输入以下内容 4、将要合并的视频也放在当前路径下，注意要用file.txt里定义的文件名 5、当前路径下打开cmd命令框 输入以下指令然后按回车键： ffmpeg -f concat -i filelist.txt -c copy output.mp4 6、完成 附 ffmpeg下载：去官网下载或者下载我打包好的：ffmpeg压缩包密码：2qr0 ...
ffmpeg 合并 拼接 mp4视频
abamon的专栏
03-04 2万+
今天同事做字幕识别测试，其中360p的视频是直接从CNTV网上下载的，一套好好接的节目被切成9段、10段，为测试带来了一点小的麻烦；   所以今天想着用ffmpeg拼接一下这些视频；   需求如下： 1.mp4 2.mp4 … 封装成 combine.mp4   我对各种封装格式还不是很了解，因为之前被坑过，大概知道mp4封装会在一个地方声明duration，因此，如果从数据层面直接
ffmpeg 视频拼接
矩阵实验室
11-14 1万+
1. 视频拼接ffmpeg视频拼接需要用concat参数。 此外ffmpeg拼接的视频和原视频的封装格式有关2. ffmpeg视频拼接的几种方法2.1 利用文件列表# this is a comment file '/path/to/file1' file '/path/to/file2' file '/path/to/file3'ffmpeg -f concat -i mylist.txt -c
FFmpeg实现音视频同步的精准片段拼接
Slash Youth - Jack Chai
05-07 4238
本文出处：http://blog.csdn.net/chaijunkun/article/details/116491526，转载请注明。由于本人不定期会整理相关博文，会对相应内容作出完善。因此强烈建议在原始出处查看此文。 片段拼接音视频同步 音视频开发过程中，经常会遇到多个片段（或者称之为“分镜头”）拼接的问题。下面将列举若干实例，来分别说明。 本文中列举的例子必须满足前提条件： 每个片段自身是音视频同步的，只是在拼接后产生了不同步的问题； 每个片段的视频流都具有相同的：画面宽度、画面高度、像素宽高比、
两个视频左右拼接成一个视频，且两个视频音频都保留
热门推荐
阿良的博客
09-25 4万+
背景 现在遇到了一个这样的问题，有两个视频，分辨率大小一致，需要将两个视频左右拼接在一起，类似直播平台打PK时的那种，左边是一个画面，右边是另一个画面的场景。面对这样的问题，我首先的做法是看一下ffmpeg是否有现成的命令，直接在一个画布上放置两个视频。但是搜索了很久没有找到满意的结果，加上给我的时间比较短，所以我采取了简单但是步骤比较多的方式解决了该问题。 技术 语言：python3.6 组件：opencv、ffmpeg 思路 1、首先使用opencv将两个视频全部图片帧提取出来。 2、按.
ffmpeg怎么输出yuv文件大小
03-14
在使用FFmpeg进行视频处理时，可以通过以下步骤来输出YUV文件的大小： 1. 首先，确保你已经安装了FFmpeg，并且可以在命令行中使用它。 2. 打开命令行终端，进入到包含视频文件的目录。 3. 使用以下命令来输出YUV文件的大小： ``` ffmpeg -i input.mp4 -c:v rawvideo -pix_fmt yuv420p output.yuv ``` 这个命令将会将输入的视频文件（input.mp4）转换为YUV格式，并输出为output.yuv文件。 4. 在命令行中执行上述命令后，FFmpeg会将视频文件转换为YUV格式，并在转换完成后显示输出信息，其中包括输出文件的大小。 请注意，输出的YUV文件大小取决于原始视频文件的分辨率、帧率以及编码参数等因素。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值