VideoInfo::getVideoStreams() - Code Metrics - Inspection of "last fixes" - soluble-io/soluble-mediatools - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( ca89e3...264744 )

by Sébastien
created 2019-02-20 16:53 UTC
VideoInfo::getVideoStreams() A

↳ Parent: VideoInfo
Complexity

Conditions	3
Paths	4
Size

Total Lines	17
Code Lines	11
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	5
CRAP Score	4.4609
Importance

Changes
Metric	Value
cc	3
eloc	11
nc	4
nop	0
dl	0
loc	17
ccs	5
cts	11
cp	0.4545
crap	4.4609
rs	9.9
c	0
b	0
f	0
<?php

declare(strict_types=1);

/**
 * @see       https://github.com/soluble-io/soluble-mediatools for the canonical repository
 *
 * @copyright Copyright (c) 2018-2019 Sébastien Vanvelthem. (https://github.com/belgattitude)
 * @license   https://github.com/soluble-io/soluble-mediatools/blob/master/LICENSE.md MIT
 */

namespace Soluble\MediaTools\Video;

use Psr\Log\LoggerInterface;
use Psr\Log\LogLevel;
use Psr\Log\NullLogger;
use Soluble\MediaTools\Common\Exception\IOException;
use Soluble\MediaTools\Common\Exception\JsonParseException;
use Soluble\MediaTools\Video\Exception\InvalidArgumentException;
use Soluble\MediaTools\Video\Exception\InvalidStreamMetadataException;
use Soluble\MediaTools\Video\Info\AudioStreamCollection;
use Soluble\MediaTools\Video\Info\AudioStreamCollectionInterface;
use Soluble\MediaTools\Video\Info\VideoStreamCollection;
use Soluble\MediaTools\Video\Info\VideoStreamCollectionInterface;

class VideoInfo implements VideoInfoInterface
{
    /** @var array<string, mixed> */
    private $metadata;

    /** @var string */
    private $file;

    /** @var LoggerInterface */
    private $logger;

    /** @var array|null */
    private $metadataByStreamType;

    /** @var VideoStreamCollectionInterface|null; */
    private $cachedVideoStreams;

    /** @var AudioStreamCollectionInterface|null; */
    private $cachedAudioStreams;

    /**
     * @param string               $fileName reference to filename
     * @param array                $metadata metadata as parsed from ffprobe --json
     * @param LoggerInterface|null $logger
     */
    public function __construct(string $fileName, array $metadata, ?LoggerInterface $logger = null)
    {
        if (!file_exists($fileName)) {
            throw new IOException(sprintf(
                'File %s does not exists',
                $this->file
            ));
        }
        $this->metadata = $metadata;
        $this->file     = $fileName;
        $this->logger   = $logger ?? new NullLogger();
    }

    /**
     * @throws JsonParseException if json is invalid
     */
    public static function createFromFFProbeJson(string $fileName, string $ffprobeJson, ?LoggerInterface $logger = null): self
    {
        if (trim($ffprobeJson) === '') {
            throw new JsonParseException('Cannot parse empty json string');
        }
        $decoded = json_decode($ffprobeJson, true);
        if ($decoded === null) {
            throw new JsonParseException('Cannot parse json');
        }

        return new self($fileName, $decoded, $logger);
    }

    public function getFile(): string
    {
        return $this->file;
    }

    /**
     * @throws IOException
     */
    public function getFileSize(): int
    {
        $size = @filesize($this->file);
        if ($size === false) {
            $msg = sprintf('Cannot get filesize of file %s', $this->file);
            $this->logger->log(LogLevel::ERROR, $msg);
            throw new IOException($msg);
        }

        return $size;
    }

    /**
     * Return VideoStreams as a collection.
     *
     * @throws InvalidStreamMetadataException
     */
    public function getVideoStreams(): VideoStreamCollectionInterface
    {
        if ($this->cachedVideoStreams === null) {
            try {
                $videoStreamsMetadata     = array_values($this->getStreamsMetadataByType(self::STREAM_TYPE_VIDEO));
                $this->cachedVideoStreams = new VideoStreamCollection($videoStreamsMetadata);
            } catch (InvalidStreamMetadataException $e) {
                $this->logger->log(LogLevel::ERROR, sprintf(
                    'Cannot get video streams info for file: %s, message is: %s',
                    $this->file,
                    $e->getMessage()
                ));
                throw $e;
            }
        }

        return $this->cachedVideoStreams;
    }

