samerand/xform.c

#include <stdio.h>
#include <stdint.h>

// bit 0 = input[1792] & (1 << 31)
// bit 1 = input[1792] & (1 << 30)
// bit 2 = input[1536] & (1 << 31)
// bit 3 = input[1536] & (1 << 30)
// bit 4 = input[1280] & (1 << 31)
// bit 5 = input[1280] & (1 << 30)
// bit 6 = input[1024] & (1 << 31)
// bit 7 = input[1024] & (1 << 30)
// bit 8 = input[768]  & (1 << 31)
// bit 9 = input[768]  & (1 << 30)
// bit 10 = input[512] & (1 << 31)
// bit 11 = input[512] & (1 << 30)
// bit 12 = input[256] & (1 << 31)
// bit 13 = input[256] & (1 << 30)
// bit 14 = input[0]   & (1 << 31)
// bit 15 = input[0]   & (1 << 30)

uint32_t polynomial = 0x04C11DB7;
static uint32_t rand_step(uint32_t input)
{
    int i;
    uint32_t output = input + 1;
    for (i = 0; i < 32; i++)
    {
        if (output & 0x80000000)
            output ^= polynomial;
        output = output << 1;
    }
    return output;
}

static uint8_t get_bit(uint32_t *field, int offset)
{
    // printf("offset&31: %d\n", offset & 31);
    // printf("offset/sizeof(*field): %d\n", offset >> 5);
    return !!(field[offset >> 5] & (1 << (offset & 31)));
}

static uint8_t set_bit(uint32_t *field, int offset)
{
    field[offset >> 5] |= (1 << (offset & 31));
}

static uint8_t clear_bit(uint32_t *field, int offset)
{
    field[offset >> 5] &= ~(1 << (offset & 31));
}

static uint8_t reverse_u8(uint8_t b)
{
    b = (b & 0xF0) >> 4 | (b & 0x0F) << 4;
    b = (b & 0xCC) >> 2 | (b & 0x33) << 2;
    b = (b & 0xAA) >> 1 | (b & 0x55) << 1;
    return b;
}

static uint16_t reverse_u16(uint16_t nonreversed)
{
    uint16_t reversed = 0;

    for (uint16_t i = 0; i < 16; i++)
    {
        reversed |= (nonreversed >> (16 - i - 1) & 1) << i;
    }

    return reversed;
}

int main(int argc, char **argv)
{
    int i;
    // uint32_t test_1[] = {1};
    // uint32_t test_2[] = {0, 1};
    // uint32_t test_3[] = {2, 0};
    // uint32_t test_4[] = {1, 0x10, 0, 8};

    // for (i = 0; i < sizeof(test_1)*8; i++) {
    //     if (get_bit(test_1, i))
    //         printf("test_1: bit %d set\n", i);
    // }
    // for (i = 0; i < sizeof(test_2)*8; i++) {
    //     if (get_bit(test_2, i))
    //         printf("test_2: bit %d set\n", i);
    // }
    // for (i = 0; i < sizeof(test_3)*8; i++) {
    //     if (get_bit(test_3, i))
    //         printf("test_3: bit %d set\n", i);
    // }
    // for (i = 0; i < sizeof(test_4)*8; i++) {
    //     if (get_bit(test_4, i))
    //         printf("test_4: bit %d set\n", i);
    // }

    uint32_t input[256];
    uint32_t output[256] = {};

    uint32_t init = 0;
    for (i = 0; i < sizeof(input) / 4; i++)
    {
        init = rand_step(init);
        input[i] = init;
    }
    // print_hex(input, sizeof(input), 0);
    // return;

    uint16_t *o16 = (uint16_t *)output;
    uint8_t *i8 = (uint8_t *)input;
    for (i = 0; i < sizeof(input) / 2; i++)
    {
        int j;
        for (j = 0; j < 16; j++)
        {
            // printf("o16[%d] |= (!!(i8[1792+%d] & (1 << %d)) << 0;\n", i, i, 2*(15-j)+1);
            o16[i] |= (!!(i8[1792+i] & (1 << 2*(15-j)+1))) << 0;
            o16[i] |= (!!(i8[1792+i] & (1 << 2*(15-j)+0))) << 1;
            o16[i] |= (!!(i8[1536+i] & (1 << 2*(15-j)+1))) << 2;
            o16[i] |= (!!(i8[1536+i] & (1 << 2*(15-j)+0))) << 3;
            o16[i] |= (!!(i8[1280+i] & (1 << 2*(15-j)+1))) << 4;
            o16[i] |= (!!(i8[1280+i] & (1 << 2*(15-j)+0))) << 5;
            o16[i] |= (!!(i8[1024+i] & (1 << 2*(15-j)+1))) << 6;
            o16[i] |= (!!(i8[1024+i] & (1 << 2*(15-j)+0))) << 7;
            o16[i] |= (!!(i8[768+i] & (1 << 2*(15-j)+1))) << 8;
            o16[i] |= (!!(i8[768+i] & (1 << 2*(15-j)+0))) << 9;
            o16[i] |= (!!(i8[512+i] & (1 << 2*(15-j)+1))) << 10;
            o16[i] |= (!!(i8[512+i] & (1 << 2*(15-j)+0))) << 11;
            o16[i] |= (!!(i8[256+i] & (1 << 2*(15-j)+1))) << 12;
            o16[i] |= (!!(i8[256+i] & (1 << 2*(15-j)+0))) << 13;
            o16[i] |= (!!(i8[0+i] & (1 << 2*(15-j)+1))) << 14;
            o16[i] |= (!!(i8[0+i] & (1 << 2*(15-j)+0))) << 15;
//             o16[0] = i
//             if (get_bit(input, i * 16 + j))
//                 set_bit(output, j * 256 + i);
//             else
//                 clear_bit(output, j * 256 + i);
        }
    }

    // uint8_t *o8 = (uint8_t *)output;
    // for (i = 0; i < sizeof(output)/4; i++)
    //     o8[i] = reverse_u8(o8[i]);

    // for (i = 0; i < sizeof(output)/4; i++)
    //     o16[i] = reverse_u16(o16[i]);

    print_hex(output, sizeof(output), 0);
    // for (i = 0; i < 2047; i++)
        // printf("00000000\n");

    return 0;
}