MediaHandler.php

Go to the documentation of this file.

<?php
abstract class MediaHandler {
    const TRANSFORM_LATER = 1;
    const METADATA_GOOD = true;
    const METADATA_BAD = false;
    const METADATA_COMPATIBLE = 2; // for old but backwards compatible.
    const MAX_ERR_LOG_SIZE = 65535;
 
    protected static $handlers = array();
 
    static function getHandler( $type ) {
        global $wgMediaHandlers;
        if ( !isset( $wgMediaHandlers[$type] ) ) {
            wfDebug( __METHOD__ . ": no handler found for $type.\n" );
 
            return false;
        }
        $class = $wgMediaHandlers[$type];
        if ( !isset( self::$handlers[$class] ) ) {
            self::$handlers[$class] = new $class;
            if ( !self::$handlers[$class]->isEnabled() ) {
                self::$handlers[$class] = false;
            }
        }
 
        return self::$handlers[$class];
    }
 
    abstract function getParamMap();
 
    abstract function validateParam( $name, $value );
 
    abstract function makeParamString( $params );
 
    abstract function parseParamString( $str );
 
    abstract function normaliseParams( $image, &$params );
 
    abstract function getImageSize( $image, $path );
 
    function getMetadata( $image, $path ) {
        return '';
    }
 
    static function getMetadataVersion() {
        $version = array( '2' ); // core metadata version
        wfRunHooks( 'GetMetadataVersion', array( &$version ) );
 
        return implode( ';', $version );
    }
 
    function convertMetadataVersion( $metadata, $version = 1 ) {
        if ( !is_array( $metadata ) ) {
 
            //unserialize to keep return parameter consistent.
            wfSuppressWarnings();
            $ret = unserialize( $metadata );
            wfRestoreWarnings();
 
            return $ret;
        }
 
        return $metadata;
    }
 
    function getMetadataType( $image ) {
        return false;
    }
 
    function isMetadataValid( $image, $metadata ) {
        return self::METADATA_GOOD;
    }
 
    public function getCommonMetaArray( File $file ) {
        return false;
    }
 
    function getScriptedTransform( $image, $script, $params ) {
        return false;
    }
 
    final function getTransform( $image, $dstPath, $dstUrl, $params ) {
        return $this->doTransform( $image, $dstPath, $dstUrl, $params, self::TRANSFORM_LATER );
    }
 
    abstract function doTransform( $image, $dstPath, $dstUrl, $params, $flags = 0 );
 
    function getThumbType( $ext, $mime, $params = null ) {
        $magic = MimeMagic::singleton();
        if ( !$ext || $magic->isMatchingExtension( $ext, $mime ) === false ) {
            // The extension is not valid for this mime type and we do
            // recognize the mime type
            $extensions = $magic->getExtensionsForType( $mime );
            if ( $extensions ) {
                return array( strtok( $extensions, ' ' ), $mime );
            }
        }
 
        // The extension is correct (true) or the mime type is unknown to
        // MediaWiki (null)
        return array( $ext, $mime );
    }
 
    public function getStreamHeaders( $metadata ) {
        return array();
    }
 
    function canRender( $file ) {
        return true;
    }
 
    function mustRender( $file ) {
        return false;
    }
 
    function isMultiPage( $file ) {
        return false;
    }
 
    function pageCount( $file ) {
        return false;
    }
 
    function isVectorized( $file ) {
        return false;
    }
 
    function isAnimatedImage( $file ) {
        return false;
    }
 
    function canAnimateThumbnail( $file ) {
        return true;
    }
 
    function isEnabled() {
        return true;
    }
 
    function getPageDimensions( $image, $page ) {
        $gis = $this->getImageSize( $image, $image->getLocalRefPath() );
        if ( $gis ) {
            return array(
                'width' => $gis[0],
                'height' => $gis[1]
            );
        } else {
            return false;
        }
    }
 
    function getPageText( $image, $page ) {
        return false;
    }
 
    public function getEntireText( File $file ) {
        $numPages = $file->pageCount();
        if ( !$numPages ) {
            // Not a multipage document
            return $this->getPageText( $file, 1 );
        }
        $document = '';
        for ( $i = 1; $i <= $numPages; $i++ ) {
            $curPage = $this->getPageText( $file, $i );
            if ( is_string( $curPage ) ) {
                $document .= $curPage . "\n";
            }
        }
        if ( $document !== '' ) {
            return $document;
        }
        return false;
    }
 
    function formatMetadata( $image ) {
        return false;
    }
 
    function formatMetadataHelper( $metadataArray ) {
        $result = array(
            'visible' => array(),
            'collapsed' => array()
        );
 
        $formatted = FormatMetadata::getFormattedData( $metadataArray );
        // Sort fields into visible and collapsed
        $visibleFields = $this->visibleMetadataFields();
        foreach ( $formatted as $name => $value ) {
            $tag = strtolower( $name );
            self::addMeta( $result,
                in_array( $tag, $visibleFields ) ? 'visible' : 'collapsed',
                'exif',
                $tag,
                $value
            );
        }
 
        return $result;
    }
 
    protected function visibleMetadataFields() {
        return FormatMetadata::getVisibleFields();
    }
 
    protected static function addMeta( &$array, $visibility, $type, $id, $value, $param = false ) {
        $msg = wfMessage( "$type-$id", $param );
        if ( $msg->exists() ) {
            $name = $msg->text();
        } else {
            // This is for future compatibility when using instant commons.
            // So as to not display as ugly a name if a new metadata
            // property is defined that we don't know about
            // (not a major issue since such a property would be collapsed
            // by default).
            wfDebug( __METHOD__ . ' Unknown metadata name: ' . $id . "\n" );
            $name = wfEscapeWikiText( $id );
        }
        $array[$visibility][] = array(
            'id' => "$type-$id",
            'name' => $name,
            'value' => $value
        );
    }
 
    function getShortDesc( $file ) {
        global $wgLang;
 
        return htmlspecialchars( $wgLang->formatSize( $file->getSize() ) );
    }
 
    function getLongDesc( $file ) {
        global $wgLang;
 
        return wfMessage( 'file-info', htmlspecialchars( $wgLang->formatSize( $file->getSize() ) ),
            $file->getMimeType() )->parse();
    }
 
    static function getGeneralShortDesc( $file ) {
        global $wgLang;
 
        return $wgLang->formatSize( $file->getSize() );
    }
 
    static function getGeneralLongDesc( $file ) {
        global $wgLang;
 
        return wfMessage( 'file-info', $wgLang->formatSize( $file->getSize() ),
            $file->getMimeType() )->parse();
    }
 
    public static function fitBoxWidth( $boxWidth, $boxHeight, $maxHeight ) {
        $idealWidth = $boxWidth * $maxHeight / $boxHeight;
        $roundedUp = ceil( $idealWidth );
        if ( round( $roundedUp * $boxHeight / $boxWidth ) > $maxHeight ) {
            return floor( $idealWidth );
        } else {
            return $roundedUp;
        }
    }
 
    function getDimensionsString( $file ) {
        return '';
    }
 
    function parserTransformHook( $parser, $file ) {
    }
 
    function verifyUpload( $fileName ) {
        return Status::newGood();
    }
 
    function removeBadFile( $dstPath, $retval = 0 ) {
        if ( file_exists( $dstPath ) ) {
            $thumbstat = stat( $dstPath );
            if ( $thumbstat['size'] == 0 || $retval != 0 ) {
                $result = unlink( $dstPath );
 
                if ( $result ) {
                    wfDebugLog( 'thumbnail',
                        sprintf( 'Removing bad %d-byte thumbnail "%s". unlink() succeeded',
                            $thumbstat['size'], $dstPath ) );
                } else {
                    wfDebugLog( 'thumbnail',
                        sprintf( 'Removing bad %d-byte thumbnail "%s". unlink() failed',
                            $thumbstat['size'], $dstPath ) );
                }
 
                return true;
            }
        }
 
        return false;
    }
 
    public function filterThumbnailPurgeList( &$files, $options ) {
        // Do nothing
    }
 
    /*
     * True if the handler can rotate the media
     * @since 1.21
     * @return bool
     */
    public static function canRotate() {
        return false;
    }
 
    public function getRotation( $file ) {
        return 0;
    }
 
    protected function logErrorForExternalProcess( $retval, $err, $cmd ) {
        # Keep error output limited (bug 57985)
        $errMessage = trim( substr( $err, 0, self::MAX_ERR_LOG_SIZE ) );
 
        wfDebugLog( 'thumbnail',
            sprintf( 'thumbnail failed on %s: error %d "%s" from "%s"',
                    wfHostname(), $retval, $errMessage, $cmd ) );
    }
 
    public function getAvailableLanguages( File $file ) {
        return array();
    }
 
    public function getDefaultRenderLanguage( File $file ) {
        return null;
    }
 
    public function getLength( $file ) {
        return 0.0;
    }
}