FFmpeg Clip Splitting Accuracy

2024-10-23 22:51 UTC gpt-4o-canmore Open in ChatGPT ↗

You

this clip splitting isnt accurate and creates overlaps when it shouldnt.

def split_clip_ffmpeg(video_file, start_time, end_time, output_filepath): duration = end_time - start_time

cmd = [
    'ffmpeg',
    '-y',  # Overwrite output files without asking
    '-ss', str(start_time),  # Fast seek to the start point, before input file
    '-i', video_file,
    '-t', str(duration),  # Duration of the output clip
    '-c', 'copy',  # Copy without re-encoding
    '-avoid_negative_ts', '1',  # Avoid negative timestamps
    output_filepath
]
try:
    subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    print(f"Created {output_filepath}")
except subprocess.CalledProcessError as e:
    print(f"Error creating {output_filepath}: {e.stderr.decode()}")

ChatGPT

The issue you’re describing—overlaps between splits—can occur for a few reasons related to how FFmpeg handles time-based operations. Here are some key reasons and solutions:

1. Keyframe Boundaries:

   • FFmpeg’s -ss parameter works by seeking to a point in the video, but depending on where that point falls, it might not land precisely if it doesn’t align with a keyframe.
   • If the starting point isn’t a keyframe, FFmpeg will find the closest keyframe before the requested time. This means the actual cut might be off from what you specify, potentially causing overlap or missing content between split parts.

2. Precision with -ss and -t:

   • When -ss is used before -i, it seeks at the input level (it’s fast, but imprecise).
   • FFmpeg’s accuracy depends on codec and keyframe availability, which means it may not be cutting precisely between frames, thus leading to overlaps.

3. Suggested Solution: Re-Encoding (-c:a and -c:v):

   • One way to make sure the split is accurate is to use re-encoding rather than copying. This approach might lose quality or increase processing time, but it will ensure exact cutting.

Suggested Changes

Below is a modified version of your function to improve the split accuracy:

import subprocess

def split_clip_ffmpeg(video_file, start_time, end_time, output_filepath):
    duration = end_time - start_time

    # More accurate command for cutting clips
    cmd = [
        'ffmpeg',
        '-y',  # Overwrite output files without asking
        '-ss', str(start_time),  # Input level seek (fast, but less accurate)
        '-i', video_file,
        '-t', str(duration),  # Duration of the output clip
        '-c:v', 'libx264',  # Re-encode video to ensure precision
        '-c:a', 'aac',  # Re-encode audio (change codec to aac)
        '-strict', 'experimental',  # Allow experimental features (optional)
        '-preset', 'fast',  # Preset to adjust speed/quality trade-off
        output_filepath
    ]

    try:
        subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        print(f"Created {output_filepath}")
    except subprocess.CalledProcessError as e:
        print(f"Error creating {output_filepath}: {e.stderr.decode()}")

Summary of Changes

1. Re-Encoding Video (-c:v and -c:a):

   • Instead of using -c copy, I’m using -c:v libx264 and -c:a aac to re-encode the video and audio streams. This allows FFmpeg to cut precisely at the specified frames and times.
   • This will reduce the issues with inaccurate timestamps that cause overlap or missing frames between clips.

2. Input-Level -ss Combined with Encoding:

   • Placing -ss before -i allows for faster seeking. However, re-encoding afterward provides more precise cuts compared to using -c copy.

3. Preset Options (-preset fast):

   • I’ve added a -preset parameter to balance encoding speed and quality. You can adjust the preset (ultrafast, fast, medium, etc.) to suit your needs.

Optional Improvement: Exact Frame Cutting

If you need frame-accurate cuts without re-encoding, you can place -ss after the -i parameter. However, this is slower as FFmpeg will need to decode the entire file up to the point you specify:

cmd = [
    'ffmpeg',
    '-y',
    '-i', video_file,
    '-ss', str(start_time),  # More precise but slower when placed after -i
    '-t', str(duration),
    '-c:v', 'copy',
    '-c:a', 'copy',
    output_filepath
]

This method may still cause precision issues due to keyframe alignment, but placing -ss after -i is generally more accurate.

Conclusion

• To eliminate overlaps, it’s best to re-encode the video, especially if you’re facing issues with -c copy.
• Alternatively, positioning -ss after -i can also improve cut precision, but this approach is slower.

If you prefer higher accuracy over processing speed, the re-encoding option will give you the most reliable results.

You

at least use nvenc.

ChatGPT

Sure! If you want to maintain speed while re-encoding, utilizing NVIDIA’s GPU-based nvenc encoder is a good option. This allows FFmpeg to leverage NVIDIA’s GPU capabilities for faster encoding, which is especially useful for large video files or when dealing with multiple clips.

Here is the modified version of the function using h264_nvenc for GPU acceleration:

import subprocess

