|
2
|
1 $!-----------------------------------------------------------------------------
|
|
|
2 $! VMS DCL for compiling and testing the G.726 implementation
|
|
|
3 $! The executable must be defined by variable G726 below.
|
|
|
4 $!
|
|
|
5 $! Usage:
|
|
|
6 $! @make-vms
|
|
|
7 $! or
|
|
|
8 $! @make-vms target
|
|
|
9 $! where target is
|
|
|
10 $! cc: compile usando Vax-C
|
|
|
11 $! gcc: compile usando VAX/VMS gcc
|
|
|
12 $! clean: delete object and test files
|
|
|
13 $! test: process reset vectors for all rates
|
|
|
14 $! test16: process reset vectors for 16 kbit/s
|
|
|
15 $! test24: process reset vectors for 24 kbit/s
|
|
|
16 $! test32: process reset vectors for 32 kbit/s
|
|
|
17 $! test40: process reset vectors for 40 kbit/s
|
|
|
18 $! comp: compare processed reset vectors with reference for all rates
|
|
|
19 $! comp16: compare processed reset vectors with reference for 16 kbit/s
|
|
|
20 $! comp24: compare processed reset vectors with reference for 24 kbit/s
|
|
|
21 $! comp32: compare processed reset vectors with reference for 32 kbit/s
|
|
|
22 $! comp40: compare processed reset vectors with reference for 40 kbit/s
|
|
|
23 $!
|
|
|
24 $! Implemented by <simao@cpqd.ansp.br> -- 01.May.94
|
|
|
25 $!-----------------------------------------------------------------------------
|
|
|
26 $ G726 := "g726demo"
|
|
|
27 $ DIFF := "cf -q"
|
|
|
28 $ RM := "delete"
|
|
|
29 $
|
|
|
30 $ TEST_VECTORS := "*.%16.*,*.%24.*,*.%32.*,*.%40.*,*.rec.*"
|
|
|
31 $ G726_OBJ := "g726demo.obj.,g726.obj."
|
|
|
32 $ g726demo:==$"''f$environment(""DEFAULT"")'"g726demo
|
|
|
33 $
|
|
|
34 $! General link options
|
|
|
35 $!-----------------------------
|
|
|
36 $ link_opt := ""
|
|
|
37 $
|
|
|
38 $! Choose a C compiler
|
|
|
39 $!-----------------------------
|
|
|
40 $! > this is for Vax-C - the default
|
|
|
41 $ if ("''p1'".nes."GCC")
|
|
|
42 $ then
|
|
|
43 $ cc := "cc /include=[-.utl]"
|
|
|
44 $!
|
|
|
45 $! > these are for GNU-C
|
|
|
46 $ else
|
|
|
47 $ CC := "gcc -I../utl"
|
|
|
48 $ libs := ",GNU_CC:[000000]GCCLIB/LIB,SYS$LIBRARY:VAXCRTL/LIB"
|
|
|
49 $ endif
|
|
|
50 $
|
|
|
51 $! General cc options
|
|
|
52 $!-----------------------------
|
|
|
53 $ CC_OPT := ""
|
|
|
54 $
|
|
|
55 $! Process User's option
|
|
|
56 $ if ("''p1'".nes."")
|
|
|
57 $ then
|
|
|
58 $ goto 'p1'
|
|
|
59 $ else
|
|
|
60 $ goto all
|
|
|
61 $ endif
|
|
|
62 $
|
|
|
63 $all:
|
|
|
64 $anyway:
|
|
|
65 $cc:
|
|
|
66 $gcc:
|
|
|
67 $ goto g726demo
|
|
|
68 $ exit
|
|
|
69 $
|
|
|
70 $
|
|
|
71 $clean:
|
|
|
72 $ 'RM' 'TEST_VECTORS','G726_OBJ'
|
|
|
73 $exit
|
|
|
74 $
|
|
|
75 $g726demo:
|
|
|
76 $ 'CC' 'CC_OPT' g726.c
|
|
|
77 $ 'CC' 'CC_OPT' g726demo.c
|
|
|
78 $ LINK 'LINK_OPT' 'G726_OBJ''LIBS'
|
|
|
79 $ g726demo:==$"''f$environment(""DEFAULT"")'"g726demo
|
|
|
80 $ exit
|
|
|
81 $
|
|
|
82 $
|
|
|
83 $test: ! clean test16 test24 test32 test40
|
|
|
84 $test16:
|
|
|
85 $!
|
|
|
86 $! Process ADPCM/ Coder for normal and overload sequences, A law
|
|
|
87 $!
|
|
|
88 $ 'G726' a load 16 bin/nrm.a nrm.a16 256 1 64
|
|
|
89 $ 'G726' a load 16 bin/ovr.a ovr.a16 256 1 8
|
|
|
90 $!
|
|
|
91 $! Process ADPCM/ Decoder for normal and overload sequences, A law
|
|
|
92 $!
|
|
|
93 $ 'G726' a adlo 16 bin/rn16fa.i rn16fa.rec 256 1 64
|
|
|
94 $ 'G726' a adlo 16 bin/rv16fa.i rv16fa.rec 256 1 8
|
|
|
95 $!
|
|
|
96 $! Process ADPCM/ Cross-decoder for normal and overload sequences,
|
|
|
97 $! A law input -> ADPCM 16kbit/s -> mu law output
|
|
|
98 $!
|
|
|
99 $ 'G726' u adlo 16 bin/rn16fa.i rn16fx.rec 256 1 64
|
|
|
100 $ 'G726' u adlo 16 bin/rv16fa.i rv16fx.rec 256 1 8
|
|
|
101 $!
|
|
|
102 $!
|
|
|
103 $! Process ADPCM/ Coder for normal and overload sequences, mu law
|
|
|
104 $!
|
|
|
105 $ 'G726' u load 16 bin/nrm.m nrm.m16 256 1 64
|
|
|
106 $ 'G726' u load 16 bin/ovr.m ovr.m16 256 1 8
|
|
|
107 $!
|
|
|
108 $! Process ADPCM/ Decoder for normal and overload sequences, mu law
|
|
|
109 $!
|
|
|
110 $ 'G726' u adlo 16 bin/rn16fm.i rn16fm.rec 256 1 64
|
|
|
111 $ 'G726' u adlo 16 bin/rv16fm.i rv16fm.rec 256 1 8
|
|
|
112 $!
|
|
|
113 $! Process ADPCM/ Cross-decoder for normal and overload sequences,
|
|
|
114 $! mu law input -> ADPCM 16kbit/s -> A law output
|
|
|
115 $!
|
|
|
116 $ 'G726' a adlo 16 bin/rn16fm.i rn16fc.rec 256 1 64
|
|
|
117 $ 'G726' a adlo 16 bin/rv16fm.i rv16fc.rec 256 1 8
|
|
|
118 $!
|
|
|
119 $!
|
|
|
120 $! Process ADPCM/ Decode-only for the same input ADPCM sequence, A and mu law
|
|
|
121 $!
|
|
|
122 $ 'G726' a adlo 16 bin/i16 ri16fa.rec 256 1 64
|
|
|
123 $ 'G726' u adlo 16 bin/i16 ri16fm.rec 256 1 64
|
|
|
124 $ if ("''p1'".nes."TEST") then exit
|
|
|
125 $
|
|
|
126 $test24:
|
|
|
127 $!
|
|
|
128 $!
|
|
|
129 $! Process ADPCM/ Coder for normal and overload sequences, A law
|
|
|
130 $!
|
|
|
131 $ 'G726' a load 24 bin/nrm.a nrm.a24 256 1 64
|
|
|
132 $ 'G726' a load 24 bin/ovr.a ovr.a24 256 1 8
|
|
|
133 $!
|
|
|
134 $! Process ADPCM/ Decoder for normal and overload sequences, A law
|
|
|
135 $!
|
|
|
136 $ 'G726' a adlo 24 bin/rn24fa.i rn24fa.rec 256 1 64
|
|
|
137 $ 'G726' a adlo 24 bin/rv24fa.i rv24fa.rec 256 1 8
|
|
|
138 $!
|
|
|
139 $! Process ADPCM/ Cross-decoder for normal and overload sequences,
|
|
|
140 $! A law input -> ADPCM 24kbit/s -> mu law output
|
|
|
141 $!
|
|
|
142 $ 'G726' u adlo 24 bin/rn24fa.i rn24fx.rec 256 1 64
|
|
|
143 $ 'G726' u adlo 24 bin/rv24fa.i rv24fx.rec 256 1 8
|
|
|
144 $!
|
|
|
145 $!
|
|
|
146 $! Process ADPCM/ Coder for normal and overload sequences, mu law
|
|
|
147 $!
|
|
|
148 $ 'G726' u load 24 bin/nrm.m nrm.m24 256 1 64
|
|
|
149 $ 'G726' u load 24 bin/ovr.m ovr.m24 256 1 8
|
|
|
150 $!
|
|
|
151 $! Process ADPCM/ Decoder for normal and overload sequences, mu law
|
|
|
152 $!
|
|
|
153 $ 'G726' u adlo 24 bin/rn24fm.i rn24fm.rec 256 1 64
|
|
|
154 $ 'G726' u adlo 24 bin/rv24fm.i rv24fm.rec 256 1 8
|
|
|
155 $!
|
|
|
156 $! Process ADPCM/ Cross-decoder for normal and overload sequences,
|
|
|
157 $! mu law input -> ADPCM 24kbit/s -> A law output
|
|
|
158 $!
|
|
|
159 $ 'G726' a adlo 24 bin/rn24fm.i rn24fc.rec 256 1 64
|
|
|
160 $ 'G726' a adlo 24 bin/rv24fm.i rv24fc.rec 256 1 8
|
|
|
161 $!
|
|
|
162 $!
|
|
|
163 $! Process ADPCM/ Decode-only for the same input ADPCM sequence, A and mu law
|
|
|
164 $!
|
|
|
165 $ 'G726' a adlo 24 bin/i24 ri24fa.rec 256 1 64
|
|
|
166 $ 'G726' u adlo 24 bin/i24 ri24fm.rec 256 1 64
|
|
|
167 $ if ("''p1'".nes."TEST") then exit
|
|
|
168 $
|
|
|
169 $test32:
|
|
|
170 $!
|
|
|
171 $! Process ADPCM/ Coder for normal and overload sequences, A law
|
|
|
172 $!
|
|
|
173 $ 'G726' a load 32 bin/nrm.a nrm.a32 256 1 64
|
|
|
174 $ 'G726' a load 32 bin/ovr.a ovr.a32 256 1 8
|
|
|
175 $!
|
|
|
176 $! Process ADPCM/ Decoder for normal and overload sequences, A law
|
|
|
177 $!
|
|
|
178 $ 'G726' a adlo 32 bin/rn32fa.i rn32fa.rec 256 1 64
|
|
|
179 $ 'G726' a adlo 32 bin/rv32fa.i rv32fa.rec 256 1 8
|
|
|
180 $!
|
|
|
181 $! Process ADPCM/ Cross-decoder for normal and overload sequences,
|
|
|
182 $! A law input -> ADPCM 32kbit/s -> mu law output
|
|
|
183 $!
|
|
|
184 $ 'G726' u adlo 32 bin/rn32fa.i rn32fx.rec 256 1 64
|
|
|
185 $ 'G726' u adlo 32 bin/rv32fa.i rv32fx.rec 256 1 8
|
|
|
186 $!
|
|
|
187 $!
|
|
|
188 $! Process ADPCM/ Coder for normal and overload sequences, mu law
|
|
|
189 $!
|
|
|
190 $ 'G726' u load 32 bin/nrm.m nrm.m32 256 1 64
|
|
|
191 $ 'G726' u load 32 bin/ovr.m ovr.m32 256 1 8
|
|
|
192 $!
|
|
|
193 $! Process ADPCM/ Decoder for normal and overload sequences, mu law
|
|
|
194 $!
|
|
|
195 $ 'G726' u adlo 32 bin/rn32fm.i rn32fm.rec 256 1 64
|
|
|
196 $ 'G726' u adlo 32 bin/rv32fm.i rv32fm.rec 256 1 8
|
|
|
197 $!
|
|
|
198 $! Process ADPCM/ Cross-decoder for normal and overload sequences,
|
|
|
199 $! mu law input -> ADPCM 32kbit/s -> A law output
|
|
|
200 $!
|
|
|
201 $ 'G726' a adlo 32 bin/rn32fm.i rn32fc.rec 256 1 64
|
|
|
202 $ 'G726' a adlo 32 bin/rv32fm.i rv32fc.rec 256 1 8
|
|
|
203 $!
|
|
|
204 $!
|
|
|
205 $! Process ADPCM/ Decode-only for the same input ADPCM sequence, A and mu law
|
|
|
206 $!
|
|
|
207 $ 'G726' a adlo 32 bin/i32 ri32fa.rec 256 1 64
|
|
|
208 $ 'G726' u adlo 32 bin/i32 ri32fm.rec 256 1 64
|
|
|
209 $ if ("''p1'".nes."TEST") then exit
|
|
|
210 $
|
|
|
211 $test40:
|
|
|
212 $!
|
|
|
213 $!
|
|
|
214 $! Process ADPCM/ Coder for normal and overload sequences, A law
|
|
|
215 $!
|
|
|
216 $ 'G726' a load 40 bin/nrm.a nrm.a40 256 1 64
|
|
|
217 $ 'G726' a load 40 bin/ovr.a ovr.a40 256 1 8
|
|
|
218 $!
|
|
|
219 $! Process ADPCM/ Decoder for normal and overload sequences, A law
|
|
|
220 $!
|
|
|
221 $ 'G726' a adlo 40 bin/rn40fa.i rn40fa.rec 256 1 64
|
|
|
222 $ 'G726' a adlo 40 bin/rv40fa.i rv40fa.rec 256 1 8
|
|
|
223 $!
|
|
|
224 $! Process ADPCM/ Cross-decoder for normal and overload sequences,
|
|
|
225 $! A law input -> ADPCM 40kbit/s -> mu law output
|
|
|
226 $!
|
|
|
227 $ 'G726' u adlo 40 bin/rn40fa.i rn40fx.rec 256 1 64
|
|
|
228 $ 'G726' u adlo 40 bin/rv40fa.i rv40fx.rec 256 1 8
|
|
|
229 $!
|
|
|
230 $!
|
|
|
231 $! Process ADPCM/ Coder for normal and overload sequences, mu law
|
|
|
232 $!
|
|
|
233 $ 'G726' u load 40 bin/nrm.m nrm.m40 256 1 64
|
|
|
234 $ 'G726' u load 40 bin/ovr.m ovr.m40 256 1 8
|
|
|
235 $!
|
|
|
236 $! Process ADPCM/ Decoder for normal and overload sequences, mu law
|
|
|
237 $!
|
|
|
238 $ 'G726' u adlo 40 bin/rn40fm.i rn40fm.rec 256 1 64
|
|
|
239 $ 'G726' u adlo 40 bin/rv40fm.i rv40fm.rec 256 1 8
|
|
|
240 $!
|
|
|
241 $! Process ADPCM/ Cross-decoder for normal and overload sequences,
|
|
|
242 $! mu law input -> ADPCM 40kbit/s -> A law output
|
|
|
243 $!
|
|
|
244 $ 'G726' a adlo 40 bin/rn40fm.i rn40fc.rec 256 1 64
|
|
|
245 $ 'G726' a adlo 40 bin/rv40fm.i rv40fc.rec 256 1 8
|
|
|
246 $!
|
|
|
247 $!
|
|
|
248 $! Process ADPCM/ Decode-only for the same input ADPCM sequence, A and mu law
|
|
|
249 $!
|
|
|
250 $ 'G726' a adlo 40 bin/i40 ri40fa.rec 256 1 64
|
|
|
251 $ 'G726' u adlo 40 bin/i40 ri40fm.rec 256 1 64
|
|
|
252 $ exit
|
|
|
253 $
|
|
|
254 $comp: ! comp16 comp24 comp32 comp40
|
|
|
255 $comp16:
|
|
|
256 $!
|
|
|
257 $! =================================================================
|
|
|
258 $! COMPARISON OF FILES !
|
|
|
259 $! =================================================================
|
|
|
260 $!
|
|
|
261 $! Compare ADPCM/ Coder for normal and overload sequences, A law
|
|
|
262 $!
|
|
|
263 $ 'DIFF' bin/rn16fa.i nrm.a16 256 1 64
|
|
|
264 $ 'DIFF' bin/rv16fa.i ovr.a16 256 1 8
|
|
|
265 $!
|
|
|
266 $! Compare ADPCM/ Decoder for normal and overload sequences, A law
|
|
|
267 $!
|
|
|
268 $ 'DIFF' bin/rn16fa.o rn16fa.rec 256 1 64
|
|
|
269 $ 'DIFF' bin/rv16fa.o rv16fa.rec 256 1 8
|
|
|
270 $!
|
|
|
271 $! Compare ADPCM/ Cross-decoder for normal and overload sequences,
|
|
|
272 $! A law input -> ADPCM x kbit/s -> mu law output
|
|
|
273 $!
|
|
|
274 $ 'DIFF' bin/rn16fx.o rn16fx.rec 256 1 64
|
|
|
275 $ 'DIFF' bin/rv16fx.o rv16fx.rec 256 1 8
|
|
|
276 $!
|
|
|
277 $!
|
|
|
278 $! Compare ADPCM/ Coder for normal and overload sequences, mu law
|
|
|
279 $!
|
|
|
280 $ 'DIFF' bin/rn16fm.i nrm.m16 256 1 64
|
|
|
281 $ 'DIFF' bin/rv16fm.i ovr.m16 256 1 8
|
|
|
282 $!
|
|
|
283 $! Compare ADPCM/ Decoder for normal and overload sequences, mu law
|
|
|
284 $!
|
|
|
285 $ 'DIFF' bin/rn16fm.o rn16fm.rec 256 1 64
|
|
|
286 $ 'DIFF' bin/rv16fm.o rv16fm.rec 256 1 8
|
|
|
287 $!
|
|
|
288 $! Compare ADPCM/ Cross-decoder for normal and overload sequences,
|
|
|
289 $! mu law input -> ADPCM x kbit/s -> A law output
|
|
|
290 $!
|
|
|
291 $ 'DIFF' bin/rn16fc.o rn16fc.rec 256 1 64
|
|
|
292 $ 'DIFF' bin/rv16fc.o rv16fc.rec 256 1 8
|
|
|
293 $!
|
|
|
294 $!
|
|
|
295 $! Compare ADPCM/ Decode-only for the same input ADPCM sequence, A and mu law
|
|
|
296 $!
|
|
|
297 $ 'DIFF' bin/ri16fa.o ri16fa.rec 256 1 64
|
|
|
298 $ 'DIFF' bin/ri16fm.o ri16fm.rec 256 1 64
|
|
|
299 $ if ("''p1'".nes."COMP") then exit
|
|
|
300 $
|
|
|
301 $comp24:
|
|
|
302 $!
|
|
|
303 $! =================================================================
|
|
|
304 $! COMPARISON OF FILES !
|
|
|
305 $! =================================================================
|
|
|
306 $!
|
|
|
307 $! Compare ADPCM/ Coder for normal and overload sequences, A law
|
|
|
308 $!
|
|
|
309 $ 'DIFF' bin/rn24fa.i nrm.a24 256 1 64
|
|
|
310 $ 'DIFF' bin/rv24fa.i ovr.a24 256 1 8
|
|
|
311 $!
|
|
|
312 $! Compare ADPCM/ Decoder for normal and overload sequences, A law
|
|
|
313 $!
|
|
|
314 $ 'DIFF' bin/rn24fa.o rn24fa.rec 256 1 64
|
|
|
315 $ 'DIFF' bin/rv24fa.o rv24fa.rec 256 1 8
|
|
|
316 $!
|
|
|
317 $! Compare ADPCM/ Cross-decoder for normal and overload sequences,
|
|
|
318 $! A law input -> ADPCM x kbit/s -> mu law output
|
|
|
319 $!
|
|
|
320 $ 'DIFF' bin/rn24fx.o rn24fx.rec 256 1 64
|
|
|
321 $ 'DIFF' bin/rv24fx.o rv24fx.rec 256 1 8
|
|
|
322 $!
|
|
|
323 $!
|
|
|
324 $! Compare ADPCM/ Coder for normal and overload sequences, mu law
|
|
|
325 $!
|
|
|
326 $ 'DIFF' bin/rn24fm.i nrm.m24 256 1 64
|
|
|
327 $ 'DIFF' bin/rv24fm.i ovr.m24 256 1 8
|
|
|
328 $!
|
|
|
329 $! Compare ADPCM/ Decoder for normal and overload sequences, mu law
|
|
|
330 $!
|
|
|
331 $ 'DIFF' bin/rn24fm.o rn24fm.rec 256 1 64
|
|
|
332 $ 'DIFF' bin/rv24fm.o rv24fm.rec 256 1 8
|
|
|
333 $!
|
|
|
334 $! Compare ADPCM/ Cross-decoder for normal and overload sequences,
|
|
|
335 $! mu law input -> ADPCM x kbit/s -> A law output
|
|
|
336 $!
|
|
|
337 $ 'DIFF' bin/rn24fc.o rn24fc.rec 256 1 64
|
|
|
338 $ 'DIFF' bin/rv24fc.o rv24fc.rec 256 1 8
|
|
|
339 $!
|
|
|
340 $!
|
|
|
341 $! Compare ADPCM/ Decode-only for the same input ADPCM sequence, A and mu law
|
|
|
342 $!
|
|
|
343 $ 'DIFF' bin/ri24fa.o ri24fa.rec 256 1 64
|
|
|
344 $ 'DIFF' bin/ri24fm.o ri24fm.rec 256 1 64
|
|
|
345 $ if ("''p1'".nes."COMP") then exit
|
|
|
346 $
|
|
|
347 $comp32:
|
|
|
348 $!
|
|
|
349 $! =================================================================
|
|
|
350 $! COMPARISON OF FILES !
|
|
|
351 $! =================================================================
|
|
|
352 $!
|
|
|
353 $! Compare ADPCM/ Coder for normal and overload sequences, A law
|
|
|
354 $!
|
|
|
355 $ 'DIFF' bin/rn32fa.i nrm.a32 256 1 64
|
|
|
356 $ 'DIFF' bin/rv32fa.i ovr.a32 256 1 8
|
|
|
357 $!
|
|
|
358 $! Compare ADPCM/ Decoder for normal and overload sequences, A law
|
|
|
359 $!
|
|
|
360 $ 'DIFF' bin/rn32fa.o rn32fa.rec 256 1 64
|
|
|
361 $ 'DIFF' bin/rv32fa.o rv32fa.rec 256 1 8
|
|
|
362 $!
|
|
|
363 $! Compare ADPCM/ Cross-decoder for normal and overload sequences,
|
|
|
364 $! A law input -> ADPCM x kbit/s -> mu law output
|
|
|
365 $!
|
|
|
366 $ 'DIFF' bin/rn32fx.o rn32fx.rec 256 1 64
|
|
|
367 $ 'DIFF' bin/rv32fx.o rv32fx.rec 256 1 8
|
|
|
368 $!
|
|
|
369 $!
|
|
|
370 $! Compare ADPCM/ Coder for normal and overload sequences, mu law
|
|
|
371 $!
|
|
|
372 $ 'DIFF' bin/rn32fm.i nrm.m32 256 1 64
|
|
|
373 $ 'DIFF' bin/rv32fm.i ovr.m32 256 1 8
|
|
|
374 $!
|
|
|
375 $! Compare ADPCM/ Decoder for normal and overload sequences, mu law
|
|
|
376 $!
|
|
|
377 $ 'DIFF' bin/rn32fm.o rn32fm.rec 256 1 64
|
|
|
378 $ 'DIFF' bin/rv32fm.o rv32fm.rec 256 1 8
|
|
|
379 $!
|
|
|
380 $! Compare ADPCM/ Cross-decoder for normal and overload sequences,
|
|
|
381 $! mu law input -> ADPCM x kbit/s -> A law output
|
|
|
382 $!
|
|
|
383 $ 'DIFF' bin/rn32fc.o rn32fc.rec 256 1 64
|
|
|
384 $ 'DIFF' bin/rv32fc.o rv32fc.rec 256 1 8
|
|
|
385 $!
|
|
|
386 $!
|
|
|
387 $! Compare ADPCM/ Decode-only for the same input ADPCM sequence, A and mu law
|
|
|
388 $!
|
|
|
389 $ 'DIFF' bin/ri32fa.o ri32fa.rec 256 1 64
|
|
|
390 $ 'DIFF' bin/ri32fm.o ri32fm.rec 256 1 64
|
|
|
391 $ if ("''p1'".nes."COMP") then exit
|
|
|
392 $
|
|
|
393 $comp40:
|
|
|
394 $!
|
|
|
395 $! =================================================================
|
|
|
396 $! COMPARISON OF FILES !
|
|
|
397 $! =================================================================
|
|
|
398 $!
|
|
|
399 $! Compare ADPCM/ Coder for normal and overload sequences, A law
|
|
|
400 $!
|
|
|
401 $ 'DIFF' bin/rn40fa.i nrm.a40 256 1 64
|
|
|
402 $ 'DIFF' bin/rv40fa.i ovr.a40 256 1 8
|
|
|
403 $!
|
|
|
404 $! Compare ADPCM/ Decoder for normal and overload sequences, A law
|
|
|
405 $!
|
|
|
406 $ 'DIFF' bin/rn40fa.o rn40fa.rec 256 1 64
|
|
|
407 $ 'DIFF' bin/rv40fa.o rv40fa.rec 256 1 8
|
|
|
408 $!
|
|
|
409 $! Compare ADPCM/ Cross-decoder for normal and overload sequences,
|
|
|
410 $! A law input -> ADPCM x kbit/s -> mu law output
|
|
|
411 $!
|
|
|
412 $ 'DIFF' bin/rn40fx.o rn40fx.rec 256 1 64
|
|
|
413 $ 'DIFF' bin/rv40fx.o rv40fx.rec 256 1 8
|
|
|
414 $!
|
|
|
415 $!
|
|
|
416 $! Compare ADPCM/ Coder for normal and overload sequences, mu law
|
|
|
417 $!
|
|
|
418 $ 'DIFF' bin/rn40fm.i nrm.m40 256 1 64
|
|
|
419 $ 'DIFF' bin/rv40fm.i ovr.m40 256 1 8
|
|
|
420 $!
|
|
|
421 $! Compare ADPCM/ Decoder for normal and overload sequences, mu law
|
|
|
422 $!
|
|
|
423 $ 'DIFF' bin/rn40fm.o rn40fm.rec 256 1 64
|
|
|
424 $ 'DIFF' bin/rv40fm.o rv40fm.rec 256 1 8
|
|
|
425 $!
|
|
|
426 $! Compare ADPCM/ Cross-decoder for normal and overload sequences,
|
|
|
427 $! mu law input -> ADPCM x kbit/s -> A law output
|
|
|
428 $!
|
|
|
429 $ 'DIFF' bin/rn40fc.o rn40fc.rec 256 1 64
|
|
|
430 $ 'DIFF' bin/rv40fc.o rv40fc.rec 256 1 8
|
|
|
431 $!
|
|
|
432 $!
|
|
|
433 $! Compare ADPCM/ Decode-only for the same input ADPCM sequence, A and mu law
|
|
|
434 $!
|
|
|
435 $ 'DIFF' bin/ri40fa.o ri40fa.rec 256 1 64
|
|
|
436 $ 'DIFF' bin/ri40fm.o ri40fm.rec 256 1 64
|
|
|
437 $ exit
|
