[C++] Guitar Synth

[AndryBest]

Ciao a tutti!

Qualche giorno fa, mentre suonavo la chitarra, mi è venuta in mente questa strana idea "e se la usassi per suonare un synth?". Allora mi sono documentato è ho scoperto di nun aver inventato nulla di nuovo (http://it.wikipedia.org/wiki/Guitar_synth)... :fagiano:
So che esistono molti pedali capaci di fare una cosa del genere (http://www.youtube.com/watch?v=hNYUdS3KbLY) ma sarebbe possibile fare tutto questo via software?
Secondo me sì!
Ecco quindi come è nato questo progetto! :D

Il tutto l'ho concepito così:

Acquisizione della chitarra (amplificata dall'amp) dalla linea-in Acquisizione del segnale vero e proprio usando una libreria come PortAudio
Calcolo dell FFT con la libreria FFTw
Calcolo dei picchi di frequenza così da rilevare le note suonate Creazione di una porta MIDI virtuale :eek:
Invio delle note alla porta MIDI
Elaborazione dei dati da parte di un qualunque synth software (tipo FL Studio)


Che ve ne pare?
Ovviamente chi vuole può dare una mano come meglio preferisce!

Per quanto riguarda portaudio non dovrebbe essere così difficile, anche perchè poco tempo fa ne avevo usato un binding per python (PyAudio)...

Per quanto riguarda l'FFT, invece, non ci ho capito praticamente nulla! :confused:
Sul sito ufficiale c'è questo tutorial (http://www.fftw.org/fftw2_doc/fftw_2.html) ma non so da che parte cominciare.
Innanzitutto so che l'FFT, sistema veloce di calcolo del DFT, prende in ingresso una serie di numeri complessi in funzione del tempo e ne restituisce altrettanti in funzione della frequenza. Il mio dubbio è: cosa "contengono" questi complessi? Mi è sembrato di capire che i dati in ingresso siano composti dalla parte reale, che identifica il tempo (espresso in cosa? in secondi? o semplicemente il numero della sequenza?), e da quella immaginaria che identifica l'ampiezza. Poi i dati in uscita sono la frequenza nella parte reale e la "quantità" nell'immaginaria. Giusto? :confused: :mbe:

Tornando alla programmazione: è possibile creare una porta MIDI virtuale? con quali librerie?

Possibilmente vorrei riuscire a creare qualcosa di completamente cross-platform! Come dotazione ho Ubuntu 10.10 a 64 bit e Windows 7 a 32 bit (compilatore MinGW).

Grazie in anticipo dei consigli e degli aiuti!

[AndryBest]

Ho fatto qualche prova con l'fft.

Ho usato questo codice per analizzare un file creato con audacity.
Per la precisone è una sinusoide a 440Hz salvata come raw (senza header) a 8 bit signed con bitrate 2^14 = 16384.

#include <iostream>
#include <cstdlib>
#include <fstream>
#include <cmath>

#include <fftw3.h>
// link a "libfftw3.a"

using namespace std;

int main(int argc, char *argv[]){
int bitrate=16384;
int i=0;
fstream f,o;
f.open("sin_440.raw",ios::in | ios::binary);
o.open("out.txt",ios::out);
if(!f){
cout << "Impossibile aprire f!" << endl;
exit(1);
}
if(!o){
cout << "Impossibile aprire o!" << endl;
exit(1);
}


fftw_complex *in, *out;
fftw_plan p;

in = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * bitrate);
out = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * bitrate);
p = fftw_plan_dft_1d(bitrate, in, out, FFTW_FORWARD, FFTW_PATIENT);

for (i=0;i<bitrate;i++){
in[i][0] = (double)i;
in[i][1] = (double)f.get();
}

cout << "START" << endl;
fftw_execute(p);
cout << "END" << endl;

for (i=0;i<bitrate;i++){
//o << "F = " << out[i][0] << "\tQ = " << out[i][1] << endl;
o << out[i][0] << endl << out[i][1] << endl;
}

fftw_destroy_plan(p);
fftw_free(in);
fftw_free(out);

o.close();
f.close();
return 0;
}

Il file "out.txt" generato alterna parte reale e immaginaria per ogni riga.
Ottengo una cosa tipo questa (ne metto solo un pezzo, il file intero è nel file zip il cui link è alla fine del messagio):
1.3421e+08
2.08873e+06
-8113.89
4.27225e+07
-9071.27
2.13617e+07
-7788.18
1.42411e+07
-8207.81
...

Poi per rendermi conto di cosa è venuto fuori ho fatto questo codice per tracciare un grafico su ROOT:
#include <iostream>
#include <cstdlib>
#include <stdio.h>

using namespace std;

void main(){
FILE *f=fopen("out.txt","r");
TGraph *g=new TGraph();
int i;
double x,y;
for (i=0;i<16384;i++){
fscanf(f,"%lf",&x);
fscanf(f,"%lf",&y);
cout << x << "\t" << y << endl;
g->SetPoint(i,x,y);
}
fclose(f);
g->Draw("APL");
}


I risultati che ottengo sono nel file zip.
Il primo (a.svg) è la panoramica dei dati. L'unica cosa che si nota è una strana "onda" intorno agli zeri. :eek:
Negli altre immagini (b.svg c.svg e d.svg) ci sono gli zoom su questa zona.

Sinceramente ha tutta l'aria di NON essere uno spettro! :D

Cosa sto sbagliando? So che questi dati vanno normalizzati per ottenere il vero valore in frequenza, ma come? In cosa consiste la normalizzazione?
Oppure dovrei dare in ingresso solo un reale invece di un complesso come descritto QUI (http://www.fftw.org/fftw3_doc/One_002dDimensional-DFTs-of-Real-Data.html#One_002dDimensional-DFTs-of-Real-Data)?

Grazie ancora! ;)


ZIP (http://www.megaupload.com/?d=58AD9I4Y)

[EDIT] Mi sono dimenticato di mettere il file "sin_440.raw" nello zip, quindi l'ho allegato...

[AndryBest]

Ciao a tutti!

Per quanto riguarda l'fft ho risolto usando la funzione di fftw con l'input in numeri reali. Poi per ottenere il vero spettro ho dovuto calcolare il modulo del complesso per l'asse y e il numero del dato per l'asse x. Ad esempio il 440esimo valore corrisponde a 440Hz con intensità data da sqrt(r*r+i*i), dove r è la parte reale ed i l'immaginaria.

Ora manca solo la periferica midi virtuale. Cercando su internet ho trovato la libreria RtMidi. Qualcuno l'ha mai provata? Ci sono alternative migliori?

[cionci]

Molto interessante questa cosa ;)

[AndryBest]

Dall'FFT ottenevo dei dati un po' sballati, ad esempio con molte armoniche dispari, tutto da una sola sinusoide. Ho risolto lavorando con campioni da 16bit anzi che da 8bit.

Ora il problema è l'acquisizione dell'audio. Dato che PortAudio non mi è sembrato molto semplice da usare, oltre al fatto che la documentazione non è molto chiara, voglio provare a usare RtAudio che, a quanto ho letto, dovrebbe essere abbastanza semplice.
Tuttavia non riesco a compilare i sorgenti!
Estraggo il tar, "./configure", "make" e mi da errore! Ecco cosa ottengo:


andrea@andrea-ubuntu:~$ cd rtaudio-4.0.8/

andrea@andrea-ubuntu:~/rtaudio-4.0.8$ ./configure
checking for g++... g++
checking for C++ compiler default output file name... a.out
checking whether the C++ compiler works... yes
checking whether we are cross compiling... no
checking for suffix of executables...
checking for suffix of object files... o
checking whether we are using the GNU C++ compiler... yes
checking whether g++ accepts -g... yes
checking for ranlib... ranlib
checking for ar... /usr/bin/ar
checking for gcc... gcc
checking whether we are using the GNU C compiler... yes
checking whether gcc accepts -g... yes
checking for gcc option to accept ISO C89... none needed
checking how to run the C preprocessor... gcc -E
checking for grep that handles long lines and -e... /bin/grep
checking for egrep... /bin/grep -E
checking for ANSI C header files... yes
checking for sys/types.h... yes
checking for sys/stat.h... yes
checking for stdlib.h... yes
checking for string.h... yes
checking for memory.h... yes
checking for strings.h... yes
checking for inttypes.h... yes
checking for stdint.h... yes
checking for unistd.h... yes
checking sys/ioctl.h usability... yes
checking sys/ioctl.h presence... yes
checking for sys/ioctl.h... yes
checking for unistd.h... (cached) yes
checking whether to compile debug version... no
checking for gettimeofday... yes
checking build system type... x86_64-unknown-linux-gnu
checking host system type... x86_64-unknown-linux-gnu
checking for audio API... using ALSA
checking for snd_pcm_open in -lasound... yes
checking for pthread_create in -lpthread... yes
configure: creating ./config.status
config.status: creating rtaudio-config
config.status: creating Makefile
config.status: creating tests/Makefile

andrea@andrea-ubuntu:~/rtaudio-4.0.8$ make
g++ -O2 -Wall -Iinclude -fPIC -DHAVE_GETTIMEOFDAY -D__LINUX_ALSA__ -c RtAudio.cpp -o RtAudio.o
/usr/bin/ar ruv librtaudio.a RtAudio.o
/usr/bin/ar: creating librtaudio.a
a - RtAudio.o
ranlib librtaudio.a
g++ -fPIC -shared -Wl,-soname,. -o .4.0.7 RtAudio.o -lpthread -lasound
/bin/ln -s librtaudio.so.4.0.7 librtaudio.so
/usr/bin/ar ruv librtaudio.a RtAudio.o
ranlib librtaudio.a
g++ -fPIC -shared -Wl,-soname,. -o .4.0.7 RtAudio.o -lpthread -lasound
/bin/ln -s librtaudio.so.4.0.7 librtaudio.so
/bin/ln: creazione del collegamento simbolico "librtaudio.so": File già esistente
make: *** [librtaudio.so] Errore 1



Suggerimenti? :stordita:

[cionci]

Edita il Makefile e aggiungi l'opzione f a ln.

ln -sf librtaudio.so.4.0.7 librtaudio.so

[AndryBest]

Edita il Makefile e aggiungi l'opzione f a ln.

ln -sf librtaudio.so.4.0.7 librtaudio.so

Grazie cionci! :mano: :yeah:
Ora non dà più l'errore ma sulle proprietà del link creato con quel "ln" dice "Tipo: collegamento (interrotto)" e se cerco di aprirlo appare un messaggio che mi chiede "il collegamento <<librtaudio.so>> è interrotto. Spostare nel cestino?" .
Comunque sia ho provato a compilare i file di test della cartella "tests" e a esseguirli e non ho ottenuto errori, quindi penso sia tutto a posto.

Il problema ora è capire come si usa! :D
Su google ho trovato solo descrizioni dei file sorgente che, saranno anche utili, ma sarebbe più comoda qualche semplice guida, anche in inglese...
Qualcuno sa dove potrei trovarla?
Oppure qualcuno è così magnanimo ( :asd: ) da darmi qualche consiglio? :eh:
Sbirciando il source ho visto che c'è da creare un oggetto a cui passo i soliti dati (canali, f. di campionamento, ecc...) più la funzione di callback che però è di tipo "RtAudioCallback"! Come la posso creare?

[AndryBest]

Ciao a tutti!

Per quanto riguarda l'acquisizione dell'audio ho risolto.
Ho lasciato perdere RtAudio che, non so per quale motivo, dava problemi nelle librerie e ho usato PortAudio. Ho abbandonato anche la callback per optare per una lettura diretta (ovviamente bloccante) dello stream.

Per il midi ho usato RtMidi che è veramente semplice da usare.
Ecco cosa ho usato per le prove:


#include <iostream>
#include <cstdlib>
#define __WINDOWS_MM__ // RIMUOVERE PER COMPILARE SU LINUX
#include "RtMidi.h"
//link a "RtMidi.o"

#if defined(__WINDOWS_MM__)
#include <windows.h>
#define SLEEP( milliseconds ) Sleep( (DWORD) milliseconds )
#else
#include <unistd.h>
#define SLEEP( milliseconds ) usleep( (unsigned long) (milliseconds * 1000.0) )
#endif

using namespace std;

int make(){
char out[128];
int i;
for (i=0;i<128;i++){out[i]='\x00';}
}


int main(int argc, char *argv[]){
char message[128];
int len=0;

// RtMidiOut constructor
RtMidiOut *midiout = 0;
try {
midiout = new RtMidiOut();
}
catch ( RtError &error ) {
error.printMessage();
exit( EXIT_FAILURE );
}
string portName;
unsigned int iter = 0, nPorts = midiout->getPortCount();
if ( nPorts == 0 ) {
cout << "Non ci sono porte disponibile!" << endl;
exit(1);
}
if ( nPorts == 1 ) {
cout << endl << midiout->getPortName() << "\t aperta!" << endl;
}
else {
for ( iter=0; iter<nPorts; iter++ ) {
portName = midiout->getPortName(iter);
cout << " Porta n. " << iter << ": " << portName << '\n';
}
do {
cout << "\nApri porta n.: ";
cin >> iter;
cin.ignore();
} while ( iter >= nPorts );
}
midiout->openPort(iter);

//Dati{
vector<unsigned char> start;
start.push_back(192);
start.push_back(5);

vector<unsigned char> on;
on.push_back(144);
on.push_back(60);
on.push_back(50);

vector<unsigned char> off;
off.push_back(128);
off.push_back(60);
off.push_back(40);
//}

midiout->sendMessage(&start);

int nota,vel,state;
cout << "STATO NOTA PRESSIONE" << endl;
while (1){
cin >> state >> nota >> vel;
cin.ignore();
if (state==1){
on[1]=nota;
on[2]=vel;
midiout->sendMessage(&on);
cout << "OK!" << endl;
}
else if (state==0){
off[1]=nota;
off[2]=vel;
midiout->sendMessage(&off);
cout << "OK!" << endl;
}
}


delete midiout;
}




Su linux l'ho provato con LMMS e funziona alla grande!
Su windows l'unica porta che rileva è la "Microsoft GS Wavetable Synth" e su FL Studio (celebre DAW) questa è riconosciuta solo come uscita, non come ingresso. Pertanto FL non me la fa scegliere e così non riesco a comunicare!

Allora ho pensato dovessi creare una porta midi virtuale; così ho compilato "midiout.cpp" presente nella cartella "tests" assieme ai sorgenti.
All'avvio del programma mi chiede se voglio creare una porta virtuale o usarne una esistente.
Tuttavia scegliendo la prima opzione ottengo questo messaggio:
RtMidiOut::openVirtualPort: cannot be implemented in Windows MM MIDI API!

Che posso fare? C'è un modo per aggirare il problema?
A quanto ho capito la versione di RtMidi per windows non può creare una porta midi virtuale! :muro:
Che altra libreria potrei usare? :what: :confused: