文件转VID

VidProcessService/Utilities/VidConverter.cs

@@ -0,0 +1,188 @@
+using SkiaSharp;
+using DICOM = Dicom;
+using Dicom.Imaging;
+using Vinno.IUS.Common.Media.FFmpeg;
+using System.Diagnostics;
+
+namespace VidProcessService.Utilities
+{
+    public class VidConverter
+    {
+        private static string _ffmpegPath;
+        private string _tempfolder;
+
+        public VidConverter(string tempfolder)
+        {
+            if (!Directory.Exists(tempfolder))
+            {
+                Directory.CreateDirectory(tempfolder);
+            }
+            _tempfolder = tempfolder;
+            _ffmpegPath = GetFFmpegPath();
+        }
+
+        public long DicomToVid(string filePath, string targetPath)
+        {
+            var dicomFile = DICOM.DicomFile.Open(filePath);
+            var dataset = dicomFile.Dataset;
+            var dicomImage = new DicomImage(dataset);
+            using (var vidFile = new VidFile(targetPath))
+            {
+                vidFile.AddExtendedData(dataset);
+                vidFile.AddProbe(dataset);
+                vidFile.AddImages(dicomImage);
+            }
+            if (File.Exists(targetPath))
+            {
+                FileInfo fileInfo = new FileInfo(targetPath);
+                return fileInfo.Length;
+            }
+            return 0;
+        }
+
+        public long ImageToVid(string filePath, string targetPath)
+        {
+            FileStream fileStream =
+            new FileStream(filePath, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite);
+            // 读取文件的 byte[]
+            byte[] bytes = new byte[fileStream.Length];
+            fileStream.Read(bytes, 0, bytes.Length);
+            fileStream.Close();
+            using (var vidFile = new VidFile(targetPath))
+            {
+                using (MemoryStream ms = new MemoryStream(bytes))
+                {
+                    var skiaBitmap = SKBitmap.Decode(ms);
+                    vidFile.AddProbe(1);
+                    vidFile.AddImages(skiaBitmap.Width, skiaBitmap.Height, bytes);
+                }
+            }
+            if (File.Exists(targetPath))
+            {
+                FileInfo fileInfo = new FileInfo(targetPath);
+                return fileInfo.Length;
+            }
+            return 0;
+        }
+
+        /// <summary>
+        /// Mp4 to vid 
+        /// </summary>
+        /// <param name="filePath"></param>
+        /// <param name="targetPath"></param>
+        /// <returns></returns>
+        public long Mp4ToVid(string filePath, string targetPath)
+        {
+            var imageTempPathList = new List<string>();
+            string id = Guid.NewGuid().ToString();
+            var targetImageDirectory = Path.Combine(_tempfolder, id);
+            if (!Directory.Exists(targetImageDirectory))
+            {
+                Directory.CreateDirectory(targetImageDirectory);
+            }
+            ConvertImages(filePath, targetImageDirectory);//Mp4 to images
+            //生成Vid
+            ImagesToVid(targetImageDirectory, targetPath);//images to vid
+            if (File.Exists(targetPath))
+            {
+                FileInfo fileInfo = new FileInfo(targetPath);
+                return fileInfo.Length;
+            }
+            return 0;
+        }
+
+        private void ImagesToVid(string targetImageDirectory, string targetPath)
+        {
+            var filePaths = Directory.GetFiles(targetImageDirectory, "*.jpg");
+            using (var vidFile = new VidFile(targetPath))
+            {
+                foreach (var item in filePaths)
+                {
+                    FileStream fileStream =
+                    new FileStream(item, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite);
+                    // 读取文件的 byte[]
+                    byte[] bytes = new byte[fileStream.Length];
+                    fileStream.Read(bytes, 0, bytes.Length);
+                    fileStream.Close();
+                    using (MemoryStream ms = new MemoryStream(bytes))
+                    {
+                        var skiaBitmap = SKBitmap.Decode(ms);
+                        vidFile.AddProbe(1);
+                        vidFile.AddImages(skiaBitmap.Width, skiaBitmap.Height, bytes);
+                    }
+                }
+            }
+            if (Directory.Exists(targetImageDirectory))//清除images文件夹
+            {
+                Directory.Delete(targetImageDirectory, true);
+            }
+        }
+
+        private void ConvertImages(string sourcePath, string desfolderPath)
+        {
+            //TODO 需要计算帧率大小
+            //var argument = "-i " + sourcePath + " -y -vframes 1 -f mjpeg " + desfolderPath+"\\output%d.jpg";
+            //  var argument = "-i " + sourcePath + " -vf  fps=15  -vsync  vfr " + desfolderPath+"\\output%d.jpg";
+            var argument = "-i " + sourcePath + " " + Path.Combine(desfolderPath, "output%d.jpg");
+            var log = new FFmpegLog();
+            log.WriteArgs(argument);
+            Process process;
+            StartFFmpeg(out process, argument, log);
+            process.WaitForExit();
+        }
+
+        private static void StartFFmpeg(out Process process, string arguments, FFmpegLog logItem = null)
+        {
+            process = new Process
+            {
+                StartInfo =
+                {
+                    FileName = _ffmpegPath,
+                    Arguments = arguments,
+                    UseShellExecute = false,
+                    Verb = "runas",
+                    CreateNoWindow = true,
+                    RedirectStandardError = true,
+                    RedirectStandardInput = true
+                },
+                EnableRaisingEvents = true
+            };
+            if (logItem != null)
+            {
+                process.ErrorDataReceived += (s, e) => { };
+            }
+            process.Start();
+            process.BeginErrorReadLine();
+        }
+
+        /// <summary>
+        /// 获取 FFmpeg exe 路径
+        /// </summary>
+        /// <returns></returns>
+        private string GetFFmpegPath()
+        {
+            switch (Environment.OSVersion.Platform)
+            {
+                case PlatformID.Win32S:
+                    throw new NotSupportedException($"Not supported OS {Environment.OSVersion.Platform}");
+                case PlatformID.Win32Windows:
+                    throw new NotSupportedException($"Not supported OS {Environment.OSVersion.Platform}");
+                case PlatformID.Win32NT:
+                    return Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Packages", "ffmpeg.exe");
+                    break;
+                case PlatformID.WinCE:
+                    throw new NotSupportedException($"Not supported OS {Environment.OSVersion.Platform}");
+                case PlatformID.Unix:
+                    return Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Packages", "ffmpeg");
+                    break;
+                case PlatformID.Xbox:
+                    throw new NotSupportedException($"Not supported OS {Environment.OSVersion.Platform}");
+                case PlatformID.MacOSX:
+                    return Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Packages", "ffmpeg");
+                    break;
+                default:
+                    throw new NotSupportedException($"Not supported OS {Environment.OSVersion.Platform}");
+            }
+        }
+    }
+}

