File.php

Go to the documentation of this file.

<?php
namespace MediaWiki\FileRepo\File;
 
use LogicException;
use MediaHandler;
use MediaHandlerState;
use MediaTransformError;
use MediaTransformOutput;
use MediaWiki\Config\ConfigException;
use MediaWiki\Context\IContextSource;
use MediaWiki\FileRepo\FileRepo;
use MediaWiki\FileRepo\ForeignAPIRepo;
use MediaWiki\FileRepo\LocalRepo;
use MediaWiki\HookContainer\ProtectedHookAccessorTrait;
use MediaWiki\JobQueue\Jobs\HTMLCacheUpdateJob;
use MediaWiki\Language\Language;
use MediaWiki\Linker\LinkTarget;
use MediaWiki\Logger\LoggerFactory;
use MediaWiki\MainConfigNames;
use MediaWiki\MediaWikiServices;
use MediaWiki\Page\PageIdentity;
use MediaWiki\Permissions\Authority;
use MediaWiki\PoolCounter\PoolCounterWorkViaCallback;
use MediaWiki\Status\Status;
use MediaWiki\Title\Title;
use MediaWiki\User\UserIdentity;
use RuntimeException;
use Shellbox\Command\BoxedCommand;
use StatusValue;
use ThumbnailImage;
use Wikimedia\FileBackend\FileBackend;
use Wikimedia\FileBackend\FSFile\FSFile;
use Wikimedia\FileBackend\FSFile\TempFSFile;
use Wikimedia\ObjectCache\WANObjectCache;
 
abstract class File implements MediaHandlerState {
    use ProtectedHookAccessorTrait;
 
    // Bitfield values akin to the revision deletion constants
    public const DELETED_FILE = 1;
    public const DELETED_COMMENT = 2;
    public const DELETED_USER = 4;
    public const DELETED_RESTRICTED = 8;
 
    public const RENDER_NOW = 1;
    public const RENDER_FORCE = 2;
 
    public const DELETE_SOURCE = 1;
 
    // Audience options for File::getDescription()
    public const FOR_PUBLIC = 1;
    public const FOR_THIS_USER = 2;
    public const RAW = 3;
 
    // Options for File::thumbName()
    public const THUMB_FULL_NAME = 1;
 
    public $repo;
 
    protected $title;
 
    protected $lastError;
 
    protected $redirected;
 
    protected $redirectedTitle;
 
    protected $fsFile;
 
    protected $handler;
 
    protected $url;
 
    protected $extension;
 
    protected $name;
 
    protected $path;
 
    protected $hashPath;
 
    protected $pageCount;
 
    protected $transformScript;
 
    protected $redirectTitle;
 
    protected $canRender;
 
    protected $isSafeFile;
 
    protected $repoClass = FileRepo::class;
 
    protected $tmpBucketedThumbCache = [];
 
    private $handlerState = [];
 
    public function __construct( $title, $repo ) {
        // Some subclasses do not use $title, but set name/title some other way
        if ( $title !== false ) {
            $title = self::normalizeTitle( $title, 'exception' );
        }
        $this->title = $title;
        $this->repo = $repo;
    }
 
    public static function normalizeTitle( $title, $exception = false ) {
        $ret = $title;
 
        if ( !$ret instanceof Title ) {
            if ( $ret instanceof PageIdentity ) {
                $ret = Title::castFromPageIdentity( $ret );
            } elseif ( $ret instanceof LinkTarget ) {
                $ret = Title::castFromLinkTarget( $ret );
            }
        }
 
        if ( $ret instanceof Title ) {
            # Normalize NS_MEDIA -> NS_FILE
            if ( $ret->getNamespace() === NS_MEDIA ) {
                $ret = Title::makeTitleSafe( NS_FILE, $ret->getDBkey() );
            # Double check the titles namespace
            } elseif ( $ret->getNamespace() !== NS_FILE ) {
                $ret = null;
            }
        } else {
            # Convert strings to Title objects
            $ret = Title::makeTitleSafe( NS_FILE, (string)$ret );
        }
        if ( !$ret && $exception !== false ) {
            throw new RuntimeException( "`$title` is not a valid file title." );
        }
 
        return $ret;
    }
 
    public function __get( $name ) {
        $function = [ $this, 'get' . ucfirst( $name ) ];
        if ( !is_callable( $function ) ) {
            return null;
        } else {
            $this->$name = $function();
 
            return $this->$name;
        }
    }
 
    public static function normalizeExtension( $extension ) {
        $lower = strtolower( $extension );
        $squish = [
            'htm' => 'html',
            'jpeg' => 'jpg',
            'mpeg' => 'mpg',
            'tiff' => 'tif',
            'ogv' => 'ogg' ];
        if ( isset( $squish[$lower] ) ) {
            return $squish[$lower];
        } elseif ( preg_match( '/^[0-9a-z]+$/', $lower ) ) {
            return $lower;
        } else {
            return '';
        }
    }
 
    public static function checkExtensionCompatibility( File $old, $new ) {
        $oldMime = $old->getMimeType();
        $n = strrpos( $new, '.' );
        $newExt = self::normalizeExtension( $n ? substr( $new, $n + 1 ) : '' );
        $mimeMagic = MediaWikiServices::getInstance()->getMimeAnalyzer();
 
        return $mimeMagic->isMatchingExtension( $newExt, $oldMime );
    }
 
    public function upgradeRow() {
    }
 
    public static function splitMime( ?string $mime ) {
        if ( $mime === null ) {
            return [ 'unknown', 'unknown' ];
        } elseif ( str_contains( $mime, '/' ) ) {
            return explode( '/', $mime, 2 );
        } else {
            return [ $mime, 'unknown' ];
        }
    }
 
    public static function compare( File $a, File $b ) {
        return strcmp( $a->getName(), $b->getName() );
    }
 
