Method encode

arch/agat/encoder.cc:61–103

public:
    std::unique_ptr<Fluxmap> encode(const LogicalTrackLayout& ltl,
        const std::vector<std::shared_ptr<const Sector>>& sectors,
        const Image& image) override
    {
        double clockRateUs = _config.target_clock_period_us() / 2.0;
        int bitsPerRevolution =
            (_config.target_rotational_period_ms() * 1000.0) / clockRateUs;
        _bits.resize(bitsPerRevolution);
        _cursor = 0;

        writeFillerRawBytes(_config.post_index_gap_bytes(), 0xaaaa);

        for (const auto& sector : sectors)
        {
            /* Header */

            writeFillerRawBytes(_config.pre_sector_gap_bytes(), 0xaaaa);
            writeRawBits(SECTOR_ID, 64);
            writeByte(0x5a);
            writeByte((sector->logicalCylinder << 1) | sector->logicalHead);
            writeByte(sector->logicalSector);
            writeByte(0x5a);

            /* Data */

            writeFillerRawBytes(_config.pre_data_gap_bytes(), 0xaaaa);
            auto data = sector->data.slice(0, AGAT_SECTOR_SIZE);
            writeRawBits(DATA_ID, 64);
            writeBytes(data);
            writeByte(agatChecksum(data));
            writeByte(0x5a);
        }

        if (_cursor >= _bits.size())
            error("track data overrun");
        fillBitmapTo(_bits, _cursor, _bits.size(), {true, false});

        auto fluxmap = std::make_unique<Fluxmap>();
        fluxmap->appendBits(_bits,
            calculatePhysicalClockPeriod(_config.target_clock_period_us() * 1e3,
                _config.target_rotational_period_ms() * 1e6));
        return fluxmap;
    }

private:
    const AgatEncoderProto& _config;