如何制作视频水印？_首页-傲世皇朝注册登录-连锁中心

傲世皇朝注册登录

傲世皇朝新闻 news

全国服务热线：0898-08980898

联系我们 contact us

地址：: 海南省海口市

邮箱：: admin@youweb.com

电话：: 0898-08980898

传真：: 1234-0000-5678

行业新闻当前位置：首页 > 傲世皇朝新闻 > 行业新闻

如何制作视频水印？添加时间：2024-04-15

因为连续两次我的视频别人盗了，但是自己加的水印都太死板而且透明度还很高

所以我就是想知道怎样制作会动的透明的比较低的水印，需要下载什么软件吗

动态的水印和静态的水印，原理大致一样，做个动态的水印，植入到视频里面就可以了，绘声绘影可以完成

视频怎么去除水印？视频中的文字如何去除？

强烈推荐！！！测试多款软件，发现一款无比实用的视频去除水印神器软件——水印云，支持全网多视频平台，操作简单，一学就会，一键轻松去除视频水印。

官网直达：shuiyinyun.com

具体操作流程可以如下：第一步：首先通过浏览器打开 “ 水印云” 的网站。下载桌面端，在首页找到【视频去水印】功能，进入视频去水印操作界面，找到水印视频将其导入。

第二步：视频文件上传完毕后添加去水印区域，然后会在视频上会出现一个水印框，然后调整水印框大小和水印框的位置，把水印框的大小和位置调整到和水印的位置相符即可，然后点开始去水印按钮，这时候就开始去水印了，去水印的时间也是根据视频大小，这个时候耐心等待下。

第三步：当去水印的的进度条到达100%后就表示视频去水印好了，大家如果想去水印后的效果，大家点击预览效果按钮就可以了。

?这个就是我给大家推荐的视频去水印软件了，可以很轻松的去除视频水印，这个软件我经常用的，感觉很灵活，今天推荐给大家哦。

抖助理官网

下来，将教程，操作特别简单，可以单视频去水印，也可以批量视频去水印

1.先看单视频去水印教程，只需两秒

第一步，粘贴视频链接到抖助理软件，点击一键批量提取

下来，看无水印视频效果

粘贴视频主页链接到抖助理软件，点击一键主页批量提取，就去水印完成了

现在越来越多的商家看到了淘宝直播的优势，也愿意花时间去研究淘宝直播玩法，但是很多商家在刚开始做直播的时候，直播间里的人数是很少的，一场直播下来观看量的数据比较惨淡，这些商家就像采用刷观看量的方式，那么如何刷淘宝直播观看量？

如何刷淘宝直播观看量

一、如何刷淘宝直播观看量

1、利用第三方的工具刷。一般市场上刷直播间观看量的工具有很多，帮助商家增加直播间人数和点赞什么的。要注意找有真实用户资源的平台，这样观看的人数是一直存在的，点的赞也是有效的，对提高直播间权重和流量有很大益处。

2、找你的亲朋好友，让他们进入你的直播间观看并分享你的直播间链接，通过多个渠道分享出去，吸引更多的人进入直播间观看直播。

二、怎么提高直播间人气

1、直播间人数。直播时的观看人数是淘宝评判的一个重要标准，观看量越多，你的直播价值和排名也就越高，因此上面刷直播间人数的方法就可以利用起来了。

2、停留时间。观众在直播间停留时间的长短是是淘宝评判此流量是否有效的根据。所以我们要让观众尽可能停留时间长一些，否则就会被平台过滤掉，如果找第三方刷，那么停留时间也是需要控制的。

3、直播间互动。淘宝直播可不只是吸引观众观看就行，还要懂得带动他们的参与性。如果观众一直默默的看，没有任何点赞或评论等互动，同样是会被平台过滤掉，所以主播要懂得怎么激起观众的互动。

淘宝直播间的数据是动态的，如果能够活跃起直播间的气氛，那么就可以吸引更多的人来到店铺的直播间里，就比如滚雪球一样，直播间的效果是越来越好。

我是 @飓哥，经常会分享Java后台硬核知识，欢迎大家关注～

from bangbanglib import Base
from bangbanglib.common import *
import matplotlib.font_manager as fm
import json
import cv2
import numpy as np
import os
import subprocess
from PIL import Image, ImageDraw, ImageFont

