public void SetComponent(int componentIndex, ReadOnlySpan <byte> quantizationTableBytes, ReadOnlySpan <byte> dcTableBytes, ReadOnlySpan <byte> acTableBytes)
{
// Build quantization table.
ushort[] quantizationTableElements = new ushort[64];
for (int i = 0; i < quantizationTableElements.Length; i++)
{
quantizationTableElements[i] = quantizationTableBytes[i];
}
var quantizationTable = new JpegQuantizationTable(0, (byte)componentIndex, quantizationTableElements);
// Build DC Table
int bytesConsumed = 0;
if (!JpegHuffmanDecodingTable.TryParse(0, (byte)componentIndex, dcTableBytes, out JpegHuffmanDecodingTable? dcTable, ref bytesConsumed))
{
throw new InvalidDataException("Corrupted DC table is encountered.");
}
// Build AC Table
if (!JpegHuffmanDecodingTable.TryParse(1, (byte)componentIndex, acTableBytes, out JpegHuffmanDecodingTable? acTable, ref bytesConsumed))
{
throw new InvalidDataException("Corrupted DC table is encountered.");
}
_components[componentIndex] = new ComponentInfo(quantizationTable, dcTable, acTable);
}
public ComponentInfo(JpegQuantizationTable quantizationTable, JpegHuffmanDecodingTable dcTable, JpegHuffmanDecodingTable acTable)
{
IsInitialized = true;
QuantizationTable = quantizationTable;
DcTable = dcTable;
AcTable = acTable;
}
private static int ReadSampleLossless(ref JpegBitReader reader, JpegHuffmanDecodingTable losslessTable)
{
int t = DecodeHuffmanCode(ref reader, losslessTable);
if (t == 16)
{
t = 32768;
}
else if (t != 0)
{
t = ReceiveAndExtend(ref reader, t);
}
return(t);
}
public override void ProcessScan(ref JpegReader reader, JpegScanHeader scanHeader)
{
if (scanHeader.Components is null)
{
throw new InvalidOperationException();
}
if (Decoder.GetOutputWriter() is null)
{
throw new InvalidOperationException();
}
// Resolve each component
Span <JpegHuffmanDecodingComponent> components = _components.AsSpan(0, InitDecodeComponents(_frameHeader, scanHeader, _components));
foreach (JpegHuffmanDecodingComponent component in components)
{
if (component.DcTable is null)
{
ThrowInvalidDataException($"Huffman table of component {component.ComponentIndex} is not defined.");
}
}
JpegPartialScanlineAllocator allocator = _allocator;
int mcusPerLine = _mcusPerLine;
int mcusPerColumn = _mcusPerColumn;
// Prepare
JpegBitReader bitReader = new JpegBitReader(reader.RemainingBytes);
int restartInterval = _restartInterval;
int mcusBeforeRestart = restartInterval;
int predictor = scanHeader.StartOfSpectralSelection;
int initialPrediction = 1 << (_frameHeader.SamplePrecision - scanHeader.SuccessiveApproximationBitPositionLow - 1);
for (int rowMcu = 0; rowMcu < mcusPerColumn; rowMcu++)
{
for (int colMcu = 0; colMcu < mcusPerLine; colMcu++)
{
// Scan an interleaved mcu... process components in order
foreach (JpegHuffmanDecodingComponent component in components)
{
int index = component.ComponentIndex;
JpegHuffmanDecodingTable losslessTable = component.DcTable !;
int h = component.HorizontalSamplingFactor;
int v = component.VerticalSamplingFactor;
int offsetX = colMcu * h;
int offsetY = rowMcu * v;
for (int y = 0; y < v; y++)
{
Span <short> scanline = allocator.GetScanlineSpan(index, offsetY + y);
Span <short> lastScanline = (y == 0 && rowMcu == 0) ? default : allocator.GetScanlineSpan(index, offsetY + y - 1);
for (int x = 0; x < h; x++)
{
int diffValue = ReadSampleLossless(ref bitReader, losslessTable);
// The one-dimensional horizontal predictor (prediction sample Ra) is used
// for the first line of samples at the start of the scan and at the beginning of each restart interval
if (rowMcu == 0 || (restartInterval > 0 && mcusBeforeRestart == restartInterval))
{
// At the beginning of the first line and at the beginning of each restart interval the prediction value of 2^(P – 1) is used, where P is the input precision.
// If the point transformation parameter (see A.4) is non-zero, the prediction value at the beginning of the first lines and the beginning of each restart interval is 2^(P – Pt – 1), where Pt is the value of the point transformation parameter.
if (colMcu == 0 && x == 0)
{
diffValue += initialPrediction;
}
else
{
int ra = scanline[offsetX + x - 1];
int rb = y == 0 ? initialPrediction : lastScanline[offsetX + x];
int rc = y == 0 ? initialPrediction : lastScanline[offsetX + x - 1];
diffValue += predictor switch
{
1 => ra, // Px = Ra
2 => rb, // Px = Rb
3 => rc, // Px = Rc
4 => ra + rb - rc, // Px = Ra + Rb – Rc
5 => ra + ((rb - rc) >> 1), // Px = Ra + (Rb – Rc)/2
6 => rb + ((ra - rc) >> 1), // Px = Rb + (Ra – Rc)/2
7 => (ra + rb) >> 1, // Px = (Ra + Rb)/2
_ => 0, // No prediction (See Annex J)
};
}
}
// The sample from the line above(prediction sample Rb) is used at the start of each line, except for the first line
else if (colMcu == 0)
{
diffValue += lastScanline[offsetX + x];
}
else
{
diffValue += predictor switch
{
1 => scanline[offsetX + x - 1], // Px = Ra
2 => lastScanline[offsetX + x], // Px = Rb
3 => lastScanline[offsetX + x - 1], // Px = Rc
4 => scanline[offsetX + x - 1] + lastScanline[offsetX + x] - lastScanline[offsetX + x - 1], // Px = Ra + Rb – Rc
5 => scanline[offsetX + x - 1] + ((lastScanline[offsetX + x] - lastScanline[offsetX + x - 1]) >> 1), // Px = Ra + (Rb – Rc)/2
6 => lastScanline[offsetX + x] + ((scanline[offsetX + x - 1] - lastScanline[offsetX + x - 1]) >> 1), // Px = Rb + (Ra – Rc)/2
7 => (scanline[offsetX + x - 1] + lastScanline[offsetX + x]) >> 1, // Px = (Ra + Rb)/2
_ => 0, // No prediction (See Annex J)
};
}
scanline[offsetX + x] = (short)diffValue;
}
}
}
// Handle restart
if (restartInterval > 0 && (--mcusBeforeRestart) == 0)
{
bitReader.AdvanceAlignByte();
JpegMarker marker = bitReader.TryReadMarker();
if (marker == JpegMarker.EndOfImage)
{
int bytesConsumedEoi = reader.RemainingByteCount - bitReader.RemainingBits / 8;
reader.TryAdvance(bytesConsumedEoi - 2);
return;
}
if (!marker.IsRestartMarker())
{
throw new InvalidOperationException("Expect restart marker.");
}
mcusBeforeRestart = restartInterval;
}
}
// Flush allocator
if (rowMcu == mcusPerColumn - 1)
{
foreach (JpegHuffmanDecodingComponent component in components)
{
allocator.FlushLastMcu(component.ComponentIndex, (rowMcu + 1) * component.VerticalSamplingFactor);
}
}
else
{
foreach (JpegHuffmanDecodingComponent component in components)
{
allocator.FlushMcu(component.ComponentIndex, (rowMcu + 1) * component.VerticalSamplingFactor);
}
}
}
bitReader.AdvanceAlignByte();
int bytesConsumed = reader.RemainingByteCount - bitReader.RemainingBits / 8;
if (bitReader.TryPeekMarker() != 0)
{
if (!bitReader.TryPeekMarker().IsRestartMarker())
{
bytesConsumed -= 2;
}
}
reader.TryAdvance(bytesConsumed);
}
