simba-uw-tf-dev 4.7.4__py3-none-any.whl → 4.7.6__py3-none-any.whl

simba/sandbox/av1.py

@@ -0,0 +1,5 @@
+from simba.video_processors.video_processing import convert_to_webm
+
+
+
+convert_to_webm(path=r"D:\troubleshooting\batch_fps\2025-09-08_13-06-38-AloneH-1.mp4", codec='vp9')

simba/sandbox/denoise_hqdn3d.py

@@ -0,0 +1,266 @@
+"""
+Function to apply hqdn3d (high-quality denoise 3D) filter to a video file using ffmpeg.
+
+The hqdn3d filter is a spatial-temporal denoise filter that reduces noise while preserving
+video quality and details.
+"""
+
+import os
+import subprocess
+from typing import Union, Optional
+
+from simba.utils.checks import (
+    check_ffmpeg_available,
+    check_file_exist_and_readable,
+    check_if_dir_exists,
+    check_nvidea_gpu_available
+)
+from simba.utils.errors import FFMPEGCodecGPUError
+from simba.utils.printing import SimbaTimer, stdout_success
+from simba.utils.read_write import get_fn_ext
+
+
+def denoise_bm3d(file_path: Union[str, os.PathLike],
+                 save_path: Optional[Union[str, os.PathLike]] = None,
+                 gpu: Optional[bool] = False,
+                 quality: int = 60,
+                 sigma: Optional[float] = None,
+                 block: Optional[int] = None,
+                 bstep: Optional[int] = None,
+                 group: Optional[int] = None) -> None:
+    """
+    Apply bm3d (Block-Matching 3D) denoise filter to a video file.
+
+    BM3D is a more advanced denoising algorithm than hqdn3d, often better at removing texture
+    and background noise while preserving details. It's slower but produces better results.
+    
+    **For removing background texture (e.g., sawdust pellets):**
+    - **sigma** is MOST IMPORTANT - controls noise level/denoising strength (higher = more denoising)
+    - **block** - block size (default: 4, larger = more smoothing but slower)
+    - **bstep** - block step (default: 4, smaller = better quality but slower)
+    - **group** - group size (default: 1, larger = better denoising but slower)
+    
+    :param Union[str, os.PathLike] file_path: Path to input video file.
+    :param Optional[Union[str, os.PathLike]] save_path: Optional save location for the denoised video. If None, then the new video is saved in the same directory as the input video with the ``_bm3d_denoised`` suffix.
+    :param Optional[bool] gpu: If True, use NVIDEA GPU codecs. Default False.
+    :param int quality: Video quality percentage (1-100). Higher values = higher quality. Default 60.
+    :param Optional[float] sigma: Noise level/denoising strength (default: 1.0). **MOST IMPORTANT** - higher values = more denoising. For background texture removal, try 5-20.
+    :param Optional[int] block: Block size (default: 4). Larger values = more smoothing but slower processing.
+    :param Optional[int] bstep: Block step (default: 4). Smaller values = better quality but slower.
+    :param Optional[int] group: Group size (default: 1). Larger values = better denoising but slower.
+    :returns: None. If save_path is not passed, the result is stored in the same directory as the input file with the ``_bm3d_denoised.mp4`` suffix.
+    
+    .. note::
+       Codec is automatically selected: libx264 for CPU encoding (ignored if gpu=True).
+       BM3D is slower than hqdn3d but often produces better results for texture removal.
+       For background texture removal, start with sigma=10-15 and adjust from there.
+
+    :example:
+    >>> denoise_bm3d(file_path='project_folder/videos/Video_1.avi', sigma=10)
+    >>> denoise_bm3d(file_path='/Users/simon/Desktop/test/noisy_video.mp4', sigma=15, block=8, quality=80)
+    """
+
+    check_ffmpeg_available(raise_error=True)
+    if gpu and not check_nvidea_gpu_available():
+        raise FFMPEGCodecGPUError(
+            msg="No GPU found (as evaluated by nvidea-smi returning None)",
+            source=denoise_bm3d.__name__
+        )
+    
+    timer = SimbaTimer(start=True)
+    check_file_exist_and_readable(file_path=file_path)
+    
+    dir, file_name, ext = get_fn_ext(filepath=file_path)
+    
+    if save_path is None:
+        save_name = os.path.join(dir, f"{file_name}_bm3d_denoised.mp4")
+    else:
+        check_if_dir_exists(
+            in_dir=os.path.dirname(save_path),
+            source=f'{denoise_bm3d.__name__} save_path',
+            create_if_not_exist=True
+        )
+        save_name = save_path
+    
+    # Set default bm3d parameters if not provided
+    sigma_val = sigma if sigma is not None else 1.0
+    block_val = block if block is not None else 4
+    bstep_val = bstep if bstep is not None else 4
+    group_val = group if group is not None else 1
+    
+    # Check if bm3d filter is available first (may not be compiled into all ffmpeg builds)
+    check_cmd = 'ffmpeg -filters 2>&1 | findstr /i "bm3d"'
+    result = subprocess.run(check_cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True)
+    if not result.stdout.strip():
+        raise FFMPEGCodecGPUError(
+            msg="BM3D filter not available in your ffmpeg build. BM3D may not be compiled into your ffmpeg installation. Try using hqdn3d or nlmeans instead.",
+            source=denoise_bm3d.__name__
+        )
+    
+    # Build bm3d filter string with named parameters
+    # Format: bm3d=sigma=value:block=value:bstep=value:group=value
+    filter_str = f'bm3d=sigma={sigma_val}:block={block_val}:bstep={bstep_val}:group={group_val}'
+    
+    # Build ffmpeg command with bm3d filter
+    if gpu:
+        # GPU encoding with bm3d filter
+        from simba.utils.lookups import quality_pct_to_crf
+        quality_crf = quality_pct_to_crf(pct=int(quality))
+        cmd = f'ffmpeg -hwaccel auto -c:v h264_cuvid -i "{file_path}" -vf {filter_str} -rc vbr -cq {quality_crf} -c:v h264_nvenc -c:a copy "{save_name}" -loglevel error -stats -hide_banner -y'
+    else:
+        # CPU encoding with bm3d filter
+        from simba.utils.lookups import quality_pct_to_crf
+        quality_crf = quality_pct_to_crf(pct=int(quality))
+        cmd = f'ffmpeg -i "{file_path}" -vf {filter_str} -c:v libx264 -crf {quality_crf} -c:a copy "{save_name}" -loglevel error -stats -hide_banner -y'
+    
+    print(f"Applying bm3d denoise filter (sigma={sigma_val}, block={block_val}, bstep={bstep_val}, group={group_val}) to {file_name}...")
+    print(f"Command: {cmd}")
+    
+    process = subprocess.run(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True)
+    if process.returncode != 0:
+        error_msg = process.stderr if process.stderr else (process.stdout if process.stdout else "Unknown error")
+        print(f"Error output: {error_msg}")
+        raise FFMPEGCodecGPUError(
+            msg=f"FFmpeg bm3d filter failed: {error_msg}",
+            source=denoise_bm3d.__name__
+        )
+    timer.stop_timer()
+    stdout_success(
+        msg=f"SIMBA COMPLETE: Video denoised with BM3D! {save_name} generated!",
+        elapsed_time=timer.elapsed_time_str,
+        source=denoise_bm3d.__name__
+    )
+
+
+def denoise_hqdn3d(file_path: Union[str, os.PathLike],
+                   save_path: Optional[Union[str, os.PathLike]] = None,
+                   gpu: Optional[bool] = False,
+                   quality: int = 60,
+                   luma_spatial: Optional[float] = None,
+                   luma_temporal: Optional[float] = None,
+                   chroma_spatial: Optional[float] = None,
+                   chroma_temporal: Optional[float] = None) -> None:
+    """
+    Apply hqdn3d (high-quality denoise 3D) filter to a video file.
+
+    The hqdn3d filter has 4 parameters that control denoising strength:
+    - Higher values = more denoising but may blur details
+    - Lower values = less denoising but preserves more detail
+    
+    **For removing background texture (e.g., sawdust pellets):**
+    - **luma_spatial** and **chroma_spatial** are MOST IMPORTANT - these control spatial smoothing within each frame
+    - **luma_temporal** and **chroma_temporal** are less critical - these smooth across frames (helpful for motion noise, not static background)
+    - For background texture removal, focus on high spatial values (50-200+) and moderate temporal values (10-20)
+    
+    .. note::
+       hqdn3d may not be ideal for removing static background texture. Consider background subtraction or blur filters instead.
+       For background texture removal, try: luma_spatial=100-200, chroma_spatial=100-200, luma_temporal=10-20, chroma_temporal=10-20
+    
+    :param Union[str, os.PathLike] file_path: Path to input video file.
+    :param Optional[Union[str, os.PathLike]] save_path: Optional save location for the denoised video. If None, then the new video is saved in the same directory as the input video with the ``_denoised`` suffix.
+    :param Optional[bool] gpu: If True, use NVIDEA GPU codecs. Default False.
+    :param int quality: Video quality percentage (1-100). Higher values = higher quality. Default 60.
+    :param Optional[float] luma_spatial: Spatial luma strength (default: 4.0). Controls detail preservation in luma channel. **MOST IMPORTANT for background texture removal.**
+    :param Optional[float] luma_temporal: Temporal luma strength (default: 3.0). Controls motion blur artifacts in luma channel. Less critical for static background.
+    :param Optional[float] chroma_spatial: Spatial chroma strength (default: 3.0). Controls detail preservation in chroma channel. **MOST IMPORTANT for background texture removal.**
+    :param Optional[float] chroma_temporal: Temporal chroma strength (default: 6.0). Controls motion blur artifacts in chroma channel. Less critical for static background.
+    :returns: None. If save_path is not passed, the result is stored in the same directory as the input file with the ``_denoised.mp4`` suffix.
+    
+    .. note::
+       Codec is automatically selected: libx264 for CPU encoding (ignored if gpu=True).
+       Default parameters are conservative. For stronger denoising, try: luma_spatial=8, luma_temporal=6, chroma_spatial=6, chroma_temporal=9
+       For very noisy videos, you may need values of 10-15 or higher.
+
+    :example:
+    >>> denoise_hqdn3d(file_path='project_folder/videos/Video_1.avi')
+    >>> denoise_hqdn3d(file_path='/Users/simon/Desktop/test/noisy_video.mp4', luma_spatial=8, luma_temporal=6, quality=80)
+    >>> # For removing background texture (sawdust pellets):
+    >>> denoise_hqdn3d(file_path='video.mp4', luma_spatial=150, chroma_spatial=150, luma_temporal=15, chroma_temporal=15)
+    """
+
+    check_ffmpeg_available(raise_error=True)
+    if gpu and not check_nvidea_gpu_available():
+        raise FFMPEGCodecGPUError(
+            msg="No GPU found (as evaluated by nvidea-smi returning None)",
+            source=denoise_hqdn3d.__name__
+        )
+    
+    timer = SimbaTimer(start=True)
+    check_file_exist_and_readable(file_path=file_path)
+    
+    dir, file_name, ext = get_fn_ext(filepath=file_path)
+    
+    if save_path is None:
+        save_name = os.path.join(dir, f"{file_name}_denoised.mp4")
+    else:
+        check_if_dir_exists(
+            in_dir=os.path.dirname(save_path),
+            source=f'{denoise_hqdn3d.__name__} save_path',
+            create_if_not_exist=True
+        )
+        save_name = save_path
+    
+    # Set default hqdn3d parameters if not provided
+    luma_sp = luma_spatial if luma_spatial is not None else 4.0
+    luma_tmp = luma_temporal if luma_temporal is not None else 3.0
+    chroma_sp = chroma_spatial if chroma_spatial is not None else 3.0
+    chroma_tmp = chroma_temporal if chroma_temporal is not None else 6.0
+    
+    # Build hqdn3d filter string with parameters
+    # Format: hqdn3d=luma_spatial:chroma_spatial:luma_temporal:chroma_temporal
+    filter_str = f'hqdn3d={luma_sp}:{chroma_sp}:{luma_tmp}:{chroma_tmp}'
+    
+    # Build ffmpeg command with hqdn3d filter
+    if gpu:
+        # GPU encoding with hqdn3d filter
+        from simba.utils.lookups import quality_pct_to_crf
+        quality_crf = quality_pct_to_crf(pct=int(quality))
+        cmd = f'ffmpeg -hwaccel auto -c:v h264_cuvid -i "{file_path}" -vf {filter_str} -rc vbr -cq {quality_crf} -c:v h264_nvenc -c:a copy "{save_name}" -loglevel error -stats -hide_banner -y'
+    else:
+        # CPU encoding with hqdn3d filter
+        from simba.utils.lookups import quality_pct_to_crf
+        quality_crf = quality_pct_to_crf(pct=int(quality))
+        cmd = f'ffmpeg -i "{file_path}" -vf {filter_str} -c:v libx264 -crf {quality_crf} -c:a copy "{save_name}" -loglevel error -stats -hide_banner -y'
+    
+    print(f"Applying hqdn3d denoise filter (luma_spatial={luma_sp}, chroma_spatial={chroma_sp}, luma_temporal={luma_tmp}, chroma_temporal={chroma_tmp}) to {file_name}...")
+    
+    subprocess.call(cmd, shell=True, stdout=subprocess.PIPE)
+    timer.stop_timer()
+    stdout_success(
+        msg=f"SIMBA COMPLETE: Video denoised! {save_name} generated!",
+        elapsed_time=timer.elapsed_time_str,
+        source=denoise_hqdn3d.__name__
+    )
+
+#
+# For removing background texture (sawdust pellets):
+# Focus on HIGH spatial values (most important) and moderate temporal values
+# Spatial parameters blur within each frame - critical for static background texture
+# Temporal parameters smooth across frames - less critical for static background
+# denoise_hqdn3d(
+#     file_path=r"E:\open_video\open_field_4\2.mp4",
+#     luma_spatial=200,      # VERY HIGH - most important for background texture removal
+#     luma_temporal=40,     # Moderate - 200 is overkill for static background
+#     chroma_spatial=200,    # VERY HIGH - most important for background texture removal
+#     chroma_temporal=40    # Moderate - 200 is overkill for static background
+# )
+
+# BM3D - Better for texture removal, slower but often produces better results
+# sigma is the most important parameter - controls denoising strength
+# denoise_bm3d(
+#     file_path=r"E:\open_video\open_field_4\2.mp4",
+#     sigma=15,              # High denoising strength for background texture removal
+#     block=8,               # Larger blocks = more smoothing
+#     bstep=2,               # Smaller step = better quality
+#     group=1                # Default group size
+# )
+#
+# # BM3D - Better for texture removal, slower but often produces better results
+# # sigma is the most important parameter - controls denoising strength
+# denoise_bm3d(
+#     file_path=r"E:\open_video\open_field_4\2.mp4",
+#     sigma=15,              # High denoising strength for background texture removal
+#     block=8,               # Larger blocks = more smoothing
+#     bstep=2,               # Smaller step = better quality
+#     group=1                # Default group size
+# )

