# -*- coding: UTF-8 -*-

# *************************************************************************

#

# 请使用支持 UTF-8 NoBOM 并最好带有 Python 语法高亮的文本编辑器

# Windows 7 的用户请最好不要使用 记事本 打开本脚本

#

# *************************************************************************

# 调用库，请不要修改

import shutil

import traceback

from typing import Optional, Any

from fontTools import ttLib

from fontTools import subset

from chardet.universaldetector import UniversalDetector

from chardet import detect_all

import os

from os import path

import sys

import re

import winreg

import zlib

import json

import copy

from colorama import init

from datetime import datetime

# 初始化环境变量

# *************************************************************************

# 自定义变量

# 修改注意: Python的布尔类型首字母要大写 True 或 False；在名称中有单引号的，需要输入反斜杠转义如 \'

# *************************************************************************

# extlist 可输入的视频媒体文件扩展名

extlist = 'mkv;mp4;mts;mpg;flv;mpeg;m2ts;avi;webm;rm;rmvb;mov;mk3d;vob'

# *************************************************************************

# no_extcheck 关闭对extlist的扩展名检查来添加一些可能支持的格式

no_extcheck = False

# *************************************************************************

# mkvout 媒体文件输出目录(封装)

# 在最前方用"?"标记来表示这是一个子目录

# 注意: 在Python中需要在左侧引号前加 r 来保留 Windows 路径中的反斜杠，路径末尾不需要反斜杠

mkvout = ''

# *************************************************************************

# assout 字幕文件输出目录

# 在最前方用"?"标记来表示这是一个子目录

# 注意: 在Python中需要在左侧引号前加 r 来保留 Windows 路径中的反斜杠，路径末尾不需要反斜杠

assout = '?subs'

# *************************************************************************

# fontout 字体文件输出目录

# 在最前方用"?"标记来表示这是一个子目录

# 注意: 在Python中需要在左侧引号前加 r 来保留 Windows 路径中的反斜杠，路径末尾不需要反斜杠

fontout = '?Fonts'

# *************************************************************************

# fontin 自定义字体文件夹，可做额外字体源，必须是绝对路径

# 可以有多个路径，路径之间用"?"来分隔

# 注意: 在Python中需要在左侧引号前加 r 来保留 Windows 路径中的反斜杠，路径末尾不需要反斜杠

fontin = r''

# *************************************************************************

# exact_lost 在列出字幕所需字体时，是否显示缺字的具体字幕文件

# True 显示

# False 不显示

exact_lost = False

# *************************************************************************

# fontload 从视频所在文件夹及其子文件夹临时载入字体（优先于系统字体）

# True 载入

# False 不载入

fontload = True

# *************************************************************************

# o_fontload 只从视频所在文件夹及其子文件夹临时载入字体（不再读取系统字体）

# 可以提高启动速度，如果 o_fontload = True 且 fontload = False，那么 fontload 会被自动设定为 True

# True 不再载入系统字体

# False 仍然载入系统字体

o_fontload = False

# *************************************************************************

# s_fontload 是否从视频所在文件夹的子文件夹载入字体

# True 载入

# False 不载入（次一级目录中名称带有font的除外）

s_fontload = False

# *************************************************************************

# f_priority 字体优先级，主要处理同名字体的取舍方式

# 注意：在开启 fontload 时工作目录中的字体始终是最优先使用

# True 优先使用自定义目录及要求用户输入的目录中的字体

# False 优先使用系统注册表中的字体

f_priority = False

# *************************************************************************

# notfont (封装)字体嵌入

# True 不嵌入字体，不子集化字体，不替换字幕中的字体信息

# False 始终嵌入字体

notfont = False

# *************************************************************************

# sublang (封装)字幕语言

# 会按照您所输入的顺序给字幕赋予语言编码，如果字幕数多于语言数，多出部分将赋予最后一种语言编码

# IDX+SUB 的 DVDSUB 由于 IDX 文件一般有语言信息，对于DVDSUB不再添加语言编码

# 各语言之间应使用半角分号 ; 隔开，如 'chi;chi;chi;und'

# 可以在 mkvmerge -l 了解语言编码

sublang = ''

# *************************************************************************

# matchStrict 严格匹配

# True 媒体文件名必须在字幕文件名的最前方，如'test.mkv'的字幕可以是'test.ass'或是'test.sub.ass'，但不能是'sub.test.ass'

# False 只要字幕文件名中有媒体文件名就行了，不管它在哪

matchStrict = True

# *************************************************************************

# warningStop 对有可能子集化失败的字体的处理方式

# True 不子集化

# False 子集化（如果失败，会保留原始字体；如果原始字体是TTC/OTC，则会保留其中的TTF/OTF）

warningStop = False

# errorStop 子集化失败后的处理方式

# True 终止批量子集化

# False 继续运行（运行方式参考warningStop）

errorStop = True

# *************************************************************************

# rmAssIn (封装)如果输入文件是mkv，删除mkv文件中原有的字幕

rmAssIn = True

# *************************************************************************

# rmAttach (封装)如果输入文件是mkv，删除mkv文件中原有的附件

rmAttach = True

# *************************************************************************

# v_subdir 视频的子目录搜索

v_subdir = False

# *************************************************************************

# s_subdir 字幕的子目录搜索

s_subdir = False

# *************************************************************************