def split_clip_ffmpeg(video_file, start_time, end_time, output_filepath):
    duration = end_time - start_time

    cmd = [
        'ffmpeg',
        '-y',  # Overwrite output files without asking
        '-ss', str(start_time),  # Input level seek (fast, but less accurate)
        '-i', video_file,
        '-t', str(duration),  # Duration of the output clip
        '-c:v', 'h264_nvenc',  # Use NVIDIA GPU encoding
        '-c:a', 'aac',  # Re-encode audio to AAC
        '-b:v', '5M',  # Set video bitrate (optional, can adjust as needed)
        '-preset', 'fast',  # Set nvenc preset (e.g., slow, medium, fast)
        output_filepath
    ]

    try:
        subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        print(f"Created {output_filepath}")
    except subprocess.CalledProcessError as e:
        print(f"Error creating {output_filepath}: {e.stderr.decode()}")

Key Changes Explained

1. NVIDIA GPU Encoding (-c:v h264_nvenc):

   • Replaced -c:v libx264 with -c:v h264_nvenc to utilize NVIDIA’s GPU encoding.
   • This provides a faster alternative to CPU-based encoding while keeping the output quality high, especially if you have an NVIDIA GPU.

2. Adjustable Bitrate (-b:v 5M):

   • Added -b:v 5M to specify the target bitrate for the video. You can adjust this value depending on the quality you want. A higher bitrate will provide better quality, while a lower bitrate will reduce the file size but also the quality.
   • You can also specify -crf to control quality-based rate, but using -b:v is better suited to nvenc.

3. Preset (-preset fast):

   • The preset affects the speed and efficiency of the encoding process. fast provides a good balance, but you can choose other options like slow, medium, etc., to match your needs.
   • NVIDIA encoders also have specific presets (p1, p2, etc.) if you need to customize further.

Why Use nvenc?

• Faster Encoding: nvenc offloads the work to the GPU, making encoding faster than CPU-based encoders.
• Suitable for High-Performance Tasks: This is especially useful when processing multiple files or working with high-resolution videos.

Optional Improvement for Cutting Accuracy

If you want even better precision for cutting, you can modify the -ss parameter’s position. Here is an alternative:

cmd = [
    'ffmpeg',
    '-y',
    '-i', video_file,
    '-ss', str(start_time),  # More accurate seeking when placed after input
    '-t', str(duration),
    '-c:v', 'h264_nvenc',  # Use NVIDIA GPU encoding
    '-c:a', 'aac',
    '-b:v', '5M',
    '-preset', 'fast',
    output_filepath
]

Summary

• Using h264_nvenc: This accelerates the encoding process while ensuring better splitting accuracy compared to -c copy.
• Bitrate Control: You can customize the bitrate to balance quality and size as per your requirements.

Let me know if this adjustment fits your needs or if you want to explore other performance optimizations!

You

check if the video is 10bit. if it is, ensure the nvenc wont throw eerors, by making t 8 bit

ChatGPT

To check if the video is 10-bit and convert it to 8-bit to prevent h264_nvenc errors (as it does not support 10-bit input directly), we need to add a check for the input video properties and modify the FFmpeg command accordingly.

Here is an updated version of the script that first checks the video color depth using FFprobe and then modifies the encoding process accordingly:

ChatGPT

Key Changes Explained

1. Function to Check Bit Depth (is_10bit_video):

   • I added a function, is_10bit_video(), that uses ffprobe to check the bits_per_raw_sample of the video.
   • If the value is '10', it returns True, indicating the video is 10-bit.

2. Conditionally Adding Video Filter:

   • If the video is determined to be 10-bit, I added a video filter (-vf 'format=yuv420p') to convert it to 8-bit.
   • This ensures compatibility with h264_nvenc, which does not support 10-bit input directly.

3. Subprocess Command:

   • The ffmpeg command is modified depending on whether the video is 10-bit or not to ensure the encoding process works without errors.

Summary

This solution ensures that 10-bit videos are converted to 8-bit before encoding with h264_nvenc, avoiding compatibility issues. Let me know if you need further adjustments or have other questions!

You

[h264_nvenc @ 000001dcc9351100] 10 bit encode not supported [h264_nvenc @ 000001dcc9351100] Provided device doesn’t support required NVENC features

ChatGPT

I’ve updated the script to convert 10-bit video to a compatible 8-bit format (nv12) for h264_nvenc. This should prevent errors related to unsupported 10-bit encoding. Let me know if you need any further modifications!

You

it doesnt work provide alternatvie

ChatGPT

I’ve updated the script to use software encoding (libx264) to convert the video to 8-bit before switching to GPU encoding, ensuring compatibility with h264_nvenc. This should address the issue with unsupported 10-bit inputs. Let me know if this works for you or if further changes are needed!

You

How can i encode hevc to h264 using cuda

ChatGPT

I’ve added a new function, convert_hevc_to_h264_cuda, which allows you to encode an HEVC video to H.264 using NVIDIA CUDA (h264_nvenc). Let me know if you need any further modifications or explanations.

You

make it cpu

    ffmpeg -y -vsync 0 -hwaccel cuda -hwaccel_output_format cuda -i "!input_file!" -c:a copy -c:v hevc_nvenc -cq:v 30 -profile:v main10 -vf "scale_cuda=1280:720, fps=30" "!output_file!"

ChatGPT

I’ve modified the script to use CPU encoding with libx264 for converting HEVC to H.264 and adjusted the scaling and frame rate settings accordingly. Let me know if this resolves your needs or if any further changes are required!