1 // Copyright (c) <2012> <Leif Asbrink>
2 //
3 // Permission is hereby granted, free of charge, to any person
4 // obtaining a copy of this software and associated documentation
5 // files (the "Software"), to deal in the Software without restriction,
6 // including without limitation the rights to use, copy, modify,
7 // merge, publish, distribute, sublicense, and/or sell copies of
8 // the Software, and to permit persons to whom the Software is
9 // furnished to do so, subject to the following conditions:
10 //
11 // The above copyright notice and this permission notice shall be
12 // included in all copies or substantial portions of the Software.
13 //
14 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
15 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
16 // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
17 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
18 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
19 // WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
21 // OR OTHER DEALINGS IN THE SOFTWARE.
22
23
24 #include <unistd.h>
25 #include <string.h>
26 #include "globdef.h"
27 #include "uidef.h"
28 #include "fft1def.h"
29 #include "fft2def.h"
30 #include "fft3def.h"
31 #include "screendef.h"
32 #include "seldef.h"
33 #include "sigdef.h"
34 #include "hwaredef.h"
35 #include "rusage.h"
36 #include "thrdef.h"
37 #include "options.h"
38
39 extern char netsend_rx_multi_group[];
40 fpos_t file_startpos;
41 fpos_t file_playpos;
42
internal_generator(void)43 void internal_generator(void)
44 {
45 #if INTERNAL_GEN_ADD_AGCTEST == TRUE
46 char s[80];
47 int i, j;
48 int *iib;
49 double dt2, dt3, dt4;
50 #define IG_CF1 0.03
51 #define IG_CF2 0.04
52 #define IG_WIDTH 0.0001
53 #define KEY_COUNT (ui.rx_ad_speed*0.0008)
54 if(internal_generator_key > KEY_COUNT)
55 {
56 internal_generator_key=0;
57 }
58 internal_generator_key++;
59 if( (ui.rx_input_mode&DWORD_INPUT) == 0)
60 {
61 for(i=0; i<(int)snd[RXAD].block_bytes/2; i+=2*ui.rx_rf_channels)
62 {
63 dt3=0x7e00*sin(internal_generator_phase1);
64 dt2=0x7e00*cos(internal_generator_phase1);
65 internal_generator_phase1+=fft1_direction*IG_CF1;
66 internal_generator_shift+=0.02/ui.rx_ad_speed;
67 if(internal_generator_shift > IG_WIDTH)internal_generator_shift=0;
68 if(internal_generator_phase1 > 2*(double)(PI_L))internal_generator_phase1-=2*(double)(PI_L);
69 if(internal_generator_phase1 < -2*(double)(PI_L))internal_generator_phase1+=2*(double)(PI_L);
70 if(internal_generator_key < KEY_COUNT/4)
71 {
72 dt3+=0x7e00*0.001*sin(internal_generator_phase2);
73 dt2+=0x7e00*0.001*cos(internal_generator_phase2);
74 internal_generator_phase2+=fft1_direction*IG_CF2;
75 if(internal_generator_phase2 > 2*(double)(PI_L))internal_generator_phase2-=2*(double)(PI_L);
76 if(internal_generator_phase2 < -2*(double)(PI_L))internal_generator_phase2+=2*(double)(PI_L);
77 }
78 if(internal_generator_noise != 0)
79 {
80 dt3+=lir_noisegen(internal_generator_noise-1);
81 dt2+=lir_noisegen(internal_generator_noise-1);
82 }
83 if(truncate_flag != 0)
84 {
85 rxin_isho[i ]+=floor(dt3);
86 rxin_isho[i+1]+=floor(dt2);
87 }
88 else
89 {
90 rxin_isho[i ]+=rint(dt3);
91 rxin_isho[i+1]+=rint(dt2);
92 }
93 if(ui.rx_rf_channels == 2)
94 {
95 if(truncate_flag != 0)
96 {
97 rxin_isho[i+2]+=floor(dt3);
98 rxin_isho[i+3]+=floor(dt2);
99 }
100 else
101 {
102 rxin_isho[i+2]+=rint(dt3);
103 rxin_isho[i+3]+=rint(dt2);
104 }
105 }
106 }
107 }
108 else
109 {
110 iib=(int*)(&timf1_char[timf1p_pa]);
111 for(i=0; i<(int)snd[RXAD].block_bytes/4; i+=2*ui.rx_rf_channels)
112 {
113 dt3=0.01*0x7e000000*sin(8*internal_generator_phase1);
114 dt2=0.01*0x7e000000*cos(8*internal_generator_phase1);
115 dt3+=0.01*0x7e000000*sin(16*internal_generator_phase1);
116 dt2+=0.01*0x7e000000*cos(16*internal_generator_phase1);
117 internal_generator_phase1+=fft1_direction*IG_CF1;
118 internal_generator_shift+=0.0001/ui.rx_ad_speed;
119 if(internal_generator_shift > IG_WIDTH)internal_generator_shift=0;
120 if(internal_generator_shift > IG_WIDTH-0.005/ui.rx_ad_speed )
121 {
122 dt3+=lir_noisegen(25);
123 dt2+=lir_noisegen(25);
124 }
125 if(internal_generator_phase1 > 2*(double)(PI_L))internal_generator_phase1-=2*(double)(PI_L);
126 if(internal_generator_phase1 < -2*(double)(PI_L))internal_generator_phase1+=2*(double)(PI_L);
127 internal_generator_phase2+=fft1_direction*IG_CF2;
128 if(internal_generator_phase2 > 2*(double)(PI_L))internal_generator_phase2-=2*(double)(PI_L);
129 if(internal_generator_phase2 < -2*(double)(PI_L))internal_generator_phase2+=2*(double)(PI_L);
130 if(internal_generator_key < 0.2*KEY_COUNT)
131 {
132 dt3+=0x7e000000*0.005*sin(4*internal_generator_phase2);
133 dt2+=0x7e000000*0.005*cos(4*internal_generator_phase2);
134 dt3+=0x7e000000*0.005*sin(18*internal_generator_phase2);
135 dt2+=0x7e000000*0.005*cos(18*internal_generator_phase2);
136 }
137 else
138 {
139 dt4=60*internal_generator_key/KEY_COUNT;
140 j=dt4;
141 dt4-=j;
142 if(dt4 > 0.5 &&
143 ( internal_generator_key < 0.75*KEY_COUNT ||
144 internal_generator_key > 0.9*KEY_COUNT) )
145 {
146 dt3+=0x7e000000*0.00001*sin(204*internal_generator_phase2);
147 dt2+=0x7e000000*0.00001*cos(204*internal_generator_phase2);
148 }
149 }
150 if(internal_generator_noise != 0)
151 {
152 dt3+=lir_noisegen(internal_generator_noise-1);
153 dt2+=lir_noisegen(internal_generator_noise-1);
154 }
155 if(truncate_flag != 0)
156 {
157 iib[i ]+=floor(dt3);
158 iib[i+1]+=floor(dt2);
159 }
160 else
161 {
162 iib[i ]+=rint(dt3);
163 iib[i+1]+=rint(dt2);
164 }
165 if(ui.rx_rf_channels == 2)
166 {
167 if(truncate_flag != 0)
168 {
169 iib[i+2]+=floor(dt3);
170 iib[i+3]+=floor(dt2);
171 }
172 else
173 {
174 iib[i+2]+=rint(dt3);
175 iib[i+3]+=rint(dt2);
176 }
177 }
178 }
179 }
180 if(internal_generator_noise != 0)
181 {
182 sprintf(s,"NOISE LEVEL %d bits",internal_generator_noise);
183 lir_text(30,0,s);
184 }
185 #endif
186 // *****************************************************************
187 // *****************************************************************
188 // *****************************************************************
189
190 #if INTERNAL_GEN_AGC_TEST == TRUE
191 char s[80];
192 int i, j;
193 int *iib;
194 double dt2, dt3, dt4;
195 #define IG_CF1 0.1
196 #define IG_CF2 0.003
197 #define IG_WIDTH (50.0/96000)
198 #define KEY_COUNT (150000000.0/ui.rx_ad_speed)
199 if(internal_generator_key > KEY_COUNT)
200 {
201 internal_generator_key=0;
202 }
203 internal_generator_key++;
204 if( (ui.rx_input_mode&DWORD_INPUT) == 0)
205 {
206 for(i=0; i<(int)snd[RXAD].block_bytes/2; i+=2*ui.rx_rf_channels)
207 {
208 dt3=0x7e00*sin(internal_generator_phase1);
209 dt2=0x7e00*cos(internal_generator_phase1);
210 internal_generator_phase1+=fft1_direction*IG_CF1;
211 internal_generator_shift+=0.02/ui.rx_ad_speed;
212 if(internal_generator_shift > IG_WIDTH)internal_generator_shift=0;
213 if(internal_generator_phase1 > 2*(double)(PI_L))internal_generator_phase1-=2*(double)(PI_L);
214 if(internal_generator_phase1 < -2*(double)(PI_L))internal_generator_phase1+=2*(double)(PI_L);
215 if(internal_generator_key < KEY_COUNT/4)
216 {
217 dt3+=0x7e00*0.001*sin(internal_generator_phase2);
218 dt2+=0x7e00*0.001*cos(internal_generator_phase2);
219 internal_generator_phase2+=fft1_direction*IG_CF2;
220 if(internal_generator_phase2 > 2*(double)(PI_L))internal_generator_phase2-=2*(double)(PI_L);
221 if(internal_generator_phase2 < -2*(double)(PI_L))internal_generator_phase2+=2*(double)(PI_L);
222 }
223 if(internal_generator_noise != 0)
224 {
225 dt3+=lir_noisegen(internal_generator_noise-1);
226 dt2+=lir_noisegen(internal_generator_noise-1);
227 }
228 if(truncate_flag != 0)
229 {
230 rxin_isho[i ]=floor(dt3);
231 rxin_isho[i+1]=floor(dt2);
232 }
233 else
234 {
235 rxin_isho[i ]=rint(dt3);
236 rxin_isho[i+1]=rint(dt2);
237 }
238 if(ui.rx_rf_channels == 2)
239 {
240 rxin_isho[i+2]=rxin_isho[i ];
241 rxin_isho[i+3]=rxin_isho[i+1];
242 }
243 }
244 }
245 else
246 {
247 iib=(int*)(&timf1_char[timf1p_pa]);
248 for(i=0; i<(int)snd[RXAD].block_bytes/4; i+=2*ui.rx_rf_channels)
249 {
250 dt3=0.01*0x7e000000*sin(8*internal_generator_phase1);
251 dt2=0.01*0x7e000000*cos(8*internal_generator_phase1);
252 dt3+=0.01*0x7e000000*sin(10*internal_generator_phase1);
253 dt2+=0.01*0x7e000000*cos(10*internal_generator_phase1);
254 internal_generator_phase1+=fft1_direction*IG_CF1;
255 internal_generator_shift+=0.0001/ui.rx_ad_speed;
256 if(internal_generator_shift > IG_WIDTH)internal_generator_shift=0;
257 if(internal_generator_shift > IG_WIDTH-0.02/ui.rx_ad_speed )
258 {
259 dt3+=lir_noisegen(30);
260 dt2+=lir_noisegen(30);
261 }
262 if(internal_generator_phase1 > 2*(double)(PI_L))internal_generator_phase1-=2*(double)(PI_L);
263 if(internal_generator_phase1 < -2*(double)(PI_L))internal_generator_phase1+=2*(double)(PI_L);
264 internal_generator_phase2+=fft1_direction*IG_CF2;
265 if(internal_generator_phase2 > 2*(double)(PI_L))internal_generator_phase2-=2*(double)(PI_L);
266 if(internal_generator_phase2 < -2*(double)(PI_L))internal_generator_phase2+=2*(double)(PI_L);
267 if(internal_generator_key < 0.2*KEY_COUNT)
268 {
269 dt3+=0x7e000000*0.005*sin(200*internal_generator_phase2);
270 dt2+=0x7e000000*0.005*cos(200*internal_generator_phase2);
271 dt3+=0x7e000000*0.005*sin(210*internal_generator_phase2);
272 dt2+=0x7e000000*0.005*cos(210*internal_generator_phase2);
273 }
274 else
275 {
276 dt4=60*internal_generator_key/KEY_COUNT;
277 j=dt4;
278 dt4-=j;
279 if(dt4 > 0.5 &&
280 ( internal_generator_key < 0.75*KEY_COUNT ||
281 internal_generator_key > 0.9*KEY_COUNT) )
282 {
283 dt3+=0x7e000000*0.00001*sin(204*internal_generator_phase2);
284 dt2+=0x7e000000*0.00001*cos(204*internal_generator_phase2);
285 }
286 }
287 if(internal_generator_noise != 0)
288 {
289 dt3+=lir_noisegen(internal_generator_noise-1);
290 dt2+=lir_noisegen(internal_generator_noise-1);
291 }
292 if(truncate_flag != 0)
293 {
294 iib[i ]=floor(dt3);
295 iib[i+1]=floor(dt2);
296 }
297 else
298 {
299 iib[i ]=rint(dt3);
300 iib[i+1]=rint(dt2);
301 }
302 if(ui.rx_rf_channels == 2)
303 {
304 iib[i+2]=iib[i ];
305 iib[i+3]=iib[i+1];
306 }
307 }
308 }
309 if(internal_generator_noise != 0)
310 {
311 sprintf(s,"NOISE LEVEL %d bits",internal_generator_noise);
312 lir_text(30,0,s);
313 }
314 #endif
315 // *****************************************************************
316 // *****************************************************************
317 // *****************************************************************
318 #if INTERNAL_GEN_FILTER_TEST == TRUE
319 int i;
320 int *iib;
321 double dt2, dt3, dt5;
322 #define IG_WIDTH 2.5
323 #define IG_CF 0.5
324 #define KEY_COUNT (5000000.0/ui.rx_ad_speed)
325
326 //#define IG_WIDTH .02
327 //#define IG_CF -.1
328 //#define KEY_COUNT 16
329 dt5=pow(0.1,0.5*internal_generator_att);
330 if(internal_generator_key > KEY_COUNT)
331 {
332 internal_generator_key=0;
333 }
334 internal_generator_key++;
335 if( (ui.rx_input_mode&DWORD_INPUT) == 0)
336 {
337 for(i=0; i<(int)snd[RXAD].block_bytes/2; i+=2*ui.rx_rf_channels)
338 {
339 dt3=dt5*0x7e00*sin(internal_generator_phase1);
340 dt2=dt5*0x7e00*cos(internal_generator_phase1);
341 internal_generator_phase1+=fft1_direction*(-IG_CF-IG_WIDTH+
342 internal_generator_shift);
343 internal_generator_shift+=0.02/ui.rx_ad_speed;
344 if(internal_generator_shift > 2*IG_WIDTH)internal_generator_shift=0;
345 if(internal_generator_phase1 > 2*(double)(PI_L))internal_generator_phase1-=2*(double)(PI_L);
346 if(internal_generator_phase1 < -2*(double)(PI_L))internal_generator_phase1+=2*(double)(PI_L);
347 if(internal_generator_key < KEY_COUNT/4)
348 {
349 dt3+=0x7e00*0.00001*sin(internal_generator_phase2);
350 dt2+=0x7e00*0.00001*cos(internal_generator_phase2);
351 internal_generator_phase2+=fft1_direction*IG_CF;
352 if(internal_generator_phase2 > 2*(double)(PI_L))internal_generator_phase2-=2*(double)(PI_L);
353 if(internal_generator_phase2 < -2*(double)(PI_L))internal_generator_phase2+=2*(double)(PI_L);
354 }
355 if(internal_generator_noise != 0)
356 {
357 dt3+=lir_noisegen(internal_generator_noise-1);
358 dt2+=lir_noisegen(internal_generator_noise-1);
359 }
360 if(truncate_flag != 0)
361 {
362 rxin_isho[i ]=floor(dt3);
363 rxin_isho[i+1]=floor(dt2);
364 }
365 else
366 {
367 rxin_isho[i ]=rint(dt3);
368 rxin_isho[i+1]=rint(dt2);
369 }
370 if(ui.rx_rf_channels == 2)
371 {
372 rxin_isho[i+2]=rxin_isho[i ];
373 rxin_isho[i+3]=rxin_isho[i+1];
374 }
375 }
376 }
377 else
378 {
379 iib=(int*)(&timf1_char[timf1p_pa]);
380 for(i=0; i<(int)snd[RXAD].block_bytes/4; i+=2*ui.rx_rf_channels)
381 {
382 dt3=dt5*0x7e000000*sin(internal_generator_phase1);
383 dt2=dt5*0x7e000000*cos(internal_generator_phase1);
384 internal_generator_phase1+=fft1_direction*(-IG_WIDTH+
385 internal_generator_shift);
386 internal_generator_shift+=0.05/ui.rx_ad_speed;
387 if(internal_generator_shift > 2*IG_WIDTH)internal_generator_shift=0;
388 if(internal_generator_phase1 > 2*(double)(PI_L))internal_generator_phase1-=2*(double)(PI_L);
389 if(internal_generator_phase1 < -2*(double)(PI_L))internal_generator_phase1+=2*(double)(PI_L);
390 internal_generator_phase2+=fft1_direction*IG_CF;
391 if(internal_generator_phase2 > 2*(double)(PI_L))internal_generator_phase2-=2*(double)(PI_L);
392 if(internal_generator_phase2 < -2*(double)(PI_L))internal_generator_phase2+=2*(double)(PI_L);
393 if(internal_generator_key < KEY_COUNT/4)
394 {
395 dt3+=0x7e000000*0.0001*sin(internal_generator_phase2);
396 dt2+=0x7e000000*0.0001*cos(internal_generator_phase2);
397 }
398 if(internal_generator_noise != 0)
399 {
400 dt3+=lir_noisegen(internal_generator_noise-1);
401 dt2+=lir_noisegen(internal_generator_noise-1);
402 }
403 if(truncate_flag != 0)
404 {
405 iib[i ]=floor(dt3);
406 iib[i+1]=floor(dt2);
407 }
408 else
409 {
410 iib[i ]=rint(dt3);
411 iib[i+1]=rint(dt2);
412 }
413 if(ui.rx_rf_channels == 2)
414 {
415 iib[i+2]=iib[i ];
416 iib[i+3]=iib[i+1];
417 }
418 }
419 }
420 #endif
421 // *****************************************************************
422 // *****************************************************************
423 // *****************************************************************
424 #if INTERNAL_GEN_CARRIER == TRUE
425 int i;
426 int *iib;
427 double dt2, dt3, dt5;
428 #define IG_WIDTH 2.5
429 #define IG_CF 0.5
430 dt5=pow(0.1,0.5*internal_generator_att);
431 if( (ui.rx_input_mode&IQ_DATA) == 0)
432 {
433 if( (ui.rx_input_mode&DWORD_INPUT) == 0)
434 {
435 for(i=0; i<(int)snd[RXAD].block_bytes/2; i+=ui.rx_rf_channels)
436 {
437 dt2=dt5*0x7e00*cos(internal_generator_phase1);
438 internal_generator_phase1+=fft1_direction*(-IG_CF-IG_WIDTH+
439 internal_generator_shift);
440 if(internal_generator_phase1 > 2*(double)(PI_L))internal_generator_phase1-=2*(double)(PI_L);
441 if(internal_generator_phase1 < -2*(double)(PI_L))internal_generator_phase1+=2*(double)(PI_L);
442 if(internal_generator_noise != 0)
443 {
444 dt2+=lir_noisegen(internal_generator_noise-1);
445 }
446 if(truncate_flag != 0)
447 {
448 rxin_isho[i ]=floor(dt2);
449 }
450 else
451 {
452 rxin_isho[i ]=rint(dt2);
453 }
454 if(ui.rx_rf_channels == 2)
455 {
456 rxin_isho[i+1]=rxin_isho[i ];
457 }
458 }
459 }
460 else
461 {
462 iib=(int*)(&timf1_char[timf1p_pa]);
463 for(i=0; i<(int)snd[RXAD].block_bytes/4; i+=ui.rx_rf_channels)
464 {
465 dt2=dt5*0x7e000000*cos(internal_generator_phase1);
466 internal_generator_phase1+=fft1_direction*(-IG_WIDTH+
467 internal_generator_shift);
468 if(internal_generator_phase1 > 2*(double)(PI_L))internal_generator_phase1-=2*(double)(PI_L);
469 if(internal_generator_phase1 < -2*(double)(PI_L))internal_generator_phase1+=2*(double)(PI_L);
470 if(internal_generator_noise != 0)
471 {
472 dt2+=lir_noisegen(internal_generator_noise-1);
473 }
474 if(truncate_flag != 0)
475 {
476 iib[i]=floor(dt2);
477 }
478 else
479 {
480 iib[i]=rint(dt2);
481 }
482 if(ui.rx_rf_channels == 2)
483 {
484 iib[i+1]=iib[i ];
485 }
486 }
487 }
488 }
489 else
490 {
491 if( (ui.rx_input_mode&DWORD_INPUT) == 0)
492 {
493 for(i=0; i<(int)snd[RXAD].block_bytes/2; i+=2*ui.rx_rf_channels)
494 {
495 dt3=dt5*0x7e00*sin(internal_generator_phase1);
496 dt2=dt5*0x7e00*cos(internal_generator_phase1);
497 internal_generator_phase1+=fft1_direction*(-IG_CF-IG_WIDTH+
498 internal_generator_shift);
499 if(internal_generator_phase1 > 2*(double)(PI_L))internal_generator_phase1-=2*(double)(PI_L);
500 if(internal_generator_phase1 < -2*(double)(PI_L))internal_generator_phase1+=2*(double)(PI_L);
501 if(internal_generator_noise != 0)
502 {
503 dt3+=lir_noisegen(internal_generator_noise-1);
504 dt2+=lir_noisegen(internal_generator_noise-1);
505 }
506 if(truncate_flag != 0)
507 {
508 rxin_isho[i ]=floor(dt3);
509 rxin_isho[i+1]=floor(dt2);
510 }
511 else
512 {
513 rxin_isho[i ]=rint(dt3);
514 rxin_isho[i+1]=rint(dt2);
515 }
516 if(ui.rx_rf_channels == 2)
517 {
518 rxin_isho[i+2]=rxin_isho[i ];
519 rxin_isho[i+3]=rxin_isho[i+1];
520 }
521 }
522 }
523 else
524 {
525 iib=(int*)(&timf1_char[timf1p_pa]);
526 for(i=0; i<(int)snd[RXAD].block_bytes/4; i+=2*ui.rx_rf_channels)
527 {
528 dt3=dt5*0x7e000000*sin(internal_generator_phase1);
529 dt2=dt5*0x7e000000*cos(internal_generator_phase1);
530 internal_generator_phase1+=fft1_direction*(-IG_WIDTH+
531 internal_generator_shift);
532 if(internal_generator_phase1 > 2*(double)(PI_L))internal_generator_phase1-=2*(double)(PI_L);
533 if(internal_generator_phase1 < -2*(double)(PI_L))internal_generator_phase1+=2*(double)(PI_L);
534 if(internal_generator_noise != 0)
535 {
536 dt3+=lir_noisegen(internal_generator_noise-1);
537 dt2+=lir_noisegen(internal_generator_noise-1);
538 }
539 if(truncate_flag != 0)
540 {
541 iib[i ]=floor(dt3);
542 iib[i+1]=floor(dt2);
543 }
544 else
545 {
546 iib[i ]=rint(dt3);
547 iib[i+1]=rint(dt2);
548 }
549 if(ui.rx_rf_channels == 2)
550 {
551 iib[i+2]=iib[i ];
552 iib[i+3]=iib[i+1];
553 }
554 }
555 }
556 }
557 #endif
558 }
559
set_raw_userfreq(void)560 void set_raw_userfreq(void)
561 {
562 net_rxdata_16.userx_freq=-1;
563 net_rxdata_16.userx_no=-1;
564 net_rxdata_18.userx_freq=-1;
565 net_rxdata_18.userx_no=-1;
566 net_rxdata_24.userx_freq=-1;
567 net_rxdata_24.userx_no=-1;
568 }
569
write_raw_file(void)570 void write_raw_file(void)
571 {
572 int i, timf1p_pnw;
573 #if RUSAGE_OLD == TRUE
574 int local_workload_counter;
575 #endif
576 #if OSNUM == OSNUM_LINUX
577 clear_thread_times(THREAD_WRITE_RAW_FILE);
578 #endif
579 #if RUSAGE_OLD == TRUE
580 local_workload_counter=workload_counter;
581 #endif
582 thread_status_flag[THREAD_WRITE_RAW_FILE]=THRFLAG_ACTIVE;
583 timf1p_pnw=timf1p_pa;
584 while(!kill_all_flag &&
585 thread_command_flag[THREAD_WRITE_RAW_FILE]==THRFLAG_ACTIVE)
586 {
587 #if RUSAGE_OLD == TRUE
588 if(local_workload_counter != workload_counter)
589 {
590 local_workload_counter=workload_counter;
591 make_thread_times(THREAD_WRITE_RAW_FILE);
592 }
593 #endif
594 lir_await_event(EVENT_WRITE_RAW_FILE);
595 while(timf1p_pnw!=timf1p_pa &&
596 thread_command_flag[THREAD_WRITE_RAW_FILE]==THRFLAG_ACTIVE)
597 {
598 if( (ui.rx_input_mode&DWORD_INPUT) == 0)
599 {
600 i=fwrite(&timf1_char[timf1p_pnw],1,snd[RXAD].block_bytes,save_wr_file);
601 if(i != (int)snd[RXAD].block_bytes)goto file_end;
602 }
603 else
604 {
605 timf1p_pc_disk=timf1p_pnw;
606 compress_rawdat_disk();
607 i=fwrite(rawsave_tmp_disk,1,save_rw_bytes,save_wr_file);
608 if(i != save_rw_bytes)goto file_end;
609 }
610 timf1p_pnw=(timf1p_pnw+snd[RXAD].block_bytes)&timf1_bytemask;
611 }
612 }
613 file_end:
614 fclose(save_wr_file);
615 save_wr_file=NULL;
616 thread_status_flag[THREAD_WRITE_RAW_FILE]=THRFLAG_RETURNED;
617 while(!kill_all_flag &&
618 thread_command_flag[THREAD_WRITE_RAW_FILE] != THRFLAG_NOT_ACTIVE)
619 {
620 lir_sleep(1000);
621 }
622 }
623
624
finish_rx_read(void)625 void finish_rx_read(void)
626 {
627 int *iib;
628 int mask2, shft;
629 char *charbuf;
630 int read_time;
631 short int *isho;
632 int i, j, k, m, ix, nn, mm;
633 float *za, *zb;
634 double dt1;
635 short int *ya, *yb;
636 isho=(short int*)(void*)&timf1_char[timf1p_pa];
637 if(internal_generator_flag != 0)internal_generator();
638 // Here we post to the screen routine every 0.1 second.
639 screen_loop_counter--;
640 if(screen_loop_counter == 0)
641 {
642 screen_loop_counter=screen_loop_counter_max;
643 lir_set_event(EVENT_SCREEN);
644 }
645 if( (ui.network_flag&(NET_RX_OUTPUT)) != 0)
646 {
647 if(diskread_flag < 2)
648 {
649 read_time=ms_since_midnight(TRUE);
650 accumulated_netwait_time*=0.75;
651 }
652 else
653 {
654 netstart_time=current_time();
655 dt1=diskread_time+diskread_block_counter*snd[RXAD].block_frames/ui.rx_ad_speed;
656 read_time=dt1/(24*3600);
657 dt1-=24*3600*read_time;
658 read_time=1000*dt1;
659 read_time%=24*3600000;
660 accumulated_netwait_time=0;
661 }
662 }
663 else
664 {
665 read_time=0;
666 }
667 if( (ui.network_flag & NET_RX_INPUT) != 0)
668 {
669 if(abs(latest_listsend_time-read_time) > 1500)
670 {
671 latest_listsend_time=read_time;
672 net_send_slaves_freq();
673 }
674 }
675 if(diskwrite_flag == 1)lir_set_event(EVENT_WRITE_RAW_FILE);
676 set_raw_userfreq();
677 charbuf=(char*)&timf1_char[timf1p_pa];
678
679 // ******************* SEND RAW16 *****************************
680 if( (ui.network_flag & NET_RXOUT_RAW16) != 0)
681 {
682 net_rxdata_16.time=read_time;
683 net_rxdata_16.passband_center=rx_passband_center_mhz;
684 net_rxdata_16.passband_direction=fg.passband_direction;
685 j=0;
686 if( (ui.rx_input_mode&DWORD_INPUT) == 0)
687 {
688 while(j < (int)snd[RXAD].block_bytes)
689 {
690 net_rxdata_16.buf[netsend_ptr_16 ]=charbuf[j ];
691 net_rxdata_16.buf[netsend_ptr_16+1]=charbuf[j+1];
692 netsend_ptr_16+=2;
693 j+=2;
694 if(netsend_ptr_16 >= NET_MULTICAST_PAYLOAD)
695 {
696 netraw16_blknum++;
697 net_rxdata_16.block_no=netraw16_blknum;
698 net_rxdata_16.ptr=next_blkptr_16;
699 lir_send_raw16();
700 next_blkptr_16=j;
701 if(next_blkptr_16 >= snd[RXAD].block_bytes)next_blkptr_16=0;
702 netsend_ptr_16=0;
703 }
704 }
705 }
706 else
707 {
708 while(j < (int)snd[RXAD].block_bytes)
709 {
710 net_rxdata_16.buf[netsend_ptr_16 ]=charbuf[j+2];
711 net_rxdata_16.buf[netsend_ptr_16+1]=charbuf[j+3];
712 netsend_ptr_16+=2;
713 j+=4;
714 if(netsend_ptr_16 >= NET_MULTICAST_PAYLOAD)
715 {
716 netraw16_blknum++;
717 net_rxdata_16.block_no=netraw16_blknum;
718 net_rxdata_16.ptr=next_blkptr_16;
719 lir_send_raw16();
720 next_blkptr_16=j/2;
721 if(next_blkptr_16 >= snd[RXAD].block_bytes/2)next_blkptr_16=0;
722 netsend_ptr_16=0;
723 }
724 }
725 }
726 }
727 // ******************* SEND RAW18 *****************************
728 if( (ui.network_flag & NET_RXOUT_RAW18) != 0)
729 {
730 timf1p_pc_net=timf1p_pa;
731 compress_rawdat_net();
732 net_rxdata_18.time=read_time;
733 net_rxdata_18.passband_center=rx_passband_center_mhz;
734 net_rxdata_18.passband_direction=fg.passband_direction;
735 j=0;
736 while(j < save_rw_bytes)
737 {
738 net_rxdata_18.buf[netsend_ptr_18]=rawsave_tmp_net[j];
739 netsend_ptr_18++;
740 j++;
741 if(netsend_ptr_18 >= NET_MULTICAST_PAYLOAD)
742 {
743 netraw18_blknum++;
744 net_rxdata_18.block_no=netraw18_blknum;
745 net_rxdata_18.ptr=next_blkptr_18;
746 lir_send_raw18();
747 next_blkptr_18=j;
748 if( next_blkptr_18 >= save_rw_bytes)next_blkptr_18=0;
749 netsend_ptr_18=0;
750 }
751 }
752 }
753 // ******************* SEND RAW24 *****************************
754 if( (ui.network_flag & NET_RXOUT_RAW24) != 0)
755 {
756 net_rxdata_24.time=read_time;
757 net_rxdata_24.passband_center=rx_passband_center_mhz;
758 net_rxdata_24.passband_direction=fg.passband_direction;
759 j=0;
760 while(j < (int)snd[RXAD].block_bytes)
761 {
762 net_rxdata_24.buf[netsend_ptr_24 ]=charbuf[j+1];
763 net_rxdata_24.buf[netsend_ptr_24+1]=charbuf[j+2];
764 net_rxdata_24.buf[netsend_ptr_24+2]=charbuf[j+3];
765 netsend_ptr_24+=3;
766 j+=4;
767 if(netsend_ptr_24 >= NET_MULTICAST_PAYLOAD)
768 {
769 netraw24_blknum++;
770 net_rxdata_24.block_no=netraw24_blknum;
771 net_rxdata_24.ptr=next_blkptr_24;
772 lir_send_raw24();
773 next_blkptr_24=j;
774 if( next_blkptr_24 >= snd[RXAD].block_bytes)next_blkptr_24=0;
775 netsend_ptr_24=0;
776 }
777 }
778 }
779 if( (ui.network_flag&NET_RXOUT_FFT1) != 0)
780 {
781 // It is important for slow computers that may be connected via the
782 // network that we distribute packets evenly in time.
783 // The fft1 transform may be very large and it could arrive at a rate
784 // of 25 Hz or even lower.
785 // The A/D interrupt rate is high when we send fft1 transforms.
786 // (see buf.c)
787 // It may be different if input is from the network or from the
788 // hard disk.
789 mm=snd[RXAD].block_bytes/(1-fft1_interleave_ratio);
790 if( (ui.rx_input_mode&DWORD_INPUT) == 0)mm*=2;
791
792 k=(fft1net_pa-fft1net_px+fft1net_size)&fft1net_mask;
793 if( k > mm+fft1_blockbytes)
794 {
795 mm+=snd[RXAD].block_bytes/2;
796 }
797 if( k < 1.5*mm)
798 {
799 mm-=snd[RXAD].block_bytes/2;
800 }
801 mm&=-4;
802 if( k > mm)
803 {
804 net_rxdata_fft1.time=read_time;
805 net_rxdata_fft1.passband_center=rx_passband_center_mhz;
806 net_rxdata_fft1.passband_direction=fg.passband_direction;
807 j=0;
808 while(j < mm)
809 {
810 net_rxdata_fft1.buf[netsend_ptr_fft1 ]=fft1_netsend_buffer[fft1net_px ];
811 net_rxdata_fft1.buf[netsend_ptr_fft1+1]=fft1_netsend_buffer[fft1net_px+1];
812 net_rxdata_fft1.buf[netsend_ptr_fft1+2]=fft1_netsend_buffer[fft1net_px+2];
813 net_rxdata_fft1.buf[netsend_ptr_fft1+3]=fft1_netsend_buffer[fft1net_px+3];
814 netsend_ptr_fft1+=4;
815 j+=4;
816 fft1net_px=(fft1net_px+4)&fft1net_mask;
817 if(netsend_ptr_fft1 >= NET_MULTICAST_PAYLOAD)
818 {
819 netfft1_blknum++;
820 net_rxdata_fft1.block_no=netfft1_blknum;
821 net_rxdata_fft1.ptr=next_blkptr_fft1;
822 lir_send_fft1();
823 next_blkptr_fft1=fft1net_px&(fft1_blockbytes-1);
824 netsend_ptr_fft1=0;
825 }
826 }
827 }
828 }
829 if( (ui.network_flag&NET_RXOUT_BASEB) != 0)
830 {
831 while( ((basebnet_pa-basebnet_px+basebnet_size)&basebnet_mask) >
832 basebnet_block_bytes+32)
833 // The baseband signal is timed to fit a loudspeaker output so
834 // it should already be evenly distributed in time.
835 {
836 j=0;
837 while(j < (int)basebnet_block_bytes)
838 {
839 net_rxdata_baseb.buf[netsend_ptr_baseb ]=baseb_netsend_buffer[basebnet_px ];
840 net_rxdata_baseb.buf[netsend_ptr_baseb+1]=baseb_netsend_buffer[basebnet_px+1];
841 net_rxdata_baseb.buf[netsend_ptr_baseb+2]=baseb_netsend_buffer[basebnet_px+2];
842 net_rxdata_baseb.buf[netsend_ptr_baseb+3]=baseb_netsend_buffer[basebnet_px+3];
843 netsend_ptr_baseb+=4;
844 basebnet_px=(basebnet_px+4)&basebnet_mask;
845 j+=4;
846 if(netsend_ptr_baseb >= NET_MULTICAST_PAYLOAD)
847 {
848 netbaseb_blknum++;
849 net_rxdata_baseb.block_no=netbaseb_blknum;
850 net_rxdata_baseb.ptr=next_blkptr_baseb;
851 lir_send_baseb();
852 next_blkptr_baseb=j;
853 if((int)next_blkptr_baseb >= basebnet_block_bytes)next_blkptr_baseb=0;
854 netsend_ptr_baseb=0;
855 }
856 }
857
858 }
859 }
860 if( (ui.network_flag&NET_RXOUT_BASEBRAW) != 0)
861 {
862 net_rxdata_basebraw.time=read_time;
863 net_rxdata_basebraw.passband_center=0;
864 net_rxdata_basebraw.passband_direction=basebraw_passband_direction;
865 while( ((basebrawnet_pa-basebrawnet_px+basebrawnet_size)&basebrawnet_mask) >
866 basebrawnet_block_bytes+32)
867 {
868 j=0;
869 while(j < (int)basebrawnet_block_bytes)
870 {
871 net_rxdata_basebraw.buf[netsend_ptr_basebraw ]=basebraw_netsend_buffer[basebrawnet_px+1];
872 net_rxdata_basebraw.buf[netsend_ptr_basebraw+1]=basebraw_netsend_buffer[basebrawnet_px+2];
873 net_rxdata_basebraw.buf[netsend_ptr_basebraw+2]=basebraw_netsend_buffer[basebrawnet_px+3];
874 netsend_ptr_basebraw+=3;
875 basebrawnet_px=(basebrawnet_px+4)&basebrawnet_mask;
876 j+=4;
877 if(netsend_ptr_basebraw >= NET_MULTICAST_PAYLOAD)
878 {
879 netbasebraw_blknum++;
880 net_rxdata_basebraw.block_no=netbasebraw_blknum;
881 net_rxdata_basebraw.ptr=next_blkptr_basebraw;
882 lir_send_basebraw();
883 next_blkptr_basebraw=j;
884 if((int)next_blkptr_basebraw >= basebrawnet_block_bytes)next_blkptr_basebraw=0;
885 netsend_ptr_basebraw=0;
886 }
887 }
888 }
889 }
890 if(genparm[SECOND_FFT_ENABLE] != 0)
891 {
892 // ******************* SEND TIMF2 *****************************
893 if( (ui.network_flag & NET_RXOUT_TIMF2) )
894 {
895 net_rxdata_timf2.time=read_time;
896 net_rxdata_timf2.passband_center=rx_passband_center_mhz;
897 net_rxdata_timf2.passband_direction=-1;
898 // Set userx_freq to sampling speed.
899 net_rxdata_timf2.userx_freq=timf1_sampling_speed;
900 mm=((timf2_pn2-timf2_pt+timf2_size)&timf2_mask);
901 if(mm>(timf2_neg))mm=0;
902 j=snd[RXAD].block_bytes;
903 if( (ui.rx_input_mode&DWORD_INPUT) != 0)j/=2;
904
905 if( mm <= j/2)
906 {
907 mm=0;
908 }
909 else
910 {
911 if( mm > 1.25*j)
912 {
913 mm=1.25*j;
914 }
915 }
916 j=0;
917 if(swfloat)
918 {
919 // Set userx_no to the number of receiver RF channels with
920 // the sign negative to indicate float format.
921 net_rxdata_timf2.userx_no=-ui.rx_rf_channels;
922 mm*=2;
923 while(j < mm)
924 {
925 za=(float*)&net_rxdata_timf2.buf[netsend_ptr_timf2];
926 zb=&timf2_float[timf2_pt];
927 for(nn=0; nn<twice_rxchan; nn++)
928 {
929 za[nn]=hg_map65_gain*(zb[nn]+hg.map65_strong*zb[twice_rxchan+nn]);
930 }
931 netsend_ptr_timf2+=twice_rxchan*sizeof(float);
932 j+=twice_rxchan*sizeof(float);
933 timf2_pt=(timf2_pt+2*twice_rxchan)&timf2_mask;
934 if(netsend_ptr_timf2 >= NET_MULTICAST_PAYLOAD)
935 {
936 nettimf2_blknum++;
937 net_rxdata_timf2.block_no=nettimf2_blknum;
938 net_rxdata_timf2.ptr=(2*timf2_pt)&(snd[RXAD].block_bytes-1);
939 lir_send_timf2();
940 netsend_ptr_timf2=0;
941 }
942 }
943 }
944 else
945 {
946 // Set userx_no to the number of receiver RF channels.
947 net_rxdata_timf2.userx_no=ui.rx_rf_channels;
948 while(j < mm)
949 {
950 ya=(short int*)(&net_rxdata_timf2.buf[netsend_ptr_timf2]);
951 yb=(short int*)(&timf2_shi[timf2_pt]);
952 for(nn=0; nn<twice_rxchan; nn++)
953 {
954 ya[nn]=hg_map65_gain*(yb[nn]+hg.map65_strong*yb[twice_rxchan+nn]);
955 }
956 netsend_ptr_timf2+=twice_rxchan*sizeof(short int);
957 j+=twice_rxchan*sizeof(short int);
958 timf2_pt=(timf2_pt+2*twice_rxchan)&timf2_mask;
959 if(netsend_ptr_timf2 >= NET_MULTICAST_PAYLOAD)
960 {
961 nettimf2_blknum++;
962 net_rxdata_timf2.block_no=nettimf2_blknum;
963 net_rxdata_timf2.ptr=timf2_pt&(snd[RXAD].block_bytes-1);
964 lir_send_timf2();
965 netsend_ptr_timf2=0;
966 }
967 }
968 }
969 }
970 // ******************* SEND FFT2 *****************************
971 if( (ui.network_flag & NET_RXOUT_FFT2) )
972 {
973 // It is important for slow computers that may be connected via the
974 // network that we distribute packets evenly in time.
975 // The fft2 transform may be very large and it could arrive at a rate
976 // of 1 Hz or even lower.
977 // It may be different if input is from the network or from the
978 // hard disk.
979 mm=1.1*snd[RXAD].block_bytes/(1-fft2_interleave_ratio);
980 m=mm;
981 if( (ui.rx_input_mode&DWORD_INPUT) != 0)mm/=2;
982 k=(fft2_pa-fft2_pt+fft2_totbytes)&fft2_mask;
983 if( k > mm+fft2_blockbytes)
984 {
985 mm+=m/2;
986 }
987 if( k < 1.5*mm)
988 {
989 mm-=m/2;
990 }
991 mm&=-4;
992 if( k > mm)
993 {
994 net_rxdata_fft2.time=read_time;
995 net_rxdata_fft2.passband_center=rx_passband_center_mhz;
996 net_rxdata_fft2.passband_direction=fg.passband_direction;
997 j=0;
998 if(fft_cntrl[FFT2_CURMODE].mmx == 0)
999 {
1000 mm*=2;
1001 charbuf=(char*)(fft2_float);
1002 while(j < mm)
1003 {
1004 net_rxdata_fft2.buf[netsend_ptr_fft2 ]=charbuf[4*fft2_pt ];
1005 net_rxdata_fft2.buf[netsend_ptr_fft2+1]=charbuf[4*fft2_pt+1];
1006 net_rxdata_fft2.buf[netsend_ptr_fft2+2]=charbuf[4*fft2_pt+2];
1007 net_rxdata_fft2.buf[netsend_ptr_fft2+3]=charbuf[4*fft2_pt+3];
1008 netsend_ptr_fft2+=4;
1009 j+=4;
1010 fft2_pt=(fft2_pt+1)&fft2_mask;
1011 if(netsend_ptr_fft2 >= NET_MULTICAST_PAYLOAD)
1012 {
1013 netfft2_blknum++;
1014 if( (netfft2_blknum&1) == 0)
1015 {
1016 // If netfft2_blknum is even, send these things:
1017 // Set userx_no to the number of receiver RF channels with
1018 // the sign negative to indicate float format.
1019 net_rxdata_fft2.userx_no=-ui.rx_rf_channels;
1020 // Set userx_freq to sampling speed.
1021 net_rxdata_fft2.userx_freq=timf1_sampling_speed;
1022 }
1023 else
1024 {
1025 // If fft2_blknum is odd, send these things:
1026 net_rxdata_fft2.userx_no=fft2_n;
1027 net_rxdata_fft2.userx_freq=genparm[SECOND_FFT_SINPOW];
1028 }
1029 net_rxdata_fft2.block_no=netfft2_blknum;
1030 net_rxdata_fft2.ptr=next_blkptr_fft2;
1031 lir_send_fft2();
1032 next_blkptr_fft2=fft2_pt&(fft2_blockbytes-1);
1033 netsend_ptr_fft2=0;
1034 }
1035 }
1036 }
1037 else
1038 {
1039 charbuf=(char*)(fft2_short_int);
1040 while(j < mm)
1041 {
1042 net_rxdata_fft2.buf[netsend_ptr_fft2 ]=charbuf[2*fft2_pt ];
1043 net_rxdata_fft2.buf[netsend_ptr_fft2+1]=charbuf[2*fft2_pt+1];
1044 netsend_ptr_fft2+=2;
1045 j+=2;
1046 fft2_pt=(fft2_pt+1)&fft2_mask;
1047 if(netsend_ptr_fft2 >= NET_MULTICAST_PAYLOAD)
1048 {
1049 netfft2_blknum++;
1050 if( (netfft2_blknum&1) == 0)
1051 {
1052 // If fft2_blknum is even, send these things:
1053 // Set userx_no to the number of receiver RF channels.
1054 net_rxdata_fft2.userx_no=ui.rx_rf_channels;
1055 // Set userx_freq to sampling speed.
1056 net_rxdata_fft2.userx_freq=timf1_sampling_speed;
1057 }
1058 else
1059 {
1060 // If fft2_blknum is odd, send these things:
1061 net_rxdata_fft2.userx_no=fft2_n;
1062 net_rxdata_fft2.userx_freq=genparm[SECOND_FFT_SINPOW];
1063 }
1064 net_rxdata_fft2.block_no=netfft2_blknum;
1065 net_rxdata_fft2.ptr=next_blkptr_fft2;
1066 lir_send_fft2();
1067 next_blkptr_fft2=fft2_pt&(fft2_blockbytes-1);
1068 netsend_ptr_fft2=0;
1069 }
1070 }
1071 }
1072 }
1073 }
1074 }
1075 if(truncate_flag != 0)
1076 {
1077 k=ui.rx_ad_channels;
1078 m=snd[RXAD].block_frames*k;
1079 iib=(int*)&timf1_char[timf1p_pa];
1080 mask2=truncate_flag^0xffffffff;
1081 shft=(truncate_flag+1)/2;
1082 if( (ui.rx_input_mode&DWORD_INPUT) == 0)
1083 {
1084 rxin_nbits=16;
1085 for(i=0; i<m; i+=k)
1086 {
1087 for(j=0; j<k; j++)
1088 {
1089 ix=isho[i+j];
1090 ix &= mask2;
1091 ix+=shft;
1092 isho[i+j]=ix;
1093 }
1094 }
1095 }
1096 else
1097 {
1098 rxin_nbits=32;
1099 for(i=0; i<m; i+=k)
1100 {
1101 for(j=0; j<k; j++)
1102 {
1103 ix=iib[i+j];
1104 ix &= mask2;
1105 ix+=shft;
1106 iib[i+j]=ix;
1107 }
1108 }
1109 }
1110 mask2=truncate_flag;
1111 while(mask2 != 0)
1112 {
1113 mask2>>=1;
1114 rxin_nbits--;
1115 }
1116 }
1117 if(ampinfo_flag != 0)
1118 {
1119 if(ampinfo_reset != workload_reset_flag)
1120 {
1121 ampinfo_reset = workload_reset_flag;
1122 for(i=0; i<ui.rx_ad_channels; i++)
1123 {
1124 ad_maxamp[i]=1;
1125 }
1126 }
1127 k=ui.rx_ad_channels;
1128 m=snd[RXAD].block_frames*k;
1129 if(ui.rx_addev_no == EXCALIBUR_DEVICE_CODE)
1130 {
1131 if( (ui.rx_input_mode&DWORD_INPUT) == 0)
1132 {
1133 for(i=0; i<m; i+=k)
1134 {
1135 for(j=0; j<k; j++)
1136 {
1137 ix=isho[i+j];
1138 ix=abs(ix);
1139 if(ix > ad_maxamp[1])ad_maxamp[1]=ix;
1140 }
1141 }
1142 }
1143 else
1144 {
1145 for(i=0; i<m; i+=k)
1146 {
1147 for(j=0; j<k; j++)
1148 {
1149 ix=isho[1+((k+j)<<1)];
1150 ix=abs(ix);
1151 if(ix > ad_maxamp[1])ad_maxamp[1]=ix;
1152 }
1153 }
1154 }
1155 }
1156 else
1157 {
1158 if( (ui.rx_input_mode&DWORD_INPUT) == 0)
1159 {
1160 for(i=0; i<m; i+=k)
1161 {
1162 for(j=0; j<k; j++)
1163 {
1164 ix=(int)isho[i+j];
1165 ix=abs(ix);
1166 if(ix > ad_maxamp[j])ad_maxamp[j]=ix;
1167 }
1168 }
1169 }
1170 else
1171 {
1172 for(i=0; i<m; i+=k)
1173 {
1174 for(j=0; j<k; j++)
1175 {
1176 ix=isho[1+((k+j)<<1)];
1177 ix=abs(ix);
1178 if(ix > ad_maxamp[j])ad_maxamp[j]=ix;
1179 }
1180 }
1181 }
1182 }
1183 }
1184 // Set the EVENT_TIMF1 condition in case there is enough
1185 // data for fft1 to make at least one transform.
1186 if( ((timf1p_pa-timf1p_pb+timf1_bytes)&timf1_bytemask) >= timf1_usebytes)
1187 {
1188 timf1p_pb=timf1p_pa;
1189 lir_set_event(EVENT_TIMF1);
1190 }
1191 timf1p_pa=(timf1p_pa+snd[RXAD].block_bytes)&timf1_bytemask;
1192 rxin_isho=(short int*)(&timf1_char[timf1p_pa]);
1193 rxin_int=(int*)(&timf1_char[timf1p_pa]);
1194 rxin_char=(char*)(&timf1_char[timf1p_pa]);
1195 rxin_block_counter++;
1196 lir_sched_yield();
1197 }
1198
rx_file_input(void)1199 void rx_file_input(void)
1200 {
1201 #if RUSAGE_OLD == TRUE
1202 int local_workload_counter;
1203 #endif
1204 int i, j, k;
1205 double speedcalc_counter;
1206 float *z;
1207 int restart_flag;
1208 double dt1, dt2, read_start_time, ideal_block_count;
1209 double total_time1, total_time2;
1210 float t2;
1211 i=0;
1212 screen_loop_counter_max=0.1*snd[RXAD].interrupt_rate;
1213 if(screen_loop_counter_max==0)screen_loop_counter_max=1;
1214 if(file_start_block < 0)
1215 {
1216 fgetpos(save_rd_file,&file_startpos);
1217 diskread_block_counter=0;
1218 }
1219 else
1220 {
1221 fsetpos(save_rd_file,&file_playpos);
1222 diskread_block_counter=file_start_block;
1223 }
1224 restart:;
1225 restart_flag=FALSE;
1226 #if OSNUM == OSNUM_LINUX
1227 clear_thread_times(THREAD_RX_FILE_INPUT);
1228 #endif
1229 #if RUSAGE_OLD == TRUE
1230 local_workload_counter=workload_counter;
1231 #endif
1232 screen_loop_counter=screen_loop_counter_max;
1233 total_time1=current_time();
1234 read_start_time=total_time1;
1235 total_time2=current_time();
1236 speedcalc_counter=0;
1237 thread_status_flag[THREAD_RX_FILE_INPUT]=THRFLAG_ACTIVE;
1238 while(thread_command_flag[THREAD_RX_FILE_INPUT] == THRFLAG_ACTIVE)
1239 {
1240 #if RUSAGE_OLD == TRUE
1241 if(local_workload_counter != workload_counter)
1242 {
1243 local_workload_counter=workload_counter;
1244 make_thread_times(THREAD_RX_FILE_INPUT);
1245 }
1246 #endif
1247 if(audio_dump_flag != 0)
1248 {
1249 wait:;
1250 lir_set_event(EVENT_TIMF1);
1251 if(kill_all_flag) goto file_rxin_error_exit;
1252 if( ((timf1p_pa-timf1p_px+timf1_bytes)&timf1_bytemask) > 3*timf1_bytemask >> 2 ||
1253 ((fft1_na-fft1_nx+max_fft1n)&fft1n_mask) > 3*max_fft1n>>2 ||
1254 ((timf3_pa-timf3_px+timf3_mask+1)&timf3_mask) >= 3*timf3_mask>>2 ||
1255 ((baseb_pa-baseb_py+baseband_mask+1)&baseband_mask) > 3*baseband_mask>>2)
1256 {
1257 lir_sleep(5000);
1258 goto wait;
1259 }
1260 else
1261 {
1262 lir_sched_yield();
1263 }
1264 dt2=current_time();
1265 i=0;
1266 if(dt2 > total_time2+0.25)
1267 {
1268 // Make sure we do not use 100% of the available CPU time.
1269 // Leave the CPU idle (from Linrad tasks) four times per second.
1270 // First make sure that all important threads have completed,
1271 // Then wait 12.5 milliseconds extra to give at least 5% of the
1272 // total CPU power to other tasks.
1273 while(!kill_all_flag &&
1274 (thread_status_flag[THREAD_WIDEBAND_DSP] != THRFLAG_SEM_WAIT ||
1275 (thread_status_flag[THREAD_SCREEN] != THRFLAG_SEM_WAIT &&
1276 thread_status_flag[THREAD_SCREEN] != THRFLAG_IDLE) ) )
1277 {
1278 i++;
1279 lir_sleep(5000);
1280 if(i>800)lirerr(88777);
1281 }
1282 if(genparm[SECOND_FFT_ENABLE] != 0)
1283 {
1284 while(!kill_all_flag &&
1285 thread_status_flag[THREAD_SECOND_FFT] != THRFLAG_SEM_WAIT)
1286 {
1287 lir_sleep(5000);
1288 i++;
1289 if(i>800)lirerr(88778);
1290 }
1291 }
1292 while(!kill_all_flag && new_baseb_flag <= 0 &&
1293 (thread_status_flag[THREAD_NARROWBAND_DSP] != THRFLAG_SEM_WAIT &&
1294 thread_status_flag[THREAD_NARROWBAND_DSP] != THRFLAG_INPUT_WAIT))
1295 {
1296 lir_sleep(5000);
1297 i++;
1298 if(i>800)lirerr(88779);
1299 }
1300 lir_sleep(5000);
1301 dt2=current_time();
1302 total_time2=dt2;
1303 }
1304 ideal_block_count=speedcalc_counter-0.4;
1305 dt1=ideal_block_count/snd[RXAD].interrupt_rate;
1306 read_start_time=dt2-dt1;
1307 }
1308 else
1309 {
1310 if(speedcalc_counter > 5)
1311 {
1312 total_time2=current_time();
1313 dt1=total_time2-read_start_time;
1314 ideal_block_count=dt1*snd[RXAD].interrupt_rate+1;
1315 t2=speedcalc_counter-ideal_block_count-.5;
1316 if(t2 >0)
1317 {
1318 t2/=snd[RXAD].interrupt_rate;
1319 lir_sleep(1000000*t2);
1320 }
1321 total_time2=current_time();
1322 dt1=total_time2-read_start_time;
1323 measured_ad_speed=(speedcalc_counter-0.75)*(snd[RXAD].block_frames/dt1);
1324 }
1325 }
1326 if(diskread_pause_flag !=0 )
1327 {
1328 lir_sleep(100000);
1329 restart_flag=TRUE;
1330 goto skip_read;
1331 }
1332 if(restart_flag)goto restart;
1333 diskread_block_counter++;
1334 if(file_stop_block > 0)
1335 {
1336 if(diskread_block_counter > file_stop_block)goto end_savfile;
1337 }
1338 speedcalc_counter++;
1339 if(internal_generator_flag == 0 || INTERNAL_GEN_ADD_AGCTEST == TRUE)
1340 {
1341 if( diskread_flag == 4)goto end_savfile;
1342 if( (ui.rx_input_mode&DWORD_INPUT) == 0)
1343 {
1344 if( (ui.rx_input_mode&BYTE_INPUT) != 0)
1345 {
1346 j=snd[RXAD].block_bytes>>1;
1347 k=j;
1348 i=fread(rxin_isho,1,j,save_rd_file);
1349 while(j > 0)
1350 {
1351 j--;
1352 rxin_isho[j]=(rxin_char[j]+128)<<8;
1353 }
1354 if(i != k)
1355 {
1356 i*=2;
1357 goto end_savfile;
1358 }
1359 }
1360 else
1361 {
1362 i=fread(rxin_isho,1,snd[RXAD].block_bytes,save_rd_file);
1363 if(i != (int)snd[RXAD].block_bytes)goto end_savfile;
1364 }
1365 }
1366 else
1367 {
1368 if( (ui.rx_input_mode&(BYTE_INPUT+FLOAT_INPUT+QWORD_INPUT)) != 0)
1369 {
1370 // Read 24 bit PCM and 32 bit float and PCM wav files here.
1371 if( (ui.rx_input_mode&(FLOAT_INPUT+QWORD_INPUT)) == 0)
1372 {
1373 j=3*(snd[RXAD].block_bytes>>2);
1374 k=j;
1375 i=fread(rxin_isho,1,j,save_rd_file);
1376 j/=3;
1377 while(j > 0)
1378 {
1379 j--;
1380 rxin_char[4*j+3]=rxin_char[3*j+2];
1381 rxin_char[4*j+2]=rxin_char[3*j+1];
1382 rxin_char[4*j+1]=rxin_char[3*j ];
1383 rxin_char[4*j ]=0;
1384 }
1385 if(i != k)
1386 {
1387 i*=4;
1388 i/=3;
1389 goto end_savfile;
1390 }
1391 }
1392 else
1393 {
1394 z=(float*)rxin_isho;
1395 i=fread(rxin_isho,1,snd[RXAD].block_bytes,save_rd_file);
1396 j=snd[RXAD].block_bytes/4;
1397 if( (ui.rx_input_mode&QWORD_INPUT) == 0)
1398 {
1399 while(j > 0)
1400 {
1401 j--;
1402 rxin_int[j]=(float)0x7fffffff*z[j];
1403 }
1404 }
1405 if(i != (int)snd[RXAD].block_bytes)
1406 {
1407 goto end_savfile;
1408 }
1409 }
1410 }
1411 else
1412 {
1413 i=fread(rawsave_tmp,1,save_rw_bytes,save_rd_file);
1414 expand_rawdat();
1415 if(i != save_rw_bytes)
1416 {
1417 end_savfile:;
1418 if(savefile_repeat_flag == 1)
1419 {
1420 memset(&timf1_char[timf1p_pa],0,snd[RXAD].block_bytes);
1421 if(file_start_block < 0)
1422 {
1423 fsetpos(save_rd_file,&file_startpos);
1424 diskread_block_counter=0;
1425 }
1426 else
1427 {
1428 fsetpos(save_rd_file,&file_playpos);
1429 diskread_block_counter=file_start_block;
1430 }
1431 }
1432 else
1433 {
1434 if(diskread_flag == 2)
1435 {
1436 diskread_block_counter=2;
1437 diskread_flag=4;
1438 }
1439 if( (diskread_flag & 4) != 0)
1440 {
1441 if(diskread_block_counter/snd[RXAD].interrupt_rate >= total_wttim)
1442 {
1443 diskread_flag=8;
1444 goto end_file_rxin;
1445 }
1446 }
1447 }
1448 // Clear the 500 last bytes. WAV files contain big numbers
1449 // appended to the signal data in the file that create huge pulses
1450 k=(timf1p_pa-500+i+timf1_bytes)&timf1_bytemask;
1451 while(k != timf1p_pa)
1452 {
1453 timf1_char[k]=0;
1454 k=(k+1)&timf1_bytemask;
1455 }
1456 }
1457 }
1458 }
1459 }
1460 finish_rx_read();
1461 if(kill_all_flag) goto file_rxin_error_exit;
1462 skip_read:;
1463 }
1464 end_file_rxin:;
1465 file_rxin_error_exit:;
1466 thread_status_flag[THREAD_RX_FILE_INPUT]=THRFLAG_RETURNED;
1467 while(thread_command_flag[THREAD_RX_FILE_INPUT] != THRFLAG_NOT_ACTIVE)
1468 {
1469 lir_sleep(5000);
1470 lir_set_event(EVENT_SCREEN);
1471 }
1472 }
1473
1474