Changeset 65367

Timestamp:

11/10/2026 01:33:13 AM (22 hours ago)

Author:

desrosj

Message:

Media: Use imageflip() to flip images with GD.

WP_Image_Editor_GD::flip() and the deprecated _flip_image_resource() mirrored images by copying them with imagecopyresampled() and negative source dimensions. With the GD 2.4.0 bundled in PHP 8.6, this produces an all-black image. It affects flips in the image editor, and also JPEG uploads with an EXIF orientation of 2, 3 or 4, which WP_Image_Editor::maybe_exif_rotate() flips.

Both functions now flip the image in place with imageflip(), and the output stays the same as before. Palette images are still converted to truecolor, alpha blending is turned off and alpha saving on, and the resolution and interlacing are reset to GD's defaults of 96 DPI and off. This matches what rotate(), crop() and resize() produce. Whether every operation should keep the source image's resolution and interlacing will be decided in a follow-up ticket.

When no valid image is loaded, flip() now returns a WP_Error instead of throwing a TypeError.

Props sanjith2023, rumancodes, arshidkv12, dhruvang21, abhishekfdd, desrosj.
Fixes #66113.

Location:

trunk

Files:

• src/wp-admin/includes/image-edit.php (modified) (2 diffs)
• src/wp-includes/class-wp-image-editor-gd.php (modified) (2 diffs)
• tests/phpunit/tests/image/editorGd.php (modified) (1 diff)
• tests/phpunit/tests/image/functions.php (modified) (1 diff)

trunk/src/wp-admin/includes/image-edit.php

@@ -566 +566 @@
  *
  * @since 2.9.0
+ * @since 7.2.0 Switched to using imageflip() instead of imagecopyresampled() with negative dimensions.
  * @deprecated 3.5.0 Use WP_Image_Editor::flip()
  * @see WP_Image_Editor::flip()
@@ -578 +579 @@
         _deprecated_function( __FUNCTION__, '3.5.0', 'WP_Image_Editor::flip()' );
 
-        $w   = imagesx( $img );
-        $h   = imagesy( $img );
-        $dst = wp_imagecreatetruecolor( $w, $h );
-
-        if ( is_gd_image( $dst ) ) {
-                $sx = $vert ? ( $w - 1 ) : 0;
-                $sy = $horz ? ( $h - 1 ) : 0;
-                $sw = $vert ? -$w : $w;
-                $sh = $horz ? -$h : $h;
-
-                if ( imagecopyresampled( $dst, $img, 0, 0, $sx, $sy, $w, $h, $sw, $sh ) ) {
-                        if ( PHP_VERSION_ID < 80000 ) { // imagedestroy() has no effect as of PHP 8.0.
-                                imagedestroy( $img );
-                        }
-
-                        $img = $dst;
-                }
-        }
+        if ( ! is_gd_image( $img ) ) {
+                return $img;
+        }
+
+        // Keep returning a truecolor image, like the previous implementation did. imagewebp() rejects palette images.
+        if ( ! imageistruecolor( $img ) && ! imagepalettetotruecolor( $img ) ) {
+                return $img;
+        }
+
+        // Match the alpha settings of the previous implementation's copy, including when no axis is flipped.
+        imagealphablending( $img, false );
+        imagesavealpha( $img, true );
+
+        /*
+         * imageflip() changes the image in place, so the image keeps its current resolution and interlace setting.
+         * _rotate_image_resource() and _crop_image_resource() copy into a new image, which resets them to GD's defaults:
+         * 96 DPI and no interlacing. Reset them here too, so a flip gives the same result as the other edits.
+         *
+         * @link https://core.trac.wordpress.org/ticket/66113
+         */
+        imageresolution( $img, 96, 96 );
+        imageinterlace( $img, 0 );
+
+        if ( ! $horz && ! $vert ) {
+                return $img;
+        }
+
+        if ( $horz && $vert ) {
+                $mode = IMG_FLIP_BOTH;
+        } elseif ( $horz ) {
+                $mode = IMG_FLIP_VERTICAL;
+        } else {
+                $mode = IMG_FLIP_HORIZONTAL;
+        }
+
+        imageflip( $img, $mode );
 
         return $img;

trunk/src/wp-includes/class-wp-image-editor-gd.php

@@ -433 +433 @@
          *
          * @since 3.5.0
+         * @since 7.2.0 Switched to using imageflip() instead of imagecopyresampled() with negative dimensions.
          *
          * @param bool $horz Flip along Horizontal Axis.
