1:
2:
3:
4:

  
    [DllImport(@"C:\Program Files (x86)\AS\Runtime\Toolbox.dll",
            CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl, EntryPoint = "Execute")]
        public static extern int Execute(int count, [MarshalAs(UnmanagedType.LPArray)] IntPtr[] bitmaps);					

1:
2:
3:
4:
5:
6:
7:

        private Bitmap[] _bmp = new Bitmap[3];
        private IntPtr[] _bmpScorpion = new HBITMAP[3];
        private IntPtr _bm = HBITMAP.Zero;
        private string _tag= "";
        private int _camCount = 0;
        private FIBITMAP _fibitmaps = FIBITMAP.Zero;
        private bool disposedValue = false; // To detect redundant calls					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

     public ScorpionFunctions(Bitmap bmp1, Bitmap bmp2, Bitmap bmp3, int cameraCount)
        {
            this._camCount = cameraCount;
            this._bmp = new Bitmap[3];
            this._bmpScorpion = new HBITMAP[3];
            this._bmp[0] = bmp1;
            this._bmp[1] = bmp2;
            this._bmp[2] = bmp3; 
            this._bm = HBITMAP.Zero;           
        }					

1:
2:
3:
4:
5:
6:

using (var obj = new ScorpionFunctions(_bmp1, _bmp2, _bmp3, _camCount))
                    {
                        // used delegate
                        Action<CallBackSvbFunction> delegateObj = obj.SvbExecute;
                        delegateObj.Invoke(CallBackInt);
                    }					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:

 public void SvbExecute(CallBackSvbFunction @return)
        {
            int hresult = 0;
            bool unload = false;
            //MessageBox.Show(" {0} " + GC.GetTotalMemory(true));
            if (_bmp[0] != null)
            {
                // create fibitmap from bitmap 
                _fibitmaps = FreeImage.CreateFromBitmap(_bmp[0]); // dauert ~ 5ms
                // creat hbitmap 
                _bmpScorpion[0] = FreeImage.GetHbitmap(_fibitmaps, _bm, unload);
            }
            if (_bmp[1] != null)
            {
                _fibitmaps = FreeImage.CreateFromBitmap(_bmp[1]); //dauert ~ 5 ms
                _bmpScorpion[1] = FreeImage.GetHbitmap(_fibitmaps, _bm, unload);
            }
            if (_bmp[2] != null)
            {
                _fibitmaps = FreeImage.CreateFromBitmap(_bmp[2]); //dauert ~ 5 ms
                _bmpScorpion[2] = FreeImage.GetHbitmap(_fibitmaps, _bm, unload);
            }

            try
            {                
                int count = _bmpScorpion.Length;
                @return(SvbFunctionLibrary.Execute(count, _bmpScorpion));
            }

            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, ex.StackTrace);
            }
      }					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:

  protected virtual void Dispose(bool disposing)
        {
            if (!disposedValue)
            {
                if (disposing)
                {
                    //// TODO: dispose managed state (managed objects).                   
                    _bmp[0]?.Dispose();
                    _bmp[0] = null;
                    _bmp[1]?.Dispose();
                    _bmp[1] = null;
                    _bmp[2]?.Dispose();
                    _bmp[2] = null;
                    _bm = IntPtr.Zero;
                }

                // TODO: free unmanaged resources (unmanaged objects) and override a finalizer below.
                // TODO: set large fields to null.
                // TODO: dispose managed state (managed objects).
                      
                _bmpScorpion[0] = IntPtr.Zero;
                _bmpScorpion[1] = IntPtr.Zero;
                _bmpScorpion[2] = IntPtr.Zero;              
                _fibitmaps = FIBITMAP.Zero; 
                                
                disposedValue = true;
            }
        }
       
        // TODO: override a finalizer only if Dispose(bool disposing) above has code to free unmanaged resources.
        ~ScorpionFunctions()
        {
            // Do not change this code. Put cleanup code in Dispose(bool disposing) above.
            Dispose(false);
        }

        // This code added to correctly implement the disposable pattern.
        public void Dispose()
        {
            // Do not change this code. Put cleanup code in Dispose(bool disposing) above.
            Dispose(true);
            // TODO: uncomment the following line if the finalizer is overridden above.
            GC.SuppressFinalize(this);
        }					

1:
2:
3:
4:

using System.Drawing;
HBITMAP = System.IntPtr;

HBITMAP hbitmap = bmp[0].GetHbitmap();					

1:
2:
3:
4:

  using (FreeImageBitmap obj = new FreeImageBitmap(_bmp[0]))
                {
                    _bmpScorpion[0] = obj.GetHbitmap();
                }					

1:
2:
3:
4:
5:
6:
7:

   if (_bmp[0] != null)
            {
                // create FreeImageBitmap from bitmap 
                // dauert ~ 5ms
                FreeImageBitmap obj = new FreeImageBitmap(_bmp[0]);
               // _bmpScorpion[0] = obj.GetHbitmap();
                obj.Dispose();					

1:
2:
3:

                _bmpScorpion[0] = IntPtr.Zero;
                _bmpScorpion[1] = IntPtr.Zero;
                _bmpScorpion[2] = IntPtr.Zero;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:

/// <summary>
    /// Performs application-defined tasks associated with freeing,
    /// releasing, or resetting unmanaged resources.
    /// </summary>
    /// <param name="disposing">If true managed ressources are released.</param>
    protected virtual void Dispose(bool disposing)
    {
      // Only clean up once
      lock (lockObject)
      {
        if (disposed)
        {
          return;
        }
        disposed = true;
      }

      // Clean up managed resources
      if (disposing)
      {
        if (stream != null)
        {
          if (disposeStream)
          {
            stream.Dispose();
          }
          stream = null;
        }
      }

      tag = null;
      saveInformation = null;

      // Clean up unmanaged resources
      UnloadDib();  //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    }

                /// <summary>
    /// Tries to replace the wrapped <see cref="FIBITMAP"/> with a new one.
    /// In case the new dib is null or the same as the already
    /// wrapped one, nothing will be changed and the result will
    /// be false.
    /// Otherwise the wrapped <see cref="FIBITMAP"/> will be unloaded and replaced.
    /// </summary>
    /// <param name="newDib">The new dib.</param>
    /// <returns>Returns true on success, false on failure.</returns>
    private bool ReplaceDib(FIBITMAP newDib)
    {
      bool result = false;
      if ((dib != newDib) && (!newDib.IsNull))
      {
        UnloadDib();
        dib = newDib;
        AddMemoryPressure();
        result = true;
      }
      return result;
    }

/// <summary>
    /// Unloads currently wrapped <see cref="FIBITMAP"/> or unlocks the locked page
    /// in case it came from a multipaged bitmap.
    /// </summary>
    private void UnloadDib()
    {
      if (!dib.IsNull)
      {
        long size = FreeImage.GetDIBSize(dib);
        FreeImage.UnloadEx(ref dib);
        if (size > 0L)
          GC.RemoveMemoryPressure(size);
      }
    }