Add files using upload-large-folder tool

.gitattributes

@@ -66,3 +66,5 @@ lib/python3.10/site-packages/propcache/_helpers_c.cpython-310-x86_64-linux-gnu.s
 lib/python3.10/site-packages/rpds/rpds.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 lib/python3.10/site-packages/grpc/_cython/cygrpc.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 lib/python3.10/site-packages/fugashi.libs/libmecab-eada4a80.so.2.0.0 filter=lfs diff=lfs merge=lfs -text
+lib/python3.10/site-packages/av/utils.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+lib/python3.10/site-packages/av/plane.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text

lib/python3.10/site-packages/arrow/_version.py

@@ -0,0 +1 @@
+__version__ = "1.3.0"

lib/python3.10/site-packages/arrow/constants.py

@@ -0,0 +1,177 @@
+"""Constants used internally in arrow."""
+
+import sys
+from datetime import datetime
+
+if sys.version_info < (3, 8):  # pragma: no cover
+    from typing_extensions import Final
+else:
+    from typing import Final  # pragma: no cover
+
+# datetime.max.timestamp() errors on Windows, so we must hardcode
+# the highest possible datetime value that can output a timestamp.
+# tl;dr platform-independent max timestamps are hard to form
+# See: https://stackoverflow.com/q/46133223
+try:
+    # Get max timestamp. Works on POSIX-based systems like Linux and macOS,
+    # but will trigger an OverflowError, ValueError, or OSError on Windows
+    _MAX_TIMESTAMP = datetime.max.timestamp()
+except (OverflowError, ValueError, OSError):  # pragma: no cover
+    # Fallback for Windows and 32-bit systems if initial max timestamp call fails
+    # Must get max value of ctime on Windows based on architecture (x32 vs x64)
+    # https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/ctime-ctime32-ctime64-wctime-wctime32-wctime64
+    # Note: this may occur on both 32-bit Linux systems (issue #930) along with Windows systems
+    is_64bits = sys.maxsize > 2**32
+    _MAX_TIMESTAMP = (
+        datetime(3000, 1, 1, 23, 59, 59, 999999).timestamp()
+        if is_64bits
+        else datetime(2038, 1, 1, 23, 59, 59, 999999).timestamp()
+    )
+
+MAX_TIMESTAMP: Final[float] = _MAX_TIMESTAMP
+MAX_TIMESTAMP_MS: Final[float] = MAX_TIMESTAMP * 1000
+MAX_TIMESTAMP_US: Final[float] = MAX_TIMESTAMP * 1_000_000
+
+MAX_ORDINAL: Final[int] = datetime.max.toordinal()
+MIN_ORDINAL: Final[int] = 1
+
+DEFAULT_LOCALE: Final[str] = "en-us"
+
+# Supported dehumanize locales
+DEHUMANIZE_LOCALES = {
+    "en",
+    "en-us",
+    "en-gb",
+    "en-au",
+    "en-be",
+    "en-jp",
+    "en-za",
+    "en-ca",
+    "en-ph",
+    "fr",
+    "fr-fr",
+    "fr-ca",
+    "it",
+    "it-it",
+    "es",
+    "es-es",
+    "el",
+    "el-gr",
+    "ja",
+    "ja-jp",
+    "se",
+    "se-fi",
+    "se-no",
+    "se-se",
+    "sv",
+    "sv-se",
+    "fi",
+    "fi-fi",
+    "zh",
+    "zh-cn",
+    "zh-tw",
+    "zh-hk",
+    "nl",
+    "nl-nl",
+    "be",
+    "be-by",
+    "pl",
+    "pl-pl",
+    "ru",
+    "ru-ru",
+    "af",
+    "bg",
+    "bg-bg",
+    "ua",
+    "uk",
+    "uk-ua",
+    "mk",
+    "mk-mk",
+    "de",
+    "de-de",
+    "de-ch",
+    "de-at",
+    "nb",
+    "nb-no",
+    "nn",
+    "nn-no",
+    "pt",
+    "pt-pt",
+    "pt-br",
+    "tl",
+    "tl-ph",
+    "vi",
+    "vi-vn",
+    "tr",
+    "tr-tr",
+    "az",
+    "az-az",
+    "da",
+    "da-dk",
+    "ml",
+    "hi",
+    "cs",
+    "cs-cz",
+    "sk",
+    "sk-sk",
+    "fa",
+    "fa-ir",
+    "mr",
+    "ca",
+    "ca-es",
+    "ca-ad",
+    "ca-fr",
+    "ca-it",
+    "eo",
+    "eo-xx",
+    "bn",
+    "bn-bd",
+    "bn-in",
+    "rm",
+    "rm-ch",
+    "ro",
+    "ro-ro",
+    "sl",
+    "sl-si",
+    "id",
+    "id-id",
+    "ne",
+    "ne-np",
+    "ee",
+    "et",
+    "sw",
+    "sw-ke",
+    "sw-tz",
+    "la",
+    "la-va",
+    "lt",
+    "lt-lt",
+    "ms",
+    "ms-my",
+    "ms-bn",
+    "or",
+    "or-in",
+    "lb",
+    "lb-lu",
+    "zu",
+    "zu-za",
+    "sq",
+    "sq-al",
+    "ta",
+    "ta-in",
+    "ta-lk",
+    "ur",
+    "ur-pk",
+    "ka",
+    "ka-ge",
+    "kk",
+    "kk-kz",
+    # "lo",
+    # "lo-la",
+    "am",
+    "am-et",
+    "hy-am",
+    "hy",
+    "uz",
+    "uz-uz",
+}

lib/python3.10/site-packages/arrow/util.py

@@ -0,0 +1,117 @@
+"""Helpful functions used internally within arrow."""
+
+import datetime
+from typing import Any, Optional, cast
+
+from dateutil.rrule import WEEKLY, rrule
+
+from arrow.constants import (
+    MAX_ORDINAL,
+    MAX_TIMESTAMP,
+    MAX_TIMESTAMP_MS,
+    MAX_TIMESTAMP_US,
+    MIN_ORDINAL,
+)
+
+
+def next_weekday(
+    start_date: Optional[datetime.date], weekday: int
+) -> datetime.datetime:
+    """Get next weekday from the specified start date.
+
+    :param start_date: Datetime object representing the start date.
+    :param weekday: Next weekday to obtain. Can be a value between 0 (Monday) and 6 (Sunday).
+    :return: Datetime object corresponding to the next weekday after start_date.
+
+    Usage::
+
+        # Get first Monday after epoch
+        >>> next_weekday(datetime(1970, 1, 1), 0)
+        1970-01-05 00:00:00
+
+        # Get first Thursday after epoch
+        >>> next_weekday(datetime(1970, 1, 1), 3)
+        1970-01-01 00:00:00
+
+        # Get first Sunday after epoch
+        >>> next_weekday(datetime(1970, 1, 1), 6)
+        1970-01-04 00:00:00
+    """
+    if weekday < 0 or weekday > 6:
+        raise ValueError("Weekday must be between 0 (Monday) and 6 (Sunday).")
+    return cast(
+        datetime.datetime,
+        rrule(freq=WEEKLY, dtstart=start_date, byweekday=weekday, count=1)[0],
+    )
+
+
+def is_timestamp(value: Any) -> bool:
+    """Check if value is a valid timestamp."""
+    if isinstance(value, bool):
+        return False
+    if not isinstance(value, (int, float, str)):
+        return False
+    try:
+        float(value)
+        return True
+    except ValueError:
+        return False
+
+
+def validate_ordinal(value: Any) -> None:
+    """Raise an exception if value is an invalid Gregorian ordinal.
+
+    :param value: the input to be checked
+
+    """
+    if isinstance(value, bool) or not isinstance(value, int):
+        raise TypeError(f"Ordinal must be an integer (got type {type(value)}).")
+    if not (MIN_ORDINAL <= value <= MAX_ORDINAL):
+        raise ValueError(f"Ordinal {value} is out of range.")
+
+
+def normalize_timestamp(timestamp: float) -> float:
+    """Normalize millisecond and microsecond timestamps into normal timestamps."""
+    if timestamp > MAX_TIMESTAMP:
+        if timestamp < MAX_TIMESTAMP_MS:
+            timestamp /= 1000
+        elif timestamp < MAX_TIMESTAMP_US:
+            timestamp /= 1_000_000
+        else:
+            raise ValueError(f"The specified timestamp {timestamp!r} is too large.")
+    return timestamp
+
+
+# Credit to https://stackoverflow.com/a/1700069
+def iso_to_gregorian(iso_year: int, iso_week: int, iso_day: int) -> datetime.date:
+    """Converts an ISO week date into a datetime object.
+
+    :param iso_year: the year
+    :param iso_week: the week number, each year has either 52 or 53 weeks
+    :param iso_day: the day numbered 1 through 7, beginning with Monday
+
+    """
+
+    if not 1 <= iso_week <= 53:
+        raise ValueError("ISO Calendar week value must be between 1-53.")
+
+    if not 1 <= iso_day <= 7:
+        raise ValueError("ISO Calendar day value must be between 1-7")
+
+    # The first week of the year always contains 4 Jan.
+    fourth_jan = datetime.date(iso_year, 1, 4)
+    delta = datetime.timedelta(fourth_jan.isoweekday() - 1)
+    year_start = fourth_jan - delta
+    gregorian = year_start + datetime.timedelta(days=iso_day - 1, weeks=iso_week - 1)
+
+    return gregorian
+
+
+def validate_bounds(bounds: str) -> None:
+    if bounds != "()" and bounds != "(]" and bounds != "[)" and bounds != "[]":
+        raise ValueError(
+            "Invalid bounds. Please select between '()', '(]', '[)', or '[]'."
+        )
+
+
+__all__ = ["next_weekday", "is_timestamp", "validate_ordinal", "iso_to_gregorian"]

lib/python3.10/site-packages/av/attachments/stream.pxd

@@ -0,0 +1,5 @@
+from av.stream cimport Stream
+
+
+cdef class AttachmentStream(Stream):
+    pass

lib/python3.10/site-packages/av/attachments/stream.pyi

@@ -0,0 +1,8 @@
+from typing import Literal
+
+from av.stream import Stream
+
+class AttachmentStream(Stream):
+    type: Literal["attachment"]
+    @property
+    def mimetype(self) -> str | None: ...

lib/python3.10/site-packages/av/attachments/stream.pyx

@@ -0,0 +1,26 @@
+from av.stream cimport Stream
+
+
+cdef class AttachmentStream(Stream):
+    """
+    An :class:`AttachmentStream` represents a stream of attachment data within a media container.
+    Typically used to attach font files that are referenced in ASS/SSA Subtitle Streams.
+    """
+
+    @property
+    def name(self):
+        """
+        Returns the file name of the attachment.
+
+        :rtype: str | None
+        """
+        return self.metadata.get("filename")
+
+    @property
+    def mimetype(self):
+        """
+        Returns the MIME type of the attachment.
+
+        :rtype: str | None
+        """
+        return self.metadata.get("mimetype")

lib/python3.10/site-packages/av/audio/__init__.py

@@ -0,0 +1,2 @@
+from .frame import AudioFrame
+from .stream import AudioStream

lib/python3.10/site-packages/av/audio/__init__.pyi

@@ -0,0 +1,4 @@
+from .frame import AudioFrame
+from .stream import AudioStream
+
+__all__ = ("AudioFrame", "AudioStream")

lib/python3.10/site-packages/av/audio/codeccontext.pxd

@@ -0,0 +1,11 @@
+
+from av.audio.frame cimport AudioFrame
+from av.audio.resampler cimport AudioResampler
+from av.codec.context cimport CodecContext
+
+
+cdef class AudioCodecContext(CodecContext):
+    # Hold onto the frames that we will decode until we have a full one.
+    cdef AudioFrame next_frame
+    # For encoding.
+    cdef AudioResampler resampler

lib/python3.10/site-packages/av/audio/codeccontext.pyi

