PyNvVideoCodec 2.2.1__cp313-cp313-win_arm64.whl

samples/utils/encode_parser.py

@@ -0,0 +1,379 @@
+# 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 parsing encoder command line arguments.
+
+This module provides standardized argument parsing for encoder sample applications.
+"""
+
+import argparse
+from pathlib import Path
+from os.path import join, dirname
+import json
+import PyNvVideoCodec as nvc
+
+# Maximum frames for performance testing to avoid OOM
+PERF_MAX_FRAMES = 1000
+
+def add_encode_args(parser: argparse.ArgumentParser, enforce_frame_limit: bool = False) -> None:
+    """Add common encoder arguments to parser.
+
+    Args:
+        parser: The argument parser to add arguments to
+        enforce_frame_limit: If True, enforces max frame limit for perf testing
+    """
+    parser.add_argument(
+        "-g", "--gpu_id",
+        type=int,
+        default=0,
+        help="Check nvidia-smi for available GPUs. Default: 0"
+    )
+    parser.add_argument(
+        "-i", "--raw_file_path",
+        type=Path,
+        required=True,
+        help="Raw video file to encode"
+    )
+    parser.add_argument(
+        "-o", "--encoded_file_path",
+        type=Path,
+        help="Encoded video file (write to). Default: <input_file_name>.<codec>"
+    )
+    parser.add_argument(
+        "-s", "--size",
+        type=str,
+        required=True,
+        help="WidthxHeight of raw frame (e.g., 1920x1080)"
+    )
+    parser.add_argument(
+        "-if", "--format",
+        type=str,
+        default="NV12",
+        help="Format of input file. Default: NV12"
+    )
+    parser.add_argument(
+        "-c", "--codec",
+        type=str,
+        default=None,
+        choices=["h264", "hevc", "av1"],
+        help="Output codec (h264/hevc/av1). Overrides the codec in the JSON config file."
+    )
+    parser.add_argument(
+        "-json", "--config_file",
+        type=str,
+        default=join(dirname(dirname(__file__)), "advanced", "encode_config.json"),
+        help="Path of JSON config file (default: encode_config.json in samples directory)"
+    )
+    help_text = "Number of frames to encode (0 for all frames). Default: 0"
+    if enforce_frame_limit:
+        help_text = f"Number of frames to encode (0-{PERF_MAX_FRAMES}, required for perf testing). Default: {PERF_MAX_FRAMES}"
+
+    parser.add_argument(
+        "-f", "--frame_count",
+        type=int,
+        default=PERF_MAX_FRAMES if enforce_frame_limit else 0,
+        help=help_text
+    )
+
+def add_parallel_args(parser: argparse.ArgumentParser) -> None:
+    """Add parallel processing arguments to parser."""
+    parser.add_argument(
+        "-m", "--mode",
+        type=str,
+        choices=["thread", "process"],
+        default="thread",
+        help="Parallel execution mode: 'thread' or 'process'"
+    )
+    parser.add_argument(
+        "-n", "--num_workers",
+        type=int,
+        default=1,
+        help="Number of parallel threads/processes. Default: 1"
+    )
+
+def load_config(args) -> dict:
+    """Load and process encoder configuration from the JSON config file.
+
+    codec is resolved with CLI priority: if -c/--codec was given on the command
+    line it overrides the JSON value; otherwise the JSON codec (default: h264)
+    is used.  fps and gop always come from the JSON config (fallbacks: 30/30).
+    All three are mirrored back onto ``args`` so downstream code can keep using
+    ``args.codec``/``args.fps``/``args.gop_size``.
+    The NVENC C++ binding reads the "gop" key from kwargs.
+    """
+    config = {}
+    if args.config_file:
+        with open(args.config_file) as jsonFile:
+            config = json.loads(jsonFile.read())
+            config["preset"] = config["preset"].upper()
+
+    json_codec = str(config.get("codec", "h264")).lower()
+    cli_codec = getattr(args, "codec", None)
+    codec = cli_codec.lower() if cli_codec else json_codec
+    args.codec = codec
+    config["codec"] = codec
+
+    fps = int(config.get("fps", 30))
+    args.fps = fps
+    config["fps"] = fps
+
+    gop = int(config.get("gop", 30))
+    args.gop_size = gop
+    config["gop"] = gop
+
+    config["gpu_id"] = args.gpu_id
+
+    args.format = args.format.upper()
+
+    width, height = map(int, args.size.split("x"))
+    args.width = width
+    args.height = height
+
+    if not hasattr(args, 'encoded_file_path') or args.encoded_file_path is None:
+        args.encoded_file_path = args.raw_file_path.with_suffix(f'.{args.codec}')
+
+    return config
+
+def add_unified_args(parser: argparse.ArgumentParser) -> None:
+    """Add unified encoder specific arguments to parser."""
+    parser.add_argument(
+        "-m", "--buffer_mode",
+        type=str,
+        choices=["cpu", "gpu"],
+        default="gpu",
+        help="Buffer mode: 'cpu' for host memory buffers, 'gpu' for CUDA device buffers. Default: gpu"
+    )
+
+def parse_perf_args(description: str = None) -> argparse.Namespace:
+    """Parse arguments for performance testing applications.
+    
+    These apps require frame count limits to prevent OOM errors.
+    Note: No output file argument as perf apps only measure performance without file output.
+    """
+    parser = argparse.ArgumentParser(description=description)
+    
+    # Add args manually without output file
+    parser.add_argument(
+        "-g", "--gpu_id",
+        type=int,
+        default=0,
+        help="Check nvidia-smi for available GPUs. Default: 0"
+    )
+    parser.add_argument(
+        "-i", "--raw_file_path",
+        type=Path,
+        required=True,
+        help="Raw video file to encode"
+    )
+    parser.add_argument(
+        "-s", "--size",
+        type=str,
+        required=True,
+        help="WidthxHeight of raw frame (e.g., 1920x1080)"
+    )
+    parser.add_argument(
+        "-if", "--format",
+        type=str,
+        default="NV12",
+        help="Format of input file. Default: NV12"
+    )
+    parser.add_argument(
+        "-c", "--codec",
+        type=str,
+        default=None,
+        choices=["h264", "hevc", "av1"],
+        help="Output codec (h264/hevc/av1). Overrides the codec in the JSON config file."
+    )
+    parser.add_argument(
+        "-json", "--config_file",
+        type=str,
+        default=join(dirname(dirname(__file__)), "advanced", "encode_config.json"),
+        help="Path of JSON config file (default: encode_config.json in samples directory)"
+    )
+    parser.add_argument(
+        "-f", "--frame_count",
+        type=int,
+        default=PERF_MAX_FRAMES,
+        help=f"Number of frames to encode (0-{PERF_MAX_FRAMES}, required for perf testing). Default: {PERF_MAX_FRAMES}"
+    )
+
+    add_parallel_args(parser)
+    args = parser.parse_args()
+    
+    # Enforce frame limit for perf testing
+    if args.frame_count > PERF_MAX_FRAMES:
+        print(f"\nWarning: Requested {args.frame_count} frames exceeds limit. Using {PERF_MAX_FRAMES} frames.")
+        args.frame_count = PERF_MAX_FRAMES
+    elif args.frame_count <= 0:
+        args.frame_count = PERF_MAX_FRAMES
+    
+    # Set encoded_file_path to None for perf apps (no output)
+    args.encoded_file_path = None
+    
+    args.config = load_config(args)
+    return args
+
+
+def parse_unified_args(description: str = None) -> argparse.Namespace:
+    """Parse arguments for unified encoding applications.
+    
+    These apps support unlimited frame counts and both CPU/GPU buffer modes.
+    """
+    parser = argparse.ArgumentParser(description=description)
+    add_unified_args(parser)
+    add_encode_args(parser, enforce_frame_limit=False)
+    args = parser.parse_args()
+    args.config = load_config(args)
+    return args
+
+def parse_sei_encode_args(description: str = None) -> argparse.Namespace:
+    """Parse arguments for SEI encoding applications.
+    
+    These apps use GPU buffer mode only and support unlimited frame counts.
+    Note: No buffer mode argument as these apps only support GPU buffer mode.
+    """
+    parser = argparse.ArgumentParser(description=description)
+    
+    # Add encode args manually without buffer mode
+    parser.add_argument(
+        "-g", "--gpu_id",
+        type=int,
+        default=0,
+        help="Check nvidia-smi for available GPUs. Default: 0"
+    )
+    parser.add_argument(
+        "-i", "--raw_file_path",
+        type=Path,
+        required=True,
+        help="Raw video file to encode"
+    )
+    parser.add_argument(
+        "-o", "--encoded_file_path",
+        type=Path,
+        help="Encoded video file (write to). Default: <input_file_name>.<codec>"
+    )
+    parser.add_argument(
+        "-s", "--size",
+        type=str,
+        required=True,
+        help="WidthxHeight of raw frame (e.g., 1920x1080)"
+    )
+    parser.add_argument(
+        "-if", "--format",
+        type=str,
+        default="NV12",
+        help="Format of input file. Default: NV12"
+    )
+    parser.add_argument(
+        "-c", "--codec",
+        type=str,
+        default=None,
+        choices=["h264", "hevc", "av1"],
+        help="Output codec (h264/hevc/av1). Overrides the codec in the JSON config file."
+    )
+    parser.add_argument(
+        "-json", "--config_file",
+        type=str,
+        default=join(dirname(dirname(__file__)), "advanced", "encode_config.json"),
+        help="Path of JSON config file (default: encode_config.json in samples directory)"
+    )
+    parser.add_argument(
+        "-f", "--frame_count",
+        type=int,
+        default=0,
+        help="Number of frames to encode (0 for all frames). Default: 0"
+    )
+
+    args = parser.parse_args()
+    args.config = load_config(args)
+    return args
+
+def parse_reconfigure_encode_args(description: str = None) -> argparse.Namespace:
+    """Parse arguments for encoder reconfiguration applications.
+    
+    These apps use GPU buffer mode only and support unlimited frame counts.
+    Note: No buffer mode argument as these apps only support GPU buffer mode.
+    """
+    parser = argparse.ArgumentParser(description=description)
+    
+    # Add encode args without buffer mode
+    parser.add_argument(
+        "-g", "--gpu_id",
+        type=int,
+        default=0,
+        help="Check nvidia-smi for available GPUs. Default: 0"
+    )
+    parser.add_argument(
+        "-i", "--raw_file_path",
+        type=Path,
+        required=True,
+        help="Raw video file to encode"
+    )
+    parser.add_argument(
+        "-o", "--encoded_file_path",
+        type=Path,
+        help="Encoded video file (write to). Default: <input_file_name>.<codec>"
+    )
+    parser.add_argument(
+        "-s", "--size",
+        type=str,
+        required=True,
+        help="WidthxHeight of raw frame (e.g., 1920x1080)"
+    )
+    parser.add_argument(
+        "-if", "--format",
+        type=str,
+        default="NV12",
+        help="Format of input file. Default: NV12"
+    )
+    parser.add_argument(
+        "-c", "--codec",
+        type=str,
+        default=None,
+        choices=["h264", "hevc", "av1"],
+        help="Output codec (h264/hevc/av1). Overrides the codec in the JSON config file."
+    )
+    parser.add_argument(
+        "-json", "--config_file",
+        type=str,
+        default=join(dirname(dirname(__file__)), "advanced", "encode_config_lowlatency.json"),
+        help="Path of JSON config file (default: encode_config_lowlatency.json in samples directory)"
+    )
+    parser.add_argument(
+        "-f", "--frame_count",
+        type=int,
+        default=0,
+        help="Number of frames to encode (0 for all frames). Default: 0"
+    )
+    parser.add_argument(
+        "-tq", "--reconfigure_target_quality",
+        action="store_true",
+        help="Also reconfigure targetQuality when alternating bitrate (requires cq in config)"
+    )
+
+    args = parser.parse_args()
+    args.config = load_config(args)
+    return args
+
+

samples/utils/frame_utils.py

@@ -0,0 +1,89 @@
+# 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 frame and memory management in video encoding/decoding.
+"""
+
+import mmap
+import sys
+import pycuda.driver as cuda
+
+def get_frame_size(width: int, height: int, surface_format: str) -> int:
+    """
+    Calculate the size of a frame in bytes based on its dimensions and format.
+
+    Parameters:
+        width (int): Width of the frame
+        height (int): Height of the frame
+        surface_format (str): Format of the surface (e.g., "NV12", "ARGB", "YUV444")
+
+    Returns:
+        int: Size of the frame in bytes
+    """
+    if surface_format in ("ARGB", "ABGR"):
+        return width * height * 4
+    elif surface_format == "YUV444":
+        return width * height * 3
+    elif surface_format == "YUV420":
+        return int(width * height * 3 / 2)
+    elif surface_format == "P010":
+        return int(width * height * 3 / 2 * 2)
+    elif surface_format == "YUV444_16BIT":
+        return int(width * height * 3 * 2)
+    elif surface_format == "NV16":
+        return width * height * 2
+    elif surface_format == "P210":
+        return width * height * 2 * 2
+    else:  # Default NV12
+        return int(width * height * 3 / 2)
+
+def create_memory_map(file_handle, access_read=True) -> mmap.mmap:
+    """
+    Create a memory map for a file with cross-platform support.
+
+    Parameters:
+        file_handle: File object to memory map
+        access_read: If True, create read-only mapping, else read-write
+
+    Returns:
+        mmap.mmap: Memory mapped file object
+    """
+    if sys.platform == 'win32':
+        return mmap.mmap(file_handle.fileno(), 0, access=mmap.ACCESS_READ if access_read else mmap.ACCESS_WRITE)
+    else:
+        return mmap.mmap(file_handle.fileno(), 0, prot=mmap.PROT_READ if access_read else mmap.PROT_WRITE)
+
+def allocate_device_memory(host_data) -> cuda.DeviceAllocation:
+    """
+    Allocate CUDA device memory and copy host data.
+
+    Parameters:
+        host_data: Data to copy to device
+
+    Returns:
+        cuda.DeviceAllocation: Allocated device memory with copied data
+    """
+    device_data = cuda.mem_alloc(len(host_data))
+    cuda.memcpy_htod(device_data, host_data)
+    return device_data

