matrice-streaming 0.1.68__py3-none-any.whl → 0.1.70__py3-none-any.whl

matrice_streaming/streaming_gateway/camera_streamer/async_camera_worker.py

@@ -88,7 +88,7 @@ class AsyncCameraWorker:
         health_queue: multiprocessing.Queue,
         command_queue: Optional[multiprocessing.Queue] = None,
         response_queue: Optional[multiprocessing.Queue] = None,
-        frame_optimizer_enabled: bool = True,
+        frame_optimizer_enabled: bool = False,  # Disabled for ML quality
         frame_optimizer_config: Optional[Dict[str, Any]] = None,
         # ================================================================
         # SHM_MODE: New parameters for shared memory architecture
@@ -99,7 +99,7 @@ class AsyncCameraWorker:
         # ================================================================
         # PERFORMANCE: New parameters for optimized frame capture
         # ================================================================
-        drop_stale_frames: bool = True,  # Use grab()/grab()/retrieve() pattern for latest frame
+        drop_stale_frames: bool = False,  # Disabled for ML quality
         pin_cpu_affinity: bool = True,   # Pin worker to specific CPU cores
         total_workers: int = 1,          # Total worker count for CPU affinity calculation
         buffer_size: int = 1,            # Minimal buffer for low latency (cv2_bench uses 1)
@@ -1313,10 +1313,14 @@ def run_async_worker(
     # ================================================================
     # PERFORMANCE: New parameters for optimized frame capture
     # ================================================================
-    drop_stale_frames: bool = True,
+    drop_stale_frames: bool = False,  # Disabled for ML quality
     pin_cpu_affinity: bool = True,
     total_workers: int = 1,
     buffer_size: int = 1,
+    # ================================================================
+    # FRAME OPTIMIZER: Control frame similarity detection
+    # ================================================================
+    frame_optimizer_enabled: bool = False,  # Disabled for ML quality
 ):
     """Entry point for async worker process.
 
@@ -1337,6 +1341,7 @@ def run_async_worker(
         pin_cpu_affinity: Pin worker process to specific CPU cores
         total_workers: Total number of workers for CPU affinity calculation
         buffer_size: VideoCapture buffer size (1 = minimal latency)
+        frame_optimizer_enabled: Enable frame similarity detection (skip similar frames)
     """
     # Setup logging for this process
     logging.basicConfig(
@@ -1378,6 +1383,8 @@ def run_async_worker(
             pin_cpu_affinity=pin_cpu_affinity,
             total_workers=total_workers,
             buffer_size=buffer_size,
+            # FRAME OPTIMIZER: Pass through frame similarity detection setting
+            frame_optimizer_enabled=frame_optimizer_enabled,
         )
 
         # Run event loop

matrice_streaming/streaming_gateway/camera_streamer/async_ffmpeg_worker.py

@@ -86,7 +86,7 @@ class AsyncFFmpegWorker:
         pin_cpu_affinity: bool = True,
         total_workers: int = 1,
         # Frame optimizer options
-        frame_optimizer_enabled: bool = True,
+        frame_optimizer_enabled: bool = False,  # Disabled for ML quality
         frame_optimizer_config: Optional[Dict[str, Any]] = None,
     ):
         """Initialize async FFmpeg worker.
@@ -905,7 +905,7 @@ def run_ffmpeg_worker(
     shm_frame_format: str = "BGR",
     pin_cpu_affinity: bool = True,
     total_workers: int = 1,
-    frame_optimizer_enabled: bool = True,
+    frame_optimizer_enabled: bool = False,  # Disabled for ML quality
     frame_optimizer_config: Optional[Dict[str, Any]] = None,
 ):
     """Entry point for FFmpeg worker process.

matrice_streaming/streaming_gateway/camera_streamer/camera_streamer.py

@@ -41,7 +41,7 @@ class CameraStreamer:
         gateway_util: StreamingGatewayUtil = None,
         connection_refresh_threshold: int = 10,
         connection_refresh_interval: float = 60.0,