# copyfont (ListAssFont)拷贝字体到源文件夹

copyfont = False

# *************************************************************************

# resultw (ListAssFont)打印结果到源文件夹

resultw = False

# *************************************************************************

# 以下变量谨慎更改

# subext 可输入的字幕扩展名，按照python列表语法

subext = ['ass', 'ssa', 'srt', 'sup', 'idx']

# lcidfil

# LCID过滤器，用于选择字体名称所用语言

# 结构为：{ platformID(Decimal) : { LCID : textcoding } }

# 目前Textcoding没有实际作用，仅用于让这个词典可读性更强

# 详情可在 https://docs.microsoft.com/en-us/typography/opentype/spec/name#platform-encoding-and-language-ids 查询

lcidfil = {3: {

2052: 'gbk',

1042: 'euc-kr',

1041: 'shift-jis',

1033: 'utf-16be',

1028: 'big5',

0: 'utf-16be'

}, 2: {

0: 'ascii',

1: 'utf-8',

2: 'iso-8859-1'

}, 1: {

33: 'gbk',

23: 'euc-kr',

19: 'big5',

11: 'shift-jis',

0: 'mac-roman'

}, 0: {

0: 'utf-16be',

1: 'utf-16be',

2: 'utf-16be',

3: 'utf-16be',

4: 'utf-16be',

5: 'utf-16be'

}}

# 以下环境变量不应更改

# 编译 style行 搜索用正则表达式

style_read = re.compile('.*\nStyle:.*')

cillegal = re.compile(r'[\\/:\*"><\|]')

# 切分extlist列表

extlist = [s.strip(' ').lstrip('.').lower() for s in extlist.split(';') if len(s) > 0]

# 切分sublang列表

sublang = [s.strip(' ').lower() for s in sublang.split(';') if len(s) > 0]

# 切分fontin列表

fontin = [s.strip(' ') for s in fontin.split('?') if len(s) > 0]

fontin = [s for s in fontin if path.isdir(s)]

if o_fontload and not fontload:

fontload = True

langlist = []

extsupp = []

dupfont = {}

init()

def fontlistAdd(s: str, fn: str, fontlist: dict) -> dict:

if len(s) > 0:

si = 0

fn = fn.lstrip('@')

# print(fn, s)

if fontlist.get(fn) is None:

fontlist[fn] = s[0]

si += 1

for i in range(si, len(s)):

if not s[i] in fontlist[fn]:

fontlist[fn] = fontlist[fn] + s[i]

return fontlist

def updateAssFont(assfont: dict = {}, assfont2: dict = {}) -> Optional[dict]:

if assfont2 is None:

return None

for key in assfont2.keys():

if assfont.get(key) is not None:

assfont[key] = [

assfont[key][0] + ''.join([ks for ks in assfont2[key][0] if ks not in assfont[key][0]]),

assfont[key][1] + ''.join(

['|' + ks for ks in assfont2[key][1].split('|') if ks.lower() not in assfont[key][1].lower()]),

assfont[key][2] + ''.join(

['|' + ks for ks in assfont2[key][2].split('|') if ks.lower() not in assfont[key][2].lower()]),

list(set(assfont[key][3] + assfont2[key][3]))

]

else:

assfont[key] = assfont2[key]

del assfont2

return assfont

def assAnalyze(asspath: str, fontlist: dict = {}, onlycheck: bool = False):

"""

ASS分析部分

需要输入

asspath: ASS文件的绝对路径

font_name: 字体名称与字体绝对路径词典，用于查询 Bold、Italic 字体

可选输入

fontlist: 可以更新fontlist，用于多ASS同时输入的情况，结构见下

onlycheck: 只确认字幕中的字体，仅仅返回fontlist

将会返回

fullass: 完整的ASS文件内容，以行分割

fontlist: 字体与其所需字符 { 字体 : 字符串 }

styleline: 样式内容的起始行

font_pos: 字体在样式中的位置

fn_lines: 带有fn标签的行数与该行的完整特效标签，一项一个 [ [行数, { 标签1 : ( ASS内部字体名称, Italic, Bold )}], ... ]

"""

global style_read

# 初始化变量

eventline = 0

style_pos = 0

style_pos2 = 0

text_pos = 0

font_pos = 0

bold_pos = 0

italic_pos = 0

infoline = 0

styleline = 0

ssRecover = {}

fn_lines = []

# 编译分析用正则表达式

style = re.compile(r'^\[[Vv]4.*[Ss]tyles\]$')

event = re.compile(r'^\[[Ee]vents\]$')

sinfo = re.compile(r'^\[[Ss]cript [Ii]nfo\]$')

# 识别文本编码并读取整个SubtitleStationAlpha文件到内存

print('\033[1;33m正在分析字幕: \033[1;37m\"{0}\"\033[0m'.format(path.basename(asspath)))

ass = open(asspath, mode='rb')

# 使用 UniversalDetector 确定字幕文本编码（防止非标准 UTF-16LE 字幕）

detector = UniversalDetector()

for dt in ass:

detector.feed(dt)

if detector.done:

ass_code = detector.result['encoding']

break

detector.reset()

ass.close()

ass = open(asspath, encoding=ass_code, mode='r')

fullass = ass.readlines()

ass.close()

asslen = len(fullass)

