PyNvVideoCodec 2.0.0__cp313-cp313-win_amd64.whl

samples/Encode.py

@@ -0,0 +1,189 @@
+# This copyright notice applies to this file only
+#
+# SPDX-FileCopyrightText: Copyright (c) 2025 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.
+
+import PyNvVideoCodec as nvc
+import json
+import argparse
+from pathlib import Path
+import io
+import os
+import sys
+from os.path import join, dirname, abspath
+
+# Add the parent directory to Python path in a way that works from any working directory
+current_dir = dirname(abspath(__file__))
+parent_dir = dirname(current_dir)
+if parent_dir not in sys.path:
+    sys.path.append(parent_dir)
+
+from Utils import AppFrame
+from Utils import FetchCPUFrame
+from Utils import FetchGPUFrame
+
+
+def encode(gpu_id, dec_file_path, enc_file_path, width, height, fmt, config_params, frame_count=1000):
+    """
+    Encode frames using CUDA device buffers as input.
+
+    This function reads image data from a file and loads it to CUDA input buffers using
+    FetchGPUFrame(). The encoder copies the CUDA buffers and submits them to NVENC hardware
+    for encoding. Video memory buffer is allocated to get the NVENC hardware output.
+    The output is copied from video memory to host memory for file storage.
+
+    Parameters:
+        gpu_id (int): Ordinal of GPU to use
+        dec_file_path (str): Path to file to be decoded
+        enc_file_path (str): Path to output file for encoded frames
+        width (int): Width of encoded frame
+        height (int): Height of encoded frame
+        fmt (str): Surface format string in uppercase (e.g., "NV12")
+        config_params (dict): Key-value pairs providing fine-grained control on encoding
+        frame_count (int, optional): Number of frames to encode. If None, 0, or negative, encode all frames from input.
+
+    Returns:
+        None
+
+    Example:
+        >>> encode(0, "input.yuv", "output.h264", 1920, 1080, "NV12", {"codec": "h264"})
+        Encode 1080p NV12 raw YUV into elementary bitstream using H.264 codec
+    """
+    try:
+        caps = nvc.GetEncoderCaps(codec=config_params["codec"])
+        if "num_encoder_engines" in caps:
+            print(f"Number of NVENCs: {caps['num_encoder_engines']}")
+
+        with open(dec_file_path, "rb") as decFile, open(enc_file_path, "wb") as encFile:
+            config_params["gpu_id"] = gpu_id
+            nvenc = nvc.CreateEncoder(width, height, fmt, False, **config_params)
+            input_frame_list = [AppFrame(width, height, fmt) for _ in range(1, 5)]
+            
+            # Calculate total available frames from file size
+            file_size = os.path.getsize(dec_file_path)
+            available_frames = file_size // input_frame_list[0].frameSize
+            
+            if frame_count is None or frame_count == 0:
+                print(f"Encoding all available frames")
+                frame_count = available_frames
+            elif frame_count < 0 or frame_count > available_frames:
+                print(f"Warning: Invalid frame count {frame_count}. Encoding all available frames.")
+                frame_count = available_frames
+            
+            for input_gpu_frame in FetchGPUFrame(
+                input_frame_list,
+                FetchCPUFrame(decFile, input_frame_list[0].frameSize),
+                frame_count
+            ):
+                bitstream = nvenc.Encode(input_gpu_frame)
+                bitstream = bytearray(bitstream)
+                encFile.write(bitstream)
+            bitstream = nvenc.EndEncode()  # flush encoder queue
+            bitstream = bytearray(bitstream)
+            encFile.write(bitstream)
+    except nvc.PyNvVCExceptionUnsupported as e:
+        print(f"CreateEncoder failure: {e}")
+    except Exception as e:
+        print(f"An unexpected error occurred: {e}")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="This sample application illustrates encoding of frames using CUDA device buffers as input."
+    )
+
+    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 (read from)"
+    )
+    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="h264",
+        help="Video codec. Default is h264. (other options: hevc, av1)"
+    )
+    parser.add_argument(
+        "-json", "--config_file",
+        type=str,
+        default=join(current_dir, "encode_config.json"),
+        help="Path of JSON config file (default: encode_config.json in the same directory)"
+    )
+    parser.add_argument(
+        "-f", "--frame_count",
+        type=int,
+        default=0,
+        help="Number of frames to encode (0 for all frames)"
+    )
+
+    args = parser.parse_args()
+    config = {}
+
+    # Set default encoded_file_path if not provided
+    if args.encoded_file_path is None:
+        input_path = Path(args.raw_file_path)
+        args.encoded_file_path = input_path.with_suffix(f'.{args.codec}')
+
+    if args.config_file:
+        with open(args.config_file) as jsonFile:
+            config = json.loads(jsonFile.read())
+            config["preset"] = config["preset"].upper()
+
+    args.codec = args.codec.lower()
+    args.format = args.format.upper()
+    config["codec"] = args.codec
+    width, height = map(int, args.size.split("x"))
+
+    encode(
+        args.gpu_id,
+        args.raw_file_path.as_posix(),
+        args.encoded_file_path.as_posix(),
+        width,
+        height,
+        args.format,
+        config,
+        args.frame_count
+    )
+    print(f"Encoded frames written to {args.encoded_file_path}")

