Subversion Repositories pentevo

Rev

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