# 在文件中搜索Styles标签、Events标签、Script Info标签来确认起始行

for s in range(0, asslen):

if re.match(sinfo, fullass[s]) is not None:

infoline = s

if re.match(style, fullass[s]) is not None:

styleline = s

elif re.match(event, fullass[s]) is not None:

eventline = s

if styleline != 0 and eventline != 0:

break

# 子集化字体信息还原

# 如果在 [Script Info] 中找到字体子集化的注释信息，则将字体名称还原并移除注释

ssRemove = []

for s in range(infoline + 1, asslen):

ss = fullass[s]

if ss.strip(' ') == '':

continue

elif ss.strip(' ')[0] == ';' and ss.lower().find('font subset') > -1 and len(ss.split(':')) > 1:

fr = ss.split(':')[1].split('-')

rawname = '-'.join(fr[1:]).strip(' ').rstrip('\n')

nowname = fr[0].strip(' ').rstrip('\n')

if not rawname == nowname: ssRecover[nowname] = rawname

ssRemove.append(s)

elif ss.strip(' ')[0] == '[' and ss.strip(' ')[-1] == ']':

break

else:

continue

if len(ssRemove) > 0:

ssRemove.reverse()

for s in ssRemove:

fullass.pop(s)

asslen -= 1

infoline -= 1

styleline -= 1

eventline -= 1

del ssRemove

# 获取Style的 Format 行，并用半角逗号分割

style_format = ''.join(fullass[styleline + 1].split(':')[1:]).strip(' ').split(',')

# 确定Style中 Name 、 Fontname 、 Bold 、 Italic 的位置

style_pos, font_pos, bold_pos, italic_pos = -1, -1, -1, -1

for i in range(0, len(style_format)):

s = style_format[i].lower().strip(' ').replace('\n', '')

if s == 'name':

style_pos = i

elif s == 'fontname':

font_pos = i

elif s == 'bold':

bold_pos = i

elif s == 'italic':

italic_pos = i

if style_pos != -1 and font_pos != -1 and bold_pos != -1 and italic_pos != -1:

break

if style_pos == font_pos == bold_pos == italic_pos == -1:

style_pos, font_pos, bold_pos, italic_pos = 0, 0, 0, 0

# 获取 字体表 与 样式字体对应表

style_font = {}

# style_font 词典内容:

# { 样式 : 字体名 }

# fontlist 词典内容:

# { 字体名?斜体?粗体 : 使用该字体的文本 }

for i in range(styleline + 2, asslen):

# 如果该行不是样式行，则跳过，直到文件末尾或出现其他标记

if len(fullass[i].split(':')) < 2:

continue

if fullass[i].split(':')[0].strip(' ').lower() != 'style':

break

styleStr = ''.join([s.strip(' ') for s in fullass[i].split(':')[1:]]).strip(' ').split(',')

font_key = styleStr[font_pos].lstrip('@')

# 如果有字体还原信息，则将样式行对应的字体还原

if len(ssRecover) > 0:

if ssRecover.get(font_key) is not None:

font_key = ssRecover[font_key]

styleStr[font_pos] = font_key

fullass[i] = fullass[i].split(':')[0] + ': ' + ','.join(styleStr)

# 获取样式行中的粗体斜体信息

isItalic = - int(styleStr[italic_pos])

isBold = - int(styleStr[bold_pos])

fontlist.setdefault('{0}?{1}?{2}'.format(font_key, isItalic, isBold), '')

style_font[styleStr[style_pos]] = '{0}?{1}?{2}'.format(font_key, isItalic, isBold)

# print(fontlist)

# 提取Event的 Format 行，并用半角逗号分割

event_format = ''.join(fullass[eventline + 1].split(':')[1:]).strip(' ').split(',')

style_pos2, text_pos = -1, -1

# 确定Event中 Style 和 Text 的位置

for i in range(0, len(event_format)):

if event_format[i].lower().replace('\n', '').strip(' ') == 'style':

style_pos2 = i

elif event_format[i].lower().replace('\n', '').strip(' ') == 'text':

text_pos = i

if style_pos2 != -1 and text_pos != -1:

break

if style_pos2 == -1 and text_pos == -1:

style_pos2, text_pos == 0, 0

# 获取 字体的字符集

# 先获取 Style，用style_font词典查找对应的 Font

# 再将字符串追加到 fontlist 中对应 Font 的值中

for i in range(eventline + 2, asslen):

eventline_sp = fullass[i].split(':')

if len(eventline_sp) < 2:

continue

# print(fullass[i])

if eventline_sp[0].strip(' ').lower() == 'comment':

continue

elif eventline_sp[0].strip(' ').lower() != 'dialogue':

break

eventline_sp = ''.join(eventline_sp[1:]).split(',')

eventftext = ','.join(eventline_sp[text_pos:])

effectDel = r'\{.*?\}|\\[nNhs]|\n'

textremain = ''

# 矢量绘图处理，如果发现有矢量表达，从字符串中删除这一部分

# 这一部分的工作未经详细验证，作用也不大

if re.search(r'\{.*?\\p[1-9]\d*.*?\}([\s\S]*?)\{.*?\\p0.*?\}', eventftext) is not None:

vecpos = re.findall(r'\{.*?\\p[1-9]\d*.*?\}[\s\S]*?\{.*?\\p0.*?\}', eventftext)