-        frame_optimizer_enabled: bool = True,
+        frame_optimizer_enabled: bool = False,  # Disabled for ML quality
         frame_optimizer_config: Optional[Dict[str, Any]] = None,
     ):
         """Initialize CameraStreamer.

matrice_streaming/streaming_gateway/camera_streamer/ffmpeg_camera_streamer.py

@@ -315,7 +315,7 @@ class FFmpegCameraStreamer:
         shm_slot_count: int = 1000,
         shm_frame_format: str = "BGR",
         # Frame optimizer options
-        frame_optimizer_enabled: bool = True,
+        frame_optimizer_enabled: bool = False,  # Disabled for ML quality
         frame_optimizer_config: Optional[Dict[str, Any]] = None,
         # CPU affinity options
         pin_cpu_affinity: bool = False,

matrice_streaming/streaming_gateway/camera_streamer/gstreamer_camera_streamer.py

@@ -532,7 +532,7 @@ class GStreamerCameraStreamer:
         video_codec: Optional[str] = None,
         gateway_util: StreamingGatewayUtil = None,
         gstreamer_config: Optional[GStreamerConfig] = None,
-        frame_optimizer_enabled: bool = True,
+        frame_optimizer_enabled: bool = False,  # Disabled for ML quality
         frame_optimizer_config: Optional[Dict[str, Any]] = None,
     ):
         """Initialize GStreamerCameraStreamer.

matrice_streaming/streaming_gateway/camera_streamer/nvdec.py

@@ -96,8 +96,23 @@ except (ImportError, AttributeError, RuntimeError, TypeError):
     CudaIpcRingBuffer = None
     GlobalFrameCounter = None
 
+try:
+    from matrice_common.stream.gpu_camera_map import GpuCameraMap
+    GPU_CAMERA_MAP_AVAILABLE = True
+except ImportError:
+    GPU_CAMERA_MAP_AVAILABLE = False
+    GpuCameraMap = None
+
 logger = logging.getLogger(__name__)
 
+# =============================================================================
+# Fixed dimensions for NV12 output - ALL cameras resize to this size
+# This matches the TensorRT model input requirements (640x640)
+# =============================================================================
+TARGET_WIDTH = 640
+TARGET_HEIGHT = 640
+NV12_HEIGHT = TARGET_HEIGHT + TARGET_HEIGHT // 2  # 960 = H * 1.5 for NV12 format
+
 def setup_logging(quiet: bool = True):
     """Configure logging level based on quiet mode."""
     level = logging.WARNING if quiet else logging.INFO
@@ -407,6 +422,8 @@ class StreamState:
     width: int = 640
     height: int = 640
     empty_packets: int = 0
+    decode_errors: int = 0  # Consecutive decode errors
+    MAX_DECODE_ERRORS: int = 5  # Restart demuxer after this many consecutive errors
 
 
 # =============================================================================
@@ -664,18 +681,44 @@ class NVDECDecoderPool:
                             break
 
                     frames_before = frames_this_stream
-                    for surface in decoder.Decode(packet):
-                        tensor = surface_to_nv12(surface, target_h, target_w)
-
-                        if tensor is not None:
-                            decoded_frames.append((stream.camera_id, tensor))
-                            frames_this_stream += 1
-                            stream.frames_decoded += 1
-                            total_frames += 1
-                            stream.empty_packets = 0
 
