public void EncodeFromRaw() { const string testImage = "obama-240p.raw"; var path = Path.GetFullPath(Path.Combine(TestImageDirectory, testImage)); var imageByte = File.ReadAllBytes(path); using var image = ImageHelper.FromRaw(imageByte, 427, 240, 427 * 3, 3, true); using var compressionParameters = new CompressionParameters(); OpenJpeg.SetDefaultEncoderParameters(compressionParameters); compressionParameters.TcpNumLayers = 1; compressionParameters.CodingParameterDistortionAllocation = 1; using var codec = OpenJpeg.CreateCompress(CodecFormat.J2k); OpenJpeg.SetInfoHandler(codec, new DelegateHandler <MsgCallback>(MsgInfoCallback), IntPtr.Zero); OpenJpeg.SetWarnHandler(codec, new DelegateHandler <MsgCallback>(MsgWarnCallback), IntPtr.Zero); OpenJpeg.SetErrorHandler(codec, new DelegateHandler <MsgCallback>(MsgErrorCallback), IntPtr.Zero); Assert.True(OpenJpeg.SetupEncoder(codec, compressionParameters, image)); var bufferLength = imageByte.Length + 1024; var outputBuffer = Marshal.AllocHGlobal(bufferLength); var buffer = new Buffer { Data = outputBuffer, Length = bufferLength, Position = 0 }; var size = Marshal.SizeOf(buffer); var userData = Marshal.AllocHGlobal(size); Marshal.StructureToPtr(buffer, userData, false); using var stream = OpenJpeg.StreamCreate((ulong)buffer.Length, false); OpenJpeg.StreamSetUserData(stream, userData); OpenJpeg.StreamSetUserDataLength(stream, buffer.Length); OpenJpeg.StreamSetWriteFunction(stream, new DelegateHandler <StreamWrite>(StreamWriteCallback)); OpenJpeg.StreamSetReadFunction(stream, new DelegateHandler <StreamRead>(StreamReadCallback)); OpenJpeg.StreamSetSeekFunction(stream, new DelegateHandler <StreamSeek>(StreamSeekCallback)); OpenJpeg.StreamSetSkipFunction(stream, new DelegateHandler <StreamSkip>(StreamSkipCallback)); Assert.True(OpenJpeg.StartCompress(codec, image, stream)); Assert.True(OpenJpeg.Encode(codec, stream)); Assert.True(OpenJpeg.EndCompress(codec, stream)); var outputPath = Path.Combine(ResultDirectory, nameof(this.EncodeFromRaw), $"{Path.GetFileNameWithoutExtension(testImage)}.j2k"); Directory.CreateDirectory(Path.GetDirectoryName(outputPath)); var tmp = Marshal.PtrToStructure <Buffer>(userData); var output = new byte[tmp.Position]; Marshal.Copy(buffer.Data, output, 0, output.Length); File.WriteAllBytes(outputPath, output); Marshal.FreeHGlobal(outputBuffer); Marshal.FreeHGlobal(userData); }
public bool ReadHeader() { this._Codec?.Dispose(); this._DecompressionParameters?.Dispose(); this._Image?.Dispose(); this._Codec = null; this._DecompressionParameters = null; this._Image = null; // ToDo: Support to change format? this._Codec = OpenJpeg.CreateDecompress(CodecFormat.J2k); //this._Codec = OpenJpeg.CreateDecompress(CodecFormat.Jp2); this._DecompressionParameters = new DecompressionParameters(); OpenJpeg.SetDefaultDecoderParameters(this._DecompressionParameters); if (!OpenJpeg.SetupDecoder(this._Codec, this._DecompressionParameters)) { return(false); } if (!OpenJpeg.ReadHeader(this._Stream, this._Codec, out var image)) { return(false); } this.Width = (int)(image.X1 - image.X0); this.Height = (int)(image.Y1 - image.Y0); this._Image = image; return(true); }
public Reader(byte[] data) { this._Buffer = new Buffer { Data = Marshal.AllocHGlobal(data.Length), Length = data.Length, Position = 0 }; Marshal.Copy(data, 0, this._Buffer.Data, this._Buffer.Length); var size = Marshal.SizeOf(this._Buffer); this._UserData = Marshal.AllocHGlobal(size); Marshal.StructureToPtr(this._Buffer, this._UserData, false); this._ReadCallback = new DelegateHandler <StreamRead>(Read); this._SeekCallback = new DelegateHandler <StreamSeek>(Seek); this._SkipCallback = new DelegateHandler <StreamSkip>(Skip); this._Stream = OpenJpeg.StreamDefaultCreate(true); OpenJpeg.StreamSetUserData(this._Stream, this._UserData); OpenJpeg.StreamSetUserDataLength(this._Stream, this._Buffer.Length); OpenJpeg.StreamSetReadFunction(this._Stream, this._ReadCallback); OpenJpeg.StreamSetSeekFunction(this._Stream, this._SeekCallback); OpenJpeg.StreamSetSkipFunction(this._Stream, this._SkipCallback); }
public void Decode() { var targets = new[] { //new { Name = "Bretagne1_0.j2k", IsReadStream = true, Format = CodecFormat.Unknown, Result = false }, new { Name = "Bretagne1_0.j2k", IsReadStream = true, Format = CodecFormat.J2k, Result = true }, //new { Name = "Bretagne1_0.j2k", IsReadStream = true, Format = CodecFormat.Jp2, Result = false }, //new { Name = "Bretagne1_0.j2k", IsReadStream = true, Format = CodecFormat.Jpp, Result = false }, //new { Name = "Bretagne1_0.j2k", IsReadStream = true, Format = CodecFormat.Jpt, Result = false }, //new { Name = "Bretagne1_0.j2k", IsReadStream = true, Format = CodecFormat.Jpx, Result = false } }; foreach (var target in targets) { var path = Path.GetFullPath(Path.Combine(TestImageDirectory, target.Name)); var stream = OpenJpeg.StreamCreateDefaultFileStream(path, target.IsReadStream); var codec = OpenJpeg.CreateDecompress(target.Format); var decompressionParameters = new DecompressionParameters(); OpenJpeg.SetDefaultDecoderParameters(decompressionParameters); Assert.True(OpenJpeg.SetupDecoder(codec, decompressionParameters) == target.Result, $"Failed to invoke {nameof(OpenJpeg.SetupDecoder)} for {target.Format} and {target.IsReadStream}"); Assert.True(OpenJpeg.ReadHeader(stream, codec, out var image) == target.Result, $"Failed to invoke {nameof(OpenJpeg.ReadHeader)} for {target.Format} and {target.IsReadStream}"); Assert.True(OpenJpeg.SetDecodeArea(codec, image, 0, 0, 0, 0) == target.Result, $"Failed to invoke {nameof(OpenJpeg.SetDecodeArea)} for {target.Format} and {target.IsReadStream}"); Assert.True(OpenJpeg.Decode(codec, stream, image) == target.Result, $"Failed to invoke {nameof(OpenJpeg.Decode)} for {target.Format} and {target.IsReadStream}"); Assert.True(OpenJpeg.EndDecompress(codec, stream) == target.Result, $"Failed to invoke {nameof(OpenJpeg.EndDecompress)} for {target.Format} and {target.IsReadStream}"); this.DisposeAndCheckDisposedState(image); this.DisposeAndCheckDisposedState(stream); this.DisposeAndCheckDisposedState(decompressionParameters); this.DisposeAndCheckDisposedState(codec); } }
public void ImageDataAlloc() { var mem = OpenJpeg.ImageDataAlloc(100); Assert.True(mem != IntPtr.Zero); OpenJpeg.ImageDataFree(mem); }
public void GetNumCpus() { var expected = System.Environment.ProcessorCount; var count = OpenJpeg.GetNumCpus(); Assert.Equal(expected, count); }
private static Image DecodeImageFromFile(string path, CodecFormat format) { using var stream = OpenJpeg.StreamCreateDefaultFileStream(path, true); using var codec = OpenJpeg.CreateDecompress(format); using var decompressionParameters = new DecompressionParameters(); OpenJpeg.SetDefaultDecoderParameters(decompressionParameters); OpenJpeg.SetupDecoder(codec, decompressionParameters); OpenJpeg.ReadHeader(stream, codec, out var image); OpenJpeg.SetDecodeArea(codec, image, 0, 0, 0, 0); OpenJpeg.Decode(codec, stream, image); OpenJpeg.EndDecompress(codec, stream); return(image); }
public void StreamDefaultCreate() { var targets = new[] { new { IsReadStream = true }, new { IsReadStream = false } }; foreach (var target in targets) { var stream = OpenJpeg.StreamDefaultCreate(target.IsReadStream); this.DisposeAndCheckDisposedState(stream); } }
public RawBitmap ReadRawBitmap() { if (this._Image == null || this._Image.IsDisposed) { throw new InvalidOperationException(); } if (!OpenJpeg.Decode(this._Codec, this._Stream, this._Image)) { throw new InvalidOperationException(); } return(this._Image.ToRawBitmap()); }
public void StreamCreateDefaultFileStream() { var targets = new[] { new { Name = "Bretagne1_0.j2k", IsReadStream = true }, //new { Name = "Bretagne1_0.j2k", IsReadStream = false } }; foreach (var target in targets) { var path = Path.Combine(TestImageDirectory, target.Name); var stream = OpenJpeg.StreamCreateDefaultFileStream(path, target.IsReadStream); this.DisposeAndCheckDisposedState(stream); } }
public void SetMCT() { var mct = new float[] { 1, 0, 0, 0, 1, 0, 0, 0, 1 }; var dcShift = new[] { 128, 128, 128 }; using var parameter = new CompressionParameters(); Assert.True(OpenJpeg.SetMCT(parameter, mct, dcShift, 4)); }
private CompressionParameters SetupEncoderParameters(Parameter parameter) { var compressionParameters = new CompressionParameters(); OpenJpeg.SetDefaultEncoderParameters(compressionParameters); if (parameter.Compression.HasValue) { compressionParameters.TcpRates[0] = 1000f / Math.Min(Math.Max(parameter.Compression.Value, 1), 1000); } compressionParameters.TcpNumLayers = 1; compressionParameters.CodingParameterDistortionAllocation = 1; if (!parameter.Compression.HasValue) { compressionParameters.TcpRates[0] = 4; } return(compressionParameters); }
public void CodecSetThreads() { var targets = new[] { //new { Name = "Bretagne1_0.j2k", IsReadStream = true, Format = CodecFormat.Unknown, Result = false }, new { Name = "Bretagne1_0.j2k", IsReadStream = true, Format = CodecFormat.J2k, Result = true }, //new { Name = "Bretagne1_0.j2k", IsReadStream = true, Format = CodecFormat.Jp2, Result = false }, //new { Name = "Bretagne1_0.j2k", IsReadStream = true, Format = CodecFormat.Jpp, Result = false }, //new { Name = "Bretagne1_0.j2k", IsReadStream = true, Format = CodecFormat.Jpt, Result = false }, //new { Name = "Bretagne1_0.j2k", IsReadStream = true, Format = CodecFormat.Jpx, Result = false } }; foreach (var target in targets) { var codec = OpenJpeg.CreateDecompress(target.Format); Assert.True(OpenJpeg.CodecSetThreads(codec, 2)); Assert.True(OpenJpeg.CodecSetThreads(codec, 0)); Assert.False(OpenJpeg.CodecSetThreads(codec, -1)); this.DisposeAndCheckDisposedState(codec); } }
public bool WriteHeader(Parameter parameter) { if (parameter == null) { throw new ArgumentNullException(nameof(parameter)); } this._Codec?.Dispose(); this._CompressionParameters?.Dispose(); this._Image?.Dispose(); this._Codec = null; this._CompressionParameters = null; this._Image = null; // ToDo: Support to change format? this._Codec = OpenJpeg.CreateDecompress(CodecFormat.J2k); //this._Codec = OpenJpeg.CreateDecompress(CodecFormat.Jp2); this._CompressionParameters = this.SetupEncoderParameters(parameter); return(true); }
public void StreamSetUserData() { var targets = new[] { new { Name = "Bretagne1_0.j2k", IsReadStream = true }, new { Name = "Bretagne1_0.j2k", IsReadStream = false } }; foreach (var target in targets) { var path = Path.Combine(TestImageDirectory, target.Name); var data = File.ReadAllBytes(path); var userData = Marshal.AllocCoTaskMem(data.Length); Marshal.Copy(data, 0, userData, data.Length); var stream = OpenJpeg.StreamDefaultCreate(target.IsReadStream); OpenJpeg.StreamSetUserData(stream, userData); this.DisposeAndCheckDisposedState(stream); Marshal.FreeCoTaskMem(userData); } }
public void Compress() { var targets = new[] { new { Format = CodecFormat.Unknown, FileName = $"{nameof(this.Compress)}.ukn", Result = false }, new { Format = CodecFormat.J2k, FileName = $"{nameof(this.Compress)}.j2k", Result = true }, new { Format = CodecFormat.Jp2, FileName = $"{nameof(this.Compress)}.jp2", Result = true }, new { Format = CodecFormat.Jpp, FileName = $"{nameof(this.Compress)}.jpp", Result = false }, new { Format = CodecFormat.Jpt, FileName = $"{nameof(this.Compress)}.jpt", Result = false }, new { Format = CodecFormat.Jpx, FileName = $"{nameof(this.Compress)}.jpx", Result = false }, }; const int numCompsMax = 4; const int codeBlockWidthInitial = 64; const int codeBlockHeightInitial = 64; const int numComps = 3; const int imageWidth = 2000; const int imageHeight = 2000; const int tileWidth = 1000; const int tileHeight = 1000; const uint compPrec = 8; const bool irreversible = false; const uint offsetX = 0; const uint offsetY = 0; var tilesWidth = (offsetX + imageWidth + tileWidth - 1) / tileWidth; var tilesHeight = (offsetY + imageHeight + tileHeight - 1) / tileHeight; var tiles = tilesWidth * tilesHeight; var dataSize = tileWidth * tileHeight * numComps * (compPrec / 8); var data = new byte[dataSize]; for (var index = 0; index < data.Length; index++) { data[index] = (byte)(index % byte.MaxValue); } foreach (var target in targets) { var codec = OpenJpeg.CreateCompress(target.Format); var compressionParameters = new CompressionParameters(); OpenJpeg.SetDefaultEncoderParameters(compressionParameters); compressionParameters.TcpNumLayers = 1; compressionParameters.CodingParameterFixedQuality = 1; compressionParameters.TcpDistoratio[0] = 20; compressionParameters.CodingParameterTx0 = 0; compressionParameters.CodingParameterTy0 = 0; compressionParameters.TileSizeOn = true; compressionParameters.CodingParameterTdx = tileWidth; compressionParameters.CodingParameterTdy = tileHeight; compressionParameters.CodeBlockWidthInitial = codeBlockWidthInitial; compressionParameters.CodeBlockHeightInitial = codeBlockHeightInitial; compressionParameters.Irreversible = irreversible; var parameters = new ImageComponentParameters[numCompsMax]; for (var index = 0; index < parameters.Length; index++) { parameters[index] = new ImageComponentParameters { Dx = 1, Dy = 1, Height = imageHeight, Width = imageWidth, Signed = false, Precision = compPrec, X0 = offsetX, Y0 = offsetY }; } var image = OpenJpeg.ImageTileCreate(numComps, parameters, ColorSpace.Srgb); image.X0 = offsetX; image.Y0 = offsetY; image.X1 = offsetX + imageWidth; image.Y1 = offsetY + imageHeight; image.ColorSpace = ColorSpace.Srgb; Directory.CreateDirectory(ResultDirectory); Directory.CreateDirectory(Path.Combine(ResultDirectory, nameof(this.Compress))); var path = Path.Combine(ResultDirectory, nameof(this.Compress), target.FileName); Assert.True(OpenJpeg.SetupEncoder(codec, compressionParameters, image) == target.Result, $"Failed to invoke {nameof(OpenJpeg.SetupDecoder)} for {target.Format}"); if (!target.Result) { this.DisposeAndCheckDisposedState(image); this.DisposeAndCheckDisposedState(compressionParameters); this.DisposeAndCheckDisposedState(codec); continue; } var stream = OpenJpeg.StreamCreateDefaultFileStream(path, false); OpenJpeg.StartCompress(codec, image, stream); for (var i = 0; i < tiles; ++i) { var tileY = (uint)(i / tilesWidth); var tileX = (uint)(i % tilesHeight); var tileX0 = Math.Max(image.X0, tileX * tileWidth); var tileY0 = Math.Max(image.Y0, tileY * tileHeight); var tileX1 = Math.Min(image.X1, (tileX + 1) * tileWidth); var tileY1 = Math.Min(image.Y1, (tileY + 1) * tileHeight); var tilesize = (tileX1 - tileX0) * (tileY1 - tileY0) * numComps * (compPrec / 8); Assert.True(OpenJpeg.WriteTile(codec, i, data, tilesize, stream), $"Failed to invoke {nameof(OpenJpeg.WriteTile)}"); } OpenJpeg.EndCompress(codec, stream); this.DisposeAndCheckDisposedState(stream); this.DisposeAndCheckDisposedState(image); this.DisposeAndCheckDisposedState(compressionParameters); this.DisposeAndCheckDisposedState(codec); } }
public byte[] Write(Bitmap bitmap) { if (bitmap == null) { throw new ArgumentNullException(nameof(bitmap)); } this._Codec?.Dispose(); this._CompressionParameters?.Dispose(); this._Image?.Dispose(); var channels = 0; var outPrecision = 0u; var colorSpace = ColorSpace.Gray; var format = bitmap.PixelFormat; var width = bitmap.Width; var height = bitmap.Height; switch (format) { case PixelFormat.Format24bppRgb: channels = 3; outPrecision = 24u / (uint)channels; colorSpace = ColorSpace.Srgb; break; } var componentParametersArray = new ImageComponentParameters[channels]; for (var i = 0; i < channels; i++) { componentParametersArray[i].Precision = outPrecision; componentParametersArray[i].Bpp = outPrecision; componentParametersArray[i].Signed = false; componentParametersArray[i].Dx = (uint)this._CompressionParameters.SubsamplingDx; componentParametersArray[i].Dy = (uint)this._CompressionParameters.SubsamplingDy; componentParametersArray[i].Width = (uint)width; componentParametersArray[i].Height = (uint)height; } Image image = null; try { // ToDo: throw proper exception image = OpenJpeg.ImageCreate((uint)channels, componentParametersArray, colorSpace); if (image == null) { throw new ArgumentException(); } // ToDo: support alpha components //switch (channels) //{ // case 2: // case 4: // image.Components[(int)(channels - 1)].Alpha = 1; // break; //} image.X0 = 0; image.Y0 = 0; image.X1 = componentParametersArray[0].Dx * componentParametersArray[0].Width; image.Y1 = componentParametersArray[0].Dy * componentParametersArray[0].Height; //std::vector<OPJ_INT32*> outcomps(channels, nullptr); //switch (channels) //{ // case 1: // outcomps.assign({ image.Components[0].data }); // break; // // Reversed order for BGR -> RGB conversion // case 2: // outcomps.assign({ image.Components[0].data, image.Components[1].data }); // break; // case 3: // outcomps.assign({ image.Components[2].data, image.Components[1].data, image.Components[0].data }); // break; // case 4: // outcomps.assign({ // image.Components[2].data, image.Components[1].data, image.Components[0].data, // image.Components[3].data }); // break; //} } finally { image?.Dispose(); } return(null); }
public void HasThreadSupport() { Assert.True(OpenJpeg.HasThreadSupport()); }
public void ImageDataFree() { OpenJpeg.ImageDataFree(IntPtr.Zero); }
private static Image CreateImage(uint numComps = 3) { const int numCompsMax = 4; const int codeBlockWidthInitial = 64; const int codeBlockHeightInitial = 64; const int imageWidth = 2000; const int imageHeight = 2000; const int tileWidth = 1000; const int tileHeight = 1000; const uint compPrec = 8; const bool irreversible = false; const uint offsetX = 0; const uint offsetY = 0; using var codec = OpenJpeg.CreateCompress(CodecFormat.Jp2); using var compressionParameters = new CompressionParameters(); OpenJpeg.SetDefaultEncoderParameters(compressionParameters); compressionParameters.TcpNumLayers = 1; compressionParameters.CodingParameterFixedQuality = 1; compressionParameters.TcpDistoratio[0] = 20; compressionParameters.CodingParameterTx0 = 0; compressionParameters.CodingParameterTy0 = 0; compressionParameters.TileSizeOn = true; compressionParameters.CodingParameterTdx = tileWidth; compressionParameters.CodingParameterTdy = tileHeight; compressionParameters.CodeBlockWidthInitial = codeBlockWidthInitial; compressionParameters.CodeBlockHeightInitial = codeBlockHeightInitial; compressionParameters.Irreversible = irreversible; var parameters = new ImageComponentParameters[numCompsMax]; for (var index = 0; index < parameters.Length; index++) { parameters[index] = new ImageComponentParameters { Dx = 1, Dy = 1, Height = imageHeight, Width = imageWidth, Signed = false, Precision = compPrec, X0 = offsetX, Y0 = offsetY }; } var data = new byte[imageWidth * imageHeight]; for (var index = 0; index < data.Length; index++) { data[index] = (byte)(index % byte.MaxValue); } var image = OpenJpeg.ImageTileCreate(numComps, parameters, ColorSpace.Srgb); foreach (var parameter in parameters) { parameter.Dispose(); } return(image); }
public void GetNativeVersion() { var version = OpenJpeg.GetNativeVersion(); Assert.True(!string.IsNullOrWhiteSpace(version)); }
public void SetErrorHandler() { using var codec = OpenJpeg.CreateCompress(CodecFormat.J2k); OpenJpeg.SetErrorHandler(codec, new DelegateHandler <MsgCallback>(MsgErrorCallback), IntPtr.Zero); this.DisposeAndCheckDisposedState(codec); }