nexts = 0

for s in vecpos:

vecfind = eventftext.find(s)

textremain += eventftext[nexts:vecfind]

nexts = vecfind

s = re.sub(r'\\p\d+', '', re.sub(r'}.*?{', '}{', s))

textremain += s

elif re.search(r'\{.*?\\p[1-9]\d*.*?\}', eventftext) is not None:

eventftext = re.sub(r'\\p\d+', '',

eventftext[:re.search(r'\{.*?\\p[1-9]\d*.*?\}', eventftext).span()[0]])

if len(textremain) > 0:

eventftext = textremain

eventfont = style_font.get(eventline_sp[style_pos2].lstrip('*'))

# 粗体、斜体标签处理

splittext = []

splitpos = []

# 首先查找蕴含有启用粗体/斜体标记的特效标签

if re.search(r'\{.*?(?:\\b[7-9]00|\\b1|\\i1).*?\}', eventftext) is not None:

lastfind = 0

allfind = re.findall(r'\{.*?\}', eventftext)

# 在所有特效标签中寻找

# 启用粗体斜体

# 禁用粗体斜体

# 分成两种情况再进入下一层嵌套if

# 启用粗体/启用斜体

# 禁用粗体/禁用斜体

# 然后分别确认该特效标签的适用范围，以准确将字体子集化

for sti in range(0, len(allfind)):

st = allfind[sti]

ibclose = re.search(r'(\\b[1-4]00|\\b0|\\i0|\\b[\\\}]|\\i[\\\}])', st)

ibopen = re.search(r'(\\b[7-9]00|\\b1|\\i1)', st)

if ibopen is not None:

stfind = eventftext.find(st)

for stii in range(sti, -1, -1):

if len(splitpos) > 0:

if splitpos[-1][1] >= eventftext.find(allfind[stii]):

break

if allfind[stii].find('\\fn') > -1:

stfind = eventftext.find(allfind[stii])

break

addbold = '0'

additalic = '0'

if re.search(r'(\\b[7-9]00|\\b1)', st) is not None:

if re.search(r'(\\b[7-9]00|\\b1)', st).span()[0] > max(

[st.find('\\b0'), st.find('\\b\\'), st.find('\\b}')]):

addbold = '1'

if st.find('\\i1') > st.find('\\i0'): additalic = '1'

if len(splittext) == 0:

if stfind > 0:

splittext.append([eventftext[:stfind], '0', '0'])

splittext.append([eventftext[stfind:], additalic, addbold])

else:

if splittext[-1][1] != additalic or splittext[-1][2] != addbold:

if stfind > 0:

splittext[-1][0] = eventftext[lastfind:stfind]

splittext.append([eventftext[stfind:], additalic, addbold])

lastfind = stfind

elif ibclose is not None:

stfind = eventftext.find(st)

for stii in range(sti, -1, -1):

if len(splitpos) > 0:

if splitpos[-1][1] >= eventftext.find(allfind[stii]):

break

if allfind[stii].find('\\fn') > -1:

stfind = eventftext.find(allfind[stii])

break

if len(splittext) > 0:

ltext = splittext[-1]

readytext = [eventftext[stfind:], ltext[1], ltext[2]]

if re.search(r'(\\i0|\\i[\\\}])', st) is not None:

readytext[1] = '0'

if re.search(r'(\\b[1-4]00|\\b0|\\b[\\\}])', st) is not None:

readytext[2] = '0'

if ltext[1] != readytext[1] or ltext[2] != readytext[2]:

if stfind > 0:

splittext[-1][0] = eventftext[lastfind:stfind]

splittext.append(readytext)

lastfind = stfind

else:

splittext.append([eventftext, '0', '0'])

else:

continue

if len(splittext) == 0:

splittext.append([eventftext, '0', '0'])

# elif len(splittext) > 1:

# print(splittext)

splitpos = [[0, len(splittext[0][0]), int(splittext[0][1]), int(splittext[0][2])]]

if len(splittext) > 1:

for spi in range(1, len(splittext)):

spil = len(splittext[spi][0])

lspil = splitpos[spi - 1][1]

splitpos.append([lspil, spil + lspil, int(splittext[spi][1]), int(splittext[spi][2])])

# print(splitpos)

# print(eventftext)

# os.system('pause')

del splittext

# print(eventftext)

# 字体标签分析

eventftext2 = eventftext

# 在全部特效标签中寻找 fn 字体标签

itl = [its for its in re.findall(r'\{.*?\}', eventftext) if its.find('\\fn') > -1]

# 如果有发现 fn 字体标签，利用 while 循环确定该标签的适用范围和所包含的文本

if len(itl) > 0:

fn_line = [i]

newstrl = []

# it = Index Font

while len(itl) > 0:

if len(newstrl) == 0:

newstrl.append([eventftext, 0, ''])

itpos = eventftext.find(itl[0])

it = (itpos, itpos + len(itl[0]))

s = eventftext[(it[0] + 1):(it[1] - 1)]

cuttext = eventftext[it[0]:]

fnpos = eventftext2.find(cuttext)

itl = itl[1:]

if len(itl) > 0:

itpos = eventftext.find(itl[0])

newstrl[-1][0] = newstrl[-1][0][:itpos]

else:

newstrl[-1][0] = newstrl[-1][0][:it[0]]

