PyNvVideoCodec 2.2.1__cp313-cp313-win_arm64.whl

samples/utils/decode_stats_writer.py

@@ -0,0 +1,177 @@
+# This copyright notice applies to this file only
+#
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: MIT
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+
+"""
+Core module for handling decode statistics.
+
+This module provides functionality for extracting and analyzing low-level video decoding 
+statistics from H.264/H.265 streams. The following statistics are collected and analyzed:
+
+1. QP (Quantization Parameter) Analysis:
+   - Average, min, max QP values per frame
+   - Indicates compression level and quality trade-offs
+   - Higher QP = more compression, potentially lower quality
+
+2. CU (Coding Unit) Type Distribution:
+   - INTRA: Spatial prediction (current frame only)
+   - INTER: Temporal prediction (motion compensation)
+   - SKIP: Copy from reference without residual
+   - PCM: Uncompressed raw pixel values
+
+3. Motion Vector Statistics:
+   - MV0: Primary motion vectors (L0 reference)
+   - MV1: Secondary motion vectors (L1 reference, B-frames)
+   - Magnitude analysis for temporal complexity assessment
+
+4. Macroblock Details:
+   - Per-block encoding decisions and parameters
+   - Motion vector coordinates and directions
+   - QP values and prediction types for debugging
+
+These statistics are valuable for:
+- Video quality analysis
+- Encoder behavior understanding
+- Performance optimization
+- Debugging encoding/decoding issues
+"""
+
+# CU type definitions and mapping
+CU_TYPES = {
+    0: "INTRA",
+    1: "INTER", 
+    2: "SKIP",
+    3: "PCM",
+    7: "INVALID"
+}
+
+class DecodeStatsWriter:
+    """Handles writing of decode statistics to output files."""
+    
+    def __init__(self, output_file):
+        """Initialize with output file handle."""
+        self.output_file = output_file
+
+    def write_frame_stats(self, frame_idx, parsed_stats):
+        """Write all statistics for a single frame."""
+        if not parsed_stats or len(parsed_stats) == 0:
+            self._write_frame_header(frame_idx)
+            self.output_file.write("No decode stats available\n")
+            return
+
+        self._write_frame_header(frame_idx)
+        
+        qp_luma_list = parsed_stats["qp_luma"]
+        if not qp_luma_list or len(qp_luma_list) == 0:
+            self.output_file.write("No macroblock statistics available\n")
+            return
+
+        num_blocks = len(qp_luma_list)
+        self.output_file.write(f"Macroblock Statistics ({num_blocks} blocks):\n")
+        
+        # Write all block statistics
+        self._write_qp_stats(qp_luma_list)
+        self._write_cu_distribution(parsed_stats["cu_type"], num_blocks)
+        self._write_motion_stats(parsed_stats)
+        self._write_detailed_blocks(parsed_stats, num_blocks)
+
+    def _write_frame_header(self, frame_idx):
+        """Write frame header with index."""
+        self.output_file.write(f"\n=== Frame {frame_idx} ===\n")
+
+    def _write_qp_stats(self, qp_luma_list):
+        """Write QP statistics summary."""
+        avg_qp = sum(qp_luma_list) / len(qp_luma_list)
+        self.output_file.write(f"  Average Luma QP: {avg_qp:.2f}\n")
+        self.output_file.write(f"  Min Luma QP: {min(qp_luma_list)}, Max Luma QP: {max(qp_luma_list)}\n")
+
+    def _write_cu_distribution(self, cu_type_list, num_blocks):
+        """Write CU type distribution."""
+        cu_counts = {}
+        for i in range(num_blocks):
+            if i < len(cu_type_list):
+                cu_type = int(cu_type_list[i])
+                cu_counts[cu_type] = cu_counts.get(cu_type, 0) + 1
+
+        if cu_counts:
+            self.output_file.write("  CU Type Distribution:\n")
+            for cu_type, count in sorted(cu_counts.items()):
+                percentage = (count / num_blocks) * 100
+                cu_name = CU_TYPES.get(cu_type, f"UNKNOWN_{cu_type}")
+                self.output_file.write(f"    {cu_name} (Type {cu_type}): {count} blocks ({percentage:.1f}%)\n")
+
+    def _write_motion_stats(self, parsed_stats):
+        """Write motion vector statistics."""
+        mv_0, mv_1 = self._calculate_mv_magnitudes(parsed_stats)
+        
+        if mv_0:
+            self.output_file.write(f"  Motion Vector Statistics (INTER and B blocks):\n")
+            self.output_file.write(f"    Average MV0 Magnitude: {sum(mv_0) / len(mv_0):.2f}\n")
+            self.output_file.write(f"    Max MV0 Magnitude: {max(mv_0):.2f}\n")
+        
+        if mv_1:
+            self.output_file.write(f"    Average MV1 Magnitude: {sum(mv_1) / len(mv_1):.2f}\n")
+            self.output_file.write(f"    Max MV1 Magnitude: {max(mv_1):.2f}\n")
+
+    def _calculate_mv_magnitudes(self, parsed_stats):
+        """Calculate motion vector magnitudes for INTER blocks."""
+        mv_0, mv_1 = [], []
+        cu_type_list = parsed_stats["cu_type"]
+        
+        for i in range(len(cu_type_list)):
+            if int(cu_type_list[i]) != 1:  # Skip non-INTER blocks
+                continue
+                
+            # Calculate MV0 magnitude
+            if i < len(parsed_stats["mv0_x"]) and i < len(parsed_stats["mv0_y"]):
+                mv_x = float(parsed_stats["mv0_x"][i])
+                mv_y = float(parsed_stats["mv0_y"][i])
+                mv_0.append((mv_x * mv_x + mv_y * mv_y) ** 0.5)
+            
+            # Calculate MV1 magnitude
+            if i < len(parsed_stats["mv1_x"]) and i < len(parsed_stats["mv1_y"]):
+                mv_x = float(parsed_stats["mv1_x"][i])
+                mv_y = float(parsed_stats["mv1_y"][i])
+                mv_1.append((mv_x * mv_x + mv_y * mv_y) ** 0.5)
+        
+        return mv_0, mv_1
+
+    def _write_detailed_blocks(self, parsed_stats, num_blocks, max_blocks=5):
+        """Write detailed information for first few blocks."""
+        self.output_file.write(f"  Detailed Macroblock Information (first {max_blocks} blocks):\n")
+        
+        for i in range(min(max_blocks, num_blocks)):
+            # Get block type and QP
+            cu_type = int(parsed_stats["cu_type"][i]) if i < len(parsed_stats["cu_type"]) else "UNKNOWN"
+            qp_luma = int(parsed_stats["qp_luma"][i]) if i < len(parsed_stats["qp_luma"]) else "UNKNOWN"
+            
+            # Build motion vector info string
+            mv_info = []
+            if i < len(parsed_stats["mv0_x"]) and i < len(parsed_stats["mv0_y"]):
+                mv_info.append(f"MV0=({int(parsed_stats['mv0_x'][i])}, {int(parsed_stats['mv0_y'][i])})")
+            if i < len(parsed_stats["mv1_x"]) and i < len(parsed_stats["mv1_y"]):
+                mv_info.append(f"MV1=({int(parsed_stats['mv1_x'][i])}, {int(parsed_stats['mv1_y'][i])})")
+            
+            mv_str = ", ".join(mv_info) if mv_info else "No MVs"
+            cu_name = CU_TYPES.get(cu_type, f"UNKNOWN_{cu_type}")
+            
+            self.output_file.write(f"    Block {i}: QP={qp_luma}, Type={cu_name}, {mv_str}\n")