@@ -0,0 +1,29 @@
+from typing import Iterator, Literal
+
+from av.codec.context import CodecContext
+from av.packet import Packet
+
+from .format import AudioFormat
+from .frame import AudioFrame
+from .layout import AudioLayout
+
+class _Format:
+    def __get__(self, i: object | None, owner: type | None = None) -> AudioFormat: ...
+    def __set__(self, instance: object, value: AudioFormat | str) -> None: ...
+
+class _Layout:
+    def __get__(self, i: object | None, owner: type | None = None) -> AudioLayout: ...
+    def __set__(self, instance: object, value: AudioLayout | str) -> None: ...
+
+class AudioCodecContext(CodecContext):
+    frame_size: int
+    sample_rate: int
+    rate: int
+    type: Literal["audio"]
+    format: _Format
+    layout: _Layout
+    @property
+    def channels(self) -> int: ...
+    def encode(self, frame: AudioFrame | None = None) -> list[Packet]: ...
+    def encode_lazy(self, frame: AudioFrame | None = None) -> Iterator[Packet]: ...
+    def decode(self, packet: Packet | None = None) -> list[AudioFrame]: ...

lib/python3.10/site-packages/av/audio/codeccontext.pyx

@@ -0,0 +1,106 @@
+cimport libav as lib
+
+from av.audio.format cimport AudioFormat, get_audio_format
+from av.audio.frame cimport AudioFrame, alloc_audio_frame
+from av.audio.layout cimport AudioLayout, get_audio_layout
+from av.codec.hwaccel cimport HWAccel
+from av.frame cimport Frame
+from av.packet cimport Packet
+
+
+cdef class AudioCodecContext(CodecContext):
+    cdef _init(self, lib.AVCodecContext *ptr, const lib.AVCodec *codec, HWAccel hwaccel):
+        CodecContext._init(self, ptr, codec, hwaccel)
+
+    cdef _prepare_frames_for_encode(self, Frame input_frame):
+
+        cdef AudioFrame frame = input_frame
+        cdef bint allow_var_frame_size = self.ptr.codec.capabilities & lib.AV_CODEC_CAP_VARIABLE_FRAME_SIZE
+
+        # Note that the resampler will simply return an input frame if there is
+        # no resampling to be done. The control flow was just a little easier this way.
+        if not self.resampler:
+            self.resampler = AudioResampler(
+                format=self.format,
+                layout=self.layout,
+                rate=self.ptr.sample_rate,
+                frame_size=None if allow_var_frame_size else self.ptr.frame_size
+            )
+        frames = self.resampler.resample(frame)
+
+        # flush if input frame is None
+        if input_frame is None:
+            frames.append(None)
+
+        return frames
+
+    cdef Frame _alloc_next_frame(self):
+        return alloc_audio_frame()
+
+    cdef _setup_decoded_frame(self, Frame frame, Packet packet):
+        CodecContext._setup_decoded_frame(self, frame, packet)
+        cdef AudioFrame aframe = frame
+        aframe._init_user_attributes()
+
+    @property
+    def frame_size(self):
+        """
+        Number of samples per channel in an audio frame.
+
+        :type: int
+        """
+        return self.ptr.frame_size
+
+    @property
+    def sample_rate(self):
+        """
+        Sample rate of the audio data, in samples per second.
+
+        :type: int
+        """
+        return self.ptr.sample_rate
+
+    @sample_rate.setter
+    def sample_rate(self, int value):
+        self.ptr.sample_rate = value
+
+    @property
+    def rate(self):
+        """Another name for :attr:`sample_rate`."""
+        return self.sample_rate
+
+    @rate.setter
+    def rate(self, value):
+        self.sample_rate = value
+
+    @property
+    def channels(self):
+        return self.layout.nb_channels
+
+    @property
+    def layout(self):
+        """
+        The audio channel layout.
+
+        :type: AudioLayout
+        """
+        return get_audio_layout(self.ptr.ch_layout)
+
+    @layout.setter
+    def layout(self, value):
+        cdef AudioLayout layout = AudioLayout(value)
+        self.ptr.ch_layout = layout.layout
+
+    @property
+    def format(self):
+        """
+        The audio sample format.
+
+        :type: AudioFormat
+        """
+        return get_audio_format(self.ptr.sample_fmt)
+
+    @format.setter
+    def format(self, value):
+        cdef AudioFormat format = AudioFormat(value)
+        self.ptr.sample_fmt = format.sample_fmt

lib/python3.10/site-packages/av/audio/fifo.pxd

@@ -0,0 +1,19 @@
+cimport libav as lib
+from libc.stdint cimport int64_t, uint64_t
+
+from av.audio.frame cimport AudioFrame
+
+
+cdef class AudioFifo:
+
+    cdef lib.AVAudioFifo *ptr
+
+    cdef AudioFrame template
+
+    cdef readonly uint64_t samples_written
+    cdef readonly uint64_t samples_read
+    cdef readonly double pts_per_sample
+
+    cpdef write(self, AudioFrame frame)
+    cpdef read(self, int samples=*, bint partial=*)
+    cpdef read_many(self, int samples, bint partial=*)

lib/python3.10/site-packages/av/audio/fifo.pyi

@@ -0,0 +1,22 @@
+from .format import AudioFormat
+from .frame import AudioFrame
+from .layout import AudioLayout
+
+class AudioFifo:
+    def write(self, frame: AudioFrame) -> None: ...
+    def read(self, samples: int = 0, partial: bool = False) -> AudioFrame | None: ...
+    def read_many(self, samples: int, partial: bool = False) -> list[AudioFrame]: ...
+    @property
+    def format(self) -> AudioFormat: ...
+    @property
+    def layout(self) -> AudioLayout: ...
+    @property
+    def sample_rate(self) -> int: ...
+    @property
+    def samples(self) -> int: ...
+    @property
+    def samples_written(self) -> int: ...
+    @property
+    def samples_read(self) -> int: ...
+    @property
+    def pts_per_sample(self) -> float: ...

lib/python3.10/site-packages/av/audio/format.pxd

@@ -0,0 +1,11 @@
+cimport libav as lib
+
+
+cdef class AudioFormat:
+
+    cdef lib.AVSampleFormat sample_fmt
+
+    cdef _init(self, lib.AVSampleFormat sample_fmt)
+
+
+cdef AudioFormat get_audio_format(lib.AVSampleFormat format)

lib/python3.10/site-packages/av/audio/format.pyi

@@ -0,0 +1,11 @@
+class AudioFormat:
+    name: str
+    bytes: int
+    bits: int
+    is_planar: bool
+    is_packed: bool
+    planar: AudioFormat
+    packed: AudioFormat
+    container_name: str
+
+    def __init__(self, name: str | AudioFormat) -> None: ...

lib/python3.10/site-packages/av/audio/frame.pxd

@@ -0,0 +1,31 @@
+cimport libav as lib
+from libc.stdint cimport uint8_t, uint64_t
+
+from av.audio.format cimport AudioFormat
+from av.audio.layout cimport AudioLayout
+from av.frame cimport Frame
+
+
+cdef class AudioFrame(Frame):
+    # For raw storage of the frame's data; don't ever touch this.
+    cdef uint8_t *_buffer
+    cdef size_t _buffer_size
+
+    cdef readonly AudioLayout layout
+    """
+    The audio channel layout.
+
+    :type: AudioLayout
+    """
+
+    cdef readonly AudioFormat format
+    """
+    The audio sample format.
+
+    :type: AudioFormat
+    """
+
+    cdef _init(self, lib.AVSampleFormat format, lib.AVChannelLayout layout, unsigned int nb_samples, unsigned int align)
+    cdef _init_user_attributes(self)
+
+cdef AudioFrame alloc_audio_frame()

lib/python3.10/site-packages/av/audio/frame.pyi

@@ -0,0 +1,47 @@
+from typing import Any, Union
+
+import numpy as np
+
+from av.frame import Frame
+
+from .format import AudioFormat
+from .layout import AudioLayout
+from .plane import AudioPlane
+
+format_dtypes: dict[str, str]
+_SupportedNDarray = Union[
+    np.ndarray[Any, np.dtype[np.float64]],  # f8
+    np.ndarray[Any, np.dtype[np.float32]],  # f4
+    np.ndarray[Any, np.dtype[np.int32]],  # i4
+    np.ndarray[Any, np.dtype[np.int16]],  # i2
+    np.ndarray[Any, np.dtype[np.uint8]],  # u1
+]
+
+class _Format:
+    def __get__(self, i: object | None, owner: type | None = None) -> AudioFormat: ...
+    def __set__(self, instance: object, value: AudioFormat | str) -> None: ...
+
+class _Layout:
+    def __get__(self, i: object | None, owner: type | None = None) -> AudioLayout: ...
+    def __set__(self, instance: object, value: AudioLayout | str) -> None: ...
+
+class AudioFrame(Frame):
+    planes: tuple[AudioPlane, ...]
+    samples: int
+    sample_rate: int
+    rate: int
+    format: _Format
+    layout: _Layout
+
+    def __init__(
+        self,
+        format: str = "s16",
+        layout: str = "stereo",
+        samples: int = 0,
+        align: int = 1,
+    ) -> None: ...
+    @staticmethod
+    def from_ndarray(
+        array: _SupportedNDarray, format: str = "s16", layout: str = "stereo"
+    ) -> AudioFrame: ...
+    def to_ndarray(self) -> _SupportedNDarray: ...

lib/python3.10/site-packages/av/audio/frame.pyx

@@ -0,0 +1,187 @@
+from av.audio.format cimport get_audio_format
+from av.audio.layout cimport get_audio_layout
+from av.audio.plane cimport AudioPlane
+from av.error cimport err_check
+from av.utils cimport check_ndarray
+
+
+cdef object _cinit_bypass_sentinel
+
+
+format_dtypes = {
+    "dbl": "f8",
+    "dblp": "f8",
+    "flt": "f4",
+    "fltp": "f4",
+    "s16": "i2",
+    "s16p": "i2",
+    "s32": "i4",
+    "s32p": "i4",
+    "u8": "u1",
+    "u8p": "u1",
+}
+
+
+cdef AudioFrame alloc_audio_frame():
+    """Get a mostly uninitialized AudioFrame.
+
+    You MUST call AudioFrame._init(...) or AudioFrame._init_user_attributes()
+    before exposing to the user.
+
+    """
+    return AudioFrame.__new__(AudioFrame, _cinit_bypass_sentinel)
+
+
+cdef class AudioFrame(Frame):
+    """A frame of audio."""
+
+    def __cinit__(self, format="s16", layout="stereo", samples=0, align=1):
+        if format is _cinit_bypass_sentinel:
+            return
+
+        cdef AudioFormat cy_format = AudioFormat(format)
+        cdef AudioLayout cy_layout = AudioLayout(layout)
+        self._init(cy_format.sample_fmt, cy_layout.layout, samples, align)
+
+    cdef _init(self, lib.AVSampleFormat format, lib.AVChannelLayout layout, unsigned int nb_samples, unsigned int align):
+        self.ptr.nb_samples = nb_samples
+        self.ptr.format = <int>format
+        self.ptr.ch_layout = layout
+
+        # Sometimes this is called twice. Oh well.
+        self._init_user_attributes()
+
+        if self.layout.nb_channels != 0 and nb_samples:
+            # Cleanup the old buffer.
+            lib.av_freep(&self._buffer)
+
+            # Get a new one.
+            self._buffer_size = err_check(lib.av_samples_get_buffer_size(
+                NULL,
+                self.layout.nb_channels,
+                nb_samples,
+                format,
+                align
+            ))
+            self._buffer = <uint8_t *>lib.av_malloc(self._buffer_size)
+            if not self._buffer:
+                raise MemoryError("cannot allocate AudioFrame buffer")
+
+            # Connect the data pointers to the buffer.
+            err_check(lib.avcodec_fill_audio_frame(
+                self.ptr,
+                self.layout.nb_channels,
+                <lib.AVSampleFormat>self.ptr.format,
+                self._buffer,
+                self._buffer_size,
+                align
+            ))
+
+    def __dealloc__(self):
+        lib.av_freep(&self._buffer)
+
+    cdef _init_user_attributes(self):
+        self.layout = get_audio_layout(self.ptr.ch_layout)
+        self.format = get_audio_format(<lib.AVSampleFormat>self.ptr.format)
+
+    def __repr__(self):
+        return (
+           f"<av.{self.__class__.__name__} pts={self.pts}, {self.samples} "
+           f"samples at {self.rate}Hz, {self.layout.name}, {self.format.name} at 0x{id(self):x}"
+        )
+
+    @staticmethod
+    def from_ndarray(array, format="s16", layout="stereo"):
+        """
+        Construct a frame from a numpy array.
+        """
+        import numpy as np
+
+        # map avcodec type to numpy type
+        try:
+            dtype = np.dtype(format_dtypes[format])
+        except KeyError:
+            raise ValueError(
+                f"Conversion from numpy array with format `{format}` is not yet supported"
+            )
+
+        # check input format
+        nb_channels = AudioLayout(layout).nb_channels
+        check_ndarray(array, dtype, 2)
+        if AudioFormat(format).is_planar:
+            if array.shape[0] != nb_channels:
+                raise ValueError(f"Expected planar `array.shape[0]` to equal `{nb_channels}` but got `{array.shape[0]}`")
+            samples = array.shape[1]
+        else:
+            if array.shape[0] != 1:
+                raise ValueError(f"Expected packed `array.shape[0]` to equal `1` but got `{array.shape[0]}`")
+            samples = array.shape[1] // nb_channels
+
+        frame = AudioFrame(format=format, layout=layout, samples=samples)
+        for i, plane in enumerate(frame.planes):
+            plane.update(array[i, :])
+        return frame
+
+    @property
+    def planes(self):
+        """
+        A tuple of :class:`~av.audio.plane.AudioPlane`.
+
+        :type: tuple
+        """
+        cdef int plane_count = 0
+        while self.ptr.extended_data[plane_count]:
+            plane_count += 1
+
+        return tuple([AudioPlane(self, i) for i in range(plane_count)])
+
+    @property
+    def samples(self):
+        """
+        Number of audio samples (per channel).
+
+        :type: int
+        """
+        return self.ptr.nb_samples
+
+    @property
+    def sample_rate(self):
+        """
+        Sample rate of the audio data, in samples per second.
+
+        :type: int
+        """
+        return self.ptr.sample_rate
+
+    @sample_rate.setter
+    def sample_rate(self, value):
+        self.ptr.sample_rate = value
+
+    @property
+    def rate(self):
+        """Another name for :attr:`sample_rate`."""
+        return self.ptr.sample_rate
+
+    @rate.setter
+    def rate(self, value):
+        self.ptr.sample_rate = value
+
+    def to_ndarray(self):
+        """Get a numpy array of this frame.
+
+        .. note:: Numpy must be installed.
+
+        """
+        import numpy as np
+
+        try:
+            dtype = np.dtype(format_dtypes[self.format.name])
+        except KeyError:
+            raise ValueError(f"Conversion from {self.format.name!r} format to numpy array is not supported.")
+
+        if self.format.is_planar:
+            count = self.samples
+        else:
+            count = self.samples * self.layout.nb_channels
+
+        return np.vstack([np.frombuffer(x, dtype=dtype, count=count) for x in self.planes])