newstrl.append([cuttext, fnpos, s])

eventftext = eventftext[it[0]:]

newstrl = [nst for nst in newstrl if len(nst[0].strip(' ')) > 0]

# 然后将新增的字体所对应的文本添加到fn_line中

fn = ''

for sp in splitpos:

for fi in range(0, len(newstrl)):

fs = newstrl[fi]

s = fs[2]

if int(fs[1]) in range(sp[0], sp[1]):

fss = re.sub(effectDel, '', fs[0])

li = [sf.strip(' ') for sf in s.split('\\') if len(s.strip(' ')) > 0]

li.reverse()

for sf in li:

if 'fn' in sf.lower():

fn = sf[2:].strip(' ').lstrip('@')

if len(ssRecover) > 0:

if ssRecover.get(fn) is not None:

fullassSplit = fullass[i].split(',')

fullass[i] = ','.join(fullassSplit[0:text_pos] + [

','.join(fullassSplit[text_pos:]).replace(fn, ssRecover[fn])])

s = s.replace(fn, ssRecover[fn])

fn = ssRecover[fn]

fn_line.append({s: (fn, str(sp[2]), str(sp[3]))})

break

spaceAdd = list(set(re.findall(r'[\u0020\u3000]', fs[0])))

if len(spaceAdd) > 0:

for sa in spaceAdd:

if not sa in fss:

fss = '{0}{1}'.format(fss, sa)

if len(fn) == 0:

fontlist = fontlistAdd(fss, eventfont, fontlist)

else:

fontlist = fontlistAdd(fss, '?'.join([fn, str(sp[2]), str(sp[3])]), fontlist)

# s = re.sub(effectDel, '', eventftext[:it[0]])

# print('add', s)

# print('fn', fn)

# print('ef', eventftext)

# it = re.search(r'\{\\fn.*?\}', eventftext)

# os.system('pause')

fn_lines.append(fn_line)

del fn_line

else:

if eventfont is not None:

# 去除行中非文本部分，包括特效标签{}，硬软换行符

eventtext = re.sub(effectDel, '', eventftext)

spaceAdd = list(set(re.findall(r'[\u0020\u3000]', eventftext)))

if len(spaceAdd) > 0:

for sa in spaceAdd:

if not sa in eventtext:

eventtext = '{0}{1}'.format(eventtext, sa)

fontlist = fontlistAdd(eventtext, eventfont, fontlist)

fl_popkey = []

# 在字体列表中检查是否有没有在文本中使用的字体，如果有，添加到删去列表

for s in fontlist.keys():

if len(fontlist[s]) == 0:

fl_popkey.append(s)

# print('跳过没有字符的字体\"{0}\"'.format(s))

# 删去 删去列表 中的字体

if len(fl_popkey) > 0:

for s in fl_popkey:

fontlist.pop(s)

# print(fontlist)

# 如果含有字体恢复信息，则恢复字幕

if len(ssRecover) > 0:

try:

nsdir = path.join(path.dirname(asspath), 'NoSubsetSub')

# nsfile = path.join(nsdir, '.NoSubset'.join(path.splitext(path.basename(asspath))))

nsfile = path.join(nsdir, path.basename(asspath))

if not path.exists(nsdir): os.mkdir(nsdir)

recoverass = open(nsfile, mode='w', encoding='utf-8')

recoverass.writelines(fullass)

recoverass.close()

print('\033[1;33m已恢复字幕: \033[0m\033[1m\"{0}\"\033[0m'.format(nsfile))

except:

print('\033[1;31m[ERROR] 恢复的子集化字幕写入失败\n{0}\033[0m'.format(sys.exc_info()))

# 如果 onlycheck 为 True，只返回字体列表

if onlycheck:

del fullass

style_font.clear()

return None, fontlist, None, None, None, None

return fullass, fontlist, styleline, font_pos, fn_lines, infoline

def getFileList(customPath: list = [], font_name: dict = {}, noreg: bool = False):

"""

获取字体文件列表

接受输入

customPath: 用户指定的字体文件夹

font_name: 用于更新font_name（启用从注册表读取名称的功能时有效）

noreg: 只从用户提供的customPath获取输入

将会返回

filelist: 字体文件清单 [[ 字体绝对路径, 读取位置（'': 注册表, '0': 自定义目录） ], ...]

font_name: 用于更新font_name（启用从注册表读取名称的功能时有效）

"""

filelist = []

if not noreg:

# 从注册表读取

fontkey = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, r'SOFTWARE\Microsoft\Windows NT\CurrentVersion\Fonts')

fontkey_num = winreg.QueryInfoKey(fontkey)[1]

# fkey = ''

try:

# 从用户字体注册表读取

fontkey10 = winreg.OpenKey(winreg.HKEY_CURRENT_USER, r'SOFTWARE\Microsoft\Windows NT\CurrentVersion\Fonts')

fontkey10_num = winreg.QueryInfoKey(fontkey10)[1]

if fontkey10_num > 0:

for i in range(fontkey10_num):

p = winreg.EnumValue(fontkey10, i)[1]

# n = winreg.EnumValue(fontkey10, i)[0]

if path.exists(p):

# test = n.split('&')

# if len(test) > 1:

# for i in range(0, len(test)):

# font_name[re.sub(r'\(.*?\)', '', test[i].strip(' '))] = [p, i]

# else: font_name[re.sub(r'\(.*?\)', '', n.strip(' '))] = [p, 0]

filelist.append([p, ''])

# test = path.splitext(path.basename(p))[0].split('&')

except:

pass

for i in range(fontkey_num):

# 从 系统字体注册表 读取

k = winreg.EnumValue(fontkey, i)[1]

# n = winreg.EnumValue(fontkey, i)[0]

pk = path.join(r'C:\Windows\Fonts', k)

if path.exists(pk):

# test = n.split('&')

# if len(test) > 1:

# for i in range(0, len(test)):

# font_name[re.sub(r'\(.*?\)', '', test[i].strip(' '))] = [pk, i]

# else: font_name[re.sub(r'\(.*?\)', '', n.strip(' '))] = [pk, 0]

filelist.append([pk, ''])

# 从定义的文件夹读取

# fontspath = [r'C:\Windows\Fonts', path.join(os.getenv('USERPROFILE'),r'AppData\Local\Microsoft\Windows\Fonts')]

if customPath is None: customPath == []

if len(customPath) > 0:

print('\033[1;33m请稍等，正在获取自定义文件夹中的字体\033[0m')

for s in customPath:

if not path.isdir(s): continue

for r, d, f in os.walk(s):

for p in f:

p = path.join(r, p)

if path.splitext(p)[1][1:].lower() not in ['ttf', 'ttc', 'otc', 'otf']: continue

filelist.append([path.join(s, p), 'xxx'])

# print(font_name)

# os.system('pause')

return filelist, font_name

charEx = re.compile(r'[\U00020000-\U0003134F\u3400-\u4DBF\u2070-\u2BFF\u02B0-\u02FF\uE000-\uF8FF\u0080-\u00B1\u00B4-\u00BF]')

def fnReadCheck(ttFont: ttLib.TTFont, index: int, fontpath: str):

global charEx

indexs = len(ttFont['name'].names)

name = ttFont['name'].names[index]

isWarningFont = False

try:

try:

s = name.toStr()

except:

s = fnReadCorrect(ttFont, index, fontpath)

isWarningFont = True

s2 = s

if re.search(charEx, s):

c = ''

cs = {}

for ci in range(0, indexs):

if not ttFont['name'].names[ci].isUnicode():

cs[ttFont['name'].names[ci].getEncoding().lower()] = True

for ec in cs.keys():

if ec not in ['mac_roman', 'utf_16_be']:

try:

s2 = name.toBytes().decode(ec)

c = ec

break

except:

pass

sc = 1

if cs.get('mac_roman') and len(c) == 0:

todetectc = [''.join(h) for h in re.findall(r'(\\x..\\)\\|(\\x..[\u0041-\u005B\u005D-\u007A]?)', str(name.toBytes())[2:-1]) if len(h) > 0]

todetect = []

for td in todetectc:

if len(td) > 4:

todetect.append(int(td[2:][:2], 16))

todetect.append(ord(td[4:][:1]))

elif len(td) > 2:

todetect.append(int(td[2:], 16))

todetect = todetect + todetect

da = [d for d in detect_all(bytes(todetect)) if d['encoding'] is not None]

if len(da) > 0: da = [d for d in da if d['encoding'].lower() not in ['mac_roman', 'windows-1252', 'iso-8859-1', 'ascii']]

if len(da) > 0:

try:

s2 = name.toBytes().decode(da[0]['encoding'])

c = da[0]['encoding']

sc = da[0]['confidence']

except:

pass

if not re.search(charEx, s2):

if len(c) > 0:

print('\n\033[1;33m尝试修正字体\"{0}\"文本编码 \"{1}\" >> \"{2}\"({4:.1f}%) = \"{3}\"\033[0m'

.format(path.basename(fontpath), name.getEncoding(), c.lower(), s2, sc * 100))

return s2, isWarningFont

else:

return s, isWarningFont

else:

print('\n\033[1;33m字体\"{0}\"文本编码修复失败 \"{1}\" = \"{2}\"\033[0m'.format(path.basename(fontpath), name.getEncoding(), s))

return s, isWarningFont

# for dc in detect_all(name.toBytes()):

# if dc['encoding'] is not None:

# print(dc)

# if not dc['encoding'].lower() in ['windows-1252', 'ascii', 'iso-8859-1']:

# c = dc['encoding']

# break

else: return s, isWarningFont

except Exception as e:

print(e)

return fnReadCorrect(ttFont, index, fontpath), True

def fnReadCorrect(ttfont: ttLib.ttFont, index: int, fontpath: str) -> str:

"""修正字体内部名称解码错误"""

name = ttfont['name'].names[index]

namestr = name.toBytes().decode('utf-16-be', errors='ignore')

try:

print('')

if len([i for i in name.toBytes() if i == 0]) > 0:

namebyteL = name.toBytes()

for bi in range(0, len(namebyteL), 2):

if namebyteL[bi] != 0:

print('\033[1;33m尝试修正字体\"{0}\"名称读取 >> \"{1}\"\033[0m'.format(path.basename(fontpath), namestr))

return namestr

namebyte = b''.join([bytes.fromhex('{:0>2}'.format(hex(i)[2:])) for i in name.toBytes() if i > 0])

namestr = namebyte.decode(name.getEncoding())

print('\033[1;33m已修正字体\"{0}\"名称读取 >> \"{1}\"\033[0m'.format(path.basename(fontpath), namestr))

# os.system('pause')

else:

namestr = name.toBytes().decode('utf-16-be', errors='ignore')

# 如果没有 \x00 字符，使用 utf-16-be 强行解码；如果有，尝试解码；如果解码失败，使用 utf-16-be 强行解码

except:

print('\033[1;33m尝试修正字体\"{0}\"名称读取 >> \"{1}\"\033[0m'.format(path.basename(fontpath), namestr))

return namestr

def outputSameLength(s: str) -> str:

length = 0

output = ''

for i in range(len(s) - 1, -1, -1):

si = s[i]

if 65281 <= ord(si) <= 65374 or ord(si) == 12288 or ord(si) not in range(33, 127):

length += 2

else:

length += 1

if length >= 56:

output = '..' + output

break

else:

output = si + output

return output + ''.join([' ' for _ in range(0, 60 - length)])

# font_info 列表结构

# [ font_name, font_n_lower, font_family, warning_font ]

# font_name 词典结构

# { 字体名称 : [ 字体绝对路径 , 字体索引 (仅用于TTC/OTC; 如果是TTF/OTF，默认为0) , 字体样式 ] }

# dupfont 词典结构

# { 重复字体名称 : [ 字体1绝对路径, 字体2绝对路径, ... ] }

def fontProgress(fl: list, font_info: list = [{}, {}, {}, []], overwrite: bool = False) -> list:

"""

字体处理部分

需要输入

fl: 字体文件列表

可选输入

f_n: 默认新建一个，可用于更新font_name

将会返回

font_name: 字体内部名称与绝对路径的索引词典

会对以下全局变量进行变更

dupfont: 重复字体的名称与其路径词典

font_n_lower: 字体全小写名称与其标准名称对应词典

"""

global dupfont

warning_font = font_info[3]

font_family = font_info[2]

font_n_lower = font_info[1]

f_n = font_info[0]

# print(fl)

flL = len(fl)

print('\033[1;32m正在读取字体信息...\033[0m')

for si in range(0, flL):

s = fl[si][0]

fromCustom = False

fl[si][1] = str(fl[si][1])

if len(fl[si][1]) > 0: fromCustom = True

# 如果有来自自定义文件夹标记，则将 fromCustom 设为 True

ext = path.splitext(s)[1][1:]

# 检查字体扩展名

if ext.lower() not in ['ttf', 'ttc', 'otf', 'otc']: continue

# 输出进度

print('\r' + '\033[1;32m{0}/{1} {2:.2f}%\033[0m \033[1m{3}\033[0m'.format(si + 1, flL, ((si + 1) / flL) * 100,

outputSameLength(path.dirname(s))),

end='', flush=True)

isTc = False

if ext.lower() in ['ttf', 'otf']:

# 如果是 TTF/OTF 单字体文件，则使用 TTFont 读取

try:

tc = [ttLib.TTFont(s, lazy=True)]

except:

print('\033[1;31m\n[ERROR] \"{0}\": {1}\n\033[1;34m[TRY] 正在尝试使用TTC/OTC模式读取\033[0m'

.format(s, sys.exc_info()))

# 如果 TTFont 读取失败，可能是使用了错误扩展名的 TTC/OTC 文件，换成 TTCollection 尝试读取

try:

tc = ttLib.TTCollection(s, lazy=True)

print('\033[1;34m[WARNING] 错误的字体扩展名\"{0}\" \033[0m'.format(s))

isTc = True

except:

print('\033[1;31m\n[ERROR] \"{0}\": {1}\033[0m'.format(s, sys.exc_info()))

continue

else:

try:

# 如果是 TTC/OTC 字体集合文件，则使用 TTCollection 读取

tc = ttLib.TTCollection(s, lazy=True)

isTc = True

except:

print('\033[1;31m\n[ERROR] \"{0}\": {1}\n\033[1;34m[TRY] 正在尝试使用TTF/OTF模式读取\033[0m'

.format(s, sys.exc_info()))

try:

# 如果读取失败，可能是使用了错误扩展名的 TTF/OTF 文件，用 TTFont 尝试读取

tc = [ttLib.TTFont(s, lazy=True)]

print('\033[1;34m[WARNING] 错误的字体扩展名\"{0}\" \033[0m'.format(s))

except:

print('\033[1;31m\n[ERROR] \"{0}\": {1}\033[0m'.format(s, sys.exc_info()))

continue

# f_n[path.splitext(path.basename(s))[0]] = [s, 0]

for ti in range(0, len(tc)):

t = tc[ti]

# 读取字体的 'OS/2' 表的 'fsSelection' 项查询字体的粗体斜体信息

try:

os_2 = bin(t['OS/2'].fsSelection)[2:].zfill(10)

except:

os_2 = '1'.zfill(10)

isItalic = int(os_2[-1])

isBold = int(os_2[-6])

# isCustom = int(os_2[-7])

# isRegular = int(os_2[-7])

# 读取字体的 'name' 表

fstyle = ''

familyN = ''

try:

indexs = len(t['name'].names)

except:

break

isWarningFont = False

namestrl1 = []

namestrl2 = []

donotStyle = False

for ii in range(0, indexs):

name = t['name'].names[ii]

