LCOV - app.info - media/libtheora/lib/huffdec.c

LCOV - code coverage report
| Current view: | directory - media/libtheora/lib - huffdec.c (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 146 | 0 | 0.0 %
| Date: | 2012-06-02 | Functions: | 10 | 0 | 0.0 %

           1                 : /********************************************************************
           2                 :  *                                                                  *
           3                 :  * THIS FILE IS PART OF THE OggTheora SOFTWARE CODEC SOURCE CODE.   *
           4                 :  * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS     *
           5                 :  * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
           6                 :  * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *
           7                 :  *                                                                  *
           8                 :  * THE Theora SOURCE CODE IS COPYRIGHT (C) 2002-2009                *
           9                 :  * by the Xiph.Org Foundation and contributors http://www.xiph.org/ *
          10                 :  *                                                                  *
          11                 :  ********************************************************************
          12                 :
          13                 :   function:
          14                 :     last mod: $Id: huffdec.c 17577 2010-10-29 04:00:07Z tterribe $
          15                 :
          16                 :  ********************************************************************/
          17                 :
          18                 : #include <stdlib.h>
          19                 : #include <string.h>
          20                 : #include <ogg/ogg.h>
          21                 : #include "huffdec.h"
          22                 : #include "decint.h"
          23                 :
          24                 :
          25                 :
          26                 : /*Instead of storing every branching in the tree, subtrees can be collapsed
          27                 :    into one node, with a table of size 1<<nbits pointing directly to its
          28                 :    descedents nbits levels down.
          29                 :   This allows more than one bit to be read at a time, and avoids following all
          30                 :    the intermediate branches with next to no increased code complexity once
          31                 :    the collapsed tree has been built.
          32                 :   We do _not_ require that a subtree be complete to be collapsed, but instead
          33                 :    store duplicate pointers in the table, and record the actual depth of the
          34                 :    node below its parent.
          35                 :   This tells us the number of bits to advance the stream after reaching it.
          36                 :
          37                 :   This turns out to be equivalent to the method described in \cite{Hash95},
          38                 :    without the requirement that codewords be sorted by length.
          39                 :   If the codewords were sorted by length (so-called ``canonical-codes''), they
          40                 :    could be decoded much faster via either Lindell and Moffat's approach or
          41                 :    Hashemian's Condensed Huffman Code approach, the latter of which has an
          42                 :    extremely small memory footprint.
          43                 :   We can't use Choueka et al.'s finite state machine approach, which is
          44                 :    extremely fast, because we can't allow multiple symbols to be output at a
          45                 :    time; the codebook can and does change between symbols.
          46                 :   It also has very large memory requirements, which impairs cache coherency.
          47                 :
          48                 :   We store the tree packed in an array of 16-bit integers (words).
          49                 :   Each node consists of a single word, followed consecutively by two or more
          50                 :    indices of its children.
          51                 :   Let n be the value of this first word.
          52                 :   This is the number of bits that need to be read to traverse the node, and
          53                 :    must be positive.
          54                 :   1<<n entries follow in the array, each an index to a child node.
          55                 :   If the child is positive, then it is the index of another internal node in
          56                 :    the table.
          57                 :   If the child is negative or zero, then it is a leaf node.
          58                 :   These are stored directly in the child pointer to save space, since they only
          59                 :    require a single word.
          60                 :   If a leaf node would have been encountered before reading n bits, then it is
          61                 :    duplicated the necessary number of times in this table.
          62                 :   Leaf nodes pack both a token value and their actual depth in the tree.
          63                 :   The token in the leaf node is (-leaf&255).
          64                 :   The number of bits that need to be consumed to reach the leaf, starting from
          65                 :    the current node, is (-leaf>>8).
          66                 :
          67                 :   @ARTICLE{Hash95,
          68                 :     author="Reza Hashemian",
          69                 :     title="Memory Efficient and High-Speed Search {Huffman} Coding",
          70                 :     journal="{IEEE} Transactions on Communications",
          71                 :     volume=43,
          72                 :     number=10,
          73                 :     pages="2576--2581",
          74                 :     month=Oct,
          75                 :     year=1995
          76                 :   }*/
          77                 :
          78                 :
          79                 :
          80                 : /*The map from external spec-defined tokens to internal tokens.
          81                 :   This is constructed so that any extra bits read with the original token value
          82                 :    can be masked off the least significant bits of its internal token index.
          83                 :   In addition, all of the tokens which require additional extra bits are placed
          84                 :    at the start of the list, and grouped by type.
          85                 :   OC_DCT_REPEAT_RUN3_TOKEN is placed first, as it is an extra-special case, so
          86                 :    giving it index 0 may simplify comparisons on some architectures.
          87                 :   These requirements require some substantial reordering.*/
          88                 : static const unsigned char OC_DCT_TOKEN_MAP[TH_NDCT_TOKENS]={
          89                 :   /*OC_DCT_EOB1_TOKEN (0 extra bits)*/
          90                 :   15,
          91                 :   /*OC_DCT_EOB2_TOKEN (0 extra bits)*/
          92                 :   16,
          93                 :   /*OC_DCT_EOB3_TOKEN (0 extra bits)*/
          94                 :   17,
          95                 :   /*OC_DCT_REPEAT_RUN0_TOKEN (2 extra bits)*/
          96                 :   88,
          97                 :   /*OC_DCT_REPEAT_RUN1_TOKEN (3 extra bits)*/
          98                 :   80,
          99                 :   /*OC_DCT_REPEAT_RUN2_TOKEN (4 extra bits)*/
         100                 :    1,
         101                 :   /*OC_DCT_REPEAT_RUN3_TOKEN (12 extra bits)*/
         102                 :    0,
         103                 :   /*OC_DCT_SHORT_ZRL_TOKEN (3 extra bits)*/
         104                 :   48,
         105                 :   /*OC_DCT_ZRL_TOKEN (6 extra bits)*/
         106                 :   14,
         107                 :   /*OC_ONE_TOKEN (0 extra bits)*/
         108                 :   56,
         109                 :   /*OC_MINUS_ONE_TOKEN (0 extra bits)*/
         110                 :   57,
         111                 :   /*OC_TWO_TOKEN (0 extra bits)*/
         112                 :   58,
         113                 :   /*OC_MINUS_TWO_TOKEN (0 extra bits)*/
         114                 :   59,
         115                 :   /*OC_DCT_VAL_CAT2 (1 extra bit)*/
         116                 :   60,
         117                 :   62,
         118                 :   64,
         119                 :   66,
         120                 :   /*OC_DCT_VAL_CAT3 (2 extra bits)*/
         121                 :   68,
         122                 :   /*OC_DCT_VAL_CAT4 (3 extra bits)*/
         123                 :   72,
         124                 :   /*OC_DCT_VAL_CAT5 (4 extra bits)*/
         125                 :    2,
         126                 :   /*OC_DCT_VAL_CAT6 (5 extra bits)*/
         127                 :    4,
         128                 :   /*OC_DCT_VAL_CAT7 (6 extra bits)*/
         129                 :    6,
         130                 :   /*OC_DCT_VAL_CAT8 (10 extra bits)*/
         131                 :    8,
         132                 :   /*OC_DCT_RUN_CAT1A (1 extra bit)*/
         133                 :   18,
         134                 :   20,
         135                 :   22,
         136                 :   24,
         137                 :   26,
         138                 :   /*OC_DCT_RUN_CAT1B (3 extra bits)*/
         139                 :   32,
         140                 :   /*OC_DCT_RUN_CAT1C (4 extra bits)*/
         141                 :   12,
         142                 :   /*OC_DCT_RUN_CAT2A (2 extra bits)*/
         143                 :   28,
         144                 :   /*OC_DCT_RUN_CAT2B (3 extra bits)*/
         145                 :   40
         146                 : };
         147                 :
         148                 : /*The log base 2 of number of internal tokens associated with each of the spec
         149                 :    tokens (i.e., how many of the extra bits are folded into the token value).
         150                 :   Increasing the maximum value beyond 3 will enlarge the amount of stack
         151                 :    required for tree construction.*/
         152                 : static const unsigned char OC_DCT_TOKEN_MAP_LOG_NENTRIES[TH_NDCT_TOKENS]={
         153                 :   0,0,0,2,3,0,0,3,0,0,0,0,0,1,1,1,1,2,3,1,1,1,2,1,1,1,1,1,3,1,2,3
         154                 : };
         155                 :
         156                 :
         157                 : /*The size a lookup table is allowed to grow to relative to the number of
         158                 :    unique nodes it contains.
         159                 :   E.g., if OC_HUFF_SLUSH is 4, then at most 75% of the space in the tree is
         160                 :    wasted (1/4 of the space must be used).
         161                 :   Larger numbers can decode tokens with fewer read operations, while smaller
         162                 :    numbers may save more space.
         163                 :   With a sample file:
         164                 :   32233473 read calls are required when no tree collapsing is done (100.0%).
         165                 :   19269269 read calls are required when OC_HUFF_SLUSH is 1 (59.8%).
         166                 :   11144969 read calls are required when OC_HUFF_SLUSH is 2 (34.6%).
         167                 :   10538563 read calls are required when OC_HUFF_SLUSH is 4 (32.7%).
         168                 :   10192578 read calls are required when OC_HUFF_SLUSH is 8 (31.6%).
         169                 :   Since a value of 2 gets us the vast majority of the speed-up with only a
         170                 :    small amount of wasted memory, this is what we use.
         171                 :   This value must be less than 128, or you could create a tree with more than
         172                 :    32767 entries, which would overflow the 16-bit words used to index it.*/
         173                 : #define OC_HUFF_SLUSH (2)
         174                 : /*The root of the tree is on the fast path, and a larger value here is more
         175                 :    beneficial than elsewhere in the tree.
         176                 :   7 appears to give the best performance, trading off between increased use of
         177                 :    the single-read fast path and cache footprint for the tables, though
         178                 :    obviously this will depend on your cache size.
         179                 :   Using 7 here, the VP3 tables are about twice as large compared to using 2.*/
         180                 : #define OC_ROOT_HUFF_SLUSH (7)
         181                 :
         182                 :
         183                 :
         184                 : /*Unpacks a Huffman codebook.
         185                 :   _opb:    The buffer to unpack from.
         186                 :   _tokens: Stores a list of internal tokens, in the order they were found in
         187                 :             the codebook, and the lengths of their corresponding codewords.
         188                 :            This is enough to completely define the codebook, while minimizing
         189                 :             stack usage and avoiding temporary allocations (for platforms
         190                 :             where free() is a no-op).
         191                 :   Return: The number of internal tokens in the codebook, or a negative value
         192                 :    on error.*/
         193               0 : int oc_huff_tree_unpack(oc_pack_buf *_opb,unsigned char _tokens[256][2]){
         194                 :   ogg_uint32_t code;
         195                 :   int          len;
         196                 :   int          ntokens;
         197                 :   int          nleaves;
         198               0 :   code=0;
         199               0 :   len=ntokens=nleaves=0;
         200                 :   for(;;){
         201                 :     long bits;
         202               0 :     bits=oc_pack_read1(_opb);
         203                 :     /*Only process nodes so long as there's more bits in the buffer.*/
         204               0 :     if(oc_pack_bytes_left(_opb)<0)return TH_EBADHEADER;
         205                 :     /*Read an internal node:*/
         206               0 :     if(!bits){
         207               0 :       len++;
         208                 :       /*Don't allow codewords longer than 32 bits.*/
         209               0 :       if(len>32)return TH_EBADHEADER;
         210                 :     }
         211                 :     /*Read a leaf node:*/
         212                 :     else{
         213                 :       ogg_uint32_t code_bit;
         214                 :       int          neb;
         215                 :       int          nentries;
         216                 :       int          token;
         217                 :       /*Don't allow more than 32 spec-tokens per codebook.*/
         218               0 :       if(++nleaves>32)return TH_EBADHEADER;
         219               0 :       bits=oc_pack_read(_opb,OC_NDCT_TOKEN_BITS);
         220               0 :       neb=OC_DCT_TOKEN_MAP_LOG_NENTRIES[bits];
         221               0 :       token=OC_DCT_TOKEN_MAP[bits];
         222               0 :       nentries=1<<neb;
         223               0 :       while(nentries-->0){
         224               0 :         _tokens[ntokens][0]=(unsigned char)token++;
         225               0 :         _tokens[ntokens][1]=(unsigned char)(len+neb);
         226               0 :         ntokens++;
         227                 :       }
         228               0 :       code_bit=0x80000000U>>len-1;
         229               0 :       while(len>0&&(code&code_bit)){
         230               0 :         code^=code_bit;
         231               0 :         code_bit<<=1;
         232               0 :         len--;
         233                 :       }
         234               0 :       if(len<=0)break;
         235               0 :       code|=code_bit;
         236                 :     }
         237               0 :   }
         238               0 :   return ntokens;
         239                 : }
         240                 :
         241                 : /*Count how many tokens would be required to fill a subtree at depth _depth.
         242                 :   _tokens: A list of internal tokens, in the order they are found in the
         243                 :             codebook, and the lengths of their corresponding codewords.
         244                 :   _depth:  The depth of the desired node in the corresponding tree structure.
         245                 :   Return: The number of tokens that belong to that subtree.*/
         246               0 : static int oc_huff_subtree_tokens(unsigned char _tokens[][2],int _depth){
         247                 :   ogg_uint32_t code;
         248                 :   int          ti;
         249               0 :   code=0;
         250               0 :   ti=0;
         251                 :   do{
         252               0 :     if(_tokens[ti][1]-_depth<32)code+=0x80000000U>>_tokens[ti++][1]-_depth;
         253                 :     else{
         254                 :       /*Because of the expanded internal tokens, we can have codewords as long
         255                 :          as 35 bits.
         256                 :         A single recursion here is enough to advance past them.*/
         257               0 :       code++;
         258               0 :       ti+=oc_huff_subtree_tokens(_tokens+ti,_depth+31);
         259                 :     }
         260                 :   }
         261               0 :   while(code<0x80000000U);
         262               0 :   return ti;
         263                 : }
         264                 :
         265                 : /*Compute the number of bits to use for a collapsed tree node at the given
         266                 :    depth.
         267                 :   _tokens:  A list of internal tokens, in the order they are found in the
         268                 :              codebook, and the lengths of their corresponding codewords.
         269                 :   _ntokens: The number of tokens corresponding to this tree node.
         270                 :   _depth:   The depth of this tree node.
         271                 :   Return: The number of bits to use for a collapsed tree node rooted here.
         272                 :           This is always at least one, even if this was a leaf node.*/
         273               0 : static int oc_huff_tree_collapse_depth(unsigned char _tokens[][2],
         274                 :  int _ntokens,int _depth){
         275                 :   int got_leaves;
         276                 :   int loccupancy;
         277                 :   int occupancy;
         278                 :   int slush;
         279                 :   int nbits;
         280                 :   int best_nbits;
         281               0 :   slush=_depth>0?OC_HUFF_SLUSH:OC_ROOT_HUFF_SLUSH;
         282                 :   /*It's legal to have a tree with just a single node, which requires no bits
         283                 :      to decode and always returns the same token.
         284                 :     However, no encoder actually does this (yet).
         285                 :     To avoid a special case in oc_huff_token_decode(), we force the number of
         286                 :      lookahead bits to be at least one.
         287                 :     This will produce a tree that looks ahead one bit and then advances the
         288                 :      stream zero bits.*/
         289               0 :   nbits=1;
         290               0 :   occupancy=2;
         291               0 :   got_leaves=1;
         292                 :   do{
         293                 :     int ti;
         294               0 :     if(got_leaves)best_nbits=nbits;
         295               0 :     nbits++;
         296               0 :     got_leaves=0;
         297               0 :     loccupancy=occupancy;
         298               0 :     for(occupancy=ti=0;ti<_ntokens;occupancy++){
         299               0 :       if(_tokens[ti][1]<_depth+nbits)ti++;
         300               0 :       else if(_tokens[ti][1]==_depth+nbits){
         301               0 :         got_leaves=1;
         302               0 :         ti++;
         303                 :       }
         304               0 :       else ti+=oc_huff_subtree_tokens(_tokens+ti,_depth+nbits);
         305                 :     }
         306                 :   }
         307               0 :   while(occupancy>loccupancy&&occupancy*slush>=1<<nbits);
         308               0 :   return best_nbits;
         309                 : }
         310                 :
         311                 : /*Determines the size in words of a Huffman tree node that represents a
         312                 :    subtree of depth _nbits.
         313                 :   _nbits: The depth of the subtree.
         314                 :           This must be greater than zero.
         315                 :   Return: The number of words required to store the node.*/
         316               0 : static size_t oc_huff_node_size(int _nbits){
         317               0 :   return 1+(1<<_nbits);
         318                 : }
         319                 :
         320                 : /*Produces a collapsed-tree representation of the given token list.
         321                 :   _tree: The storage for the collapsed Huffman tree.
         322                 :          This may be NULL to compute the required storage size instead of
         323                 :           constructing the tree.
         324                 :   _tokens:  A list of internal tokens, in the order they are found in the
         325                 :              codebook, and the lengths of their corresponding codewords.
         326                 :   _ntokens: The number of tokens corresponding to this tree node.
         327                 :   Return: The number of words required to store the tree.*/
         328               0 : static size_t oc_huff_tree_collapse(ogg_int16_t *_tree,
         329                 :  unsigned char _tokens[][2],int _ntokens){
         330                 :   ogg_int16_t   node[34];
         331                 :   unsigned char depth[34];
         332                 :   unsigned char last[34];
         333                 :   size_t        ntree;
         334                 :   int           ti;
         335                 :   int           l;
         336               0 :   depth[0]=0;
         337               0 :   last[0]=(unsigned char)(_ntokens-1);
         338               0 :   ntree=0;
         339               0 :   ti=0;
         340               0 :   l=0;
         341                 :   do{
         342                 :     int nbits;
         343               0 :     nbits=oc_huff_tree_collapse_depth(_tokens+ti,last[l]+1-ti,depth[l]);
         344               0 :     node[l]=(ogg_int16_t)ntree;
         345               0 :     ntree+=oc_huff_node_size(nbits);
         346               0 :     if(_tree!=NULL)_tree[node[l]++]=(ogg_int16_t)nbits;
         347                 :     do{
         348               0 :       while(ti<=last[l]&&_tokens[ti][1]<=depth[l]+nbits){
         349               0 :         if(_tree!=NULL){
         350                 :           ogg_int16_t leaf;
         351                 :           int         nentries;
         352               0 :           nentries=1<<depth[l]+nbits-_tokens[ti][1];
         353               0 :           leaf=(ogg_int16_t)-(_tokens[ti][1]-depth[l]<<8|_tokens[ti][0]);
         354               0 :           while(nentries-->0)_tree[node[l]++]=leaf;
         355                 :         }
         356               0 :         ti++;
         357                 :       }
         358               0 :       if(ti<=last[l]){
         359                 :         /*We need to recurse*/
         360               0 :         depth[l+1]=(unsigned char)(depth[l]+nbits);
         361               0 :         if(_tree!=NULL)_tree[node[l]++]=(ogg_int16_t)ntree;
         362               0 :         l++;
         363               0 :         last[l]=
         364               0 :          (unsigned char)(ti+oc_huff_subtree_tokens(_tokens+ti,depth[l])-1);
         365               0 :         break;
         366                 :       }
         367                 :       /*Pop back up a level of recursion.*/
         368               0 :       else if(l-->0)nbits=depth[l+1]-depth[l];
         369                 :     }
         370               0 :     while(l>=0);
         371                 :   }
         372               0 :   while(l>=0);
         373               0 :   return ntree;
         374                 : }
         375                 :
         376                 : /*Unpacks a set of Huffman trees, and reduces them to a collapsed
         377                 :    representation.
         378                 :   _opb:   The buffer to unpack the trees from.
         379                 :   _nodes: The table to fill with the Huffman trees.
         380                 :   Return: 0 on success, or a negative value on error.
         381                 :           The caller is responsible for cleaning up any partially initialized
         382                 :            _nodes on failure.*/
         383               0 : int oc_huff_trees_unpack(oc_pack_buf *_opb,
         384                 :  ogg_int16_t *_nodes[TH_NHUFFMAN_TABLES]){
         385                 :   int i;
         386               0 :   for(i=0;i<TH_NHUFFMAN_TABLES;i++){
         387                 :     unsigned char  tokens[256][2];
         388                 :     int            ntokens;
         389                 :     ogg_int16_t   *tree;
         390                 :     size_t         size;
         391                 :     /*Unpack the full tree into a temporary buffer.*/
         392               0 :     ntokens=oc_huff_tree_unpack(_opb,tokens);
         393               0 :     if(ntokens<0)return ntokens;
         394                 :     /*Figure out how big the collapsed tree will be and allocate space for it.*/
         395               0 :     size=oc_huff_tree_collapse(NULL,tokens,ntokens);
         396                 :     /*This should never happen; if it does it means you set OC_HUFF_SLUSH or
         397                 :        OC_ROOT_HUFF_SLUSH too large.*/
         398               0 :     if(size>32767)return TH_EIMPL;
         399               0 :     tree=(ogg_int16_t *)_ogg_malloc(size*sizeof(*tree));
         400               0 :     if(tree==NULL)return TH_EFAULT;
         401                 :     /*Construct the collapsed the tree.*/
         402               0 :     oc_huff_tree_collapse(tree,tokens,ntokens);
         403               0 :     _nodes[i]=tree;
         404                 :   }
         405               0 :   return 0;
         406                 : }
         407                 :
         408                 : /*Determines the size in words of a Huffman subtree.
         409                 :   _tree: The complete Huffman tree.
         410                 :   _node: The index of the root of the desired subtree.
         411                 :   Return: The number of words required to store the tree.*/
         412               0 : static size_t oc_huff_tree_size(const ogg_int16_t *_tree,int _node){
         413                 :   size_t size;
         414                 :   int    nchildren;
         415                 :   int    n;
         416                 :   int    i;
         417               0 :   n=_tree[_node];
         418               0 :   size=oc_huff_node_size(n);
         419               0 :   nchildren=1<<n;
         420               0 :   i=0;
         421                 :   do{
         422                 :     int child;
         423               0 :     child=_tree[_node+i+1];
         424               0 :     if(child<=0)i+=1<<n-(-child>>8);
         425                 :     else{
         426               0 :       size+=oc_huff_tree_size(_tree,child);
         427               0 :       i++;
         428                 :     }
         429                 :   }
         430               0 :   while(i<nchildren);
         431               0 :   return size;
         432                 : }
         433                 :
         434                 : /*Makes a copy of the given set of Huffman trees.
         435                 :   _dst: The array to store the copy in.
         436                 :   _src: The array of trees to copy.*/
         437               0 : int oc_huff_trees_copy(ogg_int16_t *_dst[TH_NHUFFMAN_TABLES],
         438                 :  const ogg_int16_t *const _src[TH_NHUFFMAN_TABLES]){
         439                 :   int total;
         440                 :   int i;
         441               0 :   total=0;
         442               0 :   for(i=0;i<TH_NHUFFMAN_TABLES;i++){
         443                 :     size_t size;
         444               0 :     size=oc_huff_tree_size(_src[i],0);
         445               0 :     total+=size;
         446               0 :     _dst[i]=(ogg_int16_t *)_ogg_malloc(size*sizeof(*_dst[i]));
         447               0 :     if(_dst[i]==NULL){
         448               0 :       while(i-->0)_ogg_free(_dst[i]);
         449               0 :       return TH_EFAULT;
         450                 :     }
         451               0 :     memcpy(_dst[i],_src[i],size*sizeof(*_dst[i]));
         452                 :   }
         453               0 :   return 0;
         454                 : }
         455                 :
         456                 : /*Frees the memory used by a set of Huffman trees.
         457                 :   _nodes: The array of trees to free.*/
         458               0 : void oc_huff_trees_clear(ogg_int16_t *_nodes[TH_NHUFFMAN_TABLES]){
         459                 :   int i;
         460               0 :   for(i=0;i<TH_NHUFFMAN_TABLES;i++)_ogg_free(_nodes[i]);
         461               0 : }
         462                 :
         463                 :
         464                 : /*Unpacks a single token using the given Huffman tree.
         465                 :   _opb:  The buffer to unpack the token from.
         466                 :   _node: The tree to unpack the token with.
         467                 :   Return: The token value.*/
         468               0 : int oc_huff_token_decode_c(oc_pack_buf *_opb,const ogg_int16_t *_tree){
         469                 :   const unsigned char *ptr;
         470                 :   const unsigned char *stop;
         471                 :   oc_pb_window         window;
         472                 :   int                  available;
         473                 :   long                 bits;
         474                 :   int                  node;
         475                 :   int                  n;
         476               0 :   ptr=_opb->ptr;
         477               0 :   window=_opb->window;
         478               0 :   stop=_opb->stop;
         479               0 :   available=_opb->bits;
         480               0 :   node=0;
         481                 :   for(;;){
         482               0 :     n=_tree[node];
         483               0 :     if(n>available){
         484                 :       unsigned shift;
         485               0 :       shift=OC_PB_WINDOW_SIZE-available;
         486                 :       do{
         487                 :         /*We don't bother setting eof because we won't check for it after we've
         488                 :            started decoding DCT tokens.*/
         489               0 :         if(ptr>=stop){
         490               0 :           shift=(unsigned)-OC_LOTS_OF_BITS;
         491               0 :           break;
         492                 :         }
         493               0 :         shift-=8;
         494               0 :         window|=(oc_pb_window)*ptr++<<shift;
         495                 :       }
         496               0 :       while(shift>=8);
         497                 :       /*Note: We never request more than 24 bits, so there's no need to fill in
         498                 :          the last partial byte here.*/
         499               0 :       available=OC_PB_WINDOW_SIZE-shift;
         500                 :     }
         501               0 :     bits=window>>OC_PB_WINDOW_SIZE-n;
         502               0 :     node=_tree[node+1+bits];
         503               0 :     if(node<=0)break;
         504               0 :     window<<=n;
         505               0 :     available-=n;
         506               0 :   }
         507               0 :   node=-node;
         508               0 :   n=node>>8;
         509               0 :   window<<=n;
         510               0 :   available-=n;
         511               0 :   _opb->ptr=ptr;
         512               0 :   _opb->window=window;
         513               0 :   _opb->bits=available;
         514               0 :   return node&255;
         515                 : }

Generated by: LCOV version 1.7