    /**
     * Return VideoStreams as a collection.
     *
     * @throws InvalidStreamMetadataException
     */
    public function getAudioStreams(): AudioStreamCollectionInterface
    {
        if ($this->cachedAudioStreams === null) {
            try {
                $audioStreamsMetadata     = array_values($this->getStreamsMetadataByType(self::STREAM_TYPE_AUDIO));
                $this->cachedAudioStreams = new AudioStreamCollection($audioStreamsMetadata);
            } catch (InvalidStreamMetadataException $e) {
                $this->logger->log(LogLevel::ERROR, sprintf(
                    'Cannot get audio streams info for file: %s, message is: %s',
                    $this->file,
                    $e->getMessage()
                ));
                throw $e;
            }
        }

        return $this->cachedAudioStreams;
    }

    /**
     * Format name as returned by ffprobe.
     */
    public function getFormatName(): string
    {
        return $this->metadata['format']['format_name'];
    }

    /**
     * @param string $streamType any of self::SUPPORTED_STREAM_TYPES
     */
    public function countStreams(?string $streamType = null): int
    {
        if ($streamType === null) {
            return count($this->metadata['streams'] ?? []);
        }

        return count($this->getStreamsMetadataByType($streamType));
    }

    /**
     * Return metadata as received by ffprobe.
     *
     * @return array<string, array>
     */
    public function getMetadata(): array
    {
        return $this->metadata;
    }

    /**
     * Return total duration.
     */
    public function getDuration(): float
    {
        return (float) ($this->metadata['format']['duration'] ?? 0.0);
    }

    /**
     * @deprecated
     *
     * @param int $streamIndex selected a specific stream by index, default: 0 = the first available
     *
     * @return array<string, int> associative array with 'height' and 'width'
     */
    public function getDimensions(int $streamIndex = 0): array
    {
        return [
            'width'  => $this->getWidth($streamIndex),
            'width'  => /** @scrutinizer ignore-deprecated */ $this->getWidth($streamIndex),
            'height' => $this->getHeight($streamIndex),
            'height' => /** @scrutinizer ignore-deprecated */ $this->getHeight($streamIndex),
        ];
    }

    /**
     * @deprecated
     *
     * @param int $streamIndex selected a specific stream by index, default: 0 = the first available
     */
    public function getWidth(int $streamIndex = 0): int
    {
        $videoStream = $this->getVideoStreamsMetadata()[$streamIndex] ?? [];

        return (int) ($videoStream['width'] ?? 0);
    }

    /**
     * @deprecated
     *
     * @param int $streamIndex selected a specific stream by index, default: 0 = the first available
     */
    public function getHeight(int $streamIndex = 0): int
    {
        $videoStream = $this->getVideoStreamsMetadata()[$streamIndex] ?? [];

        return (int) ($videoStream['height'] ?? 0);
    }

    /**
     * @deprecated
     *
     * @param int $streamIndex selected a specific stream by index, default: 0 = the first available
     */
    public function getNbFrames(int $streamIndex = 0): int
    {
        $videoStream = $this->getVideoStreamsMetadata()[$streamIndex] ?? [];

        return (int) ($videoStream['nb_frames'] ?? 0);
    }

    /**
     * @deprecated
     *
     * @param int $streamIndex selected a specific stream by index, default: 0 = the first available
     */
    public function getVideoBitrate(int $streamIndex = 0): int
    {
        $videoStream = $this->getVideoStreamsMetadata()[$streamIndex] ?? [];

        return (int) ($videoStream['bit_rate'] ?? 0);
    }

    /**
     * @deprecated
     *
     * @param int $streamIndex selected a specific stream by index, default: 0 = the first available
     */
    public function getAudioBitrate(int $streamIndex = 0): int
    {
        $audioStream = $this->getAudioStreamsMetadata()[$streamIndex] ?? [];

        return (int) ($audioStream['bit_rate'] ?? 0);
    }

