ffmpeg截取指定时间范围内的视频

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

ffmpeg提供了如下命令行用于截取指定时间范围内的视频：
ffmpeg -i c:\record\out_computer.mp4 -ss 00:00:10 -to 00:00:39 out_computer_2second.mp4

我跟了下ffmpeg命令行代码，没有使用滤镜，直接读取的视频AVPacket，用里面的pts判断是否在时间范围内。
如果读取到的pts小于起始时间，则读取下一帧，接着判断。
如果读取到的pts大于结束时间，则结束。

本人为此专门写了一个工程，该工程考虑了只有视频，没音频的文件。
main函数的内容如下，通俗易懂：

int main()
{
	CTrimFile cVideoTrim;
	const char *pFileA = "c:\\record\\out-computer.mp4";

	const char *pFileOut = "c:\\record\\out-computer_trimmed.mp4";

	std::string strBeginTime = "00:00:10";
	std::string strEndTime = "00:00:20";


	int iStartTime = TimeToSeconds(strBeginTime);
	int iEndTime = TimeToSeconds(strEndTime);

	int iDuration = iEndTime - iStartTime;


	cVideoTrim.StartTrim(pFileA, pFileOut, iStartTime, iDuration);
	cVideoTrim.WaitFinish();
	return 0;
}

下面是读取文件的部分代码，红色方框显示了帧的过滤逻辑
在这里插入图片描述

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

#include <iostream>
#include "TrimFile.h"
#include <vector>

#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


void SeparateString(const char* pStr, std::vector<int>& vecResult, char chKey)
{
	if (pStr == NULL || pStr[0] == 0)
	{
		return;
	}

	std::string tmp = pStr;
	if (tmp.at(tmp.length() - 1) != chKey)
	{
		tmp += chKey;
	}
	size_t beginIndex = 0;
	static const size_t npos = size_t(-1);
	size_t indexCh1a = tmp.find(chKey, beginIndex);

	std::string tmpBuf;

	while (indexCh1a != npos)
	{
		int len = static_cast<int>(indexCh1a - beginIndex);
		if (len > 0)
		{
			tmpBuf.clear();
			tmpBuf.append(tmp.c_str() + beginIndex, static_cast<size_t>(len));
			vecResult.push_back(atoi(tmpBuf.c_str()));
		}
		beginIndex = ++indexCh1a;
		indexCh1a = tmp.find(chKey, beginIndex);
	}
}


///00:00:10这种类型的时间转化为秒数
int TimeToSeconds(std::string strTime)
{
	int iRetSecond = 0;
	std::vector<int> vecTime;
	SeparateString(strTime.c_str(), vecTime, ':');

	if (vecTime.size() != 3)
	{
		return iRetSecond;
	}

	int iHour = vecTime[0];
	int iMinute = vecTime[1];
	int iSecond = vecTime[2];

	iRetSecond = iHour * 3600 + iMinute * 60 + iSecond;

	return iRetSecond;
}


int main()
{
	CTrimFile cVideoTrim;
	const char *pFileA = "c:\\record\\out-computer.mp4";

	const char *pFileOut = "c:\\record\\out-computer_trimmed.mp4";

	std::string strBeginTime = "00:00:10";
	std::string strEndTime = "00:00:20";


	int iStartTime = TimeToSeconds(strBeginTime);
	int iEndTime = TimeToSeconds(strEndTime);

	int iDuration = iEndTime - iStartTime;


	cVideoTrim.StartTrim(pFileA, pFileOut, iStartTime, iDuration);
	cVideoTrim.WaitFinish();
	return 0;
}

TrimFile.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 CTrimFile
{
public:
	CTrimFile();
	~CTrimFile();
public:
	int StartTrim(const char *pFileA, const char *pFileOut, int iStartTime, int iDuration);
	int WaitFinish();
private:
	int OpenFileA(const char *pFileA);
	int OpenOutPut(const char *pFileOut);
private:
	static DWORD WINAPI VideoAReadProc(LPVOID lpParam);
	void VideoARead();


	static DWORD WINAPI VideoTrimProc(LPVOID lpParam);
	void VideoTrim();
private:
	AVFormatContext *m_pFormatCtx_FileA = NULL;

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


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

	AVFifoBuffer *m_pVideoAFifo = NULL;


	int m_iVideoWidth = 1920;
	int m_iVideoHeight = 1080;
	int m_iYuv420FrameSize = 0;
private:
	CRITICAL_SECTION m_csVideoASection;
	HANDLE m_hVideoAReadThread = NULL;
	HANDLE m_hVideoTrimThread = NULL;

	int64_t m_i64TrimStartTime = 0;
	int64_t m_i64TrimDuration = 0;

	int64_t m_i64VideoStartTime = 0;
	AVRational m_streamTimeBase;
};

TrimFile.cpp的内容如下：


#include "TrimFile.h"
//#include "log/log.h"





CTrimFile::CTrimFile()
{
	InitializeCriticalSection(&m_csVideoASection);
}

CTrimFile::~CTrimFile()
{
	DeleteCriticalSection(&m_csVideoASection);
}

int CTrimFile::StartTrim(const char *pFileA, const char *pFileOut, int iStartTime, int iDuration)
{
	int ret = -1;
	do
	{
		ret = OpenFileA(pFileA);
		if (ret != 0)
		{
			break;
		}

		m_i64TrimStartTime = iStartTime * m_streamTimeBase.den / m_streamTimeBase.num;
		m_i64TrimDuration = iDuration * m_streamTimeBase.den / m_streamTimeBase.num;

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

		char szFilterDesc[512] = { 0 };

		_snprintf(szFilterDesc, sizeof(szFilterDesc),
			"[inPad]pad=%d:%d[inPad0];[in0]trim=start=%d:duration=%d[in00];[inPad0][in00]overlay=0[out]",
			m_iVideoWidth, m_iVideoHeight, iStartTime, iDuration);

		_snprintf(szFilterDesc, sizeof(szFilterDesc),
			"[inPad]pad=%d:%d[inPad0];[in0]trim=start=%d:end=%d[in00];[inPad0][in00]overlay=0[out]",
			m_iVideoWidth, m_iVideoHeight, iStartTime, iStartTime + iDuration);

		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_hVideoAReadThread = CreateThread(NULL, 0, VideoAReadProc, this, 0, NULL);

		m_hVideoTrimThread = CreateThread(NULL, 0, VideoTrimProc, this, 0, NULL);

	} while (0);

	return ret;
}

int CTrimFile::WaitFinish()
{
	int ret = 0;
	do
	{
		if (NULL == m_hVideoAReadThread)
		{
			break;
		}
		WaitForSingleObject(m_hVideoAReadThread, INFINITE);

		CloseHandle(m_hVideoAReadThread);
		m_hVideoAReadThread = NULL;

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

	return ret;
}

int CTrimFile::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_i64VideoStartTime = m_pFormatCtx_FileA->streams[0]->start_time;
		m_streamTimeBase = m_pFormatCtx_FileA->streams[0]->time_base;

		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_iVideoWidth = m_pReadCodecCtx_VideoA->width;
		m_iVideoHeight = m_pReadCodecCtx_VideoA->height;

		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 CTrimFile::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_iVideoWidth;
			m_pCodecEncodeCtx_Video->height = m_iVideoHeight;
			//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;
}


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

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

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

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

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

			if (packet.pts - m_i64VideoStartTime < m_i64TrimStartTime)
			{
				continue;
			}

			if (packet.pts - m_i64VideoStartTime > m_i64TrimStartTime + m_i64TrimDuration)
			{
				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;
		}
	}

	av_frame_free(&pFrame);
	delete[] pY;
	delete[] pU;
	delete[] pV;
}

DWORD WINAPI CTrimFile::VideoTrimProc(LPVOID lpParam)
{
	CTrimFile *pVideoMerge = (CTrimFile *)lpParam;
	if (pVideoMerge != NULL)
	{
		pVideoMerge->VideoTrim();
	}
	return 0;
}


void CTrimFile::VideoTrim()
{
	int ret = 0;

	int iYuv420PadFrameSize = av_image_get_buffer_size(AV_PIX_FMT_YUV420P, m_iVideoWidth, m_iVideoHeight, 1);
	int y_size = m_iVideoWidth * m_iVideoHeight;


	DWORD dwBeginTime = ::GetTickCount();


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

	pFrameVideoA->width = m_iVideoWidth;
	pFrameVideoA->height = m_iVideoHeight;
	pFrameVideoA->format = AV_PIX_FMT_YUV420P;

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

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

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

		int iVideoASize = av_fifo_size(m_pVideoAFifo);

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


			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;


			ret = avcodec_send_frame(m_pCodecEncodeCtx_Video, pFrameVideoA);

			ret = avcodec_receive_packet(m_pCodecEncodeCtx_Video, &packet);

			av_write_frame(m_pFormatCtx_Out, &packet);

			iPicCount++;
		}
		else
		{
			if (m_hVideoAReadThread == NULL)
			{
				break;
			}
			Sleep(1);
		}
	}

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

	av_frame_free(&pFrameVideoA);
}
tusong86
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
FFmpeg[12] - FFmpeg之视频分段裁剪（等时间段）
liuzhen007的专栏
09-06 9401
FFmpeg有非常多的功能。 实际生活中，经常会遇到想把一段视频等比例切片的情况，今天就来介绍一下怎么实现这个功能。 实现这个功能的前提就是对FFmpeg的视频操作非常了解。 这个功能涉及到一个参数 segment_time ，意思是时间切片时长，你可以使用时间格式，时:分:秒 ，表明时间切片长度。 比如我们想将test.mp4进行切片，每片视频的时间长度是6分钟，可以使用如下命令。 windows机器： ffmpeg.exe -i C:/clips/test.mp4 -c copy -map
使用ffmpeg根据开始和结束时间剪切视频
p15097962069的博客
05-06 1万+
I tried to cut the video using the start and end time of the video by using the following command 我
ffmpeg截取视频片段的两种方式 1） 按时间截取 2）按帧数截取
热门推荐
大洋深处
05-24 3万+
代码保存下： ffmpeg -i ./SN.mp4 -vcodec copy -acodec copy -ss 00:00:00 -to 00:00:05 ./cutout1.mp4 -y
ffmpeg 对视频按时间裁减（分段）
最新发布
weixin_42220452的博客
04-09 343
ss 00:00:03 -t 00:00:06：从视频的多少时间开始 到 多少时间结束。这里表示从视频的第3秒开始裁减，一直裁减到第6秒结束。-i ./input.mp4: -i 表示输入，即需要被裁减的视频。./ 表示当前位置， input.mp4 是需要被裁减视频的名称。总上所述：将当前位置的input.mp4 从第3秒开始裁减，裁减到第6秒。./output.mp4：裁减后的视频保存位置 ./ 表示当前位置， output.mp4是裁减后的视频名称。
使用 ffmpeg 截取视频的某一个时间段内容
岁月如歌
07-17 2312
使用 -ss 选项指定需要截取的开始时间，结合 -to 或者 -t。
使用FFmpeg提取视频中的图像(根据帧间隔、时间间隔)
修炼之路
07-14 2万+
前言 为了对视频做一些处理，需要提取视频中的图像，根据不同需求有时候可能需要按一定时间间隔或帧间隔来提取视频中的帧，目的是为了处理提高效率和减少内存的占用，使用OpenCV也可以完成这一功能，不过相对于FFmpeg来说，处理视频的效率要慢不少，对于数量比较大的视频处理建议使用FFmpeg来进行。 通过FFmpeg获取视频的总帧数 ffprobe <input> -select_...
ffmpeg截取视频用到的文件
02-15
使用步骤： 1、修改down.bat文件中的视屏名称与保存名称 2、把被截取视频放在与文件一个目录下 3、点击down.bat执行
java用ffmpeg截取视频图片
11-21
Java 使用 FFmpeg 截取视频图片是一个常见的任务，它涉及到多媒体处理、命令行操作和跨平台编程。FFmpeg 是一个强大的开源工具集，用于处理音频和视频文件，包括编码、解码、转码、流处理等功能。在 Java 中，我们...
FFMpeg视频截取工具
09-16
3. 持续时间截取：若要截取一段连续的视频片段，可以使用`-t`参数，如`ffmpeg -ss 00:01:23 -t 00:00:10 -i input.mp4 output.mp4`，截取1分23秒到1分33秒的视频。 三、高级特性 1. 视频质量控制：通过`-qscale`或...
php截取视频指定帧为图片
10-22
总的来说，通过PHP结合FFmpeg，我们可以方便地实现从视频中截取指定帧并处理旋转问题，以生成正确的图片。这样的功能在处理用户上传的视频或者需要预览视频关键帧的场景中非常有用。在实际应用中，还应考虑错误处理...
FFMPEG视频录制+时间水印
04-06
FFMPEG采集摄像头图像数据 SDL图像渲染 avfilter库处理时间水印 MP4格式视频保存 Linux下FFMEPG应用
三种方法使用FFmpeg截取视频片断
m0_60259116的博客
09-23 1万+
三种方法使用FFmpeg截取视频片断
ffmpeg根据开始时间结束时间切割视频
fjh1997的博客
05-10 7994
根据开始时间结束时间,to+结束时间 ffmpeg -ss 00:01:00 -i input.mp4 -to 00:02:00 -c copy output.mp4 根据时长切割视频 ```bash ffmpeg -ss 00:01:00 -i input.mp4 -t 00:02:00 -c copy output.mp4
ffmpeg裁剪合并视频
富亮的地盘
10-02 1475
这里裁剪是指时间轴裁剪，不是空间裁剪。 比如说，你想把视频的从一分20秒开始，30秒的视频裁剪出来，保存成一个视频。这是这个文章要讨论的问题。   一  裁剪视频 ffmpeg提供简单的命令参数： ffmpeg -ss START -t DURATION -i INPUT -vcodec copy -acodec copy OUTPUT 对上面的命令稍做个解释。 -ss 开始时
“快速掌握如何用FFmpeg在Python中截取定时间隔的MP4视频画面“
Winfredzhang的博客
03-09 1093
input_video.mp4：输入视频文件的路径和名称。-vf "select='not(mod(n,300))',drawtext=fontfile=/path/to/font.ttf:fontsize=30:text='%{pts:hms}'"：指定要应用的滤镜。
使用ffmpeg一行命令根据时间分割MP4文件
Never Give Up
01-24 2788
纯小白参考得博客 https://www.cnblogs.com/exlo/p/14240096.html ffmpeg -ss 00:00:00 -i input.mp4 -c copy -t 00:05:30 output.mp4 把音频文件命名为input.exe在ffmpeg文件下输入命令，最后一个参数00:50:30是你希望视频结束地址，最后文件夹下会输出output.exe 吐槽一下网上得视频分割软件也太大了，我只想简单切去视频末尾一部分???? ...
python中使用ffmpeg进行视频指定时长截断（解决剪切后音视频不同步的问题）
weixin_45475063的博客
09-26 5157
1. 获取视频时长 有两种方式获取视频总时长： python-ffmpeg（ 获取的是视频总秒数 ） video_time = float(ffmpeg.probe(video)['format']['duration']) opencv（ 帧速率 / 视频总帧数 = 时间 ） cap = cv2.VideoCapture(video) video_time = float(cap.get(7)...
如何用ffmpeg截取视频片段&截取时间不准确的坑
xindoo
01-31 8110
之前在工作中，有遇到需要程序化截取视频片段的场景，这里使用ffmpeg命令行就可以很容易实现，这里也记录下我们使用过程中遇到的坑，希望对大家也有所帮助。这里的参数-c:v copy指的是复用原始视频的编码格式，如果想切换视频编码也可以直接指定，比如(关于修改视频和音频编码的问题，后续会继续出一篇博客)。这里需要注意的是。
FFmpeg截屏、剪切一段视频、或者压缩视频
styleqw的博客
07-21 2895
这里我给出剪切视频的一段代码，缺点是无法精确，比如我想剪切20秒，但是可能剪切好的是23秒。网上大多是通过命令的显示操作ffmpeg,不太灵活。//如果想截取规定时间段视频 请看系列文章二。
FFMPEG截取视频
09-12
FFmpeg是一个强大的多媒体处理工具，可以用来截取视频。有两种方法可以使用FFmpeg截取视频。 第一种方法是使用参数"-ss"和"-t"，其中"-ss"表示开始时间，"-t"表示持续时间。例如，可以使用以下命令来从视频的第10秒开始截取15秒的片段： ffmpeg -i ./input.mp4 -c:v libx264 -crf 18 -ss 00:00:10 -t 15 ./cut_out.mp4。 第二种方法是使用参数"-ss"和"-to"，其中"-ss"表示开始时间，"-to"表示结束时间。例如，可以使用以下命令来从视频的第10秒开始截取到第15秒的片段： ffmpeg -i ./input.mp4 -c:v libx264 -crf 18 -ss 00:00:10 -to 00:00:15 ./cut_out.mp4。 通过以上两种方法，你可以根据需要指定开始时间和持续时间或者开始时间和结束时间来截取视频。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值