diff --git a/apple/nibutil.cpp b/apple/nibutil.cpp index 936b626..a8d7c2e 100644 --- a/apple/nibutil.cpp +++ b/apple/nibutil.cpp @@ -19,11 +19,6 @@ // In 6-and-2 encoding, there are 86 (0x56) 6-bit values #define SIXBIT_SPAN 0x56 -typedef struct _bitPtr { - uint16_t idx; - uint8_t bitIdx; -} bitPtr; - #define INCIDX(p) { p->bitIdx >>= 1; if (!p->bitIdx) {p->bitIdx = 0x80; p->idx++;} } // This is the DOS 3.3 RWTS Write Table (UTA2E, p. 9-26). @@ -94,7 +89,7 @@ static void _packByte(uint8_t *output, bitPtr *ptr, uint8_t v) } // Take 256 bytes of input and turn it in to 343 bytes of nibblized output -static void _encodeData(uint8_t *outputBuffer, bitPtr *ptr, const uint8_t input[256]) +void _encode62Data(uint8_t outputBuffer[343], const uint8_t input[256]) { int ptr2 = 0; int ptr6 = 0x56; @@ -126,17 +121,17 @@ static void _encodeData(uint8_t *outputBuffer, bitPtr *ptr, const uint8_t input[ } // mask out the "extra" 2-bit data above. Note that the Apple decoders // don't care about the extra bits, so taking these back out isn't - // operationally important. + // operationally important. Just don't overflow _trans[]... nibbles[0x54] &= 0x0F; nibbles[0x55] &= 0x0F; int lastv = 0; for (int idx = 0; idx < 0x156; idx++) { int val = nibbles[idx]; - _packByte(outputBuffer, ptr, _trans[lastv ^ val]); + outputBuffer[idx] = _trans[lastv^val]; lastv = val; } - _packByte(outputBuffer, ptr, _trans[lastv]); + outputBuffer[342] = _trans[lastv]; } static uint8_t _whichBit(uint8_t bitIdx) @@ -209,7 +204,12 @@ uint32_t nibblizeTrack(uint8_t outputBuffer[NIBTRACKSIZE], const uint8_t rawTrac _packByte(outputBuffer, &ptr, 0xAD); uint8_t physicalSector = (diskType == T_PO ? deProdosPhys[sector] : dephys[sector]); - _encodeData(outputBuffer, &ptr, &rawTrackBuffer[physicalSector * 256]); + + uint8_t nibData[343]; + _encode62Data(nibData, &rawTrackBuffer[physicalSector * 256]); + for (int i=0; i<343; i++) { + _packByte(outputBuffer, &ptr, nibData[i]); + } _packByte(outputBuffer, &ptr, 0xDE); // data epilog _packByte(outputBuffer, &ptr, 0xAA); @@ -229,7 +229,7 @@ uint32_t nibblizeTrack(uint8_t outputBuffer[NIBTRACKSIZE], const uint8_t rawTrac // // Return true if we've successfully consumed 343 bytes from // trackBuf. -static bool _decodeData(const uint8_t trackBuffer[343], uint8_t output[256]) +bool _decode62Data(const uint8_t trackBuffer[343], uint8_t output[256]) { static uint8_t workbuf[342]; @@ -346,7 +346,7 @@ nibErr denibblizeTrack(const uint8_t input[NIBTRACKSIZE], uint8_t rawTrackBuffer for (int j=0; j<343; j++) { nibData[j] = input[(i+j)%NIBTRACKSIZE]; } - if (!_decodeData(nibData, output)) { + if (!_decode62Data(nibData, output)) { return errorBadData; } i += 343; @@ -391,3 +391,18 @@ nibErr denibblizeTrack(const uint8_t input[NIBTRACKSIZE], uint8_t rawTrackBuffer return errorNone; } +nibErr nibblizeSector(uint8_t dataIn[256], uint8_t dataOut[343]) +{ + _encode62Data(dataOut, dataIn); + + return errorNone; +} + +nibErr denibblizeSector(nibSector input, uint8_t dataOut[256]) +{ + if (_decode62Data((uint8_t *)(input.data62), dataOut)) { + return errorNone; + } + + return errorBadData; +} diff --git a/apple/nibutil.h b/apple/nibutil.h index ca703dd..64ac7f6 100644 --- a/apple/nibutil.h +++ b/apple/nibutil.h @@ -41,6 +41,14 @@ enum nibErr { errorBadData = 2 }; +typedef struct _bitPtr { + uint16_t idx; + uint8_t bitIdx; +} bitPtr; + + bool _decode62Data(const uint8_t trackBuffer[343], uint8_t output[256]); + void _encode62Data(uint8_t *outputBuffer, const uint8_t input[256]); + uint32_t nibblizeTrack(uint8_t outputBuffer[NIBTRACKSIZE], const uint8_t rawTrackBuffer[256*16], uint8_t diskType, int8_t track); @@ -49,6 +57,9 @@ nibErr denibblizeTrack(const uint8_t input[NIBTRACKSIZE], uint8_t rawTrackBuffer uint8_t de44(uint8_t nibs[2]); +nibErr nibblizeSector(uint8_t dataIn[256], uint8_t dataOut[343]); +nibErr denibblizeSector(nibSector input, uint8_t dataOut[256]); + #ifdef __cplusplus }; #endif diff --git a/apple/woz-serializer.cpp b/apple/woz-serializer.cpp index 3482039..53c4b59 100644 --- a/apple/woz-serializer.cpp +++ b/apple/woz-serializer.cpp @@ -7,7 +7,7 @@ #include "iocompat.h" #endif -#define WOZMAGIC 0xD5 +#define WOZMAGIC 0xAA WozSerializer::WozSerializer() : Woz(false,0) { @@ -29,16 +29,25 @@ bool WozSerializer::Serialize(int8_t fd) { // If we're being asked to serialize, make sure we've flushed any data first flush(); - + /* serializeMagic(WOZMAGIC); + + imageType 8 + autoFlushTrackData bool + diskinfo ??? can this be regen'd? + trackInfo tracks[160] -- has a dirty flag in it :/ + serialize32(trackPointer); serialize32(trackBitCounter); - serialize32(lastReadPointer); serialize8(trackByte); + trackByteFromDataTrack 8 serialize8(trackBitIdx); serialize8(trackLoopCounter); - serializeMagic(WOZMAGIC); + + metadata randData randPtr + serializeMagic(WOZMAGIC); + */ return true; err: @@ -48,6 +57,7 @@ bool WozSerializer::Serialize(int8_t fd) bool WozSerializer::Deserialize(int8_t fd) { // Before deserializing, the caller has to re-load the right disk image! + /* deserializeMagic(WOZMAGIC); deserialize32(trackPointer); deserialize32(trackBitCounter); @@ -55,8 +65,16 @@ bool WozSerializer::Deserialize(int8_t fd) deserialize8(trackByte); deserialize8(trackBitIdx); deserialize8(trackLoopCounter); - deserializeMagic(WOZMAGIC); + +... + have to serialize/deserialize all of tracks[*] now + and the dirty flag is in there + tracks[datatrack].dirty = true; +... + + deserializeMagic(WOZMAGIC); + */ return true; err: @@ -67,8 +85,15 @@ bool WozSerializer::flush() { // Flush the entire disk image if it's dirty. We could make this // smarter later. - if (!trackDirty) + // FIXME hard-coded number of tracks? + bool trackDirty = false; + for (int i=0; i<160; i++) { + if (tracks[i].dirty) + trackDirty = true; + } + if (!trackDirty) { return true; + } // The fd should still be open. If it's not, then we can't flush. if (fd == -1) @@ -92,8 +117,7 @@ bool WozSerializer::flush() ret = false; break; } - // fsync(fd); // FIXME should not be needed - trackDirty = false; + g_filemanager->flush(); return true; } diff --git a/apple/woz.cpp b/apple/woz.cpp index 840bee0..e8211ac 100644 --- a/apple/woz.cpp +++ b/apple/woz.cpp @@ -14,6 +14,7 @@ #ifdef TEENSYDUINO // This junk is for my AiiE project. I need to abstract it out better. +#include "iocompat.h" #define SKIPCHECKSUM #define malloc extmem_malloc #define free extmem_free @@ -33,10 +34,10 @@ #define END_SECTION(fd) { \ long endpos = lseek(fd, 0, SEEK_CUR); \ lseek(fd, curpos-4, SEEK_SET); \ - uint32_t chunksize = endpos - curpos; \ + uint32_t chunksize = endpos - curpos; \ if (!write32(fd, chunksize)) \ return false; \ - lseek(fd, 0, SEEK_END); \ + lseek(fd, endpos, SEEK_SET); \ } Woz::Woz(bool verbose, uint8_t dumpflags) @@ -95,7 +96,7 @@ bool Woz::writeNextWozBit(uint8_t datatrack, uint8_t bit) trackByte = tracks[datatrack].trackData[trackPointer]; trackByteFromDataTrack = datatrack; } - + if (bit) trackByte |= trackBitIdx; else @@ -104,7 +105,7 @@ bool Woz::writeNextWozBit(uint8_t datatrack, uint8_t bit) tracks[datatrack].trackData[trackPointer] = trackByte; advanceBitStream(datatrack); - trackDirty = true; + tracks[datatrack].dirty = true; return true; } @@ -137,6 +138,7 @@ uint8_t Woz::getNextWozBit(uint8_t datatrack) if (datatrack >= 160) { if (datatrack != 255) { fprintf(stderr, "datatrack %d out of range\n", datatrack); + exit(1); } return 0; } @@ -217,6 +219,10 @@ uint8_t Woz::nextDiskBit(uint8_t datatrack) return 0; } + /* + +FIXME: this needs evaluation. We want the fake bit work, but can't do it at the expense of being 1 bit behind -- b/c that would mean switching tracks drops a bit; and seek-and-write would leave an excess bit in place too... + static uint8_t head_window = 0; head_window <<= 1; head_window |= getNextWozBit(datatrack); @@ -224,7 +230,10 @@ uint8_t Woz::nextDiskBit(uint8_t datatrack) return (head_window & 0x02) >> 1; } else { return fakeBit(); - } + }*/ + + // Until the above is figured out, we're gonna just return what's on the datastream + return getNextWozBit(datatrack); } uint8_t Woz::nextDiskByte(uint8_t datatrack) @@ -363,6 +372,7 @@ bool Woz::writeWozFile(const char *filename, uint8_t subtype) bool retval = writeWozFile(fdout, subtype); close(fdout); + return retval; } @@ -472,6 +482,11 @@ bool Woz::writeWozFile(int fdout, uint8_t subtype) } #endif + for (int i=0; i<160; i++) { + tracks[i].dirty = false; + } + + retval = true; done: @@ -514,6 +529,10 @@ bool Woz::writeDskFile(int fdout, uint8_t subtype) } } + for (int i=0; i<160; i++) { + tracks[i].dirty = false; + } + return true; } @@ -549,6 +568,10 @@ bool Woz::writeNibFile(int fdout) } } + for (int i=0; i<160; i++) { + tracks[i].dirty = false; + } + return true; } @@ -589,15 +612,9 @@ bool Woz::loadMissingTrackFromImage(uint8_t datatrack) // that might be malloc'd and purge them if we're // autoFlushTrackData==true (trying to limit memory use) if (autoFlushTrackData == true) { - - if (trackDirty) { - printf("Hackily writing /tmp/auto.woz\n"); - trackDirty = false; - writeFile("/tmp/auto.woz"/*, T_WOZ2*/); // FIXME: debugging - } - for (int i=0; i<160; i++) { - if (tracks[i].trackData) { + // Don't flush any tracks that are dirty + if (tracks[i].trackData && !tracks[i].dirty) { free(tracks[i].trackData); tracks[i].trackData = NULL; } @@ -843,7 +860,7 @@ bool Woz::readWozFile(const char *filename, bool preloadTracks) case 0x4F464E49: // 'INFO' if (verbose) { printf("Reading INFO chunk starting at byte 0x%llX\n", - lseek(fd, 0, SEEK_CUR)); + (unsigned long long)lseek(fd, 0, SEEK_CUR)); } isOk = parseInfoChunk(chunkDataSize); haveData |= cINFO; @@ -851,7 +868,7 @@ bool Woz::readWozFile(const char *filename, bool preloadTracks) case 0x50414D54: // 'TMAP' if (verbose) { printf("Reading TMAP chunk starting at byte 0x%llX\n", - lseek(fd, 0, SEEK_CUR)); + (unsigned long long)lseek(fd, 0, SEEK_CUR)); } isOk = parseTMAPChunk(chunkDataSize); haveData |= cTMAP; @@ -859,7 +876,7 @@ bool Woz::readWozFile(const char *filename, bool preloadTracks) case 0x534B5254: // 'TRKS' if (verbose) { printf("Reading TRKS chunk starting at byte 0x%llX\n", - lseek(fd, 0, SEEK_CUR)); + (unsigned long long) lseek(fd, 0, SEEK_CUR)); } isOk = parseTRKSChunk(chunkDataSize); haveData |= cTRKS; @@ -867,7 +884,7 @@ bool Woz::readWozFile(const char *filename, bool preloadTracks) case 0x4154454D: // 'META' if (verbose) { printf("Reading META chunk starting at byte 0x%llX\n", - lseek(fd, 0, SEEK_CUR)); + (unsigned long long) lseek(fd, 0, SEEK_CUR)); } isOk = parseMetaChunk(chunkDataSize); break; @@ -1163,6 +1180,135 @@ bool Woz::readWozDataTrack(uint8_t datatrack) return true; } +#if 0 +static void dumpNibSector(nibSector *ns) +{ + printf("gap1: "); + for (int i=0; i<48; i++) { + printf("%.2X ", ns->gap1[i]); + } + printf("\nsectorProlog: "); + for (int i=0; i<3; i++) { + printf("%.2X ", ns->sectorProlog[i]); + } + printf("\n volume44: %.2X %.2X == %.2X\n", ns->volume44[0], ns->volume44[1], de44(ns->volume44)); + printf(" sector44: %.2X %.2X == %.2X\n", ns->sector44[0], ns->sector44[1], de44(ns->sector44)); + printf(" checksum44: %.2X %.2X == %.2X\n", ns->checksum44[0], ns->checksum44[1], de44(ns->checksum44)); + printf("sectorEpilog: "); + for (int i=0; i<3; i++) { + printf("%.2X ", ns->sectorEpilog[i]); + } + printf("\n"); + + printf("gap2: "); + for (int i=0; i<5; i++) { + printf("%.2X ", ns->gap2[i]); + } + printf("\ndataProlog: "); + for (int i=0; i<3; i++) { + printf("%.2X ", ns->dataProlog[i]); + } + printf("\n data62:"); + for (int i=0; i<342; i+=16) { + printf("\n "); + for (int j=0; (j<16) && (j+i < 342); j++) { + printf("%.2X ", ns->data62[i+j]); + } + } + printf("\n checksum: %.2X", ns->checksum); + printf("\ndataEpilog: "); + for (int i=0; i<3; i++) { + printf("%.2X ", ns->dataEpilog[i]); + } + printf("\n\n"); +} +#endif + + +// This writes to the given *physical* sector -- the caller is responsible for translating +// to a logical sector number +bool Woz::writeNibSectorDataToDataTrack(uint8_t dataTrack, uint8_t sector, uint8_t nibData[343]) +{ + // Find the spot on the track that has the right sector + if (!tracks[dataTrack].trackData) { + // Load the cached track for this phys Nib track. + if (!loadMissingTrackFromImage(dataTrack)) { + fprintf(stderr, "Failed to read track %d\n", dataTrack); + return false; + } + } + + // find the data header + // write this nibblized data on top of whatever was there before + // ensure the epilog is correct + nibSector sectorData; + memset(sectorData.gap1, 0xFF, sizeof(sectorData.gap1)); + memset(sectorData.gap2, 0xFF, sizeof(sectorData.gap2)); + + // Allow two loops through the track data looking for the sector prolog + uint32_t endCount = tracks[dataTrack].blockCount*512*2; + if (di.version == 1) endCount = 2*6646; + + uint32_t ptr = 0; + while (ptr < endCount) { + sectorData.sectorProlog[0] = sectorData.sectorProlog[1]; + sectorData.sectorProlog[1] = sectorData.sectorProlog[2]; + sectorData.sectorProlog[2] = nextDiskByte(dataTrack); + ptr++; + + if (sectorData.sectorProlog[0] == 0xd5 && + sectorData.sectorProlog[1] == 0xaa && + sectorData.sectorProlog[2] == 0x96) { + // Found *a* sector header. See if it's ours. + sectorData.volume44[0] = nextDiskByte(dataTrack); + sectorData.volume44[1] = nextDiskByte(dataTrack); + sectorData.track44[0] = nextDiskByte(dataTrack); + sectorData.track44[1] = nextDiskByte(dataTrack); + sectorData.sector44[0] = nextDiskByte(dataTrack); + sectorData.sector44[1] = nextDiskByte(dataTrack); + sectorData.checksum44[0] = nextDiskByte(dataTrack); + sectorData.checksum44[1] = nextDiskByte(dataTrack); + sectorData.sectorEpilog[0] = nextDiskByte(dataTrack); + sectorData.sectorEpilog[1] = nextDiskByte(dataTrack); + sectorData.sectorEpilog[2] = nextDiskByte(dataTrack); + + if (sectorData.sectorEpilog[0] == 0xde && + sectorData.sectorEpilog[1] == 0xaa && + sectorData.sectorEpilog[2] == 0xeb) { + // Header is integral. See if it's our sector: + uint8_t sectorNum = de44(sectorData.sector44); + if (sectorNum != sector) { + continue; + } + + // It's our sector - find the data chunk and write it + while (ptr < tracks[dataTrack].blockCount*512*2) { + sectorData.dataProlog[0] = sectorData.dataProlog[1]; + sectorData.dataProlog[1] = sectorData.dataProlog[2]; + sectorData.dataProlog[2] = nextDiskByte(dataTrack); + ptr++; + + if (sectorData.dataProlog[0] == 0xd5 && + sectorData.dataProlog[1] == 0xaa && + sectorData.dataProlog[2] == 0xad) { + // That's the data prolog, so next comes our data payload: + // 342 bytes of payload, 1 byte of checksum. + for (int i=0; i<343; i++) { + writeNextWozByte(dataTrack, nibData[i]); + } + writeNextWozByte(dataTrack, 0xDE); + writeNextWozByte(dataTrack, 0xAA); + writeNextWozByte(dataTrack, 0xEB); + return true; + } + } + } + } + } + + // If we get here, we failed to write it + return false; +} bool Woz::readNibSectorDataFromDataTrack(uint8_t dataTrack, uint8_t sector, nibSector *sectorData) { @@ -1354,14 +1500,7 @@ bool Woz::writeTRKSChunk(uint8_t version, int fdout) perror("error writing"); return false; } -#if 0 - uint8_t c = 0; - while (writeSize < tracks[i].blockCount * 512) { - if (write(fdout, &c, 1) != 1) - return false; - writeSize++; - } -#endif + tracks[i].dirty = false; } } return true; @@ -1379,6 +1518,51 @@ bool Woz::decodeWozTrackToNibFromDataTrack(uint8_t dataTrack, nibSector sectorDa return true; } +// The caller is responsible for translating between the physical sector numbers and the logical +// sector numbers. This only takes in to account the physical sector numbers (whatever is +// represented in the sector's header). +bool Woz::decodeWozTrackSector(uint8_t phystrack, uint8_t sector, uint8_t dataOut[256]) +{ + uint8_t dataTrack = quarterTrackMap[phystrack*4]; + nibSector nibData; + if (!readNibSectorDataFromDataTrack(dataTrack, sector, &nibData)) { + fprintf(stderr, "Failed to readNibSectorDataFromDataTrack for track %d sector %d\n", phystrack, sector); + return false; + } + +#if 0 + printf("Track %d physector %d nib dump:\n", phystrack, sector); + dumpNibSector(&nibData); +#endif + if (denibblizeSector(nibData, dataOut) != errorNone) { + fprintf(stderr, "failed to denib sector\n"); + return false; + } + return true; +} + +// The caller is responsible for translating between the physical sector numbers and the logical +// sector numbers. This only takes in to account the physical sector numbers (whatever is +// represented in the sector's header). +bool Woz::encodeWozTrackSector(uint8_t phystrack, uint8_t sector, uint8_t dataIn[256]) +{ + uint8_t dataTrack = quarterTrackMap[phystrack*4]; + uint8_t dataOut[343]; + + if (nibblizeSector(dataIn, dataOut) != errorNone) { + fprintf(stderr, "Failed to nibblizeSector for track %d sector %d\n", phystrack, sector); + return false; + } + + if (!writeNibSectorDataToDataTrack(dataTrack, sector, dataOut)) { + fprintf(stderr, "Failed to writeNibSectorDataToDataTrack for track %d sector %d\n", phystrack, sector); + return false; + } + + return true; +} + + bool Woz::decodeWozTrackToDsk(uint8_t phystrack, uint8_t subtype, uint8_t sectorData[256*16]) { // Figure out which datatrack we need for the given physical track @@ -1389,7 +1573,13 @@ bool Woz::decodeWozTrackToDsk(uint8_t phystrack, uint8_t subtype, uint8_t sector fprintf(stderr, "failed to decode Woz\n"); return false; } - +#if 0 + for (int s=0; s<16; s++) { + printf("Track read dumping nib sector %d:\n", s); + dumpNibSector(&nibData[s]); + } +#endif + if (denibblizeTrack((const uint8_t *)nibData, sectorData, subtype) != errorNone) { fprintf(stderr, "failed to denib track\n"); return false; @@ -1637,12 +1827,6 @@ uint8_t Woz::dataTrackNumberForQuarterTrack(uint16_t qt) bool Woz::flush() { -#if 0 - if (trackDirty) { - printf("Hackily writing /tmp/auto.woz\n"); - trackDirty = false; - return writeFile(2, "/tmp/auto.woz"); // FIXME: debugging - } + // *** FIXME - should flush() write the image out if it's dirty? return true; -#endif } diff --git a/apple/woz.h b/apple/woz.h index 303fe4d..a6bed00 100644 --- a/apple/woz.h +++ b/apple/woz.h @@ -39,20 +39,18 @@ typedef struct _trackInfo { uint16_t blockCount; uint32_t bitCount; uint8_t *trackData; + bool dirty; } trackInfo; -class WozSerializer; - class Woz { - friend class WozSerializer; - public: Woz(bool verbose, uint8_t dumpflags); - virtual ~Woz(); + ~Woz(); bool readFile(const char *filename, bool preloadTracks, uint8_t forceType = T_AUTO); bool writeFile(const char *filename, uint8_t forceType = T_AUTO); + void advanceBitStream(uint8_t datatrack); uint8_t getNextWozBit(uint8_t datatrack); void dumpInfo(); @@ -61,41 +59,37 @@ class Woz { uint8_t dataTrackNumberForQuarterTrack(uint16_t qt); - virtual bool flush(); + bool flush(); - void debug(); + bool decodeWozTrackToDsk(uint8_t phystrack, uint8_t subtype, uint8_t sectorData[256*16]); + bool decodeWozTrackSector(uint8_t phystrack, uint8_t sector, uint8_t dataOut[256]); + bool encodeWozTrackSector(uint8_t phystrack, uint8_t sector, uint8_t dataIn[256]); -protected: - // Interface for AiiE - virtual bool writeNextWozBit(uint8_t datatrack, uint8_t bit); - virtual bool writeNextWozByte(uint8_t datatrack, uint8_t b); - virtual uint8_t nextDiskBit(uint8_t datatrack); - virtual uint8_t nextDiskByte(uint8_t datatrack); - + protected: bool writeWozFile(const char *filename, uint8_t subtype); - bool writeWozFile(int fd, uint8_t subtype); + bool writeWozFile(int fdout, uint8_t subtype); bool writeDskFile(const char *filename, uint8_t subtype); - bool writeDskFile(int fd, uint8_t subtype); + bool writeDskFile(int fdout, uint8_t subtype); bool writeNibFile(const char *filename); - bool writeNibFile(int fd); - - private: - void loadTrackByte(uint8_t datatrack); - void advanceBitStream(uint8_t datatrack); + bool writeNibFile(int fdout); + uint8_t nextDiskBit(uint8_t datatrack); + uint8_t nextDiskByte(uint8_t datatrack); + + void writeDiskByte(uint8_t datatrack, uint8_t b); + + protected: bool readWozFile(const char *filename, bool preloadTracks); bool readDskFile(const char *filename, bool preloadTracks, uint8_t subtype); bool readNibFile(const char *filename, bool preloadTracks); - bool decodeWozTrackToNibFromDataTrack(uint8_t datatrack, nibSector sectorData[16]); - bool decodeWozTrackToDsk(uint8_t phystrack, uint8_t subtype, uint8_t sectorData[256*16]); - - bool writeWozTrack(int fd, uint8_t trackToWrite, uint8_t imageType); - bool writeDskTrack(int fd, uint8_t trackToWrite, uint8_t imageType); - bool writeNibTrack(int fd, uint8_t trackToWrite, uint8_t imageType); + bool decodeWozTrackToNibFromDataTrack(uint8_t dataTrack, nibSector sectorData[16]); uint8_t fakeBit(); + bool writeNextWozBit(uint8_t datatrack, uint8_t bit); + bool writeNextWozByte(uint8_t datatrack, uint8_t b); + bool parseTRKSChunk(uint32_t chunkSize); bool parseTMAPChunk(uint32_t chunkSize); bool parseInfoChunk(uint32_t chunkSize); @@ -106,7 +100,8 @@ protected: bool writeTRKSChunk(uint8_t version, int fdout); bool readWozDataTrack(uint8_t datatrack); - bool readNibSectorDataFromDataTrack(uint8_t datatrack, uint8_t sector, nibSector *sectorData); + bool writeNibSectorDataToDataTrack(uint8_t dataTrack, uint8_t sector, uint8_t nibData[343]); + bool readNibSectorDataFromDataTrack(uint8_t dataTrack, uint8_t sector, nibSector *sectorData); bool loadMissingTrackFromImage(uint8_t datatrack); @@ -114,31 +109,28 @@ protected: void _initInfo(); - private: + protected: + int fd; + + protected: uint8_t imageType; bool verbose; uint8_t dumpflags; bool autoFlushTrackData; - bool trackDirty; uint8_t quarterTrackMap[40*4]; diskInfo di; trackInfo tracks[160]; // cursor for track enumeration -protected: - int fd; - uint32_t trackPointer; - uint32_t lastReadPointer; uint32_t trackBitCounter; uint8_t trackByte; uint8_t trackByteFromDataTrack; uint8_t trackBitIdx; uint8_t trackLoopCounter; -private: char *metaData; uint8_t randData, randPtr; }; diff --git a/sdl/fscompat.h b/sdl/fscompat.h index d94adfd..820a8ac 100644 --- a/sdl/fscompat.h +++ b/sdl/fscompat.h @@ -13,6 +13,6 @@ #define close(filedes) g_filemanager->closeFile(filedes) #define write(filedes,buf,nbyte) g_filemanager->write(filedes,buf,nbyte) #define read(filedes,buf,nbyte) g_filemanager->read(filedes,buf,nbyte) -#define lseek(filedes,offset,whence) g_filemanager->lseek(filedes,offset,whence) +#define lseek(filedes,offset,whence) (int) g_filemanager->lseek(filedes,(int)offset,(int)whence) diff --git a/teensy/fscompat.h b/teensy/fscompat.h index 1fd1a8a..4fb5420 100644 --- a/teensy/fscompat.h +++ b/teensy/fscompat.h @@ -14,6 +14,6 @@ #define close(filedes) g_filemanager->closeFile(filedes) #define write(filedes,buf,nbyte) g_filemanager->write(filedes,buf,nbyte) #define read(filedes,buf,nbyte) g_filemanager->read(filedes,buf,nbyte) -#define lseek(filedes,offset,whence) g_filemanager->lseek(filedes,offset,whence) +#define lseek(filedes,offset,whence) (int)g_filemanager->lseek(filedes,(int)offset,(int)whence) #include "iocompat.h"