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);
}
