rocPyDecode

https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/
Admin
rocPyDecode provides Python bindings for the rocDecode C++ APIs, enabling GPU-accelerated video...
Tokens:13,526
Snippets:182
Trust Score:10
Update:5 months ago
Show doc for...
Tokens:
Raw
### Install libstdc++-12-dev on Ubuntu

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/how-to/rocPyDecode-wheel.html

Install the `libstdc++-12-dev` package on Ubuntu 22.04 if required for building the wheel.

```bash
apt install libstdc++-12-dev
```

--------------------------------

### Install Deb Packages

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/install/rocPyDecode-cmake-install.html

Install the generated deb packages using apt. This includes the main library and test packages.

```bash
sudo apt install ./rocpydecode_0.8.0-local_amd64.deb
sudo apt install ./rocpydecode-test_0.8.0-local_amd64.deb

```

--------------------------------

### Build and Install rocPyDecode

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/install/rocPyDecode-cmake-install.html

Compile the project using make with parallel jobs and then install the built components.

```bash
make -j8
sudo make install

```

--------------------------------

### Install rocPyDecode using pip

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/how-to/rocPyDecode-wheel.html

Install the rocPyDecode package using pip after ensuring all requirements are met.

```bash
pip3 install .
```

--------------------------------

### Set Reconfiguration Parameters

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/reference/decoderClass.html

Configure flush mode and output file name for multi-resolution video. Flush mode 0 flushes to get frame count, while mode 1 dumps remaining frames to a file. Specify the full path for the output file.

```python
# set reconfiguration params based on user arguments
flush_mode = 0

if (output_file_path is not None):
        flush_mode = 1

viddec.SetReconfigParams(flush_mode, output_file_path if (output_file_path is not None) else str(""))

```

--------------------------------

### Get GPU Device Information

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/reference/structures.html

Retrieves GPU device information using GetGpuInfo. The returned ConfigInfo structure contains details like device name, architecture, and PCI IDs.

```python
# Get GPU device information
cfg = viddec.GetGpuInfo()

#  print GPU info out
print("GPU device " + str(device_id) + " \- " + cfg.device_name + "[" + cfg.gcn_arch_name + "] on PCI bus " + str(cfg.pci_bus_id) + ":" + str(cfg.pci_domain_id) + "." + str(cfg.pci_device_id))
```

--------------------------------

### Get GPU Device Information

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/reference/decoderClass.html

Retrieve and print detailed information about the GPU device being used by the decoder, including device name, architecture, and PCI bus details.

```python
# Get GPU device information
cfg = viddec.GetGpuInfo()

# print GPU info out
print("GPU device " + str(device_id) + " \- " + cfg.device_name + "[" + cfg.gcn_arch_name + "] on PCI bus " + str(cfg.pci_bus_id) + ":" + str(cfg.pci_domain_id) + "." + str(cfg.pci_device_id))

```

--------------------------------

### SeekFrame

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/reference/demuxerClass.html

Demuxes the video file starting from specified seek parameters.

```APIDOC
#### SeekFrame(frame_number, seek_mode, seek_criteria)
Demux the input video file starting from the specified seek parameters. Returns a Packet structure for use in decoding the demuxed frames.
Input: - **frame_number** : Seek this number of frames - **seek_mode** : 0 - Seek by exact frame number, 1 - Seek by previous key frame - **seek_criteria** : 0 - Seek by frame number, 1 - Seek by time stamp
### Example:
```python
not_seeking = False

seek_frame = 100     # seek to the 100th frames
seek_mode = 0        # by exact frame number
seek_criteria = 0    # by frame number

# The decoding loop to start by seek
while True:
        start_time = datetime.datetime.now()
        if(not_seeking):
                packet = demuxer.DemuxFrame()
        else:
                packet = demuxer.SeekFrame(seek_frame, seek_mode, seek_criteria)
                not_seeking = True
```
```

--------------------------------

### Configure CMake for Hidden Python Installation

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/install/rocPyDecode-cmake-install.html

