IPFStruct.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;

namespace ipf {
    public enum MediaType : uint { Unknown, Floppy_Disk };

    public enum EncoderType : uint { Unknown, CAPS, SPS };

    public enum Platform : uint {
        Unknown, Amiga, Atari_ST, PC, Amstrad_CPC, Spectrum, Sam_Coupe, Archimedes, C64, Atari_8bit
    }

    public enum Density : uint {
        Unknown, Noise, Auto, Copylock_Amiga, Copylock_Amiga_New, Copylock_ST, Speedlock_Amiga,
        Speedlock_Amiga_Old, Adam_Brierley_Amiga, Adam_Brierley_Key_Amiga
    }

    public enum SignalType : uint { Unknown, cell_2us }

    [Flags]
    public enum TrackFlags : uint {
        None = 0x0,
        Fuzzy = 0x1
    }

    public enum BlockEncoderType : uint { Unknown, MFM, RAW }


    [Flags]
    public enum BlockFlags : uint {
        None = 0x00,
        FwGap = 0x01,
        BwGap = 0x02,
        DataInBit = 0x04
    }
    
    // Flags
    // https://msdn.microsoft.com/fr-fr/library/cc138362.aspx
    //if ((bd.blockFlags & BlockFlags.BwGap) == BlockFlags.BwGap) {
    //if (bd.blockFlags.HasFlag(BlockFlags.BwGap)) {
    //if(bd.blockFlags.Equals(BlockFlags.None))


    public enum DataType : uint { Unknown, Sync, Data, IGap, Raw, Fuzzy }

    public enum GapType : uint { Unknown, Forward, Backward }

    public enum GapElemType { Unknown, GapLength, SampleLength }

    public class RecordHeader {
        public char[] type = new char[4];

        public uint length;

        public uint crc;

        public override string ToString() {
            return String.Format("Record={0} Size={1} CRC={2:X8}",
                new string(type), length, crc);
        }
    }   // RecordHeader


    public class InfoRecord {
        public MediaType mediaType;

        public EncoderType encoderType;

        public uint encoderRev;

        public uint fileKey;

        public uint fileRev;

        public uint origin;

        public uint minTrack;

        public uint maxTrack;

        public uint minSide;

        public uint maxSide;

        public uint creationDate;

        public uint creationTime;

        public Platform[] platforms = new Platform[4];

        public uint diskNumber;

        public uint creatorId;

        public uint[] reserved = new uint[3];


        public override string ToString() {
            string date = String.Format("{0:D2}/{1:D2}/{2:D2}", creationDate / 10000, (creationDate/100) % 100, creationDate % 100);
            string time = String.Format("{0:D2}:{1:D2}:{2:D2}.{3:D3}", creationTime/10000000, (creationTime/100000) % 100, 
                (creationTime/1000)%100, creationTime % 1000);
            string pstring = null;
            foreach (Platform p in platforms)
                if (p != 0) pstring += (p.ToString() + " ");

            return String.Format(
                    "   Type={0} Encoder={1}(V{2}) File={3}(V{4}) Disk={5} Origin={6:X8} Creator={7:X8}\n" +
                    "   Track={8:D2}-{9:D2} Side={10}-{11} Date={12} Time={13} Platforms={14}\n",
                    mediaType.ToString(), encoderType.ToString(), encoderRev, fileKey, fileRev, diskNumber, origin,
                    creatorId, minTrack, maxTrack, minSide, maxSide, date, time, pstring);
        }
    }

    public class ImageRecord {
        public uint track;
        public uint side;
        public Density density;
        public SignalType signalType;
        public uint trackBytes;
        public uint startBytePos;
        public uint startBitPos;
        public uint dataBits;
        public uint gapBits;
        public uint trackBits;
        public uint blockCount;
        public uint encoder;
        public TrackFlags trackFlags;
        public uint dataKey;
        public uint[] reserved = new uint[3];

        public override string ToString() {
            return String.Format(
                "   T{0:D2}.{1} Size={2} bytes ({3} bits = Data={4} + Gap={5}) Start Byte={6} Bit={7}\n" +
                "   DataKey={8:D3} Block={9} Density={10} Signal={11} Encoder={12} Flags={13}\n",
                track, side, trackBytes, trackBits, dataBits, gapBits, startBytePos, startBitPos,
                dataKey, blockCount, density.ToString(), signalType.ToString(), encoder, trackFlags.ToString());
        }
    }


    public class DataRecord {
        public uint length;
        public uint bitSize;
        public uint crc;
        public uint key;
        public override string ToString() {
            return String.Format("== DataKey={0:D3} Length={1} bytes bitSize={2} bits CRC={3:X8}",
                key, length, bitSize, crc);
        }
    }


    [StructLayout(LayoutKind.Explicit)]
    public struct BlockDescriptor {
        [FieldOffset(0)]
        public uint dataBits;
        [FieldOffset(4)]
        public uint gapBits;

        [FieldOffset(8)]    // CAPS
        public uint dataBytes;
        [FieldOffset(12)]
        public uint gapBytes;

        [FieldOffset(8)]    // SPS
        public uint gapOffset;
        [FieldOffset(12)]
        public SignalType cellType;

        [FieldOffset(16)]
        public BlockEncoderType encoderType;
        [FieldOffset(20)]
        public BlockFlags blockFlags;
        [FieldOffset(24)]
        public uint gapDefaultValue;
        [FieldOffset(28)]
        public uint dataOffset;
    }


    public class CteiRecord {
        public uint releaseCrc;
        public uint analyzerRev;
        public uint[] reserved = new uint[14];
        public override string ToString() {
            return String.Format("   Associated IPF CRC={0:X8}  Analyzer revision={1}\n",
                releaseCrc, analyzerRev);
        }
    }


    public class CtexRecord {
        public uint track;
        public uint side;
        public Density density;
        public uint formatId;
        public uint fix;
        public uint trackSize;
        public uint[] reserved = new uint[2];
        public override string ToString() {
            return String.Format("   T{0:D2}.{1} Density={2} Format={3} Fix={4} TrackSize={5}\n",
                track, side, density.ToString(), formatId, fix, trackSize);
        }
    }

 
}