Python处理视频文件的实用姿势

感觉这辈子，最深情绵长的注视，都给了手机。

视频是目前最热门的领域之一。各平台争先推出便捷工具，自带滤镜和玩法，普通人也能轻松制作精美视频。

也有不少团队实现了批量视频制作，拥有更高产能，运营效率也更高。

现在手机上的剪映，电脑的爱剪辑，已经足够我们应付日常视频处理需求。再专业点，也可以用PR、FinalCut、Edius等软件处理。这些软件都提供可视化的编辑，可以边剪辑边预览。

但对于那些工作流程相对固定、产能要求高的操作，更适合机器处理。当人睡觉时，机器依旧在剪辑。

甚至如果需要支持多团队的视频处理，可以考虑把剪辑工作搬到云上，随时扩大处理能力。

视频可以看成是连续的图片，如果你看过翻书做的动画就能马上理解。

当连续的图片切换足够快时（主流认为每秒24帧），我们就会感受到平滑的视觉效果。

和音频类似，视频的清晰度，主要由帧率和每帧图像的清晰度（即分辨率）决定。

但需要注意的是：对于已有视频，提高帧率和分辨率，并不能让视频更清晰，因为信息无法凭空还原。

当然，这是人工智能的研究领域之一，俗称“AI修图”，把不清晰的变得更清晰。

比如前阵子火爆B站的老北京AI修复视频：

视频文件本身是个容器，内含音频、视频、字幕等信息，独立字幕是文本文件，音视频经编码后保存。

上一章已经介绍过 ffmpeg ，它是开源软件中处理视频的最佳选择，不少Python三方模块在处理音视频时，都会调用其编码和读写文件的能力。

Python处理视频主要有3类模块：

1. opencv-python ，由于视频本质上就是连续的图像，所以图像处理模块也能处理视频中的每一帧图像。最后对视频的编码和读写会依赖 ffmpeg 完成。
   
2. ffmpeg-python ，这类模块是对 ffmpeg 的命令包装，相当于用Python调用 ffmepg 的命令。
   
3. moviepy ，提供了便捷的视频处理接口，文件编码和读写也依赖 ffmpeg 。
   

其中， moviepy 使用门槛低，足够应付最常见的需求，如截取、拼接、简单转场和特效等。

模块安装： pip install moviepy

它的基本工作原理可以概括为：

• 基于 ffmpeg 读写视频文件。
• 基于 numpy 、 scipy 、 opencv 、 PIL 处理内部图像数据。
• 两大核心类： AudioClip 、 VideoClip 分别处理音频和视频。

如果要在视频中增加图形或文字，需要提前安装 ImageMagick 软件。

ImageMagick 的安装在Mac上稍微复杂些，因为它基于 X11 框架。

分两步安装：

1. 安装 XQuartz ：即 X11 框架的MacOS版实现。
2. Homebrew 安装软件： brew install imagemagick

本文将以 moviepy 为主介绍视频处理，图像特效等部分会兼用 opencv 和 skimage 等模块。

视频处理的常见场景包括：

• 分段截取 ：剪掉前几秒或后几秒，或取中间某段
• 素材提取 ：音频提取，视频截图
• 清晰调整 ：帧率、分辨率
• 倍速播放 ：加速、减速
• 格式转换 ：视频编码选择、GIF转换
• 视频拼接 ：如添加片头、添加片尾
• 视频剪裁 ：裁剪某个区域内容
• 水印处理 ：加文字水印、加图片水印、加动画水印
• 视频特效 ：镜像、滤镜、过长切换、遮照
• 字幕处理 ：提取字幕，添加字幕
• 智能处理 ：人脸追踪、马赛克、换脸

下面分成4个部分介绍： 基本使用、拼接裁剪、效果水印、智能处理。

基本使用

视频的基本处理包括：文件读写、分段截取、音量调整、素材提取、清晰度参数、倍速播放、格式转换。

