Upload folder using huggingface_hub (part 4)

.gitattributes

@@ -106,3 +106,12 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 .venvs/kimodo/lib/python3.10/site-packages/av/sidedata/motionvectors.cpython-310-darwin.so filter=lfs diff=lfs merge=lfs -text
 .venvs/kimodo/lib/python3.10/site-packages/av/sidedata/sidedata.cpython-310-darwin.so filter=lfs diff=lfs merge=lfs -text
 .venvs/kimodo/lib/python3.10/site-packages/av/stream.cpython-310-darwin.so filter=lfs diff=lfs merge=lfs -text
+.venvs/kimodo/lib/python3.10/site-packages/av/subtitles/codeccontext.cpython-310-darwin.so filter=lfs diff=lfs merge=lfs -text
+.venvs/kimodo/lib/python3.10/site-packages/av/subtitles/subtitle.cpython-310-darwin.so filter=lfs diff=lfs merge=lfs -text
+.venvs/kimodo/lib/python3.10/site-packages/av/video/codeccontext.cpython-310-darwin.so filter=lfs diff=lfs merge=lfs -text
+.venvs/kimodo/lib/python3.10/site-packages/av/video/format.cpython-310-darwin.so filter=lfs diff=lfs merge=lfs -text
+.venvs/kimodo/lib/python3.10/site-packages/av/video/frame.cpython-310-darwin.so filter=lfs diff=lfs merge=lfs -text
+.venvs/kimodo/lib/python3.10/site-packages/av/video/plane.cpython-310-darwin.so filter=lfs diff=lfs merge=lfs -text
+.venvs/kimodo/lib/python3.10/site-packages/av/video/reformatter.cpython-310-darwin.so filter=lfs diff=lfs merge=lfs -text
+.venvs/kimodo/lib/python3.10/site-packages/av/video/stream.cpython-310-darwin.so filter=lfs diff=lfs merge=lfs -text
+.venvs/kimodo/lib/python3.10/site-packages/botocore/__pycache__/utils.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text

.venvs/kimodo/lib/python3.10/site-packages/av-17.1.0.dist-info/INSTALLER

@@ -0,0 +1 @@
+uv

.venvs/kimodo/lib/python3.10/site-packages/av-17.1.0.dist-info/METADATA

@@ -0,0 +1,127 @@
+Metadata-Version: 2.4
+Name: av
+Version: 17.1.0
+Summary: Pythonic bindings for FFmpeg's libraries.
+Author-email: WyattBlue <wyattblue@auto-editor.com>, Jeremy Lainé <jeremy.laine@m4x.org>
+License-Expression: BSD-3-Clause
+Project-URL: Bug Tracker, https://github.com/PyAV-Org/PyAV/issues
+Project-URL: Source Code, https://github.com/PyAV-Org/PyAV
+Project-URL: homepage, https://pyav.basswood-io.com
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Unix
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Cython
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Multimedia :: Sound/Audio
+Classifier: Topic :: Multimedia :: Sound/Audio :: Conversion
+Classifier: Topic :: Multimedia :: Video
+Classifier: Topic :: Multimedia :: Video :: Conversion
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+License-File: AUTHORS.py
+License-File: AUTHORS.rst
+Dynamic: license-file
+
+PyAV
+====
+
+PyAV is a Pythonic binding for the [FFmpeg][ffmpeg] libraries. We aim to provide all of the power and control of the underlying library, but manage the gritty details as much as possible.
+
+---
+
+[![GitHub Test Status][github-tests-badge]][github-tests] [![Documentation][docs-badge]][docs] [![Python Package Index][pypi-badge]][pypi] [![Conda Forge][conda-badge]][conda]
+
+PyAV is for direct and precise access to your media via containers, streams, packets, codecs, and frames. It exposes a few transformations of that data, and helps you get your data to/from other packages (e.g. Numpy and Pillow).
+
+This power does come with some responsibility as working with media is horrendously complicated and PyAV can't abstract it away or make all the best decisions for you. If the `ffmpeg` command does the job without you bending over backwards, PyAV is likely going to be more of a hindrance than a help.
+
+But where you can't work without it, PyAV is a critical tool.
+
+
+Installation
+------------
+
+Binary wheels are provided on [PyPI][pypi] for Linux, MacOS and Windows linked against the latest stable version of ffmpeg. You can install these wheels by running:
+
+```bash
+pip install av
+```
+
+Another way of installing PyAV is via [conda-forge][conda-forge]:
+
+```bash
+conda install av -c conda-forge
+```
+
+See the [Conda install][conda-install] docs to get started with (mini)Conda.
+
+
+Alternative installation methods
+--------------------------------
+
+Due to the complexity of the dependencies, PyAV is not always the easiest Python package to install from source. If you want to use your existing ffmpeg (must be the correct major version), the source version of PyAV is on [PyPI][pypi]:
+
+> [!WARNING]
+> You must be in a posix env, and have the correct version of ffmpeg installed on your system.
+
+```bash
+pip install av --no-binary av
+```
+
+
+Installing From Source
+----------------------
+
+Here's how to build PyAV from source. You must use [MSYS2](https://www.msys2.org/) when using Windows.
+
+```bash
+git clone https://github.com/PyAV-Org/PyAV.git
+cd PyAV
+source scripts/activate.sh
+
+# Build ffmpeg from source. You can skip this step
+# if ffmpeg is already installed.
+./scripts/build-deps
+
+# Build PyAV
+make
+
+# Testing
+make test
+
+# Install globally
+deactivate
+pip install .
+```
+
+---
+
+Have fun, [read the docs][docs], [come chat with us][discuss], and good luck!
+
+
+
+[conda-badge]: https://img.shields.io/conda/vn/conda-forge/av.svg?colorB=CCB39A
+[conda]: https://anaconda.org/conda-forge/av
+[docs-badge]: https://img.shields.io/badge/docs-on%20pyav.basswood--io.com-blue.svg
+[docs]: https://pyav.basswood-io.com
+[pypi-badge]: https://img.shields.io/pypi/v/av.svg?colorB=CCB39A
+[pypi]: https://pypi.org/project/av
+[discuss]: https://github.com/PyAV-Org/PyAV/discussions
+
+[github-tests-badge]: https://github.com/PyAV-Org/PyAV/workflows/tests/badge.svg
+[github-tests]: https://github.com/PyAV-Org/PyAV/actions?workflow=tests
+[github]: https://github.com/PyAV-Org/PyAV
+
+[ffmpeg]: https://ffmpeg.org/
+[conda-forge]: https://conda-forge.github.io/
+[conda-install]: https://docs.conda.io/projects/conda/en/latest/user-guide/install/index.html

.venvs/kimodo/lib/python3.10/site-packages/av-17.1.0.dist-info/RECORD

@@ -0,0 +1,244 @@
+../../../bin/pyav,sha256=cELpQkXIcZFyrpocYv7ltcCyWc94_s-_vkLMxGOUpCY,358
+av-17.1.0.dist-info/INSTALLER,sha256=5hhM4Q4mYTT9z6QB6PGpUAW81PGNFrYrdXMj4oM_6ak,2
+av-17.1.0.dist-info/METADATA,sha256=icLfisEQuey0LC6JWPu26d3P56lMXX3MJ3dfQ8dCxBA,4597
+av-17.1.0.dist-info/RECORD,,
+av-17.1.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+av-17.1.0.dist-info/WHEEL,sha256=GMlGfk9_-EKG_D0ClpCsWj7ncE2uKUvKdCS--Fq7w1Q,136
+av-17.1.0.dist-info/entry_points.txt,sha256=3XMdM30ih673nLSRVzDsHLBmGYNlt7wQ1xyW8xoHAzg,42
+av-17.1.0.dist-info/licenses/AUTHORS.py,sha256=Tsbg3KPQcDrr77OG0-tu0UoF2W_osKoItSwtKVGBf-w,5558
+av-17.1.0.dist-info/licenses/AUTHORS.rst,sha256=rbOps1qLdLtZcybex3XXSp95tN7KxU2iZqndsgtdoUI,5996
+av-17.1.0.dist-info/licenses/LICENSE.txt,sha256=dq8EYf-5LhnxwURJ6VVX2Dot-qG68gLUnl8dh0bA2hk,1505
+av-17.1.0.dist-info/top_level.txt,sha256=TuQF-stvFHN8ilfr36ctqc7_MR5IOhUqrR0i6i5gNR8,3
+av/.dylibs/libSvtAv1Enc.4.1.0.dylib,sha256=03_ynPMqGaSmMPeJ0c4BfB3LRhOsNSNZZEWXytArJlM,3794416
+av/.dylibs/libavcodec.62.28.101.dylib,sha256=uiuyGtMvKW8fWrYmRtH5tSmQbQt9ok_fBpC4d5GQLN8,12895552
+av/.dylibs/libavdevice.62.3.101.dylib,sha256=k5nEzJxW_6xzAYFIIe5TbHesWnXHElsGj4ClwpiMgxE,117504
+av/.dylibs/libavfilter.11.14.101.dylib,sha256=tEZ_r5VT2eX_Njmicb24q1v78dOdLjSfZRxTaADulag,3677904
+av/.dylibs/libavformat.62.12.101.dylib,sha256=ol2UYQh_MD7BYTWsynflRuUO45xPPx6F9B1S1L9ZmnI,2590944
+av/.dylibs/libavutil.60.26.101.dylib,sha256=9hnr5BVSx3iBTHZMZ_bChOg9-stoftjtmWfjQc8g9CY,743952
+av/.dylibs/libdav1d.7.dylib,sha256=eY_I1aOt9fOzzzqov4lc4sK16ALdk6oLFwSHFrzbF5E,733792
+av/.dylibs/libmp3lame.0.dylib,sha256=_w1pfG7MimNiQPxn1WfgdDQfmYhn0inHhrE8phFdaMU,365152
+av/.dylibs/libopencore-amrnb.0.dylib,sha256=GAEGPnUEyHAtKhzubm70SS2WK54Fy3_FJRXtQV28kS0,267664
+av/.dylibs/libopencore-amrwb.0.dylib,sha256=sTpU9uw9rvpoKJt3dAXssGJx4JAGhivB96FXBZAiCXI,134800
+av/.dylibs/libopus.0.dylib,sha256=3KErgbd49R3FzsvHif_6rEct4JsQKhZNU0izYLI4ogI,636800
+av/.dylibs/libsharpyuv.0.1.2.dylib,sha256=bKMch2QGYuX2rvBGDzuCThktAcWhnLmtENRY2HCXGeQ,85424
+av/.dylibs/libswresample.6.3.101.dylib,sha256=dpZgyuVvnmAod7VXSikVA3KzEz74M-yM0J6ef2feKIg,121632
+av/.dylibs/libswscale.9.5.101.dylib,sha256=Jy_qF8kE9GoReq_GQuYltxiXd72_2uAqX5f7d_gqkcc,1051952
+av/.dylibs/libvpx.12.dylib,sha256=s7b9AW8tpp2ZK91eNf7gx5Z2YWS1RFN9ciogRKLx82Y,1711056
+av/.dylibs/libwebp.7.2.0.dylib,sha256=xjcBQyJkSVMckWMclBuFDFN_8cGGK764apkb12hxQg0,471632
+av/.dylibs/libwebpmux.3.1.2.dylib,sha256=YAXXzM-UE5iY9cXiD3WvCgGQUBRMtgFdRksDTyb8c3U,88112
+av/.dylibs/libx264.165.dylib,sha256=WVUzAsgpqbszMdWc3Jx7czecRh_Dkm4a-a7VM-gHqRs,1545728
+av/.dylibs/libx265.216.dylib,sha256=MONYlYmRtXmyXYFPbii9MMkr15dCWy4jKXqt1UdUNSc,6867472
+av/__init__.pxd,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+av/__init__.py,sha256=vyggkKciHoepXPZUQvVpRRpN-EXIGWAxLkZRZkMMhKI,2249
+av/__main__.py,sha256=x6yMMfLGUHLly2_PlYwsHr1fsZIvaauzPVe3ZAVAuCM,1568
+av/_core.cpython-310-darwin.so,sha256=0dcxA730Zv5XAN9LnGjkGpjVJ0MTkKuXI8xwHFTDLVs,94640
+av/_core.pxd,sha256=uMyjqyDhhL57NCdDjWp-s-1HCxG8E0ebfrjfwQ00qpA,316
+av/_core.py,sha256=M2OoJt4fkxgYYXNOvbvk8OsV4D7dd3gv0TZhs10_3wA,1945
+av/_core.pyi,sha256=FAlEwvbG4HgiXmupnWpi1jebTWRqVvE8QFOTxZhqbp0,251
+av/about.py,sha256=xUHx-wsQuyzyIcA8cLOlUeTP4tcLv4ugTAke4mQ8onY,23
+av/audio/__init__.pxd,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+av/audio/__init__.py,sha256=cKjwtg1eO9LUrcUit-ELFZH1wVtPv8NFLpiyufJA680,91
+av/audio/__init__.pyi,sha256=dl9gWskpaZ1gGDhi3L1tFUPyDFeLmk26DQ1D17jX1yY,259
+av/audio/codeccontext.cpython-310-darwin.so,sha256=-O53UEN_1-Lm8fPpUU4f9FuS2eanTZ0Mr7gxc7guC4g,114464
+av/audio/codeccontext.pxd,sha256=Yf6KxyJRo33v_ceKrqlk404otGtTvxZY-q3W_TISF6M,334
+av/audio/codeccontext.py,sha256=bEDbidpCHIgdSYPu_sTNs9jjQFTPf9AyOORLoGIOElk,3033
+av/audio/codeccontext.pyi,sha256=k-_y8gFQGb8PfDRQQrQ3ygXpLKNRWv1VlcL8Keua-58,1014
+av/audio/fifo.cpython-310-darwin.so,sha256=QbFb00liu7nn8okfaicnCDCadsvnc-fERgcHFF6OB2g,116048
+av/audio/fifo.pxd,sha256=ZTO40EMP15fO1Adm34Qh4TzgQDXeVLLAn08DQlF5Q9c,461
+av/audio/fifo.py,sha256=k9s4mdnTO6BPE56O-ASXigBUyvZd1zTYCEQ__aFPPxg,7200
+av/audio/fifo.pyi,sha256=I_nzPMFexnhzLcPZVjFQvIMevxrEHsEQxSjKmBdvh4E,712
+av/audio/format.cpython-310-darwin.so,sha256=nZXeL2qrgawz3EhvKy-5iE91KBU8UqbLrAk2LMN0uAs,113728
+av/audio/format.pxd,sha256=vDyHNUlO76PM9Yo8mMxMxJPsa2KRJg4d9_Klq84PNW4,148
+av/audio/format.py,sha256=2kB8ndKkELpN7E803KnY13Q1DD0JiQAvYmqezKhdKqQ,3629
+av/audio/format.pyi,sha256=SrRDgZkJ8kzKtywq2htlbJKK3d2ae9PIL-Qcnyoui8s,236
+av/audio/frame.cpython-310-darwin.so,sha256=EsD35r3YxCrVISyVuuuFoFtfAjAR1HhGOtXSbSr7z9A,136672
+av/audio/frame.pxd,sha256=yRuyThzIm-1HI5qCGAQkhawW77vKaDTADBfb793C5Zc,739
+av/audio/frame.py,sha256=ErZJplmdIDZlLdJ__RyZSqyEQE7wPeJbg4_cQkFlTSw,6076
+av/audio/frame.pyi,sha256=p1VeBhOkXSn7X87pT1wRvbkidKdQoWy4CV8eWXCqYoM,1419
+av/audio/layout.cpython-310-darwin.so,sha256=UBV4H-85sNPLkpiyB-ZUx4Co5cqdbf_x0YTke5J8_Kg,120880
+av/audio/layout.pxd,sha256=YQDkPvukGLIRgvHmWFpMKYCqyYWbpMZoQdGmMuy9peE,148
+av/audio/layout.py,sha256=9X-epVscUsJn44i7QDpB9MP7x08XjWyPYRl6DI_e0X4,3227
+av/audio/layout.pyi,sha256=cc0Y9RCsei824HWwZUt00tYAus92FKgIHuUk07lpEZw,250
+av/audio/plane.cpython-310-darwin.so,sha256=llrfNGx3dwRgzzmLPv9ui-zjDPNQOa-ShCx1yGKSBYg,95104
+av/audio/plane.pxd,sha256=H1vKYhmpwMOlz47ba0HeeMamzgeFfvxX7y_M1fZqrr0,132
+av/audio/plane.py,sha256=7tPNSBKjRk5q4zqciYZr8TPFsXL7d_Afs7gAlvaHfIk,421
+av/audio/plane.pyi,sha256=84IuSlDcyAhLh1wR-QPer4s0mfFVvF-yc88v0qfPntQ,74
+av/audio/resampler.cpython-310-darwin.so,sha256=cGVKqGgXUXb3AqTxEGKm6UBWPIAc6plfHQfsWKLfKQ0,133200
+av/audio/resampler.pxd,sha256=SbWg7wXGtLNTs34Bc4Hh-5mhmFdTq45Qc4AuzBgdBGE,490
+av/audio/resampler.py,sha256=khcRspEQq9j9nt1MaNBzT-rAWNtH1q4FFFYEU5v_Ro0,4089
+av/audio/resampler.pyi,sha256=dVyEvLOJ3IUN3AXsSYfg77H2Yaz2sIW38sJASH5fHRg,542
+av/audio/stream.cpython-310-darwin.so,sha256=6B98kSPcQWw_kdugqOXra954v8N9GsG95IF6pbj8FY8,114192
+av/audio/stream.pxd,sha256=E38lNdZrVkiNbVLUJo8sgqFLQYb_UVTjOLmhM-cjbbg,209
+av/audio/stream.py,sha256=Evy2eYCN-wBw7EyFbJFmTVVADRPrtVszVwwuWUS8Q9g,1628
+av/audio/stream.pyi,sha256=9OcxV5qNCwxGBN1vrommvbMfDwHtuumEPsujVw2ysbI,989
+av/bitstream.cpython-310-darwin.so,sha256=zmUSpQRTgmsnFE8mW2drnCE6YN0EvxLnbptbvzQsbKM,112608
+av/bitstream.pxd,sha256=hi30kwIdgdCQEVjtUqXo2L4gioHU_1_yWgKu3SqCgTc,184
+av/bitstream.py,sha256=jaDTJdPFYu4M14FA9hioVjuevfOmxR1-A9ZEhnVgkV0,3313
+av/bitstream.pyi,sha256=CuumhPlDJV91iKtUpJDcuvPxighE9q2FzYmc0qtIN7A,389
+av/buffer.cpython-310-darwin.so,sha256=noqlSrH7YncV4nHluSk2RWD4qlajjCwpV8IexVMMMGQ,116576
+av/buffer.pxd,sha256=KYPVOIDVZ-RTj-tSPRrYxyGIgrekKXt3kQSquZb6Ycw,363
+av/buffer.py,sha256=2cUibrqxK1jPPYAqehLzYY8RYplDdpHsMRDxBzAosvM,2900
+av/buffer.pyi,sha256=0JCfkCBhhP3a3-_1AIhMf4sbNYJ1Uyy8GOrQ5-U4EVs,316
+av/codec/__init__.pxd,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+av/codec/__init__.py,sha256=vOJ3lfD1Z0iSXqq4bED5mCDocxBo7YJCujk3-1N9SYQ,298
+av/codec/codec.cpython-310-darwin.so,sha256=7XINcriu-LdckMGeIJrwTmJ7GpsT754uzAVd4vgNC9w,155760
+av/codec/codec.pxd,sha256=0yZubvg-MpyJ4t2JalN-BIxKB_zJM1VcG4s3iZpy_Is,263
+av/codec/codec.py,sha256=-U_OeiGpajjVJvCc4vB3l1sO7_ZXM7EGaeIM0EFNMgc,13948
+av/codec/codec.pyi,sha256=6PSfYZ1zKzm3Ks7HA4k06dK9tNqiUezDGi3GxXxBJBk,4716
+av/codec/context.cpython-310-darwin.so,sha256=sKq8AJCh_YV5MiMcPnebnVAECDspKdoZTS7hOOOd90c,201488
+av/codec/context.pxd,sha256=s9aYw4PhlB_1eLk3_xO0PKmNwY49D--sya9cCLs6Tio,2500
+av/codec/context.py,sha256=rZXwZl-PUKRVJMITUKOhKR39T6-4Ks8KPk_9Maigf2g,24736
+av/codec/context.pyi,sha256=7NgxSKjx8ha9XpTSDufWNNlOp8CEpRaeSlRPEHBNtao,3489
+av/codec/hwaccel.cpython-310-darwin.so,sha256=LacZACRRTchlGNvKiKd4DxHsTKm1o6zuOa9Ub5HAZI4,137600
+av/codec/hwaccel.pxd,sha256=TkULWTlVpZLOh1jO4BsoqsXy-5WNVXsYWYLR0G_UmWQ,595
+av/codec/hwaccel.py,sha256=szSAcz08Vv7x-QhoaLXKn4uTKrD09y_lf4x60QihqQE,5989
+av/codec/hwaccel.pyi,sha256=41bocToAsL_EGlqZ1TmuMlj5oZtW7VCCbPnKyErZieY,1493
+av/container/__init__.pxd,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+av/container/__init__.py,sha256=_GTpNeXz0bo93otTZ3v6fhS9238ZjOobn3CRQv2dd94,148
+av/container/__init__.pyi,sha256=OvEGnWBxXGuuGVG9n8raY8mfhsO5JKM7PiG9NF1xHzQ,63
+av/container/core.cpython-310-darwin.so,sha256=7JrW4G3UUl8fx5ApDsLsAgXs2h0MUOR6dMaS_3xz3YI,195888
+av/container/core.pxd,sha256=4XQTllGfo_8SlO0PUaflJwgiTmAxEO5UuOAYGmn5gGU,1342
+av/container/core.py,sha256=k-h5nHbTvgYl51Cin1kbe1S1pIPyUFIOVo0en_OG9-A,22015
+av/container/core.pyi,sha256=P78wYuSBoJbzyMDVzFU9S-mCVzpqmW-PShl4vkOZ_Ng,5310
+av/container/input.cpython-310-darwin.so,sha256=rakxQieyt5B4JXo1z-qTnbmz52tL574fzGsTHRsRq20,157504
+av/container/input.pxd,sha256=57CHqOcDRcXRvPinfLwG8Z83FI3hjGGTT07SDQqNMws,162
+av/container/input.py,sha256=KXzU_WsZxbW1HZAdmgx9Gz2MOSIyTshS84aRftHkD6g,12032
+av/container/input.pyi,sha256=wIl7b-Mb0AWG9YX0eAuIH0IXxMlykrbCrfdXORPiVY8,3083
+av/container/output.cpython-310-darwin.so,sha256=wFhdcdUxCSLDoAGY1gkAd3VOjBxKxRi8s4VNmdEthi8,156176
+av/container/output.pxd,sha256=5A0l7ZNR0SOrA5PjwHIYllKYcnaWxSHBgtmOjyqObM8,199
+av/container/output.py,sha256=L_PkvUyvo-4oO_g13NEK2NlCIim4DJAuABnrLAre5zU,22698
+av/container/output.pyi,sha256=ZgWgGOlxILO55JUUGQV-xp6qHDeJArBTRxhIgU6ozjw,2113
+av/container/pyio.cpython-310-darwin.so,sha256=7ojK51QvYR0uKSw3ftyUzwzX7SPmtbSrW2LWqk7RLwc,113696
+av/container/pyio.pxd,sha256=Q1wOsyR09k5h4dS-wjk_CjkASabD3hDQ71W8FXvGjTQ,729
+av/container/pyio.py,sha256=yoa1EhrDWPYPIZml_Hp320vghWLR2bSYTNlwEuwGa-c,6329
+av/container/streams.cpython-310-darwin.so,sha256=pD9DGzuH9sKLYMecx3QjTcIw8rO5Ua_p3PP-fC4RQXE,159696
+av/container/streams.pxd,sha256=iHkTkzM1Ybs6VIuRfPuRkXFK1gayI3li95G-euLEmSY,151
+av/container/streams.py,sha256=ulTig1f-lCmycDJ5WuBGFpYucaszcKvNC8M0NiNGZMY,5312
+av/container/streams.pyi,sha256=iuiJVhIlU-j6CtknPXxmxtePZ1aj7Ad0HnKsl4mTe_M,1140
+av/datasets.py,sha256=crxN4-UwGSOG6eHNfli7kSnOgwc3SK8fnY-p8Hje4Cc,3094
+av/device.cpython-310-darwin.so,sha256=rkfPyS-aPzimOoguv2WxVS_toosqhwPMxu7WOElP8o0,137344
+av/device.py,sha256=HBpdY2GDcrq24V3R4UYn6kumlOIhJTOJc9Euc6RiHRg,6334
+av/device.pyi,sha256=Ak39HPSoHGutW2UYt6_kxcZU7izvegAZf8axEOpv208,516
+av/dictionary.cpython-310-darwin.so,sha256=gfhhvXn0PUoCMCzQDQQYMzrAnbfUABjJgpB2x-2OXGY,138416
+av/dictionary.pxd,sha256=zNNJW_zfBKILR23fwcUffhXjK2SFS316H_bbbKGOa2Y,168
+av/dictionary.py,sha256=odsCuz3YOn21-I0IaX4tCPQ9bZ28xOWM9VF25O3Ehbk,2299
+av/dictionary.pyi,sha256=bf3eGEu0DwMJvWm4ulnVkJrqHFMqREa76SDceO-wVks,605
+av/error.cpython-310-darwin.so,sha256=3fokdi0E_REPCGXBbTja8Ww7aZVAg-bDZwsrx8QOpFw,227344
+av/error.pxd,sha256=pIFybV6fBCAI3IveFVMnEv_9S_f8xv1ZCwRYHvbLaVQ,88
+av/error.py,sha256=5T9fI20pP-RbJmeb5yEc0CBeNUcIrPm_LaBM2cKzMGc,11999
+av/error.pyi,sha256=ohKxnWMullPZ8ntE2inFQ7FrGNmitxNxFWW3Q3hdYDc,3213
+av/filter/__init__.pxd,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+av/filter/__init__.py,sha256=3PhVQg5b52PMmAaJf2pmMKbScTvo7cvKSa_1Zprd0gk,117
+av/filter/__init__.pyi,sha256=Jkfg79hkGdMuvHM5_rIK_YyP1flJJqlpSrV6w-znzig,90
+av/filter/context.cpython-310-darwin.so,sha256=EyC2fvDnLI1So6pN6m6M0s8ZyRoWvdFkf2Uq1_xzBwU,217984
+av/filter/context.pxd,sha256=ytFXp6WCjHWm89b2hs4xQpVEv9H9MqiOQFtYhrCyxho,388
+av/filter/context.py,sha256=l2SRAc6_M6C9VYA-f1OnyFhLRIkqpqG7sYHY8zA_AS4,5873
+av/filter/context.pyi,sha256=Mm1IwQXDdSoQjnebdIE5EDInxWHWj9HPDNSbFrVtOzg,559
+av/filter/filter.cpython-310-darwin.so,sha256=QD_GRFtmhjc2EL4eVpLt8_JMMrT8PxeDjNAJCpyH0u0,95680
+av/filter/filter.pxd,sha256=5w87wK9ugRAc8qUHPJ5f-iB0MW3aIHXk1BiaF4jqTNM,175
+av/filter/filter.py,sha256=h0OMjEcDdu4hCdP2fEuPj-V_1IPmAgTkr1MYRzmVZAc,1639
+av/filter/filter.pyi,sha256=Poi6pctZayAf1g23SAzu8LqZCXUuzn74Zv7m966YL58,141
+av/filter/graph.cpython-310-darwin.so,sha256=qaSzzFjOMN4yQZCvG1BfFg5g0TDgj8htLp0tPWYK-ts,153712
+av/filter/graph.pxd,sha256=cd1UIcvghDMORxJ-qtm0fsTc3rtTEIvUKdM65BH0KSo,600
+av/filter/graph.py,sha256=4cSbAxm1o7I8PzPEQGy_a9oaqkMiUlJjEfEQJVXUB60,9379
+av/filter/graph.pyi,sha256=VZN2ltBYNMBjcjfaNO5vZG9wfZDAYYXAZjZUxX0ih10,1677
+av/filter/link.cpython-310-darwin.so,sha256=tRIVVDGaSXC1jCP5lMzMx1H6mfIXSWzQ7SDybIDg5Rw,117872
+av/filter/link.pxd,sha256=qyA9oQF1M975aafIF1X5JpD6TW-3R8B8VTHckbQKEZU,786
+av/filter/link.py,sha256=UmXTU3ZtwM3100Mut1B0h6kjyqbQA_HGWnHQwlawiMk,4537
+av/filter/link.pyi,sha256=UtgqwA_9EV5w311swXpS9pwZzruTl-nHtU7-hpEt5u4,27
+av/filter/loudnorm.cpython-310-darwin.so,sha256=xN2cqxMS0dFQiQUkobv3wHXLRZ5f0GDldkZVUzKnCSs,113856
+av/filter/loudnorm.pxd,sha256=mrKiGSe6WnIrMkDJU8uj1fs0Iwz_kxFPDL_NmnveyUE,464
+av/filter/loudnorm.py,sha256=OuTHzqHjkKOkOcKP3Pus2SXr_Giw4ZwaDToHxo5sfvU,1439
+av/filter/loudnorm.pyi,sha256=N_HuXpQlTaZLpnKjfqMk68ac3djymdy3x_9en33sA74,106
+av/filter/loudnorm_impl.c,sha256=2ixg15rxo_m92kdwuCvYhkQF8NB_LV_RSEVNyZKtVRw,6251
+av/filter/loudnorm_impl.h,sha256=QmUqnvobMbPSmas5haev86WCVAs_a6iXaAZPwx-iVAk,240
+av/format.cpython-310-darwin.so,sha256=YCM-84krV0Wf9C0GaNsj6v1f0OlHHO0cw_m5UsHgekc,115568
+av/format.pxd,sha256=VbCPLqdb49zGSiOdyc4nk1IQA7JD1VChFyshmjV8mu4,258
+av/format.py,sha256=7bz0zL_-2EjpQUR1Hg0qkJkIwo0kZEXHpGvIU7DXV4E,5571
+av/format.pyi,sha256=dh49OMLec0IadFEiQxZ0-VKyu9eP0NDI1yDk8HrU6RY,1403
+av/frame.cpython-310-darwin.so,sha256=Au5VkoaZTw4lOSmoQhOUDmvmf6t9qBE4op5Xt5haxh4,116304
+av/frame.pxd,sha256=MdtAffABVLDFi_c5oQFm3lT-n6xVbya8IBEsppbf6tU,411
+av/frame.py,sha256=vObiqHSJK26RP2AdL8pC9q3XvvRqgog_yUd6BUFOl_M,5801
+av/frame.pyi,sha256=tyk7ffzDSOY6IiOXDeu1GThIguICv9Eb_wwZjULFMLE,532
+av/index.cpython-310-darwin.so,sha256=NsSL-LYeR-1wOHd3nq0ROX8h_K9tos1mYcFsCsEAKG0,139264
+av/index.pxd,sha256=rPkSQuLLTZfmLFnRCzhEoj_y1WIDsflw2zmMy2YNCIw,290
+av/index.py,sha256=E_SscIwgHeKGTbZk1ywpuMdreK1i8w-QQCKA5Xvb5k4,4288
+av/index.pyi,sha256=Y7Y-_CoaScDyAzZWVW4uURzwD1Z6cRBBawD-R43Mv_Y,559
+av/logging.cpython-310-darwin.so,sha256=eKt-4Tow3dhRs31mstgy2_b4hUnUdxVjMCdOlB9Gv4Y,154192
+av/logging.pxd,sha256=tFpeiXuAHyp6bhB0pBnmpHqG3gL3mXW4pNl6SSXQeNI,319
+av/logging.py,sha256=ybuJeXaQJPQcpyG4gReUMn2wparbWGSLB8CI5GLil0M,10388
+av/logging.pyi,sha256=Afqq5ud46eh617UM6b_D3xpIisdz9uyxvKK4rK1n6RA,885
+av/opaque.cpython-310-darwin.so,sha256=WZxW0r5A6FfvgJ7sfbWg_ZC9QAMZ5PrvR2m_CBHUeW0,95040
+av/opaque.pxd,sha256=vRgs17rMhB8CuiZ450z30WmSi6VMTiirDQr8ykLPwJs,236
+av/opaque.py,sha256=9YwOMEm3CfLK2eq-F59XXqdRQ1uIo1MDjYHU4U177og,1741
+av/packet.cpython-310-darwin.so,sha256=l_iZ6-iUrtmYL3jqS0RwxMG2vlMick5BIy-18dKUyFw,164224
+av/packet.pxd,sha256=7L5wqv7vzE4yZUwAAcducxIdIVMvVXrqSKprNrTGiIo,561
+av/packet.py,sha256=KX91fT4iKg1cBLPjPYU-bhSiHRc5U1ZzEwHwbL3C3-g,14054
+av/packet.pyi,sha256=s91OVOX0OK65OF0zC-d2e1tlwjA2vSJF7inTQIO1zto,3232
+av/plane.cpython-310-darwin.so,sha256=LlkYLgNwShD43ACDvJfCNpve3y1O7rPv8d2NqpDr2Go,112624
+av/plane.pxd,sha256=eOzjPaCDVvvaygHiTXmm477_bmwZZ5bDo4gqKZczvxE,194
+av/plane.py,sha256=FFCfzCS3XmzjQuHjFhmWWtPkoxMIirsz-O980CGn-nQ,626
+av/plane.pyi,sha256=qJLw7M73ekThXf05LqTllf1BLIfF3gckxEy6rEjKx4U,169
+av/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+av/sidedata/__init__.pxd,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+av/sidedata/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+av/sidedata/encparams.cpython-310-darwin.so,sha256=jyj0xVH7NsTDhxmNklir8CHF1k4ytJ3OSoUm3vxOsgI,135280
+av/sidedata/encparams.pxd,sha256=1ovAOjIZKwCm9KV_lxtY9kmUqNuuwmWI0nktf4hiRe0,181
+av/sidedata/encparams.py,sha256=Xg86RTjso4gXAwaIdSHmvOjO2VuBrWG5wUJadWbfVvE,6047
+av/sidedata/encparams.pyi,sha256=BebTdGqqzNLY8_7hkrW2poXWMuIeY4O-kBSXVvh0mUo,571
+av/sidedata/motionvectors.cpython-310-darwin.so,sha256=X2bNO91DOrbaAYVX02PTjjgPpicx6wUAWgORvMJBaOs,142240
+av/sidedata/motionvectors.pxd,sha256=QetgIOGElsOMJokp9KIvYM0pH2L8x5cR995HaNZc1Eo,269
+av/sidedata/motionvectors.py,sha256=Toavw_91yx92lleFT8U0FZowmeQSN3k95wrrIQkL0uU,3557
+av/sidedata/motionvectors.pyi,sha256=p_9dVgneh52OdrdK4CRdZYg2ACZHrlRwEcbrbLH3rqA,536
+av/sidedata/sidedata.cpython-310-darwin.so,sha256=xE9qQGHVIYdkPKFbl8EuZjmTaQ9ztgbEVOYqviY-9Ao,137056
+av/sidedata/sidedata.pxd,sha256=OWx1tWeGoYHPLgRzFZbVBAe9WPHvLSeDVv4Wd5Q06AY,447
+av/sidedata/sidedata.py,sha256=Fsmqu4ESFUH5J9F4czb54AR8jmUGIEOQ9N6KPM_Ot64,4671
+av/sidedata/sidedata.pyi,sha256=MaoM-BKdFEQoZ2muFfC4Qxkg3Q4b_sFyGXY7tGLRjHs,1969
+av/stream.cpython-310-darwin.so,sha256=HOxBV_gl-8Tx6J93pn6PtFGd9Nqjoj9w9csvk_UDi44,137712
+av/stream.pxd,sha256=kV-xU37bzdL1PMCPh66SYuPfZbqYHH5MLFv2EIj8WcA,768
+av/stream.py,sha256=UuZhLDj3dWz2TKGnYHORoU554ggoqWfkNGhkRTQVabo,9932
+av/stream.pyi,sha256=7frqrvvwTOk6ImtQ_iKsdep0wW1_FlVMjAopeykKjUY,1966
+av/subtitles/__init__.pxd,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+av/subtitles/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+av/subtitles/codeccontext.cpython-310-darwin.so,sha256=H6LVP3STJq2QU4h2tEhzyay4GF-S-mIVH1Kjepq651s,113952
+av/subtitles/codeccontext.pxd,sha256=lrG4G4JEvUyWbVFtqXv7u_9f8SH1kTgBLNqAJHvclbk,235
+av/subtitles/codeccontext.py,sha256=IzfeuX5NEJmWeBaYuQMNGKDG5ukFtc2VTjpL1kclkY8,4722
+av/subtitles/codeccontext.pyi,sha256=HcPuzR5BuwD0Ph4OnUHfIUXJFqeuN6pjo1N0886v0ao,385
+av/subtitles/stream.cpython-310-darwin.so,sha256=nd_SW2u6xdTDTKxFzRccb0YM7yeJngv4C7ieivg7P_Q,95312
+av/subtitles/stream.pxd,sha256=Lo4RBTTOWErzKgNqc07AoNDaAgkUsF_Q25DJaAIo52Y,137
+av/subtitles/stream.py,sha256=r0gPhz3vP5VRiOuGM_sL8uS3nDRmSlPp9h8MiscWoDI,645
+av/subtitles/stream.pyi,sha256=rGoPESxKYF9DD9f0PeMkLd-QwT01D-GA-dhwF60gtwM,343
+av/subtitles/subtitle.cpython-310-darwin.so,sha256=wH6wmH_8MiJGBPalm3qKH5EaRCIviGvLm_6l3R7ydPc,184416
+av/subtitles/subtitle.pxd,sha256=N_QwXo5kimdZY-T2SxIowRkqiD38qHA4MEjOaZD619A,590
+av/subtitles/subtitle.py,sha256=Vef8bw1ffc5UbxdjX8NA0ro9c2-rP3_8AeFlq8opsVo,10151
+av/subtitles/subtitle.pyi,sha256=DXZ_0nKzZcGOnzKlS1AWGXPdAb8FiG5xdJqDQx-SgLk,984
+av/utils.cpython-310-darwin.so,sha256=j_11r0SmVV1aDttlx7ONyaDXW7isw1LAcGkb4mNxehk,94560
+av/utils.pxd,sha256=NGyU6Ve4JWjw2Epk0-8se5D3FRUm56VhL72j-V6AJiA,366
+av/utils.py,sha256=F1DNSuNIRbtF9-1blgXPKgBlCVSCPpD3vPFyGvnify4,2008
+av/video/__init__.pxd,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+av/video/__init__.py,sha256=Vq396L7PMjMhTDhvFZPbcLqU9mgdAR82NWk1K08QH64,91
+av/video/__init__.pyi,sha256=zTUgi5b-SF1D9iR0IFZjjWmnrWikVSk6Sn5P4NAj0mA,262
+av/video/codeccontext.cpython-310-darwin.so,sha256=b5Yl8QxUpJlzj_2XUzF_9LzPhgw2d7IPzbGKcoFH7nc,137680
+av/video/codeccontext.pxd,sha256=vLe2JHf4XxfOwXmJOFLAcVBfe4Me773ZnXpiLngmD2c,875
+av/video/codeccontext.py,sha256=fvVox-YN84itXJs34wH-BSQkuPAqEJS5jKVNNzecR7g,11860
+av/video/codeccontext.pyi,sha256=ord9zvT5MUveSivTg1hWrHOACywxNf5qDlrrTwjGcmY,991
+av/video/format.cpython-310-darwin.so,sha256=Ou0sGl6sqzBvROZuBthDMkSmLqFctirH6_VFeTu8YUA,142592
+av/video/format.pxd,sha256=hUqOV0DEGy8yRhfX1e2I246BcBwaGOWrixhNazO2v-g,686
+av/video/format.py,sha256=d4T5dvkIT7aE1bZcddD2MiesAwf2Lzh9BB29ZijvEL8,6175
+av/video/format.pyi,sha256=XGTdOgcr5YMTR30ozRd9A8KC0NZVhXHl5hh9CxDdcjY,805
+av/video/frame.cpython-310-darwin.so,sha256=Gsvbfzo2qz66XNyg19S11fTlmmV6oCT6A17irgYMX4g,413152
+av/video/frame.pxd,sha256=3VYbrytXp62lxGauju6ormIkLK9mL7yOFdvGVxAk-TQ,869
+av/video/frame.py,sha256=oOJV95C5zdZA9S4hc1RnTBlpjF5YFHzPLzzmc8igg3Y,59254
+av/video/frame.pyi,sha256=_d8xiGAmlt-YEvA4C7fkFsUr9UGmYoNKJBbxKPZL2fQ,3067
+av/video/plane.cpython-310-darwin.so,sha256=oKBQt-liVQR5_ihBjDdzFgHTzNNInFdP7yOx2my772I,117184
+av/video/plane.pxd,sha256=g3qjx6-1cSlBNnFS2Mif4iBkD_VvHA92D_SvbUTd3DY,772
+av/video/plane.py,sha256=ICLTU998bK-un16p8stBAPvPzRuHPIzc5mVzFxHbhAU,10667
+av/video/plane.pyi,sha256=26hYzC63EN31pFyR3GTndf5uYc43vH2zWMaXLS_wMl0,385
+av/video/reformatter.cpython-310-darwin.so,sha256=j75MGLhaZZi2w-2AdR4I056bwfjbpUtj0asoY2zoIks,131616
+av/video/reformatter.pxd,sha256=vR4FvP-xns3o6U8tKN65lNOOrCUZowYAy7HvRk72dv0,1291
+av/video/reformatter.py,sha256=Z-aXlQ92e2eSBhef3mHst9f3IHo6jrBubOVUQSn0uFY,12697
+av/video/reformatter.pyi,sha256=0ikHmHcxY0B3LcQ5X-OBoyqag93qIpoin79q-t82p10,2466
+av/video/stream.cpython-310-darwin.so,sha256=GX-giICn9YYUds8eFpnORhy_h6vIB5a-aVFY4a0A64o,135440
+av/video/stream.pxd,sha256=6z65wy60rKFRpN0rjWd4smgnPOd6P6EzNh3umZenD9c,528
+av/video/stream.py,sha256=xFGIjd-R24ja_Y-hrd3CrCa8vpiKFGtRHfM46qtzwiE,6884
+av/video/stream.pyi,sha256=bFX706QESMaHSi3A2d-wEKaAM4TN-a5vqEQmOuadb50,1416