    public function getName() {
        if ( $this->name === null ) {
            $this->assertRepoDefined();
            $this->name = $this->repo->getNameFromTitle( $this->title );
        }
 
        return $this->name;
    }
 
    public function getExtension() {
        if ( $this->extension === null ) {
            $n = strrpos( $this->getName(), '.' );
            $this->extension = self::normalizeExtension(
                $n ? substr( $this->getName(), $n + 1 ) : '' );
        }
 
        return $this->extension;
    }
 
    public function getTitle() {
        return $this->title;
    }
 
    public function getOriginalTitle() {
        if ( $this->redirected !== null ) {
            return $this->getRedirectedTitle();
        }
 
        return $this->title;
    }
 
    public function getUrl() {
        if ( $this->url === null ) {
            $this->assertRepoDefined();
            $ext = $this->getExtension();
            $this->url = $this->repo->getZoneUrl( 'public', $ext ) . '/' . $this->getUrlRel();
        }
 
        return $this->url;
    }
 
    public function getDescriptionShortUrl() {
        return null;
    }
 
    public function getFullUrl() {
        return (string)MediaWikiServices::getInstance()->getUrlUtils()
            ->expand( $this->getUrl(), PROTO_RELATIVE );
    }
 
    public function getCanonicalUrl() {
        return (string)MediaWikiServices::getInstance()->getUrlUtils()
            ->expand( $this->getUrl(), PROTO_CANONICAL );
    }
 
    public function getViewURL() {
        if ( $this->mustRender() ) {
            if ( $this->canRender() ) {
                return $this->createThumb( $this->getWidth() );
            } else {
                wfDebug( __METHOD__ . ': supposed to render ' . $this->getName() .
                    ' (' . $this->getMimeType() . "), but can't!" );
 
                return $this->getUrl(); # hm... return NULL?
            }
        } else {
            return $this->getUrl();
        }
    }
 
    public function getPath() {
        if ( $this->path === null ) {
            $this->assertRepoDefined();
            $this->path = $this->repo->getZonePath( 'public' ) . '/' . $this->getRel();
        }
 
        return $this->path;
    }
 
    public function getLocalRefPath() {
        $this->assertRepoDefined();
        if ( !$this->fsFile ) {
            $timer = MediaWikiServices::getInstance()->getStatsFactory()
                ->getTiming( 'media_thumbnail_generate_fetchoriginal_seconds' )
                ->copyToStatsdAt( 'media.thumbnail.generate.fetchoriginal' )
                ->start();
 
            $this->fsFile = $this->repo->getLocalReference( $this->getPath() );
 
            $timer->stop();
 
            if ( !$this->fsFile ) {
                $this->fsFile = false; // null => false; cache negative hits
            }
        }
 
        return ( $this->fsFile )
            ? $this->fsFile->getPath()
            : false;
    }
 
    public function addToShellboxCommand( BoxedCommand $command, string $boxedName ) {
        return $this->repo->addShellboxInputFile( $command, $boxedName, $this->getVirtualUrl() );
    }
 
    public function getWidth( $page = 1 ) {
        return false;
    }
 
    public function getHeight( $page = 1 ) {
        return false;
    }
 
    public function getThumbnailBucket( $desiredWidth, $page = 1 ) {
        $thumbnailBuckets = MediaWikiServices::getInstance()
            ->getMainConfig()->get( MainConfigNames::ThumbnailBuckets );
        $thumbnailMinimumBucketDistance = MediaWikiServices::getInstance()
            ->getMainConfig()->get( MainConfigNames::ThumbnailMinimumBucketDistance );
        $imageWidth = $this->getWidth( $page );
 
        if ( $imageWidth === false ) {
            return false;
        }
 
        if ( $desiredWidth > $imageWidth ) {
            return false;
        }
 
        if ( !$thumbnailBuckets ) {
            return false;
        }
 
        $sortedBuckets = $thumbnailBuckets;
 
        sort( $sortedBuckets );
 
        foreach ( $sortedBuckets as $bucket ) {
            if ( $bucket >= $imageWidth ) {
                return false;
            }
 
            if ( $bucket - $thumbnailMinimumBucketDistance > $desiredWidth ) {
                return $bucket;
            }
        }
 
        // Image is bigger than any available bucket
        return false;
    }
 
    public function getDisplayWidthHeight( $maxWidth, $maxHeight, $page = 1 ) {
        if ( !$maxWidth || !$maxHeight ) {
            // should never happen
            throw new ConfigException( 'Using a choice from $wgImageLimits that is 0x0' );
        }
 
        $width = $this->getWidth( $page );
        $height = $this->getHeight( $page );
        if ( !$width || !$height ) {
            return [ 0, 0 ];
        }
 
        // Calculate the thumbnail size.
        if ( $width <= $maxWidth && $height <= $maxHeight ) {
            // Vectorized image, do nothing.
        } elseif ( $width / $height >= $maxWidth / $maxHeight ) {
            # The limiting factor is the width, not the height.
            $height = round( $height * $maxWidth / $width );
            $width = $maxWidth;
            // Note that $height <= $maxHeight now.
        } else {
            $newwidth = floor( $width * $maxHeight / $height );
            $height = round( $height * $newwidth / $width );
            $width = $newwidth;
            // Note that $height <= $maxHeight now, but might not be identical
            // because of rounding.
        }
        return [ $width, $height ];
    }
 
    public function getLength() {
        $handler = $this->getHandler();
        if ( $handler ) {
            return $handler->getLength( $this );
        } else {
            return 0;
        }
    }
 
    public function isVectorized() {
        $handler = $this->getHandler();
        if ( $handler ) {
            return $handler->isVectorized( $this );
        } else {
            return false;
        }
    }
 
    public function getAvailableLanguages() {
        $handler = $this->getHandler();
        if ( $handler ) {
            return $handler->getAvailableLanguages( $this );
        } else {
            return [];
        }
    }
 
