public void singlePass(Kernel kernel, FloatMap inMap, FloatMap outMap)
{
var clInImageFormat = new OpenCL.Net.ImageFormat(ChannelOrder.Luminance, ChannelType.Float);
IMem inputMapBuffer = Cl.CreateImage2D(_context, MemFlags.CopyHostPtr | MemFlags.ReadOnly, clInImageFormat,
(IntPtr)inMap.W, (IntPtr)inMap.H, new IntPtr(inMap.Stride * sizeof(float)),
inMap._buf, out err);
assert(err, "input img creation");
IMem outputMapBuffer = Cl.CreateImage2D(_context, MemFlags.WriteOnly, clInImageFormat,
(IntPtr)outMap.W, (IntPtr)outMap.H, new IntPtr(outMap.Stride * sizeof(float)),
outMap._buf, out err);
assert(err, "output img creation");
// Set memory objects as parameters to kernel
err = Cl.SetKernelArg(kernel, 0, intPtrSize, inputMapBuffer);
assert(err, "input map setKernelArg");
err = Cl.SetKernelArg(kernel, 1, intPtrSize, outputMapBuffer);
assert(err, "output map setKernelArg");
// write actual data into memory object
IntPtr[] originPtr = new IntPtr[] { (IntPtr)0, (IntPtr)0, (IntPtr)0 }; //x, y, z
IntPtr[] inRegionPtr = new IntPtr[] { (IntPtr)inMap.W, (IntPtr)inMap.H, (IntPtr)1 }; //x, y, z
IntPtr[] outRegionPtr = new IntPtr[] { (IntPtr)outMap.W, (IntPtr)outMap.H, (IntPtr)1 }; //x, y, z
IntPtr[] workGroupSizePtr = new IntPtr[] { (IntPtr)outMap.W, (IntPtr)outMap.H, (IntPtr)1 };
Event clevent;
//err = Cl.EnqueueWriteImage(_commandsQueue, inputMapBuffer, Bool.True, originPtr, inRegionPtr, (IntPtr)0, (IntPtr)0, inMap._buf, 0, null, out clevent);
//clevent.Dispose();
//assert(err, "write input img");
// execute
err = Cl.EnqueueNDRangeKernel(_commandsQueue, kernel, 2,
originPtr,
workGroupSizePtr,
null, 0, null, out clevent);
clevent.Dispose();
assert(err, "Cl.EnqueueNDRangeKernel");
// sync
Cl.Finish(_commandsQueue);
// read from output memory object into actual buffer
err = Cl.EnqueueReadImage(_commandsQueue, outputMapBuffer, Bool.True, originPtr, outRegionPtr, new IntPtr(outMap.Stride * sizeof(float)), (IntPtr)0, outMap._buf, 0, null, out clevent);
clevent.Dispose();
assert(err, "read output buffer");
Cl.ReleaseMemObject(inputMapBuffer);
Cl.ReleaseMemObject(outputMapBuffer);
}
ErrorCode queue_scrypt_kernel(clState _clState, dev_blk_ctx blk)
{
//Scantime
blk.work.midstate0 = new uint4(0);
blk.work.midstate16 = new uint4(1);
// unsigned char *midstate = blk->work->midstate;
int num = 0;
uint16 le_target;
le_target = new uint16(Convert.ToUInt16(blk.work.device_target + 28));
_clState.cldata = blk.work.data;
_clState.CLBuffer0 = new uint4(0);
_clState.outputBuffer = new Mem();
_clState.padbuffer8 = new uint4(0);
OpenCL.Net.Event clevent;
OpenCL.Net.ImageFormat clImageFormat = new OpenCL.Net.ImageFormat(ChannelOrder.RGBA, ChannelType.Unsigned_Int8);
ErrorCode err1;
byte[] inputByteArray = new byte[1024];
//buffer0 = (OpenCL.Net.Mem)OpenCL.Net.Cl.CreateImage2D(_clState.cl_context, OpenCL.Net.MemFlags.CopyHostPtr | OpenCL.Net.MemFlags.ReadOnly, clImageFormat, (IntPtr)1024, (IntPtr)1, (IntPtr)0, inputByteArray, out err1);
// buffer0 = (OpenCL.Net.Mem)inputByteArray;
// byte[] byteSrcImage2DData = new byte[srcIMGBytesSize];
Mem buffer0 = (Mem)OpenCL.Net.Cl.CreateBuffer(_clState.cl_context, MemFlags.ReadWrite, 1024, out err1);
ErrorCode status = Cl.EnqueueWriteBuffer(_clState.cl_command_queue, buffer0, OpenCL.Net.Bool.True, (IntPtr)0, (IntPtr)1024, _clState.cldata, 0, null, out clevent);
//
// status = OpenCL.Net.Cl.SetKernelArg(_clState.Kernel, num++, sizeof(var), (void *)&var)
// CL_SET_VARG(args, var) status |= clSetKernelArg(*kernel, num++, args * sizeof(uint), (void *)var)
int intPtrSize = 0;
intPtrSize = Marshal.SizeOf(typeof(IntPtr));
OpenCL.Net.Cl.SetKernelArg(_clState.cl_kernel, 0, (IntPtr)intPtrSize, _clState.CLBuffer0);
OpenCL.Net.Cl.SetKernelArg(_clState.cl_kernel, 1, _clState.outputBuffer);
OpenCL.Net.Cl.SetKernelArg(_clState.cl_kernel, 2, _clState.padbuffer8);
OpenCL.Net.Cl.SetKernelArg(_clState.cl_kernel, 3, blk.work.midstate0);
OpenCL.Net.Cl.SetKernelArg(_clState.cl_kernel, 4, blk.work.midstate16);
// CL_SET_VARG(4, &midstate[0]);
// CL_SET_VARG(4, &midstate[16]);
OpenCL.Net.Cl.SetKernelArg(_clState.cl_kernel, 5, le_target);
//error = Cl.SetKernelArg(kernel, 0, (IntPtr)intPtrSize, inputImage2DBuffer);
CheckErr(status, "Cl.SetKernelArg");
return(status);
}
public void ImagingTest(string inputImagePath, string outputImagePath)
{
ErrorCode error;
//Load and compile kernel source code.
string programPath = System.Environment.CurrentDirectory + "/../../imagingtest.cl"; //The path to the source file may vary
if (!System.IO.File.Exists(programPath))
{
Console.WriteLine("Program doesn't exist at path " + programPath);
return;
}
string programSource = System.IO.File.ReadAllText(programPath);
using (Program program = Cl.CreateProgramWithSource(_context, 1, new[] { programSource }, null, out error))
{
CheckErr(error, "Cl.CreateProgramWithSource");
//Compile kernel source
error = Cl.BuildProgram(program, 1, new[] { _device }, string.Empty, null, IntPtr.Zero);
CheckErr(error, "Cl.BuildProgram");
//Check for any compilation errors
if (Cl.GetProgramBuildInfo(program, _device, ProgramBuildInfo.Status, out error).CastTo <BuildStatus>()
!= BuildStatus.Success && 1 == 0)
{
CheckErr(error, "Cl.GetProgramBuildInfo");
Console.WriteLine("Cl.GetProgramBuildInfo != Success");
Console.WriteLine(Cl.GetProgramBuildInfo(program, _device, ProgramBuildInfo.Log, out error));
return;
}
//Create the required kernel (entry function)
Kernel kernel = Cl.CreateKernel(program, "imagingTest", out error);
CheckErr(error, "Cl.CreateKernel");
int intPtrSize = 0;
intPtrSize = Marshal.SizeOf(typeof(IntPtr));
//Image's RGBA data converted to an unmanaged[] array
byte[] inputByteArray;
//OpenCL memory buffer that will keep our image's byte[] data.
Mem inputImage2DBuffer;
OpenCL.Net.ImageFormat clImageFormat = new OpenCL.Net.ImageFormat(ChannelOrder.RGBA, ChannelType.Unsigned_Int8);
int inputImgWidth, inputImgHeight;
int inputImgBytesSize;
int inputImgStride;
//Try loading the input image
using (FileStream imageFileStream = new FileStream(inputImagePath, FileMode.Open))
{
System.Drawing.Image inputImage = System.Drawing.Image.FromStream(imageFileStream);
if (inputImage == null)
{
Console.WriteLine("Unable to load input image");
return;
}
inputImgWidth = inputImage.Width;
inputImgHeight = inputImage.Height;
System.Drawing.Bitmap bmpImage = new System.Drawing.Bitmap(inputImage);
//Get raw pixel data of the bitmap
//The format should match the format of clImageFormat
BitmapData bitmapData = bmpImage.LockBits(new Rectangle(0, 0, bmpImage.Width, bmpImage.Height),
ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);//inputImage.PixelFormat);
inputImgStride = bitmapData.Stride;
inputImgBytesSize = bitmapData.Stride * bitmapData.Height;
//Copy the raw bitmap data to an unmanaged byte[] array
inputByteArray = new byte[inputImgBytesSize];
Marshal.Copy(bitmapData.Scan0, inputByteArray, 0, inputImgBytesSize);
//Allocate OpenCL image memory buffer
inputImage2DBuffer = (OpenCL.Net.Mem)OpenCL.Net.Cl.CreateImage2D(_context,
OpenCL.Net.MemFlags.CopyHostPtr | OpenCL.Net.MemFlags.ReadOnly, clImageFormat,
(IntPtr)bitmapData.Width, (IntPtr)bitmapData.Height,
(IntPtr)0, inputByteArray, out error);
CheckErr(error, "Cl.CreateImage2D input");
}
//Unmanaged output image's raw RGBA byte[] array
byte[] outputByteArray = new byte[inputImgBytesSize];
//Allocate OpenCL image memory buffer
OpenCL.Net.Mem outputImage2DBuffer = (OpenCL.Net.Mem)OpenCL.Net.Cl.CreateImage2D(_context, OpenCL.Net.MemFlags.CopyHostPtr | OpenCL.Net.MemFlags.WriteOnly, clImageFormat,
(IntPtr)inputImgWidth, (IntPtr)inputImgHeight, (IntPtr)0, outputByteArray, out error);
CheckErr(error, "Cl.CreateImage2D output");
//Pass the memory buffers to our kernel function
error = Cl.SetKernelArg(kernel, 0, (IntPtr)intPtrSize, inputImage2DBuffer);
error |= Cl.SetKernelArg(kernel, 1, (IntPtr)intPtrSize, outputImage2DBuffer);
CheckErr(error, "Cl.SetKernelArg");
//Create a command queue, where all of the commands for execution will be added
CommandQueue cmdQueue = Cl.CreateCommandQueue(_context, _device, (CommandQueueProperties)0, out error);
CheckErr(error, "Cl.CreateCommandQueue");
OpenCL.Net.Event clevent;
//Copy input image from the host to the GPU.
IntPtr[] originPtr = new IntPtr[] { (IntPtr)0, (IntPtr)0, (IntPtr)0 }; //x, y, z
IntPtr[] regionPtr = new IntPtr[] { (IntPtr)inputImgWidth, (IntPtr)inputImgHeight, (IntPtr)1 }; //x, y, z
IntPtr[] workGroupSizePtr = new IntPtr[] { (IntPtr)inputImgWidth, (IntPtr)inputImgHeight, (IntPtr)1 };
error = Cl.EnqueueWriteImage(cmdQueue, inputImage2DBuffer, OpenCL.Net.Bool.True, originPtr, regionPtr, (IntPtr)0, (IntPtr)0, inputByteArray, 0, null, out clevent);
CheckErr(error, "Cl.EnqueueWriteImage");
//Execute our kernel (OpenCL code)
// CommandQueue q = new OpenCL.Net.CommandQueue();
//enqueue nd range kernel
// error = cmdQueue.EnqueueKernel(cmdQueue, kernel, 2, null, workGroupSizePtr, null, 0, null, out clevent);
// OpenCL.Net.Cl.EnqueueNDRangeKernel(
OpenCL.Net.Cl.EnqueueNDRangeKernel(cmdQueue, kernel, 2, null, workGroupSizePtr, null, 0, null, out clevent);
CheckErr(error, "Cl.EnqueueNDRangeKernel");
//Wait for completion of all calculations on the GPU.
error = Cl.Finish(cmdQueue);
CheckErr(error, "Cl.Finish");
//Read the processed image from GPU to raw RGBA data byte[] array
error = Cl.EnqueueReadImage(cmdQueue, outputImage2DBuffer, OpenCL.Net.Bool.True, originPtr, regionPtr,
(IntPtr)0, (IntPtr)0, outputByteArray, 0, null, out clevent);
CheckErr(error, "Cl.clEnqueueReadImage");
//Clean up memory
Cl.ReleaseKernel(kernel);
Cl.ReleaseCommandQueue(cmdQueue);
Cl.ReleaseMemObject(inputImage2DBuffer);
Cl.ReleaseMemObject(outputImage2DBuffer);
//Get a pointer to our unmanaged output byte[] array
GCHandle pinnedOutputArray = GCHandle.Alloc(outputByteArray, GCHandleType.Pinned);
IntPtr outputBmpPointer = pinnedOutputArray.AddrOfPinnedObject();
//Create a new bitmap with processed data and save it to a file.
Bitmap outputBitmap = new Bitmap(inputImgWidth, inputImgHeight, inputImgStride, PixelFormat.Format32bppArgb, outputBmpPointer);
outputBitmap.Save(outputImagePath, System.Drawing.Imaging.ImageFormat.Png);
pinnedOutputArray.Free();
}
}
private void FixImage()
{
Event e;
ErrorCode error;
OpenCL.Net.Program program = Cl.CreateProgramWithSource(context, 1, new[] { script }, null, out error);
error = Cl.BuildProgram(program, 0, null, string.Empty, null, IntPtr.Zero);
//MessageBox.Show(error.ToString());
Kernel kernel = Cl.CreateKernel(program, "fixImage", out error);
int intPtrSize = Marshal.SizeOf(typeof(IntPtr));
Mem dest;
OpenCL.Net.ImageFormat clImageFormat = new OpenCL.Net.ImageFormat(OpenCL.Net.ChannelOrder.RGBA, OpenCL.Net.ChannelType.Unsigned_Int8);
int inputImgWidth, inputImgHeight;
Image img = Image.FromFile(path);
inputImgWidth = img.Width;
inputImgHeight = img.Height;
Bitmap bmp = new Bitmap(img);
float[] buffer = new float[40960 * count];
float[] array = new float[] { radius, O.X, O.Y };
dest = (Mem)Cl.CreateBuffer(context, MemFlags.WriteOnly, new IntPtr(count * 40960 * sizeof(float)), out error);
Mem P = (Mem)Cl.CreateBuffer(context, MemFlags.ReadWrite, Marshal.SizeOf(typeof(PointF)) * 10240 * count, out error);
Mem data = (Mem)Cl.CreateBuffer(context, MemFlags.ReadOnly, Marshal.SizeOf(typeof(PointF)) * points.Count, out error);
Mem ptr = (Mem)Cl.CreateBuffer(context, MemFlags.ReadOnly, 3 * sizeof(float), out error);
Cl.EnqueueWriteBuffer(queue, P, Bool.True, IntPtr.Zero, new IntPtr(Marshal.SizeOf(typeof(PointF)) * 10240 * count), map.ToArray(), 0, null, out e);
Cl.EnqueueWriteBuffer(queue, data, Bool.True, IntPtr.Zero, new IntPtr(Marshal.SizeOf(typeof(PointF)) * points.Count), points.ToArray(), 0, null, out e);
Cl.EnqueueWriteBuffer(queue, ptr, Bool.True, IntPtr.Zero, (IntPtr)3, array, 0, null, out e);
error = Cl.SetKernelArg(kernel, 0, (IntPtr)intPtrSize, dest);
error |= Cl.SetKernelArg(kernel, 1, (IntPtr)intPtrSize, P);
error |= Cl.SetKernelArg(kernel, 2, (IntPtr)intPtrSize, data);
error |= Cl.SetKernelArg(kernel, 3, (IntPtr)intPtrSize, ptr);
error |= Cl.SetKernelArg(kernel, 4, (IntPtr)intPtrSize, points.Count);
IntPtr[] workGroupSizePtr = new IntPtr[] { (IntPtr)count, (IntPtr)10240 };
Cl.EnqueueNDRangeKernel(queue, kernel, 2, null, workGroupSizePtr, null, 0, null, out e);
Cl.Finish(queue);
error |= Cl.EnqueueReadBuffer(queue,
dest,
Bool.True,
IntPtr.Zero,
new IntPtr(sizeof(float) * 40960 * count),
buffer,
0,
null,
out e);
Cl.ReleaseKernel(kernel);
Cl.ReleaseCommandQueue(queue);
Cl.ReleaseMemObject(dest);
Cl.ReleaseMemObject(P);
Cl.ReleaseMemObject(data);
for (int i = 0; i < buffer.Length; i += 4)
{
int dx = (int)Math.Round(buffer[i]);
int dy = (int)Math.Round(buffer[i + 1]);
int sx = (int)Math.Round(buffer[i + 2]);
int sy = (int)Math.Round(buffer[i + 3]);
bool test = (sx >= 0 && sx < img.Width) && (sy >= 0 && sy < img.Height);
Color src = test ? bmp.GetPixel(sx, sy) : Color.White;
if ((dx >= 0 && dx < img.Width) && (dy >= 0 && dy < img.Height))
{
bmp.SetPixel(dx, dy, src);
}
}
int index = path.LastIndexOf('.');
string ext = path.Substring(index + 1);
newPath = path.Substring(0, index) + $"_final.{ext}";
System.Drawing.Imaging.ImageFormat format = System.Drawing.Imaging.ImageFormat.Jpeg;
if (ext == "bmp")
{
format = System.Drawing.Imaging.ImageFormat.Bmp;
}
else if (ext == "png")
{
format = System.Drawing.Imaging.ImageFormat.Png;
}
bmp.Save(newPath, format);
}
// copypasted/modified from Map2Bmp
public Bitmap Map2BmpFauxColors(FloatMap inMap, float k)
{
var kernel = _kernels["mapToFauxColorsBmp"];
int w = inMap.W;
int h = inMap.H;
var clInImageFormat = new OpenCL.Net.ImageFormat(ChannelOrder.Luminance, ChannelType.Float);
IMem inputImage2DBuffer = Cl.CreateImage2D(_context, MemFlags.CopyHostPtr | MemFlags.ReadOnly, clInImageFormat,
(IntPtr)w, (IntPtr)h,
new IntPtr(inMap.Stride * sizeof(float)), inMap._buf, out err);
assert(err, "input img creation");
var clOutImageFormat = new OpenCL.Net.ImageFormat(ChannelOrder.RGBA, ChannelType.Unsigned_Int8);
IMem outputImage2DBuffer = Cl.CreateImage2D(_context, MemFlags.WriteOnly, clOutImageFormat,
(IntPtr)w, (IntPtr)h,
(IntPtr)0, (IntPtr)0, out err);
assert(err, "output img creation");
err = Cl.SetKernelArg(kernel, 0, intPtrSize, inputImage2DBuffer);
assert(err, "input img setKernelArg");
err = Cl.SetKernelArg(kernel, 1, intPtrSize, outputImage2DBuffer);
assert(err, "output img setKernelArg");
err = Cl.SetKernelArg(kernel, 2, floatSize, k);
assert(err, "k setKernelArg");
Event clevent;
//x, y, z
IntPtr[] originPtr = new IntPtr[] { (IntPtr)0, (IntPtr)0, (IntPtr)0 };
IntPtr[] regionPtr = new IntPtr[] { (IntPtr)w, (IntPtr)h, (IntPtr)1 };
IntPtr[] workGroupSizePtr = new IntPtr[] { (IntPtr)w, (IntPtr)h, (IntPtr)1 };
//err = Cl.EnqueueWriteImage(_commandsQueue, inputImage2DBuffer, Bool.True, originPtr, regionPtr, (IntPtr)0, (IntPtr)0, inputByteArray, 0, null, out clevent);
//assert(err, "Cl.EnqueueWriteImage");
//Execute kernel
err = Cl.EnqueueNDRangeKernel(_commandsQueue, kernel, 2, null, workGroupSizePtr, null, 0, null, out clevent);
clevent.Dispose();
assert(err, "Cl.EnqueueNDRangeKernel");
//Wait for completion
err = Cl.Finish(_commandsQueue);
assert(err, "Cl.Finish");
// get data back
var outputByteArray = new byte[w * h * 4];
err = Cl.EnqueueReadImage(_commandsQueue, outputImage2DBuffer, Bool.True, originPtr, regionPtr, (IntPtr)0, (IntPtr)0, outputByteArray, 0, null, out clevent);
clevent.Dispose();
assert(err, "read output buffer");
Cl.ReleaseMemObject(inputImage2DBuffer);
Cl.ReleaseMemObject(outputImage2DBuffer);
GCHandle pinnedOutputArray = GCHandle.Alloc(outputByteArray, GCHandleType.Pinned);
IntPtr outputBmpPointer = pinnedOutputArray.AddrOfPinnedObject();
var bmp = new Bitmap(w, h, w * 4, PixelFormat.Format32bppArgb, outputBmpPointer);
pinnedOutputArray.Free();
return(bmp);
}
public FloatMap Bmp2Map(Bitmap bmpImage)
{
var kernel = _kernels["getLumaImg"];
int w = bmpImage.Width;
int h = bmpImage.Height;
BitmapData bitmapData = bmpImage.LockBits(new Rectangle(0, 0, w, h), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
int inputImgStride = bitmapData.Stride;
int inputImgBytesSize = bitmapData.Stride * bitmapData.Height;
//Copy the raw bitmap data to an unmanaged byte[] array
byte[] inputByteArray = new byte[inputImgBytesSize];
Marshal.Copy(bitmapData.Scan0, inputByteArray, 0, inputImgBytesSize);
var clInImageFormat = new OpenCL.Net.ImageFormat(ChannelOrder.RGBA, ChannelType.Unsigned_Int8);
//Allocate OpenCL image memory buffer
IMem inputImage2DBuffer = Cl.CreateImage2D(_context, MemFlags.CopyHostPtr | MemFlags.ReadOnly, clInImageFormat,
(IntPtr)bitmapData.Width, (IntPtr)bitmapData.Height,
(IntPtr)0, inputByteArray, out err);
assert(err, "input img creation");
var clOutImageFormat = new OpenCL.Net.ImageFormat(ChannelOrder.Luminance, ChannelType.Float);
FloatMap outMap = new FloatMap(w, h);
IMem outputMapBuffer = Cl.CreateImage2D(_context, MemFlags.WriteOnly, clOutImageFormat,
(IntPtr)outMap.W, (IntPtr)outMap.H, new IntPtr(outMap.Stride * sizeof(float)),
outMap._buf, out err);
assert(err, "output img creation");
err = Cl.SetKernelArg(kernel, 0, intPtrSize, inputImage2DBuffer);
assert(err, "input img setKernelArg");
err = Cl.SetKernelArg(kernel, 1, intPtrSize, outputMapBuffer);
assert(err, "output img setKernelArg");
Event clevent;
//Copy input image from the host to the GPU.
IntPtr[] originPtr = new IntPtr[] { (IntPtr)0, (IntPtr)0, (IntPtr)0 }; //x, y, z
IntPtr[] regionPtr = new IntPtr[] { (IntPtr)w, (IntPtr)h, (IntPtr)1 }; //x, y, z
IntPtr[] workGroupSizePtr = new IntPtr[] { (IntPtr)w, (IntPtr)h, (IntPtr)1 };
//err = Cl.EnqueueWriteImage(_commandsQueue, inputImage2DBuffer, Bool.True, originPtr, regionPtr, (IntPtr)0, (IntPtr)0, inputByteArray, 0, null, out clevent);
//assert(err, "Cl.EnqueueWriteImage");
//Execute our kernel (OpenCL code)
err = Cl.EnqueueNDRangeKernel(_commandsQueue, kernel, 2, null, workGroupSizePtr, null, 0, null, out clevent);
clevent.Dispose();
assert(err, "Cl.EnqueueNDRangeKernel");
//Wait for completion of all calculations on the GPU.
err = Cl.Finish(_commandsQueue);
assert(err, "Cl.Finish");
err = Cl.EnqueueReadImage(_commandsQueue, outputMapBuffer, Bool.True, originPtr, regionPtr, new IntPtr(outMap.Stride * sizeof(float)), (IntPtr)0, outMap._buf, 0, null, out clevent);
clevent.Dispose();
assert(err, "read output buffer");
Cl.ReleaseMemObject(inputImage2DBuffer);
Cl.ReleaseMemObject(outputMapBuffer);
return(outMap);
}
// copypasted/modified from Map2Bmp
public Bitmap Map2BmpFauxColors(FloatMap inMap, float k)
{
var kernel = _kernels["mapToFauxColorsBmp"];
int w = inMap.W;
int h = inMap.H;
var clInImageFormat = new OpenCL.Net.ImageFormat(ChannelOrder.Luminance, ChannelType.Float);
IMem inputImage2DBuffer = Cl.CreateImage2D(_context, MemFlags.CopyHostPtr | MemFlags.ReadOnly, clInImageFormat,
(IntPtr)w, (IntPtr)h,
new IntPtr(inMap.Stride * sizeof(float)), inMap._buf, out err);
assert(err, "input img creation");
var clOutImageFormat = new OpenCL.Net.ImageFormat(ChannelOrder.RGBA, ChannelType.Unsigned_Int8);
IMem outputImage2DBuffer = Cl.CreateImage2D(_context, MemFlags.WriteOnly, clOutImageFormat,
(IntPtr)w, (IntPtr)h,
(IntPtr)0, (IntPtr)0, out err);
assert(err, "output img creation");
err = Cl.SetKernelArg(kernel, 0, intPtrSize, inputImage2DBuffer);
assert(err, "input img setKernelArg");
err = Cl.SetKernelArg(kernel, 1, intPtrSize, outputImage2DBuffer);
assert(err, "output img setKernelArg");
err = Cl.SetKernelArg(kernel, 2, floatSize, k);
assert(err, "k setKernelArg");
Event clevent;
//x, y, z
IntPtr[] originPtr = new IntPtr[] { (IntPtr)0, (IntPtr)0, (IntPtr)0 };
IntPtr[] regionPtr = new IntPtr[] { (IntPtr)w, (IntPtr)h, (IntPtr)1 };
IntPtr[] workGroupSizePtr = new IntPtr[] { (IntPtr)w, (IntPtr)h, (IntPtr)1 };
//err = Cl.EnqueueWriteImage(_commandsQueue, inputImage2DBuffer, Bool.True, originPtr, regionPtr, (IntPtr)0, (IntPtr)0, inputByteArray, 0, null, out clevent);
//assert(err, "Cl.EnqueueWriteImage");
//Execute kernel
err = Cl.EnqueueNDRangeKernel(_commandsQueue, kernel, 2, null, workGroupSizePtr, null, 0, null, out clevent);
clevent.Dispose();
assert(err, "Cl.EnqueueNDRangeKernel");
//Wait for completion
err = Cl.Finish(_commandsQueue);
assert(err, "Cl.Finish");
// get data back
var outputByteArray = new byte[w * h * 4];
err = Cl.EnqueueReadImage(_commandsQueue, outputImage2DBuffer, Bool.True, originPtr, regionPtr, (IntPtr)0, (IntPtr)0, outputByteArray, 0, null, out clevent);
clevent.Dispose();
assert(err, "read output buffer");
Cl.ReleaseMemObject(inputImage2DBuffer);
Cl.ReleaseMemObject(outputImage2DBuffer);
GCHandle pinnedOutputArray = GCHandle.Alloc(outputByteArray, GCHandleType.Pinned);
IntPtr outputBmpPointer = pinnedOutputArray.AddrOfPinnedObject();
var bmp = new Bitmap(w, h, w * 4, PixelFormat.Format32bppArgb, outputBmpPointer);
pinnedOutputArray.Free();
return bmp;
}
public void ImagingTest(string inputImagePath, string outputImagePath)
{
ErrorCode error;
//Load and compile kernel source code.
string programPath = System.Environment.CurrentDirectory + "/../../imagingtest.cl"; //The path to the source file may vary
if (!System.IO.File.Exists(programPath))
{
Console.WriteLine("Program doesn't exist at path " + programPath);
return;
}
string programSource = System.IO.File.ReadAllText(programPath);
using (Program program = Cl.CreateProgramWithSource(_context, 1, new[] { programSource }, null, out error))
{
CheckErr(error, "Cl.CreateProgramWithSource");
//Compile kernel source
error = Cl.BuildProgram(program, 1, new[] { _device }, string.Empty, null, IntPtr.Zero);
CheckErr(error, "Cl.BuildProgram");
//Check for any compilation errors
if (Cl.GetProgramBuildInfo(program, _device, ProgramBuildInfo.Status, out error).CastTo<BuildStatus>()
!= BuildStatus.Success && 1==0)
{
CheckErr(error, "Cl.GetProgramBuildInfo");
Console.WriteLine("Cl.GetProgramBuildInfo != Success");
Console.WriteLine(Cl.GetProgramBuildInfo(program, _device, ProgramBuildInfo.Log, out error));
return;
}
//Create the required kernel (entry function)
Kernel kernel = Cl.CreateKernel(program, "imagingTest", out error);
CheckErr(error, "Cl.CreateKernel");
int intPtrSize = 0;
intPtrSize = Marshal.SizeOf(typeof(IntPtr));
//Image's RGBA data converted to an unmanaged[] array
byte[] inputByteArray;
//OpenCL memory buffer that will keep our image's byte[] data.
Mem inputImage2DBuffer;
OpenCL.Net.ImageFormat clImageFormat = new OpenCL.Net.ImageFormat(ChannelOrder.RGBA, ChannelType.Unsigned_Int8);
int inputImgWidth, inputImgHeight;
int inputImgBytesSize;
int inputImgStride;
//Try loading the input image
using (FileStream imageFileStream = new FileStream(inputImagePath, FileMode.Open))
{
System.Drawing.Image inputImage = System.Drawing.Image.FromStream(imageFileStream);
if (inputImage == null)
{
Console.WriteLine("Unable to load input image");
return;
}
inputImgWidth = inputImage.Width;
inputImgHeight = inputImage.Height;
System.Drawing.Bitmap bmpImage = new System.Drawing.Bitmap(inputImage);
//Get raw pixel data of the bitmap
//The format should match the format of clImageFormat
BitmapData bitmapData = bmpImage.LockBits(new Rectangle(0, 0, bmpImage.Width, bmpImage.Height),
ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);//inputImage.PixelFormat);
inputImgStride = bitmapData.Stride;
inputImgBytesSize = bitmapData.Stride * bitmapData.Height;
//Copy the raw bitmap data to an unmanaged byte[] array
inputByteArray = new byte[inputImgBytesSize];
Marshal.Copy(bitmapData.Scan0, inputByteArray, 0, inputImgBytesSize);
//Allocate OpenCL image memory buffer
inputImage2DBuffer = (OpenCL.Net.Mem)OpenCL.Net.Cl.CreateImage2D(_context,
OpenCL.Net.MemFlags.CopyHostPtr | OpenCL.Net.MemFlags.ReadOnly, clImageFormat,
(IntPtr)bitmapData.Width, (IntPtr)bitmapData.Height,
(IntPtr)0, inputByteArray, out error);
CheckErr(error, "Cl.CreateImage2D input");
}
//Unmanaged output image's raw RGBA byte[] array
byte[] outputByteArray = new byte[inputImgBytesSize];
//Allocate OpenCL image memory buffer
OpenCL.Net.Mem outputImage2DBuffer = (OpenCL.Net.Mem)OpenCL.Net.Cl.CreateImage2D(_context, OpenCL.Net.MemFlags.CopyHostPtr | OpenCL.Net.MemFlags.WriteOnly, clImageFormat,
(IntPtr)inputImgWidth, (IntPtr)inputImgHeight, (IntPtr)0, outputByteArray, out error);
CheckErr(error, "Cl.CreateImage2D output");
//Pass the memory buffers to our kernel function
error = Cl.SetKernelArg(kernel, 0, (IntPtr)intPtrSize, inputImage2DBuffer);
error |= Cl.SetKernelArg(kernel, 1, (IntPtr)intPtrSize, outputImage2DBuffer);
CheckErr(error, "Cl.SetKernelArg");
//Create a command queue, where all of the commands for execution will be added
CommandQueue cmdQueue = Cl.CreateCommandQueue(_context, _device, (CommandQueueProperties)0, out error);
CheckErr(error, "Cl.CreateCommandQueue");
OpenCL.Net.Event clevent;
//Copy input image from the host to the GPU.
IntPtr[] originPtr = new IntPtr[] { (IntPtr)0, (IntPtr)0, (IntPtr)0 }; //x, y, z
IntPtr[] regionPtr = new IntPtr[] { (IntPtr)inputImgWidth, (IntPtr)inputImgHeight, (IntPtr)1 }; //x, y, z
IntPtr[] workGroupSizePtr = new IntPtr[] { (IntPtr)inputImgWidth, (IntPtr)inputImgHeight, (IntPtr)1 };
error = Cl.EnqueueWriteImage(cmdQueue, inputImage2DBuffer, OpenCL.Net.Bool.True, originPtr, regionPtr, (IntPtr)0, (IntPtr)0, inputByteArray, 0, null, out clevent);
CheckErr(error, "Cl.EnqueueWriteImage");
//Execute our kernel (OpenCL code)
// CommandQueue q = new OpenCL.Net.CommandQueue();
//enqueue nd range kernel
// error = cmdQueue.EnqueueKernel(cmdQueue, kernel, 2, null, workGroupSizePtr, null, 0, null, out clevent);
// OpenCL.Net.Cl.EnqueueNDRangeKernel(
OpenCL.Net.Cl.EnqueueNDRangeKernel(cmdQueue, kernel, 2, null, workGroupSizePtr, null, 0, null, out clevent);
CheckErr(error, "Cl.EnqueueNDRangeKernel");
//Wait for completion of all calculations on the GPU.
error = Cl.Finish(cmdQueue);
CheckErr(error, "Cl.Finish");
//Read the processed image from GPU to raw RGBA data byte[] array
error = Cl.EnqueueReadImage(cmdQueue, outputImage2DBuffer, OpenCL.Net.Bool.True, originPtr, regionPtr,
(IntPtr)0, (IntPtr)0, outputByteArray, 0, null, out clevent);
CheckErr(error, "Cl.clEnqueueReadImage");
//Clean up memory
Cl.ReleaseKernel(kernel);
Cl.ReleaseCommandQueue(cmdQueue);
Cl.ReleaseMemObject(inputImage2DBuffer);
Cl.ReleaseMemObject(outputImage2DBuffer);
//Get a pointer to our unmanaged output byte[] array
GCHandle pinnedOutputArray = GCHandle.Alloc(outputByteArray, GCHandleType.Pinned);
IntPtr outputBmpPointer = pinnedOutputArray.AddrOfPinnedObject();
//Create a new bitmap with processed data and save it to a file.
Bitmap outputBitmap = new Bitmap(inputImgWidth, inputImgHeight, inputImgStride, PixelFormat.Format32bppArgb, outputBmpPointer);
outputBitmap.Save(outputImagePath, System.Drawing.Imaging.ImageFormat.Png);
pinnedOutputArray.Free();
}
}
/* Broken at the moment. */
public void GetStatGPU(string file)
{
var stopwatch = new System.Diagnostics.Stopwatch();
stopwatch.Start();
stopwatch.Restart();
ErrorCode err;
using (OpenCL.Net.Program program = Cl.CreateProgramWithSource(clInfo._context, 1, new[] { clInfo.KernelSrc }, null, out err))
{
clInfo.CheckErr(err, "Cl.CreateProgramWithSource");
//Compile Kernels & check errors.
err = Cl.BuildProgram(program, 1, new[] { clInfo._device }, string.Empty, null, IntPtr.Zero);
clInfo.CheckErr(err, "Cl.BuildProgram");
if (Cl.GetProgramBuildInfo(program, clInfo._device, ProgramBuildInfo.Status, out err).CastTo <BuildStatus>() != BuildStatus.Success)
{
clInfo.CheckErr(err, "Cl.GetProgramBuildInfo");
Console.WriteLine("Cl.GetProgramBuildInfo != Success");
Console.WriteLine(Cl.GetProgramBuildInfo(program, clInfo._device, ProgramBuildInfo.Log, out err));
}
//Specify the specific kernel for use
Kernel kernel = Cl.CreateKernel(program, "satAvg", out err);
clInfo.CheckErr(err, "Cl.CreateKernel");
int intPtrSize = 0;
intPtrSize = Marshal.SizeOf(typeof(IntPtr));
IMem image2DBuffer;
OpenCL.Net.ImageFormat imageFormat = new OpenCL.Net.ImageFormat(ChannelOrder.RGBA, ChannelType.Unsigned_Int8);
int imageWidth, imageHeight, imageBytesSize, imageStride;
using (FileStream imgStream = new FileStream(file, FileMode.Open))
{
Image image = Image.FromStream(imgStream);
if (image == null)
{
Console.Error.WriteLine($"failed to open file {file}");
return;
}
imageWidth = image.Width;
imageHeight = image.Height;
//Create a bitmap from the file with the correct channel settings.
Bitmap inputBitmap = new Bitmap(image);
BitmapData bitmapDat = inputBitmap.LockBits(new Rectangle(0, 0, inputBitmap.Width, inputBitmap.Height),
ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
imageStride = bitmapDat.Stride;
imageBytesSize = imageStride * bitmapDat.Height;
byte[] inputByteArray = new byte[imageBytesSize];
Marshal.Copy(bitmapDat.Scan0, inputByteArray, 0, imageBytesSize);
//Create & populate memory buffer for use in Kernel
image2DBuffer = Cl.CreateImage2D(clInfo._context,
MemFlags.CopyHostPtr | MemFlags.ReadOnly, imageFormat,
(IntPtr)inputBitmap.Width,
(IntPtr)inputBitmap.Height,
(IntPtr)0, inputByteArray, out err);
clInfo.CheckErr(err, "Cl.CreateImage2D output");
}
//Create an output buffer for the average saturation of the image.
float saturation = 0;
IMem sat = Cl.CreateBuffer(clInfo._context, MemFlags.CopyHostPtr | MemFlags.WriteOnly, (IntPtr)intPtrSize, (object)saturation, out err);
clInfo.CheckErr(err, "Cl.CreateBuffer saturation");
//Passing buffers to the CL kernel
err = Cl.SetKernelArg(kernel, 0, (IntPtr)intPtrSize, image2DBuffer);
//TODO: Figure out how to pass a float to the kernel
//err |= Cl.SetKernelArg(kernel, 1, (IntPtr)intPtrSize, sat );
clInfo.CheckErr(err, "Cl.SetKernelArg");
//Create & queue commands
CommandQueue cmdQueue = Cl.CreateCommandQueue(clInfo._context, clInfo._device, CommandQueueProperties.None, out err);
clInfo.CheckErr(err, "Cl.CreateCommandQueue");
Event @event;
//Transfer image data to kernel buffers
IntPtr[] originPtr = new IntPtr[] { (IntPtr)0, (IntPtr)0, (IntPtr)0 };
IntPtr[] regionPtr = new IntPtr[] { (IntPtr)imageWidth, (IntPtr)imageHeight, (IntPtr)1 };
IntPtr[] workGroupPtr = new IntPtr[] { (IntPtr)imageWidth, (IntPtr)imageHeight, (IntPtr)1 };
err = Cl.EnqueueReadImage(cmdQueue, image2DBuffer, Bool.True, originPtr, regionPtr, (IntPtr)0, (IntPtr)0, null, 0, null, out @event);
clInfo.CheckErr(err, "Cl.EnqueueReadImage");
//Execute the kerenl
err = Cl.EnqueueNDRangeKernel(cmdQueue, kernel, 2, null, workGroupPtr, null, 0, null, out @event);
clInfo.CheckErr(err, "Cl.EnqueueNDRangeKernel");
err = Cl.Finish(cmdQueue);
clInfo.CheckErr(err, "Cl.Finish");
Cl.ReleaseKernel(kernel);
Cl.ReleaseCommandQueue(cmdQueue);
Cl.ReleaseMemObject(image2DBuffer);
}
Console.WriteLine(stopwatch.Elapsed);
stopwatch.Stop();
}
public FloatMap Bmp2Map(Bitmap bmpImage)
{
var kernel = _kernels["getLumaImg"];
int w = bmpImage.Width;
int h = bmpImage.Height;
BitmapData bitmapData = bmpImage.LockBits(new Rectangle(0, 0, w, h), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
int inputImgStride = bitmapData.Stride;
int inputImgBytesSize = bitmapData.Stride * bitmapData.Height;
//Copy the raw bitmap data to an unmanaged byte[] array
byte[] inputByteArray = new byte[inputImgBytesSize];
Marshal.Copy(bitmapData.Scan0, inputByteArray, 0, inputImgBytesSize);
var clInImageFormat = new OpenCL.Net.ImageFormat(ChannelOrder.RGBA, ChannelType.Unsigned_Int8);
//Allocate OpenCL image memory buffer
IMem inputImage2DBuffer = Cl.CreateImage2D(_context, MemFlags.CopyHostPtr | MemFlags.ReadOnly, clInImageFormat,
(IntPtr)bitmapData.Width, (IntPtr)bitmapData.Height,
(IntPtr)0, inputByteArray, out err);
assert(err, "input img creation");
var clOutImageFormat = new OpenCL.Net.ImageFormat(ChannelOrder.Luminance, ChannelType.Float);
FloatMap outMap = new FloatMap(w, h);
IMem outputMapBuffer = Cl.CreateImage2D(_context, MemFlags.WriteOnly, clOutImageFormat,
(IntPtr)outMap.W, (IntPtr)outMap.H, new IntPtr(outMap.Stride * sizeof(float)),
outMap._buf, out err);
assert(err, "output img creation");
err = Cl.SetKernelArg(kernel, 0, intPtrSize, inputImage2DBuffer);
assert(err, "input img setKernelArg");
err = Cl.SetKernelArg(kernel, 1, intPtrSize, outputMapBuffer);
assert(err, "output img setKernelArg");
Event clevent;
//Copy input image from the host to the GPU.
IntPtr[] originPtr = new IntPtr[] { (IntPtr)0, (IntPtr)0, (IntPtr)0 }; //x, y, z
IntPtr[] regionPtr = new IntPtr[] { (IntPtr)w, (IntPtr)h, (IntPtr)1 }; //x, y, z
IntPtr[] workGroupSizePtr = new IntPtr[] { (IntPtr)w, (IntPtr)h, (IntPtr)1 };
//err = Cl.EnqueueWriteImage(_commandsQueue, inputImage2DBuffer, Bool.True, originPtr, regionPtr, (IntPtr)0, (IntPtr)0, inputByteArray, 0, null, out clevent);
//assert(err, "Cl.EnqueueWriteImage");
//Execute our kernel (OpenCL code)
err = Cl.EnqueueNDRangeKernel(_commandsQueue, kernel, 2, null, workGroupSizePtr, null, 0, null, out clevent);
clevent.Dispose();
assert(err, "Cl.EnqueueNDRangeKernel");
//Wait for completion of all calculations on the GPU.
err = Cl.Finish(_commandsQueue);
assert(err, "Cl.Finish");
err = Cl.EnqueueReadImage(_commandsQueue, outputMapBuffer, Bool.True, originPtr, regionPtr, new IntPtr(outMap.Stride * sizeof(float)), (IntPtr)0, outMap._buf, 0, null, out clevent);
clevent.Dispose();
assert(err, "read output buffer");
Cl.ReleaseMemObject(inputImage2DBuffer);
Cl.ReleaseMemObject(outputMapBuffer);
return outMap;
}
public Bitmap GPUMandel(Bitmap inputBitmap)
{
ErrorCode error;
//Load and compile kernel source code.
string programPath = System.Environment.CurrentDirectory + "/../../program.cl";
//The path to the source file may vary
if (!System.IO.File.Exists(programPath))
{
Console.WriteLine("Program doesn't exist at path " + programPath);
return(inputBitmap);
}
string programSource = System.IO.File.ReadAllText(programPath);
using (Program program = Cl.CreateProgramWithSource(_context, 1, new[] { programSource }, null, out error))
{
CheckErr(error, "Cl.CreateProgramWithSource");
//Compile kernel source
error = Cl.BuildProgram(program, 1, new[] { _device }, string.Empty, null, IntPtr.Zero);
CheckErr(error, "Cl.BuildProgram");
//Check for any compilation errors
if (Cl.GetProgramBuildInfo(program, _device, ProgramBuildInfo.Status, out error).CastTo <BuildStatus>()
!= BuildStatus.Success)
{
CheckErr(error, "Cl.GetProgramBuildInfo");
Console.WriteLine("Cl.GetProgramBuildInfo != Success");
Console.WriteLine(Cl.GetProgramBuildInfo(program, _device, ProgramBuildInfo.Log, out error));
return(inputBitmap);
}
//Create the required kernel (entry function)
Kernel kernel = Cl.CreateKernel(program, "Mandelbrot", out error);
CheckErr(error, "Cl.CreateKernel");
//Unmanaged output image's raw RGBA byte[] array
BitmapData bitmapData = inputBitmap.LockBits(new Rectangle(0, 0, inputBitmap.Width, inputBitmap.Height), ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
int inputImgBytesSize = bitmapData.Stride * bitmapData.Height;
int inputImgWidth = inputBitmap.Width;
int inputImgHeight = inputBitmap.Height;
int intPtrSize = Marshal.SizeOf(typeof(IntPtr));
OpenCL.Net.ImageFormat clImageFormat = new OpenCL.Net.ImageFormat(ChannelOrder.RGBA, ChannelType.Unsigned_Int8);
//OpenCL.Net.ImageFormat clImageFormat = new OpenCL.Net.ImageFormat(ChannelOrder.RGBA, ChannelType.Float);
byte[] outputByteArray = new byte[inputImgBytesSize];
//Allocate OpenCL image memory buffer
Mem outputImage2DBuffer = (Mem)Cl.CreateImage2D(_context, MemFlags.CopyHostPtr |
MemFlags.WriteOnly, clImageFormat, (IntPtr)inputImgWidth,
(IntPtr)inputImgHeight, (IntPtr)0, outputByteArray, out error);
CheckErr(error, "Cl.CreateImage2D output");
//Pass the memory buffers to our kernel function
error = Cl.SetKernelArg(kernel, 0, (IntPtr)intPtrSize, outputImage2DBuffer);
CheckErr(error, "Cl.SetKernelArg");
//Create a command queue, where all of the commands for execution will be added
CommandQueue cmdQueue = Cl.CreateCommandQueue(_context, _device, (CommandQueueProperties)0, out error);
CheckErr(error, "Cl.CreateCommandQueue");
Event clevent;
//Copy input image from the host to the GPU.
IntPtr[] originPtr = new IntPtr[] { (IntPtr)0, (IntPtr)0, (IntPtr)0 }; //x, y, z
IntPtr[] regionPtr = new IntPtr[] { (IntPtr)inputImgWidth, (IntPtr)inputImgHeight, (IntPtr)1 }; //x, y, z
IntPtr[] workGroupSizePtr = new IntPtr[] { (IntPtr)inputImgWidth, (IntPtr)inputImgHeight, (IntPtr)1 };
error = Cl.EnqueueWriteImage(cmdQueue, outputImage2DBuffer, Bool.True,
originPtr, regionPtr, (IntPtr)0, (IntPtr)0, outputByteArray, 0, null, out clevent);
CheckErr(error, "Cl.EnqueueWriteImage");
//Execute our kernel (OpenCL code)
error = Cl.EnqueueNDRangeKernel(cmdQueue, kernel, 2, null, workGroupSizePtr, null, 0, null, out clevent);
CheckErr(error, "Cl.EnqueueNDRangeKernel");
//Wait for completion of all calculations on the GPU.
error = Cl.Finish(cmdQueue);
CheckErr(error, "Cl.Finish");
//Read the processed image from GPU to raw RGBA data byte[] array
error = Cl.EnqueueReadImage(cmdQueue, outputImage2DBuffer, Bool.True, originPtr, regionPtr,
(IntPtr)0, (IntPtr)0, outputByteArray, 0, null, out clevent);
CheckErr(error, "Cl.clEnqueueReadImage");
//Clean up memory
Cl.ReleaseKernel(kernel);
Cl.ReleaseCommandQueue(cmdQueue);
//Cl.ReleaseMemObject(inputImage2DBuffer);
Cl.ReleaseMemObject(outputImage2DBuffer);
//Get a pointer to our unmanaged output byte[] array
GCHandle pinnedOutputArray = GCHandle.Alloc(outputByteArray, GCHandleType.Pinned);
IntPtr outputBmpPointer = pinnedOutputArray.AddrOfPinnedObject();
//Create a new bitmap with processed data and save it to a file.
Bitmap outputBitmap = new Bitmap(inputImgWidth, inputImgHeight,
bitmapData.Stride, PixelFormat.Format32bppArgb, outputBmpPointer);
return(outputBitmap);
//outputBitmap.Save(outputImagePath, System.Drawing.Imaging.ImageFormat.Png);
//pinnedOutputArray.Free();
}
}
public ClImage2D(Bitmap bitmap, Context context, IOMode iOMode, ChannelType channelType, out ErrorCode error)
{
switch (channelType)
{
case ChannelType.RGBA32bpp:
clImageFormat = new OpenCL.Net.ImageFormat(ChannelOrder.RGBA, Net.ChannelType.Unsigned_Int8);
pixelFormat = PixelFormat.Format32bppArgb;
break;
case ChannelType.Single8bpp:
clImageFormat = new OpenCL.Net.ImageFormat(ChannelOrder.R, Net.ChannelType.Unsigned_Int8);
pixelFormat = PixelFormat.Format8bppIndexed;
break;
}
ready = false;
original = bitmap;
this.Width = bitmap.Width;
this.Height = bitmap.Height;
this.iOMode = iOMode;
//Lock bitmap
switch (iOMode)
{
case IOMode.ReadOnly:
bitmapData = bitmap.LockBits(new Rectangle(0, 0, Width, Height),
ImageLockMode.ReadOnly, pixelFormat);
break;
case IOMode.WriteOnly:
bitmapData = bitmap.LockBits(new Rectangle(0, 0, Width, Height),
ImageLockMode.WriteOnly, pixelFormat);
break;
case IOMode.ReadWrite:
bitmapData = bitmap.LockBits(new Rectangle(0, 0, Width, Height),
ImageLockMode.ReadWrite, pixelFormat);
break;
}
//Get image properties
this.Stride = bitmapData.Stride;
this.Size = Stride * Height;
//Crate cl memory object
switch (iOMode)
{
default:
case IOMode.ReadOnly:
clMem = Cl.CreateImage2D(context, MemFlags.UseHostPtr | MemFlags.ReadOnly, clImageFormat,
(IntPtr)Width, (IntPtr)Height, (IntPtr)0,
bitmapData.Scan0, out error);
break;
case IOMode.WriteOnly:
clMem = Cl.CreateImage2D(context, MemFlags.AllocHostPtr | MemFlags.WriteOnly, clImageFormat,
(IntPtr)Width, (IntPtr)Height, (IntPtr)0,
null, out error);
break;
case IOMode.ReadWrite:
clMem = Cl.CreateImage2D(context, MemFlags.UseHostPtr | MemFlags.ReadWrite, clImageFormat,
(IntPtr)Width, (IntPtr)Height, (IntPtr)0,
bitmapData.Scan0, out error);
break;
}
//Check error
if (error == ErrorCode.Success)
{
ready = true;
}
else
{
UnlockBits();
}
}
ErrorCode queue_scrypt_kernel(clState _clState, dev_blk_ctx blk)
{
//Scantime
blk.work.midstate0 = new uint4(0);
blk.work.midstate16 = new uint4(1);
// unsigned char *midstate = blk->work->midstate;
int num = 0;
uint16 le_target;
le_target = new uint16(Convert.ToUInt16(blk.work.device_target + 28));
_clState.cldata = blk.work.data;
_clState.CLBuffer0 = new uint4(0);
_clState.outputBuffer = new Mem();
_clState.padbuffer8 = new uint4(0);
OpenCL.Net.Event clevent;
OpenCL.Net.ImageFormat clImageFormat = new OpenCL.Net.ImageFormat(ChannelOrder.RGBA, ChannelType.Unsigned_Int8);
ErrorCode err1;
byte[] inputByteArray = new byte[1024];
//buffer0 = (OpenCL.Net.Mem)OpenCL.Net.Cl.CreateImage2D(_clState.cl_context, OpenCL.Net.MemFlags.CopyHostPtr | OpenCL.Net.MemFlags.ReadOnly, clImageFormat, (IntPtr)1024, (IntPtr)1, (IntPtr)0, inputByteArray, out err1);
// buffer0 = (OpenCL.Net.Mem)inputByteArray;
// byte[] byteSrcImage2DData = new byte[srcIMGBytesSize];
Mem buffer0 = (Mem)OpenCL.Net.Cl.CreateBuffer(_clState.cl_context, MemFlags.ReadWrite, 1024,out err1);
ErrorCode status =Cl.EnqueueWriteBuffer(_clState.cl_command_queue, buffer0, OpenCL.Net.Bool.True, (IntPtr)0, (IntPtr)1024, _clState.cldata, 0, null,out clevent);
//
// status = OpenCL.Net.Cl.SetKernelArg(_clState.Kernel, num++, sizeof(var), (void *)&var)
// CL_SET_VARG(args, var) status |= clSetKernelArg(*kernel, num++, args * sizeof(uint), (void *)var)
int intPtrSize = 0;
intPtrSize = Marshal.SizeOf(typeof(IntPtr));
OpenCL.Net.Cl.SetKernelArg(_clState.cl_kernel, 0,(IntPtr)intPtrSize, _clState.CLBuffer0);
OpenCL.Net.Cl.SetKernelArg(_clState.cl_kernel, 1, _clState.outputBuffer);
OpenCL.Net.Cl.SetKernelArg(_clState.cl_kernel, 2, _clState.padbuffer8);
OpenCL.Net.Cl.SetKernelArg(_clState.cl_kernel, 3, blk.work.midstate0);
OpenCL.Net.Cl.SetKernelArg(_clState.cl_kernel, 4, blk.work.midstate16);
// CL_SET_VARG(4, &midstate[0]);
// CL_SET_VARG(4, &midstate[16]);
OpenCL.Net.Cl.SetKernelArg(_clState.cl_kernel, 5,le_target);
//error = Cl.SetKernelArg(kernel, 0, (IntPtr)intPtrSize, inputImage2DBuffer);
CheckErr(status, "Cl.SetKernelArg");
return status;
}
public HTTPResponse GetResponse(HTTPRequest request)
{
HTTPResponse response = new HTTPResponse(200);
StringBuilder sb = new StringBuilder();
ErrorCode error;
if (!_isInit)
{
init();
_isInit = true;
}
if (request.Method == HTTPRequest.METHOD_GET)
{
// Input form, this can be place by any HTML page
sb.Append("<html><body>");
sb.Append(GenUploadForm());
sb.Append("</body></html>");
response.Body = Encoding.UTF8.GetBytes(sb.ToString());
return(response);
}
else if (request.Method == HTTPRequest.METHOD_POST)
{
// Get remote image from URL
string url = Uri.UnescapeDataString(request.GetRequestByKey("imageUploadUrl"));
byte[] data;
try {
data = DownloadImageFromUrl(url);
} catch (Exception) {
return(new HTTPResponse(400));
}
// https://www.codeproject.com/Articles/502829/GPGPU-image-processing-basics-using-OpenCL-NET
// Convert image to bitmap binary
Image inputImage = Image.FromStream(new MemoryStream(data));
if (inputImage == null)
{
return(new HTTPResponse(500));
}
int imagewidth = inputImage.Width;
int imageHeight = inputImage.Height;
Bitmap bmpImage = new Bitmap(inputImage);
BitmapData bitmapData = bmpImage.LockBits(new Rectangle(0, 0, bmpImage.Width, bmpImage.Height), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
int inputImageByteSize = bitmapData.Stride * bitmapData.Height;
byte[] inputByteArray = new byte[inputImageByteSize];
Marshal.Copy(bitmapData.Scan0, inputByteArray, 0, inputImageByteSize);
// Load kernel source code
string programPath = System.Environment.CurrentDirectory + "/Kernel.cl";
if (!System.IO.File.Exists(programPath))
{
return(new HTTPResponse(404));
}
string programSource = System.IO.File.ReadAllText(programPath);
using (OpenCL.Net.Program program = Cl.CreateProgramWithSource(_context, 1, new[] { programSource }, null, out error)) {
// Create kernel
LogError(error, "Cl.CreateProgramWithSource");
error = Cl.BuildProgram(program, 1, new[] { _device }, string.Empty, null, IntPtr.Zero);
LogError(error, "Cl.BuildProgram");
if (Cl.GetProgramBuildInfo(program, _device, ProgramBuildInfo.Status, out error).CastTo <OpenCL.Net.BuildStatus>()
!= BuildStatus.Success)
{
LogError(error, "Cl.GetProgramBuildInfo");
return(new HTTPResponse(404));
}
Kernel kernel = Cl.CreateKernel(program, _parameters["KernelFunction"], out error);
LogError(error, "Cl.CreateKernel");
// Create image memory objects
OpenCL.Net.ImageFormat clImageFormat = new OpenCL.Net.ImageFormat(ChannelOrder.RGBA, ChannelType.Unsigned_Int8);
IMem inputImage2DBuffer = Cl.CreateImage2D(_context, MemFlags.CopyHostPtr | MemFlags.ReadOnly,
clImageFormat, (IntPtr)bitmapData.Width, (IntPtr)bitmapData.Height,
(IntPtr)0, inputByteArray, out error);
LogError(error, "CreateImage2D input");
byte[] outputByteArray = new byte[inputImageByteSize];
IMem outputImage2DBuffer = Cl.CreateImage2D(_context, MemFlags.CopyHostPtr | MemFlags.WriteOnly,
clImageFormat, (IntPtr)bitmapData.Width, (IntPtr)bitmapData.Height,
(IntPtr)0, outputByteArray, out error);
LogError(error, "CreateImage2D output");
// Set arguments
int IntPtrSize = Marshal.SizeOf(typeof(IntPtr));
error = Cl.SetKernelArg(kernel, 0, (IntPtr)IntPtrSize, inputImage2DBuffer);
error |= Cl.SetKernelArg(kernel, 1, (IntPtr)IntPtrSize, outputImage2DBuffer);
LogError(error, "Cl.SetKernelArg");
// Create command queue
CommandQueue cmdQueue = Cl.CreateCommandQueue(_context, _device, (CommandQueueProperties)0, out error);
LogError(error, "Cl.CreateCommandQueue");
Event clevent;
// Copy input image from the host to the GPU
IntPtr[] originPtr = new IntPtr[] { (IntPtr)0, (IntPtr)0, (IntPtr)0 };
IntPtr[] regionPtr = new IntPtr[] { (IntPtr)imagewidth, (IntPtr)imageHeight, (IntPtr)1 };
IntPtr[] workGroupSizePtr = new IntPtr[] { (IntPtr)imagewidth, (IntPtr)imageHeight, (IntPtr)1 };
error = Cl.EnqueueWriteImage(cmdQueue, inputImage2DBuffer, Bool.True, originPtr, regionPtr, (IntPtr)0,
(IntPtr)0, inputByteArray, 0, null, out clevent);
LogError(error, "Cl.EnqueueWriteImage");
// Run the kernel
error = Cl.EnqueueNDRangeKernel(cmdQueue, kernel, 2, null, workGroupSizePtr, null, 0, null, out clevent);
LogError(error, "Cl.EnqueueNDRangeKernel");
// Wait for finish event
error = Cl.Finish(cmdQueue);
LogError(error, "Cl.Finish");
// Read the output image back from GPU
error = Cl.EnqueueReadImage(cmdQueue, outputImage2DBuffer, Bool.True, originPtr, regionPtr, (IntPtr)0,
(IntPtr)0, outputByteArray, 0, null, out clevent);
LogError(error, "Cl.EnqueueReadImage");
error = Cl.Finish(cmdQueue);
LogError(error, "Cl.Finih");
// Release memory
Cl.ReleaseKernel(kernel);
Cl.ReleaseCommandQueue(cmdQueue);
Cl.ReleaseMemObject(inputImage2DBuffer);
Cl.ReleaseMemObject(outputImage2DBuffer);
// Convert binary bitmap to JPEG image and return as response
GCHandle pinnedOutputArray = GCHandle.Alloc(outputByteArray, GCHandleType.Pinned);
IntPtr outputBmpPointer = pinnedOutputArray.AddrOfPinnedObject();
Bitmap outputBitmap = new Bitmap(imagewidth, imageHeight, bitmapData.Stride, PixelFormat.Format32bppArgb, outputBmpPointer);
MemoryStream msOutput = new MemoryStream();
outputBitmap.Save(msOutput, System.Drawing.Imaging.ImageFormat.Jpeg);
response.Body = msOutput.ToArray();
response.Type = "image/jpeg";
return(response);
}
}
return(new HTTPResponse(501));
}
public void singlePass(Kernel kernel, FloatMap inMap, FloatMap outMap)
{
var clInImageFormat = new OpenCL.Net.ImageFormat(ChannelOrder.Luminance, ChannelType.Float);
IMem inputMapBuffer = Cl.CreateImage2D(_context, MemFlags.CopyHostPtr | MemFlags.ReadOnly, clInImageFormat,
(IntPtr)inMap.W, (IntPtr)inMap.H, new IntPtr(inMap.Stride * sizeof(float)),
inMap._buf, out err);
assert(err, "input img creation");
IMem outputMapBuffer = Cl.CreateImage2D(_context, MemFlags.WriteOnly, clInImageFormat,
(IntPtr)outMap.W, (IntPtr)outMap.H, new IntPtr(outMap.Stride * sizeof(float)),
outMap._buf, out err);
assert(err, "output img creation");
// Set memory objects as parameters to kernel
err = Cl.SetKernelArg(kernel, 0, intPtrSize, inputMapBuffer);
assert(err, "input map setKernelArg");
err = Cl.SetKernelArg(kernel, 1, intPtrSize, outputMapBuffer);
assert(err, "output map setKernelArg");
// write actual data into memory object
IntPtr[] originPtr = new IntPtr[] { (IntPtr)0, (IntPtr)0, (IntPtr)0 }; //x, y, z
IntPtr[] inRegionPtr = new IntPtr[] { (IntPtr)inMap.W, (IntPtr)inMap.H, (IntPtr)1 }; //x, y, z
IntPtr[] outRegionPtr = new IntPtr[] { (IntPtr)outMap.W, (IntPtr)outMap.H, (IntPtr)1 }; //x, y, z
IntPtr[] workGroupSizePtr = new IntPtr[] { (IntPtr)outMap.W, (IntPtr)outMap.H, (IntPtr)1 };
Event clevent;
//err = Cl.EnqueueWriteImage(_commandsQueue, inputMapBuffer, Bool.True, originPtr, inRegionPtr, (IntPtr)0, (IntPtr)0, inMap._buf, 0, null, out clevent);
//clevent.Dispose();
//assert(err, "write input img");
// execute
err = Cl.EnqueueNDRangeKernel(_commandsQueue, kernel, 2,
originPtr,
workGroupSizePtr,
null, 0, null, out clevent);
clevent.Dispose();
assert(err, "Cl.EnqueueNDRangeKernel");
// sync
Cl.Finish(_commandsQueue);
// read from output memory object into actual buffer
err = Cl.EnqueueReadImage(_commandsQueue, outputMapBuffer, Bool.True, originPtr, outRegionPtr, new IntPtr(outMap.Stride * sizeof(float)), (IntPtr)0, outMap._buf, 0, null, out clevent);
clevent.Dispose();
assert(err, "read output buffer");
Cl.ReleaseMemObject(inputMapBuffer);
Cl.ReleaseMemObject(outputMapBuffer);
}
public override Bitmap Plot()
{
ErrorCode error;
using (Kernel kernel = CompileKernel("mandelbrot"))
{
Bitmap plotImg = new Bitmap(Width, Height);
int intPtrSize = Marshal.SizeOf(typeof(IntPtr));
int uint4size = Marshal.SizeOf(typeof(uint4));
// Buffer do OpenCL para manter os dados da imagem
OpenCL.Net.ImageFormat clImageFormat = new OpenCL.Net.ImageFormat(ChannelOrder.RGBA, ChannelType.Unsigned_Int8);
//// Obtém o buffer de pixels
//BitmapData data = plotImg.LockBits(new Rectangle(0, 0, plotImg.Width, plotImg.Height), ImageLockMode.WriteOnly, plotImg.PixelFormat);
//int depth = Bitmap.GetPixelFormatSize(data.PixelFormat) / 8; // Tamanho de cada pixel em memória, em bytes
int depth = Bitmap.GetPixelFormatSize(PixelFormat.Format32bppArgb) / 8;
int stride = 4 * ((Width * depth + 3) / 4);
byte[] buffer = new byte[Height * stride]; // Cria o buffer para se trabalhar na imagem
//Marshal.Copy(data.Scan0, buffer, 0, buffer.Length); // Copia as informações da imagem no buffer
// Cria o buffer do OpenCL para a imagem
Mem image2dbuffer = (Mem)Cl.CreateImage2D(context, MemFlags.CopyHostPtr | MemFlags.WriteOnly, clImageFormat,
(IntPtr)Width, (IntPtr)Height,
(IntPtr)0, buffer, out error);
CheckErr(error, "Cl.CreateImage2D");
// Passa os parametros para o kernel
error = Cl.SetKernelArg(kernel, 0, (IntPtr)intPtrSize, image2dbuffer);
CheckErr(error, "Cl.SetKernelArg imageBuffer");
uint4 startColorUi = new uint4(Colors.StartColor.B, Colors.StartColor.G, Colors.StartColor.R, Colors.StartColor.A);
error = Cl.SetKernelArg(kernel, 1, (IntPtr)uint4size, startColorUi);
CheckErr(error, "Cl.SetKernelArg startColor");
uint4 endColorUi = new uint4(Colors.EndColor.B, Colors.EndColor.G, Colors.EndColor.R, Colors.EndColor.A);
error = Cl.SetKernelArg(kernel, 2, (IntPtr)uint4size, endColorUi);
CheckErr(error, "Cl.SetKernelArg endColor");
error = Cl.SetKernelArg(kernel, 3, (IntPtr)sizeof(int), Iterations);
CheckErr(error, "Cl.SetKernelArg iterations");
// Cria uma fila de comandos, com todos os comandos a serem executados pelo kernel
CommandQueue cmdQueue = Cl.CreateCommandQueue(context, device, 0, out error);
CheckErr(error, "Cl.CreateCommandQueue");
// Copia a imagem para a GPU
Event clevent;
IntPtr[] imgOriginPtr = new IntPtr[] { (IntPtr)0, (IntPtr)0, (IntPtr)0 }; //x, y, z
IntPtr[] imgRegionPtr = new IntPtr[] { (IntPtr)Width, (IntPtr)Height, (IntPtr)1 }; //x, y, z
error = Cl.EnqueueWriteImage(cmdQueue, image2dbuffer, Bool.True, imgOriginPtr, imgRegionPtr, (IntPtr)0, (IntPtr)0, buffer, 0, null, out clevent);
CheckErr(error, "Cl.EnqueueWriteImage");
// Executa o Kernel carregado pelo OpenCL (com múltiplos processadores :D)
IntPtr[] workGroupSizePtr = new IntPtr[] { (IntPtr)Width, (IntPtr)Height, (IntPtr)1 }; // x, y, z
error = Cl.EnqueueNDRangeKernel(cmdQueue, kernel, 2, null, workGroupSizePtr, null, 0, null, out clevent);
CheckErr(error, "Cl.EnqueueNDRangeKernel");
// Espera terminar a execução
error = Cl.Finish(cmdQueue);
CheckErr(error, "Cl.Finish");
// Lê a imagem processada pela GPU e coloca novamente no buffer
error = Cl.EnqueueReadImage(cmdQueue, image2dbuffer, Bool.True, imgOriginPtr, imgRegionPtr,
(IntPtr)0, (IntPtr)0, buffer, 0, null, out clevent);
CheckErr(error, "Cl.clEnqueueReadImage");
// Limpa a memória
Cl.ReleaseKernel(kernel);
Cl.ReleaseCommandQueue(cmdQueue);
Cl.ReleaseMemObject(image2dbuffer);
// Get a pointer to our unmanaged output byte[] array
//GCHandle pinnedBuffer = GCHandle.Alloc(buffer, GCHandleType.Pinned);
//IntPtr bmpPointer = pinnedBuffer.AddrOfPinnedObject();
BitmapData data = plotImg.LockBits(new Rectangle(0, 0, plotImg.Width, plotImg.Height), ImageLockMode.WriteOnly, plotImg.PixelFormat);
Marshal.Copy(buffer, 0, data.Scan0, buffer.Length); // Copia as informações no buffer de volta à imagem
plotImg.UnlockBits(data); // Libera a imagem
//pinnedBuffer.Free();
return(plotImg);
}
}
public void Process(int[] inputArray, int inputImgWidth, int inputImgHeight, double threshold, out int[] outputArray)
{
Cl.ErrorCode error;
outputArray = null;
//Create the required kernel (entry function)
Cl.Kernel kernel = Cl.Cl.CreateKernel(program, "sobelEdgeDetect", out error);
CheckErr(error, "Cl.CreateKernel");
int intPtrSize = 0;
intPtrSize = Marshal.SizeOf(typeof(IntPtr));
//OpenCL memory buffer that will keep our image's byte[] data.
Cl.IMem inputImage2DBuffer;
Cl.ImageFormat clImageFormat = new Cl.ImageFormat(Cl.ChannelOrder.RGBA, Cl.ChannelType.Unsigned_Int8);
//Copy the raw bitmap data to an unmanaged byte[] array
//inputByteArray = new byte[inputImgBytesSize];
//Marshal.Copy(bitmapData.Scan0, inputByteArray, 0, inputImgBytesSize);
//Allocate OpenCL image memory buffer
inputImage2DBuffer = Cl.Cl.CreateImage2D(_context, Cl.MemFlags.CopyHostPtr | Cl.MemFlags.ReadOnly, clImageFormat,
(IntPtr)inputImgWidth, (IntPtr)inputImgHeight,
(IntPtr)0, inputArray, out error);
CheckErr(error, "Cl.CreateImage2D input");
//Unmanaged output image's raw RGBA byte[] array
outputArray = new int[inputArray.Length];
//Allocate OpenCL image memory buffer
Cl.IMem outputImage2DBuffer = Cl.Cl.CreateImage2D(_context, Cl.MemFlags.CopyHostPtr | Cl.MemFlags.WriteOnly, clImageFormat, (IntPtr)inputImgWidth,
(IntPtr)inputImgHeight, (IntPtr)0, outputArray, out error);
CheckErr(error, "Cl.CreateImage2D output");
//Pass the memory buffers to our kernel function
error = Cl.Cl.SetKernelArg(kernel, 0, (IntPtr)intPtrSize, inputImage2DBuffer);
error |= Cl.Cl.SetKernelArg(kernel, 1, (IntPtr)intPtrSize, outputImage2DBuffer);
error |= Cl.Cl.SetKernelArg(kernel, 2, (float)threshold / 250.0f);
CheckErr(error, "Cl.SetKernelArg");
//Create a command queue, where all of the commands for execution will be added
Cl.CommandQueue cmdQueue = Cl.Cl.CreateCommandQueue(_context, _device, (Cl.CommandQueueProperties) 0, out error);
CheckErr(error, "Cl.CreateCommandQueue");
Cl.Event clevent;
//Copy input image from the host to the GPU.
IntPtr[] originPtr = new IntPtr[] { (IntPtr)0, (IntPtr)0, (IntPtr)0 }; //x, y, z
IntPtr[] regionPtr = new IntPtr[] { (IntPtr)inputImgWidth, (IntPtr)inputImgHeight, (IntPtr)1 }; //x, y, z
IntPtr[] workGroupSizePtr = new IntPtr[] { (IntPtr)inputImgWidth, (IntPtr)inputImgHeight, (IntPtr)1 };
error = Cl.Cl.EnqueueWriteImage(cmdQueue, inputImage2DBuffer, Cl.Bool.True,
originPtr, regionPtr, (IntPtr)0, (IntPtr)0, inputArray, 0, null, out clevent);
CheckErr(error, "Cl.EnqueueWriteImage");
//Execute our kernel (OpenCL code)
error = Cl.Cl.EnqueueNDRangeKernel(cmdQueue, kernel, 2, null, workGroupSizePtr, null, 0, null, out clevent);
CheckErr(error, "Cl.EnqueueNDRangeKernel");
//Wait for completion of all calculations on the GPU.
error = Cl.Cl.Finish(cmdQueue);
CheckErr(error, "Cl.Finish");
//Read the processed image from GPU to raw RGBA data byte[] array
error = Cl.Cl.EnqueueReadImage(cmdQueue, outputImage2DBuffer, Cl.Bool.True, originPtr, regionPtr,
(IntPtr)0, (IntPtr)0, outputArray, 0, null, out clevent);
CheckErr(error, "Cl.clEnqueueReadImage");
//Clean up memory
Cl.Cl.ReleaseKernel(kernel);
Cl.Cl.ReleaseCommandQueue(cmdQueue);
Cl.Cl.ReleaseMemObject(inputImage2DBuffer);
Cl.Cl.ReleaseMemObject(outputImage2DBuffer);
}
