Update

Author: Shane32

QRCoder/QRCodeGenerator.CodewordBlock.cs

@@ -13,24 +13,16 @@ private struct CodewordBlock
             /// <summary>
             /// Initializes a new instance of the CodewordBlock struct with specified arrays of code words and error correction (ECC) words.
             /// </summary>
-            /// <param name="codeWords">The array of data codewords for this block. Data codewords carry the actual information.</param>
+            /// <param name="codeWordsOffset">The offset of the data codewords within the main BitArray. Data codewords carry the actual information.</param>
+            /// <param name="codeWordsLength">The length in bits of the data codewords within the main BitArray.</param>
             /// <param name="eccWords">The array of error correction codewords for this block. These codewords help recover the data if the QR code is damaged.</param>
-            public CodewordBlock(/* byte[] codeWordsArray, */ BitArray codeWords, int codeWordsOffset, int codeWordsLength, byte[] eccWords)
+            public CodewordBlock(int codeWordsOffset, int codeWordsLength, byte[] eccWords)
             {
-                //this.CodeWordsArray = codeWordsArray;
-                this.CodeWords = codeWords;
                 this.CodeWordsOffset = codeWordsOffset;
                 this.CodeWordsLength = codeWordsLength;
                 this.ECCWords = eccWords;
             }
 
-            //public byte[] CodeWordsArray { get; }
-
-            /// <summary>
-            /// Gets the data codewords associated with this block. 
-            /// </summary>
-            public BitArray CodeWords { get; }
-
             /// <summary>
             /// Gets the offset of the data codewords in the BitArray.
             /// </summary>

QRCoder/QRCodeGenerator.cs

@@ -253,7 +253,7 @@ private static QRCodeData GenerateQrCode(BitArray bitArray, ECCLevel eccLevel, i
                 foreach (var codeBlock in codeWordWithECC)
                 {
                     if (codeBlock.CodeWordsLength / 8 > i)
-                        pos = codeBlock.CodeWords.CopyTo(i * 8 + codeBlock.CodeWordsOffset, interleavedData, pos, 8);
+                        pos = bitArray.CopyTo(i * 8 + codeBlock.CodeWordsOffset, interleavedData, pos, 8);
                 }
             }
             for (var i = 0; i < eccInfo.ECCPerBlock; i++)
@@ -292,11 +292,9 @@ void AddCodeWordBlocks(int blockNum, int blocksInGroup, int codewordsInGroup, Bi
                 var groupLength = codewordsInGroup * 8;
                 for (var i = 0; i < blocksInGroup; i++)
                 {
-                    //var bitBlockList = BinaryStringToBitBlockByteList(bitArray2, offset2, groupLength);
                     var eccWordList = CalculateECCWords(bitArray2, offset2, groupLength, eccInfo);
                     codeWordWithECC.Add(new CodewordBlock(
-                                          //bitBlockList,
-                                          bitArray2,
+                                          //bitArray2,
                                           offset2,
                                           groupLength,
                                           eccWordList)
@@ -624,37 +622,6 @@ private static Polynom CalculateGeneratorPolynom(int numEccWords)
             return generatorPolynom; // Return the completed generator polynomial
         }
 
-        /// <summary>
-        /// Converts a segment of a BitArray into a list of bytes where each byte represents a consecutive block of 8 bits from the BitArray.
-        /// </summary>
-        private static byte[] BinaryStringToBitBlockByteList(BitArray bitString, int offset, int count)
-        {
-            const int blockSize = 8;
-            if (count % blockSize != 0)
-                ThrowCountMustBeMultipleOf8Exception();
-            var numberOfBlocks = (int)((uint)count / blockSize);
-            var blocklist = new byte[numberOfBlocks];
-
-            int j = 0;
-            count += offset;
-            for (int i = offset; i < count; i += blockSize)
-            {
-                blocklist[j++] = (byte)(
-                    (bitString[i] ? 128 : 0) + 
-                    (bitString[i + 1] ? 64 : 0) + 
-                    (bitString[i + 2] ? 32 : 0) + 
-                    (bitString[i + 3] ? 16 : 0) + 
-                    (bitString[i + 4] ? 8 : 0) + 
-                    (bitString[i + 5] ? 4 : 0) + 
-                    (bitString[i + 6] ? 2 : 0) + 
-                    (bitString[i + 7] ? 1 : 0));
-            }
-
-            return blocklist;
-
-            void ThrowCountMustBeMultipleOf8Exception() => throw new ArgumentOutOfRangeException(nameof(count), "Count must be a multiple of 8.");
-        }
-
         /// <summary>
         /// Converts a segment of a BitArray into its decimal (integer) equivalent.
         /// </summary>