samples/utils/sei_message_parser.py

@@ -0,0 +1,223 @@
+# 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.
+
+"""
+SEI message structures and parsing utilities.
+"""
+
+import ctypes
+import pickle
+import os
+from os.path import join, dirname, abspath
+import PyNvVideoCodec as nvc
+
+# Constants
+MAX_CLOCK_TS = 3
+
+class TIMECODESET(ctypes.Structure):
+    """Structure for time code set information."""
+    _fields_ = [
+        ("time_offset_value", ctypes.c_uint32),  # unsigned int
+        ("n_frames", ctypes.c_uint16),  # unsigned short
+        ("clock_timestamp_flag", ctypes.c_uint8),  # unsigned char
+        ("units_field_based_flag", ctypes.c_uint8),  # unsigned char
+        ("counting_type", ctypes.c_uint8),  # unsigned char
+        ("full_timestamp_flag", ctypes.c_uint8),  # unsigned char
+        ("discontinuity_flag", ctypes.c_uint8),  # unsigned char
+        ("cnt_dropped_flag", ctypes.c_uint8),  # unsigned char
+        ("seconds_value", ctypes.c_uint8),  # unsigned char
+        ("minutes_value", ctypes.c_uint8),  # unsigned char
+        ("hours_value", ctypes.c_uint8),  # unsigned char
+        ("seconds_flag", ctypes.c_uint8),  # unsigned char
+        ("minutes_flag", ctypes.c_uint8),  # unsigned char
+        ("hours_flag", ctypes.c_uint8),  # unsigned char
+        ("time_offset_length", ctypes.c_uint8),  # unsigned char
+        ("reserved", ctypes.c_uint8),  # unsigned char
+    ]
+
+    def __repr__(self):
+        return (
+            "TIMECODESET(\n"
+            f"    time_offset_value={self.time_offset_value},\n"
+            f"    n_frames={self.n_frames},\n"
+            f"    clock_timestamp_flag={self.clock_timestamp_flag},\n"
+            f"    units_field_based_flag={self.units_field_based_flag},\n"
+            f"    counting_type={self.counting_type},\n"
+            f"    full_timestamp_flag={self.full_timestamp_flag},\n"
+            f"    discontinuity_flag={self.discontinuity_flag},\n"
+            f"    cnt_dropped_flag={self.cnt_dropped_flag},\n"
+            f"    seconds_value={self.seconds_value},\n"
+            f"    minutes_value={self.minutes_value},\n"
+            f"    hours_value={self.hours_value},\n"
+            f"    seconds_flag={self.seconds_flag},\n"
+            f"    minutes_flag={self.minutes_flag},\n"
+            f"    hours_flag={self.hours_flag},\n"
+            f"    time_offset_length={self.time_offset_length},\n"
+            f"    reserved={self.reserved}\n"
+            ")"
+        )
+
+class TIMECODE(ctypes.Structure):
+    """Structure for time code information."""
+    _fields_ = [
+        ("time_code_set", TIMECODESET * MAX_CLOCK_TS),  # Array of TIMECODESET
+        ("num_clock_ts", ctypes.c_uint8),  # unsigned char
+    ]
+
+    def __repr__(self):
+        time_code_set_repr = ",\n        ".join(
+            repr(self.time_code_set[i]) for i in range(self.num_clock_ts)
+        )
+        return (
+            "TIMECODE(\n"
+            f"    time_code_set=[\n        {time_code_set_repr}\n    ],\n"
+            f"    num_clock_ts={self.num_clock_ts}\n"
+            ")"
+        )
+
+class SEICONTENTLIGHTLEVELINFO(ctypes.Structure):
+    """Structure for content light level information."""
+    _fields_ = [
+        ("max_content_light_level", ctypes.c_uint16),  # unsigned short
+        ("max_pic_average_light_level", ctypes.c_uint16),  # unsigned short
+        ("reserved", ctypes.c_uint32),  # unsigned int
+    ]
+
+    def __repr__(self):
+        return (
+            "SEICONTENTLIGHTLEVELINFO(\n"
+            f"    max_content_light_level={self.max_content_light_level},\n"
+            f"    max_pic_average_light_level={self.max_pic_average_light_level},\n"
+            f"    reserved={self.reserved}\n"
+            ")"
+        )
+
+class SEIMASTERINGDISPLAYINFO(ctypes.Structure):
+    """Structure for mastering display information."""
+    _fields_ = [
+        ("display_primaries_x", ctypes.c_uint16 * 3),  # Array of 3 unsigned short
+        ("display_primaries_y", ctypes.c_uint16 * 3),  # Array of 3 unsigned short
+        ("white_point_x", ctypes.c_uint16),  # unsigned short
+        ("white_point_y", ctypes.c_uint16),  # unsigned short
+        ("max_display_mastering_luminance", ctypes.c_uint32),  # unsigned int
+        ("min_display_mastering_luminance", ctypes.c_uint32),  # unsigned int
+    ]
+
+    def __repr__(self):
+        return (
+            "SEIMASTERINGDISPLAYINFO(\n"
+            f"    display_primaries_x={list(self.display_primaries_x)},\n"
+            f"    display_primaries_y={list(self.display_primaries_y)},\n"
+            f"    white_point_x={self.white_point_x},\n"
+            f"    white_point_y={self.white_point_y},\n"
+            f"    max_display_mastering_luminance={self.max_display_mastering_luminance},\n"
+            f"    min_display_mastering_luminance={self.min_display_mastering_luminance}\n"
+            ")"
+        )
+    
+class TIMECODEMPEG2(ctypes.Structure):
+    """Structure for MPEG2 time code information."""
+    _fields_ = [
+        ("drop_frame_flag", ctypes.c_uint8),  # unsigned char
+        ("time_code_hours", ctypes.c_uint8),  # unsigned char
+        ("time_code_minutes", ctypes.c_uint8),  # unsigned char
+        ("marker_bit", ctypes.c_uint8),  # unsigned char
+        ("time_code_seconds", ctypes.c_uint8),  # unsigned char
+        ("time_code_pictures", ctypes.c_uint8),  # unsigned char
+    ]
+
+    def __repr__(self):
+        return (
+            "TIMECODEMPEG2(\n"
+            f"    drop_frame_flag={self.drop_frame_flag},\n"
+            f"    time_code_hours={self.time_code_hours},\n"
+            f"    time_code_minutes={self.time_code_minutes},\n"
+            f"    marker_bit={self.marker_bit},\n"
+            f"    time_code_seconds={self.time_code_seconds},\n"
+            f"    time_code_pictures={self.time_code_pictures}\n"
+            ")"
+        )
+
+class SEIALTERNATIVETRANSFERCHARACTERISTICS(ctypes.Structure):
+    """Structure for alternative transfer characteristics."""
+    _fields_ = [
+        ("preferred_transfer_characteristics", ctypes.c_uint8),  # unsigned char
+    ]
+    
+    def __repr__(self):
+        return f"SEIALTERNATIVETRANSFERCHARACTERISTICS(preferred_transfer_characteristics={self.preferred_transfer_characteristics})"
+
+def write_sei_messages(sei_messages, sei_file_path, script_dir=None):
+    """
+    Write SEI messages to output files.
+
+    This function writes SEI messages in three formats:
+    1. sei_message.bin - Raw binary SEI messages
+    2. sei_type_message.bin - Pickled SEI type information
+    3. sei_message.txt - Human-readable parsed SEI content
+
+    Parameters:
+        sei_messages (list): List of tuples containing (sei_info, sei_message)
+        sei_file_path (str): Path to output file (base name for all three files)
+        script_dir (str, optional): Directory for type message file. If None, uses sei_file_path's directory.
+
+    Returns:
+        None
+    """
+    # Determine output paths
+    if script_dir is None:
+        script_dir = dirname(abspath(sei_file_path))
+    
+    sei_type_message_path = join(script_dir, "sei_type_message.bin")
+    
+    # Open files for storing SEI data
+    with open(sei_file_path, "wb") as file_message, \
+         open(sei_type_message_path, "wb") as file_type_message:
+        
+        for sei_info, sei_message in sei_messages:
+            sei_type = sei_info["sei_type"]
+            sei_uncompressed = sei_info["sei_uncompressed"]
+            
+            if sei_uncompressed == 1:
+                buffer = (ctypes.c_ubyte * len(sei_message))(*sei_message)
+                sei_struct = None
+                
+                # Handle different SEI message types
+                if sei_type in (nvc.SEI_TYPE.TIME_CODE_H264, nvc.SEI_TYPE.TIME_CODE):
+                    sei_struct = ctypes.cast(
+                        buffer,
+                        ctypes.POINTER(TIMECODEMPEG2 if codec_id == nvc.cudaVideoCodec.MPEG2 else TIMECODE)
+                    ).contents
+                elif sei_type == nvc.SEI_TYPE.MASTERING_DISPLAY_COLOR_VOLUME:
+                    sei_struct = ctypes.cast(buffer, ctypes.POINTER(SEIMASTERINGDISPLAYINFO)).contents
+                elif sei_type == nvc.SEI_TYPE.CONTENT_LIGHT_LEVEL_INFO:
+                    sei_struct = ctypes.cast(buffer, ctypes.POINTER(SEICONTENTLIGHTLEVELINFO)).contents
+                elif sei_type == nvc.SEI_TYPE.ALTERNATIVE_TRANSFER_CHARACTERISTICS:
+                    sei_struct = ctypes.cast(buffer, ctypes.POINTER(SEIALTERNATIVETRANSFERCHARACTERISTICS)).contents
+                
+                if sei_struct:
+                    print(sei_struct)
+                    
+            file_message.write(bytearray(sei_message))
+        pickle.dump(sei_messages, file_type_message)
+        print(f"SEI message written to {sei_file_path}")