ffmpeg录制变帧率桌面视频

最新推荐文章于 2023-09-16 21:25:53 发布
最新推荐文章于 2023-09-16 21:25:53 发布
阅读量1k 收藏 3
点赞数 2
文章标签： 音视频
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tusong86/article/details/122658699
版权

之前写过ffmpeg录制桌面(自己用gdi抓图)

帧率是固定的。

现在决定写个变帧率的例子，第一分钟的帧率为10，第二分钟的帧率为5.
这个设置AVFrame的pts即可。
第一分钟，pts大致如下(以毫秒为单位)：
100,200，300，400，500，600，700，800，900，1000，…

第二分钟，pts大致如下(以毫秒为单位)：
60200,60400，60600，60800，61000

录制后，在播放时，会发现帧率为7，如下所示：
在这里插入图片描述

下面是代码结构
在这里插入图片描述
CaptureScreen.h内容如下：

#ifndef _CCAPTURE_SCREEN_HH
#define _CCAPTURE_SCREEN_HH

#include<time.h>
#include <d3d9.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <windows.h>

#include <tchar.h>
#include <winbase.h>
#include <winreg.h>
#include <Strsafe.h>


//
// ---抓屏类----
//
class CCaptureScreen
{
public:
	CCaptureScreen(void);
	~CCaptureScreen(void);

public:
	/*-----------定义外部调用函数-----------*/
	int Init(int&, int&);//初始化
	BYTE* CaptureImage(); //抓取屏幕

private:
	/*-----------定义内部调用函数-----------*/
	void* CaptureScreenFrame(int, int, int, int);//抓屏
	HCURSOR FetchCursorHandle(); //获取鼠标光标

private:
	/*-----------定义私有变量-----------*/
	int m_width;
	int m_height;
	UINT   wLineLen;
	DWORD  dwSize;
	DWORD  wColSize;

	//设备句柄
	HDC hScreenDC;
	HDC hMemDC;
	//图像RGB内存缓存
	PRGBTRIPLE m_hdib;
	//位图头信息结构体
	BITMAPINFO pbi;

	HBITMAP hbm;
	//鼠标光标
	HCURSOR m_hSavedCursor;


};

#endif //--_CCAPTURE_SCREEN_HH

CaptureScreen.cpp的内容如下：

//#include "stdafx.h"
#include "CaptureScreen.h"

CCaptureScreen::CCaptureScreen(void)
{
	m_hdib = NULL;
	m_hSavedCursor = NULL;
	hScreenDC = NULL;
	hMemDC = NULL;
	hbm = NULL;
	m_width = 1920;
	m_height = 1080;
	FetchCursorHandle();
}
//
// 释放资源
//
CCaptureScreen::~CCaptureScreen(void)
{
	DeleteObject(hbm);
	if (m_hdib){

		free(m_hdib);
		m_hdib = NULL;
	}
	if (hScreenDC){

		::ReleaseDC(NULL, hScreenDC);
	}
	if (hMemDC) {

		DeleteDC(hMemDC);
	}
	if (hbm)
	{
		DeleteObject(hbm);
	}
}

//
// 初始化
//
int CCaptureScreen::Init(int& src_VideoWidth, int& src_VideoHeight)
{
	hScreenDC = ::GetDC(GetDesktopWindow());
	if (hScreenDC == NULL) return 0;

	int m_nMaxxScreen = GetDeviceCaps(hScreenDC, HORZRES);
	int m_nMaxyScreen = GetDeviceCaps(hScreenDC, VERTRES);

	hMemDC = ::CreateCompatibleDC(hScreenDC);
	if (hMemDC == NULL) return 0;

	m_width = m_nMaxxScreen;
	m_height = m_nMaxyScreen;

	if (!m_hdib){
		m_hdib = (PRGBTRIPLE)malloc(m_width * m_height * 3);//24位图像大小
	}
	//位图头信息结构体
	pbi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
	pbi.bmiHeader.biWidth = m_width;
	pbi.bmiHeader.biHeight = m_height;
	pbi.bmiHeader.biPlanes = 1;
	pbi.bmiHeader.biBitCount = 24;
	pbi.bmiHeader.biCompression = BI_RGB;

	src_VideoWidth = m_width;
	src_VideoHeight = m_height;

	hbm = CreateCompatibleBitmap(hScreenDC, m_width, m_height);
	SelectObject(hMemDC, hbm);

	wLineLen = ((m_width * 24 + 31) & 0xffffffe0) / 8;
	wColSize = sizeof(RGBQUAD)* ((24 <= 8) ? 1 << 24 : 0);
	dwSize = (DWORD)(UINT)wLineLen * (DWORD)(UINT)m_height;

	return 1;
}

