output_format -> hw.is_hw_owned

Author: WyattBlue

av/codec/hwaccel.pxd

@@ -16,8 +16,8 @@ cdef class HWAccel:
     cdef readonly Codec codec
     cdef readonly HWConfig config
     cdef lib.AVBufferRef *ptr
+    cdef readonly int device_id
+    cdef readonly bint is_hw_owned
     cdef public bint allow_software_fallback
     cdef public dict options
     cdef public int flags
-    cdef str _output_format
-    cdef int _device_id

av/codec/hwaccel.py

@@ -110,11 +110,8 @@ def __init__(
         allow_software_fallback=True,
         options=None,
         flags=None,
-        output_format=None,
+        is_hw_owned=False,
     ):
-        if isinstance(device, int):
-            device = str(device)
-
         if isinstance(device_type, HWDeviceType):
             self._device_type = device_type
         elif isinstance(device_type, str):
@@ -124,27 +121,16 @@ def __init__(
         else:
             raise ValueError("Unknown type for device_type")
 
-        if output_format is None:
-            output_format = "sw"
-        if isinstance(output_format, str):
-            output_format = output_format.lower()
-        if output_format not in {"sw", "hw"}:
-            raise ValueError("output_format must be 'sw' or 'hw'")
-        self._output_format = output_format
-
-        self._device_id = 0
-        if self._device_type == HWDeviceType.cuda:
-            if device:
-                try:
-                    self._device_id = int(device)
-                except ValueError:
-                    self._device_id = 0
-
-        self._device = device
+        self.is_hw_owned = is_hw_owned
+        self.device_id = 0
+        if self._device_type == HWDeviceType.cuda and device:
+            self.device_id = int(device)
+
+        self._device = None if device is None else f"{device}"
         self.allow_software_fallback = allow_software_fallback
 
         self.options = {} if not options else dict(options)
-        if self._device_type == HWDeviceType.cuda and self.output_format == "hw":
+        if self._device_type == HWDeviceType.cuda and self.is_hw_owned == True:
             self.options.setdefault("primary_ctx", "1")
         self.flags = 0 if not flags else flags
         self.ptr = cython.NULL
@@ -158,7 +144,7 @@ def _initialize_hw_context(self, codec: Codec):
             if self._device_type and config.device_type != self._device_type:
                 continue
             break
-        else:
+        else:  # nobreak
             raise NotImplementedError(f"No supported hardware config for {codec}")
 
         self.config = config
@@ -178,15 +164,7 @@ def _initialize_hw_context(self, codec: Codec):
             )
         )
 
-    @property
-    def device_id(self) -> int:
-        return self._device_id
-
-    @property
-    def output_format(self) -> str:
-        return self._output_format
-
-    def create(self, codec: Codec):
+    def create(self, codec: Codec) -> HWAccel:
         """Create a new hardware accelerator context with the given codec"""
         if self.ptr:
             raise RuntimeError("Hardware context already initialized")

av/codec/hwaccel.pyi

@@ -1,5 +1,5 @@
 from enum import IntEnum
-from typing import Literal, cast
+from typing import cast
 
 from av.codec.codec import Codec
 from av.video.format import VideoFormat
@@ -40,7 +40,7 @@ class HWAccel:
     options: dict[str, object]
 
     @property
-    def output_format(self) -> Literal["sw", "hw"]: ...
+    def is_hw_owned(self) -> bool: ...
     @property
     def device_id(self) -> int: ...
     def __init__(
@@ -50,7 +50,7 @@ class HWAccel:
         allow_software_fallback: bool = False,
         options: dict[str, object] | None = None,
         flags: int | None = None,
-        output_format: Literal["sw", "hw"] | None = None,
+        is_hw_owned: bool = False,
     ) -> None: ...
     def create(self, codec: Codec) -> HWAccel: ...
 

av/video/codeccontext.py

@@ -127,9 +127,7 @@ def _transfer_hwframe(self, frame: Frame):
             # need to transfer.
             return frame
 
-        if self.hwaccel_ctx.output_format == "hw":
-            vframe = cython.cast(VideoFrame, frame)
-            vframe._device_id = int(getattr(self.hwaccel_ctx, "device_id", 0))
+        if self.hwaccel_ctx.is_hw_owned:
             return frame
 
         frame_sw: Frame = self._alloc_next_frame()

av/video/frame.pxd

@@ -7,11 +7,10 @@ from av.video.reformatter cimport VideoReformatter
 
 
 cdef class CudaContext:
-    cdef int _device_id
-    cdef bool _primary_ctx
+    cdef readonly int device_id
+    cdef readonly bint primary_ctx
     cdef lib.AVBufferRef* _device_ref
     cdef dict _frames_cache
