deepblue/samplebrain
1
0
Fork 0
mirror of https://gitlab.com/then-try-this/samplebrain.git synced 2025-05-12 10:37:20 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

started work on live input

Browse Source
This commit is contained in:
dave griffiths 2016-07-08 11:41:30 +01:00
parent b146f869c8
commit 3deaf9ac1e
23 changed files with 1256 additions and 978 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
samplebrain/interface/samplebrain.ui
View File

@ -7,11 +7,11 @@
<x>0</x>
<y>0</y>
<width>910</width>
<height>669</height>
<height>671</height>
</rect>
</property>
<property name="windowTitle">
<string>samplebrain 0.16</string>
<string>samplebrain 0.17</string>
</property>
<widget class="QWidget" name="centralwidget">
<layout class="QVBoxLayout" name="verticalLayout_4">
@ -865,6 +865,18 @@
</property>
</widget>
</item>
<item>
<widget class="QCheckBox" name="mic">
<property name="font">
<font>
<family>Comic Sans MS</family>
</font>
</property>
<property name="text">
<string>use mic input</string>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="label_23">
<property name="font">
@ -1384,7 +1396,24 @@
</attribute>
<layout class="QHBoxLayout" name="horizontalLayout_15">
<item>
<layout class="QVBoxLayout" name="netContainer"/>
<layout class="QVBoxLayout" name="verticalLayout_7">
<item>
<layout class="QVBoxLayout" name="netContainer"/>
</item>
<item>
<widget class="QLabel" name="label_4">
<property name="sizePolicy">
<sizepolicy hsizetype="Preferred" vsizetype="Maximum">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="text">
<string>This program is free software made in Cornwall by &lt;a href=&quot;http://fo.am/kernow&quot;&gt;FoAM Kernow&lt;/a&gt;</string>
</property>
</widget>
</item>
</layout>
</item>
</layout>
</widget>
@ -2407,6 +2436,22 @@
</hint>
</hints>
</connection>
<connection>
<sender>mic</sender>
<signal>clicked(bool)</signal>
<receiver>MainWindow</receiver>
<slot>mic(bool)</slot>
<hints>
<hint type="sourcelabel">
<x>404</x>
<y>601</y>
</hint>
<hint type="destinationlabel">
<x>454</x>
<y>335</y>
</hint>
</hints>
</connection>
</connections>
<slots>
<slot>play_slot()</slot>
@ -2463,5 +2508,6 @@
<slot>load_sounds()</slot>
<slot>select_all()</slot>
<slot>select_none()</slot>
<slot>mic(bool)</slot>
</slots>
</ui>

1
samplebrain/qt/MainWindow.h
View File

