311 lines
9.1 KiB
Bash
Executable File
311 lines
9.1 KiB
Bash
Executable File
#!/bin/bash
|
|
|
|
# Script to trim empty frames from start and end of WebM files
|
|
# Usage: ./trim_webm_empty_frames.sh [directory_path] [sample_rate]
|
|
|
|
# Function to display usage
|
|
usage() {
|
|
echo "Usage: $0 [directory_path] [sample_rate]"
|
|
echo " directory_path: Path to directory containing WebM files to trim (default: current directory)"
|
|
echo " sample_rate: How many frames to sample per second for analysis (default: 2)"
|
|
echo " Higher values = more accurate but slower (1-10 recommended)"
|
|
echo ""
|
|
echo "Examples:"
|
|
echo " $0 # Current directory, sample 2 frames/sec"
|
|
echo " $0 /path/to/files # Custom directory, default sampling"
|
|
echo " $0 /path/to/files 4 # Custom directory, sample 4 frames/sec"
|
|
echo ""
|
|
echo "This script will:"
|
|
echo " - Analyze WebM files to find first and last non-empty frames"
|
|
echo " - Trim away all empty frames from start and end"
|
|
echo " - Preserve original quality and alpha transparency"
|
|
echo " - Save trimmed files in a 'trim' subdirectory"
|
|
exit 1
|
|
}
|
|
|
|
# Check if ffmpeg is installed
|
|
if ! command -v ffmpeg &> /dev/null; then
|
|
echo "Error: ffmpeg is not installed or not in PATH"
|
|
echo "Please install ffmpeg to use this script"
|
|
exit 1
|
|
fi
|
|
|
|
# Check if bc is available for floating point calculations
|
|
if ! command -v bc >/dev/null 2>&1; then
|
|
echo "Warning: 'bc' calculator not found. Using basic arithmetic (less precise)."
|
|
echo "For better precision, install 'bc': brew install bc (macOS) or apt-get install bc (Linux)"
|
|
echo ""
|
|
fi
|
|
|
|
# Set default values
|
|
DIRECTORY="."
|
|
SAMPLE_RATE=2
|
|
|
|
# Parse arguments
|
|
if [ $# -eq 0 ]; then
|
|
DIRECTORY="."
|
|
elif [ $# -eq 1 ]; then
|
|
if [ "$1" = "-h" ] || [ "$1" = "--help" ]; then
|
|
usage
|
|
fi
|
|
DIRECTORY="$1"
|
|
elif [ $# -eq 2 ]; then
|
|
DIRECTORY="$1"
|
|
SAMPLE_RATE="$2"
|
|
else
|
|
echo "Error: Too many arguments"
|
|
usage
|
|
fi
|
|
|
|
# Validate sample rate
|
|
if ! [[ "$SAMPLE_RATE" =~ ^[1-9][0-9]*$ ]] || [ "$SAMPLE_RATE" -gt 10 ]; then
|
|
echo "Error: sample_rate must be between 1-10"
|
|
exit 1
|
|
fi
|
|
|
|
# Check if directory exists
|
|
if [ ! -d "$DIRECTORY" ]; then
|
|
echo "Error: Directory '$DIRECTORY' does not exist"
|
|
exit 1
|
|
fi
|
|
|
|
# Convert to absolute path
|
|
DIRECTORY=$(realpath "$DIRECTORY")
|
|
echo "Trimming WebM files in: $DIRECTORY"
|
|
echo "Sample rate: $SAMPLE_RATE frames per second"
|
|
|
|
# Create trim output directory
|
|
TRIM_DIR="$DIRECTORY/trim"
|
|
if [ ! -d "$TRIM_DIR" ]; then
|
|
mkdir -p "$TRIM_DIR"
|
|
echo "Created output directory: $TRIM_DIR"
|
|
else
|
|
echo "Using existing output directory: $TRIM_DIR"
|
|
fi
|
|
|
|
# Create temporary directory for frame analysis
|
|
temp_dir=$(mktemp -d)
|
|
trap "rm -rf $temp_dir" EXIT
|
|
|
|
# Function to check if a frame is empty (returns 0 for empty, 1 for content, 2 for unclear)
|
|
check_frame_empty() {
|
|
local frame_file="$1"
|
|
|
|
# Check if frame file exists
|
|
if [ ! -f "$frame_file" ]; then
|
|
return 2 # unclear/error
|
|
fi
|
|
|
|
# Get file size - very small files are likely empty/transparent
|
|
file_size=$(stat -f%z "$frame_file" 2>/dev/null || stat -c%s "$frame_file" 2>/dev/null)
|
|
|
|
# If file is very small (less than 2KB), likely empty
|
|
if [ -n "$file_size" ] && [ "$file_size" -lt 2048 ]; then
|
|
return 0 # definitely empty
|
|
fi
|
|
|
|
# If file is reasonably large, assume it has content
|
|
if [ "$file_size" -gt 50000 ]; then
|
|
return 1 # definitely has content
|
|
fi
|
|
|
|
# For medium-sized files, try alpha analysis
|
|
alpha_info=$(ffmpeg -i "$frame_file" -vf "extractplanes=a" -f null - 2>&1 | grep "mean\|avg" 2>/dev/null)
|
|
|
|
if [ -n "$alpha_info" ]; then
|
|
alpha_mean=$(echo "$alpha_info" | grep -o "mean:[0-9.]*" | cut -d: -f2 | head -1)
|
|
|
|
if [ -n "$alpha_mean" ]; then
|
|
# Check if mean is very low (close to 0 = transparent)
|
|
is_empty=$(awk "BEGIN {print ($alpha_mean < 2.0) ? 1 : 0}")
|
|
|
|
if [ "$is_empty" = "1" ]; then
|
|
return 0 # definitely empty
|
|
else
|
|
return 1 # definitely has content
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
# Default: assume medium files have some content (conservative approach)
|
|
return 1
|
|
}
|
|
|
|
# Function to find first non-empty frame
|
|
find_first_content_frame() {
|
|
local video_file="$1"
|
|
local duration="$2"
|
|
local decoder="$3"
|
|
|
|
# Check frames at 0, 0.5, 1.0, 1.5 seconds etc
|
|
for i in 0 0.5 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0; do
|
|
local test_frame="$temp_dir/start_${i}.png"
|
|
|
|
ffmpeg -c:v "$decoder" -ss "$i" -i "$video_file" -frames:v 1 -y "$test_frame" -v quiet 2>/dev/null
|
|
|
|
if [ -f "$test_frame" ]; then
|
|
check_frame_empty "$test_frame"
|
|
if [ $? -eq 1 ]; then
|
|
echo "$i"
|
|
rm -f "$test_frame"
|
|
return 0
|
|
fi
|
|
rm -f "$test_frame"
|
|
fi
|
|
done
|
|
|
|
echo "0"
|
|
}
|
|
|
|
# Function to find last non-empty frame
|
|
find_last_content_frame() {
|
|
local video_file="$1"
|
|
local duration="$2"
|
|
local decoder="$3"
|
|
|
|
# Work backwards from end
|
|
local dur_int=${duration%.*}
|
|
|
|
for i in 0.1 0.5 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0; do
|
|
local check_time=$(echo "$duration - $i" | bc 2>/dev/null || echo "$dur_int")
|
|
local test_frame="$temp_dir/end_${i}.png"
|
|
|
|
ffmpeg -c:v "$decoder" -ss "$check_time" -i "$video_file" -frames:v 1 -y "$test_frame" -v quiet 2>/dev/null
|
|
|
|
if [ -f "$test_frame" ]; then
|
|
check_frame_empty "$test_frame"
|
|
if [ $? -eq 1 ]; then
|
|
echo "$check_time"
|
|
rm -f "$test_frame"
|
|
return 0
|
|
fi
|
|
rm -f "$test_frame"
|
|
fi
|
|
done
|
|
|
|
echo "$duration"
|
|
}
|
|
|
|
# Find all WebM files in the directory
|
|
WEBM_FILES=($(find "$DIRECTORY" -maxdepth 1 -name "*.webm" -type f))
|
|
|
|
# Check if any WebM files were found
|
|
if [ ${#WEBM_FILES[@]} -eq 0 ]; then
|
|
echo "No WebM files found in '$DIRECTORY'"
|
|
exit 0
|
|
fi
|
|
|
|
echo "Found ${#WEBM_FILES[@]} WebM file(s) to process"
|
|
echo ""
|
|
|
|
# Counters
|
|
processed=0
|
|
skipped=0
|
|
failed=0
|
|
|
|
# Process each WebM file
|
|
for webm_file in "${WEBM_FILES[@]}"; do
|
|
count=$((count + 1))
|
|
base_name=$(basename "$webm_file" .webm)
|
|
|
|
echo "[$((processed + skipped + failed + 1))/${#WEBM_FILES[@]}] Processing: $base_name.webm"
|
|
|
|
# Check if output file already exists
|
|
output_file="$TRIM_DIR/${base_name}.webm"
|
|
if [ -f "$output_file" ]; then
|
|
echo " → Skipping: Output file already exists"
|
|
((skipped++))
|
|
echo ""
|
|
continue
|
|
fi
|
|
|
|
# Test if file is readable by ffprobe
|
|
if ! ffprobe -v quiet "$webm_file" >/dev/null 2>&1; then
|
|
echo " ✗ Error: File cannot be read by ffprobe"
|
|
((failed++))
|
|
echo ""
|
|
continue
|
|
fi
|
|
|
|
# Detect codec type and get video info
|
|
CODEC_INFO=$(ffprobe -v quiet -select_streams v:0 -show_entries stream=codec_name -of csv=p=0 "$webm_file" 2>/dev/null)
|
|
duration=$(ffprobe -v quiet -show_entries format=duration -of csv=p=0 "$webm_file" 2>/dev/null)
|
|
|
|
if [ -z "$duration" ] || [ "$duration" = "N/A" ]; then
|
|
echo " ✗ Error: Could not get video duration"
|
|
((failed++))
|
|
echo ""
|
|
continue
|
|
fi
|
|
|
|
# Set appropriate decoder
|
|
if [ "$CODEC_INFO" = "vp9" ]; then
|
|
DECODER="libvpx-vp9"
|
|
echo " → VP9 codec detected"
|
|
else
|
|
DECODER="libvpx"
|
|
echo " → VP8 codec detected"
|
|
fi
|
|
|
|
echo " → Duration: ${duration}s"
|
|
|
|
# Find content boundaries
|
|
echo " → Analyzing frames..."
|
|
start_time=$(find_first_content_frame "$webm_file" "$duration" "$DECODER")
|
|
end_time=$(find_last_content_frame "$webm_file" "$duration" "$DECODER")
|
|
|
|
# Validate times
|
|
if [ -z "$start_time" ] || [ -z "$end_time" ]; then
|
|
echo " ✗ Error: Could not determine content boundaries"
|
|
((failed++))
|
|
echo ""
|
|
continue
|
|
fi
|
|
|
|
echo " → Content from ${start_time}s to ${end_time}s"
|
|
|
|
# Calculate new duration
|
|
new_duration=$(echo "$end_time - $start_time" | bc 2>/dev/null || echo "$end_time")
|
|
|
|
# Simple trimming check
|
|
if [ "$start_time" = "0" ] && [ "$end_time" = "$duration" ]; then
|
|
echo " → No trimming needed, copying original..."
|
|
cp "$webm_file" "$output_file"
|
|
if [ $? -eq 0 ]; then
|
|
echo " ✓ File copied successfully"
|
|
((processed++))
|
|
else
|
|
echo " ✗ Failed to copy file"
|
|
((failed++))
|
|
fi
|
|
else
|
|
echo " → Trimming (new duration: ${new_duration}s)"
|
|
|
|
if ffmpeg -ss "$start_time" -i "$webm_file" -t "$new_duration" -c copy -y "$output_file" -v quiet 2>/dev/null; then
|
|
echo " ✓ Successfully trimmed"
|
|
((processed++))
|
|
else
|
|
echo " ✗ Failed to trim"
|
|
((failed++))
|
|
fi
|
|
fi
|
|
|
|
echo ""
|
|
done
|
|
|
|
# Summary
|
|
echo "==================================="
|
|
echo "Trimming Complete!"
|
|
echo "Total files processed: $processed"
|
|
echo "Files skipped (already exist): $skipped"
|
|
echo "Files failed: $failed"
|
|
echo "Output directory: $TRIM_DIR"
|
|
|
|
if [ $processed -gt 0 ]; then
|
|
echo ""
|
|
echo "Trimmed files:"
|
|
ls -la "$TRIM_DIR"/*.webm 2>/dev/null | while read -r line; do
|
|
echo " $line"
|
|
done
|
|
fi
|