Make utils pure

av/option.pyx

@@ -1,6 +1,5 @@
 cimport libav as lib
-
-from av.utils cimport flag_in_bitfield
+from libc.stdint cimport uint64_t
 
 from enum import Enum, Flag
 
@@ -16,6 +15,13 @@ cdef Option wrap_option(tuple choices, const lib.AVOption *ptr):
     return obj
 
 
+cdef flag_in_bitfield(uint64_t bitfield, uint64_t flag):
+    # Not every flag exists in every version of FFMpeg, so we define them to 0.
+    if not flag:
+        return None
+    return bool(bitfield & flag)
+
+
 class OptionType(Enum):
     FLAGS = lib.AV_OPT_TYPE_FLAGS
     INT = lib.AV_OPT_TYPE_INT

av/utils.pxd

@@ -1,12 +1,9 @@
 cimport libav as lib
-from libc.stdint cimport uint64_t
 
 
 cdef dict avdict_to_dict(lib.AVDictionary *input, str encoding, str errors)
 cdef dict_to_avdict(lib.AVDictionary **dst, dict src, str encoding, str errors)
 
 cdef object avrational_to_fraction(const lib.AVRational *input)
 cdef void to_avrational(object frac, lib.AVRational *input)
-
-cdef check_ndarray(object array, object dtype, int ndim)
-cdef flag_in_bitfield(uint64_t bitfield, uint64_t flag)
+cdef void check_ndarray(object array, object dtype, int ndim)

av/utils.py

@@ -0,0 +1,86 @@
+# type: ignore
+from fractions import Fraction
+
+import cython
+from cython.cimports import libav as lib
+from cython.cimports.av.error import err_check
+
+# === DICTIONARIES ===
+# ====================
+
+
+@cython.cfunc
+def _decode(s: cython.pointer[cython.char], encoding, errors) -> str:
+    return cython.cast(bytes, s).decode(encoding, errors)
+
+
+@cython.cfunc
+def _encode(s, encoding, errors) -> bytes:
+    return s.encode(encoding, errors)
+
+
+@cython.cfunc
+def avdict_to_dict(
+    input: cython.pointer[lib.AVDictionary], encoding: str, errors: str
+) -> dict:
+    element: cython.pointer[lib.AVDictionaryEntry] = cython.NULL
+    output: dict = {}
+    while True:
+        element = lib.av_dict_get(input, "", element, lib.AV_DICT_IGNORE_SUFFIX)
+        if element == cython.NULL:
+            break
+        output[_decode(element.key, encoding, errors)] = _decode(
+            element.value, encoding, errors
+        )
+
+    return output
+
+
+@cython.cfunc
+def dict_to_avdict(
+    dst: cython.pointer[cython.pointer[lib.AVDictionary]],
+    src: dict,
+    encoding: str,
+    errors: str,
+):
+    lib.av_dict_free(dst)
+    for key, value in src.items():
+        err_check(
+            lib.av_dict_set(
+                dst, key.encode(encoding, errors), value.encode(encoding, errors), 0
+            )
+        )
+
+
+# === FRACTIONS ===
+# =================
+
+
+@cython.cfunc
+def avrational_to_fraction(
+    input: cython.pointer[cython.const[lib.AVRational]],
+) -> object:
+    if input.num and input.den:
+        return Fraction(input.num, input.den)
+    return None
+
+
+@cython.cfunc
+def to_avrational(frac: object, input: cython.pointer[lib.AVRational]) -> cython.void:
+    input.num = frac.numerator
+    input.den = frac.denominator
+
+
+@cython.cfunc
+def check_ndarray(array: object, dtype: object, ndim: cython.int) -> cython.void:
+    """
+    Check a numpy array has the expected data type and number of dimensions.
+    """
+    if array.dtype != dtype:
+        raise ValueError(
+            f"Expected numpy array with dtype `{dtype}` but got `{array.dtype}`"
+        )
+    if array.ndim != ndim:
+        raise ValueError(
+            f"Expected numpy array with ndim `{ndim}` but got `{array.ndim}`"
+        )