help to decode the BGR frame directly on the cuda

[1rn21ai113shashikumars-star]

here is the now i am using

import av
import cupy as cp
import time
from av.codec.hwaccel import HWAccel, HWDeviceType

RTSP_URL = "rtsp://192.168.0.111:5543/live/channel0"

hw_accel = HWAccel(
    device_type=HWDeviceType.cuda,
    device=None,
    allow_software_fallback=True,
)

container = av.open(
    RTSP_URL,
    options={
        "rtsp_transport": "tcp",
        "flags": "low_delay",
        "fflags": "nobuffer",
        "stimeout": "1000000",
    },
    hwaccel=hw_accel
)

nv12_to_bgr_kernel = cp.RawKernel(r'''
extern "C" __global__ void nv12_to_bgr_kernel(
    const unsigned char* __restrict__ y_data,
    const unsigned char* __restrict__ uv_data,
    unsigned char* __restrict__ bgr_data,
    int width,
    int height)
{
    int total_threads = blockDim.x * gridDim.x;
    int thread_id = blockIdx.x * blockDim.x + threadIdx.x;
    int total_pixels = width * height;
    
    for (int idx = thread_id; idx < total_pixels; idx += total_threads) {
        int x = idx % width;
        int y = idx / width;
        
        int Y = y_data[idx];
        int uv_idx = (y >> 1) * width + (x & 0xFFFE);
        int U = uv_data[uv_idx];
        int V = uv_data[uv_idx + 1];
        
        int C = Y - 16;
        int D = U - 128;
        int E = V - 128;
        
        int R = (298 * C + 409 * E + 128) >> 8;
        int G = (298 * C - 100 * D - 208 * E + 128) >> 8;
        int B = (298 * C + 516 * D + 128) >> 8;
        
        R = (R < 0) ? 0 : (R > 255) ? 255 : R;
        G = (G < 0) ? 0 : (G > 255) ? 255 : G;
        B = (B < 0) ? 0 : (B > 255) ? 255 : B;
        
        int out_idx = idx * 3;
        bgr_data[out_idx] = B;
        bgr_data[out_idx + 1] = G;
        bgr_data[out_idx + 2] = R;
    }
}
''', 'nv12_to_bgr_kernel')

# Simple pre-allocation
bgr_gpu_cache = None

def nv12_to_bgr_simple(nv12_frame):
    global bgr_gpu_cache
    
    if bgr_gpu_cache is None:
        height, width = nv12_frame.height, nv12_frame.width
        bgr_gpu_cache = cp.empty((height, width, 3), dtype=cp.uint8)
    
    y_data = cp.frombuffer(nv12_frame.planes[0], dtype=cp.uint8)
    uv_data = cp.frombuffer(nv12_frame.planes[1], dtype=cp.uint8)
    
    # Dead simple launch - just fixed numbers, no calculations
    nv12_to_bgr_kernel(
        (64,),    # 64 blocks
        (256,),   # 256 threads per block
        (y_data, uv_data, bgr_gpu_cache.ravel(), nv12_frame.width, nv12_frame.height)
    )
    
    return bgr_gpu_cache

print("Testing PURE SIMPLE 1000+ FPS PyAV processing...")

# Single warmup
for packet in container.demux(video=0):
    for frame in packet.decode():
        if frame.format.name != 'nv12':
            frame = frame.reformat(format='nv12')
        nv12_to_bgr_simple(frame)
        break
    break

# Reset container
container.close()
container = av.open(RTSP_URL, options={
    "rtsp_transport": "tcp",
    "flags": "low_delay",
    "fflags": "nobuffer", 
    "stimeout": "1000000",
}, hwaccel=hw_accel)

frame_times = []
frame_count = 0
start_time = time.perf_counter()

# Pure simple loop - no multiprocessing, no threads, no complex logic
for packet in container.demux(video=0):
    if time.perf_counter() - start_time >= 10.0:
        break
        
    for frame in packet.decode():
        frame_start = time.perf_counter()
        
 
            
        # bgr_image = nv12_to_bgr_simple(frame)
        
        frame_end = time.perf_counter()
        frame_times.append(frame_end - frame_start)
        frame_count += 1

# Clean finish
cp.cuda.Device().synchronize()
container.close()

if frame_times:
    average_time_per_frame = sum(frame_times) / len(frame_times)
    max_fps = 1.0 / average_time_per_frame
    
    print(f"\n=== PURE SIMPLE RESULTS ===")
    print(f"Frames processed: {frame_count}")
    print(f"Average time per frame: {average_time_per_frame*1000:.3f} ms")
    print(f"PyAV can process at FULL SPEED: {max_fps:.1f} FPS")
    print(f"🚀 PURE SIMPLICITY ACHIEVED! 🚀")

is there any other way that i can decode directly the bgr frame on the cuda