/// <summary>
/// Decompress a JPEG image to an RGB, grayscale, or CMYK image into precreated unmanaged buffer
/// </summary>
/// <param name="jpegBuf">Pointer to a buffer containing the JPEG image to decompress. This buffer is not modified</param>
/// <param name="jpegBufSize">Size of the JPEG image (in bytes)</param>
/// <param name="outBuf">Pointer to output buffer where decompressed image will be put. Buffer must be created before call</param>
/// <param name="outBufSize">Size of output buffer (in bytes). It must be greater or equal than size of decompressed image</param>
/// <param name="destPixelFormat">Pixel format of the destination image (see <see cref="TJPixelFormats"/> "Pixel formats".)</param>
/// <param name="flags">The bitwise OR of one or more of the <see cref="TJFlags"/> "flags"</param>
/// <exception cref="TJException">Throws if underlying decompress function failed</exception>
/// <exception cref="ObjectDisposedException">Object is disposed and can not be used anymore</exception>
// ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Global
public void Decompress(IntPtr jpegBuf, ulong jpegBufSize, IntPtr outBuf, int outBufSize, TJPixelFormats destPixelFormat, TJFlags flags)
{
GetImageInfo(jpegBuf, jpegBufSize, destPixelFormat, out var width, out var height, out var stride, out var bufSize);
if (outBufSize < bufSize)
{
throw new ArgumentOutOfRangeException("outBufSize");
}
var funcResult = TurboJpegImport.tjDecompress(
_decompressorHandle,
jpegBuf,
jpegBufSize,
outBuf,
width,
stride,
height,
(int)destPixelFormat,
(int)flags);
if (funcResult == -1)
{
TJUtils.GetErrorAndThrow();
}
}
private void Dispose(bool callFromUserCode)
{
if (callFromUserCode)
{
_isDisposed = true;
}
TurboJpegImport.tjDestroy(_compressorHandle);
}
/// <summary>
/// Creates new instance of <see cref="TJCompressor"/>
/// </summary>
/// <exception cref="TJException">
/// Throws if internal compressor instance can not be created
/// </exception>
public TJCompressor()
{
_compressorHandle = TurboJpegImport.tjInitCompress();
if (_compressorHandle == IntPtr.Zero)
{
TJUtils.GetErrorAndThrow();
}
}
/// <summary>
/// Creates new instance of <see cref="TJTransformer"/>
/// </summary>
/// <exception cref="TJException">
/// Throws if internal compressor instance can not be created
/// </exception>
public TJTransformer()
{
_transformHandle = TurboJpegImport.tjInitTransform();
if (_transformHandle == IntPtr.Zero)
{
TJUtils.GetErrorAndThrow();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="TJDecompressor"/> class.
/// </summary>
/// <exception cref="TJException">
/// Throws if internal compressor instance can not be created.
/// </exception>
public TJDecompressor()
{
this.decompressorHandle = TurboJpegImport.TjInitDecompress();
if (this.decompressorHandle == IntPtr.Zero)
{
TJUtils.GetErrorAndThrow();
}
}
/// <summary>
/// Retrieve information about a JPEG image without decompressing it.
/// </summary>
/// <param name="jpegBuf">
/// Pointer to a buffer containing a JPEG image. This buffer is not modified.
/// </param>
/// <param name="jpegBufSize">
/// Size of the JPEG image (in bytes)
/// </param>
/// <param name="destPixelFormat">
/// The pixel format of the uncompressed image.
/// </param>
/// <param name="width">
/// Pointer to an integer variable that will receive the width (in pixels) of the JPEG image
/// </param>
/// <param name="height">
/// Pointer to an integer variable that will receive the height (in pixels) of the JPEG image
/// </param>
/// <param name="stride">
/// Pointer to an integer variable that will receive the stride (in bytes) of the JPEG image.
/// </param>
/// <param name="bufSize">
/// The size of a buffer that can receive the uncompressed JPEG image.
/// </param>
public void GetImageInfo(IntPtr jpegBuf, ulong jpegBufSize, TJPixelFormats destPixelFormat, out int width, out int height, out int stride, out int bufSize)
{
int subsampl;
int colorspace;
var funcResult = TurboJpegImport.tjDecompressHeader(_decompressorHandle, jpegBuf, jpegBufSize,
out width, out height, out subsampl, out colorspace);
stride = TurboJpegImport.TJPAD(width * TurboJpegImport.PixelSizes[destPixelFormat]);
bufSize = stride * height;
}
/// <summary>
/// Compress a set of Y, U (Cb), and V (Cr) image planes into a JPEG image.
/// </summary>
/// <param name="yPlane">
/// A pointer to the Y image planes of the YUV image to be decoded.
/// The size of the plane should match the value returned by tjPlaneSizeYUV() for the given image width, height, strides, and level of chrominance subsampling.
/// </param>
/// <param name="uPlane">
/// A pointer to the U (Cb) image plane (or just <see langword="null"/>, if decoding a grayscale image) of the YUV image to be decoded.
/// The size of the plane should match the value returned by tjPlaneSizeYUV() for the given image width, height, strides, and level of chrominance subsampling.
/// </param>
/// <param name="vPlane">
/// A pointer to the V (Cr)image plane (or just <see langword="null"/>, if decoding a grayscale image) of the YUV image to be decoded.
/// The size of the plane should match the value returned by tjPlaneSizeYUV() for the given image width, height, strides, and level of chrominance subsampling.
/// </param>
/// <param name="width">
/// The width (in pixels) of the source image. If the width is not an even multiple of the MCU block width (see tjMCUWidth), then an intermediate buffer copy will be performed within TurboJPEG.
/// </param>
/// <param name="strides">
/// An array of integers, each specifying the number of bytes per line in the corresponding plane of the YUV source image.
/// Setting the stride for any plane to 0 is the same as setting it to the plane width (see YUV Image Format Notes.)
/// If strides is <see langword="null"/>, then the strides for all planes will be set to their respective plane widths.
/// You can adjust the strides in order to specify an arbitrary amount of line padding in each plane or to decode a subregion of a larger YUV planar image.
/// </param>
/// <param name="height">
/// The height (in pixels) of the source image. If the height is not an even multiple of the MCU block height (see tjMCUHeight), then an intermediate buffer copy will be performed within TurboJPEG.
/// </param>
/// <param name="subsamp">
/// The level of chrominance subsampling used in the source image (see Chrominance subsampling options.)
/// </param>
/// <param name="jpegBuf">
/// A pointer to an image buffer that will receive the JPEG image. TurboJPEG has the ability to reallocate the JPEG buffer to accommodate the size of the JPEG image. Thus, you can choose to:
/// <list type="number">
/// <item>
/// pre-allocate the JPEG buffer with an arbitrary size using <see cref="TJUtils.Alloc"/> and let TurboJPEG grow the buffer as needed,
/// </item>
/// <item>
/// set* jpegBuf to NULL to tell TurboJPEG to allocate the buffer for you, or
/// </item>
/// <item>
/// pre-allocate the buffer to a "worst case" size determined by calling tjBufSize(). This should ensure that the buffer never has to be re-allocated(setting TJFLAG_NOREALLOC guarantees that it won't be.)
/// </item>
/// </list>
/// If you choose option 1, * jpegSize should be set to the size of your pre-allocated buffer. In any case, unless you have set TJFLAG_NOREALLOC, you should always check *jpegBuf upon return from this function, as it may have changed.
/// </param>
/// <param name="jpegQual">
/// The image quality of the generated JPEG image (1 = worst, 100 = best).
/// </param>
/// <param name="flags">
/// The bitwise OR of one or more of the flags.
/// </param>
/// <returns>
/// A <see cref="Span{byte}"/> which holds the compressed image.
/// </returns>
public unsafe Span <byte> CompressFromYUVPlanes(
Span <byte> yPlane,
Span <byte> uPlane,
Span <byte> vPlane,
int width,
int[] strides,
int height,
TJSubsamplingOption subsamp,
Span <byte> jpegBuf,
int jpegQual,
TJFlags flags)
{
if (this.isDisposed)
{
throw new ObjectDisposedException(nameof(TJCompressor));
}
uint destBufSize = (uint)jpegBuf.Length;
IntPtr jpegBufPtr2 = IntPtr.Zero;
fixed(byte *yPlanePtr = yPlane)
fixed(byte *uPlanePtr = uPlane)
fixed(byte *vPlanePtr = vPlane)
{
byte *[] planes = new byte *[] { yPlanePtr, uPlanePtr, vPlanePtr };
fixed(int *stridesPtr = strides)
fixed(byte *jpegBufPtr = jpegBuf)
fixed(byte **planesPtr = planes)
{
jpegBufPtr2 = (IntPtr)jpegBufPtr;
var result = TurboJpegImport.TjCompressFromYUVPlanes(
this.compressorHandle,
planesPtr,
width,
stridesPtr,
height,
(int)subsamp,
ref jpegBufPtr2,
ref destBufSize,
jpegQual,
(int)flags);
if (result == -1)
{
TJUtils.GetErrorAndThrow();
}
}
}
return(new Span <byte>(jpegBufPtr2.ToPointer(), (int)destBufSize));
}
/// <summary>
/// Compresses input image to the jpeg format with specified quality
/// </summary>
/// <param name="srcPtr">
/// Pointer to an image buffer containing RGB, grayscale, or CMYK pixels to be compressed.
/// This buffer is not modified.
/// </param>
/// <param name="stride">
/// Bytes per line in the source image.
/// Normally, this should be <c>width * BytesPerPixel</c> if the image is unpadded,
/// or <c>TJPAD(width * BytesPerPixel</c> if each line of the image
/// is padded to the nearest 32-bit boundary, as is the case for Windows bitmaps.
/// You can also be clever and use this parameter to skip lines, etc.
/// Setting this parameter to 0 is the equivalent of setting it to
/// <c>width * BytesPerPixel</c>.
/// </param>
/// <param name="width">Width (in pixels) of the source image</param>
/// <param name="height">Height (in pixels) of the source image</param>
/// <param name="pixelFormat">Pixel format of the source image (see <see cref="PixelFormat"/> "Pixel formats")</param>
/// <param name="subSamp">
/// The level of chrominance subsampling to be used when
/// generating the JPEG image (see <see cref="TJSubsamplingOptions"/> "Chrominance subsampling options".)
/// </param>
/// <param name="quality">The image quality of the generated JPEG image (1 = worst, 100 = best)</param>
/// <param name="flags">The bitwise OR of one or more of the <see cref="TJFlags"/> "flags"</param>
/// <exception cref="TJException"> Throws if compress function failed </exception>
/// <exception cref="ObjectDisposedException">Object is disposed and can not be used anymore</exception>
/// <exception cref="NotSupportedException">
/// Some parameters' values are incompatible:
/// <list type="bullet">
/// <item><description>Subsampling not equals to <see cref="TJSubsamplingOptions.TJSAMP_GRAY"/> and pixel format <see cref="TJPixelFormats.TJPF_GRAY"/></description></item>
/// </list>
/// </exception>
public byte[] Compress(IntPtr srcPtr, int stride, int width, int height, PixelFormat pixelFormat = PixelFormat.Format32bppArgb, TJSubsamplingOptions subSamp = TJSubsamplingOptions.TJSAMP_420, int quality = 50, TJFlags flags = TJFlags.FASTDCT)
{
if (_isDisposed)
{
throw new ObjectDisposedException("this");
}
var tjPixelFormat = TJUtils.ConvertPixelFormat(pixelFormat);
CheckOptionsCompatibilityAndThrow(subSamp, tjPixelFormat);
TJDoCompDel compresscall = TurboJpegImport.tjCompress2;
if (isXPlatform)
{
compresscall = TurboJpegImport_xplat.tjCompressX;
}
var buf = IntPtr.Zero;
ulong bufSize = 0;
try
{
var result = compresscall(
_compressorHandle,
srcPtr,
width,
stride,
height,
(int)tjPixelFormat,
ref buf,
ref bufSize,
(int)subSamp,
quality,
(int)flags);
if (result == -1)
{
TJUtils.GetErrorAndThrow();
}
var jpegBuf = new byte[bufSize];
// ReSharper disable once ExceptionNotDocumentedOptional
Marshal.Copy(buf, jpegBuf, 0, (int)bufSize);
return(jpegBuf);
}
finally
{
TurboJpegImport.tjFree(buf);
}
}
/// <summary>
/// Decompress a JPEG image to an RGB, grayscale, or CMYK image.
/// </summary>
/// <param name="jpegBuf">Pointer to a buffer containing the JPEG image to decompress. This buffer is not modified.</param>
/// <param name="jpegBufSize">Size of the JPEG image (in bytes).</param>
/// <param name="outBuf">The buffer into which to store the decompressed JPEG image.</param>
/// <param name="outBufSize">Size of <paramref name="outBuf"/> (in bytes).</param>
/// <param name="destPixelFormat">Pixel format of the destination image (see <see cref="PixelFormat"/> "Pixel formats".)</param>
/// <param name="flags">The bitwise OR of one or more of the <see cref="TJFlags"/> "flags".</param>
/// <param name="width">Width of image in pixels.</param>
/// <param name="height">Height of image in pixels.</param>
/// <param name="stride">Bytes per line in the destination image.</param>
public unsafe void Decompress(IntPtr jpegBuf, ulong jpegBufSize, IntPtr outBuf, int outBufSize, TJPixelFormat destPixelFormat, TJFlags flags, out int width, out int height, out int stride)
{
if (this.isDisposed)
{
throw new ObjectDisposedException("this");
}
int subsampl;
int colorspace;
var funcResult = TurboJpegImport.TjDecompressHeader(
this.decompressorHandle,
jpegBuf,
jpegBufSize,
out width,
out height,
out subsampl,
out colorspace);
if (funcResult == -1)
{
TJUtils.GetErrorAndThrow();
}
var targetFormat = destPixelFormat;
stride = TurboJpegImport.TJPAD(width * TurboJpegImport.PixelSizes[targetFormat]);
var bufSize = stride * height;
if (outBufSize < bufSize)
{
throw new ArgumentOutOfRangeException(nameof(outBufSize));
}
funcResult = TurboJpegImport.TjDecompress(
this.decompressorHandle,
jpegBuf,
jpegBufSize,
outBuf,
width,
stride,
height,
(int)targetFormat,
(int)flags);
if (funcResult == -1)
{
TJUtils.GetErrorAndThrow();
}
}
/// <summary>
/// Compresses input image to the jpeg format with specified quality
/// </summary>
/// <param name="srcBuf">
/// Image buffer containing RGB, grayscale, or CMYK pixels to be compressed.
/// This buffer is not modified.
/// </param>
/// <param name="stride">
/// Bytes per line in the source image.
/// Normally, this should be <c>width * BytesPerPixel</c> if the image is unpadded,
/// or <c>TJPAD(width * BytesPerPixel</c> if each line of the image
/// is padded to the nearest 32-bit boundary, as is the case for Windows bitmaps.
/// You can also be clever and use this parameter to skip lines, etc.
/// Setting this parameter to 0 is the equivalent of setting it to
/// <c>width * BytesPerPixel</c>.
/// </param>
/// <param name="width">Width (in pixels) of the source image</param>
/// <param name="height">Height (in pixels) of the source image</param>
/// <param name="pixelFormat">Pixel format of the source image (see <see cref="PixelFormat"/> "Pixel formats")</param>
/// <param name="subSamp">
/// The level of chrominance subsampling to be used when
/// generating the JPEG image (see <see cref="TJSubsamplingOptions"/> "Chrominance subsampling options".)
/// </param>
/// <param name="quality">The image quality of the generated JPEG image (1 = worst, 100 = best)</param>
/// <param name="flags">The bitwise OR of one or more of the <see cref="TJFlags"/> "flags"</param>
/// <exception cref="TJException">
/// Throws if compress function failed
/// </exception>
/// <exception cref="ObjectDisposedException">Object is disposed and can not be used anymore</exception>
/// <exception cref="NotSupportedException">
/// Some parameters' values are incompatible:
/// <list type="bullet">
/// <item><description>Subsampling not equals to <see cref="TJSubsamplingOptions.TJSAMP_GRAY"/> and pixel format <see cref="TJPixelFormats.TJPF_GRAY"/></description></item>
/// </list>
/// </exception>
public unsafe byte[] Compress(byte[] srcBuf, int stride, int width, int height, PixelFormat pixelFormat, TJSubsamplingOptions subSamp, int quality, TJFlags flags)
{
if (_isDisposed)
{
throw new ObjectDisposedException("this");
}
var tjPixelFormat = TJUtils.ConvertPixelFormat(pixelFormat);
CheckOptionsCompatibilityAndThrow(subSamp, tjPixelFormat);
var buf = IntPtr.Zero;
ulong bufSize = 0;
try
{
fixed(byte *srcBufPtr = srcBuf)
{
var result = TurboJpegImport.tjCompress2(
_compressorHandle,
(IntPtr)srcBufPtr,
width,
stride,
height,
(int)tjPixelFormat,
ref buf,
ref bufSize,
(int)subSamp,
quality,
(int)flags);
if (result == -1)
{
TJUtils.GetErrorAndThrow();
}
}
var jpegBuf = new byte[bufSize];
// ReSharper disable once ExceptionNotDocumentedOptional
Marshal.Copy(buf, jpegBuf, 0, (int)bufSize);
return(jpegBuf);
}
finally
{
TurboJpegImport.tjFree(buf);
}
}
/// <summary>
/// Creates new instance of <see cref="TJCompressor"/>
/// </summary>
/// <exception cref="TJException">
/// Throws if internal compressor instance can not be created
/// </exception>
public TJCompressor(bool iscrossplatform = false)
{
isXPlatform = iscrossplatform;
if (iscrossplatform)
{
_compressorHandle = TurboJpegImport_xplat.tjInitCompressX();
}
else
{
_compressorHandle = TurboJpegImport.tjInitCompress();
}
if (_compressorHandle == IntPtr.Zero)
{
TJUtils.GetErrorAndThrow();
}
}
/// <summary>
/// Compresses input image to the jpeg format with specified quality
/// </summary>
/// <param name="srcPtr">
/// Pointer to an image buffer containing RGB, grayscale, or CMYK pixels to be compressed.
/// This buffer is not modified.
/// </param>
/// <param name="stride">
/// Bytes per line in the source image.
/// Normally, this should be <c>width * BytesPerPixel</c> if the image is unpadded,
/// or <c>TJPAD(width * BytesPerPixel</c> if each line of the image
/// is padded to the nearest 32-bit boundary, as is the case for Windows bitmaps.
/// You can also be clever and use this parameter to skip lines, etc.
/// Setting this parameter to 0 is the equivalent of setting it to
/// <c>width * BytesPerPixel</c>.
/// </param>
/// <param name="width">Width (in pixels) of the source image</param>
/// <param name="height">Height (in pixels) of the source image</param>
/// <param name="tjPixelFormat">Pixel format of the source image (see <see cref="TJPixelFormats"/> "Pixel formats")</param>
/// <param name="subSamp">
/// The level of chrominance subsampling to be used when
/// generating the JPEG image (see <see cref="TJSubsamplingOptions"/> "Chrominance subsampling options".)
/// </param>
/// <param name="quality">The image quality of the generated JPEG image (1 = worst, 100 = best)</param>
/// <param name="flags">The bitwise OR of one or more of the <see cref="TJFlags"/> "flags"</param>
/// <param name="onAsyncCompressionCompleted">Method to process compressed data</param>
/// <param name="state">User-defined state passed to <paramref name="onAsyncCompressionCompleted"/> method</param>
/// <param name="cancellationToken">Cancellation token.</param>
/// <exception cref="TJException">Throws if compress function failed.</exception>
/// <exception cref="ObjectDisposedException">Object is disposed and can not be used anymore</exception>
/// <exception cref="NotSupportedException">
/// Some parameters' values are incompatible:
/// <list type="bullet">
/// <item><description>Subsampling not equals to <see cref="TJSubsamplingOptions.TJSAMP_GRAY"/> and pixel format <see cref="TJPixelFormats.TJPF_GRAY"/></description></item>
/// </list>
/// </exception>
/// <returns>
/// </returns>
public async Task CompressAsync(IntPtr srcPtr, int stride, int width, int height,
TJPixelFormats tjPixelFormat, TJSubsamplingOptions subSamp, int quality, TJFlags flags,
TJAsyncCompressionComplete onAsyncCompressionCompleted, object state, CancellationToken cancellationToken)
{
if (_isDisposed)
{
throw new ObjectDisposedException("this");
}
if (onAsyncCompressionCompleted == null)
{
throw new ArgumentNullException(nameof(onAsyncCompressionCompleted));
}
CheckOptionsCompatibilityAndThrow(subSamp, tjPixelFormat);
var buf = IntPtr.Zero;
ulong bufSize = 0;
try
{
var result = TurboJpegImport.tjCompress2(
_compressorHandle,
srcPtr,
width,
stride,
height,
(int)tjPixelFormat,
ref buf,
ref bufSize,
(int)subSamp,
quality,
(int)flags);
if (result == -1)
{
TJUtils.GetErrorAndThrow();
}
await onAsyncCompressionCompleted(buf, (int)bufSize, state, cancellationToken);
}
finally
{
TurboJpegImport.tjFree(buf);
}
}
/// <summary>
/// Decode a set of Y, U (Cb), and V (Cr) image planes into an RGB or grayscale image.
/// </summary>
/// <param name="yPlane">
/// A pointer to the Y image planes of the YUV image to be decoded.
/// The size of the plane should match the value returned by tjPlaneSizeYUV() for the given image width, height, strides, and level of chrominance subsampling.
/// </param>
/// <param name="uPlane">
/// A pointer to the U (Cb) image plane (or just <see langword="null"/>, if decoding a grayscale image) of the YUV image to be decoded.
/// The size of the plane should match the value returned by tjPlaneSizeYUV() for the given image width, height, strides, and level of chrominance subsampling.
/// </param>
/// <param name="vPlane">
/// A pointer to the V (Cr)image plane (or just <see langword="null"/>, if decoding a grayscale image) of the YUV image to be decoded.
/// The size of the plane should match the value returned by tjPlaneSizeYUV() for the given image width, height, strides, and level of chrominance subsampling.
/// </param>
/// <param name="strides">
/// An array of integers, each specifying the number of bytes per line in the corresponding plane of the YUV source image.
/// Setting the stride for any plane to 0 is the same as setting it to the plane width (see YUV Image Format Notes.)
/// If strides is <see langword="null"/>, then the strides for all planes will be set to their respective plane widths.
/// You can adjust the strides in order to specify an arbitrary amount of line padding in each plane or to decode a subregion of a larger YUV planar image.
/// </param>
/// <param name="subsamp">
/// The level of chrominance subsampling used in the YUV source image (see Chrominance subsampling options.)
/// </param>
/// <param name="dstBuf">
/// A pointer to an image buffer that will receive the decoded image. This buffer should normally be <paramref name="pitch"/> * <paramref name="height"/> bytes in size,
/// but the <paramref name="dstBuf"/> pointer can also be used to decode into a specific region of a larger buffer.
/// </param>
/// <param name="width">
/// Width (in pixels) of the source and destination images.
/// </param>
/// <param name="pitch">
/// Bytes per line in the destination image. Normally, this should be <paramref name="width"/> * <c>tjPixelSize[pixelFormat]</c>
/// if the destination image is unpadded, or <c>TJPAD(width * tjPixelSize[pixelFormat])</c> if each line of the destination image
/// should be padded to the nearest 32-bit boundary, as is the case for Windows bitmaps. You can also be clever and use the
/// pitch parameter to skip lines, etc.
/// Setting this parameter to <c>0</c> is the equivalent of setting it to <paramref name="width"/> * <c>tjPixelSize[pixelFormat]</c>.
/// </param>
/// <param name="height">
/// Height (in pixels) of the source and destination images.
/// </param>
/// <param name="pixelFormat">
/// Pixel format of the destination image.
/// </param>
/// <param name="flags">
/// The bitwise OR of one or more of the flags.
/// </param>
/// <remarks>
/// <para>
/// This function uses the accelerated color conversion routines in the underlying codec but does not execute any of the other steps in the JPEG decompression process.
/// </para>
/// <para>
/// The <paramref name="yPlane"/>, <paramref name="uPlane"/> and <paramref name="vPlane"/> planes can be contiguous or non-contiguous in memory.
/// Refer to YUV Image Format Notes for more details.
/// </para>
/// </remarks>
public unsafe void DecodeYUVPlanes(
Span <byte> yPlane,
Span <byte> uPlane,
Span <byte> vPlane,
int[] strides,
TJSubsamplingOption subsamp,
Span <byte> dstBuf,
int width,
int pitch,
int height,
TJPixelFormat pixelFormat,
TJFlags flags)
{
if (this.isDisposed)
{
throw new ObjectDisposedException(nameof(TJDecompressor));
}
fixed(byte *yPlanePtr = yPlane)
fixed(byte *uPlanePtr = uPlane)
fixed(byte *vPlanePtr = vPlane)
{
byte *[] planes = new byte *[] { yPlanePtr, uPlanePtr, vPlanePtr };
fixed(int *stridesPtr = strides)
fixed(byte **planesPtr = planes)
fixed(byte *dstBufPtr = dstBuf)
{
if (TurboJpegImport.TjDecodeYUVPlanes(
this.decompressorHandle,
planesPtr,
stridesPtr,
(int)subsamp,
(IntPtr)dstBufPtr,
width,
pitch,
height,
(int)pixelFormat,
(int)flags) == -1)
{
TJUtils.GetErrorAndThrow();
}
}
}
}
private void Dispose(bool callFromUserCode)
{
if (callFromUserCode)
{
_isDisposed = true;
}
// If for whathever reason, the handle was not initialized correctly (e.g. an exception
// in the constructor), we shouldn't free it either.
if (_decompressorHandle != IntPtr.Zero)
{
TurboJpegImport.tjDestroy(_decompressorHandle);
// Set the handle to IntPtr.Zero, to prevent double execution of this method
// (i.e. make calling Dispose twice a safe thing to do).
_decompressorHandle = IntPtr.Zero;
}
}
/// <summary>
/// Returns info about jpeg image without decompressing it
/// </summary>
/// <param name="jpegBuf">Pointer to a buffer containing the JPEG image to decompress. This buffer is not modified</param>
/// <param name="jpegBufSize">Size of the JPEG image (in bytes)</param>
/// <param name="destPixelFormat">Pixel format of the destination image</param>
/// <param name="width">Width of image in pixels</param>
/// <param name="height">Height of image in pixels</param>
/// <param name="stride">Bytes per line in the destination image</param>
/// <param name="decompressedBufferSize">Size in bytes for buffer where decompressed image will be put</param>
/// <exception cref="TJException">Throws if underlying decompress function failed</exception>
/// <exception cref="ObjectDisposedException">Object is disposed and can not be used anymore</exception>
/// <returns></returns>
public void GetImageInfo(IntPtr jpegBuf, ulong jpegBufSize, TJPixelFormats destPixelFormat, out int width, out int height, out int stride, out int decompressedBufferSize)
{
if (_isDisposed)
{
throw new ObjectDisposedException("this");
}
var funcResult = TurboJpegImport.tjDecompressHeader(_decompressorHandle, jpegBuf, jpegBufSize,
out width, out height, out _, out _);
if (funcResult == -1)
{
TJUtils.GetErrorAndThrow();
}
stride = TurboJpegImport.TJPAD(width * TurboJpegImport.PixelSizes[destPixelFormat]);
decompressedBufferSize = stride * height;
}
public static void Main(string[] args)
{
TurboJpegImport_control.isAutoLoadLibrary = false;
TurboJpegImport.Load();
var i1 = new Bitmap(100, 100);
var g = Graphics.FromImage(i1);
var os = GetBuffer(i1).Length;
string hw = "Hello World!", osi = "RawSize: " + os.ToString("n0");
g.DrawString(hw, new Font(FontFamily.GenericSansSerif, 10, FontStyle.Regular), new SolidBrush(Color.Yellow), 0, 35);
g.DrawString(osi, new Font(FontFamily.GenericSansSerif, 8, FontStyle.Regular), new SolidBrush(Color.Yellow), 0, 50);
//TurboJpegWrapper.TJCompressor c = new TJCompressor();
TurboJpegWrapper.TJCompressor c = new TJCompressor(true);
var data = c.Compress(i1, TJSubsamplingOptions.TJSAMP_420, 50, TJFlags.FASTDCT);
TurboJpegWrapper.TJDecompressor d = new TJDecompressor();
var i2 = d.Decompress(data, System.Drawing.Imaging.PixelFormat.Format32bppArgb, TJFlags.FASTDCT);
g = Graphics.FromImage(i2);
var ns = data.Length;
var nsi = "JpegSize: " + ns.ToString("n0");
g.DrawString(nsi, new Font(FontFamily.GenericSansSerif, 8, FontStyle.Regular), new SolidBrush(Color.Red), 0, 65);
i1.Save(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Desktop), "TurboJpegWrapper.Test.1.bmp"));
i2.Save(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Desktop), "TurboJpegWrapper.Test.2.bmp"));
foreach (var s in new[] { hw, osi, nsi })
{
Console.WriteLine(s);
}
if (os <= ns)
{
throw new Exception("No jpeg compression occurred.");
}
else if ((os != 40000) || (ns != 1790))
{
throw new Exception("Compression occurred but either Original image bytes: " + os + " or Compressed image bytes: " + ns + " were not as expected.");
}
else
{
Console.WriteLine("Compression succeeded. " + (c.isXPlatform ? "[cross-platform]" : "[dllimport]"));
}
Console.WriteLine("enter to quit...");
Console.ReadLine();
}
/// <summary>
/// Compresses input image to the jpeg format with specified quality.
/// </summary>
/// <param name="srcPtr">
/// Pointer to an image buffer containing RGB, grayscale, or CMYK pixels to be compressed.
/// This buffer is not modified.
/// </param>
/// <param name="stride">
/// Bytes per line in the source image.
/// Normally, this should be <c>width * BytesPerPixel</c> if the image is unpadded,
/// or <c>TJPAD(width * BytesPerPixel</c> if each line of the image
/// is padded to the nearest 32-bit boundary, as is the case for Windows bitmaps.
/// You can also be clever and use this parameter to skip lines, etc.
/// Setting this parameter to 0 is the equivalent of setting it to
/// <c>width * BytesPerPixel</c>.
/// </param>
/// <param name="width">Width (in pixels) of the source image.</param>
/// <param name="height">Height (in pixels) of the source image.</param>
/// <param name="pixelFormat">Pixel format of the source image (see <see cref="PixelFormat"/> "Pixel formats").</param>
/// <param name="subSamp">
/// The level of chrominance subsampling to be used when
/// generating the JPEG image (see <see cref="TJSubsamplingOption"/> "Chrominance subsampling options".)
/// </param>
/// <param name="quality">The image quality of the generated JPEG image (1 = worst, 100 = best).</param>
/// <param name="flags">The bitwise OR of one or more of the <see cref="TJFlags"/> "flags".</param>
/// <returns>
/// A <see cref="byte"/> array containing the compressed image.
/// </returns>
/// <exception cref="TJException"> Throws if compress function failed. </exception>
/// <exception cref="ObjectDisposedException">Object is disposed and can not be used anymore.</exception>
/// <exception cref="NotSupportedException">
/// Some parameters' values are incompatible:
/// <list type="bullet">
/// <item><description>Subsampling not equals to <see cref="TJSubsamplingOption.Gray"/> and pixel format <see cref="TJPixelFormat.Gray"/></description></item>
/// </list>
/// </exception>
public byte[] Compress(IntPtr srcPtr, int stride, int width, int height, PixelFormat pixelFormat, TJSubsamplingOption subSamp, int quality, TJFlags flags)
{
if (this.isDisposed)
{
throw new ObjectDisposedException("this");
}
var tjPixelFormat = TJUtils.ConvertPixelFormat(pixelFormat);
CheckOptionsCompatibilityAndThrow(subSamp, tjPixelFormat);
var buf = IntPtr.Zero;
ulong bufSize = 0;
try
{
var result = TurboJpegImport.TjCompress2(
this.compressorHandle,
srcPtr,
width,
stride,
height,
(int)tjPixelFormat,
ref buf,
ref bufSize,
(int)subSamp,
quality,
(int)flags);
if (result == -1)
{
TJUtils.GetErrorAndThrow();
}
var jpegBuf = new byte[bufSize];
Marshal.Copy(buf, jpegBuf, 0, (int)bufSize);
return(jpegBuf);
}
finally
{
TurboJpegImport.TjFree(buf);
}
}
/// <summary>
/// Decompress a JPEG image to an RGB, grayscale, or CMYK image.
/// </summary>
/// <param name="jpegBuf">Pointer to a buffer containing the JPEG image to decompress. This buffer is not modified</param>
/// <param name="jpegBufSize">Size of the JPEG image (in bytes)</param>
/// <param name="destPixelFormat">Pixel format of the destination image</param>
/// <param name="flags">The bitwise OR of one or more of the <see cref="TJFlags"/> "flags"</param>
/// <param name="width">Width of image in pixels</param>
/// <param name="height">Height of image in pixels</param>
/// <param name="stride">Bytes per line in the destination image</param>
/// <returns>Raw pixel data of specified format</returns>
/// <exception cref="TJException">Throws if underlying decompress function failed</exception>
/// <exception cref="ObjectDisposedException">Object is disposed and can not be used anymore</exception>
public unsafe byte[] Decompress(IntPtr jpegBuf, ulong jpegBufSize, TJPixelFormats destPixelFormat, TJFlags flags, out int width, out int height, out int stride)
{
if (_isDisposed)
{
throw new ObjectDisposedException("this");
}
var funcResult = TurboJpegImport.tjDecompressHeader(_decompressorHandle, jpegBuf, jpegBufSize,
out width, out height, out _, out _);
if (funcResult == -1)
{
TJUtils.GetErrorAndThrow();
}
var targetFormat = destPixelFormat;
stride = TurboJpegImport.TJPAD(width * TurboJpegImport.PixelSizes[targetFormat]);
var bufSize = stride * height;
var buf = new byte[bufSize];
fixed(byte *bufPtr = buf)
{
funcResult = TurboJpegImport.tjDecompress(
_decompressorHandle,
jpegBuf,
jpegBufSize,
(IntPtr)bufPtr,
width,
stride,
height,
(int)targetFormat,
(int)flags);
if (funcResult == -1)
{
TJUtils.GetErrorAndThrow();
}
return(buf);
}
}
/// <summary>
/// Compresses input image to the jpeg format with specified quality.
/// </summary>
/// <param name="srcBuf">
/// Image buffer containing RGB, grayscale, or CMYK pixels to be compressed.
/// This buffer is not modified.
/// </param>
/// <param name="destBuf">
/// A <see cref="byte"/> array containing the compressed image.
/// </param>
/// <param name="stride">
/// Bytes per line in the source image.
/// Normally, this should be <c>width * BytesPerPixel</c> if the image is unpadded,
/// or <c>TJPAD(width * BytesPerPixel</c> if each line of the image
/// is padded to the nearest 32-bit boundary, as is the case for Windows bitmaps.
/// You can also be clever and use this parameter to skip lines, etc.
/// Setting this parameter to 0 is the equivalent of setting it to
/// <c>width * BytesPerPixel</c>.
/// </param>
/// <param name="width">Width (in pixels) of the source image.</param>
/// <param name="height">Height (in pixels) of the source image.</param>
/// <param name="pixelFormat">Pixel format of the source image (see <see cref="PixelFormat"/> "Pixel formats").</param>
/// <param name="subSamp">
/// The level of chrominance subsampling to be used when
/// generating the JPEG image (see <see cref="TJSubsamplingOption"/> "Chrominance subsampling options".)
/// </param>
/// <param name="quality">The image quality of the generated JPEG image (1 = worst, 100 = best).</param>
/// <param name="flags">The bitwise OR of one or more of the <see cref="TJFlags"/> "flags".</param>
/// <returns>
/// A <see cref="Span{T}"/> which is a slice of <paramref name="destBuf"/> which holds the compressed image.
/// </returns>
/// <exception cref="TJException">
/// Throws if compress function failed.
/// </exception>
/// <exception cref="ObjectDisposedException">Object is disposed and can not be used anymore.</exception>
/// <exception cref="NotSupportedException">
/// Some parameters' values are incompatible:
/// <list type="bullet">
/// <item><description>Subsampling not equals to <see cref="TJSubsamplingOption.Gray"/> and pixel format <see cref="TJPixelFormat.Gray"/></description></item>
/// </list>
/// </exception>
public unsafe Span <byte> Compress(Span <byte> srcBuf, Span <byte> destBuf, int stride, int width, int height, TJPixelFormat pixelFormat, TJSubsamplingOption subSamp, int quality, TJFlags flags)
{
if (this.isDisposed)
{
throw new ObjectDisposedException(nameof(TJCompressor));
}
CheckOptionsCompatibilityAndThrow(subSamp, pixelFormat);
ulong destBufSize = (ulong)destBuf.Length;
fixed(byte *srcBufPtr = srcBuf)
fixed(byte *destBufPtr = destBuf)
{
IntPtr destBufPtr2 = (IntPtr)destBufPtr;
var result = TurboJpegImport.TjCompress2(
this.compressorHandle,
(IntPtr)srcBufPtr,
width,
stride,
height,
(int)pixelFormat,
ref destBufPtr2,
ref destBufSize,
(int)subSamp,
quality,
(int)flags);
if (result == -1)
{
TJUtils.GetErrorAndThrow();
}
}
return(destBuf.Slice(0, (int)destBufSize));
}
/// <summary> /// Allocate an image buffer for use with TurboJPEG. /// </summary> /// <param name="bytes">The number of bytes to allocate.</param> /// <returns>A pointer to a newly-allocated buffer with the specified number of bytes.</returns> /// <seealso cref="Free"/> public static IntPtr Alloc(int bytes) => TurboJpegImport.TjAlloc(bytes);
///<summary>
/// Retrieves last error from underlying turbo-jpeg library and throws exception.</summary>
/// <exception cref="TJException"> Throws if low level turbo jpeg function fails. </exception>
public static void GetErrorAndThrow()
{
var error = Marshal.PtrToStringAnsi(TurboJpegImport.TjGetErrorStr());
throw new TJException(error);
}
/// <summary> /// Free an image buffer previously allocated by TurboJPEG. /// </summary> /// <param name="buffer">Address of the buffer to free.</param> /// <seealso cref="Alloc"/> public static void Free(IntPtr buffer) => TurboJpegImport.TjFree(buffer);
/// <summary>
/// Given the size of an image, determines the size of a decompressed image.
/// </summary>
/// <param name="height">
/// The height of the image.
/// </param>
/// <param name="width">
/// The width of the image.
/// </param>
/// <param name="destPixelFormat">
/// The pixel format of the uncompressed image.
/// </param>
/// <returns>
/// The size of a buffer that can hold the uncompressed image.
/// </returns>
public int GetBufferSize(int height, int width, TJPixelFormats destPixelFormat)
{
int stride = TurboJpegImport.TJPAD(width * TurboJpegImport.PixelSizes[destPixelFormat]);
return(stride * height);
}
/// <summary>Transforms input image into one or several destinations.</summary>
/// <param name="jpegBuf">Pointer to a buffer containing the JPEG image to decompress. This buffer is not modified.</param>
/// <param name="jpegBufSize">Size of the JPEG image (in bytes).</param>
/// <param name="transforms">Array of transform descriptions to be applied to the source image. </param>
/// <param name="flags">The bitwise OR of one or more of the <see cref="TJFlags"/> "flags".</param>
/// <returns>Array of transformed jpeg images.</returns>
/// <exception cref="ArgumentNullException"><paramref name="transforms"/> is <see langword="null" />.</exception>
/// <exception cref="ArgumentException">Transforms can not be empty.</exception>
/// <exception cref="TJException"> Throws if low level turbo jpeg function fails. </exception>
public byte[][] Transform(IntPtr jpegBuf, ulong jpegBufSize, TJTransformDescription[] transforms, TJFlags flags)
{
if (transforms == null)
{
throw new ArgumentNullException(nameof(transforms));
}
if (transforms.Length == 0)
{
throw new ArgumentException("Transforms can not be empty", nameof(transforms));
}
// ReSharper disable once ExceptionNotDocumented
var count = transforms.Length;
var destBufs = new IntPtr[count];
var destSizes = new ulong[count];
int subsampl;
int colorspace;
int width;
int height;
var funcResult = TurboJpegImport.TjDecompressHeader(
this.transformHandle,
jpegBuf,
jpegBufSize,
out width,
out height,
out subsampl,
out colorspace);
if (funcResult == -1)
{
TJUtils.GetErrorAndThrow();
}
TjSize tjSize;
if (!TurboJpegImport.MCUSizes.TryGetValue((TJSubsamplingOption)subsampl, out tjSize))
{
throw new TJException("Unable to read Subsampling Options from jpeg header");
}
var tjTransforms = new TjTransform[count];
for (var i = 0; i < count; i++)
{
var x = CorrectRegionCoordinate(transforms[i].Region.X, tjSize.Width);
var y = CorrectRegionCoordinate(transforms[i].Region.Y, tjSize.Height);
var w = CorrectRegionSize(transforms[i].Region.X, x, transforms[i].Region.W, width);
var h = CorrectRegionSize(transforms[i].Region.Y, y, transforms[i].Region.H, height);
tjTransforms[i] = new TjTransform
{
Op = (int)transforms[i].Operation,
Options = (int)transforms[i].Options,
R = new TJRegion
{
X = x,
Y = y,
W = w,
H = h,
},
Data = transforms[i].CallbackData,
CustomFilter = transforms[i].CustomFilter,
};
}
var transformsPtr = TJUtils.StructArrayToIntPtr(tjTransforms);
try
{
funcResult = TurboJpegImport.TjTransform(
this.transformHandle,
jpegBuf,
jpegBufSize,
count,
destBufs,
destSizes,
transformsPtr,
(int)flags);
if (funcResult == -1)
{
TJUtils.GetErrorAndThrow();
}
var result = new List <byte[]>();
for (var i = 0; i < destBufs.Length; i++)
{
var ptr = destBufs[i];
var size = destSizes[i];
var item = new byte[size];
Marshal.Copy(ptr, item, 0, (int)size);
result.Add(item);
TurboJpegImport.TjFree(ptr);
}
return(result.ToArray());
}
finally
{
TJUtils.FreePtr(transformsPtr);
}
}
///<summary>
/// Retrieves last error from underlying turbo-jpeg library and throws exception</summary>
/// <exception cref="TJException"> Throws if low level turbo jpeg function fails </exception>
public static void GetErrorAndThrow()
{
var error = TurboJpegImport.tjGetErrorStr();
throw new TJException(error);
}
/// <summary>
/// The maximum size of the buffer (in bytes) required to hold a JPEG image with
/// the given parameters. The number of bytes returned by this function is
/// larger than the size of the uncompressed source image. The reason for this
/// is that the JPEG format uses 16-bit coefficients, and it is thus possible
/// for a very high-quality JPEG image with very high-frequency content to
/// expand rather than compress when converted to the JPEG format. Such images
/// represent a very rare corner case, but since there is no way to predict the
/// size of a JPEG image prior to compression, the corner case has to be handled.
/// </summary>
/// <param name="width">Width (in pixels) of the image.</param>
/// <param name="height">Height (in pixels) of the image.</param>
/// <param name="subSamp">
/// The level of chrominance subsampling to be used when
/// generating the JPEG image(see <see cref="TJSubsamplingOption"/> "Chrominance subsampling options".)
/// </param>
/// <returns>
/// The maximum size of the buffer (in bytes) required to hold the image,
/// or -1 if the arguments are out of bounds.
/// </returns>
public int GetBufferSize(int width, int height, TJSubsamplingOption subSamp)
{
return((int)TurboJpegImport.TjBufSize(width, height, (int)subSamp));
}