Deprecated: Constant E_STRICT is deprecated in /home/pastorz/old-espace-client/vendor/symfony/error-handler/ErrorHandler.php on line 58

Deprecated: Constant E_STRICT is deprecated in /home/pastorz/old-espace-client/vendor/symfony/error-handler/ErrorHandler.php on line 76
Symfony Profiler

vendor/liip/imagine-bundle/Imagine/Filter/PostProcessor/CwebpPostProcessor.php line 96

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the `liip/LiipImagineBundle` project.
  5.  *
  6.  * (c) https://github.com/liip/LiipImagineBundle/graphs/contributors
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE.md
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Liip\ImagineBundle\Imagine\Filter\PostProcessor;
  14. use Liip\ImagineBundle\Binary\BinaryInterface;
  15. use Liip\ImagineBundle\Model\Binary;
  16. use Symfony\Component\OptionsResolver\OptionsResolver;
  17. use Symfony\Component\Process\Exception\ProcessFailedException;
  19. class CwebpPostProcessor extends AbstractPostProcessor
  20. {
  21.     /**
  22.      * Specify the compression factor for RGB channels between **0** and **100**. The default is **75**.
  23.      *
  24.      * In case of lossy compression , a small factor produces a smaller file with lower quality. Best quality is
  25.      * achieved by using a value of **100**.
  26.      *
  27.      * In case of lossless compression (specified by the **-lossless** option), a small factor enables faster
  28.      * compression speed, but produces a larger file. Maximum compression is achieved by using a value of **100**.
  29.      *
  30.      * @var int
  31.      */
  32.     protected $q;
  34.     /**
  35.      * Specify the compression factor for alpha compression between **0** and **100**. Lossless compression of alpha is
  36.      * achieved using a value of **100**, while the lower values result in a lossy compression.
  37.      *
  38.      * @var int
  39.      */
  40.     protected $alphaQ;
  42.     /**
  43.      * Specify the compression method to use. This parameter controls the trade off between encoding speed and the
  44.      * compressed file size and quality. Possible values range from **0** to **6**. When higher values are used, the
  45.      * encoder will spend more time inspecting additional encoding possibilities and decide on the quality gain. Lower
  46.      * value can result in faster processing time at the expense of larger file size and lower compression quality.
  47.      *
  48.      * @var int
  49.      */
  50.     protected $m;
  52.     /**
  53.      * Specify the predictive filtering method for the alpha plane. One of **none**, **fast** or **best**, in
  54.      * increasing complexity and slowness order. Internally, alpha filtering is performed using four possible
  55.      * predictions (none, horizontal, vertical, gradient). The **best** mode will try each mode in turn and pick the
  56.      * one which gives the smaller size. The **fast** mode will just try to form an a priori guess without testing all
  57.      * modes.
  58.      *
  59.      * @var string
  60.      */
  61.     protected $alphaFilter;
  63.     /**
  64.      * Specify the algorithm used for alpha compression: **0** or **1**. Algorithm **0** denotes no compression, **1**
  65.      * uses WebP lossless format for compression.
  66.      *
  67.      * @var int
  68.      */
  69.     protected $alphaMethod;
  71.     /**
  72.      * Preserve RGB values in transparent area. The default is off, to help compressibility.
  73.      *
  74.      * @var bool
  75.      */
  76.     protected $exact;
  78.     /**
  79.      * An array of metadata to copy from the input to the output if present. Valid values: **all**, **none**, **exif**,
  80.      * **icc**, **xmp**.
  81.      *
  82.      * Note that each input format may not support all combinations.
  83.      *
  84.      * @var string[]
  85.      */
  86.     protected $metadata;
  88.     /**
  89.      * @var OptionsResolver
  90.      */
  91.     private $resolver;
  93.     /**
  94.      * @param string[] $metadata
  95.      */
  96.     public function __construct(
  97.         string $executablePath = '/usr/bin/cwebp',
  98.         string $temporaryRootPath = null,
  99.         int $q = null,
  100.         int $alphaQ = null,
  101.         int $m = null,
  102.         string $alphaFilter = null,
  103.         int $alphaMethod = null,
  104.         bool $exact = null,
  105.         array $metadata = []
  106.     ) {
  107.         parent::__construct($executablePath, $temporaryRootPath);
  109.         $this->q = $q;
  110.         $this->alphaQ = $alphaQ;
  111.         $this->m = $m;
  112.         $this->alphaFilter = $alphaFilter;
  113.         $this->alphaMethod = $alphaMethod;
  114.         $this->exact = $exact;
  115.         $this->metadata = $metadata;
  116.         $this->resolver = new OptionsResolver();
  118.         $this->configureOptions($this->resolver);
  119.     }
  121.     public function process(BinaryInterface $binary, array $options = []): BinaryInterface
  122.     {
  123.         if (!$this->isBinaryTypeWebpImage($binary)) {
  124.             return $binary;
  125.         }
  127.         $file = $this->writeTemporaryFile($binary, $options, 'imagine-post-processor-cwebp');
  128.         $arguments = $this->getProcessArguments($options);
  129.         $arguments[] = $file;
  130.         $arguments[] = '-o';
  131.         $arguments[] = '-';
  132.         $process = $this->createProcess($arguments, $options);
  134.         $process->run();
  136.         if (!$this->isSuccessfulProcess($process)) {
  137.             unlink($file);
  139.             throw new ProcessFailedException($process);
  140.         }
  142.         $result = new Binary($process->getOutput(), $binary->getMimeType(), $binary->getFormat());
  144.         unlink($file);
  146.         return $result;
  147.     }
  149.     protected function isBinaryTypeWebpImage(BinaryInterface $binary): bool
  150.     {
  151.         return $this->isBinaryTypeMatch($binary, ['image/webp']);
  152.     }
  154.     protected function configureOptions(OptionsResolver $resolver): void
  155.     {
  156.         $resolver
  157.             ->setDefault('q', $this->q)
  158.             ->setAllowedTypes('q', ['null', 'int'])
  159.             ->setAllowedValues('q', static function ($value) {
  160.                 if (null === $value) {
  161.                     return true;
  162.                 }
  164.                 return $value >= 0 && $value <= 100;
  165.             });
  167.         $resolver
  168.             ->setDefault('alphaQ', $this->alphaQ)
  169.             ->setAllowedTypes('alphaQ', ['null', 'int'])
  170.             ->setAllowedValues('alphaQ', static function ($value) {
  171.                 if (null === $value) {
  172.                     return true;
  173.                 }
  175.                 return $value >= 0 && $value <= 100;
  176.             });
  178.         $resolver
  179.             ->setDefault('m', $this->m)
  180.             ->setAllowedTypes('m', ['null', 'int'])
  181.             ->setAllowedValues('m', static function ($value) {
  182.                 if (null === $value) {
  183.                     return true;
  184.                 }
  186.                 return $value >= 0 && $value <= 6;
  187.             });
  189.         $resolver
  190.             ->setDefault('alphaFilter', $this->alphaFilter)
  191.             ->setAllowedTypes('alphaFilter', ['null', 'string'])
  192.             ->setAllowedValues('alphaFilter', [null, 'none', 'fast', 'best']);
  194.         $resolver
  195.             ->setDefault('alphaMethod', $this->alphaMethod)
  196.             ->setAllowedTypes('alphaMethod', ['null', 'int'])
  197.             ->setAllowedValues('alphaMethod', [null, 0, 1]);
  199.         $resolver
  200.             ->setDefault('exact', $this->exact)
  201.             ->setAllowedTypes('exact', ['null', 'bool']);
  203.         $resolver
  204.             ->setDefault('metadata', $this->metadata)
  205.             ->setAllowedTypes('metadata', ['null', 'array'])
  206.             ->setAllowedValues('metadata', static function ($value) {
  207.                 if (null === $value) {
  208.                     return true;
  209.                 }
  211.                 foreach ($value as $metadata) {
  212.                     if (!\in_array($metadata, ['all', 'none', 'exif', 'icc', 'xmp'], true)) {
  213.                         return false;
  214.                     }
  215.                 }
  217.                 return true;
  218.             });
  219.     }
  221.     /**
  222.      * @param array<mixed> $options
  223.      *
  224.      * @return string[]
  225.      */
  226.     protected function getProcessArguments(array $options = []): array
  227.     {
  228.         $options = $this->resolver->resolve($options);
  229.         $arguments = [$this->executablePath];
  231.         if ($q = $options['q']) {
  232.             $arguments[] = '-q';
  233.             $arguments[] = $q;
  234.         }
  236.         if ($alphaQ = $options['alphaQ']) {
  237.             $arguments[] = '-alpha_q';
  238.             $arguments[] = $alphaQ;
  239.         }
  241.         if ($m = $options['m']) {
  242.             $arguments[] = '-m';
  243.             $arguments[] = $m;
  244.         }
  246.         if ($alphaFilter = $options['alphaFilter']) {
  247.             $arguments[] = '-alpha_filter';
  248.             $arguments[] = $alphaFilter;
  249.         }
  251.         $alphaMethod = $options['alphaMethod'];
  252.         if (null !== $alphaMethod) {
  253.             $arguments[] = '-alpha_method';
  254.             $arguments[] = $alphaMethod;
  255.         }
  257.         if ($options['exact']) {
  258.             $arguments[] = '-exact';
  259.         }
  261.         if ($metadata = $options['metadata']) {
  262.             $arguments[] = '-metadata';
  263.             $arguments[] = implode(',', $metadata);
  264.         }
  266.         return $arguments;
  267.     }
  268. }