extbrotli 0.0.1.PROTOTYPE2-x86-mingw32

data/contrib/brotli/dec/state.c

@@ -0,0 +1,149 @@
+/* Copyright 2015 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,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+#include "./huffman.h"
+#include "./state.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+void BrotliStateInit(BrotliState* s) {
+  s->state = BROTLI_STATE_UNINITED;
+  s->sub0_state = BROTLI_STATE_SUB0_NONE;
+  s->sub1_state = BROTLI_STATE_SUB1_NONE;
+
+  s->block_type_trees = NULL;
+  s->block_len_trees = NULL;
+  s->ringbuffer = NULL;
+
+  s->context_map = NULL;
+  s->context_modes = NULL;
+  s->dist_context_map = NULL;
+  s->context_map_slice = NULL;
+  s->dist_context_map_slice = NULL;
+
+  s->literal_hgroup.codes = NULL;
+  s->literal_hgroup.htrees = NULL;
+  s->insert_copy_hgroup.codes = NULL;
+  s->insert_copy_hgroup.htrees = NULL;
+  s->distance_hgroup.codes = NULL;
+  s->distance_hgroup.htrees = NULL;
+
+  s->custom_dict = NULL;
+  s->custom_dict_size = 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->block_type_trees = NULL;
+  s->block_len_trees = NULL;
+
+  /* Make small negative indexes addressable. */
+  s->symbol_lists = &s->symbols_lists_array[BROTLI_HUFFMAN_MAX_CODE_LENGTH + 1];
+
+  s->mtf_upper_bound = 255;
+}
+
+void BrotliStateMetablockBegin(BrotliState* s) {
+  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->num_block_types[0] = 1;
+  s->num_block_types[1] = 1;
+  s->num_block_types[2] = 1;
+  s->block_type_rb[0] = 1;
+  s->block_type_rb[1] = 0;
+  s->block_type_rb[2] = 1;
+  s->block_type_rb[3] = 0;
+  s->block_type_rb[4] = 1;
+  s->block_type_rb[5] = 0;
+  s->context_map = NULL;
+  s->context_modes = NULL;
+  s->dist_context_map = NULL;
+  s->context_map_slice = NULL;
+  s->literal_htree_index = 0;
+  s->literal_htree = NULL;
+  s->dist_context_map_slice = NULL;
+  s->dist_htree_index = 0;
+  s->context_lookup1 = NULL;
+  s->context_lookup2 = NULL;
+  s->literal_hgroup.codes = NULL;
+  s->literal_hgroup.htrees = NULL;
+  s->insert_copy_hgroup.codes = NULL;
+  s->insert_copy_hgroup.htrees = NULL;
+  s->distance_hgroup.codes = NULL;
+  s->distance_hgroup.htrees = NULL;
+}
+
+void BrotliStateCleanupAfterMetablock(BrotliState* s) {
+  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;
+  }
+
+  BrotliHuffmanTreeGroupRelease(&s->literal_hgroup);
+  BrotliHuffmanTreeGroupRelease(&s->insert_copy_hgroup);
+  BrotliHuffmanTreeGroupRelease(&s->distance_hgroup);
+  s->literal_hgroup.codes = NULL;
+  s->literal_hgroup.htrees = NULL;
+  s->insert_copy_hgroup.codes = NULL;
+  s->insert_copy_hgroup.htrees = NULL;
+  s->distance_hgroup.codes = NULL;
+  s->distance_hgroup.htrees = NULL;
+}
+
+void BrotliStateCleanup(BrotliState* s) {
+  if (s->context_modes != 0) {
+    free(s->context_modes);
+  }
+  if (s->context_map != 0) {
+    free(s->context_map);
+  }
+  if (s->dist_context_map != 0) {
+    free(s->dist_context_map);
+  }
+  BrotliHuffmanTreeGroupRelease(&s->literal_hgroup);
+  BrotliHuffmanTreeGroupRelease(&s->insert_copy_hgroup);
+  BrotliHuffmanTreeGroupRelease(&s->distance_hgroup);
+
+  if (s->ringbuffer != 0) {
+    free(s->ringbuffer);
+  }
+  if (s->block_type_trees != 0) {
+    free(s->block_type_trees);
+  }
+}
+
+#if defined(__cplusplus) || defined(c_plusplus)
+} /* extern "C" */
+#endif

