tsai
/
ImageSharp
mirror of https://github.com/SixLabors/ImageSharp
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

More encoder cleanup. 

Former-commit-id: fe7074b76c3bb682667c1f00077a87373cf15b4b
Former-commit-id: 875477a03fa94ab5c72ab2ebd4fc8303a36403fe
Former-commit-id: b06f1d713c57778d7d6d29dd2e6000becc5ff929
pull/1/head
James Jackson-South 10 years ago
parent
9fb1afb594
commit
46254f2a62
1 changed files with 295 additions and 223 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 518
      src/ImageProcessorCore/Formats/Jpg/JpegEncoderCore.cs

518
src/ImageProcessorCore/Formats/Jpg/JpegEncoderCore.cs
View File

@ -9,35 +9,12 @@ namespace ImageProcessorCore.Formats
internal class JpegEncoderCore
{
// "APPlication specific" markers aren't part of the JPEG spec per se,
// but in practice, their use is described at
// http://www.sno.phy.queensu.ca/~phil/exiftool/TagNames/JPEG.html
private const int app0Marker = 0xe0;
private const int app14Marker = 0xee;
private const int app15Marker = 0xef;
// bitCount counts the number of bits needed to hold an integer.
private readonly byte[] bitCount =
{
0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5,
5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
8, 8, 8, 8, 8, 8,
};
// unzig maps from the zig-zag ordering to the natural ordering. For example,
// unzig[3] is the column and row of the fourth element in zig-zag order. The
// value is 16, which means first column (16%8 == 0) and third row (16/8 == 2).
private static readonly int[] unzig = new[]
/// <summary>
/// Maps from the zig-zag ordering to the natural ordering. For example,
/// unzig[3] is the column and row of the fourth element in zig-zag order. The
/// value is 16, which means first column (16%8 == 0) and third row (16/8 == 2).
/// </summary>
private static readonly int[] Unzig =
{
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,
@ -45,165 +22,154 @@ namespace ImageProcessorCore.Formats
39, 46, 53, 60, 61, 54, 47, 55, 62, 63,
};
private const int nQuantIndex = 2;
private const int NQuantIndex = 2;
private const int nHuffIndex = 4;
private enum quantIndex
{
quantIndexLuminance = 0,
quantIndexChrominance = 1,
}
private enum huffIndex
/// <summary>
/// Counts the number of bits needed to hold an integer.
/// </summary>
private readonly byte[] bitCount =
{
huffIndexLuminanceDC = 0,
huffIndexLuminanceAC = 1,
huffIndexChrominanceDC = 2,
huffIndexChrominanceAC = 3,
}
0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5,
5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
8, 8, 8, 8, 8, 8,
};
// unscaledQuant are the unscaled quantization tables in zig-zag order. Each
// encoder copies and scales the tables according to its quality parameter.
// The values are derived from section K.1 after converting from natural to
// zig-zag order.
private byte[,] unscaledQuant = new byte[,]
{
{
// Luminance.
16, 11, 12, 14, 12, 10, 16, 14, 13, 14, 18, 17, 16, 19, 24, 40,
26, 24, 22, 22, 24, 49, 35, 37, 29, 40, 58, 51, 61, 60, 57, 51,
56, 55, 64, 72, 92, 78, 64, 68, 87, 69, 55, 56, 80, 109, 81,
87, 95, 98, 103, 104, 103, 62, 77, 113, 121, 112, 100, 120, 92,
101, 103, 99,
},
{
// Chrominance.
17, 18, 18, 24, 21, 24, 47, 26, 26, 47, 99, 66, 56, 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, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
},
};
private class huffmanSpec
{
public huffmanSpec(byte[] c, byte[] v)
/// <summary>
/// The unscaled quantization tables in zig-zag order. Each
/// encoder copies and scales the tables according to its quality parameter.
/// The values are derived from section K.1 after converting from natural to
/// zig-zag order.
/// </summary>
private readonly byte[,] unscaledQuant = {
{
// Luminance.
16, 11, 12, 14, 12, 10, 16, 14, 13, 14, 18, 17, 16, 19, 24, 40,
26, 24, 22, 22, 24, 49, 35, 37, 29, 40, 58, 51, 61, 60, 57, 51,
56, 55, 64, 72, 92, 78, 64, 68, 87, 69, 55, 56, 80, 109, 81,
87, 95, 98, 103, 104, 103, 62, 77, 113, 121, 112, 100, 120, 92,
101, 103, 99,
},
{
this.count = c;
this.values = v;
// Chrominance.
17, 18, 18, 24, 21, 24, 47, 26, 26, 47, 99, 66, 56, 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, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
}
};
public byte[] count;
public byte[] values;
}
// theHuffmanSpec is the Huffman encoding specifications.
// This encoder uses the same Huffman encoding for all images.
private huffmanSpec[] theHuffmanSpec = new[]
{
/// <summary>
/// The Huffman encoding specifications.
/// This encoder uses the same Huffman encoding for all images.
/// </summary>
private readonly HuffmanSpec[] theHuffmanSpec = {
// Luminance DC.
new huffmanSpec(
new HuffmanSpec(
new byte[]
{
0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0
},
{
0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0
},
new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 }),
new huffmanSpec(
new HuffmanSpec(
new byte[]
{
0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 125
},
{
0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 125
},
new byte[]
{
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
}),
new huffmanSpec(
{
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
}),
new HuffmanSpec(
new byte[]
{
0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0
},
{
0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0
},
new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 }),
// Chrominance AC.
new huffmanSpec(
new HuffmanSpec(
new byte[]
{
0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 119
},
{
0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 119
},
new byte[]
{
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,
})
{
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,
})
};
// huffmanLUT is a compiled look-up table representation of a huffmanSpec.
// Each value maps to a uint32 of which the 8 most significant bits hold the
// codeword size in bits and the 24 least significant bits hold the codeword.
// The maximum codeword size is 16 bits.
private class huffmanLUT
/// <summary>
/// A compiled look-up table representation of a huffmanSpec.
/// Each value maps to a uint32 of which the 8 most significant bits hold the
/// codeword size in bits and the 24 least significant bits hold the codeword.
/// The maximum codeword size is 16 bits.
/// </summary>
private class HuffmanLut
{
public uint[] values;
public readonly uint[] Values;
public huffmanLUT(huffmanSpec s)
public HuffmanLut(HuffmanSpec s)
{
int maxValue = 0;
foreach (var v in s.values)
foreach (var v in s.Values)
{
if (v > maxValue) maxValue = v;
}
this.values = new uint[maxValue + 1];
this.Values = new uint[maxValue + 1];
int code = 0;
int k = 0;
for (int i = 0; i < s.count.Length; i++)
for (int i = 0; i < s.Count.Length; i++)
{
int nBits = (i + 1) << 24;
for (int j = 0; j < s.count[i]; j++)
for (int j = 0; j < s.Count[i]; j++)
{
this.values[s.values[k]] = (uint)(nBits | code);
this.Values[s.Values[k]] = (uint)(nBits | code);
code++;
k++;
}
@ -217,32 +183,52 @@ namespace ImageProcessorCore.Formats
// writing. All attempted writes after the first error become no-ops.
private Stream outputStream;
// buf is a scratch buffer.
private byte[] buffer = new byte[16];
/// <summary>
/// A scratch buffer to reduce allocations.
/// </summary>
private readonly byte[] buffer = new byte[16];
// bits and nBits are accumulated bits to write to w.
/// <summary>
/// The accumulated bits to write to the stream.
/// </summary>
private uint bits;
/// <summary>
/// The accumulated bits to write to the stream.
/// </summary>
private uint nBits;
// quant is the scaled quantization tables, in zig-zag order.
private byte[][] quant = new byte[nQuantIndex][]; // [Block.blockSize];
/// <summary>
/// The scaled quantization tables, in zig-zag order.
/// </summary>
private readonly byte[][] quant = new byte[NQuantIndex][]; // [Block.blockSize];
// theHuffmanLUT are compiled representations of theHuffmanSpec.
private huffmanLUT[] theHuffmanLUT = new huffmanLUT[4];
// The compiled representations of theHuffmanSpec.
private readonly HuffmanLut[] theHuffmanLUT = new HuffmanLut[4];
/// <summary>
/// The subsampling method to use.
/// </summary>
private JpegSubsample subsample;
private void writeByte(byte b)
/// <summary>
/// Writes the given byte to the stream.
/// </summary>
/// <param name="b"></param>
private void WriteByte(byte b)
{
var data = new byte[1];
data[0] = b;
this.outputStream.Write(data, 0, 1);
}
// emit emits the least significant nBits bits of bits to the bit-stream.
// The precondition is bits < 1<<nBits && nBits <= 16.
private void emit(uint bits, uint nBits)
/// <summary>
/// Emits the least significant nBits bits of bits to the bit-stream.
/// The precondition is bits <example>&lt; 1&lt;&lt;nBits &amp;&amp; nBits &lt;= 16</example>.
/// </summary>
/// <param name="bits"></param>
/// <param name="nBits"></param>
private void Emit(uint bits, uint nBits)
{
nBits += this.nBits;
bits <<= (int)(32 - nBits);
@ -250,8 +236,8 @@ namespace ImageProcessorCore.Formats
while (nBits >= 8)
{
byte b = (byte)(bits >> 24);
this.writeByte(b);
if (b == 0xff) this.writeByte(0x00);
this.WriteByte(b);
if (b == 0xff) this.WriteByte(0x00);
bits <<= 8;
nBits -= 8;
}
@ -260,52 +246,75 @@ namespace ImageProcessorCore.Formats
this.nBits = nBits;
}
// emitHuff emits the given value with the given Huffman encoder.
private void emitHuff(huffIndex h, int v)
/// <summary>
/// Emits the given value with the given Huffman encoder.
/// </summary>
/// <param name="index">The index of the Huffman encoder</param>
/// <param name="value">The value to encode.</param>
private void EmitHuff(HuffIndex index, int value)
{
uint x = this.theHuffmanLUT[(int)h].values[v];
this.emit(x & ((1 << 24) - 1), x >> 24);
uint x = this.theHuffmanLUT[(int)index].Values[value];
this.Emit(x & ((1 << 24) - 1), x >> 24);
}
// emitHuffRLE emits a run of runLength copies of value encoded with the given
// Huffman encoder.
private void emitHuffRLE(huffIndex h, int runLength, int v)
/// <summary>
/// Emits a run of runLength copies of value encoded with the given Huffman encoder.
/// </summary>
/// <param name="index">The index of the Huffman encoder</param>
/// <param name="runLength">The number of copies to encode.</param>
/// <param name="value">The value to encode.</param>
private void EmitHuffRLE(HuffIndex index, int runLength, int value)
{
int a = v;
int b = v;
int a = value;
int b = value;
if (a < 0)
{
a = -v;
b = v - 1;
a = -value;
b = value - 1;
}
uint nBits = 0;
if (a < 0x100) nBits = this.bitCount[a];
else nBits = 8 + (uint)this.bitCount[a >> 8];
uint bt;
if (a < 0x100)
{
bt = this.bitCount[a];
}
else
{
bt = 8 + (uint)this.bitCount[a >> 8];
}
this.emitHuff(h, (int)((uint)(runLength << 4) | nBits));
if (nBits > 0) this.emit((uint)b & (uint)((1 << ((int)nBits)) - 1), nBits);
this.EmitHuff(index, (int)((uint)(runLength << 4) | bt));
if (bt > 0)
{
this.Emit((uint)b & (uint)((1 << ((int)bt)) - 1), bt);
}
}
// writeBlock writes a block of pixel data using the given quantization table,
// returning the post-quantized DC value of the DCT-transformed block. b is in
// natural (not zig-zag) order.
private int writeBlock(Block b, quantIndex q, int prevDC)
/// <summary>
/// Writes a block of pixel data using the given quantization table,
/// returning the post-quantized DC value of the DCT-transformed block.
/// The block is in natural (not zig-zag) order.
/// </summary>
/// <param name="block">The block to write.</param>
/// <param name="index">The quantization table index.</param>
/// <param name="prevDC">The previous DC value.</param>
/// <returns></returns>
private int WriteBlock(Block block, QuantIndex index, int prevDC)
{
FDCT.Transform(b);
FDCT.Transform(block);
// Emit the DC delta.
int dc = Round(b[0], 8 * this.quant[(int)q][0]);
this.emitHuffRLE((huffIndex)(2 * (int)q + 0), 0, dc - prevDC);
int dc = Round(block[0], 8 * this.quant[(int)index][0]);
this.EmitHuffRLE((HuffIndex)(2 * (int)index + 0), 0, dc - prevDC);
// Emit the AC components.
var h = (huffIndex)(2 * (int)q + 1);
var h = (HuffIndex)(2 * (int)index + 1);
int runLength = 0;
for (int zig = 1; zig < Block.BlockSize; zig++)
{
int ac = Round(b[unzig[zig]], 8 * this.quant[(int)q][zig]);
int ac = Round(block[Unzig[zig]], 8 * this.quant[(int)index][zig]);
if (ac == 0)
{
@ -315,22 +324,22 @@ namespace ImageProcessorCore.Formats
{
while (runLength > 15)
{
this.emitHuff(h, 0xf0);
this.EmitHuff(h, 0xf0);
runLength -= 16;
}
this.emitHuffRLE(h, runLength, ac);
this.EmitHuffRLE(h, runLength, ac);
runLength = 0;
}
}
if (runLength > 0) this.emitHuff(h, 0x00);
if (runLength > 0) this.EmitHuff(h, 0x00);
return dc;
}
// toYCbCr converts the 8x8 region of m whose top-left corner is p to its
// YCbCr values.
private void toYCbCr(PixelAccessor pixels, int x, int y, Block yBlock, Block cbBlock, Block crBlock)
private void ToYCbCr(PixelAccessor pixels, int x, int y, Block yBlock, Block cbBlock, Block crBlock)
{
int xmax = pixels.Width - 1;
int ymax = pixels.Height - 1;
@ -347,9 +356,13 @@ namespace ImageProcessorCore.Formats
}
}
// scale scales the 16x16 region represented by the 4 src blocks to the 8x8
// dst block.
private void scale_16x16_8x8(Block dst, Block[] src)
/// <summary>
/// Scales the 16x16 region represented by the 4 src blocks to the 8x8
/// dst block.
/// </summary>
/// <param name="destination">The destination block array</param>
/// <param name="source">The source block array.</param>
private void Scale16X16_8X8(Block destination, Block[] source)
{
for (int i = 0; i < 4; i++)
{
@ -359,8 +372,8 @@ namespace ImageProcessorCore.Formats
for (int x = 0; x < 4; x++)
{
int j = 16 * y + 2 * x;
int sum = src[i][j] + src[i][j + 1] + src[i][j + 8] + src[i][j + 9];
dst[8 * y + x + dstOff] = (sum + 2) / 4;
int sum = source[i][j] + source[i][j + 1] + source[i][j + 8] + source[i][j + 9];
destination[8 * y + x + dstOff] = (sum + 2) / 4;
}
}
}
@ -429,10 +442,10 @@ namespace ImageProcessorCore.Formats
// TODO: This should be static should it not?
for (int i = 0; i < this.theHuffmanSpec.Length; i++)
{
this.theHuffmanLUT[i] = new huffmanLUT(this.theHuffmanSpec[i]);
this.theHuffmanLUT[i] = new HuffmanLut(this.theHuffmanSpec[i]);
}
for (int i = 0; i < nQuantIndex; i++)
for (int i = 0; i < NQuantIndex; i++)
{
this.quant[i] = new byte[Block.BlockSize];
}
@ -452,7 +465,7 @@ namespace ImageProcessorCore.Formats
}
// Initialize the quantization tables.
for (int i = 0; i < nQuantIndex; i++)
for (int i = 0; i < NQuantIndex; i++)
{
for (int j = 0; j < Block.BlockSize; j++)
{
@ -516,11 +529,11 @@ namespace ImageProcessorCore.Formats
/// </summary>
private void WriteDQT()
{
int markerlen = 2 + nQuantIndex * (1 + Block.BlockSize);
int markerlen = 2 + NQuantIndex * (1 + Block.BlockSize);
this.WriteMarkerHeader(JpegConstants.Markers.DQT, markerlen);
for (int i = 0; i < nQuantIndex; i++)
for (int i = 0; i < NQuantIndex; i++)
{
this.writeByte((byte)i);
this.WriteByte((byte)i);
this.outputStream.Write(this.quant[i], 0, this.quant[i].Length);
}
}
@ -587,7 +600,7 @@ namespace ImageProcessorCore.Formats
{
byte[] headers = { 0x00, 0x10, 0x01, 0x11 };
int markerlen = 2;
huffmanSpec[] specs = this.theHuffmanSpec;
HuffmanSpec[] specs = this.theHuffmanSpec;
if (nComponent == 1)
{
@ -597,17 +610,17 @@ namespace ImageProcessorCore.Formats
foreach (var s in specs)
{
markerlen += 1 + 16 + s.values.Length;
markerlen += 1 + 16 + s.Values.Length;
}
this.WriteMarkerHeader(JpegConstants.Markers.DHT, markerlen);
for (int i = 0; i < specs.Length; i++)
{
huffmanSpec spec = specs[i];
HuffmanSpec spec = specs[i];
this.writeByte(headers[i]);
this.outputStream.Write(spec.count, 0, spec.count.Length);
this.outputStream.Write(spec.values, 0, spec.values.Length);
this.WriteByte(headers[i]);
this.outputStream.Write(spec.Count, 0, spec.Count.Length);
this.outputStream.Write(spec.Values, 0, spec.Values.Length);
}
}
@ -631,9 +644,11 @@ namespace ImageProcessorCore.Formats
}
// Pad the last byte with 1's.
this.emit(0x7f, 7);
this.Emit(0x7f, 7);
}
/// <summary>
/// Encodes the image with no subsampling.
/// </summary>
@ -649,10 +664,10 @@ namespace ImageProcessorCore.Formats
{
for (int x = 0; x < pixels.Width; x += 8)
{
this.toYCbCr(pixels, x, y, b, cb, cr);
prevDCY = this.writeBlock(b, (quantIndex)0, prevDCY);
prevDCCb = this.writeBlock(cb, (quantIndex)1, prevDCCb);
prevDCCr = this.writeBlock(cr, (quantIndex)1, prevDCCr);
this.ToYCbCr(pixels, x, y, b, cb, cr);
prevDCY = this.WriteBlock(b, QuantIndex.Luminance, prevDCY);
prevDCCb = this.WriteBlock(cb, QuantIndex.Chrominance, prevDCCb);
prevDCCr = this.WriteBlock(cr, QuantIndex.Chrominance, prevDCCr);
}
}
}
@ -681,14 +696,14 @@ namespace ImageProcessorCore.Formats
int xOff = (i & 1) * 8;
int yOff = (i & 2) * 4;
this.toYCbCr(pixels, x + xOff, y + yOff, b, cb[i], cr[i]);
prevDCY = this.writeBlock(b, (quantIndex)0, prevDCY);
this.ToYCbCr(pixels, x + xOff, y + yOff, b, cb[i], cr[i]);
prevDCY = this.WriteBlock(b, QuantIndex.Luminance, prevDCY);
}
this.scale_16x16_8x8(b, cb);
prevDCCb = this.writeBlock(b, (quantIndex)1, prevDCCb);
this.scale_16x16_8x8(b, cr);
prevDCCr = this.writeBlock(b, (quantIndex)1, prevDCCr);
this.Scale16X16_8X8(b, cb);
prevDCCb = this.WriteBlock(b, QuantIndex.Chrominance, prevDCCb);
this.Scale16X16_8X8(b, cr);
prevDCCr = this.WriteBlock(b, QuantIndex.Chrominance, prevDCCr);
}
}
}
@ -707,5 +722,62 @@ namespace ImageProcessorCore.Formats
this.buffer[3] = (byte)(length & 0xff);
this.outputStream.Write(this.buffer, 0, 4);
}
/// <summary>
/// Enumerates the Huffman tables
/// </summary>
private enum HuffIndex
{
LuminanceDC = 0,
LuminanceAC = 1,
ChrominanceDC = 2,
ChrominanceAC = 3,
}
/// <summary>
/// Enumerates the quantization tables
/// </summary>
private enum QuantIndex
{
/// <summary>
/// Luminance
/// </summary>
Luminance = 0,
/// <summary>
/// Chrominance
/// </summary>
Chrominance = 1,
}
/// <summary>
/// The Huffman encoding specifications.
/// </summary>
private struct HuffmanSpec
{
/// <summary>
/// Initializes a n ew instance of the <see cref="HuffmanSpec"/> struct.
/// </summary>
/// <param name="count">The number of codes.</param>
/// <param name="values">The decoded values.</param>
public HuffmanSpec(byte[] count, byte[] values)
{
this.Count = count;
this.Values = values;
}
/// <summary>
/// Gets count[i] - The number of codes of length i bits.
/// </summary>
public readonly byte[] Count;
/// <summary>
/// Gets value[i] - The decoded value of the i'th codeword.
/// </summary>
public readonly byte[] Values;
}
}
}

Write Preview
Loading…
Cancel
Save