lib/python3.10/site-packages/av/audio/layout.pxd

@@ -0,0 +1,8 @@
+cimport libav as lib
+
+
+cdef class AudioLayout:
+    cdef lib.AVChannelLayout layout
+    cdef _init(self, lib.AVChannelLayout layout)
+
+cdef AudioLayout get_audio_layout(lib.AVChannelLayout c_layout)

lib/python3.10/site-packages/av/audio/layout.pyi

@@ -0,0 +1,12 @@
+from dataclasses import dataclass
+
+class AudioLayout:
+    name: str
+    nb_channels: int
+    channels: tuple[AudioChannel, ...]
+    def __init__(self, layout: str | AudioLayout): ...
+
+@dataclass
+class AudioChannel:
+    name: str
+    description: str

lib/python3.10/site-packages/av/audio/layout.pyx

@@ -0,0 +1,84 @@
+cimport libav as lib
+from cpython.bytes cimport PyBytes_FromStringAndSize
+
+from dataclasses import dataclass
+
+
+@dataclass
+class AudioChannel:
+    name: str
+    description: str
+
+    def __repr__(self):
+        return f"<av.AudioChannel '{self.name}' ({self.description})>"
+
+cdef object _cinit_bypass_sentinel
+
+cdef AudioLayout get_audio_layout(lib.AVChannelLayout c_layout):
+    """Get an AudioLayout from Cython land."""
+    cdef AudioLayout layout = AudioLayout.__new__(AudioLayout, _cinit_bypass_sentinel)
+    layout._init(c_layout)
+    return layout
+
+
+cdef class AudioLayout:
+    def __init__(self, layout):
+        if layout is _cinit_bypass_sentinel:
+            return
+
+        if type(layout) is str:
+            ret = lib.av_channel_layout_from_string(&c_layout, layout)
+            if ret != 0:
+                raise ValueError(f"Invalid layout: {layout}")
+        elif isinstance(layout, AudioLayout):
+            c_layout = (<AudioLayout>layout).layout
+        else:
+            raise TypeError(f"layout must be of type: string | av.AudioLayout, got {type(layout)}")
+
+        self._init(c_layout)
+
+    cdef _init(self, lib.AVChannelLayout layout):
+        self.layout = layout
+
+    def __repr__(self):
+        return f"<av.{self.__class__.__name__} {self.name!r}>"
+
+    def __eq__(self, other):
+        return isinstance(other, AudioLayout) and self.name == other.name and self.nb_channels == other.nb_channels
+
+    @property
+    def nb_channels(self):
+        return self.layout.nb_channels
+
+    @property
+    def channels(self):
+        cdef lib.AVChannel channel
+        cdef char buf[16]
+        cdef char buf2[128]
+
+        results = []
+
+        for index in range(self.layout.nb_channels):
+            channel = lib.av_channel_layout_channel_from_index(&self.layout, index);
+            size = lib.av_channel_name(buf, sizeof(buf), channel) - 1
+            size2 = lib.av_channel_description(buf2, sizeof(buf2), channel) - 1
+            results.append(
+                AudioChannel(
+                    PyBytes_FromStringAndSize(buf, size).decode("utf-8"),
+                    PyBytes_FromStringAndSize(buf2, size2).decode("utf-8"),
+                )
+            )
+
+        return tuple(results)
+
+    @property
+    def name(self) -> str:
+        """The canonical name of the audio layout."""
+        cdef char layout_name[128]
+        cdef int ret
+
+        ret = lib.av_channel_layout_describe(&self.layout, layout_name, sizeof(layout_name))
+        if ret < 0:
+            raise RuntimeError(f"Failed to get layout name: {ret}")
+
+        return layout_name

lib/python3.10/site-packages/av/audio/plane.pxd

@@ -0,0 +1,8 @@
+from av.plane cimport Plane
+
+
+cdef class AudioPlane(Plane):
+
+    cdef readonly size_t buffer_size
+
+    cdef size_t _buffer_size(self)

lib/python3.10/site-packages/av/audio/plane.pyi

@@ -0,0 +1,4 @@
+from av.plane import Plane
+
+class AudioPlane(Plane):
+    buffer_size: int

lib/python3.10/site-packages/av/audio/plane.pyx

@@ -0,0 +1,11 @@
+from av.audio.frame cimport AudioFrame
+
+
+cdef class AudioPlane(Plane):
+
+    def __cinit__(self, AudioFrame frame, int index):
+        # Only the first linesize is ever populated, but it applies to every plane.
+        self.buffer_size = self.frame.ptr.linesize[0]
+
+    cdef size_t _buffer_size(self):
+        return self.buffer_size

lib/python3.10/site-packages/av/audio/resampler.pxd

@@ -0,0 +1,21 @@
+from av.audio.format cimport AudioFormat
+from av.audio.frame cimport AudioFrame
+from av.audio.layout cimport AudioLayout
+from av.filter.graph cimport Graph
+
+
+cdef class AudioResampler:
+
+    cdef readonly bint is_passthrough
+
+    cdef AudioFrame template
+
+    # Destination descriptors
+    cdef readonly AudioFormat format
+    cdef readonly AudioLayout layout
+    cdef readonly int rate
+    cdef readonly unsigned int frame_size
+
+    cdef Graph graph
+
+    cpdef resample(self, AudioFrame)

lib/python3.10/site-packages/av/audio/resampler.pyi

@@ -0,0 +1,20 @@
+from av.filter.graph import Graph
+
+from .format import AudioFormat
+from .frame import AudioFrame
+from .layout import AudioLayout
+
+class AudioResampler:
+    rate: int
+    frame_size: int
+    format: AudioFormat
+    graph: Graph | None
+
+    def __init__(
+        self,
+        format: str | int | AudioFormat | None = None,
+        layout: str | int | AudioLayout | None = None,
+        rate: int | None = None,
+        frame_size: int | None = None,
+    ) -> None: ...
+    def resample(self, frame: AudioFrame | None) -> list[AudioFrame]: ...

lib/python3.10/site-packages/av/audio/resampler.pyx

@@ -0,0 +1,119 @@
+from av.filter.context cimport FilterContext
+
+import errno
+
+import av.filter
+
+
+cdef class AudioResampler:
+
+    """AudioResampler(format=None, layout=None, rate=None)
+
+    :param AudioFormat format: The target format, or string that parses to one
+        (e.g. ``"s16"``).
+    :param AudioLayout layout: The target layout, or an int/string that parses
+        to one (e.g. ``"stereo"``).
+    :param int rate: The target sample rate.
+
+
+    """
+
+    def __cinit__(self, format=None, layout=None, rate=None, frame_size=None):
+        if format is not None:
+            self.format = format if isinstance(format, AudioFormat) else AudioFormat(format)
+
+        if layout is not None:
+            self.layout = AudioLayout(layout)
+        self.rate = int(rate) if rate else 0
+
+        self.frame_size = int(frame_size) if frame_size else 0
+
+        self.graph = None
+
+    cpdef resample(self, AudioFrame frame):
+        """resample(frame)
+
+        Convert the ``sample_rate``, ``channel_layout`` and/or ``format`` of
+        a :class:`~.AudioFrame`.
+
+        :param AudioFrame frame: The frame to convert or `None` to flush.
+        :returns: A list of :class:`AudioFrame` in new parameters. If the nothing is to be done return the same frame
+            as a single element list.
+
+        """
+        # We don't have any input, so don't bother even setting up.
+        if not self.graph and frame is None:
+            return []
+
+        # Shortcut for passthrough.
+        if self.is_passthrough:
+            return [frame]
+
+        # Take source settings from the first frame.
+        if not self.graph:
+            self.template = frame
+
+            # Set some default descriptors.
+            self.format = self.format or frame.format
+            self.layout = self.layout or frame.layout
+            self.rate = self.rate or frame.sample_rate
+
+            # Check if we can passthrough or if there is actually work to do.
+            if (
+                frame.format.sample_fmt == self.format.sample_fmt and
+                frame.layout == self.layout and
+                frame.sample_rate == self.rate and
+                self.frame_size == 0
+            ):
+                self.is_passthrough = True
+                return [frame]
+
+            # handle resampling with aformat filter
+            # (similar to configure_output_audio_filter from ffmpeg)
+            self.graph = av.filter.Graph()
+            extra_args = {}
+            if frame.time_base is not None:
+                extra_args["time_base"] = str(frame.time_base)
+            abuffer = self.graph.add(
+                "abuffer",
+                sample_rate=str(frame.sample_rate),
+                sample_fmt=AudioFormat(frame.format).name,
+                channel_layout=frame.layout.name,
+                **extra_args,
+            )
+            aformat = self.graph.add(
+                "aformat",
+                sample_rates=str(self.rate),
+                sample_fmts=self.format.name,
+                channel_layouts=self.layout.name,
+            )
+            abuffersink = self.graph.add("abuffersink")
+            abuffer.link_to(aformat)
+            aformat.link_to(abuffersink)
+            self.graph.configure()
+
+            if self.frame_size > 0:
+                self.graph.set_audio_frame_size(self.frame_size)
+
+        if frame is not None:
+            if (
+                frame.format.sample_fmt != self.template.format.sample_fmt or
+                frame.layout != self.template.layout or
+                frame.sample_rate != self.template.rate
+            ):
+                raise ValueError("Frame does not match AudioResampler setup.")
+
+        self.graph.push(frame)
+
+        output = []
+        while True:
+            try:
+                output.append(self.graph.pull())
+            except EOFError:
+                break
+            except av.FFmpegError as e:
+                if e.errno != errno.EAGAIN:
+                    raise
+                break
+
+        return output

lib/python3.10/site-packages/av/audio/stream.pyx

