#include <string.h> /* memcpy, memset */\r
\r
#include "../common/constants.h"\r
-#include "../common/types.h"\r
-#include "./context.h"\r
+#include "../common/context.h"\r
+#include "../common/platform.h"\r
+#include <brotli/types.h>\r
#include "./entropy_encode.h"\r
#include "./entropy_encode_static.h"\r
#include "./fast_log.h"\r
+#include "./histogram.h"\r
#include "./memory.h"\r
-#include "./port.h"\r
#include "./write_bits.h"\r
\r
#if defined(__cplusplus) || defined(c_plusplus)\r
#endif\r
\r
#define MAX_HUFFMAN_TREE_SIZE (2 * BROTLI_NUM_COMMAND_SYMBOLS + 1)\r
+/* The maximum size of Huffman dictionary for distances assuming that\r
+ NPOSTFIX = 0 and NDIRECT = 0. */\r
+#define MAX_SIMPLE_DISTANCE_ALPHABET_SIZE \\r
+ BROTLI_DISTANCE_ALPHABET_SIZE(0, 0, BROTLI_LARGE_MAX_DISTANCE_BITS)\r
+/* MAX_SIMPLE_DISTANCE_ALPHABET_SIZE == 140 */\r
\r
/* Represents the range of values belonging to a prefix code:\r
[offset, offset + 2^nbits) */\r
return type_code;\r
}\r
\r
-/* nibblesbits represents the 2 bits to encode MNIBBLES (0-3)\r
+/* |nibblesbits| represents the 2 bits to encode MNIBBLES (0-3)\r
REQUIRES: length > 0\r
REQUIRES: length <= (1 << 24) */\r
static void BrotliEncodeMlen(size_t length, uint64_t* bits,\r
size_t* numbits, uint64_t* nibblesbits) {\r
size_t lg = (length == 1) ? 1 : Log2FloorNonZero((uint32_t)(length - 1)) + 1;\r
size_t mnibbles = (lg < 16 ? 16 : (lg + 3)) / 4;\r
- assert(length > 0);\r
- assert(length <= (1 << 24));\r
- assert(lg <= 24);\r
+ BROTLI_DCHECK(length > 0);\r
+ BROTLI_DCHECK(length <= (1 << 24));\r
+ BROTLI_DCHECK(lg <= 24);\r
*nibblesbits = mnibbles - 4;\r
*numbits = mnibbles * 4;\r
*bits = length - 1;\r
size_t symbols[4],\r
size_t num_symbols,\r
size_t max_bits,\r
- size_t *storage_ix, uint8_t *storage) {\r
+ size_t* storage_ix, uint8_t* storage) {\r
/* value of 1 indicates a simple Huffman code */\r
BrotliWriteBits(2, 1, storage_ix, storage);\r
BrotliWriteBits(2, num_symbols - 1, storage_ix, storage); /* NSYM - 1 */\r
depths = symbol depths */\r
void BrotliStoreHuffmanTree(const uint8_t* depths, size_t num,\r
HuffmanTree* tree,\r
- size_t *storage_ix, uint8_t *storage) {\r
+ size_t* storage_ix, uint8_t* storage) {\r
/* Write the Huffman tree into the brotli-representation.\r
The command alphabet is the largest, so this allocation will fit all\r
alphabets. */\r
int num_codes = 0;\r
size_t code = 0;\r
\r
- assert(num <= BROTLI_NUM_COMMAND_SYMBOLS);\r
+ BROTLI_DCHECK(num <= BROTLI_NUM_COMMAND_SYMBOLS);\r
\r
BrotliWriteHuffmanTree(depths, num, &huffman_tree_size, huffman_tree,\r
huffman_tree_extra_bits);\r
code_length_bitdepth[code] = 0;\r
}\r
\r
- /* Store the real huffman tree now. */\r
+ /* Store the real Huffman tree now. */\r
BrotliStoreHuffmanTreeToBitMask(huffman_tree_size,\r
huffman_tree,\r
huffman_tree_extra_bits,\r
\r
/* Builds a Huffman tree from histogram[0:length] into depth[0:length] and\r
bits[0:length] and stores the encoded tree to the bit stream. */\r
-static void BuildAndStoreHuffmanTree(const uint32_t *histogram,\r
- const size_t length,\r
+static void BuildAndStoreHuffmanTree(const uint32_t* histogram,\r
+ const size_t histogram_length,\r
+ const size_t alphabet_size,\r
HuffmanTree* tree,\r
uint8_t* depth,\r
uint16_t* bits,\r
size_t s4[4] = { 0 };\r
size_t i;\r
size_t max_bits = 0;\r
- for (i = 0; i < length; i++) {\r
+ for (i = 0; i < histogram_length; i++) {\r
if (histogram[i]) {\r
if (count < 4) {\r
s4[count] = i;\r
}\r
\r
{\r
- size_t max_bits_counter = length - 1;\r
+ size_t max_bits_counter = alphabet_size - 1;\r
while (max_bits_counter) {\r
max_bits_counter >>= 1;\r
++max_bits;\r
return;\r
}\r
\r
- memset(depth, 0, length * sizeof(depth[0]));\r
- BrotliCreateHuffmanTree(histogram, length, 15, tree, depth);\r
- BrotliConvertBitDepthsToSymbols(depth, length, bits);\r
+ memset(depth, 0, histogram_length * sizeof(depth[0]));\r
+ BrotliCreateHuffmanTree(histogram, histogram_length, 15, tree, depth);\r
+ BrotliConvertBitDepthsToSymbols(depth, histogram_length, bits);\r
\r
if (count <= 4) {\r
StoreSimpleHuffmanTree(depth, s4, count, max_bits, storage_ix, storage);\r
} else {\r
- BrotliStoreHuffmanTree(depth, length, tree, storage_ix, storage);\r
+ BrotliStoreHuffmanTree(depth, histogram_length, tree, storage_ix, storage);\r
}\r
}\r
\r
for (l = length; l != 0;) {\r
--l;\r
if (histogram[l]) {\r
- if (PREDICT_TRUE(histogram[l] >= count_limit)) {\r
+ if (BROTLI_PREDICT_TRUE(histogram[l] >= count_limit)) {\r
InitHuffmanTree(node, histogram[l], -1, (int16_t)l);\r
} else {\r
InitHuffmanTree(node, count_limit, -1, (int16_t)l);\r
/* Complex Huffman Tree */\r
StoreStaticCodeLengthCode(storage_ix, storage);\r
\r
- /* Actual rle coding. */\r
+ /* Actual RLE coding. */\r
for (i = 0; i < length;) {\r
const uint8_t value = depth[i];\r
size_t reps = 1;\r
for (i = 1; i < v_size; ++i) {\r
if (v_in[i] > max_value) max_value = v_in[i];\r
}\r
- assert(max_value < 256u);\r
+ BROTLI_DCHECK(max_value < 256u);\r
for (i = 0; i <= max_value; ++i) {\r
mtf[i] = (uint8_t)i;\r
}\r
size_t mtf_size = max_value + 1;\r
for (i = 0; i < v_size; ++i) {\r
size_t index = IndexOf(mtf, mtf_size, (uint8_t)v_in[i]);\r
- assert(index < mtf_size);\r
+ BROTLI_DCHECK(index < mtf_size);\r
v_out[i] = (uint32_t)index;\r
MoveToFront(mtf, index);\r
}\r
*max_run_length_prefix = max_prefix;\r
*out_size = 0;\r
for (i = 0; i < in_size;) {\r
- assert(*out_size <= i);\r
+ BROTLI_DCHECK(*out_size <= i);\r
if (v[i] != 0) {\r
v[*out_size] = v[i] + *max_run_length_prefix;\r
++i;\r
}\r
}\r
BuildAndStoreHuffmanTree(histogram, num_clusters + max_run_length_prefix,\r
+ num_clusters + max_run_length_prefix,\r
tree, depths, bits, storage_ix, storage);\r
for (i = 0; i < num_rle_symbols; ++i) {\r
const uint32_t rle_symbol = rle_symbols[i] & kSymbolMask;\r
}\r
StoreVarLenUint8(num_types - 1, storage_ix, storage);\r
if (num_types > 1) { /* TODO: else? could StoreBlockSwitch occur? */\r
- BuildAndStoreHuffmanTree(&type_histo[0], num_types + 2, tree,\r
+ BuildAndStoreHuffmanTree(&type_histo[0], num_types + 2, num_types + 2, tree,\r
&code->type_depths[0], &code->type_bits[0],\r
storage_ix, storage);\r
BuildAndStoreHuffmanTree(&length_histo[0], BROTLI_NUM_BLOCK_LEN_SYMBOLS,\r
+ BROTLI_NUM_BLOCK_LEN_SYMBOLS,\r
tree, &code->length_depths[0],\r
&code->length_bits[0], storage_ix, storage);\r
StoreBlockSwitch(code, lengths[0], types[0], 1, storage_ix, storage);\r
for (i = context_bits; i < alphabet_size; ++i) {\r
histogram[i] = 1;\r
}\r
- BuildAndStoreHuffmanTree(histogram, alphabet_size, tree,\r
- depths, bits, storage_ix, storage);\r
+ BuildAndStoreHuffmanTree(histogram, alphabet_size, alphabet_size,\r
+ tree, depths, bits, storage_ix, storage);\r
for (i = 0; i < num_types; ++i) {\r
size_t code = (i == 0 ? 0 : i + context_bits - 1);\r
BrotliWriteBits(depths[code], bits[code], storage_ix, storage);\r
\r
/* Manages the encoding of one block category (literal, command or distance). */\r
typedef struct BlockEncoder {\r
- size_t alphabet_size_;\r
+ size_t histogram_length_;\r
size_t num_block_types_;\r
const uint8_t* block_types_; /* Not owned. */\r
const uint32_t* block_lengths_; /* Not owned. */\r
uint16_t* bits_;\r
} BlockEncoder;\r
\r
-static void InitBlockEncoder(BlockEncoder* self, size_t alphabet_size,\r
+static void InitBlockEncoder(BlockEncoder* self, size_t histogram_length,\r
size_t num_block_types, const uint8_t* block_types,\r
const uint32_t* block_lengths, const size_t num_blocks) {\r
- self->alphabet_size_ = alphabet_size;\r
+ self->histogram_length_ = histogram_length;\r
self->num_block_types_ = num_block_types;\r
self->block_types_ = block_types;\r
self->block_lengths_ = block_lengths;\r
uint32_t block_len = self->block_lengths_[block_ix];\r
uint8_t block_type = self->block_types_[block_ix];\r
self->block_len_ = block_len;\r
- self->entropy_ix_ = block_type * self->alphabet_size_;\r
+ self->entropy_ix_ = block_type * self->histogram_length_;\r
StoreBlockSwitch(&self->block_split_code_, block_len, block_type, 0,\r
storage_ix, storage);\r
}\r
--self->block_len_;\r
{\r
size_t histo_ix = context_map[self->entropy_ix_ + context];\r
- size_t ix = histo_ix * self->alphabet_size_ + symbol;\r
+ size_t ix = histo_ix * self->histogram_length_ + symbol;\r
BrotliWriteBits(self->depths_[ix], self->bits_[ix], storage_ix, storage);\r
}\r
}\r
}\r
\r
void BrotliStoreMetaBlock(MemoryManager* m,\r
- const uint8_t* input,\r
- size_t start_pos,\r
- size_t length,\r
- size_t mask,\r
- uint8_t prev_byte,\r
- uint8_t prev_byte2,\r
- BROTLI_BOOL is_last,\r
- uint32_t num_direct_distance_codes,\r
- uint32_t distance_postfix_bits,\r
- ContextType literal_context_mode,\r
- const Command *commands,\r
- size_t n_commands,\r
- const MetaBlockSplit* mb,\r
- size_t *storage_ix,\r
- uint8_t *storage) {\r
+ const uint8_t* input, size_t start_pos, size_t length, size_t mask,\r
+ uint8_t prev_byte, uint8_t prev_byte2, BROTLI_BOOL is_last,\r
+ const BrotliEncoderParams* params, ContextType literal_context_mode,\r
+ const Command* commands, size_t n_commands, const MetaBlockSplit* mb,\r
+ size_t* storage_ix, uint8_t* storage) {\r
+\r
size_t pos = start_pos;\r
size_t i;\r
- size_t num_distance_codes =\r
- BROTLI_NUM_DISTANCE_SHORT_CODES + num_direct_distance_codes +\r
- (48u << distance_postfix_bits);\r
+ uint32_t num_distance_symbols = params->dist.alphabet_size;\r
+ uint32_t num_effective_distance_symbols = num_distance_symbols;\r
HuffmanTree* tree;\r
+ ContextLut literal_context_lut = BROTLI_CONTEXT_LUT(literal_context_mode);\r
BlockEncoder literal_enc;\r
BlockEncoder command_enc;\r
BlockEncoder distance_enc;\r
+ const BrotliDistanceParams* dist = ¶ms->dist;\r
+ if (params->large_window &&\r
+ num_effective_distance_symbols > BROTLI_NUM_HISTOGRAM_DISTANCE_SYMBOLS) {\r
+ num_effective_distance_symbols = BROTLI_NUM_HISTOGRAM_DISTANCE_SYMBOLS;\r
+ }\r
\r
StoreCompressedMetaBlockHeader(is_last, length, storage_ix, storage);\r
\r
tree = BROTLI_ALLOC(m, HuffmanTree, MAX_HUFFMAN_TREE_SIZE);\r
if (BROTLI_IS_OOM(m)) return;\r
- InitBlockEncoder(&literal_enc, 256, mb->literal_split.num_types,\r
- mb->literal_split.types, mb->literal_split.lengths,\r
- mb->literal_split.num_blocks);\r
+ InitBlockEncoder(&literal_enc, BROTLI_NUM_LITERAL_SYMBOLS,\r
+ mb->literal_split.num_types, mb->literal_split.types,\r
+ mb->literal_split.lengths, mb->literal_split.num_blocks);\r
InitBlockEncoder(&command_enc, BROTLI_NUM_COMMAND_SYMBOLS,\r
mb->command_split.num_types, mb->command_split.types,\r
mb->command_split.lengths, mb->command_split.num_blocks);\r
- InitBlockEncoder(&distance_enc, num_distance_codes,\r
+ InitBlockEncoder(&distance_enc, num_effective_distance_symbols,\r
mb->distance_split.num_types, mb->distance_split.types,\r
mb->distance_split.lengths, mb->distance_split.num_blocks);\r
\r
BuildAndStoreBlockSwitchEntropyCodes(\r
&distance_enc, tree, storage_ix, storage);\r
\r
- BrotliWriteBits(2, distance_postfix_bits, storage_ix, storage);\r
- BrotliWriteBits(4, num_direct_distance_codes >> distance_postfix_bits,\r
- storage_ix, storage);\r
+ BrotliWriteBits(2, dist->distance_postfix_bits, storage_ix, storage);\r
+ BrotliWriteBits(\r
+ 4, dist->num_direct_distance_codes >> dist->distance_postfix_bits,\r
+ storage_ix, storage);\r
for (i = 0; i < mb->literal_split.num_types; ++i) {\r
BrotliWriteBits(2, literal_context_mode, storage_ix, storage);\r
}\r
}\r
\r
BuildAndStoreEntropyCodesLiteral(m, &literal_enc, mb->literal_histograms,\r
- mb->literal_histograms_size, tree, storage_ix, storage);\r
+ mb->literal_histograms_size, BROTLI_NUM_LITERAL_SYMBOLS, tree,\r
+ storage_ix, storage);\r
if (BROTLI_IS_OOM(m)) return;\r
BuildAndStoreEntropyCodesCommand(m, &command_enc, mb->command_histograms,\r
- mb->command_histograms_size, tree, storage_ix, storage);\r
+ mb->command_histograms_size, BROTLI_NUM_COMMAND_SYMBOLS, tree,\r
+ storage_ix, storage);\r
if (BROTLI_IS_OOM(m)) return;\r
BuildAndStoreEntropyCodesDistance(m, &distance_enc, mb->distance_histograms,\r
- mb->distance_histograms_size, tree, storage_ix, storage);\r
+ mb->distance_histograms_size, num_distance_symbols, tree,\r
+ storage_ix, storage);\r
if (BROTLI_IS_OOM(m)) return;\r
BROTLI_FREE(m, tree);\r
\r
} else {\r
size_t j;\r
for (j = cmd.insert_len_; j != 0; --j) {\r
- size_t context = Context(prev_byte, prev_byte2, literal_context_mode);\r
+ size_t context =\r
+ BROTLI_CONTEXT(prev_byte, prev_byte2, literal_context_lut);\r
uint8_t literal = input[pos & mask];\r
StoreSymbolWithContext(&literal_enc, literal, context,\r
mb->literal_context_map, storage_ix, storage,\r
prev_byte2 = input[(pos - 2) & mask];\r
prev_byte = input[(pos - 1) & mask];\r
if (cmd.cmd_prefix_ >= 128) {\r
- size_t dist_code = cmd.dist_prefix_;\r
- uint32_t distnumextra = cmd.dist_extra_ >> 24;\r
- uint64_t distextra = cmd.dist_extra_ & 0xffffff;\r
+ size_t dist_code = cmd.dist_prefix_ & 0x3FF;\r
+ uint32_t distnumextra = cmd.dist_prefix_ >> 10;\r
+ uint64_t distextra = cmd.dist_extra_;\r
if (mb->distance_context_map_size == 0) {\r
StoreSymbol(&distance_enc, dist_code, storage_ix, storage);\r
} else {\r
static void BuildHistograms(const uint8_t* input,\r
size_t start_pos,\r
size_t mask,\r
- const Command *commands,\r
+ const Command* commands,\r
size_t n_commands,\r
HistogramLiteral* lit_histo,\r
HistogramCommand* cmd_histo,\r
}\r
pos += CommandCopyLen(&cmd);\r
if (CommandCopyLen(&cmd) && cmd.cmd_prefix_ >= 128) {\r
- HistogramAddDistance(dist_histo, cmd.dist_prefix_);\r
+ HistogramAddDistance(dist_histo, cmd.dist_prefix_ & 0x3FF);\r
}\r
}\r
}\r
static void StoreDataWithHuffmanCodes(const uint8_t* input,\r
size_t start_pos,\r
size_t mask,\r
- const Command *commands,\r
+ const Command* commands,\r
size_t n_commands,\r
const uint8_t* lit_depth,\r
const uint16_t* lit_bits,\r
}\r
pos += CommandCopyLen(&cmd);\r
if (CommandCopyLen(&cmd) && cmd.cmd_prefix_ >= 128) {\r
- const size_t dist_code = cmd.dist_prefix_;\r
- const uint32_t distnumextra = cmd.dist_extra_ >> 24;\r
- const uint32_t distextra = cmd.dist_extra_ & 0xffffff;\r
+ const size_t dist_code = cmd.dist_prefix_ & 0x3FF;\r
+ const uint32_t distnumextra = cmd.dist_prefix_ >> 10;\r
+ const uint32_t distextra = cmd.dist_extra_;\r
BrotliWriteBits(dist_depth[dist_code], dist_bits[dist_code],\r
storage_ix, storage);\r
BrotliWriteBits(distnumextra, distextra, storage_ix, storage);\r
}\r
\r
void BrotliStoreMetaBlockTrivial(MemoryManager* m,\r
- const uint8_t* input,\r
- size_t start_pos,\r
- size_t length,\r
- size_t mask,\r
- BROTLI_BOOL is_last,\r
- const Command *commands,\r
- size_t n_commands,\r
- size_t *storage_ix,\r
- uint8_t *storage) {\r
+ const uint8_t* input, size_t start_pos, size_t length, size_t mask,\r
+ BROTLI_BOOL is_last, const BrotliEncoderParams* params,\r
+ const Command* commands, size_t n_commands,\r
+ size_t* storage_ix, uint8_t* storage) {\r
HistogramLiteral lit_histo;\r
HistogramCommand cmd_histo;\r
HistogramDistance dist_histo;\r
- uint8_t lit_depth[256];\r
- uint16_t lit_bits[256];\r
+ uint8_t lit_depth[BROTLI_NUM_LITERAL_SYMBOLS];\r
+ uint16_t lit_bits[BROTLI_NUM_LITERAL_SYMBOLS];\r
uint8_t cmd_depth[BROTLI_NUM_COMMAND_SYMBOLS];\r
uint16_t cmd_bits[BROTLI_NUM_COMMAND_SYMBOLS];\r
- uint8_t dist_depth[64];\r
- uint16_t dist_bits[64];\r
+ uint8_t dist_depth[MAX_SIMPLE_DISTANCE_ALPHABET_SIZE];\r
+ uint16_t dist_bits[MAX_SIMPLE_DISTANCE_ALPHABET_SIZE];\r
HuffmanTree* tree;\r
+ uint32_t num_distance_symbols = params->dist.alphabet_size;\r
\r
StoreCompressedMetaBlockHeader(is_last, length, storage_ix, storage);\r
\r
\r
tree = BROTLI_ALLOC(m, HuffmanTree, MAX_HUFFMAN_TREE_SIZE);\r
if (BROTLI_IS_OOM(m)) return;\r
- BuildAndStoreHuffmanTree(lit_histo.data_, 256, tree,\r
+ BuildAndStoreHuffmanTree(lit_histo.data_, BROTLI_NUM_LITERAL_SYMBOLS,\r
+ BROTLI_NUM_LITERAL_SYMBOLS, tree,\r
lit_depth, lit_bits,\r
storage_ix, storage);\r
- BuildAndStoreHuffmanTree(cmd_histo.data_, BROTLI_NUM_COMMAND_SYMBOLS, tree,\r
+ BuildAndStoreHuffmanTree(cmd_histo.data_, BROTLI_NUM_COMMAND_SYMBOLS,\r
+ BROTLI_NUM_COMMAND_SYMBOLS, tree,\r
cmd_depth, cmd_bits,\r
storage_ix, storage);\r
- BuildAndStoreHuffmanTree(dist_histo.data_, 64, tree,\r
+ BuildAndStoreHuffmanTree(dist_histo.data_, MAX_SIMPLE_DISTANCE_ALPHABET_SIZE,\r
+ num_distance_symbols, tree,\r
dist_depth, dist_bits,\r
storage_ix, storage);\r
BROTLI_FREE(m, tree);\r
}\r
\r
void BrotliStoreMetaBlockFast(MemoryManager* m,\r
- const uint8_t* input,\r
- size_t start_pos,\r
- size_t length,\r
- size_t mask,\r
- BROTLI_BOOL is_last,\r
- const Command *commands,\r
- size_t n_commands,\r
- size_t *storage_ix,\r
- uint8_t *storage) {\r
+ const uint8_t* input, size_t start_pos, size_t length, size_t mask,\r
+ BROTLI_BOOL is_last, const BrotliEncoderParams* params,\r
+ const Command* commands, size_t n_commands,\r
+ size_t* storage_ix, uint8_t* storage) {\r
+ uint32_t num_distance_symbols = params->dist.alphabet_size;\r
+ uint32_t distance_alphabet_bits =\r
+ Log2FloorNonZero(num_distance_symbols - 1) + 1;\r
+\r
StoreCompressedMetaBlockHeader(is_last, length, storage_ix, storage);\r
\r
BrotliWriteBits(13, 0, storage_ix, storage);\r
uint16_t lit_bits[BROTLI_NUM_LITERAL_SYMBOLS];\r
uint8_t cmd_depth[BROTLI_NUM_COMMAND_SYMBOLS];\r
uint16_t cmd_bits[BROTLI_NUM_COMMAND_SYMBOLS];\r
- uint8_t dist_depth[64];\r
- uint16_t dist_bits[64];\r
+ uint8_t dist_depth[MAX_SIMPLE_DISTANCE_ALPHABET_SIZE];\r
+ uint16_t dist_bits[MAX_SIMPLE_DISTANCE_ALPHABET_SIZE];\r
HistogramClearLiteral(&lit_histo);\r
HistogramClearCommand(&cmd_histo);\r
HistogramClearDistance(&dist_histo);\r
if (BROTLI_IS_OOM(m)) return;\r
BrotliBuildAndStoreHuffmanTreeFast(m, dist_histo.data_,\r
dist_histo.total_count_,\r
- /* max_bits = */ 6,\r
+ /* max_bits = */\r
+ distance_alphabet_bits,\r
dist_depth, dist_bits,\r
storage_ix, storage);\r
if (BROTLI_IS_OOM(m)) return;\r
/* This is for storing uncompressed blocks (simple raw storage of\r
bytes-as-bytes). */\r
void BrotliStoreUncompressedMetaBlock(BROTLI_BOOL is_final_block,\r
- const uint8_t * BROTLI_RESTRICT input,\r
+ const uint8_t* BROTLI_RESTRICT input,\r
size_t position, size_t mask,\r
size_t len,\r
- size_t * BROTLI_RESTRICT storage_ix,\r
- uint8_t * BROTLI_RESTRICT storage) {\r
+ size_t* BROTLI_RESTRICT storage_ix,\r
+ uint8_t* BROTLI_RESTRICT storage) {\r
size_t masked_pos = position & mask;\r
BrotliStoreUncompressedMetaBlockHeader(len, storage_ix, storage);\r
JumpToByteBoundary(storage_ix, storage);\r
}\r
}\r
\r
-void BrotliStoreSyncMetaBlock(size_t* BROTLI_RESTRICT storage_ix,\r
- uint8_t* BROTLI_RESTRICT storage) {\r
- /* Empty metadata meta-block bit pattern:\r
- 1 bit: is_last (0)\r
- 2 bits: num nibbles (3)\r
- 1 bit: reserved (0)\r
- 2 bits: metadata length bytes (0) */\r
- BrotliWriteBits(6, 6, storage_ix, storage);\r
- JumpToByteBoundary(storage_ix, storage);\r
-}\r
-\r
-\r
#if defined(__cplusplus) || defined(c_plusplus)\r
} /* extern "C" */\r
#endif\r
projects / mirror_edk2.git / blobdiff