示例#1
0
        private static extern int tjTransform_64(IntPtr handle, byte [] jpegBuf,
			ulong jpegSize, int n, IntPtr[] dstBufs, ulong [] dstSizes, Transform [] transforms, FunctionFlags flags);
示例#2
0
        /// <summary>
        /// Losslessly transform a JPEG image into another JPEG image.  Lossless
        /// transforms work by moving the raw coefficients from one JPEG image structure
        /// to another without altering the values of the coefficients.  While this is
        /// typically faster than decompressing the image, transforming it, and
        /// re-compressing it, lossless transforms are not free.  Each lossless
        /// transform requires reading and performing Huffman decoding on all of the
        /// coefficients in the source image, regardless of the size of the destination
        /// image.  Thus, this function provides a means of generating multiple
        /// transformed images from the same source or  applying multiple
        /// transformations simultaneously, in order to eliminate the need to read the
        /// source coefficients multiple times.
        /// </summary>
        /// <returns>An array of byte arrays containing the losslessly transformed JPEG images.</returns>
        /// <param name="jpegBuf">Buffer containing the JPEG image to transform.</param>
        /// <param name="transforms">An array of <see cref="Transform"/> structures, each of
        ///        which specifies the transform parameters and/or cropping region for
        ///        the corresponding transformed output image.</param>
        public byte[][] Transform(byte[] jpegBuf, Transform[] transforms)
        {
            if (jpegBuf == null)
                throw new ArgumentNullException(nameof (jpegBuf));
            if (transforms == null)
                throw new ArgumentNullException(nameof (transforms));

            IntPtr[] dstBufs = new IntPtr[transforms.Length];

            // Initialize all destination buffer pointers to NULL, to tell TurboJPEG to allocate the buffers for us
            for (int i = 0; i < dstBufs.Length; ++i)
            {
                dstBufs[i] = IntPtr.Zero;
            }

            uint[] dstSizes = new uint[transforms.Length];

            Library.tjTransform(_handle, jpegBuf, dstBufs, dstSizes, transforms, (FunctionFlags)0);

            byte[][] output = new byte[transforms.Length][];

            for (int i = 0; i < transforms.Length; ++i)
            {
                output[i] = new byte[dstSizes[i]];

                Marshal.Copy(dstBufs[i], output[i], 0, output[i].Length);
                Library.tjFree(dstBufs[i]);
                dstBufs[i] = IntPtr.Zero;
            }

            return output;
        }
示例#3
0
        /// <summary>
        /// Losslessly transform a JPEG image into another JPEG image.  Lossless
        /// transforms work by moving the raw coefficients from one JPEG image structure
        /// to another without altering the values of the coefficients.  While this is
        /// typically faster than decompressing the image, transforming it, and
        /// re-compressing it, lossless transforms are not free.  Each lossless
        /// transform requires reading and performing Huffman decoding on all of the
        /// coefficients in the source image, regardless of the size of the destination
        /// image.  Thus, this function provides a means of generating multiple
        /// transformed images from the same source or  applying multiple
        /// transformations simultaneously, in order to eliminate the need to read the
        /// source coefficients multiple times.
        /// </summary>
        /// <param name="handle">a handle to a TurboJPEG transformer instance.</param>
        /// <param name="jpegBuf">pointer to a buffer containing the JPEG image to transform</param>
        /// <param name="dstBufs">
        /// pointer to an array of <paramref name="n"/> image buffers.  <paramref name="dstBufs"/>[i]
        /// will receive a JPEG image that has been transformed using the
        /// parameters in <paramref name="transforms"/>[i].  TurboJPEG has the ability to
        /// reallocate the JPEG buffer to accommodate the size of the JPEG image.
        /// Thus, you can choose to:
        /// <list type="bullet">
        /// <item>
        /// <description>
        /// pre-allocate the JPEG buffer with an arbitrary size using
        /// <see cref="tjAlloc"/> and let TurboJPEG grow the buffer as needed,
        /// </description>
        /// </item>
        /// <item>
        /// <description>
        /// set <paramref name="dstBufs"/>[i] to NULL to tell TurboJPEG to allocate the
        /// buffer for you, or
        /// </description>
        /// </item>
        /// <item>
        /// <description>
        /// pre-allocate the buffer to a "worst case" size determined by
        /// calling <see cref="tjBufSize"/> with the transformed or cropped width and
        /// height.  This should ensure that the buffer never has to be
        /// re-allocated (setting <see cref="FunctionFlags.NoRealloc"/> guarantees this.)
        /// </description>
        /// </item>
        /// </list>
        /// If you choose option 1, <paramref name="dstSizes"/>[i] should be set to
        /// the size of your pre-allocated buffer.  In any case, unless you have set
        /// <see cref="FunctionFlags.NoRealloc"/>, you should always check <paramref name="dstBufs"/>[i]
        /// upon return from this function, as it may have changed.
        /// </param>
        /// <param name="dstSizes">
        /// pointer to an array of <paramref name="n"/> unsigned long variables that will
        /// receive the actual sizes (in bytes) of each transformed JPEG image.  If
        /// <paramref name="dstBufs"/>[i] points to a pre-allocated buffer, then
        /// <paramref name="dstSizes"/>[i] should be set to the size of the buffer.  Upon return,
        /// <paramref name="dstSizes"/>[i] will contain the size of the JPEG image (in bytes.)
        /// </param>
        /// <param name="transforms">
        /// pointer to an array of <paramref name="n"/> <see cref="Transform"/> structures, each of
        /// which specifies the transform parameters and/or cropping region for
        /// the corresponding transformed output image.
        /// </param>
        /// <param name="flags">the bitwise OR of one or more of the <see cref="FunctionFlags"/>.</param>
        /// <returns>0 if successful, or -1 if an error occurred (see <see cref="tjGetErrorStr"/>.)</returns>
        /// <remarks>
        /// Defined in turbojpeg.h as:
        /// 
        /// DLLEXPORT int DLLCALL tjTransform(tjhandle handle,
        ///   const unsigned char* jpegBuf, unsigned long jpegSize, int n,
        ///   unsigned char** dstBufs, unsigned long* dstSizes, tjtransform *transforms,
        ///   int flags);
        /// </remarks>
        internal static void tjTransform(IntPtr handle, byte [] jpegBuf, IntPtr[] dstBufs, uint [] dstSizes, Transform [] transforms, FunctionFlags flags)
        {
            int retval;

            if (IsLP64)
            {
                ulong [] dstSizes64 = new ulong [dstSizes.Length];
                dstSizes.CopyTo (dstSizes64, 0);

                retval = tjTransform_64 (handle, jpegBuf, (ulong)jpegBuf.Length, transforms.Length, dstBufs, dstSizes64, transforms, flags);

                for (int i = 0; i < dstSizes.Length; ++i)
                    dstSizes [i] = (uint)dstSizes64 [i];
            }
            else
                retval = tjTransform_32 (handle, jpegBuf, (uint)jpegBuf.Length, transforms.Length, dstBufs, dstSizes, transforms, flags);

            if (retval != 0)
                throw new TurboJPEGException ();
        }