Method writeSector

arch/c64/encoder.cc:207–305

private:
    void writeSector(std::vector<bool>& bits,
        unsigned& cursor,
        std::shared_ptr<const Sector> sector) const
    {
        /* Source: http://www.unusedino.de/ec64/technical/formats/g64.html
         * 1. Header sync       FF FF FF FF FF (40 'on' bits, not GCR)
         * 2. Header info       52 54 B5 29 4B 7A 5E 95 55 55 (10 GCR bytes)
         * 3. Header gap        55 55 55 55 55 55 55 55 55 (9 bytes, never read)
         * 4. Data sync         FF FF FF FF FF (40 'on' bits, not GCR)
         * 5. Data block        55...4A (325 GCR bytes)
         * 6. Inter-sector gap  55 55 55 55...55 55 (4 to 12 bytes, never read)
         * 1. Header sync       (SYNC for the next sector)
         */
        if ((sector->status == Sector::OK) or
            (sector->status == Sector::BAD_CHECKSUM))
        {
            // There is data to encode to disk.
            if ((sector->data.size() != C64_SECTOR_LENGTH))
                error("unsupported sector size {} --- you must pick 256",
                    sector->data.size());

            // 1. Write header Sync (not GCR)
            for (int i = 0; i < 6; i++)
                write_bits(
                    bits, cursor, C64_HEADER_DATA_SYNC, 1 * 8); /* sync */

            // 2. Write Header info 10 GCR bytes
            /*
             * The 10 byte header info (#2) is GCR encoded and must be decoded
             * to it's normal 8 bytes to be understood. Once decoded, its
             * breakdown is as follows:
             *
             * Byte $00 - header block ID           ($08)
             *   01 - header block checksum 16  (EOR of $02-$05)
             *   02 - Sector
             *   03 - Track
             *   04 - Format ID byte #2
             *   05 - Format ID byte #1
             *   06-07 - $0F ("off" bytes)
             */
            uint8_t encodedTrack =
                ((sector->logicalCylinder) +
                    1); // C64 track numbering starts with 1. Fluxengine with 0.
            uint8_t encodedSector = sector->logicalSector;
            // uint8_t formatByte1 = C64_FORMAT_ID_BYTE1;
            // uint8_t formatByte2 = C64_FORMAT_ID_BYTE2;
            uint8_t headerChecksum =
                (encodedTrack ^ encodedSector ^ _formatByte1 ^ _formatByte2);
            write_bits(bits, cursor, encode_data(C64_HEADER_BLOCK_ID));
            write_bits(bits, cursor, encode_data(headerChecksum));
            write_bits(bits, cursor, encode_data(encodedSector));
            write_bits(bits, cursor, encode_data(encodedTrack));
            write_bits(bits, cursor, encode_data(_formatByte2));
            write_bits(bits, cursor, encode_data(_formatByte1));
            write_bits(bits, cursor, encode_data(C64_PADDING));
            write_bits(bits, cursor, encode_data(C64_PADDING));

            // 3. Write header GAP not GCR