DynamicHLSPlaylist::parseLines() - Code Metrics - Inspection of "Encrypted HLS" - protonemedia/laravel-ffmpeg - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#262)

by Pascal

created 2020-12-22 10:27 UTC

DynamicHLSPlaylist::parseLines() A

↳ Parent: DynamicHLSPlaylist

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	1
nc	1
nop	1
dl	0
loc	3
rs	10
c	1
b	0
f	0

<?php

namespace ProtoneMedia\LaravelFFMpeg\Http;

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
use ProtoneMedia\LaravelFFMpeg\Filesystem\Disk;
use ProtoneMedia\LaravelFFMpeg\Filesystem\Media;

class DynamicHLSPlaylist
{
    /**
     * @var \ProtoneMedia\LaravelFFMpeg\Filesystem\Disk
     */
    private $disk;

    /**
     * @var \ProtoneMedia\LaravelFFMpeg\Filesystem\Media
     */
    private $media;

    /**
     * Callable to retrieve the path to the given key.
     *
     * @var callable
     */
    private $keyResolver;

    /**
     * Callable to retrieve the path to the given media.
     *
     * @var callable
     */
    private $mediaResolver;

    /**
     * @var array
     */
    private $keyCache = [];

    /**
     * @var array
     */
    private $mediaCache = [];

    /**
     * Uses the 'filesystems.default' disk as default.
     */
    public function __construct()
    {
        $this->disk = Disk::make(config('filesystems.default'));
    }

    /**
     * Set the disk to open files from.
     */
    public function fromDisk($disk): self
    {
        $this->disk = Disk::make($disk);

        return $this;
    }

    /**
     * Instantiates a Media object for the given path and clears the cache.
     */
    public function open(string $path): self
    {
        $this->media = Media::make($this->disk, $path);

        $this->keyCache   = [];
        $this->mediaCache = [];

        return $this;
    }

    public function setMediaResolver(callable $mediaResolver): self
    {
        $this->mediaResolver = $mediaResolver;

        return $this;
    }

    public function setKeyResolver(callable $keyResolver): self
    {
        $this->keyResolver = $keyResolver;

        return $this;
    }

    /**
     * Returns the resolved key filename from the cache or resolves it.
     *
     * @param string $key
     * @return string
     */
    public function resolveKeyFilename(string $key): string
    {
        if (array_key_exists($key, $this->keyCache)) {
            return $this->keyCache[$key];
        }

        return $this->keyCache[$key] = call_user_func($this->keyResolver, $key);
    }

    /**
     * Returns the resolved media filename from the cache or resolves it.
     *
     * @param string $key
     * @return string
     */
    public function resolveMediaFilename(string $media): string
    {
        if (array_key_exists($media, $this->mediaCache)) {
            return $this->mediaCache[$media];
        }

        return $this->mediaCache[$media] = call_user_func($this->mediaResolver, $media);
    }

    /**
     * Parses the lines into a Collection
     *
     * @param string $lines
     * @return \Illuminate\Support\Collection
     */
    private static function parseLines(string $lines): Collection
    {
        return Collection::make(preg_split('/\n|\r\n?/', $lines));
    }

    /**
     * Returns a boolean wether the line contains a .M3U8 playlist filename
     * or a .TS segment filename.
     *
     * @param string $line
     * @return boolean
     */
    private static function lineHasMediaFilename(string $line): bool
    {
        return !Str::startsWith($line, '#') && Str::endsWith($line, ['.m3u8', '.ts']);
    }

    /**
     * Returns the filename of the encryption key.
     *
     * @param string $line
     * @return string|null
     */
    private static function extractKeyFromExtLine(string $line): ?string
    {
        preg_match_all('/#EXT-X-KEY:METHOD=AES-128,URI="([a-zA-Z0-9-_\/]+.key)",IV=[a-z0-9]+/', $line, $matches);

        return $matches[1][0] ?? null;
    }

    /**
     * Returns the processed content of the master playlist.
     *
     * @return string
     */
    public function getMasterPlaylist(): string
    {
        return $this->get($this->media->getPath());
    }

    /**
     * Returns a collection of all processed segment playlists
     * and the processed master playlist.
     *
     * @return \Illuminate\Support\Collection
     */
    public function all(): Collection
    {
        return static::parseLines(
            $this->disk->get($this->media->getPath())
                         get($this->media->getPath())
        )->filter(function ($line) {
            return static::lineHasMediaFilename($line);
        })->mapWithKeys(function ($segmentPlaylist) {
            return [$segmentPlaylist => $this->get($segmentPlaylist)];
        })->prepend(
            $this->get($this->media->getPath()),
            $this->media->getPath()
        );
    }

    /**
     * Processes the given playlist.
     *
     * @param string $playlistPath
     * @return string
     */
    public function get(string $playlistPath): string
    {
        return static::parseLines($this->disk->get($playlistPath))->map(function (string $line) {
            if (static::lineHasMediaFilename($line)) {
                return $this->resolveMediaFilename($line);
            }

            $key = static::extractKeyFromExtLine($line);

            if (!$key) {
                return $line;
            }

            return str_replace(
                '#EXT-X-KEY:METHOD=AES-128,URI="' . $key . '"',
                '#EXT-X-KEY:METHOD=AES-128,URI="' . $this->resolveKeyFilename($key) . '"',
                $line
            );
        })->implode(PHP_EOL);
    }
}


protonemedia / laravel-ffmpeg

Pull Request — master (#262)

DynamicHLSPlaylist::parseLines() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like