1 files changed, 477 insertions, 0 deletions

diff --git a/src/lib/hd24project.cpp b/src/lib/hd24project.cpp
new file mode 100755
index 0000000..1111003
--- /dev/null
+++ b/src/lib/hd24project.cpp
@@ -0,0 +1,477 @@
+#define PROJDEBUG 0
+#define PROJINFO_PROJECTNAME_8 0x0
+#define PROJINFO_SONGCOUNT 0x0c
+#define PROJINFO_LASTSONG 0x10
+#define PROJINFO_SONGLIST 0x20
+#define PROJINFO_PROJECTNAME 0x1b8
+#define INVALID_SONGENTRY 0xFFFFFFFF
+#define RESULT_SUCCESS 0
+#define RESULT_FAIL 1
+#include <hd24utils.h>
+#include "memutils.h"
+void hd24project::initvars(hd24fs* p_parent,__sint32 p_myprojectid)
+{
+        this->myprojectid=p_myprojectid;
+        this->parentfs = p_parent;
+        return;
+}
+
+__sint32 hd24project::projectid()
+{
+        return this->myprojectid;
+}
+
+hd24project::hd24project(hd24fs* p_parent, __sint32 p_myprojectid,
+                        __uint32 p_projectsector, const char* p_projectname,
+                        bool isnew) 
+{
+#if (PROJDEBUG == 1) 
+        cout << "CONSTRUCT hd24project " << p_myprojectid << endl;
+#endif
+        // initialize a new project.
+        // Boolean is obligatory to prevent accidents;
+        // one can still create a project and not save it immediately.
+        this->myprojectid = p_myprojectid;
+        buffer = (unsigned char*)memutils::mymalloc("hd24project(1)",1024,1);
+        parentfs = p_parent;
+        if (!isnew) {
+                p_parent->readsector(p_parent->devhd24,
+                        p_parent->getprojectsectornum(myprojectid),
+                        buffer); // fstfix follows
+                        
+                p_parent->fstfix(buffer, 512);
+                projectname(p_projectname);
+        } else {
+#if (PROJDEBUG == 1) 
+                cout << "Create new project " <<projectname << " with id "
+                     << p_myprojectid << " on sec " <<p_projectsector << endl;
+#endif
+
+                for (int i=0;i<1024;i++) {
+                        buffer[i]=0;
+                }
+                projectname(p_projectname);
+                this->save(p_projectsector);            
+        }
+}
+
+hd24project::hd24project(hd24fs* p_parent, __sint32 p_myprojectid) 
+{
+        // project id is 1-based
+#if (PROJDEBUG == 1) 
+        cout << "Here we are. time to create the project object for proj. "
+        << p_myprojectid << endl;
+#endif
+        this->myprojectid = p_myprojectid;
+        buffer = (unsigned char*)memutils::mymalloc("hd24project(2)",1024,1);
+        if (buffer==NULL) {
+                return;
+        }
+        parentfs = p_parent;
+        __uint32 projsecnum=p_parent->getprojectsectornum(myprojectid);
+        if (projsecnum==0) {
+                for (int i=0;i<512;i++) {
+                        buffer[i]=0;
+                }
+        } else {
+                p_parent->readsector(p_parent->devhd24,
+                        projsecnum,
+                        buffer); // fstfix follows
+                        
+                p_parent->fstfix(buffer, 512);
+                //this->sort();
+        }
+
+}
+
+hd24project::~hd24project() 
+{
+#if (PROJDEBUG == 1) 
+        cout << "DESTRUCT hd24project " << myprojectid << endl;
+#endif
+        if (buffer != NULL) memutils::myfree("hd24project::buffer",buffer);
+}
+
+string* hd24project::projectname() 
+{
+        string* ver=parentfs->version();
+        if (*ver == "1.00") 
+        {
+                delete ver;     
+                // version 1.0 filesystem.
+                string* tmp = new string("");
+                string* dummy = Convert::readstring(buffer, PROJINFO_PROJECTNAME_8, 8);
+                
+                *tmp += *dummy;
+                delete dummy;
+                
+                if (tmp->length() == 8) 
+                {
+                        dummy = Convert::readstring(buffer, PROJINFO_PROJECTNAME_8 + 10, 2);
+                        *tmp += *dummy;
+                        delete dummy;
+                }
+                
+                return tmp;
+        }
+        delete ver;     
+        return Convert::readstring(buffer, PROJINFO_PROJECTNAME, 64);
+}
+
+void hd24project::projectname(string newname)
+{
+        hd24fs::setname(this->buffer,newname,PROJINFO_PROJECTNAME_8,PROJINFO_PROJECTNAME);      
+        return;
+}
+
+unsigned long hd24project::maxsongs() 
+{
+        return parentfs->maxsongsperproject();
+}
+
+unsigned long hd24project::getsongsectornum(int i) 
+{
+        unsigned int songsec = Convert::getint32(buffer, 
+                PROJINFO_SONGLIST + ((i - 1) * 4));
+        // FIXME: Check for sensible values.            
+        return songsec;
+}
+
+void hd24project::setsongsectornum(int i,__uint32 sector) 
+{
+        Convert::setint32(buffer, 
+                PROJINFO_SONGLIST + ((i - 1) * 4),sector);
+        // FIXME: Check for sensible values.            
+        return;
+}
+
+void hd24project::lastsongid(signed long songid)
+{
+        if (songid<1)
+        {
+                return;
+
+        }
+        int maxsongsperproj = maxsongs();       
+        if (songid>maxsongsperproj)
+        {
+                return;
+        }
+        if (songid==lastsongid())
+        {
+                /* same 'last song id' as before-
+                   nothing changes.
+                */
+                return;
+        }
+        Convert::setint32(buffer, PROJINFO_LASTSONG,getsongsectornum(songid));
+        this->save();
+        return;
+}
+
+signed long hd24project::lastsongid() 
+{
+        unsigned int lastsongsec = Convert::getint32(buffer, PROJINFO_LASTSONG);
+        
+        if (lastsongsec == 0)
+        {
+                return -1;
+        }
+
+        int maxsongsperproj = maxsongs();
+        for (int i = 1; i <= maxsongsperproj; i++) 
+        {
+                unsigned int songsec = getsongsectornum(i);
+
+                if (songsec == lastsongsec)
+                {
+                        return i;
+                }
+        }
+        
+        if (maxsongsperproj >= 1)
+        {
+                return 1;
+        }
+        
+        return -1;
+}
+
+__uint32 hd24project::songcount() 
+{
+        if (this==NULL)
+        {
+                return 0;
+        }
+        if (myprojectid == -1)
+        {
+                return 0;
+        }
+        if (buffer==NULL) {
+                return 0;
+        }
+        __uint32 scount = Convert::getint32(buffer, PROJINFO_SONGCOUNT);
+        
+        if (scount > 99)
+        {
+                return 99;
+        }
+        
+        return scount;
+}
+
+hd24song* hd24project::getsong(unsigned long songid) 
+{
+#if (PROJDEBUG == 1) 
+        cout << "get song " << songid << endl;
+#endif  
+        return new hd24song(this,songid);
+}
+
+void hd24project::save(__uint32 projsector)
+{
+#if (PROJDEBUG == 1) 
+        cout << "save project info to sector " << projsector << endl;
+#endif
+        if (buffer==NULL) 
+        {
+                return;  // nothing to do!
+        }
+        parentfs->fstfix(buffer,512); // sector is now in native format again 
+        parentfs->setsectorchecksum(buffer,0,projsector,1);     
+        parentfs->writesectors(parentfs->devhd24,
+                        projsector,
+                        buffer,1);
+        
+        parentfs->fstfix(buffer,512); // sector is now in 'fixed' format
+        parentfs->commit();
+}
+
+void hd24project::save()
+{
+        // This is capable of handling only 1-sector-per-project projects.
+        // save(projsector) is only intended for new projects.
+        __uint32 projsector=parentfs->getprojectsectornum(this->myprojectid);
+#if (PROJDEBUG == 1) 
+        cout << "save project info to sector " << projsector << endl;
+#endif  
+        if (projsector==0) 
+        {
+                return; // safety measure
+        }
+        save(projsector);
+}
+
+__uint32 hd24project::getunusedsongslot()
+{
+        // Find the first unused song slot in the current project.
+        __uint32 unusedsongslot=INVALID_SONGENTRY;
+
+        int maxsongcount=this->maxsongs();
+        for (int j=1; j<=maxsongcount;j++) 
+        {
+                // get song sector info.
+                __uint32 songsector = getsongsectornum(j);
+                if (songsector==0) 
+                {
+                        unusedsongslot=(j-1);
+                        break;
+                }
+        }
+        
+        return unusedsongslot;
+}
+
+hd24song* hd24project::createsong(const char* songname,__uint32 trackcount,
+                                  __uint32 samplerate)
+{
+        /* This creates a new song (with given songname)
+           on the drive (if possible).
+           NULL is returned when unsuccessful, a pointer to the
+           new song object otherwise.
+        */
+        __uint32 songslot=getunusedsongslot();
+        if (songslot==INVALID_SONGENTRY) 
+        {
+                // project is full.
+                return NULL;
+        }
+
+        // Project is not full so there must be unused song sectors
+        // (if not, something seriously fishy is going on).
+        __uint32 newsongsector=this->parentfs->getunusedsongsector();
+        if (newsongsector==0)
+        {
+                // no songsector found (0 is not a valid songsector)
+                return NULL;
+        }
+
+        // So, we have got a free songsector and a free song slot.
+        unsigned char songbuf[512*7];
+        for (int i=0;i<(7*512);i++) 
+        {
+                songbuf[i]=(unsigned char)(0);
+        }
+        hd24song::sectorinit(songbuf);  // put some default info in there
+
+        hd24song::songname((unsigned char*)songbuf,songname);
+        string* setsongname=hd24song::songname(parentfs,songbuf);
+        delete setsongname;
+
+        hd24song::samplerate((unsigned char*)songbuf,samplerate); 
+        hd24song::logical_channels((unsigned char*)songbuf,trackcount) ;// depends on samplerate
+        __uint32 songsector=newsongsector;
+
+        // - Create the empty song at the songsector 
+        // (2 sectors in size)
+        // - Create empty allocation info at songsector+2
+        // (5 sectors in size)
+        // write song info to drive
+
+        parentfs->fstfix(songbuf,TOTAL_SECTORS_PER_SONG*512); // sector is now once again in native format
+        parentfs->setsectorchecksum(songbuf,0,songsector,2);
+        parentfs->setsectorchecksum(songbuf,2*512,songsector+2,5);
+        parentfs->writesectors(parentfs->devhd24,songsector,songbuf,TOTAL_SECTORS_PER_SONG);
+        parentfs->fstfix(songbuf,TOTAL_SECTORS_PER_SONG*512); // sector is now once again in fixed format
+
+        /////////////////////////////
+        // -Update the project slot info to point at that sector
+        Convert::setint32(buffer,PROJINFO_SONGLIST+(songslot*4),songsector);
+        this->lastsongid(songslot+1);
+        Convert::setint32(buffer,PROJINFO_SONGCOUNT,
+                Convert::getint32(buffer,PROJINFO_SONGCOUNT)+1);
+        this->save();
+        parentfs->refreshsongusage();
+
+        ////////////////////////
+        // Now commit the FS
+        parentfs->commit();
+        
+        return getsong(songslot+1);
+}
+
+__uint32 hd24project::deletesong(__uint32 songid) 
+{
+        hd24song* songtodel=this->getsong(songid);
+#if (PROJDEBUG == 1)
+        cout << "del song with id " << songid << endl;
+#endif
+        __uint32 songsector=getsongsectornum(songid);
+#if (PROJDEBUG == 1)
+        cout << "sector " << songsector << endl;
+#endif
+        songsector++; songsector--; // prevent 'variable not used' warning
+
+        if (songtodel==NULL) 
+        {
+#if (PROJDEBUG == 1)
+        cout << "song to del==null " << endl;
+#endif
+                return RESULT_FAIL;
+        }
+        songtodel->songlength_in_samples(0,false);
+        songtodel->save();
+
+        // delete song from project list by shifting left
+        // all other songs...
+        for (__uint32 i=songid;i<99;i++) 
+        {
+#if (PROJDEBUG == 1)
+        cout << "set new sector for song id " << i <<" to " << getsongsectornum(i+1) << endl;
+#endif
+                setsongsectornum(i,getsongsectornum(i+1));
+        }
+        setsongsectornum(99,0); // ...and clearing the last entry.
+        __uint32 scount = Convert::getint32(buffer, PROJINFO_SONGCOUNT);
+        Convert::setint32(buffer,PROJINFO_SONGCOUNT,scount-1);
+#if (PROJDEBUG == 1)
+        cout << "set new song count to " << (scount-1) << endl;
+#endif
+
+        // set 'last accessed song' to first song in list
+        // (if there are no songs anymore, this automatically
+        // results in 'last song' to be on sector zero.
+#if (PROJDEBUG ==1)
+        cout << "set default project song to song 1 with sectornum " << getsongsectornum(1) << endl;
+#endif
+        Convert::setint32(buffer, PROJINFO_LASTSONG,getsongsectornum(1));
+#if (PROJDEBUG ==1)
+        cout << "save project." << endl;
+#endif
+
+        this->save();
+#if (PROJDEBUG ==1)
+        cout << "refresh song usage table (+superblock) " << endl;
+#endif
+        parentfs->refreshsongusage(); // or calcsongusage?
+        
+        unsigned char* sectors_driveusage=parentfs->getsectors_driveusage();
+
+        // now, we still have the song object songtodel,
+        // plus its original sector number.
+#if (PROJDEBUG ==1)
+        cout << "Reset song length" << endl;
+#endif
+#if (PROJDEBUG ==1)
+        cout << "Unmark used clusters " << endl;
+#endif
+        songtodel->unmark_used_clusters(sectors_driveusage);
+#if (PROJDEBUG ==1)
+        cout << "Destruct song object." << endl;
+#endif
+        delete(songtodel);
+#if (PROJDEBUG ==1)
+        cout << "Save drive usage." << endl;
+#endif
+        parentfs->savedriveusage();     
+#if (PROJDEBUG ==1)
+        cout << "Commit FS" << endl;
+#endif
+        parentfs->commit();
+        return RESULT_SUCCESS;
+}
+
+void hd24project::sort()
+{
+        // a max. of 99 elements is still doable by bubble sort.
+        int songs=this->songcount();
+        if (songs<2) return; // nothing to sort!
+        string** songnames=(string**)memutils::mymalloc("hd24project::sort",99,sizeof(string*));
+        hd24song* song1=NULL;
+
+        int i, j;
+        int arrayLength = songs;
+        for (i=1;i<=arrayLength;i++)
+        {
+                song1=getsong(i);
+                songnames[i-1]=song1->songname();
+                delete song1;
+                song1=NULL;
+        }
+        
+        for(i = 1; i <= arrayLength ; i++)
+        {
+                for (j=0; j < (arrayLength -1); j++)
+                {
+                        int compare=strncmp(songnames[j]->c_str(),songnames[j+1]->c_str(),64);
+                        if (compare>0)
+                        {
+                                // swap entries
+                                __uint32 a=getsongsectornum(j+1);
+                                __uint32 b=getsongsectornum(j+2);
+                                setsongsectornum(j+2,a);
+                                setsongsectornum(j+1,b);
+                                string* tmp=songnames[j];
+                                songnames[j]=songnames[j+1];
+                                songnames[j+1]=tmp;
+                        }
+                }
+        }
+        
+        for (i=1;i<=arrayLength;i++)
+        {
+                free(songnames[i-1]);
+        }
+        free(songnames);
+        return;
+}