OwlProgram/LibSource/Patch.cpp at 1c174136986850ced4d2e90b5a2c194b502ec94e · RebelTechnology/OwlProgram · GitHub

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
132
133
#include <cstddef>
#include <string.h>
#include "Patch.h"
#include "device.h"
#include "ProgramVector.h"
#include "PatchProcessor.h"
#include "basicmaths.h"
#include "main.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;
}

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

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()/(float)5000;
}

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

#ifdef USE_SCREEN
  void drawMessage(ScreenBuffer& screen){
    ProgramVector* pv = getProgramVector();
    if(pv->message != NULL){
      screen.setTextSize(1);
      screen.setTextWrap(true);
      screen.print(0, 26, pv->message);
    }
  }
  void drawTitle(const char* title, ScreenBuffer& screen){
    // draw title
    screen.setTextSize(2);
    screen.print(0, 16, title);
  }
void Patch::processScreen(ScreenBuffer& screen){
  // screen.clear();
  const char* title = getInitialisingPatchProcessor()->getPatchName();
  drawTitle(title, screen);
  drawMessage(screen);
  // const char title[] = "KickBox";
  // screen.setTextSize(2);
  // screen.print(0, 16, title);
}
#endif /* USE_SCREEN */

#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 */

#include "MemoryBuffer.hpp"
AudioBuffer* AudioBuffer::create(int channels, int samples){
  return new ManagedMemoryBuffer(channels, samples);
}

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;