samples/utils/encode_parallel_utils.py

@@ -0,0 +1,174 @@
+# This copyright notice applies to this file only
+#
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: MIT
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+
+"""
+Helper module for parallel processing in video encoding.
+"""
+
+import os
+import threading
+import multiprocessing
+from typing import Callable, Any, Dict, Union
+import pycuda.driver as cuda
+import PyNvVideoCodec as nvc
+from .Utils import AppFramePerf
+from .frame_utils import get_frame_size
+from .encode_parser import PERF_MAX_FRAMES
+
+def print_performance_summary(mode: str, num_workers: int, total_frames: int, duration: float) -> None:
+    """Print performance statistics for parallel encoding/decoding."""
+    print(f"\n--- {mode.capitalize()} Performance Summary ---")
+    print(f"Number of {mode}: {num_workers}")
+    print(f"Total frames processed: {total_frames}")
+    if duration > 0:
+        fps = total_frames / duration
+        print(f"Duration: {duration:.2f} seconds")
+        print(f"Total FPS: {fps:.2f}")
+        print(f"Average FPS per {mode[:-1]}: {fps / num_workers:.2f}")
+
+def encode_thread_worker(
+    thread_id: int,
+    input_file: str,
+    encoder: nvc.PyNvEncoder,
+    device_data: cuda.DeviceAllocation,
+    frame_size: int,
+    width: int,
+    height: int,
+    fmt: str,
+    frame_count: int,
+    result_queue: Union[multiprocessing.Queue, 'queue.Queue']
+) -> None:
+    """Worker function for threaded encoding."""
+    try:
+        worker_name = f"Thread-{thread_id + 1}"  # 1-based indexing
+        print(f"Starting encode worker {worker_name}")
+        
+        # Calculate frames to process
+        file_size = os.path.getsize(input_file)
+        available_frames = file_size // frame_size
+        
+        # Determine how many frames to encode
+        frames_to_process = min(frame_count or available_frames, available_frames, PERF_MAX_FRAMES)
+        
+        # Encode frames
+        frames_encoded = 0
+        for i in range(frames_to_process):
+            input_gpu_frame = AppFramePerf(width, height, fmt, device_data, i)
+            pic_params = nvc.NV_ENC_PIC_PARAMS()
+            pic_params.inputTimeStamp = i
+            encoder.Encode(input_gpu_frame, pic_params)
+            frames_encoded += 1
+        
+        # Flush encoder
+        encoder.EndEncode()
+        print(f"Worker {worker_name} completed encoding {frames_encoded} frames")
+        result_queue.put(frames_encoded)
+        
+    except Exception as e:
+        print(f"Worker {worker_name}: An unexpected error occurred: {e}")
+        result_queue.put(0)
+
+def encode_process_worker(
+    process_id: int,
+    input_file: str,
+    width: int,
+    height: int,
+    fmt: str,
+    ipc_handle: Any,
+    frame_size: int,
+    config: Dict[str, Any],
+    frame_count: int,
+    result_queue: multiprocessing.Queue,
+    ready_queue: multiprocessing.Queue,
+    go_event: Any,
+) -> None:
+    """Worker function for multiprocess encoding.
+
+    Signals readiness on ``ready_queue`` after encoder and IPC memory are set up,
+    then blocks on ``go_event`` so the parent can measure encode-only duration.
+    """
+    worker_name = f"Process-{process_id + 1}"  # 1-based indexing
+    print(f"Starting encode worker {worker_name}")
+
+    worker_context = None
+    encoder = None
+    try:
+        # Match thread mode: explicit context + stream (avoids primary-context + extra stream path).
+        # Open IPC memory in this context before CreateEncoder so NVENC sees a consistent CUcontext.
+        cuda.init()
+        gpu_id = int(config.get("gpu_id", 0))
+        worker_context = cuda.Device(gpu_id).make_context()
+        worker_stream = cuda.Stream()
+        device_data = cuda.IPCMemoryHandle(ipc_handle)
+        encoder = nvc.CreateEncoder(
+            width,
+            height,
+            fmt,
+            False,
+            cudacontext=worker_context.handle,
+            cudastream=worker_stream.handle,
+            **config,
+        )
+    except Exception as e:
+        print(f"Worker {worker_name}: setup failed: {e}")
+        ready_queue.put((process_id, False))
+        result_queue.put(0)
+        if worker_context is not None:
+            try:
+                worker_context.pop()
+                worker_context.detach()
+            except Exception:
+                pass
+        return
+
+    file_size = os.path.getsize(input_file)
+    available_frames = file_size // frame_size
+    frames_to_process = min(frame_count or available_frames, available_frames, PERF_MAX_FRAMES)
+
+    ready_queue.put((process_id, True))
+    go_event.wait()
+
+    try:
+        frames_encoded = 0
+        for i in range(frames_to_process):
+            input_gpu_frame = AppFramePerf(width, height, fmt, device_data, i)
+            pic_params = nvc.NV_ENC_PIC_PARAMS()
+            pic_params.inputTimeStamp = i
+            encoder.Encode(input_gpu_frame, pic_params)
+            frames_encoded += 1
+
+        encoder.EndEncode()
+        print(f"Worker {worker_name} completed encoding {frames_encoded} frames")
+        result_queue.put(frames_encoded)
+
+    except Exception as e:
+        print(f"Worker {worker_name}: An unexpected error occurred: {e}")
+        result_queue.put(0)
+    finally:
+        encoder = None
+        if worker_context is not None:
+            try:
+                worker_context.pop()
+                worker_context.detach()
+            except Exception:
+                pass