Only use aom codec

radarhere · radarhere · commit b88fa560aad6 · 2025-04-05T00:37:30.000+11:00
diff --git a/.github/workflows/wheels-dependencies.sh b/.github/workflows/wheels-dependencies.sh
@@ -122,16 +122,6 @@ function build_libavif {
         build_simple nasm 2.16.03 https://www.nasm.us/pub/nasm/releasebuilds/2.16.03
     fi
 
-    # For rav1e
-    curl https://sh.rustup.rs -sSf | sh -s -- -y
-    . "$HOME/.cargo/env"
-    if [ -z "$IS_ALPINE" ] && [ -z "$SANITIZER" ] && [ -z "$IS_MACOS" ]; then
-        yum install -y perl
-        if [[ "$MB_ML_VER" == 2014 ]]; then
-            yum install -y perl-IPC-Cmd
-        fi
-    fi
-
     local out_dir=$(fetch_unpack https://github.com/AOMediaCodec/libavif/archive/refs/tags/v$LIBAVIF_VERSION.tar.gz libavif-$LIBAVIF_VERSION.tar.gz)
     (cd $out_dir \
         && CMAKE_POLICY_VERSION_MINIMUM=3.5 cmake \
@@ -142,9 +132,6 @@ function build_libavif {
             -DAVIF_LIBSHARPYUV=LOCAL \
             -DAVIF_LIBYUV=LOCAL \
             -DAVIF_CODEC_AOM=LOCAL \
-            -DAVIF_CODEC_DAV1D=LOCAL \
-            -DAVIF_CODEC_RAV1E=LOCAL \
-            -DAVIF_CODEC_SVT=LOCAL \
             -DENABLE_NASM=ON \
             -DCMAKE_MODULE_PATH=/tmp/cmake/Modules \
             . \
diff --git a/.github/workflows/wheels.yml b/.github/workflows/wheels.yml
@@ -160,11 +160,6 @@ jobs:
           & python.exe winbuild\build_prepare.py -v --no-imagequant --architecture=${{ matrix.cibw_arch }}
         shell: pwsh
 
-      - name: Update rust
-        if: matrix.cibw_arch == 'AMD64'
-        run: |
-          rustup update
-
       - name: Build wheels
         run: |
           setlocal EnableDelayedExpansion
diff --git a/Tests/test_file_avif.py b/Tests/test_file_avif.py
@@ -51,20 +51,6 @@ def roundtrip(im: ImageFile.ImageFile, **options: Any) -> ImageFile.ImageFile:
     return Image.open(out)
 
 
-def skip_unless_avif_decoder(codec_name: str) -> pytest.MarkDecorator:
-    reason = f"{codec_name} decode not available"
-    return pytest.mark.skipif(
-        not HAVE_AVIF or not _avif.decoder_codec_available(codec_name), reason=reason
-    )
-
-
-def skip_unless_avif_encoder(codec_name: str) -> pytest.MarkDecorator:
-    reason = f"{codec_name} encode not available"
-    return pytest.mark.skipif(
-        not HAVE_AVIF or not _avif.encoder_codec_available(codec_name), reason=reason
-    )
-
-
 def is_docker_qemu() -> bool:
     try:
         init_proc_exe = os.readlink("/proc/1/exe")
@@ -99,15 +85,12 @@ def test_version(self) -> None:
     def test_codec_version(self) -> None:
         assert AvifImagePlugin.get_codec_version("unknown") is None
 
-        for codec_name in ("aom", "dav1d", "rav1e", "svt"):
-            codec_version = AvifImagePlugin.get_codec_version(codec_name)
-            if _avif.decoder_codec_available(
-                codec_name
-            ) or _avif.encoder_codec_available(codec_name):
-                assert codec_version is not None
-                assert re.search(r"^v?\d+\.\d+\.\d+(-([a-z\d])+)*$", codec_version)
-            else:
-                assert codec_version is None
+        codec_version = AvifImagePlugin.get_codec_version("aom")
+        if _avif.decoder_codec_available() or _avif.encoder_codec_available():
+            assert codec_version is not None
+            assert re.search(r"^v?\d+\.\d+\.\d+(-([a-z\d])+)*$", codec_version)
+        else:
+            assert codec_version is None
 
     def test_read(self) -> None:
         """
@@ -181,6 +164,9 @@ def test_encoder_finish_none_error(
         """Save should raise an OSError if AvifEncoder.finish returns None"""
 
         class _mock_avif:
+            def encoder_codec_available(self) -> None:
+                return True
+
             class AvifEncoder:
                 def __init__(self, *args: Any) -> None:
                     pass
@@ -433,26 +419,6 @@ def test_encoder_range_invalid(self, tmp_path: Path) -> None:
             with pytest.raises(ValueError):
                 im.save(test_file, range="foo")
 
-    @skip_unless_avif_encoder("aom")
-    def test_encoder_codec_param(self, tmp_path: Path) -> None:
-        with Image.open(TEST_AVIF_FILE) as im:
-            test_file = tmp_path / "temp.avif"
-            im.save(test_file, codec="aom")
-
-    def test_encoder_codec_invalid(self, tmp_path: Path) -> None:
-        with Image.open(TEST_AVIF_FILE) as im:
-            test_file = tmp_path / "temp.avif"
-            with pytest.raises(ValueError):
-                im.save(test_file, codec="foo")
-
-    @skip_unless_avif_decoder("dav1d")
-    def test_decoder_codec_cannot_encode(self, tmp_path: Path) -> None:
-        with Image.open(TEST_AVIF_FILE) as im:
-            test_file = tmp_path / "temp.avif"
-            with pytest.raises(ValueError):
-                im.save(test_file, codec="dav1d")
-
-    @skip_unless_avif_encoder("aom")
     @pytest.mark.parametrize(
         "advanced",
         [
@@ -469,86 +435,30 @@ def test_encoder_advanced_codec_options(
     ) -> None:
         with Image.open(TEST_AVIF_FILE) as im:
             ctrl_buf = BytesIO()
-            im.save(ctrl_buf, "AVIF", codec="aom")
+            im.save(ctrl_buf, "AVIF")
             test_buf = BytesIO()
             im.save(
                 test_buf,
                 "AVIF",
-                codec="aom",
                 advanced=advanced,
             )
             assert ctrl_buf.getvalue() != test_buf.getvalue()
 
-    @skip_unless_avif_encoder("aom")
     @pytest.mark.parametrize("advanced", [{"foo": "bar"}, {"foo": 1234}, 1234])
     def test_encoder_advanced_codec_options_invalid(
         self, tmp_path: Path, advanced: dict[str, str] | int
     ) -> None:
         with Image.open(TEST_AVIF_FILE) as im:
             test_file = tmp_path / "temp.avif"
             with pytest.raises(ValueError):
-                im.save(test_file, codec="aom", advanced=advanced)
-
-    @skip_unless_avif_decoder("aom")
-    def test_decoder_codec_param(self, monkeypatch: pytest.MonkeyPatch) -> None:
-        monkeypatch.setattr(AvifImagePlugin, "DECODE_CODEC_CHOICE", "aom")
-
-        with Image.open(TEST_AVIF_FILE) as im:
-            assert im.size == (128, 128)
-
-    @skip_unless_avif_encoder("rav1e")
-    def test_encoder_codec_cannot_decode(
-        self, monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-    ) -> None:
-        monkeypatch.setattr(AvifImagePlugin, "DECODE_CODEC_CHOICE", "rav1e")
-
-        with pytest.raises(ValueError):
-            with Image.open(TEST_AVIF_FILE):
-                pass
-
-    def test_decoder_codec_invalid(self, monkeypatch: pytest.MonkeyPatch) -> None:
-        monkeypatch.setattr(AvifImagePlugin, "DECODE_CODEC_CHOICE", "foo")
-
-        with pytest.raises(ValueError):
-            with Image.open(TEST_AVIF_FILE):
-                pass
-
-    @skip_unless_avif_encoder("aom")
-    def test_encoder_codec_available(self) -> None:
-        assert _avif.encoder_codec_available("aom") is True
-
-    def test_encoder_codec_available_bad_params(self) -> None:
-        with pytest.raises(TypeError):
-            _avif.encoder_codec_available()
-
-    @skip_unless_avif_decoder("dav1d")
-    def test_encoder_codec_available_cannot_decode(self) -> None:
-        assert _avif.encoder_codec_available("dav1d") is False
-
-    def test_encoder_codec_available_invalid(self) -> None:
-        assert _avif.encoder_codec_available("foo") is False
+                im.save(test_file, advanced=advanced)
 
     def test_encoder_quality_valueerror(self, tmp_path: Path) -> None:
         with Image.open(TEST_AVIF_FILE) as im:
             test_file = tmp_path / "temp.avif"
             with pytest.raises(ValueError):
                 im.save(test_file, quality="invalid")
 
-    @skip_unless_avif_decoder("aom")
-    def test_decoder_codec_available(self) -> None:
-        assert _avif.decoder_codec_available("aom") is True
-
-    def test_decoder_codec_available_bad_params(self) -> None:
-        with pytest.raises(TypeError):
-            _avif.decoder_codec_available()
-
-    @skip_unless_avif_encoder("rav1e")
-    def test_decoder_codec_available_cannot_decode(self) -> None:
-        assert _avif.decoder_codec_available("rav1e") is False
-
-    def test_decoder_codec_available_invalid(self) -> None:
-        assert _avif.decoder_codec_available("foo") is False
-
     def test_p_mode_transparency(self, tmp_path: Path) -> None:
         im = Image.new("P", size=(64, 64))
         draw = ImageDraw.Draw(im)
@@ -569,16 +479,10 @@ def test_decoder_strict_flags(self) -> None:
         with Image.open("Tests/images/avif/hopper-missing-pixi.avif") as im:
             assert im.size == (128, 128)
 
-    @skip_unless_avif_encoder("aom")
     @pytest.mark.parametrize("speed", [-1, 1, 11])
     def test_aom_optimizations(self, tmp_path: Path, speed: int) -> None:
         test_file = tmp_path / "temp.avif"
-        hopper().save(test_file, codec="aom", speed=speed)
-
-    @skip_unless_avif_encoder("svt")
-    def test_svt_optimizations(self, tmp_path: Path) -> None:
-        test_file = tmp_path / "temp.avif"
-        hopper().save(test_file, codec="svt", speed=1)
+        hopper().save(test_file, speed=speed)
 
 
 @skip_unless_feature("avif")
diff --git a/docs/handbook/image-file-formats.rst b/docs/handbook/image-file-formats.rst
@@ -50,17 +50,11 @@ The :py:meth:`~PIL.Image.Image.save` method supports the following options:
     Quality/speed trade-off (0=slower/better, 10=fastest). Defaults to 6.
 
 **max_threads**
-    Limit the number of active threads used. By default, there is no limit. If the aom
-    codec is used, there is a maximum of 64.
+    Limit the number of active threads used. There is a maximum of 64.
 
 **range**
     YUV range, either "full" or "limited". Defaults to "full".
 
-**codec**
-    AV1 codec to use for encoding. Specific values are "aom", "rav1e", and
-    "svt", presuming the chosen codec is available. Defaults to "auto", which
-    will choose the first available codec in the order of the preceding list.
-
 **tile_rows** / **tile_cols**
     For tile encoding, the (log 2) number of tile rows and columns to use.
     Valid values are 0-6, default 0. Ignored if "autotiling" is set to true.
diff --git a/src/PIL/AvifImagePlugin.py b/src/PIL/AvifImagePlugin.py
@@ -13,9 +13,6 @@
 except ImportError:
     SUPPORTED = False
 
-# Decoder options as module globals, until there is a way to pass parameters
-# to Image.open (see https://github.com/python-pillow/Pillow/issues/569)
-DECODE_CODEC_CHOICE = "auto"
 # Decoding is only affected by this for libavif **0.8.4** or greater.
 DEFAULT_MAX_THREADS = 0
 
@@ -73,14 +70,11 @@ def _open(self) -> None:
             msg = "image file could not be opened because AVIF support not installed"
             raise SyntaxError(msg)
 
-        if DECODE_CODEC_CHOICE != "auto" and not _avif.decoder_codec_available(
-            DECODE_CODEC_CHOICE
-        ):
-            msg = "Invalid opening codec"
+        if not _avif.decoder_codec_available():
+            msg = "Codec not available"
             raise ValueError(msg)
         self._decoder = _avif.AvifDecoder(
             self.fp.read(),
-            DECODE_CODEC_CHOICE,
             _get_default_max_threads(),
         )
 
@@ -165,9 +159,8 @@ def _save(
     subsampling = info.get("subsampling", "4:2:0")
     speed = info.get("speed", 6)
     max_threads = info.get("max_threads", _get_default_max_threads())
-    codec = info.get("codec", "auto")
-    if codec != "auto" and not _avif.encoder_codec_available(codec):
-        msg = "Invalid saving codec"
+    if not _avif.encoder_codec_available():
+        msg = "Codec not available"
         raise ValueError(msg)
     range_ = info.get("range", "full")
     tile_rows_log2 = info.get("tile_rows", 0)
@@ -218,7 +211,6 @@ def _save(
         quality,
         speed,
         max_threads,
-        codec,
         range_,
         tile_rows_log2,
         tile_cols_log2,
diff --git a/src/_avif.c b/src/_avif.c
@@ -142,21 +142,13 @@ _codec_available(const char *name, avifCodecFlags flags) {
 
 PyObject *
 _decoder_codec_available(PyObject *self, PyObject *args) {
-    char *codec_name;
-    if (!PyArg_ParseTuple(args, "s", &codec_name)) {
-        return NULL;
-    }
-    int is_available = _codec_available(codec_name, AVIF_CODEC_FLAG_CAN_DECODE);
+    int is_available = _codec_available("aom", AVIF_CODEC_FLAG_CAN_DECODE);
     return PyBool_FromLong(is_available);
 }
 
 PyObject *
 _encoder_codec_available(PyObject *self, PyObject *args) {
-    char *codec_name;
-    if (!PyArg_ParseTuple(args, "s", &codec_name)) {
-        return NULL;
-    }
-    int is_available = _codec_available(codec_name, AVIF_CODEC_FLAG_CAN_ENCODE);
+    int is_available = _codec_available("aom", AVIF_CODEC_FLAG_CAN_ENCODE);
     return PyBool_FromLong(is_available);
 }
 
@@ -229,22 +221,20 @@ AvifEncoderNew(PyObject *self_, PyObject *args) {
     int tile_rows_log2;
     int tile_cols_log2;
 
-    char *codec;
     char *range;
 
     PyObject *advanced;
     int error = 0;
 
     if (!PyArg_ParseTuple(
             args,
-            "(II)siiissiippy*y*iy*O",
+            "(II)siiisiippy*y*iy*O",
             &width,
             &height,
             &subsampling,
             &quality,
             &speed,
             &max_threads,
-            &codec,
             &range,
             &tile_rows_log2,
             &tile_cols_log2,
@@ -310,18 +300,10 @@ AvifEncoderNew(PyObject *self_, PyObject *args) {
         goto end;
     }
 
-    int is_aom_encode = strcmp(codec, "aom") == 0 ||
-                        (strcmp(codec, "auto") == 0 &&
-                         _codec_available("aom", AVIF_CODEC_FLAG_CAN_ENCODE));
-    encoder->maxThreads = is_aom_encode && max_threads > 64 ? 64 : max_threads;
+    encoder->maxThreads = max_threads > 64 ? 64 : max_threads;
 
     encoder->quality = quality;
 
-    if (strcmp(codec, "auto") == 0) {
-        encoder->codecChoice = AVIF_CODEC_CHOICE_AUTO;
-    } else {
-        encoder->codecChoice = avifCodecChoiceFromName(codec);
-    }
     if (speed < AVIF_SPEED_SLOWEST) {
         speed = AVIF_SPEED_SLOWEST;
     } else if (speed > AVIF_SPEED_FASTEST) {
@@ -616,22 +598,14 @@ AvifDecoderNew(PyObject *self_, PyObject *args) {
     AvifDecoderObject *self = NULL;
     avifDecoder *decoder;
 
-    char *codec_str;
-    avifCodecChoice codec;
     int max_threads;
 
     avifResult result;
 
-    if (!PyArg_ParseTuple(args, "y*si", &buffer, &codec_str, &max_threads)) {
+    if (!PyArg_ParseTuple(args, "y*i", &buffer, &max_threads)) {
         return NULL;
     }
 
-    if (strcmp(codec_str, "auto") == 0) {
-        codec = AVIF_CODEC_CHOICE_AUTO;
-    } else {
-        codec = avifCodecChoiceFromName(codec_str);
-    }
-
     self = PyObject_New(AvifDecoderObject, &AvifDecoder_Type);
     if (!self) {
         PyErr_SetString(PyExc_RuntimeError, "could not create decoder object");
@@ -653,7 +627,6 @@ AvifDecoderNew(PyObject *self_, PyObject *args) {
     // items. libheif v1.11.0 and older does not add the 'pixi' item property to
     // AV1 image items.
     decoder->strictFlags &= ~AVIF_STRICT_PIXI_REQUIRED;
-    decoder->codecChoice = codec;
 
     result = avifDecoderSetIOMemory(decoder, buffer.buf, buffer.len);
     if (result != AVIF_RESULT_OK) {
diff --git a/winbuild/build_prepare.py b/winbuild/build_prepare.py
