dave/py-media-grader
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(main.py): add threaded video rendering with progress updates and cancellation support

Browse Source
This commit is contained in:
PhatPhuckDave
2025-09-07 23:54:57 +02:00
parent a815679a38
commit b7e4fac9e7
1 changed files with 208 additions and 133 deletions
Download Patch File Download Diff File Expand all files Collapse all files

341
croppa/main.py
View File

@@ -8,6 +8,8 @@ from typing import List
import time
import re
import json
import threading
import queue
class VideoEditor:
# Configuration constants
@@ -139,6 +141,11 @@ class VideoEditor:
# Crop adjustment settings
self.crop_size_step = self.CROP_SIZE_STEP
# Render thread management
self.render_thread = None
self.render_cancelled = False
self.render_progress_queue = queue.Queue()
def _get_state_file_path(self) -> Path:
"""Get the state file path for the current media file"""
@@ -1487,7 +1494,195 @@ class VideoEditor:
if self.is_image_mode:
return self._render_image(output_path)
else:
return self._render_video(output_path)
return self._render_video_threaded(output_path)
def _render_video_threaded(self, output_path: str):
"""Start video rendering in a separate thread"""
# Check if already rendering
if self.render_thread and self.render_thread.is_alive():
print("Render already in progress!")
return False
# Reset render state
self.render_cancelled = False
# Start render thread
self.render_thread = threading.Thread(
target=self._render_video_worker,
args=(output_path,),
daemon=True
)
self.render_thread.start()
print(f"Started rendering to {output_path} in background thread...")
return True
def _render_video_worker(self, output_path: str):
"""Worker method that runs in the render thread"""
try:
if not output_path.endswith(".mp4"):
output_path += ".mp4"
start_time = time.time()
# Send progress update to main thread
self.render_progress_queue.put(("init", "Initializing render...", 0.0, 0.0))
# Determine frame range
start_frame = self.cut_start_frame if self.cut_start_frame is not None else 0
end_frame = (
self.cut_end_frame
if self.cut_end_frame is not None
else self.total_frames - 1
)
if start_frame >= end_frame:
self.render_progress_queue.put(("error", "Invalid cut range!", 1.0, 0.0))
return False
# Send progress update
self.render_progress_queue.put(("progress", "Calculating output dimensions...", 0.05, 0.0))
# Calculate output dimensions (accounting for rotation)
if self.crop_rect:
crop_width = int(self.crop_rect[2])
crop_height = int(self.crop_rect[3])
else:
crop_width = self.frame_width
crop_height = self.frame_height
# Swap dimensions if rotation is 90 or 270 degrees
if self.rotation_angle == 90 or self.rotation_angle == 270:
output_width = int(crop_height * self.zoom_factor)
output_height = int(crop_width * self.zoom_factor)
else:
output_width = int(crop_width * self.zoom_factor)
output_height = int(crop_height * self.zoom_factor)
# Send progress update
self.render_progress_queue.put(("progress", "Setting up video writer...", 0.1, 0.0))
# Use mp4v codec (most compatible with MP4)
fourcc = cv2.VideoWriter_fourcc(*"mp4v")
out = cv2.VideoWriter(
output_path, fourcc, self.fps, (output_width, output_height)
)
if not out.isOpened():
self.render_progress_queue.put(("error", "Could not open video writer!", 1.0, 0.0))
return False
# Simple sequential processing - the I/O is the bottleneck anyway
total_output_frames = end_frame - start_frame + 1
last_progress_update = 0
for frame_idx in range(start_frame, end_frame + 1):
# Check for cancellation
if self.render_cancelled:
out.release()
self.render_progress_queue.put(("cancelled", "Render cancelled", 0.0, 0.0))
return False
# Read frame
self.cap.set(cv2.CAP_PROP_POS_FRAMES, frame_idx)
ret, frame = self.cap.read()
if not ret:
break
# Process and write frame directly (minimize memory copies)
processed_frame = self._process_frame_for_render(
frame, output_width, output_height
)
if processed_frame is not None:
out.write(processed_frame)
frames_written = frame_idx - start_frame + 1
current_time = time.time()
# Update progress bar (10% to 95% of progress reserved for frame processing)
progress = 0.1 + (0.85 * (frames_written / total_output_frames))
# Throttled progress update
if current_time - last_progress_update > 0.5:
elapsed = current_time - start_time
fps_rate = frames_written / elapsed
eta = (elapsed / frames_written) * (
total_output_frames - frames_written
)
progress_text = f"Rendering {frames_written}/{total_output_frames} frames (ETA: {eta:.1f}s)"
self.render_progress_queue.put(("progress", progress_text, progress, fps_rate))
last_progress_update = current_time
out.release()
# Ensure the video writer is completely closed and file handles are freed
del out
time.sleep(0.1) # Small delay to ensure file is unlocked
total_time = time.time() - start_time
total_frames_written = end_frame - start_frame + 1
avg_fps = total_frames_written / total_time if total_time > 0 else 0
# Complete the progress bar
self.render_progress_queue.put(("complete", f"Complete! Rendered {total_frames_written} frames in {total_time:.1f}s", 1.0, avg_fps))
print(f"\nVideo rendered successfully to {output_path}")
print(f"Rendered {total_frames_written} frames in {total_time:.2f}s (avg {avg_fps:.1f} FPS)")
return True
except Exception as e:
self.render_progress_queue.put(("error", f"Render error: {str(e)}", 1.0, 0.0))
print(f"Render error: {e}")
return False
def update_render_progress(self):
"""Process progress updates from the render thread"""
try:
while True:
# Non-blocking get from queue
update_type, text, progress, fps = self.render_progress_queue.get_nowait()
if update_type == "init":
self.show_progress_bar(text)
elif update_type == "progress":
self.update_progress_bar(progress, text, fps)
elif update_type == "complete":
self.update_progress_bar(progress, text, fps)
elif update_type == "error":
self.update_progress_bar(progress, text, fps)
elif update_type == "cancelled":
self.hide_progress_bar()
self.show_feedback_message("Render cancelled")
except queue.Empty:
# No more updates in queue
pass
def cancel_render(self):
"""Cancel the current render operation"""
if self.render_thread and self.render_thread.is_alive():
self.render_cancelled = True
print("Render cancellation requested...")
return True
return False
def is_rendering(self):
"""Check if a render operation is currently active"""
return self.render_thread and self.render_thread.is_alive()
def cleanup_render_thread(self):
"""Clean up render thread resources"""
if self.render_thread and self.render_thread.is_alive():
self.render_cancelled = True
# Wait a bit for the thread to finish gracefully
self.render_thread.join(timeout=2.0)
if self.render_thread.is_alive():
print("Warning: Render thread did not finish gracefully")
self.render_thread = None
self.render_cancelled = False
def _render_image(self, output_path: str):
"""Save image with current edits applied"""
@@ -1514,138 +1709,6 @@ class VideoEditor:
print("Error: Could not process image")
return False
def _render_video(self, output_path: str):
"""Optimized video rendering with multithreading and batch processing"""
if not output_path.endswith(".mp4"):
output_path += ".mp4"
print(f"Rendering video to {output_path}...")
start_time = time.time()
# Show progress bar
self.show_progress_bar("Initializing render...")
# Determine frame range
start_frame = self.cut_start_frame if self.cut_start_frame is not None else 0
end_frame = (
self.cut_end_frame
if self.cut_end_frame is not None
else self.total_frames - 1
)
if start_frame >= end_frame:
print("Invalid cut range!")
self.update_progress_bar(1.0, "Error: Invalid cut range!")
return False
# Update progress for initialization
self.update_progress_bar(0.05, "Calculating output dimensions...")
# Calculate output dimensions (accounting for rotation)
if self.crop_rect:
crop_width = int(self.crop_rect[2])
crop_height = int(self.crop_rect[3])
else:
crop_width = self.frame_width
crop_height = self.frame_height
# Swap dimensions if rotation is 90 or 270 degrees
if self.rotation_angle == 90 or self.rotation_angle == 270:
output_width = int(crop_height * self.zoom_factor)
output_height = int(crop_width * self.zoom_factor)
else:
output_width = int(crop_width * self.zoom_factor)
output_height = int(crop_height * self.zoom_factor)
# Update progress for video writer setup
self.update_progress_bar(0.1, "Setting up video writer...")
# Use mp4v codec (most compatible with MP4)
fourcc = cv2.VideoWriter_fourcc(*"mp4v")
out = cv2.VideoWriter(
output_path, fourcc, self.fps, (output_width, output_height)
)
if not out.isOpened():
print("Error: Could not open video writer!")
self.update_progress_bar(1.0, "Error: Could not open video writer!")
return False
# Simple sequential processing - the I/O is the bottleneck anyway
total_output_frames = end_frame - start_frame + 1
last_progress_update = 0
last_display_update = 0
for frame_idx in range(start_frame, end_frame + 1):
# Read frame
self.cap.set(cv2.CAP_PROP_POS_FRAMES, frame_idx)
ret, frame = self.cap.read()
if not ret:
break
# Process and write frame directly (minimize memory copies)
processed_frame = self._process_frame_for_render(
frame, output_width, output_height
)
if processed_frame is not None:
out.write(processed_frame)
frames_written = frame_idx - start_frame + 1
current_time = time.time()
# Update progress bar (10% to 95% of progress reserved for frame processing)
progress = 0.1 + (0.85 * (frames_written / total_output_frames))
# Throttled progress update
if current_time - last_progress_update > 0.5:
elapsed = current_time - start_time
fps_rate = frames_written / elapsed
eta = (elapsed / frames_written) * (
total_output_frames - frames_written
)
progress_text = f"Rendering {frames_written}/{total_output_frames} frames (ETA: {eta:.1f}s)"
self.update_progress_bar(progress, progress_text, fps_rate)
print(
f"Progress: {progress*100:.1f}% | {frames_written}/{total_output_frames} | "
f"FPS: {fps_rate:.1f} | ETA: {eta:.1f}s\r",
end="",
)
last_progress_update = current_time
# Update display more frequently to show progress bar
if (
current_time - last_display_update > 0.1
): # Update display every 100ms
self.display_current_frame()
cv2.waitKey(1) # Allow OpenCV to process events
last_display_update = current_time
out.release()
# Ensure the video writer is completely closed and file handles are freed
del out
time.sleep(0.1) # Small delay to ensure file is unlocked
total_time = time.time() - start_time
total_frames_written = end_frame - start_frame + 1
avg_fps = total_frames_written / total_time if total_time > 0 else 0
# Complete the progress bar
self.update_progress_bar(
1.0,
f"Complete! Rendered {total_frames_written} frames in {total_time:.1f}s",
avg_fps,
)
print(f"\nVideo rendered successfully to {output_path}")
print(
f"Rendered {total_frames_written} frames in {total_time:.2f}s (avg {avg_fps:.1f} FPS)"
)
return True
def _process_frame_for_render(self, frame, output_width: int, output_height: int):
"""Process a single frame for rendering (optimized for speed)"""
@@ -1761,6 +1824,7 @@ class VideoEditor:
print(" N: Next video")
print(" n: Previous video")
print(" Enter: Render video")
print(" X: Cancel render")
print(" Q/ESC: Quit")
print()
@@ -1775,6 +1839,9 @@ class VideoEditor:
# Update auto-repeat seeking if active
self.update_auto_repeat_seek()
# Update render progress from background thread
self.update_render_progress()
# Only update display if needed and throttled
if self.should_update_display():
self.display_current_frame()
@@ -1945,6 +2012,13 @@ class VideoEditor:
# Marker looping only for videos
if not self.is_image_mode:
self.toggle_marker_looping()
elif key == ord("x"):
# Cancel render if active
if self.is_rendering():
self.cancel_render()
print("Render cancellation requested")
else:
print("No render operation to cancel")
# Individual direction controls using shift combinations we can detect
elif key == ord("J"): # Shift+i - expand up
@@ -1980,6 +2054,7 @@ class VideoEditor:
self.advance_frame()
self.save_state()
self.cleanup_render_thread()
if hasattr(self, 'cap') and self.cap:
self.cap.release()
cv2.destroyAllWindows()