WordPress

<?php


namespace App\Service;


use App\Entity\Stock;
use App\Event\VideoUploadedEvent;
use App\EventSubscriber\VideoEvent;
use App\EventSubscriber\VideoUploadedSubscriber;
use Doctrine\ORM\EntityManager;
use Doctrine\ORM\ORMException;
use FFMpeg\Coordinate\Dimension;
use FFMpeg\Coordinate\TimeCode;
use FFMpeg\FFMpeg;
use FFMpeg\FFProbe;
use FFMpeg\Filters\Video\ResizeFilter;
use FFMpeg\Format\Video\WebM;
use FFMpeg\Format\Video\WMV;
use FFMpeg\Format\Video\X264;
use Intervention\Image\ImageManager;
use Symfony\Component\EventDispatcher\EventDispatcher;
use Symfony\Component\Filesystem\Filesystem;
use Symfony\Component\HttpFoundation\File\Exception\FileException;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\Process\Process;
use Symfony\Component\Routing\Router;

class VideoHelper
{
    private $em;
    private $root_dir;
    private $water_mark;
    private $router;
    private $stock_dir;
    private $imageHelper;
    private $water_mark200;
    private $water_mark_SI;
    private $ffmpeg;

    public function __construct(EntityManager $em, Router $router ,$root_dir, $water_mark,$water_mark200,$water_mark_SI, $stock_dir, ImageHelper $imageHelper)
    {
        $this->em    = $em;
        $this->router    = $router;
        $this->root_dir    = $root_dir;
        $this->water_mark    = $water_mark;
        $this->water_mark200    = $water_mark200;
        $this->water_mark_SI    = $water_mark_SI;
        $this->stock_dir    = $stock_dir;
        $this->imageHelper = $imageHelper;
        $this->ffmpeg = FFMpeg::create();
    }

    public function generate($file_path, Stock $stock)
    {
        $file = new \SplFileInfo($file_path);
        $ext = $file->getExtension();
        $preview_name = uniqid("preview_").'.'.$ext;
        $large_name = uniqid("1080p_").'.'.$ext;
        $small_name = uniqid("480p_").'.'.$ext;

        $large_path = $this->stock_dir.DIRECTORY_SEPARATOR.$large_name;
        $small_path = $this->stock_dir.DIRECTORY_SEPARATOR.$small_name;

        try{

            $stock->setPreviewName($preview_name);
            $stock->setSmallImagePath($small_path);
            $stock->setLargeImagePath($large_path);
            $this->em->persist($stock);
            $this->em->flush();

            $dispatcher = new EventDispatcher();
            $videoUploadedEvent = new VideoUploadedEvent($stock);
            $dispatcher->addSubscriber(new VideoUploadedSubscriber($this->getParameter("stock_directory"), $this->getParameter("watermark")));
            $dispatcher->dispatch($videoUploadedEvent, VideoUploadedEvent::NAME);

            $message = "Success";

        }catch (\Exception $e){
            $message = $e->getMessage();
        }
        return new JsonResponse(["message"=>$message]);
    }

    public function generateVideoSizes(Stock $stock, $asynchronous = true)
    {
        $video = $stock->getLargeImagePath();

        $metadata = $this->fetchVideoMetaData($video);

        $duration = gmdate("H:i:s", (int)str_replace(",","",$metadata['duration']));

        $resolution = $metadata['resolution'];

        switch ($resolution){
            case '4K UHD':
                $medium_res = "1920x1080";
                $low_res = "1280x720";
                break;
            case '1080p':
                $medium_res = "1280x720";
                $low_res = "852x480";
                break;
            case '720p':
                $medium_res = "852x480";
                $low_res = "640x360";
                break;
            default:
                $medium_res = "1280x720";
                $low_res = "852x480";
        }

        $cmdAll = ' ffmpeg -i "$VIDEO" -i "$WATERMARK" \
                        -ss 00:00:00 -t '.$duration.' -async 1 \
                        -filter_complex \
                        "[0:v]scale=740:460[bg];[bg][1:v] overlay=x=(main_w-overlay_w)/2:y=(main_h-overlay_h)/2" \
                        -codec:a copy "$PREVIEW_PATH" \
                        -vf scale='.$medium_res.':flags=lanczos -c:v libx264 -preset slow -crf 21 "$MEDIUM_PATH" \
                        -vf scale='.$low_res.':flags=lanczos -c:v libx264 -preset slow -crf 21 "$SMALL_PATH"';


        //generate shareable image && thumb size
        $this->generateVideoShareableImage($stock);
        $this->generateVideoThumbSizes($stock);

        $process = new Process($cmdAll);

        $process->setTimeout(null);

        $file = new \SplFileInfo($video);


        if ($file){
            if ($asynchronous){
                $process->start(null, [
                    'VIDEO'=> $video,
                    'WATERMARK'=>$this->water_mark_SI,
                    'PREVIEW_PATH' => $this->stock_dir.DIRECTORY_SEPARATOR.$stock->getPreviewName(),
                    'MEDIUM_PATH' => $stock->getFilePath(),
                    'SMALL_PATH' => $stock->getSmallImagePath()
                ]);
            }else{
                $process->run(null, [
                    'VIDEO'=> $video,
                    'WATERMARK'=>$this->water_mark_SI,
                    'PREVIEW_PATH' => $this->stock_dir.DIRECTORY_SEPARATOR.$stock->getPreviewName(),
                    'MEDIUM_PATH' => $stock->getFilePath(),
                    'SMALL_PATH' => $stock->getSmallImagePath()
                ]);
            }

            $this->create_search_page_video($stock);

            $stock->setPublished(Stock::PUBLISHED_STOCK);
            $this->em->persist($stock);
            $this->em->flush();
        }
    }

