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 } 106