.venvs/kimodo/lib/python3.10/site-packages/av-17.1.0.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: false
+Tag: cp310-cp310-macosx_14_0_arm64
+Generator: delocate 0.13.0
+

.venvs/kimodo/lib/python3.10/site-packages/av-17.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pyav = av.__main__:main

.venvs/kimodo/lib/python3.10/site-packages/av-17.1.0.dist-info/licenses/AUTHORS.py

@@ -0,0 +1,182 @@
+""" Generate the AUTHORS.rst file from git commit history.
+
+This module reads git commit logs and produces a formatted list of contributors
+grouped by their contribution count, mapping email aliases and GitHub usernames.
+"""
+
+from dataclasses import dataclass
+import math
+import subprocess  # noqa: S404
+
+
+def main() -> None:
+    """ Generate and print the AUTHORS.rst content. """
+
+    contributors = get_git_contributors()
+    print_contributors(contributors)
+# ------------------------------------------------------------------------------
+
+
+EMAIL_ALIASES: dict[str, str | None] = {
+    # Maintainers.
+    "git@mikeboers.com": "github@mikeboers.com",
+    "mboers@keypics.com": "github@mikeboers.com",
+    "mikeb@loftysky.com": "github@mikeboers.com",
+    "mikeb@markmedia.co": "github@mikeboers.com",
+    "westernx@mikeboers.com": "github@mikeboers.com",
+    # Junk.
+    "mark@mark-VirtualBox.(none)": None,
+    # Aliases.
+    "a.davoudi@aut.ac.ir": "davoudialireza@gmail.com",
+    "tcaswell@bnl.gov": "tcaswell@gmail.com",
+    "xxr3376@gmail.com": "xxr@megvii.com",
+    "dallan@pha.jhu.edu": "daniel.b.allan@gmail.com",
+    "61652821+laggykiller@users.noreply.github.com": "chaudominic2@gmail.com",
+}
+
+CANONICAL_NAMES: dict[str, str] = {
+    "caspervdw@gmail.com": "Casper van der Wel",
+    "daniel.b.allan@gmail.com": "Dan Allan",
+    "mgoacolou@cls.fr": "Manuel Goacolou",
+    "mindmark@gmail.com": "Mark Reid",
+    "moritzkassner@gmail.com": "Moritz Kassner",
+    "vidartf@gmail.com": "Vidar Tonaas Fauske",
+    "xxr@megvii.com": "Xinran Xu",
+}
+
+GITHUB_USERNAMES: dict[str, str] = {
+    "billy.shambrook@gmail.com": "billyshambrook",
+    "daniel.b.allan@gmail.com": "danielballan",
+    "davoudialireza@gmail.com": "adavoudi",
+    "github@mikeboers.com": "mikeboers",
+    "jeremy.laine@m4x.org": "jlaine",
+    "kalle.litterfeldt@gmail.com": "litterfeldt",
+    "mindmark@gmail.com": "markreidvfx",
+    "moritzkassner@gmail.com": "mkassner",
+    "rush@logic.cz": "radek-senfeld",
+    "self@brendanlong.com": "brendanlong",
+    "tcaswell@gmail.com": "tacaswell",
+    "ulrik.mikaelsson@magine.com": "rawler",
+    "vidartf@gmail.com": "vidartf",
+    "willpatera@gmail.com": "willpatera",
+    "xxr@megvii.com": "xxr3376",
+    "chaudominic2@gmail.com": "laggykiller",
+    "wyattblue@auto-editor.com": "WyattBlue",
+    "Curtis@GreenKey.net": "dotysan",
+}
+
+
+@dataclass
+class Contributor:
+    """ Represents a contributor with their email, names, and GitHub username. """
+
+    email: str
+    names: set[str]
+    github: str | None = None
+    commit_count: int = 0
+
+    @property
+    def display_name(self) -> str:
+        """ Return the formatted display name for the contributor.
+
+        Returns:
+            Comma-separated sorted list of contributor names.
+        """
+
+        return ", ".join(sorted(self.names))
+
+    def format_line(self, bullet: str) -> str:
+        """ Format the contributor line for RST output.
+
+        Args:
+            bullet: The bullet character to use (- or *).
+
+        Returns:
+            Formatted RST line with contributor info.
+        """
+
+        if self.github:
+            return (
+                f"{bullet} {self.display_name} <{self.email}>; "
+                f"`@{self.github} <https://github.com/{self.github}>`_"
+            )
+        return f"{bullet} {self.display_name} <{self.email}>"
+
+
+def get_git_contributors() -> dict[str, Contributor]:
+    """ Parse git log and return contributors grouped by canonical email.
+
+    Returns:
+        Dictionary mapping canonical emails to Contributor objects.
+    """
+
+    contributors: dict[str, Contributor] = {}
+    git_log = subprocess.check_output(
+        ["git", "log", "--format=%aN,%aE"],  # noqa: S607
+        text=True,
+    ).splitlines()
+
+    for line in git_log:
+        name, email = line.strip().rsplit(",", 1)
+        canonical_email = EMAIL_ALIASES.get(email, email)
+
+        if not canonical_email:
+            continue
+
+        if canonical_email not in contributors:
+            contributors[canonical_email] = Contributor(
+                email=canonical_email,
+                names=set(),
+                github=GITHUB_USERNAMES.get(canonical_email),
+            )
+
+        contributor = contributors[canonical_email]
+        contributor.names.add(name)
+        contributor.commit_count += 1
+
+    for email, canonical_name in CANONICAL_NAMES.items():
+        if email in contributors:
+            contributors[email].names = {canonical_name}
+
+    return contributors
+
+
+def print_contributors(contributors: dict[str, Contributor]) -> None:
+    """Print contributors grouped by logarithmic order of commits.
+
+    Args:
+        contributors: Dictionary of contributors to print.
+    """
+
+    print("""\
+        Contributors
+        ============
+
+        All contributors (by number of commits):
+        """.replace("        ", ""))
+
+    sorted_contributors = sorted(
+        contributors.values(),
+        key=lambda c: (-c.commit_count, c.email),
+    )
+
+    last_order: int | None = None
+    block_index = 0
+
+    for contributor in sorted_contributors:
+        # This is the natural log, because of course it should be. ;)
+        order = int(math.log(contributor.commit_count))
+
+        if last_order and last_order != order:
+            block_index += 1
+            print()
+        last_order = order
+
+        # The '-' vs '*' is so that Sphinx treats them as different lists, and
+        # introduces a gap between them.
+        bullet = "-*"[block_index % 2]
+        print(contributor.format_line(bullet))
+
+
+if __name__ == "__main__":
+    main()

.venvs/kimodo/lib/python3.10/site-packages/av-17.1.0.dist-info/licenses/AUTHORS.rst

