linux compatibility support on native code

Author: ReferenceType

Examples/AVRecord/MainWindow.xaml.cs

@@ -41,8 +41,8 @@ public partial class MainWindow :System.Windows.Window
         private H264Decoder decoder;
         private Stream s;
         private AviWriter writer;
-        const int w = 1920;
-        const int h = 1080;
+        const int w = 640;
+        const int h = 480;
         object mtex = new object();
         int numThreads = 4;
         public MainWindow()

Examples/H264SharpNativePInvoke/H264SharpNative-win64.dll

@@ -39,10 +39,16 @@ static void Main(string[] args)
             Stopwatch sw = Stopwatch.StartNew();
             var data = BitmapToImageData(bmp);
 
+            //Converter converter = new Converter();
+            //RgbImage to = new RgbImage(data.Width / 2, data.Height / 2);
+            //converter.Downscale(data,to,2);
+            //var bb = RgbToBitmap(to);
+            //bb.Save("Dowmscaled.bmp");
+
             RgbImage rgbb = new RgbImage(w, h);
             for (int j = 0; j < 1000; j++)
             {
-               
+              
                 if(!encoder.Encode(data, out EncodedData[] ec))
                 {
                     Console.WriteLine("skipped");
@@ -104,7 +110,7 @@ private static Bitmap RgbToBitmap(RgbImage img)
          * On a little-endian machine, like yours and many others,
          * the little end is stored first, so the byte order is b g r a.
          */
-        private static H264Sharp.ImageData BitmapToImageData(Bitmap bmp)
+        private static ImageData BitmapToImageData(Bitmap bmp)
         {
             int width = bmp.Width;
             int height = bmp.Height;

Examples/H264SharpNativePInvoke/Program.cs

@@ -7,6 +7,7 @@ namespace H264Sharp
 {
     public class Converter
     {
+        //todo
         [DllImport(Defines.WrapperDllName64bit, EntryPoint = "GetDecoder", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Unicode)]
         private static extern void RGBtoYUVx64(ref RGBImagePointer rgb, ref YUVImagePointer yuv, int numThreads);
 
@@ -18,10 +19,96 @@ public class Converter
 
         [DllImport(Defines.WrapperDllName32bit, EntryPoint = "DecodeAsRGB", CallingConvention = CallingConvention.Cdecl)]
         private static extern void YUV2RGBx86(ref YUVImagePointer rgb, ref RGBImagePointer yuv, int numThreads);
+        //
+
+        [DllImport(Defines.WrapperDllName32bit, EntryPoint = "DownscaleImg", CallingConvention = CallingConvention.Cdecl)]
+        private static extern void DownscaleImgx86(ref UnsafeGenericImage from, ref UnsafeGenericImage to, int mul);
+
+        [DllImport(Defines.WrapperDllName64bit, EntryPoint = "DownscaleImg", CallingConvention = CallingConvention.Cdecl)]
+        private static extern void DownscaleImgx64(ref UnsafeGenericImage from, ref UnsafeGenericImage to, int mul);
+        
+
+
+        private readonly bool x64 = Environment.Is64BitProcess;
+
+        public void Downscale(ImageData from, RgbImage to, int multiplier)
+        {
+            unsafe
+            {
+                if (from.isManaged)
+                {
+                    fixed (byte* dp = &from.data[from.dataOffset])
+                    {
+                        var ugi = new UnsafeGenericImage()
+                        {
+                            ImageBytes = dp,
+                            Width = from.Width,
+                            Height = from.Height,
+                            Stride = from.Stride,
+                            ImgType = from.ImgType,
+                        };
+
+                        var t = new UnsafeGenericImage();
+
+                        t.ImageBytes = (byte*)to.ImageBytes;
+                        t.Width = from.Width;
+                        t.Height = from.Height;
+                        t.Stride = from.Stride;
+                        t.ImgType = ImageType.Rgb;
+
+                        if (x64)
+                        {
+                            DownscaleImgx64(ref ugi, ref t, multiplier);
+                        }
+                        else
+                        {
+                            DownscaleImgx86(ref ugi, ref t, multiplier);
+                        }
+
+                    }
+                }
+                else
+                {
+
+                    var ugi = new UnsafeGenericImage()
+                    {
+                        ImageBytes = (byte*)from.imageData.ToPointer(),
+                        Width = from.Width,
+                        Height = from.Height,
+                        Stride = from.Stride,
+                        ImgType = from.ImgType,
+                    };
+
+                    var t = new UnsafeGenericImage();
+
+                    t.ImageBytes = (byte*)to.ImageBytes;
+                    t.Width = from.Width;
+                    t.Height = from.Height;
+                    t.Stride = from.Stride;
+                    t.ImgType = ImageType.Rgb;
+
+                    if (x64)
+                    {
+                        DownscaleImgx64(ref ugi, ref t, multiplier);
+                    }
+                    else
+                    {
+                        DownscaleImgx86(ref ugi, ref t, multiplier);
+                    }
+                }
+                      
+
+               
+            }
+
+        }
+
+
+
 
 
-        //todo
     }
+
 }
 
 

H264Sharp/Converter.cs

@@ -110,6 +110,7 @@ public ImageData(ImageType imgType, int width, int height, int stride, IntPtr im
             imageData= imageBytes;
             isManaged = false;
         }
+
 
     }
 
@@ -223,6 +224,53 @@ public void Dispose()
         }
 
 
+    }
+
+    /// <summary>
+    /// Represents storable bgr image
+    /// you can pool images and reuse them.
+    /// </summary>
+    public class BgrImage : IDisposable
+    {
+        public IntPtr ImageBytes;
+        public int offset;
+        public int Width;
+        public int Height;
+        public int Stride;
+        private bool disposedValue;
+
+        public BgrImage(int width, int height)
+        {
+
+            this.Width = width;
+            this.Height = height;
+            this.offset = 0;
+            this.Stride = width * 3;
+            this.ImageBytes = Marshal.AllocHGlobal(width * height * 3);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (!disposedValue)
+            {
+
+                Marshal.FreeHGlobal(ImageBytes);
+                disposedValue = true;
+            }
+        }
+
+        ~BgrImage()
+        {
+            Dispose(disposing: false);
+        }
+
+        public void Dispose()
+        {
+            Dispose(disposing: true);
+            GC.SuppressFinalize(this);
+        }
+
+
     }
 
 

