Вывод ffmpeg по видео

private async Task AddFileToUI(string filePath)
        {
            try
            {
                string fileName = Path.GetFileName(filePath);
                logText += $"Start of metadata processing for {fileName}" + Environment.NewLine;
 
                // Создаем команду для выполнения
                string command = $" -hide_banner -i \"{filePath}\"";
                logText += $"Command metadata processing for {command}" + Environment.NewLine;
 
                // Выполняем команду и записываем вывод в файл
                string outputFilePath = Path.ChangeExtension(filePath, "txt");
 
                string output = await ExecuteFFmpegCommandAsync(command);
 
                // Извлекаем нужную информацию из вывода FFmpeg
                var videoInfo = ExtractVideoInfo(output);
                var audioInfos = ExtractAudioInfos(output);
 
                // Создаем информацию о файле
                var fileInfo = CreateFileInfo(videoInfo, audioInfos, filePath);
 
                // Сохраняем информацию о файле в текстовый файл
                SaveFileInfoToFile(outputFilePath, fileInfo, output);
 
                // собираем информуцю для UI
                var finalFileInfo = CreateFileInfo(videoInfo, audioInfos, filePath);
 
                // Вызов метода UpdateUI с информацией о файле
                UpdateUI(filePath, finalFileInfo);                
 
                logText += $"Finish of metadata processing for {fileName}" + Environment.NewLine + Environment.NewLine;
                //CreateSnapshots(queue, fileName, filePath, snapshotsOutputDirectory, videoDurationDictionary, videoFPSDictionary);
            }
            catch (Exception ex)
            {
                // Обработать ошибку и уведомить пользователя
                HandleError(filePath, ex);
            }
        }
        
        private async Task<string> ExecuteFFmpegCommandAsync(string command)
        {
            using (var process = new Process())
            {
                process.StartInfo.FileName = ffmpegPath;
                process.StartInfo.Arguments = command;
                process.StartInfo.UseShellExecute = false;
                process.StartInfo.RedirectStandardError = true;
                process.StartInfo.CreateNoWindow = true;
 
                process.Start();
 
                var output = process.StandardError.ReadToEnd(); // Ждем завершения и считываем вывод
 
                process.WaitForExit();
 
                return output;
            }
        }
 
 
        private string RemoveTextInBrackets(string input)
        {
            // Удаляем текст в скобках
            var withoutBrackets = Regex.Replace(input, @"\([^()]*\)", "").Trim();
 
            // Удаляем запятую после скобок, если она есть
            return withoutBrackets.Replace(",", "").Trim();
        }
 
        private Dictionary<string, string> ExtractVideoInfo(string output)
        {
            var videoInfo = new Dictionary<string, string>();
            var durationPattern = @"Duration:\s*(\S+)";
            var bitratePattern = @"bitrate:\s*(\S+)";
            var codecPattern = @"Video:\s*([^,]+)";
 
            var durationMatch = Regex.Match(output, durationPattern);
            if (durationMatch.Success)
            {
                videoInfo["Duration"] = durationMatch.Groups[1].Value;
 
            }
 
            var bitrateMatch = Regex.Match(output, bitratePattern);
            if (bitrateMatch.Success)
            {
                videoInfo["Bitrate"] = bitrateMatch.Groups[1].Value;
            }
 
            var codecMatch = Regex.Match(output, codecPattern);
            if (codecMatch.Success)
            {
                videoInfo["Codec"] = codecMatch.Groups[1].Value;
            }
 
            return videoInfo;
        }
 
        private List<Dictionary<string, string>> ExtractAudioInfos(string output)
        {
            var audioInfos = new List<Dictionary<string, string>>();
            var lines = output.Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
            var currentAudioInfo = new Dictionary<string, string>();
            var audioInfoRegex = new Regex(@"Stream #\d+:\d+(.*?)Audio:\s(.*?)\s(\d+)\sHz,\s(.*?),\s(\d+)\skb/s");
 
            foreach (var line in lines)
            {
                if (line.Contains("Stream #") && line.Contains("Audio:"))
                {
                    if (currentAudioInfo.Count > 0)
                    {
                        audioInfos.Add(currentAudioInfo);
                        currentAudioInfo = new Dictionary<string, string>();
                    }
 
                    var match = audioInfoRegex.Match(line);
                    if (match.Success)
                    {
                        currentAudioInfo["Stream"] = match.Groups[1].Value.Trim();
                        currentAudioInfo["Codec"] = match.Groups[2].Value.Trim();
                        currentAudioInfo["Sample_rate"] = match.Groups[3].Value.Trim();
                        currentAudioInfo["Channel_format"] = match.Groups[4].Value.Trim();
                        currentAudioInfo["Bitrate"] = match.Groups[5].Value.Trim();
                    }
                }
                else if (currentAudioInfo.Count > 0)
                {
                    // Обработка других параметров аудио, если необходимо
                }
            }
 
            // Добавляем последний поток, если он есть
            if (currentAudioInfo.Count > 0)
            {
                audioInfos.Add(currentAudioInfo);
            }
 
            return audioInfos;
        }
        private string CreateFileInfo(Dictionary<string, string> videoInfo, List<Dictionary<string, string>> audioInfos, string filePath)
        {
            var fileInfoBuilder = new StringBuilder();
 
            // Добавляем информацию о длительности и битрейте видео
            if (videoInfo.TryGetValue("Duration", out string duration) && videoInfo.TryGetValue("Bitrate", out string bitrate))
            {                
                fileInfoBuilder.AppendLine($"Duration: {duration} Bitrate: {bitrate} kb/s");               
            }
 
            // Добавляем информацию о видео-кодеке
            if (videoInfo.TryGetValue("Codec", out string videoCodec))
            {
                videoCodec = RemoveTextInBrackets(videoCodec);
                fileInfoBuilder.AppendLine($"Video: {videoCodec}");
            }
 
            // Добавляем информацию о каждом аудио-потоке
            for (int i = 0; i < audioInfos.Count; i++)
            {
                var audioInfo = audioInfos[i];
                if (audioInfo.TryGetValue("Codec", out string audioCodec))
                {
                    audioCodec = RemoveTextInBrackets(audioCodec);
                    fileInfoBuilder.AppendLine($"Audio: {audioCodec}");
                }
            }
 
 
            return fileInfoBuilder.ToString();
        }
 
        private void SaveFileInfoToFile(string filePath, string fileInfo, string output)
        {
            
            string fileName = Path.GetFileName(filePath);
            string outputFilePath = Path.ChangeExtension(filePath, "txt");
            // вот тут нужно сделать запись в текстовый файл с метаданными
            File.WriteAllText(outputFilePath, resultText);
        }
 
 
 
        private void UpdateUI(string filePath, string finalFileInfo)
        {
            // Создайте экземпляр VideoFileData и заполните его данными
            var videoFileData = new VideoFileData
            {
                FileName = Path.GetFileName(filePath),
                FilePath = filePath,
                FileInfo = finalFileInfo
            };
 
            videoFilesData.Add(videoFileData);
            // Обновите интерфейс с информацией о файле
            Dispatcher.Invoke(() =>
            {
                lock (processedFilesLock)
                {
                    if (!processedFiles.Contains(filePath))
                    {
                        VideoList.Items.Add(videoFileData);
                        processedFiles.Add(filePath);
                    }
                }
            });
        }
        private void HandleError(string filePath, Exception ex)
        {
            System.Windows.MessageBox.Show("Error, wrong metadata!", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
            return;
        }

process.StandardOutput.ReadToEnd();