1 files changed, 3002 insertions, 0 deletions

diff --git a/src/lib/hd24fs.cpp b/src/lib/hd24fs.cpp
new file mode 100755
index 0000000..5c6b3fc
--- /dev/null
+++ b/src/lib/hd24fs.cpp
@@ -0,0 +1,3002 @@
+#define ALLOC_SECTORS_PER_SONG  5
+#define SONG_SECTORS_PER_SONG   2
+#define TOTAL_SECTORS_PER_SONG  (ALLOC_SECTORS_PER_SONG+SONG_SECTORS_PER_SONG)
+#ifdef DARWIN
+#define creat64 creat
+#endif
+#define HD24FSDEBUG 0      /* generic hd24fs debugging */
+#define HD24FSDEBUG_QUICKFORMAT 0  /* debugging for calculation of # of free clusters */
+#define HD24FSDEBUG_WRITE 0 /* output debugging messages on disk writes */
+#define HD24FSDEBUG_BITSET 0 /* output debugging messages on disk writes */
+#define HD24FSDEBUG_COMMIT 0 /* output debugging messages on disk writes */
+#define HD24FSDEBUG_DEVSCAN 0 /* output debugging messages for device scan */
+#include "hd24fs.h"
+#include <string>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#ifndef WINDOWS
+#include <unistd.h>
+#endif
+#define RESULT_SUCCESS 0
+#define RESULT_FAIL 1
+#include <stdio.h>
+#include <stdlib.h>
+#include <iostream>
+#include <fstream>
+#include <math.h>
+#include "convertlib.h"
+#include "memutils.h"
+
+#include <hd24devicenamegenerator.h>
+#define _LARGE_FILES
+#define _FILE_OFFSET_BITS 64
+#define FILE_OFFSET_BITS 64
+#define LARGE_FILES
+#define LARGEFILE64_SOURCE
+#define SECTORSIZE 512
+#ifdef DARWIN
+#define open64 open
+#define lseek64 lseek
+#define pread64 pread
+#define pwrite64 pwrite
+#endif
+#define FSINFO_VERSION_MAJOR            0x8
+#define FSINFO_VERSION_MINOR            0x9
+#define FSINFO_BLOCKSIZE_IN_SECTORS     0x10
+#define FSINFO_AUDIOBLOCKS_PER_CLUSTER  0x14
+#define FSINFO_STARTSECTOR_DRIVEUSAGE   0x38
+#define FSINFO_NUMSECTORS_DRIVEUSAGE    0x3c
+#define FSINFO_FREE_CLUSTERS_ON_DISK    0x44
+#define FSINFO_FIRST_PROJECT_SECTOR     0x48
+#define FSINFO_SECTORS_PER_PROJECT      0x4C
+#define FSINFO_MAXPROJECTS              0x50
+#define FSINFO_MAXSONGSPERPROJECT       0x54
+#define FSINFO_FIRST_SONG_SECTOR        0x58
+#define FSINFO_SECTORS_IN_SONGENTRY     0x5C
+#define FSINFO_SECTORS_IN_SONGALLOC     0x60
+#define FSINFO_SECTORS_PER_SONG         0x64
+#define FSINFO_CURRENT_SONGS_ON_DISK    0x68
+#define FSINFO_ALLOCATABLE_SECTORCOUNT  0x80
+#define FSINFO_LAST_SECTOR              0x84
+#define FSINFO_DATAAREA                 0x7c
+
+#define DRIVEINFO_VOLUME        0x1b8
+#define DRIVEINFO_VOLUME_8      0x00
+#define DRIVEINFO_PROJECTCOUNT  0x0c
+#define DRIVEINFO_LASTPROJ      0x10
+#define DRIVEINFO_LASTPROJECT   0x10
+#define DRIVEINFO_PROJECTLIST   0x20
+
+#include "hd24project.cpp"
+#include "hd24song.cpp"
+#if defined(LINUX) || defined(DARWIN)
+const int hd24fs::MODE_RDONLY=O_RDONLY;
+const int hd24fs::MODE_RDWR=O_RDWR;
+#endif
+#ifdef WINDOWS
+#include <shellapi.h>
+const int hd24fs::MODE_RDONLY=GENERIC_READ;
+const int hd24fs::MODE_RDWR=GENERIC_READ|GENERIC_WRITE;
+#define popen _popen
+#define pclose _pclose
+#endif
+
+const int hd24fs::TRANSPORTSTATUS_STOP  =0;
+const int hd24fs::TRANSPORTSTATUS_REC   =1;
+const int hd24fs::TRANSPORTSTATUS_PLAY  =2;
+
+void dumpsector(const char* buffer)
+{
+        for (int i=0;i<512;i+=16) {
+                string* dummy=Convert::int32tohex(i);
+                cout << *dummy  << "  ";
+                delete dummy; dummy=NULL;
+                for (int j=0;j<16;j++) {
+                        string* dummy= Convert::byte2hex(buffer[i+j]);
+                        cout << *dummy;
+                        if (j==7) {
+                                cout << "-" ;
+                        } else {
+                                cout << " " ;
+                        }
+                        delete dummy; dummy=NULL;
+                }
+                cout << " ";
+                for (int j=0;j<16;j++) {
+                        cout << Convert::safebyte(buffer[i+j]);
+                }
+                cout << "" << endl;
+        }
+}
+
+__uint32 hd24fs::songentry2sector(__uint32 songentry)
+{
+        // Given the possibility to store 99*99 songs,
+        // converts the song number (0..99*99-1) to
+        // the sector where the info of that song starts.
+        // TODO: answer is FSINFO_FIRST_SONG_SECTOR+(FSINFO_SECTORS_PER_SONG*songentry)
+        // returns 0 when entry number is not legal.
+        getsector_bootinfo();
+        if (sector_boot==NULL) {
+                // info needed for the calculation is missing.
+                return 0;
+        }
+        __uint32 firstsongsec=Convert::getint32(sector_boot,FSINFO_FIRST_SONG_SECTOR);
+        __uint32 secspersong=Convert::getint32(sector_boot,FSINFO_SECTORS_PER_SONG);
+        if (songentry<(99*99)) {
+                __uint32 secnum=(firstsongsec+(songentry*secspersong));
+                return secnum;
+        }
+        return 0; // entry number is not legal.
+}
+
+__uint32 hd24fs::songsondisk()
+{
+        getsector_bootinfo();
+        if (sector_boot==NULL) {
+                // info needed for the calculation is missing.
+                return 0;
+        }
+        return Convert::getint32(sector_boot,FSINFO_CURRENT_SONGS_ON_DISK);
+}
+
+void hd24fs::songsondisk(__uint32 songcount)
+{
+        getsector_bootinfo();
+        if (sector_boot==NULL) {
+                // info needed for the calculation is missing.
+                return; //cannot update.
+        }
+        Convert::setint32(sector_boot,FSINFO_CURRENT_SONGS_ON_DISK,songcount);  
+}
+
+__uint32 hd24fs::songsector2entry(__uint32 songsector)
+{
+        // given the sector where a song entry starts,
+        // returns the entry number of that song.
+        // Entry number typically ranges from 0
+        // to (99*99)-1.
+        // A value 0xffffffff is returned when the 
+        // sector number is not valid. 
+        getsector_bootinfo();
+        if (sector_boot==NULL) {
+                // info needed for the calculation is missing.
+                return 0xFFFFFFFF; // sector number is not valid.
+        }
+        __uint32 firstsongsec=Convert::getint32(sector_boot,FSINFO_FIRST_SONG_SECTOR);
+        __uint32 secspersong=Convert::getint32(sector_boot,FSINFO_SECTORS_PER_SONG);
+        __uint32 offset=songsector-firstsongsec;
+        if ((offset%secspersong) !=0) {
+                return 0xFFFFFFFF; // sector number is not valid.
+        }
+        __uint32 resultentry=(offset/secspersong);
+        if (resultentry>=(99*99)) return 0xFFFFFFFF;
+        return resultentry;
+}
+
+__uint32 hd24fs::cluster2sector(__uint32 clusternum)
+{
+        getsector_bootinfo();
+        if (sector_boot==NULL) {
+                // unknown cluster size.
+                return 0;
+        }
+        return Convert::getint32(sector_boot,FSINFO_DATAAREA) /* first audio sector */
+        +(
+                Convert::getint32(sector_boot,FSINFO_BLOCKSIZE_IN_SECTORS)
+                * Convert::getint32(sector_boot,FSINFO_AUDIOBLOCKS_PER_CLUSTER)
+                * clusternum
+        );
+}
+
+__uint32 hd24fs::sector2cluster(__uint32 sectornum)
+{
+        getsector_bootinfo();
+        if (sector_boot==NULL) {
+                // unknown cluster size. Return 'undefined' cluster number.
+                return CLUSTER_UNDEFINED;
+        }
+        __uint32 dataarea=Convert::getint32(sector_boot,FSINFO_DATAAREA);
+        
+        if (sectornum<dataarea) {
+                // A cluster number of a sector outside the data area was requested.
+                return CLUSTER_UNDEFINED;
+        }
+
+        __uint32 unoffsetsector=sectornum-dataarea;
+        __uint32 sectorspercluster=
+                Convert::getint32(sector_boot,FSINFO_BLOCKSIZE_IN_SECTORS)
+                * Convert::getint32(sector_boot,FSINFO_AUDIOBLOCKS_PER_CLUSTER);
+        __uint32 firstsectorofcluster=unoffsetsector-(unoffsetsector%sectorspercluster);
+        __uint32 cluster=firstsectorofcluster/sectorspercluster;
+        return cluster;
+}
+
+__uint32 hd24fs::getnextfreesector(__uint32 cluster)
+{
+        if (cluster==CLUSTER_UNDEFINED) {
+                __uint32 result=getnextfreesectorword();
+#if (HD24FSDEBUG==1)
+                cout << result << endl;
+#endif
+                return result;
+        }
+        if (isfreecluster(cluster+1,&sectors_driveusage[0])) 
+        {
+                return cluster2sector(cluster+1);
+        }       
+        return getnextfreesectorword();
+}
+
+__uint32 hd24fs::getnextfreesectorword()
+{
+        __uint32 cluster=getnextfreeclusterword();
+        if (cluster==CLUSTER_UNDEFINED) {
+                return 0;
+        }
+        return cluster2sector(cluster);
+}
+
+__uint32 hd24fs::getnextfreeclusterword()
+{
+        getsectors_driveusage();
+        __uint32 driveusagecount=driveusagesectorcount();
+        __uint32 driveusagewords=driveusagecount*(512/4);
+
+        // For performance reasons, we start searching
+        // at last result+1 (this will typically result
+        // in an immediate hit).
+        // Wrap around to cluster 0 if nothing found.
+
+#if (HD24FSDEBUG==1)
+        cout << " start search at " << nextfreeclusterword << endl;
+#endif
+        __uint32 i=nextfreeclusterword;
+        __uint32 initsec=i;
+                
+        bool foundfree=false;
+        while (i<driveusagewords) {
+                if (Convert::getint32(&sectors_driveusage[0],i*4)==0) {
+                        foundfree=true;
+                        break;
+                }
+                i++;
+        }
+        if (!foundfree) {
+                if (initsec==0) {
+                        // we didnt find anything although
+                        // we started searching at cluster 0.
+                        return CLUSTER_UNDEFINED;
+                } else {
+                        // we didnt find anything but started
+                        // searching at a cluster>0. Wrap around.
+                        nextfreeclusterword=0;
+                        return getnextfreeclusterword();
+                }
+        }
+        // we found a (set of 32) free cluster(s).
+        nextfreeclusterword=i;
+        return (i*32);
+}
+
+unsigned long hd24fs::getlastsectornum() 
+{
+#if (HD24FSDEBUG==1)
+        cout <<"hd24fs::getlastsectornum()" << endl;
+#endif
+        // cache result.
+        if (gotlastsectornum==false) {
+                foundlastsectornum=getlastsectornum(devhd24);
+                gotlastsectornum=true;
+        }
+        return foundlastsectornum;
+}
+
+void hd24fs::setwavefixmode(int mode) 
+{
+        wavefixmode=mode;
+}
+
+void hd24fs::setmaintenancemode(int mode) 
+{
+        maintenancemode=mode;
+}
+
+int hd24fs::getmaintenancemode() 
+{
+        return maintenancemode;
+}
+
+string* hd24fs::getdevicename() {
+
+        return this->devicename;
+}
+
+void hd24fs::setdevicename(const char* orig,string* devname)
+{
+        if (this->devicename!=NULL) {
+                delete this->devicename;
+                this->devicename=NULL;
+        }
+        this->devicename=new string(devname->c_str());
+}
+
+unsigned long hd24fs::getlastsectornum(FSHANDLE handle) 
+{
+#if (HD24FSDEBUG==1)
+        cout <<"hd24fs::getlastsectornum(FSHANDLE handle)" << endl;
+#endif
+#if defined(LINUX) || defined(DARWIN)
+        __uint64 curroff=lseek64(handle,0,SEEK_CUR);
+        __uint64 sectors=(lseek64(handle,0,SEEK_END)+1)>>9;
+        lseek64(handle,curroff,SEEK_SET);
+        return sectors-1;
+#endif
+        /* unfortunately, apart from other functions being needed
+         * to read 64 bit files, the elegant solution above won't
+         * work on Windows, because it is not possible to
+         * request the file size of a device.
+         */
+        
+#ifdef WINDOWS
+        unsigned char buffer[2048];
+        LARGE_INTEGER lizero;
+        lizero.QuadPart=0;
+        LARGE_INTEGER saveoff;
+        LARGE_INTEGER filelen;
+        filelen.QuadPart=0;
+        SetFilePointerEx(handle,lizero,&saveoff,FILE_CURRENT); // save offset
+        /* If things would work properly, the following would
+         * not only work for regular files, but also for devices.
+         * Perhaps the next version of Windows has proper hardware
+         * abstraction and this will magically start working.
+         */
+        if (0!=SetFilePointerEx(handle,lizero,&filelen,FILE_END)) {
+                SetFilePointerEx(handle,saveoff,NULL,FILE_BEGIN); // restore offset
+                return ((filelen.QuadPart)/512);
+        }
+        SetFilePointerEx(handle,saveoff,NULL,FILE_BEGIN); // restore offset
+#if (HD24FSDEBUG==1)
+        cout << "fileptr method failed" << endl;
+#endif
+        /* The proper way to do things has failed (probably because
+         * we are dealing with a device file instead of with a 
+         * regular one.
+         */
+
+        /* TODO: Before trying a raw sectornum scan, 
+           we can still check if we're dealing with a valid
+           superblock, not using a headerfile and checking if
+           the last sector as indicated by the superblock points
+           to a copy of that superblock. This won't work on a raw
+           drive, of course, but will provide a reasonably safe
+           workaround for valid HD24 drives. */
+
+        /* The workaround has also failed, so we need to perform
+           raw drive size detection. Windows does not have a reliable
+           way to get the real LBA sector count, so we need to perform
+           the following semi-smart trick (if you have a better idea that
+           works on all windows versions and all drive types,
+           I'd be thrilled to know!)
+
+           - First, iterate reading sector numbers until it fails.
+             To keep speed acceptable, multiply sector number by 2
+             each time.
+           - After failed read, do a binary search between the
+             failed read sector number and the sector number of
+             the last successful read.
+           - As the drive MUST be aware of its own size, this will
+             give the real sector count of the drive.
+         */
+        lizero.QuadPart=0;
+        saveoff.QuadPart=0;
+
+        LARGE_INTEGER maxbytes;
+        maxbytes.QuadPart=0;
+        SetFilePointerEx(handle,lizero,&saveoff,FILE_CURRENT); // save offset
+
+        long bytesread=1;
+        unsigned long trysector=1;
+        unsigned long oldtrysector=1;
+        int drivetoosmall=1;
+        bytesread=readsectors(handle,trysector,buffer,1); // raw/audio read (no fstfix needed)
+        unsigned long lastok=0;
+        unsigned long firstfail=0;
+        //int dummy;
+        /* This loop doubles the sector number. Actually stays at 2^n-1,
+         * this will likely perform better than 2^n because chances are
+         * greater that it stays below disk boundaries, preventing slow
+         * timeouts.
+         */
+        while (bytesread>0) 
+        {
+#if (HD24FSDEBUG==1)
+                cout << "trysector=" << trysector << endl;
+#endif
+//              cin >> dummy;
+                drivetoosmall=0;
+                oldtrysector=trysector;
+                trysector=trysector*2+1; // count will be 1,3,7,15,31,... =(2^n)-1
+                if (oldtrysector==trysector) 
+                {
+                        // x*2+1 yields x - this means all
+                        // bits are turned on and we overflow.
+                        // So we're at 4 tera limit.
+                        // 4 terabyte and still nothing found? hmmmm    
+                        SetFilePointerEx(handle,saveoff,NULL,FILE_BEGIN);
+                        return 0;
+                }
+                bytesread=0;
+                bytesread=readsectors(handle,trysector,buffer,1); // raw/audio read (no fstfix needed)
+#if (HD24FSDEBUG==1)
+                cout << "   bytesread=" <<bytesread << endl;
+#endif
+                if (bytesread>0) {
+                        lastok=trysector;
+                } else {
+                        firstfail=trysector;
+                }
+        }
+        /* We have the sector number of the last successful read and
+         * of the failed read. Time to do a binary search. */
+        unsigned long lowerbound=lastok;
+#if (HD24FSDEBUG==1)
+        cout << "lastok=" << lastok << endl;
+        cout << "firstfaiL=" << firstfail << endl;
+
+#endif
+        if (lastok==0) 
+        {
+                if (firstfail==0)
+                {
+                        return 0;
+                }
+        }
+        unsigned long upperbound=lastok*2;
+        unsigned long midpos=0;
+        while (lowerbound<=upperbound) 
+        {
+                //midpos=lowerbound+floor((upperbound-lowerbound)/2);
+                midpos=lowerbound+(__uint32)floor((upperbound-lowerbound)/8); 
+                // prefer asymmetrical search due to time out when
+                // searching past upperbound
+//              cout << "try=" << midpos << endl;
+                bytesread=readsectors(handle,midpos,buffer,1); // raw/audio read (no fstfix needed)
+                if (bytesread>0) {
+                        lowerbound=midpos+1;
+                } else {
+                        // could not read midpos, 
+                        // so upperbound is before that.
+                        upperbound=midpos-1;
+                }       
+        }
+        if (midpos==lowerbound)
+        {
+                midpos--;
+        }
+        /* midpos is now last sector number. counting starts at sector 0
+         * so total number of sectors is one more. */
+        midpos++;
+        SetFilePointerEx(handle,saveoff,&saveoff,FILE_BEGIN); //restore
+        
+        __uint64 sectors=midpos;
+//      cout << "found " <<sectors << "sectors " <<endl;
+        return sectors;
+#endif
+}
+
+/* The hd24raw class provides sector level access to hd24 disks
+ * which is functionality that is shielded off in hd24fs.
+ */
+
+__uint32 hd24raw::songsondisk()
+{
+        return fsys->songsondisk();
+}
+
+__uint32 hd24raw::getlastsectornum()
+{
+        return fsys->getlastsectornum();
+}
+
+__uint32 hd24raw::getprojectsectornum(__uint32 x)
+{
+        return fsys->getprojectsectornum(x);
+}
+
+__uint32 hd24raw::quickformat(char* message)
+{
+        return fsys->quickformat(message);
+}
+
+unsigned long hd24raw::getnextfreesector(__uint32 cluster)
+{
+        return fsys->getnextfreesector(cluster);
+}
+
+hd24raw::hd24raw(hd24fs* p_fsys) 
+{
+        fsys=p_fsys;
+}
+
+long hd24raw::readsectors(unsigned long secnum, unsigned char* buffer,int sectors) 
+{
+        return fsys->readsectors(fsys->devhd24, secnum, buffer,sectors);
+}
+
+long hd24raw::writesectors(unsigned long secnum, unsigned char* buffer,int sectors) 
+{
+        return fsys->writesectors(fsys->devhd24, secnum, buffer,sectors);
+};
+
+bool hd24fs::isinvalidhandle(FSHANDLE handle)
+{
+#ifdef WINDOWS
+        if (handle==FSHANDLE_INVALID) {
+                return true;
+        }
+#endif
+#if defined(LINUX) || defined(DARWIN)
+        if (handle==0) {
+                return true;
+        }
+        if (handle==FSHANDLE_INVALID) {
+                return true;
+        }
+#endif
+        return false;
+}
+
+bool hd24fs::isexistingdevice(string* devname) 
+{
+#if defined(LINUX) || defined(DARWIN)
+#if (HD24FSDEBUG==1)
+cout << "try open device " << devname->c_str() << endl;
+#endif
+        FSHANDLE handle=open64(devname->c_str(),MODE_RDONLY); //read binary
+#endif
+#ifdef WINDOWS
+        FSHANDLE handle=CreateFile(devname->c_str(),MODE_RDONLY,
+                     FILE_SHARE_READ|FILE_SHARE_WRITE,
+                     NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
+#endif
+        if (!isinvalidhandle(handle)) return true;
+        return false;   
+}
+
+FSHANDLE hd24fs::findhd24device(int mode,string* devname,bool force,bool tryharder) 
+{
+#if (HD24FSDEBUG_DEVSCAN==1)
+        cout << "FSHANDLE hd24fs::findhd24device(" << mode << ", " << *devname << ", force=" << force << ",tryharder=" << tryharder <<")" << endl;
+#endif
+        unsigned char findhdbuf[1024];
+        unsigned char compare1buf[1024];
+        unsigned char compare2buf[1024];
+#if defined(LINUX)
+        FSHANDLE handle=open64(devname->c_str(),mode,0); //read binary
+#endif
+#if defined(DARWIN)
+        FSHANDLE handle=open64(devname->c_str(),mode); //read binary
+#endif
+#ifdef WINDOWS
+#if (HD24FSDEBUG_DEVSCAN==1)
+        cout << "Mode=" << mode << endl;
+#endif
+        FSHANDLE handle=CreateFile(devname->c_str(),mode,
+                FILE_SHARE_READ|FILE_SHARE_WRITE,
+                NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
+#endif
+
+        if (isinvalidhandle(handle)) {
+                if (mode==MODE_RDWR) 
+                {
+                        // attempt fallback to read-only mode
+                        // (for CDROM/DVD devices etc)
+                        mode=MODE_RDONLY;
+#if defined(LINUX) || defined(DARWIN)
+                        handle=open64(devname->c_str(),mode); //read binary
+#endif
+#ifdef WINDOWS
+#if (HD24FSDEBUG==1)
+//      cout << "Mode=" << mode << endl;
+#endif
+                        handle=CreateFile(devname->c_str(),mode,
+                        FILE_SHARE_READ|FILE_SHARE_WRITE,
+                        NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
+#endif
+
+                }
+
+
+        }
+
+        if (isinvalidhandle(handle)) {
+                return handle;
+        }
+
+        // can open device.
+        __uint32 sectornum=0;
+        if (tryharder) {
+                sectornum=getlastsectornum(handle);
+        }
+
+        readsector_noheader(handle,sectornum,findhdbuf); // fstfix follows
+        fstfix(findhdbuf,512);
+        string* fstype=Convert::readstring(findhdbuf,0,8);
+        bool isadat=false;
+        
+        if (*fstype=="ADAT FST") {
+                /* Okay, but if we are 'trying harder' we can run into
+                   a false positive for old HD24 drives that are now in
+                   use as OS drive. So we'll demand that the second and
+                   secondlast sector are equal.
+                */
+                if (tryharder) 
+                {
+                        readsector_noheader(handle,sectornum-1,compare1buf); 
+                        readsector_noheader(handle,1,compare2buf); 
+                        if (memcmp(compare1buf,compare2buf,512)==0) 
+                        {
+                                isadat=true;
+                        }
+                        else 
+                        {
+                                /* Drive may have been an ADAT drive,
+                                   but no longer is. If it is in fact an 
+                                   ADAT drive but corrupted, it is still 
+                                   possible to force detection using force 
+                                   mode. Give it another chance; do not
+                                   enable write prevention for now.
+                                */
+                                isadat=false;
+                        }
+                }
+                else 
+                {
+                        isadat=true;
+                }
+        }
+        delete fstype;
+
+        if (isadat) return handle;
+
+        if (force) 
+        {
+                forcemode=true;
+                m_isOpen=true;
+                this->writeprotected=true; // TODO: unless expert mode is enabled too. May also be overridden to allow formatting.
+                return handle;
+        }
+        hd24closedevice(handle);
+        return FSHANDLE_INVALID;
+}
+
+unsigned long hd24fs::hd24devicecount() 
+{
+        /* Attempt to auto-detect a hd24 disk on all IDE and SCSI devices.
+           (this should include USB and firewire) */
+        FSHANDLE handle;
+        int devcount=0;
+#if (HD24FSDEBUG==1)
+        cout << "====PERFORMING DEVICE COUNT====" << endl;      
+#endif
+        hd24devicenamegenerator* dng=new hd24devicenamegenerator();
+        dng->imagedir(this->imagedir);
+        
+        __uint32 totnames=dng->getnumberofnames();
+//      cout << totnames << " devices" << endl;         
+        for (__uint32 j=0;j<2;j++) 
+        {
+                // 2 loops: one to try, one to try harder
+                // first loop searches strictly valid devices 
+                // second loop searches for possibly corrupted devices
+                bool tryharder=false;
+                if (j==1) {
+                        tryharder=true;
+                }
+                for (__uint32 i=0;i<totnames;i++) 
+                {
+                        string* devname=dng->getdevicename(i);
+                        handle=findhd24device(MODE_RDONLY,devname,false,tryharder);
+#if (HD24FSDEBUG_DEVSCAN==1)
+                        cout << "try device no " <<i << "with name" << *devname << "...";
+#endif
+                        delete (devname);
+                        if (!(isinvalidhandle(handle))) 
+                        {
+                                devcount++;
+        //                      cout << "found" << endl;
+                                hd24closedevice(handle);
+                        } else {
+        //                      cout << "nope." << endl;
+                        }
+                }
+
+                if (devcount>0) {               
+                        break;
+                }
+        }
+#if (HD24FSDEBUG==1)
+        cout << "====END OF DEVICE COUNT, " << devcount << " DEVICES FOUND ====" << endl;       
+#endif
+        delete (dng);
+        return devcount;
+}
+
+void hd24fs::setimagedir(const char* newdir)
+{
+#if (HD24FSDEBUG==1)
+if (newdir==NULL)
+{
+        cout << "hd24fs::setimagedir(NULL)"<< endl;
+}
+else
+{
+        cout << "hd24fs::setimagedir("<<newdir<<")"<< endl;
+}
+#endif
+        
+        if (this->imagedir!=NULL)
+        {
+                free ((void*)imagedir);
+                this->imagedir=NULL;
+        }
+
+        if (newdir!=NULL)
+        {
+                this->imagedir=(char*)malloc(strlen(newdir)+1);
+                if (this->imagedir!=NULL)
+                {
+                        strncpy((char*)imagedir,newdir,strlen(newdir)+1);               
+                }
+        }
+        
+        return; //return (const char*)imagedir;
+}
+
+FSHANDLE hd24fs::findhd24device(int mode,int base0devnum) 
+{
+#if (HD24FSDEBUG_DEVSCAN==1)
+        cout << "hd24fs::findhd24device(" << mode << "," << base0devnum << ")" << endl;
+#endif
+        // TODO: Reduce code duplication in this subroutine
+        // and hd24devicecount
+        /* Attempt to auto-detect a hd24 disk on all known
+           IDE and SCSI devices. (this should include USB 
+           and firewire) */
+        int currdev=0;
+        FSHANDLE handle;
+        hd24devicenamegenerator* dng=new hd24devicenamegenerator();
+        dng->imagedir(this->imagedir);
+                
+        __uint32 totnames=dng->getnumberofnames();              
+#if (HD24FSDEBUG==1)
+        cout << totnames << " devices" << endl;         
+#endif
+        for (__uint32 j=0;j<2;j++) 
+        {
+                // 2 loops: one to try, one to try harder
+                // first loop searches strictly valid devices 
+                // second loop searches for possibly corrupted devices
+
+                bool tryharder=false;
+                if (j==1) {
+                        tryharder=true;
+                }
+
+                for (__uint32 i=0;i<totnames;i++) 
+                {
+                        string* devname=dng->getdevicename(i);
+                        handle=findhd24device(mode,devname,false,tryharder);
+                        
+                        if (!(isinvalidhandle(handle))) {
+                                if (currdev==base0devnum) {
+                                        // String "3" indicates origin, i.e.
+                                        // who is setting the device name.
+                                        // Useful for debugging purposes.
+                                        setdevicename("3",devname);
+                                        deviceid=i;
+                                        p_mode=mode;
+                                        delete (devname);
+                                        delete (dng);
+                                        return handle;
+                                }
+                                hd24closedevice(handle);
+                                currdev++;
+                        }
+                        delete (devname);
+                }
+        }
+        delete (dng);
+        return FSHANDLE_INVALID;
+}
+
+void hd24fs::hd24closedevice(FSHANDLE handle) {
+#if defined(LINUX) || defined(DARWIN)
+        close(handle);
+#endif
+#ifdef WINDOWS
+        CloseHandle(handle);
+#endif
+}
+
+FSHANDLE hd24fs::findhd24device(int mode) 
+{
+        /* Attempt to auto-detect a hd24 disk on all IDE and SCSI devices.
+           (this should include USB and firewire) */
+        return findhd24device(mode,0);
+}
+
+FSHANDLE hd24fs::findhd24device() 
+{
+        return findhd24device(MODE_RDONLY);
+}
+
+int hd24fs::gettransportstatus()
+{
+        return this->transportstatus;
+}
+
+void hd24fs::settransportstatus(int newstatus)
+{
+        this->transportstatus=newstatus;
+}
+
+int hd24fs::getdeviceid()
+{
+        return deviceid;
+}
+
+void hd24fs::initvars() 
+{
+        this->deviceid=-1;
+        this->writeprotected=false; // by default allow writes.
+                                    // can be disabled if corrupt 
+                                    // state is detected.
+        this->transportstatus=TRANSPORTSTATUS_STOP;
+        this->imagedir=NULL;
+        this->nextfreeclusterword=0;
+        this->gotlastsectornum=false;
+        this->foundlastsectornum=0;
+        this->forcemode=false;
+        this->headersectors=0;
+        sector_boot=NULL;
+        sector_diskinfo=NULL;
+        sectors_driveusage=NULL;
+        sectors_orphan=NULL;
+        sectors_songusage=NULL;
+        projlist=NULL;
+        this->m_isOpen=false;
+        this->allinput=false;
+        this->autoinput=false;
+        this->wavefixmode=false;
+        this->formatting=false;
+        this->maintenancemode=false;
+        this->headermode=false;
+        this->devicename=NULL;
+        this->highestFSsectorwritten=0;
+        // 0x10c76 is last sector of song/project area (without undo buffer)
+        return; 
+}
+
+hd24fs::hd24fs(const char* imagedir,int mode)
+{
+        initvars();
+        setimagedir(imagedir);
+        devicename=new string("");
+        devhd24=findhd24device(mode);
+        if (!(isinvalidhandle(devhd24))) {
+                m_isOpen=true;
+                p_mode=mode;
+        }
+        return;
+}
+
+hd24fs::hd24fs(const char* imagedir,int mode,int base0devnum)
+{
+#if (HD24FSDEBUG==1)
+        cout << "hd24fs::hd24fs(" << mode << "," << base0devnum << ")" << endl;
+#endif  
+        initvars();
+        setimagedir(imagedir);
+        devicename=new string("");
+        devhd24=findhd24device(mode,base0devnum);
+        if (!(isinvalidhandle(devhd24))) {
+                m_isOpen=true;
+                p_mode=mode;
+        }
+        return;
+}
+
+hd24fs::hd24fs(const char* imagedir,int mode,string* devname,bool force)
+{
+        initvars();
+        setimagedir(imagedir);
+        devicename=new string(devname->c_str());
+        bool tryharder=false;
+        devhd24=findhd24device(mode,devname,force,tryharder);
+        if (!(isinvalidhandle(devhd24))) {
+                m_isOpen=true;
+                p_mode=mode;
+        }
+        return;
+}
+
+hd24fs::hd24fs(const char* imagedir)
+{
+        initvars();
+        setimagedir(imagedir);
+        devicename=new string("");
+        devhd24=findhd24device(MODE_RDONLY);
+        if (!(isinvalidhandle(devhd24))) {
+                m_isOpen=true;
+                p_mode=MODE_RDONLY;
+        }
+        return;
+}
+
+hd24fs::~hd24fs()
+{
+#if (HD24FSDEBUG==1)
+        cout << "Deleting devicename" << endl;
+#endif
+        if (devicename!=NULL) {
+                delete devicename;
+                devicename=NULL;
+        }
+#if (HD24FSDEBUG==1)
+        cout << "Close FS handle" << endl;
+#endif
+        if (isOpen())
+        {
+                hd24close();
+        }
+#if (HD24FSDEBUG==1)
+        cout << "Free superblock mem" << endl;
+#endif
+        if (sector_boot!=NULL)
+        {
+                memutils::myfree("sectors_boot",sector_boot);
+                sector_boot=NULL;
+        }
+#if (HD24FSDEBUG==1)
+        cout << "Free diskinfo mem" << endl;
+#endif
+        if (sector_diskinfo!=NULL) 
+        {
+                memutils::myfree("sectors_diskinfo",sector_diskinfo);
+                sector_diskinfo=NULL;
+        }
+#if (HD24FSDEBUG==1)
+        cout << "Free drive usage mem" << endl;
+#endif
+        if (sectors_driveusage!=NULL)
+        {
+                memutils::myfree("sectors_driveusage",sectors_driveusage);
+                sectors_driveusage=NULL;
+        }
+#if (HD24FSDEBUG==1)
+        cout << "Free orphan sectors mem" << endl;
+#endif
+        if (sectors_orphan!=NULL)
+        {
+                memutils::myfree("sectors_orphan",sectors_orphan);
+                sectors_orphan=NULL;
+        }
+#if (HD24FSDEBUG==1)
+        cout << "Free song usage sectors mem" << endl;
+#endif
+        if (sectors_songusage!=NULL)
+        {
+                memutils::myfree("sectors_songusage",sectors_songusage);
+                sectors_songusage=NULL;
+        };
+        // commit?
+}
+
+bool hd24fs::isOpen() 
+{
+        if (this->m_isOpen) 
+        {
+                return true;
+        }
+        return false;
+}       
+
+void hd24fs::hd24close() 
+{
+        // TODO: At the point that we start supporting
+        // write access, we will need to flush and close
+        // the device here.
+        
+        hd24closedevice(this->devhd24);
+}
+
+void hd24fs::fstfix(unsigned char * bootblock,int fixsize) 
+{
+        if (bootblock==NULL) return;
+        if (fixsize<=0) return;
+#if (HD24FSDEBUG==1)
+        cout << "fstfix("<<bootblock<<","<<fixsize/512 <<"*512)"<< endl;
+#endif
+        for (int i=0;i<fixsize;i+=4) 
+        {
+                unsigned char a=bootblock[i];
+                unsigned char b=bootblock[i+1];
+                unsigned char c=bootblock[i+2];
+                unsigned char d=bootblock[i+3];
+                bootblock[i]=d;
+                bootblock[i+1]=c;
+                bootblock[i+2]=b;
+                bootblock[i+3]=a;
+        }
+}
+
+void hd24fs::hd24seek(FSHANDLE devhd24,__uint64 seekpos) {
+#if defined(LINUX) || defined(DARWIN)
+        lseek64(devhd24,seekpos,SEEK_SET);
+#endif
+#ifdef WINDOWS
+//      cout << "setfp to " <<seekpos << endl;
+        LARGE_INTEGER li;
+        li.HighPart=seekpos>>32;
+        li.LowPart=seekpos%((__uint64)1<<32);
+//LowPart=seekpos%
+//      SetFilePointer(devhd24,seekpos,NULL,FILE_BEGIN);
+        SetFilePointerEx(devhd24,li,NULL,FILE_BEGIN);
+        // TODO: SetFilePointer vs SetFilePointerEx
+        // DWORD SetFilePointer(
+        //   HANDLE hFile,
+        //     LONG lDistanceToMove,
+        //       PLONG lpDistanceToMoveHigh,
+        //         DWORD dwMoveMethod
+        //         );
+        //
+        // vs.
+        // BOOL SetFilePointerEx(
+        //   HANDLE hFile,
+        //     LARGE_INTEGER liDistanceToMove,
+        //       PLARGE_INTEGER lpNewFilePointer,
+        //         DWORD dwMoveMethod
+        //         );
+        //
+#endif
+        return;
+}
+
+long hd24fs::writesectors(FSHANDLE devhd24,unsigned long sectornum,unsigned char * buffer,int sectors) 
+{
+        //////
+        // this bit keeps track of the highest FS sector written
+        // to keep commit times acceptable: commit function will then
+        // only backup up to the highest sector used.
+        // (this is still suboptimal performance-wise but requires
+        // a minimum of memory and administration during writes).
+        __uint32 lastsec=sectornum+(sectors-1);
+        if (lastsec<=0x10c76)
+        {
+                // 0x10c76 is last sector of song/project area (without
+                // undo buffer). TODO: calculate based on superblock. info.
+                if (lastsec>highestFSsectorwritten)
+                {
+                        highestFSsectorwritten=lastsec;
+                }
+        }
+        //////
+        
+#if (HD24FSDEBUG_WRITE==1)
+                cout << "   writesectors sectornum " << sectornum << ", sectorcount=" << sectors << endl;
+#endif
+        if (this!=NULL)
+        {
+                if (this->writeprotected)
+                {
+#if (HD24FSDEBUG_WRITE==1)
+                        cout << "Write protected- not writing. " << endl;
+#endif
+                        return 0;
+                }
+        }
+        FSHANDLE currdevice=devhd24;
+
+#if (HD24FSDEBUG_WRITE==1)
+        cout << "WRITESECTORS sec=" << sectornum << " buf=" << buffer << "#=" << sectors << endl;
+#endif
+        int WRITESIZE=SECTORSIZE*sectors; // allows searching across sector boundaries
+        
+//      cout << "headersectors=" << this->headersectors << "this=" <<this << endl;
+        if (this!=NULL)
+        {
+                if ((this->headersectors)!=0)
+                {
+//              cout << "headermode enabled." << endl;
+                        // Header mode is active. Only allow writing over header area.
+                        if (sectornum<this->headersectors) 
+                        {
+//                      cout << "Headermode enabled for sector " << sectornum << endl;
+                        currdevice=hd24header;
+
+                        } else {
+                                // headermode is active yet caller is trying to write over drive
+                                // data area. We cannot allow this (for safety reasons).
+                                return 0;
+                
+//                      cout << "Headermode disabled for sector " << sectornum << endl;
+                        }
+                } else {
+//                      cout << "Headermode disabled. " << sectornum << endl;
+                }
+        }
+
+        hd24seek(currdevice,(__uint64)sectornum*512);
+
+#if defined(LINUX) || defined(DARWIN) || defined(__APPLE__)
+       long bytes=pwrite64(currdevice,buffer,WRITESIZE,(__uint64)sectornum*512); //1,devhd24);
+//      cout << "BYTES=" << bytes << endl;
+#endif
+#ifdef WINDOWS
+        DWORD dummy;
+        long bytes=0;
+        if (WriteFile(currdevice,buffer,WRITESIZE,&dummy,NULL)) {
+                bytes=WRITESIZE;
+        };
+#endif
+        return bytes;
+}
+
+long hd24fs::readsectors(FSHANDLE devhd24,unsigned long sectornum,unsigned char * buffer,int sectors) 
+{
+        FSHANDLE currdevice=devhd24;
+        // The following prints the sector num in hex:
+#if (HD24FSDEBUG==1)
+/*      string* x=this->p_convert->int32tohex(sectornum);
+        cout << *x << endl;
+        delete x; 
+*/
+#endif
+        
+//      cout << "headersectors=" << this->headersectors << "this=" <<this << endl;
+        if ((this->headersectors)!=0)
+        {
+//              cout << "headermode enabled." << endl;
+                if (sectornum<this->headersectors) 
+                {
+//                      cout << "Headermode enabled for sector " << sectornum << endl;
+                        currdevice=hd24header;
+                } else {
+//                      cout << "Headermode disabled for sector " << sectornum << endl;
+                }
+        } else {
+//              cout << "Headermode disabled. " << sectornum << endl;
+        }
+        hd24seek(currdevice,(__uint64)sectornum*SECTORSIZE);
+       int READSIZE=SECTORSIZE*(sectors);
+#if defined(LINUX) || defined(DARWIN)
+       long bytes_read=pread64(currdevice,buffer,READSIZE,(__uint64)sectornum*512); //1,currdevice);
+#endif
+#ifdef WINDOWS
+//      cout << "Readsectors: num="<<sectornum<<"buffer available, numsecs=" <<sectors << endl;
+        DWORD bytes_read;
+        //long bytes=0;
+        if( ReadFile(currdevice,buffer,READSIZE,&bytes_read,NULL)) {
+//              cout << "read succes"<< bytes_read << "bytes" << endl;
+        } else {
+//              cout << "read fail" << endl;

+                bytes_read = 0;
+        }
+#endif
+        return bytes_read;
+}
+
+long hd24fs::readsector(FSHANDLE devhd24,unsigned long sectornum,unsigned char * bootblock) 
+{
+        return readsectors(devhd24,sectornum,bootblock,1);
+}
+
+long hd24fs::readsector_noheader(hd24fs* currhd24,unsigned long sectornum,unsigned char * bootblock) 
+{
+        return readsector_noheader(currhd24->devhd24,sectornum,bootblock);
+}
+
+long hd24fs::readsector_noheader(FSHANDLE devhd24,unsigned long sectornum,unsigned char * bootblock) 
+{
+        unsigned long headersecs=this->headersectors;
+        this->headersectors=0; // disable header processing, if applies
+        long number_read=readsectors(devhd24,sectornum,bootblock,1);
+        this->headersectors=headersecs; // re-enable header processing
+        return number_read;
+}
+
+long hd24fs::writesector(FSHANDLE devhd24,unsigned long sectornum,unsigned char * bootblock) 
+{
+        return writesectors(devhd24,sectornum,bootblock,1);
+}
+
+string* hd24fs::gethd24currentdir(int argc,char* argv[]) 
+{
+        /* For future use. We may save a file in the
+           homedir of the user containing info about which
+           "path" (project/songname/file format) was last
+           selected by the user.
+        */
+        
+       return new string("/");
+}
+
+string* hd24fs::gethd24currentdir()
+{
+       return new string("/");
+}
+
+unsigned char* hd24fs::readdiskinfo() 
+{
+#if (HD24FSDEBUG==1)
+        cout << "Driveusage before readdiskinfo=" << (int)(this->sectors_driveusage) << endl;
+#endif
+        // read disk info
+        if (/*formatting||*/(sector_boot==NULL))
+        {
+                this->readbootinfo();
+        }
+        if (sector_diskinfo!=NULL)
+        {
+                memutils::myfree("readdiskinfo",sector_diskinfo);
+                sector_diskinfo=NULL;
+        }
+        sector_diskinfo=(unsigned char *)memutils::mymalloc("readdiskinfo",1024,1);
+        if (sector_diskinfo!=NULL) 
+        {
+                readsector(devhd24,1,sector_diskinfo); // fstfix follows
+                fstfix (sector_diskinfo,512);
+        }
+#if (HD24FSDEBUG==1)
+        cout << "Driveusage after readdiskinfo=" << (int)(this->sectors_driveusage) << endl;
+#endif
+        return sector_diskinfo;
+}
+
+bool hd24fs::useheaderfile(string headerfilename)
+{
+        getsector_bootinfo();
+        if (sector_boot==NULL) 
+        {
+                /* we haven't got a main device yet
+                   so we cannot apply a header to it */ 
+                return false;
+        }
+        // allow writing to header.
+#if defined(LINUX) || defined(DARWIN)
+        FSHANDLE handle=open64(headerfilename.c_str(),MODE_RDWR); //read binary
+#endif
+#ifdef WINDOWS
+//      cout << "Mode=" << mode << endl;
+        FSHANDLE handle=CreateFile(headerfilename.c_str(),MODE_RDWR,
+                FILE_SHARE_READ|FILE_SHARE_WRITE,
+                NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
+#endif
+
+        if (isinvalidhandle(handle)) return false;
+//      cout << "Trying to enable header mode with file " << headerfilename << endl;
+        hd24header=handle;
+        this->headersectors=0;
+        this->headersectors=getlastsectornum(hd24header)+1;
+        // re-read disk info as number of projects etc can differ with header
+        readsector(devhd24,1,sector_diskinfo); // fstfix follows
+        fstfix (sector_diskinfo,512);
+
+//      cout << "headersectors=" << this->headersectors << "this=" <<this << endl;
+        return true;
+}
+
+void hd24fs::clearbuffer(unsigned char* buffer,unsigned int bytes)
+{
+        /* clear buffer */
+        for (unsigned int i=0;i<bytes;i++) {
+                buffer[i]=0;
+        }
+        return;
+}
+
+void hd24fs::clearbuffer(unsigned char* buffer)
+{
+        clearbuffer(buffer,512);
+}
+
+
+void hd24fs::cleardriveinfo(unsigned char* buffer)
+{
+        clearbuffer(buffer);
+        string drivename="Drive Name";
+        this->setname(buffer,drivename,DRIVEINFO_VOLUME_8,DRIVEINFO_VOLUME);
+        return;
+}
+
+void hd24fs::useinternalboot(unsigned char* buffer,__uint32 lastsector)
+{
+        unsigned char internal_boot[136]=
+        {
+        0x54,0x41,0x44,0x41,0x54,0x53,0x46,0x20, 0x20,0x30,0x31,0x31,0x33,0xcc,0xaa,0x55,
+        0x80,0x04,0x00,0x00,0x02,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,
+        0x02,0x00,0x00,0x00,0x03,0x00,0x00,0x00, 0x05,0x00,0x00,0x00,0x0f,0x00,0x00,0x00,
+        0x2f,0x04,0x00,0x00,0x00,0x00,0x00,0x00, 0x14,0x00,0x00,0x00,0x01,0x00,0x00,0x00,
+        0x63,0x00,0x00,0x00,0x63,0x00,0x00,0x00, 0x77,0x00,0x00,0x00,0x02,0x00,0x00,0x00,
+        0x05,0x00,0x00,0x00,0x07,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x49,0x26,0x00,0x00,
+        0x76,0x0c,0x01,0x00,0x80,0x8b,0x12,0x00, 0x1f,0x04,0x00,0x00,0xf6,0x97,0x13,0x00,
+        0x14,0x89,0xb4,0x04,0x7f,0x2d,0xc9,0x04
+        };
+
+        clearbuffer(buffer);
+
+        /* fill buffer with default boot info */
+        for (unsigned int i=0;i<sizeof(internal_boot);i++) {
+                buffer[i]=internal_boot[i];
+        }       
+
+        /* If a specific FS size (in sectors) was given, update boot info
+           to match that size */
+        if (lastsector!=0) 
+        {
+#if (HD24FSDEBUG_QUICKFORMAT==1)
+                cout << "Calculating number of clusters on the drive" << endl;
+#endif
+                fstfix(buffer,512); // convert into editable format
+
+                Convert::setint32(buffer,FSINFO_LAST_SECTOR,lastsector);
+#if (HD24FSDEBUG_QUICKFORMAT==1)
+                cout << "Last sector=" << lastsector << endl;
+#endif          
+                // allocatable sectors=total sectors-(2*fs sectors+undo area)
+                // tot secs-0x14a46b
+
+                __uint32 allocatablesectors=lastsector-0x14a46b;
+#if (HD24FSDEBUG_QUICKFORMAT==1)
+                cout << "# allocatable sectors=" << allocatablesectors << endl;
+#endif          
+                Convert::setint32(buffer,FSINFO_ALLOCATABLE_SECTORCOUNT,allocatablesectors);
+
+                // (15 sectors of drive usage info=((15*512)-8)*8 bits
+                //
+                __uint32 maxclusters=((15 /*sectors of alloc info*/ 
+                                       *512 /*bytes*/)
+                                       -8 /* checksum bytes */)
+                                        *8 /* bits per byte */;
+                // represents ~ 61376 allocatable clusters 
+#if (HD24FSDEBUG_QUICKFORMAT==1)
+                cout << "max # of clusters=" << maxclusters << endl;
+#endif                          
+                __uint32 allocatableaudioblocks=(allocatablesectors - (allocatablesectors%0x480))/0x480;
+#if (HD24FSDEBUG_QUICKFORMAT==1)
+                cout << "allocatable audio blocks=" << allocatableaudioblocks << endl;
+#endif                          
+                // given the maximum number of clusters 
+                // and the total number of allocatable audio blocks,
+                // we must decide on the number of audio blocks per cluster.
+                __uint32 rest=0;
+                if ((allocatableaudioblocks%maxclusters)>0) rest++;
+                __uint32 blockspercluster=rest+((allocatableaudioblocks-(allocatableaudioblocks%maxclusters))/maxclusters);
+#if (HD24FSDEBUG_QUICKFORMAT==1)
+                cout << "blocks per cluster="<<blockspercluster<< endl;
+#endif                          
+                Convert::setint32(buffer,FSINFO_AUDIOBLOCKS_PER_CLUSTER,blockspercluster);
+
+                // offset 0x14h: number of audio blocks per cluster
+                __uint32 allocatableclusters=(allocatableaudioblocks-(allocatableaudioblocks%blockspercluster))/blockspercluster;
+                Convert::setint32(buffer,FSINFO_FREE_CLUSTERS_ON_DISK,allocatableclusters);
+#if (HD24FSDEBUG_QUICKFORMAT==1)
+                cout << "allocatableclusters="<<allocatableclusters<< endl;
+#endif                          
+                fstfix(buffer,512); // convert back into native format
+        }       
+
+        /* Calculate the proper checksum for the bootinfo */
+        setsectorchecksum(buffer,
+                0 /* startoffset */,
+                0 /* sector */, 
+                1 /*sectorcount */
+        );
+        return;
+}
+
+unsigned char* hd24fs::readbootinfo() 
+{
+        // read boot info
+
+        if (sector_boot==NULL)
+        {
+#if (HD24FSDEBUG_QUICKFORMAT==1)
+                cout << "Malloc space for bootsector" << endl;
+#endif
+                sector_boot=(unsigned char *)memutils::mymalloc("readbootinfo",1024,1);
+        }
+
+        if (sector_boot!=NULL) 
+        {
+#if (HD24FSDEBUG_QUICKFORMAT==1)
+                cout << "Malloc space for bootsector succeeded" << endl;
+                cout << "forcemode=" << forcemode << endl;
+#endif
+                if (formatting||(!forcemode)) {
+#if (HD24FSDEBUG_QUICKFORMAT==1)
+                cout << "Reading sector (From disk)" << endl;
+#endif
+                        readsector(devhd24,0,sector_boot);
+                } else {                
+#if (HD24FSDEBUG_QUICKFORMAT==1)
+                cout << "Using internal boot." << endl;
+#endif
+                        useinternalboot(sector_boot,0); 
+                }
+                fstfix(sector_boot,512);
+        } else {
+#if (HD24FSDEBUG_QUICKFORMAT==1)
+                cout << "Malloc space for bootsector failed" << endl;
+#endif
+        }
+#if (HD24FSDEBUG_QUICKFORMAT==1)                        
+        dumpsector((const char*)sector_boot);
+#endif  
+        return sector_boot;
+}
+
+unsigned char* hd24fs::readdriveusageinfo()
+{
+#if (HD24FSDEBUG==1)|| (HD24FSDEBUG_QUICKFORMAT==1)
+        cout << "hd24fs::readdriveusageinfo()" << endl;
+#endif
+
+        // read file allocation table/disk usage table
+        unsigned int driveusagecount=driveusagesectorcount();
+        if (sectors_driveusage==NULL)
+        {
+
+                sectors_driveusage=(unsigned char *)memutils::mymalloc("readdriveusageinfo/sectors_driveusage",512*(driveusagecount+1),1);
+        }
+        //cout << "ptr=" << sectors_driveusage << endl;
+        if (sectors_driveusage!=NULL)
+        {
+#if (HD24FSDEBUG_QUICKFORMAT==1)
+        cout    << "hd24fs::readdriveusageinfo() reading "
+                << driveusagecount << "sectors into buffer at "
+                << &sectors_driveusage << endl;
+#endif          
+                readsectors(devhd24,driveusagefirstsector(),sectors_driveusage,driveusagecount);
+                fstfix(sectors_driveusage,512*driveusagecount);
+
+        }
+#if (HD24FSDEBUG_QUICKFORMAT==1)
+        cout << "Dumping newly read sector to screen:" << endl ;
+        dumpsector((const char*)sectors_driveusage);
+#endif
+        return sectors_driveusage;
+}
+
+unsigned char* hd24fs::resetsongusage()
+{
+        // Reset song usage table. First we occupy all of it;
+        // then we make only accessible entries available.
+        if (sectors_songusage==NULL)
+        {
+                sectors_songusage=(unsigned char *)memutils::mymalloc("resetsongusage",512*3,1);
+                if (sectors_songusage==NULL) 
+                {
+                        return NULL;
+                }
+        }
+
+        if (sectors_songusage!=NULL)
+        {
+                for (int i=0;i<512*3;i++) 
+                {
+                        sectors_songusage[i]=0xff;
+                }
+        }
+
+        __uint32 i;
+        // table is initialized, now populate it.
+        __uint32 maxprojs=this->maxprojects();
+        __uint32 maxsongcount=this->maxsongsperproject();
+        __uint32 totentries=maxprojs*maxsongcount; // 99 songs, 99 projects
+#if (HD24FSDEBUG==1)
+        cout << "Clear song usage table..."<< endl;     
+        cout << "this=" << this << endl;
+#endif
+        for (i=0;i<totentries;i++) {
+                disablebit(i,sectors_songusage);
+                // this is based on song sectors. 
+                // That is, entry 0=sec 0x77,
+                // entry 1=sec 0x77+7, etc.
+        }
+#if (HD24FSDEBUG==1)
+        cout << "Usage table cleared." << endl;
+#endif
+        return sectors_songusage;
+}
+
+unsigned char* hd24fs::resetdriveusage()
+{
+#if (HD24FSDEBUG==1)||(HD24FSDEBUG_QUICKFORMAT==1)
+        cout << "hd24fs::resetdriveusage()" << endl;
+#endif  
+        // Reset drive usage table. First we occupy all of it;
+        // then we make only accessible entries available.
+
+        if (this->sectors_driveusage==NULL)
+        {
+                unsigned char* du=(unsigned char *)memutils::mymalloc("resetdriveusage/sectors_driveusage",512*15,1);
+                sectors_driveusage=du;
+                if (this->sectors_driveusage==NULL) 
+                {
+                        return NULL;
+                }
+        }
+
+        for (int i=0;i<512*15;i++) 
+        {
+                sectors_driveusage[i]=0xff;
+        }
+
+        if (formatting||(sector_boot==NULL) )
+        {
+#if (HD24FSDEBUG_QUICKFORMAT==1)
+        cout << "hd24fs::resetdriveusage() - reloading boot info " << endl;
+#endif  
+
+                this->readbootinfo();
+        } else {
+#if (HD24FSDEBUG_QUICKFORMAT==1)
+        cout << "hd24fs::resetdriveusage() - using current (not reloading) boot info " << endl;
+#endif  
+
+        }
+
+        __uint32 i;
+        // table is initialized, now populate it.
+        __uint32 totentries=Convert::getint32(sector_boot,FSINFO_FREE_CLUSTERS_ON_DISK);
+#if (HD24FSDEBUG_QUICKFORMAT==1)
+        cout << "According to superblock, free clusters on disk=" << totentries << endl;
+        dumpsector((const char*)sector_boot);
+#endif  
+#if (HD24FSDEBUG_QUICKFORMAT==1)
+        cout << "before reset, drive usage looks as follows: "<< endl;
+        dumpsector((const char*)sectors_driveusage);
+#endif  
+        for (i=0;i<totentries;i++) {
+                disablebit(i,sectors_driveusage);
+        }
+#if (HD24FSDEBUG_QUICKFORMAT==1)
+        cout << "after reset, drive usage looks as follows: "<< endl;
+        dumpsector((const char*)sectors_driveusage);
+#endif  
+        
+#if (HD24FSDEBUG==1)
+        cout << "Drive usage table cleared." << endl;
+#endif
+        return sectors_driveusage;
+}
+
+unsigned char* hd24fs::calcsongusage()
+{
+        resetsongusage();
+
+        hd24project* currproj=NULL;
+        __uint32 projcount=projectcount();
+        __uint32 i;
+        __uint32 j;
+        for (i=1; i<=projcount;i++) 
+        {
+                if (currproj!=NULL) 
+                {
+                        delete(currproj);
+                        currproj=NULL;
+                }
+                currproj=getproject(i);
+                if (currproj==NULL) 
+                {
+                        continue;
+                }
+
+                // currproj!=NULL.
+                __uint32 currsongcount=currproj->songcount();
+                for (j=1; j<=currsongcount;j++) 
+                {
+                        // get song sector info.
+                        __uint32 songsector = currproj->getsongsectornum(j);
+                        if (songsector==0) 
+                        {
+                                // song at given entry is not in use 
+                                // in this project, no need to mark it as used.
+                                continue;
+                        }
+
+                        // mark the song used based on its entry number
+                        // (calculated from the sector where it lives)
+                        __uint32 songentry=songsector2entry(songsector);
+                        if (songentry!=INVALID_SONGENTRY) 
+                        {
+                                enablebit(songentry,sectors_songusage);
+                        }
+                }
+
+                if (currproj!=NULL)
+                {
+                        delete(currproj);
+                        currproj=NULL;
+                }
+        }
+        return sectors_songusage;
+}
+
+void hd24fs::refreshsongusage()
+{
+        unsigned char* songusage=calcsongusage();
+        __uint32 sectornum=2; /* TODO: get from fs */
+        __uint32 sectorcount=3; /* TODO: get from fs */
+        fstfix(songusage,sectorcount*512);
+        setsectorchecksum(songusage,
+                0 /* startoffset */,
+                sectornum /* sector */, 
+                sectorcount /*sectorcount */
+        );
+        this->writesectors(this->devhd24,
+                        sectornum,
+                        songusage,
+                        sectorcount);
+        fstfix(songusage,sectorcount*512);
+        
+        /* this also implies we need to update the superblock 
+           with the current song count */
+        __uint32 songcount=0;
+        for (int i=0;i<99*99;i++) {
+                if (!(isbitzero(i,songusage)))
+                {
+                        songcount++;
+                }
+        };
+        songsondisk(songcount);
+        fstfix(sector_boot,512);
+        setsectorchecksum(sector_boot,
+                0 /* startoffset */,
+                0 /* sector */, 
+                1 /*sectorcount */);
+        this->writesectors(this->devhd24,
+                        0,
+                        sector_boot,
+                        1);
+        fstfix(sector_boot,512);
+        return;
+}
+
+unsigned char* hd24fs::getsector_diskinfo() 
+{
+        getsector_bootinfo();
+        unsigned char* targetbuf=sector_diskinfo;
+        if (/*formatting||*/(sector_diskinfo==NULL) )
+        {
+                targetbuf=readdiskinfo();
+        }
+        return sector_diskinfo;
+}
+
+unsigned char* hd24fs::getsector_bootinfo() 
+{
+        unsigned char* targetbuf=sector_boot;
+        if (/*formatting||*/(sector_boot==NULL) )
+        {
+#if (HD24FSDEBUG_QUICKFORMAT==1)
+                cout << "Re-reading bootinfo now." << endl;
+#endif
+                targetbuf=readbootinfo();
+        }
+        return targetbuf;
+}
+
+unsigned char* hd24fs::getsectors_driveusage()
+{
+#if (HD24FSDEBUG_QUICKFORMAT==1)
+        cout << "hd24fs::getsectors_driveusage()" << endl;
+#endif
+        
+        readbootinfo();
+        if (sectors_driveusage==NULL)
+        {
+                sectors_driveusage=readdriveusageinfo();
+        }
+        return sectors_driveusage;
+}
+
+unsigned char* hd24fs::getcopyofusagetable()
+{
+        unsigned char* copyusagetable=(unsigned char*)memutils::mymalloc("copyusagetable",15*512,1);
+        if (copyusagetable==NULL) 
+        {
+                /* Out of memory */
+                return NULL;
+        }
+
+        // copy current drive usage table to a copy;
+        readdriveusageinfo();
+        int i;
+        for (i=0;i<(512*15);i++) {
+                copyusagetable[i]=sectors_driveusage[i];
+        }
+        return copyusagetable;
+}
+
+string* hd24fs::volumename() 
+{       
+        if (!(isOpen())) 
+        {
+                return new string("");
+        }
+        getsector_diskinfo();
+        return Convert::readstring(sector_diskinfo,DRIVEINFO_VOLUME,64);
+}
+
+void hd24fs::setvolumename(string newname)
+{
+        if (sector_diskinfo==NULL)
+        {
+                readdiskinfo();
+        }
+        this->setname(sector_diskinfo,newname,DRIVEINFO_VOLUME_8,DRIVEINFO_VOLUME);
+        return;
+}
+
+unsigned long hd24fs::driveusagesectorcount()
+{
+        if (!(isOpen())) 
+        {       
+                cout << "FS not open!";
+                return 0;
+        }
+#if (HD24FSDEBUG_QUICKFORMAT==1)
+                cout << "Figuring out number of sectors used for drive usage"
+                << endl;
+#endif
+        
+        getsector_bootinfo();
+        return Convert::getint32(sector_boot,FSINFO_NUMSECTORS_DRIVEUSAGE);
+}
+
+unsigned long hd24fs::clustercount()
+{
+        /* 
+           Clustercount=
+                (number of allocatable sectors on disk)/
+                ((sectors per audioblock)*(audioblocks per cluster))
+        */
+        if (!(isOpen())) 
+        {
+                return 0;
+        }
+        getsector_bootinfo();
+        __uint32 allocatablesectorcount=
+            Convert::getint32(sector_boot,FSINFO_ALLOCATABLE_SECTORCOUNT);
+        __uint32 audioblocksize=
+            Convert::getint32(sector_boot,FSINFO_BLOCKSIZE_IN_SECTORS);
+        __uint32 clustersize=
+            Convert::getint32(sector_boot,FSINFO_AUDIOBLOCKS_PER_CLUSTER)
+            *audioblocksize;
+
+        allocatablesectorcount-=(allocatablesectorcount%clustersize);
+        return allocatablesectorcount/clustersize; 
+}
+
+void hd24fs::dumpclusterusage(unsigned char* usagebuffer)
+{
+        if (!(isOpen())) 
+        {
+                return;
+        }
+        __uint32 clusters=clustercount();
+        for (__uint32 i=0;i<clusters;i++) {
+                if (isfreecluster(i,usagebuffer)) {
+                        cout << "0";
+                } else {
+                        cout << "1";
+                }
+        }
+        cout <<endl;
+        return;
+}
+
+void hd24fs::dumpclusterusage2(unsigned char* usagebuffer)
+{
+        __uint32 clusters=clustercount();
+        __uint32 currpos=0;
+        cout << "DumpClusterUsage2" << endl;
+        while (currpos<clusters) {
+                __uint32 blockstart=currpos;
+                while (isfreecluster(blockstart,usagebuffer) && (blockstart<clusters)) {
+                        blockstart++;
+                }
+//              cout << "Block starts at cluster " <<blockstart << endl;
+                if (blockstart==clusters) {
+                        break;
+                }
+
+                // blockstart now points to a nonfree cluster
+                __uint32 blockend=blockstart;
+                while (!isfreecluster(blockend,usagebuffer) && (blockend<clusters)) {
+                        blockend++;
+                }
+                // blockend now points to a free cluster
+                currpos=blockend;
+                __uint32 blocklen=blockend-blockstart;
+                printf("%x %x\n",(unsigned int) cluster2sector(blockstart),(unsigned int)( getblockspercluster()*blocklen ));
+        }       
+}
+
+unsigned long hd24fs::driveusagefirstsector()
+{
+        if (!(isOpen())) 
+        {
+                return 0;
+        }
+        getsector_bootinfo();
+
+        return Convert::getint32(sector_boot,FSINFO_STARTSECTOR_DRIVEUSAGE);
+}
+
+unsigned char* hd24fs::findorphanclusters()
+{
+        if (!(isOpen())) 
+        {
+                return NULL;
+        }
+        __uint32 driveusagecount=driveusagesectorcount();
+        getsectors_driveusage();
+        int numprojs=projectcount();
+
+        if (sectors_orphan==NULL) { 
+                // only allocate once (free on object destruct)
+                sectors_orphan=(unsigned char *)memutils::mymalloc("findorphanclusters",512*(driveusagecount+1),1);
+        }
+        readsectors(devhd24,driveusagefirstsector(),sectors_orphan,driveusagecount);
+        fstfix(sectors_orphan,512*driveusagecount);
+        
+        for (int proj=1; proj<=numprojs; proj++) {
+                hd24project* currproj=this->getproject(proj);
+                int numsongs=currproj->songcount();
+                for (int song=1; song<=numsongs; song++) {
+                        hd24song* currsong=currproj->getsong(song);
+                        if (currsong==NULL) continue;
+                        currsong->unmark_used_clusters(sectors_orphan); 
+                        delete currsong;
+                }
+                if (currproj!=NULL) {
+                        delete currproj;                
+                        currproj=NULL;
+                }
+        }
+        return sectors_orphan;
+}
+
+bool hd24fs::isbitzero(unsigned long i,unsigned char* usagebuffer)
+{
+        int bitnum=i%32;
+        i-=bitnum;
+        i/=32;  // i now is word num
+        i*=4;   // i now is offset
+        __uint32 getword=Convert::getint32(usagebuffer,i);
+        __uint32 mask=1;
+#if (HD24FSDEBUG_BITSET==1)
+        cout << "bitnum=" << bitnum << " ";
+#endif  
+        mask=mask<<bitnum;
+        __uint32 bitval=(getword & mask);
+#if (HD24FSDEBUG_BITSET==1)
+        cout << "bitval=" << bitval << endl;
+#endif
+        if (bitval == 0) return true;
+        return false;
+}
+
+void hd24fs::enablebit(__uint32 ibitnum,unsigned char* usagebuffer) 
+{
+#if (HD24FSDEBUG_BITSET==1)
+        cout << "enable bit " << ibitnum << endl;
+#endif
+        int bitnum=ibitnum%32;
+        ibitnum-=bitnum;
+        ibitnum/=32;    // i now is word num
+        ibitnum*=4;     // i now is byte offset of word
+        __uint32 getword=Convert::getint32(usagebuffer,ibitnum);
+        __uint32 mask=1;
+        mask=mask<<bitnum;
+#if (HD24FSDEBUG_BITSET==1)
+        cout << "getword=" << getword << "mask=" << mask << endl;
+#endif          
+        getword=getword|mask;
+        Convert::setint32(usagebuffer,ibitnum,getword);
+}
+
+void hd24fs::disablebit(__uint32 ibitnum,unsigned char* usagebuffer)
+{
+#if (HD24FSDEBUG_BITSET==1)
+        cout << "disable bit " << ibitnum << endl;
+#endif
+        int bitnum=ibitnum%32;
+        ibitnum-=bitnum;
+        ibitnum/=32;    // i now is word num
+        ibitnum*=4;     // i now is offset
+        __uint32 getword=Convert::getint32(usagebuffer,ibitnum);
+        __uint32 mask=1;
+        mask=mask<<bitnum;
+#if (HD24FSDEBUG_BITSET==1)
+        cout << "getword=" << getword << "mask=" << mask << endl;
+#endif  
+        getword=getword& (0xFFFFFFFF ^ mask);
+#if (HD24FSDEBUG_BITSET==1)
+        cout << "new getword=" << getword << endl;
+#endif          
+        Convert::setint32(usagebuffer,ibitnum,getword);
+}
+
+bool hd24fs::isfreecluster(unsigned long i,unsigned char* usagebuffer) 
+{
+        return isbitzero(i,usagebuffer);
+}
+
+void hd24fs::allocatecluster(__uint32 clusternum,unsigned char* usagebuffer) 
+{
+        enablebit(clusternum,usagebuffer);
+}
+
+void hd24fs::freecluster(__uint32 clusternum,unsigned char* usagebuffer) 
+{
+        disablebit(clusternum,usagebuffer);
+}
+void hd24fs::allocatecluster(__uint32 clusternum) 
+{
+        allocatecluster(clusternum,sectors_driveusage);
+}
+
+void hd24fs::freecluster(__uint32 clusternum) 
+{
+        freecluster(clusternum,sectors_driveusage);
+}
+
+unsigned long hd24fs::freeclustercount() 
+{
+        if (!(isOpen())) 
+        {
+                return 0;
+        }
+#if (HD24FSDEBUG_QUICKFORMAT==1)
+                cout << "hd24fs::freeclustercount()" << endl;
+#endif
+        
+        sectors_driveusage=getsectors_driveusage();
+        
+        if (sectors_driveusage==NULL) 
+        {
+                return 0; // cannot get driveusage sectors, 0 clusters free.
+        }
+        unsigned long i=0;
+        __uint32 fsc=driveusagesectorcount();
+        
+        if (fsc>0xFF) return 0;
+#if (HD24FSDEBUG_QUICKFORMAT==1)
+                cout << "Sectors used for drive usage=" << fsc << endl;
+#endif
+        __uint32 clusters=((fsc /*sectors of alloc info*/ 
+                                       *512 /*bytes*/)
+                                       -8 /* checksum bytes */)
+                                        *8 /* bits per byte */;
+        //unsigned long clusters=((512*fsc-1)+504)*8;
+#if (HD24FSDEBUG_QUICKFORMAT==1)
+                cout << "Total clusters=" << clusters << endl;
+#endif
+        
+        unsigned long freeclusters=0;
+        for (i=0;i<clusters;i++) {
+                if (isfreecluster(i,sectors_driveusage)) 
+                {
+#if (HD24FSDEBUG_QUICKFORMAT==1)
+                cout << "Cluster " << i << " is free" << endl;
+#endif                  
+                        freeclusters++;
+                }
+        }
+        return freeclusters;
+}
+
+string* hd24fs::freespace(unsigned long rate,unsigned long tracks) 
+{
+        if (!(isOpen())) 
+        {
+                return new string("");
+        }
+
+        unsigned long freeclusters=freeclustercount();
+#if (HD24FSDEBUG_QUICKFORMAT==1)        
+        cout << "free clusters=" << freeclusters << endl;
+#endif  
+        __uint64 freesectors=freeclusters*getblocksizeinsectors()*getblockspercluster();
+#if (HD24FSDEBUG_QUICKFORMAT==1)        
+        cout << "free sectors=" << freesectors << endl;
+#endif  
+        __uint64 freebytes=freesectors*SECTORSIZE;
+#if (HD24FSDEBUG_QUICKFORMAT==1)        
+        cout << "free bytes=" << freesectors << endl;
+#endif  
+        __uint64 freesamples=(__uint64)(freebytes/3);
+#if (HD24FSDEBUG_QUICKFORMAT==1)
+        cout << "free samples=" << freesamples << endl;
+#endif
+        __uint64 freeseconds=(__uint64)(freesamples/rate/tracks);
+        unsigned long freehours=(freeseconds-(freeseconds%3600))/3600;
+        freeseconds-=(freehours*3600);
+        unsigned long freeminutes=(freeseconds-(freeseconds%60))/60;
+        freeseconds-=(freeminutes*60);
+        string* newst=Convert::int2str(freehours);
+        *newst+=" hr ";
+        string* freemins=Convert::int2str(freeminutes,2,"0");
+        *newst+=*freemins;
+        delete freemins;
+        *newst+=" min ";
+        string* freesecs=Convert::int2str(freeseconds,2,"0");
+        *newst+=*freesecs;
+        delete freesecs;
+        *newst+=" sec ";
+        return newst; // throw exception?
+}
+
+string* hd24fs::version() 
+{
+        if (!(isOpen())) 
+        {
+                return new string("");
+        }
+        getsector_bootinfo();
+        string* newst=Convert::readstring(sector_boot,FSINFO_VERSION_MAJOR,1);
+        *newst+=".";
+        string* dummy=Convert::readstring(sector_boot,FSINFO_VERSION_MINOR,2);
+        *newst+=*dummy;
+        delete dummy;
+        return newst;
+}
+
+unsigned long hd24fs::maxprojects() 
+{
+        if (!(isOpen())) 
+        {
+                return 0;
+        }
+        getsector_bootinfo();
+        unsigned long maxprojs=Convert::getint32(sector_boot,FSINFO_MAXPROJECTS);
+        if (maxprojs>99) {
+                maxprojs=99; 
+                /* safety feature while no larger project
+                   counts are known to be valid; gives 
+                   more stability when working with corrupt drives */
+                this->writeprotected=true;
+        }
+        return maxprojs;
+}
+
+unsigned long hd24fs::getblocksizeinsectors() 
+{
+        if (!(isOpen())) 
+        {
+                return 0;
+        }
+        getsector_bootinfo();
+        if (forcemode) {
+                return 0x480;
+        }
+        unsigned long blocksize=Convert::getint32(sector_boot,FSINFO_BLOCKSIZE_IN_SECTORS);
+        if (blocksize!=0x480)
+        {
+                this->writeprotected=true;
+        }
+        return blocksize;
+}
+
+unsigned long hd24fs::getbytesperaudioblock()
+{
+        return getblocksizeinsectors()*512;
+}
+
+unsigned long hd24fs::getblockspercluster() 
+{
+        if (!(isOpen())) 
+        {
+                return 0;
+        }
+        getsector_bootinfo();
+        unsigned long maxprojs=Convert::getint32(sector_boot,FSINFO_AUDIOBLOCKS_PER_CLUSTER);
+        return maxprojs;
+}
+
+unsigned long hd24fs::maxsongsperproject() 
+{
+        if (!(isOpen())) 
+        {
+                return 0;
+        }
+        getsector_bootinfo();
+        unsigned long maxsongs=Convert::getint32(sector_boot,FSINFO_MAXSONGSPERPROJECT);
+        return maxsongs;
+}
+
+__uint32 hd24fs::getprojectsectornum(__uint32 i) 
+{
+#if (HD24FSDEBUG==1)
+        cout << "hd24fs::getprojectsectornum("<<i<<")"<< endl;
+#endif
+        // 1-based project sectornum
+        if (!(isOpen())) 
+        {
+                return 0;
+        }
+        if (i<1)
+        {
+                return 0;
+        }
+        if (i>maxprojects())
+        {
+                return 0;
+        }
+        getsector_diskinfo();
+        unsigned long projsec=Convert::getint32(sector_diskinfo,        
+                        DRIVEINFO_PROJECTLIST+((i-1)*4));
+        
+#if (HD24FSDEBUG==1)
+        cout << "projsec = " << projsec << endl;
+#endif
+        return projsec;
+}
+
+void hd24fs::lastprojectid(signed long projectid)
+{
+        if (!(isOpen())) 
+        {
+                return;
+        }
+        getsector_diskinfo();
+        __uint32 lastprojsec=getprojectsectornum(projectid);
+        if (lastprojsec==0) {
+                return;
+        }
+        if (projectid==lastprojectid())
+        {
+                // nothing changed- nothing to save
+                return;
+        }
+
+        Convert::setint32(sector_diskinfo,DRIVEINFO_LASTPROJ,lastprojsec);
+        savedriveinfo();
+        return;
+}
+
+signed long hd24fs::lastprojectid() 
+{
+        if (!(isOpen())) 
+        {
+                return -1;
+        }
+        getsector_diskinfo();
+        unsigned long lastprojsec=Convert::getint32(sector_diskinfo,DRIVEINFO_LASTPROJ);
+        if (lastprojsec==0) {
+                // TODO: This differs from the real HD24 where even
+                // on a freshly formatted drive there always is at least
+                // one project.
+                return -1;
+        }
+        int i;
+        int maxprojs=maxprojects();
+        for (i=1;i<=maxprojs;i++) 
+        {
+                unsigned long projsec=getprojectsectornum(i);
+
+                if (projsec==lastprojsec) 
+                {
+                        return i;
+                }
+        }
+        // no default project. hm......
+        if (maxprojs>=1) {
+                return 1;
+        }
+        return -1;
+}
+
+__uint32 hd24fs::getunusedsongsector()
+{
+        if (!(isOpen())) 
+        {
+                return 0; // return 0- this is an invalid songsector
+                          // so error is detectable
+        }
+
+        // generate an up-to-date song usage table.
+        unsigned char* songusage=calcsongusage();
+
+        int currsongentry=0;
+        signed long foundentry=-1;
+        int maxprojs=this->maxprojects();
+        int maxsongcount=this->maxsongsperproject();
+        int totentries=maxprojs*maxsongcount; // 99 songs, 99 projects
+        while (currsongentry<totentries) // 99 sec, 99 proj
+        {
+                if (isbitzero(currsongentry,songusage)) {
+                        foundentry=currsongentry;
+                        break;
+                }
+                currsongentry++;
+        }
+        if (foundentry==-1)
+        {
+                return 0;
+        }
+        return songentry2sector(foundentry);
+}
+
+void hd24fs::allocsongentry(unsigned long songentry) 
+{
+        enablebit(songentry,sectors_songusage);
+}
+
+unsigned long hd24fs::projectcount() 
+{
+        if (!(isOpen())) 
+        {
+                return 0;
+        }
+        getsector_diskinfo();
+        unsigned long lastprojsec=Convert::getint32(sector_diskinfo,DRIVEINFO_LASTPROJ);
+        if (lastprojsec==0) 
+        {
+                return 0;
+        }
+        __uint32 projcount=Convert::getint32(sector_diskinfo,DRIVEINFO_PROJECTCOUNT);
+        if (projcount>maxprojects()) return maxprojects();
+
+        return projcount;
+}
+
+int hd24fs::mode() {
+        return p_mode;
+}
+        
+hd24project* hd24fs::getproject(__sint32 projectid) 
+{
+        __uint32 projsec=getprojectsectornum(projectid); // 1-based
+        if (projsec==0) {
+                return NULL;
+        }
+        return new hd24project(this,projectid);
+}
+
+hd24project* hd24fs::createproject(const char* projectname)
+{
+#if (HD24FSDEBUG==1)
+        cout << "hd24fs::createproject(" << projectname << ")" << endl;
+//      cout << "Driveusage before createproject=" << (int)(this->sectors_driveusage) << endl;
+#endif
+        /* This creates a new project (with given project name)
+           on the drive (if possible).
+           NULL is returned when unsuccessful, a pointer to the
+           project otherwise.
+        */
+#if (HD24FSDEBUG==1) 
+        cout << "hd24fs asked to create project " << projectname << endl;
+#endif
+        int i;
+        // find first project with project sector num 0!
+        int maxprojs=maxprojects();
+
+        getsector_bootinfo();
+        if (sector_boot==NULL) {
+                // unknown cluster size.
+                return 0;
+        }
+        __uint32 firstprojsec=Convert::getint32(sector_boot,FSINFO_FIRST_PROJECT_SECTOR);
+        cout << "Firstprojsec="<< firstprojsec << endl;
+        __uint32 secsperproj=Convert::getint32(sector_boot,FSINFO_SECTORS_PER_PROJECT);
+        cout << "Sectors per project="<< secsperproj << endl;
+
+        // Let's calculate a list of unused project sectors
+        char* projused=(char*)memutils::mymalloc("createproject",maxprojs,1);
+        if (projused==NULL) {
+                return 0; // out of memory
+        }
+
+        for (i=0;i<maxprojs;i++) {
+                projused[i]=0;
+        }
+
+        for (i=1;i<=maxprojs;i++) { 
+                __uint32 projsec=getprojectsectornum(i); // 1-based
+                if (projsec!=0)
+                {
+                        /* projects do not necessarily have to  
+                           be stored on disk in the same order 
+                           as their project numbers- 
+                           so project 1 can be at sector 0x15
+                           while project 2 is at sector 0x14.
+                           This is why we have to convert project 
+                           sector to project slot. The cast to int
+                           makes sure we don't accidentally end up
+                           with a float index that can be misinterpreted. */
+                        projused[(int)((projsec-firstprojsec)/secsperproj)]=1;
+                }
+        }
+
+        int foundslotnum=0;
+        for (i=1;i<=maxprojs;i++) 
+        {
+                __uint32 projsec=getprojectsectornum(i); // 1-based
+
+                if (projsec==0) 
+                {
+                        foundslotnum=i;
+                        break;
+                }
+        }
+        
+        // Now find an unused project sector
+        __uint32 foundsecnum=0;
+        for (i=0;i<maxprojs;i++) {
+                if (projused[i]==0) {
+                        foundsecnum=(i*secsperproj)+firstprojsec;
+                        break;
+                }
+        }
+        memutils::myfree("projused",projused);
+
+        if (foundslotnum==0) 
+        {
+                // no unused slots.
+                return NULL;
+        }
+        __uint32 projectid=foundslotnum;
+        foundslotnum--; // use 0-based slot num
+
+        if (foundsecnum==0) {
+                // no unsused project sectors found.
+                // This is seriously fishy as there *are*
+                // unused slots- so that should never happen.
+                // Looks like we're dealing with a corrupt FS!
+                this->writeprotected=true;
+                return NULL;                    
+        }
+        // Now to assign the first unused project sector 
+        // to the first unused project slot.
+
+        // First, update the drive info.
+        getsector_diskinfo();
+
+        // Add the new project pointer to the disk info:
+        Convert::setint32(sector_diskinfo,DRIVEINFO_PROJECTLIST+(foundslotnum*4),foundsecnum);
+        Convert::setint32(sector_diskinfo,DRIVEINFO_LASTPROJ,foundsecnum);
+
+        Convert::setint32(sector_diskinfo,DRIVEINFO_PROJECTCOUNT,
+        Convert::getint32(sector_diskinfo,DRIVEINFO_PROJECTCOUNT)+1);
+
+        bool isnew=true;
+        hd24project* newproject=new hd24project(this,projectid,foundsecnum,projectname,isnew);
+        savedriveinfo();
+
+        return newproject;
+}
+
+bool hd24fs::isallinput()
+{
+        return this->allinput;
+}
+
+void hd24fs::setallinput(bool p_allinput)
+{
+        this->allinput=p_allinput;
+}
+
+void hd24fs::setallinput(void)
+{
+        this->setallinput(true);
+}
+
+/* These three functions are for the 'auto input' button
+   (having to do with automatic toggling of monitoring 
+    between 'tape' and inputs during a punch in */
+bool hd24fs::isautoinput()
+{
+        return this->autoinput;
+}
+
+void hd24fs::setautoinput(bool p_autoinput)
+{
+        this->autoinput=p_autoinput;
+}
+
+void hd24fs::setautoinput(void)
+{
+        this->setautoinput(true);
+}
+
+void hd24fs::writebackupblock(__uint32 p_sector,__uint32 p_blocksize,
+                              __uint32 lastsec,bool fullcommit)
+{
+        /** Used by commit. This writes a logical block 
+            of file system data to the end of the drive. */
+        unsigned char backbuf[1024];
+
+        __uint32 i;
+        __uint32 blocksize=p_blocksize;
+        
+        if (fullcommit==false)
+        {
+                // we're doing a quick commit, so only backup
+                // changed blocks.
+                if (p_sector>highestFSsectorwritten) return;
+        }
+        
+        for (i=1;i<=blocksize;i++) {
+                // read sector $sector+$i-1
+                // write to sector -($sector+1+$blocksize-$i)
+                //      (where -1= last sector)
+                __uint32 currentsourcesector=p_sector+(i-1);
+                
+                readsector_noheader(this, currentsourcesector, backbuf);                
+                __uint32 targetsector=(lastsec-(p_sector+1+blocksize-i))+1;
+        //      cout << "write sec " << targetsector << endl;
+                writesector(this->devhd24,targetsector,backbuf);
+        }
+}
+
+bool hd24fs::commit()
+{
+        // default commit is a quick commit rather than full commit.
+        // A quick commit only commits sectors up to the last project/song
+        // sector changed.
+        return this->commit(false);
+}
+bool hd24fs::commit(bool fullcommit)
+{
+        /** This creates a backup of the file system to the end of the drive. */
+        
+        
+#if (HD24FSDEBUG==1)
+        cout << "hd24fs::commit()" << endl;
+//      cout << "Driveusage before commit=" << (int)(this->sectors_driveusage) << endl;
+#endif
+        if (this->headersectors!=0)
+        {
+                // ehm. Obviously we're not going to overwrite the
+                // end of the drive with header file information,
+                // as that would defeat the purpose of header files
+                // (which is to allow safe read-only operation).
+                return true;
+        };
+        __uint32 sector=0;
+        __uint32 blocksize=1;
+        __uint32 count=1;
+        __uint32 lastsec=getlastsectornum();
+        writebackupblock(sector,blocksize,lastsec,fullcommit); // backup superblock
+
+        sector+=(blocksize*count);
+        blocksize=1;
+        count=1;
+
+        writebackupblock(sector,blocksize,lastsec,fullcommit); // backup drive info
+
+        sector+=(blocksize*count);
+        blocksize=3;
+        count=1;
+        writebackupblock(sector,blocksize,lastsec,fullcommit); // Backup undo (?) usage
+
+        sector+=(blocksize*count);
+        blocksize=15;
+        count=1;
+        writebackupblock(sector,blocksize,lastsec,fullcommit); // Backup drive usage table
+
+        sector+=(blocksize*count);
+        blocksize=1;
+        count=99;
+
+        __uint32 i;
+        for (i=1;i<=count;i++) 
+        {
+#if (HD24FSDEBUG_COMMIT==1)
+        cout <<"Going to write proj backup block no. " << i << endl;
+#endif
+                writebackupblock(sector+(i-1),blocksize,lastsec,fullcommit); // Backup project 
+        }
+
+        sector+=(blocksize*count);
+        count=99*99;
+        for (i=1;i<=count;i++) 
+        {
+#if (HD24FSDEBUG_COMMIT==1)
+        cout <<"Going to write song backup block no. " << i << endl;
+#endif
+                blocksize=2;
+                writebackupblock(sector+(7*(i-1)),blocksize,lastsec,fullcommit); // Backup song
+
+                blocksize=5;
+                writebackupblock(sector+(7*(i-1))+2,blocksize,lastsec,fullcommit); // Backup song alloc info
+        }
+#if (HD24FSDEBUG_COMMIT==1)
+        cout <<"Wrote backup blocks" << endl;
+        cout << "Driveusage after commit=" << (int)(this->sectors_driveusage) << endl;
+#endif
+        highestFSsectorwritten=0; // reset 
+        return true;
+}
+
+long unsigned int hd24fs::setsectorchecksum(unsigned char* buffer,unsigned int startoffset,unsigned int startsector,unsigned int sectors)
+{
+        // Calculates and sets the checksum for a block of data.
+        // Data must be in drive-native format.
+        long unsigned int checksum32 = 0;
+        unsigned long int totbytes=(SECTORSIZE*sectors);
+
+        buffer[startoffset+totbytes-8]=startsector%256;
+        buffer[startoffset+totbytes-7]=(startsector>>8)%256;
+        buffer[startoffset+totbytes-6]=255-     buffer[startoffset+totbytes-8];
+        buffer[startoffset+totbytes-5]=255-     buffer[startoffset+totbytes-7];
+
+        for (unsigned long i = 0; i < totbytes; i += 4) 
+        {
+                unsigned long num = Convert::getint32(buffer, i+startoffset);
+                int byte1 = num % 256;
+                int byte2 = (num >> 8) % 256;
+                int byte3 = (num >> 16) % 256;
+                int byte4 = (num >> 24) % 256;
+                num = byte4 + (byte3 << 8) + (byte2 << 16) + (byte1 << 24);
+                checksum32 += num;
+        }
+        unsigned long oldchecksum=0;
+        oldchecksum+=((unsigned char)(buffer[startoffset+totbytes-1])); oldchecksum=oldchecksum <<8;
+        oldchecksum+=((unsigned char)(buffer[startoffset+totbytes-2])); oldchecksum=oldchecksum <<8;
+        oldchecksum+=((unsigned char)(buffer[startoffset+totbytes-3])); oldchecksum=oldchecksum <<8;
+        oldchecksum+=((unsigned char)(buffer[startoffset+totbytes-4])); 
+        oldchecksum-=checksum32;
+        buffer[startoffset+totbytes-4]=oldchecksum%256; oldchecksum=oldchecksum >> 8;
+        buffer[startoffset+totbytes-3]=oldchecksum%256; oldchecksum=oldchecksum >> 8;
+        buffer[startoffset+totbytes-2]=oldchecksum%256; oldchecksum=oldchecksum >> 8;
+        buffer[startoffset+totbytes-1]=oldchecksum%256; oldchecksum=oldchecksum >> 8;
+        return checksum32;
+}
+
+void hd24fs::savedriveinfo()
+{
+        // This is capable of handling only 1-sector-per-project projects
+        __uint32 driveinfosector=1;
+        if (sector_diskinfo==NULL)
+        {
+                // diskinfo is not available, nothing to do.
+                return;
+        }
+#if (HD24FSDEBUG==1)
+        cout << "FSTFIX" << endl;
+#endif  
+        this->fstfix(sector_diskinfo,512); // sector is now once again in native format
+
+#if (HD24FSDEBUG==1)
+        cout << "set checksum" << endl;
+#endif  
+        this->setsectorchecksum(sector_diskinfo,0,driveinfosector,1);     
+#if (HD24FSDEBUG==1)
+        cout << "write sectors" << endl;
+#endif  
+        this->writesectors(this->devhd24,
+                        driveinfosector,
+                        sector_diskinfo,1);
+        
+#if (HD24FSDEBUG==1)
+        cout << "unfix" << endl;
+#endif  
+        this->fstfix(sector_diskinfo,512); // sector is now in 'fixed' format
+#if (HD24FSDEBUG==1)
+        cout << "commit" << endl;
+#endif  
+        this->commit();
+}
+
+void hd24fs::setname(unsigned char* namebuf,string newname,__uint32 shortnameoff,__uint32 longnameoff)
+{
+        /** Used for setting song/project/drive names 
+            Long name is up to 64 characters; short name 
+            is up to 10 chars.
+        */
+#if (HD24FSDEBUG==1)
+        cout    << "hd24fs::setname("
+                << "*namebuf=" << *namebuf << ","
+                << "newname=" << newname << ","
+                << "shortnameoff="<<shortnameoff << ","
+                << "longnameoff=" << longnameoff <<");" << endl;
+#endif          
+        bool foundzero=false;
+        for (__uint32 i=0;i<64;i++) 
+        {
+                if (!foundzero) 
+                {
+                        namebuf[longnameoff+i]=newname.c_str()[i];
+                        if (namebuf[longnameoff+i]==0) {
+                                foundzero=true;
+#if (HD24FSDEBUG==1)
+                                cout << "Found zero at " << i << endl;
+#endif
+                        }
+                }
+                else 
+                {
+                        namebuf[longnameoff+i]=0;
+                }
+        }
+        // Now set FST 1.0 short name
+        unsigned char* target=namebuf+shortnameoff;     
+        foundzero=false;
+        __uint32 count=0;
+        for (__uint32 i=0;i<10;i++) 
+        {
+                if (!foundzero)
+                {
+                        target[count]=newname.c_str()[i];
+                        if (target[count]==0)   
+                        {
+                                foundzero=true;
+                        }
+                }
+                else
+                {
+                        target[count]=0x20; /* short name is filled out
+                                               with spaces */
+                                        
+                }
+                count++;
+                if (count==8) 
+                {
+                        count=0;
+                        target+=10;
+                }
+        }
+        return;
+}
+
+void hd24fs::savedriveusage()
+{
+        __uint32 driveusagesector=5;
+        __uint32 totsectors=15;
+        this->fstfix(sectors_driveusage,totsectors*512); // sector is now once again in native format
+
+        this->setsectorchecksum(sectors_driveusage,0,driveusagesector,totsectors);
+        this->writesectors(this->devhd24,
+                        driveusagesector,
+                        sectors_driveusage,totsectors);
+        
+        this->fstfix(sectors_driveusage,totsectors*512); // sector is now in 'fixed' format
+#if (HD24FSDEBUG==1)
+        cout << "free cluster count=" << freeclustercount() << endl;
+#endif
+        unsigned char* bootrec=readbootinfo();
+        // update FSINFO_FREE_CLUSTERS_ON_DISK  
+        
+        Convert::setint32(bootrec,FSINFO_FREE_CLUSTERS_ON_DISK,freeclustercount());
+        fstfix(bootrec,512); // convert back into native format
+
+        /* Calculate the proper checksum for the bootinfo */
+        setsectorchecksum(bootrec,
+                0 /* startoffset */,
+                0 /* sector */, 
+                1 /*sectorcount */
+        );
+        this->writesectors(this->devhd24, 0,bootrec,1);
+        fstfix(bootrec,512); // convert back into fixed format
+        this->commit();
+}
+
+
+__uint32 hd24fs::writesuperblock(__uint32 lastsec)
+{
+        // writes a new superblock to an unformatted drive.
+        //
+        // normal start of data area=1397f6
+        // size of 1 audio block=0x480 sectors
+        // fs size=0x77+7*99
+        // so minimum usable drive is 0x1397f6+0x480+(0x77+(7*99*99))
+        // =0x14a8ec sectors
+        if (lastsec<0x14a8ec)
+        {
+                // drive is smaller than the minimum needed for 
+                // storing at least 1 audio block.
+                return RESULT_FAIL;
+        }
+        unsigned char superblock[512];
+        useinternalboot(superblock,lastsec); // this automatically sets sector checksum
+        writesectors(this->devhd24,0,&superblock[0],1);
+#if (HD24FSDEBUG_QUICKFORMAT==1)        
+
+        cout << "Writing superblock." << endl;
+        dumpsector((const char*)superblock);
+
+#endif
+
+        force_reload();
+
+        readbootinfo();
+        
+#if (HD24FSDEBUG_CLUSTERddCALC==1)      
+        cout << "Displaying sector after reload." << endl;
+        dumpsector((const char*)sector_boot);
+#endif
+
+        return RESULT_SUCCESS;
+}
+
+void hd24fs::force_reload()
+{
+#if (HD24FSDEBUG==1)
+        cout << "Free superblock mem" << endl;
+#endif
+        if (sector_boot!=NULL)
+        {
+                memutils::myfree("sectors_boot",sector_boot);
+                sector_boot=NULL;
+        }
+#if (HD24FSDEBUG==1)
+        cout << "Free diskinfo mem" << endl;
+#endif
+        if (sector_diskinfo!=NULL) 
+        {
+                memutils::myfree("sectors_diskinfo",sector_diskinfo);
+                sector_diskinfo=NULL;
+        }
+#if (HD24FSDEBUG==1)
+        cout << "Free drive usage mem" << endl;
+#endif
+        if (sectors_driveusage!=NULL)
+        {
+                memutils::myfree("sectors_driveusage",sectors_driveusage);
+                sectors_driveusage=NULL;
+        }
+#if (HD24FSDEBUG==1)
+        cout << "Free orphan sectors mem" << endl;
+#endif
+        if (sectors_orphan!=NULL)
+        {
+                memutils::myfree("sectors_orphan",sectors_orphan);
+                sectors_orphan=NULL;
+        }
+#if (HD24FSDEBUG==1)
+        cout << "Free song usage sectors mem" << endl;
+#endif
+        if (sectors_songusage!=NULL)
+        {
+                memutils::myfree("sectors_songusage",sectors_songusage);
+                sectors_songusage=NULL;
+        };
+                
+}
+__uint32 hd24fs::writedriveinfo()
+{
+        readdiskinfo();
+        cleardriveinfo(sector_diskinfo);
+        fstfix(sector_diskinfo,512); // back into native format
+        writesectors(this->devhd24,1,sector_diskinfo,1);
+        if (sector_diskinfo!=NULL) {
+                memutils::myfree("sector_diskinfo",sector_diskinfo);
+                sector_diskinfo=NULL; // force re-read
+        }
+        hd24project* firstproject=createproject("Proj Name");
+        memutils::myfree("firstproject",firstproject);
+        
+        if (sector_diskinfo!=NULL) {
+                memutils::myfree("sector_diskinfo",sector_diskinfo);
+                sector_diskinfo=NULL; // force re-read
+        }
+        __uint32 psec=getprojectsectornum(1);
+        if (sector_diskinfo!=NULL) {
+                memutils::myfree("sector_diskinfo",sector_diskinfo);
+                sector_diskinfo=NULL; // force re-read
+        }
+        readdiskinfo();
+        Convert::setint32(sector_diskinfo,DRIVEINFO_LASTPROJ,psec);
+        savedriveinfo();
+        
+        return RESULT_SUCCESS;
+}
+
+__uint32 hd24fs::writesongusage()
+{
+        unsigned char* buffer=resetsongusage();
+        if (buffer==NULL)
+        {
+                return RESULT_FAIL;
+        }
+        __uint32 sectornum=2; 
+        __uint32 sectorcount=3; 
+        fstfix(buffer,sectorcount*512);
+        setsectorchecksum(buffer,
+                0 /* startoffset */,
+                sectornum /* sector */, 
+                sectorcount /*sectorcount */
+        );
+        this->writesectors(this->devhd24,
+                        sectornum,
+                        buffer,
+                        sectorcount);
+        fstfix(buffer,sectorcount*512);
+        return RESULT_SUCCESS;
+}
+
+__uint32 hd24fs::writedriveusage()
+{
+        if (sectors_driveusage!=NULL)
+        {
+                memutils::myfree("sectors_driveusage",sectors_driveusage);
+                sectors_driveusage=NULL;
+        }
+        
+        unsigned char* buffer=resetdriveusage();
+        if (buffer==NULL)
+        {
+                return RESULT_FAIL;
+        }
+        __uint32 sectornum=5; 
+        __uint32 sectorcount=15; 
+        fstfix(buffer,sectorcount*512);
+        setsectorchecksum(buffer,
+                0 /* startoffset */,
+                sectornum /* sector */, 
+                sectorcount /*sectorcount */
+        );
+
+        this->writesectors(this->devhd24,
+                        sectornum,
+                        buffer,
+                        sectorcount);
+        fstfix(buffer,sectorcount*512);
+        
+        return RESULT_SUCCESS;
+}
+
+__uint32 hd24fs::quickformat(char* message)
+{
+        // This procedure performs a quickformat on the current drive.
+        // There is no need for the drive to be a valid HD24 drive
+        // for this to work.
+        // Safety confirmations etc. are considered to be the
+        // responsibility of the caller.
+        
+        gotlastsectornum=false; // force re-finding last sector num
+        __uint32 lastsec=getlastsectornum();
+        
+        formatting=true;
+        
+        if (lastsec==0)
+        {
+                if (message!=NULL) strcpy(message,(const char*)&"Lastsec=0");
+                return 0;
+        }
+        __uint32 result=writesuperblock(lastsec);
+
+        if (result==RESULT_FAIL)
+        {
+                if (message!=NULL) strcpy(message,(const char*)&"Write superblock failed");
+                return 0; // lastsec 0 means failed format
+        }
+
+        result=writedriveinfo();
+        if (result==RESULT_FAIL)
+        {
+                if (message!=NULL) strcpy(message,(const char*)&"Write driveinfo failed");
+                return 0; // lastsec 0 means failed format
+        }
+
+        result=writesongusage();
+        if (result==RESULT_FAIL)
+        {
+                if (message!=NULL) strcpy(message,(const char*)&"Write song usage failed");
+                return 0; // lastsec 0 means failed format
+        }
+
+        result=writedriveusage();
+        if (result==RESULT_FAIL)
+        {
+                if (message!=NULL) strcpy(message,(const char*)&"Write drive usage failed");
+                return 0; // lastsec 0 means failed format
+        }
+
+        // write empty song-entry usage table
+        // write empty drive usage table
+        // write 99 empty projects
+        // create default project
+        // (write 99*99 empty songs)
+        // (empty audio space)
+        // commit fs
+        commit();
+        formatting=false;
+        force_reload();
+        return lastsec;
+}
+
+void hd24fs::setprojectsectornum(int i,__uint32 sector) 
+{
+        getsector_diskinfo();
+        Convert::setint32(sector_diskinfo, 
+                DRIVEINFO_PROJECTLIST + ((i - 1) * 4),sector);
+                
+        return;
+}
+
+__uint32 hd24fs::deleteproject(__sint32 projid) 
+{
+        if (projid<1) 
+        {
+                /* Illegal project id;
+                   project IDs are set in base 1. */
+                return RESULT_FAIL;
+        }
+
+        getsector_diskinfo(); // has list of pointers to project sectors
+        __uint32 pcount = Convert::getint32(sector_diskinfo, DRIVEINFO_PROJECTCOUNT);
+
+        if (pcount<=1)
+        {
+                /* Attempt to delete last project on drive- 
+                   not allowed, a drive must always contain
+                   at least 1 project */
+                return RESULT_FAIL;
+        }
+
+        hd24project* projtodel=this->getproject(projid);
+        if (projtodel==NULL) {
+                return RESULT_FAIL;
+        }
+
+        /* If there still all songs in the project, delete them */
+        __uint32 currsongcount=projtodel->songcount();
+        if (currsongcount>0)
+        {
+                for (__uint32 j=1; j<=currsongcount;j++) 
+                {
+                        projtodel->deletesong(1); // songs will shift
+                        projtodel->save();
+                }
+        }
+
+        /* delete project from project list by shifting left
+           all other projects... */
+        if (projid<99)
+        {
+                /* When project 99 is deleted no shifting is needed */
+                for (__uint32 i=projid;i<99;i++) 
+                {
+                        setprojectsectornum(i,getprojectsectornum(i+1));
+                }
+        }
+
+        setprojectsectornum(99,0); // ...and clearing the last entry.
+
+        Convert::setint32(sector_diskinfo,DRIVEINFO_PROJECTCOUNT,pcount-1);
+
+        /* Set 'last accessed project' to first in list 
+           (the project being deleted needs to be accessed 
+            prior to deletion so this must always be updated)
+        */
+        Convert::setint32(sector_diskinfo, DRIVEINFO_LASTPROJECT,getprojectsectornum(1));
+#if (HD24FSDEBUG==1)
+        cout << "save project." << endl;
+#endif
+
+        savedriveinfo();
+        delete projtodel;
+        return RESULT_SUCCESS;
+}
+
+void hd24fs::write_enable()
+{
+        this->writeprotected=false;
+}
+
+void hd24fs::write_disable()
+{
+        this->writeprotected=true;
+}
+