public OverrideByteSymbolCodeValuesBitIterator(CodeSymbolCode <T> setOriginalCode, int[] setNewValues) { this.bitPosition = 0; this.bitCount = setOriginalCode.BitCount; this.originalCode = setOriginalCode; this.newValues = setNewValues; }
private void ParseEncodingMessage(IBitIterator it, MessageMode mode) { if (!it.EndReached) { this.charCountIndicatorSymbolCode = CodeSymbolCode <CharCountIndicatorSymbol> .BuildInstance(it, new CharCountIndicatorSymbolFactory(mode)); this.characterCount = charCountIndicatorSymbolCode.GetSymbolAt(0).GetCharacterCount(); if (!it.EndReached) { switch (mode.Mode) { case MessageMode.EncodingMode.Byte: this.Message = CodeSymbolCode <ByteEncodingSymbol> .BuildInstance(it, new ByteEncodingSymbolFactory(characterCount)); break; case MessageMode.EncodingMode.Alphanumeric: this.Message = CodeSymbolCode <AlphaNumericEncodingSymbol> .BuildInstance(it, new AlphaNumericEncodingSymbolFactory(characterCount)); break; case MessageMode.EncodingMode.Numeric: this.Message = CodeSymbolCode <NumericEncodingSymbol> .BuildInstance(it, new NumericEncodingSymbolFactory(characterCount)); break; default: throw new NotImplementedException($"{mode.Mode} decoding not implemented"); } } } }
private static int[] ConvertToIntArray(CodeSymbolCode <RawCodeByte> code) { var symbolsAsInts = new int[code.SymbolCount]; for (int i = 0; i < code.SymbolCount; i++) { code.GetSymbolAt(i).TryGetAsByte(out var symbolAsByte); symbolsAsInts[i] = symbolAsByte; } return(symbolsAsInts); }
private void RepairBlock() { int[] dataWithECC = new int[this.preRepairData.SymbolCount + this.preRepairECC.SymbolCount]; ECCBlock.ConvertToIntArray(preRepairData).CopyTo(dataWithECC, 0); ECCBlock.ConvertToIntArray(preRepairECC).CopyTo(dataWithECC, this.preRepairData.SymbolCount); var rsDecoder = new ReedSolomonDecoder(GenericGF.QR_CODE_FIELD_256); this.RepairSuccess = rsDecoder.decode(dataWithECC, this.preRepairECC.SymbolCount); if (dataWithECC.All(x => x == 0)) // TODO determine better way to detect zeroing out of block { this.RepairSuccess = false; } if (this.RepairSuccess) { var dataArr = new int[this.preRepairData.SymbolCount]; var eccArr = new int[this.preRepairECC.SymbolCount]; Array.Copy(dataWithECC, 0, dataArr, 0, dataArr.Length); Array.Copy(dataWithECC, dataArr.Length, eccArr, 0, eccArr.Length); var dataIt = new OverrideByteSymbolCodeValuesBitIterator <RawCodeByte>(this.preRepairData, dataArr); var eccIt = new OverrideByteSymbolCodeValuesBitIterator <RawCodeByte>(this.preRepairECC, eccArr); var factory = new RawCodeByteFactory(); this.postRepairData = CodeSymbolCode <RawCodeByte> .BuildInstance(dataIt, factory); this.postRepairECC = CodeSymbolCode <RawCodeByte> .BuildInstance(eccIt, factory); } else { this.postRepairData = this.preRepairData; this.postRepairECC = this.preRepairECC; } }
internal EncodedMessage(IBitIterator it, MessageMode setMode, CodeSymbolCode <MessageModeSymbol> setMessageModeSymbolCode) { this.MessageModeSymbolCode = setMessageModeSymbolCode; this.mode = setMode; this.ParseEncodingMessage(it, mode); }
internal ECCBlock(CodeSymbolCode <RawCodeByte> _preRepairData, CodeSymbolCode <RawCodeByte> _preRepairECC) { this.preRepairData = _preRepairData; this.preRepairECC = _preRepairECC; this.RepairBlock(); }
public static List <ECCBlock> DeInterleave(CodeSymbolCode <RawCodeByte> interleavedCode, ErrorCorrectionLevel eccLevel) { // a block consists of data and ecc codewords for that block // blocks are in groups of blocks with the same amount of data codewords (max 2 groups) // blocks for all groups have the same amount of ecc codewords // the number of data codewords can differ between groups but not between blocks of a group var eccGroups = eccLevel.GetECCGroups(); int numberOfGroups = eccGroups.Length; uint numberOfBlocks = 0; uint numberOfRawCodeBytes = 0; foreach (ECCGroupInfo g in eccGroups) { numberOfBlocks += g.NumberOfBlocks; numberOfRawCodeBytes += g.NumberOfBlocks * (g.DataBytesPerBlock + eccLevel.ECCBytesPerBlock); } if (interleavedCode.SymbolCount != numberOfRawCodeBytes) { throw new ArgumentException("Invalid number of symbols in interleaved code."); } uint largestBlockLength = 0; foreach (ECCGroupInfo g in eccGroups) { largestBlockLength = Math.Max(largestBlockLength, g.DataBytesPerBlock); } var dataCodewords = new RawCodeByte[numberOfBlocks, largestBlockLength]; var eccCodewords = new RawCodeByte[numberOfBlocks, eccLevel.ECCBytesPerBlock]; int pos = 0; // position in interleavedCode // generate data block code for (int j = 0; j < largestBlockLength; j++) // for each symbol in block { for (int i = 0; i < numberOfBlocks; i++) // for each block { if (j < DeInterleaver.GetBlockLength(i, eccGroups)) // skip block if it is already full { dataCodewords[i, j] = interleavedCode.GetSymbolAt(pos++); System.Diagnostics.Debug.Assert(dataCodewords[i, j] != null); } } } // generate ecc block code for (int j = 0; j < eccLevel.ECCBytesPerBlock; j++) // for each symbol in block { for (int i = 0; i < numberOfBlocks; i++) // for each block { eccCodewords[i, j] = interleavedCode.GetSymbolAt(pos++); } } var eccBlockList = new List <ECCBlock>(); int absBlockNo = 0; for (int g = 0; g < eccGroups.Length; g++) // group { for (int b = 0; b < eccGroups[g].NumberOfBlocks; b++) // block { var blockData = new List <RawCodeByte>(); var blockECC = new List <RawCodeByte>(); for (int s = 0; s < eccGroups[g].DataBytesPerBlock; s++) // data symbol { blockData.Add(dataCodewords[absBlockNo, s]); } for (int e = 0; e < eccLevel.ECCBytesPerBlock; e++) // ecc symbol { blockECC.Add(eccCodewords[absBlockNo, e]); } eccBlockList.Add(new ECCBlock(new CodeSymbolCode <RawCodeByte>(blockData), new CodeSymbolCode <RawCodeByte>(blockECC))); absBlockNo++; } } return(eccBlockList); }