-
     cdef lib.AVBufferRef* _get_device_ref(self)
     cdef public lib.AVBufferRef* get_frames_ctx(
         self,
@@ -26,7 +25,6 @@ cdef class VideoFrame(Frame):
     cdef uint8_t *_buffer
     cdef object _np_buffer
 
-    cdef int _device_id
     cdef VideoReformatter reformatter
     cdef readonly VideoFormat format
 

av/video/frame.py

@@ -8,23 +8,22 @@
 from cython.cimports.av.sidedata.sidedata import get_display_rotation
 from cython.cimports.av.utils import check_ndarray
 from cython.cimports.av.video.format import get_pix_fmt, get_video_format
-from cython.cimports.av.video.plane import VideoPlane
+from cython.cimports.av.video.plane import DLManagedTensor, VideoPlane, kCPU, kCuda
 from cython.cimports.cpython.exc import PyErr_Clear
 from cython.cimports.cpython.pycapsule import (
     PyCapsule_GetPointer,
     PyCapsule_IsValid,
     PyCapsule_SetName,
 )
 from cython.cimports.cpython.ref import Py_DECREF, Py_INCREF
-from cython.cimports.dlpack import DLManagedTensor, kDLCPU, kDLCUDA, kDLUInt
 from cython.cimports.libc.stdint import int64_t, uint8_t
 
 
 @cython.cclass
 class CudaContext:
-    def __cinit__(self, device_id=0, primary_ctx=True):
-        self._device_id = int(device_id)
-        self._primary_ctx = bool(primary_ctx)
+    def __cinit__(self, device_id: cython.int = 0, primary_ctx: cython.bint = True):
+        self.device_id = device_id
+        self.primary_ctx = primary_ctx
         self._device_ref = cython.NULL
         self._frames_cache = {}
 
@@ -44,27 +43,18 @@ def __dealloc__(self):
             lib.av_buffer_unref(cython.address(ref))
             self._device_ref = cython.NULL
 
-    @property
-    def device_id(self) -> int:
-        return self._device_id
-
-    @property
-    def primary_ctx(self) -> bool:
-        return self._primary_ctx
-
     @cython.cfunc
     def _get_device_ref(self) -> cython.pointer[lib.AVBufferRef]:
         device_ref: cython.pointer[lib.AVBufferRef] = self._device_ref
         if device_ref != cython.NULL:
             return device_ref
 
         device_ref = cython.NULL
-        device_bytes = str(int(self.device_id)).encode()
+        device_bytes = f"{self.device_id}".encode()
         c_device: cython.p_char = device_bytes
         options: Dictionary = Dictionary(
             {"primary_ctx": "1" if self.primary_ctx else "0"}
         )
-
         err_check(
             lib.av_hwdevice_ctx_create(
                 cython.address(device_ref),
@@ -74,7 +64,6 @@ def _get_device_ref(self) -> cython.pointer[lib.AVBufferRef]:
                 0,
             )
         )
-
         self._device_ref = device_ref
         return device_ref
 
@@ -426,10 +415,6 @@ def __repr__(self):
             f"{self.width}x{self.height} at 0x{id(self):x}>"
         )
 
