Coverage Report

Created: 2023-03-26 06:27

/src/draco/src/draco/compression/entropy/symbol_decoding.cc
Line
Count
Source (jump to first uncovered line)
1
// Copyright 2016 The Draco Authors.
2
//
3
// Licensed under the Apache License, Version 2.0 (the "License");
4
// you may not use this file except in compliance with the License.
5
// You may obtain a copy of the License at
6
//
7
//      http://www.apache.org/licenses/LICENSE-2.0
8
//
9
// Unless required by applicable law or agreed to in writing, software
10
// distributed under the License is distributed on an "AS IS" BASIS,
11
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12
// See the License for the specific language governing permissions and
13
// limitations under the License.
14
//
15
#include "draco/compression/entropy/symbol_decoding.h"
16
17
#include <algorithm>
18
#include <cmath>
19
20
#include "draco/compression/entropy/rans_symbol_decoder.h"
21
22
namespace draco {
23
24
template <template <int> class SymbolDecoderT>
25
bool DecodeTaggedSymbols(uint32_t num_values, int num_components,
26
                         DecoderBuffer *src_buffer, uint32_t *out_values);
27
28
template <template <int> class SymbolDecoderT>
29
bool DecodeRawSymbols(uint32_t num_values, DecoderBuffer *src_buffer,
30
                      uint32_t *out_values);
31
32
bool DecodeSymbols(uint32_t num_values, int num_components,
33
786
                   DecoderBuffer *src_buffer, uint32_t *out_values) {
34
786
  if (num_values == 0) {
35
0
    return true;
36
0
  }
37
  // Decode which scheme to use.
38
786
  uint8_t scheme;
39
786
  if (!src_buffer->Decode(&scheme)) {
40
0
    return false;
41
0
  }
42
786
  if (scheme == SYMBOL_CODING_TAGGED) {
43
109
    return DecodeTaggedSymbols<RAnsSymbolDecoder>(num_values, num_components,
44
109
                                                  src_buffer, out_values);
45
677
  } else if (scheme == SYMBOL_CODING_RAW) {
46
490
    return DecodeRawSymbols<RAnsSymbolDecoder>(num_values, src_buffer,
47
490
                                               out_values);
48
490
  }
49
187
  return false;
50
786
}
51
52
template <template <int> class SymbolDecoderT>
53
bool DecodeTaggedSymbols(uint32_t num_values, int num_components,
54
109
                         DecoderBuffer *src_buffer, uint32_t *out_values) {
55
  // Decode the encoded data.
56
109
  SymbolDecoderT<5> tag_decoder;
57
109
  if (!tag_decoder.Create(src_buffer)) {
58
62
    return false;
59
62
  }
60
61
47
  if (!tag_decoder.StartDecoding(src_buffer)) {
62
20
    return false;
63
20
  }
64
65
27
  if (num_values > 0 && tag_decoder.num_symbols() == 0) {
66
26
    return false;  // Wrong number of symbols.
67
26
  }
68
69
  // src_buffer now points behind the encoded tag data (to the place where the
70
  // values are encoded).
71
1
  src_buffer->StartBitDecoding(false, nullptr);
72
1
  int value_id = 0;
73
112
  for (uint32_t i = 0; i < num_values; i += num_components) {
74
    // Decode the tag.
75
111
    const uint32_t bit_length = tag_decoder.DecodeSymbol();
76
    // Decode the actual value.
77
222
    for (int j = 0; j < num_components; ++j) {
78
111
      uint32_t val;
79
111
      if (!src_buffer->DecodeLeastSignificantBits32(bit_length, &val)) {
80
0
        return false;
81
0
      }
82
111
      out_values[value_id++] = val;
83
111
    }
84
111
  }
85
1
  tag_decoder.EndDecoding();
86
1
  src_buffer->EndBitDecoding();
87
1
  return true;
88
1
}
89
90
template <class SymbolDecoderT>
91
bool DecodeRawSymbolsInternal(uint32_t num_values, DecoderBuffer *src_buffer,
92
438
                              uint32_t *out_values) {
93
438
  SymbolDecoderT decoder;
94
438
  if (!decoder.Create(src_buffer)) {
95
383
    return false;
96
383
  }
97
98
55
  if (num_values > 0 && decoder.num_symbols() == 0) {
99
3
    return false;  // Wrong number of symbols.
100
3
  }
101
102
52
  if (!decoder.StartDecoding(src_buffer)) {
103
26
    return false;
104
26
  }
105
54.6k
  for (uint32_t i = 0; i < num_values; ++i) {
106
    // Decode a symbol into the value.
107
54.6k
    const uint32_t value = decoder.DecodeSymbol();
108
54.6k
    out_values[i] = value;
109
54.6k
  }
110
26
  decoder.EndDecoding();
111
26
  return true;
112
52
}
bool draco::DecodeRawSymbolsInternal<draco::RAnsSymbolDecoder<1> >(unsigned int, draco::DecoderBuffer*, unsigned int*)
Line
Count
Source
92
41
                              uint32_t *out_values) {
93
41
  SymbolDecoderT decoder;
94
41
  if (!decoder.Create(src_buffer)) {
95
41
    return false;
96
41
  }
97
98
0
  if (num_values > 0 && decoder.num_symbols() == 0) {
99
0
    return false;  // Wrong number of symbols.
100
0
  }
101
102
0
  if (!decoder.StartDecoding(src_buffer)) {
103
0
    return false;
104
0
  }
105
0
  for (uint32_t i = 0; i < num_values; ++i) {
106
    // Decode a symbol into the value.
107
0
    const uint32_t value = decoder.DecodeSymbol();
108
0
    out_values[i] = value;
109
0
  }
110
0
  decoder.EndDecoding();
111
0
  return true;
112
0
}
bool draco::DecodeRawSymbolsInternal<draco::RAnsSymbolDecoder<2> >(unsigned int, draco::DecoderBuffer*, unsigned int*)
Line
Count
Source
92
11
                              uint32_t *out_values) {
93
11
  SymbolDecoderT decoder;
94
11
  if (!decoder.Create(src_buffer)) {
95
8
    return false;
96
8
  }
97
98
3
  if (num_values > 0 && decoder.num_symbols() == 0) {
99
0
    return false;  // Wrong number of symbols.
100
0
  }
101
102
3
  if (!decoder.StartDecoding(src_buffer)) {
103
0
    return false;
104
0
  }
105
5.99k
  for (uint32_t i = 0; i < num_values; ++i) {
106
    // Decode a symbol into the value.
107
5.99k
    const uint32_t value = decoder.DecodeSymbol();
108
5.99k
    out_values[i] = value;
109
5.99k
  }
110
3
  decoder.EndDecoding();
111
3
  return true;
112
3
}
bool draco::DecodeRawSymbolsInternal<draco::RAnsSymbolDecoder<3> >(unsigned int, draco::DecoderBuffer*, unsigned int*)
Line
Count
Source
92
31
                              uint32_t *out_values) {
93
31
  SymbolDecoderT decoder;
94
31
  if (!decoder.Create(src_buffer)) {
95
30
    return false;
96
30
  }
97
98
1
  if (num_values > 0 && decoder.num_symbols() == 0) {
99
1
    return false;  // Wrong number of symbols.
100
1
  }
101
102
0
  if (!decoder.StartDecoding(src_buffer)) {
103
0
    return false;
104
0
  }
105
0
  for (uint32_t i = 0; i < num_values; ++i) {
106
    // Decode a symbol into the value.
107
0
    const uint32_t value = decoder.DecodeSymbol();
108
0
    out_values[i] = value;
109
0
  }
110
0
  decoder.EndDecoding();
111
0
  return true;
112
0
}
bool draco::DecodeRawSymbolsInternal<draco::RAnsSymbolDecoder<4> >(unsigned int, draco::DecoderBuffer*, unsigned int*)
Line
Count
Source
92
35
                              uint32_t *out_values) {
93
35
  SymbolDecoderT decoder;
94
35
  if (!decoder.Create(src_buffer)) {
95
26
    return false;
96
26
  }
97
98
9
  if (num_values > 0 && decoder.num_symbols() == 0) {
99
0
    return false;  // Wrong number of symbols.
100
0
  }
101
102
9
  if (!decoder.StartDecoding(src_buffer)) {
103
3
    return false;
104
3
  }
105
17.7k
  for (uint32_t i = 0; i < num_values; ++i) {
106
    // Decode a symbol into the value.
107
17.7k
    const uint32_t value = decoder.DecodeSymbol();
108
17.7k
    out_values[i] = value;
109
17.7k
  }
110
6
  decoder.EndDecoding();
111
6
  return true;
112
9
}
bool draco::DecodeRawSymbolsInternal<draco::RAnsSymbolDecoder<5> >(unsigned int, draco::DecoderBuffer*, unsigned int*)
Line
Count
Source
92
1
                              uint32_t *out_values) {
93
1
  SymbolDecoderT decoder;
94
1
  if (!decoder.Create(src_buffer)) {
95
0
    return false;
96
0
  }
97
98
1
  if (num_values > 0 && decoder.num_symbols() == 0) {
99
0
    return false;  // Wrong number of symbols.
100
0
  }
101
102
1
  if (!decoder.StartDecoding(src_buffer)) {
103
0
    return false;
104
0
  }
105
3.50k
  for (uint32_t i = 0; i < num_values; ++i) {
106
    // Decode a symbol into the value.
107
3.50k
    const uint32_t value = decoder.DecodeSymbol();
108
3.50k
    out_values[i] = value;
109
3.50k
  }
110
1
  decoder.EndDecoding();
111
1
  return true;
112
1
}
bool draco::DecodeRawSymbolsInternal<draco::RAnsSymbolDecoder<6> >(unsigned int, draco::DecoderBuffer*, unsigned int*)
Line
Count
Source
92
35
                              uint32_t *out_values) {
93
35
  SymbolDecoderT decoder;
94
35
  if (!decoder.Create(src_buffer)) {
95
20
    return false;
96
20
  }
97
98
15
  if (num_values > 0 && decoder.num_symbols() == 0) {
99
0
    return false;  // Wrong number of symbols.
100
0
  }
101
102
15
  if (!decoder.StartDecoding(src_buffer)) {
103
11
    return false;
104
11
  }
105
32
  for (uint32_t i = 0; i < num_values; ++i) {
106
    // Decode a symbol into the value.
107
28
    const uint32_t value = decoder.DecodeSymbol();
108
28
    out_values[i] = value;
109
28
  }
110
4
  decoder.EndDecoding();
111
4
  return true;
112
15
}
bool draco::DecodeRawSymbolsInternal<draco::RAnsSymbolDecoder<7> >(unsigned int, draco::DecoderBuffer*, unsigned int*)
Line
Count
Source
92
23
                              uint32_t *out_values) {
93
23
  SymbolDecoderT decoder;
94
23
  if (!decoder.Create(src_buffer)) {
95
21
    return false;
96
21
  }
97
98
2
  if (num_values > 0 && decoder.num_symbols() == 0) {
99
0
    return false;  // Wrong number of symbols.
100
0
  }
101
102
2
  if (!decoder.StartDecoding(src_buffer)) {
103
1
    return false;
104
1
  }
105
14.7k
  for (uint32_t i = 0; i < num_values; ++i) {
106
    // Decode a symbol into the value.
107
14.7k
    const uint32_t value = decoder.DecodeSymbol();
108
14.7k
    out_values[i] = value;
109
14.7k
  }
110
1
  decoder.EndDecoding();
111
1
  return true;
112
2
}
bool draco::DecodeRawSymbolsInternal<draco::RAnsSymbolDecoder<8> >(unsigned int, draco::DecoderBuffer*, unsigned int*)
Line
Count
Source
92
39
                              uint32_t *out_values) {
93
39
  SymbolDecoderT decoder;
94
39
  if (!decoder.Create(src_buffer)) {
95
35
    return false;
96
35
  }
97
98
4
  if (num_values > 0 && decoder.num_symbols() == 0) {
99
0
    return false;  // Wrong number of symbols.
100
0
  }
101
102
4
  if (!decoder.StartDecoding(src_buffer)) {
103
2
    return false;
104
2
  }
105
7.71k
  for (uint32_t i = 0; i < num_values; ++i) {
106
    // Decode a symbol into the value.
107
7.71k
    const uint32_t value = decoder.DecodeSymbol();
108
7.71k
    out_values[i] = value;
109
7.71k
  }
110
2
  decoder.EndDecoding();
111
2
  return true;
112
4
}
bool draco::DecodeRawSymbolsInternal<draco::RAnsSymbolDecoder<9> >(unsigned int, draco::DecoderBuffer*, unsigned int*)
Line
Count
Source
92
30
                              uint32_t *out_values) {
93
30
  SymbolDecoderT decoder;
94
30
  if (!decoder.Create(src_buffer)) {
95
24
    return false;
96
24
  }
97
98
6
  if (num_values > 0 && decoder.num_symbols() == 0) {
99
0
    return false;  // Wrong number of symbols.
100
0
  }
101
102
6
  if (!decoder.StartDecoding(src_buffer)) {
103
0
    return false;
104
0
  }
105
12
  for (uint32_t i = 0; i < num_values; ++i) {
106
    // Decode a symbol into the value.
107
6
    const uint32_t value = decoder.DecodeSymbol();
108
6
    out_values[i] = value;
109
6
  }
110
6
  decoder.EndDecoding();
111
6
  return true;
112
6
}
bool draco::DecodeRawSymbolsInternal<draco::RAnsSymbolDecoder<10> >(unsigned int, draco::DecoderBuffer*, unsigned int*)
Line
Count
Source
92
25
                              uint32_t *out_values) {
93
25
  SymbolDecoderT decoder;
94
25
  if (!decoder.Create(src_buffer)) {
95
24
    return false;
96
24
  }
97
98
1
  if (num_values > 0 && decoder.num_symbols() == 0) {
99
0
    return false;  // Wrong number of symbols.
100
0
  }
101
102
1
  if (!decoder.StartDecoding(src_buffer)) {
103
1
    return false;
104
1
  }
105
0
  for (uint32_t i = 0; i < num_values; ++i) {
106
    // Decode a symbol into the value.
107
0
    const uint32_t value = decoder.DecodeSymbol();
108
0
    out_values[i] = value;
109
0
  }
110
0
  decoder.EndDecoding();
111
0
  return true;
112
1
}
bool draco::DecodeRawSymbolsInternal<draco::RAnsSymbolDecoder<11> >(unsigned int, draco::DecoderBuffer*, unsigned int*)
Line
Count
Source
92
16
                              uint32_t *out_values) {
93
16
  SymbolDecoderT decoder;
94
16
  if (!decoder.Create(src_buffer)) {
95
14
    return false;
96
14
  }
97
98
2
  if (num_values > 0 && decoder.num_symbols() == 0) {
99
0
    return false;  // Wrong number of symbols.
100
0
  }
101
102
2
  if (!decoder.StartDecoding(src_buffer)) {
103
2
    return false;
104
2
  }
105
0
  for (uint32_t i = 0; i < num_values; ++i) {
106
    // Decode a symbol into the value.
107
0
    const uint32_t value = decoder.DecodeSymbol();
108
0
    out_values[i] = value;
109
0
  }
110
0
  decoder.EndDecoding();
111
0
  return true;
112
2
}
bool draco::DecodeRawSymbolsInternal<draco::RAnsSymbolDecoder<12> >(unsigned int, draco::DecoderBuffer*, unsigned int*)
Line
Count
Source
92
45
                              uint32_t *out_values) {
93
45
  SymbolDecoderT decoder;
94
45
  if (!decoder.Create(src_buffer)) {
95
44
    return false;
96
44
  }
97
98
1
  if (num_values > 0 && decoder.num_symbols() == 0) {
99
0
    return false;  // Wrong number of symbols.
100
0
  }
101
102
1
  if (!decoder.StartDecoding(src_buffer)) {
103
1
    return false;
104
1
  }
105
0
  for (uint32_t i = 0; i < num_values; ++i) {
106
    // Decode a symbol into the value.
107
0
    const uint32_t value = decoder.DecodeSymbol();
108
0
    out_values[i] = value;
109
0
  }
110
0
  decoder.EndDecoding();
111
0
  return true;
112
1
}
bool draco::DecodeRawSymbolsInternal<draco::RAnsSymbolDecoder<13> >(unsigned int, draco::DecoderBuffer*, unsigned int*)
Line
Count
Source
92
20
                              uint32_t *out_values) {
93
20
  SymbolDecoderT decoder;
94
20
  if (!decoder.Create(src_buffer)) {
95
18
    return false;
96
18
  }
97
98
2
  if (num_values > 0 && decoder.num_symbols() == 0) {
99
0
    return false;  // Wrong number of symbols.
100
0
  }
101
102
2
  if (!decoder.StartDecoding(src_buffer)) {
103
2
    return false;
104
2
  }
105
0
  for (uint32_t i = 0; i < num_values; ++i) {
106
    // Decode a symbol into the value.
107
0
    const uint32_t value = decoder.DecodeSymbol();
108
0
    out_values[i] = value;
109
0
  }
110
0
  decoder.EndDecoding();
111
0
  return true;
112
2
}
bool draco::DecodeRawSymbolsInternal<draco::RAnsSymbolDecoder<14> >(unsigned int, draco::DecoderBuffer*, unsigned int*)
Line
Count
Source
92
16
                              uint32_t *out_values) {
93
16
  SymbolDecoderT decoder;
94
16
  if (!decoder.Create(src_buffer)) {
95
15
    return false;
96
15
  }
97
98
1
  if (num_values > 0 && decoder.num_symbols() == 0) {
99
1
    return false;  // Wrong number of symbols.
100
1
  }
101
102
0
  if (!decoder.StartDecoding(src_buffer)) {
103
0
    return false;
104
0
  }
105
0
  for (uint32_t i = 0; i < num_values; ++i) {
106
    // Decode a symbol into the value.
107
0
    const uint32_t value = decoder.DecodeSymbol();
108
0
    out_values[i] = value;
109
0
  }
110
0
  decoder.EndDecoding();
111
0
  return true;
112
0
}
bool draco::DecodeRawSymbolsInternal<draco::RAnsSymbolDecoder<15> >(unsigned int, draco::DecoderBuffer*, unsigned int*)
Line
Count
Source
92
23
                              uint32_t *out_values) {
93
23
  SymbolDecoderT decoder;
94
23
  if (!decoder.Create(src_buffer)) {
95
22
    return false;
96
22
  }
97
98
1
  if (num_values > 0 && decoder.num_symbols() == 0) {
99
0
    return false;  // Wrong number of symbols.
100
0
  }
101
102
1
  if (!decoder.StartDecoding(src_buffer)) {
103
1
    return false;
104
1
  }
105
0
  for (uint32_t i = 0; i < num_values; ++i) {
106
    // Decode a symbol into the value.
107
0
    const uint32_t value = decoder.DecodeSymbol();
108
0
    out_values[i] = value;
109
0
  }
110
0
  decoder.EndDecoding();
111
0
  return true;
112
1
}
bool draco::DecodeRawSymbolsInternal<draco::RAnsSymbolDecoder<16> >(unsigned int, draco::DecoderBuffer*, unsigned int*)
Line
Count
Source
92
3
                              uint32_t *out_values) {
93
3
  SymbolDecoderT decoder;
94
3
  if (!decoder.Create(src_buffer)) {
95
1
    return false;
96
1
  }
97
98
2
  if (num_values > 0 && decoder.num_symbols() == 0) {
99
0
    return false;  // Wrong number of symbols.
100
0
  }
101
102
2
  if (!decoder.StartDecoding(src_buffer)) {
103
2
    return false;
104
2
  }
105
0
  for (uint32_t i = 0; i < num_values; ++i) {
106
    // Decode a symbol into the value.
107
0
    const uint32_t value = decoder.DecodeSymbol();
108
0
    out_values[i] = value;
109
0
  }
110
0
  decoder.EndDecoding();
111
0
  return true;
112
2
}
bool draco::DecodeRawSymbolsInternal<draco::RAnsSymbolDecoder<17> >(unsigned int, draco::DecoderBuffer*, unsigned int*)
Line
Count
Source
92
24
                              uint32_t *out_values) {
93
24
  SymbolDecoderT decoder;
94
24
  if (!decoder.Create(src_buffer)) {
95
23
    return false;
96
23
  }
97
98
1
  if (num_values > 0 && decoder.num_symbols() == 0) {
99
1
    return false;  // Wrong number of symbols.
100
1
  }
101
102
0
  if (!decoder.StartDecoding(src_buffer)) {
103
0
    return false;
104
0
  }
105
0
  for (uint32_t i = 0; i < num_values; ++i) {
106
    // Decode a symbol into the value.
107
0
    const uint32_t value = decoder.DecodeSymbol();
108
0
    out_values[i] = value;
109
0
  }
110
0
  decoder.EndDecoding();
111
0
  return true;
112
0
}
bool draco::DecodeRawSymbolsInternal<draco::RAnsSymbolDecoder<18> >(unsigned int, draco::DecoderBuffer*, unsigned int*)
Line
Count
Source
92
20
                              uint32_t *out_values) {
93
20
  SymbolDecoderT decoder;
94
20
  if (!decoder.Create(src_buffer)) {
95
17
    return false;
96
17
  }
97
98
3
  if (num_values > 0 && decoder.num_symbols() == 0) {
99
0
    return false;  // Wrong number of symbols.
100
0
  }
101
102
3
  if (!decoder.StartDecoding(src_buffer)) {
103
0
    return false;
104
0
  }
105
4.88k
  for (uint32_t i = 0; i < num_values; ++i) {
106
    // Decode a symbol into the value.
107
4.88k
    const uint32_t value = decoder.DecodeSymbol();
108
4.88k
    out_values[i] = value;
109
4.88k
  }
110
3
  decoder.EndDecoding();
111
3
  return true;
112
3
}
113
114
template <template <int> class SymbolDecoderT>
115
bool DecodeRawSymbols(uint32_t num_values, DecoderBuffer *src_buffer,
116
490
                      uint32_t *out_values) {
117
490
  uint8_t max_bit_length;
118
490
  if (!src_buffer->Decode(&max_bit_length)) {
119
0
    return false;
120
0
  }
121
490
  switch (max_bit_length) {
122
41
    case 1:
123
41
      return DecodeRawSymbolsInternal<SymbolDecoderT<1>>(num_values, src_buffer,
124
41
                                                         out_values);
125
11
    case 2:
126
11
      return DecodeRawSymbolsInternal<SymbolDecoderT<2>>(num_values, src_buffer,
127
11
                                                         out_values);
128
31
    case 3:
129
31
      return DecodeRawSymbolsInternal<SymbolDecoderT<3>>(num_values, src_buffer,
130
31
                                                         out_values);
131
35
    case 4:
132
35
      return DecodeRawSymbolsInternal<SymbolDecoderT<4>>(num_values, src_buffer,
133
35
                                                         out_values);
134
1
    case 5:
135
1
      return DecodeRawSymbolsInternal<SymbolDecoderT<5>>(num_values, src_buffer,
136
1
                                                         out_values);
137
35
    case 6:
138
35
      return DecodeRawSymbolsInternal<SymbolDecoderT<6>>(num_values, src_buffer,
139
35
                                                         out_values);
140
23
    case 7:
141
23
      return DecodeRawSymbolsInternal<SymbolDecoderT<7>>(num_values, src_buffer,
142
23
                                                         out_values);
143
39
    case 8:
144
39
      return DecodeRawSymbolsInternal<SymbolDecoderT<8>>(num_values, src_buffer,
145
39
                                                         out_values);
146
30
    case 9:
147
30
      return DecodeRawSymbolsInternal<SymbolDecoderT<9>>(num_values, src_buffer,
148
30
                                                         out_values);
149
25
    case 10:
150
25
      return DecodeRawSymbolsInternal<SymbolDecoderT<10>>(
151
25
          num_values, src_buffer, out_values);
152
16
    case 11:
153
16
      return DecodeRawSymbolsInternal<SymbolDecoderT<11>>(
154
16
          num_values, src_buffer, out_values);
155
45
    case 12:
156
45
      return DecodeRawSymbolsInternal<SymbolDecoderT<12>>(
157
45
          num_values, src_buffer, out_values);
158
20
    case 13:
159
20
      return DecodeRawSymbolsInternal<SymbolDecoderT<13>>(
160
20
          num_values, src_buffer, out_values);
161
16
    case 14:
162
16
      return DecodeRawSymbolsInternal<SymbolDecoderT<14>>(
163
16
          num_values, src_buffer, out_values);
164
23
    case 15:
165
23
      return DecodeRawSymbolsInternal<SymbolDecoderT<15>>(
166
23
          num_values, src_buffer, out_values);
167
3
    case 16:
168
3
      return DecodeRawSymbolsInternal<SymbolDecoderT<16>>(
169
3
          num_values, src_buffer, out_values);
170
24
    case 17:
171
24
      return DecodeRawSymbolsInternal<SymbolDecoderT<17>>(
172
24
          num_values, src_buffer, out_values);
173
20
    case 18:
174
20
      return DecodeRawSymbolsInternal<SymbolDecoderT<18>>(
175
20
          num_values, src_buffer, out_values);
176
52
    default:
177
52
      return false;
178
490
  }
179
490
}
180
181
}  // namespace draco