Use the -DPYTHON_FOLDER_SUGGESTED directive to include a hidden Python installation, such as one in a conda environment, in the build targets.

```bash
cmake -DPYTHON_FOLDER_SUGGESTED=/opt/miniconda3/bin/python3 ../

```

--------------------------------

### Configure CMake for Specific Python Version

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/install/rocPyDecode-cmake-install.html

Use the -DPYTHON_VERSION_SUGGESTED directive to build and install rocPyDecode and rocPyJpegDecode for a specific Python version, like 3.12.

```bash
cmake -DPYTHON_VERSION_SUGGESTED=3.12  ../

```

--------------------------------

### Get Codec ID for Decoder

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/how-to/using-rocPydecode.html

Obtain the specific codec ID required for the decoder. This is done by first getting the codec ID from the demuxer and then converting it using `GetRocDecCodecID`.

```python
codec_id = dec.GetRocDecCodecID(demuxer.GetCodecId())
```

--------------------------------

### Get Demuxer Codec ID

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/reference/demuxerClass.html

Obtain the codec ID from the demuxer instance to initialize the decoder. Ensure the correct RocDecCodecID is used.

```python
# demuxer instance
demuxer = dmx.demuxer(input_file_path)

# get the used coded id
codec_id = dec.GetRocDecCodecID(demuxer.GetCodecId())
# decoder instance
viddec = dec.decoder(device_id, mem_type, codec_id, b_force_zero_latency, crop_rect, 0, 0, 1000)

```

--------------------------------

### Seek to Specific Frame

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/reference/demuxerClass.html

Demuxes frames starting from a specified frame number using either exact frame matching or seeking to the previous key frame. Seek criteria can be by frame number or timestamp.

```python
not_seeking = False

seek_frame = 100     # seek to the 100th frames
seek_mode = 0        # by exact frame number
seek_criteria = 0    # by frame number

# The decoding loop to start by seek
while True:
        start_time = datetime.datetime.now()
        if(not_seeking):
                packet = demuxer.DemuxFrame()
        else:
                packet = demuxer.SeekFrame(seek_frame, seek_mode, seek_criteria)
                not_seeking = True

```

--------------------------------

### Build rocPyDecode Wheel using setup.py

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/how-to/rocPyDecode-wheel.html

Alternatively, generate the wheel distribution file for rocPyDecode using the standard `setup.py` script.

```python
python3 setup.py bdist_wheel
```

--------------------------------

### Instantiate Demuxer

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/how-to/using-rocPydecode.html

Create an instance of the demuxer by providing the path to the video file. This prepares the file for reading.

```python
demuxer = dmx.demuxer(input_file_path)
```

--------------------------------

### Instantiate Decoder with Parameters

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/how-to/using-rocPydecode.html

Initialize the decoder instance. The `codec_id` is mandatory, while other parameters like `device_id`, `mem_type`, and `b_force_zero_latency` are optional and allow for fine-tuning the decoding process.

```python
viddec = dec.decoder(
    codec_id,
    device_id,
    mem_type,
    b_force_zero_latency,
    crop_rect,
    0,
    0,
    1000)

# Get the GPU device information
cfg = viddec.GetGpuInfo()
```

--------------------------------

### Demuxer Instantiation

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/reference/demuxerClass.html

Instantiate a demuxer by providing the video file path.

```APIDOC
## Instantiation
To instantiate a demuxer instance, pass the video file name and path as the input parameter.
### Example:
```python
# demuxer instance
demuxer = dmx.demuxer(input_file_path)
```
```

--------------------------------

### Decoder Instantiation

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/reference/decoderClass.html

Instantiate a decoder instance by passing the required parameters such as device_id, mem_type, codec, and optional parameters like b_force_zero_latency, crop_rect, max_width, max_height, and clk_rate.

