public static void Test()
{
if (test == null)
{
test = CL.GetKernel("myKernelFunction");
}
const int BUFFERSIZE = 10;
CLBuffer buf = CL.GenBuffer(new float[BUFFERSIZE]);
test.SetArgument(0, buf);
CL.EnqueueRange(test, new MultiDimension(BUFFERSIZE), new MultiDimension(1));
float[] readBack = new float[BUFFERSIZE];
CL.ReadBuffer(buf, readBack);
foreach (var v in readBack)
{
Console.WriteLine(v);
}
}
public static void FillRectangle(CLBuffer trg, IBRectangle trgSize, PixelData color, IBRectangle rect)
{
if (fillRect == null)
{
fillRect = CL.GetKernel("fillRect");
}
int[] _trgSize = new int[] { (int)trgSize.Width, (int)trgSize.Height };
int[] _offset = new int[] { (int)rect.OffsetX, (int)rect.OffsetY };
int[] _size = new int[] { (int)rect.Width, (int)rect.Height };
float[] _color = new float[] { color.b / 255.0f, color.g / 255.0f, color.r / 255.0f, color.a / 255.0f };
CLBuffer __trgSize = CL.GenBuffer(_trgSize);
CLBuffer __offset = CL.GenBuffer(_offset);
CLBuffer __size = CL.GenBuffer(_size);
CLBuffer __color = CL.GenBuffer(_color);
fillRect.SetArgument(0, trg.InternalPointer);
fillRect.SetArgument(1, __trgSize);
fillRect.SetArgument(2, __color);
fillRect.SetArgument(3, __offset);
fillRect.SetArgument(4, __size);
CL.EnqueueRange(fillRect, new MultiDimension(1080), new MultiDimension(1));
}
/// <summary>
/// 現在のコンテキストからバッファを作成します
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="data"></param>
/// <returns></returns>
public static CLBuffer GenBuffer <T>(T[] data) where T : struct
{
return(CLBuffer.FromCopiedHostMemory(Context, data));
}
/// <summary>
/// 現在のコマンドキューを使ってバッファを読み出します
/// </summary>
public static void ReadBuffer <T>(CLBuffer buffer, T[] systemBuffer) where T : struct
{
CommandQueue.ReadBuffer(buffer, systemBuffer);
}
public override void Blend(SingleColorImage source, CLBuffer trg, IBRectangle trgSize, CLBuffer buffer)
{
CLImageProcessing.FillRectangle(trg, trgSize, source.Color, source.Rect);
//int trgSizeW = (int)trg.size.Width;
//int trgSizeH = (int)trg.size.Height;
//if ((int)source.Size.OffsetX > trgSizeW || (int)source.Size.OffsetY > trgSizeH)
// return;
//int strX = 0, strY = 0;
//if ((int)source.Size.OffsetX < 0)
// strX = 0;
//else if ((int)source.Size.OffsetX > (int)trg.size.Width)
// strX = (int)trg.size.Width;
//else
// strX = (int)source.Size.OffsetX;
//if ((int)source.Size.OffsetY < 0)
// strY = 0;
//else if ((int)source.Size.OffsetY > (int)trg.size.Height)
// strY = (int)trg.size.Height;
//else
// strY = (int)source.Size.OffsetY;
//int maxX = 0, maxY = 0;
//if ((int)source.Size.OffsetX + (int)source.Size.Width < 0)
// maxX = 0;
//else if ((int)source.Size.OffsetX + (int)source.Size.Width > (int)trg.size.Width)
// maxX = (int)trg.size.Width;
//else
// maxX = (int)source.Size.OffsetX + (int)source.Size.Width;
//if ((int)source.Size.OffsetY + (int)source.Size.Height < 0)
// maxY = 0;
//else if ((int)source.Size.OffsetY + (int)source.Size.Height > (int)trg.size.Height)
// maxY = (int)trg.size.Height;
//else
// maxY = (int)source.Size.OffsetY + (int)source.Size.Height;
//int trgDataLength = trg.data.Length;
//double Cb2 = source.color.b;
//double Cg2 = source.color.g;
//double Cr2 = source.color.r;
//Parallel.For(strY, maxY, y =>
//{
// if (trg.size.OffsetY <= y && y < trg.size.OffsetY + trg.size.Height)
// for (int x = strX; x < maxX; x++)
// {
// double A1;
// double A2;
// double _A2;
// double A;
// double B;
// double G;
// double R;
// if (trg.size.OffsetX <= y && y < trg.size.OffsetX + trg.size.Width)
// {
// int index = (x + y * trgSizeW) * 4;
// if (index >= trgDataLength) break;
// A1 = trg.data[index + 3] / 255.0;
// A2 = source.color.a / 255.0;
// _A2 = 1 - A2;
// A = A2 + _A2 * A1;
// B = (Cb2 * A2 + _A2 * A1 * trg.data[index]) / A;
// G = (Cg2 * A2 + _A2 * A1 * trg.data[index + 1]) / A;
// R = (Cr2 * A2 + _A2 * A1 * trg.data[index + 2]) / A;
// trg.data[index] = (byte)B;
// trg.data[index + 1] = (byte)G;
// trg.data[index + 2] = (byte)R;
// trg.data[index + 3] = (byte)(A * 255.0);
// }
// }
//});
}
public override void Blend(PixcelImage source, CLBuffer trg, IBRectangle trgSize, CLBuffer buffer)
{
throw new NotImplementedException();
}
static void Main(string[] args)
{
ToGrayscale.ConvertToGrayscale("image.jpg");
//Get the ids of available opencl platforms
CL.GetPlatformIds(0, null, out uint platformCount);
CLPlatform[] platformIds = new CLPlatform[platformCount];
CL.GetPlatformIds(platformCount, platformIds, out _);
Console.WriteLine(platformIds.Length);
foreach (CLPlatform platform in platformIds)
{
Console.WriteLine(platform.Handle);
CL.GetPlatformInfo(platform, PlatformInfo.Name, out byte[] val);
}
//Get the device ids for each platform
foreach (IntPtr platformId in platformIds)
{
CL.GetDeviceIds(new CLPlatform(platformId), DeviceType.All, out CLDevice[] deviceIds);
CLContext context = CL.CreateContext(IntPtr.Zero, (uint)deviceIds.Length, deviceIds, IntPtr.Zero,
IntPtr.Zero, out CLResultCode result);
if (result != CLResultCode.Success)
{
throw new Exception("The context couldn't be created.");
}
string code = @"
__kernel void add(__global float* A, __global float* B,__global float* result, const float mul)
{
int i = get_global_id(0);
result[i] = (A[i] + B[i])*mul;
}";
CLProgram program = CL.CreateProgramWithSource(context, code, out result);
CL.BuildProgram(program, (uint)deviceIds.Length, deviceIds, null, IntPtr.Zero, IntPtr.Zero);
CLKernel kernel = CL.CreateKernel(program, "add", out result);
int arraySize = 20;
float[] A = new float[arraySize];
float[] B = new float[arraySize];
for (int i = 0; i < arraySize; i++)
{
A[i] = 1;
B[i] = i;
}
CLBuffer bufferA = CL.CreateBuffer(context, MemoryFlags.ReadOnly | MemoryFlags.CopyHostPtr, A,
out result);
CLBuffer bufferB = CL.CreateBuffer(context, MemoryFlags.ReadOnly | MemoryFlags.CopyHostPtr, B,
out result);
float[] pattern = new float[] { 1, 3, 5, 7 };
CLBuffer resultBuffer = new CLBuffer(CL.CreateBuffer(context, MemoryFlags.WriteOnly,
new UIntPtr((uint)(arraySize * sizeof(float))), IntPtr.Zero, out result));
try
{
CL.SetKernelArg(kernel, 0, bufferA);
CL.SetKernelArg(kernel, 1, bufferB);
CL.SetKernelArg(kernel, 2, resultBuffer);
CL.SetKernelArg(kernel, 3, -1f);
CLCommandQueue commandQueue = new CLCommandQueue(
CL.CreateCommandQueueWithProperties(context, deviceIds[0], IntPtr.Zero, out result));
CL.EnqueueFillBuffer(commandQueue, bufferB, pattern, UIntPtr.Zero, (UIntPtr)(arraySize * sizeof(float)), null,
out _);
//CL.EnqueueNDRangeKernel(commandQueue, kernel, 1, null, new UIntPtr[] {new UIntPtr((uint)A.Length)},
// null, 0, null, out CLEvent eventHandle);
CL.EnqueueNDRangeKernel(commandQueue, kernel, 1, null, new UIntPtr[] { new UIntPtr((uint)A.Length) },
null, 0, null, out CLEvent eventHandle);
CL.Finish(commandQueue);
CL.SetEventCallback(eventHandle, (int)CommandExecutionStatus.Complete, (waitEvent, data) =>
{
float[] resultValues = new float[arraySize];
CL.EnqueueReadBuffer(commandQueue, resultBuffer, true, UIntPtr.Zero, resultValues, null, out _);
StringBuilder line = new StringBuilder();
foreach (float res in resultValues)
{
line.Append(res);
line.Append(", ");
}
Console.WriteLine(line.ToString());
});
//get rid of the buffers because we no longer need them
CL.ReleaseMemoryObject(bufferA);
CL.ReleaseMemoryObject(bufferB);
CL.ReleaseMemoryObject(resultBuffer);
//Release the program kernels and queues
CL.ReleaseProgram(program);
CL.ReleaseKernel(kernel);
CL.ReleaseCommandQueue(commandQueue);
CL.ReleaseContext(context);
CL.ReleaseEvent(eventHandle);
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
throw;
}
}
}
public static void Add()
{
CLResultCode error = CLResultCode.Success;
CLPlatform[] platforms = new CLPlatform[1];
CL.GetPlatformIds(1, platforms, out _);
CLDevice[] devices = new CLDevice[1];
CL.GetDeviceIds(platforms[0], DeviceType.All, 1, devices, out _);
CLContext context = CL.CreateContext(IntPtr.Zero, devices, IntPtr.Zero, IntPtr.Zero, out _);
CLProgram program =
CL.CreateProgramWithSource(context, File.ReadAllText("Kernels/add_arrays.cl"), out error);
error = CL.BuildProgram(program, 1, devices, null, IntPtr.Zero, IntPtr.Zero);
if (error != CLResultCode.Success)
{
throw new Exception(error.ToString());
}
CLKernel kernel = CL.CreateKernel(program, "add", out error);
Span <float> inputA = new float[]
{
1, 24, 5, 43, 41, 56
};
Span <float> inputB = new float[]
{
72, -323, -1, 43, -41, -26
};
Span <float> output = stackalloc float[inputA.Length];
CLBuffer bufferA = CL.CreateBuffer(context, MemoryFlags.ReadOnly | MemoryFlags.CopyHostPtr, inputA, out _);
CLBuffer bufferB = CL.CreateBuffer(context, MemoryFlags.ReadOnly | MemoryFlags.CopyHostPtr, inputB, out _);
CLBuffer outputBuffer = CL.CreateBuffer(context, MemoryFlags.WriteOnly, (UIntPtr)(output.Length * sizeof(float)), IntPtr.Zero, out _);
//For outputs I wouldn't use that also enqueueing a ReadBuffer is needed regardless
//CLBuffer outputBuffer = CL.CreateBuffer(context, MemoryFlags.WriteOnly | MemoryFlags.UseHostPtr, output, out _);
CL.SetKernelArg(kernel, 0, bufferA);
CL.SetKernelArg(kernel, 1, bufferB);
CL.SetKernelArg(kernel, 2, outputBuffer);
CLCommandQueue queue = CL.CreateCommandQueueWithProperties(context, devices[0], IntPtr.Zero, out error);
CL.EnqueueNDRangeKernel(queue, kernel, 1, null,
new[] { (UIntPtr)inputA.Length }, null, 0, null, out _);
CL.EnqueueReadBuffer(queue, outputBuffer, true, UIntPtr.Zero, output, null, out _);
foreach (float f in output)
{
Console.WriteLine(f);
}
CL.ReleaseMemoryObject(bufferA);
CL.ReleaseMemoryObject(bufferB);
CL.ReleaseMemoryObject(outputBuffer);
CL.ReleaseCommandQueue(queue);
CL.ReleaseKernel(kernel);
CL.ReleaseProgram(program);
CL.ReleaseContext(context);
}
public abstract void Blend(PixcelImage source, CLBuffer trg, IBRectangle trgSize, CLBuffer buffer);
public abstract void Blend(SingleColorImage source, CLBuffer trg, IBRectangle trgSize, CLBuffer buffer);
