public static FHANDLE fnFGA_img_root_import_alloc(
	IntPtr[] adrss,
	int channels,
	int type,
	SIZE_T step,
	int width,
	int height
)

Public Shared Function fnFGA_img_root_import_alloc ( 
	adrss As IntPtr(),
	channels As Integer,
	type As Integer,
	step As SIZE_T,
	width As Integer,
	height As Integer
) As FHANDLE

//    $Revision: 1.2 $

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
using System.Diagnostics;
using fvalgcli;
using cudaError_t = System.Int32;

namespace TC
{
    public partial class FIE
    {
        /// <summary>
        /// ルート画像の確保(import版).
        /// </summary>
        [FvPluginExecute]
        public unsafe void fnFGA_img_root_import_alloc()
        {
            FHANDLE hroot = FHANDLE.Zero;
            int type = (int)f_imgtype.F_IMG_UC8;
            int channels = 3;
            int step = 640;
            int width = 640;
            int height = 480;
            IntPtr[] devPtrs = new IntPtr[channels];
            IntPtr cuda = LoadLibrary(cudart);

            try
            {
                // 画像メモリ空間の確保.
                if (cuda != IntPtr.Zero)
                {
                    for (int ch = 0; ch < channels; ch++)
                    {
                        cudaMalloc(ref devPtrs[ch], width * height * sizeof(byte));
                    }
                }

                // 処理の実行.
                hroot = fga.fnFGA_img_root_import_alloc(devPtrs, channels, type, step, width, height);
                if (hroot == IntPtr.Zero)
                    throw new FvException(f_err.F_ERR_NOMEMORY, "fnFGA_img_root_import_alloc: エラーが発生しました。");
            }
            finally
            {
                // オブジェクトの開放.
                hroot.Dispose();

                // メモリの開放.
                if (cuda != IntPtr.Zero)
                {
                    for (int ch = 0; ch < channels; ch++)
                    {
                        cudaFree(devPtrs[ch]);
                    }
                }
            }
        }

        // Heap API flags
        const int HEAP_ZERO_MEMORY = 0x00000008;

        [DllImport("kernel32")]
        static extern int GetProcessHeap();

        [DllImport("kernel32.dll")]
        public static extern IntPtr HeapAlloc(int hHeap, uint dwFlags, int dwBytes);

        [DllImport("kernel32.dll")]
        public static extern bool HeapFree(int hHeap, uint flags, IntPtr block);

        /// <summary>
        /// NVIDIA CUDA Runtime Library
        /// </summary>
        public const string cudart = "cudart64_101.dll";

        /// <summary>
        /// NVIDIA CUDA API: メモリ確保
        /// </summary>
        /// <param name="devPtr"></param>
        /// <param name="size"></param>
        /// <returns></returns>
        [DllImport(cudart, CallingConvention = CallingConvention.Cdecl)]
        public static extern cudaError_t cudaMalloc(ref IntPtr devPtr, SIZE_T size);

        /// <summary>
        /// NVIDIA CUDA API: メモリ解放
        /// </summary>
        /// <param name="devPtr"></param>
        /// <returns></returns>
        [DllImport(cudart, CallingConvention = CallingConvention.Cdecl)]
        public static extern cudaError_t cudaFree(IntPtr devPtr);

        /// <summary>
        /// ライブラリロード
        /// </summary>
        /// <param name="lpFileName">ファイルパス</param>
        /// <returns>ハンドル</returns>
        [DllImport("kernel32", CharSet = CharSet.Unicode, SetLastError = true)]
        public static extern IntPtr LoadLibrary(string lpFileName);
    }
}