fix big-endian build (i think)

src/engine/fileOps.cpp

@@ -826,6 +826,13 @@ bool DivEngine::loadDMF(unsigned char* file, size_t len) {
             reader.read(data,length*2);
           }
           
+#ifdef TA_BIG_ENDIAN
+          // convert to big-endian
+          for (size_t pos=0; pos<length; pos++) {
+            data[pos]=(short)((((unsigned short)data[pos])<<8)|(((unsigned short)data[pos])>>8));
+          }
+#endif
+
           if (pitch!=5) {
             logD("%d: scaling from %d...",i,pitch);
           }
@@ -1323,9 +1330,15 @@ bool DivEngine::loadFur(unsigned char* file, size_t len) {
     }
 
     // pointers
-    reader.read(insPtr,ds.insLen*4);
+    for (int i=0; i<ds.insLen; i++) {
-    reader.read(wavePtr,ds.waveLen*4);
+      insPtr[i]=reader.readI();
-    reader.read(samplePtr,ds.sampleLen*4);
+    }
+    for (int i=0; i<ds.waveLen; i++) {
+      wavePtr[i]=reader.readI();
+    }
+    for (int i=0; i<ds.sampleLen; i++) {
+      samplePtr[i]=reader.readI();
+    }
     for (int i=0; i<numberOfPats; i++) patPtr.push_back(reader.readI());
 
     logD("reading orders (%d)...",subSong->ordersLen);
