Tonspuren extrahieren?

using System.Diagnostics;
using Microsoft.Extensions.Configuration;

namespace FFmpegFileMerger
{
    class Program
    {
        private static string targetPath = AppDomain.CurrentDomain.BaseDirectory;
        private static IConfigurationRoot config;

        static void Main(string[] args)
        {
            //To ease debugging
            //args = new string[] { @"E:\Lets Play\MHGU\2 Edited\39-40\20180913_212456.MOV", @"E:\Lets Play\MHGU\2 Edited\39-40\20180913_215119.MOV", @"E:\Lets Play\MHGU\2 Edited\39-40\20180913_221741.MOV" };
            //args = new string[] { @"D:\LPAufnahmen\2022-02-26 13-57-08.mkv" };
            config = new ConfigurationBuilder().AddJsonFile("FFmpegFileMergerSettings.json").Build();

            try
            {
                if (args.Length == 0)
                {
                    endAndOutputResult(new List<string>() { "No arguments given. Press any key to exit." }, ConsoleColor.Red);
                }
                else
                {
                    List<string> messages = new List<string>();

                    if (args.Length == 1)
                    {
                        char action = acknowledgeMoveOrCopy(args[0]);
                        bool extract = acknowledgeAudioExtract();

                        if (action == 'n' && extract == false)
                        {
                            getVideoFps(args[0], messages);
                            messages.Add("Nothing done. Press any key to exit.");
                            endAndOutputResult(messages, ConsoleColor.Red);
                        }
                        else
                        {
                            string fileSuffix = string.Empty;
                            bool rename = acknowledgeRename();
                            fileSuffix = acknowledgeFileSuffix();
                            

                            string file = args[0];
                            string targetFile;
                            if (rename)
                            {
                                targetFile = Path.Combine(targetPath, new DirectoryInfo(targetPath).Name + fileSuffix + Path.GetExtension(file));
                            }
                            else
                            {
                                targetFile = Path.Combine(targetPath, Path.GetFileNameWithoutExtension(file) + fileSuffix + Path.GetExtension(file));
                            }


                            if (extract)
                            {
                                extractAudioFromVideoFile(file, Path.Combine(Path.GetDirectoryName(targetFile), Path.GetFileNameWithoutExtension(targetFile)), fileSuffix, messages);
                            }

                            if (action == 'c' || action == 'm')
                            {
                                processFile(args[0], action, targetFile, fileSuffix);
                                messages.Add(getMessage(action, rename));
                            }

                            getVideoFps(targetFile, messages);
                            messages.Add("Done. Press any key to exit.");
                            endAndOutputResult(messages, ConsoleColor.Green);
                        }
                    }

                    if (args.Length > 1)
                    {
                        if (acknowledgeMerge(args))
                        {
                            mergeVideoFiles(args, acknowledgeAudioExtractAfterVideoMerge(), acknowledgeFileSuffix(), messages);
                        }
                    }

                    endAndOutputResult(messages, ConsoleColor.Green);
                }
            }
            catch (Exception e)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine(e.ToString());
                Console.WriteLine("Error. Press any key to exit.");
                Console.ReadKey();
            }
        }

        private static string acknowledgeFileSuffix()
        {
            string suffix = string.Empty;
            Console.WriteLine("File Suffix for file name?");
            suffix= Console.ReadLine().ToLower();

            if (!string.IsNullOrWhiteSpace(suffix))
            {
                return suffix;
            }

            return string.Empty;
        }

        private static string getMessage(char action, bool rename)
        {
            string message;
            string actionWord;
            if (action == 'c')
            {
                actionWord = "copied";
            }
            else
            {
                actionWord = "moved";
            }

            message = "File " + actionWord;
            if (rename)
            {
                message += " and renamed";
            }

            message += ".";
            return message;
        }

