hpack_huffman_decoder.cc | Explore in Territory

// Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "quiche/http2/hpack/huffman/hpack_huffman_decoder.h"

#include <bitset>
#include <limits>
#include <ostream>
#include <sstream>
#include <string>

#include "quiche/common/platform/api/quiche_logging.h"

// Terminology:
//
// Symbol - a plain text (unencoded) character (uint8), or the End-of-String
//          (EOS) symbol, 256.
//
// Code - the sequence of bits used to encode a symbol, varying in length from
//        5 bits for the most common symbols (e.g. '0', '1', and 'a'), to
//        30 bits for the least common (e.g. the EOS symbol).
//        For those symbols whose codes have the same length, their code values
//        are sorted such that the lower symbol value has a lower code value.
//
// Canonical - a symbol's cardinal value when sorted first by code length, and
//             then by symbol value. For example, canonical 0 is for ASCII '0'
//             (uint8 value 0x30), which is the first of the symbols whose code
//             is 5 bits long, and the last canonical is EOS, which is the last
//             of the symbols whose code is 30 bits long.

namespace http2 {
namespace {

// HuffmanCode is used to store the codes associated with symbols (a pattern of
// from 5 to 30 bits).
HuffmanCode;

// HuffmanCodeBitCount is used to store a count of bits in a code.
HuffmanCodeBitCount;

// HuffmanCodeBitSet is used for producing a string version of a code because
// std::bitset logs nicely.
HuffmanCodeBitSet;
HuffmanAccumulatorBitSet;

static constexpr HuffmanCodeBitCount kMinCodeBitCount = …;
static constexpr HuffmanCodeBitCount kMaxCodeBitCount = …;
static constexpr HuffmanCodeBitCount kHuffmanCodeBitCount = …;

static_assert …;

static_assert …;

static constexpr HuffmanAccumulatorBitCount kHuffmanAccumulatorBitCount = …;
static constexpr HuffmanAccumulatorBitCount kExtraAccumulatorBitCount = …;

// PrefixInfo holds info about a group of codes that are all of the same length.
struct PrefixInfo { … };

inline std::ostream& operator<<(std::ostream& out, const PrefixInfo& v) { … }

// Given |value|, a sequence of the leading bits remaining to be decoded,
// figure out which group of canonicals (by code length) that value starts
// with. This function was generated.
PrefixInfo PrefixToInfo(HuffmanCode value) { … }

// Mapping from canonical symbol (0 to 255) to actual symbol.
// clang-format off
constexpr unsigned char kCanonicalToSymbol[] = …;
// clang-format on

constexpr size_t kShortCodeTableSize = …;
struct ShortCodeInfo { … } kShortCodeTable[kShortCodeTableSize] = …;

}  // namespace

HuffmanBitBuffer::HuffmanBitBuffer() { … }

void HuffmanBitBuffer::Reset() { … }

size_t HuffmanBitBuffer::AppendBytes(absl::string_view input) { … }

HuffmanAccumulatorBitCount HuffmanBitBuffer::free_count() const { … }

void HuffmanBitBuffer::ConsumeBits(HuffmanAccumulatorBitCount code_length) { … }

bool HuffmanBitBuffer::InputProperlyTerminated() const { … }

std::string HuffmanBitBuffer::DebugString() const { … }

HpackHuffmanDecoder::HpackHuffmanDecoder() = default;

HpackHuffmanDecoder::~HpackHuffmanDecoder() = default;

bool HpackHuffmanDecoder::Decode(absl::string_view input, std::string* output) { … }

std::string HpackHuffmanDecoder::DebugString() const { … }

}  // namespace http2
chromium/net/third_party/quiche/src/quiche/http2/hpack/huffman/hpack_huffman_decoder.cc