simba/sandbox/extract_random_frames.py

@@ -0,0 +1,126 @@
+"""
+Function to extract random N frames from all videos in a directory.
+
+Each frame is saved as videoname_framenumber.png in the same directory as the video.
+"""
+
+import os
+import random
+from typing import Union, Optional
+import numpy as np
+import cv2
+
+from simba.utils.checks import (
+    check_if_dir_exists,
+    check_int,
+    check_file_exist_and_readable
+)
+from simba.utils.read_write import (
+    get_video_meta_data,
+    find_all_videos_in_directory,
+    read_frm_of_video,
+    get_fn_ext
+)
+from simba.utils.printing import SimbaTimer, stdout_success
+
+
+def extract_random_frames_from_directory(
+    directory: Union[str, os.PathLike],
+    n_frames: int = 10,
+    save_dir: Optional[Union[str, os.PathLike]] = None,
+    verbose: Optional[bool] = True
+) -> None:
+    """
+    Extract random N frames from all videos in a directory.
+
+    For each video, randomly samples N frames and saves them as individual PNG files.
+    Frames are saved with the naming convention: videoname_framenumber.png
+
+    :param Union[str, os.PathLike] directory: Path to directory containing video files.
+    :param int n_frames: Number of random frames to extract from each video. Default: 10.
+    :param Optional[Union[str, os.PathLike]] save_dir: Optional directory where extracted frames will be saved. 
+        If None, frames are saved in the same directory as each video file. Default: None.
+    :param Optional[bool] verbose: If True, prints progress messages during extraction. Default: True.
+    :return: None. Frames are saved to disk.
+
+    :example:
+    >>> extract_random_frames_from_directory(directory='project_folder/videos', n_frames=20)
+    >>> extract_random_frames_from_directory(directory='/Users/simon/Desktop/videos', n_frames=5, save_dir='/Users/simon/Desktop/frames')
+    """
+
+    timer = SimbaTimer(start=True)
+    check_if_dir_exists(in_dir=directory, source=extract_random_frames_from_directory.__name__)
+    check_int(name="n_frames", value=n_frames, min_value=1)
+    
+    # Find all videos in directory
+    video_paths = find_all_videos_in_directory(
+        directory=directory,
+        as_dict=False,
+        raise_error=True
+    )
+    
+    if not video_paths or video_paths == ["No videos found"]:
+        raise ValueError(f"No videos found in directory: {directory}")
+    
+    total_frames_extracted = 0
+    
+    for video_cnt, video_name in enumerate(video_paths):
+        video_path = os.path.join(directory, video_name)
+        check_file_exist_and_readable(file_path=video_path)
+        
+        # Get video metadata
+        video_meta_data = get_video_meta_data(video_path=video_path)
+        total_frames = video_meta_data["frame_count"]
+        _, video_name_only, _ = get_fn_ext(filepath=video_path)  # Returns (directory, filename, extension)
+        
+        # Determine save directory
+        if save_dir is None:
+            video_save_dir = directory  # Save to the same directory as the videos
+        else:
+            video_save_dir = save_dir
+        
+        # Create save directory if it doesn't exist
+        if not os.path.exists(video_save_dir):
+            os.makedirs(video_save_dir)
+        
+        # Randomly sample N frames (or all frames if video has fewer than N frames)
+        n_samples = min(n_frames, total_frames)
+        if total_frames < n_frames:
+            if verbose:
+                print(f"Video {video_name_only} has only {total_frames} frames. Extracting all {total_frames} frames.")
+            selected_frames = list(range(total_frames))
+        else:
+            selected_frames = sorted(random.sample(range(total_frames), n_samples))
+        
+        # Extract and save frames
+        cap = cv2.VideoCapture(video_path)
+        for frame_idx, frame_number in enumerate(selected_frames):
+            # Seek to the correct frame
+            cap.set(cv2.CAP_PROP_POS_FRAMES, frame_number)
+            ret, frame = cap.read()
+            
+            if not ret:
+                if verbose:
+                    print(f"Warning: Could not read frame {frame_number} from {video_name_only}. Skipping...")
+                continue
+            
+            # Save frame with naming convention: videoname_framenumber.png
+            # video_name_only is the video filename without extension
+            save_path = os.path.join(video_save_dir, f"{video_name_only}_{frame_number}.png")
+            cv2.imwrite(save_path, frame, [cv2.IMWRITE_PNG_COMPRESSION, 3])
+            total_frames_extracted += 1
+            
+            if verbose:
+                print(f"Video {video_cnt + 1}/{len(video_paths)}: Frame {frame_number} saved from {video_name_only} ({frame_idx + 1}/{len(selected_frames)})")
+        
+        cap.release()
+    
+    timer.stop_timer()
+    stdout_success(
+        msg=f"SIMBA COMPLETE: Extracted {total_frames_extracted} random frames from {len(video_paths)} video(s)!",
+        elapsed_time=timer.elapsed_time_str,
+        source=extract_random_frames_from_directory.__name__
+    )
+
+
+extract_random_frames_from_directory(directory=r"D:\maplight_tg2576_yolo\videos", n_frames=35, save_dir=r'D:\maplight_tg2576_yolo\frames')

