int hxcfe_popTrack (FBuilder* fb)
{
CYLINDER* currentcylinder;
fb_track_state * current_fb_track_state;
int i;
unsigned long sui_flag;
if(fb->fb_stack_pointer)
{
current_fb_track_state=&fb->fb_stack[fb->fb_stack_pointer];
if( current_fb_track_state->track_number < fb->floppydisk->floppyNumberOfTrack)
{
if(!fb->floppydisk->tracks[current_fb_track_state->track_number])
fb->floppydisk->tracks[current_fb_track_state->track_number]=allocCylinderEntry(current_fb_track_state->rpm,2);
currentcylinder=fb->floppydisk->tracks[current_fb_track_state->track_number];
sui_flag=0;
if(!current_fb_track_state->sectorunderindex)
sui_flag=NO_SECTOR_UNDER_INDEX;
currentcylinder->sides[current_fb_track_state->side_number]=tg_generateTrackEx((unsigned short)current_fb_track_state->numberofsector,
current_fb_track_state->sectortab,
current_fb_track_state->interleave,
current_fb_track_state->skew,
current_fb_track_state->bitrate,
current_fb_track_state->rpm,
current_fb_track_state->type,
current_fb_track_state->pregap,
current_fb_track_state->indexlen|sui_flag,current_fb_track_state->indexpos);
for(i=0;i<current_fb_track_state->numberofsector;i++)
{
if(current_fb_track_state->sectortab[i].input_data)
free(current_fb_track_state->sectortab[i].input_data);
}
fb->fb_stack_pointer--;
return HXCFE_NOERROR;
}
else
{
for(i=0;i<current_fb_track_state->numberofsector;i++)
{
if(current_fb_track_state->sectortab[i].input_data)
free(current_fb_track_state->sectortab[i].input_data);
}
fb->fb_stack_pointer--;
return HXCFE_BADPARAMETER;
}
}
return HXCFE_NOERROR;
}
int EDE_libLoad_DiskFile(HXCFE_IMGLDR * imgldr_ctx,HXCFE_FLOPPY * floppydisk,char * imgfile,void * parameters)
{
FILE * f;
unsigned int filesize;
int i,j,l,k;
int gap3len,interleave;
int rpm,sectorsize;
HXCFE_CYLINDER* currentcylinder;
unsigned char header_buffer[512];
int header_offset;
int blocknum;
int number_of_block;
unsigned char bitmask;
int floppy_buffer_index;
unsigned char trackformat;
int skew;
HXCFE_SECTCFG * sectorconfig;
unsigned int sectorsizelayout[32];
unsigned int sectoridlayout[32];
imgldr_ctx->hxcfe->hxc_printf(MSG_DEBUG,"EDE_libLoad_DiskFile %s",imgfile);
f=hxc_fopen(imgfile,"rb");
if(f==NULL)
{
imgldr_ctx->hxcfe->hxc_printf(MSG_ERROR,"Cannot open %s !",imgfile);
return HXCFE_ACCESSERROR;
}
fseek (f , 0 , SEEK_END);
filesize=ftell(f);
fseek (f , 0 , SEEK_SET);
fread(header_buffer,0x200,1,f);
if((filesize!=0) && (header_buffer[0]==0x0D) && (header_buffer[1]==0x0A))
{
floppydisk->floppyiftype=GENERIC_SHUGART_DD_FLOPPYMODE;
sectorsize=512;
rpm=300;
trackformat=ISOFORMAT_DD;
skew=0;
switch(header_buffer[0x1FF])
{
case 0x01:
imgldr_ctx->hxcfe->hxc_printf(MSG_INFO_0,"Mirage (DD) format");
header_offset=0xA0;
sectorsize=1024;
floppydisk->floppyBitRate=250000;
floppydisk->floppyNumberOfTrack=80;
floppydisk->floppyNumberOfSide=1;
floppydisk->floppySectorPerTrack=6;
gap3len=255;
interleave=1;
for(k=0;k<floppydisk->floppySectorPerTrack;k++)sectorsizelayout[k]=sectorsize;
for(k=1;k<floppydisk->floppySectorPerTrack;k++)sectoridlayout[k]=k-1;
sectoridlayout[0]=5;
sectorsizelayout[0]=512;
break;
case 0x02:
imgldr_ctx->hxcfe->hxc_printf(MSG_INFO_0,"SQ-80 (DD) format");
header_offset=0xA0;
sectorsize=1024;
rpm=290;
floppydisk->floppyBitRate=250000;
floppydisk->floppyNumberOfTrack=80;
floppydisk->floppyNumberOfSide=2;
floppydisk->floppySectorPerTrack=6;
gap3len=255;
interleave=1;
for(k=0;k<floppydisk->floppySectorPerTrack;k++)sectorsizelayout[k]=sectorsize;
for(k=1;k<floppydisk->floppySectorPerTrack;k++)sectoridlayout[k]=k-1;
sectoridlayout[0]=5;
sectorsizelayout[0]=512;
break;
case 0x03:
imgldr_ctx->hxcfe->hxc_printf(MSG_INFO_0,"EPS (DD) format");
header_offset=0xA0;
floppydisk->floppyBitRate=250000;
floppydisk->floppyNumberOfTrack=80;
floppydisk->floppyNumberOfSide=2;
floppydisk->floppySectorPerTrack=10;
gap3len=36;
interleave=1;
skew=2;
for(k=0;k<floppydisk->floppySectorPerTrack;k++)sectorsizelayout[k]=sectorsize;
for(k=0;k<floppydisk->floppySectorPerTrack;k++)sectoridlayout[k]=k;
break;
case 0x04:
imgldr_ctx->hxcfe->hxc_printf(MSG_INFO_0,"VFX-SD (DD) format");
header_offset=0xA0;
floppydisk->floppyBitRate=250000;
floppydisk->floppyNumberOfTrack=80;
floppydisk->floppyNumberOfSide=2;
floppydisk->floppySectorPerTrack=10;
gap3len=36;
interleave=1;
for(k=0;k<floppydisk->floppySectorPerTrack;k++)sectorsizelayout[k]=sectorsize;
for(k=0;k<floppydisk->floppySectorPerTrack;k++)sectoridlayout[k]=k;
break;
case 0xcb:
imgldr_ctx->hxcfe->hxc_printf(MSG_INFO_0,"ASR-10 HD format");
floppydisk->floppyiftype=IBMPC_HD_FLOPPYMODE;
header_offset=0x60;
floppydisk->floppyBitRate=500000;
floppydisk->floppyNumberOfTrack=80;
floppydisk->floppyNumberOfSide=2;
floppydisk->floppySectorPerTrack=20;
// ASR 10 GAP3 verified with an HFE image formatted from one ASR-10
gap3len = 36;
interleave=1;
skew=2;
for(k=0;k<floppydisk->floppySectorPerTrack;k++)sectorsizelayout[k]=sectorsize;
for(k=0;k<floppydisk->floppySectorPerTrack;k++)sectoridlayout[k]=k;
break;
case 0xcc:
imgldr_ctx->hxcfe->hxc_printf(MSG_INFO_0,"TS-10/12 HD format");
floppydisk->floppyiftype=IBMPC_HD_FLOPPYMODE;
header_offset=0x60;
floppydisk->floppyBitRate=500000;
floppydisk->floppyNumberOfTrack=80;
floppydisk->floppyNumberOfSide=2;
floppydisk->floppySectorPerTrack=20;
gap3len=40;
interleave=1;
skew=2;
for(k=0;k<floppydisk->floppySectorPerTrack;k++)sectorsizelayout[k]=sectorsize;
for(k=0;k<floppydisk->floppySectorPerTrack;k++)sectoridlayout[k]=k;
break;
case 0x07:
floppydisk->floppyiftype=IBMPC_DD_FLOPPYMODE;
imgldr_ctx->hxcfe->hxc_printf(MSG_INFO_0,"TS-10/12 DD format");
header_offset=0xA0;
floppydisk->floppyBitRate=250000;
floppydisk->floppyNumberOfTrack=80;
floppydisk->floppyNumberOfSide=2;
floppydisk->floppySectorPerTrack=10;
gap3len=40;
interleave=1;
skew=2;
for(k=0;k<floppydisk->floppySectorPerTrack;k++)sectorsizelayout[k]=sectorsize;
for(k=0;k<floppydisk->floppySectorPerTrack;k++)sectoridlayout[k]=k;
break;
default:
imgldr_ctx->hxcfe->hxc_printf(MSG_ERROR,"Unknow format : %x !",header_buffer[0x1FF]);
hxc_fclose(f);
return HXCFE_BADFILE;
break;
}
number_of_block=floppydisk->floppyNumberOfTrack*floppydisk->floppyNumberOfSide*floppydisk->floppySectorPerTrack;
sectorconfig=malloc(sizeof(HXCFE_SECTCFG) * floppydisk->floppySectorPerTrack);
memset(sectorconfig,0,sizeof(HXCFE_SECTCFG) * floppydisk->floppySectorPerTrack);
floppy_buffer_index=0;
blocknum=0;
bitmask=0x80;
floppydisk->tracks=(HXCFE_CYLINDER**)malloc(sizeof(HXCFE_CYLINDER*)*floppydisk->floppyNumberOfTrack);
imgldr_ctx->hxcfe->hxc_printf(MSG_INFO_1,"%d tracks, %d side(s), %d sectors/track, gap3:%d, interleave:%d,rpm:%d",floppydisk->floppyNumberOfTrack,floppydisk->floppyNumberOfSide,floppydisk->floppySectorPerTrack,gap3len,interleave,rpm);
for(j=0;j<floppydisk->floppyNumberOfTrack;j++)
{
floppydisk->tracks[j]=allocCylinderEntry(rpm,floppydisk->floppyNumberOfSide);
currentcylinder=floppydisk->tracks[j];
for(i=0;i<floppydisk->floppyNumberOfSide;i++)
{
hxcfe_imgCallProgressCallback(imgldr_ctx,(j<<1) + (i&1),floppydisk->floppyNumberOfTrack*2 );
memset(sectorconfig,0,sizeof(HXCFE_SECTCFG)*floppydisk->floppySectorPerTrack);
for(k=0;k<floppydisk->floppySectorPerTrack;k++)
{
sectorconfig[k].head=i;
sectorconfig[k].cylinder=j;
sectorconfig[k].sector=sectoridlayout[k];
sectorconfig[k].sectorsize=sectorsizelayout[k];
sectorconfig[k].bitrate=floppydisk->floppyBitRate;
sectorconfig[k].gap3=gap3len;
sectorconfig[k].trackencoding=trackformat;
sectorconfig[k].input_data=malloc(sectorsize);
memset(sectorconfig[k].input_data,0,sectorsize);
if(blocknum<number_of_block)
{
if(!(header_buffer[header_offset]&bitmask))
{
imgldr_ctx->hxcfe->hxc_printf(MSG_DEBUG,"T:%.3d S:%d Sector:%.2d Size:%.4d File offset: 0x%.8x",j,i,sectorconfig[k].sector,sectorconfig[k].sectorsize,ftell(f));
fread(sectorconfig[k].input_data,sectorsize,1,f);
}
else
{
imgldr_ctx->hxcfe->hxc_printf(MSG_DEBUG,"T:%.3d S:%d Sector:%.2d Size:%.4d File offset: ----------",j,i,sectorconfig[k].sector,sectorconfig[k].sectorsize);
for(l=0;l<(sectorconfig[k].sectorsize/2);l++)
{
sectorconfig[k].input_data[(l*2)]=0x6D;
sectorconfig[k].input_data[(l*2)+1]=0xB6;
}
}
bitmask=bitmask>>1;
if(!bitmask)
{
header_offset++;
bitmask=0x80;
}
blocknum++;
}
else
{
imgldr_ctx->hxcfe->hxc_printf(MSG_DEBUG,"T:%.3d S:%d Sector:%.2d Size:%.4d",j,i,sectorconfig[k].sector,sectorconfig[k].sectorsize);
for(l=0;l<(sectorconfig[k].sectorsize/2);l++)
{
sectorconfig[k].input_data[(l*2)]=0x6D;
sectorconfig[k].input_data[(l*2)+1]=0xB6;
}
}
}
currentcylinder->sides[i]=tg_generateTrackEx(floppydisk->floppySectorPerTrack,sectorconfig,interleave,(unsigned char)(((j<<1)|(i&1))*skew),floppydisk->floppyBitRate,rpm,trackformat,128,2500,-2500);
for(k=0;k<floppydisk->floppySectorPerTrack;k++)
{
free(sectorconfig[k].input_data);
}
}
}
int JV3_libLoad_DiskFile(HXCFLOPPYEMULATOR* floppycontext,FLOPPY * floppydisk,char * imgfile,void * parameters)
{
FILE * f;
unsigned int filesize,cur_pos;
unsigned int i,j,k,bitrate;
unsigned short SectorSize, NumberofEntries;
unsigned char gap3len,interleave,StartIdSector;
unsigned short rpm;
unsigned char trackformat;
unsigned short sector_found;
SECTORCONFIG* sectorconfig;
CYLINDER* currentcylinder;
JV3SectorHeader sh[JV3_HEADER_MAX];
JV3SectorsOffsets *pOffset, *SectorsOffsets;
unsigned char write_protected;
unsigned int inc;
floppycontext->hxc_printf(MSG_DEBUG,"JV3_libLoad_DiskFile %s",imgfile);
f=hxc_fopen(imgfile,"rb");
if(f==NULL)
{
floppycontext->hxc_printf(MSG_ERROR,"Cannot open %s !",imgfile);
return HXCFE_ACCESSERROR;
}
fseek (f , 0 , SEEK_END);
filesize=ftell(f);
fseek (f , 0 , SEEK_SET);
if(filesize!=0)
{
fread(sh, sizeof(JV3SectorHeader), JV3_HEADER_MAX, f);
JV3_disk_geometry(sh, &floppydisk->floppyNumberOfSide, &floppydisk->floppySectorPerTrack, &floppydisk->floppyNumberOfTrack, &SectorSize, &StartIdSector, &NumberofEntries);
fread(&write_protected, sizeof(write_protected), 1, f); // just to jump this infomation
SectorsOffsets = JV3_offset(sh, floppydisk->floppyNumberOfSide, floppydisk->floppySectorPerTrack, floppydisk->floppyNumberOfTrack, NumberofEntries, f);
bitrate=250000;
rpm=300;
interleave=1;
gap3len=255;
trackformat=IBMFORMAT_SD;
floppydisk->floppyBitRate=bitrate;
floppydisk->floppyiftype=GENERIC_SHUGART_DD_FLOPPYMODE;
floppydisk->tracks=(CYLINDER**)malloc(sizeof(CYLINDER*)*floppydisk->floppyNumberOfTrack);
floppycontext->hxc_printf(MSG_DEBUG,"rpm %d bitrate:%d track:%d side:%d sector:%d",rpm,bitrate,floppydisk->floppyNumberOfTrack,floppydisk->floppyNumberOfSide,floppydisk->floppySectorPerTrack);
sectorconfig=(SECTORCONFIG*)malloc(sizeof(SECTORCONFIG)*floppydisk->floppySectorPerTrack);
memset(sectorconfig,0,sizeof(SECTORCONFIG)*floppydisk->floppySectorPerTrack);
for(j=0;j<floppydisk->floppyNumberOfTrack;j++)
{
floppydisk->tracks[j]=allocCylinderEntry(rpm,floppydisk->floppyNumberOfSide);
currentcylinder=floppydisk->tracks[j];
for(i=0;i<floppydisk->floppyNumberOfSide;i++)
{
inc = 0; // used to build track data
memset(sectorconfig,0,sizeof(SECTORCONFIG)*floppydisk->floppySectorPerTrack);
sector_found=0;
cur_pos = GetFirstPos(SectorsOffsets,NumberofEntries,j,i);
for(k=0;k<floppydisk->floppySectorPerTrack;k++)
{
pOffset = GetSectorPosition(SectorsOffsets,NumberofEntries,cur_pos);
if (pOffset == NULL)
{
inc += SectorSize;
}
else
{
sectorconfig[sector_found].sectorsize=pOffset->size;
sectorconfig[sector_found].input_data=malloc(sectorconfig[sector_found].sectorsize);
memset(sectorconfig[sector_found].input_data,0,sectorconfig[sector_found].sectorsize);
fseek(f, pOffset->offset, SEEK_SET);
fread(sectorconfig[sector_found].input_data,pOffset->size,1,f);
inc += pOffset->size;
if (pOffset->DAM != 0xFB)
{
sectorconfig[sector_found].use_alternate_datamark=1;
sectorconfig[sector_found].alternate_datamark=pOffset->DAM;
}
if(pOffset->density)
{
sectorconfig[sector_found].trackencoding=IBMFORMAT_DD;
if(!sector_found) trackformat=IBMFORMAT_DD;
}
else
{
sectorconfig[sector_found].trackencoding=IBMFORMAT_SD;
if(!sector_found) trackformat=IBMFORMAT_SD;
}
if(pOffset->bad_sector)
{
sectorconfig[sector_found].use_alternate_data_crc = 0x01;
sectorconfig[sector_found].data_crc = 0xAA55;
}
sectorconfig[sector_found].cylinder = pOffset->track_id;
sectorconfig[sector_found].head = i;
sectorconfig[sector_found].sector = pOffset->sector_id;
sectorconfig[sector_found].bitrate = floppydisk->floppyBitRate;
sectorconfig[sector_found].gap3 = gap3len;
sector_found++;
}
cur_pos = GetNextPos(SectorsOffsets,NumberofEntries,j,i,cur_pos);
}
currentcylinder->sides[i]=tg_generateTrackEx(sector_found,sectorconfig,interleave,0,floppydisk->floppyBitRate,rpm,trackformat,0,2500|NO_SECTOR_UNDER_INDEX,-2500);
for(k=0;k<floppydisk->floppySectorPerTrack;k++)
{
free(sectorconfig[k].input_data);
}
}
}
free(sectorconfig);
free(SectorsOffsets);
floppycontext->hxc_printf(MSG_INFO_1,"track file successfully loaded and encoded!");
hxc_fclose(f);
hxcfe_sanityCheck(floppycontext,floppydisk);
return HXCFE_NOERROR;
}
floppycontext->hxc_printf(MSG_ERROR,"file size=%d !?",filesize);
hxc_fclose(f);
return HXCFE_BADFILE;
}
int TeleDisk_libLoad_DiskFile(HXCFE_IMGLDR * imgldr_ctx,HXCFE_FLOPPY * floppydisk,char * imgfile,void * parameters)
{
FILE * f;
unsigned int i;
unsigned int file_offset;
uint32_t tracklen;
unsigned char interleave,skew,trackformat;
unsigned short rpm,sectorsize;
int Compress,numberoftrack,sidenumber;
unsigned short * datalen;
HXCFE_CYLINDER* currentcylinder;
HXCFE_SIDE* currentside;
TELEDISK_HEADER *td_header;
TELEDISK_TRACK_HEADER *td_track_header;
TELEDISK_SECTOR_HEADER *td_sector_header;
TELEDISK_COMMENT * td_comment;
unsigned char tempdata[8*1024];
unsigned char crctable[32];
unsigned char CRC16_High,CRC16_Low;
unsigned char * ptr;
uint32_t filesize;
HXCFE_SECTCFG * sectorconfig;
unsigned char * fileimage;
uint32_t fileimage_buffer_offset;
int rlen;
imgldr_ctx->hxcfe->hxc_printf(MSG_DEBUG,"TeleDisk_libLoad_DiskFile %s",imgfile);
hxcfe_imgCallProgressCallback(imgldr_ctx,0,100 );
f=hxc_fopen(imgfile,"rb");
if(f==NULL)
{
imgldr_ctx->hxcfe->hxc_printf(MSG_ERROR,"TeleDisk_libLoad_DiskFile : Cannot open %s !",imgfile);
return HXCFE_ACCESSERROR;
}
fseek(f,0,SEEK_END);
filesize=ftell(f);
if(!filesize)
{
imgldr_ctx->hxcfe->hxc_printf(MSG_ERROR,"TeleDisk_libLoad_DiskFile : 0 byte file !");
hxc_fclose(f);
return HXCFE_BADFILE;
}
fseek(f,0,SEEK_SET);
fileimage_buffer_offset=0;
fileimage=(unsigned char*)malloc(filesize+512);
if(!fileimage)
{
imgldr_ctx->hxcfe->hxc_printf(MSG_ERROR,"TeleDisk_libLoad_DiskFile : Malloc error !");
hxc_fclose(f);
return HXCFE_INTERNALERROR;
}
memset(fileimage,0,filesize+512);
fread(fileimage,filesize,1,f);
hxc_fclose(f);
td_header=(TELEDISK_HEADER*)&fileimage[fileimage_buffer_offset];
fileimage_buffer_offset=fileimage_buffer_offset+sizeof(TELEDISK_HEADER);
if ( ((td_header->TXT[0]!='t') || (td_header->TXT[1]!='d')) && ((td_header->TXT[0]!='T') || (td_header->TXT[1]!='D')))
{
imgldr_ctx->hxcfe->hxc_printf(MSG_ERROR,"TeleDisk_libLoad_DiskFile : bad header tag !");
free(fileimage);
return HXCFE_BADFILE;
}
CRC16_Init(&CRC16_High,&CRC16_Low,(unsigned char*)crctable,0xA097,0x0000);
ptr=(unsigned char*)td_header;
for(i=0;i<0xA;i++)
{
CRC16_Update(&CRC16_High,&CRC16_Low, ptr[i],(unsigned char*)crctable );
}
if(((td_header->CRC[1]<<8)|td_header->CRC[0])!=((CRC16_High<<8)|CRC16_Low))
{
imgldr_ctx->hxcfe->hxc_printf(MSG_ERROR,"TeleDisk_libLoad_DiskFile : bad header crc !");
free(fileimage);
return HXCFE_BADFILE;
}
imgldr_ctx->hxcfe->hxc_printf(MSG_INFO_1,"TeleDisk_libLoad_DiskFile : Teledisk version : %d",td_header->TDVer);
if((td_header->TDVer>21) || (td_header->TDVer<10))
{
imgldr_ctx->hxcfe->hxc_printf(MSG_ERROR,"TeleDisk_libLoad_DiskFile : Unsupported version !");
free(fileimage);
return HXCFE_BADFILE;
}
Compress=0;
if(((td_header->TXT[0]=='T') && (td_header->TXT[1]=='D')))
{
imgldr_ctx->hxcfe->hxc_printf(MSG_INFO_1,"TeleDisk_libLoad_DiskFile : Normal compression");
Compress=0;
}
if(((td_header->TXT[0]=='t') && (td_header->TXT[1]=='d')))
{
imgldr_ctx->hxcfe->hxc_printf(MSG_INFO_1,"TeleDisk_libLoad_DiskFile : Advanced compression");
fileimage=unpack(fileimage,filesize);
Compress=1;
}
td_header=(TELEDISK_HEADER*)&fileimage[0];
if(td_header->TrkDens&0x80)
{
CRC16_Init(&CRC16_High,&CRC16_Low,(unsigned char*)crctable,0xA097,0x0000);
td_comment=(TELEDISK_COMMENT *)&fileimage[fileimage_buffer_offset];
fileimage_buffer_offset=fileimage_buffer_offset+sizeof(TELEDISK_COMMENT);
//fread( &td_comment, sizeof(td_comment), 1, f );
ptr=(unsigned char*)td_comment;
ptr=ptr+2;
for(i=0;i<sizeof(TELEDISK_COMMENT)-2;i++)
{
CRC16_Update(&CRC16_High,&CRC16_Low, ptr[i],(unsigned char*)crctable );
}
memcpy(&tempdata,&fileimage[fileimage_buffer_offset],td_comment->Len);
fileimage_buffer_offset=fileimage_buffer_offset+td_comment->Len;
ptr=(unsigned char*)&tempdata;
for(i=0;i<td_comment->Len;i++)
{
CRC16_Update(&CRC16_High,&CRC16_Low, ptr[i],(unsigned char*)crctable );
}
imgldr_ctx->hxcfe->hxc_printf(MSG_INFO_1,"TeleDisk_libLoad_DiskFile : Creation date: %.2d/%.2d/%.4d %.2d:%.2d:%.2d",td_comment->bDay,\
td_comment->bMon+1,\
td_comment->bYear+1900,\
td_comment->bHour,\
td_comment->bMin,\
td_comment->bSec);
imgldr_ctx->hxcfe->hxc_printf(MSG_INFO_1,"TeleDisk_libLoad_DiskFile : Comment: %s",tempdata);
}
interleave=1;
numberoftrack=0;
sectorsize=512;
file_offset=fileimage_buffer_offset;
floppydisk->floppyNumberOfSide=td_header->Surface;
td_track_header=(TELEDISK_TRACK_HEADER *)&fileimage[fileimage_buffer_offset];
fileimage_buffer_offset=fileimage_buffer_offset+sizeof(TELEDISK_TRACK_HEADER);
while(td_track_header->SecPerTrk!=0xFF)
{
if(td_track_header->PhysCyl>numberoftrack)
{
numberoftrack=td_track_header->PhysCyl;
}
CRC16_Init(&CRC16_High,&CRC16_Low,(unsigned char*)crctable,0xA097,0x0000);
ptr=(unsigned char*)td_track_header;
for(i=0;i<0xA;i++)
{
CRC16_Update(&CRC16_High,&CRC16_Low, ptr[i],(unsigned char*)crctable );
}
for ( i=0;i < td_track_header->SecPerTrk;i++ )
{
td_sector_header=(TELEDISK_SECTOR_HEADER *)&fileimage[fileimage_buffer_offset];
fileimage_buffer_offset=fileimage_buffer_offset+sizeof(TELEDISK_SECTOR_HEADER);
if ( (td_sector_header->Syndrome & 0x30) == 0 && (td_sector_header->SLen & 0xf8) == 0 )
{
//fileimage_buffer_offset=fileimage_buffer_offset+sizeof(unsigned short);
datalen=(unsigned short*)&fileimage[fileimage_buffer_offset];
fileimage_buffer_offset=fileimage_buffer_offset+(*datalen)+2;
}
}
td_track_header=(TELEDISK_TRACK_HEADER *)&fileimage[fileimage_buffer_offset];
fileimage_buffer_offset=fileimage_buffer_offset+sizeof(TELEDISK_TRACK_HEADER);
}
floppydisk->floppyNumberOfTrack=numberoftrack+1;
floppydisk->floppySectorPerTrack=-1;
floppydisk->tracks=(HXCFE_CYLINDER**)malloc(sizeof(HXCFE_CYLINDER*)*floppydisk->floppyNumberOfTrack);
memset(floppydisk->tracks,0,sizeof(HXCFE_CYLINDER*)*floppydisk->floppyNumberOfTrack);
//Source disk density (0 = 250K bps, 1 = 300K bps, 2 = 500K bps ; +128 = single-density FM)
switch(td_header->Dens)
{
case 0:
floppydisk->floppyBitRate=250000;
break;
case 1:
floppydisk->floppyBitRate=300000;
break;
case 2:
floppydisk->floppyBitRate=500000;
break;
default:
floppydisk->floppyBitRate=250000;
break;
}
floppydisk->floppyiftype=GENERIC_SHUGART_DD_FLOPPYMODE;
skew=1;
rpm=300; // normal rpm
imgldr_ctx->hxcfe->hxc_printf(MSG_INFO_1,"%d tracks, %d side(s), gap3:%d,rpm:%d bitrate:%d",floppydisk->floppyNumberOfTrack,floppydisk->floppyNumberOfSide,floppydisk->floppySectorPerTrack,rpm,floppydisk->floppyBitRate);
tracklen=(floppydisk->floppyBitRate/(rpm/60))/4;
//////////////////////////////////
fileimage_buffer_offset=file_offset;
td_track_header=(TELEDISK_TRACK_HEADER *)&fileimage[fileimage_buffer_offset];
fileimage_buffer_offset=fileimage_buffer_offset+sizeof(TELEDISK_TRACK_HEADER);
while(td_track_header->SecPerTrk!=0xFF)
{
if(td_track_header->PhysSide&0x7F)
{
sidenumber=1;
}
else
{
sidenumber=0;
}
if(td_track_header->PhysSide&0x80)
{
trackformat=IBMFORMAT_SD;
}
else
{
trackformat=IBMFORMAT_DD;
}
imgldr_ctx->hxcfe->hxc_printf(MSG_DEBUG,"------------- Track:%d, Side:%d, Number of Sector:%d -------------",td_track_header->PhysCyl,sidenumber,td_track_header->SecPerTrk);
if(!floppydisk->tracks[td_track_header->PhysCyl])
{
floppydisk->tracks[td_track_header->PhysCyl]=(HXCFE_CYLINDER*)malloc(sizeof(HXCFE_CYLINDER));
memset(floppydisk->tracks[td_track_header->PhysCyl],0,sizeof(HXCFE_CYLINDER));
}
currentcylinder=floppydisk->tracks[td_track_header->PhysCyl];
currentcylinder->number_of_side=floppydisk->floppyNumberOfSide;
if(!currentcylinder->sides)
{
currentcylinder->sides=(HXCFE_SIDE**)malloc(sizeof(HXCFE_SIDE*)*currentcylinder->number_of_side);
memset(currentcylinder->sides,0,sizeof(HXCFE_SIDE*)*currentcylinder->number_of_side);
}
currentcylinder->floppyRPM=rpm;
////////////////////crc track header///////////////////
CRC16_Init(&CRC16_High,&CRC16_Low,(unsigned char*)crctable,0xA097,0x0000);
ptr=(unsigned char*)td_track_header;
for(i=0;i<0x3;i++)
{
CRC16_Update(&CRC16_High,&CRC16_Low, ptr[i],(unsigned char*)crctable );
}
if(CRC16_Low!=td_track_header->CRC)
{
imgldr_ctx->hxcfe->hxc_printf(MSG_ERROR,"!!!! Track header CRC Error !!!!");
}
////////////////////////////////////////////////////////
sectorconfig=(HXCFE_SECTCFG *)malloc(sizeof(HXCFE_SECTCFG)*td_track_header->SecPerTrk);
memset(sectorconfig,0,sizeof(HXCFE_SECTCFG)*td_track_header->SecPerTrk);
for ( i=0;i < td_track_header->SecPerTrk;i++ )
{
td_sector_header=(TELEDISK_SECTOR_HEADER *)&fileimage[fileimage_buffer_offset];
fileimage_buffer_offset=fileimage_buffer_offset+sizeof(TELEDISK_SECTOR_HEADER);
sectorconfig[i].cylinder=td_sector_header->Cyl;
sectorconfig[i].head=td_sector_header->Side;
sectorconfig[i].sector=td_sector_header->SNum;
sectorconfig[i].sectorsize=128<<td_sector_header->SLen;
sectorconfig[i].bitrate=floppydisk->floppyBitRate;
sectorconfig[i].gap3=255;
sectorconfig[i].trackencoding=trackformat;
if(td_sector_header->Syndrome & 0x04)
{
sectorconfig[i].use_alternate_datamark=1;
sectorconfig[i].alternate_datamark=0xF8;
}
if(td_sector_header->Syndrome & 0x02)
{
sectorconfig[i].use_alternate_data_crc=2;
}
if(td_sector_header->Syndrome & 0x20)
{
sectorconfig[i].missingdataaddressmark=1;
}
sectorconfig[i].input_data=malloc(sectorconfig[i].sectorsize);
if ( (td_sector_header->Syndrome & 0x30) == 0 && (td_sector_header->SLen & 0xf8) == 0 )
{
//fileimage_buffer_offset=fileimage_buffer_offset+sizeof(unsigned short);
datalen=(unsigned short*)&fileimage[fileimage_buffer_offset];
memcpy(&tempdata,&fileimage[fileimage_buffer_offset],(*datalen)+2);
fileimage_buffer_offset=fileimage_buffer_offset+(*datalen)+2;
rlen=RLEExpander(tempdata,sectorconfig[i].input_data,(int)*datalen);
}
else
{
memset(sectorconfig[i].input_data,0,sectorconfig[i].sectorsize);
}
imgldr_ctx->hxcfe->hxc_printf(MSG_DEBUG,"track:%d, side:%d, sector:%d, sectorsize:%d, flag:%.2x",sectorconfig[i].cylinder,sectorconfig[i].head,sectorconfig[i].sector,sectorconfig[i].sectorsize,td_sector_header->Syndrome);
}
currentside=tg_generateTrackEx((unsigned short)td_track_header->SecPerTrk,sectorconfig,interleave,0,floppydisk->floppyBitRate,rpm,trackformat,0,2500 | NO_SECTOR_UNDER_INDEX,-2500);
currentcylinder->sides[sidenumber]=currentside;
for ( i=0;i < td_track_header->SecPerTrk;i++ )
{
if(sectorconfig[i].input_data)
free(sectorconfig[i].input_data);
}
free(sectorconfig);
td_track_header=(TELEDISK_TRACK_HEADER *)&fileimage[fileimage_buffer_offset];
fileimage_buffer_offset=fileimage_buffer_offset+sizeof(TELEDISK_TRACK_HEADER);
}
imgldr_ctx->hxcfe->hxc_printf(MSG_INFO_1,"track file successfully loaded and encoded!");
free(fileimage);
hxcfe_imgCallProgressCallback(imgldr_ctx,100,100 );
hxcfe_sanityCheck(imgldr_ctx->hxcfe,floppydisk);
return HXCFE_NOERROR;
}
int FDI_libLoad_DiskFile(HXCFLOPPYEMULATOR* floppycontext,FLOPPY * floppydisk,char * imgfile,void * parameters)
{
FILE * f;
unsigned int i,j,k,file_size;
unsigned char interleave;
unsigned short rpm;
int number_of_track,number_of_side,number_of_sectorpertrack;
unsigned char tempsector[256];
unsigned char trackformat;
unsigned char skew;
unsigned int trackoffset,tempoffset,file_offset;
SECTORCONFIG* sectorconfig;
CYLINDER* currentcylinder;
fdi_header f_header;
fdi_track_header track_header;
fdi_sector_header sector_header;
floppycontext->hxc_printf(MSG_DEBUG,"FDI_libLoad_DiskFile %s",imgfile);
f=hxc_fopen(imgfile,"rb");
if(f==NULL)
{
floppycontext->hxc_printf(MSG_ERROR,"Cannot open %s !",imgfile);
return HXCFE_ACCESSERROR;
}
fseek(f,0,SEEK_END);
file_size=ftell(f);
fseek(f,0,SEEK_SET);
fread(&f_header,sizeof(fdi_header),1,f);
if(f_header.signature[0]!='F' || f_header.signature[1]!='D' || f_header.signature[2]!='I')
{
floppycontext->hxc_printf(MSG_ERROR,"Bad FDI file !");
hxc_fclose(f);
return HXCFE_BADFILE;
}
fseek(f,f_header.diskdescription_offset,SEEK_SET);
fread(tempsector,f_header.data_offset - f_header.diskdescription_offset,1,f);
floppycontext->hxc_printf(MSG_INFO_1,"Disk:%s",tempsector);
trackoffset=f_header.additionnal_infos_len+0xE;
fseek(f,trackoffset,SEEK_SET);
number_of_track=f_header.number_of_cylinders;
number_of_side =f_header.number_of_heads;
number_of_sectorpertrack=-1;
rpm=300;
interleave=1;
skew=0;
floppydisk->floppyBitRate=250000;
floppydisk->floppyiftype=GENERIC_SHUGART_DD_FLOPPYMODE;
floppydisk->floppyNumberOfTrack=number_of_track;
floppydisk->floppyNumberOfSide=number_of_side;
floppydisk->floppySectorPerTrack=number_of_sectorpertrack;
floppydisk->tracks=(CYLINDER**)malloc(sizeof(CYLINDER*)*floppydisk->floppyNumberOfTrack);
trackformat=IBMFORMAT_DD;
floppycontext->hxc_printf(MSG_DEBUG,"rpm %d bitrate:%d track:%d side:%d sector:%d",rpm,floppydisk->floppyBitRate,floppydisk->floppyNumberOfTrack,floppydisk->floppyNumberOfSide,floppydisk->floppySectorPerTrack);
for(j=0;j<floppydisk->floppyNumberOfTrack;j++)
{
floppydisk->tracks[j]=allocCylinderEntry(rpm,floppydisk->floppyNumberOfSide);
currentcylinder=floppydisk->tracks[j];
for(i=0;i<floppydisk->floppyNumberOfSide;i++)
{
fread(&track_header,sizeof(fdi_track_header),1,f);
floppycontext->hxc_printf(MSG_DEBUG,"[%d:%d] %d sectors, Track Offset :0x%x:",j,i,track_header.number_of_sectors,track_header.track_offset+f_header.data_offset);
sectorconfig=(SECTORCONFIG*)malloc(sizeof(SECTORCONFIG)*track_header.number_of_sectors);
memset(sectorconfig,0,sizeof(SECTORCONFIG)*track_header.number_of_sectors);
for(k=0;k<track_header.number_of_sectors;k++)
{
fread(§or_header,sizeof(fdi_sector_header),1,f);
file_offset=f_header.data_offset+track_header.track_offset+sector_header.sector_offset;
floppycontext->hxc_printf(MSG_DEBUG,"[%d:%d] Cyl:%d,Head:%d,Sec:%d,Size:%d,Flags:0x%.2X,Offset:0x%.8x",
j,i,sector_header.cylinder_number,
sector_header.head_number,
sector_header.sector_number,
128<<sector_header.sector_size,
sector_header.flags,
file_offset
);
tempoffset=ftell(f);
sectorconfig[k].cylinder=sector_header.cylinder_number;
sectorconfig[k].head=sector_header.head_number;
sectorconfig[k].sector=sector_header.sector_number;
sectorconfig[k].sectorsize=128<<sector_header.sector_size;
sectorconfig[k].gap3=255;
sectorconfig[k].fill_byte=246;
sectorconfig[k].bitrate=floppydisk->floppyBitRate;
sectorconfig[k].trackencoding=trackformat;
if(!(sector_header.flags&0x1F))
{
sectorconfig[k].use_alternate_data_crc=0xFF;
sectorconfig[k].data_crc=0xAAAA;
}
if(sector_header.flags&0x80)
{
sectorconfig[k].alternate_datamark=0xF8;
sectorconfig[k].use_alternate_datamark=1;
}
if(file_offset<file_size)
{
sectorconfig[k].input_data=malloc(sectorconfig[k].sectorsize);
fseek(f,file_offset,SEEK_SET);
fread(sectorconfig[k].input_data,sectorconfig[k].sectorsize,1,f);
}
fseek(f,tempoffset,SEEK_SET);
}
currentcylinder->sides[i]=tg_generateTrackEx(track_header.number_of_sectors,sectorconfig,interleave,(unsigned char)(((j<<1)|(i&1))*skew),floppydisk->floppyBitRate,rpm,trackformat,0,2500|NO_SECTOR_UNDER_INDEX,-2500);
for(k=0;k<track_header.number_of_sectors;k++)
{
free(sectorconfig[k].input_data);
}
free(sectorconfig);
}
}
floppycontext->hxc_printf(MSG_INFO_1,"track file successfully loaded and encoded!");
hxc_fclose(f);
hxcfe_sanityCheck(floppycontext,floppydisk);
return HXCFE_NOERROR;
}
