revert to pass-by-pointer to prevent double collection due to copy constructors. Added Patch::getResource()

Author: Martin Klang

LibSource/Patch.cpp

@@ -6,6 +6,7 @@
 #include "PatchProcessor.h"
 #include "basicmaths.h"
 #include "main.h"
+#include "message.h"
 
 AudioBuffer::~AudioBuffer(){}
 
@@ -91,6 +92,13 @@ void Patch::sendMidi(MidiMessage msg){
 
 #endif /* USE_MIDI_CALLBACK */
 
+Resource* Patch::getResource(const char* name){
+  Resource* resource = Resource::load(name);
+  if(resource == NULL)
+    error(CONFIGURATION_ERROR_STATUS, "Missing Resource");
+  return resource;
+}
+
 #include "MemoryBuffer.hpp"
 AudioBuffer* AudioBuffer::create(int channels, int samples){
   return new ManagedMemoryBuffer(channels, samples);

LibSource/Patch.h

@@ -3,6 +3,7 @@
 
 #include "device.h"
 #include "basicmaths.h"
+#include "Resource.h"
 #include "FloatArray.h"
 #include "PatchParameter.h"
 #include "SmoothValue.h"
@@ -70,6 +71,12 @@ class Patch {
   virtual void processMidi(MidiMessage msg);
   virtual void sendMidi(MidiMessage msg);
 #endif /* USE_MIDI_CALLBACK */
+  /**
+   * Get a resource (such as a stored FloatArray) from the firmware.
+   * If the resource does not exist, this raises an error.
+   * If the resource exists but is not memory mapped, this will allocate new memory.
+   */
+  Resource* getResource(const char* name);
 };
 
 #endif // __Patch_h__

LibSource/Resource.cpp

@@ -10,39 +10,39 @@ Array Resource::asArray(size_t offset, size_t max_size) {
     // Data is expected to be aligned
     if (max_size > size - offset)
         max_size = size - offset;
-    return Array((Element*)((uint8_t*)getData() + offset), max_size / sizeof(Element));
+    return Array((Element*)(data + offset), max_size / sizeof(Element));
 }
 
 template FloatArray Resource::asArray<FloatArray, float>(size_t offset, size_t max_size);
 
-Resource::~Resource() {
-  if(allocated)
-    delete[] (uint8_t*)data;
+void Resource::destroy(Resource* resource) {
+  if(resource && resource->allocated)
+    delete[] resource->data;
 }
 
-Resource Resource::open(const char* name){
+Resource* Resource::open(const char* name){
   uint8_t* data = NULL;
   size_t offset = 0;
   size_t size = 0;
   void* args[] = {
 		  (void*)name, (void*)&data, (void*)&offset, (void*)&size
   };
   if(getProgramVector()->serviceCall(OWL_SERVICE_LOAD_RESOURCE, args, 4) == OWL_SERVICE_OK)
-    return Resource(name, size, data);
-  return Resource();
+    return new Resource(name, size, data);
+  return NULL;
 }
 
-Resource Resource::load(const char* name){
-  Resource resource = Resource::open(name);
-  if(resource.exists() && !resource.hasData()){
-    uint8_t* data = new uint8_t[resource.size];
+Resource* Resource::load(const char* name){
+  Resource* resource = Resource::open(name);
+  if(resource && !resource->hasData()){
+    uint8_t* data = new uint8_t[resource->size];
     size_t offset = 0;
     void* args[] = {
-		    (void*)name, (void*)&data, (void*)&offset, (void*)&resource.size
+		    (void*)name, (void*)&data, (void*)&offset, (void*)&resource->size
     };
     if (getProgramVector()->serviceCall(OWL_SERVICE_LOAD_RESOURCE, args, 4) == OWL_SERVICE_OK){
-      resource.data = data;
-      resource.allocated = true;
+      resource->data = data;
+      resource->allocated = true;
     }else{
       delete[] data;
     }

LibSource/Resource.h

@@ -2,6 +2,7 @@
 #define __RESOURCE_STORAGE_H__
 
 #include <cstddef>
+#include <stdint.h>
 #include "FloatArray.h"
 
 class Resource {
@@ -31,6 +32,10 @@ class Resource {
     return size != 0;
   }
 
+  bool isMutable() const {
+    return allocated;
+  }
+
   /**
    * Get resource name
    */
@@ -53,20 +58,26 @@ class Resource {
 
   /**
    * Get resource from storage.
+   * Returned object must be garbage collected with Resource::destroy()
    * 
    * @param name resource name
    * 
    * @return NULL if resource does not exist or can't be read.
    * 
    */
-  static Resource open(const char* name);
+  static Resource* open(const char* name);
 
   /**
    * Open resource and load data.
-   * Allocates extra memory if required, which will be garbage collected 
-   * in the object destructor.
+   * Allocates extra memory to hold the resource if required.
+   * Returned object must be garbage collected with Resource::destroy()
+   */
+  static Resource* load(const char* name);
+
+  /**
+   * Clean up used memory resources.
    */
-  static Resource load(const char* name);
+  static void destroy(Resource* resource);
 
   /**
    * Read data from resource into memory
@@ -82,10 +93,10 @@ class Resource {
   ~Resource();
 protected:
   Resource(const char* name, size_t size, void* data)
-    : name(name), size(size), data(data) {}
+    : name(name), size(size), data((uint8_t*)data) {}
   const char* name;
+  uint8_t* data;
   size_t size;
-  void* data;
   bool allocated;
 };
 #endif

Source/main.cpp

@@ -21,7 +21,7 @@ ProgramVector programVector __attribute__ ((section (".pv")));
 
 extern "C" {
   void vApplicationMallocFailedHook( void ){
-    error(0x60, "Memory overflow");
+    error(OUT_OF_MEMORY_ERROR_STATUS, "Memory overflow");
   }
 }