```APIDOC
## Instantiation
To instantiate a decoder instance, pass the following parameters:
  * **device_id** : The GPU device ID, default is 0
  * **mem_type** : The mem type of output surface - 0: Internal 1: dev_copied 2: host_copied, default is 1
  * **codec** : The codec ID obtained by _GetRocDecCodecID_ API
  * **b_force_zero_latency** : Force zero latency flag, default is ‘False’
  * **crop_rect** : See Structures Classess, optional, default: ‘None’, no cropping
  * **max_width** : Max width, default is 0
  * **max_height** : Max height, default is 0
  * **clk_rate** : Clock rate, default is 1000

### Example:
```python
# create decoder instance
viddec = dec.decoder(device_id, mem_type, codec_id, b_force_zero_latency, crop_rect, 0, 0, 1000)
```
```

--------------------------------

### Generate Makefile with CMake

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/install/rocPyDecode-cmake-install.html

Navigate to the build directory and use CMake to generate the build system's makefile.

```bash
cd build
cmake ../

```

--------------------------------

### Create Build Directory

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/install/rocPyDecode-cmake-install.html

Create a dedicated directory for build artifacts within the rocPyDecode source directory.

```bash
mkdir build

```

--------------------------------

### GetGpuInfo

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/reference/decoderClass.html

Returns the ConfigInfo structure for the current GPU device.

```APIDOC
### GetGpuInfo()#
Returns the ConfigInfo structure for the current GPU device
#### Example:
```python
# Get GPU device information
cfg = viddec.GetGpuInfo()

# print GPU info out
print("GPU device " + str(device_id) + " \- " + cfg.device_name + "[" + cfg.gcn_arch_name + "] on PCI bus " + str(cfg.pci_bus_id) + ":" + str(cfg.pci_domain_id) + "." + str(cfg.pci_device_id))
```
```

--------------------------------

### Run rocPyDecode Requirements Script

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/how-to/rocPyDecode-wheel.html

Execute the `rocPyDecode-requirements.py` script to set up necessary dependencies before building the wheel.

```python
python3 rocPyDecode-requirements.py
```

--------------------------------

### Build rocPyDecode Wheel using build_rocpydecode_wheel.py

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/how-to/rocPyDecode-wheel.html

Generate the wheel distribution file for rocPyDecode by running the `build_rocpydecode_wheel.py` script.

```python
python3 build_rocpydecode_wheel.py
```

--------------------------------

### Generate Distribution Packages

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/install/rocPyDecode-cmake-install.html

Create distribution packages such as deb files and tar archives for deployment.

```bash
make package

```

--------------------------------

### Run rocPyDecode Requirements Script

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/install/rocPyDecode-cmake-install.html

Execute this script from the rocPyDecode root directory before building to ensure all dependencies are met.

```bash
python3 rocPyDecode-requirements.py

```

--------------------------------

### Instantiate rocPyDecode Decoder

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/reference/decoderClass.html

Create a decoder instance by providing device ID, memory type, codec ID, and other optional parameters. Defaults are used if parameters are omitted.

```python
# create decoder instance
viddec = dec.decoder(device_id, mem_type, codec_id, b_force_zero_latency, crop_rect, 0, 0, 1000)

```

--------------------------------

### Import rocPyDecode Modules

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/how-to/using-rocPydecode.html

Import the necessary decoder and demuxer modules from the pyRocVideoDecode library. These are required for video processing.

```python
import pyRocVideoDecode.decoder as dec
import pyRocVideoDecode.demuxer as dmx
```

--------------------------------

### ConfigInfo Structure

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/reference/structures.html

The ConfigInfo structure provides GPU device-specific details such as the device name, architecture, and PCI bus identifiers. This information is obtained by rocPyDecode APIs to describe the current GPU environment.

```APIDOC
## ConfigInfo Structure

The ConfigInfo structure members are used to describe the current GPU device-related information to be obtained by the rocPyDecode APIs.

### Fields
* **device_name** : String Contains the device name
* **gcn_arch_name** : String Contains the GPU architecture name
* **pci_bus_id** : Integer value contains the PCIE bus ID
* **pci_domain_id** : Integer value contains the PCIE domain ID
* **pci_device_id** : Integer value contains the PCIE device ID

### Example
```python
# Get GPU device information
cfg = viddec.GetGpuInfo()

