OTVision 0.6.6__py3-none-any.whl → 0.6.8__py3-none-any.whl

OTVision/plugin/ffmpeg_video_writer.py

@@ -0,0 +1,300 @@
+import logging
+from enum import IntEnum, StrEnum
+from pathlib import Path
+from subprocess import PIPE, Popen, TimeoutExpired
+from threading import Thread
+from typing import Callable, Generator
+
+import ffmpeg
+from numpy import ndarray
+
+from OTVision.application.event.new_video_start import NewVideoStartEvent
+from OTVision.detect.detected_frame_buffer import FlushEvent
+from OTVision.domain.frame import Frame, FrameKeys
+from OTVision.domain.video_writer import VideoWriter
+from OTVision.helpers.log import LOGGER_NAME
+from OTVision.helpers.machine import ON_WINDOWS
+
+VideoSaveLocationStrategy = Callable[[str], str]
+
+BUFFER_SIZE_100MB = 10**8
+DEFAULT_CRF = 23
+VIDEO_SAVE_FILE_POSTFIX = "_processed"
+
+log = logging.getLogger(LOGGER_NAME)
+
+
+class VideoCodec(StrEnum):
+    """Enum of possible video codecs to be used with ffmpeg
+
+    Attributes:
+        H264_SOFTWARE: Software-based H.264 encoder.
+        H264_NVENC: NVIDIA GPU-based H.264 encoder.
+        H264_QSV: Intel Quick Sync Video encoder.
+        H264_VAAPI: Intel/AMD GPU-based H.264 encoder.
+        H264_VIDEOTOOLBOX: macOS hardware encoder.
+    """
+
+    H264_SOFTWARE = "libx264"
+    H264_NVENC = "h264_nvenc"
+    H264_QSV = "h264_qsv"
+    H264_VAAPI = "h264_vaapi"
+    H264_VIDEOTOOLBOX = "h264_videotoolbox"
+
+    @staticmethod
+    def as_list() -> list[str]:
+        return list(VideoCodec.__members__.values())
+
+
+class VideoFormat(StrEnum):
+    RAW = "rawvideo"
+    MP4 = "mp4"
+
+    @staticmethod
+    def as_list() -> list[str]:
+        return list(VideoFormat.__members__.values())
+
+
+class PixelFormat(StrEnum):
+    YUV420P = "yuv420p"  # compatible with most players for H.264
+    RGB24 = "rgb24"
+    BGR24 = "bgr24"
+
+    @staticmethod
+    def as_list() -> list[str]:
+        return list(PixelFormat.__members__.values())
+
+
+class EncodingSpeed(StrEnum):
+    ULTRA_FAST = "ultrafast"
+    SUPER_FAST = "superfast"
+    VERY_FAST = "veryfast"
+    FASTER = "faster"
+    FAST = "fast"
+    MEDIUM = "medium"
+    SLOW = "slow"
+    SLOWER = "slower"
+    VERY_SLOW = "veryslow"
+
+    @staticmethod
+    def as_list() -> list[str]:
+        return list(EncodingSpeed.__members__.values())
+
+
+class ConstantRateFactor(IntEnum):
+    """Adjust quality/size (lower means better quality/larger file).
+    Attributes:
+        LOSSLESS: Perfect quality, massive file size.
+        HIGH_QUALITY: Visually lossless for most eyes.
+        GOOD: High quality, slightly compressed.
+        DEFAULT: x264 default; good balance of size and quality.
+        COMPACT: Acceptable quality for small screens or streaming.
+        LOW_QUALITY: Noticeable compression artifacts; smaller file.
+        WORST_ACCEPTABLE: Very low quality; only for previews or constrained storage.
+    """
+
+    LOSSLESS = 0
+    HIGH_QUALITY = 18
+    GOOD = 20
+    DEFAULT = 23
+    COMPACT = 26
+    LOW_QUALITY = 28
+    WORST_ACCEPTABLE = 35
+
+    @staticmethod
+    def as_list() -> list[str]:
+        return list(ConstantRateFactor.__members__.keys())
+
+
+class FfmpegVideoWriter(VideoWriter):
+
+    @property
+    def _current_video_metadata(self) -> NewVideoStartEvent:
+        if self.__current_video_metadata is None:
+            raise ValueError("FfmpegVideoWriter is not configured yet.")
+        return self.__current_video_metadata
+
+    @property
+    def _ffmpeg_process(self) -> Popen:
+        if self.__ffmpeg_process is None:
+            raise ValueError("FfmpegVideoWriter is not initialized yet.")
+        return self.__ffmpeg_process
+
+    @property
+    def is_open(self) -> bool:
+        return self.__ffmpeg_process is not None
+
+    @property
+    def is_closed(self) -> bool:
+        return self.is_open is False
+
+    def __init__(
+        self,
+        save_location_strategy: VideoSaveLocationStrategy,
+        encoding_speed: EncodingSpeed = EncodingSpeed.FAST,
+        input_format: VideoFormat = VideoFormat.RAW,
+        output_format: VideoFormat = VideoFormat.MP4,
+        input_pixel_format: PixelFormat = PixelFormat.RGB24,
+        output_pixel_format: PixelFormat = PixelFormat.YUV420P,
+        output_video_codec: VideoCodec = VideoCodec.H264_SOFTWARE,
+        constant_rate_factor: ConstantRateFactor = ConstantRateFactor.LOSSLESS,
+    ) -> None:
+        if ON_WINDOWS:
+            log.warning(
+                "Writing every frame into a new video is not supported on Windows."
+            )
+        self._save_location_strategy = save_location_strategy
+        self._encoding_speed = encoding_speed
+        self._input_format = input_format
+        self._output_format = output_format
+        self._input_pixel_format = input_pixel_format
+        self._output_pixel_format = output_pixel_format
+        self._output_video_codec = output_video_codec
+        self.__ffmpeg_process: Popen | None = None
+        self.__current_video_metadata: NewVideoStartEvent | None = None
+        self._constant_rate_factor = constant_rate_factor
+        log.info(
+            "FFmpeg video writer settings: "
+            f"video_codec='{self._output_video_codec.value}', "
+            f"encoding_speed='{self._encoding_speed.value}', "
+            f"crf='{self._constant_rate_factor.value}'"
+        )
+
+    def open(self, output: str, width: int, height: int, fps: float) -> None:
+        self.__ffmpeg_process = self.__create_ffmpeg_process(
+            output_file=output,
+            width=width,
+            height=height,
+            fps=fps,
+        )
+
+    def write(self, image: ndarray) -> None:
+        try:
+            if self._ffmpeg_process.stdin:
+                self._ffmpeg_process.stdin.write(image.tobytes())
+                self._ffmpeg_process.stdin.flush()
+        except BrokenPipeError:
+            # Check if the process is still running
+            if self._ffmpeg_process.poll() is not None:
+                # Process has terminated, get the error message
+                stderr = (
+                    self._ffmpeg_process.stderr.read()
+                    if self._ffmpeg_process.stderr
+                    else b""
+                )
+                log.info(stderr.decode("utf-8", errors="ignore"))
+                raise RuntimeError(
+                    "ffmpeg process terminated unexpectedly: "
+                    f"{stderr.decode('utf-8', errors='ignore')}"
+                )
+            raise  # Re-raise the original exception if the process is still running
+
+    def close(self) -> None:
+        if self.__ffmpeg_process is not None:
+            process_to_cleanup = self._ffmpeg_process
+            self.__ffmpeg_process = None  # Immediately mark as closed
+
+            # Close stdin synchronously (fast operation)
+            try:
+                if process_to_cleanup.stdin:
+                    process_to_cleanup.stdin.flush()
+                    process_to_cleanup.stdin.close()
+            except Exception as cause:
+                log.debug(f"Error closing stdin: {cause}")
+
+            # Handle cleanup in background thread
+            def cleanup_process() -> None:
+                try:
+                    # Just check if it's still running and wait for it
+                    if process_to_cleanup.poll() is None:
+                        # Still running, close stdin and wait
+                        try:
+                            if (
+                                process_to_cleanup.stdin
+                                and not process_to_cleanup.stdin.closed
+                            ):
+                                process_to_cleanup.stdin.close()
+                        except Exception as cause:
+                            log.error(f"Error closing stdin: {cause}")
+
+                        # Simple wait with timeout
+                        try:
+                            process_to_cleanup.wait(timeout=5.0)
+                        except TimeoutExpired:
+                            process_to_cleanup.kill()
+                            try:
+                                process_to_cleanup.wait(timeout=1.0)
+                            except TimeoutExpired:
+                                log.error("Could not kill FFmpeg process")
+
+                    # Log return code if we care
+                    if process_to_cleanup.returncode != 0:
+                        log.debug(
+                            f"FFmpeg ended with code: {process_to_cleanup.returncode}"
+                        )
+
+                except Exception as e:
+                    log.debug(f"Cleanup completed with minor issues: {e}")
+
+            # Start cleanup in daemon thread (won't prevent program exit)
+            cleanup_thread = Thread(target=cleanup_process, daemon=True)
+            cleanup_thread.start()
+
+        self.__current_video_metadata = None
+
+    def notify_on_flush_event(self, event: FlushEvent) -> None:
+        self.close()
+
+    def notify_on_new_video_start(self, event: NewVideoStartEvent) -> None:
+        self.__current_video_metadata = event
+        self.open(event.output, event.width, event.height, event.fps)
+
+    def __create_ffmpeg_process(
+        self, output_file: str, width: int, height: int, fps: float
+    ) -> Popen:
+        save_file = self._save_location_strategy(output_file)
+        cmd = (
+            ffmpeg.input(
+                "pipe:0",
+                format=self._input_format.value,
+                framerate=fps,
+                pix_fmt=self._input_pixel_format.value,
+                s=f"{width}x{height}",
+            )
+            .output(
+                save_file,
+                pix_fmt=self._output_pixel_format.value,
+                vcodec=self._output_video_codec.value,
+                preset=self._encoding_speed.value,
+                crf=self._constant_rate_factor.value,
+                format=self._output_format.value,
+            )
+            .overwrite_output()
+            .compile()
+        )
+
+        process = Popen(
+            cmd,
+            stdin=PIPE,
+            stderr=PIPE,
+            bufsize=BUFFER_SIZE_100MB,
+        )
+        log.info(f"Writing new video file to '{save_file}'.")
+        return process
+
+    def filter(
+        self, pipe: Generator[Frame, None, None]
+    ) -> Generator[Frame, None, None]:
+        for frame in pipe:
+            if (image := frame.get(FrameKeys.data)) is not None:
+                self.write(image)
+            yield frame
+
+
+def append_save_suffix_to_save_location(given: str) -> str:
+    filepath = Path(given)
+    return str(Path(filepath).with_stem(f"{filepath.stem}{VIDEO_SAVE_FILE_POSTFIX}"))
+
+
+def keep_original_save_location(given: str) -> str:
+    return given