//抓取屏幕数据
BYTE* CCaptureScreen::CaptureImage()
{

	VOID*  alpbi = CaptureScreenFrame(0, 0, m_width, m_height);
	return (BYTE*)(alpbi);
}

void* CCaptureScreen::CaptureScreenFrame(int left, int top, int width, int height)
{

	if (hbm == NULL || hMemDC == NULL || hScreenDC == NULL) return NULL;

	BitBlt(hMemDC, 0, 0, width, height, hScreenDC, left, top, SRCCOPY);
	/*-------------------------捕获鼠标-------------------------------*/
	{
		POINT xPoint;
		GetCursorPos(&xPoint);
		HCURSOR hcur = FetchCursorHandle();
		xPoint.x -= left;
		xPoint.y -= top;

		ICONINFO iconinfo;
		BOOL ret;
		ret = GetIconInfo(hcur, &iconinfo);
		if (ret){
			xPoint.x -= iconinfo.xHotspot;
			xPoint.y -= iconinfo.yHotspot;

			if (iconinfo.hbmMask) DeleteObject(iconinfo.hbmMask);
			if (iconinfo.hbmColor) DeleteObject(iconinfo.hbmColor);
		}
		/*画鼠标*/
		::DrawIcon(hMemDC, xPoint.x, xPoint.y, hcur);
	}
	//动态分配的内存
	PRGBTRIPLE hdib = m_hdib;
	if (!hdib)
		return hdib;

	GetDIBits(hMemDC, hbm, 0, m_height, hdib, (LPBITMAPINFO)&pbi, DIB_RGB_COLORS);
	return hdib;
}

//
// 获取窗体鼠标光标
//
HCURSOR CCaptureScreen::FetchCursorHandle()
{
	if (m_hSavedCursor == NULL)
	{
		m_hSavedCursor = GetCursor();
	}
	return m_hSavedCursor;
}

VaryFrameTest.cpp的内容如下：

// RecordingScreen.cpp : 定义控制台应用程序的入口点。
//

//#include "stdafx.h"
#include "CaptureScreen.h"
extern "C"
{
#include <libavutil/opt.h>
#include <libavutil/mathematics.h>
#include <libavutil\time.h>
#include <libavformat/avformat.h>
#include <libswscale/swscale.h>
#include <libswresample/swresample.h>
#include <libavutil/imgutils.h>
#include <libavcodec/avcodec.h>
#include <libavdevice\avdevice.h>

#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")


}
//#include <ipp.h>
#include <chrono>

//signed int Bgr2YuvI420(const BYTE* srcBgr, int image_width, int image_height, BYTE* dstYuvI420)
//{
//	IppStatus ipp_status;
//
//	int srcStep = image_width * 3;
//	int dstYStep = image_width;
//	int dstCbCrStep = image_width;
//	IppiSize roiSize = { image_width, image_height };
//
//	const Ipp8u* pSrc = (Ipp8u*)srcBgr;
//
//	Ipp8u *pDstY = (Ipp8u*)dstYuvI420;
//	Ipp8u *pDstU = (Ipp8u*)&dstYuvI420[image_width * image_height];
//	Ipp8u *pDstV = (Ipp8u*)&dstYuvI420[image_width * image_height * 5 / 4];
//	Ipp8u *pDst[3];
//	pDst[0] = pDstY;
//	pDst[1] = pDstU;
//	pDst[2] = pDstV;
//	int dstStep[3] = { image_width, image_width / 2, image_width / 2 };
//
//	ipp_status = ippiBGRToYCbCr420_8u_C3P3R(pSrc, srcStep, pDst, dstStep, roiSize);
//
//	return ipp_status;
//}