@@ -0,0 +1,43 @@
+from av.packet cimport Packet
+
+from .frame cimport AudioFrame
+
+
+cdef class AudioStream(Stream):
+    def __repr__(self):
+        form = self.format.name if self.format else None
+        return (
+            f"<av.AudioStream #{self.index} {self.name} at {self.rate}Hz,"
+            f" {self.layout.name}, {form} at 0x{id(self):x}>"
+        )
+
+    def __getattr__(self, name):
+        return getattr(self.codec_context, name)
+
+    cpdef encode(self, AudioFrame frame=None):
+        """
+        Encode an :class:`.AudioFrame` and return a list of :class:`.Packet`.
+
+        :rtype: list[Packet]
+
+        .. seealso:: This is mostly a passthrough to :meth:`.CodecContext.encode`.
+        """
+
+        packets = self.codec_context.encode(frame)
+        cdef Packet packet
+        for packet in packets:
+            packet._stream = self
+            packet.ptr.stream_index = self.ptr.index
+
+        return packets
+
+    cpdef decode(self, Packet packet=None):
+        """
+        Decode a :class:`.Packet` and return a list of :class:`.AudioFrame`.
+
+        :rtype: list[AudioFrame]
+
+        .. seealso:: This is a passthrough to :meth:`.CodecContext.decode`.
+        """
+
+        return self.codec_context.decode(packet)

lib/python3.10/site-packages/av/codec/codec.pyi

@@ -0,0 +1,115 @@
+from enum import Flag, IntEnum
+from fractions import Fraction
+from typing import ClassVar, Literal, cast, overload
+
+from av.audio.codeccontext import AudioCodecContext
+from av.audio.format import AudioFormat
+from av.descriptor import Descriptor
+from av.subtitles.codeccontext import SubtitleCodecContext
+from av.video.codeccontext import VideoCodecContext
+from av.video.format import VideoFormat
+
+from .context import CodecContext
+
+class Properties(Flag):
+    NONE = cast(ClassVar[Properties], ...)
+    INTRA_ONLY = cast(ClassVar[Properties], ...)
+    LOSSY = cast(ClassVar[Properties], ...)
+    LOSSLESS = cast(ClassVar[Properties], ...)
+    REORDER = cast(ClassVar[Properties], ...)
+    BITMAP_SUB = cast(ClassVar[Properties], ...)
+    TEXT_SUB = cast(ClassVar[Properties], ...)
+
+class Capabilities(IntEnum):
+    none = cast(int, ...)
+    draw_horiz_band = cast(int, ...)
+    dr1 = cast(int, ...)
+    hwaccel = cast(int, ...)
+    delay = cast(int, ...)
+    small_last_frame = cast(int, ...)
+    hwaccel_vdpau = cast(int, ...)
+    subframes = cast(int, ...)
+    experimental = cast(int, ...)
+    channel_conf = cast(int, ...)
+    neg_linesizes = cast(int, ...)
+    frame_threads = cast(int, ...)
+    slice_threads = cast(int, ...)
+    param_change = cast(int, ...)
+    auto_threads = cast(int, ...)
+    variable_frame_size = cast(int, ...)
+    avoid_probing = cast(int, ...)
+    hardware = cast(int, ...)
+    hybrid = cast(int, ...)
+    encoder_reordered_opaque = cast(int, ...)
+    encoder_flush = cast(int, ...)
+    encoder_recon_frame = cast(int, ...)
+
+class UnknownCodecError(ValueError): ...
+
+class Codec:
+    @property
+    def is_encoder(self) -> bool: ...
+    @property
+    def is_decoder(self) -> bool: ...
+    @property
+    def mode(self) -> Literal["r", "w"]: ...
+    descriptor: Descriptor
+    @property
+    def name(self) -> str: ...
+    @property
+    def canonical_name(self) -> str: ...
+    @property
+    def long_name(self) -> str: ...
+    @property
+    def type(self) -> Literal["video", "audio", "data", "subtitle", "attachment"]: ...
+    @property
+    def id(self) -> int: ...
+    frame_rates: list[Fraction] | None
+    audio_rates: list[int] | None
+    video_formats: list[VideoFormat] | None
+    audio_formats: list[AudioFormat] | None
+
+    @property
+    def properties(self) -> int: ...
+    @property
+    def intra_only(self) -> bool: ...
+    @property
+    def lossy(self) -> bool: ...
+    @property
+    def lossless(self) -> bool: ...
+    @property
+    def reorder(self) -> bool: ...
+    @property
+    def bitmap_sub(self) -> bool: ...
+    @property
+    def text_sub(self) -> bool: ...
+    @property
+    def capabilities(self) -> int: ...
+    @property
+    def experimental(self) -> bool: ...
+    @property
+    def delay(self) -> bool: ...
+    def __init__(self, name: str, mode: Literal["r", "w"] = "r") -> None: ...
+    @overload
+    def create(self, kind: Literal["video"]) -> VideoCodecContext: ...
+    @overload
+    def create(self, kind: Literal["audio"]) -> AudioCodecContext: ...
+    @overload
+    def create(self, kind: Literal["subtitle"]) -> SubtitleCodecContext: ...
+    @overload
+    def create(self, kind: None = None) -> CodecContext: ...
+    @overload
+    def create(
+        self, kind: Literal["video", "audio", "subtitle"] | None = None
+    ) -> (
+        VideoCodecContext | AudioCodecContext | SubtitleCodecContext | CodecContext
+    ): ...
+
+class codec_descriptor:
+    name: str
+    options: tuple[int, ...]
+
+codecs_available: set[str]
+
+def dump_codecs() -> None: ...
+def dump_hwconfigs() -> None: ...

lib/python3.10/site-packages/av/codec/context.pxd

@@ -0,0 +1,64 @@
+cimport libav as lib
+from libc.stdint cimport int64_t
+
+from av.bytesource cimport ByteSource
+from av.codec.codec cimport Codec
+from av.codec.hwaccel cimport HWAccel
+from av.frame cimport Frame
+from av.packet cimport Packet
+
+
+cdef class CodecContext:
+    cdef lib.AVCodecContext *ptr
+
+    # Whether AVCodecContext.extradata should be de-allocated upon destruction.
+    cdef bint extradata_set
+
+    # Used as a signal that this is within a stream, and also for us to access that
+    # stream. This is set "manually" by the stream after constructing this object.
+    cdef int stream_index
+
+    cdef lib.AVCodecParserContext *parser
+    cdef _init(self, lib.AVCodecContext *ptr, const lib.AVCodec *codec, HWAccel hwaccel)
+
+    # Public API.
+    cdef readonly bint is_open
+    cdef readonly Codec codec
+    cdef readonly HWAccel hwaccel
+    cdef public dict options
+    cpdef open(self, bint strict=?)
+
+    # Wraps both versions of the transcode API, returning lists.
+    cpdef encode(self, Frame frame=?)
+    cpdef decode(self, Packet packet=?)
+    cpdef flush_buffers(self)
+
+    # Used by hardware-accelerated decode.
+    cdef HWAccel hwaccel_ctx
+
+    # Used by both transcode APIs to setup user-land objects.
+    # TODO: Remove the `Packet` from `_setup_decoded_frame` (because flushing packets
+    # are bogus). It should take all info it needs from the context and/or stream.
+    cdef _prepare_and_time_rebase_frames_for_encode(self, Frame frame)
+    cdef _prepare_frames_for_encode(self, Frame frame)
+    cdef _setup_encoded_packet(self, Packet)
+    cdef _setup_decoded_frame(self, Frame, Packet)
+
+    # Implemented by base for the generic send/recv API.
+    # Note that the user cannot send without receiving. This is because
+    # `_prepare_frames_for_encode` may expand a frame into multiple (e.g. when
+    # resampling audio to a higher rate but with fixed size frames), and the
+    # send/recv buffer may be limited to a single frame. Ergo, we need to flush
+    # the buffer as often as possible.
+    cdef _recv_packet(self)
+    cdef _send_packet_and_recv(self, Packet packet)
+    cdef _recv_frame(self)
+
+    cdef _transfer_hwframe(self, Frame frame)
+
+    # Implemented by children for the generic send/recv API, so we have the
+    # correct subclass of Frame.
+    cdef Frame _next_frame
+    cdef Frame _alloc_next_frame(self)
+
+cdef CodecContext wrap_codec_context(lib.AVCodecContext*, const lib.AVCodec*, HWAccel hwaccel)

lib/python3.10/site-packages/av/codec/context.pyx

