mirror of
https://github.com/zxing/zxing.git
synced 2024-09-22 06:27:35 -07:00
7616c4d06d
git-svn-id: https://zxing.googlecode.com/svn/trunk@2558 59b500cc-1b3d-0410-9834-0bbf25fbcc57
644 lines
18 KiB
C#
Executable file
644 lines
18 KiB
C#
Executable file
using System;
|
|
using System.Collections.Generic;
|
|
using System.Text;
|
|
using com.google.zxing.common;
|
|
|
|
/*
|
|
* Copyright 2008 ZXing authors
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
namespace com.google.zxing.datamatrix.decoder
|
|
{
|
|
|
|
using FormatException = com.google.zxing.FormatException;
|
|
using BitSource = com.google.zxing.common.BitSource;
|
|
using DecoderResult = com.google.zxing.common.DecoderResult;
|
|
|
|
|
|
/// <summary>
|
|
/// <p>Data Matrix Codes can encode text as bits in one of several modes, and can use multiple modes
|
|
/// in one Data Matrix Code. This class decodes the bits back into text.</p>
|
|
///
|
|
/// <p>See ISO 16022:2006, 5.2.1 - 5.2.9.2</p>
|
|
///
|
|
/// @author bbrown@google.com (Brian Brown)
|
|
/// @author Sean Owen
|
|
/// </summary>
|
|
internal sealed class DecodedBitStreamParser
|
|
{
|
|
|
|
private enum Mode
|
|
{
|
|
PAD_ENCODE, // Not really a mode
|
|
ASCII_ENCODE,
|
|
C40_ENCODE,
|
|
TEXT_ENCODE,
|
|
ANSIX12_ENCODE,
|
|
EDIFACT_ENCODE,
|
|
BASE256_ENCODE
|
|
}
|
|
|
|
/// <summary>
|
|
/// See ISO 16022:2006, Annex C Table C.1
|
|
/// The C40 Basic Character Set (*'s used for placeholders for the shift values)
|
|
/// </summary>
|
|
private static readonly char[] C40_BASIC_SET_CHARS = {'*', '*', '*', ' ', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
|
|
|
|
private static readonly char[] C40_SHIFT2_SET_CHARS = {'!', '"', '#', '$', '%', '&', '\'', '(', ')', '*', '+', ',', '-', '.', '/', ':', ';', '<', '=', '>', '?', '@', '[', '\\', ']', '^', '_'};
|
|
|
|
/// <summary>
|
|
/// See ISO 16022:2006, Annex C Table C.2
|
|
/// The Text Basic Character Set (*'s used for placeholders for the shift values)
|
|
/// </summary>
|
|
private static readonly char[] TEXT_BASIC_SET_CHARS = {'*', '*', '*', ' ', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
|
|
|
|
private static readonly char[] TEXT_SHIFT3_SET_CHARS = {'\'', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '{', '|', '}', '~', (char) 127};
|
|
|
|
private DecodedBitStreamParser()
|
|
{
|
|
}
|
|
|
|
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
|
|
//ORIGINAL LINE: static com.google.zxing.common.DecoderResult decode(byte[] bytes) throws com.google.zxing.FormatException
|
|
internal static DecoderResult decode(sbyte[] bytes)
|
|
{
|
|
BitSource bits = new BitSource(bytes);
|
|
StringBuilder result = new StringBuilder(100);
|
|
StringBuilder resultTrailer = new StringBuilder(0);
|
|
IList<sbyte[]> byteSegments = new List<sbyte[]>(1);
|
|
Mode mode = Mode.ASCII_ENCODE;
|
|
do
|
|
{
|
|
if (mode == Mode.ASCII_ENCODE)
|
|
{
|
|
mode = decodeAsciiSegment(bits, result, resultTrailer);
|
|
}
|
|
else
|
|
{
|
|
switch (mode)
|
|
{
|
|
case com.google.zxing.datamatrix.decoder.DecodedBitStreamParser.Mode.C40_ENCODE:
|
|
decodeC40Segment(bits, result);
|
|
break;
|
|
case com.google.zxing.datamatrix.decoder.DecodedBitStreamParser.Mode.TEXT_ENCODE:
|
|
decodeTextSegment(bits, result);
|
|
break;
|
|
case com.google.zxing.datamatrix.decoder.DecodedBitStreamParser.Mode.ANSIX12_ENCODE:
|
|
decodeAnsiX12Segment(bits, result);
|
|
break;
|
|
case com.google.zxing.datamatrix.decoder.DecodedBitStreamParser.Mode.EDIFACT_ENCODE:
|
|
decodeEdifactSegment(bits, result);
|
|
break;
|
|
case com.google.zxing.datamatrix.decoder.DecodedBitStreamParser.Mode.BASE256_ENCODE:
|
|
decodeBase256Segment(bits, result, byteSegments);
|
|
break;
|
|
default:
|
|
throw FormatException.FormatInstance;
|
|
}
|
|
mode = Mode.ASCII_ENCODE;
|
|
}
|
|
} while (mode != Mode.PAD_ENCODE && bits.available() > 0);
|
|
if (resultTrailer.Length > 0)
|
|
{
|
|
result.Append(resultTrailer.ToString());
|
|
}
|
|
return new DecoderResult(bytes, result.ToString(), byteSegments.Count == 0 ? null : byteSegments, null);
|
|
}
|
|
|
|
/// <summary>
|
|
/// See ISO 16022:2006, 5.2.3 and Annex C, Table C.2
|
|
/// </summary>
|
|
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
|
|
//ORIGINAL LINE: private static Mode decodeAsciiSegment(com.google.zxing.common.BitSource bits, StringBuilder result, StringBuilder resultTrailer) throws com.google.zxing.FormatException
|
|
private static Mode decodeAsciiSegment(BitSource bits, StringBuilder result, StringBuilder resultTrailer)
|
|
{
|
|
bool upperShift = false;
|
|
do
|
|
{
|
|
int oneByte = bits.readBits(8);
|
|
if (oneByte == 0)
|
|
{
|
|
throw FormatException.FormatInstance;
|
|
} // ASCII data (ASCII value + 1)
|
|
else if (oneByte <= 128)
|
|
{
|
|
if (upperShift)
|
|
{
|
|
oneByte += 128;
|
|
//upperShift = false;
|
|
}
|
|
result.Append((char)(oneByte - 1));
|
|
return Mode.ASCII_ENCODE;
|
|
} // Pad
|
|
else if (oneByte == 129)
|
|
{
|
|
return Mode.PAD_ENCODE;
|
|
} // 2-digit data 00-99 (Numeric Value + 130)
|
|
else if (oneByte <= 229)
|
|
{
|
|
int value = oneByte - 130;
|
|
if (value < 10) // padd with '0' for single digit values
|
|
{
|
|
result.Append('0');
|
|
}
|
|
result.Append(value);
|
|
} // Latch to C40 encodation
|
|
else if (oneByte == 230)
|
|
{
|
|
return Mode.C40_ENCODE;
|
|
} // Latch to Base 256 encodation
|
|
else if (oneByte == 231)
|
|
{
|
|
return Mode.BASE256_ENCODE;
|
|
}
|
|
else if (oneByte == 232)
|
|
{
|
|
// FNC1
|
|
result.Append((char) 29); // translate as ASCII 29
|
|
}
|
|
else if (oneByte == 233 || oneByte == 234)
|
|
{
|
|
// Structured Append, Reader Programming
|
|
// Ignore these symbols for now
|
|
//throw ReaderException.getInstance();
|
|
} // Upper Shift (shift to Extended ASCII)
|
|
else if (oneByte == 235)
|
|
{
|
|
upperShift = true;
|
|
} // 05 Macro
|
|
else if (oneByte == 236)
|
|
{
|
|
result.Append("[)>\u001E05\u001D");
|
|
resultTrailer.Insert(0, "\u001E\u0004");
|
|
} // 06 Macro
|
|
else if (oneByte == 237)
|
|
{
|
|
result.Append("[)>\u001E06\u001D");
|
|
resultTrailer.Insert(0, "\u001E\u0004");
|
|
} // Latch to ANSI X12 encodation
|
|
else if (oneByte == 238)
|
|
{
|
|
return Mode.ANSIX12_ENCODE;
|
|
} // Latch to Text encodation
|
|
else if (oneByte == 239)
|
|
{
|
|
return Mode.TEXT_ENCODE;
|
|
} // Latch to EDIFACT encodation
|
|
else if (oneByte == 240)
|
|
{
|
|
return Mode.EDIFACT_ENCODE;
|
|
} // ECI Character
|
|
else if (oneByte == 241)
|
|
{
|
|
// TODO(bbrown): I think we need to support ECI
|
|
//throw ReaderException.getInstance();
|
|
// Ignore this symbol for now
|
|
} // Not to be used in ASCII encodation
|
|
else if (oneByte >= 242)
|
|
{
|
|
// ... but work around encoders that end with 254, latch back to ASCII
|
|
if (oneByte != 254 || bits.available() != 0)
|
|
{
|
|
throw FormatException.FormatInstance;
|
|
}
|
|
}
|
|
} while (bits.available() > 0);
|
|
return Mode.ASCII_ENCODE;
|
|
}
|
|
|
|
/// <summary>
|
|
/// See ISO 16022:2006, 5.2.5 and Annex C, Table C.1
|
|
/// </summary>
|
|
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
|
|
//ORIGINAL LINE: private static void decodeC40Segment(com.google.zxing.common.BitSource bits, StringBuilder result) throws com.google.zxing.FormatException
|
|
private static void decodeC40Segment(BitSource bits, StringBuilder result)
|
|
{
|
|
// Three C40 values are encoded in a 16-bit value as
|
|
// (1600 * C1) + (40 * C2) + C3 + 1
|
|
// TODO(bbrown): The Upper Shift with C40 doesn't work in the 4 value scenario all the time
|
|
bool upperShift = false;
|
|
|
|
int[] cValues = new int[3];
|
|
int shift = 0;
|
|
|
|
do
|
|
{
|
|
// If there is only one byte left then it will be encoded as ASCII
|
|
if (bits.available() == 8)
|
|
{
|
|
return;
|
|
}
|
|
int firstByte = bits.readBits(8);
|
|
if (firstByte == 254) // Unlatch codeword
|
|
{
|
|
return;
|
|
}
|
|
|
|
parseTwoBytes(firstByte, bits.readBits(8), cValues);
|
|
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
int cValue = cValues[i];
|
|
switch (shift)
|
|
{
|
|
case 0:
|
|
if (cValue < 3)
|
|
{
|
|
shift = cValue + 1;
|
|
}
|
|
else if (cValue < C40_BASIC_SET_CHARS.Length)
|
|
{
|
|
char c40char = C40_BASIC_SET_CHARS[cValue];
|
|
if (upperShift)
|
|
{
|
|
result.Append((char)(c40char + 128));
|
|
upperShift = false;
|
|
}
|
|
else
|
|
{
|
|
result.Append(c40char);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
throw FormatException.FormatInstance;
|
|
}
|
|
break;
|
|
case 1:
|
|
if (upperShift)
|
|
{
|
|
result.Append((char)(cValue + 128));
|
|
upperShift = false;
|
|
}
|
|
else
|
|
{
|
|
result.Append((char) cValue);
|
|
}
|
|
shift = 0;
|
|
break;
|
|
case 2:
|
|
if (cValue < C40_SHIFT2_SET_CHARS.Length)
|
|
{
|
|
char c40char = C40_SHIFT2_SET_CHARS[cValue];
|
|
if (upperShift)
|
|
{
|
|
result.Append((char)(c40char + 128));
|
|
upperShift = false;
|
|
}
|
|
else
|
|
{
|
|
result.Append(c40char);
|
|
}
|
|
} // FNC1
|
|
else if (cValue == 27)
|
|
{
|
|
result.Append((char) 29); // translate as ASCII 29
|
|
} // Upper Shift
|
|
else if (cValue == 30)
|
|
{
|
|
upperShift = true;
|
|
}
|
|
else
|
|
{
|
|
throw FormatException.FormatInstance;
|
|
}
|
|
shift = 0;
|
|
break;
|
|
case 3:
|
|
if (upperShift)
|
|
{
|
|
result.Append((char)(cValue + 224));
|
|
upperShift = false;
|
|
}
|
|
else
|
|
{
|
|
result.Append((char)(cValue + 96));
|
|
}
|
|
shift = 0;
|
|
break;
|
|
default:
|
|
throw FormatException.FormatInstance;
|
|
}
|
|
}
|
|
} while (bits.available() > 0);
|
|
}
|
|
|
|
/// <summary>
|
|
/// See ISO 16022:2006, 5.2.6 and Annex C, Table C.2
|
|
/// </summary>
|
|
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
|
|
//ORIGINAL LINE: private static void decodeTextSegment(com.google.zxing.common.BitSource bits, StringBuilder result) throws com.google.zxing.FormatException
|
|
private static void decodeTextSegment(BitSource bits, StringBuilder result)
|
|
{
|
|
// Three Text values are encoded in a 16-bit value as
|
|
// (1600 * C1) + (40 * C2) + C3 + 1
|
|
// TODO(bbrown): The Upper Shift with Text doesn't work in the 4 value scenario all the time
|
|
bool upperShift = false;
|
|
|
|
int[] cValues = new int[3];
|
|
int shift = 0;
|
|
do
|
|
{
|
|
// If there is only one byte left then it will be encoded as ASCII
|
|
if (bits.available() == 8)
|
|
{
|
|
return;
|
|
}
|
|
int firstByte = bits.readBits(8);
|
|
if (firstByte == 254) // Unlatch codeword
|
|
{
|
|
return;
|
|
}
|
|
|
|
parseTwoBytes(firstByte, bits.readBits(8), cValues);
|
|
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
int cValue = cValues[i];
|
|
switch (shift)
|
|
{
|
|
case 0:
|
|
if (cValue < 3)
|
|
{
|
|
shift = cValue + 1;
|
|
}
|
|
else if (cValue < TEXT_BASIC_SET_CHARS.Length)
|
|
{
|
|
char textChar = TEXT_BASIC_SET_CHARS[cValue];
|
|
if (upperShift)
|
|
{
|
|
result.Append((char)(textChar + 128));
|
|
upperShift = false;
|
|
}
|
|
else
|
|
{
|
|
result.Append(textChar);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
throw FormatException.FormatInstance;
|
|
}
|
|
break;
|
|
case 1:
|
|
if (upperShift)
|
|
{
|
|
result.Append((char)(cValue + 128));
|
|
upperShift = false;
|
|
}
|
|
else
|
|
{
|
|
result.Append((char) cValue);
|
|
}
|
|
shift = 0;
|
|
break;
|
|
case 2:
|
|
// Shift 2 for Text is the same encoding as C40
|
|
if (cValue < C40_SHIFT2_SET_CHARS.Length)
|
|
{
|
|
char c40char = C40_SHIFT2_SET_CHARS[cValue];
|
|
if (upperShift)
|
|
{
|
|
result.Append((char)(c40char + 128));
|
|
upperShift = false;
|
|
}
|
|
else
|
|
{
|
|
result.Append(c40char);
|
|
}
|
|
} // FNC1
|
|
else if (cValue == 27)
|
|
{
|
|
result.Append((char) 29); // translate as ASCII 29
|
|
} // Upper Shift
|
|
else if (cValue == 30)
|
|
{
|
|
upperShift = true;
|
|
}
|
|
else
|
|
{
|
|
throw FormatException.FormatInstance;
|
|
}
|
|
shift = 0;
|
|
break;
|
|
case 3:
|
|
if (cValue < TEXT_SHIFT3_SET_CHARS.Length)
|
|
{
|
|
char textChar = TEXT_SHIFT3_SET_CHARS[cValue];
|
|
if (upperShift)
|
|
{
|
|
result.Append((char)(textChar + 128));
|
|
upperShift = false;
|
|
}
|
|
else
|
|
{
|
|
result.Append(textChar);
|
|
}
|
|
shift = 0;
|
|
}
|
|
else
|
|
{
|
|
throw FormatException.FormatInstance;
|
|
}
|
|
break;
|
|
default:
|
|
throw FormatException.FormatInstance;
|
|
}
|
|
}
|
|
} while (bits.available() > 0);
|
|
}
|
|
|
|
/// <summary>
|
|
/// See ISO 16022:2006, 5.2.7
|
|
/// </summary>
|
|
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
|
|
//ORIGINAL LINE: private static void decodeAnsiX12Segment(com.google.zxing.common.BitSource bits, StringBuilder result) throws com.google.zxing.FormatException
|
|
private static void decodeAnsiX12Segment(BitSource bits, StringBuilder result)
|
|
{
|
|
// Three ANSI X12 values are encoded in a 16-bit value as
|
|
// (1600 * C1) + (40 * C2) + C3 + 1
|
|
|
|
int[] cValues = new int[3];
|
|
do
|
|
{
|
|
// If there is only one byte left then it will be encoded as ASCII
|
|
if (bits.available() == 8)
|
|
{
|
|
return;
|
|
}
|
|
int firstByte = bits.readBits(8);
|
|
if (firstByte == 254) // Unlatch codeword
|
|
{
|
|
return;
|
|
}
|
|
|
|
parseTwoBytes(firstByte, bits.readBits(8), cValues);
|
|
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
int cValue = cValues[i];
|
|
if (cValue == 0) // X12 segment terminator <CR>
|
|
{
|
|
result.Append('\r');
|
|
} // X12 segment separator *
|
|
else if (cValue == 1)
|
|
{
|
|
result.Append('*');
|
|
} // X12 sub-element separator >
|
|
else if (cValue == 2)
|
|
{
|
|
result.Append('>');
|
|
} // space
|
|
else if (cValue == 3)
|
|
{
|
|
result.Append(' ');
|
|
} // 0 - 9
|
|
else if (cValue < 14)
|
|
{
|
|
result.Append((char)(cValue + 44));
|
|
} // A - Z
|
|
else if (cValue < 40)
|
|
{
|
|
result.Append((char)(cValue + 51));
|
|
}
|
|
else
|
|
{
|
|
throw FormatException.FormatInstance;
|
|
}
|
|
}
|
|
} while (bits.available() > 0);
|
|
}
|
|
|
|
private static void parseTwoBytes(int firstByte, int secondByte, int[] result)
|
|
{
|
|
int fullBitValue = (firstByte << 8) + secondByte - 1;
|
|
int temp = fullBitValue / 1600;
|
|
result[0] = temp;
|
|
fullBitValue -= temp * 1600;
|
|
temp = fullBitValue / 40;
|
|
result[1] = temp;
|
|
result[2] = fullBitValue - temp * 40;
|
|
}
|
|
|
|
/// <summary>
|
|
/// See ISO 16022:2006, 5.2.8 and Annex C Table C.3
|
|
/// </summary>
|
|
private static void decodeEdifactSegment(BitSource bits, StringBuilder result)
|
|
{
|
|
do
|
|
{
|
|
// If there is only two or less bytes left then it will be encoded as ASCII
|
|
if (bits.available() <= 16)
|
|
{
|
|
return;
|
|
}
|
|
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
int edifactValue = bits.readBits(6);
|
|
|
|
// Check for the unlatch character
|
|
if (edifactValue == 0x1F) // 011111
|
|
{
|
|
// Read rest of byte, which should be 0, and stop
|
|
int bitsLeft = 8 - bits.BitOffset;
|
|
if (bitsLeft != 8)
|
|
{
|
|
bits.readBits(bitsLeft);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if ((edifactValue & 0x20) == 0) // no 1 in the leading (6th) bit
|
|
{
|
|
edifactValue |= 0x40; // Add a leading 01 to the 6 bit binary value
|
|
}
|
|
result.Append((char) edifactValue);
|
|
}
|
|
} while (bits.available() > 0);
|
|
}
|
|
|
|
/// <summary>
|
|
/// See ISO 16022:2006, 5.2.9 and Annex B, B.2
|
|
/// </summary>
|
|
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
|
|
//ORIGINAL LINE: private static void decodeBase256Segment(com.google.zxing.common.BitSource bits, StringBuilder result, java.util.Collection<byte[]> byteSegments) throws com.google.zxing.FormatException
|
|
private static void decodeBase256Segment(BitSource bits, StringBuilder result, ICollection<sbyte[]> byteSegments)
|
|
{
|
|
// Figure out how long the Base 256 Segment is.
|
|
int codewordPosition = 1 + bits.ByteOffset; // position is 1-indexed
|
|
int d1 = unrandomize255State(bits.readBits(8), codewordPosition++);
|
|
int count;
|
|
if (d1 == 0) // Read the remainder of the symbol
|
|
{
|
|
count = bits.available() / 8;
|
|
}
|
|
else if (d1 < 250)
|
|
{
|
|
count = d1;
|
|
}
|
|
else
|
|
{
|
|
count = 250 * (d1 - 249) + unrandomize255State(bits.readBits(8), codewordPosition++);
|
|
}
|
|
|
|
// We're seeing NegativeArraySizeException errors from users.
|
|
if (count < 0)
|
|
{
|
|
throw FormatException.FormatInstance;
|
|
}
|
|
|
|
sbyte[] bytes = new sbyte[count];
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
// Have seen this particular error in the wild, such as at
|
|
// http://www.bcgen.com/demo/IDAutomationStreamingDataMatrix.aspx?MODE=3&D=Fred&PFMT=3&PT=F&X=0.3&O=0&LM=0.2
|
|
if (bits.available() < 8)
|
|
{
|
|
throw FormatException.FormatInstance;
|
|
}
|
|
bytes[i] = (sbyte) unrandomize255State(bits.readBits(8), codewordPosition++);
|
|
}
|
|
byteSegments.Add(bytes);
|
|
try
|
|
{
|
|
//result.Append(new string(bytes, "ISO8859_1"));
|
|
result.Append(GetEncodedStringFromBuffer(bytes, "ISO-8859-1"));
|
|
}
|
|
catch (System.IO.IOException uee)
|
|
{
|
|
throw new InvalidOperationException("Platform does not support required encoding: " + uee);
|
|
}
|
|
}
|
|
private static string GetEncodedStringFromBuffer(sbyte[] buffer, string encoding)
|
|
{
|
|
byte[] bytes = buffer.ToBytes();
|
|
Encoding en = Encoding.GetEncoding(encoding);
|
|
return en.GetString(bytes);
|
|
}
|
|
|
|
/// <summary>
|
|
/// See ISO 16022:2006, Annex B, B.2
|
|
/// </summary>
|
|
private static int unrandomize255State(int randomizedBase256Codeword, int base256CodewordPosition)
|
|
{
|
|
int pseudoRandomNumber = ((149 * base256CodewordPosition) % 255) + 1;
|
|
int tempVariable = randomizedBase256Codeword - pseudoRandomNumber;
|
|
return tempVariable >= 0 ? tempVariable : tempVariable + 256;
|
|
}
|
|
|
|
}
|
|
|
|
} |