前言

    最近在看一部电影，发现没有字幕。网上找了找发现也没有，于是，萌生了一个想法：就是用Python去自动生成字幕文件

    这边大体是参考这篇文章，不过也有些许不同，主要是引擎方面的选择

一、字幕文件

    要做字幕，得先了解字幕文件的格式才行，主流的格式是：ass（SubRip Text）、ssa（S Station Alpha）、srt（Advanced SubStation Alpha）、vtt（webvtt，类似于srt），具体参考这里。这边我选择的是SRT格式，SRT的格式如下：

    除了字幕文件之外，还有就是选择语音转文字的引擎，国内的有：百度、网易见外等，国外的有：谷歌、IBM等，这里我选择的是speech_recognition，因为Python可以直接用，而且支持别的多国语言

二、思路整理

    开始做之前，先捋一下思路

1.分离视频里的语音

    由于做字幕只需要语音即可，所以需要先把视频中的语音提取出来，这部分直接用moviepy就行了，pip直接安装就可以了

pip install moviepy

代码也比较简单，如下：

from moviepy.video.io.VideoFileClip import VideoFileClip

video_path = r'G:\usr\a.mp4'
file_name = get_file_name(video_path);
audio_file = file_name + '.wav'
video = VideoFileClip(video_path)
video.audio.write_audiofile(audio_file, ffmpeg_params=['-ar', '16000', '-ac', '1'])

FFmpeg的参数说明：

• ar <采样率> 设定声音采样率，PSP只认24000
• ac <数值> 设定声道数，1就是单声道，2就是立体声

2.将语音切片

    电影分离的语音整个文件太大，而且做字幕也不能整个电影语音生成，所以需要把音频文件进行分割。分割用的是Python自带的pydub模块进行分割的（只支持原生的wav格式），安装命令，如下：

pip install pydub

分割语音主要有两种方式：一是用时间分割，二是用静默分割。这里用时间分割显然不行，不可能去看一遍电影在进行处理，所以只能用静默分割，主要代码如下：

from pydub import AudioSegment
from pydub.silence import detect_nonsilent

# 这里silence_thresh是认定小于-70dBFS以下的为silence，发现小于 sound.dBFS * 1.3 部分超过500毫秒，就进行拆分。这样子分割成一段一段的。
# 通过搜索静音的方法将音频分段
# 参考：https://wqian.net/blog/2018/1128-python-pydub-split-mp3-index.html
sound = AudioSegment.from_file(audio_file)
timestamp_list = detect_nonsilent(sound, 500, sound.dBFS * 1.3, 1)

3.调用引擎转成文字

    接下来就是将切割好的语音转成文字，用的是speech_recognition模块进行转换，这个模块有google、sphinx、bing、google_cloud进行选择，除了sphinx是本地引擎外，其他都需要联网，google可以直接进行翻译，其他两个需要注册才能用，所以这边主要用google和sphinx

     google方法的用法比较简单，只需指定文件和语言就行了，不用由于连的是Google，所以访问不了，有两种选择，一个是用VPN，另一种是修改访问的URL。使用VPN就不说了，这里主要说下第二种，直接用PyCharm点开speech_recognition模块，找到http://www.google.com/speech-api/v2/recognize?{},将其改为http://www.google.cn/speech-api/v2/recognize?{}即可。或者找到pyhon所在路径\Lib\site-packages\speech_recognition目录，底下有个__init__.py文件,打开进行同样的操作也行，这个主要参考这篇文章

改完之后，就可以使用了。代码如下：

import speech_recognition as sr

python r = sr.Recognizer() 
wav = sr.AudioFile('abc.wav')
with wav as source:
	audio = r.record(source)
	result = r.recognize_google(audio, language='ko-KR', show_all=True)

    使用 sphinx转换的话需要先安装pocketsphinx模块，安装命令如下：

 pip install pocketsphinx 

不过这样子直接安装，可能会出现以下错误：

这里是由于没有安装Swig的缘故，需要下载在配置一下环境变量即可，具体可以参考这里

安装成功之后，speech_recognition默认只有英文的，所以还需要添加一下中文库。不过遗憾的是，这里好像没有日文和韩文。下载完之后解压，需要重命名文件，如下：

 cmusphinx-zh-cn-5.2 -> zh-CN
 zh_cn.cd_cont_5000 ->  acoustic-model
 zh_cn.lm.bin -> language-model.lm.bin
 zh_cn.dic -> pronounciation-dictionary.dict

改完之后复制到pyhon所在路径\Lib\site-packages\speech_recognition\pocketsphinx-data目录下，详细可以参考这里

完成之后，代码如下：

import speech_recognition as sr

python r = sr.Recognizer() 
wav = sr.AudioFile('abc.wav')
with wav as source:
	audio = r.record(source)
	result = r.recognize_sphinx(audio, language='zh-CN', show_all=True)
    print("翻译结束:"+result.hyp().hypstr)

4.调用谷歌翻译

    使用谷歌翻译模块时候要注意，不能直接install，不然会出现如下错误（Google翻译更改了API导致）：

这里得先卸载再安装别的版本，具体参考这里，如下：

pip uninstall googletrans
pip install googletrans==4.0.0-rc1

安装好之后，用就很简单了，如下：

from googletrans import Translator

# 修改google翻译地址
translator = Translator(service_urls=[
    'translate.google.cn'
])

translator.translate('hello', dest='zh-cn').text

5.生成SRT文件

    生成SRT文件也简单，只要按srt文件要求格式化一下时间就行了

import math
from time import strftime, gmtime

def format_time(timestamp):
    if timestamp is None:
        return ''
    second = math.modf(timestamp / 1000)
    return strftime("%H:%M:%S", gmtime(second[1])) + ',' + str(int(round(second[0], 3) * 1000))

6.视频嵌入字幕

    这一步其实可有可无，现在视频播放器基本都支持读取srt字幕。这里就简单说下吧，添加字幕分为软字幕和硬字幕，使用FFmpeg命令添加如软字幕（貌似只能mkv格式），如下：

ffmpeg -i test.mp4 -i test.srt -c copy output.mkv

添加硬字幕命令，如下：

ffmpeg -i test.mkv -vf subtitles=test.srt out.mp4

这边只是简单的介绍下，具体参考这篇文章

三、代码实现

    完整代码，如下：

import math
import os
from time import strftime, gmtime

import speech_recognition as sr
from googletrans import Translator
from moviepy.video.io.VideoFileClip import VideoFileClip
from pydub import AudioSegment
from pydub.silence import detect_nonsilent

# 修改google翻译地址
translator = Translator(service_urls=[
    'translate.google.cn'
])

"""
    转换srt格式时间，毫秒转时分秒
"""


def format_time(timestamp):
    if timestamp is None:
        return ''
    second = math.modf(timestamp / 1000)
    return strftime("%H:%M:%S", gmtime(second[1])) + ',' + str(int(round(second[0], 3) * 1000))


"""
    调用google翻译
"""


def translate(text, dest='zh-cn'):
    if text is None:
        return text
    if text == '':
        return text
    return translator.translate(text, dest=dest).text


"""
    切割翻译结果，避免字幕显示过长
"""


def split_srt(text):
    new_text = ''
    # 长度大于20进行分割
    while len(text) > 20:
        new_text += text[:20] + '\n'
        text = text[20:]
    new_text += text[0:]
    return new_text


"""
    获取文件名
"""


def get_file_name(file):
    path, name = os.path.split(file)
    name, suffix = os.path.splitext(name)
    return name


"""
    生成字幕文件
"""


def generate_srt(srt_name, srt_content):
    srt_file = srt_name + r'.srt'
    with open(srt_file, "w", encoding='utf-8') as f:
        f.write(srt_content)


"""
    调用google在线翻译
"""


def recognize_google(recognizer, audioData, language):
    result = recognizer.recognize_google(audioData, language=language, show_all=True)
    if len(result) != 0:
        return handle_result(language, result['alternative'][0]['transcript'])


"""
    本地翻译
"""


def sphinx(recognizer, audioData, language):
    result = recognizer.recognize_sphinx(audioData, language=language, show_all=True)
    return handle_result(language, result.hyp().hypstr)


"""
    处理翻译结果
"""


def handle_result(language, source_result):
    if source_result is None:
        return None
    source_result = source_result.replace(" ", "")
    if 'zh' not in language:
        dest_result = translate(source_result)
        return source_result, dest_result.replace(" ", "")
    return source_result, ''


if __name__ == '__main__':
    dest = translate('hello')
    video_path = r'G:\FFOutput\test.mp4'
    video_language = r'zh-CN'
    file_name = get_file_name(video_path);
    audio_file = file_name + '.wav'
    video = VideoFileClip(video_path)
    video.audio.write_audiofile(audio_file, ffmpeg_params=['-ar', '16000', '-ac', '1'])

    # 这里silence_thresh是认定小于-70dBFS以下的为silence，发现小于 sound.dBFS * 1.3 部分超过 500毫秒，就进行拆分。这样子分割成一段一段的。
    # 通过搜索静音的方法将音频分段
    # 参考：https://wqian.net/blog/2018/1128-python-pydub-split-mp3-index.html
    sound = AudioSegment.from_file(audio_file)
    timestamp_list = detect_nonsilent(sound, 500, sound.dBFS * 1.3, 1)
    r = sr.Recognizer()
    idx = 0
    srt_text = '';
    for i in range(len(timestamp_list)):
        # sound[timestamp_list[i][0]:timestamp_list[i][1]].export(str(i)+'.wav', format="wav")
        # wav = sr.AudioFile(str(i)+'.wav')
        # with wav as source:
        #     audio = r.record(source)
        #     result = r.recognize_google(audio, language='ko-KR', show_all=True)
        wav = sound[timestamp_list[i][0]:timestamp_list[i][1]].raw_data;

        source, dest = recognize_google(r, sr.AudioData(sample_width=2, sample_rate=16000, frame_data=wav),
                                        language=video_language)
        if source is not None:
            srt_text += '{0}\n{1} --> {2}\n'.format(idx, format_time(timestamp_list[i][0]),
                                                    format_time(timestamp_list[i][1]))
            srt_text += split_srt(source)
            srt_text += '\n'
            srt_text += split_srt(dest)
            srt_text += '\n'
            idx = idx + 1
            print(str(i) + ":" + source + '->' + dest);

        d = timestamp_list[i][1] - timestamp_list[i][0]
        print("Section is :", timestamp_list[i], "duration is:", d)
    #print('dBFS: {0}, max_dBFS: {1}, duration: {2}, split: {3}'.format(round(sound.dBFS, 2), round(sound.max_dBFS, 2),
    #                                                                   sound.duration_seconds, len(timestamp_list)))

    generate_srt(file_name, srt_text)

总结

    这里实现的方式其实网上大部分都有，这里只是简单的做一下尝试和整合，以及记录一下遇到的问题(✪ω✪)