-                        if frames_this_stream >= frames_per_stream:
-                            break
+                    # Wrap decode loop in try/except to catch decode errors
+                    try:
+                        for surface in decoder.Decode(packet):
+                            tensor = surface_to_nv12(surface, target_h, target_w)
+
+                            if tensor is not None:
+                                decoded_frames.append((stream.camera_id, tensor))
+                                frames_this_stream += 1
+                                stream.frames_decoded += 1
+                                total_frames += 1
+                                stream.empty_packets = 0
+                                stream.decode_errors = 0  # Reset on success
+
+                            if frames_this_stream >= frames_per_stream:
+                                break
+
+                    except Exception as decode_err:
+                        # Handle decode errors - these can happen with corrupted packets
+                        stream.decode_errors += 1
+                        if stream.decode_errors == 1:
+                            # Only log first error per stream to avoid spam
+                            logger.warning(f"{stream.camera_id}: Decode error: {decode_err}")
+
+                        if stream.decode_errors >= stream.MAX_DECODE_ERRORS:
+                            # Too many consecutive errors - restart demuxer
+                            logger.warning(
+                                f"{stream.camera_id}: {stream.decode_errors} consecutive decode errors, "
+                                f"restarting demuxer"
+                            )
+                            try:
+                                stream.demuxer = nvc.CreateDemuxer(stream.video_path)
+                                stream.decode_errors = 0
+                                stream.empty_packets = 0
+                                logger.info(f"{stream.camera_id}: Demuxer restarted successfully")
+                            except Exception as restart_err:
+                                logger.error(f"{stream.camera_id}: Failed to restart demuxer: {restart_err}")
+                                break  # Exit this stream's loop
 
                     if frames_this_stream == frames_before:
                         stream.empty_packets += 1
@@ -683,7 +726,17 @@ class NVDECDecoderPool:
                             stream.demuxer = nvc.CreateDemuxer(stream.video_path)
                             stream.empty_packets = 0
 
-                except Exception:
+                except Exception as demux_err:
+                    # Handle demux errors
+                    logger.warning(f"{stream.camera_id}: Demux error: {demux_err}")
+                    stream.decode_errors += 1
+                    if stream.decode_errors >= stream.MAX_DECODE_ERRORS:
+                        try:
+                            stream.demuxer = nvc.CreateDemuxer(stream.video_path)
+                            stream.decode_errors = 0
+                            logger.info(f"{stream.camera_id}: Demuxer restarted after demux errors")
+                        except Exception:
+                            pass
                     break
 
                 if frames_this_stream >= frames_per_stream:
@@ -778,16 +831,28 @@ def nvdec_pool_worker(
 
         try:
             with cuda_stream:
+                # Always use fixed TARGET dimensions to ensure consistent NV12 output
                 num_frames, decoded_frames = pool.decode_round(
                     decoder_idx,
                     frames_per_stream=burst_size,
-                    target_h=target_h,
-                    target_w=target_w
+                    target_h=TARGET_HEIGHT,  # Always 640
+                    target_w=TARGET_WIDTH    # Always 640
                 )
 
                 for cam_id, tensor in decoded_frames:
                     if cam_id in ring_buffers:
                         try:
+                            # Validate frame shape matches expected NV12 dimensions
+                            expected_shape = (NV12_HEIGHT, TARGET_WIDTH, 1)  # (960, 640, 1)
+                            if tensor.shape != expected_shape:
+                                local_errors += 1
+                                if local_errors <= 5:
+                                    logger.error(
+                                        f"Worker {worker_id} shape mismatch for {cam_id}: "
+                                        f"got {tensor.shape}, expected {expected_shape}"
+                                    )
+                                continue  # Skip this frame
+
                             ring_buffers[cam_id].write_frame_fast(tensor, sync=False)
                             local_frames += 1
                             frames_since_counter_update += 1
@@ -932,30 +997,64 @@ def nvdec_pool_process(
         })
         return
 
-    # Create NV12 ring buffers: (H + H/2, W, 1) = 0.6 MB/frame
+    # Create NV12 ring buffers with FIXED dimensions (640x640 -> 960x640 for NV12)
+    # ALL cameras resize to TARGET_WIDTH x TARGET_HEIGHT regardless of source resolution
     ring_buffers: Dict[str, CudaIpcRingBuffer] = {}
-    frame_size_mb = target_h * target_w * 1.5 / 1e6
+    frame_size_mb = TARGET_WIDTH * NV12_HEIGHT * 1 / 1e6  # 640 * 960 * 1 channel
 
     try:
+        # Initialize GPU camera map (producer side) - process 0 creates, others connect
+        gpu_map = None
+        if GPU_CAMERA_MAP_AVAILABLE:
+            gpu_map = GpuCameraMap(is_producer=True)
+            if process_id == 0:
+                if gpu_map.initialize():
+                    logger.info(f"Process {process_id}: GpuCameraMap initialized")
+                else:
+                    logger.warning(f"Process {process_id}: Failed to initialize GpuCameraMap")
+                    gpu_map = None
+            else:
+                # Wait for process 0 to initialize
+                for retry in range(50):
+                    if gpu_map.connect():
+                        logger.info(f"Process {process_id}: Connected to GpuCameraMap")
+                        break
+                    time.sleep(0.1)
+                else:
+                    logger.warning(f"Process {process_id}: Failed to connect to GpuCameraMap")
+                    gpu_map = None
+
+        # Collect GPU mappings for bulk write
+        gpu_mappings = {}
+
         for i, config in enumerate(camera_configs):
+            # Use fixed dimensions - ALL cameras output 640x640 (960x640 for NV12)
             rb = CudaIpcRingBuffer.create_producer(
                 config.camera_id,
                 gpu_id=config.gpu_id,
                 num_slots=num_slots,
-                width=config.width,
-                height=config.height + config.height // 2,  # H * 1.5 for NV12
+                width=TARGET_WIDTH,      # Always 640
+                height=NV12_HEIGHT,      # Always 960 (640 * 1.5 for NV12)
                 channels=1,
             )
             ring_buffers[config.camera_id] = rb
 
+            # Track GPU assignment for this camera
+            gpu_mappings[config.camera_id] = config.gpu_id
+
             pool.assign_stream(
                 stream_id=i,
                 camera_id=config.camera_id,
                 video_path=config.video_path,
-                width=config.width,
-                height=config.height
+                width=TARGET_WIDTH,   # Use fixed width
+                height=TARGET_HEIGHT  # Use fixed height
             )
 
+        # Write all GPU mappings at once
+        if gpu_map and gpu_mappings:
+            gpu_map.set_bulk_mapping(gpu_mappings)
+            logger.info(f"Process {process_id}: Wrote {len(gpu_mappings)} camera-GPU mappings")
+
         logger.info(f"Process {process_id}: {pool.actual_pool_size} decoders, "
                    f"{len(camera_configs)} streams, NV12 ({frame_size_mb:.1f} MB/frame)")
 

matrice_streaming/streaming_gateway/camera_streamer/worker_manager.py

@@ -43,9 +43,13 @@ class WorkerManager:
         # ================================================================
         # PERFORMANCE: New parameters for optimized frame capture
         # ================================================================
-        drop_stale_frames: bool = True,   # Use grab()/grab()/retrieve() for latest frame
+        drop_stale_frames: bool = False,   # Use grab()/grab()/retrieve() for latest frame (disabled for ML quality)
         pin_cpu_affinity: bool = True,    # Pin workers to specific CPU cores
         buffer_size: int = 1,             # VideoCapture buffer size (1 = minimal latency)
+        # ================================================================
+        # FRAME OPTIMIZER: Control frame similarity detection
+        # ================================================================
+        frame_optimizer_enabled: bool = False,  # Enable frame similarity detection (disabled for ML quality)
     ):
         """Initialize worker manager with dynamic CPU-based scaling.
 
@@ -62,6 +66,7 @@ class WorkerManager:
             drop_stale_frames: Use grab()/grab()/retrieve() pattern for latest frame
             pin_cpu_affinity: Pin worker processes to specific CPU cores for cache locality
             buffer_size: VideoCapture buffer size (1 = minimal latency)
+            frame_optimizer_enabled: Enable frame similarity detection (skip similar frames for bandwidth saving)
         """
         self.camera_configs = camera_configs
         self.stream_config = stream_config
