← Back to branch summary

~alinuxninja/nginx-edge/trunk

« back to all changes in this revision

Viewing changes to debian/modules/ngx_pagespeed/psol/include/third_party/libwebp/src/utils/huffman.h

  • Committer: Vivian
  • Date: 2015-12-04 18:20:11 UTC
  • Revision ID: git-v1:a36f2bc32e884f7473b3a47040e5411306144d7d
* Do not extract psol.tar.gz

Show diffs side-by-side

added added

removed removed

Lines of Context:
debian/modules/ngx_pagespeed/psol/include/third_party/libwebp/src/utils/huffman.h
1
 
// Copyright 2012 Google Inc. All Rights Reserved.
2
 
//
3
 
// Use of this source code is governed by a BSD-style license
4
 
// that can be found in the COPYING file in the root of the source
5
 
// tree. An additional intellectual property rights grant can be found
6
 
// in the file PATENTS. All contributing project authors may
7
 
// be found in the AUTHORS file in the root of the source tree.
8
 
// -----------------------------------------------------------------------------
9
 
//
10
 
// Utilities for building and looking up Huffman trees.
11
 
//
12
 
// Author: Urvang Joshi (urvang@google.com)
13
 
 
14
 
#ifndef WEBP_UTILS_HUFFMAN_H_
15
 
#define WEBP_UTILS_HUFFMAN_H_
16
 
 
17
 
#include <assert.h>
18
 
#include "../webp/format_constants.h"
19
 
#include "../webp/types.h"
20
 
 
21
 
#ifdef __cplusplus
22
 
extern "C" {
23
 
#endif
24
 
 
25
 
// A node of a Huffman tree.
26
 
typedef struct {
27
 
  int symbol_;
28
 
  int children_;  // delta offset to both children (contiguous) or 0 if leaf.
29
 
} HuffmanTreeNode;
30
 
 
31
 
// Huffman Tree.
32
 
#define HUFF_LUT_BITS 7
33
 
#define HUFF_LUT (1U << HUFF_LUT_BITS)
34
 
typedef struct HuffmanTree HuffmanTree;
35
 
struct HuffmanTree {
36
 
  // Fast lookup for short bit lengths.
37
 
  uint8_t lut_bits_[HUFF_LUT];
38
 
  int16_t lut_symbol_[HUFF_LUT];
39
 
  int16_t lut_jump_[HUFF_LUT];
40
 
  // Complete tree for lookups.
41
 
  HuffmanTreeNode* root_;   // all the nodes, starting at root.
42
 
  int max_nodes_;           // max number of nodes
43
 
  int num_nodes_;           // number of currently occupied nodes
44
 
};
45
 
 
46
 
// Huffman Tree group.
47
 
typedef struct HTreeGroup HTreeGroup;
48
 
struct HTreeGroup {
49
 
  HuffmanTree htrees_[HUFFMAN_CODES_PER_META_CODE];
50
 
};
51
 
 
52
 
// Returns true if the given node is not a leaf of the Huffman tree.
53
 
static WEBP_INLINE int HuffmanTreeNodeIsNotLeaf(
54
 
    const HuffmanTreeNode* const node) {
55
 
  return node->children_;
56
 
}
57
 
 
58
 
// Go down one level. Most critical function. 'right_child' must be 0 or 1.
59
 
static WEBP_INLINE const HuffmanTreeNode* HuffmanTreeNextNode(
60
 
    const HuffmanTreeNode* node, int right_child) {
61
 
  return node + node->children_ + right_child;
62
 
}
63
 
 
64
 
// Releases the nodes of the Huffman tree.
65
 
// Note: It does NOT free 'tree' itself.
66
 
void VP8LHuffmanTreeFree(HuffmanTree* const tree);
67
 
 
68
 
// Creates the instance of HTreeGroup with specified number of tree-groups.
69
 
HTreeGroup* VP8LHtreeGroupsNew(int num_htree_groups);
70
 
 
71
 
// Releases the memory allocated for HTreeGroup.
72
 
void VP8LHtreeGroupsFree(HTreeGroup* htree_groups, int num_htree_groups);
73
 
 
74
 
// Builds Huffman tree assuming code lengths are implicitly in symbol order.
75
 
// The 'huff_codes' and 'code_lengths' are pre-allocated temporary memory
76
 
// buffers, used for creating the huffman tree.
77
 
// Returns false in case of error (invalid tree or memory error).
78
 
int VP8LHuffmanTreeBuildImplicit(HuffmanTree* const tree,
79
 
                                 const int* const code_lengths,
80
 
                                 int* const huff_codes,
81
 
                                 int code_lengths_size);
82
 
 
83
 
// Build a Huffman tree with explicitly given lists of code lengths, codes
84
 
// and symbols. Verifies that all symbols added are smaller than max_symbol.
85
 
// Returns false in case of an invalid symbol, invalid tree or memory error.
86
 
int VP8LHuffmanTreeBuildExplicit(HuffmanTree* const tree,
87
 
                                 const int* const code_lengths,
88
 
                                 const int* const codes,
89
 
                                 const int* const symbols, int max_symbol,
90
 
                                 int num_symbols);
91
 
 
92
 
// Utility: converts Huffman code lengths to corresponding Huffman codes.
93
 
// 'huff_codes' should be pre-allocated.
94
 
// Returns false in case of error (memory allocation, invalid codes).
95
 
int VP8LHuffmanCodeLengthsToCodes(const int* const code_lengths,
96
 
                                  int code_lengths_size, int* const huff_codes);
97
 
 
98
 
#ifdef __cplusplus
99
 
}    // extern "C"
100
 
#endif
101
 
 
102
 
#endif  // WEBP_UTILS_HUFFMAN_H_