@@ -439 +440 @@
          */
         public function flip( $horz, $vert ) {
-                $w   = $this->size['width'];
-                $h   = $this->size['height'];
-                $dst = wp_imagecreatetruecolor( $w, $h );
-
-                if ( is_gd_image( $dst ) ) {
-                        $sx = $vert ? ( $w - 1 ) : 0;
-                        $sy = $horz ? ( $h - 1 ) : 0;
-                        $sw = $vert ? -$w : $w;
-                        $sh = $horz ? -$h : $h;
-
-                        if ( imagecopyresampled( $dst, $this->image, 0, 0, $sx, $sy, $w, $h, $sw, $sh ) ) {
-                                if ( PHP_VERSION_ID < 80000 ) { // imagedestroy() has no effect as of PHP 8.0.
-                                        imagedestroy( $this->image );
-                                }
-
-                                $this->image = $dst;
-
-                                return true;
-                        }
+                if ( ! is_gd_image( $this->image ) ) {
+                        return new WP_Error( 'image_flip_error', __( 'Image flip failed.' ), $this->file );
+                }
+
+                /*
+                 * imageflip() works in place and keeps palette images as palette images.
+                 * The previous implementation always copied into a new truecolor image,
+                 * and saving or streaming as WebP relies on that, since imagewebp()
+                 * rejects palette images. Convert first to keep that behavior.
+                 */
+                if ( ! imageistruecolor( $this->image ) && ! imagepalettetotruecolor( $this->image ) ) {
+                        return new WP_Error( 'image_flip_error', __( 'Image flip failed.' ), $this->file );
+                }
+
+                /*
+                 * imageflip() also keeps the current alpha settings, which rotate() leaves
+                 * with blending enabled. Reset them to what the previous implementation
+                 * always produced, including when no axis is flipped.
+                 */
+                imagealphablending( $this->image, false );
+                imagesavealpha( $this->image, true );
+
+                /*
+                 * imageflip() changes the image in place, so the image keeps its current resolution and interlace setting.
+                 * rotate(), crop() and resize() copy into a new image, which resets them to GD's defaults: 96 DPI and no
+                 * interlacing. Reset them here too, so a flip gives the same result as the other edits.
+                 *
+                 * @link https://core.trac.wordpress.org/ticket/66113
+                 */
+                imageresolution( $this->image, 96, 96 );
+                imageinterlace( $this->image, 0 );
+
+                if ( ! $horz && ! $vert ) {
+                        return true;
+                }
+
+                if ( $horz && $vert ) {
+                        $mode = IMG_FLIP_BOTH;
+                } elseif ( $horz ) {
+                        $mode = IMG_FLIP_VERTICAL;
+                } else {
+                        $mode = IMG_FLIP_HORIZONTAL;
+                }
+
+                if ( imageflip( $this->image, $mode ) ) {
+                        return true;
                 }
 

trunk/tests/phpunit/tests/image/editorGd.php

@@ -579 +579 @@
 
         /**
+         * Tests that flip() moves every pixel to its mirrored position.
+         *
+         * A small non-square image with a distinct color per pixel is used so that
+         * mixed up axes, off-by-one shifts and duplicated edges are all detected.
+         *
+         * @ticket 66113
+         *
+         * @dataProvider data_flip_axes
+         *
+         * @covers WP_Image_Editor_GD::flip
+         *
+         * @param bool $horz Whether to flip along the horizontal axis.
+         * @param bool $vert Whether to flip along the vertical axis.
+         */
+        public function test_flip_moves_every_pixel( $horz, $vert ) {
+                $w     = 3;
+                $h     = 2;
+                $color = static function ( $x, $y ) {
+                        return ( ( $x * 40 + 10 ) << 16 ) | ( ( $y * 90 + 20 ) << 8 ) | 0x77;
+                };
+
+                $image = imagecreatetruecolor( $w, $h );
+                for ( $y = 0; $y < $h; $y++ ) {
+                        for ( $x = 0; $x < $w; $x++ ) {
+                                imagesetpixel( $image, $x, $y, $color( $x, $y ) );
+                        }
+                }
+
+                $gd_image_editor = new WP_Image_Editor_GD( DIR_TESTDATA . '/images/gradient-square.jpg' );
+                $gd_image_editor->load();
+
+                $this->set_property_value( $gd_image_editor, 'image', $image );
+
+                // Keep the stored size in sync with the replaced image.
+                $this->set_property_value(
+                        $gd_image_editor,
+                        'size',
+                        array(
+                                'width'  => $w,
+                                'height' => $h,
+                        )
+                );
+
+                $this->assertTrue( $gd_image_editor->flip( $horz, $vert ) );
+
+                $flipped = $this->get_property_value( $gd_image_editor );
+
+                $this->assertSame( $w, imagesx( $flipped ), 'The width should not change.' );
+                $this->assertSame( $h, imagesy( $flipped ), 'The height should not change.' );
+
+                for ( $y = 0; $y < $h; $y++ ) {
+                        for ( $x = 0; $x < $w; $x++ ) {
+                                $source_x = $vert ? $w - 1 - $x : $x;
+                                $source_y = $horz ? $h - 1 - $y : $y;
+
+                                $this->assertSame(
+                                        $color( $source_x, $source_y ),
+                                        imagecolorat( $flipped, $x, $y ),
+                                        "Pixel ($source_x,$source_y) did not move to ($x,$y)."
+                                );
+                        }
+                }
+        }
+
+        /**
+         * Data provider with every combination of flip axes.
+         *
+         * @return array[]
+         */
+        public static function data_flip_axes() {
+                return array(
+                        'no flip'         => array( false, false ),
+                        'vertical flip'   => array( true, false ),
+                        'horizontal flip' => array( false, true ),
+                        'both'            => array( true, true ),
+                );
+        }
+
+        /**
+         * Tests that flip() returns a WP_Error when no valid GD image is loaded.
+         *
+         * @ticket 66113
+         *
+         * @dataProvider data_flip_axes
+         *
+         * @covers WP_Image_Editor_GD::flip
+         *
+         * @param bool $horz Whether to flip along the horizontal axis.
+         * @param bool $vert Whether to flip along the vertical axis.
+         */
+        public function test_flip_returns_error_for_invalid_image( $horz, $vert ) {
+                $gd_image_editor = new WP_Image_Editor_GD( DIR_TESTDATA . '/images/gradient-square.jpg' );
+                $gd_image_editor->load();
+
+                $this->set_property_value( $gd_image_editor, 'image', false );
+
+                $result = $gd_image_editor->flip( $horz, $vert );
+
+                $this->assertWPError( $result, 'flip() should return a WP_Error when no valid image is loaded.' );
+                $this->assertSame( 'image_flip_error', $result->get_error_code(), 'The error code should be image_flip_error.' );
+        }
+
+        /**
+         * Tests that maybe_exif_rotate() flips images whose EXIF orientation requires a flip.
+         *
+         * This is the most common way to reach flip(): uploading a mirrored or
+         * upside-down JPEG. The image is only flipped, so its size does not change
+         * and every pixel must end up at its mirrored position.
+         *
+         * @ticket 66113
+         *
+         * @dataProvider data_maybe_exif_rotate_flips_image
+         *
+         * @covers WP_Image_Editor::maybe_exif_rotate
+         * @covers WP_Image_Editor_GD::flip
+         *
+         * @param int  $orientation EXIF orientation value.
+         * @param bool $mirror_x    Whether the image should be mirrored left to right.
+         * @param bool $mirror_y    Whether the image should be mirrored top to bottom.
+         */
+        public function test_maybe_exif_rotate_flips_image( $orientation, $mirror_x, $mirror_y ) {
+                $file = DIR_TESTDATA . '/images/test-image-upside-down.jpg';
+
+                // The fixture has orientation 3. Override it to cover the other flip-only orientations.
+                $filter = static function () use ( $orientation ) {
+                        return $orientation;
+                };
+                add_filter( 'wp_image_maybe_exif_rotate', $filter );
+
+                $gd_image_editor = new WP_Image_Editor_GD( $file );
+                $gd_image_editor->load();
+
+                $original = $this->get_property_value( $gd_image_editor );
+                $w        = imagesx( $original );
+                $h        = imagesy( $original );
+
+                // Snapshot a grid of pixels, since flip() modifies the image in place.
+                $points = array();
+                foreach ( array( 0, (int) ( $w / 3 ), (int) ( $w / 2 ), $w - 1 ) as $x ) {
+                        foreach ( array( 0, (int) ( $h / 3 ), (int) ( $h / 2 ), $h - 1 ) as $y ) {
+                                $points[] = array( $x, $y, imagecolorat( $original, $x, $y ) );
+                        }
+                }
+
+                $result = $gd_image_editor->maybe_exif_rotate();
+
+                remove_filter( 'wp_image_maybe_exif_rotate', $filter );
+
+                $this->assertTrue( $result, 'maybe_exif_rotate() should return true.' );
+                $this->assertSame(
+                        array(
+                                'width'  => $w,
+                                'height' => $h,
+                        ),
+                        $gd_image_editor->get_size(),
+                        'Flipping should not change the size.'
+                );
+
+                $flipped = $this->get_property_value( $gd_image_editor );
+
+                foreach ( $points as list( $x, $y, $color ) ) {
+                        $target_x = $mirror_x ? $w - 1 - $x : $x;
+                        $target_y = $mirror_y ? $h - 1 - $y : $y;
+
+                        $this->assertSame(
+                                $color,
+                                imagecolorat( $flipped, $target_x, $target_y ),
+                                "Pixel ($x,$y) did not move to ($target_x,$target_y)."
+                        );
+                }
+        }
+
+        /**
+         * Data provider for test_maybe_exif_rotate_flips_image().
+         *
+         * @return array[]
+         */
+        public static function data_maybe_exif_rotate_flips_image() {
+                return array(
+                        'orientation 2: mirrored horizontally' => array( 2, true, false ),
+                        'orientation 3: upside down'           => array( 3, true, true ),
+                        'orientation 4: mirrored vertically'   => array( 4, false, true ),
+                );
+        }
+
+        /**
+         * Tests that flip() converts palette images to truecolor, like the previous implementation.
+         *
+         * The previous implementation always copied into a new truecolor image.
+         * Code that saves or streams the flipped image as WebP relies on that,
+         * since imagewebp() rejects palette images.
+         *
+         * @ticket 66113
+         *
+         * @dataProvider data_flip_axes
+         *
+         * @covers WP_Image_Editor_GD::flip
+         *
+         * @param bool $horz Whether to flip along the horizontal axis.
+         * @param bool $vert Whether to flip along the vertical axis.
+         */
+        public function test_flip_converts_palette_image_to_truecolor( $horz, $vert ) {
+                $gd_image_editor = new WP_Image_Editor_GD( DIR_TESTDATA . '/images/test-image.gif' );
+                $gd_image_editor->load();
+
+                $image = $this->get_property_value( $gd_image_editor );
+                $w     = imagesx( $image );
+                $h     = imagesy( $image );
+
+                $this->assertFalse( imageistruecolor( $image ), 'The fixture should be a palette image.' );
+
+                // Snapshot every pixel as a truecolor value, since flip() modifies the image in place.
+                $colors = array();
+                for ( $y = 0; $y < $h; $y++ ) {
+                        for ( $x = 0; $x < $w; $x++ ) {
+                                $rgba = imagecolorsforindex( $image, imagecolorat( $image, $x, $y ) );
+
+                                $colors[ $y ][ $x ] = ( $rgba['alpha'] << 24 ) | ( $rgba['red'] << 16 ) | ( $rgba['green'] << 8 ) | $rgba['blue'];
+                        }
+                }
+
+                $this->assertTrue( $gd_image_editor->flip( $horz, $vert ) );
+
+                $flipped = $this->get_property_value( $gd_image_editor );
+
+                $this->assertTrue( imageistruecolor( $flipped ), 'The flipped image should be a truecolor image.' );
+
+                for ( $y = 0; $y < $h; $y++ ) {
+                        for ( $x = 0; $x < $w; $x++ ) {
+                                $source_x = $vert ? $w - 1 - $x : $x;
+                                $source_y = $horz ? $h - 1 - $y : $y;
+
+                                $this->assertSame(
+                                        $colors[ $source_y ][ $source_x ],
+                                        imagecolorat( $flipped, $x, $y ),
+                                        "Pixel ($source_x,$source_y) did not move to ($x,$y)."
+                                );
+                        }
+                }
+        }
+
+        /**
+         * Tests that a flipped palette image can be saved as WebP.
+         *
+         * imagewebp() rejects palette images with a warning and writes an empty file,
+         * so this fails unless flip() returns a truecolor image.
+         *
+         * @ticket 66113
+         *
+         * @covers WP_Image_Editor_GD::flip
+         * @covers WP_Image_Editor_GD::save
+         */
+        public function test_flipped_palette_image_can_be_saved_as_webp() {
+                if ( ! WP_Image_Editor_GD::supports_mime_type( 'image/webp' ) ) {
+                        $this->markTestSkipped( 'This GD build does not support WebP.' );
+                }
+
+                $gd_image_editor = new WP_Image_Editor_GD( DIR_TESTDATA . '/images/test-image.gif' );
+                $gd_image_editor->load();
+
+                $this->assertTrue( $gd_image_editor->flip( true, false ) );
+
+                $save_to_file = get_temp_dir() . wp_unique_filename( get_temp_dir(), 'flipped-palette.webp' );
+                $saved        = $gd_image_editor->save( $save_to_file, 'image/webp' );
+
+                $this->assertNotWPError( $saved, 'Saving the flipped image as WebP should not fail.' );
+
+                $size     = wp_getimagesize( $saved['path'] );
+                $filesize = filesize( $saved['path'] );
+
+                unlink( $saved['path'] );
+
+                $this->assertGreaterThan( 0, $filesize, 'The saved WebP file should not be empty.' );
+                $this->assertIsArray( $size, 'The saved WebP file should be a valid image.' );
+                $this->assertSame( 'image/webp', $size['mime'], 'The saved file should be a WebP image.' );
+                $this->assertSame( array( 50, 50 ), array( $size[0], $size[1] ), 'The saved image size should not change.' );
+        }
+
+        /**
+         * Tests that flip() keeps the alpha channel of every pixel, in memory and after saving as PNG.
+         *
+         * Fully transparent pixels are left out on purpose: their hidden RGB value
+         * is not visible and is not guaranteed to survive saving.
+         *
+         * @ticket 66113
+         *
+         * @dataProvider data_flip_axes
+         *
+         * @covers WP_Image_Editor_GD::flip
+         *
+         * @param bool $horz Whether to flip along the horizontal axis.
+         * @param bool $vert Whether to flip along the vertical axis.
+         */
+        public function test_flip_keeps_alpha_channel( $horz, $vert ) {
+                $w     = 3;
+                $h     = 2;
+                $color = static function ( $x, $y ) {
+                        // Alpha values from 0 (opaque) to 125, all distinct.
+                        $alpha = ( $y * 3 + $x ) * 25;
+
+                        return ( $alpha << 24 ) | ( ( $x * 40 + 10 ) << 16 ) | ( ( $y * 90 + 20 ) << 8 ) | 0x77;
+                };
+
+                $image = imagecreatetruecolor( $w, $h );
+                imagealphablending( $image, false );
+                imagesavealpha( $image, true );
+                for ( $y = 0; $y < $h; $y++ ) {
+                        for ( $x = 0; $x < $w; $x++ ) {
+                                imagesetpixel( $image, $x, $y, $color( $x, $y ) );
+                        }
+                }
+
+                $source_file = get_temp_dir() . wp_unique_filename( get_temp_dir(), 'flip-alpha.png' );
+                imagepng( $image, $source_file );
+
+                $gd_image_editor = new WP_Image_Editor_GD( $source_file );
+                $loaded          = $gd_image_editor->load();
+
+                unlink( $source_file );
+
+                $this->assertTrue( $loaded, 'The test image should load.' );
+                $this->assertTrue( $gd_image_editor->flip( $horz, $vert ) );
+
+                $flipped = $this->get_property_value( $gd_image_editor );
+
+                $save_to_file = get_temp_dir() . wp_unique_filename( get_temp_dir(), 'flipped-alpha.png' );
+                $saved        = $gd_image_editor->save( $save_to_file, 'image/png' );
+
+                $this->assertNotWPError( $saved, 'Saving the flipped image as PNG should not fail.' );
+
+                $reloaded = imagecreatefrompng( $saved['path'] );
+                unlink( $saved['path'] );
+
+                for ( $y = 0; $y < $h; $y++ ) {
+                        for ( $x = 0; $x < $w; $x++ ) {
+                                $source_x = $vert ? $w - 1 - $x : $x;
+                                $source_y = $horz ? $h - 1 - $y : $y;
+                                $expected = $color( $source_x, $source_y );
+
+                                $this->assertSame(
+                                        $expected,
+                                        imagecolorat( $flipped, $x, $y ),
+                                        "Pixel ($source_x,$source_y) did not move to ($x,$y) with its alpha in memory."
+                                );
+                                $this->assertSame(
+                                        $expected,
+                                        imagecolorat( $reloaded, $x, $y ),
+                                        "Pixel ($source_x,$source_y) did not move to ($x,$y) with its alpha after saving."
+                                );
+                        }
+                }
+        }
+
+        /**
+         * Tests that flipping along both axes gives the same image as rotating by 180 degrees.
+         *
+         * @ticket 66113
+         *
+         * @covers WP_Image_Editor_GD::flip
+         */
+        public function test_flip_both_axes_matches_rotate_180() {
+                $file = DIR_TESTDATA . '/images/canola.jpg';
+
+                $flipped_editor = new WP_Image_Editor_GD( $file );
+                $flipped_editor->load();
+                $this->assertTrue( $flipped_editor->flip( true, true ) );
+
+                $rotated_editor = new WP_Image_Editor_GD( $file );
+                $rotated_editor->load();
+                $this->assertTrue( $rotated_editor->rotate( 180 ) );
+
+                $this->assertSame( $rotated_editor->get_size(), $flipped_editor->get_size(), 'The sizes should match.' );
+
+                $flipped = $this->get_property_value( $flipped_editor );
+                $rotated = $this->get_property_value( $rotated_editor );
+
+                $w = imagesx( $flipped );
+                $h = imagesy( $flipped );
+
+                // Count mismatches instead of asserting each pixel, since the image is large.
+                $mismatches = 0;
+                for ( $y = 0; $y < $h; $y++ ) {
+                        for ( $x = 0; $x < $w; $x++ ) {
+                                if ( imagecolorat( $flipped, $x, $y ) !== imagecolorat( $rotated, $x, $y ) ) {
+                                        ++$mismatches;
+                                }
+                        }
+                }
+
+                $this->assertSame( 0, $mismatches, 'Every pixel should match the image rotated by 180 degrees.' );
+        }
+
+        /**
+         * Tests that flip() disables alpha blending, including after rotate() enabled it.
+         *
+         * Alpha blending only affects drawing onto the image, so it is detected by
+         * drawing a fully transparent pixel: with blending disabled, it replaces the
+         * existing pixel instead of being blended into it.
+         *
+         * @ticket 66113
+         *
+         * @dataProvider data_flip_axes
+         *
+         * @covers WP_Image_Editor_GD::flip
+         *
+         * @param bool $horz Whether to flip along the horizontal axis.
+         * @param bool $vert Whether to flip along the vertical axis.
+         */
+        public function test_flip_disables_alpha_blending_after_rotate( $horz, $vert ) {
+                $gd_image_editor = new WP_Image_Editor_GD( DIR_TESTDATA . '/images/gradient-square.jpg' );
+                $gd_image_editor->load();
+
+                $this->assertTrue( $gd_image_editor->rotate( 90 ) );
+                $this->assertTrue( $gd_image_editor->flip( $horz, $vert ) );
+
+                $image = $this->get_property_value( $gd_image_editor );
+
+                imagesetpixel( $image, 0, 0, imagecolorallocatealpha( $image, 0, 0, 0, 127 ) );
+
+                $this->assertSame( 127, ( imagecolorat( $image, 0, 0 ) >> 24 ) & 0x7F, 'Alpha blending should be disabled after flipping.' );
+        }
+
+        /**
+         * Tests that flip() resets the resolution and interlace setting to GD's defaults.
+         *
+         * The previous implementation always copied into a new image, which starts
+         * at 96 DPI with interlacing disabled, like rotate(), crop() and resize().
+         *
+         * @ticket 66113
+         *
+         * @dataProvider data_flip_axes
+         *
+         * @covers WP_Image_Editor_GD::flip
+         *
+         * @param bool $horz Whether to flip along the horizontal axis.
+         * @param bool $vert Whether to flip along the vertical axis.
+         */
+        public function test_flip_resets_resolution_and_interlace( $horz, $vert ) {
+                $gd_image_editor = new WP_Image_Editor_GD( DIR_TESTDATA . '/images/gradient-square.jpg' );
+                $gd_image_editor->load();
+
+                $image = $this->get_property_value( $gd_image_editor );
+
+                imageresolution( $image, 300, 150 );
+                imageinterlace( $image, true );
+
+                $this->assertTrue( $gd_image_editor->flip( $horz, $vert ) );
+
+                $flipped = $this->get_property_value( $gd_image_editor );
+
+                $this->assertSame( array( 96, 96 ), imageresolution( $flipped ), 'The resolution should be reset to 96 DPI.' );
+                $this->assertFalse( (bool) imageinterlace( $flipped ), 'Interlacing should be disabled.' );
+        }
+
+        /**
          * Tests that an image created with WP_Image_Editor_GD preserves alpha with no resizing.
          *

trunk/tests/phpunit/tests/image/functions.php

@@ -1204 +1204 @@
                 );
         }
+
+        /**
+         * Tests that _flip_image_resource() mirrors every pixel for each flip mode.
+         *
+         * A small non-square image with a distinct color per pixel is used so that
+         * mixed up axes, off-by-one shifts and duplicated edges are all detected.
+         *
+         * @ticket 66113
+         *
+         * @requires extension gd
+         *
+         * @expectedDeprecated _flip_image_resource
+         *
+         * @dataProvider data_flip_image_resource
+         *
+         * @covers ::_flip_image_resource
+         *
+         * @param bool $horz Whether to flip along the horizontal axis.
+         * @param bool $vert Whether to flip along the vertical axis.
+         */
+        public function test_flip_image_resource( $horz, $vert ) {
+                require_once ABSPATH . 'wp-admin/includes/image-edit.php';
+
+                $w     = 3;
+                $h     = 2;
+                $color = static function ( $x, $y ) {
+                        return ( ( $x * 40 + 10 ) << 16 ) | ( ( $y * 90 + 20 ) << 8 ) | 0x77;
+                };
+
+                $image = imagecreatetruecolor( $w, $h );
+                for ( $y = 0; $y < $h; $y++ ) {
+                        for ( $x = 0; $x < $w; $x++ ) {
+                                imagesetpixel( $image, $x, $y, $color( $x, $y ) );
+                        }
+                }
+
+                $flipped = _flip_image_resource( $image, $horz, $vert );
+
+                $this->assertTrue( is_gd_image( $flipped ), 'A GD image should be returned.' );
+                $this->assertSame( $w, imagesx( $flipped ), 'The width should not change.' );
+                $this->assertSame( $h, imagesy( $flipped ), 'The height should not change.' );
+
+                for ( $y = 0; $y < $h; $y++ ) {
+                        for ( $x = 0; $x < $w; $x++ ) {
+                                $source_x = $vert ? $w - 1 - $x : $x;
+                                $source_y = $horz ? $h - 1 - $y : $y;
+
+                                $this->assertSame(
+                                        $color( $source_x, $source_y ),
+                                        imagecolorat( $flipped, $x, $y ),
+                                        "Pixel ($source_x,$source_y) did not move to ($x,$y)."
+                                );
+                        }
+                }
+        }
+
+        /**
+         * Data provider for test_flip_image_resource().
+         *
+         * @return array[]
+         */
+        public static function data_flip_image_resource() {
+                return array(
+                        'no flip'         => array( false, false ),
+                        'vertical flip'   => array( true, false ),
+                        'horizontal flip' => array( false, true ),
+                        'both'            => array( true, true ),
+                );
+        }
+
+        /**
+         * Tests that _flip_image_resource() returns a truecolor image for a palette image.
+         *
+         * The previous implementation always copied into a new truecolor image.
+         * A small palette image with a distinct color per pixel is used, so every
+         * pixel can be checked at its mirrored position.
+         *
+         * @ticket 66113
+         *
+         * @requires extension gd
+         *
+         * @expectedDeprecated _flip_image_resource
+         *
+         * @dataProvider data_flip_image_resource
+         *
+         * @covers ::_flip_image_resource
+         *
+         * @param bool $horz Whether to flip along the horizontal axis.
+         * @param bool $vert Whether to flip along the vertical axis.
+         */
+        public function test_flip_image_resource_converts_palette_image_to_truecolor( $horz, $vert ) {
+                require_once ABSPATH . 'wp-admin/includes/image-edit.php';
+
+                $w     = 3;
+                $h     = 2;
+                $color = static function ( $x, $y ) {
+                        return ( ( $x * 40 + 10 ) << 16 ) | ( ( $y * 90 + 20 ) << 8 ) | 0x77;
+                };
+
+                $image = imagecreate( $w, $h );
+                for ( $y = 0; $y < $h; $y++ ) {
+                        for ( $x = 0; $x < $w; $x++ ) {
+                                $rgb = $color( $x, $y );
+                                imagesetpixel( $image, $x, $y, imagecolorallocate( $image, ( $rgb >> 16 ) & 0xFF, ( $rgb >> 8 ) & 0xFF, $rgb & 0xFF ) );
+                        }
+                }
+
+                $this->assertFalse( imageistruecolor( $image ), 'The test image should be a palette image.' );
+
+                $flipped = _flip_image_resource( $image, $horz, $vert );
+
+                $this->assertTrue( imageistruecolor( $flipped ), 'The flipped image should be a truecolor image.' );
+                $this->assertSame( $w, imagesx( $flipped ), 'The width should not change.' );
+                $this->assertSame( $h, imagesy( $flipped ), 'The height should not change.' );
+
+                for ( $y = 0; $y < $h; $y++ ) {
+                        for ( $x = 0; $x < $w; $x++ ) {
+                                $source_x = $vert ? $w - 1 - $x : $x;
+                                $source_y = $horz ? $h - 1 - $y : $y;
+
+                                $this->assertSame(
+                                        $color( $source_x, $source_y ),
+                                        imagecolorat( $flipped, $x, $y ),
+                                        "Pixel ($source_x,$source_y) did not move to ($x,$y)."
+                                );
+                        }
+                }
+        }
+
+        /**
+         * Tests that _flip_image_resource() returns an image that keeps its alpha channel when saved as PNG.
+         *
+         * The previous implementation always returned a new image with alpha saving
+         * enabled, even if the input had it disabled and no axis was flipped.
+         *
+         * @ticket 66113
+         *
+         * @requires extension gd
+         *
+         * @expectedDeprecated _flip_image_resource
+         *
+         * @dataProvider data_flip_image_resource
+         *
+         * @covers ::_flip_image_resource
+         *
+         * @param bool $horz Whether to flip along the horizontal axis.
+         * @param bool $vert Whether to flip along the vertical axis.
+         */
+        public function test_flip_image_resource_enables_alpha_saving( $horz, $vert ) {
+                require_once ABSPATH . 'wp-admin/includes/image-edit.php';
+
+                // A single half-transparent pixel, so its position does not change when flipped.
+                $image = imagecreatetruecolor( 1, 1 );
+                imagealphablending( $image, false );
+                imagesavealpha( $image, false );
+                imagesetpixel( $image, 0, 0, imagecolorallocatealpha( $image, 200, 100, 50, 64 ) );
+
+                $flipped = _flip_image_resource( $image, $horz, $vert );
+
+                $file = get_temp_dir() . wp_unique_filename( get_temp_dir(), 'flip-image-resource-alpha.png' );
+                imagepng( $flipped, $file );
+                $reloaded = imagecreatefrompng( $file );
+                unlink( $file );
+
+                $this->assertSame( 64, ( imagecolorat( $reloaded, 0, 0 ) >> 24 ) & 0x7F, 'The alpha channel should be kept when saving as PNG.' );
+        }
+
+        /**
+         * Tests that _flip_image_resource() returns an image with alpha blending disabled.
+         *
+         * The previous implementation always returned a new image with alpha blending
+         * disabled, even if the input had it enabled and no axis was flipped.
+         *
+         * Alpha blending only affects drawing onto the image, so it is detected by
+         * drawing a fully transparent pixel: with blending disabled, it replaces the
+         * existing pixel instead of being blended into it.
+         *
+         * @ticket 66113
+         *
+         * @requires extension gd
+         *
+         * @expectedDeprecated _flip_image_resource
+         *
+         * @dataProvider data_flip_image_resource
+         *
+         * @covers ::_flip_image_resource
+         *
+         * @param bool $horz Whether to flip along the horizontal axis.
+         * @param bool $vert Whether to flip along the vertical axis.
+         */
+        public function test_flip_image_resource_disables_alpha_blending( $horz, $vert ) {
+                require_once ABSPATH . 'wp-admin/includes/image-edit.php';
+
+                // New truecolor images have alpha blending enabled.
+                $image = imagecreatetruecolor( 3, 2 );
+
+                $flipped = _flip_image_resource( $image, $horz, $vert );
+
+                imagesetpixel( $flipped, 0, 0, imagecolorallocatealpha( $flipped, 0, 0, 0, 127 ) );
+
+                $this->assertSame( 127, ( imagecolorat( $flipped, 0, 0 ) >> 24 ) & 0x7F, 'Alpha blending should be disabled after flipping.' );
+        }
+
+        /**
+         * Tests that _flip_image_resource() resets the resolution and interlace setting to GD's defaults.
+         *
+         * The previous implementation always copied into a new image, which starts
+         * at 96 DPI with interlacing disabled, like _rotate_image_resource() and
+         * _crop_image_resource().
+         *
+         * @ticket 66113
+         *
+         * @requires extension gd
+         *
+         * @expectedDeprecated _flip_image_resource
+         *
+         * @dataProvider data_flip_image_resource
+         *
+         * @covers ::_flip_image_resource
+         *
+         * @param bool $horz Whether to flip along the horizontal axis.
+         * @param bool $vert Whether to flip along the vertical axis.
+         */
+        public function test_flip_image_resource_resets_resolution_and_interlace( $horz, $vert ) {
+                require_once ABSPATH . 'wp-admin/includes/image-edit.php';
+
+                $image = imagecreatetruecolor( 3, 2 );
+                imageresolution( $image, 300, 150 );
+                imageinterlace( $image, true );
+
+                $flipped = _flip_image_resource( $image, $horz, $vert );
+
+                $this->assertSame( array( 96, 96 ), imageresolution( $flipped ), 'The resolution should be reset to 96 DPI.' );
+                $this->assertFalse( (bool) imageinterlace( $flipped ), 'Interlacing should be disabled.' );
+        }
 }