Soundsamples für ATARI STE- und TT-Computer - Einladen & Abspielen
Die Rechner der ATARI-STE- und TT-Reihe bieten die einfache Möglichkeit, digitalisierte Geräusche oder Musik in verschiedenen (aber festen) Frequenzlagen abzuspielen. Leider bietet das Betriebssystem keine entsprechende Funktion, welche diese Arbeit erledigt, so daß man darauf angewiesen ist, selber dafür zu sorgen.
Dies erledigt die Unit in Listing 1. Sie stellt einfach zu benutzende Funktionen zum Laden und Abspielen von Soundsamples bereit. In Listing 2 findet sich ein kurzes Programm zum Testen der obigen Unit.
Über Samples ...
Als Samples bezeichnet man im allgemeinen digitalisierte Geräusche oder Musik. Analoge Signale werden über einen A/D-(Analog-Digital)-Konverter in digitale Signale umgewandelt. Da analoge Signale beliebige Amplitudenwerte (Pegel) besitzen können, müssen sie auf ein festes digitales Raster abgebildet werden.
... und ihre Darstellung im ATARI
Im Falle der DMA im ATARI, welche für die Verarbeitung der Samples zuständig ist, wird jedem Analog- ein Digitalwert zwischen -128 (negative Amplitude) und +127 (positive Amplitude) zugeordnet. Allerdings gibt es auch Samples, deren binäre Darstellung derart ist, daß das (negative) Minimum bei 0 und das (positive) Maximum bei 255 liegt. Solche Samples klingen natürlich auf einem ATARI nicht korrekt, können aber durch ein einfaches Programm umgewandelt werden. Es wird also, in beiden Fällen, jeweils ein Byte (8 Bit) zur Kodierung verwendet. (Im Gegensatz z.B. zu CD-Playern. Diese verwenden i.a. 16 Bit.)
Nun müssen diese Daten auch wiedergegeben werden können. Hierzu findet ein zu oben umgekehrter Vorgang Verwendung. Ein Digital-Analog-Konverter berechnet aus den (recht wenigen) 255 möglichen Pegelwerten wieder das analoge Signal. Man erhält also in keinem Fall wieder den Verlauf des originalen analogen Pegels, sondern nur eine (mehr oder weniger) gute Annäherung.
Die Geschwindigkeit, mit welcher diese Umrechnung erfolgt bzw. mit welcher das Sample wiedergegeben wird, läßt sich einstellen. Sie wird als Sample-Rate bezeichnet. In der Analog-Digital-Konvertierung gilt folgendes: Je höher die Sample-Rate ist, desto genauer, d.h. in kleineren, engeren, Zeitintervallen kann ein analoges Signal abgetastet werden, um so eine bessere Kopie des originalen Signals zu erhalten. Bei der Digital-Analog-Konvertierung gibt die Sample-Rate primär die Abspielgeschwindigkeit des Samples an, wobei sie natürlich mit der Sample-Rate der A/D-Konvertierung identisch sein sollte, um eine originalgetreue Wiedergabe zu ermöglichen. Beim ATARI sind dies 6.25,12,25 oder 50 kHz. Zum Beispiel werden bei 12 kHz 12000 digitale Daten (also etwa 12 KBytes) in der Sekunde in ein analoges Signal umgerechnet und wiedergegeben. Dies ist recht viel und erklärt auch, wieso Samples i.a. soviel Speicherplatz benötigen.
Des weiteren gibt es noch die Möglichkeit, die Daten in Stereo wiederzugeben. In diesem Fall wird jeweils immer abwechselnd ein Byte auf dem rechten und dem linken Kanal ausgegeben. Damit verdoppelt sich natürlich der Speicherbedarf für ein einziges Sample.
Als letztes gibt es noch die Möglichkeit ein einzelnes Sample nur ein einziges Mal abzuspielen oder beliebig oft zu wiederholen.
Implementierung
Funktion sam_load (Dateiname): Ergebnis.
Parameter:
- Dateiname: Pfadname des zu ladenden Samples
- Ergebnis: negativer Wert: Fehler, positiver Wert: Referenznummer des geladenen Samples
Ein Sample wird durch obige Funktion geladen und in einem Speicherbereich, der angefordert wird, abgelegt. Zur Verwaltung aller eingeladenen Samples wird ein Feld-Record benutzt, der jeweils die Länge des Samples und die Anfangsadresse des reservierten Speicherbereiches enthält. Bei erfolgreichem Laden erhält man ein Handle, mit dem das Sample referenziert wird. Sollte nicht genügend Platz für alle zu ladenden Samples in dem Record sein, kann die Konstante max_samples, zu finden im Kopf der Unit, entsprechend hochgesetzt werden.
Prozedur sam_play(ld,Wie_oft, Frequenz, Mono_Stereo);
Parameter:
- Id: Referenznummer des abzuspielenden Samples
- Wie-oft: Sample stoppen (0), Sample einmal abspielen (1), Sample dauernd abspielen (3)
- Frequenz: 6.25 kHz(O), 12.5 kHz(1), 25 kHz(2), 50 kHz(3)
- Mono_Stereo: Mono (1), Stereo (0)
Die Prozedur übernimmt das Abspielen der Samples. Ihr werden außer der Referenznummer eines Samples die oben erwähnten Charakteristika übergeben (Es empfiehlt sich, die Konstantenvereinbarungen aus dem Unit-Kopf zu verwenden.) Diese Daten werden nun in die entsprechenden DMA-Register des ATARI übertragen. Da die Register in einem geschützten Speicherbereich liegen, muß der Zugriff im Supervisormodus erfolgen. Dies erledigt die erste Anweisung in der Prozedur. Sobald alle Daten in die Register geschrieben wurden, beginnt die DMA mit dem Abspielen des Samples. Dies geschieht im Hintergrund und allein durch die DMA, d.h. der Hauptprozessor wird durch den Vorgang nicht beeinträchtigt.
Prozedur sam_free(Id);
Parameter:
- Id: Referenznummer des zu entfernenden Samples aus dem Speicher, bzw. -1: alle Samples werden aus dem Speicher entfernt.
Vor Verlassen eines Programmes, in dem die Unit Verwendung findet, sollten die Speicherbereiche, in denen die Samples abgelegt sind, durch obige Prozedurfreigegeben werden. Andernfalls könnte man plötzlich einige hundert Kilobyte RAM-Speicher vermissen.
Listing 2 stellt eine kleine Testumgebung für die Unit dar. Ein Sample kann ausgewählt werden, und die Abspiel-Charakteristika lassen sich einstellen. Klicken auf Abbruch in der Fileselectorbox führt zum Verlassen des Programmes.
Die Unit ist recht einfach und modular aufgebaut, und es sollte keine zu großen Probleme bereiten, sie für andere Pascal-Versionen oder auf andere Sprachen anzupassen.
DMA-Hardware-Register
Alle in Bild 1 aufgeführten Register sind Wortregister, sie haben also eine Länge von 2 Byte, von denen allerdings immer nur das niederwertige Byte (Registeradresse+1) benutzt wird.
(* Laden und Abspielen von Soundsamples auf *)
(* Atari STE und TT Computer *)
(* (w) Marco Feikert (10'92) & (1'93) *)
(* (c) MAXON Computer 1993 *)
{$X+}
UNIT sample;
INTERFACE
USES tos;
CONST
max_samples = 150;
stop = 0;
einmal = 1;
dauernd = 3;
mono = 1;
stereo= 0;
fr_6 = 0;
fr_12 = 1;
fr_25 = 2;
fr_50 = 3;
VAR
i: INTEGER;
FUNCTION sam_load(name: STRING): INTEGER;
PROCEDURE sam_free(was: INTEGER);
PROCEDURE sam_play(id, wie_oft, frequenz, mono_stereo: INTEGER);
(* -------------------------------------------*)
IMPLEMENTATION
TYPE
sam_arr = RECORD
start: POINTER; (* Startadresse *)
len: LONGINT; (* Länge *)
END;
VAR
sam: ARRAY[0 .. max_samples] OF sam_arr;
(* Lädt Sample name, return: Id-Nummer bzw. *)
(* -1: Datei nicht gefunden, *)
(* -2: Speicherreservierungsfehler *)
(* -3: Einladefehler *)
(* -4: Recordarray vollständig belegt *)
FUNCTION sam_load(name: STRING): INTEGER;
VAR
frei, i, fh, return: INTEGER;
amount, len: LONGINT;
p: POINTER;
dat: DTAPtr;
BEGIN
P:=NIL;
len:=0;
return:=-4;
i: =0;
(* Freien Platz suchen *)
REPEAT
IF sam[i].start=NIL THEN
return:=i
ELSE
INC(i);
UNTIL (i>max_samples) OR (return<>-4);
IF return<>-4 THEN BEGIN (* Dateilänge bestimmen *)
i:=FSFIRST(name,0);
IF i=0 THEN BEGIN
dat:=FGETDTA;
len:=dat^.d_length;
END;
(* Dateilänge=0 => nicht gefunden *)
IF len=0 THEN
return:=-1
ELSE BEGIN
frei:=return;
(* Speicherplatz reservieren *)
p:=Malloc(len);
IF p=NIL THEN
return:=-2
ELSE BEGIN
return:=-3;
fh: =Fopen(name,FO_READ);
IF fh>0 THEN BEGIN
(* Sample einiesen *)
amount:=Fread(fh,len.p);
IF amount=len THEN BEGIN
sam[frei].start:=p;
sam[frei].len:=len;
return:=frei;
END;
Fclose(fh);
END;
END;
END;
END;
(* Einladefehler, Speicher freigeben *)
IF return=-3 THEN
Mfree(p);
sam_load:=return;
END;
(* Speicherplatz von Samples freigeben *)
(* was: >=0: Für ein Sample freigeben *)
(* -1: Für alle Samples freigeben *)
PROCEDURE sam_free(was: INTEGER);
VAR
i: INTEGER;
BEGIN
IF was>=0 THEN BEGIN
IF sam[was].start<>NIL THEN BEGIN
Mfree(sam[was].start);
sam[was].start:=NIL;
sam[was].len:=0;
END;
END
ELSE BEGIN
i:=0;
REPEAT
IF sam[i].start<>NIL THEN BEGIN
Mfree(sam[i].start);
sam[i].start:=NIL;
sam[i].len:=0;
END;
INC(i);
UNTIL i>max_samp1es;
END;
END;
(* 1 Longint in 4 Bytes aufteilen *)
(* b1: Highbyte ... b4: Lowbyte *)
PROCEDURE split_var(v: LONGINT; VAR b1, b2, b3, b4: BYTE);
VAR
p: POINTER;
BEGIN
p:=ADDR(v);
b1:=BYTE(p^);
b2:=BYTE(POINTER(LONGINT(p)+1)^);
b3:=BYTE(POINTER(LONGINT(p)+2)^);
b4:=BYTE(POINTER(LONGINT(p)+3)^);
END;
(* Sample abspielen *)
(* id: Samplekennung aus sam„load() *)
(* wie_oft: 0: Stop, 1: Einmal, 3: Endlos *)
(* frequenz: 0: 6.25 Khz, 1: 12.5 Khz, *)
(* 2: 25 Khz, 3: 50 Khz *)
(* mono_stereo: 0: Stereo, 1: Mono *)
(* bzw. Konstantenvereinbarungen aus *)
(* Programmkopf benutzen *)
PROCEDURE sam_play(id, wie_oft, frequenz, mono_stereo: INTEGER);
VAR
l, Start, ende, os: LONGINT;
b1, b2, b3, b4: BYTE;
BEGIN
IF sam[id].len>0 THEN BEGIN (* Gültige Id ? *)
(* Supervisormodus an *)
os:=Super(NIL);
(* Startadresse eintragen *)
l:=$ff8902;
start:=LONGINT(sam[id].start);
split_var(start,b1,b2,b3,b4);
BYTE(POINTER(l+1)^):=b2;
BYTE(POINTER(l+3)^):=b3;
BYTE(POINTER(l+5)^):=b4;
(* Endadresse eintragen *)
l:=$ff890e;
ende:=LONGINT(sam[id].start)+sam[id].len;
split_var(ende,b1,b2,b3,b4);
BYTE(POINTER(l+1)^):=b2;
BYTE(POINTER(l+3)^):=b3;
BYTE(POINTER(l+5)^):=b4;
(* Frequenz eintragen *)
1:=$ff8920;
IF mono_stereo=1 THEN
INC(frequenz, 128);
WORD(POINTER(l)^):=frequenz;
(* Abspielen starten/stoppen *)
l:=$ff8900;
WORD(POINTER(1)^):=wie_oft;
(* Supervisormodus aus *)
Super(POINTER(os));
END;
END;
BEGIN
(* Record initialisieen *)
i:=0;
REPEAT
sam[i].start:=NIL;
sam[i].len:=0;
INC(i);
UNTIL i>maxsamples;
END.
(* Kurzes Beispielprogram zum Testen *)
(* der Sample-Unit *)
{$X+}
PROGRAM test_sample;
USES gem,sample;
VAR
s1, s2, s3: STRING;
len, i, x: INTEGER;
freq, m_s: INTEGER;
BEGIN
REPEAT
s1:='';
s2:='';
(* Sample auswählen *)
fsel_input(s1,s2,i);
IF (i<>0) AND (s2<>'') THEN BEGIN
len:=LENGTH(s1);
WHILE COPY(s1,len,1)<>'\' DO
DEC(len);
s2:=COPY(s1,1,len)+s2;
(* Laden *)
x:=sam_load(s2);
IF x>=0 THEN BEGIN (* Laden erfolgreich *)
(* ACHTUNG: Bei Verwendung von Write's in der *)
(* niedrigen oder mittleren Auflösung gibt es *)
(* einen Runtimeerror in Pure Pascal (Version *)
(* 13.Aug) in Verbindung mit NVDI 2.1 ! *)
write('Frequenz: (0-3):');
readln(freq);
write('Stereo/Mono (0-1):');
readln(m_s);
(* und abspielen *)
sam_play(x,einmal,freq,m_s);
sam_free(x);
END;
END;
UNTIL (i=0) OR (s2='');
END.
| Registeradresse | Bit-Belegung | Erklärung |
|---|---|---|
| $ff8900 | **** **** **** **BA A=0, B=0: DMA-Sound ausschalten A=0, B=1: DMA-Sound einschalten A=1, B=1: DMA-Sound einschalten, Sample endlos wiederholen |
|
| $ff8920 | **** **** A*** **CD | C=0, D=0: Sample-Rate: 6,25 kHz C=0, D=1: Sample-Rate: 12,50 kHz C=1, D=0: Sample-Rate: 25,00 kHz C=1, D=1: Sample-Rate: 50,00 kHz A=0: Stereo A=1: mono |
| $ff8902 | **** **** 00xx xxxx | Sample-Startadresse, Highbyte |
| $ff8904 | **** **** xxxx xxxx | Sample-Startadresse, Middlebyte |
| $ff8906 | **** **** xxxx xxxx | Sample-Startadresse, Lowbyte |
| $ff890E | **** **** 00xx xxxx | Sample-Endadresse, Highbyte |
| $ff8910 | **** **** xxxx xxxx | Sample-Endadresse, Middlebyte |
| $ff8912 | **** **** xxxx xxxx | Sample-Endadresse, Lowbyte |
| $ff8908 | **** **** 00xx xxxx | Hier findet sich die aktuelle Position |
| $ff890A | **** **** xxxx xxxx | im Sample, an welcher sich die DMA |
| $ff890C | **** **** xxxx xxxx | gerade während des Abspielens befindet. (High-, Middle- und Lowbyte) |
Marco Feikert