422 lines
14 KiB
Python
422 lines
14 KiB
Python
import os
|
|
import sys
|
|
import json
|
|
import uuid
|
|
import subprocess
|
|
from datetime import datetime
|
|
from collections import defaultdict
|
|
|
|
# --- CONFIGURATION ---
|
|
CROSSFADE_SEC = 1.5
|
|
FADE_IN_SEC = 1.5
|
|
FADE_OUT_SEC = 1.5
|
|
MIN_CLIP_DURATION = 5.0 # Skip clips under 5 seconds
|
|
|
|
TITLE_START_SEC = 5.0
|
|
TITLE_HOLD_SEC = 5.0
|
|
TITLE_FADE_SEC = 1.5
|
|
|
|
|
|
def get_video_info(file_path):
|
|
"""Extracts duration, resolution, frame rate, stream metadata, and creation date using ffprobe."""
|
|
cmd = [
|
|
"ffprobe", "-v", "quiet",
|
|
"-print_format", "json",
|
|
"-show_format", "-show_streams",
|
|
file_path
|
|
]
|
|
try:
|
|
result = subprocess.run(cmd, capture_output=True, text=True, check=True)
|
|
data = json.loads(result.stdout)
|
|
|
|
duration = float(data['format']['duration'])
|
|
|
|
creation_str = data['format'].get('tags', {}).get('creation_time')
|
|
if creation_str:
|
|
dt = datetime.fromisoformat(creation_str.replace('Z', '+00:00'))
|
|
else:
|
|
dt = datetime.fromtimestamp(os.path.getmtime(file_path))
|
|
|
|
streams = data.get('streams', [])
|
|
v_stream = next((s for s in streams if s.get('codec_type') == 'video'), {})
|
|
a_stream = next((s for s in streams if s.get('codec_type') == 'audio'), {})
|
|
|
|
width = int(v_stream.get('width', 1920))
|
|
height = int(v_stream.get('height', 1080))
|
|
|
|
fps_str = v_stream.get('r_frame_rate', '30/1')
|
|
num, den = map(int, fps_str.split('/'))
|
|
fps_val = num / den if den != 0 else 30.0
|
|
|
|
return {
|
|
"duration": duration,
|
|
"dt": dt,
|
|
"width": width,
|
|
"height": height,
|
|
"fps_val": fps_val,
|
|
"vcodec": v_stream.get('codec_name', 'h264'),
|
|
"acodec": a_stream.get('codec_name', 'aac'),
|
|
"video_stream_index": v_stream.get('index', 0),
|
|
"audio_stream_index": a_stream.get('index', 1)
|
|
}
|
|
except Exception as e:
|
|
print(f"Error reading {file_path}: {e}")
|
|
return None
|
|
|
|
|
|
def normalize_fps(fps_val):
|
|
"""Normalizes Variable Frame Rates (VFR) to standard project rates."""
|
|
if fps_val > 45.0:
|
|
return {"num": 60, "den": 1, "val": 60.0}
|
|
elif fps_val > 27.0:
|
|
return {"num": 30, "den": 1, "val": 30.0}
|
|
elif fps_val > 22.0:
|
|
return {"num": 24, "den": 1, "val": 24.0}
|
|
else:
|
|
return {"num": int(round(fps_val)), "den": 1, "val": float(round(fps_val))}
|
|
|
|
|
|
def generate_title_svg(output_path, event_name, date_str):
|
|
"""Generates an SVG lower-third title card using hex escapes for clean copying."""
|
|
svg_content = f"""\x3csvg xmlns="http://www.w3.org/2000/svg" width="1920" height="1080" viewBox="0 0 1920 1080"\x3e
|
|
\x3cstyle\x3e
|
|
.title {{ font-family: 'Arial', sans-serif; font-size: 52px; fill: white; font-weight: bold; text-anchor: middle; }}
|
|
.subtitle {{ font-family: 'Arial', sans-serif; font-size: 34px; fill: #E0E0E0; text-anchor: middle; }}
|
|
\x3c/style\x3e
|
|
\x3cfilter id="shadow"\x3e
|
|
\x3cfeDropShadow dx="2" dy="2" stdDeviation="3" flood-color="black" flood-opacity="0.8"/\x3e
|
|
\x3c/filter\x3e
|
|
\x3cg filter="url(#shadow)"\x3e
|
|
\x3ctext x="960" y="920" class="title"\x3e{event_name}\x3c/text\x3e
|
|
\x3ctext x="960" y="970" class="subtitle"\x3e{date_str}\x3c/text\x3e
|
|
\x3c/g\x3e
|
|
\x3c/svg\x3e"""
|
|
|
|
with open(output_path, "w", encoding="utf-8") as f:
|
|
f.write(svg_content)
|
|
|
|
|
|
def make_keyframe(val):
|
|
"""Generates OpenShot's standard keyframe curve structure with required handle_type."""
|
|
return {
|
|
"Points": [
|
|
{
|
|
"co": {"X": 1.0, "Y": float(val)},
|
|
"interpolation": 0,
|
|
"handle_type": 0,
|
|
"handle_left": {"X": 0.5, "Y": 0.5},
|
|
"handle_right": {"X": 0.5, "Y": 0.5}
|
|
}
|
|
]
|
|
}
|
|
|
|
|
|
def make_keyframe_points(points_sec, fps):
|
|
"""Converts (seconds, alpha) tuples into valid OpenShot JSON keyframes."""
|
|
pts = []
|
|
for t, alpha in points_sec:
|
|
frame = max(1, int(round(t * fps)) + 1)
|
|
pts.append({
|
|
"co": {"X": float(frame), "Y": float(alpha)},
|
|
"interpolation": 0,
|
|
"handle_type": 0,
|
|
"handle_left": {"X": 0.5, "Y": 0.5},
|
|
"handle_right": {"X": 0.5, "Y": 0.5}
|
|
})
|
|
return {"Points": pts}
|
|
|
|
|
|
def create_openshot_clip(file_id, file_reader, position, start, end, layer=1, title=""):
|
|
"""Creates a fully compliant OpenShot clip object matching native 3.x schema."""
|
|
clip_duration = float(end - start)
|
|
|
|
return {
|
|
"id": str(uuid.uuid4()),
|
|
"file_id": file_id,
|
|
"title": title,
|
|
"position": position,
|
|
"start": start,
|
|
"end": end,
|
|
"duration": clip_duration,
|
|
"layer": layer,
|
|
"reader": file_reader,
|
|
|
|
# --- Hierarchy & Orientation Attributes ---
|
|
"parentObjectId": "",
|
|
"reader_orientation_mode": "reader",
|
|
|
|
# --- Mandatory Keyframe Property Dictionaries ---
|
|
"location_x": make_keyframe(0.0),
|
|
"location_y": make_keyframe(0.0),
|
|
"scale_x": make_keyframe(1.0),
|
|
"scale_y": make_keyframe(1.0),
|
|
"scale": 1, # Best Fit
|
|
"rotation": make_keyframe(0.0),
|
|
"shear_x": make_keyframe(0.0),
|
|
"shear_y": make_keyframe(0.0),
|
|
"origin_x": make_keyframe(0.5),
|
|
"origin_y": make_keyframe(0.5),
|
|
"corner_radius": make_keyframe(0.0),
|
|
"margin": make_keyframe(0.0),
|
|
"alpha": make_keyframe(1.0),
|
|
"volume": make_keyframe(1.0),
|
|
"time": make_keyframe(1.0),
|
|
|
|
# --- Perspective Keyframes ---
|
|
"perspective_c1_x": make_keyframe(-0.5),
|
|
"perspective_c1_y": make_keyframe(-0.5),
|
|
"perspective_c2_x": make_keyframe(0.5),
|
|
"perspective_c2_y": make_keyframe(-0.5),
|
|
"perspective_c3_x": make_keyframe(-0.5),
|
|
"perspective_c3_y": make_keyframe(0.5),
|
|
"perspective_c4_x": make_keyframe(0.5),
|
|
"perspective_c4_y": make_keyframe(0.5),
|
|
|
|
# --- Audio, Channel & Display Defaults ---
|
|
"channel_filter": make_keyframe(-1.0),
|
|
"channel_mapping": make_keyframe(-1.0),
|
|
"has_audio": make_keyframe(-1.0), # -1.0 default sentinel for enabled stream
|
|
"has_video": make_keyframe(-1.0), # -1.0 default sentinel for enabled stream
|
|
"waveform": False,
|
|
"waveform_mode": 1,
|
|
"wave_color": {
|
|
"red": make_keyframe(0.0),
|
|
"green": make_keyframe(123.0),
|
|
"blue": make_keyframe(255.0),
|
|
"alpha": make_keyframe(255.0)
|
|
},
|
|
"anchor": 0,
|
|
"gravity": 4, # Center alignment
|
|
"composite": 0,
|
|
"mixing": 0,
|
|
"display": 0
|
|
}
|
|
|
|
|
|
def create_osp_project(date_str, event_name, video_clips, output_dir):
|
|
"""Assembles OpenShot project JSON with standard schema and normalized FPS."""
|
|
os.makedirs(output_dir, exist_ok=True)
|
|
|
|
max_raw_fps = max(c["fps_val"] for c in video_clips)
|
|
fps_info = normalize_fps(max_raw_fps)
|
|
master_fps = fps_info["val"]
|
|
|
|
max_width = max(c["width"] for c in video_clips)
|
|
max_height = max(c["height"] for c in video_clips)
|
|
|
|
# Generate Title SVG
|
|
title_svg_path = os.path.abspath(os.path.join(output_dir, f"title_{date_str}.svg"))
|
|
formatted_date = datetime.strptime(date_str, "%Y-%m-%d").strftime("%B %d, %Y")
|
|
generate_title_svg(title_svg_path, event_name, formatted_date)
|
|
|
|
osp_files = []
|
|
osp_clips = []
|
|
|
|
# 1. Title File & Reader Setup
|
|
title_file_id = str(uuid.uuid4())
|
|
title_dur = TITLE_FADE_SEC + TITLE_HOLD_SEC + TITLE_FADE_SEC
|
|
title_video_length = int(round(title_dur * master_fps))
|
|
|
|
title_reader = {
|
|
"id": title_file_id,
|
|
"path": title_svg_path,
|
|
"type": "QtImageReader",
|
|
"duration": title_dur,
|
|
"video_length": title_video_length,
|
|
"width": 1920,
|
|
"height": 1080,
|
|
"has_audio": False,
|
|
"has_video": True,
|
|
"fps": {"num": fps_info["num"], "den": fps_info["den"]}
|
|
}
|
|
|
|
osp_files.append({
|
|
"id": title_file_id,
|
|
"path": title_svg_path,
|
|
"media_type": "image",
|
|
"duration": title_dur,
|
|
"video_length": title_video_length,
|
|
"width": 1920,
|
|
"height": 1080,
|
|
"fps": {"num": fps_info["num"], "den": fps_info["den"]},
|
|
"has_audio": False,
|
|
"has_video": True
|
|
})
|
|
|
|
# Title Clip Creation
|
|
title_clip = create_openshot_clip(
|
|
file_id=title_file_id,
|
|
file_reader=title_reader,
|
|
position=TITLE_START_SEC,
|
|
start=0.0,
|
|
end=title_dur,
|
|
layer=4,
|
|
title=f"title_{date_str}.svg"
|
|
)
|
|
title_clip["alpha"] = make_keyframe_points([
|
|
(0.0, 0.0),
|
|
(TITLE_FADE_SEC, 1.0),
|
|
(TITLE_FADE_SEC + TITLE_HOLD_SEC, 1.0),
|
|
(title_dur, 0.0)
|
|
], master_fps)
|
|
osp_clips.append(title_clip)
|
|
|
|
# 2. Video Files & Clips Creation
|
|
current_pos = 0.0
|
|
num_clips = len(video_clips)
|
|
|
|
for idx, c in enumerate(video_clips):
|
|
file_id = str(uuid.uuid4())
|
|
dur = c["duration"]
|
|
file_path = os.path.abspath(c["path"])
|
|
video_length = int(round(dur * master_fps))
|
|
file_size = os.path.getsize(file_path) if os.path.exists(file_path) else 0
|
|
|
|
# Reader Object attached to the Clip
|
|
video_reader = {
|
|
"id": file_id,
|
|
"path": file_path,
|
|
"type": "FFmpegReader",
|
|
"duration": dur,
|
|
"video_length": video_length,
|
|
"width": c["width"],
|
|
"height": c["height"],
|
|
"video_stream_index": c.get("video_stream_index", 0),
|
|
"audio_stream_index": c.get("audio_stream_index", 1),
|
|
"vcodec": c.get("vcodec", "h264"),
|
|
"acodec": c.get("acodec", "aac"),
|
|
"fps": {"num": fps_info["num"], "den": fps_info["den"]},
|
|
"sample_rate": 44100,
|
|
"channels": 2,
|
|
"channel_layout": 3,
|
|
"has_audio": True,
|
|
"has_video": True,
|
|
"pixel_format": 12,
|
|
"pixel_ratio": {"num": 1, "den": 1},
|
|
"display_ratio": {"num": 16, "den": 9}
|
|
}
|
|
|
|
# Flattened top-level File Object in osp_files
|
|
osp_files.append({
|
|
"id": file_id,
|
|
"path": file_path,
|
|
"media_type": "video",
|
|
"duration": dur,
|
|
"file_size": file_size,
|
|
"width": c["width"],
|
|
"height": c["height"],
|
|
"video_length": video_length,
|
|
"video_stream_index": c.get("video_stream_index", 0),
|
|
"audio_stream_index": c.get("audio_stream_index", 1),
|
|
"vcodec": c.get("vcodec", "h264"),
|
|
"acodec": c.get("acodec", "aac"),
|
|
"fps": {"num": fps_info["num"], "den": fps_info["den"]},
|
|
"sample_rate": 44100,
|
|
"channels": 2,
|
|
"channel_layout": 3,
|
|
"has_audio": True,
|
|
"has_video": True,
|
|
"pixel_format": 12,
|
|
"pixel_ratio": {"num": 1, "den": 1},
|
|
"display_ratio": {"num": 16, "den": 9}
|
|
})
|
|
|
|
layer = 2 if (idx % 2 == 0) else 3
|
|
|
|
alpha_pts = []
|
|
if idx == 0:
|
|
alpha_pts.extend([(0.0, 0.0), (FADE_IN_SEC, 1.0)])
|
|
else:
|
|
alpha_pts.extend([(0.0, 0.0), (CROSSFADE_SEC, 1.0)])
|
|
|
|
if idx == num_clips - 1:
|
|
alpha_pts.extend([(dur - FADE_OUT_SEC, 1.0), (dur, 0.0)])
|
|
else:
|
|
alpha_pts.extend([(dur - CROSSFADE_SEC, 1.0), (dur, 0.0)])
|
|
|
|
video_clip = create_openshot_clip(
|
|
file_id=file_id,
|
|
file_reader=video_reader,
|
|
position=current_pos,
|
|
start=0.0,
|
|
end=dur,
|
|
layer=layer,
|
|
title=os.path.basename(file_path)
|
|
)
|
|
video_clip["alpha"] = make_keyframe_points(alpha_pts, master_fps)
|
|
osp_clips.append(video_clip)
|
|
|
|
current_pos += (dur - CROSSFADE_SEC)
|
|
|
|
# Validated OpenShot Project Schema
|
|
osp_data = {
|
|
"width": max_width,
|
|
"height": max_height,
|
|
"fps": {"num": fps_info["num"], "den": fps_info["den"]},
|
|
"display_ratio": {"num": 16, "den": 9},
|
|
"pixel_ratio": {"num": 1, "den": 1},
|
|
"sample_rate": 44100,
|
|
"channels": 2,
|
|
"channel_layout": 3,
|
|
"settings": {},
|
|
"profile": "Custom",
|
|
"files": osp_files,
|
|
"clips": osp_clips,
|
|
"effects": [],
|
|
"markers": [],
|
|
"layers": [
|
|
{"id": "L1", "layer": 1, "label": "Track 1", "number": 1},
|
|
{"id": "L2", "layer": 2, "label": "Track 2", "number": 2},
|
|
{"id": "L3", "layer": 3, "label": "Track 3", "number": 3},
|
|
{"id": "L4", "layer": 4, "label": "Track 4", "number": 4},
|
|
{"id": "L5", "layer": 5, "label": "Track 5", "number": 5}
|
|
],
|
|
"history": {"undo": [], "redo": []},
|
|
"scale": 1.0,
|
|
"tick_method": "FRAME",
|
|
"version": {
|
|
"openshot-qt": "3.1.1",
|
|
"libopenshot": "0.3.2"
|
|
}
|
|
}
|
|
|
|
osp_filename = os.path.join(output_dir, f"{date_str}_{event_name.replace(' ', '_')}.osp")
|
|
with open(osp_filename, "w", encoding="utf-8") as f:
|
|
json.dump(osp_data, f, indent=2)
|
|
|
|
print(f"Project created: {osp_filename} ({max_width}x{max_height} @ {fps_info['num']}/{fps_info['den']} fps)")
|
|
|
|
|
|
def process_folder(input_folder, event_name="Home Video"):
|
|
valid_exts = ('.mp4', '.mov', '.m4v', '.mkv', '.avi')
|
|
videos_by_day = defaultdict(list)
|
|
|
|
for fname in sorted(os.listdir(input_folder)):
|
|
if fname.lower().endswith(valid_exts):
|
|
fpath = os.path.join(input_folder, fname)
|
|
info = get_video_info(fpath)
|
|
|
|
if not info:
|
|
continue
|
|
if info["duration"] < MIN_CLIP_DURATION:
|
|
print(f"Skipping short clip (< {MIN_CLIP_DURATION}s): {fname}")
|
|
continue
|
|
|
|
info["path"] = fpath
|
|
day_key = info["dt"].strftime("%Y-%m-%d")
|
|
videos_by_day[day_key].append(info)
|
|
|
|
for day_key, clips in videos_by_day.items():
|
|
if clips:
|
|
print(f"\nProcessing {len(clips)} clip(s) for date: {day_key}")
|
|
create_osp_project(day_key, event_name, clips, output_dir=input_folder)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
if len(sys.argv) < 2:
|
|
print("Usage: python build_openshot_project.py [Folder Path] [Event Title]")
|
|
sys.exit(1)
|
|
|
|
folder_path = sys.argv[1]
|
|
title = sys.argv[2] if len(sys.argv) > 2 else "Family Memories"
|
|
process_folder(folder_path, title) |