FFMpegAdapter::getParamsOptions() - Code Metrics - Inspection of "ProcessParamsInterface added as param" - soluble-io/soluble-mediatools - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 5ea322...ff77d7 )

by Sébastien

created 2018-07-10 12:35 UTC

FFMpegAdapter::getParamsOptions() A

↳ Parent: FFMpegAdapter

Complexity

Conditions	1
Paths	1

Size

Total Lines	84
Code Lines	51

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	51
nc	1
nop	0
dl	0
loc	84
rs	9.069
c	0
b	0
f	0

How to fix Long Method

<?php

declare(strict_types=1);

namespace Soluble\MediaTools\Video\Adapter;

use Soluble\MediaTools\Common\Exception\InvalidArgumentException;
use Soluble\MediaTools\Common\Exception\UnsupportedParamException;
use Soluble\MediaTools\Common\Exception\UnsupportedParamValueException;
use Soluble\MediaTools\Common\IO\PlatformNullFile;
use Soluble\MediaTools\Config\FFMpegConfigInterface;
use Soluble\MediaTools\Video\ConversionParamsInterface;

class FFMpegAdapter implements AdapterInterface
{
    /** @var FFMpegConfigInterface */
    protected $ffmpegConfig;

    public function __construct(FFMpegConfigInterface $ffmpegConfig)
    {
        $this->ffmpegConfig = $ffmpegConfig;
    }

    public function getDefaultThreads(): ?int
    {
        return $this->ffmpegConfig->getThreads();
    }

    /**
     * @return array<string, array<string, string>>
     */
    public function getParamsOptions(): array
    {
        return [
            ConversionParamsInterface::PARAM_OUTPUT_FORMAT => [
                'pattern' => '-f %s',
            ],

            ConversionParamsInterface::PARAM_VIDEO_CODEC => [
                'pattern' => '-c:v %s',
            ],
            ConversionParamsInterface::PARAM_VIDEO_BITRATE => [
                'pattern' => '-b:v %s',
            ],
            ConversionParamsInterface::PARAM_VIDEO_MIN_BITRATE => [
                'pattern' => '-minrate %s',
            ],
            ConversionParamsInterface::PARAM_VIDEO_MAX_BITRATE => [
                'pattern' => '-maxrate %s',
            ],

            ConversionParamsInterface::PARAM_AUDIO_CODEC => [
                'pattern' => '-c:a %s',
            ],
            ConversionParamsInterface::PARAM_AUDIO_BITRATE => [
                'pattern' => '-b:a %s',
            ],
            ConversionParamsInterface::PARAM_PIX_FMT => [
                'pattern' => '-pix_fmt %s',
            ],
            ConversionParamsInterface::PARAM_PRESET => [
                'pattern' => '-preset %s',
            ],
            ConversionParamsInterface::PARAM_SPEED => [
                'pattern' => '-speed %d',
            ],
            ConversionParamsInterface::PARAM_THREADS => [
                'pattern' => '-threads %d',
            ],
            ConversionParamsInterface::PARAM_KEYFRAME_SPACING => [
                'pattern' => '-g %d',
            ],
            ConversionParamsInterface::PARAM_QUALITY => [
                'pattern' => '-quality %s',
            ],

            ConversionParamsInterface::PARAM_VIDEO_QUALITY_SCALE => [
                'pattern' => '-qscale:v %d',
            ],

            ConversionParamsInterface::PARAM_CRF => [
                'pattern' => '-crf %d',
            ],
            ConversionParamsInterface::PARAM_STREAMABLE => [
                'pattern' => '-movflags +faststart',
            ],

            ConversionParamsInterface::PARAM_FRAME_PARALLEL => [
                'pattern' => '-frame-parallel %s',
            ],
            ConversionParamsInterface::PARAM_TILE_COLUMNS => [
                'pattern' => '-tile-columns %s',
            ],
            ConversionParamsInterface::PARAM_TUNE => [
                'pattern' => '-tune %s',
            ],
            ConversionParamsInterface::PARAM_VIDEO_FILTER => [
                'pattern' => '-vf %s',
            ],
            ConversionParamsInterface::PARAM_OVERWRITE => [
                'pattern' => '-y',
            ],
            ConversionParamsInterface::PARAM_VIDEO_FRAMES => [
                'pattern' => '-frames:v %d',
            ],
            ConversionParamsInterface::PARAM_NOAUDIO => [
                'pattern' => '-an',
            ],

            ConversionParamsInterface::PARAM_SEEK_START => [
                'pattern' => '-ss %s',
            ],

            ConversionParamsInterface::PARAM_SEEK_END => [
                'pattern' => '-to %s',
            ],
        ];
    }

