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

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