data/contrib/brotli/dec/state.h

@@ -0,0 +1,185 @@
+/* Copyright 2015 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,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+/* Brotli state for partial streaming decoding. */
+
+#ifndef BROTLI_DEC_STATE_H_
+#define BROTLI_DEC_STATE_H_
+
+#include <stdio.h>
+#include "./bit_reader.h"
+#include "./huffman.h"
+#include "./streams.h"
+#include "./types.h"
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+typedef enum {
+  BROTLI_STATE_UNINITED,
+  BROTLI_STATE_BITREADER_WARMUP,
+  BROTLI_STATE_METABLOCK_BEGIN,
+  BROTLI_STATE_METABLOCK_HEADER_1,
+  BROTLI_STATE_METABLOCK_HEADER_2,
+  BROTLI_STATE_COMMAND_BEGIN,
+  BROTLI_STATE_COMMAND_INNER,
+  BROTLI_STATE_UNCOMPRESSED,
+  BROTLI_STATE_METADATA,
+  BROTLI_STATE_COMMAND_INNER_WRITE,
+  BROTLI_STATE_METABLOCK_DONE,
+  BROTLI_STATE_COMMAND_POST_WRITE_1,
+  BROTLI_STATE_COMMAND_POST_WRITE_2,
+  BROTLI_STATE_COMMAND_POST_WRAP_COPY,
+  BROTLI_STATE_HUFFMAN_CODE_0,
+  BROTLI_STATE_HUFFMAN_CODE_1,
+  BROTLI_STATE_HUFFMAN_CODE_2,
+  BROTLI_STATE_CONTEXT_MAP_1,
+  BROTLI_STATE_CONTEXT_MAP_2,
+  BROTLI_STATE_TREE_GROUP,
+  BROTLI_STATE_DONE
+} BrotliRunningState;
+
+typedef enum {
+  BROTLI_STATE_SUB0_NONE,
+  BROTLI_STATE_SUB0_UNCOMPRESSED_SHORT,
+  BROTLI_STATE_SUB0_UNCOMPRESSED_FILL,
+  BROTLI_STATE_SUB0_UNCOMPRESSED_COPY,
+  BROTLI_STATE_SUB0_UNCOMPRESSED_WARMUP,
+  BROTLI_STATE_SUB0_UNCOMPRESSED_WRITE_1,
+  BROTLI_STATE_SUB0_UNCOMPRESSED_WRITE_2,
+  BROTLI_STATE_SUB0_UNCOMPRESSED_WRITE_3,
+  BROTLI_STATE_SUB0_TREE_GROUP,
+  BROTLI_STATE_SUB0_CONTEXT_MAP_HUFFMAN,
+  BROTLI_STATE_SUB0_CONTEXT_MAPS
+} BrotliRunningSub0State;
+
+typedef enum {
+  BROTLI_STATE_SUB1_NONE,
+  BROTLI_STATE_SUB1_HUFFMAN_LENGTH_SYMBOLS
+} BrotliRunningSub1State;
+
+typedef struct {
+  BrotliRunningState state;
+  /* This counter is reused for several disjoint loops. */
+  BrotliBitReader br;
+  int loop_counter;
+  int pos;
+  int max_backward_distance;
+  int max_backward_distance_minus_custom_dict_size;
+  int max_distance;
+  int ringbuffer_size;
+  int ringbuffer_mask;
+  int dist_rb_idx;
+  int dist_rb[4];
+  uint8_t* ringbuffer;
+  uint8_t* ringbuffer_end;
+  HuffmanCode* htree_command;
+  const uint8_t* context_lookup1;
+  const uint8_t* context_lookup2;
+  uint8_t* context_map_slice;
+  uint8_t* dist_context_map_slice;
+
+  /* This ring buffer holds a few past copy distances that will be used by */
+  /* some special distance codes. */
+  HuffmanTreeGroup literal_hgroup;
+  HuffmanTreeGroup insert_copy_hgroup;
+  HuffmanTreeGroup distance_hgroup;
+  HuffmanCode* block_type_trees;
+  HuffmanCode* block_len_trees;
+  /* This is true if the literal context map histogram type always matches the
+  block type. It is then not needed to keep the context (faster decoding). */
+  int trivial_literal_context;
+  int distance_context;
+  int meta_block_remaining_len;
+  int block_length[3];
+  int num_block_types[3];
+  int block_type_rb[6];
+  int distance_postfix_bits;
+  int num_direct_distance_codes;
+  int distance_postfix_mask;
+  uint8_t* dist_context_map;
+  uint8_t literal_htree_index;
+  HuffmanCode *literal_htree;
+  uint8_t dist_htree_index;
+  uint8_t repeat_code_len;
+  uint8_t prev_code_len;
+
+  int copy_length;
+  int distance_code;
+
+  /* For partial write operations */
+  int to_write;
+  int partially_written;
+
+  /* For ReadHuffmanCode */
+  uint32_t symbol;
+  uint32_t repeat;
+  uint32_t space;
+
+  HuffmanCode table[32];
+  /* List of of symbol chains. */
+  uint16_t* symbol_lists;
+  /* Storage from symbol_lists. */
+  uint16_t symbols_lists_array[BROTLI_HUFFMAN_MAX_CODE_LENGTH + 1 +
+      BROTLI_HUFFMAN_MAX_CODE_LENGTHS_SIZE];
+  /* Tails of symbol chains. */
+  int next_symbol[32];
+  uint8_t code_length_code_lengths[18];
+  /* Population counts for the code lengths */
+  uint16_t code_length_histo[16];
+
+  /* For HuffmanTreeGroupDecode */
+  int htree_index;
+  HuffmanCode* next;
+
+  /* For DecodeContextMap */
+  int context_index;
+  int max_run_length_prefix;
+  HuffmanCode context_map_table[BROTLI_HUFFMAN_MAX_TABLE_SIZE];
+
+  /* For InverseMoveToFrontTransform */
+  int mtf_upper_bound;
+  uint8_t mtf[256];
+
+  /* For custom dictionaries */
+  const uint8_t* custom_dict;
+  int custom_dict_size;
+
+  /* less used attributes are in the end of this struct */
+  BrotliRunningSub0State sub0_state;  /* State inside function call */
+  BrotliRunningSub1State sub1_state;  /* State inside function call */
+
+  int input_end;
+  uint32_t window_bits;
+
+  /* For CopyUncompressedBlockToOutput */
+  int nbytes;
+
+  int num_literal_htrees;
+  uint8_t* context_map;
+  uint8_t* context_modes;
+} BrotliState;
+
+void BrotliStateInit(BrotliState* s);
+void BrotliStateCleanup(BrotliState* s);
+void BrotliStateMetablockBegin(BrotliState* s);
+void BrotliStateCleanupAfterMetablock(BrotliState* s);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+} /* extern "C" */
+#endif
+
+#endif  /* BROTLI_DEC_STATE_H_ */

