work in progress, support both sync and async loading

Author: newdigate

src/flashloader.cpp

@@ -22,13 +22,53 @@
 #include "flashloader.h"
 
 namespace newdigate {
-/*
+
     audiosample * flashloader::loadSample(const char *filename ) {
         Serial.printf("Reading %s\n", filename);
         //unsigned s = ((-_lastPointer) % 512)-4;
         //Serial.printf("Align size: %x\n", s);
         //auto* align = (unsigned*)extmem_malloc (s);
 
+        File f = SD.open(filename, O_READ);
+        if (f) {
+            uint64_t size = f.size();
+            //uint mod = size % 1024;
+            //size = size + mod;
+            if (f.size() < _bytes_available) {
+                noInterrupts();
+                uint32_t total_read = 0;
+                auto *data = (uint32_t*)extmem_malloc( size );
+                memset(data, 0, size);
+
+                int8_t *index = (int8_t*)data + 4;
+                while (f.available()) {
+                    size_t bytesRead = f.read(index, flashloader_default_sd_buffer_size);
+                    if (bytesRead == -1)
+                        break;
+                    total_read += bytesRead;
+                    index += bytesRead;
+                }
+                interrupts();
+                _bytes_available -= total_read;
+
+                audiosample *sample = new audiosample();
+                sample->sampledata = (int16_t*)data;
+                sample->samplesize = f.size();
+
+                return sample;
+            }
+        }
+
+        Serial.printf("not found %s\n", filename);
+        return nullptr;
+    }
+
+    audiosample * flashloader::loadSampleWav(const char *filename ) {
+        Serial.printf("Reading %s\n", filename);
+        //unsigned s = ((-_lastPointer) % 512)-4;
+        //Serial.printf("Align size: %x\n", s);
+        //auto* align = (unsigned*)extmem_malloc (s);
+
         File f = SD.open(filename, O_READ);
         if (f) {
             uint64_t size = f.size();
@@ -38,9 +78,9 @@ namespace newdigate {
                 noInterrupts();
                 uint32_t total_read = 0;
                 auto *data = (uint32_t*)extmem_malloc( size + 4);
-                //_lastPointer = (uint32_t)data;
                 memset(data, 0, size + 4);
-                data[0] = (01 << 24) | size; // format == 01 PCM
+                //data[0] = (01 << 24) | size; // format == 01 PCM
+                data[0] = (0x81 << 24) | (size / 2); // format == 01 PCM
 
                 int8_t *index = (int8_t*)data + 4;
                 while (f.available()) {
@@ -57,17 +97,16 @@ namespace newdigate {
                 audiosample *sample = new audiosample();
                 sample->sampledata = (int16_t*)data;
                 sample->samplesize = f.size();
-
+/*
                 Serial.printf("\tsample start %x\n", (uint32_t)data);
                 Serial.printf("\tsample size %d\n", sample->samplesize);
                 Serial.printf("\tavailable: %d\n", _bytes_available);
-
+*/
                 return sample;
             }
         }
 
         Serial.printf("not found %s\n", filename);
         return nullptr;
     }
-*/
 }

src/flashloader.h

@@ -141,12 +141,41 @@ namespace newdigate {
             return sample;
         }
 
+        audiosample * beginAsyncLoadWav(File &file) {
+            if (!file) {
+                Serial.println("WARN: file is not open!");
+                return nullptr;
+            }
+            _currentFile = &file;
+
+            auto size = _currentFile->size();
+            uint mod = size % 512;
+            //size = size + (512 - mod);
+            size = size +  (512 - mod);
+            Serial.printf("size: %x\n", size);
+            file.seek(0);
+
+            audiosample *sample = _writeHeap->allocate(size + 4);
+            if (!sample) {
+                Serial.println("WARN: sample was not allocated");
+                return nullptr;
+            }
+            memset( sample->sampledata, 0, size + 4);
+            //((uint32_t*)(sample->sampledata))[0] = (0x81 << 24) | (size / 2); // format == 81 PCM
+            ((uint32_t*)(sample->sampledata))[0] = (0x01 << 24) | (size / 2); // format == 01 PCM
+            //((uint16_t*)(sample->sampledata))[0] = 0x81 << 8 | size/2 >> 16;
+            //((uint16_t*)(sample->sampledata))[1] = size/2 & 0xFFFF;
+            _currentSampleOffset += 4;
+            _currentReadSample = sample;
+            return sample;
+        }
+
         bool continueAsyncLoadPartial() {
             if (_currentFile && _currentReadSample) {
 
-                //AudioNoInterrupts();
-                size_t bytesRead = _currentFile->read( (int8_t*)_currentReadSample->sampledata +  _currentSampleOffset, _read_buffer_size);
-                //AudioInterrupts();
+                AudioNoInterrupts();
+                size_t bytesRead = _currentFile->read( _currentReadSample->sampledata +  _currentSampleOffset, _read_buffer_size);
+                AudioInterrupts();
 
                 _currentSampleOffset += bytesRead;
                 if (bytesRead == _read_buffer_size) {
@@ -170,18 +199,19 @@ namespace newdigate {
         // 4. call toggle_afterNewPatternStarts()
         void toggle_beforeNewPatternVoicesStart() {
             // switch the read and write heap
-            //AudioNoInterrupts();
+            AudioNoInterrupts();
             audio_chunk_heap *temp = _readHeap;
             _readHeap = _writeHeap;
             _writeHeap = temp;
-            //  AudioInterrupts();
+            AudioInterrupts();
         }
 
         void toggle_afterNewPatternStarts() const {
             _writeHeap->reset();
         }
 
-        //audiosample * loadSample(const char *filename );
+        audiosample * loadSampleWav(const char *filename );
+        audiosample * loadSample(const char *filename );
     };
 };
 #endif