owl_patch 0.8.0

Rust SDK for Rebel Technology Owl2/3 devices
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

#include <cstddef>
#include <string.h>
#include "Patch.h"
#include "device.h"
#include "ProgramVector.h"
#include "PatchProcessor.h"
#include "basicmaths.h"
#include "main.h"
#include "message.h"

AudioBuffer::~AudioBuffer(){}

PatchProcessor* getInitialisingPatchProcessor();

Patch::Patch(){}

Patch::~Patch(){}

void Patch::registerParameter(PatchParameterId pid, const char* name){
  if(getProgramVector()->registerPatchParameter != NULL)
    getProgramVector()->registerPatchParameter(pid, name);
}

float Patch::getSampleRate(){
  return getProgramVector()->audio_samplingrate;
}

float Patch::getBlockRate(){
  return getSampleRate()/getBlockSize();
}

int Patch::getBlockSize(){
  return getProgramVector()->audio_blocksize;
}

int Patch::getNumberOfChannels(){
  uint8_t format = getProgramVector()->audio_format;
  if((format & 0xf0) == AUDIO_FORMAT_24B32 && (format & 0x0f) > 0)
    return format & 0x0f;
  return 2;
}

float Patch::getParameterValue(PatchParameterId pid){
  //  return getInitialisingPatchProcessor()->getParameterValue(pid);
  // if(pid < getProgramVector()->parameters_size)
  if(pid < getProgramVector()->parameters_size){
    if(getProgramVector()->hardware_version == OWL_MODULAR_HARDWARE && pid < 4){
      return (4095 - getProgramVector()->parameters[pid])/4096.0f;
    }else{
      return getProgramVector()->parameters[pid]/4096.0f;
    }
  }
  return 0.0f;
}

void Patch::setParameterValue(PatchParameterId pid, float value){
  if(getProgramVector()->hardware_version == OWL_MODULAR_HARDWARE && pid < 4)
    doSetPatchParameter(pid, 4095 - (int16_t)(value*4096.0f));
  else
    doSetPatchParameter(pid, (int16_t)(value*4096));
}

void Patch::setButton(PatchButtonId bid, uint16_t value, uint16_t samples){
  doSetButton(bid, value, samples);
}

bool Patch::isButtonPressed(PatchButtonId bid){
  return getProgramVector()->buttons & (1<<bid);
}

int Patch::getSamplesSinceButtonPressed(PatchButtonId bid){
  // deprecated
  return 0;
}

AudioBuffer* Patch::createMemoryBuffer(int channels, int samples){
  return AudioBuffer::create(channels, samples);
}

#define DWT_CYCCNT ((volatile unsigned int *)0xE0001004)

float Patch::getElapsedBlockTime(){
  return (*DWT_CYCCNT)/getBlockSize()/3500.0;
}

int Patch::getElapsedCycles(){
  return *DWT_CYCCNT;
}

#ifdef USE_MIDI_CALLBACK
void Patch::processMidi(MidiMessage msg){}

void Patch::sendMidi(MidiMessage msg){
  doMidiSend(msg.data[0], msg.data[1], msg.data[2], msg.data[3]);
}

#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);
}

void AudioBuffer::destroy(AudioBuffer* buffer){
  delete buffer;
}

FloatParameter Patch::getParameter(const char* name, float defaultValue){
  return getFloatParameter(name, 0.0f, 1.0f, defaultValue, 0.0f, 0.0f, LIN);
}

FloatParameter Patch::getFloatParameter(const char* name, float min, float max, float defaultValue, float lambda, float delta, float skew){
  return getInitialisingPatchProcessor()->getParameter(name, min, max, defaultValue, lambda, delta, skew);
}

IntParameter Patch::getIntParameter(const char* name, int min, int max, int defaultValue, float lambda, float delta, float skew){
  return getInitialisingPatchProcessor()->getParameter(name, min, max, defaultValue, lambda, delta, skew);
}

const float Patch::EXP = 0.5;
const float Patch::LIN = 1.0;
const float Patch::LOG = 2.0;
const uint16_t Patch::ON = 4095;
const uint16_t Patch::OFF = 0;