Folour\Flavy\Flavy

Complexity

Total Complexity

28

Size/Duplication

Total Lines	325
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
B	info()	0	16	5
B	thumbnail()	0	24	5
A	from()	0	12	2
A	to()	0	12	2
A	aCodec()	0	7	1
A	vCodec()	0	8	1
A	aBitrate()	0	7	1
A	vBitrate()	0	7	1
A	channels()	0	7	1
A	sampleRate()	0	7	1
A	frameRate()	0	7	1
A	overwrite()	0	7	1
A	logTo()	0	7	1
A	run()	0	15	2
A	isPossible()	0	8	2

<?php namespace Folour\Flavy;

/**
 *
 * FFmpeg layer for Laravel 5.2
 * This is a fully reworked fork of http://github.com/rafasamp/sonus package.
 *
 * @author Vadim Bova <folour@gmail.com>
 * @link   http://github.com/folour | http://vk.com/folour
 *
 */

use \File;
use \Folour\Flavy\Extensions\Base;
use \Folour\Flavy\Exceptions\NotWritableException;
use \Folour\Flavy\Exceptions\FileNotFoundException;

class Flavy extends Base
{
    /**
     * Flavy version
     */
    const VERSION = '1.0.2';

    /**
     *
     * Array of command parameters from builder
     *
     * @var array
     */
    protected $parameters = [];

    /**
     *
     * Output file path
     *
     * @var string
     */
    protected $outputPath;

    /**
     *
     * Log path
     *
     * @var string
     */
    protected $logPath;

    /**
     *
     * Array of possible methods for execute
     *
     * @var array
     */
    private $nextContext = 'input';

    /**
     *
     * Flavy constructor.
     *
     * @param array $config
     */
    public function __construct(array $config)
    {
        parent::__construct($config);
    }

    /**
     *
     * Returns array (for json format) or string (for other formats) with file information
     *
     * @param string $file File path
     * @param string $format output format, supported json, xml and csv
     * @param bool   $decode decode json to array
     *
     *
     * @return array|string
     * @throws FileNotFoundException
     */
    public function info($file, $format = 'json', $decode = true)
    {
        $this->isPossible('input');
        if(!File::exists($file)) {
            throw new FileNotFoundException('The input file "'.$file.'" not exists!');
        }

        $format = in_array($format, ['json', 'xml', 'csv']) ? $format : 'json';
        $data = $this->runCmd('get_file_info', [$this->config['ffprobe_path'], $format, $file]);
        if($format == 'json' && $decode === true) {
            return json_decode($data, true);
        }

        return $data;

    }

    /**
     *
     * Create thumbnails from video
     *
     * @param string $file input file
     * @param string $outputPath output file path template
     * @param int $count thumbnails count
     * @param int|null $interval frames interval in seconds
     *
     * @return bool|string
     * @throws FileNotFoundException
     * @throws NotWritableException
     */
    public function thumbnail($file, $outputPath, $count = 1, $interval = null)
    {
        $this->isPossible('input');
        if(!File::exists($file)) {
            throw new FileNotFoundException('The input file "'.$file.'" not exists!');
        }
        if(!File::isWritable(dirname($outputPath))) {
            throw new NotWritableException('The output path "'.$outputPath.'" is not writable!');
        }

        if($interval == null) {

It seems like you are loosely comparing $interval of type integer|null against null; this is ambiguous if the integer can be zero. Consider using a strict comparison === instead.

            $interval = 10;
            $info = $this->info($file);
            if(is_array($info)) {
                $duration = $this->timestamp(explode('.', $info['format']['duration'])[0]);

                $interval = round($duration / $count);
            }
        }

        return $this->runCmd('get_thumbnails', [
            $this->config['ffmpeg_path'], $file, $interval, $count, $outputPath
        ]);
    }

