Subversion Repositories pentevo

Rev

Blame | Last modification | View Log | Download | RSS feed | ?url?

  1. #include "std.h"
  2.  
  3. #include "emul.h"
  4. #include "vars.h"
  5. #include "tape.h"
  6. #include "memory.h"
  7.  
  8. #include "util.h"
  9. #include "png/zlib.h"
  10.  
  11. #define Z80FQ 3500000
  12.  
  13. // └ыЇртшЄ шч шьяєы№ёют Ёрчэющ фышэ√ (ўшёыю ёшьтюыют рыЇртшЄр эх сюыхх 256, ёё√ыъш юфэюсрщЄют√х)
  14. // -1 (UINT_MAX) - ╤яхЎшры№эюх чэрўхэшх - юёЄрэют ыхэЄ√
  15. // ─тр ёЄрЁ°шї сшЄр - Їыруш (ъръ т сыюъх 0x19 TZX 1.20):
  16. // 00: opposite to the current level (make an edge, as usual) - default
  17. // 01: same as the current level (no edge - prolongs the previous pulse)
  18. // 10: force low level
  19. // 11: force high level
  20. u32 tape_pulse[0x100];
  21. static unsigned max_pulses = 0;
  22. static unsigned tape_err = 0;
  23.  
  24. // ╠рёёшт ёё√ыюъ эр рыЇртшЄ (ёё√ыъш юфэюсрщЄют√х), ърцф√щ эют√щ ёшьтюы - ёьхэр яюы ЁэюёЄш ёшуэрыр
  25. // ═рўры№эр  яюы ЁэюёЄ№ яюыюцшЄхы№эр  (т√ёюъшщ єЁютхэ№ ёшуэрыр)
  26. u8 *tape_image = nullptr;
  27. static unsigned tape_imagesize = 0;
  28.  
  29. TAPEINFO *tapeinfo;
  30. unsigned tape_infosize;
  31.  
  32. static unsigned appendable;
  33.  
  34. typedef int (__cdecl *inflateInit__ptr)(z_streamp strm, const char *version, int stream_size);
  35. typedef int (__cdecl *inflate_ptr)(z_streamp strm, int flush);
  36. typedef int (__cdecl *inflateEnd_ptr)(z_streamp strm);
  37.  
  38. static inflateInit__ptr inflateInit__p = nullptr;
  39. static inflate_ptr inflate_p = nullptr;
  40. static inflateEnd_ptr inflateEnd_p = nullptr;
  41.  
  42. static HMODULE ZlibDll = nullptr;
  43.  
  44. bool ZlibInit()
  45. {
  46.     ZlibDll = LoadLibrary("zlib1.dll");
  47.     if (!ZlibDll)
  48.     {
  49.         return false;
  50.     }
  51.     inflateInit__p = (inflateInit__ptr)GetProcAddress(ZlibDll, "inflateInit_");
  52.     if (!inflateInit__p)
  53.     {
  54.         return false;
  55.     }
  56.     inflate_p = (inflate_ptr)GetProcAddress(ZlibDll,"inflate");
  57.     if (!inflate_p)
  58.     {
  59.         return false;
  60.     }
  61.     inflateEnd_p = (inflateEnd_ptr)GetProcAddress(ZlibDll,"inflateEnd");
  62.     if (!inflateEnd_p)
  63.     {
  64.         return false;
  65.     }
  66.     return true;
  67. }
  68.  
  69. void ZlibDone()
  70. {
  71.     if (ZlibDll)
  72.     {
  73.         FreeLibrary(ZlibDll);
  74.     }
  75. }
  76.  
  77. // ╚∙хЄ фышэє шьяєы№ёр т рыЇртшЄх ш тючтЁр∙рхЄ шэфхъё эрщфхээюую ¤ыхьхэЄр
  78. // ┼ёыш шьяєы№ё ё Єръющ °шЁшэющ эх эрщфхэ, юэ фюсрты хЄё  т ъюэхЎ ш тючтЁр∙рхЄё  хую шэфхъё
  79. // tape image contains indexes in tape_pulse[]
  80. static u8 find_pulse(u32 t, unsigned Flags = 0)
  81. {
  82.     if (max_pulses < _countof(tape_pulse))
  83.     {
  84.         double e = 0.10 * t; // ЁрчсЁюё 10%
  85.         for (unsigned i = 0; i < max_pulses; i++)
  86.         {
  87.             u32 pulse = tape_pulse[i] & tape_pulse_mask;
  88.             unsigned fl = (tape_pulse[i] >> 30) & 3;
  89.             if (fl == (Flags & 3) && (t - e) < pulse && pulse <= (t + e))
  90.             {
  91.                 return u8(i);
  92.             }
  93.         }
  94.         tape_pulse[max_pulses] = t | ((Flags & 3) << 30);
  95.         return u8(max_pulses++);
  96.     }
  97.     if (!tape_err)
  98.     {
  99.         errmsg("pulse table full");
  100.         tape_err = 1;
  101.     }
  102.     unsigned nearest = 0; int delta = INT_MAX;
  103.     for (unsigned i = 0; i < _countof(tape_pulse); i++)
  104.     {
  105.         u32 pulse = tape_pulse[i] & tape_pulse_mask;
  106.         unsigned fl = (tape_pulse[i] >> 30) & 3;
  107.         if (fl == (Flags & 3) && delta > abs((int)t - (int)pulse))
  108.         {
  109.             nearest = i;
  110.             delta = abs((int)t - (int)pulse);
  111.         }
  112.     }
  113.     return u8(nearest);
  114. }
  115.  
  116. void find_tape_index()
  117. {
  118.     for (unsigned i = 0; i < tape_infosize; i++)
  119.     {
  120.         if (comp.tape.play_pointer >= tape_image + tapeinfo[i].pos)
  121.         {
  122.             comp.tape.index = i;
  123.         }
  124.     }
  125.     temp.led.tape_started = -600 * Z80FQ;
  126. }
  127.  
  128. static void find_tape_sizes()
  129. {
  130.     for (unsigned i = 0; i < tape_infosize; i++)
  131.     {
  132.         unsigned end = (i == tape_infosize - 1) ? tape_imagesize : tapeinfo[i + 1].pos;
  133.  
  134.         unsigned sz = 0;
  135.         for (unsigned j = tapeinfo[i].pos; j < end; j++)
  136.         {
  137.             sz += tape_pulse[tape_image[j]] & tape_pulse_mask;
  138.         }
  139.         tapeinfo[i].t_size = sz;
  140.     }
  141. }
  142.  
  143. void stop_tape()
  144. {
  145.     // ╙ёыютш  фы  т√їюфр шї ЇєэъЎшш tape_bit()
  146.     comp.tape.edge_change = LLONG_MAX;
  147.     comp.tape.tape_bit = -1U;
  148.  
  149.     if (comp.tape.stopped) // ┼ёыш ыхэЄр єцх юёЄрэютыхэр, Єю эшўхую эх фхырхь
  150.     {
  151.         return;
  152.     }
  153.  
  154.     comp.tape.stopped = true;
  155.  
  156.     find_tape_index();
  157.  
  158.     const char *msg = "tape stopped";
  159.     if (comp.tape.play_pointer == comp.tape.end_of_tape) // ╧Ёш фюёЄшцхэшш ъюэЎр ыхэЄ√ эх фхырхь ртЄюяхЁхьюЄъє
  160.     {
  161.         msg = "end of tape";
  162.     }
  163.     else
  164.     {
  165.         comp.tape.play_pointer = nullptr;
  166.     }
  167.     strcpy(statusline, msg); statcnt = 40;
  168. }
  169.  
  170. void reset_tape()
  171. {
  172.     comp.tape.index = 0;
  173.     comp.tape.stopped = true;
  174.     comp.tape.play_pointer = nullptr;
  175.     comp.tape.edge_change = LLONG_MAX;
  176.     comp.tape.tape_bit = -1U;
  177. }
  178.  
  179. void start_tape()
  180. {
  181.     if (!tape_image)
  182.     {
  183.         return;
  184.     }
  185.  
  186.     comp.tape.play_pointer = tape_image + tapeinfo[comp.tape.index].pos;
  187.     comp.tape.end_of_tape = tape_image + tape_imagesize;
  188.  
  189.     if (comp.tape.play_pointer >= comp.tape.end_of_tape) // ╩юэхЎ ыхэЄ√, шуэюЁшЁєхь чряєёъ
  190.     {
  191.         return;
  192.     }
  193.     comp.tape.stopped = false;
  194.     comp.tape.edge_change = comp.t_states + cpu.t;
  195.     temp.led.tape_started = -600 * Z80FQ;
  196.     comp.tape.tape_bit = -1U;
  197.     strcpy(statusline, "tape started"); statcnt = 40;
  198. }
  199.  
  200. void closetape()
  201. {
  202.     if (tape_image)
  203.     {
  204.         free(tape_image);
  205.         tape_image = nullptr;
  206.     }
  207.     if (tapeinfo)
  208.     {
  209.         free(tapeinfo);
  210.         tapeinfo = nullptr;
  211.     }
  212.     comp.tape.play_pointer = nullptr; // stop tape
  213.     comp.tape.index = 0; // rewind tape
  214.     tape_err = max_pulses = tape_imagesize = tape_infosize = 0;
  215.     comp.tape.edge_change = LLONG_MAX;
  216.     comp.tape.tape_bit = -1U;
  217. }
  218.  
  219. static void reserve(unsigned datasize)
  220. {
  221.     const unsigned blocksize = 16384;
  222.     unsigned newsize = align_by(datasize + tape_imagesize + 1, blocksize);
  223.     if (!tape_image)
  224.     {
  225.         tape_image = (unsigned char*)malloc(newsize);
  226.     }
  227.     if (align_by(tape_imagesize, blocksize) < newsize)
  228.     {
  229.         tape_image = (unsigned char*)realloc(tape_image, newsize);
  230.     }
  231. }
  232.  
  233. static void makeblock(const unsigned char *data, unsigned size, unsigned pilot_t,
  234.     unsigned s1_t, unsigned s2_t, unsigned zero_t, unsigned one_t,
  235.     unsigned pilot_len, unsigned pause, unsigned char last = 8)
  236. {
  237.     reserve(size * 16 + pilot_len + 3);
  238.     if (pilot_len != -1U)
  239.     {
  240.         u8 t = find_pulse(pilot_t);
  241.         for (unsigned i = 0; i < pilot_len; i++)
  242.             tape_image[tape_imagesize++] = t;
  243.         tape_image[tape_imagesize++] = find_pulse(s1_t);
  244.         tape_image[tape_imagesize++] = find_pulse(s2_t);
  245.     }
  246.     u8 t0 = find_pulse(zero_t), t1 = find_pulse(one_t);
  247.     for (; size > 1; size--, data++)
  248.     {
  249.         for (unsigned char j = 0x80; j; j >>= 1)
  250.         {
  251.             tape_image[tape_imagesize++] = (*data & j) ? t1 : t0;
  252.             tape_image[tape_imagesize++] = (*data & j) ? t1 : t0;
  253.         }
  254.     }
  255.     for (unsigned char j = 0x80; j != (unsigned char)(0x80 >> last); j >>= 1) // last byte
  256.     {
  257.         tape_image[tape_imagesize++] = (*data & j) ? t1 : t0;
  258.         tape_image[tape_imagesize++] = (*data & j) ? t1 : t0;
  259.     }
  260.     if (pause)
  261.     {
  262.         tape_image[tape_imagesize++] = find_pulse(pause*(Z80FQ / 1000));
  263.     }
  264. }
  265.  
  266. static void desc(const unsigned char *data, unsigned size, char *dst)
  267. {
  268.     unsigned char crc = 0;
  269.     char prg[11];
  270.     unsigned i; //Alone Coder 0.36.7
  271.     for (/*unsigned*/ i = 0; i < size; i++)
  272.     {
  273.         crc ^= data[i];
  274.     }
  275.  
  276.     if (!*data && size == 19 && (data[1] == 0 || data[1] == 3))
  277.     {
  278.         for (i = 0; i < 10; i++)
  279.         {
  280.             prg[i] = (data[i + 2] < ' ' || data[i + 2] >= 0x80) ? '?' : char(data[i + 2]);
  281.         }
  282.         prg[10] = 0;
  283.         for (i = 9; i && prg[i] == ' '; prg[i--] = 0);
  284.         sprintf(dst, "%s: \"%s\" %d,%d", data[1] ? "Bytes" : "Program", prg,
  285.             *(const unsigned short*)(data + 14), *(const unsigned short*)(data + 12));
  286.     }
  287.     else if (*data == 0xFF)
  288.     {
  289.         sprintf(dst, "data block, %u bytes", size - 2);
  290.     }
  291.     else
  292.     {
  293.         sprintf(dst, "#%02X block, %u bytes", *data, size - 2);
  294.     }
  295.     sprintf(dst + strlen(dst), ", crc %s", crc ? "bad" : "ok");
  296. }
  297.  
  298. static bool alloc_infocell()
  299. {
  300.     TAPEINFO *tmp = (TAPEINFO*)realloc(tapeinfo, (tape_infosize + 1) * sizeof(TAPEINFO));
  301.     if (!tmp)
  302.     {
  303.         return false;
  304.     }
  305.     tapeinfo = tmp;
  306.     tapeinfo[tape_infosize].pos = tape_imagesize;
  307.     appendable = 0;
  308.     return true;
  309. }
  310.  
  311. static bool named_cell(const void *nm, unsigned sz = 0)
  312. {
  313.     if (!alloc_infocell())
  314.         return false;
  315.  
  316.     const size_t n = _countof(tapeinfo[tape_infosize].desc) - 1;
  317.     size_t len = min(n, sz ? sz : strlen((const char*)nm));
  318.     strncpy(tapeinfo[tape_infosize].desc, (const char*)nm, len);
  319.     tapeinfo[tape_infosize].desc[len] = 0;
  320.     tape_infosize++;
  321.     return true;
  322. }
  323.  
  324. int readTAP()
  325. {
  326.     unsigned char *ptr = snbuf;
  327.     closetape();
  328.     while(ptr < snbuf + snapsize)
  329.     {
  330.         unsigned size = *(unsigned short*)ptr; ptr += 2;
  331.         if (!size)
  332.         {
  333.             break;
  334.         }
  335.         alloc_infocell();
  336.         desc(ptr, size, tapeinfo[tape_infosize].desc);
  337.         tape_infosize++;
  338.         makeblock(ptr, size, 2168U, 667U, 735U, 855U, 1710U, (*ptr < 4) ? 8064U : 3220U, 1000U);
  339.         ptr += size;
  340.     }
  341.     find_tape_sizes();
  342.     return (ptr == snbuf + snapsize);
  343. }
  344.  
  345. #pragma pack(push, 1)
  346. struct TCswHdr
  347. {
  348.     char Signature[22];
  349.     u8 Term;
  350.     u8 VerMajor;
  351.     u8 VerMinor;
  352.     union
  353.     {
  354.         struct
  355.         {
  356.             u16 SampleRate;
  357.             u8 CompressionType;
  358.             u8 Flags;
  359.             u8 Reserved[3];
  360. //          u8 Data[];
  361.             u8 Data[0];         //NEDOREPO
  362.         } Ver1;
  363.  
  364.         struct
  365.         {
  366.             u32 SampleRate;
  367.             u32 PulsesAfterDecompression;
  368.             u8 CompressionType;
  369.             u8 Flags;
  370.             u8 HeaderExtLen;
  371.             char EncAppDesc[16];
  372. //          u8 ExtHdr[];
  373.             u8 ExtHdr[0];       //NEDOREPO
  374.         } Ver2;
  375.     };
  376. };
  377. #pragma pack(pop)
  378.  
  379. int readCSW()
  380. {
  381.     closetape();
  382.     named_cell("CSW tape image");
  383.  
  384.     const TCswHdr *CswHdr = (TCswHdr *)snbuf;
  385.     u8 CompType;
  386.     u32 SampleRate;
  387.     u8 Flags;
  388.     u32 DataOffset;
  389.     u32 PulsesCount;
  390.     switch(CswHdr->VerMajor)
  391.     {
  392.     case 1:
  393.         CompType = CswHdr->Ver1.CompressionType;
  394.         SampleRate = CswHdr->Ver1.SampleRate;
  395.         Flags = CswHdr->Ver1.Flags;
  396.         DataOffset = offsetof(TCswHdr, Ver1.Data);
  397.         PulsesCount = snapsize - 0x18; // ═хяюэ Єэр  ъюэёЄрэЄр
  398.         break;
  399.  
  400.     case 2:
  401.         CompType = CswHdr->Ver2.CompressionType;
  402.         SampleRate = CswHdr->Ver2.SampleRate;
  403.         Flags = CswHdr->Ver2.Flags;
  404.         DataOffset = offsetof(TCswHdr, Ver2.ExtHdr) + CswHdr->Ver2.HeaderExtLen;
  405.         PulsesCount = CswHdr->Ver2.PulsesAfterDecompression;
  406.         break;
  407.  
  408.     default: // unknown csw version
  409.         return 0;
  410.     }
  411.  
  412.     u32 UncompressedSize = snapsize;
  413.     switch(CompType)
  414.     {
  415.     case 2: // Z-RLE
  416.     {
  417.         if (!temp.ZlibSupport)
  418.             return 0;
  419.         static const size_t out_sz = sizeof(snbuf);
  420.         void *out = malloc(out_sz);
  421.         if (!out)
  422.             return 0;
  423.  
  424.         z_stream strm;
  425.         strm.zalloc = Z_NULL;
  426.         strm.zfree = Z_NULL;
  427.         strm.opaque = Z_NULL;
  428.         strm.avail_in = snapsize - DataOffset;
  429.         strm.next_in = snbuf + DataOffset;
  430.         int ret = inflateInit__p(&strm, ZLIB_VERSION, sizeof(strm));
  431.         if (ret != Z_OK)
  432.         {
  433.             free(out);
  434.             return 0;
  435.         }
  436.  
  437.         strm.avail_out = out_sz;
  438.         strm.next_out = (Byte *)out;
  439.         ret = inflate_p(&strm, Z_FINISH);
  440.         if (ret < 0)
  441.         {
  442.             free(out);
  443.             inflateEnd_p(&strm);
  444.             return 0;
  445.         }
  446.         UncompressedSize = out_sz - strm.avail_out;
  447.         memcpy(snbuf + DataOffset, out, UncompressedSize);
  448.         UncompressedSize += DataOffset;
  449.         free(out);
  450.         inflateEnd_p(&strm);
  451.     }
  452.     case 1: // RLE
  453.         break;
  454.  
  455.     default:
  456.         return 0; // unknown compression type
  457.     }
  458.  
  459.     unsigned rate = Z80FQ / SampleRate; // usually 3.5mhz / 44khz
  460.     if (!rate)
  461.         return 0;
  462.  
  463.     if (!(Flags & 1))
  464.     {
  465.         PulsesCount++;
  466.     }
  467.     PulsesCount++; // ─юяюыэшхЄы№э√щ шэЄхЁтры (ярєчр) т ъюэЎх CSW
  468.  
  469.     reserve(PulsesCount);
  470.  
  471.     if (!(Flags & 1))
  472.         tape_image[tape_imagesize++] = find_pulse(1);
  473.  
  474.     unsigned i = 0;
  475.     for (unsigned char *ptr = snbuf + DataOffset; ptr < snbuf + UncompressedSize; i++)
  476.     {
  477.         unsigned len = *ptr++ * rate;
  478.         if (!len)
  479.         {
  480.             len = *(unsigned*)ptr * rate;
  481.             ptr += 4;
  482.         }
  483.         tape_image[tape_imagesize++] = find_pulse(len);
  484.     }
  485.  
  486.     tape_image[tape_imagesize++] = find_pulse(Z80FQ / 10);
  487.     find_tape_sizes();
  488.     return 1;
  489. }
  490.  
  491. static void create_appendable_block()
  492. {
  493.     if (!tape_infosize || appendable)
  494.     {
  495.         return;
  496.     }
  497.     named_cell("set of pulses");
  498.     appendable = 1;
  499. }
  500.  
  501. static void parse_hardware(const unsigned char *ptr)
  502. {
  503.     unsigned n = *ptr++;
  504.     if (!n)
  505.     {
  506.         return;
  507.     }
  508.     named_cell("- HARDWARE TYPE ");
  509.     static char ids[] =
  510.         "computer\0"
  511.         "ZX Spectrum 16k\0"
  512.         "ZX Spectrum 48k, Plus\0"
  513.         "ZX Spectrum 48k ISSUE 1\0"
  514.         "ZX Spectrum 128k (Sinclair)\0"
  515.         "ZX Spectrum 128k +2 (Grey case)\0"
  516.         "ZX Spectrum 128k +2A, +3\0"
  517.         "Timex Sinclair TC-2048\0"
  518.         "Timex Sinclair TS-2068\0"
  519.         "Pentagon 128\0"
  520.         "Sam Coupe\0"
  521.         "Didaktik M\0"
  522.         "Didaktik Gama\0"
  523.         "ZX-81 or TS-1000 with  1k RAM\0"
  524.         "ZX-81 or TS-1000 with 16k RAM or more\0"
  525.         "ZX Spectrum 128k, Spanish version\0"
  526.         "ZX Spectrum, Arabic version\0"
  527.         "TK 90-X\0"
  528.         "TK 95\0"
  529.         "Byte\0"
  530.         "Elwro\0"
  531.         "ZS Scorpion\0"
  532.         "Amstrad CPC 464\0"
  533.         "Amstrad CPC 664\0"
  534.         "Amstrad CPC 6128\0"
  535.         "Amstrad CPC 464+\0"
  536.         "Amstrad CPC 6128+\0"
  537.         "Jupiter ACE\0"
  538.         "Enterprise\0"
  539.         "Commodore 64\0"
  540.         "Commodore 128\0"
  541.         "\0"
  542.         "ext. storage\0"
  543.         "Microdrive\0"
  544.         "Opus Discovery\0"
  545.         "Disciple\0"
  546.         "Plus-D\0"
  547.         "Rotronics Wafadrive\0"
  548.         "TR-DOS (BetaDisk)\0"
  549.         "Byte Drive\0"
  550.         "Watsford\0"
  551.         "FIZ\0"
  552.         "Radofin\0"
  553.         "Didaktik disk drives\0"
  554.         "BS-DOS (MB-02)\0"
  555.         "ZX Spectrum +3 disk drive\0"
  556.         "JLO (Oliger) disk interface\0"
  557.         "FDD3000\0"
  558.         "Zebra disk drive\0"
  559.         "Ramex Millenia\0"
  560.         "Larken\0"
  561.         "\0"
  562.         "ROM/RAM type add-on\0"
  563.         "Sam Ram\0"
  564.         "Multiface\0"
  565.         "Multiface 128k\0"
  566.         "Multiface +3\0"
  567.         "MultiPrint\0"
  568.         "MB-02 ROM/RAM expansion\0"
  569.         "\0"
  570.         "sound device\0"
  571.         "Classic AY hardware\0"
  572.         "Fuller Box AY sound hardware\0"
  573.         "Currah microSpeech\0"
  574.         "SpecDrum\0"
  575.         "AY ACB stereo; Melodik\0"
  576.         "AY ABC stereo\0"
  577.         "\0"
  578.         "joystick\0"
  579.         "Kempston\0"
  580.         "Cursor, Protek, AGF\0"
  581.         "Sinclair 2\0"
  582.         "Sinclair 1\0"
  583.         "Fuller\0"
  584.         "\0"
  585.         "mice\0"
  586.         "AMX mouse\0"
  587.         "Kempston mouse\0"
  588.         "\0"
  589.         "other controller\0"
  590.         "Trickstick\0"
  591.         "ZX Light Gun\0"
  592.         "Zebra Graphics Tablet\0"
  593.         "\0"
  594.         "serial port\0"
  595.         "ZX Interface 1\0"
  596.         "ZX Spectrum 128k\0"
  597.         "\0"
  598.         "parallel port\0"
  599.         "Kempston S\0"
  600.         "Kempston E\0"
  601.         "ZX Spectrum 128k +2A, +3\0"
  602.         "Tasman\0"
  603.         "DK'Tronics\0"
  604.         "Hilderbay\0"
  605.         "INES Printerface\0"
  606.         "ZX LPrint Interface 3\0"
  607.         "MultiPrint\0"
  608.         "Opus Discovery\0"
  609.         "Standard 8255 chip with ports 31,63,95\0"
  610.         "\0"
  611.         "printer\0"
  612.         "ZX Printer, Alphacom 32 & compatibles\0"
  613.         "Generic Printer\0"
  614.         "EPSON Compatible\0"
  615.         "\0"
  616.         "modem\0"
  617.         "VTX 5000\0"
  618.         "T/S 2050 or Westridge 2050\0"
  619.         "\0"
  620.         "digitaiser\0"
  621.         "RD Digital Tracer\0"
  622.         "DK'Tronics Light Pen\0"
  623.         "British MicroGraph Pad\0"
  624.         "\0"
  625.         "network adapter\0"
  626.         "ZX Interface 1\0"
  627.         "\0"
  628.         "keyboard / keypad\0"
  629.         "Keypad for ZX Spectrum 128k\0"
  630.         "\0"
  631.         "AD/DA converter\0"
  632.         "Harley Systems ADC 8.2\0"
  633.         "Blackboard Electronics\0"
  634.         "\0"
  635.         "EPROM Programmer\0"
  636.         "Orme Electronics\0"
  637.         "\0"
  638.         "\0";
  639.     for (unsigned i = 0; i < n; i++)
  640.     {
  641.         unsigned char type_n = *ptr++;
  642.         unsigned char id_n = *ptr++;
  643.         unsigned char value_n = *ptr++;
  644.         const char *type = ids, *id, *value;
  645.         unsigned j; //Alone Coder 0.36.7
  646.         for (/*unsigned*/ j = 0; j < type_n; j++)
  647.         {
  648.             if (!*type)
  649.             {
  650.                 break;
  651.             }
  652.             while(*(const short*)type)
  653.             {
  654.                 type++;
  655.             }
  656.             type += 2;
  657.         }
  658.         if (!*type)
  659.         {
  660.             type = id = "??";
  661.         }
  662.         else
  663.         {
  664.             id = type + strlen(type) + 1;
  665.             for (j = 0; j < id_n; j++)
  666.             {
  667.                 if (!*id)
  668.                 {
  669.                     id = "??";
  670.                     break;
  671.                 }
  672.                 id += strlen(id) + 1;
  673.             }
  674.         }
  675.         switch(value_n)
  676.         {
  677.         case 0: value = "compatible with"; break;
  678.         case 1: value = "uses"; break;
  679.         case 2: value = "compatible, but doesn't use"; break;
  680.         case 3: value = "incompatible with"; break;
  681.         default: value = "??";
  682.         }
  683.         char bf[512];
  684.         sprintf(bf, "%s %s: %s", value, type, id);
  685.         named_cell(bf);
  686.     }
  687.     named_cell("-");
  688. }
  689.  
  690. static inline bool IsPowerOfTwo(unsigned x)
  691. {
  692.     // x will check if x == 0 and !(x & (x - 1)) will check if x is a power of 2 or not
  693.     return x != 0 && (x & (x - 1)) == 0;
  694. }
  695.  
  696. int readTZX()
  697. {
  698.     unsigned char *ptr = snbuf;
  699.     closetape();
  700.     u32 pause;
  701.     unsigned t0;
  702.     unsigned char pl, last;
  703.     unsigned char *end;
  704.     char *p;
  705.     unsigned loop_n = 0, loop_p = 0;
  706.     unsigned TzxVer = (unsigned(ptr[8]) << 8U) | unsigned(ptr[9]);
  707.     char nm[512];
  708.  
  709.     ptr += 10; // ╧Ёюяєёъ чруюыютър
  710.  
  711.     while(ptr < snbuf + snapsize)
  712.     {
  713.         unsigned BlkId = *ptr++;
  714.         switch(BlkId)
  715.         {
  716.         case 0x10: // normal block
  717.         {
  718.             alloc_infocell();
  719.             unsigned size = *(unsigned short*)(ptr + 2);
  720.             pause = *(unsigned short*)ptr;
  721.             ptr += 4;
  722.             desc(ptr, size, tapeinfo[tape_infosize].desc);
  723.             tape_infosize++;
  724.             makeblock(ptr, size, 2168U, 667U, 735U, 855U, 1710U,
  725.                 (*ptr < 4) ? 8064U : 3220U, pause);
  726.             ptr += size;
  727.         }
  728.             break;
  729.         case 0x11: // turbo block
  730.         {
  731.             alloc_infocell();
  732.             unsigned size = 0xFFFFFF & *(unsigned*)(ptr + 0x0F);
  733.             desc(ptr + 0x12, size, tapeinfo[tape_infosize].desc);
  734.             tape_infosize++;
  735.             makeblock(ptr + 0x12, size,
  736.                 *(unsigned short*)ptr, *(unsigned short*)(ptr + 2),
  737.                 *(unsigned short*)(ptr + 4), *(unsigned short*)(ptr + 6),
  738.                 *(unsigned short*)(ptr + 8), *(unsigned short*)(ptr + 10),
  739.                 *(unsigned short*)(ptr + 13), ptr[12]);
  740.             // todo: test used bits - ptr+12
  741.             ptr += size + 0x12;
  742.         }
  743.             break;
  744.         case 0x12: // pure tone
  745.         {
  746.             create_appendable_block();
  747.             pl = u8(find_pulse(*(unsigned short*)ptr));
  748.             unsigned n = *(unsigned short*)(ptr + 2);
  749.             reserve(n);
  750.             for (unsigned i = 0; i < n; i++)
  751.             {
  752.                 tape_image[tape_imagesize++] = pl;
  753.             }
  754.             ptr += 4;
  755.         }
  756.             break;
  757.         case 0x13: // sequence of pulses of different lengths
  758.         {
  759.             create_appendable_block();
  760.             unsigned n = *ptr++;
  761.             reserve(n);
  762.             for (unsigned i = 0; i < n; i++, ptr += 2)
  763.             {
  764.                 tape_image[tape_imagesize++] = find_pulse(*(unsigned short*)ptr);
  765.             }
  766.         }
  767.             break;
  768.         case 0x14: // pure data block
  769.         {
  770.             create_appendable_block();
  771.             unsigned size = 0xFFFFFF & *(unsigned*)(ptr + 7);
  772.             makeblock(ptr + 0x0A, size, 0, 0, 0, *(unsigned short*)ptr,
  773.                 *(unsigned short*)(ptr + 2), -1U, *(unsigned short*)(ptr + 5), ptr[4]);
  774.             ptr += size + 0x0A;
  775.         }
  776.             break;
  777.         case 0x15: // direct recording
  778.         {
  779.             unsigned size = 0xFFFFFF & *(unsigned*)(ptr + 5);
  780.             t0 = *(unsigned short*)ptr;
  781.             pause = *(unsigned short*)(ptr + 2);
  782.             last = ptr[4];
  783.             named_cell("direct recording");
  784.             ptr += 8;
  785.             pl = 0;
  786.             unsigned n = 0;
  787.             for (unsigned i = 0; i < size; i++) // count number of pulses
  788.             {
  789.                 for (unsigned j = 0x80; j; j >>= 1)
  790.                 {
  791.                     if ((ptr[i] ^ pl) & j)
  792.                     {
  793.                         n++;
  794.                         pl ^= -1;
  795.                     }
  796.                 }
  797.             }
  798.             unsigned t = 0;
  799.             pl = 0;
  800.             reserve(n + 2);
  801.             for (unsigned i = 1; i < size; i++, ptr++) // find pulses
  802.             {
  803.                 for (unsigned j = 0x80; j; j >>= 1)
  804.                 {
  805.                     t += t0;
  806.                     if ((*ptr ^ pl) & j)
  807.                     {
  808.                         tape_image[tape_imagesize++] = find_pulse(t);
  809.                         pl ^= -1; t = 0;
  810.                     }
  811.                 }
  812.             }
  813.             // find pulses - last byte
  814.             for (unsigned j = 0x80; j != (unsigned char)(0x80 >> last); j >>= 1)
  815.             {
  816.                 t += t0;
  817.                 if ((*ptr ^ pl) & j)
  818.                 {
  819.                     tape_image[tape_imagesize++] = find_pulse(t);
  820.                     pl ^= -1; t = 0;
  821.                 }
  822.             }
  823.             ptr++;
  824.             tape_image[tape_imagesize++] = find_pulse(t); // last pulse ???
  825.             if (pause)
  826.             {
  827.                 tape_image[tape_imagesize++] = find_pulse(pause*(Z80FQ / 1000));
  828.             }
  829.         }
  830.             break;
  831.  
  832.         case 0x19: // generalized data block
  833.         {
  834. #pragma pack(push, 1)
  835.             struct TTzxBlk19
  836.             {
  837.                 u32 Size;
  838.                 u16 Pause; // Pause after this block(ms)
  839.                 u32 Totp; // Total number of symbols in pilot/sync block (can be 0)
  840.                 u8 Npp; // Maximum number of pulses per pilot/sync symbol
  841.                 u8 Asp; // Number of pilot/sync symbols in the alphabet table (0=256)
  842.                 u32 Totd; // Total number of symbols in data stream(can be 0)
  843.                 u8 Npd; // Maximum number of pulses per data symbol
  844.                 u8 Asd; // Number of data symbols in the alphabet table (0=256)
  845.             };
  846.             struct TSymDef
  847.             {
  848.                 u8 Flags;
  849.                 u16 PulseLen[]; // Array of pulse lengths (Npp / Npd)
  850.             };
  851.             struct TPrle
  852.             {
  853.                 u8 Symbol; // Symbol to be represented
  854.                 u16 RepCnt; // Number of repetitions
  855.             };
  856. #pragma pack(pop)
  857.             auto Blk = (const TTzxBlk19 *)ptr;
  858.             const unsigned Asp = Blk->Asp == 0 ? 256U : Blk->Asp;
  859.             const unsigned Asd = Blk->Asd == 0 ? 256U : Blk->Asd;
  860.  
  861.             named_cell("generalized data block");
  862.             auto Pause = Blk->Pause;
  863.  
  864.             auto SymDefp = (const TSymDef *)(Blk + 1); // └ыЇртшЄ яшыюЄ Єюэр
  865.             const auto SympSize = sizeof(TSymDef) + Blk->Npp * sizeof(*SymDefp->PulseLen); // ╨рчьхЁ ёшьтюыр т рыЇртшЄх яшыюЄ Єюэр
  866.             auto Prle = (const TPrle *)(((const u8 *)SymDefp) + Asp * SympSize); // ╤шьтюы√ яшыюЄ Єюэр
  867.  
  868.             unsigned n = 0;
  869.  
  870.             // ╧юфёўхЄ ўшёыр шьяєы№ёют т яшыюЄ Єюэх
  871.             for (unsigned i = 0; i < Blk->Totp; i++)
  872.             {
  873.                 auto Sym = Prle[i].Symbol; // ╤шьтюы рыЇртшЄр
  874.                 assert(Sym < Asp);
  875.  
  876.                 auto RepCnt = Prle[i].RepCnt; // ╫шёыю яютЄюЁют ёшьтюыр
  877.                 auto Symp = (const TSymDef *)(((const u8 *)SymDefp) + Sym * SympSize); // ╬яшёрэшх ёшьтюыр т рыЇртшЄх
  878.  
  879.                 unsigned PulseCnt = 0; // ╫шёыю шьяєы№ёют т юфэюь ёшьтюых рыЇртшЄр
  880.                 for (unsigned j = 0; j < Blk->Npp && Symp->PulseLen[j] != 0; j++)
  881.                 {
  882.                     PulseCnt++;
  883.                 }
  884.                 n += PulseCnt * RepCnt;
  885.             }
  886.  
  887.             auto Np = n;
  888.  
  889.             auto SymDefd = (const TSymDef *)(Prle + Blk->Totp); // └ыЇртшЄ фрээ√ї
  890.             const auto SymdSize = sizeof(TSymDef) + Blk->Npd * sizeof(*SymDefd->PulseLen); // ╨рчьхЁ ёшьтюыр т рыЇртшЄх фрээ√ї
  891.             auto Data = (const u8 *)(((const u8 *)SymDefd) + Asd * SymdSize); // ─рээ√х
  892.  
  893.             const auto Nb = unsigned(ceil(log2(float(Asd))));
  894.             assert(IsPowerOfTwo(Nb)); // ╧юффхЁцър Єюы№ъю ъюфшЁютрэш  ёю ёЄхяхэ№■ фтющъш (1,2,4,8 сшЄ эр ёшьтюы)
  895.  
  896.             unsigned BitMask = (1U << Nb) - 1U;
  897.  
  898.             const auto Ds = unsigned(ceil(Nb * Blk->Totd / 8));
  899.  
  900.             // ╧юфёўхЄ ўшёыр шьяєы№ёют т фрээ√ї
  901.             for (unsigned i = 0; i < Ds; i++)
  902.             {
  903.                 auto Bits = Data[i];
  904.                 unsigned PulseCnt = 0; // ╫шёыю шьяєы№ёют т юфэюь ёшьтюых рыЇртшЄр
  905.  
  906.                 // ╧хЁхъюшЁютрэшх сшЄют т ёшьтюы√
  907.                 for (unsigned k = 0; k <= 8 - Nb; k++)
  908.                 {
  909.                     Bits = rol8(Bits, u8(Nb));
  910.                     auto Sym = unsigned(Bits & BitMask); // ╤шьтюы рыЇртшЄр
  911.                     assert(Sym < Asd);
  912.  
  913.                     auto Symd = (const TSymDef *)(((const u8 *)SymDefd) + Sym * SymdSize); // ╬яшёрэшх ёшьтюыр т рыЇртшЄх
  914.  
  915.                     for (unsigned j = 0; j < Blk->Npd && Symd->PulseLen[j] != 0; j++)
  916.                     {
  917.                         PulseCnt++;
  918.                     }
  919.                 }
  920.                 n += PulseCnt;
  921.             }
  922.  
  923.             if (Pause != 0)
  924.             {
  925.                 n++;
  926.             }
  927.  
  928.             reserve(n); // ┬√фхыхэшх ярь Єш яюф n шьяєы№ёют
  929.  
  930.             const auto MaxTapeImageSize = tape_imagesize + n;
  931.  
  932.             auto Npp = 0U;
  933.             // ├хэхЁрЎш  шьяєы№ёют яшыюЄ Єюэр
  934.             for (unsigned i = 0; i < Blk->Totp; i++)
  935.             {
  936.                 auto Sym = Prle[i].Symbol; // ╤шьтюы рыЇртшЄр
  937.                 assert(Sym < Asp);
  938.  
  939.                 auto RepCnt = Prle[i].RepCnt; // ╫шёыю яютЄюЁют ёшьтюыр
  940.                 auto Symp = (const TSymDef *)(((const u8 *)SymDefp) + Sym * SympSize); // ╬яшёрэшх ёшьтюыр т рыЇртшЄх
  941.  
  942.                 unsigned Flags = Symp->Flags & 3U;
  943.                 for (unsigned j = 0; j < Blk->Npp && Symp->PulseLen[j] != 0; j++)
  944.                 {
  945.                     auto t = Symp->PulseLen[j];
  946.                     for (unsigned k = 0; k < RepCnt; k++)
  947.                     {
  948.                         tape_image[tape_imagesize++] = find_pulse(t, Flags);
  949.                         Flags = 0;
  950.                         assert(tape_imagesize <= MaxTapeImageSize);
  951.                         Npp++;
  952.                     }
  953.                 }
  954.             }
  955.  
  956.             assert(Npp == Np);
  957.  
  958.             // ├хэхЁрЎш  шьяєы№ёют фрээ√ї
  959.             for (unsigned i = 0; i < Ds; i++)
  960.             {
  961.                 auto Bits = Data[i];
  962.  
  963.                 // ╧хЁхъюшЁютрэшх сшЄют т ёшьтюы√
  964.                 for (unsigned k = 0; k <= 8 - Nb; k++)
  965.                 {
  966.                     Bits = rol8(Bits, u8(Nb));
  967.                     auto Sym = unsigned(Bits & BitMask); // ╤шьтюы рыЇртшЄр
  968.                     assert(Sym < Asd);
  969.  
  970.                     auto Symd = (const TSymDef *)(((const u8 *)SymDefd) + Sym * SymdSize); // ╬яшёрэшх ёшьтюыр т рыЇртшЄх
  971.  
  972.                     unsigned Flags = Symd->Flags & 3U;
  973.                     for (unsigned j = 0; j < Blk->Npd && Symd->PulseLen[j] != 0; j++)
  974.                     {
  975.                         auto t = Symd->PulseLen[j];
  976.                         tape_image[tape_imagesize++] = find_pulse(t, Flags);
  977.                         Flags = 0;
  978.                         assert(tape_imagesize <= MaxTapeImageSize);
  979.                     }
  980.                 }
  981.             }
  982.  
  983.             if (Pause != 0)
  984.             {
  985.                 tape_image[tape_imagesize++] = find_pulse(Pause * (Z80FQ / 1000U));
  986.                 assert(tape_imagesize <= MaxTapeImageSize);
  987.             }
  988.  
  989.             ptr += Blk->Size + sizeof(Blk->Size);
  990.         }
  991.         break;
  992.  
  993.         case 0x20: // pause (silence) or 'stop the tape' command
  994.             pause = *(unsigned short*)ptr;
  995.             if (pause != 0)
  996.             {
  997.                 sprintf(nm, "pause %u ms", unsigned(pause));
  998.             }
  999.             else
  1000.             {
  1001.                 sprintf(nm, "stop the tape");
  1002.             }
  1003.             named_cell(nm);
  1004.             reserve(2); ptr += 2;
  1005.             if (!pause)
  1006.             { // at least 1ms pulse as specified in TZX 1.13
  1007.                 tape_image[tape_imagesize++] = find_pulse(Z80FQ / 1000);
  1008.                 pause = UINT32_MAX;
  1009.             }
  1010.             else
  1011.             {
  1012.                 pause *= Z80FQ / 1000;
  1013.             }
  1014.             tape_image[tape_imagesize++] = find_pulse(pause);
  1015.             break;
  1016.         case 0x21: // group start
  1017.         {
  1018.             unsigned n = *ptr++;
  1019.             named_cell(ptr, n); ptr += n;
  1020.             appendable = 1;
  1021.         }
  1022.             break;
  1023.         case 0x22: // group end
  1024.             break;
  1025.         case 0x23: // jump to block
  1026.             named_cell("* jump"); ptr += 2;
  1027.             break;
  1028.         case 0x24: // loop start
  1029.             loop_n = *(unsigned short*)ptr; loop_p = tape_imagesize; ptr += 2;
  1030.             break;
  1031.         case 0x25: // loop end
  1032.         {
  1033.             if (!loop_n)
  1034.             {
  1035.                 break;
  1036.             }
  1037.             unsigned size = tape_imagesize - loop_p;
  1038.             reserve((loop_n - 1) * size);
  1039.             for (unsigned i = 1; i < loop_n; i++)
  1040.             {
  1041.                 memcpy(tape_image + loop_p + i * size, tape_image + loop_p, size);
  1042.             }
  1043.             tape_imagesize += (loop_n - 1) * size;
  1044.             loop_n = 0;
  1045.         }
  1046.             break;
  1047.         case 0x26: // call
  1048.             named_cell("* call"); ptr += 2 + 2 * *(unsigned short*)ptr;
  1049.             break;
  1050.         case 0x27: // ret
  1051.             named_cell("* return");
  1052.             break;
  1053.         case 0x28: // select block
  1054.         {
  1055.             int l = _countof(nm);
  1056.             l -= sprintf(nm, "* choice: ");
  1057.             unsigned n = ptr[2];
  1058.             p = (char*)ptr + 3;
  1059.  
  1060.             for (unsigned i = 0; i < n; i++)
  1061.             {
  1062.                 unsigned size = *(unsigned char*)(p + 2);
  1063.                 l -= size;
  1064.                 if (i)
  1065.                 {
  1066.                     l -= 4;
  1067.                 }
  1068.  
  1069.                 if (l >= 0)
  1070.                 {
  1071.                     if (i)
  1072.                     {
  1073.                         strcat(nm, " / ");
  1074.                     }
  1075.  
  1076.                     char *q = nm + strlen(nm);
  1077.                     memcpy(q, p + 3, size);
  1078.                     q[size] = 0;
  1079.                 }
  1080.  
  1081.                 p += size + 3;
  1082.             }
  1083.             named_cell(nm);
  1084.             ptr += 2 + *(unsigned short*)ptr;
  1085.         }
  1086.         break;
  1087.         case 0x2A: // stop if 48k
  1088.             named_cell("* stop if 48K");
  1089.             ptr += 4 + *(unsigned*)ptr;
  1090.             break;
  1091.         case 0x30: // text description
  1092.         {
  1093.             unsigned n = *ptr++;
  1094.             named_cell(ptr, n); ptr += n;
  1095.             appendable = 1;
  1096.         }
  1097.             break;
  1098.         case 0x31: // message block
  1099.             named_cell("- MESSAGE BLOCK ");
  1100.             end = ptr + 2 + ptr[1]; pl = *end; *end = 0;
  1101.             for (p = (char*)ptr + 2; p < (const char*)end; p++)
  1102.             {
  1103.                 if (*p == 0x0D)
  1104.                 {
  1105.                     *p = 0;
  1106.                 }
  1107.             }
  1108.             for (p = (char*)ptr + 2; p < (const char*)end; p += strlen(p) + 1)
  1109.             {
  1110.                 named_cell(p);
  1111.             }
  1112.             *end = pl; ptr = end;
  1113.             named_cell("-");
  1114.             break;
  1115.         case 0x32: // archive info
  1116.             named_cell("- ARCHIVE INFO ");
  1117.             p = (char*)ptr + 3;
  1118.             for (unsigned i = 0; i < ptr[2]; i++)
  1119.             {
  1120.                 const char *info;
  1121.                 switch(*p++)
  1122.                 {
  1123.                 case 0: info = "Title"; break;
  1124.                 case 1: info = "Publisher"; break;
  1125.                 case 2: info = "Author"; break;
  1126.                 case 3: info = "Year"; break;
  1127.                 case 4: info = "Language"; break;
  1128.                 case 5: info = "Type"; break;
  1129.                 case 6: info = "Price"; break;
  1130.                 case 7: info = "Protection"; break;
  1131.                 case 8: info = "Origin"; break;
  1132.                 case -1:info = "Comment"; break;
  1133.                 default:info = "info"; break;
  1134.                 }
  1135.                 unsigned size = *(BYTE*)p + 1U;
  1136.                 char tmp = p[size]; p[size] = 0;
  1137.                 sprintf(nm, "%s: %s", info, p + 1);
  1138.                 p[size] = tmp; p += size;
  1139.                 named_cell(nm);
  1140.             }
  1141.             named_cell("-");
  1142.             ptr += 2 + *(unsigned short*)ptr;
  1143.             break;
  1144.         case 0x33: // hardware type
  1145.             parse_hardware(ptr);
  1146.             ptr += 1 + 3 * *ptr;
  1147.             break;
  1148.         case 0x34: // emulation info
  1149.             named_cell("* emulation info"); ptr += 8;
  1150.             break;
  1151.         case 0x35: // custom info
  1152.             if (!memcmp(ptr, "POKEs           ", 16))
  1153.             {
  1154.                 named_cell("- POKEs block ");
  1155.                 named_cell(ptr + 0x15, ptr[0x14]);
  1156.                 p = (char*)ptr + 0x15 + ptr[0x14];
  1157.                 unsigned n = *(unsigned char*)p++;
  1158.                 for (unsigned i = 0; i < n; i++)
  1159.                 {
  1160.                     named_cell(p + 1, *(unsigned char*)p);
  1161.                     p += *p + 1;
  1162.                     unsigned t = *(unsigned char*)p++;
  1163.                     strcpy(nm, "POKE ");
  1164.                     for (unsigned j = 0; j < t; j++)
  1165.                     {
  1166.                         sprintf(nm + strlen(nm), "%d,", *(unsigned short*)(p + 1));
  1167.                         if (*p & 0x10)
  1168.                         {
  1169.                             sprintf(nm + strlen(nm), "nn");
  1170.                         }
  1171.                         else
  1172.                         {
  1173.                             sprintf(nm + strlen(nm), "%d", *(unsigned char*)(p + 3));
  1174.                         }
  1175.                         if (!(*p & 0x08))
  1176.                         {
  1177.                             sprintf(nm + strlen(nm), "(page %d)", *p & 7);
  1178.                         }
  1179.                         strcat(nm, "; "); p += 5;
  1180.                     }
  1181.                     named_cell(nm);
  1182.                 }
  1183.                 *(unsigned*)nm = '-';
  1184.             }
  1185.             else
  1186.             {
  1187.                 sprintf(nm, "* custom info: %s", ptr);
  1188.                 nm[15 + 16] = 0;
  1189.             }
  1190.             named_cell(nm);
  1191.             ptr += 0x14 + *(unsigned*)(ptr + 0x10);
  1192.             break;
  1193.         case 0x40: // snapshot
  1194.             named_cell("* snapshot"); ptr += 4 + (0xFFFFFF & *(unsigned*)(ptr + 1));
  1195.             break;
  1196.         default:
  1197.             if (TzxVer >= 0x10A)
  1198.             {
  1199.                 // ┬ эрўрых ърцфюую эхёЄрэфрЁЄэюую сыюър шфхЄ хую фышэр
  1200.                 sprintf(nm, "* unknown id: 0x%X", ptr[-1]);
  1201.                 named_cell(nm);
  1202.                 u32 Skip = *(u32 *)ptr;
  1203.                 ptr += Skip + sizeof(u32);
  1204.             }
  1205.             else
  1206.             {
  1207.                 ptr += snapsize;
  1208.             }
  1209.         }
  1210.     }
  1211.     for (unsigned i = 0; i < tape_infosize; i++)
  1212.     {
  1213.         if (*(short*)tapeinfo[i].desc == WORD2('*', ' '))
  1214.         {
  1215.             if (strlen(tapeinfo[i].desc) < _countof(tapeinfo[i].desc) - sizeof(" [UNSUPPORTED]"))
  1216.             {
  1217.                 strcat(tapeinfo[i].desc, " [UNSUPPORTED]");
  1218.             }
  1219.             else
  1220.             {
  1221.                 strcpy(tapeinfo[i].desc + _countof(tapeinfo[i].desc) - sizeof(" [UNSUPPORTED]"), " [UNSUPPORTED]");
  1222.             }
  1223.         }
  1224.         if (*tapeinfo[i].desc == '-')
  1225.         {
  1226.             while(strlen(tapeinfo[i].desc) < sizeof(tapeinfo[i].desc) - 1)
  1227.             {
  1228.                 strcat(tapeinfo[i].desc, "-");
  1229.             }
  1230.         }
  1231.     }
  1232.     if (tape_imagesize && tape_pulse[tape_image[tape_imagesize - 1]] < Z80FQ / 10)
  1233.     {
  1234.         // small pause [rqd for 3ddeathchase]
  1235.         reserve(1);
  1236.         tape_image[tape_imagesize++] = find_pulse(Z80FQ / 10);
  1237.     }
  1238.     find_tape_sizes();
  1239.     return ptr == snbuf + snapsize;
  1240. }
  1241.  
  1242. unsigned char tape_bit() // used in io.cpp & sound.cpp
  1243. {
  1244.     __int64 cur = comp.t_states + cpu.t;
  1245.     if (cur < comp.tape.edge_change)
  1246.     {
  1247.         return (unsigned char)comp.tape.tape_bit;
  1248.     }
  1249.     while(comp.tape.edge_change < cur)
  1250.     {
  1251.         if (!temp.sndblock)
  1252.         {
  1253.             unsigned t = (unsigned)(comp.tape.edge_change - comp.t_states - temp.cpu_t_at_frame_start);
  1254.             if ((int)t >= 0)
  1255.             {
  1256.                 unsigned tape_in = unsigned(conf.sound.micin_vol) & comp.tape.tape_bit;
  1257.                 comp.tape.sound.update(t, tape_in, tape_in);
  1258.             }
  1259.         }
  1260.         unsigned pulse;
  1261.         if (comp.tape.play_pointer == comp.tape.end_of_tape ||
  1262.             (pulse = tape_pulse[*comp.tape.play_pointer++]) == UINT32_MAX)
  1263.         {
  1264.             stop_tape();
  1265.         }
  1266.         else
  1267.         {
  1268.             unsigned Flags = (pulse >> 30) & 3;
  1269.             switch(Flags)
  1270.             {
  1271.             case 0: comp.tape.tape_bit ^= -1U; break; // opposite to the current level(make an edge, as usual) - default
  1272.             case 1: break; // same as the current level(no edge - prolongs the previous pulse)
  1273.             case 2: comp.tape.tape_bit = 0; break; // force low level
  1274.             case 3: comp.tape.tape_bit |= -1U; break; // force high level
  1275.             }
  1276.             comp.tape.edge_change += pulse & tape_pulse_mask;
  1277.         }
  1278.     }
  1279.     return (unsigned char)comp.tape.tape_bit;
  1280. }
  1281.  
  1282. void fast_tape()
  1283. {
  1284.     unsigned char *ptr = am_r(cpu.pc);
  1285.     unsigned p = *(unsigned*)ptr;
  1286.     if (p == WORD4(0x3D, 0x20, 0xFD, 0xA7))
  1287.     { // dec a:jr nz,$-1
  1288.         cpu.t += ((unsigned char)(cpu.a - 1)) * 16; cpu.a = 1;
  1289.         return;
  1290.     }
  1291.     if ((unsigned short)p == WORD2(0x10, 0xFE))
  1292.     { // djnz $
  1293.         cpu.t += ((unsigned char)(cpu.b - 1)) * 13; cpu.b = 1;
  1294.         return;
  1295.     }
  1296.     if ((unsigned short)p == WORD2(0x3D, 0xC2) && (cpu.pc & 0xFFFF) == (p >> 16))
  1297.     { // dec a:jp nz,$-1
  1298.         cpu.t += ((unsigned char)(cpu.a - 1)) * 14; cpu.a = 1;
  1299.         return;
  1300.     }
  1301.     if ((p | WORD4(0, 0, 0, 0xFF)) == WORD4(0x04, 0xC8, 0x3E, 0xFF))
  1302.     {
  1303.         if (*(unsigned*)(ptr + 4) == WORD4(0xDB, 0xFE, 0x1F, 0xD0) &&
  1304.             *(unsigned*)(ptr + 8) == WORD4(0xA9, 0xE6, 0x20, 0x28) && ptr[12] == 0xF3)
  1305.         { // find edge (rom routine)
  1306.             for (;;)
  1307.             {
  1308.                 if (cpu.b == 0xFF)
  1309.                 {
  1310.                     return;
  1311.                 }
  1312.                 if ((tape_bit() ? 0x20 : 0) ^ (cpu.c & 0x20))
  1313.                 {
  1314.                     return;
  1315.                 }
  1316.                 cpu.b++; cpu.t += 59;
  1317.             }
  1318.         }
  1319.         if (*(unsigned*)(ptr + 4) == WORD4(0xDB, 0xFE, 0xCB, 0x1F) &&
  1320.             *(unsigned*)(ptr + 8) == WORD4(0xA9, 0xE6, 0x20, 0x28) && ptr[12] == 0xF3)
  1321.         { // rra,ret nc => rr a (popeye2)
  1322.             for (;;)
  1323.             {
  1324.                 if (cpu.b == 0xFF)
  1325.                 {
  1326.                     return;
  1327.                 }
  1328.                 if ((tape_bit() ^ cpu.c) & 0x20)
  1329.                 {
  1330.                     return;
  1331.                 }
  1332.                 cpu.b++; cpu.t += 58;
  1333.             }
  1334.         }
  1335.         if (*(unsigned*)(ptr + 4) == WORD4(0xDB, 0xFE, 0x1F, 0x00) &&
  1336.             *(unsigned*)(ptr + 8) == WORD4(0xA9, 0xE6, 0x20, 0x28) && ptr[12] == 0xF3)
  1337.         { // ret nc nopped (some bleep loaders)
  1338.             for (;;)
  1339.             {
  1340.                 if (cpu.b == 0xFF)
  1341.                 {
  1342.                     return;
  1343.                 }
  1344.                 if ((tape_bit() ^ cpu.c) & 0x20)
  1345.                 {
  1346.                     return;
  1347.                 }
  1348.                 cpu.b++; cpu.t += 58;
  1349.             }
  1350.         }
  1351.         if (*(unsigned*)(ptr + 4) == WORD4(0xDB, 0xFE, 0xA9, 0xE6) &&
  1352.             *(unsigned*)(ptr + 8) == WORD4(0x40, 0xD8, 0x00, 0x28) && ptr[12] == 0xF3)
  1353.         { // no rra, no break check (rana rama)
  1354.             for (;;)
  1355.             {
  1356.                 if (cpu.b == 0xFF)
  1357.                 {
  1358.                     return;
  1359.                 }
  1360.                 if ((tape_bit() ^ cpu.c) & 0x40)
  1361.                 {
  1362.                     return;
  1363.                 }
  1364.                 cpu.b++; cpu.t += 59;
  1365.             }
  1366.         }
  1367.         if (*(unsigned*)(ptr + 4) == WORD4(0xDB, 0xFE, 0x1F, 0xA9) &&
  1368.             *(unsigned*)(ptr + 8) == WORD4(0xE6, 0x20, 0x28, 0xF4))
  1369.         { // ret nc skipped: routine without BREAK checking (ZeroMusic & JSW)
  1370.             for (;;)
  1371.             {
  1372.                 if (cpu.b == 0xFF)
  1373.                 {
  1374.                     return;
  1375.                 }
  1376.                 if ((tape_bit() ^ cpu.c) & 0x20)
  1377.                 {
  1378.                     return;
  1379.                 }
  1380.                 cpu.b++; cpu.t += 54;
  1381.             }
  1382.         }
  1383.     }
  1384.     if ((p | WORD4(0, 0, 0, 0xFF)) == WORD4(0x04, 0x20, 0x03, 0xFF) &&
  1385.         ptr[6] == 0xDB && *(unsigned*)(ptr + 8) == WORD4(0x1F, 0xC8, 0xA9, 0xE6) &&
  1386.         (*(unsigned*)(ptr + 0x0C) | WORD4(0, 0, 0, 0xFF)) == WORD4(0x20, 0x28, 0xF1, 0xFF))
  1387.     { // find edge from Donkey Kong
  1388.         for (;;)
  1389.         {
  1390.             if (cpu.b == 0xFF)
  1391.             {
  1392.                 return;
  1393.             }
  1394.             if ((tape_bit() ^ cpu.c) & 0x20)
  1395.             {
  1396.                 return;
  1397.             }
  1398.             cpu.b++; cpu.t += 59;
  1399.         }
  1400.     }
  1401.     if ((p | WORD4(0, 0xFF, 0, 0)) == WORD4(0x3E, 0xFF, 0xDB, 0xFE) &&
  1402.         *(unsigned*)(ptr + 4) == WORD4(0xA9, 0xE6, 0x40, 0x20) &&
  1403.         (*(unsigned*)(ptr + 8) | WORD4(0xFF, 0, 0, 0)) == WORD4(0xFF, 0x05, 0x20, 0xF4))
  1404.     { // lode runner
  1405.         for (;;)
  1406.         {
  1407.             if (cpu.b == 1)
  1408.             {
  1409.                 return;
  1410.             }
  1411.             if ((tape_bit() ^ cpu.c) & 0x40)
  1412.             {
  1413.                 return;
  1414.             }
  1415.             cpu.t += 52; cpu.b--;
  1416.         }
  1417.     }
  1418. }
  1419.  
  1420. // ╧хЁхїтрЄ ёЄюшЄ эр рфЁхёх 0x56B (фы  яюффхЁцъш эхёЄрэфрЁЄэ√ї чруЁєчўшъют)
  1421. void tape_traps()
  1422. {
  1423.     u32 pulse;
  1424.  
  1425.     // ┬їюф (фы  рфЁхёр 0x0556, фы  0x56B чэрўхэш  єцх шёяюЁўхэ√):
  1426.     // A - Їыруют√щ срщЄ (фюыцхэ ёютярфрЄ№ ё Їыруют√ь срщЄюь чряшёрээ√ь эр ыхэЄх)
  1427.     // IX - рфЁхё чруЁєчъш
  1428.     // DE - фышэр чруЁєцрхьюую сыюър
  1429.     // CF - 0 - verify, 1 - load
  1430.     //
  1431.     // ┬√їюф:
  1432.     // CF - 0 - ю°шсюъ эхЄ, 1 - ю°шсър чруЁєчъш
  1433.  
  1434.     /*
  1435.     LD_BYTES 0x0556 inc    d                   ; ═х ьхэ хЄ CF
  1436.                     ex     af, af'             ; A ш CF ёюїЁрэ ■Єё  т af'
  1437.                     dec    d
  1438.                     di
  1439.                     ld     a,0xF
  1440.                     out    (0xFE),a
  1441.                     ld     hl, 0x53F           ; SA_LD_RET = 0x53F
  1442.                     push   hl
  1443.                     in     a,(0xFE)
  1444.              0x0564 rra
  1445.                     and    0x20
  1446.                     or     2
  1447.              0x056A ld     c,a
  1448.     LD_BREAK 0x056B ret    nz
  1449.     */
  1450.  
  1451.     bool IsLoad = ((cpu.alt.f & CF) != 0);
  1452.     u8 Flag = cpu.alt.a;
  1453.  
  1454.     // ─ы  чруЁєчўшъют ъюЄюЁ√х эх яЁюїюф Є ўхЁхч рфЁхё 0x0564 фхырхЄё  яЁшэєфшЄхы№э√щ чряєёъ ыхэЄ√
  1455.     // ╧ЁшьхЁ Єръшї чруЁєчўшъют - чруЁєчўшъш юЄ Bill Gilbert (єёЄрэртыштр■Є эхёЄрэфрЁЄэ√х ЎтхЄр сюЁф■Ёр ш
  1456.     // фхыр■Є яхЁхїюф эр 0x056A)
  1457.     if (!comp.tape.play_pointer)
  1458.     {
  1459.         start_tape();
  1460.     }
  1461.  
  1462.     do
  1463.     {
  1464.         if (comp.tape.play_pointer >= comp.tape.end_of_tape ||
  1465.             (pulse = tape_pulse[*comp.tape.play_pointer++]) == UINT32_MAX)
  1466.         {
  1467.             stop_tape();
  1468.             return;
  1469.         }
  1470.     } while((pulse & tape_pulse_mask) > 770);
  1471.     comp.tape.play_pointer++;
  1472.  
  1473.     // loading flag byte
  1474.     cpu.l = 0;
  1475.     cpu.h = 0;
  1476.     for (unsigned bit = 0x80; bit; bit >>= 1)
  1477.     {
  1478.         if (comp.tape.play_pointer >= comp.tape.end_of_tape ||
  1479.             (pulse = tape_pulse[*comp.tape.play_pointer++]) == UINT32_MAX)
  1480.         {
  1481.             stop_tape();
  1482.             cpu.pc = 0x05DF;
  1483.             return;
  1484.         }
  1485.         cpu.l |= ((pulse & tape_pulse_mask) > 1240) ? bit : 0;
  1486.         comp.tape.play_pointer++;
  1487.     }
  1488.  
  1489.     if (cpu.l != Flag) // ╧Ёш эхёютярфхэшш Їыруютюую срщЄр яЁюяєёърхь сыюъ фрээ√ї
  1490.     {
  1491.         IsLoad = false;
  1492.     }
  1493.  
  1494.     cpu.h ^= cpu.l;
  1495.  
  1496.     // loading data
  1497.     do
  1498.     {
  1499.         cpu.l = 0;
  1500.         for (unsigned bit = 0x80; bit; bit >>= 1)
  1501.         {
  1502.             if (comp.tape.play_pointer >= comp.tape.end_of_tape ||
  1503.                 (pulse = tape_pulse[*comp.tape.play_pointer++]) == UINT32_MAX)
  1504.             {
  1505.                 stop_tape();
  1506.                 cpu.pc = 0x05DF;
  1507.                 return;
  1508.             }
  1509.             cpu.l |= ((pulse & tape_pulse_mask) > 1240) ? bit : 0;
  1510.             comp.tape.play_pointer++;
  1511.         }
  1512.         cpu.h ^= cpu.l;
  1513.         if (IsLoad)
  1514.         {
  1515.             cpu.DbgMemIf->wm(cpu.ix, cpu.l);
  1516.         }
  1517.         cpu.ix++;
  1518.         cpu.de--;
  1519.     } while(cpu.de & 0xFFFF);
  1520.  
  1521.     // loading CRC
  1522.     cpu.l = 0;
  1523.     for (unsigned bit = 0x80; bit; bit >>= 1)
  1524.     {
  1525.         if (comp.tape.play_pointer >= comp.tape.end_of_tape ||
  1526.             (pulse = tape_pulse[*comp.tape.play_pointer++]) == UINT32_MAX)
  1527.         {
  1528.             stop_tape();
  1529.             cpu.pc = 0x05DF;
  1530.             return;
  1531.         }
  1532.         cpu.l |= ((pulse & tape_pulse_mask) > 1240) ? bit : 0;
  1533.         comp.tape.play_pointer++;
  1534.     }
  1535.     cpu.h ^= cpu.l;
  1536.     cpu.pc = 0x05DF; // ld a,h / cp 01 / ret
  1537.     cpu.bc = 0xB001;
  1538.  
  1539.     comp.tape.play_pointer++;
  1540.     stop_tape();
  1541.  
  1542.     /*cpu.pc=0x0604; // the old one
  1543.     unsigned pulse;
  1544.     pulse = tape_pulse[*comp.tape.play_pointer++];
  1545.     if (pulse == -1) stop_tape();
  1546.     else{
  1547.       comp.t_states+=pulse;
  1548.       comp.tape.edge_change = comp.t_states + cpu.t + 520;
  1549.  
  1550.       cpu.b+=(pulse-520)/56;
  1551.       cpu.f|=CF;
  1552.     }*/
  1553. }
  1554.