# 若 nameID 为 1，读取 NameRecord 的字体家族名称

if name.nameID == 1:

familyN, isWarningFont = fnReadCheck(t, ii, s)

familyN = familyN.strip(' ').strip('\u0000')

font_family.setdefault(familyN, {})

# 若 nameID 为 2，读取 NameRecord 的字体样式

elif name.nameID == 2 and not donotStyle:

fstyle, isWarningFont = fnReadCheck(t, ii, s)

if not fstyle is None:

fstyle = fstyle.strip(' ').strip('\u0000')

# 若 nameID 为 4，读取 NameRecord 的字体完整名称

elif name.nameID == 4:

# 如果 fontTools 解码失败，则尝试使用 utf-16-be 直接解码

namestr, isWarningFont = fnReadCheck(t, ii, s)

if namestr is None: continue

namestr = namestr.strip(' ').strip('\u0000')

if name.langID in lcidfil[name.platformID].keys():

if namestr not in namestrl1: namestrl1.append(namestr.strip(' '))

if namestr.lower().find(familyN.lower()) > -1: donotStyle = True

else:

if namestr not in namestrl2: namestrl2.append(namestr.strip(' '))

del namestr

# print(namestrl)

if len(namestrl1) > 0:

namestrl = namestrl1

elif len(namestrl2) > 0:

namestrl = namestrl2

else:

continue

del namestrl1, namestrl2

addfmn = True

for ns in namestrl:

if ns.lower().find(familyN.lower()) > -1:

addfmn = False

if addfmn: namestrl.append(familyN.strip(' '))

# print(namestr, path.basename(s))

for namestr in namestrl:

# print(namestr)

if isWarningFont:

if namestr not in warning_font:

warning_font.append(namestr.lower())

if f_n.get(namestr) is not None and not overwrite:

# 如果发现列表中已有相同名称的字体，检测它的文件名、扩展名、父目录、样式是否相同

# 如果有一者不同且不来自自定义文件夹，添加到重复字体列表

dupp = f_n[namestr][0]

if (dupp != s and path.splitext(path.basename(dupp))[0] != path.splitext(path.basename(s))[0] and

not fromCustom and f_n[namestr][2].lower() == fstyle.lower()):

print('\n\033[1;35m[WARNING] 字体\"{0}\"与字体\"{1}\"的名称\"{2}\"重复！\033[0m'.format(

path.basename(f_n[namestr][0]), path.basename(s), namestr))

if dupfont.get(namestr) is not None:

if s not in dupfont[namestr]:

dupfont[namestr].append(s)

else:

dupfont[namestr] = [dupp, s]

else:

f_n[namestr] = [s, ti, fstyle, isTc]

font_n_lower[namestr.lower()] = namestr

# print(f_n[namestr], namestr)

if len(familyN) > 0 and namestr != namestrl[-1]:

if font_family[familyN].get((isItalic, isBold)) is not None:

if namestr not in font_family[familyN][(isItalic, isBold)]:

font_family[familyN][(isItalic, isBold)].append(namestr)

else:

font_family[familyN].setdefault((isItalic, isBold), [namestr])

tc[0].close()

keys = list(font_family.keys())

for k in keys:

if not len(font_family[k]) > 1:

font_family.pop(k)

del keys

dupfont_cache = dupfont

dupfont = {}

for k in dupfont_cache.keys():

k2 = tuple(dupfont_cache[k])

if dupfont.get(k2) is not None:

dupfont[k2].append(k)

else:

dupfont[k2] = [k]

del dupfont_cache

return [f_n, font_n_lower, font_family, warning_font]

# print(filelist)

# if path.exists(fontspath10): filelist = filelist.extend(os.listdir(fontspath10))

# for s in font_name.keys(): print('{0}: {1}'.format(s, font_name[s]))

def fnGetFromFamilyName(font_family: dict, fn: str, isitalic: int, isbold: int) -> str:

if font_family.get(fn) is not None:

if font_family[fn].get((isitalic, isbold)) is not None:

return font_family[fn][(isitalic, isbold)][0]

elif font_family[fn].get((0, isbold)) is not None:

return font_family[fn][(0, isbold)][0]

elif font_family[fn].get((isitalic, 0)) is not None:

return font_family[fn][(isitalic, 0)][0]

elif font_family[fn].get((0, 0)) is not None:

return font_family[fn][(0, 0)][0]

else:

return fn

else:

return fn

def checkAssFont(fontlist: dict, font_info: list, fn_lines: list = [], onlycheck: bool = False, checkf : str = ''):

"""

系统字体完整性检查，检查是否有ASS所需的全部字体，如果没有，则要求拖入

需要以下输入

fontlist: 字体与其所需字符（只读字体部分） { ASS内的字体名称 : 字符串 }

font_name: 字体名称与字体路径对应词典 { 字体名称 : [ 字体绝对路径, 字体索引 ] }

以下输入可选

fn_lines: fn标签所指定的字体与其包含的文本

onlycheck: 缺少字体时不要求输入

将会返回以下

assfont: { 字体绝对路径?字体索引 : [ 字符串, ASS内的字体名称, 修正名称 ]}

font_name: 同上，用于有新字体拖入时对该词典的更新

"""

# 从fontlist获取字体名称

assfont = {}

font_name = font_info[0]

font_n_lower = font_info[1]