dan/Cosmos
1
0
Fork 0
mirror of https://github.com/danbulant/Cosmos synced 2026-06-05 07:42:45 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
Cosmos/source2/Users/Orvid/Orvid.Graphics.Dependancies/Image Formats/BitMiracle/LibJpeg.cs

20230 lines
864 KiB
C#
Raw Blame History

/****************************************************************************
*
* LibJpeg.Net
* Copyright (c) 2008-2011, Bit Miracle
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the Bit Miracle nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS Software IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
* IS" AND Any EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BIT MIRACLE BE
* LIABLE FOR Any DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON Any THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN Any WAY OUT OF THE USE OF THIS Software, EVEN IF ADVISED OF
* THE POSSIBILITY OF SUCH DAMAGE.
****************************************************************************/
using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Drawing;
using System.Collections.ObjectModel;
namespace BitMiracle.LibJpeg
{
#region JpegImage
public sealed class JpegImage : IDisposable
{
private bool m_alreadyDisposed;
private List<SampleRow> m_rows = new List<SampleRow>();
private int m_width;
private int m_height;
private byte m_bitsPerComponent;
private byte m_componentsPerSample;
private ColorSpace m_colorspace;
private MemoryStream m_compressedData;
private CompressionParameters m_compressionParameters;
private MemoryStream m_decompressedData;
private Bitmap m_bitmap;
public JpegImage(System.Drawing.Bitmap bitmap)
{
createFromBitmap(bitmap);
}
public JpegImage(Stream imageData)
{
createFromStream(imageData);
}
public JpegImage(string fileName)
{
if (fileName == null)
throw new ArgumentNullException("fileName");
using (FileStream input = new FileStream(fileName, FileMode.Open))
createFromStream(input);
}
public JpegImage(SampleRow[] sampleData, ColorSpace colorspace)
{
if (sampleData == null)
throw new ArgumentNullException("sampleData");
if (sampleData.Length == 0)
throw new ArgumentException("sampleData must not be empty");
if (colorspace == ColorSpace.Unknown)
throw new ArgumentException("Unknown colorspace");
m_rows = new List<SampleRow>(sampleData);
SampleRow firstRow = m_rows[0];
m_width = firstRow.Length;
m_height = m_rows.Count;
Sample firstSample = firstRow[0];
m_bitsPerComponent = firstSample.BitsPerComponent;
m_componentsPerSample = firstSample.ComponentCount;
m_colorspace = colorspace;
}
public static JpegImage FromBitmap(Bitmap bitmap)
{
return new JpegImage(bitmap);
}
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
private void Dispose(bool disposing)
{
if (!m_alreadyDisposed)
{
if (disposing)
{
if (m_compressedData != null)
m_compressedData.Dispose();
if (m_decompressedData != null)
m_decompressedData.Dispose();
if (m_bitmap != null)
m_bitmap.Dispose();
}
m_compressionParameters = null;
m_compressedData = null;
m_decompressedData = null;
m_bitmap = null;
m_rows = null;
m_alreadyDisposed = true;
}
}
public int Width
{
get
{
return m_width;
}
internal set
{
m_width = value;
}
}
public int Height
{
get
{
return m_height;
}
internal set
{
m_height = value;
}
}
public byte ComponentsPerSample
{
get
{
return m_componentsPerSample;
}
internal set
{
m_componentsPerSample = value;
}
}
public byte BitsPerComponent
{
get
{
return m_bitsPerComponent;
}
internal set
{
m_bitsPerComponent = value;
}
}
public ColorSpace Colorspace
{
get
{
return m_colorspace;
}
internal set
{
m_colorspace = value;
}
}
public SampleRow GetRow(int rowNumber)
{
return m_rows[rowNumber];
}
public void WriteJpeg(Stream output)
{
WriteJpeg(output, new CompressionParameters());
}
public void WriteJpeg(Stream output, CompressionParameters parameters)
{
compress(parameters);
compressedData.WriteTo(output);
}
public void WriteBitmap(Stream output)
{
decompressedData.WriteTo(output);
}
public Bitmap ToBitmap()
{
return bitmap.Clone() as Bitmap;
}
private MemoryStream compressedData
{
get
{
if (m_compressedData == null)
compress(new CompressionParameters());
return m_compressedData;
}
}
private MemoryStream decompressedData
{
get
{
if (m_decompressedData == null)
fillDecompressedData();
return m_decompressedData;
}
}
private Bitmap bitmap
{
get
{
if (m_bitmap == null)
{
long position = compressedData.Position;
m_bitmap = new Bitmap(compressedData);
compressedData.Seek(position, SeekOrigin.Begin);
}
return m_bitmap;
}
}
internal void addSampleRow(SampleRow row)
{
if (row == null)
throw new ArgumentNullException("row");
m_rows.Add(row);
}
private static bool isCompressed(Stream imageData)
{
if (imageData == null)
return false;
if (imageData.Length <= 2)
return false;
imageData.Seek(0, SeekOrigin.Begin);
int first = imageData.ReadByte();
int second = imageData.ReadByte();
return (first == 0xFF && second == (int)JpegMarkerType.SOI);
}
private void createFromBitmap(Bitmap bitmap)
{
initializeFromBitmap(bitmap);
compress(new CompressionParameters());
}
private void createFromStream(Stream imageData)
{
if (imageData == null)
throw new ArgumentNullException("imageData");
if (isCompressed(imageData))
{
m_compressedData = Utils.CopyStream(imageData);
decompress();
}
else
{
createFromBitmap(new Bitmap(imageData));
}
}
private void initializeFromBitmap(Bitmap bitmap)
{
if (bitmap == null)
throw new ArgumentNullException("bitmap");
m_bitmap = bitmap;
m_width = m_bitmap.Width;
m_height = m_bitmap.Height;
processPixelFormat(bitmap.PixelFormat);
fillSamplesFromBitmap();
}
private void compress(CompressionParameters parameters)
{
if (m_rows == null)
throw new Exception("'m_rows' Cannot be null!");
if (m_rows.Count == 0)
throw new ArgumentException("'m_rows' Cannot be empty!");
RawImage source = new RawImage(m_rows, m_colorspace);
compress(source, parameters);
}
private void compress(IRawImage source, CompressionParameters parameters)
{
if (source == null)
throw new ArgumentNullException("'source' Cannot be null!");
if (!needCompressWith(parameters))
return;
m_compressedData = new MemoryStream();
m_compressionParameters = new CompressionParameters(parameters);
Jpeg jpeg = new Jpeg();
jpeg.CompressionParameters = m_compressionParameters;
jpeg.Compress(source, m_compressedData);
}
private bool needCompressWith(CompressionParameters parameters)
{
return m_compressedData == null ||
m_compressionParameters == null ||
!m_compressionParameters.Equals(parameters);
}
private void decompress()
{
Jpeg jpeg = new Jpeg();
jpeg.Decompress(compressedData, new DecompressorToJpegImage(this));
}
private void fillDecompressedData()
{
if (m_decompressedData != null)
throw new Exception("'m_decompressedData' Is not null!");
m_decompressedData = new MemoryStream();
BitmapDestination dest = new BitmapDestination(m_decompressedData);
Jpeg jpeg = new Jpeg();
jpeg.Decompress(compressedData, dest);
}
private void processPixelFormat(System.Drawing.Imaging.PixelFormat pixelFormat)
{
if (pixelFormat == System.Drawing.Imaging.PixelFormat.Format16bppGrayScale)
{
m_bitsPerComponent = 16;
m_componentsPerSample = 1;
m_colorspace = ColorSpace.Grayscale;
return;
}
byte formatIndexByte = (byte)((int)pixelFormat & 0x000000FF);
byte pixelSizeByte = (byte)((int)pixelFormat & 0x0000FF00);
if (pixelSizeByte == 32 && formatIndexByte == 15)
{
m_bitsPerComponent = 8;
m_componentsPerSample = 4;
m_colorspace = ColorSpace.CMYK;
return;
}
m_bitsPerComponent = 8;
m_componentsPerSample = 3;
m_colorspace = ColorSpace.RGB;
if (pixelSizeByte == 16)
m_bitsPerComponent = 6;
else if (pixelSizeByte == 24 || pixelSizeByte == 32)
m_bitsPerComponent = 8;
else if (pixelSizeByte == 48 || pixelSizeByte == 64)
m_bitsPerComponent = 16;
}
private void fillSamplesFromBitmap()
{
if (m_bitmap == null)
throw new Exception("Field 'm_bitmap' Cannot be null!");
for (int y = 0; y < Height; ++y)
{
short[] samples = new short[Width * 3];
for (int x = 0; x < Width; ++x)
{
Color color = m_bitmap.GetPixel(x, y);
samples[x * 3] = color.R;
samples[x * 3 + 1] = color.G;
samples[x * 3 + 2] = color.B;
}
m_rows.Add(new SampleRow(samples, m_bitsPerComponent, m_componentsPerSample));
}
}
}
#endregion
#region BitmapDestination
class BitmapDestination : IDecompressor
{
private Stream m_output;
private byte[][] m_pixels;
private int m_rowWidth;
private int m_currentRow;
private LoadedImageAttributes m_parameters;
public BitmapDestination(Stream output)
{
m_output = output;
}
public override Stream Output
{
get
{
return m_output;
}
}
public override void SetImageAttributes(LoadedImageAttributes parameters)
{
if (parameters == null)
throw new ArgumentNullException("parameters");
m_parameters = parameters;
}
public override void BeginWrite()
{
m_rowWidth = m_parameters.Width * m_parameters.Components;
while (m_rowWidth % 4 != 0)
m_rowWidth++;
m_pixels = new byte[m_rowWidth][];
for (int i = 0; i < m_rowWidth; i++)
m_pixels[i] = new byte[m_parameters.Height];
m_currentRow = 0;
}
public override void ProcessPixelsRow(byte[] row)
{
if (m_parameters.Colorspace == ColorSpace.Grayscale || m_parameters.QuantizeColors)
{
putGrayRow(row);
}
else
{
if (m_parameters.Colorspace == ColorSpace.CMYK)
putCmykRow(row);
else
putRgbRow(row);
}
++m_currentRow;
}
public override void EndWrite()
{
writeHeader();
writePixels();
m_output.Flush();
}
private void putGrayRow(byte[] row)
{
for (int i = 0; i < m_parameters.Width; ++i)
m_pixels[i][m_currentRow] = row[i];
}
private void putRgbRow(byte[] row)
{
for (int i = 0; i < m_parameters.Width; ++i)
{
int firstComponent = i * 3;
byte red = row[firstComponent];
byte green = row[firstComponent + 1];
byte blue = row[firstComponent + 2];
m_pixels[firstComponent][m_currentRow] = blue;
m_pixels[firstComponent + 1][m_currentRow] = green;
m_pixels[firstComponent + 2][m_currentRow] = red;
}
}
private void putCmykRow(byte[] row)
{
for (int i = 0; i < m_parameters.Width; ++i)
{
int firstComponent = i * 4;
m_pixels[firstComponent][m_currentRow] = row[firstComponent + 2];
m_pixels[firstComponent + 1][m_currentRow] = row[firstComponent + 1];
m_pixels[firstComponent + 2][m_currentRow] = row[firstComponent + 0];
m_pixels[firstComponent + 3][m_currentRow] = row[firstComponent + 3];
}
}
private void writeHeader()
{
int bits_per_pixel;
int cmap_entries;
if (m_parameters.Colorspace == ColorSpace.Grayscale || m_parameters.QuantizeColors)
{
bits_per_pixel = 8;
cmap_entries = 256;
}
else
{
cmap_entries = 0;
if (m_parameters.Colorspace == ColorSpace.RGB)
bits_per_pixel = 24;
else if (m_parameters.Colorspace == ColorSpace.CMYK)
bits_per_pixel = 32;
else
throw new InvalidOperationException();
}
byte[] infoHeader = null;
if (m_parameters.Colorspace == ColorSpace.RGB)
infoHeader = createBitmapInfoHeader(bits_per_pixel, cmap_entries);
else
infoHeader = createBitmapV4InfoHeader(bits_per_pixel);
const int fileHeaderSize = 14;
int infoHeaderSize = infoHeader.Length;
int paletteSize = cmap_entries * 4;
int offsetToPixels = fileHeaderSize + infoHeaderSize + paletteSize;
int fileSize = offsetToPixels + m_rowWidth * m_parameters.Height;
byte[] fileHeader = createBitmapFileHeader(offsetToPixels, fileSize);
m_output.Write(fileHeader, 0, fileHeader.Length);
m_output.Write(infoHeader, 0, infoHeader.Length);
if (cmap_entries > 0)
writeColormap(cmap_entries, 4);
}
private static byte[] createBitmapFileHeader(int offsetToPixels, int fileSize)
{
byte[] bmpfileheader = new byte[14];
bmpfileheader[0] = 0x42;
bmpfileheader[1] = 0x4D;
PUT_4B(bmpfileheader, 2, fileSize);
PUT_4B(bmpfileheader, 10, offsetToPixels);
return bmpfileheader;
}
private byte[] createBitmapInfoHeader(int bits_per_pixel, int cmap_entries)
{
byte[] bmpinfoheader = new byte[40];
fillBitmapInfoHeader(bits_per_pixel, cmap_entries, bmpinfoheader);
return bmpinfoheader;
}
private void fillBitmapInfoHeader(int bitsPerPixel, int cmap_entries, byte[] infoHeader)
{
PUT_2B(infoHeader, 0, infoHeader.Length);
PUT_4B(infoHeader, 4, m_parameters.Width);
PUT_4B(infoHeader, 8, m_parameters.Height);
PUT_2B(infoHeader, 12, 1);
PUT_2B(infoHeader, 14, bitsPerPixel);
if (m_parameters.DensityUnit == DensityUnit.DotsCm)
{
PUT_4B(infoHeader, 24, m_parameters.DensityX * 100);
PUT_4B(infoHeader, 28, m_parameters.DensityY * 100);
}
PUT_2B(infoHeader, 32, cmap_entries);
}
private byte[] createBitmapV4InfoHeader(int bitsPerPixel)
{
byte[] infoHeader = new byte[40 + 68];
fillBitmapInfoHeader(bitsPerPixel, 0, infoHeader);
PUT_4B(infoHeader, 56, 0x02);
return infoHeader;
}
private void writeColormap(int map_colors, int map_entry_size)
{
byte[][] colormap = m_parameters.Colormap;
int num_colors = m_parameters.ActualNumberOfColors;
int i = 0;
if (colormap != null)
{
if (m_parameters.ComponentsPerSample == 3)
{
for (i = 0; i < num_colors; i++)
{
m_output.WriteByte(colormap[2][i]);
m_output.WriteByte(colormap[1][i]);
m_output.WriteByte(colormap[0][i]);
if (map_entry_size == 4)
m_output.WriteByte(0);
}
}
else
{
for (i = 0; i < num_colors; i++)
{
m_output.WriteByte(colormap[0][i]);
m_output.WriteByte(colormap[0][i]);
m_output.WriteByte(colormap[0][i]);
if (map_entry_size == 4)
m_output.WriteByte(0);
}
}
}
else
{
for (i = 0; i < 256; i++)
{
m_output.WriteByte((byte)i);
m_output.WriteByte((byte)i);
m_output.WriteByte((byte)i);
if (map_entry_size == 4)
m_output.WriteByte(0);
}
}
if (i > map_colors)
throw new InvalidOperationException("Too many colors");
for (; i < map_colors; i++)
{
m_output.WriteByte(0);
m_output.WriteByte(0);
m_output.WriteByte(0);
if (map_entry_size == 4)
m_output.WriteByte(0);
}
}
private void writePixels()
{
for (int row = m_parameters.Height - 1; row >= 0; --row)
for (int col = 0; col < m_rowWidth; ++col)
m_output.WriteByte(m_pixels[col][row]);
}
private static void PUT_2B(byte[] array, int offset, int value)
{
array[offset] = (byte)((value) & 0xFF);
array[offset + 1] = (byte)(((value) >> 8) & 0xFF);
}
private static void PUT_4B(byte[] array, int offset, int value)
{
array[offset] = (byte)((value) & 0xFF);
array[offset + 1] = (byte)(((value) >> 8) & 0xFF);
array[offset + 2] = (byte)(((value) >> 16) & 0xFF);
array[offset + 3] = (byte)(((value) >> 24) & 0xFF);
}
}
#endregion
#region BitStream
class BitStream : IDisposable
{
private bool m_alreadyDisposed;
private const int bitsInByte = 8;
private Stream m_stream;
private int m_positionInByte;
private int m_size;
public BitStream()
{
m_stream = new MemoryStream();
}
public BitStream(byte[] buffer)
{
if (buffer == null)
throw new ArgumentNullException("buffer");
m_stream = new MemoryStream(buffer);
m_size = bitsAllocated();
}
public void Dispose()
{
this.Dispose(true);
GC.SuppressFinalize(this);
}
protected virtual void Dispose(bool disposing)
{
if (!m_alreadyDisposed)
{
if (disposing)
{
if (m_stream != null)
m_stream.Dispose();
}
m_stream = null;
m_alreadyDisposed = true;
}
}
public int Size()
{
return m_size;
}
public Stream UnderlyingStream
{
get
{
return m_stream;
}
}
public virtual int Read(int bitCount)
{
if (Tell() + bitCount > bitsAllocated())
throw new ArgumentOutOfRangeException("bitCount");
return read(bitCount);
}
public int Write(int bitStorage, int bitCount)
{
if (bitCount == 0)
return 0;
const int maxBitsInStorage = sizeof(int) * bitsInByte;
if (bitCount > maxBitsInStorage)
throw new ArgumentOutOfRangeException("bitCount");
for (int i = 0; i < bitCount; ++i)
{
byte bit = (byte)((bitStorage << (maxBitsInStorage - (bitCount - i))) >> (maxBitsInStorage - 1));
if (!writeBit(bit))
return i;
}
return bitCount;
}
public void Seek(int pos, SeekOrigin mode)
{
switch (mode)
{
case SeekOrigin.Begin:
seekSet(pos);
break;
case SeekOrigin.Current:
seekCurrent(pos);
break;
case SeekOrigin.End:
seekSet(Size() + pos);
break;
}
}
public int Tell()
{
return (int)m_stream.Position * bitsInByte + m_positionInByte;
}
private int bitsAllocated()
{
return (int)m_stream.Length * bitsInByte;
}
private int read(int bitsCount)
{
if (bitsCount < 0 || bitsCount > 32)
throw new ArgumentOutOfRangeException("bitsCount");
if (bitsCount == 0)
return 0;
int bitsRead = 0;
int result = 0;
byte[] bt = new byte[1];
while (bitsRead == 0 || (bitsRead - m_positionInByte < bitsCount))
{
m_stream.Read(bt, 0, 1);
result = (result << bitsInByte);
result += bt[0];
bitsRead += 8;
}
m_positionInByte = (m_positionInByte + bitsCount) % 8;
if (m_positionInByte != 0)
{
result = (result >> (bitsInByte - m_positionInByte));
m_stream.Seek(-1, SeekOrigin.Current);
}
if (bitsCount < 32)
{
int mask = ((1 << bitsCount) - 1);
result = result & mask;
}
return result;
}
private bool writeBit(byte bit)
{
if (m_stream.Position == m_stream.Length)
{
byte[] bt = { (byte)(bit << (bitsInByte - 1)) };
m_stream.Write(bt, 0, 1);
m_stream.Seek(-1, SeekOrigin.Current);
}
else
{
byte[] bt = { 0 };
m_stream.Read(bt, 0, 1);
m_stream.Seek(-1, SeekOrigin.Current);
int shift = (bitsInByte - m_positionInByte - 1) % bitsInByte;
byte maskByte = (byte)(bit << shift);
bt[0] |= maskByte;
m_stream.Write(bt, 0, 1);
m_stream.Seek(-1, SeekOrigin.Current);
}
Seek(1, SeekOrigin.Current);
int currentPosition = Tell();
if (currentPosition > m_size)
m_size = currentPosition;
return true;
}
private void seekSet(int pos)
{
if (pos < 0)
throw new ArgumentOutOfRangeException("pos");
int byteDisplacement = pos / bitsInByte;
m_stream.Seek(byteDisplacement, SeekOrigin.Begin);
int shiftInByte = pos - byteDisplacement * bitsInByte;
m_positionInByte = shiftInByte;
}
private void seekCurrent(int pos)
{
int result = Tell() + pos;
if (result < 0 || result > bitsAllocated())
throw new ArgumentOutOfRangeException("pos");
seekSet(result);
}
}
#endregion
#region CoefControllerImpl
class CoefControllerImpl : JpegCompressorCoefController
{
private BufferMode m_passModeSetByLastStartPass;
private JpegCompressor m_cinfo;
private int m_iMCU_row_num;
private int m_mcu_ctr;
private int m_MCU_vert_offset;
private int m_MCU_rows_per_iMCU_row;
private JpegBlock[][] m_MCU_buffer = new JpegBlock[JpegConstants.CompressorMaxBlocksInMCU][];
private JpegVirtualArray<JpegBlock>[] m_whole_image = new JpegVirtualArray<JpegBlock>[JpegConstants.MaxComponents];
public CoefControllerImpl(JpegCompressor cinfo, bool need_full_buffer)
{
m_cinfo = cinfo;
if (need_full_buffer)
{
for (int ci = 0; ci < cinfo.m_num_components; ci++)
{
m_whole_image[ci] = JpegCommonBase.CreateBlocksArray(
JpegUtils.jround_up(cinfo.Component_info[ci].Width_in_blocks, cinfo.Component_info[ci].H_samp_factor),
JpegUtils.jround_up(cinfo.Component_info[ci].height_in_blocks, cinfo.Component_info[ci].V_samp_factor));
m_whole_image[ci].ErrorProcessor = cinfo;
}
}
else
{
JpegBlock[] buffer = new JpegBlock[JpegConstants.CompressorMaxBlocksInMCU];
for (int i = 0; i < JpegConstants.CompressorMaxBlocksInMCU; i++)
buffer[i] = new JpegBlock();
for (int i = 0; i < JpegConstants.CompressorMaxBlocksInMCU; i++)
{
m_MCU_buffer[i] = new JpegBlock[JpegConstants.CompressorMaxBlocksInMCU - i];
for (int j = i; j < JpegConstants.CompressorMaxBlocksInMCU; j++)
m_MCU_buffer[i][j - i] = buffer[j];
}
m_whole_image[0] = null;
}
}
public virtual void start_pass(BufferMode pass_mode)
{
m_iMCU_row_num = 0;
start_iMCU_row();
switch (pass_mode)
{
case BufferMode.PassThru:
if (m_whole_image[0] != null)
throw new Exception("Bogus buffer control mode");
break;
case BufferMode.SaveAndPass:
if (m_whole_image[0] == null)
throw new Exception("Bogus buffer control mode");
break;
case BufferMode.CrankDest:
if (m_whole_image[0] == null)
throw new Exception("Bogus buffer control mode");
break;
default:
throw new Exception("Bogus buffer control mode");
}
m_passModeSetByLastStartPass = pass_mode;
}
public virtual bool compress_data(byte[][][] input_buf)
{
switch (m_passModeSetByLastStartPass)
{
case BufferMode.PassThru:
return compressDataImpl(input_buf);
case BufferMode.SaveAndPass:
return compressFirstPass(input_buf);
case BufferMode.CrankDest:
return compressOutput();
}
return false;
}
private bool compressDataImpl(byte[][][] input_buf)
{
int last_MCU_col = m_cinfo.m_MCUs_per_row - 1;
int last_iMCU_row = m_cinfo.m_total_iMCU_rows - 1;
for (int yoffset = m_MCU_vert_offset; yoffset < m_MCU_rows_per_iMCU_row; yoffset++)
{
for (int MCU_col_num = m_mcu_ctr; MCU_col_num <= last_MCU_col; MCU_col_num++)
{
int blkn = 0;
for (int ci = 0; ci < m_cinfo.m_comps_in_scan; ci++)
{
JpegComponent componentInfo = m_cinfo.Component_info[m_cinfo.m_cur_comp_info[ci]];
int blockcnt = (MCU_col_num < last_MCU_col) ? componentInfo.MCU_width : componentInfo.last_col_width;
int xpos = MCU_col_num * componentInfo.MCU_sample_width;
int ypos = yoffset * JpegConstants.DCTSize;
for (int yindex = 0; yindex < componentInfo.MCU_height; yindex++)
{
if (m_iMCU_row_num < last_iMCU_row || yoffset + yindex < componentInfo.last_row_height)
{
m_cinfo.m_fdct.forward_DCT(componentInfo.Quant_tbl_no, input_buf[componentInfo.Component_index],
m_MCU_buffer[blkn], ypos, xpos, blockcnt);
if (blockcnt < componentInfo.MCU_width)
{
for (int i = 0; i < (componentInfo.MCU_width - blockcnt); i++)
Array.Clear(m_MCU_buffer[blkn + blockcnt][i].data, 0, m_MCU_buffer[blkn + blockcnt][i].data.Length);
for (int bi = blockcnt; bi < componentInfo.MCU_width; bi++)
m_MCU_buffer[blkn + bi][0][0] = m_MCU_buffer[blkn + bi - 1][0][0];
}
}
else
{
for (int i = 0; i < componentInfo.MCU_width; i++)
Array.Clear(m_MCU_buffer[blkn][i].data, 0, m_MCU_buffer[blkn][i].data.Length);
for (int bi = 0; bi < componentInfo.MCU_width; bi++)
m_MCU_buffer[blkn + bi][0][0] = m_MCU_buffer[blkn - 1][0][0];
}
blkn += componentInfo.MCU_width;
ypos += JpegConstants.DCTSize;
}
}
if (!m_cinfo.m_entropy.encode_mcu(m_MCU_buffer))
{
m_MCU_vert_offset = yoffset;
m_mcu_ctr = MCU_col_num;
return false;
}
}
m_mcu_ctr = 0;
}
m_iMCU_row_num++;
start_iMCU_row();
return true;
}
private bool compressFirstPass(byte[][][] input_buf)
{
int last_iMCU_row = m_cinfo.m_total_iMCU_rows - 1;
for (int ci = 0; ci < m_cinfo.m_num_components; ci++)
{
JpegComponent componentInfo = m_cinfo.Component_info[ci];
JpegBlock[][] buffer = m_whole_image[ci].Access(m_iMCU_row_num * componentInfo.V_samp_factor, componentInfo.V_samp_factor);
int block_rows;
if (m_iMCU_row_num < last_iMCU_row)
{
block_rows = componentInfo.V_samp_factor;
}
else
{
block_rows = componentInfo.height_in_blocks % componentInfo.V_samp_factor;
if (block_rows == 0)
block_rows = componentInfo.V_samp_factor;
}
int blocks_across = componentInfo.Width_in_blocks;
int h_samp_factor = componentInfo.H_samp_factor;
int ndummy = blocks_across % h_samp_factor;
if (ndummy > 0)
ndummy = h_samp_factor - ndummy;
for (int block_row = 0; block_row < block_rows; block_row++)
{
m_cinfo.m_fdct.forward_DCT(componentInfo.Quant_tbl_no, input_buf[ci],
buffer[block_row], block_row * JpegConstants.DCTSize, 0, blocks_across);
if (ndummy > 0)
{
Array.Clear(buffer[block_row][blocks_across].data, 0, buffer[block_row][blocks_across].data.Length);
short lastDC = buffer[block_row][blocks_across - 1][0];
for (int bi = 0; bi < ndummy; bi++)
buffer[block_row][blocks_across + bi][0] = lastDC;
}
}
if (m_iMCU_row_num == last_iMCU_row)
{
blocks_across += ndummy;
int MCUs_across = blocks_across / h_samp_factor;
for (int block_row = block_rows; block_row < componentInfo.V_samp_factor; block_row++)
{
for (int i = 0; i < blocks_across; i++)
Array.Clear(buffer[block_row][i].data, 0, buffer[block_row][i].data.Length);
int thisOffset = 0;
int lastOffset = 0;
for (int MCUindex = 0; MCUindex < MCUs_across; MCUindex++)
{
short lastDC = buffer[block_row - 1][lastOffset + h_samp_factor - 1][0];
for (int bi = 0; bi < h_samp_factor; bi++)
buffer[block_row][thisOffset + bi][0] = lastDC;
thisOffset += h_samp_factor;
lastOffset += h_samp_factor;
}
}
}
}
return compressOutput();
}
private bool compressOutput()
{
JpegBlock[][][] buffer = new JpegBlock[JpegConstants.MaxComponentsInScan][][];
for (int ci = 0; ci < m_cinfo.m_comps_in_scan; ci++)
{
JpegComponent componentInfo = m_cinfo.Component_info[m_cinfo.m_cur_comp_info[ci]];
buffer[ci] = m_whole_image[componentInfo.Component_index].Access(
m_iMCU_row_num * componentInfo.V_samp_factor, componentInfo.V_samp_factor);
}
for (int yoffset = m_MCU_vert_offset; yoffset < m_MCU_rows_per_iMCU_row; yoffset++)
{
for (int MCU_col_num = m_mcu_ctr; MCU_col_num < m_cinfo.m_MCUs_per_row; MCU_col_num++)
{
int blkn = 0;
for (int ci = 0; ci < m_cinfo.m_comps_in_scan; ci++)
{
JpegComponent componentInfo = m_cinfo.Component_info[m_cinfo.m_cur_comp_info[ci]];
int start_col = MCU_col_num * componentInfo.MCU_width;
for (int yindex = 0; yindex < componentInfo.MCU_height; yindex++)
{
for (int xindex = 0; xindex < componentInfo.MCU_width; xindex++)
{
int bufLength = buffer[ci][yindex + yoffset].Length;
int start = start_col + xindex;
m_MCU_buffer[blkn] = new JpegBlock[bufLength - start];
for (int j = start; j < bufLength; j++)
m_MCU_buffer[blkn][j - start] = buffer[ci][yindex + yoffset][j];
blkn++;
}
}
}
if (!m_cinfo.m_entropy.encode_mcu(m_MCU_buffer))
{
m_MCU_vert_offset = yoffset;
m_mcu_ctr = MCU_col_num;
return false;
}
}
m_mcu_ctr = 0;
}
m_iMCU_row_num++;
start_iMCU_row();
return true;
}
private void start_iMCU_row()
{
if (m_cinfo.m_comps_in_scan > 1)
{
m_MCU_rows_per_iMCU_row = 1;
}
else
{
if (m_iMCU_row_num < (m_cinfo.m_total_iMCU_rows - 1))
m_MCU_rows_per_iMCU_row = m_cinfo.Component_info[m_cinfo.m_cur_comp_info[0]].V_samp_factor;
else
m_MCU_rows_per_iMCU_row = m_cinfo.Component_info[m_cinfo.m_cur_comp_info[0]].last_row_height;
}
m_mcu_ctr = 0;
m_MCU_vert_offset = 0;
}
}
#endregion
#region ColorConverter
class ColorConverter
{
private const int SCALEBITS = 16;
private const int CBCR_OFFSET = JpegConstants.MediumSampleValue << SCALEBITS;
private const int ONE_HALF = 1 << (SCALEBITS - 1);
private const int R_Y_OFF = 0;
private const int G_Y_OFF = (1 * (JpegConstants.MaxSampleValue + 1));
private const int B_Y_OFF = (2 * (JpegConstants.MaxSampleValue + 1));
private const int R_CB_OFF = (3 * (JpegConstants.MaxSampleValue + 1));
private const int G_CB_OFF = (4 * (JpegConstants.MaxSampleValue + 1));
private const int B_CB_OFF = (5 * (JpegConstants.MaxSampleValue + 1));
private const int R_CR_OFF = B_CB_OFF;
private const int G_CR_OFF = (6 * (JpegConstants.MaxSampleValue + 1));
private const int B_CR_OFF = (7 * (JpegConstants.MaxSampleValue + 1));
private const int TABLE_SIZE = (8 * (JpegConstants.MaxSampleValue + 1));
private JpegCompressor m_cinfo;
private bool m_useNullStart;
private bool m_useCmykYcckConvert;
private bool m_useGrayscaleConvert;
private bool m_useNullConvert;
private bool m_useRgbGrayConvert;
private bool m_useRgbYccConvert;
private int[] m_rgb_ycc_tab;
public ColorConverter(JpegCompressor cinfo)
{
m_cinfo = cinfo;
m_useNullStart = true;
switch (cinfo.m_in_color_space)
{
case ColorSpace.Grayscale:
if (cinfo.m_input_components != 1)
throw new Exception("Bogus input colorspace!");
break;
case ColorSpace.RGB:
case ColorSpace.YCbCr:
if (cinfo.m_input_components != 3)
throw new Exception("Bogus input colorspace!");
break;
case ColorSpace.CMYK:
case ColorSpace.YCCK:
if (cinfo.m_input_components != 4)
throw new Exception("Bogus input colorspace!");
break;
default:
if (cinfo.m_input_components < 1)
throw new Exception("Bogus input colorspace!");
break;
}
clearConvertFlags();
switch (cinfo.m_jpeg_color_space)
{
case ColorSpace.Grayscale:
{
if (cinfo.m_num_components != 1)
throw new Exception("Bogus Jpeg colorspace!");
if (cinfo.m_in_color_space == ColorSpace.Grayscale)
{
m_useGrayscaleConvert = true;
}
else if (cinfo.m_in_color_space == ColorSpace.RGB)
{
m_useNullStart = false;
m_useRgbGrayConvert = true;
}
else if (cinfo.m_in_color_space == ColorSpace.YCbCr)
{
m_useGrayscaleConvert = true;
}
else
{
throw new Exception("Unsupported color conversion request.");
}
break;
}
case ColorSpace.RGB:
{
if (cinfo.m_num_components != 3)
throw new Exception("Bogus Jpeg colorspace!");
if (cinfo.m_in_color_space == ColorSpace.RGB)
{
m_useNullConvert = true;
}
else
{
throw new Exception("Unsupported color conversion request.");
}
break;
}
case ColorSpace.YCbCr:
{
if (cinfo.m_num_components != 3)
throw new Exception("Bogus Jpeg colorspace!");
if (cinfo.m_in_color_space == ColorSpace.RGB)
{
m_useNullStart = false;
m_useRgbYccConvert = true;
}
else if (cinfo.m_in_color_space == ColorSpace.YCbCr)
{
m_useNullConvert = true;
}
else
{
throw new Exception("Unsupported color conversion request.");
}
break;
}
case ColorSpace.CMYK:
{
if (cinfo.m_num_components != 4)
throw new Exception("Bogus Jpeg colorspace!");
if (cinfo.m_in_color_space == ColorSpace.CMYK)
{
m_useNullConvert = true;
}
else
{
throw new Exception("Unsupported color conversion request.");
}
break;
}
case ColorSpace.YCCK:
{
if (cinfo.m_num_components != 4)
throw new Exception("Bogus Jpeg colorspace!");
if (cinfo.m_in_color_space == ColorSpace.CMYK)
{
m_useNullStart = false;
m_useCmykYcckConvert = true;
}
else if (cinfo.m_in_color_space == ColorSpace.YCCK)
{
m_useNullConvert = true;
}
else
{
throw new Exception("Unsupported color conversion request.");
}
break;
}
default:
if (cinfo.m_jpeg_color_space != cinfo.m_in_color_space || cinfo.m_num_components != cinfo.m_input_components)
throw new Exception("Unsupported color conversion request.");
m_useNullConvert = true;
break;
}
}
public void start_pass()
{
if (!m_useNullStart)
rgb_ycc_start();
}
public void color_convert(byte[][] input_buf, int input_row, byte[][][] output_buf, int output_row, int num_rows)
{
if (m_useCmykYcckConvert)
cmyk_ycck_convert(input_buf, input_row, output_buf, output_row, num_rows);
else if (m_useGrayscaleConvert)
grayscale_convert(input_buf, input_row, output_buf, output_row, num_rows);
else if (m_useRgbGrayConvert)
rgb_gray_convert(input_buf, input_row, output_buf, output_row, num_rows);
else if (m_useRgbYccConvert)
rgb_ycc_convert(input_buf, input_row, output_buf, output_row, num_rows);
else if (m_useNullConvert)
null_convert(input_buf, input_row, output_buf, output_row, num_rows);
else
throw new Exception("Unsupported color conversion request.");
}
private void clearConvertFlags()
{
m_useCmykYcckConvert = false;
m_useGrayscaleConvert = false;
m_useNullConvert = false;
m_useRgbGrayConvert = false;
m_useRgbYccConvert = false;
}
private static int FIX(double x)
{
return (int)(x * (1L << SCALEBITS) + 0.5);
}
#region RGB to YCC
private void rgb_ycc_start()
{
m_rgb_ycc_tab = new int[TABLE_SIZE];
for (int i = 0; i <= JpegConstants.MaxSampleValue; i++)
{
m_rgb_ycc_tab[i + R_Y_OFF] = FIX(0.29900) * i;
m_rgb_ycc_tab[i + G_Y_OFF] = FIX(0.58700) * i;
m_rgb_ycc_tab[i + B_Y_OFF] = FIX(0.11400) * i + ONE_HALF;
m_rgb_ycc_tab[i + R_CB_OFF] = (-FIX(0.16874)) * i;
m_rgb_ycc_tab[i + G_CB_OFF] = (-FIX(0.33126)) * i;
m_rgb_ycc_tab[i + B_CB_OFF] = FIX(0.50000) * i + CBCR_OFFSET + ONE_HALF - 1;
m_rgb_ycc_tab[i + G_CR_OFF] = (-FIX(0.41869)) * i;
m_rgb_ycc_tab[i + B_CR_OFF] = (-FIX(0.08131)) * i;
}
}
private void rgb_ycc_convert(byte[][] input_buf, int input_row, byte[][][] output_buf, int output_row, int num_rows)
{
int num_cols = m_cinfo.m_image_width;
for (int row = 0; row < num_rows; row++)
{
int columnOffset = 0;
for (int col = 0; col < num_cols; col++)
{
int r = input_buf[input_row + row][columnOffset + JpegConstants.Offset_RGB_Red];
int g = input_buf[input_row + row][columnOffset + JpegConstants.Offset_RGB_Green];
int b = input_buf[input_row + row][columnOffset + JpegConstants.Offset_RGB_Blue];
columnOffset += JpegConstants.RGB_PixelLength;
output_buf[0][output_row][col] = (byte)((m_rgb_ycc_tab[r + R_Y_OFF] + m_rgb_ycc_tab[g + G_Y_OFF] + m_rgb_ycc_tab[b + B_Y_OFF]) >> SCALEBITS);
output_buf[1][output_row][col] = (byte)((m_rgb_ycc_tab[r + R_CB_OFF] + m_rgb_ycc_tab[g + G_CB_OFF] + m_rgb_ycc_tab[b + B_CB_OFF]) >> SCALEBITS);
output_buf[2][output_row][col] = (byte)((m_rgb_ycc_tab[r + R_CR_OFF] + m_rgb_ycc_tab[g + G_CR_OFF] + m_rgb_ycc_tab[b + B_CR_OFF]) >> SCALEBITS);
}
output_row++;
}
}
#endregion
#region RGB to Grayscale
private void rgb_gray_convert(byte[][] input_buf, int input_row, byte[][][] output_buf, int output_row, int num_rows)
{
int num_cols = m_cinfo.m_image_width;
for (int row = 0; row < num_rows; row++)
{
int columnOffset = 0;
for (int col = 0; col < num_cols; col++)
{
int r = input_buf[input_row + row][columnOffset + JpegConstants.Offset_RGB_Red];
int g = input_buf[input_row + row][columnOffset + JpegConstants.Offset_RGB_Green];
int b = input_buf[input_row + row][columnOffset + JpegConstants.Offset_RGB_Blue];
columnOffset += JpegConstants.RGB_PixelLength;
output_buf[0][output_row][col] = (byte)((m_rgb_ycc_tab[r + R_Y_OFF] + m_rgb_ycc_tab[g + G_Y_OFF] + m_rgb_ycc_tab[b + B_Y_OFF]) >> SCALEBITS);
}
output_row++;
}
}
#endregion
#region CMYK to YCCK
private void cmyk_ycck_convert(byte[][] input_buf, int input_row, byte[][][] output_buf, int output_row, int num_rows)
{
int num_cols = m_cinfo.m_image_width;
for (int row = 0; row < num_rows; row++)
{
int columnOffset = 0;
for (int col = 0; col < num_cols; col++)
{
int r = JpegConstants.MaxSampleValue - input_buf[input_row + row][columnOffset];
int g = JpegConstants.MaxSampleValue - input_buf[input_row + row][columnOffset + 1];
int b = JpegConstants.MaxSampleValue - input_buf[input_row + row][columnOffset + 2];
output_buf[3][output_row][col] = input_buf[input_row + row][columnOffset + 3];
columnOffset += 4;
output_buf[0][output_row][col] = (byte)((m_rgb_ycc_tab[r + R_Y_OFF] + m_rgb_ycc_tab[g + G_Y_OFF] + m_rgb_ycc_tab[b + B_Y_OFF]) >> SCALEBITS);
output_buf[1][output_row][col] = (byte)((m_rgb_ycc_tab[r + R_CB_OFF] + m_rgb_ycc_tab[g + G_CB_OFF] + m_rgb_ycc_tab[b + B_CB_OFF]) >> SCALEBITS);
output_buf[2][output_row][col] = (byte)((m_rgb_ycc_tab[r + R_CR_OFF] + m_rgb_ycc_tab[g + G_CR_OFF] + m_rgb_ycc_tab[b + B_CR_OFF]) >> SCALEBITS);
}
output_row++;
}
}
#endregion
#region Grayscale Conversion
private void grayscale_convert(byte[][] input_buf, int input_row, byte[][][] output_buf, int output_row, int num_rows)
{
int num_cols = m_cinfo.m_image_width;
int instride = m_cinfo.m_input_components;
for (int row = 0; row < num_rows; row++)
{
int columnOffset = 0;
for (int col = 0; col < num_cols; col++)
{
output_buf[0][output_row][col] = input_buf[input_row + row][columnOffset];
columnOffset += instride;
}
output_row++;
}
}
#endregion
#region Null Conversion
private void null_convert(byte[][] input_buf, int input_row, byte[][][] output_buf, int output_row, int num_rows)
{
int nc = m_cinfo.m_num_components;
int num_cols = m_cinfo.m_image_width;
for (int row = 0; row < num_rows; row++)
{
for (int ci = 0; ci < nc; ci++)
{
int columnOffset = 0;
for (int col = 0; col < num_cols; col++)
{
output_buf[ci][output_row][col] = input_buf[input_row + row][columnOffset + ci];
columnOffset += nc;
}
}
output_row++;
}
}
#endregion
}
#endregion
#region ColorDeconverter
class ColorDeconverter
{
private const int SCALEBITS = 16;
private const int ONE_HALF = 1 << (SCALEBITS - 1);
private enum ColorConverter
{
grayscale_converter,
ycc_rgb_converter,
gray_rgb_converter,
null_converter,
ycck_cmyk_converter
}
private ColorConverter m_converter;
private JpegDecompressor m_cinfo;
private int[] m_perComponentOffsets;
private int[] m_Cr_r_tab;
private int[] m_Cb_b_tab;
private int[] m_Cr_g_tab;
private int[] m_Cb_g_tab;
public ColorDeconverter(JpegDecompressor cinfo)
{
m_cinfo = cinfo;
switch (cinfo.m_jpeg_color_space)
{
case ColorSpace.Grayscale:
if (cinfo.m_num_components != 1)
throw new Exception("Bogus Jpeg colorspace!");
break;
case ColorSpace.RGB:
case ColorSpace.YCbCr:
if (cinfo.m_num_components != 3)
throw new Exception("Bogus Jpeg colorspace!");
break;
case ColorSpace.CMYK:
case ColorSpace.YCCK:
if (cinfo.m_num_components != 4)
throw new Exception("Bogus Jpeg colorspace!");
break;
default:
if (cinfo.m_num_components < 1)
throw new Exception("Bogus Jpeg colorspace!");
break;
}
switch (cinfo.m_out_color_space)
{
case ColorSpace.Grayscale:
cinfo.m_out_color_components = 1;
if (cinfo.m_jpeg_color_space == ColorSpace.Grayscale || cinfo.m_jpeg_color_space == ColorSpace.YCbCr)
{
m_converter = ColorConverter.grayscale_converter;
for (int ci = 1; ci < cinfo.m_num_components; ci++)
cinfo.Comp_info[ci].component_needed = false;
}
else
throw new Exception("Unsupported color conversion request.");
break;
case ColorSpace.RGB:
cinfo.m_out_color_components = JpegConstants.RGB_PixelLength;
if (cinfo.m_jpeg_color_space == ColorSpace.YCbCr)
{
m_converter = ColorConverter.ycc_rgb_converter;
build_ycc_rgb_table();
}
else if (cinfo.m_jpeg_color_space == ColorSpace.Grayscale)
m_converter = ColorConverter.gray_rgb_converter;
else if (cinfo.m_jpeg_color_space == ColorSpace.RGB)
m_converter = ColorConverter.null_converter;
else
throw new Exception("Unsupported color conversion request.");
break;
case ColorSpace.CMYK:
cinfo.m_out_color_components = 4;
if (cinfo.m_jpeg_color_space == ColorSpace.YCCK)
{
m_converter = ColorConverter.ycck_cmyk_converter;
build_ycc_rgb_table();
}
else if (cinfo.m_jpeg_color_space == ColorSpace.CMYK)
m_converter = ColorConverter.null_converter;
else
throw new Exception("Unsupported color conversion request.");
break;
default:
if (cinfo.m_out_color_space == cinfo.m_jpeg_color_space)
{
cinfo.m_out_color_components = cinfo.m_num_components;
m_converter = ColorConverter.null_converter;
}
else
{
throw new Exception("Unsupported color conversion request.");
}
break;
}
if (cinfo.m_quantize_colors)
cinfo.m_output_components = 1;
else
cinfo.m_output_components = cinfo.m_out_color_components;
}
public void color_convert(ComponentBuffer[] input_buf, int[] perComponentOffsets, int input_row, byte[][] output_buf, int output_row, int num_rows)
{
m_perComponentOffsets = perComponentOffsets;
switch (m_converter)
{
case ColorConverter.grayscale_converter:
grayscale_convert(input_buf, input_row, output_buf, output_row, num_rows);
break;
case ColorConverter.ycc_rgb_converter:
ycc_rgb_convert(input_buf, input_row, output_buf, output_row, num_rows);
break;
case ColorConverter.gray_rgb_converter:
gray_rgb_convert(input_buf, input_row, output_buf, output_row, num_rows);
break;
case ColorConverter.null_converter:
null_convert(input_buf, input_row, output_buf, output_row, num_rows);
break;
case ColorConverter.ycck_cmyk_converter:
ycck_cmyk_convert(input_buf, input_row, output_buf, output_row, num_rows);
break;
default:
throw new Exception("Unsupported color conversion request.");
}
}
private static int FIX(double x)
{
return (int)(x * (1L << SCALEBITS) + 0.5);
}
#region YCbCr to RGB
private void build_ycc_rgb_table()
{
m_Cr_r_tab = new int[JpegConstants.MaxSampleValue + 1];
m_Cb_b_tab = new int[JpegConstants.MaxSampleValue + 1];
m_Cr_g_tab = new int[JpegConstants.MaxSampleValue + 1];
m_Cb_g_tab = new int[JpegConstants.MaxSampleValue + 1];
for (int i = 0, x = -JpegConstants.MediumSampleValue; i <= JpegConstants.MaxSampleValue; i++, x++)
{
m_Cr_r_tab[i] = JpegUtils.RIGHT_SHIFT(FIX(1.40200) * x + ONE_HALF, SCALEBITS);
m_Cb_b_tab[i] = JpegUtils.RIGHT_SHIFT(FIX(1.77200) * x + ONE_HALF, SCALEBITS);
m_Cr_g_tab[i] = (-FIX(0.71414)) * x;
m_Cb_g_tab[i] = (-FIX(0.34414)) * x + ONE_HALF;
}
}
private void ycc_rgb_convert(ComponentBuffer[] input_buf, int input_row, byte[][] output_buf, int output_row, int num_rows)
{
int component0RowOffset = m_perComponentOffsets[0];
int component1RowOffset = m_perComponentOffsets[1];
int component2RowOffset = m_perComponentOffsets[2];
byte[] limit = m_cinfo.m_sample_range_limit;
int limitOffset = m_cinfo.m_sampleRangeLimitOffset;
for (int row = 0; row < num_rows; row++)
{
int columnOffset = 0;
for (int col = 0; col < m_cinfo.m_output_width; col++)
{
int y = input_buf[0][input_row + component0RowOffset][col];
int cb = input_buf[1][input_row + component1RowOffset][col];
int cr = input_buf[2][input_row + component2RowOffset][col];
output_buf[output_row + row][columnOffset + JpegConstants.Offset_RGB_Red] = limit[limitOffset + y + m_Cr_r_tab[cr]];
output_buf[output_row + row][columnOffset + JpegConstants.Offset_RGB_Green] = limit[limitOffset + y + JpegUtils.RIGHT_SHIFT(m_Cb_g_tab[cb] + m_Cr_g_tab[cr], SCALEBITS)];
output_buf[output_row + row][columnOffset + JpegConstants.Offset_RGB_Blue] = limit[limitOffset + y + m_Cb_b_tab[cb]];
columnOffset += JpegConstants.RGB_PixelLength;
}
input_row++;
}
}
#endregion
#region YCCK to CMYK
private void ycck_cmyk_convert(ComponentBuffer[] input_buf, int input_row, byte[][] output_buf, int output_row, int num_rows)
{
int component0RowOffset = m_perComponentOffsets[0];
int component1RowOffset = m_perComponentOffsets[1];
int component2RowOffset = m_perComponentOffsets[2];
int component3RowOffset = m_perComponentOffsets[3];
byte[] limit = m_cinfo.m_sample_range_limit;
int limitOffset = m_cinfo.m_sampleRangeLimitOffset;
int num_cols = m_cinfo.m_output_width;
for (int row = 0; row < num_rows; row++)
{
int columnOffset = 0;
for (int col = 0; col < num_cols; col++)
{
int y = input_buf[0][input_row + component0RowOffset][col];
int cb = input_buf[1][input_row + component1RowOffset][col];
int cr = input_buf[2][input_row + component2RowOffset][col];
output_buf[output_row + row][columnOffset] = limit[limitOffset + JpegConstants.MaxSampleValue - (y + m_Cr_r_tab[cr])];
output_buf[output_row + row][columnOffset + 1] = limit[limitOffset + JpegConstants.MaxSampleValue - (y + JpegUtils.RIGHT_SHIFT(m_Cb_g_tab[cb] + m_Cr_g_tab[cr], SCALEBITS))];
output_buf[output_row + row][columnOffset + 2] = limit[limitOffset + JpegConstants.MaxSampleValue - (y + m_Cb_b_tab[cb])];
output_buf[output_row + row][columnOffset + 3] = input_buf[3][input_row + component3RowOffset][col];
columnOffset += 4;
}
input_row++;
}
}
#endregion
#region Grayscale to RGB
private void gray_rgb_convert(ComponentBuffer[] input_buf, int input_row, byte[][] output_buf, int output_row, int num_rows)
{
int component0RowOffset = m_perComponentOffsets[0];
int component1RowOffset = m_perComponentOffsets[1];
int component2RowOffset = m_perComponentOffsets[2];
int num_cols = m_cinfo.m_output_width;
for (int row = 0; row < num_rows; row++)
{
int columnOffset = 0;
for (int col = 0; col < num_cols; col++)
{
output_buf[output_row + row][columnOffset + JpegConstants.Offset_RGB_Red] = input_buf[0][input_row + component0RowOffset][col];
output_buf[output_row + row][columnOffset + JpegConstants.Offset_RGB_Green] = input_buf[0][input_row + component1RowOffset][col];
output_buf[output_row + row][columnOffset + JpegConstants.Offset_RGB_Blue] = input_buf[0][input_row + component2RowOffset][col];
columnOffset += JpegConstants.RGB_PixelLength;
}
input_row++;
}
}
#endregion
#region Grayscale Conversion
private void grayscale_convert(ComponentBuffer[] input_buf, int input_row, byte[][] output_buf, int output_row, int num_rows)
{
JpegUtils.jcopy_sample_rows(input_buf[0], input_row + m_perComponentOffsets[0], output_buf, output_row, num_rows, m_cinfo.m_output_width);
}
#endregion
#region Null Conversion
private void null_convert(ComponentBuffer[] input_buf, int input_row, byte[][] output_buf, int output_row, int num_rows)
{
for (int row = 0; row < num_rows; row++)
{
for (int ci = 0; ci < m_cinfo.m_num_components; ci++)
{
int columnIndex = 0;
int componentOffset = 0;
int perComponentOffset = m_perComponentOffsets[ci];
for (int count = m_cinfo.m_output_width; count > 0; count--)
{
output_buf[output_row + row][ci + componentOffset] = input_buf[ci][input_row + perComponentOffset][columnIndex];
componentOffset += m_cinfo.m_num_components;
columnIndex++;
}
}
input_row++;
}
}
#endregion
}
#endregion
#region ColorQuantizer
interface ColorQuantizer
{
void start_pass(bool is_pre_scan);
void color_quantize(byte[][] input_buf, int in_row, byte[][] output_buf, int out_row, int num_rows);
void finish_pass();
void new_color_map();
}
#endregion
#region ComponentBuffer
class ComponentBuffer
{
private byte[][] m_buffer;
private int[] m_funnyIndices;
private int m_funnyOffset;
public ComponentBuffer()
{
}
public ComponentBuffer(byte[][] buf, int[] funnyIndices, int funnyOffset)
{
SetBuffer(buf, funnyIndices, funnyOffset);
}
public void SetBuffer(byte[][] buf, int[] funnyIndices, int funnyOffset)
{
m_buffer = buf;
m_funnyIndices = funnyIndices;
m_funnyOffset = funnyOffset;
}
public byte[] this[int i]
{
get
{
if (m_funnyIndices == null)
return m_buffer[i];
return m_buffer[m_funnyIndices[i + m_funnyOffset]];
}
}
}
#endregion
#region CompressionParameters
public class CompressionParameters
{
private int m_quality = 75;
private int m_smoothingFactor;
private bool m_simpleProgressive;
public CompressionParameters()
{
}
internal CompressionParameters(CompressionParameters parameters)
{
if (parameters == null)
throw new ArgumentNullException("parameters");
m_quality = parameters.m_quality;
m_smoothingFactor = parameters.m_smoothingFactor;
m_simpleProgressive = parameters.m_simpleProgressive;
}
public override bool Equals(object obj)
{
CompressionParameters parameters = obj as CompressionParameters;
if (parameters == null)
return false;
return (m_quality == parameters.m_quality &&
m_smoothingFactor == parameters.m_smoothingFactor &&
m_simpleProgressive == parameters.m_simpleProgressive);
}
public override int GetHashCode()
{
return base.GetHashCode();
}
public int Quality
{
get { return m_quality; }
set { m_quality = value; }
}
public int SmoothingFactor
{
get { return m_smoothingFactor; }
set { m_smoothingFactor = value; }
}
public bool SimpleProgressive
{
get { return m_simpleProgressive; }
set { m_simpleProgressive = value; }
}
}
#endregion
#region DecompressionParameters
class DecompressionParameters
{
private ColorSpace m_outColorspace = ColorSpace.Unknown;
private int m_scaleNumerator = 1;
private int m_scaleDenominator = 1;
private bool m_bufferedImage;
private bool m_rawDataOut;
private DCTMethod m_dctMethod = (DCTMethod)JpegConstants.DefaultDCTMethod;
private DitherMode m_ditherMode = DitherMode.FloydStein;
private bool m_doFancyUpsampling = true;
private bool m_doBlockSmoothing = true;
private bool m_quantizeColors;
private bool m_twoPassQuantize = true;
private int m_desiredNumberOfColors = 256;
private bool m_enableOnePassQuantizer;
private bool m_enableExternalQuant;
private bool m_enableTwoPassQuantizer;
private int m_traceLevel;
public int TraceLevel
{
get
{
return m_traceLevel;
}
set
{
m_traceLevel = value;
}
}
public ColorSpace OutColorspace
{
get
{
return m_outColorspace;
}
set
{
m_outColorspace = value;
}
}
public int ScaleNumerator
{
get
{
return m_scaleNumerator;
}
set
{
m_scaleNumerator = value;
}
}
public int ScaleDenominator
{
get
{
return m_scaleDenominator;
}
set
{
m_scaleDenominator = value;
}
}
public bool BufferedImage
{
get
{
return m_bufferedImage;
}
set
{
m_bufferedImage = value;
}
}
public bool RawDataOut
{
get
{
return m_rawDataOut;
}
set
{
m_rawDataOut = value;
}
}
public DCTMethod DCTMethod
{
get
{
return m_dctMethod;
}
set
{
m_dctMethod = value;
}
}
public bool DoFancyUpsampling
{
get
{
return m_doFancyUpsampling;
}
set
{
m_doFancyUpsampling = value;
}
}
public bool DoBlockSmoothing
{
get
{
return m_doBlockSmoothing;
}
set
{
m_doBlockSmoothing = value;
}
}
public bool QuantizeColors
{
get
{
return m_quantizeColors;
}
set
{
m_quantizeColors = value;
}
}
public DitherMode DitherMode
{
get
{
return m_ditherMode;
}
set
{
m_ditherMode = value;
}
}
public bool TwoPassQuantize
{
get
{
return m_twoPassQuantize;
}
set
{
m_twoPassQuantize = value;
}
}
public int DesiredNumberOfColors
{
get
{
return m_desiredNumberOfColors;
}
set
{
m_desiredNumberOfColors = value;
}
}
public bool EnableOnePassQuantizer
{
get
{
return m_enableOnePassQuantizer;
}
set
{
m_enableOnePassQuantizer = value;
}
}
public bool EnableExternalQuant
{
get
{
return m_enableExternalQuant;
}
set
{
m_enableExternalQuant = value;
}
}
public bool EnableTwoPassQuantizer
{
get
{
return m_enableTwoPassQuantizer;
}
set
{
m_enableTwoPassQuantizer = value;
}
}
}
#endregion
#region DecompressorToJpegImage
class DecompressorToJpegImage : IDecompressor
{
private JpegImage m_jpegImage;
internal DecompressorToJpegImage(JpegImage jpegImage)
{
m_jpegImage = jpegImage;
}
public override Stream Output
{
get
{
return null;
}
}
public override void SetImageAttributes(LoadedImageAttributes parameters)
{
m_jpegImage.Width = parameters.Width;
m_jpegImage.Height = parameters.Height;
m_jpegImage.BitsPerComponent = 8;
m_jpegImage.ComponentsPerSample = (byte)parameters.ComponentsPerSample;
m_jpegImage.Colorspace = parameters.Colorspace;
}
public override void BeginWrite()
{
}
public override void ProcessPixelsRow(byte[] row)
{
SampleRow samplesRow = new SampleRow(row, m_jpegImage.Width, m_jpegImage.BitsPerComponent, m_jpegImage.ComponentsPerSample);
m_jpegImage.addSampleRow(samplesRow);
}
public override void EndWrite()
{
}
}
#endregion
#region DerivedTable
class DerivedTable
{
public int[] maxcode = new int[18];
public int[] valoffset = new int[17];
public JpegHuffmanTable pub;
public int[] look_nbits = new int[1 << JpegConstants.HuffmanLookaheadDistance];
public byte[] look_sym = new byte[1 << JpegConstants.HuffmanLookaheadDistance];
}
#endregion
#region DestinationManager
public abstract class DestinationManager
{
private byte[] m_buffer;
private int m_position;
private int m_free_in_buffer;
public abstract void init_destination();
public abstract bool empty_output_buffer();
public abstract void term_destination();
public virtual bool emit_byte(int val)
{
m_buffer[m_position] = (byte)val;
m_position++;
if (--m_free_in_buffer == 0)
{
if (!empty_output_buffer())
return false;
}
return true;
}
protected void initInternalBuffer(byte[] buffer, int offset)
{
m_buffer = buffer;
m_free_in_buffer = buffer.Length - offset;
m_position = offset;
}
protected int freeInBuffer
{
get
{
return m_free_in_buffer;
}
}
}
#endregion
#region DestinationManagerImpl
class DestinationManagerImpl : DestinationManager
{
private const int OUTPUT_BUF_SIZE = 4096;
private JpegCompressor m_cinfo;
private Stream m_outfile;
private byte[] m_buffer;
public DestinationManagerImpl(JpegCompressor cinfo, Stream alreadyOpenFile)
{
m_cinfo = cinfo;
m_outfile = alreadyOpenFile;
}
public override void init_destination()
{
m_buffer = new byte[OUTPUT_BUF_SIZE];
initInternalBuffer(m_buffer, 0);
}
public override bool empty_output_buffer()
{
writeBuffer(m_buffer.Length);
initInternalBuffer(m_buffer, 0);
return true;
}
public override void term_destination()
{
int datacount = m_buffer.Length - freeInBuffer;
if (datacount > 0)
writeBuffer(datacount);
m_outfile.Flush();
}
private void writeBuffer(int dataCount)
{
try
{
m_outfile.Write(m_buffer, 0, dataCount);
}
#pragma warning disable 168
catch (IOException e)
{
throw new Exception("Output file write error --- out of disk space?");
}
catch (NotSupportedException e)
{
throw new Exception("Output file write error --- out of disk space?");
}
catch (ObjectDisposedException e)
{
throw new Exception("Output file write error --- out of disk space?");
}
#pragma warning restore 168
}
}
#endregion
#region Enumerations
enum BufferMode
{
PassThru,
SaveSource,
CrankDest,
SaveAndPass
}
public enum DensityUnit
{
Unknown = 0,
DotsInch = 1,
DotsCm = 2
}
public enum DitherMode
{
None,
Ordered,
FloydStein
}
public enum ReadResult
{
Suspended = 0,
Header_Ok = 1,
Header_Tables_Only = 2,
Reached_SOS = 3,
Reached_EOI = 4,
Row_Completed = 5,
Scan_Completed = 6
}
public enum ColorSpace
{
Unknown,
Grayscale,
RGB,
YCbCr,
CMYK,
YCCK
}
public enum DCTMethod
{
IntSlow,
IntFast,
Float
}
#endregion
#region HuffEntropyDecoder
class HuffEntropyDecoder : JpegEntropyDecoder
{
private class savable_state
{
public int[] last_dc_val = new int[JpegConstants.MaxComponentsInScan]; /* last DC coef for each component */
public void Assign(savable_state ss)
{
Buffer.BlockCopy(ss.last_dc_val, 0, last_dc_val, 0, last_dc_val.Length * sizeof(int));
}
}
private SavedBitreadState m_bitstate;
private savable_state m_saved = new savable_state();
private int m_restarts_to_go;
private DerivedTable[] m_dc_derived_tbls = new DerivedTable[JpegConstants.NumberOfHuffmanTables];
private DerivedTable[] m_ac_derived_tbls = new DerivedTable[JpegConstants.NumberOfHuffmanTables];
private DerivedTable[] m_dc_cur_tbls = new DerivedTable[JpegConstants.DecompressorMaxBlocksInMCU];
private DerivedTable[] m_ac_cur_tbls = new DerivedTable[JpegConstants.DecompressorMaxBlocksInMCU];
private bool[] m_dc_needed = new bool[JpegConstants.DecompressorMaxBlocksInMCU];
private bool[] m_ac_needed = new bool[JpegConstants.DecompressorMaxBlocksInMCU];
public HuffEntropyDecoder(JpegDecompressor cinfo)
{
m_cinfo = cinfo;
for (int i = 0; i < JpegConstants.NumberOfHuffmanTables; i++)
m_dc_derived_tbls[i] = m_ac_derived_tbls[i] = null;
}
public override void start_pass()
{
for (int ci = 0; ci < m_cinfo.m_comps_in_scan; ci++)
{
JpegComponent componentInfo = m_cinfo.Comp_info[m_cinfo.m_cur_comp_info[ci]];
int dctbl = componentInfo.Dc_tbl_no;
int actbl = componentInfo.Ac_tbl_no;
jpeg_make_d_derived_tbl(true, dctbl, ref m_dc_derived_tbls[dctbl]);
jpeg_make_d_derived_tbl(false, actbl, ref m_ac_derived_tbls[actbl]);
m_saved.last_dc_val[ci] = 0;
}
for (int blkn = 0; blkn < m_cinfo.m_blocks_in_MCU; blkn++)
{
int ci = m_cinfo.m_MCU_membership[blkn];
JpegComponent componentInfo = m_cinfo.Comp_info[m_cinfo.m_cur_comp_info[ci]];
m_dc_cur_tbls[blkn] = m_dc_derived_tbls[componentInfo.Dc_tbl_no];
m_ac_cur_tbls[blkn] = m_ac_derived_tbls[componentInfo.Ac_tbl_no];
if (componentInfo.component_needed)
{
m_dc_needed[blkn] = true;
m_ac_needed[blkn] = (componentInfo.DCT_scaled_size > 1);
}
else
{
m_dc_needed[blkn] = m_ac_needed[blkn] = false;
}
}
m_bitstate.bits_left = 0;
m_bitstate.get_buffer = 0;
m_insufficient_data = false;
m_restarts_to_go = m_cinfo.m_restart_interval;
}
public override bool decode_mcu(JpegBlock[] MCU_data)
{
if (m_cinfo.m_restart_interval != 0)
{
if (m_restarts_to_go == 0)
{
if (!process_restart())
return false;
}
}
if (!m_insufficient_data)
{
int get_buffer;
int bits_left;
WorkingBitreadState br_state = new WorkingBitreadState();
BITREAD_LOAD_STATE(m_bitstate, out get_buffer, out bits_left, ref br_state);
savable_state state = new savable_state();
state.Assign(m_saved);
for (int blkn = 0; blkn < m_cinfo.m_blocks_in_MCU; blkn++)
{
int s;
if (!HUFF_DECODE(out s, ref br_state, m_dc_cur_tbls[blkn], ref get_buffer, ref bits_left))
return false;
if (s != 0)
{
if (!CHECK_BIT_BUFFER(ref br_state, s, ref get_buffer, ref bits_left))
return false;
int r = GET_BITS(s, get_buffer, ref bits_left);
s = HUFF_EXTEND(r, s);
}
if (m_dc_needed[blkn])
{
int ci = m_cinfo.m_MCU_membership[blkn];
s += state.last_dc_val[ci];
state.last_dc_val[ci] = s;
MCU_data[blkn][0] = (short)s;
}
if (m_ac_needed[blkn])
{
for (int k = 1; k < JpegConstants.DCTSize2; k++)
{
if (!HUFF_DECODE(out s, ref br_state, m_ac_cur_tbls[blkn], ref get_buffer, ref bits_left))
return false;
int r = s >> 4;
s &= 15;
if (s != 0)
{
k += r;
if (!CHECK_BIT_BUFFER(ref br_state, s, ref get_buffer, ref bits_left))
return false;
r = GET_BITS(s, get_buffer, ref bits_left);
s = HUFF_EXTEND(r, s);
MCU_data[blkn][JpegUtils.jpeg_natural_order[k]] = (short)s;
}
else
{
if (r != 15)
break;
k += 15;
}
}
}
else
{
for (int k = 1; k < JpegConstants.DCTSize2; k++)
{
if (!HUFF_DECODE(out s, ref br_state, m_ac_cur_tbls[blkn], ref get_buffer, ref bits_left))
return false;
int r = s >> 4;
s &= 15;
if (s != 0)
{
k += r;
if (!CHECK_BIT_BUFFER(ref br_state, s, ref get_buffer, ref bits_left))
return false;
DROP_BITS(s, ref bits_left);
}
else
{
if (r != 15)
break;
k += 15;
}
}
}
}
BITREAD_SAVE_STATE(ref m_bitstate, get_buffer, bits_left);
m_saved.Assign(state);
}
m_restarts_to_go--;
return true;
}
private bool process_restart()
{
m_cinfo.m_marker.SkipBytes(m_bitstate.bits_left / 8);
m_bitstate.bits_left = 0;
if (!m_cinfo.m_marker.read_restart_marker())
return false;
for (int ci = 0; ci < m_cinfo.m_comps_in_scan; ci++)
m_saved.last_dc_val[ci] = 0;
m_restarts_to_go = m_cinfo.m_restart_interval;
if (m_cinfo.m_unread_marker == 0)
m_insufficient_data = false;
return true;
}
}
#endregion
#region HuffEntropyEncoder
class HuffEntropyEncoder : JpegEntropyEncoder
{
private class savable_state
{
public int put_buffer;
public int put_bits;
public int[] last_dc_val = new int[JpegConstants.MaxComponentsInScan];
}
private bool m_gather_statistics;
private savable_state m_saved = new savable_state();
private int m_restarts_to_go;
private int m_next_restart_num;
private c_derived_tbl[] m_dc_derived_tbls = new c_derived_tbl[JpegConstants.NumberOfHuffmanTables];
private c_derived_tbl[] m_ac_derived_tbls = new c_derived_tbl[JpegConstants.NumberOfHuffmanTables];
private long[][] m_dc_count_ptrs = new long[JpegConstants.NumberOfHuffmanTables][];
private long[][] m_ac_count_ptrs = new long[JpegConstants.NumberOfHuffmanTables][];
public HuffEntropyEncoder(JpegCompressor cinfo)
{
m_cinfo = cinfo;
for (int i = 0; i < JpegConstants.NumberOfHuffmanTables; i++)
{
m_dc_derived_tbls[i] = m_ac_derived_tbls[i] = null;
m_dc_count_ptrs[i] = m_ac_count_ptrs[i] = null;
}
}
public override void start_pass(bool gather_statistics)
{
m_gather_statistics = gather_statistics;
for (int ci = 0; ci < m_cinfo.m_comps_in_scan; ci++)
{
int dctbl = m_cinfo.Component_info[m_cinfo.m_cur_comp_info[ci]].Dc_tbl_no;
int actbl = m_cinfo.Component_info[m_cinfo.m_cur_comp_info[ci]].Ac_tbl_no;
if (m_gather_statistics)
{
if (dctbl < 0 || dctbl >= JpegConstants.NumberOfHuffmanTables)
throw new Exception(String.Format("Huffman table 0x{0:X2} was not defined", dctbl));
if (actbl < 0 || actbl >= JpegConstants.NumberOfHuffmanTables)
throw new Exception(String.Format("Huffman table 0x{0:X2} was not defined", actbl));
if (m_dc_count_ptrs[dctbl] == null)
m_dc_count_ptrs[dctbl] = new long[257];
Array.Clear(m_dc_count_ptrs[dctbl], 0, m_dc_count_ptrs[dctbl].Length);
if (m_ac_count_ptrs[actbl] == null)
m_ac_count_ptrs[actbl] = new long[257];
Array.Clear(m_ac_count_ptrs[actbl], 0, m_ac_count_ptrs[actbl].Length);
}
else
{
jpeg_make_c_derived_tbl(true, dctbl, ref m_dc_derived_tbls[dctbl]);
jpeg_make_c_derived_tbl(false, actbl, ref m_ac_derived_tbls[actbl]);
}
m_saved.last_dc_val[ci] = 0;
}
m_saved.put_buffer = 0;
m_saved.put_bits = 0;
m_restarts_to_go = m_cinfo.m_restart_interval;
m_next_restart_num = 0;
}
public override bool encode_mcu(JpegBlock[][] MCU_data)
{
if (m_gather_statistics)
return encode_mcu_gather(MCU_data);
return encode_mcu_huff(MCU_data);
}
public override void finish_pass()
{
if (m_gather_statistics)
finish_pass_gather();
else
finish_pass_huff();
}
private bool encode_mcu_huff(JpegBlock[][] MCU_data)
{
savable_state state;
state = m_saved;
if (m_cinfo.m_restart_interval != 0)
{
if (m_restarts_to_go == 0)
{
if (!emit_restart(state, m_next_restart_num))
return false;
}
}
for (int blkn = 0; blkn < m_cinfo.m_blocks_in_MCU; blkn++)
{
int ci = m_cinfo.m_MCU_membership[blkn];
if (!encode_one_block(state, MCU_data[blkn][0].data, state.last_dc_val[ci],
m_dc_derived_tbls[m_cinfo.Component_info[m_cinfo.m_cur_comp_info[ci]].Dc_tbl_no],
m_ac_derived_tbls[m_cinfo.Component_info[m_cinfo.m_cur_comp_info[ci]].Ac_tbl_no]))
{
return false;
}
state.last_dc_val[ci] = MCU_data[blkn][0][0];
}
m_saved = state;
if (m_cinfo.m_restart_interval != 0)
{
if (m_restarts_to_go == 0)
{
m_restarts_to_go = m_cinfo.m_restart_interval;
m_next_restart_num++;
m_next_restart_num &= 7;
}
m_restarts_to_go--;
}
return true;
}
private void finish_pass_huff()
{
savable_state state;
state = m_saved;
if (!flush_bits(state))
throw new Exception("Suspension not allowed here!");
m_saved = state;
}
private bool encode_mcu_gather(JpegBlock[][] MCU_data)
{
if (m_cinfo.m_restart_interval != 0)
{
if (m_restarts_to_go == 0)
{
for (int ci = 0; ci < m_cinfo.m_comps_in_scan; ci++)
m_saved.last_dc_val[ci] = 0;
m_restarts_to_go = m_cinfo.m_restart_interval;
}
m_restarts_to_go--;
}
for (int blkn = 0; blkn < m_cinfo.m_blocks_in_MCU; blkn++)
{
int ci = m_cinfo.m_MCU_membership[blkn];
htest_one_block(MCU_data[blkn][0].data, m_saved.last_dc_val[ci],
m_dc_count_ptrs[m_cinfo.Component_info[m_cinfo.m_cur_comp_info[ci]].Dc_tbl_no],
m_ac_count_ptrs[m_cinfo.Component_info[m_cinfo.m_cur_comp_info[ci]].Ac_tbl_no]);
m_saved.last_dc_val[ci] = MCU_data[blkn][0][0];
}
return true;
}
private void finish_pass_gather()
{
bool[] did_dc = new bool[JpegConstants.NumberOfHuffmanTables];
bool[] did_ac = new bool[JpegConstants.NumberOfHuffmanTables];
for (int ci = 0; ci < m_cinfo.m_comps_in_scan; ci++)
{
int dctbl = m_cinfo.Component_info[m_cinfo.m_cur_comp_info[ci]].Dc_tbl_no;
if (!did_dc[dctbl])
{
if (m_cinfo.m_dc_huff_tbl_ptrs[dctbl] == null)
m_cinfo.m_dc_huff_tbl_ptrs[dctbl] = new JpegHuffmanTable();
jpeg_gen_optimal_table(m_cinfo.m_dc_huff_tbl_ptrs[dctbl], m_dc_count_ptrs[dctbl]);
did_dc[dctbl] = true;
}
int actbl = m_cinfo.Component_info[m_cinfo.m_cur_comp_info[ci]].Ac_tbl_no;
if (!did_ac[actbl])
{
if (m_cinfo.m_ac_huff_tbl_ptrs[actbl] == null)
m_cinfo.m_ac_huff_tbl_ptrs[actbl] = new JpegHuffmanTable();
jpeg_gen_optimal_table(m_cinfo.m_ac_huff_tbl_ptrs[actbl], m_ac_count_ptrs[actbl]);
did_ac[actbl] = true;
}
}
}
private bool encode_one_block(savable_state state, short[] block, int last_dc_val, c_derived_tbl dctbl, c_derived_tbl actbl)
{
int temp = block[0] - last_dc_val;
int temp2 = temp;
if (temp < 0)
{
temp = -temp;
temp2--;
}
int nbits = 0;
while (temp != 0)
{
nbits++;
temp >>= 1;
}
if (nbits > MAX_HUFFMAN_COEF_BITS + 1)
throw new Exception("DCT coefficient is out of range!");
if (!emit_bits(state, dctbl.ehufco[nbits], dctbl.ehufsi[nbits]))
return false;
if (nbits != 0)
{
if (!emit_bits(state, temp2, nbits))
return false;
}
int r = 0;
for (int k = 1; k < JpegConstants.DCTSize2; k++)
{
temp = block[JpegUtils.jpeg_natural_order[k]];
if (temp == 0)
{
r++;
}
else
{
while (r > 15)
{
if (!emit_bits(state, actbl.ehufco[0xF0], actbl.ehufsi[0xF0]))
return false;
r -= 16;
}
temp2 = temp;
if (temp < 0)
{
temp = -temp;
temp2--;
}
nbits = 1;
while ((temp >>= 1) != 0)
nbits++;
if (nbits > MAX_HUFFMAN_COEF_BITS)
throw new Exception("DCT coefficient is out of range!");
int i = (r << 4) + nbits;
if (!emit_bits(state, actbl.ehufco[i], actbl.ehufsi[i]))
return false;
if (!emit_bits(state, temp2, nbits))
return false;
r = 0;
}
}
if (r > 0)
{
if (!emit_bits(state, actbl.ehufco[0], actbl.ehufsi[0]))
return false;
}
return true;
}
private void htest_one_block(short[] block, int last_dc_val, long[] dc_counts, long[] ac_counts)
{
int temp = block[0] - last_dc_val;
if (temp < 0)
temp = -temp;
int nbits = 0;
while (temp != 0)
{
nbits++;
temp >>= 1;
}
if (nbits > MAX_HUFFMAN_COEF_BITS + 1)
throw new Exception("DCT coefficient is out of range!");
dc_counts[nbits]++;
int r = 0;
for (int k = 1; k < JpegConstants.DCTSize2; k++)
{
temp = block[JpegUtils.jpeg_natural_order[k]];
if (temp == 0)
{
r++;
}
else
{
while (r > 15)
{
ac_counts[0xF0]++;
r -= 16;
}
if (temp < 0)
temp = -temp;
nbits = 1;
while ((temp >>= 1) != 0)
nbits++;
if (nbits > MAX_HUFFMAN_COEF_BITS)
throw new Exception("DCT coefficient is out of range!");
ac_counts[(r << 4) + nbits]++;
r = 0;
}
}
if (r > 0)
ac_counts[0]++;
}
private bool emit_byte(int val)
{
return m_cinfo.m_dest.emit_byte(val);
}
private bool emit_bits(savable_state state, int code, int size)
{
int put_buffer = code;
int put_bits = state.put_bits;
if (size == 0)
throw new Exception("Missing Huffman code table entry");
put_buffer &= (1 << size) - 1;
put_bits += size;
put_buffer <<= 24 - put_bits;
put_buffer |= state.put_buffer;
while (put_bits >= 8)
{
int c = (put_buffer >> 16) & 0xFF;
if (!emit_byte(c))
return false;
if (c == 0xFF)
{
if (!emit_byte(0))
return false;
}
put_buffer <<= 8;
put_bits -= 8;
}
state.put_buffer = put_buffer;
state.put_bits = put_bits;
return true;
}
private bool flush_bits(savable_state state)
{
if (!emit_bits(state, 0x7F, 7))
return false;
state.put_buffer = 0;
state.put_bits = 0;
return true;
}
private bool emit_restart(savable_state state, int restart_num)
{
if (!flush_bits(state))
return false;
if (!emit_byte(0xFF))
return false;
if (!emit_byte((int)(JpegMarkerType.RST0 + restart_num)))
return false;
for (int ci = 0; ci < m_cinfo.m_comps_in_scan; ci++)
state.last_dc_val[ci] = 0;
return true;
}
}
#endregion
#region IDecompressDestination
abstract class IDecompressor
{
public abstract Stream Output { get; }
public abstract void SetImageAttributes(LoadedImageAttributes parameters);
public abstract void BeginWrite();
public abstract void ProcessPixelsRow(byte[] row);
public abstract void EndWrite();
}
class LoadedImageAttributes
{
private ColorSpace m_colorspace;
private bool m_quantizeColors;
private int m_width;
private int m_height;
private int m_componentsPerSample;
private int m_components;
private int m_actualNumberOfColors;
private byte[][] m_colormap;
private DensityUnit m_densityUnit;
private int m_densityX;
private int m_densityY;
public ColorSpace Colorspace
{
get
{
return m_colorspace;
}
internal set
{
m_colorspace = value;
}
}
public bool QuantizeColors
{
get
{
return m_quantizeColors;
}
internal set
{
m_quantizeColors = value;
}
}
public int Width
{
get
{
return m_width;
}
internal set
{
m_width = value;
}
}
public int Height
{
get
{
return m_height;
}
internal set
{
m_height = value;
}
}
public int ComponentsPerSample
{
get
{
return m_componentsPerSample;
}
internal set
{
m_componentsPerSample = value;
}
}
public int Components
{
get
{
return m_components;
}
internal set
{
m_components = value;
}
}
public int ActualNumberOfColors
{
get
{
return m_actualNumberOfColors;
}
internal set
{
m_actualNumberOfColors = value;
}
}
public byte[][] Colormap
{
get
{
return m_colormap;
}
internal set
{
m_colormap = value;
}
}
public DensityUnit DensityUnit
{
get
{
return m_densityUnit;
}
internal set
{
m_densityUnit = value;
}
}
public int DensityX
{
get
{
return m_densityX;
}
internal set
{
m_densityX = value;
}
}
public int DensityY
{
get
{
return m_densityY;
}
internal set
{
m_densityY = value;
}
}
}
#endregion
#region IRawImage
abstract class IRawImage
{
public abstract int Width { get; }
public abstract int Height { get; }
public abstract ColorSpace Colorspace { get; }
public abstract int ComponentsPerPixel { get; }
public abstract void BeginRead();
public abstract byte[] GetPixelRow();
public abstract void EndRead();
}
#endregion
#region Jpeg
class Jpeg
{
private JpegCompressor m_compressor = new JpegCompressor();
private JpegDecompressor m_decompressor = new JpegDecompressor();
private CompressionParameters m_compressionParameters = new CompressionParameters();
private DecompressionParameters m_decompressionParameters = new DecompressionParameters();
public CompressionParameters CompressionParameters
{
get
{
return m_compressionParameters;
}
set
{
if (value == null)
throw new ArgumentNullException("value");
m_compressionParameters = value;
}
}
public DecompressionParameters DecompressionParameters
{
get
{
return m_decompressionParameters;
}
set
{
if (value == null)
throw new ArgumentNullException("value");
m_decompressionParameters = value;
}
}
public void Compress(IRawImage source, Stream output)
{
if (source == null)
throw new ArgumentNullException("source");
if (output == null)
throw new ArgumentNullException("output");
m_compressor.Image_width = source.Width;
m_compressor.Image_height = source.Height;
m_compressor.In_color_space = (ColorSpace)source.Colorspace;
m_compressor.Input_components = source.ComponentsPerPixel;
m_compressor.jpeg_set_defaults();
applyParameters(m_compressionParameters);
m_compressor.jpeg_stdio_dest(output);
m_compressor.jpeg_start_compress(true);
source.BeginRead();
while (m_compressor.Next_scanline < m_compressor.Image_height)
{
byte[] row = source.GetPixelRow();
if (row == null)
{
throw new InvalidDataException("Row of pixels is null");
}
byte[][] rowForDecompressor = new byte[1][];
rowForDecompressor[0] = row;
m_compressor.jpeg_write_scanlines(rowForDecompressor, 1);
}
source.EndRead();
m_compressor.jpeg_finish_compress();
}
public void Decompress(Stream jpeg, IDecompressor destination)
{
if (jpeg == null)
throw new ArgumentNullException("jpeg");
if (destination == null)
throw new ArgumentNullException("destination");
beforeDecompress(jpeg);
m_decompressor.jpeg_start_decompress();
LoadedImageAttributes parameters = getImageParametersFromDecompressor();
destination.SetImageAttributes(parameters);
destination.BeginWrite();
while (m_decompressor.Output_scanline < m_decompressor.Output_height)
{
byte[][] row = JpegCommonBase.AllocJpegSamples(m_decompressor.Output_width * m_decompressor.Output_components, 1);
m_decompressor.jpeg_read_scanlines(row, 1);
destination.ProcessPixelsRow(row[0]);
}
destination.EndWrite();
m_decompressor.jpeg_finish_decompress();
}
private void beforeDecompress(Stream jpeg)
{
m_decompressor.jpeg_stdio_src(jpeg);
m_decompressor.jpeg_read_header(true);
applyParameters(m_decompressionParameters);
m_decompressor.jpeg_calc_output_dimensions();
}
private LoadedImageAttributes getImageParametersFromDecompressor()
{
LoadedImageAttributes result = new LoadedImageAttributes();
result.Colorspace = (ColorSpace)m_decompressor.Out_color_space;
result.QuantizeColors = m_decompressor.Quantize_colors;
result.Width = m_decompressor.Output_width;
result.Height = m_decompressor.Output_height;
result.ComponentsPerSample = m_decompressor.Out_color_components;
result.Components = m_decompressor.Output_components;
result.ActualNumberOfColors = m_decompressor.Actual_number_of_colors;
result.Colormap = m_decompressor.Colormap;
result.DensityUnit = m_decompressor.Density_unit;
result.DensityX = m_decompressor.X_density;
result.DensityY = m_decompressor.Y_density;
return result;
}
public JpegCompressor ClassicCompressor
{
get
{
return m_compressor;
}
}
public JpegDecompressor ClassicDecompressor
{
get
{
return m_decompressor;
}
}
public delegate bool MarkerParser(Jpeg decompressor);
public void SetMarkerProcessor(int markerCode, MarkerParser routine)
{
JpegDecompressor.jpeg_marker_parser_method f = delegate { return routine(this); };
m_decompressor.jpeg_set_marker_processor(markerCode, f);
}
private void applyParameters(DecompressionParameters parameters)
{
if (parameters == null)
throw new ArgumentNullException("'parameters' Cannot be null!");
if (parameters.OutColorspace != ColorSpace.Unknown)
m_decompressor.Out_color_space = (ColorSpace)parameters.OutColorspace;
m_decompressor.Scale_num = parameters.ScaleNumerator;
m_decompressor.Scale_denom = parameters.ScaleDenominator;
m_decompressor.Buffered_image = parameters.BufferedImage;
m_decompressor.Raw_data_out = parameters.RawDataOut;
m_decompressor.Dct_method = (DCTMethod)parameters.DCTMethod;
m_decompressor.Dither_mode = (DitherMode)parameters.DitherMode;
m_decompressor.Do_fancy_upsampling = parameters.DoFancyUpsampling;
m_decompressor.Do_block_smoothing = parameters.DoBlockSmoothing;
m_decompressor.Quantize_colors = parameters.QuantizeColors;
m_decompressor.Two_pass_quantize = parameters.TwoPassQuantize;
m_decompressor.Desired_number_of_colors = parameters.DesiredNumberOfColors;
m_decompressor.Enable_1pass_quant = parameters.EnableOnePassQuantizer;
m_decompressor.Enable_external_quant = parameters.EnableExternalQuant;
m_decompressor.Enable_2pass_quant = parameters.EnableTwoPassQuantizer;
}
private void applyParameters(CompressionParameters parameters)
{
if (parameters == null)
throw new ArgumentNullException("'parameters' Cannot be null!");
m_compressor.Smoothing_factor = parameters.SmoothingFactor;
m_compressor.jpeg_set_quality(parameters.Quality, true);
if (parameters.SimpleProgressive)
m_compressor.jpeg_simple_progression();
}
}
#endregion
#region JpegBlock
public class JpegBlock
{
internal short[] data = new short[JpegConstants.DCTSize2];
public short this[int index]
{
get
{
return data[index];
}
set
{
data[index] = value;
}
}
}
#endregion
#region JpegCompressor
public class JpegCompressor : JpegCommonBase
{
private static int[] std_luminance_quant_tbl = {
16, 11, 10, 16, 24, 40, 51, 61, 12, 12, 14, 19, 26,
58, 60, 55, 14, 13, 16, 24, 40, 57, 69, 56, 14, 17,
22, 29, 51, 87, 80, 62, 18, 22, 37, 56, 68, 109,
103, 77, 24, 35, 55, 64, 81, 104, 113, 92, 49, 64,
78, 87, 103, 121, 120, 101, 72, 92, 95, 98, 112,
100, 103, 99 };
private static int[] std_chrominance_quant_tbl = {
17, 18, 24, 47, 99, 99, 99, 99, 18, 21, 26, 66,
99, 99, 99, 99, 24, 26, 56, 99, 99, 99, 99, 99,
47, 66, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99 };
private static byte[] bits_dc_luminance = { 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
private static byte[] val_dc_luminance = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
private static byte[] bits_dc_chrominance = { 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
private static byte[] val_dc_chrominance = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
private static byte[] bits_ac_luminance = { 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
private static byte[] val_ac_luminance =
{ 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06,
0x13, 0x51, 0x61, 0x07, 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0, 0x24, 0x33, 0x62, 0x72,
0x82, 0x09, 0x0a, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x43, 0x44, 0x45,
0x46, 0x47, 0x48, 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x73, 0x74, 0x75,
0x76, 0x77, 0x78, 0x79, 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3,
0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9,
0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf1, 0xf2, 0xf3, 0xf4,
0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa };
private static byte[] bits_ac_chrominance = { 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
private static byte[] val_ac_chrominance =
{ 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, 0x31, 0x06, 0x12, 0x41,
0x51, 0x07, 0x61, 0x71, 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0, 0x15, 0x62, 0x72, 0xd1,
0x0a, 0x16, 0x24, 0x34, 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x43, 0x44,
0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x73, 0x74,
0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a,
0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf2, 0xf3, 0xf4,
0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa };
internal DestinationManager m_dest;
internal int m_image_width;
internal int m_image_height;
internal int m_input_components;
internal ColorSpace m_in_color_space;
internal int m_data_precision;
internal int m_num_components;
internal ColorSpace m_jpeg_color_space;
private JpegComponent[] m_comp_info;
internal JpegQuantizationTable[] m_quant_tbl_ptrs = new JpegQuantizationTable[JpegConstants.NumberOfQuantTables];
internal JpegHuffmanTable[] m_dc_huff_tbl_ptrs = new JpegHuffmanTable[JpegConstants.NumberOfHuffmanTables];
internal JpegHuffmanTable[] m_ac_huff_tbl_ptrs = new JpegHuffmanTable[JpegConstants.NumberOfHuffmanTables];
internal int m_num_scans;
internal JpegScanInfo[] m_scan_info;
internal bool m_raw_data_in;
internal bool m_optimize_coding;
internal bool m_CCIR601_sampling;
internal int m_smoothing_factor;
internal DCTMethod m_dct_method;
internal int m_restart_interval;
internal int m_restart_in_rows;
internal bool m_write_JFIF_header;
internal byte m_JFIF_major_version;
internal byte m_JFIF_minor_version;
internal DensityUnit m_density_unit;
internal short m_X_density;
internal short m_Y_density;
internal bool m_write_Adobe_marker;
internal int m_next_scanline;
internal bool m_progressive_mode;
internal int m_max_h_samp_factor;
internal int m_max_v_samp_factor;
internal int m_total_iMCU_rows;
internal int m_comps_in_scan;
internal int[] m_cur_comp_info = new int[JpegConstants.MaxComponentsInScan];
internal int m_MCUs_per_row;
internal int m_MCU_rows_in_scan;
internal int m_blocks_in_MCU;
internal int[] m_MCU_membership = new int[JpegConstants.CompressorMaxBlocksInMCU];
internal int m_Ss;
internal int m_Se;
internal int m_Ah;
internal int m_Al;
internal JpegCompressorMaster m_master;
internal JpegCompressorMainController m_main;
internal JpegCompressorPrepController m_prep;
internal JpegCompressorCoefController m_coef;
internal JpegMarkerWriter m_marker;
internal ColorConverter m_cconvert;
internal JpegDownsampler m_downsample;
internal JpegFowardDCT m_fdct;
internal JpegEntropyEncoder m_entropy;
internal JpegScanInfo[] m_script_space;
internal int m_script_space_size;
public JpegCompressor()
: base()
{
initialize();
}
public override bool IsDecompressor
{
get { return false; }
}
public LibJpeg.DestinationManager Dest
{
get { return m_dest; }
set { m_dest = value; }
}
public int Image_width
{
get { return m_image_width; }
set { m_image_width = value; }
}
public int Image_height
{
get { return m_image_height; }
set { m_image_height = value; }
}
public int Input_components
{
get { return m_input_components; }
set { m_input_components = value; }
}
public LibJpeg.ColorSpace In_color_space
{
get { return m_in_color_space; }
set { m_in_color_space = value; }
}
public int Data_precision
{
get { return m_data_precision; }
set { m_data_precision = value; }
}
public int Num_components
{
get { return m_num_components; }
set { m_num_components = value; }
}
public ColorSpace Jpeg_color_space
{
get { return m_jpeg_color_space; }
set { m_jpeg_color_space = value; }
}
public bool Raw_data_in
{
get { return m_raw_data_in; }
set { m_raw_data_in = value; }
}
public bool Optimize_coding
{
get { return m_optimize_coding; }
set { m_optimize_coding = value; }
}
public bool CCIR601_sampling
{
get { return m_CCIR601_sampling; }
set { m_CCIR601_sampling = value; }
}
public int Smoothing_factor
{
get { return m_smoothing_factor; }
set { m_smoothing_factor = value; }
}
public DCTMethod Dct_method
{
get { return m_dct_method; }
set { m_dct_method = value; }
}
public int Restart_interval
{
get { return m_restart_interval; }
set { m_restart_interval = value; }
}
public int Restart_in_rows
{
get { return m_restart_in_rows; }
set { m_restart_in_rows = value; }
}
public bool Write_JFIF_header
{
get { return m_write_JFIF_header; }
set { m_write_JFIF_header = value; }
}
public byte JFIF_major_version
{
get { return m_JFIF_major_version; }
set { m_JFIF_major_version = value; }
}
public byte JFIF_minor_version
{
get { return m_JFIF_minor_version; }
set { m_JFIF_minor_version = value; }
}
public DensityUnit Density_unit
{
get { return m_density_unit; }
set { m_density_unit = value; }
}
public short X_density
{
get { return m_X_density; }
set { m_X_density = value; }
}
public short Y_density
{
get { return m_Y_density; }
set { m_Y_density = value; }
}
public bool Write_Adobe_marker
{
get { return m_write_Adobe_marker; }
set { m_write_Adobe_marker = value; }
}
public int Max_v_samp_factor
{
get { return m_max_v_samp_factor; }
}
public JpegComponent[] Component_info
{
get { return m_comp_info; }
}
public JpegQuantizationTable[] Quant_tbl_ptrs
{
get { return m_quant_tbl_ptrs; }
}
public JpegHuffmanTable[] Dc_huff_tbl_ptrs
{
get { return m_dc_huff_tbl_ptrs; }
}
public JpegHuffmanTable[] Ac_huff_tbl_ptrs
{
get { return m_ac_huff_tbl_ptrs; }
}
public int Next_scanline
{
get { return m_next_scanline; }
}
public void jpeg_abort_compress()
{
jpeg_abort();
}
public void jpeg_suppress_tables(bool suppress)
{
for (int i = 0; i < JpegConstants.NumberOfQuantTables; i++)
{
if (m_quant_tbl_ptrs[i] != null)
m_quant_tbl_ptrs[i].Sent_table = suppress;
}
for (int i = 0; i < JpegConstants.NumberOfHuffmanTables; i++)
{
if (m_dc_huff_tbl_ptrs[i] != null)
m_dc_huff_tbl_ptrs[i].Sent_table = suppress;
if (m_ac_huff_tbl_ptrs[i] != null)
m_ac_huff_tbl_ptrs[i].Sent_table = suppress;
}
}
public void jpeg_finish_compress()
{
int iMCU_row;
if (m_global_state == JpegState.CSTATE_SCANNING || m_global_state == JpegState.CSTATE_RAW_OK)
{
if (m_next_scanline < m_image_height)
throw new Exception("Application transferred too few scanlines");
m_master.finish_pass();
}
else if (m_global_state != JpegState.CSTATE_WRCOEFS)
throw new Exception(String.Format("Improper call to JPEG library in state {0}", (int)m_global_state));
while (!m_master.IsLastPass())
{
m_master.prepare_for_pass();
for (iMCU_row = 0; iMCU_row < m_total_iMCU_rows; iMCU_row++)
{
if (!m_coef.compress_data(null))
throw new Exception("Suspension not allowed here");
}
m_master.finish_pass();
}
m_marker.write_file_trailer();
m_dest.term_destination();
jpeg_abort();
}
public void jpeg_write_marker(int marker, byte[] data)
{
if (m_next_scanline != 0 || (m_global_state != JpegState.CSTATE_SCANNING && m_global_state != JpegState.CSTATE_RAW_OK && m_global_state != JpegState.CSTATE_WRCOEFS))
throw new Exception(String.Format("Improper call to JPEG library in state {0}", (int)m_global_state));
m_marker.write_marker_header(marker, data.Length);
for (int i = 0; i < data.Length; i++)
m_marker.write_marker_byte(data[i]);
}
public void jpeg_write_m_header(int marker, int datalen)
{
if (m_next_scanline != 0 || (m_global_state != JpegState.CSTATE_SCANNING && m_global_state != JpegState.CSTATE_RAW_OK && m_global_state != JpegState.CSTATE_WRCOEFS))
throw new Exception(String.Format("Improper call to JPEG library in state {0}", (int)m_global_state));
m_marker.write_marker_header(marker, datalen);
}
public void jpeg_write_m_byte(byte val)
{
m_marker.write_marker_byte(val);
}
public void jpeg_write_tables()
{
if (m_global_state != JpegState.CSTATE_START)
throw new Exception(String.Format("Improper call to JPEG library in state {0}", (int)m_global_state));
m_dest.init_destination();
m_marker = new JpegMarkerWriter(this);
m_marker.write_tables_only();
m_dest.term_destination();
}
public void jpeg_stdio_dest(Stream outfile)
{
m_dest = new DestinationManagerImpl(this, outfile);
}
public void jpeg_set_defaults()
{
if (m_global_state != JpegState.CSTATE_START)
throw new Exception(String.Format("Improper call to JPEG library in state {0}", (int)m_global_state));
if (m_comp_info == null)
{
m_comp_info = JpegComponent.createArrayOfComponents(JpegConstants.MaxComponents);
}
m_data_precision = JpegConstants.BitsInSample;
jpeg_set_quality(75, true);
std_huff_tables();
m_scan_info = null;
m_num_scans = 0;
m_raw_data_in = false;
m_optimize_coding = false;
if (m_data_precision > 8)
m_optimize_coding = true;
m_CCIR601_sampling = false;
m_smoothing_factor = 0;
m_dct_method = JpegConstants.DefaultDCTMethod;
m_restart_interval = 0;
m_restart_in_rows = 0;
m_JFIF_major_version = 1;
m_JFIF_minor_version = 1;
m_density_unit = DensityUnit.Unknown;
m_X_density = 1;
m_Y_density = 1;
jpeg_default_colorspace();
}
public void jpeg_set_colorspace(ColorSpace colorspace)
{
int ci;
if (m_global_state != JpegState.CSTATE_START)
throw new Exception(String.Format("Improper call to JPEG library in state {0}", (int)m_global_state));
m_jpeg_color_space = colorspace;
m_write_JFIF_header = false;
m_write_Adobe_marker = false;
switch (colorspace)
{
case ColorSpace.Grayscale:
m_write_JFIF_header = true;
m_num_components = 1;
jpeg_set_colorspace_SET_COMP(0, 1, 1, 1, 0, 0, 0);
break;
case ColorSpace.RGB:
m_write_Adobe_marker = true;
m_num_components = 3;
jpeg_set_colorspace_SET_COMP(0, 0x52, 1, 1, 0, 0, 0);
jpeg_set_colorspace_SET_COMP(1, 0x47, 1, 1, 0, 0, 0);
jpeg_set_colorspace_SET_COMP(2, 0x42, 1, 1, 0, 0, 0);
break;
case ColorSpace.YCbCr:
m_write_JFIF_header = true;
m_num_components = 3;
jpeg_set_colorspace_SET_COMP(0, 1, 2, 2, 0, 0, 0);
jpeg_set_colorspace_SET_COMP(1, 2, 1, 1, 1, 1, 1);
jpeg_set_colorspace_SET_COMP(2, 3, 1, 1, 1, 1, 1);
break;
case ColorSpace.CMYK:
m_write_Adobe_marker = true;
m_num_components = 4;
jpeg_set_colorspace_SET_COMP(0, 0x43, 1, 1, 0, 0, 0);
jpeg_set_colorspace_SET_COMP(1, 0x4D, 1, 1, 0, 0, 0);
jpeg_set_colorspace_SET_COMP(2, 0x59, 1, 1, 0, 0, 0);
jpeg_set_colorspace_SET_COMP(3, 0x4B, 1, 1, 0, 0, 0);
break;
case ColorSpace.YCCK:
m_write_Adobe_marker = true;
m_num_components = 4;
jpeg_set_colorspace_SET_COMP(0, 1, 2, 2, 0, 0, 0);
jpeg_set_colorspace_SET_COMP(1, 2, 1, 1, 1, 1, 1);
jpeg_set_colorspace_SET_COMP(2, 3, 1, 1, 1, 1, 1);
jpeg_set_colorspace_SET_COMP(3, 4, 2, 2, 0, 0, 0);
break;
case ColorSpace.Unknown:
m_num_components = m_input_components;
if (m_num_components < 1 || m_num_components > JpegConstants.MaxComponents)
throw new Exception(String.Format("Too many color components: {0}, max {1}", m_num_components, JpegConstants.MaxComponents));
for (ci = 0; ci < m_num_components; ci++)
{
jpeg_set_colorspace_SET_COMP(ci, ci, 1, 1, 0, 0, 0);
}
break;
default:
throw new Exception("Bad Jpeg ColorSpace.");
}
}
public void jpeg_default_colorspace()
{
switch (m_in_color_space)
{
case ColorSpace.Grayscale:
jpeg_set_colorspace(ColorSpace.Grayscale);
break;
case ColorSpace.RGB:
jpeg_set_colorspace(ColorSpace.YCbCr);
break;
case ColorSpace.YCbCr:
jpeg_set_colorspace(ColorSpace.YCbCr);
break;
case ColorSpace.CMYK:
jpeg_set_colorspace(ColorSpace.CMYK);
break;
case ColorSpace.YCCK:
jpeg_set_colorspace(ColorSpace.YCCK);
break;
case ColorSpace.Unknown:
jpeg_set_colorspace(ColorSpace.Unknown);
break;
default:
throw new Exception("Bad input colorspace!");
}
}
public void jpeg_set_quality(int quality, bool force_baseline)
{
quality = jpeg_quality_scaling(quality);
jpeg_set_linear_quality(quality, force_baseline);
}
public void jpeg_set_linear_quality(int scale_factor, bool force_baseline)
{
jpeg_add_quant_table(0, std_luminance_quant_tbl, scale_factor, force_baseline);
jpeg_add_quant_table(1, std_chrominance_quant_tbl, scale_factor, force_baseline);
}
public void jpeg_add_quant_table(int which_tbl, int[] basic_table, int scale_factor, bool force_baseline)
{
if (m_global_state != JpegState.CSTATE_START)
throw new Exception(String.Format("Improper call to JPEG library in state {0}", (int)m_global_state));
if (which_tbl < 0 || which_tbl >= JpegConstants.NumberOfQuantTables)
throw new Exception(String.Format("Bogus DQT index {0}", which_tbl));
if (m_quant_tbl_ptrs[which_tbl] == null)
m_quant_tbl_ptrs[which_tbl] = new JpegQuantizationTable();
for (int i = 0; i < JpegConstants.DCTSize2; i++)
{
int temp = (basic_table[i] * scale_factor + 50) / 100;
if (temp <= 0)
temp = 1;
if (temp > 32767)
temp = 32767;
if (force_baseline && temp > 255)
temp = 255;
m_quant_tbl_ptrs[which_tbl].quantval[i] = (short)temp;
}
m_quant_tbl_ptrs[which_tbl].Sent_table = false;
}
public static int jpeg_quality_scaling(int quality)
{
if (quality <= 0)
quality = 1;
if (quality > 100)
quality = 100;
if (quality < 50)
quality = 5000 / quality;
else
quality = 200 - quality * 2;
return quality;
}
public void jpeg_simple_progression()
{
if (m_global_state != JpegState.CSTATE_START)
throw new Exception(String.Format("Improper call to JPEG library in state {0}", (int)m_global_state));
int nscans;
if (m_num_components == 3 && m_jpeg_color_space == ColorSpace.YCbCr)
{
nscans = 10;
}
else
{
if (m_num_components > JpegConstants.MaxComponentsInScan)
{
nscans = 6 * m_num_components;
}
else
{
nscans = 2 + 4 * m_num_components;
}
}
if (m_script_space == null || m_script_space_size < nscans)
{
m_script_space_size = Math.Max(nscans, 10);
m_script_space = new JpegScanInfo[m_script_space_size];
for (int i = 0; i < m_script_space_size; i++)
m_script_space[i] = new JpegScanInfo();
}
m_scan_info = m_script_space;
m_num_scans = nscans;
int scanIndex = 0;
if (m_num_components == 3 && m_jpeg_color_space == ColorSpace.YCbCr)
{
fill_dc_scans(ref scanIndex, m_num_components, 0, 1);
fill_a_scan(ref scanIndex, 0, 1, 5, 0, 2);
fill_a_scan(ref scanIndex, 2, 1, 63, 0, 1);
fill_a_scan(ref scanIndex, 1, 1, 63, 0, 1);
fill_a_scan(ref scanIndex, 0, 6, 63, 0, 2);
fill_a_scan(ref scanIndex, 0, 1, 63, 2, 1);
fill_dc_scans(ref scanIndex, m_num_components, 1, 0);
fill_a_scan(ref scanIndex, 2, 1, 63, 1, 0);
fill_a_scan(ref scanIndex, 1, 1, 63, 1, 0);
fill_a_scan(ref scanIndex, 0, 1, 63, 1, 0);
}
else
{
fill_dc_scans(ref scanIndex, m_num_components, 0, 1);
fill_scans(ref scanIndex, m_num_components, 1, 5, 0, 2);
fill_scans(ref scanIndex, m_num_components, 6, 63, 0, 2);
fill_scans(ref scanIndex, m_num_components, 1, 63, 2, 1);
fill_dc_scans(ref scanIndex, m_num_components, 1, 0);
fill_scans(ref scanIndex, m_num_components, 1, 63, 1, 0);
}
}
public void jpeg_start_compress(bool write_all_tables)
{
if (m_global_state != JpegState.CSTATE_START)
throw new Exception(String.Format("Improper call to JPEG library in state {0}", (int)m_global_state));
if (write_all_tables)
jpeg_suppress_tables(false);
m_dest.init_destination();
jinit_compress_master();
m_master.prepare_for_pass();
m_next_scanline = 0;
m_global_state = (m_raw_data_in ? JpegState.CSTATE_RAW_OK : JpegState.CSTATE_SCANNING);
}
public int jpeg_write_scanlines(byte[][] scanlines, int num_lines)
{
if (m_global_state != JpegState.CSTATE_SCANNING)
throw new Exception(String.Format("Improper call to JPEG library in state {0}", (int)m_global_state));
if (m_master.MustCallPassStartup())
m_master.pass_startup();
int rows_left = m_image_height - m_next_scanline;
if (num_lines > rows_left)
num_lines = rows_left;
int row_ctr = 0;
m_main.process_data(scanlines, ref row_ctr, num_lines);
m_next_scanline += row_ctr;
return row_ctr;
}
public int jpeg_write_raw_data(byte[][][] data, int num_lines)
{
if (m_global_state != JpegState.CSTATE_RAW_OK)
throw new Exception(String.Format("Improper call to JPEG library in state {0}", (int)m_global_state));
if (m_next_scanline >= m_image_height)
{
return 0;
}
if (m_master.MustCallPassStartup())
m_master.pass_startup();
int lines_per_iMCU_row = m_max_v_samp_factor * JpegConstants.DCTSize;
if (num_lines < lines_per_iMCU_row)
throw new Exception("Buffer passed to JPEG library is too small");
if (!m_coef.compress_data(data))
{
return 0;
}
m_next_scanline += lines_per_iMCU_row;
return lines_per_iMCU_row;
}
public void jpeg_write_coefficients(JpegVirtualArray<JpegBlock>[] coef_arrays)
{
if (m_global_state != JpegState.CSTATE_START)
throw new Exception(String.Format("Improper call to JPEG library in state {0}", (int)m_global_state));
jpeg_suppress_tables(false);
m_dest.init_destination();
transencode_master_selection(coef_arrays);
m_next_scanline = 0;
m_global_state = JpegState.CSTATE_WRCOEFS;
}
private void initialize()
{
m_dest = null;
m_comp_info = null;
for (int i = 0; i < JpegConstants.NumberOfQuantTables; i++)
m_quant_tbl_ptrs[i] = null;
for (int i = 0; i < JpegConstants.NumberOfHuffmanTables; i++)
{
m_dc_huff_tbl_ptrs[i] = null;
m_ac_huff_tbl_ptrs[i] = null;
}
m_script_space = null;
m_global_state = JpegState.CSTATE_START;
}
private void jinit_compress_master()
{
jinit_c_master_control(false);
if (!m_raw_data_in)
{
m_cconvert = new ColorConverter(this);
m_downsample = new JpegDownsampler(this);
m_prep = new JpegCompressorPrepController(this);
}
m_fdct = new JpegFowardDCT(this);
if (m_progressive_mode)
m_entropy = new ProgressiveHuffmanEncoder(this);
else
m_entropy = new HuffEntropyEncoder(this);
m_coef = new CoefControllerImpl(this, (bool)(m_num_scans > 1 || m_optimize_coding));
jinit_c_main_controller(false);
m_marker = new JpegMarkerWriter(this);
m_marker.write_file_header();
}
private void jinit_c_master_control(bool transcode_only)
{
initial_setup();
if (m_scan_info != null)
{
validate_script();
}
else
{
m_progressive_mode = false;
m_num_scans = 1;
}
if (m_progressive_mode)
m_optimize_coding = true;
m_master = new JpegCompressorMaster(this, transcode_only);
}
private void jinit_c_main_controller(bool need_full_buffer)
{
if (m_raw_data_in)
return;
if (need_full_buffer)
throw new Exception("Bogus buffer control mode");
else
m_main = new JpegCompressorMainController(this);
}
private void transencode_master_selection(JpegVirtualArray<JpegBlock>[] coef_arrays)
{
m_input_components = 1;
jinit_c_master_control(true);
if (m_progressive_mode)
m_entropy = new ProgressiveHuffmanEncoder(this);
else
m_entropy = new HuffEntropyEncoder(this);
m_coef = new TransCoefControllerImpl(this, coef_arrays);
m_marker = new JpegMarkerWriter(this);
m_marker.write_file_header();
}
private void initial_setup()
{
if (m_image_height <= 0 || m_image_width <= 0 || m_num_components <= 0 || m_input_components <= 0)
throw new Exception("Empty JPEG image (DNL not supported)");
if (m_image_height > JpegConstants.JpegMaxDimention || m_image_width > JpegConstants.JpegMaxDimention)
throw new Exception(String.Format("Maximum supported image dimension is {0} pixels", (int)JpegConstants.JpegMaxDimention));
long samplesperrow = m_image_width * m_input_components;
int jd_samplesperrow = (int)samplesperrow;
if ((long)jd_samplesperrow != samplesperrow)
throw new Exception("Image too wide for this implementation");
if (m_data_precision != JpegConstants.BitsInSample)
throw new Exception(String.Format("Unsupported JPEG data precision {0}", m_data_precision));
if (m_num_components > JpegConstants.MaxComponents)
throw new Exception(String.Format("Too many color components: {0}, max {1}", m_num_components, JpegConstants.MaxComponents));
m_max_h_samp_factor = 1;
m_max_v_samp_factor = 1;
for (int ci = 0; ci < m_num_components; ci++)
{
if (m_comp_info[ci].H_samp_factor <= 0 || m_comp_info[ci].H_samp_factor > JpegConstants.MaxSamplingFactor ||
m_comp_info[ci].V_samp_factor <= 0 || m_comp_info[ci].V_samp_factor > JpegConstants.MaxSamplingFactor)
{
throw new Exception("Bogus sampling factors");
}
m_max_h_samp_factor = Math.Max(m_max_h_samp_factor, m_comp_info[ci].H_samp_factor);
m_max_v_samp_factor = Math.Max(m_max_v_samp_factor, m_comp_info[ci].V_samp_factor);
}
for (int ci = 0; ci < m_num_components; ci++)
{
m_comp_info[ci].Component_index = ci;
m_comp_info[ci].DCT_scaled_size = JpegConstants.DCTSize;
m_comp_info[ci].Width_in_blocks = JpegUtils.jdiv_round_up(
m_image_width * m_comp_info[ci].H_samp_factor, m_max_h_samp_factor * JpegConstants.DCTSize);
m_comp_info[ci].height_in_blocks = JpegUtils.jdiv_round_up(
m_image_height * m_comp_info[ci].V_samp_factor, m_max_v_samp_factor * JpegConstants.DCTSize);
m_comp_info[ci].downsampled_width = JpegUtils.jdiv_round_up(
m_image_width * m_comp_info[ci].H_samp_factor, m_max_h_samp_factor);
m_comp_info[ci].downsampled_height = JpegUtils.jdiv_round_up(
m_image_height * m_comp_info[ci].V_samp_factor, m_max_v_samp_factor);
m_comp_info[ci].component_needed = true;
}
m_total_iMCU_rows = JpegUtils.jdiv_round_up(m_image_height, m_max_v_samp_factor * JpegConstants.DCTSize);
}
private void validate_script()
{
if (m_num_scans <= 0)
throw new Exception(String.Format("Invalid scan script at entry {0}", 0));
int[][] last_bitpos = new int[JpegConstants.MaxComponents][];
for (int i = 0; i < JpegConstants.MaxComponents; i++)
last_bitpos[i] = new int[JpegConstants.DCTSize2];
bool[] component_sent = new bool[JpegConstants.MaxComponents];
if (m_scan_info[0].Ss != 0 || m_scan_info[0].Se != JpegConstants.DCTSize2 - 1)
{
m_progressive_mode = true;
for (int ci = 0; ci < m_num_components; ci++)
{
for (int coefi = 0; coefi < JpegConstants.DCTSize2; coefi++)
last_bitpos[ci][coefi] = -1;
}
}
else
{
m_progressive_mode = false;
for (int ci = 0; ci < m_num_components; ci++)
component_sent[ci] = false;
}
for (int scanno = 1; scanno <= m_num_scans; scanno++)
{
JpegScanInfo scanInfo = m_scan_info[scanno - 1];
int ncomps = scanInfo.comps_in_scan;
if (ncomps <= 0 || ncomps > JpegConstants.MaxComponentsInScan)
throw new Exception(String.Format("Too many color components: {0}, max {1}", ncomps, JpegConstants.MaxComponentsInScan));
for (int ci = 0; ci < ncomps; ci++)
{
int thisi = scanInfo.component_index[ci];
if (thisi < 0 || thisi >= m_num_components)
throw new Exception(String.Format("Invalid scan script at entry {0}", scanno));
if (ci > 0 && thisi <= scanInfo.component_index[ci - 1])
throw new Exception(String.Format("Invalid scan script at entry {0}", scanno));
}
int Ss = scanInfo.Ss;
int Se = scanInfo.Se;
int Ah = scanInfo.Ah;
int Al = scanInfo.Al;
if (m_progressive_mode)
{
const int MAX_AH_AL = 10;
if (Ss < 0 || Ss >= JpegConstants.DCTSize2 || Se < Ss || Se >= JpegConstants.DCTSize2 ||
Ah < 0 || Ah > MAX_AH_AL || Al < 0 || Al > MAX_AH_AL)
{
throw new Exception(String.Format("Invalid progressive parameters at scan script entry {0}", scanno));
}
if (Ss == 0)
{
if (Se != 0)
throw new Exception(String.Format("Invalid progressive parameters at scan script entry {0}", scanno));
}
else
{
if (ncomps != 1)
throw new Exception(String.Format("Invalid progressive parameters at scan script entry {0}", scanno));
}
for (int ci = 0; ci < ncomps; ci++)
{
int lastBitComponentIndex = scanInfo.component_index[ci];
if (Ss != 0 && last_bitpos[lastBitComponentIndex][0] < 0)
throw new Exception(String.Format("Invalid progressive parameters at scan script entry {0}", scanno));
for (int coefi = Ss; coefi <= Se; coefi++)
{
if (last_bitpos[lastBitComponentIndex][coefi] < 0)
{
if (Ah != 0)
throw new Exception(String.Format("Invalid progressive parameters at scan script entry {0}", scanno));
}
else
{
if (Ah != last_bitpos[lastBitComponentIndex][coefi] || Al != Ah - 1)
throw new Exception(String.Format("Invalid progressive parameters at scan script entry {0}", scanno));
}
last_bitpos[lastBitComponentIndex][coefi] = Al;
}
}
}
else
{
if (Ss != 0 || Se != JpegConstants.DCTSize2 - 1 || Ah != 0 || Al != 0)
throw new Exception(String.Format("Invalid progressive parameters at scan script entry {0}", scanno));
for (int ci = 0; ci < ncomps; ci++)
{
int thisi = scanInfo.component_index[ci];
if (component_sent[thisi])
throw new Exception(String.Format("Invalid scan script at entry {0}", scanno));
component_sent[thisi] = true;
}
}
}
if (m_progressive_mode)
{
for (int ci = 0; ci < m_num_components; ci++)
{
if (last_bitpos[ci][0] < 0)
throw new Exception("Scan script does not transmit all data");
}
}
else
{
for (int ci = 0; ci < m_num_components; ci++)
{
if (!component_sent[ci])
throw new Exception("Scan script does not transmit all data");
}
}
}
private void std_huff_tables()
{
add_huff_table(ref m_dc_huff_tbl_ptrs[0], bits_dc_luminance, val_dc_luminance);
add_huff_table(ref m_ac_huff_tbl_ptrs[0], bits_ac_luminance, val_ac_luminance);
add_huff_table(ref m_dc_huff_tbl_ptrs[1], bits_dc_chrominance, val_dc_chrominance);
add_huff_table(ref m_ac_huff_tbl_ptrs[1], bits_ac_chrominance, val_ac_chrominance);
}
private void add_huff_table(ref JpegHuffmanTable htblptr, byte[] bits, byte[] val)
{
if (htblptr == null)
htblptr = new JpegHuffmanTable();
Buffer.BlockCopy(bits, 0, htblptr.Bits, 0, htblptr.Bits.Length);
int nsymbols = 0;
for (int len = 1; len <= 16; len++)
nsymbols += bits[len];
if (nsymbols < 1 || nsymbols > 256)
throw new Exception("Bogus Huffman table definition");
Buffer.BlockCopy(val, 0, htblptr.Huffval, 0, nsymbols);
htblptr.Sent_table = false;
}
private void fill_a_scan(ref int scanIndex, int ci, int Ss, int Se, int Ah, int Al)
{
m_script_space[scanIndex].comps_in_scan = 1;
m_script_space[scanIndex].component_index[0] = ci;
m_script_space[scanIndex].Ss = Ss;
m_script_space[scanIndex].Se = Se;
m_script_space[scanIndex].Ah = Ah;
m_script_space[scanIndex].Al = Al;
scanIndex++;
}
private void fill_dc_scans(ref int scanIndex, int ncomps, int Ah, int Al)
{
if (ncomps <= JpegConstants.MaxComponentsInScan)
{
m_script_space[scanIndex].comps_in_scan = ncomps;
for (int ci = 0; ci < ncomps; ci++)
m_script_space[scanIndex].component_index[ci] = ci;
m_script_space[scanIndex].Ss = 0;
m_script_space[scanIndex].Se = 0;
m_script_space[scanIndex].Ah = Ah;
m_script_space[scanIndex].Al = Al;
scanIndex++;
}
else
{
fill_scans(ref scanIndex, ncomps, 0, 0, Ah, Al);
}
}
private void fill_scans(ref int scanIndex, int ncomps, int Ss, int Se, int Ah, int Al)
{
for (int ci = 0; ci < ncomps; ci++)
{
m_script_space[scanIndex].comps_in_scan = 1;
m_script_space[scanIndex].component_index[0] = ci;
m_script_space[scanIndex].Ss = Ss;
m_script_space[scanIndex].Se = Se;
m_script_space[scanIndex].Ah = Ah;
m_script_space[scanIndex].Al = Al;
scanIndex++;
}
}
private void jpeg_set_colorspace_SET_COMP(int index, int id, int hsamp, int vsamp, int quant, int dctbl, int actbl)
{
m_comp_info[index].Component_id = id;
m_comp_info[index].H_samp_factor = hsamp;
m_comp_info[index].V_samp_factor = vsamp;
m_comp_info[index].Quant_tbl_no = quant;
m_comp_info[index].Dc_tbl_no = dctbl;
m_comp_info[index].Ac_tbl_no = actbl;
}
}
#endregion
// STOPPED REMOVING COMMENTS HERE.
#region JpegCompressorCoefController
/// <summary>
/// Coefficient buffer control
/// </summary>
interface JpegCompressorCoefController
{
void start_pass(BufferMode pass_mode);
bool compress_data(byte[][][] input_buf);
}
#endregion
#region JpegCompressorMainController
/// <summary>
/// Main buffer control (downsampled-data buffer)
/// </summary>
class JpegCompressorMainController
{
private JpegCompressor m_cinfo;
private int m_cur_iMCU_row; /* number of current iMCU row */
private int m_rowgroup_ctr; /* counts row groups received in iMCU row */
private bool m_suspended; /* remember if we suspended output */
/* If using just a strip buffer, this points to the entire set of buffers
* (we allocate one for each component). In the full-image case, this
* points to the currently accessible strips of the virtual arrays.
*/
private byte[][][] m_buffer = new byte[JpegConstants.MaxComponents][][];
public JpegCompressorMainController(JpegCompressor cinfo)
{
m_cinfo = cinfo;
/* Allocate a strip buffer for each component */
for (int ci = 0; ci < cinfo.m_num_components; ci++)
{
m_buffer[ci] = JpegCommonBase.AllocJpegSamples(
cinfo.Component_info[ci].Width_in_blocks * JpegConstants.DCTSize,
cinfo.Component_info[ci].V_samp_factor * JpegConstants.DCTSize);
}
}
// Initialize for a processing pass.
public void start_pass(BufferMode pass_mode)
{
/* Do nothing in raw-data mode. */
if (m_cinfo.m_raw_data_in)
return;
m_cur_iMCU_row = 0; /* initialize counters */
m_rowgroup_ctr = 0;
m_suspended = false;
if (pass_mode != BufferMode.PassThru)
throw new Exception("Bogus buffer control mode!");
}
/// <summary>
/// Process some data.
/// This routine handles the simple pass-through mode,
/// where we have only a strip buffer.
/// </summary>
public void process_data(byte[][] input_buf, ref int in_row_ctr, int in_rows_avail)
{
while (m_cur_iMCU_row < m_cinfo.m_total_iMCU_rows)
{
/* Read input data if we haven't filled the main buffer yet */
if (m_rowgroup_ctr < JpegConstants.DCTSize)
m_cinfo.m_prep.pre_process_data(input_buf, ref in_row_ctr, in_rows_avail, m_buffer, ref m_rowgroup_ctr, JpegConstants.DCTSize);
/* If we don't have a full iMCU row buffered, return to application for
* more data. Note that preprocessor will always pad to fill the iMCU row
* at the bottom of the image.
*/
if (m_rowgroup_ctr != JpegConstants.DCTSize)
return;
/* Send the completed row to the compressor */
if (!m_cinfo.m_coef.compress_data(m_buffer))
{
/* If compressor did not consume the whole row, then we must need to
* suspend processing and return to the application. In this situation
* we pretend we didn't yet consume the last input row; otherwise, if
* it happened to be the last row of the image, the application would
* think we were done.
*/
if (!m_suspended)
{
in_row_ctr--;
m_suspended = true;
}
return;
}
/* We did finish the row. Undo our little suspension hack if a previous
* call suspended; then mark the main buffer empty.
*/
if (m_suspended)
{
in_row_ctr++;
m_suspended = false;
}
m_rowgroup_ctr = 0;
m_cur_iMCU_row++;
}
}
}
#endregion
#region JpegCompressorMaster
/// <summary>
/// Master control module
/// </summary>
class JpegCompressorMaster
{
private enum c_pass_type
{
main_pass, /* input data, also do first output step */
huff_opt_pass, /* Huffman code optimization pass */
output_pass /* data output pass */
}
private JpegCompressor m_cinfo;
private bool m_call_pass_startup; /* True if pass_startup must be called */
private bool m_is_last_pass; /* True during last pass */
private c_pass_type m_pass_type; /* the type of the current pass */
private int m_pass_number; /* # of passes completed */
private int m_total_passes; /* total # of passes needed */
private int m_scan_number; /* current index in scan_info[] */
public JpegCompressorMaster(JpegCompressor cinfo, bool transcode_only)
{
m_cinfo = cinfo;
if (transcode_only)
{
/* no main pass in transcoding */
if (cinfo.m_optimize_coding)
m_pass_type = c_pass_type.huff_opt_pass;
else
m_pass_type = c_pass_type.output_pass;
}
else
{
/* for normal compression, first pass is always this type: */
m_pass_type = c_pass_type.main_pass;
}
if (cinfo.m_optimize_coding)
m_total_passes = cinfo.m_num_scans * 2;
else
m_total_passes = cinfo.m_num_scans;
}
/// <summary>
/// Per-pass setup.
///
/// This is called at the beginning of each pass. We determine which
/// modules will be active during this pass and give them appropriate
/// start_pass calls.
/// We also set is_last_pass to indicate whether any more passes will
/// be required.
/// </summary>
public void prepare_for_pass()
{
switch (m_pass_type)
{
case c_pass_type.main_pass:
prepare_for_main_pass();
break;
case c_pass_type.huff_opt_pass:
if (!prepare_for_huff_opt_pass())
break;
prepare_for_output_pass();
break;
case c_pass_type.output_pass:
prepare_for_output_pass();
break;
}
m_is_last_pass = (m_pass_number == m_total_passes - 1);
}
/// <summary>
/// Special start-of-pass hook.
///
/// This is called by jpeg_write_scanlines if call_pass_startup is true.
/// In single-pass processing, we need this hook because we don't want to
/// write frame/scan headers during jpeg_start_compress; we want to let the
/// application write COM markers etc. between jpeg_start_compress and the
/// jpeg_write_scanlines loop.
/// In multi-pass processing, this routine is not used.
/// </summary>
public void pass_startup()
{
m_cinfo.m_master.m_call_pass_startup = false; /* reset flag so call only once */
m_cinfo.m_marker.write_frame_header();
m_cinfo.m_marker.write_scan_header();
}
/// <summary>
/// Finish up at end of pass.
/// </summary>
public void finish_pass()
{
/* The entropy coder always needs an end-of-pass call,
* either to analyze statistics or to flush its output buffer.
*/
m_cinfo.m_entropy.finish_pass();
/* Update state for next pass */
switch (m_pass_type)
{
case c_pass_type.main_pass:
/* next pass is either output of scan 0 (after optimization)
* or output of scan 1 (if no optimization).
*/
m_pass_type = c_pass_type.output_pass;
if (!m_cinfo.m_optimize_coding)
m_scan_number++;
break;
case c_pass_type.huff_opt_pass:
/* next pass is always output of current scan */
m_pass_type = c_pass_type.output_pass;
break;
case c_pass_type.output_pass:
/* next pass is either optimization or output of next scan */
if (m_cinfo.m_optimize_coding)
m_pass_type = c_pass_type.huff_opt_pass;
m_scan_number++;
break;
}
m_pass_number++;
}
public bool IsLastPass()
{
return m_is_last_pass;
}
public bool MustCallPassStartup()
{
return m_call_pass_startup;
}
private void prepare_for_main_pass()
{
/* Initial pass: will collect input data, and do either Huffman
* optimization or data output for the first scan.
*/
select_scan_parameters();
per_scan_setup();
if (!m_cinfo.m_raw_data_in)
{
m_cinfo.m_cconvert.start_pass();
m_cinfo.m_prep.start_pass(BufferMode.PassThru);
}
m_cinfo.m_fdct.start_pass();
m_cinfo.m_entropy.start_pass(m_cinfo.m_optimize_coding);
m_cinfo.m_coef.start_pass((m_total_passes > 1 ? BufferMode.SaveAndPass : BufferMode.PassThru));
m_cinfo.m_main.start_pass(BufferMode.PassThru);
if (m_cinfo.m_optimize_coding)
{
/* No immediate data output; postpone writing frame/scan headers */
m_call_pass_startup = false;
}
else
{
/* Will write frame/scan headers at first jpeg_write_scanlines call */
m_call_pass_startup = true;
}
}
private bool prepare_for_huff_opt_pass()
{
/* Do Huffman optimization for a scan after the first one. */
select_scan_parameters();
per_scan_setup();
if (m_cinfo.m_Ss != 0 || m_cinfo.m_Ah == 0)
{
m_cinfo.m_entropy.start_pass(true);
m_cinfo.m_coef.start_pass(BufferMode.CrankDest);
m_call_pass_startup = false;
return false;
}
/* Special case: Huffman DC refinement scans need no Huffman table
* and therefore we can skip the optimization pass for them.
*/
m_pass_type = c_pass_type.output_pass;
m_pass_number++;
return true;
}
private void prepare_for_output_pass()
{
/* Do a data-output pass. */
/* We need not repeat per-scan setup if prior optimization pass did it. */
if (!m_cinfo.m_optimize_coding)
{
select_scan_parameters();
per_scan_setup();
}
m_cinfo.m_entropy.start_pass(false);
m_cinfo.m_coef.start_pass(BufferMode.CrankDest);
/* We emit frame/scan headers now */
if (m_scan_number == 0)
m_cinfo.m_marker.write_frame_header();
m_cinfo.m_marker.write_scan_header();
m_call_pass_startup = false;
}
// Set up the scan parameters for the current scan
private void select_scan_parameters()
{
if (m_cinfo.m_scan_info != null)
{
/* Prepare for current scan --- the script is already validated */
JpegScanInfo scanInfo = m_cinfo.m_scan_info[m_scan_number];
m_cinfo.m_comps_in_scan = scanInfo.comps_in_scan;
for (int ci = 0; ci < scanInfo.comps_in_scan; ci++)
m_cinfo.m_cur_comp_info[ci] = scanInfo.component_index[ci];
m_cinfo.m_Ss = scanInfo.Ss;
m_cinfo.m_Se = scanInfo.Se;
m_cinfo.m_Ah = scanInfo.Ah;
m_cinfo.m_Al = scanInfo.Al;
}
else
{
/* Prepare for single sequential-JPEG scan containing all components */
if (m_cinfo.m_num_components > JpegConstants.MaxComponentsInScan)
throw new Exception(String.Format("Too many color components: {0}, max {1}", m_cinfo.m_num_components, JpegConstants.MaxComponentsInScan));
m_cinfo.m_comps_in_scan = m_cinfo.m_num_components;
for (int ci = 0; ci < m_cinfo.m_num_components; ci++)
m_cinfo.m_cur_comp_info[ci] = ci;
m_cinfo.m_Ss = 0;
m_cinfo.m_Se = JpegConstants.DCTSize2 - 1;
m_cinfo.m_Ah = 0;
m_cinfo.m_Al = 0;
}
}
/// <summary>
/// Do computations that are needed before processing a JPEG scan
/// cinfo.comps_in_scan and cinfo.cur_comp_info[] are already set
/// </summary>
private void per_scan_setup()
{
if (m_cinfo.m_comps_in_scan == 1)
{
/* Non-interleaved (single-component) scan */
int compIndex = m_cinfo.m_cur_comp_info[0];
/* Overall image size in MCUs */
m_cinfo.m_MCUs_per_row = m_cinfo.Component_info[compIndex].Width_in_blocks;
m_cinfo.m_MCU_rows_in_scan = m_cinfo.Component_info[compIndex].height_in_blocks;
/* For non-interleaved scan, always one block per MCU */
m_cinfo.Component_info[compIndex].MCU_width = 1;
m_cinfo.Component_info[compIndex].MCU_height = 1;
m_cinfo.Component_info[compIndex].MCU_blocks = 1;
m_cinfo.Component_info[compIndex].MCU_sample_width = JpegConstants.DCTSize;
m_cinfo.Component_info[compIndex].last_col_width = 1;
/* For non-interleaved scans, it is convenient to define last_row_height
* as the number of block rows present in the last iMCU row.
*/
int tmp = m_cinfo.Component_info[compIndex].height_in_blocks % m_cinfo.Component_info[compIndex].V_samp_factor;
if (tmp == 0)
tmp = m_cinfo.Component_info[compIndex].V_samp_factor;
m_cinfo.Component_info[compIndex].last_row_height = tmp;
/* Prepare array describing MCU composition */
m_cinfo.m_blocks_in_MCU = 1;
m_cinfo.m_MCU_membership[0] = 0;
}
else
{
/* Interleaved (multi-component) scan */
if (m_cinfo.m_comps_in_scan <= 0 || m_cinfo.m_comps_in_scan > JpegConstants.MaxComponentsInScan)
throw new Exception(String.Format("Too many color components: {0}, max {1}", m_cinfo.m_comps_in_scan, JpegConstants.MaxComponentsInScan));
/* Overall image size in MCUs */
m_cinfo.m_MCUs_per_row = JpegUtils.jdiv_round_up(
m_cinfo.m_image_width, m_cinfo.m_max_h_samp_factor * JpegConstants.DCTSize);
m_cinfo.m_MCU_rows_in_scan = JpegUtils.jdiv_round_up(m_cinfo.m_image_height,
m_cinfo.m_max_v_samp_factor * JpegConstants.DCTSize);
m_cinfo.m_blocks_in_MCU = 0;
for (int ci = 0; ci < m_cinfo.m_comps_in_scan; ci++)
{
int compIndex = m_cinfo.m_cur_comp_info[ci];
/* Sampling factors give # of blocks of component in each MCU */
m_cinfo.Component_info[compIndex].MCU_width = m_cinfo.Component_info[compIndex].H_samp_factor;
m_cinfo.Component_info[compIndex].MCU_height = m_cinfo.Component_info[compIndex].V_samp_factor;
m_cinfo.Component_info[compIndex].MCU_blocks = m_cinfo.Component_info[compIndex].MCU_width * m_cinfo.Component_info[compIndex].MCU_height;
m_cinfo.Component_info[compIndex].MCU_sample_width = m_cinfo.Component_info[compIndex].MCU_width * JpegConstants.DCTSize;
/* Figure number of non-dummy blocks in last MCU column & row */
int tmp = m_cinfo.Component_info[compIndex].Width_in_blocks % m_cinfo.Component_info[compIndex].MCU_width;
if (tmp == 0)
tmp = m_cinfo.Component_info[compIndex].MCU_width;
m_cinfo.Component_info[compIndex].last_col_width = tmp;
tmp = m_cinfo.Component_info[compIndex].height_in_blocks % m_cinfo.Component_info[compIndex].MCU_height;
if (tmp == 0)
tmp = m_cinfo.Component_info[compIndex].MCU_height;
m_cinfo.Component_info[compIndex].last_row_height = tmp;
/* Prepare array describing MCU composition */
int mcublks = m_cinfo.Component_info[compIndex].MCU_blocks;
if (m_cinfo.m_blocks_in_MCU + mcublks > JpegConstants.CompressorMaxBlocksInMCU)
throw new Exception("Sampling factors too large for interleaved scan");
while (mcublks-- > 0)
m_cinfo.m_MCU_membership[m_cinfo.m_blocks_in_MCU++] = ci;
}
}
/* Convert restart specified in rows to actual MCU count. */
/* Note that count must fit in 16 bits, so we provide limiting. */
if (m_cinfo.m_restart_in_rows > 0)
{
int nominal = m_cinfo.m_restart_in_rows * m_cinfo.m_MCUs_per_row;
m_cinfo.m_restart_interval = Math.Min(nominal, 65535);
}
}
}
#endregion
#region JpegCompressorPrepController
/// <summary>
/// Compression preprocessing (downsampling input buffer control).
///
/// For the simple (no-context-row) case, we just need to buffer one
/// row group's worth of pixels for the downsampling step. At the bottom of
/// the image, we pad to a full row group by replicating the last pixel row.
/// The downsampler's last output row is then replicated if needed to pad
/// out to a full iMCU row.
///
/// When providing context rows, we must buffer three row groups' worth of
/// pixels. Three row groups are physically allocated, but the row pointer
/// arrays are made five row groups high, with the extra pointers above and
/// below "wrapping around" to point to the last and first real row groups.
/// This allows the downsampler to access the proper context rows.
/// At the top and bottom of the image, we create dummy context rows by
/// copying the first or last real pixel row. This copying could be avoided
/// by pointer hacking as is done in jdmainct.c, but it doesn't seem worth the
/// trouble on the compression side.
/// </summary>
class JpegCompressorPrepController
{
private JpegCompressor m_cinfo;
/* Downsampling input buffer. This buffer holds color-converted data
* until we have enough to do a downsample step.
*/
private byte[][][] m_color_buf = new byte[JpegConstants.MaxComponents][][];
private int m_colorBufRowsOffset;
private int m_rows_to_go; /* counts rows remaining in source image */
private int m_next_buf_row; /* index of next row to store in color_buf */
private int m_this_row_group; /* starting row index of group to process */
private int m_next_buf_stop; /* downsample when we reach this index */
public JpegCompressorPrepController(JpegCompressor cinfo)
{
m_cinfo = cinfo;
/* Allocate the color conversion buffer.
* We make the buffer wide enough to allow the downsampler to edge-expand
* horizontally within the buffer, if it so chooses.
*/
if (cinfo.m_downsample.NeedContextRows())
{
/* Set up to provide context rows */
create_context_buffer();
}
else
{
/* No context, just make it tall enough for one row group */
for (int ci = 0; ci < cinfo.m_num_components; ci++)
{
m_colorBufRowsOffset = 0;
m_color_buf[ci] = JpegCompressor.AllocJpegSamples(
(cinfo.Component_info[ci].Width_in_blocks * JpegConstants.DCTSize * cinfo.m_max_h_samp_factor) / cinfo.Component_info[ci].H_samp_factor,
cinfo.m_max_v_samp_factor);
}
}
}
/// <summary>
/// Initialize for a processing pass.
/// </summary>
public void start_pass(BufferMode pass_mode)
{
if (pass_mode != BufferMode.PassThru)
throw new Exception("Bogus buffer control mode!");
/* Initialize total-height counter for detecting bottom of image */
m_rows_to_go = m_cinfo.m_image_height;
/* Mark the conversion buffer empty */
m_next_buf_row = 0;
/* Preset additional state variables for context mode.
* These aren't used in non-context mode, so we needn't test which mode.
*/
m_this_row_group = 0;
/* Set next_buf_stop to stop after two row groups have been read in. */
m_next_buf_stop = 2 * m_cinfo.m_max_v_samp_factor;
}
public void pre_process_data(byte[][] input_buf, ref int in_row_ctr, int in_rows_avail, byte[][][] output_buf, ref int out_row_group_ctr, int out_row_groups_avail)
{
if (m_cinfo.m_downsample.NeedContextRows())
pre_process_context(input_buf, ref in_row_ctr, in_rows_avail, output_buf, ref out_row_group_ctr, out_row_groups_avail);
else
pre_process_WithoutContext(input_buf, ref in_row_ctr, in_rows_avail, output_buf, ref out_row_group_ctr, out_row_groups_avail);
}
/// <summary>
/// Create the wrapped-around downsampling input buffer needed for context mode.
/// </summary>
private void create_context_buffer()
{
int rgroup_height = m_cinfo.m_max_v_samp_factor;
for (int ci = 0; ci < m_cinfo.m_num_components; ci++)
{
int samplesPerRow = (m_cinfo.Component_info[ci].Width_in_blocks * JpegConstants.DCTSize * m_cinfo.m_max_h_samp_factor) / m_cinfo.Component_info[ci].H_samp_factor;
byte[][] fake_buffer = new byte[5 * rgroup_height][];
for (int i = 1; i < 4 * rgroup_height; i++)
fake_buffer[i] = new byte[samplesPerRow];
/* Allocate the actual buffer space (3 row groups) for this component.
* We make the buffer wide enough to allow the downsampler to edge-expand
* horizontally within the buffer, if it so chooses.
*/
byte[][] true_buffer = JpegCommonBase.AllocJpegSamples(samplesPerRow, 3 * rgroup_height);
/* Copy true buffer row pointers into the middle of the fake row array */
for (int i = 0; i < 3 * rgroup_height; i++)
fake_buffer[rgroup_height + i] = true_buffer[i];
/* Fill in the above and below wraparound pointers */
for (int i = 0; i < rgroup_height; i++)
{
fake_buffer[i] = true_buffer[2 * rgroup_height + i];
fake_buffer[4 * rgroup_height + i] = true_buffer[i];
}
m_color_buf[ci] = fake_buffer;
m_colorBufRowsOffset = rgroup_height;
}
}
/// <summary>
/// Process some data in the simple no-context case.
///
/// Preprocessor output data is counted in "row groups". A row group
/// is defined to be v_samp_factor sample rows of each component.
/// Downsampling will produce this much data from each max_v_samp_factor
/// input rows.
/// </summary>
private void pre_process_WithoutContext(byte[][] input_buf, ref int in_row_ctr, int in_rows_avail, byte[][][] output_buf, ref int out_row_group_ctr, int out_row_groups_avail)
{
while (in_row_ctr < in_rows_avail && out_row_group_ctr < out_row_groups_avail)
{
/* Do color conversion to fill the conversion buffer. */
int inrows = in_rows_avail - in_row_ctr;
int numrows = m_cinfo.m_max_v_samp_factor - m_next_buf_row;
numrows = Math.Min(numrows, inrows);
m_cinfo.m_cconvert.color_convert(input_buf, in_row_ctr, m_color_buf, m_colorBufRowsOffset + m_next_buf_row, numrows);
in_row_ctr += numrows;
m_next_buf_row += numrows;
m_rows_to_go -= numrows;
/* If at bottom of image, pad to fill the conversion buffer. */
if (m_rows_to_go == 0 && m_next_buf_row < m_cinfo.m_max_v_samp_factor)
{
for (int ci = 0; ci < m_cinfo.m_num_components; ci++)
expand_bottom_edge(m_color_buf[ci], m_colorBufRowsOffset, m_cinfo.m_image_width, m_next_buf_row, m_cinfo.m_max_v_samp_factor);
m_next_buf_row = m_cinfo.m_max_v_samp_factor;
}
/* If we've filled the conversion buffer, empty it. */
if (m_next_buf_row == m_cinfo.m_max_v_samp_factor)
{
m_cinfo.m_downsample.downsample(m_color_buf, m_colorBufRowsOffset, output_buf, out_row_group_ctr);
m_next_buf_row = 0;
out_row_group_ctr++;
}
/* If at bottom of image, pad the output to a full iMCU height.
* Note we assume the caller is providing a one-iMCU-height output buffer!
*/
if (m_rows_to_go == 0 && out_row_group_ctr < out_row_groups_avail)
{
for (int ci = 0; ci < m_cinfo.m_num_components; ci++)
{
JpegComponent componentInfo = m_cinfo.Component_info[ci];
expand_bottom_edge(output_buf[ci], 0, componentInfo.Width_in_blocks * JpegConstants.DCTSize,
out_row_group_ctr * componentInfo.V_samp_factor,
out_row_groups_avail * componentInfo.V_samp_factor);
}
out_row_group_ctr = out_row_groups_avail;
break; /* can exit outer loop without test */
}
}
}
/// <summary>
/// Process some data in the context case.
/// </summary>
private void pre_process_context(byte[][] input_buf, ref int in_row_ctr, int in_rows_avail, byte[][][] output_buf, ref int out_row_group_ctr, int out_row_groups_avail)
{
while (out_row_group_ctr < out_row_groups_avail)
{
if (in_row_ctr < in_rows_avail)
{
/* Do color conversion to fill the conversion buffer. */
int inrows = in_rows_avail - in_row_ctr;
int numrows = m_next_buf_stop - m_next_buf_row;
numrows = Math.Min(numrows, inrows);
m_cinfo.m_cconvert.color_convert(input_buf, in_row_ctr, m_color_buf, m_colorBufRowsOffset + m_next_buf_row, numrows);
/* Pad at top of image, if first time through */
if (m_rows_to_go == m_cinfo.m_image_height)
{
for (int ci = 0; ci < m_cinfo.m_num_components; ci++)
{
for (int row = 1; row <= m_cinfo.m_max_v_samp_factor; row++)
JpegUtils.jcopy_sample_rows(m_color_buf[ci], m_colorBufRowsOffset, m_color_buf[ci], m_colorBufRowsOffset - row, 1, m_cinfo.m_image_width);
}
}
in_row_ctr += numrows;
m_next_buf_row += numrows;
m_rows_to_go -= numrows;
}
else
{
/* Return for more data, unless we are at the bottom of the image. */
if (m_rows_to_go != 0)
break;
/* When at bottom of image, pad to fill the conversion buffer. */
if (m_next_buf_row < m_next_buf_stop)
{
for (int ci = 0; ci < m_cinfo.m_num_components; ci++)
expand_bottom_edge(m_color_buf[ci], m_colorBufRowsOffset, m_cinfo.m_image_width, m_next_buf_row, m_next_buf_stop);
m_next_buf_row = m_next_buf_stop;
}
}
/* If we've gotten enough data, downsample a row group. */
if (m_next_buf_row == m_next_buf_stop)
{
m_cinfo.m_downsample.downsample(m_color_buf, m_colorBufRowsOffset + m_this_row_group, output_buf, out_row_group_ctr);
out_row_group_ctr++;
/* Advance pointers with wraparound as necessary. */
m_this_row_group += m_cinfo.m_max_v_samp_factor;
int buf_height = m_cinfo.m_max_v_samp_factor * 3;
if (m_this_row_group >= buf_height)
m_this_row_group = 0;
if (m_next_buf_row >= buf_height)
m_next_buf_row = 0;
m_next_buf_stop = m_next_buf_row + m_cinfo.m_max_v_samp_factor;
}
}
}
/// <summary>
/// Expand an image vertically from height input_rows to height output_rows,
/// by duplicating the bottom row.
/// </summary>
private static void expand_bottom_edge(byte[][] image_data, int rowsOffset, int num_cols, int input_rows, int output_rows)
{
for (int row = input_rows; row < output_rows; row++)
JpegUtils.jcopy_sample_rows(image_data, rowsOffset + input_rows - 1, image_data, row, 1, num_cols);
}
}
#endregion
#region JpegDecompressor
/// <summary>
/// JPEG decompression routine.
/// </summary>
/// <seealso cref="JpegCompressor"/>
public class JpegDecompressor : JpegCommonBase
{
/// <summary>
/// The delegate for application-supplied marker processing methods.
/// </summary>
/// <param name="cinfo">Decompressor.</param>
/// <returns>Return <c>true</c> to indicate success. <c>false</c> should be returned only
/// if you are using a suspending data source and it tells you to suspend.
/// </returns>
/// <remarks>Although the marker code is not explicitly passed, the routine can find it
/// in the <see cref="JpegDecompressor.Unread_marker"/>. At the time of call,
/// the marker proper has been read from the data source module. The processor routine
/// is responsible for reading the marker length word and the remaining parameter bytes, if any.
/// </remarks>
public delegate bool jpeg_marker_parser_method(JpegDecompressor cinfo);
/* Source of compressed data */
internal Jpeg_Source m_src;
internal int m_image_width; /* nominal image width (from SOF marker) */
internal int m_image_height; /* nominal image height */
internal int m_num_components; /* # of color components in JPEG image */
internal ColorSpace m_jpeg_color_space; /* colorspace of JPEG image */
internal ColorSpace m_out_color_space; /* colorspace for output */
internal int m_scale_num;
internal int m_scale_denom; /* fraction by which to scale image */
internal bool m_buffered_image; /* true=multiple output passes */
internal bool m_raw_data_out; /* true=downsampled data wanted */
internal DCTMethod m_dct_method; /* IDCT algorithm selector */
internal bool m_do_fancy_upsampling; /* true=apply fancy up-sampling */
internal bool m_do_block_smoothing; /* true=apply inter-block smoothing */
internal bool m_quantize_colors; /* true=colormapped output wanted */
internal DitherMode m_dither_mode; /* type of color dithering to use */
internal bool m_two_pass_quantize; /* true=use two-pass color quantization */
internal int m_desired_number_of_colors; /* max # colors to use in created colormap */
internal bool m_enable_1pass_quant; /* enable future use of 1-pass quantizer */
internal bool m_enable_external_quant;/* enable future use of external colormap */
internal bool m_enable_2pass_quant; /* enable future use of 2-pass quantizer */
internal int m_output_width; /* scaled image width */
internal int m_output_height; /* scaled image height */
internal int m_out_color_components; /* # of color components in out_color_space */
/* # of color components returned
* output_components is 1 (a colormap index) when quantizing colors;
* otherwise it equals out_color_components.
*/
internal int m_output_components;
internal int m_rec_outbuf_height; /* min recommended height of scanline buffer */
internal int m_actual_number_of_colors; /* number of entries in use */
internal byte[][] m_colormap; /* The color map as a 2-D pixel array */
internal int m_output_scanline; /* 0 .. output_height-1 */
internal int m_input_scan_number; /* Number of SOS markers seen so far */
internal int m_input_iMCU_row; /* Number of iMCU rows completed */
internal int m_output_scan_number; /* Nominal scan number being displayed */
internal int m_output_iMCU_row; /* Number of iMCU rows read */
internal int[][] m_coef_bits; /* -1 or current Al value for each coef */
/* Internal JPEG parameters --- the application usually need not look at
* these fields. Note that the decompressor output side may not use
* any parameters that can change between scans.
*/
/* Quantization and Huffman tables are carried forward across input
* data-streams when processing abbreviated JPEG data-streams.
*/
internal JpegQuantizationTable[] m_quant_tbl_ptrs = new JpegQuantizationTable[JpegConstants.NumberOfQuantTables];
/* ptrs to coefficient quantization tables, or null if not defined */
internal JpegHuffmanTable[] m_dc_huff_tbl_ptrs = new JpegHuffmanTable[JpegConstants.NumberOfHuffmanTables];
internal JpegHuffmanTable[] m_ac_huff_tbl_ptrs = new JpegHuffmanTable[JpegConstants.NumberOfHuffmanTables];
/* ptrs to Huffman coding tables, or null if not defined */
/* These parameters are never carried across data-streams, since they
* are given in SOF/SOS markers or defined to be reset by SOI.
*/
internal int m_data_precision; /* bits of precision in image data */
/* m_comp_info[i] describes component that appears i'th in SOF */
private JpegComponent[] m_comp_info;
internal bool m_progressive_mode; /* true if SOFn specifies progressive mode */
internal int m_restart_interval; /* MCUs per restart interval, or 0 for no restart */
/* These fields record data obtained from optional markers recognized by
* the JPEG library.
*/
internal bool m_saw_JFIF_marker; /* true iff a JFIF APP0 marker was found */
/* Data copied from JFIF marker; only valid if saw_JFIF_marker is true: */
internal byte m_JFIF_major_version; /* JFIF version number */
internal byte m_JFIF_minor_version;
internal DensityUnit m_density_unit; /* JFIF code for pixel size units */
internal short m_X_density; /* Horizontal pixel density */
internal short m_Y_density; /* Vertical pixel density */
internal bool m_saw_Adobe_marker; /* true iff an Adobe APP14 marker was found */
internal byte m_Adobe_transform; /* Color transform code from Adobe marker */
internal bool m_CCIR601_sampling; /* true=first samples are co-sited */
internal List<JpegMarker> m_marker_list; /* Head of list of saved markers */
/* Remaining fields are known throughout decompressor, but generally
* should not be touched by a surrounding application.
*/
/*
* These fields are computed during decompression startup
*/
internal int m_max_h_samp_factor; /* largest h_samp_factor */
internal int m_max_v_samp_factor; /* largest v_samp_factor */
internal int m_min_DCT_scaled_size; /* smallest DCT_scaled_size of any component */
internal int m_total_iMCU_rows; /* # of iMCU rows in image */
/* The coefficient controller's input and output progress is measured in
* units of "iMCU" (interleaved MCU) rows. These are the same as MCU rows
* in fully interleaved JPEG scans, but are used whether the scan is
* interleaved or not. We define an iMCU row as v_samp_factor DCT block
* rows of each component. Therefore, the IDCT output contains
* v_samp_factor*DCT_scaled_size sample rows of a component per iMCU row.
*/
internal byte[] m_sample_range_limit; /* table for fast range-limiting */
internal int m_sampleRangeLimitOffset;
/*
* These fields are valid during any one scan.
* They describe the components and MCUs actually appearing in the scan.
* Note that the decompressor output side must not use these fields.
*/
internal int m_comps_in_scan; /* # of JPEG components in this scan */
internal int[] m_cur_comp_info = new int[JpegConstants.MaxComponentsInScan];
/* *cur_comp_info[i] describes component that appears i'th in SOS */
internal int m_MCUs_per_row; /* # of MCUs across the image */
internal int m_MCU_rows_in_scan; /* # of MCU rows in the image */
internal int m_blocks_in_MCU; /* # of DCT blocks per MCU */
internal int[] m_MCU_membership = new int[JpegConstants.DecompressorMaxBlocksInMCU];
/* MCU_membership[i] is index in cur_comp_info of component owning */
/* i'th block in an MCU */
/* progressive JPEG parameters for scan */
internal int m_Ss;
internal int m_Se;
internal int m_Ah;
internal int m_Al;
/* This field is shared between entropy decoder and marker parser.
* It is either zero or the code of a JPEG marker that has been
* read from the data source, but has not yet been processed.
*/
internal int m_unread_marker;
/*
* Links to decompression sub-objects (methods, private variables of modules)
*/
internal JpegDecompressorMaster m_master;
internal JpegDecompressorMainController m_main;
internal JpegDecompressorCoefController m_coef;
internal JpegDecompressorPostController m_post;
internal JpegInputController m_inputctl;
internal JpegMarkerReader m_marker;
internal JpegEntropyDecoder m_entropy;
internal JpegInverseDCT m_idct;
internal JpegUpsampler m_upsample;
internal ColorDeconverter m_cconvert;
internal ColorQuantizer m_cquantize;
/// <summary>
/// Initializes a new instance of the <see cref="JpegDecompressor"/> class.
/// </summary>
/// <seealso cref="JpegCompressor"/>
public JpegDecompressor()
: base()
{
initialize();
}
/// <summary>
/// Retrieves <c>true</c> because this is a decompressor.
/// </summary>
/// <value><c>true</c></value>
public override bool IsDecompressor
{
get { return true; }
}
/// <summary>
/// Gets or sets the source for decompression.
/// </summary>
/// <value>The source for decompression.</value>
public LibJpeg.Jpeg_Source Src
{
get { return m_src; }
set { m_src = value; }
}
/* Basic description of image --- filled in by jpeg_read_header(). */
/* Application may inspect these values to decide how to process image. */
/// <summary>
/// Gets the width of image, set by <see cref="JpegDecompressor.jpeg_read_header"/>
/// </summary>
/// <value>The width of image.</value>
/// <seealso href="0955150c-4ee7-4b0f-a716-4bda2e85652b.htm" target="_self">Decompression parameter selection</seealso>
public int Image_width
{
get { return m_image_width; }
}
/// <summary>
/// Gets the height of image, set by <see cref="JpegDecompressor.jpeg_read_header"/>
/// </summary>
/// <value>The height of image.</value>
/// <seealso href="0955150c-4ee7-4b0f-a716-4bda2e85652b.htm" target="_self">Decompression parameter selection</seealso>
public int Image_height
{
get { return m_image_height; }
}
/// <summary>
/// Gets the number of color components in JPEG image.
/// </summary>
/// <value>The number of color components.</value>
/// <seealso href="0955150c-4ee7-4b0f-a716-4bda2e85652b.htm" target="_self">Decompression parameter selection</seealso>
public int Num_components
{
get { return m_num_components; }
}
/// <summary>
/// Gets or sets the colorspace of JPEG image.
/// </summary>
/// <value>The colorspace of JPEG image.</value>
/// <seealso href="0955150c-4ee7-4b0f-a716-4bda2e85652b.htm" target="_self">Decompression parameter selection</seealso>
public LibJpeg.ColorSpace Jpeg_color_space
{
get { return m_jpeg_color_space; }
set { m_jpeg_color_space = value; }
}
/// <summary>
/// Gets the list of loaded special markers.
/// </summary>
/// <remarks>All the special markers in the file appear in this list, in order of
/// their occurrence in the file (but omitting any markers of types you didn't ask for)
/// </remarks>
/// <value>The list of loaded special markers.</value>
/// <seealso href="81c88818-a5d7-4550-9ce5-024a768f7b1e.htm" target="_self">Special markers</seealso>
public ReadOnlyCollection<JpegMarker> Marker_list
{
get
{
return m_marker_list.AsReadOnly();
}
}
/* Decompression processing parameters --- these fields must be set before
* calling jpeg_start_decompress(). Note that jpeg_read_header() initializes
* them to default values.
*/
/// <summary>
/// Gets or sets the output color space.
/// </summary>
/// <value>The output color space.</value>
/// <seealso href="0955150c-4ee7-4b0f-a716-4bda2e85652b.htm" target="_self">Decompression parameter selection</seealso>
public LibJpeg.ColorSpace Out_color_space
{
get { return m_out_color_space; }
set { m_out_color_space = value; }
}
/// <summary>
/// Gets or sets the numerator of the fraction of image scaling.
/// </summary>
/// <value>Scale the image by the fraction Scale_num/<see cref="JpegDecompressor.Scale_denom">Scale_denom</see>.
/// Default is 1/1, or no scaling. Currently, the only supported scaling ratios are 1/1, 1/2, 1/4, and 1/8.
/// (The library design allows for arbitrary scaling ratios but this is not likely to be implemented any time soon.)
/// </value>
/// <remarks>Smaller scaling ratios permit significantly faster decoding since fewer pixels
/// need to be processed and a simpler <see cref="DCTMethod">DCT method</see> can be used.</remarks>
/// <seealso cref="JpegDecompressor.Scale_denom"/>
/// <seealso href="0955150c-4ee7-4b0f-a716-4bda2e85652b.htm" target="_self">Decompression parameter selection</seealso>
public int Scale_num
{
get { return m_scale_num; }
set { m_scale_num = value; }
}
/// <summary>
/// Gets or sets the denominator of the fraction of image scaling.
/// </summary>
/// <value>Scale the image by the fraction <see cref="JpegDecompressor.Scale_num">Scale_num</see>/Scale_denom.
/// Default is 1/1, or no scaling. Currently, the only supported scaling ratios are 1/1, 1/2, 1/4, and 1/8.
/// (The library design allows for arbitrary scaling ratios but this is not likely to be implemented any time soon.)
/// </value>
/// <remarks>Smaller scaling ratios permit significantly faster decoding since fewer pixels
/// need to be processed and a simpler <see cref="DCTMethod">DCT method</see> can be used.</remarks>
/// <seealso cref="JpegDecompressor.Scale_num"/>
/// <seealso href="0955150c-4ee7-4b0f-a716-4bda2e85652b.htm" target="_self">Decompression parameter selection</seealso>
public int Scale_denom
{
get { return m_scale_denom; }
set { m_scale_denom = value; }
}
/// <summary>
/// Gets or sets a value indicating whether to use buffered-image mode.
/// </summary>
/// <value><c>true</c> if buffered-image mode is turned on; otherwise, <c>false</c>.</value>
/// <seealso href="6dba59c5-d32e-4dfc-87fe-f9eff7004146.htm" target="_self">Buffered-image mode</seealso>
public bool Buffered_image
{
get { return m_buffered_image; }
set { m_buffered_image = value; }
}
/// <summary>
/// Enable or disable raw data output.
/// </summary>
/// <value><c>true</c> if raw data output is enabled; otherwise, <c>false</c>.</value>
/// <remarks>Default value: <c>false</c><br/>
/// Set this to true before <see cref="JpegDecompressor.jpeg_start_decompress"/>
/// if you need to obtain raw data output.
/// </remarks>
/// <seealso cref="jpeg_read_raw_data"/>
public bool Raw_data_out
{
get { return m_raw_data_out; }
set { m_raw_data_out = value; }
}
/// <summary>
/// Gets or sets the algorithm used for the DCT step.
/// </summary>
/// <value>The algorithm used for the DCT step.</value>
/// <seealso href="0955150c-4ee7-4b0f-a716-4bda2e85652b.htm" target="_self">Decompression parameter selection</seealso>
public LibJpeg.DCTMethod Dct_method
{
get { return m_dct_method; }
set { m_dct_method = value; }
}
/// <summary>
/// Enable or disable up-sampling of chroma components.
/// </summary>
/// <value>If <c>true</c>, do careful up-sampling of chroma components.
/// If <c>false</c>, a faster but sloppier method is used.
/// The visual impact of the sloppier method is often very small.
/// </value>
/// <remarks>Default value: <c>true</c></remarks>
/// <seealso href="0955150c-4ee7-4b0f-a716-4bda2e85652b.htm" target="_self">Decompression parameter selection</seealso>
public bool Do_fancy_upsampling
{
get { return m_do_fancy_upsampling; }
set { m_do_fancy_upsampling = value; }
}
/// <summary>
/// Apply inter-block smoothing in early stages of decoding progressive JPEG files.
/// </summary>
/// <value>If <c>true</c>, inter-block smoothing is applied in early stages of decoding progressive JPEG files;
/// if <c>false</c>, not. Early progression stages look "fuzzy" with smoothing, "blocky" without.</value>
/// <remarks>Default value: <c>true</c><br/>
/// In any case, block smoothing ceases to be applied after the first few AC coefficients are
/// known to full accuracy, so it is relevant only when using
/// <see href="6dba59c5-d32e-4dfc-87fe-f9eff7004146.htm" target="_self">buffered-image mode</see> for progressive images.
/// </remarks>
/// <seealso href="0955150c-4ee7-4b0f-a716-4bda2e85652b.htm" target="_self">Decompression parameter selection</seealso>
public bool Do_block_smoothing
{
get { return m_do_block_smoothing; }
set { m_do_block_smoothing = value; }
}
/// <summary>
/// Colors quantization.
/// </summary>
/// <value>If set <c>true</c>, colormapped output will be delivered.<br/>
/// Default value: <c>false</c>, meaning that full-color output will be delivered.
/// </value>
/// <seealso href="0955150c-4ee7-4b0f-a716-4bda2e85652b.htm" target="_self">Decompression parameter selection</seealso>
public bool Quantize_colors
{
get { return m_quantize_colors; }
set { m_quantize_colors = value; }
}
/* the following are ignored if not quantize_colors: */
/// <summary>
/// Selects color dithering method.
/// </summary>
/// <value>Default value: <see cref="DitherMode.FloydStein"/>.</value>
/// <remarks>Ignored if <see cref="JpegDecompressor.Quantize_colors"/> is <c>false</c>.<br/>
/// At present, ordered dither is implemented only in the single-pass, standard-colormap case.
/// If you ask for ordered dither when <see cref="JpegDecompressor.Two_pass_quantize"/> is <c>true</c>
/// or when you supply an external color map, you'll get F-S dithering.
/// </remarks>
/// <seealso cref="JpegDecompressor.Quantize_colors"/>
/// <seealso href="0955150c-4ee7-4b0f-a716-4bda2e85652b.htm" target="_self">Decompression parameter selection</seealso>
public LibJpeg.DitherMode Dither_mode
{
get { return m_dither_mode; }
set { m_dither_mode = value; }
}
/// <summary>
/// Gets or sets a value indicating whether to use two-pass color quantization.
/// </summary>
/// <value>If <c>true</c>, an extra pass over the image is made to select a custom color map for the image.
/// This usually looks a lot better than the one-size-fits-all colormap that is used otherwise.
/// Ignored when the application supplies its own color map.<br/>
///
/// Default value: <c>true</c>
/// </value>
/// <remarks>Ignored if <see cref="JpegDecompressor.Quantize_colors"/> is <c>false</c>.<br/>
/// </remarks>
/// <seealso cref="JpegDecompressor.Quantize_colors"/>
/// <seealso href="0955150c-4ee7-4b0f-a716-4bda2e85652b.htm" target="_self">Decompression parameter selection</seealso>
public bool Two_pass_quantize
{
get { return m_two_pass_quantize; }
set { m_two_pass_quantize = value; }
}
/// <summary>
/// Maximum number of colors to use in generating a library-supplied color map.
/// </summary>
/// <value>Default value: 256.</value>
/// <remarks>Ignored if <see cref="JpegDecompressor.Quantize_colors"/> is <c>false</c>.<br/>
/// The actual number of colors is returned in a <see cref="JpegDecompressor.Actual_number_of_colors"/>.
/// </remarks>
/// <seealso cref="JpegDecompressor.Quantize_colors"/>
/// <seealso href="0955150c-4ee7-4b0f-a716-4bda2e85652b.htm" target="_self">Decompression parameter selection</seealso>
public int Desired_number_of_colors
{
get { return m_desired_number_of_colors; }
set { m_desired_number_of_colors = value; }
}
/* these are significant only in buffered-image mode: */
/// <summary>
/// Enable future use of 1-pass quantizer.
/// </summary>
/// <value>Default value: <c>false</c></value>
/// <remarks>Significant only in buffered-image mode.</remarks>
/// <seealso href="6dba59c5-d32e-4dfc-87fe-f9eff7004146.htm" target="_self">Buffered-image mode</seealso>
public bool Enable_1pass_quant
{
get { return m_enable_1pass_quant; }
set { m_enable_1pass_quant = value; }
}
/// <summary>
/// Enable future use of external colormap.
/// </summary>
/// <value>Default value: <c>false</c></value>
/// <remarks>Significant only in buffered-image mode.</remarks>
/// <seealso href="6dba59c5-d32e-4dfc-87fe-f9eff7004146.htm" target="_self">Buffered-image mode</seealso>
public bool Enable_external_quant
{
get { return m_enable_external_quant; }
set { m_enable_external_quant = value; }
}
/// <summary>
/// Enable future use of 2-pass quantizer.
/// </summary>
/// <value>Default value: <c>false</c></value>
/// <remarks>Significant only in buffered-image mode.</remarks>
/// <seealso href="6dba59c5-d32e-4dfc-87fe-f9eff7004146.htm" target="_self">Buffered-image mode</seealso>
public bool Enable_2pass_quant
{
get { return m_enable_2pass_quant; }
set { m_enable_2pass_quant = value; }
}
/* Description of actual output image that will be returned to application.
* These fields are computed by jpeg_start_decompress().
* You can also use jpeg_calc_output_dimensions() to determine these values
* in advance of calling jpeg_start_decompress().
*/
/// <summary>
/// Gets the actual width of output image.
/// </summary>
/// <value>The width of output image.</value>
/// <remarks>Computed by <see cref="JpegDecompressor.jpeg_start_decompress"/>.
/// You can also use <see cref="JpegDecompressor.jpeg_calc_output_dimensions"/> to determine this value
/// in advance of calling <see cref="JpegDecompressor.jpeg_start_decompress"/>.</remarks>
/// <seealso cref="JpegDecompressor.Output_height"/>
public int Output_width
{
get { return m_output_width; }
}
/// <summary>
/// Gets the actual height of output image.
/// </summary>
/// <value>The height of output image.</value>
/// <remarks>Computed by <see cref="JpegDecompressor.jpeg_start_decompress"/>.
/// You can also use <see cref="JpegDecompressor.jpeg_calc_output_dimensions"/> to determine this value
/// in advance of calling <see cref="JpegDecompressor.jpeg_start_decompress"/>.</remarks>
/// <seealso cref="JpegDecompressor.Output_width"/>
public int Output_height
{
get { return m_output_height; }
}
/// <summary>
/// Gets the number of color components in <see cref="JpegDecompressor.Out_color_space"/>.
/// </summary>
/// <remarks>Computed by <see cref="JpegDecompressor.jpeg_start_decompress"/>.
/// You can also use <see cref="JpegDecompressor.jpeg_calc_output_dimensions"/> to determine this value
/// in advance of calling <see cref="JpegDecompressor.jpeg_start_decompress"/>.</remarks>
/// <value>The number of color components.</value>
/// <seealso cref="JpegDecompressor.Out_color_space"/>
/// <seealso href="0955150c-4ee7-4b0f-a716-4bda2e85652b.htm" target="_self">Decompression parameter selection</seealso>
public int Out_color_components
{
get { return m_out_color_components; }
}
/// <summary>
/// Gets the number of color components returned.
/// </summary>
/// <remarks>Computed by <see cref="JpegDecompressor.jpeg_start_decompress"/>.
/// You can also use <see cref="JpegDecompressor.jpeg_calc_output_dimensions"/> to determine this value
/// in advance of calling <see cref="JpegDecompressor.jpeg_start_decompress"/>.</remarks>
/// <value>When <see cref="JpegDecompressor.Quantize_colors">quantizing colors</see>,
/// <c>Output_components</c> is 1, indicating a single color map index per pixel.
/// Otherwise it equals to <see cref="JpegDecompressor.Out_color_components"/>.
/// </value>
/// <seealso cref="JpegDecompressor.Out_color_space"/>
/// <seealso href="0955150c-4ee7-4b0f-a716-4bda2e85652b.htm" target="_self">Decompression parameter selection</seealso>
public int Output_components
{
get { return m_output_components; }
}
/// <summary>
/// Gets the recommended height of scanline buffer.
/// </summary>
/// <value>In high-quality modes, <c>Rec_outbuf_height</c> is always 1, but some faster,
/// lower-quality modes set it to larger values (typically 2 to 4).</value>
/// <remarks>Computed by <see cref="JpegDecompressor.jpeg_start_decompress"/>.
/// You can also use <see cref="JpegDecompressor.jpeg_calc_output_dimensions"/> to determine this value
/// in advance of calling <see cref="JpegDecompressor.jpeg_start_decompress"/>.<br/>
///
/// <c>Rec_outbuf_height</c> is the recommended minimum height (in scanlines)
/// of the buffer passed to <see cref="JpegDecompressor.jpeg_read_scanlines"/>.
/// If the buffer is smaller, the library will still work, but time will be wasted due
/// to unnecessary data copying. If you are going to ask for a high-speed processing mode,
/// you may as well go to the trouble of honoring <c>Rec_outbuf_height</c> so as to avoid data copying.
/// (An output buffer larger than <c>Rec_outbuf_height</c> lines is OK, but won't provide
/// any material speed improvement over that height.)
/// </remarks>
/// <seealso href="0955150c-4ee7-4b0f-a716-4bda2e85652b.htm" target="_self">Decompression parameter selection</seealso>
public int Rec_outbuf_height
{
get { return m_rec_outbuf_height; }
}
/* When quantizing colors, the output colormap is described by these fields.
* The application can supply a colormap by setting colormap non-null before
* calling jpeg_start_decompress; otherwise a colormap is created during
* jpeg_start_decompress or jpeg_start_output.
* The map has out_color_components rows and actual_number_of_colors columns.
*/
/// <summary>
/// The number of colors in the color map.
/// </summary>
/// <value>The number of colors in the color map.</value>
/// <seealso cref="JpegDecompressor.Colormap"/>
/// <seealso href="0955150c-4ee7-4b0f-a716-4bda2e85652b.htm" target="_self">Decompression parameter selection</seealso>
public int Actual_number_of_colors
{
get { return m_actual_number_of_colors; }
set { m_actual_number_of_colors = value; }
}
/// <summary>
/// The color map, represented as a 2-D pixel array of <see cref="JpegDecompressor.Out_color_components"/> rows
/// and <see cref="JpegDecompressor.Actual_number_of_colors"/> columns.
/// </summary>
/// <value>Colormap is set to <c>null</c> by <see cref="JpegDecompressor.jpeg_read_header"/>.
/// The application can supply a color map by setting <c>Colormap</c> non-null and setting
/// <see cref="JpegDecompressor.Actual_number_of_colors"/> to the map size.
/// </value>
/// <remarks>Ignored if not quantizing.<br/>
/// Implementation restriction: at present, an externally supplied <c>Colormap</c>
/// is only accepted for 3-component output color spaces.
/// </remarks>
/// <seealso cref="JpegDecompressor.Actual_number_of_colors"/>
/// <seealso cref="JpegDecompressor.Quantize_colors"/>
/// <seealso href="0955150c-4ee7-4b0f-a716-4bda2e85652b.htm" target="_self">Decompression parameter selection</seealso>
public byte[][] Colormap
{
get { return m_colormap; }
set { m_colormap = value; }
}
/* State variables: these variables indicate the progress of decompression.
* The application may examine these but must not modify them.
*/
/* Row index of next scanline to be read from jpeg_read_scanlines().
* Application may use this to control its processing loop, e.g.,
* "while (output_scanline < output_height)".
*/
/// <summary>
/// Gets the number of scanlines returned so far.
/// </summary>
/// <value>The output_scanline.</value>
/// <remarks>Usually you can just use this variable as the loop counter,
/// so that the loop test looks like
/// <c>while (cinfo.Output_scanline &lt; cinfo.Output_height)</c></remarks>
/// <seealso href="9d052723-a7f9-42de-8747-0bd9896f8157.htm" target="_self">Decompression details</seealso>
public int Output_scanline
{
get { return m_output_scanline; }
}
/* Current input scan number and number of iMCU rows completed in scan.
* These indicate the progress of the decompressor input side.
*/
/// <summary>
/// Gets the number of SOS markers seen so far.
/// </summary>
/// <value>The number of SOS markers seen so far.</value>
/// <remarks>Indicates the progress of the decompressor input side.</remarks>
public int Input_scan_number
{
get { return m_input_scan_number; }
}
/// <summary>
/// Gets the number of iMCU rows completed.
/// </summary>
/// <value>The number of iMCU rows completed.</value>
/// <remarks>Indicates the progress of the decompressor input side.</remarks>
public int Input_iMCU_row
{
get { return m_input_iMCU_row; }
}
/* The "output scan number" is the notional scan being displayed by the
* output side. The decompressor will not allow output scan/row number
* to get ahead of input scan/row, but it can fall arbitrarily far behind.
*/
/// <summary>
/// Gets the nominal scan number being displayed.
/// </summary>
/// <value>The nominal scan number being displayed.</value>
public int Output_scan_number
{
get { return m_output_scan_number; }
}
/// <summary>
/// Gets the number of iMCU rows read.
/// </summary>
/// <value>The number of iMCU rows read.</value>
public int Output_iMCU_row
{
get { return m_output_iMCU_row; }
}
/* Current progression status. coef_bits[c][i] indicates the precision
* with which component c's DCT coefficient i (in zigzag order) is known.
* It is -1 when no data has yet been received, otherwise it is the point
* transform (shift) value for the most recent scan of the coefficient
* (thus, 0 at completion of the progression).
* This is null when reading a non-progressive file.
*/
/// <summary>
/// Gets the current progression status..
/// </summary>
/// <value><c>Coef_bits[c][i]</c> indicates the precision with
/// which component c's DCT coefficient i (in zigzag order) is known.
/// It is <c>-1</c> when no data has yet been received, otherwise
/// it is the point transform (shift) value for the most recent scan of the coefficient
/// (thus, 0 at completion of the progression). This is null when reading a non-progressive file.
/// </value>
/// <seealso href="bda5b19b-88e0-44bf-97de-cd30fc61bb65.htm" target="_self">Progressive JPEG support</seealso>
public int[][] Coef_bits
{
get { return m_coef_bits; }
}
// These fields record data obtained from optional markers
// recognized by the JPEG library.
/// <summary>
/// Gets the resolution information from JFIF marker.
/// </summary>
/// <value>The information from JFIF marker.</value>
/// <seealso cref="JpegDecompressor.X_density"/>
/// <seealso cref="JpegDecompressor.Y_density"/>
/// <seealso href="0955150c-4ee7-4b0f-a716-4bda2e85652b.htm" target="_self">Decompression parameter selection</seealso>
public DensityUnit Density_unit
{
get { return m_density_unit; }
}
/// <summary>
/// Gets the horizontal component of pixel ratio.
/// </summary>
/// <value>The horizontal component of pixel ratio.</value>
/// <seealso cref="JpegDecompressor.Y_density"/>
/// <seealso cref="JpegDecompressor.Density_unit"/>
public short X_density
{
get { return m_X_density; }
}
/// <summary>
/// Gets the vertical component of pixel ratio.
/// </summary>
/// <value>The vertical component of pixel ratio.</value>
/// <seealso cref="JpegDecompressor.X_density"/>
/// <seealso cref="JpegDecompressor.Density_unit"/>
public short Y_density
{
get { return m_Y_density; }
}
/// <summary>
/// Gets the data precision.
/// </summary>
/// <value>The data precision.</value>
public int Data_precision
{
get { return m_data_precision; }
//set { m_data_precision = value; }
}
/// <summary>
/// Gets the largest vertical sample factor.
/// </summary>
/// <value>The largest vertical sample factor.</value>
public int Max_v_samp_factor
{
get { return m_max_v_samp_factor; }
//set { m_max_v_samp_factor = value; }
}
/// <summary>
/// Gets the last read and unprocessed JPEG marker.
/// </summary>
/// <value>It is either zero or the code of a JPEG marker that has been
/// read from the data source, but has not yet been processed.
/// </value>
/// <seealso cref="JpegDecompressor.jpeg_set_marker_processor"/>
/// <seealso href="81c88818-a5d7-4550-9ce5-024a768f7b1e.htm" target="_self">Special markers</seealso>
public int Unread_marker
{
get { return m_unread_marker; }
}
/// <summary>
/// Comp_info[i] describes component that appears i'th in SOF
/// </summary>
/// <value>The components in SOF.</value>
/// <seealso cref="JpegComponent"/>
public JpegComponent[] Comp_info
{
get { return m_comp_info; }
internal set { m_comp_info = value; }
}
/// <summary>
/// Sets input stream.
/// </summary>
/// <param name="infile">The input stream.</param>
/// <remarks>
/// The caller must have already opened the stream, and is responsible
/// for closing it after finishing decompression.
/// </remarks>
/// <seealso href="9d052723-a7f9-42de-8747-0bd9896f8157.htm" target="_self">Decompression details</seealso>
public void jpeg_stdio_src(Stream infile)
{
/* The source object and input buffer are made permanent so that a series
* of JPEG images can be read from the same file by calling jpeg_stdio_src
* only before the first one. (If we discarded the buffer at the end of
* one image, we'd likely lose the start of the next one.)
* This makes it unsafe to use this manager and a different source
* manager serially with the same JPEG object. Caveat programmer.
*/
if (m_src == null)
{
/* first time for this JPEG object? */
m_src = new SourceManagerImpl(this);
}
SourceManagerImpl m = m_src as SourceManagerImpl;
if (m != null)
m.Attach(infile);
}
/// <summary>
/// Decompression startup: this will read the source datastream header markers, up to the beginning of the compressed data proper.
/// </summary>
/// <param name="require_image">Read a description of <b>Return Value</b>.</param>
/// <returns>
/// If you pass <c>require_image=true</c> (normal case), you need not check for a
/// <see cref="ReadResult.Header_Tables_Only"/> return code; an abbreviated file will cause
/// an error exit. <see cref="ReadResult.Suspended"/> is only possible if you use a data source
/// module that can give a suspension return.<br/><br/>
///
/// This method will read as far as the first SOS marker (ie, actual start of compressed data),
/// and will save all tables and parameters in the JPEG object. It will also initialize the
/// decompression parameters to default values, and finally return <see cref="ReadResult.Header_Ok"/>.
/// On return, the application may adjust the decompression parameters and then call
/// <see cref="JpegDecompressor.jpeg_start_decompress"/>. (Or, if the application only wanted to
/// determine the image parameters, the data need not be decompressed. In that case, call
/// <see cref="JpegCommonBase.jpeg_abort"/> to release any temporary space.)<br/><br/>
///
/// If an abbreviated (tables only) datastream is presented, the routine will return
/// <see cref="ReadResult.Header_Tables_Only"/> upon reaching EOI. The application may then re-use
/// the JPEG object to read the abbreviated image datastream(s). It is unnecessary (but OK) to call
/// <see cref="JpegCommonBase.jpeg_abort">jpeg_abort</see> in this case.
/// The <see cref="ReadResult.Suspended"/> return code only occurs if the data source module
/// requests suspension of the decompressor. In this case the application should load more source
/// data and then re-call <c>jpeg_read_header</c> to resume processing.<br/><br/>
///
/// If a non-suspending data source is used and <c>require_image</c> is <c>true</c>,
/// then the return code need not be inspected since only <see cref="ReadResult.Header_Ok"/> is possible.
/// </returns>
/// <remarks>Need only initialize JPEG object and supply a data source before calling.<br/>
/// On return, the image dimensions and other info have been stored in the JPEG object.
/// The application may wish to consult this information before selecting decompression parameters.<br/>
/// This routine is now just a front end to <see cref="jpeg_consume_input"/>, with some extra error checking.
/// </remarks>
/// <seealso href="9d052723-a7f9-42de-8747-0bd9896f8157.htm" target="_self">Decompression details</seealso>
/// <seealso href="0955150c-4ee7-4b0f-a716-4bda2e85652b.htm" target="_self">Decompression parameter selection</seealso>
public ReadResult jpeg_read_header(bool require_image)
{
if (m_global_state != JpegState.DSTATE_START && m_global_state != JpegState.DSTATE_INHEADER)
throw new Exception(String.Format("Improper call to JPEG library in state {0}", (int)m_global_state));
ReadResult retcode = jpeg_consume_input();
switch (retcode)
{
case ReadResult.Reached_SOS:
return ReadResult.Header_Ok;
case ReadResult.Reached_EOI:
if (require_image) /* Complain if application wanted an image */
throw new Exception("JPEG datastream contains no image");
/* Reset to start state; it would be safer to require the application to
* call jpeg_abort, but we can't change it now for compatibility reasons.
* A side effect is to free any temporary memory (there shouldn't be any).
*/
jpeg_abort(); /* sets state = DSTATE_START */
return ReadResult.Header_Tables_Only;
case ReadResult.Suspended:
/* no work */
break;
}
return ReadResult.Suspended;
}
//////////////////////////////////////////////////////////////////////////
// Main entry points for decompression
/// <summary>
/// Decompression initialization.
/// </summary>
/// <returns>Returns <c>false</c> if suspended. The return value need be inspected
/// only if a suspending data source is used.
/// </returns>
/// <remarks><see cref="JpegDecompressor.jpeg_read_header">jpeg_read_header</see> must be completed before calling this.<br/>
///
/// If a multipass operating mode was selected, this will do all but the last pass, and thus may take a great deal of time.
/// </remarks>
/// <seealso cref="JpegDecompressor.jpeg_finish_decompress"/>
/// <seealso href="9d052723-a7f9-42de-8747-0bd9896f8157.htm" target="_self">Decompression details</seealso>
public bool jpeg_start_decompress()
{
if (m_global_state == JpegState.DSTATE_READY)
{
/* First call: initialize master control, select active modules */
m_master = new JpegDecompressorMaster(this);
if (m_buffered_image)
{
/* No more work here; expecting jpeg_start_output next */
m_global_state = JpegState.DSTATE_BUFIMAGE;
return true;
}
m_global_state = JpegState.DSTATE_PRELOAD;
}
if (m_global_state == JpegState.DSTATE_PRELOAD)
{
/* If file has multiple scans, absorb them all into the coef buffer */
if (m_inputctl.HasMultipleScans())
{
for (; ; )
{
ReadResult retcode;
/* Absorb some more input */
retcode = m_inputctl.consume_input();
if (retcode == ReadResult.Suspended)
return false;
if (retcode == ReadResult.Reached_EOI)
break;
}
}
m_output_scan_number = m_input_scan_number;
}
else if (m_global_state != JpegState.DSTATE_PRESCAN)
throw new Exception(String.Format("Improper call to JPEG library in state {0}", (int)m_global_state));
/* Perform any dummy output passes, and set up for the final pass */
return output_pass_setup();
}
/// <summary>
/// Read some scanlines of data from the JPEG decompressor.
/// </summary>
/// <param name="scanlines">Buffer for filling.</param>
/// <param name="max_lines">Required number of lines.</param>
/// <returns>The return value will be the number of lines actually read.
/// This may be less than the number requested in several cases, including
/// bottom of image, data source suspension, and operating modes that emit multiple scanlines at a time.
/// </returns>
/// <remarks>We warn about excess calls to <c>jpeg_read_scanlines</c> since this likely signals an
/// application programmer error. However, an oversize buffer <c>(max_lines > scanlines remaining)</c>
/// is not an error.
/// </remarks>
/// <seealso href="9d052723-a7f9-42de-8747-0bd9896f8157.htm" target="_self">Decompression details</seealso>
public int jpeg_read_scanlines(byte[][] scanlines, int max_lines)
{
if (m_global_state != JpegState.DSTATE_SCANNING)
throw new Exception(String.Format("Improper call to JPEG library in state {0}", (int)m_global_state));
if (m_output_scanline >= m_output_height)
{
return 0;
}
/* Process some data */
int row_ctr = 0;
m_main.process_data(scanlines, ref row_ctr, max_lines);
m_output_scanline += row_ctr;
return row_ctr;
}
/// <summary>
/// Finish JPEG decompression.
/// </summary>
/// <returns>Returns <c>false</c> if suspended. The return value need be inspected
/// only if a suspending data source is used.
/// </returns>
/// <remarks>This will normally just verify the file trailer and release temp storage.</remarks>
/// <seealso cref="JpegDecompressor.jpeg_start_decompress"/>
/// <seealso href="9d052723-a7f9-42de-8747-0bd9896f8157.htm" target="_self">Decompression details</seealso>
public bool jpeg_finish_decompress()
{
if ((m_global_state == JpegState.DSTATE_SCANNING || m_global_state == JpegState.DSTATE_RAW_OK) && !m_buffered_image)
{
/* Terminate final pass of non-buffered mode */
if (m_output_scanline < m_output_height)
throw new Exception("Application transferred too few scanlines");
m_master.finish_output_pass();
m_global_state = JpegState.DSTATE_STOPPING;
}
else if (m_global_state == JpegState.DSTATE_BUFIMAGE)
{
/* Finishing after a buffered-image operation */
m_global_state = JpegState.DSTATE_STOPPING;
}
else if (m_global_state != JpegState.DSTATE_STOPPING)
{
/* STOPPING = repeat call after a suspension, anything else is error */
throw new Exception(String.Format("Improper call to JPEG library in state {0}", (int)m_global_state));
}
/* Read until EOI */
while (!m_inputctl.EOIReached())
{
if (m_inputctl.consume_input() == ReadResult.Suspended)
{
/* Suspend, come back later */
return false;
}
}
/* Do final cleanup */
m_src.term_source();
/* We can use jpeg_abort to release memory and reset global_state */
jpeg_abort();
return true;
}
/// <summary>
/// Alternate entry point to read raw data.
/// </summary>
/// <param name="data">The raw data.</param>
/// <param name="max_lines">The number of scanlines for reading.</param>
/// <returns>The number of lines actually read.</returns>
/// <remarks>Replaces <see cref="JpegDecompressor.jpeg_read_scanlines">jpeg_read_scanlines</see>
/// when reading raw downsampled data. Processes exactly one iMCU row per call, unless suspended.
/// </remarks>
public int jpeg_read_raw_data(byte[][][] data, int max_lines)
{
if (m_global_state != JpegState.DSTATE_RAW_OK)
throw new Exception(String.Format("Improper call to JPEG library in state {0}", (int)m_global_state));
if (m_output_scanline >= m_output_height)
{
return 0;
}
/* Verify that at least one iMCU row can be returned. */
int lines_per_iMCU_row = m_max_v_samp_factor * m_min_DCT_scaled_size;
if (max_lines < lines_per_iMCU_row)
throw new Exception("Buffer passed to JPEG library is too small");
int componentCount = data.Length; // maybe we should use max_lines here
ComponentBuffer[] cb = new ComponentBuffer[componentCount];
for (int i = 0; i < componentCount; i++)
{
cb[i] = new ComponentBuffer();
cb[i].SetBuffer(data[i], null, 0);
}
/* Decompress directly into user's buffer. */
if (m_coef.decompress_data(cb) == ReadResult.Suspended)
{
/* suspension forced, can do nothing more */
return 0;
}
/* OK, we processed one iMCU row. */
m_output_scanline += lines_per_iMCU_row;
return lines_per_iMCU_row;
}
//////////////////////////////////////////////////////////////////////////
// Additional entry points for buffered-image mode.
/// <summary>
/// Is there more than one scan?
/// </summary>
/// <returns><c>true</c> if image has more than one scan; otherwise, <c>false</c></returns>
/// <remarks>If you are concerned about maximum performance on baseline JPEG files,
/// you should use <see href="6dba59c5-d32e-4dfc-87fe-f9eff7004146.htm" target="_self">buffered-image mode</see> only
/// when the incoming file actually has multiple scans. This can be tested by calling this method.
/// </remarks>
public bool jpeg_has_multiple_scans()
{
/* Only valid after jpeg_read_header completes */
if (m_global_state < JpegState.DSTATE_READY || m_global_state > JpegState.DSTATE_STOPPING)
throw new Exception(String.Format("Improper call to JPEG library in state {0}", (int)m_global_state));
return m_inputctl.HasMultipleScans();
}
/// <summary>
/// Initialize for an output pass in <see href="6dba59c5-d32e-4dfc-87fe-f9eff7004146.htm" target="_self">buffered-image mode</see>.
/// </summary>
/// <param name="scan_number">Indicates which scan of the input file is to be displayed;
/// the scans are numbered starting at 1 for this purpose.</param>
/// <returns><c>true</c> if done; <c>false</c> if suspended</returns>
/// <seealso cref="JpegDecompressor.jpeg_finish_output"/>
/// <seealso href="6dba59c5-d32e-4dfc-87fe-f9eff7004146.htm" target="_self">Buffered-image mode</seealso>
public bool jpeg_start_output(int scan_number)
{
if (m_global_state != JpegState.DSTATE_BUFIMAGE && m_global_state != JpegState.DSTATE_PRESCAN)
throw new Exception(String.Format("Improper call to JPEG library in state {0}", (int)m_global_state));
/* Limit scan number to valid range */
if (scan_number <= 0)
scan_number = 1;
if (m_inputctl.EOIReached() && scan_number > m_input_scan_number)
scan_number = m_input_scan_number;
m_output_scan_number = scan_number;
/* Perform any dummy output passes, and set up for the real pass */
return output_pass_setup();
}
/// <summary>
/// Finish up after an output pass in <see href="6dba59c5-d32e-4dfc-87fe-f9eff7004146.htm" target="_self">buffered-image mode</see>.
/// </summary>
/// <returns>Returns <c>false</c> if suspended. The return value need be inspected only if a suspending data source is used.</returns>
/// <seealso cref="JpegDecompressor.jpeg_start_output"/>
/// <seealso href="6dba59c5-d32e-4dfc-87fe-f9eff7004146.htm" target="_self">Buffered-image mode</seealso>
public bool jpeg_finish_output()
{
if ((m_global_state == JpegState.DSTATE_SCANNING || m_global_state == JpegState.DSTATE_RAW_OK) && m_buffered_image)
{
/* Terminate this pass. */
/* We do not require the whole pass to have been completed. */
m_master.finish_output_pass();
m_global_state = JpegState.DSTATE_BUFPOST;
}
else if (m_global_state != JpegState.DSTATE_BUFPOST)
{
/* BUFPOST = repeat call after a suspension, anything else is error */
throw new Exception(String.Format("Improper call to JPEG library in state {0}", (int)m_global_state));
}
/* Read markers looking for SOS or EOI */
while (m_input_scan_number <= m_output_scan_number && !m_inputctl.EOIReached())
{
if (m_inputctl.consume_input() == ReadResult.Suspended)
{
/* Suspend, come back later */
return false;
}
}
m_global_state = JpegState.DSTATE_BUFIMAGE;
return true;
}
/// <summary>
/// Indicates if we have finished reading the input file.
/// </summary>
/// <returns><c>true</c> if we have finished reading the input file.</returns>
/// <seealso href="6dba59c5-d32e-4dfc-87fe-f9eff7004146.htm" target="_self">Buffered-image mode</seealso>
public bool jpeg_input_complete()
{
/* Check for valid jpeg object */
if (m_global_state < JpegState.DSTATE_START || m_global_state > JpegState.DSTATE_STOPPING)
throw new Exception(String.Format("Improper call to JPEG library in state {0}", (int)m_global_state));
return m_inputctl.EOIReached();
}
/// <summary>
/// Consume data in advance of what the decompressor requires.
/// </summary>
/// <returns>The result of data consumption.</returns>
/// <remarks>This routine can be called at any time after initializing the JPEG object.
/// It reads some additional data and returns when one of the indicated significant events
/// occurs. If called after the EOI marker is reached, it will immediately return
/// <see cref="ReadResult.Reached_EOI"/> without attempting to read more data.</remarks>
public ReadResult jpeg_consume_input()
{
ReadResult retcode = ReadResult.Suspended;
/* NB: every possible DSTATE value should be listed in this switch */
switch (m_global_state)
{
case JpegState.DSTATE_START:
jpeg_consume_input_start();
retcode = jpeg_consume_input_inHeader();
break;
case JpegState.DSTATE_INHEADER:
retcode = jpeg_consume_input_inHeader();
break;
case JpegState.DSTATE_READY:
/* Can't advance past first SOS until start_decompress is called */
retcode = ReadResult.Reached_SOS;
break;
case JpegState.DSTATE_PRELOAD:
case JpegState.DSTATE_PRESCAN:
case JpegState.DSTATE_SCANNING:
case JpegState.DSTATE_RAW_OK:
case JpegState.DSTATE_BUFIMAGE:
case JpegState.DSTATE_BUFPOST:
case JpegState.DSTATE_STOPPING:
retcode = m_inputctl.consume_input();
break;
default:
throw new Exception(String.Format("Improper call to JPEG library in state {0}", (int)m_global_state));
}
return retcode;
}
/// <summary>
/// Pre-calculate output image dimensions and related values for current decompression parameters.
/// </summary>
/// <remarks>This is allowed for possible use by application. Hence it mustn't do anything
/// that can't be done twice. Also note that it may be called before the master module is initialized!
/// </remarks>
public void jpeg_calc_output_dimensions()
{
// Do computations that are needed before master selection phase
/* Prevent application from calling me at wrong times */
if (m_global_state != JpegState.DSTATE_READY)
throw new Exception(String.Format("Improper call to JPEG library in state {0}", (int)m_global_state));
/* Compute actual output image dimensions and DCT scaling choices. */
if (m_scale_num * 8 <= m_scale_denom)
{
/* Provide 1/8 scaling */
m_output_width = JpegUtils.jdiv_round_up(m_image_width, 8);
m_output_height = JpegUtils.jdiv_round_up(m_image_height, 8);
m_min_DCT_scaled_size = 1;
}
else if (m_scale_num * 4 <= m_scale_denom)
{
/* Provide 1/4 scaling */
m_output_width = JpegUtils.jdiv_round_up(m_image_width, 4);
m_output_height = JpegUtils.jdiv_round_up(m_image_height, 4);
m_min_DCT_scaled_size = 2;
}
else if (m_scale_num * 2 <= m_scale_denom)
{
/* Provide 1/2 scaling */
m_output_width = JpegUtils.jdiv_round_up(m_image_width, 2);
m_output_height = JpegUtils.jdiv_round_up(m_image_height, 2);
m_min_DCT_scaled_size = 4;
}
else
{
/* Provide 1/1 scaling */
m_output_width = m_image_width;
m_output_height = m_image_height;
m_min_DCT_scaled_size = JpegConstants.DCTSize;
}
/* In selecting the actual DCT scaling for each component, we try to
* scale up the chroma components via IDCT scaling rather than upsampling.
* This saves time if the upsampler gets to use 1:1 scaling.
* Note this code assumes that the supported DCT scalings are powers of 2.
*/
for (int ci = 0; ci < m_num_components; ci++)
{
int ssize = m_min_DCT_scaled_size;
while (ssize < JpegConstants.DCTSize &&
(m_comp_info[ci].H_samp_factor * ssize * 2 <= m_max_h_samp_factor * m_min_DCT_scaled_size) &&
(m_comp_info[ci].V_samp_factor * ssize * 2 <= m_max_v_samp_factor * m_min_DCT_scaled_size))
{
ssize = ssize * 2;
}
m_comp_info[ci].DCT_scaled_size = ssize;
}
/* Recompute downsampled dimensions of components;
* application needs to know these if using raw downsampled data.
*/
for (int ci = 0; ci < m_num_components; ci++)
{
/* Size in samples, after IDCT scaling */
m_comp_info[ci].downsampled_width = JpegUtils.jdiv_round_up(
m_image_width * m_comp_info[ci].H_samp_factor * m_comp_info[ci].DCT_scaled_size,
m_max_h_samp_factor * JpegConstants.DCTSize);
m_comp_info[ci].downsampled_height = JpegUtils.jdiv_round_up(
m_image_height * m_comp_info[ci].V_samp_factor * m_comp_info[ci].DCT_scaled_size,
m_max_v_samp_factor * JpegConstants.DCTSize);
}
/* Report number of components in selected colorspace. */
/* Probably this should be in the color conversion module... */
switch (m_out_color_space)
{
case ColorSpace.Grayscale:
m_out_color_components = 1;
break;
case ColorSpace.RGB:
case ColorSpace.YCbCr:
m_out_color_components = 3;
break;
case ColorSpace.CMYK:
case ColorSpace.YCCK:
m_out_color_components = 4;
break;
default:
/* else must be same colorspace as in file */
m_out_color_components = m_num_components;
break;
}
m_output_components = (m_quantize_colors ? 1 : m_out_color_components);
/* See if up-sampler will want to emit more than one row at a time */
if (use_merged_upsample())
m_rec_outbuf_height = m_max_v_samp_factor;
else
m_rec_outbuf_height = 1;
}
/// <summary>
/// Read or write the raw DCT coefficient arrays from a JPEG file (useful for lossless transcoding).
/// </summary>
/// <returns>Returns <c>null</c> if suspended. This case need be checked only
/// if a suspending data source is used.
/// </returns>
/// <remarks>
/// <see cref="JpegDecompressor.jpeg_read_header">jpeg_read_header</see> must be completed before calling this.<br/>
///
/// The entire image is read into a set of virtual coefficient-block arrays, one per component.
/// The return value is an array of virtual-array descriptors.<br/>
///
/// An alternative usage is to simply obtain access to the coefficient arrays during a
/// <see href="6dba59c5-d32e-4dfc-87fe-f9eff7004146.htm" target="_self">buffered-image mode</see> decompression operation. This is allowed after any
/// <see cref="JpegDecompressor.jpeg_finish_output">jpeg_finish_output</see> call. The arrays can be accessed
/// until <see cref="JpegDecompressor.jpeg_finish_decompress">jpeg_finish_decompress</see> is called.
/// Note that any call to the library may reposition the arrays,
/// so don't rely on <see cref="JpegVirtualArray{T}.Access"/> results to stay valid across library calls.
/// </remarks>
public JpegVirtualArray<JpegBlock>[] jpeg_read_coefficients()
{
if (m_global_state == JpegState.DSTATE_READY)
{
/* First call: initialize active modules */
transdecode_master_selection();
m_global_state = JpegState.DSTATE_RDCOEFS;
}
if (m_global_state == JpegState.DSTATE_RDCOEFS)
{
/* Absorb whole file into the coef buffer */
for (; ; )
{
ReadResult retcode;
/* Absorb some more input */
retcode = m_inputctl.consume_input();
if (retcode == ReadResult.Suspended)
return null;
if (retcode == ReadResult.Reached_EOI)
break;
}
/* Set state so that jpeg_finish_decompress does the right thing */
m_global_state = JpegState.DSTATE_STOPPING;
}
/* At this point we should be in state DSTATE_STOPPING if being used
* standalone, or in state DSTATE_BUFIMAGE if being invoked to get access
* to the coefficients during a full buffered-image-mode decompression.
*/
if ((m_global_state == JpegState.DSTATE_STOPPING || m_global_state == JpegState.DSTATE_BUFIMAGE) && m_buffered_image)
return m_coef.GetCoefArrays();
/* Oops, improper usage */
throw new Exception(String.Format("Improper call to JPEG library in state {0}", (int)m_global_state));
}
/// <summary>
/// Initializes the compression object with default parameters, then copy from the source object
/// all parameters needed for lossless transcoding.
/// </summary>
/// <param name="dstinfo">Target JPEG compression object.</param>
/// <remarks>Parameters that can be varied without loss (such as scan script and
/// Huffman optimization) are left in their default states.</remarks>
public void jpeg_copy_critical_parameters(JpegCompressor dstinfo)
{
/* Safety check to ensure start_compress not called yet. */
if (dstinfo.m_global_state != JpegState.CSTATE_START)
throw new Exception(String.Format("Improper call to JPEG library in state {0}", (int)m_global_state));
/* Copy fundamental image dimensions */
dstinfo.m_image_width = m_image_width;
dstinfo.m_image_height = m_image_height;
dstinfo.m_input_components = m_num_components;
dstinfo.m_in_color_space = m_jpeg_color_space;
/* Initialize all parameters to default values */
dstinfo.jpeg_set_defaults();
/* jpeg_set_defaults may choose wrong colorspace, eg YCbCr if input is RGB.
* Fix it to get the right header markers for the image colorspace.
*/
dstinfo.jpeg_set_colorspace(m_jpeg_color_space);
dstinfo.m_data_precision = m_data_precision;
dstinfo.m_CCIR601_sampling = m_CCIR601_sampling;
/* Copy the source's quantization tables. */
for (int tblno = 0; tblno < JpegConstants.NumberOfQuantTables; tblno++)
{
if (m_quant_tbl_ptrs[tblno] != null)
{
if (dstinfo.m_quant_tbl_ptrs[tblno] == null)
dstinfo.m_quant_tbl_ptrs[tblno] = new JpegQuantizationTable();
Buffer.BlockCopy(m_quant_tbl_ptrs[tblno].quantval, 0,
dstinfo.m_quant_tbl_ptrs[tblno].quantval, 0,
dstinfo.m_quant_tbl_ptrs[tblno].quantval.Length * sizeof(short));
dstinfo.m_quant_tbl_ptrs[tblno].Sent_table = false;
}
}
/* Copy the source's per-component info.
* Note we assume jpeg_set_defaults has allocated the dest comp_info array.
*/
dstinfo.m_num_components = m_num_components;
if (dstinfo.m_num_components < 1 || dstinfo.m_num_components > JpegConstants.MaxComponents)
throw new Exception(String.Format("Too many color components: {0}, max {1}", dstinfo.m_num_components, JpegConstants.MaxComponents));
for (int ci = 0; ci < dstinfo.m_num_components; ci++)
{
dstinfo.Component_info[ci].Component_id = m_comp_info[ci].Component_id;
dstinfo.Component_info[ci].H_samp_factor = m_comp_info[ci].H_samp_factor;
dstinfo.Component_info[ci].V_samp_factor = m_comp_info[ci].V_samp_factor;
dstinfo.Component_info[ci].Quant_tbl_no = m_comp_info[ci].Quant_tbl_no;
/* Make sure saved quantization table for component matches the qtable
* slot. If not, the input file re-used this qtable slot.
* IJG encoder currently cannot duplicate this.
*/
int tblno = dstinfo.Component_info[ci].Quant_tbl_no;
if (tblno < 0 || tblno >= JpegConstants.NumberOfQuantTables || m_quant_tbl_ptrs[tblno] == null)
throw new Exception(String.Format("Quantization table 0x{0:X2} was not defined", tblno));
JpegQuantizationTable c_quant = m_comp_info[ci].quant_table;
if (c_quant != null)
{
JpegQuantizationTable slot_quant = m_quant_tbl_ptrs[tblno];
for (int coefi = 0; coefi < JpegConstants.DCTSize2; coefi++)
{
if (c_quant.quantval[coefi] != slot_quant.quantval[coefi])
throw new Exception(String.Format("Cannot transcode due to multiple use of quantization table {0}", tblno));
}
}
/* Note: we do not copy the source's Huffman table assignments;
* instead we rely on jpeg_set_colorspace to have made a suitable choice.
*/
}
/* Also copy JFIF version and resolution information, if available.
* Strictly speaking this isn't "critical" info, but it's nearly
* always appropriate to copy it if available. In particular,
* if the application chooses to copy JFIF 1.02 extension markers from
* the source file, we need to copy the version to make sure we don't
* emit a file that has 1.02 extensions but a claimed version of 1.01.
* We will *not*, however, copy version info from mislabeled "2.01" files.
*/
if (m_saw_JFIF_marker)
{
if (m_JFIF_major_version == 1)
{
dstinfo.m_JFIF_major_version = m_JFIF_major_version;
dstinfo.m_JFIF_minor_version = m_JFIF_minor_version;
}
dstinfo.m_density_unit = m_density_unit;
dstinfo.m_X_density = (short)m_X_density;
dstinfo.m_Y_density = (short)m_Y_density;
}
}
/// <summary>
/// Aborts processing of a JPEG decompression operation.
/// </summary>
/// <seealso cref="JpegCommonBase.jpeg_abort"/>
public void jpeg_abort_decompress()
{
jpeg_abort();
}
/// <summary>
/// Sets processor for special marker.
/// </summary>
/// <param name="marker_code">The marker code.</param>
/// <param name="routine">The processor.</param>
/// <remarks>Allows you to supply your own routine to process
/// COM and/or APPn markers on-the-fly as they are read.
/// </remarks>
/// <seealso href="81c88818-a5d7-4550-9ce5-024a768f7b1e.htm" target="_self">Special markers</seealso>
public void jpeg_set_marker_processor(int marker_code, jpeg_marker_parser_method routine)
{
m_marker.jpeg_set_marker_processor(marker_code, routine);
}
/// <summary>
/// Control saving of COM and APPn markers into <see cref="JpegDecompressor.Marker_list">Marker_list</see>.
/// </summary>
/// <param name="marker_code">The marker type to save (see JpegMarkerType enumeration).<br/>
/// To arrange to save all the special marker types, you need to call this
/// routine 17 times, for COM and APP0-APP15 markers.</param>
/// <param name="length_limit">If the incoming marker is longer than <c>length_limit</c> data bytes,
/// only <c>length_limit</c> bytes will be saved; this parameter allows you to avoid chewing up memory
/// when you only need to see the first few bytes of a potentially large marker. If you want to save
/// all the data, set <c>length_limit</c> to 0xFFFF; that is enough since marker lengths are only 16 bits.
/// As a special case, setting <c>length_limit</c> to 0 prevents that marker type from being saved at all.
/// (That is the default behavior, in fact.)
/// </param>
/// <seealso cref="JpegDecompressor.Marker_list"/>
/// <seealso href="81c88818-a5d7-4550-9ce5-024a768f7b1e.htm" target="_self">Special markers</seealso>
public void jpeg_save_markers(int marker_code, int length_limit)
{
m_marker.jpeg_save_markers(marker_code, length_limit);
}
/// <summary>
/// Determine whether merged upsample/color conversion should be used.
/// CRUCIAL: this must match the actual capabilities of merged upsampler!
/// </summary>
internal bool use_merged_upsample()
{
/* Merging is the equivalent of plain box-filter upsampling */
if (m_do_fancy_upsampling || m_CCIR601_sampling)
return false;
/* UpsamplerImpl only supports YCC=>RGB color conversion */
if (m_jpeg_color_space != ColorSpace.YCbCr || m_num_components != 3 ||
m_out_color_space != ColorSpace.RGB || m_out_color_components != JpegConstants.RGB_PixelLength)
{
return false;
}
/* and it only handles 2h1v or 2h2v sampling ratios */
if (m_comp_info[0].H_samp_factor != 2 || m_comp_info[1].H_samp_factor != 1 ||
m_comp_info[2].H_samp_factor != 1 || m_comp_info[0].V_samp_factor > 2 ||
m_comp_info[1].V_samp_factor != 1 || m_comp_info[2].V_samp_factor != 1)
{
return false;
}
/* furthermore, it doesn't work if we've scaled the IDCTs differently */
if (m_comp_info[0].DCT_scaled_size != m_min_DCT_scaled_size ||
m_comp_info[1].DCT_scaled_size != m_min_DCT_scaled_size ||
m_comp_info[2].DCT_scaled_size != m_min_DCT_scaled_size)
{
return false;
}
/* ??? also need to test for upsample-time rescaling, when & if supported */
/* by golly, it'll work... */
return true;
}
/// <summary>
/// Initialization of JPEG compression objects.
/// The error manager must already be set up (in case memory manager fails).
/// </summary>
private void initialize()
{
/* Zero out pointers to permanent structures. */
m_src = null;
for (int i = 0; i < JpegConstants.NumberOfQuantTables; i++)
m_quant_tbl_ptrs[i] = null;
for (int i = 0; i < JpegConstants.NumberOfHuffmanTables; i++)
{
m_dc_huff_tbl_ptrs[i] = null;
m_ac_huff_tbl_ptrs[i] = null;
}
/* Initialize marker processor so application can override methods
* for COM, APPn markers before calling jpeg_read_header.
*/
m_marker_list = new List<JpegMarker>();
m_marker = new JpegMarkerReader(this);
/* And initialize the overall input controller. */
m_inputctl = new JpegInputController(this);
/* OK, I'm ready */
m_global_state = JpegState.DSTATE_START;
}
/// <summary>
/// Master selection of decompression modules for transcoding (that is, reading
/// raw DCT coefficient arrays from an input JPEG file.)
/// This substitutes for initialization of the full decompressor.
/// </summary>
private void transdecode_master_selection()
{
/* This is effectively a buffered-image operation. */
m_buffered_image = true;
if (m_progressive_mode)
m_entropy = new ProgressiveHuffmanDecoder(this);
else
m_entropy = new HuffEntropyDecoder(this);
/* Always get a full-image coefficient buffer. */
m_coef = new JpegDecompressorCoefController(this, true);
/* Initialize input side of decompressor to consume first scan. */
m_inputctl.start_input_pass();
}
/// <summary>
/// Set up for an output pass, and perform any dummy pass(es) needed.
/// Common subroutine for jpeg_start_decompress and jpeg_start_output.
/// Entry: global_state = DSTATE_PRESCAN only if previously suspended.
/// Exit: If done, returns true and sets global_state for proper output mode.
/// If suspended, returns false and sets global_state = DSTATE_PRESCAN.
/// </summary>
private bool output_pass_setup()
{
if (m_global_state != JpegState.DSTATE_PRESCAN)
{
/* First call: do pass setup */
m_master.prepare_for_output_pass();
m_output_scanline = 0;
m_global_state = JpegState.DSTATE_PRESCAN;
}
/* Loop over any required dummy passes */
while (m_master.IsDummyPass())
{
/* Crank through the dummy pass */
while (m_output_scanline < m_output_height)
{
int last_scanline;
/* Process some data */
last_scanline = m_output_scanline;
m_main.process_data(null, ref m_output_scanline, 0);
if (m_output_scanline == last_scanline)
{
/* No progress made, must suspend */
return false;
}
}
/* Finish up dummy pass, and set up for another one */
m_master.finish_output_pass();
m_master.prepare_for_output_pass();
m_output_scanline = 0;
}
/* Ready for application to drive output pass through
* jpeg_read_scanlines or jpeg_read_raw_data.
*/
m_global_state = m_raw_data_out ? JpegState.DSTATE_RAW_OK : JpegState.DSTATE_SCANNING;
return true;
}
/// <summary>
/// Set default decompression parameters.
/// </summary>
private void default_decompress_parms()
{
/* Guess the input colorspace, and set output colorspace accordingly. */
/* (Wish JPEG committee had provided a real way to specify this...) */
/* Note application may override our guesses. */
switch (m_num_components)
{
case 1:
m_jpeg_color_space = ColorSpace.Grayscale;
m_out_color_space = ColorSpace.Grayscale;
break;
case 3:
if (m_saw_JFIF_marker)
{
/* JFIF implies YCbCr */
m_jpeg_color_space = ColorSpace.YCbCr;
}
else if (m_saw_Adobe_marker)
{
switch (m_Adobe_transform)
{
case 0:
m_jpeg_color_space = ColorSpace.RGB;
break;
case 1:
m_jpeg_color_space = ColorSpace.YCbCr;
break;
default:
m_jpeg_color_space = ColorSpace.YCbCr; /* assume it's YCbCr */
break;
}
}
else
{
/* Saw no special markers, try to guess from the component IDs */
int cid0 = m_comp_info[0].Component_id;
int cid1 = m_comp_info[1].Component_id;
int cid2 = m_comp_info[2].Component_id;
if (cid0 == 1 && cid1 == 2 && cid2 == 3)
{
/* assume JFIF w/out marker */
m_jpeg_color_space = ColorSpace.YCbCr;
}
else if (cid0 == 82 && cid1 == 71 && cid2 == 66)
{
/* ASCII 'R', 'G', 'B' */
m_jpeg_color_space = ColorSpace.RGB;
}
else
{
/* assume it's YCbCr */
m_jpeg_color_space = ColorSpace.YCbCr;
}
}
/* Always guess RGB is proper output colorspace. */
m_out_color_space = ColorSpace.RGB;
break;
case 4:
if (m_saw_Adobe_marker)
{
switch (m_Adobe_transform)
{
case 0:
m_jpeg_color_space = ColorSpace.CMYK;
break;
case 2:
m_jpeg_color_space = ColorSpace.YCCK;
break;
default:
/* assume it's YCCK */
m_jpeg_color_space = ColorSpace.YCCK;
break;
}
}
else
{
/* No special markers, assume straight CMYK. */
m_jpeg_color_space = ColorSpace.CMYK;
}
m_out_color_space = ColorSpace.CMYK;
break;
default:
m_jpeg_color_space = ColorSpace.Unknown;
m_out_color_space = ColorSpace.Unknown;
break;
}
/* Set defaults for other decompression parameters. */
m_scale_num = 1; /* 1:1 scaling */
m_scale_denom = 1;
m_buffered_image = false;
m_raw_data_out = false;
m_dct_method = JpegConstants.DefaultDCTMethod;
m_do_fancy_upsampling = true;
m_do_block_smoothing = true;
m_quantize_colors = false;
/* We set these in case application only sets quantize_colors. */
m_dither_mode = DitherMode.FloydStein;
m_two_pass_quantize = true;
m_desired_number_of_colors = 256;
m_colormap = null;
/* Initialize for no mode change in buffered-image mode. */
m_enable_1pass_quant = false;
m_enable_external_quant = false;
m_enable_2pass_quant = false;
}
private void jpeg_consume_input_start()
{
/* Start-of-datastream actions: reset appropriate modules */
m_inputctl.reset_input_controller();
/* Initialize application's data source module */
m_src.init_source();
m_global_state = JpegState.DSTATE_INHEADER;
}
private ReadResult jpeg_consume_input_inHeader()
{
ReadResult retcode = m_inputctl.consume_input();
if (retcode == ReadResult.Reached_SOS)
{
/* Found SOS, prepare to decompress */
/* Set up default parameters based on header data */
default_decompress_parms();
/* Set global state: ready for start_decompress */
m_global_state = JpegState.DSTATE_READY;
}
return retcode;
}
}
#endregion
#region JpegDecompressorCoefController
/// <summary>
/// Coefficient buffer control
///
/// This code applies interblock smoothing as described by section K.8
/// of the JPEG standard: the first 5 AC coefficients are estimated from
/// the DC values of a DCT block and its 8 neighboring blocks.
/// We apply smoothing only for progressive JPEG decoding, and only if
/// the coefficients it can estimate are not yet known to full precision.
/// </summary>
class JpegDecompressorCoefController
{
private const int SAVED_COEFS = 6; /* we save coef_bits[0..5] */
/* Natural-order array positions of the first 5 zigzag-order coefficients */
private const int Q01_POS = 1;
private const int Q10_POS = 8;
private const int Q20_POS = 16;
private const int Q11_POS = 9;
private const int Q02_POS = 2;
private enum DecompressorType
{
Ordinary,
Smooth,
OnePass
}
private JpegDecompressor m_cinfo;
private bool m_useDummyConsumeData;
private DecompressorType m_decompressor;
/* These variables keep track of the current location of the input side. */
/* cinfo.input_iMCU_row is also used for this. */
private int m_MCU_ctr; /* counts MCUs processed in current row */
private int m_MCU_vert_offset; /* counts MCU rows within iMCU row */
private int m_MCU_rows_per_iMCU_row; /* number of such rows needed */
/* The output side's location is represented by cinfo.output_iMCU_row. */
/* In single-pass modes, it's sufficient to buffer just one MCU.
* We allocate a workspace of DecompressorMaxBlocksInMCU coefficient blocks,
* and let the entropy decoder write into that workspace each time.
* (On 80x86, the workspace is FAR even though it's not really very big;
* this is to keep the module interfaces unchanged when a large coefficient
* buffer is necessary.)
* In multi-pass modes, this array points to the current MCU's blocks
* within the virtual arrays; it is used only by the input side.
*/
private JpegBlock[] m_MCU_buffer = new JpegBlock[JpegConstants.DecompressorMaxBlocksInMCU];
/* In multi-pass modes, we need a virtual block array for each component. */
private JpegVirtualArray<JpegBlock>[] m_whole_image = new JpegVirtualArray<JpegBlock>[JpegConstants.MaxComponents];
private JpegVirtualArray<JpegBlock>[] m_coef_arrays;
/* When doing block smoothing, we latch coefficient Al values here */
private int[] m_coef_bits_latch;
private int m_coef_bits_savedOffset;
public JpegDecompressorCoefController(JpegDecompressor cinfo, bool need_full_buffer)
{
m_cinfo = cinfo;
/* Create the coefficient buffer. */
if (need_full_buffer)
{
/* Allocate a full-image virtual array for each component, */
/* padded to a multiple of samp_factor DCT blocks in each direction. */
/* Note we ask for a pre-zeroed array. */
for (int ci = 0; ci < cinfo.m_num_components; ci++)
{
m_whole_image[ci] = JpegCommonBase.CreateBlocksArray(
JpegUtils.jround_up(cinfo.Comp_info[ci].Width_in_blocks, cinfo.Comp_info[ci].H_samp_factor),
JpegUtils.jround_up(cinfo.Comp_info[ci].height_in_blocks, cinfo.Comp_info[ci].V_samp_factor));
m_whole_image[ci].ErrorProcessor = cinfo;
}
m_useDummyConsumeData = false;
m_decompressor = DecompressorType.Ordinary;
m_coef_arrays = m_whole_image; /* link to virtual arrays */
}
else
{
/* We only need a single-MCU buffer. */
JpegBlock[] buffer = new JpegBlock[JpegConstants.DecompressorMaxBlocksInMCU];
for (int i = 0; i < JpegConstants.DecompressorMaxBlocksInMCU; i++)
{
buffer[i] = new JpegBlock();
for (int ii = 0; ii < buffer[i].data.Length; ii++)
buffer[i].data[ii] = -12851;
m_MCU_buffer[i] = buffer[i];
}
m_useDummyConsumeData = true;
m_decompressor = DecompressorType.OnePass;
m_coef_arrays = null; /* flag for no virtual arrays */
}
}
/// <summary>
/// Initialize for an input processing pass.
/// </summary>
public void start_input_pass()
{
m_cinfo.m_input_iMCU_row = 0;
start_iMCU_row();
}
/// <summary>
/// Consume input data and store it in the full-image coefficient buffer.
/// We read as much as one fully interleaved MCU row ("iMCU" row) per call,
/// ie, v_samp_factor block rows for each component in the scan.
/// </summary>
public ReadResult consume_data()
{
if (m_useDummyConsumeData)
return ReadResult.Suspended; /* Always indicate nothing was done */
JpegBlock[][][] buffer = new JpegBlock[JpegConstants.MaxComponentsInScan][][];
/* Align the virtual buffers for the components used in this scan. */
for (int ci = 0; ci < m_cinfo.m_comps_in_scan; ci++)
{
JpegComponent componentInfo = m_cinfo.Comp_info[m_cinfo.m_cur_comp_info[ci]];
buffer[ci] = m_whole_image[componentInfo.Component_index].Access(
m_cinfo.m_input_iMCU_row * componentInfo.V_samp_factor, componentInfo.V_samp_factor);
/* Note: entropy decoder expects buffer to be zeroed,
* but this is handled automatically by the memory manager
* because we requested a pre-zeroed array.
*/
}
/* Loop to process one whole iMCU row */
for (int yoffset = m_MCU_vert_offset; yoffset < m_MCU_rows_per_iMCU_row; yoffset++)
{
for (int MCU_col_num = m_MCU_ctr; MCU_col_num < m_cinfo.m_MCUs_per_row; MCU_col_num++)
{
/* Construct list of pointers to DCT blocks belonging to this MCU */
int blkn = 0; /* index of current DCT block within MCU */
for (int ci = 0; ci < m_cinfo.m_comps_in_scan; ci++)
{
JpegComponent componentInfo = m_cinfo.Comp_info[m_cinfo.m_cur_comp_info[ci]];
int start_col = MCU_col_num * componentInfo.MCU_width;
for (int yindex = 0; yindex < componentInfo.MCU_height; yindex++)
{
for (int xindex = 0; xindex < componentInfo.MCU_width; xindex++)
{
m_MCU_buffer[blkn] = buffer[ci][yindex + yoffset][start_col + xindex];
blkn++;
}
}
}
/* Try to fetch the MCU. */
if (!m_cinfo.m_entropy.decode_mcu(m_MCU_buffer))
{
/* Suspension forced; update state counters and exit */
m_MCU_vert_offset = yoffset;
m_MCU_ctr = MCU_col_num;
return ReadResult.Suspended;
}
}
/* Completed an MCU row, but perhaps not an iMCU row */
m_MCU_ctr = 0;
}
/* Completed the iMCU row, advance counters for next one */
m_cinfo.m_input_iMCU_row++;
if (m_cinfo.m_input_iMCU_row < m_cinfo.m_total_iMCU_rows)
{
start_iMCU_row();
return ReadResult.Row_Completed;
}
/* Completed the scan */
m_cinfo.m_inputctl.finish_input_pass();
return ReadResult.Scan_Completed;
}
/// <summary>
/// Initialize for an output processing pass.
/// </summary>
public void start_output_pass()
{
/* If multipass, check to see whether to use block smoothing on this pass */
if (m_coef_arrays != null)
{
if (m_cinfo.m_do_block_smoothing && smoothing_ok())
m_decompressor = DecompressorType.Smooth;
else
m_decompressor = DecompressorType.Ordinary;
}
m_cinfo.m_output_iMCU_row = 0;
}
public ReadResult decompress_data(ComponentBuffer[] output_buf)
{
switch (m_decompressor)
{
case DecompressorType.Ordinary:
return decompress_data_ordinary(output_buf);
case DecompressorType.Smooth:
return decompress_smooth_data(output_buf);
case DecompressorType.OnePass:
return decompress_onepass(output_buf);
}
throw new Exception("Not implemented yet");
}
/* Pointer to array of coefficient virtual arrays, or null if none */
public JpegVirtualArray<JpegBlock>[] GetCoefArrays()
{
return m_coef_arrays;
}
/// <summary>
/// Decompress and return some data in the single-pass case.
/// Always attempts to emit one fully interleaved MCU row ("iMCU" row).
/// Input and output must run in lockstep since we have only a one-MCU buffer.
/// Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED.
///
/// NB: output_buf contains a plane for each component in image,
/// which we index according to the component's SOF position.
/// </summary>
private ReadResult decompress_onepass(ComponentBuffer[] output_buf)
{
int last_MCU_col = m_cinfo.m_MCUs_per_row - 1;
int last_iMCU_row = m_cinfo.m_total_iMCU_rows - 1;
/* Loop to process as much as one whole iMCU row */
for (int yoffset = m_MCU_vert_offset; yoffset < m_MCU_rows_per_iMCU_row; yoffset++)
{
for (int MCU_col_num = m_MCU_ctr; MCU_col_num <= last_MCU_col; MCU_col_num++)
{
/* Try to fetch an MCU. Entropy decoder expects buffer to be zeroed. */
for (int i = 0; i < m_cinfo.m_blocks_in_MCU; i++)
Array.Clear(m_MCU_buffer[i].data, 0, m_MCU_buffer[i].data.Length);
if (!m_cinfo.m_entropy.decode_mcu(m_MCU_buffer))
{
/* Suspension forced; update state counters and exit */
m_MCU_vert_offset = yoffset;
m_MCU_ctr = MCU_col_num;
return ReadResult.Suspended;
}
/* Determine where data should go in output_buf and do the IDCT thing.
* We skip dummy blocks at the right and bottom edges (but blkn gets
* incremented past them!). Note the inner loop relies on having
* allocated the MCU_buffer[] blocks sequentially.
*/
int blkn = 0; /* index of current DCT block within MCU */
for (int ci = 0; ci < m_cinfo.m_comps_in_scan; ci++)
{
JpegComponent componentInfo = m_cinfo.Comp_info[m_cinfo.m_cur_comp_info[ci]];
/* Don't bother to IDCT an uninteresting component. */
if (!componentInfo.component_needed)
{
blkn += componentInfo.MCU_blocks;
continue;
}
int useful_width = (MCU_col_num < last_MCU_col) ? componentInfo.MCU_width : componentInfo.last_col_width;
int outputIndex = yoffset * componentInfo.DCT_scaled_size;
int start_col = MCU_col_num * componentInfo.MCU_sample_width;
for (int yindex = 0; yindex < componentInfo.MCU_height; yindex++)
{
if (m_cinfo.m_input_iMCU_row < last_iMCU_row || yoffset + yindex < componentInfo.last_row_height)
{
int output_col = start_col;
for (int xindex = 0; xindex < useful_width; xindex++)
{
m_cinfo.m_idct.inverse(componentInfo.Component_index,
m_MCU_buffer[blkn + xindex].data, output_buf[componentInfo.Component_index],
outputIndex, output_col);
output_col += componentInfo.DCT_scaled_size;
}
}
blkn += componentInfo.MCU_width;
outputIndex += componentInfo.DCT_scaled_size;
}
}
}
/* Completed an MCU row, but perhaps not an iMCU row */
m_MCU_ctr = 0;
}
/* Completed the iMCU row, advance counters for next one */
m_cinfo.m_output_iMCU_row++;
m_cinfo.m_input_iMCU_row++;
if (m_cinfo.m_input_iMCU_row < m_cinfo.m_total_iMCU_rows)
{
start_iMCU_row();
return ReadResult.Row_Completed;
}
/* Completed the scan */
m_cinfo.m_inputctl.finish_input_pass();
return ReadResult.Scan_Completed;
}
/// <summary>
/// Decompress and return some data in the multi-pass case.
/// Always attempts to emit one fully interleaved MCU row ("iMCU" row).
/// Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED.
///
/// NB: output_buf contains a plane for each component in image.
/// </summary>
private ReadResult decompress_data_ordinary(ComponentBuffer[] output_buf)
{
/* Force some input to be done if we are getting ahead of the input. */
while (m_cinfo.m_input_scan_number < m_cinfo.m_output_scan_number ||
(m_cinfo.m_input_scan_number == m_cinfo.m_output_scan_number &&
m_cinfo.m_input_iMCU_row <= m_cinfo.m_output_iMCU_row))
{
if (m_cinfo.m_inputctl.consume_input() == ReadResult.Suspended)
return ReadResult.Suspended;
}
int last_iMCU_row = m_cinfo.m_total_iMCU_rows - 1;
/* OK, output from the virtual arrays. */
for (int ci = 0; ci < m_cinfo.m_num_components; ci++)
{
JpegComponent componentInfo = m_cinfo.Comp_info[ci];
/* Don't bother to IDCT an uninteresting component. */
if (!componentInfo.component_needed)
continue;
/* Align the virtual buffer for this component. */
JpegBlock[][] buffer = m_whole_image[ci].Access(m_cinfo.m_output_iMCU_row * componentInfo.V_samp_factor,
componentInfo.V_samp_factor);
/* Count non-dummy DCT block rows in this iMCU row. */
int block_rows;
if (m_cinfo.m_output_iMCU_row < last_iMCU_row)
block_rows = componentInfo.V_samp_factor;
else
{
/* NB: can't use last_row_height here; it is input-side-dependent! */
block_rows = componentInfo.height_in_blocks % componentInfo.V_samp_factor;
if (block_rows == 0)
block_rows = componentInfo.V_samp_factor;
}
/* Loop over all DCT blocks to be processed. */
int rowIndex = 0;
for (int block_row = 0; block_row < block_rows; block_row++)
{
int output_col = 0;
for (int block_num = 0; block_num < componentInfo.Width_in_blocks; block_num++)
{
m_cinfo.m_idct.inverse(componentInfo.Component_index,
buffer[block_row][block_num].data, output_buf[ci], rowIndex, output_col);
output_col += componentInfo.DCT_scaled_size;
}
rowIndex += componentInfo.DCT_scaled_size;
}
}
m_cinfo.m_output_iMCU_row++;
if (m_cinfo.m_output_iMCU_row < m_cinfo.m_total_iMCU_rows)
return ReadResult.Row_Completed;
return ReadResult.Scan_Completed;
}
/// <summary>
/// Variant of decompress_data for use when doing block smoothing.
/// </summary>
private ReadResult decompress_smooth_data(ComponentBuffer[] output_buf)
{
/* Force some input to be done if we are getting ahead of the input. */
while (m_cinfo.m_input_scan_number <= m_cinfo.m_output_scan_number && !m_cinfo.m_inputctl.EOIReached())
{
if (m_cinfo.m_input_scan_number == m_cinfo.m_output_scan_number)
{
/* If input is working on current scan, we ordinarily want it to
* have completed the current row. But if input scan is DC,
* we want it to keep one row ahead so that next block row's DC
* values are up to date.
*/
int delta = (m_cinfo.m_Ss == 0) ? 1 : 0;
if (m_cinfo.m_input_iMCU_row > m_cinfo.m_output_iMCU_row + delta)
break;
}
if (m_cinfo.m_inputctl.consume_input() == ReadResult.Suspended)
return ReadResult.Suspended;
}
int last_iMCU_row = m_cinfo.m_total_iMCU_rows - 1;
/* OK, output from the virtual arrays. */
for (int ci = 0; ci < m_cinfo.m_num_components; ci++)
{
JpegComponent componentInfo = m_cinfo.Comp_info[ci];
/* Don't bother to IDCT an uninteresting component. */
if (!componentInfo.component_needed)
continue;
int block_rows;
int access_rows;
bool last_row;
/* Count non-dummy DCT block rows in this iMCU row. */
if (m_cinfo.m_output_iMCU_row < last_iMCU_row)
{
block_rows = componentInfo.V_samp_factor;
access_rows = block_rows * 2; /* this and next iMCU row */
last_row = false;
}
else
{
/* NB: can't use last_row_height here; it is input-side-dependent! */
block_rows = componentInfo.height_in_blocks % componentInfo.V_samp_factor;
if (block_rows == 0)
block_rows = componentInfo.V_samp_factor;
access_rows = block_rows; /* this iMCU row only */
last_row = true;
}
/* Align the virtual buffer for this component. */
JpegBlock[][] buffer = null;
bool first_row;
int bufferRowOffset = 0;
if (m_cinfo.m_output_iMCU_row > 0)
{
access_rows += componentInfo.V_samp_factor; /* prior iMCU row too */
buffer = m_whole_image[ci].Access((m_cinfo.m_output_iMCU_row - 1) * componentInfo.V_samp_factor, access_rows);
bufferRowOffset = componentInfo.V_samp_factor; /* point to current iMCU row */
first_row = false;
}
else
{
buffer = m_whole_image[ci].Access(0, access_rows);
first_row = true;
}
/* Fetch component-dependent info */
int coefBitsOffset = ci * SAVED_COEFS;
int Q00 = componentInfo.quant_table.quantval[0];
int Q01 = componentInfo.quant_table.quantval[Q01_POS];
int Q10 = componentInfo.quant_table.quantval[Q10_POS];
int Q20 = componentInfo.quant_table.quantval[Q20_POS];
int Q11 = componentInfo.quant_table.quantval[Q11_POS];
int Q02 = componentInfo.quant_table.quantval[Q02_POS];
int outputIndex = ci;
/* Loop over all DCT blocks to be processed. */
for (int block_row = 0; block_row < block_rows; block_row++)
{
int bufferIndex = bufferRowOffset + block_row;
int prev_block_row = 0;
if (first_row && block_row == 0)
prev_block_row = bufferIndex;
else
prev_block_row = bufferIndex - 1;
int next_block_row = 0;
if (last_row && block_row == block_rows - 1)
next_block_row = bufferIndex;
else
next_block_row = bufferIndex + 1;
/* We fetch the surrounding DC values using a sliding-register approach.
* Initialize all nine here so as to do the right thing on narrow pics.
*/
int DC1 = buffer[prev_block_row][0][0];
int DC2 = DC1;
int DC3 = DC1;
int DC4 = buffer[bufferIndex][0][0];
int DC5 = DC4;
int DC6 = DC4;
int DC7 = buffer[next_block_row][0][0];
int DC8 = DC7;
int DC9 = DC7;
int output_col = 0;
int last_block_column = componentInfo.Width_in_blocks - 1;
for (int block_num = 0; block_num <= last_block_column; block_num++)
{
/* Fetch current DCT block into workspace so we can modify it. */
JpegBlock workspace = new JpegBlock();
Buffer.BlockCopy(buffer[bufferIndex][0].data, 0, workspace.data, 0, workspace.data.Length * sizeof(short));
/* Update DC values */
if (block_num < last_block_column)
{
DC3 = buffer[prev_block_row][1][0];
DC6 = buffer[bufferIndex][1][0];
DC9 = buffer[next_block_row][1][0];
}
/* Compute coefficient estimates per K.8.
* An estimate is applied only if coefficient is still zero,
* and is not known to be fully accurate.
*/
/* AC01 */
int Al = m_coef_bits_latch[m_coef_bits_savedOffset + coefBitsOffset + 1];
if (Al != 0 && workspace[1] == 0)
{
int pred;
int num = 36 * Q00 * (DC4 - DC6);
if (num >= 0)
{
pred = ((Q01 << 7) + num) / (Q01 << 8);
if (Al > 0 && pred >= (1 << Al))
pred = (1 << Al) - 1;
}
else
{
pred = ((Q01 << 7) - num) / (Q01 << 8);
if (Al > 0 && pred >= (1 << Al))
pred = (1 << Al) - 1;
pred = -pred;
}
workspace[1] = (short)pred;
}
/* AC10 */
Al = m_coef_bits_latch[m_coef_bits_savedOffset + coefBitsOffset + 2];
if (Al != 0 && workspace[8] == 0)
{
int pred;
int num = 36 * Q00 * (DC2 - DC8);
if (num >= 0)
{
pred = ((Q10 << 7) + num) / (Q10 << 8);
if (Al > 0 && pred >= (1 << Al))
pred = (1 << Al) - 1;
}
else
{
pred = ((Q10 << 7) - num) / (Q10 << 8);
if (Al > 0 && pred >= (1 << Al))
pred = (1 << Al) - 1;
pred = -pred;
}
workspace[8] = (short)pred;
}
/* AC20 */
Al = m_coef_bits_latch[m_coef_bits_savedOffset + coefBitsOffset + 3];
if (Al != 0 && workspace[16] == 0)
{
int pred;
int num = 9 * Q00 * (DC2 + DC8 - 2 * DC5);
if (num >= 0)
{
pred = ((Q20 << 7) + num) / (Q20 << 8);
if (Al > 0 && pred >= (1 << Al))
pred = (1 << Al) - 1;
}
else
{
pred = ((Q20 << 7) - num) / (Q20 << 8);
if (Al > 0 && pred >= (1 << Al))
pred = (1 << Al) - 1;
pred = -pred;
}
workspace[16] = (short)pred;
}
/* AC11 */
Al = m_coef_bits_latch[m_coef_bits_savedOffset + coefBitsOffset + 4];
if (Al != 0 && workspace[9] == 0)
{
int pred;
int num = 5 * Q00 * (DC1 - DC3 - DC7 + DC9);
if (num >= 0)
{
pred = ((Q11 << 7) + num) / (Q11 << 8);
if (Al > 0 && pred >= (1 << Al))
pred = (1 << Al) - 1;
}
else
{
pred = ((Q11 << 7) - num) / (Q11 << 8);
if (Al > 0 && pred >= (1 << Al))
pred = (1 << Al) - 1;
pred = -pred;
}
workspace[9] = (short)pred;
}
/* AC02 */
Al = m_coef_bits_latch[m_coef_bits_savedOffset + coefBitsOffset + 5];
if (Al != 0 && workspace[2] == 0)
{
int pred;
int num = 9 * Q00 * (DC4 + DC6 - 2 * DC5);
if (num >= 0)
{
pred = ((Q02 << 7) + num) / (Q02 << 8);
if (Al > 0 && pred >= (1 << Al))
pred = (1 << Al) - 1;
}
else
{
pred = ((Q02 << 7) - num) / (Q02 << 8);
if (Al > 0 && pred >= (1 << Al))
pred = (1 << Al) - 1;
pred = -pred;
}
workspace[2] = (short)pred;
}
/* OK, do the IDCT */
m_cinfo.m_idct.inverse(componentInfo.Component_index, workspace.data, output_buf[outputIndex], 0, output_col);
/* Advance for next column */
DC1 = DC2;
DC2 = DC3;
DC4 = DC5;
DC5 = DC6;
DC7 = DC8;
DC8 = DC9;
bufferIndex++;
prev_block_row++;
next_block_row++;
output_col += componentInfo.DCT_scaled_size;
}
outputIndex += componentInfo.DCT_scaled_size;
}
}
m_cinfo.m_output_iMCU_row++;
if (m_cinfo.m_output_iMCU_row < m_cinfo.m_total_iMCU_rows)
return ReadResult.Row_Completed;
return ReadResult.Scan_Completed;
}
/// <summary>
/// Determine whether block smoothing is applicable and safe.
/// We also latch the current states of the coef_bits[] entries for the
/// AC coefficients; otherwise, if the input side of the decompressor
/// advances into a new scan, we might think the coefficients are known
/// more accurately than they really are.
/// </summary>
private bool smoothing_ok()
{
if (!m_cinfo.m_progressive_mode || m_cinfo.m_coef_bits == null)
return false;
/* Allocate latch area if not already done */
if (m_coef_bits_latch == null)
{
m_coef_bits_latch = new int[m_cinfo.m_num_components * SAVED_COEFS];
m_coef_bits_savedOffset = 0;
}
bool smoothing_useful = false;
for (int ci = 0; ci < m_cinfo.m_num_components; ci++)
{
/* All components' quantization values must already be latched. */
JpegQuantizationTable qtable = m_cinfo.Comp_info[ci].quant_table;
if (qtable == null)
return false;
/* Verify DC & first 5 AC quantizers are nonzero to avoid zero-divide. */
if (qtable.quantval[0] == 0 || qtable.quantval[Q01_POS] == 0 ||
qtable.quantval[Q10_POS] == 0 || qtable.quantval[Q20_POS] == 0 ||
qtable.quantval[Q11_POS] == 0 || qtable.quantval[Q02_POS] == 0)
{
return false;
}
/* DC values must be at least partly known for all components. */
if (m_cinfo.m_coef_bits[ci][0] < 0)
return false;
/* Block smoothing is helpful if some AC coefficients remain inaccurate. */
for (int coefi = 1; coefi <= 5; coefi++)
{
m_coef_bits_latch[m_coef_bits_savedOffset + coefi] = m_cinfo.m_coef_bits[ci][coefi];
if (m_cinfo.m_coef_bits[ci][coefi] != 0)
smoothing_useful = true;
}
m_coef_bits_savedOffset += SAVED_COEFS;
}
return smoothing_useful;
}
/// <summary>
/// Reset within-iMCU-row counters for a new row (input side)
/// </summary>
private void start_iMCU_row()
{
/* In an interleaved scan, an MCU row is the same as an iMCU row.
* In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows.
* But at the bottom of the image, process only what's left.
*/
if (m_cinfo.m_comps_in_scan > 1)
{
m_MCU_rows_per_iMCU_row = 1;
}
else
{
JpegComponent componentInfo = m_cinfo.Comp_info[m_cinfo.m_cur_comp_info[0]];
if (m_cinfo.m_input_iMCU_row < (m_cinfo.m_total_iMCU_rows - 1))
m_MCU_rows_per_iMCU_row = componentInfo.V_samp_factor;
else
m_MCU_rows_per_iMCU_row = componentInfo.last_row_height;
}
m_MCU_ctr = 0;
m_MCU_vert_offset = 0;
}
}
#endregion
#region JpegDecompressorMainController
/// <summary>
/// Main buffer control (downsampled-data buffer)
///
/// In the current system design, the main buffer need never be a full-image
/// buffer; any full-height buffers will be found inside the coefficient or
/// postprocessing controllers. Nonetheless, the main controller is not
/// trivial. Its responsibility is to provide context rows for upsampling/
/// rescaling, and doing this in an efficient fashion is a bit tricky.
///
/// Postprocessor input data is counted in "row groups". A row group
/// is defined to be (v_samp_factor * DCT_scaled_size / min_DCT_scaled_size)
/// sample rows of each component. (We require DCT_scaled_size values to be
/// chosen such that these numbers are integers. In practice DCT_scaled_size
/// values will likely be powers of two, so we actually have the stronger
/// condition that DCT_scaled_size / min_DCT_scaled_size is an integer.)
/// Upsampling will typically produce max_v_samp_factor pixel rows from each
/// row group (times any additional scale factor that the upsampler is
/// applying).
///
/// The coefficient controller will deliver data to us one iMCU row at a time;
/// each iMCU row contains v_samp_factor * DCT_scaled_size sample rows, or
/// exactly min_DCT_scaled_size row groups. (This amount of data corresponds
/// to one row of MCUs when the image is fully interleaved.) Note that the
/// number of sample rows varies across components, but the number of row
/// groups does not. Some garbage sample rows may be included in the last iMCU
/// row at the bottom of the image.
///
/// Depending on the vertical scaling algorithm used, the upsampler may need
/// access to the sample row(s) above and below its current input row group.
/// The upsampler is required to set need_context_rows true at global selection
/// time if so. When need_context_rows is false, this controller can simply
/// obtain one iMCU row at a time from the coefficient controller and dole it
/// out as row groups to the postprocessor.
///
/// When need_context_rows is true, this controller guarantees that the buffer
/// passed to postprocessing contains at least one row group's worth of samples
/// above and below the row group(s) being processed. Note that the context
/// rows "above" the first passed row group appear at negative row offsets in
/// the passed buffer. At the top and bottom of the image, the required
/// context rows are manufactured by duplicating the first or last real sample
/// row; this avoids having special cases in the upsampling inner loops.
///
/// The amount of context is fixed at one row group just because that's a
/// convenient number for this controller to work with. The existing
/// upsamplers really only need one sample row of context. An upsampler
/// supporting arbitrary output rescaling might wish for more than one row
/// group of context when shrinking the image; tough, we don't handle that.
/// (This is justified by the assumption that downsizing will be handled mostly
/// by adjusting the DCT_scaled_size values, so that the actual scale factor at
/// the upsample step needn't be much less than one.)
///
/// To provide the desired context, we have to retain the last two row groups
/// of one iMCU row while reading in the next iMCU row. (The last row group
/// can't be processed until we have another row group for its below-context,
/// and so we have to save the next-to-last group too for its above-context.)
/// We could do this most simply by copying data around in our buffer, but
/// that'd be very slow. We can avoid copying any data by creating a rather
/// strange pointer structure. Here's how it works. We allocate a workspace
/// consisting of M+2 row groups (where M = min_DCT_scaled_size is the number
/// of row groups per iMCU row). We create two sets of redundant pointers to
/// the workspace. Labeling the physical row groups 0 to M+1, the synthesized
/// pointer lists look like this:
/// M+1 M-1
/// master pointer --> 0 master pointer --> 0
/// 1 1
/// ... ...
/// M-3 M-3
/// M-2 M
/// M-1 M+1
/// M M-2
/// M+1 M-1
/// 0 0
/// We read alternate iMCU rows using each master pointer; thus the last two
/// row groups of the previous iMCU row remain un-overwritten in the workspace.
/// The pointer lists are set up so that the required context rows appear to
/// be adjacent to the proper places when we pass the pointer lists to the
/// upsampler.
///
/// The above pictures describe the normal state of the pointer lists.
/// At top and bottom of the image, we diddle the pointer lists to duplicate
/// the first or last sample row as necessary (this is cheaper than copying
/// sample rows around).
///
/// This scheme breaks down if M less than 2, ie, min_DCT_scaled_size is 1. In that
/// situation each iMCU row provides only one row group so the buffering logic
/// must be different (eg, we must read two iMCU rows before we can emit the
/// first row group). For now, we simply do not support providing context
/// rows when min_DCT_scaled_size is 1. That combination seems unlikely to
/// be worth providing --- if someone wants a 1/8th-size preview, they probably
/// want it quick and dirty, so a context-free upsampler is sufficient.
/// </summary>
class JpegDecompressorMainController
{
private enum DataProcessor
{
context_main,
simple_main,
crank_post
}
/* context_state values: */
private const int CTX_PREPARE_FOR_IMCU = 0; /* need to prepare for MCU row */
private const int CTX_PROCESS_IMCU = 1; /* feeding iMCU to postprocessor */
private const int CTX_POSTPONED_ROW = 2; /* feeding postponed row group */
private DataProcessor m_dataProcessor;
private JpegDecompressor m_cinfo;
/* Pointer to allocated workspace (M or M+2 row groups). */
private byte[][][] m_buffer = new byte[JpegConstants.MaxComponents][][];
private bool m_buffer_full; /* Have we gotten an iMCU row from decoder? */
private int m_rowgroup_ctr; /* counts row groups output to postprocessor */
/* Remaining fields are only used in the context case. */
private int[][][] m_funnyIndices = new int[2][][] { new int[JpegConstants.MaxComponents][], new int[JpegConstants.MaxComponents][] };
private int[] m_funnyOffsets = new int[JpegConstants.MaxComponents];
private int m_whichFunny; /* indicates which funny indices set is now in use */
private int m_context_state; /* process_data state machine status */
private int m_rowgroups_avail; /* row groups available to postprocessor */
private int m_iMCU_row_ctr; /* counts iMCU rows to detect image top/bot */
public JpegDecompressorMainController(JpegDecompressor cinfo)
{
m_cinfo = cinfo;
/* Allocate the workspace.
* ngroups is the number of row groups we need.
*/
int ngroups = cinfo.m_min_DCT_scaled_size;
if (cinfo.m_upsample.NeedContextRows())
{
if (cinfo.m_min_DCT_scaled_size < 2) /* unsupported, see comments above */
throw new Exception("Not implemented yet");
alloc_funny_pointers(); /* Alloc space for xbuffer[] lists */
ngroups = cinfo.m_min_DCT_scaled_size + 2;
}
for (int ci = 0; ci < cinfo.m_num_components; ci++)
{
/* height of a row group of component */
int rgroup = (cinfo.Comp_info[ci].V_samp_factor * cinfo.Comp_info[ci].DCT_scaled_size) / cinfo.m_min_DCT_scaled_size;
m_buffer[ci] = JpegCommonBase.AllocJpegSamples(
cinfo.Comp_info[ci].Width_in_blocks * cinfo.Comp_info[ci].DCT_scaled_size,
rgroup * ngroups);
}
}
/// <summary>
/// Initialize for a processing pass.
/// </summary>
public void start_pass(BufferMode pass_mode)
{
switch (pass_mode)
{
case BufferMode.PassThru:
if (m_cinfo.m_upsample.NeedContextRows())
{
m_dataProcessor = DataProcessor.context_main;
make_funny_pointers(); /* Create the xbuffer[] lists */
m_whichFunny = 0; /* Read first iMCU row into xbuffer[0] */
m_context_state = CTX_PREPARE_FOR_IMCU;
m_iMCU_row_ctr = 0;
}
else
{
/* Simple case with no context needed */
m_dataProcessor = DataProcessor.simple_main;
}
m_buffer_full = false; /* Mark buffer empty */
m_rowgroup_ctr = 0;
break;
case BufferMode.CrankDest:
/* For last pass of 2-pass quantization, just crank the postprocessor */
m_dataProcessor = DataProcessor.crank_post;
break;
default:
throw new Exception("Bogus buffer control mode");
}
}
public void process_data(byte[][] output_buf, ref int out_row_ctr, int out_rows_avail)
{
switch (m_dataProcessor)
{
case DataProcessor.simple_main:
process_data_simple_main(output_buf, ref out_row_ctr, out_rows_avail);
break;
case DataProcessor.context_main:
process_data_context_main(output_buf, ref out_row_ctr, out_rows_avail);
break;
case DataProcessor.crank_post:
process_data_crank_post(output_buf, ref out_row_ctr, out_rows_avail);
break;
default:
throw new Exception("Not implemented yet");
}
}
/// <summary>
/// Process some data.
/// This handles the simple case where no context is required.
/// </summary>
private void process_data_simple_main(byte[][] output_buf, ref int out_row_ctr, int out_rows_avail)
{
ComponentBuffer[] cb = new ComponentBuffer[JpegConstants.MaxComponents];
for (int i = 0; i < JpegConstants.MaxComponents; i++)
{
cb[i] = new ComponentBuffer();
cb[i].SetBuffer(m_buffer[i], null, 0);
}
/* Read input data if we haven't filled the main buffer yet */
if (!m_buffer_full)
{
if (m_cinfo.m_coef.decompress_data(cb) == ReadResult.Suspended)
{
/* suspension forced, can do nothing more */
return;
}
/* OK, we have an iMCU row to work with */
m_buffer_full = true;
}
/* There are always min_DCT_scaled_size row groups in an iMCU row. */
int rowgroups_avail = m_cinfo.m_min_DCT_scaled_size;
/* Note: at the bottom of the image, we may pass extra garbage row groups
* to the postprocessor. The postprocessor has to check for bottom
* of image anyway (at row resolution), so no point in us doing it too.
*/
/* Feed the postprocessor */
m_cinfo.m_post.post_process_data(cb, ref m_rowgroup_ctr, rowgroups_avail, output_buf, ref out_row_ctr, out_rows_avail);
/* Has postprocessor consumed all the data yet? If so, mark buffer empty */
if (m_rowgroup_ctr >= rowgroups_avail)
{
m_buffer_full = false;
m_rowgroup_ctr = 0;
}
}
/// <summary>
/// Process some data.
/// This handles the case where context rows must be provided.
/// </summary>
private void process_data_context_main(byte[][] output_buf, ref int out_row_ctr, int out_rows_avail)
{
ComponentBuffer[] cb = new ComponentBuffer[m_cinfo.m_num_components];
for (int i = 0; i < m_cinfo.m_num_components; i++)
{
cb[i] = new ComponentBuffer();
cb[i].SetBuffer(m_buffer[i], m_funnyIndices[m_whichFunny][i], m_funnyOffsets[i]);
}
/* Read input data if we haven't filled the main buffer yet */
if (!m_buffer_full)
{
if (m_cinfo.m_coef.decompress_data(cb) == ReadResult.Suspended)
{
/* suspension forced, can do nothing more */
return;
}
/* OK, we have an iMCU row to work with */
m_buffer_full = true;
/* count rows received */
m_iMCU_row_ctr++;
}
/* Postprocessor typically will not swallow all the input data it is handed
* in one call (due to filling the output buffer first). Must be prepared
* to exit and restart.
This switch lets us keep track of how far we got.
* Note that each case falls through to the next on successful completion.
*/
if (m_context_state == CTX_POSTPONED_ROW)
{
/* Call postprocessor using previously set pointers for postponed row */
m_cinfo.m_post.post_process_data(cb, ref m_rowgroup_ctr,
m_rowgroups_avail, output_buf, ref out_row_ctr, out_rows_avail);
if (m_rowgroup_ctr < m_rowgroups_avail)
{
/* Need to suspend */
return;
}
m_context_state = CTX_PREPARE_FOR_IMCU;
if (out_row_ctr >= out_rows_avail)
{
/* Postprocessor exactly filled output buf */
return;
}
}
if (m_context_state == CTX_PREPARE_FOR_IMCU)
{
/* Prepare to process first M-1 row groups of this iMCU row */
m_rowgroup_ctr = 0;
m_rowgroups_avail = m_cinfo.m_min_DCT_scaled_size - 1;
/* Check for bottom of image: if so, tweak pointers to "duplicate"
* the last sample row, and adjust rowgroups_avail to ignore padding rows.
*/
if (m_iMCU_row_ctr == m_cinfo.m_total_iMCU_rows)
set_bottom_pointers();
m_context_state = CTX_PROCESS_IMCU;
}
if (m_context_state == CTX_PROCESS_IMCU)
{
/* Call postprocessor using previously set pointers */
m_cinfo.m_post.post_process_data(cb, ref m_rowgroup_ctr,
m_rowgroups_avail, output_buf, ref out_row_ctr, out_rows_avail);
if (m_rowgroup_ctr < m_rowgroups_avail)
{
/* Need to suspend */
return;
}
/* After the first iMCU, change wraparound pointers to normal state */
if (m_iMCU_row_ctr == 1)
set_wraparound_pointers();
/* Prepare to load new iMCU row using other xbuffer list */
m_whichFunny ^= 1; /* 0=>1 or 1=>0 */
m_buffer_full = false;
/* Still need to process last row group of this iMCU row, */
/* which is saved at index M+1 of the other xbuffer */
m_rowgroup_ctr = m_cinfo.m_min_DCT_scaled_size + 1;
m_rowgroups_avail = m_cinfo.m_min_DCT_scaled_size + 2;
m_context_state = CTX_POSTPONED_ROW;
}
}
/// <summary>
/// Process some data.
/// Final pass of two-pass quantization: just call the postprocessor.
/// Source data will be the postprocessor controller's internal buffer.
/// </summary>
private void process_data_crank_post(byte[][] output_buf, ref int out_row_ctr, int out_rows_avail)
{
int dummy = 0;
m_cinfo.m_post.post_process_data(null, ref dummy, 0, output_buf, ref out_row_ctr, out_rows_avail);
}
/// <summary>
/// Allocate space for the funny pointer lists.
/// This is done only once, not once per pass.
/// </summary>
private void alloc_funny_pointers()
{
int M = m_cinfo.m_min_DCT_scaled_size;
for (int ci = 0; ci < m_cinfo.m_num_components; ci++)
{
/* height of a row group of component */
int rgroup = (m_cinfo.Comp_info[ci].V_samp_factor * m_cinfo.Comp_info[ci].DCT_scaled_size) / m_cinfo.m_min_DCT_scaled_size;
/* Get space for pointer lists --- M+4 row groups in each list.
*/
m_funnyIndices[0][ci] = new int[rgroup * (M + 4)];
m_funnyIndices[1][ci] = new int[rgroup * (M + 4)];
m_funnyOffsets[ci] = rgroup;
}
}
/// <summary>
/// Create the funny pointer lists discussed in the comments above.
/// The actual workspace is already allocated (in main.buffer),
/// and the space for the pointer lists is allocated too.
/// This routine just fills in the curiously ordered lists.
/// This will be repeated at the beginning of each pass.
/// </summary>
private void make_funny_pointers()
{
int M = m_cinfo.m_min_DCT_scaled_size;
for (int ci = 0; ci < m_cinfo.m_num_components; ci++)
{
/* height of a row group of component */
int rgroup = (m_cinfo.Comp_info[ci].V_samp_factor * m_cinfo.Comp_info[ci].DCT_scaled_size) / m_cinfo.m_min_DCT_scaled_size;
int[] ind0 = m_funnyIndices[0][ci];
int[] ind1 = m_funnyIndices[1][ci];
/* First copy the workspace pointers as-is */
for (int i = 0; i < rgroup * (M + 2); i++)
{
ind0[i + rgroup] = i;
ind1[i + rgroup] = i;
}
/* In the second list, put the last four row groups in swapped order */
for (int i = 0; i < rgroup * 2; i++)
{
ind1[rgroup * (M - 1) + i] = rgroup * M + i;
ind1[rgroup * (M + 1) + i] = rgroup * (M - 2) + i;
}
/* The wraparound pointers at top and bottom will be filled later
* (see set_wraparound_pointers, below). Initially we want the "above"
* pointers to duplicate the first actual data line. This only needs
* to happen in xbuffer[0].
*/
for (int i = 0; i < rgroup; i++)
ind0[i] = ind0[rgroup];
}
}
/// <summary>
/// Set up the "wraparound" pointers at top and bottom of the pointer lists.
/// This changes the pointer list state from top-of-image to the normal state.
/// </summary>
private void set_wraparound_pointers()
{
int M = m_cinfo.m_min_DCT_scaled_size;
for (int ci = 0; ci < m_cinfo.m_num_components; ci++)
{
/* height of a row group of component */
int rgroup = (m_cinfo.Comp_info[ci].V_samp_factor * m_cinfo.Comp_info[ci].DCT_scaled_size) / m_cinfo.m_min_DCT_scaled_size;
int[] ind0 = m_funnyIndices[0][ci];
int[] ind1 = m_funnyIndices[1][ci];
for (int i = 0; i < rgroup; i++)
{
ind0[i] = ind0[rgroup * (M + 2) + i];
ind1[i] = ind1[rgroup * (M + 2) + i];
ind0[rgroup * (M + 3) + i] = ind0[i + rgroup];
ind1[rgroup * (M + 3) + i] = ind1[i + rgroup];
}
}
}
/// <summary>
/// Change the pointer lists to duplicate the last sample row at the bottom
/// of the image. m_whichFunny indicates which m_funnyIndices holds the final iMCU row.
/// Also sets rowgroups_avail to indicate number of nondummy row groups in row.
/// </summary>
private void set_bottom_pointers()
{
for (int ci = 0; ci < m_cinfo.m_num_components; ci++)
{
/* Count sample rows in one iMCU row and in one row group */
int iMCUheight = m_cinfo.Comp_info[ci].V_samp_factor * m_cinfo.Comp_info[ci].DCT_scaled_size;
int rgroup = iMCUheight / m_cinfo.m_min_DCT_scaled_size;
/* Count nondummy sample rows remaining for this component */
int rows_left = m_cinfo.Comp_info[ci].downsampled_height % iMCUheight;
if (rows_left == 0)
rows_left = iMCUheight;
/* Count nondummy row groups. Should get same answer for each component,
* so we need only do it once.
*/
if (ci == 0)
m_rowgroups_avail = (rows_left - 1) / rgroup + 1;
/* Duplicate the last real sample row rgroup*2 times; this pads out the
* last partial rowgroup and ensures at least one full rowgroup of context.
*/
for (int i = 0; i < rgroup * 2; i++)
m_funnyIndices[m_whichFunny][ci][rows_left + i + rgroup] = m_funnyIndices[m_whichFunny][ci][rows_left - 1 + rgroup];
}
}
}
#endregion
#region JpegDecompressorMaster
/// <summary>
/// Master control module
/// </summary>
class JpegDecompressorMaster
{
private JpegDecompressor m_cinfo;
private int m_pass_number; /* # of passes completed */
private bool m_is_dummy_pass; /* True during 1st pass for 2-pass quant */
private bool m_using_merged_upsample; /* true if using merged upsample/cconvert */
/* Saved references to initialized quantizer modules,
* in case we need to switch modes.
*/
private ColorQuantizer m_quantizer_1pass;
private ColorQuantizer m_quantizer_2pass;
public JpegDecompressorMaster(JpegDecompressor cinfo)
{
m_cinfo = cinfo;
master_selection();
}
/// <summary>
/// Per-pass setup.
/// This is called at the beginning of each output pass. We determine which
/// modules will be active during this pass and give them appropriate
/// start_pass calls. We also set is_dummy_pass to indicate whether this
/// is a "real" output pass or a dummy pass for color quantization.
/// (In the latter case, we will crank the pass to completion.)
/// </summary>
public void prepare_for_output_pass()
{
if (m_is_dummy_pass)
{
/* Final pass of 2-pass quantization */
m_is_dummy_pass = false;
m_cinfo.m_cquantize.start_pass(false);
m_cinfo.m_post.start_pass(BufferMode.CrankDest);
m_cinfo.m_main.start_pass(BufferMode.CrankDest);
}
else
{
if (m_cinfo.m_quantize_colors && m_cinfo.m_colormap == null)
{
/* Select new quantization method */
if (m_cinfo.m_two_pass_quantize && m_cinfo.m_enable_2pass_quant)
{
m_cinfo.m_cquantize = m_quantizer_2pass;
m_is_dummy_pass = true;
}
else if (m_cinfo.m_enable_1pass_quant)
m_cinfo.m_cquantize = m_quantizer_1pass;
else
throw new Exception("Invalid color quantization mode change");
}
m_cinfo.m_idct.start_pass();
m_cinfo.m_coef.start_output_pass();
if (!m_cinfo.m_raw_data_out)
{
m_cinfo.m_upsample.start_pass();
if (m_cinfo.m_quantize_colors)
m_cinfo.m_cquantize.start_pass(m_is_dummy_pass);
m_cinfo.m_post.start_pass((m_is_dummy_pass ? BufferMode.SaveAndPass : BufferMode.PassThru));
m_cinfo.m_main.start_pass(BufferMode.PassThru);
}
}
}
/// <summary>
/// Finish up at end of an output pass.
/// </summary>
public void finish_output_pass()
{
if (m_cinfo.m_quantize_colors)
m_cinfo.m_cquantize.finish_pass();
m_pass_number++;
}
public bool IsDummyPass()
{
return m_is_dummy_pass;
}
/// <summary>
/// Master selection of decompression modules.
/// This is done once at jpeg_start_decompress time. We determine
/// which modules will be used and give them appropriate initialization calls.
/// We also initialize the decompressor input side to begin consuming data.
///
/// Since jpeg_read_header has finished, we know what is in the SOF
/// and (first) SOS markers. We also have all the application parameter
/// settings.
/// </summary>
private void master_selection()
{
/* Initialize dimensions and other stuff */
m_cinfo.jpeg_calc_output_dimensions();
prepare_range_limit_table();
/* Width of an output scanline must be representable as int. */
long samplesperrow = m_cinfo.m_output_width * m_cinfo.m_out_color_components;
int jd_samplesperrow = (int)samplesperrow;
if ((long)jd_samplesperrow != samplesperrow)
throw new Exception("Image too wide for this implementation");
/* Initialize my private state */
m_pass_number = 0;
m_using_merged_upsample = m_cinfo.use_merged_upsample();
/* Color quantizer selection */
m_quantizer_1pass = null;
m_quantizer_2pass = null;
/* No mode changes if not using buffered-image mode. */
if (!m_cinfo.m_quantize_colors || !m_cinfo.m_buffered_image)
{
m_cinfo.m_enable_1pass_quant = false;
m_cinfo.m_enable_external_quant = false;
m_cinfo.m_enable_2pass_quant = false;
}
if (m_cinfo.m_quantize_colors)
{
if (m_cinfo.m_raw_data_out)
throw new Exception("Not implemented yet");
/* 2-pass quantizer only works in 3-component color space. */
if (m_cinfo.m_out_color_components != 3)
{
m_cinfo.m_enable_1pass_quant = true;
m_cinfo.m_enable_external_quant = false;
m_cinfo.m_enable_2pass_quant = false;
m_cinfo.m_colormap = null;
}
else if (m_cinfo.m_colormap != null)
m_cinfo.m_enable_external_quant = true;
else if (m_cinfo.m_two_pass_quantize)
m_cinfo.m_enable_2pass_quant = true;
else
m_cinfo.m_enable_1pass_quant = true;
if (m_cinfo.m_enable_1pass_quant)
{
m_cinfo.m_cquantize = new Pass1ColorQuantizer(m_cinfo);
m_quantizer_1pass = m_cinfo.m_cquantize;
}
/* We use the 2-pass code to map to external colormaps. */
if (m_cinfo.m_enable_2pass_quant || m_cinfo.m_enable_external_quant)
{
m_cinfo.m_cquantize = new Pass2ColorQuantizer(m_cinfo);
m_quantizer_2pass = m_cinfo.m_cquantize;
}
/* If both quantizers are initialized, the 2-pass one is left active;
* this is necessary for starting with quantization to an external map.
*/
}
/* Post-processing: in particular, color conversion first */
if (!m_cinfo.m_raw_data_out)
{
if (m_using_merged_upsample)
{
/* does color conversion too */
m_cinfo.m_upsample = new MergedUpsampler(m_cinfo);
}
else
{
m_cinfo.m_cconvert = new ColorDeconverter(m_cinfo);
m_cinfo.m_upsample = new UpsamplerImpl(m_cinfo);
}
m_cinfo.m_post = new JpegDecompressorPostController(m_cinfo, m_cinfo.m_enable_2pass_quant);
}
/* Inverse DCT */
m_cinfo.m_idct = new JpegInverseDCT(m_cinfo);
if (m_cinfo.m_progressive_mode)
m_cinfo.m_entropy = new ProgressiveHuffmanDecoder(m_cinfo);
else
m_cinfo.m_entropy = new HuffEntropyDecoder(m_cinfo);
/* Initialize principal buffer controllers. */
bool use_c_buffer = m_cinfo.m_inputctl.HasMultipleScans() || m_cinfo.m_buffered_image;
m_cinfo.m_coef = new JpegDecompressorCoefController(m_cinfo, use_c_buffer);
if (!m_cinfo.m_raw_data_out)
m_cinfo.m_main = new JpegDecompressorMainController(m_cinfo);
/* Initialize input side of decompressor to consume first scan. */
m_cinfo.m_inputctl.start_input_pass();
}
/// <summary>
/// Allocate and fill in the sample_range_limit table.
///
/// Several decompression processes need to range-limit values to the range
/// 0..MaxSampleValue; the input value may fall somewhat outside this range
/// due to noise introduced by quantization, roundoff error, etc. These
/// processes are inner loops and need to be as fast as possible. On most
/// machines, particularly CPUs with pipelines or instruction prefetch,
/// a (subscript-check-less) C table lookup
/// x = sample_range_limit[x];
/// is faster than explicit tests
/// <c>
/// if (x &amp; 0)
/// x = 0;
/// else if (x > MaxSampleValue)
/// x = MaxSampleValue;
/// </c>
/// These processes all use a common table prepared by the routine below.
///
/// For most steps we can mathematically guarantee that the initial value
/// of x is within MaxSampleValue + 1 of the legal range, so a table running from
/// -(MaxSampleValue + 1) to 2 * MaxSampleValue + 1 is sufficient. But for the initial
/// limiting step (just after the IDCT), a wildly out-of-range value is
/// possible if the input data is corrupt. To avoid any chance of indexing
/// off the end of memory and getting a bad-pointer trap, we perform the
/// post-IDCT limiting thus: <c>x = range_limit[x &amp; Mask];</c>
/// where Mask is 2 bits wider than legal sample data, ie 10 bits for 8-bit
/// samples. Under normal circumstances this is more than enough range and
/// a correct output will be generated; with bogus input data the mask will
/// cause wraparound, and we will safely generate a bogus-but-in-range output.
/// For the post-IDCT step, we want to convert the data from signed to unsigned
/// representation by adding MediumSampleValue at the same time that we limit it.
/// So the post-IDCT limiting table ends up looking like this:
/// <pre>
/// MediumSampleValue, MediumSampleValue + 1, ..., MaxSampleValue,
/// MaxSampleValue (repeat 2 * (MaxSampleValue + 1) - MediumSampleValue times),
/// 0 (repeat 2 * (MaxSampleValue + 1) - MediumSampleValue times),
/// 0, 1, ..., MediumSampleValue - 1
/// </pre>
/// Negative inputs select values from the upper half of the table after
/// masking.
///
/// We can save some space by overlapping the start of the post-IDCT table
/// with the simpler range limiting table. The post-IDCT table begins at
/// sample_range_limit + MediumSampleValue.
///
/// Note that the table is allocated in near data space on PCs; it's small
/// enough and used often enough to justify this.
/// </summary>
private void prepare_range_limit_table()
{
byte[] table = new byte[5 * (JpegConstants.MaxSampleValue + 1) + JpegConstants.MediumSampleValue];
/* allow negative subscripts of simple table */
int tableOffset = JpegConstants.MaxSampleValue + 1;
m_cinfo.m_sample_range_limit = table;
m_cinfo.m_sampleRangeLimitOffset = tableOffset;
/* First segment of "simple" table: limit[x] = 0 for x < 0 */
Array.Clear(table, 0, JpegConstants.MaxSampleValue + 1);
/* Main part of "simple" table: limit[x] = x */
for (int i = 0; i <= JpegConstants.MaxSampleValue; i++)
table[tableOffset + i] = (byte)i;
tableOffset += JpegConstants.MediumSampleValue; /* Point to where post-IDCT table starts */
/* End of simple table, rest of first half of post-IDCT table */
for (int i = JpegConstants.MediumSampleValue; i < 2 * (JpegConstants.MaxSampleValue + 1); i++)
table[tableOffset + i] = JpegConstants.MaxSampleValue;
/* Second half of post-IDCT table */
Array.Clear(table, tableOffset + 2 * (JpegConstants.MaxSampleValue + 1),
2 * (JpegConstants.MaxSampleValue + 1) - JpegConstants.MediumSampleValue);
Buffer.BlockCopy(m_cinfo.m_sample_range_limit, 0, table,
tableOffset + 4 * (JpegConstants.MaxSampleValue + 1) - JpegConstants.MediumSampleValue, JpegConstants.MediumSampleValue);
}
}
#endregion
#region JpegDecompressorPostController
/// <summary>
/// Decompression postprocessing (color quantization buffer control)
/// </summary>
class JpegDecompressorPostController
{
private enum ProcessorType
{
OnePass,
PrePass,
Upsample,
SecondPass
}
private ProcessorType m_processor;
private JpegDecompressor m_cinfo;
/* Color quantization source buffer: this holds output data from
* the upsample/color conversion step to be passed to the quantizer.
* For two-pass color quantization, we need a full-image buffer;
* for one-pass operation, a strip buffer is sufficient.
*/
private JpegVirtualArray<byte> m_whole_image; /* virtual array, or null if one-pass */
private byte[][] m_buffer; /* strip buffer, or current strip of virtual */
private int m_strip_height; /* buffer size in rows */
/* for two-pass mode only: */
private int m_starting_row; /* row # of first row in current strip */
private int m_next_row; /* index of next row to fill/empty in strip */
/// <summary>
/// Initialize postprocessing controller.
/// </summary>
public JpegDecompressorPostController(JpegDecompressor cinfo, bool need_full_buffer)
{
m_cinfo = cinfo;
/* Create the quantization buffer, if needed */
if (cinfo.m_quantize_colors)
{
/* The buffer strip height is max_v_samp_factor, which is typically
* an efficient number of rows for upsampling to return.
* (In the presence of output rescaling, we might want to be smarter?)
*/
m_strip_height = cinfo.m_max_v_samp_factor;
if (need_full_buffer)
{
/* Two-pass color quantization: need full-image storage. */
/* We round up the number of rows to a multiple of the strip height. */
m_whole_image = JpegCommonBase.CreateSamplesArray(
cinfo.m_output_width * cinfo.m_out_color_components,
JpegUtils.jround_up(cinfo.m_output_height, m_strip_height));
m_whole_image.ErrorProcessor = cinfo;
}
else
{
/* One-pass color quantization: just make a strip buffer. */
m_buffer = JpegCommonBase.AllocJpegSamples(
cinfo.m_output_width * cinfo.m_out_color_components, m_strip_height);
}
}
}
/// <summary>
/// Initialize for a processing pass.
/// </summary>
public void start_pass(BufferMode pass_mode)
{
switch (pass_mode)
{
case BufferMode.PassThru:
if (m_cinfo.m_quantize_colors)
{
/* Single-pass processing with color quantization. */
m_processor = ProcessorType.OnePass;
/* We could be doing buffered-image output before starting a 2-pass
* color quantization; in that case, jinit_d_post_controller did not
* allocate a strip buffer. Use the virtual-array buffer as workspace.
*/
if (m_buffer == null)
m_buffer = m_whole_image.Access(0, m_strip_height);
}
else
{
/* For single-pass processing without color quantization,
* I have no work to do; just call the upsampler directly.
*/
m_processor = ProcessorType.Upsample;
}
break;
case BufferMode.SaveAndPass:
/* First pass of 2-pass quantization */
if (m_whole_image == null)
throw new Exception("Bogus buffer control mode");
m_processor = ProcessorType.PrePass;
break;
case BufferMode.CrankDest:
/* Second pass of 2-pass quantization */
if (m_whole_image == null)
throw new Exception("Bogus buffer control mode");
m_processor = ProcessorType.SecondPass;
break;
default:
throw new Exception("Bogus buffer control mode");
}
m_starting_row = m_next_row = 0;
}
public void post_process_data(ComponentBuffer[] input_buf, ref int in_row_group_ctr, int in_row_groups_avail, byte[][] output_buf, ref int out_row_ctr, int out_rows_avail)
{
switch (m_processor)
{
case ProcessorType.OnePass:
post_process_1pass(input_buf, ref in_row_group_ctr, in_row_groups_avail, output_buf, ref out_row_ctr, out_rows_avail);
break;
case ProcessorType.PrePass:
post_process_prepass(input_buf, ref in_row_group_ctr, in_row_groups_avail, ref out_row_ctr);
break;
case ProcessorType.Upsample:
m_cinfo.m_upsample.upsample(input_buf, ref in_row_group_ctr, in_row_groups_avail, output_buf, ref out_row_ctr, out_rows_avail);
break;
case ProcessorType.SecondPass:
post_process_2pass(output_buf, ref out_row_ctr, out_rows_avail);
break;
default:
throw new Exception("Not implemented yet");
}
}
/// <summary>
/// Process some data in the one-pass (strip buffer) case.
/// This is used for color precision reduction as well as one-pass quantization.
/// </summary>
private void post_process_1pass(ComponentBuffer[] input_buf, ref int in_row_group_ctr, int in_row_groups_avail, byte[][] output_buf, ref int out_row_ctr, int out_rows_avail)
{
/* Fill the buffer, but not more than what we can dump out in one go. */
/* Note we rely on the upsampler to detect bottom of image. */
int max_rows = out_rows_avail - out_row_ctr;
if (max_rows > m_strip_height)
max_rows = m_strip_height;
int num_rows = 0;
m_cinfo.m_upsample.upsample(input_buf, ref in_row_group_ctr, in_row_groups_avail, m_buffer, ref num_rows, max_rows);
/* Quantize and emit data. */
m_cinfo.m_cquantize.color_quantize(m_buffer, 0, output_buf, out_row_ctr, num_rows);
out_row_ctr += num_rows;
}
/// <summary>
/// Process some data in the first pass of 2-pass quantization.
/// </summary>
private void post_process_prepass(ComponentBuffer[] input_buf, ref int in_row_group_ctr, int in_row_groups_avail, ref int out_row_ctr)
{
int old_next_row, num_rows;
/* Reposition virtual buffer if at start of strip. */
if (m_next_row == 0)
m_buffer = m_whole_image.Access(m_starting_row, m_strip_height);
/* Upsample some data (up to a strip height's worth). */
old_next_row = m_next_row;
m_cinfo.m_upsample.upsample(input_buf, ref in_row_group_ctr, in_row_groups_avail, m_buffer, ref m_next_row, m_strip_height);
/* Allow quantizer to scan new data. No data is emitted, */
/* but we advance out_row_ctr so outer loop can tell when we're done. */
if (m_next_row > old_next_row)
{
num_rows = m_next_row - old_next_row;
m_cinfo.m_cquantize.color_quantize(m_buffer, old_next_row, null, 0, num_rows);
out_row_ctr += num_rows;
}
/* Advance if we filled the strip. */
if (m_next_row >= m_strip_height)
{
m_starting_row += m_strip_height;
m_next_row = 0;
}
}
/// <summary>
/// Process some data in the second pass of 2-pass quantization.
/// </summary>
private void post_process_2pass(byte[][] output_buf, ref int out_row_ctr, int out_rows_avail)
{
int num_rows, max_rows;
/* Reposition virtual buffer if at start of strip. */
if (m_next_row == 0)
m_buffer = m_whole_image.Access(m_starting_row, m_strip_height);
/* Determine number of rows to emit. */
num_rows = m_strip_height - m_next_row; /* available in strip */
max_rows = out_rows_avail - out_row_ctr; /* available in output area */
if (num_rows > max_rows)
num_rows = max_rows;
/* We have to check bottom of image here, can't depend on upsampler. */
max_rows = m_cinfo.m_output_height - m_starting_row;
if (num_rows > max_rows)
num_rows = max_rows;
/* Quantize and emit data. */
m_cinfo.m_cquantize.color_quantize(m_buffer, m_next_row, output_buf, out_row_ctr, num_rows);
out_row_ctr += num_rows;
/* Advance if we filled the strip. */
m_next_row += num_rows;
if (m_next_row >= m_strip_height)
{
m_starting_row += m_strip_height;
m_next_row = 0;
}
}
}
#endregion
#region JpegCommonBase
/// <summary>Base class for both JPEG compressor and decompresor.</summary>
/// <remarks>
/// Routines that are to be used by both halves of the library are declared
/// to receive an instance of this class. There are no actual instances of
/// <see cref="JpegCommonBase"/>, only of <see cref="JpegCompressor"/>
/// and <see cref="JpegDecompressor"/>
/// </remarks>
public abstract class JpegCommonBase
{
internal enum JpegState
{
DESTROYED = 0,
CSTATE_START = 100, /* after create_compress */
CSTATE_SCANNING = 101, /* start_compress done, write_scanlines OK */
CSTATE_RAW_OK = 102, /* start_compress done, write_raw_data OK */
CSTATE_WRCOEFS = 103, /* jpeg_write_coefficients done */
DSTATE_START = 200, /* after create_decompress */
DSTATE_INHEADER = 201, /* reading header markers, no SOS yet */
DSTATE_READY = 202, /* found SOS, ready for start_decompress */
DSTATE_PRELOAD = 203, /* reading multi-scan file in start_decompress*/
DSTATE_PRESCAN = 204, /* performing dummy pass for 2-pass quant */
DSTATE_SCANNING = 205, /* start_decompress done, read_scanlines OK */
DSTATE_RAW_OK = 206, /* start_decompress done, read_raw_data OK */
DSTATE_BUFIMAGE = 207, /* expecting jpeg_start_output */
DSTATE_BUFPOST = 208, /* looking for SOS/EOI in jpeg_finish_output */
DSTATE_RDCOEFS = 209, /* reading file in jpeg_read_coefficients */
DSTATE_STOPPING = 210 /* looking for EOI in jpeg_finish_decompress */
}
internal JpegState m_global_state; /* For checking call sequence validity */
/// <summary>
/// Base constructor.
/// </summary>
/// <seealso cref="JpegCompressor"/>
/// <seealso cref="JpegDecompressor"/>
public JpegCommonBase()
{
}
/// <summary>
/// Gets a value indicating whether this instance is Jpeg decompressor.
/// </summary>
/// <value>
/// <c>true</c> if this is Jpeg decompressor; otherwise, <c>false</c>.
/// </value>
public abstract bool IsDecompressor
{
get;
}
/// <summary>
/// Gets the version of LibJpeg.
/// </summary>
/// <value>The version of LibJpeg.</value>
public static string Version
{
get
{
return "Special Compilation for Cosmos. Based on version 1.2.300.0 of LibJpeg.Net";
}
}
/// <summary>
/// Gets the LibJpeg's copyright.
/// </summary>
/// <value>The copyright.</value>
public static string Copyright
{
get
{
return "Copyright (C) 2008-2011, Bit Miracle";
}
}
/// <summary>
/// Creates the array of samples.
/// </summary>
/// <param name="samplesPerRow">The number of samples in row.</param>
/// <param name="numberOfRows">The number of rows.</param>
/// <returns>The array of samples.</returns>
public static JpegVirtualArray<byte> CreateSamplesArray(int samplesPerRow, int numberOfRows)
{
return new JpegVirtualArray<byte>(samplesPerRow, numberOfRows, AllocJpegSamples);
}
/// <summary>
/// Creates the array of blocks.
/// </summary>
/// <param name="blocksPerRow">The number of blocks in row.</param>
/// <param name="numberOfRows">The number of rows.</param>
/// <returns>The array of blocks.</returns>
/// <seealso cref="JpegBlock"/>
public static JpegVirtualArray<JpegBlock> CreateBlocksArray(int blocksPerRow, int numberOfRows)
{
return new JpegVirtualArray<JpegBlock>(blocksPerRow, numberOfRows, allocJpegBlocks);
}
/// <summary>
/// Creates 2-D sample array.
/// </summary>
/// <param name="samplesPerRow">The number of samples per row.</param>
/// <param name="numberOfRows">The number of rows.</param>
/// <returns>The array of samples.</returns>
public static byte[][] AllocJpegSamples(int samplesPerRow, int numberOfRows)
{
byte[][] result = new byte[numberOfRows][];
for (int i = 0; i < numberOfRows; ++i)
result[i] = new byte[samplesPerRow];
return result;
}
// Creation of 2-D block arrays.
private static JpegBlock[][] allocJpegBlocks(int blocksPerRow, int numberOfRows)
{
JpegBlock[][] result = new JpegBlock[numberOfRows][];
for (int i = 0; i < numberOfRows; ++i)
{
result[i] = new JpegBlock[blocksPerRow];
for (int j = 0; j < blocksPerRow; ++j)
result[i][j] = new JpegBlock();
}
return result;
}
// Generic versions of jpeg_abort and jpeg_destroy that work on either
// flavor of JPEG object. These may be more convenient in some places.
/// <summary>
/// Abort processing of a JPEG compression or decompression operation,
/// but don't destroy the object itself.
///
/// Closing a data source or destination, if necessary, is the
/// application's responsibility.
/// </summary>
public void jpeg_abort()
{
/* Reset overall state for possible reuse of object */
if (IsDecompressor)
{
m_global_state = JpegState.DSTATE_START;
/* Try to keep application from accessing now-deleted marker list.
* A bit kludgy to do it here, but this is the most central place.
*/
JpegDecompressor s = this as JpegDecompressor;
if (s != null)
s.m_marker_list = null;
}
else
{
m_global_state = JpegState.CSTATE_START;
}
}
/// <summary>
/// Destruction of a JPEG object.
///
/// Closing a data source or destination, if necessary, is the
/// application's responsibility.
/// </summary>
public void jpeg_destroy()
{
// mark it destroyed
m_global_state = JpegState.DESTROYED;
}
}
#endregion
#region JpegComponent
/// <summary>
/// Basic info about one component (color channel).
/// </summary>
public class JpegComponent
{
/* These values are fixed over the whole image. */
/* For compression, they must be supplied by parameter setup; */
/* for decompression, they are read from the SOF marker. */
private int component_id;
private int component_index;
private int h_samp_factor;
private int v_samp_factor;
private int quant_tbl_no;
/* These values may vary between scans. */
/* For compression, they must be supplied by parameter setup; */
/* for decompression, they are read from the SOS marker. */
/* The decompressor output side may not use these variables. */
private int dc_tbl_no;
private int ac_tbl_no;
/* Remaining fields should be treated as private by applications. */
/* These values are computed during compression or decompression startup: */
/* Component's size in DCT blocks.
* Any dummy blocks added to complete an MCU are not counted; therefore
* these values do not depend on whether a scan is interleaved or not.
*/
private int width_in_blocks;
internal int height_in_blocks;
/* Size of a DCT block in samples. Always DCTSize for compression.
* For decompression this is the size of the output from one DCT block,
* reflecting any scaling we choose to apply during the IDCT step.
* Values of 1,2,4,8 are likely to be supported. Note that different
* components may receive different IDCT scalings.
*/
internal int DCT_scaled_size;
/* The downsampled dimensions are the component's actual, unpadded number
* of samples at the main buffer (preprocessing/compression interface), thus
* downsampled_width = ceil(image_width * Hi/Hmax)
* and similarly for height. For decompression, IDCT scaling is included, so
* downsampled_width = ceil(image_width * Hi/Hmax * DCT_scaled_size/DCTSize)
*/
internal int downsampled_width; /* actual width in samples */
internal int downsampled_height; /* actual height in samples */
/* This flag is used only for decompression. In cases where some of the
* components will be ignored (eg grayscale output from YCbCr image),
* we can skip most computations for the unused components.
*/
internal bool component_needed; /* do we need the value of this component? */
/* These values are computed before starting a scan of the component. */
/* The decompressor output side may not use these variables. */
internal int MCU_width; /* number of blocks per MCU, horizontally */
internal int MCU_height; /* number of blocks per MCU, vertically */
internal int MCU_blocks; /* MCU_width * MCU_height */
internal int MCU_sample_width; /* MCU width in samples, MCU_width*DCT_scaled_size */
internal int last_col_width; /* # of non-dummy blocks across in last MCU */
internal int last_row_height; /* # of non-dummy blocks down in last MCU */
/* Saved quantization table for component; null if none yet saved.
* See JpegInputController comments about the need for this information.
* This field is currently used only for decompression.
*/
internal JpegQuantizationTable quant_table;
internal JpegComponent()
{
}
internal void Assign(JpegComponent ci)
{
component_id = ci.component_id;
component_index = ci.component_index;
h_samp_factor = ci.h_samp_factor;
v_samp_factor = ci.v_samp_factor;
quant_tbl_no = ci.quant_tbl_no;
dc_tbl_no = ci.dc_tbl_no;
ac_tbl_no = ci.ac_tbl_no;
width_in_blocks = ci.width_in_blocks;
height_in_blocks = ci.height_in_blocks;
DCT_scaled_size = ci.DCT_scaled_size;
downsampled_width = ci.downsampled_width;
downsampled_height = ci.downsampled_height;
component_needed = ci.component_needed;
MCU_width = ci.MCU_width;
MCU_height = ci.MCU_height;
MCU_blocks = ci.MCU_blocks;
MCU_sample_width = ci.MCU_sample_width;
last_col_width = ci.last_col_width;
last_row_height = ci.last_row_height;
quant_table = ci.quant_table;
}
/// <summary>
/// Identifier for this component (0..255)
/// </summary>
/// <value>The component ID.</value>
public int Component_id
{
get { return component_id; }
set { component_id = value; }
}
/// <summary>
/// Its index in SOF or <see cref="JpegDecompressor.Comp_info"/>.
/// </summary>
/// <value>The component index.</value>
public int Component_index
{
get { return component_index; }
set { component_index = value; }
}
/// <summary>
/// Horizontal sampling factor (1..4)
/// </summary>
/// <value>The horizontal sampling factor.</value>
public int H_samp_factor
{
get { return h_samp_factor; }
set { h_samp_factor = value; }
}
/// <summary>
/// Vertical sampling factor (1..4)
/// </summary>
/// <value>The vertical sampling factor.</value>
public int V_samp_factor
{
get { return v_samp_factor; }
set { v_samp_factor = value; }
}
/// <summary>
/// Quantization table selector (0..3)
/// </summary>
/// <value>The quantization table selector.</value>
public int Quant_tbl_no
{
get { return quant_tbl_no; }
set { quant_tbl_no = value; }
}
/// <summary>
/// DC entropy table selector (0..3)
/// </summary>
/// <value>The DC entropy table selector.</value>
public int Dc_tbl_no
{
get { return dc_tbl_no; }
set { dc_tbl_no = value; }
}
/// <summary>
/// AC entropy table selector (0..3)
/// </summary>
/// <value>The AC entropy table selector.</value>
public int Ac_tbl_no
{
get { return ac_tbl_no; }
set { ac_tbl_no = value; }
}
/// <summary>
/// Gets or sets the width in blocks.
/// </summary>
/// <value>The width in blocks.</value>
public int Width_in_blocks
{
get { return width_in_blocks; }
set { width_in_blocks = value; }
}
/// <summary>
/// Gets the downsampled width.
/// </summary>
/// <value>The downsampled width.</value>
public int Downsampled_width
{
get { return downsampled_width; }
}
internal static JpegComponent[] createArrayOfComponents(int length)
{
if (length < 0)
throw new ArgumentOutOfRangeException("length");
JpegComponent[] result = new JpegComponent[length];
for (int i = 0; i < result.Length; ++i)
result[i] = new JpegComponent();
return result;
}
}
#endregion
#region JpegConstants
/// <summary>
/// Defines some JPEG constants.
/// </summary>
public static class JpegConstants
{
//////////////////////////////////////////////////////////////////////////
// All of these are specified by the JPEG standard, so don't change them
// if you want to be compatible.
//
/// <summary>
/// The basic DCT block is 8x8 samples
/// </summary>
public const int DCTSize = 8;
/// <summary>
/// DCTSize squared; the number of elements in a block.
/// </summary>
public const int DCTSize2 = DCTSize * DCTSize;
/// <summary>
/// Quantization tables are numbered 0..3
/// </summary>
public const int NumberOfQuantTables = 4;
/// <summary>
/// Huffman tables are numbered 0..3
/// </summary>
public const int NumberOfHuffmanTables = 4;
/// <summary>
/// JPEG limit on the number of components in one scan.
/// </summary>
public const int MaxComponentsInScan = 4;
// compressor's limit on blocks per MCU
//
// Unfortunately, some bozo at Adobe saw no reason to be bound by the standard;
// the PostScript DCT filter can emit files with many more than 10 blocks/MCU.
// If you happen to run across such a file, you can up DecompressorMaxBlocksInMCU
// to handle it. We even let you do this from the jconfig.h file. However,
// we strongly discourage changing CompressorMaxBlocksInMCU; just because Adobe
// sometimes emits noncompliant files doesn't mean you should too.
/// <summary>
/// Compressor's limit on blocks per MCU.
/// </summary>
public const int CompressorMaxBlocksInMCU = 10;
/// <summary>
/// Decompressor's limit on blocks per MCU.
/// </summary>
public const int DecompressorMaxBlocksInMCU = 10;
/// <summary>
/// JPEG limit on sampling factors.
/// </summary>
public const int MaxSamplingFactor = 4;
//////////////////////////////////////////////////////////////////////////
// implementation-specific constants
//
// Maximum number of components (color channels) allowed in JPEG image.
// To meet the letter of the JPEG spec, set this to 255. However, darn
// few applications need more than 4 channels (maybe 5 for CMYK + alpha
// mask). We recommend 10 as a reasonable compromise; use 4 if you are
// really short on memory. (Each allowed component costs a hundred or so
// bytes of storage, whether actually used in an image or not.)
/// <summary>
/// Maximum number of color channels allowed in JPEG image.
/// </summary>
public const int MaxComponents = 10;
/// <summary>
/// The size of sample.
/// </summary>
/// <remarks>Is either:
/// 8 - for 8-bit sample values (the usual setting)<br/>
/// 12 - for 12-bit sample values (not supported by this version)<br/>
/// Only 8 and 12 are legal data precisions for lossy JPEG according to the JPEG standard.
/// Although original IJG code claims it supports 12 bit images, our code does not support
/// anything except 8-bit images.</remarks>
public const int BitsInSample = 8;
/// <summary>
/// DCT method used by default.
/// </summary>
public static DCTMethod DefaultDCTMethod = DCTMethod.IntSlow;
/// <summary>
/// Fastest DCT method.
/// </summary>
public static DCTMethod FastestDCTMethod = DCTMethod.IntFast;
/// <summary>
/// A tad under 64K to prevent overflows.
/// </summary>
public const int JpegMaxDimention = 65500;
/// <summary>
/// The maximum sample value.
/// </summary>
public const int MaxSampleValue = 255;
/// <summary>
/// The medium sample value.
/// </summary>
public const int MediumSampleValue = 128;
// Ordering of RGB data in scanlines passed to or from the application.
// RESTRICTIONS:
// 1. These macros only affect RGB<=>YCbCr color conversion, so they are not
// useful if you are using JPEG color spaces other than YCbCr or grayscale.
// 2. The color quantizer modules will not behave desirably if RGB_PixelLength
// is not 3 (they don't understand about dummy color components!). So you
// can't use color quantization if you change that value.
/// <summary>
/// Offset of Red in an RGB scanline element.
/// </summary>
public const int Offset_RGB_Red = 0;
/// <summary>
/// Offset of Green in an RGB scanline element.
/// </summary>
public const int Offset_RGB_Green = 1;
/// <summary>
/// Offset of Blue in an RGB scanline element.
/// </summary>
public const int Offset_RGB_Blue = 2;
/// <summary>
/// Bytes per RGB scanline element.
/// </summary>
public const int RGB_PixelLength = 3;
/// <summary>
/// The number of bits of lookahead.
/// </summary>
public const int HuffmanLookaheadDistance = 8;
}
#endregion
#region JpegDownsampler
/// <summary>
/// Downsampling
/// </summary>
class JpegDownsampler
{
private enum downSampleMethod
{
fullsize_smooth_downsampler,
fullsize_downsampler,
h2v1_downsampler,
h2v2_smooth_downsampler,
h2v2_downsampler,
int_downsampler
};
/* Downsamplers, one per component */
private downSampleMethod[] m_downSamplers = new downSampleMethod[JpegConstants.MaxComponents];
private JpegCompressor m_cinfo;
private bool m_need_context_rows; /* true if need rows above & below */
public JpegDownsampler(JpegCompressor cinfo)
{
m_cinfo = cinfo;
m_need_context_rows = false;
if (cinfo.m_CCIR601_sampling)
throw new Exception("CCIR601 sampling not implemented yet");
/* Verify we can handle the sampling factors, and set up method pointers */
for (int ci = 0; ci < cinfo.m_num_components; ci++)
{
JpegComponent componentInfo = cinfo.Component_info[ci];
if (componentInfo.H_samp_factor == cinfo.m_max_h_samp_factor &&
componentInfo.V_samp_factor == cinfo.m_max_v_samp_factor)
{
if (cinfo.m_smoothing_factor != 0)
{
m_downSamplers[ci] = downSampleMethod.fullsize_smooth_downsampler;
m_need_context_rows = true;
}
else
{
m_downSamplers[ci] = downSampleMethod.fullsize_downsampler;
}
}
else if (componentInfo.H_samp_factor * 2 == cinfo.m_max_h_samp_factor &&
componentInfo.V_samp_factor == cinfo.m_max_v_samp_factor)
{
m_downSamplers[ci] = downSampleMethod.h2v1_downsampler;
}
else if (componentInfo.H_samp_factor * 2 == cinfo.m_max_h_samp_factor &&
componentInfo.V_samp_factor * 2 == cinfo.m_max_v_samp_factor)
{
if (cinfo.m_smoothing_factor != 0)
{
m_downSamplers[ci] = downSampleMethod.h2v2_smooth_downsampler;
m_need_context_rows = true;
}
else
{
m_downSamplers[ci] = downSampleMethod.h2v2_downsampler;
}
}
else if ((cinfo.m_max_h_samp_factor % componentInfo.H_samp_factor) == 0 &&
(cinfo.m_max_v_samp_factor % componentInfo.V_samp_factor) == 0)
{
m_downSamplers[ci] = downSampleMethod.int_downsampler;
}
else
throw new Exception("Fractional sampling not implemented yet");
}
}
/// <summary>
/// Do downsampling for a whole row group (all components).
///
/// In this version we simply downsample each component independently.
/// </summary>
public void downsample(byte[][][] input_buf, int in_row_index, byte[][][] output_buf, int out_row_group_index)
{
for (int ci = 0; ci < m_cinfo.m_num_components; ci++)
{
int outIndex = out_row_group_index * m_cinfo.Component_info[ci].V_samp_factor;
switch (m_downSamplers[ci])
{
case downSampleMethod.fullsize_smooth_downsampler:
fullsize_smooth_downsample(ci, input_buf[ci], in_row_index, output_buf[ci], outIndex);
break;
case downSampleMethod.fullsize_downsampler:
fullsize_downsample(ci, input_buf[ci], in_row_index, output_buf[ci], outIndex);
break;
case downSampleMethod.h2v1_downsampler:
h2v1_downsample(ci, input_buf[ci], in_row_index, output_buf[ci], outIndex);
break;
case downSampleMethod.h2v2_smooth_downsampler:
h2v2_smooth_downsample(ci, input_buf[ci], in_row_index, output_buf[ci], outIndex);
break;
case downSampleMethod.h2v2_downsampler:
h2v2_downsample(ci, input_buf[ci], in_row_index, output_buf[ci], outIndex);
break;
case downSampleMethod.int_downsampler:
int_downsample(ci, input_buf[ci], in_row_index, output_buf[ci], outIndex);
break;
};
}
}
public bool NeedContextRows()
{
return m_need_context_rows;
}
/// <summary>
/// Downsample pixel values of a single component.
/// One row group is processed per call.
/// This version handles arbitrary integral sampling ratios, without smoothing.
/// Note that this version is not actually used for customary sampling ratios.
/// </summary>
private void int_downsample(int componentIndex, byte[][] input_data, int startInputRow, byte[][] output_data, int startOutRow)
{
/* Expand input data enough to let all the output samples be generated
* by the standard loop. Special-casing padded output would be more
* efficient.
*/
int output_cols = m_cinfo.Component_info[componentIndex].Width_in_blocks * JpegConstants.DCTSize;
int h_expand = m_cinfo.m_max_h_samp_factor / m_cinfo.Component_info[componentIndex].H_samp_factor;
expand_right_edge(input_data, startInputRow, m_cinfo.m_max_v_samp_factor, m_cinfo.m_image_width, output_cols * h_expand);
int v_expand = m_cinfo.m_max_v_samp_factor / m_cinfo.Component_info[componentIndex].V_samp_factor;
int numpix = h_expand * v_expand;
int numpix2 = numpix / 2;
int inrow = 0;
for (int outrow = 0; outrow < m_cinfo.Component_info[componentIndex].V_samp_factor; outrow++)
{
for (int outcol = 0, outcol_h = 0; outcol < output_cols; outcol++, outcol_h += h_expand)
{
int outvalue = 0;
for (int v = 0; v < v_expand; v++)
{
for (int h = 0; h < h_expand; h++)
outvalue += input_data[startInputRow + inrow + v][outcol_h + h];
}
output_data[startOutRow + outrow][outcol] = (byte)((outvalue + numpix2) / numpix);
}
inrow += v_expand;
}
}
/// <summary>
/// Downsample pixel values of a single component.
/// This version handles the special case of a full-size component,
/// without smoothing.
/// </summary>
private void fullsize_downsample(int componentIndex, byte[][] input_data, int startInputRow, byte[][] output_data, int startOutRow)
{
/* Copy the data */
JpegUtils.jcopy_sample_rows(input_data, startInputRow, output_data, startOutRow, m_cinfo.m_max_v_samp_factor, m_cinfo.m_image_width);
/* Edge-expand */
expand_right_edge(output_data, startOutRow, m_cinfo.m_max_v_samp_factor, m_cinfo.m_image_width, m_cinfo.Component_info[componentIndex].Width_in_blocks * JpegConstants.DCTSize);
}
/// <summary>
/// Downsample pixel values of a single component.
/// This version handles the common case of 2:1 horizontal and 1:1 vertical,
/// without smoothing.
///
/// A note about the "bias" calculations: when rounding fractional values to
/// integer, we do not want to always round 0.5 up to the next integer.
/// If we did that, we'd introduce a noticeable bias towards larger values.
/// Instead, this code is arranged so that 0.5 will be rounded up or down at
/// alternate pixel locations (a simple ordered dither pattern).
/// </summary>
private void h2v1_downsample(int componentIndex, byte[][] input_data, int startInputRow, byte[][] output_data, int startOutRow)
{
/* Expand input data enough to let all the output samples be generated
* by the standard loop. Special-casing padded output would be more
* efficient.
*/
int output_cols = m_cinfo.Component_info[componentIndex].Width_in_blocks * JpegConstants.DCTSize;
expand_right_edge(input_data, startInputRow, m_cinfo.m_max_v_samp_factor, m_cinfo.m_image_width, output_cols * 2);
for (int outrow = 0; outrow < m_cinfo.Component_info[componentIndex].V_samp_factor; outrow++)
{
/* bias = 0,1,0,1,... for successive samples */
int bias = 0;
int inputColumn = 0;
for (int outcol = 0; outcol < output_cols; outcol++)
{
output_data[startOutRow + outrow][outcol] = (byte)(
((int)input_data[startInputRow + outrow][inputColumn] +
(int)input_data[startInputRow + outrow][inputColumn + 1] + bias) >> 1);
bias ^= 1; /* 0=>1, 1=>0 */
inputColumn += 2;
}
}
}
/// <summary>
/// Downsample pixel values of a single component.
/// This version handles the standard case of 2:1 horizontal and 2:1 vertical,
/// without smoothing.
/// </summary>
private void h2v2_downsample(int componentIndex, byte[][] input_data, int startInputRow, byte[][] output_data, int startOutRow)
{
/* Expand input data enough to let all the output samples be generated
* by the standard loop. Special-casing padded output would be more
* efficient.
*/
int output_cols = m_cinfo.Component_info[componentIndex].Width_in_blocks * JpegConstants.DCTSize;
expand_right_edge(input_data, startInputRow, m_cinfo.m_max_v_samp_factor, m_cinfo.m_image_width, output_cols * 2);
int inrow = 0;
for (int outrow = 0; outrow < m_cinfo.Component_info[componentIndex].V_samp_factor; outrow++)
{
/* bias = 1,2,1,2,... for successive samples */
int bias = 1;
int inputColumn = 0;
for (int outcol = 0; outcol < output_cols; outcol++)
{
output_data[startOutRow + outrow][outcol] = (byte)((
(int)input_data[startInputRow + inrow][inputColumn] +
(int)input_data[startInputRow + inrow][inputColumn + 1] +
(int)input_data[startInputRow + inrow + 1][inputColumn] +
(int)input_data[startInputRow + inrow + 1][inputColumn + 1] + bias) >> 2);
bias ^= 3; /* 1=>2, 2=>1 */
inputColumn += 2;
}
inrow += 2;
}
}
/// <summary>
/// Downsample pixel values of a single component.
/// This version handles the standard case of 2:1 horizontal and 2:1 vertical,
/// with smoothing. One row of context is required.
/// </summary>
private void h2v2_smooth_downsample(int componentIndex, byte[][] input_data, int startInputRow, byte[][] output_data, int startOutRow)
{
/* Expand input data enough to let all the output samples be generated
* by the standard loop. Special-casing padded output would be more
* efficient.
*/
int output_cols = m_cinfo.Component_info[componentIndex].Width_in_blocks * JpegConstants.DCTSize;
expand_right_edge(input_data, startInputRow - 1, m_cinfo.m_max_v_samp_factor + 2, m_cinfo.m_image_width, output_cols * 2);
/* We don't bother to form the individual "smoothed" input pixel values;
* we can directly compute the output which is the average of the four
* smoothed values. Each of the four member pixels contributes a fraction
* (1-8*SF) to its own smoothed image and a fraction SF to each of the three
* other smoothed pixels, therefore a total fraction (1-5*SF)/4 to the final
* output. The four corner-adjacent neighbor pixels contribute a fraction
* SF to just one smoothed pixel, or SF/4 to the final output; while the
* eight edge-adjacent neighbors contribute SF to each of two smoothed
* pixels, or SF/2 overall. In order to use integer arithmetic, these
* factors are scaled by 2^16 = 65536.
* Also recall that SF = smoothing_factor / 1024.
*/
int memberscale = 16384 - m_cinfo.m_smoothing_factor * 80; /* scaled (1-5*SF)/4 */
int neighscale = m_cinfo.m_smoothing_factor * 16; /* scaled SF/4 */
for (int inrow = 0, outrow = 0; outrow < m_cinfo.Component_info[componentIndex].V_samp_factor; outrow++)
{
int outIndex = 0;
int inIndex0 = 0;
int inIndex1 = 0;
int aboveIndex = 0;
int belowIndex = 0;
/* Special case for first column: pretend column -1 is same as column 0 */
int membersum = input_data[startInputRow + inrow][inIndex0] +
input_data[startInputRow + inrow][inIndex0 + 1] +
input_data[startInputRow + inrow + 1][inIndex1] +
input_data[startInputRow + inrow + 1][inIndex1 + 1];
int neighsum = input_data[startInputRow + inrow - 1][aboveIndex] +
input_data[startInputRow + inrow - 1][aboveIndex + 1] +
input_data[startInputRow + inrow + 2][belowIndex] +
input_data[startInputRow + inrow + 2][belowIndex + 1] +
input_data[startInputRow + inrow][inIndex0] +
input_data[startInputRow + inrow][inIndex0 + 2] +
input_data[startInputRow + inrow + 1][inIndex1] +
input_data[startInputRow + inrow + 1][inIndex1 + 2];
neighsum += neighsum;
neighsum += input_data[startInputRow + inrow - 1][aboveIndex] +
input_data[startInputRow + inrow - 1][aboveIndex + 2] +
input_data[startInputRow + inrow + 2][belowIndex] +
input_data[startInputRow + inrow + 2][belowIndex + 2];
membersum = membersum * memberscale + neighsum * neighscale;
output_data[startOutRow + outrow][outIndex] = (byte)((membersum + 32768) >> 16);
outIndex++;
inIndex0 += 2;
inIndex1 += 2;
aboveIndex += 2;
belowIndex += 2;
for (int colctr = output_cols - 2; colctr > 0; colctr--)
{
/* sum of pixels directly mapped to this output element */
membersum = input_data[startInputRow + inrow][inIndex0] +
input_data[startInputRow + inrow][inIndex0 + 1] +
input_data[startInputRow + inrow + 1][inIndex1] +
input_data[startInputRow + inrow + 1][inIndex1 + 1];
/* sum of edge-neighbor pixels */
neighsum = input_data[startInputRow + inrow - 1][aboveIndex] +
input_data[startInputRow + inrow - 1][aboveIndex + 1] +
input_data[startInputRow + inrow + 2][belowIndex] +
input_data[startInputRow + inrow + 2][belowIndex + 1] +
input_data[startInputRow + inrow][inIndex0 - 1] +
input_data[startInputRow + inrow][inIndex0 + 2] +
input_data[startInputRow + inrow + 1][inIndex1 - 1] +
input_data[startInputRow + inrow + 1][inIndex1 + 2];
/* The edge-neighbors count twice as much as corner-neighbors */
neighsum += neighsum;
/* Add in the corner-neighbors */
neighsum += input_data[startInputRow + inrow - 1][aboveIndex - 1] +
input_data[startInputRow + inrow - 1][aboveIndex + 2] +
input_data[startInputRow + inrow + 2][belowIndex - 1] +
input_data[startInputRow + inrow + 2][belowIndex + 2];
/* form final output scaled up by 2^16 */
membersum = membersum * memberscale + neighsum * neighscale;
/* round, descale and output it */
output_data[startOutRow + outrow][outIndex] = (byte)((membersum + 32768) >> 16);
outIndex++;
inIndex0 += 2;
inIndex1 += 2;
aboveIndex += 2;
belowIndex += 2;
}
/* Special case for last column */
membersum = input_data[startInputRow + inrow][inIndex0] +
input_data[startInputRow + inrow][inIndex0 + 1] +
input_data[startInputRow + inrow + 1][inIndex1] +
input_data[startInputRow + inrow + 1][inIndex1 + 1];
neighsum = input_data[startInputRow + inrow - 1][aboveIndex] +
input_data[startInputRow + inrow - 1][aboveIndex + 1] +
input_data[startInputRow + inrow + 2][belowIndex] +
input_data[startInputRow + inrow + 2][belowIndex + 1] +
input_data[startInputRow + inrow][inIndex0 - 1] +
input_data[startInputRow + inrow][inIndex0 + 1] +
input_data[startInputRow + inrow + 1][inIndex1 - 1] +
input_data[startInputRow + inrow + 1][inIndex1 + 1];
neighsum += neighsum;
neighsum += input_data[startInputRow + inrow - 1][aboveIndex - 1] +
input_data[startInputRow + inrow - 1][aboveIndex + 1] +
input_data[startInputRow + inrow + 2][belowIndex - 1] +
input_data[startInputRow + inrow + 2][belowIndex + 1];
membersum = membersum * memberscale + neighsum * neighscale;
output_data[startOutRow + outrow][outIndex] = (byte)((membersum + 32768) >> 16);
inrow += 2;
}
}
/// <summary>
/// Downsample pixel values of a single component.
/// This version handles the special case of a full-size component,
/// with smoothing. One row of context is required.
/// </summary>
private void fullsize_smooth_downsample(int componentIndex, byte[][] input_data, int startInputRow, byte[][] output_data, int startOutRow)
{
/* Expand input data enough to let all the output samples be generated
* by the standard loop. Special-casing padded output would be more
* efficient.
*/
int output_cols = m_cinfo.Component_info[componentIndex].Width_in_blocks * JpegConstants.DCTSize;
expand_right_edge(input_data, startInputRow - 1, m_cinfo.m_max_v_samp_factor + 2, m_cinfo.m_image_width, output_cols);
/* Each of the eight neighbor pixels contributes a fraction SF to the
* smoothed pixel, while the main pixel contributes (1-8*SF). In order
* to use integer arithmetic, these factors are multiplied by 2^16 = 65536.
* Also recall that SF = smoothing_factor / 1024.
*/
int memberscale = 65536 - m_cinfo.m_smoothing_factor * 512; /* scaled 1-8*SF */
int neighscale = m_cinfo.m_smoothing_factor * 64; /* scaled SF */
for (int outrow = 0; outrow < m_cinfo.Component_info[componentIndex].V_samp_factor; outrow++)
{
int outIndex = 0;
int inIndex = 0;
int aboveIndex = 0;
int belowIndex = 0;
/* Special case for first column */
int colsum = input_data[startInputRow + outrow - 1][aboveIndex] +
input_data[startInputRow + outrow + 1][belowIndex] +
input_data[startInputRow + outrow][inIndex];
aboveIndex++;
belowIndex++;
int membersum = input_data[startInputRow + outrow][inIndex];
inIndex++;
int nextcolsum = input_data[startInputRow + outrow - 1][aboveIndex] +
input_data[startInputRow + outrow + 1][belowIndex] +
input_data[startInputRow + outrow][inIndex];
int neighsum = colsum + (colsum - membersum) + nextcolsum;
membersum = membersum * memberscale + neighsum * neighscale;
output_data[startOutRow + outrow][outIndex] = (byte)((membersum + 32768) >> 16);
outIndex++;
int lastcolsum = colsum;
colsum = nextcolsum;
for (int colctr = output_cols - 2; colctr > 0; colctr--)
{
membersum = input_data[startInputRow + outrow][inIndex];
inIndex++;
aboveIndex++;
belowIndex++;
nextcolsum = input_data[startInputRow + outrow - 1][aboveIndex] +
input_data[startInputRow + outrow + 1][belowIndex] +
input_data[startInputRow + outrow][inIndex];
neighsum = lastcolsum + (colsum - membersum) + nextcolsum;
membersum = membersum * memberscale + neighsum * neighscale;
output_data[startOutRow + outrow][outIndex] = (byte)((membersum + 32768) >> 16);
outIndex++;
lastcolsum = colsum;
colsum = nextcolsum;
}
/* Special case for last column */
membersum = input_data[startInputRow + outrow][inIndex];
neighsum = lastcolsum + (colsum - membersum) + colsum;
membersum = membersum * memberscale + neighsum * neighscale;
output_data[startOutRow + outrow][outIndex] = (byte)((membersum + 32768) >> 16);
}
}
/// <summary>
/// Expand a component horizontally from width input_cols to width output_cols,
/// by duplicating the rightmost samples.
/// </summary>
private static void expand_right_edge(byte[][] image_data, int startInputRow, int num_rows, int input_cols, int output_cols)
{
int numcols = output_cols - input_cols;
if (numcols > 0)
{
for (int row = startInputRow; row < (startInputRow + num_rows); row++)
{
/* don't need GETJSAMPLE() here */
byte pixval = image_data[row][input_cols - 1];
for (int count = 0; count < numcols; count++)
image_data[row][input_cols + count] = pixval;
}
}
}
}
#endregion
#region JpegEntropyDecoder
/// <summary>
/// Entropy decoding
/// </summary>
abstract class JpegEntropyDecoder
{
// Figure F.12: extend sign bit.
// entry n is 2**(n-1)
private static int[] extend_test =
{
0, 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020,
0x0040, 0x0080, 0x0100, 0x0200, 0x0400, 0x0800,
0x1000, 0x2000, 0x4000
};
// entry n is (-1 << n) + 1
private static int[] extend_offset =
{
0, (-1 << 1) + 1, (-1 << 2) + 1,
(-1 << 3) + 1, (-1 << 4) + 1, (-1 << 5) + 1,
(-1 << 6) + 1, (-1 << 7) + 1, (-1 << 8) + 1,
(-1 << 9) + 1, (-1 << 10) + 1,
(-1 << 11) + 1, (-1 << 12) + 1,
(-1 << 13) + 1, (-1 << 14) + 1,
(-1 << 15) + 1
};
/* Fetching the next N bits from the input stream is a time-critical operation
* for the Huffman decoders. We implement it with a combination of inline
* macros and out-of-line subroutines. Note that N (the number of bits
* demanded at one time) never exceeds 15 for JPEG use.
*
* We read source bytes into get_buffer and dole out bits as needed.
* If get_buffer already contains enough bits, they are fetched in-line
* by the macros CHECK_BIT_BUFFER and GET_BITS. When there aren't enough
* bits, jpeg_fill_bit_buffer is called; it will attempt to fill get_buffer
* as full as possible (not just to the number of bits needed; this
* prefetching reduces the overhead cost of calling jpeg_fill_bit_buffer).
* Note that jpeg_fill_bit_buffer may return false to indicate suspension.
* On true return, jpeg_fill_bit_buffer guarantees that get_buffer contains
* at least the requested number of bits --- dummy zeroes are inserted if
* necessary.
*/
protected const int BIT_BUF_SIZE = 32; /* size of buffer in bits */
/*
* Out-of-line code for bit fetching (shared with jdphuff.c).
* See jdhuff.h for info about usage.
* Note: current values of get_buffer and bits_left are passed as parameters,
* but are returned in the corresponding fields of the state struct.
*
* On most machines MIN_GET_BITS should be 25 to allow the full 32-bit width
* of get_buffer to be used. (On machines with wider words, an even larger
* buffer could be used.) However, on some machines 32-bit shifts are
* quite slow and take time proportional to the number of places shifted.
* (This is true with most PC compilers, for instance.) In this case it may
* be a win to set MIN_GET_BITS to the minimum value of 15. This reduces the
* average shift distance at the cost of more calls to jpeg_fill_bit_buffer.
*/
protected const int MIN_GET_BITS = BIT_BUF_SIZE - 7;
protected JpegDecompressor m_cinfo;
/* This is here to share code between baseline and progressive decoders; */
/* other modules probably should not use it */
protected bool m_insufficient_data; /* set true after emitting warning */
public abstract void start_pass();
public abstract bool decode_mcu(JpegBlock[] MCU_data);
protected static int HUFF_EXTEND(int x, int s)
{
return ((x) < extend_test[s] ? (x) + extend_offset[s] : (x));
}
protected void BITREAD_LOAD_STATE(SavedBitreadState bitstate, out int get_buffer, out int bits_left, ref WorkingBitreadState br_state)
{
br_state.cinfo = m_cinfo;
get_buffer = bitstate.get_buffer;
bits_left = bitstate.bits_left;
}
protected static void BITREAD_SAVE_STATE(ref SavedBitreadState bitstate, int get_buffer, int bits_left)
{
bitstate.get_buffer = get_buffer;
bitstate.bits_left = bits_left;
}
/// <summary>
/// Expand a Huffman table definition into the derived format
/// This routine also performs some validation checks on the table.
/// </summary>
protected void jpeg_make_d_derived_tbl(bool isDC, int tblno, ref DerivedTable dtbl)
{
/* Note that huffsize[] and huffcode[] are filled in code-length order,
* paralleling the order of the symbols themselves in htbl.huffval[].
*/
/* Find the input Huffman table */
if (tblno < 0 || tblno >= JpegConstants.NumberOfHuffmanTables)
throw new Exception(String.Format("Huffman table 0x{0:X2} was not defined", tblno));
JpegHuffmanTable htbl = isDC ? m_cinfo.m_dc_huff_tbl_ptrs[tblno] : m_cinfo.m_ac_huff_tbl_ptrs[tblno];
if (htbl == null)
throw new Exception(String.Format("Huffman table 0x{0:X2} was not defined", tblno));
/* Allocate a workspace if we haven't already done so. */
if (dtbl == null)
dtbl = new DerivedTable();
dtbl.pub = htbl; /* fill in back link */
/* Figure C.1: make table of Huffman code length for each symbol */
int p = 0;
char[] huffsize = new char[257];
for (int l = 1; l <= 16; l++)
{
int i = htbl.Bits[l];
if (i < 0 || p + i > 256) /* protect against table overrun */
throw new Exception("Bogus Huffman table definition");
while ((i--) != 0)
huffsize[p++] = (char)l;
}
huffsize[p] = (char)0;
int numsymbols = p;
/* Figure C.2: generate the codes themselves */
/* We also validate that the counts represent a legal Huffman code tree. */
int code = 0;
int si = huffsize[0];
int[] huffcode = new int[257];
p = 0;
while (huffsize[p] != 0)
{
while (((int)huffsize[p]) == si)
{
huffcode[p++] = code;
code++;
}
/* code is now 1 more than the last code used for code-length si; but
* it must still fit in si bits, since no code is allowed to be all ones.
*/
if (code >= (1 << si))
throw new Exception("Bogus Huffman table definition");
code <<= 1;
si++;
}
/* Figure F.15: generate decoding tables for bit-sequential decoding */
p = 0;
for (int l = 1; l <= 16; l++)
{
if (htbl.Bits[l] != 0)
{
/* valoffset[l] = huffval[] index of 1st symbol of code length l,
* minus the minimum code of length l
*/
dtbl.valoffset[l] = p - huffcode[p];
p += htbl.Bits[l];
dtbl.maxcode[l] = huffcode[p - 1]; /* maximum code of length l */
}
else
{
/* -1 if no codes of this length */
dtbl.maxcode[l] = -1;
}
}
dtbl.maxcode[17] = 0xFFFFF; /* ensures jpeg_huff_decode terminates */
/* Compute lookahead tables to speed up decoding.
* First we set all the table entries to 0, indicating "too long";
* then we iterate through the Huffman codes that are short enough and
* fill in all the entries that correspond to bit sequences starting
* with that code.
*/
Array.Clear(dtbl.look_nbits, 0, dtbl.look_nbits.Length);
p = 0;
for (int l = 1; l <= JpegConstants.HuffmanLookaheadDistance; l++)
{
for (int i = 1; i <= htbl.Bits[l]; i++, p++)
{
/* l = current code's length, p = its index in huffcode[] & huffval[]. */
/* Generate left-justified code followed by all possible bit sequences */
int lookbits = huffcode[p] << (JpegConstants.HuffmanLookaheadDistance - l);
for (int ctr = 1 << (JpegConstants.HuffmanLookaheadDistance - l); ctr > 0; ctr--)
{
dtbl.look_nbits[lookbits] = l;
dtbl.look_sym[lookbits] = htbl.Huffval[p];
lookbits++;
}
}
}
/* Validate symbols as being reasonable.
* For AC tables, we make no check, but accept all byte values 0..255.
* For DC tables, we require the symbols to be in range 0..15.
* (Tighter bounds could be applied depending on the data depth and mode,
* but this is sufficient to ensure safe decoding.)
*/
if (isDC)
{
for (int i = 0; i < numsymbols; i++)
{
int sym = htbl.Huffval[i];
if (sym < 0 || sym > 15)
throw new Exception("Bogus Huffman table definition");
}
}
}
/*
* These methods provide the in-line portion of bit fetching.
* Use CHECK_BIT_BUFFER to ensure there are N bits in get_buffer
* before using GET_BITS, PEEK_BITS, or DROP_BITS.
* The variables get_buffer and bits_left are assumed to be locals,
* but the state struct might not be (jpeg_huff_decode needs this).
* CHECK_BIT_BUFFER(state,n,action);
* Ensure there are N bits in get_buffer; if suspend, take action.
* val = GET_BITS(n);
* Fetch next N bits.
* val = PEEK_BITS(n);
* Fetch next N bits without removing them from the buffer.
* DROP_BITS(n);
* Discard next N bits.
* The value N should be a simple variable, not an expression, because it
* is evaluated multiple times.
*/
protected static bool CHECK_BIT_BUFFER(ref WorkingBitreadState state, int nbits, ref int get_buffer, ref int bits_left)
{
if (bits_left < nbits)
{
if (!jpeg_fill_bit_buffer(ref state, get_buffer, bits_left, nbits))
return false;
get_buffer = state.get_buffer;
bits_left = state.bits_left;
}
return true;
}
protected static int GET_BITS(int nbits, int get_buffer, ref int bits_left)
{
return (((int)(get_buffer >> (bits_left -= nbits))) & ((1 << nbits) - 1));
}
protected static int PEEK_BITS(int nbits, int get_buffer, int bits_left)
{
return (((int)(get_buffer >> (bits_left - nbits))) & ((1 << nbits) - 1));
}
protected static void DROP_BITS(int nbits, ref int bits_left)
{
bits_left -= nbits;
}
/* Load up the bit buffer to a depth of at least nbits */
protected static bool jpeg_fill_bit_buffer(ref WorkingBitreadState state, int get_buffer, int bits_left, int nbits)
{
/* Attempt to load at least MIN_GET_BITS bits into get_buffer. */
/* (It is assumed that no request will be for more than that many bits.) */
/* We fail to do so only if we hit a marker or are forced to suspend. */
bool noMoreBytes = false;
if (state.cinfo.m_unread_marker == 0)
{
/* cannot advance past a marker */
while (bits_left < MIN_GET_BITS)
{
int c;
state.cinfo.m_src.GetByte(out c);
/* If it's 0xFF, check and discard stuffed zero byte */
if (c == 0xFF)
{
/* Loop here to discard any padding FF's on terminating marker,
* so that we can save a valid unread_marker value. NOTE: we will
* accept multiple FF's followed by a 0 as meaning a single FF data
* byte. This data pattern is not valid according to the standard.
*/
do
{
state.cinfo.m_src.GetByte(out c);
}
while (c == 0xFF);
if (c == 0)
{
/* Found FF/00, which represents an FF data byte */
c = 0xFF;
}
else
{
/* Oops, it's actually a marker indicating end of compressed data.
* Save the marker code for later use.
* Fine point: it might appear that we should save the marker into
* bitread working state, not straight into permanent state. But
* once we have hit a marker, we cannot need to suspend within the
* current MCU, because we will read no more bytes from the data
* source. So it is OK to update permanent state right away.
*/
state.cinfo.m_unread_marker = c;
/* See if we need to insert some fake zero bits. */
noMoreBytes = true;
break;
}
}
/* OK, load c into get_buffer */
get_buffer = (get_buffer << 8) | c;
bits_left += 8;
} /* end while */
}
else
noMoreBytes = true;
if (noMoreBytes)
{
/* We get here if we've read the marker that terminates the compressed
* data segment. There should be enough bits in the buffer register
* to satisfy the request; if so, no problem.
*/
if (nbits > bits_left)
{
/* Uh-oh. Report corrupted data to user and stuff zeroes into
* the data stream, so that we can produce some kind of image.
* We use a nonvolatile flag to ensure that only one warning message
* appears per data segment.
*/
if (!state.cinfo.m_entropy.m_insufficient_data)
{
state.cinfo.m_entropy.m_insufficient_data = true;
}
/* Fill the buffer with zero bits */
get_buffer <<= MIN_GET_BITS - bits_left;
bits_left = MIN_GET_BITS;
}
}
/* Unload the local registers */
state.get_buffer = get_buffer;
state.bits_left = bits_left;
return true;
}
/*
* Code for extracting next Huffman-coded symbol from input bit stream.
* Again, this is time-critical and we make the main paths be macros.
*
* We use a lookahead table to process codes of up to HuffmanLookaheadDistance bits
* without looping. Usually, more than 95% of the Huffman codes will be 8
* or fewer bits long. The few overlength codes are handled with a loop,
* which need not be inline code.
*
* Notes about the HUFF_DECODE macro:
* 1. Near the end of the data segment, we may fail to get enough bits
* for a lookahead. In that case, we do it the hard way.
* 2. If the lookahead table contains no entry, the next code must be
* more than HuffmanLookaheadDistance bits long.
* 3. jpeg_huff_decode returns -1 if forced to suspend.
*/
protected static bool HUFF_DECODE(out int result, ref WorkingBitreadState state, DerivedTable htbl, ref int get_buffer, ref int bits_left)
{
int nb = 0;
bool doSlow = false;
if (bits_left < JpegConstants.HuffmanLookaheadDistance)
{
if (!jpeg_fill_bit_buffer(ref state, get_buffer, bits_left, 0))
{
result = -1;
return false;
}
get_buffer = state.get_buffer;
bits_left = state.bits_left;
if (bits_left < JpegConstants.HuffmanLookaheadDistance)
{
nb = 1;
doSlow = true;
}
}
if (!doSlow)
{
int look = PEEK_BITS(JpegConstants.HuffmanLookaheadDistance, get_buffer, bits_left);
if ((nb = htbl.look_nbits[look]) != 0)
{
DROP_BITS(nb, ref bits_left);
result = htbl.look_sym[look];
return true;
}
nb = JpegConstants.HuffmanLookaheadDistance + 1;
}
result = jpeg_huff_decode(ref state, get_buffer, bits_left, htbl, nb);
if (result < 0)
return false;
get_buffer = state.get_buffer;
bits_left = state.bits_left;
return true;
}
/* Out-of-line case for Huffman code fetching */
protected static int jpeg_huff_decode(ref WorkingBitreadState state, int get_buffer, int bits_left, DerivedTable htbl, int min_bits)
{
/* HUFF_DECODE has determined that the code is at least min_bits */
/* bits long, so fetch that many bits in one swoop. */
int l = min_bits;
if (!CHECK_BIT_BUFFER(ref state, l, ref get_buffer, ref bits_left))
return -1;
int code = GET_BITS(l, get_buffer, ref bits_left);
/* Collect the rest of the Huffman code one bit at a time. */
/* This is per Figure F.16 in the JPEG spec. */
while (code > htbl.maxcode[l])
{
code <<= 1;
if (!CHECK_BIT_BUFFER(ref state, 1, ref get_buffer, ref bits_left))
return -1;
code |= GET_BITS(1, get_buffer, ref bits_left);
l++;
}
/* Unload the local registers */
state.get_buffer = get_buffer;
state.bits_left = bits_left;
/* With garbage input we may reach the sentinel value l = 17. */
if (l > 16)
{
/* fake a zero as the safest result */
return 0;
}
return htbl.pub.Huffval[code + htbl.valoffset[l]];
}
}
#endregion
#region JpegEntropyEncoder
/// <summary>
/// Entropy encoding
/// </summary>
abstract class JpegEntropyEncoder
{
/* Derived data constructed for each Huffman table */
protected class c_derived_tbl
{
public int[] ehufco = new int[256]; /* code for each symbol */
public char[] ehufsi = new char[256]; /* length of code for each symbol */
/* If no code has been allocated for a symbol S, ehufsi[S] contains 0 */
}
/* The legal range of a DCT coefficient is
* -1024 .. +1023 for 8-bit data;
* -16384 .. +16383 for 12-bit data.
* Hence the magnitude should always fit in 10 or 14 bits respectively.
*/
protected static int MAX_HUFFMAN_COEF_BITS = 10;
private static int MAX_CLEN = 32; /* assumed maximum initial code length */
protected JpegCompressor m_cinfo;
public abstract void start_pass(bool gather_statistics);
public abstract bool encode_mcu(JpegBlock[][] MCU_data);
public abstract void finish_pass();
/// <summary>
/// Expand a Huffman table definition into the derived format
/// Compute the derived values for a Huffman table.
/// This routine also performs some validation checks on the table.
/// </summary>
protected void jpeg_make_c_derived_tbl(bool isDC, int tblno, ref c_derived_tbl dtbl)
{
/* Note that huffsize[] and huffcode[] are filled in code-length order,
* paralleling the order of the symbols themselves in htbl.huffval[].
*/
/* Find the input Huffman table */
if (tblno < 0 || tblno >= JpegConstants.NumberOfHuffmanTables)
throw new Exception(String.Format("Huffman table 0x{0:X2} was not defined", tblno));
JpegHuffmanTable htbl = isDC ? m_cinfo.m_dc_huff_tbl_ptrs[tblno] : m_cinfo.m_ac_huff_tbl_ptrs[tblno];
if (htbl == null)
throw new Exception(String.Format("Huffman table 0x{0:X2} was not defined", tblno));
/* Allocate a workspace if we haven't already done so. */
if (dtbl == null)
dtbl = new c_derived_tbl();
/* Figure C.1: make table of Huffman code length for each symbol */
int p = 0;
char[] huffsize = new char[257];
for (int l = 1; l <= 16; l++)
{
int i = htbl.Bits[l];
if (i < 0 || p + i > 256) /* protect against table overrun */
throw new Exception("Bogus Huffman table definition");
while ((i--) != 0)
huffsize[p++] = (char)l;
}
huffsize[p] = (char)0;
int lastp = p;
/* Figure C.2: generate the codes themselves */
/* We also validate that the counts represent a legal Huffman code tree. */
int code = 0;
int si = huffsize[0];
p = 0;
int[] huffcode = new int[257];
while (huffsize[p] != 0)
{
while (((int)huffsize[p]) == si)
{
huffcode[p++] = code;
code++;
}
/* code is now 1 more than the last code used for codelength si; but
* it must still fit in si bits, since no code is allowed to be all ones.
*/
if (code >= (1 << si))
throw new Exception("Bogus Huffman table definition");
code <<= 1;
si++;
}
/* Figure C.3: generate encoding tables */
/* These are code and size indexed by symbol value */
/* Set all codeless symbols to have code length 0;
* this lets us detect duplicate VAL entries here, and later
* allows emit_bits to detect any attempt to emit such symbols.
*/
Array.Clear(dtbl.ehufsi, 0, dtbl.ehufsi.Length);
/* This is also a convenient place to check for out-of-range
* and duplicated VAL entries. We allow 0..255 for AC symbols
* but only 0..15 for DC. (We could constrain them further
* based on data depth and mode, but this seems enough.)
*/
int maxsymbol = isDC ? 15 : 255;
for (p = 0; p < lastp; p++)
{
int i = htbl.Huffval[p];
if (i < 0 || i > maxsymbol || dtbl.ehufsi[i] != 0)
throw new Exception("Bogus Huffman table definition");
dtbl.ehufco[i] = huffcode[p];
dtbl.ehufsi[i] = huffsize[p];
}
}
/// <summary>
/// Generate the best Huffman code table for the given counts, fill htbl.
///
/// The JPEG standard requires that no symbol be assigned a codeword of all
/// one bits (so that padding bits added at the end of a compressed segment
/// can't look like a valid code). Because of the canonical ordering of
/// codewords, this just means that there must be an unused slot in the
/// longest codeword length category. Section K.2 of the JPEG spec suggests
/// reserving such a slot by pretending that symbol 256 is a valid symbol
/// with count 1. In theory that's not optimal; giving it count zero but
/// including it in the symbol set anyway should give a better Huffman code.
/// But the theoretically better code actually seems to come out worse in
/// practice, because it produces more all-ones bytes (which incur stuffed
/// zero bytes in the final file). In any case the difference is tiny.
///
/// The JPEG standard requires Huffman codes to be no more than 16 bits long.
/// If some symbols have a very small but nonzero probability, the Huffman tree
/// must be adjusted to meet the code length restriction. We currently use
/// the adjustment method suggested in JPEG section K.2. This method is *not*
/// optimal; it may not choose the best possible limited-length code. But
/// typically only very-low-frequency symbols will be given less-than-optimal
/// lengths, so the code is almost optimal. Experimental comparisons against
/// an optimal limited-length-code algorithm indicate that the difference is
/// microscopic --- usually less than a hundredth of a percent of total size.
/// So the extra complexity of an optimal algorithm doesn't seem worthwhile.
/// </summary>
protected void jpeg_gen_optimal_table(JpegHuffmanTable htbl, long[] freq)
{
byte[] bits = new byte[MAX_CLEN + 1]; /* bits[k] = # of symbols with code length k */
int[] codesize = new int[257]; /* codesize[k] = code length of symbol k */
int[] others = new int[257]; /* next symbol in current branch of tree */
int c1, c2;
int p, i, j;
long v;
/* This algorithm is explained in section K.2 of the JPEG standard */
for (i = 0; i < 257; i++)
others[i] = -1; /* init links to empty */
freq[256] = 1; /* make sure 256 has a nonzero count */
/* Including the pseudo-symbol 256 in the Huffman procedure guarantees
* that no real symbol is given code-value of all ones, because 256
* will be placed last in the largest codeword category.
*/
/* Huffman's basic algorithm to assign optimal code lengths to symbols */
for (; ; )
{
/* Find the smallest nonzero frequency, set c1 = its symbol */
/* In case of ties, take the larger symbol number */
c1 = -1;
v = 1000000000L;
for (i = 0; i <= 256; i++)
{
if (freq[i] != 0 && freq[i] <= v)
{
v = freq[i];
c1 = i;
}
}
/* Find the next smallest nonzero frequency, set c2 = its symbol */
/* In case of ties, take the larger symbol number */
c2 = -1;
v = 1000000000L;
for (i = 0; i <= 256; i++)
{
if (freq[i] != 0 && freq[i] <= v && i != c1)
{
v = freq[i];
c2 = i;
}
}
/* Done if we've merged everything into one frequency */
if (c2 < 0)
break;
/* Else merge the two counts/trees */
freq[c1] += freq[c2];
freq[c2] = 0;
/* Increment the codesize of everything in c1's tree branch */
codesize[c1]++;
while (others[c1] >= 0)
{
c1 = others[c1];
codesize[c1]++;
}
others[c1] = c2; /* chain c2 onto c1's tree branch */
/* Increment the codesize of everything in c2's tree branch */
codesize[c2]++;
while (others[c2] >= 0)
{
c2 = others[c2];
codesize[c2]++;
}
}
/* Now count the number of symbols of each code length */
for (i = 0; i <= 256; i++)
{
if (codesize[i] != 0)
{
/* The JPEG standard seems to think that this can't happen, */
/* but I'm paranoid... */
if (codesize[i] > MAX_CLEN)
throw new Exception("Huffman code size table overflow");
bits[codesize[i]]++;
}
}
/* JPEG doesn't allow symbols with code lengths over 16 bits, so if the pure
* Huffman procedure assigned any such lengths, we must adjust the coding.
* Here is what the JPEG spec says about how this next bit works:
* Since symbols are paired for the longest Huffman code, the symbols are
* removed from this length category two at a time. The prefix for the pair
* (which is one bit shorter) is allocated to one of the pair; then,
* skipping the BITS entry for that prefix length, a code word from the next
* shortest nonzero BITS entry is converted into a prefix for two code words
* one bit longer.
*/
for (i = MAX_CLEN; i > 16; i--)
{
while (bits[i] > 0)
{
j = i - 2; /* find length of new prefix to be used */
while (bits[j] == 0)
j--;
bits[i] -= 2; /* remove two symbols */
bits[i - 1]++; /* one goes in this length */
bits[j + 1] += 2; /* two new symbols in this length */
bits[j]--; /* symbol of this length is now a prefix */
}
}
/* Remove the count for the pseudo-symbol 256 from the largest codelength */
while (bits[i] == 0) /* find largest codelength still in use */
i--;
bits[i]--;
/* Return final symbol counts (only for lengths 0..16) */
Buffer.BlockCopy(bits, 0, htbl.Bits, 0, htbl.Bits.Length);
/* Return a list of the symbols sorted by code length */
/* It's not real clear to me why we don't need to consider the codelength
* changes made above, but the JPEG spec seems to think this works.
*/
p = 0;
for (i = 1; i <= MAX_CLEN; i++)
{
for (j = 0; j <= 255; j++)
{
if (codesize[j] == i)
{
htbl.Huffval[p] = (byte)j;
p++;
}
}
}
/* Set sent_table false so updated table will be written to JPEG file. */
htbl.Sent_table = false;
}
}
#endregion
#region JpegFowardDCT
/// <summary>
/// Forward DCT (also controls coefficient quantization)
///
/// A forward DCT routine is given a pointer to a work area of type DCTELEM[];
/// the DCT is to be performed in-place in that buffer. Type DCTELEM is int
/// for 8-bit samples, int for 12-bit samples. (NOTE: Floating-point DCT
/// implementations use an array of type float, instead.)
/// The DCT inputs are expected to be signed (range +-MediumSampleValue).
/// The DCT outputs are returned scaled up by a factor of 8; they therefore
/// have a range of +-8K for 8-bit data, +-128K for 12-bit data. This
/// convention improves accuracy in integer implementations and saves some
/// work in floating-point ones.
///
/// Each IDCT routine has its own ideas about the best dct_table element type.
/// </summary>
class JpegFowardDCT
{
private const int FAST_INTEGER_CONST_BITS = 8;
/* We use the following pre-calculated constants.
* If you change FAST_INTEGER_CONST_BITS you may want to add appropriate values.
*
* Convert a positive real constant to an integer scaled by CONST_SCALE.
* static int FAST_INTEGER_FIX(double x)
*{
* return ((int) ((x) * (((int) 1) << FAST_INTEGER_CONST_BITS) + 0.5));
*}
*/
private const int FAST_INTEGER_FIX_0_382683433 = 98; /* FIX(0.382683433) */
private const int FAST_INTEGER_FIX_0_541196100 = 139; /* FIX(0.541196100) */
private const int FAST_INTEGER_FIX_0_707106781 = 181; /* FIX(0.707106781) */
private const int FAST_INTEGER_FIX_1_306562965 = 334; /* FIX(1.306562965) */
private const int SLOW_INTEGER_CONST_BITS = 13;
private const int SLOW_INTEGER_PASS1_BITS = 2;
/* We use the following pre-calculated constants.
* If you change SLOW_INTEGER_CONST_BITS you may want to add appropriate values.
*
* Convert a positive real constant to an integer scaled by CONST_SCALE.
*
* static int SLOW_INTEGER_FIX(double x)
* {
* return ((int) ((x) * (((int) 1) << SLOW_INTEGER_CONST_BITS) + 0.5));
* }
*/
private const int SLOW_INTEGER_FIX_0_298631336 = 2446; /* FIX(0.298631336) */
private const int SLOW_INTEGER_FIX_0_390180644 = 3196; /* FIX(0.390180644) */
private const int SLOW_INTEGER_FIX_0_541196100 = 4433; /* FIX(0.541196100) */
private const int SLOW_INTEGER_FIX_0_765366865 = 6270; /* FIX(0.765366865) */
private const int SLOW_INTEGER_FIX_0_899976223 = 7373; /* FIX(0.899976223) */
private const int SLOW_INTEGER_FIX_1_175875602 = 9633; /* FIX(1.175875602) */
private const int SLOW_INTEGER_FIX_1_501321110 = 12299; /* FIX(1.501321110) */
private const int SLOW_INTEGER_FIX_1_847759065 = 15137; /* FIX(1.847759065) */
private const int SLOW_INTEGER_FIX_1_961570560 = 16069; /* FIX(1.961570560) */
private const int SLOW_INTEGER_FIX_2_053119869 = 16819; /* FIX(2.053119869) */
private const int SLOW_INTEGER_FIX_2_562915447 = 20995; /* FIX(2.562915447) */
private const int SLOW_INTEGER_FIX_3_072711026 = 25172; /* FIX(3.072711026) */
/* For AA&N IDCT method, divisors are equal to quantization
* coefficients scaled by scalefactor[row]*scalefactor[col], where
* scalefactor[0] = 1
* scalefactor[k] = cos(k*PI/16) * sqrt(2) for k=1..7
* We apply a further scale factor of 8.
*/
private const int CONST_BITS = 14;
/* precomputed values scaled up by 14 bits */
private static short[] aanscales = {
16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520, 22725, 31521, 29692, 26722, 22725, 17855,
12299, 6270, 21407, 29692, 27969, 25172, 21407, 16819, 11585,
5906, 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315,
16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520, 12873,
17855, 16819, 15137, 12873, 10114, 6967, 3552, 8867, 12299,
11585, 10426, 8867, 6967, 4799, 2446, 4520, 6270, 5906, 5315,
4520, 3552, 2446, 1247 };
/* For float AA&N IDCT method, divisors are equal to quantization
* coefficients scaled by scalefactor[row]*scalefactor[col], where
* scalefactor[0] = 1
* scalefactor[k] = cos(k*PI/16) * sqrt(2) for k=1..7
* We apply a further scale factor of 8.
* What's actually stored is 1/divisor so that the inner loop can
* use a multiplication rather than a division.
*/
private static double[] aanscalefactor = {
1.0, 1.387039845, 1.306562965, 1.175875602, 1.0,
0.785694958, 0.541196100, 0.275899379 };
private JpegCompressor m_cinfo;
private bool m_useSlowMethod;
private bool m_useFloatMethod;
/* The actual post-DCT divisors --- not identical to the quant table
* entries, because of scaling (especially for an unnormalized DCT).
* Each table is given in normal array order.
*/
private int[][] m_divisors = new int[JpegConstants.NumberOfQuantTables][];
/* Same as above for the floating-point case. */
private float[][] m_float_divisors = new float[JpegConstants.NumberOfQuantTables][];
public JpegFowardDCT(JpegCompressor cinfo)
{
m_cinfo = cinfo;
switch (cinfo.m_dct_method)
{
case DCTMethod.IntSlow:
m_useFloatMethod = false;
m_useSlowMethod = true;
break;
case DCTMethod.IntFast:
m_useFloatMethod = false;
m_useSlowMethod = false;
break;
case DCTMethod.Float:
m_useFloatMethod = true;
break;
default:
throw new Exception("Unknown dct method!");
}
/* Mark divisor tables unallocated */
for (int i = 0; i < JpegConstants.NumberOfQuantTables; i++)
{
m_divisors[i] = null;
m_float_divisors[i] = null;
}
}
/// <summary>
/// Initialize for a processing pass.
/// Verify that all referenced Q-tables are present, and set up
/// the divisor table for each one.
/// In the current implementation, DCT of all components is done during
/// the first pass, even if only some components will be output in the
/// first scan. Hence all components should be examined here.
/// </summary>
public virtual void start_pass()
{
for (int ci = 0; ci < m_cinfo.m_num_components; ci++)
{
int qtblno = m_cinfo.Component_info[ci].Quant_tbl_no;
/* Make sure specified quantization table is present */
if (qtblno < 0 || qtblno >= JpegConstants.NumberOfQuantTables || m_cinfo.m_quant_tbl_ptrs[qtblno] == null)
throw new Exception(String.Format("Quantization table 0x{0:X2} was not defined", qtblno));
JpegQuantizationTable qtbl = m_cinfo.m_quant_tbl_ptrs[qtblno];
/* Compute divisors for this quant table */
/* We may do this more than once for same table, but it's not a big deal */
int i = 0;
switch (m_cinfo.m_dct_method)
{
case DCTMethod.IntSlow:
/* For LL&M IDCT method, divisors are equal to raw quantization
* coefficients multiplied by 8 (to counteract scaling).
*/
if (m_divisors[qtblno] == null)
m_divisors[qtblno] = new int[JpegConstants.DCTSize2];
for (i = 0; i < JpegConstants.DCTSize2; i++)
m_divisors[qtblno][i] = ((int)qtbl.quantval[i]) << 3;
break;
case DCTMethod.IntFast:
if (m_divisors[qtblno] == null)
m_divisors[qtblno] = new int[JpegConstants.DCTSize2];
for (i = 0; i < JpegConstants.DCTSize2; i++)
m_divisors[qtblno][i] = JpegUtils.DESCALE((int)qtbl.quantval[i] * (int)aanscales[i], CONST_BITS - 3);
break;
case DCTMethod.Float:
if (m_float_divisors[qtblno] == null)
m_float_divisors[qtblno] = new float[JpegConstants.DCTSize2];
float[] fdtbl = m_float_divisors[qtblno];
i = 0;
for (int row = 0; row < JpegConstants.DCTSize; row++)
{
for (int col = 0; col < JpegConstants.DCTSize; col++)
{
fdtbl[i] = (float)(1.0 / (((double)qtbl.quantval[i] * aanscalefactor[row] * aanscalefactor[col] * 8.0)));
i++;
}
}
break;
default:
throw new Exception("Unknown dct method!");
}
}
}
/// <summary>
/// Perform forward DCT on one or more blocks of a component.
///
/// The input samples are taken from the sample_data[] array starting at
/// position start_row/start_col, and moving to the right for any additional
/// blocks. The quantized coefficients are returned in coef_blocks[].
/// </summary>
public virtual void forward_DCT(int quant_tbl_no, byte[][] sample_data, JpegBlock[] coef_blocks, int start_row, int start_col, int num_blocks)
{
if (m_useFloatMethod)
forwardDCTFloatImpl(quant_tbl_no, sample_data, coef_blocks, start_row, start_col, num_blocks);
else
forwardDCTImpl(quant_tbl_no, sample_data, coef_blocks, start_row, start_col, num_blocks);
}
// This version is used for integer DCT implementations.
private void forwardDCTImpl(int quant_tbl_no, byte[][] sample_data, JpegBlock[] coef_blocks, int start_row, int start_col, int num_blocks)
{
/* This routine is heavily used, so it's worth coding it tightly. */
int[] workspace = new int[JpegConstants.DCTSize2]; /* work area for FDCT subroutine */
for (int bi = 0; bi < num_blocks; bi++, start_col += JpegConstants.DCTSize)
{
/* Load data into workspace, applying unsigned->signed conversion */
int workspaceIndex = 0;
for (int elemr = 0; elemr < JpegConstants.DCTSize; elemr++)
{
for (int column = 0; column < JpegConstants.DCTSize; column++)
{
workspace[workspaceIndex] = (int)sample_data[start_row + elemr][start_col + column] - JpegConstants.MediumSampleValue;
workspaceIndex++;
}
}
/* Perform the DCT */
if (m_useSlowMethod)
jpeg_fdct_islow(workspace);
else
jpeg_fdct_ifast(workspace);
/* Quantize/descale the coefficients, and store into coef_blocks[] */
for (int i = 0; i < JpegConstants.DCTSize2; i++)
{
int qval = m_divisors[quant_tbl_no][i];
int temp = workspace[i];
if (temp < 0)
{
temp = -temp;
temp += qval >> 1; /* for rounding */
if (temp >= qval)
temp /= qval;
else
temp = 0;
temp = -temp;
}
else
{
temp += qval >> 1; /* for rounding */
if (temp >= qval)
temp /= qval;
else
temp = 0;
}
coef_blocks[bi][i] = (short)temp;
}
}
}
// This version is used for floating-point DCT implementations.
private void forwardDCTFloatImpl(int quant_tbl_no, byte[][] sample_data, JpegBlock[] coef_blocks, int start_row, int start_col, int num_blocks)
{
/* This routine is heavily used, so it's worth coding it tightly. */
float[] workspace = new float[JpegConstants.DCTSize2]; /* work area for FDCT subroutine */
for (int bi = 0; bi < num_blocks; bi++, start_col += JpegConstants.DCTSize)
{
/* Load data into workspace, applying unsigned->signed conversion */
int workspaceIndex = 0;
for (int elemr = 0; elemr < JpegConstants.DCTSize; elemr++)
{
for (int column = 0; column < JpegConstants.DCTSize; column++)
{
workspace[workspaceIndex] = (float)((int)sample_data[start_row + elemr][start_col + column] - JpegConstants.MediumSampleValue);
workspaceIndex++;
}
}
/* Perform the DCT */
jpeg_fdct_float(workspace);
/* Quantize/descale the coefficients, and store into coef_blocks[] */
for (int i = 0; i < JpegConstants.DCTSize2; i++)
{
/* Apply the quantization and scaling factor */
float temp = workspace[i] * m_float_divisors[quant_tbl_no][i];
/* Round to nearest integer.
* Since C does not specify the direction of rounding for negative
* quotients, we have to force the dividend positive for portability.
* The maximum coefficient size is +-16K (for 12-bit data), so this
* code should work for either 16-bit or 32-bit ints.
*/
coef_blocks[bi][i] = (short)((int)(temp + (float)16384.5) - 16384);
}
}
}
/// <summary>
/// Perform the forward DCT on one block of samples.
/// NOTE: this code only copes with 8x8 DCTs.
///
/// A floating-point implementation of the
/// forward DCT (Discrete Cosine Transform).
///
/// This implementation should be more accurate than either of the integer
/// DCT implementations. However, it may not give the same results on all
/// machines because of differences in roundoff behavior. Speed will depend
/// on the hardware's floating point capacity.
///
/// A 2-D DCT can be done by 1-D DCT on each row followed by 1-D DCT
/// on each column. Direct algorithms are also available, but they are
/// much more complex and seem not to be any faster when reduced to code.
///
/// This implementation is based on Arai, Agui, and Nakajima's algorithm for
/// scaled DCT. Their original paper (Trans. IEICE E-71(11):1095) is in
/// Japanese, but the algorithm is described in the Pennebaker &amp; Mitchell
/// JPEG textbook (see REFERENCES section in file README). The following code
/// is based directly on figure 4-8 in P&amp;M.
/// While an 8-point DCT cannot be done in less than 11 multiplies, it is
/// possible to arrange the computation so that many of the multiplies are
/// simple scalings of the final outputs. These multiplies can then be
/// folded into the multiplications or divisions by the JPEG quantization
/// table entries. The AA&amp;N method leaves only 5 multiplies and 29 adds
/// to be done in the DCT itself.
/// The primary disadvantage of this method is that with a fixed-point
/// implementation, accuracy is lost due to imprecise representation of the
/// scaled quantization values. However, that problem does not arise if
/// we use floating point arithmetic.
/// </summary>
private static void jpeg_fdct_float(float[] data)
{
/* Pass 1: process rows. */
int dataIndex = 0;
for (int ctr = JpegConstants.DCTSize - 1; ctr >= 0; ctr--)
{
float tmp0 = data[dataIndex + 0] + data[dataIndex + 7];
float tmp7 = data[dataIndex + 0] - data[dataIndex + 7];
float tmp1 = data[dataIndex + 1] + data[dataIndex + 6];
float tmp6 = data[dataIndex + 1] - data[dataIndex + 6];
float tmp2 = data[dataIndex + 2] + data[dataIndex + 5];
float tmp5 = data[dataIndex + 2] - data[dataIndex + 5];
float tmp3 = data[dataIndex + 3] + data[dataIndex + 4];
float tmp4 = data[dataIndex + 3] - data[dataIndex + 4];
/* Even part */
float tmp10 = tmp0 + tmp3; /* phase 2 */
float tmp13 = tmp0 - tmp3;
float tmp11 = tmp1 + tmp2;
float tmp12 = tmp1 - tmp2;
data[dataIndex + 0] = tmp10 + tmp11; /* phase 3 */
data[dataIndex + 4] = tmp10 - tmp11;
float z1 = (tmp12 + tmp13) * ((float)0.707106781); /* c4 */
data[dataIndex + 2] = tmp13 + z1; /* phase 5 */
data[dataIndex + 6] = tmp13 - z1;
/* Odd part */
tmp10 = tmp4 + tmp5; /* phase 2 */
tmp11 = tmp5 + tmp6;
tmp12 = tmp6 + tmp7;
/* The rotator is modified from fig 4-8 to avoid extra negations. */
float z5 = (tmp10 - tmp12) * ((float)0.382683433); /* c6 */
float z2 = ((float)0.541196100) * tmp10 + z5; /* c2-c6 */
float z4 = ((float)1.306562965) * tmp12 + z5; /* c2+c6 */
float z3 = tmp11 * ((float)0.707106781); /* c4 */
float z11 = tmp7 + z3; /* phase 5 */
float z13 = tmp7 - z3;
data[dataIndex + 5] = z13 + z2; /* phase 6 */
data[dataIndex + 3] = z13 - z2;
data[dataIndex + 1] = z11 + z4;
data[dataIndex + 7] = z11 - z4;
dataIndex += JpegConstants.DCTSize; /* advance pointer to next row */
}
/* Pass 2: process columns. */
dataIndex = 0;
for (int ctr = JpegConstants.DCTSize - 1; ctr >= 0; ctr--)
{
float tmp0 = data[dataIndex + JpegConstants.DCTSize * 0] + data[dataIndex + JpegConstants.DCTSize * 7];
float tmp7 = data[dataIndex + JpegConstants.DCTSize * 0] - data[dataIndex + JpegConstants.DCTSize * 7];
float tmp1 = data[dataIndex + JpegConstants.DCTSize * 1] + data[dataIndex + JpegConstants.DCTSize * 6];
float tmp6 = data[dataIndex + JpegConstants.DCTSize * 1] - data[dataIndex + JpegConstants.DCTSize * 6];
float tmp2 = data[dataIndex + JpegConstants.DCTSize * 2] + data[dataIndex + JpegConstants.DCTSize * 5];
float tmp5 = data[dataIndex + JpegConstants.DCTSize * 2] - data[dataIndex + JpegConstants.DCTSize * 5];
float tmp3 = data[dataIndex + JpegConstants.DCTSize * 3] + data[dataIndex + JpegConstants.DCTSize * 4];
float tmp4 = data[dataIndex + JpegConstants.DCTSize * 3] - data[dataIndex + JpegConstants.DCTSize * 4];
/* Even part */
float tmp10 = tmp0 + tmp3; /* phase 2 */
float tmp13 = tmp0 - tmp3;
float tmp11 = tmp1 + tmp2;
float tmp12 = tmp1 - tmp2;
data[dataIndex + JpegConstants.DCTSize * 0] = tmp10 + tmp11; /* phase 3 */
data[dataIndex + JpegConstants.DCTSize * 4] = tmp10 - tmp11;
float z1 = (tmp12 + tmp13) * ((float)0.707106781); /* c4 */
data[dataIndex + JpegConstants.DCTSize * 2] = tmp13 + z1; /* phase 5 */
data[dataIndex + JpegConstants.DCTSize * 6] = tmp13 - z1;
/* Odd part */
tmp10 = tmp4 + tmp5; /* phase 2 */
tmp11 = tmp5 + tmp6;
tmp12 = tmp6 + tmp7;
/* The rotator is modified from fig 4-8 to avoid extra negations. */
float z5 = (tmp10 - tmp12) * ((float)0.382683433); /* c6 */
float z2 = ((float)0.541196100) * tmp10 + z5; /* c2-c6 */
float z4 = ((float)1.306562965) * tmp12 + z5; /* c2+c6 */
float z3 = tmp11 * ((float)0.707106781); /* c4 */
float z11 = tmp7 + z3; /* phase 5 */
float z13 = tmp7 - z3;
data[dataIndex + JpegConstants.DCTSize * 5] = z13 + z2; /* phase 6 */
data[dataIndex + JpegConstants.DCTSize * 3] = z13 - z2;
data[dataIndex + JpegConstants.DCTSize * 1] = z11 + z4;
data[dataIndex + JpegConstants.DCTSize * 7] = z11 - z4;
dataIndex++; /* advance pointer to next column */
}
}
/// <summary>
/// Perform the forward DCT on one block of samples.
/// NOTE: this code only copes with 8x8 DCTs.
/// This file contains a fast, not so accurate integer implementation of the
/// forward DCT (Discrete Cosine Transform).
///
/// A 2-D DCT can be done by 1-D DCT on each row followed by 1-D DCT
/// on each column. Direct algorithms are also available, but they are
/// much more complex and seem not to be any faster when reduced to code.
///
/// This implementation is based on Arai, Agui, and Nakajima's algorithm for
/// scaled DCT. Their original paper (Trans. IEICE E-71(11):1095) is in
/// Japanese, but the algorithm is described in the Pennebaker &amp; Mitchell
/// JPEG textbook (see REFERENCES section in file README). The following code
/// is based directly on figure 4-8 in P&amp;M.
/// While an 8-point DCT cannot be done in less than 11 multiplies, it is
/// possible to arrange the computation so that many of the multiplies are
/// simple scalings of the final outputs. These multiplies can then be
/// folded into the multiplications or divisions by the JPEG quantization
/// table entries. The AA&amp;N method leaves only 5 multiplies and 29 adds
/// to be done in the DCT itself.
/// The primary disadvantage of this method is that with fixed-point math,
/// accuracy is lost due to imprecise representation of the scaled
/// quantization values. The smaller the quantization table entry, the less
/// precise the scaled value, so this implementation does worse with high-
/// quality-setting files than with low-quality ones.
///
/// Scaling decisions are generally the same as in the LL&amp;M algorithm;
/// see jpeg_fdct_islow for more details. However, we choose to descale
/// (right shift) multiplication products as soon as they are formed,
/// rather than carrying additional fractional bits into subsequent additions.
/// This compromises accuracy slightly, but it lets us save a few shifts.
/// More importantly, 16-bit arithmetic is then adequate (for 8-bit samples)
/// everywhere except in the multiplications proper; this saves a good deal
/// of work on 16-bit-int machines.
///
/// Again to save a few shifts, the intermediate results between pass 1 and
/// pass 2 are not upscaled, but are represented only to integral precision.
///
/// A final compromise is to represent the multiplicative constants to only
/// 8 fractional bits, rather than 13. This saves some shifting work on some
/// machines, and may also reduce the cost of multiplication (since there
/// are fewer one-bits in the constants).
/// </summary>
private static void jpeg_fdct_ifast(int[] data)
{
/* Pass 1: process rows. */
int dataIndex = 0;
for (int ctr = JpegConstants.DCTSize - 1; ctr >= 0; ctr--)
{
int tmp0 = data[dataIndex + 0] + data[dataIndex + 7];
int tmp7 = data[dataIndex + 0] - data[dataIndex + 7];
int tmp1 = data[dataIndex + 1] + data[dataIndex + 6];
int tmp6 = data[dataIndex + 1] - data[dataIndex + 6];
int tmp2 = data[dataIndex + 2] + data[dataIndex + 5];
int tmp5 = data[dataIndex + 2] - data[dataIndex + 5];
int tmp3 = data[dataIndex + 3] + data[dataIndex + 4];
int tmp4 = data[dataIndex + 3] - data[dataIndex + 4];
/* Even part */
int tmp10 = tmp0 + tmp3; /* phase 2 */
int tmp13 = tmp0 - tmp3;
int tmp11 = tmp1 + tmp2;
int tmp12 = tmp1 - tmp2;
data[dataIndex + 0] = tmp10 + tmp11; /* phase 3 */
data[dataIndex + 4] = tmp10 - tmp11;
int z1 = FAST_INTEGER_MULTIPLY(tmp12 + tmp13, FAST_INTEGER_FIX_0_707106781); /* c4 */
data[dataIndex + 2] = tmp13 + z1; /* phase 5 */
data[dataIndex + 6] = tmp13 - z1;
/* Odd part */
tmp10 = tmp4 + tmp5; /* phase 2 */
tmp11 = tmp5 + tmp6;
tmp12 = tmp6 + tmp7;
/* The rotator is modified from fig 4-8 to avoid extra negations. */
int z5 = FAST_INTEGER_MULTIPLY(tmp10 - tmp12, FAST_INTEGER_FIX_0_382683433); /* c6 */
int z2 = FAST_INTEGER_MULTIPLY(tmp10, FAST_INTEGER_FIX_0_541196100) + z5; /* c2-c6 */
int z4 = FAST_INTEGER_MULTIPLY(tmp12, FAST_INTEGER_FIX_1_306562965) + z5; /* c2+c6 */
int z3 = FAST_INTEGER_MULTIPLY(tmp11, FAST_INTEGER_FIX_0_707106781); /* c4 */
int z11 = tmp7 + z3; /* phase 5 */
int z13 = tmp7 - z3;
data[dataIndex + 5] = z13 + z2; /* phase 6 */
data[dataIndex + 3] = z13 - z2;
data[dataIndex + 1] = z11 + z4;
data[dataIndex + 7] = z11 - z4;
dataIndex += JpegConstants.DCTSize; /* advance pointer to next row */
}
/* Pass 2: process columns. */
dataIndex = 0;
for (int ctr = JpegConstants.DCTSize - 1; ctr >= 0; ctr--)
{
int tmp0 = data[dataIndex + JpegConstants.DCTSize * 0] + data[dataIndex + JpegConstants.DCTSize * 7];
int tmp7 = data[dataIndex + JpegConstants.DCTSize * 0] - data[dataIndex + JpegConstants.DCTSize * 7];
int tmp1 = data[dataIndex + JpegConstants.DCTSize * 1] + data[dataIndex + JpegConstants.DCTSize * 6];
int tmp6 = data[dataIndex + JpegConstants.DCTSize * 1] - data[dataIndex + JpegConstants.DCTSize * 6];
int tmp2 = data[dataIndex + JpegConstants.DCTSize * 2] + data[dataIndex + JpegConstants.DCTSize * 5];
int tmp5 = data[dataIndex + JpegConstants.DCTSize * 2] - data[dataIndex + JpegConstants.DCTSize * 5];
int tmp3 = data[dataIndex + JpegConstants.DCTSize * 3] + data[dataIndex + JpegConstants.DCTSize * 4];
int tmp4 = data[dataIndex + JpegConstants.DCTSize * 3] - data[dataIndex + JpegConstants.DCTSize * 4];
/* Even part */
int tmp10 = tmp0 + tmp3; /* phase 2 */
int tmp13 = tmp0 - tmp3;
int tmp11 = tmp1 + tmp2;
int tmp12 = tmp1 - tmp2;
data[dataIndex + JpegConstants.DCTSize * 0] = tmp10 + tmp11; /* phase 3 */
data[dataIndex + JpegConstants.DCTSize * 4] = tmp10 - tmp11;
int z1 = FAST_INTEGER_MULTIPLY(tmp12 + tmp13, FAST_INTEGER_FIX_0_707106781); /* c4 */
data[dataIndex + JpegConstants.DCTSize * 2] = tmp13 + z1; /* phase 5 */
data[dataIndex + JpegConstants.DCTSize * 6] = tmp13 - z1;
/* Odd part */
tmp10 = tmp4 + tmp5; /* phase 2 */
tmp11 = tmp5 + tmp6;
tmp12 = tmp6 + tmp7;
/* The rotator is modified from fig 4-8 to avoid extra negations. */
int z5 = FAST_INTEGER_MULTIPLY(tmp10 - tmp12, FAST_INTEGER_FIX_0_382683433); /* c6 */
int z2 = FAST_INTEGER_MULTIPLY(tmp10, FAST_INTEGER_FIX_0_541196100) + z5; /* c2-c6 */
int z4 = FAST_INTEGER_MULTIPLY(tmp12, FAST_INTEGER_FIX_1_306562965) + z5; /* c2+c6 */
int z3 = FAST_INTEGER_MULTIPLY(tmp11, FAST_INTEGER_FIX_0_707106781); /* c4 */
int z11 = tmp7 + z3; /* phase 5 */
int z13 = tmp7 - z3;
data[dataIndex + JpegConstants.DCTSize * 5] = z13 + z2; /* phase 6 */
data[dataIndex + JpegConstants.DCTSize * 3] = z13 - z2;
data[dataIndex + JpegConstants.DCTSize * 1] = z11 + z4;
data[dataIndex + JpegConstants.DCTSize * 7] = z11 - z4;
dataIndex++; /* advance pointer to next column */
}
}
/// <summary>
/// Perform the forward DCT on one block of samples.
/// NOTE: this code only copes with 8x8 DCTs.
///
/// A slow-but-accurate integer implementation of the
/// forward DCT (Discrete Cosine Transform).
///
/// A 2-D DCT can be done by 1-D DCT on each row followed by 1-D DCT
/// on each column. Direct algorithms are also available, but they are
/// much more complex and seem not to be any faster when reduced to code.
///
/// This implementation is based on an algorithm described in
/// C. Loeffler, A. Ligtenberg and G. Moschytz, "Practical Fast 1-D DCT
/// Algorithms with 11 Multiplications", Proc. Int'l. Conf. on Acoustics,
/// Speech, and Signal Processing 1989 (ICASSP '89), pp. 988-991.
/// The primary algorithm described there uses 11 multiplies and 29 adds.
/// We use their alternate method with 12 multiplies and 32 adds.
/// The advantage of this method is that no data path contains more than one
/// multiplication; this allows a very simple and accurate implementation in
/// scaled fixed-point arithmetic, with a minimal number of shifts.
///
/// The poop on this scaling stuff is as follows:
///
/// Each 1-D DCT step produces outputs which are a factor of sqrt(N)
/// larger than the true DCT outputs. The final outputs are therefore
/// a factor of N larger than desired; since N=8 this can be cured by
/// a simple right shift at the end of the algorithm. The advantage of
/// this arrangement is that we save two multiplications per 1-D DCT,
/// because the y0 and y4 outputs need not be divided by sqrt(N).
/// In the IJG code, this factor of 8 is removed by the quantization
/// step, NOT here.
///
/// We have to do addition and subtraction of the integer inputs, which
/// is no problem, and multiplication by fractional constants, which is
/// a problem to do in integer arithmetic. We multiply all the constants
/// by CONST_SCALE and convert them to integer constants (thus retaining
/// SLOW_INTEGER_CONST_BITS bits of precision in the constants). After doing a
/// multiplication we have to divide the product by CONST_SCALE, with proper
/// rounding, to produce the correct output. This division can be done
/// cheaply as a right shift of SLOW_INTEGER_CONST_BITS bits. We postpone shifting
/// as long as possible so that partial sums can be added together with
/// full fractional precision.
///
/// The outputs of the first pass are scaled up by SLOW_INTEGER_PASS1_BITS bits so that
/// they are represented to better-than-integral precision. These outputs
/// require BitsInSample + SLOW_INTEGER_PASS1_BITS + 3 bits; this fits in a 16-bit word
/// with the recommended scaling. (For 12-bit sample data, the intermediate
/// array is int anyway.)
///
/// To avoid overflow of the 32-bit intermediate results in pass 2, we must
/// have BitsInSample + SLOW_INTEGER_CONST_BITS + SLOW_INTEGER_PASS1_BITS &lt;= 26. Error analysis
/// shows that the values given below are the most effective.
/// </summary>
private static void jpeg_fdct_islow(int[] data)
{
/* Pass 1: process rows. */
/* Note results are scaled up by sqrt(8) compared to a true DCT; */
/* furthermore, we scale the results by 2**SLOW_INTEGER_PASS1_BITS. */
int dataIndex = 0;
for (int ctr = JpegConstants.DCTSize - 1; ctr >= 0; ctr--)
{
int tmp0 = data[dataIndex + 0] + data[dataIndex + 7];
int tmp7 = data[dataIndex + 0] - data[dataIndex + 7];
int tmp1 = data[dataIndex + 1] + data[dataIndex + 6];
int tmp6 = data[dataIndex + 1] - data[dataIndex + 6];
int tmp2 = data[dataIndex + 2] + data[dataIndex + 5];
int tmp5 = data[dataIndex + 2] - data[dataIndex + 5];
int tmp3 = data[dataIndex + 3] + data[dataIndex + 4];
int tmp4 = data[dataIndex + 3] - data[dataIndex + 4];
/* Even part per LL&M figure 1 --- note that published figure is faulty;
* rotator "sqrt(2)*c1" should be "sqrt(2)*c6".
*/
int tmp10 = tmp0 + tmp3;
int tmp13 = tmp0 - tmp3;
int tmp11 = tmp1 + tmp2;
int tmp12 = tmp1 - tmp2;
data[dataIndex + 0] = (tmp10 + tmp11) << SLOW_INTEGER_PASS1_BITS;
data[dataIndex + 4] = (tmp10 - tmp11) << SLOW_INTEGER_PASS1_BITS;
int z1 = (tmp12 + tmp13) * SLOW_INTEGER_FIX_0_541196100;
data[dataIndex + 2] = JpegUtils.DESCALE(z1 + tmp13 * SLOW_INTEGER_FIX_0_765366865,
SLOW_INTEGER_CONST_BITS - SLOW_INTEGER_PASS1_BITS);
data[dataIndex + 6] = JpegUtils.DESCALE(z1 + tmp12 * (-SLOW_INTEGER_FIX_1_847759065),
SLOW_INTEGER_CONST_BITS - SLOW_INTEGER_PASS1_BITS);
/* Odd part per figure 8 --- note paper omits factor of sqrt(2).
* cK represents cos(K*pi/16).
* i0..i3 in the paper are tmp4..tmp7 here.
*/
z1 = tmp4 + tmp7;
int z2 = tmp5 + tmp6;
int z3 = tmp4 + tmp6;
int z4 = tmp5 + tmp7;
int z5 = (z3 + z4) * SLOW_INTEGER_FIX_1_175875602; /* sqrt(2) * c3 */
tmp4 = tmp4 * SLOW_INTEGER_FIX_0_298631336; /* sqrt(2) * (-c1+c3+c5-c7) */
tmp5 = tmp5 * SLOW_INTEGER_FIX_2_053119869; /* sqrt(2) * ( c1+c3-c5+c7) */
tmp6 = tmp6 * SLOW_INTEGER_FIX_3_072711026; /* sqrt(2) * ( c1+c3+c5-c7) */
tmp7 = tmp7 * SLOW_INTEGER_FIX_1_501321110; /* sqrt(2) * ( c1+c3-c5-c7) */
z1 = z1 * (-SLOW_INTEGER_FIX_0_899976223); /* sqrt(2) * (c7-c3) */
z2 = z2 * (-SLOW_INTEGER_FIX_2_562915447); /* sqrt(2) * (-c1-c3) */
z3 = z3 * (-SLOW_INTEGER_FIX_1_961570560); /* sqrt(2) * (-c3-c5) */
z4 = z4 * (-SLOW_INTEGER_FIX_0_390180644); /* sqrt(2) * (c5-c3) */
z3 += z5;
z4 += z5;
data[dataIndex + 7] = JpegUtils.DESCALE(tmp4 + z1 + z3, SLOW_INTEGER_CONST_BITS - SLOW_INTEGER_PASS1_BITS);
data[dataIndex + 5] = JpegUtils.DESCALE(tmp5 + z2 + z4, SLOW_INTEGER_CONST_BITS - SLOW_INTEGER_PASS1_BITS);
data[dataIndex + 3] = JpegUtils.DESCALE(tmp6 + z2 + z3, SLOW_INTEGER_CONST_BITS - SLOW_INTEGER_PASS1_BITS);
data[dataIndex + 1] = JpegUtils.DESCALE(tmp7 + z1 + z4, SLOW_INTEGER_CONST_BITS - SLOW_INTEGER_PASS1_BITS);
dataIndex += JpegConstants.DCTSize; /* advance pointer to next row */
}
/* Pass 2: process columns.
* We remove the SLOW_INTEGER_PASS1_BITS scaling, but leave the results scaled up
* by an overall factor of 8.
*/
dataIndex = 0;
for (int ctr = JpegConstants.DCTSize - 1; ctr >= 0; ctr--)
{
int tmp0 = data[dataIndex + JpegConstants.DCTSize * 0] + data[dataIndex + JpegConstants.DCTSize * 7];
int tmp7 = data[dataIndex + JpegConstants.DCTSize * 0] - data[dataIndex + JpegConstants.DCTSize * 7];
int tmp1 = data[dataIndex + JpegConstants.DCTSize * 1] + data[dataIndex + JpegConstants.DCTSize * 6];
int tmp6 = data[dataIndex + JpegConstants.DCTSize * 1] - data[dataIndex + JpegConstants.DCTSize * 6];
int tmp2 = data[dataIndex + JpegConstants.DCTSize * 2] + data[dataIndex + JpegConstants.DCTSize * 5];
int tmp5 = data[dataIndex + JpegConstants.DCTSize * 2] - data[dataIndex + JpegConstants.DCTSize * 5];
int tmp3 = data[dataIndex + JpegConstants.DCTSize * 3] + data[dataIndex + JpegConstants.DCTSize * 4];
int tmp4 = data[dataIndex + JpegConstants.DCTSize * 3] - data[dataIndex + JpegConstants.DCTSize * 4];
/* Even part per LL&M figure 1 --- note that published figure is faulty;
* rotator "sqrt(2)*c1" should be "sqrt(2)*c6".
*/
int tmp10 = tmp0 + tmp3;
int tmp13 = tmp0 - tmp3;
int tmp11 = tmp1 + tmp2;
int tmp12 = tmp1 - tmp2;
data[dataIndex + JpegConstants.DCTSize * 0] = JpegUtils.DESCALE(tmp10 + tmp11, SLOW_INTEGER_PASS1_BITS);
data[dataIndex + JpegConstants.DCTSize * 4] = JpegUtils.DESCALE(tmp10 - tmp11, SLOW_INTEGER_PASS1_BITS);
int z1 = (tmp12 + tmp13) * SLOW_INTEGER_FIX_0_541196100;
data[dataIndex + JpegConstants.DCTSize * 2] = JpegUtils.DESCALE(z1 + tmp13 * SLOW_INTEGER_FIX_0_765366865,
SLOW_INTEGER_CONST_BITS + SLOW_INTEGER_PASS1_BITS);
data[dataIndex + JpegConstants.DCTSize * 6] = JpegUtils.DESCALE(z1 + tmp12 * (-SLOW_INTEGER_FIX_1_847759065),
SLOW_INTEGER_CONST_BITS + SLOW_INTEGER_PASS1_BITS);
/* Odd part per figure 8 --- note paper omits factor of sqrt(2).
* cK represents cos(K*pi/16).
* i0..i3 in the paper are tmp4..tmp7 here.
*/
z1 = tmp4 + tmp7;
int z2 = tmp5 + tmp6;
int z3 = tmp4 + tmp6;
int z4 = tmp5 + tmp7;
int z5 = (z3 + z4) * SLOW_INTEGER_FIX_1_175875602; /* sqrt(2) * c3 */
tmp4 = tmp4 * SLOW_INTEGER_FIX_0_298631336; /* sqrt(2) * (-c1+c3+c5-c7) */
tmp5 = tmp5 * SLOW_INTEGER_FIX_2_053119869; /* sqrt(2) * ( c1+c3-c5+c7) */
tmp6 = tmp6 * SLOW_INTEGER_FIX_3_072711026; /* sqrt(2) * ( c1+c3+c5-c7) */
tmp7 = tmp7 * SLOW_INTEGER_FIX_1_501321110; /* sqrt(2) * ( c1+c3-c5-c7) */
z1 = z1 * (-SLOW_INTEGER_FIX_0_899976223); /* sqrt(2) * (c7-c3) */
z2 = z2 * (-SLOW_INTEGER_FIX_2_562915447); /* sqrt(2) * (-c1-c3) */
z3 = z3 * (-SLOW_INTEGER_FIX_1_961570560); /* sqrt(2) * (-c3-c5) */
z4 = z4 * (-SLOW_INTEGER_FIX_0_390180644); /* sqrt(2) * (c5-c3) */
z3 += z5;
z4 += z5;
data[dataIndex + JpegConstants.DCTSize * 7] = JpegUtils.DESCALE(tmp4 + z1 + z3, SLOW_INTEGER_CONST_BITS + SLOW_INTEGER_PASS1_BITS);
data[dataIndex + JpegConstants.DCTSize * 5] = JpegUtils.DESCALE(tmp5 + z2 + z4, SLOW_INTEGER_CONST_BITS + SLOW_INTEGER_PASS1_BITS);
data[dataIndex + JpegConstants.DCTSize * 3] = JpegUtils.DESCALE(tmp6 + z2 + z3, SLOW_INTEGER_CONST_BITS + SLOW_INTEGER_PASS1_BITS);
data[dataIndex + JpegConstants.DCTSize * 1] = JpegUtils.DESCALE(tmp7 + z1 + z4, SLOW_INTEGER_CONST_BITS + SLOW_INTEGER_PASS1_BITS);
dataIndex++; /* advance pointer to next column */
}
}
/// <summary>
/// Multiply a DCTELEM variable by an int constant, and immediately
/// descale to yield a DCTELEM result.
/// </summary>
private static int FAST_INTEGER_MULTIPLY(int var, int c)
{
return (JpegUtils.DESCALE((var) * (c), FAST_INTEGER_CONST_BITS));
}
}
#endregion
#region JpegHuffmanTable
/// <summary>
/// Huffman coding table.
/// </summary>
public class JpegHuffmanTable
{
/* These two fields directly represent the contents of a JPEG DHT marker */
private readonly byte[] m_bits = new byte[17]; /* bits[k] = # of symbols with codes of */
/* length k bits; bits[0] is unused */
private readonly byte[] m_huffval = new byte[256]; /* The symbols, in order of incr code length */
private bool m_sent_table; /* true when table has been output */
internal JpegHuffmanTable()
{
}
internal byte[] Bits
{
get { return m_bits; }
}
internal byte[] Huffval
{
get { return m_huffval; }
}
/// <summary>
/// Gets or sets a value indicating whether the table has been output to file.
/// </summary>
/// <value>It's initialized <c>false</c> when the table is created, and set
/// <c>true</c> when it's been output to the file. You could suppress output
/// of a table by setting this to <c>true</c>.
/// </value>
/// <remarks>This property is used only during compression. It's initialized
/// <c>false</c> when the table is created, and set <c>true</c> when it's been
/// output to the file. You could suppress output of a table by setting this to
/// <c>true</c>. (See jpeg_suppress_tables for an example.)</remarks>
/// <seealso cref="JpegCompressor.jpeg_suppress_tables"/>
public bool Sent_table
{
get { return m_sent_table; }
set { m_sent_table = value; }
}
}
#endregion
#region JpegInputController
/// <summary>
/// Input control module
/// </summary>
class JpegInputController
{
private JpegDecompressor m_cinfo;
private bool m_consumeData;
private bool m_inheaders; /* true until first SOS is reached */
private bool m_has_multiple_scans; /* True if file has multiple scans */
private bool m_eoi_reached; /* True when EOI has been consumed */
/// <summary>
/// Initialize the input controller module.
/// This is called only once, when the decompression object is created.
/// </summary>
public JpegInputController(JpegDecompressor cinfo)
{
m_cinfo = cinfo;
/* Initialize state: can't use reset_input_controller since we don't
* want to try to reset other modules yet.
*/
m_inheaders = true;
}
public ReadResult consume_input()
{
if (m_consumeData)
return m_cinfo.m_coef.consume_data();
return consume_markers();
}
/// <summary>
/// Reset state to begin a fresh datastream.
/// </summary>
public void reset_input_controller()
{
m_consumeData = false;
m_has_multiple_scans = false; /* "unknown" would be better */
m_eoi_reached = false;
m_inheaders = true;
/* Reset other modules */
m_cinfo.m_marker.reset_marker_reader();
/* Reset progression state -- would be cleaner if entropy decoder did this */
m_cinfo.m_coef_bits = null;
}
/// <summary>
/// Initialize the input modules to read a scan of compressed data.
/// The first call to this is done after initializing
/// the entire decompressor (during jpeg_start_decompress).
/// Subsequent calls come from consume_markers, below.
/// </summary>
public void start_input_pass()
{
per_scan_setup();
latch_quant_tables();
m_cinfo.m_entropy.start_pass();
m_cinfo.m_coef.start_input_pass();
m_consumeData = true;
}
/// <summary>
/// Finish up after inputting a compressed-data scan.
/// This is called by the coefficient controller after it's read all
/// the expected data of the scan.
/// </summary>
public void finish_input_pass()
{
m_consumeData = false;
}
public bool HasMultipleScans()
{
return m_has_multiple_scans;
}
public bool EOIReached()
{
return m_eoi_reached;
}
/// <summary>
/// Read JPEG markers before, between, or after compressed-data scans.
/// Change state as necessary when a new scan is reached.
/// Return value is JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI.
///
/// The consume_input method pointer points either here or to the
/// coefficient controller's consume_data routine, depending on whether
/// we are reading a compressed data segment or inter-segment markers.
/// </summary>
private ReadResult consume_markers()
{
ReadResult val;
if (m_eoi_reached) /* After hitting EOI, read no further */
return ReadResult.Reached_EOI;
val = m_cinfo.m_marker.read_markers();
switch (val)
{
case ReadResult.Reached_SOS:
/* Found SOS */
if (m_inheaders)
{
/* 1st SOS */
initial_setup();
m_inheaders = false;
/* Note: start_input_pass must be called by JpegDecompressorMaster
* before any more input can be consumed.
*/
}
else
{
/* 2nd or later SOS marker */
if (!m_has_multiple_scans)
{
/* Oops, I wasn't expecting this! */
throw new Exception("Didn't expect more than one scan");
}
m_cinfo.m_inputctl.start_input_pass();
}
break;
case ReadResult.Reached_EOI:
/* Found EOI */
m_eoi_reached = true;
if (m_inheaders)
{
/* Tables-only data-stream, apparently */
if (m_cinfo.m_marker.SawSOF())
throw new Exception("Invalid JPEG file structure: missing SOS marker");
}
else
{
/* Prevent infinite loop in coef ctlr's decompress_data routine
* if user set output_scan_number larger than number of scans.
*/
if (m_cinfo.m_output_scan_number > m_cinfo.m_input_scan_number)
m_cinfo.m_output_scan_number = m_cinfo.m_input_scan_number;
}
break;
case ReadResult.Suspended:
break;
}
return val;
}
/// <summary>
/// Routines to calculate various quantities related to the size of the image.
/// Called once, when first SOS marker is reached
/// </summary>
private void initial_setup()
{
/* Make sure image isn't bigger than I can handle */
if (m_cinfo.m_image_height > JpegConstants.JpegMaxDimention ||
m_cinfo.m_image_width > JpegConstants.JpegMaxDimention)
{
throw new Exception(String.Format("Maximum supported image dimension is {0} pixels", (int)JpegConstants.JpegMaxDimention));
}
/* For now, precision must match compiled-in value... */
if (m_cinfo.m_data_precision != JpegConstants.BitsInSample)
throw new Exception(String.Format("Unsupported JPEG data precision {0}", m_cinfo.m_data_precision));
/* Check that number of components won't exceed internal array sizes */
if (m_cinfo.m_num_components > JpegConstants.MaxComponents)
throw new Exception(String.Format("Too many color components: {0}, max {1}", m_cinfo.m_num_components, JpegConstants.MaxComponents));
/* Compute maximum sampling factors; check factor validity */
m_cinfo.m_max_h_samp_factor = 1;
m_cinfo.m_max_v_samp_factor = 1;
for (int ci = 0; ci < m_cinfo.m_num_components; ci++)
{
if (m_cinfo.Comp_info[ci].H_samp_factor <= 0 || m_cinfo.Comp_info[ci].H_samp_factor > JpegConstants.MaxSamplingFactor ||
m_cinfo.Comp_info[ci].V_samp_factor <= 0 || m_cinfo.Comp_info[ci].V_samp_factor > JpegConstants.MaxSamplingFactor)
{
throw new Exception("Bogus sampling factors");
}
m_cinfo.m_max_h_samp_factor = Math.Max(m_cinfo.m_max_h_samp_factor, m_cinfo.Comp_info[ci].H_samp_factor);
m_cinfo.m_max_v_samp_factor = Math.Max(m_cinfo.m_max_v_samp_factor, m_cinfo.Comp_info[ci].V_samp_factor);
}
/* We initialize DCT_scaled_size and min_DCT_scaled_size to DCTSize.
* In the full decompressor, this will be overridden JpegDecompressorMaster;
* but in the transcoder, JpegDecompressorMaster is not used, so we must do it here.
*/
m_cinfo.m_min_DCT_scaled_size = JpegConstants.DCTSize;
/* Compute dimensions of components */
for (int ci = 0; ci < m_cinfo.m_num_components; ci++)
{
m_cinfo.Comp_info[ci].DCT_scaled_size = JpegConstants.DCTSize;
/* Size in DCT blocks */
m_cinfo.Comp_info[ci].Width_in_blocks = JpegUtils.jdiv_round_up(
m_cinfo.m_image_width * m_cinfo.Comp_info[ci].H_samp_factor,
m_cinfo.m_max_h_samp_factor * JpegConstants.DCTSize);
m_cinfo.Comp_info[ci].height_in_blocks = JpegUtils.jdiv_round_up(
m_cinfo.m_image_height * m_cinfo.Comp_info[ci].V_samp_factor,
m_cinfo.m_max_v_samp_factor * JpegConstants.DCTSize);
/* downsampled_width and downsampled_height will also be overridden by
* JpegDecompressorMaster if we are doing full decompression. The transcoder library
* doesn't use these values, but the calling application might.
*/
/* Size in samples */
m_cinfo.Comp_info[ci].downsampled_width = JpegUtils.jdiv_round_up(
m_cinfo.m_image_width * m_cinfo.Comp_info[ci].H_samp_factor,
m_cinfo.m_max_h_samp_factor);
m_cinfo.Comp_info[ci].downsampled_height = JpegUtils.jdiv_round_up(
m_cinfo.m_image_height * m_cinfo.Comp_info[ci].V_samp_factor,
m_cinfo.m_max_v_samp_factor);
/* Mark component needed, until color conversion says otherwise */
m_cinfo.Comp_info[ci].component_needed = true;
/* Mark no quantization table yet saved for component */
m_cinfo.Comp_info[ci].quant_table = null;
}
/* Compute number of fully interleaved MCU rows. */
m_cinfo.m_total_iMCU_rows = JpegUtils.jdiv_round_up(
m_cinfo.m_image_height, m_cinfo.m_max_v_samp_factor * JpegConstants.DCTSize);
/* Decide whether file contains multiple scans */
if (m_cinfo.m_comps_in_scan < m_cinfo.m_num_components || m_cinfo.m_progressive_mode)
m_cinfo.m_inputctl.m_has_multiple_scans = true;
else
m_cinfo.m_inputctl.m_has_multiple_scans = false;
}
/// <summary>
/// Save away a copy of the Q-table referenced by each component present
/// in the current scan, unless already saved during a prior scan.
///
/// In a multiple-scan JPEG file, the encoder could assign different components
/// the same Q-table slot number, but change table definitions between scans
/// so that each component uses a different Q-table. (The IJG encoder is not
/// currently capable of doing this, but other encoders might.) Since we want
/// to be able to de-quantize all the components at the end of the file, this
/// means that we have to save away the table actually used for each component.
/// We do this by copying the table at the start of the first scan containing
/// the component.
/// The JPEG spec prohibits the encoder from changing the contents of a Q-table
/// slot between scans of a component using that slot. If the encoder does so
/// anyway, this decoder will simply use the Q-table values that were current
/// at the start of the first scan for the component.
///
/// The decompressor output side looks only at the saved quant tables,
/// not at the current Q-table slots.
/// </summary>
private void latch_quant_tables()
{
for (int ci = 0; ci < m_cinfo.m_comps_in_scan; ci++)
{
JpegComponent componentInfo = m_cinfo.Comp_info[m_cinfo.m_cur_comp_info[ci]];
/* No work if we already saved Q-table for this component */
if (componentInfo.quant_table != null)
continue;
/* Make sure specified quantization table is present */
int qtblno = componentInfo.Quant_tbl_no;
if (qtblno < 0 || qtblno >= JpegConstants.NumberOfQuantTables || m_cinfo.m_quant_tbl_ptrs[qtblno] == null)
throw new Exception(String.Format("Quantization table 0x{0:X2} was not defined", qtblno));
/* OK, save away the quantization table */
JpegQuantizationTable qtbl = new JpegQuantizationTable();
Buffer.BlockCopy(m_cinfo.m_quant_tbl_ptrs[qtblno].quantval, 0,
qtbl.quantval, 0, qtbl.quantval.Length * sizeof(short));
qtbl.Sent_table = m_cinfo.m_quant_tbl_ptrs[qtblno].Sent_table;
componentInfo.quant_table = qtbl;
m_cinfo.Comp_info[m_cinfo.m_cur_comp_info[ci]] = componentInfo;
}
}
/// <summary>
/// Do computations that are needed before processing a JPEG scan
/// cinfo.comps_in_scan and cinfo.cur_comp_info[] were set from SOS marker
/// </summary>
private void per_scan_setup()
{
if (m_cinfo.m_comps_in_scan == 1)
{
/* Non-interleaved (single-component) scan */
JpegComponent componentInfo = m_cinfo.Comp_info[m_cinfo.m_cur_comp_info[0]];
/* Overall image size in MCUs */
m_cinfo.m_MCUs_per_row = componentInfo.Width_in_blocks;
m_cinfo.m_MCU_rows_in_scan = componentInfo.height_in_blocks;
/* For non-interleaved scan, always one block per MCU */
componentInfo.MCU_width = 1;
componentInfo.MCU_height = 1;
componentInfo.MCU_blocks = 1;
componentInfo.MCU_sample_width = componentInfo.DCT_scaled_size;
componentInfo.last_col_width = 1;
/* For non-interleaved scans, it is convenient to define last_row_height
* as the number of block rows present in the last iMCU row.
*/
int tmp = componentInfo.height_in_blocks % componentInfo.V_samp_factor;
if (tmp == 0)
tmp = componentInfo.V_samp_factor;
componentInfo.last_row_height = tmp;
m_cinfo.Comp_info[m_cinfo.m_cur_comp_info[0]] = componentInfo;
/* Prepare array describing MCU composition */
m_cinfo.m_blocks_in_MCU = 1;
m_cinfo.m_MCU_membership[0] = 0;
}
else
{
/* Interleaved (multi-component) scan */
if (m_cinfo.m_comps_in_scan <= 0 || m_cinfo.m_comps_in_scan > JpegConstants.MaxComponentsInScan)
throw new Exception(String.Format("Too many color components: {0}, max {1}", m_cinfo.m_comps_in_scan, JpegConstants.MaxComponentsInScan));
/* Overall image size in MCUs */
m_cinfo.m_MCUs_per_row = JpegUtils.jdiv_round_up(
m_cinfo.m_image_width, m_cinfo.m_max_h_samp_factor * JpegConstants.DCTSize);
m_cinfo.m_MCU_rows_in_scan = JpegUtils.jdiv_round_up(
m_cinfo.m_image_height, m_cinfo.m_max_v_samp_factor * JpegConstants.DCTSize);
m_cinfo.m_blocks_in_MCU = 0;
for (int ci = 0; ci < m_cinfo.m_comps_in_scan; ci++)
{
JpegComponent componentInfo = m_cinfo.Comp_info[m_cinfo.m_cur_comp_info[ci]];
/* Sampling factors give # of blocks of component in each MCU */
componentInfo.MCU_width = componentInfo.H_samp_factor;
componentInfo.MCU_height = componentInfo.V_samp_factor;
componentInfo.MCU_blocks = componentInfo.MCU_width * componentInfo.MCU_height;
componentInfo.MCU_sample_width = componentInfo.MCU_width * componentInfo.DCT_scaled_size;
/* Figure number of non-dummy blocks in last MCU column & row */
int tmp = componentInfo.Width_in_blocks % componentInfo.MCU_width;
if (tmp == 0)
tmp = componentInfo.MCU_width;
componentInfo.last_col_width = tmp;
tmp = componentInfo.height_in_blocks % componentInfo.MCU_height;
if (tmp == 0)
tmp = componentInfo.MCU_height;
componentInfo.last_row_height = tmp;
/* Prepare array describing MCU composition */
int mcublks = componentInfo.MCU_blocks;
if (m_cinfo.m_blocks_in_MCU + mcublks > JpegConstants.DecompressorMaxBlocksInMCU)
throw new Exception("Sampling factors too large for interleaved scan");
m_cinfo.Comp_info[m_cinfo.m_cur_comp_info[ci]] = componentInfo;
while (mcublks-- > 0)
m_cinfo.m_MCU_membership[m_cinfo.m_blocks_in_MCU++] = ci;
}
}
}
}
#endregion
#region JpegInverseDCT
/// <summary>
/// An inverse DCT routine is given a pointer to the input JpegBlock and a pointer
/// to an output sample array. The routine must dequantize the input data as
/// well as perform the IDCT; for dequantization, it uses the multiplier table
/// pointed to by componentInfo.dct_table. The output data is to be placed into the
/// sample array starting at a specified column. (Any row offset needed will
/// be applied to the array pointer before it is passed to the IDCT code)
/// Note that the number of samples emitted by the IDCT routine is
/// DCT_scaled_size * DCT_scaled_size.
///
/// Each IDCT routine has its own ideas about the best dct_table element type.
///
/// The decompressor input side saves away the appropriate
/// quantization table for each component at the start of the first scan
/// involving that component. (This is necessary in order to correctly
/// decode files that reuse Q-table slots.)
/// When we are ready to make an output pass, the saved Q-table is converted
/// to a multiplier table that will actually be used by the IDCT routine.
/// The multiplier table contents are IDCT-method-dependent. To support
/// application changes in IDCT method between scans, we can remake the
/// multiplier tables if necessary.
/// In buffered-image mode, the first output pass may occur before any data
/// has been seen for some components, and thus before their Q-tables have
/// been saved away. To handle this case, multiplier tables are preset
/// to zeroes; the result of the IDCT will be a neutral gray level.
/// </summary>
class JpegInverseDCT
{
private const int IFAST_SCALE_BITS = 2; /* fractional bits in scale factors */
/*
* Each IDCT routine is responsible for range-limiting its results and
* converting them to unsigned form (0..MaxSampleValue). The raw outputs could
* be quite far out of range if the input data is corrupt, so a bulletproof
* range-limiting step is required. We use a mask-and-table-lookup method
* to do the combined operations quickly. See the comments with
* prepare_range_limit_table (in jdmaster.c) for more info.
*/
private const int RANGE_MASK = (JpegConstants.MaxSampleValue * 4 + 3); /* 2 bits wider than legal samples */
private const int SLOW_INTEGER_CONST_BITS = 13;
private const int SLOW_INTEGER_PASS1_BITS = 2;
/* We use the following pre-calculated constants.
* If you change SLOW_INTEGER_CONST_BITS you may want to add appropriate values.
*
* Convert a positive real constant to an integer scaled by CONST_SCALE.
* static int SLOW_INTEGER_FIX(double x)
* {
* return ((int) ((x) * (((int) 1) << SLOW_INTEGER_CONST_BITS) + 0.5));
* }
*/
private const int SLOW_INTEGER_FIX_0_298631336 = 2446; /* SLOW_INTEGER_FIX(0.298631336) */
private const int SLOW_INTEGER_FIX_0_390180644 = 3196; /* SLOW_INTEGER_FIX(0.390180644) */
private const int SLOW_INTEGER_FIX_0_541196100 = 4433; /* SLOW_INTEGER_FIX(0.541196100) */
private const int SLOW_INTEGER_FIX_0_765366865 = 6270; /* SLOW_INTEGER_FIX(0.765366865) */
private const int SLOW_INTEGER_FIX_0_899976223 = 7373; /* SLOW_INTEGER_FIX(0.899976223) */
private const int SLOW_INTEGER_FIX_1_175875602 = 9633; /* SLOW_INTEGER_FIX(1.175875602) */
private const int SLOW_INTEGER_FIX_1_501321110 = 12299; /* SLOW_INTEGER_FIX(1.501321110) */
private const int SLOW_INTEGER_FIX_1_847759065 = 15137; /* SLOW_INTEGER_FIX(1.847759065) */
private const int SLOW_INTEGER_FIX_1_961570560 = 16069; /* SLOW_INTEGER_FIX(1.961570560) */
private const int SLOW_INTEGER_FIX_2_053119869 = 16819; /* SLOW_INTEGER_FIX(2.053119869) */
private const int SLOW_INTEGER_FIX_2_562915447 = 20995; /* SLOW_INTEGER_FIX(2.562915447) */
private const int SLOW_INTEGER_FIX_3_072711026 = 25172; /* SLOW_INTEGER_FIX(3.072711026) */
private const int FAST_INTEGER_CONST_BITS = 8;
private const int FAST_INTEGER_PASS1_BITS = 2;
/* We use the following pre-calculated constants.
* If you change FAST_INTEGER_CONST_BITS you may want to add appropriate values.
*/
private const int FAST_INTEGER_FIX_1_082392200 = 277; /* FAST_INTEGER_FIX(1.082392200) */
private const int FAST_INTEGER_FIX_1_414213562 = 362; /* FAST_INTEGER_FIX(1.414213562) */
private const int FAST_INTEGER_FIX_1_847759065 = 473; /* FAST_INTEGER_FIX(1.847759065) */
private const int FAST_INTEGER_FIX_2_613125930 = 669; /* FAST_INTEGER_FIX(2.613125930) */
private const int REDUCED_CONST_BITS = 13;
private const int REDUCED_PASS1_BITS = 2;
/* We use the following pre-calculated constants.
* If you change REDUCED_CONST_BITS you may want to add appropriate values.
* Convert a positive real constant to an integer scaled by CONST_SCALE.
* static int REDUCED_FIX(double x)
* {
* return ((int) ((x) * (((int) 1) << REDUCED_CONST_BITS) + 0.5));
* }
*/
private const int REDUCED_FIX_0_211164243 = 1730; /* REDUCED_FIX(0.211164243) */
private const int REDUCED_FIX_0_509795579 = 4176; /* REDUCED_FIX(0.509795579) */
private const int REDUCED_FIX_0_601344887 = 4926; /* REDUCED_FIX(0.601344887) */
private const int REDUCED_FIX_0_720959822 = 5906; /* REDUCED_FIX(0.720959822) */
private const int REDUCED_FIX_0_765366865 = 6270; /* REDUCED_FIX(0.765366865) */
private const int REDUCED_FIX_0_850430095 = 6967; /* REDUCED_FIX(0.850430095) */
private const int REDUCED_FIX_0_899976223 = 7373; /* REDUCED_FIX(0.899976223) */
private const int REDUCED_FIX_1_061594337 = 8697; /* REDUCED_FIX(1.061594337) */
private const int REDUCED_FIX_1_272758580 = 10426; /* REDUCED_FIX(1.272758580) */
private const int REDUCED_FIX_1_451774981 = 11893; /* REDUCED_FIX(1.451774981) */
private const int REDUCED_FIX_1_847759065 = 15137; /* REDUCED_FIX(1.847759065) */
private const int REDUCED_FIX_2_172734803 = 17799; /* REDUCED_FIX(2.172734803) */
private const int REDUCED_FIX_2_562915447 = 20995; /* REDUCED_FIX(2.562915447) */
private const int REDUCED_FIX_3_624509785 = 29692; /* REDUCED_FIX(3.624509785) */
/* precomputed values scaled up by 14 bits */
private static short[] aanscales =
{
16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520, 22725, 31521, 29692, 26722, 22725, 17855,
12299, 6270, 21407, 29692, 27969, 25172, 21407, 16819, 11585,
5906, 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315,
16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520, 12873,
17855, 16819, 15137, 12873, 10114, 6967, 3552, 8867, 12299,
11585, 10426, 8867, 6967, 4799, 2446, 4520, 6270, 5906, 5315,
4520, 3552, 2446, 1247
};
private const int CONST_BITS = 14;
private static double[] aanscalefactor =
{
1.0, 1.387039845, 1.306562965, 1.175875602, 1.0,
0.785694958, 0.541196100, 0.275899379
};
private enum InverseMethod
{
Unknown,
idct_1x1_method,
idct_2x2_method,
idct_4x4_method,
idct_islow_method,
idct_ifast_method,
idct_float_method
}
/* It is useful to allow each component to have a separate IDCT method. */
private InverseMethod[] m_inverse_DCT_method = new InverseMethod[JpegConstants.MaxComponents];
/* Allocated multiplier tables: big enough for any supported variant */
private class multiplier_table
{
public int[] int_array = new int[JpegConstants.DCTSize2];
public float[] float_array = new float[JpegConstants.DCTSize2];
};
private multiplier_table[] m_dctTables;
private JpegDecompressor m_cinfo;
/* This array contains the IDCT method code that each multiplier table
* is currently set up for, or -1 if it's not yet set up.
* The actual multiplier tables are pointed to by dct_table in the
* per-component comp_info structures.
*/
private int[] m_cur_method = new int[JpegConstants.MaxComponents];
private ComponentBuffer m_componentBuffer;
public JpegInverseDCT(JpegDecompressor cinfo)
{
m_cinfo = cinfo;
m_dctTables = new multiplier_table[cinfo.m_num_components];
for (int ci = 0; ci < cinfo.m_num_components; ci++)
{
/* Allocate and pre-zero a multiplier table for each component */
m_dctTables[ci] = new multiplier_table();
/* Mark multiplier table not yet set up for any method */
m_cur_method[ci] = -1;
}
}
/// <summary>
/// Prepare for an output pass.
/// Here we select the proper IDCT routine for each component and build
/// a matching multiplier table.
/// </summary>
public void start_pass()
{
for (int ci = 0; ci < m_cinfo.m_num_components; ci++)
{
JpegComponent componentInfo = m_cinfo.Comp_info[ci];
InverseMethod im = InverseMethod.Unknown;
int method = 0;
/* Select the proper IDCT routine for this component's scaling */
switch (componentInfo.DCT_scaled_size)
{
case 1:
im = InverseMethod.idct_1x1_method;
method = (int)DCTMethod.IntSlow; /* jidctred uses islow-style table */
break;
case 2:
im = InverseMethod.idct_2x2_method;
method = (int)DCTMethod.IntSlow; /* jidctred uses islow-style table */
break;
case 4:
im = InverseMethod.idct_4x4_method;
method = (int)DCTMethod.IntSlow; /* jidctred uses islow-style table */
break;
case JpegConstants.DCTSize:
switch (m_cinfo.m_dct_method)
{
case DCTMethod.IntSlow:
im = InverseMethod.idct_islow_method;
method = (int)DCTMethod.IntSlow;
break;
case DCTMethod.IntFast:
im = InverseMethod.idct_ifast_method;
method = (int)DCTMethod.IntFast;
break;
case DCTMethod.Float:
im = InverseMethod.idct_float_method;
method = (int)DCTMethod.Float;
break;
default:
throw new Exception("Unknown DCT Method!");
}
break;
default:
throw new Exception(String.Format("IDCT output block size {0} not supported", componentInfo.DCT_scaled_size));
}
m_inverse_DCT_method[ci] = im;
/* Create multiplier table from quant table.
* However, we can skip this if the component is uninteresting
* or if we already built the table. Also, if no quant table
* has yet been saved for the component, we leave the
* multiplier table all-zero; we'll be reading zeroes from the
* coefficient controller's buffer anyway.
*/
if (!componentInfo.component_needed || m_cur_method[ci] == method)
continue;
if (componentInfo.quant_table == null)
{
/* happens if no data yet for component */
continue;
}
m_cur_method[ci] = method;
switch ((DCTMethod)method)
{
case DCTMethod.IntSlow:
/* For LL&M IDCT method, multipliers are equal to raw quantization
* coefficients, but are stored as ints to ensure access efficiency.
*/
int[] ismtbl = m_dctTables[ci].int_array;
for (int i = 0; i < JpegConstants.DCTSize2; i++)
ismtbl[i] = componentInfo.quant_table.quantval[i];
break;
case DCTMethod.IntFast:
/* For AA&N IDCT method, multipliers are equal to quantization
* coefficients scaled by scalefactor[row]*scalefactor[col], where
* scalefactor[0] = 1
* scalefactor[k] = cos(k*PI/16) * sqrt(2) for k=1..7
* For integer operation, the multiplier table is to be scaled by
* IFAST_SCALE_BITS.
*/
int[] ifmtbl = m_dctTables[ci].int_array;
for (int i = 0; i < JpegConstants.DCTSize2; i++)
{
ifmtbl[i] = JpegUtils.DESCALE((int)componentInfo.quant_table.quantval[i] * (int)aanscales[i], CONST_BITS - IFAST_SCALE_BITS);
}
break;
case DCTMethod.Float:
/* For float AA&N IDCT method, multipliers are equal to quantization
* coefficients scaled by scalefactor[row]*scalefactor[col], where
* scalefactor[0] = 1
* scalefactor[k] = cos(k*PI/16) * sqrt(2) for k=1..7
*/
float[] fmtbl = m_dctTables[ci].float_array;
int ii = 0;
for (int row = 0; row < JpegConstants.DCTSize; row++)
{
for (int col = 0; col < JpegConstants.DCTSize; col++)
{
fmtbl[ii] = (float)((double)componentInfo.quant_table.quantval[ii] * aanscalefactor[row] * aanscalefactor[col]);
ii++;
}
}
break;
default:
throw new Exception("Unknown DCT Method!");
}
}
}
/* Inverse DCT (also performs de-quantization) */
public void inverse(int component_index, short[] coef_block, ComponentBuffer output_buf, int output_row, int output_col)
{
m_componentBuffer = output_buf;
switch (m_inverse_DCT_method[component_index])
{
case InverseMethod.idct_1x1_method:
jpeg_idct_1x1(component_index, coef_block, output_row, output_col);
break;
case InverseMethod.idct_2x2_method:
jpeg_idct_2x2(component_index, coef_block, output_row, output_col);
break;
case InverseMethod.idct_4x4_method:
jpeg_idct_4x4(component_index, coef_block, output_row, output_col);
break;
case InverseMethod.idct_islow_method:
jpeg_idct_islow(component_index, coef_block, output_row, output_col);
break;
case InverseMethod.idct_ifast_method:
jpeg_idct_ifast(component_index, coef_block, output_row, output_col);
break;
case InverseMethod.idct_float_method:
jpeg_idct_float(component_index, coef_block, output_row, output_col);
break;
case InverseMethod.Unknown:
default:
throw new Exception("Unknown Inverse Method!");
}
}
/// <summary>
/// Perform de-quantization and inverse DCT on one block of coefficients.
/// NOTE: this code only copes with 8x8 DCTs.
/// A slow-but-accurate integer implementation of the
/// inverse DCT (Discrete Cosine Transform). In the IJG code, this routine
/// must also perform de-quantization of the input coefficients.
///
/// A 2-D IDCT can be done by 1-D IDCT on each column followed by 1-D IDCT
/// on each row (or vice versa, but it's more convenient to emit a row at
/// a time). Direct algorithms are also available, but they are much more
/// complex and seem not to be any faster when reduced to code.
///
/// This implementation is based on an algorithm described in
/// C. Loeffler, A. Ligtenberg and G. Moschytz, "Practical Fast 1-D DCT
/// Algorithms with 11 Multiplications", Proc. Int'l. Conf. on Acoustics,
/// Speech, and Signal Processing 1989 (ICASSP '89), pp. 988-991.
/// The primary algorithm described there uses 11 multiplies and 29 adds.
/// We use their alternate method with 12 multiplies and 32 adds.
/// The advantage of this method is that no data path contains more than one
/// multiplication; this allows a very simple and accurate implementation in
/// scaled fixed-point arithmetic, with a minimal number of shifts.
///
/// The poop on this scaling stuff is as follows:
///
/// Each 1-D IDCT step produces outputs which are a factor of sqrt(N)
/// larger than the true IDCT outputs. The final outputs are therefore
/// a factor of N larger than desired; since N=8 this can be cured by
/// a simple right shift at the end of the algorithm. The advantage of
/// this arrangement is that we save two multiplications per 1-D IDCT,
/// because the y0 and y4 inputs need not be divided by sqrt(N).
///
/// We have to do addition and subtraction of the integer inputs, which
/// is no problem, and multiplication by fractional constants, which is
/// a problem to do in integer arithmetic. We multiply all the constants
/// by CONST_SCALE and convert them to integer constants (thus retaining
/// SLOW_INTEGER_CONST_BITS bits of precision in the constants). After doing a
/// multiplication we have to divide the product by CONST_SCALE, with proper
/// rounding, to produce the correct output. This division can be done
/// cheaply as a right shift of SLOW_INTEGER_CONST_BITS bits. We postpone shifting
/// as long as possible so that partial sums can be added together with
/// full fractional precision.
///
/// The outputs of the first pass are scaled up by SLOW_INTEGER_PASS1_BITS bits so that
/// they are represented to better-than-integral precision. These outputs
/// require BitsInSample + SLOW_INTEGER_PASS1_BITS + 3 bits; this fits in a 16-bit word
/// with the recommended scaling. (To scale up 12-bit sample data further, an
/// intermediate int array would be needed.)
///
/// To avoid overflow of the 32-bit intermediate results in pass 2, we must
/// have BitsInSample + SLOW_INTEGER_CONST_BITS + SLOW_INTEGER_PASS1_BITS &lt;= 26. Error analysis
/// shows that the values given below are the most effective.
/// </summary>
private void jpeg_idct_islow(int component_index, short[] coef_block, int output_row, int output_col)
{
/* buffers data between passes */
int[] workspace = new int[JpegConstants.DCTSize2];
/* Pass 1: process columns from input, store into work array. */
/* Note results are scaled up by sqrt(8) compared to a true IDCT; */
/* furthermore, we scale the results by 2**SLOW_INTEGER_PASS1_BITS. */
int coefBlockIndex = 0;
int[] quantTable = m_dctTables[component_index].int_array;
int quantTableIndex = 0;
int workspaceIndex = 0;
for (int ctr = JpegConstants.DCTSize; ctr > 0; ctr--)
{
/* Due to quantization, we will usually find that many of the input
* coefficients are zero, especially the AC terms. We can exploit this
* by short-circuiting the IDCT calculation for any column in which all
* the AC terms are zero. In that case each output is equal to the
* DC coefficient (with scale factor as needed).
* With typical images and quantization tables, half or more of the
* column DCT calculations can be simplified this way.
*/
if (coef_block[coefBlockIndex + JpegConstants.DCTSize * 1] == 0 &&
coef_block[coefBlockIndex + JpegConstants.DCTSize * 2] == 0 &&
coef_block[coefBlockIndex + JpegConstants.DCTSize * 3] == 0 &&
coef_block[coefBlockIndex + JpegConstants.DCTSize * 4] == 0 &&
coef_block[coefBlockIndex + JpegConstants.DCTSize * 5] == 0 &&
coef_block[coefBlockIndex + JpegConstants.DCTSize * 6] == 0 &&
coef_block[coefBlockIndex + JpegConstants.DCTSize * 7] == 0)
{
/* AC terms all zero */
int dcval = SLOW_INTEGER_DEQUANTIZE(coef_block[coefBlockIndex + JpegConstants.DCTSize * 0],
quantTable[quantTableIndex + JpegConstants.DCTSize * 0]) << SLOW_INTEGER_PASS1_BITS;
workspace[workspaceIndex + JpegConstants.DCTSize * 0] = dcval;
workspace[workspaceIndex + JpegConstants.DCTSize * 1] = dcval;
workspace[workspaceIndex + JpegConstants.DCTSize * 2] = dcval;
workspace[workspaceIndex + JpegConstants.DCTSize * 3] = dcval;
workspace[workspaceIndex + JpegConstants.DCTSize * 4] = dcval;
workspace[workspaceIndex + JpegConstants.DCTSize * 5] = dcval;
workspace[workspaceIndex + JpegConstants.DCTSize * 6] = dcval;
workspace[workspaceIndex + JpegConstants.DCTSize * 7] = dcval;
/* advance pointers to next column */
coefBlockIndex++;
quantTableIndex++;
workspaceIndex++;
continue;
}
/* Even part: reverse the even part of the forward DCT. */
/* The rotator is sqrt(2)*c(-6). */
int z2 = SLOW_INTEGER_DEQUANTIZE(coef_block[coefBlockIndex + JpegConstants.DCTSize * 2],
quantTable[quantTableIndex + JpegConstants.DCTSize * 2]);
int z3 = SLOW_INTEGER_DEQUANTIZE(coef_block[coefBlockIndex + JpegConstants.DCTSize * 6],
quantTable[quantTableIndex + JpegConstants.DCTSize * 6]);
int z1 = (z2 + z3) * SLOW_INTEGER_FIX_0_541196100;
int tmp2 = z1 + z3 * (-SLOW_INTEGER_FIX_1_847759065);
int tmp3 = z1 + z2 * SLOW_INTEGER_FIX_0_765366865;
z2 = SLOW_INTEGER_DEQUANTIZE(coef_block[coefBlockIndex + JpegConstants.DCTSize * 0],
quantTable[quantTableIndex + JpegConstants.DCTSize * 0]);
z3 = SLOW_INTEGER_DEQUANTIZE(coef_block[coefBlockIndex + JpegConstants.DCTSize * 4],
quantTable[quantTableIndex + JpegConstants.DCTSize * 4]);
int tmp0 = (z2 + z3) << SLOW_INTEGER_CONST_BITS;
int tmp1 = (z2 - z3) << SLOW_INTEGER_CONST_BITS;
int tmp10 = tmp0 + tmp3;
int tmp13 = tmp0 - tmp3;
int tmp11 = tmp1 + tmp2;
int tmp12 = tmp1 - tmp2;
/* Odd part per figure 8; the matrix is unitary and hence its
* transpose is its inverse. i0..i3 are y7,y5,y3,y1 respectively.
*/
tmp0 = SLOW_INTEGER_DEQUANTIZE(coef_block[coefBlockIndex + JpegConstants.DCTSize * 7],
quantTable[quantTableIndex + JpegConstants.DCTSize * 7]);
tmp1 = SLOW_INTEGER_DEQUANTIZE(coef_block[coefBlockIndex + JpegConstants.DCTSize * 5],
quantTable[quantTableIndex + JpegConstants.DCTSize * 5]);
tmp2 = SLOW_INTEGER_DEQUANTIZE(coef_block[coefBlockIndex + JpegConstants.DCTSize * 3],
quantTable[quantTableIndex + JpegConstants.DCTSize * 3]);
tmp3 = SLOW_INTEGER_DEQUANTIZE(coef_block[coefBlockIndex + JpegConstants.DCTSize * 1],
quantTable[quantTableIndex + JpegConstants.DCTSize * 1]);
z1 = tmp0 + tmp3;
z2 = tmp1 + tmp2;
z3 = tmp0 + tmp2;
int z4 = tmp1 + tmp3;
int z5 = (z3 + z4) * SLOW_INTEGER_FIX_1_175875602; /* sqrt(2) * c3 */
tmp0 = tmp0 * SLOW_INTEGER_FIX_0_298631336; /* sqrt(2) * (-c1+c3+c5-c7) */
tmp1 = tmp1 * SLOW_INTEGER_FIX_2_053119869; /* sqrt(2) * ( c1+c3-c5+c7) */
tmp2 = tmp2 * SLOW_INTEGER_FIX_3_072711026; /* sqrt(2) * ( c1+c3+c5-c7) */
tmp3 = tmp3 * SLOW_INTEGER_FIX_1_501321110; /* sqrt(2) * ( c1+c3-c5-c7) */
z1 = z1 * (-SLOW_INTEGER_FIX_0_899976223); /* sqrt(2) * (c7-c3) */
z2 = z2 * (-SLOW_INTEGER_FIX_2_562915447); /* sqrt(2) * (-c1-c3) */
z3 = z3 * (-SLOW_INTEGER_FIX_1_961570560); /* sqrt(2) * (-c3-c5) */
z4 = z4 * (-SLOW_INTEGER_FIX_0_390180644); /* sqrt(2) * (c5-c3) */
z3 += z5;
z4 += z5;
tmp0 += z1 + z3;
tmp1 += z2 + z4;
tmp2 += z2 + z3;
tmp3 += z1 + z4;
/* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
workspace[workspaceIndex + JpegConstants.DCTSize * 0] = JpegUtils.DESCALE(tmp10 + tmp3, SLOW_INTEGER_CONST_BITS - SLOW_INTEGER_PASS1_BITS);
workspace[workspaceIndex + JpegConstants.DCTSize * 7] = JpegUtils.DESCALE(tmp10 - tmp3, SLOW_INTEGER_CONST_BITS - SLOW_INTEGER_PASS1_BITS);
workspace[workspaceIndex + JpegConstants.DCTSize * 1] = JpegUtils.DESCALE(tmp11 + tmp2, SLOW_INTEGER_CONST_BITS - SLOW_INTEGER_PASS1_BITS);
workspace[workspaceIndex + JpegConstants.DCTSize * 6] = JpegUtils.DESCALE(tmp11 - tmp2, SLOW_INTEGER_CONST_BITS - SLOW_INTEGER_PASS1_BITS);
workspace[workspaceIndex + JpegConstants.DCTSize * 2] = JpegUtils.DESCALE(tmp12 + tmp1, SLOW_INTEGER_CONST_BITS - SLOW_INTEGER_PASS1_BITS);
workspace[workspaceIndex + JpegConstants.DCTSize * 5] = JpegUtils.DESCALE(tmp12 - tmp1, SLOW_INTEGER_CONST_BITS - SLOW_INTEGER_PASS1_BITS);
workspace[workspaceIndex + JpegConstants.DCTSize * 3] = JpegUtils.DESCALE(tmp13 + tmp0, SLOW_INTEGER_CONST_BITS - SLOW_INTEGER_PASS1_BITS);
workspace[workspaceIndex + JpegConstants.DCTSize * 4] = JpegUtils.DESCALE(tmp13 - tmp0, SLOW_INTEGER_CONST_BITS - SLOW_INTEGER_PASS1_BITS);
/* advance pointers to next column */
coefBlockIndex++;
quantTableIndex++;
workspaceIndex++;
}
/* Pass 2: process rows from work array, store into output array. */
/* Note that we must descale the results by a factor of 8 == 2**3, */
/* and also undo the SLOW_INTEGER_PASS1_BITS scaling. */
workspaceIndex = 0;
byte[] limit = m_cinfo.m_sample_range_limit;
int limitOffset = m_cinfo.m_sampleRangeLimitOffset + JpegConstants.MediumSampleValue;
for (int ctr = 0; ctr < JpegConstants.DCTSize; ctr++)
{
/* Rows of zeroes can be exploited in the same way as we did with columns.
* However, the column calculation has created many nonzero AC terms, so
* the simplification applies less often (typically 5% to 10% of the time).
* On machines with very fast multiplication, it's possible that the
* test takes more time than it's worth. In that case this section
* may be commented out.
*/
int currentOutRow = output_row + ctr;
if (workspace[workspaceIndex + 1] == 0 &&
workspace[workspaceIndex + 2] == 0 &&
workspace[workspaceIndex + 3] == 0 &&
workspace[workspaceIndex + 4] == 0 &&
workspace[workspaceIndex + 5] == 0 &&
workspace[workspaceIndex + 6] == 0 &&
workspace[workspaceIndex + 7] == 0)
{
/* AC terms all zero */
byte dcval = limit[limitOffset + JpegUtils.DESCALE(workspace[workspaceIndex + 0], SLOW_INTEGER_PASS1_BITS + 3) & RANGE_MASK];
m_componentBuffer[currentOutRow][output_col + 0] = dcval;
m_componentBuffer[currentOutRow][output_col + 1] = dcval;
m_componentBuffer[currentOutRow][output_col + 2] = dcval;
m_componentBuffer[currentOutRow][output_col + 3] = dcval;
m_componentBuffer[currentOutRow][output_col + 4] = dcval;
m_componentBuffer[currentOutRow][output_col + 5] = dcval;
m_componentBuffer[currentOutRow][output_col + 6] = dcval;
m_componentBuffer[currentOutRow][output_col + 7] = dcval;
workspaceIndex += JpegConstants.DCTSize; /* advance pointer to next row */
continue;
}
/* Even part: reverse the even part of the forward DCT. */
/* The rotator is sqrt(2)*c(-6). */
int z2 = workspace[workspaceIndex + 2];
int z3 = workspace[workspaceIndex + 6];
int z1 = (z2 + z3) * SLOW_INTEGER_FIX_0_541196100;
int tmp2 = z1 + z3 * (-SLOW_INTEGER_FIX_1_847759065);
int tmp3 = z1 + z2 * SLOW_INTEGER_FIX_0_765366865;
int tmp0 = (workspace[workspaceIndex + 0] + workspace[workspaceIndex + 4]) << SLOW_INTEGER_CONST_BITS;
int tmp1 = (workspace[workspaceIndex + 0] - workspace[workspaceIndex + 4]) << SLOW_INTEGER_CONST_BITS;
int tmp10 = tmp0 + tmp3;
int tmp13 = tmp0 - tmp3;
int tmp11 = tmp1 + tmp2;
int tmp12 = tmp1 - tmp2;
/* Odd part per figure 8; the matrix is unitary and hence its
* transpose is its inverse. i0..i3 are y7,y5,y3,y1 respectively.
*/
tmp0 = workspace[workspaceIndex + 7];
tmp1 = workspace[workspaceIndex + 5];
tmp2 = workspace[workspaceIndex + 3];
tmp3 = workspace[workspaceIndex + 1];
z1 = tmp0 + tmp3;
z2 = tmp1 + tmp2;
z3 = tmp0 + tmp2;
int z4 = tmp1 + tmp3;
int z5 = (z3 + z4) * SLOW_INTEGER_FIX_1_175875602; /* sqrt(2) * c3 */
tmp0 = tmp0 * SLOW_INTEGER_FIX_0_298631336; /* sqrt(2) * (-c1+c3+c5-c7) */
tmp1 = tmp1 * SLOW_INTEGER_FIX_2_053119869; /* sqrt(2) * ( c1+c3-c5+c7) */
tmp2 = tmp2 * SLOW_INTEGER_FIX_3_072711026; /* sqrt(2) * ( c1+c3+c5-c7) */
tmp3 = tmp3 * SLOW_INTEGER_FIX_1_501321110; /* sqrt(2) * ( c1+c3-c5-c7) */
z1 = z1 * (-SLOW_INTEGER_FIX_0_899976223); /* sqrt(2) * (c7-c3) */
z2 = z2 * (-SLOW_INTEGER_FIX_2_562915447); /* sqrt(2) * (-c1-c3) */
z3 = z3 * (-SLOW_INTEGER_FIX_1_961570560); /* sqrt(2) * (-c3-c5) */
z4 = z4 * (-SLOW_INTEGER_FIX_0_390180644); /* sqrt(2) * (c5-c3) */
z3 += z5;
z4 += z5;
tmp0 += z1 + z3;
tmp1 += z2 + z4;
tmp2 += z2 + z3;
tmp3 += z1 + z4;
/* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
m_componentBuffer[currentOutRow][output_col + 0] = limit[limitOffset + JpegUtils.DESCALE(tmp10 + tmp3, SLOW_INTEGER_CONST_BITS + SLOW_INTEGER_PASS1_BITS + 3) & RANGE_MASK];
m_componentBuffer[currentOutRow][output_col + 7] = limit[limitOffset + JpegUtils.DESCALE(tmp10 - tmp3, SLOW_INTEGER_CONST_BITS + SLOW_INTEGER_PASS1_BITS + 3) & RANGE_MASK];
m_componentBuffer[currentOutRow][output_col + 1] = limit[limitOffset + JpegUtils.DESCALE(tmp11 + tmp2, SLOW_INTEGER_CONST_BITS + SLOW_INTEGER_PASS1_BITS + 3) & RANGE_MASK];
m_componentBuffer[currentOutRow][output_col + 6] = limit[limitOffset + JpegUtils.DESCALE(tmp11 - tmp2, SLOW_INTEGER_CONST_BITS + SLOW_INTEGER_PASS1_BITS + 3) & RANGE_MASK];
m_componentBuffer[currentOutRow][output_col + 2] = limit[limitOffset + JpegUtils.DESCALE(tmp12 + tmp1, SLOW_INTEGER_CONST_BITS + SLOW_INTEGER_PASS1_BITS + 3) & RANGE_MASK];
m_componentBuffer[currentOutRow][output_col + 5] = limit[limitOffset + JpegUtils.DESCALE(tmp12 - tmp1, SLOW_INTEGER_CONST_BITS + SLOW_INTEGER_PASS1_BITS + 3) & RANGE_MASK];
m_componentBuffer[currentOutRow][output_col + 3] = limit[limitOffset + JpegUtils.DESCALE(tmp13 + tmp0, SLOW_INTEGER_CONST_BITS + SLOW_INTEGER_PASS1_BITS + 3) & RANGE_MASK];
m_componentBuffer[currentOutRow][output_col + 4] = limit[limitOffset + JpegUtils.DESCALE(tmp13 - tmp0, SLOW_INTEGER_CONST_BITS + SLOW_INTEGER_PASS1_BITS + 3) & RANGE_MASK];
/* advance pointer to next row */
workspaceIndex += JpegConstants.DCTSize;
}
}
/// <summary>
/// Dequantize a coefficient by multiplying it by the multiplier-table
/// entry; produce an int result. In this module, both inputs and result
/// are 16 bits or less, so either int or short multiply will work.
/// </summary>
private static int SLOW_INTEGER_DEQUANTIZE(int coef, int quantval)
{
return (coef * quantval);
}
/// <summary>
/// Perform dequantization and inverse DCT on one block of coefficients.
/// NOTE: this code only copes with 8x8 DCTs.
///
/// A fast, not so accurate integer implementation of the
/// inverse DCT (Discrete Cosine Transform). In the IJG code, this routine
/// must also perform dequantization of the input coefficients.
///
/// A 2-D IDCT can be done by 1-D IDCT on each column followed by 1-D IDCT
/// on each row (or vice versa, but it's more convenient to emit a row at
/// a time). Direct algorithms are also available, but they are much more
/// complex and seem not to be any faster when reduced to code.
///
/// This implementation is based on Arai, Agui, and Nakajima's algorithm for
/// scaled DCT. Their original paper (Trans. IEICE E-71(11):1095) is in
/// Japanese, but the algorithm is described in the Pennebaker &amp; Mitchell
/// JPEG textbook (see REFERENCES section in file README). The following code
/// is based directly on figure 4-8 in P&amp;M.
/// While an 8-point DCT cannot be done in less than 11 multiplies, it is
/// possible to arrange the computation so that many of the multiplies are
/// simple scalings of the final outputs. These multiplies can then be
/// folded into the multiplications or divisions by the JPEG quantization
/// table entries. The AA&amp;N method leaves only 5 multiplies and 29 adds
/// to be done in the DCT itself.
/// The primary disadvantage of this method is that with fixed-point math,
/// accuracy is lost due to imprecise representation of the scaled
/// quantization values. The smaller the quantization table entry, the less
/// precise the scaled value, so this implementation does worse with high-
/// quality-setting files than with low-quality ones.
///
/// Scaling decisions are generally the same as in the LL&amp;M algorithm;
/// However, we choose to descale
/// (right shift) multiplication products as soon as they are formed,
/// rather than carrying additional fractional bits into subsequent additions.
/// This compromises accuracy slightly, but it lets us save a few shifts.
/// More importantly, 16-bit arithmetic is then adequate (for 8-bit samples)
/// everywhere except in the multiplications proper; this saves a good deal
/// of work on 16-bit-int machines.
///
/// The dequantized coefficients are not integers because the AA&amp;N scaling
/// factors have been incorporated. We represent them scaled up by FAST_INTEGER_PASS1_BITS,
/// so that the first and second IDCT rounds have the same input scaling.
/// For 8-bit JSAMPLEs, we choose IFAST_SCALE_BITS = FAST_INTEGER_PASS1_BITS so as to
/// avoid a descaling shift; this compromises accuracy rather drastically
/// for small quantization table entries, but it saves a lot of shifts.
/// For 12-bit JSAMPLEs, there's no hope of using 16x16 multiplies anyway,
/// so we use a much larger scaling factor to preserve accuracy.
///
/// A final compromise is to represent the multiplicative constants to only
/// 8 fractional bits, rather than 13. This saves some shifting work on some
/// machines, and may also reduce the cost of multiplication (since there
/// are fewer one-bits in the constants).
/// </summary>
private void jpeg_idct_ifast(int component_index, short[] coef_block, int output_row, int output_col)
{
/* buffers data between passes */
int[] workspace = new int[JpegConstants.DCTSize2];
/* Pass 1: process columns from input, store into work array. */
int coefBlockIndex = 0;
int workspaceIndex = 0;
int[] quantTable = m_dctTables[component_index].int_array;
int quantTableIndex = 0;
for (int ctr = JpegConstants.DCTSize; ctr > 0; ctr--)
{
/* Due to quantization, we will usually find that many of the input
* coefficients are zero, especially the AC terms. We can exploit this
* by short-circuiting the IDCT calculation for any column in which all
* the AC terms are zero. In that case each output is equal to the
* DC coefficient (with scale factor as needed).
* With typical images and quantization tables, half or more of the
* column DCT calculations can be simplified this way.
*/
if (coef_block[coefBlockIndex + JpegConstants.DCTSize * 1] == 0 &&
coef_block[coefBlockIndex + JpegConstants.DCTSize * 2] == 0 &&
coef_block[coefBlockIndex + JpegConstants.DCTSize * 3] == 0 &&
coef_block[coefBlockIndex + JpegConstants.DCTSize * 4] == 0 &&
coef_block[coefBlockIndex + JpegConstants.DCTSize * 5] == 0 &&
coef_block[coefBlockIndex + JpegConstants.DCTSize * 6] == 0 &&
coef_block[coefBlockIndex + JpegConstants.DCTSize * 7] == 0)
{
/* AC terms all zero */
int dcval = FAST_INTEGER_DEQUANTIZE(coef_block[coefBlockIndex + JpegConstants.DCTSize * 0],
quantTable[quantTableIndex + JpegConstants.DCTSize * 0]);
workspace[workspaceIndex + JpegConstants.DCTSize * 0] = dcval;
workspace[workspaceIndex + JpegConstants.DCTSize * 1] = dcval;
workspace[workspaceIndex + JpegConstants.DCTSize * 2] = dcval;
workspace[workspaceIndex + JpegConstants.DCTSize * 3] = dcval;
workspace[workspaceIndex + JpegConstants.DCTSize * 4] = dcval;
workspace[workspaceIndex + JpegConstants.DCTSize * 5] = dcval;
workspace[workspaceIndex + JpegConstants.DCTSize * 6] = dcval;
workspace[workspaceIndex + JpegConstants.DCTSize * 7] = dcval;
/* advance pointers to next column */
coefBlockIndex++;
quantTableIndex++;
workspaceIndex++;
continue;
}
/* Even part */
int tmp0 = FAST_INTEGER_DEQUANTIZE(coef_block[coefBlockIndex + JpegConstants.DCTSize * 0],
quantTable[quantTableIndex + JpegConstants.DCTSize * 0]);
int tmp1 = FAST_INTEGER_DEQUANTIZE(coef_block[coefBlockIndex + JpegConstants.DCTSize * 2],
quantTable[quantTableIndex + JpegConstants.DCTSize * 2]);
int tmp2 = FAST_INTEGER_DEQUANTIZE(coef_block[coefBlockIndex + JpegConstants.DCTSize * 4],
quantTable[quantTableIndex + JpegConstants.DCTSize * 4]);
int tmp3 = FAST_INTEGER_DEQUANTIZE(coef_block[coefBlockIndex + JpegConstants.DCTSize * 6],
quantTable[quantTableIndex + JpegConstants.DCTSize * 6]);
int tmp10 = tmp0 + tmp2; /* phase 3 */
int tmp11 = tmp0 - tmp2;
int tmp13 = tmp1 + tmp3; /* phases 5-3 */
int tmp12 = FAST_INTEGER_MULTIPLY(tmp1 - tmp3, FAST_INTEGER_FIX_1_414213562) - tmp13; /* 2*c4 */
tmp0 = tmp10 + tmp13; /* phase 2 */
tmp3 = tmp10 - tmp13;
tmp1 = tmp11 + tmp12;
tmp2 = tmp11 - tmp12;
/* Odd part */
int tmp4 = FAST_INTEGER_DEQUANTIZE(coef_block[coefBlockIndex + JpegConstants.DCTSize * 1],
quantTable[quantTableIndex + JpegConstants.DCTSize * 1]);
int tmp5 = FAST_INTEGER_DEQUANTIZE(coef_block[coefBlockIndex + JpegConstants.DCTSize * 3],
quantTable[quantTableIndex + JpegConstants.DCTSize * 3]);
int tmp6 = FAST_INTEGER_DEQUANTIZE(coef_block[coefBlockIndex + JpegConstants.DCTSize * 5],
quantTable[quantTableIndex + JpegConstants.DCTSize * 5]);
int tmp7 = FAST_INTEGER_DEQUANTIZE(coef_block[coefBlockIndex + JpegConstants.DCTSize * 7],
quantTable[quantTableIndex + JpegConstants.DCTSize * 7]);
int z13 = tmp6 + tmp5; /* phase 6 */
int z10 = tmp6 - tmp5;
int z11 = tmp4 + tmp7;
int z12 = tmp4 - tmp7;
tmp7 = z11 + z13; /* phase 5 */
tmp11 = FAST_INTEGER_MULTIPLY(z11 - z13, FAST_INTEGER_FIX_1_414213562); /* 2*c4 */
int z5 = FAST_INTEGER_MULTIPLY(z10 + z12, FAST_INTEGER_FIX_1_847759065); /* 2*c2 */
tmp10 = FAST_INTEGER_MULTIPLY(z12, FAST_INTEGER_FIX_1_082392200) - z5; /* 2*(c2-c6) */
tmp12 = FAST_INTEGER_MULTIPLY(z10, -FAST_INTEGER_FIX_2_613125930) + z5; /* -2*(c2+c6) */
tmp6 = tmp12 - tmp7; /* phase 2 */
tmp5 = tmp11 - tmp6;
tmp4 = tmp10 + tmp5;
workspace[workspaceIndex + JpegConstants.DCTSize * 0] = tmp0 + tmp7;
workspace[workspaceIndex + JpegConstants.DCTSize * 7] = tmp0 - tmp7;
workspace[workspaceIndex + JpegConstants.DCTSize * 1] = tmp1 + tmp6;
workspace[workspaceIndex + JpegConstants.DCTSize * 6] = tmp1 - tmp6;
workspace[workspaceIndex + JpegConstants.DCTSize * 2] = tmp2 + tmp5;
workspace[workspaceIndex + JpegConstants.DCTSize * 5] = tmp2 - tmp5;
workspace[workspaceIndex + JpegConstants.DCTSize * 4] = tmp3 + tmp4;
workspace[workspaceIndex + JpegConstants.DCTSize * 3] = tmp3 - tmp4;
/* advance pointers to next column */
coefBlockIndex++;
quantTableIndex++;
workspaceIndex++;
}
/* Pass 2: process rows from work array, store into output array. */
/* Note that we must descale the results by a factor of 8 == 2**3, */
/* and also undo the FAST_INTEGER_PASS1_BITS scaling. */
workspaceIndex = 0;
byte[] limit = m_cinfo.m_sample_range_limit;
int limitOffset = m_cinfo.m_sampleRangeLimitOffset + JpegConstants.MediumSampleValue;
for (int ctr = 0; ctr < JpegConstants.DCTSize; ctr++)
{
int currentOutRow = output_row + ctr;
/* Rows of zeroes can be exploited in the same way as we did with columns.
* However, the column calculation has created many nonzero AC terms, so
* the simplification applies less often (typically 5% to 10% of the time).
* On machines with very fast multiplication, it's possible that the
* test takes more time than it's worth. In that case this section
* may be commented out.
*/
if (workspace[workspaceIndex + 1] == 0 &&
workspace[workspaceIndex + 2] == 0 &&
workspace[workspaceIndex + 3] == 0 &&
workspace[workspaceIndex + 4] == 0 &&
workspace[workspaceIndex + 5] == 0 &&
workspace[workspaceIndex + 6] == 0 &&
workspace[workspaceIndex + 7] == 0)
{
/* AC terms all zero */
byte dcval = limit[limitOffset + FAST_INTEGER_IDESCALE(workspace[workspaceIndex + 0], FAST_INTEGER_PASS1_BITS + 3) & RANGE_MASK];
m_componentBuffer[currentOutRow][output_col + 0] = dcval;
m_componentBuffer[currentOutRow][output_col + 1] = dcval;
m_componentBuffer[currentOutRow][output_col + 2] = dcval;
m_componentBuffer[currentOutRow][output_col + 3] = dcval;
m_componentBuffer[currentOutRow][output_col + 4] = dcval;
m_componentBuffer[currentOutRow][output_col + 5] = dcval;
m_componentBuffer[currentOutRow][output_col + 6] = dcval;
m_componentBuffer[currentOutRow][output_col + 7] = dcval;
/* advance pointer to next row */
workspaceIndex += JpegConstants.DCTSize;
continue;
}
/* Even part */
int tmp10 = workspace[workspaceIndex + 0] + workspace[workspaceIndex + 4];
int tmp11 = workspace[workspaceIndex + 0] - workspace[workspaceIndex + 4];
int tmp13 = workspace[workspaceIndex + 2] + workspace[workspaceIndex + 6];
int tmp12 = FAST_INTEGER_MULTIPLY(workspace[workspaceIndex + 2] - workspace[workspaceIndex + 6], FAST_INTEGER_FIX_1_414213562) - tmp13;
int tmp0 = tmp10 + tmp13;
int tmp3 = tmp10 - tmp13;
int tmp1 = tmp11 + tmp12;
int tmp2 = tmp11 - tmp12;
/* Odd part */
int z13 = workspace[workspaceIndex + 5] + workspace[workspaceIndex + 3];
int z10 = workspace[workspaceIndex + 5] - workspace[workspaceIndex + 3];
int z11 = workspace[workspaceIndex + 1] + workspace[workspaceIndex + 7];
int z12 = workspace[workspaceIndex + 1] - workspace[workspaceIndex + 7];
int tmp7 = z11 + z13; /* phase 5 */
tmp11 = FAST_INTEGER_MULTIPLY(z11 - z13, FAST_INTEGER_FIX_1_414213562); /* 2*c4 */
int z5 = FAST_INTEGER_MULTIPLY(z10 + z12, FAST_INTEGER_FIX_1_847759065); /* 2*c2 */
tmp10 = FAST_INTEGER_MULTIPLY(z12, FAST_INTEGER_FIX_1_082392200) - z5; /* 2*(c2-c6) */
tmp12 = FAST_INTEGER_MULTIPLY(z10, -FAST_INTEGER_FIX_2_613125930) + z5; /* -2*(c2+c6) */
int tmp6 = tmp12 - tmp7; /* phase 2 */
int tmp5 = tmp11 - tmp6;
int tmp4 = tmp10 + tmp5;
/* Final output stage: scale down by a factor of 8 and range-limit */
m_componentBuffer[currentOutRow][output_col + 0] = limit[limitOffset + FAST_INTEGER_IDESCALE(tmp0 + tmp7, FAST_INTEGER_PASS1_BITS + 3) & RANGE_MASK];
m_componentBuffer[currentOutRow][output_col + 7] = limit[limitOffset + FAST_INTEGER_IDESCALE(tmp0 - tmp7, FAST_INTEGER_PASS1_BITS + 3) & RANGE_MASK];
m_componentBuffer[currentOutRow][output_col + 1] = limit[limitOffset + FAST_INTEGER_IDESCALE(tmp1 + tmp6, FAST_INTEGER_PASS1_BITS + 3) & RANGE_MASK];
m_componentBuffer[currentOutRow][output_col + 6] = limit[limitOffset + FAST_INTEGER_IDESCALE(tmp1 - tmp6, FAST_INTEGER_PASS1_BITS + 3) & RANGE_MASK];
m_componentBuffer[currentOutRow][output_col + 2] = limit[limitOffset + FAST_INTEGER_IDESCALE(tmp2 + tmp5, FAST_INTEGER_PASS1_BITS + 3) & RANGE_MASK];
m_componentBuffer[currentOutRow][output_col + 5] = limit[limitOffset + FAST_INTEGER_IDESCALE(tmp2 - tmp5, FAST_INTEGER_PASS1_BITS + 3) & RANGE_MASK];
m_componentBuffer[currentOutRow][output_col + 4] = limit[limitOffset + FAST_INTEGER_IDESCALE(tmp3 + tmp4, FAST_INTEGER_PASS1_BITS + 3) & RANGE_MASK];
m_componentBuffer[currentOutRow][output_col + 3] = limit[limitOffset + FAST_INTEGER_IDESCALE(tmp3 - tmp4, FAST_INTEGER_PASS1_BITS + 3) & RANGE_MASK];
/* advance pointer to next row */
workspaceIndex += JpegConstants.DCTSize;
}
}
/// <summary>
/// Multiply a DCTELEM variable by an int constant, and immediately
/// descale to yield a DCTELEM result.
/// </summary>
private static int FAST_INTEGER_MULTIPLY(int var, int c)
{
return (JpegUtils.DESCALE(var * c, FAST_INTEGER_CONST_BITS));
}
/// <summary>
/// Dequantize a coefficient by multiplying it by the multiplier-table
/// entry; produce a DCTELEM result. For 8-bit data a 16x16->16
/// multiplication will do. For 12-bit data, the multiplier table is
/// declared int, so a 32-bit multiply will be used.
/// </summary>
private static int FAST_INTEGER_DEQUANTIZE(short coef, int quantval)
{
return ((int)coef * quantval);
}
/// <summary>
/// Like DESCALE, but applies to a DCTELEM and produces an int.
/// We assume that int right shift is unsigned if int right shift is.
/// </summary>
private static int FAST_INTEGER_IRIGHT_SHIFT(int x, int shft)
{
return (x >> shft);
}
private static int FAST_INTEGER_IDESCALE(int x, int n)
{
return (FAST_INTEGER_IRIGHT_SHIFT((x) + (1 << ((n) - 1)), n));
}
/// <summary>
/// Perform dequantization and inverse DCT on one block of coefficients.
/// NOTE: this code only copes with 8x8 DCTs.
///
/// A floating-point implementation of the
/// inverse DCT (Discrete Cosine Transform). In the IJG code, this routine
/// must also perform dequantization of the input coefficients.
///
/// This implementation should be more accurate than either of the integer
/// IDCT implementations. However, it may not give the same results on all
/// machines because of differences in roundoff behavior. Speed will depend
/// on the hardware's floating point capacity.
///
/// A 2-D IDCT can be done by 1-D IDCT on each column followed by 1-D IDCT
/// on each row (or vice versa, but it's more convenient to emit a row at
/// a time). Direct algorithms are also available, but they are much more
/// complex and seem not to be any faster when reduced to code.
///
/// This implementation is based on Arai, Agui, and Nakajima's algorithm for
/// scaled DCT. Their original paper (Trans. IEICE E-71(11):1095) is in
/// Japanese, but the algorithm is described in the Pennebaker &amp; Mitchell
/// JPEG textbook (see REFERENCES section in file README). The following code
/// is based directly on figure 4-8 in P&amp;M.
/// While an 8-point DCT cannot be done in less than 11 multiplies, it is
/// possible to arrange the computation so that many of the multiplies are
/// simple scalings of the final outputs. These multiplies can then be
/// folded into the multiplications or divisions by the JPEG quantization
/// table entries. The AA&amp;N method leaves only 5 multiplies and 29 adds
/// to be done in the DCT itself.
/// The primary disadvantage of this method is that with a fixed-point
/// implementation, accuracy is lost due to imprecise representation of the
/// scaled quantization values. However, that problem does not arise if
/// we use floating point arithmetic.
/// </summary>
private void jpeg_idct_float(int component_index, short[] coef_block, int output_row, int output_col)
{
/* buffers data between passes */
float[] workspace = new float[JpegConstants.DCTSize2];
/* Pass 1: process columns from input, store into work array. */
int coefBlockIndex = 0;
int workspaceIndex = 0;
float[] quantTable = m_dctTables[component_index].float_array;
int quantTableIndex = 0;
for (int ctr = JpegConstants.DCTSize; ctr > 0; ctr--)
{
/* Due to quantization, we will usually find that many of the input
* coefficients are zero, especially the AC terms. We can exploit this
* by short-circuiting the IDCT calculation for any column in which all
* the AC terms are zero. In that case each output is equal to the
* DC coefficient (with scale factor as needed).
* With typical images and quantization tables, half or more of the
* column DCT calculations can be simplified this way.
*/
if (coef_block[coefBlockIndex + JpegConstants.DCTSize * 1] == 0 &&
coef_block[coefBlockIndex + JpegConstants.DCTSize * 2] == 0 &&
coef_block[coefBlockIndex + JpegConstants.DCTSize * 3] == 0 &&
coef_block[coefBlockIndex + JpegConstants.DCTSize * 4] == 0 &&
coef_block[coefBlockIndex + JpegConstants.DCTSize * 5] == 0 &&
coef_block[coefBlockIndex + JpegConstants.DCTSize * 6] == 0 &&
coef_block[coefBlockIndex + JpegConstants.DCTSize * 7] == 0)
{
/* AC terms all zero */
float dcval = FLOAT_DEQUANTIZE(coef_block[coefBlockIndex + JpegConstants.DCTSize * 0],
quantTable[quantTableIndex + JpegConstants.DCTSize * 0]);
workspace[workspaceIndex + JpegConstants.DCTSize * 0] = dcval;
workspace[workspaceIndex + JpegConstants.DCTSize * 1] = dcval;
workspace[workspaceIndex + JpegConstants.DCTSize * 2] = dcval;
workspace[workspaceIndex + JpegConstants.DCTSize * 3] = dcval;
workspace[workspaceIndex + JpegConstants.DCTSize * 4] = dcval;
workspace[workspaceIndex + JpegConstants.DCTSize * 5] = dcval;
workspace[workspaceIndex + JpegConstants.DCTSize * 6] = dcval;
workspace[workspaceIndex + JpegConstants.DCTSize * 7] = dcval;
coefBlockIndex++; /* advance pointers to next column */
quantTableIndex++;
workspaceIndex++;
continue;
}
/* Even part */
float tmp0 = FLOAT_DEQUANTIZE(coef_block[coefBlockIndex + JpegConstants.DCTSize * 0],
quantTable[quantTableIndex + JpegConstants.DCTSize * 0]);
float tmp1 = FLOAT_DEQUANTIZE(coef_block[coefBlockIndex + JpegConstants.DCTSize * 2],
quantTable[quantTableIndex + JpegConstants.DCTSize * 2]);
float tmp2 = FLOAT_DEQUANTIZE(coef_block[coefBlockIndex + JpegConstants.DCTSize * 4],
quantTable[quantTableIndex + JpegConstants.DCTSize * 4]);
float tmp3 = FLOAT_DEQUANTIZE(coef_block[coefBlockIndex + JpegConstants.DCTSize * 6],
quantTable[quantTableIndex + JpegConstants.DCTSize * 6]);
float tmp10 = tmp0 + tmp2; /* phase 3 */
float tmp11 = tmp0 - tmp2;
float tmp13 = tmp1 + tmp3; /* phases 5-3 */
float tmp12 = (tmp1 - tmp3) * 1.414213562f - tmp13; /* 2*c4 */
tmp0 = tmp10 + tmp13; /* phase 2 */
tmp3 = tmp10 - tmp13;
tmp1 = tmp11 + tmp12;
tmp2 = tmp11 - tmp12;
/* Odd part */
float tmp4 = FLOAT_DEQUANTIZE(coef_block[coefBlockIndex + JpegConstants.DCTSize * 1],
quantTable[quantTableIndex + JpegConstants.DCTSize * 1]);
float tmp5 = FLOAT_DEQUANTIZE(coef_block[coefBlockIndex + JpegConstants.DCTSize * 3],
quantTable[quantTableIndex + JpegConstants.DCTSize * 3]);
float tmp6 = FLOAT_DEQUANTIZE(coef_block[coefBlockIndex + JpegConstants.DCTSize * 5],
quantTable[quantTableIndex + JpegConstants.DCTSize * 5]);
float tmp7 = FLOAT_DEQUANTIZE(coef_block[coefBlockIndex + JpegConstants.DCTSize * 7],
quantTable[quantTableIndex + JpegConstants.DCTSize * 7]);
float z13 = tmp6 + tmp5; /* phase 6 */
float z10 = tmp6 - tmp5;
float z11 = tmp4 + tmp7;
float z12 = tmp4 - tmp7;
tmp7 = z11 + z13; /* phase 5 */
tmp11 = (z11 - z13) * 1.414213562f; /* 2*c4 */
float z5 = (z10 + z12) * 1.847759065f; /* 2*c2 */
tmp10 = 1.082392200f * z12 - z5; /* 2*(c2-c6) */
tmp12 = -2.613125930f * z10 + z5; /* -2*(c2+c6) */
tmp6 = tmp12 - tmp7; /* phase 2 */
tmp5 = tmp11 - tmp6;
tmp4 = tmp10 + tmp5;
workspace[workspaceIndex + JpegConstants.DCTSize * 0] = tmp0 + tmp7;
workspace[workspaceIndex + JpegConstants.DCTSize * 7] = tmp0 - tmp7;
workspace[workspaceIndex + JpegConstants.DCTSize * 1] = tmp1 + tmp6;
workspace[workspaceIndex + JpegConstants.DCTSize * 6] = tmp1 - tmp6;
workspace[workspaceIndex + JpegConstants.DCTSize * 2] = tmp2 + tmp5;
workspace[workspaceIndex + JpegConstants.DCTSize * 5] = tmp2 - tmp5;
workspace[workspaceIndex + JpegConstants.DCTSize * 4] = tmp3 + tmp4;
workspace[workspaceIndex + JpegConstants.DCTSize * 3] = tmp3 - tmp4;
coefBlockIndex++; /* advance pointers to next column */
quantTableIndex++;
workspaceIndex++;
}
/* Pass 2: process rows from work array, store into output array. */
/* Note that we must descale the results by a factor of 8 == 2**3. */
workspaceIndex = 0;
byte[] limit = m_cinfo.m_sample_range_limit;
int limitOffset = m_cinfo.m_sampleRangeLimitOffset + JpegConstants.MediumSampleValue;
for (int ctr = 0; ctr < JpegConstants.DCTSize; ctr++)
{
/* Rows of zeroes can be exploited in the same way as we did with columns.
* However, the column calculation has created many nonzero AC terms, so
* the simplification applies less often (typically 5% to 10% of the time).
* And testing floats for zero is relatively expensive, so we don't bother.
*/
/* Even part */
float tmp10 = workspace[workspaceIndex + 0] + workspace[workspaceIndex + 4];
float tmp11 = workspace[workspaceIndex + 0] - workspace[workspaceIndex + 4];
float tmp13 = workspace[workspaceIndex + 2] + workspace[workspaceIndex + 6];
float tmp12 = (workspace[workspaceIndex + 2] - workspace[workspaceIndex + 6]) * 1.414213562f - tmp13;
float tmp0 = tmp10 + tmp13;
float tmp3 = tmp10 - tmp13;
float tmp1 = tmp11 + tmp12;
float tmp2 = tmp11 - tmp12;
/* Odd part */
float z13 = workspace[workspaceIndex + 5] + workspace[workspaceIndex + 3];
float z10 = workspace[workspaceIndex + 5] - workspace[workspaceIndex + 3];
float z11 = workspace[workspaceIndex + 1] + workspace[workspaceIndex + 7];
float z12 = workspace[workspaceIndex + 1] - workspace[workspaceIndex + 7];
float tmp7 = z11 + z13;
tmp11 = (z11 - z13) * 1.414213562f;
float z5 = (z10 + z12) * 1.847759065f; /* 2*c2 */
tmp10 = 1.082392200f * z12 - z5; /* 2*(c2-c6) */
tmp12 = -2.613125930f * z10 + z5; /* -2*(c2+c6) */
float tmp6 = tmp12 - tmp7;
float tmp5 = tmp11 - tmp6;
float tmp4 = tmp10 + tmp5;
/* Final output stage: scale down by a factor of 8 and range-limit */
int currentOutRow = output_row + ctr;
m_componentBuffer[currentOutRow][output_col + 0] = limit[limitOffset + JpegUtils.DESCALE((int)(tmp0 + tmp7), 3) & RANGE_MASK];
m_componentBuffer[currentOutRow][output_col + 7] = limit[limitOffset + JpegUtils.DESCALE((int)(tmp0 - tmp7), 3) & RANGE_MASK];
m_componentBuffer[currentOutRow][output_col + 1] = limit[limitOffset + JpegUtils.DESCALE((int)(tmp1 + tmp6), 3) & RANGE_MASK];
m_componentBuffer[currentOutRow][output_col + 6] = limit[limitOffset + JpegUtils.DESCALE((int)(tmp1 - tmp6), 3) & RANGE_MASK];
m_componentBuffer[currentOutRow][output_col + 2] = limit[limitOffset + JpegUtils.DESCALE((int)(tmp2 + tmp5), 3) & RANGE_MASK];
m_componentBuffer[currentOutRow][output_col + 5] = limit[limitOffset + JpegUtils.DESCALE((int)(tmp2 - tmp5), 3) & RANGE_MASK];
m_componentBuffer[currentOutRow][output_col + 4] = limit[limitOffset + JpegUtils.DESCALE((int)(tmp3 + tmp4), 3) & RANGE_MASK];
m_componentBuffer[currentOutRow][output_col + 3] = limit[limitOffset + JpegUtils.DESCALE((int)(tmp3 - tmp4), 3) & RANGE_MASK];
workspaceIndex += JpegConstants.DCTSize; /* advance pointer to next row */
}
}
/// <summary>
/// Dequantize a coefficient by multiplying it by the multiplier-table
/// entry; produce a float result.
/// </summary>
private static float FLOAT_DEQUANTIZE(short coef, float quantval)
{
return (((float)(coef)) * (quantval));
}
/// <summary>
/// Inverse-DCT routines that produce reduced-size output:
/// either 4x4, 2x2, or 1x1 pixels from an 8x8 DCT block.
///
/// NOTE: this code only copes with 8x8 DCTs.
///
/// The implementation is based on the Loeffler, Ligtenberg and Moschytz (LL&amp;M)
/// algorithm. We simply replace each 8-to-8 1-D IDCT step
/// with an 8-to-4 step that produces the four averages of two adjacent outputs
/// (or an 8-to-2 step producing two averages of four outputs, for 2x2 output).
/// These steps were derived by computing the corresponding values at the end
/// of the normal LL&amp;M code, then simplifying as much as possible.
///
/// 1x1 is trivial: just take the DC coefficient divided by 8.
///
/// Perform dequantization and inverse DCT on one block of coefficients,
/// producing a reduced-size 4x4 output block.
/// </summary>
private void jpeg_idct_4x4(int component_index, short[] coef_block, int output_row, int output_col)
{
/* buffers data between passes */
int[] workspace = new int[JpegConstants.DCTSize * 4];
/* Pass 1: process columns from input, store into work array. */
int coefBlockIndex = 0;
int workspaceIndex = 0;
int[] quantTable = m_dctTables[component_index].int_array;
int quantTableIndex = 0;
for (int ctr = JpegConstants.DCTSize; ctr > 0; coefBlockIndex++, quantTableIndex++, workspaceIndex++, ctr--)
{
/* Don't bother to process column 4, because second pass won't use it */
if (ctr == JpegConstants.DCTSize - 4)
continue;
if (coef_block[coefBlockIndex + JpegConstants.DCTSize * 1] == 0 &&
coef_block[coefBlockIndex + JpegConstants.DCTSize * 2] == 0 &&
coef_block[coefBlockIndex + JpegConstants.DCTSize * 3] == 0 &&
coef_block[coefBlockIndex + JpegConstants.DCTSize * 5] == 0 &&
coef_block[coefBlockIndex + JpegConstants.DCTSize * 6] == 0 &&
coef_block[coefBlockIndex + JpegConstants.DCTSize * 7] == 0)
{
/* AC terms all zero; we need not examine term 4 for 4x4 output */
int dcval = REDUCED_DEQUANTIZE(coef_block[coefBlockIndex + JpegConstants.DCTSize * 0],
quantTable[quantTableIndex + JpegConstants.DCTSize * 0]) << REDUCED_PASS1_BITS;
workspace[workspaceIndex + JpegConstants.DCTSize * 0] = dcval;
workspace[workspaceIndex + JpegConstants.DCTSize * 1] = dcval;
workspace[workspaceIndex + JpegConstants.DCTSize * 2] = dcval;
workspace[workspaceIndex + JpegConstants.DCTSize * 3] = dcval;
continue;
}
/* Even part */
int tmp0 = REDUCED_DEQUANTIZE(coef_block[coefBlockIndex + JpegConstants.DCTSize * 0],
quantTable[quantTableIndex + JpegConstants.DCTSize * 0]);
tmp0 <<= (REDUCED_CONST_BITS + 1);
int z2 = REDUCED_DEQUANTIZE(coef_block[coefBlockIndex + JpegConstants.DCTSize * 2],
quantTable[quantTableIndex + JpegConstants.DCTSize * 2]);
int z3 = REDUCED_DEQUANTIZE(coef_block[coefBlockIndex + JpegConstants.DCTSize * 6],
quantTable[quantTableIndex + JpegConstants.DCTSize * 6]);
int tmp2 = z2 * REDUCED_FIX_1_847759065 + z3 * (-REDUCED_FIX_0_765366865);
int tmp10 = tmp0 + tmp2;
int tmp12 = tmp0 - tmp2;
/* Odd part */
int z1 = REDUCED_DEQUANTIZE(coef_block[coefBlockIndex + JpegConstants.DCTSize * 7],
quantTable[quantTableIndex + JpegConstants.DCTSize * 7]);
z2 = REDUCED_DEQUANTIZE(coef_block[coefBlockIndex + JpegConstants.DCTSize * 5],
quantTable[quantTableIndex + JpegConstants.DCTSize * 5]);
z3 = REDUCED_DEQUANTIZE(coef_block[coefBlockIndex + JpegConstants.DCTSize * 3],
quantTable[quantTableIndex + JpegConstants.DCTSize * 3]);
int z4 = REDUCED_DEQUANTIZE(coef_block[coefBlockIndex + JpegConstants.DCTSize * 1],
quantTable[quantTableIndex + JpegConstants.DCTSize * 1]);
tmp0 = z1 * (-REDUCED_FIX_0_211164243) /* sqrt(2) * (c3-c1) */ +
z2 * REDUCED_FIX_1_451774981 /* sqrt(2) * (c3+c7) */ +
z3 * (-REDUCED_FIX_2_172734803) /* sqrt(2) * (-c1-c5) */ +
z4 * REDUCED_FIX_1_061594337; /* sqrt(2) * (c5+c7) */
tmp2 = z1 * (-REDUCED_FIX_0_509795579) /* sqrt(2) * (c7-c5) */ +
z2 * (-REDUCED_FIX_0_601344887) /* sqrt(2) * (c5-c1) */ +
z3 * REDUCED_FIX_0_899976223 /* sqrt(2) * (c3-c7) */ +
z4 * REDUCED_FIX_2_562915447; /* sqrt(2) * (c1+c3) */
/* Final output stage */
workspace[workspaceIndex + JpegConstants.DCTSize * 0] = JpegUtils.DESCALE(tmp10 + tmp2, REDUCED_CONST_BITS - REDUCED_PASS1_BITS + 1);
workspace[workspaceIndex + JpegConstants.DCTSize * 3] = JpegUtils.DESCALE(tmp10 - tmp2, REDUCED_CONST_BITS - REDUCED_PASS1_BITS + 1);
workspace[workspaceIndex + JpegConstants.DCTSize * 1] = JpegUtils.DESCALE(tmp12 + tmp0, REDUCED_CONST_BITS - REDUCED_PASS1_BITS + 1);
workspace[workspaceIndex + JpegConstants.DCTSize * 2] = JpegUtils.DESCALE(tmp12 - tmp0, REDUCED_CONST_BITS - REDUCED_PASS1_BITS + 1);
}
/* Pass 2: process 4 rows from work array, store into output array. */
byte[] limit = m_cinfo.m_sample_range_limit;
int limitOffset = m_cinfo.m_sampleRangeLimitOffset + JpegConstants.MediumSampleValue;
workspaceIndex = 0;
for (int ctr = 0; ctr < 4; ctr++)
{
int currentOutRow = output_row + ctr;
/* It's not clear whether a zero row test is worthwhile here ... */
if (workspace[workspaceIndex + 1] == 0 &&
workspace[workspaceIndex + 2] == 0 &&
workspace[workspaceIndex + 3] == 0 &&
workspace[workspaceIndex + 5] == 0 &&
workspace[workspaceIndex + 6] == 0 &&
workspace[workspaceIndex + 7] == 0)
{
/* AC terms all zero */
byte dcval = limit[limitOffset + JpegUtils.DESCALE(workspace[workspaceIndex + 0], REDUCED_PASS1_BITS + 3) & RANGE_MASK];
m_componentBuffer[currentOutRow][output_col + 0] = dcval;
m_componentBuffer[currentOutRow][output_col + 1] = dcval;
m_componentBuffer[currentOutRow][output_col + 2] = dcval;
m_componentBuffer[currentOutRow][output_col + 3] = dcval;
workspaceIndex += JpegConstants.DCTSize; /* advance pointer to next row */
continue;
}
/* Even part */
int tmp0 = (workspace[workspaceIndex + 0]) << (REDUCED_CONST_BITS + 1);
int tmp2 = workspace[workspaceIndex + 2] * REDUCED_FIX_1_847759065 + workspace[workspaceIndex + 6] * (-REDUCED_FIX_0_765366865);
int tmp10 = tmp0 + tmp2;
int tmp12 = tmp0 - tmp2;
/* Odd part */
int z1 = workspace[workspaceIndex + 7];
int z2 = workspace[workspaceIndex + 5];
int z3 = workspace[workspaceIndex + 3];
int z4 = workspace[workspaceIndex + 1];
tmp0 = z1 * (-REDUCED_FIX_0_211164243) /* sqrt(2) * (c3-c1) */ +
z2 * REDUCED_FIX_1_451774981 /* sqrt(2) * (c3+c7) */ +
z3 * (-REDUCED_FIX_2_172734803) /* sqrt(2) * (-c1-c5) */ +
z4 * REDUCED_FIX_1_061594337; /* sqrt(2) * (c5+c7) */
tmp2 = z1 * (-REDUCED_FIX_0_509795579) /* sqrt(2) * (c7-c5) */ +
z2 * (-REDUCED_FIX_0_601344887) /* sqrt(2) * (c5-c1) */ +
z3 * REDUCED_FIX_0_899976223 /* sqrt(2) * (c3-c7) */ +
z4 * REDUCED_FIX_2_562915447; /* sqrt(2) * (c1+c3) */
/* Final output stage */
m_componentBuffer[currentOutRow][output_col + 0] = limit[limitOffset + JpegUtils.DESCALE(tmp10 + tmp2, REDUCED_CONST_BITS + REDUCED_PASS1_BITS + 3 + 1) & RANGE_MASK];
m_componentBuffer[currentOutRow][output_col + 3] = limit[limitOffset + JpegUtils.DESCALE(tmp10 - tmp2, REDUCED_CONST_BITS + REDUCED_PASS1_BITS + 3 + 1) & RANGE_MASK];
m_componentBuffer[currentOutRow][output_col + 1] = limit[limitOffset + JpegUtils.DESCALE(tmp12 + tmp0, REDUCED_CONST_BITS + REDUCED_PASS1_BITS + 3 + 1) & RANGE_MASK];
m_componentBuffer[currentOutRow][output_col + 2] = limit[limitOffset + JpegUtils.DESCALE(tmp12 - tmp0, REDUCED_CONST_BITS + REDUCED_PASS1_BITS + 3 + 1) & RANGE_MASK];
workspaceIndex += JpegConstants.DCTSize; /* advance pointer to next row */
}
}
/// <summary>
/// Perform dequantization and inverse DCT on one block of coefficients,
/// producing a reduced-size 2x2 output block.
/// </summary>
private void jpeg_idct_2x2(int component_index, short[] coef_block, int output_row, int output_col)
{
/* buffers data between passes */
int[] workspace = new int[JpegConstants.DCTSize * 2];
/* Pass 1: process columns from input, store into work array. */
int coefBlockIndex = 0;
int workspaceIndex = 0;
int[] quantTable = m_dctTables[component_index].int_array;
int quantTableIndex = 0;
for (int ctr = JpegConstants.DCTSize; ctr > 0; coefBlockIndex++, quantTableIndex++, workspaceIndex++, ctr--)
{
/* Don't bother to process columns 2,4,6 */
if (ctr == JpegConstants.DCTSize - 2 || ctr == JpegConstants.DCTSize - 4 || ctr == JpegConstants.DCTSize - 6)
continue;
if (coef_block[coefBlockIndex + JpegConstants.DCTSize * 1] == 0 &&
coef_block[coefBlockIndex + JpegConstants.DCTSize * 3] == 0 &&
coef_block[coefBlockIndex + JpegConstants.DCTSize * 5] == 0 &&
coef_block[coefBlockIndex + JpegConstants.DCTSize * 7] == 0)
{
/* AC terms all zero; we need not examine terms 2,4,6 for 2x2 output */
int dcval = REDUCED_DEQUANTIZE(coef_block[coefBlockIndex + JpegConstants.DCTSize * 0],
quantTable[quantTableIndex + JpegConstants.DCTSize * 0]) << REDUCED_PASS1_BITS;
workspace[workspaceIndex + JpegConstants.DCTSize * 0] = dcval;
workspace[workspaceIndex + JpegConstants.DCTSize * 1] = dcval;
continue;
}
/* Even part */
int z1 = REDUCED_DEQUANTIZE(coef_block[coefBlockIndex + JpegConstants.DCTSize * 0],
quantTable[quantTableIndex + JpegConstants.DCTSize * 0]);
int tmp10 = z1 << (REDUCED_CONST_BITS + 2);
/* Odd part */
z1 = REDUCED_DEQUANTIZE(coef_block[coefBlockIndex + JpegConstants.DCTSize * 7],
quantTable[quantTableIndex + JpegConstants.DCTSize * 7]);
int tmp0 = z1 * -REDUCED_FIX_0_720959822; /* sqrt(2) * (c7-c5+c3-c1) */
z1 = REDUCED_DEQUANTIZE(coef_block[coefBlockIndex + JpegConstants.DCTSize * 5],
quantTable[quantTableIndex + JpegConstants.DCTSize * 5]);
tmp0 += z1 * REDUCED_FIX_0_850430095; /* sqrt(2) * (-c1+c3+c5+c7) */
z1 = REDUCED_DEQUANTIZE(coef_block[coefBlockIndex + JpegConstants.DCTSize * 3],
quantTable[quantTableIndex + JpegConstants.DCTSize * 3]);
tmp0 += z1 * (-REDUCED_FIX_1_272758580); /* sqrt(2) * (-c1+c3-c5-c7) */
z1 = REDUCED_DEQUANTIZE(coef_block[coefBlockIndex + JpegConstants.DCTSize * 1],
quantTable[quantTableIndex + JpegConstants.DCTSize * 1]);
tmp0 += z1 * REDUCED_FIX_3_624509785; /* sqrt(2) * (c1+c3+c5+c7) */
/* Final output stage */
workspace[workspaceIndex + JpegConstants.DCTSize * 0] = JpegUtils.DESCALE(tmp10 + tmp0, REDUCED_CONST_BITS - REDUCED_PASS1_BITS + 2);
workspace[workspaceIndex + JpegConstants.DCTSize * 1] = JpegUtils.DESCALE(tmp10 - tmp0, REDUCED_CONST_BITS - REDUCED_PASS1_BITS + 2);
}
/* Pass 2: process 2 rows from work array, store into output array. */
workspaceIndex = 0;
byte[] limit = m_cinfo.m_sample_range_limit;
int limitOffset = m_cinfo.m_sampleRangeLimitOffset + JpegConstants.MediumSampleValue;
for (int ctr = 0; ctr < 2; ctr++)
{
int currentOutRow = output_row + ctr;
/* It's not clear whether a zero row test is worthwhile here ... */
if (workspace[workspaceIndex + 1] == 0 &&
workspace[workspaceIndex + 3] == 0 &&
workspace[workspaceIndex + 5] == 0 &&
workspace[workspaceIndex + 7] == 0)
{
/* AC terms all zero */
byte dcval = limit[limitOffset + JpegUtils.DESCALE(workspace[workspaceIndex + 0], REDUCED_PASS1_BITS + 3) & RANGE_MASK];
m_componentBuffer[currentOutRow][output_col + 0] = dcval;
m_componentBuffer[currentOutRow][output_col + 1] = dcval;
workspaceIndex += JpegConstants.DCTSize; /* advance pointer to next row */
continue;
}
/* Even part */
int tmp10 = (workspace[workspaceIndex + 0]) << (REDUCED_CONST_BITS + 2);
/* Odd part */
int tmp0 = workspace[workspaceIndex + 7] * (-REDUCED_FIX_0_720959822) /* sqrt(2) * (c7-c5+c3-c1) */ +
workspace[workspaceIndex + 5] * REDUCED_FIX_0_850430095 /* sqrt(2) * (-c1+c3+c5+c7) */ +
workspace[workspaceIndex + 3] * (-REDUCED_FIX_1_272758580) /* sqrt(2) * (-c1+c3-c5-c7) */ +
workspace[workspaceIndex + 1] * REDUCED_FIX_3_624509785; /* sqrt(2) * (c1+c3+c5+c7) */
/* Final output stage */
m_componentBuffer[currentOutRow][output_col + 0] = limit[limitOffset + JpegUtils.DESCALE(tmp10 + tmp0, REDUCED_CONST_BITS + REDUCED_PASS1_BITS + 3 + 2) & RANGE_MASK];
m_componentBuffer[currentOutRow][output_col + 1] = limit[limitOffset + JpegUtils.DESCALE(tmp10 - tmp0, REDUCED_CONST_BITS + REDUCED_PASS1_BITS + 3 + 2) & RANGE_MASK];
workspaceIndex += JpegConstants.DCTSize; /* advance pointer to next row */
}
}
/// <summary>
/// Perform dequantization and inverse DCT on one block of coefficients,
/// producing a reduced-size 1x1 output block.
/// </summary>
private void jpeg_idct_1x1(int component_index, short[] coef_block, int output_row, int output_col)
{
/* We hardly need an inverse DCT routine for this: just take the
* average pixel value, which is one-eighth of the DC coefficient.
*/
int[] quantptr = m_dctTables[component_index].int_array;
int dcval = REDUCED_DEQUANTIZE(coef_block[0], quantptr[0]);
dcval = JpegUtils.DESCALE(dcval, 3);
byte[] limit = m_cinfo.m_sample_range_limit;
int limitOffset = m_cinfo.m_sampleRangeLimitOffset + JpegConstants.MediumSampleValue;
m_componentBuffer[output_row + 0][output_col] = limit[limitOffset + dcval & RANGE_MASK];
}
/// <summary>
/// Dequantize a coefficient by multiplying it by the multiplier-table
/// entry; produce an int result. In this module, both inputs and result
/// are 16 bits or less, so either int or short multiply will work.
/// </summary>
private static int REDUCED_DEQUANTIZE(short coef, int quantval)
{
return ((int)coef * quantval);
}
}
#endregion
#region JpegMarker
/// <summary>
/// Representation of special JPEG marker.
/// </summary>
/// <remarks>You can't create instance of this class manually.
/// Concrete objects are instantiated by library and you can get them
/// through <see cref="JpegDecompressor.Marker_list">Marker_list</see> property.
/// </remarks>
/// <seealso cref="JpegDecompressor.Marker_list"/>
/// <seealso href="81c88818-a5d7-4550-9ce5-024a768f7b1e.htm" target="_self">Special markers</seealso>
public class JpegMarker
{
/// <summary>
/// marker code: JPEG_COM, or JPEG_APP0+n
/// </summary>
private byte m_marker;
/// <summary>
/// # bytes of data in the file
/// </summary>
private int m_originalLength;
/// <summary>
/// the data contained in the marker
/// </summary>
private byte[] m_data;
internal JpegMarker(byte marker, int originalDataLength, int lengthLimit)
{
m_marker = marker;
m_originalLength = originalDataLength;
m_data = new byte[lengthLimit];
}
/// <summary>
/// Gets the special marker.
/// </summary>
/// <value>The marker value.</value>
public byte Marker
{
get
{
return m_marker;
}
}
/// <summary>
/// Gets the full length of original data associated with the marker.
/// </summary>
/// <value>The length of original data associated with the marker.</value>
/// <remarks>This length excludes the marker length word, whereas the stored representation
/// within the JPEG file includes it. (Hence the maximum data length is really only 65533.)
/// </remarks>
public int OriginalLength
{
get
{
return m_originalLength;
}
}
/// <summary>
/// Gets the data associated with the marker.
/// </summary>
/// <value>The data associated with the marker.</value>
/// <remarks>The length of this array doesn't exceed <c>length_limit</c> for the particular marker type.
/// Note that this length excludes the marker length word, whereas the stored representation
/// within the JPEG file includes it. (Hence the maximum data length is really only 65533.)
/// </remarks>
public byte[] Data
{
get
{
return m_data;
}
}
}
#endregion
#region JpegMarkerReader
/// <summary>
/// Marker reading and parsing
/// </summary>
class JpegMarkerReader
{
private const int APP0_DATA_LEN = 14; /* Length of interesting data in APP0 */
private const int APP14_DATA_LEN = 12; /* Length of interesting data in APP14 */
private const int APPN_DATA_LEN = 14; /* Must be the largest of the above!! */
private JpegDecompressor m_cinfo;
/* Application-overridable marker processing methods */
private JpegDecompressor.jpeg_marker_parser_method m_process_COM;
private JpegDecompressor.jpeg_marker_parser_method[] m_process_APPn = new JpegDecompressor.jpeg_marker_parser_method[16];
/* Limit on marker data length to save for each marker type */
private int m_length_limit_COM;
private int[] m_length_limit_APPn = new int[16];
private bool m_saw_SOI; /* found SOI? */
private bool m_saw_SOF; /* found SOF? */
private int m_next_restart_num; /* next restart number expected (0-7) */
private int m_discarded_bytes; /* # of bytes skipped looking for a marker */
/* Status of COM/APPn marker saving */
private JpegMarker m_cur_marker; /* null if not processing a marker */
private int m_bytes_read; /* data bytes read so far in marker */
/* Note: cur_marker is not linked into marker_list until it's all read. */
/// <summary>
/// Initialize the marker reader module.
/// This is called only once, when the decompression object is created.
/// </summary>
public JpegMarkerReader(JpegDecompressor cinfo)
{
m_cinfo = cinfo;
/* Initialize COM/APPn processing.
* By default, we examine and then discard APP0 and APP14,
* but simply discard COM and all other APPn.
*/
m_process_COM = skip_variable;
for (int i = 0; i < 16; i++)
{
m_process_APPn[i] = skip_variable;
m_length_limit_APPn[i] = 0;
}
m_process_APPn[0] = get_interesting_appn;
m_process_APPn[14] = get_interesting_appn;
/* Reset marker processing state */
reset_marker_reader();
}
/// <summary>
/// Reset marker processing state to begin a fresh datastream.
/// </summary>
public void reset_marker_reader()
{
m_cinfo.Comp_info = null; /* until allocated by get_sof */
m_cinfo.m_input_scan_number = 0; /* no SOS seen yet */
m_cinfo.m_unread_marker = 0; /* no pending marker */
m_saw_SOI = false; /* set internal state too */
m_saw_SOF = false;
m_discarded_bytes = 0;
m_cur_marker = null;
}
/// <summary>
/// Read markers until SOS or EOI.
///
/// Returns same codes as are defined for jpeg_consume_input:
/// JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI.
/// </summary>
public ReadResult read_markers()
{
/* Outer loop repeats once for each marker. */
for (; ; )
{
/* Collect the marker proper, unless we already did. */
/* NB: first_marker() enforces the requirement that SOI appear first. */
if (m_cinfo.m_unread_marker == 0)
{
if (!m_cinfo.m_marker.m_saw_SOI)
{
if (!first_marker())
return ReadResult.Suspended;
}
else
{
if (!next_marker())
return ReadResult.Suspended;
}
}
/* At this point m_cinfo.unread_marker contains the marker code and the
* input point is just past the marker proper, but before any parameters.
* A suspension will cause us to return with this state still true.
*/
switch ((JpegMarkerType)m_cinfo.m_unread_marker)
{
case JpegMarkerType.SOI:
if (!get_soi())
return ReadResult.Suspended;
break;
case JpegMarkerType.SOF0:
/* Baseline */
case JpegMarkerType.SOF1:
/* Extended sequential, Huffman */
if (!get_sof(false))
return ReadResult.Suspended;
break;
case JpegMarkerType.SOF2:
/* Progressive, Huffman */
if (!get_sof(true))
return ReadResult.Suspended;
break;
/* Currently unsupported SOFn types */
case JpegMarkerType.SOF3:
/* Lossless, Huffman */
case JpegMarkerType.SOF5:
/* Differential sequential, Huffman */
case JpegMarkerType.SOF6:
/* Differential progressive, Huffman */
case JpegMarkerType.SOF7:
/* Differential lossless, Huffman */
case JpegMarkerType.SOF9:
/* Extended sequential, arithmetic */
case JpegMarkerType.SOF10:
/* Progressive, arithmetic */
case JpegMarkerType.JPG:
/* Reserved for JPEG extensions */
case JpegMarkerType.SOF11:
/* Lossless, arithmetic */
case JpegMarkerType.SOF13:
/* Differential sequential, arithmetic */
case JpegMarkerType.SOF14:
/* Differential progressive, arithmetic */
case JpegMarkerType.SOF15:
/* Differential lossless, arithmetic */
throw new Exception(String.Format("Unsupported JPEG process: SOF type 0x{0:X2}", m_cinfo.m_unread_marker));
case JpegMarkerType.SOS:
if (!get_sos())
return ReadResult.Suspended;
m_cinfo.m_unread_marker = 0; /* processed the marker */
return ReadResult.Reached_SOS;
case JpegMarkerType.EOI:
m_cinfo.m_unread_marker = 0; /* processed the marker */
return ReadResult.Reached_EOI;
case JpegMarkerType.DAC:
if (!skip_variable(m_cinfo))
return ReadResult.Suspended;
break;
case JpegMarkerType.DHT:
if (!get_dht())
return ReadResult.Suspended;
break;
case JpegMarkerType.DQT:
if (!get_dqt())
return ReadResult.Suspended;
break;
case JpegMarkerType.DRI:
if (!get_dri())
return ReadResult.Suspended;
break;
case JpegMarkerType.APP0:
case JpegMarkerType.APP1:
case JpegMarkerType.APP2:
case JpegMarkerType.APP3:
case JpegMarkerType.APP4:
case JpegMarkerType.APP5:
case JpegMarkerType.APP6:
case JpegMarkerType.APP7:
case JpegMarkerType.APP8:
case JpegMarkerType.APP9:
case JpegMarkerType.APP10:
case JpegMarkerType.APP11:
case JpegMarkerType.APP12:
case JpegMarkerType.APP13:
case JpegMarkerType.APP14:
case JpegMarkerType.APP15:
if (!m_cinfo.m_marker.m_process_APPn[m_cinfo.m_unread_marker - (int)JpegMarkerType.APP0](m_cinfo))
return ReadResult.Suspended;
break;
case JpegMarkerType.COM:
if (!m_cinfo.m_marker.m_process_COM(m_cinfo))
return ReadResult.Suspended;
break;
/* these are all parameter-less */
case JpegMarkerType.RST0:
case JpegMarkerType.RST1:
case JpegMarkerType.RST2:
case JpegMarkerType.RST3:
case JpegMarkerType.RST4:
case JpegMarkerType.RST5:
case JpegMarkerType.RST6:
case JpegMarkerType.RST7:
case JpegMarkerType.TEM:
break;
case JpegMarkerType.DNL:
/* Ignore DNL ... perhaps the wrong thing */
if (!skip_variable(m_cinfo))
return ReadResult.Suspended;
break;
default:
/* must be DHP, EXP, JPGn, or RESn */
/* For now, we treat the reserved markers as fatal errors since they are
* likely to be used to signal incompatible JPEG Part 3 extensions.
* Once the JPEG 3 version-number marker is well defined, this code
* ought to change!
*/
throw new Exception(String.Format("Unsupported marker type 0x{0:X2}", m_cinfo.m_unread_marker));
}
/* Successfully processed marker, so reset state variable */
m_cinfo.m_unread_marker = 0;
} /* end loop */
}
/// <summary>
/// Read a restart marker, which is expected to appear next in the data-stream;
/// if the marker is not there, take appropriate recovery action.
/// Returns false if suspension is required.
///
/// Made public for use by entropy decoder only
///
/// This is called by the entropy decoder after it has read an appropriate
/// number of MCUs. cinfo.unread_marker may be nonzero if the entropy decoder
/// has already read a marker from the data source. Under normal conditions
/// cinfo.unread_marker will be reset to 0 before returning; if not reset,
/// it holds a marker which the decoder will be unable to read past.
/// </summary>
public bool read_restart_marker()
{
/* Obtain a marker unless we already did. */
/* Note that next_marker will complain if it skips any data. */
if (m_cinfo.m_unread_marker == 0)
{
if (!next_marker())
return false;
}
if (m_cinfo.m_unread_marker == ((int)JpegMarkerType.RST0 + m_cinfo.m_marker.m_next_restart_num))
{
/* Normal case --- swallow the marker and let entropy decoder continue */
m_cinfo.m_unread_marker = 0;
}
else
{
/* Uh-oh, the restart markers have been messed up. */
/* Let the data source manager determine how to re-sync. */
if (!m_cinfo.m_src.resync_to_restart(m_cinfo, m_cinfo.m_marker.m_next_restart_num))
return false;
}
/* Update next-restart state */
m_cinfo.m_marker.m_next_restart_num = (m_cinfo.m_marker.m_next_restart_num + 1) & 7;
return true;
}
/// <summary>
/// Find the next JPEG marker, save it in cinfo.unread_marker.
/// Returns false if had to suspend before reaching a marker;
/// in that case cinfo.unread_marker is unchanged.
///
/// Note that the result might not be a valid marker code,
/// but it will never be 0 or FF.
/// </summary>
public bool next_marker()
{
int c;
for (; ; )
{
if (!m_cinfo.m_src.GetByte(out c))
return false;
/* Skip any non-FF bytes.
* This may look a bit inefficient, but it will not occur in a valid file.
* We sync after each discarded byte so that a suspending data source
* can discard the byte from its buffer.
*/
while (c != 0xFF)
{
m_cinfo.m_marker.m_discarded_bytes++;
if (!m_cinfo.m_src.GetByte(out c))
return false;
}
/* This loop swallows any duplicate FF bytes. Extra FFs are legal as
* pad bytes, so don't count them in discarded_bytes. We assume there
* will not be so many consecutive FF bytes as to overflow a suspending
* data source's input buffer.
*/
do
{
if (!m_cinfo.m_src.GetByte(out c))
return false;
}
while (c == 0xFF);
if (c != 0)
{
/* found a valid marker, exit loop */
break;
}
/* Reach here if we found a stuffed-zero data sequence (FF/00).
* Discard it and loop back to try again.
*/
m_cinfo.m_marker.m_discarded_bytes += 2;
}
if (m_cinfo.m_marker.m_discarded_bytes != 0)
{
m_cinfo.m_marker.m_discarded_bytes = 0;
}
m_cinfo.m_unread_marker = c;
return true;
}
/// <summary>
/// Install a special processing method for COM or APPn markers.
/// </summary>
public void jpeg_set_marker_processor(int marker_code, JpegDecompressor.jpeg_marker_parser_method routine)
{
if (marker_code == (int)JpegMarkerType.COM)
m_process_COM = routine;
else if (marker_code >= (int)JpegMarkerType.APP0 && marker_code <= (int)JpegMarkerType.APP15)
m_process_APPn[marker_code - (int)JpegMarkerType.APP0] = routine;
else
throw new Exception(String.Format("Unsupported marker type 0x{0:X2}", marker_code));
}
public void jpeg_save_markers(int marker_code, int length_limit)
{
/* Choose processor routine to use.
* APP0/APP14 have special requirements.
*/
JpegDecompressor.jpeg_marker_parser_method processor;
if (length_limit != 0)
{
processor = save_marker;
/* If saving APP0/APP14, save at least enough for our internal use. */
if (marker_code == (int)JpegMarkerType.APP0 && length_limit < APP0_DATA_LEN)
length_limit = APP0_DATA_LEN;
else if (marker_code == (int)JpegMarkerType.APP14 && length_limit < APP14_DATA_LEN)
length_limit = APP14_DATA_LEN;
}
else
{
processor = skip_variable;
/* If discarding APP0/APP14, use our regular on-the-fly processor. */
if (marker_code == (int)JpegMarkerType.APP0 || marker_code == (int)JpegMarkerType.APP14)
processor = get_interesting_appn;
}
if (marker_code == (int)JpegMarkerType.COM)
{
m_process_COM = processor;
m_length_limit_COM = length_limit;
}
else if (marker_code >= (int)JpegMarkerType.APP0 && marker_code <= (int)JpegMarkerType.APP15)
{
m_process_APPn[marker_code - (int)JpegMarkerType.APP0] = processor;
m_length_limit_APPn[marker_code - (int)JpegMarkerType.APP0] = length_limit;
}
else
throw new Exception(String.Format("Unsupported marker type 0x{0:X2}", marker_code));
}
/* State of marker reader, applications
* supplying COM or APPn handlers might like to know the state.
*/
public bool SawSOI()
{
return m_saw_SOI;
}
public bool SawSOF()
{
return m_saw_SOF;
}
public int NextRestartNumber()
{
return m_next_restart_num;
}
public int DiscardedByteCount()
{
return m_discarded_bytes;
}
public void SkipBytes(int count)
{
m_discarded_bytes += count;
}
/// <summary>
/// Save an APPn or COM marker into the marker list
/// </summary>
private static bool save_marker(JpegDecompressor cinfo)
{
JpegMarker cur_marker = cinfo.m_marker.m_cur_marker;
byte[] data = null;
int length = 0;
int bytes_read;
int data_length;
int dataOffset = 0;
if (cur_marker == null)
{
/* begin reading a marker */
if (!cinfo.m_src.GetTwoBytes(out length))
return false;
length -= 2;
if (length >= 0)
{
/* watch out for bogus length word */
/* figure out how much we want to save */
int limit;
if (cinfo.m_unread_marker == (int)JpegMarkerType.COM)
limit = cinfo.m_marker.m_length_limit_COM;
else
limit = cinfo.m_marker.m_length_limit_APPn[cinfo.m_unread_marker - (int)JpegMarkerType.APP0];
if (length < limit)
limit = length;
/* allocate and initialize the marker item */
cur_marker = new JpegMarker((byte)cinfo.m_unread_marker, length, limit);
/* data area is just beyond the JpegMarker */
data = cur_marker.Data;
cinfo.m_marker.m_cur_marker = cur_marker;
cinfo.m_marker.m_bytes_read = 0;
bytes_read = 0;
data_length = limit;
}
else
{
/* deal with bogus length word */
bytes_read = data_length = 0;
data = null;
}
}
else
{
/* resume reading a marker */
bytes_read = cinfo.m_marker.m_bytes_read;
data_length = cur_marker.Data.Length;
data = cur_marker.Data;
dataOffset = bytes_read;
}
byte[] tempData = null;
if (data_length != 0)
tempData = new byte[data.Length];
while (bytes_read < data_length)
{
/* move the restart point to here */
cinfo.m_marker.m_bytes_read = bytes_read;
/* If there's not at least one byte in buffer, suspend */
if (!cinfo.m_src.MakeByteAvailable())
return false;
/* Copy bytes with reasonable rapidity */
int read = cinfo.m_src.GetBytes(tempData, data_length - bytes_read);
Buffer.BlockCopy(tempData, 0, data, dataOffset, data_length - bytes_read);
bytes_read += read;
}
/* Done reading what we want to read */
if (cur_marker != null)
{
/* will be null if bogus length word */
/* Add new marker to end of list */
cinfo.m_marker_list.Add(cur_marker);
/* Reset pointer & calc remaining data length */
data = cur_marker.Data;
dataOffset = 0;
length = cur_marker.OriginalLength - data_length;
}
/* Reset to initial state for next marker */
cinfo.m_marker.m_cur_marker = null;
JpegMarkerType currentMarker = (JpegMarkerType)cinfo.m_unread_marker;
if (data_length != 0 && (currentMarker == JpegMarkerType.APP0 || currentMarker == JpegMarkerType.APP14))
{
tempData = new byte[data.Length];
Buffer.BlockCopy(data, dataOffset, tempData, 0, data.Length - dataOffset);
}
/* Process the marker if interesting; else just make a generic trace msg */
switch ((JpegMarkerType)cinfo.m_unread_marker)
{
case JpegMarkerType.APP0:
examine_app0(cinfo, tempData, data_length, length);
break;
case JpegMarkerType.APP14:
examine_app14(cinfo, tempData, data_length, length);
break;
default:
break;
}
/* skip any remaining data -- could be lots */
if (length > 0)
cinfo.m_src.skip_input_data(length);
return true;
}
/// <summary>
/// Skip over an unknown or uninteresting variable-length marker
/// </summary>
private static bool skip_variable(JpegDecompressor cinfo)
{
int length;
if (!cinfo.m_src.GetTwoBytes(out length))
return false;
length -= 2;
if (length > 0)
cinfo.m_src.skip_input_data(length);
return true;
}
/// <summary>
/// Process an APP0 or APP14 marker without saving it
/// </summary>
private static bool get_interesting_appn(JpegDecompressor cinfo)
{
int length;
if (!cinfo.m_src.GetTwoBytes(out length))
return false;
length -= 2;
/* get the interesting part of the marker data */
int numtoread = 0;
if (length >= APPN_DATA_LEN)
numtoread = APPN_DATA_LEN;
else if (length > 0)
numtoread = length;
byte[] b = new byte[APPN_DATA_LEN];
for (int i = 0; i < numtoread; i++)
{
int temp = 0;
if (!cinfo.m_src.GetByte(out temp))
return false;
b[i] = (byte)temp;
}
length -= numtoread;
/* process it */
switch ((JpegMarkerType)cinfo.m_unread_marker)
{
case JpegMarkerType.APP0:
examine_app0(cinfo, b, numtoread, length);
break;
case JpegMarkerType.APP14:
examine_app14(cinfo, b, numtoread, length);
break;
default:
/* can't get here unless jpeg_save_markers chooses wrong processor */
throw new Exception(String.Format("Unsupported marker type 0x{0:X2}", cinfo.m_unread_marker));
}
/* skip any remaining data -- could be lots */
if (length > 0)
cinfo.m_src.skip_input_data(length);
return true;
}
/*
* Routines for processing APPn and COM markers.
* These are either saved in memory or discarded, per application request.
* APP0 and APP14 are specially checked to see if they are
* JFIF and Adobe markers, respectively.
*/
/// <summary>
/// Examine first few bytes from an APP0.
/// Take appropriate action if it is a JFIF marker.
/// datalen is # of bytes at data[], remaining is length of rest of marker data.
/// </summary>
private static void examine_app0(JpegDecompressor cinfo, byte[] data, int datalen, int remaining)
{
int totallen = datalen + remaining;
if (datalen >= APP0_DATA_LEN &&
data[0] == 0x4A &&
data[1] == 0x46 &&
data[2] == 0x49 &&
data[3] == 0x46 &&
data[4] == 0)
{
/* Found JFIF APP0 marker: save info */
cinfo.m_saw_JFIF_marker = true;
cinfo.m_JFIF_major_version = data[5];
cinfo.m_JFIF_minor_version = data[6];
cinfo.m_density_unit = (DensityUnit)data[7];
cinfo.m_X_density = (short)((data[8] << 8) + data[9]);
cinfo.m_Y_density = (short)((data[10] << 8) + data[11]);
}
else if (datalen >= 6 && data[0] == 0x4A && data[1] == 0x46 && data[2] == 0x58 && data[3] == 0x58 && data[4] == 0)
{
/* Found JFIF "JFXX" extension APP0 marker */
/* The library doesn't actually do anything with these.
*/
}
else
{
/* Start of APP0 does not match "JFIF" or "JFXX", or too short */
}
}
/// <summary>
/// Examine first few bytes from an APP14.
/// Take appropriate action if it is an Adobe marker.
/// datalen is # of bytes at data[], remaining is length of rest of marker data.
/// </summary>
private static void examine_app14(JpegDecompressor cinfo, byte[] data, int datalen, int remaining)
{
if (datalen >= APP14_DATA_LEN &&
data[0] == 0x41 &&
data[1] == 0x64 &&
data[2] == 0x6F &&
data[3] == 0x62 &&
data[4] == 0x65)
{
/* Found Adobe APP14 marker */
int version = (data[5] << 8) + data[6];
int flags0 = (data[7] << 8) + data[8];
int flags1 = (data[9] << 8) + data[10];
int transform = data[11];
cinfo.m_saw_Adobe_marker = true;
cinfo.m_Adobe_transform = (byte)transform;
}
else
{
/* Start of APP14 does not match "Adobe", or too short */
}
}
/*
* Routines to process JPEG markers.
*
* Entry condition: JPEG marker itself has been read and its code saved
* in cinfo.unread_marker; input restart point is just after the marker.
*
* Exit: if return true, have read and processed any parameters, and have
* updated the restart point to point after the parameters.
* If return false, was forced to suspend before reaching end of
* marker parameters; restart point has not been moved. Same routine
* will be called again after application supplies more input data.
*
* This approach to suspension assumes that all of a marker's parameters
* can fit into a single input buffer-load. This should hold for "normal"
* markers. Some COM/APPn markers might have large parameter segments
* that might not fit. If we are simply dropping such a marker, we use
* skip_input_data to get past it, and thereby put the problem on the
* source manager's shoulders. If we are saving the marker's contents
* into memory, we use a slightly different convention: when forced to
* suspend, the marker processor updates the restart point to the end of
* what it's consumed (ie, the end of the buffer) before returning false.
* On resumption, cinfo.unread_marker still contains the marker code,
* but the data source will point to the next chunk of marker data.
* The marker processor must retain internal state to deal with this.
*
* Note that we don't bother to avoid duplicate trace messages if a
* suspension occurs within marker parameters. Other side effects
* require more care.
*/
/// <summary>
/// Process an SOI marker
/// </summary>
private bool get_soi()
{
if (m_cinfo.m_marker.m_saw_SOI)
throw new Exception("Invalid JPEG file structure: two SOI markers");
/* Reset all parameters that are defined to be reset by SOI */
m_cinfo.m_restart_interval = 0;
/* Set initial assumptions for colorspace etc */
m_cinfo.m_jpeg_color_space = ColorSpace.Unknown;
m_cinfo.m_CCIR601_sampling = false; /* Assume non-CCIR sampling??? */
m_cinfo.m_saw_JFIF_marker = false;
m_cinfo.m_JFIF_major_version = 1; /* set default JFIF APP0 values */
m_cinfo.m_JFIF_minor_version = 1;
m_cinfo.m_density_unit = DensityUnit.Unknown;
m_cinfo.m_X_density = 1;
m_cinfo.m_Y_density = 1;
m_cinfo.m_saw_Adobe_marker = false;
m_cinfo.m_Adobe_transform = 0;
m_cinfo.m_marker.m_saw_SOI = true;
return true;
}
/// <summary>
/// Process a SOFn marker
/// </summary>
private bool get_sof(bool is_prog)
{
m_cinfo.m_progressive_mode = is_prog;
int length;
if (!m_cinfo.m_src.GetTwoBytes(out length))
return false;
if (!m_cinfo.m_src.GetByte(out m_cinfo.m_data_precision))
return false;
int temp = 0;
if (!m_cinfo.m_src.GetTwoBytes(out temp))
return false;
m_cinfo.m_image_height = temp;
if (!m_cinfo.m_src.GetTwoBytes(out temp))
return false;
m_cinfo.m_image_width = temp;
if (!m_cinfo.m_src.GetByte(out m_cinfo.m_num_components))
return false;
length -= 8;
if (m_cinfo.m_marker.m_saw_SOF)
throw new Exception("Invalid JPEG file structure: two SOI markers");
/* We don't support files in which the image height is initially specified */
/* as 0 and is later redefined by DNL. As long as we have to check that, */
/* might as well have a general sanity check. */
if (m_cinfo.m_image_height <= 0 || m_cinfo.m_image_width <= 0 || m_cinfo.m_num_components <= 0)
throw new Exception("Empty JPEG image (DNL not supported)");
if (length != (m_cinfo.m_num_components * 3))
throw new Exception("Bogus marker length");
if (m_cinfo.Comp_info == null)
{
/* do only once, even if suspend */
m_cinfo.Comp_info = JpegComponent.createArrayOfComponents(m_cinfo.m_num_components);
}
for (int ci = 0; ci < m_cinfo.m_num_components; ci++)
{
m_cinfo.Comp_info[ci].Component_index = ci;
int component_id;
if (!m_cinfo.m_src.GetByte(out component_id))
return false;
m_cinfo.Comp_info[ci].Component_id = component_id;
int c;
if (!m_cinfo.m_src.GetByte(out c))
return false;
m_cinfo.Comp_info[ci].H_samp_factor = (c >> 4) & 15;
m_cinfo.Comp_info[ci].V_samp_factor = (c) & 15;
int quant_tbl_no;
if (!m_cinfo.m_src.GetByte(out quant_tbl_no))
return false;
m_cinfo.Comp_info[ci].Quant_tbl_no = quant_tbl_no;
}
m_cinfo.m_marker.m_saw_SOF = true;
return true;
}
/// <summary>
/// Process a SOS marker
/// </summary>
private bool get_sos()
{
if (!m_cinfo.m_marker.m_saw_SOF)
throw new Exception("Invalid JPEG file structure: SOS before SOF");
int length;
if (!m_cinfo.m_src.GetTwoBytes(out length))
return false;
/* Number of components */
int n;
if (!m_cinfo.m_src.GetByte(out n))
return false;
if (length != (n * 2 + 6) || n < 1 || n > JpegConstants.MaxComponentsInScan)
throw new Exception("Bogus marker length");
m_cinfo.m_comps_in_scan = n;
/* Collect the component-spec parameters */
for (int i = 0; i < n; i++)
{
int cc;
if (!m_cinfo.m_src.GetByte(out cc))
return false;
int c;
if (!m_cinfo.m_src.GetByte(out c))
return false;
bool idFound = false;
int foundIndex = -1;
for (int ci = 0; ci < m_cinfo.m_num_components; ci++)
{
if (cc == m_cinfo.Comp_info[ci].Component_id)
{
foundIndex = ci;
idFound = true;
break;
}
}
if (!idFound)
throw new Exception(String.Format("Invalid component ID {0} in SOS", cc));
m_cinfo.m_cur_comp_info[i] = foundIndex;
m_cinfo.Comp_info[foundIndex].Dc_tbl_no = (c >> 4) & 15;
m_cinfo.Comp_info[foundIndex].Ac_tbl_no = (c) & 15;
}
/* Collect the additional scan parameters Ss, Se, Ah/Al. */
int temp;
if (!m_cinfo.m_src.GetByte(out temp))
return false;
m_cinfo.m_Ss = temp;
if (!m_cinfo.m_src.GetByte(out temp))
return false;
m_cinfo.m_Se = temp;
if (!m_cinfo.m_src.GetByte(out temp))
return false;
m_cinfo.m_Ah = (temp >> 4) & 15;
m_cinfo.m_Al = (temp) & 15;
/* Prepare to scan data & restart markers */
m_cinfo.m_marker.m_next_restart_num = 0;
/* Count another SOS marker */
m_cinfo.m_input_scan_number++;
return true;
}
/// <summary>
/// Process a DHT marker
/// </summary>
private bool get_dht()
{
int length;
if (!m_cinfo.m_src.GetTwoBytes(out length))
return false;
length -= 2;
byte[] bits = new byte[17];
byte[] huffval = new byte[256];
while (length > 16)
{
int index;
if (!m_cinfo.m_src.GetByte(out index))
return false;
bits[0] = 0;
int count = 0;
for (int i = 1; i <= 16; i++)
{
int temp = 0;
if (!m_cinfo.m_src.GetByte(out temp))
return false;
bits[i] = (byte)temp;
count += bits[i];
}
length -= 1 + 16;
/* Here we just do minimal validation of the counts to avoid walking
* off the end of our table space. HuffEntropyDecoder will check more carefully.
*/
if (count > 256 || count > length)
throw new Exception("Bogus Huffman table definition");
for (int i = 0; i < count; i++)
{
int temp = 0;
if (!m_cinfo.m_src.GetByte(out temp))
return false;
huffval[i] = (byte)temp;
}
length -= count;
JpegHuffmanTable htblptr = null;
if ((index & 0x10) != 0)
{
/* AC table definition */
index -= 0x10;
if (m_cinfo.m_ac_huff_tbl_ptrs[index] == null)
m_cinfo.m_ac_huff_tbl_ptrs[index] = new JpegHuffmanTable();
htblptr = m_cinfo.m_ac_huff_tbl_ptrs[index];
}
else
{
/* DC table definition */
if (m_cinfo.m_dc_huff_tbl_ptrs[index] == null)
m_cinfo.m_dc_huff_tbl_ptrs[index] = new JpegHuffmanTable();
htblptr = m_cinfo.m_dc_huff_tbl_ptrs[index];
}
if (index < 0 || index >= JpegConstants.NumberOfHuffmanTables)
throw new Exception(String.Format("Bogus DHT index {0}", index));
Buffer.BlockCopy(bits, 0, htblptr.Bits, 0, htblptr.Bits.Length);
Buffer.BlockCopy(huffval, 0, htblptr.Huffval, 0, htblptr.Huffval.Length);
}
if (length != 0)
throw new Exception("Bogus marker length");
return true;
}
/// <summary>
/// Process a DQT marker
/// </summary>
private bool get_dqt()
{
int length;
if (!m_cinfo.m_src.GetTwoBytes(out length))
return false;
length -= 2;
while (length > 0)
{
int n;
if (!m_cinfo.m_src.GetByte(out n))
return false;
int prec = n >> 4;
n &= 0x0F;
if (n >= JpegConstants.NumberOfQuantTables)
throw new Exception(String.Format("Bogus DQT index {0}", n));
if (m_cinfo.m_quant_tbl_ptrs[n] == null)
m_cinfo.m_quant_tbl_ptrs[n] = new JpegQuantizationTable();
JpegQuantizationTable quant_ptr = m_cinfo.m_quant_tbl_ptrs[n];
for (int i = 0; i < JpegConstants.DCTSize2; i++)
{
int tmp;
if (prec != 0)
{
int temp = 0;
if (!m_cinfo.m_src.GetTwoBytes(out temp))
return false;
tmp = temp;
}
else
{
int temp = 0;
if (!m_cinfo.m_src.GetByte(out temp))
return false;
tmp = temp;
}
/* We convert the zigzag-order table to natural array order. */
quant_ptr.quantval[JpegUtils.jpeg_natural_order[i]] = (short)tmp;
}
length -= JpegConstants.DCTSize2 + 1;
if (prec != 0)
length -= JpegConstants.DCTSize2;
}
if (length != 0)
throw new Exception("Bogus marker length");
return true;
}
/// <summary>
/// Process a DRI marker
/// </summary>
private bool get_dri()
{
int length;
if (!m_cinfo.m_src.GetTwoBytes(out length))
return false;
if (length != 4)
throw new Exception("Bogus marker length");
int temp = 0;
if (!m_cinfo.m_src.GetTwoBytes(out temp))
return false;
int tmp = temp;
m_cinfo.m_restart_interval = tmp;
return true;
}
/// <summary>
/// Like next_marker, but used to obtain the initial SOI marker.
/// For this marker, we do not allow preceding garbage or fill; otherwise,
/// we might well scan an entire input file before realizing it's not JPEG.
/// If an application wants to process non-JFIF files, it must seek to the
/// SOI before calling the JPEG library.
/// </summary>
private bool first_marker()
{
int c;
if (!m_cinfo.m_src.GetByte(out c))
return false;
int c2;
if (!m_cinfo.m_src.GetByte(out c2))
return false;
if (c != 0xFF || c2 != (int)JpegMarkerType.SOI)
throw new Exception(String.Format("Not a JPEG file: starts with 0x{0:X2} 0x{1:X2}", c, c2));
m_cinfo.m_unread_marker = c2;
return true;
}
}
#endregion
#region JpegMarkerType
/// <summary>
/// JPEG marker codes.
/// </summary>
/// <seealso href="81c88818-a5d7-4550-9ce5-024a768f7b1e.htm" target="_self">Special markers</seealso>
public enum JpegMarkerType
{
/// <summary>
///
/// </summary>
SOF0 = 0xc0,
/// <summary>
///
/// </summary>
SOF1 = 0xc1,
/// <summary>
///
/// </summary>
SOF2 = 0xc2,
/// <summary>
///
/// </summary>
SOF3 = 0xc3,
/// <summary>
///
/// </summary>
SOF5 = 0xc5,
/// <summary>
///
/// </summary>
SOF6 = 0xc6,
/// <summary>
///
/// </summary>
SOF7 = 0xc7,
/// <summary>
///
/// </summary>
JPG = 0xc8,
/// <summary>
///
/// </summary>
SOF9 = 0xc9,
/// <summary>
///
/// </summary>
SOF10 = 0xca,
/// <summary>
///
/// </summary>
SOF11 = 0xcb,
/// <summary>
///
/// </summary>
SOF13 = 0xcd,
/// <summary>
///
/// </summary>
SOF14 = 0xce,
/// <summary>
///
/// </summary>
SOF15 = 0xcf,
/// <summary>
///
/// </summary>
DHT = 0xc4,
/// <summary>
///
/// </summary>
DAC = 0xcc,
/// <summary>
///
/// </summary>
RST0 = 0xd0,
/// <summary>
///
/// </summary>
RST1 = 0xd1,
/// <summary>
///
/// </summary>
RST2 = 0xd2,
/// <summary>
///
/// </summary>
RST3 = 0xd3,
/// <summary>
///
/// </summary>
RST4 = 0xd4,
/// <summary>
///
/// </summary>
RST5 = 0xd5,
/// <summary>
///
/// </summary>
RST6 = 0xd6,
/// <summary>
///
/// </summary>
RST7 = 0xd7,
/// <summary>
///
/// </summary>
SOI = 0xd8,
/// <summary>
///
/// </summary>
EOI = 0xd9,
/// <summary>
///
/// </summary>
SOS = 0xda,
/// <summary>
///
/// </summary>
DQT = 0xdb,
/// <summary>
///
/// </summary>
DNL = 0xdc,
/// <summary>
///
/// </summary>
DRI = 0xdd,
/// <summary>
///
/// </summary>
DHP = 0xde,
/// <summary>
///
/// </summary>
EXP = 0xdf,
/// <summary>
///
/// </summary>
APP0 = 0xe0,
/// <summary>
///
/// </summary>
APP1 = 0xe1,
/// <summary>
///
/// </summary>
APP2 = 0xe2,
/// <summary>
///
/// </summary>
APP3 = 0xe3,
/// <summary>
///
/// </summary>
APP4 = 0xe4,
/// <summary>
///
/// </summary>
APP5 = 0xe5,
/// <summary>
///
/// </summary>
APP6 = 0xe6,
/// <summary>
///
/// </summary>
APP7 = 0xe7,
/// <summary>
///
/// </summary>
APP8 = 0xe8,
/// <summary>
///
/// </summary>
APP9 = 0xe9,
/// <summary>
///
/// </summary>
APP10 = 0xea,
/// <summary>
///
/// </summary>
APP11 = 0xeb,
/// <summary>
///
/// </summary>
APP12 = 0xec,
/// <summary>
///
/// </summary>
APP13 = 0xed,
/// <summary>
///
/// </summary>
APP14 = 0xee,
/// <summary>
///
/// </summary>
APP15 = 0xef,
/// <summary>
///
/// </summary>
JPG0 = 0xf0,
/// <summary>
///
/// </summary>
JPG13 = 0xfd,
/// <summary>
///
/// </summary>
COM = 0xfe,
/// <summary>
///
/// </summary>
TEM = 0x01,
/// <summary>
///
/// </summary>
ERROR = 0x100
}
#endregion
#region JpegMarkerWriter
/// <summary>
/// Marker writing
/// </summary>
class JpegMarkerWriter
{
private JpegCompressor m_cinfo;
private int m_last_restart_interval; /* last DRI value emitted; 0 after SOI */
public JpegMarkerWriter(JpegCompressor cinfo)
{
m_cinfo = cinfo;
}
/// <summary>
/// Write datastream header.
/// This consists of an SOI and optional APPn markers.
/// We recommend use of the JFIF marker, but not the Adobe marker,
/// when using YCbCr or grayscale data. The JFIF marker should NOT
/// be used for any other JPEG colorspace. The Adobe marker is helpful
/// to distinguish RGB, CMYK, and YCCK colorspaces.
/// Note that an application can write additional header markers after
/// jpeg_start_compress returns.
/// </summary>
public void write_file_header()
{
emit_marker(JpegMarkerType.SOI); /* first the SOI */
/* SOI is defined to reset restart interval to 0 */
m_last_restart_interval = 0;
if (m_cinfo.m_write_JFIF_header) /* next an optional JFIF APP0 */
emit_jfif_app0();
if (m_cinfo.m_write_Adobe_marker) /* next an optional Adobe APP14 */
emit_adobe_app14();
}
/// <summary>
/// Write frame header.
/// This consists of DQT and SOFn markers.
/// Note that we do not emit the SOF until we have emitted the DQT(s).
/// This avoids compatibility problems with incorrect implementations that
/// try to error-check the quant table numbers as soon as they see the SOF.
/// </summary>
public void write_frame_header()
{
/* Emit DQT for each quantization table.
* Note that emit_dqt() suppresses any duplicate tables.
*/
int prec = 0;
for (int ci = 0; ci < m_cinfo.m_num_components; ci++)
prec += emit_dqt(m_cinfo.Component_info[ci].Quant_tbl_no);
/* now prec is nonzero iff there are any 16-bit quant tables. */
/* Check for a non-baseline specification.
* Note we assume that Huffman table numbers won't be changed later.
*/
bool is_baseline;
if (m_cinfo.m_progressive_mode || m_cinfo.m_data_precision != 8)
{
is_baseline = false;
}
else
{
is_baseline = true;
for (int ci = 0; ci < m_cinfo.m_num_components; ci++)
{
if (m_cinfo.Component_info[ci].Dc_tbl_no > 1 || m_cinfo.Component_info[ci].Ac_tbl_no > 1)
is_baseline = false;
}
if (prec != 0 && is_baseline)
{
is_baseline = false;
}
}
/* Emit the proper SOF marker */
if (m_cinfo.m_progressive_mode)
emit_sof(JpegMarkerType.SOF2); /* SOF code for progressive Huffman */
else if (is_baseline)
emit_sof(JpegMarkerType.SOF0); /* SOF code for baseline implementation */
else
emit_sof(JpegMarkerType.SOF1); /* SOF code for non-baseline Huffman file */
}
/// <summary>
/// Write scan header.
/// This consists of DHT or DAC markers, optional DRI, and SOS.
/// Compressed data will be written following the SOS.
/// </summary>
public void write_scan_header()
{
/* Emit Huffman tables.
* Note that emit_dht() suppresses any duplicate tables.
*/
for (int i = 0; i < m_cinfo.m_comps_in_scan; i++)
{
int ac_tbl_no = m_cinfo.Component_info[m_cinfo.m_cur_comp_info[i]].Ac_tbl_no;
int dc_tbl_no = m_cinfo.Component_info[m_cinfo.m_cur_comp_info[i]].Dc_tbl_no;
if (m_cinfo.m_progressive_mode)
{
/* Progressive mode: only DC or only AC tables are used in one scan */
if (m_cinfo.m_Ss == 0)
{
if (m_cinfo.m_Ah == 0)
{
/* DC needs no table for refinement scan */
emit_dht(dc_tbl_no, false);
}
}
else
{
emit_dht(ac_tbl_no, true);
}
}
else
{
/* Sequential mode: need both DC and AC tables */
emit_dht(dc_tbl_no, false);
emit_dht(ac_tbl_no, true);
}
}
/* Emit DRI if required --- note that DRI value could change for each scan.
* We avoid wasting space with unnecessary DRIs, however.
*/
if (m_cinfo.m_restart_interval != m_last_restart_interval)
{
emit_dri();
m_last_restart_interval = m_cinfo.m_restart_interval;
}
emit_sos();
}
/// <summary>
/// Write datastream trailer.
/// </summary>
public void write_file_trailer()
{
emit_marker(JpegMarkerType.EOI);
}
/// <summary>
/// Write an abbreviated table-specification datastream.
/// This consists of SOI, DQT and DHT tables, and EOI.
/// Any table that is defined and not marked sent_table = true will be
/// emitted. Note that all tables will be marked sent_table = true at exit.
/// </summary>
public void write_tables_only()
{
emit_marker(JpegMarkerType.SOI);
for (int i = 0; i < JpegConstants.NumberOfQuantTables; i++)
{
if (m_cinfo.m_quant_tbl_ptrs[i] != null)
emit_dqt(i);
}
for (int i = 0; i < JpegConstants.NumberOfHuffmanTables; i++)
{
if (m_cinfo.m_dc_huff_tbl_ptrs[i] != null)
emit_dht(i, false);
if (m_cinfo.m_ac_huff_tbl_ptrs[i] != null)
emit_dht(i, true);
}
emit_marker(JpegMarkerType.EOI);
}
//////////////////////////////////////////////////////////////////////////
// These routines allow writing an arbitrary marker with parameters.
// The only intended use is to emit COM or APPn markers after calling
// write_file_header and before calling write_frame_header.
// Other uses are not guaranteed to produce desirable results.
// Counting the parameter bytes properly is the caller's responsibility.
/// <summary>
/// Emit an arbitrary marker header
/// </summary>
public void write_marker_header(int marker, int datalen)
{
if (datalen > 65533) /* safety check */
throw new Exception("Bogus marker length");
emit_marker((JpegMarkerType)marker);
emit_2bytes(datalen + 2); /* total length */
}
/// <summary>
/// Emit one byte of marker parameters following write_marker_header
/// </summary>
public void write_marker_byte(byte val)
{
emit_byte(val);
}
//////////////////////////////////////////////////////////////////////////
// Routines to write specific marker types.
//
/// <summary>
/// Emit a SOS marker
/// </summary>
private void emit_sos()
{
emit_marker(JpegMarkerType.SOS);
emit_2bytes(2 * m_cinfo.m_comps_in_scan + 2 + 1 + 3); /* length */
emit_byte(m_cinfo.m_comps_in_scan);
for (int i = 0; i < m_cinfo.m_comps_in_scan; i++)
{
int componentIndex = m_cinfo.m_cur_comp_info[i];
emit_byte(m_cinfo.Component_info[componentIndex].Component_id);
int td = m_cinfo.Component_info[componentIndex].Dc_tbl_no;
int ta = m_cinfo.Component_info[componentIndex].Ac_tbl_no;
if (m_cinfo.m_progressive_mode)
{
/* Progressive mode: only DC or only AC tables are used in one scan;
* furthermore, Huffman coding of DC refinement uses no table at all.
* We emit 0 for unused field(s); this is recommended by the P&M text
* but does not seem to be specified in the standard.
*/
if (m_cinfo.m_Ss == 0)
{
/* DC scan */
ta = 0;
if (m_cinfo.m_Ah != 0)
{
/* no DC table either */
td = 0;
}
}
else
{
/* AC scan */
td = 0;
}
}
emit_byte((td << 4) + ta);
}
emit_byte(m_cinfo.m_Ss);
emit_byte(m_cinfo.m_Se);
emit_byte((m_cinfo.m_Ah << 4) + m_cinfo.m_Al);
}
/// <summary>
/// Emit a SOF marker
/// </summary>
private void emit_sof(JpegMarkerType code)
{
emit_marker(code);
emit_2bytes(3 * m_cinfo.m_num_components + 2 + 5 + 1); /* length */
/* Make sure image isn't bigger than SOF field can handle */
if (m_cinfo.m_image_height > 65535 || m_cinfo.m_image_width > 65535)
throw new Exception(String.Format("Maximum supported image dimension is {0} pixels", 65535));
emit_byte(m_cinfo.m_data_precision);
emit_2bytes(m_cinfo.m_image_height);
emit_2bytes(m_cinfo.m_image_width);
emit_byte(m_cinfo.m_num_components);
for (int ci = 0; ci < m_cinfo.m_num_components; ci++)
{
JpegComponent componentInfo = m_cinfo.Component_info[ci];
emit_byte(componentInfo.Component_id);
emit_byte((componentInfo.H_samp_factor << 4) + componentInfo.V_samp_factor);
emit_byte(componentInfo.Quant_tbl_no);
}
}
/// <summary>
/// Emit an Adobe APP14 marker
/// </summary>
private void emit_adobe_app14()
{
/*
* Length of APP14 block (2 bytes)
* Block ID (5 bytes - ASCII "Adobe")
* Version Number (2 bytes - currently 100)
* Flags0 (2 bytes - currently 0)
* Flags1 (2 bytes - currently 0)
* Color transform (1 byte)
*
* Although Adobe TN 5116 mentions Version = 101, all the Adobe files
* now in circulation seem to use Version = 100, so that's what we write.
*
* We write the color transform byte as 1 if the JPEG color space is
* YCbCr, 2 if it's YCCK, 0 otherwise. Adobe's definition has to do with
* whether the encoder performed a transformation, which is pretty useless.
*/
emit_marker(JpegMarkerType.APP14);
emit_2bytes(2 + 5 + 2 + 2 + 2 + 1); /* length */
emit_byte(0x41); /* Identifier: ASCII "Adobe" */
emit_byte(0x64);
emit_byte(0x6F);
emit_byte(0x62);
emit_byte(0x65);
emit_2bytes(100); /* Version */
emit_2bytes(0); /* Flags0 */
emit_2bytes(0); /* Flags1 */
switch (m_cinfo.m_jpeg_color_space)
{
case ColorSpace.YCbCr:
emit_byte(1); /* Color transform = 1 */
break;
case ColorSpace.YCCK:
emit_byte(2); /* Color transform = 2 */
break;
default:
emit_byte(0); /* Color transform = 0 */
break;
}
}
/// <summary>
/// Emit a DRI marker
/// </summary>
private void emit_dri()
{
emit_marker(JpegMarkerType.DRI);
emit_2bytes(4); /* fixed length */
emit_2bytes(m_cinfo.m_restart_interval);
}
/// <summary>
/// Emit a DHT marker
/// </summary>
private void emit_dht(int index, bool is_ac)
{
JpegHuffmanTable htbl = m_cinfo.m_dc_huff_tbl_ptrs[index];
if (is_ac)
{
htbl = m_cinfo.m_ac_huff_tbl_ptrs[index];
index += 0x10; /* output index has AC bit set */
}
if (htbl == null)
throw new Exception(String.Format("Huffman table 0x{0:X2} was not defined", index));
if (!htbl.Sent_table)
{
emit_marker(JpegMarkerType.DHT);
int length = 0;
for (int i = 1; i <= 16; i++)
length += htbl.Bits[i];
emit_2bytes(length + 2 + 1 + 16);
emit_byte(index);
for (int i = 1; i <= 16; i++)
emit_byte(htbl.Bits[i]);
for (int i = 0; i < length; i++)
emit_byte(htbl.Huffval[i]);
htbl.Sent_table = true;
}
}
/// <summary>
/// Emit a DQT marker
/// </summary>
/// <param name="index">The index.</param>
/// <returns>the precision used (0 = 8bits, 1 = 16bits) for baseline checking</returns>
private int emit_dqt(int index)
{
JpegQuantizationTable qtbl = m_cinfo.m_quant_tbl_ptrs[index];
if (qtbl == null)
throw new Exception(String.Format("Quantization table 0x{0:X2} was not defined", index));
int prec = 0;
for (int i = 0; i < JpegConstants.DCTSize2; i++)
{
if (qtbl.quantval[i] > 255)
prec = 1;
}
if (!qtbl.Sent_table)
{
emit_marker(JpegMarkerType.DQT);
emit_2bytes(prec != 0 ? JpegConstants.DCTSize2 * 2 + 1 + 2 : JpegConstants.DCTSize2 + 1 + 2);
emit_byte(index + (prec << 4));
for (int i = 0; i < JpegConstants.DCTSize2; i++)
{
/* The table entries must be emitted in zigzag order. */
int qval = qtbl.quantval[JpegUtils.jpeg_natural_order[i]];
if (prec != 0)
emit_byte(qval >> 8);
emit_byte(qval & 0xFF);
}
qtbl.Sent_table = true;
}
return prec;
}
/// <summary>
/// Emit a JFIF-compliant APP0 marker
/// </summary>
private void emit_jfif_app0()
{
/*
* Length of APP0 block (2 bytes)
* Block ID (4 bytes - ASCII "JFIF")
* Zero byte (1 byte to terminate the ID string)
* Version Major, Minor (2 bytes - major first)
* Units (1 byte - 0x00 = none, 0x01 = inch, 0x02 = cm)
* Xdpu (2 bytes - dots per unit horizontal)
* Ydpu (2 bytes - dots per unit vertical)
* Thumbnail X size (1 byte)
* Thumbnail Y size (1 byte)
*/
emit_marker(JpegMarkerType.APP0);
emit_2bytes(2 + 4 + 1 + 2 + 1 + 2 + 2 + 1 + 1); /* length */
emit_byte(0x4A); /* Identifier: ASCII "JFIF" */
emit_byte(0x46);
emit_byte(0x49);
emit_byte(0x46);
emit_byte(0);
emit_byte(m_cinfo.m_JFIF_major_version); /* Version fields */
emit_byte(m_cinfo.m_JFIF_minor_version);
emit_byte((int)m_cinfo.m_density_unit); /* Pixel size information */
emit_2bytes(m_cinfo.m_X_density);
emit_2bytes(m_cinfo.m_Y_density);
emit_byte(0); /* No thumbnail image */
emit_byte(0);
}
//////////////////////////////////////////////////////////////////////////
// Basic output routines.
//
// Note that we do not support suspension while writing a marker.
// Therefore, an application using suspension must ensure that there is
// enough buffer space for the initial markers (typ. 600-700 bytes) before
// calling jpeg_start_compress, and enough space to write the trailing EOI
// (a few bytes) before calling jpeg_finish_compress. Multi-pass compression
// modes are not supported at all with suspension, so those two are the only
// points where markers will be written.
/// <summary>
/// Emit a marker code
/// </summary>
private void emit_marker(JpegMarkerType mark)
{
emit_byte(0xFF);
emit_byte((int)mark);
}
/// <summary>
/// Emit a 2-byte integer; these are always MSB first in JPEG files
/// </summary>
private void emit_2bytes(int value)
{
emit_byte((value >> 8) & 0xFF);
emit_byte(value & 0xFF);
}
/// <summary>
/// Emit a byte
/// </summary>
private void emit_byte(int val)
{
if (!m_cinfo.m_dest.emit_byte(val))
throw new Exception("Suspension not allowed here");
}
}
#endregion
#region JpegQuantizationTable
/// <summary>
/// DCT coefficient quantization table.
/// </summary>
public class JpegQuantizationTable
{
/// <summary>
/// This field is used only during compression. It's initialized false when
/// the table is created, and set true when it's been output to the file.
/// You could suppress output of a table by setting this to true.
/// </summary>
private bool m_sent_table;
/// <summary>
/// This array gives the coefficient quantizers in natural array order
/// (not the zigzag order in which they are stored in a JPEG DQT marker).
/// CAUTION: IJG versions prior to v6a kept this array in zigzag order.
/// </summary>
internal readonly short[] quantval = new short[JpegConstants.DCTSize2];
internal JpegQuantizationTable()
{
}
/// <summary>
/// Gets or sets a value indicating whether the table has been output to file.
/// </summary>
/// <value>It's initialized <c>false</c> when the table is created, and set
/// <c>true</c> when it's been output to the file. You could suppress output of a table by setting this to <c>true</c>.
/// </value>
/// <remarks>This property is used only during compression.</remarks>
/// <seealso cref="JpegCompressor.jpeg_suppress_tables"/>
public bool Sent_table
{
get { return m_sent_table; }
set { m_sent_table = value; }
}
}
#endregion
#region JpegScanInfo
/// <summary>
/// The script for encoding a multiple-scan file is an array of these:
/// </summary>
class JpegScanInfo
{
public int comps_in_scan; /* number of components encoded in this scan */
public int[] component_index = new int[JpegConstants.MaxComponentsInScan]; /* their SOF/comp_info[] indexes */
public int Ss;
public int Se; /* progressive JPEG spectral selection parms */
public int Ah;
public int Al; /* progressive JPEG successive approx. parms */
}
#endregion
#region JpegSource
/// <summary>
/// Data source object for decompression.
/// </summary>
public abstract class Jpeg_Source
{
private byte[] m_next_input_byte;
private int m_bytes_in_buffer; /* # of bytes remaining (unread) in buffer */
private int m_position;
/// <summary>
/// Initializes this instance.
/// </summary>
public abstract void init_source();
/// <summary>
/// Fills input buffer
/// </summary>
/// <returns><c>true</c> if operation succeed; otherwise, <c>false</c></returns>
public abstract bool fill_input_buffer();
/// <summary>
/// Initializes the internal buffer.
/// </summary>
/// <param name="buffer">The buffer.</param>
/// <param name="size">The size.</param>
protected void initInternalBuffer(byte[] buffer, int size)
{
m_bytes_in_buffer = size;
m_next_input_byte = buffer;
m_position = 0;
}
/// <summary>
/// Skip data - used to skip over a potentially large amount of
/// uninteresting data (such as an APPn marker).
/// </summary>
/// <param name="num_bytes">The number of bytes to skip.</param>
/// <remarks>Writers of suspendable-input applications must note that skip_input_data
/// is not granted the right to give a suspension return. If the skip extends
/// beyond the data currently in the buffer, the buffer can be marked empty so
/// that the next read will cause a fill_input_buffer call that can suspend.
/// Arranging for additional bytes to be discarded before reloading the input
/// buffer is the application writer's problem.</remarks>
public virtual void skip_input_data(int num_bytes)
{
/* Just a dumb implementation for now. Could use fseek() except
* it doesn't work on pipes. Not clear that being smart is worth
* any trouble anyway --- large skips are infrequent.
*/
if (num_bytes > 0)
{
while (num_bytes > m_bytes_in_buffer)
{
num_bytes -= m_bytes_in_buffer;
fill_input_buffer();
/* note we assume that fill_input_buffer will never return false,
* so suspension need not be handled.
*/
}
m_position += num_bytes;
m_bytes_in_buffer -= num_bytes;
}
}
/// <summary>
/// This is the default resync_to_restart method for data source
/// managers to use if they don't have any better approach.
/// </summary>
/// <param name="cinfo">An instance of <see cref="JpegDecompressor"/></param>
/// <param name="desired">The desired</param>
/// <returns><c>false</c> if suspension is required.</returns>
/// <remarks>That method assumes that no backtracking is possible.
/// Some data source managers may be able to back up, or may have
/// additional knowledge about the data which permits a more
/// intelligent recovery strategy; such managers would
/// presumably supply their own resync method.<br/><br/>
///
/// read_restart_marker calls resync_to_restart if it finds a marker other than
/// the restart marker it was expecting. (This code is *not* used unless
/// a nonzero restart interval has been declared.) cinfo.unread_marker is
/// the marker code actually found (might be anything, except 0 or FF).
/// The desired restart marker number (0..7) is passed as a parameter.<br/><br/>
///
/// This routine is supposed to apply whatever error recovery strategy seems
/// appropriate in order to position the input stream to the next data segment.
/// Note that cinfo.unread_marker is treated as a marker appearing before
/// the current data-source input point; usually it should be reset to zero
/// before returning.<br/><br/>
///
/// This implementation is substantially constrained by wanting to treat the
/// input as a data stream; this means we can't back up. Therefore, we have
/// only the following actions to work with:<br/>
/// 1. Simply discard the marker and let the entropy decoder resume at next
/// byte of file.<br/>
/// 2. Read forward until we find another marker, discarding intervening
/// data. (In theory we could look ahead within the current bufferload,
/// without having to discard data if we don't find the desired marker.
/// This idea is not implemented here, in part because it makes behavior
/// dependent on buffer size and chance buffer-boundary positions.)<br/>
/// 3. Leave the marker unread (by failing to zero cinfo.unread_marker).
/// This will cause the entropy decoder to process an empty data segment,
/// inserting dummy zeroes, and then we will reprocess the marker.<br/>
///
/// #2 is appropriate if we think the desired marker lies ahead, while #3 is
/// appropriate if the found marker is a future restart marker (indicating
/// that we have missed the desired restart marker, probably because it got
/// corrupted).<br/>
/// We apply #2 or #3 if the found marker is a restart marker no more than
/// two counts behind or ahead of the expected one. We also apply #2 if the
/// found marker is not a legal JPEG marker code (it's certainly bogus data).
/// If the found marker is a restart marker more than 2 counts away, we do #1
/// (too much risk that the marker is erroneous; with luck we will be able to
/// resync at some future point).<br/>
/// For any valid non-restart JPEG marker, we apply #3. This keeps us from
/// overrunning the end of a scan. An implementation limited to single-scan
/// files might find it better to apply #2 for markers other than EOI, since
/// any other marker would have to be bogus data in that case.</remarks>
public virtual bool resync_to_restart(JpegDecompressor cinfo, int desired)
{
/* Outer loop handles repeated decision after scanning forward. */
int action = 1;
for (; ; )
{
if (cinfo.m_unread_marker < (int)JpegMarkerType.SOF0)
{
/* invalid marker */
action = 2;
}
else if (cinfo.m_unread_marker < (int)JpegMarkerType.RST0 ||
cinfo.m_unread_marker > (int)JpegMarkerType.RST7)
{
/* valid non-restart marker */
action = 3;
}
else
{
if (cinfo.m_unread_marker == ((int)JpegMarkerType.RST0 + ((desired + 1) & 7))
|| cinfo.m_unread_marker == ((int)JpegMarkerType.RST0 + ((desired + 2) & 7)))
{
/* one of the next two expected restarts */
action = 3;
}
else if (cinfo.m_unread_marker == ((int)JpegMarkerType.RST0 + ((desired - 1) & 7)) ||
cinfo.m_unread_marker == ((int)JpegMarkerType.RST0 + ((desired - 2) & 7)))
{
/* a prior restart, so advance */
action = 2;
}
else
{
/* desired restart or too far away */
action = 1;
}
}
switch (action)
{
case 1:
/* Discard marker and let entropy decoder resume processing. */
cinfo.m_unread_marker = 0;
return true;
case 2:
/* Scan to the next marker, and repeat the decision loop. */
if (!cinfo.m_marker.next_marker())
return false;
break;
case 3:
/* Return without advancing past this marker. */
/* Entropy decoder will be forced to process an empty segment. */
return true;
}
}
}
/// <summary>
/// Terminate source - called by jpeg_finish_decompress
/// after all data has been read. Often a no-op.
/// </summary>
/// <remarks>NB: <b>not</b> called by jpeg_abort or jpeg_destroy; surrounding
/// application must deal with any cleanup that should happen even
/// for error exit.</remarks>
public virtual void term_source()
{
}
/// <summary>
/// Reads two bytes interpreted as an unsigned 16-bit integer.
/// </summary>
/// <param name="V">The result.</param>
/// <returns><c>true</c> if operation succeed; otherwise, <c>false</c></returns>
public virtual bool GetTwoBytes(out int V)
{
if (!MakeByteAvailable())
{
V = 0;
return false;
}
m_bytes_in_buffer--;
V = m_next_input_byte[m_position] << 8;
m_position++;
if (!MakeByteAvailable())
return false;
m_bytes_in_buffer--;
V += m_next_input_byte[m_position];
m_position++;
return true;
}
/// <summary>
/// Read a byte into variable V.
/// If must suspend, take the specified action (typically "return false").
/// </summary>
/// <param name="V">The result.</param>
/// <returns><c>true</c> if operation succeed; otherwise, <c>false</c></returns>
public virtual bool GetByte(out int V)
{
if (!MakeByteAvailable())
{
V = 0;
return false;
}
m_bytes_in_buffer--;
V = m_next_input_byte[m_position];
m_position++;
return true;
}
/// <summary>
/// Gets the bytes.
/// </summary>
/// <param name="dest">The destination.</param>
/// <param name="amount">The amount.</param>
/// <returns>The number of available bytes.</returns>
public virtual int GetBytes(byte[] dest, int amount)
{
int avail = amount;
if (avail > m_bytes_in_buffer)
avail = m_bytes_in_buffer;
for (int i = 0; i < avail; i++)
{
dest[i] = m_next_input_byte[m_position];
m_position++;
m_bytes_in_buffer--;
}
return avail;
}
/// <summary>
/// Functions for fetching data from the data source module.
/// </summary>
/// <returns><c>true</c> if operation succeed; otherwise, <c>false</c></returns>
/// <remarks>At all times, cinfo.src.next_input_byte and .bytes_in_buffer reflect
/// the current restart point; we update them only when we have reached a
/// suitable place to restart if a suspension occurs.</remarks>
public virtual bool MakeByteAvailable()
{
if (m_bytes_in_buffer == 0)
{
if (!fill_input_buffer())
return false;
}
return true;
}
}
#endregion
#region JpegUpsampler
/// <summary>
/// Upsampling (note that upsampler must also call color converter)
/// </summary>
abstract class JpegUpsampler
{
protected bool m_need_context_rows; /* true if need rows above & below */
public abstract void start_pass();
public abstract void upsample(ComponentBuffer[] input_buf, ref int in_row_group_ctr, int in_row_groups_avail, byte[][] output_buf, ref int out_row_ctr, int out_rows_avail);
public bool NeedContextRows()
{
return m_need_context_rows;
}
}
#endregion
#region JpegUtils
class JpegUtils
{
/*
* jpeg_natural_order[i] is the natural-order position of the i'th element
* of zigzag order.
*
* When reading corrupted data, the Huffman decoders could attempt
* to reference an entry beyond the end of this array (if the decoded
* zero run length reaches past the end of the block). To prevent
* wild stores without adding an inner-loop test, we put some extra
* "63"s after the real entries. This will cause the extra coefficient
* to be stored in location 63 of the block, not somewhere random.
* The worst case would be a run-length of 15, which means we need 16
* fake entries.
*/
public static int[] jpeg_natural_order =
{
0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5, 12,
19, 26, 33, 40, 48, 41, 34, 27, 20, 13, 6, 7, 14, 21, 28, 35,
42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51,
58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62,
63, 63, 63, 63, 63, 63, 63, 63, 63,
/* extra entries for safety in decoder */
63, 63, 63, 63, 63, 63, 63, 63
};
/* We assume that right shift corresponds to signed division by 2 with
* rounding towards minus infinity. This is correct for typical "arithmetic
* shift" instructions that shift in copies of the sign bit.
* RIGHT_SHIFT provides a proper signed right shift of an int quantity.
* It is only applied with constant shift counts. SHIFT_TEMPS must be
* included in the variables of any routine using RIGHT_SHIFT.
*/
public static int RIGHT_SHIFT(int x, int shft)
{
return (x >> shft);
}
/* Descale and correctly round an int value that's scaled by N bits.
* We assume RIGHT_SHIFT rounds towards minus infinity, so adding
* the fudge factor is correct for either sign of X.
*/
public static int DESCALE(int x, int n)
{
return RIGHT_SHIFT(x + (1 << (n - 1)), n);
}
//////////////////////////////////////////////////////////////////////////
// Arithmetic utilities
/// <summary>
/// Compute a/b rounded up to next integer, ie, ceil(a/b)
/// Assumes a >= 0, b > 0
/// </summary>
public static int jdiv_round_up(int a, int b)
{
return (a + b - 1) / b;
}
/// <summary>
/// Compute a rounded up to next multiple of b, ie, ceil(a/b)*b
/// Assumes a >= 0, b > 0
/// </summary>
public static int jround_up(int a, int b)
{
a += b - 1;
return a - (a % b);
}
/// <summary>
/// Copy some rows of samples from one place to another.
/// num_rows rows are copied from input_array[source_row++]
/// to output_array[dest_row++]; these areas may overlap for duplication.
/// The source and destination arrays must be at least as wide as num_cols.
/// </summary>
public static void jcopy_sample_rows(ComponentBuffer input_array, int source_row, byte[][] output_array, int dest_row, int num_rows, int num_cols)
{
for (int row = 0; row < num_rows; row++)
Buffer.BlockCopy(input_array[source_row + row], 0, output_array[dest_row + row], 0, num_cols);
}
public static void jcopy_sample_rows(ComponentBuffer input_array, int source_row, ComponentBuffer output_array, int dest_row, int num_rows, int num_cols)
{
for (int row = 0; row < num_rows; row++)
Buffer.BlockCopy(input_array[source_row + row], 0, output_array[dest_row + row], 0, num_cols);
}
public static void jcopy_sample_rows(byte[][] input_array, int source_row, byte[][] output_array, int dest_row, int num_rows, int num_cols)
{
for (int row = 0; row < num_rows; row++)
Buffer.BlockCopy(input_array[source_row++], 0, output_array[dest_row++], 0, num_cols);
}
}
#endregion
#region JpegVirtualArray
/// <summary>
/// JPEG virtual array.
/// </summary>
/// <typeparam name="T">The type of array's elements.</typeparam>
/// <remarks>You can't create virtual array manually. For creation use methods
/// <see cref="JpegCommonBase.CreateSamplesArray"/> and
/// <see cref="JpegCommonBase.CreateBlocksArray"/>.
/// </remarks>
public class JpegVirtualArray<T>
{
internal delegate T[][] Allocator(int width, int height);
private JpegCommonBase m_cinfo;
/// <summary>
/// the in-memory buffer
/// </summary>
private T[][] m_buffer;
/// <summary>
/// Request a virtual 2-D array
/// </summary>
/// <param name="width">Width of array</param>
/// <param name="height">Total virtual array height</param>
/// <param name="allocator">The allocator.</param>
internal JpegVirtualArray(int width, int height, Allocator allocator)
{
m_cinfo = null;
m_buffer = allocator(width, height);
if (m_buffer == null)
throw new Exception("Filling of 'm_buffer' Failed!");
}
/// <summary>
/// Gets or sets the error processor.
/// </summary>
/// <value>The error processor.<br/>
/// Default value: <c>null</c>
/// </value>
/// <remarks>Uses only for calling
/// <see cref="M:BitMiracle.LibJpeg.Classic.JpegCommonBase.ERREXIT(BitMiracle.LibJpeg.Classic.J_MESSAGE_CODE)">JpegCommonBase.ERREXIT</see>
/// on error.</remarks>
public JpegCommonBase ErrorProcessor
{
get { return m_cinfo; }
set { m_cinfo = value; }
}
/// <summary>
/// Access the part of a virtual array.
/// </summary>
/// <param name="startRow">The first row in required block.</param>
/// <param name="numberOfRows">The number of required rows.</param>
/// <returns>The required part of virtual array.</returns>
public T[][] Access(int startRow, int numberOfRows)
{
/* debugging check */
if (startRow + numberOfRows > m_buffer.Length)
{
throw new InvalidOperationException("Bogus virtual array access");
}
/* Return proper part of the buffer */
T[][] ret = new T[numberOfRows][];
for (int i = 0; i < numberOfRows; i++)
ret[i] = m_buffer[startRow + i];
return ret;
}
}
#endregion
#region MergedUpsampler
class MergedUpsampler : JpegUpsampler
{
private const int SCALEBITS = 16; /* speediest right-shift on some machines */
private const int ONE_HALF = 1 << (SCALEBITS - 1);
private JpegDecompressor m_cinfo;
private bool m_use_2v_upsample;
/* Private state for YCC->RGB conversion */
private int[] m_Cr_r_tab; /* => table for Cr to R conversion */
private int[] m_Cb_b_tab; /* => table for Cb to B conversion */
private int[] m_Cr_g_tab; /* => table for Cr to G conversion */
private int[] m_Cb_g_tab; /* => table for Cb to G conversion */
/* For 2:1 vertical sampling, we produce two output rows at a time.
* We need a "spare" row buffer to hold the second output row if the
* application provides just a one-row buffer; we also use the spare
* to discard the dummy last row if the image height is odd.
*/
private byte[] m_spare_row;
private bool m_spare_full; /* T if spare buffer is occupied */
private int m_out_row_width; /* samples per output row */
private int m_rows_to_go; /* counts rows remaining in image */
public MergedUpsampler(JpegDecompressor cinfo)
{
m_cinfo = cinfo;
m_need_context_rows = false;
m_out_row_width = cinfo.m_output_width * cinfo.m_out_color_components;
if (cinfo.m_max_v_samp_factor == 2)
{
m_use_2v_upsample = true;
/* Allocate a spare row buffer */
m_spare_row = new byte[m_out_row_width];
}
else
{
m_use_2v_upsample = false;
}
build_ycc_rgb_table();
}
/// <summary>
/// Initialize for an upsampling pass.
/// </summary>
public override void start_pass()
{
/* Mark the spare buffer empty */
m_spare_full = false;
/* Initialize total-height counter for detecting bottom of image */
m_rows_to_go = m_cinfo.m_output_height;
}
public override void upsample(ComponentBuffer[] input_buf, ref int in_row_group_ctr, int in_row_groups_avail, byte[][] output_buf, ref int out_row_ctr, int out_rows_avail)
{
if (m_use_2v_upsample)
merged_2v_upsample(input_buf, ref in_row_group_ctr, output_buf, ref out_row_ctr, out_rows_avail);
else
merged_1v_upsample(input_buf, ref in_row_group_ctr, output_buf, ref out_row_ctr);
}
/// <summary>
/// Control routine to do upsampling (and color conversion).
/// The control routine just handles the row buffering considerations.
/// 1:1 vertical sampling case: much easier, never need a spare row.
/// </summary>
private void merged_1v_upsample(ComponentBuffer[] input_buf, ref int in_row_group_ctr, byte[][] output_buf, ref int out_row_ctr)
{
/* Just do the upsampling. */
h2v1_merged_upsample(input_buf, in_row_group_ctr, output_buf, out_row_ctr);
/* Adjust counts */
out_row_ctr++;
in_row_group_ctr++;
}
/// <summary>
/// Control routine to do upsampling (and color conversion).
/// The control routine just handles the row buffering considerations.
/// 2:1 vertical sampling case: may need a spare row.
/// </summary>
private void merged_2v_upsample(ComponentBuffer[] input_buf, ref int in_row_group_ctr, byte[][] output_buf, ref int out_row_ctr, int out_rows_avail)
{
int num_rows; /* number of rows returned to caller */
if (m_spare_full)
{
/* If we have a spare row saved from a previous cycle, just return it. */
byte[][] temp = new byte[1][];
temp[0] = m_spare_row;
JpegUtils.jcopy_sample_rows(temp, 0, output_buf, out_row_ctr, 1, m_out_row_width);
num_rows = 1;
m_spare_full = false;
}
else
{
/* Figure number of rows to return to caller. */
num_rows = 2;
/* Not more than the distance to the end of the image. */
if (num_rows > m_rows_to_go)
num_rows = m_rows_to_go;
/* And not more than what the client can accept: */
out_rows_avail -= out_row_ctr;
if (num_rows > out_rows_avail)
num_rows = out_rows_avail;
/* Create output pointer array for upsampler. */
byte[][] work_ptrs = new byte[2][];
work_ptrs[0] = output_buf[out_row_ctr];
if (num_rows > 1)
{
work_ptrs[1] = output_buf[out_row_ctr + 1];
}
else
{
work_ptrs[1] = m_spare_row;
m_spare_full = true;
}
/* Now do the upsampling. */
h2v2_merged_upsample(input_buf, in_row_group_ctr, work_ptrs);
}
/* Adjust counts */
out_row_ctr += num_rows;
m_rows_to_go -= num_rows;
/* When the buffer is emptied, declare this input row group consumed */
if (!m_spare_full)
in_row_group_ctr++;
}
/*
* These are the routines invoked by the control routines to do
* the actual upsampling/conversion. One row group is processed per call.
*
* Note: since we may be writing directly into application-supplied buffers,
* we have to be honest about the output width; we can't assume the buffer
* has been rounded up to an even width.
*/
/// <summary>
/// Upsample and color convert for the case of 2:1 horizontal and 1:1 vertical.
/// </summary>
private void h2v1_merged_upsample(ComponentBuffer[] input_buf, int in_row_group_ctr, byte[][] output_buf, int outRow)
{
int inputIndex0 = 0;
int inputIndex1 = 0;
int inputIndex2 = 0;
int outputIndex = 0;
byte[] limit = m_cinfo.m_sample_range_limit;
int limitOffset = m_cinfo.m_sampleRangeLimitOffset;
/* Loop for each pair of output pixels */
for (int col = m_cinfo.m_output_width >> 1; col > 0; col--)
{
/* Do the chroma part of the calculation */
int cb = input_buf[1][in_row_group_ctr][inputIndex1];
inputIndex1++;
int cr = input_buf[2][in_row_group_ctr][inputIndex2];
inputIndex2++;
int cred = m_Cr_r_tab[cr];
int cgreen = JpegUtils.RIGHT_SHIFT(m_Cb_g_tab[cb] + m_Cr_g_tab[cr], SCALEBITS);
int cblue = m_Cb_b_tab[cb];
/* Fetch 2 Y values and emit 2 pixels */
int y = input_buf[0][in_row_group_ctr][inputIndex0];
inputIndex0++;
output_buf[outRow][outputIndex + JpegConstants.Offset_RGB_Red] = limit[limitOffset + y + cred];
output_buf[outRow][outputIndex + JpegConstants.Offset_RGB_Green] = limit[limitOffset + y + cgreen];
output_buf[outRow][outputIndex + JpegConstants.Offset_RGB_Blue] = limit[limitOffset + y + cblue];
outputIndex += JpegConstants.RGB_PixelLength;
y = input_buf[0][in_row_group_ctr][inputIndex0];
inputIndex0++;
output_buf[outRow][outputIndex + JpegConstants.Offset_RGB_Red] = limit[limitOffset + y + cred];
output_buf[outRow][outputIndex + JpegConstants.Offset_RGB_Green] = limit[limitOffset + y + cgreen];
output_buf[outRow][outputIndex + JpegConstants.Offset_RGB_Blue] = limit[limitOffset + y + cblue];
outputIndex += JpegConstants.RGB_PixelLength;
}
/* If image width is odd, do the last output column separately */
if ((m_cinfo.m_output_width & 1) != 0)
{
int cb = input_buf[1][in_row_group_ctr][inputIndex1];
int cr = input_buf[2][in_row_group_ctr][inputIndex2];
int cred = m_Cr_r_tab[cr];
int cgreen = JpegUtils.RIGHT_SHIFT(m_Cb_g_tab[cb] + m_Cr_g_tab[cr], SCALEBITS);
int cblue = m_Cb_b_tab[cb];
int y = input_buf[0][in_row_group_ctr][inputIndex0];
output_buf[outRow][outputIndex + JpegConstants.Offset_RGB_Red] = limit[limitOffset + y + cred];
output_buf[outRow][outputIndex + JpegConstants.Offset_RGB_Green] = limit[limitOffset + y + cgreen];
output_buf[outRow][outputIndex + JpegConstants.Offset_RGB_Blue] = limit[limitOffset + y + cblue];
}
}
/// <summary>
/// Upsample and color convert for the case of 2:1 horizontal and 2:1 vertical.
/// </summary>
private void h2v2_merged_upsample(ComponentBuffer[] input_buf, int in_row_group_ctr, byte[][] output_buf)
{
int inputRow00 = in_row_group_ctr * 2;
int inputIndex00 = 0;
int inputRow01 = in_row_group_ctr * 2 + 1;
int inputIndex01 = 0;
int inputIndex1 = 0;
int inputIndex2 = 0;
int outIndex0 = 0;
int outIndex1 = 0;
byte[] limit = m_cinfo.m_sample_range_limit;
int limitOffset = m_cinfo.m_sampleRangeLimitOffset;
/* Loop for each group of output pixels */
for (int col = m_cinfo.m_output_width >> 1; col > 0; col--)
{
/* Do the chroma part of the calculation */
int cb = input_buf[1][in_row_group_ctr][inputIndex1];
inputIndex1++;
int cr = input_buf[2][in_row_group_ctr][inputIndex2];
inputIndex2++;
int cred = m_Cr_r_tab[cr];
int cgreen = JpegUtils.RIGHT_SHIFT(m_Cb_g_tab[cb] + m_Cr_g_tab[cr], SCALEBITS);
int cblue = m_Cb_b_tab[cb];
/* Fetch 4 Y values and emit 4 pixels */
int y = input_buf[0][inputRow00][inputIndex00];
inputIndex00++;
output_buf[0][outIndex0 + JpegConstants.Offset_RGB_Red] = limit[limitOffset + y + cred];
output_buf[0][outIndex0 + JpegConstants.Offset_RGB_Green] = limit[limitOffset + y + cgreen];
output_buf[0][outIndex0 + JpegConstants.Offset_RGB_Blue] = limit[limitOffset + y + cblue];
outIndex0 += JpegConstants.RGB_PixelLength;
y = input_buf[0][inputRow00][inputIndex00];
inputIndex00++;
output_buf[0][outIndex0 + JpegConstants.Offset_RGB_Red] = limit[limitOffset + y + cred];
output_buf[0][outIndex0 + JpegConstants.Offset_RGB_Green] = limit[limitOffset + y + cgreen];
output_buf[0][outIndex0 + JpegConstants.Offset_RGB_Blue] = limit[limitOffset + y + cblue];
outIndex0 += JpegConstants.RGB_PixelLength;
y = input_buf[0][inputRow01][inputIndex01];
inputIndex01++;
output_buf[1][outIndex1 + JpegConstants.Offset_RGB_Red] = limit[limitOffset + y + cred];
output_buf[1][outIndex1 + JpegConstants.Offset_RGB_Green] = limit[limitOffset + y + cgreen];
output_buf[1][outIndex1 + JpegConstants.Offset_RGB_Blue] = limit[limitOffset + y + cblue];
outIndex1 += JpegConstants.RGB_PixelLength;
y = input_buf[0][inputRow01][inputIndex01];
inputIndex01++;
output_buf[1][outIndex1 + JpegConstants.Offset_RGB_Red] = limit[limitOffset + y + cred];
output_buf[1][outIndex1 + JpegConstants.Offset_RGB_Green] = limit[limitOffset + y + cgreen];
output_buf[1][outIndex1 + JpegConstants.Offset_RGB_Blue] = limit[limitOffset + y + cblue];
outIndex1 += JpegConstants.RGB_PixelLength;
}
/* If image width is odd, do the last output column separately */
if ((m_cinfo.m_output_width & 1) != 0)
{
int cb = input_buf[1][in_row_group_ctr][inputIndex1];
int cr = input_buf[2][in_row_group_ctr][inputIndex2];
int cred = m_Cr_r_tab[cr];
int cgreen = JpegUtils.RIGHT_SHIFT(m_Cb_g_tab[cb] + m_Cr_g_tab[cr], SCALEBITS);
int cblue = m_Cb_b_tab[cb];
int y = input_buf[0][inputRow00][inputIndex00];
output_buf[0][outIndex0 + JpegConstants.Offset_RGB_Red] = limit[limitOffset + y + cred];
output_buf[0][outIndex0 + JpegConstants.Offset_RGB_Green] = limit[limitOffset + y + cgreen];
output_buf[0][outIndex0 + JpegConstants.Offset_RGB_Blue] = limit[limitOffset + y + cblue];
y = input_buf[0][inputRow01][inputIndex01];
output_buf[1][outIndex1 + JpegConstants.Offset_RGB_Red] = limit[limitOffset + y + cred];
output_buf[1][outIndex1 + JpegConstants.Offset_RGB_Green] = limit[limitOffset + y + cgreen];
output_buf[1][outIndex1 + JpegConstants.Offset_RGB_Blue] = limit[limitOffset + y + cblue];
}
}
/// <summary>
/// Initialize tables for YCC->RGB colorspace conversion.
/// This is taken directly from ColorDeconverter; see that file for more info.
/// </summary>
private void build_ycc_rgb_table()
{
m_Cr_r_tab = new int[JpegConstants.MaxSampleValue + 1];
m_Cb_b_tab = new int[JpegConstants.MaxSampleValue + 1];
m_Cr_g_tab = new int[JpegConstants.MaxSampleValue + 1];
m_Cb_g_tab = new int[JpegConstants.MaxSampleValue + 1];
for (int i = 0, x = -JpegConstants.MediumSampleValue; i <= JpegConstants.MaxSampleValue; i++, x++)
{
/* i is the actual input pixel value, in the range 0..MaxSampleValue */
/* The Cb or Cr value we are thinking of is x = i - MediumSampleValue */
/* Cr=>R value is nearest int to 1.40200 * x */
m_Cr_r_tab[i] = JpegUtils.RIGHT_SHIFT(FIX(1.40200) * x + ONE_HALF, SCALEBITS);
/* Cb=>B value is nearest int to 1.77200 * x */
m_Cb_b_tab[i] = JpegUtils.RIGHT_SHIFT(FIX(1.77200) * x + ONE_HALF, SCALEBITS);
/* Cr=>G value is scaled-up -0.71414 * x */
m_Cr_g_tab[i] = (-FIX(0.71414)) * x;
/* Cb=>G value is scaled-up -0.34414 * x */
/* We also add in ONE_HALF so that need not do it in inner loop */
m_Cb_g_tab[i] = (-FIX(0.34414)) * x + ONE_HALF;
}
}
private static int FIX(double x)
{
return ((int)((x) * (1L << SCALEBITS) + 0.5));
}
}
#endregion
#region Pass1ColorQuantizer
/// <summary>
/// The main purpose of 1-pass quantization is to provide a fast, if not very
/// high quality, colormapped output capability. A 2-pass quantizer usually
/// gives better visual quality; however, for quantized grayscale output this
/// quantizer is perfectly adequate. Dithering is highly recommended with this
/// quantizer, though you can turn it off if you really want to.
///
/// In 1-pass quantization the colormap must be chosen in advance of seeing the
/// image. We use a map consisting of all combinations of Ncolors[i] color
/// values for the i'th component. The Ncolors[] values are chosen so that
/// their product, the total number of colors, is no more than that requested.
/// (In most cases, the product will be somewhat less.)
///
/// Since the colormap is orthogonal, the representative value for each color
/// component can be determined without considering the other components;
/// then these indexes can be combined into a colormap index by a standard
/// N-dimensional-array-subscript calculation. Most of the arithmetic involved
/// can be precalculated and stored in the lookup table colorindex[].
/// colorindex[i][j] maps pixel value j in component i to the nearest
/// representative value (grid plane) for that component; this index is
/// multiplied by the array stride for component i, so that the
/// index of the colormap entry closest to a given pixel value is just
/// sum( colorindex[component-number][pixel-component-value] )
/// Aside from being fast, this scheme allows for variable spacing between
/// representative values with no additional lookup cost.
///
/// If gamma correction has been applied in color conversion, it might be wise
/// to adjust the color grid spacing so that the representative colors are
/// equidistant in linear space. At this writing, gamma correction is not
/// implemented, so nothing is done here.
///
///
/// Declarations for Floyd-Steinberg dithering.
///
/// Errors are accumulated into the array fserrors[], at a resolution of
/// 1/16th of a pixel count. The error at a given pixel is propagated
/// to its not-yet-processed neighbors using the standard F-S fractions,
/// ... (here) 7/16
/// 3/16 5/16 1/16
/// We work left-to-right on even rows, right-to-left on odd rows.
///
/// We can get away with a single array (holding one row's worth of errors)
/// by using it to store the current row's errors at pixel columns not yet
/// processed, but the next row's errors at columns already processed. We
/// need only a few extra variables to hold the errors immediately around the
/// current column. (If we are lucky, those variables are in registers, but
/// even if not, they're probably cheaper to access than array elements are.)
///
/// The fserrors[] array is indexed [component#][position].
/// We provide (#columns + 2) entries per component; the extra entry at each
/// end saves us from special-casing the first and last pixels.
///
///
/// Declarations for ordered dithering.
///
/// We use a standard 16x16 ordered dither array. The basic concept of ordered
/// dithering is described in many references, for instance Dale Schumacher's
/// chapter II.2 of Graphics Gems II (James Arvo, ed. Academic Press, 1991).
/// In place of Schumacher's comparisons against a "threshold" value, we add a
/// "dither" value to the input pixel and then round the result to the nearest
/// output value. The dither value is equivalent to (0.5 - threshold) times
/// the distance between output values. For ordered dithering, we assume that
/// the output colors are equally spaced; if not, results will probably be
/// worse, since the dither may be too much or too little at a given point.
///
/// The normal calculation would be to form pixel value + dither, range-limit
/// this to 0..MaxSampleValue, and then index into the colorindex table as usual.
/// We can skip the separate range-limiting step by extending the colorindex
/// table in both directions.
/// </summary>
class Pass1ColorQuantizer : ColorQuantizer
{
private enum QuantizerType
{
color_quantizer3,
color_quantizer,
quantize3_ord_dither_quantizer,
quantize_ord_dither_quantizer,
quantize_fs_dither_quantizer
}
private static int[] RGB_order = { JpegConstants.Offset_RGB_Green, JpegConstants.Offset_RGB_Red, JpegConstants.Offset_RGB_Blue };
private const int MAX_Q_COMPS = 4; /* max components I can handle */
private const int ODITHER_SIZE = 16; /* dimension of dither matrix */
/* NB: if ODITHER_SIZE is not a power of 2, ODITHER_MASK uses will break */
private const int ODITHER_CELLS = (ODITHER_SIZE * ODITHER_SIZE); /* # cells in matrix */
private const int ODITHER_MASK = (ODITHER_SIZE - 1); /* mask for wrapping around counters */
/* Bayer's order-4 dither array. Generated by the code given in
* Stephen Hawley's article "Ordered Dithering" in Graphics Gems I.
* The values in this array must range from 0 to ODITHER_CELLS-1.
*/
private static byte[][] base_dither_matrix = new byte[][]
{
new byte[] { 0,192, 48,240, 12,204, 60,252, 3,195, 51,243, 15,207, 63,255 },
new byte[] { 128, 64,176,112,140, 76,188,124,131, 67,179,115,143, 79,191,127 },
new byte[] { 32,224, 16,208, 44,236, 28,220, 35,227, 19,211, 47,239, 31,223 },
new byte[] { 160, 96,144, 80,172,108,156, 92,163, 99,147, 83,175,111,159, 95 },
new byte[] { 8,200, 56,248, 4,196, 52,244, 11,203, 59,251, 7,199, 55,247 },
new byte[] { 136, 72,184,120,132, 68,180,116,139, 75,187,123,135, 71,183,119 },
new byte[] { 40,232, 24,216, 36,228, 20,212, 43,235, 27,219, 39,231, 23,215 },
new byte[] { 168,104,152, 88,164,100,148, 84,171,107,155, 91,167,103,151, 87 },
new byte[] { 2,194, 50,242, 14,206, 62,254, 1,193, 49,241, 13,205, 61,253 },
new byte[] { 130, 66,178,114,142, 78,190,126,129, 65,177,113,141, 77,189,125 },
new byte[] { 34,226, 18,210, 46,238, 30,222, 33,225, 17,209, 45,237, 29,221 },
new byte[] { 162, 98,146, 82,174,110,158, 94,161, 97,145, 81,173,109,157, 93 },
new byte[] { 10,202, 58,250, 6,198, 54,246, 9,201, 57,249, 5,197, 53,245 },
new byte[] { 138, 74,186,122,134, 70,182,118,137, 73,185,121,133, 69,181,117 },
new byte[] { 42,234, 26,218, 38,230, 22,214, 41,233, 25,217, 37,229, 21,213 },
new byte[] { 170,106,154, 90,166,102,150, 86,169,105,153, 89,165,101,149, 85 }
};
private QuantizerType m_quantizer;
private JpegDecompressor m_cinfo;
/* Initially allocated colormap is saved here */
private byte[][] m_sv_colormap; /* The color map as a 2-D pixel array */
private int m_sv_actual; /* number of entries in use */
private byte[][] m_colorindex; /* Precomputed mapping for speed */
private int[] m_colorindexOffset;
/* colorindex[i][j] = index of color closest to pixel value j in component i,
* premultiplied as described above. Since colormap indexes must fit into
* bytes, the entries of this array will too.
*/
private bool m_is_padded; /* is the colorindex padded for odither? */
private int[] m_Ncolors = new int[MAX_Q_COMPS]; /* # of values alloced to each component */
/* Variables for ordered dithering */
private int m_row_index; /* cur row's vertical index in dither matrix */
private int[][][] m_odither = new int[MAX_Q_COMPS][][]; /* one dither array per component */
/* Variables for Floyd-Steinberg dithering */
private short[][] m_fserrors = new short[MAX_Q_COMPS][]; /* accumulated errors */
private bool m_on_odd_row; /* flag to remember which row we are on */
/// <summary>
/// Module initialization routine for 1-pass color quantization.
/// </summary>
/// <param name="cinfo">The cinfo.</param>
public Pass1ColorQuantizer(JpegDecompressor cinfo)
{
m_cinfo = cinfo;
m_fserrors[0] = null; /* Flag FS workspace not allocated */
m_odither[0] = null; /* Also flag odither arrays not allocated */
/* Make sure my internal arrays won't overflow */
if (cinfo.m_out_color_components > MAX_Q_COMPS)
throw new Exception(String.Format("Cannot quantize more than {0} color components", MAX_Q_COMPS));
/* Make sure colormap indexes can be represented by JSAMPLEs */
if (cinfo.m_desired_number_of_colors > (JpegConstants.MaxSampleValue + 1))
throw new Exception(String.Format("Cannot quantize to more than {0} colors", JpegConstants.MaxSampleValue + 1));
/* Create the colormap and color index table. */
create_colormap();
create_colorindex();
/* Allocate Floyd-Steinberg workspace now if requested.
* We do this now since it is FAR storage and may affect the memory
* manager's space calculations. If the user changes to FS dither
* mode in a later pass, we will allocate the space then, and will
* possibly overrun the max_memory_to_use setting.
*/
if (cinfo.m_dither_mode == DitherMode.FloydStein)
alloc_fs_workspace();
}
/// <summary>
/// Initialize for one-pass color quantization.
/// </summary>
public virtual void start_pass(bool is_pre_scan)
{
/* Install my colormap. */
m_cinfo.m_colormap = m_sv_colormap;
m_cinfo.m_actual_number_of_colors = m_sv_actual;
/* Initialize for desired dithering mode. */
switch (m_cinfo.m_dither_mode)
{
case DitherMode.None:
if (m_cinfo.m_out_color_components == 3)
m_quantizer = QuantizerType.color_quantizer3;
else
m_quantizer = QuantizerType.color_quantizer;
break;
case DitherMode.Ordered:
if (m_cinfo.m_out_color_components == 3)
m_quantizer = QuantizerType.quantize3_ord_dither_quantizer;
else
m_quantizer = QuantizerType.quantize3_ord_dither_quantizer;
/* initialize state for ordered dither */
m_row_index = 0;
/* If user changed to ordered dither from another mode,
* we must recreate the color index table with padding.
* This will cost extra space, but probably isn't very likely.
*/
if (!m_is_padded)
create_colorindex();
/* Create ordered-dither tables if we didn't already. */
if (m_odither[0] == null)
create_odither_tables();
break;
case DitherMode.FloydStein:
m_quantizer = QuantizerType.quantize_fs_dither_quantizer;
/* initialize state for F-S dither */
m_on_odd_row = false;
/* Allocate Floyd-Steinberg workspace if didn't already. */
if (m_fserrors[0] == null)
alloc_fs_workspace();
/* Initialize the propagated errors to zero. */
int arraysize = m_cinfo.m_output_width + 2;
for (int i = 0; i < m_cinfo.m_out_color_components; i++)
Array.Clear(m_fserrors[i], 0, arraysize);
break;
default:
throw new Exception("Unknown Dither Mode");
}
}
public virtual void color_quantize(byte[][] input_buf, int in_row, byte[][] output_buf, int out_row, int num_rows)
{
switch (m_quantizer)
{
case QuantizerType.color_quantizer3:
quantize3(input_buf, in_row, output_buf, out_row, num_rows);
break;
case QuantizerType.color_quantizer:
quantize(input_buf, in_row, output_buf, out_row, num_rows);
break;
case QuantizerType.quantize3_ord_dither_quantizer:
quantize3_ord_dither(input_buf, in_row, output_buf, out_row, num_rows);
break;
case QuantizerType.quantize_ord_dither_quantizer:
quantize_ord_dither(input_buf, in_row, output_buf, out_row, num_rows);
break;
case QuantizerType.quantize_fs_dither_quantizer:
quantize_fs_dither(input_buf, in_row, output_buf, out_row, num_rows);
break;
default:
throw new Exception("Not implemented yet");
}
}
/// <summary>
/// Finish up at the end of the pass.
/// </summary>
public virtual void finish_pass()
{
/* no work in 1-pass case */
}
/// <summary>
/// Switch to a new external colormap between output passes.
/// Shouldn't get to this!
/// </summary>
public virtual void new_color_map()
{
throw new Exception("Invalid mode change during color quantization");
}
/// <summary>
/// Map some rows of pixels to the output colormapped representation.
/// General case, no dithering.
/// </summary>
private void quantize(byte[][] input_buf, int in_row, byte[][] output_buf, int out_row, int num_rows)
{
int nc = m_cinfo.m_out_color_components;
for (int row = 0; row < num_rows; row++)
{
int inIndex = 0;
int inRow = in_row + row;
int outIndex = 0;
int outRow = out_row + row;
for (int col = m_cinfo.m_output_width; col > 0; col--)
{
int pixcode = 0;
for (int ci = 0; ci < nc; ci++)
{
pixcode += m_colorindex[ci][m_colorindexOffset[ci] + input_buf[inRow][inIndex]];
inIndex++;
}
output_buf[outRow][outIndex] = (byte)pixcode;
outIndex++;
}
}
}
/// <summary>
/// Map some rows of pixels to the output colormapped representation.
/// Fast path for out_color_components==3, no dithering
/// </summary>
private void quantize3(byte[][] input_buf, int in_row, byte[][] output_buf, int out_row, int num_rows)
{
int width = m_cinfo.m_output_width;
for (int row = 0; row < num_rows; row++)
{
int inIndex = 0;
int inRow = in_row + row;
int outIndex = 0;
int outRow = out_row + row;
for (int col = width; col > 0; col--)
{
int pixcode = m_colorindex[0][m_colorindexOffset[0] + input_buf[inRow][inIndex]];
inIndex++;
pixcode += m_colorindex[1][m_colorindexOffset[1] + input_buf[inRow][inIndex]];
inIndex++;
pixcode += m_colorindex[2][m_colorindexOffset[2] + input_buf[inRow][inIndex]];
inIndex++;
output_buf[outRow][outIndex] = (byte)pixcode;
outIndex++;
}
}
}
/// <summary>
/// Map some rows of pixels to the output colormapped representation.
/// General case, with ordered dithering.
/// </summary>
private void quantize_ord_dither(byte[][] input_buf, int in_row, byte[][] output_buf, int out_row, int num_rows)
{
int nc = m_cinfo.m_out_color_components;
int width = m_cinfo.m_output_width;
for (int row = 0; row < num_rows; row++)
{
/* Initialize output values to 0 so can process components separately */
Array.Clear(output_buf[out_row + row], 0, width);
int row_index = m_row_index;
for (int ci = 0; ci < nc; ci++)
{
int inputIndex = ci;
int outIndex = 0;
int outRow = out_row + row;
int col_index = 0;
for (int col = width; col > 0; col--)
{
/* Form pixel value + dither, range-limit to 0..MaxSampleValue,
* select output value, accumulate into output code for this pixel.
* Range-limiting need not be done explicitly, as we have extended
* the colorindex table to produce the right answers for out-of-range
* inputs. The maximum dither is +- MaxSampleValue; this sets the
* required amount of padding.
*/
output_buf[outRow][outIndex] += m_colorindex[ci][m_colorindexOffset[ci] + input_buf[in_row + row][inputIndex] + m_odither[ci][row_index][col_index]];
inputIndex += nc;
outIndex++;
col_index = (col_index + 1) & ODITHER_MASK;
}
}
/* Advance row index for next row */
row_index = (row_index + 1) & ODITHER_MASK;
m_row_index = row_index;
}
}
/// <summary>
/// Map some rows of pixels to the output colormapped representation.
/// Fast path for out_color_components==3, with ordered dithering
/// </summary>
private void quantize3_ord_dither(byte[][] input_buf, int in_row, byte[][] output_buf, int out_row, int num_rows)
{
int width = m_cinfo.m_output_width;
for (int row = 0; row < num_rows; row++)
{
int row_index = m_row_index;
int inRow = in_row + row;
int inIndex = 0;
int outIndex = 0;
int outRow = out_row + row;
int col_index = 0;
for (int col = width; col > 0; col--)
{
int pixcode = m_colorindex[0][m_colorindexOffset[0] + input_buf[inRow][inIndex] + m_odither[0][row_index][col_index]];
inIndex++;
pixcode += m_colorindex[1][m_colorindexOffset[1] + input_buf[inRow][inIndex] + m_odither[1][row_index][col_index]];
inIndex++;
pixcode += m_colorindex[2][m_colorindexOffset[2] + input_buf[inRow][inIndex] + m_odither[2][row_index][col_index]];
inIndex++;
output_buf[outRow][outIndex] = (byte)pixcode;
outIndex++;
col_index = (col_index + 1) & ODITHER_MASK;
}
row_index = (row_index + 1) & ODITHER_MASK;
m_row_index = row_index;
}
}
/// <summary>
/// Map some rows of pixels to the output colormapped representation.
/// General case, with Floyd-Steinberg dithering
/// </summary>
private void quantize_fs_dither(byte[][] input_buf, int in_row, byte[][] output_buf, int out_row, int num_rows)
{
int nc = m_cinfo.m_out_color_components;
int width = m_cinfo.m_output_width;
byte[] limit = m_cinfo.m_sample_range_limit;
int limitOffset = m_cinfo.m_sampleRangeLimitOffset;
for (int row = 0; row < num_rows; row++)
{
/* Initialize output values to 0 so can process components separately */
Array.Clear(output_buf[out_row + row], 0, width);
for (int ci = 0; ci < nc; ci++)
{
int inRow = in_row + row;
int inIndex = ci;
int outIndex = 0;
int outRow = out_row + row;
int errorIndex = 0;
int dir; /* 1 for left-to-right, -1 for right-to-left */
if (m_on_odd_row)
{
/* work right to left in this row */
inIndex += (width - 1) * nc; /* so point to rightmost pixel */
outIndex += width - 1;
dir = -1;
errorIndex = width + 1; /* => entry after last column */
}
else
{
/* work left to right in this row */
dir = 1;
errorIndex = 0; /* => entry before first column */
}
int dirnc = dir * nc;
/* Preset error values: no error propagated to first pixel from left */
int cur = 0;
/* and no error propagated to row below yet */
int belowerr = 0;
int bpreverr = 0;
for (int col = width; col > 0; col--)
{
/* cur holds the error propagated from the previous pixel on the
* current line. Add the error propagated from the previous line
* to form the complete error correction term for this pixel, and
* round the error term (which is expressed * 16) to an integer.
* RIGHT_SHIFT rounds towards minus infinity, so adding 8 is correct
* for either sign of the error value.
* Note: errorIndex is for *previous* column's array entry.
*/
cur = JpegUtils.RIGHT_SHIFT(cur + m_fserrors[ci][errorIndex + dir] + 8, 4);
/* Form pixel value + error, and range-limit to 0..MaxSampleValue.
* The maximum error is +- MaxSampleValue; this sets the required size
* of the range_limit array.
*/
cur += input_buf[inRow][inIndex];
cur = limit[limitOffset + cur];
/* Select output value, accumulate into output code for this pixel */
int pixcode = m_colorindex[ci][m_colorindexOffset[ci] + cur];
output_buf[outRow][outIndex] += (byte)pixcode;
/* Compute actual representation error at this pixel */
/* Note: we can do this even though we don't have the final */
/* pixel code, because the colormap is orthogonal. */
cur -= m_sv_colormap[ci][pixcode];
/* Compute error fractions to be propagated to adjacent pixels.
* Add these into the running sums, and simultaneously shift the
* next-line error sums left by 1 column.
*/
int bnexterr = cur;
int delta = cur * 2;
cur += delta; /* form error * 3 */
m_fserrors[ci][errorIndex + 0] = (short)(bpreverr + cur);
cur += delta; /* form error * 5 */
bpreverr = belowerr + cur;
belowerr = bnexterr;
cur += delta; /* form error * 7 */
/* At this point cur contains the 7/16 error value to be propagated
* to the next pixel on the current line, and all the errors for the
* next line have been shifted over. We are therefore ready to move on.
*/
inIndex += dirnc; /* advance input to next column */
outIndex += dir; /* advance output to next column */
errorIndex += dir; /* advance errorIndex to current column */
}
/* Post-loop cleanup: we must unload the final error value into the
* final fserrors[] entry. Note we need not unload belowerr because
* it is for the dummy column before or after the actual array.
*/
m_fserrors[ci][errorIndex + 0] = (short)bpreverr; /* unload prev err into array */
}
m_on_odd_row = (m_on_odd_row ? false : true);
}
}
/// <summary>
/// Create the colormap.
/// </summary>
private void create_colormap()
{
/* Select number of colors for each component */
int total_colors = select_ncolors(m_Ncolors);
/* Allocate and fill in the colormap. */
/* The colors are ordered in the map in standard row-major order, */
/* i.e. rightmost (highest-indexed) color changes most rapidly. */
byte[][] colormap = JpegCommonBase.AllocJpegSamples(total_colors, m_cinfo.m_out_color_components);
/* blksize is number of adjacent repeated entries for a component */
/* blkdist is distance between groups of identical entries for a component */
int blkdist = total_colors;
for (int i = 0; i < m_cinfo.m_out_color_components; i++)
{
/* fill in colormap entries for i'th color component */
int nci = m_Ncolors[i]; /* # of distinct values for this color */
int blksize = blkdist / nci;
for (int j = 0; j < nci; j++)
{
/* Compute j'th output value (out of nci) for component */
int val = output_value(j, nci - 1);
/* Fill in all colormap entries that have this value of this component */
for (int ptr = j * blksize; ptr < total_colors; ptr += blkdist)
{
/* fill in blksize entries beginning at ptr */
for (int k = 0; k < blksize; k++)
colormap[i][ptr + k] = (byte)val;
}
}
/* blksize of this color is blkdist of next */
blkdist = blksize;
}
/* Save the colormap in private storage,
* where it will survive color quantization mode changes.
*/
m_sv_colormap = colormap;
m_sv_actual = total_colors;
}
/// <summary>
/// Create the color index table.
/// </summary>
private void create_colorindex()
{
/* For ordered dither, we pad the color index tables by MaxSampleValue in
* each direction (input index values can be -MaxSampleValue .. 2*MaxSampleValue).
* This is not necessary in the other dithering modes. However, we
* flag whether it was done in case user changes dithering mode.
*/
int pad;
if (m_cinfo.m_dither_mode == DitherMode.Ordered)
{
pad = JpegConstants.MaxSampleValue * 2;
m_is_padded = true;
}
else
{
pad = 0;
m_is_padded = false;
}
m_colorindex = JpegCommonBase.AllocJpegSamples(JpegConstants.MaxSampleValue + 1 + pad, m_cinfo.m_out_color_components);
m_colorindexOffset = new int[m_cinfo.m_out_color_components];
/* blksize is number of adjacent repeated entries for a component */
int blksize = m_sv_actual;
for (int i = 0; i < m_cinfo.m_out_color_components; i++)
{
/* fill in colorindex entries for i'th color component */
int nci = m_Ncolors[i]; /* # of distinct values for this color */
blksize = blksize / nci;
/* adjust colorindex pointers to provide padding at negative indexes. */
if (pad != 0)
m_colorindexOffset[i] += JpegConstants.MaxSampleValue;
/* in loop, val = index of current output value, */
/* and k = largest j that maps to current val */
int val = 0;
int k = largest_input_value(0, nci - 1);
for (int j = 0; j <= JpegConstants.MaxSampleValue; j++)
{
while (j > k)
{
/* advance val if past boundary */
k = largest_input_value(++val, nci - 1);
}
/* premultiply so that no multiplication needed in main processing */
m_colorindex[i][m_colorindexOffset[i] + j] = (byte)(val * blksize);
}
/* Pad at both ends if necessary */
if (pad != 0)
{
for (int j = 1; j <= JpegConstants.MaxSampleValue; j++)
{
m_colorindex[i][m_colorindexOffset[i] + -j] = m_colorindex[i][m_colorindexOffset[i]];
m_colorindex[i][m_colorindexOffset[i] + JpegConstants.MaxSampleValue + j] = m_colorindex[i][m_colorindexOffset[i] + JpegConstants.MaxSampleValue];
}
}
}
}
/// <summary>
/// Create the ordered-dither tables.
/// Components having the same number of representative colors may
/// share a dither table.
/// </summary>
private void create_odither_tables()
{
for (int i = 0; i < m_cinfo.m_out_color_components; i++)
{
int nci = m_Ncolors[i]; /* # of distinct values for this color */
/* search for matching prior component */
int foundPos = -1;
for (int j = 0; j < i; j++)
{
if (nci == m_Ncolors[j])
{
foundPos = j;
break;
}
}
if (foundPos == -1)
{
/* need a new table? */
m_odither[i] = make_odither_array(nci);
}
else
m_odither[i] = m_odither[foundPos];
}
}
/// <summary>
/// Allocate workspace for Floyd-Steinberg errors.
/// </summary>
private void alloc_fs_workspace()
{
for (int i = 0; i < m_cinfo.m_out_color_components; i++)
m_fserrors[i] = new short[m_cinfo.m_output_width + 2];
}
/*
* Policy-making subroutines for create_colormap and create_colorindex.
* These routines determine the colormap to be used. The rest of the module
* only assumes that the colormap is orthogonal.
*
* * select_ncolors decides how to divvy up the available colors
* among the components.
* * output_value defines the set of representative values for a component.
* * largest_input_value defines the mapping from input values to
* representative values for a component.
* Note that the latter two routines may impose different policies for
* different components, though this is not currently done.
*/
/// <summary>
/// Return largest input value that should map to j'th output value
/// Must have largest(j=0) >= 0, and largest(j=maxj) >= MaxSampleValue
/// </summary>
private static int largest_input_value(int j, int maxj)
{
/* Breakpoints are halfway between values returned by output_value */
return (int)(((2 * j + 1) * JpegConstants.MaxSampleValue + maxj) / (2 * maxj));
}
/// <summary>
/// Return j'th output value, where j will range from 0 to maxj
/// The output values must fall in 0..MaxSampleValue in increasing order
/// </summary>
private static int output_value(int j, int maxj)
{
/* We always provide values 0 and MaxSampleValue for each component;
* any additional values are equally spaced between these limits.
* (Forcing the upper and lower values to the limits ensures that
* dithering can't produce a color outside the selected gamut.)
*/
return (int)((j * JpegConstants.MaxSampleValue + maxj / 2) / maxj);
}
/// <summary>
/// Determine allocation of desired colors to components,
/// and fill in Ncolors[] array to indicate choice.
/// Return value is total number of colors (product of Ncolors[] values).
/// </summary>
private int select_ncolors(int[] Ncolors)
{
int nc = m_cinfo.m_out_color_components; /* number of color components */
int max_colors = m_cinfo.m_desired_number_of_colors;
/* We can allocate at least the nc'th root of max_colors per component. */
/* Compute floor(nc'th root of max_colors). */
int iroot = 1;
long temp = 0;
do
{
iroot++;
temp = iroot; /* set temp = iroot ** nc */
for (int i = 1; i < nc; i++)
temp *= iroot;
}
while (temp <= max_colors); /* repeat till iroot exceeds root */
/* now iroot = floor(root) */
iroot--;
/* Must have at least 2 color values per component */
if (iroot < 2)
throw new Exception(String.Format("Cannot quantize to fewer than {0} colors", (int)temp));
/* Initialize to iroot color values for each component */
int total_colors = 1;
for (int i = 0; i < nc; i++)
{
Ncolors[i] = iroot;
total_colors *= iroot;
}
/* We may be able to increment the count for one or more components without
* exceeding max_colors, though we know not all can be incremented.
* Sometimes, the first component can be incremented more than once!
* (Example: for 16 colors, we start at 2*2*2, go to 3*2*2, then 4*2*2.)
* In RGB colorspace, try to increment G first, then R, then B.
*/
bool changed = false;
do
{
changed = false;
for (int i = 0; i < nc; i++)
{
int j = (m_cinfo.m_out_color_space == ColorSpace.RGB ? RGB_order[i] : i);
/* calculate new total_colors if Ncolors[j] is incremented */
temp = total_colors / Ncolors[j];
temp *= Ncolors[j] + 1; /* done in long arith to avoid oflo */
if (temp > max_colors)
break; /* won't fit, done with this pass */
Ncolors[j]++; /* OK, apply the increment */
total_colors = (int)temp;
changed = true;
}
}
while (changed);
return total_colors;
}
/// <summary>
/// Create an ordered-dither array for a component having ncolors
/// distinct output values.
/// </summary>
private static int[][] make_odither_array(int ncolors)
{
int[][] odither = new int[ODITHER_SIZE][];
for (int i = 0; i < ODITHER_SIZE; i++)
odither[i] = new int[ODITHER_SIZE];
/* The inter-value distance for this color is MaxSampleValue/(ncolors-1).
* Hence the dither value for the matrix cell with fill order f
* (f=0..N-1) should be (N-1-2*f)/(2*N) * MaxSampleValue/(ncolors-1).
* On 16-bit-int machine, be careful to avoid overflow.
*/
int den = 2 * ODITHER_CELLS * (ncolors - 1);
for (int j = 0; j < ODITHER_SIZE; j++)
{
for (int k = 0; k < ODITHER_SIZE; k++)
{
int num = ((int)(ODITHER_CELLS - 1 - 2 * ((int)base_dither_matrix[j][k]))) * JpegConstants.MaxSampleValue;
/* Ensure round towards zero despite C's lack of consistency
* about rounding negative values in integer division...
*/
odither[j][k] = num < 0 ? -((-num) / den) : num / den;
}
}
return odither;
}
}
#endregion
#region Pass2ColorQuantizer
/// <summary>
/// This module implements the well-known Heckbert paradigm for color
/// quantization. Most of the ideas used here can be traced back to
/// Heckbert's seminal paper
/// Heckbert, Paul. "Color Image Quantization for Frame Buffer Display",
/// Proc. SIGGRAPH '82, Computer Graphics v.16 #3 (July 1982), pp 297-304.
///
/// In the first pass over the image, we accumulate a histogram showing the
/// usage count of each possible color. To keep the histogram to a reasonable
/// size, we reduce the precision of the input; typical practice is to retain
/// 5 or 6 bits per color, so that 8 or 4 different input values are counted
/// in the same histogram cell.
///
/// Next, the color-selection step begins with a box representing the whole
/// color space, and repeatedly splits the "largest" remaining box until we
/// have as many boxes as desired colors. Then the mean color in each
/// remaining box becomes one of the possible output colors.
///
/// The second pass over the image maps each input pixel to the closest output
/// color (optionally after applying a Floyd-Steinberg dithering correction).
/// This mapping is logically trivial, but making it go fast enough requires
/// considerable care.
///
/// Heckbert-style quantizers vary a good deal in their policies for choosing
/// the "largest" box and deciding where to cut it. The particular policies
/// used here have proved out well in experimental comparisons, but better ones
/// may yet be found.
///
/// In earlier versions of the IJG code, this module quantized in YCbCr color
/// space, processing the raw upsampled data without a color conversion step.
/// This allowed the color conversion math to be done only once per colormap
/// entry, not once per pixel. However, that optimization precluded other
/// useful optimizations (such as merging color conversion with upsampling)
/// and it also interfered with desired capabilities such as quantizing to an
/// externally-supplied colormap. We have therefore abandoned that approach.
/// The present code works in the post-conversion color space, typically RGB.
///
/// To improve the visual quality of the results, we actually work in scaled
/// RGB space, giving G distances more weight than R, and R in turn more than
/// B. To do everything in integer math, we must use integer scale factors.
/// The 2/3/1 scale factors used here correspond loosely to the relative
/// weights of the colors in the NTSC grayscale equation.
/// If you want to use this code to quantize a non-RGB color space, you'll
/// probably need to change these scale factors.
///
/// First we have the histogram data structure and routines for creating it.
///
/// The number of bits of precision can be adjusted by changing these symbols.
/// We recommend keeping 6 bits for G and 5 each for R and B.
/// If you have plenty of memory and cycles, 6 bits all around gives marginally
/// better results; if you are short of memory, 5 bits all around will save
/// some space but degrade the results.
/// To maintain a fully accurate histogram, we'd need to allocate a "long"
/// (preferably unsigned long) for each cell. In practice this is overkill;
/// we can get by with 16 bits per cell. Few of the cell counts will overflow,
/// and clamping those that do overflow to the maximum value will give close-
/// enough results. This reduces the recommended histogram size from 256Kb
/// to 128Kb, which is a useful savings on PC-class machines.
/// (In the second pass the histogram space is re-used for pixel mapping data;
/// in that capacity, each cell must be able to store zero to the number of
/// desired colors. 16 bits/cell is plenty for that too.)
/// Since the JPEG code is intended to run in small memory model on 80x86
/// machines, we can't just allocate the histogram in one chunk. Instead
/// of a true 3-D array, we use a row of pointers to 2-D arrays. Each
/// pointer corresponds to a C0 value (typically 2^5 = 32 pointers) and
/// each 2-D array has 2^6*2^5 = 2048 or 2^6*2^6 = 4096 entries. Note that
/// on 80x86 machines, the pointer row is in near memory but the actual
/// arrays are in far memory (same arrangement as we use for image arrays).
///
///
/// Declarations for Floyd-Steinberg dithering.
///
/// Errors are accumulated into the array fserrors[], at a resolution of
/// 1/16th of a pixel count. The error at a given pixel is propagated
/// to its not-yet-processed neighbors using the standard F-S fractions,
/// ... (here) 7/16
/// 3/16 5/16 1/16
/// We work left-to-right on even rows, right-to-left on odd rows.
///
/// We can get away with a single array (holding one row's worth of errors)
/// by using it to store the current row's errors at pixel columns not yet
/// processed, but the next row's errors at columns already processed. We
/// need only a few extra variables to hold the errors immediately around the
/// current column. (If we are lucky, those variables are in registers, but
/// even if not, they're probably cheaper to access than array elements are.)
///
/// The fserrors[] array has (#columns + 2) entries; the extra entry at
/// each end saves us from special-casing the first and last pixels.
/// Each entry is three values long, one value for each color component.
/// </summary>
class Pass2ColorQuantizer : ColorQuantizer
{
private struct box
{
/* The bounds of the box (inclusive); expressed as histogram indexes */
public int c0min;
public int c0max;
public int c1min;
public int c1max;
public int c2min;
public int c2max;
/* The volume (actually 2-norm) of the box */
public int volume;
/* The number of nonzero histogram cells within this box */
public long colorcount;
}
private enum QuantizerType
{
prescan_quantizer,
pass2_fs_dither_quantizer,
pass2_no_dither_quantizer
}
private const int MAXNUMCOLORS = (JpegConstants.MaxSampleValue + 1); /* maximum size of colormap */
/* These will do the right thing for either R,G,B or B,G,R color order,
* but you may not like the results for other color orders.
*/
private const int HIST_C0_BITS = 5; /* bits of precision in R/B histogram */
private const int HIST_C1_BITS = 6; /* bits of precision in G histogram */
private const int HIST_C2_BITS = 5; /* bits of precision in B/R histogram */
/* Number of elements along histogram axes. */
private const int HIST_C0_ELEMS = (1 << HIST_C0_BITS);
private const int HIST_C1_ELEMS = (1 << HIST_C1_BITS);
private const int HIST_C2_ELEMS = (1 << HIST_C2_BITS);
/* These are the amounts to shift an input value to get a histogram index. */
private const int C0_SHIFT = (JpegConstants.BitsInSample - HIST_C0_BITS);
private const int C1_SHIFT = (JpegConstants.BitsInSample - HIST_C1_BITS);
private const int C2_SHIFT = (JpegConstants.BitsInSample - HIST_C2_BITS);
private const int R_SCALE = 2; /* scale R distances by this much */
private const int G_SCALE = 3; /* scale G distances by this much */
private const int B_SCALE = 1; /* and B by this much */
/* log2(histogram cells in update box) for each axis; this can be adjusted */
private const int BOX_C0_LOG = (HIST_C0_BITS - 3);
private const int BOX_C1_LOG = (HIST_C1_BITS - 3);
private const int BOX_C2_LOG = (HIST_C2_BITS - 3);
private const int BOX_C0_ELEMS = (1 << BOX_C0_LOG); /* # of hist cells in update box */
private const int BOX_C1_ELEMS = (1 << BOX_C1_LOG);
private const int BOX_C2_ELEMS = (1 << BOX_C2_LOG);
private const int BOX_C0_SHIFT = (C0_SHIFT + BOX_C0_LOG);
private const int BOX_C1_SHIFT = (C1_SHIFT + BOX_C1_LOG);
private const int BOX_C2_SHIFT = (C2_SHIFT + BOX_C2_LOG);
private QuantizerType m_quantizer;
private bool m_useFinishPass1;
private JpegDecompressor m_cinfo;
/* Space for the eventually created colormap is stashed here */
private byte[][] m_sv_colormap; /* colormap allocated at init time */
private int m_desired; /* desired # of colors = size of colormap */
/* Variables for accumulating image statistics */
private ushort[][] m_histogram; /* pointer to the histogram */
private bool m_needs_zeroed; /* true if next pass must zero histogram */
/* Variables for Floyd-Steinberg dithering */
private short[] m_fserrors; /* accumulated errors */
private bool m_on_odd_row; /* flag to remember which row we are on */
private int[] m_error_limiter; /* table for clamping the applied error */
/// <summary>
/// Module initialization routine for 2-pass color quantization.
/// </summary>
public Pass2ColorQuantizer(JpegDecompressor cinfo)
{
m_cinfo = cinfo;
/* Make sure jdmaster didn't give me a case I can't handle */
if (cinfo.m_out_color_components != 3)
throw new Exception("Unable to handle anything other than 3 color components!");
/* Allocate the histogram/inverse colormap storage */
m_histogram = new ushort[HIST_C0_ELEMS][];
for (int i = 0; i < HIST_C0_ELEMS; i++)
m_histogram[i] = new ushort[HIST_C1_ELEMS * HIST_C2_ELEMS];
m_needs_zeroed = true; /* histogram is garbage now */
/* Allocate storage for the completed colormap, if required.
* We do this now since it is FAR storage and may affect
* the memory manager's space calculations.
*/
if (cinfo.m_enable_2pass_quant)
{
/* Make sure color count is acceptable */
int desired_local = cinfo.m_desired_number_of_colors;
/* Lower bound on # of colors ... somewhat arbitrary as long as > 0 */
if (desired_local < 8)
throw new Exception("Cannot quantize to fewer than 8 colors");
/* Make sure colormap indexes can be represented by JSAMPLEs */
if (desired_local > MAXNUMCOLORS)
throw new Exception(String.Format("Cannot quantize to more than {0} colors", MAXNUMCOLORS));
m_sv_colormap = JpegCommonBase.AllocJpegSamples(desired_local, 3);
m_desired = desired_local;
}
/* Only F-S dithering or no dithering is supported. */
/* If user asks for ordered dither, give him F-S. */
if (cinfo.m_dither_mode != DitherMode.None)
cinfo.m_dither_mode = DitherMode.FloydStein;
/* Allocate Floyd-Steinberg workspace if necessary.
* This isn't really needed until pass 2, but again it is FAR storage.
* Although we will cope with a later change in dither_mode,
* we do not promise to honor max_memory_to_use if dither_mode changes.
*/
if (cinfo.m_dither_mode == DitherMode.FloydStein)
{
m_fserrors = new short[(cinfo.m_output_width + 2) * 3];
/* Might as well create the error-limiting table too. */
init_error_limit();
}
}
/// <summary>
/// Initialize for each processing pass.
/// </summary>
public virtual void start_pass(bool is_pre_scan)
{
/* Only F-S dithering or no dithering is supported. */
/* If user asks for ordered dither, give him F-S. */
if (m_cinfo.m_dither_mode != DitherMode.None)
m_cinfo.m_dither_mode = DitherMode.FloydStein;
if (is_pre_scan)
{
/* Set up method pointers */
m_quantizer = QuantizerType.prescan_quantizer;
m_useFinishPass1 = true;
m_needs_zeroed = true; /* Always zero histogram */
}
else
{
/* Set up method pointers */
if (m_cinfo.m_dither_mode == DitherMode.FloydStein)
m_quantizer = QuantizerType.pass2_fs_dither_quantizer;
else
m_quantizer = QuantizerType.pass2_no_dither_quantizer;
m_useFinishPass1 = false;
/* Make sure color count is acceptable */
int i = m_cinfo.m_actual_number_of_colors;
if (i < 1)
throw new Exception("Cannot quantize to less than 1 color");
if (i > MAXNUMCOLORS)
throw new Exception(String.Format("Cannot quantize to more than {0} colors", MAXNUMCOLORS));
if (m_cinfo.m_dither_mode == DitherMode.FloydStein)
{
/* Allocate Floyd-Steinberg workspace if we didn't already. */
if (m_fserrors == null)
{
int arraysize = (m_cinfo.m_output_width + 2) * 3;
m_fserrors = new short[arraysize];
}
else
{
/* Initialize the propagated errors to zero. */
Array.Clear(m_fserrors, 0, m_fserrors.Length);
}
/* Make the error-limit table if we didn't already. */
if (m_error_limiter == null)
init_error_limit();
m_on_odd_row = false;
}
}
/* Zero the histogram or inverse color map, if necessary */
if (m_needs_zeroed)
{
for (int i = 0; i < HIST_C0_ELEMS; i++)
Array.Clear(m_histogram[i], 0, m_histogram[i].Length);
m_needs_zeroed = false;
}
}
public virtual void color_quantize(byte[][] input_buf, int in_row, byte[][] output_buf, int out_row, int num_rows)
{
switch (m_quantizer)
{
case QuantizerType.prescan_quantizer:
prescan_quantize(input_buf, in_row, num_rows);
break;
case QuantizerType.pass2_fs_dither_quantizer:
pass2_fs_dither(input_buf, in_row, output_buf, out_row, num_rows);
break;
case QuantizerType.pass2_no_dither_quantizer:
pass2_no_dither(input_buf, in_row, output_buf, out_row, num_rows);
break;
default:
throw new Exception("Specified Quantizer Type not implemented");
}
}
public virtual void finish_pass()
{
if (m_useFinishPass1)
finish_pass1();
}
/// <summary>
/// Switch to a new external colormap between output passes.
/// </summary>
public virtual void new_color_map()
{
/* Reset the inverse color map */
m_needs_zeroed = true;
}
/// <summary>
/// Prescan some rows of pixels.
/// In this module the prescan simply updates the histogram, which has been
/// initialized to zeroes by start_pass.
/// An output_buf parameter is required by the method signature, but no data
/// is actually output (in fact the buffer controller is probably passing a
/// null pointer).
/// </summary>
private void prescan_quantize(byte[][] input_buf, int in_row, int num_rows)
{
for (int row = 0; row < num_rows; row++)
{
int inputIndex = 0;
for (int col = m_cinfo.m_output_width; col > 0; col--)
{
int rowIndex = (int)input_buf[in_row + row][inputIndex] >> C0_SHIFT;
int columnIndex = ((int)input_buf[in_row + row][inputIndex + 1] >> C1_SHIFT) * HIST_C2_ELEMS +
((int)input_buf[in_row + row][inputIndex + 2] >> C2_SHIFT);
/* increment pixel value, check for overflow and undo increment if so. */
m_histogram[rowIndex][columnIndex]++;
if (m_histogram[rowIndex][columnIndex] <= 0)
m_histogram[rowIndex][columnIndex]--;
inputIndex += 3;
}
}
}
/// <summary>
/// Map some rows of pixels to the output colormapped representation.
/// This version performs Floyd-Steinberg dithering
/// </summary>
private void pass2_fs_dither(byte[][] input_buf, int in_row, byte[][] output_buf, int out_row, int num_rows)
{
byte[] limit = m_cinfo.m_sample_range_limit;
int limitOffset = m_cinfo.m_sampleRangeLimitOffset;
for (int row = 0; row < num_rows; row++)
{
int inputPixelIndex = 0;
int outputPixelIndex = 0;
int errorIndex = 0;
int dir; /* +1 or -1 depending on direction */
int dir3; /* 3*dir, for advancing inputIndex & errorIndex */
if (m_on_odd_row)
{
/* work right to left in this row */
inputPixelIndex += (m_cinfo.m_output_width - 1) * 3; /* so point to rightmost pixel */
outputPixelIndex += m_cinfo.m_output_width - 1;
dir = -1;
dir3 = -3;
errorIndex = (m_cinfo.m_output_width + 1) * 3; /* => entry after last column */
m_on_odd_row = false; /* flip for next time */
}
else
{
/* work left to right in this row */
dir = 1;
dir3 = 3;
errorIndex = 0; /* => entry before first real column */
m_on_odd_row = true; /* flip for next time */
}
/* Preset error values: no error propagated to first pixel from left */
/* current error or pixel value */
int cur0 = 0;
int cur1 = 0;
int cur2 = 0;
/* and no error propagated to row below yet */
/* error for pixel below cur */
int belowerr0 = 0;
int belowerr1 = 0;
int belowerr2 = 0;
/* error for below/prev col */
int bpreverr0 = 0;
int bpreverr1 = 0;
int bpreverr2 = 0;
for (int col = m_cinfo.m_output_width; col > 0; col--)
{
/* curN holds the error propagated from the previous pixel on the
* current line. Add the error propagated from the previous line
* to form the complete error correction term for this pixel, and
* round the error term (which is expressed * 16) to an integer.
* RIGHT_SHIFT rounds towards minus infinity, so adding 8 is correct
* for either sign of the error value.
* Note: errorIndex is for *previous* column's array entry.
*/
cur0 = JpegUtils.RIGHT_SHIFT(cur0 + m_fserrors[errorIndex + dir3] + 8, 4);
cur1 = JpegUtils.RIGHT_SHIFT(cur1 + m_fserrors[errorIndex + dir3 + 1] + 8, 4);
cur2 = JpegUtils.RIGHT_SHIFT(cur2 + m_fserrors[errorIndex + dir3 + 2] + 8, 4);
/* Limit the error using transfer function set by init_error_limit.
* See comments with init_error_limit for rationale.
*/
cur0 = m_error_limiter[JpegConstants.MaxSampleValue + cur0];
cur1 = m_error_limiter[JpegConstants.MaxSampleValue + cur1];
cur2 = m_error_limiter[JpegConstants.MaxSampleValue + cur2];
/* Form pixel value + error, and range-limit to 0..MaxSampleValue.
* The maximum error is +- MaxSampleValue (or less with error limiting);
* this sets the required size of the range_limit array.
*/
cur0 += input_buf[in_row + row][inputPixelIndex];
cur1 += input_buf[in_row + row][inputPixelIndex + 1];
cur2 += input_buf[in_row + row][inputPixelIndex + 2];
cur0 = limit[limitOffset + cur0];
cur1 = limit[limitOffset + cur1];
cur2 = limit[limitOffset + cur2];
/* Index into the cache with adjusted pixel value */
int hRow = cur0 >> C0_SHIFT;
int hColumn = (cur1 >> C1_SHIFT) * HIST_C2_ELEMS + (cur2 >> C2_SHIFT);
/* If we have not seen this color before, find nearest colormap */
/* entry and update the cache */
if (m_histogram[hRow][hColumn] == 0)
fill_inverse_cmap(cur0 >> C0_SHIFT, cur1 >> C1_SHIFT, cur2 >> C2_SHIFT);
/* Now emit the colormap index for this cell */
int pixcode = m_histogram[hRow][hColumn] - 1;
output_buf[out_row + row][outputPixelIndex] = (byte)pixcode;
/* Compute representation error for this pixel */
cur0 -= m_cinfo.m_colormap[0][pixcode];
cur1 -= m_cinfo.m_colormap[1][pixcode];
cur2 -= m_cinfo.m_colormap[2][pixcode];
/* Compute error fractions to be propagated to adjacent pixels.
* Add these into the running sums, and simultaneously shift the
* next-line error sums left by 1 column.
*/
int bnexterr = cur0; /* Process component 0 */
int delta = cur0 * 2;
cur0 += delta; /* form error * 3 */
m_fserrors[errorIndex] = (short)(bpreverr0 + cur0);
cur0 += delta; /* form error * 5 */
bpreverr0 = belowerr0 + cur0;
belowerr0 = bnexterr;
cur0 += delta; /* form error * 7 */
bnexterr = cur1; /* Process component 1 */
delta = cur1 * 2;
cur1 += delta; /* form error * 3 */
m_fserrors[errorIndex + 1] = (short)(bpreverr1 + cur1);
cur1 += delta; /* form error * 5 */
bpreverr1 = belowerr1 + cur1;
belowerr1 = bnexterr;
cur1 += delta; /* form error * 7 */
bnexterr = cur2; /* Process component 2 */
delta = cur2 * 2;
cur2 += delta; /* form error * 3 */
m_fserrors[errorIndex + 2] = (short)(bpreverr2 + cur2);
cur2 += delta; /* form error * 5 */
bpreverr2 = belowerr2 + cur2;
belowerr2 = bnexterr;
cur2 += delta; /* form error * 7 */
/* At this point curN contains the 7/16 error value to be propagated
* to the next pixel on the current line, and all the errors for the
* next line have been shifted over. We are therefore ready to move on.
*/
inputPixelIndex += dir3; /* Advance pixel pointers to next column */
outputPixelIndex += dir;
errorIndex += dir3; /* advance errorIndex to current column */
}
/* Post-loop cleanup: we must unload the final error values into the
* final fserrors[] entry. Note we need not unload belowerrN because
* it is for the dummy column before or after the actual array.
*/
m_fserrors[errorIndex] = (short)bpreverr0; /* unload prev errs into array */
m_fserrors[errorIndex + 1] = (short)bpreverr1;
m_fserrors[errorIndex + 2] = (short)bpreverr2;
}
}
/// <summary>
/// Map some rows of pixels to the output colormapped representation.
/// This version performs no dithering
/// </summary>
private void pass2_no_dither(byte[][] input_buf, int in_row, byte[][] output_buf, int out_row, int num_rows)
{
for (int row = 0; row < num_rows; row++)
{
int inRow = row + in_row;
int inIndex = 0;
int outIndex = 0;
int outRow = out_row + row;
for (int col = m_cinfo.m_output_width; col > 0; col--)
{
/* get pixel value and index into the cache */
int c0 = (int)input_buf[inRow][inIndex] >> C0_SHIFT;
inIndex++;
int c1 = (int)input_buf[inRow][inIndex] >> C1_SHIFT;
inIndex++;
int c2 = (int)input_buf[inRow][inIndex] >> C2_SHIFT;
inIndex++;
int hRow = c0;
int hColumn = c1 * HIST_C2_ELEMS + c2;
/* If we have not seen this color before, find nearest colormap entry */
/* and update the cache */
if (m_histogram[hRow][hColumn] == 0)
fill_inverse_cmap(c0, c1, c2);
/* Now emit the colormap index for this cell */
output_buf[outRow][outIndex] = (byte)(m_histogram[hRow][hColumn] - 1);
outIndex++;
}
}
}
/// <summary>
/// Finish up at the end of each pass.
/// </summary>
private void finish_pass1()
{
/* Select the representative colors and fill in cinfo.colormap */
m_cinfo.m_colormap = m_sv_colormap;
select_colors(m_desired);
/* Force next pass to zero the color index table */
m_needs_zeroed = true;
}
/// <summary>
/// Compute representative color for a box, put it in colormap[icolor]
/// </summary>
private void compute_color(box[] boxlist, int boxIndex, int icolor)
{
/* Current algorithm: mean weighted by pixels (not colors) */
/* Note it is important to get the rounding correct! */
long total = 0;
long c0total = 0;
long c1total = 0;
long c2total = 0;
box curBox = boxlist[boxIndex];
for (int c0 = curBox.c0min; c0 <= curBox.c0max; c0++)
{
for (int c1 = curBox.c1min; c1 <= curBox.c1max; c1++)
{
int histogramIndex = c1 * HIST_C2_ELEMS + curBox.c2min;
for (int c2 = curBox.c2min; c2 <= curBox.c2max; c2++)
{
long count = m_histogram[c0][histogramIndex];
histogramIndex++;
if (count != 0)
{
total += count;
c0total += ((c0 << C0_SHIFT) + ((1 << C0_SHIFT) >> 1)) * count;
c1total += ((c1 << C1_SHIFT) + ((1 << C1_SHIFT) >> 1)) * count;
c2total += ((c2 << C2_SHIFT) + ((1 << C2_SHIFT) >> 1)) * count;
}
}
}
}
m_cinfo.m_colormap[0][icolor] = (byte)((c0total + (total >> 1)) / total);
m_cinfo.m_colormap[1][icolor] = (byte)((c1total + (total >> 1)) / total);
m_cinfo.m_colormap[2][icolor] = (byte)((c2total + (total >> 1)) / total);
}
/// <summary>
/// Master routine for color selection
/// </summary>
private void select_colors(int desired_colors)
{
/* Allocate workspace for box list */
box[] boxlist = new box[desired_colors];
/* Initialize one box containing whole space */
int numboxes = 1;
boxlist[0].c0min = 0;
boxlist[0].c0max = JpegConstants.MaxSampleValue >> C0_SHIFT;
boxlist[0].c1min = 0;
boxlist[0].c1max = JpegConstants.MaxSampleValue >> C1_SHIFT;
boxlist[0].c2min = 0;
boxlist[0].c2max = JpegConstants.MaxSampleValue >> C2_SHIFT;
/* Shrink it to actually-used volume and set its statistics */
update_box(boxlist, 0);
/* Perform median-cut to produce final box list */
numboxes = median_cut(boxlist, numboxes, desired_colors);
/* Compute the representative color for each box, fill colormap */
for (int i = 0; i < numboxes; i++)
compute_color(boxlist, i, i);
m_cinfo.m_actual_number_of_colors = numboxes;
}
/// <summary>
/// Repeatedly select and split the largest box until we have enough boxes
/// </summary>
private int median_cut(box[] boxlist, int numboxes, int desired_colors)
{
while (numboxes < desired_colors)
{
/* Select box to split.
* Current algorithm: by population for first half, then by volume.
*/
int foundIndex;
if (numboxes * 2 <= desired_colors)
foundIndex = find_biggest_color_pop(boxlist, numboxes);
else
foundIndex = find_biggest_volume(boxlist, numboxes);
if (foundIndex == -1) /* no splittable boxes left! */
break;
/* Copy the color bounds to the new box. */
boxlist[numboxes].c0max = boxlist[foundIndex].c0max;
boxlist[numboxes].c1max = boxlist[foundIndex].c1max;
boxlist[numboxes].c2max = boxlist[foundIndex].c2max;
boxlist[numboxes].c0min = boxlist[foundIndex].c0min;
boxlist[numboxes].c1min = boxlist[foundIndex].c1min;
boxlist[numboxes].c2min = boxlist[foundIndex].c2min;
/* Choose which axis to split the box on.
* Current algorithm: longest scaled axis.
* See notes in update_box about scaling distances.
*/
int c0 = ((boxlist[foundIndex].c0max - boxlist[foundIndex].c0min) << C0_SHIFT) * R_SCALE;
int c1 = ((boxlist[foundIndex].c1max - boxlist[foundIndex].c1min) << C1_SHIFT) * G_SCALE;
int c2 = ((boxlist[foundIndex].c2max - boxlist[foundIndex].c2min) << C2_SHIFT) * B_SCALE;
/* We want to break any ties in favor of green, then red, blue last.
* This code does the right thing for R,G,B or B,G,R color orders only.
*/
int cmax = c1;
int n = 1;
if (c0 > cmax)
{
cmax = c0;
n = 0;
}
if (c2 > cmax)
{
n = 2;
}
/* Choose split point along selected axis, and update box bounds.
* Current algorithm: split at halfway point.
* (Since the box has been shrunk to minimum volume,
* any split will produce two nonempty subboxes.)
* Note that lb value is max for lower box, so must be < old max.
*/
int lb;
switch (n)
{
case 0:
lb = (boxlist[foundIndex].c0max + boxlist[foundIndex].c0min) / 2;
boxlist[foundIndex].c0max = lb;
boxlist[numboxes].c0min = lb + 1;
break;
case 1:
lb = (boxlist[foundIndex].c1max + boxlist[foundIndex].c1min) / 2;
boxlist[foundIndex].c1max = lb;
boxlist[numboxes].c1min = lb + 1;
break;
case 2:
lb = (boxlist[foundIndex].c2max + boxlist[foundIndex].c2min) / 2;
boxlist[foundIndex].c2max = lb;
boxlist[numboxes].c2min = lb + 1;
break;
}
/* Update stats for boxes */
update_box(boxlist, foundIndex);
update_box(boxlist, numboxes);
numboxes++;
}
return numboxes;
}
/*
* Next we have the really interesting routines: selection of a colormap
* given the completed histogram.
* These routines work with a list of "boxes", each representing a rectangular
* subset of the input color space (to histogram precision).
*/
/// <summary>
/// Find the splittable box with the largest color population
/// Returns null if no splittable boxes remain
/// </summary>
private static int find_biggest_color_pop(box[] boxlist, int numboxes)
{
long maxc = 0;
int which = -1;
for (int i = 0; i < numboxes; i++)
{
if (boxlist[i].colorcount > maxc && boxlist[i].volume > 0)
{
which = i;
maxc = boxlist[i].colorcount;
}
}
return which;
}
/// <summary>
/// Find the splittable box with the largest (scaled) volume
/// Returns null if no splittable boxes remain
/// </summary>
private static int find_biggest_volume(box[] boxlist, int numboxes)
{
int maxv = 0;
int which = -1;
for (int i = 0; i < numboxes; i++)
{
if (boxlist[i].volume > maxv)
{
which = i;
maxv = boxlist[i].volume;
}
}
return which;
}
/// <summary>
/// Shrink the min/max bounds of a box to enclose only nonzero elements,
/// and recompute its volume and population
/// </summary>
private void update_box(box[] boxlist, int boxIndex)
{
box curBox = boxlist[boxIndex];
bool have_c0min = false;
if (curBox.c0max > curBox.c0min)
{
for (int c0 = curBox.c0min; c0 <= curBox.c0max; c0++)
{
for (int c1 = curBox.c1min; c1 <= curBox.c1max; c1++)
{
int histogramIndex = c1 * HIST_C2_ELEMS + curBox.c2min;
for (int c2 = curBox.c2min; c2 <= curBox.c2max; c2++)
{
if (m_histogram[c0][histogramIndex++] != 0)
{
curBox.c0min = c0;
have_c0min = true;
break;
}
}
if (have_c0min)
break;
}
if (have_c0min)
break;
}
}
bool have_c0max = false;
if (curBox.c0max > curBox.c0min)
{
for (int c0 = curBox.c0max; c0 >= curBox.c0min; c0--)
{
for (int c1 = curBox.c1min; c1 <= curBox.c1max; c1++)
{
int histogramIndex = c1 * HIST_C2_ELEMS + curBox.c2min;
for (int c2 = curBox.c2min; c2 <= curBox.c2max; c2++)
{
if (m_histogram[c0][histogramIndex++] != 0)
{
curBox.c0max = c0;
have_c0max = true;
break;
}
}
if (have_c0max)
break;
}
if (have_c0max)
break;
}
}
bool have_c1min = false;
if (curBox.c1max > curBox.c1min)
{
for (int c1 = curBox.c1min; c1 <= curBox.c1max; c1++)
{
for (int c0 = curBox.c0min; c0 <= curBox.c0max; c0++)
{
int histogramIndex = c1 * HIST_C2_ELEMS + curBox.c2min;
for (int c2 = curBox.c2min; c2 <= curBox.c2max; c2++)
{
if (m_histogram[c0][histogramIndex++] != 0)
{
curBox.c1min = c1;
have_c1min = true;
break;
}
}
if (have_c1min)
break;
}
if (have_c1min)
break;
}
}
bool have_c1max = false;
if (curBox.c1max > curBox.c1min)
{
for (int c1 = curBox.c1max; c1 >= curBox.c1min; c1--)
{
for (int c0 = curBox.c0min; c0 <= curBox.c0max; c0++)
{
int histogramIndex = c1 * HIST_C2_ELEMS + curBox.c2min;
for (int c2 = curBox.c2min; c2 <= curBox.c2max; c2++)
{
if (m_histogram[c0][histogramIndex++] != 0)
{
curBox.c1max = c1;
have_c1max = true;
break;
}
}
if (have_c1max)
break;
}
if (have_c1max)
break;
}
}
bool have_c2min = false;
if (curBox.c2max > curBox.c2min)
{
for (int c2 = curBox.c2min; c2 <= curBox.c2max; c2++)
{
for (int c0 = curBox.c0min; c0 <= curBox.c0max; c0++)
{
int histogramIndex = curBox.c1min * HIST_C2_ELEMS + c2;
for (int c1 = curBox.c1min; c1 <= curBox.c1max; c1++, histogramIndex += HIST_C2_ELEMS)
{
if (m_histogram[c0][histogramIndex] != 0)
{
curBox.c2min = c2;
have_c2min = true;
break;
}
}
if (have_c2min)
break;
}
if (have_c2min)
break;
}
}
bool have_c2max = false;
if (curBox.c2max > curBox.c2min)
{
for (int c2 = curBox.c2max; c2 >= curBox.c2min; c2--)
{
for (int c0 = curBox.c0min; c0 <= curBox.c0max; c0++)
{
int histogramIndex = curBox.c1min * HIST_C2_ELEMS + c2;
for (int c1 = curBox.c1min; c1 <= curBox.c1max; c1++, histogramIndex += HIST_C2_ELEMS)
{
if (m_histogram[c0][histogramIndex] != 0)
{
curBox.c2max = c2;
have_c2max = true;
break;
}
}
if (have_c2max)
break;
}
if (have_c2max)
break;
}
}
/* Update box volume.
* We use 2-norm rather than real volume here; this biases the method
* against making long narrow boxes, and it has the side benefit that
* a box is splittable iff norm > 0.
* Since the differences are expressed in histogram-cell units,
* we have to shift back to byte units to get consistent distances;
* after which, we scale according to the selected distance scale factors.
*/
int dist0 = ((curBox.c0max - curBox.c0min) << C0_SHIFT) * R_SCALE;
int dist1 = ((curBox.c1max - curBox.c1min) << C1_SHIFT) * G_SCALE;
int dist2 = ((curBox.c2max - curBox.c2min) << C2_SHIFT) * B_SCALE;
curBox.volume = dist0 * dist0 + dist1 * dist1 + dist2 * dist2;
/* Now scan remaining volume of box and compute population */
long ccount = 0;
for (int c0 = curBox.c0min; c0 <= curBox.c0max; c0++)
{
for (int c1 = curBox.c1min; c1 <= curBox.c1max; c1++)
{
int histogramIndex = c1 * HIST_C2_ELEMS + curBox.c2min;
for (int c2 = curBox.c2min; c2 <= curBox.c2max; c2++, histogramIndex++)
{
if (m_histogram[c0][histogramIndex] != 0)
ccount++;
}
}
}
curBox.colorcount = ccount;
boxlist[boxIndex] = curBox;
}
/// <summary>
/// Initialize the error-limiting transfer function (lookup table).
/// The raw F-S error computation can potentially compute error values of up to
/// +- MaxSampleValue. But we want the maximum correction applied to a pixel to be
/// much less, otherwise obviously wrong pixels will be created. (Typical
/// effects include weird fringes at color-area boundaries, isolated bright
/// pixels in a dark area, etc.) The standard advice for avoiding this problem
/// is to ensure that the "corners" of the color cube are allocated as output
/// colors; then repeated errors in the same direction cannot cause cascading
/// error buildup. However, that only prevents the error from getting
/// completely out of hand; Aaron Giles reports that error limiting improves
/// the results even with corner colors allocated.
/// A simple clamping of the error values to about +- MaxSampleValue/8 works pretty
/// well, but the smoother transfer function used below is even better. Thanks
/// to Aaron Giles for this idea.
/// </summary>
private void init_error_limit()
{
m_error_limiter = new int[JpegConstants.MaxSampleValue * 2 + 1];
int tableOffset = JpegConstants.MaxSampleValue;
const int STEPSIZE = ((JpegConstants.MaxSampleValue + 1) / 16);
/* Map errors 1:1 up to +- MaxSampleValue/16 */
int output = 0;
int input = 0;
for (; input < STEPSIZE; input++, output++)
{
m_error_limiter[tableOffset + input] = output;
m_error_limiter[tableOffset - input] = -output;
}
/* Map errors 1:2 up to +- 3*MaxSampleValue/16 */
for (; input < STEPSIZE * 3; input++)
{
m_error_limiter[tableOffset + input] = output;
m_error_limiter[tableOffset - input] = -output;
output += (input & 1) != 0 ? 1 : 0;
}
/* Clamp the rest to final output value (which is (MaxSampleValue+1)/8) */
for (; input <= JpegConstants.MaxSampleValue; input++)
{
m_error_limiter[tableOffset + input] = output;
m_error_limiter[tableOffset - input] = -output;
}
}
/*
* These routines are concerned with the time-critical task of mapping input
* colors to the nearest color in the selected colormap.
*
* We re-use the histogram space as an "inverse color map", essentially a
* cache for the results of nearest-color searches. All colors within a
* histogram cell will be mapped to the same colormap entry, namely the one
* closest to the cell's center. This may not be quite the closest entry to
* the actual input color, but it's almost as good. A zero in the cache
* indicates we haven't found the nearest color for that cell yet; the array
* is cleared to zeroes before starting the mapping pass. When we find the
* nearest color for a cell, its colormap index plus one is recorded in the
* cache for future use. The pass2 scanning routines call fill_inverse_cmap
* when they need to use an unfilled entry in the cache.
*
* Our method of efficiently finding nearest colors is based on the "locally
* sorted search" idea described by Heckbert and on the incremental distance
* calculation described by Spencer W. Thomas in chapter III.1 of Graphics
* Gems II (James Arvo, ed. Academic Press, 1991). Thomas points out that
* the distances from a given colormap entry to each cell of the histogram can
* be computed quickly using an incremental method: the differences between
* distances to adjacent cells themselves differ by a constant. This allows a
* fairly fast implementation of the "brute force" approach of computing the
* distance from every colormap entry to every histogram cell. Unfortunately,
* it needs a work array to hold the best-distance-so-far for each histogram
* cell (because the inner loop has to be over cells, not colormap entries).
* The work array elements have to be ints, so the work array would need
* 256Kb at our recommended precision. This is not feasible in DOS machines.
*
* To get around these problems, we apply Thomas' method to compute the
* nearest colors for only the cells within a small subbox of the histogram.
* The work array need be only as big as the subbox, so the memory usage
* problem is solved. Furthermore, we need not fill subboxes that are never
* referenced in pass2; many images use only part of the color gamut, so a
* fair amount of work is saved. An additional advantage of this
* approach is that we can apply Heckbert's locality criterion to quickly
* eliminate colormap entries that are far away from the subbox; typically
* three-fourths of the colormap entries are rejected by Heckbert's criterion,
* and we need not compute their distances to individual cells in the subbox.
* The speed of this approach is heavily influenced by the subbox size: too
* small means too much overhead, too big loses because Heckbert's criterion
* can't eliminate as many colormap entries. Empirically the best subbox
* size seems to be about 1/512th of the histogram (1/8th in each direction).
*
* Thomas' article also describes a refined method which is asymptotically
* faster than the brute-force method, but it is also far more complex and
* cannot efficiently be applied to small subboxes. It is therefore not
* useful for programs intended to be portable to DOS machines. On machines
* with plenty of memory, filling the whole histogram in one shot with Thomas'
* refined method might be faster than the present code --- but then again,
* it might not be any faster, and it's certainly more complicated.
*/
/*
* The next three routines implement inverse colormap filling. They could
* all be folded into one big routine, but splitting them up this way saves
* some stack space (the mindist[] and bestdist[] arrays need not coexist)
* and may allow some compilers to produce better code by registerizing more
* inner-loop variables.
*/
/// <summary>
/// Locate the colormap entries close enough to an update box to be candidates
/// for the nearest entry to some cell(s) in the update box. The update box
/// is specified by the center coordinates of its first cell. The number of
/// candidate colormap entries is returned, and their colormap indexes are
/// placed in colorlist[].
/// This routine uses Heckbert's "locally sorted search" criterion to select
/// the colors that need further consideration.
/// </summary>
private int find_nearby_colors(int minc0, int minc1, int minc2, byte[] colorlist)
{
/* Compute true coordinates of update box's upper corner and center.
* Actually we compute the coordinates of the center of the upper-corner
* histogram cell, which are the upper bounds of the volume we care about.
* Note that since ">>" rounds down, the "center" values may be closer to
* min than to max; hence comparisons to them must be "<=", not "<".
*/
int maxc0 = minc0 + ((1 << BOX_C0_SHIFT) - (1 << C0_SHIFT));
int centerc0 = (minc0 + maxc0) >> 1;
int maxc1 = minc1 + ((1 << BOX_C1_SHIFT) - (1 << C1_SHIFT));
int centerc1 = (minc1 + maxc1) >> 1;
int maxc2 = minc2 + ((1 << BOX_C2_SHIFT) - (1 << C2_SHIFT));
int centerc2 = (minc2 + maxc2) >> 1;
/* For each color in colormap, find:
* 1. its minimum squared-distance to any point in the update box
* (zero if color is within update box);
* 2. its maximum squared-distance to any point in the update box.
* Both of these can be found by considering only the corners of the box.
* We save the minimum distance for each color in mindist[];
* only the smallest maximum distance is of interest.
*/
int minmaxdist = 0x7FFFFFFF;
int[] mindist = new int[MAXNUMCOLORS]; /* min distance to colormap entry i */
for (int i = 0; i < m_cinfo.m_actual_number_of_colors; i++)
{
/* We compute the squared-c0-distance term, then add in the other two. */
int x = m_cinfo.m_colormap[0][i];
int min_dist;
int max_dist;
if (x < minc0)
{
int tdist = (x - minc0) * R_SCALE;
min_dist = tdist * tdist;
tdist = (x - maxc0) * R_SCALE;
max_dist = tdist * tdist;
}
else if (x > maxc0)
{
int tdist = (x - maxc0) * R_SCALE;
min_dist = tdist * tdist;
tdist = (x - minc0) * R_SCALE;
max_dist = tdist * tdist;
}
else
{
/* within cell range so no contribution to min_dist */
min_dist = 0;
if (x <= centerc0)
{
int tdist = (x - maxc0) * R_SCALE;
max_dist = tdist * tdist;
}
else
{
int tdist = (x - minc0) * R_SCALE;
max_dist = tdist * tdist;
}
}
x = m_cinfo.m_colormap[1][i];
if (x < minc1)
{
int tdist = (x - minc1) * G_SCALE;
min_dist += tdist * tdist;
tdist = (x - maxc1) * G_SCALE;
max_dist += tdist * tdist;
}
else if (x > maxc1)
{
int tdist = (x - maxc1) * G_SCALE;
min_dist += tdist * tdist;
tdist = (x - minc1) * G_SCALE;
max_dist += tdist * tdist;
}
else
{
/* within cell range so no contribution to min_dist */
if (x <= centerc1)
{
int tdist = (x - maxc1) * G_SCALE;
max_dist += tdist * tdist;
}
else
{
int tdist = (x - minc1) * G_SCALE;
max_dist += tdist * tdist;
}
}
x = m_cinfo.m_colormap[2][i];
if (x < minc2)
{
int tdist = (x - minc2) * B_SCALE;
min_dist += tdist * tdist;
tdist = (x - maxc2) * B_SCALE;
max_dist += tdist * tdist;
}
else if (x > maxc2)
{
int tdist = (x - maxc2) * B_SCALE;
min_dist += tdist * tdist;
tdist = (x - minc2) * B_SCALE;
max_dist += tdist * tdist;
}
else
{
/* within cell range so no contribution to min_dist */
if (x <= centerc2)
{
int tdist = (x - maxc2) * B_SCALE;
max_dist += tdist * tdist;
}
else
{
int tdist = (x - minc2) * B_SCALE;
max_dist += tdist * tdist;
}
}
mindist[i] = min_dist; /* save away the results */
if (max_dist < minmaxdist)
minmaxdist = max_dist;
}
/* Now we know that no cell in the update box is more than minmaxdist
* away from some colormap entry. Therefore, only colors that are
* within minmaxdist of some part of the box need be considered.
*/
int ncolors = 0;
for (int i = 0; i < m_cinfo.m_actual_number_of_colors; i++)
{
if (mindist[i] <= minmaxdist)
colorlist[ncolors++] = (byte)i;
}
return ncolors;
}
/// <summary>
/// Find the closest colormap entry for each cell in the update box,
/// given the list of candidate colors prepared by find_nearby_colors.
/// Return the indexes of the closest entries in the bestcolor[] array.
/// This routine uses Thomas' incremental distance calculation method to
/// find the distance from a colormap entry to successive cells in the box.
/// </summary>
private void find_best_colors(int minc0, int minc1, int minc2, int numcolors, byte[] colorlist, byte[] bestcolor)
{
/* Nominal steps between cell centers ("x" in Thomas article) */
const int STEP_C0 = ((1 << C0_SHIFT) * R_SCALE);
const int STEP_C1 = ((1 << C1_SHIFT) * G_SCALE);
const int STEP_C2 = ((1 << C2_SHIFT) * B_SCALE);
/* This array holds the distance to the nearest-so-far color for each cell */
int[] bestdist = new int[BOX_C0_ELEMS * BOX_C1_ELEMS * BOX_C2_ELEMS];
/* Initialize best-distance for each cell of the update box */
int bestIndex = 0;
for (int i = BOX_C0_ELEMS * BOX_C1_ELEMS * BOX_C2_ELEMS - 1; i >= 0; i--)
{
bestdist[bestIndex] = 0x7FFFFFFF;
bestIndex++;
}
/* For each color selected by find_nearby_colors,
* compute its distance to the center of each cell in the box.
* If that's less than best-so-far, update best distance and color number.
*/
for (int i = 0; i < numcolors; i++)
{
int icolor = colorlist[i];
/* Compute (square of) distance from minc0/c1/c2 to this color */
int inc0 = (minc0 - m_cinfo.m_colormap[0][icolor]) * R_SCALE;
int dist0 = inc0 * inc0;
int inc1 = (minc1 - m_cinfo.m_colormap[1][icolor]) * G_SCALE;
dist0 += inc1 * inc1;
int inc2 = (minc2 - m_cinfo.m_colormap[2][icolor]) * B_SCALE;
dist0 += inc2 * inc2;
/* Form the initial difference increments */
inc0 = inc0 * (2 * STEP_C0) + STEP_C0 * STEP_C0;
inc1 = inc1 * (2 * STEP_C1) + STEP_C1 * STEP_C1;
inc2 = inc2 * (2 * STEP_C2) + STEP_C2 * STEP_C2;
/* Now loop over all cells in box, updating distance per Thomas method */
bestIndex = 0;
int colorIndex = 0;
int xx0 = inc0;
for (int ic0 = BOX_C0_ELEMS - 1; ic0 >= 0; ic0--)
{
int dist1 = dist0;
int xx1 = inc1;
for (int ic1 = BOX_C1_ELEMS - 1; ic1 >= 0; ic1--)
{
int dist2 = dist1;
int xx2 = inc2;
for (int ic2 = BOX_C2_ELEMS - 1; ic2 >= 0; ic2--)
{
if (dist2 < bestdist[bestIndex])
{
bestdist[bestIndex] = dist2;
bestcolor[colorIndex] = (byte)icolor;
}
dist2 += xx2;
xx2 += 2 * STEP_C2 * STEP_C2;
bestIndex++;
colorIndex++;
}
dist1 += xx1;
xx1 += 2 * STEP_C1 * STEP_C1;
}
dist0 += xx0;
xx0 += 2 * STEP_C0 * STEP_C0;
}
}
}
/// <summary>
/// Fill the inverse-colormap entries in the update box that contains
/// histogram cell c0/c1/c2. (Only that one cell MUST be filled, but
/// we can fill as many others as we wish.)
/// </summary>
private void fill_inverse_cmap(int c0, int c1, int c2)
{
/* Convert cell coordinates to update box ID */
c0 >>= BOX_C0_LOG;
c1 >>= BOX_C1_LOG;
c2 >>= BOX_C2_LOG;
/* Compute true coordinates of update box's origin corner.
* Actually we compute the coordinates of the center of the corner
* histogram cell, which are the lower bounds of the volume we care about.
*/
int minc0 = (c0 << BOX_C0_SHIFT) + ((1 << C0_SHIFT) >> 1);
int minc1 = (c1 << BOX_C1_SHIFT) + ((1 << C1_SHIFT) >> 1);
int minc2 = (c2 << BOX_C2_SHIFT) + ((1 << C2_SHIFT) >> 1);
/* Determine which colormap entries are close enough to be candidates
* for the nearest entry to some cell in the update box.
*/
/* This array lists the candidate colormap indexes. */
byte[] colorlist = new byte[MAXNUMCOLORS];
int numcolors = find_nearby_colors(minc0, minc1, minc2, colorlist);
/* Determine the actually nearest colors. */
/* This array holds the actually closest colormap index for each cell. */
byte[] bestcolor = new byte[BOX_C0_ELEMS * BOX_C1_ELEMS * BOX_C2_ELEMS];
find_best_colors(minc0, minc1, minc2, numcolors, colorlist, bestcolor);
/* Save the best color numbers (plus 1) in the main cache array */
c0 <<= BOX_C0_LOG; /* convert ID back to base cell indexes */
c1 <<= BOX_C1_LOG;
c2 <<= BOX_C2_LOG;
int bestcolorIndex = 0;
for (int ic0 = 0; ic0 < BOX_C0_ELEMS; ic0++)
{
for (int ic1 = 0; ic1 < BOX_C1_ELEMS; ic1++)
{
int histogramIndex = (c1 + ic1) * HIST_C2_ELEMS + c2;
for (int ic2 = 0; ic2 < BOX_C2_ELEMS; ic2++)
{
m_histogram[c0 + ic0][histogramIndex] = (ushort)((int)bestcolor[bestcolorIndex] + 1);
histogramIndex++;
bestcolorIndex++;
}
}
}
}
}
#endregion
#region ProgressiveHuffmanDecoder
/// <summary>
/// Expanded entropy decoder object for progressive Huffman decoding.
///
/// The savable_state sub-record contains fields that change within an MCU,
/// but must not be updated permanently until we complete the MCU.
/// </summary>
class ProgressiveHuffmanDecoder : JpegEntropyDecoder
{
private class savable_state
{
//savable_state operator=(savable_state src);
public int EOBRUN; /* remaining EOBs in EOBRUN */
public int[] last_dc_val = new int[JpegConstants.MaxComponentsInScan]; /* last DC coef for each component */
public void Assign(savable_state ss)
{
EOBRUN = ss.EOBRUN;
Buffer.BlockCopy(ss.last_dc_val, 0, last_dc_val, 0, last_dc_val.Length * sizeof(int));
}
}
private enum MCUDecoder
{
mcu_DC_first_decoder,
mcu_AC_first_decoder,
mcu_DC_refine_decoder,
mcu_AC_refine_decoder
}
private MCUDecoder m_decoder;
/* These fields are loaded into local variables at start of each MCU.
* In case of suspension, we exit WITHOUT updating them.
*/
private SavedBitreadState m_bitstate; /* Bit buffer at start of MCU */
private savable_state m_saved = new savable_state(); /* Other state at start of MCU */
/* These fields are NOT loaded into local working state. */
private int m_restarts_to_go; /* MCUs left in this restart interval */
/* Pointers to derived tables (these workspaces have image lifespan) */
private DerivedTable[] m_derived_tbls = new DerivedTable[JpegConstants.NumberOfHuffmanTables];
private DerivedTable m_ac_derived_tbl; /* active table during an AC scan */
public ProgressiveHuffmanDecoder(JpegDecompressor cinfo)
{
m_cinfo = cinfo;
/* Mark derived tables unallocated */
for (int i = 0; i < JpegConstants.NumberOfHuffmanTables; i++)
m_derived_tbls[i] = null;
/* Create progression status table */
cinfo.m_coef_bits = new int[cinfo.m_num_components][];
for (int i = 0; i < cinfo.m_num_components; i++)
cinfo.m_coef_bits[i] = new int[JpegConstants.DCTSize2];
for (int ci = 0; ci < cinfo.m_num_components; ci++)
{
for (int i = 0; i < JpegConstants.DCTSize2; i++)
cinfo.m_coef_bits[ci][i] = -1;
}
}
/// <summary>
/// Initialize for a Huffman-compressed scan.
/// </summary>
public override void start_pass()
{
/* Validate scan parameters */
bool bad = false;
bool is_DC_band = (m_cinfo.m_Ss == 0);
if (is_DC_band)
{
if (m_cinfo.m_Se != 0)
bad = true;
}
else
{
/* need not check Ss/Se < 0 since they came from unsigned bytes */
if (m_cinfo.m_Ss > m_cinfo.m_Se || m_cinfo.m_Se >= JpegConstants.DCTSize2)
bad = true;
/* AC scans may have only one component */
if (m_cinfo.m_comps_in_scan != 1)
bad = true;
}
if (m_cinfo.m_Ah != 0)
{
/* Successive approximation refinement scan: must have Al = Ah-1. */
if (m_cinfo.m_Al != m_cinfo.m_Ah - 1)
bad = true;
}
if (m_cinfo.m_Al > 13)
{
/* need not check for < 0 */
bad = true;
}
/* Arguably the maximum Al value should be less than 13 for 8-bit precision,
* but the spec doesn't say so, and we try to be liberal about what we
* accept. Note: large Al values could result in out-of-range DC
* coefficients during early scans, leading to bizarre displays due to
* overflows in the IDCT math. But we won't crash.
*/
if (bad)
throw new Exception(String.Format("Invalid progressive parameters Ss={0} Se={1} Ah={2} Al={3}", m_cinfo.m_Ss, m_cinfo.m_Se, m_cinfo.m_Ah, m_cinfo.m_Al));
/* Update progression status, and verify that scan order is legal.
* Note that inter-scan inconsistencies are treated as warnings
* not fatal errors ... not clear if this is right way to behave.
*/
for (int ci = 0; ci < m_cinfo.m_comps_in_scan; ci++)
{
int cindex = m_cinfo.Comp_info[m_cinfo.m_cur_comp_info[ci]].Component_index;
for (int coefi = m_cinfo.m_Ss; coefi <= m_cinfo.m_Se; coefi++)
{
int expected = m_cinfo.m_coef_bits[cindex][coefi];
if (expected < 0)
expected = 0;
m_cinfo.m_coef_bits[cindex][coefi] = m_cinfo.m_Al;
}
}
/* Select MCU decoding routine */
if (m_cinfo.m_Ah == 0)
{
if (is_DC_band)
m_decoder = MCUDecoder.mcu_DC_first_decoder;
else
m_decoder = MCUDecoder.mcu_AC_first_decoder;
}
else
{
if (is_DC_band)
m_decoder = MCUDecoder.mcu_DC_refine_decoder;
else
m_decoder = MCUDecoder.mcu_AC_refine_decoder;
}
for (int ci = 0; ci < m_cinfo.m_comps_in_scan; ci++)
{
JpegComponent componentInfo = m_cinfo.Comp_info[m_cinfo.m_cur_comp_info[ci]];
/* Make sure requested tables are present, and compute derived tables.
* We may build same derived table more than once, but it's not expensive.
*/
if (is_DC_band)
{
if (m_cinfo.m_Ah == 0)
{
/* DC refinement needs no table */
jpeg_make_d_derived_tbl(true, componentInfo.Dc_tbl_no, ref m_derived_tbls[componentInfo.Dc_tbl_no]);
}
}
else
{
jpeg_make_d_derived_tbl(false, componentInfo.Ac_tbl_no, ref m_derived_tbls[componentInfo.Ac_tbl_no]);
/* remember the single active table */
m_ac_derived_tbl = m_derived_tbls[componentInfo.Ac_tbl_no];
}
/* Initialize DC predictions to 0 */
m_saved.last_dc_val[ci] = 0;
}
/* Initialize bitread state variables */
m_bitstate.bits_left = 0;
m_bitstate.get_buffer = 0; /* unnecessary, but keeps Purify quiet */
m_insufficient_data = false;
/* Initialize private state variables */
m_saved.EOBRUN = 0;
/* Initialize restart counter */
m_restarts_to_go = m_cinfo.m_restart_interval;
}
public override bool decode_mcu(JpegBlock[] MCU_data)
{
switch (m_decoder)
{
case MCUDecoder.mcu_DC_first_decoder:
return decode_mcu_DC_first(MCU_data);
case MCUDecoder.mcu_AC_first_decoder:
return decode_mcu_AC_first(MCU_data);
case MCUDecoder.mcu_DC_refine_decoder:
return decode_mcu_DC_refine(MCU_data);
case MCUDecoder.mcu_AC_refine_decoder:
return decode_mcu_AC_refine(MCU_data);
}
throw new Exception("The specified MCUDecoder is not implemented!");
}
/*
* Huffman MCU decoding.
* Each of these routines decodes and returns one MCU's worth of
* Huffman-compressed coefficients.
* The coefficients are reordered from zigzag order into natural array order,
* but are not de-quantized.
*
* The i'th block of the MCU is stored into the block pointed to by
* MCU_data[i]. WE ASSUME THIS AREA IS INITIALLY ZEROED BY THE CALLER.
*
* We return false if data source requested suspension. In that case no
* changes have been made to permanent state. (Exception: some output
* coefficients may already have been assigned. This is harmless for
* spectral selection, since we'll just re-assign them on the next call.
* Successive approximation AC refinement has to be more careful, however.)
*/
/// <summary>
/// MCU decoding for DC initial scan (either spectral selection,
/// or first pass of successive approximation).
/// </summary>
private bool decode_mcu_DC_first(JpegBlock[] MCU_data)
{
/* Process restart marker if needed; may have to suspend */
if (m_cinfo.m_restart_interval != 0)
{
if (m_restarts_to_go == 0)
{
if (!process_restart())
return false;
}
}
/* If we've run out of data, just leave the MCU set to zeroes.
* This way, we return uniform gray for the remainder of the segment.
*/
if (!m_insufficient_data)
{
/* Load up working state */
int get_buffer;
int bits_left;
WorkingBitreadState br_state = new WorkingBitreadState();
BITREAD_LOAD_STATE(m_bitstate, out get_buffer, out bits_left, ref br_state);
savable_state state = new savable_state();
state.Assign(m_saved);
/* Outer loop handles each block in the MCU */
for (int blkn = 0; blkn < m_cinfo.m_blocks_in_MCU; blkn++)
{
int ci = m_cinfo.m_MCU_membership[blkn];
/* Decode a single block's worth of coefficients */
/* Section F.2.2.1: decode the DC coefficient difference */
int s;
if (!HUFF_DECODE(out s, ref br_state, m_derived_tbls[m_cinfo.Comp_info[m_cinfo.m_cur_comp_info[ci]].Dc_tbl_no], ref get_buffer, ref bits_left))
return false;
if (s != 0)
{
if (!CHECK_BIT_BUFFER(ref br_state, s, ref get_buffer, ref bits_left))
return false;
int r = GET_BITS(s, get_buffer, ref bits_left);
s = HUFF_EXTEND(r, s);
}
/* Convert DC difference to actual value, update last_dc_val */
s += state.last_dc_val[ci];
state.last_dc_val[ci] = s;
/* Scale and output the coefficient (assumes jpeg_natural_order[0]=0) */
MCU_data[blkn][0] = (short)(s << m_cinfo.m_Al);
}
/* Completed MCU, so update state */
BITREAD_SAVE_STATE(ref m_bitstate, get_buffer, bits_left);
m_saved.Assign(state);
}
/* Account for restart interval (no-op if not using restarts) */
m_restarts_to_go--;
return true;
}
/// <summary>
/// MCU decoding for AC initial scan (either spectral selection,
/// or first pass of successive approximation).
/// </summary>
private bool decode_mcu_AC_first(JpegBlock[] MCU_data)
{
/* Process restart marker if needed; may have to suspend */
if (m_cinfo.m_restart_interval != 0)
{
if (m_restarts_to_go == 0)
{
if (!process_restart())
return false;
}
}
/* If we've run out of data, just leave the MCU set to zeroes.
* This way, we return uniform gray for the remainder of the segment.
*/
if (!m_insufficient_data)
{
/* Load up working state.
* We can avoid loading/saving bitread state if in an EOB run.
*/
int EOBRUN = m_saved.EOBRUN; /* only part of saved state we need */
/* There is always only one block per MCU */
if (EOBRUN > 0)
{
/* if it's a band of zeroes... */
/* ...process it now (we do nothing) */
EOBRUN--;
}
else
{
int get_buffer;
int bits_left;
WorkingBitreadState br_state = new WorkingBitreadState();
BITREAD_LOAD_STATE(m_bitstate, out get_buffer, out bits_left, ref br_state);
for (int k = m_cinfo.m_Ss; k <= m_cinfo.m_Se; k++)
{
int s;
if (!HUFF_DECODE(out s, ref br_state, m_ac_derived_tbl, ref get_buffer, ref bits_left))
return false;
int r = s >> 4;
s &= 15;
if (s != 0)
{
k += r;
if (!CHECK_BIT_BUFFER(ref br_state, s, ref get_buffer, ref bits_left))
return false;
r = GET_BITS(s, get_buffer, ref bits_left);
s = HUFF_EXTEND(r, s);
/* Scale and output coefficient in natural (dezigzagged) order */
MCU_data[0][JpegUtils.jpeg_natural_order[k]] = (short)(s << m_cinfo.m_Al);
}
else
{
if (r == 15)
{
/* ZRL */
k += 15; /* skip 15 zeroes in band */
}
else
{
/* EOBr, run length is 2^r + appended bits */
EOBRUN = 1 << r;
if (r != 0)
{
/* EOBr, r > 0 */
if (!CHECK_BIT_BUFFER(ref br_state, r, ref get_buffer, ref bits_left))
return false;
r = GET_BITS(r, get_buffer, ref bits_left);
EOBRUN += r;
}
EOBRUN--; /* this band is processed at this moment */
break; /* force end-of-band */
}
}
}
BITREAD_SAVE_STATE(ref m_bitstate, get_buffer, bits_left);
}
/* Completed MCU, so update state */
m_saved.EOBRUN = EOBRUN; /* only part of saved state we need */
}
/* Account for restart interval (no-op if not using restarts) */
m_restarts_to_go--;
return true;
}
/// <summary>
/// MCU decoding for DC successive approximation refinement scan.
/// Note: we assume such scans can be multi-component, although the spec
/// is not very clear on the point.
/// </summary>
private bool decode_mcu_DC_refine(JpegBlock[] MCU_data)
{
/* Process restart marker if needed; may have to suspend */
if (m_cinfo.m_restart_interval != 0)
{
if (m_restarts_to_go == 0)
{
if (!process_restart())
return false;
}
}
/* Not worth the cycles to check insufficient_data here,
* since we will not change the data anyway if we read zeroes.
*/
/* Load up working state */
int get_buffer;
int bits_left;
WorkingBitreadState br_state = new WorkingBitreadState();
BITREAD_LOAD_STATE(m_bitstate, out get_buffer, out bits_left, ref br_state);
/* Outer loop handles each block in the MCU */
for (int blkn = 0; blkn < m_cinfo.m_blocks_in_MCU; blkn++)
{
/* Encoded data is simply the next bit of the two's-complement DC value */
if (!CHECK_BIT_BUFFER(ref br_state, 1, ref get_buffer, ref bits_left))
return false;
if (GET_BITS(1, get_buffer, ref bits_left) != 0)
{
/* 1 in the bit position being coded */
MCU_data[blkn][0] |= (short)(1 << m_cinfo.m_Al);
}
/* Note: since we use |=, repeating the assignment later is safe */
}
/* Completed MCU, so update state */
BITREAD_SAVE_STATE(ref m_bitstate, get_buffer, bits_left);
/* Account for restart interval (no-op if not using restarts) */
m_restarts_to_go--;
return true;
}
// There is always only one block per MCU
private bool decode_mcu_AC_refine(JpegBlock[] MCU_data)
{
int p1 = 1 << m_cinfo.m_Al; /* 1 in the bit position being coded */
int m1 = -1 << m_cinfo.m_Al; /* -1 in the bit position being coded */
/* Process restart marker if needed; may have to suspend */
if (m_cinfo.m_restart_interval != 0)
{
if (m_restarts_to_go == 0)
{
if (!process_restart())
return false;
}
}
/* If we've run out of data, don't modify the MCU.
*/
if (!m_insufficient_data)
{
/* Load up working state */
int get_buffer;
int bits_left;
WorkingBitreadState br_state = new WorkingBitreadState();
BITREAD_LOAD_STATE(m_bitstate, out get_buffer, out bits_left, ref br_state);
int EOBRUN = m_saved.EOBRUN; /* only part of saved state we need */
/* If we are forced to suspend, we must undo the assignments to any newly
* nonzero coefficients in the block, because otherwise we'd get confused
* next time about which coefficients were already nonzero.
* But we need not undo addition of bits to already-nonzero coefficients;
* instead, we can test the current bit to see if we already did it.
*/
int num_newnz = 0;
int[] newnz_pos = new int[JpegConstants.DCTSize2];
/* initialize coefficient loop counter to start of band */
int k = m_cinfo.m_Ss;
if (EOBRUN == 0)
{
for (; k <= m_cinfo.m_Se; k++)
{
int s;
if (!HUFF_DECODE(out s, ref br_state, m_ac_derived_tbl, ref get_buffer, ref bits_left))
{
undo_decode_mcu_AC_refine(MCU_data, newnz_pos, num_newnz);
return false;
}
int r = s >> 4;
s &= 15;
if (s != 0)
{
if (!CHECK_BIT_BUFFER(ref br_state, 1, ref get_buffer, ref bits_left))
{
undo_decode_mcu_AC_refine(MCU_data, newnz_pos, num_newnz);
return false;
}
if (GET_BITS(1, get_buffer, ref bits_left) != 0)
{
/* newly nonzero coef is positive */
s = p1;
}
else
{
/* newly nonzero coef is negative */
s = m1;
}
}
else
{
if (r != 15)
{
EOBRUN = 1 << r; /* EOBr, run length is 2^r + appended bits */
if (r != 0)
{
if (!CHECK_BIT_BUFFER(ref br_state, r, ref get_buffer, ref bits_left))
{
undo_decode_mcu_AC_refine(MCU_data, newnz_pos, num_newnz);
return false;
}
r = GET_BITS(r, get_buffer, ref bits_left);
EOBRUN += r;
}
break; /* rest of block is handled by EOB logic */
}
/* note s = 0 for processing ZRL */
}
/* Advance over already-nonzero coefs and r still-zero coefs,
* appending correction bits to the nonzeroes. A correction bit is 1
* if the absolute value of the coefficient must be increased.
*/
do
{
int blockIndex = JpegUtils.jpeg_natural_order[k];
short thiscoef = MCU_data[0][blockIndex];
if (thiscoef != 0)
{
if (!CHECK_BIT_BUFFER(ref br_state, 1, ref get_buffer, ref bits_left))
{
undo_decode_mcu_AC_refine(MCU_data, newnz_pos, num_newnz);
return false;
}
if (GET_BITS(1, get_buffer, ref bits_left) != 0)
{
if ((thiscoef & p1) == 0)
{
/* do nothing if already set it */
if (thiscoef >= 0)
MCU_data[0][blockIndex] += (short)p1;
else
MCU_data[0][blockIndex] += (short)m1;
}
}
}
else
{
if (--r < 0)
break; /* reached target zero coefficient */
}
k++;
}
while (k <= m_cinfo.m_Se);
if (s != 0)
{
int pos = JpegUtils.jpeg_natural_order[k];
/* Output newly nonzero coefficient */
MCU_data[0][pos] = (short)s;
/* Remember its position in case we have to suspend */
newnz_pos[num_newnz++] = pos;
}
}
}
if (EOBRUN > 0)
{
/* Scan any remaining coefficient positions after the end-of-band
* (the last newly nonzero coefficient, if any). Append a correction
* bit to each already-nonzero coefficient. A correction bit is 1
* if the absolute value of the coefficient must be increased.
*/
for (; k <= m_cinfo.m_Se; k++)
{
int blockIndex = JpegUtils.jpeg_natural_order[k];
short thiscoef = MCU_data[0][blockIndex];
if (thiscoef != 0)
{
if (!CHECK_BIT_BUFFER(ref br_state, 1, ref get_buffer, ref bits_left))
{
//undo_decode_mcu_AC_refine(MCU_data[0], newnz_pos, num_newnz);
undo_decode_mcu_AC_refine(MCU_data, newnz_pos, num_newnz);
return false;
}
if (GET_BITS(1, get_buffer, ref bits_left) != 0)
{
if ((thiscoef & p1) == 0)
{
/* do nothing if already changed it */
if (thiscoef >= 0)
MCU_data[0][blockIndex] += (short)p1;
else
MCU_data[0][blockIndex] += (short)m1;
}
}
}
}
/* Count one block completed in EOB run */
EOBRUN--;
}
/* Completed MCU, so update state */
BITREAD_SAVE_STATE(ref m_bitstate, get_buffer, bits_left);
m_saved.EOBRUN = EOBRUN; /* only part of saved state we need */
}
/* Account for restart interval (no-op if not using restarts) */
m_restarts_to_go--;
return true;
}
/// <summary>
/// Check for a restart marker and resynchronize decoder.
/// Returns false if must suspend.
/// </summary>
private bool process_restart()
{
/* Throw away any unused bits remaining in bit buffer; */
/* include any full bytes in next_marker's count of discarded bytes */
m_cinfo.m_marker.SkipBytes(m_bitstate.bits_left / 8);
m_bitstate.bits_left = 0;
/* Advance past the RSTn marker */
if (!m_cinfo.m_marker.read_restart_marker())
return false;
/* Re-initialize DC predictions to 0 */
for (int ci = 0; ci < m_cinfo.m_comps_in_scan; ci++)
m_saved.last_dc_val[ci] = 0;
/* Re-init EOB run count, too */
m_saved.EOBRUN = 0;
/* Reset restart counter */
m_restarts_to_go = m_cinfo.m_restart_interval;
/* Reset out-of-data flag, unless read_restart_marker left us smack up
* against a marker. In that case we will end up treating the next data
* segment as empty, and we can avoid producing bogus output pixels by
* leaving the flag set.
*/
if (m_cinfo.m_unread_marker == 0)
m_insufficient_data = false;
return true;
}
/// <summary>
/// MCU decoding for AC successive approximation refinement scan.
/// </summary>
private static void undo_decode_mcu_AC_refine(JpegBlock[] block, int[] newnz_pos, int num_newnz)
{
/* Re-zero any output coefficients that we made newly nonzero */
while (num_newnz > 0)
block[0][newnz_pos[--num_newnz]] = 0;
}
}
#endregion
#region ProgressiveHuffmanEncoder
/// <summary>
/// Expanded entropy encoder object for progressive Huffman encoding.
/// </summary>
class ProgressiveHuffmanEncoder : JpegEntropyEncoder
{
private enum MCUEncoder
{
mcu_DC_first_encoder,
mcu_AC_first_encoder,
mcu_DC_refine_encoder,
mcu_AC_refine_encoder
}
/* MAX_CORR_BITS is the number of bits the AC refinement correction-bit
* buffer can hold. Larger sizes may slightly improve compression, but
* 1000 is already well into the realm of overkill.
* The minimum safe size is 64 bits.
*/
private const int MAX_CORR_BITS = 1000; /* Max # of correction bits I can buffer */
private MCUEncoder m_MCUEncoder;
/* Mode flag: true for optimization, false for actual data output */
private bool m_gather_statistics;
// Bit-level coding status.
private int m_put_buffer; /* current bit-accumulation buffer */
private int m_put_bits; /* # of bits now in it */
/* Coding status for DC components */
private int[] m_last_dc_val = new int[JpegConstants.MaxComponentsInScan]; /* last DC coef for each component */
/* Coding status for AC components */
private int m_ac_tbl_no; /* the table number of the single component */
private int m_EOBRUN; /* run length of EOBs */
private int m_BE; /* # of buffered correction bits before MCU */
private char[] m_bit_buffer; /* buffer for correction bits (1 per char) */
/* packing correction bits tightly would save some space but cost time... */
private int m_restarts_to_go; /* MCUs left in this restart interval */
private int m_next_restart_num; /* next restart number to write (0-7) */
/* Pointers to derived tables (these workspaces have image lifespan).
* Since any one scan codes only DC or only AC, we only need one set
* of tables, not one for DC and one for AC.
*/
private c_derived_tbl[] m_derived_tbls = new c_derived_tbl[JpegConstants.NumberOfHuffmanTables];
/* Statistics tables for optimization; again, one set is enough */
private long[][] m_count_ptrs = new long[JpegConstants.NumberOfHuffmanTables][];
public ProgressiveHuffmanEncoder(JpegCompressor cinfo)
{
m_cinfo = cinfo;
/* Mark tables unallocated */
for (int i = 0; i < JpegConstants.NumberOfHuffmanTables; i++)
{
m_derived_tbls[i] = null;
m_count_ptrs[i] = null;
}
}
// Initialize for a Huffman-compressed scan using progressive JPEG.
public override void start_pass(bool gather_statistics)
{
m_gather_statistics = gather_statistics;
/* We assume the scan parameters are already validated. */
/* Select execution routines */
bool is_DC_band = (m_cinfo.m_Ss == 0);
if (m_cinfo.m_Ah == 0)
{
if (is_DC_band)
m_MCUEncoder = MCUEncoder.mcu_DC_first_encoder;
else
m_MCUEncoder = MCUEncoder.mcu_AC_first_encoder;
}
else
{
if (is_DC_band)
{
m_MCUEncoder = MCUEncoder.mcu_DC_refine_encoder;
}
else
{
m_MCUEncoder = MCUEncoder.mcu_AC_refine_encoder;
/* AC refinement needs a correction bit buffer */
if (m_bit_buffer == null)
m_bit_buffer = new char[MAX_CORR_BITS];
}
}
/* Only DC coefficients may be interleaved, so m_cinfo.comps_in_scan = 1
* for AC coefficients.
*/
for (int ci = 0; ci < m_cinfo.m_comps_in_scan; ci++)
{
JpegComponent componentInfo = m_cinfo.Component_info[m_cinfo.m_cur_comp_info[ci]];
/* Initialize DC predictions to 0 */
m_last_dc_val[ci] = 0;
/* Get table index */
int tbl;
if (is_DC_band)
{
if (m_cinfo.m_Ah != 0) /* DC refinement needs no table */
continue;
tbl = componentInfo.Dc_tbl_no;
}
else
{
m_ac_tbl_no = componentInfo.Ac_tbl_no;
tbl = componentInfo.Ac_tbl_no;
}
if (m_gather_statistics)
{
/* Check for invalid table index */
/* (make_c_derived_tbl does this in the other path) */
if (tbl < 0 || tbl >= JpegConstants.NumberOfHuffmanTables)
throw new Exception(String.Format("Huffman table 0x{0:X2} was not defined", tbl));
/* Allocate and zero the statistics tables */
/* Note that jpeg_gen_optimal_table expects 257 entries in each table! */
if (m_count_ptrs[tbl] == null)
m_count_ptrs[tbl] = new long[257];
Array.Clear(m_count_ptrs[tbl], 0, 257);
}
else
{
/* Compute derived values for Huffman table */
/* We may do this more than once for a table, but it's not expensive */
jpeg_make_c_derived_tbl(is_DC_band, tbl, ref m_derived_tbls[tbl]);
}
}
/* Initialize AC stuff */
m_EOBRUN = 0;
m_BE = 0;
/* Initialize bit buffer to empty */
m_put_buffer = 0;
m_put_bits = 0;
/* Initialize restart stuff */
m_restarts_to_go = m_cinfo.m_restart_interval;
m_next_restart_num = 0;
}
public override bool encode_mcu(JpegBlock[][] MCU_data)
{
switch (m_MCUEncoder)
{
case MCUEncoder.mcu_DC_first_encoder:
return encode_mcu_DC_first(MCU_data);
case MCUEncoder.mcu_AC_first_encoder:
return encode_mcu_AC_first(MCU_data);
case MCUEncoder.mcu_DC_refine_encoder:
return encode_mcu_DC_refine(MCU_data);
case MCUEncoder.mcu_AC_refine_encoder:
return encode_mcu_AC_refine(MCU_data);
}
throw new Exception("The specified MCUEncoder is not implemented.");
}
public override void finish_pass()
{
if (m_gather_statistics)
finish_pass_gather_phuff();
else
finish_pass_phuff();
}
/// <summary>
/// MCU encoding for DC initial scan (either spectral selection,
/// or first pass of successive approximation).
/// </summary>
private bool encode_mcu_DC_first(JpegBlock[][] MCU_data)
{
/* Emit restart marker if needed */
if (m_cinfo.m_restart_interval != 0)
{
if (m_restarts_to_go == 0)
emit_restart(m_next_restart_num);
}
/* Encode the MCU data blocks */
for (int blkn = 0; blkn < m_cinfo.m_blocks_in_MCU; blkn++)
{
/* Compute the DC value after the required point transform by Al.
* This is simply an arithmetic right shift.
*/
int temp2 = IRIGHT_SHIFT(MCU_data[blkn][0][0], m_cinfo.m_Al);
/* DC differences are figured on the point-transformed values. */
int ci = m_cinfo.m_MCU_membership[blkn];
int temp = temp2 - m_last_dc_val[ci];
m_last_dc_val[ci] = temp2;
/* Encode the DC coefficient difference per section G.1.2.1 */
temp2 = temp;
if (temp < 0)
{
/* temp is abs value of input */
temp = -temp;
/* For a negative input, want temp2 = bitwise complement of abs(input) */
/* This code assumes we are on a two's complement machine */
temp2--;
}
/* Find the number of bits needed for the magnitude of the coefficient */
int nbits = 0;
while (temp != 0)
{
nbits++;
temp >>= 1;
}
/* Check for out-of-range coefficient values.
* Since we're encoding a difference, the range limit is twice as much.
*/
if (nbits > MAX_HUFFMAN_COEF_BITS + 1)
throw new Exception("DCT coefficient out of range");
/* Count/emit the Huffman-coded symbol for the number of bits */
emit_symbol(m_cinfo.Component_info[m_cinfo.m_cur_comp_info[ci]].Dc_tbl_no, nbits);
/* Emit that number of bits of the value, if positive, */
/* or the complement of its magnitude, if negative. */
if (nbits != 0)
{
/* emit_bits rejects calls with size 0 */
emit_bits(temp2, nbits);
}
}
/* Update restart-interval state too */
if (m_cinfo.m_restart_interval != 0)
{
if (m_restarts_to_go == 0)
{
m_restarts_to_go = m_cinfo.m_restart_interval;
m_next_restart_num++;
m_next_restart_num &= 7;
}
m_restarts_to_go--;
}
return true;
}
/// <summary>
/// MCU encoding for AC initial scan (either spectral selection,
/// or first pass of successive approximation).
/// </summary>
private bool encode_mcu_AC_first(JpegBlock[][] MCU_data)
{
/* Emit restart marker if needed */
if (m_cinfo.m_restart_interval != 0)
{
if (m_restarts_to_go == 0)
emit_restart(m_next_restart_num);
}
/* Encode the AC coefficients per section G.1.2.2, fig. G.3 */
/* r = run length of zeros */
int r = 0;
for (int k = m_cinfo.m_Ss; k <= m_cinfo.m_Se; k++)
{
int temp = MCU_data[0][0][JpegUtils.jpeg_natural_order[k]];
if (temp == 0)
{
r++;
continue;
}
/* We must apply the point transform by Al. For AC coefficients this
* is an integer division with rounding towards 0. To do this portably
* in C, we shift after obtaining the absolute value; so the code is
* interwoven with finding the abs value (temp) and output bits (temp2).
*/
int temp2;
if (temp < 0)
{
temp = -temp; /* temp is abs value of input */
temp >>= m_cinfo.m_Al; /* apply the point transform */
/* For a negative coef, want temp2 = bitwise complement of abs(coef) */
temp2 = ~temp;
}
else
{
temp >>= m_cinfo.m_Al; /* apply the point transform */
temp2 = temp;
}
/* Watch out for case that nonzero coef is zero after point transform */
if (temp == 0)
{
r++;
continue;
}
/* Emit any pending EOBRUN */
if (m_EOBRUN > 0)
emit_eobrun();
/* if run length > 15, must emit special run-length-16 codes (0xF0) */
while (r > 15)
{
emit_symbol(m_ac_tbl_no, 0xF0);
r -= 16;
}
/* Find the number of bits needed for the magnitude of the coefficient */
int nbits = 1; /* there must be at least one 1 bit */
while ((temp >>= 1) != 0)
nbits++;
/* Check for out-of-range coefficient values */
if (nbits > MAX_HUFFMAN_COEF_BITS)
throw new Exception("DCT coefficient out of range");
/* Count/emit Huffman symbol for run length / number of bits */
emit_symbol(m_ac_tbl_no, (r << 4) + nbits);
/* Emit that number of bits of the value, if positive, */
/* or the complement of its magnitude, if negative. */
emit_bits(temp2, nbits);
r = 0; /* reset zero run length */
}
if (r > 0)
{
/* If there are trailing zeroes, */
m_EOBRUN++; /* count an EOB */
if (m_EOBRUN == 0x7FFF)
emit_eobrun(); /* force it out to avoid overflow */
}
/* Update restart-interval state too */
if (m_cinfo.m_restart_interval != 0)
{
if (m_restarts_to_go == 0)
{
m_restarts_to_go = m_cinfo.m_restart_interval;
m_next_restart_num++;
m_next_restart_num &= 7;
}
m_restarts_to_go--;
}
return true;
}
/// <summary>
/// MCU encoding for DC successive approximation refinement scan.
/// Note: we assume such scans can be multi-component, although the spec
/// is not very clear on the point.
/// </summary>
private bool encode_mcu_DC_refine(JpegBlock[][] MCU_data)
{
/* Emit restart marker if needed */
if (m_cinfo.m_restart_interval != 0)
{
if (m_restarts_to_go == 0)
emit_restart(m_next_restart_num);
}
/* Encode the MCU data blocks */
for (int blkn = 0; blkn < m_cinfo.m_blocks_in_MCU; blkn++)
{
/* We simply emit the Al'th bit of the DC coefficient value. */
int temp = MCU_data[blkn][0][0];
emit_bits(temp >> m_cinfo.m_Al, 1);
}
/* Update restart-interval state too */
if (m_cinfo.m_restart_interval != 0)
{
if (m_restarts_to_go == 0)
{
m_restarts_to_go = m_cinfo.m_restart_interval;
m_next_restart_num++;
m_next_restart_num &= 7;
}
m_restarts_to_go--;
}
return true;
}
/// <summary>
/// MCU encoding for AC successive approximation refinement scan.
/// </summary>
private bool encode_mcu_AC_refine(JpegBlock[][] MCU_data)
{
/* Emit restart marker if needed */
if (m_cinfo.m_restart_interval != 0)
{
if (m_restarts_to_go == 0)
emit_restart(m_next_restart_num);
}
/* Encode the MCU data block */
/* It is convenient to make a pre-pass to determine the transformed
* coefficients' absolute values and the EOB position.
*/
int EOB = 0;
int[] absvalues = new int[JpegConstants.DCTSize2];
for (int k = m_cinfo.m_Ss; k <= m_cinfo.m_Se; k++)
{
int temp = MCU_data[0][0][JpegUtils.jpeg_natural_order[k]];
/* We must apply the point transform by Al. For AC coefficients this
* is an integer division with rounding towards 0. To do this portably
* in C, we shift after obtaining the absolute value.
*/
if (temp < 0)
temp = -temp; /* temp is abs value of input */
temp >>= m_cinfo.m_Al; /* apply the point transform */
absvalues[k] = temp; /* save abs value for main pass */
if (temp == 1)
{
/* EOB = index of last newly-nonzero coef */
EOB = k;
}
}
/* Encode the AC coefficients per section G.1.2.3, fig. G.7 */
int r = 0; /* r = run length of zeros */
int BR = 0; /* BR = count of buffered bits added now */
int bitBufferOffset = m_BE; /* Append bits to buffer */
for (int k = m_cinfo.m_Ss; k <= m_cinfo.m_Se; k++)
{
int temp = absvalues[k];
if (temp == 0)
{
r++;
continue;
}
/* Emit any required ZRLs, but not if they can be folded into EOB */
while (r > 15 && k <= EOB)
{
/* emit any pending EOBRUN and the BE correction bits */
emit_eobrun();
/* Emit ZRL */
emit_symbol(m_ac_tbl_no, 0xF0);
r -= 16;
/* Emit buffered correction bits that must be associated with ZRL */
emit_buffered_bits(bitBufferOffset, BR);
bitBufferOffset = 0;/* BE bits are gone now */
BR = 0;
}
/* If the coef was previously nonzero, it only needs a correction bit.
* NOTE: a straight translation of the spec's figure G.7 would suggest
* that we also need to test r > 15. But if r > 15, we can only get here
* if k > EOB, which implies that this coefficient is not 1.
*/
if (temp > 1)
{
/* The correction bit is the next bit of the absolute value. */
m_bit_buffer[bitBufferOffset + BR] = (char)(temp & 1);
BR++;
continue;
}
/* Emit any pending EOBRUN and the BE correction bits */
emit_eobrun();
/* Count/emit Huffman symbol for run length / number of bits */
emit_symbol(m_ac_tbl_no, (r << 4) + 1);
/* Emit output bit for newly-nonzero coef */
temp = (MCU_data[0][0][JpegUtils.jpeg_natural_order[k]] < 0) ? 0 : 1;
emit_bits(temp, 1);
/* Emit buffered correction bits that must be associated with this code */
emit_buffered_bits(bitBufferOffset, BR);
bitBufferOffset = 0;/* BE bits are gone now */
BR = 0;
r = 0; /* reset zero run length */
}
if (r > 0 || BR > 0)
{
/* If there are trailing zeroes, */
m_EOBRUN++; /* count an EOB */
m_BE += BR; /* concat my correction bits to older ones */
/* We force out the EOB if we risk either:
* 1. overflow of the EOB counter;
* 2. overflow of the correction bit buffer during the next MCU.
*/
if (m_EOBRUN == 0x7FFF || m_BE > (MAX_CORR_BITS - JpegConstants.DCTSize2 + 1))
emit_eobrun();
}
/* Update restart-interval state too */
if (m_cinfo.m_restart_interval != 0)
{
if (m_restarts_to_go == 0)
{
m_restarts_to_go = m_cinfo.m_restart_interval;
m_next_restart_num++;
m_next_restart_num &= 7;
}
m_restarts_to_go--;
}
return true;
}
/// <summary>
/// Finish up at the end of a Huffman-compressed progressive scan.
/// </summary>
private void finish_pass_phuff()
{
/* Flush out any buffered data */
emit_eobrun();
flush_bits();
}
/// <summary>
/// Finish up a statistics-gathering pass and create the new Huffman tables.
/// </summary>
private void finish_pass_gather_phuff()
{
/* Flush out buffered data (all we care about is counting the EOB symbol) */
emit_eobrun();
/* It's important not to apply jpeg_gen_optimal_table more than once
* per table, because it clobbers the input frequency counts!
*/
bool[] did = new bool[JpegConstants.NumberOfHuffmanTables];
bool is_DC_band = (m_cinfo.m_Ss == 0);
for (int ci = 0; ci < m_cinfo.m_comps_in_scan; ci++)
{
JpegComponent componentInfo = m_cinfo.Component_info[m_cinfo.m_cur_comp_info[ci]];
int tbl = componentInfo.Ac_tbl_no;
if (is_DC_band)
{
if (m_cinfo.m_Ah != 0) /* DC refinement needs no table */
continue;
tbl = componentInfo.Dc_tbl_no;
}
if (!did[tbl])
{
JpegHuffmanTable htblptr = null;
if (is_DC_band)
{
if (m_cinfo.m_dc_huff_tbl_ptrs[tbl] == null)
m_cinfo.m_dc_huff_tbl_ptrs[tbl] = new JpegHuffmanTable();
htblptr = m_cinfo.m_dc_huff_tbl_ptrs[tbl];
}
else
{
if (m_cinfo.m_ac_huff_tbl_ptrs[tbl] == null)
m_cinfo.m_ac_huff_tbl_ptrs[tbl] = new JpegHuffmanTable();
htblptr = m_cinfo.m_ac_huff_tbl_ptrs[tbl];
}
jpeg_gen_optimal_table(htblptr, m_count_ptrs[tbl]);
did[tbl] = true;
}
}
}
//////////////////////////////////////////////////////////////////////////
// Outputting bytes to the file.
// NB: these must be called only when actually outputting,
// that is, entropy.gather_statistics == false.
// Emit a byte
private void emit_byte(int val)
{
m_cinfo.m_dest.emit_byte(val);
}
/// <summary>
/// Outputting bits to the file
///
/// Only the right 24 bits of put_buffer are used; the valid bits are
/// left-justified in this part. At most 16 bits can be passed to emit_bits
/// in one call, and we never retain more than 7 bits in put_buffer
/// between calls, so 24 bits are sufficient.
/// </summary>
private void emit_bits(int code, int size)
{
// Emit some bits, unless we are in gather mode
/* This routine is heavily used, so it's worth coding tightly. */
int local_put_buffer = code;
/* if size is 0, caller used an invalid Huffman table entry */
if (size == 0)
throw new Exception("Missing Huffman code table entry");
if (m_gather_statistics)
{
/* do nothing if we're only getting stats */
return;
}
local_put_buffer &= (1 << size) - 1; /* mask off any extra bits in code */
m_put_bits += size; /* new number of bits in buffer */
local_put_buffer <<= 24 - m_put_bits; /* align incoming bits */
local_put_buffer |= m_put_buffer; /* and merge with old buffer contents */
while (m_put_bits >= 8)
{
int c = (local_put_buffer >> 16) & 0xFF;
emit_byte(c);
if (c == 0xFF)
{
/* need to stuff a zero byte? */
emit_byte(0);
}
local_put_buffer <<= 8;
m_put_bits -= 8;
}
m_put_buffer = local_put_buffer; /* update variables */
}
private void flush_bits()
{
emit_bits(0x7F, 7); /* fill any partial byte with ones */
m_put_buffer = 0; /* and reset bit-buffer to empty */
m_put_bits = 0;
}
// Emit (or just count) a Huffman symbol.
private void emit_symbol(int tbl_no, int symbol)
{
if (m_gather_statistics)
m_count_ptrs[tbl_no][symbol]++;
else
emit_bits(m_derived_tbls[tbl_no].ehufco[symbol], m_derived_tbls[tbl_no].ehufsi[symbol]);
}
// Emit bits from a correction bit buffer.
private void emit_buffered_bits(int offset, int nbits)
{
if (m_gather_statistics)
{
/* no real work */
return;
}
for (int i = 0; i < nbits; i++)
emit_bits(m_bit_buffer[offset + i], 1);
}
// Emit any pending EOBRUN symbol.
private void emit_eobrun()
{
if (m_EOBRUN > 0)
{
/* if there is any pending EOBRUN */
int temp = m_EOBRUN;
int nbits = 0;
while ((temp >>= 1) != 0)
nbits++;
/* safety check: shouldn't happen given limited correction-bit buffer */
if (nbits > 14)
throw new Exception("Missing Huffman code table entry");
emit_symbol(m_ac_tbl_no, nbits << 4);
if (nbits != 0)
emit_bits(m_EOBRUN, nbits);
m_EOBRUN = 0;
/* Emit any buffered correction bits */
emit_buffered_bits(0, m_BE);
m_BE = 0;
}
}
// Emit a restart marker & resynchronize predictions.
private void emit_restart(int restart_num)
{
emit_eobrun();
if (!m_gather_statistics)
{
flush_bits();
emit_byte(0xFF);
emit_byte((int)(JpegMarkerType.RST0 + restart_num));
}
if (m_cinfo.m_Ss == 0)
{
/* Re-initialize DC predictions to 0 */
for (int ci = 0; ci < m_cinfo.m_comps_in_scan; ci++)
m_last_dc_val[ci] = 0;
}
else
{
/* Re-initialize all AC-related fields to 0 */
m_EOBRUN = 0;
m_BE = 0;
}
}
/// <summary>
/// IRIGHT_SHIFT is like RIGHT_SHIFT, but works on int rather than int.
/// We assume that int right shift is unsigned if int right shift is,
/// which should be safe.
/// </summary>
private static int IRIGHT_SHIFT(int x, int shft)
{
return (x >> shft);
}
}
#endregion
#region RawImage
class RawImage : IRawImage
{
private List<SampleRow> m_samples;
private ColorSpace m_colorspace;
private int m_currentRow = -1;
internal RawImage(List<SampleRow> samples, ColorSpace colorspace)
{
if (samples == null)
throw new ArgumentNullException("'samples' Cannot be null!");
if (samples.Count <= 0)
throw new Exception("No element specified in 'samples'");
if (colorspace == ColorSpace.Unknown)
throw new Exception("Unknown Color Space!");
m_samples = samples;
m_colorspace = colorspace;
}
public override int Width
{
get
{
return m_samples[0].Length;
}
}
public override int Height
{
get
{
return m_samples.Count;
}
}
public override ColorSpace Colorspace
{
get
{
return m_colorspace;
}
}
public override int ComponentsPerPixel
{
get
{
return m_samples[0][0].ComponentCount;
}
}
public override void BeginRead()
{
m_currentRow = 0;
}
public override byte[] GetPixelRow()
{
SampleRow row = m_samples[m_currentRow];
List<byte> result = new List<byte>();
for (int i = 0; i < row.Length; ++i)
{
Sample sample = row[i];
for (int j = 0; j < sample.ComponentCount; ++j)
result.Add((byte)sample[j]);
}
++m_currentRow;
return result.ToArray();
}
public override void EndRead()
{
}
}
#endregion
#region Sample
/// <summary>
/// Represents a "sample" (you can understand it as a "pixel") of image.
/// </summary>
/// <remarks>It's impossible to create an instance of this class directly,
/// but you can use existing samples through <see cref="SampleRow"/> collection.
/// Usual scenario is to get row of samples from the <see cref="JpegImage.GetRow"/> method.
/// </remarks>
public class Sample
{
private short[] m_components;
private byte m_bitsPerComponent;
internal Sample(BitStream bitStream, byte bitsPerComponent, byte componentCount)
{
if (bitStream == null)
throw new ArgumentNullException("bitStream");
if (bitsPerComponent <= 0 || bitsPerComponent > 16)
throw new ArgumentOutOfRangeException("bitsPerComponent");
if (componentCount <= 0 || componentCount > 5)
throw new ArgumentOutOfRangeException("componentCount");
m_bitsPerComponent = bitsPerComponent;
m_components = new short[componentCount];
for (short i = 0; i < componentCount; ++i)
m_components[i] = (short)bitStream.Read(bitsPerComponent);
}
internal Sample(short[] components, byte bitsPerComponent)
{
if (components == null)
throw new ArgumentNullException("components");
if (components.Length == 0 || components.Length > 5)
throw new ArgumentException("components must be not empty and contain less than 5 elements");
if (bitsPerComponent <= 0 || bitsPerComponent > 16)
throw new ArgumentOutOfRangeException("bitsPerComponent");
m_bitsPerComponent = bitsPerComponent;
m_components = new short[components.Length];
Buffer.BlockCopy(components, 0, m_components, 0, components.Length * sizeof(short));
}
/// <summary>
/// Gets the number of bits per color component.
/// </summary>
/// <value>The number of bits per color component.</value>
public byte BitsPerComponent
{
get
{
return m_bitsPerComponent;
}
}
/// <summary>
/// Gets the number of color components.
/// </summary>
/// <value>The number of color components.</value>
public byte ComponentCount
{
get
{
return (byte)m_components.Length;
}
}
/// <summary>
/// Gets the color component at the specified index.
/// </summary>
/// <param name="componentNumber">The number of color component.</param>
/// <returns>Value of color component.</returns>
public short this[int componentNumber]
{
get
{
return GetComponent(componentNumber);
}
}
/// <summary>
/// Gets the required color component.
/// </summary>
/// <param name="componentNumber">The number of color component.</param>
/// <returns>Value of color component.</returns>
public short GetComponent(int componentNumber)
{
return m_components[componentNumber];
}
}
#endregion
#region SampleRow
/// <summary>
/// Represents a row of image - collection of samples.
/// </summary>
public class SampleRow
{
private byte[] m_bytes;
private Sample[] m_samples;
/// <summary>
/// Creates a row from raw samples data.
/// </summary>
/// <param name="row">Raw description of samples.<br/>
/// You can pass collection with more than sampleCount samples - only sampleCount samples
/// will be parsed and all remaining bytes will be ignored.</param>
/// <param name="sampleCount">The number of samples in row.</param>
/// <param name="bitsPerComponent">The number of bits per component.</param>
/// <param name="componentsPerSample">The number of components per sample.</param>
public SampleRow(byte[] row, int sampleCount, byte bitsPerComponent, byte componentsPerSample)
{
if (row == null)
throw new ArgumentNullException("row");
if (row.Length == 0)
throw new ArgumentException("row is empty");
if (sampleCount <= 0)
throw new ArgumentOutOfRangeException("sampleCount");
if (bitsPerComponent <= 0 || bitsPerComponent > 16)
throw new ArgumentOutOfRangeException("bitsPerComponent");
if (componentsPerSample <= 0 || componentsPerSample > 5)
throw new ArgumentOutOfRangeException("componentsPerSample");
m_bytes = row;
using (BitStream bitStream = new BitStream(row))
{
m_samples = new Sample[sampleCount];
for (int i = 0; i < sampleCount; ++i)
m_samples[i] = new Sample(bitStream, bitsPerComponent, componentsPerSample);
}
}
/// <summary>
/// Creates row from an array of components.
/// </summary>
/// <param name="sampleComponents">Array of color components.</param>
/// <param name="bitsPerComponent">The number of bits per component.</param>
/// <param name="componentsPerSample">The number of components per sample.</param>
/// <remarks>The difference between this constructor and
/// <see cref="M:BitMiracle.LibJpeg.SampleRow.#ctor(System.Byte[],System.Int32,System.Byte,System.Byte)">another one</see> -
/// this constructor accept an array of prepared color components whereas
/// another constructor accept raw bytes and parse them.
/// </remarks>
internal SampleRow(short[] sampleComponents, byte bitsPerComponent, byte componentsPerSample)
{
if (sampleComponents == null)
throw new ArgumentNullException("sampleComponents");
if (sampleComponents.Length == 0)
throw new ArgumentException("row is empty");
if (bitsPerComponent <= 0 || bitsPerComponent > 16)
throw new ArgumentOutOfRangeException("bitsPerComponent");
if (componentsPerSample <= 0 || componentsPerSample > 5)
throw new ArgumentOutOfRangeException("componentsPerSample");
int sampleCount = sampleComponents.Length / componentsPerSample;
m_samples = new Sample[sampleCount];
for (int i = 0; i < sampleCount; ++i)
{
short[] components = new short[componentsPerSample];
Buffer.BlockCopy(sampleComponents, i * componentsPerSample * sizeof(short), components, 0, componentsPerSample * sizeof(short));
m_samples[i] = new Sample(components, bitsPerComponent);
}
using (BitStream bits = new BitStream())
{
for (int i = 0; i < sampleCount; ++i)
{
for (int j = 0; j < componentsPerSample; ++j)
bits.Write(sampleComponents[i * componentsPerSample + j], bitsPerComponent);
}
m_bytes = new byte[bits.UnderlyingStream.Length];
bits.UnderlyingStream.Seek(0, System.IO.SeekOrigin.Begin);
bits.UnderlyingStream.Read(m_bytes, 0, (int)bits.UnderlyingStream.Length);
}
}
/// <summary>
/// Gets the number of samples in this row.
/// </summary>
/// <value>The number of samples.</value>
public int Length
{
get
{
return m_samples.Length;
}
}
/// <summary>
/// Gets the sample at the specified index.
/// </summary>
/// <param name="sampleNumber">The number of sample.</param>
/// <returns>The required sample.</returns>
public Sample this[int sampleNumber]
{
get
{
return GetAt(sampleNumber);
}
}
/// <summary>
/// Gets the sample at the specified index.
/// </summary>
/// <param name="sampleNumber">The number of sample.</param>
/// <returns>The required sample.</returns>
public Sample GetAt(int sampleNumber)
{
return m_samples[sampleNumber];
}
/// <summary>
/// Serializes this row to raw bytes.
/// </summary>
/// <returns>The row representation as array of bytes</returns>
public byte[] ToBytes()
{
return m_bytes;
}
}
#endregion
#region SavedBitreadState
/// <summary>
/// Bitreading state saved across MCUs
/// </summary>
struct SavedBitreadState
{
public int get_buffer; /* current bit-extraction buffer */
public int bits_left; /* # of unused bits in it */
}
#endregion
#region SourceManagerImpl
/// <summary>
/// Expanded data source object for stdio input
/// </summary>
class SourceManagerImpl : Jpeg_Source
{
private const int INPUT_BUF_SIZE = 4096;
private JpegDecompressor m_cinfo;
private Stream m_infile; /* source stream */
private byte[] m_buffer; /* start of buffer */
private bool m_start_of_file; /* have we gotten any data yet? */
/// <summary>
/// Initialize source - called by jpeg_read_header
/// before any data is actually read.
/// </summary>
public SourceManagerImpl(JpegDecompressor cinfo)
{
m_cinfo = cinfo;
m_buffer = new byte[INPUT_BUF_SIZE];
}
public void Attach(Stream infile)
{
m_infile = infile;
m_infile.Seek(0, SeekOrigin.Begin);
initInternalBuffer(null, 0);
}
public override void init_source()
{
/* We reset the empty-input-file flag for each image,
* but we don't clear the input buffer.
* This is correct behavior for reading a series of images from one source.
*/
m_start_of_file = true;
}
/// <summary>
/// Fill the input buffer - called whenever buffer is emptied.
///
/// In typical applications, this should read fresh data into the buffer
/// (ignoring the current state of next_input_byte and bytes_in_buffer),
/// reset the pointer and count to the start of the buffer, and return true
/// indicating that the buffer has been reloaded. It is not necessary to
/// fill the buffer entirely, only to obtain at least one more byte.
///
/// There is no such thing as an EOF return. If the end of the file has been
/// reached, the routine has a choice of ERREXIT() or inserting fake data into
/// the buffer. In most cases, generating a warning message and inserting a
/// fake EOI marker is the best course of action --- this will allow the
/// decompressor to output however much of the image is there. However,
/// the resulting error message is misleading if the real problem is an empty
/// input file, so we handle that case specially.
///
/// In applications that need to be able to suspend compression due to input
/// not being available yet, a false return indicates that no more data can be
/// obtained right now, but more may be forthcoming later. In this situation,
/// the decompressor will return to its caller (with an indication of the
/// number of scanlines it has read, if any). The application should resume
/// decompression after it has loaded more data into the input buffer. Note
/// that there are substantial restrictions on the use of suspension --- see
/// the documentation.
///
/// When suspending, the decompressor will back up to a convenient restart point
/// (typically the start of the current MCU). next_input_byte and bytes_in_buffer
/// indicate where the restart point will be if the current call returns false.
/// Data beyond this point must be rescanned after resumption, so move it to
/// the front of the buffer rather than discarding it.
/// </summary>
public override bool fill_input_buffer()
{
int nbytes = m_infile.Read(m_buffer, 0, INPUT_BUF_SIZE);
if (nbytes <= 0)
{
if (m_start_of_file) /* Treat empty input file as fatal error */
throw new Exception("The input file is empty!");
/* Insert a fake EOI marker */
m_buffer[0] = (byte)0xFF;
m_buffer[1] = (byte)JpegMarkerType.EOI;
nbytes = 2;
}
initInternalBuffer(m_buffer, nbytes);
m_start_of_file = false;
return true;
}
}
#endregion
#region TransCoefControllerImpl
/// <summary>
/// This is a special implementation of the coefficient
/// buffer controller. This is similar to jccoefct.c, but it handles only
/// output from presupplied virtual arrays. Furthermore, we generate any
/// dummy padding blocks on-the-fly rather than expecting them to be present
/// in the arrays.
/// </summary>
class TransCoefControllerImpl : JpegCompressorCoefController
{
private JpegCompressor m_cinfo;
private int m_iMCU_row_num; /* iMCU row # within image */
private int m_mcu_ctr; /* counts MCUs processed in current row */
private int m_MCU_vert_offset; /* counts MCU rows within iMCU row */
private int m_MCU_rows_per_iMCU_row; /* number of such rows needed */
/* Virtual block array for each component. */
private JpegVirtualArray<JpegBlock>[] m_whole_image;
/* Workspace for constructing dummy blocks at right/bottom edges. */
private JpegBlock[][] m_dummy_buffer = new JpegBlock[JpegConstants.CompressorMaxBlocksInMCU][];
/// <summary>
/// Initialize coefficient buffer controller.
///
/// Each passed coefficient array must be the right size for that
/// coefficient: width_in_blocks wide and height_in_blocks high,
/// with unit height at least v_samp_factor.
/// </summary>
public TransCoefControllerImpl(JpegCompressor cinfo, JpegVirtualArray<JpegBlock>[] coef_arrays)
{
m_cinfo = cinfo;
/* Save pointer to virtual arrays */
m_whole_image = coef_arrays;
/* Allocate and pre-zero space for dummy DCT blocks. */
JpegBlock[] buffer = new JpegBlock[JpegConstants.CompressorMaxBlocksInMCU];
for (int i = 0; i < JpegConstants.CompressorMaxBlocksInMCU; i++)
buffer[i] = new JpegBlock();
for (int i = 0; i < JpegConstants.CompressorMaxBlocksInMCU; i++)
{
m_dummy_buffer[i] = new JpegBlock[JpegConstants.CompressorMaxBlocksInMCU - i];
for (int j = i; j < JpegConstants.CompressorMaxBlocksInMCU; j++)
m_dummy_buffer[i][j - i] = buffer[j];
}
}
/// <summary>
/// Initialize for a processing pass.
/// </summary>
public virtual void start_pass(BufferMode pass_mode)
{
if (pass_mode != BufferMode.CrankDest)
throw new Exception("Bogus buffer control mode");
m_iMCU_row_num = 0;
start_iMCU_row();
}
/// <summary>
/// Process some data.
/// We process the equivalent of one fully interleaved MCU row ("iMCU" row)
/// per call, ie, v_samp_factor block rows for each component in the scan.
/// The data is obtained from the virtual arrays and fed to the entropy coder.
/// Returns true if the iMCU row is completed, false if suspended.
///
/// NB: input_buf is ignored; it is likely to be a null pointer.
/// </summary>
public virtual bool compress_data(byte[][][] input_buf)
{
/* Align the virtual buffers for the components used in this scan. */
JpegBlock[][][] buffer = new JpegBlock[JpegConstants.MaxComponentsInScan][][];
for (int ci = 0; ci < m_cinfo.m_comps_in_scan; ci++)
{
JpegComponent componentInfo = m_cinfo.Component_info[m_cinfo.m_cur_comp_info[ci]];
buffer[ci] = m_whole_image[componentInfo.Component_index].Access(
m_iMCU_row_num * componentInfo.V_samp_factor, componentInfo.V_samp_factor);
}
/* Loop to process one whole iMCU row */
int last_MCU_col = m_cinfo.m_MCUs_per_row - 1;
int last_iMCU_row = m_cinfo.m_total_iMCU_rows - 1;
JpegBlock[][] MCU_buffer = new JpegBlock[JpegConstants.CompressorMaxBlocksInMCU][];
for (int yoffset = m_MCU_vert_offset; yoffset < m_MCU_rows_per_iMCU_row; yoffset++)
{
for (int MCU_col_num = m_mcu_ctr; MCU_col_num < m_cinfo.m_MCUs_per_row; MCU_col_num++)
{
/* Construct list of pointers to DCT blocks belonging to this MCU */
int blkn = 0; /* index of current DCT block within MCU */
for (int ci = 0; ci < m_cinfo.m_comps_in_scan; ci++)
{
JpegComponent componentInfo = m_cinfo.Component_info[m_cinfo.m_cur_comp_info[ci]];
int start_col = MCU_col_num * componentInfo.MCU_width;
int blockcnt = (MCU_col_num < last_MCU_col) ? componentInfo.MCU_width : componentInfo.last_col_width;
for (int yindex = 0; yindex < componentInfo.MCU_height; yindex++)
{
int xindex = 0;
if (m_iMCU_row_num < last_iMCU_row || yindex + yoffset < componentInfo.last_row_height)
{
/* Fill in pointers to real blocks in this row */
for (xindex = 0; xindex < blockcnt; xindex++)
{
int bufLength = buffer[ci][yindex + yoffset].Length;
int start = start_col + xindex;
MCU_buffer[blkn] = new JpegBlock[bufLength - start];
for (int j = start; j < bufLength; j++)
MCU_buffer[blkn][j - start] = buffer[ci][yindex + yoffset][j];
blkn++;
}
}
else
{
/* At bottom of image, need a whole row of dummy blocks */
xindex = 0;
}
/* Fill in any dummy blocks needed in this row.
* Dummy blocks are filled in the same way as in jccoefct.c:
* all zeroes in the AC entries, DC entries equal to previous
* block's DC value. The init routine has already zeroed the
* AC entries, so we need only set the DC entries correctly.
*/
for (; xindex < componentInfo.MCU_width; xindex++)
{
MCU_buffer[blkn] = m_dummy_buffer[blkn];
MCU_buffer[blkn][0][0] = MCU_buffer[blkn - 1][0][0];
blkn++;
}
}
}
/* Try to write the MCU. */
if (!m_cinfo.m_entropy.encode_mcu(MCU_buffer))
{
/* Suspension forced; update state counters and exit */
m_MCU_vert_offset = yoffset;
m_mcu_ctr = MCU_col_num;
return false;
}
}
/* Completed an MCU row, but perhaps not an iMCU row */
m_mcu_ctr = 0;
}
/* Completed the iMCU row, advance counters for next one */
m_iMCU_row_num++;
start_iMCU_row();
return true;
}
/// <summary>
/// Reset within-iMCU-row counters for a new row
/// </summary>
private void start_iMCU_row()
{
/* In an interleaved scan, an MCU row is the same as an iMCU row.
* In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows.
* But at the bottom of the image, process only what's left.
*/
if (m_cinfo.m_comps_in_scan > 1)
{
m_MCU_rows_per_iMCU_row = 1;
}
else
{
if (m_iMCU_row_num < (m_cinfo.m_total_iMCU_rows - 1))
m_MCU_rows_per_iMCU_row = m_cinfo.Component_info[m_cinfo.m_cur_comp_info[0]].V_samp_factor;
else
m_MCU_rows_per_iMCU_row = m_cinfo.Component_info[m_cinfo.m_cur_comp_info[0]].last_row_height;
}
m_mcu_ctr = 0;
m_MCU_vert_offset = 0;
}
}
#endregion
#region UpsamplerImpl
class UpsamplerImpl : JpegUpsampler
{
private enum ComponentUpsampler
{
noop_upsampler,
fullsize_upsampler,
h2v1_fancy_upsampler,
h2v1_upsampler,
h2v2_fancy_upsampler,
h2v2_upsampler,
int_upsampler
}
private JpegDecompressor m_cinfo;
/* Color conversion buffer. When using separate upsampling and color
* conversion steps, this buffer holds one upsampled row group until it
* has been color converted and output.
* Note: we do not allocate any storage for component(s) which are full-size,
* ie do not need rescaling. The corresponding entry of color_buf[] is
* simply set to point to the input data array, thereby avoiding copying.
*/
private ComponentBuffer[] m_color_buf = new ComponentBuffer[JpegConstants.MaxComponents];
// used only for fullsize_upsampler mode
private int[] m_perComponentOffsets = new int[JpegConstants.MaxComponents];
/* Per-component upsampling method pointers */
private ComponentUpsampler[] m_upsampleMethods = new ComponentUpsampler[JpegConstants.MaxComponents];
private int m_currentComponent; // component being upsampled
private int m_upsampleRowOffset;
private int m_next_row_out; /* counts rows emitted from color_buf */
private int m_rows_to_go; /* counts rows remaining in image */
/* Height of an input row group for each component. */
private int[] m_rowgroup_height = new int[JpegConstants.MaxComponents];
/* These arrays save pixel expansion factors so that int_expand need not
* re-compute them each time. They are unused for other up-sampling methods.
*/
private byte[] m_h_expand = new byte[JpegConstants.MaxComponents];
private byte[] m_v_expand = new byte[JpegConstants.MaxComponents];
public UpsamplerImpl(JpegDecompressor cinfo)
{
m_cinfo = cinfo;
m_need_context_rows = false; /* until we find out differently */
if (cinfo.m_CCIR601_sampling) /* this isn't supported */
throw new Exception("CCIR601 sampling not implemented yet");
/* JpegDecompressorMainController doesn't support context rows when min_DCT_scaled_size = 1,
* so don't ask for it.
*/
bool do_fancy = cinfo.m_do_fancy_upsampling && cinfo.m_min_DCT_scaled_size > 1;
/* Verify we can handle the sampling factors, select per-component methods,
* and create storage as needed.
*/
for (int ci = 0; ci < cinfo.m_num_components; ci++)
{
JpegComponent componentInfo = cinfo.Comp_info[ci];
/* Compute size of an "input group" after IDCT scaling. This many samples
* are to be converted to max_h_samp_factor * max_v_samp_factor pixels.
*/
int h_in_group = (componentInfo.H_samp_factor * componentInfo.DCT_scaled_size) / cinfo.m_min_DCT_scaled_size;
int v_in_group = (componentInfo.V_samp_factor * componentInfo.DCT_scaled_size) / cinfo.m_min_DCT_scaled_size;
int h_out_group = cinfo.m_max_h_samp_factor;
int v_out_group = cinfo.m_max_v_samp_factor;
/* save for use later */
m_rowgroup_height[ci] = v_in_group;
bool need_buffer = true;
if (!componentInfo.component_needed)
{
/* Don't bother to upsample an uninteresting component. */
m_upsampleMethods[ci] = ComponentUpsampler.noop_upsampler;
need_buffer = false;
}
else if (h_in_group == h_out_group && v_in_group == v_out_group)
{
/* Fullsize components can be processed without any work. */
m_upsampleMethods[ci] = ComponentUpsampler.fullsize_upsampler;
need_buffer = false;
}
else if (h_in_group * 2 == h_out_group && v_in_group == v_out_group)
{
/* Special cases for 2h1v upsampling */
if (do_fancy && componentInfo.downsampled_width > 2)
m_upsampleMethods[ci] = ComponentUpsampler.h2v1_fancy_upsampler;
else
m_upsampleMethods[ci] = ComponentUpsampler.h2v1_upsampler;
}
else if (h_in_group * 2 == h_out_group && v_in_group * 2 == v_out_group)
{
/* Special cases for 2h2v upsampling */
if (do_fancy && componentInfo.downsampled_width > 2)
{
m_upsampleMethods[ci] = ComponentUpsampler.h2v2_fancy_upsampler;
m_need_context_rows = true;
}
else
{
m_upsampleMethods[ci] = ComponentUpsampler.h2v2_upsampler;
}
}
else if ((h_out_group % h_in_group) == 0 && (v_out_group % v_in_group) == 0)
{
/* Generic integral-factors up-sampling method */
m_upsampleMethods[ci] = ComponentUpsampler.int_upsampler;
m_h_expand[ci] = (byte)(h_out_group / h_in_group);
m_v_expand[ci] = (byte)(v_out_group / v_in_group);
}
else
throw new Exception("Fractional sampling not implemented yet");
if (need_buffer)
{
ComponentBuffer cb = new ComponentBuffer();
cb.SetBuffer(JpegCommonBase.AllocJpegSamples(JpegUtils.jround_up(cinfo.m_output_width,
cinfo.m_max_h_samp_factor), cinfo.m_max_v_samp_factor), null, 0);
m_color_buf[ci] = cb;
}
}
}
/// <summary>
/// Initialize for an upsampling pass.
/// </summary>
public override void start_pass()
{
/* Mark the conversion buffer empty */
m_next_row_out = m_cinfo.m_max_v_samp_factor;
/* Initialize total-height counter for detecting bottom of image */
m_rows_to_go = m_cinfo.m_output_height;
}
/// <summary>
/// Control routine to do upsampling (and color conversion).
///
/// In this version we upsample each component independently.
/// We upsample one row group into the conversion buffer, then apply
/// color conversion a row at a time.
/// </summary>
public override void upsample(ComponentBuffer[] input_buf, ref int in_row_group_ctr, int in_row_groups_avail, byte[][] output_buf, ref int out_row_ctr, int out_rows_avail)
{
/* Fill the conversion buffer, if it's empty */
if (m_next_row_out >= m_cinfo.m_max_v_samp_factor)
{
for (int ci = 0; ci < m_cinfo.m_num_components; ci++)
{
m_perComponentOffsets[ci] = 0;
/* Invoke per-component upsample method.*/
m_currentComponent = ci;
m_upsampleRowOffset = in_row_group_ctr * m_rowgroup_height[ci];
upsampleComponent(ref input_buf[ci]);
}
m_next_row_out = 0;
}
/* Color-convert and emit rows */
/* How many we have in the buffer: */
int num_rows = m_cinfo.m_max_v_samp_factor - m_next_row_out;
/* Not more than the distance to the end of the image. Need this test
* in case the image height is not a multiple of max_v_samp_factor:
*/
if (num_rows > m_rows_to_go)
num_rows = m_rows_to_go;
/* And not more than what the client can accept: */
out_rows_avail -= out_row_ctr;
if (num_rows > out_rows_avail)
num_rows = out_rows_avail;
m_cinfo.m_cconvert.color_convert(m_color_buf, m_perComponentOffsets, m_next_row_out, output_buf, out_row_ctr, num_rows);
/* Adjust counts */
out_row_ctr += num_rows;
m_rows_to_go -= num_rows;
m_next_row_out += num_rows;
/* When the buffer is emptied, declare this input row group consumed */
if (m_next_row_out >= m_cinfo.m_max_v_samp_factor)
in_row_group_ctr++;
}
private void upsampleComponent(ref ComponentBuffer input_data)
{
switch (m_upsampleMethods[m_currentComponent])
{
case ComponentUpsampler.noop_upsampler:
noop_upsample();
break;
case ComponentUpsampler.fullsize_upsampler:
fullsize_upsample(ref input_data);
break;
case ComponentUpsampler.h2v1_fancy_upsampler:
h2v1_fancy_upsample(m_cinfo.Comp_info[m_currentComponent].downsampled_width, ref input_data);
break;
case ComponentUpsampler.h2v1_upsampler:
h2v1_upsample(ref input_data);
break;
case ComponentUpsampler.h2v2_fancy_upsampler:
h2v2_fancy_upsample(m_cinfo.Comp_info[m_currentComponent].downsampled_width, ref input_data);
break;
case ComponentUpsampler.h2v2_upsampler:
h2v2_upsample(ref input_data);
break;
case ComponentUpsampler.int_upsampler:
int_upsample(ref input_data);
break;
default:
throw new Exception("The specified Component Up-sampler isn't implemented.");
}
}
/*
* These are the routines invoked to upsample pixel values
* of a single component. One row group is processed per call.
*/
/// <summary>
/// This is a no-op version used for "uninteresting" components.
/// These components will not be referenced by color conversion.
/// </summary>
private static void noop_upsample()
{
// do nothing
}
/// <summary>
/// For full-size components, we just make color_buf[ci] point at the
/// input buffer, and thus avoid copying any data. Note that this is
/// safe only because sep_upsample doesn't declare the input row group
/// "consumed" until we are done color converting and emitting it.
/// </summary>
private void fullsize_upsample(ref ComponentBuffer input_data)
{
m_color_buf[m_currentComponent] = input_data;
m_perComponentOffsets[m_currentComponent] = m_upsampleRowOffset;
}
/// <summary>
/// Fancy processing for the common case of 2:1 horizontal and 1:1 vertical.
///
/// The upsampling algorithm is linear interpolation between pixel centers,
/// also known as a "triangle filter". This is a good compromise between
/// speed and visual quality. The centers of the output pixels are 1/4 and 3/4
/// of the way between input pixel centers.
///
/// A note about the "bias" calculations: when rounding fractional values to
/// integer, we do not want to always round 0.5 up to the next integer.
/// If we did that, we'd introduce a noticeable bias towards larger values.
/// Instead, this code is arranged so that 0.5 will be rounded up or down at
/// alternate pixel locations (a simple ordered dither pattern).
/// </summary>
private void h2v1_fancy_upsample(int downsampled_width, ref ComponentBuffer input_data)
{
ComponentBuffer output_data = m_color_buf[m_currentComponent];
for (int inrow = 0; inrow < m_cinfo.m_max_v_samp_factor; inrow++)
{
int row = m_upsampleRowOffset + inrow;
int inIndex = 0;
int outIndex = 0;
/* Special case for first column */
int invalue = input_data[row][inIndex];
inIndex++;
output_data[inrow][outIndex] = (byte)invalue;
outIndex++;
output_data[inrow][outIndex] = (byte)((invalue * 3 + (int)input_data[row][inIndex] + 2) >> 2);
outIndex++;
for (int colctr = downsampled_width - 2; colctr > 0; colctr--)
{
/* General case: 3/4 * nearer pixel + 1/4 * further pixel */
invalue = (int)input_data[row][inIndex] * 3;
inIndex++;
output_data[inrow][outIndex] = (byte)((invalue + (int)input_data[row][inIndex - 2] + 1) >> 2);
outIndex++;
output_data[inrow][outIndex] = (byte)((invalue + (int)input_data[row][inIndex] + 2) >> 2);
outIndex++;
}
/* Special case for last column */
invalue = input_data[row][inIndex];
output_data[inrow][outIndex] = (byte)((invalue * 3 + (int)input_data[row][inIndex - 1] + 1) >> 2);
outIndex++;
output_data[inrow][outIndex] = (byte)invalue;
outIndex++;
}
}
/// <summary>
/// Fast processing for the common case of 2:1 horizontal and 1:1 vertical.
/// It's still a box filter.
/// </summary>
private void h2v1_upsample(ref ComponentBuffer input_data)
{
ComponentBuffer output_data = m_color_buf[m_currentComponent];
for (int inrow = 0; inrow < m_cinfo.m_max_v_samp_factor; inrow++)
{
int row = m_upsampleRowOffset + inrow;
int outIndex = 0;
for (int col = 0; col < m_cinfo.m_output_width; col++)
{
byte invalue = input_data[row][col]; /* don't need GETJSAMPLE() here */
output_data[inrow][outIndex] = invalue;
outIndex++;
output_data[inrow][outIndex] = invalue;
outIndex++;
}
}
}
/// <summary>
/// Fancy processing for the common case of 2:1 horizontal and 2:1 vertical.
/// Again a triangle filter; see comments for h2v1 case, above.
///
/// It is OK for us to reference the adjacent input rows because we demanded
/// context from the main buffer controller (see initialization code).
/// </summary>
private void h2v2_fancy_upsample(int downsampled_width, ref ComponentBuffer input_data)
{
ComponentBuffer output_data = m_color_buf[m_currentComponent];
int inrow = m_upsampleRowOffset;
int outrow = 0;
while (outrow < m_cinfo.m_max_v_samp_factor)
{
for (int v = 0; v < 2; v++)
{
// nearest input row index
int inIndex0 = 0;
//next nearest input row index
int inIndex1 = 0;
int inRow1 = -1;
if (v == 0)
{
/* next nearest is row above */
inRow1 = inrow - 1;
}
else
{
/* next nearest is row below */
inRow1 = inrow + 1;
}
int row = outrow;
int outIndex = 0;
outrow++;
/* Special case for first column */
int thiscolsum = (int)input_data[inrow][inIndex0] * 3 + (int)input_data[inRow1][inIndex1];
inIndex0++;
inIndex1++;
int nextcolsum = (int)input_data[inrow][inIndex0] * 3 + (int)input_data[inRow1][inIndex1];
inIndex0++;
inIndex1++;
output_data[row][outIndex] = (byte)((thiscolsum * 4 + 8) >> 4);
outIndex++;
output_data[row][outIndex] = (byte)((thiscolsum * 3 + nextcolsum + 7) >> 4);
outIndex++;
int lastcolsum = thiscolsum;
thiscolsum = nextcolsum;
for (int colctr = downsampled_width - 2; colctr > 0; colctr--)
{
/* General case: 3/4 * nearer pixel + 1/4 * further pixel in each */
/* dimension, thus 9/16, 3/16, 3/16, 1/16 overall */
nextcolsum = (int)input_data[inrow][inIndex0] * 3 + (int)input_data[inRow1][inIndex1];
inIndex0++;
inIndex1++;
output_data[row][outIndex] = (byte)((thiscolsum * 3 + lastcolsum + 8) >> 4);
outIndex++;
output_data[row][outIndex] = (byte)((thiscolsum * 3 + nextcolsum + 7) >> 4);
outIndex++;
lastcolsum = thiscolsum;
thiscolsum = nextcolsum;
}
/* Special case for last column */
output_data[row][outIndex] = (byte)((thiscolsum * 3 + lastcolsum + 8) >> 4);
outIndex++;
output_data[row][outIndex] = (byte)((thiscolsum * 4 + 7) >> 4);
outIndex++;
}
inrow++;
}
}
/// <summary>
/// Fast processing for the common case of 2:1 horizontal and 2:1 vertical.
/// It's still a box filter.
/// </summary>
private void h2v2_upsample(ref ComponentBuffer input_data)
{
ComponentBuffer output_data = m_color_buf[m_currentComponent];
int inrow = 0;
int outrow = 0;
while (outrow < m_cinfo.m_max_v_samp_factor)
{
int row = m_upsampleRowOffset + inrow;
int outIndex = 0;
for (int col = 0; col < m_cinfo.m_output_width; col++)
{
byte invalue = input_data[row][col]; /* don't need GETJSAMPLE() here */
output_data[outrow][outIndex] = invalue;
outIndex++;
output_data[outrow][outIndex] = invalue;
outIndex++;
}
JpegUtils.jcopy_sample_rows(output_data, outrow, output_data, outrow + 1, 1, m_cinfo.m_output_width);
inrow++;
outrow += 2;
}
}
/// <summary>
/// This version handles any integral sampling ratios.
/// This is not used for typical JPEG files, so it need not be fast.
/// Nor, for that matter, is it particularly accurate: the algorithm is
/// simple replication of the input pixel onto the corresponding output
/// pixels. The hi-falutin sampling literature refers to this as a
/// "box filter". A box filter tends to introduce visible artifacts,
/// so if you are actually going to use 3:1 or 4:1 sampling ratios
/// you would be well advised to improve this code.
/// </summary>
private void int_upsample(ref ComponentBuffer input_data)
{
ComponentBuffer output_data = m_color_buf[m_currentComponent];
int h_expand = m_h_expand[m_currentComponent];
int v_expand = m_v_expand[m_currentComponent];
int inrow = 0;
int outrow = 0;
while (outrow < m_cinfo.m_max_v_samp_factor)
{
/* Generate one output row with proper horizontal expansion */
int row = m_upsampleRowOffset + inrow;
for (int col = 0; col < m_cinfo.m_output_width; col++)
{
byte invalue = input_data[row][col]; /* don't need GETJSAMPLE() here */
int outIndex = 0;
for (int h = h_expand; h > 0; h--)
{
output_data[outrow][outIndex] = invalue;
outIndex++;
}
}
/* Generate any additional output rows by duplicating the first one */
if (v_expand > 1)
{
JpegUtils.jcopy_sample_rows(output_data, outrow, output_data,
outrow + 1, v_expand - 1, m_cinfo.m_output_width);
}
inrow++;
outrow += v_expand;
}
}
}
#endregion
#region Utils
class Utils
{
public static MemoryStream CopyStream(Stream stream)
{
if (stream == null)
throw new ArgumentNullException("stream");
long positionBefore = stream.Position;
stream.Seek(0, SeekOrigin.Begin);
MemoryStream result = new MemoryStream((int)stream.Length);
byte[] block = new byte[2048];
for (; ; )
{
int bytesRead = stream.Read(block, 0, 2048);
result.Write(block, 0, bytesRead);
if (bytesRead < 2048)
break;
}
stream.Seek(positionBefore, SeekOrigin.Begin);
return result;
}
public static void CMYK2RGB(byte c, byte m, byte y, byte k, out byte red, out byte green, out byte blue)
{
float C, M, Y, K;
C = c / 255.0f;
M = m / 255.0f;
Y = y / 255.0f;
K = k / 255.0f;
float R, G, B;
R = C * (1.0f - K) + K;
G = M * (1.0f - K) + K;
B = Y * (1.0f - K) + K;
R = (1.0f - R) * 255.0f + 0.5f;
G = (1.0f - G) * 255.0f + 0.5f;
B = (1.0f - B) * 255.0f + 0.5f;
red = (byte)(R * 255);
green = (byte)(G * 255);
blue = (byte)(B * 255);
}
}
#endregion
#region WorkingBitreadState
struct WorkingBitreadState
{
public int get_buffer;
public int bits_left;
public JpegDecompressor cinfo;
}
#endregion
}
Reference in a new issue View git blame Copy permalink