/// <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="TJPixelFormat"/> "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)
{
Verify.NotDisposed(this);
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);
TJUtils.ThrowOnError(result);
}
return(destBuf.Slice(0, (int)destBufSize));
}
/// <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, TJPixelFormat destPixelFormat)
{
Verify.NotDisposed(this);
int stride = TurboJpegImport.TJPAD(width * TurboJpegImport.PixelSizes[destPixelFormat]);
return(stride * height);
}
/// <inheritdoc/>
public void Dispose()
{
// If for whathever reason, the handle was not initialized correctly (e.g. an exception
// in the constructor), we shouldn't free it either.
if (this.compressorHandle != IntPtr.Zero)
{
TurboJpegImport.TjDestroy(this.compressorHandle);
// Set the handle to IntPtr.Zero, to prevent double execution of this method
// (i.e. make calling Dispose twice a safe thing to do).
this.compressorHandle = IntPtr.Zero;
}
this.IsDisposed = true;
}
/// <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 <see cref="PlaneSizeYUV"/> 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 <see cref="PlaneSizeYUV"/> 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 <see cref="PlaneSizeYUV"/> 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="TurboJpegImport.TjAlloc"/> 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{T}"/> 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)
{
Verify.NotDisposed(this);
nuint destBufSize = (nuint)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);
TJUtils.ThrowOnError(result);
}
}
return(new Span <byte>(jpegBufPtr2.ToPointer(), (int)destBufSize));
}
/// <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="outBuf">The buffer into which to store the decompressed JPEG image.</param>
/// <param name="destPixelFormat">Pixel format of the destination image (see <see cref="TJPixelFormat"/> "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(Span <byte> jpegBuf, Span <byte> outBuf, TJPixelFormat destPixelFormat, TJFlags flags, out int width, out int height, out int stride)
{
Verify.NotDisposed(this);
fixed(byte *jpegBufPtr = jpegBuf)
fixed(byte *outBufPtr = outBuf)
{
int subsampl;
int colorspace;
var funcResult = TurboJpegImport.TjDecompressHeader(
this.decompressorHandle,
jpegBufPtr,
(nuint)jpegBuf.Length,
out width,
out height,
out subsampl,
out colorspace);
TJUtils.ThrowOnError(funcResult);
var targetFormat = destPixelFormat;
stride = TurboJpegImport.TJPAD(width * TurboJpegImport.PixelSizes[targetFormat]);
var bufSize = stride * height;
if (outBuf.Length < bufSize)
{
throw new ArgumentOutOfRangeException(nameof(outBuf));
}
funcResult = TurboJpegImport.TjDecompress(
this.decompressorHandle,
jpegBufPtr,
(nuint)jpegBuf.Length,
outBufPtr,
width,
stride,
height,
(int)targetFormat,
(int)flags);
TJUtils.ThrowOnError(funcResult);
}
}
/// <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)
{
Verify.NotDisposed(this);
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)
{
TJUtils.ThrowOnError(
TurboJpegImport.TjDecodeYUVPlanes(
this.decompressorHandle,
planesPtr,
stridesPtr,
(int)subsamp,
(IntPtr)dstBufPtr,
width,
pitch,
height,
(int)pixelFormat,
(int)flags));
}
}
}
/// <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="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(Span <byte> jpegBuf, TJPixelFormat destPixelFormat, out int width, out int height, out int stride, out int bufSize)
{
Verify.NotDisposed(this);
int subsampl;
int colorspace;
fixed(byte *jpegBufPtr = jpegBuf)
{
var funcResult = TurboJpegImport.TjDecompressHeader(
this.decompressorHandle,
jpegBufPtr,
(nuint)jpegBuf.Length,
out width,
out height,
out subsampl,
out colorspace);
stride = TurboJpegImport.TJPAD(width * TurboJpegImport.PixelSizes[destPixelFormat]);
bufSize = stride * height;
}
}
/// <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>
/// 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)
{
Verify.NotDisposed(this);
return((int)TurboJpegImport.TjBufSize(width, height, (int)subSamp));
}
/// <summary>
/// Initializes a new instance of the <see cref="TJCompressor"/> class.
/// </summary>
/// <exception cref="TJException">
/// Throws if internal compressor instance can not be created.
/// </exception>
public TJCompressor()
{
this.compressorHandle = TurboJpegImport.TjInitCompress();
TJUtils.ThrowOnError(this.compressorHandle);
}
/// <summary> /// The plane height of a YUV image plane with the given parameters. /// </summary> /// <param name="componentID"> /// ID number of the image plane (0 = Y, 1 = U/Cb, 2 = V/Cr). /// </param> /// <param name="height"> /// Height (in pixels) of the YUV image. /// </param> /// <param name="subsamp"> /// Level of chrominance subsampling in the image. /// </param> /// <returns> /// The plane height of a YUV image plane with the given parameters, or /// -1 if the arguments are out of bounds. /// </returns> public int PlaneHeight(TJPlane componentID, int height, int subsamp) => TurboJpegImport.TjPlaneHeight(componentID, height, subsamp);
/// <summary> /// The plane width of a YUV image plane with the given parameters. /// </summary> /// <param name="componentID"> /// ID number of the image plane (0 = Y, 1 = U/Cb, 2 = V/Cr). /// </param> /// <param name="width"> /// width (in pixels) of the YUV image. /// </param> /// <param name="subsamp"> /// level of chrominance subsampling in the image. /// </param> /// <returns> /// The plane width of a YUV image plane with the given parameters, or /// -1 if the arguments are out of bounds. /// </returns> public int PlaneWidth(TJPlane componentID, int width, int subsamp) => TurboJpegImport.TjPlaneWidth(componentID, width, subsamp);
/// <summary> /// The size of the buffer (in bytes) required to hold a YUV image plane with /// the given parameters. /// </summary> /// <param name="componentID"> /// ID number of the image plane (0 = Y, 1 = U/Cb, 2 = V/Cr). /// </param> /// <param name="width"> /// width (in pixels) of the YUV image. NOTE: this is the width of /// the whole image, not the plane width. /// </param> /// <param name="stride"> /// bytes per line in the image plane. Setting this to 0 is the /// equivalent of setting it to the plane width. /// </param> /// <param name="height"> /// height (in pixels) of the YUV image. NOTE: this is the height /// of the whole image, not the plane height. /// </param> /// <param name="subsamp"> /// level of chrominance subsampling in the image. /// </param> /// <returns> /// the size of the buffer (in bytes) required to hold the YUV image /// plane, or -1 if the arguments are out of bounds. /// </returns> public nuint PlaneSizeYUV(TJPlane componentID, int width, int stride, int height, int subsamp) => TurboJpegImport.TjPlaneSizeYUV(componentID, width, stride, height, subsamp);
/// <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="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(Span <byte> jpegBuf, TJTransformDescription[] transforms, TJFlags flags)
{
Verify.NotDisposed(this);
if (transforms == null)
{
throw new ArgumentNullException(nameof(transforms));
}
if (transforms.Length == 0)
{
throw new ArgumentException("Transforms can not be empty", nameof(transforms));
}
fixed(byte *jpegBufPtr = jpegBuf)
{
var count = transforms.Length;
var destBufs = new IntPtr[count];
var destSizes = new uint[count];
int subsampl;
int colorspace;
int width;
int height;
var funcResult = TurboJpegImport.TjDecompressHeader(
this.transformHandle,
jpegBufPtr,
(nuint)jpegBuf.Length,
out width,
out height,
out subsampl,
out colorspace);
TJUtils.ThrowOnError(funcResult);
Size mcuSize;
if (!TurboJpegImport.MCUSizes.TryGetValue((TJSubsamplingOption)subsampl, out mcuSize))
{
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, mcuSize.Width);
var y = CorrectRegionCoordinate(transforms[i].Region.Y, mcuSize.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,
jpegBufPtr,
(nuint)jpegBuf.Length,
count,
destBufs,
destSizes,
transformsPtr,
(int)flags);
TJUtils.ThrowOnError(funcResult);
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>
/// Initializes a new instance of the <see cref="TJTransformer"/> class.
/// </summary>
/// <exception cref="TJException">
/// Throws if internal compressor instance can not be created.
/// </exception>
public TJTransformer()
{
this.transformHandle = TurboJpegImport.TjInitTransform();
TJUtils.ThrowOnError(this.transformHandle);
}
