PhatPhuckDave
cacaa5f2ac
This commit refactors the video rendering process in the VideoEditor class by delegating rendering tasks to a new rendering module. The _render_video_threaded and _render_video_worker methods are replaced with start_render_thread and pump_progress functions, enhancing code organization and maintainability. Additionally, the pyproject.toml file is updated to include the new rendering module, ensuring proper module recognition. This restructuring improves the overall clarity and efficiency of the video rendering workflow.
304 lines
13 KiB
Python
304 lines
13 KiB
Python
import os
|
|
import time
|
|
import subprocess
|
|
import threading
|
|
import queue
|
|
import tempfile
|
|
from typing import Optional
|
|
|
|
import cv2
|
|
|
|
|
|
def start_render_thread(editor, output_path: str) -> bool:
|
|
if editor.render_thread and editor.render_thread.is_alive():
|
|
print("Render already in progress! Use 'X' to cancel first.")
|
|
return False
|
|
editor.render_cancelled = False
|
|
editor.render_thread = threading.Thread(target=_render_worker, args=(editor, output_path), daemon=True)
|
|
editor.render_thread.start()
|
|
print(f"Started rendering to {output_path} in background thread...")
|
|
print("You can continue editing while rendering. Press 'X' to cancel.")
|
|
return True
|
|
|
|
|
|
def _render_worker(editor, output_path: str) -> bool:
|
|
try:
|
|
if not output_path.endswith(".mp4"):
|
|
output_path += ".mp4"
|
|
|
|
start_frame = editor.cut_start_frame if editor.cut_start_frame is not None else 0
|
|
end_frame = editor.cut_end_frame if editor.cut_end_frame is not None else editor.total_frames - 1
|
|
if start_frame >= end_frame:
|
|
editor.render_progress_queue.put(("error", "Invalid cut range!", 1.0, 0.0))
|
|
return False
|
|
|
|
editor.render_progress_queue.put(("progress", "Calculating output dimensions...", 0.05, 0.0))
|
|
|
|
if editor.crop_rect:
|
|
crop_width = int(editor.crop_rect[2])
|
|
crop_height = int(editor.crop_rect[3])
|
|
else:
|
|
crop_width = editor.frame_width
|
|
crop_height = editor.frame_height
|
|
|
|
if editor.rotation_angle in (90, 270):
|
|
output_width = int(crop_height * editor.zoom_factor)
|
|
output_height = int(crop_width * editor.zoom_factor)
|
|
else:
|
|
output_width = int(crop_width * editor.zoom_factor)
|
|
output_height = int(crop_height * editor.zoom_factor)
|
|
|
|
output_width -= output_width % 2
|
|
output_height -= output_height % 2
|
|
|
|
editor.render_progress_queue.put(("progress", "Setting up FFmpeg encoder...", 0.1, 0.0))
|
|
print(f"Output dimensions: {output_width}x{output_height}")
|
|
print(f"Zoom factor: {editor.zoom_factor}")
|
|
print(f"Crop dimensions: {crop_width}x{crop_height}")
|
|
print("Using FFmpeg for encoding with OpenCV transformations...")
|
|
|
|
return _render_with_ffmpeg_pipe(editor, output_path, start_frame, end_frame, output_width, output_height)
|
|
except Exception as e:
|
|
error_msg = str(e)
|
|
if "async_lock" in error_msg or "pthread_frame" in error_msg:
|
|
error_msg = "FFmpeg threading error - try restarting the application"
|
|
elif "Assertion" in error_msg:
|
|
error_msg = "Video codec error - the video file may be corrupted or incompatible"
|
|
editor.render_progress_queue.put(("error", f"Render error: {error_msg}", 1.0, 0.0))
|
|
print(f"Render error: {error_msg}")
|
|
return False
|
|
|
|
|
|
def pump_progress(editor):
|
|
try:
|
|
while True:
|
|
update_type, text, progress, fps = editor.render_progress_queue.get_nowait()
|
|
if update_type == "init":
|
|
editor.show_progress_bar(text)
|
|
elif update_type == "progress":
|
|
editor.update_progress_bar(progress, text, fps)
|
|
elif update_type == "complete":
|
|
editor.update_progress_bar(progress, text, fps)
|
|
if hasattr(editor, "overwrite_temp_path") and editor.overwrite_temp_path:
|
|
_handle_overwrite_completion(editor)
|
|
elif update_type == "error":
|
|
editor.update_progress_bar(progress, text, fps)
|
|
editor.show_feedback_message(f"ERROR: {text}")
|
|
elif update_type == "cancelled":
|
|
editor.hide_progress_bar()
|
|
editor.show_feedback_message("Render cancelled")
|
|
except queue.Empty:
|
|
pass
|
|
|
|
|
|
def _handle_overwrite_completion(editor):
|
|
try:
|
|
print("Replacing original file...")
|
|
if hasattr(editor, "cap") and editor.cap:
|
|
editor.cap.release()
|
|
import shutil
|
|
print(f"DEBUG: Moving {editor.overwrite_temp_path} to {editor.overwrite_target_path}")
|
|
try:
|
|
shutil.move(editor.overwrite_temp_path, editor.overwrite_target_path)
|
|
print("DEBUG: File move successful")
|
|
except Exception as e:
|
|
print(f"DEBUG: File move failed: {e}")
|
|
if os.path.exists(editor.overwrite_temp_path):
|
|
os.remove(editor.overwrite_temp_path)
|
|
raise
|
|
time.sleep(0.1)
|
|
try:
|
|
editor._load_video(editor.video_path)
|
|
editor.load_current_frame()
|
|
print("File reloaded successfully")
|
|
except Exception as e:
|
|
print(f"Warning: Could not reload file after overwrite: {e}")
|
|
print("The file was saved successfully, but you may need to restart the editor to continue editing it.")
|
|
except Exception as e:
|
|
print(f"Error during file overwrite: {e}")
|
|
finally:
|
|
editor.overwrite_temp_path = None
|
|
editor.overwrite_target_path = None
|
|
|
|
|
|
def request_cancel(editor) -> bool:
|
|
if editor.render_thread and editor.render_thread.is_alive():
|
|
editor.render_cancelled = True
|
|
print("Render cancellation requested...")
|
|
return True
|
|
return False
|
|
|
|
|
|
def is_rendering(editor) -> bool:
|
|
return editor.render_thread and editor.render_thread.is_alive()
|
|
|
|
|
|
def cleanup_thread(editor):
|
|
if editor.render_thread and editor.render_thread.is_alive():
|
|
editor.render_cancelled = True
|
|
if editor.ffmpeg_process:
|
|
try:
|
|
editor.ffmpeg_process.terminate()
|
|
editor.ffmpeg_process.wait(timeout=1.0)
|
|
except Exception:
|
|
try:
|
|
editor.ffmpeg_process.kill()
|
|
except Exception:
|
|
pass
|
|
editor.ffmpeg_process = None
|
|
editor.render_thread.join(timeout=2.0)
|
|
if editor.render_thread.is_alive():
|
|
print("Warning: Render thread did not finish gracefully")
|
|
editor.render_thread = None
|
|
editor.render_cancelled = False
|
|
|
|
|
|
def _process_frame_for_render(editor, frame, output_width: int, output_height: int, frame_number: Optional[int] = None):
|
|
try:
|
|
if editor.crop_rect:
|
|
x, y, w, h = map(int, editor.crop_rect)
|
|
if editor.motion_tracker.tracking_enabled and frame_number is not None:
|
|
current_pos = editor.motion_tracker.get_interpolated_position(frame_number)
|
|
if current_pos:
|
|
tracked_x, tracked_y = current_pos
|
|
new_x = int(tracked_x - w // 2)
|
|
new_y = int(tracked_y - h // 2)
|
|
x, y = new_x, new_y
|
|
h_frame, w_frame = frame.shape[:2]
|
|
x = max(0, min(x, w_frame - 1))
|
|
y = max(0, min(y, h_frame - 1))
|
|
w = min(w, w_frame - x)
|
|
h = min(h, h_frame - y)
|
|
if w > 0 and h > 0:
|
|
frame = frame[y:y + h, x:x + w]
|
|
else:
|
|
return None
|
|
frame = editor.apply_brightness_contrast(frame)
|
|
if editor.rotation_angle != 0:
|
|
frame = editor.apply_rotation(frame)
|
|
if editor.zoom_factor != 1.0:
|
|
height, width = frame.shape[:2]
|
|
zoomed_width = int(width * editor.zoom_factor)
|
|
zoomed_height = int(height * editor.zoom_factor)
|
|
if zoomed_width == output_width and zoomed_height == output_height:
|
|
frame = cv2.resize(frame, (zoomed_width, zoomed_height), interpolation=cv2.INTER_LINEAR)
|
|
else:
|
|
frame = cv2.resize(frame, (output_width, output_height), interpolation=cv2.INTER_LINEAR)
|
|
else:
|
|
if frame.shape[1] != output_width or frame.shape[0] != output_height:
|
|
frame = cv2.resize(frame, (output_width, output_height), interpolation=cv2.INTER_LINEAR)
|
|
return frame
|
|
except Exception as e:
|
|
print(f"Error processing frame: {e}")
|
|
return None
|
|
|
|
|
|
def _render_with_ffmpeg_pipe(editor, output_path: str, start_frame: int, end_frame: int, output_width: int, output_height: int):
|
|
try:
|
|
try:
|
|
test_result = subprocess.run(["ffmpeg", "-version"], capture_output=True, text=True, timeout=10)
|
|
if test_result.returncode != 0:
|
|
print(f"FFmpeg test failed with return code {test_result.returncode}")
|
|
print(f"FFmpeg stderr: {test_result.stderr}")
|
|
editor.render_progress_queue.put(("error", "FFmpeg is not working properly", 1.0, 0.0))
|
|
return False
|
|
except (subprocess.CalledProcessError, FileNotFoundError, subprocess.TimeoutExpired) as e:
|
|
error_msg = f"FFmpeg not found or not working: {e}"
|
|
print(error_msg)
|
|
editor.render_progress_queue.put(("error", error_msg, 1.0, 0.0))
|
|
return False
|
|
|
|
editor.render_progress_queue.put(("progress", "Starting encoder...", 0.0, 0.0))
|
|
|
|
temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.raw')
|
|
temp_file.close()
|
|
|
|
ffmpeg_cmd = [
|
|
'ffmpeg', '-y',
|
|
'-f', 'rawvideo',
|
|
'-s', f'{output_width}x{output_height}',
|
|
'-pix_fmt', 'bgr24',
|
|
'-r', str(editor.fps),
|
|
'-i', temp_file.name,
|
|
'-c:v', 'libx264',
|
|
'-preset', 'fast',
|
|
'-crf', '18',
|
|
'-pix_fmt', 'yuv420p',
|
|
output_path
|
|
]
|
|
editor.temp_file_name = temp_file.name
|
|
|
|
render_cap = cv2.VideoCapture(str(editor.video_path))
|
|
render_cap.set(cv2.CAP_PROP_POS_FRAMES, start_frame)
|
|
|
|
total_frames = end_frame - start_frame + 1
|
|
frames_written = 0
|
|
start_time = time.time()
|
|
last_progress_update = 0
|
|
editor.render_progress_queue.put(("progress", f"Processing {total_frames} frames...", 0.1, 0.0))
|
|
|
|
with open(editor.temp_file_name, 'wb') as tf:
|
|
for i in range(total_frames):
|
|
if editor.render_cancelled:
|
|
render_cap.release()
|
|
editor.render_progress_queue.put(("cancelled", "Render cancelled", 0.0, 0.0))
|
|
return False
|
|
ret, frame = render_cap.read()
|
|
if not ret:
|
|
break
|
|
processed = _process_frame_for_render(editor, frame, output_width, output_height, start_frame + i)
|
|
if processed is not None:
|
|
if i == 0:
|
|
print(f"Processed frame dimensions: {processed.shape[1]}x{processed.shape[0]}")
|
|
print(f"Expected dimensions: {output_width}x{output_height}")
|
|
tf.write(processed.tobytes())
|
|
frames_written += 1
|
|
current_time = time.time()
|
|
progress = 0.1 + (0.8 * (i + 1) / total_frames)
|
|
if current_time - last_progress_update > 0.5:
|
|
elapsed = current_time - start_time
|
|
fps_rate = frames_written / elapsed if elapsed > 0 else 0
|
|
editor.render_progress_queue.put(("progress", f"Processed {i+1}/{total_frames} frames", progress, fps_rate))
|
|
last_progress_update = current_time
|
|
|
|
render_cap.release()
|
|
|
|
editor.render_progress_queue.put(("progress", "Encoding...", 0.9, 0.0))
|
|
result = subprocess.run(
|
|
ffmpeg_cmd,
|
|
capture_output=True,
|
|
text=True,
|
|
timeout=300,
|
|
creationflags=(subprocess.CREATE_NO_WINDOW if hasattr(subprocess, 'CREATE_NO_WINDOW') else 0)
|
|
)
|
|
if os.path.exists(editor.temp_file_name):
|
|
try:
|
|
os.unlink(editor.temp_file_name)
|
|
except OSError:
|
|
pass
|
|
|
|
if result.returncode == 0:
|
|
total_time = time.time() - start_time
|
|
avg_fps = frames_written / total_time if total_time > 0 else 0
|
|
editor.render_progress_queue.put(("complete", f"Rendered {frames_written} frames", 1.0, avg_fps))
|
|
print(f"Successfully rendered {frames_written} frames (avg {avg_fps:.1f} FPS)")
|
|
return True
|
|
else:
|
|
error_details = result.stderr if result.stderr else "No error details available"
|
|
print(f"Encoding failed with return code {result.returncode}")
|
|
print(f"Error: {error_details}")
|
|
editor.render_progress_queue.put(("error", f"Encoding failed: {error_details}", 1.0, 0.0))
|
|
return False
|
|
except Exception as e:
|
|
error_msg = str(e)
|
|
print(f"Rendering exception: {error_msg}")
|
|
print(f"Exception type: {type(e).__name__}")
|
|
if "Errno 22" in error_msg or "invalid argument" in error_msg.lower():
|
|
error_msg = "File system error - try using a different output path"
|
|
elif "BrokenPipeError" in error_msg:
|
|
error_msg = "Process terminated unexpectedly"
|
|
elif "FileNotFoundError" in error_msg or "ffmpeg" in error_msg.lower():
|
|
error_msg = "FFmpeg not found - please install FFmpeg and ensure it's in your PATH"
|
|
editor.render_progress_queue.put(("error", f"Rendering failed: {error_msg}", 1.0, 0.0))
|
|
return False
|