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

simba/assets/lookups/yolo_schematics/yolo_mitra.csv

@@ -6,4 +6,4 @@ right_side
 tail_base
 center
 tail_center
-tail_tip
+tail_tip

simba/mixins/image_mixin.py

@@ -18,6 +18,7 @@ from collections import ChainMap
 import cv2
 import pandas as pd
 from numba import float64, int64, jit, njit, prange, uint8
+from PIL import Image, ImageDraw, ImageFont
 from shapely.geometry import Polygon
 from skimage.metrics import structural_similarity
 
@@ -30,11 +31,12 @@ from simba.utils.checks import (check_file_exist_and_readable, check_float,
 from simba.utils.data import terminate_cpu_pool
 from simba.utils.enums import Defaults, Formats, GeometryEnum, Options
 from simba.utils.errors import ArrayError, FrameRangeError, InvalidInputError
+from simba.utils.lookups import get_fonts
 from simba.utils.printing import SimbaTimer, stdout_success
 from simba.utils.read_write import (find_core_cnt,
                                     find_files_of_filetypes_in_directory,
                                     get_fn_ext, get_video_meta_data,
-                                    read_frm_of_video)
+                                    read_frm_of_video, seconds_to_timestamp)
 
 
 class ImageMixin(object):
@@ -2052,18 +2054,141 @@ class ImageMixin(object):
 
         return denoised_img
 
+    @staticmethod
+    def get_timelapse_img(video_path: Union[str, os.PathLike],
+                          frame_cnt: int = 25,
+                          size: Optional[int] = None,
+                          crop_ratio: int = 50) -> np.ndarray:
 
+        """
+        Creates timelapse image from video.
 
+        .. image:: _static/img/get_timelapse_img.png
+           :width: 600
+           :align: center
 
+        :param Union[str, os.PathLike] video_path: Path to the video to cerate the timelapse image from.
+        :param int frame_cnt: Number of frames to grab from the video. There will be an even interval between each frame.
+        :param Optional[int] size: The total width in pixels of the final timelapse image. If None, uses the video width (adjusted for crop_ratio).
+        :param int crop_ratio: The percent of each original video (from the left) to show.
+        :return np.ndarray: The timelapse image as a numpy array
 
+        :example:
+        >>> img = ImageMixin.get_timelapse_img(video_path=r"E:\troubleshooting\mitra_emergence\project_folder\clip_test\Box1_180mISOcontrol_Females_clipped_progress_bar.mp4", size=100)
+        """
 
+        video_meta = get_video_meta_data(video_path=video_path, raise_error=True)
+        frm_ids = [int(i * video_meta['frame_count'] / frame_cnt) for i in range(frame_cnt)]
+        cap = cv2.VideoCapture(video_path)
+        frms = [read_frm_of_video(video_path=cap, frame_index=x, use_ffmpeg=False) for x in frm_ids]
+
+        effective_video_width = int(video_meta['width'] * (crop_ratio / 100))
+        if size is None:
+            size = effective_video_width
+        per_frame_width_after_crop = size / frame_cnt
+        per_frame_width_before_crop = per_frame_width_after_crop / (crop_ratio / 100)
+        scale_factor = per_frame_width_before_crop / frms[0].shape[1]
+        scaled_frms = [cv2.resize(x, None, fx=scale_factor, fy=scale_factor, interpolation=cv2.INTER_LINEAR) for x in frms]
+        if crop_ratio is not None:
+            scaled_frms = [ImageMixin.segment_img_vertical(img=x, pct=crop_ratio, left=True) for x in scaled_frms]
+        
+        return cv2.hconcat(scaled_frms)
 
