includes/media/DjVu.php

   1 <?php
   2 /**
   3  * Handler for DjVu images.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18  * http://www.gnu.org/copyleft/gpl.html
  19  *
  20  * @file
  21  * @ingroup Media
  22  */
  23
  24 /**
  25  * Handler for DjVu images
  26  *
  27  * @ingroup Media
  28  */
  29 class DjVuHandler extends ImageHandler {
  30         /**
  31          * @return bool
  32          */
  33         function isEnabled() {
  34                 global $wgDjvuRenderer, $wgDjvuDump, $wgDjvuToXML;
  35                 if ( !$wgDjvuRenderer || ( !$wgDjvuDump && !$wgDjvuToXML ) ) {
  36                         wfDebug( "DjVu is disabled, please set \$wgDjvuRenderer and \$wgDjvuDump\n" );
  37
  38                         return false;
  39                 } else {
  40                         return true;
  41                 }
  42         }
  43
  44         /**
  45          * @param File $file
  46          * @return bool
  47          */
  48         function mustRender( $file ) {
  49                 return true;
  50         }
  51
  52         /**
  53          * @param File $file
  54          * @return bool
  55          */
  56         function isMultiPage( $file ) {
  57                 return true;
  58         }
  59
  60         /**
  61          * @return array
  62          */
  63         function getParamMap() {
  64                 return array(
  65                         'img_width' => 'width',
  66                         'img_page' => 'page',
  67                 );
  68         }
  69
  70         /**
  71          * @param string $name
  72          * @param mixed $value
  73          * @return bool
  74          */
  75         function validateParam( $name, $value ) {
  76                 if ( in_array( $name, array( 'width', 'height', 'page' ) ) ) {
  77                         if ( $value <= 0 ) {
  78                                 return false;
  79                         } else {
  80                                 return true;
  81                         }
  82                 } else {
  83                         return false;
  84                 }
  85         }
  86
  87         /**
  88          * @param array $params
  89          * @return bool|string
  90          */
  91         function makeParamString( $params ) {
  92                 $page = isset( $params['page'] ) ? $params['page'] : 1;
  93                 if ( !isset( $params['width'] ) ) {
  94                         return false;
  95                 }
  96
  97                 return "page{$page}-{$params['width']}px";
  98         }
  99
 100         /**
 101          * @param string $str
 102          * @return array|bool
 103          */
 104         function parseParamString( $str ) {
 105                 $m = false;
 106                 if ( preg_match( '/^page(\d+)-(\d+)px$/', $str, $m ) ) {
 107                         return array( 'width' => $m[2], 'page' => $m[1] );
 108                 } else {
 109                         return false;
 110                 }
 111         }
 112
 113         /**
 114          * @param array $params
 115          * @return array
 116          */
 117         function getScriptParams( $params ) {
 118                 return array(
 119                         'width' => $params['width'],
 120                         'page' => $params['page'],
 121                 );
 122         }
 123
 124         /**
 125          * @param File $image
 126          * @param string $dstPath
 127          * @param string $dstUrl
 128          * @param array $params
 129          * @param int $flags
 130          * @return MediaTransformError|ThumbnailImage|TransformParameterError
 131          */
 132         function doTransform( $image, $dstPath, $dstUrl, $params, $flags = 0 ) {
 133                 global $wgDjvuRenderer, $wgDjvuPostProcessor;
 134
 135                 // Fetch XML and check it, to give a more informative error message than the one which
 136                 // normaliseParams will inevitably give.
 137                 $xml = $image->getMetadata();
 138                 if ( !$xml ) {
 139                         $width = isset( $params['width'] ) ? $params['width'] : 0;
 140                         $height = isset( $params['height'] ) ? $params['height'] : 0;
 141
 142                         return new MediaTransformError( 'thumbnail_error', $width, $height,
 143                                 wfMessage( 'djvu_no_xml' )->text() );
 144                 }
 145
 146                 if ( !$this->normaliseParams( $image, $params ) ) {
 147                         return new TransformParameterError( $params );
 148                 }
 149                 $width = $params['width'];
 150                 $height = $params['height'];
 151                 $page = $params['page'];
 152                 if ( $page > $this->pageCount( $image ) ) {
 153                         return new MediaTransformError(
 154                                 'thumbnail_error',
 155                                 $width,
 156                                 $height,
 157                                 wfMessage( 'djvu_page_error' )->text()
 158                         );
 159                 }
 160
 161                 if ( $flags & self::TRANSFORM_LATER ) {
 162                         $params = array(
 163                                 'width' => $width,
 164                                 'height' => $height,
 165                                 'page' => $page
 166                         );
 167
 168                         return new ThumbnailImage( $image, $dstUrl, $dstPath, $params );
 169                 }
 170
 171                 if ( !wfMkdirParents( dirname( $dstPath ), null, __METHOD__ ) ) {
 172                         return new MediaTransformError(
 173                                 'thumbnail_error',
 174                                 $width,
 175                                 $height,
 176                                 wfMessage( 'thumbnail_dest_directory' )->text()
 177                         );
 178                 }
 179
 180                 // Get local copy source for shell scripts
 181                 // Thumbnail extraction is very inefficient for large files.
 182                 // Provide a way to pool count limit the number of downloaders.
 183                 if ( $image->getSize() >= 1e7 ) { // 10MB
 184                         $work = new PoolCounterWorkViaCallback( 'GetLocalFileCopy', sha1( $image->getName() ),
 185                                 array(
 186                                         'doWork' => function() use ( $image ) {
 187                                                 return $image->getLocalRefPath();
 188                                         }
 189                                 )
 190                         );
 191                         $srcPath = $work->execute();
 192                 } else {
 193                         $srcPath = $image->getLocalRefPath();
 194                 }
 195
 196                 if ( $srcPath === false ) { // Failed to get local copy
 197                         wfDebugLog( 'thumbnail',
 198                                 sprintf( 'Thumbnail failed on %s: could not get local copy of "%s"',
 199                                         wfHostname(), $image->getName() ) );
 200
 201                         return new MediaTransformError( 'thumbnail_error',
 202                                 $params['width'], $params['height'],
 203                                 wfMessage( 'filemissing' )->text()
 204                         );
 205                 }
 206
 207                 # Use a subshell (brackets) to aggregate stderr from both pipeline commands
 208                 # before redirecting it to the overall stdout. This works in both Linux and Windows XP.
 209                 $cmd = '(' . wfEscapeShellArg(
 210                         $wgDjvuRenderer,
 211                         "-format=ppm",
 212                         "-page={$page}",
 213                         "-size={$params['physicalWidth']}x{$params['physicalHeight']}",
 214                         $srcPath );
 215                 if ( $wgDjvuPostProcessor ) {
 216                         $cmd .= " | {$wgDjvuPostProcessor}";
 217                 }
 218                 $cmd .= ' > ' . wfEscapeShellArg( $dstPath ) . ') 2>&1';
 219                 wfProfileIn( 'ddjvu' );
 220                 wfDebug( __METHOD__ . ": $cmd\n" );
 221                 $retval = '';
 222                 $err = wfShellExec( $cmd, $retval );
 223                 wfProfileOut( 'ddjvu' );
 224
 225                 $removed = $this->removeBadFile( $dstPath, $retval );
 226                 if ( $retval != 0 || $removed ) {
 227                         $this->logErrorForExternalProcess( $retval, $err, $cmd );
 228                         return new MediaTransformError( 'thumbnail_error', $width, $height, $err );
 229                 } else {
 230                         $params = array(
 231                                 'width' => $width,
 232                                 'height' => $height,
 233                                 'page' => $page
 234                         );
 235
 236                         return new ThumbnailImage( $image, $dstUrl, $dstPath, $params );
 237                 }
 238         }
 239
 240         /**
 241          * Cache an instance of DjVuImage in an Image object, return that instance
 242          *
 243          * @param File $image
 244          * @param string $path
 245          * @return DjVuImage
 246          */
 247         function getDjVuImage( $image, $path ) {
 248                 if ( !$image ) {
 249                         $deja = new DjVuImage( $path );
 250                 } elseif ( !isset( $image->dejaImage ) ) {
 251                         $deja = $image->dejaImage = new DjVuImage( $path );
 252                 } else {
 253                         $deja = $image->dejaImage;
 254                 }
 255
 256                 return $deja;
 257         }
 258
 259         /**
 260          * Get metadata, unserializing it if neccessary.
 261          *
 262          * @param File $file The DjVu file in question
 263          * @return String XML metadata as a string.
 264          */
 265         private function getUnserializedMetadata( File $file ) {
 266                 $metadata = $file->getMetadata();
 267                 if ( substr( $metadata, 0, 3 ) === '<?xml' ) {
 268                         // Old style. Not serialized but instead just a raw string of XML.
 269                         return $metadata;
 270                 }
 271
 272                 wfSuppressWarnings();
 273                 $unser = unserialize( $metadata );
 274                 wfRestoreWarnings();
 275                 if ( is_array( $unser ) ) {
 276                         return $unser['xml'];
 277                 }
 278
 279                 // unserialize failed. Guess it wasn't really serialized after all,
 280                 return $metadata;
 281         }
 282
 283         /**
 284          * Cache a document tree for the DjVu XML metadata
 285          * @param File $image
 286          * @param bool $gettext DOCUMENT (Default: false)
 287          * @return bool|SimpleXMLElement
 288          */
 289         function getMetaTree( $image, $gettext = false ) {
 290                 if ( $gettext && isset( $image->djvuTextTree ) ) {
 291                         return $image->djvuTextTree;
 292                 }
 293                 if ( !$gettext && isset( $image->dejaMetaTree ) ) {
 294                         return $image->dejaMetaTree;
 295                 }
 296
 297                 $metadata = $this->getUnserializedMetadata( $image );
 298                 if ( !$this->isMetadataValid( $image, $metadata ) ) {
 299                         wfDebug( "DjVu XML metadata is invalid or missing, should have been fixed in upgradeRow\n" );
 300
 301                         return false;
 302                 }
 303                 wfProfileIn( __METHOD__ );
 304
 305                 wfSuppressWarnings();
 306                 try {
 307                         // Set to false rather than null to avoid further attempts
 308                         $image->dejaMetaTree = false;
 309                         $image->djvuTextTree = false;
 310                         $tree = new SimpleXMLElement( $metadata );
 311                         if ( $tree->getName() == 'mw-djvu' ) {
 312                                 /** @var SimpleXMLElement $b */
 313                                 foreach ( $tree->children() as $b ) {
 314                                         if ( $b->getName() == 'DjVuTxt' ) {
 315                                                 // @todo File::djvuTextTree and File::dejaMetaTree are declared
 316                                                 // dynamically. Add a public File::$data to facilitate this?
 317                                                 $image->djvuTextTree = $b;
 318                                         } elseif ( $b->getName() == 'DjVuXML' ) {
 319                                                 $image->dejaMetaTree = $b;
 320                                         }
 321                                 }
 322                         } else {
 323                                 $image->dejaMetaTree = $tree;
 324                         }
 325                 } catch ( Exception $e ) {
 326                         wfDebug( "Bogus multipage XML metadata on '{$image->getName()}'\n" );
 327                 }
 328                 wfRestoreWarnings();
 329                 wfProfileOut( __METHOD__ );
 330                 if ( $gettext ) {
 331                         return $image->djvuTextTree;
 332                 } else {
 333                         return $image->dejaMetaTree;
 334                 }
 335         }
 336
 337         /**
 338          * @param File $image
 339          * @param string $path
 340          * @return bool|array False on failure
 341          */
 342         function getImageSize( $image, $path ) {
 343                 return $this->getDjVuImage( $image, $path )->getImageSize();
 344         }
 345
 346         function getThumbType( $ext, $mime, $params = null ) {
 347                 global $wgDjvuOutputExtension;
 348                 static $mime;
 349                 if ( !isset( $mime ) ) {
 350                         $magic = MimeMagic::singleton();
 351                         $mime = $magic->guessTypesForExtension( $wgDjvuOutputExtension );
 352                 }
 353
 354                 return array( $wgDjvuOutputExtension, $mime );
 355         }
 356
 357         function getMetadata( $image, $path ) {
 358                 wfDebug( "Getting DjVu metadata for $path\n" );
 359
 360                 $xml = $this->getDjVuImage( $image, $path )->retrieveMetaData();
 361                 if ( $xml === false ) {
 362                         return false;
 363                 } else {
 364                         return serialize( array( 'xml' => $xml ) );
 365                 }
 366         }
 367
 368         function getMetadataType( $image ) {
 369                 return 'djvuxml';
 370         }
 371
 372         function isMetadataValid( $image, $metadata ) {
 373                 return !empty( $metadata ) && $metadata != serialize( array() );
 374         }
 375
 376         function pageCount( $image ) {
 377                 $tree = $this->getMetaTree( $image );
 378                 if ( !$tree ) {
 379                         return false;
 380                 }
 381
 382                 return count( $tree->xpath( '//OBJECT' ) );
 383         }
 384
 385         function getPageDimensions( $image, $page ) {
 386                 $tree = $this->getMetaTree( $image );
 387                 if ( !$tree ) {
 388                         return false;
 389                 }
 390
 391                 $o = $tree->BODY[0]->OBJECT[$page - 1];
 392                 if ( $o ) {
 393                         return array(
 394                                 'width' => intval( $o['width'] ),
 395                                 'height' => intval( $o['height'] )
 396                         );
 397                 } else {
 398                         return false;
 399                 }
 400         }
 401
 402         /**
 403          * @param File $image
 404          * @param int $page Page number to get information for
 405          * @return bool|string Page text or false when no text found.
 406          */
 407         function getPageText( $image, $page ) {
 408                 $tree = $this->getMetaTree( $image, true );
 409                 if ( !$tree ) {
 410                         return false;
 411                 }
 412
 413                 $o = $tree->BODY[0]->PAGE[$page - 1];
 414                 if ( $o ) {
 415                         $txt = $o['value'];
 416
 417                         return $txt;
 418                 } else {
 419                         return false;
 420                 }
 421         }
 422 }