#  print GPU info out
print("GPU device " + str(device_id) + " \- " + cfg.device_name + "[" + cfg.gcn_arch_name + "] on PCI bus " + str(cfg.pci_bus_id) + ":" + str(cfg.pci_domain_id) + "." + str(cfg.pci_device_id))
```
```

--------------------------------

### Navigate to rocPyDecode Directory

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/how-to/rocPyDecode-wheel.html

Change the current directory to the root of the rocPyDecode repository before running scripts.

```bash
cd rocPyDecode
```

--------------------------------

### initialize_hip()

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/reference/rocPyJPEGDecode-api.html

Initializes the HIP device for decoding. The user can specify the device to use for decoding. By default device 0 is used. This function must be called before any other call is made to the rocPyJpeg library.

```APIDOC
## initialize_hip()

### Description
Initializes the HIP device for decoding. Allows specifying the device ID, defaulting to 0. Must be called before any other rocPyJpeg library functions.

### Method
`initialize_hip()`

### Parameters
None explicitly mentioned, but implies device selection is possible.
```

--------------------------------

### decoder()

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/reference/rocPyJPEGDecode-api.html

Constructor for the main decoding class.

```APIDOC
## decoder()

### Description
Creates an instance of the main decoding class.

### Method
`decoder()`

### Parameters
None.
```

--------------------------------

### Set Flush Mode for Resolution Changes

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/how-to/using-rocPydecode.html

Configure the flush mode using SetReconfigParams() to handle videos with varying frame resolutions. Set flush_mode to 1 if outputting to a file, otherwise 0.

```python
flush_mode = 0
if (output_file_path is not None):
    flush_mode = 1

viddec.SetReconfigParams(flush_mode, output_file_path if (output_file_path is not None) else str(""))
```

--------------------------------

### SetReconfigParams

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/reference/decoderClass.html

Specify the flush mode and the output file name to use in multi resolution video support.

```APIDOC
## SetReconfigParams(flush_mode, out_file_name)

### Description
Specify the flush mode and the output file name to use in multi resolution video support.

### Parameters
#### Path Parameters
- **flush_mode** (integer) - Required - Specifies the flush mode:
  * 0: Just flush to get the frame count
  * 1: The remaining frames will be dumped to file in this mode
- **out_file_name** (string) - Required - The full path disk file name to save the YUV frames

### Request Example
```python
# set reconfiguration params based on user arguments
flush_mode = 0

if (output_file_path is not None):
        flush_mode = 1

viddec.SetReconfigParams(flush_mode, output_file_path if (output_file_path is not None) else str(""))
```
```

--------------------------------

### decoder().set_output_image_format()

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/reference/rocPyJPEGDecode-api.html

Passes the output image format to the decoder engine. The output image format can be set to `ROCJPEG_OUTPUT_RGB` or `ROCJPEG_OUTPUT_RGB_PLANAR`. These types are defined in `pyRocJpegDecode/types.py`.

```APIDOC
## decoder().set_output_image_format()

### Description
Sets the desired output image format for the decoder. Supported formats include `ROCJPEG_OUTPUT_RGB` and `ROCJPEG_OUTPUT_RGB_PLANAR`.

### Method
`decoder().set_output_image_format(format)`

### Parameters
* **format** (enum) - Required - The desired output image format. Can be `ROCJPEG_OUTPUT_RGB` or `ROCJPEG_OUTPUT_RGB_PLANAR`.
```

--------------------------------

### Resize Frame with Dimensions

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/reference/structures.html

Resizes a video frame using the ResizeFrame API. Requires a Dim structure specifying the target width and height, and the output surface information.

```python
import rocPyDecode as rocpydec

frame_is_resized = False
resize_dim = rocpydec.Dim()
resize_dim.width = 200
resize_dim.height = 200
surface_info = viddec.GetOutputSurfaceInfo()

if(viddec.ResizeFrame(packet, resize_dim, surface_info) != 0):

        frame_is_resized = True
```

--------------------------------

### DemuxFrame

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/reference/demuxerClass.html

Demuxes the input video file and returns a Packet structure for decoding.