        private static bool acknowledgeRename()
        {
            string choice = "";
            while (choice != "y" && choice != "n")
            {
                Console.WriteLine("Rename output file(s) to directory name? (y/n)");
                choice = Console.ReadLine().ToLower();
            }

            if (choice == "y")
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        private static void processFile(string file, char action, string targetFile, string fileSuffix)
        {
            if (action == 'c')
            {
                CopyFileExWrapper.CopyFile(file, targetFile, CopyFileOptions.FailIfDestinationExists, outputCopyProgress);
            }

            if(action == 'm')
            {
                Move(file, targetFile);
            }
        }

        private static char acknowledgeMoveOrCopy(string file)
        {
            Console.WriteLine("File: " + file);

            string choice = "";
            while (choice != "c" && choice != "m" && choice != "n")
            {
                Console.WriteLine("Copy or move file? (c/m/n)");
                choice = Console.ReadLine().ToLower();
            }

            return choice[0];
        }    

        private static bool acknowledgeAudioExtract()
        {
            string choice = "";
            while (choice != "y" && choice != "n")
            {
                Console.WriteLine("Exctract audio from file? (y/n)");
                choice = Console.ReadLine().ToLower();
            }

            if (choice == "y")
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        private static bool acknowledgeMerge(string[] files)
        {
            foreach (string file in files)
            {
                Console.WriteLine("Adding file " + file);
            }

            string choice = "";
            while (choice != "y" && choice != "n")
            {
                Console.WriteLine("Merge files to current directoy? (y/n)");
                choice = Console.ReadLine().ToLower();
            }

            if (choice == "y")
            {
                return true;
            }
            else
            {
                endAndOutputResult(new List<string>() { "Nothing done. Press any key to exit." }, ConsoleColor.Red);
                return false;
            }
        }

        private static bool acknowledgeAudioExtractAfterVideoMerge()
        {
            string choice = "";
            while (choice != "y" && choice != "n")
            {
                Console.WriteLine("Extract audio after merge? (y/n)");
                choice = Console.ReadLine().ToLower();
            }

            if (choice == "y")
            {
                return true;
            }
            else
            {

                return false;
            }
        }
    
        private static void extractAudioFromVideoFile(string file, string targetFileWithoutExtension, string fileSuffix, List<string> messages)
        {
            List<string> audioExtensions = getAudioFileExtensions(file);
            int audioCount = 0;
            string argumentString = "";

            foreach (string audioExtension in audioExtensions)
            {
                string targetFile = targetFileWithoutExtension + "-audioextract-" + (audioCount + 1) + audioExtension;

                argumentString += " -map a:" + audioCount + " -c copy \"" + targetFile + "\"";
                audioCount++;
            }

            ProcessStartInfo info = new ProcessStartInfo(config["FFmpegFilePath"], "-i \"" + file + "\"" + argumentString);
            info.UseShellExecute = false;

            using (Process p = Process.Start(info))
            {
                p.WaitForExit();
            }

            messages.Add("Command used for audio extract: " + info.FileName + " " + info.Arguments);
        }

        private static List<string> getAudioFileExtensions(string file)
        {
            List<string> extensions = new List<string>();

            ProcessStartInfo info = new ProcessStartInfo(config["MediaInfoCliFilePath"], $"--output=Audio;\"%Format% \" \"{ file }\"");
            info.UseShellExecute = false;
            info.RedirectStandardOutput = true;

            Dictionary<string, string> audioCodecsFileExtensions = new Dictionary<string, string>();
            foreach (IConfigurationSection child in config.GetSection("AudioCodecsFileExtensions").GetChildren())
            {
                //don't add sections to config.
                if(child.Key != null && child.Value!=null)
                {
                    audioCodecsFileExtensions.Add(child.Key, child.Value);
                }
            }

            using (Process p = Process.Start(info))
            {
                p.WaitForExit();
                string output;
                string[] parts;

                output = p.StandardOutput.ReadLine();
                output = output.Substring(0, output.Length - 1);
                parts = output.Split(' ');
                if (parts.Length > 0)
                {
                    foreach (string format in parts)
                    {
                        string formatLower = format.ToLower();
                        if (audioCodecsFileExtensions.ContainsKey(formatLower))
                        {
                            extensions.Add("." + audioCodecsFileExtensions[formatLower]);
                        }
                        else
                        {
                            extensions.Add("." + formatLower);
                        }
                    }
                }
            }

            if(extensions.Count > 0)
            {
                return extensions;
            }

            throw new ApplicationException("No audio codec information found.");
        }

        private static void getVideoFps(string file, List<string> messages)
        {
            ProcessStartInfo info = new ProcessStartInfo(config["MediaInfoCliFilePath"], $"--output=Video;\"%FrameRate_Mode% %FrameRate% \" \"{ file }\"");
            info.UseShellExecute = false;
            info.RedirectStandardOutput = true;

            messages.Add("Command used go get fps info r_frame_rate: " + info.FileName + " " + info.Arguments);

            using (Process p = Process.Start(info))
            {
                p.WaitForExit();
                string output;
                string[] parts;

                output = p.StandardOutput.ReadLine();
                output = output.Substring(0,  output.Length - 1);
                parts = output.Split(' ');

                if (parts.Length > 0)
                {
                    for (int i = 0; i < parts.Length / 2; i++)
                    {
                        messages.Add($"Video stream {i} frame rate: {parts[i * 2]} {parts[i * 2 + 1]}");
                    }

                    return;
                }
            }

            throw new ApplicationException("No video fps information found.");
        }

        private static void endAndOutputResult(List<string> messages, ConsoleColor color)
        {
            Console.ForegroundColor = color;
            Console.WriteLine(string.Empty);
            foreach (string message in messages)
            {
                if (message.Contains("frame rate") && !message.Contains("CFR 60.000"))
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.WriteLine(message);
                    Console.ForegroundColor = color;
                }
                else
                {
                    Console.WriteLine(message);
                }
            }

            Console.ReadKey();
        }

        private static void mergeVideoFiles(string[] files, bool extractAudioAfter, string fileSuffix, List<string> messages)
        {
            string inputFile = Path.Combine(targetPath, "input.txt");

            using (StreamWriter parameterFile = new StreamWriter(inputFile))
            {
                foreach (string file in files)
                {
                    parameterFile.WriteLine("file '" + file + "'");
                }
            }

            string targetFile = Path.Combine(targetPath, new DirectoryInfo(targetPath).Name) + fileSuffix + Path.GetExtension(files[0]);
            ProcessStartInfo info = new ProcessStartInfo(config["FFmpegFilePath"], "-f concat -safe 0 -i \""
                + inputFile + "\" -c copy \"" + targetFile + "\"");
            info.UseShellExecute = false;

            using (Process p = Process.Start(info))
            {
                p.WaitForExit();
            }

            messages.Add("Command used for file merge: " + info.FileName + " " + info.Arguments);


            if (extractAudioAfter)
            {
                extractAudioFromVideoFile(targetFile, Path.Combine(Path.GetFullPath(targetFile), Path.GetFileNameWithoutExtension(targetFile)), fileSuffix, messages);
            }

            getVideoFps(targetFile, messages);
            messages.Add("Done. Press any key to exit.");
        }

        public static void Move(string inputFilePath, string outputFilePath)
        {
            FileInfo inputFileInfo = new FileInfo(inputFilePath);
            FileInfo outputFileInfo = new FileInfo(outputFilePath);

            if (inputFileInfo.DirectoryName[0] == outputFileInfo.DirectoryName[0])
            {
                File.Move(inputFilePath, outputFilePath);
            }
            else
            {
                CopyFileExWrapper.CopyFile(inputFilePath, outputFilePath, CopyFileOptions.FailIfDestinationExists, outputCopyProgress);
                File.Delete(inputFilePath);
            }
        }

        /*public static void Copy(string inputFilePath, string outputFilePath)
        {
            int bufferSize = 1024 * 1024;

            using (FileStream targetFileStream = new FileStream(outputFilePath, FileMode.CreateNew, FileAccess.Write, FileShare.None))
            {
                using (FileStream sourceFileStream = new FileStream(inputFilePath, FileMode.Open, FileAccess.ReadWrite))
                {
                    targetFileStream.SetLength(sourceFileStream.Length);
                    int bytesRead = -1;
                    byte[] bytes = new byte[bufferSize];

                    double totalLength = sourceFileStream.Length;
                    while ((bytesRead = sourceFileStream.Read(bytes, 0, bufferSize)) > 0)
                    {
                        targetFileStream.Write(bytes, 0, bytesRead);
                        double percentage = Math.Round((targetFileStream.Position / totalLength) * 100, 2);
                        Console.Write("\rCopy/move progress: " + percentage + "%     ");
                    }
                }

                Console.WriteLine();
            }
        }*/

        public static int outputCopyProgress (long totalFileSize, long totalBytesTransferred,
                long streamSize, long streamBytesTransferred,
                int streamNumber, int callbackReason,
                IntPtr sourceFile, IntPtr destinationFile, IntPtr data)
        {
            double copyProgress = Math.Round((totalBytesTransferred / (double)totalFileSize) * 100.0, 2);
            Console.Write("\rCopy/move progress: " + copyProgress + "%     ");
            return (int)CopyAction.Continue;
        }
    }
}