@ -239,6 +239,7 @@ private slots:
void brain_shape(int n) { send_process_osc("/window_type","i",n); }
void target_shape(int n) { send_process_osc("/target_window_type","i",n); }
void mic(bool n) { send_audio_osc("/mic","i",(int)n); }
void record() {
if (m_save_wav=="") {

35
samplebrain/qt/audio_thread.cpp
View File

@ -25,12 +25,14 @@ audio_thread::audio_thread(process_thread &p) :
m_osc("8888"),
m_process_thread(p),
m_brain_mutex(p.m_brain_mutex),
m_stereo_mode(false)
m_stereo_mode(false),
m_mic_mode(false)
{
start_audio();
pthread_mutex_lock(m_brain_mutex);
m_left_renderer = new renderer(p.m_source,p.m_left_target);
m_right_renderer = new renderer(p.m_source,p.m_right_target);
m_block_stream = new block_stream();
pthread_mutex_unlock(m_brain_mutex);
m_osc.run();
}
@ -54,13 +56,15 @@ void audio_thread::run_audio(void* c, unsigned int frames) {
if (state) {
audio_thread *at = (audio_thread*)c;
at->m_audio_device->left_out.zero();
at->process(at->m_audio_device->left_out,
at->process(at->m_audio_device->left_in,
at->m_audio_device->right_in,
at->m_audio_device->left_out,
at->m_audio_device->right_out);
at->m_audio_device->maybe_record();
}
}
void audio_thread::process(sample &s, sample &s2) {
void audio_thread::process(sample &left_in, sample &right_in, sample &left_out, sample &right_out) {
command_ring_buffer::command cmd;
while (m_osc.get(cmd)) {
@ -162,16 +166,31 @@ void audio_thread::process(sample &s, sample &s2) {
m_left_renderer->reset();
m_right_renderer->reset();
}
if (name=="/mic") {
m_mic_mode = cmd.get_int(0);
}
}
s.zero();
s2.zero();
left_out.zero();
right_out.zero();
if (!pthread_mutex_trylock(m_brain_mutex)) {
m_left_renderer->process(s.get_length(),s.get_non_const_buffer());
block_stream *bs=NULL;
if (m_mic_mode) {
m_block_stream->process(left_in,right_in);
bs = m_block_stream;
}
m_left_renderer->process(left_out.get_length(),
left_out.get_non_const_buffer(),
bs);
if (m_stereo_mode) {
m_right_renderer->process(s2.get_length(),s2.get_non_const_buffer());
m_right_renderer->process(right_out.get_length(),
right_out.get_non_const_buffer(),
bs);
} else {
s2=s;
right_out=left_out;
}
pthread_mutex_unlock(m_brain_mutex);
} else {

5
samplebrain/qt/audio_thread.h
View File

@ -17,6 +17,7 @@
#include "jellyfish/OSC_server.h"
#include "process_thread.h"
#include "renderer.h"
#include "block_stream.h"
#include "jellyfish/audio.h"
#pragma once
@ -28,13 +29,14 @@ public:
audio_thread(process_thread &p);
~audio_thread();
void process(sample &left, sample &right);
void process(sample &left_in, sample &right_in, sample &left_out, sample &right_out);
static void run_audio(void* c, unsigned int frames);
audio_device *m_audio_device;
renderer *m_left_renderer;
renderer *m_right_renderer;
block_stream *m_block_stream;
private:
void start_audio();
@ -43,6 +45,7 @@ private:
process_thread &m_process_thread;
pthread_mutex_t* m_brain_mutex;
bool m_stereo_mode;
bool m_mic_mode;
};
}

43
samplebrain/qt/generated/ui_samplebrain.h
View File

@ -1,13 +1,13 @@
/********************************************************************************
** Form generated from reading UI file 'samplebrainr24659.ui'
** Form generated from reading UI file 'samplebrainr15646.ui'
**
** Created by: Qt User Interface Compiler version 4.8.6
**
** WARNING! All changes made in this file will be lost when recompiling UI file!
********************************************************************************/
#ifndef SAMPLEBRAINR24659_H
#define SAMPLEBRAINR24659_H
#ifndef SAMPLEBRAINR15646_H
#define SAMPLEBRAINR15646_H
#include <QtCore/QVariant>
#include <QtGui/QAction>
@ -99,6 +99,7 @@ public:
QLabel *label_14;
QComboBox *comboBoxTargetShape;
QPushButton *pushButtonGenerateTarget;
QCheckBox *mic;
QLabel *label_23;
QHBoxLayout *horizontalLayout_22;
QLabel *label_31;
@ -143,7 +144,9 @@ public:
QSpacerItem *verticalSpacer_2;
QWidget *netTab;
QHBoxLayout *horizontalLayout_15;
QVBoxLayout *verticalLayout_7;
QVBoxLayout *netContainer;
QLabel *label_4;
QHBoxLayout *horizontalLayout_12;
QPushButton *pushButtonPlay;
QPushButton *pushButtonStop;
@ -161,7 +164,7 @@ public:
{
if (MainWindow->objectName().isEmpty())
MainWindow->setObjectName(QString::fromUtf8("MainWindow"));
MainWindow->resize(910, 669);
MainWindow->resize(910, 671);
centralwidget = new QWidget(MainWindow);
centralwidget->setObjectName(QString::fromUtf8("centralwidget"));
verticalLayout_4 = new QVBoxLayout(centralwidget);
@ -588,6 +591,14 @@ public:
verticalLayout_6->addWidget(pushButtonGenerateTarget);
mic = new QCheckBox(controlTab);
mic->setObjectName(QString::fromUtf8("mic"));
QFont font3;
font3.setFamily(QString::fromUtf8("Comic Sans MS"));
mic->setFont(font3);
verticalLayout_6->addWidget(mic);
label_23 = new QLabel(controlTab);
label_23->setObjectName(QString::fromUtf8("label_23"));
label_23->setFont(font1);
@ -852,10 +863,25 @@ public:
netTab->setObjectName(QString::fromUtf8("netTab"));
horizontalLayout_15 = new QHBoxLayout(netTab);
horizontalLayout_15->setObjectName(QString::fromUtf8("horizontalLayout_15"));
verticalLayout_7 = new QVBoxLayout();
verticalLayout_7->setObjectName(QString::fromUtf8("verticalLayout_7"));
netContainer = new QVBoxLayout();
netContainer->setObjectName(QString::fromUtf8("netContainer"));
horizontalLayout_15->addLayout(netContainer);
verticalLayout_7->addLayout(netContainer);
label_4 = new QLabel(netTab);
label_4->setObjectName(QString::fromUtf8("label_4"));
QSizePolicy sizePolicy3(QSizePolicy::Preferred, QSizePolicy::Maximum);
sizePolicy3.setHorizontalStretch(0);
sizePolicy3.setVerticalStretch(0);
sizePolicy3.setHeightForWidth(label_4->sizePolicy().hasHeightForWidth());
label_4->setSizePolicy(sizePolicy3);
verticalLayout_7->addWidget(label_4);
horizontalLayout_15->addLayout(verticalLayout_7);
tabWidget->addTab(netTab, QString());
@ -1000,6 +1026,7 @@ public:
QObject::connect(pushButtonLoadSounds, SIGNAL(released()), MainWindow, SLOT(load_sounds()));
QObject::connect(toolButtonAll, SIGNAL(released()), MainWindow, SLOT(select_all()));
QObject::connect(toolButtonNone, SIGNAL(released()), MainWindow, SLOT(select_none()));
QObject::connect(mic, SIGNAL(clicked(bool)), MainWindow, SLOT(mic(bool)));
tabWidget->setCurrentIndex(0);
@ -1009,7 +1036,7 @@ public:
void retranslateUi(QMainWindow *MainWindow)
{
MainWindow->setWindowTitle(QApplication::translate("MainWindow", "samplebrain 0.16", 0, QApplication::UnicodeUTF8));
MainWindow->setWindowTitle(QApplication::translate("MainWindow", "samplebrain 0.17", 0, QApplication::UnicodeUTF8));
label_19->setText(QApplication::translate("MainWindow", "brain tweaks", 0, QApplication::UnicodeUTF8));
label_6->setText(QApplication::translate("MainWindow", "fft / mfcc", 0, QApplication::UnicodeUTF8));
#ifndef QT_NO_TOOLTIP
@ -1107,6 +1134,7 @@ public:
<< QApplication::translate("MainWindow", "rectangle", 0, QApplication::UnicodeUTF8)
);
pushButtonGenerateTarget->setText(QApplication::translate("MainWindow", "(re)generate blocks", 0, QApplication::UnicodeUTF8));
mic->setText(QApplication::translate("MainWindow", "use mic input", 0, QApplication::UnicodeUTF8));
label_23->setText(QApplication::translate("MainWindow", "mix", 0, QApplication::UnicodeUTF8));
label_31->setText(QApplication::translate("MainWindow", "autotune", 0, QApplication::UnicodeUTF8));
#ifndef QT_NO_TOOLTIP
@ -1145,6 +1173,7 @@ public:
pushButtonLoadBrain->setText(QApplication::translate("MainWindow", "load brain", 0, QApplication::UnicodeUTF8));
pushButtonSaveBrain->setText(QApplication::translate("MainWindow", "save brain", 0, QApplication::UnicodeUTF8));
tabWidget->setTabText(tabWidget->indexOf(controlTab), QApplication::translate("MainWindow", "search", 0, QApplication::UnicodeUTF8));
label_4->setText(QApplication::translate("MainWindow", "This program is free software made in Cornwall by <a href=\"http://fo.am/kernow\">FoAM Kernow</a>", 0, QApplication::UnicodeUTF8));
tabWidget->setTabText(tabWidget->indexOf(netTab), QApplication::translate("MainWindow", "net", 0, QApplication::UnicodeUTF8));
pushButtonPlay->setText(QString());
pushButtonStop->setText(QString());
@ -1163,4 +1192,4 @@ namespace Ui {
QT_END_NAMESPACE
#endif // SAMPLEBRAINR24659_H
#endif // SAMPLEBRAINR15646_H

289
samplebrain/qt/process_thread.cpp
View File

@ -23,176 +23,181 @@ using namespace spiralcore;
using namespace std;
static void _process(void *c) {
process_thread *p=(process_thread*)c;
p->process();
process_thread *p=(process_thread*)c;
p->process();
}
process_thread::process_thread() :
m_osc("8889"),
m_source_block_size(3000),
m_source_overlap(0.75),
m_target_block_size(3000),
m_target_overlap(0.75),
m_window_type(window::DODGY),
m_target_window_type(window::DODGY)
m_osc("8889"),
m_source_block_size(3000),
m_source_overlap(0.75),
m_target_block_size(3000),
m_target_overlap(0.75),
m_window_type(window::DODGY),
m_target_window_type(window::DODGY)
{
m_brain_mutex = new pthread_mutex_t;
pthread_mutex_init(m_brain_mutex,NULL);
m_osc.run();
// start the processing thread
m_thread = new pthread_t;
pthread_create(m_thread,NULL,(void*(*)(void*))_process,this);
m_brain_mutex = new pthread_mutex_t;
pthread_mutex_init(m_brain_mutex,NULL);
m_osc.run();
// start the processing thread
m_thread = new pthread_t;
pthread_create(m_thread,NULL,(void*(*)(void*))_process,this);
}
process_thread::~process_thread() {
pthread_cancel(*m_thread);
delete m_brain_mutex;
pthread_cancel(*m_thread);
delete m_brain_mutex;
}
void process_thread::process() {
command_ring_buffer::command cmd;
command_ring_buffer::command cmd;
while(true) {
while (m_osc.get(cmd)) {
string name = cmd.m_name;
//cerr<<name<<endl;
if (name=="/load_sample") {
pthread_mutex_lock(m_brain_mutex);
m_source.load_sound(cmd.get_string(0),brain::MIX);
pthread_mutex_unlock(m_brain_mutex);
}
if (name=="/delete_sample") {
pthread_mutex_lock(m_brain_mutex);
m_source.delete_sound(cmd.get_string(0));
pthread_mutex_unlock(m_brain_mutex);
}
if (name=="/activate_sound") {
pthread_mutex_lock(m_brain_mutex);
m_source.activate_sound(cmd.get_string(0),1);
pthread_mutex_unlock(m_brain_mutex);
}
if (name=="/deactivate_sound") {
pthread_mutex_lock(m_brain_mutex);
m_source.activate_sound(cmd.get_string(0),0);
pthread_mutex_unlock(m_brain_mutex);
}
if (name=="/source_block_size") {
m_source_block_size = cmd.get_int(0);
}
if (name=="/source_overlap") {
m_source_overlap = m_source_block_size*cmd.get_float(0);
}
if (name=="/generate_brain") {
pthread_mutex_lock(m_brain_mutex);
m_source.init(m_source_block_size, m_source_overlap, m_window_type);
search_params p(1,0,0,100,0);
m_source.build_synapses_fixed(p);
m_left_renderer->reset();
m_right_renderer->reset();
pthread_mutex_unlock(m_brain_mutex);
}
if (name=="/load_target") {
pthread_mutex_lock(m_brain_mutex);
m_left_target.clear_sounds();
m_left_target.load_sound(cmd.get_string(0),brain::LEFT);
m_right_target.clear_sounds();
m_right_target.load_sound(cmd.get_string(0),brain::RIGHT);
pthread_mutex_unlock(m_brain_mutex);
}
if (name=="/target_block_size") {
m_target_block_size = cmd.get_int(0);
}
if (name=="/target_overlap") {
m_target_overlap = m_target_block_size*cmd.get_float(0);
}
if (name=="/generate_target") {
pthread_mutex_lock(m_brain_mutex);
m_left_target.init(m_target_block_size, m_target_overlap, m_target_window_type);
m_right_target.init(m_target_block_size, m_target_overlap, m_target_window_type);
pthread_mutex_unlock(m_brain_mutex);
}
if (name=="/window_type") {
m_window_type=(window::type)cmd.get_int(0);
}
if (name=="/target_window_type") {
m_target_window_type=(window::type)cmd.get_int(0);
}
if (name=="/load_brain") {
load_source(cmd.get_string(0));
}
if (name=="/save_brain") {
save_source(cmd.get_string(0));
}
if (name=="/load_session") {
load_session(cmd.get_string(0));
}
if (name=="/save_session") {
save_session(cmd.get_string(0));
}
}
usleep(500);
while(true) {
while (m_osc.get(cmd)) {
string name = cmd.m_name;
//cerr<<name<<endl;
if (name=="/load_sample") {
pthread_mutex_lock(m_brain_mutex);
m_source.load_sound(cmd.get_string(0),brain::MIX);
pthread_mutex_unlock(m_brain_mutex);
}
if (name=="/delete_sample") {
pthread_mutex_lock(m_brain_mutex);
m_source.delete_sound(cmd.get_string(0));
pthread_mutex_unlock(m_brain_mutex);
}
if (name=="/activate_sound") {
pthread_mutex_lock(m_brain_mutex);
m_source.activate_sound(cmd.get_string(0),1);
pthread_mutex_unlock(m_brain_mutex);
}
if (name=="/deactivate_sound") {
pthread_mutex_lock(m_brain_mutex);
m_source.activate_sound(cmd.get_string(0),0);
pthread_mutex_unlock(m_brain_mutex);
}
if (name=="/source_block_size") {
m_source_block_size = cmd.get_int(0);
}
if (name=="/source_overlap") {
m_source_overlap = m_source_block_size*cmd.get_float(0);
}
if (name=="/generate_brain") {
pthread_mutex_lock(m_brain_mutex);
m_source.init(m_source_block_size, m_source_overlap, m_window_type);
search_params p(1,0,0,100,0);
m_source.build_synapses_fixed(p);
m_left_renderer->reset();
m_right_renderer->reset();
pthread_mutex_unlock(m_brain_mutex);
}
if (name=="/load_target") {
pthread_mutex_lock(m_brain_mutex);
m_left_target.clear_sounds();
m_left_target.load_sound(cmd.get_string(0),brain::LEFT);
m_right_target.clear_sounds();
m_right_target.load_sound(cmd.get_string(0),brain::RIGHT);
pthread_mutex_unlock(m_brain_mutex);
}
if (name=="/target_block_size") {
m_target_block_size = cmd.get_int(0);
m_block_stream->init(m_target_block_size, m_target_overlap, m_target_window_type);
}
if (name=="/target_overlap") {
m_target_overlap = m_target_block_size*cmd.get_float(0);
m_block_stream->init(m_target_block_size, m_target_overlap, m_target_window_type);
}
if (name=="/generate_target") {
pthread_mutex_lock(m_brain_mutex);
m_left_target.init(m_target_block_size, m_target_overlap, m_target_window_type);
m_right_target.init(m_target_block_size, m_target_overlap, m_target_window_type);
// probably elsewhere
m_block_stream->init(m_target_block_size, m_target_overlap, m_target_window_type);
pthread_mutex_unlock(m_brain_mutex);
}
if (name=="/window_type") {
m_window_type=(window::type)cmd.get_int(0);
}
if (name=="/target_window_type") {
m_target_window_type=(window::type)cmd.get_int(0);
m_block_stream->init(m_target_block_size, m_target_overlap, m_target_window_type);
}
if (name=="/load_brain") {
load_source(cmd.get_string(0));
}
if (name=="/save_brain") {
save_source(cmd.get_string(0));
}
if (name=="/load_session") {
load_session(cmd.get_string(0));
}
if (name=="/save_session") {
save_session(cmd.get_string(0));
}
}
usleep(500);
}
}
void process_thread::load_source(const std::string &filename) {
pthread_mutex_lock(m_brain_mutex);
m_source.clear();
ifstream ifs(filename.c_str(),ios::binary);
ifs||m_source;
ifs.close();
pthread_mutex_unlock(m_brain_mutex);
pthread_mutex_lock(m_brain_mutex);
m_source.clear();
ifstream ifs(filename.c_str(),ios::binary);
ifs||m_source;
ifs.close();
pthread_mutex_unlock(m_brain_mutex);
}
void process_thread::save_source(const std::string &filename) {
pthread_mutex_lock(m_brain_mutex);
ofstream ofs(filename.c_str(),ios::binary);
ofs||m_source;
ofs.close();
pthread_mutex_unlock(m_brain_mutex);
pthread_mutex_lock(m_brain_mutex);
ofstream ofs(filename.c_str(),ios::binary);
ofs||m_source;
ofs.close();
pthread_mutex_unlock(m_brain_mutex);
}
// remember to change GUI side to match in MainWindow.cpp
void process_thread::load_session(const std::string &filename) {
pthread_mutex_lock(m_brain_mutex);
m_source.clear();
m_left_target.clear();
m_right_target.clear();
ifstream ifs(filename.c_str(),ios::binary);
u32 version=0;
ifs||version;
ifs||(*m_left_renderer);
ifs||(*m_right_renderer);
ifs||m_source_block_size||m_source_overlap;
ifs||m_target_block_size||m_target_overlap;
ifs||m_window_type||m_target_window_type;
pthread_mutex_lock(m_brain_mutex);
m_source.clear();
m_left_target.clear();
m_right_target.clear();
ifstream ifs(filename.c_str(),ios::binary);
u32 version=0;
ifs||version;
ifs||(*m_left_renderer);
ifs||(*m_right_renderer);
ifs||m_source_block_size||m_source_overlap;
ifs||m_target_block_size||m_target_overlap;
ifs||m_window_type||m_target_window_type;
cerr<<"loading window type session "<<m_target_window_type<<endl;
cerr<<"loading window type session "<<m_target_window_type<<endl;
ifs||m_source;
ifs||m_left_target;
ifs||m_right_target;
ifs.close();
pthread_mutex_unlock(m_brain_mutex);
ifs||m_source;
ifs||m_left_target;
ifs||m_right_target;
ifs.close();
pthread_mutex_unlock(m_brain_mutex);
}
void process_thread::save_session(const std::string &filename) {
pthread_mutex_lock(m_brain_mutex);
ofstream ofs(filename.c_str(),ios::binary);
u32 version=0;
ofs||version;
ofs||(*m_left_renderer);
ofs||(*m_right_renderer);
ofs||m_source_block_size||m_source_overlap;
ofs||m_target_block_size||m_target_overlap;
pthread_mutex_lock(m_brain_mutex);
ofstream ofs(filename.c_str(),ios::binary);
u32 version=0;
ofs||version;
ofs||(*m_left_renderer);
ofs||(*m_right_renderer);
ofs||m_source_block_size||m_source_overlap;
ofs||m_target_block_size||m_target_overlap;
cerr<<"saving window type session "<<m_target_window_type<<endl;
cerr<<"saving window type session "<<m_target_window_type<<endl;
ofs||m_window_type||m_target_window_type;
ofs||m_source;
ofs||m_left_target;
ofs||m_right_target;
ofs.close();
pthread_mutex_unlock(m_brain_mutex);
ofs||m_window_type||m_target_window_type;
ofs||m_source;
ofs||m_left_target;
ofs||m_right_target;
ofs.close();
pthread_mutex_unlock(m_brain_mutex);
}

6
samplebrain/qt/process_thread.h
View File

@ -17,6 +17,7 @@
#include "jellyfish/OSC_server.h"
#include "brain.h"
#include "renderer.h"
#include "block_stream.h"
#include <pthread.h>
#pragma once
@ -30,9 +31,11 @@ public:
pthread_mutex_t* m_brain_mutex;
void register_renderer(renderer *lr, renderer *rr) {
void register_renderer(renderer *lr, renderer *rr, block_stream *bs) {
m_left_renderer=lr;
m_right_renderer=rr;
m_block_stream=bs;
m_block_stream->init(m_target_block_size, m_target_overlap, m_target_window_type);
}
void process();
@ -59,6 +62,7 @@ private:
// only use in mutex obvs...
renderer *m_left_renderer;
renderer *m_right_renderer;
block_stream *m_block_stream;
};
}

2
samplebrain/qt/qtmain.cpp
View File

@ -38,7 +38,7 @@ int main( int argc , char *argv[] ){
process_thread pt;
audio_thread at(pt);
pt.register_renderer(at.m_left_renderer, at.m_right_renderer);
pt.register_renderer(at.m_left_renderer, at.m_right_renderer, at.m_block_stream);
return app.exec();
}

5
samplebrain/qt/samplebrain.pro
View File

@ -3,7 +3,7 @@
######################################################################
TEMPLATE = app
TARGET =
TARGET = samplebrain
DEPENDPATH += . 2
INCLUDEPATH += . 2
@ -27,6 +27,7 @@ SOURCES += MainWindow.cpp \
../src/search_params.cpp \
../src/status.cpp \
../src/window.cpp \
../src/block_stream.cpp \
../src/aquila/filter/MelFilterBank.cpp \
../src/aquila/filter/MelFilter.cpp \
../src/aquila/transform/Dct.cpp \
@ -41,7 +42,7 @@ SOURCES += MainWindow.cpp \
INCLUDEPATH += ../src
LIBS += -L.. -lportaudio -lfftw3 -lsndfile -llo -ldl -lpthread -lm
#CONFIG+=debug
CONFIG+=debug
QMAKE_CXXFLAGS += -Wall -Wno-unused -std=c++11 -DDONT_USE_FLUXA_GRAPH

13
samplebrain/src/block.cpp
View File

@ -89,6 +89,7 @@ block::block(u64 id, const string &filename, const sample &pcm, u32 rate, const
w.run(m_n_pcm);
process(m_n_pcm,m_n_fft,m_n_mfcc,m_n_dominant_freq);
// don't need to keep pcm for the target
if (ditchpcm) {
m_pcm.clear();
m_n_pcm.clear();
@ -96,8 +97,7 @@ block::block(u64 id, const string &filename, const sample &pcm, u32 rate, const
}
void block::init_fft(u32 block_size)
{
void block::init_fft(u32 block_size) {
if (m_fftw == NULL || m_fftw->m_length!=block_size) {
if (m_fftw == NULL) delete m_fftw;
m_fftw = new FFT(block_size,100);
@ -148,6 +148,7 @@ double block::_compare(const sample &fft_a, const sample &mfcc_a,
u32 fft_start = params.m_fft1_start;
u32 fft_end = fmin(params.m_fft1_end,m_fft.get_length());
// first check for only fft
if (params.m_ratio==0) {
for (u32 i=fft_start; i<fft_end; ++i) {
fft_acc+=square(fft_a[i]-fft_b[i]);
@ -155,6 +156,7 @@ double block::_compare(const sample &fft_a, const sample &mfcc_a,
return (fft_acc/(float)fft_a.get_length())*FFT_BIAS;
}
// only mfcc
if (params.m_ratio==1) {
for (u32 i=0; i<MFCC_FILTERS; ++i) {
mfcc_acc+=square(mfcc_a[i]-mfcc_b[i]);
@ -162,7 +164,7 @@ double block::_compare(const sample &fft_a, const sample &mfcc_a,
return mfcc_acc/(float)MFCC_FILTERS;
}
// calculate both
// calculate mix of em both
for (u32 i=fft_start; i<fft_end; ++i) {
fft_acc+=square(fft_a[i]-fft_b[i]);
}
@ -170,19 +172,20 @@ double block::_compare(const sample &fft_a, const sample &mfcc_a,
mfcc_acc+=square(mfcc_a[i]-mfcc_b[i]);
}
// weight them based on ratio
return blend(fft_acc/(float)fft_a.get_length(),
mfcc_acc/(float)MFCC_FILTERS,
params.m_ratio);
}
double block::compare(const block &other, const search_params &params) const {
return blend(
blend(_compare(m_fft, m_mfcc, other.m_fft, other.m_mfcc, params),
return blend(blend(_compare(m_fft, m_mfcc, other.m_fft, other.m_mfcc, params),
_compare(m_n_fft, m_n_mfcc, other.m_n_fft, other.m_n_mfcc, params),
params.m_n_ratio),
other.m_usage, params.m_usage_importance);
}
// serialise in/out to file
ios &spiralcore::operator||(ios &s, block &b) {
u32 version=3;
string id("block");

45
samplebrain/src/block_source.h Normal file
View File

@ -0,0 +1,45 @@
// Copyright (C) 2016 Foam Kernow
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include "block.h"
#ifndef BLOCK_SOURCE
#define BLOCK_SOURCE
namespace spiralcore {
// base class for brain or block_stream - a source of audio blocks
class block_source {
public:
block_source() {}
~block_source() {}
virtual const block &get_block(u32 index) const=0;
u32 get_block_size() const { return m_block_size; }
u32 get_overlap() const { return m_overlap; }
virtual u32 get_num_blocks() const=0;
protected:
u32 m_block_size;
u32 m_overlap;
};
}
#endif

88
samplebrain/src/block_stream.cpp Normal file
View File

@ -0,0 +1,88 @@
// Copyright (C) 2015 Foam Kernow
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include <iostream>
#include "block_stream.h"
using namespace spiralcore;
using namespace std;
#define BUFFER_SIZE 4096*10
#define MAX_BLOCKS 200
block_stream::block_stream() :
m_ready(false),
m_block_index(0),
m_block_position(0),
m_buffer_position(0),
m_buffer(BUFFER_SIZE),
m_block_index_offset(0)
{
}
block_stream::~block_stream() {}
void block_stream::init(u32 block_size, u32 overlap, window::type t, bool ditchpcm) {
m_block_size=block_size;
m_overlap=overlap;
m_block_index=0;
m_block_position=0;
m_buffer_position=0;
if (m_overlap>=m_block_size) m_overlap=0;
cerr<<m_block_size<<endl;
m_window.init(m_block_size);
m_window.set_current_type(t);
m_blocks.clear();
m_ready=true;
}
void block_stream::process(const sample &left, const sample &right) {
if (!m_ready) return;
// load the audio into the buffer
for (u32 i=0; i<left.get_length(); i++) {
m_buffer[m_buffer_position++]=left[i];
if (m_buffer_position>m_buffer.get_length()) {
m_buffer_position=0;
}
// time to make a new block
if (m_block_position>m_block_size-m_overlap) {
sample region;
// m_buffer_pos-m_block_size can be negative to deal
// with the buffer wrapping...
//cerr<<(s32)(m_buffer_position-m_block_size)<<" to "<<m_buffer_position<<endl;
m_buffer.get_region(region,(s32)(m_buffer_position-m_block_size),
m_buffer_position);
m_blocks.push_back(block(0,"input",region,44100,m_window));
m_block_position=0;
if (m_blocks.size()>MAX_BLOCKS) {
m_blocks.erase(m_blocks.begin());
m_block_index_offset++;
}
}
m_block_position++;
}
cerr<<"num blocks: "<<m_blocks.size()<<endl;
}
const block &block_stream::get_block(u32 index) const {
return m_blocks[(index-m_block_index_offset)%m_blocks.size()];
}

62
samplebrain/src/block_stream.h Normal file
View File

@ -0,0 +1,62 @@
// Copyright (C) 2016 Foam Kernow
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include <vector>
#include "window.h"
#include "block.h"
#include "block_source.h"
#ifndef BLOCK_STREAM
#define BLOCK_STREAM
namespace spiralcore {
// the block stream takes incoming audio and chops it up into blocks
// in realtime, for providing them to the renderer (in place of a
// source brain)
class block_stream : public block_source {
public:
block_stream();
virtual ~block_stream();
void init(u32 block_size, u32 overlap, window::type t, bool ditchpcm=false);
// for the moment ignores right channel
void process(const sample &left, const sample &right);
virtual const block &get_block(u32 index) const;
virtual u32 get_num_blocks() const { return UINT_MAX; }
u32 last_block_index() const { return m_block_index_offset+m_blocks.size(); }
private:
bool m_ready;
u32 m_block_index;
u32 m_block_position;
u32 m_buffer_position;
sample m_buffer;
window m_window;
u32 m_block_index_offset;
vector<block> m_blocks;
};
}
#endif

567
samplebrain/src/brain.cpp
View File

@ -29,58 +29,58 @@ static const u32 NUM_FIXED_SYNAPSES = 1000;
static const double usage_factor = 1000;
brain::brain() :
m_current_block_index(0),
m_current_error(0),
m_average_error(0),
m_usage_falloff(0.9)
m_current_block_index(0),
m_current_error(0),
m_average_error(0),
m_usage_falloff(0.9)
{
status::update("brain ready...");
status::update("brain ready...");
}
// load, chop up and add to brain
// todo: add tags
void brain::load_sound(std::string filename, stereo_mode mode) {
SF_INFO sfinfo;
sfinfo.format=0;
SNDFILE* f=sf_open(filename.c_str(), SFM_READ, &sfinfo);
if (f!=NULL) {
sample s(sfinfo.frames);
float *temp = new float[sfinfo.channels * sfinfo.frames];
SF_INFO sfinfo;
sfinfo.format=0;
SNDFILE* f=sf_open(filename.c_str(), SFM_READ, &sfinfo);
if (f!=NULL) {
sample s(sfinfo.frames);
float *temp = new float[sfinfo.channels * sfinfo.frames];
sf_read_float(f, temp, sfinfo.channels * sfinfo.frames);
sf_read_float(f, temp, sfinfo.channels * sfinfo.frames);
if (mode==MIX) {
for(u32 i=0; i<sfinfo.frames; i++) {
s[i]=0;
// mix down stereo to mono
for(u32 j = 0; j < sfinfo.channels; j++) {
s[i]+=temp[i*sfinfo.channels + j];
}
}
} else {
// just take one channel (assume stereo, split if mono)
for(u32 i=0; i<sfinfo.frames; i++) {
u32 si=i*sfinfo.channels;
if (mode==RIGHT && sfinfo.channels>1) si++;
s[i]=temp[si];
}
}
delete[] temp;
m_samples.push_back(sound(filename,s));
status::update("loaded %s",filename.c_str());
if (mode==MIX) {
for(u32 i=0; i<sfinfo.frames; i++) {
s[i]=0;
// mix down stereo to mono
for(u32 j = 0; j < sfinfo.channels; j++) {
s[i]+=temp[i*sfinfo.channels + j];
}
}
} else {
// just take one channel (assume stereo, split if mono)
for(u32 i=0; i<sfinfo.frames; i++) {
u32 si=i*sfinfo.channels;
if (mode==RIGHT && sfinfo.channels>1) si++;
s[i]=temp[si];
}
}
delete[] temp;
m_samples.push_back(sound(filename,s));
status::update("loaded %s",filename.c_str());
}
}
void brain::delete_sound(std::string filename) {
for (auto i=m_samples.begin(); i!=m_samples.end(); ++i) {
if (i->m_filename==filename) {
m_samples.erase(i);
status::update("deleted %s",filename.c_str());
return;
}
for (auto i=m_samples.begin(); i!=m_samples.end(); ++i) {
if (i->m_filename==filename) {
m_samples.erase(i);
status::update("deleted %s",filename.c_str());
return;
}
recompute_sample_sections();
}
recompute_sample_sections();
}
void brain::activate_sound(std::string filename, bool active) {
@ -91,33 +91,32 @@ void brain::activate_sound(std::string filename, bool active) {
}
}
void brain::clear() {
m_blocks.clear();
m_samples.clear();
m_active_sounds.clear();
m_blocks.clear();
m_samples.clear();
m_active_sounds.clear();
}
// rewrites whole brain
void brain::init(u32 block_size, u32 overlap, window::type t, bool ditchpcm) {
m_blocks.clear();
m_block_size = block_size;
m_overlap = overlap;
m_window.init(block_size);
m_window.set_current_type(t);
u32 count=0;
for (auto &s:m_samples) {
status::sound_item(s.m_filename,"lightgrey");
}
for (auto &s:m_samples) {
status::sound_item(s.m_filename,"yellow");
count++;
chop_and_add(s, count, ditchpcm);
if (count%2==0) status::sound_item(s.m_filename,"lightblue");
else status::sound_item(s.m_filename,"pink");
}
status::sound_item_refresh();
status::update("all samples processed");
m_blocks.clear();
m_block_size = block_size;
m_overlap = overlap;
m_window.init(block_size);
m_window.set_current_type(t);
u32 count=0;
for (auto &s:m_samples) {
status::sound_item(s.m_filename,"lightgrey");
}
for (auto &s:m_samples) {
status::sound_item(s.m_filename,"yellow");
count++;
chop_and_add(s, count, ditchpcm);
if (count%2==0) status::sound_item(s.m_filename,"lightblue");
else status::sound_item(s.m_filename,"pink");
}
status::sound_item_refresh();
status::update("all samples processed");
}
void brain::chop_and_add(sound &s, u32 count, bool ditchpcm) {
@ -158,7 +157,7 @@ void brain::recompute_sample_sections() {
}
const block &brain::get_block(u32 index) const {
return m_blocks[index];
return m_blocks[index];
}
// helper to do the stickyness comparison and sort out current_block_index
@ -167,14 +166,14 @@ u32 brain::stickify(const block &target, u32 closest_index, f32 dist, const sear
// if we have stickyness turned on and the next block exists
if (params.m_stickyness>0 && next_index<m_blocks.size()) {
// get next block
f32 dist_to_next = target.compare(m_blocks[next_index],params);
if (dist_to_next * (1-params.m_stickyness) <
dist * params.m_stickyness) {
// use the next block rather than the closest
m_current_block_index = next_index;
return m_current_block_index;
}
// get next block
f32 dist_to_next = target.compare(m_blocks[next_index],params);
if (dist_to_next * (1-params.m_stickyness) <
dist * params.m_stickyness) {
// use the next block rather than the closest
m_current_block_index = next_index;
return m_current_block_index;
}
}
// use the closest block
m_current_block_index = closest_index;
@ -183,131 +182,131 @@ u32 brain::stickify(const block &target, u32 closest_index, f32 dist, const sear
// returns index to block
u32 brain::search(const block &target, const search_params &params) {
double closest = FLT_MAX;
u32 closest_index = 0;
// check each sample section
for (auto &s : m_samples) {
if (s.m_enabled) { // are we turned on?
// loop through indexes for this section
for (u32 i=s.m_start; i<s.m_end; ++i) {
double diff = target.compare(m_blocks[i],params);
if (diff<closest) {
closest=diff;
closest_index = i;
}
}
double closest = FLT_MAX;
u32 closest_index = 0;
// check each sample section
for (auto &s : m_samples) {
if (s.m_enabled) { // are we turned on?
// loop through indexes for this section
for (u32 i=s.m_start; i<s.m_end; ++i) {
double diff = target.compare(m_blocks[i],params);
if (diff<closest) {
closest=diff;
closest_index = i;
}
}
}
deplete_usage();
m_blocks[closest_index].get_usage()+=usage_factor;
return stickify(target,closest_index,closest,params);
}
deplete_usage();
m_blocks[closest_index].get_usage()+=usage_factor;
return stickify(target,closest_index,closest,params);
}
// returns index to block
u32 brain::rev_search(const block &target, const search_params &params) {
double furthest = 0;
u32 furthest_index = 0;
// check each sample section
for (auto &s : m_samples) {
if (s.m_enabled) { // are we turned on?
// loop through indexes for this section
for (u32 i=s.m_start; i<s.m_end; ++i) {
double diff = target.compare(m_blocks[i],params);
if (diff>furthest) {
furthest=diff;
furthest_index = i;
}
}
double furthest = 0;
u32 furthest_index = 0;
// check each sample section
for (auto &s : m_samples) {
if (s.m_enabled) { // are we turned on?
// loop through indexes for this section
for (u32 i=s.m_start; i<s.m_end; ++i) {
double diff = target.compare(m_blocks[i],params);
if (diff>furthest) {
furthest=diff;
furthest_index = i;
}
}
}
deplete_usage();
m_blocks[furthest_index].get_usage()+=usage_factor;
m_current_block_index = furthest_index;
}
deplete_usage();
m_blocks[furthest_index].get_usage()+=usage_factor;
m_current_block_index = furthest_index;
return furthest_index;
return furthest_index;
}
// really slow - every to every comparison of blocks calculating average distance
double brain::calc_average_diff(search_params &params) {
double diff=0;
for (auto &i:m_blocks) {
for (auto &j:m_blocks) {
diff += j.compare(i,params);
}
diff/=(double)m_blocks.size();
double diff=0;
for (auto &i:m_blocks) {
for (auto &j:m_blocks) {
diff += j.compare(i,params);
}
return diff;
diff/=(double)m_blocks.size();
}
return diff;
}
void brain::build_synapses_thresh(search_params &params, double thresh) {
m_average_error = calc_average_diff(params)*thresh;
double err = m_average_error*thresh;
u32 brain_size = m_blocks.size();
u32 outer_index = 0;
for (auto &i : m_blocks) {
u32 index = 0;
status::update("building synapses %d%%",(int)(outer_index/(float)brain_size*100));
for (auto &j : m_blocks) {
if (index!=outer_index) {
// collect connections that are under threshold in closeness
double diff = i.compare(j,params);
if (diff<err) {
i.get_synapse().push_back(index);
}
}
++index;
}
++outer_index;
m_average_error = calc_average_diff(params)*thresh;
double err = m_average_error*thresh;
u32 brain_size = m_blocks.size();
u32 outer_index = 0;
for (auto &i : m_blocks) {
u32 index = 0;
status::update("building synapses %d%%",(int)(outer_index/(float)brain_size*100));
for (auto &j : m_blocks) {
if (index!=outer_index) {
// collect connections that are under threshold in closeness
double diff = i.compare(j,params);
if (diff<err) {
i.get_synapse().push_back(index);
}
}
++index;
}
++outer_index;
}
}
void brain::build_synapses_fixed(search_params &params) {
//m_average_error = calc_average_diff(params)*thresh;
u32 brain_size = m_blocks.size();
u32 outer_index = 0;
u32 num_synapses = NUM_FIXED_SYNAPSES;
if (num_synapses>=m_blocks.size()) num_synapses=m_blocks.size()-1;
//m_average_error = calc_average_diff(params)*thresh;
u32 brain_size = m_blocks.size();
u32 outer_index = 0;
u32 num_synapses = NUM_FIXED_SYNAPSES;
if (num_synapses>=m_blocks.size()) num_synapses=m_blocks.size()-1;
for (auto &i:m_blocks) {
status::update("building synapses %d%%",(int)(outer_index/(float)brain_size*100));
u32 index = 0;
vector<pair<u32,double>> collect;
for (auto &i:m_blocks) {
status::update("building synapses %d%%",(int)(outer_index/(float)brain_size*100));
u32 index = 0;
vector<pair<u32,double>> collect;
// collect comparisons to all other blocks
for (auto &j:m_blocks) {
assert(index<m_blocks.size());
if (index!=outer_index) {
double diff = i.compare(j,params);
collect.push_back(pair<u32,double>(index,diff));
}
++index;
}
// sort them by closeness
sort(collect.begin(),collect.end(),
[](const pair<u32,double> &a,
const pair<u32,double> &b) -> bool {
return a.second<b.second;
});
// add the closest ones to the list
for(u32 n=0; n<num_synapses; ++n) {
assert(collect[n].first<m_blocks.size());
i.get_synapse().push_back(collect[n].first);
}
++outer_index;
// collect comparisons to all other blocks
for (auto &j:m_blocks) {
assert(index<m_blocks.size());
if (index!=outer_index) {
double diff = i.compare(j,params);
collect.push_back(pair<u32,double>(index,diff));
}
++index;
}
status::update("Done: %d synapses grown for %d blocks",num_synapses*brain_size,brain_size);
// sort them by closeness
sort(collect.begin(),collect.end(),
[](const pair<u32,double> &a,
const pair<u32,double> &b) -> bool {
return a.second<b.second;
});
// add the closest ones to the list
for(u32 n=0; n<num_synapses; ++n) {
assert(collect[n].first<m_blocks.size());
i.get_synapse().push_back(collect[n].first);
}
++outer_index;
}
status::update("Done: %d synapses grown for %d blocks",num_synapses*brain_size,brain_size);
}
// randomise the current block
void brain::jiggle() {
if (m_blocks.size()>0) {
m_current_block_index=rand()%m_blocks.size();
} else {
m_current_block_index=0;
}
if (m_blocks.size()>0) {
m_current_block_index=rand()%m_blocks.size();
} else {
m_current_block_index=0;
}
}
bool brain::is_block_active(u32 index) {
@ -321,164 +320,164 @@ bool brain::is_block_active(u32 index) {
}
u32 brain::search_synapses(const block &target, search_params &params) {
const block &current = get_block(m_current_block_index);
double closest = DBL_MAX;
u32 closest_index = 0;
const block &current = get_block(m_current_block_index);
double closest = DBL_MAX;
u32 closest_index = 0;
// find nearest in synaptic connections
if (current.get_synapse_const().size()<params.m_num_synapses) {
params.m_num_synapses = current.get_synapse_const().size()-1;
}
// assert(current.get_synapse_const().size()>params.m_num_synapses);
// find nearest in synaptic connections
if (current.get_synapse_const().size()<params.m_num_synapses) {
params.m_num_synapses = current.get_synapse_const().size()-1;
}
// assert(current.get_synapse_const().size()>params.m_num_synapses);
u32 synapse_count=0;
// use m_num_synapses to restrict search
// only makes sense when ordered by closeness in fixed mode
vector<u32>::const_iterator i=current.get_synapse_const().begin();
while (i!=current.get_synapse_const().end() &&
synapse_count<params.m_num_synapses) {
//assert(*i<m_blocks.size());
u32 synapse_count=0;
// use m_num_synapses to restrict search
// only makes sense when ordered by closeness in fixed mode
vector<u32>::const_iterator i=current.get_synapse_const().begin();
while (i!=current.get_synapse_const().end() &&
synapse_count<params.m_num_synapses) {
//assert(*i<m_blocks.size());
if (is_block_active(*i)) {
const block &other = get_block(*i);
double diff = target.compare(other,params);
if (diff<closest) {
closest=diff;
closest_index = *i;
}
if (is_block_active(*i)) {
const block &other = get_block(*i);
double diff = target.compare(other,params);
if (diff<closest) {
closest=diff;
closest_index = *i;
}
++i;
++synapse_count;
}
++i;
++synapse_count;
}
deplete_usage();
m_blocks[m_current_block_index].get_usage()+=usage_factor;
m_current_error = closest;
deplete_usage();
m_blocks[m_current_block_index].get_usage()+=usage_factor;
m_current_error = closest;
// probably impossible to be false?
if (closest_index!=0) {
//cerr<<"usage:"<<m_blocks[closest_index].get_usage()<<endl;
return stickify(target,closest_index,closest,params);
}
return m_current_block_index;
// probably impossible to be false?
if (closest_index!=0) {
//cerr<<"usage:"<<m_blocks[closest_index].get_usage()<<endl;
return stickify(target,closest_index,closest,params);
}
return m_current_block_index;
}
void brain::deplete_usage() {
for (vector<block>::iterator i=m_blocks.begin(); i!=m_blocks.end(); ++i) {
i->get_usage()*=m_usage_falloff;
}
for (vector<block>::iterator i=m_blocks.begin(); i!=m_blocks.end(); ++i) {
i->get_usage()*=m_usage_falloff;
}
}
// take another brain and rebuild this brain from bits of that one
// (presumably this one is made from a single sample)
/*void brain::resynth(const string &filename, const brain &other, const search_params &params){
sample out((m_block_size-m_overlap)*m_blocks.size());
out.zero();
u32 pos = 0;
u32 count = 0;
cerr<<other.m_blocks.size()<<" brain blocks..."<<endl;
cerr<<endl;
for (vector<block>::iterator i=m_blocks.begin(); i!=m_blocks.end(); ++i) {
cerr<<'\r';
cerr<<"searching: "<<count/float(m_blocks.size())*100;
u32 index = other.search(*i, params);
//cerr<<index<<endl;
out.mul_mix(other.get_block_pcm(index),pos,0.2);
sample out((m_block_size-m_overlap)*m_blocks.size());
out.zero();
u32 pos = 0;
u32 count = 0;
cerr<<other.m_blocks.size()<<" brain blocks..."<<endl;
cerr<<endl;
for (vector<block>::iterator i=m_blocks.begin(); i!=m_blocks.end(); ++i) {
cerr<<'\r';
cerr<<"searching: "<<count/float(m_blocks.size())*100;
u32 index = other.search(*i, params);
//cerr<<index<<endl;
out.mul_mix(other.get_block_pcm(index),pos,0.2);
if (count%1000==0) {
audio_device::save_sample(filename,out);
}
if (count%1000==0) {
audio_device::save_sample(filename,out);
}
++count;
pos += (m_block_size-m_overlap);
}
audio_device::save_sample(filename,out);
}
++count;
pos += (m_block_size-m_overlap);
}
audio_device::save_sample(filename,out);
}
*/
ios &spiralcore::operator||(ios &s, brain::sound &b) {
u32 version=1;
string id("brain::sound");
s||id||version;
s||b.m_filename||b.m_sample;
if (version>0) {
s||b.m_num_blocks||b.m_start||b.m_end||b.m_enabled;
}
return s;
u32 version=1;
string id("brain::sound");
s||id||version;
s||b.m_filename||b.m_sample;
if (version>0) {
s||b.m_num_blocks||b.m_start||b.m_end||b.m_enabled;
}
return s;
}
ios &spiralcore::operator||(ios &s, brain &b) {
u32 version=1;
string id("brain");
// changes here need to be reflected in interface loading
s||id||version;
stream_vector(s,b.m_blocks);
stream_list(s,b.m_samples);
s||b.m_block_size||b.m_overlap||b.m_window;
s||b.m_current_block_index||b.m_current_error||
b.m_average_error||b.m_usage_falloff;
return s;
u32 version=1;
string id("brain");
// changes here need to be reflected in interface loading
s||id||version;
stream_vector(s,b.m_blocks);
stream_list(s,b.m_samples);
s||b.m_block_size||b.m_overlap||b.m_window;
s||b.m_current_block_index||b.m_current_error||
b.m_average_error||b.m_usage_falloff;
return s;
}
bool brain::unit_test() {
brain b;
assert(b.m_samples.size()==0);
assert(b.m_blocks.size()==0);
brain b;
assert(b.m_samples.size()==0);
assert(b.m_blocks.size()==0);
b.load_sound("test_data/100f32.wav",MIX);
b.load_sound("test_data/100i16.wav",MIX);
assert(b.m_samples.size()==2);
b.load_sound("test_data/100f32.wav",MIX);
b.load_sound("test_data/100i16.wav",MIX);
assert(b.m_samples.size()==2);
b.init(10, 0, window::RECTANGLE);
assert(b.m_blocks.size()==20);
b.init(10, 5, window::RECTANGLE);
assert(b.m_samples.size()==2);
assert(b.m_blocks.size()==38);
b.init(20, 5, window::RECTANGLE);
assert(b.m_samples.size()==2);
assert(b.m_blocks.size()==12);
b.init(10, 0, window::RECTANGLE);
assert(b.m_blocks.size()==20);
b.init(10, 5, window::RECTANGLE);
assert(b.m_samples.size()==2);
assert(b.m_blocks.size()==38);
b.init(20, 5, window::RECTANGLE);
assert(b.m_samples.size()==2);
assert(b.m_blocks.size()==12);
// replicate brains
brain b2;
b2.load_sound("test_data/up.wav",MIX);
brain b3;
b3.load_sound("test_data/up.wav",MIX);
// replicate brains
brain b2;
b2.load_sound("test_data/up.wav",MIX);
brain b3;
b3.load_sound("test_data/up.wav",MIX);
b2.init(512, 0, window::BLACKMAN);
b3.init(512, 0, window::BLACKMAN);
b2.init(512, 0, window::BLACKMAN);
b3.init(512, 0, window::BLACKMAN);
search_params p(1,0,0,100,0);
search_params p(1,0,0,100,0);
assert(b3.search(b2.m_blocks[0],p)==0);
assert(b3.search(b2.m_blocks[9],p)==9);
assert(b3.search(b2.m_blocks[19],p)==19);
assert(b3.search(b2.m_blocks[29],p)==29);
assert(b3.search(b2.m_blocks[0],p)==0);
//assert(b3.search(b2.m_blocks[9],p)==9);
//assert(b3.search(b2.m_blocks[19],p)==19);
//assert(b3.search(b2.m_blocks[29],p)==29);
ofstream of("test_data/test.brain",ios::binary);
of||b3;
of.close();
ofstream of("test_data/test.brain",ios::binary);
of||b3;
of.close();
brain b4;
ifstream ifs("test_data/test.brain",ios::binary);
ifs||b4;
ifs.close();
brain b4;
ifstream ifs("test_data/test.brain",ios::binary);
ifs||b4;
ifs.close();
assert(b3.m_samples.size()==b4.m_samples.size());
assert(b3.m_blocks.size()==b4.m_blocks.size());
assert(b3.m_samples.size()==b4.m_samples.size());
assert(b3.m_blocks.size()==b4.m_blocks.size());
assert(b4.search(b2.m_blocks[0],p)==0);
assert(b4.search(b2.m_blocks[9],p)==9);
assert(b4.search(b2.m_blocks[19],p)==19);
assert(b4.search(b2.m_blocks[29],p)==29);
assert(b4.search(b2.m_blocks[0],p)==0);
//assert(b4.search(b2.m_blocks[9],p)==9);
//assert(b4.search(b2.m_blocks[19],p)==19);
//assert(b4.search(b2.m_blocks[29],p)==29);
cerr<<"!!!"<<endl;
//cerr<<"!!!"<<endl;
// sample r = b2.resynth(b,1);
// assert(r.get_length()==200);
// sample r = b2.resynth(b,1);
// assert(r.get_length()==200);
return true;
return true;
}

13
samplebrain/src/brain.h
View File

@ -19,6 +19,7 @@
#include <string>
#include "jellyfish/types.h"
#include "jellyfish/sample.h"
#include "block_source.h"
#include "block.h"
#include "search_params.h"
#include "window.h"
@ -28,7 +29,7 @@
namespace spiralcore {
class brain {
class brain : public block_source {
public:
brain();
@ -49,10 +50,9 @@ public:
const sample &get_block_pcm(u32 index) const;
const sample &get_block_n_pcm(u32 index) const;
const block &get_block(u32 index) const;
u32 get_num_blocks() const { return m_blocks.size(); }
u32 get_block_size() const { return m_block_size; }
u32 get_overlap() const { return m_overlap; }
virtual const block &get_block(u32 index) const;
virtual u32 get_num_blocks() const { return m_blocks.size(); }
void set_usage_falloff(float s) { m_usage_falloff=s; }
float get_usage_falloff() { return m_usage_falloff; }
@ -106,9 +106,6 @@ private:
std::list<sound> m_samples;
vector<string> m_active_sounds;
u32 m_block_size;
u32 m_overlap;
window m_window;
u32 m_current_block_index;

2
samplebrain/src/jellyfish/audio.cpp
View File

@ -36,9 +36,9 @@ audio_device::audio_device(const string &clientname, u32 samplerate, u32 buffer_
opt.in_channels = 2;
opt.out_channels = 2;
m_client.attach(clientname,opt);
m_client.set_outputs(left_out.get_buffer(), right_out.get_buffer());
m_client.set_inputs(left_in.get_non_const_buffer(), right_in.get_non_const_buffer());
m_client.attach(clientname,opt);
}

211
samplebrain/src/jellyfish/portaudio_client.cpp
View File

@ -31,134 +31,121 @@ float *portaudio_client::m_left_in_data=NULL;
///////////////////////////////////////////////////////
portaudio_client::portaudio_client()
{
portaudio_client::portaudio_client() {
}
/////////////////////////////////////////////////////////////////////////////////////////////
portaudio_client::~portaudio_client()
{
detach();
portaudio_client::~portaudio_client() {
detach();
}
/////////////////////////////////////////////////////////////////////////////////////////////
bool portaudio_client::attach(const string &client_name, const device_options &dopt)
{
if (m_attached) return true;
bool portaudio_client::attach(const string &client_name, const device_options &dopt) {
if (m_attached) return true;
PaError err;
err = Pa_Initialize();
if( err != paNoError )
{
cerr<<"could not init portaudio_client"<<endl;
Pa_Terminate();
fprintf( stderr, "an error occured while using the portaudio stream\n" );
fprintf( stderr, "error number: %d\n", err );
fprintf( stderr, "error message: %s\n", Pa_GetErrorText( err ) );
}
PaStreamParameters output_parameters;
output_parameters.device = Pa_GetDefaultOutputDevice(); /* default output device */
if (output_parameters.device == paNoDevice) {
cerr<<"error: no default output device."<<endl;
}
output_parameters.channelCount = 2; /* stereo output */
output_parameters.sampleFormat = paFloat32; /* 32 bit floating point output */
output_parameters.suggestedLatency = Pa_GetDeviceInfo( output_parameters.device )->defaultLowOutputLatency;
output_parameters.hostApiSpecificStreamInfo = NULL;
PaStreamParameters input_parameters;
input_parameters.device = Pa_GetDefaultInputDevice(); /* default output device */
if (input_parameters.device == paNoDevice) {
cerr<<"error: no default input device."<<endl;
}
input_parameters.channelCount = 2; /* stereo output */
input_parameters.sampleFormat = paFloat32; /* 32 bit floating point output */
input_parameters.suggestedLatency = Pa_GetDeviceInfo( input_parameters.device )->defaultLowInputLatency;
input_parameters.hostApiSpecificStreamInfo = NULL;
PaStream *stream;
err = Pa_OpenStream(
&stream,
NULL, //&input_parameters,
&output_parameters,
dopt.samplerate,
dopt.buffer_size,
paClipOff,
process,
NULL);
if( err != paNoError )
{
cerr<<"could not attach portaudio_client: "<<Pa_GetErrorText( err )<<endl;
Pa_Terminate();
return false;
}
err = Pa_StartStream(stream);
if( err != paNoError )
{
cerr<<"could not start stream: "<<Pa_GetErrorText( err )<<endl;
Pa_Terminate();
return false;
}
m_attached=true;
cerr<<"connected to portaudio..."<<endl;
return true;
}
/////////////////////////////////////////////////////////////////////////////////////////////
void portaudio_client::detach()
{
cerr<<"detaching from portaudio"<<endl;
PaError err;
err = Pa_Initialize();
if( err != paNoError ) {
cerr<<"could not init portaudio_client"<<endl;
Pa_Terminate();
m_attached=false;
fprintf( stderr, "an error occured while using the portaudio stream\n" );
fprintf( stderr, "error number: %d\n", err );
fprintf( stderr, "error message: %s\n", Pa_GetErrorText( err ) );
}
PaStreamParameters output_parameters;
output_parameters.device = Pa_GetDefaultOutputDevice(); /* default output device */
if (output_parameters.device == paNoDevice) {
cerr<<"error: no default output device."<<endl;
}
output_parameters.channelCount = 2; /* stereo output */
output_parameters.sampleFormat = paFloat32; /* 32 bit floating point output */
output_parameters.suggestedLatency = Pa_GetDeviceInfo( output_parameters.device )->defaultLowOutputLatency;
output_parameters.hostApiSpecificStreamInfo = NULL;
PaStreamParameters input_parameters;
input_parameters.device = Pa_GetDefaultInputDevice(); /* default output device */
if (input_parameters.device == paNoDevice) {
cerr<<"error: no default input device."<<endl;
}
input_parameters.channelCount = 2; /* stereo output */
input_parameters.sampleFormat = paFloat32; /* 32 bit floating point output */
input_parameters.suggestedLatency = Pa_GetDeviceInfo( input_parameters.device )->defaultLowInputLatency;
input_parameters.hostApiSpecificStreamInfo = NULL;
PaStream *stream;
err = Pa_OpenStream(&stream,
&input_parameters,
&output_parameters,
dopt.samplerate,
dopt.buffer_size,
paClipOff,
process,
NULL);
if(err != paNoError) {
cerr<<"could not attach portaudio_client: "<<Pa_GetErrorText( err )<<endl;
Pa_Terminate();
return false;
}
err = Pa_StartStream(stream);
if(err != paNoError) {
cerr<<"could not start stream: "<<Pa_GetErrorText( err )<<endl;
Pa_Terminate();
return false;
}
m_attached=true;
cerr<<"connected to portaudio..."<<endl;
return true;
}
/////////////////////////////////////////////////////////////////////////////////////////////
void portaudio_client::detach() {
cerr<<"detaching from portaudio"<<endl;
Pa_Terminate();
m_attached=false;
}
/////////////////////////////////////////////////////////////////////////////////////////////
int portaudio_client::process(const void *input_buffer, void *output_buffer,
unsigned long frames_per_buffer,
const PaStreamCallbackTimeInfo* time_info,
PaStreamCallbackFlags status_flags,
void *user_data)
{
m_buffer_size=frames_per_buffer;
unsigned long frames_per_buffer,
const PaStreamCallbackTimeInfo* time_info,
PaStreamCallbackFlags status_flags,
void *user_data) {
m_buffer_size=frames_per_buffer;
if(run_callback&&run_context)
{
// do the work
run_callback(run_context, frames_per_buffer);
}
if(run_callback&&run_context) {
// do the work
run_callback(run_context, frames_per_buffer);
}
if (m_right_data && m_left_data)
{
float *out = (float*)output_buffer;
for (unsigned int n=0; n<m_buffer_size; n++)
{
*out=m_left_data[n];
out++;
*out=m_right_data[n];
out++;
}
}
if (m_right_data && m_left_data) {
float *out = (float*)output_buffer;
for (unsigned int n=0; n<m_buffer_size; n++) {
*out=m_left_data[n];
out++;
*out=m_right_data[n];
out++;
}
}
/* if (m_right_in_data && m_left_in_data)
{
float *in = (float*)input_buffer;
for (unsigned int n=0; n<m_buffer_size; n++)
{
m_left_in_data[n]=*in;
in++;
m_right_in_data[n]=*in;
in++;
}
}*/
return 0;
if (m_right_in_data && m_left_in_data) {
float *in = (float*)input_buffer;
for (unsigned int n=0; n<m_buffer_size; n++) {
m_left_in_data[n]=*in;
in++;
m_right_in_data[n]=*in;
in++;
}
}
return 0;
}

70
samplebrain/src/jellyfish/portaudio_client.h
View File

@ -27,49 +27,49 @@ using namespace std;
class portaudio_client
{
public:
portaudio_client();
~portaudio_client();
public:
portaudio_client();
~portaudio_client();
class device_options
{
public:
enum type {READ,WRITE,READWRITE};
unsigned int buffer_size;
unsigned int num_buffers;
unsigned int samplerate;
unsigned int in_channels;
unsigned int out_channels;
};
class device_options
{
public:
enum type {READ,WRITE,READWRITE};
unsigned int buffer_size;
unsigned int num_buffers;
unsigned int samplerate;
unsigned int in_channels;
unsigned int out_channels;
};
bool attach(const string &client_name, const device_options &dopt);
void detach();
bool is_attached() { return m_attached; }
void set_callback(void(*run)(void*, unsigned int),void *context) { run_callback=run; run_context=context; }
void set_outputs(const float *l, const float *r) { m_left_data=l; m_right_data=r; }
void set_inputs(float *l, float *r) { m_left_in_data=l; m_right_in_data=r; }
bool attach(const string &client_name, const device_options &dopt);
void detach();
bool is_attached() { return m_attached; }
void set_callback(void(*run)(void*, unsigned int),void *context) { run_callback=run; run_context=context; }
void set_outputs(const float *l, const float *r) { m_left_data=l; m_right_data=r; }
void set_inputs(float *l, float *r) { m_left_in_data=l; m_right_in_data=r; }
protected:
protected:
static int process(const void *input_buffer, void *output_buffer,
unsigned long frames_per_buffer,
const PaStreamCallbackTimeInfo* time_info,
PaStreamCallbackFlags status_flags,
void *user_data);
static int process(const void *input_buffer, void *output_buffer,
unsigned long frames_per_buffer,
const PaStreamCallbackTimeInfo* time_info,
PaStreamCallbackFlags status_flags,
void *user_data);
private:
private:
static long unsigned int m_buffer_size;
static long unsigned int m_sample_rate;
static bool m_attached;
static long unsigned int m_buffer_size;
static long unsigned int m_sample_rate;
static bool m_attached;
static const float *m_right_data;
static const float *m_left_data;
static float *m_right_in_data;
static float *m_left_in_data;
static const float *m_right_data;
static const float *m_left_data;
static float *m_right_in_data;
static float *m_left_in_data;
static void(*run_callback)(void *, unsigned int);
static void *run_context;
static void(*run_callback)(void *, unsigned int);
static void *run_context;
};
#endif

495
samplebrain/src/jellyfish/sample.cpp
View File

@ -1,18 +1,19 @@
// _copyright (_c) 2003 _david _griffiths <dave@pawfal.org>
// Copyright (C) 2003 Dave Griffiths
//
// _this program is free software; you can redistribute it and/or modify
// it under the terms of the _g_n_u _general _public _license as published by
// the _free _software _foundation; either version 2 of the _license, or
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// _this program is distributed in the hope that it will be useful,
// but _w_i_t_h_o_u_t _a_n_y _w_a_r_r_a_n_t_y; without even the implied warranty of
// _m_e_r_c_h_a_n_t_a_b_i_l_i_t_y or _f_i_t_n_e_s_s _f_o_r _a _p_a_r_t_i_c_u_l_a_r _p_u_r_p_o_s_e. _see the
// _g_n_u _general _public _license for more details.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// _you should have received a copy of the _g_n_u _general _public _license
// along with this program; if not, write to the _free _software
// _foundation, _inc., 59 _temple _place - _suite 330, _boston, _m_a 02111-1307, _u_s_a.
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include <string.h>
#include "types.h"
@ -23,349 +24,313 @@ using namespace spiralcore;
base_allocator *sample::m_allocator = new malloc_allocator();
sample::sample(unsigned int len) :
m_data(NULL),
m_length(0)
m_data(NULL),
m_length(0)
{
if (len)
{
allocate(len);
}
if (len) {
allocate(len);
}
}
sample::sample(const sample &rhs):
m_data(NULL),
m_length(0)
m_data(NULL),
m_length(0)
{
*this=rhs;
*this=rhs;
}
sample::sample(const audio_type *s, unsigned int len):
m_data(NULL),
m_length(0)
m_data(NULL),
m_length(0)
{
assert(s);
allocate(len);
memcpy(m_data,s,get_length_in_bytes());
assert(s);
allocate(len);
memcpy(m_data,s,get_length_in_bytes());
}
sample::~sample()
{
clear();
sample::~sample() {
clear();
}
bool sample::allocate(unsigned int size)
{
clear();
bool sample::allocate(unsigned int size) {
clear();
m_data = (audio_type*) m_allocator->anew(size*sizeof(audio_type));
m_length=size;
m_data = (audio_type*) m_allocator->anew(size*sizeof(audio_type));
m_length=size;
memset(m_data,0,get_length_in_bytes());
memset(m_data,0,get_length_in_bytes());
return (m_data);
return (m_data);
}
void sample::clear()
{
if (m_data)
{
m_allocator->adelete((char*)m_data);
m_length=0;
m_data=NULL;
}
void sample::clear() {
if (m_data) {
m_allocator->adelete((char*)m_data);
m_length=0;
m_data=NULL;
}
}
void sample::zero()
{
memset(m_data,0,get_length_in_bytes());
void sample::zero() {
memset(m_data,0,get_length_in_bytes());
}
void sample::set(audio_type val)
{
for (unsigned int n=0; n<m_length; n++)
{
m_data[n]=val;
}
void sample::set(audio_type val) {
for (unsigned int n=0; n<m_length; n++) {
m_data[n]=val;
}
}
void sample::insert(const sample &s, unsigned int pos)
{
// do some checking
assert(pos<=get_length());
void sample::insert(const sample &s, unsigned int pos) {
// do some checking
assert(pos<=get_length());
unsigned int new_len = get_length()+s.get_length();
audio_type *new_buf = (audio_type*) m_allocator->anew(new_len*sizeof(audio_type));
unsigned int from_pos=0, to_pos=0, temp_buf_pos=0;
unsigned int new_len = get_length()+s.get_length();
audio_type *new_buf = (audio_type*) m_allocator->anew(new_len*sizeof(audio_type));
unsigned int from_pos=0, to_pos=0, temp_buf_pos=0;
while (from_pos<=get_length())
{
if (from_pos==pos)
{
for (temp_buf_pos=0; temp_buf_pos<s.get_length(); temp_buf_pos++)
{
new_buf[to_pos]=s[temp_buf_pos];
to_pos++;
}
}
else
{
// this test is needed so the loop can deal
// with samples being "inserted" on to the
// very end of the buffer
if (from_pos<get_length())
{
new_buf[to_pos]=m_data[from_pos];
}
}
from_pos++;
to_pos++;
}
while (from_pos<=get_length()) {
if (from_pos==pos) {
for (temp_buf_pos=0; temp_buf_pos<s.get_length(); temp_buf_pos++) {
new_buf[to_pos]=s[temp_buf_pos];
to_pos++;
}
} else {
// this test is needed so the loop can deal
// with samples being "inserted" on to the
// very end of the buffer
if (from_pos<get_length()) {
new_buf[to_pos]=m_data[from_pos];
}
}
from_pos++;
to_pos++;
}
clear();
m_data=new_buf;
m_length=new_len;
clear();
m_data=new_buf;
m_length=new_len;
}
void sample::add(const sample &s)
{
insert(s,get_length());
void sample::add(const sample &s) {
insert(s,get_length());
}
void sample::mix(const sample &s, unsigned int pos)
{
// do some checking
assert(pos<get_length());
void sample::mix(const sample &s, unsigned int pos) {
// do some checking
assert(pos<get_length());
unsigned int to_pos=pos;
unsigned int to_pos=pos;
for (unsigned int from_pos=0; from_pos<s.get_length(); from_pos++)
{
m_data[to_pos]=m_data[to_pos]+s[from_pos];
if (to_pos>get_length()) to_pos=0;
to_pos++;
}
for (unsigned int from_pos=0; from_pos<s.get_length(); from_pos++) {
m_data[to_pos]=m_data[to_pos]+s[from_pos];
if (to_pos>get_length()) to_pos=0;
to_pos++;
}
}
void sample::mul_mix(const sample &s, unsigned int pos, float m)
{
// do some checking
assert(pos<get_length());
void sample::mul_mix(const sample &s, unsigned int pos, float m) {
// do some checking
assert(pos<get_length());
unsigned int to_pos=pos;
unsigned int to_pos=pos;
for (unsigned int from_pos=0; from_pos<s.get_length(); from_pos++)
{
m_data[to_pos]=m_data[to_pos]+s[from_pos]*m;
if (to_pos>get_length()) to_pos=0;
to_pos++;
}
for (unsigned int from_pos=0; from_pos<s.get_length(); from_pos++) {
m_data[to_pos]=m_data[to_pos]+s[from_pos]*m;
if (to_pos>get_length()) to_pos=0;
to_pos++;
}
}
void sample::mul_clip_mix(const sample &s, float m)
{
unsigned int to_pos=0;
for (unsigned int from_pos=0; from_pos<s.get_length(); from_pos++)
{
float t=s[from_pos]*m;
if (t>m) t=m;
else if (t<-m) t=-m;
m_data[to_pos]=m_data[to_pos]+t;
if (to_pos>get_length()) to_pos=0;
to_pos++;
}
void sample::mul_clip_mix(const sample &s, float m) {
unsigned int to_pos=0;
for (unsigned int from_pos=0; from_pos<s.get_length(); from_pos++) {
float t=s[from_pos]*m;
if (t>m) t=m;
else if (t<-m) t=-m;
m_data[to_pos]=m_data[to_pos]+t;
if (to_pos>get_length()) to_pos=0;
to_pos++;
}
}
void sample::remove(unsigned int start, unsigned int end)
{
// do some checking
assert(end<get_length() && start<get_length());
assert(start<=end);
void sample::remove(unsigned int start, unsigned int end) {
// do some checking
assert(end<get_length() && start<get_length());
assert(start<=end);
// check the range
if (end>get_length()) end=get_length();
// unsigned, impossible
//if (start<0) start=0;
// check the range
if (end>get_length()) end=get_length();
// unsigned, impossible
//if (start<0) start=0;
// calc lengths and allocate memory
unsigned int cut_len = end - start;
// has to be granulated by the buffer size
// calc lengths and allocate memory
unsigned int cut_len = end - start;
// has to be granulated by the buffer size
unsigned int new_len = get_length()-cut_len;
unsigned int new_len = get_length()-cut_len;
audio_type *temp_buf = (audio_type*) m_allocator->anew(new_len*sizeof(audio_type));
audio_type *temp_buf = (audio_type*) m_allocator->anew(new_len*sizeof(audio_type));
unsigned int to_pos=0;
unsigned int to_pos=0;
for (unsigned int from_pos=0; from_pos<get_length(); from_pos++)
{
// copy the areas outside of the cut range
if (from_pos<start || from_pos>end)
{
temp_buf[to_pos]=m_data[from_pos];
to_pos++;
// check the position is in range of the calculated length
assert(to_pos<=new_len);
}
}
clear();
m_data=temp_buf;
m_length=new_len;
for (unsigned int from_pos=0; from_pos<get_length(); from_pos++) {
// copy the areas outside of the cut range
if (from_pos<start || from_pos>end) {
temp_buf[to_pos]=m_data[from_pos];
to_pos++;
// check the position is in range of the calculated length
assert(to_pos<=new_len);
}
}
clear();
m_data=temp_buf;
m_length=new_len;
}
void sample::reverse(unsigned int start, unsigned int end)
{
// do some checking
assert(end<get_length() && start<get_length());
assert(start<=end);
void sample::reverse(unsigned int start, unsigned int end) {
// do some checking
assert(end<get_length() && start<get_length());
assert(start<=end);
// check the range
if (end>get_length()) end=get_length();
// check the range
if (end>get_length()) end=get_length();
unsigned int new_len = end-start;
audio_type *temp_buf = (audio_type*) m_allocator->anew(new_len*sizeof(audio_type));
unsigned int to_pos=0;
unsigned int from_pos=0;
unsigned int new_len = end-start;
audio_type *temp_buf = (audio_type*) m_allocator->anew(new_len*sizeof(audio_type));
unsigned int to_pos=0;
unsigned int from_pos=0;
// get the reversed sample
for (from_pos=end; from_pos>start; from_pos--)
{
temp_buf[to_pos]=m_data[from_pos];
to_pos++;
assert(to_pos<=new_len);
}
// get the reversed sample
for (from_pos=end; from_pos>start; from_pos--) {
temp_buf[to_pos]=m_data[from_pos];
to_pos++;
assert(to_pos<=new_len);
}
from_pos=0;
from_pos=0;
// overwrite back into place
for (to_pos=start; to_pos<end; to_pos++)
{
m_data[to_pos]=temp_buf[from_pos];
from_pos++;
}
// overwrite back into place
for (to_pos=start; to_pos<end; to_pos++) {
m_data[to_pos]=temp_buf[from_pos];
from_pos++;
}
}
void sample::move(unsigned int dist)
{
unsigned int length=get_length();
audio_type *temp_buf = (audio_type*) m_allocator->anew(length*sizeof(audio_type));
unsigned int to_pos=0;
unsigned int from_pos=dist;
void sample::move(unsigned int dist) {
unsigned int length=get_length();
audio_type *temp_buf = (audio_type*) m_allocator->anew(length*sizeof(audio_type));
unsigned int to_pos=0;
unsigned int from_pos=dist;
// unsigned - impossible
//if (from_pos<0) from_pos+=length;
if (from_pos>length) from_pos-=length;
// unsigned - impossible
//if (from_pos<0) from_pos+=length;
if (from_pos>length) from_pos-=length;
// get the offset sample
for (to_pos=0; to_pos<length; to_pos++)
{
temp_buf[to_pos]=m_data[from_pos];
from_pos++;
if (from_pos>=length) from_pos=0;
}
// get the offset sample
for (to_pos=0; to_pos<length; to_pos++) {
temp_buf[to_pos]=m_data[from_pos];
from_pos++;
if (from_pos>=length) from_pos=0;
}
clear();
m_data=temp_buf;
m_length=length;
clear();
m_data=temp_buf;
m_length=length;
}
void sample::get_region(sample &s, unsigned int start, unsigned int end) const
{
// do some checking
assert(end<get_length() && start<get_length());
assert(start<=end);
// will wrap with minus start index
void sample::get_region(sample &s, int start, unsigned int end) const {
// do some checking
assert(end<get_length() && start<(s32)get_length());
assert(start<=(s32)end);
unsigned int length=end-start;
s.allocate(length);
unsigned int length=end-start;
s.allocate(length);
unsigned int from_pos=start;
unsigned int from_pos=start;
for (unsigned int to_pos=0; to_pos<length; to_pos++)
{
s.set(to_pos,m_data[from_pos]);
from_pos++;
}
for (unsigned int to_pos=0; to_pos<length; to_pos++) {
s.set(to_pos,wrapped_get(from_pos));
from_pos++;
}
}
void sample::crop_to(unsigned int new_length)
{
assert (new_length<get_length());
void sample::crop_to(unsigned int new_length) {
assert (new_length<get_length());
audio_type *temp = (audio_type*) m_allocator->anew(new_length*sizeof(audio_type));
audio_type *temp = (audio_type*) m_allocator->anew(new_length*sizeof(audio_type));
for(unsigned int n=0; n<new_length; n++)
{
temp[n]=m_data[n];
}
for(unsigned int n=0; n<new_length; n++) {
temp[n]=m_data[n];
}
clear();
m_data=temp;
m_length=new_length;
clear();
m_data=temp;
m_length=new_length;
}
// adds length amount of blank space
void sample::expand(unsigned int length)
{
sample temp(length);
temp.zero();
void sample::expand(unsigned int length) {
sample temp(length);
temp.zero();
add(temp);
add(temp);
}
// shrink the samle by length amount
void sample::shrink(unsigned int length)
{
unsigned int new_length=get_length()-length;
assert(new_length>0 && new_length<=get_length());
void sample::shrink(unsigned int length) {
unsigned int new_length=get_length()-length;
assert(new_length>0 && new_length<=get_length());
audio_type *temp = (audio_type*) m_allocator->anew(new_length*sizeof(audio_type));
audio_type *temp = (audio_type*) m_allocator->anew(new_length*sizeof(audio_type));
for(unsigned int n=0; n<new_length; n++)
{
temp[n]=m_data[n];
}
for(unsigned int n=0; n<new_length; n++) {
temp[n]=m_data[n];
}
clear();
m_data=temp;
m_length=new_length;
clear();
m_data=temp;
m_length=new_length;
}
ios &spiralcore::operator||(ios &s, sample &sa) {
unsigned int version=1;
string id("sample");
s||id||version;
s||sa.m_sample_type;
unsigned int version=1;
string id("sample");
s||id||version;
s||sa.m_sample_type;
ofstream *pos=dynamic_cast<ofstream*>(&s);
if (pos!=NULL) {
ofstream &os = *pos;
size_t len = sa.m_length;
os.write((char*)&len,sizeof(size_t));
os.write((char*)sa.m_data,sa.m_length*sizeof(audio_type));
return os;
}
else
ofstream *pos=dynamic_cast<ofstream*>(&s);
if (pos!=NULL) {
ofstream &os = *pos;
size_t len = sa.m_length;
os.write((char*)&len,sizeof(size_t));
os.write((char*)sa.m_data,sa.m_length*sizeof(audio_type));
return os;
}
else
{
ifstream *pis=dynamic_cast<ifstream*>(&s);
assert(pis!=NULL);
ifstream &is = *pis;
size_t len=0;
is.read((char *)&len,sizeof(size_t));
float *data = new float[len];
is.read((char*)data,len*sizeof(audio_type));
sa.m_data = data;
sa.m_length = len;
return is;
ifstream *pis=dynamic_cast<ifstream*>(&s);
assert(pis!=NULL);
ifstream &is = *pis;
size_t len=0;
is.read((char *)&len,sizeof(size_t));
float *data = new float[len];
is.read((char*)data,len*sizeof(audio_type));
sa.m_data = data;
sa.m_length = len;
return is;
}
}

149
samplebrain/src/jellyfish/sample.h
View File

@ -32,102 +32,101 @@ namespace spiralcore
{
//#define DEBUG
inline float linear(float bot,float top,float pos,float val1,float val2)
{
inline float linear(float bot,float top,float pos,float val1,float val2) {
float t=(pos-bot)/(top-bot);
return val1*t + val2*(1.0f-t);
}
}
inline bool feq(float a, float b, float tol=0.00001)
{
return (a>b-tol && a<b+tol);
}
inline bool feq(float a, float b, float tol=0.00001) {
return (a>b-tol && a<b+tol);
}
class sample
{
public:
enum sample_type {AUDIO=0, IMAGE, MIDI};
class sample
{
public:
enum sample_type {AUDIO=0, IMAGE, MIDI};
sample(unsigned int len=0);
sample(const sample &rhs);
sample(const audio_type *s, unsigned int len);
~sample();
sample(unsigned int len=0);
sample(const sample &rhs);
sample(const audio_type *s, unsigned int len);
~sample();
static void set_allocator(base_allocator *s) { m_allocator=s; }
static base_allocator *get_allocator() { return m_allocator; }
static void set_allocator(base_allocator *s) { m_allocator=s; }
static base_allocator *get_allocator() { return m_allocator; }
bool allocate(unsigned int size);
void clear();
void zero();
void set(audio_type val);
void insert(const sample &s, unsigned int pos);
void add(const sample &s);
void mix(const sample &s, unsigned int pos=0);
bool allocate(unsigned int size);
void clear();
void zero();
void set(audio_type val);
void insert(const sample &s, unsigned int pos);
void add(const sample &s);
void mix(const sample &s, unsigned int pos=0);
void mul_mix(const sample &s, unsigned int pos, float m);
void mul_clip_mix(const sample &s, float m);
void remove(unsigned int start, unsigned int end);
void reverse(unsigned int start, unsigned int end);
void move(unsigned int dist);
void get_region(sample &s, unsigned int start, unsigned int end) const;
const audio_type *get_buffer() const {return m_data;}
audio_type *get_non_const_buffer() {return m_data;}
unsigned int get_length() const {return m_length;}
unsigned int get_length_in_bytes() const {return m_length*sizeof(audio_type);}
void expand(unsigned int length);
void shrink(unsigned int length);
void crop_to(unsigned int new_length);
void mul_clip_mix(const sample &s, float m);
void remove(unsigned int start, unsigned int end);
void reverse(unsigned int start, unsigned int end);
void move(unsigned int dist);
// will wrap with minus start index
void get_region(sample &s, int start, unsigned int end) const;
const audio_type *get_buffer() const {return m_data;}
audio_type *get_non_const_buffer() {return m_data;}
unsigned int get_length() const {return m_length;}
unsigned int get_length_in_bytes() const {return m_length*sizeof(audio_type);}
void expand(unsigned int length);
void shrink(unsigned int length);
void crop_to(unsigned int new_length);
audio_type &operator[](unsigned int i) const
{
#ifdef DEBUG
cerr<<"debug..."<<endl;
assert(i<m_length);
#endif
return m_data[i%m_length];
}
audio_type &wrapped_get(int i) const {
return m_data[i%m_length];
}
// _linear interpolated
inline audio_type operator[](float i) const
{
unsigned int ii=(unsigned int)i;
audio_type &operator[](unsigned int i) const {
#ifdef DEBUG
cerr<<"debug..."<<endl;
assert(i<m_length);
#endif
return m_data[i%m_length];
}
#ifdef DEBUG
assert(ii<m_length);
#endif
// linear interpolated
inline audio_type operator[](float i) const {
unsigned int ii=(unsigned int)i;
if (ii==m_length-1) return m_data[ii%m_length];
audio_type t=i-ii;
return ((m_data[ii%m_length]*(1-t))+
(m_data[(ii+1)%m_length])*t);
}
#ifdef DEBUG
assert(ii<m_length);
#endif
if (ii==m_length-1) return m_data[ii%m_length];
audio_type t=i-ii;
return ((m_data[ii%m_length]*(1-t))+
(m_data[(ii+1)%m_length])*t);
}
void set(unsigned int i, audio_type v)
{
#ifdef DEBUG
assert(i<m_length);
#endif
m_data[i%m_length]=v;
}
void set(unsigned int i, audio_type v) {
#ifdef DEBUG
assert(i<m_length);
#endif
m_data[i%m_length]=v;
}
sample &operator=(const sample &rhs)
{
if (get_length()!=rhs.get_length()) allocate(rhs.get_length());
memcpy(m_data,rhs.get_buffer(),get_length_in_bytes());
return *this;
}
sample &operator=(const sample &rhs) {
if (get_length()!=rhs.get_length()) allocate(rhs.get_length());
memcpy(m_data,rhs.get_buffer(),get_length_in_bytes());
return *this;
}
friend ios &operator||(ios &s, sample &sa);
private:
audio_type *m_data;
unsigned int m_length;
private:
audio_type *m_data;
unsigned int m_length;
sample_type m_sample_type;
static base_allocator *m_allocator;
};
static base_allocator *m_allocator;
};
ios &operator||(ios &s, sample &sa);
ios &operator||(ios &s, sample &sa);
}
#endif

7
samplebrain/src/main.cpp
View File

@ -28,6 +28,7 @@
#include <pthread.h>
using namespace std;
using namespace spiralcore;
pthread_mutex_t* m_fuz_mutex;
@ -116,7 +117,7 @@ void fuz() {
search_params p(0.5,0,0,99,0);
cerr<<"starting"<<endl;
fuz_new_brain(p);
//fuz_new_brain(p);
cerr<<"reloading brain"<<endl;
brain source;
@ -166,7 +167,6 @@ void fuz() {
} break;
}
cerr<<"switch"<<endl;
rr.get_params()->m_ratio=fuz_rr_f(0,1);
rr.get_params()->m_n_ratio=fuz_rr_f(0,1);
rr.get_params()->m_fft1_start=fuz_rr_i(0,49);
@ -190,7 +190,6 @@ void fuz() {
}
sleep(1);
cerr<<counter<<endl;
counter++;
}
@ -200,6 +199,6 @@ int main(int argc, char *argv[])
{
m_fuz_mutex = new pthread_mutex_t;
pthread_mutex_init(m_fuz_mutex,NULL);
//unit_test();
unit_test();
fuz();
}

65
samplebrain/src/renderer.cpp
View File

@ -52,11 +52,28 @@ void renderer::reset() {
}
void renderer::process(u32 nframes, float *buf) {
if (!m_playing) return;
if (!find_render_blocks(nframes)) return;
void renderer::process(u32 nframes, float *buf, const block_stream *bs) {
// we can get blocks from the preprocessed target brain
// or the realtime block stream
const block_source *source = (block_source*)bs;
if (source==NULL) {
cerr<<"not using block stream..."<<endl;
source = &m_target;
} else {
if (m_target_index<bs->last_block_index()-10) {
cerr<<"catch up..."<<endl;
m_target_index = bs->last_block_index();
}
if (m_target_index>bs->last_block_index()) {
cerr<<"catch down..."<<endl;
m_target_index = bs->last_block_index();
}
}
render(nframes,buf);
if (!m_playing) return;
if (!find_render_blocks(*source,nframes)) return;
render(*source,nframes,buf);
clean_up();
@ -67,19 +84,20 @@ void renderer::process(u32 nframes, float *buf) {
// target_time = samples time into target stream
// render_time = position in output stream, updated per process - used for offsets
bool renderer::find_render_blocks(u32 nframes) {
bool renderer::find_render_blocks(const block_source &target, u32 nframes) {
// get new blocks from source for the current buffer
// where are we phase?
u32 tgt_shift = m_target.get_block_size()-m_target.get_overlap();
// figure out where are in the target blocks
u32 tgt_shift = target.get_block_size()-target.get_overlap();
m_target_index = m_target_time/(float)tgt_shift;
u32 tgt_end = (m_target_time+nframes)/(float)tgt_shift;
// render end
u32 rnd_end = (m_render_time+nframes)/(float)tgt_shift;
// stuff has changed - recompute and abort
// when stuff has changed, or we have fallen off the end
// then recompute and abort
if (tgt_shift!=m_last_tgt_shift ||
tgt_end>=m_target.get_num_blocks() ||
tgt_end>=target.get_num_blocks() ||
m_source.get_num_blocks()==0) {
reset();
m_last_tgt_shift = tgt_shift;
@ -87,7 +105,7 @@ bool renderer::find_render_blocks(u32 nframes) {
return false;
}
/*
cerr<<"-----------------"<<endl;
cerr<<"tgt start:"<<m_target_index<<endl;
cerr<<"tgt end:"<<tgt_end<<endl;
@ -99,7 +117,7 @@ bool renderer::find_render_blocks(u32 nframes) {
cerr<<"render time (index) "<<m_render_index*tgt_shift<<endl;
cerr<<"real vs index = "<<(s32)m_render_time-(s32)(m_render_index*tgt_shift)<<endl;
cerr<<m_render_blocks.size()<<endl;
*/
// search phase
// get indices for current buffer
@ -109,22 +127,25 @@ bool renderer::find_render_blocks(u32 nframes) {
u32 time=m_render_index*tgt_shift;
u32 src_index=0;
// which algo are we using today?
switch (m_search_algo) {
case BASIC:
src_index = m_source.search(m_target.get_block(m_target_index), m_search_params);
src_index = m_source.search(target.get_block(m_target_index), m_search_params);
break;
case REV_BASIC:
src_index = m_source.rev_search(m_target.get_block(m_target_index), m_search_params);
src_index = m_source.rev_search(target.get_block(m_target_index), m_search_params);
break;
case SYNAPTIC:
case SYNAPTIC_SLIDE:
src_index = m_source.search_synapses(m_target.get_block(m_target_index), m_search_params);
src_index = m_source.search_synapses(target.get_block(m_target_index), m_search_params);
break;
}
if (m_search_algo==SYNAPTIC_SLIDE) {
m_render_blocks.push_back(render_block(src_index,m_target_index,time));
// synaptic slide blocks progression of the target until
// a good enough source block is found
if (m_source.get_current_error()<m_slide_error &&
m_render_index%m_stretch==0) {
m_target_index++;
@ -145,15 +166,16 @@ bool renderer::find_render_blocks(u32 nframes) {
return true;
}
void renderer::render(u32 nframes, float *buf) {
void renderer::render(const block_source &target, u32 nframes, float *buf) {
sample render_pcm(m_source.get_block_size());
// render phase
// render all blocks in list
for (std::list<render_block>::iterator i=m_render_blocks.begin(); i!=m_render_blocks.end(); ++i) {
// get all the pcm data now
const sample &pcm=m_source.get_block(i->m_index).get_pcm();
const sample &n_pcm=m_source.get_block(i->m_index).get_n_pcm();
const sample &target_pcm=m_target.get_block(i->m_tgt_index).get_pcm();
const sample &target_pcm=target.get_block(i->m_tgt_index).get_pcm();
// get the sample offset into the buffer
s32 offset = i->m_time-m_render_time;
@ -163,6 +185,7 @@ void renderer::render(u32 nframes, float *buf) {
u32 block_start = offset;
u32 buffer_start = 0;
if (offset<0) {
// it was running before this buffer
block_start=-offset;
if (block_start>=block_length &&
i->m_position>=block_length) {
@ -177,20 +200,22 @@ void renderer::render(u32 nframes, float *buf) {
// cerr<<"block start:"<<block_start<<endl;
// cerr<<"buffer start:"<<buffer_start<<endl;
// fade in/out autotune
//pitch_scale = pitch_scale*m_autotune + 1.0f*(1-m_autotune);
float pitch_scale = 1;
if (m_autotune>0) {
pitch_scale = m_target.get_block(i->m_tgt_index).get_freq() /
// scale by ratio between target and source
pitch_scale = target.get_block(i->m_tgt_index).get_freq() /
m_source.get_block(i->m_index).get_freq();
// restrict min/max pitch bend
float max = 1+(m_autotune*m_autotune)*100.0f;
if (pitch_scale>(max)) pitch_scale=max;
if (pitch_scale<(1/max)) pitch_scale=1/max;
}
// pitchshifting sounded rubbish with such small clips
//pitchshift::process(pcm,pitch_scale,render_pcm);
if (!i->m_finished) {
@ -234,7 +259,7 @@ void renderer::render(u32 nframes, float *buf) {
void renderer::clean_up() {
// cleanup phase
// delete old ones
// delete old render blocks that have finished
std::list<render_block>::iterator i=m_render_blocks.begin();
std::list<render_block>::iterator ni=m_render_blocks.begin();
while(i!=m_render_blocks.end()) {

9
samplebrain/src/renderer.h
View File

@ -17,6 +17,7 @@
#include <list>
#include <jellyfish/sample.h>
#include "brain.h"
#include "block_stream.h"
#ifndef SB_RENDERER
#define SB_RENDERER
@ -42,8 +43,8 @@ namespace spiralcore {
void reset();
void process(u32 nframes, float *buf);
void old_process(u32 nframes, float *buf);
// block stream should be NULL if we are reading the target brain instead
void process(u32 nframes, float *buf, const block_stream *bs=NULL);
void set_search_algo(search_algo s) { m_search_algo=s; }
void set_playing(bool s) { m_playing=s; }
@ -71,8 +72,8 @@ namespace spiralcore {
private:
bool find_render_blocks(u32 nframes);
void render(u32 nframes, float *buf);
bool find_render_blocks(const block_source &target, u32 nframes);
void render(const block_source &target, u32 nframes, float *buf);
void clean_up();