Point Cloud Library (PCL)  1.11.0
entropy_range_coder.hpp
1 /*
2  * Software License Agreement (BSD License)
3  *
4  * Point Cloud Library (PCL) - www.pointclouds.org
5  * Copyright (c) 2010-2012, Willow Garage, Inc.
6  *
7  * All rights reserved.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  *
13  * * Redistributions of source code must retain the above copyright
14  * notice, this list of conditions and the following disclaimer.
15  * * Redistributions in binary form must reproduce the above
16  * copyright notice, this list of conditions and the following
17  * disclaimer in the documentation and/or other materials provided
18  * with the distribution.
19  * * Neither the name of Willow Garage, Inc. nor the names of its
20  * contributors may be used to endorse or promote products derived
21  * from this software without specific prior written permission.
22  *
23  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
24  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
25  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
26  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
27  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
28  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
29  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
30  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
31  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
33  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
34  * POSSIBILITY OF SUCH DAMAGE.
35  *
36  *
37  * range coder based on Dmitry Subbotin's carry-less implementation (http://www.compression.ru/ds/)
38  * Added optimized symbol lookup and fixed/static frequency tables
39  *
40  */
41 
42 #ifndef __PCL_IO_RANGECODING__HPP
43 #define __PCL_IO_RANGECODING__HPP
44 
45 #include <pcl/compression/entropy_range_coder.h>
46 #include <map>
47 #include <iostream>
48 #include <vector>
49 #include <cstring>
50 #include <algorithm>
51 #include <cstdio>
52 
53 //////////////////////////////////////////////////////////////////////////////////////////////
54 unsigned long
55 pcl::AdaptiveRangeCoder::encodeCharVectorToStream (const std::vector<char>& inputByteVector_arg,
56  std::ostream& outputByteStream_arg)
57 {
58  DWord freq[257];
59 
60  // define limits
61  const DWord top = static_cast<DWord> (1) << 24;
62  const DWord bottom = static_cast<DWord> (1) << 16;
63  const DWord maxRange = static_cast<DWord> (1) << 16;
64 
65  unsigned int input_size = static_cast<unsigned> (inputByteVector_arg.size ());
66 
67  // init output vector
68  outputCharVector_.clear ();
69  outputCharVector_.reserve (sizeof(char) * input_size);
70 
71  unsigned int readPos = 0;
72 
73  DWord low = 0;
74  DWord range = static_cast<DWord> (-1);
75 
76  // initialize cumulative frequency table
77  for (unsigned int i = 0; i < 257; i++)
78  freq[i] = i;
79 
80  // scan input
81  while (readPos < input_size)
82  {
83  // read byte
84  std::uint8_t ch = inputByteVector_arg[readPos++];
85 
86  // map range
87  low += freq[ch] * (range /= freq[256]);
88  range *= freq[ch + 1] - freq[ch];
89 
90  // check range limits
91  while ((low ^ (low + range)) < top || ((range < bottom) && ((range = -int (low) & (bottom - 1)), 1)))
92  {
93  char out = static_cast<char> (low >> 24);
94  range <<= 8;
95  low <<= 8;
96  outputCharVector_.push_back (out);
97  }
98 
99  // update frequency table
100  for (unsigned int j = ch + 1; j < 257; j++)
101  freq[j]++;
102 
103  // detect overflow
104  if (freq[256] >= maxRange)
105  {
106  // rescale
107  for (unsigned int f = 1; f <= 256; f++)
108  {
109  freq[f] /= 2;
110  if (freq[f] <= freq[f - 1])
111  freq[f] = freq[f - 1] + 1;
112  }
113  }
114 
115  }
116 
117  // flush remaining data
118  for (unsigned int i = 0; i < 4; i++)
119  {
120  char out = static_cast<char> (low >> 24);
121  outputCharVector_.push_back (out);
122  low <<= 8;
123  }
124 
125  // write to stream
126  outputByteStream_arg.write (&outputCharVector_[0], outputCharVector_.size ());
127 
128  return (static_cast<unsigned long> (outputCharVector_.size ()));
129 }
130 
131 //////////////////////////////////////////////////////////////////////////////////////////////
132 unsigned long
133 pcl::AdaptiveRangeCoder::decodeStreamToCharVector (std::istream& inputByteStream_arg,
134  std::vector<char>& outputByteVector_arg)
135 {
136  DWord freq[257];
137 
138  // define limits
139  const DWord top = static_cast<DWord> (1) << 24;
140  const DWord bottom = static_cast<DWord> (1) << 16;
141  const DWord maxRange = static_cast<DWord> (1) << 16;
142 
143  unsigned int output_size = static_cast<unsigned> (outputByteVector_arg.size ());
144 
145  unsigned long streamByteCount = 0;
146 
147  unsigned int outputBufPos = 0;
148 
149  DWord code = 0;
150  DWord low = 0;
151  DWord range = static_cast<DWord> (-1);
152 
153  // init decoding
154  for (unsigned int i = 0; i < 4; i++)
155  {
156  std::uint8_t ch;
157  inputByteStream_arg.read (reinterpret_cast<char*> (&ch), sizeof(char));
158  streamByteCount += sizeof(char);
159  code = (code << 8) | ch;
160  }
161 
162  // init cumulative frequency table
163  for (unsigned int i = 0; i <= 256; i++)
164  freq[i] = i;
165 
166  // decoding loop
167  for (unsigned int i = 0; i < output_size; i++)
168  {
169  std::uint8_t symbol = 0;
170  std::uint8_t sSize = 256 / 2;
171 
172  // map code to range
173  DWord count = (code - low) / (range /= freq[256]);
174 
175  // find corresponding symbol
176  while (sSize > 0)
177  {
178  if (freq[symbol + sSize] <= count)
179  {
180  symbol = static_cast<std::uint8_t> (symbol + sSize);
181  }
182  sSize /= 2;
183  }
184 
185  // output symbol
186  outputByteVector_arg[outputBufPos++] = symbol;
187 
188  // update range limits
189  low += freq[symbol] * range;
190  range *= freq[symbol + 1] - freq[symbol];
191 
192  // decode range limits
193  while ((low ^ (low + range)) < top || ((range < bottom) && ((range = -int (low) & (bottom - 1)), 1)))
194  {
195  std::uint8_t ch;
196  inputByteStream_arg.read (reinterpret_cast<char*> (&ch), sizeof(char));
197  streamByteCount += sizeof(char);
198  code = code << 8 | ch;
199  range <<= 8;
200  low <<= 8;
201  }
202 
203  // update cumulative frequency table
204  for (unsigned int j = symbol + 1; j < 257; j++)
205  freq[j]++;
206 
207  // detect overflow
208  if (freq[256] >= maxRange)
209  {
210  // rescale
211  for (unsigned int f = 1; f <= 256; f++)
212  {
213  freq[f] /= 2;
214  if (freq[f] <= freq[f - 1])
215  freq[f] = freq[f - 1] + 1;
216  }
217  }
218  }
219 
220  return (streamByteCount);
221 }
222 
223 //////////////////////////////////////////////////////////////////////////////////////////////
224 unsigned long
225 pcl::StaticRangeCoder::encodeIntVectorToStream (std::vector<unsigned int>& inputIntVector_arg,
226  std::ostream& outputByteStream_arg)
227 {
228  // define numerical limits
229  const std::uint64_t top = static_cast<std::uint64_t> (1) << 56;
230  const std::uint64_t bottom = static_cast<std::uint64_t> (1) << 48;
231  const std::uint64_t maxRange = static_cast<std::uint64_t> (1) << 48;
232 
233  unsigned long input_size = static_cast<unsigned long> (inputIntVector_arg.size ());
234 
235  // init output vector
236  outputCharVector_.clear ();
237  outputCharVector_.reserve ((sizeof(char) * input_size * 2));
238 
239  std::uint64_t frequencyTableSize = 1;
240 
241  unsigned int readPos = 0;
242 
243  // calculate frequency table
244  cFreqTable_[0] = cFreqTable_[1] = 0;
245  while (readPos < input_size)
246  {
247  unsigned int inputSymbol = inputIntVector_arg[readPos++];
248 
249  if (inputSymbol + 1 >= frequencyTableSize)
250  {
251  // frequency table is to small -> adaptively extend it
252  std::uint64_t oldfrequencyTableSize;
253  oldfrequencyTableSize = frequencyTableSize;
254 
255  do
256  {
257  // increase frequency table size by factor 2
258  frequencyTableSize <<= 1;
259  } while (inputSymbol + 1 > frequencyTableSize);
260 
261  if (cFreqTable_.size () < frequencyTableSize + 1)
262  {
263  // resize frequency vector
264  cFreqTable_.resize (static_cast<std::size_t> (frequencyTableSize + 1));
265  }
266 
267  // init new frequency range with zero
268  memset (&cFreqTable_[static_cast<std::size_t> (oldfrequencyTableSize + 1)], 0,
269  sizeof(std::uint64_t) * static_cast<std::size_t> (frequencyTableSize - oldfrequencyTableSize));
270  }
271  cFreqTable_[inputSymbol + 1]++;
272  }
273  frequencyTableSize++;
274 
275  // convert to cumulative frequency table
276  for (std::uint64_t f = 1; f < frequencyTableSize; f++)
277  {
278  cFreqTable_[f] = cFreqTable_[f - 1] + cFreqTable_[f];
279  if (cFreqTable_[f] <= cFreqTable_[f - 1])
280  cFreqTable_[f] = cFreqTable_[f - 1] + 1;
281  }
282 
283  // rescale if numerical limits are reached
284  while (cFreqTable_[static_cast<std::size_t> (frequencyTableSize - 1)] >= maxRange)
285  {
286  for (std::size_t f = 1; f < cFreqTable_.size (); f++)
287  {
288  cFreqTable_[f] /= 2;
289  ;
290  if (cFreqTable_[f] <= cFreqTable_[f - 1])
291  cFreqTable_[f] = cFreqTable_[f - 1] + 1;
292  }
293  }
294 
295  // calculate amount of bytes per frequency table entry
296  std::uint8_t frequencyTableByteSize = static_cast<std::uint8_t> (std::ceil (
297  std::log2 (static_cast<double> (cFreqTable_[static_cast<std::size_t> (frequencyTableSize - 1)] + 1)) / 8.0));
298 
299  // write size of frequency table to output stream
300  outputByteStream_arg.write (reinterpret_cast<const char*> (&frequencyTableSize), sizeof(frequencyTableSize));
301  outputByteStream_arg.write (reinterpret_cast<const char*> (&frequencyTableByteSize), sizeof(frequencyTableByteSize));
302 
303  unsigned long streamByteCount = sizeof(frequencyTableSize) + sizeof(frequencyTableByteSize);
304 
305  // write cumulative frequency table to output stream
306  for (std::uint64_t f = 1; f < frequencyTableSize; f++)
307  {
308  outputByteStream_arg.write (reinterpret_cast<const char*> (&cFreqTable_[f]), frequencyTableByteSize);
309  streamByteCount += frequencyTableByteSize;
310  }
311 
312  readPos = 0;
313  std::uint64_t low = 0;
314  std::uint64_t range = static_cast<std::uint64_t> (-1);
315 
316  // start encoding
317  while (readPos < input_size)
318  {
319 
320  // read symol
321  unsigned int inputsymbol = inputIntVector_arg[readPos++];
322 
323  // map to range
324  low += cFreqTable_[inputsymbol] * (range /= cFreqTable_[static_cast<std::size_t> (frequencyTableSize - 1)]);
325  range *= cFreqTable_[inputsymbol + 1] - cFreqTable_[inputsymbol];
326 
327  // check range limits
328  while ((low ^ (low + range)) < top || ((range < bottom) && ((range = -low & (bottom - 1)), 1)))
329  {
330  char out = static_cast<char> (low >> 56);
331  range <<= 8;
332  low <<= 8;
333  outputCharVector_.push_back (out);
334  }
335 
336  }
337 
338  // flush remaining data
339  for (unsigned int i = 0; i < 8; i++)
340  {
341  char out = static_cast<char> (low >> 56);
342  outputCharVector_.push_back (out);
343  low <<= 8;
344  }
345 
346  // write encoded data to stream
347  outputByteStream_arg.write (&outputCharVector_[0], outputCharVector_.size ());
348 
349  streamByteCount += static_cast<unsigned long> (outputCharVector_.size ());
350 
351  return (streamByteCount);
352 }
353 
354 //////////////////////////////////////////////////////////////////////////////////////////////
355 unsigned long
356 pcl::StaticRangeCoder::decodeStreamToIntVector (std::istream& inputByteStream_arg,
357  std::vector<unsigned int>& outputIntVector_arg)
358 {
359  // define range limits
360  const std::uint64_t top = static_cast<std::uint64_t> (1) << 56;
361  const std::uint64_t bottom = static_cast<std::uint64_t> (1) << 48;
362 
363  std::uint64_t frequencyTableSize;
364  unsigned char frequencyTableByteSize;
365 
366  unsigned int outputBufPos = 0;
367  std::size_t output_size = outputIntVector_arg.size ();
368 
369  // read size of cumulative frequency table from stream
370  inputByteStream_arg.read (reinterpret_cast<char*> (&frequencyTableSize), sizeof(frequencyTableSize));
371  inputByteStream_arg.read (reinterpret_cast<char*> (&frequencyTableByteSize), sizeof(frequencyTableByteSize));
372 
373  unsigned long streamByteCount = sizeof(frequencyTableSize) + sizeof(frequencyTableByteSize);
374 
375  // check size of frequency table vector
376  if (cFreqTable_.size () < frequencyTableSize)
377  {
378  cFreqTable_.resize (static_cast<std::size_t> (frequencyTableSize));
379  }
380 
381  // init with zero
382  memset (&cFreqTable_[0], 0, sizeof(std::uint64_t) * static_cast<std::size_t> (frequencyTableSize));
383 
384  // read cumulative frequency table
385  for (std::uint64_t f = 1; f < frequencyTableSize; f++)
386  {
387  inputByteStream_arg.read (reinterpret_cast<char *> (&cFreqTable_[f]), frequencyTableByteSize);
388  streamByteCount += frequencyTableByteSize;
389  }
390 
391  // initialize range & code
392  std::uint64_t code = 0;
393  std::uint64_t low = 0;
394  std::uint64_t range = static_cast<std::uint64_t> (-1);
395 
396  // init code vector
397  for (unsigned int i = 0; i < 8; i++)
398  {
399  std::uint8_t ch;
400  inputByteStream_arg.read (reinterpret_cast<char*> (&ch), sizeof(char));
401  streamByteCount += sizeof(char);
402  code = (code << 8) | ch;
403  }
404 
405  // decoding
406  for (std::size_t i = 0; i < output_size; i++)
407  {
408  std::uint64_t count = (code - low) / (range /= cFreqTable_[static_cast<std::size_t> (frequencyTableSize - 1)]);
409 
410  // symbol lookup in cumulative frequency table
411  std::uint64_t symbol = 0;
412  std::uint64_t sSize = (frequencyTableSize - 1) / 2;
413  while (sSize > 0)
414  {
415  if (cFreqTable_[static_cast<std::size_t> (symbol + sSize)] <= count)
416  {
417  symbol += sSize;
418  }
419  sSize /= 2;
420  }
421 
422  // write symbol to output stream
423  outputIntVector_arg[outputBufPos++] = static_cast<unsigned int> (symbol);
424 
425  // map to range
426  low += cFreqTable_[static_cast<std::size_t> (symbol)] * range;
427  range *= cFreqTable_[static_cast<std::size_t> (symbol + 1)] - cFreqTable_[static_cast<std::size_t> (symbol)];
428 
429  // check range limits
430  while ((low ^ (low + range)) < top || ((range < bottom) && ((range = -low & (bottom - 1)), 1)))
431  {
432  std::uint8_t ch;
433  inputByteStream_arg.read (reinterpret_cast<char*> (&ch), sizeof(char));
434  streamByteCount += sizeof(char);
435  code = code << 8 | ch;
436  range <<= 8;
437  low <<= 8;
438  }
439  }
440 
441  return streamByteCount;
442 }
443 
444 //////////////////////////////////////////////////////////////////////////////////////////////
445 unsigned long
446 pcl::StaticRangeCoder::encodeCharVectorToStream (const std::vector<char>& inputByteVector_arg,
447  std::ostream& outputByteStream_arg)
448 {
449  DWord freq[257];
450 
451  // define numerical limits
452  const DWord top = static_cast<DWord> (1) << 24;
453  const DWord bottom = static_cast<DWord> (1) << 16;
454  const DWord maxRange = static_cast<DWord> (1) << 16;
455 
456  DWord low, range;
457 
458  unsigned int input_size;
459  input_size = static_cast<unsigned int> (inputByteVector_arg.size ());
460 
461  // init output vector
462  outputCharVector_.clear ();
463  outputCharVector_.reserve (sizeof(char) * input_size);
464 
465  std::uint64_t FreqHist[257];
466 
467  // calculate frequency table
468  memset (FreqHist, 0, sizeof(FreqHist));
469  unsigned int readPos = 0;
470  while (readPos < input_size)
471  {
472  std::uint8_t symbol = static_cast<std::uint8_t> (inputByteVector_arg[readPos++]);
473  FreqHist[symbol + 1]++;
474  }
475 
476  // convert to cumulative frequency table
477  freq[0] = 0;
478  for (int f = 1; f <= 256; f++)
479  {
480  freq[f] = freq[f - 1] + static_cast<DWord> (FreqHist[f]);
481  if (freq[f] <= freq[f - 1])
482  freq[f] = freq[f - 1] + 1;
483  }
484 
485  // rescale if numerical limits are reached
486  while (freq[256] >= maxRange)
487  {
488  for (int f = 1; f <= 256; f++)
489  {
490  freq[f] /= 2;
491  ;
492  if (freq[f] <= freq[f - 1])
493  freq[f] = freq[f - 1] + 1;
494  }
495  }
496 
497  // write cumulative frequency table to output stream
498  outputByteStream_arg.write (reinterpret_cast<const char*> (&freq[0]), sizeof(freq));
499  unsigned long streamByteCount = sizeof(freq);
500 
501  readPos = 0;
502 
503  low = 0;
504  range = static_cast<DWord> (-1);
505 
506  // start encoding
507  while (readPos < input_size)
508  {
509  // read symol
510  std::uint8_t ch = inputByteVector_arg[readPos++];
511 
512  // map to range
513  low += freq[ch] * (range /= freq[256]);
514  range *= freq[ch + 1] - freq[ch];
515 
516  // check range limits
517  while ((low ^ (low + range)) < top || ((range < bottom) && ((range = -int (low) & (bottom - 1)), 1)))
518  {
519  char out = static_cast<char> (low >> 24);
520  range <<= 8;
521  low <<= 8;
522  outputCharVector_.push_back (out);
523  }
524 
525  }
526 
527  // flush remaining data
528  for (int i = 0; i < 4; i++)
529  {
530  char out = static_cast<char> (low >> 24);
531  outputCharVector_.push_back (out);
532  low <<= 8;
533  }
534 
535  // write encoded data to stream
536  outputByteStream_arg.write (&outputCharVector_[0], outputCharVector_.size ());
537 
538  streamByteCount += static_cast<unsigned long> (outputCharVector_.size ());
539 
540  return (streamByteCount);
541 }
542 
543 //////////////////////////////////////////////////////////////////////////////////////////////
544 unsigned long
545 pcl::StaticRangeCoder::decodeStreamToCharVector (std::istream& inputByteStream_arg,
546  std::vector<char>& outputByteVector_arg)
547 {
548  DWord freq[257];
549 
550  // define range limits
551  const DWord top = static_cast<DWord> (1) << 24;
552  const DWord bottom = static_cast<DWord> (1) << 16;
553 
554  DWord low, range;
555  DWord code;
556 
557  unsigned int outputBufPos;
558  unsigned int output_size;
559 
560  unsigned long streamByteCount;
561 
562  streamByteCount = 0;
563 
564  output_size = static_cast<unsigned int> (outputByteVector_arg.size ());
565 
566  outputBufPos = 0;
567 
568  // read cumulative frequency table
569  inputByteStream_arg.read (reinterpret_cast<char*> (&freq[0]), sizeof(freq));
570  streamByteCount += sizeof(freq);
571 
572  code = 0;
573  low = 0;
574  range = static_cast<DWord> (-1);
575 
576  // init code
577  for (unsigned int i = 0; i < 4; i++)
578  {
579  std::uint8_t ch;
580  inputByteStream_arg.read (reinterpret_cast<char*> (&ch), sizeof(char));
581  streamByteCount += sizeof(char);
582  code = (code << 8) | ch;
583  }
584 
585  // decoding
586  for (unsigned int i = 0; i < output_size; i++)
587  {
588  // symbol lookup in cumulative frequency table
589  std::uint8_t symbol = 0;
590  std::uint8_t sSize = 256 / 2;
591 
592  DWord count = (code - low) / (range /= freq[256]);
593 
594  while (sSize > 0)
595  {
596  if (freq[symbol + sSize] <= count)
597  {
598  symbol = static_cast<std::uint8_t> (symbol + sSize);
599  }
600  sSize /= 2;
601  }
602 
603  // write symbol to output stream
604  outputByteVector_arg[outputBufPos++] = symbol;
605 
606  low += freq[symbol] * range;
607  range *= freq[symbol + 1] - freq[symbol];
608 
609  // check range limits
610  while ((low ^ (low + range)) < top || ((range < bottom) && ((range = -int (low) & (bottom - 1)), 1)))
611  {
612  std::uint8_t ch;
613  inputByteStream_arg.read (reinterpret_cast<char*> (&ch), sizeof(char));
614  streamByteCount += sizeof(char);
615  code = code << 8 | ch;
616  range <<= 8;
617  low <<= 8;
618  }
619 
620  }
621 
622  return (streamByteCount);
623 }
624 
625 #endif
626 
pcl::AdaptiveRangeCoder::DWord
std::uint32_t DWord
Definition: entropy_range_coder.h:102
pcl::StaticRangeCoder::decodeStreamToIntVector
unsigned long decodeStreamToIntVector(std::istream &inputByteStream_arg, std::vector< unsigned int > &outputIntVector_arg)
Decode stream to output integer vector.
Definition: entropy_range_coder.hpp:356
pcl::AdaptiveRangeCoder::encodeCharVectorToStream
unsigned long encodeCharVectorToStream(const std::vector< char > &inputByteVector_arg, std::ostream &outputByteStream_arg)
Encode char vector to output stream.
Definition: entropy_range_coder.hpp:55
pcl::StaticRangeCoder::DWord
std::uint32_t DWord
Definition: entropy_range_coder.h:167
pcl::StaticRangeCoder::decodeStreamToCharVector
unsigned long decodeStreamToCharVector(std::istream &inputByteStream_arg, std::vector< char > &outputByteVector_arg)
Decode char stream to output vector.
Definition: entropy_range_coder.hpp:545
pcl::uint8_t
std::uint8_t uint8_t
Definition: types.h:54
pcl::AdaptiveRangeCoder::decodeStreamToCharVector
unsigned long decodeStreamToCharVector(std::istream &inputByteStream_arg, std::vector< char > &outputByteVector_arg)
Decode char stream to output vector.
Definition: entropy_range_coder.hpp:133
pcl::StaticRangeCoder::encodeIntVectorToStream
unsigned long encodeIntVectorToStream(std::vector< unsigned int > &inputIntVector_arg, std::ostream &outputByterStream_arg)
Encode integer vector to output stream.
Definition: entropy_range_coder.hpp:225
pcl::StaticRangeCoder::encodeCharVectorToStream
unsigned long encodeCharVectorToStream(const std::vector< char > &inputByteVector_arg, std::ostream &outputByteStream_arg)
Encode char vector to output stream.
Definition: entropy_range_coder.hpp:446
pcl::uint64_t
std::uint64_t uint64_t
Definition: types.h:60