-    @property
-    def device_id(self) -> int:
-        return self._device_id
-
     @property
     def planes(self):
         """
@@ -1059,10 +1044,6 @@ def from_numpy_buffer(array, format="rgb24", width=0):
         return frame
 
     def _image_fill_pointers_numpy(self, buffer, width, height, linesizes, format):
-        c_data: cython.size_t = buffer.ctypes.data
-        c_ptr: cython.pointer[uint8_t] = cython.cast(cython.pointer[uint8_t], c_data)
-        c_format: lib.AVPixelFormat = get_pix_fmt(format)
-
         # If you want to use the numpy notation, then you need to include the following lines at the top of the file:
         #      cimport numpy as cnp
         #      cnp.import_array()
@@ -1079,9 +1060,9 @@ def _image_fill_pointers_numpy(self, buffer, width, height, linesizes, format):
         # Using buffer.ctypes.data helps avoid any kind of usage of the c-api from
         # numpy, which avoid the need to add numpy as a compile time dependency.
 
-        c_data = buffer.ctypes.data
-        c_ptr = cython.cast(cython.pointer[uint8_t], c_data)
-        c_format = get_pix_fmt(format)
+        c_data: cython.Py_ssize_t = buffer.ctypes.data
+        c_ptr: cython.pointer[uint8_t] = cython.cast(cython.pointer[uint8_t], c_data)
+        c_format: lib.AVPixelFormat = get_pix_fmt(format)
         lib.av_frame_unref(self.ptr)
         self._np_buffer = None
 
@@ -1419,7 +1400,7 @@ def from_dlpack(
         p010le = get_pix_fmt(b"p010le")
         p016le = get_pix_fmt(b"p016le")
 
-        if sw_fmt not in {nv12, p010le, p016le}:
+        if sw_fmt not in (nv12, p010le, p016le):
             raise NotImplementedError("from_dlpack supports nv12, p010le, p016le only")
 
         expected_bits = 8 if sw_fmt == nv12 else 16
@@ -1437,7 +1418,7 @@ def from_dlpack(
             dev_type1 = m1.dl_tensor.device_type
             if dev_type0 != dev_type1:
                 raise ValueError("plane tensors must have the same device_type")
-            if dev_type0 not in {kDLCUDA, kDLCPU}:
+            if dev_type0 not in (kCuda, kCPU):
                 raise NotImplementedError(
                     "only CPU and CUDA DLPack tensors are supported"
                 )
@@ -1446,7 +1427,7 @@ def from_dlpack(
             dev1 = m1.dl_tensor.device_id
             if dev0 != dev1:
                 raise ValueError("plane tensors must be on the same CUDA device")
-            if dev_type0 == kDLCUDA:
+            if dev_type0 == kCuda:
                 if device_id is None:
                     device_id = dev0
                 elif device_id != dev0:
@@ -1457,18 +1438,17 @@ def from_dlpack(
                 if device_id not in (None, 0):
                     raise ValueError("device_id must be 0 for CPU tensors")
                 device_id = 0
-            if dev_type0 == kDLCPU and (dev0 != 0 or dev1 != 0):
+            if dev_type0 == kCPU and (dev0 != 0 or dev1 != 0):
                 raise ValueError("CPU DLPack tensors must have device_id == 0")
 
             if (
-                m0.dl_tensor.dtype.code != kDLUInt
+                m0.dl_tensor.dtype.code != 1
                 or m0.dl_tensor.dtype.bits != expected_bits
                 or m0.dl_tensor.dtype.lanes != 1
             ):
                 raise TypeError("unexpected dtype for plane 0")
-
             if (
-                m1.dl_tensor.dtype.code != kDLUInt
+                m1.dl_tensor.dtype.code != 1
                 or m1.dl_tensor.dtype.bits != expected_bits
                 or m1.dl_tensor.dtype.lanes != 1
             ):
@@ -1541,13 +1521,9 @@ def from_dlpack(
             frame = alloc_video_frame()
             frame.ptr.width = width
             frame.ptr.height = height
-            if dev_type0 == kDLCUDA:
-                ctx = cython.declare(CudaContext)
-                frames_ref = cython.declare(cython.pointer[lib.AVBufferRef])
-                if not isinstance(primary_ctx, (bool, int)):
-                    raise TypeError("primary_ctx must be a bool")
-                primary_ctx = bool(primary_ctx)
-
+            if dev_type0 == kCuda:
+                ctx: CudaContext
+                frames_ref: cython.pointer[lib.AVBufferRef]
                 if cuda_context is None:
                     ctx = CudaContext(device_id=device_id, primary_ctx=primary_ctx)
                 else:
@@ -1564,7 +1540,6 @@ def from_dlpack(
                     ctx = cython.cast(CudaContext, cuda_context)
 
                 frames_ref = ctx.get_frames_ctx(sw_fmt, width, height)
-
                 frame.ptr.format = get_pix_fmt(b"cuda")
                 frame.ptr.hw_frames_ctx = frames_ref
             else:
@@ -1600,7 +1575,6 @@ def from_dlpack(
             m1 = cython.NULL
 
             frame._init_user_attributes()
-            frame._device_id = device_id
             return frame
 
         except Exception:

av/video/frame.pyi

@@ -52,8 +52,6 @@ class VideoFrame(Frame):
     def interlaced_frame(self) -> bool: ...
     @property
     def rotation(self) -> int: ...
-    @property
-    def device_id(self) -> int: ...
     def __init__(
         self, width: int = 0, height: int = 0, format: str = "yuv420p"
     ) -> None: ...

av/video/plane.pxd

@@ -1,8 +1,38 @@
+from libc.stdint cimport int64_t, uint8_t, uint16_t, uint64_t
+
 from av.plane cimport Plane
 from av.video.format cimport VideoFormatComponent
 
 
 cdef class VideoPlane(Plane):
-
     cdef readonly size_t buffer_size
     cdef readonly unsigned int width, height
+
+
+cdef enum DeviceType:
+    kCPU = 1
+    kCuda = 2
+
+cdef struct DLDataType:
+    uint8_t code
+    uint8_t bits
+    uint16_t lanes
+
+cdef struct DLTensor:
+    void* data
+    int device_type
+    int device_id
+    int ndim
+    DLDataType dtype
+    int64_t* shape
+    int64_t* strides
+    uint64_t byte_offset
+
+cdef struct DLManagedTensor
+
+ctypedef void (*DLManagedTensorDeleter)(DLManagedTensor*) noexcept nogil
+
+cdef struct DLManagedTensor:
+    DLTensor dl_tensor
+    void* manager_ctx
+    DLManagedTensorDeleter deleter