# -*- coding: utf-8 -*-
from bangbanglib import Base
from bangbanglib.common import *
import matplotlib.font_manager as fm
import json
import cv2
import numpy as np
import os
import subprocess
from PIL import Image, ImageDraw, ImageFont
__all__ = ['MarkMonitor']


class MarkMonitor(Base):

    def __init__(self, config):

        super().__init__(config)
        self.table_name = 'ptr_upload_video'
        self.my_request = config['my_request']
        self.oss = config['aliyun_oss']
        self.oss_config = config['oss_config']
        self.font_size = 15
        self.line_space = 8
        self.left_padding = 8

    def list_all_video_names(self, page_num):
        page_size = 10
        offset = (page_num - 1) * page_size
        select_wait_mark_video_sql = '''select id, video_name,longitude,latitude,address,create_name,create_time,create_id
                    from ptr_upload_video where is_mark='0' and create_time>date_add(now(),interval -1 day)
                    limit 1
                    '''
        select_wait_mark_video_sql = select_wait_mark_video_sql.format(
            offset=offset, page_size=page_size)
        return self.my_db.query(
            select_wait_mark_video_sql
        )

    def get_recycler_name(self, user_id):
        get_recycler_name_sql = '''
        select recycler_name from ptr_recycler where recycler_id=(select recycler_id from ptr_recycler_user u where u.user_id={user_id}) limit 1
        '''
        return self.my_db.query(get_recycler_name_sql.format(user_id=user_id))

    def get_vid_path(self, vid_name):
        '''获取视频路径'''
        return 'bang-ptr/bsp/video/origin/video/{}'.format(vid_name)

    def get_absolute_path(self, vid_name):
        return self.oss_config['domain']+self.get_vid_path(vid_name)

    def get_vid_mark_path(self, vid_name):
        '''获取水印视频路径'''
        return 'bang-ptr/bsp/video/watermark/video/{}'.format(vid_name)

    # 封装函数
    def cv2AddChineseText(self, img, text, position, textColor=(255, 255, 255), textSize=15):
        if (isinstance(img, np.ndarray)):  # 判断是否OpenCV图片类型
            img = Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
        # 创建一个可以在给定图像上绘图的对象
        draw = ImageDraw.Draw(img)
        # 字体的格式
        # fontStyle=ImageFont.truetype(
        #     "simsun.ttc", textSize, encoding="utf-8")
        font_path = os.path.join(self.app_path['__conf__'], 'fonts','simhei.ttf')
        fontStyle = ImageFont.truetype(fm.findfont(fm.FontProperties(fname=font_path)),textSize)
        # 绘制文本
        draw.text(position, text, textColor, font=fontStyle)
        # 转换回OpenCV格式
        return cv2.cvtColor(np.asarray(img), cv2.COLOR_RGB2BGR)

    def drawRect(self, img, water_content):
        width, height = self.size[0], self.size[1]
        if (isinstance(img, np.ndarray)):  # 判断是否OpenCV图片类型
            img = Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
        # 创建一个可以在给定图像上绘图的对象
        draw = ImageDraw.Draw(img, 'RGBA')
        top_margin = self.get_top_margin(height, water_content)
        # draw.rectangle((0,top_margin,width,self.get_mark_height(water_content)),fill=(0,0,0,70))
        draw.rectangle((0, top_margin-self.line_space,
                       width, height), fill=(0, 0, 0, 70))
        return cv2.cvtColor(np.asarray(img), cv2.COLOR_RGB2BGR)

    def get_top_margin(self, height, water_content):
        return height-self.get_mark_height(water_content)

    def get_mark_height(self, water_content):
        mark_height = (self.font_size+self.line_space) * \\
            (self.get_mark_field_length(water_content))
        return mark_height

    def get_mark_field_length(self, water_content):
        num = 0
        if water_content['address']:
            if len(water_content['address']) > self.font_num:
                num += 2
            else:
                num += 1
        if water_content['create_time']:
            num += 1
        if water_content['create_name']:
            if len(water_content['create_name']) > self.font_num:
                num += 2
            else:
                num += 1
        if water_content['longitude']:
            num += 1
        return num

    def get_font_num(self):
        return int((self.size[0]-self.left_padding*2)/(self.font_size+0.1))

    # ffmpeg将视频转为h.264编码格式
    def get_ffmpeg_command(self, source_dir, filename, output_name):
        return 'docker run --rm -v %s:/config linuxserver/ffmpeg -i /config/%s -c:v libx264 -b:v 2000k -preset medium /config/%s' % (source_dir, filename, output_name)

    def get_line_size(self, lineNo):
        return lineNo*(self.font_size+self.line_space)

    # 在视频中插入文字、图片
    def video_edit(self, video_path, write_path, water_content):
        # 打开视频获取视频信息
        video = cv2.VideoCapture(video_path, cv2.CAP_FFMPEG)
        fps = video.get(cv2.CAP_PROP_FPS)
        self.size = (int(video.get(cv2.CAP_PROP_FRAME_WIDTH)),
                     int(video.get(cv2.CAP_PROP_FRAME_HEIGHT)))
        # 每行字数
        self.font_num = self.get_font_num()
        # 新建视频
        videoWriter = cv2.VideoWriter(
            write_path, cv2.VideoWriter_fourcc(*'mp4v'), fps, self.size, True)
        # 读取视频
        success, frame = video.read()
        index = 1
        top_margin = self.get_top_margin(self.size[1], water_content)
        while success:
            frame = self.drawRect(frame, water_content)
            # 为视频添加字幕信息
            lineNo = 0
            # frame=self.cv2AddChineseText(frame, '视频中打印中文', (100, 100), (255, 0, 0), 30)
            if water_content['address']:
                position = (self.left_padding, top_margin +
                            self.get_line_size(lineNo))
                address = str(water_content['address'])
                if len(address) > self.font_num:
                    frame = self.cv2AddChineseText(
                        frame, '地址: '+address[0:self.font_num-3], position, (255, 255, 255), self.font_size)
                    lineNo += 1
                    position = (self.left_padding, top_margin +
                                self.get_line_size(lineNo))
                    frame = self.cv2AddChineseText(
                        frame, ''+address[self.font_num-3:min(self.font_num * 2 - 3, len(address))], position, (255, 255, 255), self.font_size)
                else:
                    frame = self.cv2AddChineseText(
                        frame, '地址: '+address, position, (255, 255, 255), self.font_size)
                lineNo += 1
            if water_content['create_time']:
                position = (self.left_padding, top_margin +
                            self.get_line_size(lineNo))
                frame = self.cv2AddChineseText(
                    frame, '时间: ' + str(water_content['create_time']), position, (255, 255, 255), self.font_size)
                lineNo += 1
            if water_content['create_name']:
                position = (self.left_padding, top_margin +
                            self.get_line_size(lineNo))
                create_name = str(water_content['create_name'])
                if len(create_name) > self.font_num:
                    frame = self.cv2AddChineseText(
                        frame, '回收员: '+create_name[0:self.font_num-3], position, (255, 255, 255), self.font_size)
                    lineNo += 1
                    position = (self.left_padding, top_margin +
                                self.get_line_size(lineNo))
                    frame = self.cv2AddChineseText(
                        frame, ''+create_name[self.font_num-3:min(self.font_num * 2 - 3, len(create_name))], position, (255, 255, 255), self.font_size)
                else:
                    frame = self.cv2AddChineseText(
                        frame, '回收员: '+create_name, position, (255, 255, 255), self.font_size)
                lineNo += 1
            if water_content['longitude']:
                position = (self.left_padding, top_margin +
                            self.get_line_size(lineNo))
                frame = self.cv2AddChineseText(frame, '经纬度: ' + str(round(water_content['longitude'], 5)) + ","
                                               + str(round(water_content['latitude'], 5)), position, (255, 255, 255), self.font_size)
                lineNo += 1
            cv2.waitKey(int(1000 / int(fps)))
            # 添加图片在此增加frame
            videoWriter.write(frame)
            success, frame = video.read()
            index += 1

        video.release()
    # 更新是否打水印字段
    def update_mark(self,id,is_mark):
        self.my_db.update(
                        table_name=self.table_name,
                        update_data_dict={
                            'is_mark': is_mark
                        },
                        where={
                            'id': id
                        },
                        auto_commit=True,
                    )
    def main(self):
        self.my_logger.logger.info("视频添加水印开始")
        video_dir = os.path.join(self.app_path['__data__'], 'video')
        mark_video_dir = os.path.join(video_dir, 'mark')
        if not os.path.exists(video_dir):
            os.mkdir(video_dir)
        if not os.path.exists(mark_video_dir):
            os.mkdir(mark_video_dir)

        page_num = 1
        while True:
            res = self.list_all_video_names(page_num)
            if not res:
                break

            for row in res:
                self.my_logger.logger.info(row)
                video_name = row['video_name']
                address = row['address']
                create_name = row['create_name']
                create_time = row['create_time']
                create_id = row['create_id']
                longitude = row['longitude'] if address else None
                latitude = row['latitude'] if address else None
                id = row['id']
                if create_id and create_name:
                    recycler_name = self.get_recycler_name(create_id)
                    if recycler_name:
                        create_name = create_name+',' + \\
                            recycler_name[0]['recycler_name']
                # 源视频地址
                local_save_path = os.path.join(video_dir, video_name)
                # 下载图片到本地
                url = self.get_absolute_path(video_name)
                img = self.my_request.get(url)
                if img:
                    with open(local_save_path, 'wb') as f:
                        f.write(img)
                else:
                    self.my_logger.logger.error('下载图片失败,video_name'+video_name)
                    continue
                local_mark_save_path = os.path.join(mark_video_dir, video_name)
                # 添加水印
                water_content = {'address': address, 'create_time': create_time,
                                 'longitude': longitude, 'latitude': latitude, 'create_name': create_name}
                self.my_logger.logger.info('video_edit begin,video_name='+video_name)
                self.video_edit(local_save_path,
                                local_mark_save_path, water_content)
                self.my_logger.logger.info('video_edit end,video_name='+video_name)
                # 转换为h264格式
                filename, extname = video_name.split(
                    '.')[0], video_name.split('.')[1]
                output_name = filename+'_h264.'+extname
                command = self.get_ffmpeg_command(
                    mark_video_dir, video_name, output_name)
                cmd_result = subprocess.getstatusoutput(command)
                # 删除转换前的水印图,原图
                if os.path.exists(local_mark_save_path):
                    os.remove(local_mark_save_path)
                    os.remove(local_save_path)
                    self.my_logger.logger.info('删除转换前的水印图和原图,video_name='+video_name)
                else:
                    self.my_logger.logger.info('水印处理失败,video_name='+video_name)
                    continue
                local_mark_save_path = os.path.join(
                    mark_video_dir, output_name)
                if os.path.exists(local_mark_save_path):
                    self.oss.put(local_mark_save_path,
                                 self.get_vid_mark_path(video_name))
                    self.update_mark(id,1)
                    # 删除转换后的水印图
                    os.remove(local_mark_save_path)
                    self.my_logger.logger.info('删除转换后的水印图,video_name='+video_name)
                else:
                    self.my_logger.logger.error('视频转码失败,vide_name='+video_name)
            page_num += 1

        self.my_logger.logger.info('视频添加水印结束')


