boytacean 0.12.0

A Game Boy emulator that is written in Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>
#include <stdlib.h>
#include <unistd.h>
#include <assert.h>

static void opts(uint8_t byte, uint8_t *options)
{
    *(options++) = byte | ((byte << 1) & 0xff);
    *(options++) = byte & (byte << 1);
    *(options++) = byte | ((byte >> 1) & 0xff);
    *(options++) = byte & (byte >> 1);
}

void write_all(FILE *stream, const void *buf, size_t count)
{
    size_t written = 0;
    while (written < count)
    {
        size_t result = fwrite((const char *)buf + written, 1, count - written, stream);
        if (result <= 0)
        {
            perror("fwrite");
            exit(EXIT_FAILURE);
        }
        written += result;
    }
}

int main(int argc, char *argv[])
{
    if (argc < 3)
    {
        fprintf(stderr, "Usage: %s <input_file> <output_file>\n", argv[0]);
        return EXIT_FAILURE;
    }

    FILE *input = fopen(argv[1], "rb");
    if (!input)
    {
        perror("fopen input");
        return EXIT_FAILURE;
    }

    FILE *output = fopen(argv[2], "wb");
    if (!output)
    {
        perror("fopen output");
        fclose(input);
        return EXIT_FAILURE;
    }

    static uint8_t source[0x4000];
    size_t size = fread(source, 1, sizeof(source), input);
    fclose(input);
    unsigned pos = 0;
    assert(size <= 0x4000);

    // Remove trailing zeroes, as the GB memory is zeroed
    // during the Boot ROM initialization
    while (size && source[size - 1] == 0)
    {
        size--;
    }

    uint8_t literals[8];
    size_t literals_size = 0;
    unsigned bits = 0;
    unsigned control = 0;
    unsigned prev[2] = {-1, -1}; // Unsigned to allow "not set" values

    while (true)
    {
        uint8_t byte = 0;
        if (pos == size)
        {
            if (bits == 0)
                break;
        }
        else
        {
            byte = source[pos++];
        }

        if (byte == prev[0] || byte == prev[1])
        {
            bits += 2;
            control <<= 1;
            control |= 1;
            control <<= 1;
            if (byte == prev[1])
            {
                control |= 1;
            }
        }
        else
        {
            bits += 2;
            control <<= 2;
            uint8_t options[4];
            opts(prev[1], options);
            bool found = false;
            for (unsigned i = 0; i < 4; i++)
            {
                if (options[i] == byte)
                {
                    // 01 = modify
                    control |= 1;

                    bits += 2;
                    control <<= 2;
                    control |= i;
                    found = true;
                    break;
                }
            }
            if (!found)
            {
                literals[literals_size++] = byte;
            }
        }

        prev[0] = prev[1];
        prev[1] = byte;
        if (bits >= 8)
        {
            uint8_t outctl = control >> (bits - 8);
            assert(outctl != 1); // 1 is reserved as the end byte
            write_all(output, &outctl, 1);
            write_all(output, literals, literals_size);
            bits -= 8;
            control &= (1 << bits) - 1;
            literals_size = 0;
        }
    }
    uint8_t end_byte = 1;
    write_all(output, &end_byte, 1);
    fclose(output);

    return 0;
}