Media: Allow HEIC/HEIF uploads when the server lacks editor support.

Enable HEIC/HEIF image uploads to succeed even when the server's image editor cannot process them, so client-side media processing can decode the file in the browser and generate the required sub-sizes. Previously, `wp_prevent_unsupported_mime_type_uploads` rejected these uploads outright with a `rest_upload_image_type_not_supported` error.

See related Gutenberg work: WordPress/gutenberg#76731.

Props westonruter, swissspidy, ramonopoly.
Fixes #64915.



git-svn-id: https://develop.svn.wordpress.org/trunk@62616 602fd350-edb4-49c9-b593-d223f7449a82

Author: adamsilverstein

src/wp-includes/post.php

@@ -6846,6 +6846,29 @@ function wp_delete_attachment_files( $post_id, $meta, $backup_sizes, $file ) {
 		}
 	}
 
+	/*
+	 * Delete the source-format companion file. The client-side media flow can
+	 * sideload a source-format original (such as a HEIC file) alongside a
+	 * web-viewable derivative, recording its filename under the 'source_image'
+	 * key. This is kept separate from 'original_image', which continues to
+	 * point at the derivative.
+	 */
+	if ( ! empty( $meta['source_image'] ) && is_string( $meta['source_image'] ) ) {
+		if ( empty( $intermediate_dir ) ) {
+			$intermediate_dir = path_join( $uploadpath['basedir'], dirname( $file ) );
+		}
+
+		$source_image = str_replace( wp_basename( $file ), $meta['source_image'], $file );
+
+		if ( ! empty( $source_image ) ) {
+			$source_image = path_join( $uploadpath['basedir'], $source_image );
+
+			if ( ! wp_delete_file_from_directory( $source_image, $intermediate_dir ) ) {
+				$deleted = false;
+			}
+		}
+	}
+
 	if ( is_array( $backup_sizes ) ) {
 		$del_dir = path_join( $uploadpath['basedir'], dirname( $meta['file'] ) );
 

src/wp-includes/rest-api/class-wp-rest-server.php

@@ -1380,7 +1380,7 @@ public function get_index( $request ) {
 			$available['image_size_threshold'] = (int) apply_filters( 'big_image_size_threshold', 2560, array( 0, 0 ), '', 0 );
 
 			// Image output formats.
-			$input_formats  = array( 'image/jpeg', 'image/png', 'image/gif', 'image/webp', 'image/avif', 'image/heic' );
+			$input_formats  = array( 'image/jpeg', 'image/png', 'image/gif', 'image/webp', 'image/avif', 'image/heic', 'image/heif' );
 			$output_formats = array();
 			foreach ( $input_formats as $mime_type ) {
 				/** This filter is documented in wp-includes/media.php */

src/wp-includes/rest-api/endpoints/class-wp-rest-attachments-controller.php

@@ -24,6 +24,29 @@ class WP_REST_Attachments_Controller extends WP_REST_Posts_Controller {
 	 */
 	protected $allow_batch = false;
 
+	/**
+	 * Image size token for the source-format original preserved alongside a
+	 * client-generated derivative (e.g. the HEIC file kept next to its JPEG).
+	 *
+	 * Used both in the `/sideload` route schema and when dispatching the
+	 * sideloaded file to its metadata key, so the two never drift apart.
+	 *
+	 * @since 7.1.0
+	 * @var string
+	 */
+	const IMAGE_SIZE_SOURCE_ORIGINAL = 'source_original';
+
+	/**
+	 * Metadata key holding the basename of the source-format original.
+	 *
+	 * Deliberately specific so it never collides with the generic `original`
+	 * or `original_image` keys other flows write to.
+	 *
+	 * @since 7.1.0
+	 * @var string
+	 */
+	const META_KEY_SOURCE_IMAGE = 'source_image';
+
 	/**
 	 * Registers the routes for attachments.
 	 *
@@ -98,6 +121,8 @@ public function register_routes() {
 									$valid_sizes[] = 'original';
 									$valid_sizes[] = 'scaled';
 									$valid_sizes[] = 'full';
+									// Source-format original (e.g. the HEIC kept alongside its JPEG derivative).
+									$valid_sizes[] = self::IMAGE_SIZE_SOURCE_ORIGINAL;
 
 									$items = is_string( $value ) ? array( $value ) : ( is_array( $value ) ? $value : null );
 									if ( null === $items ) {
@@ -327,6 +352,26 @@ public function create_item_permissions_check( $request ) {
 			$prevent_unsupported_uploads = false;
 		}
 
+		/*
+		 * Always allow still HEIC/HEIF uploads through even if the server's
+		 * image editor doesn't support them. The client-side canvas fallback
+		 * handles processing using the browser's native HEVC decoder.
+		 *
+		 * The '-sequence' variants (multi-frame Live Photos) are deliberately
+		 * excluded: neither the server nor the browser fallback can process
+		 * them yet, so they should fall through to the standard unsupported
+		 * mime-type error rather than be stored unprocessable.
+		 */
+		$still_heic_mime_types = array( 'image/heic', 'image/heif' );
+
+		if (
+			$prevent_unsupported_uploads &&
+			! empty( $files['file']['type'] ) &&
+			in_array( $files['file']['type'], $still_heic_mime_types, true )
+		) {
+			$prevent_unsupported_uploads = false;
+		}
+
 		// If the upload is an image, check if the server can handle the mime type.
 		if (
 			$prevent_unsupported_uploads &&
@@ -1458,7 +1503,7 @@ public function get_item_schema() {
 	 * @param string      $data    Supplied file data.
 	 * @param array       $headers HTTP headers from the request.
 	 * @param string|null $time    Optional. Time formatted in 'yyyy/mm'. Default null.
-	 * @return array|WP_Error Data from wp_handle_sideload().
+	 * @return array{ file: non-empty-string, url: non-empty-string, type: non-empty-string }|WP_Error Data from wp_handle_sideload().
 	 */
 	protected function upload_from_data( $data, $headers, $time = null ) {
 		if ( empty( $data ) ) {
@@ -1678,7 +1723,7 @@ public function get_collection_params() {
 	 * @param array       $files   Data from the `$_FILES` superglobal.
 	 * @param array       $headers HTTP headers from the request.
 	 * @param string|null $time    Optional. Time formatted in 'yyyy/mm'. Default null.
-	 * @return array|WP_Error Data from wp_handle_upload().
+	 * @return array{ file: non-empty-string, url: non-empty-string, type: non-empty-string }|WP_Error Data from wp_handle_upload().
 	 */
 	protected function upload_from_file( $files, $headers, $time = null ) {
 		if ( empty( $files ) ) {
@@ -2173,6 +2218,13 @@ public function sideload_item( WP_REST_Request $request ) {
 			$sub_size_data['filesize']  = wp_filesize( $path );
 		} elseif ( 'original' === $image_size ) {
 			$sub_size_data['file'] = wp_basename( $path );
+		} elseif ( self::IMAGE_SIZE_SOURCE_ORIGINAL === $image_size ) {
+			/*
+			 * Source-format original (e.g. the HEIC kept next to its JPEG
+			 * derivative). Record the filename so finalize_item can store it
+			 * under the dedicated source-image meta key.
+			 */
+			$sub_size_data['file'] = wp_basename( $path );
 		} elseif ( 'scaled' === $image_size ) {
 			// Record the current attached file as the original.
 			$current_file = get_attached_file( $attachment_id, true );
@@ -2328,6 +2380,15 @@ public function finalize_item( WP_REST_Request $request ) {
 
 			if ( 'original' === $image_size ) {
 				$metadata['original_image'] = $sub_size['file'];
+			} elseif ( self::IMAGE_SIZE_SOURCE_ORIGINAL === $image_size ) {
+				/*
+				 * Source-format original: stored under its own meta key so the
+				 * scaled-sideload flow (which writes 'original_image') cannot
+				 * clobber it. 'original_image' keeps pointing at the
+				 * web-viewable JPEG derivative. Cleanup on attachment delete
+				 * is handled by wp_delete_attachment_files().
+				 */
+				$metadata[ self::META_KEY_SOURCE_IMAGE ] = $sub_size['file'];
 			} elseif ( 'scaled' === $image_size ) {
 				if ( ! empty( $sub_size['original_image'] ) ) {
 					$metadata['original_image'] = $sub_size['original_image'];

tests/phpunit/tests/media/wpDeleteAttachmentSourceImage.php

@@ -0,0 +1,95 @@
+<?php
+
+/**
+ * Tests that wp_delete_attachment_files() removes the 'source_image' companion file.
+ *
+ * @group media
+ * @covers ::wp_delete_attachment_files
+ */
+class Tests_Media_wpDeleteAttachmentSourceImage extends WP_UnitTestCase {
+
+	public function tear_down(): void {
+		$this->remove_added_uploads();
+
+		parent::tear_down();
+	}
+
+	/**
+	 * @ticket 64915
+	 */
+	public function test_deletes_companion_file_recorded_in_metadata_source_image(): void {
+		$attachment_id = self::factory()->attachment->create_upload_object( DIR_TESTDATA . '/images/canola.jpg' );
+		$this->assertIsInt( $attachment_id );
+
+		$attached_file = get_attached_file( $attachment_id, true );
+		$this->assertIsString( $attached_file );
+		$dir       = dirname( $attached_file );
+		$heic_name = 'companion-' . wp_generate_password( 6, false ) . '.heic';
+		$heic_path = $dir . '/' . $heic_name;
+
+		// Create a dummy companion file on disk.
+		file_put_contents( $heic_path, 'test' );
+		$this->assertFileExists( $heic_path, 'Test fixture should be on disk.' );
+
+		// Record the companion under metadata['source_image'] as the sideload route does.
+		$metadata = wp_get_attachment_metadata( $attachment_id, true );
+		$this->assertIsArray( $metadata );
+		$metadata['source_image'] = $heic_name;
+		wp_update_attachment_metadata( $attachment_id, $metadata );
+
+		wp_delete_attachment( $attachment_id, true );
+
+		$this->assertNull( get_post( $attachment_id ) );
+		$this->assertFileDoesNotExist( $heic_path, 'Companion file should be deleted alongside the attachment.' );
+	}
+
+	/**
+	 * @ticket 64915
+	 */
+	public function test_noop_when_metadata_source_image_is_missing(): void {
+		$attachment_id = self::factory()->attachment->create_upload_object( DIR_TESTDATA . '/images/canola.jpg' );
+		$this->assertIsInt( $attachment_id );
+
+		// Sanity: no 'source_image' key on freshly-created metadata.
+		$metadata = wp_get_attachment_metadata( $attachment_id, true );
+		$this->assertIsArray( $metadata );
+		$this->assertArrayNotHasKey( 'source_image', $metadata );
+
+		// Deletion should complete cleanly even though no companion file is recorded.
+		wp_delete_attachment( $attachment_id, true );
+
+		$this->assertNull( get_post( $attachment_id ) );
+	}
+
+	/**
+	 * Guards against $metadata['source_image'] holding a non-string value (e.g.
+	 * the array form some flows write). Regression coverage for GB #78128.
+	 *
+	 * @ticket 64915
+	 */
+	public function test_noop_when_metadata_source_image_is_not_a_string(): void {
+		$attachment_id = self::factory()->attachment->create_upload_object( DIR_TESTDATA . '/images/canola.jpg' );
+		$this->assertIsInt( $attachment_id );
+		$attached_file = get_attached_file( $attachment_id, true );
+		$this->assertIsString( $attached_file );
+
+		/*
+		 * Place a real file that a buggy, guard-less implementation could try to
+		 * delete after running wp_basename() over the array value below.
+		 */
+		$bystander_path = dirname( $attached_file ) . '/should-not-delete.heic';
+		file_put_contents( $bystander_path, 'test' );
+		$this->assertFileExists( $bystander_path, 'Test fixture should be on disk.' );
+
+		$metadata = wp_get_attachment_metadata( $attachment_id, true );
+		$this->assertIsArray( $metadata );
+		$metadata['source_image'] = array( 'file' => 'should-not-delete.heic' );
+		wp_update_attachment_metadata( $attachment_id, $metadata );
+
+		// Deletion should not raise (no str_replace() / file deletion on an array).
+		wp_delete_attachment( $attachment_id, true );
+
+		$this->assertNull( get_post( $attachment_id ) );
+		$this->assertFileExists( $bystander_path, 'The non-string guard must prevent any file deletion.' );
+	}
+}