@@ -0,0 +1,129 @@
+Contributors
+============
+
+All contributors (by number of commits):
+
+- Mike Boers <github@mikeboers.com>; `@mikeboers <https://github.com/mikeboers>`_
+- WyattBlue <wyattblue@auto-editor.com>; `@WyattBlue <https://github.com/WyattBlue>`_
+
+* Jeremy Lainé <jeremy.laine@m4x.org>; `@jlaine <https://github.com/jlaine>`_
+
+- Mark Reid <mindmark@gmail.com>; `@markreidvfx <https://github.com/markreidvfx>`_
+
+* Lukas Geiger <lukas.geiger94@gmail.com>
+
+- Vidar Tonaas Fauske <vidartf@gmail.com>; `@vidartf <https://github.com/vidartf>`_
+- laggykiller <chaudominic2@gmail.com>; `@laggykiller <https://github.com/laggykiller>`_
+- Billy Shambrook <billy.shambrook@gmail.com>; `@billyshambrook <https://github.com/billyshambrook>`_
+- Casper van der Wel <caspervdw@gmail.com>
+- Philip de Nier <philipn@rd.bbc.co.uk>
+- Tadas Dailyda <tadas@dailyda.com>
+- Dave Johansen <davejohansen@gmail.com>
+- Mark Harfouche <mark.harfouche@gmail.com>
+- JoeUgly <41972063+JoeUgly@users.noreply.github.com>
+- Justin Wong <46082645+uvjustin@users.noreply.github.com>
+- Santtu Keskinen <santtu.keskinen@gmail.com>
+
+* Alba Mendez <me@alba.sh>
+* Curtis Doty <Curtis@GreenKey.net>; `@dotysan <https://github.com/dotysan>`_
+* Xinran Xu <xxr@megvii.com>; `@xxr3376 <https://github.com/xxr3376>`_
+* z-khan <zohaibkh_27@yahoo.com>
+* Marc Mueller <30130371+cdce8p@users.noreply.github.com>
+* Dan Allan <daniel.b.allan@gmail.com>; `@danielballan <https://github.com/danielballan>`_
+* Moonsik Park <moonsik.park@estsoft.com>
+* velsinki <40809145+velsinki@users.noreply.github.com>
+* Christoph Rackwitz <christoph.rackwitz@gmail.com>
+* David Plowman <david.plowman@raspberrypi.com>
+* Alireza Davoudi <davoudialireza@gmail.com>; `@adavoudi <https://github.com/adavoudi>`_
+* Jonathan Drolet <jonathan.drolet@riedel.net>
+* Matthew Lai <m@matthewlai.ca>
+* Kim Minjong <make.dirty.code@gmail.com>
+* Moritz Kassner <moritzkassner@gmail.com>; `@mkassner <https://github.com/mkassner>`_
+* Thomas A Caswell <tcaswell@gmail.com>; `@tacaswell <https://github.com/tacaswell>`_
+* Ulrik Mikaelsson <ulrik.mikaelsson@magine.com>; `@rawler <https://github.com/rawler>`_
+* Wel C. van der <wel@Physics.LeidenUniv.nl>
+* Will Patera <willpatera@gmail.com>; `@willpatera <https://github.com/willpatera>`_
+
+- zzjjbb <31069326+zzjjbb@users.noreply.github.com>
+- Joe Schiff <41972063+JoeSchiff@users.noreply.github.com>
+- Nils DEYBACH <68770774+ndeybach@users.noreply.github.com>
+- Dexer <73297572+DexerBR@users.noreply.github.com>
+- DE-AI <81620697+DE-AI@users.noreply.github.com>
+- rutsh <Eugene.Krokhalev@gmail.com>
+- Felix Vollmer <FelixVollmer@gmail.com>
+- Benedikt Lorch, benedikt-grl <benedikt@getreallabs.com>
+- Santiago Castro <bryant1410@gmail.com>
+- Christian Clauss <cclauss@me.com>
+- Ihor Liubymov <ihor.liubymov@ring.com>
+- Johannes Erdfelt <johannes@erdfelt.com>
+- Karl Litterfeldt <kalle.litterfeldt@gmail.com>; `@litterfeldt <https://github.com/litterfeldt>`_
+- Leon White <l.white@interstellarlab.earth>
+- Martin Larralde <martin.larralde@ens-cachan.fr>
+- Simon-Martin Schröder <martin.schroeder@nerdluecht.de>
+- Matteo Destro <matteo.est@gmail.com>
+- Mattias Wadman <mattias.wadman@gmail.com>
+- mephi42 <mephi42@gmail.com>
+- Miles Kaufmann <mkfmnn@gmail.com>
+- Nathan Goldbaum <nathan.goldbaum@gmail.com>
+- Pablo Prietz <pablo@prietz.org>
+- Andrew Wason <rectalogic@rectalogic.com>
+- Radek Senfeld <rush@logic.cz>; `@radek-senfeld <https://github.com/radek-senfeld>`_
+- robinechuca <serveurpython.oz@gmail.com>
+- Nick <24689722+ntjohnson1@users.noreply.github.com>
+- Benjamin Chrétien <2742231+bchretien@users.noreply.github.com>
+- 吴小白 <296015668@qq.com>
+- davidplowman <38045873+davidplowman@users.noreply.github.com>
+- Hanz <40712686+HanzCEO@users.noreply.github.com>
+- Clay Castronovo <42858023+clayy24@users.noreply.github.com>
+- Kesh Ikuma <79113787+tikuma-lsuhsc@users.noreply.github.com>
+- Artturin <Artturin@artturin.com>
+- Ian Lee <IanLee1521@gmail.com>
+- Ryan Huang <NPN@users.noreply.github.com>
+- Arthur Barros <arthbarros@gmail.com>
+- bdavid-evertz <bdavid@evertz.com>
+- Carlos Ruiz <carlos.r.domin@gmail.com>
+- Carlos Ruiz <carlos.ruiz.dominguez@west.cmu.edu>
+- Maxime Desroches <desroches.maxime@gmail.com>
+- egao1980 <egao1980@gmail.com>
+- Eric Kalosa-Kenyon <ekalosak@gmail.com>
+- elxy <elxy@outlook.com>
+- Gemfield <gemfield@civilnet.cn>
+- henri-gasc <henri.gasc@eurecom.fr>
+- Jonathan Martin <homerunisgood@hotmail.com>
+- HotariTobu <hotari24tools@gmail.com>
+- Joshua <jbree@users.noreply.github.com>
+- Johan Jeppsson Karlin <johjep@gmail.com>
+- Kazuki Oikawa <k@oikw.org>
+- Kian-Meng Ang <kianmeng@cpan.org>
+- Philipp Klaus <klaus@physik.uni-frankfurt.de>
+- Marcell Pardavi <marcell.pardavi@gmail.com>
+- Matteo Destro <matteo@cerrion.com>
+- Max Ehrlich <max.ehr@gmail.com>
+- Manuel Goacolou <mgoacolou@cls.fr>
+- Julian Schweizer <neuneck@gmail.com>
+- Nikhil Idiculla <nikhilidiculla@gmail.com>
+- Ömer Sezgin Uğurlu <omer@ugurlu.org>
+- Orivej Desh <orivej@gmx.fr>
+- Philipp Krähenbühl <philkr@users.noreply.github.com>
+- Mattia Procopio <promat85@gmail.com>
+- Max Ehrlich <queuecumber@protonmail.com>
+- ramoncaldeira <ramoncaldeira_328@hotmail.com>
+- Roland van Laar <roland@rolandvanlaar.nl>
+- Santiago Castro <sacastro@umich.edu>
+- Kengo Sawatsu <seattleserv0@gmail.com>
+- FirefoxMetzger <sebastian@wallkoetter.net>
+- hyenal <sebastien.ehrhardt@gmail.com>
+- Brendan Long <self@brendanlong.com>; `@brendanlong <https://github.com/brendanlong>`_
+- Семён Марьясин <simeon@maryasin.name>
+- Stephen.Y <stepheny@users.noreply.github.com>
+- Tom Flanagan <theknio@gmail.com>
+- Tim O'Shea <tim.oshea753@gmail.com>
+- Tim Ahpee <timah@blackmagicdesign.com>
+- Jonas Tingeborn <tinjon@gmail.com>
+- Pino Toscano <toscano.pino@tiscali.it>
+- Ulrik Mikaelsson <ulrikm@spotify.com>
+- Vasiliy Kotov <vasiliy.kotov@itechart-group.com>
+- Koichi Akabe <vbkaisetsu@gmail.com>
+- David Joy <videan42@gmail.com>
+- Sviatoslav Sydorenko (Святослав Сидоренко) <webknjaz@redhat.com>
+- Jiabei Zhu <zjb@bu.edu>

.venvs/kimodo/lib/python3.10/site-packages/av-17.1.0.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,23 @@
+Copyright retained by original committers. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the project nor the names of its contributors may be
+      used to endorse or promote products derived from this software without
+      specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY DIRECT,
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

.venvs/kimodo/lib/python3.10/site-packages/av-17.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+av

.venvs/kimodo/lib/python3.10/site-packages/av/subtitles/codeccontext.cpython-310-darwin.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1fa2d53f749326ad90538876b44873c9acb8185f92fa62151f52a37a9abae75b
+size 113952

.venvs/kimodo/lib/python3.10/site-packages/av/subtitles/codeccontext.pxd

@@ -0,0 +1,8 @@
+from av.codec.context cimport CodecContext
+from av.packet cimport Packet
+
+
+cdef class SubtitleCodecContext(CodecContext):
+    cdef bint subtitle_header_set
+    cpdef decode(self, Packet packet=?)
+    cpdef decode2(self, Packet packet)

.venvs/kimodo/lib/python3.10/site-packages/av/subtitles/codeccontext.py

@@ -0,0 +1,146 @@
+import cython
+from cython.cimports import libav as lib
+from cython.cimports.av.buffer import ByteSource, bytesource
+from cython.cimports.av.codec.context import CodecContext
+from cython.cimports.av.error import err_check
+from cython.cimports.av.packet import Packet
+from cython.cimports.av.subtitles.subtitle import SubtitleProxy, SubtitleSet
+from cython.cimports.cpython.bytes import PyBytes_FromStringAndSize
+from cython.cimports.libc.string import memcpy
+
+
+@cython.final
+@cython.cclass
+class SubtitleCodecContext(CodecContext):
+    @property
+    def subtitle_header(self) -> bytes | None:
+        """Get the subtitle header data (ASS/SSA format for text subtitles)."""
+        if (
+            self.ptr.subtitle_header == cython.NULL
+            or self.ptr.subtitle_header_size <= 0
+        ):
+            return None
+        return PyBytes_FromStringAndSize(
+            cython.cast(cython.p_char, self.ptr.subtitle_header),
+            self.ptr.subtitle_header_size,
+        )
+
+    @subtitle_header.setter
+    def subtitle_header(self, data: bytes | None) -> None:
+        """Set the subtitle header data."""
+        source: ByteSource
+        if data is None:
+            lib.av_freep(cython.address(self.ptr.subtitle_header))
+            self.ptr.subtitle_header_size = 0
+        else:
+            source = bytesource(data)
+            self.ptr.subtitle_header = cython.cast(
+                cython.p_uchar,
+                lib.av_realloc(
+                    self.ptr.subtitle_header,
+                    source.length + lib.AV_INPUT_BUFFER_PADDING_SIZE,
+                ),
+            )
+            if not self.ptr.subtitle_header:
+                raise MemoryError("Cannot allocate subtitle_header")
+            memcpy(self.ptr.subtitle_header, source.ptr, source.length)
+            self.ptr.subtitle_header_size = source.length
+        self.subtitle_header_set = True
+
+    def __dealloc__(self) -> None:
+        if self.ptr and self.subtitle_header_set:
+            lib.av_freep(cython.address(self.ptr.subtitle_header))
+
+    def encode_subtitle(self, subtitle: SubtitleSet) -> Packet:
+        """
+        Encode a SubtitleSet into a Packet.
+
+        Args:
+            subtitle: The SubtitleSet to encode
+
+        Returns:
+            A Packet containing the encoded subtitle data
+        """
+        if not self.codec.ptr:
+            raise ValueError("Cannot encode with unknown codec")
+
+        self.open(strict=False)
+
+        buf: cython.p_uchar = cython.cast(cython.p_uchar, lib.av_malloc(1024 * 1024))
+        if buf == cython.NULL:
+            raise MemoryError()
+
+        ret: cython.int = lib.avcodec_encode_subtitle(
+            self.ptr,
+            buf,
+            1024 * 1024,
+            cython.address(subtitle.proxy.struct),
+        )
+        if ret < 0:
+            lib.av_free(buf)
+            err_check(ret, "avcodec_encode_subtitle()")
+
+        packet: Packet = Packet(ret)
+        memcpy(packet.ptr.data, buf, ret)
+        lib.av_free(buf)
+        packet.ptr.pts = subtitle.proxy.struct.pts
+        packet.ptr.dts = subtitle.proxy.struct.pts
+        packet.ptr.duration = (
+            subtitle.proxy.struct.end_display_time
+            - subtitle.proxy.struct.start_display_time
+        )
+
+        return packet
+
+    @cython.ccall
+    def decode(self, packet: Packet | None = None):
+        """Decode a subtitle packet, returning a list of :class:`.Subtitle` objects
+        if a subtitle was decoded, or an empty list otherwise."""
+        if not self.codec.ptr:
+            raise ValueError("cannot decode unknown codec")
+
+        if packet is None:
+            raise RuntimeError("packet cannot be None")
+
+        self.open(strict=False)
+        proxy: SubtitleProxy = SubtitleProxy()
+        got_frame: cython.int = 0
+
+        err_check(
+            lib.avcodec_decode_subtitle2(
+                self.ptr,
+                cython.address(proxy.struct),
+                cython.address(got_frame),
+                packet.ptr,
+            )
+        )
+
+        if got_frame:
+            return list(SubtitleSet(proxy))
+        return []
+
+    @cython.ccall
+    def decode2(self, packet: Packet):
+        """
+        Returns SubtitleSet if you really need it.
+        """
+        if not self.codec.ptr:
+            raise ValueError("cannot decode unknown codec")
+
+        self.open(strict=False)
+
+        proxy: SubtitleProxy = SubtitleProxy()
+        got_frame: cython.int = 0
+
+        err_check(
+            lib.avcodec_decode_subtitle2(
+                self.ptr,
+                cython.address(proxy.struct),
+                cython.address(got_frame),
+                packet.ptr,
+            )
+        )
+
+        if got_frame:
+            return SubtitleSet(proxy)
+        return None

.venvs/kimodo/lib/python3.10/site-packages/av/subtitles/codeccontext.pyi

@@ -0,0 +1,11 @@
+from typing import Literal
+
+from av.codec.context import CodecContext
+from av.packet import Packet
+from av.subtitles.subtitle import SubtitleSet
+
+class SubtitleCodecContext(CodecContext):
+    type: Literal["subtitle"]
+    subtitle_header: bytes | None
+    def decode2(self, packet: Packet) -> SubtitleSet | None: ...
+    def encode_subtitle(self, subtitle: SubtitleSet) -> Packet: ...

.venvs/kimodo/lib/python3.10/site-packages/av/subtitles/stream.pxd

@@ -0,0 +1,6 @@
+from av.packet cimport Packet
+from av.stream cimport Stream
+
+
+cdef class SubtitleStream(Stream):
+    cpdef decode(self, Packet packet=?)

.venvs/kimodo/lib/python3.10/site-packages/av/subtitles/stream.py

@@ -0,0 +1,24 @@
+import cython
+from cython.cimports.av.packet import Packet
+from cython.cimports.av.stream import Stream
+
+
+@cython.final
+@cython.cclass
+class SubtitleStream(Stream):
+    def __getattr__(self, name):
+        return getattr(self.codec_context, name)
+
+    @cython.ccall
+    def decode(self, packet: Packet | None = None):
+        """
+        Decode a :class:`.Packet` and returns a subtitle object.
+
+        :rtype: list[AssSubtitle] | list[BitmapSubtitle]
+
+        .. seealso:: This is a passthrough to :meth:`.CodecContext.decode`.
+        """
+        if not packet:
+            packet = Packet()
+
+        return self.codec_context.decode(packet)

.venvs/kimodo/lib/python3.10/site-packages/av/subtitles/stream.pyi

@@ -0,0 +1,9 @@
+from av.packet import Packet
+from av.stream import Stream
+from av.subtitles.subtitle import AssSubtitle, BitmapSubtitle, SubtitleSet
+
+class SubtitleStream(Stream):
+    def decode(
+        self, packet: Packet | None = None
+    ) -> list[AssSubtitle] | list[BitmapSubtitle]: ...
+    def decode2(self, packet: Packet) -> SubtitleSet | None: ...

.venvs/kimodo/lib/python3.10/site-packages/av/subtitles/subtitle.cpython-310-darwin.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c07eb0987ffc32224604f6a59b7a8a1f911a44222f886bcb9bfea5dd1ef274f7
+size 184416

.venvs/kimodo/lib/python3.10/site-packages/av/subtitles/subtitle.pxd

@@ -0,0 +1,29 @@
+cimport libav as lib
+
+
+cdef class SubtitleProxy:
+    cdef lib.AVSubtitle struct
+
+cdef class SubtitleSet:
+    cdef SubtitleProxy proxy
+    cdef readonly tuple rects
+
+cdef class Subtitle:
+    cdef SubtitleProxy proxy
+    cdef lib.AVSubtitleRect *ptr
+    cdef readonly bytes type
+
+cdef class TextSubtitle(Subtitle):
+    pass
+
+cdef class ASSSubtitle(Subtitle):
+    pass
+
+cdef class BitmapSubtitle(Subtitle):
+    cdef readonly planes
+
+cdef class BitmapSubtitlePlane:
+    cdef readonly BitmapSubtitle subtitle
+    cdef readonly int index
+    cdef readonly long buffer_size
+    cdef void *_buffer

.venvs/kimodo/lib/python3.10/site-packages/av/subtitles/subtitle.py

@@ -0,0 +1,336 @@
+import cython
+from cython.cimports.cpython import PyBuffer_FillInfo, PyBytes_FromString
+from cython.cimports.libc.string import memcpy
+
+
+@cython.final
+@cython.cclass
+class SubtitleProxy:
+    def __dealloc__(self):
+        lib.avsubtitle_free(cython.address(self.struct))
+
+
+_cinit_bypass_sentinel = cython.declare(object, object())
+
+
+@cython.final
+@cython.cclass
+class SubtitleSet:
+    """
+    A :class:`SubtitleSet` can contain many :class:`Subtitle` objects.
+
+    Wraps :ffmpeg:`AVSubtitle`.
+    """
+
+    def __cinit__(self, proxy_or_sentinel=None):
+        if proxy_or_sentinel is _cinit_bypass_sentinel:
+            # Creating empty SubtitleSet for encoding
+            self.proxy = SubtitleProxy()
+            self.rects = ()
+        elif isinstance(proxy_or_sentinel, SubtitleProxy):
+            # Creating from decoded subtitle
+            self.proxy = proxy_or_sentinel
+            self.rects = tuple(
+                build_subtitle(self, i) for i in range(self.proxy.struct.num_rects)
+            )
+        else:
+            raise TypeError(
+                "SubtitleSet requires a SubtitleProxy or use SubtitleSet.create()"
+            )
+
+    @staticmethod
+    def create(
+        text: bytes,
+        start: int,
+        end: int,
+        pts: int = 0,
+        subtitle_format: int = 1,
+    ) -> SubtitleSet:
+        """
+        Create a SubtitleSet for encoding.
+
+        :param text: The subtitle text in ASS dialogue format
+            (e.g. ``b"0,0,Default,,0,0,0,,Hello World"``)
+        :param start: Start display time as offset from pts (typically 0)
+        :param end: End display time as offset from pts (i.e., duration)
+        :param pts: Presentation timestamp in stream time_base units
+        :param subtitle_format: Subtitle format (default 1 for text)
+        :return: A SubtitleSet ready for encoding
+
+        .. note::
+            All timing values should be in stream time_base units.
+            For MKV (time_base=1/1000), units are milliseconds.
+            For MP4 (time_base=1/1000000), units are microseconds.
+        """
+        subset: SubtitleSet = SubtitleSet(_cinit_bypass_sentinel)
+
+        subset.proxy.struct.format = subtitle_format
+        subset.proxy.struct.start_display_time = start
+        subset.proxy.struct.end_display_time = end
+        subset.proxy.struct.pts = pts
+
+        subset.proxy.struct.num_rects = 1
+        subset.proxy.struct.rects = cython.cast(
+            cython.pointer[cython.pointer[lib.AVSubtitleRect]],
+            lib.av_mallocz(cython.sizeof(cython.pointer[lib.AVSubtitleRect])),
+        )
+        if subset.proxy.struct.rects == cython.NULL:
+            raise MemoryError("Failed to allocate subtitle rects array")
+
+        rect: cython.pointer[lib.AVSubtitleRect] = cython.cast(
+            cython.pointer[lib.AVSubtitleRect],
+            lib.av_mallocz(cython.sizeof(lib.AVSubtitleRect)),
+        )
+        if rect == cython.NULL:
+            lib.av_free(subset.proxy.struct.rects)
+            subset.proxy.struct.rects = cython.NULL
+            raise MemoryError("Failed to allocate subtitle rect")
+
+        subset.proxy.struct.rects[0] = rect
+
+        rect.x = 0
+        rect.y = 0
+        rect.w = 0
+        rect.h = 0
+        rect.nb_colors = 0
+        rect.type = lib.SUBTITLE_ASS
+        rect.text = cython.NULL
+        rect.flags = 0
+
+        text_len: cython.Py_ssize_t = len(text)
+        rect.ass = cython.cast(cython.p_char, lib.av_malloc(text_len + 1))
+        if rect.ass == cython.NULL:
+            raise MemoryError("Failed to allocate subtitle text")
+        memcpy(rect.ass, cython.cast(cython.p_char, text), text_len)
+        rect.ass[text_len] = 0
+
+        subset.rects = (AssSubtitle(subset, 0),)
+
+        return subset
+
+    def __repr__(self):
+        return (
+            f"<{self.__class__.__module__}.{self.__class__.__name__} at 0x{id(self):x}>"
+        )
+
+    @property
+    def format(self):
+        return self.proxy.struct.format
+
+    @format.setter
+    def format(self, value: int):
+        self.proxy.struct.format = value
+
+    @property
+    def start_display_time(self):
+        return self.proxy.struct.start_display_time
+
+    @start_display_time.setter
+    def start_display_time(self, value: int):
+        self.proxy.struct.start_display_time = value
+
+    @property
+    def end_display_time(self):
+        return self.proxy.struct.end_display_time
+
+    @end_display_time.setter
+    def end_display_time(self, value: int):
+        self.proxy.struct.end_display_time = value
+
+    @property
+    def pts(self):
+        """Same as packet pts, in av.time_base."""
+        return self.proxy.struct.pts
+
+    @pts.setter
+    def pts(self, value: int):
+        self.proxy.struct.pts = value
+
+    def __len__(self):
+        return len(self.rects)
+
+    def __iter__(self):
+        return iter(self.rects)
+
+    def __getitem__(self, i):
+        return self.rects[i]
+
+
+@cython.cfunc
+def build_subtitle(subtitle: SubtitleSet, index: cython.int) -> Subtitle:
+    """Build an av.Stream for an existing AVStream.
+
+    The AVStream MUST be fully constructed and ready for use before this is called.
+    """
+    if index < 0 or cython.cast(cython.uint, index) >= subtitle.proxy.struct.num_rects:
+        raise ValueError("subtitle rect index out of range")
+
+    ptr: cython.pointer[lib.AVSubtitleRect] = subtitle.proxy.struct.rects[index]
+
+    if ptr.type == lib.SUBTITLE_BITMAP:
+        return BitmapSubtitle(subtitle, index)
+    if ptr.type == lib.SUBTITLE_ASS or ptr.type == lib.SUBTITLE_TEXT:
+        return AssSubtitle(subtitle, index)
+
+    raise ValueError("unknown subtitle type %r" % ptr.type)
+
+
+@cython.cclass
+class Subtitle:
+    """
+    An abstract base class for each concrete type of subtitle.
+    Wraps :ffmpeg:`AVSubtitleRect`
+    """
+
+    def __cinit__(self, subtitle: SubtitleSet, index: cython.int):
+        if (
+            index < 0
+            or cython.cast(cython.uint, index) >= subtitle.proxy.struct.num_rects
+        ):
+            raise ValueError("subtitle rect index out of range")
+        self.proxy = subtitle.proxy
+        self.ptr = self.proxy.struct.rects[index]
+
+        if self.ptr.type == lib.SUBTITLE_NONE:
+            self.type = b"none"
+        elif self.ptr.type == lib.SUBTITLE_BITMAP:
+            self.type = b"bitmap"
+        elif self.ptr.type == lib.SUBTITLE_TEXT:
+            self.type = b"text"
+        elif self.ptr.type == lib.SUBTITLE_ASS:
+            self.type = b"ass"
+        else:
+            raise ValueError(f"unknown subtitle type {self.ptr.type!r}")
+
+    def __repr__(self):
+        return f"<av.{self.__class__.__name__} at 0x{id(self):x}>"
+
+
+@cython.final
+@cython.cclass
+class BitmapSubtitle(Subtitle):
+    def __cinit__(self, subtitle: SubtitleSet, index: cython.int):
+        self.planes = tuple(
+            BitmapSubtitlePlane(self, i) for i in range(4) if self.ptr.linesize[i]
+        )
+
+    def __repr__(self):
+        return (
+            f"<{self.__class__.__module__}.{self.__class__.__name__} "
+            f"{self.width}x{self.height} at {self.x},{self.y}; at 0x{id(self):x}>"
+        )
+
+    @property
+    def x(self):
+        return self.ptr.x
+
+    @property
+    def y(self):
+        return self.ptr.y
+
+    @property
+    def width(self):
+        return self.ptr.w
+
+    @property
+    def height(self):
+        return self.ptr.h
+
+    @property
+    def nb_colors(self):
+        return self.ptr.nb_colors
+
+    def __len__(self):
+        return len(self.planes)
+
+    def __iter__(self):
+        return iter(self.planes)
+
+    def __getitem__(self, i):
+        return self.planes[i]
+
+
+@cython.final
+@cython.cclass
+class BitmapSubtitlePlane:
+    def __cinit__(self, subtitle: BitmapSubtitle, index: cython.int):
+        if index >= 4:
+            raise ValueError("BitmapSubtitles have only 4 planes")
+        if not subtitle.ptr.linesize[index]:
+            raise ValueError("plane does not exist")
+
+        self.subtitle = subtitle
+        self.index = index
+        self.buffer_size = subtitle.ptr.w * subtitle.ptr.h
+        self._buffer = cython.cast(cython.p_void, subtitle.ptr.data[index])
+
+    # New-style buffer support.
+    def __getbuffer__(self, view: cython.pointer[Py_buffer], flags: cython.int):
+        PyBuffer_FillInfo(view, self, self._buffer, self.buffer_size, 0, flags)
+
+
+@cython.final
+@cython.cclass
+class AssSubtitle(Subtitle):
+    """
+    Represents an ASS/Text subtitle format, as opposed to a bitmap Subtitle format.
+    """
+
+    def __repr__(self):
+        return f"<av.AssSubtitle {self.dialogue!r} at 0x{id(self):x}>"
+
+    @property
+    def ass(self):
+        """
+        Returns the subtitle in the ASS/SSA format. Used by the vast majority of subtitle formats.
+        """
+        if self.ptr.ass is not cython.NULL:
+            return PyBytes_FromString(self.ptr.ass)
+        return b""
+
+    @property
+    def dialogue(self):
+        """
+        Extract the dialogue from the ass format. Strip comments.
+        """
+        comma_count: cython.short = 0
+        i: cython.Py_ssize_t = 0
+        state: cython.bint = False
+        ass_text: bytes = self.ass
+        char, next_char = cython.declare(cython.uchar)
+        result: bytearray = bytearray()
+        text_len: cython.Py_ssize_t = len(ass_text)
+
+        while comma_count < 8 and i < text_len:
+            if ass_text[i] == b","[0]:
+                comma_count += 1
+            i += 1
+
+        while i < text_len:
+            char = ass_text[i]
+            next_char = 0 if i + 1 >= text_len else ass_text[i + 1]
+
+            if char == b"\\"[0] and next_char == b"N"[0]:
+                result.append(b"\n"[0])
+                i += 2
+                continue
+
+            if not state:
+                if char == b"{"[0] and next_char != b"\\"[0]:
+                    state = True
+                else:
+                    result.append(char)
+            elif char == b"}"[0]:
+                state = False
+            i += 1
+
+        return bytes(result)
+
+    @property
+    def text(self):
+        """
+        Rarely used attribute. You're probably looking for dialogue.
+        """
+        if self.ptr.text is not cython.NULL:
+            return PyBytes_FromString(self.ptr.text)
+        return b""