    public function regenerateVideoSizes(Stock $stock, $asynchronous = true)
    {
        $video = $stock->getLargeImagePath();

        $metadata = $this->fetchVideoMetaData($video);

        $duration = gmdate("H:i:s", (int)str_replace(",","",$metadata['duration']));

        $resolution = $metadata['resolution'];

        switch ($resolution){
            case '4K UHD':
                $medium_res = "1920x1080";
                $low_res = "1280x720";
                break;
            case '1080p':
                $medium_res = "1280x720";
                $low_res = "852x480";
                break;
            case '720p':
                $medium_res = "852x480";
                $low_res = "640x360";
                break;
            default:
                $medium_res = "1280x720";
                $low_res = "852x480";
        }

        $cmdAll = 'ffmpeg -i "$VIDEO" -i "$WATERMARK" \
                        -ss 00:00:00 -t '.$duration.' -async 1 \
                        -filter_complex \
                        "[0:v]scale=740:460[bg];[bg][1:v] overlay=x=(main_w-overlay_w)/2:y=(main_h-overlay_h)/2" \
                        -codec:a copy "$PREVIEW_PATH" -y \
                        -vf scale='.$medium_res.':flags=lanczos -c:v libx264 -preset slow -crf 21 "$MEDIUM_PATH" -y \
                        -vf scale='.$low_res.':flags=lanczos -c:v libx264 -preset slow -crf 21 "$SMALL_PATH" -y ';


        //generate shareable image && thumb size
        $this->generateVideoShareableImage($stock);
        $this->generateVideoThumbSizes($stock);

        $process = new Process($cmdAll);

        $process->setTimeout(null);

        $file = new \SplFileInfo($video);
//        dd( [
//            'VIDEO'=> $video,
//            'WATERMARK'=>$this->water_mark_SI,
//            'PREVIEW_PATH' => $this->stock_dir.DIRECTORY_SEPARATOR.$stock->getPreviewName(),
//            'MEDIUM_PATH' => $stock->getFilePath(),
//            'SMALL_PATH' => $stock->getSmallImagePath()
//        ]);


        if ($file){
            if ($asynchronous){
                $process->start(null, [
                    'VIDEO'=> $video,
                    'WATERMARK'=>$this->water_mark_SI,
                    'PREVIEW_PATH' => $this->stock_dir.DIRECTORY_SEPARATOR.$stock->getPreviewName(),
                    'MEDIUM_PATH' => $stock->getFilePath(),
                    'SMALL_PATH' => $stock->getSmallImagePath()
                ]);
            }else{
                $process->run(null, [
                    'VIDEO'=> $video,
                    'WATERMARK'=>$this->water_mark_SI,
                    'PREVIEW_PATH' => $this->stock_dir.DIRECTORY_SEPARATOR.$stock->getPreviewName(),
                    'MEDIUM_PATH' => $stock->getFilePath(),
                    'SMALL_PATH' => $stock->getSmallImagePath()
                ]);
            }

            //$this->create_search_page_video($stock);

            $stock->setPublished(Stock::PUBLISHED_STOCK);
            $stock->setProcessed(true);
            $this->em->persist($stock);
            $this->em->flush();
        }
    }

