Optage lyd og converte til Beep's

Du skal finde frekvens (og amplituden) på det det du har optaget, der gør man med en FFT (eller DFT) funktion, søg på nettet.

Men vær opmærksom på at det meste lyd indeholder mere end 1 frekvens.

Du skal finde frekvens (og amplituden) på det det du har optaget, der gør man med en FFT (eller DFT) funktion, søg på nettet.

Men vær opmærksom på at det meste lyd indeholder mere end 1 frekvens.

Ja okay vil jeg prøve.

Ja men tænkte sådan på at tag et "øjebliks" billede af lyd frekvensen eller amplitude og så vente f.eks. 10 ms igen og så gøre det. Det vil nok gi halvdårlig lyd men det jo os ok hehe.

Men vil kigge lidt på det.

10 ms er i underkanten.
Men selv inden for et lille interval er der mange toner samtidig.
Forskellen på lyden fra forskellige instrumenter der spiller samme tone er (bl.a.) sammensætningen af toner/frekvenser.

10 ms er i underkanten.
Men selv inden for et lille interval er der mange toner samtidig.
Forskellen på lyden fra forskellige instrumenter der spiller samme tone er (bl.a.) sammensætningen af toner/frekvenser.

Hmm ja kom også til at tænke på at man jo heller ikke kan instille amplituden via standard Beep komandoen...
Men burde man ikke kunne det måske med en lidt mere indviklet buzzer funktion?

Hvis du kikker her:
http://damb.dk/snip/playtone.html

Er der en PlayTone funktion, i denne angiver tallene 128 og 127 amplituden, summen skal være mindre end 256.

Hvis du kikker her:
http://damb.dk/snip/playtone.html

Er der en PlayTone funktion, i denne angiver tallene 128 og 127 amplituden, summen skal være mindre end 256.

Mm ganske nice funktion... godt nok ikke buzzeren der laver lyden. Men kan sikkert give lidt sjov alligevel hehe


er lidt fasineret af den her kode:

char *buffer = (char *)malloc(SAMPLE_RATE*duration/1000);
  for (x = 0; x < SAMPLE_RATE*duration/1000; x++)
     buffer[x] = (char )(128.0 + (127.0 * sin(2.0 * MY_PI * freq * x / SAMPLE_RATE)));

Kunne man evt. lave den omvendte funktion og på den måde få nogle frekvenser ud på den måde?

Den "omvendte" funktion hedder FFT

Den "omvendte" funktion hedder FFT

Nå okay fair fair. Det vel bare at konvertere den til en int istedet for en char og så lave nogle lidt besværlige beregninger. Tror jeg har en ide til hvordan jeg skal gøre det hehe. Vil lige eksperimentere lidt med det.

Har lige 2 nye spørgsmål:

1: Hvis man nu vil afspille en lyd i i et "uendelig" loop eller hva man nu kan sige det, og gærne vil ændre tone. Er den rigtige metode så at lave en ny buffer og header og så sende headeren med buffer igen? Uden at lukke headeren helt med waveOutClose? Håber du forstår...

2: Er der en måde hvorpå man kan sætte bufferen på pause eller afslutte den helt selv om den ikk er færdig?

Du kan sætte flere buffere i kø, men de skal lukkes med waveOutClose til slut.

Der er en waveOutPause funktion.

Jeg mener at kunne huske at man kan stoppe den uden at den er færdig, men det giver nogen voldsomme klik i højtaleren og er ikke helt problemfrit. Det bedste er at have tilpas små buffere og så lade dem køre til ende.

Du kan sætte flere buffere i kø, men de skal lukkes med waveOutClose til slut.

Der er en waveOutPause funktion.

Jeg mener at kunne huske at man kan stoppe den uden at den er færdig, men det giver nogen voldsomme klik i højtaleren og er ikke helt problemfrit. Det bedste er at have tilpas små buffere og så lade dem køre til ende.

Ja den gir nogle ikke så gode lyde med mindre den giver fejl hvilket også kan ske...

Når jeg prøver at lukke den med waveOutClose så fortæller fejlmeddelelsen mig at jeg skal prøve at resette headeren. Det prøver jeg så med waveOutReset.. Men dette låser bare koden så resten ikke bliver eksekveret... Hmmm

Jeg kan ikke helt finde nogle FFT funktioner jeg kan få til at virke... har fundet følgende 2:

http://www.dsprelated.com/showmessage/69924/1.php

#include <math.h>
#define M_PI 3.14159265359


void fft(float *x,float *y,int order,int param)
{
unsigned int n,l,e,f,i,j,o,o1,j1,i1,k;
float u,v,z,c,s,p,q,r,t,w,a;


n=1u<<order;


for(l=1;l<=order;l++)
{

u=1.0;
v=0.0;
e=1u<<(order-l+1);
f=e/2;

z=M_PI/f;

c=cos(z);
s=sin(z);

if(param==FFT) s=-s;

for(j=1;j<=f;j++)
{
for(i=j;i<=n;i+=e)
{
o=i+f-1;
o1=i-1;
p=x[o1]+x[o];
r=x[o1]-x[o];
q=y[o1]+y[o];
t=y[o1]-y[o];
x[o]=r*u-t*v;
y[o]=t*u+r*v;
x[o1]=p;
y[o1]=q;
}
w=u*c-v*s;
v=v*c+u*s;
u=w;
}
}


j=1;

for(i=1;i<n;i++)
{
if(i<j)
{
j1=j-1;
i1=i-1;
p=x[j1];
q=y[j1];
x[j1]=x[i1];
y[j1]=y[i1];
x[i1]=p;
y[i1]=q;
}

k=n/2;

while(k<j)
{
j=j-k;
k=k/2;
}

j+=k;
}

if(param==FFT) return;

a=1.0/n;
for(k=0;k<n;k++)
{
x[k]*=a;
y[k]*=a;
}
return;
}

og

http://www.ddj.com/cpp/199500857

void four1(double* data, unsigned long nn)
{
    unsigned long n, mmax, m, j, istep, i;
    double wtemp, wr, wpr, wpi, wi, theta;
    double tempr, tempi;


    // reverse-binary reindexing
    n = nn<<1;
    j=1;
    for (i=1; i<n; i+=2) {
        if (j>i) {
            swap(data[j-1], data[i-1]);
            swap(data[j], data[i]);
        }
        m = nn;
        while (m>=2 && j>m) {
            j -= m;
            m >>= 1;
        }
        j += m;
    };


    // here begins the Danielson-Lanczos section
    mmax=2;
    while (n>mmax) {
        istep = mmax<<1;
        theta = -(2*M_PI/mmax);
        wtemp = sin(0.5*theta);
        wpr = -2.0*wtemp*wtemp;
        wpi = sin(theta);
        wr = 1.0;
        wi = 0.0;
        for (m=1; m < mmax; m += 2) {
            for (i=m; i <= n; i += istep) {
                j=i+mmax;
                tempr = wr*data[j-1] - wi*data[j];
                tempi = wr * data[j] + wi*data[j-1];


                data[j-1] = data[i-1] - tempr;
                data[j] = data[i] - tempi;
                data[i-1] += tempr;
                data[i] += tempi;
            }
            wtemp=wr;
            wr += wr*wpr - wi*wpi;
            wi += wi*wpr + wtemp*wpi;
        }
        mmax=istep;
    }
}

Sorry for den lidt dårlige kode opsætning (copy paste hehe )