Subversion Repositories pentevo

#include "std.h"

#include "emul.h"

#include "vars.h"

#include "tape.h"

#include "memory.h"

#include "util.h"

#include "png/zlib.h"

#define Z80FQ 3500000

unsigned tape_pulse[0x100]; // Àëôàâèò èç èìïóëüñîâ ðàçíîé äëèíû (÷èñëî ñèìâîëîâ àëôàâèòà íå áîëåå 256, ññûëêè îäíîáàéòîâûå)

unsigned max_pulses = 0;

unsigned tape_err = 0;

unsigned char *tape_image = 0; // Ìàññèâ ññûëîê íà àëôàâèò (ññûëêè îäíîáàéòîâûå)

unsigned tape_imagesize = 0;

TAPEINFO *tapeinfo;

unsigned tape_infosize;

unsigned appendable;

typedef int (__cdecl *inflateInit__ptr)(z_streamp strm, const char *version, int stream_size);

typedef int (__cdecl *inflate_ptr)(z_streamp strm, int flush);

typedef int (__cdecl *inflateEnd_ptr)(z_streamp strm);

static inflateInit__ptr inflateInit__p = 0;

static inflate_ptr inflate_p = 0;

static inflateEnd_ptr inflateEnd_p = 0;

static HMODULE ZlibDll = 0;

bool ZlibInit()

{

    ZlibDll = LoadLibrary("zlib1.dll");

    if(!ZlibDll)

        return false;

    inflateInit__p = (inflateInit__ptr)GetProcAddress(ZlibDll, "inflateInit_");

    if(!inflateInit__p)

        return false;

    inflate_p = (inflate_ptr)GetProcAddress(ZlibDll,"inflate");

    if(!inflate_p)

        return false;

    inflateEnd_p = (inflateEnd_ptr)GetProcAddress(ZlibDll,"inflateEnd");

    if(!inflateEnd_p)

        return false;

    return true;

}

void ZlibDone()

{

    if(ZlibDll)

        FreeLibrary(ZlibDll);

}

// Èùåò äëèíó èìïóëüñà â àëôàâèòå è âîçâðàùàåò èíäåêñ íàéäåííîãî ýëåìåíòà

// Åñëè èìïóëüñ ñ òàêîé øèðèíîé íå íàéäåí, îí äîáàâëÿåòñÿ â êîíåö è âîçâðàùàåòñÿ åãî èíäåêñ

// tape image contains indexes in tape_pulse[]

unsigned find_pulse(unsigned t)

{

   if (max_pulses < _countof(tape_pulse))

   {

      double e = 0.10 * t; // ðàçáðîñ 10%

      for (unsigned i = 0; i < max_pulses; i++)

      {

         if ((t - e) < tape_pulse[i] && tape_pulse[i] <= (t + e))

         {

             return i;

         }

      }

      tape_pulse[max_pulses] = t;

      return max_pulses++;

   }

   if (!tape_err)

   {

       errmsg("pulse table full");

       tape_err = 1;

   }

   unsigned nearest = 0; int delta = 0x7FFFFFFF;

   for (unsigned i = 0; i < _countof(tape_pulse); i++)

   {

      if (delta > abs((int)t - (int)tape_pulse[i]))

      {

         nearest = i;

         delta = abs((int)t - (int)tape_pulse[i]);

      }

   }

   return nearest;

}

void find_tape_index()

{

   for (unsigned i = 0; i < tape_infosize; i++)

      if (comp.tape.play_pointer >= tape_image + tapeinfo[i].pos)

         comp.tape.index = i;

   temp.led.tape_started = -600*3500000;

}

void find_tape_sizes()

{

   for (unsigned i = 0; i < tape_infosize; i++) {

      unsigned end = (i == tape_infosize-1) ? tape_imagesize : tapeinfo[i+1].pos;

      unsigned sz = 0;

      for (unsigned j = tapeinfo[i].pos; j < end; j++)

         sz += tape_pulse[tape_image[j]];

      tapeinfo[i].t_size = sz;

   }

}

void stop_tape()