    public function create_search_page_video(Stock $stock)
    {
        $video = $stock->getLargeImagePath();
        $metadata = $this->fetchVideoMetaData($video);
        $width = $metadata['width'];
        $height = $metadata['height'];
        $search_thumb_width = 400;
        $search_thumb_height = number_format($height * $search_thumb_width / $width);
        $search_thumb_height = ($search_thumb_height % 2) == 0 ? $search_thumb_height : $search_thumb_height + 1;

        //Generate video to display on search page
        $filename = "suraimages_{$stock->getSlug()}-{$stock->getSuraID()}-thumb.mp4";
        $search_display_file = $this->stock_dir.DIRECTORY_SEPARATOR.$filename;


        //resize
        $clip_cmd = "ffmpeg -ss 3 -i \"{$video}\" -c copy -t 5 \"{$search_display_file}\"";
        //dump($clip_cmd);
        try {
            $process_clip = new Process($clip_cmd);
            $process_clip->setTimeout(null);
            $process_clip->run();
        }catch (\Exception $exception){
            //dd($exception->getMessage());
        }


        $cmd = "ffmpeg -i \"{$video}\" -vf scale={$search_thumb_width}x{$search_thumb_height}:flags=lanczos -c:v libx264 -preset slow -crf 21 \"{$search_display_file}\"";
        //dd($cmd);

        $stock->setThumbWidth($search_thumb_width);
        $stock->setThumbHeight($search_thumb_height);

        $process_search_video = new Process($cmd);
        $process_search_video->setTimeout(null);
        try {
            $process_search_video->run();
        }catch (\Exception $exception){
            dd($exception->getMessage());
        }


        if (is_file($search_display_file)){

            $new_search_name = "search_".$filename;
            $new_file_path = $this->stock_dir.DIRECTORY_SEPARATOR.$new_search_name;

            $watermarked = $this->addVideoWatermark($search_display_file,$this->water_mark_SI,$new_file_path) ? 'Yes' : 'No';

            $filename = $watermarked ? $new_search_name : $filename;

            $stock->setSearchPageVideoName($filename);
            $this->em->persist($stock);
            $this->em->flush();


            return $watermarked;
        }else{
            dd('file was not processed');
        }
        $stock->setSearchPageVideoName($filename);
        $this->em->persist($stock);
        $this->em->flush();


        return false;
    }

    private function addVideoWatermark($path, $watermark, $newFile)
    {
        if (is_file($path)){
            $cmd_watermark = "ffmpeg -i \"{$path}\" -i \"{$watermark}\" \
                        -filter_complex \
                        \" [0:v]scale=640:360[bg];[bg][1:v] overlay=x=(main_w-overlay_w)/2:y=(main_h-overlay_h)/2\" \
                        -codec:a copy \"{$newFile}\"";
            //dd($cmd_watermark);
            $process_watermark = new Process($cmd_watermark);
            $process_watermark->setTimeout(null);

            try {
                $process_watermark->run();
                $fs = new Filesystem();
                $fs->remove($path);
                return true;
            }catch (\Exception $exception){
                return true;
            }

        }else{
        }
        return false;

    }

    public function generateVideoThumbSizes(Stock $stock)
    {
        return $this->imageHelper->setStockThumbSizes($stock);
    }

    public function generateVideoShareableImage(Stock $stock)
    {
        $stockId = $stock->getId();
        $suraId = $stock->getSuraID();
        $error = false;
        if ($stock->getType()->getId() == 5){
            $video = $stock->getFilePath();
            if ($video){
                if ($stock->getSharableImage() && is_file($this->stock_dir.DIRECTORY_SEPARATOR.$stock->getSharableImage())){
                    $fileSystem = new Filesystem();
                    $fileSystem->remove($this->stock_dir.DIRECTORY_SEPARATOR.$stock->getSharableImage());
                }

                //create shareable image
                $ffmpeg = FFMpeg::create();
                $date = new \DateTime("now",new \DateTimeZone("Africa/Nairobi"));
                try {
                    $videoObj = $ffmpeg->open($video);
                    $shareable_img = uniqid("shareable_").".jpg";
                    $frame = $videoObj->frame(TimeCode::fromSeconds(3));
                    $frame->save($this->stock_dir.DIRECTORY_SEPARATOR.$shareable_img);
                    $stock->setSharableImage($shareable_img);
                    $this->em->persist($stock);
                    $this->em->flush();

                    $log = $date->format("Y-m-d, h:i:s A")." - shareable image created successfully - create shareable image\n";

//                    file_put_contents("video_recreation.txt", $log,FILE_APPEND);

                    $message = "Shareable image created successfully. [Stock Id: $stockId, Sura Id: $suraId]";

                    //optimize the image for sharing
                    $optimize = $this->imageHelper->optimize_shareable_image($stock);
                    $error = $optimize['error'];
                    $message .= PHP_EOL. $optimize['message'];
                }catch (\Exception $exception){

                    $log = $date->format("Y-m-d, h:i:s A")." - ".$exception->getMessage()." [Stock Id: $stockId, Sura Id: $suraId] - create shareable image\n";

                    $message = "Error opening video: %s, [Stock id: $stockId, Sura id: $suraId]";
                    $error = true;

//                    file_put_contents("video_recreation.txt", $log,FILE_APPEND);
                }
            }else{
                $message = "No stock file found.[Stock id: $stockId, Sura id: $suraId]";
                $error = true;
            }
        }else{
            $message = "Sorry this stock is not a video. [Stock id: $stockId, Sura id: $suraId]";
            $error = true;
        }

        return [
            'error'=>$error,
            'message'=>$message
        ];
    }