    /**
     * @return array<string, string>
     *
     * @throws UnsupportedParamException
     * @throws UnsupportedParamValueException
     */
    public function getMappedConversionParams(ConversionParamsInterface $conversionParams): array
    {
        $args             = [];
        $supportedOptions = $this->getParamsOptions();

        // Add default overwrite option if not set
        $overwriteParam = ConversionParamsInterface::PARAM_OVERWRITE;
        if (!$conversionParams->hasParam($overwriteParam)) {
            $conversionParams = $conversionParams->withBuiltInParam(
                $overwriteParam,
                true
            );
        }

        foreach ($conversionParams->toArray() as $paramName => $value) {
            if (!array_key_exists($paramName, $supportedOptions)) {
                throw new UnsupportedParamException(
                    sprintf(
                        'FFMpegAdapter does not support param \'%s\'',
                        $paramName
                    )
                );
            }
            $pattern = $supportedOptions[$paramName]['pattern'];
            if (is_bool($value)) {
                $args[$paramName] = $value ? $pattern : '';
            } elseif ($value instanceof FFMpegCLIValueInterface) {
                // Will test also FFMpegVideoFilterInterface
                $args[$paramName] = sprintf($pattern, $value->getFFmpegCLIValue());
            } elseif (is_string($value) || is_int($value)) {
                $args[$paramName] = sprintf($pattern, $value);
            } else {
                throw new UnsupportedParamValueException(
                    sprintf(
                        'Param \'%s\' has an unsupported type: \'%s\'',
                        $paramName,
                        is_object($value) ? get_class($value) : gettype($value)
                    )
                );
            }
        }

        return $args;
    }