simba/sandbox/remove_end_of_video.py

@@ -1,80 +1,80 @@
-"""
-Function to remove N seconds from the end of a video file.
-
-Similar to simba.video_processors.video_processing.remove_beginning_of_video
-but removes from the end instead of the beginning.
-"""
-
-import os
-import subprocess
-from typing import Union, Optional
-
-from simba.utils.checks import (
-    check_ffmpeg_available,
-    check_file_exist_and_readable,
-    check_int,
-    check_if_dir_exists,
-    check_nvidea_gpu_available
-)
-from simba.utils.errors import FFMPEGCodecGPUError, InvalidInputError
-from simba.utils.printing import SimbaTimer, stdout_success
-from simba.utils.read_write import get_fn_ext, get_video_meta_data
-from simba.utils.lookups import quality_pct_to_crf
-
-
-def remove_end_of_video(file_path: Union[str, os.PathLike],
-                       time: int,
-                       quality: int = 60,
-                       save_path: Optional[Union[str, os.PathLike]] = None,
-                       gpu: Optional[bool] = False) -> None:
-    """
-    Remove N seconds from the end of a video file.
-
-    :param Union[str, os.PathLike] file_path: Path to video file
-    :param int time: Number of seconds to remove from the end of the video.
-    :param int quality: Video quality percentage (1-100). Higher values = higher quality. Default 60.
-    :param Optional[Union[str, os.PathLike]] save_path: Optional save location for the shortened video. If None, then the new video is saved in the same directory as the input video with the ``_shortened`` suffix.
-    :param Optional[bool] gpu: If True, use NVIDEA GPU codecs. Default False.
-    :returns: None. If save_path is not passed, the result is stored in the same directory as the input file with the ``_shorten.mp4`` suffix.
-    
-    .. note::
-       Codec is automatically selected: libx264 for CPU encoding (ignored if gpu=True).
-
-    :example:
-    >>> _ = remove_end_of_video(file_path='project_folder/videos/Video_1.avi', time=10)
-    >>> remove_end_of_video(file_path=f'/Users/simon/Desktop/imgs_4/test/blahhhh.mp4', save_path='/Users/simon/Desktop/imgs_4/test/CUT.mp4', time=3)
-    """
-
-    check_ffmpeg_available(raise_error=True)
-    if gpu and not check_nvidea_gpu_available():
-        raise FFMPEGCodecGPUError(msg="No GPU found (as evaluated by nvidea-smi returning None)", source=remove_end_of_video.__name__)
-    timer = SimbaTimer(start=True)
-    check_file_exist_and_readable(file_path=file_path)
-    video_meta_data = get_video_meta_data(video_path=file_path)
-    check_int(name="Cut time", value=time, min_value=1)
-    check_int(name=f'{remove_end_of_video.__name__} quality', value=quality, min_value=1, max_value=100, raise_error=True)
-    quality_crf = quality_pct_to_crf(pct=int(quality))
-    time = int(time)
-    dir, file_name, ext = get_fn_ext(filepath=file_path)
-    if video_meta_data['video_length_s'] <= time:
-        raise InvalidInputError(msg=f"The cut time {time}s is invalid for video {file_name} with length {video_meta_data['video_length_s']}s", source=remove_end_of_video.__name__)
-    if save_path is None:
-        save_name = os.path.join(dir, f"{file_name}_shorten.mp4")
-    else:
-        check_if_dir_exists(in_dir=os.path.dirname(save_path), source=f'{remove_end_of_video.__name__} save_path', create_if_not_exist=True)
-        save_name = save_path
-    duration = video_meta_data['video_length_s'] - time
-    if gpu:
-        cmd = f'ffmpeg -hwaccel auto -c:v h264_cuvid -i "{file_path}" -t {duration} -rc vbr -cq {quality_crf} -c:v h264_nvenc -c:a aac "{save_name}" -loglevel error -stats -hide_banner -y'
-    else:
-        cmd = f'ffmpeg -i "{file_path}" -t {duration} -c:v libx264 -crf {quality_crf} -c:a aac "{save_name}" -loglevel error -stats -hide_banner -y'
-    print(f"Removing final {time}s from {file_name}... ")
-    subprocess.call(cmd, shell=True, stdout=subprocess.PIPE)
-    timer.stop_timer()
-    stdout_success(msg=f"SIMBA COMPLETE: Video converted! {save_name} generated!", elapsed_time=timer.elapsed_time_str, source=remove_end_of_video.__name__)
-
-
-if __name__ == "__main__":
-    # Example usage
-    # remove_end_of_video(file_path='path/to/video.mp4', time=10)
-    pass
+"""
+Function to remove N seconds from the end of a video file.
+
+Similar to simba.video_processors.video_processing.remove_beginning_of_video
+but removes from the end instead of the beginning.
+"""
+
+import os
+import subprocess
+from typing import Union, Optional
+
+from simba.utils.checks import (
+    check_ffmpeg_available,
+    check_file_exist_and_readable,
+    check_int,
+    check_if_dir_exists,
+    check_nvidea_gpu_available
+)
+from simba.utils.errors import FFMPEGCodecGPUError, InvalidInputError
+from simba.utils.printing import SimbaTimer, stdout_success
+from simba.utils.read_write import get_fn_ext, get_video_meta_data
+from simba.utils.lookups import quality_pct_to_crf
+
+
+def remove_end_of_video(file_path: Union[str, os.PathLike],
+                       time: int,
+                       quality: int = 60,
+                       save_path: Optional[Union[str, os.PathLike]] = None,
+                       gpu: Optional[bool] = False) -> None:
+    """
+    Remove N seconds from the end of a video file.
+
+    :param Union[str, os.PathLike] file_path: Path to video file
+    :param int time: Number of seconds to remove from the end of the video.
+    :param int quality: Video quality percentage (1-100). Higher values = higher quality. Default 60.
+    :param Optional[Union[str, os.PathLike]] save_path: Optional save location for the shortened video. If None, then the new video is saved in the same directory as the input video with the ``_shortened`` suffix.
+    :param Optional[bool] gpu: If True, use NVIDEA GPU codecs. Default False.
+    :returns: None. If save_path is not passed, the result is stored in the same directory as the input file with the ``_shorten.mp4`` suffix.
+    
+    .. note::
+       Codec is automatically selected: libx264 for CPU encoding (ignored if gpu=True).
+
+    :example:
+    >>> _ = remove_end_of_video(file_path='project_folder/videos/Video_1.avi', time=10)
+    >>> remove_end_of_video(file_path=f'/Users/simon/Desktop/imgs_4/test/blahhhh.mp4', save_path='/Users/simon/Desktop/imgs_4/test/CUT.mp4', time=3)
+    """
+
+    check_ffmpeg_available(raise_error=True)
+    if gpu and not check_nvidea_gpu_available():
+        raise FFMPEGCodecGPUError(msg="No GPU found (as evaluated by nvidea-smi returning None)", source=remove_end_of_video.__name__)
+    timer = SimbaTimer(start=True)
+    check_file_exist_and_readable(file_path=file_path)
+    video_meta_data = get_video_meta_data(video_path=file_path)
+    check_int(name="Cut time", value=time, min_value=1)
+    check_int(name=f'{remove_end_of_video.__name__} quality', value=quality, min_value=1, max_value=100, raise_error=True)
+    quality_crf = quality_pct_to_crf(pct=int(quality))
+    time = int(time)
+    dir, file_name, ext = get_fn_ext(filepath=file_path)
+    if video_meta_data['video_length_s'] <= time:
+        raise InvalidInputError(msg=f"The cut time {time}s is invalid for video {file_name} with length {video_meta_data['video_length_s']}s", source=remove_end_of_video.__name__)
+    if save_path is None:
+        save_name = os.path.join(dir, f"{file_name}_shorten.mp4")
+    else:
+        check_if_dir_exists(in_dir=os.path.dirname(save_path), source=f'{remove_end_of_video.__name__} save_path', create_if_not_exist=True)
+        save_name = save_path
+    duration = video_meta_data['video_length_s'] - time
+    if gpu:
+        cmd = f'ffmpeg -hwaccel auto -c:v h264_cuvid -i "{file_path}" -t {duration} -rc vbr -cq {quality_crf} -c:v h264_nvenc -c:a aac "{save_name}" -loglevel error -stats -hide_banner -y'
+    else:
+        cmd = f'ffmpeg -i "{file_path}" -t {duration} -c:v libx264 -crf {quality_crf} -c:a aac "{save_name}" -loglevel error -stats -hide_banner -y'
+    print(f"Removing final {time}s from {file_name}... ")
+    subprocess.call(cmd, shell=True, stdout=subprocess.PIPE)
+    timer.stop_timer()
+    stdout_success(msg=f"SIMBA COMPLETE: Video converted! {save_name} generated!", elapsed_time=timer.elapsed_time_str, source=remove_end_of_video.__name__)
+
+
+if __name__ == "__main__":
+    # Example usage
+    # remove_end_of_video(file_path='path/to/video.mp4', time=10)
+    pass