unsigned char clip_value(unsigned char x, unsigned char min_val, unsigned char  max_val) {
	if (x > max_val) {
		return max_val;
	}
	else if (x < min_val) {
		return min_val;
	}
	else {
		return x;
	}
}

//RGB to YUV420
bool RGB24_TO_YUV420(unsigned char *RgbBuf, int w, int h, unsigned char *yuvBuf)
{
	unsigned char*ptrY, *ptrU, *ptrV, *ptrRGB;
	memset(yuvBuf, 0, w*h * 3 / 2);
	ptrY = yuvBuf;
	ptrU = yuvBuf + w * h;
	ptrV = ptrU + (w*h * 1 / 4);
	unsigned char y, u, v, r, g, b;
	for (int j = h - 1; j >= 0; j--) {
		ptrRGB = RgbBuf + w * j * 3;
		for (int i = 0; i < w; i++) {

			b = *(ptrRGB++);
			g = *(ptrRGB++);
			r = *(ptrRGB++);


			y = (unsigned char)((66 * r + 129 * g + 25 * b + 128) >> 8) + 16;
			u = (unsigned char)((-38 * r - 74 * g + 112 * b + 128) >> 8) + 128;
			v = (unsigned char)((112 * r - 94 * g - 18 * b + 128) >> 8) + 128;
			*(ptrY++) = clip_value(y, 0, 255);
			if (j % 2 == 0 && i % 2 == 0) {
				*(ptrU++) = clip_value(u, 0, 255);
			}
			else {
				if (i % 2 == 0) {
					*(ptrV++) = clip_value(v, 0, 255);
				}
			}
		}
	}
	return true;
}