```APIDOC
## Member functions
The following are the member functions of the demuxer class.
Demux the input video file and returns a Packet structure for use in decoding the demuxed frames.
### Example:
```python
while True:
        packet = demuxer.DemuxFrame()
        n_frame_returned = viddec.DecodeFrame(packet)

        for i in range(n_frame_returned):
                viddec.GetFrame(packet)

                # save frames
                surface_info = viddec.GetOutputSurfaceInfo()
                viddec.SaveFrameToFile(output_file_path, packet.frame_adrs, surface_info)

                # release frame
                viddec.ReleaseFrame(packet)
                if (packet.frame_size <= 0):  # EOF: no more to decode
                        break
```
```

--------------------------------

### decoder().read and decoder().decode

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/reference/rocPyJPEGDecode-api.html

These functions read in JPEG images or batches of images, pass them to the decoder, and return the decoded images. They support various input types including file paths, memory buffers, and NumPy arrays.

```APIDOC
## decoder().read and decoder().decode

### Description
Reads and decodes JPEG images or batches of images. Returns decoded image tensors in the specified output format. Handles single images or batches, and various input types like file paths, memory buffers, and NumPy arrays. Errors occur if images are unsupported or corrupted.

### Method
`decoder().read(input, batch_size=None)`
`decoder().decode(input, batch_size=None)`

### Parameters
* **input** (string | buffer | numpy.ndarray) - Required - The JPEG image(s) to decode. Can be a file path, memory buffer, or NumPy array.
* **batch_size** (int) - Optional - The number of images in a batch when input is a folder path, memory buffer, or NumPy array.

### Response
* **Success Response**: Returns a single image tensor or a list of image tensors in the specified output format.
* **Error Response**: If decoding fails for any image, no image will be returned and an error message will be produced.
```

--------------------------------

### Check Codec Support in rocPyDecode

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/how-to/using-rocPydecode.html

Before decoding, verify if the desired codec is supported on the target GPU. This check is crucial for preventing runtime errors.

```python
if (viddec.IsCodecSupported(device_id, codec_id, demuxer.GetBitDepth()) == False):
    print("ERROR: Codec is not supported on this GPU " + cfg.device_name)
    exit()
```

--------------------------------

### GetWidth

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/reference/decoderClass.html

Returns the width of the current decoded frame.

```APIDOC
### GetWidth()#
Returns the width of the current decoded frame.
```

--------------------------------

### GetFrameSize

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/reference/decoderClass.html

Returns the size of the current decoded frame in bytes.

```APIDOC
### GetFrameSize()#
Returns the size of the current decoded frame in bytes.
```

--------------------------------

### SaveFrameToFile

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/reference/decoderClass.html

Saves all the decoded frames to a disk file in YUV format.

```APIDOC
### SaveFrameToFile(output_file_path, frame_adrs, surface_info)#
Saves all the decoded frames to a disk file in YUV format.
  * **output_file_path** : The full path disk file name to save the YUV frames
  * **frame_adrs** : The current frame pointer, obtained from the used packet
  * **surface_info** : The current decode frame surface information structure pointer
```

--------------------------------

### GetOutputSurfaceInfo

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/reference/decoderClass.html

Returns the current decoded frame’s surface information structure pointer.

```APIDOC
### GetOutputSurfaceInfo()#
Returns the current decoded frame’s surface information structure pointer.
```

--------------------------------

### SaveTensorToFile

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/reference/decoderClass.html

Saves all the decoded frames after being converted to a Tensor to a disk file in RGB format.

```APIDOC
### SaveTensorToFile(output_file_path, frame_adrs, width, height, rgb_format, surface_info)#
Saves all the decoded frames after being converted to a Tensor to a disk file in RGB format.
  * **output_file_path** : The full path disk file name to save the YUV frames
  * **frame_adrs** : The current frame/tensor pointer, obtained from the used packet
  * **width** : The width of the current Tensor
  * **height** : The height of the current Tensor
  * **rgb_format** : 1 for bgr, 3 for rgb
  * **surface_info** : The current decode frame surface information structure pointer
```