    public function getMatchedLanguage( $userPreferredLanguage ) {
        $handler = $this->getHandler();
        if ( $handler ) {
            return $handler->getMatchedLanguage(
                $userPreferredLanguage,
                $handler->getAvailableLanguages( $this )
            );
        }
 
        return null;
    }
 
    public function getDefaultRenderLanguage() {
        $handler = $this->getHandler();
        if ( $handler ) {
            return $handler->getDefaultRenderLanguage( $this );
        } else {
            return null;
        }
    }
 
    public function canAnimateThumbIfAppropriate() {
        $handler = $this->getHandler();
        if ( !$handler ) {
            // We cannot handle image whatsoever, thus
            // one would not expect it to be animated
            // so true.
            return true;
        }
 
        return !$this->allowInlineDisplay()
            // Image is not animated, so one would
            // not expect thumb to be
            || !$handler->isAnimatedImage( $this )
            // Image is animated, but thumbnail isn't.
            // This is unexpected to the user.
            || $handler->canAnimateThumbnail( $this );
    }
 
    public function getMetadata() {
        return false;
    }
 
    public function getHandlerState( string $key ) {
        return $this->handlerState[$key] ?? null;
    }
 
    public function setHandlerState( string $key, $value ) {
        $this->handlerState[$key] = $value;
    }
 
    public function getMetadataArray(): array {
        return [];
    }
 
    public function getMetadataItem( string $itemName ) {
        $items = $this->getMetadataItems( [ $itemName ] );
        return $items[$itemName] ?? null;
    }
 
    public function getMetadataItems( array $itemNames ): array {
        return array_intersect_key(
            $this->getMetadataArray(),
            array_fill_keys( $itemNames, true ) );
    }
 
    public function getCommonMetaArray() {
        $handler = $this->getHandler();
        return $handler ? $handler->getCommonMetaArray( $this ) : false;
    }
 
    public function convertMetadataVersion( $metadata, $version ) {
        $handler = $this->getHandler();
        if ( $handler ) {
            return $handler->convertMetadataVersion( $metadata, $version );
        } else {
            return $metadata;
        }
    }
 
    public function getBitDepth() {
        return 0;
    }
 
    public function getSize() {
        return false;
    }
 
    public function getMimeType() {
        return 'unknown/unknown';
    }
 
    public function getMediaType() {
        return MEDIATYPE_UNKNOWN;
    }
 
    public function canRender() {
        if ( $this->canRender === null ) {
            $this->canRender = $this->getHandler() && $this->handler->canRender( $this ) && $this->exists();
        }
 
        return $this->canRender;
    }
 
    protected function getCanRender() {
        return $this->canRender();
    }
 
    public function mustRender() {
        return $this->getHandler() && $this->handler->mustRender( $this );
    }
 
    public function allowInlineDisplay() {
        return $this->canRender();
    }
 
    public function isSafeFile() {
        if ( $this->isSafeFile === null ) {
            $this->isSafeFile = $this->getIsSafeFileUncached();
        }
 
        return $this->isSafeFile;
    }
 
    protected function getIsSafeFile() {
        return $this->isSafeFile();
    }
 
    protected function getIsSafeFileUncached() {
        $trustedMediaFormats = MediaWikiServices::getInstance()->getMainConfig()
            ->get( MainConfigNames::TrustedMediaFormats );
 
        if ( $this->allowInlineDisplay() ) {
            return true;
        }
        if ( $this->isTrustedFile() ) {
            return true;
        }
 
        $type = $this->getMediaType();
        $mime = $this->getMimeType();
 
        if ( !$type || $type === MEDIATYPE_UNKNOWN ) {
            return false; # unknown type, not trusted
        }
        if ( in_array( $type, $trustedMediaFormats ) ) {
            return true;
        }
 
        if ( $mime === "unknown/unknown" ) {
            return false; # unknown type, not trusted
        }
        if ( in_array( $mime, $trustedMediaFormats ) ) {
            return true;
        }
 
        return false;
    }
 
    protected function isTrustedFile() {
        # this could be implemented to check a flag in the database,
        # look for signatures, etc
        return false;
    }
 
    public function load( $flags = 0 ) {
    }
 
    public function exists() {
        return $this->getPath() && $this->repo->fileExists( $this->path );
    }
 
    public function isVisible() {
        return $this->exists();
    }
 
    private function getTransformScript() {
        if ( $this->transformScript === null ) {
            $this->transformScript = false;
            if ( $this->repo ) {
                $script = $this->repo->getThumbScriptUrl();
                if ( $script ) {
                    $this->transformScript = wfAppendQuery( $script, [ 'f' => $this->getName() ] );
                }
            }
        }
 
        return $this->transformScript;
    }
 
    public function getUnscaledThumb( $handlerParams = [] ) {
        $hp =& $handlerParams;
        $page = $hp['page'] ?? false;
        $width = $this->getWidth( $page );
        if ( !$width ) {
            return $this->iconThumb();
        }
        $hp['width'] = $width;
        // be sure to ignore any height specification as well (T64258)
        unset( $hp['height'] );
 
        return $this->transform( $hp );
    }
 
    public function thumbName( $params, $flags = 0 ) {
        $name = ( $this->repo && !( $flags & self::THUMB_FULL_NAME ) )
            ? $this->repo->nameForThumb( $this->getName() )
            : $this->getName();
 
        return $this->generateThumbName( $name, $params );
    }
 
    public function generateThumbName( $name, $params ) {
        if ( !$this->getHandler() ) {
            return null;
        }
        $extension = $this->getExtension();
        [ $thumbExt, ] = $this->getHandler()->getThumbType(
            $extension, $this->getMimeType(), $params );
        $thumbName = $this->getHandler()->makeParamString( $this->adjustThumbWidthForSteps( $params ) );
 
        if ( $this->repo->supportsSha1URLs() ) {
            $thumbName .= '-' . $this->getSha1() . '.' . $thumbExt;
        } else {
            $thumbName .= '-' . $name;
 
            if ( $thumbExt != $extension ) {
                $thumbName .= ".$thumbExt";
            }
        }
 
        return $thumbName;
    }
 
