285 lines
7.5 KiB
Python
Executable File
285 lines
7.5 KiB
Python
Executable File
#!/usr/bin/python
|
|
from argparse import ArgumentParser
|
|
import json
|
|
import os
|
|
import subprocess
|
|
import sys
|
|
import time
|
|
|
|
import ox
|
|
import mlt
|
|
from PyQt5 import QtWidgets
|
|
|
|
usage = "usage: %(prog)s [options] json"
|
|
parser = ArgumentParser(usage=usage)
|
|
parser.add_argument('-p', '--prefix', dest='prefix', help='version prefix', default='.')
|
|
parser.add_argument('files', metavar='path', type=str, nargs='*', help='json source file')
|
|
opts = parser.parse_args()
|
|
|
|
if 'performance' in opts.prefix:
|
|
version = 'performance'
|
|
else:
|
|
version = 'main'
|
|
|
|
# Avoid segfault in webvfx
|
|
app = QtWidgets.QApplication(sys.argv)
|
|
|
|
#mlt.mlt_log_set_level(40) # verbose
|
|
mlt.Factory.init()
|
|
|
|
|
|
def add_color(playlist, color, duration):
|
|
red = mlt.Producer(profile, 'color:' + color)
|
|
red.set_in_and_out(0, duration)
|
|
playlist.append(red)
|
|
|
|
def add_clip(playlist, clip, in_, duration):
|
|
file_ = clip['path']
|
|
if not isinstance(file_, str):
|
|
file_ = file_.encode('utf-8')
|
|
info = ox.avinfo(file_)
|
|
tractor = mlt.Tractor(profile)
|
|
tracks = tractor.multitrack()
|
|
video = mlt.Playlist()
|
|
c = mlt.Producer(profile, file_)
|
|
c.set_in_and_out(in_, in_+duration-1)
|
|
video.append(c)
|
|
tracks.connect(video, 0)
|
|
if not info.get('audio'):
|
|
audio = mlt.Playlist()
|
|
add_silence(audio, duration)
|
|
tracks.connect(audio, 1)
|
|
else:
|
|
volume = mlt.Filter(profile, "volume")
|
|
if clip.get('tag', '') == 'gong':
|
|
volume.set("gain", '0.8')
|
|
# Vocal Cords in Action
|
|
elif clip.get('id', '').split('/')[0] in ('EBB', 'ECE', 'ECK', 'ECJ') and \
|
|
clip.get('tag', '') in ('vagina', 'voice'):
|
|
volume.set("gain", '0.4')
|
|
else:
|
|
volume.set("gain", '0.12')
|
|
tractor.plant_filter(volume)
|
|
playlist.append(tractor)
|
|
|
|
def add_audio_clip(playlist, file_, duration, in_=0):
|
|
if not isinstance(file_, str):
|
|
file_ = file_.encode('utf-8')
|
|
clip = mlt.Producer(profile, file_)
|
|
clip.set_in_and_out(in_, in_+duration-1)
|
|
playlist.append(clip)
|
|
|
|
def add_silence(playlist, length):
|
|
file_ = 'silence.wav'
|
|
add_audio_clip(playlist, file_, length)
|
|
|
|
def add_blank(playlist, length):
|
|
playlist.blank(length)
|
|
|
|
def add_text(playlist, value, length):
|
|
if not isinstance(value, str):
|
|
value = value.encode('utf-8')
|
|
text = mlt.Producer(profile, 'webvfx:text.html')
|
|
text.set('transparent', 1)
|
|
text.set('title', value)
|
|
text.set('length', length)
|
|
playlist.append(text)
|
|
|
|
def mix_audio_tracks(a, b, ratio, combine=False):
|
|
tractor = mlt.Tractor(profile)
|
|
|
|
audio = tractor.multitrack()
|
|
audio.connect(a, 0)
|
|
audio.connect(b, 1)
|
|
mix = mlt.Transition(profile, "mix")
|
|
mix.set("start", ratio)
|
|
mix.set("end", ratio)
|
|
#mix.set("always_active", 1)
|
|
if combine:
|
|
mix.set("combine", 1)
|
|
tractor.plant_transition(mix)
|
|
return tractor
|
|
|
|
|
|
def save_xml(track, filename):
|
|
consumer = mlt.Consumer(profile, 'xml', filename)
|
|
consumer.connect(track)
|
|
consumer.start()
|
|
|
|
# main
|
|
fps = 60
|
|
profile = mlt.Profile("atsc_1080p_%d" % fps)
|
|
#profile.set_explicit(1)
|
|
|
|
source = opts.files[0]
|
|
|
|
target = source.replace('.json', '.xml')
|
|
target_audio = source.replace('.json', '.audio.xml')
|
|
target_audio_wav = target_audio + '.wav'
|
|
target_vocals = source.replace('.json', '.vocals.xml')
|
|
target_music = source.replace('.json', '.music.xml')
|
|
target_drones = source.replace('.json', '.drones.xml')
|
|
target_source = source.replace('.json', '.source.xml')
|
|
gongs_wav = source.replace('.json', '.gongs.wav')
|
|
|
|
with open(source) as fd:
|
|
data = json.load(fd)
|
|
|
|
video = mlt.Playlist()
|
|
overlay = mlt.Playlist()
|
|
music = mlt.Playlist()
|
|
vocals = mlt.Playlist()
|
|
drones0 = mlt.Playlist()
|
|
drones1 = mlt.Playlist()
|
|
gongs = mlt.Playlist()
|
|
|
|
# hide Set to 1 to hide the video (make it an audio-only track),
|
|
# 2 to hide the audio (make it a video-only track),
|
|
# or 3 to hide audio and video (hidden track).
|
|
drones0.set("hide", 1)
|
|
drones1.set("hide", 1)
|
|
gongs.set("hide", 1)
|
|
vocals.set("hide", 1)
|
|
music.set("hide", 1)
|
|
|
|
|
|
for clip in data['clips']:
|
|
frames = int(clip['duration'] * fps)
|
|
if not frames:
|
|
continue
|
|
if clip.get('black'):
|
|
add_color(video, 'black', frames)
|
|
else:
|
|
#print(clip['duration'], clip['path'])
|
|
if not os.path.exists(clip['path']):
|
|
print(clip['path'], 'is missing')
|
|
sys.exit(1)
|
|
# fixme seconds to fps!
|
|
in_ = int(clip['in'] * fps)
|
|
add_clip(video, clip, in_, frames)
|
|
add_color(video, 'black', 60)
|
|
|
|
for clip in data['text']:
|
|
frames = int(clip['duration'] * fps)
|
|
if not frames:
|
|
continue
|
|
if clip.get('blank'):
|
|
add_blank(overlay, frames)
|
|
else:
|
|
add_text(overlay, clip['text'], frames)
|
|
|
|
for clip in data['music']:
|
|
frames = int(clip['duration'] * fps)
|
|
if not frames:
|
|
continue
|
|
if clip.get('blank'):
|
|
add_silence(music, frames)
|
|
else:
|
|
add_audio_clip(music, clip['path'], frames)
|
|
|
|
for clip in data['vocals']:
|
|
frames = int(clip['duration'] * fps)
|
|
if not frames:
|
|
continue
|
|
if clip.get('blank'):
|
|
add_silence(vocals, frames)
|
|
else:
|
|
add_audio_clip(vocals, clip['path'], frames)
|
|
|
|
for name, plist in (
|
|
('drones0', drones0),
|
|
('drones1', drones1),
|
|
):
|
|
for clip in data[name]:
|
|
frames = int(clip['duration'] * fps)
|
|
if clip.get('blank'):
|
|
add_silence(plist, frames)
|
|
else:
|
|
add_audio_clip(plist, clip['path'], frames)
|
|
|
|
duration = sum(clip['duration'] for clip in data['clips'])
|
|
|
|
save_xml(vocals, target_vocals)
|
|
video.set("hide", 1)
|
|
save_xml(video, target_source)
|
|
video.set("hide", 0)
|
|
|
|
# mix drones
|
|
drones = mix_audio_tracks(drones0, drones1, 0.5)
|
|
save_xml(drones, target_drones)
|
|
|
|
save_xml(music, target_music)
|
|
|
|
if version == 'performance':
|
|
# render gongs
|
|
render_gongs = not os.path.exists(gongs_wav)
|
|
#if not render_gongs:
|
|
# render_gongs = os.path.getmtime(source) > os.path.getmtime(gongs_wav)
|
|
if render_gongs:
|
|
subprocess.call([
|
|
# offset in pi, duration, number of tracks, target
|
|
'./render_gongs.py',
|
|
str(data['gongs']['offset']),
|
|
str(duration),
|
|
str(data['gongs']['tracks']),
|
|
gongs_wav
|
|
])
|
|
|
|
# load gongs
|
|
add_audio_clip(gongs, gongs_wav, int(duration * fps), int(5*fps))
|
|
|
|
# mix gongs + music
|
|
mtractor = mix_audio_tracks(gongs, music, 0.15)
|
|
|
|
else:
|
|
# mix drones + music
|
|
mtractor = mix_audio_tracks(drones, music, 0.3)
|
|
|
|
norm = mlt.Filter(profile, "volume")
|
|
# lower volume
|
|
if version == 'performance':
|
|
norm.set("gain", "-6dB")
|
|
else:
|
|
norm.set("gain", "-12dB")
|
|
mtractor.plant_filter(norm)
|
|
|
|
# background and vocals
|
|
|
|
# vocals are on extra track now
|
|
#atractor = mix_audio_tracks(vocals, mtractor, 0.4)
|
|
atractor = mtractor
|
|
|
|
save_xml(atractor, target_audio)
|
|
|
|
'''
|
|
'''
|
|
subprocess.call([
|
|
'qmelt', target_audio, '-consumer', 'avformat:' + target_audio_wav,
|
|
])
|
|
audiomix = mlt.Playlist()
|
|
add_audio_clip(audiomix, target_audio_wav, int(duration * fps))
|
|
|
|
# mix video + audio
|
|
#tractor = mix_audio_tracks(atractor, video, 0.29)
|
|
|
|
# with vocals to background 0.4 -> 0.29
|
|
# with vocals as extra track 0.725
|
|
#tractor = mix_audio_tracks(audiomix, video, 0.5)
|
|
tractor = mix_audio_tracks(audiomix, video, 0.6)
|
|
|
|
output = mlt.Tractor(profile)
|
|
output_tracks = output.multitrack()
|
|
output_tracks.connect(tractor, 0)
|
|
output_tracks.connect(overlay, 1)
|
|
|
|
norm = mlt.Filter(profile, "volume")
|
|
#norm.set("gain", "-6dB")
|
|
norm.set("gain", "6dB")
|
|
output.plant_filter(norm)
|
|
|
|
composite = mlt.Transition(profile, "composite")
|
|
#composite.set('fill', 1)
|
|
output.plant_transition(composite)
|
|
|
|
save_xml(output, target)
|