if __name__ == '__main__':
    pass

这里因为格式问题需要转换264视频

采用的是docker命令

# ffmpeg将视频转为h.264编码格式
    def get_ffmpeg_command(self, source_dir, filename, output_name):
        return 'docker run --rm -v %s:/config linuxserver/ffmpeg -i /config/%s -c:v libx264 -b:v 2000k -preset medium /config/%s' % (source_dir, filename, output_name)

Basic Transcode（dockerhub 官方命令）

docker run --rm -it \\
  -v $(pwd):/config \\
  linuxserver/ffmpeg \\
  -i /config/input.mkv \\
  -c:v libx264 \\
  -b:v 4M \\
  -vf scale=1280:720 \\
  -c:a copy \\
  /config/output.mkvdocker run --rm -it \\
  -v $(pwd):/config \\
  linuxserver/ffmpeg \\
  -i /config/input.mkv \\
  -c:v libx264 \\
  -b:v 4M \\
  -vf scale=1280:720 \\
  -c:a copy \\
  /config/output.mkv

CV2指的是OpenCV2（Open Source Computer Vision Library），是一个开源的库平台计算机视觉库。有很强大的图片处理功能，可实现图像处理和计算机视觉方面的很多通用算法。

OpenCV官网文档 OpenCV-Python Tutorials

中文文档http://www.woshicver.com/