import pathlib
from moviepy.editor import VideoFileClip
path = list(pathlib.Path.cwd().parents)[1].joinpath('data/automate/008video')
mp4_path = path.joinpath('input.mp4')
vout_path = path.joinpath('008video_basic_video.mp4')
vout15_path = path.joinpath('008video_basic_video_fps15.mp4')
vout_scale_path = path.joinpath('008video_basic_video_scale.mp4')
vout_speed2x_path = path.joinpath('008video_basic_video_speed2x.mp4')
vout_speed05x_path = path.joinpath('008video_basic_video_speed05x.mp4')
vout_webm_path = path.joinpath('008video_basic_video_format.webm')
vout_gif_path = path.joinpath('008video_basic_video_gif.gif')
aout_path = path.joinpath('008video_basic_audio.mp3')
img_path = path.joinpath('008video_basic_images')
clip = VideoFileClip(str(mp4_path))
# 获取基本信息：时长、
print('基本信息：')
print(clip.duration, clip.size, clip.fps)
# 截取前50秒视频
clip = clip.subclip(0, 50)
# 提取音频素材
audio = clip.audio
audio.write_audiofile(str(aout_path))
# 视频截图
ts = [5, 10, 20, 30, 40, 50] # 单位：秒
for t in ts:
    clip.save_frame(str(img_path.joinpath(f'{t}.png')), t=t)
# 调低音量
clip.volumex(0.6)
# 保存文件，audio_codec指定音频编码，默认视频编码为libx264
clip.write_videofile(str(vout_path), audio_codec='aac')
# 清晰度参数：帧率、分辨率
clip_fps15 = clip.set_fps(15) # 调整帧率，并不会减少多少文件大小
# 如果不指定audio，就会生成一个临时音频文件
clip_fps15.write_videofile(str(vout15_path), audio_codec='aac')
# 调整分辨率，可以很明显降低文件大小
# clip_scale = clip.resize((clip.w//2, clip.h//2))
clip_scale = clip.resize(0.5) # 等比缩放0.5
clip_scale.write_videofile(str(vout_scale_path), audio_codec='aac')
# 倍速播放
clip_sp2x = clip.speedx(2)
clip_sp2x.write_videofile(str(vout_speed2x_path), audio_codec='aac')
clip_sp05x = clip.speedx(0.5)
clip_sp05x.write_videofile(str(vout_speed05x_path), audio_codec='aac')
# 格式转换，根据后缀选择编码器
clip.write_videofile(str(vout_webm_path), audio=True)
# 转GIF图
clip.subclip(0,10).set_fps(1).write_gif(str(vout_gif_path))

视频拼接和裁剪

视频拼接是指在时间维度上，把多个视频段连起来，常见如每个视频的片头片尾。

视频裁剪是指在屏幕上划出一个区域当成新的视频。

import pathlib
from moviepy.editor import VideoFileClip, TextClip
from moviepy.editor import vfx
from moviepy.editor import CompositeVideoClip, concatenate_videoclips
from moviepy.video.tools.drawing import circle
from moviepy.video.tools.credits import credits1
path = list(pathlib.Path.cwd().parents)[1].joinpath('data/automate/008video')
mp4s_path = path.joinpath('008video_concat')
vout_final_path = path.joinpath('008video_concat_final.mp4')
vout_cropped_path = path.joinpath('008video_concat_cropped.mp4')
font_path = path.joinpath('SourceHanSansCN-Bold.otf')
# 设置一个简单片头片尾
the_start = TextClip('英语"不可能"怎么说？\n"No Way"', font=font_path, 
                     color='white', fontsize=70).set_duration(2).set_pos('center')
the_end = TextClip('By 程一初', font=font_path,
                   color='white', fontsize=70).set_duration(2).set_pos('center')
clip_list = [ the_start ]
# 把所有文件夹下的视频都读取出来
mp4_list = [ f for f in mp4s_path.iterdir() if f.is_file() ]
for mp4 in mp4_list:
    clip_list.append(VideoFileClip(str(mp4)))