{

   find_tape_index();

   const char *msg = "tape stopped";

   if (comp.tape.play_pointer == comp.tape.end_of_tape)

      comp.tape.index = 0, msg = "end of tape";

   comp.tape.play_pointer = 0;

   strcpy(statusline, msg); statcnt = 40;

   comp.tape.edge_change = 0x7FFFFFFFFFFFFFFFULL;

   comp.tape.tape_bit = -1;

}

void reset_tape()

{

   comp.tape.index = 0;

   comp.tape.play_pointer = 0;

   comp.tape.edge_change = 0x7FFFFFFFFFFFFFFFULL;

   comp.tape.tape_bit = -1;

}

void start_tape()

{

   if (!tape_image) return;

   strcpy(statusline, "tape started"); statcnt = 40;

   comp.tape.play_pointer = tape_image + tapeinfo[comp.tape.index].pos;

   comp.tape.end_of_tape = tape_image + tape_imagesize;

   comp.tape.edge_change = comp.t_states + cpu.t;

   temp.led.tape_started = -600*3500000;

   comp.tape.tape_bit = -1;

}

void closetape()

{

   if (tape_image) free(tape_image), tape_image = 0;

   if (tapeinfo) free(tapeinfo), tapeinfo = 0;

   comp.tape.play_pointer = 0; // stop tape

   comp.tape.index = 0; // rewind tape

   tape_err = max_pulses = tape_imagesize = tape_infosize = 0;

   comp.tape.edge_change = 0x7FFFFFFFFFFFFFFFULL;

   comp.tape.tape_bit = -1;

}

void reserve(unsigned datasize)

{

   const int blocksize = 16384;

   unsigned newsize = align_by(datasize+tape_imagesize+1, blocksize);

   if (!tape_image) tape_image = (unsigned char*)malloc(newsize);

   if (align_by(tape_imagesize, blocksize) < newsize) tape_image = (unsigned char*)realloc(tape_image, newsize);

}

void makeblock(const unsigned char *data, unsigned size, unsigned pilot_t,

      unsigned s1_t, unsigned s2_t, unsigned zero_t, unsigned one_t,

      unsigned pilot_len, unsigned pause, unsigned char last = 8)

{

   reserve(size*16 + pilot_len + 3);

   if (pilot_len != -1) {

      unsigned t = find_pulse(pilot_t);

      for (unsigned i = 0; i < pilot_len; i++)

         tape_image[tape_imagesize++] = t;

      tape_image[tape_imagesize++] = find_pulse(s1_t);

      tape_image[tape_imagesize++] = find_pulse(s2_t);

   }

   unsigned t0 = find_pulse(zero_t), t1 = find_pulse(one_t);

   for (; size>1; size--, data++)

      for (unsigned char j = 0x80; j; j >>= 1)

         tape_image[tape_imagesize++] = (*data & j) ? t1 : t0,

         tape_image[tape_imagesize++] = (*data & j) ? t1 : t0;

   for (unsigned char j = 0x80; j != (unsigned char)(0x80 >> last); j >>= 1) // last byte

      tape_image[tape_imagesize++] = (*data & j) ? t1 : t0,

      tape_image[tape_imagesize++] = (*data & j) ? t1 : t0;

   if (pause) tape_image[tape_imagesize++] = find_pulse(pause*3500);

}

void desc(const unsigned char *data, unsigned size, char *dst)

{

   unsigned char crc = 0; char prg[10];

   unsigned i; //Alone Coder 0.36.7

   for (/*unsigned*/ i = 0; i < size; i++) crc ^= data[i];

   if (!*data && size == 19 && (data[1] == 0 || data[1] == 3)) {

      for (i = 0; i < 10; i++) prg[i] = (data[i+2] < ' ' || data[i+2] >= 0x80) ? '?' : data[i+2];

      for (i = 9; i && prg[i] == ' '; prg[i--] = 0);

      sprintf(dst, "%s: \"%s\" %d,%d", data[1] ? "Bytes":"Program", prg,

         *(unsigned short*)(data+14), *(unsigned short*)(data+12));

   } else if (*data == 0xFF) sprintf(dst, "data block, %d bytes", size-2);

   else sprintf(dst, "#%02X block, %d bytes", *data, size-2);

   sprintf(dst + strlen(dst), ", crc %s", crc ? "bad":"ok");

}

static bool alloc_infocell()