.venvs/kimodo/lib/python3.10/site-packages/av/subtitles/subtitle.pyi

@@ -0,0 +1,45 @@
+from typing import Iterator, Literal
+
+class SubtitleSet:
+    format: int
+    start_display_time: int
+    end_display_time: int
+    pts: int
+    rects: tuple[Subtitle, ...]
+
+    @staticmethod
+    def create(
+        text: bytes,
+        start: int,
+        end: int,
+        pts: int = 0,
+        subtitle_format: int = 1,
+    ) -> SubtitleSet: ...
+    def __len__(self) -> int: ...
+    def __iter__(self) -> Iterator[Subtitle]: ...
+    def __getitem__(self, i: int) -> Subtitle: ...
+
+class Subtitle: ...
+
+class BitmapSubtitle(Subtitle):
+    type: Literal[b"bitmap"]
+    x: int
+    y: int
+    width: int
+    height: int
+    nb_colors: int
+    planes: tuple[BitmapSubtitlePlane, ...]
+
+class BitmapSubtitlePlane:
+    subtitle: BitmapSubtitle
+    index: int
+    buffer_size: int
+
+class AssSubtitle(Subtitle):
+    type: Literal[b"ass", b"text"]
+    @property
+    def ass(self) -> bytes: ...
+    @property
+    def dialogue(self) -> bytes: ...
+    @property
+    def text(self) -> bytes: ...

.venvs/kimodo/lib/python3.10/site-packages/av/utils.pxd

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

.venvs/kimodo/lib/python3.10/site-packages/av/utils.py

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

.venvs/kimodo/lib/python3.10/site-packages/av/video/__init__.py

@@ -0,0 +1,2 @@
+from .frame import VideoFrame as VideoFrame
+from .stream import VideoStream as VideoStream

.venvs/kimodo/lib/python3.10/site-packages/av/video/__init__.pyi

@@ -0,0 +1,17 @@
+from typing import Literal
+
+from .frame import VideoFrame
+from .stream import VideoStream
+
+_VideoCodecName = Literal[
+    "gif",
+    "h264",
+    "hevc",
+    "libvpx",
+    "libx264",
+    "mpeg4",
+    "png",
+    "qtrle",
+]
+
+__all__ = ("VideoFrame", "VideoStream")

.venvs/kimodo/lib/python3.10/site-packages/av/video/codeccontext.cpython-310-darwin.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6f9625f10c54a499738ffd9753317ff4bccf860c3677b20fcdb18a728147ee77
+size 137680

.venvs/kimodo/lib/python3.10/site-packages/av/video/codeccontext.pxd

@@ -0,0 +1,21 @@
+cimport libav as lib
+
+from av.codec.context cimport CodecContext
+from av.video.format cimport VideoFormat
+from av.video.frame cimport VideoFrame
+from av.video.reformatter cimport VideoReformatter
+
+
+# The get_format callback in AVCodecContext is called by the decoder to pick a format out of a list.
+# When we want accelerated decoding, we need to figure out ahead of time what the format should be,
+# and find a way to pass that into our callback so we can return it to the decoder. We use the 'opaque'
+# user data field in AVCodecContext for that. This is the struct we store a pointer to in that field.
+cdef struct AVCodecPrivateData:
+    lib.AVPixelFormat hardware_pix_fmt
+    bint allow_software_fallback
+
+
+cdef class VideoCodecContext(CodecContext):
+    cdef AVCodecPrivateData _private_data
+    cdef readonly VideoReformatter reformatter
+    cdef VideoFrame next_frame

.venvs/kimodo/lib/python3.10/site-packages/av/video/codeccontext.py

@@ -0,0 +1,396 @@
+import cython
+import cython.cimports.libav as lib
+from cython.cimports.av.codec.context import CodecContext
+from cython.cimports.av.codec.hwaccel import HWAccel
+from cython.cimports.av.error import err_check
+from cython.cimports.av.frame import Frame
+from cython.cimports.av.packet import Packet
+from cython.cimports.av.utils import avrational_to_fraction, to_avrational
+from cython.cimports.av.video.format import VideoFormat, get_pix_fmt, get_video_format
+from cython.cimports.av.video.frame import VideoFrame, alloc_video_frame
+from cython.cimports.av.video.reformatter import VideoReformatter
+from cython.cimports.libc.stdint import int64_t
+
+
+@cython.cfunc
+@cython.exceptval(check=False)
+def _get_hw_format(
+    ctx: cython.pointer[lib.AVCodecContext],
+    pix_fmts: cython.pointer[cython.const[lib.AVPixelFormat]],
+) -> lib.AVPixelFormat:
+    # In the case where we requested accelerated decoding, the decoder first calls this function
+    # with a list that includes both the hardware format and software formats.
+    # First we try to pick the hardware format if it's in the list.
+    # However, if the decoder fails to initialize the hardware, it will call this function again,
+    # with only software formats in pix_fmts. We return ctx->sw_pix_fmt regardless in this case,
+    # because that should be in the candidate list. If not, we are out of ideas anyways.
+    private_data: cython.pointer[AVCodecPrivateData] = cython.cast(
+        cython.pointer[AVCodecPrivateData], ctx.opaque
+    )
+    i: cython.int = 0
+    while pix_fmts[i] != -1:
+        if pix_fmts[i] == private_data.hardware_pix_fmt:
+            return pix_fmts[i]
+        i += 1
+    return (
+        ctx.sw_pix_fmt if private_data.allow_software_fallback else lib.AV_PIX_FMT_NONE
+    )
+
+
+@cython.final
+@cython.cclass
+class VideoCodecContext(CodecContext):
+    @cython.cfunc
+    def _init(
+        self,
+        ptr: cython.pointer[lib.AVCodecContext],
+        codec: cython.pointer[cython.const[lib.AVCodec]],
+        hwaccel: HWAccel | None,
+    ):
+        CodecContext._init(self, ptr, codec, hwaccel)
+
+        if hwaccel is not None:
+            try:
+                self.hwaccel_ctx = hwaccel.create(self.codec)
+                self.ptr.hw_device_ctx = lib.av_buffer_ref(self.hwaccel_ctx.ptr)
+                self.ptr.pix_fmt = self.hwaccel_ctx.config.ptr.pix_fmt
+                self.ptr.get_format = _get_hw_format
+                self._private_data.hardware_pix_fmt = (
+                    self.hwaccel_ctx.config.ptr.pix_fmt
+                )
+                self._private_data.allow_software_fallback = (
+                    self.hwaccel.allow_software_fallback
+                )
+                self.ptr.opaque = cython.address(self._private_data)
+            except NotImplementedError:
+                # Some streams may not have a hardware decoder. For example, many action
+                # cam videos have a low resolution mjpeg stream, which is usually not
+                # compatible with hardware decoders.
+                # The user may have passed in a hwaccel because they want to decode the main
+                # stream with it, so we shouldn't abort even if we find a stream that can't
+                # be HW decoded.
+                # If the user wants to make sure hwaccel is actually used, they can check with the
+                # is_hwaccel() function on each stream's codec context.
+                self.hwaccel_ctx = None
+
+    @cython.cfunc
+    def _prepare_frames_for_encode(self, input: Frame | None) -> list:
+        if input is None or not input:
+            return [None]
+
+        vframe: VideoFrame = input
+        if (
+            vframe.format.pix_fmt != self.pix_fmt
+            or vframe.width != self.ptr.width
+            or vframe.height != self.ptr.height
+        ):
+            if not self.reformatter:
+                self.reformatter = VideoReformatter()
+
+            vframe = self.reformatter.reformat(
+                vframe,
+                self.ptr.width,
+                self.ptr.height,
+                self.format,
+                threads=self.ptr.thread_count,
+            )
+
+        if vframe.ptr.pts == lib.AV_NOPTS_VALUE:
+            vframe.ptr.pts = self.ptr.frame_num
+
+        return [vframe]
+
+    @cython.cfunc
+    def _alloc_next_frame(self) -> Frame:
+        return alloc_video_frame()
+
+    @cython.cfunc
+    def _setup_decoded_frame(self, frame: Frame, packet: Packet):
+        CodecContext._setup_decoded_frame(self, frame, packet)
+        vframe: VideoFrame = frame
+        vframe._init_user_attributes()
+
+    @cython.cfunc
+    def _transfer_hwframe(self, frame: Frame):
+        if self.hwaccel_ctx is None:
+            return frame
+        if frame.ptr.format != self.hwaccel_ctx.config.ptr.pix_fmt:
+            # If we get a software frame, that means we are in software fallback mode, and don't actually
+            # need to transfer.
+            return frame
+
+        if self.hwaccel_ctx.is_hw_owned:
+            cython.cast(VideoFrame, frame)._device_id = self.hwaccel_ctx.device_id
+            return frame
+
+        frame_sw: Frame = self._alloc_next_frame()
+        err_check(lib.av_hwframe_transfer_data(frame_sw.ptr, frame.ptr, 0))
+        # TODO: Is there anything else to transfer?
+        frame_sw.pts = frame.pts
+        return frame_sw
+
+    @property
+    def format(self):
+        return get_video_format(
+            cython.cast(lib.AVPixelFormat, self.ptr.pix_fmt),
+            self.ptr.width,
+            self.ptr.height,
+        )
+
+    @format.setter
+    def format(self, format: VideoFormat):
+        self.ptr.pix_fmt = format.pix_fmt
+        self.ptr.width = format.width
+        self.ptr.height = format.height
+
+    @property
+    def width(self):
+        if self.ptr is cython.NULL:
+            return 0
+        return self.ptr.width
+
+    @width.setter
+    def width(self, value: cython.uint):
+        self.ptr.width = value
+
+    @property
+    def height(self):
+        if self.ptr is cython.NULL:
+            return 0
+        return self.ptr.height
+
+    @height.setter
+    def height(self, value: cython.uint):
+        self.ptr.height = value
+
+    @property
+    def bits_per_coded_sample(self):
+        """
+        The number of bits per sample in the codedwords. It's mandatory for this to be set for some formats to decode properly.
+
+        Wraps :ffmpeg:`AVCodecContext.bits_per_coded_sample`.
+
+        :type: int
+        """
+        return self.ptr.bits_per_coded_sample
+
+    @bits_per_coded_sample.setter
+    def bits_per_coded_sample(self, value: cython.int):
+        if self.is_encoder:
+            raise ValueError("Not supported for encoders")
+
+        self.ptr.bits_per_coded_sample = value
+
+    @property
+    def pix_fmt(self):
+        """
+        The pixel format's name.
+
+        :type: str | None
+        """
+        desc: cython.pointer[cython.const[lib.AVPixFmtDescriptor]] = (
+            lib.av_pix_fmt_desc_get(cython.cast(lib.AVPixelFormat, self.ptr.pix_fmt))
+        )
+        return cython.cast(str, desc.name)
+
+    @pix_fmt.setter
+    def pix_fmt(self, value):
+        self.ptr.pix_fmt = get_pix_fmt(value)
+
+    @property
+    def framerate(self):
+        """
+        The frame rate, in frames per second.
+
+        :type: fractions.Fraction
+        """
+        return avrational_to_fraction(cython.address(self.ptr.framerate))
+
+    @framerate.setter
+    def framerate(self, value):
+        to_avrational(value, cython.address(self.ptr.framerate))
+
+    @property
+    def rate(self):
+        """Another name for :attr:`framerate`."""
+        return self.framerate
+
+    @rate.setter
+    def rate(self, value):
+        self.framerate = value
+
+    @property
+    def gop_size(self):
+        """
+        Sets the number of frames between keyframes. Used only for encoding.
+
+        :type: int
+        """
+        if self.is_decoder:
+            raise RuntimeError("Cannot access 'gop_size' as a decoder")
+        return self.ptr.gop_size
+
+    @gop_size.setter
+    def gop_size(self, value: cython.int):
+        if self.is_decoder:
+            raise RuntimeError("Cannot access 'gop_size' as a decoder")
+        self.ptr.gop_size = value
+
+    @property
+    def sample_aspect_ratio(self):
+        return avrational_to_fraction(cython.address(self.ptr.sample_aspect_ratio))
+
+    @sample_aspect_ratio.setter
+    def sample_aspect_ratio(self, value):
+        to_avrational(value, cython.address(self.ptr.sample_aspect_ratio))
+
+    @property
+    def display_aspect_ratio(self):
+        dar: lib.AVRational
+        lib.av_reduce(
+            cython.address(dar.num),
+            cython.address(dar.den),
+            self.ptr.width * self.ptr.sample_aspect_ratio.num,
+            self.ptr.height * self.ptr.sample_aspect_ratio.den,
+            1024 * 1024,
+        )
+
+        return avrational_to_fraction(cython.address(dar))
+
+    @property
+    def has_b_frames(self):
+        """
+        :type: bool
+        """
+        return bool(self.ptr.has_b_frames)
+
+    @property
+    def reorder_depth(self):
+        """Raw ``has_b_frames`` value from FFmpeg (int, not bool).
+
+        After :meth:`flush_buffers`, FFmpeg may reset the internal reorder
+        heuristic. Set this to the known reorder depth *after* seeking to
+        avoid dropped hierarchical B-frames.
+        """
+        return self.ptr.has_b_frames
+
+    @reorder_depth.setter
+    def reorder_depth(self, value: cython.int):
+        self.ptr.has_b_frames = value
+
+    @property
+    def coded_width(self):
+        """
+        :type: int
+        """
+        return self.ptr.coded_width
+
+    @property
+    def coded_height(self):
+        """
+        :type: int
+        """
+        return self.ptr.coded_height
+
+    @property
+    def color_range(self):
+        """
+        Describes the signal range of the colorspace.
+
+        Wraps :ffmpeg:`AVFrame.color_range`.
+
+        :type: int
+        """
+        return self.ptr.color_range
+
+    @color_range.setter
+    def color_range(self, value):
+        self.ptr.color_range = value
+
+    @property
+    def color_primaries(self):
+        """
+        Describes the RGB/XYZ matrix of the colorspace.
+
+        Wraps :ffmpeg:`AVFrame.color_primaries`.
+
+        :type: int
+        """
+        return self.ptr.color_primaries
+
+    @color_primaries.setter
+    def color_primaries(self, value):
+        self.ptr.color_primaries = value
+
+    @property
+    def color_trc(self):
+        """
+        Describes the linearization function (a.k.a. transformation characteristics) of the colorspace.
+
+        Wraps :ffmpeg:`AVFrame.color_trc`.
+
+        :type: int
+        """
+        return self.ptr.color_trc
+
+    @color_trc.setter
+    def color_trc(self, value):
+        self.ptr.color_trc = value
+
+    @property
+    def colorspace(self):
+        """
+        Describes the YUV/RGB transformation matrix of the colorspace.
+
+        Wraps :ffmpeg:`AVFrame.colorspace`.
+
+        :type: int
+        """
+        return self.ptr.colorspace
+
+    @colorspace.setter
+    def colorspace(self, value):
+        self.ptr.colorspace = value
+
+    @property
+    def max_b_frames(self):
+        """
+        The maximum run of consecutive B frames when encoding a video.
+
+        :type: int
+        """
+        return self.ptr.max_b_frames
+
+    @max_b_frames.setter
+    def max_b_frames(self, value):
+        self.ptr.max_b_frames = value
+
+    @property
+    def qmin(self):
+        """
+        The minimum quantiser value of an encoded stream.
+
+        Wraps :ffmpeg:`AVCodecContext.qmin`.
+
+        :type: int
+        """
+        return self.ptr.qmin
+
+    @qmin.setter
+    def qmin(self, value):
+        self.ptr.qmin = value
+
+    @property
+    def qmax(self):
+        """
+        The maximum quantiser value of an encoded stream.
+
+        Wraps :ffmpeg:`AVCodecContext.qmax`.
+
+        :type: int
+        """
+        return self.ptr.qmax
+
+    @qmax.setter
+    def qmax(self, value):
+        self.ptr.qmax = value

.venvs/kimodo/lib/python3.10/site-packages/av/video/codeccontext.pyi

@@ -0,0 +1,36 @@
+from fractions import Fraction
+from typing import Iterator, Literal
+
+from av.codec.context import CodecContext
+from av.packet import Packet
+
+from .format import VideoFormat
+from .frame import VideoFrame
+
+class VideoCodecContext(CodecContext):
+    format: VideoFormat | None
+    width: int
+    height: int
+    bits_per_coded_sample: int
+    pix_fmt: str | None
+    framerate: Fraction
+    rate: Fraction
+    gop_size: int
+    sample_aspect_ratio: Fraction | None
+    display_aspect_ratio: Fraction | None
+    has_b_frames: bool
+    reorder_depth: int
+    max_b_frames: int
+    coded_width: int
+    coded_height: int
+    color_range: int
+    color_primaries: int
+    color_trc: int
+    colorspace: int
+    qmin: int
+    qmax: int
+    type: Literal["video"]
+
+    def encode(self, frame: VideoFrame | None = None) -> list[Packet]: ...
+    def encode_lazy(self, frame: VideoFrame | None = None) -> Iterator[Packet]: ...
+    def decode(self, packet: Packet | None = None) -> list[VideoFrame]: ...

.venvs/kimodo/lib/python3.10/site-packages/av/video/format.cpython-310-darwin.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3aed2c1a5eacab306f44e66e06d8433244a62ea15cb62ac7ebf545793bbc6140
+size 142592

.venvs/kimodo/lib/python3.10/site-packages/av/video/format.pxd

@@ -0,0 +1,20 @@
+cimport libav as lib
+
+
+cdef class VideoFormat:
+    cdef lib.AVPixelFormat pix_fmt
+    cdef const lib.AVPixFmtDescriptor *ptr
+    cdef readonly unsigned int width, height
+    cdef _init(self, lib.AVPixelFormat pix_fmt, unsigned int width, unsigned int height)
+    cpdef chroma_width(self, int luma_width=?)
+    cpdef chroma_height(self, int luma_height=?)
+
+
+cdef class VideoFormatComponent:
+    cdef VideoFormat format
+    cdef readonly unsigned int index
+    cdef const lib.AVComponentDescriptor *ptr
+
+
+cdef VideoFormat get_video_format(lib.AVPixelFormat c_format, unsigned int width, unsigned int height)
+cdef lib.AVPixelFormat get_pix_fmt(const char *name) except lib.AV_PIX_FMT_NONE

.venvs/kimodo/lib/python3.10/site-packages/av/video/format.py

@@ -0,0 +1,209 @@
+import cython
+from cython import uint as cuint
+
+_cinit_bypass_sentinel = cython.declare(object, object())
+
+
+@cython.cfunc
+def get_video_format(
+    c_format: lib.AVPixelFormat, width: cuint, height: cuint
+) -> VideoFormat | None:
+    if c_format == lib.AV_PIX_FMT_NONE:
+        return None
+
+    format: VideoFormat = VideoFormat.__new__(VideoFormat, _cinit_bypass_sentinel)
+    format._init(c_format, width, height)
+    return format
+
+
+@cython.cfunc
+@cython.exceptval(lib.AV_PIX_FMT_NONE, check=False)
+def get_pix_fmt(name: cython.p_const_char) -> lib.AVPixelFormat:
+    """Wrapper for lib.av_get_pix_fmt with error checking."""
+
+    pix_fmt: lib.AVPixelFormat = lib.av_get_pix_fmt(name)
+    if pix_fmt == lib.AV_PIX_FMT_NONE:
+        raise ValueError("not a pixel format: %r" % name)
+    return pix_fmt
+
+
+@cython.final
+@cython.cclass
+class VideoFormat:
+    """
+
+    >>> format = VideoFormat('rgb24')
+    >>> format.name
+    'rgb24'
+
+    """
+
+    def __cinit__(self, name, width=0, height=0):
+        if name is _cinit_bypass_sentinel:
+            return
+
+        if isinstance(name, VideoFormat):
+            other: VideoFormat = cython.cast(VideoFormat, name)
+            self._init(other.pix_fmt, width or other.width, height or other.height)
+            return
+
+        pix_fmt: lib.AVPixelFormat = get_pix_fmt(name)
+        self._init(pix_fmt, width, height)
+
+    @cython.cfunc
+    def _init(self, pix_fmt: lib.AVPixelFormat, width: cuint, height: cuint):
+        self.pix_fmt = pix_fmt
+        self.ptr = lib.av_pix_fmt_desc_get(pix_fmt)
+        self.width = width
+        self.height = height
+
+    def __repr__(self):
+        if self.width or self.height:
+            return f"<av.{self.__class__.__name__} {self.name}, {self.width}x{self.height}>"
+        else:
+            return f"<av.{self.__class__.__name__} {self.name}>"
+
+    def __int__(self):
+        return int(self.pix_fmt)
+
+    @property
+    def name(self):
+        """Canonical name of the pixel format."""
+        return cython.cast(str, self.ptr.name)
+
+    @property
+    def components(self):
+        return tuple(
+            VideoFormatComponent(self, i) for i in range(self.ptr.nb_components)
+        )
+
+    @property
+    def bits_per_pixel(self):
+        return lib.av_get_bits_per_pixel(self.ptr)
+
+    @property
+    def padded_bits_per_pixel(self):
+        return lib.av_get_padded_bits_per_pixel(self.ptr)
+
+    @property
+    def is_big_endian(self):
+        """Pixel format is big-endian."""
+        return bool(self.ptr.flags & lib.AV_PIX_FMT_FLAG_BE)
+
+    @property
+    def has_palette(self):
+        """Pixel format has a palette in data[1], values are indexes in this palette."""
+        return bool(self.ptr.flags & lib.AV_PIX_FMT_FLAG_PAL)
+
+    @property
+    def is_bit_stream(self):
+        """All values of a component are bit-wise packed end to end."""
+        return bool(self.ptr.flags & lib.AV_PIX_FMT_FLAG_BITSTREAM)
+
+    @property
+    def is_planar(self):
+        """At least one pixel component is not in the first data plane."""
+        return bool(self.ptr.flags & lib.AV_PIX_FMT_FLAG_PLANAR)
+
+    @property
+    def is_rgb(self):
+        """The pixel format contains RGB-like data (as opposed to YUV/grayscale)."""
+        return bool(self.ptr.flags & lib.AV_PIX_FMT_FLAG_RGB)
+
+    @property
+    def is_bayer(self):
+        """The pixel format contains Bayer data."""
+        return bool(self.ptr.flags & lib.AV_PIX_FMT_FLAG_BAYER)
+
+    @cython.ccall
+    def chroma_width(self, luma_width: cython.int = 0):
+        """chroma_width(luma_width=0)
+
+        Width of a chroma plane relative to a luma plane.
+
+        :param int luma_width: Width of the luma plane; defaults to ``self.width``.
+
+        """
+        luma_width = luma_width or self.width
+        return -((-luma_width) >> self.ptr.log2_chroma_w) if luma_width else 0
+
+    @cython.ccall
+    def chroma_height(self, luma_height: cython.int = 0):
+        """chroma_height(luma_height=0)
+
+        Height of a chroma plane relative to a luma plane.
+
+        :param int luma_height: Height of the luma plane; defaults to ``self.height``.
+
+        """
+        luma_height = luma_height or self.height
+        return -((-luma_height) >> self.ptr.log2_chroma_h) if luma_height else 0
+
+
+@cython.final
+@cython.cclass
+class VideoFormatComponent:
+    def __cinit__(self, format: VideoFormat, index: cython.size_t):
+        self.format = format
+        self.index = index
+        self.ptr = cython.address(format.ptr.comp[index])
+
+    @property
+    def plane(self):
+        """The index of the plane which contains this component."""
+        return self.ptr.plane
+
+    @property
+    def bits(self):
+        """Number of bits in the component."""
+        return self.ptr.depth
+
+    @property
+    def is_alpha(self):
+        """Is this component an alpha channel?"""
+        return (self.index == 1 and self.format.ptr.nb_components == 2) or (
+            self.index == 3 and self.format.ptr.nb_components == 4
+        )
+
+    @property
+    def is_luma(self):
+        """Is this component a luma channel?"""
+        return self.index == 0 and (
+            self.format.ptr.nb_components == 1
+            or self.format.ptr.nb_components == 2
+            or not self.format.is_rgb
+        )
+
+    @property
+    def is_chroma(self):
+        """Is this component a chroma channel?"""
+        return (self.index == 1 or self.index == 2) and (
+            self.format.ptr.log2_chroma_w or self.format.ptr.log2_chroma_h
+        )
+
+    @property
+    def width(self):
+        """The width of this component's plane.
+
+        Requires the parent :class:`VideoFormat` to have a width.
+
+        """
+        return self.format.chroma_width() if self.is_chroma else self.format.width
+
+    @property
+    def height(self):
+        """The height of this component's plane.
+
+        Requires the parent :class:`VideoFormat` to have a height.
+
+        """
+        return self.format.chroma_height() if self.is_chroma else self.format.height
+
+
+names = set()
+desc = cython.declare(cython.pointer[cython.const[lib.AVPixFmtDescriptor]], cython.NULL)
+while True:
+    desc = lib.av_pix_fmt_desc_next(desc)
+    if not desc:
+        break
+    names.add(desc.name)