data/contrib/brotli/dec/streams.c

@@ -0,0 +1,99 @@
+/* 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,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+/* Functions for streaming input and output. */
+
+#include <string.h>
+#ifndef _WIN32
+#include <unistd.h>
+#endif
+#include "./streams.h"
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+int BrotliMemInputFunction(void* data, uint8_t* buf, size_t count) {
+  BrotliMemInput* input = (BrotliMemInput*)data;
+  if (input->pos > input->length) {
+    return -1;
+  }
+  if (input->pos + count > input->length) {
+    count = input->length - input->pos;
+  }
+  memcpy(buf, input->buffer + input->pos, count);
+  input->pos += count;
+  return (int)count;
+}
+
+BrotliInput BrotliInitMemInput(const uint8_t* buffer, size_t length,
+                               BrotliMemInput* mem_input) {
+  BrotliInput input;
+  mem_input->buffer = buffer;
+  mem_input->length = length;
+  mem_input->pos = 0;
+  input.cb_ = &BrotliMemInputFunction;
+  input.data_ = mem_input;
+  return input;
+}
+
+int BrotliMemOutputFunction(void* data, const uint8_t* buf, size_t count) {
+  BrotliMemOutput* output = (BrotliMemOutput*)data;
+  size_t limit = output->length - output->pos;
+  if (count > limit) {
+    count = limit;
+  }
+  memcpy(output->buffer + output->pos, buf, count);
+  output->pos += count;
+  return (int)count;
+}
+
+BrotliOutput BrotliInitMemOutput(uint8_t* buffer, size_t length,
+                                 BrotliMemOutput* mem_output) {
+  BrotliOutput output;
+  mem_output->buffer = buffer;
+  mem_output->length = length;
+  mem_output->pos = 0;
+  output.cb_ = &BrotliMemOutputFunction;
+  output.data_ = mem_output;
+  return output;
+}
+
+int BrotliFileInputFunction(void* data, uint8_t* buf, size_t count) {
+  return (int)fread(buf, 1, count, (FILE*)data);
+}
+
+BrotliInput BrotliFileInput(FILE* f) {
+  BrotliInput in;
+  in.cb_ = BrotliFileInputFunction;
+  in.data_ = f;
+  return in;
+}
+
+int BrotliFileOutputFunction(void* data, const uint8_t* buf, size_t count) {
+  return (int)fwrite(buf, 1, count, (FILE*)data);
+}
+
+BrotliOutput BrotliFileOutput(FILE* f) {
+  BrotliOutput out;
+  out.cb_ = BrotliFileOutputFunction;
+  out.data_ = f;
+  return out;
+}
+
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}    /* extern "C" */
+#endif