{

   TAPEINFO *tmp = (TAPEINFO*)realloc(tapeinfo, (tape_infosize+1)*sizeof(TAPEINFO));

   if(!tmp)

   {

       return false;

   }

   tapeinfo = tmp;

   tapeinfo[tape_infosize].pos = tape_imagesize;

   appendable = 0;

   return true;

}

bool named_cell(const void *nm, unsigned sz = 0)

{

   if(!alloc_infocell())

       return false;

   const size_t n = _countof(tapeinfo[tape_infosize].desc)-1;

   size_t len = min(n, sz ? sz : strlen((const char*)nm));

   strncpy(tapeinfo[tape_infosize].desc, (const char*)nm, len);

   tapeinfo[tape_infosize].desc[len] = 0;

   tape_infosize++;

   return true;

}

int readTAP()

{

   unsigned char *ptr = snbuf; closetape();

   while (ptr < snbuf+snapsize) {

      unsigned size = *(unsigned short*)ptr; ptr += 2;

      if (!size) break;

      alloc_infocell();

      desc(ptr, size, tapeinfo[tape_infosize].desc);

      tape_infosize++;

      makeblock(ptr, size, 2168, 667, 735, 855, 1710, (*ptr < 4) ? 8064 : 3220, 1000);

      ptr += size;

   }

   find_tape_sizes();

   return (ptr == snbuf+snapsize);

}

#pragma pack(push, 1)

struct TCswHdr

{

    char Signature[22];

    u8 Term;

    u8 VerMajor;

    u8 VerMinor;

    union

    {

        struct

        {

            u16 SampleRate;

            u8 CompressionType;

            u8 Flags;

            u8 Reserved[3];

            u8 Data[1];

        } Ver1;

        struct

        {

            u32 SampleRate;

            u32 PulsesAfterDecompression;

            u8 CompressionType;

            u8 Flags;

            u8 HeaderExtLen;

            char EncAppDesc[16];

            u8 ExtHdr[1];

        } Ver2;

    };

};

#pragma pack(pop)

int readCSW()

{

   closetape();

   named_cell("CSW tape image");

   const TCswHdr *CswHdr = (TCswHdr *)snbuf;

   u8 CompType;

   u32 SampleRate;

   u8 Flags;

   u32 DataOffset;

   u32 PulsesCount;

   switch(CswHdr->VerMajor)

   {

   case 1:

       CompType = CswHdr->Ver1.CompressionType;

       SampleRate = CswHdr->Ver1.SampleRate;

       Flags = CswHdr->Ver1.Flags;

       DataOffset = offsetof(TCswHdr, Ver1.Data);

       PulsesCount = snapsize - 0x18; // Íåïîíÿòíàÿ êîíñòàíòà

   break;

   case 2:

       CompType = CswHdr->Ver2.CompressionType;

       SampleRate = CswHdr->Ver2.SampleRate;

       Flags = CswHdr->Ver2.Flags;

       DataOffset = offsetof(TCswHdr, Ver2.ExtHdr) + CswHdr->Ver2.HeaderExtLen;

       PulsesCount = CswHdr->Ver2.PulsesAfterDecompression;

   break;

   default: // unknown csw version

       return 0;

   }

   u32 UncompressedSize = snapsize;

   switch(CompType)

   {

   case 2: // Z-RLE

       {

           if(!temp.ZlibSupport)

               return 0;

           static const size_t out_sz = sizeof(snbuf);

           void *out = malloc(out_sz);

           if(!out)

               return 0;

           z_stream strm;

           strm.zalloc = Z_NULL;

           strm.zfree = Z_NULL;

           strm.opaque = Z_NULL;

           strm.avail_in = snapsize - DataOffset;

           strm.next_in = snbuf + DataOffset;

           int ret = inflateInit__p(&strm, ZLIB_VERSION, sizeof(strm));

           if(ret != Z_OK)

           {

               free(out);

               return 0;

           }

           strm.avail_out = out_sz;

           strm.next_out = (Byte *)out;

           ret = inflate_p(&strm, Z_FINISH);

           if(ret < 0)

           {

               free(out);

               inflateEnd_p(&strm);

               return 0;

           }

           UncompressedSize = out_sz - strm.avail_out;

           memcpy(snbuf + DataOffset, out, UncompressedSize);

           UncompressedSize += DataOffset;

           free(out);

           inflateEnd_p(&strm);

       }

   case 1: // RLE

   break;

   default:

       return 0; // unknown compression type

   }

   unsigned rate = Z80FQ / SampleRate; // usually 3.5mhz / 44khz

   if (!rate)

       return 0;

   reserve(PulsesCount);

   if (!(Flags & 1))

       tape_image[tape_imagesize++] = find_pulse(1);

   unsigned i = 0;

   for (unsigned char *ptr = snbuf + DataOffset; ptr < snbuf + UncompressedSize; i++)

   {

      unsigned len = *ptr++ * rate;

      if (!len)

      {

          len = *(unsigned*)ptr * rate;

          ptr += 4;

      }

      tape_image[tape_imagesize++] = find_pulse(len);

   }

   tape_image[tape_imagesize++] = find_pulse(Z80FQ/10);

   find_tape_sizes();

   return 1;

}