.venvs/kimodo/lib/python3.10/site-packages/av/video/format.pyi

@@ -0,0 +1,30 @@
+class VideoFormat:
+    name: str
+    bits_per_pixel: int
+    padded_bits_per_pixel: int
+    is_big_endian: bool
+    has_palette: bool
+    is_bit_stream: bool
+    is_planar: bool
+    width: int
+    height: int
+    @property
+    def components(self) -> tuple[VideoFormatComponent, ...]: ...
+    @property
+    def is_rgb(self) -> bool: ...
+    @property
+    def is_bayer(self) -> bool: ...
+    def __init__(self, name: str, width: int = 0, height: int = 0) -> None: ...
+    def chroma_width(self, luma_width: int = 0) -> int: ...
+    def chroma_height(self, luma_height: int = 0) -> int: ...
+
+class VideoFormatComponent:
+    plane: int
+    bits: int
+    is_alpha: bool
+    is_luma: bool
+    is_chroma: bool
+    width: int
+    height: int
+
+    def __init__(self, format: VideoFormat, index: int) -> None: ...

.venvs/kimodo/lib/python3.10/site-packages/av/video/frame.cpython-310-darwin.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1acbdb7f3a36ab3eba5cdca0d7d4b5d5f4e59a657aa024fa035ee2ae060c5f88
+size 413152

.venvs/kimodo/lib/python3.10/site-packages/av/video/frame.pxd

@@ -0,0 +1,28 @@
+cimport libav as lib
+from libc.stdint cimport uint8_t
+
+from av.frame cimport Frame
+from av.video.format cimport VideoFormat
+from av.video.reformatter cimport VideoReformatter
+
+
+cdef class CudaContext:
+    cdef readonly int device_id
+    cdef readonly bint primary_ctx
+    cdef lib.AVBufferRef* _device_ref
+    cdef dict _frames_cache
+    cdef lib.AVBufferRef* _get_device_ref(self)
+    cdef public lib.AVBufferRef* get_frames_ctx(
+        self, lib.AVPixelFormat sw_fmt, int width, int height
+    )
+
+cdef class VideoFrame(Frame):
+    cdef CudaContext _cuda_ctx
+    cdef VideoReformatter reformatter
+    cdef readonly VideoFormat format
+    cdef readonly int _device_id
+    cdef _init(self, lib.AVPixelFormat format, unsigned int width, unsigned int height)
+    cdef _init_user_attributes(self)
+    cpdef save(self, object filepath)
+
+cdef VideoFrame alloc_video_frame()

.venvs/kimodo/lib/python3.10/site-packages/av/video/frame.py