    private function adjustThumbWidthForSteps( array $params ): array {
        $thumbnailSteps = MediaWikiServices::getInstance()
            ->getMainConfig()->get( MainConfigNames::ThumbnailSteps );
        $thumbnailStepsRatio = MediaWikiServices::getInstance()
            ->getMainConfig()->get( MainConfigNames::ThumbnailStepsRatio );
 
        if ( !$thumbnailSteps || !$thumbnailStepsRatio ) {
            return $params;
        }
        if ( !isset( $params['physicalWidth'] ) || !$params['physicalWidth'] ) {
            return $params;
        }
 
        if ( $thumbnailStepsRatio < 1 ) {
            // If thumbnail ratio is below 100%, build a random number
            // out of the file name and decide whether to apply adjustments
            // based on that. This way, we get a good uniformity while not going
            // back and forth between old and new in different requests.
            // Also this way, ramping up (e.g. from 0.1 to 0.2) would also
            // cover the previous values too which would reduce the scale of changes.
            $hash = hexdec( substr( md5( $this->name ), 0, 8 ) ) & 0x7fffffff;
            if ( ( $hash % 1000 ) > ( $thumbnailStepsRatio * 1000 ) ) {
                return $params;
            }
        }
 
        $newThumbSize = null;
        foreach ( $thumbnailSteps as $widthStep ) {
            if ( $widthStep > $this->getWidth() ) {
                return $params;
            }
            if ( $widthStep == $params['physicalWidth'] ) {
                return $params;
            }
            if ( $widthStep > $params['physicalWidth'] ) {
                $newThumbSize = $widthStep;
                break;
            }
        }
        if ( !$newThumbSize ) {
            return $params;
        }
 
        if ( isset( $params['physicalHeight'] ) ) {
            $params['physicalHeight'] = intval(
                $params['physicalHeight'] *
                ( $newThumbSize / $params['physicalWidth'] )
            );
        }
        $params['physicalWidth'] = $newThumbSize;
        return $params;
    }
 
    public function createThumb( $width, $height = -1 ) {
        $params = [ 'width' => $width ];
        if ( $height != -1 ) {
            $params['height'] = $height;
        }
        $thumb = $this->transform( $params );
        if ( !$thumb || $thumb->isError() ) {
            return '';
        }
 
        return $thumb->getUrl();
    }
 
    protected function transformErrorOutput( $thumbPath, $thumbUrl, $params, $flags ) {
        $ignoreImageErrors = MediaWikiServices::getInstance()->getMainConfig()
            ->get( MainConfigNames::IgnoreImageErrors );
 
        $handler = $this->getHandler();
        if ( $handler && $ignoreImageErrors && !( $flags & self::RENDER_NOW ) ) {
            return $handler->getTransform( $this, $thumbPath, $thumbUrl, $params );
        } else {
            return new MediaTransformError( 'thumbnail_error',
                $params['width'], 0, wfMessage( 'thumbnail-dest-create' ) );
        }
    }
 
    public function transform( $params, $flags = 0 ) {
        $thumbnailEpoch = MediaWikiServices::getInstance()->getMainConfig()
            ->get( MainConfigNames::ThumbnailEpoch );
 
        do {
            if ( !$this->canRender() ) {
                $thumb = $this->iconThumb();
                break; // not a bitmap or renderable image, don't try
            }
 
            // Get the descriptionUrl to embed it as comment into the thumbnail. T21791.
            $descriptionUrl = $this->getDescriptionUrl();
            if ( $descriptionUrl ) {
                $params['descriptionUrl'] = MediaWikiServices::getInstance()->getUrlUtils()
                    ->expand( $descriptionUrl, PROTO_CANONICAL );
            }
 
            $handler = $this->getHandler();
            $script = $this->getTransformScript();
            if ( $script && !( $flags & self::RENDER_NOW ) ) {
                // Use a script to transform on client request, if possible
                $thumb = $handler->getScriptedTransform( $this, $script, $params );
                if ( $thumb ) {
                    break;
                }
            }
 
            $normalisedParams = $params;
            $handler->normaliseParams( $this, $normalisedParams );
 
            $thumbName = $this->thumbName( $normalisedParams );
            $thumbUrl = $this->getThumbUrl( $thumbName );
            $thumbPath = $this->getThumbPath( $thumbName ); // final thumb path
            if ( isset( $normalisedParams['isFilePageThumb'] ) && $normalisedParams['isFilePageThumb'] ) {
                // Use a versioned URL on file description pages
                $thumbUrl = $this->getFilePageThumbUrl( $thumbUrl );
            }
 
            if ( $this->repo ) {
                // Defer rendering if a 404 handler is set up...
                if ( $this->repo->canTransformVia404() && !( $flags & self::RENDER_NOW ) ) {
                    // XXX: Pass in the storage path even though we are not rendering anything
                    // and the path is supposed to be an FS path. This is due to getScalerType()
                    // getting called on the path and clobbering $thumb->getUrl() if it's false.
                    $thumb = $handler->getTransform( $this, $thumbPath, $thumbUrl, $params );
                    break;
                }
                // Check if an up-to-date thumbnail already exists...
                wfDebug( __METHOD__ . ": Doing stat for $thumbPath" );
                if ( !( $flags & self::RENDER_FORCE ) && $this->repo->fileExists( $thumbPath ) ) {
                    $timestamp = $this->repo->getFileTimestamp( $thumbPath );
                    if ( $timestamp !== false && $timestamp >= $thumbnailEpoch ) {
                        // XXX: Pass in the storage path even though we are not rendering anything
                        // and the path is supposed to be an FS path. This is due to getScalerType()
                        // getting called on the path and clobbering $thumb->getUrl() if it's false.
                        $thumb = $handler->getTransform( $this, $thumbPath, $thumbUrl, $params );
                        $thumb->setStoragePath( $thumbPath );
                        break;
                    }
                } elseif ( $flags & self::RENDER_FORCE ) {
                    wfDebug( __METHOD__ . ": forcing rendering per flag File::RENDER_FORCE" );
                }
 
                // If the backend is ready-only, don't keep generating thumbnails
                // only to return transformation errors, just return the error now.
                if ( $this->repo->getReadOnlyReason() !== false ) {
                    $thumb = $this->transformErrorOutput( $thumbPath, $thumbUrl, $params, $flags );
                    break;
                }
 
                // Check to see if local transformation is disabled.
                if ( !$this->repo->canTransformLocally() ) {
                    LoggerFactory::getInstance( 'thumbnail' )
                        ->error( 'Local transform denied by configuration' );
                    $thumb = new MediaTransformError(
                        wfMessage(
                            'thumbnail_error',
                            'MediaWiki is configured to disallow local image scaling'
                        ),
                        $params['width'],
                        0
                    );
                    break;
                }
            }
 
            $tmpFile = $this->makeTransformTmpFile( $thumbPath );
 
            if ( !$tmpFile ) {
                $thumb = $this->transformErrorOutput( $thumbPath, $thumbUrl, $params, $flags );
            } else {
                $thumb = $this->generateAndSaveThumb( $tmpFile, $params, $flags );
            }
        } while ( false );
 
        return $thumb ?: false;
    }
 