--------------------------------

### ReleaseFrame

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/reference/decoderClass.html

Release the GPU memory of the current decoded frame.

```APIDOC
### ReleaseFrame(packet)#
Release the GPU memory of the current decoded frame.
```

--------------------------------

### Demux and Decode Frames

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/reference/demuxerClass.html

Demuxes frames from the input video file and decodes them. This loop continues until the end of the file is reached.

```python
while True:
        packet = demuxer.DemuxFrame()
        n_frame_returned = viddec.DecodeFrame(packet)

        for i in range(n_frame_returned):
                viddec.GetFrame(packet)

                # save frames
                surface_info = viddec.GetOutputSurfaceInfo()
                viddec.SaveFrameToFile(output_file_path, packet.frame_adrs, surface_info)

                # release frame
                viddec.ReleaseFrame(packet)
                if (packet.frame_size <= 0):  # EOF: no more to decode
                        break

```

--------------------------------

### GetResizedOutputSurfaceInfo

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/reference/decoderClass.html

Returns the current decoded and resized frame’s surface information structure pointer.

```APIDOC
### GetResizedOutputSurfaceInfo()#
Returns the current decoded and resized frame’s surface information structure pointer.
```

--------------------------------

### GetHeight

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/reference/decoderClass.html

Returns the height of the current decoded frame.

```APIDOC
### GetHeight()#
Returns the height of the current decoded frame.
```

--------------------------------

### Demux and Decode Frames with rocPyDecode

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/how-to/using-rocPydecode.html

Demux frames sequentially using DemuxFrame() or seek to a specific frame with SeekFrame(). Decode the obtained packet using DecodeFrame().

```python
if(not_seeking):
    packet = demuxer.DemuxFrame()
else:
    packet = demuxer.SeekFrame(seek_frame, seek_mode, seek_criteria)
    not_seeking = True

n_frame_returned = viddec.DecodeFrame(packet)
```

--------------------------------

### GetFrameRgb

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/reference/decoderClass.html

Obtains a pointer to the current decoded frame in the input packet, and converts that YUV frame to ‘Tensor’ in RGB format. Returns the current frame time stamp, the frame pointer, and the time stamp saved in the packet.

```APIDOC
### GetFrameRgb(packet, rgb_format)#
Obtains a pointer to the current decoded frame in the input packet, and converts that YUV frame to ‘Tensor’ in RGB format. Returns the current frame time stamp, the frame pointer, and the time stamp saved in the packet.
  * **packet** : The demuxed packet contains the demuxed frames information, and the desired rgb format
  * **rgb_format** : 1 for bgr, 3 for rgb
```

--------------------------------

### GetFrame

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/reference/decoderClass.html

Obtains a pointer to the current decoded frame in the input packet. Returns the current frame time stamp, the frame pointer, and the time stamp saved in the packet.

```APIDOC
### GetFrame(packet)#
Obtains a pointer to the current decoded frame in the input packet. Returns the current frame time stamp, the frame pointer, and the time stamp saved in the packet.
#### Example:
```python
# decoding loop
while True:
        packet = demuxer.DemuxFrame()

        n_frame_returned = viddec.DecodeFrame(packet)

        for i in range(n_frame_returned):
                viddec.GetFrame(packet)

        # TO DO: process the frame or save it, etc.
        # ...

        # release frame
        viddec.ReleaseFrame(packet)

        if (packet.frame_size <= 0):  # EOF: no more to decode
                break
```
```

--------------------------------

### GetStride

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/reference/decoderClass.html

Returns the stride of the current decoded frame.

```APIDOC
### GetStride()#
Returns the stride of the current decoded frame.
```

--------------------------------

### Decode and Process Video Frames

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/reference/decoderClass.html

A typical decoding loop that demuxes frames, decodes them, retrieves the decoded frames, processes them, and releases them. The loop breaks upon reaching the end of the file.

