#include <stdio.h>
#include <stdlib.h>

void spice_error(const char *msg, ...) { fprintf(stderr, "Ooops\n"); }

#define G_LIKELY(expr) (__builtin_expect ((_Bool)((expr)), 1))

#define spice_assert(x) do {                  \
    if G_LIKELY(x) { } else {                           \
        spice_error("assertion `%s' failed", #x);       \
    }                                                   \
} while(0);

/* bppmask[i] contains i ones as lsb-s */
static const unsigned int bppmask[33] = {
    0x00000000, /* [0] */
    0x00000001, 0x00000003, 0x00000007, 0x0000000f,
    0x0000001f, 0x0000003f, 0x0000007f, 0x000000ff,
    0x000001ff, 0x000003ff, 0x000007ff, 0x00000fff,
    0x00001fff, 0x00003fff, 0x00007fff, 0x0000ffff,
    0x0001ffff, 0x0003ffff, 0x0007ffff, 0x000fffff,
    0x001fffff, 0x003fffff, 0x007fffff, 0x00ffffff,
    0x01ffffff, 0x03ffffff, 0x07ffffff, 0x0fffffff,
    0x1fffffff, 0x3fffffff, 0x7fffffff, 0xffffffff /* [32] */
};

typedef unsigned uint32_t;

typedef enum {
    QUIC_IMAGE_TYPE_INVALID,
    QUIC_IMAGE_TYPE_GRAY,
    QUIC_IMAGE_TYPE_RGB16,
    QUIC_IMAGE_TYPE_RGB24,
    QUIC_IMAGE_TYPE_RGB32,
    QUIC_IMAGE_TYPE_RGBA
} QuicImageType;

typedef struct Encoder {
    void *usr;
    QuicImageType type;
    unsigned int width;
    unsigned int height;

    unsigned int n_buckets_8bpc;
    unsigned int n_buckets_5bpc;

    unsigned int io_available_bits;
    uint32_t io_word;
    uint32_t io_next_word;
    uint32_t *io_now;
    uint32_t *io_end;
    uint32_t io_words_count;

    int rows_completed;
} Encoder;

#define write_io_word(encoder) 0


static inline void encode(Encoder *encoder, unsigned int word, unsigned int len)
{
    int delta;

    if ((delta = ((int)encoder->io_available_bits - len)) >= 0) {
        encoder->io_available_bits = delta;
        encoder->io_word |= word << encoder->io_available_bits;
        return;
    }
    delta = -delta;
    encoder->io_word |= word >> delta;
    write_io_word(encoder);
    encoder->io_available_bits = 32 - delta;
    encoder->io_word = word << encoder->io_available_bits;

}


int main(int argc, char **argv)
{
    unsigned n = atoi(argv[1]);
    Encoder encoder = { 0 };
    encoder.io_available_bits = 16;
    encoder.io_word = 0;
    for (unsigned i = 0; i < n; i++)
        for (unsigned j = 0; j < 1000000; j++)
            encode(&encoder, bppmask[(j%32)|1], (j%32) | 1);
    fprintf(stderr, "Rows completed: %d\n", encoder.rows_completed);
}