    /**
     *
     * Set input file
     *
     * @param $file
     * @return $this
     * @throws FileNotFoundException
     */
    public function from($file)
    {
        $this->isPossible('input');
        if(!File::exists($file)) {
            throw new FileNotFoundException('The input file "'.$file.'" not exists!');
        }

        $this->parameters[] = sprintf('%s -i "%s"', $this->config['ffmpeg_path'], $file);
        $this->nextContext = 'output';

It seems like 'output' of type string is incompatible with the declared type array of property $nextContext.

        return $this;
    }

    /**
     *
     * Set output file
     *
     * @param string $outputPath
     *
     * @return $this
     * @throws NotWritableException
     */
    public function to($outputPath)
    {
        $this->isPossible('output');
        if(!File::isWritable(dirname($outputPath))) {
            throw new NotWritableException('The output path "'.$outputPath.'" is not writable!');
        }

        $this->outputPath = $outputPath;
        $this->nextContext = 'run_or_param';

It seems like 'run_or_param' of type string is incompatible with the declared type array of property $nextContext.

        return $this;
    }

    /**
     *
     * Set audio codec
     *
     * @param string $codec
     * @return $this
     */
    public function aCodec($codec)
    {
        $this->isPossible('run_or_param');
        $this->parameters[] = sprintf('-acodec %s', $codec);

        return $this;
    }

    /**
     *
     * Set video codec
     *
     * @param string $codec
     * @return $this
     */
    public function vCodec($codec)
    {
        $this->isPossible('run_or_param');

        $this->parameters[] = sprintf('-vcodec %s', $codec);

        return $this;
    }

    /**
     *
     * Set audio bitrate
     *
     * @param int $bitrate
     * @return $this
     */
    public function aBitrate($bitrate)
    {
        $this->isPossible('run_or_param');
        $this->parameters[] = sprintf('-b:a %dk', $bitrate);

        return $this;
    }

    /**
     *
     * Set video bitrate
     *
     * @param int $bitrate
     * @return $this
     */
    public function vBitrate($bitrate)
    {
        $this->isPossible('run_or_param');
        $this->parameters[] = sprintf('-b:v %dk', $bitrate);

        return $this;
    }

    /**
     *
     * Set audio channels
     *
     * @param int $channels
     * @return $this
     */
    public function channels($channels)
    {
        $this->isPossible('run_or_param');
        $this->parameters[] = sprintf('-ac %d', $channels);

        return $this;
    }

    /**
     *
     * Set audio sample rate
     *
     * @param int $rate
     * @return $this
     */
    public function sampleRate($rate)
    {
        $this->isPossible('run_or_param');
        $this->parameters[] = sprintf('-ar %d', $rate);

        return $this;
    }

    /**
     *
     * Set video frame rate
     *
     * @param int $rate
     * @return $this
     */
    public function frameRate($rate)
    {
        $this->isPossible('run_or_param');
        $this->parameters[] = sprintf('-r %d', $rate);

        return $this;
    }

    /**
     *
     * Overwrite output file
     *
     * @return $this
     */
    public function overwrite()
    {
        $this->isPossible('run_or_param');
        $this->parameters[] = '-y';

        return $this;
    }

    public function logTo($logPath)
    {
        $this->isPossible('run_or_param');
        $this->logPath = $logPath;

        return $this;
    }

    /**
     *
     * Run a conversion process
     *
     * @throws Exceptions\CmdException
     */
    public function run()
    {
        $this->parameters[] = sprintf('"%s"', $this->outputPath);
        if($this->logPath !== null) {
            $this->parameters[] = sprintf('>"%s" 2>&1', $this->logPath);
        }

        $command = implode(' ', $this->parameters);

        $this->parameters = [];
        $this->nextContext = 'input';

It seems like 'input' of type string is incompatible with the declared type array of property $nextContext.

        $this->logPath = $this->outputPath = null;

        $this->runCmd($command);
    }

    /**
     * @param string $context context name
     *
     * @return bool
     * @throws \BadMethodCallException
     */
    private function isPossible($context)
    {
        if($this->nextContext != $context) {
            throw new \BadMethodCallException('This method is not possible on this context');
        }

        return true;
    }
}