void create_appendable_block()

{

   if (!tape_infosize || appendable) return;

   named_cell("set of pulses"); appendable = 1;

}

void parse_hardware(const unsigned char *ptr)

{

   unsigned n = *ptr++;

   if (!n) return;

   named_cell("- HARDWARE TYPE ");

   static char ids[] =

     "computer\0"

        "ZX Spectrum 16k\0"

        "ZX Spectrum 48k, Plus\0"

        "ZX Spectrum 48k ISSUE 1\0"

        "ZX Spectrum 128k (Sinclair)\0"

        "ZX Spectrum 128k +2 (Grey case)\0"

        "ZX Spectrum 128k +2A, +3\0"

        "Timex Sinclair TC-2048\0"

        "Timex Sinclair TS-2068\0"

        "Pentagon 128\0"

        "Sam Coupe\0"

        "Didaktik M\0"

        "Didaktik Gama\0"

        "ZX-81 or TS-1000 with  1k RAM\0"

        "ZX-81 or TS-1000 with 16k RAM or more\0"

        "ZX Spectrum 128k, Spanish version\0"

        "ZX Spectrum, Arabic version\0"

        "TK 90-X\0"

        "TK 95\0"

        "Byte\0"

        "Elwro\0"

        "ZS Scorpion\0"

        "Amstrad CPC 464\0"

        "Amstrad CPC 664\0"

        "Amstrad CPC 6128\0"

        "Amstrad CPC 464+\0"

        "Amstrad CPC 6128+\0"

        "Jupiter ACE\0"

        "Enterprise\0"

        "Commodore 64\0"

        "Commodore 128\0"

        "\0"

     "ext. storage\0"

        "Microdrive\0"

        "Opus Discovery\0"

        "Disciple\0"

        "Plus-D\0"

        "Rotronics Wafadrive\0"

        "TR-DOS (BetaDisk)\0"

        "Byte Drive\0"

        "Watsford\0"

        "FIZ\0"

        "Radofin\0"

        "Didaktik disk drives\0"

        "BS-DOS (MB-02)\0"

        "ZX Spectrum +3 disk drive\0"

        "JLO (Oliger) disk interface\0"

        "FDD3000\0"

        "Zebra disk drive\0"

        "Ramex Millenia\0"

        "Larken\0"

        "\0"

     "ROM/RAM type add-on\0"

        "Sam Ram\0"

        "Multiface\0"

        "Multiface 128k\0"

        "Multiface +3\0"

        "MultiPrint\0"

        "MB-02 ROM/RAM expansion\0"

        "\0"

     "sound device\0"

        "Classic AY hardware\0"

        "Fuller Box AY sound hardware\0"

        "Currah microSpeech\0"

        "SpecDrum\0"

        "AY ACB stereo; Melodik\0"

        "AY ABC stereo\0"

        "\0"

     "joystick\0"

        "Kempston\0"

        "Cursor, Protek, AGF\0"

        "Sinclair 2\0"

        "Sinclair 1\0"

        "Fuller\0"

        "\0"

     "mice\0"

        "AMX mouse\0"

        "Kempston mouse\0"

        "\0"

     "other controller\0"

        "Trickstick\0"

        "ZX Light Gun\0"

        "Zebra Graphics Tablet\0"

        "\0"

     "serial port\0"

        "ZX Interface 1\0"

        "ZX Spectrum 128k\0"

        "\0"

     "parallel port\0"

        "Kempston S\0"

        "Kempston E\0"

        "ZX Spectrum 128k +2A, +3\0"

        "Tasman\0"

        "DK'Tronics\0"

        "Hilderbay\0"

        "INES Printerface\0"

        "ZX LPrint Interface 3\0"

        "MultiPrint\0"

        "Opus Discovery\0"

        "Standard 8255 chip with ports 31,63,95\0"

        "\0"

     "printer\0"

        "ZX Printer, Alphacom 32 & compatibles\0"

        "Generic Printer\0"

        "EPSON Compatible\0"

        "\0"

     "modem\0"

        "VTX 5000\0"

        "T/S 2050 or Westridge 2050\0"

        "\0"

     "digitaiser\0"

        "RD Digital Tracer\0"

        "DK'Tronics Light Pen\0"

        "British MicroGraph Pad\0"

        "\0"

     "network adapter\0"

        "ZX Interface 1\0"

        "\0"

     "keyboard / keypad\0"

        "Keypad for ZX Spectrum 128k\0"

        "\0"

     "AD/DA converter\0"

        "Harley Systems ADC 8.2\0"

        "Blackboard Electronics\0"

        "\0"

     "EPROM Programmer\0"

        "Orme Electronics\0"

        "\0"

     "\0";

   for (unsigned i = 0; i < n; i++) {

      unsigned char type_n = *ptr++;

      unsigned char id_n = *ptr++;

      unsigned char value_n = *ptr++;

      const char *type = ids, *id, *value;

      unsigned j; //Alone Coder 0.36.7

      for (/*unsigned*/ j = 0; j < type_n; j++) {

         if (!*type) break;

         while (*(short*)type) type++;

         type += 2;

      }

      if (!*type) type = id = "??"; else {

         id = type + strlen(type) + 1;

         for (j = 0; j < id_n; j++) {

            if (!*id) { id = "??"; break; }

            id += strlen(id)+1;

         }

      }

      switch (value_n) {

         case 0: value = "compatible with"; break;

         case 1: value = "uses"; break;

         case 2: value = "compatible, but doesn't use"; break;

         case 3: value = "incompatible with"; break;

         default: value = "??";

      }

      char bf[512]; sprintf(bf, "%s %s: %s", value, type, id);

      named_cell(bf);

   }

   named_cell("-");

}