    public function generateAndSaveThumb( $tmpFile, $transformParams, $flags ) {
        $ignoreImageErrors = MediaWikiServices::getInstance()->getMainConfig()
            ->get( MainConfigNames::IgnoreImageErrors );
 
        if ( !$this->repo->canTransformLocally() ) {
            LoggerFactory::getInstance( 'thumbnail' )
                ->error( 'Local transform denied by configuration' );
            return new MediaTransformError(
                wfMessage(
                    'thumbnail_error',
                    'MediaWiki is configured to disallow local image scaling'
                ),
                $transformParams['width'],
                0
            );
        }
 
        $statsFactory = MediaWikiServices::getInstance()->getStatsFactory();
 
        $handler = $this->getHandler();
 
        $normalisedParams = $transformParams;
        $handler->normaliseParams( $this, $normalisedParams );
 
        $thumbName = $this->thumbName( $normalisedParams );
        $thumbUrl = $this->getThumbUrl( $thumbName );
        $thumbPath = $this->getThumbPath( $thumbName ); // final thumb path
        if ( isset( $normalisedParams['isFilePageThumb'] ) && $normalisedParams['isFilePageThumb'] ) {
            // Use a versioned URL on file description pages
            $thumbUrl = $this->getFilePageThumbUrl( $thumbUrl );
        }
 
        $tmpThumbPath = $tmpFile->getPath();
 
        if ( $handler->supportsBucketing() ) {
            $this->generateBucketsIfNeeded( $normalisedParams, $flags );
        }
 
        # T367110
        # Calls to doTransform() can recur back on $this->transform()
        # depending on implementation. One such example is PagedTiffHandler.
        # TimingMetric->start() and stop() cannot be used in this situation
        # so we will track the time manually.
        $starttime = microtime( true );
 
        // Actually render the thumbnail...
        $thumb = $handler->doTransform( $this, $tmpThumbPath, $thumbUrl, $transformParams );
        $tmpFile->bind( $thumb ); // keep alive with $thumb
 
        $statsFactory->getTiming( 'media_thumbnail_generate_transform_seconds' )
            ->copyToStatsdAt( 'media.thumbnail.generate.transform' )
            ->observe( ( microtime( true ) - $starttime ) * 1000 );
 
        if ( !$thumb ) { // bad params?
            $thumb = false;
        } elseif ( $thumb->isError() ) { // transform error
            '@phan-var MediaTransformError $thumb';
            $this->lastError = $thumb->toText();
            // Ignore errors if requested
            if ( $ignoreImageErrors && !( $flags & self::RENDER_NOW ) ) {
                $thumb = $handler->getTransform( $this, $tmpThumbPath, $thumbUrl, $transformParams );
            }
        } elseif ( $this->repo && $thumb->hasFile() && !$thumb->fileIsSource() ) {
            // Copy the thumbnail from the file system into storage...
 
            $timer = $statsFactory->getTiming( 'media_thumbnail_generate_store_seconds' )
                ->copyToStatsdAt( 'media.thumbnail.generate.store' )
                ->start();
 
            wfDebug( __METHOD__ . ": copying $tmpThumbPath to $thumbPath" );
            $disposition = $this->getThumbDisposition( $thumbName );
            $status = $this->repo->quickImport( $tmpThumbPath, $thumbPath, $disposition );
            if ( $status->isOK() ) {
                $thumb->setStoragePath( $thumbPath );
            } else {
                $thumb = $this->transformErrorOutput( $thumbPath, $thumbUrl, $transformParams, $flags );
            }
 
            $timer->stop();
 
            // Give extensions a chance to do something with this thumbnail...
            $this->getHookRunner()->onFileTransformed( $this, $thumb, $tmpThumbPath, $thumbPath );
        }
 
        return $thumb;
    }
 