samples/EncodeFromCPUBuffer.py

@@ -0,0 +1,220 @@
+# This copyright notice applies to this file only
+#
+# SPDX-FileCopyrightText: Copyright (c) 2025 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.
+
+import PyNvVideoCodec as nvc
+import numpy as np
+import json
+import argparse
+from pathlib import Path
+import os
+from os.path import join, dirname, abspath
+import sys
+
+# Add the parent directory to Python path in a way that works from any working directory
+current_dir = dirname(abspath(__file__))
+parent_dir = dirname(current_dir)
+if parent_dir not in sys.path:
+    sys.path.append(parent_dir)
+
+
+def GetFrameSize(width, height, surface_format):
+    """
+    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)
+    else:
+        return int(width * height * 3 / 2)
+
+
+def FetchCPUFrame(dec_file, frame_size):
+    """
+    Generator function to fetch frames from a file.
+
+    Parameters:
+        dec_file: File object to read from
+        frame_size (int): Size of each frame in bytes
+
+    Yields:
+        numpy.ndarray: Frame data as a numpy array
+    """
+    yield np.fromfile(dec_file, np.uint8, count=frame_size)
+
+
+def encode(gpu_id, dec_file_path, enc_file_path, width, height, fmt, config_params, frame_count=None):
+    """
+    Encode frames using host memory buffers as input.
+
+    This function reads image data from a file and copies it to CUDA buffers for encoding.
+    The encoder submits the data to NVENC hardware for encoding. Video memory buffer is
+    allocated to get the NVENC hardware output. The output is copied from video memory
+    to host memory for file storage.
+
+    Parameters:
+        gpu_id (int): Ordinal of GPU to use.
+        dec_file_path (str): Path to file to be decoded
+        enc_file_path (str): Path to output file for encoded frames
+        width (int): Width of encoded frame
+        height (int): Height of encoded frame
+        fmt (str): Surface format string in uppercase (e.g., "NV12")
+        config_params (dict): Key-value pairs providing fine-grained control on encoding
+        frame_count (int, optional): Number of frames to encode. If None, 0 or negative, encodes all frames from input.
+
+    Returns:
+        None
+
+    Example:
+        >>> encode(0, "input.yuv", "output.h264", 1920, 1080, "NV12", 1, {"codec": "h264"})
+        Encode 1080p NV12 raw YUV into elementary bitstream using H.264 codec
+    """
+    try:
+        frame_size = GetFrameSize(width, height, fmt)
+        with open(dec_file_path, "rb") as dec_file, open(enc_file_path, "wb") as enc_file:
+            config_params["gpu_id"] = gpu_id
+            nvenc = nvc.CreateEncoder(width, height, fmt, True, **config_params)  # create encoder object
+            
+            # Calculate total available frames from file size
+            file_size = os.path.getsize(dec_file_path)
+            available_frames = file_size // frame_size
+            
+            if frame_count is None or frame_count == 0:
+                print(f"Encoding all available frames")
+                frame_count = available_frames
+            elif frame_count < 0 or frame_count > available_frames:
+                print(f"Warning: Invalid frame count {frame_count}. Encoding all available frames.")
+                frame_count = available_frames
+            
+            for _ in range(frame_count):
+                chunk = np.fromfile(dec_file, np.uint8, count=frame_size)
+                if chunk.size != 0:
+                    bitstream = nvenc.Encode(chunk)
+                    enc_file.write(bytearray(bitstream))
+            
+            # Flush encoder queue
+            bitstream = nvenc.EndEncode()
+            enc_file.write(bytearray(bitstream))
+            print(f"Encoded {frame_count} frames. Output file: {enc_file_path}")
+    except nvc.PyNvVCExceptionUnsupported as e:
+        print(f"CreateEncoder failure: {e}")
+    except Exception as e:
+        print(f"An unexpected error occurred: {e}")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="This sample application illustrates encoding of frames using host memory buffers as input."
+    )
+
+    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 (read from)"
+    )
+    parser.add_argument(
+        "-o", "--encoded_file_path",
+        type=Path,
+        help="Encoded video file (write to). Default: <raw_file_path>.<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="H264", 
+        help="Video codec (HEVC, H264, AV1). (default: H264)"
+    )
+    parser.add_argument(
+    "-json", "--config_file",
+    type=str,
+    default=join(current_dir, "encode_config.json"),
+    help="Path of JSON config file (default: encode_config.json in the same directory)"
+)
+    
+    parser.add_argument(
+        "-f", "--frame_count",
+        type=int,
+        default=0,
+        help="Number of frames to encode (0 for all frames)"
+    )
+
+    args = parser.parse_args()
+    config = {}
+
+    # Set default encoded_file_path if not provided
+    if args.encoded_file_path is None:
+        input_path = Path(args.raw_file_path)
+        args.encoded_file_path = input_path.with_suffix(f'.{args.codec}')
+
+    if args.config_file:
+        with open(args.config_file) as jsonFile:
+            config = json.loads(jsonFile.read())
+            config["preset"] = config["preset"].upper()
+
+    args.codec = args.codec.lower()
+    args.format = args.format.upper()
+    config["codec"] = args.codec
+    width, height = map(int, args.size.split("x"))
+
+    encode(
+        args.gpu_id,
+        args.raw_file_path.as_posix(),
+        args.encoded_file_path.as_posix(),
+        width,
+        height,
+        args.format,
+        config,
+        args.frame_count
+    )

samples/EncodeMultiprocessing.py

@@ -0,0 +1,268 @@
+# This copyright notice applies to this file only
+#
+# SPDX-FileCopyrightText: Copyright (c) 2025 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.
+
+import argparse
+from pathlib import Path
+import pycuda.driver as cuda
+import PyNvVideoCodec as nvc
+from pycuda.autoinit import context
+import mmap
+import json
+import multiprocessing
+from multiprocessing import Process
+import os
+import sys
+from os.path import join, dirname, abspath
+
+# Add the parent directory to Python path in a way that works from any working directory
+current_dir = dirname(abspath(__file__))
+parent_dir = dirname(current_dir)
+if parent_dir not in sys.path:
+    sys.path.append(parent_dir)
+
+from Utils import AppFramePerf
+
+
+def GetFrameSize(width, height, surface_format):
+    """
+    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)
+    else:
+        return int(width * height * 3 / 2)
+
+
+def encode_process(gpu_id, dec_file_path, width, height, fmt, h, framesize, config_params, frame_count=None):
+    """
+    Function to encode frames in a separate process.
+
+    This function demonstrates how to set up and run video encoding in a separate process,
+    showing proper handling of CUDA contexts and device memory in a multiprocessing environment.
+
+    Parameters:
+        gpu_id (int): Ordinal of GPU to use
+        dec_file_path (str): Path to file to be decoded
+        width (int): Width of encoded frame
+        height (int): Height of encoded frame
+        fmt (str): Surface format string in uppercase (e.g., "NV12")
+        h: IPC memory handle for CUDA device memory
+        framesize (int): Size of each frame in bytes
+        config_params (dict): Key-value pairs providing fine-grained control on encoding
+        frame_count (int, optional): Number of frames to encode. If None, 0, or negative, encode all frames from input.
+
+    Returns:
+        None
+    """
+    try:
+        process_id = multiprocessing.current_process().name
+        print(f"Starting encode process {process_id}")
+        
+        config_params["gpu_id"] = gpu_id
+        nvenc = nvc.CreateEncoder(width, height, fmt, False, **config_params)
+        devicedata = cuda.IPCMemoryHandle(h)
+        input_gpu_frame = AppFramePerf(width, height, fmt, devicedata, 0)
+        
+        # Calculate total available frames from file size
+        file_size = os.path.getsize(dec_file_path)
+        available_frames = file_size // framesize
+        
+        if frame_count is None or frame_count == 0:
+            print(f"Encoding all available frames")
+            frame_count = available_frames
+        elif frame_count < 0 or frame_count > available_frames:
+            print(f"Warning: Invalid frame count {frame_count}. Process {process_id} will process all available frames.")
+            frame_count = available_frames 
+        
+        frames_encoded = 0
+        for i in range(frame_count):
+            input_gpu_frame.gpuAlloc = int(devicedata) + (i * framesize)
+            bitstream = nvenc.Encode(input_gpu_frame)
+            frames_encoded += 1
+    
+        # Flush encoder queue
+        bitstream = nvenc.EndEncode()
+        print(f"Process {process_id} completed encoding {frames_encoded} frames")
+
+    except nvc.PyNvVCExceptionUnsupported as e:
+        print(f"CreateEncoder failure in process {process_id}: {e}")
+    except Exception as e:
+        print(f"An unexpected error occurred in process {process_id}: {e}")
+
+
+def run_parallel_encode(num_processes, gpu_id, enc_file_path, width, height, fmt, framesize, config, frame_count=None):
+    """
+    Demonstrates parallel video encoding using multiple processes.
+
+    This function shows how to:
+    1. Set up shared device memory for multiple encoder processes
+    2. Create and manage multiple encoding processes
+    3. Handle CUDA IPC memory in a multiprocessing context
+    4. Coordinate multiple encoder instances running in parallel
+
+    Parameters:
+        num_processes (int): Number of parallel encoding processes to run
+        gpu_id (int): Ordinal of GPU to use
+        enc_file_path (str): Path to file to be encoded
+        width (int): Width of encoded frame
+        height (int): Height of encoded frame
+        fmt (str): Surface format string
+        framesize (int): Size of each frame in bytes
+        config (dict): Encoder configuration parameters
+        frame_count (int, optional): Number of frames for each process to encode
+    """
+    processes = []
+    
+    print(f"Initializing {num_processes} encoder processes")
+    
+    with open(enc_file_path, "rb") as decFile:
+        # Cross-platform memory mapping
+        if sys.platform == 'win32':
+            m = mmap.mmap(decFile.fileno(), 0, access=mmap.ACCESS_READ)
+        else:
+            m = mmap.mmap(decFile.fileno(), 0, prot=mmap.PROT_READ)
+            
+        hostdata = m.read(m.size())
+        devicedata = cuda.mem_alloc(m.size())
+        cuda.memcpy_htod(devicedata, hostdata)
+        devptrhandle = cuda.mem_get_ipc_handle(devicedata)
+
+        for i in range(num_processes):
+            p = Process(
+                target=encode_process,
+                args=(
+                    gpu_id,
+                    enc_file_path,
+                    width,
+                    height,
+                    fmt,
+                    devptrhandle,
+                    framesize,
+                    config,
+                    frame_count
+                )
+            )
+            p.start()
+            processes.append(p)
+
+        for p in processes:
+            p.join()
+            
+    print("All encoding processes completed")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="This sample application demonstrates video encoding using multiple processes."
+    )
+    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="H264",
+        help="Video codec (HEVC, H264, AV1). Default: H264"
+    )
+    parser.add_argument(
+        "-json", "--config_file",
+        type=str,
+        default=join(dirname(__file__), "encode_config_perf.json"),
+        help="Path of JSON config file (default: encode_config_perf.json in the same directory)"
+    )
+    parser.add_argument(
+        "-n", "--num_processes",
+        type=int,
+        default=1,
+        help="Number of parallel encoding processes. Default: 1"
+    )
+    parser.add_argument(
+        "-f", "--frame_count",
+        type=int,
+        help="Number of frames for each process to encode. If not specified, encodes all frames."
+    )
+
+    args = parser.parse_args()
+    config = {}
+
+    if args.config_file:
+        with open(args.config_file) as jsonFile:
+            config = json.loads(jsonFile.read())
+            config["preset"] = config["preset"].upper()
+
+    args.codec = args.codec.lower()
+    args.format = args.format.upper()
+    config["codec"] = args.codec
+    width, height = map(int, args.size.split("x"))
+    framesize = GetFrameSize(width, height, args.format)
+
+    multiprocessing.set_start_method('spawn')
+
+    run_parallel_encode(
+        args.num_processes,
+        args.gpu_id,
+        args.raw_file_path.as_posix(),
+        width,
+        height,
+        args.format,
+        framesize,
+        config,
+        args.frame_count
+    )