@@ -0,0 +1,1631 @@
+import sys
+from enum import IntEnum
+
+import cython
+import cython.cimports.libav as lib
+from cython.cimports.av.dictionary import Dictionary
+from cython.cimports.av.error import err_check
+from cython.cimports.av.sidedata.sidedata import get_display_rotation
+from cython.cimports.av.utils import check_ndarray
+from cython.cimports.av.video.format import get_pix_fmt, get_video_format
+from cython.cimports.av.video.plane import DLManagedTensor, VideoPlane, kCPU, kCuda
+from cython.cimports.cpython.exc import PyErr_Clear
+from cython.cimports.cpython.pycapsule import (
+    PyCapsule_GetPointer,
+    PyCapsule_IsValid,
+    PyCapsule_SetName,
+)
+from cython.cimports.cpython.ref import Py_DECREF, Py_INCREF
+from cython.cimports.libc.stdint import int64_t, uint8_t
+
+
+@cython.final
+@cython.cclass
+class CudaContext:
+    def __cinit__(self, device_id: cython.int = 0, primary_ctx: cython.bint = True):
+        self.device_id = device_id
+        self.primary_ctx = primary_ctx
+        self._device_ref = cython.NULL
+        self._frames_cache = {}
+
+    def __dealloc__(self):
+        ref: cython.pointer[lib.AVBufferRef]
+
+        for v in self._frames_cache.values():
+            ref = cython.cast(
+                cython.pointer[lib.AVBufferRef],
+                cython.cast(cython.size_t, v),
+            )
+            lib.av_buffer_unref(cython.address(ref))
+        self._frames_cache.clear()
+
+        ref = self._device_ref
+        if ref != cython.NULL:
+            lib.av_buffer_unref(cython.address(ref))
+            self._device_ref = cython.NULL
+
+    @cython.cfunc
+    def _get_device_ref(self) -> cython.pointer[lib.AVBufferRef]:
+        device_ref: cython.pointer[lib.AVBufferRef] = self._device_ref
+        if device_ref != cython.NULL:
+            return device_ref
+
+        device_ref = cython.NULL
+        device_bytes = f"{self.device_id}".encode()
+        c_device: cython.p_char = device_bytes
+        options: Dictionary = Dictionary(
+            {"primary_ctx": "1" if self.primary_ctx else "0"}
+        )
+        err_check(
+            lib.av_hwdevice_ctx_create(
+                cython.address(device_ref),
+                lib.AV_HWDEVICE_TYPE_CUDA,
+                c_device,
+                options.ptr,
+                0,
+            )
+        )
+        self._device_ref = device_ref
+        return device_ref
+
+    @cython.cfunc
+    def get_frames_ctx(
+        self,
+        sw_fmt: lib.AVPixelFormat,
+        width: cython.int,
+        height: cython.int,
+    ) -> cython.pointer[lib.AVBufferRef]:
+        key = (int(sw_fmt), int(width), int(height))
+        cached = self._frames_cache.get(key)
+        cached_ref: cython.pointer[lib.AVBufferRef]
+        out_ref: cython.pointer[lib.AVBufferRef]
+
+        if cached is not None:
+            cached_ref = cython.cast(
+                cython.pointer[lib.AVBufferRef],
+                cython.cast(cython.size_t, cached),
+            )
+            out_ref = lib.av_buffer_ref(cached_ref)
+            if out_ref == cython.NULL:
+                raise MemoryError("av_buffer_ref() failed")
+            return out_ref
+
+        device_ref = self._get_device_ref()
+
+        frames_ref: cython.pointer[lib.AVBufferRef] = lib.av_hwframe_ctx_alloc(
+            device_ref
+        )
+        if frames_ref == cython.NULL:
+            raise MemoryError("av_hwframe_ctx_alloc() failed")
+
+        try:
+            frames_ctx: cython.pointer[lib.AVHWFramesContext] = cython.cast(
+                cython.pointer[lib.AVHWFramesContext], frames_ref.data
+            )
+            frames_ctx.format = get_pix_fmt(b"cuda")
+            frames_ctx.sw_format = sw_fmt
+            frames_ctx.width = int(width)
+            frames_ctx.height = int(height)
+            err_check(lib.av_hwframe_ctx_init(frames_ref))
+        except Exception:
+            lib.av_buffer_unref(cython.address(frames_ref))
+            raise
+
+        out_ref = lib.av_buffer_ref(frames_ref)
+        if out_ref == cython.NULL:
+            lib.av_buffer_unref(cython.address(frames_ref))
+            raise MemoryError("av_buffer_ref() failed")
+
+        self._frames_cache[key] = cython.cast(cython.size_t, frames_ref)
+        return out_ref
+
+
+@cython.cfunc
+def _consume_dlpack(obj: object, stream: object) -> cython.pointer[DLManagedTensor]:
+    capsule: object
+    managed: cython.pointer[DLManagedTensor]
+
+    if hasattr(obj, "__dlpack__"):
+        capsule = obj.__dlpack__() if stream is None else obj.__dlpack__(stream=stream)
+    else:
+        capsule = obj
+
+    if not PyCapsule_IsValid(capsule, b"dltensor"):
+        PyErr_Clear()
+        raise TypeError(
+            "expected a DLPack capsule or an object implementing __dlpack__"
+        )
+
+    managed = cython.cast(
+        cython.pointer[DLManagedTensor],
+        PyCapsule_GetPointer(capsule, b"dltensor"),
+    )
+    if managed == cython.NULL:
+        raise ValueError("PyCapsule_GetPointer returned NULL")
+
+    if PyCapsule_SetName(capsule, b"used_dltensor") != 0:
+        raise RuntimeError("PyCapsule_SetName failed")
+
+    return managed
+
+
+@cython.cfunc
+@cython.nogil
+@cython.exceptval(check=False)
+def _dlpack_avbuffer_free(
+    opaque: cython.p_void,
+    data: cython.pointer[uint8_t],
+) -> cython.void:
+    managed: cython.pointer[DLManagedTensor] = cython.cast(
+        cython.pointer[DLManagedTensor], opaque
+    )
+    if managed != cython.NULL:
+        managed.deleter(managed)
+
+
+@cython.cfunc
+@cython.nogil
+@cython.exceptval(check=False)
+def _numpy_avbuffer_free(
+    opaque: cython.p_void,
+    data: cython.pointer[uint8_t],
+) -> cython.void:
+    if opaque != cython.NULL:
+        with cython.gil:
+            Py_DECREF(cython.cast(object, opaque))
+
+
+_cinit_bypass_sentinel = cython.declare(object, object())
+
+# `pix_fmt`s supported by Frame.to_ndarray() and Frame.from_ndarray()
+supported_np_pix_fmts = {
+    "abgr",
+    "argb",
+    "bayer_bggr16be",
+    "bayer_bggr16le",
+    "bayer_bggr8",
+    "bayer_gbrg16be",
+    "bayer_gbrg16le",
+    "bayer_gbrg8",
+    "bayer_grbg16be",
+    "bayer_grbg16le",
+    "bayer_grbg8",
+    "bayer_rggb16be",
+    "bayer_rggb16le",
+    "bayer_rggb8",
+    "bgr24",
+    "bgr48be",
+    "bgr48le",
+    "bgr8",
+    "bgra",
+    "bgra64be",
+    "bgra64le",
+    "gbrap",
+    "gbrap10be",
+    "gbrap10le",
+    "gbrap12be",
+    "gbrap12le",
+    "gbrap14be",
+    "gbrap14le",
+    "gbrap16be",
+    "gbrap16le",
+    "gbrapf32be",
+    "gbrapf32le",
+    "gbrp",
+    "gbrp10be",
+    "gbrp10le",
+    "gbrp12be",
+    "gbrp12le",
+    "gbrp14be",
+    "gbrp14le",
+    "gbrp16be",
+    "gbrp16le",
+    "gbrp9be",
+    "gbrp9le",
+    "gbrpf32be",
+    "gbrpf32le",
+    "gray",
+    "gray10be",
+    "gray10le",
+    "gray12be",
+    "gray12le",
+    "gray14be",
+    "gray14le",
+    "gray16be",
+    "gray16le",
+    "gray8",
+    "gray9be",
+    "gray9le",
+    "grayf32be",
+    "grayf32le",
+    "nv12",
+    "pal8",
+    "rgb24",
+    "rgb48be",
+    "rgb48le",
+    "rgb8",
+    "rgba",
+    "rgba64be",
+    "rgba64le",
+    "rgbaf16be",
+    "rgbaf16le",
+    "rgbaf32be",
+    "rgbaf32le",
+    "rgbf32be",
+    "rgbf32le",
+    "yuv420p",
+    "yuv422p10le",
+    "yuv444p",
+    "yuv444p16be",
+    "yuv444p16le",
+    "yuva444p16be",
+    "yuva444p16le",
+    "yuvj420p",
+    "yuvj444p",
+    "yuyv422",
+}
+
+# Mapping from format name to (itemsize, dtype) for formats where planes
+# are simply concatenated into shape (height, width, channels).
+_np_pix_fmt_dtypes = cython.declare(
+    dict[str, tuple[cython.uint, str]],
+    {
+        "abgr": (4, "uint8"),
+        "argb": (4, "uint8"),
+        "bayer_bggr8": (1, "uint8"),
+        "bayer_gbrg8": (1, "uint8"),
+        "bayer_grbg8": (1, "uint8"),
+        "bayer_rggb8": (1, "uint8"),
+        "bayer_bggr16le": (2, "uint16"),
+        "bayer_bggr16be": (2, "uint16"),
+        "bayer_gbrg16le": (2, "uint16"),
+        "bayer_gbrg16be": (2, "uint16"),
+        "bayer_grbg16le": (2, "uint16"),
+        "bayer_grbg16be": (2, "uint16"),
+        "bayer_rggb16le": (2, "uint16"),
+        "bayer_rggb16be": (2, "uint16"),
+        "bgr24": (3, "uint8"),
+        "bgr48be": (6, "uint16"),
+        "bgr48le": (6, "uint16"),
+        "bgr8": (1, "uint8"),
+        "bgra": (4, "uint8"),
+        "bgra64be": (8, "uint16"),
+        "bgra64le": (8, "uint16"),
+        "gbrap": (1, "uint8"),
+        "gbrap10be": (2, "uint16"),
+        "gbrap10le": (2, "uint16"),
+        "gbrap12be": (2, "uint16"),
+        "gbrap12le": (2, "uint16"),
+        "gbrap14be": (2, "uint16"),
+        "gbrap14le": (2, "uint16"),
+        "gbrap16be": (2, "uint16"),
+        "gbrap16le": (2, "uint16"),
+        "gbrapf32be": (4, "float32"),
+        "gbrapf32le": (4, "float32"),
+        "gbrp": (1, "uint8"),
+        "gbrp10be": (2, "uint16"),
+        "gbrp10le": (2, "uint16"),
+        "gbrp12be": (2, "uint16"),
+        "gbrp12le": (2, "uint16"),
+        "gbrp14be": (2, "uint16"),
+        "gbrp14le": (2, "uint16"),
+        "gbrp16be": (2, "uint16"),
+        "gbrp16le": (2, "uint16"),
+        "gbrp9be": (2, "uint16"),
+        "gbrp9le": (2, "uint16"),
+        "gbrpf32be": (4, "float32"),
+        "gbrpf32le": (4, "float32"),
+        "gray": (1, "uint8"),
+        "gray10be": (2, "uint16"),
+        "gray10le": (2, "uint16"),
+        "gray12be": (2, "uint16"),
+        "gray12le": (2, "uint16"),
+        "gray14be": (2, "uint16"),
+        "gray14le": (2, "uint16"),
+        "gray16be": (2, "uint16"),
+        "gray16le": (2, "uint16"),
+        "gray8": (1, "uint8"),
+        "gray9be": (2, "uint16"),
+        "gray9le": (2, "uint16"),
+        "grayf32be": (4, "float32"),
+        "grayf32le": (4, "float32"),
+        "rgb24": (3, "uint8"),
+        "rgb48be": (6, "uint16"),
+        "rgb48le": (6, "uint16"),
+        "rgb8": (1, "uint8"),
+        "rgba": (4, "uint8"),
+        "rgba64be": (8, "uint16"),
+        "rgba64le": (8, "uint16"),
+        "rgbaf16be": (8, "float16"),
+        "rgbaf16le": (8, "float16"),
+        "rgbaf32be": (16, "float32"),
+        "rgbaf32le": (16, "float32"),
+        "rgbf32be": (12, "float32"),
+        "rgbf32le": (12, "float32"),
+        "yuv444p": (1, "uint8"),
+        "yuv444p16be": (2, "uint16"),
+        "yuv444p16le": (2, "uint16"),
+        "yuva444p16be": (2, "uint16"),
+        "yuva444p16le": (2, "uint16"),
+        "yuvj444p": (1, "uint8"),
+        "yuyv422": (2, "uint8"),
+    },
+)
+
+
+@cython.cfunc
+def alloc_video_frame() -> VideoFrame:
+    """Get a mostly uninitialized VideoFrame.
+
+    You MUST call VideoFrame._init(...) or VideoFrame._init_user_attributes()
+    before exposing to the user.
+
+    """
+    return VideoFrame(_cinit_bypass_sentinel)
+
+
+class PictureType(IntEnum):
+    NONE = lib.AV_PICTURE_TYPE_NONE  # Undefined
+    I = lib.AV_PICTURE_TYPE_I  # Intra
+    P = lib.AV_PICTURE_TYPE_P  # Predicted
+    B = lib.AV_PICTURE_TYPE_B  # Bi-directional predicted
+    S = lib.AV_PICTURE_TYPE_S  # S(GMC)-VOP MPEG-4
+    SI = lib.AV_PICTURE_TYPE_SI  # Switching intra
+    SP = lib.AV_PICTURE_TYPE_SP  # Switching predicted
+    BI = lib.AV_PICTURE_TYPE_BI  # BI type
+
+
+_is_big_endian = cython.declare(cython.bint, sys.byteorder == "big")
+
+
+@cython.cfunc
+@cython.inline
+def byteswap_array(array, big_endian: cython.bint):
+    if _is_big_endian != big_endian:
+        return array.byteswap()
+    return array
+
+
+@cython.cfunc
+def copy_bytes_to_plane(
+    img_bytes,
+    plane: VideoPlane,
+    bytes_per_pixel: cython.uint,
+    flip_horizontal: cython.bint,
+    flip_vertical: cython.bint,
+):
+    i_buf: cython.const[uint8_t][:] = img_bytes
+    i_pos: cython.size_t = 0
+    i_stride: cython.size_t = plane.width * bytes_per_pixel
+
+    o_buf: uint8_t[:] = plane
+    o_pos: cython.size_t = 0
+    o_stride: cython.size_t = abs(plane.line_size)
+
+    start_row, end_row, step = cython.declare(cython.int)
+    if flip_vertical:
+        start_row = plane.height - 1
+        end_row = -1
+        step = -1
+    else:
+        start_row = 0
+        end_row = plane.height
+        step = 1
+
+    for row in range(start_row, end_row, step):
+        i_pos = row * i_stride
+        if flip_horizontal:
+            i: cython.Py_ssize_t
+            for i in range(0, i_stride, bytes_per_pixel):
+                j: cython.Py_ssize_t
+                for j in range(bytes_per_pixel):
+                    o_buf[o_pos + i + j] = i_buf[
+                        i_pos + i_stride - i - bytes_per_pixel + j
+                    ]
+        else:
+            o_buf[o_pos : o_pos + i_stride] = i_buf[i_pos : i_pos + i_stride]
+        o_pos += o_stride
+
+
+@cython.cfunc
+def copy_array_to_plane(array, plane: VideoPlane, bytes_per_pixel: cython.uint):
+    imgbytes: bytes = array.tobytes()
+    copy_bytes_to_plane(imgbytes, plane, bytes_per_pixel, False, False)
+
+
+@cython.cfunc
+@cython.inline
+def useful_array(
+    plane: VideoPlane, bytes_per_pixel: cython.uint = 1, dtype: str = "uint8"
+):
+    """
+    Return the useful part of the VideoPlane as a strided array.
+
+    We are simply creating a view that discards any padding which was added for
+    alignment.
+    """
+    import numpy as np
+
+    dtype_obj = np.dtype(dtype)
+    line_size = plane.frame.ptr.linesize[plane.index]
+    total_line_size = abs(line_size)
+    itemsize = dtype_obj.itemsize
+    channels = bytes_per_pixel // itemsize
+
+    if channels == 1:
+        shape = (plane.height, plane.width)
+        strides = (total_line_size, itemsize)
+    else:
+        shape = (plane.height, plane.width, channels)
+        strides = (total_line_size, bytes_per_pixel, itemsize)
+
+    if line_size < 0:
+        offset = (plane.height - 1) * total_line_size
+        strides = (-total_line_size, *strides[1:])
+        return np.ndarray(
+            shape, dtype=dtype_obj, buffer=plane, offset=offset, strides=strides
+        )
+
+    return np.ndarray(shape, dtype=dtype_obj, buffer=plane, strides=strides)
+
+
+@cython.cfunc
+def check_ndarray_shape(array: object, ok: cython.bint):
+    if not ok:
+        raise ValueError(f"Unexpected numpy array shape `{array.shape}`")
+
+
+@cython.final
+@cython.cclass
+class VideoFrame(Frame):
+    def __cinit__(self, width=0, height=0, format="yuv420p"):
+        if width is _cinit_bypass_sentinel:
+            return
+
+        c_format: lib.AVPixelFormat = get_pix_fmt(format)
+        self._init(c_format, width, height)
+
+    @cython.cfunc
+    def _init(self, format: lib.AVPixelFormat, width: cython.uint, height: cython.uint):
+        res: cython.int = 0
+
+        with cython.nogil:
+            self.ptr.width = width
+            self.ptr.height = height
+            self.ptr.format = format
+
+            # We enforce aligned buffers, otherwise `sws_scale_frame` can perform
+            # poorly or even cause out-of-bounds reads and writes.
+            if width and height:
+                res = lib.av_frame_get_buffer(self.ptr, 16)
+
+        if res:
+            err_check(res)
+
+        self._init_user_attributes()
+
+    @cython.cfunc
+    def _init_user_attributes(self):
+        self.format = get_video_format(
+            cython.cast(lib.AVPixelFormat, self.ptr.format),
+            self.ptr.width,
+            self.ptr.height,
+        )
+
+    def __dealloc__(self):
+        lib.av_frame_unref(self.ptr)
+
+    def __repr__(self):
+        return (
+            f"<av.{self.__class__.__name__}, pts={self.pts} {self.format.name} "
+            f"{self.width}x{self.height} at 0x{id(self):x}>"
+        )
+
+    @property
+    def planes(self):
+        """
+        A tuple of :class:`.VideoPlane` objects.
+        """
+        # We need to detect which planes actually exist, but also constrain ourselves to
+        # the maximum plane count (as determined only by VideoFrames so far), in case
+        # the library implementation does not set the last plane to NULL.
+        fmt = self.format
+        if self.ptr.hw_frames_ctx:
+            frames_ctx: cython.pointer[lib.AVHWFramesContext] = cython.cast(
+                cython.pointer[lib.AVHWFramesContext], self.ptr.hw_frames_ctx.data
+            )
+            fmt = get_video_format(
+                frames_ctx.sw_format, self.ptr.width, self.ptr.height
+            )
+
+        max_plane_count: cython.int = 0
+        for i in range(fmt.ptr.nb_components):
+            count = fmt.ptr.comp[i].plane + 1
+            if max_plane_count < count:
+                max_plane_count = count
+        if fmt.name == "pal8":
+            max_plane_count = 2
+
+        plane_count: cython.int = 0
+        while plane_count < max_plane_count and self.ptr.extended_data[plane_count]:
+            plane_count += 1
+        if plane_count == 1:
+            return (VideoPlane(self, 0),)
+        return tuple([VideoPlane(self, i) for i in range(plane_count)])
+
+    @property
+    def width(self):
+        """Width of the image, in pixels."""
+        return self.ptr.width
+
+    @property
+    def height(self):
+        """Height of the image, in pixels."""
+        return self.ptr.height
+
+    @property
+    def rotation(self):
+        """The rotation component of the `DISPLAYMATRIX` transformation matrix.
+
+        Returns:
+            int: The angle (in degrees) by which the transformation rotates the frame
+                counterclockwise. The angle will be in range [-180, 180].
+        """
+        return get_display_rotation(self)
+
+    @property
+    def interlaced_frame(self):
+        """Is this frame an interlaced or progressive?"""
+
+        return bool(self.ptr.flags & lib.AV_FRAME_FLAG_INTERLACED)
+
+    @property
+    def pict_type(self):
+        """Returns an integer that corresponds to the PictureType enum.
+
+        Wraps :ffmpeg:`AVFrame.pict_type`
+
+        :type: int
+        """
+        return self.ptr.pict_type
+
+    @pict_type.setter
+    def pict_type(self, value):
+        self.ptr.pict_type = value
+
+    @property
+    def colorspace(self):
+        """Colorspace of frame.
+
+        Wraps :ffmpeg:`AVFrame.colorspace`.
+
+        """
+        return self.ptr.colorspace
+
+    @colorspace.setter
+    def colorspace(self, value):
+        self.ptr.colorspace = value
+
+    @property
+    def color_range(self):
+        """Color range of frame.
+
+        Wraps :ffmpeg:`AVFrame.color_range`.
+
+        """
+        return self.ptr.color_range
+
+    @color_range.setter
+    def color_range(self, value):
+        self.ptr.color_range = value
+
+    @property
+    def color_trc(self):
+        """Transfer characteristic of frame.
+
+        Wraps :ffmpeg:`AVFrame.color_trc`.
+
+        """
+        return self.ptr.color_trc
+
+    @color_trc.setter
+    def color_trc(self, value):
+        self.ptr.color_trc = value
+
+    @property
+    def color_primaries(self):
+        """Color primaries of frame.
+
+        Wraps :ffmpeg:`AVFrame.color_primaries`.
+
+        """
+        return self.ptr.color_primaries
+
+    @color_primaries.setter
+    def color_primaries(self, value):
+        self.ptr.color_primaries = value
+
+    def reformat(self, *args, **kwargs):
+        """reformat(width=None, height=None, format=None, src_colorspace=None, dst_colorspace=None, interpolation=None, threads=None)
+
+        Create a new :class:`VideoFrame` with the given width/height/format/colorspace.
+
+        .. seealso:: :meth:`.VideoReformatter.reformat` for arguments.
+
+        """
+        if not self.reformatter:
+            self.reformatter = VideoReformatter()
+        return self.reformatter.reformat(self, *args, **kwargs)
+
+    def to_rgb(self, **kwargs):
+        """Get an RGB version of this frame.
+
+        Any ``**kwargs`` are passed to :meth:`.VideoReformatter.reformat`.
+
+        >>> frame = VideoFrame(1920, 1080)
+        >>> frame.format.name
+        'yuv420p'
+        >>> frame.to_rgb().format.name
+        'rgb24'
+
+        """
+        return self.reformat(format="rgb24", **kwargs)
+
+    @cython.ccall
+    def save(self, filepath: object):
+        """Save a VideoFrame as a JPG or PNG.
+
+        :param filepath: str | Path
+        """
+        is_jpg: cython.bint
+
+        if filepath.endswith(".png"):
+            is_jpg = False
+        elif filepath.endswith(".jpg") or filepath.endswith(".jpeg"):
+            is_jpg = True
+        else:
+            raise ValueError("filepath must end with png or jpg.")
+
+        encoder: str = "mjpeg" if is_jpg else "png"
+        pix_fmt: str = "yuvj420p" if is_jpg else "rgb24"
+
+        from av.container.core import open
+
+        with open(filepath, "w", options={"update": "1"}) as output:
+            output_stream = output.add_stream(encoder, pix_fmt=pix_fmt)
+            output_stream.width = self.width
+            output_stream.height = self.height
+
+            output.mux(output_stream.encode(self.reformat(format=pix_fmt)))
+            output.mux(output_stream.encode(None))
+
+    def to_image(self, **kwargs):
+        """Get an RGB ``PIL.Image`` of this frame.
+
+        Any ``**kwargs`` are passed to :meth:`.VideoReformatter.reformat`.
+
+        .. note:: PIL or Pillow must be installed.
+
+        """
+        from PIL import Image
+
+        plane: VideoPlane = self.reformat(format="rgb24", **kwargs).planes[0]
+
+        i_buf: cython.const[uint8_t][:] = plane
+        line_size: cython.int = plane.line_size
+        i_stride: cython.size_t = abs(line_size)
+
+        o_pos: cython.size_t = 0
+        o_stride: cython.size_t = plane.width * 3
+        o_size: cython.size_t = plane.height * o_stride
+        o_buf: bytearray = bytearray(o_size)
+
+        # For bottom-up frames (negative line_size) the buffer protocol exposes
+        # rows from the lowest address, so the top display row is at the far end.
+        i_pos: cython.size_t = (plane.height - 1) * i_stride if line_size < 0 else 0
+
+        while o_pos < o_size:
+            o_buf[o_pos : o_pos + o_stride] = i_buf[i_pos : i_pos + o_stride]
+            if line_size < 0:
+                i_pos -= i_stride
+            else:
+                i_pos += i_stride
+            o_pos += o_stride
+
+        return Image.frombytes(
+            "RGB", (plane.width, plane.height), bytes(o_buf), "raw", "RGB", 0, 1
+        )
+
+    def to_ndarray(self, channel_last=False, **kwargs):
+        """Get a numpy array of this frame.
+
+        Any ``**kwargs`` are passed to :meth:`.VideoReformatter.reformat`.
+
+        The array returned is generally of dimension (height, width, channels).
+
+        :param bool channel_last: If True, the shape of array will be
+            (height, width, channels) rather than (channels, height, width) for
+            the "yuv444p" and "yuvj444p" formats.
+
+        .. note:: Numpy must be installed.
+
+        .. note:: For formats which return an array of ``uint16``, ``float16`` or ``float32``,
+            the samples will be in the system's native byte order.
+
+        .. note:: For ``pal8``, an ``(image, palette)`` tuple will be returned,
+            with the palette being in ARGB (PyAV will swap bytes if needed).
+
+        .. note:: For ``gbrp`` formats, channels are flipped to RGB order.
+
+        """
+        if self.ptr.hw_frames_ctx and "format" not in kwargs:
+            frames_ctx: cython.pointer[lib.AVHWFramesContext] = cython.cast(
+                cython.pointer[lib.AVHWFramesContext], self.ptr.hw_frames_ctx.data
+            )
+            kwargs = dict(kwargs)
+            kwargs["format"] = get_video_format(
+                frames_ctx.sw_format, self.ptr.width, self.ptr.height
+            ).name
+
+        frame: VideoFrame = self.reformat(**kwargs) if len(kwargs) > 0 else self
+        if frame.ptr.hw_frames_ctx:
+            raise ValueError("Cannot convert a hardware frame to numpy directly.")
+
+        import numpy as np
+
+        # check size
+        format_name = frame.format.name
+        planes: tuple[VideoPlane, ...] = frame.planes
+        # cases planes are simply concatenated in shape (height, width, channels)
+        if format_name in _np_pix_fmt_dtypes:
+            if format_name == "yuyv422":
+                assert frame.ptr.width % 2 == 0, "width has to be even for yuyv422"
+                assert frame.ptr.height % 2 == 0, "height has to be even for yuyv422"
+            itemsize: cython.uint
+            itemsize, dtype = _np_pix_fmt_dtypes[format_name]
+            num_planes: cython.size_t = len(planes)
+            if num_planes == 1:  # shortcut, avoid memory copy
+                array = useful_array(planes[0], itemsize, dtype)
+            else:  # general case
+                array = np.empty(
+                    (frame.ptr.height, frame.ptr.width, num_planes), dtype=dtype
+                )
+                if format_name.startswith("gbr"):
+                    plane_indices = (2, 0, 1, *range(3, num_planes))
+                else:
+                    plane_indices = range(num_planes)
+                for i, p_idx in enumerate(plane_indices):
+                    array[:, :, i] = useful_array(planes[p_idx], itemsize, dtype)
+            array = byteswap_array(array, format_name.endswith("be"))
+            if not channel_last and format_name in {"yuv444p", "yuvj444p"}:
+                array = np.moveaxis(array, 2, 0)
+            return array
+
+        # special cases
+        if format_name in {"yuv420p", "yuvj420p", "yuv422p"}:
+            assert frame.ptr.width % 2 == 0, "width has to be even for this format"
+            assert frame.ptr.height % 2 == 0, "height has to be even for this format"
+            return np.hstack(
+                [
+                    useful_array(planes[0]).reshape(-1),
+                    useful_array(planes[1]).reshape(-1),
+                    useful_array(planes[2]).reshape(-1),
+                ]
+            ).reshape(-1, frame.ptr.width)
+        if format_name == "yuv422p10le":
+            assert frame.ptr.width % 2 == 0, "width has to be even for this format"
+            assert frame.ptr.height % 2 == 0, "height has to be even for this format"
+            # Read planes as uint16 at their original width
+            y = useful_array(planes[0], 2, "uint16")
+            u = useful_array(planes[1], 2, "uint16")
+            v = useful_array(planes[2], 2, "uint16")
+
+            # Double the width of U and V by repeating each value
+            u_full = np.repeat(u, 2, axis=1)
+            v_full = np.repeat(v, 2, axis=1)
+            if channel_last:
+                return np.stack([y, u_full, v_full], axis=2)
+            return np.stack([y, u_full, v_full], axis=0)
+        if format_name == "pal8":
+            image = useful_array(planes[0])
+            palette = (
+                np.frombuffer(planes[1], "i4")
+                .astype(">i4")
+                .reshape(-1, 1)
+                .view(np.uint8)
+            )
+            return image, palette
+        if format_name == "nv12":
+            return np.hstack(
+                [
+                    useful_array(planes[0]).reshape(-1),
+                    useful_array(planes[1], 2).reshape(-1),
+                ]
+            ).reshape(-1, frame.ptr.width)
+
+        raise ValueError(
+            f"Conversion to numpy array with format `{format_name}` is not yet supported"
+        )
+
+    def set_image(self, img):
+        """
+        Update content from a ``PIL.Image``.
+        """
+        if img.mode != "RGB":
+            img = img.convert("RGB")
+
+        copy_array_to_plane(img, self.planes[0], 3)
+
+    @staticmethod
+    def from_image(img):
+        """
+        Construct a frame from a ``PIL.Image``.
+        """
+        frame: VideoFrame = VideoFrame(img.size[0], img.size[1], "rgb24")
+        frame.set_image(img)
+
+        return frame
+
+    @staticmethod
+    def from_numpy_buffer(array, format="rgb24", width=0):
+        """
+        Construct a frame from a numpy buffer.
+
+        :param int width: optional width of actual image, if different from the array width.
+
+        .. note:: For formats which expect an array of ``uint16``, ``float16`` or ``float32``,
+            the samples must be in the system's native byte order.
+
+        .. note:: for ``gbrp`` formats, channels are assumed to be given in RGB order.
+
+        .. note:: For formats where width of the array is not the same as the width of the image,
+        for example with yuv420p images the UV rows at the bottom have padding bytes in the middle of the
+        row as well as at the end. To cope with these, callers need to be able to pass the actual width.
+        """
+        import numpy as np
+
+        height = array.shape[0]
+        if not width:
+            width = array.shape[1]
+
+        if format in {"rgb24", "bgr24"}:
+            check_ndarray(array, "uint8", 3)
+            check_ndarray_shape(array, array.shape[2] == 3)
+            if array.strides[1:] != (3, 1):
+                raise ValueError("provided array does not have C_CONTIGUOUS rows")
+            linesizes = (array.strides[0],)
+        elif format in {"rgb48le", "rgb48be", "bgr48le", "bgr48be"}:
+            check_ndarray(array, "uint16", 3)
+            check_ndarray_shape(array, array.shape[2] == 3)
+            if array.strides[1:] != (6, 2):
+                raise ValueError("provided array does not have C_CONTIGUOUS rows")
+            linesizes = (array.strides[0],)
+        elif format in {"rgbf32le", "rgbf32be"}:
+            check_ndarray(array, "float32", 3)
+            check_ndarray_shape(array, array.shape[2] == 3)
+            if array.strides[1:] != (12, 4):
+                raise ValueError("provided array does not have C_CONTIGUOUS rows")
+            linesizes = (array.strides[0],)
+        elif format in {"rgba", "bgra", "argb", "abgr"}:
+            check_ndarray(array, "uint8", 3)
+            check_ndarray_shape(array, array.shape[2] == 4)
+            if array.strides[1:] != (4, 1):
+                raise ValueError("provided array does not have C_CONTIGUOUS rows")
+            linesizes = (array.strides[0],)
+        elif format in {"rgba64le", "rgba64be", "bgra64le", "bgra64be"}:
+            check_ndarray(array, "uint16", 3)
+            check_ndarray_shape(array, array.shape[2] == 4)
+            if array.strides[1:] != (8, 2):
+                raise ValueError("provided array does not have C_CONTIGUOUS rows")
+            linesizes = (array.strides[0],)
+        elif format in {"rgbaf16le", "rgbaf16be"}:
+            check_ndarray(array, "float16", 3)
+            check_ndarray_shape(array, array.shape[2] == 4)
+            if array.strides[1:] != (8, 2):
+                raise ValueError("provided array does not have C_CONTIGUOUS rows")
+            linesizes = (array.strides[0],)
+        elif format in {"rgbaf32le", "rgbaf32be"}:
+            check_ndarray(array, "float32", 3)
+            check_ndarray_shape(array, array.shape[2] == 4)
+            if array.strides[1:] != (16, 4):
+                raise ValueError("provided array does not have C_CONTIGUOUS rows")
+            linesizes = (array.strides[0],)
+        elif format in {
+            "gray",
+            "gray8",
+            "rgb8",
+            "bgr8",
+            "bayer_bggr8",
+            "bayer_gbrg8",
+            "bayer_grbg8",
+            "bayer_rggb8",
+        }:
+            check_ndarray(array, "uint8", 2)
+            if array.strides[1] != 1:
+                raise ValueError("provided array does not have C_CONTIGUOUS rows")
+            linesizes = (array.strides[0],)
+        elif format in {
+            "gray9be",
+            "gray9le",
+            "gray10be",
+            "gray10le",
+            "gray12be",
+            "gray12le",
+            "gray14be",
+            "gray14le",
+            "gray16be",
+            "gray16le",
+            "bayer_bggr16be",
+            "bayer_bggr16le",
+            "bayer_gbrg16be",
+            "bayer_gbrg16le",
+            "bayer_grbg16be",
+            "bayer_grbg16le",
+            "bayer_rggb16be",
+            "bayer_rggb16le",
+        }:
+            check_ndarray(array, "uint16", 2)
+            if array.strides[1] != 2:
+                raise ValueError("provided array does not have C_CONTIGUOUS rows")
+            linesizes = (array.strides[0],)
+        elif format in {"grayf32le", "grayf32be"}:
+            check_ndarray(array, "float32", 2)
+            if array.strides[1] != 4:
+                raise ValueError("provided array does not have C_CONTIGUOUS rows")
+            linesizes = (array.strides[0],)
+        elif format in {"gbrp"}:
+            check_ndarray(array, "uint8", 3)
+            check_ndarray_shape(array, array.shape[2] == 3)
+            if array.strides[1:] != (3, 1):
+                raise ValueError("provided array does not have C_CONTIGUOUS rows")
+            linesizes = (
+                array.strides[0] // 3,
+                array.strides[0] // 3,
+                array.strides[0] // 3,
+            )
+        elif format in {
+            "gbrp9be",
+            "gbrp9le",
+            "gbrp10be",
+            "gbrp10le",
+            "gbrp12be",
+            "gbrp12le",
+            "gbrp14be",
+            "gbrp14le",
+            "gbrp16be",
+            "gbrp16le",
+        }:
+            check_ndarray(array, "uint16", 3)
+            check_ndarray_shape(array, array.shape[2] == 3)
+            if array.strides[1:] != (6, 2):
+                raise ValueError("provided array does not have C_CONTIGUOUS rows")
+            linesizes = (
+                array.strides[0] // 3,
+                array.strides[0] // 3,
+                array.strides[0] // 3,
+            )
+        elif format in {"gbrpf32be", "gbrpf32le"}:
+            check_ndarray(array, "float32", 3)
+            check_ndarray_shape(array, array.shape[2] == 3)
+            if array.strides[1:] != (12, 4):
+                raise ValueError("provided array does not have C_CONTIGUOUS rows")
+            linesizes = (
+                array.strides[0] // 3,
+                array.strides[0] // 3,
+                array.strides[0] // 3,
+            )
+        elif format in {"gbrap"}:
+            check_ndarray(array, "uint8", 3)
+            check_ndarray_shape(array, array.shape[2] == 4)
+            if array.strides[1:] != (4, 1):
+                raise ValueError("provided array does not have C_CONTIGUOUS rows")
+            linesizes = (
+                array.strides[0] // 4,
+                array.strides[0] // 4,
+                array.strides[0] // 4,
+                array.strides[0] // 4,
+            )
+        elif format in {
+            "gbrap10be",
+            "gbrap10le",
+            "gbrap12be",
+            "gbrap12le",
+            "gbrap14be",
+            "gbrap14le",
+            "gbrap16be",
+            "gbrap16le",
+        }:
+            check_ndarray(array, "uint16", 3)
+            check_ndarray_shape(array, array.shape[2] == 4)
+            if array.strides[1:] != (8, 2):
+                raise ValueError("provided array does not have C_CONTIGUOUS rows")
+            linesizes = (
+                array.strides[0] // 4,
+                array.strides[0] // 4,
+                array.strides[0] // 4,
+                array.strides[0] // 4,
+            )
+        elif format in {"gbrapf32be", "gbrapf32le"}:
+            check_ndarray(array, "float32", 3)
+            check_ndarray_shape(array, array.shape[2] == 4)
+            if array.strides[1:] != (16, 4):
+                raise ValueError("provided array does not have C_CONTIGUOUS rows")
+            linesizes = (
+                array.strides[0] // 4,
+                array.strides[0] // 4,
+                array.strides[0] // 4,
+                array.strides[0] // 4,
+            )
+        elif format in {"yuv420p", "yuvj420p", "nv12"}:
+            check_ndarray(array, "uint8", 2)
+            check_ndarray_shape(array, array.shape[0] % 3 == 0)
+            check_ndarray_shape(array, array.shape[1] % 2 == 0)
+            height = height // 6 * 4
+            if array.strides[1] != 1:
+                raise ValueError("provided array does not have C_CONTIGUOUS rows")
+            if format in {"yuv420p", "yuvj420p"}:
+                # For YUV420 planar formats, the UV plane stride is always half the Y stride.
+                linesizes = (
+                    array.strides[0],
+                    array.strides[0] // 2,
+                    array.strides[0] // 2,
+                )
+            else:
+                # Planes where U and V are interleaved have the same stride as Y.
+                linesizes = (array.strides[0], array.strides[0])
+        else:
+            raise ValueError(
+                f"Conversion from numpy array with format `{format}` is not yet supported"
+            )
+
+        if format.startswith("gbrap"):  # rgba -> gbra
+            array = np.ascontiguousarray(np.moveaxis(array[..., [1, 2, 0, 3]], -1, 0))
+        elif format.startswith("gbrp"):  # rgb -> gbr
+            array = np.ascontiguousarray(np.moveaxis(array[..., [1, 2, 0]], -1, 0))
+
+        frame = VideoFrame(_cinit_bypass_sentinel)
+        frame._image_fill_pointers_numpy(array, width, height, linesizes, format)
+        return frame
+
+    def _image_fill_pointers_numpy(self, buffer, width, height, linesizes, format):
+        # If you want to use the numpy notation, then you need to include the following lines at the top of the file:
+        #      cimport numpy as cnp
+        #      cnp.import_array()
+
+        # And add the numpy include directories to the setup.py files
+        # hint np.get_include()
+        # cdef cnp.ndarray[
+        #     dtype=cnp.uint8_t, ndim=1,
+        #     negative_indices=False, mode='c'] c_buffer
+        # c_buffer = buffer.reshape(-1)
+        # c_ptr = &c_buffer[0]
+        # c_ptr = <uint8_t*> (<void*>(buffer.ctypes.data))
+
+        # Using buffer.ctypes.data helps avoid any kind of usage of the c-api from
+        # numpy, which avoid the need to add numpy as a compile time dependency.
+
+        c_data: cython.Py_ssize_t = buffer.ctypes.data
+        c_ptr: cython.pointer[uint8_t] = cython.cast(cython.pointer[uint8_t], c_data)
+        c_format: lib.AVPixelFormat = get_pix_fmt(format)
+        lib.av_frame_unref(self.ptr)
+
+        # Hold on to a reference for the numpy buffer so that it doesn't get accidentally garbage collected
+        self.ptr.format = c_format
+        self.ptr.width = width
+        self.ptr.height = height
+        for i, linesize in enumerate(linesizes):
+            self.ptr.linesize[i] = linesize
+
+        required = err_check(
+            lib.av_image_fill_pointers(
+                self.ptr.data,
+                cython.cast(lib.AVPixelFormat, self.ptr.format),
+                self.ptr.height,
+                c_ptr,
+                self.ptr.linesize,
+            )
+        )
+
+        py_buf = cython.cast(object, buffer)
+        Py_INCREF(py_buf)
+
+        self.ptr.buf[0] = lib.av_buffer_create(
+            c_ptr,
+            required,
+            _numpy_avbuffer_free,
+            cython.cast(cython.p_void, py_buf),
+            0,
+        )
+        if self.ptr.buf[0] == cython.NULL:
+            Py_DECREF(py_buf)
+            raise MemoryError("av_buffer_create failed")
+
+        self._init_user_attributes()
+
+    @staticmethod
+    def from_ndarray(array, format="rgb24", channel_last=False):
+        """
+        Construct a frame from a numpy array.
+
+        :param bool channel_last: If False (default), the shape for the yuv444p and yuvj444p
+            is given by (channels, height, width) rather than (height, width, channels).
+
+        .. note:: For formats which expect an array of ``uint16``, ``float16`` or ``float32``,
+            the samples must be in the system's native byte order.
+
+        .. note:: for ``pal8``, an ``(image, palette)`` pair must be passed. `palette` must
+            have shape (256, 4) and is given in ARGB format (PyAV will swap bytes if needed).
+
+        .. note:: for ``gbrp`` formats, channels are assumed to be given in RGB order.
+
+        """
+        import numpy as np
+
+        # case layers are concatenated
+        channels, itemsize, dtype = {
+            "bayer_bggr16be": (1, 2, "uint16"),
+            "bayer_bggr16le": (1, 2, "uint16"),
+            "bayer_bggr8": (1, 1, "uint8"),
+            "bayer_gbrg16be": (1, 2, "uint16"),
+            "bayer_gbrg16le": (1, 2, "uint16"),
+            "bayer_gbrg8": (1, 1, "uint8"),
+            "bayer_grbg16be": (1, 2, "uint16"),
+            "bayer_grbg16le": (1, 2, "uint16"),
+            "bayer_grbg8": (1, 1, "uint8"),
+            "bayer_rggb16be": (1, 2, "uint16"),
+            "bayer_rggb16le": (1, 2, "uint16"),
+            "bayer_rggb8": (1, 1, "uint8"),
+            "bgr8": (1, 1, "uint8"),
+            "gbrap": (4, 1, "uint8"),
+            "gbrap10be": (4, 2, "uint16"),
+            "gbrap10le": (4, 2, "uint16"),
+            "gbrap12be": (4, 2, "uint16"),
+            "gbrap12le": (4, 2, "uint16"),
+            "gbrap14be": (4, 2, "uint16"),
+            "gbrap14le": (4, 2, "uint16"),
+            "gbrap16be": (4, 2, "uint16"),
+            "gbrap16le": (4, 2, "uint16"),
+            "gbrapf32be": (4, 4, "float32"),
+            "gbrapf32le": (4, 4, "float32"),
+            "gbrp": (3, 1, "uint8"),
+            "gbrp10be": (3, 2, "uint16"),
+            "gbrp10le": (3, 2, "uint16"),
+            "gbrp12be": (3, 2, "uint16"),
+            "gbrp12le": (3, 2, "uint16"),
+            "gbrp14be": (3, 2, "uint16"),
+            "gbrp14le": (3, 2, "uint16"),
+            "gbrp16be": (3, 2, "uint16"),
+            "gbrp16le": (3, 2, "uint16"),
+            "gbrp9be": (3, 2, "uint16"),
+            "gbrp9le": (3, 2, "uint16"),
+            "gbrpf32be": (3, 4, "float32"),
+            "gbrpf32le": (3, 4, "float32"),
+            "gray": (1, 1, "uint8"),
+            "gray10be": (1, 2, "uint16"),
+            "gray10le": (1, 2, "uint16"),
+            "gray12be": (1, 2, "uint16"),
+            "gray12le": (1, 2, "uint16"),
+            "gray14be": (1, 2, "uint16"),
+            "gray14le": (1, 2, "uint16"),
+            "gray16be": (1, 2, "uint16"),
+            "gray16le": (1, 2, "uint16"),
+            "gray8": (1, 1, "uint8"),
+            "gray9be": (1, 2, "uint16"),
+            "gray9le": (1, 2, "uint16"),
+            "grayf32be": (1, 4, "float32"),
+            "grayf32le": (1, 4, "float32"),
+            "rgb8": (1, 1, "uint8"),
+            "yuv444p": (3, 1, "uint8"),
+            "yuv444p16be": (3, 2, "uint16"),
+            "yuv444p16le": (3, 2, "uint16"),
+            "yuva444p16be": (4, 2, "uint16"),
+            "yuva444p16le": (4, 2, "uint16"),
+            "yuvj444p": (3, 1, "uint8"),
+        }.get(format, (None, None, None))
+        if channels is not None:
+            if array.ndim == 2:  # (height, width) -> (height, width, 1)
+                array = array[:, :, None]
+            check_ndarray(array, dtype, 3)
+            if not channel_last and format in {"yuv444p", "yuvj444p"}:
+                array = np.moveaxis(array, 0, 2)  # (channels, h, w) -> (h, w, channels)
+            check_ndarray_shape(array, array.shape[2] == channels)
+            array = byteswap_array(array, format.endswith("be"))
+            frame = VideoFrame(array.shape[1], array.shape[0], format)
+            if frame.format.name.startswith("gbr"):  # rgb -> gbr
+                array = np.concatenate(
+                    [  # not inplace to avoid bad surprises
+                        array[:, :, 1:3],
+                        array[:, :, 0:1],
+                        array[:, :, 3:],
+                    ],
+                    axis=2,
+                )
+            for i in range(channels):
+                copy_array_to_plane(array[:, :, i], frame.planes[i], itemsize)
+            return frame
+
+        # other cases
+        if format == "pal8":
+            array, palette = array
+            check_ndarray(array, "uint8", 2)
+            check_ndarray(palette, "uint8", 2)
+            check_ndarray_shape(palette, palette.shape == (256, 4))
+
+            frame = VideoFrame(array.shape[1], array.shape[0], format)
+            copy_array_to_plane(array, frame.planes[0], 1)
+            frame.planes[1].update(palette.view(">i4").astype("i4").tobytes())
+            return frame
+        elif format in {"yuv420p", "yuvj420p"}:
+            check_ndarray(array, "uint8", 2)
+            check_ndarray_shape(array, array.shape[0] % 3 == 0)
+            check_ndarray_shape(array, array.shape[1] % 2 == 0)
+
+            frame = VideoFrame(array.shape[1], (array.shape[0] * 2) // 3, format)
+            u_start = frame.width * frame.height
+            v_start = 5 * u_start // 4
+            flat = array.reshape(-1)
+            copy_array_to_plane(flat[0:u_start], frame.planes[0], 1)
+            copy_array_to_plane(flat[u_start:v_start], frame.planes[1], 1)
+            copy_array_to_plane(flat[v_start:], frame.planes[2], 1)
+            return frame
+        elif format == "yuv422p":
+            check_ndarray(array, "uint8", 2)
+            check_ndarray_shape(array, array.shape[0] % 4 == 0)
+            check_ndarray_shape(array, array.shape[1] % 2 == 0)
+
+            frame = VideoFrame(array.shape[1], array.shape[0] // 2, format)
+            u_start = frame.width * frame.height
+            v_start = u_start + u_start // 2
+            flat = array.reshape(-1)
+            copy_array_to_plane(flat[0:u_start], frame.planes[0], 1)
+            copy_array_to_plane(flat[u_start:v_start], frame.planes[1], 1)
+            copy_array_to_plane(flat[v_start:], frame.planes[2], 1)
+            return frame
+        elif format == "yuv422p10le":
+            if not isinstance(array, np.ndarray) or array.dtype != np.uint16:
+                raise ValueError("Array must be uint16 type")
+
+            # Convert to channel-first if needed
+            if channel_last and array.shape[2] == 3:
+                array = np.moveaxis(array, 2, 0)
+            elif not (array.shape[0] == 3):
+                raise ValueError(
+                    "Array must have shape (3, height, width) or (height, width, 3)"
+                )
+
+            height, width = array.shape[1:]
+            if width % 2 != 0 or height % 2 != 0:
+                raise ValueError("Width and height must be even")
+
+            frame = VideoFrame(width, height, format)
+            copy_array_to_plane(array[0], frame.planes[0], 2)
+            # Subsample U and V by taking every other column
+            u = array[1, :, ::2].copy()  # Need copy to ensure C-contiguous
+            v = array[2, :, ::2].copy()  # Need copy to ensure C-contiguous
+            copy_array_to_plane(u, frame.planes[1], 2)
+            copy_array_to_plane(v, frame.planes[2], 2)
+            return frame
+        elif format == "yuyv422":
+            check_ndarray(array, "uint8", 3)
+            check_ndarray_shape(array, array.shape[0] % 2 == 0)
+            check_ndarray_shape(array, array.shape[1] % 2 == 0)
+            check_ndarray_shape(array, array.shape[2] == 2)
+        elif format in {"rgb24", "bgr24"}:
+            check_ndarray(array, "uint8", 3)
+            check_ndarray_shape(array, array.shape[2] == 3)
+        elif format in {"argb", "rgba", "abgr", "bgra"}:
+            check_ndarray(array, "uint8", 3)
+            check_ndarray_shape(array, array.shape[2] == 4)
+        elif format in {"rgb48be", "rgb48le", "bgr48be", "bgr48le"}:
+            check_ndarray(array, "uint16", 3)
+            check_ndarray_shape(array, array.shape[2] == 3)
+            frame = VideoFrame(array.shape[1], array.shape[0], format)
+            copy_array_to_plane(
+                byteswap_array(array, format.endswith("be")), frame.planes[0], 6
+            )
+            return frame
+        elif format in {"rgbf32be", "rgbf32le"}:
+            check_ndarray(array, "float32", 3)
+            check_ndarray_shape(array, array.shape[2] == 3)
+            frame = VideoFrame(array.shape[1], array.shape[0], format)
+            copy_array_to_plane(
+                byteswap_array(array, format.endswith("be")), frame.planes[0], 12
+            )
+            return frame
+        elif format in {"rgba64be", "rgba64le", "bgra64be", "bgra64le"}:
+            check_ndarray(array, "uint16", 3)
+            check_ndarray_shape(array, array.shape[2] == 4)
+            frame = VideoFrame(array.shape[1], array.shape[0], format)
+            copy_array_to_plane(
+                byteswap_array(array, format.endswith("be")), frame.planes[0], 8
+            )
+            return frame
+        elif format in {"rgbaf16be", "rgbaf16le"}:
+            check_ndarray(array, "float16", 3)
+            check_ndarray_shape(array, array.shape[2] == 4)
+            frame = VideoFrame(array.shape[1], array.shape[0], format)
+            copy_array_to_plane(
+                byteswap_array(array, format.endswith("be")), frame.planes[0], 8
+            )
+            return frame
+        elif format in {"rgbaf32be", "rgbaf32le"}:
+            check_ndarray(array, "float32", 3)
+            check_ndarray_shape(array, array.shape[2] == 4)
+            frame = VideoFrame(array.shape[1], array.shape[0], format)
+            copy_array_to_plane(
+                byteswap_array(array, format.endswith("be")), frame.planes[0], 16
+            )
+            return frame
+        elif format == "nv12":
+            check_ndarray(array, "uint8", 2)
+            check_ndarray_shape(array, array.shape[0] % 3 == 0)
+            check_ndarray_shape(array, array.shape[1] % 2 == 0)
+
+            frame = VideoFrame(array.shape[1], (array.shape[0] * 2) // 3, format)
+            uv_start = frame.width * frame.height
+            flat = array.reshape(-1)
+            copy_array_to_plane(flat[:uv_start], frame.planes[0], 1)
+            copy_array_to_plane(flat[uv_start:], frame.planes[1], 2)
+            return frame
+        else:
+            raise ValueError(
+                f"Conversion from numpy array with format `{format}` is not yet supported"
+            )
+
+        frame = VideoFrame(array.shape[1], array.shape[0], format)
+        copy_array_to_plane(
+            array, frame.planes[0], 1 if array.ndim == 2 else array.shape[2]
+        )
+
+        return frame
+
+    @staticmethod
+    def from_bytes(
+        img_bytes: bytes,
+        width: int,
+        height: int,
+        format="rgba",
+        flip_horizontal=False,
+        flip_vertical=False,
+    ):
+        frame = VideoFrame(width, height, format)
+        if format == "rgba":
+            copy_bytes_to_plane(
+                img_bytes, frame.planes[0], 4, flip_horizontal, flip_vertical
+            )
+        elif format in {
+            "bayer_bggr8",
+            "bayer_rggb8",
+            "bayer_gbrg8",
+            "bayer_grbg8",
+            "bayer_bggr16le",
+            "bayer_rggb16le",
+            "bayer_gbrg16le",
+            "bayer_grbg16le",
+            "bayer_bggr16be",
+            "bayer_rggb16be",
+            "bayer_gbrg16be",
+            "bayer_grbg16be",
+        }:
+            copy_bytes_to_plane(
+                img_bytes,
+                frame.planes[0],
+                1 if format.endswith("8") else 2,
+                flip_horizontal,
+                flip_vertical,
+            )
+        else:
+            raise NotImplementedError(f"Format '{format}' is not supported.")
+        return frame
+
+    @staticmethod
+    def from_dlpack(
+        planes,
+        format: str = "nv12",
+        width: int = 0,
+        height: int = 0,
+        stream=None,
+        device_id: int | None = None,
+        primary_ctx: bool = True,
+        cuda_context=None,
+    ):
+        if not isinstance(planes, (tuple, list)):
+            planes = (planes,)
+
+        if len(planes) != 2:
+            raise ValueError(
+                "from_dlpack currently supports 2-plane formats only (nv12/p010le/p016le)"
+            )
+
+        sw_fmt: lib.AVPixelFormat = get_pix_fmt(format)
+        nv12 = get_pix_fmt(b"nv12")
+        p010le = get_pix_fmt(b"p010le")
+        p016le = get_pix_fmt(b"p016le")
+
+        if sw_fmt not in (nv12, p010le, p016le):
+            raise NotImplementedError("from_dlpack supports nv12, p010le, p016le only")
+
+        expected_bits = 8 if sw_fmt == nv12 else 16
+        itemsize = 1 if expected_bits == 8 else 2
+
+        m0: cython.pointer[DLManagedTensor] = cython.NULL
+        m1: cython.pointer[DLManagedTensor] = cython.NULL
+        frame: VideoFrame = None
+
+        try:
+            m0 = _consume_dlpack(planes[0], stream)
+            m1 = _consume_dlpack(planes[1], stream)
+
+            dev_type0 = m0.dl_tensor.device_type
+            dev_type1 = m1.dl_tensor.device_type
+            if dev_type0 != dev_type1:
+                raise ValueError("plane tensors must have the same device_type")
+            if dev_type0 not in (kCuda, kCPU):
+                raise NotImplementedError(
+                    "only CPU and CUDA DLPack tensors are supported"
+                )
+
+            dev0 = m0.dl_tensor.device_id
+            dev1 = m1.dl_tensor.device_id
+            if dev0 != dev1:
+                raise ValueError("plane tensors must be on the same CUDA device")
+            if dev_type0 == kCuda:
+                if device_id is None:
+                    device_id = dev0
+                elif device_id != dev0:
+                    raise ValueError(
+                        "device_id does not match the DLPack tensor device_id"
+                    )
+            else:
+                if device_id not in (None, 0):
+                    raise ValueError("device_id must be 0 for CPU tensors")
+                device_id = 0
+            if dev_type0 == kCPU and (dev0 != 0 or dev1 != 0):
+                raise ValueError("CPU DLPack tensors must have device_id == 0")
+
+            if (
+                m0.dl_tensor.dtype.code != 1
+                or m0.dl_tensor.dtype.bits != expected_bits
+                or m0.dl_tensor.dtype.lanes != 1
+            ):
+                raise TypeError("unexpected dtype for plane 0")
+            if (
+                m1.dl_tensor.dtype.code != 1
+                or m1.dl_tensor.dtype.bits != expected_bits
+                or m1.dl_tensor.dtype.lanes != 1
+            ):
+                raise TypeError("unexpected dtype for plane 1")
+
+            if m0.dl_tensor.ndim != 2:
+                raise ValueError("plane 0 must be 2D (H, W)")
+
+            y_h = cython.cast(int64_t, m0.dl_tensor.shape[0])
+            y_w = cython.cast(int64_t, m0.dl_tensor.shape[1])
+
+            if width == 0 and height == 0:
+                width = cython.cast(int, y_w)
+                height = cython.cast(int, y_h)
+            elif width == 0 or height == 0:
+                raise ValueError("either specify both width/height or neither")
+            else:
+                if y_w != width or y_h != height:
+                    raise ValueError("plane 0 shape does not match width/height")
+
+            if width % 2 or height % 2:
+                raise ValueError("width/height must be even for nv12/p010le/p016le")
+
+            if m0.dl_tensor.strides != cython.NULL:
+                if m0.dl_tensor.strides[1] != 1:
+                    raise ValueError("plane 0 must be contiguous in the last dimension")
+                y_pitch_elems = cython.cast(int64_t, m0.dl_tensor.strides[0])
+            else:
+                y_pitch_elems = cython.cast(int64_t, width)
+
+            y_linesize = cython.cast(int, y_pitch_elems * itemsize)
+            y_size = cython.cast(int, y_linesize * height)
+
+            uv_ndim = m1.dl_tensor.ndim
+            uv_h_expected = height // 2
+
+            if uv_ndim == 2:
+                uv_h = cython.cast(int, m1.dl_tensor.shape[0])
+                uv_w = cython.cast(int, m1.dl_tensor.shape[1])
+                if uv_h != uv_h_expected or uv_w != width:
+                    raise ValueError("plane 1 must have shape (H/2, W) for 2D UV")
+                if m1.dl_tensor.strides != cython.NULL:
+                    if m1.dl_tensor.strides[1] != 1:
+                        raise ValueError(
+                            "plane 1 must be contiguous in the last dimension"
+                        )
+                    uv_pitch_elems = cython.cast(int64_t, m1.dl_tensor.strides[0])
+                else:
+                    uv_pitch_elems = cython.cast(int64_t, uv_w)
+            elif uv_ndim == 3:
+                uv_h = cython.cast(int, m1.dl_tensor.shape[0])
+                uv_w2 = cython.cast(int, m1.dl_tensor.shape[1])
+                uv_c = cython.cast(int, m1.dl_tensor.shape[2])
+                if uv_h != uv_h_expected or uv_w2 != (width // 2) or uv_c != 2:
+                    raise ValueError("plane 1 must have shape (H/2, W/2, 2) for 3D UV")
+                if m1.dl_tensor.strides != cython.NULL:
+                    if m1.dl_tensor.strides[2] != 1 or m1.dl_tensor.strides[1] != 2:
+                        raise ValueError(
+                            "unexpected UV plane strides for (H/2, W/2, 2)"
+                        )
+                    uv_pitch_elems = cython.cast(int64_t, m1.dl_tensor.strides[0])
+                else:
+                    uv_pitch_elems = cython.cast(int64_t, width)
+            else:
+                raise ValueError("plane 1 must be 2D or 3D")
+
+            uv_linesize = cython.cast(int, uv_pitch_elems * itemsize)
+            uv_size = cython.cast(int, uv_linesize * (height // 2))
+
+            frame = alloc_video_frame()
+            frame.ptr.width = width
+            frame.ptr.height = height
+            if dev_type0 == kCuda:
+                ctx: CudaContext
+                frames_ref: cython.pointer[lib.AVBufferRef]
+                if cuda_context is None:
+                    ctx = CudaContext(device_id=device_id, primary_ctx=primary_ctx)
+                else:
+                    if not isinstance(cuda_context, CudaContext):
+                        raise TypeError("cuda_context must be a CudaContext")
+                    if int(cuda_context.device_id) != int(device_id):
+                        raise ValueError(
+                            "cuda_context.device_id does not match the DLPack tensor device_id"
+                        )
+                    if bool(cuda_context.primary_ctx) != bool(primary_ctx):
+                        raise ValueError(
+                            "cuda_context.primary_ctx does not match primary_ctx"
+                        )
+                    ctx = cython.cast(CudaContext, cuda_context)
+
+                frames_ref = ctx.get_frames_ctx(sw_fmt, width, height)
+                frame.ptr.format = get_pix_fmt(b"cuda")
+                frame.ptr.hw_frames_ctx = frames_ref
+                frame._device_id = device_id
+                frame._cuda_ctx = ctx
+            else:
+                frame.ptr.format = sw_fmt
+
+            y_ptr = cython.cast(
+                cython.pointer[uint8_t], m0.dl_tensor.data
+            ) + cython.cast(cython.size_t, m0.dl_tensor.byte_offset)
+            uv_ptr = cython.cast(
+                cython.pointer[uint8_t], m1.dl_tensor.data
+            ) + cython.cast(cython.size_t, m1.dl_tensor.byte_offset)
+
+            frame.ptr.buf[0] = lib.av_buffer_create(
+                y_ptr, y_size, _dlpack_avbuffer_free, cython.cast(cython.p_void, m0), 0
+            )
+            if frame.ptr.buf[0] == cython.NULL:
+                raise MemoryError("av_buffer_create failed for plane 0")
+            frame.ptr.data[0] = y_ptr
+            frame.ptr.linesize[0] = y_linesize
+            m0 = cython.NULL
+
+            frame.ptr.buf[1] = lib.av_buffer_create(
+                uv_ptr,
+                uv_size,
+                _dlpack_avbuffer_free,
+                cython.cast(cython.p_void, m1),
+                0,
+            )
+            if frame.ptr.buf[1] == cython.NULL:
+                raise MemoryError("av_buffer_create failed for plane 1")
+            frame.ptr.data[1] = uv_ptr
+            frame.ptr.linesize[1] = uv_linesize
+            m1 = cython.NULL
+
+            frame._init_user_attributes()
+            return frame
+
+        except Exception:
+            if frame is not None:
+                lib.av_frame_unref(frame.ptr)
+            if m0 != cython.NULL:
+                m0.deleter(m0)
+            if m1 != cython.NULL:
+                m1.deleter(m1)
+            raise

.venvs/kimodo/lib/python3.10/site-packages/av/video/frame.pyi

@@ -0,0 +1,110 @@
+from enum import IntEnum
+from pathlib import Path
+from typing import Any, Union
+
+import numpy as np
+
+from av.frame import Frame
+
+from .format import VideoFormat
+from .plane import VideoPlane
+from .reformatter import ColorPrimaries, ColorTrc
+
+_SupportedNDarray = Union[
+    np.ndarray[Any, np.dtype[np.uint8]],
+    np.ndarray[Any, np.dtype[np.uint16]],
+    np.ndarray[Any, np.dtype[np.float16]],
+    np.ndarray[Any, np.dtype[np.float32]],
+]
+
+supported_np_pix_fmts: set[str]
+
+class PictureType(IntEnum):
+    NONE = 0
+    I = 1
+    P = 2
+    B = 3
+    S = 4
+    SI = 5
+    SP = 6
+    BI = 7
+
+class CudaContext:
+    @property
+    def device_id(self) -> int: ...
+    @property
+    def primary_ctx(self) -> bool: ...
+    def __init__(self, device_id: int = 0, primary_ctx: bool = True) -> None: ...
+
+class VideoFrame(Frame):
+    format: VideoFormat
+    planes: tuple[VideoPlane, ...]
+    pict_type: int
+    colorspace: int
+    color_range: int
+    color_trc: int
+    color_primaries: int
+
+    @property
+    def time(self) -> float: ...
+    @property
+    def width(self) -> int: ...
+    @property
+    def height(self) -> int: ...
+    @property
+    def interlaced_frame(self) -> bool: ...
+    @property
+    def rotation(self) -> int: ...
+    def __init__(
+        self, width: int = 0, height: int = 0, format: str = "yuv420p"
+    ) -> None: ...
+    def reformat(
+        self,
+        width: int | None = None,
+        height: int | None = None,
+        format: str | None = None,
+        src_colorspace: str | int | None = None,
+        dst_colorspace: str | int | None = None,
+        interpolation: int | str | None = None,
+        src_color_range: int | str | None = None,
+        dst_color_range: int | str | None = None,
+        dst_color_trc: int | ColorTrc | None = None,
+        dst_color_primaries: int | ColorPrimaries | None = None,
+        threads: int | None = None,
+    ) -> VideoFrame: ...
+    def to_rgb(self, **kwargs: Any) -> VideoFrame: ...
+    def save(self, filepath: str | Path) -> None: ...
+    def to_image(self, **kwargs): ...
+    def to_ndarray(
+        self, channel_last: bool = False, **kwargs: Any
+    ) -> _SupportedNDarray: ...
+    @staticmethod
+    def from_image(img): ...
+    @staticmethod
+    def from_numpy_buffer(
+        array: _SupportedNDarray, format: str = "rgb24", width: int = 0
+    ) -> VideoFrame: ...
+    @staticmethod
+    def from_ndarray(
+        array: _SupportedNDarray, format: str = "rgb24", channel_last: bool = False
+    ) -> VideoFrame: ...
+    @staticmethod
+    def from_bytes(
+        data: bytes,
+        width: int,
+        height: int,
+        format: str = "rgba",
+        flip_horizontal: bool = False,
+        flip_vertical: bool = False,
+    ) -> VideoFrame: ...
+    @staticmethod
+    def from_dlpack(
+        planes: object | tuple[object, ...],
+        format: str = "nv12",
+        width: int = 0,
+        height: int = 0,
+        stream: int | None = None,
+        device_id: int | None = None,
+        primary_ctx: bool = True,
+        cuda_context: CudaContext | None = None,
+    ) -> VideoFrame: ...

.venvs/kimodo/lib/python3.10/site-packages/av/video/plane.cpython-310-darwin.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a0a050b7e962550479fe28418c37731601d3ccd3489c574fef23b1da6cbbef62
+size 117184

.venvs/kimodo/lib/python3.10/site-packages/av/video/plane.pxd

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

.venvs/kimodo/lib/python3.10/site-packages/av/video/plane.py

@@ -0,0 +1,305 @@
+import cython
+import cython.cimports.libav as lib
+from cython.cimports.av.error import err_check
+from cython.cimports.av.video.format import (
+    VideoFormatComponent,
+    get_pix_fmt,
+    get_video_format,
+)
+from cython.cimports.av.video.frame import VideoFrame
+from cython.cimports.cpython import PyBUF_WRITABLE, PyBuffer_FillInfo
+from cython.cimports.cpython.buffer import Py_buffer
+from cython.cimports.cpython.pycapsule import (
+    PyCapsule_GetPointer,
+    PyCapsule_IsValid,
+    PyCapsule_New,
+)
+from cython.cimports.libc.stdlib import free, malloc
+
+
+@cython.final
+@cython.cclass
+class VideoPlane(Plane):
+    def __cinit__(self, frame: VideoFrame, index: cython.int):
+        # The palette plane has no associated component or linesize; set fields manually
+        fmt = frame.format
+        if frame.ptr.hw_frames_ctx:
+            frames_ctx: cython.pointer[lib.AVHWFramesContext] = cython.cast(
+                cython.pointer[lib.AVHWFramesContext], frame.ptr.hw_frames_ctx.data
+            )
+            fmt = get_video_format(
+                frames_ctx.sw_format, frame.ptr.width, frame.ptr.height
+            )
+
+        if index == 1 and fmt.name == "pal8":
+            self.width = 256
+            self.height = 1
+            self.buffer_size = 256 * 4
+            return
+
+        for i in range(fmt.ptr.nb_components):
+            if fmt.ptr.comp[i].plane == index:
+                component = VideoFormatComponent(fmt, i)
+                self.width = component.width
+                self.height = component.height
+                break
+        else:
+            raise RuntimeError(f"could not find plane {index} of {fmt!r}")
+
+        # Sometimes, linesize is negative (and that is meaningful). We are only
+        # insisting that the buffer size be based on the extent of linesize, and
+        # ignore it's direction.
+        self.buffer_size = abs(self.frame.ptr.linesize[self.index]) * self.height
+
+    @cython.cfunc
+    def _buffer_size(self) -> cython.size_t:
+        return self.buffer_size
+
+    @property
+    def line_size(self):
+        """
+        Bytes per horizontal line in this plane.
+
+        :type: int
+        """
+        return self.frame.ptr.linesize[self.index]
+
+    @cython.cfunc
+    def _buffer_writable(self) -> cython.bint:
+        if self.frame.ptr.hw_frames_ctx:
+            return False
+        return True
+
+    def __getbuffer__(self, view: cython.pointer[Py_buffer], flags: cython.int):
+        if self.frame.ptr.hw_frames_ctx:
+            raise TypeError(
+                "Hardware frame planes do not support the Python buffer protocol. "
+                "Use DLPack (__dlpack__) or download to a software frame."
+            )
+        if flags & PyBUF_WRITABLE and not self._buffer_writable():
+            raise ValueError("buffer is not writable")
+
+        ptr: cython.p_void = self._buffer_ptr()
+        line_size: cython.int = self.frame.ptr.linesize[self.index]
+        if line_size < 0:
+            height: cython.int = self.height
+            ptr = cython.cast(cython.p_char, ptr) + (height - 1) * line_size
+
+        PyBuffer_FillInfo(view, self, ptr, self._buffer_size(), 0, flags)
+
+    def __dlpack_device__(self):
+        if self.frame.ptr.hw_frames_ctx:
+            if cython.cast(lib.AVPixelFormat, self.frame.ptr.format) != get_pix_fmt(
+                b"cuda"
+            ):
+                raise NotImplementedError(
+                    "DLPack export is only implemented for CUDA hw frames"
+                )
+            return (kCuda, self.frame._device_id)
+        return (kCPU, 0)
+
+    def __dlpack__(self, *, stream: int | None = None):
+        if self.frame.ptr.buf[0] == cython.NULL:
+            raise TypeError(
+                "DLPack export requires a refcounted AVFrame (frame.buf[0] is NULL)"
+            )
+
+        sw_fmt: lib.AVPixelFormat
+        device_type: cython.int
+        device_id: cython.int
+
+        if self.frame.ptr.hw_frames_ctx:
+            if cython.cast(lib.AVPixelFormat, self.frame.ptr.format) != get_pix_fmt(
+                b"cuda"
+            ):
+                raise NotImplementedError(
+                    "DLPack export is only implemented for CUDA hw frames"
+                )
+            if stream is not None:
+                raise NotImplementedError(
+                    "CUDA stream synchronization is not supported. "
+                    "Pass stream=None and synchronize before calling __dlpack__."
+                )
+
+            frames_ctx: cython.pointer[lib.AVHWFramesContext] = cython.cast(
+                cython.pointer[lib.AVHWFramesContext], self.frame.ptr.hw_frames_ctx.data
+            )
+            sw_fmt = frames_ctx.sw_format
+            device_type = kCuda
+            device_id = self.frame._device_id
+        else:
+            sw_fmt = cython.cast(lib.AVPixelFormat, self.frame.ptr.format)
+            device_type = kCPU
+            device_id = 0
+
+        line_size = self.line_size
+        if line_size < 0:
+            raise NotImplementedError(
+                "negative linesize is not supported for DLPack export"
+            )
+
+        nv12 = get_pix_fmt(b"nv12")
+        p010le = get_pix_fmt(b"p010le")
+        p016le = get_pix_fmt(b"p016le")
+
+        ndim, bits, itemsize = cython.declare(cython.int)
+        s0, s1, s2 = cython.declare(int64_t)
+        st0, st1, st2 = cython.declare(int64_t)
+
+        if sw_fmt == nv12:
+            itemsize = 1
+            bits = 8
+            if self.index == 0:
+                ndim = 2
+                s0 = self.frame.ptr.height
+                s1 = self.frame.ptr.width
+                st0 = line_size
+                st1 = 1
+            elif self.index == 1:
+                ndim = 3
+                s0 = self.frame.ptr.height // 2
+                s1 = self.frame.ptr.width // 2
+                s2 = 2
+                st0 = line_size
+                st1 = 2
+                st2 = 1
+            else:
+                raise ValueError("invalid plane index for NV12")
+        elif sw_fmt == p010le or sw_fmt == p016le:
+            itemsize = 2
+            bits = 16
+            if line_size % itemsize:
+                raise ValueError("linesize is not aligned to dtype")
+            if self.index == 0:
+                ndim = 2
+                s0 = self.frame.ptr.height
+                s1 = self.frame.ptr.width
+                st0 = line_size // itemsize
+                st1 = 1
+            elif self.index == 1:
+                ndim = 3
+                s0 = self.frame.ptr.height // 2
+                s1 = self.frame.ptr.width // 2
+                s2 = 2
+                st0 = line_size // itemsize
+                st1 = 2
+                st2 = 1
+            else:
+                raise ValueError("invalid plane index for P010/P016")
+        else:
+            raise NotImplementedError("unsupported sw_format for DLPack export")
+
+        frame_ref: cython.pointer[lib.AVFrame] = lib.av_frame_alloc()
+        if frame_ref == cython.NULL:
+            raise MemoryError("av_frame_alloc() failed")
+        err_check(lib.av_frame_ref(frame_ref, self.frame.ptr))
+
+        shape = cython.cast(
+            cython.pointer[int64_t], malloc(ndim * cython.sizeof(int64_t))
+        )
+        strides = cython.cast(
+            cython.pointer[int64_t], malloc(ndim * cython.sizeof(int64_t))
+        )
+        if shape == cython.NULL or strides == cython.NULL:
+            if shape != cython.NULL:
+                free(shape)
+            if strides != cython.NULL:
+                free(strides)
+            lib.av_frame_free(cython.address(frame_ref))
+            raise MemoryError("malloc() failed")
+
+        if ndim == 2:
+            shape[0] = s0
+            shape[1] = s1
+            strides[0] = st0
+            strides[1] = st1
+        else:
+            shape[0] = s0
+            shape[1] = s1
+            shape[2] = s2
+            strides[0] = st0
+            strides[1] = st1
+            strides[2] = st2
+
+        ctx = cython.cast(
+            cython.pointer[cython.p_void], malloc(3 * cython.sizeof(cython.p_void))
+        )
+        if ctx == cython.NULL:
+            free(shape)
+            free(strides)
+            lib.av_frame_free(cython.address(frame_ref))
+            raise MemoryError("malloc() failed")
+
+        ctx[0] = cython.cast(cython.p_void, frame_ref)
+        ctx[1] = cython.cast(cython.p_void, shape)
+        ctx[2] = cython.cast(cython.p_void, strides)
+
+        managed = cython.cast(
+            cython.pointer[DLManagedTensor], malloc(cython.sizeof(DLManagedTensor))
+        )
+        if managed == cython.NULL:
+            free(ctx)
+            free(shape)
+            free(strides)
+            lib.av_frame_free(cython.address(frame_ref))
+            raise MemoryError("malloc() failed")
+
+        managed.dl_tensor.data = cython.cast(cython.p_void, frame_ref.data[self.index])
+        managed.dl_tensor.device_type = device_type
+        managed.dl_tensor.device_id = device_id
+        managed.dl_tensor.ndim = ndim
+        managed.dl_tensor.dtype = DLDataType(code=1, bits=bits, lanes=1)
+        managed.dl_tensor.shape = shape
+        managed.dl_tensor.strides = strides
+        managed.dl_tensor.byte_offset = 0
+        managed.manager_ctx = cython.cast(cython.p_void, ctx)
+        managed.deleter = _dlpack_managed_tensor_deleter
+
+        try:
+            capsule = PyCapsule_New(
+                cython.cast(cython.p_void, managed),
+                b"dltensor",
+                _dlpack_capsule_destructor,
+            )
+        except Exception:
+            _dlpack_managed_tensor_deleter(managed)
+            raise
+
+        return capsule
+
+
+@cython.cfunc
+@cython.nogil
+@cython.exceptval(check=False)
+def _dlpack_managed_tensor_deleter(
+    managed: cython.pointer[DLManagedTensor],
+) -> cython.void:
+    if managed == cython.NULL:
+        return
+    ctx = cython.cast(cython.pointer[cython.p_void], managed.manager_ctx)
+    if ctx != cython.NULL:
+        frame_ref = cython.cast(cython.pointer[lib.AVFrame], ctx[0])
+        shape = cython.cast(cython.pointer[int64_t], ctx[1])
+        strides = cython.cast(cython.pointer[int64_t], ctx[2])
+
+        if frame_ref != cython.NULL:
+            lib.av_frame_free(cython.address(frame_ref))
+        if shape != cython.NULL:
+            free(shape)
+        if strides != cython.NULL:
+            free(strides)
+        free(ctx)
+
+    free(managed)
+
+
+@cython.cfunc
+@cython.exceptval(check=False)
+def _dlpack_capsule_destructor(capsule: object) -> cython.void:
+    if PyCapsule_IsValid(capsule, b"dltensor"):
+        managed = cython.cast(
+            cython.pointer[DLManagedTensor],
+            PyCapsule_GetPointer(capsule, b"dltensor"),
+        )
+        if managed != cython.NULL:
+            managed.deleter(managed)

.venvs/kimodo/lib/python3.10/site-packages/av/video/plane.pyi

@@ -0,0 +1,15 @@
+from types import CapsuleType
+
+from av.plane import Plane
+
+from .frame import VideoFrame
+
+class VideoPlane(Plane):
+    line_size: int
+    width: int
+    height: int
+    buffer_size: int
+
+    def __init__(self, frame: VideoFrame, index: int) -> None: ...
+    def __dlpack_device__(self) -> tuple[int, int]: ...
+    def __dlpack__(self, *, stream: int | None = None) -> CapsuleType: ...

.venvs/kimodo/lib/python3.10/site-packages/av/video/reformatter.cpython-310-darwin.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8fbe4c18b85a6598b6c3ed80751e08d39e9bc1f8dba54b63d1ab28636ce8224b
+size 131616

.venvs/kimodo/lib/python3.10/site-packages/av/video/reformatter.pxd

@@ -0,0 +1,42 @@
+cimport libav as lib
+
+from av.video.frame cimport VideoFrame
+
+
+cdef extern from "libswscale/swscale.h" nogil:
+    cdef struct SwsContext:
+        unsigned flags
+        int threads
+
+    cdef int SWS_FAST_BILINEAR
+    cdef int SWS_BILINEAR
+    cdef int SWS_BICUBIC
+    cdef int SWS_X
+    cdef int SWS_POINT
+    cdef int SWS_AREA
+    cdef int SWS_BICUBLIN
+    cdef int SWS_GAUSS
+    cdef int SWS_SINC
+    cdef int SWS_LANCZOS
+    cdef int SWS_SPLINE
+    cdef int SWS_CS_ITU709
+    cdef int SWS_CS_FCC
+    cdef int SWS_CS_ITU601
+    cdef int SWS_CS_ITU624
+    cdef int SWS_CS_SMPTE170M
+    cdef int SWS_CS_SMPTE240M
+    cdef int SWS_CS_DEFAULT
+
+    cdef SwsContext *sws_alloc_context()
+    cdef void sws_free_context(SwsContext **ctx)
+    cdef int sws_scale_frame(SwsContext *c, lib.AVFrame *dst, const lib.AVFrame *src)
+
+cdef class VideoReformatter:
+    cdef SwsContext *ptr
+    cdef _reformat(self, VideoFrame frame, int width, int height,
+                   lib.AVPixelFormat format, int src_colorspace,
+                   int dst_colorspace, int interpolation,
+                   int src_color_range, int dst_color_range,
+                   int dst_color_trc, int dst_color_primaries,
+                   bint set_dst_color_trc, bint set_dst_color_primaries,
+                   int threads)

.venvs/kimodo/lib/python3.10/site-packages/av/video/reformatter.py

@@ -0,0 +1,322 @@
+from enum import IntEnum
+
+import cython
+import cython.cimports.libav as lib
+from cython.cimports.av.error import err_check
+from cython.cimports.av.video.format import VideoFormat, get_pix_fmt
+from cython.cimports.av.video.frame import alloc_video_frame
+
+
+class Interpolation(IntEnum):
+    FAST_BILINEAR: "Fast bilinear" = SWS_FAST_BILINEAR
+    BILINEAR: "Bilinear" = SWS_BILINEAR
+    BICUBIC: "2-tap cubic B-spline" = SWS_BICUBIC
+    X: "Experimental" = SWS_X
+    POINT: "Nearest neighbor / point" = SWS_POINT
+    AREA: "Area averaging" = SWS_AREA
+    BICUBLIN: "Bicubic luma / Bilinear chroma" = SWS_BICUBLIN
+    GAUSS: "Gaussian approximation" = SWS_GAUSS
+    SINC: "Unwindowed Sinc" = SWS_SINC
+    LANCZOS: "3-tap sinc/sinc" = SWS_LANCZOS
+    SPLINE: "Unwindowed natural cubic spline" = SWS_SPLINE
+
+
+class Colorspace(IntEnum):
+    ITU709 = SWS_CS_ITU709
+    FCC = SWS_CS_FCC
+    ITU601 = SWS_CS_ITU601
+    ITU624 = SWS_CS_ITU624
+    SMPTE170M = SWS_CS_SMPTE170M
+    SMPTE240M = SWS_CS_SMPTE240M
+    DEFAULT = SWS_CS_DEFAULT
+    # Lowercase for b/c.
+    itu709 = SWS_CS_ITU709
+    fcc = SWS_CS_FCC
+    itu601 = SWS_CS_ITU601
+    itu624 = SWS_CS_ITU624
+    smpte170m = SWS_CS_SMPTE170M
+    smpte240m = SWS_CS_SMPTE240M
+    default = SWS_CS_DEFAULT
+
+
+class ColorRange(IntEnum):
+    UNSPECIFIED: "Unspecified" = lib.AVCOL_RANGE_UNSPECIFIED
+    MPEG: "MPEG (limited) YUV range, 219*2^(n-8)" = lib.AVCOL_RANGE_MPEG
+    JPEG: "JPEG (full) YUV range, 2^n-1" = lib.AVCOL_RANGE_JPEG
+    NB: "Not part of ABI" = lib.AVCOL_RANGE_NB
+
+
+class ColorTrc(IntEnum):
+    """Transfer characteristic (gamma curve) of a video frame.
+
+    Maps to FFmpeg's ``AVColorTransferCharacteristic``.
+    """
+
+    BT709: "BT.709" = lib.AVCOL_TRC_BT709
+    UNSPECIFIED: "Unspecified" = lib.AVCOL_TRC_UNSPECIFIED
+    GAMMA22: "Gamma 2.2 (BT.470M)" = lib.AVCOL_TRC_GAMMA22
+    GAMMA28: "Gamma 2.8 (BT.470BG)" = lib.AVCOL_TRC_GAMMA28
+    SMPTE170M: "SMPTE 170M" = lib.AVCOL_TRC_SMPTE170M
+    SMPTE240M: "SMPTE 240M" = lib.AVCOL_TRC_SMPTE240M
+    LINEAR: "Linear" = lib.AVCOL_TRC_LINEAR
+    LOG: "Logarithmic (100:1 range)" = lib.AVCOL_TRC_LOG
+    LOG_SQRT: "Logarithmic (100*sqrt(10):1 range)" = lib.AVCOL_TRC_LOG_SQRT
+    IEC61966_2_4: "IEC 61966-2-4 (sRGB)" = lib.AVCOL_TRC_IEC61966_2_4
+    BT1361_ECG: "BT.1361 extended colour gamut" = lib.AVCOL_TRC_BT1361_ECG
+    IEC61966_2_1: "IEC 61966-2-1 (sYCC)" = lib.AVCOL_TRC_IEC61966_2_1
+    BT2020_10: "BT.2020 10-bit" = lib.AVCOL_TRC_BT2020_10
+    BT2020_12: "BT.2020 12-bit" = lib.AVCOL_TRC_BT2020_12
+    SMPTE2084: "SMPTE 2084 (PQ, HDR10)" = lib.AVCOL_TRC_SMPTE2084
+    SMPTE428: "SMPTE 428-1" = lib.AVCOL_TRC_SMPTE428
+    ARIB_STD_B67: "ARIB STD-B67 (HLG)" = lib.AVCOL_TRC_ARIB_STD_B67
+
+
+class ColorPrimaries(IntEnum):
+    """Color primaries of a video frame.
+
+    Maps to FFmpeg's ``AVColorPrimaries``.
+    """
+
+    BT709: "BT.709 / sRGB / sYCC" = lib.AVCOL_PRI_BT709
+    UNSPECIFIED: "Unspecified" = lib.AVCOL_PRI_UNSPECIFIED
+    BT470M: "BT.470M" = lib.AVCOL_PRI_BT470M
+    BT470BG: "BT.470BG / BT.601-6 625" = lib.AVCOL_PRI_BT470BG
+    SMPTE170M: "SMPTE 170M / BT.601-6 525" = lib.AVCOL_PRI_SMPTE170M
+    SMPTE240M: "SMPTE 240M" = lib.AVCOL_PRI_SMPTE240M
+    FILM: "Generic film (Illuminant C)" = lib.AVCOL_PRI_FILM
+    BT2020: "BT.2020 / BT.2100" = lib.AVCOL_PRI_BT2020
+    SMPTE428: "SMPTE 428-1 / XYZ" = lib.AVCOL_PRI_SMPTE428
+    SMPTE431: "SMPTE 431-2 (DCI-P3)" = lib.AVCOL_PRI_SMPTE431
+    SMPTE432: "SMPTE 432-1 (Display P3)" = lib.AVCOL_PRI_SMPTE432
+    EBU3213: "EBU 3213-E / JEDEC P22" = lib.AVCOL_PRI_EBU3213
+
+
+@cython.cfunc
+@cython.inline
+def _resolve_enum_value(
+    value: object, enum_class: object, default: cython.int
+) -> cython.int:
+    # Helper function to resolve enum values from different input types.
+    if value is None:
+        return default
+    if isinstance(value, enum_class):
+        return value.value
+    if isinstance(value, int):
+        return value
+    if isinstance(value, str):
+        return enum_class[value].value
+    raise ValueError(f"Cannot convert {value} to {enum_class.__name__}")
+
+
+@cython.cfunc
+@cython.inline
+def _resolve_format(format: object, default: lib.AVPixelFormat) -> lib.AVPixelFormat:
+    if format is None:
+        return default
+    if isinstance(format, VideoFormat):
+        return cython.cast(VideoFormat, format).pix_fmt
+    return get_pix_fmt(format)
+
+
+@cython.cfunc
+def _set_frame_colorspace(
+    frame: cython.pointer(lib.AVFrame),
+    colorspace: cython.int,
+    color_range: cython.int,
+):
+    """Set AVFrame colorspace/range from SWS_CS_* and AVColorRange values."""
+    if color_range != lib.AVCOL_RANGE_UNSPECIFIED:
+        frame.color_range = cython.cast(lib.AVColorRange, color_range)
+    # Mapping from SWS_CS_* (swscale colorspace) to AVColorSpace (frame metadata).
+    # Note: SWS_CS_ITU601, SWS_CS_ITU624, SWS_CS_SMPTE170M, and SWS_CS_DEFAULT all have
+    # the same value (5), so we map 5 -> AVCOL_SPC_SMPTE170M as the most common case.
+    # SWS_CS_DEFAULT is handled specially by not setting frame metadata.
+    if colorspace == SWS_CS_ITU709:
+        frame.colorspace = lib.AVCOL_SPC_BT709
+    elif colorspace == SWS_CS_FCC:
+        frame.colorspace = lib.AVCOL_SPC_FCC
+    elif colorspace == SWS_CS_ITU601:
+        frame.colorspace = lib.AVCOL_SPC_SMPTE170M
+    elif colorspace == SWS_CS_SMPTE240M:
+        frame.colorspace = lib.AVCOL_SPC_SMPTE240M
+
+
+@cython.final
+@cython.cclass
+class VideoReformatter:
+    """An object for reformatting size and pixel format of :class:`.VideoFrame`.
+
+    It is most efficient to have a reformatter object for each set of parameters
+    you will use as calling :meth:`reformat` will reconfigure the internal object.
+
+    """
+
+    def __dealloc__(self):
+        with cython.nogil:
+            sws_free_context(cython.address(self.ptr))
+
+    def reformat(
+        self,
+        frame: VideoFrame,
+        width=None,
+        height=None,
+        format=None,
+        src_colorspace=None,
+        dst_colorspace=None,
+        interpolation=None,
+        src_color_range=None,
+        dst_color_range=None,
+        dst_color_trc=None,
+        dst_color_primaries=None,
+        threads=None,
+    ):
+        """Create a new :class:`VideoFrame` with the given width/height/format/colorspace.
+
+        Returns the same frame untouched if nothing needs to be done to it.
+
+        :param int width: New width, or ``None`` for the same width.
+        :param int height: New height, or ``None`` for the same height.
+        :param format: New format, or ``None`` for the same format.
+        :type  format: :class:`.VideoFormat` or ``str``
+        :param src_colorspace: Current colorspace, or ``None`` for the frame colorspace.
+        :type  src_colorspace: :class:`Colorspace` or ``str``
+        :param dst_colorspace: Desired colorspace, or ``None`` for the frame colorspace.
+        :type  dst_colorspace: :class:`Colorspace` or ``str``
+        :param interpolation: The interpolation method to use, or ``None`` for ``BILINEAR``.
+        :type  interpolation: :class:`Interpolation` or ``str``
+        :param src_color_range: Current color range, or ``None`` for the ``UNSPECIFIED``.
+        :type  src_color_range: :class:`ColorRange` or ``str``
+        :param dst_color_range: Desired color range, or ``None`` for the ``UNSPECIFIED``.
+        :type  dst_color_range: :class:`ColorRange` or ``str``
+        :param dst_color_trc: Desired transfer characteristic to tag on the output frame,
+            or ``None`` to preserve the source frame's value. This sets frame metadata only;
+            it does not perform a pixel-level transfer function conversion.
+        :type  dst_color_trc: :class:`ColorTrc` or ``int``
+        :param dst_color_primaries: Desired color primaries to tag on the output frame,
+            or ``None`` to preserve the source frame's value.
+        :type  dst_color_primaries: :class:`ColorPrimaries` or ``int``
+        :param int threads: How many threads to use for scaling, or ``0`` for automatic
+            selection based on the number of available CPUs. Defaults to ``0`` (auto).
+
+        """
+        c_dst_format = _resolve_format(format, frame.format.pix_fmt)
+        c_src_colorspace = _resolve_enum_value(
+            src_colorspace, Colorspace, frame.ptr.colorspace
+        )
+        c_dst_colorspace = _resolve_enum_value(
+            dst_colorspace, Colorspace, frame.ptr.colorspace
+        )
+        c_interpolation = _resolve_enum_value(
+            interpolation, Interpolation, SWS_BILINEAR
+        )
+        c_src_color_range = _resolve_enum_value(src_color_range, ColorRange, 0)
+        c_dst_color_range = _resolve_enum_value(dst_color_range, ColorRange, 0)
+        c_dst_color_trc = _resolve_enum_value(dst_color_trc, ColorTrc, 0)
+        c_dst_color_primaries = _resolve_enum_value(
+            dst_color_primaries, ColorPrimaries, 0
+        )
+        c_threads: cython.int = threads if threads is not None else 0
+        c_width: cython.int = width if width is not None else frame.ptr.width
+        c_height: cython.int = height if height is not None else frame.ptr.height
+
+        # Track whether user explicitly specified destination metadata
+        set_dst_color_trc: cython.bint = dst_color_trc is not None
+        set_dst_color_primaries: cython.bint = dst_color_primaries is not None
+
+        return self._reformat(
+            frame,
+            c_width,
+            c_height,
+            c_dst_format,
+            c_src_colorspace,
+            c_dst_colorspace,
+            c_interpolation,
+            c_src_color_range,
+            c_dst_color_range,
+            c_dst_color_trc,
+            c_dst_color_primaries,
+            set_dst_color_trc,
+            set_dst_color_primaries,
+            c_threads,
+        )
+
+    @cython.cfunc
+    def _reformat(
+        self,
+        frame: VideoFrame,
+        width: cython.int,
+        height: cython.int,
+        dst_format: lib.AVPixelFormat,
+        src_colorspace: cython.int,
+        dst_colorspace: cython.int,
+        interpolation: cython.int,
+        src_color_range: cython.int,
+        dst_color_range: cython.int,
+        dst_color_trc: cython.int,
+        dst_color_primaries: cython.int,
+        set_dst_color_trc: cython.bint,
+        set_dst_color_primaries: cython.bint,
+        threads: cython.int,
+    ):
+        if frame.ptr.format < 0:
+            raise ValueError("Frame does not have format set.")
+
+        src_format = cython.cast(lib.AVPixelFormat, frame.ptr.format)
+
+        # Shortcut!
+        if (
+            dst_format == src_format
+            and width == frame.ptr.width
+            and height == frame.ptr.height
+            and dst_colorspace == src_colorspace
+            and src_color_range == dst_color_range
+            and not set_dst_color_trc
+            and not set_dst_color_primaries
+        ):
+            return frame
+
+        if frame.ptr.hw_frames_ctx:
+            frame_sw = alloc_video_frame()
+            err_check(lib.av_hwframe_transfer_data(frame_sw.ptr, frame.ptr, 0))
+            frame_sw.pts = frame.pts
+            frame_sw._init_user_attributes()
+            frame = frame_sw
+            src_format = cython.cast(lib.AVPixelFormat, frame.ptr.format)
+
+        if self.ptr == cython.NULL:
+            self.ptr = sws_alloc_context()
+            if self.ptr == cython.NULL:
+                raise MemoryError("Could not allocate SwsContext")
+        self.ptr.threads = threads
+        self.ptr.flags = cython.cast(cython.uint, interpolation)
+
+        new_frame: VideoFrame = alloc_video_frame()
+        new_frame._copy_internal_attributes(frame)
+        new_frame._init(dst_format, width, height)
+
+        # Set source frame colorspace/range so sws_scale_frame can read it
+        frame_src_colorspace: lib.AVColorSpace = frame.ptr.colorspace
+        frame_src_color_range: lib.AVColorRange = frame.ptr.color_range
+        _set_frame_colorspace(frame.ptr, src_colorspace, src_color_range)
+        _set_frame_colorspace(new_frame.ptr, dst_colorspace, dst_color_range)
+
+        with cython.nogil:
+            ret = sws_scale_frame(self.ptr, new_frame.ptr, frame.ptr)
+
+        # Restore source frame colorspace/range to avoid side effects
+        frame.ptr.colorspace = frame_src_colorspace
+        frame.ptr.color_range = frame_src_color_range
+
+        err_check(ret)
+
+        # Set metadata-only properties on the output frame if explicitly specified
+        if set_dst_color_trc:
+            new_frame.ptr.color_trc = cython.cast(
+                lib.AVColorTransferCharacteristic, dst_color_trc
+            )
+        if set_dst_color_primaries:
+            new_frame.ptr.color_primaries = cython.cast(
+                lib.AVColorPrimaries, dst_color_primaries
+            )
+
+        return new_frame

.venvs/kimodo/lib/python3.10/site-packages/av/video/reformatter.pyi

@@ -0,0 +1,89 @@
+from enum import IntEnum
+from typing import cast
+
+from .frame import VideoFrame
+
+class Interpolation(IntEnum):
+    FAST_BILINEAER = cast(int, ...)
+    BILINEAR = cast(int, ...)
+    BICUBIC = cast(int, ...)
+    X = cast(int, ...)
+    POINT = cast(int, ...)
+    AREA = cast(int, ...)
+    BICUBLIN = cast(int, ...)
+    GAUSS = cast(int, ...)
+    SINC = cast(int, ...)
+    LANCZOS = cast(int, ...)
+    SPLINE = cast(int, ...)
+
+class Colorspace(IntEnum):
+    ITU709 = cast(int, ...)
+    FCC = cast(int, ...)
+    ITU601 = cast(int, ...)
+    ITU624 = cast(int, ...)
+    SMPTE170M = cast(int, ...)
+    SMPTE240M = cast(int, ...)
+    DEFAULT = cast(int, ...)
+    itu709 = cast(int, ...)
+    fcc = cast(int, ...)
+    itu601 = cast(int, ...)
+    itu624 = cast(int, ...)
+    smpte170m = cast(int, ...)
+    smpte240m = cast(int, ...)
+    default = cast(int, ...)
+
+class ColorRange(IntEnum):
+    UNSPECIFIED = 0
+    MPEG = 1
+    JPEG = 2
+    NB = 3
+
+class ColorTrc(IntEnum):
+    BT709 = cast(int, ...)
+    UNSPECIFIED = cast(int, ...)
+    GAMMA22 = cast(int, ...)
+    GAMMA28 = cast(int, ...)
+    SMPTE170M = cast(int, ...)
+    SMPTE240M = cast(int, ...)
+    LINEAR = cast(int, ...)
+    LOG = cast(int, ...)
+    LOG_SQRT = cast(int, ...)
+    IEC61966_2_4 = cast(int, ...)
+    BT1361_ECG = cast(int, ...)
+    IEC61966_2_1 = cast(int, ...)
+    BT2020_10 = cast(int, ...)
+    BT2020_12 = cast(int, ...)
+    SMPTE2084 = cast(int, ...)
+    SMPTE428 = cast(int, ...)
+    ARIB_STD_B67 = cast(int, ...)
+
+class ColorPrimaries(IntEnum):
+    BT709 = cast(int, ...)
+    UNSPECIFIED = cast(int, ...)
+    BT470M = cast(int, ...)
+    BT470BG = cast(int, ...)
+    SMPTE170M = cast(int, ...)
+    SMPTE240M = cast(int, ...)
+    FILM = cast(int, ...)
+    BT2020 = cast(int, ...)
+    SMPTE428 = cast(int, ...)
+    SMPTE431 = cast(int, ...)
+    SMPTE432 = cast(int, ...)
+    EBU3213 = cast(int, ...)
+
+class VideoReformatter:
+    def reformat(
+        self,
+        frame: VideoFrame,
+        width: int | None = None,
+        height: int | None = None,
+        format: str | None = None,
+        src_colorspace: int | None = None,
+        dst_colorspace: int | None = None,
+        interpolation: int | str | None = None,
+        src_color_range: int | str | None = None,
+        dst_color_range: int | str | None = None,
+        dst_color_trc: int | ColorTrc | None = None,
+        dst_color_primaries: int | ColorPrimaries | None = None,
+        threads: int | None = None,
+    ) -> VideoFrame: ...

.venvs/kimodo/lib/python3.10/site-packages/av/video/stream.cpython-310-darwin.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:197fa08880a7f5861476cf1e1699ce461cbf87abc80796be695158e1ad00eb8a
+size 135440