-
Notifications
You must be signed in to change notification settings - Fork 128
/
processors.py
210 lines (184 loc) · 8.24 KB
/
processors.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
from mediacrush.processing.processor import Processor, UnrecognisedFormatException
from mediacrush.mimeinfo import extension
from mediacrush.processing.invocation import Invocation
from mediacrush.config import _cfg
import os
copy = "cp {0} {1}.{extension}"
_extension = lambda f: f.rsplit('.', 1)[1].lower()
class VideoProcessor(Processor):
time = 1200
outputs = ['mp4', 'webm', 'ogv']
extras = ['jpg']
def sync(self):
self._execute(copy)
map_string = ''
filter_string = 'scale=trunc(in_w/2)*2:trunc(in_h/2)*2'
if self.processor_state['has_video']:
self._execute("ffmpeg -y -i {0} -vframes 1 -map 0:v:0 {1}.jpg")
map_string += ' -map 0:v:0'
if self.processor_state['has_audio']:
map_string += ' -map 0:a:0'
if 'interlaced' in self.processor_state:
print("WARNING: Detected interlacing on " + self.output)
filter_string = 'yadif,' + filter_string
self._execute("ffmpeg -y -i {0} -vcodec libx264 -acodec libfdk_aac -movflags faststart -pix_fmt yuv420p -profile:v baseline -level 3.0 -preset slower -crf 18 -vf " + filter_string + map_string + " {1}.mp4")
skip_webm = False
for s in self.processor_state['streams']:
if 'info' in s:
if 'video_codec' in s['info'] and s['info']['video_codec'] == 'vp8':
skip_webm = True
if not skip_webm:
self._execute("ffmpeg -y -i {0} -c:v libvpx -c:a libvorbis -q:a 5 -pix_fmt yuv420p -quality good -b:v 5M -crf 5 -vf " + filter_string + map_string + " {1}.webm")
# Extract extra streams if present
fonts = []
extract_fonts = False
if 'has_fonts' in self.processor_state and 'has_subtitles' in self.processor_state:
if self.processor_state['has_fonts'] or self.processor_state['has_subtitles']:
for stream in self.processor_state['streams']:
if stream['type'] == 'font':
ext = _extension(stream["info"])
if ext in ['ttf', 'otf']:
# Note that ffmpeg returns a nonzero exit code when dumping attachments because there's technically no output file
# -dump_attachment is a mechanism completely removed from the rest of the ffmpeg workflow
self._execute("ffmpeg -y -dump_attachment:" + str(stream["index"]) + ' {1}_attachment_' + str(len(fonts)) + '.' + ext + ' -i {0}', ignoreNonZero=True)
fonts.append(stream)
elif stream['type'] == 'subtitle' and 'info' in stream:
extension = None
if stream['info']['codec_name'] == 'ssa':
extension = '.ass'
extract_fonts = True
elif stream['info']['codec_name'] == 'srt':
extension = '.srt'
elif stream['info']['codec_name'] == 'vtt':
extension = '.vtt'
if extension != None:
self._execute("ffmpeg -y -i {0} -map 0:s:0 {1}" + extension)
if extension == '.srt':
# convert to vtt
vtt = convert_to_vtt(os.path.join(_cfg("storage_folder"), '%s.srt' % self.f.hash))
with open(os.path.join(_cfg("storage_folder"), '%s.vtt' % self.f.hash), 'w') as f:
f.write(vtt)
os.remove(os.path.join(_cfg("storage_folder"), '%s.srt' % self.f.hash))
if extract_fonts:
# Examine font files and construct some CSS to import them
css = ''
i = 0
for font in fonts:
ext = _extension(font['info'])
if not ext in ['ttf', 'otf']:
continue
command = Invocation('otfinfo --info {0}')
command(os.path.join(_cfg("storage_folder"), '%s_attachment_%s.%s' % (self.f.hash, i, _extension(font['info']))))
command.run()
output = command.stdout[0].split('\n')
family = None
subfamily = None
for line in output:
if line.startswith('Family:'):
family = line[7:].strip(' \t')
if line.startswith('Subfamily:'):
subfamily = line[10:].strip(' \t')
css += '@font-face{font-family: "%s";' % family
css += 'src:url("/%s_attachment_%s.%s");' % (self.f.hash, i, _extension(font['info']))
if subfamily == 'SemiBold':
css += 'font-weight: 600;'
elif subfamily == 'Bold':
css += 'font-weight: bold;'
elif subfamily == 'Italic':
css += 'font-style: italic;'
css += '}'
i += 1
css_file = open(os.path.join(_cfg("storage_folder"), '%s_fonts.css' % self.f.hash), 'w')
css_file.write(css)
css_file.close()
def async(self):
map_string = ''
if self.processor_state['has_video']:
map_string += ' -map 0:v:0'
if self.processor_state['has_audio']:
map_string += ' -map 0:a:0'
self._execute("ffmpeg -y -i {0} -q:v 5 -q:a 5 -pix_fmt yuv420p -acodec libvorbis -vcodec libtheora" + map_string + " {1}.ogv")
class AudioProcessor(Processor):
time = 600
outputs = ['mp3', 'ogg']
def sync(self):
self._execute(copy)
self._execute("ffmpeg -y -i {0} -acodec libmp3lame -q:a 2 -map 0:a:0 {1}.mp3")
def async(self):
self._execute("ffmpeg -y -i {0} -acodec libvorbis -q:a 5 -map 0:a:0 {1}.ogg")
class ImageProcessor(Processor):
time = 60
outputs = ['png']
def sync(self):
self._execute(copy)
self._execute("convert {0} {1}.png")
def async(self):
self._execute("optipng -o5 {1}.png")
# We have some special optimizations for specific filetypes
# These customized processors follow
class PNGProcessor(Processor):
time = 120
outputs = ['png']
def sync(self):
self._execute(copy)
def async(self):
self._execute("optipng -o5 {1}.png")
class JPEGProcessor(Processor):
time = 5
outputs = ['jpg']
def sync(self):
self._execute("jhead -purejpg {0}")
self._execute("cp {0} {1}.{extension}")
class SVGProcessor(Processor):
time = 5
outputs = []
def sync(self):
self._execute(copy)
def async(self):
self._execute("tidy -asxml -xml --hide-comments 1 --wrap 0 --quiet --write-back 1 {0}")
class XCFProcessor(Processor):
time = 5
outputs = ['png']
def sync(self):
self._execute(copy)
self._execute('xcf2png {0} -o {1}.png')
def async(self):
self._execute('optipng -o5 {1}.png')
class DefaultProcessor(Processor):
def sync(self):
raise UnrecognisedFormatException # It shouldn't get to this point, but if it does, invalidate the file
processor_table = {
'video': VideoProcessor,
'audio': AudioProcessor,
'image': ImageProcessor,
'image/png': PNGProcessor,
'image/jpeg': JPEGProcessor,
'image/svg+xml': SVGProcessor,
'image/x-gimp-xcf': XCFProcessor,
'default': DefaultProcessor,
}
def get_processor(processor):
return processor_table.get(processor, DefaultProcessor)
def convert_to_vtt(path):
srt = list()
vtt = 'WEBVTT\n\n'
mode = 0
with open(path) as f:
srt = f.readlines()
for line in srt:
l = line.rstrip()
if mode == 0: # waiting on cue
vtt += l + '\n'
try:
int(l.strip())
mode += 1
except: pass
elif mode == 1: # Parsing timecode
# The only difference between SRT and VTT timecodes is that VTT uses . instead of ,
vtt += l.replace(',', '.') + '\n'
mode += 1
else: # inside of cue
vtt += l + '\n'
if l == '':
mode = 0
return vtt