aom/src/aom_integer.c

   1 /*
   2  * Copyright (c) 2018, Alliance for Open Media. All rights reserved
   3  *
   4  * This source code is subject to the terms of the BSD 2 Clause License and
   5  * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
   6  * was not distributed with this source code in the LICENSE file, you can
   7  * obtain it at www.aomedia.org/license/software. If the Alliance for Open
   8  * Media Patent License 1.0 was not distributed with this source code in the
   9  * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
  10  */
  11 #include <assert.h>
  12
  13 #include "aom/aom_integer.h"
  14
  15 static const size_t kMaximumLeb128Size = 8;
  16 static const uint8_t kLeb128ByteMask = 0x7f;  // Binary: 01111111
  17
  18 // Disallow values larger than 32-bits to ensure consistent behavior on 32 and
  19 // 64 bit targets: value is typically used to determine buffer allocation size
  20 // when decoded.
  21 static const uint64_t kMaximumLeb128Value = UINT32_MAX;
  22
  23 size_t aom_uleb_size_in_bytes(uint64_t value) {
  24   size_t size = 0;
  25   do {
  26     ++size;
  27   } while ((value >>= 7) != 0);
  28   return size;
  29 }
  30
  31 int aom_uleb_decode(const uint8_t *buffer, size_t available, uint64_t *value,
  32                     size_t *length) {
  33   if (buffer && value) {
  34     *value = 0;
  35     for (size_t i = 0; i < kMaximumLeb128Size && i < available; ++i) {
  36       const uint8_t decoded_byte = *(buffer + i) & kLeb128ByteMask;
  37       *value |= ((uint64_t)decoded_byte) << (i * 7);
  38       if ((*(buffer + i) >> 7) == 0) {
  39         if (length) {
  40           *length = i + 1;
  41         }
  42
  43         // Fail on values larger than 32-bits to ensure consistent behavior on
  44         // 32 and 64 bit targets: value is typically used to determine buffer
  45         // allocation size.
  46         if (*value > UINT32_MAX) return -1;
  47
  48         return 0;
  49       }
  50     }
  51   }
  52
  53   // If we get here, either the buffer/value pointers were invalid,
  54   // or we ran over the available space
  55   return -1;
  56 }
  57
  58 int aom_uleb_encode(uint64_t value, size_t available, uint8_t *coded_value,
  59                     size_t *coded_size) {
  60   const size_t leb_size = aom_uleb_size_in_bytes(value);
  61   if (value > kMaximumLeb128Value || leb_size > kMaximumLeb128Size ||
  62       leb_size > available || !coded_value || !coded_size) {
  63     return -1;
  64   }
  65
  66   for (size_t i = 0; i < leb_size; ++i) {
  67     uint8_t byte = value & 0x7f;
  68     value >>= 7;
  69
  70     if (value != 0) byte |= 0x80;  // Signal that more bytes follow.
  71
  72     *(coded_value + i) = byte;
  73   }
  74
  75   *coded_size = leb_size;
  76   return 0;
  77 }
  78
  79 int aom_uleb_encode_fixed_size(uint64_t value, size_t available,
  80                                size_t pad_to_size, uint8_t *coded_value,
  81                                size_t *coded_size) {
  82   if (value > kMaximumLeb128Value || !coded_value || !coded_size ||
  83       available < pad_to_size || pad_to_size > kMaximumLeb128Size) {
  84     return -1;
  85   }
  86   const uint64_t limit = 1ULL << (7 * pad_to_size);
  87   if (value >= limit) {
  88     // Can't encode 'value' within 'pad_to_size' bytes
  89     return -1;
  90   }
  91
  92   for (size_t i = 0; i < pad_to_size; ++i) {
  93     uint8_t byte = value & 0x7f;
  94     value >>= 7;
  95
  96     if (i < pad_to_size - 1) byte |= 0x80;  // Signal that more bytes follow.
  97
  98     *(coded_value + i) = byte;
  99   }
 100
 101   assert(value == 0);
 102
 103   *coded_size = pad_to_size;
 104   return 0;
 105 }