@@ -1703,11 +1716,36 @@ bool DivEngine::loadFur(unsigned char* file, size_t len) {
       if (ds.version>=58) { // modern sample
         sample->init(sample->samples);
         reader.read(sample->getCurBuf(),sample->getCurBufLen());
+#ifdef TA_BIG_ENDIAN
+        // convert 16-bit samples to big-endian
+        if (sample->depth==DIV_SAMPLE_DEPTH_16BIT) {
+          unsigned char* sampleBuf=sample->getCurBuf();
+          size_t sampleBufLen=sample->getCurBufLen();
+          for (size_t pos=0; pos<sampleBufLen; pos+=2) {
+            sampleBuf[pos]^=sampleBuf[pos+1];
+            sampleBuf[pos+1]^=sampleBuf[pos];
+            sampleBuf[pos]^=sampleBuf[pos+1];
+          }
+        }
+#endif
       } else { // legacy sample
         int length=sample->samples;
         short* data=new short[length];
         reader.read(data,2*length);
 
+#ifdef TA_BIG_ENDIAN
+        // convert 16-bit samples to big-endian
+        if (sample->depth==DIV_SAMPLE_DEPTH_16BIT) {
+          unsigned char* sampleBuf=sample->getCurBuf();
+          size_t sampleBufLen=sample->getCurBufLen();
+          for (size_t pos=0; pos<sampleBufLen; pos+=2) {
+            sampleBuf[pos]^=sampleBuf[pos+1];
+            sampleBuf[pos+1]^=sampleBuf[pos];
+            sampleBuf[pos]^=sampleBuf[pos+1];
+          }
+        }
+#endif
+
         if (pitch!=5) {
           logD("%d: scaling from %d...",i,pitch);
         }
@@ -3807,7 +3845,21 @@ SafeWriter* DivEngine::saveFur(bool notPrimary) {
       w->writeI(0xffffffff);
     }
 
+#ifdef TA_BIG_ENDIAN
+    // store 16-bit samples as little-endian
+    if (sample->depth==DIV_SAMPLE_DEPTH_16BIT) {
+      unsigned char* sampleBuf=(unsigned char*)sample->getCurBuf();
+      size_t bufLen=sample->getCurBufLen();
+      for (size_t i=0; i<bufLen; i+=2) {
+        w->writeC(sampleBuf[i+1]);
+        w->writeC(sampleBuf[i]);
+      }
+    } else {
+      w->write(sample->getCurBuf(),sample->getCurBufLen());
+    }
+#else
     w->write(sample->getCurBuf(),sample->getCurBufLen());
+#endif
 
     blockEndSeek=w->tell();
     w->seek(blockStartSeek,SEEK_SET);
@@ -3834,7 +3886,13 @@ SafeWriter* DivEngine::saveFur(bool notPrimary) {
       w->writeS(pat->data[j][1]); // octave
       w->writeS(pat->data[j][2]); // instrument
       w->writeS(pat->data[j][3]); // volume
+#ifdef TA_BIG_ENDIAN
+      for (int k=0; k<song.subsong[i.subsong]->pat[i.chan].effectCols*2; k++) {
+        w->writeS(pat->data[j][4+k]);
+      }
+#else
       w->write(&pat->data[j][4],2*song.subsong[i.subsong]->pat[i.chan].effectCols*2); // effects
+#endif
     }
 
     w->writeString(pat->name,false);
@@ -4116,7 +4174,9 @@ SafeWriter* DivEngine::saveDMF(unsigned char version) {
             w->writeI(i->std.volMacro.val[j]+18);
           }
         } else {
-          w->write(i->std.volMacro.val,4*i->std.volMacro.len);
+          for (int j=0; j<i->std.volMacro.len; j++) {
+            w->writeI(i->std.volMacro.val[j]);
+          }
         }
         if (i->std.volMacro.len>0) {
           w->writeC(i->std.volMacro.loop);
@@ -4125,7 +4185,9 @@ SafeWriter* DivEngine::saveDMF(unsigned char version) {
 
       w->writeC(i->std.arpMacro.len);
       if (i->std.arpMacro.mode) {
-        w->write(i->std.arpMacro.val,4*i->std.arpMacro.len);
+        for (int j=0; j<i->std.arpMacro.len; j++) {
+          w->writeI(i->std.arpMacro.val[j]);
+        }
       } else {
         for (int j=0; j<i->std.arpMacro.len; j++) {
           w->writeI(i->std.arpMacro.val[j]+12);
@@ -4142,14 +4204,18 @@ SafeWriter* DivEngine::saveDMF(unsigned char version) {
           w->writeI(i->std.dutyMacro.val[j]+12);
         }
       } else {
-        w->write(i->std.dutyMacro.val,4*i->std.dutyMacro.len);
+        for (int j=0; j<i->std.dutyMacro.len; j++) {
+          w->writeI(i->std.dutyMacro.val[j]);
+        }
       }
       if (i->std.dutyMacro.len>0) {
         w->writeC(i->std.dutyMacro.loop);
       }
 
       w->writeC(i->std.waveMacro.len);
-      w->write(i->std.waveMacro.val,4*i->std.waveMacro.len);
+      for (int j=0; j<i->std.waveMacro.len; j++) {
+        w->writeI(i->std.waveMacro.val[j]);
+      }
       if (i->std.waveMacro.len>0) {
         w->writeC(i->std.waveMacro.loop);
       }
@@ -4200,7 +4266,9 @@ SafeWriter* DivEngine::saveDMF(unsigned char version) {
         w->writeI(i->data[j]>>2);
       }
     } else {
-      w->write(i->data,4*i->len);
+      for (int j=0; j<i->len; j++) {
+        w->writeI(i->data[j]);
+      }
     }
   }
 
@@ -4213,7 +4281,13 @@ SafeWriter* DivEngine::saveDMF(unsigned char version) {
         w->writeS(pat->data[k][0]); // note
         w->writeS(pat->data[k][1]); // octave
         w->writeS(pat->data[k][3]); // volume
+#ifdef TA_BIG_ENDIAN
+        for (int l=0; l<curPat[i].effectCols*2; l++) {
+          w->writeS(pat->data[k][4+l]);
+        }
+#else
         w->write(&pat->data[k][4],2*curPat[i].effectCols*2); // effects
+#endif
         w->writeS(pat->data[k][2]); // instrument
       }
     }
@@ -4232,7 +4306,15 @@ SafeWriter* DivEngine::saveDMF(unsigned char version) {
     w->writeC(50);
     // i'm too lazy to deal with .dmf's weird way of storing 8-bit samples
     w->writeC(16);
+    // well I can't be lazy if it's on a big-endian system
+#ifdef TA_BIG_ENDIAN
+    for (unsigned int j=0; j<i->length16; j++) {
+      w->writeC(((unsigned short)i->data16[j])&0xff);
+      w->writeC(((unsigned short)i->data16[j])>>8);
+    }
+#else
     w->write(i->data16,i->length16);
+#endif
   }
   
   saveLock.unlock();

src/engine/instrument.cpp

@@ -549,6 +549,9 @@ void DivInstrument::putInsData(SafeWriter* w) {
   w->seek(0,SEEK_END);
 }
 
+#define READ_MACRO_VALS(x,y) \
+  for (int macroValPos=0; macroValPos<y; macroValPos++) x[macroValPos]=reader.readI();
+
 DivDataErrors DivInstrument::readInsData(SafeReader& reader, short version) {
   char magic[4];
   reader.read(magic,4);
@@ -674,10 +677,10 @@ DivDataErrors DivInstrument::readInsData(SafeReader& reader, short version) {
   int oldVolHeight=reader.readC();
   int oldDutyHeight=reader.readC();
   reader.readC(); // oldWaveHeight
-  reader.read(std.volMacro.val,4*std.volMacro.len);
+  READ_MACRO_VALS(std.volMacro.val,std.volMacro.len);
-  reader.read(std.arpMacro.val,4*std.arpMacro.len);
+  READ_MACRO_VALS(std.arpMacro.val,std.arpMacro.len);
-  reader.read(std.dutyMacro.val,4*std.dutyMacro.len);
+  READ_MACRO_VALS(std.dutyMacro.val,std.dutyMacro.len);
-  reader.read(std.waveMacro.val,4*std.waveMacro.len);
+  READ_MACRO_VALS(std.waveMacro.val,std.waveMacro.len);
   if (version<31) {
     if (!std.arpMacro.mode) for (int j=0; j<std.arpMacro.len; j++) {
       std.arpMacro.val[j]-=12;
@@ -692,10 +695,10 @@ DivDataErrors DivInstrument::readInsData(SafeReader& reader, short version) {
     }
   }
   if (version>=17) {
-    reader.read(std.pitchMacro.val,4*std.pitchMacro.len);
+    READ_MACRO_VALS(std.pitchMacro.val,std.pitchMacro.len);
-    reader.read(std.ex1Macro.val,4*std.ex1Macro.len);
+    READ_MACRO_VALS(std.ex1Macro.val,std.ex1Macro.len);
-    reader.read(std.ex2Macro.val,4*std.ex2Macro.len);
+    READ_MACRO_VALS(std.ex2Macro.val,std.ex2Macro.len);
-    reader.read(std.ex3Macro.val,4*std.ex3Macro.len);
+    READ_MACRO_VALS(std.ex3Macro.val,std.ex3Macro.len);
   } else {
     if (type==DIV_INS_STD) {
       if (oldVolHeight==31) {
@@ -730,10 +733,10 @@ DivDataErrors DivInstrument::readInsData(SafeReader& reader, short version) {
     std.fmsMacro.open=reader.readC();
     std.amsMacro.open=reader.readC();
 
-    reader.read(std.algMacro.val,4*std.algMacro.len);
+    READ_MACRO_VALS(std.algMacro.val,std.algMacro.len);
-    reader.read(std.fbMacro.val,4*std.fbMacro.len);
+    READ_MACRO_VALS(std.fbMacro.val,std.fbMacro.len);
-    reader.read(std.fmsMacro.val,4*std.fmsMacro.len);
+    READ_MACRO_VALS(std.fmsMacro.val,std.fmsMacro.len);
-    reader.read(std.amsMacro.val,4*std.amsMacro.len);
+    READ_MACRO_VALS(std.amsMacro.val,std.amsMacro.len);
 
     for (int i=0; i<4; i++) {
       DivInstrumentSTD::OpMacro& op=std.opMacros[i];
@@ -1007,14 +1010,14 @@ DivDataErrors DivInstrument::readInsData(SafeReader& reader, short version) {
     std.ex7Macro.open=reader.readC();
     std.ex8Macro.open=reader.readC();
 
-    reader.read(std.panLMacro.val,4*std.panLMacro.len);
+    READ_MACRO_VALS(std.panLMacro.val,std.panLMacro.len);
-    reader.read(std.panRMacro.val,4*std.panRMacro.len);
+    READ_MACRO_VALS(std.panRMacro.val,std.panRMacro.len);
-    reader.read(std.phaseResetMacro.val,4*std.phaseResetMacro.len);
+    READ_MACRO_VALS(std.phaseResetMacro.val,std.phaseResetMacro.len);
-    reader.read(std.ex4Macro.val,4*std.ex4Macro.len);
+    READ_MACRO_VALS(std.ex4Macro.val,std.ex4Macro.len);
-    reader.read(std.ex5Macro.val,4*std.ex5Macro.len);
+    READ_MACRO_VALS(std.ex5Macro.val,std.ex5Macro.len);
-    reader.read(std.ex6Macro.val,4*std.ex6Macro.len);
+    READ_MACRO_VALS(std.ex6Macro.val,std.ex6Macro.len);
-    reader.read(std.ex7Macro.val,4*std.ex7Macro.len);
+    READ_MACRO_VALS(std.ex7Macro.val,std.ex7Macro.len);
-    reader.read(std.ex8Macro.val,4*std.ex8Macro.len);
+    READ_MACRO_VALS(std.ex8Macro.val,std.ex8Macro.len);
 
     // FDS
     fds.modSpeed=reader.readI();