@@ -0,0 +1,672 @@
+cimport libav as lib
+from libc.errno cimport EAGAIN
+from libc.stdint cimport uint8_t
+from libc.string cimport memcpy
+
+from av.bytesource cimport ByteSource, bytesource
+from av.codec.codec cimport Codec, wrap_codec
+from av.dictionary cimport _Dictionary
+from av.error cimport err_check
+from av.packet cimport Packet
+from av.utils cimport avrational_to_fraction, to_avrational
+
+from enum import Flag, IntEnum
+
+from av.dictionary import Dictionary
+
+
+cdef object _cinit_sentinel = object()
+
+
+cdef CodecContext wrap_codec_context(lib.AVCodecContext *c_ctx, const lib.AVCodec *c_codec, HWAccel hwaccel):
+    """Build an av.CodecContext for an existing AVCodecContext."""
+
+    cdef CodecContext py_ctx
+
+    if c_ctx.codec_type == lib.AVMEDIA_TYPE_VIDEO:
+        from av.video.codeccontext import VideoCodecContext
+        py_ctx = VideoCodecContext(_cinit_sentinel)
+    elif c_ctx.codec_type == lib.AVMEDIA_TYPE_AUDIO:
+        from av.audio.codeccontext import AudioCodecContext
+        py_ctx = AudioCodecContext(_cinit_sentinel)
+    elif c_ctx.codec_type == lib.AVMEDIA_TYPE_SUBTITLE:
+        from av.subtitles.codeccontext import SubtitleCodecContext
+        py_ctx = SubtitleCodecContext(_cinit_sentinel)
+    else:
+        py_ctx = CodecContext(_cinit_sentinel)
+
+    py_ctx._init(c_ctx, c_codec, hwaccel)
+
+    return py_ctx
+
+
+class ThreadType(Flag):
+    NONE = 0
+    FRAME: "Decode more than one frame at once" = lib.FF_THREAD_FRAME
+    SLICE: "Decode more than one part of a single frame at once" = lib.FF_THREAD_SLICE
+    AUTO: "Decode using both FRAME and SLICE methods." = lib.FF_THREAD_SLICE | lib.FF_THREAD_FRAME
+
+class Flags(IntEnum):
+    unaligned = lib.AV_CODEC_FLAG_UNALIGNED
+    qscale = lib.AV_CODEC_FLAG_QSCALE
+    four_mv = lib.AV_CODEC_FLAG_4MV
+    output_corrupt = lib.AV_CODEC_FLAG_OUTPUT_CORRUPT
+    qpel = lib.AV_CODEC_FLAG_QPEL
+    drop_changed = 1 << 5
+    recon_frame = lib.AV_CODEC_FLAG_RECON_FRAME
+    copy_opaque = lib.AV_CODEC_FLAG_COPY_OPAQUE
+    frame_duration = lib.AV_CODEC_FLAG_FRAME_DURATION
+    pass1 = lib.AV_CODEC_FLAG_PASS1
+    pass2 = lib.AV_CODEC_FLAG_PASS2
+    loop_filter = lib.AV_CODEC_FLAG_LOOP_FILTER
+    gray = lib.AV_CODEC_FLAG_GRAY
+    psnr = lib.AV_CODEC_FLAG_PSNR
+    interlaced_dct = lib.AV_CODEC_FLAG_INTERLACED_DCT
+    low_delay = lib.AV_CODEC_FLAG_LOW_DELAY
+    global_header = lib.AV_CODEC_FLAG_GLOBAL_HEADER
+    bitexact = lib.AV_CODEC_FLAG_BITEXACT
+    ac_pred = lib.AV_CODEC_FLAG_AC_PRED
+    interlaced_me = lib.AV_CODEC_FLAG_INTERLACED_ME
+    closed_gop = lib.AV_CODEC_FLAG_CLOSED_GOP
+
+class Flags2(IntEnum):
+    fast = lib.AV_CODEC_FLAG2_FAST
+    no_output = lib.AV_CODEC_FLAG2_NO_OUTPUT
+    local_header = lib.AV_CODEC_FLAG2_LOCAL_HEADER
+    chunks = lib.AV_CODEC_FLAG2_CHUNKS
+    ignore_crop = lib.AV_CODEC_FLAG2_IGNORE_CROP
+    show_all = lib.AV_CODEC_FLAG2_SHOW_ALL
+    export_mvs = lib.AV_CODEC_FLAG2_EXPORT_MVS
+    skip_manual = lib.AV_CODEC_FLAG2_SKIP_MANUAL
+    ro_flush_noop = lib.AV_CODEC_FLAG2_RO_FLUSH_NOOP
+
+
+cdef class CodecContext:
+    @staticmethod
+    def create(codec, mode=None, hwaccel=None):
+        cdef Codec cy_codec = codec if isinstance(codec, Codec) else Codec(codec, mode)
+        cdef lib.AVCodecContext *c_ctx = lib.avcodec_alloc_context3(cy_codec.ptr)
+        return wrap_codec_context(c_ctx, cy_codec.ptr, hwaccel)
+
+    def __cinit__(self, sentinel=None, *args, **kwargs):
+        if sentinel is not _cinit_sentinel:
+            raise RuntimeError("Cannot instantiate CodecContext")
+
+        self.options = {}
+        self.stream_index = -1  # This is set by the container immediately.
+        self.is_open = False
+
+    cdef _init(self, lib.AVCodecContext *ptr, const lib.AVCodec *codec, HWAccel hwaccel):
+        self.ptr = ptr
+        if self.ptr.codec and codec and self.ptr.codec != codec:
+            raise RuntimeError("Wrapping CodecContext with mismatched codec.")
+        self.codec = wrap_codec(codec if codec != NULL else self.ptr.codec)
+        self.hwaccel = hwaccel
+
+        # Set reasonable threading defaults.
+        self.ptr.thread_count = 0  # use as many threads as there are CPUs.
+        self.ptr.thread_type = 0x02  # thread within a frame. Does not change the API.
+
+    @property
+    def flags(self):
+        """
+        Get and set the flags bitmask of CodecContext.
+
+        :rtype: int
+        """
+        return self.ptr.flags
+
+    @flags.setter
+    def flags(self, int value):
+        self.ptr.flags = value
+
+    @property
+    def qscale(self):
+        """
+        Use fixed qscale.
+
+        :rtype: bool
+        """
+        return bool(self.ptr.flags & lib.AV_CODEC_FLAG_QSCALE)
+
+    @qscale.setter
+    def qscale(self, value):
+        if value:
+            self.ptr.flags |= lib.AV_CODEC_FLAG_QSCALE
+        else:
+            self.ptr.flags &= ~lib.AV_CODEC_FLAG_QSCALE
+
+    @property
+    def copy_opaque(self):
+        return bool(self.ptr.flags & lib.AV_CODEC_FLAG_COPY_OPAQUE)
+
+    @copy_opaque.setter
+    def copy_opaque(self, value):
+        if value:
+            self.ptr.flags |= lib.AV_CODEC_FLAG_COPY_OPAQUE
+        else:
+            self.ptr.flags &= ~lib.AV_CODEC_FLAG_COPY_OPAQUE
+
+    @property
+    def flags2(self):
+        """
+        Get and set the flags2 bitmask of CodecContext.
+
+        :rtype: int
+        """
+        return self.ptr.flags2
+
+    @flags2.setter
+    def flags2(self, int value):
+        self.ptr.flags2 = value
+
+    @property
+    def extradata(self):
+        if self.ptr is NULL:
+            return None
+        if self.ptr.extradata_size > 0:
+            return <bytes>(<uint8_t*>self.ptr.extradata)[:self.ptr.extradata_size]
+        return None
+
+    @extradata.setter
+    def extradata(self, data):
+        if data is None:
+            lib.av_freep(&self.ptr.extradata)
+            self.ptr.extradata_size = 0
+        else:
+            source = bytesource(data)
+            self.ptr.extradata = <uint8_t*>lib.av_realloc(self.ptr.extradata, source.length + lib.AV_INPUT_BUFFER_PADDING_SIZE)
+            if not self.ptr.extradata:
+                raise MemoryError("Cannot allocate extradata")
+            memcpy(self.ptr.extradata, source.ptr, source.length)
+            self.ptr.extradata_size = source.length
+        self.extradata_set = True
+
+    @property
+    def extradata_size(self):
+        return self.ptr.extradata_size
+
+    @property
+    def is_encoder(self):
+        if self.ptr is NULL:
+            return False
+        return lib.av_codec_is_encoder(self.ptr.codec)
+
+    @property
+    def is_decoder(self):
+        if self.ptr is NULL:
+            return False
+        return lib.av_codec_is_decoder(self.ptr.codec)
+
+    cpdef open(self, bint strict=True):
+        if self.is_open:
+            if strict:
+                raise ValueError("CodecContext is already open.")
+            return
+
+        cdef _Dictionary options = Dictionary()
+        options.update(self.options or {})
+
+        if not self.ptr.time_base.num and self.is_encoder:
+            if self.type == "video":
+                self.ptr.time_base.num = self.ptr.framerate.den or 1
+                self.ptr.time_base.den = self.ptr.framerate.num or lib.AV_TIME_BASE
+            elif self.type == "audio":
+                self.ptr.time_base.num = 1
+                self.ptr.time_base.den = self.ptr.sample_rate
+            else:
+                self.ptr.time_base.num = 1
+                self.ptr.time_base.den = lib.AV_TIME_BASE
+
+        err_check(lib.avcodec_open2(self.ptr, self.codec.ptr, &options.ptr), "avcodec_open2(" + self.codec.name + ")")
+        self.is_open = True
+        self.options = dict(options)
+
+    def __dealloc__(self):
+        if self.ptr and self.extradata_set:
+            lib.av_freep(&self.ptr.extradata)
+        if self.ptr:
+            lib.avcodec_free_context(&self.ptr)
+        if self.parser:
+            lib.av_parser_close(self.parser)
+
+    def __repr__(self):
+        _type = self.type or "<notype>"
+        name = self.name or "<nocodec>"
+        return f"<av.{self.__class__.__name__} {_type}/{name} at 0x{id(self):x}>"
+
+    def parse(self, raw_input=None):
+        """Split up a byte stream into list of :class:`.Packet`.
+
+        This is only effectively splitting up a byte stream, and does no
+        actual interpretation of the data.
+
+        It will return all packets that are fully contained within the given
+        input, and will buffer partial packets until they are complete.
+
+        :param ByteSource raw_input: A chunk of a byte-stream to process.
+            Anything that can be turned into a :class:`.ByteSource` is fine.
+            ``None`` or empty inputs will flush the parser's buffers.
+
+        :return: ``list`` of :class:`.Packet` newly available.
+
+        """
+
+        if not self.parser:
+            self.parser = lib.av_parser_init(self.codec.ptr.id)
+            if not self.parser:
+                raise ValueError(f"No parser for {self.codec.name}")
+
+        cdef ByteSource source = bytesource(raw_input, allow_none=True)
+
+        cdef unsigned char *in_data = source.ptr if source is not None else NULL
+        cdef int in_size = source.length if source is not None else 0
+
+        cdef unsigned char *out_data
+        cdef int out_size
+        cdef int consumed
+        cdef Packet packet = None
+
+        packets = []
+
+        while True:
+            with nogil:
+                consumed = lib.av_parser_parse2(
+                    self.parser,
+                    self.ptr,
+                    &out_data, &out_size,
+                    in_data, in_size,
+                    lib.AV_NOPTS_VALUE, lib.AV_NOPTS_VALUE,
+                    0
+                )
+            err_check(consumed)
+
+            if out_size:
+                # We copy the data immediately, as we have yet to figure out
+                # the expected lifetime of the buffer we get back. All of the
+                # examples decode it immediately.
+                #
+                # We've also tried:
+                #   packet = Packet()
+                #   packet.data = out_data
+                #   packet.size = out_size
+                #   packet.source = source
+                #
+                # ... but this results in corruption.
+
+                packet = Packet(out_size)
+                memcpy(packet.ptr.data, out_data, out_size)
+
+                packets.append(packet)
+
+            if not in_size:
+                # This was a flush. Only one packet should ever be returned.
+                break
+
+            in_data += consumed
+            in_size -= consumed
+
+            if not in_size:
+                break
+
+        return packets
+
+    @property
+    def is_hwaccel(self):
+        """
+        Returns ``True`` if this codec context is hardware accelerated, ``False`` otherwise.
+        """
+        return self.hwaccel_ctx is not None
+
+    def _send_frame_and_recv(self, Frame frame):
+        cdef Packet packet
+
+        cdef int res
+        with nogil:
+            res = lib.avcodec_send_frame(self.ptr, frame.ptr if frame is not None else NULL)
+        err_check(res, "avcodec_send_frame()")
+
+        packet = self._recv_packet()
+        while packet:
+            yield packet
+            packet = self._recv_packet()
+
+    cdef _send_packet_and_recv(self, Packet packet):
+        cdef Frame frame
+
+        cdef int res
+        with nogil:
+            res = lib.avcodec_send_packet(self.ptr, packet.ptr if packet is not None else NULL)
+        err_check(res, "avcodec_send_packet()")
+
+        out = []
+        while True:
+            frame = self._recv_frame()
+            if frame:
+                out.append(frame)
+            else:
+                break
+        return out
+
+    cdef _prepare_frames_for_encode(self, Frame frame):
+        return [frame]
+
+    cdef Frame _alloc_next_frame(self):
+        raise NotImplementedError("Base CodecContext cannot decode.")
+
+    cdef _recv_frame(self):
+        if not self._next_frame:
+            self._next_frame = self._alloc_next_frame()
+        cdef Frame frame = self._next_frame
+
+        cdef int res
+        with nogil:
+            res = lib.avcodec_receive_frame(self.ptr, frame.ptr)
+
+        if res == -EAGAIN or res == lib.AVERROR_EOF:
+            return
+        err_check(res, "avcodec_receive_frame()")
+
+        frame = self._transfer_hwframe(frame)
+
+        if not res:
+            self._next_frame = None
+            return frame
+
+    cdef _transfer_hwframe(self, Frame frame):
+        return frame
+
+    cdef _recv_packet(self):
+        cdef Packet packet = Packet()
+
+        cdef int res
+        with nogil:
+            res = lib.avcodec_receive_packet(self.ptr, packet.ptr)
+        if res == -EAGAIN or res == lib.AVERROR_EOF:
+            return
+        err_check(res, "avcodec_receive_packet()")
+
+        if not res:
+            return packet
+
+    cdef _prepare_and_time_rebase_frames_for_encode(self, Frame frame):
+        if self.ptr.codec_type not in [lib.AVMEDIA_TYPE_VIDEO, lib.AVMEDIA_TYPE_AUDIO]:
+            raise NotImplementedError("Encoding is only supported for audio and video.")
+
+        self.open(strict=False)
+
+        frames = self._prepare_frames_for_encode(frame)
+
+        # Assert the frames are in our time base.
+        # TODO: Don't mutate time.
+        for frame in frames:
+            if frame is not None:
+                frame._rebase_time(self.ptr.time_base)
+
+        return frames
+
+    cpdef encode(self, Frame frame=None):
+        """Encode a list of :class:`.Packet` from the given :class:`.Frame`."""
+        res = []
+        for frame in self._prepare_and_time_rebase_frames_for_encode(frame):
+            for packet in self._send_frame_and_recv(frame):
+                self._setup_encoded_packet(packet)
+                res.append(packet)
+        return res
+
+    def encode_lazy(self, Frame frame=None):
+        for frame in self._prepare_and_time_rebase_frames_for_encode(frame):
+            for packet in self._send_frame_and_recv(frame):
+                self._setup_encoded_packet(packet)
+                yield packet
+
+    cdef _setup_encoded_packet(self, Packet packet):
+        # We coerced the frame's time_base into the CodecContext's during encoding,
+        # and FFmpeg copied the frame's pts/dts to the packet, so keep track of
+        # this time_base in case the frame needs to be muxed to a container with
+        # a different time_base.
+        #
+        # NOTE: if the CodecContext's time_base is altered during encoding, all bets
+        # are off!
+        packet._time_base = self.ptr.time_base
+
+    cpdef decode(self, Packet packet=None):
+        """Decode a list of :class:`.Frame` from the given :class:`.Packet`.
+
+        If the packet is None, the buffers will be flushed. This is useful if
+        you do not want the library to automatically re-order frames for you
+        (if they are encoded with a codec that has B-frames).
+
+        """
+
+        if not self.codec.ptr:
+            raise ValueError("cannot decode unknown codec")
+
+        self.open(strict=False)
+
+        res = []
+        for frame in self._send_packet_and_recv(packet):
+            if isinstance(frame, Frame):
+                self._setup_decoded_frame(frame, packet)
+            res.append(frame)
+        return res
+
+    cpdef flush_buffers(self):
+        """Reset the internal codec state and discard all internal buffers.
+
+        Should be called before you start decoding from a new position e.g.
+        when seeking or when switching to a different stream.
+
+        """
+        if self.is_open:
+            with nogil:
+                lib.avcodec_flush_buffers(self.ptr)
+
+    cdef _setup_decoded_frame(self, Frame frame, Packet packet):
+        # Propagate our manual times.
+        # While decoding, frame times are in stream time_base, which PyAV
+        # is carrying around.
+        # TODO: Somehow get this from the stream so we can not pass the
+        # packet here (because flushing packets are bogus).
+        if packet is not None:
+            frame._time_base = packet._time_base
+
+    @property
+    def name(self):
+        return self.codec.name
+
+    @property
+    def type(self):
+        return self.codec.type
+
+    @property
+    def profiles(self):
+        """
+        List the available profiles for this stream.
+
+        :type: list[str]
+        """
+        ret = []
+        if not self.ptr.codec or not self.codec.desc or not self.codec.desc.profiles:
+            return ret
+
+        # Profiles are always listed in the codec descriptor, but not necessarily in
+        # the codec itself. So use the descriptor here.
+        desc = self.codec.desc
+        cdef int i = 0
+        while desc.profiles[i].profile != lib.FF_PROFILE_UNKNOWN:
+            ret.append(desc.profiles[i].name)
+            i += 1
+
+        return ret
+
+    @property
+    def profile(self):
+        if not self.ptr.codec or not self.codec.desc or not self.codec.desc.profiles:
+            return
+
+        # Profiles are always listed in the codec descriptor, but not necessarily in
+        # the codec itself. So use the descriptor here.
+        desc = self.codec.desc
+        cdef int i = 0
+        while desc.profiles[i].profile != lib.FF_PROFILE_UNKNOWN:
+            if desc.profiles[i].profile == self.ptr.profile:
+                return desc.profiles[i].name
+            i += 1
+
+    @profile.setter
+    def profile(self, value):
+        if not self.codec or not self.codec.desc or not self.codec.desc.profiles:
+            return
+
+        # Profiles are always listed in the codec descriptor, but not necessarily in
+        # the codec itself. So use the descriptor here.
+        desc = self.codec.desc
+        cdef int i = 0
+        while desc.profiles[i].profile != lib.FF_PROFILE_UNKNOWN:
+            if desc.profiles[i].name == value:
+                self.ptr.profile = desc.profiles[i].profile
+                return
+            i += 1
+
+    @property
+    def time_base(self):
+        if self.is_decoder:
+            raise RuntimeError("Cannot access 'time_base' as a decoder")
+        return avrational_to_fraction(&self.ptr.time_base)
+
+    @time_base.setter
+    def time_base(self, value):
+        if self.is_decoder:
+            raise RuntimeError("Cannot access 'time_base' as a decoder")
+        to_avrational(value, &self.ptr.time_base)
+
+    @property
+    def codec_tag(self):
+        return self.ptr.codec_tag.to_bytes(4, byteorder="little", signed=False).decode(
+            encoding="ascii")
+
+    @codec_tag.setter
+    def codec_tag(self, value):
+        if isinstance(value, str) and len(value) == 4:
+            self.ptr.codec_tag = int.from_bytes(value.encode(encoding="ascii"),
+                                                byteorder="little", signed=False)
+        else:
+            raise ValueError("Codec tag should be a 4 character string.")
+
+    @property
+    def bit_rate(self):
+        return self.ptr.bit_rate if self.ptr.bit_rate > 0 else None
+
+    @bit_rate.setter
+    def bit_rate(self, int value):
+        self.ptr.bit_rate = value
+
+    @property
+    def max_bit_rate(self):
+        if self.ptr.rc_max_rate > 0:
+            return self.ptr.rc_max_rate
+        else:
+            return None
+
+    @property
+    def bit_rate_tolerance(self):
+        self.ptr.bit_rate_tolerance
+
+    @bit_rate_tolerance.setter
+    def bit_rate_tolerance(self, int value):
+        self.ptr.bit_rate_tolerance = value
+
+    @property
+    def thread_count(self):
+        """How many threads to use; 0 means auto.
+
+        Wraps :ffmpeg:`AVCodecContext.thread_count`.
+
+        """
+        return self.ptr.thread_count
+
+    @thread_count.setter
+    def thread_count(self, int value):
+        if self.is_open:
+            raise RuntimeError("Cannot change thread_count after codec is open.")
+        self.ptr.thread_count = value
+
+    @property
+    def thread_type(self):
+        """One of :class:`.ThreadType`.
+
+        Wraps :ffmpeg:`AVCodecContext.thread_type`.
+
+        """
+        return ThreadType(self.ptr.thread_type)
+
+    @thread_type.setter
+    def thread_type(self, value):
+        if self.is_open:
+            raise RuntimeError("Cannot change thread_type after codec is open.")
+        if type(value) is int:
+            self.ptr.thread_type = value
+        elif type(value) is str:
+            self.ptr.thread_type = ThreadType[value].value
+        else:
+            self.ptr.thread_type = value.value
+
+    @property
+    def skip_frame(self):
+        """Returns one of the following str literals:
+
+        "NONE" Discard nothing
+        "DEFAULT" Discard useless packets like 0 size packets in AVI
+        "NONREF" Discard all non reference
+        "BIDIR" Discard all bidirectional frames
+        "NONINTRA" Discard all non intra frames
+        "NONKEY Discard all frames except keyframes
+        "ALL" Discard all
+
+        Wraps :ffmpeg:`AVCodecContext.skip_frame`.
+        """
+        value = self.ptr.skip_frame
+        if value == lib.AVDISCARD_NONE:
+            return "NONE"
+        if value == lib.AVDISCARD_DEFAULT:
+            return "DEFAULT"
+        if value == lib.AVDISCARD_NONREF:
+            return "NONREF"
+        if value == lib.AVDISCARD_BIDIR:
+            return "BIDIR"
+        if value == lib.AVDISCARD_NONINTRA:
+            return "NONINTRA"
+        if value == lib.AVDISCARD_NONKEY:
+            return "NONKEY"
+        if value == lib.AVDISCARD_ALL:
+            return "ALL"
+        return f"{value}"
+
+    @skip_frame.setter
+    def skip_frame(self, value):
+        if value == "NONE":
+            self.ptr.skip_frame = lib.AVDISCARD_NONE
+        elif value == "DEFAULT":
+            self.ptr.skip_frame = lib.AVDISCARD_DEFAULT
+        elif value == "NONREF":
+            self.ptr.skip_frame = lib.AVDISCARD_NONREF
+        elif value == "BIDIR":
+            self.ptr.skip_frame = lib.AVDISCARD_BIDIR
+        elif value == "NONINTRA":
+            self.ptr.skip_frame = lib.AVDISCARD_NONINTRA
+        elif value == "NONKEY":
+            self.ptr.skip_frame = lib.AVDISCARD_NONKEY
+        elif value == "ALL":
+            self.ptr.skip_frame = lib.AVDISCARD_ALL
+        else:
+            raise ValueError("Invalid skip_frame type")
+
+    @property
+    def delay(self):
+        """Codec delay.
+
+        Wraps :ffmpeg:`AVCodecContext.delay`.
+
+        """
+        return self.ptr.delay

