home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Large Pack of OldSkool DOS MOD Trackers
/
ast110.zip
/
ASTFORMA.PAS
< prev
next >
Wrap
Pascal/Delphi Source File
|
1996-11-28
|
10KB
|
299 lines
{-------------------------------AST FORMAT-----------------------------------
FIRST, i am really sorry for my ugly english
HERE IS AN EXAMPLE OF A TP7 PROCEDURE TO LOAD AN AST FILE
{---------------------------------------------------------------------------}
{AWE SAMPLE***********************}
type aws= record
t:array[0..5] of longint;
loop:byte;
nom:string[8];
binf:byte;
end;
{t[0] :address in awe32 memory
t[1] :size of the sample in word
t[2] :begin position
t[3] :loop begin
t[4] :loop end
t[5] :base pitch
if you want to play sample send to
awe pitch register note*341.33+t[5]
loop: loop and $80 =1 ==> looping (don't matter, just care about t[3] & t[4]
loop and 1 =1 ==> sample in ram ,0==> sample in rom
(don't matter, just care about t[0])
binf: =16 ==>16 bits signed sample
7 ==> 8 bits signed sample
awe playposition register:=t[0]+t[2]
awe loop begin register :=t[0]+t[3]
awe loop end register :=t[0]+t[4]-2 ( i don't know if it's a bug,but
if you forget -2 you are going to have
noise at the end of sample
}
awss=record
t:array[0..15] of integer;
ad:longint;
end;
{ it's sound data removed from awe32 memory
to avoid noise at the end of sample,only used by ast
don't care about that}
{AWE INSTRUMENT**************************************}
aweins=record
t:array[0..28] of byte;
nom:string[8];
flg:byte;
end;
{t[0]:number of the sample associated
t[1]:pan level
t[2]:chorus level
t[3]:reverb level
t[4]:filter cut
t[5]:filterQ
t[6]:volume /awe volume register:= (t[4] shl 8) +not(current volume +t[6])
ENVELLOPE 1
t[7]:delay /awe delay register:=(128-t[7]) shl 8
t[8]:sustain
t[9]:decay
t[10]:hold
t[11]:attack /awe hold attack register:=(127-t[10]) shl 8+(127-t[11])
t[12]:override/ awe sust dec register:=(t[12] shl 15)+(t[8] shl 8)+(127-t[9])
t[13]:env 1 to filter
t[14]:env 1 to pitch
ENVELLOPE 2
t[15]:delay /awe delay register:=(128-t[15]) shl 8
t[16]:sustain
t[17]:decay
t[18]:hold
t[19]:attack /awe hold attack register:=(127-t[18]) shl 8+(127-t[19])
t[20]:override / awe sust dec register:=(t[20] shl 15)+(t[16] shl 8)+(127-t[17])
LFO1
t[21]: delay /delay register:= (128-t[21]) shl 8
t[22]: pitch
t[23]: to volume
t[24]: to pitch
t[25]: to filter
LFO2
t[26] :delay /delay register:=(128-t[26]) shl 8
t[27] :pitch
t[28] :to pitch
flg :decomposed in 8 bits
1st bit (flg and 1) : set lfo1
2nd bit (flg and 2) : set lfo2
3 bit (flg and 4) : set filter
4 bit (flg and 8) : set lfo1 pitch
5 bit (flg and 16) : set chorus level
6 bit (flg and 32) : set reverb level
7 bit (flg and 64) : set pan level
8 bit (flg and 128): set lfo2 pitch}
{AWE DRUM INSTRUMENT************************************}
awdrum=record
ist:byte;
f:word;
end;
{ist : awe instrument
f: awe pitch register value}
{PATTERN************************************}
pattern=record
pat_size:word;
pat:pointer;
end;
var
header:string; {header ='AST 0001'}
def:byte; {def is the definition (4 to 8);
it's the number of commande in a time
a pattern has 16*def lines}
tsm:word; {size of the song message}
sm:array[0..1000] of char; {song message}
no:byte; {size of the order}
order:array[0..255] of byte; { order , should be init to 255}
fmin:array[0..127] of string[8]; { name of the FM instruments}
fmi:array[0..127] of array[0..10] of byte;
{----FM INSTRUMENTS---
0: AM/VIB/EG/KSR/MULTI M
1:KSL/TOTAL LEVEL O
2: AR/DR D
3: SL/RR U
4: WAV SEL L
5: AM/VIB/EG/KSR/MULTI C
6:KSL/TOTAL LEVEL A
7: AR/DR R
8: SL/RR R
9: WAV SEL i
10: FB/CON}
sample:array[0..127] of aws;
svs:array[0..127] of awss;
awei:array[0..127] of aweins;
awd:array[0..35] of awdrum;
{CHORUS AND REVERB****************************************}
cht:byte; {type of chorus }
customch:array[0..4] of word; {customize chorus data}
custchname:string[8]; {customize chorus name}
revt:byte; {type of reverb}
custrevname:string[8]; {customize reverb name}
customrev:array[0..27] of word; {customize reverb data}
{**********************PATTERN DATA************************}
pattab:array[0..254] of pattern; {pattern data}
{the pattern have a little compression
1st byte :number of command used in a line of the pattern
2nf byte :track of the 1st command
3,4,5,6 :1st command data
7 :track of th 2nd command
8,9,10,11:2nd command data
etc.. when you have red all the command of the line the next byte
is the number of command used at the 2nd line of the pattern and etc..
there is 16*def lines in a pattern
command stucture
1st byte : note
2nd byte and 127 :volume
2nd byte and $80 : note off
3rd byte: effect
4 byte:effect value}
{*************************************************************}
procedure LOAD_AST_FILE( filename:string);
var
f:file;
i,k:byte;
fmpos,awpos,patpos,awesonpos,wavepos:longint;
begin
assign(f,filename);
reset(f,1);
blockread(f,header,9); {header must be 'AST 0001'}
blockread(f,def,1); {def is the definition (4 to 8);
it's the number of commande in a time
a pattern has 16*def lines}
blockread(f,tsm,2); {size of the message}
blockread(f,sm,tsm+1); {read message}
blockread(f,no,1); {size of the order}
blockread(f,order,no+1); {read order }
blockread(f,fmpos,4); {position of the FM instrument in the file}
blockread(f,awpos,4); {" " " " the AWE data( sample,instrument, chorus)}
blockread(f,patpos,4); {" " " " the patterns}
blockread(f,awesonpos,4); {" " " " the awe sample data}
blockread(f,wavepos,4); {" " " " the wav data, not used yet}
{INSTRUMENTS FM}
seek(f,fmpos); {go at the right position}
blockread(f,i,1); {read first byte, if different of 255 then
number of the 1st instrument}
while i<255 do
begin
blockread(f,fmi[i],11); {data of instrument}
blockread(f,fmin[i],9); {name of the instrument}
blockread(f,i,1); {number of the next instrument}
end;
{SAMPLE AWE}
seek(f,awpos); {go at the right position}
blockread(f,i,1); {read first byte, if different of 255 then
number of the 1st sample}
while i<255 do
begin
blockread(f,sample[i],35); {sample parameter}
blockread(f,svs[i],16); {reserved for ast}
blockread(f,i,1); {next sample}
end;
{INSTRUMENT AWE}
blockread(f,i,1);{read first byte, if different of 255 then
number of the 1st awe instrument}
while i<255 do
begin
blockread(f,awei[i],39); {awe instrument data}
blockread(f,i,1); {next instrument}
end;
blockread(f,i,1); {read first byte, if different of 255 then
number of the 1st awe drum instrument}
while i<255 do
begin
blockread(f,awd[i],3); {awe drum instrument data}
blockread(f,i,1); {next}
end;
blockread(f,cht,1); {read the type of chorus}
blockread(f,custchname,9); {customize chorus name}
blockread(f,customch,10); {customize chorus data}
blockread(f,revt,1); {read the type of reverb}
blockread(f,custrevname,9); {customize reverb name}
blockread(f,customrev,56); {customize reverb data}
blockread(f,i,1); {read a byte for future extension}
{PATTERN}
seek(f,patpos); {go at the right place in the file}
blockread(f,i,1); {read 1st byte if <> of 255 then it's the number of the
1st pattern}
while i<255 do
begin
blockread(f,pattab[i].pat_size,2); {read size of the pattern}
if maxavail > pattab[i].pat_size then
begin
getmem(pattab[i].pat,pattab[i].pat_size); {alloc memory}
blockread(f,pattab[i].pat^,pattab[i].pat_size); {read pattern data}
end else pattab[i].pat_size:=16*def; {not enough memory==>empty pattern
you should use an array[0..127] of byte,
full of 0 to point empty pattern}
blockread(f,i,1);
end;
{AWE SOUND DATA}
seek(f,awesonpos); {go at the right place in the file
it' the sound data,
for each sample, size in the file in byte of sound data is
t[1] for 8 bits sample
2*t[1] for 16 bits sample
so read sound data of the first sample,2nd sample, etc..}
close(f);
end;
begin
end.
{I hope it' s clear enough , but write me if you don't understand something
Patrice BOUCHAND
LE BOURG
42990 St Georges en couzan
FRANCE
See you soon...
and again, thanks to Vince Vu and Cygnus X-1 }