/*

 * Copyright (c) 2021, Hunter Salyer <thefalsehonesty@gmail.com>

 * Copyright (c) 2022, Gregory Bertilson <zaggy1024@gmail.com>

 *

 * SPDX-License-Identifier: BSD-2-Clause

 */

#include <AK/BuiltinWrappers.h>

#include <AK/Debug.h>

#include <AK/Endian.h>

#include "BooleanDecoder.h"

namespace Gfx {

// 9.2.1 Initialization process for Boolean decoder

ErrorOr<BooleanDecoder> BooleanDecoder::initialize(ReadonlyBytes data)

{

    if (data.size() == 0)

        return Error::from_string_literal("Size of decoder range cannot be zero");

    // NOTE: This implementation is shared between VP8 and VP9. Therefore, we do not check the

    //       marker bit at the start of the range decode that is required in the VP9 specification.

    //       This is instead handled by the function that instantiates all range decoders for the

    //       VP9 decoder.

    // NOTE: As noted below in fill_reservoir(), we read in multi-byte-sized chunks,

    //       so here we will deviate from the standard to count in bytes rather than bits.

    return BooleanDecoder { data.data(), data.size() };

}

// Instead of filling the value field one bit at a time as the spec suggests, we store the

// data to be read in a reservoir of greater than one byte. This allows us to read out data

// for the entire reservoir at once, avoiding a lot of branch misses in read_bool().

void BooleanDecoder::fill_reservoir()

{

    if (m_value_bits_left > 8)

        return;

    // Defer errors until the decode is finalized, so the work to check for errors and return them only has

    // to be done once. Not refilling the reservoir here will only result in reading out all zeroes until

    // the range decode is finished.

    if (m_bytes_left == 0) {

        dbgln_if(VPX_DEBUG, "BooleanDecoder has read past the end of the coded range");

        m_overread = true;

        return;

    }

    // Read the data into the most significant bits of a variable.

    auto read_size = min<size_t>(reserve_bytes, m_bytes_left);

    ValueType read_value = 0;

    memcpy(&read_value, m_data, read_size);

    read_value = AK::convert_between_host_and_big_endian(read_value);

    // Skip the number of bytes read in the data.

    m_data += read_size;

    m_bytes_left -= read_size;

    // Shift the value that was read to be less significant than the least significant bit available in the reservoir.

    read_value >>= m_value_bits_left;

    m_value |= read_value;

    m_value_bits_left += read_size * 8;

}

// 9.2.2 Boolean decoding process

bool BooleanDecoder::read_bool(u8 probability)

{

    auto split = 1u + (((m_range - 1u) * probability) >> 8u);

    // The actual value being read resides in the most significant 8 bits

    // of the value field, so we shift the split into that range for comparison.

    auto split_shifted = static_cast<ValueType>(split) << reserve_bits;

    bool return_bool;

    if (m_value < split_shifted) {

        m_range = split;

        return_bool = false;

    } else {

        m_range -= split;

        m_value -= split_shifted;

        return_bool = true;

    }

    u8 bits_to_shift_into_range = count_leading_zeroes(m_range) - ((sizeof(m_range) - 1) * 8);

    m_range <<= bits_to_shift_into_range;

    m_value <<= bits_to_shift_into_range;

    m_value_bits_left -= bits_to_shift_into_range;

    fill_reservoir();

    return return_bool;

}

// 9.2.4 Parsing process for read_literal

u8 BooleanDecoder::read_literal(u8 bits)

{

    u8 return_value = 0;

    for (size_t i = 0; i < bits; i++) {

        return_value = (2 * return_value) + read_bool(128);

    }

    return return_value;

}

ErrorOr<void> BooleanDecoder::finish_decode()

{

    if (m_overread)

        return Error::from_string_literal("Range decoder was read past the end of its data");

#if VPX_DEBUG

    // 9.2.3 Exit process for Boolean decoder

    //

    // This process is invoked when the function exit_bool( ) is called from the syntax structure.

    //

    // The padding syntax element is read using the f(BoolMaxBits) parsing process.

    //

    // It is a requirement of bitstream conformance that padding is equal to 0.

    //

    // NOTE: This requirement holds up for all of our WebP lossy test inputs, as well.

    bool padding_good = true;

    if (m_value != 0)

        padding_good = false;

    while (m_bytes_left > 0) {

        if (*m_data != 0)

            padding_good = false;

        m_data++;

        m_bytes_left--;

    }

    if (!padding_good)

        return Error::from_string_literal("Range decoder padding was non-zero");

#endif

    return {};

}

}