RawTrack.hh

Go to the documentation of this file.

#ifndef RAWTRACK_HH
#define RAWTRACK_HH
 
#include "narrow.hh"
#include "serialize_meta.hh"
#include <cstdint>
#include <optional>
#include <span>
#include <vector>
 
namespace openmsx {
 
class CRC16;
 
// This class represents a raw disk track. It contains the logical sector
// content, but also address blocks, CRC checksums, sync blocks and the data
// in the gaps between these blocks.
//
// The internal representation is based on the DMK disk image file format. See:
//    http://www.trs-80.com/wordpress/dsk-and-dmk-image-utilities/
//    (at the bottom of the page)
//
// Besides the raw track data, this format also stores the positions of the
// 'address marks' in the track (this roughly corresponds with the start of a
// sector). Of course a real disk doesn't have such a list. In a real disk this
// information is stored as 'MFM encodings with missing clock transitions'.
//
// Normal MFM encoding goes like this: An input bit of '0' is encoded as 'x0'
// with x the inverse of the previously encoded bit. A '1' input bit is encoded
// as '01'. (More in detail: a '1' encoded bit indicates a magnetic flux
// transition, a '0' bit is no flux transition). So for example the input byte
// 0xA1 (binary 10100001) is MFM encoded as '01 00 01 00 10 10 10 01'. (Note
// that decoding is simply taking every 2nd bit (the data bits), the other bits
// (the clock bits) ensure that between encoded '1' bits is always at least 1
// and at most 3 zero bits. So no too dense flux transitions and not too far
// apart to keep the stream synchronized).
//
// Now for the missing clock transitions: besides the encodings for the 256
// possible input bytes, the FDC can write two other encodings, namely:
//   01 00 01 00 10 00 10 01  (0xA1 with missing clock between bit 4 and 5)
//   01 01 00 10 00 10 01 00  (0xC2 with missing clock between bit 3 and 4)
//
// So in principle we should store each of these special 0xA1 or 0xC2 bytes.
// Instead we only store the locations of '0xA1 0xA1 0xA1 0xFE' sequences (the
// 0xA1 bytes have missing clocks, this sequence indicates the start of an
// address mark). So we don't store the location of the special 0xC2 bytes, nor
// the location of each special 0xA1 byte. These certainly do occur on a real
// disk track, but the WD2793 controller only reacts to the full sequence
// above, so for us this is good enough. (The FDC also uses these special
// encodings to re-synchronize itself with the input stream, e.g. figure out
// which bit is the start bit in a byte, but from a functional emulation point
// of view we can ignore this).
//
// Also note that it's possible to create real disks that have still completely
// different magnetic flux patterns than the 256+2 possible MFM patterns
// described above. Such disks cannot be described by this class. But for
// openMSX that's not a problem because the WD2793 or TC8566AF disk controllers
// anyway can't handle such disks (they would always interpret the flux pattern
// as one of the 256+2 MFM patterns). Other systems (like Amiga) have disk
// controllers that allow more direct access to the disk and could for example
// encode the data in a more efficient way than MFM (e.g. GCR6). That's why
// Amiga can fit more data on the same disk (even more than simply storing 10
// or 11 sectors on a track by making the gaps between the sectors smaller).
 
class RawTrack {
public:
        // Typical track length is 6250 bytes:
        //    250kbps, 300rpm -> 6250 bytes per rotation.
        // The IBM Disk Format Specification confirms this number.
        // Of course this is in ideal circumstances: in reality the rotation
        // speed can vary and thus the disk can be formatted with slightly more
        // or slightly less raw bytes per track. This class can also represent
        // tracks of different lengths.
        static constexpr unsigned STANDARD_SIZE = 6250;
 
        struct Sector
        {
                // note: initialize to avoid UMR on savestate
                int addrIdx = 0;
                int dataIdx = 0;
                uint8_t track = 0;
                uint8_t head = 0;
                uint8_t sector = 0;
                uint8_t sizeCode = 0;
                bool deleted = false;
                bool addrCrcErr = false;
                bool dataCrcErr = false;
 
                template<typename Archive>
                void serialize(Archive& ar, unsigned version);
        };
 
        /* Construct a (cleared) track. */
        explicit RawTrack(unsigned size = STANDARD_SIZE);
 
        void clear(unsigned size);
 
        [[nodiscard]] unsigned getLength() const { return unsigned(data.size()); }
 
        void addIdam(unsigned idx);
 
        // In the methods below, 'index' is allowed to be 'out-of-bounds',
        // it will wrap like in a circular buffer.
 
        [[nodiscard]] uint8_t read(int idx) const { return data[wrapIndex(idx)]; }
        void write(int idx, uint8_t val, bool setIdam = false);
        [[nodiscard]] int wrapIndex(int idx) const {
                // operator% is not a modulo but a remainder operation (makes a
                // difference for negative inputs). Hence the extra test.
                int size = narrow<int>(data.size());
                int tmp = idx % size;
                return (tmp >= 0) ? tmp : (tmp + size);
        }
 
        [[nodiscard]] std::span<      uint8_t> getRawBuffer()       { return data; }
        [[nodiscard]] std::span<const uint8_t> getRawBuffer() const { return data; }
        [[nodiscard]] const auto& getIdamBuffer() const { return idam; }
 
        [[nodiscard]] std::vector<Sector> decodeAll() const;
 
        [[nodiscard]] std::optional<Sector> decodeNextSector(unsigned startIdx) const;
 
        [[nodiscard]] std::optional<Sector> decodeSector(uint8_t sectorNum) const;
 
        void readBlock (int idx, std::span<uint8_t> destination) const;
        void writeBlock(int idx, std::span<const uint8_t> source);
 
        [[nodiscard]] uint16_t calcCrc(int idx, int size) const;
        void updateCrc(CRC16& crc, int idx, int size) const;
 
        void applyWd2793ReadTrackQuirk();
 
        template<typename Archive>
        void serialize(Archive& ar, unsigned version);
 
private:
        [[nodiscard]] std::optional<Sector> decodeSectorImpl(int idx) const;
 
private:
        // Index into 'data'-array to positions where an address mark
        // starts (it points to the 'FE' byte in the 'A1 A1 A1 FE ..'
        // sequence.
        std::vector<unsigned> idam;
 
        // MFM-decoded raw data, this does NOT include the missing clock
        // transitions that can occur in the encodings of the 'A1' and
        // 'C2' bytes.
        std::vector<uint8_t> data;
};
SERIALIZE_CLASS_VERSION(RawTrack, 2);
 
} // namespace openmsx
 
#endif