ffmpeg delogo滤镜去除图片水印

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

之前本人写过ffmpeg movie滤镜添加图片水印，ffmpeg 非movie滤镜添加图片水印
今天用delogo滤镜去掉图片水印，ffmpeg命令行如下：

ffmpeg -i in-computer_drawmovie.mp4 -vf delogo=x=100:y=300:w=480:h=320:show=0 in-computer_drawmovie_delogo.mp4

指定去除的起始位置为100,300，水印的宽度和高度分别为480和320。

水印去除前，效果如下：
在这里插入图片描述
去除水印后，效果如下：
在这里插入图片描述

去除的原理是根据被去掉部分周围的色彩进行颜色构造，具体我暂时没兴趣研究。

下面是代码结构：
在这里插入图片描述
FfmpegDelogoTest.cpp的代码如下：

#include <iostream>
#include "Delogo.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



std::string Unicode_to_Utf8(const std::string & str)
{
	int nwLen = ::MultiByteToWideChar(CP_ACP, 0, str.c_str(), -1, NULL, 0);
	wchar_t * pwBuf = new wchar_t[nwLen + 1];//一定要加1，不然会出现尾巴 
	ZeroMemory(pwBuf, nwLen * 2 + 2);
	::MultiByteToWideChar(CP_ACP, 0, str.c_str(), str.length(), pwBuf, nwLen);
	int nLen = ::WideCharToMultiByte(CP_UTF8, 0, pwBuf, -1, NULL, NULL, NULL, NULL);
	char * pBuf = new char[nLen + 1];
	ZeroMemory(pBuf, nLen + 1);
	::WideCharToMultiByte(CP_UTF8, 0, pwBuf, nwLen, pBuf, nLen, NULL, NULL);
	std::string retStr(pBuf);
	delete[]pwBuf;
	delete[]pBuf;
	pwBuf = NULL;
	pBuf = NULL;
	return retStr;
}


int main()
{
	CDelogo cCDelogo;
	const char *pFileA = "E:\\learn\\ffmpeg\\FfmpegFilterTest\\x64\\Release\\in-computer_drawmovie.mp4";

	const char *pFileOut = "E:\\learn\\ffmpeg\\FfmpegFilterTest\\x64\\Release\\in-computer_drawmovie_delogo.mp4";

	int x = 100;
	int y = 300;
	int width = 480;
	int height = 320;
	cCDelogo.StartDelogo(pFileA, pFileOut, x, y, width, height);
	cCDelogo.WaitFinish();
	return 0;
}

Delogo.h的代码如下：

#pragma once

#include <Windows.h>
#include <string>

#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 CDelogo
{
public:
	CDelogo();
	~CDelogo();
public:
	int StartDelogo(const char *pFileA, const char *pFileOut, int x, int y, int width, int height);
	int WaitFinish();
private:
	int OpenFileA(const char *pFileA);
	int OpenOutPut(const char *pFileOut);
	int InitFilter(const char* filter_desc);
private:
	static DWORD WINAPI VideoAReadProc(LPVOID lpParam);
	void VideoARead();


	static DWORD WINAPI VideoDelogoProc(LPVOID lpParam);
	void VideoDelogo();
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:
	AVFilterGraph* m_pFilterGraph = NULL;
	AVFilterContext* m_pFilterCtxSrcVideoA = NULL;
	AVFilterContext* m_pFilterCtxSink = NULL;
private:
	CRITICAL_SECTION m_csVideoASection;
	HANDLE m_hVideoAReadThread = NULL;
	HANDLE m_hVideoDelogoThread = NULL;
};

Delogo.cpp的代码如下：


#include "Delogo.h"
//#include "log/log.h"





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

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

int CDelogo::StartDelogo(const char *pFileA, const char *pFileOut, int x, int y, int width, int height)
{
	int ret = -1;
	do
	{
		ret = OpenFileA(pFileA);
		if (ret != 0)
		{
			break;
		}

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

		char szFilterDesc[512] = { 0 };


		_snprintf(szFilterDesc, sizeof(szFilterDesc),
			"[in0]delogo=x=%d:y=%d:w=%d:h=%d:show=0[out]", x, y, width, height);

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

		m_hVideoDelogoThread = CreateThread(NULL, 0, VideoDelogoProc, this, 0, NULL);

	} while (0);

	return ret;
}

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

		CloseHandle(m_hVideoAReadThread);
		m_hVideoAReadThread = NULL;

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

	return ret;
}

int CDelogo::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_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 CDelogo::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 CDelogo::VideoAReadProc(LPVOID lpParam)
{
	CDelogo *pVideoMerge = (CDelogo *)lpParam;
	if (pVideoMerge != NULL)
	{
		pVideoMerge->VideoARead();
	}
	return 0;
}

void CDelogo::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;
			}

			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 CDelogo::VideoDelogoProc(LPVOID lpParam)
{
	CDelogo *pVideoMerge = (CDelogo *)lpParam;
	if (pVideoMerge != NULL)
	{
		pVideoMerge->VideoDelogo();
	}
	return 0;
}


void CDelogo::VideoDelogo()
{
	int ret = 0;


	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;


	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_iVideoWidth, m_iVideoHeight, 1);

	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 = av_buffersrc_add_frame(m_pFilterCtxSrcVideoA, pFrameVideoA);
			if (ret < 0)
			{
				break;
			}

			ret = av_buffersink_get_frame(m_pFilterCtxSink, pFrame_out);
			if (ret < 0)
			{
				//printf("Mixer: failed to call av_buffersink_get_frame_flags\n");
				break;
			}

			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_iVideoWidth;
			pFrame_out->height = m_iVideoHeight;
			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++;
		}
		else
		{
			if (m_hVideoAReadThread == NULL)
			{
				break;
			}
			Sleep(1);
		}
	}

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

	av_frame_free(&pFrameVideoA);
}


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

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

	AVFilter* filter_src_videoA = (AVFilter *)avfilter_get_by_name("buffer");
	AVFilter* filter_sink = (AVFilter *)avfilter_get_by_name("buffersink");

	AVFilterInOut* filter_output_videoA = 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_videoA, sizeof(args_videoA),
		"video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
		m_iVideoWidth, m_iVideoHeight, AV_PIX_FMT_YUV420P,
		timeBase.num, timeBase.den,
		timeAspect.num,
		timeAspect.den);

	AVFilterInOut* filter_outputs[1];
	do
	{
		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_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_videoA->name = av_strdup(pad_name_videoA);
		filter_output_videoA->filter_ctx = m_pFilterCtxSrcVideoA;
		filter_output_videoA->pad_idx = 0;
		filter_output_videoA->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[0] = filter_output_videoA;


		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_videoA);
	avfilter_inout_free(filter_outputs);

	char* temp = avfilter_graph_dump(m_pFilterGraph, NULL);

	return ret;
}
tusong86
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
ffmpeg 视频添加水印 logo
03-24
NULL 博文链接：https://tompig.iteye.com/blog/1107765
ffmpeg滤镜:简单去掉电视台的logo
mwsubt的博客
01-11 517
这里用到的是delogo这个功能,它通过指定电视台logo 的区域,然后指定区域利用周围相邻像素来进行插值混合运 算,得到指定区域去掉logo后的像素值,从而实现滤镜效果. 其具备的参数值有: 1. x,y 指定区域的起始坐标 2. w,h 指定区域的宽高 3. band,t 这个已经废弃,就不做介绍了 4. show 这个置为1,滤镜后会呈现滤镜的具体区域,让人容易定位. 具体指令: ./ffmpeg -i yourinput.$(filesuffix) -vf "delogo=x=$(logo_x).
ffmpeg 滤镜实现不同采样率多音频混音
03-17
该资源主要实现多个AAC文件的混音功能；ffmpeg版本：5.14 利用ffmpeg开源库 对AAC数据进行解码，然后使用FFMPEG滤镜类对多个解码的PCM数据进行混合，最后对混合后的数据进行AAC编码； 主要内容： 音频解码，滤镜混音，音频编码 内容亮点： 当一个文件读取完毕后，程序不会停止，会继续读取其他文件，直到所有数据读取完毕 可以实现不同采样率的音频混合； 该代码以经过验证无误，下载下来后知名ffmpeg库可直接编译； 编译之前请确认ffmpeg版本是否匹配，不同的版本有着很大的差别；
ffmpeg添加水印
02-24
王纲老师的录制视频的代码部分,在我的机器上还多少有些问题，不知是视频文件还是FFMPEG的问题。
FFmpeg的加水印滤镜例子（有图形界面） ---ffmpeg_filter_mix_logo
10-12
ffmpeg_filter_mix_logo -- 在视频上叠加OSD文字或Logo图标，用到了FFmpeg的加水印滤镜。
ffmpeg去除水印(遮盖指定区域)的几种办法
u011531157的博客
11-16 2230
注意，drawbox过滤器会改变视频的内容，可能会导致视频的质量降低。overlay是ffmpeg中的一个过滤器，用于将一个视频流覆盖在另一个视频流上。delogo是ffmpeg中的一个过滤器，用于从视频中删除不需要的标志或水印。overlay同样可以将一个图片覆盖在一个视频的指定职位，实现遮挡或者添加水印的功能。drawbox是ffmpeg中的一个过滤器，用于在视频帧上绘制一个矩形。你也可以指定覆盖视频的位置。在这个命令中，W和H是主视频的宽度和高度，w和h是覆盖视频的宽度和高度。
ffmpeg 如何剔除掉视频中的水印和马赛克
百鸣的专栏
04-14 5357
表示从视频的第 0 秒开始取 60 秒的视频进行处理。这个命令会将 input.mp4 中的马赛克去除，并生成一个新的视频文件 output.mp4。分别表示水印区域的左上角坐标和宽高。这个命令会将 input.mp4 中的水印去除，并生成一个新的视频文件 output.mp4。FFmpeg 是一款功能强大的用于处理音视频的开源软件，可以用它来剔除视频中的水印和马赛克。分别表示帧间插值算法、运动补偿算法和块大小。表示使用 minterpolate 滤镜，表示使用 delogo 滤镜，表示输入视频的视频流，
使用ffmpeg视频去水印
热门推荐
漫步语林
09-12 2万+
ffmpeg提供一个delogo滤镜可以去除视频水印，通过对周围像素进行简单的插值来去掉一个logo,不过有可能产生一个马赛克效果 官方文档参考 http://ffmpeg.org/ffmpeg-all.html#delogo 使用delogo去除水印 通过对周围像素进行简单的插值来去掉一个logo。设置一个矩形覆盖标识，但可能出现其他误差 参数 x,y  logo的位置 w,h  ...
ffmpeg去水印
redis数据库安装及启用
05-09 1920
这句意思是在test.mp4这个文件1秒的位置截取一张图片，保存为out.jpg。2.将图片放入画图工具或者专业的图像处理工具（Photoshop）进行计算。show=0水印位置没有边框，show=1水印位置是一个绿色框覆盖。视频水印坐标为：50，640. 水印的宽高为：180,60。#【不推荐，容易算不准】使用截图工具截图一张视频完整的截图。#【推荐】使用ffmpeg 命令截取视频第一帧图，示例如下。找到水印左上角第一个点的坐标。3.组装去除水印的命令。x —— 水印横坐标。y —— 水印纵坐标。
深度探索：使用FFmpeg实现视频Logo的添加与移除
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
05-27 3382
深度探索：使用FFmpeg实现视频Logo的添加与移除
android利用FFmpeg为视频加水印
01-11
之前有人反馈之前上传的下载不了，我再次上传一次，如果有问题及时给我发邮件，或者可以关注一下我，给我发私信，咱们互相学习！（android端代码，FFmpeg实现为视频加水印, 邮箱：[email protected]）
FFmpeg 常用滤镜命令文档以及相应参数说明
04-25
FFmepg常用滤镜命令整理，以及LUT3D 命令使用参考，包含常用部分命令
FFMPEG视频录制+时间水印
04-06
FFMPEG采集摄像头图像数据 SDL图像渲染 avfilter库处理时间水印 MP4格式视频保存 Linux下FFMEPG应用
视频去水印工具 很好用私人珍藏
09-07
打开视频之后，点击设置水印区域一，选择水印所在的位置，用方框刚好遮盖，然后点击下方确定。有些视频会出现两个水印，可以点击设置水印区域二，选择另外一个水印，点击下方确定，这样的话同时选择了两个水印。 有些水印出现的时间不一，我们可以拖动主界面的进度条，拖动到出现水印的位置，然后在设置去掉水印的区域。
【国标语音对讲】EasyCVR视频汇聚平台海康/大华/宇视摄像头GB28181语音对讲配置
最新发布
EasyCVR视频融合云平台的技术博客
04-24 866
注意：旧固件的海康设备不支持跨网语音对讲，即设备和视频汇聚平台EasyCVR服务需要在同一网络内。
视频怎么批量压缩？5个好用的电脑软件和在线网站
2301_82062174的博客
04-24 616
视频怎么批量压缩？以上就是批量压缩视频分享的2个电脑压缩软件和3个在线压缩视频网站的全部内容啦。电脑软件批量压缩相比在线压缩网站会提供更丰富的压缩选项和功能，精确控制压缩参数，根据自己的需求选择不同的压缩设置，但是批量压缩太多太大的视频会影响电脑运行速度。而在线视频压缩网站则更加方便快捷，无需下载任何软件，任何设备和系统都可以随时使用，不过各方面的功能选择单一不丰富，会有一些限制。不同的方法有不同的优缺点，按需选择就好，希望可以帮助到你哦~
【AIGC】文本与音频生成引领行业革新
richard_yuu的博客
04-20 1003
AIGC技术是指利用人工智能算法生成各种形式的内容，包括文本、音频、视频等。这种技术的出现，不仅极大地提高了内容生产的效率，也为创作者提供了更广阔的创新空间。其中，文本生成和音频生成是AIGC技术最为重要的应用方向之一。AIGC技术的崛起，为文本和音频生成领域带来了前所未有的机遇与挑战。随着技术的不断进步和应用场景的不断拓展，我们有理由相信，未来的内容生产将更加高效、丰富和个性化。同时，我们也需要关注到AIGC技术可能带来的伦理和版权问题，确保技术的健康发展与人类社会的和谐共进。
音视频封装格式解析（1）——H264格式简析，I/P/B帧是什么？H264压缩原理
嵌入式Linux开发从业者，立志做一名优秀的博客输出者！
04-20 1117
的前提下，
java使用FFmpeg给视频加图片水印
05-23
要使用FFmpeg给视频加图片水印，需要先安装FFmpeg并设置环境变量。然后，可以使用Java调用FFmpeg的命令行工具来实现添加图片水印的功能。以下是一个示例代码： ```java public class VideoUtils { /** * 给视频添加图片水印 * @param videoPath 视频文件路径 * @param imagePath 水印图片路径 * @param outputPath 输出文件路径 * @throws Exception */ public static void addImageWatermark(String videoPath, String imagePath, String outputPath) throws Exception { // 构造FFmpeg命令 List<String> command = new ArrayList<>(); command.add("ffmpeg"); command.add("-i"); command.add(videoPath); command.add("-i"); command.add(imagePath); command.add("-filter_complex"); command.add("[0:v][1:v]overlay=10:10"); command.add("-codec:a"); command.add("copy"); command.add(outputPath); // 执行FFmpeg命令 ProcessBuilder builder = new ProcessBuilder(command); Process process = builder.start(); process.waitFor(); } } ``` 在上面的代码中，我们使用了FFmpeg的overlay过滤器来实现将水印图片叠加在视频上的功能。其中，`[0:v]`表示第一个输入文件的视频流，`[1:v]`表示第二个输入文件的视频流，`overlay=10:10`表示在视频的左上角叠加水印图片，并且水印图片的左上角坐标为(10, 10)。如果要调整水印图片的位置，可以修改`overlay`参数的值。 使用时，可以调用`VideoUtils.addImageWatermark()`方法来给视频添加水印，例如： ```java try { VideoUtils.addImageWatermark("input.mp4", "watermark.png", "output.mp4"); } catch (Exception e) { e.printStackTrace(); } ``` 其中，`input.mp4`是要添加水印的视频文件，`watermark.png`是水印图片文件，`output.mp4`是输出文件路径。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值