@@ -122,14 +127,28 @@ class WorkerManager:
         self.pin_cpu_affinity = pin_cpu_affinity
         self.buffer_size = buffer_size
 
-        if drop_stale_frames or pin_cpu_affinity:
+        # ================================================================
+        # FRAME OPTIMIZER: Store frame similarity detection configuration
+        # ================================================================
+        self.frame_optimizer_enabled = frame_optimizer_enabled
+
+        if frame_optimizer_enabled:
             self.logger.info(
-                f"PERFORMANCE OPTIMIZATIONS ENABLED: "
-                f"drop_stale_frames={drop_stale_frames}, "
-                f"pin_cpu_affinity={pin_cpu_affinity}, "
-                f"buffer_size={buffer_size}"
+                "FRAME OPTIMIZER ENABLED: Similar frames will be skipped (may reduce ML quality)"
             )
 
+        if drop_stale_frames:
+            self.logger.info(
+                "DROP STALE FRAMES ENABLED: Using grab/grab/retrieve pattern (may reduce ML quality)"
+            )
+
+        self.logger.info(
+            f"Worker config: frame_optimizer={frame_optimizer_enabled}, "
+            f"drop_stale_frames={drop_stale_frames}, "
+            f"pin_cpu_affinity={pin_cpu_affinity}, "
+            f"buffer_size={buffer_size}"
+        )
+
         # Note: Batch parameters are calculated per-worker in _start_worker()
         # based on each worker's camera count, not the global total.
         # This ensures optimal batching when cameras are distributed across workers.
@@ -291,6 +310,8 @@ class WorkerManager:
                     self.pin_cpu_affinity,
                     self.num_workers,     # Total workers for CPU affinity calculation
                     self.buffer_size,
+                    # FRAME OPTIMIZER: Pass frame similarity detection setting
+                    self.frame_optimizer_enabled,
                 ),
                 name=f"AsyncWorker-{worker_id}",
                 daemon=False  # Non-daemon so we can properly wait for shutdown