lib/python3.10/site-packages/av/codec/hwaccel.pyx

@@ -0,0 +1,156 @@
+import weakref
+from enum import IntEnum
+
+cimport libav as lib
+
+from av.codec.codec cimport Codec
+from av.dictionary cimport _Dictionary
+from av.error cimport err_check
+from av.video.format cimport get_video_format
+
+from av.dictionary import Dictionary
+
+
+class HWDeviceType(IntEnum):
+    none = lib.AV_HWDEVICE_TYPE_NONE
+    vdpau = lib.AV_HWDEVICE_TYPE_VDPAU
+    cuda = lib.AV_HWDEVICE_TYPE_CUDA
+    vaapi = lib.AV_HWDEVICE_TYPE_VAAPI
+    dxva2 = lib.AV_HWDEVICE_TYPE_DXVA2
+    qsv = lib.AV_HWDEVICE_TYPE_QSV
+    videotoolbox = lib.AV_HWDEVICE_TYPE_VIDEOTOOLBOX
+    d3d11va = lib.AV_HWDEVICE_TYPE_D3D11VA
+    drm = lib.AV_HWDEVICE_TYPE_DRM
+    opencl = lib.AV_HWDEVICE_TYPE_OPENCL
+    mediacodec = lib.AV_HWDEVICE_TYPE_MEDIACODEC
+    vulkan = lib.AV_HWDEVICE_TYPE_VULKAN
+    d3d12va = lib.AV_HWDEVICE_TYPE_D3D12VA
+
+class HWConfigMethod(IntEnum):
+    none = 0
+    hw_device_ctx = lib.AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX  # This is the only one we support.
+    hw_frame_ctx = lib.AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX
+    internal = lib.AV_CODEC_HW_CONFIG_METHOD_INTERNAL
+    ad_hoc = lib.AV_CODEC_HW_CONFIG_METHOD_AD_HOC
+
+
+cdef object _cinit_sentinel = object()
+cdef object _singletons = weakref.WeakValueDictionary()
+
+cdef HWConfig wrap_hwconfig(lib.AVCodecHWConfig *ptr):
+    try:
+        return _singletons[<int>ptr]
+    except KeyError:
+        pass
+    cdef HWConfig config = HWConfig(_cinit_sentinel)
+    config._init(ptr)
+    _singletons[<int>ptr] = config
+    return config
+
+
+cdef class HWConfig:
+    def __init__(self, sentinel):
+        if sentinel is not _cinit_sentinel:
+            raise RuntimeError("Cannot instantiate CodecContext")
+
+    cdef void _init(self, lib.AVCodecHWConfig *ptr):
+        self.ptr = ptr
+
+    def __repr__(self):
+        return (
+            f"<av.{self.__class__.__name__} "
+            f"device_type={lib.av_hwdevice_get_type_name(self.device_type)} "
+            f"format={self.format.name if self.format else None} "
+            f"is_supported={self.is_supported} at 0x{<int>self.ptr:x}>"
+        )
+
+    @property
+    def device_type(self):
+        return HWDeviceType(self.ptr.device_type)
+
+    @property
+    def format(self):
+        return get_video_format(self.ptr.pix_fmt, 0, 0)
+
+    @property
+    def methods(self):
+        return HWConfigMethod(self.ptr.methods)
+
+    @property
+    def is_supported(self):
+        return bool(self.ptr.methods & lib.AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX)
+
+
+cpdef hwdevices_available():
+    result = []
+
+    cdef lib.AVHWDeviceType x = lib.AV_HWDEVICE_TYPE_NONE
+    while True:
+        x = lib.av_hwdevice_iterate_types(x)
+        if x == lib.AV_HWDEVICE_TYPE_NONE:
+            break
+        result.append(lib.av_hwdevice_get_type_name(HWDeviceType(x)))
+
+    return result
+
+
+cdef class HWAccel:
+    def __init__(self, device_type, device=None, allow_software_fallback=True, options=None, flags=None):
+        if isinstance(device_type, HWDeviceType):
+            self._device_type = device_type
+        elif isinstance(device_type, str):
+            self._device_type = int(lib.av_hwdevice_find_type_by_name(device_type))
+        elif isinstance(device_type, int):
+            self._device_type = device_type
+        else:
+            raise ValueError("Unknown type for device_type")
+
+        self._device = device
+        self.allow_software_fallback = allow_software_fallback
+        self.options = {} if not options else dict(options)
+        self.flags = 0 if not flags else flags
+        self.ptr = NULL
+        self.config = None
+
+    def _initialize_hw_context(self, Codec codec not None):
+        cdef HWConfig config
+        for config in codec.hardware_configs:
+            if not (config.ptr.methods & lib.AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX):
+                continue
+            if self._device_type and config.device_type != self._device_type:
+                continue
+            break
+        else:
+            raise NotImplementedError(f"No supported hardware config for {codec}")
+
+        self.config = config
+
+        cdef char *c_device = NULL
+        if self._device:
+            device_bytes = self._device.encode()
+            c_device = device_bytes
+        cdef _Dictionary c_options = Dictionary(self.options)
+
+        err_check(
+            lib.av_hwdevice_ctx_create(
+                &self.ptr, config.ptr.device_type, c_device, c_options.ptr, self.flags
+            )
+        )
+
+    def create(self, Codec codec not None):
+        """Create a new hardware accelerator context with the given codec"""
+        if self.ptr:
+            raise RuntimeError("Hardware context already initialized")
+
+        ret = HWAccel(
+            device_type=self._device_type,
+            device=self._device,
+            allow_software_fallback=self.allow_software_fallback,
+            options=self.options
+        )
+        ret._initialize_hw_context(codec)
+        return ret
+
+    def __dealloc__(self):
+        if self.ptr:
+            lib.av_buffer_unref(&self.ptr)

