Example #1
0
 public byte[] GetSZXSnapshot()
 {
     return(SZX.ExportSZX(_machine));
     //return System.Text.Encoding.Default.GetString(data);
 }
Example #2
0
        /// <summary>
        /// Exports state information to a byte array in ZX-State format
        /// </summary>
        /// <param name="machine"></param>
        /// <returns></returns>
        public static byte[] ExportSZX(SpectrumBase machine)
        {
            var s = new SZX(machine);

            byte[] result = null;

            using (MemoryStream ms = new MemoryStream())
            {
                using (BinaryWriter r = new BinaryWriter(ms))
                {
                    // temp buffer
                    byte[] buff;
                    // working block
                    ZXSTBLOCK block = new ZXSTBLOCK();

                    // header
                    ZXSTHEADER header = new ZXSTHEADER();
                    header.dwMagic        = MediaConverter.GetUInt32(Encoding.UTF8.GetBytes("ZXST"), 0);
                    header.chMajorVersion = 1;
                    header.chMinorVersion = 4;
                    header.chFlags        = 0;
                    switch (s._machine.Spectrum.MachineType)
                    {
                    case MachineType.ZXSpectrum16: header.chMachineId = (int)MachineIdentifier.ZXSTMID_16K; break;

                    case MachineType.ZXSpectrum48: header.chMachineId = (int)MachineIdentifier.ZXSTMID_48K; break;

                    case MachineType.ZXSpectrum128: header.chMachineId = (int)MachineIdentifier.ZXSTMID_128K; break;

                    case MachineType.ZXSpectrum128Plus2: header.chMachineId = (int)MachineIdentifier.ZXSTMID_PLUS2; break;

                    case MachineType.ZXSpectrum128Plus2a: header.chMachineId = (int)MachineIdentifier.ZXSTMID_PLUS2A; break;

                    case MachineType.ZXSpectrum128Plus3: header.chMachineId = (int)MachineIdentifier.ZXSTMID_PLUS3; break;
                    }
                    buff = MediaConverter.SerializeRaw(header);
                    r.Write(buff);

                    // ZXSTCREATOR
                    var bStruct = s.GetZXSTCREATOR();
                    block.dwId   = MediaConverter.GetUInt32(Encoding.UTF8.GetBytes("CRTR"), 0);
                    block.dwSize = (uint)Marshal.SizeOf(bStruct);
                    buff         = MediaConverter.SerializeRaw(block);
                    r.Write(buff);
                    buff = MediaConverter.SerializeRaw(bStruct);
                    r.Write(buff);

                    // ZXSTZ80REGS
                    var cStruct = s.GetZXSTZ80REGS();
                    block.dwId   = MediaConverter.GetUInt32(Encoding.UTF8.GetBytes("Z80R"), 0);
                    block.dwSize = (uint)Marshal.SizeOf(cStruct);
                    buff         = MediaConverter.SerializeRaw(block);
                    r.Write(buff);
                    buff = MediaConverter.SerializeRaw(cStruct);
                    r.Write(buff);

                    // ZXSTSPECREGS
                    var dStruct = s.GetZXSTSPECREGS();
                    block.dwId   = MediaConverter.GetUInt32(Encoding.UTF8.GetBytes("SPCR"), 0);
                    block.dwSize = (uint)Marshal.SizeOf(dStruct);
                    buff         = MediaConverter.SerializeRaw(block);
                    r.Write(buff);
                    buff = MediaConverter.SerializeRaw(dStruct);
                    r.Write(buff);

                    // ZXSTKEYBOARD
                    var eStruct = s.GetZXSTKEYBOARD();
                    block.dwId   = MediaConverter.GetUInt32(Encoding.UTF8.GetBytes("KEYB"), 0);
                    block.dwSize = (uint)Marshal.SizeOf(eStruct);
                    buff         = MediaConverter.SerializeRaw(block);
                    r.Write(buff);
                    buff = MediaConverter.SerializeRaw(eStruct);
                    r.Write(buff);

                    // ZXSTJOYSTICK
                    var fStruct = s.GetZXSTJOYSTICK();
                    block.dwId   = MediaConverter.GetUInt32(Encoding.UTF8.GetBytes("JOY\0"), 0);
                    block.dwSize = (uint)Marshal.SizeOf(fStruct);
                    buff         = MediaConverter.SerializeRaw(block);
                    r.Write(buff);
                    buff = MediaConverter.SerializeRaw(fStruct);
                    r.Write(buff);


                    // ZXSTAYBLOCK
                    if (s._machine.Spectrum.MachineType != MachineType.ZXSpectrum16 && s._machine.Spectrum.MachineType != MachineType.ZXSpectrum48)
                    {
                        var gStruct = s.GetZXSTAYBLOCK();
                        block.dwId   = MediaConverter.GetUInt32(Encoding.UTF8.GetBytes("AY\0\0"), 0);
                        block.dwSize = (uint)Marshal.SizeOf(gStruct);
                        buff         = MediaConverter.SerializeRaw(block);
                        r.Write(buff);
                        buff = MediaConverter.SerializeRaw(gStruct);
                        r.Write(buff);
                    }

                    // ZXSTRAMPAGE
                    switch (s._machine.Spectrum.MachineType)
                    {
                    // For 16k Spectrums, only page 5 (0x4000 - 0x7fff) is saved.
                    case MachineType.ZXSpectrum16:
                        block.dwId = MediaConverter.GetUInt32(Encoding.UTF8.GetBytes("RAMP"), 0);
                        var rp16 = s.GetZXSTRAMPAGE(5, s._machine.RAM0);
                        block.dwSize = (uint)Marshal.SizeOf(rp16);
                        buff         = MediaConverter.SerializeRaw(block);
                        r.Write(buff);
                        buff = MediaConverter.SerializeRaw(rp16);
                        r.Write(buff);
                        break;

                    // For 48k Spectrums and Timex TS/TC models, pages 5, 2 (0x8000 - 0xbfff) and 0 (0xc000 - 0xffff) are saved.
                    case MachineType.ZXSpectrum48:
                        block.dwId = MediaConverter.GetUInt32(Encoding.UTF8.GetBytes("RAMP"), 0);
                        var rp48_0 = s.GetZXSTRAMPAGE(5, s._machine.RAM0);
                        block.dwSize = (uint)Marshal.SizeOf(rp48_0);
                        buff         = MediaConverter.SerializeRaw(block);
                        r.Write(buff);
                        buff = MediaConverter.SerializeRaw(rp48_0);
                        r.Write(buff);

                        block.dwId = MediaConverter.GetUInt32(Encoding.UTF8.GetBytes("RAMP"), 0);
                        var rp48_1 = s.GetZXSTRAMPAGE(5, s._machine.RAM1);
                        block.dwSize = (uint)Marshal.SizeOf(rp48_1);
                        buff         = MediaConverter.SerializeRaw(block);
                        r.Write(buff);
                        buff = MediaConverter.SerializeRaw(rp48_1);
                        r.Write(buff);

                        block.dwId = MediaConverter.GetUInt32(Encoding.UTF8.GetBytes("RAMP"), 0);
                        var rp48_2 = s.GetZXSTRAMPAGE(5, s._machine.RAM2);
                        block.dwSize = (uint)Marshal.SizeOf(rp48_2);
                        buff         = MediaConverter.SerializeRaw(block);
                        r.Write(buff);
                        buff = MediaConverter.SerializeRaw(rp48_2);
                        r.Write(buff);
                        break;

                    // For 128k Spectrums and the Pentagon 128, all pages (0-7) are saved.
                    case MachineType.ZXSpectrum128:
                    case MachineType.ZXSpectrum128Plus2:
                    case MachineType.ZXSpectrum128Plus2a:
                    case MachineType.ZXSpectrum128Plus3:
                        List <byte[]> rams = new List <byte[]>
                        {
                            s._machine.RAM0, s._machine.RAM1, s._machine.RAM2, s._machine.RAM3,
                            s._machine.RAM4, s._machine.RAM5, s._machine.RAM6, s._machine.RAM7
                        };
                        for (byte i = 0; i < 8; i++)
                        {
                            block.dwId = MediaConverter.GetUInt32(Encoding.UTF8.GetBytes("RAMP"), 0);
                            var rp = s.GetZXSTRAMPAGE(i, rams[i]);
                            block.dwSize = (uint)Marshal.SizeOf(rp);
                            buff         = MediaConverter.SerializeRaw(block);
                            r.Write(buff);
                            buff = MediaConverter.SerializeRaw(rp);
                            r.Write(buff);
                        }
                        break;
                    }

                    /*
                     * // ZXSTPLUS3
                     * if (s._machine.Spectrum.MachineType == MachineType.ZXSpectrum128Plus3)
                     * {
                     *  var iStruct = s.GetZXSTPLUS3();
                     *  block.dwId = MediaConverter.GetUInt32(Encoding.UTF8.GetBytes("+3\0\0"), 0);
                     *  block.dwSize = (uint)Marshal.SizeOf(iStruct);
                     *  buff = MediaConverter.SerializeRaw(block);
                     *  r.Write(buff);
                     *  buff = MediaConverter.SerializeRaw(iStruct);
                     *  r.Write(buff);
                     *
                     *  // ZXSTDSKFILE
                     *  if (s._machine.diskImages.Count() > 0)
                     *  {
                     *      var jStruct = s.GetZXSTDSKFILE();
                     *      block.dwId = MediaConverter.GetUInt32(Encoding.UTF8.GetBytes("DSK\0"), 0);
                     *      block.dwSize = (uint)Marshal.SizeOf(jStruct);
                     *      buff = MediaConverter.SerializeRaw(block);
                     *      r.Write(buff);
                     *      buff = MediaConverter.SerializeRaw(jStruct);
                     *      r.Write(buff);
                     *  }
                     * }
                     *
                     * // ZXSTTAPE
                     * if (s._machine.tapeImages.Count() > 0)
                     * {
                     *  var hStruct = s.GetZXSTTAPE();
                     *  var tapeData = s._machine.tapeImages[s._machine.TapeMediaIndex];
                     *  block.dwId = MediaConverter.GetUInt32(Encoding.UTF8.GetBytes("TAPE"), 0);
                     *  block.dwSize = (uint)Marshal.SizeOf(hStruct) + (uint)tapeData.Length;
                     *  buff = MediaConverter.SerializeRaw(block);
                     *  r.Write(buff);
                     *  buff = MediaConverter.SerializeRaw(hStruct);
                     *  r.Write(buff);
                     *  buff = MediaConverter.SerializeRaw(tapeData);
                     *  r.Write(buff);
                     *  char[] terminator = "\0".ToCharArray();
                     *  r.Write(terminator);
                     * }
                     */
                }

                result = ms.ToArray();
            }

            return(result);
        }
 /// <summary>
 /// Called by MainForm - dumps a close approximation of the Spectaculator SZX snapshot format
 /// DEV use only - this is nowhere near accurate
 /// </summary>
 public byte[] GetSZXSnapshot()
 {
     return(SZX.ExportSZX(_machine));
 }