brotli 0.1.8 → 0.2.0

data/vendor/brotli/common/dictionary.h

@@ -1,29 +0,0 @@
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Collection of static dictionary words. */
-
-#ifndef BROTLI_COMMON_DICTIONARY_H_
-#define BROTLI_COMMON_DICTIONARY_H_
-
-#include "./types.h"
-
-#if defined(__cplusplus) || defined(c_plusplus)
-extern "C" {
-#endif
-
-extern const uint8_t kBrotliDictionary[122784];
-extern const uint32_t kBrotliDictionaryOffsetsByLength[25];
-extern const uint8_t kBrotliDictionarySizeBitsByLength[25];
-
-#define kBrotliMinDictionaryWordLength 4
-#define kBrotliMaxDictionaryWordLength 24
-
-#if defined(__cplusplus) || defined(c_plusplus)
-}  /* extern "C" */
-#endif
-
-#endif  /* BROTLI_COMMON_DICTIONARY_H_ */

data/vendor/brotli/common/port.h

@@ -1,107 +0,0 @@
-/* Copyright 2016 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Macros for compiler / platform specific features and build options. */
-
-#ifndef BROTLI_COMMON_PORT_H_
-#define BROTLI_COMMON_PORT_H_
-
-/* Compatibility with non-clang compilers. */
-#ifndef __has_builtin
-#define __has_builtin(x) 0
-#endif
-
-#ifndef __has_attribute
-#define __has_attribute(x) 0
-#endif
-
-#ifndef __has_feature
-#define __has_feature(x) 0
-#endif
-
-#if defined(__GNUC__) && defined(__GNUC_MINOR__)
-#define BROTLI_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
-#else
-#define BROTLI_GCC_VERSION 0
-#endif
-
-#if defined(__ICC)
-#define BROTLI_ICC_VERSION __ICC
-#else
-#define BROTLI_ICC_VERSION 0
-#endif
-
-#if defined(BROTLI_BUILD_MODERN_COMPILER)
-#define BROTLI_MODERN_COMPILER 1
-#elif BROTLI_GCC_VERSION > 300 || BROTLI_ICC_VERSION >= 1600
-#define BROTLI_MODERN_COMPILER 1
-#else
-#define BROTLI_MODERN_COMPILER 0
-#endif
-
-/* Define "PREDICT_TRUE" and "PREDICT_FALSE" macros for capable compilers.
-
-To apply compiler hint, enclose the branching condition into macros, like this:
-
-  if (PREDICT_TRUE(zero == 0)) {
-    // main execution path
-  } else {
-    // compiler should place this code outside of main execution path
-  }
-
-OR:
-
-  if (PREDICT_FALSE(something_rare_or_unexpected_happens)) {
-    // compiler should place this code outside of main execution path
-  }
-
-*/
-#if BROTLI_MODERN_COMPILER || __has_builtin(__builtin_expect)
-#define PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
-#define PREDICT_FALSE(x) (__builtin_expect(x, 0))
-#else
-#define PREDICT_FALSE(x) (x)
-#define PREDICT_TRUE(x) (x)
-#endif
-
-#if BROTLI_MODERN_COMPILER || __has_attribute(always_inline)
-#define ATTRIBUTE_ALWAYS_INLINE __attribute__ ((always_inline))
-#else
-#define ATTRIBUTE_ALWAYS_INLINE
-#endif
-
-#if defined(_WIN32) || defined(__CYGWIN__)
-#define ATTRIBUTE_VISIBILITY_HIDDEN
-#elif BROTLI_MODERN_COMPILER || __has_attribute(visibility)
-#define ATTRIBUTE_VISIBILITY_HIDDEN __attribute__ ((visibility ("hidden")))
-#else
-#define ATTRIBUTE_VISIBILITY_HIDDEN
-#endif
-
-#ifndef BROTLI_INTERNAL
-#define BROTLI_INTERNAL ATTRIBUTE_VISIBILITY_HIDDEN
-#endif
-
-#ifndef _MSC_VER
-#if defined(__cplusplus) || !defined(__STRICT_ANSI__) || \
-    __STDC_VERSION__ >= 199901L
-#define BROTLI_INLINE inline ATTRIBUTE_ALWAYS_INLINE
-#else
-#define BROTLI_INLINE
-#endif
-#else  /* _MSC_VER */
-#define BROTLI_INLINE __forceinline
-#endif  /* _MSC_VER */
-
-#if BROTLI_MODERN_COMPILER || __has_attribute(noinline)
-#define BROTLI_NOINLINE __attribute__((noinline))
-#else
-#define BROTLI_NOINLINE
-#endif
-
-#define BROTLI_UNUSED(X) (void)(X)
-
-#endif  /* BROTLI_COMMON_PORT_H_ */

data/vendor/brotli/common/types.h

@@ -1,58 +0,0 @@
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Common types */
-
-#ifndef BROTLI_COMMON_TYPES_H_
-#define BROTLI_COMMON_TYPES_H_
-
-#include <stddef.h>  /* for size_t */
-
-#if defined(_MSC_VER) && (_MSC_VER < 1600)
-typedef __int8 int8_t;
-typedef unsigned __int8 uint8_t;
-typedef __int16 int16_t;
-typedef unsigned __int16 uint16_t;
-typedef __int32 int32_t;
-typedef unsigned __int32 uint32_t;
-typedef unsigned __int64 uint64_t;
-typedef __int64 int64_t;
-#else
-#include <stdint.h>
-#endif  /* defined(_MSC_VER) && (_MSC_VER < 1600) */
-
-#if (!defined(_MSC_VER) || (_MSC_VER >= 1800)) && \
-  (defined(__cplusplus) || (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L))
-#include <stdbool.h>
-#define BROTLI_BOOL bool
-#define BROTLI_TRUE true
-#define BROTLI_FALSE false
-#define TO_BROTLI_BOOL(X) (!!(X))
-#else
-typedef enum {
-  BROTLI_FALSE = 0,
-  BROTLI_TRUE = !BROTLI_FALSE
-} BROTLI_BOOL;
-#define TO_BROTLI_BOOL(X) (!!(X) ? BROTLI_TRUE : BROTLI_FALSE)
-#endif
-
-#define MAKE_UINT64_T(high, low) ((((uint64_t)(high)) << 32) | low)
-
-#define BROTLI_UINT32_MAX (~((uint32_t)0))
-#define BROTLI_SIZE_MAX (~((size_t)0))
-
-/* Allocating function pointer. Function MUST return 0 in the case of failure.
-   Otherwise it MUST return a valid pointer to a memory region of at least
-   size length. Neither items nor size are allowed to be 0.
-   opaque argument is a pointer provided by client and could be used to bind
-   function to specific object (memory pool). */
-typedef void* (*brotli_alloc_func)(void* opaque, size_t size);
-
-/* Deallocating function pointer. Function SHOULD be no-op in the case the
-   address is 0. */
-typedef void (*brotli_free_func)(void* opaque, void* address);
-
-#endif  /* BROTLI_COMMON_TYPES_H_ */

data/vendor/brotli/dec/decode.h

