variable_length.cc 3.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129
  1. /* Copyright 2015 Google Inc. All Rights Reserved.
  2. Distributed under MIT license.
  3. See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
  4. */
  5. /* Helper functions for woff2 variable length types: 255UInt16 and UIntBase128 */
  6. #include "./variable_length.h"
  7. namespace woff2 {
  8. size_t Size255UShort(uint16_t value) {
  9. size_t result = 3;
  10. if (value < 253) {
  11. result = 1;
  12. } else if (value < 762) {
  13. result = 2;
  14. } else {
  15. result = 3;
  16. }
  17. return result;
  18. }
  19. void Write255UShort(std::vector<uint8_t>* out, int value) {
  20. if (value < 253) {
  21. out->push_back(value);
  22. } else if (value < 506) {
  23. out->push_back(255);
  24. out->push_back(value - 253);
  25. } else if (value < 762) {
  26. out->push_back(254);
  27. out->push_back(value - 506);
  28. } else {
  29. out->push_back(253);
  30. out->push_back(value >> 8);
  31. out->push_back(value & 0xff);
  32. }
  33. }
  34. void Store255UShort(int val, size_t* offset, uint8_t* dst) {
  35. std::vector<uint8_t> packed;
  36. Write255UShort(&packed, val);
  37. for (uint8_t packed_byte : packed) {
  38. dst[(*offset)++] = packed_byte;
  39. }
  40. }
  41. // Based on section 6.1.1 of MicroType Express draft spec
  42. bool Read255UShort(Buffer* buf, unsigned int* value) {
  43. static const int kWordCode = 253;
  44. static const int kOneMoreByteCode2 = 254;
  45. static const int kOneMoreByteCode1 = 255;
  46. static const int kLowestUCode = 253;
  47. uint8_t code = 0;
  48. if (!buf->ReadU8(&code)) {
  49. return FONT_COMPRESSION_FAILURE();
  50. }
  51. if (code == kWordCode) {
  52. uint16_t result = 0;
  53. if (!buf->ReadU16(&result)) {
  54. return FONT_COMPRESSION_FAILURE();
  55. }
  56. *value = result;
  57. return true;
  58. } else if (code == kOneMoreByteCode1) {
  59. uint8_t result = 0;
  60. if (!buf->ReadU8(&result)) {
  61. return FONT_COMPRESSION_FAILURE();
  62. }
  63. *value = result + kLowestUCode;
  64. return true;
  65. } else if (code == kOneMoreByteCode2) {
  66. uint8_t result = 0;
  67. if (!buf->ReadU8(&result)) {
  68. return FONT_COMPRESSION_FAILURE();
  69. }
  70. *value = result + kLowestUCode * 2;
  71. return true;
  72. } else {
  73. *value = code;
  74. return true;
  75. }
  76. }
  77. bool ReadBase128(Buffer* buf, uint32_t* value) {
  78. uint32_t result = 0;
  79. for (size_t i = 0; i < 5; ++i) {
  80. uint8_t code = 0;
  81. if (!buf->ReadU8(&code)) {
  82. return FONT_COMPRESSION_FAILURE();
  83. }
  84. // Leading zeros are invalid.
  85. if (i == 0 && code == 0x80) {
  86. return FONT_COMPRESSION_FAILURE();
  87. }
  88. // If any of the top seven bits are set then we're about to overflow.
  89. if (result & 0xfe000000) {
  90. return FONT_COMPRESSION_FAILURE();
  91. }
  92. result = (result << 7) | (code & 0x7f);
  93. if ((code & 0x80) == 0) {
  94. *value = result;
  95. return true;
  96. }
  97. }
  98. // Make sure not to exceed the size bound
  99. return FONT_COMPRESSION_FAILURE();
  100. }
  101. size_t Base128Size(size_t n) {
  102. size_t size = 1;
  103. for (; n >= 128; n >>= 7) ++size;
  104. return size;
  105. }
  106. void StoreBase128(size_t len, size_t* offset, uint8_t* dst) {
  107. size_t size = Base128Size(len);
  108. for (size_t i = 0; i < size; ++i) {
  109. int b = static_cast<int>((len >> (7 * (size - i - 1))) & 0x7f);
  110. if (i < size - 1) {
  111. b |= 0x80;
  112. }
  113. dst[(*offset)++] = b;
  114. }
  115. }
  116. } // namespace woff2