```python
# decoding loop
while True:
        packet = demuxer.DemuxFrame()

        n_frame_returned = viddec.DecodeFrame(packet)

        for i in range(n_frame_returned):
                viddec.GetFrame(packet)

        # TO DO: process the frame or save it, etc.
        # ...

        # release frame
        viddec.ReleaseFrame(packet)

        if (packet.frame_size <= 0):  # EOF: no more to decode
                break

```

--------------------------------

### Process Decoded Frames with rocPyDecode

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/how-to/using-rocPydecode.html

Retrieve decoded frame information using GetOutputSurfaceInfo(). Optionally resize the frame using ResizeFrame() before further processing or saving.

```python
surface_info = viddec.GetOutputSurfaceInfo()
if(viddec.ResizeFrame(packet, resize_dim, surface_info) != 0):
    frame_is_resized = True
else:
    frame_is_resized = False
```

--------------------------------

### Define Region of Interest for Cropping

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/reference/structures.html

Defines a rectangular region of interest for cropping using the Rect structure. Specifies the top-left and bottom-right coordinates.

```python
import rocPyDecode as rocpydec

p_crop_rect = rocpydec.Rect()
p_crop_rect.left = 100
p_crop_rect.top = 100
p_crop_rect.right = 300
p_crop_rect.bottom = 300
```

--------------------------------

### Dim Structure

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/reference/structures.html

The Dim structure is used to specify the width and height dimensions for video frame scaling operations within the rocPyDecode APIs.

```APIDOC
## Dim Structure

The Dim structure allows specifying the dimensions of a video frame to be used in frame scaling via the rocPyDecode APIs.

### Fields
* **width** : Integer value contains the width
* **height** : Integer value contains the height

### Example
```python
import rocPyDecode as rocpydec

frame_is_resized = False
resize_dim = rocpydec.Dim()
resize_dim.width = 200
resize_dim.height = 200
surface_info = viddec.GetOutputSurfaceInfo()

if(viddec.ResizeFrame(packet, resize_dim, surface_info) != 0):

        frame_is_resized = True
```
```

--------------------------------

### Release and Save Frames in rocPyDecode

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/how-to/using-rocPydecode.html

After processing, release each decoded frame using ReleaseFrame(). If saving to a file, use SaveFrameToFile(), handling resized frames appropriately.

```python
for i in range(n_frame_returned):
    viddec.GetFrameYuv(packet)

    ...

    if (resize_dim is not None):
        surface_info = viddec.GetOutputSurfaceInfo()
        if(viddec.ResizeFrame(packet, resize_dim, surface_info) != 0):
            frame_is_resized = True
        else:
            frame_is_resized = False

    if (output_file_path is not None):
        if (frame_is_resized):
            resized_surface_info = viddec.GetResizedOutputSurfaceInfo()
            viddec.SaveFrameToFile(output_file_path, packet.frame_adrs_resized, resized_surface_info)
        else:
            viddec.SaveFrameToFile(output_file_path, packet.frame_adrs)

    # release frame
    viddec.ReleaseFrame(packet)
```

--------------------------------

### Packet Structure

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/reference/structures.html

The Packet structure holds information about demuxed frames, including stream status, timestamps, and memory addresses for YUV, RGB, and resized frames. It is passed to decoder APIs for processing.

```APIDOC
## Packet Structure

The Packet structure contains information related to the demuxed frames from the original input video. The packet is passed to the decoder APIs for further processing, which uses and updates the information in the same structure.

### Fields
* **end_of_stream** : Boolean flag, indicates demuxing reach end of stream when ‘True’
* **pkt_flags** : Integer value indicate the status of the packet
* **frame_pts** : The time stamp of the current frame
* **frame_size** : The current packet size
* **frame_adrs** : The current YUV frame address in memory
* **frame_adrs_rgb** : The current RGB frame address in memory, valid only when RGB conversion used
* **frame_adrs_resized** : The current resized frame address in memory, valid only when frame is resized

### Example
```python
packet = demuxer.DemuxFrame()
n_frame_returned = viddec.DecodeFrame(packet)
```
```

--------------------------------

### GetNumOfFlushedFrames

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/reference/decoderClass.html

