amiga-news ENGLISH VERSION
.
Links| Forum| Kommentare| News melden
.
Chat| Umfragen| Newsticker| Archiv
.

amiga-news.de Forum > Programmierung > Tonerkennung [ - Suche - Neue Beiträge - Registrieren - Login - ]

1 -2- 3 4 5 6 7 Letzte [ - Beitrag schreiben - ]

02.08.2006, 13:04 Uhr

gni
Posts: 1106
Nutzer
[quote]DariusBrewka:
C code:
void FFT(signed char *in, signed char *out, int m) {
    double x[(int) pow(2, m)];
    double y[(int) pow(2, m)];

Nicht jeder C Compiler kann mit diesen Array-Definitionen umgehen, da die Größe erst zur Laufzeit ermittelt wird.

[ - Antworten - Zitieren - Direktlink - ]

02.08.2006, 13:52 Uhr

bubblebobble
Posts: 707
Nutzer
@MaikG

>>Hast Du Dir mal das Beispiel für die DTMF-Erkennung mittels
>>Goertzel-Algorithmus angesehen? Der scheint für diesen Zweck
>>deutlich effizienter zu sein, insb. wenn man das Programm in
>>Basic für einen nicht-FPU ausgestatteten Amiga schreiben will.

>Wo gibt es das?

Wie der Goertzel Algo funktioniert, hat Holger doch oben als Link referenziert.
Wenn dir aber bereits der FFT Algo zu kompliziert ist, obwohl hier C und Basic Code gepostet wurde, dann wird dir das auch nicht weiter helfen. Evtl. nimmst du dann besser die easyFFT lib, oder steigst auf Amiblitz2 um und nimmst die fft.inlcude, wie man die anwendet habe ich ja oben gepostet. Vielleicht wandle ich die auch mal in eine Library um, aber da ich alles in Amiblitz2 code brauche ich das für mich nicht.

Ob der Goertzel Algo aber besser geeignet ist weiss ich nicht.
Schliesslich kann man bei der FFT auch die Kenntniss der anderen Frequenzbänder ausnutzen, d.h. du akzeptierst den Piep Ton nur, wenn er einen Ausschlag verursacht an der gewünschten Frequenz, aber NUR wenn die anderen Frequenzen ruhig bleiben. Das geht beim Goertzel nicht. Da würdest du auch akzeptieren, wenn alle möglichen anderen Frequenzen zu hören sind, z.B. beim weissen Rauschen.


--
Thilo Köhler, Author von:
HD-Rec, Samplemanager, ArTKanoid, Monkeyscript, Toadies, AsteroidsTR, TuiTED, PosTED, TKPlayer, TKUnpacker
Homepage: http://www.hd-rec.de



[ Dieser Beitrag wurde von bubblebobble am 02.08.2006 um 13:53 Uhr geändert. ]

[ - Antworten - Zitieren - Direktlink - ]

02.08.2006, 18:13 Uhr

MaikG
Posts: 5172
Nutzer
>Wie der Goertzel Algo funktioniert, hat Holger doch oben als Link
>referenziert.

Oh, hatte ich übersehen. Ich dachte jetzt sowas gibts auch in
einer Library Form.

>Evtl. nimmst du dann besser die easyFFT lib, oder steigst auf

Ja, ich muss mir das mal ausdrucken und in ruhe gucken wie man
die Library ansteuert.

>Amiblitz2 um und nimmst die fft.inlcude,

Nein Amiblitz2 ist nix für mich.

[ - Antworten - Zitieren - Direktlink - ]

02.08.2006, 23:33 Uhr

DariusBrewka
Posts: 899
[Benutzer gesperrt]
[quote]
Original von gni:
Zitat:
DariusBrewka:
C code:
void FFT(signed char *in, signed char *out, int m) {
    double x[(int) pow(2, m)];
    double y[(int) pow(2, m)];

Nicht jeder C Compiler kann mit diesen Array-Definitionen umgehen, da die Größe erst zur Laufzeit ermittelt wird.

Ja und manche können andere Sachen nicht, ich schreibe Programme so, daß ich die bei mir compilieren kann. Ich würde vermuten, das Daten dieser Art vom compiler sowieso auf den Stack verfrachtet werden, anders wäre es auch garnicht so "richtig" möglich.

[ - Antworten - Zitieren - Direktlink - ]

03.08.2006, 01:26 Uhr

Holger
Posts: 8089
Nutzer
Zitat:
Original von gni:
Nicht jeder C Compiler kann mit diesen Array-Definitionen umgehen, da die Größe erst zur Laufzeit ermittelt wird.

Aber jeder C99-konforme C-Compiler kann das. Und auf ältere Compiler Rücksicht nehmen, hilft einem nicht wirklich. Schließlich soll der Compiler dem Programmierer Arbeit abnehmen und nicht umgekehrt.
Zitat:
Original von DariusBrewka:
Ich würde vermuten, das Daten dieser Art vom compiler sowieso auf den Stack verfrachtet werden, anders wäre es auch garnicht so "richtig" möglich.

Natürlich landet jede Variable, deren Speicher nicht explizit durch den Programmierer vom heap angefordert wurde, auf dem Stack. Aber was hat das mit der Frage nach den arrays mit dynamischer Länge zu tun?

mfg
--
Good coders do not comment. What was hard to write should be hard to read too.

[ - Antworten - Zitieren - Direktlink - ]

03.08.2006, 02:30 Uhr

DariusBrewka
Posts: 899
[Benutzer gesperrt]
Zitat:
Original von Holger:
Natürlich landet jede Variable, deren Speicher nicht explizit durch den Programmierer vom heap angefordert wurde, auf dem Stack. Aber was hat das mit der Frage nach den arrays mit dynamischer Länge zu tun?


z.B. daß es wesentlich einfacher zu realisieren ist AUCH zur Laufzeit ein Array zu belegen.

Man braucht da garnicht erst groß zu überlegen, was das an Aufwand ist ob man nun ein Array von 10 doubles auf'm Stack packt und dafür höchstens ein add #80,sp (auf 68k) braucht, oder das Ganze irgendwie versucht im Normalen Speicher zu hinterlegen.

Gerade weil dieses Array im Stack landet sehe ich nicht das Problem warum es Schwierig sein sollte, wäre es nicht so, könnte ich gni's Einwand verstehen.


[ - Antworten - Zitieren - Direktlink - ]

03.08.2006, 13:02 Uhr

Holger
Posts: 8089
Nutzer
Zitat:
Original von DariusBrewka:
Man braucht da garnicht erst groß zu überlegen, was das an Aufwand ist ob man nun ein Array von 10 doubles auf'm Stack packt und dafür höchstens ein add #80,sp (auf 68k) braucht, oder das Ganze irgendwie versucht im Normalen Speicher zu hinterlegen.

Es geht nicht darum, ein array auf den stack zu packen, sondern ein array, dessen Größe beim Funktionsbeginn nicht bekannt ist. Die normale, bzw. althergebrachte Methode, code zu generieren, reserviert nämlich zu Beginn den Platz für alle Variablen der Funktion.

Mal abgesehen davon, dass es eher lea -80(a7),a7 auf dem 68k wäre, steht es jedem natürlich frei, sich seine eigene Programmiersprache zu erschaffen, oder in Assembler zu programmieren, wo alles möglich ist. In C war es jedenfalls jahrzehntelang nicht möglich.

mfg
--
Good coders do not comment. What was hard to write should be hard to read too.

[ - Antworten - Zitieren - Direktlink - ]

03.08.2006, 14:17 Uhr

bubblebobble
Posts: 707
Nutzer
Ihr werdet langsam off-topic, zumal Maik das nicht in C coden will.

MaikG:
Die FFT wird dir sicher die besten Ergebnisse liefern.

Du wirst am Ende eine Zahlenfolge bekommen, wie Darius sie gepostet hat, wo man leicht erkennen kann, ob die zwei Sinustöne drin sind oder nicht. Also sowas wie

1 2 1 4 1 3 20 1 3 2 1 2 24 1 2 1 1

Du musst dann nur gucken, ob "deine" Frequenzen stark verteten sind, und alle anderen recht niedrig sind.
Bei Goertzel Algo bekomsmt du nur raus, dass deine Frequenzen drin sind, aber nicht ob noch andere Frequenzen drin sind. Dadruch könntest du Geräsuche positiv klassifizieren, die du nicht haben willst (false positives), z.B. weisses Rauschen, wo alle Freqeunzen stark vertreten sind, und das willst du ja auf jeden Fall vermeiden.

--
Thilo Köhler, Author von:
HD-Rec, Samplemanager, ArTKanoid, Monkeyscript, Toadies, AsteroidsTR, TuiTED, PosTED, TKPlayer, TKUnpacker
Homepage: http://www.hd-rec.de


[ - Antworten - Zitieren - Direktlink - ]

03.08.2006, 22:33 Uhr

Holger
Posts: 8089
Nutzer
Zitat:
Original von bubblebobble:
Du musst dann nur gucken, ob "deine" Frequenzen stark verteten sind, und alle anderen recht niedrig sind.
Bei Goertzel Algo bekomsmt du nur raus, dass deine Frequenzen drin sind, aber nicht ob noch andere Frequenzen drin sind.

Das ist Unsinn. Beim DTMF dürfen nur zwei Frequenzen der acht zu analysierenden ein Signal ergeben und ihre Energielevel müssen in einem definierten Verhältnis mit einer genau spezifizierten maximalen Toleranz zueinander stehen, während natürlich die anderen sechs unterhalb einer Rauschschwelle liegen müssen. Das ist bei weissem Rauschen nicht gegeben und bei natürlichen Tönen treten diese Töne normalerweise nicht in diesem Verhältnis zueinander auf. Dazu wurden extra diese disharmonischen Frequenzen gewählt.

Wenn doch, hilft Dir auch FFT nicht weiter. Der gepostetete Beispielcode enthält außerdem bereits die vollständige Analyse für die DTMF-Erkennung und ist dabei kompakter als der FFT-Code, der diese entsprechende Analyse noch gar nicht enthält.

mfg
--
Good coders do not comment. What was hard to write should be hard to read too.

[ - Antworten - Zitieren - Direktlink - ]

04.08.2006, 12:09 Uhr

bubblebobble
Posts: 707
Nutzer
Ok, Holger. Soll er Goertzel nehmen.

--
Thilo Köhler, Author von:
HD-Rec, Samplemanager, ArTKanoid, Monkeyscript, Toadies, AsteroidsTR, TuiTED, PosTED, TKPlayer, TKUnpacker
Homepage: http://www.hd-rec.de


[ - Antworten - Zitieren - Direktlink - ]

07.08.2006, 18:27 Uhr

MaikG
Posts: 5172
Nutzer
So hab mir die Library jetzt mal ganz in Ruhe angesehen, einfach ist das
irgendwie auch nicht. Man kann da nicht einfach einen Sample hinschicken
und man bekommt dann die Frequenzen. Da muss man irgendwie eine Funktion
aufrufen, diese dann mit der nächsten einstellen und dann noch diese
ganzen Tags wo dann von PI usw. die rede ist...

[ - Antworten - Zitieren - Direktlink - ]

08.08.2006, 11:04 Uhr

DariusBrewka
Posts: 899
[Benutzer gesperrt]
Zitat:
Original von MaikG:
So hab mir die Library jetzt mal ganz in Ruhe angesehen, einfach ist das
irgendwie auch nicht. Man kann da nicht einfach einen Sample hinschicken
und man bekommt dann die Frequenzen. Da muss man irgendwie eine Funktion
aufrufen, diese dann mit der nächsten einstellen und dann noch diese
ganzen Tags wo dann von PI usw. die rede ist...


Sorry, was erwartest du? Bubblebobble hat dach gesagt was zu tun ist und mit der lib sollte das Alles schon einfacher sein oder? oder willst du das Bubblebobble oder Ich dir eine Funktion schreiben, die nur für Deinen Zweck gedacht ist?.

Nee irgendwas mußt du auch schon machen, sonst brauchst du garnicht erst Programmieren.


[ - Antworten - Zitieren - Direktlink - ]

08.08.2006, 12:00 Uhr

bubblebobble
Posts: 707
Nutzer
Zitat:
oder willst du das Bubblebobble oder Ich dir eine Funktion schreiben, die nur für Deinen Zweck gedacht ist?.
... und zwar in Maxon Basic. In C und Blitzbasic haben wir dir ja schon den Code gepostet. Alles was du machen müsstest ist, das Input Format sicher zu stellen (bei meinem Code 32bit samples) und am Ende die Frequenzen auszuwerten.

Zitat:
Nee irgendwas mußt du auch schon machen, sonst brauchst du garnicht erst Programmieren.
Das stimmt. Ich wäre damals froh gewesen, wenn mir jemand die FFT (sogar mit Beispiel Code) erklärt hätte oder wenn es Wikipedia gegeben hätte. Nur gab es damals noch kein Internet und keine Foren, und ich musste Bücher welzen und von der Theorie auf den eigentlichen Code schliessen. Dafür hab ich es aber auch verstanden und dabei gelernt, mich durch zubeissen.

P.S. Die API der easyFFT lib ist zugegebenermassen etwas verkorkst, aber sooooo kompliziert ist das auch wieder nicht.
Vielleicht wäre es ja besser, dein Rahmenprogram in Amilbitz zu konvertieren und meine fft.inlcude zu benutzen.
Dann liefe das mehr oder weniger hinaus auf:

code:
ffthandle.l = fft_init{order}
If ffthandle
  fft_sethanning{ffthandle}

  ...

  ; so oft aufrufen wie du willst:
  fft_do_mono{ffthandle,sourcebuffer,destbuffer}

  ...

  fft_free{ffthandle)
End If


Einfacher gehts eigentlich nicht.
Das erstellen eines ffthandle ist notwendig, weil man für die FFT einen Kontext vorbereiten muss. Das könnte man zwar implizit on-the-fly machen, aber dann könnte man nicht zwischen verschiedenen FFT Fenster größen wählen, ohne Overhead.

--
Thilo Köhler, Author von:
HD-Rec, Samplemanager, ArTKanoid, Monkeyscript, Toadies, AsteroidsTR, TuiTED, PosTED, TKPlayer, TKUnpacker
Homepage: http://www.hd-rec.de


[ - Antworten - Zitieren - Direktlink - ]

08.08.2006, 18:28 Uhr

MaikG
Posts: 5172
Nutzer
>... und zwar in Maxon Basic. In C und Blitzbasic haben wir dir ja
>schon den Code gepostet. Alles was du machen müsstest ist, das
>Input Format sicher zu stellen (bei meinem Code 32bit samples) und
>am Ende die Frequenzen auszuwerten.


Das kann ich nicht umwandeln, sowohl die beispiele und die Samples.
Davon abgesehen nehme ich mal an das eine 8->32bit umwandlung
zuviel rechenzeit in Anspruch nehmen würde.


Mein zeugs in Amiblitz zu wandeln ist noch komplizerter,
immerhin ist da Sprachausgabe(nicht Translator), Spracherkennung,
Sensoranalysen, Abwehrsteuerung usw. drin.

[ - Antworten - Zitieren - Direktlink - ]

08.08.2006, 22:39 Uhr

DariusBrewka
Posts: 899
[Benutzer gesperrt]
Zitat:
Original von MaikG:
Das kann ich nicht umwandeln, sowohl die beispiele und die Samples.
Davon abgesehen nehme ich mal an das eine 8->32bit umwandlung
zuviel rechenzeit in Anspruch nehmen würde.


???, eine 8->32 Bit Konvertierung ist etwas was nun wirklich keine CPU überfordert, selbst einen 68000/7.14MHz nicht. Ich wüßte auch nicht was da so viel Zeit brauchen sollte. Und wieso kannst du die nicht Umwandeln? Es gibt keine Sprache, welche ich kenne wo eine Umwandlung kein einfaches Zuweisen ist.

In c(++)

signed char buffer1[10]
signed int buffer2[10]

buffer2[1] = buffer1[1]

oder in Basic

DIM %buffer1[10]
DIM &buffer2[10]

buffer2[1] = buffer1[1]

Ich habe mit Basic schon lange nichts mehr gemacht und kenne das Zeichen für BYTE und für LONG Nicht, darum % und &.

Was macht eine 8->32 Bit Konvertierung?, Bits 0-7 vom 8 Bit Wert werden einfach in Bit 0-7 des Zielregisters geschrieben und die Bits 8-31 werden einfach mit Bit 7 des Quellwertes aufgefüllt.

D.h. wenn der 8 Bit Wert von der Quelle in der Binärdarstellung

01110101 ist ist Ziel
0000000000000000000000000110101

ist die Quelle
11000011 (Bit 7=1 -> Zahl ist Negativ) dann ist das Ziel

11111111111111111111111111000011, d.h. selbst wenn die CPU das nicht selber könnte wäre es nicht allzu schwer das selber zu machen.


[ - Antworten - Zitieren - Direktlink - ]

08.08.2006, 22:44 Uhr

bubblebobble
Posts: 707
Nutzer
Im Vergleich zur FFT würde die Umwandlung von 8->32bit so gut wie nicht ins Gewicht fallen.
Man muss sowieso früher oder später nach Float wandeln, oder man implementiert eine integer FFT, aber auch da wäre 32bit Int ratsam.

--
Thilo Köhler, Author von:
HD-Rec, Samplemanager, ArTKanoid, Monkeyscript, Toadies, AsteroidsTR, TuiTED, PosTED, TKPlayer, TKUnpacker
Homepage: http://www.hd-rec.de


[ - Antworten - Zitieren - Direktlink - ]

09.08.2006, 10:54 Uhr

MaikG
Posts: 5172
Nutzer
>oder in Basic

>DIM %buffer1[10]
>DIM &buffer2[10]

>buffer2[1] = buffer1[1]


buffer%(10)
buffer&(10)

buffer&=buffer%

Man kann dann aber auch gleich die werte vom Sampler in
einer Long Variabelen legen. Ich versuche mal eines der Beipiele
umzuwandeln.

[ - Antworten - Zitieren - Direktlink - ]

09.08.2006, 22:56 Uhr

MaikG
Posts: 5172
Nutzer
Okay ich habs mal probiert:

FUNCTION fft_makeptable&(order&) REM DO the dirty stuff (oh my god, I have headache!)
npoints& = 1 LSL order&
ptr& = AllocMem_(npoints&*4,MEMF_CLEAR&)
IF ptr&
FOR n& = npoints&-1 TO 0 STEP -1
ibit& = 0
in& = 0
FOR bit&=order&-1 TO 0 STEP -1
mask& = 1 LSL bit&
IF (n& AND mask&) THEN in& = in& | (1 LSL ibit)
ibit&+1
NEXT bit&
POKEL ptr& + (n&*SizeOf&) , in&
NEXT n&
END IF
fft_makeptable&=ptr&
END FUNCTION


Statement fft_create_win{*fft_handle.fft_handle,alpha!,beta!}
If *fft_handle
If \wtable=0 AND \ptable><0
\wtable = AllocMem_(\npoints&*SizeOf&,0)
If \wtable
f! = \npoints&
temp! = 2.0 * Pi / (f-1)
perptr& = \ptable
winptr& = \wtable
FOR i&=0 TO \npoints&-1
f! = i&
Poke.f winptr& + PEEKL(perptr&+i&*4)*4, alpha! - beta!*COS(temp!*f)
NEXT i&
END IF
END IF
END IF

End Statement

; init a hamming window
Statement fft_create_hamming{*fft_handle.fft_handle}
fft_create_win {*fft_handle, 0.54 , 0.46}
End Statement

; init a hanning window
Statement fft_create_hanning{*fft_handle.fft_handle}
fft_create_win {*fft_handle, 0.5 , 0.5}
End Statement

Statement fft_permutate_mono {*fft_handle.fft_handle,buffer_src&,buffer_dst&}
If *fft_handle
IF buffer_src&
IF buffer_dst&
perptr& = \ptable
winptr& = \wtable
If winptr
FOR n&=0 TO \npoints&-1
Poke.f buffer_dst& , PEEKL(buffer_src& + PEEKL(perptr&)*4) * Peek.f(winptr&)
Poke.f buffer_dst&+4 , 0
buffer_dst=buffer_dst& + 8
winptr&=winptr& + 4
perptr&=perptr& + 4
NEXT n&
ELSE
FOR n&=0 TO \npoints&-1
Poke.f buffer_dst& , PEEKL(buffer_src& + PEEKL(perptr&)*4)
Poke.f buffer_dst&+4 , 0
buffer_dst&=buffer_dst& + 8
perptr&=perptr& + 4
NEXT n&
END IF
END IF
END IF
END IF
END Statement

Statement fft {*fft_handle.fft_handle,buffer_dst&,dir&}
IF *fft_handle
IF buffer_dst&
*sinT.sinT = \sintable
*cosT.sinT = &\sintable\w[\order&]

le& = 0
le2& = 1
buffer_r& = buffer_dst&
buffer_i& = buffer_dst& + 4

FOR k& = 0 TO \order&-1
le& = le2&
le2& LSL 1
le16& = (le2& LSL 3)
le8& = (le& LSL 3)
ur! = 1.0
ui! = 0.0
wr! = *cosT\w[k]
wi! = dir& * *sinT\w[k]
FOR j& = 0 TO le&-1
p1r& = buffer_r& + (j& LSL 3)
p1i& = buffer_i& + (j& LSL 3)
p2r& = p1r&+le8&
p2i& = p1i&+le8&
FOR i& = j& TO \npoints&-1 STEP le2&
tr! = Peek.f(p2r&) * ur! - Peek.f(p2i&) * ui!
ti! = Peek.f(p2r&) * ui! + Peek.f(p2i&) * ur!
Poke.f p2r&, Peek.f(p1r&) - tr
Poke.f p2i&, Peek.f(p1i&) - ti
Poke.f p1r&, Peek.f(p1r&) + tr
Poke.f p1i&, Peek.f(p1i&) + ti
p1r& + le16& : p1i& + le16&
p2r& + le16& : p2i& + le16&
NEXT i&
tr = (ur!*wr! - ui!*wi!)
ui = (ur!*wi! + ui!*wr!)
ur! = tr
NEXT j&
NEXT k&
END IF
END IF
End Statement

In Maxon gibts aber kein Statement, Peek/Pook.f, SinT, CosT
* \ [] und kein LSL

[ - Antworten - Zitieren - Direktlink - ]

10.08.2006, 00:19 Uhr

Holger
Posts: 8089
Nutzer
Zitat:
Original von MaikG:
In Maxon gibts aber kein Statement, Peek/Pook.f, SinT, CosT
* \ [] und kein LSL

Vielleicht solltest Du besser den C-Code als Ausgangsbasis nehmen. Dort ist LSL der Operator <<, genauso wie in MaxonBasic. Wenn Poke.l in MaxonBasic POKEL ist, müsste poke.f der Logik nach POKEF sein, gibt es aber wahrscheinlich gar nicht. Müsstest Du Dir selbst definieren, ala
Basic code:
DEFINE FUNCTION PEEKF!(adr&)
tmp!=0
POKEL VARPTR(tmp!),PEEKL(adr&)
RETURN tmp!
END FUNCTION

DEFINE SUB POKEF(adr&,value!)
POKEL adr&,PEEKL(VARPTR(value!))
END SUB

Ich hoffe, die Syntax stimmt halbweg, Basic benutz ich wahrlich selten. Das da oben funktioniert allerdings nur, wenn MaxonBasic die Zahlen auch im IEEE...-Format ablegt, was vermutlich nur der Fall wäre, wenn es eine Version mit FPU-Unterstützung beim Compilieren unterstützt, andernfalls ist es höchstwahrscheinlich FFP, was man über die mathlibs konvertieren müsste, aber das sprengt jetzt den Rahmen.

Die eckigen Klammern sind wohl bei Dir runde, falls Du die tables mittels DIM nachbildest, das hast Du ja schon selbst gepostet.

Und die Backslashes...sind eine Augenqual...

mfg
--
Good coders do not comment. What was hard to write should be hard to read too.

[ - Antworten - Zitieren - Direktlink - ]

10.08.2006, 11:57 Uhr

bubblebobble
Posts: 707
Nutzer
@MaikG

Um es 1:1 umzusetzen, fehlt dir noch der Rahmen.

Hier findest du die fft.inlcude als BB2 code und als ASCII:

http://www.hd-rec.de/Archive/fft_test.lha

Zum Konvertieren:

"Statement" ist in Blitzbasic eine Funktion ohne Rückgabewert.

LSL ist der Bit-Schiebeoperator << in C.

Poke.f macht das gleiche wie Poke.l, nur mit Floats statt mit 32bit Integern.


SinT und CosT sind einfache Arrays, keine Funktionen.

Die eckigen Klammern sind Arrays, die innerhalb eines Komplexen Datentyps definiert werden.

Der * signalisiert, dass es eine komplexe Zeiger Variable handelt, also in dem Fall *ffthandle vom Typ ffthandle, der dessen Speicher mit AllocMem allociert wurde.

Die Backslashes bedeuten, dass es sich um ein Element eines komplexen Typ handelt. Also z.B. *ffthandle\sintable
Wenn nichts davor steht, ist es immer das letzte "UsePath" gemeint, hier IMMER *ffthandle.

Grundsätzlich ist der Code so aufgebaut, dass jede Funktion den
"fft_handle" haben will, das ist eine Structur vom Typ fft_handle.
Darin sind alle Variablen gespeichert, die mit \ angesprochen werden.

Ich hoffe das hilft dir weiter.



@Holger:

Alles Gewöhnungssache. Für mich sehen die vielen "&" in Maxonbasic fuchtbar aus.

--
Thilo Köhler, Author von:
HD-Rec, Samplemanager, ArTKanoid, Monkeyscript, Toadies, AsteroidsTR, TuiTED, PosTED, TKPlayer, TKUnpacker
Homepage: http://www.hd-rec.de



[ Dieser Beitrag wurde von bubblebobble am 10.08.2006 um 11:57 Uhr geändert. ]

[ - Antworten - Zitieren - Direktlink - ]

13.08.2006, 10:15 Uhr

MaikG
Posts: 5172
Nutzer
>Vielleicht solltest Du besser den C-Code als Ausgangsbasis nehmen.

Ist der vollständig oder bräuchte ich da auch nochmehr drumrum?


>Um es 1:1 umzusetzen, fehlt dir noch der Rahmen.
>Hier findest du die fft.inlcude als BB2 code und als ASCII:
>http://www.hd-rec.de/Archive/fft_test.lha

Da ist ja noch viel mehr.

[ - Antworten - Zitieren - Direktlink - ]

13.08.2006, 13:29 Uhr

bubblebobble
Posts: 707
Nutzer
Zitat:
>Um es 1:1 umzusetzen, fehlt dir noch der Rahmen.
>Hier findest du die fft.inlcude als BB2 code und als ASCII:
>http://www.hd-rec.de/Archive/fft_test.lha

Da ist ja noch viel mehr.

8o

Du brauchst nicht alles, nur die Funktionen die ich dir hier als Beispiel mini-Quellcode gepostet habe, und einige, die von diesen Funktioen aufgerufen wurden.
Da sind halt noch andere Funktionen drin, z.B. für Stereo, für inverse FFT, Hamming window, cos/sin <=> magnitude/phase und ein build-in Demo, was dir ein paar Coeffizienten berechnet.

Also wenn dich das aus der Bahn wirft, sorry, lass es lieber sein mit dem Programmieren. So wie du dich hier anstellst frage ich mich ernsthaft, wie du den Rest hinbekommen hast.
Zitat:
Mein zeugs in Amiblitz zu wandeln ist noch komplizerter,
immerhin ist da Sprachausgabe(nicht Translator), Spracherkennung,
Sensoranalysen, Abwehrsteuerung usw. drin.

--
Thilo Köhler, Author von:
HD-Rec, Samplemanager, ArTKanoid, Monkeyscript, Toadies, AsteroidsTR, TuiTED, PosTED, TKPlayer, TKUnpacker
Homepage: http://www.hd-rec.de


[ - Antworten - Zitieren - Direktlink - ]

13.08.2006, 13:36 Uhr

Ralf27
Posts: 2779
Nutzer
[quote]
Original von bubblebobble:
Zitat:
Also wenn dich das aus der Bahn wirft, sorry, lass es lieber sein mit dem Programmieren. So wie du dich hier anstellst frage ich mich ernsthaft, wie du den Rest hinbekommen hast.

Ich kann MaikG schon etwas verstehn, denn ich versteh BB noch weniger als C.
Bzw. versteh ich da sogar die Beispiele in MBasic von denn MBasic-Disks weniger als Beispiele in C im Internet.
Aber dennoch hab ich auch schon ein paar Programme geschrieben.
--
http://www.alternativercomputerclub.de.vu

[ - Antworten - Zitieren - Direktlink - ]

13.08.2006, 15:00 Uhr

bubblebobble
Posts: 707
Nutzer
Der FFT Algorithmus ist fast pure Arithmetik. Der sieht in jeder Sprache gleich aus, alleine der Varialben Zugriff unterscheidet sich leicht, aber ich glaube jeder kann sich vborstellen, was z.B. Peek.f() macht, oder a = b + c, oder For n=0 to m ... Next.

Das ist was anderes als z.B. eine Spiel oder eine App, wo man viele Sprachen-Spezifische Befehle nutzt, die ein "outsider" nicht kennt und im Handbuch nachschlagen müsste um zu verstehen, was da genau passiert.

Aber vielleicht habe ich etwas überreagiert. Sorry MaikG.

--
Thilo Köhler, Author von:
HD-Rec, Samplemanager, ArTKanoid, Monkeyscript, Toadies, AsteroidsTR, TuiTED, PosTED, TKPlayer, TKUnpacker
Homepage: http://www.hd-rec.de


[ - Antworten - Zitieren - Direktlink - ]

27.08.2006, 23:35 Uhr

MaikG
Posts: 5172
Nutzer
Ja, hatte eine weile keine Zeit und war Krank.
Nun habe ich mir nochmal easyFFT angesehen und glaube zumindest
zu verstehen was ich der Library übergeben muss.
Nur irgendwas läuft da schief im C Beispiel z.B. muss bei new nur
ein Parameter übergeben werden, Basic sagt dann aber da Fehlt noch
was. Da ich etwas von Tag gelesen habe, hab ich dann immer TAGEND&
dahinter gesetzt. Wird jetzt zwar Compilert aber die Rückgabewerte
sind nicht so wie sie sein müssten oder anders gesagt kein Ergebniss.

Hier das Programm:

'$INCLUDE easyFFT.bc
'$INCLUDE exec.bh
'$INCLUDE dos.bh

LIBRARY "easyFFT.library"
LIBRARY OPEN "exec.library"
LIBRARY OPEN "dos.library"

DECLARE FUNCTION eFFTnew& LIBRARY '
DECLARE FUNCTION eFFTcalc& LIBRARY '
DECLARE FUNCTION eFFTfree& LIBRARY '
DECLARE FUNCTION eFFTsetdat& LIBRARY '
DECLARE FUNCTION eFFTgetdat& LIBRARY '

POKEB &hBFE301,0 REM ParallelPort auf Eingang

DIM temptag&(10)
DIM sample%(10000)

REM ParallelPort daten 128 entspricht 0 Linie
1
IF PEEKB(&hBFE101)>180 THEN
PRINT "jetzt"
3 t!=TIMER
2 IF TIMER-t<.00012207 THEN 2 REM 8192 HZ
INCR a%:sample%(a%)=PEEKB(&hBFE101):IF a%=10000 THEN GOSUB 4
GOTO 3
END IF

GOTO 1

4 myhl&=eFFTnew&(150&,TAG_END&)
x&=eFFTsetdat& (myhl&, eFFT_SIG&, VARPTR(sample%(0)),TAG_END&)
PRINT x&;"setdat1"
x&=eFFTsetdat& (myhl&, eFFT_DOPD&, TRUE&,TAG_END&)
PRINT x&;"setdat2"
x&=eFFTcalc&(myhl&,TAG_END&)
PRINT x&;"calc"
dptr&=eFFTgetdat&(myhl&, eFFT_ASP&,TAG_END&)
IF dptr& THEN
PRINT PEEKL(dptr&)
PRINT PEEKL(dptr&+4)
PRINT PEEKL(dptr&+8)
PRINT PEEKL(dptr&+12)
PRINT PEEKL(dptr&+16)
END IF
REM FFT
a%=0
RETURN

[ - Antworten - Zitieren - Direktlink - ]

28.08.2006, 09:17 Uhr

Mad_Dog
Posts: 1944
Nutzer
Vielleicht hilft Dir dieser Artikel zum Thema FFT weiter:

http://de.wikipedia.org/wiki/Schnelle_Fourier-Transformation

Und hier noch was zum Thema:

http://de.wikipedia.org/wiki/Frequenzbereich

--
http://www.norman-interactive.com

[ Dieser Beitrag wurde von Mad_Dog am 28.08.2006 um 09:20 Uhr geändert. ]

[ - Antworten - Zitieren - Direktlink - ]

28.08.2006, 09:39 Uhr

MaikG
Posts: 5172
Nutzer
Oh, Mathe war viele Jahre her.
Ich möchte lieber die Library benutzen, dann brauche ich nicht
Rechnen und FFT an sich nicht verstehen.

[ - Antworten - Zitieren - Direktlink - ]

28.08.2006, 12:37 Uhr

Mad_Dog
Posts: 1944
Nutzer
Zitat:
Original von MaikG:
Oh, Mathe war viele Jahre her.
Ich möchte lieber die Library benutzen, dann brauche ich nicht
Rechnen und FFT an sich nicht verstehen.


Du solltest Dir aber erstmal das eigentliche Problem bewusst machen, bevor Du von irgendwoher wild Code umherkopierst.

Du willst einen Ton erkennen - also eine bestimmte Frequenz.

Das kannst Du anhand des Amplitudenspektrums herausfinden. Das Eingangssignal wird dabei nach seinen Frequenzbereichen aufgeschlüsselt. Wenn Du dann siehst, daß der Frequenzbereich, denn Du suchst einen besonders hohen Ausschlag hat, weißt Du, daß jetzt gerade Dein gesuchter Ton kommt.

Um Mathe und vor allem Physik wirst Du bei diesem Problem nicht herumkommen... sehs mal positiv: Du lernst noch was dabei. ;)
--
http://www.norman-interactive.com

[ - Antworten - Zitieren - Direktlink - ]

28.08.2006, 15:13 Uhr

MaikG
Posts: 5172
Nutzer
>Du solltest Dir aber erstmal das eigentliche Problem bewusst machen,
>bevor Du von irgendwoher wild Code umherkopierst.
>Du willst einen Ton erkennen - also eine bestimmte Frequenz.

Ähm, mit der Library werden keine kentnisse benötigt.
Man gibt einen Sample und so dort hin und bekommt eine Frequenzliste.
Welche Frequenzen z.B. DTMF 1 hat weiss ich.


>Um Mathe und vor allem Physik wirst Du bei diesem Problem nicht
>herumkommen... sehs mal positiv: Du lernst noch was dabei. ;)

Etwas Mathe kann ich ja hatte glaube ich eine 2 und Physik 1.
Das leben ist kurz und man kann leider in der Zeit nicht
alles lernen...

[ - Antworten - Zitieren - Direktlink - ]

31.08.2006, 14:34 Uhr

MaikG
Posts: 5172
Nutzer
Keiner eine Idee?
Hab schon überlegt ob man ein Sample mit dem Basic Programm
in die Ram Disk legt und dann mit einem C Programm das Sample
auswertet.

[ - Antworten - Zitieren - Direktlink - ]


1 -2- 3 4 5 6 7 Letzte [ - Beitrag schreiben - ]


amiga-news.de Forum > Programmierung > Tonerkennung [ - Suche - Neue Beiträge - Registrieren - Login - ]


.
Impressum | Datenschutzerklärung | Netiquette | Werbung | Kontakt
Copyright © 1998-2022 by amiga-news.de - alle Rechte vorbehalten.
.