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.
    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;
    }

    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;
    }

    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;
    }

    function visibleMetadataFields() {
        $fields = array();
        $lines = explode( "\n", wfMessage( 'metadata-fields' )->inContentLanguage()->text() );
        foreach ( $lines as $line ) {
            $matches = array();
            if ( preg_match( '/^\\*\s*(.*?)\s*$/', $line, $matches ) ) {
                $fields[] = $matches[1];
            }
        }
        $fields = array_map( 'strtolower', $fields );
        return $fields;
    }

    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;
    }

}