Returns the count of the flushed frames.

```APIDOC
### GetNumOfFlushedFrames()#
Returns the count of the flushed frames.
#### Example:
```python
# beyond the decoding loop
n_frame += viddec.GetNumOfFlushedFrames()
```
```

--------------------------------

### GetCodecId

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/reference/demuxerClass.html

Returns the demux codec ID for use in decoder functions.

```APIDOC
#### GetCodecId()
Returns the demux codec ID to be used in later decoder functions.
### Example:
```python
# demuxer instance
demuxer = dmx.demuxer(input_file_path)

# get the used coded id
codec_id = dec.GetRocDecCodecID(demuxer.GetCodecId())
# decoder instance
viddec = dec.decoder(device_id, mem_type, codec_id, b_force_zero_latency, crop_rect, 0, 0, 1000)
```
```

--------------------------------

### ResizeFrame

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/reference/decoderClass.html

Resizes the decode frame pointed to by the passed packet to the new dimension using the passed surface info.

```APIDOC
### ResizeFrame(packet, resize_dim, surface_info)#
Resizes the decode frame pointed to by the passed packet, see: Structures Classess, to the new dimension in resize_dim, to the new dimension using the passed surface info.
  * **packet** : The demuxed packet contains the demuxed frames information, and the desired rgb format
  * **resize_dim** : The new dimension, width and height
  * **surface_info** : The current surface info obtained by GetOutputSurfaceInfo API

#### Example:
```python
# resize frame to new dimension
resize__dim = [1024, 720]

surface__info = viddec.GetOutputSurfaceInfo()

frame_is_resized = False

if(viddec.ResizeFrame(packet, resize_dim, surface_info) != 0):
        frame_is_resized = True
```
```

--------------------------------

### Count Flushed Frames

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/reference/decoderClass.html

Obtain the total count of frames that have been flushed by the decoder. This is typically called after the main decoding loop.

```python
# beyond the decoding loop
n_frame += viddec.GetNumOfFlushedFrames()

```

--------------------------------

### Decode Frame with Packet

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/reference/structures.html

Passes a Packet structure to the DecodeFrame API for processing demuxed video frames. The Packet structure is updated by the API.

```python
packet = demuxer.DemuxFrame()
n_frame_returned = viddec.DecodeFrame(packet)
```

--------------------------------

### Resize Decoded Frame

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/reference/decoderClass.html

Resize a decoded frame to a new dimension using the provided packet and surface information. Checks if the resizing operation was successful.

```python
# resize frame to new dimension
resize__dim = [1024, 720]

surface__info = viddec.GetOutputSurfaceInfo()

frame_is_resized = False

if(viddec.ResizeFrame(packet, resize_dim, surface_info) != 0):
        frame_is_resized = True

```

--------------------------------

### DecodeFrame

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/reference/decoderClass.html

Decodes video frames described by the input Packet structure obtained from demux functions. Returns the count of decoded frames.

```APIDOC
### DecodeFrame(packet)#
Decodes video frames described by the input Packet structure obtained from demux functions. Returns the count of decoded frames.
```

--------------------------------

### Rect Structure

Source: https://rocm.docs.amd.com/projects/rocPyDecode/en/latest/reference/structures.html

The Rect structure defines a rectangular area of interest by specifying the top-left and bottom-right coordinates. This is used for cropping or defining regions in rocPyDecode API calls.

```APIDOC
## Rect Structure

The Rect structure provides the top-left and bottom-right coordinates of the area of interest to be passed to the rocPyDecode APIs.

### Fields
* **left** : Integer value contains the left column of a rectangle
* **top** : Integer value contains the top row of a rectangle
* **right** : Integer value contains the right column of a rectangle
* **bottom** : Integer value contains the bottom row of a rectangle

### Example
```python
import rocPyDecode as rocpydec

p_crop_rect = rocpydec.Rect()
p_crop_rect.left = 100
p_crop_rect.top = 100
p_crop_rect.right = 300
p_crop_rect.bottom = 300
```
```
Tokens:
Raw