lib/python3.10/site-packages/av/filter/__init__.py

@@ -0,0 +1,3 @@
+from .filter import Filter, FilterFlags, filter_descriptor, filters_available
+from .graph import Graph
+from .loudnorm import stats

lib/python3.10/site-packages/av/filter/__init__.pyi

@@ -0,0 +1,4 @@
+from .context import *
+from .filter import *
+from .graph import *
+from .loudnorm import *

lib/python3.10/site-packages/av/filter/context.pyi

@@ -0,0 +1,18 @@
+from av.filter import Graph
+from av.frame import Frame
+
+from .pad import FilterContextPad
+
+class FilterContext:
+    name: str | None
+    inputs: tuple[FilterContextPad, ...]
+    outputs: tuple[FilterContextPad, ...]
+
+    def init(self, args: str | None = None, **kwargs: str | None) -> None: ...
+    def link_to(
+        self, input_: FilterContext, output_idx: int = 0, input_idx: int = 0
+    ) -> None: ...
+    @property
+    def graph(self) -> Graph: ...
+    def push(self, frame: Frame) -> None: ...
+    def pull(self) -> Frame: ...

lib/python3.10/site-packages/av/filter/context.pyx

@@ -0,0 +1,134 @@
+import weakref
+
+from av.audio.frame cimport alloc_audio_frame
+from av.dictionary cimport _Dictionary
+from av.dictionary import Dictionary
+from av.error cimport err_check
+from av.filter.pad cimport alloc_filter_pads
+from av.frame cimport Frame
+from av.utils cimport avrational_to_fraction
+from av.video.frame cimport alloc_video_frame
+
+
+cdef object _cinit_sentinel = object()
+
+
+cdef FilterContext wrap_filter_context(Graph graph, Filter filter, lib.AVFilterContext *ptr):
+    cdef FilterContext self = FilterContext(_cinit_sentinel)
+    self._graph = weakref.ref(graph)
+    self.filter = filter
+    self.ptr = ptr
+    return self
+
+
+cdef class FilterContext:
+    def __cinit__(self, sentinel):
+        if sentinel is not _cinit_sentinel:
+            raise RuntimeError("cannot construct FilterContext")
+
+    def __repr__(self):
+        if self.ptr != NULL:
+            name = repr(self.ptr.name) if self.ptr.name != NULL else "<NULL>"
+        else:
+            name = "None"
+
+        parent = self.filter.ptr.name if self.filter and self.filter.ptr != NULL else None
+        return f"<av.FilterContext {name} of {parent!r} at 0x{id(self):x}>"
+
+    @property
+    def name(self):
+        if self.ptr.name != NULL:
+            return self.ptr.name
+
+    @property
+    def inputs(self):
+        if self._inputs is None:
+            self._inputs = alloc_filter_pads(self.filter, self.ptr.input_pads, True, self)
+        return self._inputs
+
+    @property
+    def outputs(self):
+        if self._outputs is None:
+            self._outputs = alloc_filter_pads(self.filter, self.ptr.output_pads, False, self)
+        return self._outputs
+
+    def init(self, args=None, **kwargs):
+        if self.inited:
+            raise ValueError("already inited")
+        if args and kwargs:
+            raise ValueError("cannot init from args and kwargs")
+
+        cdef _Dictionary dict_ = None
+        cdef char *c_args = NULL
+        if args or not kwargs:
+            if args:
+                c_args = args
+            err_check(lib.avfilter_init_str(self.ptr, c_args))
+        else:
+            dict_ = Dictionary(kwargs)
+            err_check(lib.avfilter_init_dict(self.ptr, &dict_.ptr))
+
+        self.inited = True
+        if dict_:
+            raise ValueError(f"unused config: {', '.join(sorted(dict_))}")
+
+    def link_to(self, FilterContext input_, int output_idx=0, int input_idx=0):
+        err_check(lib.avfilter_link(self.ptr, output_idx, input_.ptr, input_idx))
+    
+    @property
+    def graph(self):
+        if (graph := self._graph()):
+            return graph
+        else:
+            raise RuntimeError("graph is unallocated")
+
+    def push(self, Frame frame):
+        cdef int res
+
+        if frame is None:
+            with nogil:
+                res = lib.av_buffersrc_write_frame(self.ptr, NULL)
+            err_check(res)
+            return
+        elif self.filter.name in ("abuffer", "buffer"):
+            with nogil:
+                res = lib.av_buffersrc_write_frame(self.ptr, frame.ptr)
+            err_check(res)
+            return
+
+        # Delegate to the input.
+        if len(self.inputs) != 1:
+            raise ValueError(
+                f"cannot delegate push without single input; found {len(self.inputs)}"
+            )
+        if not self.inputs[0].link:
+            raise ValueError("cannot delegate push without linked input")
+        self.inputs[0].linked.context.push(frame)
+
+    def pull(self):
+        cdef Frame frame
+        cdef int res
+
+        if self.filter.name == "buffersink":
+            frame = alloc_video_frame()
+        elif self.filter.name == "abuffersink":
+            frame = alloc_audio_frame()
+        else:
+            # Delegate to the output.
+            if len(self.outputs) != 1:
+                raise ValueError(
+                    f"cannot delegate pull without single output; found {len(self.outputs)}"
+                )
+            if not self.outputs[0].link:
+                raise ValueError("cannot delegate pull without linked output")
+            return self.outputs[0].linked.context.pull()
+
+        self.graph.configure()
+
+        with nogil:
+            res = lib.av_buffersink_get_frame(self.ptr, frame.ptr)
+        err_check(res)
+
+        frame._init_user_attributes()
+        frame.time_base = avrational_to_fraction(&self.ptr.inputs[0].time_base)
+        return frame

lib/python3.10/site-packages/av/filter/filter.pxd

@@ -0,0 +1,15 @@
+cimport libav as lib
+
+from av.descriptor cimport Descriptor
+
+
+cdef class Filter:
+
+    cdef const lib.AVFilter *ptr
+
+    cdef object _inputs
+    cdef object _outputs
+    cdef Descriptor _descriptor
+
+
+cdef Filter wrap_filter(const lib.AVFilter *ptr)

lib/python3.10/site-packages/av/filter/filter.pyi

@@ -0,0 +1,23 @@
+from av.descriptor import Descriptor
+from av.option import Option
+
+from .pad import FilterPad
+
+class Filter:
+    name: str
+    description: str
+
+    descriptor: Descriptor
+    options: tuple[Option, ...] | None
+    flags: int
+    dynamic_inputs: bool
+    dynamic_outputs: bool
+    timeline_support: bool
+    slice_threads: bool
+    command_support: bool
+    inputs: tuple[FilterPad, ...]
+    outputs: tuple[FilterPad, ...]
+
+    def __init__(self, name: str) -> None: ...
+
+filters_available: set[str]

lib/python3.10/site-packages/av/filter/filter.pyx

@@ -0,0 +1,106 @@
+cimport libav as lib
+
+from av.descriptor cimport wrap_avclass
+from av.filter.pad cimport alloc_filter_pads
+
+
+cdef object _cinit_sentinel = object()
+
+
+cdef Filter wrap_filter(const lib.AVFilter *ptr):
+    cdef Filter filter_ = Filter(_cinit_sentinel)
+    filter_.ptr = ptr
+    return filter_
+
+
+cpdef enum FilterFlags:
+    DYNAMIC_INPUTS = lib.AVFILTER_FLAG_DYNAMIC_INPUTS
+    DYNAMIC_OUTPUTS = lib.AVFILTER_FLAG_DYNAMIC_OUTPUTS
+    SLICE_THREADS = lib.AVFILTER_FLAG_SLICE_THREADS
+    SUPPORT_TIMELINE_GENERIC = lib.AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
+    SUPPORT_TIMELINE_INTERNAL = lib.AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL
+
+
+cdef class Filter:
+    def __cinit__(self, name):
+        if name is _cinit_sentinel:
+            return
+        if not isinstance(name, str):
+            raise TypeError("takes a filter name as a string")
+        self.ptr = lib.avfilter_get_by_name(name)
+        if not self.ptr:
+            raise ValueError(f"no filter {name}")
+
+    @property
+    def descriptor(self):
+        if self._descriptor is None:
+            self._descriptor = wrap_avclass(self.ptr.priv_class)
+        return self._descriptor
+
+    @property
+    def options(self):
+        if self.descriptor is None:
+            return
+        return self.descriptor.options
+
+    @property
+    def name(self):
+        return self.ptr.name
+
+    @property
+    def description(self):
+        return self.ptr.description
+
+    @property
+    def flags(self):
+        return self.ptr.flags
+
+    @property
+    def dynamic_inputs(self):
+        return bool(self.ptr.flags & lib.AVFILTER_FLAG_DYNAMIC_INPUTS)
+
+    @property
+    def dynamic_outputs(self):
+        return bool(self.ptr.flags & lib.AVFILTER_FLAG_DYNAMIC_OUTPUTS)
+
+    @property
+    def timeline_support(self):
+        return bool(self.ptr.flags & lib.AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC)
+
+    @property
+    def slice_threads(self):
+        return bool(self.ptr.flags & lib.AVFILTER_FLAG_SLICE_THREADS)
+
+    @property
+    def command_support(self):
+        return self.ptr.process_command != NULL
+
+    @property
+    def inputs(self):
+        if self._inputs is None:
+            self._inputs = alloc_filter_pads(self, self.ptr.inputs, True)
+        return self._inputs
+
+    @property
+    def outputs(self):
+        if self._outputs is None:
+            self._outputs = alloc_filter_pads(self, self.ptr.outputs, False)
+        return self._outputs
+
+
+cdef get_filter_names():
+    names = set()
+    cdef const lib.AVFilter *ptr
+    cdef void *opaque = NULL
+    while True:
+        ptr = lib.av_filter_iterate(&opaque)
+        if ptr:
+            names.add(ptr.name)
+        else:
+            break
+    return names
+
+filters_available = get_filter_names()
+
+
+filter_descriptor = wrap_avclass(lib.avfilter_get_class())

lib/python3.10/site-packages/av/filter/graph.pxd

@@ -0,0 +1,22 @@
+cimport libav as lib
+
+from av.filter.context cimport FilterContext
+
+
+cdef class Graph:
+    cdef object __weakref__
+
+    cdef lib.AVFilterGraph *ptr
+
+    cdef readonly bint configured
+    cpdef configure(self, bint auto_buffer=*, bint force=*)
+
+    cdef dict _name_counts
+    cdef str _get_unique_name(self, str name)
+
+    cdef _register_context(self, FilterContext)
+    cdef _auto_register(self)
+    cdef int _nb_filters_seen
+    cdef dict _context_by_ptr
+    cdef dict _context_by_name
+    cdef dict _context_by_type

lib/python3.10/site-packages/av/filter/graph.pyi