+    @staticmethod
+    def create_time_ruler(width: int,
+                          video_path: Union[str, os.PathLike],
+                          height: int = 60,
+                          num_divisions: int = 6,
+                          font: str = 'Arial',
+                          bg_color: Tuple[int, int, int] = (255, 255, 255),
+                          line_color: Tuple[int, int, int] = (128, 128, 128),
+                          text_color: Tuple[int, int, int] = (0, 0, 0),
+                          padding: int = 60,
+                          show_time: bool = True) -> np.ndarray:
+        """
+        Create a horizontal ruler/scale bar with tick marks and labels.
+
+        .. image:: _static/img/create_time_ruler.png
+           :width: 600
+           :align: center
 
+        :param int width: Width of the ruler in pixels (should match timelapse image width if one is used)
+        :param Union[str, os.PathLike] video_path: Path to video file to get metadata from
+        :param int height: Height of the ruler in pixels. Default 60.
+        :param int num_divisions: Number of major divisions on the ruler. Default 6.
+        :param str font: Font name to use for labels. Default 'Algerian'.
+        :param Tuple[int, int, int] bg_color: Background color (R, G, B). Default white.
+        :param Tuple[int, int, int] line_color: Color for tick marks and lines (R, G, B). Default grey.
+        :param Tuple[int, int, int] text_color: Color for text labels (R, G, B). Default black.
+        :param bool show_time: If True, show time labels, else show frame numbers. Default True.
+        :return: Ruler image as numpy array (BGR format for OpenCV compatibility)
+        :rtype: np.ndarray
 
+        :example:
+        >>> ruler = ImageMixin.create_time_ruler(width=1920, video_path='path/to/video.mp4', height=60, num_divisions=6)
+        """
 