    public function fetchVideoDuration($videoPath)
    {
        $info = [];

        $command = "ffprobe -i '$videoPath' -show_format -v quiet | sed -n 's/duration=//p'";
        exec($command,$info);

        return $info[0];
    }

    public function fetchVideoMetaData($file)
    {
        $target_file = $file;
        //Fetch information ht,wt,du,res,fps, size
        $ffprobe = FFProbe::create();

        $data = [];
        $data['width'] = "";
        $data['height'] = "";
        $data['resolution'] = "";
        $data['orientation'] = "";
        $data['fps'] = "";
        $data['size'] = "";
        $data['duration'] = "";


        try {
            $duration = $ffprobe->format($target_file)->get('duration'); //secs
            $size = $ffprobe->format($target_file)->get('size'); //bytes

            $size = number_format($size / 1000000,1);
            $duration = number_format($duration,0);

            $data['size'] = $size;
            $data['duration'] = $duration;

            $results = [];
            $res_cmd = "ffprobe -v error -select_streams v:0 -show_entries stream=width,height -of csv=s=x:p=0 \"".$target_file."\"";
            $fps_cmd = "ffprobe -v 0 -of compact=p=0 -select_streams 0 -show_entries stream=r_frame_rate \"".$target_file."\"";
            $rotation_cmd = "ffprobe -loglevel error -select_streams v:0 -show_entries stream_tags=rotate -of default=nw=1:nk=1 -i \"".$target_file."\"";
            exec($res_cmd,$results);
            exec($fps_cmd,$results);

            $rotation = null;
            $rotation = shell_exec($rotation_cmd);


            //fps
            $fps_r = null;
            foreach ($results as $key=>$value){
                if(strpos($value,"rate")){
                    $fps_r = $value;
                }
            }
            $fps = "";
            //$fps_r = count($results) >= 1 ? $results[1] : null;
            if ($fps_r){
                $fps_r = str_replace("r_frame_rate=","",$fps_r);
                $fps_ar = explode("/",$fps_r);
                $num = $fps_ar[0];
                $den = $fps_ar[1];

                $fps = number_format(($num/$den), 0);
            }
            $data['fps'] = $fps;
            //end fps

            //Width, height, resolution
            $res = count($results) > 0 ? $results[0] : null;

            $width = "";
            $height = "";

            if ($res){
                $data['resolution'] = $res;
                $res_ar = explode("x",$res);
                $width = $res_ar[0];
                $height = $res_ar[1];
            }
            $resolution = $this->resolution_mapper($width,$height);


            $orientation = $height >= $width ? "Portrait" : "Landscape";
            if ($rotation != null && trim($rotation) == '90' || trim($rotation) == '270'){
                $orientation = "Portrait";
            }

            $data['width'] = $width;
            $data['height'] = $height;
            $data['resolution'] = $resolution;
            $data['orientation'] = $orientation;

            //End width,height,res
        }catch (\Exception $exception){
           // dd($exception->getMessage());

        }

        return $data;
    }

    public function resolution_mapper($width,$height)
    {
        $res = $width."x".$height;

        $resolutions = [
            '480x360' => "360p",
            '640x360' => "360p",
            '852x480' => "480p",
            '854x480' => "480p",
            '720x576' => "576p",
            '1280x720' => "720p",
            '1920x1080' => "1080p",
            '3840x2160' => "4K UHD",
            '4096x2160' => "DCI 4K",
            '7680x4320' => "8K UHD",
        ];

        return array_key_exists($res,$resolutions) ? $resolutions[$res] : $res;
    }

    public function regenerate_video_thumbnail(Stock $stock)
    {
        if ($stock->getType()->getId() != 5){
            return false;
        }
        $target_file = $stock->getLargeImagePath();

        if (!is_file($target_file)){
            return false;
        }

        $metadata = $this->fetchVideoMetaData($target_file);

        $width = (double)$metadata['width'];
        $height = $metadata['height'];

        $thumb_width = 400;
        $thumb_height = number_format(($height * $thumb_width/$width),0);

        $ffmpeg = FFMpeg::create();
        $video = $ffmpeg->open($target_file);
        $clip = $video
            ->gif(TimeCode::fromSeconds(3),new Dimension($thumb_width, $thumb_height), 5);

        $clip->save($this->stock_dir.DIRECTORY_SEPARATOR.$stock->getThumbName());

        $stock->setThumbHeight($thumb_height);
        $stock->setThumbWidth($thumb_width);

        try {
            $this->em->persist($stock);
            $this->em->flush();
        } catch (ORMException $e) {
        }


        return [
            'height' => $thumb_height,
            'width' => $thumb_width,
        ];

    }
}