OTVision/plugin/generate_video.py

@@ -0,0 +1,24 @@
+from functools import cached_property
+
+from OTVision.application.video.generate_video import GenerateVideo
+from OTVision.detect.file_based_detect_builder import FileBasedDetectBuilder
+
+
+class GenerateVideoBuilder(FileBasedDetectBuilder):
+    @cached_property
+    def generate_video(self) -> GenerateVideo:
+        return GenerateVideo(
+            input_source=self.input_source, video_writer=self.video_file_writer
+        )
+
+    def build_generate_video(self) -> GenerateVideo:
+        self.register_observers()
+        return self.generate_video
+
+    def register_observers(self) -> None:
+        self.input_source.subject_new_video_start.register(
+            self.video_file_writer.notify_on_new_video_start
+        )
+        self.input_source.subject_flush.register(
+            self.video_file_writer.notify_on_flush_event
+        )

OTVision/version.py

@@ -1,4 +1,4 @@
-__version__ = "v0.6.6"
+__version__ = "v0.6.8"
 
 
 def otdet_version() -> str:

{otvision-0.6.6.dist-info → otvision-0.6.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OTVision
-Version: 0.6.6
+Version: 0.6.8
 Summary: OTVision is a core module of the OpenTrafficCam framework to perform object detection and tracking.
 Project-URL: Homepage, https://opentrafficcam.org/
 Project-URL: Documentation, https://opentrafficcam.org/overview/
@@ -17,22 +17,22 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.11
 Requires-Dist: av==13.0.0
+Requires-Dist: ffmpeg-python==0.2.0
 Requires-Dist: fire==0.7.0
 Requires-Dist: geopandas==1.0.1
 Requires-Dist: ijson==3.3.0
-Requires-Dist: more-itertools==10.5.0
+Requires-Dist: more-itertools==10.7.0
 Requires-Dist: moviepy==1.0.3
 Requires-Dist: numpy==1.26.4; sys_platform == 'win32'
 Requires-Dist: numpy==2.1.1; sys_platform != 'win32'
 Requires-Dist: opencv-python==4.10.0.84
 Requires-Dist: pandas==2.2.3
 Requires-Dist: pyyaml==6.0.2
-Requires-Dist: setuptools==74.0.0
-Requires-Dist: torch==2.3.1
-Requires-Dist: torchvision==0.18.1
+Requires-Dist: torch==2.7.1
+Requires-Dist: torchvision==0.22.1
 Requires-Dist: tqdm==4.67.1
 Requires-Dist: ujson==5.10.0
-Requires-Dist: ultralytics==8.3.94
+Requires-Dist: ultralytics==8.3.159
 Description-Content-Type: text/markdown
 
 # OTVision

{otvision-0.6.6.dist-info → otvision-0.6.8.dist-info}/RECORD

@@ -1,15 +1,15 @@
 OTVision/__init__.py,sha256=CLnfgTlVHM4_nzDacvy06Z_Crc3hU6usd0mUyEvBf24,781
-OTVision/config.py,sha256=0ecnI0N2rS2q0Ld6gBpK4iU2iyuUw683XWjj4g-L1m4,5336
+OTVision/config.py,sha256=D4NIio27JG9hZk7yHI6kNKiMxKeKa_MGfrKNDdEH370,5389
 OTVision/dataformat.py,sha256=BHF7qHzyNb80hI1EKfwcdJ9bgG_X4bp_hCXzdg7_MSA,1941
-OTVision/version.py,sha256=TePRHn7igC5gC-d_U37x7TlN7c1dsVfR5nB0hJk7lY0,175
+OTVision/version.py,sha256=8pR24rKY8pgm_Tctl-E9a4RhSGvh-bTk4sm-pPiNync,175
 OTVision/abstraction/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 OTVision/abstraction/defaults.py,sha256=ftETDe25gmr563RPSbG6flcEiNiHnRb0iXK1Zj_zdNg,442
 OTVision/abstraction/observer.py,sha256=ZFGxUUjI3wUpf5ogXg2yDe-QjCcXre6SxH5zOogOx2U,1350
 OTVision/abstraction/pipes_and_filter.py,sha256=rzYaWDalXnlMbfpkgI91a0FL0q1llUlCRuIQsidYDv8,940
 OTVision/application/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 OTVision/application/buffer.py,sha256=eoK3Rfvc_72cQD3EAASzmxhznjmnIFFh3LX9fqAzXyU,1166
-OTVision/application/config.py,sha256=FFNmwiwZnAqDax8xIJhVhW_wK1FKrhaSzBgYXjcAoq0,13080
-OTVision/application/config_parser.py,sha256=CLBTEKDqREbEpf6-N7ZDPu8EV4OgWbaGfAJAPWLbhwA,9162
+OTVision/application/config.py,sha256=tTFVo2iJt3zCJ_p06FCeQOJ_NbuwmPd60ttrh-6fANI,13670
+OTVision/application/config_parser.py,sha256=-k-FlqH4Cb5q_OD2u5Aa12-Ca8RtKPbpaNcadmGUhXk,9610
 OTVision/application/configure_logger.py,sha256=1TzHB-zm7vGTPtUp7m28ne4WxOyiUYeChLZU-ZPyOVQ,623
 OTVision/application/frame_count_provider.py,sha256=zN_75IM-w9Xlc5rT8OArhiWhPHR8mUfFhdzhSmQQuaM,693
 OTVision/application/get_config.py,sha256=kFRTFQ1eLzBZCIkLrsf0wk7pWIlnUQRXvoZsl0QttVM,829
@@ -19,44 +19,50 @@ OTVision/application/detect/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMp
 OTVision/application/detect/current_object_detector.py,sha256=J4U5k1s902agN90FYR4M_gO8MYYa_5XkYGREjStWCxQ,1343
 OTVision/application/detect/current_object_detector_metadata.py,sha256=xai0UBEzxr-rxXCc8mTmNDECds7mdsw2sem5HZxvQ4Q,1017
 OTVision/application/detect/detected_frame_factory.py,sha256=sW_l0xaPz44_lPEmCPKz4Xg1Mv4ZGKN9CyBCG_iN8dQ,1007
-OTVision/application/detect/detected_frame_producer.py,sha256=LD4AnQG04YGE68TpxmaRuWRZeCZfhp8oixk6SHTru7c,906
 OTVision/application/detect/detection_file_save_path_provider.py,sha256=nUyzgR7imrH8PkUl_72kdUDiolPXq1_RQqbpFwLI5Cs,2165
 OTVision/application/detect/factory.py,sha256=UCnLtgpWdNqwwjW0v2yzKF9Gacx6gewjTyy43wXs2Jg,938
 OTVision/application/detect/get_detect_cli_args.py,sha256=gezr17im8SwbuXW1suCodWRrFs8lSljNKu76SbWBgkY,265
 OTVision/application/detect/timestamper.py,sha256=us9l1GaPnSfMrUZQ5UEDBPX787ypeUiUtpOZm3JpgM0,653
-OTVision/application/detect/update_detect_config_with_cli_args.py,sha256=_8vaFfqqtq1tjj8twArqPKOmQBiCzdBnEKhSRNjX_yQ,3769
+OTVision/application/detect/update_detect_config_with_cli_args.py,sha256=tRT4jB-ynhZ24HvA7c6pyvNDcwIs_M6w-o4k2hCONPQ,4393
+OTVision/application/event/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+OTVision/application/event/new_video_start.py,sha256=Ydkao4v3fagJUvXASkvxgmplRb7PYY88cmj-bSxmzfk,148
 OTVision/application/track/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 OTVision/application/track/get_track_cli_args.py,sha256=uebHGDB6xzttak_Z4Nos08Ay69QKT2JypfHwn1dLpIM,553
 OTVision/application/track/update_current_track_config.py,sha256=pCFNuGl6rqpsUUGm2i1kjLSuuITVXv2R79Xf81n45as,1667
 OTVision/application/track/update_track_config_with_cli_args.py,sha256=5MDr2ih4xHzZ0kI6TSQ2C4mcWsPXW2PB80kA22-M_5I,2273
+OTVision/application/video/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+OTVision/application/video/generate_video.py,sha256=4zazQoRdwefF_R-sUcnbP-23NTWgn_aYdQJrhtJ5Ni4,513
 OTVision/convert/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 OTVision/convert/convert.py,sha256=UUfzpbtMlxlJgKE6XeT5nyNqK26-K02bQDhq3o7KrXE,11050
 OTVision/detect/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-OTVision/detect/builder.py,sha256=P2RbTTffetz0gBfNKKYBOKuXEJyGRk3HDyclYAXBGxY,7166
-OTVision/detect/cli.py,sha256=_fB_4UH_AhxUFxKDgzErieiviUZ1u51Zb66YRIXUXVE,6052
+OTVision/detect/builder.py,sha256=ubmxSICTR5wEPhqrLfuH3Bq0fvA_1qxRjn_z9NXa33c,7723
+OTVision/detect/cli.py,sha256=3yf0G_B9cVm2CAz7AFzG10Cctv4ogMOxRHWEg8SZHss,7562
 OTVision/detect/detect.py,sha256=YaVS-DJXdEmh-OzwE31UPNl2uk7mcFyO_CKKTgMeiuM,1328
 OTVision/detect/detected_frame_buffer.py,sha256=TrLbImpvCm1B09Z3c000e2uDO5WguyVwoMmFAqH8Zvk,1505
-OTVision/detect/file_based_detect_builder.py,sha256=C6BqVuknbJzX-B4N4nSwJgEpt9Nf79Oen8H6so9AflU,754
+OTVision/detect/detected_frame_producer.py,sha256=yO60w4YHOum2DkiinA6mi2aaHSOmZxXRykhox2CMsZY,544
+OTVision/detect/detected_frame_producer_factory.py,sha256=QeBvjF6MneHiaTPYelTrzJWTpYxWYWDcVBzFYNb1PUQ,1646
+OTVision/detect/file_based_detect_builder.py,sha256=G72GFhF2BCXO3fwfC9pXkbJPhRFfU6RphLRQs3ugCUQ,2315
 OTVision/detect/otdet.py,sha256=-8rZGY9NVRAwIHeVcNCjm665SmnW5UVIO_PSKdHegDA,6274
 OTVision/detect/otdet_file_writer.py,sha256=idgPKwhgEd18HT7HshaT304JPlSw0kT4Isn2gWJRaSk,4304
 OTVision/detect/pyav_frame_count_provider.py,sha256=w7p9iM3F2fljV8SD7q491gQhIHANbVczqtalcUiKj-E,453
-OTVision/detect/rtsp_based_detect_builder.py,sha256=5-jg4ivJhiWi3PVIILVThorDNKg-i4Z-rFqZ2n01RDY,1322
-OTVision/detect/rtsp_input_source.py,sha256=0BGMTFZqAf_8qjha_3BrNhjDoS-ejyNlU_Z9h3DqG54,6865
+OTVision/detect/rtsp_based_detect_builder.py,sha256=P47nKU2C1PJQmokgacv04DzJ-7eG6CUbqqg3bdQhXTQ,2662
+OTVision/detect/rtsp_input_source.py,sha256=1us8zziXGeggNROWQWrx7N35XztGwhEhpbbMNHQScvs,10268
 OTVision/detect/timestamper.py,sha256=VvDTzHu9fTI7qQL9x775Gc27r47R8D5Pb040ffwO04k,5288
-OTVision/detect/video_input_source.py,sha256=GLzG4LeZNYcOE1tHyebL51HxBHzJOVaDfJKsLiAtu4A,8775
-OTVision/detect/yolo.py,sha256=Ksj8X7DZmONalaMB_iz-AtXwhEk4Fu7nZNzrXpqfhQw,10451
+OTVision/detect/video_input_source.py,sha256=LCmElr8r03n4OqQlzhas9soq5bZ76Q9vXQZ8jk5IxME,10106
+OTVision/detect/yolo.py,sha256=7NOH6Tbr1ILkp_u7AdWNmnU3wLem6u7oSMhHAexZaXs,10632
 OTVision/detect/plugin_av/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 OTVision/detect/plugin_av/rotate_frame.py,sha256=4wJqTYI2HRlfa4p2Ffap33vLmKIzE_EwFvQraEkQ4R8,1055
 OTVision/domain/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-OTVision/domain/cli.py,sha256=VNZZ_zc1x6RzndQlOFp5HSeWTg_VAiF1G3IhYymdrzA,1781
+OTVision/domain/cli.py,sha256=INiw1dxQNO4XI6GGCIMhX2G08ig68FNS04fdtMt3gNs,2061
 OTVision/domain/current_config.py,sha256=Q38NCktoGNU1Z_miXNoJXLH8-NDbVszwVOMGR1aAwWM,286
 OTVision/domain/detect_producer_consumer.py,sha256=gD7NwscQZLmCxMDZpZkGql0oMrpGHDBBNvdTXs58Vvw,855
 OTVision/domain/detection.py,sha256=SZLP-87XE3NcTkeYz7GTqp4oPMiqI1P5gILp1_yHtxY,3761
 OTVision/domain/frame.py,sha256=Hv1v9cegfhVGgl2MB4uKYbvngfkOLrvES_w4gD0HtMo,6410
-OTVision/domain/input_source_detect.py,sha256=9DzkTg5dh7_KmxE9oxdmxrcTYhvZY8hHLZwhrh7Gz2o,1245
+OTVision/domain/input_source_detect.py,sha256=BNhzxJBurKrM7g5cFrBigJGNmTdIQfVOy9V0pIqsZQ8,1107
 OTVision/domain/object_detection.py,sha256=kyrTbP9sZBKtGo54vCNfluDMM8wpWZST9Oqf8m8Q1y4,1394
 OTVision/domain/serialization.py,sha256=S7gb648z_W8U3Fb6TSk7hVU4qHlGwOZ7D6FeYSLXQwM,257
-OTVision/domain/time.py,sha256=gVjhWNRhYKDp11CcCYHlymlWbhGEIFjWlUwVDat77eY,327
+OTVision/domain/time.py,sha256=_6a4zDbhXU7DmK7PdBYWRrrO2yQ4D68qtSYLTwnwWMQ,302
+OTVision/domain/video_writer.py,sha256=iYt-QXu8jaNSIwdbpEjc5hsEtHveUgqbmxme7iZNVLA,910
 OTVision/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 OTVision/helpers/date.py,sha256=XK0fmXMombQ2CJ2_RXjk-bc-R8qqXRK2rDmCMBi0_G0,854
 OTVision/helpers/files.py,sha256=G7zoOHzWIYrMmkjgHJHkZbh2hcGtnwZomuspthG2GsE,18444
@@ -66,6 +72,8 @@ OTVision/helpers/log.py,sha256=fOSMTXQRQ3_3zzYL8pDlx85IXPwyDsI2WGpK-V_R47Q,4985
 OTVision/helpers/machine.py,sha256=8Bz_Eg7PS0IL4riOVeJcEIi5D9E8Ju8-JomTkW975p8,2166
 OTVision/helpers/video.py,sha256=xyI35CiWXqoeGd3HeLhZUPxrLz8GccWyzHusxoweJr4,1480
 OTVision/plugin/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+OTVision/plugin/ffmpeg_video_writer.py,sha256=1e8FVrdNopTOtgn2QOicz_lTXriwLXoJ9CPtAv9hlL4,10469
+OTVision/plugin/generate_video.py,sha256=Jxk8iQBP8YhobRIRJ535yW3gx0h4d7H8oz0rULRPgcc,840
 OTVision/plugin/yaml_serialization.py,sha256=LjJ_QLJPClRwsaw7ooagWT7LBW08OvSb527jbex1qIQ,557
 OTVision/track/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 OTVision/track/builder.py,sha256=kHGV8Bb7Uh_SbVP1-tT5p68yzBqiWEeLmjM_P6wnE3A,4868
@@ -98,7 +106,7 @@ OTVision/view/view_helpers.py,sha256=a5yV_6ZxO5bxsSymOmxdHqzOEv0VFq4wFBopVRGuVRo
 OTVision/view/view_track.py,sha256=vmfMqpbUfnzg_EsWiL-IIKNOApVF09dzSojHpUfYY6M,5393
 OTVision/view/view_transform.py,sha256=HvRd8g8geKRy0OoiZUDn_oC3SJC5nuXhZf3uZelfGKg,5473
 OTVision/view/helpers/OTC.ico,sha256=G9kwlDtgBXmXO3yxW6Z-xVFV2q4nUGuz9E1VPHSu_I8,21662
-otvision-0.6.6.dist-info/METADATA,sha256=RzNTAEFsKAPXOo7ze8bsD_wrxIt7RtPSP6C_uWgZ7QA,6262
-otvision-0.6.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-otvision-0.6.6.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-otvision-0.6.6.dist-info/RECORD,,
+otvision-0.6.8.dist-info/METADATA,sha256=fj6FWmTovYBzy7TPOR3jtVWfkSQW9vmcZiBDybboTlY,6265
+otvision-0.6.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+otvision-0.6.8.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+otvision-0.6.8.dist-info/RECORD,,

OTVision/application/detect/detected_frame_producer.py

@@ -1,24 +0,0 @@
-from typing import Generator
-
-from OTVision.abstraction.pipes_and_filter import Filter
-from OTVision.domain.detect_producer_consumer import DetectedFrameProducer
-from OTVision.domain.frame import DetectedFrame, Frame
-from OTVision.domain.input_source_detect import InputSourceDetect
-
-
-class SimpleDetectedFrameProducer(DetectedFrameProducer):
-
-    def __init__(
-        self,
-        input_source: InputSourceDetect,
-        detection_filter: Filter[Frame, DetectedFrame],
-        detected_frame_buffer: Filter[DetectedFrame, DetectedFrame],
-    ) -> None:
-        self._input_source = input_source
-        self._detection_filter = detection_filter
-        self._detected_frame_buffer = detected_frame_buffer
-
-    def produce(self) -> Generator[DetectedFrame, None, None]:
-        return self._detected_frame_buffer.filter(
-            self._detection_filter.filter(self._input_source.produce())
-        )