home *** CD-ROM | disk | FTP | other *** search
/ Emulator Universe CD / emulatoruniversecd1998.iso / CPC / Utils / DSKutil / XTI_CONV.C < prev    next >
Encoding:
Text File  |  1996-12-13  |  15.8 KB  |  615 lines
  1. /* XTI 1.2b - format convertors */
  2. /* filename : xti_conv.c */
  3.  
  4.  
  5.  
  6. /* global flags, buffers and counters */
  7.  
  8.  
  9. int theFormat;
  10. int theSide;
  11. int theCut;
  12. unsigned char theCutLo;
  13. unsigned char theCutHi;
  14. int DETrick;
  15.  
  16. FILE *Source;
  17. FILE *Merger;
  18. FILE *Target;
  19.  
  20. #define k8KB  0x2000
  21. #define k16KB 0x4000
  22.  
  23. unsigned char TrackBuff[k16KB]; /* target track including header, at most 16k */
  24. unsigned char HeaderBuff[256];  /* target file header */
  25. unsigned char  InputBuff[k8KB]; /* source header: at most 8k */
  26. unsigned char SectorBuff[k8KB]; /* glue buffer: 8k */
  27.  
  28. long targetOffset;   /* offset to end of target file (after header) */
  29. int  trackOffset;    /* offset to next track size in header */
  30. int  SInfoOffset;    /* offset to next sector info list in track buffer */
  31. int  SDataOffset;    /* offset to next sector data in same buffer */
  32.  
  33. int extCall;
  34.  
  35. #define kOldSizeOffset  0x32
  36. #define kTrackNumOffset 0x30
  37. #define kSideNumOffset  0x31
  38.  
  39. #define min(i,j) (((i)>(j))?(j):(i))
  40. #define max(i,j) (((i)>(j))?(i):(j))
  41.  
  42. #define kNUL 255
  43.  
  44.  
  45. /* conversion sub routines */
  46.  
  47.  
  48.  
  49.  
  50.  
  51. void Reset()
  52. {
  53.  #if MSDOS == 1
  54.  _fmode = O_BINARY;
  55.  #endif
  56.  
  57.  targetOffset = 256;
  58.  trackOffset  = 0x34;
  59.  theCut  = 6*1024;
  60.  theFormat = kNUL;
  61.  DETrick = 0;
  62.  extCall = 0;
  63. }
  64.  
  65. int NtoSize(unsigned char N)
  66. {
  67.  int i = (0x80 << min(N,8));
  68.  
  69.  return ( min(i,theCut) );
  70. }
  71.  
  72. long Bword32Load(FILE *source)    /* load a big endian long from file */
  73. {
  74.  long i = 0, j;
  75.  
  76.  for(j=0; j<4; j++) i = ((i<<8) | fgetc(source));
  77.  return(i);
  78. }
  79.  
  80. long Bword32Acc(unsigned char *buff)   /* compute big endian long from buffer */
  81. {
  82.  long i = 0, j;
  83.  
  84.  for (j=0; j<4; j++) i = ((i<<8) | (*buff++));
  85.  return(i);
  86. }
  87.  
  88. long Lword32Acc(unsigned char *buff)  /* compute little endian long from buffer */
  89. {
  90.  long i = *buff++;
  91.  i |= ((*buff++)<<8);
  92.  i |= ((*buff++)<<16);
  93.  i |= ((*buff++)<<24);
  94.  return(i);
  95. }
  96.  
  97.  
  98.  
  99. void SetUpDSKHeader(unsigned char *Buff, int numtrack, int numside)
  100. {
  101.  int i;
  102.  for(i=0; i<256; i++) Buff[i] = 0;
  103.  
  104.  sprintf(Buff, "EXTENDED CPC DSK File\r\nDisk-Info\r\n");
  105.  sprintf(Buff + 34 , "Image XTender\n");
  106.  
  107.  if ((numtrack > 100) || (numside > 2))
  108.      { fprintf(stderr,"Error: Invalid structure !\n");   exit(6); }
  109.  Buff[kTrackNumOffset] = numtrack;
  110.  Buff[kSideNumOffset] = (numside & 0x3F) | (DETrick << 7);
  111. }
  112.  
  113.  
  114. void SetUpTrackHeader(unsigned char *Buff,  int tracknum, int sidenum,
  115.                               int sectsize, int numsect,
  116.                               unsigned char GAP, unsigned char filler)
  117. {
  118.  int i;
  119.  for(i=0; i<k16KB; i++) Buff[i] = 0;
  120.  
  121.  sprintf (Buff, "Track-Info\r\n");
  122.  
  123.  Buff[0x10] = tracknum;
  124.  Buff[0x11] = sidenum;
  125.  Buff[0x14] = sectsize;
  126.  Buff[0x15] = numsect;
  127.  Buff[0x16] = GAP;
  128.  Buff[0x17] = filler;
  129.  SInfoOffset = 0x18;      /* set up for future increments */
  130.  SDataOffset = 256;
  131. }
  132.  
  133.  
  134. void StoreTrack(unsigned char *Buff)
  135. {
  136.  int i;
  137.  
  138.  if (SDataOffset & 255) SDataOffset = (SDataOffset & 0xFF00) + 0x100; /* rounding */
  139.  HeaderBuff[trackOffset++] = SDataOffset >> 8;
  140.  fseek (Target, targetOffset, SEEK_SET);    /* make sure we're at the right place */
  141.  for (i=0; i<SDataOffset; i++) fputc(Buff[i], Target);       /* dump with padding */
  142.  targetOffset += SDataOffset;
  143. }
  144.  
  145.  
  146. void StoreHeader(unsigned char *Buff)
  147. {
  148.  int i;
  149.  unsigned char test;
  150.  int ok = 1;
  151.  
  152.  fseek(Target, 0, 0);
  153.  for (i= trackOffset-1; (Buff[i]==0) && (i > 0x33); i--) ; /* fewer tracks than expected */
  154.  if (1 == Buff[kSideNumOffset]) Buff[kTrackNumOffset] = i-0x33; /* careful rounding */
  155.            else  Buff[kTrackNumOffset] = (i-0x32)>>1;
  156.  
  157.  test = Buff[0x34];     /* compute old style track length - may be removed ! */
  158.  for (i=0x35; i<0x34+Buff[kTrackNumOffset]; i++)
  159.                        if (Buff[i] != test) {ok =0; break;}
  160.  if (ok) Buff[kOldSizeOffset+1] = test;
  161.  for (i=0; i<256; i++) fputc(Buff[i], Target);
  162. }
  163.  
  164.  
  165. void AddSector(unsigned char *Buff, unsigned char *SourceBuff,
  166.                int track, int side, unsigned char ID, unsigned char N,
  167.                unsigned char ST1, unsigned char ST2, int length)
  168. {
  169.  int i;
  170.  
  171.  Buff[SInfoOffset++] = track;
  172.  Buff[SInfoOffset++] = side; 
  173.  Buff[SInfoOffset++] = ID;
  174.  Buff[SInfoOffset++] = N;
  175.  Buff[SInfoOffset++] = ST1;
  176.  Buff[SInfoOffset++] = ST2;
  177.  Buff[SInfoOffset++] = length;
  178.  Buff[SInfoOffset++] = length >> 8;
  179.  
  180.  if ( (SDataOffset + length) > k16KB)
  181.      { fprintf(stderr,"Error: Track too long !\n");   exit(5); }
  182.  for(i=0; i<length; i++) Buff[SDataOffset++] = SourceBuff[i];
  183. }
  184.  
  185.  
  186.  
  187.  
  188.  
  189.  
  190. /* format convertors start here */
  191.  
  192.  
  193.  
  194.  
  195.  
  196. void edsk2edsk()     /* when flag extCall (extractor call) armed, keeps only one side */
  197. {
  198.  int i,c,k,l, Tsize, t,tno,sno,sno2;
  199.  int unique = 1, FirstSize;
  200.  unsigned char TrS[256];
  201.  unsigned char TrS2[256];
  202.  
  203.  fseek(Source, 0x30, 0);
  204.  fputs("EXTENDED CPC DSK File\r\nDisk-Info\r\n" , Target);
  205.  fputs("Image XTender\n" , Target);
  206.  
  207.  for(c=0x30; c<256; c++) TrS2[c] = TrS[c] = fgetc(Source);
  208.  k = l = 0x34;
  209.  sno = sno2 = TrS[kSideNumOffset];
  210.  if (extCall)
  211.    {
  212.    if (theSide) k++;
  213.    for(c=k; c<256; c += 2) TrS2[l++] = TrS[c];  /* skip unneeded tracks */
  214.    sno2 = 1;
  215.    }
  216.  
  217.  for (i = TrS[kTrackNumOffset]*sno2+0x34; (TrS2[i]==0) && (i > 0x33); i--) ;
  218.                                           /* fewer tracks than expected */
  219.  if (sno != 2)
  220.      {  /* single sided */
  221.      if (extCall)
  222.         { fprintf(stderr,"Error: Image is single-sided !\n"); exit(14); }
  223.      TrS2[kTrackNumOffset] = i-0x33;
  224.      }
  225.    else
  226.      {
  227.      if (extCall) TrS2[kTrackNumOffset] = i-0x33;   /* same as single side */
  228.         else TrS2[kTrackNumOffset] = (i-0x32)>>1;      /* careful rounding */
  229.      }
  230.  for(i=0x30; i<256; i++) fputc(TrS2[i], Target);
  231.  
  232.  FirstSize = TrS[k]<<8;
  233.  
  234.  for(t=0; t<TrS[kTrackNumOffset]*sno; t++)
  235.   {
  236.   Tsize = TrS[t+0x34]<<8;
  237.   if (extCall && ((t&1) ^ theSide) )
  238.      { fseek(Source, Tsize, SEEK_CUR); continue; }
  239.   if (Tsize != FirstSize) unique = 0;
  240.   if (!Tsize) continue;         /* track missing: nothing to clean */
  241.  
  242.   fseek(Source, 16, SEEK_CUR);
  243.   fputs("Track-Info\r\n", Target);
  244.   for(c=12; c<16; c++) fputc(0, Target);
  245.   tno = fgetc(Source);
  246.   sno2 = fgetc(Source);
  247.   fputc(tno, Target);
  248.   if (extCall) fputc(0, Target); else fputc(sno2, Target);
  249.   for(c=18; c<Tsize; c++) fputc(fgetc(Source), Target);
  250.   }
  251.  
  252.  if (!extCall)
  253.    while( (c = getc(Source)) != EOF) fputc( c ,Target); /* support for supertrack */
  254.  
  255.  fseek(Target, kSideNumOffset, SEEK_SET);
  256.  
  257.  if (!extCall)
  258.     fputc( (TrS[kSideNumOffset] & 0x3F) | (DETrick<<7) ,Target);  /* DE marking */
  259.    else
  260.     fputc(1 | (TrS[kSideNumOffset] & 128) , Target);
  261.             /* don't change anything if called from extractor */
  262.  
  263.  if (unique) {fputc(0, Target); fputc(TrS[k],Target);}
  264. }
  265.  
  266.  
  267.  
  268. void dif2edsk()
  269. {
  270.  int i,j,k, NumSect;
  271.  unsigned char filler;
  272.  int InputPt;  /* used to scan header in InputBuff */ 
  273.  int size, size2, NTr;
  274.  unsigned char N, ST2;
  275.  
  276.  for(i=0; i<k8KB; i++) InputBuff[i] = fgetc(Source);
  277.  SetUpDSKHeader(HeaderBuff,NTr = InputBuff[1], 1);
  278.  InputPt = 2;              /* first track descriptor */
  279.  
  280. for (j=0; j<NTr; j++)
  281.  {
  282.  NumSect = InputBuff[InputPt++];
  283.  
  284.  if (NumSect == 0) SDataOffset = 0; else   /* unformatted track */
  285.   {
  286.   SetUpTrackHeader(TrackBuff, j ,0, 2, NumSect, 0x4e, 0xe5 );
  287.   for (k=0; k<NumSect; k++)
  288.    {
  289.    size = NtoSize(N = InputBuff[InputPt+3]); /* in target */
  290.    size2 = (0x80 << min(N,8));               /* in source */
  291.    size2 = min(k8KB,size2);   /* Sector buffer limit = 8k */
  292.  
  293.    if ((ST2 = InputBuff[InputPt+6])>>7)
  294.          {
  295.          filler = InputBuff[InputPt+7];
  296.          for (i=0; i<size; i++) SectorBuff[i] = filler;  /* decompress sector */
  297.          }
  298.       else
  299.          for (i=0; i<size2; i++) SectorBuff[i] = fgetc(Source);
  300.  
  301.    if ((SDataOffset+size) > k16KB) size = 0;     /* fix some special protections */
  302.    AddSector(TrackBuff, SectorBuff, InputBuff[InputPt], InputBuff[InputPt+1],
  303.                                     InputBuff[InputPt+2], N, InputBuff[InputPt+5],
  304.                                     ST2 & 0x7F, size);
  305.    InputPt += 8;
  306.    }
  307.   }
  308.  
  309.  StoreTrack(TrackBuff);
  310.  }
  311. StoreHeader(HeaderBuff);
  312. }
  313.  
  314.  
  315.  
  316. void Odif2edsk()
  317. {
  318.  int i,j,k, NumSect;
  319.  unsigned char filler;
  320.  int InputPt;  /* used to scan header in InputBuff */ 
  321.  int size, size2, NTr;
  322.  unsigned char N, ST1, ST2;
  323.  
  324.  for(i=0; i<2048; i++) InputBuff[i] = fgetc(Source);      /* shorter header */
  325.  SetUpDSKHeader(HeaderBuff,NTr = InputBuff[1], 1);
  326.  InputPt = 2;              /* first track descriptor */
  327.  
  328. for (j=0; j<NTr; j++)
  329.  {
  330.  NumSect = InputBuff[InputPt++];
  331.  
  332.  if (NumSect == 0) SDataOffset = 0; else   /* unformatted track */
  333.   {
  334.   SetUpTrackHeader(TrackBuff, j ,0, 2, NumSect, 0x4e, 0xe5 );
  335.   for (k=0; k<NumSect; k++)
  336.    {
  337.    size = NtoSize(N = InputBuff[InputPt+3]); /* in target */
  338.    size2 = (0x80 << min(N,8));               /* in source */
  339.    size2 = min(k8KB,size2);   /* Sector buffer limit = 8k */
  340.  
  341.    for (i=0; i<size2; i++) SectorBuff[i] = fgetc(Source);
  342.  
  343.    if (N > 5) { ST1 = ST2 = 0x20; } else { ST1 = 0x80; ST2 = 0;}
  344.    if ((SDataOffset+size) > k16KB) size = 0;     /* fix some special protections */
  345.  
  346.    AddSector(TrackBuff, SectorBuff, InputBuff[InputPt], InputBuff[InputPt+1],
  347.                                                                   InputBuff[InputPt+2], N, ST1, ST2, size);
  348.    InputPt += 4;     /* shorter sector descriptors */
  349.    }
  350.   }
  351.  
  352.  StoreTrack(TrackBuff);
  353.  }
  354. StoreHeader(HeaderBuff);
  355. }
  356.  
  357.  
  358.  
  359. void dsk2edsk()
  360. {
  361.  int i,j,k,l;
  362.  int SectSize, ShiftSize, Ts;
  363.  long Toffset;
  364.  int SizePt, HeadPt, NTr, Ns;
  365.  
  366.  for(i=0; i<256; i++) InputBuff[i] = fgetc(Source);
  367.  Ts = InputBuff[kOldSizeOffset] + (InputBuff[kOldSizeOffset+1]<<8);
  368.  SetUpDSKHeader(HeaderBuff, NTr = InputBuff[kTrackNumOffset],
  369.                              Ns =  InputBuff[kSideNumOffset]);
  370.  for(i=64; i<256; i++) HeaderBuff[i] = InputBuff[i];  /* copy some extra data */
  371.  
  372.  for(i=0; i<NTr; i++) /* loop on cylinders */
  373.   for(j=0; j<Ns; j++) /* loop on surfaces */
  374.    {
  375.    fseek(Source, Toffset = 256L+(long)Ts*(i*Ns +j), SEEK_SET);
  376.    for(k=0; k<256; k++) TrackBuff[k] = fgetc(Source);  /* copy everything */
  377.    sprintf(TrackBuff, "Track-Info\r\n");
  378.  
  379.    if (TrackBuff[0x15])
  380.     {
  381.     SizePt = 0x18+6;
  382.     ShiftSize = 128<<TrackBuff[0x14]; /* unique size in source */
  383.     SDataOffset = 256;
  384.  
  385.     for(k=0; k<TrackBuff[0x15]; k++)
  386.      {
  387.      fseek(Source, Toffset+k*ShiftSize+256, SEEK_SET);
  388.      SectSize = NtoSize(TrackBuff[SizePt-3]);
  389.        if ( (SDataOffset + SectSize) > k16KB)
  390.               { fprintf(stderr,"Error: Track too long !\n");   exit(5); }
  391.      for (l=0; l<SectSize; l++) TrackBuff[SDataOffset++] = fgetc(Source);
  392.  
  393.      TrackBuff[SizePt] = SectSize;
  394.      TrackBuff[SizePt+1] = SectSize>>8;  /* add new data to sector info */
  395.      SizePt += 8;
  396.        if ( SizePt > 255 )
  397.               { fprintf(stderr,"Error: Invalid structure !\n");   exit(6); }
  398.      }
  399.     } else SDataOffset = 0;   /* unformatted track */
  400.  
  401.    StoreTrack(TrackBuff);
  402.    }
  403.  
  404.  StoreHeader(HeaderBuff);
  405. }
  406.  
  407.  
  408.  
  409. void cpd2edsk()
  410. {
  411.  int j,k, Ntr, Max_SectSize, NumSect;
  412.  long i;
  413.  unsigned char C,H,R,N,ST1,ST2;
  414.  int size;
  415.  
  416.  fseek(Source, 8, SEEK_SET);
  417.  Ntr = fgetc(Source);
  418.  SetUpDSKHeader(HeaderBuff, Ntr, 1);
  419.  
  420.  for(i=0; i<Ntr; i++)
  421.  {
  422.  fseek(Source, 9+(5120+132)*i, SEEK_SET);
  423.  for(j=0; j<132; j++) InputBuff[j] = fgetc(Source);
  424.  for(j=0, Max_SectSize = 0; j<132; j++)
  425.  {
  426.   if (InputBuff[j] == 0xFF) break;  /* count sectors */
  427.   if (InputBuff[j+66] > Max_SectSize)
  428.    Max_SectSize = InputBuff[j+66];
  429.  }
  430.  NumSect = j;
  431.  
  432.  if (NumSect)
  433.   {
  434.   SetUpTrackHeader(TrackBuff, i, 0, Max_SectSize, NumSect, 0x4e, 0xe5);
  435.   for(j=0; j<NumSect; j++)
  436.     {
  437.     size = NtoSize(N = InputBuff[j+66]);
  438.     C = i;
  439.     H = 0;
  440.     R = InputBuff[j];
  441.     ST1 = 0x80;
  442.     ST2 = 0;
  443.  
  444.     if (size > k8KB) { fprintf(stderr, "Error: Sector too long !\n"); exit(7); }
  445.  
  446.     for(k=0; k<size; k++) SectorBuff[k] = fgetc(Source);
  447.     AddSector(TrackBuff, SectorBuff, C, H, R, N, ST1, ST2, size);
  448.     }
  449.   } else SDataOffset = 0;  /* unformatted track */
  450.  
  451.  StoreTrack(TrackBuff);
  452.  }
  453. StoreHeader(HeaderBuff);
  454. }
  455.  
  456.  
  457. void emc2edsk()
  458. {
  459.  long FSize;
  460.  long Toffset, Soffset;
  461.  int i,j,k,l, N, Ns;
  462.  int SectPt, size;
  463.  unsigned int CRC, CRC2;
  464.  unsigned char ST1, ST2;
  465.  
  466.  fseek(Source, 12, SEEK_SET);
  467.  FSize = Bword32Load(Source);
  468.  if ((FSize/4816) > 42) Ns = 2; else Ns = 1;   /* arbitrary limit: 4.5k + header */
  469.  SetUpDSKHeader(HeaderBuff, 40, Ns);
  470.  
  471.  for(i=0; i<40; i++)
  472.   for(j=0; j<Ns; j++)
  473.    {
  474.    fseek(Source, Toffset = 16 + 4816*(i + j*40), SEEK_SET);
  475.    for(k=0; k<208; k++) InputBuff[k] = fgetc(Source);
  476.    for(k=1; k<208; k+=8) if (InputBuff[k] > 5) break;
  477.  
  478.    if (k == 1) SDataOffset = 0; else  /* unformatted track */
  479.     {
  480.     SetUpTrackHeader(TrackBuff, i, j, InputBuff[1], (--k)>>3, 0x4e, 0xe5 );
  481.     for(SectPt=0; SectPt<k; SectPt+=8)
  482.      {
  483.      N = InputBuff[SectPt+1];
  484.      size = NtoSize(N);
  485.      Soffset = Toffset + 208 + Bword32Acc(InputBuff+SectPt+4);
  486.      fseek(Source, Soffset, SEEK_SET);
  487.      CRC = 0;
  488.      CRC2 = (InputBuff[SectPt+2]<<8) | InputBuff[SectPt+3];
  489.  
  490.      for(l=0; l<size; l++) CRC += (SectorBuff[l] = fgetc(Source));
  491.      if (CRC == CRC2) { ST1 = 0x80; ST2 = 0; } else { ST2 = ST1 = 0x20; }
  492.  
  493.      AddSector(TrackBuff, SectorBuff, i, j, InputBuff[SectPt], N, ST1, ST2, size);
  494.      }
  495.     }
  496.  
  497.    StoreTrack(TrackBuff);
  498.    }
  499.  StoreHeader(HeaderBuff);
  500. }
  501.  
  502.  
  503.  
  504. void ami2edsk()
  505. {
  506.  int i,j,k;
  507.  unsigned char C,H,R,N,ST1, ST2;
  508.  
  509.  fseek(Source, 0, SEEK_SET);
  510.  SetUpDSKHeader(HeaderBuff, 42, 1);
  511.  
  512.  for(i=0; i<42; i++)
  513.   {
  514.   SetUpTrackHeader(TrackBuff, i, 0, 2, 9, 0x4e, 0xe5 );
  515.  
  516.   for(j=0; j<9; j++)
  517.    {
  518.    C = fgetc(Source);
  519.    H = fgetc(Source);
  520.    N = fgetc(Source);
  521.    R = fgetc(Source);
  522.    if (N <= 2) { ST1 = 0x80; ST2 = 0; } else { ST2 = ST1 = 0x20; }
  523.    ST2 |= (C != i)<<4;       /* wrong track */
  524.  
  525.    for(k=0; k<512; k++) SectorBuff[k] = fgetc(Source);
  526.  
  527.    AddSector(TrackBuff, SectorBuff, C, H, R, N, ST1, ST2, min(512, NtoSize(N)) );
  528.    }
  529.  
  530.   StoreTrack(TrackBuff);
  531.   }
  532.  
  533.  StoreHeader(HeaderBuff);
  534. }
  535.  
  536.  
  537. void cpc2edsk()
  538. {
  539.  long i,j,k,  Nt,Ns,Sect;
  540.  int SectPt, size1, size2;
  541.  unsigned char C,H,R,N,ST1, ST2;
  542.  
  543.  fseek(Source, 32, SEEK_SET);
  544.  for(i=0; i<32; i++) InputBuff[i] = fgetc(Source);
  545.  Nt = 10*(InputBuff[0] - 48) + (InputBuff[1] - 48);
  546.  if (!strcmp(InputBuff+16, "DoubleSided")) Ns = 2; else Ns = 1;
  547.  
  548.  SetUpDSKHeader(HeaderBuff, Nt, Ns);
  549.  
  550.  for(i=0; i<Nt; i++)
  551.    for(j=0; j<Ns; j++)
  552.     {
  553.     SetUpTrackHeader(TrackBuff, i, j, 2, 0, 0x4e, 0xe5 );  /* dummy sector number */
  554.     fseek(Source, 128 + (i*Ns+j)*6144, SEEK_SET);
  555.     Sect = 0;
  556.  
  557.      for(; ;)
  558.       {
  559.       for(k=0; k<8; k++) InputBuff[k] = fgetc(Source);
  560.       if (!strncmp(InputBuff+4, "IDFD", 4)) Sect++; else break; /* EOT */
  561.  
  562.       C = fgetc(Source);
  563.       H = fgetc(Source);
  564.       R = fgetc(Source);
  565.       N = fgetc(Source);
  566.        for(k=12; k<32; k++) fgetc(Source);
  567.  
  568.       size1 = min (128<<N, k8KB);
  569.       size2 = NtoSize(N);
  570.  
  571.       if (N<6) { ST1 = 0x80; ST2 = 0; } else { ST2 = ST1 = 0x20; }
  572.       ST2 |= (C != i)<<4;       /* wrong track */
  573.  
  574.       for(k=0; k<size1; k++) SectorBuff[k] = fgetc(Source);
  575.  
  576.       AddSector(TrackBuff, SectorBuff, C, H, R, N, ST1, ST2, size2 );
  577.       }
  578.  
  579.     if (Sect) TrackBuff[0x15] = Sect; else SDataOffset = 0;   /* correct the */
  580.     StoreTrack(TrackBuff);   /* sector number and unformatted track case ... */
  581.     }
  582.  
  583.  StoreHeader(HeaderBuff);
  584. }
  585.  
  586.  
  587.  
  588. void npc2edsk()
  589. {
  590.  unsigned char Rbase;
  591.  int TotTracks, curTrack, curSect, offset;
  592.  long Size;
  593.  
  594.  fseek(Source, 0, SEEK_END);
  595.  Size = ftell(Source);
  596.  TotTracks = (Size-2L)/4608L;
  597.  fseek(Source, 0, SEEK_SET);
  598.  fgetc(Source);
  599.  Rbase = fgetc(Source);
  600.  
  601.  SetUpDSKHeader(HeaderBuff, TotTracks, 1);
  602.  for(curTrack = 0; curTrack<TotTracks; curTrack++)
  603.    {
  604.    SetUpTrackHeader(TrackBuff, 0, curTrack, 2, 9, 0x4e, 0xe5);
  605.    for(curSect = 0; curSect<9; curSect++)
  606.      {
  607.      for(offset = 0; offset<512; offset++) SectorBuff[offset] = fgetc(Source);
  608.      AddSector(TrackBuff, SectorBuff, curTrack, 0,
  609.                                       Rbase+curSect, 2, 0x80, 0, 512);
  610.      }
  611.    StoreTrack(TrackBuff);
  612.    }
  613.  StoreHeader(HeaderBuff);
  614. }
  615.