| // SPDX-License-Identifier: Apache-2.0 |
| // ---------------------------------------------------------------------------- |
| // Copyright 2011-2021 Arm Limited |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); you may not |
| // use this file except in compliance with the License. You may obtain a copy |
| // of the License at: |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| // License for the specific language governing permissions and limitations |
| // under the License. |
| // ---------------------------------------------------------------------------- |
| |
| /** |
| * @brief Functions for encoding/decoding Bounded Integer Sequence Encoding. |
| */ |
| |
| #include "astcenc_internal.h" |
| |
| #include <array> |
| |
| /** @brief Unpacked quint triplets <low,middle,high> for each packed value */ |
| static const uint8_t quints_of_integer[128][3] { |
| {0, 0, 0}, {1, 0, 0}, {2, 0, 0}, {3, 0, 0}, |
| {4, 0, 0}, {0, 4, 0}, {4, 4, 0}, {4, 4, 4}, |
| {0, 1, 0}, {1, 1, 0}, {2, 1, 0}, {3, 1, 0}, |
| {4, 1, 0}, {1, 4, 0}, {4, 4, 1}, {4, 4, 4}, |
| {0, 2, 0}, {1, 2, 0}, {2, 2, 0}, {3, 2, 0}, |
| {4, 2, 0}, {2, 4, 0}, {4, 4, 2}, {4, 4, 4}, |
| {0, 3, 0}, {1, 3, 0}, {2, 3, 0}, {3, 3, 0}, |
| {4, 3, 0}, {3, 4, 0}, {4, 4, 3}, {4, 4, 4}, |
| {0, 0, 1}, {1, 0, 1}, {2, 0, 1}, {3, 0, 1}, |
| {4, 0, 1}, {0, 4, 1}, {4, 0, 4}, {0, 4, 4}, |
| {0, 1, 1}, {1, 1, 1}, {2, 1, 1}, {3, 1, 1}, |
| {4, 1, 1}, {1, 4, 1}, {4, 1, 4}, {1, 4, 4}, |
| {0, 2, 1}, {1, 2, 1}, {2, 2, 1}, {3, 2, 1}, |
| {4, 2, 1}, {2, 4, 1}, {4, 2, 4}, {2, 4, 4}, |
| {0, 3, 1}, {1, 3, 1}, {2, 3, 1}, {3, 3, 1}, |
| {4, 3, 1}, {3, 4, 1}, {4, 3, 4}, {3, 4, 4}, |
| {0, 0, 2}, {1, 0, 2}, {2, 0, 2}, {3, 0, 2}, |
| {4, 0, 2}, {0, 4, 2}, {2, 0, 4}, {3, 0, 4}, |
| {0, 1, 2}, {1, 1, 2}, {2, 1, 2}, {3, 1, 2}, |
| {4, 1, 2}, {1, 4, 2}, {2, 1, 4}, {3, 1, 4}, |
| {0, 2, 2}, {1, 2, 2}, {2, 2, 2}, {3, 2, 2}, |
| {4, 2, 2}, {2, 4, 2}, {2, 2, 4}, {3, 2, 4}, |
| {0, 3, 2}, {1, 3, 2}, {2, 3, 2}, {3, 3, 2}, |
| {4, 3, 2}, {3, 4, 2}, {2, 3, 4}, {3, 3, 4}, |
| {0, 0, 3}, {1, 0, 3}, {2, 0, 3}, {3, 0, 3}, |
| {4, 0, 3}, {0, 4, 3}, {0, 0, 4}, {1, 0, 4}, |
| {0, 1, 3}, {1, 1, 3}, {2, 1, 3}, {3, 1, 3}, |
| {4, 1, 3}, {1, 4, 3}, {0, 1, 4}, {1, 1, 4}, |
| {0, 2, 3}, {1, 2, 3}, {2, 2, 3}, {3, 2, 3}, |
| {4, 2, 3}, {2, 4, 3}, {0, 2, 4}, {1, 2, 4}, |
| {0, 3, 3}, {1, 3, 3}, {2, 3, 3}, {3, 3, 3}, |
| {4, 3, 3}, {3, 4, 3}, {0, 3, 4}, {1, 3, 4} |
| }; |
| |
| /** @brief Packed quint values for each unpacked value, indexed [hi][mid][lo]. */ |
| static const uint8_t integer_of_quints[5][5][5] { |
| { |
| {0, 1, 2, 3, 4}, |
| {8, 9, 10, 11, 12}, |
| {16, 17, 18, 19, 20}, |
| {24, 25, 26, 27, 28}, |
| {5, 13, 21, 29, 6} |
| }, |
| { |
| {32, 33, 34, 35, 36}, |
| {40, 41, 42, 43, 44}, |
| {48, 49, 50, 51, 52}, |
| {56, 57, 58, 59, 60}, |
| {37, 45, 53, 61, 14} |
| }, |
| { |
| {64, 65, 66, 67, 68}, |
| {72, 73, 74, 75, 76}, |
| {80, 81, 82, 83, 84}, |
| {88, 89, 90, 91, 92}, |
| {69, 77, 85, 93, 22} |
| }, |
| { |
| {96, 97, 98, 99, 100}, |
| {104, 105, 106, 107, 108}, |
| {112, 113, 114, 115, 116}, |
| {120, 121, 122, 123, 124}, |
| {101, 109, 117, 125, 30} |
| }, |
| { |
| {102, 103, 70, 71, 38}, |
| {110, 111, 78, 79, 46}, |
| {118, 119, 86, 87, 54}, |
| {126, 127, 94, 95, 62}, |
| {39, 47, 55, 63, 31} |
| } |
| }; |
| |
| /** @brief Unpacked trit quintuplets <low,...,high> for each packed value */ |
| static const uint8_t trits_of_integer[256][5] { |
| {0, 0, 0, 0, 0}, {1, 0, 0, 0, 0}, {2, 0, 0, 0, 0}, {0, 0, 2, 0, 0}, |
| {0, 1, 0, 0, 0}, {1, 1, 0, 0, 0}, {2, 1, 0, 0, 0}, {1, 0, 2, 0, 0}, |
| {0, 2, 0, 0, 0}, {1, 2, 0, 0, 0}, {2, 2, 0, 0, 0}, {2, 0, 2, 0, 0}, |
| {0, 2, 2, 0, 0}, {1, 2, 2, 0, 0}, {2, 2, 2, 0, 0}, {2, 0, 2, 0, 0}, |
| {0, 0, 1, 0, 0}, {1, 0, 1, 0, 0}, {2, 0, 1, 0, 0}, {0, 1, 2, 0, 0}, |
| {0, 1, 1, 0, 0}, {1, 1, 1, 0, 0}, {2, 1, 1, 0, 0}, {1, 1, 2, 0, 0}, |
| {0, 2, 1, 0, 0}, {1, 2, 1, 0, 0}, {2, 2, 1, 0, 0}, {2, 1, 2, 0, 0}, |
| {0, 0, 0, 2, 2}, {1, 0, 0, 2, 2}, {2, 0, 0, 2, 2}, {0, 0, 2, 2, 2}, |
| {0, 0, 0, 1, 0}, {1, 0, 0, 1, 0}, {2, 0, 0, 1, 0}, {0, 0, 2, 1, 0}, |
| {0, 1, 0, 1, 0}, {1, 1, 0, 1, 0}, {2, 1, 0, 1, 0}, {1, 0, 2, 1, 0}, |
| {0, 2, 0, 1, 0}, {1, 2, 0, 1, 0}, {2, 2, 0, 1, 0}, {2, 0, 2, 1, 0}, |
| {0, 2, 2, 1, 0}, {1, 2, 2, 1, 0}, {2, 2, 2, 1, 0}, {2, 0, 2, 1, 0}, |
| {0, 0, 1, 1, 0}, {1, 0, 1, 1, 0}, {2, 0, 1, 1, 0}, {0, 1, 2, 1, 0}, |
| {0, 1, 1, 1, 0}, {1, 1, 1, 1, 0}, {2, 1, 1, 1, 0}, {1, 1, 2, 1, 0}, |
| {0, 2, 1, 1, 0}, {1, 2, 1, 1, 0}, {2, 2, 1, 1, 0}, {2, 1, 2, 1, 0}, |
| {0, 1, 0, 2, 2}, {1, 1, 0, 2, 2}, {2, 1, 0, 2, 2}, {1, 0, 2, 2, 2}, |
| {0, 0, 0, 2, 0}, {1, 0, 0, 2, 0}, {2, 0, 0, 2, 0}, {0, 0, 2, 2, 0}, |
| {0, 1, 0, 2, 0}, {1, 1, 0, 2, 0}, {2, 1, 0, 2, 0}, {1, 0, 2, 2, 0}, |
| {0, 2, 0, 2, 0}, {1, 2, 0, 2, 0}, {2, 2, 0, 2, 0}, {2, 0, 2, 2, 0}, |
| {0, 2, 2, 2, 0}, {1, 2, 2, 2, 0}, {2, 2, 2, 2, 0}, {2, 0, 2, 2, 0}, |
| {0, 0, 1, 2, 0}, {1, 0, 1, 2, 0}, {2, 0, 1, 2, 0}, {0, 1, 2, 2, 0}, |
| {0, 1, 1, 2, 0}, {1, 1, 1, 2, 0}, {2, 1, 1, 2, 0}, {1, 1, 2, 2, 0}, |
| {0, 2, 1, 2, 0}, {1, 2, 1, 2, 0}, {2, 2, 1, 2, 0}, {2, 1, 2, 2, 0}, |
| {0, 2, 0, 2, 2}, {1, 2, 0, 2, 2}, {2, 2, 0, 2, 2}, {2, 0, 2, 2, 2}, |
| {0, 0, 0, 0, 2}, {1, 0, 0, 0, 2}, {2, 0, 0, 0, 2}, {0, 0, 2, 0, 2}, |
| {0, 1, 0, 0, 2}, {1, 1, 0, 0, 2}, {2, 1, 0, 0, 2}, {1, 0, 2, 0, 2}, |
| {0, 2, 0, 0, 2}, {1, 2, 0, 0, 2}, {2, 2, 0, 0, 2}, {2, 0, 2, 0, 2}, |
| {0, 2, 2, 0, 2}, {1, 2, 2, 0, 2}, {2, 2, 2, 0, 2}, {2, 0, 2, 0, 2}, |
| {0, 0, 1, 0, 2}, {1, 0, 1, 0, 2}, {2, 0, 1, 0, 2}, {0, 1, 2, 0, 2}, |
| {0, 1, 1, 0, 2}, {1, 1, 1, 0, 2}, {2, 1, 1, 0, 2}, {1, 1, 2, 0, 2}, |
| {0, 2, 1, 0, 2}, {1, 2, 1, 0, 2}, {2, 2, 1, 0, 2}, {2, 1, 2, 0, 2}, |
| {0, 2, 2, 2, 2}, {1, 2, 2, 2, 2}, {2, 2, 2, 2, 2}, {2, 0, 2, 2, 2}, |
| {0, 0, 0, 0, 1}, {1, 0, 0, 0, 1}, {2, 0, 0, 0, 1}, {0, 0, 2, 0, 1}, |
| {0, 1, 0, 0, 1}, {1, 1, 0, 0, 1}, {2, 1, 0, 0, 1}, {1, 0, 2, 0, 1}, |
| {0, 2, 0, 0, 1}, {1, 2, 0, 0, 1}, {2, 2, 0, 0, 1}, {2, 0, 2, 0, 1}, |
| {0, 2, 2, 0, 1}, {1, 2, 2, 0, 1}, {2, 2, 2, 0, 1}, {2, 0, 2, 0, 1}, |
| {0, 0, 1, 0, 1}, {1, 0, 1, 0, 1}, {2, 0, 1, 0, 1}, {0, 1, 2, 0, 1}, |
| {0, 1, 1, 0, 1}, {1, 1, 1, 0, 1}, {2, 1, 1, 0, 1}, {1, 1, 2, 0, 1}, |
| {0, 2, 1, 0, 1}, {1, 2, 1, 0, 1}, {2, 2, 1, 0, 1}, {2, 1, 2, 0, 1}, |
| {0, 0, 1, 2, 2}, {1, 0, 1, 2, 2}, {2, 0, 1, 2, 2}, {0, 1, 2, 2, 2}, |
| {0, 0, 0, 1, 1}, {1, 0, 0, 1, 1}, {2, 0, 0, 1, 1}, {0, 0, 2, 1, 1}, |
| {0, 1, 0, 1, 1}, {1, 1, 0, 1, 1}, {2, 1, 0, 1, 1}, {1, 0, 2, 1, 1}, |
| {0, 2, 0, 1, 1}, {1, 2, 0, 1, 1}, {2, 2, 0, 1, 1}, {2, 0, 2, 1, 1}, |
| {0, 2, 2, 1, 1}, {1, 2, 2, 1, 1}, {2, 2, 2, 1, 1}, {2, 0, 2, 1, 1}, |
| {0, 0, 1, 1, 1}, {1, 0, 1, 1, 1}, {2, 0, 1, 1, 1}, {0, 1, 2, 1, 1}, |
| {0, 1, 1, 1, 1}, {1, 1, 1, 1, 1}, {2, 1, 1, 1, 1}, {1, 1, 2, 1, 1}, |
| {0, 2, 1, 1, 1}, {1, 2, 1, 1, 1}, {2, 2, 1, 1, 1}, {2, 1, 2, 1, 1}, |
| {0, 1, 1, 2, 2}, {1, 1, 1, 2, 2}, {2, 1, 1, 2, 2}, {1, 1, 2, 2, 2}, |
| {0, 0, 0, 2, 1}, {1, 0, 0, 2, 1}, {2, 0, 0, 2, 1}, {0, 0, 2, 2, 1}, |
| {0, 1, 0, 2, 1}, {1, 1, 0, 2, 1}, {2, 1, 0, 2, 1}, {1, 0, 2, 2, 1}, |
| {0, 2, 0, 2, 1}, {1, 2, 0, 2, 1}, {2, 2, 0, 2, 1}, {2, 0, 2, 2, 1}, |
| {0, 2, 2, 2, 1}, {1, 2, 2, 2, 1}, {2, 2, 2, 2, 1}, {2, 0, 2, 2, 1}, |
| {0, 0, 1, 2, 1}, {1, 0, 1, 2, 1}, {2, 0, 1, 2, 1}, {0, 1, 2, 2, 1}, |
| {0, 1, 1, 2, 1}, {1, 1, 1, 2, 1}, {2, 1, 1, 2, 1}, {1, 1, 2, 2, 1}, |
| {0, 2, 1, 2, 1}, {1, 2, 1, 2, 1}, {2, 2, 1, 2, 1}, {2, 1, 2, 2, 1}, |
| {0, 2, 1, 2, 2}, {1, 2, 1, 2, 2}, {2, 2, 1, 2, 2}, {2, 1, 2, 2, 2}, |
| {0, 0, 0, 1, 2}, {1, 0, 0, 1, 2}, {2, 0, 0, 1, 2}, {0, 0, 2, 1, 2}, |
| {0, 1, 0, 1, 2}, {1, 1, 0, 1, 2}, {2, 1, 0, 1, 2}, {1, 0, 2, 1, 2}, |
| {0, 2, 0, 1, 2}, {1, 2, 0, 1, 2}, {2, 2, 0, 1, 2}, {2, 0, 2, 1, 2}, |
| {0, 2, 2, 1, 2}, {1, 2, 2, 1, 2}, {2, 2, 2, 1, 2}, {2, 0, 2, 1, 2}, |
| {0, 0, 1, 1, 2}, {1, 0, 1, 1, 2}, {2, 0, 1, 1, 2}, {0, 1, 2, 1, 2}, |
| {0, 1, 1, 1, 2}, {1, 1, 1, 1, 2}, {2, 1, 1, 1, 2}, {1, 1, 2, 1, 2}, |
| {0, 2, 1, 1, 2}, {1, 2, 1, 1, 2}, {2, 2, 1, 1, 2}, {2, 1, 2, 1, 2}, |
| {0, 2, 2, 2, 2}, {1, 2, 2, 2, 2}, {2, 2, 2, 2, 2}, {2, 1, 2, 2, 2} |
| }; |
| |
| /** @brief Packed trit values for each unpacked value, indexed [hi][][][][lo]. */ |
| static const uint8_t integer_of_trits[3][3][3][3][3] { |
| { |
| { |
| { |
| {0, 1, 2}, |
| {4, 5, 6}, |
| {8, 9, 10} |
| }, |
| { |
| {16, 17, 18}, |
| {20, 21, 22}, |
| {24, 25, 26} |
| }, |
| { |
| {3, 7, 15}, |
| {19, 23, 27}, |
| {12, 13, 14} |
| } |
| }, |
| { |
| { |
| {32, 33, 34}, |
| {36, 37, 38}, |
| {40, 41, 42} |
| }, |
| { |
| {48, 49, 50}, |
| {52, 53, 54}, |
| {56, 57, 58} |
| }, |
| { |
| {35, 39, 47}, |
| {51, 55, 59}, |
| {44, 45, 46} |
| } |
| }, |
| { |
| { |
| {64, 65, 66}, |
| {68, 69, 70}, |
| {72, 73, 74} |
| }, |
| { |
| {80, 81, 82}, |
| {84, 85, 86}, |
| {88, 89, 90} |
| }, |
| { |
| {67, 71, 79}, |
| {83, 87, 91}, |
| {76, 77, 78} |
| } |
| } |
| }, |
| { |
| { |
| { |
| {128, 129, 130}, |
| {132, 133, 134}, |
| {136, 137, 138} |
| }, |
| { |
| {144, 145, 146}, |
| {148, 149, 150}, |
| {152, 153, 154} |
| }, |
| { |
| {131, 135, 143}, |
| {147, 151, 155}, |
| {140, 141, 142} |
| } |
| }, |
| { |
| { |
| {160, 161, 162}, |
| {164, 165, 166}, |
| {168, 169, 170} |
| }, |
| { |
| {176, 177, 178}, |
| {180, 181, 182}, |
| {184, 185, 186} |
| }, |
| { |
| {163, 167, 175}, |
| {179, 183, 187}, |
| {172, 173, 174} |
| } |
| }, |
| { |
| { |
| {192, 193, 194}, |
| {196, 197, 198}, |
| {200, 201, 202} |
| }, |
| { |
| {208, 209, 210}, |
| {212, 213, 214}, |
| {216, 217, 218} |
| }, |
| { |
| {195, 199, 207}, |
| {211, 215, 219}, |
| {204, 205, 206} |
| } |
| } |
| }, |
| { |
| { |
| { |
| {96, 97, 98}, |
| {100, 101, 102}, |
| {104, 105, 106} |
| }, |
| { |
| {112, 113, 114}, |
| {116, 117, 118}, |
| {120, 121, 122} |
| }, |
| { |
| {99, 103, 111}, |
| {115, 119, 123}, |
| {108, 109, 110} |
| } |
| }, |
| { |
| { |
| {224, 225, 226}, |
| {228, 229, 230}, |
| {232, 233, 234} |
| }, |
| { |
| {240, 241, 242}, |
| {244, 245, 246}, |
| {248, 249, 250} |
| }, |
| { |
| {227, 231, 239}, |
| {243, 247, 251}, |
| {236, 237, 238} |
| } |
| }, |
| { |
| { |
| {28, 29, 30}, |
| {60, 61, 62}, |
| {92, 93, 94} |
| }, |
| { |
| {156, 157, 158}, |
| {188, 189, 190}, |
| {220, 221, 222} |
| }, |
| { |
| {31, 63, 127}, |
| {159, 191, 255}, |
| {252, 253, 254} |
| } |
| } |
| } |
| }; |
| |
| /** |
| * @brief The number of bits, trits, and quints needed for a quant level. |
| */ |
| struct btq_count |
| { |
| /** @brief The quantization level. */ |
| uint8_t quant; |
| |
| /** @brief The number of bits. */ |
| uint8_t bits; |
| |
| /** @brief The number of trits. */ |
| uint8_t trits; |
| |
| /** @brief The number of quints. */ |
| uint8_t quints; |
| }; |
| |
| /** |
| * @brief The table of bits, trits, and quints needed for a quant encode. |
| */ |
| static const std::array<btq_count, 21> btq_counts {{ |
| { QUANT_2, 1, 0, 0 }, |
| { QUANT_3, 0, 1, 0 }, |
| { QUANT_4, 2, 0, 0 }, |
| { QUANT_5, 0, 0, 1 }, |
| { QUANT_6, 1, 1, 0 }, |
| { QUANT_8, 3, 0, 0 }, |
| { QUANT_10, 1, 0, 1 }, |
| { QUANT_12, 2, 1, 0 }, |
| { QUANT_16, 4, 0, 0 }, |
| { QUANT_20, 2, 0, 1 }, |
| { QUANT_24, 3, 1, 0 }, |
| { QUANT_32, 5, 0, 0 }, |
| { QUANT_40, 3, 0, 1 }, |
| { QUANT_48, 4, 1, 0 }, |
| { QUANT_64, 6, 0, 0 }, |
| { QUANT_80, 4, 0, 1 }, |
| { QUANT_96, 5, 1, 0 }, |
| { QUANT_128, 7, 0, 0 }, |
| { QUANT_160, 5, 0, 1 }, |
| { QUANT_192, 6, 1, 0 }, |
| { QUANT_256, 8, 0, 0 } |
| }}; |
| |
| /** |
| * @brief The sequence scale, round, and divisors needed to compute sizing. |
| * |
| * The length of a quantized sequence in bits is: |
| * (scale * <sequence_len> + round) / divisor |
| */ |
| struct ise_size |
| { |
| /** @brief The quantization level. */ |
| uint8_t quant; |
| |
| /** @brief The scaling parameter. */ |
| uint8_t scale; |
| |
| /** @brief The rounding parameter. */ |
| uint8_t round; |
| |
| /** @brief The divisor parameter. */ |
| uint8_t divisor; |
| }; |
| |
| /** |
| * @brief The table of scale, round, and divisors needed for quant sizing. |
| */ |
| static const std::array<ise_size, 21> ise_sizes {{ |
| { QUANT_2, 1, 0, 1 }, |
| { QUANT_3, 8, 4, 5 }, |
| { QUANT_4, 2, 0, 1 }, |
| { QUANT_5, 7, 2, 3 }, |
| { QUANT_6, 13, 4, 5 }, |
| { QUANT_8, 3, 0, 1 }, |
| { QUANT_10, 10, 2, 3 }, |
| { QUANT_12, 18, 4, 5 }, |
| { QUANT_16, 4, 0, 1 }, |
| { QUANT_20, 13, 2, 3 }, |
| { QUANT_24, 23, 4, 5 }, |
| { QUANT_32, 5, 0, 1 }, |
| { QUANT_40, 16, 2, 3 }, |
| { QUANT_48, 28, 4, 5 }, |
| { QUANT_64, 6, 0, 1 }, |
| { QUANT_80, 19, 2, 3 }, |
| { QUANT_96, 33, 4, 5 }, |
| { QUANT_128, 7, 0, 1 }, |
| { QUANT_160, 22, 2, 3 }, |
| { QUANT_192, 38, 4, 5 }, |
| { QUANT_256, 8, 0, 1 } |
| }}; |
| |
| /* See header for documentation. */ |
| unsigned int get_ise_sequence_bitcount( |
| unsigned int character_count, |
| quant_method quant_level |
| ) { |
| // Cope with out-of bounds values - input might be invalid |
| if (static_cast<size_t>(quant_level) >= ise_sizes.size()) |
| { |
| // Arbitrary large number that's more than an ASTC block can hold |
| return 1024; |
| } |
| |
| auto& entry = ise_sizes[quant_level]; |
| return (entry.scale * character_count + entry.round) / entry.divisor; |
| } |
| |
| /** |
| * @brief Write up to 8 bits at an arbitrary bit offset. |
| * |
| * The stored value is at most 8 bits, but can be stored at an offset of between 0 and 7 bits so may |
| * span two separate bytes in memory. |
| * |
| * @param value The value to write. |
| * @param bitcount The number of bits to write, starting from LSB. |
| * @param bitoffset The bit offset to store at, between 0 and 7. |
| * @param[in,out] ptr The data pointer to write to. |
| */ |
| static inline void write_bits( |
| unsigned int value, |
| unsigned int bitcount, |
| unsigned int bitoffset, |
| uint8_t ptr[2] |
| ) { |
| unsigned int mask = (1 << bitcount) - 1; |
| value &= mask; |
| ptr += bitoffset >> 3; |
| bitoffset &= 7; |
| value <<= bitoffset; |
| mask <<= bitoffset; |
| mask = ~mask; |
| |
| ptr[0] &= mask; |
| ptr[0] |= value; |
| ptr[1] &= mask >> 8; |
| ptr[1] |= value >> 8; |
| } |
| |
| /** |
| * @brief Read up to 8 bits at an arbitrary bit offset. |
| * |
| * The stored value is at most 8 bits, but can be stored at an offset of between 0 and 7 bits so may |
| * span two separate bytes in memory. |
| * |
| * @param bitcount The number of bits to read. |
| * @param bitoffset The bit offset to read from, between 0 and 7. |
| * @param[in,out] ptr The data pointer to read from. |
| * |
| * @return The read value. |
| */ |
| static inline unsigned int read_bits( |
| unsigned int bitcount, |
| unsigned int bitoffset, |
| const uint8_t* ptr |
| ) { |
| unsigned int mask = (1 << bitcount) - 1; |
| ptr += bitoffset >> 3; |
| bitoffset &= 7; |
| unsigned int value = ptr[0] | (ptr[1] << 8); |
| value >>= bitoffset; |
| value &= mask; |
| return value; |
| } |
| |
| /* See header for documentation. */ |
| void encode_ise( |
| quant_method quant_level, |
| unsigned int character_count, |
| const uint8_t* input_data, |
| uint8_t* output_data, |
| unsigned int bit_offset |
| ) { |
| promise(character_count > 0); |
| |
| unsigned int bits = btq_counts[quant_level].bits; |
| unsigned int trits = btq_counts[quant_level].trits; |
| unsigned int quints = btq_counts[quant_level].quints; |
| unsigned int mask = (1 << bits) - 1; |
| |
| // Write out trits and bits |
| if (trits) |
| { |
| unsigned int i = 0; |
| unsigned int full_trit_blocks = character_count / 5; |
| |
| for (unsigned int j = 0; j < full_trit_blocks; j++) |
| { |
| unsigned int i4 = input_data[i + 4] >> bits; |
| unsigned int i3 = input_data[i + 3] >> bits; |
| unsigned int i2 = input_data[i + 2] >> bits; |
| unsigned int i1 = input_data[i + 1] >> bits; |
| unsigned int i0 = input_data[i + 0] >> bits; |
| |
| uint8_t T = integer_of_trits[i4][i3][i2][i1][i0]; |
| |
| // The max size of a trit bit count is 6, so we can always safely |
| // pack a single MX value with the following 1 or 2 T bits. |
| uint8_t pack; |
| |
| // Element 0 + T0 + T1 |
| pack = (input_data[i++] & mask) | (((T >> 0) & 0x3) << bits); |
| write_bits(pack, bits + 2, bit_offset, output_data); |
| bit_offset += bits + 2; |
| |
| // Element 1 + T2 + T3 |
| pack = (input_data[i++] & mask) | (((T >> 2) & 0x3) << bits); |
| write_bits(pack, bits + 2, bit_offset, output_data); |
| bit_offset += bits + 2; |
| |
| // Element 2 + T4 |
| pack = (input_data[i++] & mask) | (((T >> 4) & 0x1) << bits); |
| write_bits(pack, bits + 1, bit_offset, output_data); |
| bit_offset += bits + 1; |
| |
| // Element 3 + T5 + T6 |
| pack = (input_data[i++] & mask) | (((T >> 5) & 0x3) << bits); |
| write_bits(pack, bits + 2, bit_offset, output_data); |
| bit_offset += bits + 2; |
| |
| // Element 4 + T7 |
| pack = (input_data[i++] & mask) | (((T >> 7) & 0x1) << bits); |
| write_bits(pack, bits + 1, bit_offset, output_data); |
| bit_offset += bits + 1; |
| } |
| |
| // Loop tail for a partial block |
| if (i != character_count) |
| { |
| // i4 cannot be present - we know the block is partial |
| // i0 must be present - we know the block isn't empty |
| unsigned int i4 = 0; |
| unsigned int i3 = i + 3 >= character_count ? 0 : input_data[i + 3] >> bits; |
| unsigned int i2 = i + 2 >= character_count ? 0 : input_data[i + 2] >> bits; |
| unsigned int i1 = i + 1 >= character_count ? 0 : input_data[i + 1] >> bits; |
| unsigned int i0 = input_data[i + 0] >> bits; |
| |
| uint8_t T = integer_of_trits[i4][i3][i2][i1][i0]; |
| |
| for (unsigned int j = 0; i < character_count; i++, j++) |
| { |
| // Truncated table as this iteration is always partital |
| static const uint8_t tbits[4] { 2, 2, 1, 2 }; |
| static const uint8_t tshift[4] { 0, 2, 4, 5 }; |
| |
| uint8_t pack = (input_data[i] & mask) | |
| (((T >> tshift[j]) & ((1 << tbits[j]) - 1)) << bits); |
| |
| write_bits(pack, bits + tbits[j], bit_offset, output_data); |
| bit_offset += bits + tbits[j]; |
| } |
| } |
| } |
| // Write out quints and bits |
| else if (quints) |
| { |
| unsigned int i = 0; |
| unsigned int full_quint_blocks = character_count / 3; |
| |
| for (unsigned int j = 0; j < full_quint_blocks; j++) |
| { |
| unsigned int i2 = input_data[i + 2] >> bits; |
| unsigned int i1 = input_data[i + 1] >> bits; |
| unsigned int i0 = input_data[i + 0] >> bits; |
| |
| uint8_t T = integer_of_quints[i2][i1][i0]; |
| |
| // The max size of a quint bit count is 5, so we can always safely |
| // pack a single M value with the following 2 or 3 T bits. |
| uint8_t pack; |
| |
| // Element 0 |
| pack = (input_data[i++] & mask) | (((T >> 0) & 0x7) << bits); |
| write_bits(pack, bits + 3, bit_offset, output_data); |
| bit_offset += bits + 3; |
| |
| // Element 1 |
| pack = (input_data[i++] & mask) | (((T >> 3) & 0x3) << bits); |
| write_bits(pack, bits + 2, bit_offset, output_data); |
| bit_offset += bits + 2; |
| |
| // Element 2 |
| pack = (input_data[i++] & mask) | (((T >> 5) & 0x3) << bits); |
| write_bits(pack, bits + 2, bit_offset, output_data); |
| bit_offset += bits + 2; |
| } |
| |
| // Loop tail for a partial block |
| if (i != character_count) |
| { |
| // i2 cannot be present - we know the block is partial |
| // i0 must be present - we know the block isn't empty |
| unsigned int i2 = 0; |
| unsigned int i1 = i + 1 >= character_count ? 0 : input_data[i + 1] >> bits; |
| unsigned int i0 = input_data[i + 0] >> bits; |
| |
| uint8_t T = integer_of_quints[i2][i1][i0]; |
| |
| for (unsigned int j = 0; i < character_count; i++, j++) |
| { |
| // Truncated table as this iteration is always partital |
| static const uint8_t tbits[2] { 3, 2 }; |
| static const uint8_t tshift[2] { 0, 3 }; |
| |
| uint8_t pack = (input_data[i] & mask) | |
| (((T >> tshift[j]) & ((1 << tbits[j]) - 1)) << bits); |
| |
| write_bits(pack, bits + tbits[j], bit_offset, output_data); |
| bit_offset += bits + tbits[j]; |
| } |
| } |
| } |
| // Write out just bits |
| else |
| { |
| promise(character_count > 0); |
| for (unsigned int i = 0; i < character_count; i++) |
| { |
| write_bits(input_data[i], bits, bit_offset, output_data); |
| bit_offset += bits; |
| } |
| } |
| } |
| |
| /* See header for documentation. */ |
| void decode_ise( |
| quant_method quant_level, |
| unsigned int character_count, |
| const uint8_t* input_data, |
| uint8_t* output_data, |
| unsigned int bit_offset |
| ) { |
| promise(character_count > 0); |
| |
| // Note: due to how the trit/quint-block unpacking is done in this function, we may write more |
| // temporary results than the number of outputs. The maximum actual number of results is 64 bit, |
| // but we keep 4 additional character_count of padding. |
| uint8_t results[68]; |
| uint8_t tq_blocks[22] { 0 }; // Trit-blocks or quint-blocks, must be zeroed |
| |
| unsigned int bits = btq_counts[quant_level].bits; |
| unsigned int trits = btq_counts[quant_level].trits; |
| unsigned int quints = btq_counts[quant_level].quints; |
| |
| unsigned int lcounter = 0; |
| unsigned int hcounter = 0; |
| |
| // Collect bits for each element, as well as bits for any trit-blocks and quint-blocks. |
| for (unsigned int i = 0; i < character_count; i++) |
| { |
| results[i] = static_cast<uint8_t>(read_bits(bits, bit_offset, input_data)); |
| bit_offset += bits; |
| |
| if (trits) |
| { |
| static const unsigned int bits_to_read[5] { 2, 2, 1, 2, 1 }; |
| static const unsigned int block_shift[5] { 0, 2, 4, 5, 7 }; |
| static const unsigned int next_lcounter[5] { 1, 2, 3, 4, 0 }; |
| static const unsigned int hcounter_incr[5] { 0, 0, 0, 0, 1 }; |
| unsigned int tdata = read_bits(bits_to_read[lcounter], bit_offset, input_data); |
| bit_offset += bits_to_read[lcounter]; |
| tq_blocks[hcounter] |= tdata << block_shift[lcounter]; |
| hcounter += hcounter_incr[lcounter]; |
| lcounter = next_lcounter[lcounter]; |
| } |
| |
| if (quints) |
| { |
| static const unsigned int bits_to_read[3] { 3, 2, 2 }; |
| static const unsigned int block_shift[3] { 0, 3, 5 }; |
| static const unsigned int next_lcounter[3] { 1, 2, 0 }; |
| static const unsigned int hcounter_incr[3] { 0, 0, 1 }; |
| unsigned int tdata = read_bits(bits_to_read[lcounter], bit_offset, input_data); |
| bit_offset += bits_to_read[lcounter]; |
| tq_blocks[hcounter] |= tdata << block_shift[lcounter]; |
| hcounter += hcounter_incr[lcounter]; |
| lcounter = next_lcounter[lcounter]; |
| } |
| } |
| |
| // Unpack trit-blocks or quint-blocks as needed |
| if (trits) |
| { |
| unsigned int trit_blocks = (character_count + 4) / 5; |
| for (unsigned int i = 0; i < trit_blocks; i++) |
| { |
| const uint8_t *tritptr = trits_of_integer[tq_blocks[i]]; |
| results[5 * i ] |= tritptr[0] << bits; |
| results[5 * i + 1] |= tritptr[1] << bits; |
| results[5 * i + 2] |= tritptr[2] << bits; |
| results[5 * i + 3] |= tritptr[3] << bits; |
| results[5 * i + 4] |= tritptr[4] << bits; |
| } |
| } |
| |
| if (quints) |
| { |
| unsigned int quint_blocks = (character_count + 2) / 3; |
| for (unsigned int i = 0; i < quint_blocks; i++) |
| { |
| const uint8_t *quintptr = quints_of_integer[tq_blocks[i]]; |
| results[3 * i ] |= quintptr[0] << bits; |
| results[3 * i + 1] |= quintptr[1] << bits; |
| results[3 * i + 2] |= quintptr[2] << bits; |
| } |
| } |
| |
| for (unsigned int i = 0; i < character_count; i++) |
| { |
| output_data[i] = results[i]; |
| } |
| } |
