1 files changed, 637 insertions, 0 deletions

diff --git a/src/lib/hd24utils.cpp b/src/lib/hd24utils.cpp
new file mode 100755
index 0000000..6efb3a7
--- /dev/null
+++ b/src/lib/hd24utils.cpp
@@ -0,0 +1,637 @@
+#define UTILDEBUG 0
+#ifdef DARWIN
+#       define creat64 creat
+#       define open64 open
+#       define lseek64 lseek
+#       define pread64 pread
+#       define pwrite64 pwrite
+#endif
+
+#if defined(LINUX) || defined(DARWIN)
+#       define PRINTAPP "lp"
+#endif
+
+#ifdef WINDOWS
+#       include <windows.h>
+#       include <shellapi.h>
+#       define PRINTAPP "print"
+#       define popen _popen
+#       define pclose _pclose
+#else
+#       include <unistd.h>
+#endif
+
+#include <string>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <iostream>
+#include <fstream>
+#include <math.h>
+#include <hd24devicenamegenerator.h>
+#include <FL/FLTKstuff.H>
+#include <FL/Fl_Preferences.H>
+#include <FL/filename.H>
+#include "convertlib.h"
+#include "hd24utils.h"
+#include "memutils.h"
+#define _LARGE_FILES
+#define LARGE_FILES
+#define LARGEFILE64_SOURCE
+#define _FILE_OFFSET_BITS               64
+#define FILE_OFFSET_BITS                64
+#define SECTORSIZE                      512
+#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_FAT          0x38
+#define FSINFO_NUMSECTORS_FAT           0x3c
+#define FSINFO_CLUSTERS_ON_DISK         0x44
+#define FSINFO_MAXPROJECTS              0x50
+#define FSINFO_MAXSONGSPERPROJECT       0x54
+#define FSINFO_DATAAREA                 0x7c
+#define DRIVEINFO_VOLUME                0x1b8
+#define DRIVEINFO_PROJECTCOUNT          0x0c
+#define DRIVEINFO_LASTPROJ              0x10
+#define DRIVEINFO_PROJECTLIST           0x20
+
+void hd24utils::gencatalog_showsongs(hd24project* currentproj,string* strcatalog)
+{
+        if (currentproj==NULL) {
+                return;
+        }
+        if (strcatalog==NULL) {
+                return;
+        }
+        int numsongs=currentproj->songcount();
+        *strcatalog+="     ======================================================================\n";
+        if (numsongs==0) {
+                *strcatalog+="      There are no songs in this project.\n";
+                return;
+        }
+        hd24song* currsong=NULL;
+        for (int i=1; i<=numsongs; i++) {
+                currsong=currentproj->getsong(i);
+                if (currsong==NULL) continue;
+
+                *strcatalog+="     ";
+                *strcatalog+="  ";
+                if (i<10) {
+                        *strcatalog+=" ";
+                }
+                string* songnum=Convert::int2str(i);
+                *strcatalog+=*songnum;
+                *strcatalog+=": ";
+                delete songnum;
+        
+                string* currsname=currsong->songname();
+                string* pad=Convert::padright(*currsname,35," ");
+                delete(currsname);
+                *strcatalog+=*pad;
+                delete pad;
+                string* dur=currsong->display_duration();
+                *strcatalog+=*dur;
+                delete dur;
+                *strcatalog+= ", " ;
+
+                string* chans=Convert::int2str(currsong->logical_channels());
+                string* chans2=Convert::padleft(*chans,2," ");
+                *strcatalog+=*chans;
+                delete chans;
+                delete chans2;
+                *strcatalog+="ch. ";
+
+                string* samrate=Convert::int2str(currsong->samplerate());
+                *strcatalog+=*samrate;
+                delete samrate;
+                *strcatalog+=" Hz";
+
+
+                if (currsong->iswriteprotected()) 
+                {
+                        *strcatalog+="*";
+                }
+
+                *strcatalog+="\n";
+                
+                delete currsong;
+                currsong=NULL;
+        }
+        return;
+}
+
+void hd24utils::gencatalog_showprojects(hd24fs* currenthd24,string* strcatalog)
+{
+        int numprojs=currenthd24->projectcount();
+        hd24project* currproj=NULL;
+        for (int i=1; i<=numprojs; i++) 
+        {
+                currproj=currenthd24->getproject(i);
+
+                *strcatalog+="     ======================================================================\n";
+                *strcatalog+="     Project ";
+                string* projnum=Convert::int2str(i);
+                *strcatalog+=*projnum;
+                delete projnum;
+                *strcatalog+=": ";
+
+                string* currpname=currproj->projectname();              
+                *strcatalog+= *currpname;
+                delete(currpname);
+
+                *strcatalog+="\n"; // << endl;
+                gencatalog_showsongs (currproj,strcatalog); //to_out);
+                delete(currproj);
+        }
+        
+}
+
+int hd24utils::gencatalog(hd24fs* currenthd24,string* strcatalog) 
+{
+
+        time_t currenttime;
+        struct tm timestamp;
+        char timebuf[80];
+        time(&currenttime);
+        timestamp = *localtime(&currenttime);
+        strftime(timebuf,sizeof(timebuf),"%a %Y-%m-%d %H:%M:%S %Z", &timestamp);
+        *strcatalog+= "     Catalog timestamp      : ";
+        *strcatalog+= timebuf ;
+        *strcatalog+="\n";
+
+        *strcatalog+="     Volume name            : ";
+        string* volname=currenthd24->volumename();
+        *strcatalog+=*volname;
+        delete volname;
+        *strcatalog+="\n";
+
+        *strcatalog+="     Number of projects     : ";
+        string* pcount=Convert::int2str(currenthd24->projectcount());
+        *strcatalog+=*pcount;
+        delete pcount;
+
+        *strcatalog+="\n";
+        gencatalog_showprojects(currenthd24,strcatalog);
+        return 0;
+}
+
+string* hd24utils::savecatalog(hd24fs* currenthd24,string* filename)
+{
+        string* error=new string("");
+
+        // gencatalog
+        string* catalog=new string("");
+
+        if (hd24utils::gencatalog(currenthd24,catalog)!=0) 
+        {
+                *error+="Error generating catalog.";
+                return error;
+        }
+        fstream to_out(filename->c_str(),ios::out);
+        if (to_out==NULL) 
+        {
+                *error+="Cannot write catalog.";
+                return error;
+        }       
+        to_out << *catalog ;
+
+        to_out.flush();
+        to_out.close();
+        return NULL;
+}
+
+string* hd24utils::printcatalog(hd24fs* currenthd24)
+{
+
+        string* error=new string("");
+        string catname="_hd24cat.txt";  
+
+
+        // gencatalog
+        string* catalog=new string("");
+
+        if (hd24utils::gencatalog(currenthd24,catalog)!=0) 
+        {
+                *error+="Error generating catalog.";
+                return error;
+        }
+        fstream to_out(catname.c_str(),ios::out);
+        if (to_out==NULL) 
+        {
+                *error+="Cannot write catalog.";
+                return error;
+        }       
+        *catalog += "\f\n"; // form feed
+        to_out << *catalog ;
+
+        to_out.flush();
+        to_out.close();
+
+#ifdef WINDOWS
+        SHELLEXECUTEINFO ShExecInfo = {0};
+        ShExecInfo.cbSize = sizeof (SHELLEXECUTEINFO);
+        ShExecInfo.fMask = SEE_MASK_NOCLOSEPROCESS; //SEE_MASK_INVOKEIDLIST;
+        ShExecInfo.hwnd = NULL;
+        ShExecInfo.lpVerb="print";
+        ShExecInfo.lpFile=catname.c_str();
+        ShExecInfo.lpParameters = "";
+        ShExecInfo.lpDirectory=NULL;
+        ShExecInfo.nShow = SW_HIDE;
+        ShExecInfo.hInstApp = NULL;
+        ShellExecuteEx(&ShExecInfo);
+        WaitForSingleObject(ShExecInfo.hProcess,INFINITE);
+        unlink (catname.c_str());
+#else   
+        char s[1024];
+        string* catcmd = new string (PRINTAPP);
+        *catcmd += " ";
+        *catcmd += catname;
+        *catcmd += " 2>&1";
+        FILE *fp = popen(catcmd->c_str() , "r");
+        while (fgets(s, sizeof(s)-1, fp)) 
+        {
+                *error += s; 
+        }
+        pclose(fp);
+        unlink (catname.c_str());
+#endif
+        return error;
+}
+
+
+void hd24utils::interlacetobuffer(unsigned char* sourcebuf,unsigned char* targetbuf,
+                __uint32 totbytes,__uint32 bytespersam,__uint32 trackwithingroup,__uint32 trackspergroup)
+{
+        __uint32 samplenum;
+        __uint32 totsams=totbytes/bytespersam;
+        __uint32 trackoff=(trackwithingroup*bytespersam);
+        __uint32 q=0;
+        // unroll loop for bytespersam=1,2,3
+        switch (bytespersam) 
+        {
+                case 3:
+                for (samplenum=0;samplenum<totsams;samplenum++)
+                {
+                        __uint32 samoff=(samplenum*bytespersam);
+                        q=trackspergroup*samoff+trackoff;
+                        targetbuf[q++]=sourcebuf[samoff];
+                        targetbuf[q++]=sourcebuf[samoff+1];
+                        targetbuf[q++]=sourcebuf[samoff+2];
+                }               
+                break;
+                case 1:
+                        for (samplenum=0;samplenum<totsams;samplenum++)
+                        {
+                                __uint32 samoff=(samplenum*bytespersam);
+                                q=trackspergroup*samoff+trackoff;
+                                targetbuf[q]=sourcebuf[samoff];
+                        }       
+                        break;
+                case 2:
+                        for (samplenum=0;samplenum<totsams;samplenum++)
+                        {
+                                __uint32 samoff=(samplenum*bytespersam);
+                                q=trackspergroup*samoff+trackoff;
+                                targetbuf[q++]=sourcebuf[samoff];
+                                targetbuf[q++]=sourcebuf[samoff+1];
+                        }               
+                        break;
+                default:
+                        for (samplenum=0;samplenum<totsams;samplenum++)
+                        {
+                                __uint32 samoff=(samplenum*bytespersam);
+                                q=trackspergroup*samoff;
+                                for (__uint32 j=0; j<bytespersam; j++) {
+                                   targetbuf[q+j+trackoff]=sourcebuf[samoff+j];
+                                }
+                        }
+                        break;
+        }
+}
+
+bool hd24utils::dirExists(const char * pszDirName)
+{
+#ifdef WIN32
+    unsigned int dwAttrs;
+    if (!(pszDirName))
+    {
+      //setupLog(NULL, "DirExists failed: passed in NULL parameter for directory");
+      return (1==0);
+    }
+    dwAttrs = GetFileAttributes(pszDirName);
+    if ((dwAttrs != 0xFFFFFFFF) && (dwAttrs & FILE_ATTRIBUTE_DIRECTORY))
+    {
+      return (1==1);
+    }
+    return (1==0);
+#else
+    struct stat fi;
+
+    if (stat (pszDirName, &fi) == -1 || !S_ISDIR(fi.st_mode))
+    {
+      return (1==0);
+    }
+    else
+    {
+      return (1==1);
+    }
+#endif
+}
+int hd24utils::savedrivesectors(hd24fs* currenthd24,string* outputfilename,unsigned long firstsector,unsigned long endsector,char* message,int* cancel) {
+        unsigned long i;
+#define MULTISECTOR 100 
+        unsigned char bootblock[(MULTISECTOR+1)*512]; // 1 sector spare
+        memset(bootblock,0,MULTISECTOR*512);
+#if defined(LINUX) || defined(DARWIN)
+#if (UTILDEBUG==1)
+        cout << "creat64" << endl;
+#endif
+        FSHANDLE handle=creat64(outputfilename->c_str(),O_WRONLY);
+#endif
+#ifdef WINDOWS
+        FSHANDLE handle=CreateFile(outputfilename->c_str(),GENERIC_WRITE|GENERIC_READ,
+              FILE_SHARE_READ|FILE_SHARE_WRITE,
+              NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
+        if (hd24fs::isinvalidhandle(handle)) {
+                handle=CreateFile(outputfilename->c_str(),GENERIC_WRITE|GENERIC_READ,
+              FILE_SHARE_READ|FILE_SHARE_WRITE,
+              NULL,OPEN_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
+        }
+                
+        #endif
+        if (hd24fs::isinvalidhandle(handle)) {
+        //      cout << "Cannot open file "<<filename <<" for writing. Access denied?" << endl;
+                return 1;               
+        }
+        int q=0;
+        for (i=firstsector;i<=endsector;i++) {
+                q++;
+                int numsectors=1;
+                if ((endsector-i) >=MULTISECTOR) {
+                        numsectors=MULTISECTOR;
+                }
+                if (currenthd24!=NULL) {
+                        currenthd24->readsector_noheader(currenthd24,i,bootblock); // raw reading 
+                }
+#if defined(LINUX) || defined(DARWIN)
+                __uint64 targetoff=i;
+                targetoff-=firstsector;
+                targetoff*=512;
+                ssize_t byteswritten=0;
+                if (currenthd24!=NULL) {
+                        byteswritten=pwrite64(handle,bootblock,512,targetoff);
+                } else {
+                        byteswritten=pwrite64(handle,bootblock,512*numsectors,targetoff);
+                        i+=(numsectors-1);
+                }
+#endif
+#ifdef WINDOWS
+                //DWORD dummy;
+                //long bytes=0;
+                __uint64 targetoff=i;
+                targetoff-=firstsector;
+                __uint64 byteswritten=0;
+                if (currenthd24!=NULL) {
+                        byteswritten=currenthd24->writesectors(handle,targetoff,bootblock,1);
+                } else {
+                        byteswritten=currenthd24->writesectors(handle,targetoff,bootblock,numsectors);
+                        i+=(numsectors-1);
+                }
+#endif
+                if (byteswritten==0) {
+#if defined(LINUX) || defined(DARWIN)
+                        close (handle);
+#endif
+#ifdef WINDOWS
+                        CloseHandle(handle);
+#endif
+                        return 1;
+                }
+                if (message!=NULL) {
+                        if (q%1000==0) {
+                                sprintf(message,"Saving sector %ld of %ld",i,(endsector+1));
+                        
+                                // cout << i << endl;   
+                                Fl::wait(0);
+                        }
+                }
+        }
+#if defined(LINUX) || defined(DARWIN)
+        close (handle);
+        chmod(outputfilename->c_str(),0664);
+#endif
+#ifdef WINDOWS
+        CloseHandle(handle);
+#endif
+
+        return 0;
+}
+
+int hd24utils::savedriveimage(hd24fs* currenthd24,string* imagefilename,char* message,int* cancel) {
+        unsigned long firstsector=0;
+        unsigned long endsector=currenthd24->getlastsectornum();
+        return savedrivesectors(currenthd24,imagefilename,firstsector,endsector,message,cancel);
+}
+
+int hd24utils::newdriveimage(string* imagefilename,__uint32 endsector,char* message,int* cancel) {
+        if (endsector<1353964)
+        {
+                // requested drive size is less than possible minimum size
+                return -1;
+        }
+        
+        unsigned long firstsector=0;
+#if (UTILDEBUG==1)
+cout << "about to save drive sectors" <<endl;
+#endif
+        int result=savedrivesectors(NULL,imagefilename,firstsector,endsector,message,cancel);
+        if (result!=0)
+        {
+                return result;
+        }
+#if (UTILDEBUG==1)
+cout << "saved drive sectors, creating new fs object to format" <<endl;
+#endif
+        hd24fs* newfs=new hd24fs((const char*)NULL,hd24fs::MODE_RDWR,imagefilename,true);
+#if (UTILDEBUG==1)
+cout << "write enabling fs" <<endl;
+#endif
+        newfs->write_enable();
+#if (UTILDEBUG==1)
+cout << "quickformatting fs" <<endl;
+#endif
+        newfs->quickformat(message);
+#if (UTILDEBUG==1)
+        cout << "format result=" << *message << endl;
+cout << "deleting format fs object" <<endl;
+#endif
+        delete newfs;
+#if (UTILDEBUG==1)
+cout << "destructed fs object" <<endl;
+#endif  
+        return 0;
+}
+
+void hd24utils::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;
+        }
+}
+int hd24utils::saveheader(hd24fs* currenthd24,string* headerfilename) {
+        return savedrivesectors(currenthd24,headerfilename,0,0x700,NULL,NULL);
+        // TODO: 0x700 sectors is arbitrary. First song entry is at 0x77,
+        // total of 99*99 songs of 7 sectors each puts actual required length 
+        // at 0x10c76. However, this has served fine so far.
+
+}
+
+void hd24utils::findfile(const char* rawname,const char* path,char* result) 
+{
+        string* strpath=new string(path);
+#ifdef WINDOWS
+        string* pathsep=new string(";");
+#else
+        string* pathsep=new string(":");
+#endif
+        int last=0;     
+        string* exename;
+        string* exepath;        
+#if (UTILDEBUG==1)
+        cout << "search path for exe " << endl;
+#endif
+        while (last==0)
+        {
+                unsigned int idx=strpath->find(pathsep->c_str());
+                if (idx==string::npos) {
+                        last=1;
+                        exepath=new string(strpath->c_str());
+                        exename=new string(strpath->c_str());
+                        *strpath="";
+                } else {
+                        exepath=new string(strpath->substr(0,idx));
+                        exename=new string(strpath->substr(0,idx));
+                        *strpath=strpath->substr(idx+1);
+                }
+#if (UTILDEBUG==1)
+                cout << "exepath= " << *exepath << endl;
+#endif
+                if (exepath->substr(exepath->length()-1,1)!=PATHSLASH) {
+                     *exepath+=PATHSLASH;
+                }       
+                if (exename->substr(exename->length()-1,1)!=PATHSLASH) {
+                     *exename+=PATHSLASH;
+                }       
+
+                *exename+=rawname;
+#if (UTILDEBUG==1)
+                cout << "test if file " << exename->c_str() << " exists" << endl;
+#endif
+                if (hd24utils::fileExists(exename->c_str())) {
+                        strncpy(result,exepath->c_str(),2048);
+                        if (exename!=NULL) {
+                                delete exename;
+                                exename=NULL;
+                        }
+                        if (exepath!=NULL) {
+                                delete exepath;
+                                exepath=NULL;
+                        }
+                        if (strpath!=NULL) {            
+                                delete strpath;
+                                strpath=NULL;
+                        }
+                        if (pathsep!=NULL) {
+                                delete pathsep;
+                                pathsep=NULL;
+                        }
+                        return ;
+                }
+                if (exename!=NULL) {
+                        delete exename;
+                        exename=NULL;
+                }
+                if (exepath!=NULL) {
+                        delete exepath;
+                        exepath=NULL;
+                }               
+        }       
+
+        if (strpath!=NULL) {            
+                delete strpath;
+                strpath=NULL;
+        }
+        if (pathsep!=NULL) {
+                delete pathsep;
+                pathsep=NULL;
+        }
+
+        result[0]=(char)0;
+        return;
+}
+
+bool hd24utils::fileExists(const char* strFilename) {
+        struct stat stFileInfo;
+        int intStat;
+
+        // Attempt to get the file attributes
+        intStat = stat(strFilename,&stFileInfo);
+        if(intStat == 0) 
+        {
+                // We were able to get the file attributes
+                // so the file obviously exists.
+                return true;
+        }
+        // We were not able to get the file attributes.
+        // This may mean that we don't have permission to
+        // access the folder which contains this file. If you
+        // need to do that level of checking, lookup the
+        // return values of stat which will give you
+        // more details on why stat failed.
+        return false;
+}
+
+string* hd24utils::getlastdir(string which)
+{
+        string* whichdir;
+        char buffer[FL_PATH_MAX];
+
+        Fl_Preferences* userprefs=new Fl_Preferences(Fl_Preferences::USER, "HD24","HD24connect" );
+        /* Attempt to find last used project dir */
+        if (userprefs->entryExists(which.c_str())) {
+                userprefs->get(which.c_str(),buffer,".",FL_PATH_MAX);
+                whichdir=new string(buffer);
+        } else {
+                whichdir=new string(".");
+        }
+        delete userprefs;
+        return whichdir;
+}
+
+void hd24utils::setlastdir(string which,const char* newdir)
+{
+        Fl_Preferences* userprefs=new Fl_Preferences(Fl_Preferences::USER, "HD24","HD24connect" );
+        userprefs->set(which.c_str(),newdir);
+        // cout << "just set " << which << " to " << newdir << endl;
+        delete userprefs;
+}