diskstack 1.0.0__py3-none-any.whl

diskstack/_vendor/greaseweazle/image/d81.py

@@ -0,0 +1,28 @@
+# greaseweazle/image/d81.py
+#
+# Written & released by Keir Fraser <keir.xen@gmail.com>
+#
+# This is free and unencumbered software released into the public domain.
+# See the file COPYING for more details, or visit <http://unlicense.org>.
+
+from diskstack._vendor.greaseweazle.image.img import IMG
+
+class D81(IMG):
+    default_format = 'commodore.1581'
+    sides_swapped = True
+
+class D1M(IMG):
+    default_format = 'commodore.cmd.fd2000.dd'
+    sides_swapped = True
+
+class D2M(IMG):
+    default_format = 'commodore.cmd.fd2000.hd'
+    sides_swapped = True
+
+class D4M(IMG):
+    default_format = 'commodore.cmd.fd4000.ed'
+    sides_swapped = True
+
+# Local variables:
+# python-indent: 4
+# End:

diskstack/_vendor/greaseweazle/image/d88.py

@@ -0,0 +1,211 @@
+# greaseweazle/image/d88.py
+#
+# Written & released by Keir Fraser <keir.xen@gmail.com>
+#
+# This is free and unencumbered software released into the public domain.
+# See the file COPYING for more details, or visit <http://unlicense.org>.
+
+from typing import Dict, Tuple, Optional, List
+
+import struct
+import os
+
+from diskstack._vendor.greaseweazle import error
+from diskstack._vendor.greaseweazle.codec.ibm import ibm
+from .image import Image, ImageOpts, OptDict
+
+TrackDict = Dict[Tuple[int,int],ibm.IBMTrack_Fixed]
+
+class D88Opts(ImageOpts):
+    """index: Index into multi-disk image."""
+
+    r_settings = [ 'index' ]
+
+    def __init__(self) -> None:
+        self._index = 0
+
+    @property
+    def index(self) -> int:
+        return self._index
+    @index.setter
+    def index(self, index: float):
+        try:
+            self._index = int(index)
+            if self._index < 0:
+                raise ValueError
+        except ValueError:
+            raise error.Fatal("D88: Invalid index: '%s'" % index)
+
+
+class D88(Image):
+
+    opts: D88Opts
+
+    read_only = True
+
+    def __init__(self, name: str, _fmt):
+        self.opts = D88Opts()
+        self.to_track: TrackDict = dict()
+        self.filename = name
+
+    @staticmethod
+    def remove_duplicate_sectors(secs) ->  List[Tuple[int,int,int,int,bytes]]:
+        new_secs: List[Tuple[int,int,int,int,bytes]] = []
+        for s in secs:
+            dup = False
+            for t in new_secs:
+                if s == t:
+                    dup = True
+                    break
+            if not dup:
+                new_secs.append(s)
+        return new_secs
+
+    @staticmethod
+    def track_from_file(f, cyl: int, head: int,
+                        media_flag: int) -> Optional[ibm.IBMTrack_Fixed]:
+        track = None
+        track_mfm_flag = None
+        pos = None
+        secs: List[Tuple[int,int,int,int,bytes]] = []
+        num_sectors_track = 255
+        while len(secs) < num_sectors_track:
+            (c, h, r, n, num_sectors, mfm_flag,
+             deleted, status, data_size) = \
+                struct.unpack('<BBBBHBBB5xH', f.read(16))
+            error.check(status == 0x00,
+                        'D88: FDC error codes are unsupported.')
+            error.check(deleted == 0x00,
+                        'D88: Deleted data is unsupported.')
+            if track is None:
+                if media_flag == 0x00:
+
+                    if mfm_flag == 0x40:
+                        track = ibm.IBMTrack_FixedDef('ibm.fm')
+                        track.rate = 125
+                    else:
+                        track = ibm.IBMTrack_FixedDef('ibm.mfm')
+                        track.rate = 250
+                    track.rpm = 300
+                else:
+                    if mfm_flag == 0x40:
+                        track = ibm.IBMTrack_FixedDef('ibm.fm')
+                        track.rate = 250
+                    else:
+                        track = ibm.IBMTrack_FixedDef('ibm.mfm')
+                        track.rate = 500
+                    track.rpm = 360
+                track_mfm_flag = mfm_flag
+                num_sectors_track = num_sectors
+            error.check(mfm_flag == track_mfm_flag,
+                        'D88: Mixed FM and MFM sectors in one track '
+                        'are unsupported.')
+            error.check(num_sectors_track == num_sectors,
+                        'D88: Corrupt number of sectors per track '
+                        'in sector header.')
+            data = f.read(data_size)
+            size = 128 << n
+            error.check(size == data_size,
+                        'D88: Extra sector data is unsupported.')
+            secs.append((c,h,r,n,data))
+
+        if track is None:
+            return None
+
+        track.secs = len(secs)
+        track.sz = [x[3] for x in secs]
+        track.finalise()
+        t = ibm.IBMTrack_Fixed.from_config(
+            track, cyl, head, warn_on_oversize = False)
+
+        # If the track is oversized, remove duplicate sectors, and
+        # re-generate the track layout with oversize warning enabled.
+        if t.oversized:
+            new_secs = D88.remove_duplicate_sectors(secs)
+            ndups = len(secs) - len(new_secs)
+            if ndups != 0:
+                print('T%d.%d: D88: Removed %d duplicate sectors '
+                      'from oversized track' % (cyl, head, ndups))
+            secs = new_secs
+            track.secs = len(secs)
+            track.sz = [x[3] for x in secs]
+            t = ibm.IBMTrack_Fixed.from_config(
+                track, cyl, head, warn_on_oversize = True)
+
+        for nr,s in enumerate(t.sectors):
+            c,h,r,n,data = secs[nr]
+            s.crc = s.idam.crc = s.dam.crc = 0
+            s.idam.c, s.idam.h, s.idam.r, s.idam.n = c,h,r,n
+            s.dam.data = data
+
+        return t
+
+    @staticmethod
+    def disk_from_file(f, disk_offset: int) -> TrackDict:
+        f.seek(disk_offset)
+        to_track: TrackDict = dict()
+
+        header = struct.unpack('<16sB9xBBL', f.read(32))
+        disk_name, terminator, write_prot, media_flag, disk_size = header
+        track_table = list(struct.unpack('<160L', f.read(640)))
+        s_off = min(filter(lambda x: x != 0, track_table), default=672)
+        if s_off == 688:
+            track_table.extend(list(struct.unpack('<4L', f.read(16))))
+        elif s_off != 672:
+            raise error.Fatal("D88: Unsupported track table length.")
+
+        for track_index, track_offset in enumerate(track_table):
+            if track_offset == 0:
+                continue
+            f.seek(disk_offset + track_offset)
+            if f.tell() >= disk_offset + disk_size:
+                continue
+            cyl = track_index // 2
+            head = track_index % 2
+            t = D88.track_from_file(f, cyl, head, media_flag)
+            if t is not None:
+                to_track[cyl, head] = t
+
+        return to_track
+
+    @classmethod
+    def from_file(cls, name: str, _fmt, opts: OptDict) -> Image:
+
+        d88 = cls(name, _fmt)
+        d88.apply_r_opts(opts)
+
+        with open(name, "rb") as f:
+            f.seek(0, os.SEEK_END)
+            file_size = f.tell()
+            f.seek(0)
+            disk_offset, disk_index = 0, 0
+            while disk_offset < file_size:
+                if disk_index == d88.opts.index:
+                    d88.to_track = D88.disk_from_file(f, disk_offset)
+                f.seek(disk_offset)
+                header = struct.unpack('<16sB9xBBL', f.read(32))
+                _, _, _, _, disk_size = header
+                disk_offset += disk_size
+                disk_index += 1
+
+        error.check(disk_index > 0,
+                    f'D88: {d88.filename}: No valid disk found')
+
+        if disk_index > 1:
+            print(f'D88: {d88.filename}: {disk_index} disks in file; '
+                  f'reading disk with index {d88.opts.index}')
+
+        error.check(d88.opts.index < disk_index,
+                    f'D88: {d88.filename}: No disk with index '
+                    f'{d88.opts.index} (valid indexes 0-{disk_index-1})')
+
+        return d88
+
+    def get_track(self, cyl: int, side: int) -> Optional[ibm.IBMTrack_Fixed]:
+        if (cyl,side) not in self.to_track:
+            return None
+        return self.to_track[cyl,side]
+
+# Local variables:
+# python-indent: 4
+# End:

diskstack/_vendor/greaseweazle/image/dcp.py

@@ -0,0 +1,45 @@
+# greaseweazle/image/dcp.py
+#
+# Written & released by Keir Fraser <keir.xen@gmail.com>
+#
+# This is free and unencumbered software released into the public domain.
+# See the file COPYING for more details, or visit <http://unlicense.org>.
+
+import struct
+
+from diskstack._vendor.greaseweazle import error
+from diskstack._vendor.greaseweazle.image.img import IMG_AutoFormat
+from diskstack._vendor.greaseweazle.codec import codec
+from .image import Image
+
+class DCP(IMG_AutoFormat):
+
+    read_only = True
+
+    @staticmethod
+    def format_from_file(name: str) -> str:
+        return 'pc98.2hd'
+
+    def from_bytes(self, dat: bytes) -> None:
+
+        header = dat[:162]
+        pos = 162
+        fmt = self.fmt
+
+        for cyl, head in self.track_list():
+            if self.sides_swapped:
+                head ^= 1
+            track = fmt.mk_track(cyl, head)
+            if track is None:
+                continue
+            if cyl > 80:
+                break
+            if header[cyl * 2 + head] == 1:
+                pos += track.set_img_track(dat[pos:])
+                self.to_track[cyl,head] = track
+            elif header[cyl * 2 + head] != 0:
+                raise error.Fatal("DCP: Corrupt header.")
+
+# Local variables:
+# python-indent: 4
+# End:

diskstack/_vendor/greaseweazle/image/dim.py

@@ -0,0 +1,53 @@
+# greaseweazle/image/dim.py
+#
+# Written & released by Keir Fraser <keir.xen@gmail.com>
+#
+# This is free and unencumbered software released into the public domain.
+# See the file COPYING for more details, or visit <http://unlicense.org>.
+
+import struct
+
+from diskstack._vendor.greaseweazle import error
+from diskstack._vendor.greaseweazle.image.img import IMG_AutoFormat
+from diskstack._vendor.greaseweazle.codec import codec
+from .image import Image
+
+class DIM(IMG_AutoFormat):
+
+    read_only = True
+
+    @staticmethod
+    def format_from_file(name: str) -> str:
+
+        with open(name, "rb") as f:
+            header = f.read(256)
+
+        error.check(header[0xAB:0xB8] == b"DIFC HEADER  ",
+                    "DIM: Not a DIM file.")
+        media_byte, = struct.unpack('B255x', header)
+        if media_byte == 0:
+            format_str = 'pc98.2hd'
+        elif media_byte == 1:
+            format_str = 'pc98.2hs'
+        else:
+            raise error.Fatal("DIM: Unsupported format.")
+
+        return format_str
+
+    def from_bytes(self, dat: bytes) -> None:
+
+        pos = 256
+        fmt = self.fmt
+
+        for t in fmt.tracks:
+            cyl, head = t.cyl, t.head
+            if self.sides_swapped:
+                head ^= 1
+            track = fmt.mk_track(cyl, head)
+            if track is not None:
+                pos += track.set_img_track(dat[pos:])
+                self.to_track[cyl,head] = track
+
+# Local variables:
+# python-indent: 4
+# End:

diskstack/_vendor/greaseweazle/image/dmk.py

@@ -0,0 +1,166 @@
+# greaseweazle/image/dmk.py
+#
+# Some of the code here is heavily inspired by Simon Owen's SAMdisk:
+# https://simonowen.com/samdisk/
+#
+# Written & released by Keir Fraser <keir.xen@gmail.com>
+# 
+# This is free and unencumbered software released into the public domain.
+# See the file COPYING for more details, or visit <http://unlicense.org>.
+
+from typing import Dict, Tuple, Optional, List, Union
+
+import struct
+import itertools as it
+from bitarray import bitarray
+
+from diskstack._vendor.greaseweazle import __version__
+from diskstack._vendor.greaseweazle import error
+from diskstack._vendor.greaseweazle.codec.ibm import ibm
+from diskstack._vendor.greaseweazle.track import MasterTrack, PLLTrack
+from .image import Image
+
+class Encoding:
+
+    def __init__(self, len: int, mfm: bool, fm_step: int) -> None:
+        self.fm_step = fm_step
+        self.mfm = [False] * len
+        self.clock = bytearray(len)
+        self.cursor = 0
+        self.prev_mfm = mfm
+
+    def move_cursor(self, off: int) -> None:
+        while self.cursor < off:
+            self.mfm[self.cursor] = self.prev_mfm
+            self.cursor += 1
+
+    def _off(self, areas, data: bytes, off: int, step: int) -> None:
+        for i, v, c in areas:
+            min_off = max(off - i*step, 0)
+            while off > min_off and data[off-step] == v:
+                off -= step
+                self.clock[off] = c
+        self.move_cursor(off)
+
+    def mfm_off(self, data: bytes, off: int) -> None:
+        areas = [(  3, 0xa1, 0x0a), # IDAM A1, Clock 0A -> 4489
+                 ( 12, 0x00,    0),
+                 (512, 0x4e,    0),
+                 (  1, 0xfc,    0),
+                 (  3, 0xc2, 0x14), # IAM C2, Clock 14 -> 5224
+                 ( 12, 0x00,    0),
+                 (512, 0x4e,    0)]
+        self._off(areas, data, off, 1)
+        self.prev_mfm = True
+
+    def fm_off(self, data: bytes, off: int) -> None:
+        areas = [(  6, 0x00,    0),
+                 (256, 0xff,    0),
+                 (  1, 0xfc, 0xd7), # IAM FC, Clock D7
+                 (  6, 0x00,    0)]
+        self._off(areas, data, off, self.fm_step)
+        self.prev_mfm = False
+
+
+class DMKTrack:
+
+    def __init__(self, data: bytes) -> None:
+        time_per_rev = 0.2
+        dlen = (len(data) * 8) // 1000
+        if (80 <= dlen <= 85) or (160 <= dlen <= 170):
+            time_per_rev *= 5/6
+        self.track = MasterTrack(
+            bits = bytes(data),
+            time_per_rev = time_per_rev)
+
+    def master_track(self) -> MasterTrack:
+        return self.track
+
+
+class DMK(Image):
+
+    read_only = True
+
+    def __init__(self, name: str, _fmt) -> None:
+        self.to_track: Dict[Tuple[int,int], DMKTrack] = dict()
+        self.filename = name
+
+    def from_bytes(self, dat: bytes) -> None:
+
+        ro, ncyl, tlen, flags = struct.unpack('<2BHB', dat[:5])
+        error.check(flags & 0x2f == 0,
+                    'DMK: Unrecognised flags value 0x%02x' % flags)
+        nside = 1 if flags & 0x10 else 2
+        fm_step = 1 if flags & 0xc0 else 2
+
+        o = 16 # skip disk header
+        for cyl in range(ncyl):
+            for head in range(nside):
+                offs = list(map(lambda x: ((x & 0x8000) == 0x8000,
+                                           (x & 0x3fff) - 128),
+                                filter(lambda x: x != 0,
+                                       struct.unpack("<64H", dat[o:o+128]))))
+                # DMK Spec: "The IDAM offsets MUST be in ascending order with
+                # no unused or bad pointers." We clip at the first
+                # non-ascending offset, fixing some buggy DMK image imports
+                # (for example, which have 0x80 added to empty offset entries).
+                prev = -1
+                for i, (_, off) in enumerate(offs):
+                    if off <= prev:
+                        offs = offs[:i]
+                        break
+                    prev = off
+                data = dat[o+128:o+tlen]
+                o += tlen
+                if not offs:
+                    continue
+                encoding = Encoding(len(data), offs[0][0], fm_step)
+                for mfm, off in offs:
+                    if mfm:
+                        encoding.mfm_off(data, off)
+                        dam = data[off+8:off+64].find(b'\xa1' * 3)
+                        error.check(dam != -1, 'DMK: No MFM DAM sync found')
+                        dam += off+8
+                        encoding.move_cursor(dam+8)
+                        encoding.clock[dam+0] = 0x0a
+                        encoding.clock[dam+1] = 0x0a
+                        encoding.clock[dam+2] = 0x0a
+                    else:
+                        # Single density: Step-align the offset
+                        step = encoding.fm_step
+                        off &= ~(step-1)
+                        if data[off] == 0:
+                            off += step
+                        encoding.fm_off(data, off)
+                        encoding.clock[off] = 0xc7
+                        for dam in range(off+8*step, off+64*step, step):
+                            if (data[dam-step] == 0 and
+                                data[dam] & 0xf0 == 0xf0):
+                                break
+                        encoding.move_cursor(dam+8*step)
+                        encoding.clock[dam] = 0xc7
+
+                encoding.move_cursor(len(data))
+
+                enc_data, fm_mask = bytearray(), encoding.fm_step-1
+                for i in range(len(data)):
+                    if not (mfm := encoding.mfm[i]) and (i & fm_mask) != 0:
+                        continue
+                    d = ibm.encode_list[data[i]]
+                    c = ibm.encode_list[encoding.clock[i]]
+                    x = struct.pack('>H', (c<<1)|d)
+                    if mfm:
+                        enc_data += ibm.mfm_encode(x)
+                    else:
+                        enc_data += ibm.doubler(ibm.fm_encode(x))
+
+                self.to_track[cyl,head] = DMKTrack(enc_data)
+
+    def get_track(self, cyl: int, side: int) -> Optional[MasterTrack]:
+        if (cyl,side) not in self.to_track:
+            return None
+        return self.to_track[cyl,side].master_track()
+
+# Local variables:
+# python-indent: 4
+# End:

diskstack/_vendor/greaseweazle/image/dsk.py

@@ -0,0 +1,31 @@
+# greaseweazle/image/dsk.py
+#
+# Written & released by Keir Fraser <keir.xen@gmail.com>
+#
+# This is free and unencumbered software released into the public domain.
+# See the file COPYING for more details, or visit <http://unlicense.org>.
+
+from diskstack._vendor.greaseweazle.image.image import Image, OptDict
+from diskstack._vendor.greaseweazle.image.img import IMG
+from diskstack._vendor.greaseweazle.image.edsk import EDSK
+from diskstack._vendor.greaseweazle.image.apridisk import Apridisk
+
+class DSK(IMG):
+
+    @classmethod
+    def from_file(cls, name: str, fmt, opts: OptDict) -> Image:
+
+        with open(name, "rb") as f:
+            sig = f.read(24)
+
+        if sig[:8] == b'MV - CPC' or sig[:16] == b'EXTENDED CPC DSK':
+            return EDSK.from_file(name, fmt, opts)
+
+        if sig[:24] == b"ACT Apricot disk image\032\004":
+            return Apridisk.from_file(name, fmt, opts)
+
+        return IMG.from_file(name, fmt, opts)
+
+# Local variables:
+# python-indent: 4
+# End: