1 files changed, 27 insertions, 25 deletions

diff --git a/modules/brotli/enc/write_bits.h b/modules/brotli/enc/write_bits.h
index 36515a6893..f6f88b45be 100644
--- a/modules/brotli/enc/write_bits.h
+++ b/modules/brotli/enc/write_bits.h
@@ -16,8 +16,6 @@
 extern "C" {
 #endif
 
-/*#define BIT_WRITER_DEBUG */
-
 /* This function writes bits into bytes in increasing addresses, and within
    a byte least-significant-bit first.
 
@@ -28,7 +26,7 @@ extern "C" {
 
    0000 0RRR    0000 0000    0000 0000
 
-   Now, we could write 5 or less bits in MSB by just sifting by 3
+   Now, we could write 5 or less bits in MSB by just shifting by 3
    and OR'ing to BYTE-0.
 
    For n bits, we take the last 5 bits, OR that with high bits in BYTE-0,
@@ -37,37 +35,41 @@ static BROTLI_INLINE void BrotliWriteBits(size_t n_bits,
                                           uint64_t bits,
                                           size_t* BROTLI_RESTRICT pos,
                                           uint8_t* BROTLI_RESTRICT array) {
+  BROTLI_LOG(("WriteBits  %2d  0x%08x%08x  %10d\n", (int)n_bits,
+      (uint32_t)(bits >> 32), (uint32_t)(bits & 0xFFFFFFFF),
+      (int)*pos));
+  BROTLI_DCHECK((bits >> n_bits) == 0);
+  BROTLI_DCHECK(n_bits <= 56);
 #if defined(BROTLI_LITTLE_ENDIAN)
   /* This branch of the code can write up to 56 bits at a time,
      7 bits are lost by being perhaps already in *p and at least
      1 bit is needed to initialize the bit-stream ahead (i.e. if 7
      bits are in *p and we write 57 bits, then the next write will
      access a byte that was never initialized). */
-  uint8_t* p = &array[*pos >> 3];
-  uint64_t v = (uint64_t)(*p);  /* Zero-extend 8 to 64 bits. */
-  BROTLI_LOG(("WriteBits  %2d  0x%08x%08x  %10d\n", (int)n_bits,
-      (uint32_t)(bits >> 32), (uint32_t)(bits & 0xFFFFFFFF),
-      (int)*pos));
-  BROTLI_DCHECK((bits >> n_bits) == 0);
-  BROTLI_DCHECK(n_bits <= 56);
-  v |= bits << (*pos & 7);
-  BROTLI_UNALIGNED_STORE64LE(p, v);  /* Set some bits. */
-  *pos += n_bits;
+  {
+    uint8_t* p = &array[*pos >> 3];
+    uint64_t v = (uint64_t)(*p);  /* Zero-extend 8 to 64 bits. */
+    v |= bits << (*pos & 7);
+    BROTLI_UNALIGNED_STORE64LE(p, v);  /* Set some bits. */
+    *pos += n_bits;
+  }
 #else
   /* implicit & 0xFF is assumed for uint8_t arithmetics */
-  uint8_t* array_pos = &array[*pos >> 3];
-  const size_t bits_reserved_in_first_byte = (*pos & 7);
-  size_t bits_left_to_write;
-  bits <<= bits_reserved_in_first_byte;
-  *array_pos++ |= (uint8_t)bits;
-  for (bits_left_to_write = n_bits + bits_reserved_in_first_byte;
-       bits_left_to_write >= 9;
-       bits_left_to_write -= 8) {
-    bits >>= 8;
-    *array_pos++ = (uint8_t)bits;
+  {
+    uint8_t* array_pos = &array[*pos >> 3];
+    const size_t bits_reserved_in_first_byte = (*pos & 7);
+    size_t bits_left_to_write;
+    bits <<= bits_reserved_in_first_byte;
+    *array_pos++ |= (uint8_t)bits;
+    for (bits_left_to_write = n_bits + bits_reserved_in_first_byte;
+         bits_left_to_write >= 9;
+         bits_left_to_write -= 8) {
+      bits >>= 8;
+      *array_pos++ = (uint8_t)bits;
+    }
+    *array_pos = 0;
+    *pos += n_bits;
   }
-  *array_pos = 0;
-  *pos += n_bits;
 #endif
 }