int readTZX()

{

   const unsigned char *ptr = snbuf;

   closetape();

   unsigned size, pause, i, j, n, t, t0;

   unsigned char pl, last;

   const unsigned char *end;

   char *p;

   unsigned loop_n = 0, loop_p;

   unsigned TzxVer = (ptr[8] << 8) | ptr[9];

   char nm[512];

   ptr += 10; // Ïðîïóñê çàãîëîâêà

   while (ptr < snbuf+snapsize)

   {

      switch (*ptr++) {

         case 0x10: // normal block

            alloc_infocell();

            size = *(unsigned short*)(ptr+2);

            pause = *(unsigned short*)ptr;

            ptr += 4;

            desc(ptr, size, tapeinfo[tape_infosize].desc);

            tape_infosize++;

            makeblock(ptr, size, 2168, 667, 735, 855, 1710,

                (*ptr < 4) ? 8064 : 3220, pause);

            ptr += size;

            break;

         case 0x11: // turbo block

            alloc_infocell();

            size = 0xFFFFFF & *(unsigned*)(ptr+0x0F);

            desc(ptr + 0x12, size, tapeinfo[tape_infosize].desc);

            tape_infosize++;

            makeblock(ptr + 0x12, size,

               *(unsigned short*)ptr, *(unsigned short*)(ptr+2),

               *(unsigned short*)(ptr+4), *(unsigned short*)(ptr+6),

               *(unsigned short*)(ptr+8), *(unsigned short*)(ptr+10),

               *(unsigned short*)(ptr+13), ptr[12]);

            // todo: test used bits - ptr+12

            ptr += size + 0x12;

            break;

         case 0x12: // pure tone

            create_appendable_block();

            pl = find_pulse(*(unsigned short*)ptr);

            n = *(unsigned short*)(ptr+2);

            reserve(n);

            for (i = 0; i < n; i++) tape_image[tape_imagesize++] = pl;

            ptr += 4;

            break;

         case 0x13: // sequence of pulses of different lengths

            create_appendable_block();

            n = *ptr++;

            reserve(n);

            for (i = 0; i < n; i++, ptr += 2)

               tape_image[tape_imagesize++] = find_pulse(*(unsigned short*)ptr);

            break;

         case 0x14: // pure data block

            create_appendable_block();

            size = 0xFFFFFF & *(unsigned*)(ptr+7);

            makeblock(ptr + 0x0A, size, 0, 0, 0, *(unsigned short*)ptr,

                      *(unsigned short*)(ptr+2), -1, *(unsigned short*)(ptr+5), ptr[4]);

            ptr += size + 0x0A;

            break;

         case 0x15: // direct recording

            size = 0xFFFFFF & *(unsigned*)(ptr+5);

            t0 = *(unsigned short*)ptr;

            pause = *(unsigned short*)(ptr+2);

            last = ptr[4];

            named_cell("direct recording");

            ptr += 8;

            pl = 0; n = 0;

            for (i = 0; i < size; i++) // count number of pulses

               for (j = 0x80; j; j >>= 1)

                  if ((ptr[i] ^ pl) & j) n++, pl ^= -1;

            t = 0; pl = 0;

            reserve(n+2);

            for (i = 1; i < size; i++, ptr++) // find pulses

               for (j = 0x80; j; j >>= 1) {

                  t += t0;

                  if ((*ptr ^ pl) & j) {

                     tape_image[tape_imagesize++] = find_pulse(t);

                     pl ^= -1; t = 0;

                  }

               }

            // find pulses - last byte

            for (j = 0x80; j != (unsigned char)(0x80 >> last); j >>= 1) {

               t += t0;

               if ((*ptr ^ pl) & j) {

                  tape_image[tape_imagesize++] = find_pulse(t);

                  pl ^= -1; t = 0;

               }

            }

            ptr++;

            tape_image[tape_imagesize++] = find_pulse(t); // last pulse ???

            if (pause) tape_image[tape_imagesize++] = find_pulse(pause*3500);

            break;

         case 0x20: // pause (silence) or 'stop the tape' command

            pause = *(unsigned short*)ptr;

            sprintf(nm, pause? "pause %d ms" : "stop the tape", pause);

            named_cell(nm);

            reserve(2); ptr += 2;

            if (!pause) { // at least 1ms pulse as specified in TZX 1.13

               tape_image[tape_imagesize++] = find_pulse(3500);

               pause = -1;

            } else pause *= 3500;

            tape_image[tape_imagesize++] = find_pulse(pause);

            break;

         case 0x21: // group start

            n = *ptr++;

            named_cell(ptr, n); ptr += n;

            appendable = 1;

            break;

         case 0x22: // group end

            break;

         case 0x23: // jump to block

            named_cell("* jump"); ptr += 2;

            break;

         case 0x24: // loop start

            loop_n = *(unsigned short*)ptr; loop_p = tape_imagesize; ptr += 2;

            break;

         case 0x25: // loop end

            if (!loop_n) break;

            size = tape_imagesize - loop_p;

            reserve((loop_n-1) * size);

            for (i = 1; i < loop_n; i++)

               memcpy(tape_image + loop_p + i*size, tape_image + loop_p, size);

            tape_imagesize += (loop_n-1) * size;

            loop_n = 0;

            break;

         case 0x26: // call

            named_cell("* call"); ptr += 2 + 2 * *(unsigned short*)ptr;

            break;

         case 0x27: // ret

            named_cell("* return");

            break;

         case 0x28: // select block

            {

                int l = _countof(nm);

                l -= sprintf(nm, "* choice: ");

                n = ptr[2];

                p = (char*)ptr+3;

                for (i = 0; i < n; i++)

                {

                   size = *(unsigned char*)(p+2);

                   l -= size;

                   if(i)

                       l -= 4;

                   if(l >= 0)

                   {

                       if (i)