-
-
-
+        check_file_exist_and_readable(file_path=video_path)
+        check_int(name='width', value=width, min_value=1, raise_error=True)
+        check_int(name='height', value=height, min_value=1, raise_error=True)
+        check_int(name='num_divisions', value=num_divisions, min_value=1, raise_error=True)
+        check_int(name='padding', value=padding, min_value=0, raise_error=True)
+        check_str(name='font', value=font, allow_blank=False, raise_error=True)
+        check_if_valid_rgb_tuple(data=bg_color, raise_error=True, source=ImageMixin.create_time_ruler.__name__)
+        check_if_valid_rgb_tuple(data=line_color, raise_error=True, source=ImageMixin.create_time_ruler.__name__)
+        check_if_valid_rgb_tuple(data=text_color, raise_error=True, source=ImageMixin.create_time_ruler.__name__)
+
+        video_meta = get_video_meta_data(video_path=video_path, raise_error=True)
+        total_width = width + (2 * padding)
+
+        img = Image.new('RGB', (total_width, height), color=bg_color)
+        draw = ImageDraw.Draw(img)
+        font_dict = get_fonts()
+        try:
+            font_path = font_dict[font]
+            pil_font = ImageFont.truetype(font_path, size=12)
+        except (KeyError, OSError):
+            pil_font = ImageFont.load_default()
+        major_tick_height, half_tick_height = height * 0.6, height * 0.4
+        quarter_tick_height, eighth_tick_height = height * 0.25, height * 0.15
+
+        for i in range(num_divisions + 1):
+            x = padding + int(i * width / num_divisions)
+            draw.line([(x, 0), (x, major_tick_height)], fill=line_color, width=2)
+            if show_time and video_meta['video_length_s'] is not None:
+                seconds_at_division = i * video_meta['video_length_s'] / num_divisions
+                label = seconds_to_timestamp(seconds=seconds_at_division)
+            elif video_meta['frame_count'] is not None:
+                label = str(int(i * video_meta['frame_count'] / num_divisions))
+            else:
+                label = str(i)
+            bbox = draw.textbbox((0, 0), label, font=pil_font)
+            text_width = bbox[2] - bbox[0]
+            if i == 0:
+                draw.text((x, major_tick_height + 5), label, fill=text_color, font=pil_font)
+            elif i == num_divisions:
+                draw.text((x - text_width, major_tick_height + 5), label, fill=text_color, font=pil_font)
+            else:
+                draw.text((x - text_width // 2, major_tick_height + 5), label, fill=text_color, font=pil_font)
+            if i < num_divisions:
+                x_half = padding + int((i + 0.5) * width / num_divisions)
+                draw.line([(x_half, 0), (x_half, half_tick_height)], fill=line_color, width=1)
+                for q in [0.25, 0.75]:
+                    x_quarter = padding + int((i + q) * width / num_divisions)
+                    draw.line([(x_quarter, 0), (x_quarter, quarter_tick_height)], fill=line_color, width=1)
+                for e in [0.125, 0.375, 0.625, 0.875]:
+                    x_eighth = padding + int((i + e) * width / num_divisions)
+                    draw.line([(x_eighth, 0), (x_eighth, eighth_tick_height)], fill=line_color, width=1)
+
+        draw.line([(0, height - 1), (total_width, height - 1)], fill=line_color, width=1)
+        img_bgr = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)
+        return img_bgr
+
+
+# img = ImageMixin.create_time_ruler(width=1920, video_path=r"E:\troubleshooting\mitra_emergence\project_folder\clip_test\Box1_180mISOcontrol_Females_clipped_progress_bar.mp4", height=60, num_divisions=6)
+#
+# cv2.imshow('sadasdas', img)
+# cv2.waitKey(40000)
 
 #x = ImageMixin.get_blob_locations(video_path=r"C:\troubleshooting\RAT_NOR\project_folder\videos\2022-06-20_NOB_DOT_4_downsampled_bg_subtracted.mp4", gpu=True)
 # imgs = ImageMixin().read_all_img_in_dir(dir='/Users/simon/Desktop/envs/simba/troubleshooting/RAT_NOR/project_folder/videos/examples')

simba/model/yolo_fit.py

@@ -1,5 +1,6 @@
 import os
 import sys
+from contextlib import redirect_stderr, redirect_stdout
 
 os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"
 import argparse
@@ -21,7 +22,8 @@ from simba.utils.checks import (check_file_exist_and_readable,
                                 check_valid_boolean, check_valid_device)
 from simba.utils.enums import Options
 from simba.utils.errors import SimBAGPUError, SimBAPAckageVersionError
-from simba.utils.read_write import find_core_cnt
+from simba.utils.printing import stdout_information
+from simba.utils.read_write import find_core_cnt, get_current_time
 from simba.utils.yolo import load_yolo_model
 
 
@@ -108,20 +110,25 @@ class FitYolo():
 
 
     def run(self):
-        model = load_yolo_model(weights_path=self.weights_path,
-                                verbose=self.verbose,
-                                format=self.format,
-                                device=self.device)
-
-        model.train(data=self.model_yaml,
-                    epochs=self.epochs,
-                    project=self.save_path,
-                    batch=self.batch,
-                    plots=self.plots,
-                    imgsz=self.imgsz,
-                    workers=self.workers,
-                    device=self.device,
-                    patience=self.patience)
+        # Temporarily redirect stdout/stderr to terminal to ensure ultralytics output goes to terminal
+        # sys.__stdout__ and sys.__stderr__ are the original terminal streams
+        stdout_information(msg=f'[{get_current_time()}] Please follow the YOLO pose model training in the terminal from where SimBA was launched ...', source=self.__class__.__name__)
+        stdout_information(msg=f'[{get_current_time()}] Results will be stored in the {self.save_path} directory ..', source=self.__class__.__name__)
+        with redirect_stdout(sys.__stdout__), redirect_stderr(sys.__stderr__):
+            model = load_yolo_model(weights_path=self.weights_path,
+                                    verbose=self.verbose,
+                                    format=self.format,
+                                    device=self.device)
+
+            model.train(data=self.model_yaml,
+                        epochs=self.epochs,
+                        project=self.save_path,
+                        batch=self.batch,
+                        plots=self.plots,
+                        imgsz=self.imgsz,
+                        workers=self.workers,
+                        device=self.device,
+                        patience=self.patience)
 
 
 if __name__ == "__main__" and not hasattr(sys, 'ps1'):

simba/model/yolo_pose_inference.py

@@ -34,7 +34,7 @@ from simba.utils.errors import (CountError, InvalidFilepathError,
                                 InvalidFileTypeError, SimBAGPUError,
                                 SimBAPAckageVersionError)
 from simba.utils.lookups import get_current_time
-from simba.utils.printing import SimbaTimer, stdout_success
+from simba.utils.printing import SimbaTimer, stdout_information, stdout_success
 from simba.utils.read_write import (find_files_of_filetypes_in_directory,
                                     get_video_meta_data, recursive_file_search)
 from simba.utils.warnings import FileExistWarning, NoDataFoundWarning
@@ -182,7 +182,12 @@ class YOLOPoseInference():
         results = {}
         class_dict = self.model.names
         timer = SimbaTimer(start=True)
-        print(f'Starting tracking inference for {len(self.video_path)} video(s) ({get_current_time()})... ')
+        if self.save_dir is not None:
+            msg = f'[{get_current_time()}] Starting tracking inference for {len(self.video_path)} video(s). Results will be saved in {self.save_dir} ... '
+        else:
+            msg = f'[{get_current_time()}] Starting tracking inference for {len(self.video_path)} video(s) ... '
+        stdout_information(msg=msg, source=self.__class__.__name__)
+        stdout_information(msg='Follow progress in OS terminal window ...', source=self.__class__.__name__)
         for video_cnt, path in enumerate(self.video_path):
             video_timer = SimbaTimer(start=True)
             _, video_name, _ = get_fn_ext(filepath=path)

simba/roi_tools/roi_utils.py

@@ -17,8 +17,8 @@ from PIL import ImageTk
 from scipy.spatial.distance import cdist
 from shapely.geometry import Polygon
 
-from simba.utils.checks import (check_file_exist_and_readable, check_instance,
-                                check_int, check_str, check_valid_array,
+from simba.utils.checks import (check_file_exist_and_readable, check_int,
+                                check_str, check_valid_array,
                                 check_valid_dataframe, check_valid_tuple,
                                 check_video_and_data_frm_count_align)
 from simba.utils.enums import (ROI_SETTINGS, ConfigKey, Formats, Keys, Options,

simba/sandbox/convert_h264_to_mp4_lossless.py

@@ -0,0 +1,129 @@
+"""
+Convert .h264 files to lossless MP4 format using FFmpeg.
+
+This script converts H.264 raw video files to MP4 container format using
+lossless encoding (copy codec) to preserve quality.
+"""
+import os
+import subprocess
+import glob
+from pathlib import Path
+from typing import List, Union
+
+def check_ffmpeg_available() -> bool:
+    """Check if FFmpeg is available in the system."""
+    try:
+        subprocess.run(['ffmpeg', '-version'], 
+                      stdout=subprocess.PIPE, 
+                      stderr=subprocess.PIPE, 
+                      check=True)
+        return True
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return False
+
+def convert_h264_to_mp4_lossless(input_path: Union[str, Path], 
+                                  output_path: Union[str, Path] = None) -> bool:
+    """
+    Convert a single .h264 file to lossless MP4.
+    
+    :param Union[str, Path] input_path: Path to input .h264 file
+    :param Union[str, Path] output_path: Optional output path. If None, creates output in same directory with .mp4 extension
+    :return: True if conversion successful, False otherwise
+    """
+    input_path = Path(input_path)
+    
+    if not input_path.exists():
+        print(f"[ERROR] File not found: {input_path}")
+        return False
+    
+    if output_path is None:
+        output_path = input_path.with_suffix('.mp4')
+    else:
+        output_path = Path(output_path)
+    
+    if output_path.exists():
+        print(f"[SKIP] Output file already exists: {output_path}")
+        return False
+    
+    # FFmpeg command for lossless conversion (copy codec, no re-encoding)
+    # -c:v copy: Copy video stream without re-encoding (lossless)
+    # -c:a copy: Copy audio stream if present (lossless)
+    # -movflags +faststart: Optimize for web streaming (optional)
+    cmd = [
+        'ffmpeg',
+        '-i', str(input_path),
+        '-c:v', 'copy',  # Copy video codec (lossless)
+        '-c:a', 'copy',  # Copy audio codec if present (lossless)
+        '-y',  # Overwrite output file if exists
+        str(output_path)
+    ]
+    
+    try:
+        print(f"Converting {input_path.name} -> {output_path.name}...")
+        result = subprocess.run(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            check=True,
+            text=True
+        )
+        print(f"  [OK] Successfully converted {input_path.name}")
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"  [ERROR] FFmpeg error for {input_path.name}: {e.stderr}")
+        return False
+    except Exception as e:
+        print(f"  [ERROR] Unexpected error for {input_path.name}: {e}")
+        return False
+
+def convert_all_h264_files(directory: str, 
+                           pattern: str = None) -> None:
+    """
+    Convert all .h264 files in a directory to MP4.
+    
+    :param str directory: Directory containing .h264 files
+    :param str pattern: Optional pattern to match in filename (e.g., '4.03.001_6_2026_01_16_09_15_00_000')
+    """
+    dir_path = Path(directory)
+    
+    if not dir_path.exists():
+        print(f"[ERROR] Directory does not exist: {directory}")
+        return
+    
+    if not check_ffmpeg_available():
+        print("[ERROR] FFmpeg is not available. Please install FFmpeg.")
+        return
+    
+    # Find all .h264 files
+    h264_files = list(dir_path.glob('*.h264'))
+    
+    if pattern:
+        h264_files = [f for f in h264_files if pattern in f.name]
+    
+    if not h264_files:
+        pattern_msg = f" matching pattern '{pattern}'" if pattern else ""
+        print(f"No .h264 files found{pattern_msg} in {directory}")
+        return
+    
+    print(f"Found {len(h264_files)} .h264 file(s) to convert...")
+    
+    successful = 0
+    failed = 0
+    
+    for h264_file in sorted(h264_files):
+        if convert_h264_to_mp4_lossless(h264_file):
+            successful += 1
+        else:
+            failed += 1
+    
+    print(f"\nConversion complete!")
+    print(f"  Successful: {successful}")
+    print(f"  Failed: {failed}")
+    print(f"  Total: {len(h264_files)}")
+
+if __name__ == "__main__":
+    # Convert all .h264 files in the directory
+    directory = r"E:\lp_videos_tar"
+    pattern = None  # Convert all .h264 files, not just matching a pattern
+    
+    convert_all_h264_files(directory, pattern=pattern)

simba/sandbox/extract_and_convert_videos.py

@@ -0,0 +1,257 @@
+"""
+Extract tar files and convert all videos to lossless MP4 format.
+
+This script:
+1. Extracts all .tar, .tar.gz, and .tgz files in a directory
+2. Finds all video files (various formats)
+3. Converts them to lossless MP4 using FFmpeg stream copy
+"""
+import os
+import tarfile
+import glob
+import subprocess
+from pathlib import Path
+from typing import List, Set
+
+# Common video file extensions
+VIDEO_EXTENSIONS = {'.h264', '.avi', '.mov', '.mkv', '.flv', '.m4v', '.mp4', 
+                    '.webm', '.wmv', '.mpg', '.mpeg', '.ts', '.mts', '.m2ts'}
+
+def check_ffmpeg_available() -> bool:
+    """Check if FFmpeg is available in the system."""
+    try:
+        subprocess.run(['ffmpeg', '-version'], 
+                      stdout=subprocess.PIPE, 
+                      stderr=subprocess.PIPE, 
+                      check=True)
+        return True
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return False
+
+def extract_tar_files(directory_path: str, output_dir: str = None) -> List[Path]:
+    """
+    Extracts all .tar, .tar.gz, and .tgz files in a given directory.
+
+    Args:
+        directory_path (str): The path to the directory containing the tar files.
+        output_dir (str, optional): The directory where to extract the contents.
+                                    If None, extracts to the same directory as the tar file.
+                                    Defaults to None.
+    Returns:
+        List[Path]: List of directories where files were extracted
+    """
+    if output_dir is None:
+        output_dir = directory_path
+    
+    dir_path = Path(directory_path)
+    output_path = Path(output_dir)
+    output_path.mkdir(parents=True, exist_ok=True)
+
+    tar_files = []
+    for ext in ['*.tar', '*.tar.gz', '*.tgz']:
+        tar_files.extend(dir_path.glob(ext))
+
+    if not tar_files:
+        print(f"No tar file(s) found in {directory_path}")
+        return []
+
+    print(f"Found {len(tar_files)} tar file(s) to extract...")
+
+    extracted_dirs = []
+    for tar_file_path in tar_files:
+        tar_file = Path(tar_file_path)
+        print(f"Extracting {tar_file.name}...")
+        try:
+            # Extract to a subdirectory named after the tar file (without extension)
+            extract_dir = output_path / tar_file.stem
+            extract_dir.mkdir(parents=True, exist_ok=True)
+            
+            with tarfile.open(tar_file_path, 'r:*') as f:
+                if hasattr(tarfile, 'data_filter'):  # Python 3.12+
+                    f.extractall(path=extract_dir, filter='data')
+                else:
+                    f.extractall(path=extract_dir)
+            print(f"  [OK] Extracted {tar_file.name} to {extract_dir}")
+            extracted_dirs.append(extract_dir)
+        except tarfile.ReadError as e:
+            print(f"  [ERROR] Error extracting {tar_file.name}: {e} (Not a valid tar file or corrupted)")
+        except Exception as e:
+            print(f"  [ERROR] Error extracting {tar_file.name}: {e}")
+    
+    print("\nExtraction complete!")
+    return extracted_dirs
+
+def find_video_files(directory: Path, recursive: bool = True) -> List[Path]:
+    """
+    Find all video files in a directory.
+    
+    Args:
+        directory: Directory to search
+        recursive: If True, search recursively in subdirectories
+    
+    Returns:
+        List of video file paths
+    """
+    video_files = []
+    
+    if recursive:
+        for ext in VIDEO_EXTENSIONS:
+            video_files.extend(directory.rglob(f'*{ext}'))
+    else:
+        for ext in VIDEO_EXTENSIONS:
+            video_files.extend(directory.glob(f'*{ext}'))
+    
+    return sorted(video_files)
+
+def convert_video_to_mp4_lossless(input_path: Path, output_path: Path = None) -> bool:
+    """
+    Convert a video file to lossless MP4 using FFmpeg stream copy.
+    
+    Args:
+        input_path: Path to input video file
+        output_path: Optional output path. If None, creates output in same directory with .mp4 extension
+    
+    Returns:
+        True if conversion successful, False otherwise
+    """
+    if not input_path.exists():
+        print(f"[ERROR] File not found: {input_path}")
+        return False
+    
+    if output_path is None:
+        output_path = input_path.with_suffix('.mp4')
+    else:
+        output_path = Path(output_path)
+    
+    # Skip if already MP4
+    if input_path.suffix.lower() == '.mp4':
+        print(f"[SKIP] File is already MP4: {input_path.name}")
+        return False
+    
+    if output_path.exists():
+        print(f"[SKIP] Output file already exists: {output_path.name}")
+        return False
+    
+    # FFmpeg command for lossless conversion (stream copy)
+    # -c:v copy: Copy video stream without re-encoding (lossless)
+    # -c:a copy: Copy audio stream if present (lossless)
+    # -y: Overwrite output file if exists
+    cmd = [
+        'ffmpeg',
+        '-i', str(input_path),
+        '-c:v', 'copy',  # Copy video codec (lossless)
+        '-c:a', 'copy',  # Copy audio codec if present (lossless)
+        '-y',
+        str(output_path)
+    ]
+    
+    try:
+        print(f"Converting {input_path.name} -> {output_path.name}...")
+        result = subprocess.run(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            check=True,
+            text=True
+        )
+        print(f"  [OK] Successfully converted {input_path.name}")
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"  [ERROR] FFmpeg error for {input_path.name}")
+        # Print first few lines of stderr for debugging
+        stderr_lines = e.stderr.split('\n')[:5]
+        for line in stderr_lines:
+            if line.strip():
+                print(f"    {line}")
+        return False
+    except Exception as e:
+        print(f"  [ERROR] Unexpected error for {input_path.name}: {e}")
+        return False
+
+def extract_and_convert_videos(directory_path: str, 
+                               extract_to_subdirs: bool = True,
+                               convert_recursive: bool = True) -> None:
+    """
+    Extract all tar files and convert all videos to lossless MP4.
+    
+    Args:
+        directory_path: Directory containing tar files
+        extract_to_subdirs: If True, extract each tar to its own subdirectory
+        convert_recursive: If True, search for videos recursively in extracted directories
+    """
+    dir_path = Path(directory_path)
+    
+    if not dir_path.exists():
+        print(f"[ERROR] Directory does not exist: {directory_path}")
+        return
+    
+    if not check_ffmpeg_available():
+        print("[ERROR] FFmpeg is not available. Please install FFmpeg.")
+        return
+    
+    # Step 1: Extract tar files
+    print("=" * 60)
+    print("STEP 1: Extracting tar files...")
+    print("=" * 60)
+    extracted_dirs = extract_tar_files(directory_path, 
+                                       output_dir=directory_path if extract_to_subdirs else None)
+    
+    # Step 2: Find all video files
+    print("\n" + "=" * 60)
+    print("STEP 2: Finding video files...")
+    print("=" * 60)
+    
+    # Search in extracted directories and the main directory
+    search_dirs = extracted_dirs if extracted_dirs else [dir_path]
+    all_video_files = []
+    
+    for search_dir in search_dirs:
+        videos = find_video_files(search_dir, recursive=convert_recursive)
+        all_video_files.extend(videos)
+        if videos:
+            print(f"Found {len(videos)} video file(s) in {search_dir}")
+    
+    # Also search in main directory if we extracted to subdirs
+    if extract_to_subdirs and dir_path not in search_dirs:
+        videos = find_video_files(dir_path, recursive=False)
+        all_video_files.extend(videos)
+        if videos:
+            print(f"Found {len(videos)} video file(s) in {dir_path}")
+    
+    if not all_video_files:
+        print("No video files found to convert.")
+        return
+    
+    print(f"\nTotal video files found: {len(all_video_files)}")
+    
+    # Step 3: Convert videos to MP4
+    print("\n" + "=" * 60)
+    print("STEP 3: Converting videos to lossless MP4...")
+    print("=" * 60)
+    
+    successful = 0
+    failed = 0
+    skipped = 0
+    
+    for video_file in all_video_files:
+        result = convert_video_to_mp4_lossless(video_file)
+        if result is True:
+            successful += 1
+        elif result is False and video_file.suffix.lower() == '.mp4':
+            skipped += 1
+        else:
+            failed += 1
+    
+    print("\n" + "=" * 60)
+    print("Conversion complete!")
+    print("=" * 60)
+    print(f"  Successful: {successful}")
+    print(f"  Failed: {failed}")
+    print(f"  Skipped (already MP4): {skipped}")
+    print(f"  Total: {len(all_video_files)}")
+
+if __name__ == "__main__":
+    target_directory = r"E:\new_tars"
+    extract_and_convert_videos(target_directory, 
+                               extract_to_subdirs=True,
+                               convert_recursive=True)