apps/plugins/zxbox/sptape.c

   1 /*
   2  * Copyright (C) 1996-1998 Szeredi Miklos
   3  * Email: mszeredi@inf.bme.hu
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version. See the file COPYING.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  *
  19  */
  20 #include "zxmisc.h"
  21
  22 #include "sptape.h"
  23 #include "tapefile.h"
  24
  25 #include "spperif.h"
  26 #include "z80.h"
  27 #include "interf.h"
  28 #include "spconf.h"
  29
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <string.h>
  33 #include <errno.h>
  34 #include <sys/types.h>
  35
  36 #define MAXLINELEN 256
  37
  38 int spt_auto_stop = 1;
  39
  40 static int playing = 0;
  41 static int paused = 0;
  42
  43 static char tapename[MAXFILENAME];
  44 static int tapetype;
  45
  46 #define EARBIT 0x40
  47
  48 #define IMPBUFLEN 1024
  49
  50 static int ingroup;
  51 static int segtype;
  52
  53 static int lastdatak;
  54
  55 static int currseg;
  56
  57 static void stop_playing(void)
  58 {
  59   if(playing) close_tapefile();
  60   playing = 0;
  61 }
  62
  63 static void pause_playing(void)
  64 {
  65   if(playing) {
  66     paused = 1;
  67     playing = 0;
  68   }
  69 }
  70
  71 static void unpause_playing(void)
  72 {
  73   if(paused) {
  74     paused = 0;
  75     playing = 1;
  76     segtype = SEG_END;
  77   }
  78 }
  79
  80 #define MAXDESCLEN 256
  81
  82 static void put_seg_desc(void)
  83 {
  84   if(segtype != SEG_VIRTUAL) {
  85     if(segtype > SEG_END) {
  86       if(!ingroup) {
  87     long len;
  88     int i, ml;
  89     char *me;
  90
  91     len = get_seglen();
  92
  93     me = msgbuf;
  94     rb->snprintf(me,MAXDESCLEN, "%4d: ", currseg);
  95     me = me+rb->strlen(me);
  96     if(segtype >= SEG_DATA && len) {
  97       rb->snprintf(me,MAXDESCLEN, "%5ld bytes, ", len);
  98       me = me+rb->strlen(me);
  99     }
 100
 101     ml = 0;
 102     for(i = 0; seg_desc[i]; i++) {
 103       if(seg_desc[i] == '\n') {
 104         *me = '\0';
 105         put_msg(msgbuf);
 106
 107         me = msgbuf;
 108         rb->snprintf(me,MAXDESCLEN, "      ");
 109         me = me+rb->strlen(me);
 110         ml = 0;
 111       }
 112       else {
 113         if(ml < MAXDESCLEN) *me++ = seg_desc[i];
 114         ml++;
 115       }
 116     }
 117     *me = '\0';
 118     put_msg(msgbuf);
 119       }
 120       else {
 121     rb->snprintf(msgbuf,MAXDESCLEN, "%4d:", currseg);
 122     put_tmp_msg(msgbuf);
 123       }
 124     }
 125     else put_msg(seg_desc);
 126   }
 127 #ifdef DEBUG_TAPE
 128   else fprintf(stderr, "virtual   segment\n");
 129 #endif
 130 }
 131
 132 static void get_next_segment(void)
 133 {
 134   int propseg;
 135
 136   do {
 137     propseg = 1;
 138
 139     segtype = next_segment();
 140     currseg = segment_pos();
 141
 142     put_seg_desc();
 143
 144     switch(segtype) {
 145     case SEG_ERROR:
 146     case SEG_END:
 147       stop_playing();
 148       break;
 149
 150     case SEG_STOP:
 151       pause_playing();
 152       put_msg(" * Tape paused; Press Ctrl-o to restart * ");
 153       break;
 154
 155     case SEG_SKIP:
 156       propseg = 0;
 157       break;
 158
 159     case SEG_GRP_BEG:
 160       ingroup = 1;
 161       propseg = 0;
 162       break;
 163
 164     case SEG_GRP_END:
 165       ingroup = 0;
 166       propseg = 0;
 167       break;
 168     }
 169   } while(!propseg);
 170
 171   lastdatak = 0;
 172 }
 173
 174
 175 void play_tape(void)
 176 {
 177   static dbyte impbuf[IMPBUFLEN];
 178
 179   static int clevel;
 180   static dbyte *impbufp;
 181   static int impbufrem;
 182   static long imprem;
 183
 184   static int cleared_buffers = 1;
 185
 186   int tsn;
 187   dbyte *ibp;
 188   byte *tsp;
 189   int ibr;
 190   long ir;
 191   int cl;
 192   signed char *op;
 193   int ov;
 194   int ca;
 195
 196   tsp = sp_tape_impinfo;
 197   op  = sp_tape_sound;
 198   tsn = TMNUM;
 199
 200   if(!playing) {
 201     if(cleared_buffers) return;
 202
 203     sp_playing_tape = 0;
 204
 205     if(!clevel) {
 206       ca = CHKTICK;
 207       clevel = ~clevel;
 208     }
 209     else {
 210       ca = 0;
 211       cleared_buffers = 1;
 212     }
 213     imprem = CHKTICK * TMNUM;
 214   }
 215   else if(!sp_playing_tape) {
 216     sp_playing_tape = 1;
 217     cleared_buffers = 0;
 218
 219     impbufrem = 0;
 220     imprem = 0;
 221     clevel = get_level() ? ~(0) : 0;
 222     if(clevel) ca = 0;
 223     else ca = 1;
 224   }
 225   else ca = 0;
 226
 227 #ifdef DEBUG_TAPE
 228   if(((clevel ? 1 : 0) ^
 229       (DANM(ula_inport) & EARBIT ? 1 : 0) ^
 230       (DANM(imp_change) ? 1 : 0) ^
 231       (ca ? 1 : 0)) == 0)
 232     fprintf(stderr, "Levels don't match %i %i\n", imprem, impbufrem);
 233 #endif
 234
 235   cl = clevel;
 236   ibr = impbufrem;
 237   ir = imprem;
 238   ibp = impbufp;
 239
 240   if(cl) ov = CHKTICK/2;
 241   else ov = -(CHKTICK/2);
 242
 243   do {
 244     if(ir > 0) {
 245       *tsp++ = ca;
 246       *op++ = ov;
 247       ir -= CHKTICK;
 248       tsn--;
 249       if(!tsn) goto done;
 250
 251       if(cl) ov = CHKTICK/2;
 252       else   ov = -(CHKTICK/2);
 253
 254       while(ir > 0) {
 255     *tsp++ = 0;
 256     *op++ = ov;
 257     ir -= CHKTICK;
 258     tsn--;
 259     if(!tsn) goto done;
 260       }
 261       ca = 0;
 262     }
 263     if(ibr) {
 264       if(!ca) {
 265     if(cl) {
 266       ov += ir;
 267       ca = (CHKTICK/2) - ov + 1;
 268     }
 269     else {
 270       ov -= ir;
 271       ca = ov + (CHKTICK/2) + 1;
 272     }
 273       }
 274       else {
 275     ca = 0;
 276     if(cl) ov += ir;
 277     else   ov -= ir;
 278       }
 279       ir += *ibp++;
 280       ibr--;
 281       cl = ~cl;
 282     }
 283     else {
 284       ibp = impbuf;
 285       do {
 286     ibr = next_imps(impbuf, IMPBUFLEN, CHKTICK * tsn);
 287     if(ibr) break;
 288     get_next_segment();
 289     if(!playing) {
 290       if(!cl) {
 291         if(ca) ca = 0;
 292         else   ca = CHKTICK;
 293         cl = ~cl;
 294       }
 295       ir = tsn*CHKTICK;
 296       ov = -(CHKTICK/2);
 297       break;
 298     }
 299       } while(1);
 300     }
 301
 302   } while(1);
 303
 304  done:
 305
 306   clevel = cl;
 307   impbufrem = ibr;
 308   imprem = ir;
 309   impbufp = ibp;
 310
 311   if(segtype >= SEG_DATA) {
 312     int datak;
 313
 314     datak = (int) (get_segpos() / 1000);
 315     if(datak > lastdatak) {
 316       if(ingroup) rb->snprintf(msgbuf,MAXDESCLEN, "%4d: ", currseg);
 317       else        rb->snprintf(msgbuf,MAXDESCLEN,  "      ");
 318       rb->snprintf(msgbuf+rb->strlen(msgbuf),MAXDESCLEN,  "%3dk", datak);
 319       put_tmp_msg(msgbuf);
 320
 321       lastdatak = datak;
 322     }
 323   }
 324 }
 325
 326 /*
 327
 328 2168
 329 2168  (9-10)
 330
 331 667
 332 735   (2-4)
 333
 334 855
 335 855   (3-5)
 336
 337 1710
 338 1710  (7-9)
 339
 340 945   (4-5)
 341
 342 hosszu: 7..9
 343 rovid:  2..5
 344
 345 */
 346
 347 #define MICBIT 0x08
 348
 349
 350 #define RC_NONE    0
 351 #define RC_LEADER  1
 352 #define RC_SYNC    2
 353 #define RC_DATA    3
 354
 355 #define MAXLEN      TMNUM
 356
 357 #define LEADER_MIN  9
 358 #define LEADER_MAX  10
 359 #define SYNC_MIN    2
 360 #define SYNC_MAX    4
 361
 362 #define BIT0_MIN    3
 363 #define BIT0_MAX    5
 364 #define BIT1_MIN    7
 365 #define BIT1_MAX    9
 366
 367 #define LEADER_MIN_COUNT 512
 368 #if 0
 369 static int rec_segment;
 370 static int rec_state = RC_NONE;
 371 static byte *recbuf = NULL;
 372 static const char *waitchars = "-\\|/";
 373 #endif
 374 static int recording = 0;
 375
 376
 377
 378 void rec_tape(void)
 379 {
 380 #if 0
 381   static byte lastmic = 0;
 382   static int lastlen = 0;
 383   static int whole;
 384   static int leadercount;
 385   static byte data;
 386   static byte parity;
 387   static int bitnum;
 388   static int bytecount;
 389   static int recbufsize;
 390   static int firsthalf;
 391   static int frameswait = 0;
 392
 393   int tsl;
 394   byte *fep;
 395   int thishalf;
 396
 397
 398   if(!recording) return;
 399
 400   for(fep = sp_fe_outport_time, tsl = TMNUM; tsl; fep++, tsl--) {
 401     lastlen++;
 402     if((*fep & MICBIT) == lastmic) {
 403       if(lastlen < MAXLEN) continue;
 404     }
 405     else lastmic = ~lastmic & MICBIT;
 406
 407     switch(rec_state) {
 408     case RC_NONE:
 409       if(lastlen >= LEADER_MIN && lastlen <= LEADER_MAX) {
 410     rec_state = RC_LEADER;
 411
 412     leadercount = 0;
 413     break;
 414       }
 415       if((frameswait++ & 15)) break;
 416       frameswait &= 0x3F;
 417       sprintf(msgbuf, "  %s: WAITING %c",
 418           tapename, waitchars[(frameswait >> 4)]);
 419       put_tmp_msg(msgbuf);
 420       break;
 421     case RC_LEADER:
 422       if(lastlen >= LEADER_MIN && lastlen <= LEADER_MAX) {
 423     leadercount++;
 424     if(leadercount == LEADER_MIN_COUNT) {
 425       sprintf(msgbuf, "  %s: LEADER", tapename);
 426       put_tmp_msg(msgbuf);
 427     }
 428     break;
 429       }
 430       if(leadercount >= LEADER_MIN_COUNT &&
 431      lastlen >= SYNC_MIN && lastlen <= SYNC_MAX) rec_state = RC_SYNC;
 432       else rec_state = RC_NONE;
 433       break;
 434     case RC_SYNC:
 435       if(lastlen >= SYNC_MIN && lastlen <= SYNC_MAX) {
 436     rec_state = RC_DATA;
 437     whole = 0;
 438     data = 0;
 439     bitnum = 0;
 440     bytecount = 0;
 441     recbuf = NULL;
 442     recbufsize = 0;
 443     parity = 0;
 444
 445     sprintf(msgbuf, "  %s: DATA", tapename);
 446     put_tmp_msg(msgbuf);
 447       }
 448       else rec_state = RC_NONE;
 449       break;
 450     case RC_DATA:
 451       thishalf = -1;
 452       if(lastlen >= BIT0_MIN && lastlen <= BIT0_MAX) thishalf = 0;
 453       else if(lastlen >= BIT1_MIN && lastlen <= BIT1_MAX) thishalf = 1;
 454
 455       if(thishalf < 0 || (whole && firsthalf != thishalf)) {
 456     char filename[11];
 457     int filesize;
 458     int filetype;
 459
 460     sprintf(msgbuf, "%s: %03d", tapename, rec_segment);
 461     if(bytecount >= 1) {
 462       sprintf(msgbuf+strlen(msgbuf),
 463           " %02X %5d %3s", recbuf[0], bytecount-2,
 464          parity == 0 ? "OK" : "ERR");
 465       if(recbuf[0] == 0 && bytecount - 2 >= 17) {
 466         filetype = recbuf[1];
 467         strncpy(filename, (char*) recbuf+2, 10);
 468         filename[10] = '\0';
 469         filesize = recbuf[12] + (recbuf[13] << 8);
 470
 471         sprintf(msgbuf+strlen(msgbuf),
 472             "  %02X %10s %5i", filetype, filename, filesize);
 473       }
 474     }
 475     put_msg(msgbuf);
 476
 477     putc(bytecount & 0xFF, tapefp);
 478     putc((bytecount >> 8) & 0xFF, tapefp);
 479
 480     fwrite(recbuf, 1, (size_t) bytecount, tapefp);
 481     fflush(tapefp);
 482
 483     rec_segment++;
 484     free(recbuf);
 485     recbuf = NULL;
 486     rec_state = RC_NONE;
 487     break;
 488       }
 489
 490       if(!whole) {
 491     whole = 1;
 492     firsthalf = thishalf;
 493       }
 494       else {
 495     whole = 0;
 496     data |= thishalf;
 497     bitnum++;
 498
 499     if(bitnum == 8) {
 500       bitnum = 0;
 501       if(recbufsize <= bytecount) {
 502         recbufsize += 1024;
 503         recbuf = realloc(recbuf, (size_t) recbufsize);
 504         if(recbuf == NULL) {
 505           //fprintf(stderr, "Out of memory\n");
 506           exit(1);
 507         }
 508       }
 509       recbuf[bytecount] = data;
 510       parity = parity ^ data;
 511       data = 0;
 512       bytecount++;
 513
 514       if(!(bytecount & 1023)) {
 515         sprintf(msgbuf, "  %s: DATA %i kB",
 516             tapename, bytecount >> 10);
 517         put_tmp_msg(msgbuf);
 518       }
 519     }
 520     data <<= 1;
 521       }
 522       break;
 523     }
 524
 525     lastlen = 0;
 526   }
 527 #endif
 528 }
 529
 530 static void stop_recording(void)
 531 {
 532 #if 0
 533   if(recording) {
 534     recording = 0;
 535     free(recbuf);
 536     recbuf = NULL;
 537
 538     rb->close(tapefp);
 539   }
 540 #endif
 541 }
 542
 543 static void restart_playing(void)
 544 {
 545   int res;
 546   struct tape_options tapeopt;
 547
 548   if(tapetype < 0) {
 549     tapetype = TAP_TZX;
 550     res = open_tapefile(tapename, tapetype);
 551     if(!res) {
 552       tapetype = TAP_TAP;
 553       res = open_tapefile(tapename, tapetype);
 554     }
 555   }
 556   else res = open_tapefile(tapename, tapetype);
 557
 558   if(!res) {
 559     put_msg(seg_desc);
 560     return;
 561   }
 562
 563   INITTAPEOPT(tapeopt);
 564 #ifndef DEBUG_Z80
 565   tapeopt.blanknoise = 1;
 566 #endif
 567   set_tapefile_options(&tapeopt);
 568
 569   if(currseg) {
 570     res = goto_segment(currseg);
 571     if(!res) {
 572       put_msg(seg_desc);
 573       return;
 574     }
 575   }
 576
 577   playing = 1;
 578   segtype = SEG_END;
 579 }
 580
 581
 582 void pause_play(void)
 583 {
 584   if(playing) {
 585     pause_playing();
 586     put_msg(" * Tape paused * ");
 587     goto_segment(currseg);
 588   }
 589   else unpause_playing();
 590 }
 591
 592
 593 void start_play_file_type(char *name, int seg, int type)
 594 {
 595   int filetype = FT_TAPEFILE;
 596
 597   rb->strlcpy(tapename, name, MAXFILENAME-10 + 1);
 598
 599   currseg = seg;
 600   tapetype = type;
 601
 602   spcf_find_file_type(tapename, &filetype, &tapetype);
 603   if(currseg < 0) currseg = 0;
 604
 605   ingroup = 0;
 606   restart_playing();
 607 }
 608
 609 void start_play(void)
 610 {
 611   char *name;
 612   int t;
 613   int seg;
 614
 615   if(playing || paused || recording) {
 616     put_msg(" * Stop the tape first! * ");
 617     return;
 618   }
 619
 620   put_msg("Enter tape file path:");
 621   name = spif_get_tape_fileinfo(&seg, &t);
 622   if(name == NULL) return;
 623
 624   start_play_file_type(name, seg, -1);
 625 }
 626
 627
 628 void stop_play(void)
 629 {
 630
 631   if(playing || paused) {
 632     put_msg(" * Stopped playing * ");
 633
 634     if(playing) stop_playing();
 635     if(paused) paused = 0;
 636   }
 637   else if(recording) {
 638 #if 0
 639     sprintf(msgbuf, " * Stopped recording tape `%s' * ", tapename);
 640     put_msg(msgbuf);
 641 #endif
 642     stop_recording();
 643   }
 644 }
 645
 646 void start_rec(void)
 647 {
 648 #if 0
 649   char *name;
 650
 651   if(playing || paused || recording) return;
 652
 653   put_msg("Enter tape file to record (default: '.tap'):");
 654
 655   name = spif_get_filename();
 656   if(name == NULL) return;
 657
 658   strncpy(tapename, name, MAXFILENAME-10);
 659   tapename[MAXFILENAME-10] = '\0';
 660
 661   if(!check_ext(tapename, "tap")) add_extension(tapename, "tap");
 662
 663   tapefp = fopen(tapename, "ab");
 664   if(tapefp == NULL) {
 665     sprintf(msgbuf, "Could not open tape file `%s', %s",
 666         tapename, strerror(errno));
 667     put_msg(msgbuf);
 668     return;
 669   }
 670
 671   recording = 1;
 672   rec_segment = 0;
 673   rec_state = RC_NONE;
 674
 675   sprintf(msgbuf,
 676       "Recordind tape file `%s'. To stop press Ctrl-s", tapename);
 677   put_msg(msgbuf);
 678 #endif
 679 }
 680
 681 #include "spkey_p.h"
 682
 683 #define CF  0x01
 684 #define ZF  0x40
 685
 686 void qload(void)
 687 {
 688   byte type, parity;
 689   dbyte length, dest, dtmp;
 690   int verify, success, firstbyte;
 691   int nextdata;
 692
 693   if(recording) {
 694     put_msg("Can't quick load tape, because recording");
 695     return;
 696   }
 697
 698   do {
 699     if(!playing) {
 700       if(paused) unpause_playing();
 701       else {
 702     start_play();
 703       }
 704     }
 705     if(!playing) {
 706       put_msg("Not quick loading tape");
 707       return;
 708     }
 709     while(playing && (segtype != SEG_DATA || get_segpos() > 0))
 710       get_next_segment();
 711
 712   } while(!playing);
 713
 714   dtmp = AFBK;
 715   AFBK = AF;
 716   AF = dtmp;
 717
 718   type = RA;
 719   verify = !(RF & CF);
 720   length = DE;
 721   firstbyte = !(RF & ZF);
 722   dest = IX;
 723
 724   parity = 0;
 725   success = 0;
 726
 727   do {
 728     nextdata = next_byte();
 729     if(nextdata < 0) break;
 730
 731     parity ^= nextdata;
 732
 733     if(!length) {
 734       if(!parity) success = 1;
 735       break;
 736     }
 737
 738     if(firstbyte) {
 739       firstbyte = 0;
 740       if(nextdata != type) break;
 741     }
 742     else {
 743       if(!verify) {
 744     if(dest >= 0x4000) DANM(mem)[dest] = nextdata;
 745       }
 746       else {
 747     if(DANM(mem)[dest] != nextdata) break;
 748       }
 749       dest++;
 750       length--;
 751     }
 752   } while(1);
 753
 754   if(success) RF |= (CF | ZF);
 755   else RF &= ~(CF | ZF);
 756   IX = dest;
 757   DE = length;
 758
 759   PC = SA_LD_RET;
 760   DANM(iff1) = DANM(iff2) = 1;
 761   DANM(haltstate) = 1;
 762
 763   sp_init_screen_mark();
 764
 765   if(spt_auto_stop) pause_playing();
 766 }