public virtual IProcessManagerFFmpeg CreateFFmpeg(ProcessOptionsFFmpeg options = null, ProcessStartedEventHandler callback = null)
        {
            var Result = Create <IProcessManagerFFmpeg>(options, callback);

            Result.Setup(x => x.RunFFmpeg(It.IsAny <string>())).Callback((string s) => Result.Object.Run("ffmpeg.exe", s)).Returns(RunResult);
            return(Result.Object);
        }
        public void Options_SetOptionsFFmpeg_ReturnsSame()
        {
            var Manager = SetupManager();
            var Options = new ProcessOptionsFFmpeg();

            Manager.Options = Options;

            Assert.Equal(Options, Manager.Options);
        }
Exemple #3
0
        public void GetFrameCount_ParamOptions_ReturnsSame(string source)
        {
            var Info    = SetupInfo();
            var Options = new ProcessOptionsFFmpeg();

            Info.GetFrameCount(source, Options);

            Assert.Same(Options, factory.Instances[0].Options);
        }
Exemple #4
0
        public void GetVersion_ParamOptions_ReturnsSame()
        {
            var Info    = SetupInfo();
            var Options = new ProcessOptionsFFmpeg();

            Info.GetVersion(Options);

            Assert.Same(Options, factory.Instances[0].Options);
        }
Exemple #5
0
        public void Truncate_ParamOptions_ReturnsSame(string source, string destination, TimeSpan?startPos, TimeSpan?duration)
        {
            var Muxer   = SetupMuxer();
            var Options = new ProcessOptionsFFmpeg();

            var Result = Muxer.Truncate(source, destination, startPos, duration, Options);

            Assert.Same(Options, factory.Instances[0].Options);
        }
Exemple #6
0
        public void Concatenate_ParamOptions_ReturnsSame(IEnumerable <string> files, string destination)
        {
            var Muxer   = SetupMuxer();
            var Options = new ProcessOptionsFFmpeg();

            var Result = Muxer.Concatenate(files, destination, Options);

            Assert.Same(Options, factory.Instances[0].Options);
        }
Exemple #7
0
        public void ExtractVideo_ParamOptions_ReturnsSame(string source, string destination)
        {
            var Muxer   = SetupMuxer();
            var Options = new ProcessOptionsFFmpeg();

            var Result = Muxer.ExtractVideo(source, destination, Options);

            Assert.Same(Options, factory.Instances[0].Options);
        }
Exemple #8
0
        public void Muxe_Simple_ParamOptions_ReturnsSame(string videoFile, string audioFile, string destination)
        {
            var Muxer   = SetupMuxer();
            var Options = new ProcessOptionsFFmpeg();

            var Result = Muxer.Muxe(videoFile, audioFile, destination, Options);

            Assert.Same(Options, factory.Instances[0].Options);
        }
Exemple #9
0
        public void Muxe_StreamsList_ParamOptions_ReturnsSame(IEnumerable <FFmpegStream> fileStreams, string destination)
        {
            var Muxer   = SetupMuxer();
            var Options = new ProcessOptionsFFmpeg();

            var Result = Muxer.Muxe(fileStreams, destination, Options);

            Assert.Same(Options, factory.Instances[0].Options);
        }
Exemple #10
0
 private async void RunSimpleButton_Click(object sender, RoutedEventArgs e)
 {
     if (Validate())
     {
         ProcessOptionsFFmpeg Options = new ProcessOptionsFFmpeg(FFmpegDisplayMode.Interface, "Encoding to H264/AAC (Simple)");
         string Src = SourceTextBox.Text;
         string Dst = DestinationTextBox.Text;
         await Task.Run(() => {
             encoder.Encode(Src, "h264", "aac", null, Dst, Options);
         });
     }
 }
Exemple #11
0
        private CompletionStatus ExecuteComplex(string src, string dst)
        {
            string DstEncode  = GetPathWithoutExtension(dst) + "_.mp4";
            string DstExtract = GetPathWithoutExtension(dst) + "_.mkv";
            string DstAac     = GetPathWithoutExtension(dst) + "_.aac";

            jobId++;
            CompletionStatus Result;

            ffmpegManagerUI.Start(jobId, "Encoding to H264/AAC (Complex)");

            ProcessOptionsFFmpeg    OptionsMain = new ProcessOptionsFFmpeg(jobId, "", true);
            IProcessManager         ProcessMain = null;
            Task <CompletionStatus> TaskMain    = Task.Run(() => encoder.Encode(src, "h264", null, "", DstEncode, OptionsMain));

            ProcessOptionsFFmpeg Options = new ProcessOptionsFFmpeg(jobId, "Extracting Audio", false);

            Result = muxer.ExtractAudio(src, DstExtract, Options);
            if (Result == CompletionStatus.Success)
            {
                Options.Title = "Encoding Audio";
                Result        = encoder.Encode(DstExtract, null, "aac", null, DstAac, Options,
                                               (s, p) => ProcessMain = p.ProcessManager);
            }

            if (Result != CompletionStatus.Success)
            {
                ProcessMain?.Cancel();
            }

            TaskMain.Wait();
            CompletionStatus Result2 = TaskMain.Result;

            if (Result == CompletionStatus.Success && Result2 == CompletionStatus.Success)
            {
                Options.Title = "Muxing Audio and Video";
                Result        = muxer.Muxe(DstEncode, DstAac, dst, Options);
            }

            File.Delete(DstEncode);
            File.Delete(DstExtract);
            File.Delete(DstAac);
            ffmpegManagerUI.Stop(jobId);
            return(Result);
        }