Transcode::moveAssetToVolume() - Code Metrics - Inspection of "Add support for volumes." - nystudio107/craft-transcoder - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — v1 (#20)

unknown
created 2019-03-25 13:59 UTC
Transcode::moveAssetToVolume() B

↳ Parent: Transcode
Complexity

Conditions	6
Paths	5
Size

Total Lines	41
Code Lines	24
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	6
eloc	24
nc	5
nop	2
dl	0
loc	41
rs	8.9137
c	0
b	0
f	0
<?php
/**
 * Transcoder plugin for Craft CMS 3.x
 *
 * Transcode videos to various formats, and provide thumbnails of the video
 *
 * @link      https://nystudio107.com

 * @copyright Copyright (c) 2017 nystudio107

 */


namespace nystudio107\transcoder\services;

use craft\records\VolumeFolder;
use craft\services\Assets;
use nystudio107\transcoder\Transcoder;

use Craft;
use craft\base\Component;
use craft\elements\Asset;
use craft\events\AssetThumbEvent;
use craft\helpers\FileHelper;
use craft\helpers\Json as JsonHelper;
use craft\volumes\Local;

use yii\base\Exception;
use yii\validators\UrlValidator;

use mikehaertl\shellcommand\Command as ShellCommand;
use yii\base\InvalidConfigException;

/**

 * @author    nystudio107

 * @package   Transcode

 * @since     1.0.0

 */

class Transcode extends Component
{
    // Constants
    // =========================================================================

    // Suffixes to add to the generated filename params
    const SUFFIX_MAP = [
        'videoFrameRate' => 'fps',
        'videoBitRate' => 'bps',
        'audioBitRate' => 'bps',
        'audioChannels' => 'c',
        'height' => 'h',
        'width' => 'w',
        'timeInSecs' => 's',
    ];

    // Params that should be excluded from being part of the generated filename
    const EXCLUDE_PARAMS = [
        'videoEncoder',
        'audioEncoder',
        'fileSuffix',
        'sharpen',
    ];

    // Mappings for getFileInfo() summary values
    const INFO_SUMMARY = [
        'format' => [
            'filename' => 'filename',
            'duration' => 'duration',
            'size' => 'size',
        ],
        'audio' => [
            'codec_name' => 'audioEncoder',
            'bit_rate' => 'audioBitRate',
            'sample_rate' => 'audioSampleRate',
            'channels' => 'audioChannels',
        ],
        'video' => [
            'codec_name' => 'videoEncoder',
            'bit_rate' => 'videoBitRate',
            'avg_frame_rate' => 'videoFrameRate',
            'height' => 'height',
            'width' => 'width',
        ],
    ];

    // Public Methods
    // =========================================================================

    /**

     * Returns a URL to the transcoded video or "" if it doesn't exist (at which
     * time it will create it).
     *
     * @param $filePath     string  path to the original video -OR- an Asset

     * @param $videoOptions array   of options for the video

     * @param bool   $generate         whether the video should be encoded

     *
     * @return string       URL of the transcoded video or ""
     */
    public function getVideoUrl($filePath, $videoOptions, $generate = true): string
    {

        $result = '';
        $settings = Transcoder::$plugin->getSettings();
		$subfolder = '';


		// sub folder check

		if(\is_object($filePath) && ($filePath instanceof Asset) && $settings['createSubfolders']) {

			$subfolder = $filePath->folderPath;

		}


		// file path

        $filePath = $this->getAssetPath($filePath);

        if (!empty($filePath)) {
            $destVideoPath = $this->localDestPath('video', $subfolder);
            $destVideoPath = $this->localDestPath('video', /** @scrutinizer ignore-type */ $subfolder);
            $videoOptions = $this->coalesceOptions('defaultVideoOptions', $videoOptions);

            // Get the video encoder presets to use
            $videoEncoders = $settings['videoEncoders'];
            $thisEncoder = $videoEncoders[$videoOptions['videoEncoder']];

            $videoOptions['fileSuffix'] = $thisEncoder['fileSuffix'];

            // Build the basic command for ffmpeg
            $ffmpegCmd = $settings['ffmpegPath']
                .' -i '.escapeshellarg($filePath)
                .' -vcodec '.$thisEncoder['videoCodec']
                .' '.$thisEncoder['videoCodecOptions']
                .' -bufsize 1000k'
                .' -threads '.$thisEncoder['threads'];

            // Set the framerate if desired
            if (!empty($videoOptions['videoFrameRate'])) {
                $ffmpegCmd .= ' -r '.$videoOptions['videoFrameRate'];
            }

            // Set the bitrate if desired
            if (!empty($videoOptions['videoBitRate'])) {
                $ffmpegCmd .= ' -b:v '.$videoOptions['videoBitRate'].' -maxrate '.$videoOptions['videoBitRate'];
            }

            // Adjust the scaling if desired
            $ffmpegCmd = $this->addScalingFfmpegArgs(
                $videoOptions,
                $ffmpegCmd
            );

            // Handle any audio transcoding
            if (empty($videoOptions['audioBitRate'])
                && empty($videoOptions['audioSampleRate'])
                && empty($videoOptions['audioChannels'])
            ) {
                // Just copy the audio if no options are provided
                $ffmpegCmd .= ' -c:a copy';
            } else {
                // Do audio transcoding based on the settings
                $ffmpegCmd .= ' -acodec '.$thisEncoder['audioCodec'];
                if (!empty($videoOptions['audioBitRate'])) {
                    $ffmpegCmd .= ' -b:a '.$videoOptions['audioBitRate'];
                }
                if (!empty($videoOptions['audioSampleRate'])) {
                    $ffmpegCmd .= ' -ar '.$videoOptions['audioSampleRate'];
                }
                if (!empty($videoOptions['audioChannels'])) {
                    $ffmpegCmd .= ' -ac '.$videoOptions['audioChannels'];
                }
                $ffmpegCmd .= ' '.$thisEncoder['audioCodecOptions'];
            }

            // Create the directory if it isn't there already
            if (!is_dir($destVideoPath)) {
                try {
                    FileHelper::createDirectory($destVideoPath);
                } catch (Exception $e) {
                    Craft::error($e->getMessage(), __METHOD__);
                }
            }

            $destVideoFile = $this->getFilename($filePath, $videoOptions);

            // File to store the video encoding progress in
            $progressFile = sys_get_temp_dir().DIRECTORY_SEPARATOR.$destVideoFile.'.progress';

            // Assemble the destination path and final ffmpeg command
            $destVideoPath .= $destVideoFile;
            $ffmpegCmd .= ' -f '
                .$thisEncoder['fileFormat']
                .' -y '.escapeshellarg($destVideoPath)
                .' 1> '.$progressFile.' 2>&1 & echo $!';

            // Make sure there isn't a lockfile for this video already
            $lockFile = sys_get_temp_dir().DIRECTORY_SEPARATOR.$destVideoFile.'.lock';
            $oldPid = @file_get_contents($lockFile);
            if ($oldPid !== false) {
                exec("ps $oldPid", $ProcessState);
                if (\count($ProcessState) >= 2) {
                    return $result;
                }
                // It's finished transcoding, so delete the lockfile and progress file
                @unlink($lockFile);
                @unlink($progressFile);
            }

            // If the video file already exists and hasn't been modified, return it.  Otherwise, start it transcoding
            if (!$this->shouldGenerateAsset('video', $destVideoPath, $filePath)) {
                $url = $settings['transcoderUrls']['video'] ?? $settings['transcoderUrls']['default'];
                $result = Craft::getAlias($url).$destVideoFile;

                if ($remoteUrl = $this->moveAssetToVolume('video', $destVideoPath)) {
                    $result = $remoteUrl;
                }

            // skip encoding

            } elseif (!$generate) {
	            $result = "";

            } else {
                // Kick off the transcoding
                $pid = $this->executeShellCommand($ffmpegCmd);
                Craft::info($ffmpegCmd."\nffmpeg PID: ".$pid, __METHOD__);

                // Create a lockfile in tmp
                file_put_contents($lockFile, $pid);
            }

            return $result;
        }

        return $result;
    }

    /**
     * Returns a URL to a video thumbnail
     *
     * @param string $filePath         path to the original video or an Asset
     * @param array  $thumbnailOptions of options for the thumbnail
     * @param bool   $generate         whether the thumbnail should be
     *                                 generated if it doesn't exists
     * @param bool   $asPath           Whether we should return a path or not
     *
     * @return string|false|null URL or path of the video thumbnail
     */
    public function getVideoThumbnailUrl($filePath, $thumbnailOptions, $generate = true, $asPath = false)
    {
        $result = null;
        $settings = Transcoder::$plugin->getSettings();
		$subfolder = '';


		// sub folder check

		if(\is_object($filePath) && ($filePath instanceof Asset) && $settings['createSubfolders']) {

			$subfolder = $filePath->folderPath;

		}


        $filePath = $this->getAssetPath($filePath);

        if (!empty($filePath)) {
            $destThumbnailPath = $this->localDestPath('thumbnail', $subfolder);

            $thumbnailOptions = $this->coalesceOptions('defaultThumbnailOptions', $thumbnailOptions);

            // Build the basic command for ffmpeg
            $ffmpegCmd = $settings['ffmpegPath']
                .' -i '.escapeshellarg($filePath)
                .' -vcodec mjpeg'
                .' -vframes 1';

            // Adjust the scaling if desired
            $ffmpegCmd = $this->addScalingFfmpegArgs(
                $thumbnailOptions,
                $ffmpegCmd
            );

            // Set the timecode to get the thumbnail from if desired
            if (!empty($thumbnailOptions['timeInSecs'])) {
                $timeCode = gmdate('H:i:s', $thumbnailOptions['timeInSecs']);
                $ffmpegCmd .= ' -ss '.$timeCode.'.00';
            }

            // Create the directory if it isn't there already
            if (!is_dir($destThumbnailPath)) {
                try {
                    FileHelper::createDirectory($destThumbnailPath);
                } catch (Exception $e) {
                    Craft::error($e->getMessage(), __METHOD__);
                }
            }

            $destThumbnailFile = $this->getFilename($filePath, $thumbnailOptions);

            // Assemble the destination path and final ffmpeg command
            $destThumbnailPath .= $destThumbnailFile;
            $ffmpegCmd .= ' -f image2 -y '.escapeshellarg($destThumbnailPath).' >/dev/null 2>/dev/null &';

            // If the thumbnail file already exists, return it.  Otherwise, generate it and return it
            if ($this->shouldGenerateAsset('thumbnail', $destThumbnailPath)) {
                if ($generate) {
                    /** @noinspection PhpUnusedLocalVariableInspection */

                    $shellOutput = $this->executeShellCommand($ffmpegCmd);
                    Craft::info($ffmpegCmd, __METHOD__);

                    // if ffmpeg fails which we can't check because the process is ran in the background
                    // dont return the future path of the image or else we can't check this in the front end

                    return false;

                } else {
                    Craft::info('Thumbnail does not exist, but not asked to generate it: '.$filePath, __METHOD__);

                    // The file doesn't exist, and we weren't asked to generate it
                    return false;
                }
            }

            if ($remoteUrl = $this->moveAssetToVolume('thumbnail', $destThumbnailPath)) {
                return $remoteUrl;
            }

            // Return either a path or a URL
            if ($asPath) {
                $result = $destThumbnailPath;
            } else {
                $url = $settings['transcoderUrls']['thumbnail'] . $subfolder ?? $settings['transcoderUrls']['default'];
                $result = Craft::getAlias($url).$destThumbnailFile;
            }
        }

        return $result;
    }

    /**

     * Returns a URL to the transcoded audio file or "" if it doesn't exist
     * (at which time it will create it).
     *
     * @param $filePath     string path to the original audio file -OR- an Asset

     * @param $audioOptions array of options for the audio file

     *
     * @return string       URL of the transcoded audio file or ""
     */
    public function getAudioUrl($filePath, $audioOptions): string
    {
        $result = '';
        $settings = Transcoder::$plugin->getSettings();
		$subfolder = '';


		// sub folder check

		if(\is_object($filePath) && ($filePath instanceof Asset) && $settings['createSubfolders']) {

			$subfolder = $filePath->folderPath;

		}


        $filePath = $this->getAssetPath($filePath);

        if (!empty($filePath)) {
            $destAudioPath = $this->localDestPath('audio', $subfolder);
            $destAudioPath = $this->localDestPath('audio', /** @scrutinizer ignore-type */ $subfolder);

            $audioOptions = $this->coalesceOptions('defaultAudioOptions', $audioOptions);

            // Get the audio encoder presets to use
            $audioEncoders = $settings['audioEncoders'];
            $thisEncoder = $audioEncoders[$audioOptions['audioEncoder']];

            $audioOptions['fileSuffix'] = $thisEncoder['fileSuffix'];

            // Build the basic command for ffmpeg
            $ffmpegCmd = $settings['ffmpegPath']
                .' -i '.escapeshellarg($filePath)
                .' -acodec '.$thisEncoder['audioCodec']
                .' '.$thisEncoder['audioCodecOptions']
                .' -bufsize 1000k'
                .' -threads '.$thisEncoder['threads'];

            // Set the bitrate if desired
            if (!empty($audioOptions['audioBitRate'])) {
                $ffmpegCmd .= ' -b:a '.$audioOptions['audioBitRate'];
            }
            // Set the sample rate if desired
            if (!empty($audioOptions['audioSampleRate'])) {
                $ffmpegCmd .= ' -ar '.$audioOptions['audioSampleRate'];
            }
            // Set the audio channels if desired
            if (!empty($audioOptions['audioChannels'])) {
                $ffmpegCmd .= ' -ac '.$audioOptions['audioChannels'];
            }
            $ffmpegCmd .= ' '.$thisEncoder['audioCodecOptions'];


            // Create the directory if it isn't there already
            if (!is_dir($destAudioPath)) {
                try {
                    FileHelper::createDirectory($destAudioPath);
                } catch (Exception $e) {
                    Craft::error($e->getMessage(), __METHOD__);
                }
            }

            $destAudioFile = $this->getFilename($filePath, $audioOptions);

            // File to store the audio encoding progress in
            $progressFile = sys_get_temp_dir().DIRECTORY_SEPARATOR.$destAudioFile.'.progress';

            // Assemble the destination path and final ffmpeg command
            $destAudioPath .= $destAudioFile;
            $ffmpegCmd .= ' -f '
                .$thisEncoder['fileFormat']
                .' -y '.escapeshellarg($destAudioPath)
                .' 1> '.$progressFile.' 2>&1 & echo $!';

            // Make sure there isn't a lockfile for this audio file already
            $lockFile = sys_get_temp_dir().DIRECTORY_SEPARATOR.$destAudioFile.'.lock';
            $oldPid = @file_get_contents($lockFile);
            if ($oldPid !== false) {
                exec("ps $oldPid", $ProcessState);
                if (\count($ProcessState) >= 2) {
                    return $result;
                }
                // It's finished transcoding, so delete the lockfile and progress file
                @unlink($lockFile);
                /** @scrutinizer ignore-unhandled */ @unlink($lockFile);
                @unlink($progressFile);
            }

            // If the audio file already exists and hasn't been modified, return it.  Otherwise, start it transcoding
            if ($this->shouldGenerateAsset('audio', $destAudioPath, $filePath)) {
                $url = $settings['transcoderUrls']['audio'] . $subfolder ?? $settings['transcoderUrls']['default'];
                $result = Craft::getAlias($url).$destAudioFile;

                if ($remoteUrl = $this->moveAssetToVolume('audio', $destAudioPath)) {
                    $result = $remoteUrl;
                }
            } else {
                // Kick off the transcoding
                $pid = $this->executeShellCommand($ffmpegCmd);
                Craft::info($ffmpegCmd."\nffmpeg PID: ".$pid, __METHOD__);

                // Create a lockfile in tmp
                file_put_contents($lockFile, $pid);
            }
        }

        return $result;
    }

    /**

     * Extract information from a video/audio file
     *
     * @param      $filePath

     * @param bool $summary

     *
     * @return null|array
     */
    public function getFileInfo($filePath, $summary = false)
    {
        $result = null;
        $settings = Transcoder::$plugin->getSettings();
        $filePath = $this->getAssetPath($filePath);

        if (!empty($filePath)) {
            // Build the basic command for ffprobe
            $ffprobeOptions = $settings['ffprobeOptions'];
            $ffprobeCmd = $settings['ffprobePath']
                .' '.$ffprobeOptions
                .' '.escapeshellarg($filePath);

            $shellOutput = $this->executeShellCommand($ffprobeCmd);
            Craft::info($ffprobeCmd, __METHOD__);
            $result = JsonHelper::decodeIfJson($shellOutput, true);
            Craft::info(print_r($result, true), __METHOD__);

            // Trim down the arrays to just a summary
            if ($summary && !empty($result)) {
                $summaryResult = [];
                foreach ($result as $topLevelKey => $topLevelValue) {
                    switch ($topLevelKey) {
                        // Format info
                        case 'format':

                            foreach (self::INFO_SUMMARY['format'] as $settingKey => $settingValue) {

                                if (!empty($topLevelValue[$settingKey])) {

                                    $summaryResult[$settingValue] = $topLevelValue[$settingKey];
                                }

                            }

                            break;
                        // Stream info
                        case 'streams':

                            foreach ($topLevelValue as $stream) {

                                $infoSummaryType = $stream['codec_type'];
                                if (in_array($infoSummaryType, self::INFO_SUMMARY, false)) {

                                    foreach (self::INFO_SUMMARY[$infoSummaryType] as $settingKey => $settingValue) {

                                        if (!empty($stream[$settingKey])) {

                                            $summaryResult[$settingValue] = $stream[$settingKey];
                                        }

                                    }

                                }

                            }

                            break;
                        // Unknown info
                        default:

                            break;
                    }
                }
                // Handle cases where the framerate is returned as XX/YY
                if (!empty($summaryResult['videoFrameRate'])
                    && (strpos($summaryResult['videoFrameRate'], '/') !== false)
                ) {
                    $parts = explode('/', $summaryResult['videoFrameRate']);
                    $summaryResult['videoFrameRate'] = (float)$parts[0] / (float)$parts[1];
                }
                $result = $summaryResult;
            }
        }

        return $result;
    }

    /**

     * Get the name of a video file from a path and options
     *
     * @param $filePath

     * @param $videoOptions

     *
     * @return string
     */
    public function getVideoFilename($filePath, $videoOptions): string
    {
        $settings = Transcoder::$plugin->getSettings();
        $videoOptions = $this->coalesceOptions('defaultVideoOptions', $videoOptions);

        // Get the video encoder presets to use
        $videoEncoders = $settings['videoEncoders'];
        $thisEncoder = $videoEncoders[$videoOptions['videoEncoder']];

        $videoOptions['fileSuffix'] = $thisEncoder['fileSuffix'];

        return $this->getFilename($filePath, $videoOptions);
    }

    /**

     * Get the name of an audio file from a path and options
     *
     * @param $filePath

     * @param $audioOptions

     *
     * @return string
     */
    public function getAudioFilename($filePath, $audioOptions): string
    {
        $settings = Transcoder::$plugin->getSettings();
        $audioOptions = $this->coalesceOptions('defaultAudioOptions', $audioOptions);

        // Get the video encoder presets to use
        $audioEncoders = $settings['audioEncoders'];
        $thisEncoder = $audioEncoders[$audioOptions['audioEncoder']];

        $audioOptions['fileSuffix'] = $thisEncoder['fileSuffix'];

        return $this->getFilename($filePath, $audioOptions);
    }

    /**

     * Get the name of a gif video file from a path and options
     *
     * @param $filePath

     * @param $gifOptions

     *
     * @return string
     */
    public function getGifFilename($filePath, $gifOptions): string
    {
        $settings = Transcoder::$plugin->getSettings();
        $gifOptions = $this->coalesceOptions('defaultGifOptions', $gifOptions);

        // Get the video encoder presets to use
        $videoEncoders = $settings['videoEncoders'];
        $thisEncoder = $videoEncoders[$gifOptions['videoEncoder']];

        $gifOptions['fileSuffix'] = $thisEncoder['fileSuffix'];

        return $this->getFilename($filePath, $gifOptions);
    }

    /**
     * Handle generated a thumbnail for the Control Panel
     *
     * @param AssetThumbEvent $event

     *
     * @return null|false|string
     */
    public function handleGetAssetThumbPath(AssetThumbEvent $event)
    {
        $options = [
            'width' => $event->width,
            'height' => $event->height,
        ];
        $thumbPath = $this->getVideoThumbnailUrl($event->asset, $options, $event->generate, true);

        return $thumbPath;
    }

    // Protected Methods
    // =========================================================================

    /**
     * Returns a URL to a encoded GIF file (mp4)
     *
     * @param string $filePath         path to the original video or an Asset

     * @param array  $gifOptions       of options for the GIF file

     *
     * @return string|false|null URL or path of the GIF file
     */


    public function getGifUrl($filePath, $gifOptions): string
    {
        $result = '';
        $settings = Transcoder::$plugin->getSettings();
        $subfolder = '';

        // sub folder check
        if(\is_object($filePath) && ($filePath instanceof Asset) && $settings['createSubfolders']) {

            $subfolder = $filePath->folderPath;
        }

        $filePath = $this->getAssetPath($filePath);

        if (!empty($filePath)) {
            // Dest path
            $destVideoPath = $this->localDestPath('gif', $subfolder);

            // Options
            $gifOptions = $this->coalesceOptions('defaultGifOptions', $gifOptions);

            // Get the video encoder presets to use
            $videoEncoders = $settings['videoEncoders'];
            $thisEncoder = $videoEncoders[$gifOptions['videoEncoder']];
            $gifOptions['fileSuffix'] = $thisEncoder['fileSuffix'];

            // Build the basic command for ffmpeg
            $ffmpegCmd = $settings['ffmpegPath']
                .' -f gif'
                .' -i '.escapeshellarg($filePath)
                .' -vcodec '.$thisEncoder['videoCodec']
                .' '.$thisEncoder['videoCodecOptions'];


            // Create the directory if it isn't there already
            if (!is_dir($destVideoPath)) {
                try {
                    FileHelper::createDirectory($destVideoPath);
                } catch (Exception $e) {
                    Craft::error($e->getMessage(), __METHOD__);
                }
            }

            $destVideoFile = $this->getFilename($filePath, $gifOptions);

            // File to store the video encoding progress in
            $progressFile = sys_get_temp_dir().DIRECTORY_SEPARATOR.$destVideoFile.'.progress';

            // Assemble the destination path and final ffmpeg command
            $destVideoPath .= $destVideoFile;
            $ffmpegCmd .= ' '
                .' -y '.escapeshellarg($destVideoPath)
                .' 1> '.$progressFile.' 2>&1 & echo $!';

            // Make sure there isn't a lockfile for this video already
            $lockFile = sys_get_temp_dir().DIRECTORY_SEPARATOR.$destVideoFile.'.lock';
            $oldPid = @file_get_contents($lockFile);
            if ($oldPid !== false) {
                exec("ps $oldPid", $ProcessState);
                if (\count($ProcessState) >= 2) {
                    return $result;
                }
                // It's finished transcoding, so delete the lockfile and progress file
                @unlink($lockFile);
                @unlink($progressFile);
            }

            // If the video file already exists and hasn't been modified, return it.  Otherwise, start it transcoding
            if ($this->shouldGenerateAsset('gif', $destVideoPath, $filePath)) {
                $url = $settings['transcoderUrls']['gif'] . $subfolder ?? $settings['transcoderUrls']['default'];
                $result = Craft::getAlias($url).$destVideoFile;

                if ($remoteUrl = $this->moveAssetToVolume('gif', $destVideoPath)) {
                    $result = $remoteUrl;
                }
            } else {
                // Kick off the transcoding
                $pid = $this->executeShellCommand($ffmpegCmd);
                Craft::info($ffmpegCmd."\nffmpeg PID: ".$pid, __METHOD__);

                // Create a lockfile in tmp
                file_put_contents($lockFile, $pid);
            }
        }

        return $result;
    }

    /**

     * Get the name of a file from a path and options
     *
     * @param $filePath

     * @param $options

     *
     * @return string
     */
    protected function getFilename($filePath, $options): string
    {
        $settings = Transcoder::$plugin->getSettings();
        $filePath = $this->getAssetPath($filePath);

        $validator = new UrlValidator();
        $error = '';
        if ($validator->validate($filePath, $error)) {
            $urlParts = parse_url($filePath);
            $pathParts = pathinfo($urlParts['path']);
        } else {
            $pathParts = pathinfo($filePath);
        }
        $fileName = $pathParts['filename'];

        // Add our options to the file name
        foreach ($options as $key => $value) {
            if (!empty($value)) {
                $suffix = '';
                if (!empty(self::SUFFIX_MAP[$key])) {
                    $suffix = self::SUFFIX_MAP[$key];
                }
                if (\is_bool($value)) {
                    $value = $value ? $key : 'no'.$key;
                }
                if (!\in_array($key, self::EXCLUDE_PARAMS, true)) {
                    $fileName .= '_'.$value.$suffix;
                }
            }
        }
        // See if we should use a hash instead
        if ($settings['useHashedNames']) {
            $fileName = $pathParts['filename'].md5($fileName);
        }
        $fileName .= $options['fileSuffix'];

        return $fileName;
    }

    /**

     * Extract a file system path if $filePath is an Asset object
     *
     * @param $filePath

     *
     * @return string
     */
    protected function getAssetPath($filePath): string
    {
        // If we're passed an Asset, extract the path from it
        if (\is_object($filePath) && ($filePath instanceof Asset)) {
            /** @var Asset $asset */

            $asset = $filePath;
            $assetVolume = null;

            try {
                $assetVolume = $asset->getVolume();
            } catch (InvalidConfigException $e) {
                Craft::error($e->getMessage(), __METHOD__);
            }

            if ($assetVolume) {

                // If it's local, get a path to the file
                if ($assetVolume instanceof Local) {
                    $sourcePath = rtrim($assetVolume->path, DIRECTORY_SEPARATOR);
                    $sourcePath .= '' === $sourcePath ? '': DIRECTORY_SEPARATOR;
                    $folderPath = '';

                    try {
                        $folderPath = rtrim($asset->getFolder()->path, DIRECTORY_SEPARATOR);
                    } catch (InvalidConfigException $e) {
                        Craft::error($e->getMessage(), __METHOD__);
                    }
                    $folderPath .= '' === $folderPath ? '': DIRECTORY_SEPARATOR;

                    $filePath = $sourcePath.$folderPath.$asset->filename;
                } else {
                    // Otherwise, get a URL
                    $filePath = $asset->getUrl();
                }
            }
        }

        $filePath = Craft::getAlias($filePath);

        // Make sure that $filePath is either an existing file, or a valid URL
        if (!file_exists($filePath)) {
            $validator = new UrlValidator();
            $error = '';
            if (!$validator->validate($filePath, $error)) {
                Craft::error($error, __METHOD__);
                $filePath = '';
            }
        }

        return $filePath;

    }

    /**

     * Set the width & height if desired
     *
     * @param $options

     * @param $ffmpegCmd

     *
     * @return string
     */
    protected function addScalingFfmpegArgs($options, $ffmpegCmd): string
    {
        if (!empty($options['width']) && !empty($options['height'])) {
            // Handle "none", "crop", and "letterbox" aspectRatios
            $aspectRatio = '';
            if (!empty($options['aspectRatio'])) {
                switch ($options['aspectRatio']) {
                    // Scale to the appropriate aspect ratio, padding
                    case 'letterbox':

                        $letterboxColor = '';
                        if (!empty($options['letterboxColor'])) {

                            $letterboxColor = ':color='.$options['letterboxColor'];
                        }

                        $aspectRatio = ':force_original_aspect_ratio=decrease'
                            .',pad='.$options['width'].':'.$options['height'].':(ow-iw)/2:(oh-ih)/2'
                            .$letterboxColor;
                        break;
                    // Scale to the appropriate aspect ratio, cropping
                    case 'crop':

                        $aspectRatio = ':force_original_aspect_ratio=increase'
                            .',crop='.$options['width'].':'.$options['height'];
                        break;
                    // No aspect ratio scaling at all
                    default:

                        $aspectRatio = ':force_original_aspect_ratio=disable';
                        $options['aspectRatio'] = 'none';
                        break;
                }
            }
            $sharpen = '';
            if (!empty($options['sharpen']) && ($options['sharpen'] !== false)) {
                $sharpen = ',unsharp=5:5:1.0:5:5:0.0';
            }
            $ffmpegCmd .= ' -vf "scale='
                .$options['width'].':'.$options['height']
                .$aspectRatio
                .$sharpen
                .'"';
        }

        return $ffmpegCmd;
    }

    // Protected Methods
    // =========================================================================

    /**

     * Combine the options arrays
     *
     * @param $defaultName

     * @param $options

     *
     * @return array
     */
    protected function coalesceOptions($defaultName, $options): array
    {
        // Default options
        $settings = Transcoder::$plugin->getSettings();
        $defaultOptions = $settings[$defaultName];

        // Coalesce the passed in $options with the $defaultOptions
        $options = array_merge($defaultOptions, $options);

        return $options;
    }

    /**
     * Execute a shell command
     *
     * @param string $command

     *
     * @return string
     */
    protected function executeShellCommand(string $command): string
    {
        // Create the shell command
        $shellCommand = new ShellCommand();
        $shellCommand->setCommand($command);

        // If we don't have proc_open, maybe we've got exec
        if (!\function_exists('proc_open') && \function_exists('exec')) {
            $shellCommand->useExec = true;
        }

        // Return the result of the command's output or error
        if ($shellCommand->execute()) {
            $result = $shellCommand->getOutput();
        } else {
            $result = $shellCommand->getError();
        }

        return $result;
    }

    protected function shouldGenerateAsset(string $type, string $destVideoFilePath, string $originalFilePath = null)

    {
        $settings = Transcoder::$plugin->getSettings();
        $destSettings = $settings['transcoderPaths'][$type] ?? $settings['transcoderPaths']['default'];

        if (file_exists($destVideoFilePath) && (@filemtime($destVideoFilePath) >= @filemtime($originalFilePath))) {
            return false;
        }

        if (!is_array($destSettings)) {
            return true;
        }

        $filename = basename($destVideoFilePath);

        $volume = Craft::$app->getVolumes()->getVolumeByHandle($destSettings['volume']);
        /** @var Asset $asset */

        $asset = Asset::findOne(['volumeId' => $volume->id, 'filename' => $filename]);


        if ($asset && $asset->dateModified->getTimestamp() >= @filemtime($originalFilePath)) {
        if ($asset && $asset->dateModified->/** @scrutinizer ignore-call */ getTimestamp() >= @filemtime($originalFilePath)) {
            return false;
        }
        return true;
    }

    protected function localDestPath(string $type, string $subfolder) {

        $settings = Transcoder::$plugin->getSettings();
        $destSettings = $settings['transcoderPaths'][$type]  ?? $settings['transcoderPaths']['default'];
        if (is_array($destSettings)) {
            return sys_get_temp_dir().DIRECTORY_SEPARATOR;
        }
        if (isset($settings['transcoderPaths'][$type])) {
            $destSettings .= $subfolder;
        }
        return Craft::getAlias($destSettings);
    }

    protected function moveAssetToVolume(string $type, string $filePath)

    {
        $settings = Transcoder::$plugin->getSettings();
        $destSettings = $settings['transcoderPaths'][$type] ?? $settings['transcoderPaths']['default'];

        // check if the setting is a volume
        if (!is_array($destSettings) || empty($filePath)) {
            return;
        }

        $volume = Craft::$app->getVolumes()->getVolumeByHandle($destSettings['volume']);
        if (!$volume) {
            $message = sprintf('Volume (handle: "%s") does not exist.', $destSettings['volume']);
            throw new \RuntimeException($message);
        }

        $filename = basename($filePath);

        /** @var Assets $assetService */

        $assetElement = Asset::findOne(['volumeId' => $volume->id, 'filename' => $filename]);

        if ($assetElement) {

            return $assetElement->getUrl();
        }

        // check if the given folder exists
        $volumeFolder = VolumeFolder::findOne(['path' => $destSettings['folder'], 'volumeId' => $volume->id]);
        if (!$volumeFolder) {
            $message = sprintf('Folder (path: "%s") in volume (handle: "%s") does not exist.', $destSettings['folder'], $destSettings['volume']);
            throw new \RuntimeException($message);
        }

        $asset = new Asset();
        $asset->volumeId = $volume->id;
        $asset->tempFilePath = $filePath;
        $asset->filename = $filename;
        $asset->folderId = $volumeFolder->id;

        Craft::$app->getElements()->saveElement($asset);
        @unlink($filePath);
        /** @scrutinizer ignore-unhandled */ @unlink($filePath);

        return $asset->getUrl();
    }
}

nystudio107 / craft-transcoder

Pull Request — v1 (#20)

Transcode::moveAssetToVolume() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