VidProcessService/Utilities/VidFile.cs

@@ -0,0 +1,143 @@
+using SkiaSharp;
+using Dicom.Imaging;
+using Vinno.vCloud.Common.Vid2;
+using Vinno.vCloud.Common.Vid2.Visuals;
+using System.Runtime.InteropServices;
+using Dicom;
+
+namespace VidProcessService.Utilities
+{
+    public class VidFile : IDisposable
+    {
+        private const int DefaultFrameRate = 0;
+        private readonly VinnoImageData _vinnoImageData;
+        public DicomFrameInfo DicomFrameInfo;
+        private int index = 0;
+
+        public VidFile(string targetPath)
+        {
+            _vinnoImageData = new VinnoImageData(targetPath, OperationMode.Create);
+        }
+
+        public void AddImages(DicomImage dicomImage)
+        {
+            var encoder = new VinnoImageEncoder();
+            for (int i = 0; i < dicomImage.NumberOfFrames; i++)
+            {
+                using (IImage image = dicomImage.RenderImage(i))
+                {
+                    var bytes = image.As<byte[]>();
+                    using (MemoryStream ms = new MemoryStream(bytes))
+                    {
+                        using (var skiaBitmap = new SKBitmap(dicomImage.Width, dicomImage.Height))
+                        {
+                            var imagePtr = Marshal.AllocHGlobal(bytes.Length);
+                            Marshal.Copy(bytes, 0, imagePtr, bytes.Length);
+                            skiaBitmap.SetPixels(imagePtr);
+                            //  var bytes1 = skiaBitmap.Encode(SKEncodedImageFormat.Jpeg, 100).ToArray();
+                            var vinnoImage = encoder.Encode(skiaBitmap);
+                            if (i == 0)
+                            {
+                                DicomFrameInfo.DicomFirstFrameData = vinnoImage.ImageData;
+                                DicomFrameInfo.FrameCount = dicomImage.NumberOfFrames;
+                            }
+                            index++;
+                            var visual = new Vinno2DVisual();
+                            visual.Modes.Add(new VinnoMode("HAR", "HAR", VinnoModeType.Tissue));
+                            visual.ActiveModeType = VinnoModeType.Tissue;
+                            var physicalCoordinateInfo = new VinnoLinearTVTissuePhysicalCoordinate(1, 0, 1, 0, 0);
+                            var logicalCoordinateInfo = new VinnoLogicalCoordinate(false, false,
+                                new VinnoRect(0, 0, 1, 1), VinnoUnit.None, VinnoUnit.None);
+                            visual.PhysicalCoordinates.Add(VinnoVisualAreaType.Tissue, physicalCoordinateInfo);
+                            visual.LogicalCoordinates.Add(VinnoVisualAreaType.Tissue, logicalCoordinateInfo);
+                            vinnoImage.Visuals.Add(visual);
+                            _vinnoImageData.AddImage(vinnoImage);
+                        }
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Add probe.
+        /// </summary>
+        /// <param name="dataSet">Dicom dataset</param>
+        public void AddProbe(DicomDataset dataSet)
+        {
+            var frame = GetFrameRate(dataSet);
+            var probe = new VinnoProbe("ThirdPart", VinnoProbeType.Linear, new VinnoApplication("ThirdPart", string.Empty, "ThirdPart", "ThirdPart", false), frame);
+            _vinnoImageData.AddProbe(probe);
+        }
+        /// <summary>
+        /// Add probe.
+        /// </summary>
+        /// <param name="dataSet">Dicom dataset</param>
+        public void AddProbe(int frame)
+        {
+            var probe = new VinnoProbe("ThirdPart", VinnoProbeType.Linear, new VinnoApplication("ThirdPart", string.Empty, "ThirdPart", "ThirdPart", false), frame);
+            _vinnoImageData.AddProbe(probe);
+        }
+        public void AddImages(int Width, int Height, byte[] e)
+        {
+            if (e == null || e.Length <= 0)
+            {
+                return;
+            }
+            if (Width <= 0 || Height <= 0)
+            {
+                return;
+            }
+            VinnoImage vinnoImage = new VinnoImage(index, Width, Height, e);
+            index++;
+            var visual = new Vinno2DVisual();
+            visual.Modes.Add(new VinnoMode("HAR", "HAR", VinnoModeType.Tissue));
+            visual.ActiveModeType = VinnoModeType.Tissue;
+            var physicalCoordinateInfo = new VinnoLinearTVTissuePhysicalCoordinate(1, 0, 1, 0, 0);
+            var logicalCoordinateInfo = new VinnoLogicalCoordinate(false, false,
+                new VinnoRect(0, 0, 1, 1), VinnoUnit.None, VinnoUnit.None);
+            visual.PhysicalCoordinates.Add(VinnoVisualAreaType.Tissue, physicalCoordinateInfo);
+            visual.LogicalCoordinates.Add(VinnoVisualAreaType.Tissue, logicalCoordinateInfo);
+            vinnoImage.Visuals.Add(visual);
+            _vinnoImageData.AddImage(vinnoImage);
+        }
+        /// <summary>
+        /// Add extended data.
+        /// </summary>
+        /// <param name="dataSet">Dicom dataset.</param>
+        public void AddExtendedData(DicomDataset dataSet)
+        {
+            var extendedData = VinnoExtendedDataGenerator.Generate(dataSet);
+            _vinnoImageData.ExtendedData = extendedData.ToBytes();
+        }
+        public void Dispose()
+        {
+            _vinnoImageData.Dispose();
+        }
+        private static int GetFrameRate(DicomDataset dataSet)
+        {
+            if (dataSet.Contains(DicomTag.CineRate))
+            {
+                var cineRate = dataSet.GetSingleValue<int>(DicomTag.CineRate);
+                if (cineRate > 0)
+                {
+                    return cineRate;
+                }
+            }
+
+            if (dataSet.Contains(DicomTag.RecommendedDisplayFrameRate))
+            {
+                var recommendedDisplayFrameRate = dataSet.GetSingleValue<int>(DicomTag.RecommendedDisplayFrameRate);
+                return recommendedDisplayFrameRate > 0 ? recommendedDisplayFrameRate : DefaultFrameRate;
+            }
+
+            return 1;
+        }
+
+    }
+    public struct DicomFrameInfo
+    {
+        public object DicomFirstFrameData;
+
+        public int FrameCount;
+    }
+}

VidProcessService/Utilities/VinnoExtendedDataGenerator.cs

@@ -0,0 +1,114 @@
+using Vinno.vCloud.Common.Vid2;
+using Dicom;
+
+namespace VidProcessService.Utilities
+{
+    public class VinnoExtendedDataGenerator
+    {
+        private readonly static List<VidTag> _uploadVidTags = new List<VidTag>()
+        {
+            new VidTag("0028","0030"),
+            new VidTag("0018","602E"),
+            new VidTag("0018","602C"),
+            new VidTag("0018","6024"),
+            new VidTag("0018","6026"),
+        };
+        public static VidExtendedData Generate(DicomDataset dataSet)
+        {
+            var dic = new Dictionary<VidTag, IVidValue>();
+            var vidExtendedData = new VidExtendedData(dic);
+            AddDicomItem(dic, dataSet);
+            return vidExtendedData;
+        }
+
+        private static void AddDicomItem(Dictionary<VidTag, IVidValue> dic, DicomDataset dataSet)
+        {
+
+            foreach (var item in dataSet)
+            {
+                var vidTag = new VidTag($"{item.Tag.Group:x4}".ToUpper(), $"{item.Tag.Element:x4}".ToUpper());
+                if (item is DicomStringElement element)
+                {
+                    AddVidValue(dic, vidTag, new VidStringValueElement(element.Get<string>()));
+                    continue;
+                }
+
+                if (item is DicomValueElement<ushort> uShortElement)
+                {
+                    AddVidValue(dic, vidTag, new VidUshortValueElement(uShortElement.Get<ushort>()));
+                    continue;
+                }
+
+                if (item is DicomValueElement<short> shortElement)
+                {
+                    AddVidValue(dic, vidTag, new VidShortValueElement(shortElement.Get<short>()));
+                    continue;
+                }
+
+                if (item is DicomValueElement<long> longElement)
+                {
+                    AddVidValue(dic, vidTag, new VidLongValueElement(longElement.Get<long>()));
+                    continue;
+                }
+
+                if (item is DicomValueElement<ulong> uLongElement)
+                {
+                    AddVidValue(dic, vidTag, new VidUlongValueElement(uLongElement.Get<ulong>()));
+                    continue;
+                }
+
+                if (item is DicomValueElement<double> doubleElement)
+                {
+                    AddVidValue(dic, vidTag, new VidDoubleValueElement(doubleElement.Get<double>()));
+                    continue;
+                }
+
+                if (item is DicomValueElement<int> intElement)
+                {
+                    AddVidValue(dic, vidTag, new VidIntegerValueElement(intElement.Get<int>()));
+                    continue;
+                }
+
+                if (item is DicomValueElement<uint> uIntElement)
+                {
+                    AddVidValue(dic, vidTag, new VidUintValueElement(uIntElement.Get<uint>()));
+                    continue;
+                }
+
+                if (item is DicomValueElement<byte> byteElement)
+                {
+                    AddVidValue(dic, vidTag, new VidByteValueElement(byteElement.Get<byte>()));
+                    continue;
+                }
+
+                if (item is DicomSequence doDicomSequence)
+                {
+                    foreach (var dataSetItem in doDicomSequence.Items)
+                    {
+                        AddDicomItem(dic, dataSetItem);
+                    }
+                }
+            }
+        }
+
+        private static void AddVidValue(Dictionary<VidTag, IVidValue> dic, VidTag vidTag, IVidValue vidValue)
+        {
+            var vidTagkey = dic.Keys.FirstOrDefault(v => v.Group == vidTag.Group && v.Element == vidTag.Element);
+            if (vidTagkey == null)
+            {
+                if (_uploadVidTags?.Count > 0)
+                {
+                    var uploadVidTag = _uploadVidTags.FirstOrDefault(v => v.Group == vidTag.Group && v.Element == vidTag.Element);
+                    if (uploadVidTag != null)
+                    {
+                        dic.Add(vidTag, vidValue);
+                    }
+                }
+                else
+                {
+                    dic.Add(vidTag, vidValue);
+                }
+            }
+        }
+    }
+}

VidProcessService/Utilities/VinnoImageEncoder.cs

@@ -0,0 +1,130 @@
+using SkiaSharp;
+using Vinno.vCloud.Common.Vid2;
+
+namespace VidProcessService.Utilities
+{
+    public class VinnoImageEncoder
+    {
+        private readonly float _xScale;
+        private readonly float _yScale;
+
+        private int _currentIndex;
+
+        public VinnoImageEncoder(float xScale = 1.0f, float yScale = 1.0f)
+        {
+            _currentIndex = -1;
+            _xScale = xScale;
+            _yScale = yScale;
+        }
+
+
+        /// <summary>
+        /// Convert bitmap to jpeg image bytes.
+        /// </summary>
+        /// <param name="image"></param>
+        /// <param name="compressLevel">The compress level for image, default is 75</param>
+        /// <returns></returns>
+        private byte[] ImageToBytes(SKBitmap image, long compressLevel = 80)
+        {
+            try
+            {
+                var newWidth = (int)(image.Width * _xScale);
+                var newHeight = (int)(image.Height * _yScale);
+                SKBitmap tempImage = image;
+                if (image.Width != newWidth || image.Height != newHeight)
+                {
+                    tempImage = image.Resize(new SKImageInfo(newWidth, newHeight), SKFilterQuality.None);
+                }
+                try
+                {
+                    using (var map = new SKPixmap(new SKImageInfo(tempImage.Width, tempImage.Height, tempImage.ColorType), tempImage.GetPixels()))
+                    {
+                        using (var stream = new SKDynamicMemoryWStream())
+                        {
+                            SKPixmap.Encode(stream, map, SKEncodedImageFormat.Jpeg, (int)compressLevel);
+                            return stream.CopyToData().ToArray();
+                        }
+                    }
+                }
+                catch (Exception exception)
+                {
+                    throw new Exception($"ImageToBytes error:{exception}");
+                }
+                finally
+                {
+                    tempImage.Dispose();
+                }
+            }
+            catch (Exception e)
+            {
+                // Logger.WriteLineError(
+                //     $"Vinno image encode error image width :{image.Width}, image height :{image.Height}, stack is {e}");
+            }
+
+            return new byte[0];
+        }
+
+
+        /// <summary>
+        /// Encode a bitmap to VinnoImage.
+        /// </summary>
+        /// <param name="image">The bitmap to be encoded.</param>
+        /// <returns>The VinnoImage</returns>
+        public VinnoImage Encode(SKBitmap image)
+        {
+            _currentIndex++;
+            return new VinnoImage(_currentIndex, image.Width, image.Height, ImageToBytes(image));
+        }
+
+
+        /// <summary>
+        /// Compress a VinnoImage to a 480p image with 50 quality.
+        /// </summary>
+        /// <param name="vinnoImage"></param>
+        /// <returns></returns>
+        public VinnoImage Compress(VinnoImage vinnoImage)
+        {
+            byte[] compressedData = vinnoImage.ImageData;
+            using (var ms = new MemoryStream(compressedData))
+            {
+                using (var image = SKBitmap.Decode(ms))
+                {
+                    //Get 480p ratio
+                    var ratio = (double)480 / image.Height;
+                    if (ratio < 1)
+                    {
+                        var width = (int)(image.Width * ratio);
+                        var height = (int)(image.Height * ratio);
+                        SKBitmap tempImage = image;
+                        if (image.Width != width || image.Height != height)
+                        {
+                            tempImage = image.Resize(new SKImageInfo(width, height), SKFilterQuality.High);
+                        }
+                        try
+                        {
+                            using (var map = new SKPixmap(new SKImageInfo(tempImage.Width, tempImage.Height, tempImage.ColorType), tempImage.GetPixels()))
+                            {
+                                using (var stream = new SKDynamicMemoryWStream())
+                                {
+                                    SKPixmap.Encode(stream, map, SKEncodedImageFormat.Jpeg, 50);
+                                    compressedData = stream.CopyToData().ToArray();
+                                }
+                            }
+                        }
+                        catch (Exception exception)
+                        {
+                            throw new Exception($"Compress error:{exception}");
+                        }
+                        finally
+                        {
+                            tempImage.Dispose();
+                        }
+                    }
+                }
+            }
+            var updater = new VinnoImageUpdater(vinnoImage);
+            updater.Update(compressedData);
+            return vinnoImage;
+        }
+    }
+}

VidProcessService/WingVinnoImageData.csproj

@@ -10,6 +10,7 @@
   </PropertyGroup>
 
   <ItemGroup>    
+    <PackageReference Include="fo-dicom" Version="4.0.7" />
     <PackageReference Include="SkiaSharp" Version="1.68.2.1" />
     <PackageReference Include="Vinno.IUS.Common.Media" Version="1.0.0.1" />
     <PackageReference Include="Vinno.vCloud.Common.Vid2" Version="1.0.0.1" />