    protected function generateBucketsIfNeeded( $params, $flags = 0 ) {
        if ( !$this->repo
            || !isset( $params['physicalWidth'] )
            || !isset( $params['physicalHeight'] )
        ) {
            return false;
        }
 
        $bucket = $this->getThumbnailBucket( $params['physicalWidth'] );
 
        if ( !$bucket || $bucket == $params['physicalWidth'] ) {
            return false;
        }
 
        $bucketPath = $this->getBucketThumbPath( $bucket );
 
        if ( $this->repo->fileExists( $bucketPath ) ) {
            return false;
        }
 
        $timer = MediaWikiServices::getInstance()->getStatsFactory()
            ->getTiming( 'media_thumbnail_generate_bucket_seconds' )
            ->copyToStatsdAt( 'media.thumbnail.generate.bucket' );
        $timer->start();
 
        $params['physicalWidth'] = $bucket;
        $params['width'] = $bucket;
 
        $params = $this->getHandler()->sanitizeParamsForBucketing( $params );
 
        $tmpFile = $this->makeTransformTmpFile( $bucketPath );
 
        if ( !$tmpFile ) {
            return false;
        }
 
        $thumb = $this->generateAndSaveThumb( $tmpFile, $params, $flags );
 
        if ( !$thumb || $thumb->isError() ) {
            return false;
        }
 
        $timer->stop();
 
        $this->tmpBucketedThumbCache[$bucket] = $tmpFile->getPath();
        // For the caching to work, we need to make the tmp file survive as long as
        // this object exists
        $tmpFile->bind( $this );
 
        return true;
    }
 
    public function getThumbnailSource( $params ) {
        if ( $this->repo
            && $this->getHandler()->supportsBucketing()
            && isset( $params['physicalWidth'] )
        ) {
            $bucket = $this->getThumbnailBucket( $params['physicalWidth'] );
            if ( $bucket ) {
                if ( $this->getWidth() != 0 ) {
                    $bucketHeight = round( $this->getHeight() * ( $bucket / $this->getWidth() ) );
                } else {
                    $bucketHeight = 0;
                }
 
                // Try to avoid reading from storage if the file was generated by this script
                if ( isset( $this->tmpBucketedThumbCache[$bucket] ) ) {
                    $tmpPath = $this->tmpBucketedThumbCache[$bucket];
 
                    if ( file_exists( $tmpPath ) ) {
                        return [
                            'path' => $tmpPath,
                            'width' => $bucket,
                            'height' => $bucketHeight
                        ];
                    }
                }
 
                $bucketPath = $this->getBucketThumbPath( $bucket );
 
                if ( $this->repo->fileExists( $bucketPath ) ) {
                    $fsFile = $this->repo->getLocalReference( $bucketPath );
 
                    if ( $fsFile ) {
                        return [
                            'path' => $fsFile->getPath(),
                            'width' => $bucket,
                            'height' => $bucketHeight
                        ];
                    }
                }
            }
        }
 
        // Thumbnailing a very large file could result in network saturation if
        // everyone does it at once.
        if ( $this->getSize() >= 1e7 ) { // 10 MB
            $work = new PoolCounterWorkViaCallback( 'GetLocalFileCopy', sha1( $this->getName() ),
                [
                    'doWork' => function () {
                        return $this->getLocalRefPath();
                    }
                ]
            );
            $srcPath = $work->execute();
        } else {
            $srcPath = $this->getLocalRefPath();
        }
 
        // Original file
        return [
            'path' => $srcPath,
            'width' => $this->getWidth(),
            'height' => $this->getHeight()
        ];
    }
 
    protected function getBucketThumbPath( $bucket ) {
        $thumbName = $this->getBucketThumbName( $bucket );
        return $this->getThumbPath( $thumbName );
    }
 
    protected function getBucketThumbName( $bucket ) {
        return $this->thumbName( [ 'physicalWidth' => $bucket ] );
    }
 
    protected function makeTransformTmpFile( $thumbPath ) {
        $thumbExt = FileBackend::extensionFromPath( $thumbPath );
        return MediaWikiServices::getInstance()->getTempFSFileFactory()
            ->newTempFSFile( 'transform_', $thumbExt );
    }
 
    public function getThumbDisposition( $thumbName, $dispositionType = 'inline' ) {
        $fileName = $this->getName(); // file name to suggest
        $thumbExt = FileBackend::extensionFromPath( $thumbName );
        if ( $thumbExt != '' && $thumbExt !== $this->getExtension() ) {
            $fileName .= ".$thumbExt";
        }
 
        return FileBackend::makeContentDisposition( $dispositionType, $fileName );
    }
 
    public function getHandler() {
        if ( !$this->handler ) {
            $this->handler = MediaHandler::getHandler( $this->getMimeType() );
        }
 
        return $this->handler;
    }
 
    public function iconThumb() {
        global $IP;
        $resourceBasePath = MediaWikiServices::getInstance()->getMainConfig()
            ->get( MainConfigNames::ResourceBasePath );
        $assetsPath = "{$resourceBasePath}/resources/assets/file-type-icons/";
        $assetsDirectory = "$IP/resources/assets/file-type-icons/";
 
        $try = [ 'fileicon-' . $this->getExtension() . '.png', 'fileicon.png' ];
        foreach ( $try as $icon ) {
            if ( file_exists( $assetsDirectory . $icon ) ) { // always FS
                $params = [ 'width' => 120, 'height' => 120 ];
 
                return new ThumbnailImage( $this, $assetsPath . $icon, false, $params );
            }
        }
 
        return null;
    }
 
    public function getLastError() {
        return $this->lastError;
    }
 
    protected function getThumbnails() {
        return [];
    }
 
    public function purgeCache( $options = [] ) {
    }
 
    public function purgeDescription() {
        $title = $this->getTitle();
        if ( $title ) {
            $title->invalidateCache();
            $hcu = MediaWikiServices::getInstance()->getHtmlCacheUpdater();
            $hcu->purgeTitleUrls( $title, $hcu::PURGE_INTENT_TXROUND_REFLECTED );
        }
    }
 
    public function purgeEverything() {
        // Delete thumbnails and refresh file metadata cache
        $this->purgeCache();
        $this->purgeDescription();
        // Purge cache of all pages using this file
        $title = $this->getTitle();
        if ( $title ) {
            $job = HTMLCacheUpdateJob::newForBacklinks(
                $title,
                'imagelinks',
                [ 'causeAction' => 'file-purge' ]
            );
            MediaWikiServices::getInstance()->getJobQueueGroup()->lazyPush( $job );
        }
    }
 
    public function getHistory( $limit = null, $start = null, $end = null, $inc = true ) {
        return [];
    }
 
    public function nextHistoryLine() {
        return false;
    }
 
    public function resetHistory() {
    }
 
    public function getHashPath() {
        if ( $this->hashPath === null ) {
            $this->assertRepoDefined();
            $this->hashPath = $this->repo->getHashPath( $this->getName() );
        }
 
        return $this->hashPath;
    }
 
    public function getRel() {
        return $this->getHashPath() . $this->getName();
    }
 
    public function getArchiveRel( $suffix = false ) {
        $path = 'archive/' . $this->getHashPath();
        if ( $suffix === false ) {
            $path = rtrim( $path, '/' );
        } else {
            $path .= $suffix;
        }
 
        return $path;
    }
 
    public function getThumbRel( $suffix = false ) {
        $path = $this->getRel();
        if ( $suffix !== false ) {
            $path .= '/' . $suffix;
        }
 
        return $path;
    }
 
    public function getUrlRel() {
        return $this->getHashPath() . rawurlencode( $this->getName() );
    }
 
    private function getArchiveThumbRel( $archiveName, $suffix = false ) {
        $path = $this->getArchiveRel( $archiveName );
        if ( $suffix !== false ) {
            $path .= '/' . $suffix;
        }
 
        return $path;
    }
 
    public function getArchivePath( $suffix = false ) {
        $this->assertRepoDefined();
 
        return $this->repo->getZonePath( 'public' ) . '/' . $this->getArchiveRel( $suffix );
    }
 
    public function getArchiveThumbPath( $archiveName, $suffix = false ) {
        $this->assertRepoDefined();
 
        return $this->repo->getZonePath( 'thumb' ) . '/' .
        $this->getArchiveThumbRel( $archiveName, $suffix );
    }
 
    public function getThumbPath( $suffix = false ) {
        $this->assertRepoDefined();
 
        return $this->repo->getZonePath( 'thumb' ) . '/' . $this->getThumbRel( $suffix );
    }
 
    public function getTranscodedPath( $suffix = false ) {
        $this->assertRepoDefined();
 
        return $this->repo->getZonePath( 'transcoded' ) . '/' . $this->getThumbRel( $suffix );
    }
 
    public function getArchiveUrl( $suffix = false ) {
        $this->assertRepoDefined();
        $ext = $this->getExtension();
        $path = $this->repo->getZoneUrl( 'public', $ext ) . '/archive/' . $this->getHashPath();
        if ( $suffix === false ) {
            $path = rtrim( $path, '/' );
        } else {
            $path .= rawurlencode( $suffix );
        }
 
        return $path;
    }
 
    public function getArchiveThumbUrl( $archiveName, $suffix = false ) {
        $this->assertRepoDefined();
        $ext = $this->getExtension();
        $path = $this->repo->getZoneUrl( 'thumb', $ext ) . '/archive/' .
            $this->getHashPath() . rawurlencode( $archiveName );
        if ( $suffix !== false ) {
            $path .= '/' . rawurlencode( $suffix );
        }
 
        return $path;
    }
 
    private function getZoneUrl( $zone, $suffix = false ) {
        $this->assertRepoDefined();
        $ext = $this->getExtension();
        $path = $this->repo->getZoneUrl( $zone, $ext ) . '/' . $this->getUrlRel();
        if ( $suffix !== false ) {
            $path .= '/' . rawurlencode( $suffix );
        }
 
        return $path;
    }
 
    public function getThumbUrl( $suffix = false ) {
        return $this->getZoneUrl( 'thumb', $suffix );
    }
 
    public function getFilePageThumbUrl( $url ) {
        if ( $this->repo->isLocal() ) {
            return wfAppendQuery( $url, urlencode( $this->getTimestamp() ) );
        } else {
            return $url;
        }
    }
 
    public function getTranscodedUrl( $suffix = false ) {
        return $this->getZoneUrl( 'transcoded', $suffix );
    }
 
    public function getVirtualUrl( $suffix = false ) {
        $this->assertRepoDefined();
        $path = $this->repo->getVirtualUrl() . '/public/' . $this->getUrlRel();
        if ( $suffix !== false ) {
            $path .= '/' . rawurlencode( $suffix );
        }
 
        return $path;
    }
 
    public function getArchiveVirtualUrl( $suffix = false ) {
        $this->assertRepoDefined();
        $path = $this->repo->getVirtualUrl() . '/public/archive/' . $this->getHashPath();
        if ( $suffix === false ) {
            $path = rtrim( $path, '/' );
        } else {
            $path .= rawurlencode( $suffix );
        }
 
        return $path;
    }
 
    public function getThumbVirtualUrl( $suffix = false ) {
        $this->assertRepoDefined();
        $path = $this->repo->getVirtualUrl() . '/thumb/' . $this->getUrlRel();
        if ( $suffix !== false ) {
            $path .= '/' . rawurlencode( $suffix );
        }
 
        return $path;
    }
 
    protected function isHashed() {
        $this->assertRepoDefined();
 
        return (bool)$this->repo->getHashLevels();
    }
 
    protected function readOnlyError() {
        throw new LogicException( static::class . ': write operations are not supported' );
    }
 
    public function publish( $src, $flags = 0, array $options = [] ) {
        $this->readOnlyError();
    }
 
    public function formatMetadata( $context = false ) {
        $handler = $this->getHandler();
        return $handler ? $handler->formatMetadata( $this, $context ) : false;
    }
 
    public function isLocal() {
        return $this->repo && $this->repo->isLocal();
    }
 
    public function getRepoName() {
        return $this->repo ? $this->repo->getName() : 'unknown';
    }
 
    public function getRepo() {
        return $this->repo;
    }
 
    public function isOld() {
        return false;
    }
 
    public function isDeleted( $field ) {
        return false;
    }
 
    public function getVisibility() {
        return 0;
    }
 
    public function wasDeleted() {
        $title = $this->getTitle();
 
        return $title && $title->hasDeletedEdits();
    }
 
    public function move( $target ) {
        $this->readOnlyError();
    }
 
    public function deleteFile( $reason, UserIdentity $user, $suppress = false ) {
        $this->readOnlyError();
    }
 
    public function restore( $versions = [], $unsuppress = false ) {
        $this->readOnlyError();
    }
 
    public function isMultipage() {
        return $this->getHandler() && $this->handler->isMultiPage( $this );
    }
 
    public function pageCount() {
        if ( $this->pageCount === null ) {
            if ( $this->getHandler() && $this->handler->isMultiPage( $this ) ) {
                $this->pageCount = $this->handler->pageCount( $this );
            } else {
                $this->pageCount = false;
            }
        }
 
        return $this->pageCount;
    }
 
    public static function scaleHeight( $srcWidth, $srcHeight, $dstWidth ) {
        // Exact integer multiply followed by division
        if ( $srcWidth == 0 ) {
            return 0;
        } else {
            return (int)round( $srcHeight * $dstWidth / $srcWidth );
        }
    }
 
    public function getDescriptionUrl() {
        if ( $this->repo ) {
            return $this->repo->getDescriptionUrl( $this->getName() );
        } else {
            return false;
        }
    }
 
    public function getDescriptionText( ?Language $lang = null ) {
        global $wgLang;
 
        if ( !$this->repo || !$this->repo->fetchDescription ) {
            return false;
        }
 
        $lang ??= $wgLang;
 
        $renderUrl = $this->repo->getDescriptionRenderUrl( $this->getName(), $lang->getCode() );
        if ( $renderUrl ) {
            $cache = MediaWikiServices::getInstance()->getMainWANObjectCache();
            $key = $this->repo->getLocalCacheKey(
                'file-remote-description',
                $lang->getCode(),
                md5( $this->getName() )
            );
            $fname = __METHOD__;
 
            return $cache->getWithSetCallback(
                $key,
                $this->repo->descriptionCacheExpiry ?: $cache::TTL_UNCACHEABLE,
                static function ( $oldValue, &$ttl, array &$setOpts ) use ( $renderUrl, $fname ) {
                    wfDebug( "Fetching shared description from $renderUrl" );
                    $res = MediaWikiServices::getInstance()->getHttpRequestFactory()->
                        get( $renderUrl, [], $fname );
                    if ( !$res ) {
                        $ttl = WANObjectCache::TTL_UNCACHEABLE;
                    }
 
                    return $res;
                }
            );
        }
 
        return false;
    }
 
    public function getUploader( int $audience = self::FOR_PUBLIC, ?Authority $performer = null ): ?UserIdentity {
        return null;
    }
 
    public function getDescription( $audience = self::FOR_PUBLIC, ?Authority $performer = null ) {
        return null;
    }
 
    public function getTimestamp() {
        $this->assertRepoDefined();
 
        return $this->repo->getFileTimestamp( $this->getPath() );
    }
 
    public function getDescriptionTouched() {
        return false;
    }
 
    public function getSha1() {
        $this->assertRepoDefined();
 
        return $this->repo->getFileSha1( $this->getPath() );
    }
 
    public function getStorageKey() {
        $hash = $this->getSha1();
        if ( !$hash ) {
            return false;
        }
        $ext = $this->getExtension();
        $dotExt = $ext === '' ? '' : ".$ext";
 
        return $hash . $dotExt;
    }
 
    public function userCan( $field, Authority $performer ) {
        return true;
    }
 
    public function getContentHeaders() {
        $handler = $this->getHandler();
        if ( $handler ) {
            return $handler->getContentHeaders( $this->getMetadataArray() );
        }
 
        return [];
    }
 
    public function getLongDesc() {
        $handler = $this->getHandler();
        if ( $handler ) {
            return $handler->getLongDesc( $this );
        } else {
            return MediaHandler::getGeneralLongDesc( $this );
        }
    }
 
    public function getShortDesc() {
        $handler = $this->getHandler();
        if ( $handler ) {
            return $handler->getShortDesc( $this );
        } else {
            return MediaHandler::getGeneralShortDesc( $this );
        }
    }
 
    public function getDimensionsString() {
        $handler = $this->getHandler();
        if ( $handler ) {
            return $handler->getDimensionsString( $this );
        } else {
            return '';
        }
    }
 
    public function getRedirected(): ?string {
        return $this->redirected;
    }
 
    protected function getRedirectedTitle() {
        if ( $this->redirected !== null ) {
            if ( !$this->redirectTitle ) {
                $this->redirectTitle = Title::makeTitle( NS_FILE, $this->redirected );
            }
 
            return $this->redirectTitle;
        }
 
        return null;
    }
 
    public function redirectedFrom( string $from ) {
        $this->redirected = $from;
    }
 
    public function isMissing() {
        return false;
    }
 
    public function isCacheable() {
        return true;
    }
 
    protected function assertRepoDefined() {
        if ( !( $this->repo instanceof $this->repoClass ) ) {
            throw new LogicException( "A {$this->repoClass} object is not set for this File.\n" );
        }
    }
 
    protected function assertTitleDefined() {
        if ( !( $this->title instanceof Title ) ) {
            throw new LogicException( "A Title object is not set for this File.\n" );
        }
    }
 
    public function isExpensiveToThumbnail() {
        $handler = $this->getHandler();
        return $handler && $handler->isExpensiveToThumbnail( $this );
    }
 
    public function isTransformedLocally() {
        return true;
    }
}
 
class_alias( File::class, 'File' );