clip_list.append(the_end)
# 拼接，'compose'表示不管各种视频大小，以最大为基础
final = concatenate_videoclips(clip_list, method='compose')
final.write_videofile(str(vout_final_path), audio_codec='aac')
# 裁剪，取中间一块
W, H = final.size
cropped = final.crop(x_center=W//2, y_center=H//2, width=400, height=300)
cropped.write_videofile(str(vout_cropped_path), audio_codec='aac')

效果处理和水印

对视频中的每一帧图像应用滤镜，就是对视频应用滤镜。

滤镜可以是变换色彩风格，也可以是应用遮照。

所以视频水印原理与图像一致，可以加文字、图片和动画水印。

此外，在视频片段间连接时，可以增加一些淡入淡出的过场效果。

moviepy 最核心的3个方法：

1. fl_image ：处理每一帧图像，比如添加元素、应用遮照。
   
2. fl_time ：处理时间相关特效，比如动态变速。
   
3. fl ：同时处理时间和每一帧图像。
   

在使用时，优先用前两个，有时会加快渲染速度。

此外 moviepy 通过 vfx 包提供了很多内置特效功能。

效果处理

import pathlib
from PIL import Image, ImageDraw
import numpy as np
from moviepy.editor import VideoFileClip, ImageClip, TextClip
from moviepy.editor import vfx, clips_array, CompositeVideoClip
from moviepy.video.tools.drawing import circle
path = list(pathlib.Path.cwd().parents)[1].joinpath('data/automate/008video')
mp4_path = path.joinpath('input.mp4')
vout_path = path.joinpath('008video_effect.mp4')
clip = VideoFileClip(str(mp4_path)).subclip(0, 10).margin(10)
# 水平镜像，变亮，增加进场效果
clip_x = clip.fx(vfx.mirror_x).fx(vfx.colorx, 2).fx(vfx.fadein, 1.5)
# 垂直镜像，变暗
clip_y = clip.fx(vfx.mirror_y).fx(vfx.colorx, 0.5)
# 上下左右对称，增加淡入淡出过场效果
clip_yx = clip_y.fx(vfx.mirror_x).fx(vfx.fadein, 1.5).fx(vfx.fadeout, 1.5)
# 任意角度
clip_90 = clip.fx(vfx.rotate, angle=90)
# 遮照: 用Image画个圆形遮照
img = Image.new('RGB', clip.size, (0,0,0))
draw = ImageDraw.Draw(img)
r = min(clip.w, clip.h)
x, y = (clip.w-r)/2, (clip.h-r)/2
draw.ellipse((x,y,x+r,y+r), fill=(255,255,255))
mask = ImageClip(np.array(img), ismask=True)
clip_mask = CompositeVideoClip([clip.set_mask(mask)])
# 输出整个效果系列
final_clip = clips_array([[clip, clip_x],
                          [clip_y, clip_yx],
                          [clip_90, clip_mask]])
final_clip.write_videofile(str(vout_path), audio_codec='aac')

关于动态遮照，目前官方代码 moviepy.video.tools.drawing.color_gradient 有点小问题。

动态遮照的本质，是对每一帧图像应用动态生成的遮照。

由于 moviepy 内部使用 numpy.ndarray 格式存储数据，我们可以选择 opencv 、 scikit-image 来处理动态的遮照图像。

这里就以 scikit-image 来演示，模块安装： pip install scikit-image 。

scikit-image基本画图方法

先看下 scikit-image 的基本图形绘制方法：

• 线： skimage.draw.line
• 实心圆： skimage.draw.circle
• 空心圆： skimage.draw.circle_perimeter
• 多边形： skimage.draw.polygon
• 椭圆： skimage.draw.ellipse
• 空心椭圆： skimage.draw.ellipse_perimeter
• 贝塞尔曲线： skimage.draw.bezier_curve

具体参数官方都有详细解释，就不列了。

动态遮照

import pathlib
from skimage import draw
from skimage import img_as_float
import cv2
import numpy as np
from moviepy.editor import VideoFileClip, TextClip
from moviepy.editor import clips_array, CompositeVideoClip
path = list(pathlib.Path.cwd().parents)[1].joinpath('data/automate/008video')
mp4_path = path.joinpath('input.mp4')
vout_path = path.joinpath('008video_effect_dynamic.mp4')
clip = VideoFileClip(str(mp4_path)).subclip(0, 5).margin(10)
# 开场，圆形打开效果
clip_start = clip.add_mask()
# 结束，圆形关闭效果，出现“The End”
clip_end = clip.add_mask()
w, h = clip.size
r = max(h, w)/2
def make_circle_ski_start(t):
    # 注意w和h，cy和cx的顺序
    arr = np.zeros((h,w), np.uint8)
    rr, cc = draw.circle(clip.h/2, clip.w/2, radius=min(r*2, int(200*t)), shape=arr.shape)
    arr[rr, cc] = 1
    return arr
def make_circle_ski_end(t):
    arr = np.zeros((h,w), np.uint8)
    rr, cc = draw.circle(clip.h/2, clip.w/2, radius=max(0, int(r-200*t)), shape=arr.shape)
    arr[rr, cc] = 1
    return arr
def make_circle_cv2(t):
    arr = np.zeros((h,w), np.uint8)
    cv2.circle(arr, (clip.w//2, clip.h//2), max(0, int(r-200*t)), 255, -1)
    # 如果要用opencv，返回值需要转为[0, 1]范围（也是skimage采用格式）
    return img_as_float(arr)
clip_start.mask.get_frame = make_circle_ski_start
clip_end.mask.get_frame = make_circle_ski_end
# clip_end.mask.get_frame = make_circle_cv2
txt_end = TextClip('The End', font='Amiri-bold', color='white',
                   fontsize=20).set_duration(clip.duration).set_pos('center')
clip_end = CompositeVideoClip([txt_end, clip_end], size=clip.size)
final_clip = clips_array([[clip_start, clip_end],])
final_clip.write_videofile(str(vout_path), audio_codec='aac')

水印处理

视频水印的处理，可以把原视频和水印用 CompositeVideoClip 方法合并。

import pathlib
from moviepy.editor import VideoFileClip, ImageClip, TextClip
from moviepy.editor import clips_array, CompositeVideoClip
path = list(pathlib.Path.cwd().parents)[1].joinpath('data/automate/008video')
font_path = path.joinpath('SourceHanSansCN-Bold.otf')
mp4_path = path.joinpath('input.mp4')
avatar_path = path.joinpath('avatar.jpg')
gif_path = path.joinpath('wm.gif')
vout_path = path.joinpath('008video_watermark.mp4')
clip = VideoFileClip(str(mp4_path)).subclip(0, 10).margin(10)
# 文字水印
txt_clip = TextClip('By 程一初', font=font_path, fontsize=20,
                     color='white').set_duration(
                     clip.duration).margin(
                     mar=10, color=(96,96,96), opacity=0.5).set_opacity(0.5)
txt_clip = txt_clip.set_position((clip.w-txt_clip.w, clip.h-txt_clip.h))
txt_clip = CompositeVideoClip([clip, txt_clip])
# 图片水印
img_clip = ImageClip(str(avatar_path)).set_duration(
                     clip.duration).resize(0.1).margin(
                     mar=10, color=(96,96,96), opacity=0.5).set_opacity(0.5)
img_clip = img_clip.set_position((clip.w-img_clip.w, clip.h-img_clip.h))
img_clip = CompositeVideoClip([clip, img_clip])
# 动画水印
gif_clip = VideoFileClip(str(gif_path)).loop().set_duration(
                     clip.duration).margin(
                     mar=10, color=(96,96,96), opacity=0.5).set_opacity(0.5)
gif_clip = gif_clip.set_position((clip.w-gif_clip.w, clip.h-gif_clip.h))
gif_clip = CompositeVideoClip([clip, gif_clip])
# 输出整个效果系列
final_clip = clips_array([[clip, txt_clip],
                          [img_clip, gif_clip]])
final_clip.write_videofile(str(vout_path), audio_codec='aac')

关于去水印的主要4种思路参考：

1. 通过裁剪，把包含水印部分去除，最简单但会丢失部分信息。
2. 把水印部分模糊化，或另一个水印覆盖原水印，相当于涂抹。
3. 拿到水印原文件，尝试透明度反向减除，不能100%但有时可做到肉眼不可见。
4. 基于算法消除，目前大部分速度很慢，一张图都得几十秒，更不用说视频。

智能处理

视频相关的智能处理，可以分解到对字幕、图像、音频的处理。

如：生成字幕、人脸追踪、视频分类等。

字幕提取

关于字幕提取的3个思路：

1. 字幕如果是嵌入在视频文件中，就可以通过 ffmpeg 命令直接提取字幕 srt 文件。
2. 更多时候字幕和视频渲染在一起，即所谓“硬字幕”，这时就需要靠算法识别。
3. 算法识别字幕有两种方式：从音频里提取（即上一章的STT），或从图像里提取（即OCR技术）。

OCR技术中较出名的如Google的 tesseract 项目，它能识别100多种语言。之前介绍过的百度 paddlehub 也有文字识别的模型。

从效果上看， paddlehub 在图像的中文识别方面更优。

处理方式也很简单：

1. 从视频里抽取图像。
2. 调用 paddlehub 识别图片里的文字。

import pathlib
import paddlehub as hub
module = hub.Module(name='chinese_ocr_db_crnn_mobile')
path = list(pathlib.Path.cwd().parents)[1].joinpath('data/automate/008video')
img_path = path.joinpath('008video_seqimages')
img_path_list = sorted([ str(f) for f in img_path.iterdir() if f.is_file() ])
results = module.recognize_text(paths=img_path_list, visualization=True)
for result in results:
    print(result)

注意还需要安装2个模块： pip install shapely pyclipper 。

在实战中更推荐STT方式提取字幕。除了之前推荐的云平台之外，平时也可以使用如网易见外、讯飞听见等在线应用。

人脸追踪

2019年ZAO换脸曾风靡一时，它就是人脸追踪的一种应用，而且实现了追踪后替换融合的效果。

此外我们经常看到一些新闻里会对人脸动态打马赛克，其基本原理如下：

1. 找到每一帧图像中的人脸位置，记录下数据。
2. 处理每一帧图像，对人脸打马赛克。

我们通过结合 moviepy 和 paddlehub 可以很容易实现。

import pathlib
import numpy as np
import cv2
from moviepy.editor import VideoFileClip, ImageSequenceClip
import paddlehub as hub
path = list(pathlib.Path.cwd().parents)[1].joinpath('data/automate/008video')
mp4_path = path.joinpath('input.mp4')
out_path = path.joinpath('008video_paddlehub_headblur_fl.mp4')
out_path_frm = path.joinpath('008video_paddlehub_headblur_frm.mp4')
snd_path = path.joinpath('008video_snd.mp3')
clip = VideoFileClip(str(mp4_path)).subclip(0,10)
module = hub.Module(name='ultra_light_fast_generic_face_detector_1mb_640')
def mask_frame(im):
    h, w, d = im.shape
    results = module.face_detection(images=[im])
    face_data = results[0]['data']
    # 模糊每个人脸
    for d in face_data:
        x = int((d['left']+d['right'])//2)
        y = int((d['top']+d['bottom'])//2)
        r_zone = int((d['right']-d['left'])//2) # 半径
        r_blur = int(2*r_zone/3) # 模糊范围
        x1, x2 = max(0, x - r_zone), min(x + r_zone, w)
        y1, y2 = max(0, y - r_zone), min(y + r_zone, h)
        region_size = y2 - y1, x2 - x1
        mask = np.zeros(region_size).astype('uint8')
        cv2.circle(mask, (r_zone, r_zone), r_zone, 255, -1, lineType=cv2.CV_AA)
        mask = np.dstack(3 * [(1.0 / 255) * mask])
        orig = im[y1:y2, x1:x2]
        blurred = cv2.blur(orig, (r_blur, r_blur))
        im[y1:y2, x1:x2] = mask * blurred + (1 - mask) * orig
    return im
def fl_fun(im):
    # im是只读数据，需要重新创建一个可修改的ndarray