/*
* Copyright 2012 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <iostream>
#include <cstdlib>
#include <math.h>
#include "synth.h"
#include "module.h"
#include "freqlut.h"
#include "wavout.h"
#include "sawtooth.h"
#include "sin.h"
#include "resofilter.h"
#include "fm_core.h"
#include "fm_op_kernel.h"
#include "env.h"
#include "dx7note.h"
using namespace std;
void benchmark_sin() {
int32_t x;
for (int j = 0; j < 1000; j++) {
for (int i = 0; i < 1000000; i++) {
x += Sin::lookup(i);
}
}
cout << x << endl; // to make sure it gets used
}
void benchmark_fm_op() {
int32_t buf[64];
int32_t fb_buf[2];
for (int i = 0; i < 15625000; i++)
FmOpKernel::compute_fb(buf, 0, 123456, 1 << 24, 1 << 24,
fb_buf, 1, false);
}
void test_sin_accuracy() {
double maxerr = 0;
for (int i = 0; i < 1000000; i++) {
int32_t phase = rand() & ((1 << 24) - 1);
int32_t y = Sin::compute(phase);
double yd = (1 << 24) * sin(phase * (M_PI / (1 << 23)));
double err = fabs(y - yd);
if (err > maxerr) maxerr = err;
}
cout << "Max error: " << maxerr;
}
void test_pure_accuracy() {
int32_t worstfreq;
int32_t worstphase;
int32_t worsterr = 0;
double errsum = 0;
for (int i = 0; i < 1000000; i++) {
int32_t freq = rand() & 0x7fffff;
int32_t phase = rand() & 0xffffff;
int32_t gain = 1 << 24;
int32_t buf[64];
FmOpKernel::compute_pure(buf, phase, freq, gain, gain, false);
int32_t maxerr = 0;
for (int j = 0; j < 64; j++) {
double y = gain * sin((phase + j * freq) * (2.0 * M_PI / (1 << 24)));
int32_t accurate = (int32_t)floor(y + 0.5);
int32_t err = abs(buf[j] - accurate);
if (err > maxerr) maxerr = err;
}
errsum += maxerr;
if (maxerr > worsterr) {
worsterr = maxerr;
worstfreq = freq;
worstphase = phase;
}
if (i < 10)
cout << phase << " " << freq << " " << maxerr << endl;
}
cout << worstphase << " " << worstfreq << " " << worsterr << endl;
cout << "Mean: " << (errsum * 1e-6) << endl;
}
void mksaw(double sample_rate) {
const int n_samples = 400 * 1024;
WavOut w("/tmp/foo.wav", sample_rate, n_samples);
Sawtooth s;
int32_t control_last[1];
int32_t control[1];
ResoFilter rf;
int32_t fc_last[2];
int32_t fc[2];
fc[0] = 0; // TODO
fc[1] = 4.2 * (1 << 24);
fc_last[0] = fc[0];
fc_last[1] = fc[1];
double ramp = 1e-7;
double f = ramp * (64 + 1);
control[0] = (1 << 24) * log(f * sample_rate) / log(2);
int32_t buf[64];
int32_t buf2[64];
int32_t *bufs[1];
int32_t *bufs2[1];
bufs[0] = buf;
bufs2[0] = buf2;
int32_t phase = 0;
for (int i = 0; i < n_samples; i += 64) {
double f = ramp * (i + 64 + 1);
// f = 44.0 / sample_rate;
control_last[0] = control[0];
control[0] = (1 << 24) * log(f * sample_rate) / log(2);
fc_last[1] = fc[1];
fc[1] = 4.0 * i * (1 << 24) / n_samples;
s.process((const int32_t **)0, control, control_last, bufs);
rf.process((const int32_t **)bufs, fc, fc_last, bufs2);
for (int j = 0; j < 64; j++) {
buf2[j] = buf[j] >> 1;
//phase += 100000;
//buf2[j] = (Sin::compute(phase) - (int32_t)((1<< 24) * sin(phase * 2 * M_PI / (1 << 24)))) << 12;
}
w.write_data(buf2, 64);
}
w.close();
}
void mknote(double sample_rate) {
const int n_samples = 400 * 1024;
WavOut w("/tmp/foo.wav", sample_rate, n_samples);
int32_t freq = 150358;
int32_t phase = 0;
int rates[4] = {70, 50, 30, 80};
int levels[4] = {99, 90, 70, 0};
Env e;
e.init(rates, levels, 99, 0);
int rates2[4] = {70, 50, 30, 80};
int levels2[4] = {99, 90, 70, 0};
Env e2;
e2.init(rates, levels, 90, 0);
int32_t buf[64];
int32_t gain1, gain2;
gain2 = 0;
int32_t gain21, gain22;
gain22 = 0;
for (int i = 0; i < n_samples; i += N) {
gain1 = gain2;
gain21 = gain22;
if (i == n_samples / 2) {
e.keydown(false);
e2.keydown(false);
}
int32_t level = e.getsample();
gain2 = (1<<8) * pow(2, level * (1.0 / (1 << 24)));
FmOpKernel::compute_pure(buf, phase, freq, gain1, gain2, false);
level = e2.getsample();
gain22 = (1<<8) * pow(2, level * (1.0 / (1 << 24)));
FmOpKernel::compute(buf, buf, phase, freq, gain21, gain22, false);
phase += freq << LG_N;
w.write_data(buf, N);
}
w.close();
}
char epiano[] = {
95, 29, 20, 50, 99, 95, 0, 0, 41, 0, 19, 0, 115, 24, 79, 2, 0, 95, 20, 20,
50, 99, 95, 0, 0, 0, 0, 0, 0, 3, 0, 99, 2, 0, 95, 29, 20, 50, 99, 95, 0, 0,
0, 0, 0, 0, 59, 24, 89, 2, 0, 95, 20, 20, 50, 99, 95, 0, 0, 0, 0, 0, 0, 59,
8, 99, 2, 0, 95, 50, 35, 78, 99, 75, 0, 0, 0, 0, 0, 0, 59, 28, 58, 28, 0, 96,
25, 25, 67, 99, 75, 0, 0, 0, 0, 0, 0, 83, 8, 99, 2, 0, 94, 67, 95, 60, 50,
50, 50, 50, 4, 6, 34, 33, 0, 0, 56, 24, 69, 46, 80, 73, 65, 78, 79, 32, 49,
32
};
void mkdx7note(double sample_rate) {
const int n_samples = 400 * 1024;
WavOut w("/tmp/foo.wav", sample_rate, n_samples);
Dx7Note note(epiano, 57, 64);
int32_t buf[N];
for (int i = 0; i < n_samples; i += N) {
for (int j = 0; j < N; j++) {
buf[j] = 0;
}
if (i == n_samples / 2) {
note.keyup();
}
note.compute(buf);
for (int j = 0; j < N; j++) {
buf[j] >>= 2;
}
w.write_data(buf, N);
}
w.close();
}
void test_ringbuffer();
int main(int argc, char **argv) {
double sample_rate = 44100.0;
Freqlut::init(sample_rate);
Sawtooth::init(sample_rate);
Sin::init();
//FmCore::dump();
//test_sin_accuracy();
//benchmark_fm_op();
//test_pure_accuracy();
//benchmark_sin();
//int32_t freq = atoi(argv[1]);
//cout << "Logfreq(" << freq << ") = " << Freqlut::lookup(freq) << endl;
//mkdx7note(sample_rate);
mksaw(sample_rate);
//test_ringbuffer();
return 0;
}