DWORD WINAPI ScreenCapThreadProc(LPVOID lpParam)
{
	CCaptureScreen* ccs = new CCaptureScreen();
	int width = 0;
	int height = 0;

	ccs->Init(width, height);

	AVFormatContext* avFormCtx_Out;
	AVCodecContext*  avCodecCtx_Out;
	AVCodec*  avCodec;
	AVStream* avStream;
	AVFrame* frame;
	AVPacket* packet;

	int frameRate = 10;
	int ret = 0;
	const char* filename = "out.mp4";

	ret = avformat_alloc_output_context2(&avFormCtx_Out, NULL, NULL, filename);
	if (ret < 0)
	{
		printf("Init avformat object is faild! \n");
		return 0;
	}

	avCodec = (AVCodec *)avcodec_find_encoder(avFormCtx_Out->oformat->video_codec);
	if (!avCodec)
	{
		printf("Init avCodec object is faild! \n");
		return 0;
	}

	avCodecCtx_Out = avcodec_alloc_context3(avCodec);
	if (!avCodecCtx_Out)
	{
		printf("Init avCodecCtx_Out object is faild! \n");
		return 0;
	}
	avStream = avformat_new_stream(avFormCtx_Out, avCodec);
	if (!avStream)
	{
		printf("Init avStream object is faild! \n");
		return 0;
	}

	avCodecCtx_Out->flags |= AV_CODEC_FLAG_QSCALE;
	avCodecCtx_Out->bit_rate = 4000000;
	avCodecCtx_Out->rc_min_rate = 4000000;
	avCodecCtx_Out->rc_max_rate = 4000000;
	avCodecCtx_Out->bit_rate_tolerance = 4000000;
	avCodecCtx_Out->time_base.den = frameRate;
	avCodecCtx_Out->time_base.num = 1;

	avCodecCtx_Out->framerate.den = frameRate;
	avCodecCtx_Out->framerate.num = 1;

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

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

	if (avFormCtx_Out->oformat->flags & AVFMT_GLOBALHEADER)
		avCodecCtx_Out->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;

	ret = avcodec_open2(avCodecCtx_Out, avCodec, NULL);
	if (ret < 0)
	{
		printf("Open avcodec is faild! \n");
		return 0;
	}

	avcodec_parameters_from_context(avStream->codecpar, avCodecCtx_Out);
	if (!(avFormCtx_Out->oformat->flags & AVFMT_NOFILE))
	{
		ret = avio_open(&avFormCtx_Out->pb, filename, AVIO_FLAG_WRITE);
		if (ret < 0)
		{
			printf("Open file is faild! \n");
			return 0;
		}
	}
	ret = avformat_write_header(avFormCtx_Out, NULL);
	if (ret < 0)
	{
		printf("write header is faild! \n");
		return 0;
	}

	frame = av_frame_alloc();
	if (!frame)
	{
		printf("Init frame is faild! \n");
		return 0;
	}
	frame->format = AV_PIX_FMT_YUV420P;
	frame->width = width;
	frame->height = height;

	LONG64 frameSize = av_image_get_buffer_size(AV_PIX_FMT_YUV420P, 1920, 1080, 1);
	BYTE* outbuffer = new BYTE[frameSize];

	ret = av_image_fill_arrays(frame->data,
		frame->linesize,
		outbuffer,
		AV_PIX_FMT_YUV420P,
		1920,
		1080, 1);

	if (ret < 0)
	{
		printf("av_image_fill_arrays is faild! \n");
		return 0;
	}
	packet = av_packet_alloc();
	//av_init_packet(packet);
	if (!packet)
	{
		printf("packet is faild! \n");
		return 0;
	}

	int frameNumber = 0;
	int got_packet = 0;

	DWORD dwBeginTime = ::GetTickCount();
	for (;;)
	{
		BYTE* frameimage = ccs->CaptureImage();

		RGB24_TO_YUV420(frameimage, width, height, outbuffer);
		AVRational timeBaseMillsecond;
		timeBaseMillsecond.den = 1000;
		timeBaseMillsecond.num = 1;

		DWORD dwCurrDtsTime = ::GetTickCount();
		frame->pkt_dts = frame->pts = av_rescale_q_rnd(dwCurrDtsTime - dwBeginTime, timeBaseMillsecond, avStream->time_base, (AVRounding)(AV_ROUND_NEAR_INF | AV_ROUND_PASS_MINMAX));
		frame->pkt_duration = 0;
		frame->pkt_pos = -1;

		ret = avcodec_send_frame(avCodecCtx_Out, frame);
		if (ret < 0)
			continue;

		ret = avcodec_receive_packet(avCodecCtx_Out, packet);
		if (ret < 0)
			continue;

		static DWORD dwInitTime = ::GetTickCount();
		if (packet->size > 0)
		{
			//av_packet_rescale_ts(packet, avCodecCtx_Out->time_base, avStream->time_base);
			av_write_frame(avFormCtx_Out, packet);
			frameNumber++;
			printf("录入第%d帧....\n", frameNumber);
		}

		DWORD dwCurrentTime = ::GetTickCount();
		if (dwCurrentTime - dwInitTime > 120000)
		{
			break;
		}

		int dwPassedMillSeconds = dwCurrentTime - dwBeginTime;
		if (dwCurrentTime - dwInitTime <= 60000)
		{
			int dwDiff = frameNumber * 1000 / 10 - dwPassedMillSeconds;
			if (dwDiff > 0)
			{
				Sleep(dwDiff);
			}
		}
		else
		{
			int dwPassedMillSeconds = dwCurrentTime - dwBeginTime - 60000;
			int dwDiff = (frameNumber - 600) * 1000 / 5 - dwPassedMillSeconds;
			if (dwDiff > 0)
			{
				Sleep(dwDiff);
			}
		}
	}
	av_write_trailer(avFormCtx_Out);
	avformat_free_context(avFormCtx_Out);
	avcodec_close(avCodecCtx_Out);
	avcodec_free_context(&avCodecCtx_Out);
	av_free(avCodec);
	av_packet_free(&packet);
	av_frame_free(&frame);
	return 0;
}