@@ -0,0 +1,47 @@
+from fractions import Fraction
+from typing import Any
+
+from av.audio.format import AudioFormat
+from av.audio.frame import AudioFrame
+from av.audio.layout import AudioLayout
+from av.audio.stream import AudioStream
+from av.video.format import VideoFormat
+from av.video.frame import VideoFrame
+from av.video.stream import VideoStream
+
+from .context import FilterContext
+from .filter import Filter
+
+class Graph:
+    configured: bool
+
+    def __init__(self) -> None: ...
+    def configure(self, auto_buffer: bool = True, force: bool = False) -> None: ...
+    def link_nodes(self, *nodes: FilterContext) -> Graph: ...
+    def add(
+        self, filter: str | Filter, args: Any = None, **kwargs: str
+    ) -> FilterContext: ...
+    def add_buffer(
+        self,
+        template: VideoStream | None = None,
+        width: int | None = None,
+        height: int | None = None,
+        format: VideoFormat | None = None,
+        name: str | None = None,
+        time_base: Fraction | None = None,
+    ) -> FilterContext: ...
+    def add_abuffer(
+        self,
+        template: AudioStream | None = None,
+        sample_rate: int | None = None,
+        format: AudioFormat | str | None = None,
+        layout: AudioLayout | str | None = None,
+        channels: int | None = None,
+        name: str | None = None,
+        time_base: Fraction | None = None,
+    ) -> FilterContext: ...
+    def set_audio_frame_size(self, frame_size: int) -> None: ...
+    def push(self, frame: None | AudioFrame | VideoFrame) -> None: ...
+    def pull(self) -> VideoFrame | AudioFrame: ...
+    def vpush(self, frame: VideoFrame | None) -> None: ...
+    def vpull(self) -> VideoFrame: ...

lib/python3.10/site-packages/av/filter/graph.pyx

@@ -0,0 +1,224 @@
+import warnings
+from fractions import Fraction
+
+from av.audio.format cimport AudioFormat
+from av.audio.frame cimport AudioFrame
+from av.audio.layout cimport AudioLayout
+from av.error cimport err_check
+from av.filter.context cimport FilterContext, wrap_filter_context
+from av.filter.filter cimport Filter, wrap_filter
+from av.video.format cimport VideoFormat
+from av.video.frame cimport VideoFrame
+
+
+cdef class Graph:
+    def __cinit__(self):
+        self.ptr = lib.avfilter_graph_alloc()
+        self.configured = False
+        self._name_counts = {}
+
+        self._nb_filters_seen = 0
+        self._context_by_ptr = {}
+        self._context_by_name = {}
+        self._context_by_type = {}
+
+    def __dealloc__(self):
+        if self.ptr:
+            # This frees the graph, filter contexts, links, etc..
+            lib.avfilter_graph_free(&self.ptr)
+
+    cdef str _get_unique_name(self, str name):
+        count = self._name_counts.get(name, 0)
+        self._name_counts[name] = count + 1
+        if count:
+            return "%s_%s" % (name, count)
+        else:
+            return name
+
+    cpdef configure(self, bint auto_buffer=True, bint force=False):
+        if self.configured and not force:
+            return
+
+        err_check(lib.avfilter_graph_config(self.ptr, NULL))
+        self.configured = True
+
+        # We get auto-inserted stuff here.
+        self._auto_register()
+
+    def link_nodes(self, *nodes):
+        """
+        Links nodes together for simple filter graphs.
+        """
+        for c, n in zip(nodes, nodes[1:]):
+            c.link_to(n)
+        return self
+
+    def add(self, filter, args=None, **kwargs):
+        cdef Filter cy_filter
+        if isinstance(filter, str):
+            cy_filter = Filter(filter)
+        elif isinstance(filter, Filter):
+            cy_filter = filter
+        else:
+            raise TypeError("filter must be a string or Filter")
+
+        cdef str name = self._get_unique_name(kwargs.pop("name", None) or cy_filter.name)
+
+        cdef lib.AVFilterContext *ptr = lib.avfilter_graph_alloc_filter(self.ptr, cy_filter.ptr, name)
+        if not ptr:
+            raise RuntimeError("Could not allocate AVFilterContext")
+
+        # Manually construct this context (so we can return it).
+        cdef FilterContext ctx = wrap_filter_context(self, cy_filter, ptr)
+        ctx.init(args, **kwargs)
+        self._register_context(ctx)
+
+        # There might have been automatic contexts added (e.g. resamplers,
+        # fifos, and scalers). It is more likely to see them after the graph
+        # is configured, but we want to be safe.
+        self._auto_register()
+
+        return ctx
+
+    cdef _register_context(self, FilterContext ctx):
+        self._context_by_ptr[<long>ctx.ptr] = ctx
+        self._context_by_name[ctx.ptr.name] = ctx
+        self._context_by_type.setdefault(ctx.filter.ptr.name, []).append(ctx)
+
+    cdef _auto_register(self):
+        cdef int i
+        cdef lib.AVFilterContext *c_ctx
+        cdef Filter filter_
+        cdef FilterContext py_ctx
+        # We assume that filters are never removed from the graph. At this
+        # point we don't expose that in the API, so we should be okay...
+        for i in range(self._nb_filters_seen, self.ptr.nb_filters):
+            c_ctx = self.ptr.filters[i]
+            if <long>c_ctx in self._context_by_ptr:
+                continue
+            filter_ = wrap_filter(c_ctx.filter)
+            py_ctx = wrap_filter_context(self, filter_, c_ctx)
+            self._register_context(py_ctx)
+        self._nb_filters_seen = self.ptr.nb_filters
+
+    def add_buffer(self, template=None, width=None, height=None, format=None, name=None, time_base=None):
+        if template is not None:
+            if width is None:
+                width = template.width
+            if height is None:
+                height = template.height
+            if format is None:
+                format = template.format
+            if time_base is None:
+                time_base = template.time_base
+
+        if width is None:
+            raise ValueError("missing width")
+        if height is None:
+            raise ValueError("missing height")
+        if format is None:
+            raise ValueError("missing format")
+        if time_base is None:
+            warnings.warn("missing time_base. Guessing 1/1000 time base. "
+                          "This is deprecated and may be removed in future releases.",
+                          DeprecationWarning)
+            time_base = Fraction(1, 1000)
+
+        return self.add(
+            "buffer",
+            name=name,
+            video_size=f"{width}x{height}",
+            pix_fmt=str(int(VideoFormat(format))),
+            time_base=str(time_base),
+            pixel_aspect="1/1",
+        )
+
+    def add_abuffer(self, template=None, sample_rate=None, format=None, layout=None, channels=None, name=None, time_base=None):
+        """
+        Convenience method for adding `abuffer <https://ffmpeg.org/ffmpeg-filters.html#abuffer>`_.
+        """
+
+        if template is not None:
+            if sample_rate is None:
+                sample_rate = template.sample_rate
+            if format is None:
+                format = template.format
+            if layout is None:
+                layout = template.layout.name
+            if channels is None:
+                channels = template.channels
+            if time_base is None:
+                time_base = template.time_base
+
+        if sample_rate is None:
+            raise ValueError("missing sample_rate")
+        if format is None:
+            raise ValueError("missing format")
+        if layout is None and channels is None:
+            raise ValueError("missing layout or channels")
+        if time_base is None:
+            time_base = Fraction(1, sample_rate)
+
+        kwargs = dict(
+            sample_rate=str(sample_rate),
+            sample_fmt=AudioFormat(format).name,
+            time_base=str(time_base),
+        )
+        if layout:
+            kwargs["channel_layout"] = AudioLayout(layout).name
+        if channels:
+            kwargs["channels"] = str(channels)
+
+        return self.add("abuffer", name=name, **kwargs)
+
+    def set_audio_frame_size(self, frame_size):
+        """
+        Set the audio frame size for the graphs `abuffersink`.
+        See `av_buffersink_set_frame_size <https://ffmpeg.org/doxygen/trunk/group__lavfi__buffersink.html#ga359d7d1e42c27ca14c07559d4e9adba7>`_.
+        """
+        if not self.configured:
+            raise ValueError("graph not configured")
+        sinks = self._context_by_type.get("abuffersink", [])
+        if not sinks:
+            raise ValueError("missing abuffersink filter")
+        for sink in sinks:
+            lib.av_buffersink_set_frame_size((<FilterContext>sink).ptr, frame_size)
+
+    def push(self, frame):
+        if frame is None:
+            contexts = self._context_by_type.get("buffer", []) + self._context_by_type.get("abuffer", [])
+        elif isinstance(frame, VideoFrame):
+            contexts = self._context_by_type.get("buffer", [])
+        elif isinstance(frame, AudioFrame):
+            contexts = self._context_by_type.get("abuffer", [])
+        else:
+            raise ValueError(f"can only AudioFrame, VideoFrame or None; got {type(frame)}")
+
+        for ctx in contexts:
+            ctx.push(frame)
+
+    def vpush(self, VideoFrame frame):
+        """Like `push`, but only for VideoFrames."""
+        for ctx in self._context_by_type.get("buffer", []):
+            ctx.push(frame)
+
+
+    # TODO: Test complex filter graphs, add `at: int = 0` arg to pull() and vpull().
+    def pull(self):
+        vsinks = self._context_by_type.get("buffersink", [])
+        asinks = self._context_by_type.get("abuffersink", [])
+
+        nsinks = len(vsinks) + len(asinks)
+        if nsinks != 1:
+            raise ValueError(f"can only auto-pull with single sink; found {nsinks}")
+
+        return (vsinks or asinks)[0].pull()
+
+    def vpull(self):
+        """Like `pull`, but only for VideoFrames."""
+        vsinks = self._context_by_type.get("buffersink", [])
+        nsinks = len(vsinks)
+        if nsinks != 1:
+            raise ValueError(f"can only auto-pull with single sink; found {nsinks}")
+
+        return vsinks[0].pull()

lib/python3.10/site-packages/av/filter/link.pxd

@@ -0,0 +1,16 @@
+cimport libav as lib
+
+from av.filter.graph cimport Graph
+from av.filter.pad cimport FilterContextPad
+
+
+cdef class FilterLink:
+
+    cdef readonly Graph graph
+    cdef lib.AVFilterLink *ptr
+
+    cdef FilterContextPad _input
+    cdef FilterContextPad _output
+
+
+cdef FilterLink wrap_filter_link(Graph graph, lib.AVFilterLink *ptr)

lib/python3.10/site-packages/av/filter/link.pyi

@@ -0,0 +1,5 @@
+from .pad import FilterContextPad
+
+class FilterLink:
+    input: FilterContextPad
+    output: FilterContextPad

lib/python3.10/site-packages/av/filter/link.pyx

@@ -0,0 +1,53 @@
+cimport libav as lib
+
+from av.filter.graph cimport Graph
+
+
+cdef _cinit_sentinel = object()
+
+
+cdef class FilterLink:
+
+    def __cinit__(self, sentinel):
+        if sentinel is not _cinit_sentinel:
+            raise RuntimeError("cannot instantiate FilterLink")
+
+    @property
+    def input(self):
+        if self._input:
+            return self._input
+        cdef lib.AVFilterContext *cctx = self.ptr.src
+        cdef unsigned int i
+        for i in range(cctx.nb_outputs):
+            if self.ptr == cctx.outputs[i]:
+                break
+        else:
+            raise RuntimeError("could not find link in context")
+        ctx = self.graph._context_by_ptr[<long>cctx]
+        self._input = ctx.outputs[i]
+        return self._input
+
+    @property
+    def output(self):
+        if self._output:
+            return self._output
+        cdef lib.AVFilterContext *cctx = self.ptr.dst
+        cdef unsigned int i
+        for i in range(cctx.nb_inputs):
+            if self.ptr == cctx.inputs[i]:
+                break
+        else:
+            raise RuntimeError("could not find link in context")
+        try:
+            ctx = self.graph._context_by_ptr[<long>cctx]
+        except KeyError:
+            raise RuntimeError("could not find context in graph", (cctx.name, cctx.filter.name))
+        self._output = ctx.inputs[i]
+        return self._output
+
+
+cdef FilterLink wrap_filter_link(Graph graph, lib.AVFilterLink *ptr):
+    cdef FilterLink link = FilterLink(_cinit_sentinel)
+    link.graph = graph
+    link.ptr = ptr
+    return link

lib/python3.10/site-packages/av/filter/loudnorm.pxd

@@ -0,0 +1,4 @@
+from av.audio.stream cimport AudioStream
+
+
+cpdef bytes stats(str loudnorm_args, AudioStream stream)