source: trunk/src/libsrc/lib330/libtokens.c @ 7420

Revision 7420, 28.2 KB checked in by baker, 6 months ago (diff)

add explanation why the high-order bits are set in cur_lcq->ctrl

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1/*   Lib330 DP Token Processing
2     Copyright 2006-2010 Certified Software Corporation
3
4    This file is part of Lib330
5
6    Lib330 is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 2 of the License, or
9    (at your option) any later version.
10
11    Lib330 is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    You should have received a copy of the GNU General Public License
17    along with Lib330; if not, write to the Free Software
18    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19
20Edit History:
21   Ed Date       By  Changes
22   -- ---------- --- ---------------------------------------------------
23    0 2006-10-01 rdr Created
24    1 2007-03-06 rdr Add call to purge_continuity.
25    2 2007-03-12 rdr Don't purge continuity here, wait until receive data.
26    3 2008-01-10 rdr Move LOG into DP LCQs. DPLCQ buffers come out of thrbuf
27                     instead of using getmem.
28    4 2009-07-30 rdr Move uppercase to libsupport.
29    5 2010-03-27 rdr Add Q335 support.
30    6 2011-07-24 rdr Fix bug in loading opaque token data.
31*/
32#ifndef libclient_h
33#include "libclient.h"
34#endif
35#ifndef libcmds_h
36#include "libcmds.h"
37#endif
38#ifndef libmsgs_h
39#include "libmsgs.h"
40#endif
41#ifndef libcvrt_h
42#include "libcvrt.h"
43#endif
44#ifndef libslider_h
45#include "libslider.h"
46#endif
47#ifndef q330cvrt_h
48#include "q330cvrt.h"
49#endif
50#ifndef OMIT_SEED
51#ifndef libopaque_h
52#include "libopaque.h"
53#endif
54#ifndef libfilters_h
55#include "libfilters.h"
56#endif
57#ifndef libctrldet_h
58#include "libctrldet.h"
59#endif
60#ifndef libarchive_h
61#include "libarchive.h"
62#endif
63#endif
64#ifndef libsampcfg_h
65#include "libsampcfg.h"
66#endif
67#ifndef libcont_h
68#include "libcont.h"
69#endif
70#ifndef libsupport_h
71#include "libsupport.h"
72#endif
73#ifndef libtokens_h
74#include "libtokens.h"
75#endif
76
77#ifndef OMIT_SEED
78void read_iir (paqstruc paqs, pbyte *p)
79begin
80  piirdef cur_iir ;
81  integer i ;
82  pq330 q330 ;
83  tsection_base *psb ;
84  integer len ;
85
86  q330 = paqs->owner ;
87  getbuf (q330, addr(cur_iir), sizeof(tiirdef)) ;
88  if (paqs->iirchain == NIL)
89    then
90      paqs->iirchain = cur_iir ;
91    else
92      paqs->iirchain = extend_link (paqs->iirchain, cur_iir) ;
93  cur_iir->iir_num = loadbyte (p) ;
94  len = loadbyte(p) ;
95  loadblock (p, len, addr(cur_iir->fname)) ;
96  cur_iir->fname[len] = 0 ; /* terminate string */
97  cur_iir->sects = loadbyte (p) ;
98  cur_iir->gain = loadsingle (p) ;
99  cur_iir->rate = loadsingle (p) ;
100  for (i = 1 ; i <= cur_iir->sects ; i++)
101    begin
102      psb = addr(cur_iir->filt[i]) ;
103      psb->ratio = loadsingle (p) ;
104      psb->poles = loadbyte (p) ;
105      if (psb->poles and 128)
106        then
107          begin
108            psb->poles = psb->poles and 127 ;
109            psb->highpass = TRUE ;
110          end
111      calc_section (addr(cur_iir->filt[i])) ;
112    end
113end
114
115void read_fir (paqstruc paqs, pbyte *p)
116begin
117  pfilter cur_fir ;
118  byte fnum ;
119  string31 ucfname, ucs ;
120  integer len ;
121
122  fnum = loadbyte (p) ;
123  len = loadbyte(p) ;
124  loadblock (p, len, addr(ucs)) ;
125  ucs[len] = 0 ;
126  lib330_upper(addr(ucs)) ;
127  cur_fir = paqs->firchain ;
128  while (cur_fir)
129    begin
130      strcpy(ucfname, cur_fir->fname) ;
131      lib330_upper(addr(ucfname)) ;
132      if (strcmp(ucfname, ucs) == 0)
133        then
134          begin
135            cur_fir->fir_num = fnum ;
136            return ;
137          end
138        else
139          cur_fir = cur_fir->link ;
140    end
141end
142
143void read_detector (paqstruc paqs, pbyte *p, boolean mh)
144begin
145  pdetector cur_def ;
146  tdet_mh dm ;
147  pq330 q330 ;
148  integer len ;
149
150  q330 = paqs->owner ;
151  getbuf (q330, addr(cur_def), sizeof(tdetector)) ;
152  if (paqs->defchain == NIL)
153    then
154      paqs->defchain = cur_def ;
155    else
156      paqs->defchain = extend_link (paqs->defchain, cur_def) ;
157  dm.num = loadbyte (p) ; /* detector number */
158  dm.filtnum = loadbyte (p) ; /* filter number */
159  dm.iw = loadbyte (p) ; /* iw parameter */
160  dm.nht = loadbyte (p) ; /* nht parameter */
161  dm.fhi = loadlongint (p) ; /* fhi/filhi parameter */
162  dm.flo = loadlongint (p) ; /* flo/fillo parameter */
163  dm.wa = loadword (p) ; /* wa parameter */
164  dm.spare = loadword (p) ; /* needed for this compiler */
165  if (mh)
166    then
167      begin
168        dm.tc = loadword (p) ; /* tc number */
169        dm.x1_2 = loadbyte (p) ; /* x1 parameter / 2 */
170        dm.x2_2 = loadbyte (p) ; /* x2 parameter / 2 */
171        dm.x3_2 = loadbyte (p) ; /* x3 parameter / 2 */
172        dm.xx = loadbyte (p) ; /* xx parameter */
173        dm.av = loadbyte (p) ; /* av parameter */
174      end
175  cur_def->detector_num = dm.num ;
176  if (dm.filtnum != 0xFF)
177    then
178      cur_def->detfilt = find_iir(paqs, dm.filtnum) ;
179  cur_def->uconst.iwin = dm.iw ;
180  cur_def->uconst.filhi = dm.fhi ;
181  cur_def->uconst.fillo = dm.flo ;
182  cur_def->uconst.wait_blk = dm.wa ;
183  cur_def->uconst.n_hits = dm.nht ;
184  if (mh)
185    then
186      begin
187        cur_def->uconst.xth1 = dm.x1_2 shl 1 ;
188        cur_def->uconst.xth2 = dm.x2_2 shl 1 ;
189        cur_def->uconst.xth3 = dm.x3_2 shl 1 ;
190        cur_def->uconst.xthx = dm.xx ;
191        cur_def->uconst.def_tc = dm.tc ;
192        cur_def->uconst.val_avg = dm.av ;
193        cur_def->dtype = MURDOCK_HUTT ;
194      end
195    else
196      cur_def->dtype = THRESHOLD ;
197  len = loadbyte(p) ;
198  loadblock (p, len, addr(cur_def->detname)) ;
199  cur_def->detname[len] = 0 ;
200end
201#endif
202
203void set_loc_name (plcq q)
204begin
205  integer i, lth ;
206  string3 s ;
207
208  lth = 0 ;
209  for (i = 0 ; i <= 1 ; i++)
210    if (q->location[i] != ' ')
211      then
212        s[lth++] = q->location[i] ;
213  s[lth] = 0 ;
214  strcpy(addr(q->slocation), s) ;
215  lth = 0 ;
216  for (i = 0 ; i <= 2 ; i++)
217    if (q->seedname[i] != ' ')
218      then
219        s[lth++] = q->seedname[i] ;
220  s[lth] = 0 ;
221  strcpy(addr(q->sseedname), s) ;
222end
223
224static void read_lcq (paqstruc paqs, pbyte *p)
225begin
226  plcq cur_lcq ;
227  byte b ;
228  longword mask ;
229  pq330 q330 ;
230  int16 real_rate ;
231  string95 s ;
232  string15 s2 ;
233#ifndef OMIT_SEED
234  plcq pt ;
235  pdownstream_packet pds ;
236  pdet_packet pdp ;
237  pdetector pd ;
238#endif
239
240  q330 = paqs->owner ;
241  getbuf (q330, addr(cur_lcq), sizeof(tlcq)) ;
242  if (paqs->lcqs == NIL)
243    then
244      paqs->lcqs = cur_lcq ;
245    else
246      paqs->lcqs = extend_link (paqs->lcqs, cur_lcq) ;
247  loadblock (p, 2, addr(cur_lcq->location)) ;
248  loadblock (p, 3, addr(cur_lcq->seedname)) ;
249  set_loc_name (cur_lcq) ;
250  cur_lcq->lcq_num = loadbyte (p) ;
251  if (cur_lcq->lcq_num > paqs->highest_lcqnum)
252    then
253      paqs->highest_lcqnum = cur_lcq->lcq_num ;
254  cur_lcq->raw_data_source = loadbyte (p) ;
255  cur_lcq->raw_data_field = loadbyte (p) ;
256  cur_lcq->lcq_opt = loadlongword (p) ;
257  cur_lcq->rate = loadint16 (p) ;
258  if (((cur_lcq->raw_data_source and DCM) == DC_D32) land (cur_lcq->raw_data_field == HIGH_FREQ_BIT))
259    then
260      begin
261        switch (q330->share.fixed.freq7 and 0x7F) begin
262          case 5 :
263            real_rate = 250 ;
264            break ;
265          case 8 :
266            real_rate = 500 ;
267            break ;
268          case 10 :
269            real_rate = 1000 ;
270            break ;
271          default :
272            real_rate = 0 ;
273            break ;
274        end
275        if (cur_lcq->rate != real_rate)
276          then
277            begin
278              seed2string(cur_lcq->location, cur_lcq->seedname, addr(s2)) ;
279              sprintf (s, "in Token:%d Actual:%d For %s", (integer)cur_lcq->rate,
280                       (integer)real_rate, s2) ;
281              libmsgadd(q330, LIBMSG_HFRATE, addr(s)) ;
282              cur_lcq->rate = real_rate ; /* correct */
283            end
284      end
285  cur_lcq->caldly = 60 ;
286#ifndef OMIT_SEED
287  getbuf (q330, addr(cur_lcq->com), sizeof(tcom_packet)) ;
288  cur_lcq->firfixing_gain = 1.000 ; /* default if not over-ridden */
289  cur_lcq->com->maxframes = 255 ; /* 16K! */
290  cur_lcq->com->frame = 1 ;
291  cur_lcq->com->next_compressed_sample = 1 ;
292#endif
293  if (cur_lcq->lcq_opt and LO_PEB)
294    then
295#ifndef OMIT_SEED
296      cur_lcq->pre_event_buffers =
297#endif
298                           loadword (p) ;
299  if (cur_lcq->lcq_opt and LO_GAP)
300    then
301      cur_lcq->gap_threshold = loadsingle (p) ;
302  if (cur_lcq->gap_threshold == 0.0)
303    then
304      cur_lcq->gap_threshold = 0.5 ;
305  set_gaps (cur_lcq) ;
306  if (cur_lcq->lcq_opt and LO_CALDLY)
307    then
308      cur_lcq->caldly = loadword (p) ;
309  if (cur_lcq->lcq_opt and LO_FRAME)
310    then
311#ifndef OMIT_SEED
312      cur_lcq->com->maxframes =
313#endif
314                        loadbyte (p) ;
315  if (cur_lcq->lcq_opt and LO_FIRMULT)
316    then
317#ifndef OMIT_SEED
318      cur_lcq->firfixing_gain =
319#endif
320                        loadsingle (p) ;
321  if (cur_lcq->lcq_opt and LO_AVG)
322    then
323      begin
324#ifndef OMIT_SEED
325        cur_lcq->avg_length = loadlongword (p) ;
326        b = loadbyte (p) ; /* iir filter number */
327        if (b != 0xFF)
328          then
329            cur_lcq->avg_source = find_iir(paqs, b) ;
330        getbuf (q330, addr(cur_lcq->avg), sizeof(tavg_packet)) ;
331#else
332        loadlongword (p) ;
333        loadbyte (p) ;
334#endif
335      end
336  if (cur_lcq->lcq_opt and LO_CDET)
337    then
338      begin
339        b = loadbyte (p) ; /* control detector number */ ;
340#ifndef OMIT_SEED
341        if (b != 0xFF)
342          then
343            /* these are resolved later in resolve_control_detectors(), below */
344            /* cur_lcq->ctrl must be non-zero                                 */
345            /* set some high-order bits in case b is 0; any will do           */
346            cur_lcq->ctrl = (pcontrol_detector)((pntrint)0xFFFFFF00 or (pntrint)b) ;
347#endif
348      end
349  if (cur_lcq->lcq_opt and LO_DEC)
350    then
351      begin
352        b = loadbyte (p) ; /* Source LCQ NUMBER */
353#ifndef OMIT_SEED
354        pt = paqs->lcqs ;
355        while (pt)
356          if (pt->lcq_num == b)
357            then
358              begin
359                cur_lcq->prev_link = (pointer) pt ; /* where I get my data from */
360                getbuf (q330, addr(pds), sizeof(tdownstream_packet)) ;
361                pds->link = NIL ;
362                pds->derived_q = cur_lcq ;
363                pt->downstream_link = extend_link (pt->downstream_link, pds) ;
364                break ;
365              end
366            else
367              pt = pt->link ;
368        b = loadbyte (p) ; /* FIR FILTER */
369        if (b != 0xFF)
370          then
371            begin
372              cur_lcq->source_fir = find_fir (paqs, b) ;
373              if (cur_lcq->source_fir == NIL)
374                then
375                  begin
376                    seed2string(cur_lcq->location, cur_lcq->seedname, addr(s)) ;
377                    libmsgadd(q330, LIBMSG_DECNOTFOUND, addr(s)) ;
378                  end
379            end
380#endif
381      end
382  mask = LO_DET1 ;
383  while (mask <= LO_DET8)
384    begin
385      if (cur_lcq->lcq_opt and mask)
386        then
387          begin
388            b = loadbyte (p) ; /* base detector number */
389#ifndef OMIT_SEED
390            pd = paqs->defchain ;
391            while (pd)
392              if (pd->detector_num == b)
393                then
394                  break ;
395                else
396                  pd = pd->link ;
397            getbuf (q330, addr(pdp), sizeof(tdet_packet)) ;
398            pdp->detector_def = pd ;
399            pdp->det_num = loadbyte (p) ;
400            pdp->det_options = loadbyte (p) ;
401            pdp->parent = cur_lcq ;
402            cur_lcq->det = extend_link (cur_lcq->det, pdp) ;
403#endif
404          end
405        else
406          break ;
407      mask = mask shl 1 ;
408    end
409end
410
411static void read_dplcq (paqstruc paqs, pbyte *p)
412begin
413  plcq cur_lcq ;
414  tlocation loc ;
415  tseed_name name ;
416  boolean newone ;
417  pq330 q330 ;
418
419  q330 = paqs->owner ;
420  loadblock (p, 2, addr(loc)) ;
421  loadblock (p, 3, addr(name)) ;
422  cur_lcq = paqs->dplcqs ;
423  newone = FALSE ;
424  while (cur_lcq)
425    if ((memcmp(addr(cur_lcq->location), addr(loc), 2) == 0) land
426        (memcmp(addr(cur_lcq->seedname), addr(name), 3) == 0))
427      then
428        break ;
429      else
430        cur_lcq = cur_lcq->link ;
431  if (cur_lcq == NIL)
432    then
433      begin /* add new one */
434        newone = TRUE ;
435        getthrbuf (q330, addr(cur_lcq), sizeof(tlcq)) ;
436        if (paqs->dplcqs == NIL)
437          then
438            paqs->dplcqs = cur_lcq ;
439          else
440            paqs->dplcqs = extend_link (paqs->dplcqs, cur_lcq) ;
441      end
442  memcpy(addr(cur_lcq->location), addr(loc), 2) ;
443  memcpy(addr(cur_lcq->seedname), addr(name), 3) ;
444  set_loc_name (cur_lcq) ;
445  cur_lcq->lcq_num = loadbyte (p) ;
446  cur_lcq->lcq_num = 0xFF ; /* we don't actually use indexing for these lcqs */
447  cur_lcq->validated = TRUE ;
448  cur_lcq->raw_data_source = loadbyte (p) ;
449  cur_lcq->raw_data_field = loadbyte (p) ;
450  cur_lcq->lcq_opt = loadlongword (p) ;
451#ifndef OMIT_SEED
452  cur_lcq->firfixing_gain = 1.000 ; /* default if not over-ridden */
453  if (newone)
454    then
455      begin
456        getthrbuf (q330, addr(cur_lcq->com), sizeof(tcom_packet)) ;
457        cur_lcq->com->frame = 1 ;
458        cur_lcq->com->next_compressed_sample = 1 ;
459        cur_lcq->com->maxframes = 255 ;
460      end
461#endif
462  cur_lcq->caldly = 60 ;
463  cur_lcq->rate = loadint16 (p) ;
464  if (cur_lcq->lcq_opt and LO_GAP)
465    then
466      cur_lcq->gap_threshold = loadsingle (p) ;
467  if (cur_lcq->gap_threshold == 0.0)
468    then
469      cur_lcq->gap_threshold = 0.5 ;
470  set_gaps (cur_lcq) ;
471  if (cur_lcq->lcq_opt and LO_FRAME)
472    then
473#ifndef OMIT_SEED
474      cur_lcq->com->maxframes =
475#endif
476                        loadbyte (p) ;
477  init_dplcq (paqs, cur_lcq, newone) ;
478#ifndef OMIT_SEED
479  if (newone)
480    then
481      preload_archive (q330, FALSE, cur_lcq) ;
482#endif
483end
484
485#ifndef OMIT_SEED
486void read_control_detector (paqstruc paqs, pbyte *p)
487begin
488  pcontrol_detector cur_ctrl ;
489  pdop po ;
490  byte b ;
491  plcq pchan ;
492  pdet_packet pdp ;
493  boolean found ;
494  pq330 q330 ;
495  integer len ;
496
497  q330 = paqs->owner ;
498  getbuf (q330, addr(cur_ctrl), sizeof(tcontrol_detector)) ;
499  paqs->ctrlchain = extend_link (paqs->ctrlchain, cur_ctrl) ;
500  cur_ctrl->ctrl_num = loadbyte (p) ;
501  cur_ctrl->logmsg = (loadbyte (p) and 1) ;
502  len = loadbyte (p) ;
503  loadblock (p, len, addr(cur_ctrl->cdname)) ;
504  cur_ctrl->cdname[len] = 0 ;
505  repeat
506    b = loadbyte (p) ;
507    if (b == (DES_OP or DEO_DONE))
508      then
509        break ;
510    getbuf (q330, addr(po), sizeof(tdop)) ;
511    po->link = NIL ;
512    po->tok = b ;
513    po->point = NIL ;
514    switch (b and DES_OP) begin
515      case DES_DET :
516        pchan = paqs->lcqs ;
517        b = b and (not DES_OP) ;
518        found = FALSE ;
519        while ((lnot found) land (pchan))
520          begin
521            pdp = pchan->det ;
522            while (pdp)
523              if (pdp->det_num == b)
524                then
525                  break ;
526                else
527                  pdp = pdp->link ;
528            if (pdp)
529              then
530                begin
531                  found = TRUE ;
532                  po->point = pdp ;
533                end
534            pchan = pchan->link ;
535          end
536        break ;
537      case DES_CAL :
538        pchan = paqs->lcqs ;
539        b = b and (not DES_OP) ;
540        while (pchan)
541          if (pchan->lcq_num == b)
542            then
543              break ;
544            else
545              pchan = pchan->link ;
546        po->point = pchan ;
547        break ;
548    end
549    cur_ctrl->token_list = extend_link (cur_ctrl->token_list, po) ;
550  until FALSE) ;
551end
552
553void resolve_control_detectors (paqstruc paqs)
554begin
555  plcq cur_lcq ;
556  pcontrol_detector pc ;
557
558  cur_lcq = paqs->lcqs ;
559  while (cur_lcq)
560    begin
561      if (cur_lcq->ctrl)
562        then
563          begin
564            pc = paqs->ctrlchain ;
565            while (pc)
566              if (pc->ctrl_num == ((pntrint)cur_lcq->ctrl and 0xFF))
567                then
568                  break ;
569                else
570                  pc = pc->link ;
571            cur_lcq->ctrl = pc ;
572          end
573      cur_lcq = cur_lcq->link ;
574    end
575end
576#endif
577
578static void read_comm_events (paqstruc paqs, pbyte *p, pbyte stop)
579begin
580  string s ;
581  byte b ;
582  integer lth ;
583
584  while ((pntrint)*p < (pntrint)stop)
585    begin
586      b = loadbyte(p) ; /* comm event number */
587      lth = loadbyte(p) ;
588      loadblock (p, lth, addr(s)) ;
589      s[lth] = 0 ; /* null terminate */
590      if (b <= 31)
591        then
592          strncpy(addr(paqs->commevents[b].name), addr(s), COMMLENGTH) ;
593    end
594end
595
596static void read_dss (paqstruc paqs, pbyte *p)
597begin
598  tdss *pdss ;
599
600  pdss = addr(paqs->dss_def) ;
601  loadstring (p, 8, addr(pdss->high_pass)) ;
602  loadstring (p, 8, addr(pdss->mid_pass)) ;
603  loadstring (p, 8, addr(pdss->low_pass)) ;
604  pdss->timeout = loadlongint (p) ;
605  pdss->max_bps = loadlongint (p) ;
606  pdss->verbosity = loadbyte (p) ;
607  pdss->max_cpu_perc = loadbyte (p) ;
608  pdss->port_number = loadword (p) ;
609  pdss->max_mem = loadword (p) ;
610  pdss->reserved = loadword (p) ;
611end
612
613static void read_clock (paqstruc paqs, pbyte *p)
614begin
615  tclock *pclk ;
616  pq330 q330 ;
617
618  q330 = paqs->owner ;
619  pclk = addr(q330->qclock) ;
620  pclk->zone = loadlongint (p) ;
621  pclk->degrade_time = loadword (p) ;
622  pclk->q_locked = loadbyte (p) ;
623  pclk->q_track = loadbyte (p) ;
624  pclk->q_hold = loadbyte (p) ;
625  pclk->q_off = loadbyte (p) ;
626  pclk->q_spare = loadbyte (p) ;
627  pclk->q_high = loadbyte (p) ;
628  pclk->q_low = loadbyte (p) ;
629  pclk->q_never = loadbyte (p) ;
630  pclk->clock_filt = loadword (p) ;
631end
632
633static void read_log_tim (paqstruc paqs, pbyte *p)
634begin
635  tlog_tim *plt ;
636
637  plt = addr(paqs->log_tim) ;
638  loadblock (p, 2, addr(plt->log_location)) ;
639  loadblock (p, 3, addr(plt->log_seedname)) ;
640  loadblock (p, 2, addr(plt->tim_location)) ;
641  loadblock (p, 3, addr(plt->tim_seedname)) ;
642end
643
644static void read_cfgid (paqstruc paqs, pbyte *p)
645begin
646  tlog_cfg *plc ;
647
648  plc = addr(paqs->log_cfg) ;
649  loadblock (p, 2, addr(plc->cfg_location)) ;
650  loadblock (p, 3, addr(plc->cfg_seedname)) ;
651  plc->flags = loadbyte (p) ;
652  plc->interval = loadword (p) ;
653end
654
655#ifndef OMIT_SEED
656void add_msg_tim_lcqs (paqstruc paqs)
657begin
658  plcq cur_lcq ;
659  pq330 q330 ;
660  boolean newone ;
661
662  q330 = paqs->owner ;
663  cur_lcq = paqs->dplcqs ;
664  newone = FALSE ;
665  while (cur_lcq)
666    if ((memcmp(addr(cur_lcq->location), addr(paqs->log_tim.log_location), 2) == 0) land
667       (memcmp(addr(cur_lcq->seedname), addr(paqs->log_tim.log_seedname), 3) == 0))
668      then
669        break ;
670      else
671        cur_lcq = cur_lcq->link ;
672  if (cur_lcq == NIL)
673    then
674      begin /* add new one */
675        newone = TRUE ;
676        getthrbuf (q330, addr(cur_lcq), sizeof(tlcq)) ;
677        if (paqs->dplcqs == NIL)
678          then
679            paqs->dplcqs = cur_lcq ;
680          else
681            paqs->dplcqs = extend_link (paqs->dplcqs, cur_lcq) ;
682      end
683  paqs->msg_lcq = cur_lcq ;
684  memcpy(addr(cur_lcq->location), addr(paqs->log_tim.log_location), 2) ;
685  memcpy(addr(cur_lcq->seedname), addr(paqs->log_tim.log_seedname), 3) ;
686  set_loc_name (cur_lcq) ;
687  cur_lcq->raw_data_source = MESSAGE_STREAM ;
688  cur_lcq->lcq_num = 0xFF ; /* not used */
689  cur_lcq->validated = TRUE ;
690#ifndef OMIT_SEED
691  if (newone)
692    then
693      begin
694        getthrbuf (q330, addr(cur_lcq->com), sizeof(tcom_packet)) ;
695        cur_lcq->com->frame = 1 ;
696        cur_lcq->com->next_compressed_sample = 1 ;
697        cur_lcq->com->maxframes = 255 ;
698      end
699#endif
700  init_dplcq (paqs, cur_lcq, newone) ;
701#ifndef OMIT_SEED
702  if (newone)
703    then
704      preload_archive (q330, FALSE, cur_lcq) ;
705#endif
706  getbuf (q330, addr(cur_lcq), sizeof(tlcq)) ;
707  getbuf (q330, addr(cur_lcq->com), sizeof(tcom_packet)) ;
708  paqs->lcqs = extend_link (paqs->lcqs, cur_lcq) ;
709  paqs->tim_lcq = cur_lcq ;
710  memcpy(addr(cur_lcq->location), addr(paqs->log_tim.tim_location), 2) ;
711  memcpy(addr(cur_lcq->seedname), addr(paqs->log_tim.tim_seedname), 3) ;
712  set_loc_name (cur_lcq) ;
713  cur_lcq->raw_data_source = TIMING_STREAM ;
714  inc(paqs->highest_lcqnum) ;
715  cur_lcq->lcq_num = paqs->highest_lcqnum ;
716  if (q330->par_create.call_minidata)
717    then
718      cur_lcq->mini_filter = q330->par_create.opt_minifilter and (OMF_ALL or OMF_TIM) ;
719  if ((paqs->arc_size > 0) land (q330->par_create.call_aminidata))
720    then
721      cur_lcq->arc.amini_filter = q330->par_create.opt_aminifilter and (OMF_ALL or OMF_TIM) ;
722  getbuf (q330, addr(cur_lcq), sizeof(tlcq)) ;
723  getbuf (q330, addr(cur_lcq->com), sizeof(tcom_packet)) ;
724  paqs->lcqs = extend_link (paqs->lcqs, cur_lcq) ;
725  paqs->cfg_lcq = cur_lcq ;
726  memcpy(addr(cur_lcq->location), addr(paqs->log_cfg.cfg_location), 2) ;
727  memcpy(addr(cur_lcq->seedname), addr(paqs->log_cfg.cfg_seedname), 3) ;
728  set_loc_name (cur_lcq) ;
729  cur_lcq->raw_data_source = CFG_STREAM ;
730  inc(paqs->highest_lcqnum) ;
731  cur_lcq->lcq_num = paqs->highest_lcqnum ;
732  if (q330->par_create.call_minidata)
733    then
734      cur_lcq->mini_filter = q330->par_create.opt_minifilter and (OMF_ALL or OMF_CFG) ;
735  if ((paqs->arc_size > 0) land (q330->par_create.call_aminidata))
736    then
737      cur_lcq->arc.amini_filter = q330->par_create.opt_aminifilter and (OMF_ALL or OMF_CFG) ;
738end
739#endif
740
741pointer tonext (pointer base, integer offset)
742begin
743
744  return (pointer)((pntrint)base + offset) ;
745end
746
747void decode_cfg (pq330 q330)
748begin
749  byte tok ;
750  word next ;
751  integer i, lth ;
752  string s ;
753  string s1 ;
754  pbyte p, pend, pref ;
755  paqstruc paqs ;
756  plcq q ;
757  enum tacctype acctype ;
758  taccmstat *paccm ;
759
760  paqs = q330->aqstruc ;
761  for (i = 0 ; i <= CE_MAX - 1 ; i++)
762    sprintf(addr(paqs->commevents[i].name), "COMM:%d", i + 1) ;
763  q = paqs->dplcqs ;
764  while (q)
765    begin
766      q->validated = FALSE ;
767      q = q->link ;
768    end
769  p = (pointer)q330->cfgbuf ;
770  pend = p ;
771  incn(pend, q330->cfgsize) ;
772  while ((pntrint)p < (pntrint)pend)
773    begin
774      tok = loadbyte (addr(p)) ;
775      switch (tok) begin
776        case TF_NOP :
777          break ;
778        case TF_VERSION :
779          tok = loadbyte (addr(p)) ; /* token version number */
780          if (tok != T_VER)
781            then
782              begin
783                libmsgadd (q330, LIBMSG_INVTVER, "") ;
784                p = pend ; /* force leaving the loop */
785                break ;
786              end
787          break ;
788        case TF_NET_STAT :
789          loadblock (addr(p), 2, addr(q330->network)) ;
790          loadblock (addr(p), 5, addr(q330->station)) ;
791          break ;
792        case TF_NETSERV :
793          paqs->netport = loadword (addr(p)) ;
794          break ;
795        case TF_DSS :
796          read_dss (paqs, addr(p)) ;
797          break ;
798        case TF_WEB :
799          paqs->webport = loadword (addr(p)) ;
800          break ;
801        case TF_DATASERV :
802          paqs->dservport = loadword (addr(p)) ;
803          break ;
804        case TF_CLOCK :
805          read_clock (paqs, addr(p)) ;
806          break ;
807        case TF_MT :
808          read_log_tim (paqs, addr(p)) ;
809          break ;
810        case TF_CFG :
811          read_cfgid (paqs, addr(p)) ;
812          break ;
813        case T1_MHD :
814        case T1_THRD :
815          pref = p ;
816          next = loadbyte (addr(p)) ; /* total size */
817#ifndef OMIT_SEED
818          read_detector (paqs, addr(p), (tok == T1_MHD)) ;
819#endif
820          p = tonext(pref, next) ;
821          break ;
822        case T1_IIR :
823          pref = p ;
824          next = loadbyte (addr(p)) ; /* total size */
825#ifndef OMIT_SEED
826          read_iir (paqs, addr(p)) ;
827#endif
828          p = tonext(pref, next) ;
829          break ;
830        case T1_FIR :
831          pref = p ;
832          next = loadbyte (addr(p)) ; /* total size */
833#ifndef OMIT_SEED
834          read_fir (paqs, addr(p)) ;
835#endif
836          p = tonext(pref, next) ;
837          break ;
838        case T1_LCQ :
839          pref = p ;
840          next = loadbyte (addr(p)) ; /* total size */
841          read_lcq (paqs, addr(p)) ;
842          p = tonext(pref, next) ;
843          break ;
844        case T1_DPLCQ :
845          pref = p ;
846          next = loadbyte (addr(p)) ; /* total size */
847          read_dplcq (paqs, addr(p)) ;
848          p = tonext(pref, next) ;
849          break ;
850        case T1_CTRL :
851          pref = p ;
852          next = loadbyte (addr(p)) ;
853#ifndef OMIT_SEED
854          read_control_detector (paqs, addr(p)) ;
855#endif
856          p = tonext(pref, next) ;
857          break ;
858        case T1_NONCOMP :
859          pref = p ;
860          paqs->non_comp = TRUE ;
861          next = loadbyte (addr(p)) ;
862          p = tonext(pref, next) ;
863          break ;
864        case T2_CNAMES :
865          pref = p ;
866          next = loadword (addr(p)) ;
867          read_comm_events (paqs, addr(p), (pointer)((pntrint)pref + next)) ;
868          p = tonext(pref, next) ;
869          break ;
870        case T2_OPAQUE :
871          pref = p ;
872          next = loadword (addr(p)) ; /* get length */
873#ifndef OMIT_SEED
874          paqs->opaque_size = next - 2 ; /* don't count length word */
875          getbuf (q330, addr(paqs->opaque_buf), paqs->opaque_size) ;
876          loadblock (addr(p), paqs->opaque_size, paqs->opaque_buf) ;
877#endif
878          p = tonext(pref, next) ;
879          break ;
880        default :
881          if (tok >= 0x80)
882            then /* variable length */
883              if (tok >= 0xC0)
884                then
885                  begin /* two byte length */
886                    pref = p ;
887                    next = loadword (addr(p)) ;
888                    p = tonext(pref, next) ;
889                  end
890                else
891                  begin /* one byte length */
892                    pref = p ;
893                    next = loadbyte (addr(p)) ;
894                    p = tonext(pref, next) ;
895                  end
896          break ;
897      end
898    end
899#ifndef OMIT_SEED
900  add_msg_tim_lcqs (paqs) ;
901  resolve_control_detectors (paqs) ; /* lcqs didn't have anything to point to yet */
902#endif
903  q = paqs->dplcqs ;
904  while (q)
905    begin
906      if ((lnot q->validated) land (q->raw_data_source != MESSAGE_STREAM))
907        then
908          begin
909            for (acctype = AC_FIRST ; acctype <= AC_LAST ; acctype++)
910              begin
911                paccm = addr(q330->share.accmstats[acctype]) ;
912                if (paccm->ds_lcq == q)
913                  then
914                    paccm->ds_lcq = NIL ;
915              end
916            if (paqs->data_latency_lcq == q)
917              then
918                paqs->data_latency_lcq = NIL ;
919            else if (paqs->status_latency_lcq == q)
920              then
921                paqs->status_latency_lcq = NIL ;
922          end
923      q = q->link ;
924    end
925  lth = 0 ;
926  for (i = 0 ; i <= 4 ; i++)
927    if (q330->station[i] != ' ')
928      then
929        s[lth++] = q330->station[i] ;
930  s[lth] = 0 ; /* build string representation of station (3-5 characters) */
931  s1[0] = q330->network[0] ;
932  s1[1] = q330->network[1] ;
933  s1[2] = 0 ; /* build string representation of network (always 2 characters) */
934  sprintf (addr(q330->station_ident), "%s-%s", s1, s) ; /* network-station */
935  init_lcq (paqs) ;
936#ifndef OMIT_SEED
937  expand_control_detectors (paqs) ;
938#endif
939  check_continuity (q330) ;
940  if (paqs->data_timetag > 1.0) /* if non-zero continuity was restored, write cfg blks at start of session */
941    then
942      begin
943        libdatamsg (q330, LIBMSG_RESTCONT, "") ;
944        paqs->contingood = restore_continuity (q330) ;
945        if (lnot paqs->contingood)
946          then
947            libdatamsg (q330, LIBMSG_CONTNR, "") ;
948      end
949  paqs->last_data_qual = NO_LAST_DATA_QUAL ;
950  paqs->first_data = TRUE ;
951  q330->data_timer = 0 ;
952  q330->status_timer = 0 ;
953  if (lnot paqs->non_comp)
954    then
955      verify_mapping (q330) ;
956#ifndef OMIT_SEED
957  if (paqs->arc_size > 0)
958    then
959      preload_archive (q330, TRUE, NIL) ;
960  if ((paqs->data_timetag > 1) land (paqs->log_cfg.flags and LC_START))
961    then
962      start_cfgblks (paqs) ;
963#endif
964  new_state (q330, LIBSTATE_RUNWAIT) ;
965end
966
967void read_q330_cfg (pq330 q330, pbyte pb)
968begin
969  word w ;
970  tseghdr seghdr ;
971  pbyte p ;
972  tmem *pmem ;
973  string31 s ;
974
975  p = pb ; /* p now has location in received buffer */
976  pmem = addr(q330->mem_hdr) ;
977  loadseghdr (addr(p), addr(seghdr)) ;
978  w = pmem->count - 4 ; /* remove segment numbers */
979  q330->cfgnow = (seghdr.segnum - 1) * MAXSEG ;
980  memcpy (addr((*(q330->cfgbuf))[q330->cfgnow]), p, w) ;
981  q330->cfgsize = q330->cfgnow + w ;
982  if (seghdr.segnum == seghdr.segtotal)
983    then
984      begin
985        sprintf(s, "%d bytes", q330->cfgsize) ;
986        libmsgadd (q330, LIBMSG_TOKREAD, addr(s)) ;
987        new_state (q330, LIBSTATE_DECTOK) ;
988      end
989    else
990      begin
991        q330->cfgoffset = q330->cfgoffset + w + OVERHEAD ;
992        pmem = addr(q330->mem_req) ;
993        pmem->start = q330->cfgoffset ;
994        pmem->count = 0 ;
995        pmem->memtype = MT_CFG1 + q330->par_create.q330id_dataport ;
996        new_cmd (q330, C1_RQMEM, MAXSEG) ;
997      end
998end
999
1000void cfg_start (pq330 q330)
1001begin
1002  tmem *pmem ;
1003
1004  pmem = addr(q330->mem_req) ;
1005  new_state (q330, LIBSTATE_READTOK) ;
1006  libmsgadd (q330, LIBMSG_READTOK, "") ;
1007  q330->data_timer = 0 ;
1008  pmem->start = 0 ;
1009  pmem->count = 0 ;
1010  pmem->memtype = MT_CFG1 + q330->par_create.q330id_dataport ;
1011  new_cmd (q330, C1_RQMEM, MAXSEG) ;
1012  q330->cfgsize = 0 ;
1013  q330->cfgnow = 0 ;
1014  q330->cfgoffset = 0 ;
1015end
Note: See TracBrowser for help on using the repository browser.