@@ -1,188 +0,0 @@
-/* Copyright 2013 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* API for Brotli decompression */
-
-#ifndef BROTLI_DEC_DECODE_H_
-#define BROTLI_DEC_DECODE_H_
-
-#include "../common/types.h"
-
-#if defined(__cplusplus) || defined(c_plusplus)
-extern "C" {
-#endif
-
-typedef struct BrotliDecoderStateStruct BrotliDecoderState;
-
-typedef enum {
-  /* Decoding error, e.g. corrupt input or memory allocation problem */
-  BROTLI_DECODER_RESULT_ERROR = 0,
-  /* Decoding successfully completed */
-  BROTLI_DECODER_RESULT_SUCCESS = 1,
-  /* Partially done; should be called again with more input */
-  BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT = 2,
-  /* Partially done; should be called again with more output */
-  BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT = 3
-} BrotliDecoderResult;
-
-#define BROTLI_DECODER_ERROR_CODES_LIST(BROTLI_ERROR_CODE, SEPARATOR)      \
-  BROTLI_ERROR_CODE(_, NO_ERROR, 0) SEPARATOR                              \
-  /* Same as BrotliDecoderResult values */                                 \
-  BROTLI_ERROR_CODE(_, SUCCESS, 1) SEPARATOR                               \
-  BROTLI_ERROR_CODE(_, NEEDS_MORE_INPUT, 2) SEPARATOR                      \
-  BROTLI_ERROR_CODE(_, NEEDS_MORE_OUTPUT, 3) SEPARATOR                     \
-                                                                           \
-  /* Errors caused by invalid input */                                     \
-  BROTLI_ERROR_CODE(_ERROR_FORMAT_, EXUBERANT_NIBBLE, -1) SEPARATOR        \
-  BROTLI_ERROR_CODE(_ERROR_FORMAT_, RESERVED, -2) SEPARATOR                \
-  BROTLI_ERROR_CODE(_ERROR_FORMAT_, EXUBERANT_META_NIBBLE, -3) SEPARATOR   \
-  BROTLI_ERROR_CODE(_ERROR_FORMAT_, SIMPLE_HUFFMAN_ALPHABET, -4) SEPARATOR \
-  BROTLI_ERROR_CODE(_ERROR_FORMAT_, SIMPLE_HUFFMAN_SAME, -5) SEPARATOR     \
-  BROTLI_ERROR_CODE(_ERROR_FORMAT_, CL_SPACE, -6) SEPARATOR                \
-  BROTLI_ERROR_CODE(_ERROR_FORMAT_, HUFFMAN_SPACE, -7) SEPARATOR           \
-  BROTLI_ERROR_CODE(_ERROR_FORMAT_, CONTEXT_MAP_REPEAT, -8) SEPARATOR      \
-  BROTLI_ERROR_CODE(_ERROR_FORMAT_, BLOCK_LENGTH_1, -9) SEPARATOR          \
-  BROTLI_ERROR_CODE(_ERROR_FORMAT_, BLOCK_LENGTH_2, -10) SEPARATOR         \
-  BROTLI_ERROR_CODE(_ERROR_FORMAT_, TRANSFORM, -11) SEPARATOR              \
-  BROTLI_ERROR_CODE(_ERROR_FORMAT_, DICTIONARY, -12) SEPARATOR             \
-  BROTLI_ERROR_CODE(_ERROR_FORMAT_, WINDOW_BITS, -13) SEPARATOR            \
-  BROTLI_ERROR_CODE(_ERROR_FORMAT_, PADDING_1, -14) SEPARATOR              \
-  BROTLI_ERROR_CODE(_ERROR_FORMAT_, PADDING_2, -15) SEPARATOR              \
-                                                                           \
-  /* -16..-20 codes are reserved */                                        \
-                                                                           \
-  /* Memory allocation problems */                                         \
-  BROTLI_ERROR_CODE(_ERROR_ALLOC_, CONTEXT_MODES, -21) SEPARATOR           \
-  /* Literal, insert and distance trees together */                        \
-  BROTLI_ERROR_CODE(_ERROR_ALLOC_, TREE_GROUPS, -22) SEPARATOR             \
-  /* -23..-24 codes are reserved for distinct tree groups */               \
-  BROTLI_ERROR_CODE(_ERROR_ALLOC_, CONTEXT_MAP, -25) SEPARATOR             \
-  BROTLI_ERROR_CODE(_ERROR_ALLOC_, RING_BUFFER_1, -26) SEPARATOR           \
-  BROTLI_ERROR_CODE(_ERROR_ALLOC_, RING_BUFFER_2, -27) SEPARATOR           \
-  /* -28..-29 codes are reserved for dynamic ringbuffer allocation */      \
-  BROTLI_ERROR_CODE(_ERROR_ALLOC_, BLOCK_TYPE_TREES, -30) SEPARATOR        \
-                                                                           \
-  /* "Impossible" states */                                                \
-  BROTLI_ERROR_CODE(_ERROR_, UNREACHABLE, -31)
-
-typedef enum {
-#define _BROTLI_COMMA ,
-#define _BROTLI_ERROR_CODE_ENUM_ITEM(PREFIX, NAME, CODE) \
-    BROTLI_DECODER ## PREFIX ## NAME = CODE
-  BROTLI_DECODER_ERROR_CODES_LIST(_BROTLI_ERROR_CODE_ENUM_ITEM, _BROTLI_COMMA)
-#undef _BROTLI_ERROR_CODE_ENUM_ITEM
-#undef _BROTLI_COMMA
-} BrotliDecoderErrorCode;
-
-#define BROTLI_LAST_ERROR_CODE BROTLI_DECODER_ERROR_UNREACHABLE
-
-/* Creates the instance of BrotliDecoderState and initializes it. |alloc_func|
-   and |free_func| MUST be both zero or both non-zero. In the case they are both
-   zero, default memory allocators are used. |opaque| is passed to |alloc_func|
-   and |free_func| when they are called. */
-BrotliDecoderState* BrotliDecoderCreateInstance(
-    brotli_alloc_func alloc_func, brotli_free_func free_func, void* opaque);
-
-/* Deinitializes and frees BrotliDecoderState instance. */
-void BrotliDecoderDestroyInstance(BrotliDecoderState* state);
-
-/* Decompresses the data in |encoded_buffer| into |decoded_buffer|, and sets
-   |*decoded_size| to the decompressed length. */
-BrotliDecoderResult BrotliDecoderDecompress(
-    size_t encoded_size, const uint8_t* encoded_buffer, size_t* decoded_size,
-    uint8_t* decoded_buffer);
-
-/* Decompresses the data. Supports partial input and output.
-
-   Must be called with an allocated input buffer in |*next_in| and an allocated
-   output buffer in |*next_out|. The values |*available_in| and |*available_out|
-   must specify the allocated size in |*next_in| and |*next_out| respectively.
-
-   After each call, |*available_in| will be decremented by the amount of input
-   bytes consumed, and the |*next_in| pointer will be incremented by that
-   amount. Similarly, |*available_out| will be decremented by the amount of
-   output bytes written, and the |*next_out| pointer will be incremented by that
-   amount. |total_out|, if it is not a null-pointer, will be set to the number
-   of bytes decompressed since the last state initialization.
-
-   Input is never overconsumed, so |next_in| and |available_in| could be passed
-   to the next consumer after decoding is complete. */
-BrotliDecoderResult BrotliDecoderDecompressStream(
-  BrotliDecoderState* s, size_t* available_in, const uint8_t** next_in,
-  size_t* available_out, uint8_t** next_out, size_t* total_out);
-
-/* Fills the new state with a dictionary for LZ77, warming up the ringbuffer,
-   e.g. for custom static dictionaries for data formats.
-   Not to be confused with the built-in transformable dictionary of Brotli.
-   |size| should be less or equal to 2^24 (16MiB), otherwise the dictionary will
-   be ignored. The dictionary must exist in memory until decoding is done and
-   is owned by the caller. To use:
-    1) Allocate and initialize state with BrotliCreateInstance
-    2) Use BrotliSetCustomDictionary
-    3) Use BrotliDecompressStream
-    4) Clean up and free state with BrotliDestroyState
-*/
-void BrotliDecoderSetCustomDictionary(
-    BrotliDecoderState* s, size_t size, const uint8_t* dict);
-
-/* Returns true, if decoder has some unconsumed output.
-   Otherwise returns false. */
-BROTLI_BOOL BrotliDecoderHasMoreOutput(const BrotliDecoderState* s);
-
-/* Returns true, if decoder has already received some input bytes.
-   Otherwise returns false. */
-BROTLI_BOOL BrotliDecoderIsUsed(const BrotliDecoderState* s);
-
-/* Returns true, if decoder is in a state where we reached the end of the input
-   and produced all of the output; returns false otherwise. */
-BROTLI_BOOL BrotliDecoderIsFinished(const BrotliDecoderState* s);
-
-/* Returns detailed error code after BrotliDecompressStream returns
-   BROTLI_DECODER_RESULT_ERROR. */
-BrotliDecoderErrorCode BrotliDecoderGetErrorCode(const BrotliDecoderState* s);
-
-const char* BrotliDecoderErrorString(BrotliDecoderErrorCode c);
-
-/* DEPRECATED >>> */
-typedef enum {
-  BROTLI_RESULT_ERROR = 0,
-  BROTLI_RESULT_SUCCESS = 1,
-  BROTLI_RESULT_NEEDS_MORE_INPUT = 2,
-  BROTLI_RESULT_NEEDS_MORE_OUTPUT = 3
-} BrotliResult;
-typedef enum {
-#define _BROTLI_COMMA ,
-#define _BROTLI_ERROR_CODE_ENUM_ITEM(PREFIX, NAME, CODE) \
-    BROTLI ## PREFIX ## NAME = CODE
-  BROTLI_DECODER_ERROR_CODES_LIST(_BROTLI_ERROR_CODE_ENUM_ITEM, _BROTLI_COMMA)
-#undef _BROTLI_ERROR_CODE_ENUM_ITEM
-#undef _BROTLI_COMMA
-} BrotliErrorCode;
-typedef struct BrotliStateStruct BrotliState;
-BrotliState* BrotliCreateState(
-    brotli_alloc_func alloc, brotli_free_func free, void* opaque);
-void BrotliDestroyState(BrotliState* state);
-BROTLI_BOOL BrotliDecompressedSize(
-    size_t encoded_size, const uint8_t* encoded_buffer, size_t* decoded_size);
-BrotliResult BrotliDecompressBuffer(
-    size_t encoded_size, const uint8_t* encoded_buffer, size_t* decoded_size,
-    uint8_t* decoded_buffer);
-BrotliResult BrotliDecompressStream(
-    size_t* available_in, const uint8_t** next_in, size_t* available_out,
-    uint8_t** next_out, size_t* total_out, BrotliState* s);
-void BrotliSetCustomDictionary(
-    size_t size, const uint8_t* dict, BrotliState* s);
-BROTLI_BOOL BrotliStateIsStreamStart(const BrotliState* s);
-BROTLI_BOOL BrotliStateIsStreamEnd(const BrotliState* s);
-BrotliErrorCode BrotliGetErrorCode(const BrotliState* s);
-const char* BrotliErrorString(BrotliErrorCode c);
-/* <<< DEPRECATED */
-
-#if defined(__cplusplus) || defined(c_plusplus)
-} /* extern "C" */
-#endif
-
-#endif  /* BROTLI_DEC_DECODE_H_ */