    /**
     * @deprecated
     *
     * @param int $streamIndex selected a specific stream by index, default: 0 = the first available
     */
    public function getAudioCodecName(int $streamIndex = 0): ?string
    {
        $audioStream = $this->getAudioStreamsMetadata()[$streamIndex] ?? [];

        return $audioStream['codec_name'] ?? null;
    }

    /**
     * @deprecated
     *
     * @param int $streamIndex selected a specific stream by index, default: 0 = the first available
     */
    public function getVideoCodecName(int $streamIndex = 0): ?string
    {
        $videoStream = $this->getVideoStreamsMetadata()[$streamIndex] ?? [];

        return $videoStream['codec_name'] ?? null;
    }

    /**
     * @return array<int, array>
     */
    public function getAudioStreamsMetadata(): array
    {
        return array_values($this->getStreamsMetadataByType(self::STREAM_TYPE_AUDIO));
    }

    /**
     * @return array<int, array>
     */
    public function getVideoStreamsMetadata(): array
    {
        return array_values($this->getStreamsMetadataByType(self::STREAM_TYPE_VIDEO));
    }

    /**
     * @throws InvalidArgumentException
     *
     * @param string $streamType  any of self::SUPPORTED_STREAM_TYPES
     * @param int    $streamIndex selected a specific stream by index, default: 0 = the first available
     *
     * @return array<string|int, array>
     *
     * @throws InvalidStreamMetadataException
     */
    public function getStreamsMetadataByType(string $streamType, int $streamIndex = 0): array
    {
        if (!in_array($streamType, self::SUPPORTED_STREAM_TYPES, true)) {
            $msg = sprintf(
                'Invalid usage, unsupported param $streamType given: %s',
                $streamType
            );
            $this->logger->log(LogLevel::ERROR, $msg);
            throw new InvalidArgumentException($msg);
        }

        return $this->getMetadataByStreamType()[$streamType];
    }

    /**
     * @throws InvalidStreamMetadataException
     */
    private function getMetadataByStreamType(): array
    {
        if ($this->metadataByStreamType === null) {
            try {
                $streams = [
                    self::STREAM_TYPE_VIDEO => [],
                    self::STREAM_TYPE_AUDIO => [],
                    self::STREAM_TYPE_DATA  => [],
                ];
                if (!is_array($this->metadata['streams'])) {
                    throw new InvalidStreamMetadataException(sprintf(
                        'Invalid or unsupported stream metadata returned by ffprobe: %s',
                        (string) json_encode($this->metadata)
                    ));
                }

                foreach ($this->metadata['streams'] as $stream) {
                    if (!is_array($stream)) {
                        throw new InvalidStreamMetadataException(sprintf(
                            'Stream metadata returned by ffprobe must be an array: %s',
                            (string) json_encode($stream)
                        ));
                    }

                    if (!isset($stream['codec_type'])) {
                        throw new InvalidStreamMetadataException(sprintf(
                            'Missing codec_type information in metadata returned by ffprobe: %s',
                            (string) json_encode($stream)
                        ));
                    }

                    $type = mb_strtolower($stream['codec_type']);
                    switch ($type) {
                        case self::STREAM_TYPE_VIDEO:
                            $streams[self::STREAM_TYPE_VIDEO][] = $stream;
                            break;
                        case self::STREAM_TYPE_AUDIO:
                            $streams[self::STREAM_TYPE_AUDIO][] = $stream;
                            break;
                        case self::STREAM_TYPE_DATA:
                            $streams[self::STREAM_TYPE_DATA][] = $stream;
                            break;
                        default:
                            $streams[$type][] = $stream;
                    }
                }

                $this->metadataByStreamType = $streams;
            } catch (InvalidStreamMetadataException $e) {
                $this->logger->log(LogLevel::ERROR, sprintf(
                    'Cannot read metadata for file: %s. Failed with message: %s',
                    $this->file,
                    $e->getMessage()
                ));
                throw $e;
            }
        }

        return $this->metadataByStreamType;
    }
}

soluble-io / soluble-mediatools

Push — master ( ca89e3...264744 )

VideoInfo::getVideoStreams() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
