Update Brotli to revision ec03509

third_party/brotli/dec/decode.c

 /* Copyright 2013 Google Inc. All Rights Reserved.
 
    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,
@@ skipping 68 matching lines @@
     int nbits = (int)BrotliReadBits(br, 3);
     if (nbits == 0) {
       return 1;
     } else {
       return (int)BrotliReadBits(br, nbits) + (1 << nbits);
     }
   }
   return 0;
 }
 
-static void DecodeMetaBlockLength(BrotliBitReader* br,
-                                  int* meta_block_length,
-                                  int* input_end,
-                                  int* is_uncompressed) {
+/* Advances the bit reader position to the next byte boundary and verifies
+   that any skipped bits are set to zero. */
+static BROTLI_INLINE int JumpToByteBoundary(BrotliBitReader* br) {
+  uint32_t new_bit_pos = (br->bit_pos_ + 7) & (uint32_t)(~7UL);
+  uint32_t pad_bits = BrotliReadBits(br, (int)(new_bit_pos - br->bit_pos_));
+  return pad_bits == 0;
+}
+
+static int DecodeMetaBlockLength(BrotliBitReader* br,
+                                 int* meta_block_length,
+                                 int* input_end,
+                                 int* is_metadata,
+                                 int* is_uncompressed) {
   int size_nibbles;
+  int size_bytes;
   int i;
   *input_end = (int)BrotliReadBits(br, 1);
   *meta_block_length = 0;
   *is_uncompressed = 0;
+  *is_metadata = 0;
   if (*input_end && BrotliReadBits(br, 1)) {
-    return;
+    return 1;
   }
   size_nibbles = (int)BrotliReadBits(br, 2) + 4;
-  for (i = 0; i < size_nibbles; ++i) {
-    *meta_block_length |= (int)BrotliReadBits(br, 4) << (i * 4);
+  if (size_nibbles == 7) {
+    *is_metadata = 1;
+    /* Verify reserved bit. */
+    if (BrotliReadBits(br, 1) != 0) {
+      return 0;
+    }
+    size_bytes = (int)BrotliReadBits(br, 2);
+    if (size_bytes == 0) {
+      return 1;
+    }
+    for (i = 0; i < size_bytes; ++i) {
+      int next_byte = (int)BrotliReadBits(br, 8);
+      if (i + 1 == size_bytes && size_bytes > 1 && next_byte == 0) {
+        return 0;
+      }
+      *meta_block_length |= next_byte << (i * 8);
+    }
+  } else {
+    for (i = 0; i < size_nibbles; ++i) {
+      int next_nibble = (int)BrotliReadBits(br, 4);
+      if (i + 1 == size_nibbles && size_nibbles > 4 && next_nibble == 0) {
+        return 0;
+      }
+      *meta_block_length |= next_nibble << (i * 4);
+    }
   }
   ++(*meta_block_length);
-  if (!*input_end) {
+  if (!*input_end && !*is_metadata) {
     *is_uncompressed = (int)BrotliReadBits(br, 1);
   }
+  return 1;
 }
 
 /* Decodes the next Huffman code from bit-stream. */
 static BROTLI_INLINE int ReadSymbol(const HuffmanCode* table,
                                     BrotliBitReader* br) {
   int nbits;
   BrotliFillBitWindow(br);
   table += (int)(br->val_ >> br->bit_pos_) & HUFFMAN_TABLE_MASK;
   nbits = table->bits - HUFFMAN_TABLE_BITS;
   if (nbits > 0) {
@@ skipping 30 matching lines @@
         PrintUcharVector(code_length_code_lengths, CODE_LENGTH_CODES);
         return BROTLI_RESULT_ERROR;
       }
       s->sub_state[1] = BROTLI_STATE_SUB_HUFFMAN_LENGTH_SYMBOLS;
       /* No break, continue to next state. */
     case BROTLI_STATE_SUB_HUFFMAN_LENGTH_SYMBOLS:
       while (s->symbol < num_symbols && s->space > 0) {
         const HuffmanCode* p = s->table;
         uint8_t code_len;
         if (!BrotliReadMoreInput(br)) {
-          return BROTLI_RESULT_PARTIAL;
+          return BROTLI_RESULT_NEEDS_MORE_INPUT;
         }
         BrotliFillBitWindow(br);
         p += (br->val_ >> br->bit_pos_) & 31;
         br->bit_pos_ += p->bits;
         code_len = (uint8_t)p->value;
         if (code_len < kCodeLengthRepeatCode) {
           s->repeat = 0;
           code_lengths[s->symbol++] = code_len;
           if (code_len != 0) {
             s->prev_code_len = code_len;
@@ skipping 47 matching lines @@
                                     int* opt_table_size,
                                     BrotliState* s) {
   BrotliBitReader* br = &s->br;
   BrotliResult result = BROTLI_RESULT_SUCCESS;
   int table_size = 0;
   /* State machine */
   for (;;) {
     switch(s->sub_state[1]) {
       case BROTLI_STATE_SUB_NONE:
         if (!BrotliReadMoreInput(br)) {
-          return BROTLI_RESULT_PARTIAL;
+          return BROTLI_RESULT_NEEDS_MORE_INPUT;
         }
         s->code_lengths =
             (uint8_t*)BrotliSafeMalloc((uint64_t)alphabet_size,
                                        sizeof(*s->code_lengths));
         if (s->code_lengths == NULL) {
           return BROTLI_RESULT_ERROR;
         }
         /* simple_code_or_skip is used as follows:
            1 for simple code;
            0 for no skipping, 2 skips 2 code lengths, 3 skips 3 code lengths */
         s->simple_code_or_skip = (int)BrotliReadBits(br, 2);
         BROTLI_LOG_UINT(s->simple_code_or_skip);
         if (s->simple_code_or_skip == 1) {
           /* Read symbols, codes & code lengths directly. */
           int i;
           int max_bits_counter = alphabet_size - 1;
           int max_bits = 0;
           int symbols[4] = { 0 };
           const int num_symbols = (int)BrotliReadBits(br, 2) + 1;
           while (max_bits_counter) {
             max_bits_counter >>= 1;
             ++max_bits;
           }
           memset(s->code_lengths, 0, (size_t)alphabet_size);
           for (i = 0; i < num_symbols; ++i) {
-            symbols[i] = (int)BrotliReadBits(br, max_bits) % alphabet_size;
+            symbols[i] = (int)BrotliReadBits(br, max_bits);
+            if (symbols[i] >= alphabet_size) {
+              return BROTLI_RESULT_ERROR;
+            }
             s->code_lengths[symbols[i]] = 2;
           }
           s->code_lengths[symbols[0]] = 1;
           switch (num_symbols) {
             case 1:
               break;
             case 3:
               if ((symbols[0] == symbols[1]) ||
                   (symbols[0] == symbols[2]) ||
                   (symbols[1] == symbols[2])) {
@@ skipping 104 matching lines @@
   if (code < NUM_DISTANCE_SHORT_CODES) {
     index += kDistanceShortCodeIndexOffset[code];
     index &= 3;
     val = ringbuffer[index] + kDistanceShortCodeValueOffset[code];
   } else {
     val = code - NUM_DISTANCE_SHORT_CODES + 1;
   }
   return val;
 }
 
-static void MoveToFront(uint8_t* v, uint8_t index) {
-  uint8_t value = v[index];
-  uint8_t i = index;
-  for (; i; --i) v[i] = v[i - 1];
-  v[0] = value;
-}
-
 static void InverseMoveToFrontTransform(uint8_t* v, int v_len) {
   uint8_t mtf[256];
   int i;
   for (i = 0; i < 256; ++i) {
     mtf[i] = (uint8_t)i;
   }
   for (i = 0; i < v_len; ++i) {
     uint8_t index = v[i];
-    v[i] = mtf[index];
-    if (index) MoveToFront(mtf, index);
+    uint8_t value = mtf[index];
+    v[i] = value;
+    for (; index; --index) {
+      mtf[index] = mtf[index - 1];
+    }
+    mtf[0] = value;
   }
 }
 
 static BrotliResult HuffmanTreeGroupDecode(HuffmanTreeGroup* group,
                                            BrotliState* s) {
   switch (s->sub_state[0]) {
     case BROTLI_STATE_SUB_NONE:
       s->next = group->codes;
       s->htree_index = 0;
       s->sub_state[0] = BROTLI_STATE_SUB_TREE_GROUP;
@@ skipping 24 matching lines @@
                                      int* num_htrees,
                                      uint8_t** context_map,
                                      BrotliState* s) {
   BrotliBitReader* br = &s->br;
   BrotliResult result = BROTLI_RESULT_SUCCESS;
   int use_rle_for_zeros;
 
   switch(s->sub_state[0]) {
     case BROTLI_STATE_SUB_NONE:
       if (!BrotliReadMoreInput(br)) {
-        return BROTLI_RESULT_PARTIAL;
+        return BROTLI_RESULT_NEEDS_MORE_INPUT;
       }
       *num_htrees = DecodeVarLenUint8(br) + 1;
 
       s->context_index = 0;
 
       BROTLI_LOG_UINT(context_map_size);
       BROTLI_LOG_UINT(*num_htrees);
 
       *context_map = (uint8_t*)malloc((size_t)context_map_size);
       if (*context_map == 0) {
@@ skipping 20 matching lines @@
     case BROTLI_STATE_SUB_CONTEXT_MAP_HUFFMAN:
       result = ReadHuffmanCode(*num_htrees + s->max_run_length_prefix,
                                s->context_map_table, NULL, s);
       if (result != BROTLI_RESULT_SUCCESS) return result;
       s->sub_state[0] = BROTLI_STATE_SUB_CONTEXT_MAPS;
       /* No break, continue to next state. */
     case BROTLI_STATE_SUB_CONTEXT_MAPS:
       while (s->context_index < context_map_size) {
         int code;
         if (!BrotliReadMoreInput(br)) {
-          return BROTLI_RESULT_PARTIAL;
+          return BROTLI_RESULT_NEEDS_MORE_INPUT;
         }
         code = ReadSymbol(s->context_map_table, br);
         if (code == 0) {
           (*context_map)[s->context_index] = 0;
           ++s->context_index;
         } else if (code <= s->max_run_length_prefix) {
           int reps = 1 + (1 << code) + (int)BrotliReadBits(br, code);
           while (--reps) {
             if (s->context_index >= context_map_size) {
               return BROTLI_RESULT_ERROR;
@@ skipping 114 matching lines @@
 
 BrotliResult CopyUncompressedBlockToOutput(BrotliOutput output,
                                            int pos,
                                            BrotliState* s) {
   const int rb_size = s->ringbuffer_mask + 1;
   uint8_t* ringbuffer_end = s->ringbuffer + rb_size;
   int rb_pos = pos & s->ringbuffer_mask;
   int br_pos = s->br.pos_ & BROTLI_IBUF_MASK;
   uint32_t remaining_bits;
   int num_read;
+  int num_written;
 
   /* State machine */
   for (;;) {
     switch (s->sub_state[0]) {
       case BROTLI_STATE_SUB_NONE:
         /* For short lengths copy byte-by-byte */
         if (s->meta_block_remaining_len < 8 || s->br.bit_pos_ +
             (uint32_t)(s->meta_block_remaining_len << 3) < s->br.bit_end_pos_) {
           s->sub_state[0] = BROTLI_STATE_SUB_UNCOMPRESSED_SHORT;
           break;
@@ skipping 24 matching lines @@
           memcpy(&s->ringbuffer[rb_pos], &s->br.buf_[br_pos], (size_t)tail);
           s->nbytes -= tail;
           rb_pos += tail;
           s->meta_block_remaining_len -= tail;
           br_pos = 0;
         }
         memcpy(&s->ringbuffer[rb_pos], &s->br.buf_[br_pos], (size_t)s->nbytes);
         rb_pos += s->nbytes;
         s->meta_block_remaining_len -= s->nbytes;
 
+        s->partially_written = 0;
+        s->sub_state[0] = BROTLI_STATE_SUB_UNCOMPRESSED_WRITE_1;
+        /* No break, continue to next state */
+      case BROTLI_STATE_SUB_UNCOMPRESSED_WRITE_1:
         /* If we wrote past the logical end of the ringbuffer, copy the tail of
            the ringbuffer to its beginning and flush the ringbuffer to the
            output. */
         if (rb_pos >= rb_size) {
-          if (BrotliWrite(output, s->ringbuffer, (size_t)rb_size) < rb_size) {
+          num_written = BrotliWrite(output,
+                                    s->ringbuffer + s->partially_written,
+                                    (size_t)(rb_size - s->partially_written));
+          if (num_written < 0) {
             return BROTLI_RESULT_ERROR;
           }
+          s->partially_written += num_written;
+          if (s->partially_written < rb_size) {
+            return BROTLI_RESULT_NEEDS_MORE_OUTPUT;
+          }
           rb_pos -= rb_size;
           s->meta_block_remaining_len += rb_size;
           memcpy(s->ringbuffer, ringbuffer_end, (size_t)rb_pos);
         }
         s->sub_state[0] = BROTLI_STATE_SUB_UNCOMPRESSED_FILL;
         break;
       case BROTLI_STATE_SUB_UNCOMPRESSED_SHORT:
         while (s->meta_block_remaining_len > 0) {
           if (!BrotliReadMoreInput(&s->br)) {
-            return BROTLI_RESULT_PARTIAL;
+            return BROTLI_RESULT_NEEDS_MORE_INPUT;
           }
           s->ringbuffer[rb_pos++] = (uint8_t)BrotliReadBits(&s->br, 8);
           if (rb_pos == rb_size) {
-            if (BrotliWrite(output, s->ringbuffer, (size_t)rb_size) < rb_size) {
-              return BROTLI_RESULT_ERROR;
-            }
-            rb_pos = 0;
+            s->partially_written = 0;
+            s->sub_state[0] = BROTLI_STATE_SUB_UNCOMPRESSED_WRITE_2;
+            break;
           }
           s->meta_block_remaining_len--;
         }
-        s->sub_state[0] = BROTLI_STATE_SUB_NONE;
-        return BROTLI_RESULT_SUCCESS;
+        if (s->sub_state[0] == BROTLI_STATE_SUB_UNCOMPRESSED_SHORT) {
+          s->sub_state[0] = BROTLI_STATE_SUB_NONE;
+          return BROTLI_RESULT_SUCCESS;
+        }
+        /* No break, if state is updated, continue to next state */
+      case BROTLI_STATE_SUB_UNCOMPRESSED_WRITE_2:
+        num_written = BrotliWrite(output, s->ringbuffer + s->partially_written,
+                                  (size_t)(rb_size - s->partially_written));
+        if (num_written < 0) {
+          return BROTLI_RESULT_ERROR;
+        }
+        s->partially_written += num_written;
+        if (s->partially_written < rb_size) {
+          return BROTLI_RESULT_NEEDS_MORE_OUTPUT;
+        }
+        rb_pos = 0;
+        s->meta_block_remaining_len--;
+        s->sub_state[0] = BROTLI_STATE_SUB_UNCOMPRESSED_SHORT;
+        break;
       case BROTLI_STATE_SUB_UNCOMPRESSED_FILL:
         /* If we have more to copy than the remaining size of the ringbuffer,
            then we first fill the ringbuffer from the input and then flush the
            ringbuffer to the output */
-        while (rb_pos + s->meta_block_remaining_len >= rb_size) {
+        if (rb_pos + s->meta_block_remaining_len >= rb_size) {
           s->nbytes = rb_size - rb_pos;
           if (BrotliRead(s->br.input_, &s->ringbuffer[rb_pos],
                          (size_t)s->nbytes) < s->nbytes) {
-            return BROTLI_RESULT_PARTIAL;
+            return BROTLI_RESULT_NEEDS_MORE_INPUT;
           }
-          if (BrotliWrite(output, s->ringbuffer, (size_t)rb_size) < s->nbytes) {
-            return BROTLI_RESULT_ERROR;
-          }
-          s->meta_block_remaining_len -= s->nbytes;
-          rb_pos = 0;
+          s->partially_written = 0;
+          s->sub_state[0] = BROTLI_STATE_SUB_UNCOMPRESSED_WRITE_3;
+        } else {
+          s->sub_state[0] = BROTLI_STATE_SUB_UNCOMPRESSED_COPY;
+          break;
         }
-        s->sub_state[0] = BROTLI_STATE_SUB_UNCOMPRESSED_COPY;
         /* No break, continue to next state */
+      case BROTLI_STATE_SUB_UNCOMPRESSED_WRITE_3:
+        num_written = BrotliWrite(output, s->ringbuffer + s->partially_written,
+                                  (size_t)(rb_size - s->partially_written));
+        if (num_written < 0) {
+          return BROTLI_RESULT_ERROR;
+        }
+        s->partially_written += num_written;
+        if (s->partially_written < rb_size) {
+          return BROTLI_RESULT_NEEDS_MORE_OUTPUT;
+        }
+        s->meta_block_remaining_len -= s->nbytes;
+        rb_pos = 0;
+        s->sub_state[0] = BROTLI_STATE_SUB_UNCOMPRESSED_FILL;
+        break;
       case BROTLI_STATE_SUB_UNCOMPRESSED_COPY:
         /* Copy straight from the input onto the ringbuffer. The ringbuffer will
            be flushed to the output at a later time. */
         num_read = BrotliRead(s->br.input_, &s->ringbuffer[rb_pos],
                               (size_t)s->meta_block_remaining_len);
         s->meta_block_remaining_len -= num_read;
         if (s->meta_block_remaining_len > 0) {
-          return BROTLI_RESULT_PARTIAL;
+          return BROTLI_RESULT_NEEDS_MORE_INPUT;
         }
 
         /* Restore the state of the bit reader. */
         BrotliInitBitReader(&s->br, s->br.input_, s->br.finish_);
         s->sub_state[0] = BROTLI_STATE_SUB_UNCOMPRESSED_WARMUP;
         /* No break, continue to next state */
       case BROTLI_STATE_SUB_UNCOMPRESSED_WARMUP:
         if (!BrotliWarmupBitReader(&s->br)) {
-          return BROTLI_RESULT_PARTIAL;
+          return BROTLI_RESULT_NEEDS_MORE_INPUT;
         }
         s->sub_state[0] = BROTLI_STATE_SUB_NONE;
         return BROTLI_RESULT_SUCCESS;
         break;
       default:
         return BROTLI_RESULT_ERROR;  /* Unknown state */
     }
   }
   return BROTLI_RESULT_ERROR;
 }
@@ skipping 70 matching lines @@
   BrotliResult success = BrotliDecompress(in, out);
   *decoded_size = mout.pos;
   return success;
 }
 
 BrotliResult BrotliDecompress(BrotliInput input, BrotliOutput output) {
   BrotliState s;
   BrotliResult result;
   BrotliStateInit(&s);
   result = BrotliDecompressStreaming(input, output, 1, &s);
-  if (result == BROTLI_RESULT_PARTIAL) {
+  if (result == BROTLI_RESULT_NEEDS_MORE_INPUT) {
     /* Not ok: it didn't finish even though this is a non-streaming function. */
     result = BROTLI_RESULT_ERROR;
   }
   BrotliStateCleanup(&s);
   return result;
 }
 
 BrotliResult BrotliDecompressBufferStreaming(size_t* available_in,
                                              const uint8_t** next_in,
                                              int finish,
@@ skipping 23 matching lines @@
 
 BrotliResult BrotliDecompressStreaming(BrotliInput input, BrotliOutput output,
                                        int finish, BrotliState* s) {
   uint8_t context;
   int pos = s->pos;
   int i = s->loop_counter;
   BrotliResult result = BROTLI_RESULT_SUCCESS;
   BrotliBitReader* br = &s->br;
   int initial_remaining_len;
   int bytes_copied;
+  int num_written;
 
   /* We need the slack region for the following reasons:
        - always doing two 8-byte copies for fast backward copying
        - transforms
        - flushing the input s->ringbuffer when decoding uncompressed blocks */
   static const int kRingBufferWriteAheadSlack = 128 + BROTLI_READ_SIZE;
 
   s->br.finish_ = finish;
 
   /* State machine */
   for (;;) {
     if (result != BROTLI_RESULT_SUCCESS) {
-      if (result == BROTLI_RESULT_PARTIAL && finish) {
+      if (result == BROTLI_RESULT_NEEDS_MORE_INPUT && finish) {
         printf("Unexpected end of input. State: %d\n", s->state);
         result = BROTLI_RESULT_ERROR;
       }
       break;  /* Fail, or partial data. */
     }
 
     switch (s->state) {
       case BROTLI_STATE_UNINITED:
         pos = 0;
         s->input_end = 0;
         s->window_bits = 0;
         s->max_distance = 0;
         s->dist_rb[0] = 16;
         s->dist_rb[1] = 15;
         s->dist_rb[2] = 11;
         s->dist_rb[3] = 4;
         s->dist_rb_idx = 0;
         s->prev_byte1 = 0;
         s->prev_byte2 = 0;
         s->block_type_trees = NULL;
         s->block_len_trees = NULL;
 
         BrotliInitBitReader(br, input, finish);
 
         s->state = BROTLI_STATE_BITREADER_WARMUP;
         /* No break, continue to next state */
       case BROTLI_STATE_BITREADER_WARMUP:
         if (!BrotliWarmupBitReader(br)) {
-          result = BROTLI_RESULT_PARTIAL;
+          result = BROTLI_RESULT_NEEDS_MORE_INPUT;
           break;
         }
         /* Decode window size. */
         s->window_bits = DecodeWindowBits(br);
         s->max_backward_distance = (1 << s->window_bits) - 16;
 
         s->ringbuffer_size = 1 << s->window_bits;
         s->ringbuffer_mask = s->ringbuffer_size - 1;
         s->ringbuffer = (uint8_t*)malloc((size_t)(s->ringbuffer_size +
                                                kRingBufferWriteAheadSlack +
@@ skipping 10 matching lines @@
             3 * BROTLI_HUFFMAN_MAX_TABLE_SIZE * sizeof(HuffmanCode));
         if (s->block_type_trees == NULL || s->block_len_trees == NULL) {
           result = BROTLI_RESULT_ERROR;
           break;
         }
 
         s->state = BROTLI_STATE_METABLOCK_BEGIN;
         /* No break, continue to next state */
       case BROTLI_STATE_METABLOCK_BEGIN:
         if (!BrotliReadMoreInput(br)) {
-          result = BROTLI_RESULT_PARTIAL;
+          result = BROTLI_RESULT_NEEDS_MORE_INPUT;
           break;
         }
         if (s->input_end) {
+          s->partially_written = 0;
           s->state = BROTLI_STATE_DONE;
           break;
         }
         s->meta_block_remaining_len = 0;
         s->block_length[0] = 1 << 28;
         s->block_length[1] = 1 << 28;
         s->block_length[2] = 1 << 28;
         s->block_type[0] = 0;
         s->num_block_types[0] = 1;
         s->num_block_types[1] = 1;
@@ skipping 17 matching lines @@
         s->context_lookup_offset1 = 0;
         s->context_lookup_offset2 = 0;
         for (i = 0; i < 3; ++i) {
           s->hgroup[i].codes = NULL;
           s->hgroup[i].htrees = NULL;
         }
         s->state = BROTLI_STATE_METABLOCK_HEADER_1;
         /* No break, continue to next state */
       case BROTLI_STATE_METABLOCK_HEADER_1:
         if (!BrotliReadMoreInput(br)) {
-          result = BROTLI_RESULT_PARTIAL;
+          result = BROTLI_RESULT_NEEDS_MORE_INPUT;
           break;
         }
         BROTLI_LOG_UINT(pos);
-        DecodeMetaBlockLength(br, &s->meta_block_remaining_len,
-                              &s->input_end, &s->is_uncompressed);
+        if (!DecodeMetaBlockLength(br,
+                                   &s->meta_block_remaining_len,
+                                   &s->input_end,
+                                   &s->is_metadata,
+                                   &s->is_uncompressed)) {
+          result = BROTLI_RESULT_ERROR;
+          break;
+        }
         BROTLI_LOG_UINT(s->meta_block_remaining_len);
+        if (s->is_metadata) {
+          if (!JumpToByteBoundary(&s->br)) {
+            result = BROTLI_RESULT_ERROR;
+            break;
+          }
+          s->state = BROTLI_STATE_METADATA;
+          break;
+        }
         if (s->meta_block_remaining_len == 0) {
           s->state = BROTLI_STATE_METABLOCK_DONE;
           break;
         }
         if (s->is_uncompressed) {
-          BrotliSetBitPos(br, (s->br.bit_pos_ + 7) & (uint32_t)(~7UL));
+          if (!JumpToByteBoundary(&s->br)) {
+            result = BROTLI_RESULT_ERROR;
+            break;
+          }
           s->state = BROTLI_STATE_UNCOMPRESSED;
           break;
         }
         i = 0;
         s->state = BROTLI_STATE_HUFFMAN_CODE_0;
         break;
       case BROTLI_STATE_UNCOMPRESSED:
         initial_remaining_len = s->meta_block_remaining_len;
         /* pos is given as argument since s->pos is only updated at the end. */
         result = CopyUncompressedBlockToOutput(output, pos, s);
+        if (result == BROTLI_RESULT_NEEDS_MORE_OUTPUT) {
+          break;
+        }
         bytes_copied = initial_remaining_len - s->meta_block_remaining_len;
         pos += bytes_copied;
         if (bytes_copied > 0) {
           s->prev_byte2 = bytes_copied == 1 ? s->prev_byte1 :
               s->ringbuffer[(pos - 2) & s->ringbuffer_mask];
           s->prev_byte1 = s->ringbuffer[(pos - 1) & s->ringbuffer_mask];
         }
         if (result != BROTLI_RESULT_SUCCESS) break;
         s->state = BROTLI_STATE_METABLOCK_DONE;
         break;
+      case BROTLI_STATE_METADATA:
+        for (; s->meta_block_remaining_len > 0; --s->meta_block_remaining_len) {
+          if (!BrotliReadMoreInput(&s->br)) {
+            result = BROTLI_RESULT_NEEDS_MORE_INPUT;
+            break;
+          }
+          /* Read one byte and ignore it. */
+          BrotliReadBits(&s->br, 8);
+        }
+        s->state = BROTLI_STATE_METABLOCK_DONE;
+        break;
       case BROTLI_STATE_HUFFMAN_CODE_0:
         if (i >= 3) {
           BROTLI_LOG_UINT(s->num_block_types[0]);
           BROTLI_LOG_UINT(s->num_block_types[1]);
           BROTLI_LOG_UINT(s->num_block_types[2]);
           BROTLI_LOG_UINT(s->block_length[0]);
           BROTLI_LOG_UINT(s->block_length[1]);
           BROTLI_LOG_UINT(s->block_length[2]);
 
           s->state = BROTLI_STATE_METABLOCK_HEADER_2;
@@ skipping 21 matching lines @@
             NULL, s);
         if (result != BROTLI_RESULT_SUCCESS) break;
         s->block_length[i] = ReadBlockLength(
             &s->block_len_trees[i * BROTLI_HUFFMAN_MAX_TABLE_SIZE], br);
         s->block_type_rb_index[i] = 1;
         i++;
         s->state = BROTLI_STATE_HUFFMAN_CODE_0;
         break;
       case BROTLI_STATE_METABLOCK_HEADER_2:
         if (!BrotliReadMoreInput(br)) {
-          result = BROTLI_RESULT_PARTIAL;
+          result = BROTLI_RESULT_NEEDS_MORE_INPUT;
           break;
         }
         s->distance_postfix_bits = (int)BrotliReadBits(br, 2);
         s->num_direct_distance_codes = NUM_DISTANCE_SHORT_CODES +
             ((int)BrotliReadBits(br, 4) << s->distance_postfix_bits);
         s->distance_postfix_mask = (1 << s->distance_postfix_bits) - 1;
         s->num_distance_codes = (s->num_direct_distance_codes +
                               (48 << s->distance_postfix_bits));
         s->context_modes = (uint8_t*)malloc((size_t)s->num_block_types[0]);
         if (s->context_modes == 0) {
@@ skipping 53 matching lines @@
 
           s->state = BROTLI_STATE_BLOCK_BEGIN;
           break;
         }
 
         break;
       case BROTLI_STATE_BLOCK_BEGIN:
  /* Block decoding is the inner loop, jumping with goto makes it 3% faster */
  BlockBegin:
         if (!BrotliReadMoreInput(br)) {
-          result = BROTLI_RESULT_PARTIAL;
+          result = BROTLI_RESULT_NEEDS_MORE_INPUT;
           break;
         }
         if (s->meta_block_remaining_len <= 0) {
           /* Protect pos from overflow, wrap it around at every GB of input. */
           pos &= 0x3fffffff;
 
           /* Next metablock, if any */
           s->state = BROTLI_STATE_METABLOCK_DONE;
           break;
         }
@@ skipping 28 matching lines @@
         BROTLI_LOG_UINT(s->copy_length);
         BROTLI_LOG_UINT(s->distance_code);
 
         i = 0;
         s->state = BROTLI_STATE_BLOCK_INNER;
         /* No break, go to next state */
       case BROTLI_STATE_BLOCK_INNER:
         if (s->trivial_literal_context) {
           while (i < s->insert_length) {
             if (!BrotliReadMoreInput(br)) {
-              result = BROTLI_RESULT_PARTIAL;
+              result = BROTLI_RESULT_NEEDS_MORE_INPUT;
               break;
             }
             if (s->block_length[0] == 0) {
               DecodeBlockTypeWithContext(s, br);
             }
 
             s->ringbuffer[pos & s->ringbuffer_mask] = (uint8_t)ReadSymbol(
                 s->hgroup[0].htrees[s->literal_htree_index], br);
 
             --s->block_length[0];
             BROTLI_LOG_UINT(s->literal_htree_index);
             BROTLI_LOG_ARRAY_INDEX(s->ringbuffer, pos & s->ringbuffer_mask);
             if ((pos & s->ringbuffer_mask) == s->ringbuffer_mask) {
-              if (BrotliWrite(output, s->ringbuffer,
-                              (size_t)s->ringbuffer_size) < 0) {
-                result = BROTLI_RESULT_ERROR;
-                break;
-              }
+              s->partially_written = 0;
+              s->state = BROTLI_STATE_BLOCK_INNER_WRITE;
+              break;
             }
+            /* Modifications to this code shold be reflected in
+            BROTLI_STATE_BLOCK_INNER_WRITE case */
             ++pos;
             ++i;
           }
         } else {
           while (i < s->insert_length) {
             if (!BrotliReadMoreInput(br)) {
-              result = BROTLI_RESULT_PARTIAL;
+              result = BROTLI_RESULT_NEEDS_MORE_INPUT;
               break;
             }
             if (s->block_length[0] == 0) {
               DecodeBlockTypeWithContext(s, br);
             }
 
             context =
                 (kContextLookup[s->context_lookup_offset1 + s->prev_byte1] |
                  kContextLookup[s->context_lookup_offset2 + s->prev_byte2]);
             BROTLI_LOG_UINT(context);
             s->literal_htree_index = s->context_map_slice[context];
             --s->block_length[0];
             s->prev_byte2 = s->prev_byte1;
             s->prev_byte1 = (uint8_t)ReadSymbol(
                 s->hgroup[0].htrees[s->literal_htree_index], br);
             s->ringbuffer[pos & s->ringbuffer_mask] = s->prev_byte1;
             BROTLI_LOG_UINT(s->literal_htree_index);
             BROTLI_LOG_ARRAY_INDEX(s->ringbuffer, pos & s->ringbuffer_mask);
             if ((pos & s->ringbuffer_mask) == s->ringbuffer_mask) {
-              if (BrotliWrite(output, s->ringbuffer,
-                              (size_t)s->ringbuffer_size) < 0) {
-                result = BROTLI_RESULT_ERROR;
-                break;
-              }
+              s->partially_written = 0;
+              s->state = BROTLI_STATE_BLOCK_INNER_WRITE;
+              break;
             }
+            /* Modifications to this code shold be reflected in
+            BROTLI_STATE_BLOCK_INNER_WRITE case */
             ++pos;
             ++i;
           }
         }
-
-        if (result != BROTLI_RESULT_SUCCESS) break;
+        if (result != BROTLI_RESULT_SUCCESS ||
+            s->state == BROTLI_STATE_BLOCK_INNER_WRITE) break;
 
         s->meta_block_remaining_len -= s->insert_length;
         if (s->meta_block_remaining_len <= 0) {
           s->state = BROTLI_STATE_METABLOCK_DONE;
           break;
         } else if (s->distance_code < 0) {
           s->state = BROTLI_STATE_BLOCK_DISTANCE;
         } else {
           s->state = BROTLI_STATE_BLOCK_POST;
           break;
         }
         /* No break, go to next state */
       case BROTLI_STATE_BLOCK_DISTANCE:
         if (!BrotliReadMoreInput(br)) {
-          result = BROTLI_RESULT_PARTIAL;
+          result = BROTLI_RESULT_NEEDS_MORE_INPUT;
           break;
         }
         assert(s->distance_code < 0);
 
         if (s->block_length[2] == 0) {
           DecodeBlockType(s->num_block_types[2],
                           s->block_type_trees, 2,
                           s->block_type, s->block_type_rb,
                           s->block_type_rb_index, br);
           s->block_length[2] = ReadBlockLength(
@@ skipping 17 matching lines @@
           nbits = (s->distance_code >> 1) + 1;
           offset = ((2 + (s->distance_code & 1)) << nbits) - 4;
           s->distance_code = s->num_direct_distance_codes +
               ((offset + (int)BrotliReadBits(br, nbits)) <<
                s->distance_postfix_bits) + postfix;
         }
         s->state = BROTLI_STATE_BLOCK_POST;
         /* No break, go to next state */
       case BROTLI_STATE_BLOCK_POST:
         if (!BrotliReadMoreInput(br)) {
-          result = BROTLI_RESULT_PARTIAL;
+          result = BROTLI_RESULT_NEEDS_MORE_INPUT;
           break;
         }
         /* Convert the distance code to the actual distance by possibly */
         /* looking up past distnaces from the s->ringbuffer. */
         s->distance =
             TranslateShortCodes(s->distance_code, s->dist_rb, s->dist_rb_idx);
         if (s->distance < 0) {
           result = BROTLI_RESULT_ERROR;
           break;
         }
@@ skipping 19 matching lines @@
             int transform_idx = word_id >> shift;
             offset += word_idx * s->copy_length;
             if (transform_idx < kNumTransforms) {
               const uint8_t* word = &kBrotliDictionary[offset];
               int len = TransformDictionaryWord(
                   s->copy_dst, word, s->copy_length, transform_idx);
               s->copy_dst += len;
               pos += len;
               s->meta_block_remaining_len -= len;
               if (s->copy_dst >= s->ringbuffer_end) {
-                if (BrotliWrite(output, s->ringbuffer,
-                                (size_t)s->ringbuffer_size) < 0) {
+                s->partially_written = 0;
+                num_written = BrotliWrite(output, s->ringbuffer,
+                                          (size_t)s->ringbuffer_size);
+                if (num_written < 0) {
                   result = BROTLI_RESULT_ERROR;
                   break;
                 }
+                s->partially_written += num_written;
+                if (s->partially_written < s->ringbuffer_size) {
+                  result = BROTLI_RESULT_NEEDS_MORE_OUTPUT;
+                  s->state = BROTLI_STATE_BLOCK_POST_WRITE_1;
+                  break;
+                }
+                /* Modifications to this code shold be reflected in
+                BROTLI_STATE_BLOCK_POST_WRITE_1 case */
                 memcpy(s->ringbuffer, s->ringbuffer_end,
                        (size_t)(s->copy_dst - s->ringbuffer_end));
               }
             } else {
               printf("Invalid backward reference. pos: %d distance: %d "
                      "len: %d bytes left: %d\n",
                      pos, s->distance, s->copy_length,
                      s->meta_block_remaining_len);
               result = BROTLI_RESULT_ERROR;
               break;
@@ skipping 29 matching lines @@
               UNALIGNED_COPY64(s->copy_dst, s->copy_src);
               UNALIGNED_COPY64(s->copy_dst + 8, s->copy_src + 8);
             } else {
               IncrementalCopyFastPath(s->copy_dst, s->copy_src, s->copy_length);
             }
             pos += s->copy_length;
             s->meta_block_remaining_len -= s->copy_length;
             s->copy_length = 0;
           }
 #endif
-
+          /* Modifications to this loop shold be reflected in
+          BROTLI_STATE_BLOCK_POST_WRITE_2 case */
           for (i = 0; i < s->copy_length; ++i) {
             s->ringbuffer[pos & s->ringbuffer_mask] =
                 s->ringbuffer[(pos - s->distance) & s->ringbuffer_mask];
             if ((pos & s->ringbuffer_mask) == s->ringbuffer_mask) {
-              if (BrotliWrite(output, s->ringbuffer,
-                              (size_t)s->ringbuffer_size) < 0) {
+              s->partially_written = 0;
+              num_written = BrotliWrite(output, s->ringbuffer,
+                              (size_t)s->ringbuffer_size);
+              if (num_written < 0) {
                 result = BROTLI_RESULT_ERROR;
                 break;
               }
+              s->partially_written += num_written;
+              if (s->partially_written < s->ringbuffer_size) {
+                result = BROTLI_RESULT_NEEDS_MORE_OUTPUT;
+                s->state = BROTLI_STATE_BLOCK_POST_WRITE_2;
+                break;
+              }
             }
             ++pos;
             --s->meta_block_remaining_len;
           }
+          if (result == BROTLI_RESULT_NEEDS_MORE_OUTPUT) {
+            break;
+          }
         }
-
+        /* No break, continue to next state */
+      case BROTLI_STATE_BLOCK_POST_CONTINUE:
         /* When we get here, we must have inserted at least one literal and */
         /* made a copy of at least length two, therefore accessing the last 2 */
         /* bytes is valid. */
         s->prev_byte1 = s->ringbuffer[(pos - 1) & s->ringbuffer_mask];
         s->prev_byte2 = s->ringbuffer[(pos - 2) & s->ringbuffer_mask];
         s->state = BROTLI_STATE_BLOCK_BEGIN;
         goto BlockBegin;
+      case BROTLI_STATE_BLOCK_INNER_WRITE:
+      case BROTLI_STATE_BLOCK_POST_WRITE_1:
+      case BROTLI_STATE_BLOCK_POST_WRITE_2:
+        num_written = BrotliWrite(
+            output, s->ringbuffer + s->partially_written,
+            (size_t)(s->ringbuffer_size - s->partially_written));
+        if (num_written < 0) {
+          result = BROTLI_RESULT_ERROR;
+          break;
+        }
+        s->partially_written += num_written;
+        if (s->partially_written < s->ringbuffer_size) {
+          result = BROTLI_RESULT_NEEDS_MORE_OUTPUT;
+          break;
+        }
+        if (s->state == BROTLI_STATE_BLOCK_POST_WRITE_1) {
+          memcpy(s->ringbuffer, s->ringbuffer_end,
+                 (size_t)(s->copy_dst - s->ringbuffer_end));
+          s->state = BROTLI_STATE_BLOCK_POST_CONTINUE;
+        } else if (s->state == BROTLI_STATE_BLOCK_POST_WRITE_2) {
+          /* The tail of "i < s->copy_length" loop. */
+          ++pos;
+          --s->meta_block_remaining_len;
+          ++i;
+          /* Reenter the loop. */
+          for (; i < s->copy_length; ++i) {
+            s->ringbuffer[pos & s->ringbuffer_mask] =
+                s->ringbuffer[(pos - s->distance) & s->ringbuffer_mask];
+            if ((pos & s->ringbuffer_mask) == s->ringbuffer_mask) {
+              s->partially_written = 0;
+              num_written = BrotliWrite(output, s->ringbuffer,
+                                        (size_t)s->ringbuffer_size);
+              if (num_written < 0) {
+                result = BROTLI_RESULT_ERROR;
+                break;
+              }
+              s->partially_written += num_written;
+              if (s->partially_written < s->ringbuffer_size) {
+                result = BROTLI_RESULT_NEEDS_MORE_OUTPUT;
+                break;
+              }
+            }
+            ++pos;
+            --s->meta_block_remaining_len;
+          }
+          if (result == BROTLI_RESULT_NEEDS_MORE_OUTPUT) {
+            break;
+          }
+          s->state = BROTLI_STATE_BLOCK_POST_CONTINUE;
+        } else {  /* BROTLI_STATE_BLOCK_INNER_WRITE */
+          /* The tail of "i < s->insert_length" loop. */
+          ++pos;
+          ++i;
+          s->state = BROTLI_STATE_BLOCK_INNER;
+        }
+        break;
       case BROTLI_STATE_METABLOCK_DONE:
         if (s->context_modes != 0) {
           free(s->context_modes);
           s->context_modes = NULL;
         }
         if (s->context_map != 0) {
           free(s->context_map);
           s->context_map = NULL;
         }
         if (s->dist_context_map != 0) {
           free(s->dist_context_map);
           s->dist_context_map = NULL;
         }
         for (i = 0; i < 3; ++i) {
           BrotliHuffmanTreeGroupRelease(&s->hgroup[i]);
           s->hgroup[i].codes = NULL;
           s->hgroup[i].htrees = NULL;
         }
         s->state = BROTLI_STATE_METABLOCK_BEGIN;
         break;
       case BROTLI_STATE_DONE:
         if (s->ringbuffer != 0) {
-          if (BrotliWrite(output, s->ringbuffer,
-                          (size_t)(pos & s->ringbuffer_mask)) < 0) {
+          num_written = BrotliWrite(
+              output, s->ringbuffer + s->partially_written,
+              (size_t)((pos & s->ringbuffer_mask) - s->partially_written));
+          if (num_written < 0) {
             result = BROTLI_RESULT_ERROR;
           }
+          s->partially_written += num_written;
+          if (s->partially_written < (pos & s->ringbuffer_mask)) {
+            result = BROTLI_RESULT_NEEDS_MORE_OUTPUT;
+            break;
+          }
+        }
+        if (!JumpToByteBoundary(&s->br)) {
+          result = BROTLI_RESULT_ERROR;
         }
         return result;
       default:
         printf("Unknown state %d\n", s->state);
         result = BROTLI_RESULT_ERROR;
     }
   }
 
   s->pos = pos;
   s->loop_counter = i;
   return result;
 }
 
 #if defined(__cplusplus) || defined(c_plusplus)
 }    /* extern "C" */
 #endif