/// <summary> /// Inverse DCT, de-quantization and level shift part of the JPEG decoding. /// Input is expected in 64x1 macro blocks and output is expected to be in 8x8 /// macro blocks. /// </summary> /// <param name="src">Source image.</param> /// <param name="dst">Destination image</param> /// <param name="QuantInvTable">Inverse quantization tables for JPEG decoding created using QuantInvTableInit()</param> /// <param name="oSizeRoi">Roi size (in macro blocks?).</param> public static void DCTQuantInv8x8LS(NPPImage_16sC1 src, NPPImage_8uC1 dst, CudaDeviceVariable <ushort> QuantInvTable, NppiSize oSizeRoi) { NppStatus status; status = NPPNativeMethods.NPPi.ImageCompression.nppiDCTQuantInv8x8LS_JPEG_16s8u_C1R(src.DevicePointer, src.Pitch, dst.DevicePointer, dst.Pitch, QuantInvTable.DevicePointer, oSizeRoi); Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiDCTQuantInv8x8LS_JPEG_16s8u_C1R", status)); NPPException.CheckNppStatus(status, null); }
/// <summary> /// 1 channel 32-bit unsigned integer to 8-bit unsigned integer connected region marker label renumbering with numbering sparseness elimination. /// </summary> /// <param name="dest">Destination-Image</param> /// <param name="nStartingNumber">The value returned from a previous call to the nppiLabelMarkers_8u32u function.</param> /// <param name="pBuffer">Pointer to device memory scratch buffer at least as large as value returned by the corresponding CompressMarkerLabelsGetBufferSize call.</param> /// <returns>the maximum renumbered marker label ID will be returned.</returns> public int CompressMarkerLabels(NPPImage_8uC1 dest, int nStartingNumber, CudaDeviceVariable <byte> pBuffer) { int pNewNumber = 0; status = NPPNativeMethods.NPPi.LabelMarkers.nppiCompressMarkerLabels_32u8u_C1R(_devPtrRoi, _pitch, dest.DevicePointerRoi, dest.Pitch, _sizeRoi, nStartingNumber, ref pNewNumber, pBuffer.DevicePointer); Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiCompressMarkerLabels_32u8u_C1R", status)); NPPException.CheckNppStatus(status, this); return(pNewNumber); }
/// <summary> /// Graphcut of a flow network (32bit floating point edge capacities). The /// function computes the minimal cut (graphcut) of a 2D regular 4-connected /// graph. <para/> /// The inputs are the capacities of the horizontal (in transposed form), /// vertical and terminal (source and sink) edges. The capacities to source and /// sink /// are stored as capacity differences in the terminals array /// ( terminals(x) = source(x) - sink(x) ). The implementation assumes that the /// edge capacities /// for boundary edges that would connect to nodes outside the specified domain /// are set to 0 (for example left(0,*) == 0). If this is not fulfilled the /// computed labeling may be wrong!<para/> /// The computed binary labeling is encoded as unsigned 8bit values (0 and >0). /// </summary> /// <param name="Terminals">Pointer to differences of terminal edge capacities</param> /// <param name="LeftTransposed">Pointer to transposed left edge capacities</param> /// <param name="RightTransposed">Pointer to transposed right edge capacities</param> /// <param name="Top">Pointer to top edge capacities (top(*,0) must be 0)</param> /// <param name="Bottom">Pointer to bottom edge capacities (bottom(*,height-1)</param> /// <param name="Label">Pointer to destination label image </param> /// <returns></returns> public void GraphCut(NPPImage_32fC1 Terminals, NPPImage_32fC1 LeftTransposed, NPPImage_32fC1 RightTransposed, NPPImage_32fC1 Top, NPPImage_32fC1 Bottom, NPPImage_8uC1 Label) { status = NPPNativeMethods.NPPi.ImageLabeling.nppiGraphcut_32f8u(Terminals.DevicePointer, LeftTransposed.DevicePointer, RightTransposed.DevicePointer, Top.DevicePointer, Bottom.DevicePointer, Terminals.Pitch, LeftTransposed.Pitch, _size, Label.DevicePointer, Label.Pitch, _state); Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiGraphcut_32f8u", status)); NPPException.CheckNppStatus(status, this); }
private void AllocateImagesNPP(Bitmap size) { int w = size.Width; int h = size.Height; if (inputImage8uC3 == null) { inputImage8uC1 = new NPPImage_8uC1(w, h); inputImage8uC3 = new NPPImage_8uC3(w, h); inputImage8uC4 = new NPPImage_8uC4(w, h); imageBayer = new NPPImage_32fC1(w, h); inputImage32f = new NPPImage_32fC3(w, h); noisyImage8u = new NPPImage_8uC3(w, h); noiseImage32f = new NPPImage_32fC3(w, h); resultImage8u = new NPPImage_8uC3(w, h); resultImage32f = new NPPImage_32fC3(w, h); return; } if (inputImage8uC3.Width >= w && inputImage8uC3.Height >= h) { inputImage8uC1.SetRoi(0, 0, w, h); inputImage8uC3.SetRoi(0, 0, w, h); inputImage8uC4.SetRoi(0, 0, w, h); imageBayer.SetRoi(0, 0, w, h); inputImage32f.SetRoi(0, 0, w, h); noisyImage8u.SetRoi(0, 0, w, h); noiseImage32f.SetRoi(0, 0, w, h); resultImage8u.SetRoi(0, 0, w, h); resultImage32f.SetRoi(0, 0, w, h); } else { inputImage8uC1.Dispose(); inputImage8uC3.Dispose(); inputImage8uC4.Dispose(); imageBayer.Dispose(); inputImage32f.Dispose(); noisyImage8u.Dispose(); noiseImage32f.Dispose(); resultImage8u.Dispose(); resultImage32f.Dispose(); inputImage8uC1 = new NPPImage_8uC1(w, h); inputImage8uC3 = new NPPImage_8uC3(w, h); inputImage8uC4 = new NPPImage_8uC4(w, h); imageBayer = new NPPImage_32fC1(w, h); inputImage32f = new NPPImage_32fC3(w, h); noisyImage8u = new NPPImage_8uC3(w, h); noiseImage32f = new NPPImage_32fC3(w, h); resultImage8u = new NPPImage_8uC3(w, h); resultImage32f = new NPPImage_32fC3(w, h); } }
private void button3_Click(object sender, EventArgs e) { if (grabcut == null) { return; } grabcut.grabCutUtils.TrimapFromRect(d_bmp_mask, selection, width, height); grabcut.computeSegmentationFromTrimap(); NPPImage_8uC1 alphamap = new NPPImage_8uC1(grabcut.AlphaMap.DevicePointer, grabcut.AlphaMap.Width, grabcut.AlphaMap.Height, grabcut.AlphaMap.Pitch); alphamap.CopyToHost(bmp_mask); pictureBox_Mask.Image = bmp_mask; int mode = 0; if (rb_Masked.Checked) { mode = 1; } if (rb_CutOut.Checked) { mode = 2; } grabcut.grabCutUtils.ApplyMatte(mode, d_bmp_res, d_bmp_src, grabcut.AlphaMap, width, height); npp_bmp_res.CopyToHost(bmp_res); pictureBox_Result.Image = bmp_res; lbl_Iterations.Text = grabcut.Iterations.ToString(); lbl_runtime.Text = grabcut.Runtime.ToString() + " [ms]"; }
/// <summary> /// 32-bit unsigned to 8-bit unsigned conversion. /// </summary> /// <param name="dst">Destination image</param> /// <param name="roundMode">Round mode</param> /// <param name="scaleFactor">scaling factor</param> public void Convert(NPPImage_8uC1 dst, NppRoundMode roundMode, int scaleFactor) { status = NPPNativeMethods.NPPi.BitDepthConversion.nppiConvert_32u8u_C1RSfs(_devPtrRoi, _pitch, dst.DevicePointerRoi, dst.Pitch, _sizeRoi, roundMode, scaleFactor); Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiConvert_32u8u_C1RSfs", status)); NPPException.CheckNppStatus(status, this); }
/// <summary> /// Inverse DCT, de-quantization and level shift part of the JPEG decoding, 16-bit short integer. /// Input is expected in 64x1 macro blocks and output is expected to be in 8x8 /// macro blocks. The new version of the primitive takes the ROI in image pixel size and /// works with DCT coefficients that are in zig-zag order. /// </summary> /// <param name="src">Source image.</param> /// <param name="dst">Destination image</param> /// <param name="pQuantizationTable">Quantization Table in zig-zag order.</param> /// <param name="oSizeRoi">Roi size (in pixels).</param> public void DCTQuant16Inv8x8LS(NPPImage_16sC1 src, NPPImage_8uC1 dst, NppiSize oSizeRoi, CudaDeviceVariable <ushort> pQuantizationTable) { status = NPPNativeMethods.NPPi.CompressionDCT.nppiDCTQuant16Inv8x8LS_JPEG_16s8u_C1R_NEW(src.DevicePointer, src.Pitch, dst.DevicePointer, dst.Pitch, pQuantizationTable.DevicePointer, oSizeRoi, _state); Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiDCTQuant16Inv8x8LS_JPEG_16s8u_C1R_NEW", status)); NPPException.CheckNppStatus(status, this); }
private void btn_open_Click(object sender, EventArgs e) { if (!_nppOK) { return; } CleanUp(); OpenFileDialog ofd = new OpenFileDialog(); ofd.Filter = "Images|*.jpg;*.bmp;*.png;*.tif"; if (ofd.ShowDialog() != System.Windows.Forms.DialogResult.OK) { return; } Bitmap src = new Bitmap(ofd.FileName); switch (src.PixelFormat) { case PixelFormat.Format24bppRgb: _colorChannels = 3; break; case PixelFormat.Format32bppArgb: _colorChannels = 4; break; case PixelFormat.Format32bppRgb: _colorChannels = 4; break; case PixelFormat.Format8bppIndexed: _colorChannels = 1; break; default: _colorChannels = 0; txt_info.AppendText(ofd.FileName + " has an unsupported pixel format.\n"); break; } try { switch (_colorChannels) { case 1: //Allocate memory on device for one channel images... src_c1 = new NPPImage_8uC1(src.Width, src.Height); dest_c1 = new NPPImage_8uC1(src.Width, src.Height); src_c1.CopyToDevice(src); txt_info.AppendText("Info: Loaded image '" + ofd.FileName + "' succesfully (Size: " + src.Width.ToString() + " x " + src.Height.ToString() + ", color channels: " + _colorChannels.ToString() + ")\n"); break; case 3: //As of version 5, NPP has new histogram and LUT functions for three channel images, no more need to convert first to 4 channels. //Allocate memory on device for four channel images... src_c3 = new NPPImage_8uC3(src.Width, src.Height); dest_c3 = new NPPImage_8uC3(src.Width, src.Height); //Fill 3 channel image in device memory src_c3.CopyToDevice(src); txt_info.AppendText("Info: Loaded image '" + ofd.FileName + "' succesfully (Size: " + src.Width.ToString() + " x " + src.Height.ToString() + ", color channels: " + _colorChannels.ToString() + ")\n"); break; case 4: //Allocate memory on device for four channel images... src_c4 = new NPPImage_8uC4(src.Width, src.Height); dest_c4 = new NPPImage_8uC4(src.Width, src.Height); src_c4.CopyToDevice(src); txt_info.AppendText("Info: Loaded image '" + ofd.FileName + "' succesfully (Size: " + src.Width.ToString() + " x " + src.Height.ToString() + ", color channels: " + _colorChannels.ToString() + ")\n"); break; } } catch (Exception ex) { if (ex is NPPException) { txt_info.AppendText("NPPException: " + ex.Message + "\n"); CleanUp(); } else if (ex is CudaException) { txt_info.AppendText("CudaException: " + ex.Message + "\n"); CleanUp(); } else { throw; } } //Show original image pictureBox_src.Image = src; }
/// <summary> /// 1 channel 32-bit uinteger connected region marker label renumbered from a previous call to nppiCompressMarkerLabelsUF or /// nppiCmpressMarkerLabelsUFBatch functions to eliminate label ID sparseness. /// </summary> /// <param name="nMaxMarkerLabelID">the value of the maximum marker label ID returned by corresponding compress marker labels UF call. </param> /// <param name="pMarkerLabelsInfoList">pointer to device memory buffer at least as large as value returned by the corresponding CompressedMarkerLabelsGetInfoListSize call.</param> /// <param name="pContoursImage">optional output image containing contours (boundaries) around each uniquely labeled connected pixel region, set to NULL if not needed. </param> /// <param name="pContoursDirectionImage">optional output image containing per contour pixel direction info around each uniquely labeled connected pixel region, set to NULL if not needed. </param> /// <param name="pContoursTotalsInfoHost">unique per call optional host memory pointer to NppiContourTotalsInfo structure in host memory, MUST be set if pContoursDirectionImage is set. </param> /// <param name="pContoursPixelCountsListDev">unique per call optional device memory pointer to array of nMaxMarkerLabelID uintegers in host memory, MUST be set if pContoursDirectionImage is set. </param> /// <param name="pContoursPixelCountsListHost">unique per call optional host memory pointer to array of nMaxMarkerLabelID uintegers in host memory, MUST be set if pContoursDirectionImage is set. </param> /// <param name="pContoursPixelStartingOffsetHost">unique per call optional host memory pointer to array of uintegers returned by this call representing the starting offset index of each contour found during geometry list generation </param> /// <param name="nppStreamCtx">NPP stream context.</param> public void CompressedMarkerLabelsUFInfo( uint nMaxMarkerLabelID, CudaDeviceVariable <NppiCompressedMarkerLabelsInfo> pMarkerLabelsInfoList, NPPImage_8uC1 pContoursImage, CudaPitchedDeviceVariable <NppiContourPixelDirectionInfo> pContoursDirectionImage, NppiContourTotalsInfo[] pContoursTotalsInfoHost, CudaDeviceVariable <uint> pContoursPixelCountsListDev, uint[] pContoursPixelCountsListHost, uint[] pContoursPixelStartingOffsetHost, NppStreamContext nppStreamCtx) { CUdeviceptr ptrMarkerLabelsInfoList = new CUdeviceptr(); CUdeviceptr ptrContoursImage = new CUdeviceptr(); CUdeviceptr ptrContoursDirectionImage = new CUdeviceptr(); CUdeviceptr ptrContoursPixelCountsListDev = new CUdeviceptr(); int pitchContoursImage = 0; int pitchContoursDirectionImage = 0; if (pMarkerLabelsInfoList != null) { ptrMarkerLabelsInfoList = pMarkerLabelsInfoList.DevicePointer; } if (pContoursImage != null) { ptrContoursImage = pContoursImage.DevicePointerRoi; pitchContoursImage = pContoursImage.Pitch; } if (pContoursDirectionImage != null) { ptrContoursDirectionImage = pContoursDirectionImage.DevicePointer; pitchContoursDirectionImage = pContoursDirectionImage.Pitch; } if (pContoursPixelCountsListDev != null) { ptrContoursPixelCountsListDev = pContoursPixelCountsListDev.DevicePointer; } status = NPPNativeMethods_Ctx.NPPi.LabelMarkers.nppiCompressedMarkerLabelsUFInfo_32u_C1R_Ctx(_devPtrRoi, _pitch, _sizeRoi, nMaxMarkerLabelID, ptrMarkerLabelsInfoList, ptrContoursImage, pitchContoursImage, ptrContoursDirectionImage, pitchContoursDirectionImage, pContoursTotalsInfoHost, ptrContoursPixelCountsListDev, pContoursPixelCountsListHost, pContoursPixelStartingOffsetHost, nppStreamCtx); Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "nppiCompressedMarkerLabelsUFInfo_32u_C1R_Ctx", status)); NPPException.CheckNppStatus(status, this); }
private void btn_openImg_Click(object sender, EventArgs e) { OpenFileDialog ofd = new OpenFileDialog(); ofd.Filter = "Images|*.bmp;*.jpg;*.jpeg;*.tiff;*.tif;*.png;*.gif"; if (ofd.ShowDialog() != System.Windows.Forms.DialogResult.OK) { return; } bmp_src = new Bitmap(ofd.FileName); if (bmp_src.PixelFormat != PixelFormat.Format24bppRgb) { MessageBox.Show("Only 24-bit RGB images are supported!"); bmp_src = null; bmp_mask = null; bmp_res = null; if (npp_bmp_src != null) { npp_bmp_src.Dispose(); } if (npp_bmp_res != null) { npp_bmp_res.Dispose(); } if (npp_bmp_mask != null) { npp_bmp_mask.Dispose(); } if (d_bmp_src != null) { d_bmp_src.Dispose(); } if (d_bmp_res != null) { d_bmp_res.Dispose(); } if (d_bmp_mask != null) { d_bmp_mask.Dispose(); } return; } width = bmp_src.Width; height = bmp_src.Height; marker = new int[width * height]; bmp_res = new Bitmap(width, height, PixelFormat.Format32bppArgb); bmp_mask = new Bitmap(width, height, PixelFormat.Format8bppIndexed); SetPalette(bmp_mask); pictureBox_src.Image = bmp_src; selection.x = (int)Math.Ceiling(width * 0.1); selection.y = (int)Math.Ceiling(height * 0.1); selection.width = width - 2 * selection.x; selection.height = height - 2 * selection.y; if (npp_bmp_src != null) { npp_bmp_src.Dispose(); } if (npp_bmp_res != null) { npp_bmp_res.Dispose(); } if (npp_bmp_mask != null) { npp_bmp_mask.Dispose(); } if (d_bmp_src != null) { d_bmp_src.Dispose(); } if (d_bmp_res != null) { d_bmp_res.Dispose(); } if (d_bmp_mask != null) { d_bmp_mask.Dispose(); } NPPImage_8uC3 npp_temp = new NPPImage_8uC3(width, height); CudaPitchedDeviceVariable <uchar3> d_bmp_temp = new CudaPitchedDeviceVariable <uchar3>(npp_temp.DevicePointer, width, height, npp_temp.Pitch); npp_temp.CopyToDevice(bmp_src); npp_bmp_src = new NPPImage_8uC4(width, height); npp_bmp_res = new NPPImage_8uC4(width, height); npp_bmp_mask = new NPPImage_8uC1(width, height); d_bmp_src = new CudaPitchedDeviceVariable <uchar4>(npp_bmp_src.DevicePointer, width, height, npp_bmp_src.Pitch); d_bmp_res = new CudaPitchedDeviceVariable <uchar4>(npp_bmp_res.DevicePointer, width, height, npp_bmp_res.Pitch); d_bmp_mask = new CudaPitchedDeviceVariable <byte>(npp_bmp_mask.DevicePointer, width, height, npp_bmp_mask.Pitch); grabcut = new GrabCut(d_bmp_src, d_bmp_mask, width, height); grabcut.grabCutUtils.convertRGBToRGBA(d_bmp_src, d_bmp_temp, width, height); d_bmp_temp.Dispose(); npp_temp.Dispose(); }
public static void SaveJpeg(string aFilename, int aQuality, Bitmap aImage) { if (aImage.PixelFormat != System.Drawing.Imaging.PixelFormat.Format24bppRgb) { throw new ArgumentException("Only three channel color images are supported."); } if (aImage.Width % 16 != 0 || aImage.Height % 16 != 0) { throw new ArgumentException("The provided bitmap must have a height and width of a multiple of 16."); } JPEGCompression compression = new JPEGCompression(); NPPImage_8uC3 src = new NPPImage_8uC3(aImage.Width, aImage.Height); NPPImage_8uC1 srcY = new NPPImage_8uC1(aImage.Width, aImage.Height); NPPImage_8uC1 srcCb = new NPPImage_8uC1(aImage.Width / 2, aImage.Height / 2); NPPImage_8uC1 srcCr = new NPPImage_8uC1(aImage.Width / 2, aImage.Height / 2); src.CopyToDevice(aImage); //System.Drawing.Bitmap is ordered BGR not RGB //The NPP routine BGR to YCbCR outputs the values in clamped range, following the YCbCr standard. //But JPEG uses unclamped values ranging all from [0..255], thus use our own color matrix: float[,] BgrToYCbCr = new float[3, 4] { { 0.114f, 0.587f, 0.299f, 0 }, { 0.5f, -0.33126f, -0.16874f, 128 }, { -0.08131f, -0.41869f, 0.5f, 128 } }; src.ColorTwist(BgrToYCbCr); //Reduce size of of Cb and Cr channel src.Copy(srcY, 2); srcY.Resize(srcCr, 0.5, 0.5, InterpolationMode.SuperSampling); src.Copy(srcY, 1); srcY.Resize(srcCb, 0.5, 0.5, InterpolationMode.SuperSampling); src.Copy(srcY, 0); FrameHeader oFrameHeader = new FrameHeader(); oFrameHeader.nComponents = 3; oFrameHeader.nHeight = (ushort)aImage.Height; oFrameHeader.nSamplePrecision = 8; oFrameHeader.nWidth = (ushort)aImage.Width; oFrameHeader.aComponentIdentifier = new byte[] { 1, 2, 3 }; oFrameHeader.aSamplingFactors = new byte[] { 34, 17, 17 }; //Y channel is twice the sice of Cb/Cr channel oFrameHeader.aQuantizationTableSelector = new byte[] { 0, 1, 1 }; //Get quantization tables from JPEG standard with quality scaling QuantizationTable[] aQuantizationTables = new QuantizationTable[2]; aQuantizationTables[0] = new QuantizationTable(QuantizationTable.QuantizationType.Luminance, aQuality); aQuantizationTables[1] = new QuantizationTable(QuantizationTable.QuantizationType.Chroma, aQuality); CudaDeviceVariable <byte>[] pdQuantizationTables = new CudaDeviceVariable <byte> [2]; pdQuantizationTables[0] = aQuantizationTables[0].aTable; pdQuantizationTables[1] = aQuantizationTables[1].aTable; //Get Huffman tables from JPEG standard HuffmanTable[] aHuffmanTables = new HuffmanTable[4]; aHuffmanTables[0] = new HuffmanTable(HuffmanTable.HuffmanType.LuminanceDC); aHuffmanTables[1] = new HuffmanTable(HuffmanTable.HuffmanType.ChromaDC); aHuffmanTables[2] = new HuffmanTable(HuffmanTable.HuffmanType.LuminanceAC); aHuffmanTables[3] = new HuffmanTable(HuffmanTable.HuffmanType.ChromaAC); //Set header ScanHeader oScanHeader = new ScanHeader(); oScanHeader.nA = 0; oScanHeader.nComponents = 3; oScanHeader.nSe = 63; oScanHeader.nSs = 0; oScanHeader.aComponentSelector = new byte[] { 1, 2, 3 }; oScanHeader.aHuffmanTablesSelector = new byte[] { 0, 17, 17 }; NPPImage_16sC1[] apdDCT = new NPPImage_16sC1[3]; NPPImage_8uC1[] apDstImage = new NPPImage_8uC1[3]; NppiSize[] aDstSize = new NppiSize[3]; aDstSize[0] = new NppiSize(srcY.Width, srcY.Height); aDstSize[1] = new NppiSize(srcCb.Width, srcCb.Height); aDstSize[2] = new NppiSize(srcCr.Width, srcCr.Height); // Compute channel sizes as stored in the output JPEG (8x8 blocks & MCU block layout) NppiSize oDstImageSize = new NppiSize(); float frameWidth = (float)Math.Floor((float)oFrameHeader.nWidth); float frameHeight = (float)Math.Floor((float)oFrameHeader.nHeight); oDstImageSize.width = (int)Math.Max(1.0f, frameWidth); oDstImageSize.height = (int)Math.Max(1.0f, frameHeight); //Console.WriteLine("Output Size: " + oDstImageSize.width + "x" + oDstImageSize.height + "x" + (int)(oFrameHeader.nComponents)); apDstImage[0] = srcY; apDstImage[1] = srcCb; apDstImage[2] = srcCr; int nMCUBlocksH = 0; int nMCUBlocksV = 0; // Compute channel sizes as stored in the JPEG (8x8 blocks & MCU block layout) for (int i = 0; i < oFrameHeader.nComponents; ++i) { nMCUBlocksV = Math.Max(nMCUBlocksV, oFrameHeader.aSamplingFactors[i] >> 4); nMCUBlocksH = Math.Max(nMCUBlocksH, oFrameHeader.aSamplingFactors[i] & 0x0f); } for (int i = 0; i < oFrameHeader.nComponents; ++i) { NppiSize oBlocks = new NppiSize(); NppiSize oBlocksPerMCU = new NppiSize(oFrameHeader.aSamplingFactors[i] & 0x0f, oFrameHeader.aSamplingFactors[i] >> 4); oBlocks.width = (int)Math.Ceiling((oFrameHeader.nWidth + 7) / 8 * (float)(oBlocksPerMCU.width) / nMCUBlocksH); oBlocks.width = DivUp(oBlocks.width, oBlocksPerMCU.width) * oBlocksPerMCU.width; oBlocks.height = (int)Math.Ceiling((oFrameHeader.nHeight + 7) / 8 * (float)(oBlocksPerMCU.height) / nMCUBlocksV); oBlocks.height = DivUp(oBlocks.height, oBlocksPerMCU.height) * oBlocksPerMCU.height; // Allocate Memory apdDCT[i] = new NPPImage_16sC1(oBlocks.width * 64, oBlocks.height); } /*************************** * * Output * ***************************/ // Forward DCT for (int i = 0; i < 3; ++i) { compression.DCTQuantFwd8x8LS(apDstImage[i], apdDCT[i], aDstSize[i], pdQuantizationTables[oFrameHeader.aQuantizationTableSelector[i]]); } // Huffman Encoding CudaDeviceVariable <byte> pdScan = new CudaDeviceVariable <byte>(BUFFER_SIZE); int nScanLength = 0; int nTempSize = JPEGCompression.EncodeHuffmanGetSize(aDstSize[0], 3); CudaDeviceVariable <byte> pJpegEncoderTemp = new CudaDeviceVariable <byte>(nTempSize); NppiEncodeHuffmanSpec[] apHuffmanDCTableEnc = new NppiEncodeHuffmanSpec[3]; NppiEncodeHuffmanSpec[] apHuffmanACTableEnc = new NppiEncodeHuffmanSpec[3]; for (int i = 0; i < 3; ++i) { apHuffmanDCTableEnc[i] = JPEGCompression.EncodeHuffmanSpecInitAlloc(aHuffmanTables[(oScanHeader.aHuffmanTablesSelector[i] >> 4)].aCodes, NppiHuffmanTableType.nppiDCTable); apHuffmanACTableEnc[i] = JPEGCompression.EncodeHuffmanSpecInitAlloc(aHuffmanTables[(oScanHeader.aHuffmanTablesSelector[i] & 0x0f) + 2].aCodes, NppiHuffmanTableType.nppiACTable); } JPEGCompression.EncodeHuffmanScan(apdDCT, 0, oScanHeader.nSs, oScanHeader.nSe, oScanHeader.nA >> 4, oScanHeader.nA & 0x0f, pdScan, ref nScanLength, apHuffmanDCTableEnc, apHuffmanACTableEnc, aDstSize, pJpegEncoderTemp); for (int i = 0; i < 3; ++i) { JPEGCompression.EncodeHuffmanSpecFree(apHuffmanDCTableEnc[i]); JPEGCompression.EncodeHuffmanSpecFree(apHuffmanACTableEnc[i]); } // Write JPEG to byte array, as in original sample code byte[] pDstOutput = new byte[BUFFER_SIZE]; int pos = 0; oFrameHeader.nWidth = (ushort)oDstImageSize.width; oFrameHeader.nHeight = (ushort)oDstImageSize.height; writeMarker(0x0D8, pDstOutput, ref pos); writeJFIFTag(pDstOutput, ref pos); writeQuantizationTable(aQuantizationTables[0], pDstOutput, ref pos); writeQuantizationTable(aQuantizationTables[1], pDstOutput, ref pos); writeFrameHeader(oFrameHeader, pDstOutput, ref pos); writeHuffmanTable(aHuffmanTables[0], pDstOutput, ref pos); writeHuffmanTable(aHuffmanTables[1], pDstOutput, ref pos); writeHuffmanTable(aHuffmanTables[2], pDstOutput, ref pos); writeHuffmanTable(aHuffmanTables[3], pDstOutput, ref pos); writeScanHeader(oScanHeader, pDstOutput, ref pos); pdScan.CopyToHost(pDstOutput, 0, pos, nScanLength); pos += nScanLength; writeMarker(0x0D9, pDstOutput, ref pos); FileStream fs = new FileStream(aFilename, FileMode.Create, FileAccess.Write); fs.Write(pDstOutput, 0, pos); fs.Close(); //cleanup: fs.Dispose(); pJpegEncoderTemp.Dispose(); pdScan.Dispose(); apdDCT[2].Dispose(); apdDCT[1].Dispose(); apdDCT[0].Dispose(); pdQuantizationTables[1].Dispose(); pdQuantizationTables[0].Dispose(); srcCr.Dispose(); srcCb.Dispose(); srcY.Dispose(); src.Dispose(); compression.Dispose(); }
public static Bitmap LoadJpeg(string aFilename) { JPEGCompression compression = new JPEGCompression(); byte[] pJpegData = File.ReadAllBytes(aFilename); int nInputLength = pJpegData.Length; // Check if this is a valid JPEG file int nPos = 0; int nMarker = nextMarker(pJpegData, ref nPos, nInputLength); if (nMarker != 0x0D8) { throw new ArgumentException(aFilename + " is not a JPEG file."); } nMarker = nextMarker(pJpegData, ref nPos, nInputLength); // Parsing and Huffman Decoding (on host) FrameHeader oFrameHeader = new FrameHeader(); oFrameHeader.aComponentIdentifier = new byte[3]; oFrameHeader.aSamplingFactors = new byte[3]; oFrameHeader.aQuantizationTableSelector = new byte[3]; QuantizationTable[] aQuantizationTables = new QuantizationTable[4]; aQuantizationTables[0] = new QuantizationTable(); aQuantizationTables[1] = new QuantizationTable(); aQuantizationTables[2] = new QuantizationTable(); aQuantizationTables[3] = new QuantizationTable(); CudaDeviceVariable <byte>[] pdQuantizationTables = new CudaDeviceVariable <byte> [4]; pdQuantizationTables[0] = new CudaDeviceVariable <byte>(64); pdQuantizationTables[1] = new CudaDeviceVariable <byte>(64); pdQuantizationTables[2] = new CudaDeviceVariable <byte>(64); pdQuantizationTables[3] = new CudaDeviceVariable <byte>(64); HuffmanTable[] aHuffmanTables = new HuffmanTable[4]; aHuffmanTables[0] = new HuffmanTable(); aHuffmanTables[1] = new HuffmanTable(); aHuffmanTables[2] = new HuffmanTable(); aHuffmanTables[3] = new HuffmanTable(); ScanHeader oScanHeader = new ScanHeader(); oScanHeader.aComponentSelector = new byte[3]; oScanHeader.aHuffmanTablesSelector = new byte[3]; int nMCUBlocksH = 0; int nMCUBlocksV = 0; int nRestartInterval = -1; NppiSize[] aSrcSize = new NppiSize[3]; short[][] aphDCT = new short[3][]; NPPImage_16sC1[] apdDCT = new NPPImage_16sC1[3]; int[] aDCTStep = new int[3]; NPPImage_8uC1[] apSrcImage = new NPPImage_8uC1[3]; int[] aSrcImageStep = new int[3]; NPPImage_8uC1[] apDstImage = new NPPImage_8uC1[3]; int[] aDstImageStep = new int[3]; NppiSize[] aDstSize = new NppiSize[3]; //Same read routine as in NPP JPEG sample from Nvidia while (nMarker != -1) { if (nMarker == 0x0D8) { // Embeded Thumbnail, skip it int nNextMarker = nextMarker(pJpegData, ref nPos, nInputLength); while (nNextMarker != -1 && nNextMarker != 0x0D9) { nNextMarker = nextMarker(pJpegData, ref nPos, nInputLength); } } if (nMarker == 0x0DD) { readRestartInterval(pJpegData, ref nPos, ref nRestartInterval); } if ((nMarker == 0x0C0) | (nMarker == 0x0C2)) { //Assert Baseline for this Sample //Note: NPP does support progressive jpegs for both encode and decode if (nMarker != 0x0C0) { pdQuantizationTables[0].Dispose(); pdQuantizationTables[1].Dispose(); pdQuantizationTables[2].Dispose(); pdQuantizationTables[3].Dispose(); throw new ArgumentException(aFilename + " is not a Baseline-JPEG file."); } // Baseline or Progressive Frame Header readFrameHeader(pJpegData, ref nPos, ref oFrameHeader); //Console.WriteLine("Image Size: " + oFrameHeader.nWidth + "x" + oFrameHeader.nHeight + "x" + (int)(oFrameHeader.nComponents)); //Assert 3-Channel Image for this Sample if (oFrameHeader.nComponents != 3) { pdQuantizationTables[0].Dispose(); pdQuantizationTables[1].Dispose(); pdQuantizationTables[2].Dispose(); pdQuantizationTables[3].Dispose(); throw new ArgumentException(aFilename + " is not a three channel JPEG file."); } // Compute channel sizes as stored in the JPEG (8x8 blocks & MCU block layout) for (int i = 0; i < oFrameHeader.nComponents; ++i) { nMCUBlocksV = Math.Max(nMCUBlocksV, oFrameHeader.aSamplingFactors[i] >> 4); nMCUBlocksH = Math.Max(nMCUBlocksH, oFrameHeader.aSamplingFactors[i] & 0x0f); } for (int i = 0; i < oFrameHeader.nComponents; ++i) { NppiSize oBlocks = new NppiSize(); NppiSize oBlocksPerMCU = new NppiSize(oFrameHeader.aSamplingFactors[i] & 0x0f, oFrameHeader.aSamplingFactors[i] >> 4); oBlocks.width = (int)Math.Ceiling((oFrameHeader.nWidth + 7) / 8 * (float)(oBlocksPerMCU.width) / nMCUBlocksH); oBlocks.width = DivUp(oBlocks.width, oBlocksPerMCU.width) * oBlocksPerMCU.width; oBlocks.height = (int)Math.Ceiling((oFrameHeader.nHeight + 7) / 8 * (float)(oBlocksPerMCU.height) / nMCUBlocksV); oBlocks.height = DivUp(oBlocks.height, oBlocksPerMCU.height) * oBlocksPerMCU.height; aSrcSize[i].width = oBlocks.width * 8; aSrcSize[i].height = oBlocks.height * 8; // Allocate Memory apdDCT[i] = new NPPImage_16sC1(oBlocks.width * 64, oBlocks.height); aDCTStep[i] = apdDCT[i].Pitch; apSrcImage[i] = new NPPImage_8uC1(aSrcSize[i].width, aSrcSize[i].height); aSrcImageStep[i] = apSrcImage[i].Pitch; aphDCT[i] = new short[aDCTStep[i] * oBlocks.height]; } } if (nMarker == 0x0DB) { // Quantization Tables readQuantizationTables(pJpegData, ref nPos, aQuantizationTables); } if (nMarker == 0x0C4) { // Huffman Tables readHuffmanTables(pJpegData, ref nPos, aHuffmanTables); } if (nMarker == 0x0DA) { // Scan readScanHeader(pJpegData, ref nPos, ref oScanHeader); nPos += 6 + oScanHeader.nComponents * 2; int nAfterNextMarkerPos = nPos; int nAfterScanMarker = nextMarker(pJpegData, ref nAfterNextMarkerPos, nInputLength); if (nRestartInterval > 0) { while (nAfterScanMarker >= 0x0D0 && nAfterScanMarker <= 0x0D7) { // This is a restart marker, go on nAfterScanMarker = nextMarker(pJpegData, ref nAfterNextMarkerPos, nInputLength); } } NppiDecodeHuffmanSpec[] apHuffmanDCTableDec = new NppiDecodeHuffmanSpec[3]; NppiDecodeHuffmanSpec[] apHuffmanACTableDec = new NppiDecodeHuffmanSpec[3]; for (int i = 0; i < 3; ++i) { apHuffmanDCTableDec[i] = JPEGCompression.DecodeHuffmanSpecInitAllocHost(aHuffmanTables[(oScanHeader.aHuffmanTablesSelector[i] >> 4)].aCodes, NppiHuffmanTableType.nppiDCTable); apHuffmanACTableDec[i] = JPEGCompression.DecodeHuffmanSpecInitAllocHost(aHuffmanTables[(oScanHeader.aHuffmanTablesSelector[i] & 0x0f) + 2].aCodes, NppiHuffmanTableType.nppiACTable); } byte[] img = new byte[nAfterNextMarkerPos - nPos - 2]; Buffer.BlockCopy(pJpegData, nPos, img, 0, nAfterNextMarkerPos - nPos - 2); JPEGCompression.DecodeHuffmanScanHost(img, nRestartInterval, oScanHeader.nSs, oScanHeader.nSe, oScanHeader.nA >> 4, oScanHeader.nA & 0x0f, aphDCT[0], aphDCT[1], aphDCT[2], aDCTStep, apHuffmanDCTableDec, apHuffmanACTableDec, aSrcSize); for (int i = 0; i < 3; ++i) { JPEGCompression.DecodeHuffmanSpecFreeHost(apHuffmanDCTableDec[i]); JPEGCompression.DecodeHuffmanSpecFreeHost(apHuffmanACTableDec[i]); } } nMarker = nextMarker(pJpegData, ref nPos, nInputLength); } // Copy DCT coefficients and Quantization Tables from host to device for (int i = 0; i < 4; ++i) { pdQuantizationTables[i].CopyToDevice(aQuantizationTables[i].aTable); } for (int i = 0; i < 3; ++i) { apdDCT[i].CopyToDevice(aphDCT[i], aDCTStep[i]); } // Inverse DCT for (int i = 0; i < 3; ++i) { compression.DCTQuantInv8x8LS(apdDCT[i], apSrcImage[i], aSrcSize[i], pdQuantizationTables[oFrameHeader.aQuantizationTableSelector[i]]); } //Alloc final image NPPImage_8uC3 res = new NPPImage_8uC3(apSrcImage[0].Width, apSrcImage[0].Height); //Copy Y color plane to first channel apSrcImage[0].Copy(res, 0); //Cb anc Cr channel might be smaller if ((oFrameHeader.aSamplingFactors[0] & 0x0f) == 1 && oFrameHeader.aSamplingFactors[0] >> 4 == 1) { //Color planes are of same size as Y channel apSrcImage[1].Copy(res, 1); apSrcImage[2].Copy(res, 2); } else { //rescale color planes to full size double scaleX = oFrameHeader.aSamplingFactors[0] & 0x0f; double scaleY = oFrameHeader.aSamplingFactors[0] >> 4; apSrcImage[1].ResizeSqrPixel(apSrcImage[0], scaleX, scaleY, 0, 0, InterpolationMode.Lanczos); apSrcImage[0].Copy(res, 1); apSrcImage[2].ResizeSqrPixel(apSrcImage[0], scaleX, scaleY, 0, 0, InterpolationMode.Lanczos); apSrcImage[0].Copy(res, 2); } //System.Drawing.Bitmap is ordered BGR not RGB //The NPP routine YCbCR to BGR needs clampled input values, following the YCbCr standard. //But JPEG uses unclamped values ranging all from [0..255], thus use our own color matrix: float[,] YCbCrToBgr = new float[3, 4] { { 1.0f, 1.772f, 0.0f, -226.816f }, { 1.0f, -0.34414f, -0.71414f, 135.45984f }, { 1.0f, 0.0f, 1.402f, -179.456f } }; //Convert from YCbCr to BGR res.ColorTwist(YCbCrToBgr); Bitmap bmp = new Bitmap(apSrcImage[0].Width, apSrcImage[0].Height, System.Drawing.Imaging.PixelFormat.Format24bppRgb); res.CopyToHost(bmp); //Cleanup: res.Dispose(); apSrcImage[2].Dispose(); apSrcImage[1].Dispose(); apSrcImage[0].Dispose(); apdDCT[2].Dispose(); apdDCT[1].Dispose(); apdDCT[0].Dispose(); pdQuantizationTables[0].Dispose(); pdQuantizationTables[1].Dispose(); pdQuantizationTables[2].Dispose(); pdQuantizationTables[3].Dispose(); compression.Dispose(); return(bmp); }