public toBytes ( int bitOffset, byte array, int offset, int numBytes ) : void | ||
bitOffset | int | first bit to start writing |
array | byte | array to write into. Bytes are written most-significant byte first. This is the opposite /// of the internal representation, which is exposed by BitArray |
offset | int | position in array to start writing |
numBytes | int | how many bytes to write |
Résultat | void |
/// <summary> /// Interleave "bits" with corresponding error correction bytes. On success, store the result in /// "result". The interleave rule is complicated. See 8.6 of JISX0510:2004 (p.37) for details. /// </summary> /// <param name="bits">The bits.</param> /// <param name="numTotalBytes">The num total bytes.</param> /// <param name="numDataBytes">The num data bytes.</param> /// <param name="numRSBlocks">The num RS blocks.</param> /// <returns></returns> internal static BitArray interleaveWithECBytes(BitArray bits, int numTotalBytes, int numDataBytes, int numRSBlocks) { // "bits" must have "getNumDataBytes" bytes of data. if (bits.SizeInBytes != numDataBytes) { throw new WriterException("Number of bits and data bytes does not match"); } // Step 1. Divide data bytes into blocks and generate error correction bytes for them. We'll // store the divided data bytes blocks and error correction bytes blocks into "blocks". int dataBytesOffset = 0; int maxNumDataBytes = 0; int maxNumEcBytes = 0; // Since, we know the number of reedsolmon blocks, we can initialize the vector with the number. var blocks = new List<BlockPair>(numRSBlocks); for (int i = 0; i < numRSBlocks; ++i) { int[] numDataBytesInBlock = new int[1]; int[] numEcBytesInBlock = new int[1]; getNumDataBytesAndNumECBytesForBlockID( numTotalBytes, numDataBytes, numRSBlocks, i, numDataBytesInBlock, numEcBytesInBlock); int size = numDataBytesInBlock[0]; byte[] dataBytes = new byte[size]; bits.toBytes(8 * dataBytesOffset, dataBytes, 0, size); byte[] ecBytes = generateECBytes(dataBytes, numEcBytesInBlock[0]); blocks.Add(new BlockPair(dataBytes, ecBytes)); maxNumDataBytes = Math.Max(maxNumDataBytes, size); maxNumEcBytes = Math.Max(maxNumEcBytes, ecBytes.Length); dataBytesOffset += numDataBytesInBlock[0]; } if (numDataBytes != dataBytesOffset) { throw new WriterException("Data bytes does not match offset"); } BitArray result = new BitArray(); // First, place data blocks. for (int i = 0; i < maxNumDataBytes; ++i) { foreach (BlockPair block in blocks) { byte[] dataBytes = block.DataBytes; if (i < dataBytes.Length) { result.appendBits(dataBytes[i], 8); } } } // Then, place error correction blocks. for (int i = 0; i < maxNumEcBytes; ++i) { foreach (BlockPair block in blocks) { byte[] ecBytes = block.ErrorCorrectionBytes; if (i < ecBytes.Length) { result.appendBits(ecBytes[i], 8); } } } if (numTotalBytes != result.SizeInBytes) { // Should be same. throw new WriterException("Interleaving error: " + numTotalBytes + " and " + result.SizeInBytes + " differ."); } return result; }
private static BitArray interleaveWithECBytes(BitArray bits, int numTotalBytes, int numDataBytes, int numRSBlocks) { // Step 1. Divide data bytes into blocks and generate error correction bytes for them. We'll // store the divided data bytes blocks and error correction bytes blocks into "blocks". int dataBytesOffset = 0; int maxNumDataBytes = 0; int maxNumEcBytes = 0; // Since, we know the number of reedsolmon blocks, we can initialize the vector with the number. var blocks = new List<Tuple<byte[], byte[]>>(numRSBlocks); for (int i = 0; i < numRSBlocks; ++i) { int numDataBytesInBlock; int numEcBytesInBlock; getNumDataBytesAndNumECBytesForBlockID( numTotalBytes, numDataBytes, numRSBlocks, i, out numDataBytesInBlock, out numEcBytesInBlock); byte[] dataBytes = new byte[numDataBytesInBlock]; bits.toBytes(8 * dataBytesOffset, dataBytes, 0, numDataBytesInBlock); byte[] ecBytes = generateECBytes(dataBytes, numEcBytesInBlock); blocks.Add(new Tuple<byte[], byte[]>(dataBytes, ecBytes)); maxNumDataBytes = Math.Max(maxNumDataBytes, numDataBytesInBlock); maxNumEcBytes = Math.Max(maxNumEcBytes, ecBytes.Length); dataBytesOffset += numEcBytesInBlock; } BitArray result = new BitArray(); // First, place data blocks. for (int i = 0; i < maxNumDataBytes; ++i) { foreach (Tuple<byte[], byte[]> block in blocks) { byte[] dataBytes = block.Item1; if (i < dataBytes.Length) { result.appendBits(dataBytes[i], 8); } } } // Then, place error correction blocks. for (int i = 0; i < maxNumEcBytes; ++i) { foreach (Tuple<byte[], byte[]> block in blocks) { byte[] ecBytes = block.Item2; if (i < ecBytes.Length) { result.appendBits(ecBytes[i], 8); } } } return result; }