
#ifndef __BITS_CC__
#define __BITS_CC__

#include <algorithm>
#include <stdexcept>
#include <qpdf/QTC.hh>
#include <qpdf/Pipeline.hh>
#include <qpdf/QUtil.hh>

// These functions may be run at places where the function call
// overhead from test coverage testing would be too high.  Therefore,
// we make the test coverage cases conditional upon a preprocessor
// symbol.  BitStream.cc includes this file without defining the
// symbol, and the specially designed test code that fully exercises
// this code includes with the symbol defined.

#ifdef BITS_READ
static unsigned long long
read_bits(unsigned char const*& p, size_t& bit_offset,
	  size_t& bits_available, size_t bits_wanted)
{
    // View p as a stream of bits:

    // 76543210 76543210 ....

    // bit_offset is the bit number within the first byte that marks
    // the first bit that we would read.

    if (bits_wanted > bits_available)
    {
	throw std::runtime_error(
            "overflow reading bit stream: wanted = " +
            QUtil::uint_to_string(bits_wanted) + "; available = " +
            QUtil::uint_to_string(bits_available));
    }
    if (bits_wanted > 32)
    {
	throw std::out_of_range("read_bits: too many bits requested");
    }

    unsigned long result = 0;
#ifdef BITS_TESTING
    if (bits_wanted == 0)
    {
	QTC::TC("libtests", "bits zero bits wanted");
    }
#endif
    while (bits_wanted > 0)
    {
	// Grab bits from the first byte clearing anything before
	// bit_offset.
	unsigned char byte = static_cast<unsigned char>(
            *p & ((1U << (bit_offset + 1U)) - 1U));

	// There are bit_offset + 1 bits available in the first byte.
	size_t to_copy = std::min(bits_wanted, bit_offset + 1);
	size_t leftover = (bit_offset + 1) - to_copy;

#ifdef BITS_TESTING
	QTC::TC("libtests", "bits bit_offset",
		((bit_offset == 0) ? 0 :
		 (bit_offset == 7) ? 1 :
		 2));
	QTC::TC("libtests", "bits leftover", (leftover > 0) ? 1 : 0);
#endif

	// Right shift so that all the bits we want are right justified.
	byte = static_cast<unsigned char>(byte >> leftover);

	// Copy the bits into result
	result <<= to_copy;
	result |= byte;

	// Update pointers
	if (leftover)
	{
	    bit_offset = leftover - 1;
	}
	else
	{
	    bit_offset = 7;
	    ++p;
	}
	bits_wanted -= to_copy;
	bits_available -= to_copy;

#ifdef BITS_TESTING
	QTC::TC("libtests", "bits iterations",
		((bits_wanted > 8) ? 0 :
		 (bits_wanted > 0) ? 1 :
		 2));
#endif
    }

    return result;
}
#endif

#ifdef BITS_WRITE
static void
write_bits(unsigned char& ch, size_t& bit_offset,
	   unsigned long long val, size_t bits, Pipeline* pipeline)
{
    if (bits > 32)
    {
	throw std::out_of_range("write_bits: too many bits requested");
    }

    // bit_offset + 1 is the number of bits left in ch
#ifdef BITS_TESTING
    if (bits == 0)
    {
	QTC::TC("libtests", "bits write zero bits");
    }
#endif
    while (bits > 0)
    {
	size_t bits_to_write = std::min(bits, bit_offset + 1);
	unsigned char newval = static_cast<unsigned char>(
	    (val >> (bits - bits_to_write)) & ((1U << bits_to_write) - 1));
	size_t bits_left_in_ch = bit_offset + 1 - bits_to_write;
	newval = static_cast<unsigned char>(newval << bits_left_in_ch);
	ch |= newval;
	if (bits_left_in_ch == 0)
	{
#ifdef BITS_TESTING
	    QTC::TC("libtests", "bits write pipeline");
#endif
	    pipeline->write(&ch, 1);
	    bit_offset = 7;
	    ch = 0;
	}
	else
	{
#ifdef BITS_TESTING
	    QTC::TC("libtests", "bits write leftover");
#endif
	    bit_offset -= bits_to_write;
	}
	bits -= bits_to_write;
#ifdef BITS_TESTING
	QTC::TC("libtests", "bits write iterations",
		((bits > 8) ? 0 :
		 (bits > 0) ? 1 :
		 2));
#endif
    }

}
#endif


#endif // __BITS_CC__
