vendor/contao/image/src/Resizer.php line 77

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. /*
  6.  * This file is part of Contao.
  7.  *
  8.  * (c) Leo Feyer
  9.  *
  10.  * @license LGPL-3.0-or-later
  11.  */
  13. namespace Contao\Image;
  15. use Contao\Image\Exception\InvalidArgumentException;
  16. use Contao\Image\Metadata\ImageMetadata;
  17. use Contao\Image\Metadata\MetadataReaderWriter;
  18. use Contao\ImagineSvg\Image as SvgImage;
  19. use Imagine\Exception\InvalidArgumentException as ImagineInvalidArgumentException;
  20. use Imagine\Exception\RuntimeException as ImagineRuntimeException;
  21. use Imagine\Filter\Basic\Autorotate;
  22. use Imagine\Gd\Image as GdImage;
  23. use Imagine\Image\ImageInterface as ImagineImageInterface;
  24. use Imagine\Image\Palette\RGB;
  25. use Symfony\Component\Filesystem\Filesystem;
  26. use Symfony\Component\Filesystem\Path;
  28. /**
  29.  * @method __construct(string $cacheDir, string $secret, ResizeCalculator $calculator = null, Filesystem $filesystem = null, MetadataReaderWriter $metadataReaderWriter = null)
  30.  */
  31. class Resizer implements ResizerInterface
  32. {
  33.     /**
  34.      * @var Filesystem
  35.      *
  36.      * @internal
  37.      */
  38.     protected $filesystem;
  40.     /**
  41.      * @var string
  42.      *
  43.      * @internal
  44.      */
  45.     protected $cacheDir;
  47.     /**
  48.      * @var ResizeCalculator
  49.      */
  50.     private $calculator;
  52.     /**
  53.      * @var MetadataReaderWriter
  54.      */
  55.     private $metadataReaderWriter;
  57.     /**
  58.      * @var string|null
  59.      */
  60.     private $secret;
  62.     /**
  63.      * @param string                    $cacheDir
  64.      * @param string                    $secret
  65.      * @param ResizeCalculator|null     $calculator
  66.      * @param Filesystem|null           $filesystem
  67.      * @param MetadataReaderWriter|null $metadataReaderWriter
  68.      */
  69.     public function __construct(string $cacheDir/*, string $secret, ResizeCalculator $calculator = null, Filesystem $filesystem = null, MetadataReaderWriter $metadataReaderWriter = null*/)
  70.     {
  71.         if (\func_num_args() > 1 && \is_string(func_get_arg(1))) {
  72.             $secret = func_get_arg(1);
  73.             $calculator = \func_num_args() > 2 ? func_get_arg(2) : null;
  74.             $filesystem = \func_num_args() > 3 ? func_get_arg(3) : null;
  75.             $metadataReaderWriter = \func_num_args() > 4 ? func_get_arg(4) : null;
  76.         } else {
  77.             trigger_deprecation('contao/image', '1.2', 'Not passing a secret to "%s()" has been deprecated and will no longer work in version 2.0.', __METHOD__);
  78.             $secret = null;
  79.             $calculator = \func_num_args() > 1 ? func_get_arg(1) : null;
  80.             $filesystem = \func_num_args() > 2 ? func_get_arg(2) : null;
  81.             $metadataReaderWriter = \func_num_args() > 3 ? func_get_arg(3) : null;
  82.         }
  84.         if (null === $calculator) {
  85.             $calculator = new ResizeCalculator();
  86.         }
  88.         if (null === $filesystem) {
  89.             $filesystem = new Filesystem();
  90.         }
  92.         if (null === $metadataReaderWriter) {
  93.             $metadataReaderWriter = new MetadataReaderWriter();
  94.         }
  96.         if (!$calculator instanceof ResizeCalculator) {
  97.             $type = \is_object($calculator) ? \get_class($calculator) : \gettype($calculator);
  99.             throw new \TypeError(sprintf('%s(): Argument #3 ($calculator) must be of type ResizeCalculator|null, %s given', __METHOD__, $type));
  100.         }
  102.         if (!$filesystem instanceof Filesystem) {
  103.             $type = \is_object($filesystem) ? \get_class($filesystem) : \gettype($filesystem);
  105.             throw new \TypeError(sprintf('%s(): Argument #4 ($filesystem) must be of type ResizeCalculator|null, %s given', __METHOD__, $type));
  106.         }
  108.         if (!$metadataReaderWriter instanceof MetadataReaderWriter) {
  109.             $type = \is_object($metadataReaderWriter) ? \get_class($metadataReaderWriter) : \gettype($metadataReaderWriter);
  111.             throw new \TypeError(sprintf('%s(): Argument #5 ($metadataReaderWriter) must be of type MetadataReaderWriter|null, %s given', __METHOD__, $type));
  112.         }
  114.         if ('' === $secret) {
  115.             throw new InvalidArgumentException('$secret must not be empty');
  116.         }
  118.         $this->cacheDir = $cacheDir;
  119.         $this->calculator = $calculator;
  120.         $this->filesystem = $filesystem;
  121.         $this->metadataReaderWriter = $metadataReaderWriter;
  122.         $this->secret = $secret;
  123.     }
  125.     /**
  126.      * {@inheritdoc}
  127.      */
  128.     public function resize(ImageInterface $image, ResizeConfiguration $config, ResizeOptions $options): ImageInterface
  129.     {
  130.         if (
  131.             $image->getDimensions()->isUndefined()
  132.             || ($config->isEmpty() && $this->canSkipResize($image, $options))
  133.         ) {
  134.             $image = $this->createImage($image, $image->getPath());
  135.         } else {
  136.             $image = $this->processResize($image, $config, $options);
  137.         }
  139.         if (null !== $options->getTargetPath()) {
  140.             $this->filesystem->copy($image->getPath(), $options->getTargetPath(), true);
  141.             $image = $this->createImage($image, $options->getTargetPath());
  142.         }
  144.         return $image;
  145.     }
  147.     /**
  148.      * Executes the resize operation via Imagine.
  149.      *
  150.      * @internal Do not call this method in your code; it will be made private in a future version
  151.      */
  152.     protected function executeResize(ImageInterface $image, ResizeCoordinates $coordinates, string $path, ResizeOptions $options): ImageInterface
  153.     {
  154.         $dir = \dirname($path);
  156.         if (!$this->filesystem->exists($dir)) {
  157.             $this->filesystem->mkdir($dir);
  158.         }
  160.         $imagineOptions = $options->getImagineOptions();
  161.         $imagineImage = $image->getImagine()->open($image->getPath());
  163.         if (ImageDimensions::ORIENTATION_NORMAL !== $image->getDimensions()->getOrientation()) {
  164.             (new Autorotate())->apply($imagineImage);
  165.         }
  167.         if ($imagineImage instanceof SvgImage || $imagineImage instanceof GdImage) {
  168.             // Backwards compatibility with imagine/imagine <= 1.2.4 and contao/imagine-svg <= 1.0.3
  169.             $filter = ImagineImageInterface::FILTER_UNDEFINED;
  170.         } else {
  171.             $filter = $imagineOptions['resampling-filter'] ?? ImagineImageInterface::FILTER_LANCZOS;
  172.         }
  174.         $imagineImage
  175.             ->resize($coordinates->getSize(), $filter)
  176.             ->crop($coordinates->getCropStart(), $coordinates->getCropSize())
  177.             ->usePalette(new RGB())
  178.             ->strip()
  179.         ;
  181.         if (isset($imagineOptions['interlace'])) {
  182.             try {
  183.                 $imagineImage->interlace($imagineOptions['interlace']);
  184.             } catch (ImagineInvalidArgumentException|ImagineRuntimeException $e) {
  185.                 // Ignore failed interlacing
  186.             }
  187.         }
  189.         if (!isset($imagineOptions['format'])) {
  190.             $imagineOptions['format'] = strtolower(pathinfo($path, PATHINFO_EXTENSION));
  191.         }
  193.         // Fix bug with undefined index notice in Imagine
  194.         if ('webp' === $imagineOptions['format'] && !isset($imagineOptions['webp_quality'])) {
  195.             $imagineOptions['webp_quality'] = 80;
  196.         }
  198.         $tmpPath1 = $this->filesystem->tempnam($dir, 'img');
  199.         $tmpPath2 = $this->filesystem->tempnam($dir, 'img');
  200.         $this->filesystem->chmod([$tmpPath1, $tmpPath2], 0666, umask());
  202.         if ($options->getPreserveCopyrightMetadata() && ($metadata = $this->getMetadata($image))->getAll()) {
  203.             $imagineImage->save($tmpPath1, $imagineOptions);
  205.             try {
  206.                 $this->metadataReaderWriter->applyCopyrightToFile($tmpPath1, $tmpPath2, $metadata, $options->getPreserveCopyrightMetadata());
  207.             } catch (\Throwable $exception) {
  208.                 $this->filesystem->rename($tmpPath1, $tmpPath2, true);
  209.             }
  210.         } else {
  211.             $imagineImage->save($tmpPath2, $imagineOptions);
  212.         }
  214.         $this->filesystem->remove($tmpPath1);
  216.         // Atomic write operation
  217.         $this->filesystem->rename($tmpPath2, $path, true);
  219.         return $this->createImage($image, $path);
  220.     }
  222.     /**
  223.      * Creates a new image instance for the specified path.
  224.      *
  225.      * @internal Do not call this method in your code; it will be made private in a future version
  226.      */
  227.     protected function createImage(ImageInterface $image, string $path): ImageInterface
  228.     {
  229.         return new Image($path, $image->getImagine(), $this->filesystem);
  230.     }
  232.     /**
  233.      * Processes the resize and executes it if not already cached.
  234.      *
  235.      * @internal
  236.      */
  237.     protected function processResize(ImageInterface $image, ResizeConfiguration $config, ResizeOptions $options): ImageInterface
  238.     {
  239.         $coordinates = $this->calculator->calculate($config, $image->getDimensions(), $image->getImportantPart());
  241.         // Skip resizing if it would have no effect
  242.         if (
  243.             $this->canSkipResize($image, $options)
  244.             && !$image->getDimensions()->isRelative()
  245.             && $coordinates->isEqualTo($image->getDimensions()->getSize())
  246.         ) {
  247.             return $this->createImage($image, $image->getPath());
  248.         }
  250.         $cachePath = Path::join($this->cacheDir, $this->createCachePath($image->getPath(), $coordinates, $options, false));
  252.         if (!$options->getBypassCache()) {
  253.             if ($this->filesystem->exists($cachePath)) {
  254.                 return $this->createImage($image, $cachePath);
  255.             }
  257.             $legacyCachePath = Path::join($this->cacheDir, $this->createCachePath($image->getPath(), $coordinates, $options, true));
  259.             if ($this->filesystem->exists($legacyCachePath)) {
  260.                 trigger_deprecation('contao/image', '1.2', 'Reusing old cached images like "%s" from version 1.1 has been deprecated and will no longer work in version 2.0. Clear the image cache directory "%s" and regenerate all images to get rid of this message.', $legacyCachePath, $this->cacheDir);
  262.                 return $this->createImage($image, $legacyCachePath);
  263.             }
  264.         }
  266.         return $this->executeResize($image, $coordinates, $cachePath, $options);
  267.     }
  269.     private function canSkipResize(ImageInterface $image, ResizeOptions $options): bool
  270.     {
  271.         if (!$options->getSkipIfDimensionsMatch()) {
  272.             return false;
  273.         }
  275.         if (ImageDimensions::ORIENTATION_NORMAL !== $image->getDimensions()->getOrientation()) {
  276.             return false;
  277.         }
  279.         if (
  280.             isset($options->getImagineOptions()['format'])
  281.             && $options->getImagineOptions()['format'] !== strtolower(pathinfo($image->getPath(), PATHINFO_EXTENSION))
  282.         ) {
  283.             return false;
  284.         }
  286.         return true;
  287.     }
  289.     /**
  290.      * Returns the relative target cache path.
  291.      */
  292.     private function createCachePath(string $path, ResizeCoordinates $coordinates, ResizeOptions $options, bool $useLegacyHash): string
  293.     {
  294.         $imagineOptions = $options->getImagineOptions();
  295.         ksort($imagineOptions);
  297.         $hashData = array_merge(
  298.             [
  299.                 Path::makeRelative($path, $this->cacheDir),
  300.                 filemtime($path),
  301.                 $coordinates->getHash(),
  302.             ],
  303.             array_keys($imagineOptions),
  304.             array_map(
  305.                 static function ($value) {
  306.                     return \is_array($value) ? implode(',', $value) : $value;
  307.                 },
  308.                 array_values($imagineOptions)
  309.             )
  310.         );
  312.         $preserveMeta = $options->getPreserveCopyrightMetadata();
  314.         if ($preserveMeta !== (new ResizeOptions())->getPreserveCopyrightMetadata()) {
  315.             ksort($preserveMeta, SORT_STRING);
  316.             $hashData[] = json_encode($preserveMeta);
  317.         }
  319.         if ($useLegacyHash || null === $this->secret) {
  320.             $hash = substr(md5(implode('|', $hashData)), 0, 9);
  321.         } else {
  322.             $hash = hash_hmac('sha256', implode('|', $hashData), $this->secret, true);
  323.             $hash = substr($this->encodeBase32($hash), 0, 16);
  324.         }
  326.         $pathinfo = pathinfo($path);
  327.         $extension = $options->getImagineOptions()['format'] ?? strtolower($pathinfo['extension']);
  329.         return Path::join($hash[0], $pathinfo['filename'].'-'.substr($hash, 1).'.'.$extension);
  330.     }
  332.     private function getMetadata(ImageInterface $image): ImageMetadata
  333.     {
  334.         try {
  335.             return $this->metadataReaderWriter->parse($image->getPath());
  336.         } catch (\Throwable $exception) {
  337.             return new ImageMetadata([]);
  338.         }
  339.     }
  341.     /**
  342.      * Encode a string with Crockford’s Base32 in lowercase
  343.      * (0123456789abcdefghjkmnpqrstvwxyz).
  344.      */
  345.     private function encodeBase32(string $bytes): string
  346.     {
  347.         $result = [];
  349.         foreach (str_split($bytes, 5) as $chunk) {
  350.             $result[] = substr(
  351.                 str_pad(
  352.                     strtr(
  353.                         base_convert(bin2hex(str_pad($chunk, 5, "\0")), 16, 32),
  354.                         'ijklmnopqrstuv',
  355.                         'jkmnpqrstvwxyz' // Crockford's Base32
  356.                     ),
  357.                     8,
  358.                     '0',
  359.                     STR_PAD_LEFT
  360.                 ),
  361.                 0,
  362.                 (int) ceil(\strlen($chunk) * 8 / 5)
  363.             );
  364.         }
  366.         return implode('', $result);
  367.     }
  368. }