data/vendor/brotli/enc/compressor.cc

@@ -1,139 +0,0 @@
-/* Copyright 2016 Google Inc. All Rights Reserved.
-
-   Distributed under MIT license.
-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
-*/
-
-/* Brotli compressor API C++ wrapper and utilities. */
-
-#include "./compressor.h"
-
-#include <cstdlib>  /* exit */
-
-namespace brotli {
-
-static void SetParams(const BrotliParams* from, BrotliEncoderState* to) {
-  BrotliEncoderMode mode = BROTLI_MODE_GENERIC;
-  if (from->mode == BrotliParams::MODE_TEXT) {
-    mode = BROTLI_MODE_TEXT;
-  } else if (from->mode == BrotliParams::MODE_FONT) {
-    mode = BROTLI_MODE_FONT;
-  }
-  BrotliEncoderSetParameter(to, BROTLI_PARAM_MODE, (uint32_t)mode);
-  BrotliEncoderSetParameter(to, BROTLI_PARAM_QUALITY, (uint32_t)from->quality);
-  BrotliEncoderSetParameter(to, BROTLI_PARAM_LGWIN, (uint32_t)from->lgwin);
-  BrotliEncoderSetParameter(to, BROTLI_PARAM_LGBLOCK, (uint32_t)from->lgblock);
-}
-
-BrotliCompressor::BrotliCompressor(BrotliParams params) {
-  state_ = BrotliEncoderCreateInstance(0, 0, 0);
-  if (state_ == 0) std::exit(EXIT_FAILURE);  /* OOM */
-  SetParams(&params, state_);
-}
-
-BrotliCompressor::~BrotliCompressor(void) {
-  BrotliEncoderDestroyInstance(state_);
-}
-
-bool BrotliCompressor::WriteMetaBlock(const size_t input_size,
-                                      const uint8_t* input_buffer,
-                                      const bool is_last, size_t* encoded_size,
-                                      uint8_t* encoded_buffer) {
-  return !!BrotliEncoderWriteMetaBlock(state_, input_size, input_buffer,
-                                       TO_BROTLI_BOOL(is_last), encoded_size,
-                                       encoded_buffer);
-}
-
-bool BrotliCompressor::WriteMetadata(const size_t input_size,
-                                     const uint8_t* input_buffer,
-                                     const bool is_last, size_t* encoded_size,
-                                     uint8_t* encoded_buffer) {
-  return !!BrotliEncoderWriteMetadata(state_, input_size, input_buffer,
-                                      TO_BROTLI_BOOL(is_last), encoded_size,
-                                      encoded_buffer);
-}
-
-bool BrotliCompressor::FinishStream(size_t* encoded_size,
-                                    uint8_t* encoded_buffer) {
-  return !!BrotliEncoderFinishStream(state_, encoded_size, encoded_buffer);
-}
-
-void BrotliCompressor::CopyInputToRingBuffer(const size_t input_size,
-                                             const uint8_t* input_buffer) {
-  BrotliEncoderCopyInputToRingBuffer(state_, input_size, input_buffer);
-}
-
-bool BrotliCompressor::WriteBrotliData(const bool is_last,
-                                       const bool force_flush, size_t* out_size,
-                                       uint8_t** output) {
-  return !!BrotliEncoderWriteData(state_, TO_BROTLI_BOOL(is_last),
-      TO_BROTLI_BOOL(force_flush), out_size, output);
-}
-
-void BrotliCompressor::BrotliSetCustomDictionary(size_t size,
-                                                 const uint8_t* dict) {
-  BrotliEncoderSetCustomDictionary(state_, size, dict);
-}
-
-int BrotliCompressBuffer(BrotliParams params, size_t input_size,
-                         const uint8_t* input_buffer, size_t* encoded_size,
-                         uint8_t* encoded_buffer) {
-  return BrotliEncoderCompress(params.quality, params.lgwin,
-      (BrotliEncoderMode)params.mode, input_size, input_buffer,
-      encoded_size, encoded_buffer);
-}
-
-int BrotliCompress(BrotliParams params, BrotliIn* in, BrotliOut* out) {
-  return BrotliCompressWithCustomDictionary(0, 0, params, in, out);
-}
-
-int BrotliCompressWithCustomDictionary(size_t dictsize, const uint8_t* dict,
-                                       BrotliParams params, BrotliIn* in,
-                                       BrotliOut* out) {
-  const size_t kOutputBufferSize = 65536;
-  uint8_t* output_buffer;
-  bool result = true;
-  size_t available_in = 0;
-  const uint8_t* next_in = NULL;
-  size_t total_out = 0;
-  bool end_of_input = false;
-  BrotliEncoderState* s;
-
-  s = BrotliEncoderCreateInstance(0, 0, 0);
-  if (!s) return 0;
-  SetParams(&params, s);
-  BrotliEncoderSetCustomDictionary(s, dictsize, dict);
-  output_buffer = new uint8_t[kOutputBufferSize];
-
-  while (true) {
-    if (available_in == 0 && !end_of_input) {
-      next_in = reinterpret_cast<const uint8_t*>(
-          in->Read(BrotliEncoderInputBlockSize(s), &available_in));
-      if (!next_in) {
-        end_of_input = true;
-        available_in = 0;
-      } else if (available_in == 0) {
-        continue;
-      }
-    }
-    size_t available_out = kOutputBufferSize;
-    uint8_t* next_out = output_buffer;
-    result = !!BrotliEncoderCompressStream(
-        s, end_of_input ? BROTLI_OPERATION_FINISH : BROTLI_OPERATION_PROCESS,
-        &available_in, &next_in, &available_out, &next_out, &total_out);
-    if (!result) break;
-    size_t used_output = kOutputBufferSize - available_out;
-    if (used_output != 0) {
-      result = out->Write(output_buffer, used_output);
-      if (!result) break;
-    }
-    if (BrotliEncoderIsFinished(s)) break;
-  }
-
-  delete[] output_buffer;
-  BrotliEncoderDestroyInstance(s);
-  return result ? 1 : 0;
-}
-
-
-}  /* namespace brotli */