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

50
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">
@ -1383,9 +1395,26 @@
<string>net</string>
</attribute>
<layout class="QHBoxLayout" name="horizontalLayout_15">
<item>
<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>
</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

5
samplebrain/qt/process_thread.cpp
View File

@ -102,14 +102,18 @@ void process_thread::process() {
}
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") {
@ -117,6 +121,7 @@ void process_thread::process() {
}
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));

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

15
samplebrain/src/brain.cpp
View File

@ -91,7 +91,6 @@ void brain::activate_sound(std::string filename, bool active) {
}
}
void brain::clear() {
m_blocks.clear();
m_samples.clear();
@ -452,9 +451,9 @@ bool brain::unit_test() {
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[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);
@ -470,12 +469,12 @@ bool brain::unit_test() {
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[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);

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

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

@ -31,27 +31,23 @@ float *portaudio_client::m_left_in_data=NULL;
///////////////////////////////////////////////////////
portaudio_client::portaudio_client()
{
portaudio_client::portaudio_client() {
}
/////////////////////////////////////////////////////////////////////////////////////////////
portaudio_client::~portaudio_client()
{
portaudio_client::~portaudio_client() {
detach();
}
/////////////////////////////////////////////////////////////////////////////////////////////
bool portaudio_client::attach(const string &client_name, const device_options &dopt)
{
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 )
{
if( err != paNoError ) {
cerr<<"could not init portaudio_client"<<endl;
Pa_Terminate();
fprintf( stderr, "an error occured while using the portaudio stream\n" );
@ -81,9 +77,8 @@ bool portaudio_client::attach(const string &client_name, const device_options &d
PaStream *stream;
err = Pa_OpenStream(
&stream,
NULL, //&input_parameters,
err = Pa_OpenStream(&stream,
&input_parameters,
&output_parameters,
dopt.samplerate,
dopt.buffer_size,
@ -91,8 +86,7 @@ bool portaudio_client::attach(const string &client_name, const device_options &d
process,
NULL);
if( err != paNoError )
{
if(err != paNoError) {
cerr<<"could not attach portaudio_client: "<<Pa_GetErrorText( err )<<endl;
Pa_Terminate();
return false;
@ -100,8 +94,7 @@ bool portaudio_client::attach(const string &client_name, const device_options &d
err = Pa_StartStream(stream);
if( err != paNoError )
{
if(err != paNoError) {
cerr<<"could not start stream: "<<Pa_GetErrorText( err )<<endl;
Pa_Terminate();
return false;
@ -114,8 +107,7 @@ bool portaudio_client::attach(const string &client_name, const device_options &d
/////////////////////////////////////////////////////////////////////////////////////////////
void portaudio_client::detach()
{
void portaudio_client::detach() {
cerr<<"detaching from portaudio"<<endl;
Pa_Terminate();
m_attached=false;
@ -127,21 +119,17 @@ 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)
{
void *user_data) {
m_buffer_size=frames_per_buffer;
if(run_callback&&run_context)
{
if(run_callback&&run_context) {
// do the work
run_callback(run_context, frames_per_buffer);
}
if (m_right_data && m_left_data)
{
if (m_right_data && m_left_data) {
float *out = (float*)output_buffer;
for (unsigned int n=0; n<m_buffer_size; n++)
{
for (unsigned int n=0; n<m_buffer_size; n++) {
*out=m_left_data[n];
out++;
*out=m_right_data[n];
@ -149,16 +137,15 @@ int portaudio_client::process(const void *input_buffer, void *output_buffer,
}
}
/* if (m_right_in_data && m_left_in_data)
{
if (m_right_in_data && m_left_in_data) {
float *in = (float*)input_buffer;
for (unsigned int n=0; n<m_buffer_size; n++)
{
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;
}

139
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"
@ -26,8 +27,7 @@ sample::sample(unsigned int len) :
m_data(NULL),
m_length(0)
{
if (len)
{
if (len) {
allocate(len);
}
}
@ -51,15 +51,13 @@ m_length(0)
}
sample::~sample()
{
sample::~sample() {
clear();
}
bool sample::allocate(unsigned int size)
{
bool sample::allocate(unsigned int size) {
clear();
m_data = (audio_type*) m_allocator->anew(size*sizeof(audio_type));
@ -70,31 +68,25 @@ bool sample::allocate(unsigned int size)
return (m_data);
}
void sample::clear()
{
if (m_data)
{
void sample::clear() {
if (m_data) {
m_allocator->adelete((char*)m_data);
m_length=0;
m_data=NULL;
}
}
void sample::zero()
{
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++)
{
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)
{
void sample::insert(const sample &s, unsigned int pos) {
// do some checking
assert(pos<=get_length());
@ -102,23 +94,17 @@ void sample::insert(const sample &s, unsigned int pos)
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++)
{
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
{
} 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())
{
if (from_pos<get_length()) {
new_buf[to_pos]=m_data[from_pos];
}
}
@ -131,20 +117,17 @@ void sample::insert(const sample &s, unsigned int pos)
m_length=new_len;
}
void sample::add(const sample &s)
{
void sample::add(const sample &s) {
insert(s,get_length());
}
void sample::mix(const sample &s, unsigned int pos)
{
void sample::mix(const sample &s, unsigned int pos) {
// do some checking
assert(pos<get_length());
unsigned int to_pos=pos;
for (unsigned int from_pos=0; from_pos<s.get_length(); from_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;
@ -152,15 +135,13 @@ void sample::mix(const sample &s, unsigned int pos)
}
}
void sample::mul_mix(const sample &s, unsigned int pos, float m)
{
void sample::mul_mix(const sample &s, unsigned int pos, float m) {
// do some checking
assert(pos<get_length());
unsigned int to_pos=pos;
for (unsigned int from_pos=0; from_pos<s.get_length(); from_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;
@ -168,12 +149,10 @@ void sample::mul_mix(const sample &s, unsigned int pos, float m)
}
}
void sample::mul_clip_mix(const sample &s, float m)
{
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++)
{
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;
@ -185,8 +164,7 @@ void sample::mul_clip_mix(const sample &s, float m)
}
}
void sample::remove(unsigned int start, unsigned int end)
{
void sample::remove(unsigned int start, unsigned int end) {
// do some checking
assert(end<get_length() && start<get_length());
assert(start<=end);
@ -206,11 +184,9 @@ void sample::remove(unsigned int start, unsigned int end)
unsigned int to_pos=0;
for (unsigned int from_pos=0; from_pos<get_length(); from_pos++)
{
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)
{
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
@ -223,8 +199,7 @@ void sample::remove(unsigned int start, unsigned int end)
m_length=new_len;
}
void sample::reverse(unsigned int start, unsigned int end)
{
void sample::reverse(unsigned int start, unsigned int end) {
// do some checking
assert(end<get_length() && start<get_length());
assert(start<=end);
@ -238,8 +213,7 @@ void sample::reverse(unsigned int start, unsigned int end)
unsigned int from_pos=0;
// get the reversed sample
for (from_pos=end; from_pos>start; from_pos--)
{
for (from_pos=end; from_pos>start; from_pos--) {
temp_buf[to_pos]=m_data[from_pos];
to_pos++;
assert(to_pos<=new_len);
@ -248,16 +222,14 @@ void sample::reverse(unsigned int start, unsigned int end)
from_pos=0;
// overwrite back into place
for (to_pos=start; to_pos<end; to_pos++)
{
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)
{
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;
@ -268,8 +240,7 @@ void sample::move(unsigned int dist)
if (from_pos>length) from_pos-=length;
// get the offset sample
for (to_pos=0; to_pos<length; to_pos++)
{
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;
@ -280,32 +251,29 @@ void sample::move(unsigned int dist)
m_length=length;
}
void sample::get_region(sample &s, unsigned int start, unsigned int end) const
{
// 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<get_length());
assert(start<=end);
assert(end<get_length() && start<(s32)get_length());
assert(start<=(s32)end);
unsigned int length=end-start;
s.allocate(length);
unsigned int from_pos=start;
for (unsigned int to_pos=0; to_pos<length; to_pos++)
{
s.set(to_pos,m_data[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)
{
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));
for(unsigned int n=0; n<new_length; n++)
{
for(unsigned int n=0; n<new_length; n++) {
temp[n]=m_data[n];
}
@ -315,8 +283,7 @@ void sample::crop_to(unsigned int new_length)
}
// adds length amount of blank space
void sample::expand(unsigned int length)
{
void sample::expand(unsigned int length) {
sample temp(length);
temp.zero();
@ -324,15 +291,13 @@ void sample::expand(unsigned int length)
}
// shrink the samle by length amount
void sample::shrink(unsigned int 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));
for(unsigned int n=0; n<new_length; n++)
{
for(unsigned int n=0; n<new_length; n++) {
temp[n]=m_data[n];
}

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

@ -32,14 +32,12 @@ 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)
{
inline bool feq(float a, float b, float tol=0.00001) {
return (a>b-tol && a<b+tol);
}
@ -68,7 +66,8 @@ public:
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;
// 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;}
@ -77,8 +76,11 @@ public:
void shrink(unsigned int length);
void crop_to(unsigned int new_length);
audio_type &operator[](unsigned int i) const
{
audio_type &wrapped_get(int i) const {
return m_data[i%m_length];
}
audio_type &operator[](unsigned int i) const {
#ifdef DEBUG
cerr<<"debug..."<<endl;
assert(i<m_length);
@ -86,9 +88,8 @@ public:
return m_data[i%m_length];
}
// _linear interpolated
inline audio_type operator[](float i) const
{
// linear interpolated
inline audio_type operator[](float i) const {
unsigned int ii=(unsigned int)i;
#ifdef DEBUG
@ -102,16 +103,14 @@ public:
}
void set(unsigned int i, audio_type 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)
{
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;

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();