Move the Kryoflux and Catweasel stuff into external.

lib/external/kryoflux.cc

@@ -0,0 +1,262 @@
+#include "lib/core/globals.h"
+#include "lib/data/fluxmap.h"
+#include "lib/external/kryoflux.h"
+#include "protocol.h"
+#include <fstream>
+#include <sys/types.h>
+#include <dirent.h>
+#include <filesystem>
+
+#define MCLK_HZ (((18432000.0 * 73.0) / 14.0) / 2.0)
+#define SCLK_HZ (MCLK_HZ / 2)
+#define ICLK_HZ (MCLK_HZ / 16)
+
+#define TICKS_PER_SCLK (TICK_FREQUENCY / SCLK_HZ)
+
+static bool has_suffix(const std::string& haystack, const std::string& needle)
+{
+    if (needle.length() > haystack.length())
+        return false;
+
+    return haystack.compare(haystack.length() - needle.length(),
+               needle.length(),
+               needle) == 0;
+}
+
+std::unique_ptr<Fluxmap> readStream(
+    std::string dir, unsigned track, unsigned side)
+{
+    std::string suffix = fmt::format("{:02}.{}.raw", track, side);
+
+    FILE* fp = fopen(dir.c_str(), "r");
+    if (fp)
+    {
+        fclose(fp);
+        int i = dir.find_last_of("/\\");
+        dir = dir.substr(0, i);
+    }
+
+    DIR* dirp = opendir(dir.c_str());
+    if (!dirp)
+        error("cannot access path '{}'", dir);
+
+    std::string filename;
+    for (;;)
+    {
+        struct dirent* de = readdir(dirp);
+        if (!de)
+            break;
+
+        if (has_suffix(de->d_name, suffix))
+        {
+            if (!filename.empty())
+                error("data is ambiguous --- multiple files end in {}", suffix);
+            filename = fmt::format("{}/{}", dir, de->d_name);
+        }
+    }
+    closedir(dirp);
+
+    if (filename.empty())
+        error("failed to find track {} side {} in {}", track, side, dir);
+
+    return readStream(filename);
+}
+
+std::unique_ptr<Fluxmap> readStream(const std::string& filename)
+{
+    std::ifstream f(filename, std::ios::in | std::ios::binary);
+    if (!f.is_open())
+        error("cannot open input file '{}'", filename);
+
+    Bytes bytes;
+    ByteWriter bw(bytes);
+    bw.append(f);
+
+    return readStream(bytes);
+}
+
+std::unique_ptr<Fluxmap> readStream(const Bytes& bytes)
+{
+    ByteReader br(bytes);
+
+    /* Pass 1: scan the stream looking for index marks. */
+
+    std::set<uint32_t> indexmarks;
+    br.seek(0);
+    while (!br.eof())
+    {
+        uint8_t b = br.read_8();
+        unsigned len = 0;
+        switch (b)
+        {
+            case 0x0d: /* OOB block */
+            {
+                int blocktype = br.read_8();
+                len = br.read_le16();
+                if (br.eof())
+                    goto finished_pass_1;
+
+                if (blocktype == 0x02)
+                {
+                    /* index data, sent asynchronously */
+                    uint32_t streampos = br.read_le32();
+                    indexmarks.insert(streampos);
+                    len -= 4;
+                }
+                break;
+            }
+
+            default:
+            {
+                if ((b >= 0x00) && (b <= 0x07))
+                {
+                    /* Flux2: double byte value */
+                    len = 1;
+                }
+                else if (b == 0x08)
+                {
+                    /* Nop1: do nothing */
+                    len = 0;
+                }
+                else if (b == 0x09)
+                {
+                    /* Nop2: skip one byte */
+                    len = 1;
+                }
+                else if (b == 0x0a)
+                {
+                    /* Nop3: skip two bytes */
+                    len = 2;
+                }
+                else if (b == 0x0b)
+                {
+                    /* Ovl16: the next block is 0x10000 sclks longer than
+                     * normal. */
+                    len = 0;
+                }
+                else if (b == 0x0c)
+                {
+                    /* Flux3: triple byte value */
+                    len = 2;
+                }
+                else if ((b >= 0x0e) && (b <= 0xff))
+                {
+                    /* Flux1: single byte value */
+                    len = 0;
+                }
+                else
+                    error("unknown stream block byte 0x{:02x} at 0x{:08x}",
+                        b,
+                        (uint64_t)br.pos - 1);
+            }
+        }
+
+        br.skip(len);
+    }
+finished_pass_1:
+
+    /* Pass 2: actually read the data. */
+
+    std::unique_ptr<Fluxmap> fluxmap(new Fluxmap);
+    int streamdelta = 0;
+    auto writeFlux = [&](uint32_t sclk)
+    {
+        const auto& nextindex = indexmarks.begin();
+        if (nextindex != indexmarks.end())
+        {
+            uint32_t nextindexpos = *nextindex + streamdelta;
+            if (br.pos >= nextindexpos)
+            {
+                fluxmap->appendIndex();
+                indexmarks.erase(nextindex);
+            }
+        }
+        int ticks = (double)sclk * TICKS_PER_SCLK;
+        fluxmap->appendInterval(ticks);
+        fluxmap->appendPulse();
+    };
+
+    uint32_t extrasclks = 0;
+    br.seek(0);
+    while (!br.eof())
+    {
+        unsigned b = br.read_8();
+        switch (b)
+        {
+            case 0x0d: /* OOB block */
+            {
+                int blocktype = br.read_8();
+                uint16_t blocklen = br.read_le16();
+                if (br.eof())
+                    goto finished_pass_2;
+
+                switch (blocktype)
+                {
+                    case 0x01: /* streaminfo */
+                    {
+                        uint32_t blockpos = br.pos - 3;
+                        streamdelta = blockpos - br.read_le32();
+                        blocklen -= 4;
+                        break;
+                    }
+                }
+
+                br.skip(blocklen);
+                break;
+            }
+
+            default:
+            {
+                if ((b >= 0x00) && (b <= 0x07))
+                {
+                    /* Flux2: double byte value */
+                    b = (b << 8) | br.read_8();
+                    writeFlux(extrasclks + b);
+                    extrasclks = 0;
+                }
+                else if (b == 0x08)
+                {
+                    /* Nop1: do nothing */
+                }
+                else if (b == 0x09)
+                {
+                    /* Nop2: skip one byte */
+                    br.skip(1);
+                }
+                else if (b == 0x0a)
+                {
+                    /* Nop3: skip two bytes */
+                    br.skip(2);
+                }
+                else if (b == 0x0b)
+                {
+                    /* Ovl16: the next block is 0x10000 sclks longer than
+                     * normal. */
+                    extrasclks += 0x10000;
+                }
+                else if (b == 0x0c)
+                {
+                    /* Flux3: triple byte value */
+                    int ticks = br.read_be16(); /* yes, really big-endian */
+                    writeFlux(extrasclks + ticks);
+                    extrasclks = 0;
+                }
+                else if ((b >= 0x0e) && (b <= 0xff))
+                {
+                    /* Flux1: single byte value */
+                    writeFlux(extrasclks + b);
+                    extrasclks = 0;
+                }
+                else
+                    error("unknown stream block byte 0x{:02x} at 0x{:08x}",
+                        b,
+                        (uint64_t)br.pos - 1);
+            }
+        }
+    }
+
+finished_pass_2:
+    if (!br.eof())
+        error("I/O error reading stream");
+    return fluxmap;
+}