data/contrib/brotli/dec/streams.h

@@ -0,0 +1,100 @@
+/* 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,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+/* Functions for streaming input and output. */
+
+#ifndef BROTLI_DEC_STREAMS_H_
+#define BROTLI_DEC_STREAMS_H_
+
+#include <stdio.h>
+#include "./port.h"
+#include "./types.h"
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+/* Function pointer type used to read len bytes into buf. Returns the */
+/* number of bytes read or -1 on error. */
+typedef int (*BrotliInputFunction)(void* data, uint8_t* buf, size_t len);
+
+/* Input callback function with associated data. */
+typedef struct {
+  BrotliInputFunction cb_;
+  void* data_;
+} BrotliInput;
+
+/* Reads len bytes into buf, using the in callback. */
+static BROTLI_INLINE int BrotliRead(BrotliInput in, uint8_t* buf, size_t len) {
+  return in.cb_(in.data_, buf, len);
+}
+
+/* Function pointer type used to write len bytes into buf. Returns the */
+/* number of bytes written or -1 on error. */
+typedef int (*BrotliOutputFunction)(void* data, const uint8_t* buf, size_t len);
+
+/* Output callback function with associated data. */
+typedef struct {
+  BrotliOutputFunction cb_;
+  void* data_;
+} BrotliOutput;
+
+/* Writes len bytes into buf, using the out callback. */
+static BROTLI_INLINE int BrotliWrite(BrotliOutput out,
+                                     const uint8_t* buf, size_t len) {
+  return out.cb_(out.data_, buf, len);
+}
+
+/* Memory region with position. */
+typedef struct {
+  const uint8_t* buffer;
+  size_t length;
+  size_t pos;
+} BrotliMemInput;
+
+/* Input callback where *data is a BrotliMemInput struct. */
+int BrotliMemInputFunction(void* data, uint8_t* buf, size_t count);
+
+/* Returns an input callback that wraps the given memory region. */
+BrotliInput BrotliInitMemInput(const uint8_t* buffer, size_t length,
+                               BrotliMemInput* mem_input);
+
+/* Output buffer with position. */
+typedef struct {
+  uint8_t* buffer;
+  size_t length;
+  size_t pos;
+} BrotliMemOutput;
+
+/* Output callback where *data is a BrotliMemOutput struct. */
+int BrotliMemOutputFunction(void* data, const uint8_t* buf, size_t count);
+
+/* Returns an output callback that wraps the given memory region. */
+BrotliOutput BrotliInitMemOutput(uint8_t* buffer, size_t length,
+                                 BrotliMemOutput* mem_output);
+
+/* Input callback that reads from a file. */
+int BrotliFileInputFunction(void* data, uint8_t* buf, size_t count);
+BrotliInput BrotliFileInput(FILE* f);
+
+/* Output callback that writes to a file. */
+int BrotliFileOutputFunction(void* data, const uint8_t* buf, size_t count);
+BrotliOutput BrotliFileOutput(FILE* f);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}    /* extern "C" */
+#endif
+
+#endif  /* BROTLI_DEC_STREAMS_H_ */