{matrice_streaming-0.1.68.dist-info → matrice_streaming-0.1.70.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: matrice_streaming
-Version: 0.1.68
+Version: 0.1.70
 Summary: Common server utilities for Matrice.ai services
 Author-email: "Matrice.ai" <dipendra@matrice.ai>
 License-Expression: MIT

{matrice_streaming-0.1.68.dist-info → matrice_streaming-0.1.70.dist-info}/RECORD

@@ -19,27 +19,27 @@ matrice_streaming/streaming_gateway/streaming_gateway_utils.py,sha256=6kNYgl3f7H
 matrice_streaming/streaming_gateway/streaming_status_listener.py,sha256=RgbW0xYbbpmO6ZjkVlh6fg8iqkpRaIShR2dQ3SMVFUw,3161
 matrice_streaming/streaming_gateway/camera_streamer/ARCHITECTURE.md,sha256=kngsqiS1PdNYhihBoMtoiIf3THJ4OM33E_hxExqzKqY,9980
 matrice_streaming/streaming_gateway/camera_streamer/__init__.py,sha256=nwVY-ySnKvOedeDXakyR_6KPHSz3yzSeaO_4IFMMP4I,2219
-matrice_streaming/streaming_gateway/camera_streamer/async_camera_worker.py,sha256=Bg7yfkCn2RofLqviq22eKRhdxMYtqaeTFJC2no94_lI,59278
-matrice_streaming/streaming_gateway/camera_streamer/async_ffmpeg_worker.py,sha256=isBYJnnbdxefkRrV2BsizCSZe1ZDPn5wfoTSOTtObsU,37007
-matrice_streaming/streaming_gateway/camera_streamer/camera_streamer.py,sha256=1BzWnwfPEWPVQ6gBW7uZFvykq2zEvygd5LWE6uqVRhY,39085
+matrice_streaming/streaming_gateway/camera_streamer/async_camera_worker.py,sha256=06fw1wLBls2SOljc8H73QyWTPEhQMzG9S271nwdVCIM,59804
+matrice_streaming/streaming_gateway/camera_streamer/async_ffmpeg_worker.py,sha256=cD3XocWqamkBE9TlkG757OK6tl_Op45r-cMd-ZgJXaA,37063
+matrice_streaming/streaming_gateway/camera_streamer/camera_streamer.py,sha256=zv6tWUKQf2uXAxqtSlfwAVDb9N483VCRApPogUWJ9e8,39113
 matrice_streaming/streaming_gateway/camera_streamer/device_detection.py,sha256=9F4rsbMpIexOIlX8aCj7Q6PFG01kOS1wtgAIQBG0FaM,18463
 matrice_streaming/streaming_gateway/camera_streamer/encoder_manager.py,sha256=guWqNtgGZQBVBxeDlAVnLWTP-hsleWmKYuVcnd0Hvn0,6962
 matrice_streaming/streaming_gateway/camera_streamer/encoding_pool_manager.py,sha256=kYfHu-B8bw9wTFxociAYLVvk-UOC-KqcaFdZ1TQuah4,4222
-matrice_streaming/streaming_gateway/camera_streamer/ffmpeg_camera_streamer.py,sha256=sCeSTVqaYy-XK2fW7ZSMmGYMCTHrSiFCMizHTzMMJyo,37646
+matrice_streaming/streaming_gateway/camera_streamer/ffmpeg_camera_streamer.py,sha256=6y1S20yED-UoZregwN_apAL4UmonvNGTeAd2H8rXpPU,37674
 matrice_streaming/streaming_gateway/camera_streamer/ffmpeg_config.py,sha256=fbogEMtmqw4Fae4MS7vL1oQeFy3FkQbJlRGRF_BxIIo,6156
 matrice_streaming/streaming_gateway/camera_streamer/ffmpeg_worker_manager.py,sha256=pzeDcgST8dHZs18Q4PgnR0-4Up8PU1oAOo8Daos_Y2o,17396
 matrice_streaming/streaming_gateway/camera_streamer/frame_processor.py,sha256=UPifhOr7wYpA1ACU4xGzC3A4lmbr2FvohcG371O6FHQ,2255
-matrice_streaming/streaming_gateway/camera_streamer/gstreamer_camera_streamer.py,sha256=Y_X_luPlvcqMzOn0qodS5opJ6BWjwUYOWWunUEX_10o,54289
+matrice_streaming/streaming_gateway/camera_streamer/gstreamer_camera_streamer.py,sha256=tLZIfpqVGMoCuzjKe9iJyAMF2mbAlkGWr8wTTjsXz0A,54317
 matrice_streaming/streaming_gateway/camera_streamer/gstreamer_worker.py,sha256=AqKNJ6q_BxFphOlJ2GaS4WpoLCHXLEu5JVvoKQNrGV0,42822
 matrice_streaming/streaming_gateway/camera_streamer/gstreamer_worker_manager.py,sha256=jlKwIWWMXpztdyKiyremGmkVyw9mf2AxEmT7154xnrc,22002
 matrice_streaming/streaming_gateway/camera_streamer/message_builder.py,sha256=W295q6cIm05ReF1ooQus3rsKgZOG3EldZplbQco-OyM,10231
-matrice_streaming/streaming_gateway/camera_streamer/nvdec.py,sha256=Y3zhycfTpZ_bF5-Ef55J0iFi9wTLTv4Xxmw-woV1occ,53118
+matrice_streaming/streaming_gateway/camera_streamer/nvdec.py,sha256=A94bIwBC9rX7AJUdNYm9KRoKgiVEgSI5z_0zMpeQZ7g,58503
 matrice_streaming/streaming_gateway/camera_streamer/nvdec_worker_manager.py,sha256=KlcwKFUPVZTQ3J1VIuhPev8Xv9BNw4dj2iLGHrREQCQ,16035
 matrice_streaming/streaming_gateway/camera_streamer/platform_pipelines.py,sha256=UNjsYYWbUJteOq2tzxISFAbWMa2e9GUExSS6fWc2Aow,27303
 matrice_streaming/streaming_gateway/camera_streamer/retry_manager.py,sha256=d8tlGoWoeSlgpCgXbUHTM61ekCQZki7TO1HzL2yPVzk,3607
 matrice_streaming/streaming_gateway/camera_streamer/stream_statistics.py,sha256=VC1S6ogiHUTlzTqn2wGOC1ClOEjvDgWm9Ydi9sWj-Do,18951
 matrice_streaming/streaming_gateway/camera_streamer/video_capture_manager.py,sha256=ySnbihdkpFPcBdFK_OFcHE-MgjG2YirUUYgEJHhvTxo,16899
-matrice_streaming/streaming_gateway/camera_streamer/worker_manager.py,sha256=JDckHyqer0ka4TbVzICEoXePSwRcT2y1YnChnfuK78c,27901
+matrice_streaming/streaming_gateway/camera_streamer/worker_manager.py,sha256=LIx6Qt2bTRZDjWw5l5YSIdif-UVxJs_0umu3p2VDF4Y,29086
 matrice_streaming/streaming_gateway/debug/README.md,sha256=6GeHClMjJbmVuSKbJ8yOIDqpeAPnLNrHXMFtmubZz0E,11343
 matrice_streaming/streaming_gateway/debug/__init__.py,sha256=_RtvH0Y12HFiDoKK8BEsMwy6k_iAFjmYYNzMawbOfeQ,2026
 matrice_streaming/streaming_gateway/debug/benchmark.py,sha256=65la9K2mjiiuADCBSnYpPr9uYFnM89clgw-KHkjSkAU,25563
@@ -49,8 +49,8 @@ matrice_streaming/streaming_gateway/debug/debug_streaming_gateway.py,sha256=ZiDg
 matrice_streaming/streaming_gateway/debug/debug_utils.py,sha256=jWcSBgrk_YVt1QzSyw6geX17YBnTvgVdA5ubqO531a0,10477
 matrice_streaming/streaming_gateway/debug/example_debug_streaming.py,sha256=-gS8zNDswAoj6oss66QQWYZhY24usfLiMH0FFK06vV0,7994
 matrice_streaming/streaming_gateway/debug/test_videoplayback.py,sha256=s_dgWkoESiuJHlUAf_iv4d7OGmAhwocwDZmIcFUZzvo,11093
-matrice_streaming-0.1.68.dist-info/licenses/LICENSE.txt,sha256=_uQUZpgO0mRYL5-fPoEvLSbNnLPv6OmbeEDCHXhK6Qc,1066
-matrice_streaming-0.1.68.dist-info/METADATA,sha256=vSC8p6EEAKwozRFvArLlVcJoipCaAe9KX7S_H9vyJ8I,2477
-matrice_streaming-0.1.68.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-matrice_streaming-0.1.68.dist-info/top_level.txt,sha256=PM_trIe8f4JLc90J871rNMYGVM3Po9Inx4As5LrCFUU,18
-matrice_streaming-0.1.68.dist-info/RECORD,,
+matrice_streaming-0.1.70.dist-info/licenses/LICENSE.txt,sha256=_uQUZpgO0mRYL5-fPoEvLSbNnLPv6OmbeEDCHXhK6Qc,1066
+matrice_streaming-0.1.70.dist-info/METADATA,sha256=TkM7S1ddGBeBaOtn_gcuXdZ8kHwpJjb_t5fcDip60OM,2477
+matrice_streaming-0.1.70.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+matrice_streaming-0.1.70.dist-info/top_level.txt,sha256=PM_trIe8f4JLc90J871rNMYGVM3Po9Inx4As5LrCFUU,18
+matrice_streaming-0.1.70.dist-info/RECORD,,