int _tmain(int argc, _TCHAR* argv[])
{
	//av_register_all();
	//avformat_network_init();
	avdevice_register_all();


	HANDLE hThread = CreateThread(NULL, 0, ScreenCapThreadProc, 0, 0, NULL);
	WaitForSingleObject(hThread, INFINITE);
	return 0;
}
tusong86
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
ffmpeg录制视频包ffmpeg录制视频包
06-12
ffmpeg录制视频包ffmpeg录制视频包ffmpeg录制视频包ffmpeg录制视频包ffmpeg录制视频包ffmpeg录制视频包ffmpeg录制视频包ffmpeg录制视频包ffmpeg录制视频包ffmpeg录制视频包ffmpeg录制视频包ffmpeg录制视频包
python 摄像头录制帧率_基于opencv和python的可变帧速率IP摄像机视频记录
weixin_39520393的博客
01-28 587
首先，我想对我正在做的事情发表评论。在我有一个IP摄像机通过一个带以太网线的路由器连接到我的网络(FOSCAM 9800p)，我试图用RTSP协议录制一段视频。我未来的打算是用opencv在中间添加一个小的视频处理，但目前我想做一些测试来简单地记录下来。在主要的问题是相机每秒传送的帧数是可变的，也就是说，有时它传送到18帧，其他的传送到22帧，依此类推。当以每秒帧数的固定速率录制视频时，最终发生的...
OCam 录制，可变帧率、码率及恒定帧率、码率详解
qq_40879051的博客
03-18 4067
一.OCam 录制使用，编码器设置 1.选择好录制区域，点击录制即可录制 2.如需更改编码设置，点击编码。 选择H.264编码格式或者其他格式 3.如需详细设置 点击菜单-选项 在录制界面设置参数，视频 帧每秒（FPS）可以选择24帧及更高，帧速率模式可选：恒定帧速率与可变帧速率（恒定可变帧速率可看详解）。质量可以选择 低 高 中等，也可自定义。其他设置按需求设置。 4.自定义设置 配置文件可选主要或高，一般选主要即可。级别可自动，也可自...
ffmpeg -比特率，帧率和文件大小
吐着泡泡说爱你的博客
06-19 1万+
比特率和帧率是音视频基本的特性，对于音视频整体的质量有关键作用！如果知道比特率和持续时间，就可以计算输出文件的大小。 1.Frame(frequency)rate introduction 帧率就是每秒编码进视频文件的帧数目。人类的眼睛需要每秒至少15帧才能将图像连贯在一起。帧率的单位是HZ，LCD显示一般有60Hz的平率。 有2种类型的帧率-interlaced(denoted asi af
ffmpeg设置视频帧率
热门推荐
ss00_2012的专栏
07-10 6万+
使用-r参数可以对视频的帧率进行设置，那么是写成ffmpeg -i input -r n output还是ffmpeg -r n -i input output呢? 实际上-r参数用来设置输入文件和输出文件的效果是不一样的 前者决定了文件的时长，如果总帧数为N我们设置帧率为n,那么文件的长度就是N/n。如果未指定帧率，默认为25。 后者可以用来降低码流，也就说对于一秒的n帧，我们想让输出文件
FFMPEG使用
chenguowen21的专栏
02-22 8973
0 将两个视频水平合成一个视频，通常用于比较两个效果视频 ffmpeg -i 11.mp4 -i 22.mp4 -filter_complex hstack output.mp4 1 从序列图片生成视频 ffmpeg -i %d.jpg out.mp4 -i后面的%d.jpg是说输入图片的命名规则 2 从视频生成图片： ffmpeg -i output.mp4 -r 30 %d.jpg -r 30写不写应该都行，他是用来指定帧率的 此外可以添加一些设置控制ffmpeg的行为：
ffmpeg
qq_42331499的博客
05-13 3367
1 简单使用需要现在ffmepg，然后配置环境变量 2 基本命令行参数介绍 -re 使用正常速度推流 -stream_loop -1 循环推流 -vcodec copy或者libx264 视频转码格式，可以不写 -acodec copy或者aac 音频转码格式，可以不写 -f flv 输出流格式 -r 16 可以直接优化直播画面卡顿问题 -framerate 15 可以优化直播画面卡顿问题 -crf 51 可以将视频清晰度直接下降，直接降低网速，硬件要求 3 一些推流命令 ffmpeg
ffmpeg帧率计算
最新发布
weixin_39399492的博客
09-16 1781
1、ffmpeg在转码过程中，输出文件的帧率如何确定。2、深入ffmpeg源码，剖析帧率的数据来源，涉及到的有 基本帧率(tbr/r_frame_rate)、平均帧率(fps/avg_frame_rate)以及编码器帧率(framerate)的数值是如何获取和计算的，以及它们之间的关系。3、上述数据如何通过ffmpeg/ffprobe/ffplay获取。
FFMPEG4.1 - 时间戳相关的pts、dts与time_base
顺其自然~专栏
05-13 1751
一、先说说time_base 1、time_base的定义： time_base的意思是时间刻度，即给定一个时间，比如1秒，然后分成25等份，那么这个时间刻度就是1/25秒。 2、time_base的结构体 /** * 分数 (分子与分母的组合). */ typedef struct AVRational{ int num; ///< 分子 int den; ///< 分母 } AVRational; 3、time_base的常用转换函数 // 创建..
FFmpeg 常用命令
简单记录工作和学习
05-31 2173
调整比特率、调整视频帧率、调整视频分辨率、修改视频的宽高比
ffmpeg录制桌面(队列方式)
tusong86的博客
11-20 793
vs版本:2017 ffmpeg版本号： ffmpeg version N-102642-g864d1ef2fc Copyright © 2000-2021 the FFmpeg developers built with gcc 8.1.0 (x86_64-win32-seh-rev0, Built by MinGW-W64 project) configuration: --arch=x86_64 --prefix=/home/ffmpeg_static_x64 --disable-debug liba
FFMPEG视频录制+时间水印
04-06
FFMPEG采集摄像头图像数据 SDL图像渲染 avfilter库处理时间水印 MP4格式视频保存 Linux下FFMEPG应用
MFC+FFMPEG非常简单的桌面视频录制及处理
10-20
编译环境VS2012 只是实现了录制，播和一些简单的编码，加水印等处理，基于FFMPEG实现的非常粗糙，仅供参考
C++ 视频录制播放 FFMPEG_Player
02-19
FFMPEG_Player 视频录制 播放
FFmpeg - ffplay制作桌面动态壁纸
02-08
本资源包含完整的Vs+Qt+FFmpeg+sdl代码。 资源介绍：https://blog.csdn.net/automoblie0/article/details/122377903 资源视频介绍：https://www.bilibili.com/video/BV1wZ4y1D7DM/?spm_id_from=333.999.0.0 【视频中...
探索FFmpeg：实现自定义播放速度的全方位指南
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
05-15 1170
探索FFmpeg：实现自定义播放速度的全方位指南
FFmpeg - time_base,r_frame_rate
biezhihua的专栏
03-15 8433
AVRational本质上用来表示有理数，有一些帧率frame_rate[每秒出现多少帧]和frame time一帧多少时间（和帧率互为倒数），不能用一个小数比如23.976来精确表示。所以用一个分母和一个分子来表示。你愿意正着除，反着除都无所谓， 误差由除法产生，它提供的数据是没有误差的。/** * rational number numerator/denominator */ typede
使用ffmpeg avfilter改变帧率
相见不如怀念
02-12 4824
最近碰到一个视频卡顿的问题，问题原因定位到采集端过来的帧率低于25帧时，分析接收端合成出来的视频帧率低于25帧，所以播放出来的画面就出现了卡顿，目前想到的方法是用ffmpeg avfilter改变视频帧率，按照指定帧率输出视频帧（丢帧或者复制），至于ffmpeg avfilter的功能有多强大大家可以网上查下，下面说下具体的实现思路： 1.先说ffmpeg avfilter在命令行下如何实现： ...
FFMPEG帧率设置总结
weixin_42717961的博客
01-24 1万+
正常情况下可以通过AVCodecContext结构体中的time_base来设置帧率，如下设置帧率30 AVCodecContext* pVideoCtx = avcodec_alloc_context3(video_encoder); pVideoCtx-&gt;time_base.num = 1; pVideoCtx-&gt;time_base.den = 30; 但是有些情况设置不会有...
ffmpeg 录制视频
08-28
其中，-f gdigrab表示使用gdigrab模块进行屏幕录制，-t 30表示录制时长为30秒，-framerate 15表示帧率为15帧/秒，-i desktop表示输入源为桌面屏幕，-f dshow -i audio="virtual-audio-capturer"表示使用dshow模块...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值