H264Sharp/Data.cs

@@ -119,6 +119,8 @@ public class H264Encoder:IDisposable
 
         [DllImport(Defines.WrapperDllName32bit, EntryPoint = "SetOptionEncoder", CallingConvention = CallingConvention.Cdecl)]
         private static extern int SetOptionEncoderx86(IntPtr encoder, ENCODER_OPTION option, IntPtr value);
+
+       
         #endregion
 
         private readonly IntPtr encoder;
@@ -430,7 +432,7 @@ public unsafe bool Encode(byte* YUV, out EncodedData[] ed)
         //        return img;
         //    }
         //}
-
+      
         private unsafe EncodedData[] Convert(FrameContainer fc)
         {
             EncodedData[] data = new EncodedData[fc.FrameCount];

H264Sharp/H264Encoder.cs

@@ -5,14 +5,14 @@
     <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
     <Title>H264Sharp</Title>
-    <Version>1.2.0</Version>
+    <Version>1.2.1</Version>
     <PackageProjectUrl>https://github.com/ReferenceType/H264Sharp</PackageProjectUrl>
     <Authors>ReferenceType</Authors>
     <RepositoryUrl>https://github.com/ReferenceType/H264Sharp</RepositoryUrl>
     <PackageTags>h264;openh264;transcoder;h264sharp</PackageTags>
     <PackageReleaseNotes>https://github.com/ReferenceType/H264Sharp/releases/</PackageReleaseNotes>
     <PackageId>H264Sharp</PackageId>
-    <Description>Cisco's OpenH264 wrapper for .Net with fast YUV conversion support</Description>
+    <Description>H264 encoding library well suited for streaming based on Cisco's OpenH264</Description>
     <Copyright></Copyright>
     <PackageLicenseFile>Licence.txt</PackageLicenseFile>
   </PropertyGroup>