apps/plugins/zxbox/tapefile.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
  21 /* This module deals with the different tape file formats (.TAP and .TZX)  */
  22 /* 'sptape.c' uses the functions provided by this module. */
  23
  24
  25 #include "tapefile.h"
  26 #include "tapef_p.h"
  27
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31 #include <errno.h>
  32 #include "inttypes.h"
  33 #include "zxconfig.h"
  34 #include "helpers.h"
  35 #define max(x, y) ((x) > (y) ? (x) : (y))
  36
  37 #define DESC_LEN 256
  38
  39 char seg_desc[DESC_LEN];
  40
  41 #define TZXMAJPROG 1
  42 #define TZXMINPROG 2
  43
  44 /*static FILE *tapefp = NULL;*/
  45 static int tapefd=-1;
  46
  47 static dbyte segi, currsegi;
  48 static int   segbeg;
  49
  50 static int   endtype, endnext, endplay;
  51 static dbyte endpause;
  52 static int finished;
  53
  54 static long firstseg_offs;
  55
  56 static struct tape_options tapeopt;
  57
  58 long tf_segoffs;
  59 struct tapeinfo tf_tpi;
  60
  61 static dbyte loopctr, loopbeg;
  62 static dbyte callctr, callbeg;
  63
  64 #define ST_NORM  0
  65 #define ST_PSEQ  1
  66 #define ST_DIRE  2
  67 #define ST_MISC  3
  68
  69 #define PL_NONE    0
  70 #define PL_PAUSE   1
  71 #define PL_LEADER  2
  72 #define PL_DATA    3
  73 #define PL_END     4
  74 #define PL_PSEQ    5
  75 #define PL_DIRE    6
  76
  77 #define IMP_1MS   3500
  78
  79 static dbyte lead_pause;
  80 static int playstate = PL_NONE;
  81 static int currlev;
  82
  83 #define DEF_LEAD_PAUSE 2000
  84
  85 struct seginfo tf_cseg;
  86
  87 struct tzxblock {
  88   int type;
  89   int lenbytes;
  90   int lenmul;
  91   int hlen;
  92 };
  93
  94 #define NUMBLOCKID 0x60
  95 /* changed NONE because of warinigs */
  96 /*#define NONE 0*/
  97 #define NONE 0,0,0,0
  98 #define COMM 1
  99 #define STAN 2
 100
 101
 102 #define RBUFLEN 1024
 103
 104 static byte rbuf[RBUFLEN];
 105
 106 /* Table containing information on TZX blocks */
 107
 108 static struct tzxblock tzxb[NUMBLOCKID] = {
 109   { NONE },                    /* ID: 00 */
 110   { NONE },
 111   { NONE },
 112   { NONE },
 113   { NONE },
 114   { NONE },
 115   { NONE },
 116   { NONE },
 117
 118   { NONE },                    /* ID: 08 */
 119   { NONE },
 120   { NONE },
 121   { NONE },
 122   { NONE },
 123   { NONE },
 124   { NONE },
 125   { NONE },
 126
 127   { COMM, 2, 1, 0x04 },        /* ID: 10 */
 128   { COMM, 3, 1, 0x12 },
 129   { COMM, 0, 1, 0x04 },
 130   { COMM, 1, 2, 0x01 },
 131   { COMM, 3, 1, 0x0A },
 132   { COMM, 3, 1, 0x08 },
 133   { NONE },
 134   { NONE },
 135
 136   { NONE },                    /* ID: 18 */
 137   { NONE },
 138   { NONE },
 139   { NONE },
 140   { NONE },
 141   { NONE },
 142   { NONE },
 143   { NONE },
 144
 145   { COMM, 0, 1, 0x02 },        /* ID: 20 */
 146   { COMM, 1, 1, 0x01 },
 147   { COMM, 0, 1, 0x00 },
 148   { COMM, 0, 1, 0x02 },
 149   { COMM, 0, 1, 0x02 },
 150   { COMM, 0, 1, 0x00 },
 151   { COMM, 2, 2, 0x02 },
 152   { COMM, 0, 1, 0x00 },
 153
 154   { COMM, 2, 1, 0x02 },        /* ID: 28 */
 155   { NONE },
 156   { STAN, 0, 1, 0x00 },
 157   { NONE },
 158   { NONE },
 159   { NONE },
 160   { NONE },
 161   { NONE },
 162
 163   { COMM, 1, 1, 0x01 },        /* ID: 30 */
 164   { COMM, 1, 1, 0x02 },
 165   { COMM, 2, 1, 0x02 },
 166   { COMM, 1, 3, 0x01 },
 167   { COMM, 0, 1, 0x08 },
 168   { COMM, 4, 1, 0x14 },
 169   { NONE },
 170   { NONE },
 171
 172   { NONE },                    /* ID: 38 */
 173   { NONE },
 174   { NONE },
 175   { NONE },
 176   { NONE },
 177   { NONE },
 178   { NONE },
 179   { NONE },
 180
 181   { COMM, 3, 1, 0x04 },        /* ID: 40 */
 182   { NONE },
 183   { NONE },
 184   { NONE },
 185   { NONE },
 186   { NONE },
 187   { NONE },
 188   { NONE },
 189
 190   { NONE },                    /* ID: 48 */
 191   { NONE },
 192   { NONE },
 193   { NONE },
 194   { NONE },
 195   { NONE },
 196   { NONE },
 197   { NONE },
 198
 199   { NONE },                    /* ID: 50 */
 200   { NONE },
 201   { NONE },
 202   { NONE },
 203   { NONE },
 204   { NONE },
 205   { NONE },
 206   { NONE },
 207
 208   { NONE },                    /* ID: 58 */
 209   { NONE },
 210   { COMM, 0, 1, 0x09 },
 211   { NONE },
 212   { NONE },
 213   { NONE },
 214   { NONE },
 215   { NONE }
 216 };
 217
 218
 219 #define PTRDIFF(pe, ps) ((int) (((long) (pe) - (long) (ps)) / sizeof(*pe)))
 220
 221 static char tzxheader[] = {'Z','X','T','a','p','e','!',0x1A};
 222
 223 static int readbuf(void *ptr, int size, /*FILE *fp*/ int fd)
 224 {
 225     /*return (int) fread(ptr, 1, (size_t) size, tapefp);*/
 226     return (int) rb->read(fd, ptr, (size_t) size);
 227 }
 228
 229 static void premature(struct seginfo *csp)
 230 {
 231   csp->segtype = SEG_ERROR;
 232   rb->snprintf(seg_desc,DESC_LEN, "Premature end of segment");
 233 }
 234
 235 static int read_tzx_header(byte *hb, struct seginfo *csp)
 236 {
 237   int res;
 238   int segid, seght;
 239   int lenoffs, lenbytes, lenmul, lenadd;
 240   int hlen;
 241   long length;
 242   byte *hip;
 243
 244   segid = getc(tapefd);
 245   if(segid == EOF) {
 246     csp->segtype = SEG_END;
 247     rb->snprintf(seg_desc,DESC_LEN, "End of Tape");
 248     return 0;
 249   }
 250
 251   hb[0] = (byte) segid;
 252
 253   if(segid < NUMBLOCKID) seght = tzxb[segid].type;
 254   else seght = 0; /* was NONE here*/
 255
 256   if(seght == COMM) {
 257     lenbytes = tzxb[segid].lenbytes;
 258     lenmul   = tzxb[segid].lenmul;
 259     hlen     = tzxb[segid].hlen;
 260     lenadd   = hlen;
 261     lenoffs  = hlen - lenbytes;
 262   }
 263   else {
 264     lenoffs = 0x00;
 265     lenbytes = 4;
 266     lenmul = 1;
 267     lenadd = 0x00;
 268     hlen = 0x04;
 269   }
 270
 271   if(seght == STAN) hlen += tzxb[segid].hlen;
 272
 273   hip = hb+1;
 274   res = readbuf(hip, hlen, tapefd);
 275   if(res != hlen) {
 276     premature(csp);
 277     return 0;
 278   }
 279   length = 0;
 280   for(;lenbytes; lenbytes--)
 281     length = (length << 8) + hip[lenoffs + lenbytes - 1];
 282
 283   length = (length * lenmul) + lenadd - hlen;
 284
 285   csp->len = length;
 286   return 1;
 287 }
 288
 289 static int read_tap_header(byte *hb, struct seginfo *csp)
 290 {
 291   int res;
 292
 293   res = readbuf(hb, 2, tapefd);
 294   if(res < 2) {
 295     if(res == 0) {
 296       csp->segtype = SEG_END;
 297       rb->snprintf(seg_desc,DESC_LEN, "End of Tape");
 298     }
 299     else premature(csp);
 300     return 0;
 301   }
 302   csp->len = DBYTE(hb, 0);
 303   return 1;
 304 }
 305
 306 static int read_header(byte *hb, struct seginfo *csp)
 307 {
 308   segbeg = 0;
 309   csp->ptr = 0;
 310
 311   csp->segtype = SEG_OTHER;
 312   if(tf_tpi.type == TAP_TAP)
 313     return read_tap_header(hb, csp);
 314   else if(tf_tpi.type == TAP_TZX)
 315     return read_tzx_header(hb, csp);
 316
 317   return 0;
 318 }
 319
 320 static void isbeg(void)
 321 {
 322   segbeg = 1;
 323   tf_cseg.len = tf_cseg.ptr = 0;
 324 }
 325
 326
 327 static int end_seg(struct seginfo *csp)
 328 {
 329   if(!segbeg) {
 330     if(csp->len != csp->ptr) {
 331       /*fseek(tapefp, tf_cseg.len - tf_cseg.ptr - 1, SEEK_CUR);*/
 332         rb->lseek(tapefd, tf_cseg.len - tf_cseg.ptr - 1, SEEK_CUR);
 333
 334       if(getc(tapefd) == EOF) {
 335         premature(csp);
 336         return 0;
 337       }
 338     }
 339     segi++;
 340     isbeg();
 341   }
 342   playstate = PL_NONE;
 343   return 1;
 344 }
 345
 346
 347 static int jump_to_segment(int newsegi, struct seginfo *csp)
 348 {
 349   if(newsegi <= segi) {
 350     segi = 0;
 351     isbeg();
 352     /*fseek(tapefp, firstseg_offs, SEEK_SET);*/
 353     rb->lseek(tapefd, firstseg_offs, SEEK_SET);
 354   }
 355   else if(!end_seg(csp)) return 0;
 356
 357   while(segi != newsegi) {
 358     if(!read_header(rbuf, csp)) return 0;
 359     if(!end_seg(csp)) return 0;
 360   }
 361   return 1;
 362 }
 363
 364
 365 static int next_data(void)
 366 {
 367   int res;
 368   if(tf_cseg.ptr == tf_cseg.len) return DAT_END;
 369
 370   res = getc(tapefd);
 371   if(res == EOF) {
 372     rb->snprintf(seg_desc, DESC_LEN,"Premature end of segment");
 373     return DAT_ERR;
 374   }
 375   tf_cseg.ptr++;
 376   return res;
 377 }
 378
 379
 380 static void normal_segment(struct seginfo *csp)
 381 {
 382   rb->snprintf(seg_desc,DESC_LEN, "Data");
 383   csp->type    = ST_NORM;
 384   csp->segtype = SEG_DATA;
 385   csp->pulse   = 2168;   /* 2016 */
 386   csp->num     = 3220;
 387   csp->sync1p  = 667;
 388   csp->sync2p  = 735;
 389   csp->zerop   = 855;   /* 672 */
 390   csp->onep    = 1710;  /* 1568 */
 391   csp->bused   = 8;
 392 }
 393
 394
 395 static int interpret_tzx_header(byte *hb, struct seginfo *csp)
 396 {
 397   int res;
 398   int segid;
 399   byte *hip;
 400   int offs;
 401   dbyte dtmp;
 402
 403   segid = hb[0];
 404   hip = hb+1;
 405
 406   switch(segid) {
 407   case 0x10:
 408     normal_segment(csp);
 409     csp->pause   = DBYTE(hip, 0x00);
 410     break;
 411
 412   case 0x11:
 413     rb->snprintf(seg_desc,DESC_LEN, "Turbo Data");
 414     csp->type    = ST_NORM;
 415     csp->segtype = SEG_DATA_TURBO;
 416     csp->pulse   = DBYTE(hip, 0x00);
 417     csp->sync1p  = DBYTE(hip, 0x02);
 418     csp->sync2p  = DBYTE(hip, 0x04);
 419     csp->zerop   = DBYTE(hip, 0x06);
 420     csp->onep    = DBYTE(hip, 0x08);
 421     csp->num     = DBYTE(hip, 0x0A);
 422     csp->bused   = BYTE(hip, 0x0C);
 423     csp->pause   = DBYTE(hip, 0x0D);
 424     break;
 425
 426   case 0x12:
 427     rb->snprintf(seg_desc,DESC_LEN, "Pure Tone");
 428     csp->type    = ST_NORM;
 429     csp->segtype = SEG_OTHER;
 430     csp->pulse   = DBYTE(hip, 0x00);
 431     csp->num     = DBYTE(hip, 0x02);
 432     csp->sync1p  = 0;
 433     csp->sync2p  = 0;
 434     csp->zerop   = 0;
 435     csp->onep    = 0;
 436     csp->bused   = 0;
 437     csp->pause   = 0;
 438     break;
 439
 440   case 0x13:
 441     rb->snprintf(seg_desc,DESC_LEN, "Pulse Sequence");
 442     csp->type    = ST_PSEQ;
 443     csp->segtype = SEG_OTHER;
 444     csp->pause   = 0;
 445     break;
 446
 447   case 0x14:
 448     rb->snprintf(seg_desc,DESC_LEN, "Pure Data");
 449     csp->type    = ST_NORM;
 450     csp->segtype = SEG_DATA_PURE;
 451     csp->zerop   = DBYTE(hip, 0x00);
 452     csp->onep    = DBYTE(hip, 0x02);
 453     csp->bused   = BYTE(hip, 0x04);
 454     csp->pause   = DBYTE(hip, 0x05);
 455     csp->pulse   = 0;
 456     csp->num     = 0;
 457     csp->sync1p  = 0;
 458     csp->sync2p  = 0;
 459     break;
 460
 461   case 0x15:
 462     rb->snprintf(seg_desc,DESC_LEN, "Direct Recording");
 463     csp->type    = ST_DIRE;
 464     csp->segtype = SEG_OTHER;
 465     csp->pulse   = DBYTE(hip, 0x00);
 466     csp->pause   = DBYTE(hip, 0x02);
 467     csp->bused   = BYTE(hip, 0x04);
 468     break;
 469
 470   case 0x20:
 471     dtmp = DBYTE(hip, 0x00);
 472     if(dtmp == 0) {
 473       if(!tapeopt.stoppause) {
 474     csp->type = ST_MISC;
 475     csp->segtype = SEG_STOP;
 476       }
 477       else {
 478     csp->pause = tapeopt.stoppause * 1000;
 479     csp->type = ST_NORM;
 480     csp->segtype = SEG_PAUSE;
 481       }
 482       rb->snprintf(seg_desc,DESC_LEN, "Stop the Tape Mark");
 483     }
 484     else {
 485       csp->pause = dtmp;
 486       csp->type = ST_NORM;
 487       csp->segtype = SEG_PAUSE;
 488       rb->snprintf(seg_desc,DESC_LEN, "Pause for %i.%03is",
 489           csp->pause / 1000, csp->pause % 1000);
 490     }
 491     csp->pulse   = 0;
 492     csp->num     = 0;
 493     csp->sync1p  = 0;
 494     csp->sync2p  = 0;
 495     csp->zerop   = 0;
 496     csp->onep    = 0;
 497     csp->bused   = 0;
 498     break;
 499
 500   case 0x21:
 501     csp->type    = ST_MISC;
 502     csp->segtype = SEG_GRP_BEG;
 503     res = readbuf(rbuf, csp->len, tapefd);
 504     if(res != (int) csp->len) {
 505       premature(csp);
 506       return 0;
 507     }
 508     csp->ptr += csp->len;
 509     {
 510       int blen;
 511       rb->snprintf(seg_desc,DESC_LEN, "Begin Group: ");
 512       blen = (int) rb->strlen(seg_desc);
 513       rb->strlcpy(seg_desc+blen, (char *) rbuf, (unsigned) csp->len + 1);
 514     }
 515     break;
 516
 517   case 0x22:
 518     rb->snprintf(seg_desc,DESC_LEN, "End Group");
 519     csp->type    = ST_MISC;
 520     csp->segtype = SEG_GRP_END;
 521     break;
 522
 523   case 0x23:
 524     offs = (signed short) DBYTE(hip, 0x00);
 525     if(offs == 0) {
 526       rb->snprintf(seg_desc,DESC_LEN, "Infinite loop");
 527       csp->type = ST_MISC;
 528       csp->segtype = SEG_STOP;
 529     }
 530     else {
 531       csp->type = ST_MISC;
 532       csp->segtype = SEG_SKIP;
 533       rb->snprintf(seg_desc,DESC_LEN, "Jump to %i", segi+offs);
 534       jump_to_segment(segi + offs, csp);
 535     }
 536     break;
 537
 538   case 0x24:
 539     loopctr = DBYTE(hip, 0x00);
 540     rb->snprintf(seg_desc,DESC_LEN, "Loop %i times", loopctr);
 541     loopbeg = segi+1;
 542     csp->type    = ST_MISC;
 543     csp->segtype = SEG_SKIP;
 544     break;
 545
 546   case 0x25:
 547     csp->type    = ST_MISC;
 548     csp->segtype = SEG_SKIP;
 549     if(loopctr) loopctr--;
 550     if(loopctr) {
 551       jump_to_segment(loopbeg, csp);
 552       rb->snprintf(seg_desc,DESC_LEN, "Loop to: %i", loopbeg);
 553     }
 554     else rb->snprintf(seg_desc,DESC_LEN, "Loop End");
 555     break;
 556
 557   case 0x26:
 558     csp->type    = ST_MISC;
 559     csp->segtype = SEG_SKIP;
 560     dtmp = DBYTE(hip, 0x00);
 561     if(callctr < dtmp) {
 562       int offset;
 563       callbeg = segi;
 564       /*fseek(tapefp, callctr*2, SEEK_CUR);*/
 565       rb->lseek(tapefd, callctr*2, SEEK_CUR);
 566       csp->ptr += callctr*2;
 567       res = readbuf(rbuf, 2, tapefd);
 568       if(res != 2) {
 569     premature(csp);
 570     return 0;
 571       }
 572       csp->ptr += 2;
 573       offset = (signed short) DBYTE(rbuf, 0x00);
 574       rb->snprintf(seg_desc,DESC_LEN, "Call to %i", segi+offset);
 575       jump_to_segment(segi+offset, csp);
 576       callctr++;
 577     }
 578     else {
 579       callctr = 0;
 580       rb->snprintf(seg_desc,DESC_LEN, "Call Sequence End");
 581     }
 582     break;
 583
 584   case 0x27:
 585     csp->type    = ST_MISC;
 586     csp->segtype = SEG_SKIP;
 587     rb->snprintf(seg_desc,DESC_LEN, "Return");
 588     if(callctr > 0) jump_to_segment(callbeg, csp);
 589     break;
 590
 591   case 0x28:
 592     rb->snprintf(seg_desc,DESC_LEN, "Selection (Not yet supported)");
 593     csp->type    = ST_MISC;
 594     csp->segtype = SEG_SKIP;
 595     break;
 596
 597   case 0x2A:
 598     if(tapeopt.machine == MACHINE_48) {
 599       rb->snprintf(seg_desc,DESC_LEN, "Stop the Tape in 48k Mode (Stopped)");
 600       csp->type = ST_MISC;
 601       csp->segtype = SEG_STOP;
 602     }
 603     else {
 604       rb->snprintf(seg_desc,DESC_LEN, "Stop the Tape in 48k Mode (Not Stopped)");
 605       csp->type = ST_MISC;
 606       csp->segtype = SEG_SKIP;
 607     }
 608     break;
 609
 610   case 0x31:
 611   case 0x30:
 612     csp->type    = ST_MISC;
 613     csp->segtype = SEG_SKIP;
 614     res = readbuf(rbuf, csp->len, tapefd);
 615     if(res != (int) csp->len) {
 616       premature(csp);
 617       return 0;
 618     }
 619     csp->ptr += csp->len;
 620     rb->strlcpy(seg_desc, (char *) rbuf, (unsigned) csp->len + 1);
 621     break;
 622
 623   case 0x32:
 624     csp->type    = ST_MISC;
 625     csp->segtype = SEG_SKIP;
 626     {
 627       int numstr, i;
 628
 629       i = 0;
 630       numstr = next_data();
 631       for(;numstr > 0; numstr--) {
 632     int tlen, tid, b;
 633
 634     tid = next_data();
 635     tlen = next_data();
 636     if(tid < 0 || tlen < 0) return 0;
 637
 638     for(; tlen; tlen--) {
 639       b = next_data();
 640       if(b < 0) return 0;
 641       seg_desc[i++] = b;
 642     }
 643     seg_desc[i++] = '\n';
 644       }
 645       seg_desc[i] = '\0';
 646     }
 647     break;
 648
 649   case 0x33:
 650     rb->snprintf(seg_desc,DESC_LEN, "Hardware Information (Not yet supported)");
 651     csp->type    = ST_MISC;
 652     csp->segtype = SEG_SKIP;
 653     break;
 654
 655   case 0x34:
 656     rb->snprintf(seg_desc, DESC_LEN,"Emulation Information (Not yet supported)");
 657     csp->type    = ST_MISC;
 658     csp->segtype = SEG_SKIP;
 659     break;
 660
 661   case 0x35:
 662     rb->snprintf(seg_desc,DESC_LEN, "Custom Information (Not yet supported)");
 663     csp->type    = ST_MISC;
 664     csp->segtype = SEG_SKIP;
 665     break;
 666
 667   case 0x40:
 668     rb->snprintf(seg_desc, DESC_LEN,"Snapshot (Not yet supported)");
 669     csp->type    = ST_MISC;
 670     csp->segtype = SEG_SKIP;
 671     break;
 672
 673   case 0x5A:
 674     rb->snprintf(seg_desc, DESC_LEN,"Tapefile Concatenation Point");
 675     csp->type    = ST_MISC;
 676     csp->segtype = SEG_SKIP;
 677
 678   default:
 679     csp->type    = ST_MISC;
 680     csp->segtype = SEG_SKIP;
 681     rb->snprintf(seg_desc,DESC_LEN, "Unknown TZX block (id: %02X, version: %i.%02i)",
 682         segid, tf_tpi.tzxmajver, tf_tpi.tzxminver);
 683     break;
 684   }
 685
 686   return 1;
 687 }
 688
 689 static int interpret_header(byte *hb, struct seginfo *csp)
 690 {
 691   if(tf_tpi.type == TAP_TAP) {
 692     normal_segment(csp);
 693     csp->pause   = DEF_LEAD_PAUSE;
 694
 695     return 1;
 696   }
 697   else if(tf_tpi.type == TAP_TZX)
 698     return interpret_tzx_header(hb, csp);
 699
 700   return 0;
 701 }
 702
 703 byte *tf_get_block(int i)
 704 {
 705   seg_desc[0] = '\0';
 706
 707   if(jump_to_segment(i, &tf_cseg)) {
 708     tf_segoffs = ftell(tapefd);
 709
 710     if(read_header(rbuf, &tf_cseg) &&
 711        interpret_header(rbuf, &tf_cseg)) return rbuf;
 712   }
 713   return NULL;
 714 }
 715
 716
 717 int next_byte(void)
 718 {
 719   playstate = PL_NONE;
 720   return next_data();
 721 }
 722
 723 #define DPULSE(v1,v2) (*impbuf++=(v1), *impbuf++=(v2), timelen-=(v1)+(v2))
 724 #define PULSE(v) (*impbuf++=(v), currlev = !currlev, timelen-=(v))
 725
 726 int next_imps(unsigned short *impbuf, int buflen, long timelen)
 727 {
 728   static int toput;
 729   static int bitrem;
 730   static dbyte dirpulse;
 731   unsigned short *impbufend, *impbufstart;
 732
 733   impbufstart = impbuf;
 734   impbufend = impbuf + buflen;
 735
 736   while(impbuf < impbufend - 1 && timelen > 0) {
 737     switch(playstate) {
 738
 739     case PL_PAUSE:
 740       if(currlev && lead_pause) {
 741     PULSE(IMP_1MS);
 742     lead_pause --;
 743       }
 744       else if(lead_pause > 10) {
 745     if(tapeopt.blanknoise && !(rb->rand() % 64))
 746       DPULSE(IMP_1MS * 10 - 1000, 1000);
 747     else
 748       DPULSE(IMP_1MS * 10, 0);
 749     lead_pause -= 10;
 750       }
 751       else if(lead_pause) {
 752     DPULSE(IMP_1MS, 0);
 753     lead_pause --;
 754       }
 755       else {
 756     if(tf_cseg.num || tf_cseg.sync1p || tf_cseg.sync2p ||
 757        tf_cseg.ptr != tf_cseg.len) finished = 0;
 758
 759     switch (tf_cseg.type) {
 760     case ST_NORM: playstate = PL_LEADER; break;
 761     case ST_DIRE: playstate = PL_DIRE;   dirpulse = 0; break;
 762     case ST_PSEQ: playstate = PL_PSEQ;   break;
 763     default:      playstate = PL_NONE;
 764     }
 765       }
 766       break;
 767
 768     case PL_LEADER:
 769       if(tf_cseg.num >= 2) {
 770     DPULSE(tf_cseg.pulse, tf_cseg.pulse);
 771     tf_cseg.num -= 2;
 772       }
 773       else
 774       if(tf_cseg.num) {
 775     PULSE(tf_cseg.pulse);
 776     tf_cseg.num --;
 777       }
 778       else { /* PL_SYNC */
 779     if(tf_cseg.sync1p || tf_cseg.sync2p)
 780       DPULSE(tf_cseg.sync1p, tf_cseg.sync2p);
 781     bitrem = 0;
 782     playstate = PL_DATA;
 783       }
 784       break;
 785
 786     case PL_DATA:
 787       if(!bitrem) {
 788     toput = next_data();
 789     if(toput < 0) {
 790       playstate = PL_END;
 791       break;
 792     }
 793     if(tf_cseg.ptr != tf_cseg.len) {
 794       if(timelen > 16 * max(tf_cseg.onep, tf_cseg.zerop) &&
 795          impbuf <= impbufend - 16) {
 796         int p1, p2, br, tp;
 797
 798         p1 = tf_cseg.onep;
 799         p2 = tf_cseg.zerop;
 800         br = 8;
 801         tp = toput;
 802
 803         while(br) {
 804           if(tp & 0x80) DPULSE(p1, p1);
 805           else          DPULSE(p2, p2);
 806           br--;
 807           tp <<= 1;
 808         }
 809         bitrem = 0;
 810         break;
 811       }
 812       bitrem = 8;
 813     }
 814     else {
 815       bitrem = tf_cseg.bused;
 816       if(!bitrem) break;
 817     }
 818       }
 819       if(toput & 0x80) DPULSE(tf_cseg.onep, tf_cseg.onep);
 820       else             DPULSE(tf_cseg.zerop, tf_cseg.zerop);
 821       bitrem--, toput <<= 1;
 822       break;
 823
 824     case PL_PSEQ:
 825       {
 826     int b1, b2;
 827     dbyte pulse1, pulse2;
 828     b1 = next_data();
 829     b2 = next_data();
 830     if(b1 < 0 || b2 < 0) {
 831       playstate = PL_END;
 832       break;
 833     }
 834     pulse1 = b1 + (b2 << 8);
 835
 836     b1 = next_data();
 837     b2 = next_data();
 838     if(b1 < 0 || b2 < 0) {
 839       PULSE(pulse1);
 840       playstate = PL_END;
 841       break;
 842     }
 843     pulse2 = b1 + (b2 << 8);
 844     DPULSE(pulse1, pulse2);
 845       }
 846       break;
 847
 848     case PL_DIRE:
 849       for(;;) {
 850     if(!bitrem) {
 851       toput = next_data();
 852       if(toput < 0) {
 853         playstate = PL_END;
 854         DPULSE(dirpulse, 0);
 855         break;
 856       }
 857       if(tf_cseg.ptr != tf_cseg.len) bitrem = 8;
 858       else {
 859         bitrem = tf_cseg.bused;
 860         if(!bitrem) break;
 861       }
 862     }
 863     bitrem--;
 864     toput <<= 1;
 865     if(((toput & 0x0100) ^ (currlev ? 0x0100 : 0x00))) {
 866       PULSE(dirpulse);
 867       dirpulse = tf_cseg.pulse;
 868       break;
 869     }
 870     dirpulse += tf_cseg.pulse;
 871     if(dirpulse >= 0x8000) {
 872       DPULSE(dirpulse, 0);
 873       dirpulse = 0;
 874       break;
 875     }
 876       }
 877       break;
 878
 879     case PL_END:
 880       if(tf_cseg.pause) {
 881     PULSE(IMP_1MS);
 882     tf_cseg.pause--;
 883     if(currlev) PULSE(0);
 884     finished = 1;
 885       }
 886       playstate = PL_NONE;
 887       break;
 888
 889     case PL_NONE:
 890     default:
 891       return PTRDIFF(impbuf, impbufstart);
 892     }
 893   }
 894
 895   return PTRDIFF(impbuf, impbufstart);
 896 }
 897
 898
 899 int next_segment(void)
 900 {
 901   if(endnext) {
 902     endnext = 0;
 903     tf_cseg.segtype = endtype;
 904     tf_cseg.pause = endpause;
 905     playstate = endplay;
 906     return tf_cseg.segtype;
 907   }
 908
 909   seg_desc[0] = '\0';
 910   lead_pause = tf_cseg.pause;
 911
 912   if(end_seg(&tf_cseg)) {
 913     currsegi = segi;
 914     if(read_header(rbuf, &tf_cseg)) interpret_header(rbuf, &tf_cseg);
 915   }
 916
 917   if(tf_cseg.segtype >= SEG_DATA) {
 918     playstate = PL_PAUSE;
 919     if(lead_pause) finished = 1;
 920   }
 921   else playstate = PL_NONE;
 922
 923   if(tf_cseg.segtype <= SEG_STOP && !finished) {
 924     endnext = 1;
 925     endtype = tf_cseg.segtype;
 926     endpause = tf_cseg.pause;
 927     endplay  = playstate;
 928     if(lead_pause > 0) lead_pause--;
 929
 930     tf_cseg.pause = 1;
 931     tf_cseg.segtype = SEG_VIRTUAL;
 932     playstate = PL_END;
 933   }
 934
 935   return tf_cseg.segtype;
 936 }
 937
 938 int goto_segment(int at_seg)
 939 {
 940   int res;
 941
 942   res = jump_to_segment(at_seg, &tf_cseg);
 943   tf_cseg.pause = DEF_LEAD_PAUSE;
 944
 945   return res;
 946 }
 947
 948 unsigned segment_pos(void)
 949 {
 950   return currsegi;
 951 }
 952
 953 void close_tapefile(void)
 954 {
 955   if(tapefd != -1) {
 956     playstate = PL_NONE;
 957     rb->close(tapefd);
 958     tapefd = -1;
 959   }
 960 }
 961
 962 int open_tapefile(char *name, int type)
 963 {
 964   int res;
 965   int ok;
 966
 967   seg_desc[0] = '\0';
 968   currlev = 0;
 969
 970   if(type != TAP_TAP && type != TAP_TZX) {
 971     rb->snprintf(seg_desc,DESC_LEN, "Illegal tape type");
 972     return 0;
 973   }
 974
 975   /*tapefp = fopen(name, "rb");*/
 976   tapefd = rb->open(name, O_RDONLY);
 977   if(tapefd < 0 ) {
 978     /*rb->snprintf(seg_desc,DESC_LEN, "Could not open `%s': %s", name, strerror(errno));*/
 979     return 0;
 980   }
 981
 982   tf_tpi.type = type;
 983   tf_cseg.pause = DEF_LEAD_PAUSE;
 984   INITTAPEOPT(tapeopt);
 985
 986   currsegi = segi = 0;
 987   isbeg();
 988
 989   firstseg_offs = 0;
 990
 991   ok = 1;
 992
 993   if(tf_tpi.type == TAP_TZX) {
 994
 995     firstseg_offs = 10;
 996     res = readbuf(rbuf, 10, tapefd);
 997     if(res == 10 && rb->strncasecmp((char *)rbuf, tzxheader, 8) == 0) {
 998       tf_tpi.tzxmajver = rbuf[8];
 999       tf_tpi.tzxminver = rbuf[9];
1000
1001       if(tf_tpi.tzxmajver > TZXMAJPROG) {
1002     rb->snprintf(seg_desc, DESC_LEN,
1003         "Cannot handle TZX file version (%i.%02i)",
1004         tf_tpi.tzxmajver, tf_tpi.tzxminver);
1005     ok = 0;
1006       }
1007     }
1008     else {
1009       rb->snprintf(seg_desc,DESC_LEN, "Illegal TZX file header");
1010       ok = 0;
1011     }
1012   }
1013
1014   if(!ok) {
1015     close_tapefile();
1016     return 0;
1017   }
1018   endnext = 0;
1019
1020   loopctr = 0;
1021   callctr = 0;
1022
1023   return 1;
1024 }
1025
1026 int get_level(void)
1027 {
1028   return currlev;
1029 }
1030
1031 long get_seglen(void)
1032 {
1033   return tf_cseg.len;
1034 }
1035
1036 long get_segpos(void)
1037 {
1038   return tf_cseg.ptr;
1039 }
1040
1041 void set_tapefile_options(struct tape_options *to)
1042 {
1043   rb->memcpy(&tapeopt, to, sizeof(tapeopt));
1044 }
1045