    /**
     * @param array<int|string, string>    $arguments
     * @param string|null                  $inputFile  if <null> will not prepend '-i inputFile' in args
     * @param null|string|PlatformNullFile $outputFile
     *
     * @throws InvalidArgumentException
     */
    public function getCliCommand(array $arguments, ?string $inputFile, $outputFile = null): string
    {
        $inputArg = ($inputFile !== null && $inputFile !== '')
                        ? sprintf('-i %s', escapeshellarg($inputFile))
                        : '';

        $outputArg = '';
        if ($outputFile instanceof PlatformNullFile) {
            $outputArg = $outputFile->getNullFile();
        } elseif (is_string($outputFile)) {
            $outputArg = sprintf('%s', escapeshellarg($outputFile));
        } elseif ($outputFile !== null) {

            throw new InvalidArgumentException(sprintf(
                'Output file must be either a non empty string, null or PlatformNullFile (type %s)',
                gettype($outputFile)
            ));
        }

        $ffmpegCmd = trim(sprintf(
            '%s %s %s %s',
            $this->ffmpegConfig->getBinary(),
            $inputArg,
            implode(' ', $arguments),
            $outputArg
        ));

        return $ffmpegCmd;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Soluble\MediaTools\Video\Adapter;
6
7			use Soluble\MediaTools\Common\Exception\InvalidArgumentException;
8			use Soluble\MediaTools\Common\Exception\UnsupportedParamException;
9			use Soluble\MediaTools\Common\Exception\UnsupportedParamValueException;
10			use Soluble\MediaTools\Common\IO\PlatformNullFile;
11			use Soluble\MediaTools\Config\FFMpegConfigInterface;
12			use Soluble\MediaTools\Video\ConversionParamsInterface;
13
14			class FFMpegAdapter implements AdapterInterface
15			{
16			/** @var FFMpegConfigInterface */
17			protected $ffmpegConfig;
18
19			public function __construct(FFMpegConfigInterface $ffmpegConfig)
20			{
21			$this->ffmpegConfig = $ffmpegConfig;
22			}
23
24			public function getDefaultThreads(): ?int
25			{
26			return $this->ffmpegConfig->getThreads();
27			}
28
29			/**
30			* @return array<string, array<string, string>>
31			*/
32			public function getParamsOptions(): array
33			{
34			return [
35			ConversionParamsInterface::PARAM_OUTPUT_FORMAT => [
36			'pattern' => '-f %s',
37			],
38
39			ConversionParamsInterface::PARAM_VIDEO_CODEC => [
40			'pattern' => '-c:v %s',
41			],
42			ConversionParamsInterface::PARAM_VIDEO_BITRATE => [
43			'pattern' => '-b:v %s',
44			],
45			ConversionParamsInterface::PARAM_VIDEO_MIN_BITRATE => [
46			'pattern' => '-minrate %s',
47			],
48			ConversionParamsInterface::PARAM_VIDEO_MAX_BITRATE => [
49			'pattern' => '-maxrate %s',
50			],
51
52			ConversionParamsInterface::PARAM_AUDIO_CODEC => [
53			'pattern' => '-c:a %s',
54			],
55			ConversionParamsInterface::PARAM_AUDIO_BITRATE => [
56			'pattern' => '-b:a %s',
57			],
58			ConversionParamsInterface::PARAM_PIX_FMT => [
59			'pattern' => '-pix_fmt %s',
60			],
61			ConversionParamsInterface::PARAM_PRESET => [
62			'pattern' => '-preset %s',
63			],
64			ConversionParamsInterface::PARAM_SPEED => [
65			'pattern' => '-speed %d',
66			],
67			ConversionParamsInterface::PARAM_THREADS => [
68			'pattern' => '-threads %d',
69			],
70			ConversionParamsInterface::PARAM_KEYFRAME_SPACING => [
71			'pattern' => '-g %d',
72			],
73			ConversionParamsInterface::PARAM_QUALITY => [
74			'pattern' => '-quality %s',
75			],
76
77			ConversionParamsInterface::PARAM_VIDEO_QUALITY_SCALE => [
78			'pattern' => '-qscale:v %d',
79			],
80
81			ConversionParamsInterface::PARAM_CRF => [
82			'pattern' => '-crf %d',
83			],
84			ConversionParamsInterface::PARAM_STREAMABLE => [
85			'pattern' => '-movflags +faststart',
86			],
87
88			ConversionParamsInterface::PARAM_FRAME_PARALLEL => [
89			'pattern' => '-frame-parallel %s',
90			],
91			ConversionParamsInterface::PARAM_TILE_COLUMNS => [
92			'pattern' => '-tile-columns %s',
93			],
94			ConversionParamsInterface::PARAM_TUNE => [
95			'pattern' => '-tune %s',
96			],
97			ConversionParamsInterface::PARAM_VIDEO_FILTER => [
98			'pattern' => '-vf %s',
99			],
100			ConversionParamsInterface::PARAM_OVERWRITE => [
101			'pattern' => '-y',
102			],
103			ConversionParamsInterface::PARAM_VIDEO_FRAMES => [
104			'pattern' => '-frames:v %d',
105			],
106			ConversionParamsInterface::PARAM_NOAUDIO => [
107			'pattern' => '-an',
108			],
109
110			ConversionParamsInterface::PARAM_SEEK_START => [
111			'pattern' => '-ss %s',
112			],
113
114			ConversionParamsInterface::PARAM_SEEK_END => [
115			'pattern' => '-to %s',
116			],
117			];
118			}
119
120			/**
121			* @return array<string, string>
122			*
123			* @throws UnsupportedParamException
124			* @throws UnsupportedParamValueException
125			*/
126			public function getMappedConversionParams(ConversionParamsInterface $conversionParams): array
127			{
128			$args = [];
129			$supportedOptions = $this->getParamsOptions();
130
131			// Add default overwrite option if not set
132			$overwriteParam = ConversionParamsInterface::PARAM_OVERWRITE;
133			if (!$conversionParams->hasParam($overwriteParam)) {
134			$conversionParams = $conversionParams->withBuiltInParam(
135			$overwriteParam,
136			true
137			);
138			}
139
140			foreach ($conversionParams->toArray() as $paramName => $value) {
141			if (!array_key_exists($paramName, $supportedOptions)) {
142			throw new UnsupportedParamException(
143			sprintf(
144			'FFMpegAdapter does not support param \'%s\'',
145			$paramName
146			)
147			);
148			}
149			$pattern = $supportedOptions[$paramName]['pattern'];
150			if (is_bool($value)) {
151			$args[$paramName] = $value ? $pattern : '';
152			} elseif ($value instanceof FFMpegCLIValueInterface) {
153			// Will test also FFMpegVideoFilterInterface
154			$args[$paramName] = sprintf($pattern, $value->getFFmpegCLIValue());
155			} elseif (is_string($value) \|\| is_int($value)) {
156			$args[$paramName] = sprintf($pattern, $value);
157			} else {
158			throw new UnsupportedParamValueException(
159			sprintf(
160			'Param \'%s\' has an unsupported type: \'%s\'',
161			$paramName,
162			is_object($value) ? get_class($value) : gettype($value)
163			)
164			);
165			}
166			}
167
168			return $args;
169			}
170
171			/**
172			* @param array<int\|string, string> $arguments
173			* @param string\|null $inputFile if <null> will not prepend '-i inputFile' in args
174			* @param null\|string\|PlatformNullFile $outputFile
175			*
176			* @throws InvalidArgumentException
177			*/
178			public function getCliCommand(array $arguments, ?string $inputFile, $outputFile = null): string
179			{
180			$inputArg = ($inputFile !== null && $inputFile !== '')
181			? sprintf('-i %s', escapeshellarg($inputFile))
182			: '';
183
184			$outputArg = '';
185			if ($outputFile instanceof PlatformNullFile) {
186			$outputArg = $outputFile->getNullFile();
187			} elseif (is_string($outputFile)) {
188			$outputArg = sprintf('%s', escapeshellarg($outputFile));
189			} elseif ($outputFile !== null) {
			0 ignored issues – show introduced 2018-07-07 21:52 UTC by Report Bug Copy Issue Report The condition `$outputFile !== null` is always `false`. Loading history...
190			throw new InvalidArgumentException(sprintf(
191			'Output file must be either a non empty string, null or PlatformNullFile (type %s)',
192			gettype($outputFile)
193			));
194			}
195
196			$ffmpegCmd = trim(sprintf(
197			'%s %s %s %s',
198			$this->ffmpegConfig->getBinary(),
199			$inputArg,
200			implode(' ', $arguments),
201			$outputArg
202			));
203
204			return $ffmpegCmd;
205			}
206			}
207

soluble-io / soluble-mediatools

Push — master ( 5ea322...ff77d7 )

FFMpegAdapter::getParamsOptions() A

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like