// infuncmp.c

// Decodes uncompressed blocks

#include "inflate.h"
#include "infmacro.h"


// Returns whether there are >= n valid bits in the bit buffer
#define ASSERT_BITS_IN_BIT_BUFFER(n) (context->bitcount + 16 >= (n))


static int twoBytesToInt(byte a, byte b)
{
    return (((int) a) & 255) | ((((int) b) & 255) << 8);
}


static void dumpBits(t_decoder_context *context, int n)
{
    context->bitbuf >>= n;
    context->bitcount -= n;
}


// retrieve n bits from the bit buffer, and dump them when done
// n can be up to 16
static int getBits(t_decoder_context *context, int n)
{
    int result;

    context->bitcount -= n;
    result = (context->bitbuf & g_BitMask[n]);
    context->bitbuf >>= n;

    return result;
}


BOOL decodeUncompressedBlock(t_decoder_context *context, BOOL *end_of_block)
{
    unsigned int unc_len, complement;

    *end_of_block = FALSE;

    if (context->state == STATE_DECODING_UNCOMPRESSED)
    {
        unc_len = context->state_loop_counter;
    }
    else
    {
        int i;

        if (context->state == STATE_UNCOMPRESSED_ALIGNING)
        {
            // Right now we have between 0 and 32 bits in bitbuf

            // However, we must flush to a byte boundary
            if ((context->bitcount & 7) != 0)
            {
                int result;

                result = getBits(context, (context->bitcount & 7));

                // Since this is supposed to be padding, we should read all zeroes,
                // however, it's not really specified in the spec that they have to
                // be zeroes, so don't count this as an error
            }

            // Now we have exactly 0, 8, 16, 24, or 32 bits in the bit buffer
            context->state = STATE_UNCOMPRESSED_1;
        }

        // Now we need to read 4 bytes from the input - however, some of these bytes may
        // be inside our bit buffer, so take them from there first
        for (i = 0; i < 4; i++)
        {
            if (context->state == STATE_UNCOMPRESSED_1 + i)
            {
                if (ASSERT_BITS_IN_BIT_BUFFER(8))
                {
                    context->unc_buffer[i] = (byte) ((context->bitbuf) & 255);
                    context->bitbuf >>= 8;
                    context->bitcount -= 8;
                }
                else
                {
                    if (INPUT_EOF())
                        return TRUE;

                    context->unc_buffer[i] = *context->input_curpos++;
                }

                context->state++;
            }
        }

        unc_len = twoBytesToInt(context->unc_buffer[0], context->unc_buffer[1]);
        complement = twoBytesToInt(context->unc_buffer[2], context->unc_buffer[3]);

        // make sure complement matches
        if ((unsigned short) unc_len != (unsigned short) (~complement))
            return FALSE; // error!
    }

    // BUGBUG Make this into a memory copy loop for speed!
    while (unc_len > 0 && context->input_curpos < context->end_input_buffer && context->output_curpos < context->end_output_buffer)
    {
        unc_len--;
        *context->output_curpos++ = context->window[context->bufpos++] = *context->input_curpos++;
        context->bufpos &= WINDOW_MASK;
    }

    // More bytes left to compress in this block?
    if (unc_len != 0)
    {
        context->state = STATE_DECODING_UNCOMPRESSED;
        context->state_loop_counter = unc_len;
    }
    else
    {
        // Done with this block, need to re-init bit buffer for next block
        context->state = STATE_READING_BFINAL_NEED_TO_INIT_BITBUF;
        *end_of_block = TRUE;
    }

    return TRUE;
}