pandora_t_for_time/render.py

441 lines
15 KiB
Python
Raw Normal View History

2023-10-08 11:19:05 +00:00
#!/usr/bin/python3
import json
import os
import subprocess
import sys
import time
2023-10-28 09:24:51 +00:00
import shutil
from pathlib import Path
2023-10-08 11:19:05 +00:00
import ox
2023-10-09 13:10:34 +00:00
from .pi import random
from .render_kdenlive import KDEnliveProject, _CACHE
2023-10-08 11:19:05 +00:00
def random_choice(seq, items, pop=False):
n = n_ = len(items) - 1
#print('len', n)
if n == 0:
if pop:
return items.pop(n)
return items[n]
2023-10-08 11:19:05 +00:00
r = seq()
base = 10
while n > 10:
n /= 10
#print(r)
r += seq()
base += 10
r = int(n_ * r / base)
#print('result', r, items)
if pop:
return items.pop(r)
return items[r]
def chance(seq, chance):
return (seq() / 10) >= chance
def get_clip_by_seqid(clips, seqid):
selected = None
for i, clip in enumerate(clips):
if clip['seqid'] == seqid:
selected = i
break
if selected is not None:
return clips.pop(i)
return None
2023-10-08 11:19:05 +00:00
def compose(clips, target=150, base=1024, voice_over=None):
2023-10-08 11:19:05 +00:00
length = 0
scene = {
'front': {
'V1': [],
'V2': [],
},
'back': {
'V1': [],
'V2': [],
2023-11-03 21:15:20 +00:00
'A1': [],
},
'audio-center': {
'A1': [],
},
'audio-front': {
'A1': [],
'A2': [],
'A3': [],
'A4': [],
2023-10-08 11:19:05 +00:00
},
2023-11-03 21:15:20 +00:00
'audio-rear': {
2023-10-08 11:19:05 +00:00
'A1': [],
'A2': [],
'A3': [],
'A4': [],
2023-11-03 21:15:20 +00:00
},
2023-10-08 11:19:05 +00:00
}
all_clips = clips.copy()
2023-10-08 11:19:05 +00:00
seq = random(base)
2023-11-01 08:23:00 +00:00
used = []
voice_overs = []
if voice_over:
vo_keys = list(voice_over)
if chance(seq, 0.5):
voice_overs.append(voice_over[vo_keys[chance(seq, len(vo_keys))]])
elif len(vo_keys) >= 2:
vo1 = vo_keys.pop(chance(seq, len(vo_keys)))
vo2 = vo_keys.pop(chance(seq, len(vo_keys)))
voice_overs.append(voice_over[vo1])
if voice_over[vo1]["duration"] + voice_over[vo2]["duration"] < target:
2023-10-30 19:25:46 +00:00
print("adding second vo")
voice_overs.append(voice_over[vo2])
vo_min = sum([vo['duration'] for vo in voice_overs])
if vo_min > target:
target = vo_min
2023-10-28 18:26:33 +00:00
elif vo_min < target:
offset = (target - vo_min) / 2
2023-11-03 21:15:20 +00:00
scene['audio-center']['A1'].append({
'blank': True,
'duration': offset
})
scene['audio-rear']['A1'].append({
'blank': True,
'duration': offset
})
2023-10-28 18:26:33 +00:00
vo_min += offset
for vo in voice_overs:
2023-11-07 23:10:28 +00:00
voc = vo.copy()
voc['filter'] = {'volume': '3'}
scene['audio-center']['A1'].append(voc)
2023-11-03 21:15:20 +00:00
vo_low = vo.copy()
vo_low['filter'] = {'volume': '-6'}
scene['audio-rear']['A1'].append(vo_low)
clip = None
2023-10-10 15:16:59 +00:00
while target - length > 0 and clips:
# coin flip which site is visible (50% chance)
if length:
remaining = target - length
remaining = remaining * 1.05 # allow for max of 10% over time
2023-11-01 08:23:00 +00:00
clips_ = [c for c in clips if c['duration'] <= remaining]
if clips_:
clips = clips_
if clip:
if chance(seq, 0.5):
next_seqid = clip['seqid'] + 1
clip = get_clip_by_seqid(clips, next_seqid)
else:
clip = None
if not clip:
clip = random_choice(seq, clips, True)
if not clips:
2023-11-01 08:23:00 +00:00
print("not enough clips, need to reset")
clips = [c for c in all_clips if c != clip]
2023-10-10 15:16:59 +00:00
if not clips:
clips = all_clips.copy()
2023-10-28 18:26:33 +00:00
if length + clip['duration'] > target and length >= vo_min:
2023-10-08 11:19:05 +00:00
break
print('%06.3f %06.3f' % (length, clip['duration']), os.path.basename(clip['original']))
2023-10-08 11:19:05 +00:00
length += clip['duration']
2023-10-28 09:33:29 +00:00
if "foreground" not in clip and "animation" in clip:
fg = clip['animation']
transparancy = 1
2023-10-19 12:10:23 +00:00
else:
2023-10-28 09:33:29 +00:00
fg = clip['foreground']
if 'foreground2' in clip:
if 'foreground3' in clip:
n = seq()
if n <= 3: # 0,1,2,3
clip['foreground']
elif n <= 6: # 4,5,6
clip['foreground2']
else: # 7,8,9
clip['foreground3']
elif chance(seq, 0.5):
fg = clip['foreground2']
transparancy = seq() / 9
transparancy = 1
if 'foley' in clip:
foley = clip['foley']
else:
foley = fg
scene['front']['V2'].append({
2023-10-08 11:19:05 +00:00
'duration': clip['duration'],
2023-10-10 09:19:47 +00:00
'src': fg,
2023-10-08 11:19:05 +00:00
"filter": {
'transparency': transparancy,
2023-10-08 11:19:05 +00:00
}
})
transparency = seq() / 9
2023-11-07 23:04:37 +00:00
# 50% of time no transparancy of foregroudnd layer
# 50% some transparancy, 25%, 50%, 75% levels of transparancy
transparancy = 1
2023-10-08 11:19:05 +00:00
# coin flip which site is visible (50% chance)
if chance(seq, 0.5):
transparency_front = transparency
transparency_back = 0
else:
transparency_back = transparency
transparency_front = 0
transparency_original = seq() / 9
2023-10-31 08:01:04 +00:00
transparency_original = 1
2023-10-28 09:33:29 +00:00
if "background" in clip:
scene['front']['V1'].append({
2023-10-28 09:33:29 +00:00
'duration': clip['duration'],
'src': clip['background'],
"filter": {
'transparency': transparency_front
}
})
scene['back']['V2'].append({
2023-10-28 09:33:29 +00:00
'duration': clip['duration'],
'src': clip['background'],
"filter": {
'transparency': transparency_back
}
})
else:
scene['front']['V1'].append({
2023-10-28 09:33:29 +00:00
'duration': clip['duration'],
'src': clip['animation'],
"filter": {
'transparency': 0,
}
2023-10-28 09:33:29 +00:00
})
scene['back']['V2'].append({
2023-10-28 09:33:29 +00:00
'duration': clip['duration'],
'src': clip['original'],
"filter": {
'transparency': 0,
}
2023-10-28 09:33:29 +00:00
})
scene['back']['V1'].append({
2023-10-08 11:19:05 +00:00
'duration': clip['duration'],
'src': clip['original'],
"filter": {
'transparency': transparency_original,
2023-10-08 11:19:05 +00:00
}
})
# 50 % chance to blur original from 0 to 30
if chance(seq, 0.5):
blur = seq() * 3
2023-10-09 13:10:34 +00:00
if blur:
scene['back']['V1'][-1]['filter']['blur'] = blur
2023-11-03 21:15:20 +00:00
scene['back']['A1'].append({
2023-10-08 11:19:05 +00:00
'duration': clip['duration'],
'src': clip['original'],
})
2023-10-19 12:10:23 +00:00
# TBD: Foley
2023-11-03 21:15:20 +00:00
scene['audio-front']['A2'].append({
'duration': clip['duration'],
'src': foley,
})
scene['audio-rear']['A2'].append({
2023-10-08 11:19:05 +00:00
'duration': clip['duration'],
2023-10-19 12:10:23 +00:00
'src': foley,
2023-10-08 11:19:05 +00:00
})
2023-11-01 08:23:00 +00:00
used.append(clip)
2023-10-30 19:25:46 +00:00
print("scene duration %0.3f (target: %0.3f, vo_min: %0.3f)" % (length, target, vo_min))
2023-11-01 08:23:00 +00:00
return scene, used
2023-10-08 11:19:05 +00:00
2023-10-10 15:16:59 +00:00
def get_scene_duration(scene):
duration = 0
for key, value in scene.items():
for name, clips in value.items():
for clip in clips:
duration += clip['duration']
return duration
2023-10-08 11:19:05 +00:00
2023-10-09 13:10:34 +00:00
def render(root, scene, prefix=''):
2023-10-08 11:19:05 +00:00
fps = 24
files = []
2023-10-08 11:19:05 +00:00
for timeline, data in scene.items():
2023-10-10 15:16:59 +00:00
#print(timeline)
2023-10-08 11:19:05 +00:00
project = KDEnliveProject(root)
tracks = []
for track, clips in data.items():
2023-10-10 15:16:59 +00:00
#print(track)
2023-10-08 11:19:05 +00:00
for clip in clips:
project.append_clip(track, clip)
path = os.path.join(root, prefix + "%s.kdenlive" % timeline)
with open(path, 'w') as fd:
2023-10-08 11:19:05 +00:00
fd.write(project.to_xml())
files.append(path)
if timeline == "audio":
duration = project.get_duration()
for track, clips in data.items():
project = KDEnliveProject(root)
for clip in clips:
project.append_clip(track, clip)
track_duration = project.get_duration()
delta = duration - track_duration
if delta > 0:
project.append_clip(track, {'blank': True, "duration": delta/24})
path = os.path.join(root, prefix + "%s-%s.kdenlive" % (timeline, track))
with open(path, 'w') as fd:
fd.write(project.to_xml())
files.append(path)
return files
2023-10-10 15:16:59 +00:00
def get_fragments(clips, voice_over):
2023-10-10 15:16:59 +00:00
import itemlist.models
import item.models
from collections import defaultdict
2023-10-10 15:16:59 +00:00
fragments = []
2023-10-10 15:16:59 +00:00
for l in itemlist.models.List.objects.filter(status='featured').order_by('name'):
if l.name.split(' ')[0].isdigit():
fragment = {
'name': l.name,
'tags': [t['value'] for t in l.query['conditions'][1]['conditions'] if t['operator'] == '=='],
'anti-tags': [t['value'] for t in l.query['conditions'][1]['conditions'] if t['operator'] == '!='],
2023-10-10 15:16:59 +00:00
'description': l.description
}
fragment["id"] = int(fragment['name'].split(' ')[0])
2023-10-10 15:16:59 +00:00
fragment['clips'] = []
for clip in clips:
if set(clip['tags']) & set(fragment['tags']) and not set(clip['tags']) & set(fragment['anti-tags']):
2023-10-10 15:16:59 +00:00
fragment['clips'].append(clip)
fragment["voice_over"] = voice_over.get(str(fragment["id"]), {})
2023-10-10 15:16:59 +00:00
fragments.append(fragment)
fragments.sort(key=lambda f: ox.sort_string(f['name']))
return fragments
def render_all(options):
prefix = options['prefix']
duration = int(options['duration'])
base = int(options['offset'])
_cache = os.path.join(prefix, "cache.json")
if os.path.exists(_cache):
with open(_cache) as fd:
_CACHE.update(json.load(fd))
2023-10-10 15:16:59 +00:00
with open(os.path.join(prefix, "clips.json")) as fd:
clips = json.load(fd)
with open(os.path.join(prefix, "voice_over.json")) as fd:
voice_over = json.load(fd)
fragments = get_fragments(clips, voice_over)
with open(os.path.join(prefix, "fragments.json"), "w") as fd:
json.dump(fragments, fd, indent=2, ensure_ascii=False)
2023-10-10 15:16:59 +00:00
position = target_position = 0
target = fragment_target = duration / len(fragments)
base_prefix = os.path.join(prefix, 'render', str(base))
2023-11-01 08:23:00 +00:00
clips_used = []
2023-10-10 15:16:59 +00:00
for fragment in fragments:
fragment_id = int(fragment['name'].split(' ')[0])
2023-10-10 15:16:59 +00:00
name = fragment['name'].replace(' ', '_')
if fragment_id < 10:
2023-10-10 15:16:59 +00:00
name = '0' + name
if not fragment['clips']:
print("skipping empty fragment", name)
continue
fragment_prefix = os.path.join(base_prefix, name)
os.makedirs(fragment_prefix, exist_ok=True)
2023-11-01 08:23:00 +00:00
fragment_clips = fragment['clips']
unused_fragment_clips = [c for c in fragment_clips if c not in clips_used]
print('fragment clips', len(fragment_clips), 'unused', len(unused_fragment_clips))
scene, used = compose(unused_fragment_clips, target=target, base=base, voice_over=fragment['voice_over'])
clips_used += used
2023-10-10 15:16:59 +00:00
scene_duration = get_scene_duration(scene)
2023-10-29 18:51:26 +00:00
print("%s %6.3f -> %6.3f (%6.3f)" % (name, target, scene_duration, fragment_target))
2023-10-10 15:16:59 +00:00
position += scene_duration
target_position += fragment_target
if position > target_position:
target = fragment_target - (position-target_position)
2023-10-29 18:51:26 +00:00
print("adjusting target duration for next fragment: %6.3f -> %6.3f" % (fragment_target, target))
2023-10-10 15:16:59 +00:00
elif position < target_position:
target = target + 0.1 * fragment_target
timelines = render(prefix, scene, fragment_prefix[len(prefix) + 1:] + '/')
with open(os.path.join(fragment_prefix, 'scene.json'), 'w') as fd:
json.dump(scene, fd, indent=2, ensure_ascii=False)
if not options['no_video']:
for timeline in timelines:
print(timeline)
2023-10-10 15:16:59 +00:00
ext = '.mp4'
if '/audio' in timeline:
2023-10-10 15:16:59 +00:00
ext = '.wav'
cmd = [
'xvfb-run', '-a',
'melt', timeline,
2023-10-22 10:18:03 +00:00
'-quiet',
'-consumer', 'avformat:%s' % timeline.replace('.kdenlive', ext),
2023-10-10 15:16:59 +00:00
]
2023-10-22 10:18:03 +00:00
if ext == '.wav':
cmd += ['vn=1']
else:
2023-11-03 21:15:20 +00:00
if not timeline.endswith("back.kdenlive"):
cmd += ['an=1']
cmd += ['vcodec=libx264', 'x264opts=keyint=1', 'crf=15']
2023-10-10 15:16:59 +00:00
subprocess.call(cmd)
if ext == '.wav' and timeline.endswith('audio.kdenlive'):
2023-10-10 15:16:59 +00:00
cmd = [
'ffmpeg', '-y',
'-nostats', '-loglevel', 'error',
'-i',
2023-10-10 15:16:59 +00:00
timeline.replace('.kdenlive', ext),
timeline.replace('.kdenlive', '.mp4')
]
subprocess.call(cmd)
os.unlink(timeline.replace('.kdenlive', ext))
fragment_prefix = Path(fragment_prefix)
cmds = []
for src, out1, out2 in (
2023-11-03 21:15:20 +00:00
("audio-front.wav", "fl.wav", "fr.wav"),
("audio-center.wav", "fc.wav", "lfe.wav"),
("audio-rear.wav", "bl.wav", "br.wav"),
):
cmds.append([
2023-10-19 12:10:23 +00:00
"ffmpeg", "-y",
"-nostats", "-loglevel", "error",
"-i", fragment_prefix / src,
"-filter_complex",
"[0:0]pan=1|c0=c0[left]; [0:0]pan=1|c0=c1[right]",
"-map", "[left]", fragment_prefix / out1,
"-map", "[right]", fragment_prefix / out2,
])
2023-10-19 12:10:23 +00:00
cmds.append([
"ffmpeg", "-y",
"-nostats", "-loglevel", "error",
"-i", fragment_prefix / "fl.wav",
"-i", fragment_prefix / "fr.wav",
"-i", fragment_prefix / "fc.wav",
"-i", fragment_prefix / "lfe.wav",
"-i", fragment_prefix / "bl.wav",
"-i", fragment_prefix / "br.wav",
"-filter_complex", "[0:a][1:a][2:a][3:a][4:a][5:a]amerge=inputs=6[a]",
"-map", "[a]", "-c:a", "aac", fragment_prefix / "audio-5.1.mp4"
])
2023-10-28 09:24:51 +00:00
cmds.append([
"ffmpeg", "-y",
"-nostats", "-loglevel", "error",
2023-11-03 21:15:20 +00:00
"-i", fragment_prefix / "front.mp4",
2023-10-28 09:24:51 +00:00
"-i", fragment_prefix / "audio-5.1.mp4",
"-c", "copy",
2023-11-03 21:15:20 +00:00
fragment_prefix / "front-5.1.mp4",
2023-10-28 09:24:51 +00:00
])
for cmd in cmds:
2023-10-19 12:10:23 +00:00
#print(" ".join([str(x) for x in cmd]))
subprocess.call(cmd)
2023-11-03 21:15:20 +00:00
shutil.move(fragment_prefix / "front-5.1.mp4", fragment_prefix / "front.mp4")
2023-10-19 12:10:23 +00:00
for fn in (
2023-10-28 09:24:51 +00:00
"audio-5.1.mp4", "fl.wav", "fr.wav", "fc.wav", "lfe.wav", "bl.wav", "br.wav",
2023-10-19 12:10:23 +00:00
):
fn = fragment_prefix / fn
if os.path.exists(fn):
os.unlink(fn)
print("Duration - Target: %s Actual: %s" % (target_position, position))
with open(_cache, "w") as fd:
json.dump(_CACHE, fd)