1.1.0版本

UniTAP/dev/ports/modules/capturer/bulk/bulk_capturer.py

@@ -0,0 +1,132 @@
+import warnings
+import time
+
+from typing import Optional
+
+from UniTAP.dev.modules.capturer.capture import Capturer, CaptureConfig
+from UniTAP.dev.modules.memory_manager import MemoryManager
+from UniTAP.dev.ports.modules.capturer.bulk.bulk_types import (TriggerPosition, TriggerVarType, _get_trigger_value,
+                                                               EncodingTypeEnum, LaneCountEnum)
+from UniTAP.dev.ports.modules.capturer.bulk.result_bulk import ResultBulkObject
+
+megabyte = 1024 * 1024
+
+
+class BulkCapturer:
+    """
+    Class `BulkCapturer` allows working with capturing Bulk data on Sink (RX - receiver) side.
+    You can `start` capturing in several modes, `stop` capturing, getting current `status` and result of
+    capturing `capture_result`.
+    """
+    def __init__(self, capturer: Capturer, memory_manager: MemoryManager):
+        self.__capturer = capturer
+        self.__memory_manager = memory_manager
+        self.__trigger_position = TriggerPosition.TP_Start
+
+        self.__result = ResultBulkObject()
+
+    @property
+    def status(self):
+        """
+        Returns current bulk capturer status.
+
+        Returns:
+            object of `VideoCaptureStatus` type
+        """
+        return self.__capturer.bulk_capturer_status
+
+    @property
+    def capture_result(self) -> ResultBulkObject:
+        """
+        Returns result of bulk capturing.
+
+        Returns:
+            object of `ResultBulkObject` type
+        """
+        return self.__result
+
+    @property
+    def encoding_type(self) -> EncodingTypeEnum:
+        """
+        Returns current encoding type of capturing.
+
+        Returns:
+            object of `EncodingTypeEnum` type
+        """
+        return self.__capturer.read_encoding_type()
+
+    @property
+    def lane_count(self) -> LaneCountEnum:
+        """
+        Returns current lane count for capturing.
+
+        Returns:
+            object of `LaneCountEnum` type
+        """
+        return self.__capturer.read_lane_count()
+
+    def start(self, bulk_size: int = 1, trigger_position: TriggerPosition = TriggerPosition.TP_Start,
+              trigger_config: Optional[TriggerVarType] = None, assume_scrambler: bool = False, gpio: bool = False,
+              encoding_type: Optional[EncodingTypeEnum] = None, lane_count: Optional[LaneCountEnum] = None):
+        """
+        Start capturing. All results can be obtained using the function `capture_result`.
+
+        Args:
+            bulk_size (int) - bulk data size in megabytes
+            trigger_position (`TriggerPosition`)
+            trigger_config (`TriggerVarType`|None)
+            assume_scrambler (bool)
+            gpio (bool)
+            encoding_type (`EncodingTypeEnum`|None)
+            lane_count (`LaneCountEnum`|None)
+        """
+        self.__result.clear()
+
+        if trigger_config is None:
+            trigger_position = TriggerPosition.TP_Start
+
+        capture_config = CaptureConfig()
+        capture_config.video = True
+        capture_config.event = True
+        capture_config.audio = True
+        capture_config.type = CaptureConfig.Type.LIVE
+        self.__capturer.stop_capture(capture_config)
+        self.__capturer.stop_bulk_capture()
+        self.__capturer.clear_bulk_buffer()
+
+        max_bulk_block_bytes = self.__memory_manager.get_total_memory() - self.__memory_manager.RESERVED_MEMORY_BYTES
+        bulk_block_bytes = max_bulk_block_bytes if bulk_size * megabyte > max_bulk_block_bytes else bulk_size * megabyte
+        self.__memory_manager.set_memory_layout([bulk_block_bytes])
+        self.__capturer.write_bulk_size(bulk_block_bytes)
+        
+        if encoding_type is None:
+            encoding_type = EncodingTypeEnum.Encoding_Auto
+        self.__capturer.write_encoding_type(encoding_type)
+
+        if lane_count is None:
+            lane_count = LaneCountEnum.Auto
+        self.__capturer.write_lane_count(lane_count)
+
+        if self.__capturer.read_bulk_capture_caps().bitGrabWidth:
+            self.__capturer.write_bulk_gpio(gpio)
+
+        self.__capturer.write_bulk_trigger_position(trigger_position.value)
+
+        if self.__capturer.read_bulk_capture_caps().triggers:
+            self.__capturer.write_bulk_trigger_settings(*_get_trigger_value(trigger_config,
+                                                                           self.__capturer.read_bulk_trigger_caps()))
+        else:
+            warnings.warn("Triggers are not supported.")
+
+        self.__result.assume_scrambler_disabled = assume_scrambler
+        self.__result.start_capture_time = time.time()
+
+        self.__capturer.start_bulk_capture()
+        self.__result.buffer.extend(self.__capturer.bulk_capture(bulk_block_bytes, trigger_config))
+
+    def stop(self):
+        """
+        Stop capture video.
+        """
+        self.__capturer.stop_bulk_capture()
+        self.__result.end_capture_time = time.time()