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

#ifndef __FeedbackProcessor_h__
#define __FeedbackProcessor_h__

#include <utility>
#include "SignalProcessor.h"
#include "DcBlockingFilter.h"

template<class Processor>
class FeedbackSignalProcessor : public Processor {
protected:
  FloatArray feedback_buffer;
  float feedback_amount;
public:
  template <typename... Args>
  FeedbackSignalProcessor(FloatArray buffer, Args&&... args) :
    Processor(std::forward<Args>(args)...), feedback_buffer(buffer), feedback_amount(0) {}
  void setFeedback(float amount){
    feedback_amount = amount;
  }
  float getFeedback(){
    return feedback_amount;
  }
  void process(FloatArray input, FloatArray output){
    feedback_buffer.multiply(feedback_amount);
    input.add(feedback_buffer);
    Processor::process(input, output);
    feedback_buffer.copyFrom(output);
  }
  template <typename... Args>
  static FeedbackSignalProcessor<Processor>* create(size_t blocksize, Args&&... args){
    return new FeedbackSignalProcessor<Processor>(FloatArray::create(blocksize), std::forward<Args>(args)...);
  }
  static void destroy(FeedbackSignalProcessor<Processor>* obj){
    FloatArray::destroy(obj->feedback_buffer);
    Processor::destroy(obj);
  }
};

class StereoFeedbackProcessor : public MultiSignalProcessor {
protected:
  SignalProcessor* processor_left;
  SignalProcessor* processor_right;
  FloatArray feedback_left;
  FloatArray feedback_right;
  float feedback_amount;
public:
  template <typename... Args>
  StereoFeedbackProcessor(SignalProcessor* left, SignalProcessor* right,
			  FloatArray fbl, FloatArray fbr) :
    processor_left(left), processor_right(right), feedback_left(fbl), feedback_right(fbr) {}
  void setFeedback(float amount){
    feedback_amount = amount;
  }
  float getFeedback(){
    return feedback_amount;
  }
  void process(AudioBuffer& input, AudioBuffer& output){
    FloatArray input_left = input.getSamples(LEFT_CHANNEL);
    FloatArray output_left = output.getSamples(LEFT_CHANNEL);
    feedback_left.multiply(feedback_amount);
    input_left.add(feedback_left);
    processor_left->process(input_left, output_left);
    FloatArray input_right = input.getSamples(RIGHT_CHANNEL);
    FloatArray output_right = output.getSamples(RIGHT_CHANNEL);
    feedback_right.multiply(feedback_amount);
    input_right.add(feedback_right);
    processor_right->process(input_right, output_right);
    feedback_left.copyFrom(output_left);
    feedback_right.copyFrom(output_right);
  }
  static StereoFeedbackProcessor* create(SignalProcessor* left, SignalProcessor* right, size_t blocksize){
    return new StereoFeedbackProcessor(left, right, FloatArray::create(blocksize), FloatArray::create(blocksize));
  }
  static void destroy(StereoFeedbackProcessor* obj){
    FloatArray::destroy(obj->feedback_left);
    FloatArray::destroy(obj->feedback_right);
    delete obj;
  }
};

class PingPongFeedbackProcessor : public MultiSignalProcessor {
protected:
  DcBlockingFilter dc_left;
  DcBlockingFilter dc_right;
  SignalProcessor* processor_left;
  SignalProcessor* processor_right;
  FloatArray feedback_left;
  FloatArray feedback_right;
  float feedback_amount;
public:
  template <typename... Args>
  PingPongFeedbackProcessor(SignalProcessor* left, SignalProcessor* right,
				  FloatArray fbl, FloatArray fbr) :
    processor_left(left), processor_right(right), feedback_left(fbl), feedback_right(fbr) {}
  void setFeedback(float amount){
    feedback_amount = amount;
  }
  float getFeedback(){
    return feedback_amount;
  }
  void process(AudioBuffer& input, AudioBuffer& output){
    FloatArray input_left = input.getSamples(LEFT_CHANNEL);
    FloatArray output_left = output.getSamples(LEFT_CHANNEL);
    feedback_left.multiply(feedback_amount);
    input_left.add(feedback_left);
    processor_left->process(input_left, output_left);
    FloatArray input_right = input.getSamples(RIGHT_CHANNEL);
    FloatArray output_right = output.getSamples(RIGHT_CHANNEL);
    feedback_right.multiply(feedback_amount);
    input_right.add(feedback_right);
    processor_right->process(input_right, output_right);
    feedback_left.copyFrom(output_right);
    dc_left.process(feedback_left);
    feedback_right.copyFrom(output_left);
    dc_right.process(feedback_right);
  }
  static PingPongFeedbackProcessor* create(SignalProcessor* left, SignalProcessor* right, size_t blocksize){
    return new PingPongFeedbackProcessor(left, right, FloatArray::create(blocksize), FloatArray::create(blocksize));
  }
  static void destroy(PingPongFeedbackProcessor* obj){
    FloatArray::destroy(obj->feedback_left);
    FloatArray::destroy(obj->feedback_right);
    delete obj;
  }
};

#endif // __FeedbackProcessor_h__