ANITA Event Reader
AnitaPacketUtil.cxx
1 //
2 // Body for AnitaPacketUtil class so that CINT recognizes its existence
3 //
4 #include "AnitaPacketUtil.h"
5 #include "AnitaGeomTool.h"
6 #include "simpleStructs.h"
7 #include "compress/mulawTables.h"
8 #include <iostream>
9 #include <zlib.h>
10 #include <cstring>
11 
12 
13 int simplePacketCheck(GenericHeader_t *gHdr, PacketCode_t code) {
14  int packetSize=getPacketSize(code);
15  unsigned char expVerId=getVersionId(code);
16 
17  if((gHdr->code&BASE_PACKET_MASK)!=code ||
18  gHdr->verId!=expVerId ||
19  gHdr->numBytes!=packetSize) {
20  std::cerr << "Mismatched packet\t" << packetCodeAsString(code) << "\n"
21  << "code:\t" << (int)gHdr->code << "\t" << (int)code
22  << "\nversion:\t" << (int)gHdr->verId
23  << "\t" << (int)expVerId
24  << "\nsize:\t" << gHdr->numBytes << "\t"
25  << packetSize << std::endl;
26  return -1;
27  }
28  return 0;
29 }
30 
31 
32 int getPacketSize(PacketCode_t code) {
33  switch(code&BASE_PACKET_MASK) {
34  case PACKET_BD: return sizeof(AnitaEventBody_t); break;
35  case PACKET_HD: return sizeof(AnitaEventHeader_t); break;
36  case PACKET_WV: return sizeof(RawWaveformPacket_t); break;
37  case PACKET_PEDSUB_WV: return sizeof(PedSubbedWaveformPacket_t); break;
38  case PACKET_PEDSUB_SURF: return sizeof(PedSubbedSurfPacket_t); break;
39  case PACKET_SURF: return sizeof(RawSurfPacket_t); break;
40  case PACKET_SURF_HK: return sizeof(FullSurfHkStruct_t); break;
41  case PACKET_TURF_RATE: return sizeof(TurfRateStruct_t); break;
42  case PACKET_TURF_REGISTER: return sizeof(TurfRegisterContents_t); break;
43  case PACKET_AVG_SURF_HK: return sizeof(AveragedSurfHkStruct_t); break;
44  case PACKET_SUM_TURF_RATE: return sizeof(SummedTurfRateStruct_t); break;
45  case PACKET_ENC_WV_PEDSUB: break;
46  case PACKET_ENC_SURF: break;
47  case PACKET_ENC_SURF_PEDSUB: break;
48  case PACKET_PED_SUBBED_EVENT: return sizeof(PedSubbedEventBody_t); break;
49  case PACKET_LAB_PED: return sizeof(FullLabChipPedStruct_t); break;
50  case PACKET_FULL_PED: return sizeof(FullPedStruct_t); break;
51  case PACKET_GPS_ADU5_PAT: return sizeof(GpsAdu5PatStruct_t); break;
52  case PACKET_GPS_ADU5_SAT: return sizeof(GpsAdu5SatStruct_t); break;
53  case PACKET_GPS_ADU5_VTG: return sizeof(GpsAdu5VtgStruct_t); break;
54  case PACKET_GPS_G12_POS: return sizeof(GpsG12PosStruct_t); break;
55  case PACKET_GPS_G12_SAT: return sizeof(GpsG12SatStruct_t); break;
56  case PACKET_GPS_GGA: return sizeof(GpsGgaStruct_t); break;
57  case PACKET_HKD: return sizeof(HkDataStruct_t); break;
58  case PACKET_HKD_SS: return sizeof(SSHkDataStruct_t); break;
59  case PACKET_CMD_ECHO: return sizeof(CommandEcho_t); break;
60  case PACKET_MONITOR: return sizeof(MonitorStruct_t); break;
61  case PACKET_WAKEUP_LOS: return WAKEUP_LOS_BUFFER_SIZE; break;
62  case PACKET_WAKEUP_HIGHRATE: return WAKEUP_TDRSS_BUFFER_SIZE;
63  break;
64  case PACKET_WAKEUP_COMM1: return WAKEUP_LOW_RATE_BUFFER_SIZE;
65  break;
66  case PACKET_WAKEUP_COMM2: return WAKEUP_LOW_RATE_BUFFER_SIZE;
67  break;
68  case PACKET_SLOW1: return sizeof(SlowRateType1_t);
69  break;
70  case PACKET_SLOW2: return sizeof(SlowRateType1_t);
71  break;
72  case PACKET_SLOW_FULL: return sizeof(SlowRateFull_t);
73  break;
74  case PACKET_RUN_START: return sizeof(RunStart_t);
75  break;
76  case PACKET_OTHER_MONITOR: return sizeof(OtherMonitorStruct_t);
77  break;
78  case PACKET_ZIPPED_PACKET: break;
79  case PACKET_ZIPPED_FILE: break;
80  case PACKET_GPSD_START: return sizeof(GpsdStartStruct_t); break;
81  case PACKET_LOGWATCHD_START: return sizeof(LogWatchdStart_t); break;
82  case PACKET_ACQD_START: return sizeof(AcqdStartStruct_t); break;
83  case PACKET_GPU_AVE_POW_SPEC: return sizeof(GpuPhiSectorPowerSpectrumStruct_t); break;
84 
85 
86 
87  // default:
88  // retVal+=PKT_E_CODE; break;
89  }
90  return 0;
91 
92 }
93 
94 
95 
96 unsigned int simpleIntCrc(unsigned int *p, unsigned int n)
97 {
98  unsigned int sum = 0;
99  unsigned int i;
100  for (i=0L; i<n; i++) {
101  //
102  sum += *p++;
103  }
104  // printf("%u %u\n",*p,sum);
105  return ((0xffffffff - sum) + 1);
106 }
107 
108 unsigned char getVersionId(PacketCode_t code) {
109 
110  switch(code&BASE_PACKET_MASK) {
111  case PACKET_BD: return VER_EVENT_BODY; break;
112  case PACKET_HD: return VER_EVENT_HEADER; break;
113  case PACKET_HD_SLAC: return SLAC_VER_EVENT_HEADER; break;
114  case PACKET_WV: return VER_WAVE_PACKET; break;
115  case PACKET_SURF: return VER_SURF_PACKET; break;
116  case PACKET_SURF_HK: return VER_SURF_HK; break;
117  case PACKET_TURF_RATE: return VER_TURF_RATE; break;
118  case PACKET_AVG_SURF_HK: return VER_AVG_SURF_HK; break;
119  case PACKET_SUM_TURF_RATE: return VER_SUM_TURF_RATE; break;
120  case PACKET_TURF_REGISTER: return VER_TURF_REG; break;
121  case PACKET_LAB_PED: return VER_LAB_PED; break;
122  case PACKET_FULL_PED: return VER_FULL_PED; break;
123  case PACKET_ENC_WV_PEDSUB: return VER_ENC_WAVE_PACKET; break;
124  case PACKET_ENC_SURF: return VER_ENC_SURF_PACKET; break;
125  case PACKET_PED_SUBBED_EVENT: return VER_PEDSUBBED_EVENT_BODY; break;
126  case PACKET_GPS_ADU5_PAT: return VER_ADU5_PAT; break;
127  case PACKET_GPS_ADU5_SAT: return VER_ADU5_SAT; break;
128  case PACKET_GPS_ADU5_VTG: return VER_ADU5_VTG; break;
129  case PACKET_GPS_G12_POS: return VER_G12_POS; break;
130  case PACKET_GPS_G12_SAT: return VER_G12_SAT; break;
131  case PACKET_GPS_GGA: return VER_GPS_GGA; break;
132  case PACKET_HKD: return VER_HK_FULL; break;
133 #ifndef ANITA_2_DATA
134  case PACKET_HKD_SS: return VER_HK_SS; break;
135 #endif
136  case PACKET_CMD_ECHO: return VER_CMD_ECHO; break;
137  case PACKET_MONITOR: return VER_MONITOR; break;
138  case PACKET_SLOW1: return VER_SLOW_1; break;
139  case PACKET_SLOW2: return VER_SLOW_2; break;
140  case PACKET_SLOW_FULL: return VER_SLOW_FULL; break;
141  case PACKET_ZIPPED_FILE: return VER_ZIPPED_FILE; break;
142  case PACKET_ZIPPED_PACKET: return VER_ZIPPED_PACKET; break;
143  case PACKET_RUN_START: return VER_RUN_START; break;
144  case PACKET_OTHER_MONITOR: return VER_OTHER_MON; break;
145  case PACKET_GPSD_START: return VER_GPSD_START; break;
146  case PACKET_LOGWATCHD_START: return VER_LOGWATCHD_START; break;
147  case PACKET_ACQD_START: return VER_ACQD_START; break;
148  case PACKET_GPU_AVE_POW_SPEC: return VER_GPU_POW_SPEC; break;
149  default:
150  return 0; break;
151  }
152  return 0;
153 }
154 
155 
156 void fillGenericHeader(void *thePtr, PacketCode_t code, unsigned short numBytes) {
157  // printf("sizeof(GenericHeader_t):\t%d\n",sizeof(GenericHeader_t));
158  // printf("numBytes %d\n",numBytes);
159  unsigned int *typedPtr = (unsigned int *)thePtr;
160  unsigned int intBytes=(numBytes-sizeof(GenericHeader_t))/4;
161  GenericHeader_t *gHdr= (GenericHeader_t*)typedPtr;
162  unsigned long dodgyNum=(unsigned long)typedPtr;
163  dodgyNum+=sizeof(GenericHeader_t);
164  unsigned int *dataPtr=(unsigned int*)dodgyNum;
165  // unsigned int *dataPtr=(unsigned int*) (typedPtr+sizeof(GenericHeader_t));
166  // printf("%u -- %u -- %u\n",thePtr,dataPtr,((unsigned int)(dataPtr)-(unsigned int)(thePtr)));
167  gHdr->code=code;
168  gHdr->numBytes=numBytes;
169  gHdr->feByte=0xfe;
170  gHdr->verId=getVersionId(code);
171  gHdr->checksum=simpleIntCrc(dataPtr,intBytes);
172  // printf("Int bytes %u\t checksum %u\n",intBytes,gHdr->checksum);
173 }
174 
175 #define PKT_E_CHECKSUM 0x1
176 #define PKT_E_CODE 0x2
177 #define PKT_E_FEBYTE 0x4
178 #define PKT_E_SIZE 0x8
179 
180 int checkPacket(void *thePtr)
181 //0 means no errors
182 //1 means checksum mismatch
183 //2 means unknown packet code
184 //4 means missing feByte missing
185 //8 means packet size mismatch
186 {
187  unsigned int *typedPtr=(unsigned int*) thePtr;
188  int retVal=0,packetSize=0;
189  GenericHeader_t *gHdr= (GenericHeader_t*)typedPtr;
190  unsigned int numInts=(gHdr->numBytes-sizeof(GenericHeader_t))/4;
191  unsigned long dodgyNum=(unsigned long)typedPtr;
192  dodgyNum+=sizeof(GenericHeader_t);
193  unsigned int *dataPtr=(unsigned int*)dodgyNum;
194  // unsigned int *dataPtr=(unsigned int*) (typedPtr+sizeof(GenericHeader_t));
195  // std::cout << thePtr << "\t" << dataPtr << std::endl;
196  unsigned int checksum=0;
197  if(numInts<4000)
198  checksum=simpleIntCrc(dataPtr,numInts);
199  PacketCode_t code=gHdr->code;
200  if(checksum!=gHdr->checksum) {
201  // printf("Checksum Mismatch (possibly %s (%d)) (%u ints -- %d bytes) %u -- %u \n",
202  // packetCodeAsString(code),code,numInts,gHdr->numBytes,checksum,gHdr->checksum);
203  retVal+=PKT_E_CHECKSUM;
204  }
205 
206  //Now check packet size
207  packetSize=getPacketSize(code);
208  if(packetSize && (packetSize!=gHdr->numBytes))
209  retVal+=PKT_E_SIZE;
210 
211  unsigned char expVerId=getVersionId(code);
212 
213  if(gHdr->verId!=expVerId) {
214  std::cout << "Version mis-match: " << (int) gHdr->verId << "\t" << (int)expVerId << "\n";
215  }
216 
217 
218  if(gHdr->feByte!=0xfe) retVal+=PKT_E_FEBYTE;
219  return retVal;
220 
221 }
222 
223 const char *packetCodeAsString(PacketCode_t code) {
224  const char* string ;
225  switch(code&BASE_PACKET_MASK) {
226  case PACKET_BD: string="AnitaEventBody_t"; break;
227  case PACKET_HD: string="AnitaEventHeader_t"; break;
228  case PACKET_WV: string="RawWaveformPacket_t"; break;
229  case PACKET_PEDSUB_WV: string="PedSubbedWaveformPacket_t"; break;
230  case PACKET_SURF: string="RawSurfPacket_t"; break;
231  case PACKET_PEDSUB_SURF: string="PedSubbedSurfPacket_t"; break;
232  case PACKET_SURF_HK: string="FullSurfHkStruct_t"; break;
233  case PACKET_TURF_RATE: string="TurfRateStruct_t"; break;
234  case PACKET_LAB_PED: string="FullLabChipPedStruct_t"; break;
235  case PACKET_FULL_PED: string="FullPedStruct_t"; break;
236  case PACKET_ENC_WV_PEDSUB: string="EncodedPedSubbedChannelPacketHeader_t"; break;
237  case PACKET_ENC_SURF: string="EncodedSurfPacketHeader_t"; break;
238  case PACKET_ENC_SURF_PEDSUB: string="EncodedPedSubbedSurfPacketHeader_t"; break;
239  case PACKET_GPS_ADU5_PAT: string="GpsAdu5PatStruct_t"; break;
240  case PACKET_GPS_ADU5_SAT: string="GpsAdu5SatStruct_t"; break;
241  case PACKET_GPS_ADU5_VTG: string="GpsAdu5VtgStruct_t"; break;
242  case PACKET_GPS_G12_POS: string="GpsG12PosStruct_t"; break;
243  case PACKET_GPS_G12_SAT: string="GpsG12SatStruct_t"; break;
244  case PACKET_HKD: string="HkDataStruct_t"; break;
245  case PACKET_HKD_SS: string="SSHkDataStruct_t"; break;
246  case PACKET_CMD_ECHO: string="CommandEcho_t"; break;
247  case PACKET_MONITOR: string="MonitorStruct_t"; break;
248  case PACKET_WAKEUP_LOS: string="LosWakeUpPacket"; break;
249  case PACKET_WAKEUP_HIGHRATE: string="TdrssWakeUpPacket"; break;
250  case PACKET_WAKEUP_COMM1: string="Comm1WakeUpPacket"; break;
251  case PACKET_WAKEUP_COMM2: string="Comm2WakeUpPacket"; break;
252  case PACKET_SLOW1: string="SlowRateType1_t"; break;
253  case PACKET_SLOW2: string="SlowRateType1_t"; break;
254  case PACKET_ZIPPED_PACKET: string="ZippedPacket_t"; break;
255  case PACKET_ZIPPED_FILE: string="ZippedFile_t"; break;
256  case PACKET_RUN_START: string="RunStart_t"; break;
257  case PACKET_OTHER_MONITOR: string="OtherMonitorStruct_t"; break;
258  case PACKET_GPSD_START: string="GpsdStartStruct_t"; break;
259  case PACKET_LOGWATCHD_START: string="LogWatchdStart_t"; break;
260  case PACKET_ACQD_START: string="AcqdStartStruct_t"; break;
261  case PACKET_GPS_GGA: string="GpsGgaStruct_t"; break;
262  case PACKET_AVG_SURF_HK: string="AveragedSurfHkStruct_t"; break;
263  case PACKET_SUM_TURF_RATE: string="SummedTurfRateStruct_t"; break;
264  case PACKET_GPU_AVE_POW_SPEC: string="GpuPhiSectorPowerSpectrumStruct_t"; break;
265 
266  default:
267  string="Unknown Packet Code"; break;
268  }
269  return string;
270 }
271 
272 
273 
274 int unzipZippedPacket(ZippedPacket_t *zipPacket, char *output, unsigned int numBytesOut) {
275  char *input = (char*) zipPacket;
276  unsigned int returnBytes=numBytesOut;
277  int retVal=unzipBuffer(&input[sizeof(ZippedPacket_t)],output,zipPacket->gHdr.numBytes-sizeof(ZippedPacket_t),&returnBytes);
278  if(retVal!=0)
279  return retVal;
280  if(zipPacket->numUncompressedBytes!=returnBytes)
281  return -1;
282  return 0;
283 }
284 
285 
286 
287 int zipBuffer(char *input, char *output, unsigned int inputBytes, unsigned int *outputBytes)
288 {
289  static int errorCounter=0;
290  int retVal=compress((unsigned char*)output,(unsigned long*)outputBytes,(unsigned char*)input,(unsigned long)inputBytes);
291  if(retVal==Z_OK)
292  return 0;
293  else {
294  if(errorCounter<100) {
295  fprintf(stderr,"zlib compress returned %d (%d of 100)\n",retVal,errorCounter);
296  errorCounter++;
297  }
298  return -1;
299  }
300 }
301 
302 
303 int unzipBuffer(char *input, char *output, unsigned int inputBytes, unsigned int *outputBytes)
304 {
305 
306  unsigned long outputBytesLong;
307  static int errorCounter=0;
308  // int retVal=uncompress((unsigned char*)output,(unsigned long*)outputBytes,(unsigned char*)input,(unsigned long)inputBytes);
309  // if(retVal==Z_OK)
310  outputBytesLong = *outputBytes;
311  int retVal=uncompress((unsigned char*)output,&outputBytesLong,(unsigned char*)input,(unsigned long)inputBytes);
312  if(retVal==Z_OK)
313  {
314  *outputBytes = outputBytesLong;
315  return 0;
316  // else {
317  }
318  else {
319  if(errorCounter<100) {
320  fprintf(stderr,"zlib compress returned %d (%d of 100)\n",retVal,errorCounter);
321  errorCounter++;
322 
323 
324  // static int errorCounter=0;
325  //int retVal=uncompress((unsigned char*)output,(unsigned long*)outputBytes,(unsigned char*)input,(unsigned long)inputBytes);
326  //if(retVal==Z_OK)
327  // return 0;
328  //else {
329  //if(errorCounter<100) {
330  // fprintf(stderr,"zlib compress returned %d (%d of 100)\n",retVal,errorCounter);
331  // errorCounter++;
332  }
333  return -1;
334  }
335 }
336 
337 
338 CompressErrorCode_t AnitaCompress::packPedSubbedEvent(PedSubbedEventBody_t *bdPtr,
339  EncodeControlStruct_t *cntlPtr,
340  unsigned char *output,
341  int *numBytes)
342 {
343 
344  int count=0,surfStart=0;
345  int surf=0;
346  int chan=0;
347  EncodedPedSubbedSurfPacketHeader_t *surfHdPtr;
348 // printf("Event %lu\n",bdPtr->eventNumber);
349 
350  EncodedEventWrapper_t *encEvWrap = (EncodedEventWrapper_t*) output;
351  encEvWrap->eventNumber=bdPtr->eventNumber;
352  count+=sizeof(EncodedEventWrapper_t);
353 
354  for(surf=0;surf<ACTIVE_SURFS;surf++) {
355  surfHdPtr = (EncodedPedSubbedSurfPacketHeader_t*) &output[count];
356  surfStart=count;
357  surfHdPtr->whichPeds=bdPtr->whichPeds;
358  surfHdPtr->eventNumber=bdPtr->eventNumber;
359  count+=sizeof(EncodedPedSubbedSurfPacketHeader_t);
360  for(chan=0;chan<CHANNELS_PER_SURF;chan++) {
361  count+=encodePSChannel(cntlPtr->encTypes[surf][chan],
362  &(bdPtr->channel[AnitaGeomTool::getChanIndex(surf,chan)]),
363  &output[count]);
364  if(count>MAX_WAVE_BUFFER)
365  return COMPRESS_E_TOO_BIG;
366  }
367  //Fill Generic Header_t;
368  fillGenericHeader(surfHdPtr,PACKET_ENC_SURF_PEDSUB,(count-surfStart));
369 
370  }
371  *numBytes=count;
372  encEvWrap->numBytes=count-sizeof(EncodedEventWrapper_t);
373  fillGenericHeader(encEvWrap,PACKET_ENC_PEDSUB_EVENT_WRAPPER,count);
374  return COMPRESS_E_OK;
375 }
376 
377 
378 
379 
380 CompressErrorCode_t AnitaCompress::unpackToPedSubbedEvent(PedSubbedEventBody_t *bdPtr,
381  unsigned char *input,
382  int numBytes)
383 
384 {
385 
386  return unpackToPedSubbedEventWithStats(bdPtr,input,numBytes,0,0);
387 
388 }
389 
390 
391 CompressErrorCode_t
392 AnitaCompress::unpackOneSurfToPedSubbedEvent(PedSubbedEventBody_t *bdPtr,
393  unsigned char *input,
394  int numBytes)
395 {
396  int count=0;
397  int chan=0;
398  int chanIndex;
399  CompressErrorCode_t retVal=COMPRESS_E_OK;
400  EncodedPedSubbedSurfPacketHeader_t *surfHdPtr;
401  EncodedSurfChannelHeader_t *chanHdPtr;
402 
403 
404  surfHdPtr = (EncodedPedSubbedSurfPacketHeader_t*) &input[count];
405  bdPtr->whichPeds=surfHdPtr->whichPeds;
406  bdPtr->eventNumber=surfHdPtr->eventNumber;
407  count+=sizeof(EncodedPedSubbedSurfPacketHeader_t);
408  for(chan=0;chan<CHANNELS_PER_SURF;chan++) {
409  chanHdPtr = (EncodedSurfChannelHeader_t*)&input[count];
410  count+=sizeof(EncodedSurfChannelHeader_t);
411  // printf("chan %d, encType %d\n",
412  // chan,chanHdPtr->encType);
413  chanIndex=chanHdPtr->rawHdr.chanId;
414  if(chanIndex%9 != chan) {
415  printf("Error reading encoded Ped Subbed SURF packet, have chanId %d and chan %d\n",chanIndex,chan);
416  return COMPRESS_E_UNPACK;
417  }
418 
419  retVal=decodePSChannel(chanHdPtr,
420  &input[count],
421  &(bdPtr->channel[chanIndex]));
422 
423  // std::cout << chanIndex << "\t" << bdPtr->channel[chanIndex].data[0]
424  // << "\n";
425 
426 
427 
428  if(retVal!=COMPRESS_E_OK) return retVal;
429  count+=chanHdPtr->numBytes;
430  if(count>numBytes)
431  return COMPRESS_E_BADSIZE;
432  }
433  //Fill Generic Header_t;
434 
435  fillGenericHeader(bdPtr,PACKET_PED_SUBBED_EVENT,count);
436  return COMPRESS_E_OK;
437 
438 }
439 
440 
441 
442 CompressErrorCode_t AnitaCompress::unpackOneWaveToPedSubbedEvent(PedSubbedEventBody_t *bdPtr,
443  unsigned char *input,
444  int numBytes)
445 {
446  int count=0;
447  int chanIndex;
448  CompressErrorCode_t retVal=COMPRESS_E_OK;
449  EncodedPedSubbedChannelPacketHeader_t *waveHdPtr;
450  EncodedSurfChannelHeader_t *chanHdPtr;
451 
452 
453  waveHdPtr = (EncodedPedSubbedChannelPacketHeader_t*) &input[count];
454  bdPtr->whichPeds=waveHdPtr->whichPeds;
455  bdPtr->eventNumber=waveHdPtr->eventNumber;
456  count+=sizeof(EncodedPedSubbedChannelPacketHeader_t);
457 
458  chanHdPtr = (EncodedSurfChannelHeader_t*)&input[count];
459  count+=sizeof(EncodedSurfChannelHeader_t);
460  chanIndex=chanHdPtr->rawHdr.chanId;
461  retVal=decodePSChannel(chanHdPtr,
462  &input[count],
463  &(bdPtr->channel[chanIndex]));
464  if(retVal!=COMPRESS_E_OK) return retVal;
465  count+=chanHdPtr->numBytes;
466  if(count>numBytes)
467  return COMPRESS_E_BADSIZE;
468 
469  //Fill Generic Header_t;
470 // fillGenericHeader(bdPtr,PACKET_PED_SUBBED_EVENT,count);
471  return COMPRESS_E_OK;
472 
473 }
474 
475 
476 CompressErrorCode_t
477 AnitaCompress::unpackToPedSubbedEventWithStats(PedSubbedEventBody_t *bdPtr,
478  unsigned char *input,
479  int numBytes,
480  EncodeControlStruct_t *cntlPtr,
481  int *sizeArray)
482 {
483 
484  int count=0;
485  int surf=0;
486  int chan=0;
487  CompressErrorCode_t retVal=COMPRESS_E_OK;
488  EncodedPedSubbedSurfPacketHeader_t *surfHdPtr;
489  EncodedSurfChannelHeader_t *chanHdPtr;
490 
491  GenericHeader_t *gHdr=(GenericHeader_t*) input;
492  if(gHdr->code==PACKET_ENC_PEDSUB_EVENT_WRAPPER && numBytes>(int)sizeof(EncodedEventWrapper_t)) {
493  return unpackToPedSubbedEventWithStats(bdPtr,&input[sizeof(EncodedEventWrapper_t)],numBytes-sizeof(EncodedEventWrapper_t),cntlPtr,sizeArray);
494  }
495 
496  // printf("unpackToPedSubbedEvent\n");
497  for(surf=0;surf<ACTIVE_SURFS;surf++) {
498  surfHdPtr = (EncodedPedSubbedSurfPacketHeader_t*) &input[count];
499  bdPtr->whichPeds=surfHdPtr->whichPeds;
500  bdPtr->eventNumber=surfHdPtr->eventNumber;
501  count+=sizeof(EncodedPedSubbedSurfPacketHeader_t);
502  for(chan=0;chan<CHANNELS_PER_SURF;chan++) {
503 
504  chanHdPtr = (EncodedSurfChannelHeader_t*)&input[count];
505  count+=sizeof(EncodedSurfChannelHeader_t);
506 // printf("surf %d, chan %d, encType %d\n",
507 // surf,chan,chanHdPtr->encType);
508 
509 
510  retVal=decodePSChannel(chanHdPtr,
511  &input[count],
512  &(bdPtr->channel[AnitaGeomTool::getChanIndex(surf,chan)]));
513  if(retVal!=COMPRESS_E_OK) return retVal;
514  count+=chanHdPtr->numBytes;
515  if(cntlPtr) {
516  cntlPtr->encTypes[surf][chan]=chanHdPtr->encType;;
517  }
518  if(sizeArray) {
519  sizeArray[AnitaGeomTool::getChanIndex(surf,chan)]=chanHdPtr->numBytes;
520  }
521  if(count>numBytes)
522  return COMPRESS_E_BADSIZE;
523  }
524  //Fill Generic Header_t;
525  }
526  fillGenericHeader(bdPtr,PACKET_PED_SUBBED_EVENT,count);
527  return COMPRESS_E_OK;
528 
529 }
530 
531 
532 void AnitaCompress::fillMinMaxMeanRMS(SurfChannelPedSubbed_t *chanPtr) {
533  int samp;
534  int wrappedHitbus=chanPtr->header.chipIdFlag&WRAPPED_HITBUS;
535  int firstSamp=0,lastSamp=MAX_NUMBER_SAMPLES;
536  int index=0;
537  float mean=0,meanSq=0,nsamps=0;
538  chanPtr->xMax=-4095;
539  chanPtr->xMin=4095;
540 
541  if(wrappedHitbus) {
542  firstSamp=chanPtr->header.firstHitbus+1;
543  lastSamp=chanPtr->header.lastHitbus;
544  }
545  else {
546  firstSamp=chanPtr->header.lastHitbus+1;
547  lastSamp=MAX_NUMBER_SAMPLES+chanPtr->header.firstHitbus;
548  }
549  for(samp=firstSamp;samp<lastSamp;samp++) {
550  index=samp;
551  if(index>=MAX_NUMBER_SAMPLES) index-=MAX_NUMBER_SAMPLES;
552  mean+=chanPtr->data[index];
553  meanSq+=(chanPtr->data[index]*chanPtr->data[index]);
554  nsamps++;
555 
556  if(chanPtr->data[index]>chanPtr->xMax)
557  chanPtr->xMax=chanPtr->data[index];
558  if(chanPtr->data[index]<chanPtr->xMin)
559  chanPtr->xMin=chanPtr->data[index];
560 
561  }
562  if(nsamps>0) {
563  mean/=nsamps;
564  meanSq/=nsamps;
565  chanPtr->mean=mean;
566  if(meanSq>mean*mean)
567  chanPtr->rms=sqrt(meanSq-mean*mean);
568  }
569 
570 
571 }
572 
573 
574 int AnitaCompress::encodeChannel(ChannelEncodingType_t encType, SurfChannelFull_t *chanPtr, unsigned char *buffer)
575 {
576 // printf("Event %lu, ChanId %d\n",theHead.eventNumber,
577 // chanPtr->header.chanId);
578 
579 
580 
581  EncodedSurfChannelHeader_t *chanHdPtr
582  =(EncodedSurfChannelHeader_t*) &buffer[0];
583  int count=0;
584  int encSize=0;
585  chanHdPtr->rawHdr=chanPtr->header;
586  chanHdPtr->encType=encType;
587  count+=sizeof(EncodedSurfChannelHeader_t);
588 
589  switch(encType) {
590  case ENCODE_NONE:
591  encSize=encodeWaveNone(&buffer[count],chanPtr);
592  break;
593  default:
594  chanHdPtr->encType=ENCODE_NONE;
595  encSize=encodeWaveNone(&buffer[count],chanPtr);
596  break;
597  }
598  chanHdPtr->numBytes=encSize;
599  chanHdPtr->crc=simpleCrcShort((unsigned short*)&buffer[count],
600  encSize/2);
601  return (count+encSize);
602 }
603 
604 
605 CompressErrorCode_t AnitaCompress::decodeChannel(EncodedSurfChannelHeader_t *encChanHdPtr,unsigned char *input, SurfChannelFull_t *chanPtr)
606 {
607  CompressErrorCode_t retVal;
608  int numBytes=encChanHdPtr->numBytes;
609  int newCrc=simpleCrcShort((unsigned short*)input,numBytes/2);
610  if(encChanHdPtr->crc!=newCrc) return COMPRESS_E_BAD_CRC;
611 
612 
613 // printf("decodePSChannel encType==%d\n",encChanHdPtr->encType);
614  chanPtr->header=encChanHdPtr->rawHdr;
615  switch(encChanHdPtr->encType) {
616  case ENCODE_NONE:
617  retVal=decodeWaveNone(input,numBytes,chanPtr);
618  break;
619  default:
620  //Try ENCODE_NONE
621  retVal=decodeWaveNone(input,numBytes,chanPtr);
622  retVal=COMPRESS_E_BAD_CODE;
623  break;
624  }
625  return retVal;
626 }
627 
628 
629 int AnitaCompress::encodeWaveNone(unsigned char *buffer,SurfChannelFull_t *chanPtr) {
630  int encSize=MAX_NUMBER_SAMPLES*sizeof(unsigned short);
631  memcpy(buffer,chanPtr->data,encSize);
632  return encSize;
633 }
634 
635 CompressErrorCode_t AnitaCompress::decodeWaveNone(unsigned char *input,int numBytes,SurfChannelFull_t *chanPtr){
636  int encSize=MAX_NUMBER_SAMPLES*sizeof(unsigned short);
637  //Check that numBytes is correct
638  if(numBytes!=encSize) return COMPRESS_E_BADSIZE;
639  memcpy(chanPtr->data,input,encSize);
640  return COMPRESS_E_OK;
641 }
642 
643 
644 int AnitaCompress::encodePSChannel(ChannelEncodingType_t encType, SurfChannelPedSubbed_t *chanPtr, unsigned char *buffer)
645 {
646 // printf("Event %lu, ChanId %d\n",theHead.eventNumber,
647 // chanPtr->header.chanId);
648 
649  EncodedSurfChannelHeader_t *chanHdPtr
650  =(EncodedSurfChannelHeader_t*) &buffer[0];
651  int count=0;
652  int encSize=0;
653  chanHdPtr->rawHdr=chanPtr->header;
654  chanHdPtr->encType=encType;
655  count+=sizeof(EncodedSurfChannelHeader_t);
656 
657  switch(encType) {
658  case ENCODE_NONE:
659  encSize=encodePSWaveNone(&buffer[count],chanPtr);
660  break;
661  case ENCODE_LOSSLESS_12BIT:
662  encSize=encodePSWave12bitBinary(&buffer[count],chanPtr);
663  break;
664  case ENCODE_LOSSLESS_BINARY:
665  encSize=encodePSWaveLosslessBinary(&buffer[count],chanPtr,
666  &(chanHdPtr->encType));
667  break;
668  case ENCODE_LOSSLESS_FIBONACCI:
669  encSize=encodePSWaveLosslessFibonacci(&buffer[count],chanPtr);
670  break;
671  case ENCODE_LOSSLESS_BINFIB_COMBO:
672  encSize=encodePSWaveLosslessBinFibCombo(&buffer[count],chanPtr,
673  &(chanHdPtr->encType));
674  break;
675  case ENCODE_LOSSY_MULAW:
676  case ENCODE_LOSSY_MULAW_8BIT:
677  encSize=encodePSWaveLossyMulawOptimally(&buffer[count],chanPtr,8,
678  &(chanHdPtr->encType));
679  break;
680  case ENCODE_LOSSY_MULAW_7BIT:
681  encSize=encodePSWaveLossyMulawOptimally(&buffer[count],chanPtr,7,
682  &(chanHdPtr->encType));
683  break;
684  case ENCODE_LOSSY_MULAW_6BIT:
685  encSize=encodePSWaveLossyMulawOptimally(&buffer[count],chanPtr,6,
686  &(chanHdPtr->encType));
687  break;
688  case ENCODE_LOSSY_MULAW_5BIT:
689  encSize=encodePSWaveLossyMulawOptimally(&buffer[count],chanPtr,5,
690  &(chanHdPtr->encType));
691  break;
692  case ENCODE_LOSSY_MULAW_4BIT:
693  encSize=encodePSWaveLossyMulawOptimally(&buffer[count],chanPtr,4,
694  &(chanHdPtr->encType));
695  break;
696  case ENCODE_LOSSY_MULAW_3BIT:
697  encSize=encodePSWaveLossyMulawOptimally(&buffer[count],chanPtr,3,
698  &(chanHdPtr->encType));
699  break;
700  default:
701  chanHdPtr->encType=ENCODE_NONE;
702  encSize=encodePSWaveNone(&buffer[count],chanPtr);
703  break;
704  }
705  chanHdPtr->numBytes=encSize;
706  chanHdPtr->crc=simpleCrcShort((unsigned short*)&buffer[count],
707  encSize/2);
708  return (count+encSize);
709 }
710 
711 CompressErrorCode_t AnitaCompress::decodePSChannel(EncodedSurfChannelHeader_t *encChanHdPtr,unsigned char *input, SurfChannelPedSubbed_t *chanPtr)
712 {
713  CompressErrorCode_t retVal;
714  int numBytes=encChanHdPtr->numBytes;
715  int newCrc=simpleCrcShort((unsigned short*)input,numBytes/2);
716  if(encChanHdPtr->crc!=newCrc) return COMPRESS_E_BAD_CRC;
717 
718 
719 // printf("decodePSChannel encType==%d\n",encChanHdPtr->encType);
720  chanPtr->header=encChanHdPtr->rawHdr;
721  switch(encChanHdPtr->encType) {
722  case ENCODE_NONE:
723  retVal=decodePSWaveNone(input,numBytes,chanPtr);
724  break;
725  case ENCODE_LOSSLESS_12BIT:
726  retVal=decodePSWave12bitBinary(input,numBytes,chanPtr);
727  break;
728  case ENCODE_LOSSLESS_11BIT:
729  case ENCODE_LOSSLESS_10BIT:
730  case ENCODE_LOSSLESS_9BIT:
731  case ENCODE_LOSSLESS_8BIT:
732  case ENCODE_LOSSLESS_7BIT:
733  case ENCODE_LOSSLESS_6BIT:
734  case ENCODE_LOSSLESS_5BIT:
735  case ENCODE_LOSSLESS_4BIT:
736  case ENCODE_LOSSLESS_3BIT:
737  case ENCODE_LOSSLESS_2BIT:
738  case ENCODE_LOSSLESS_1BIT:
739  retVal=decodePSWaveLosslessBinary(input,numBytes,chanPtr,encChanHdPtr->encType);
740  break;
741  case ENCODE_LOSSLESS_FIBONACCI:
742  retVal=decodePSWaveLosslessFibonacci(input,numBytes,chanPtr);
743  break;
744  case ENCODE_LOSSLESS_BINFIB_COMBO:
745  case ENCODE_LOSSLESS_BINFIB_10BIT:
746  case ENCODE_LOSSLESS_BINFIB_9BIT:
747  case ENCODE_LOSSLESS_BINFIB_8BIT:
748  case ENCODE_LOSSLESS_BINFIB_7BIT:
749  case ENCODE_LOSSLESS_BINFIB_6BIT:
750  case ENCODE_LOSSLESS_BINFIB_5BIT:
751  case ENCODE_LOSSLESS_BINFIB_4BIT:
752  case ENCODE_LOSSLESS_BINFIB_3BIT:
753  case ENCODE_LOSSLESS_BINFIB_2BIT:
754  case ENCODE_LOSSLESS_BINFIB_1BIT:
755  retVal=decodePSWaveLosslessBinFibCombo(input,numBytes,chanPtr,
756  encChanHdPtr->encType);
757  break;
758  case ENCODE_LOSSY_MULAW_11_8:
759  case ENCODE_LOSSY_MULAW_11_7:
760  case ENCODE_LOSSY_MULAW_11_6:
761  case ENCODE_LOSSY_MULAW_11_5:
762  case ENCODE_LOSSY_MULAW_11_4:
763  case ENCODE_LOSSY_MULAW_11_3:
764  case ENCODE_LOSSY_MULAW_10_8:
765  case ENCODE_LOSSY_MULAW_10_7:
766  case ENCODE_LOSSY_MULAW_10_6:
767  case ENCODE_LOSSY_MULAW_10_5:
768  case ENCODE_LOSSY_MULAW_10_4:
769  case ENCODE_LOSSY_MULAW_10_3:
770  case ENCODE_LOSSY_MULAW_9_7:
771  case ENCODE_LOSSY_MULAW_9_6:
772  case ENCODE_LOSSY_MULAW_9_5:
773  case ENCODE_LOSSY_MULAW_9_4:
774  case ENCODE_LOSSY_MULAW_9_3:
775  case ENCODE_LOSSY_MULAW_8_6:
776  case ENCODE_LOSSY_MULAW_8_5:
777  case ENCODE_LOSSY_MULAW_8_4:
778  case ENCODE_LOSSY_MULAW_8_3:
779  case ENCODE_LOSSY_MULAW_7_5:
780  case ENCODE_LOSSY_MULAW_7_4:
781  case ENCODE_LOSSY_MULAW_7_3:
782  case ENCODE_LOSSY_MULAW_6_4:
783  case ENCODE_LOSSY_MULAW_6_3:
784  retVal=decodePSWaveLossyMuLaw(input,numBytes,chanPtr,
785  encChanHdPtr->encType);
786  break;
787 
788  default:
789  //Try ENCODE_NONE
790  retVal=decodePSWaveNone(input,numBytes,chanPtr);
791  retVal=COMPRESS_E_BAD_CODE;
792  break;
793  }
794  if(retVal==COMPRESS_E_OK) fillMinMaxMeanRMS(chanPtr);
795  return retVal;
796 }
797 
798 
799 int AnitaCompress::encodePSWaveNone(unsigned char *buffer,SurfChannelPedSubbed_t *chanPtr) {
800 // int samp;
801  int encSize=MAX_NUMBER_SAMPLES*sizeof(short);
802  memcpy(buffer,chanPtr->data,encSize);
803 // for(samp=0;samp<MAX_NUMBER_SAMPLES;samp+=4) {
804 // printf("samp %d: value %d\n",samp,chanPtr->data[samp]);
805 // }
806  return encSize;
807 }
808 
809 CompressErrorCode_t AnitaCompress::decodePSWaveNone(unsigned char *input,int numBytes,SurfChannelPedSubbed_t *chanPtr){
810 // int samp;
811  int encSize=MAX_NUMBER_SAMPLES*sizeof(unsigned short);
812  //Check that numBytes is correct
813  if(numBytes!=encSize) return COMPRESS_E_BADSIZE;
814 // printf("Here\n");
815  memcpy(chanPtr->data,input,encSize);
816 // for(samp=0;samp<MAX_NUMBER_SAMPLES;samp++) {
817 // printf("samp %d: value %d\n",samp,chanPtr->data[samp]);
818 // }
819  return COMPRESS_E_OK;
820 }
821 
822 #define OFFSET_VALUE 2048
823 
824 int AnitaCompress::encodePSWave12bitBinary(unsigned char *buffer,SurfChannelPedSubbed_t *chanPtr) {
825  int encSize=3*(MAX_NUMBER_SAMPLES/4)*sizeof(unsigned short);
826  int samp=0,charNum=0,valNum=0;
827  unsigned short value[4];
828  for(samp=0;samp<MAX_NUMBER_SAMPLES;samp+=4) {
829  charNum=(samp*3)/2;
830  for(valNum=0;valNum<4;valNum++)
831  value[valNum]=chanPtr->data[samp+valNum]+OFFSET_VALUE;
832 
833  pack12bit(value,&buffer[charNum]);
834  }
835  return encSize;
836 }
837 
838 CompressErrorCode_t AnitaCompress::decodePSWave12bitBinary(unsigned char *input,int numBytes,SurfChannelPedSubbed_t *chanPtr){
839  int encSize=3*(MAX_NUMBER_SAMPLES/4)*sizeof(unsigned short);
840  if(numBytes!=encSize) return COMPRESS_E_BADSIZE;
841  unsigned short value[4];
842  int samp=0,charNum=0,valNum=0;
843  for(charNum=0;charNum<6*(MAX_NUMBER_SAMPLES/4);charNum+=6) {
844  samp=2*(charNum/3);
845  unpack12bit(value,&input[charNum]);
846  for(valNum=0;valNum<4;valNum++)
847  chanPtr->data[samp+valNum]=((short)value[valNum])-OFFSET_VALUE;
848  }
849  return COMPRESS_E_OK;
850 }
851 
852 int AnitaCompress::encodePSWaveLosslessBinary(unsigned char *buffer,SurfChannelPedSubbed_t *chanPtr, ChannelEncodingType_t *encTypePtr) {
853  //Remember this function works an array of pedestal subtracted shorts
854  //Which is what SurfChannelPedSubbed_t contains
855  int wordNum=0;
856  int numBitsLeft;
857  int bitMask;
858  int bitNum;
859  unsigned char *currentChar=buffer;
860  int currentBit=0;
861  unsigned short newVal=0;
862  int mean=0;
863  short xMax=chanPtr->xMax; //Filled by pedestalLib
864  short xMin=chanPtr->xMin; //Filled by pedestalLib
865  short *input = chanPtr->data;
866 
867  //Find min and max
868 // for(wordNum=0;wordNum<numInputs;wordNum++) {
869 // mean+=input[wordNum];
870 // if(input[wordNum]>xMax) xMax=input[wordNum];
871 // if(input[wordNum]<xMin) xMin=input[wordNum];
872 // }
873 // mean/=numInputs;
874  //Don't actual use min we just use the median value
875 
876  int rangeTotal=xMax-xMin;
877  float logValue=(float)(log(rangeTotal+1)/log(2));
878  int bitSize=(int)logValue;
879  if((logValue-bitSize)>0) bitSize++;
880 
881  *encTypePtr=getBinaryEncType(bitSize);
882 
883  mean=xMin+rangeTotal/2;
884 // printf("mean %d\txMin %d\txMax %d\tbitSize %d\n",mean,xMin,xMax,bitSize);
885 // if(mean<-20 || mean>20)
886 // printf("mean %d, xMin %d xMax %d\n",mean,xMin,xMax);
887  short *meanPtr=(short*)currentChar;
888  (*meanPtr)=mean;
889  currentChar+=2;
890 /* *currentChar = (unsigned char) bitSize; */
891 /* currentChar++; */
892 
893  for(wordNum=0;wordNum<MAX_NUMBER_SAMPLES;wordNum++) {
894  newVal=bifurcate(input[wordNum]-mean);
895  numBitsLeft=bitSize;
896 // printf("input: %d (%d)\t newVal: %#x\t: bitsize %d\n",input[wordNum],
897 // input[wordNum]-mean,newVal,bitSize);
898 // printf("cc %u cbit %d:\n",(int)(currentChar-buffer),currentBit);
899  while(numBitsLeft) {
900 // if(wordNum<5) cout << wordNum << "\t" << numBitsLeft << endl;
901  if(numBitsLeft>(8-currentBit)) {
902  bitMask=0;
903  for(bitNum=0;bitNum<(8-currentBit);bitNum++)
904  bitMask|=(1<<bitNum);
905  (*currentChar)|= (newVal&bitMask)<<currentBit;
906  newVal=(newVal>>(8-currentBit));
907  numBitsLeft-=(8-currentBit);
908  currentChar++;
909  currentBit=0;
910  }
911  else {
912  bitMask=0;
913  for(bitNum=0;bitNum<numBitsLeft;bitNum++)
914  bitMask|=(1<<bitNum);
915  (*currentChar)|= (newVal&bitMask)<<currentBit;
916  currentBit+=numBitsLeft;
917  if(currentBit==8) {
918  currentBit=0;
919  currentChar++;
920  }
921  numBitsLeft=0;
922  }
923  }
924  }
925 // for(int i=0;i<int(currentChar-buffer);i++) {
926 // cout << i << "\t" << (int)buffer[i] << endl;
927 // }
928  if(currentBit) currentChar++;
929  return (int)(currentChar-buffer);
930 }
931 
932 CompressErrorCode_t AnitaCompress::decodePSWaveLosslessBinary(unsigned char *input,int numBytes,SurfChannelPedSubbed_t *chanPtr, ChannelEncodingType_t encType)
933 {
934  int sampNum=0;
935  short *meanPtr=(short*)input;
936  short mean=(short)(*meanPtr);
937 // unsigned char flag = input[1];
938  int bitSize=getBinaryBitSize(encType);
939  int bitNum;
940 // if(mean<-1100 || mean>100)
941 // printf("binary mean %d %#x\n",mean,mean);
942 // printf("mean %d\tbitSize %d\n",mean,bitSize);
943 
944  unsigned char *currentChar=&input[2];
945  int currentBit=0;
946  unsigned short tempNum;
947  while(sampNum<MAX_NUMBER_SAMPLES) {
948  int fred = *( (int*) currentChar);
949 // printf("cc %u cbit %d: \t %#x\n",(int)(currentChar-input),currentBit,fred);
950 // bin_prnt_int(fred);
951  tempNum=0;
952  for(bitNum=currentBit;bitNum<currentBit+bitSize;bitNum++) {
953  tempNum|= (((fred>>bitNum)&0x1)<<(bitNum-currentBit));
954 // bin_prnt_short(tempNum);
955 // cout << (((fred>>bitNum)&0x1)<<(bitNum-currentBit));
956  }
957 // cout << endl;
958 // bin_prnt_short(tempNum);
959 
960 // cout << sampNum << "\t" << tempNum << endl;
961 
962  chanPtr->data[sampNum]=mean+unbifurcate(tempNum);
963 // printf("samp %d:\t %#x \t %d\n",sampNum,tempNum,chanPtr->data[sampNum]);
964 
965  sampNum++;
966  currentBit+=bitSize;
967  while(currentBit>=8) {
968  currentBit-=8;
969  currentChar++;
970  }
971  if(((int)(currentChar-input))>numBytes) return COMPRESS_E_BADSIZE;
972  }
973  return COMPRESS_E_OK;
974 
975 }
976 
977 int AnitaCompress::encodePSWaveLosslessFibonacci(unsigned char *buffer,SurfChannelPedSubbed_t *chanPtr) {
978  //Remember this function works an array of pedestal subtracted shorts
979  //Which is what SurfChannelPedSubbed_t contains
980  int wordNum=0;
981  int numBitsLeft;
982  int bitMask;
983  int bitNum;
984  unsigned char *currentChar=buffer;
985  int currentBit=0;
986  unsigned short newVal=0;
987  int mean=(int)chanPtr->mean;
988  if(mean>127) mean=127;
989  if(mean<-127) mean=-127;
990 // short xMax=chanPtr->xMax; //Filled by pedestalLib
991 // short xMin=chanPtr->xMin; //Filled by pedestalLib
992  short *input = chanPtr->data;
993 
994 // int rangeTotal=xMax-xMin;
995 // printf("mean %d\txMin %d\txMax %d\n",mean,xMin,xMax);
996 
997  char *meanPtr=(char*)currentChar;
998  (*meanPtr)=(char)(mean);
999  currentChar++;
1000 
1001 
1002  for(wordNum=0;wordNum<MAX_NUMBER_SAMPLES;wordNum++) {
1003  newVal=bifurcate(input[wordNum]-mean);
1004  newVal=encodeFibonacci(newVal,&numBitsLeft);
1005  while(numBitsLeft) {
1006 // if(wordNum<5) cout << wordNum << "\t" << numBitsLeft << endl;
1007  if(numBitsLeft>(8-currentBit)) {
1008  bitMask=0;
1009  for(bitNum=0;bitNum<(8-currentBit);bitNum++)
1010  bitMask|=(1<<bitNum);
1011  (*currentChar)|= (newVal&bitMask)<<currentBit;
1012  newVal=(newVal>>(8-currentBit));
1013  numBitsLeft-=(8-currentBit);
1014  currentChar++;
1015  currentBit=0;
1016  }
1017  else {
1018  bitMask=0;
1019  for(bitNum=0;bitNum<numBitsLeft;bitNum++)
1020  bitMask|=(1<<bitNum);
1021  (*currentChar)|= (newVal&bitMask)<<currentBit;
1022  currentBit+=numBitsLeft;
1023  if(currentBit==8) {
1024  currentBit=0;
1025  currentChar++;
1026  }
1027  numBitsLeft=0;
1028  }
1029  }
1030  }
1031 // for(int i=0;i<int(currentChar-buffer);i++) {
1032 // cout << i << "\t" << (int)buffer[i] << endl;
1033 // }
1034  if(currentBit) currentChar++;
1035  return (int)(currentChar-buffer);
1036 }
1037 
1038 CompressErrorCode_t AnitaCompress::decodePSWaveLosslessFibonacci(unsigned char *input,int numBytes,SurfChannelPedSubbed_t *chanPtr)
1039 {
1040  int sampNum=0;
1041  char *meanPtr=(char*)input;
1042  short mean=(short)(*meanPtr);
1043 
1044  unsigned char *currentChar=&input[1];
1045  int currentBit=0;
1046  unsigned short fibNum;
1047  unsigned short unfibNum;
1048  int tempBit,bitNum;
1049  while(sampNum<MAX_NUMBER_SAMPLES) {
1050  tempBit=currentBit;
1051  int fred = *( (int*) currentChar);
1052  if(sampNum==259)
1053  printf("samp %d, fred %#x\n",sampNum,fred);
1054  while(tempBit<32) {
1055  if( ((fred>>tempBit)&0x1) && ((fred>>(tempBit+1))&0x1)) {
1056  //Got two ones;
1057  fibNum=0;
1058  for(bitNum=currentBit;bitNum<=tempBit+1;bitNum++) {
1059  fibNum|= (((fred>>bitNum)&0x1)<<(bitNum-currentBit));
1060  }
1061  unfibNum=unfibonacci(fibNum);
1062  chanPtr->data[sampNum]=mean+unbifurcate(unfibNum);
1063 
1064 
1065 
1066  tempBit+=2;
1067  currentChar+=(tempBit/8);
1068  currentBit=(tempBit%8);
1069 // cout << tempBit << "\t" << currentChar << "\t" << currentBit << endl;
1070  break;
1071  }
1072 // cout << ((fred>>tempBit)&0x1) << " ";
1073  tempBit++;
1074  }
1075  sampNum++;
1076  if(((int)(currentChar-input))>numBytes) return COMPRESS_E_BADSIZE;
1077  }
1078 
1079  return COMPRESS_E_OK;
1080 
1081 }
1082 
1083 int AnitaCompress::encodePSWaveLosslessBinFibCombo(unsigned char *buffer,SurfChannelPedSubbed_t *chanPtr, ChannelEncodingType_t *encTypePtr) {
1084  //Remember this function works an array of pedestal subtracted shorts
1085  //Which is what SurfChannelPedSubbed_t contains
1086  float numSigma=3; //Will hard code for now
1087  int wordNum=0;
1088  int numBitsLeft;
1089  int bitMask;
1090  int bitNum;
1091  unsigned short fibVal=0;
1092  int asFib=0;
1093  int fibBits;
1094  unsigned char *currentChar=buffer;
1095  int currentBit=0;
1096  unsigned char *overflowChar;
1097  int overflowBit=0;
1098  unsigned short newVal=0;
1099  int mean=(int)chanPtr->mean;
1100  if(mean>127) mean=127;
1101  if(mean<-127) mean=-127;
1102  float sigma=chanPtr->rms;
1103  short xMax=chanPtr->xMax; //Filled by pedestalLib
1104  short xMin=chanPtr->xMin; //Filled by pedestalLib
1105  short *input = chanPtr->data;
1106  int rangeTotal=(int)(numSigma*sigma);
1107  float logValue=(float)(log(rangeTotal+1)/log(2));
1108  int bitSize=(int)logValue;
1109  if((logValue-bitSize)>0) bitSize++;
1110  if(bitSize==1) bitSize++;
1111 
1112 
1113  //Reset xMin and xMax to be the binary/fibonacci cut off point
1114  xMin=mean-(1<<(bitSize-1));
1115  xMax=mean+(1<<(bitSize-1));
1116  xMax-=1;
1117 // printf("mean %d\txMin %d\txMax %d\tbitSize %d\n",mean,xMin,xMax,bitSize);
1118 
1119  char *meanPtr=(char*)currentChar;
1120  (*meanPtr)=(char)(mean);
1121  currentChar++;
1122  *encTypePtr=getBinFibEncType(bitSize);
1123 // *currentChar = (unsigned char) bitSize;
1124  // currentChar++;
1125 
1126 
1127  overflowChar=currentChar+(MAX_NUMBER_SAMPLES*bitSize)/8;
1128  overflowBit=(MAX_NUMBER_SAMPLES*bitSize)%8;
1129 
1130  unsigned short flagVal=(1<<bitSize)-1;
1131  int countOverflows=0;
1132 
1133  for(wordNum=0;wordNum<MAX_NUMBER_SAMPLES;wordNum++) {
1134  //Check if value is in the range xMin to xMax
1135  if(input[wordNum]>xMin && input[wordNum]<xMax) {
1136  newVal=bifurcate(input[wordNum]-mean);
1137  }
1138  else {
1139  //If not encode number as fibonacci in the overflow
1140  countOverflows++;
1141  newVal=flagVal;
1142  if(input[wordNum]>=xMax) {
1143  fibVal=((input[wordNum]-xMax)<<1)+1; //Odd numbers
1144  }
1145  else {
1146  fibVal=((xMin-input[wordNum])<<1)+2; //Even numbers
1147  }
1148  asFib=encodeFibonacci(fibVal,&fibBits);
1149 
1150 
1151 // cout << "Fib:\t" << fibVal << "\t" << asFib << "\t" << fibBits << endl;
1152 // bin_prnt_int(asFib);
1153 // cout <<
1154 
1155  numBitsLeft=fibBits;
1156  while(numBitsLeft) {
1157 // if(wordNum<3) cout << wordNum << "\t" << numBitsLeft << endl;
1158  if(numBitsLeft>(8-overflowBit)) {
1159  bitMask=0;
1160  for(bitNum=0;bitNum<(8-overflowBit);bitNum++)
1161  bitMask|=(1<<bitNum);
1162  (*overflowChar)|= (asFib&bitMask)<<overflowBit;
1163  asFib=(asFib>>(8-overflowBit));
1164  numBitsLeft-=(8-overflowBit);
1165  overflowChar++;
1166  overflowBit=0;
1167  }
1168  else {
1169  bitMask=0;
1170  for(bitNum=0;bitNum<numBitsLeft;bitNum++)
1171  bitMask|=(1<<bitNum);
1172  (*overflowChar)|= (asFib&bitMask)<<overflowBit;
1173  overflowBit+=numBitsLeft;
1174  if(overflowBit==8) {
1175  overflowBit=0;
1176  overflowChar++;
1177  }
1178  numBitsLeft=0;
1179  }
1180  }
1181 
1182  }
1183 // cout << wordNum << "\t" << newVal << endl;
1184  numBitsLeft=bitSize;
1185  while(numBitsLeft) {
1186 // if(wordNum<3) cout << wordNum << "\t" << numBitsLeft << endl;
1187  if(numBitsLeft>(8-currentBit)) {
1188  bitMask=0;
1189  for(bitNum=0;bitNum<(8-currentBit);bitNum++)
1190  bitMask|=(1<<bitNum);
1191  (*currentChar)|= (newVal&bitMask)<<currentBit;
1192  newVal=(newVal>>(8-currentBit));
1193  numBitsLeft-=(8-currentBit);
1194  currentChar++;
1195  currentBit=0;
1196  }
1197  else {
1198  bitMask=0;
1199  for(bitNum=0;bitNum<numBitsLeft;bitNum++)
1200  bitMask|=(1<<bitNum);
1201  (*currentChar)|= (newVal&bitMask)<<currentBit;
1202  currentBit+=numBitsLeft;
1203  if(currentBit==8) {
1204  currentBit=0;
1205  currentChar++;
1206  }
1207  numBitsLeft=0;
1208  }
1209  }
1210  }
1211 // cout << "countOverflows: " << countOverflows << endl;
1212  if(overflowBit) overflowChar++;
1213 // cout << int(overflowChar-buffer) << "\t" << overflowBit << endl;
1214  return (int)(overflowChar-buffer);
1215 
1216 }
1217 
1218 CompressErrorCode_t AnitaCompress::decodePSWaveLosslessBinFibCombo(unsigned char *input,int numBytes,SurfChannelPedSubbed_t *chanPtr, ChannelEncodingType_t encType) {
1219 
1220  char *meanPtr=(char*)input;
1221  short mean=(*meanPtr);
1222 
1223 // if(mean<-1100 || mean>100)
1224 // printf("binfib mean %d %#x\n",mean,mean);
1225 // unsigned char flag = input[1];
1226  int bitSize=getBinFibBitSize(encType);
1227  short overFlowVals[256];
1228  short xMin=mean-(1<<(bitSize-1));
1229  short xMax=mean+(1<<(bitSize-1));
1230  xMax-=1;
1231  unsigned short flagVal=(1<<bitSize)-1;
1232 
1233  unsigned char *currentChar=&input[1];
1234  int currentBit=0;
1235  unsigned char *overflowChar;
1236  int overflowBit=0;
1237  overflowChar=currentChar+(MAX_NUMBER_SAMPLES*bitSize)/8;
1238  overflowBit=(MAX_NUMBER_SAMPLES*bitSize)%8;
1239  int numOverflows=numBytes-(int)(overflowChar-input);
1240 // cout << "numOverflows: " << numOverflows << endl;
1241 
1242  int overflowNum=0;
1243  unsigned short tempNum;
1244  int fibNum=0;
1245  int sampNum=0;
1246  int tempBit,bitNum;
1247 
1248  //Loop through overflow
1249  while(overflowNum<260) {
1250  tempBit=overflowBit;
1251  int fred = *( (int*) overflowChar);
1252 // bin_prnt_int(fred);
1253  while(tempBit<32) {
1254  // bin_prnt_int((fred>>tempBit));
1255  if( ((fred>>tempBit)&0x1) && ((fred>>(tempBit+1))&0x1)) {
1256  //Got two ones;
1257  fibNum=0;
1258  for(bitNum=overflowBit;bitNum<=tempBit+1;bitNum++) {
1259  fibNum|= (((fred>>bitNum)&0x1)<<(bitNum-overflowBit));
1260  }
1261 // bin_prnt_int(fibNum);
1262 // cout << fibNum << endl;
1263 // tempNum=decodeFibonacci(fibNum,tempBit+2-overflowBit);
1264  tempNum=unfibonacci(fibNum);
1265 // cout << fibNum << "\t" << tempBit+2-overflowBit
1266 // <<"\t" << tempNum << endl;
1267  if(tempNum&0x1) {
1268  //Positive
1269 // tempNum-=1;
1270  overFlowVals[overflowNum]=xMax+((tempNum-1)>>1);
1271  }
1272  else {
1273  //Negative
1274  overFlowVals[overflowNum]=xMin-((tempNum-2)>>1);
1275  }
1276 // if(overflowNum<2) cout << buffer[overflowNum] << "\t" << tempNum << endl;
1277 // cout << overflowNum << "\t" << overFlowVals[overflowNum] << endl;
1278  tempBit+=2;
1279  overflowChar+=(tempBit/8);
1280  overflowBit=(tempBit%8);
1281 // cout << tempBit << "\t" << overflowChar << "\t" << overflowBit << endl;
1282 
1283  break;
1284  }
1285 // cout << ((fred>>tempBit)&0x1) << " ";
1286  tempBit++;
1287  }
1288  if(tempBit==32) break;
1289 // cout << endl;
1290 // cout << overflowNum << "\t" << buffer[overflowNum] << endl;
1291  overflowNum++;
1292 // if(overflowNum>4) break;
1293  }
1294  numOverflows=overflowNum;
1295 // cout << "numOverflows: " << numOverflows << endl;
1296  overflowNum=0;
1297  //Loop through binary
1298 
1299  while(sampNum<MAX_NUMBER_SAMPLES) {
1300  int fred = *( (int*) currentChar);
1301 // bin_prnt_int(fred);
1302  tempNum=0;
1303  for(bitNum=currentBit;bitNum<currentBit+bitSize;bitNum++) {
1304  tempNum|= (((fred>>bitNum)&0x1)<<(bitNum-currentBit));
1305 // bin_prnt_short(tempNum);
1306 // cout << (((fred>>bitNum)&0x1)<<(bitNum-currentBit));
1307  }
1308 // cout << endl;
1309 // bin_prnt_short(tempNum);
1310 // cout << sampNum << "\t" << tempNum << endl;
1311  if(tempNum==flagVal) {
1312  chanPtr->data[sampNum]=overFlowVals[overflowNum];
1313  overflowNum++;
1314  }
1315  else {
1316  chanPtr->data[sampNum]=mean+unbifurcate(tempNum);
1317  }
1318  sampNum++;
1319  currentBit+=bitSize;
1320  while(currentBit>=8) {
1321  currentBit-=8;
1322  currentChar++;
1323  }
1324  }
1325  return COMPRESS_E_OK;
1326 }
1327 
1328 
1329 
1330 int AnitaCompress::encodePSWaveLossyMulawOptimally(unsigned char *buffer,SurfChannelPedSubbed_t *chanPtr,int mulawBits, ChannelEncodingType_t *encTypePtr) {
1331  short xMax=chanPtr->xMax; //Filled by pedestalLib
1332  short xMin=chanPtr->xMin; //Filled by pedestalLib
1333  short rangeTotal=xMax-xMin;
1334  int numBits=1;
1335  while(rangeTotal>(1<<numBits)) numBits++;
1336  int inputBits=numBits+1;
1337  if(inputBits<=mulawBits) return encodePSWaveLosslessBinary(buffer,chanPtr,encTypePtr);
1338  if(inputBits<6) inputBits=6;
1339  if(inputBits<mulawBits+2) inputBits=mulawBits+2;
1340  *encTypePtr=getEncodingTypeFromInputAndMuLawBits(inputBits,mulawBits);
1341  return encodePSWaveLossyMuLaw(buffer,chanPtr,*encTypePtr);
1342 }
1343 
1344 int AnitaCompress::encodePSWaveLossyMuLaw(unsigned char *buffer,SurfChannelPedSubbed_t *chanPtr,ChannelEncodingType_t encType)
1345 {
1346  //Remember this function works an array of pedestal subtracted shorts
1347  //Which is what SurfChannelPedSubbed_t contains
1348  int wordNum=0;
1349  int numBitsLeft;
1350  int bitMask;
1351  int bitNum;
1352  unsigned char *currentChar=buffer;
1353  int currentBit=0;
1354  unsigned char newVal=0;
1355  int inputBits=0,mulawBits=0;
1356  getInputAndMuLawBits(encType,&inputBits,&mulawBits);
1357  short maxVal=(1<<(inputBits-1));
1358  short minVal=-1*maxVal;
1359 
1360  short xMax=chanPtr->xMax; //Filled by pedestalLib
1361  short xMin=chanPtr->xMin; //Filled by pedestalLib
1362  short rangeTotal=xMax-xMin;
1363  short *input = chanPtr->data;
1364  int mean=xMin+(int)rangeTotal/2;
1365  short testVal;
1366  int bitSize=mulawBits;
1367 
1368 // printf("mean %d\txMin %d\txMax %d\tbitSize %d\n",mean,xMin,xMax,bitSize);
1369 // printf("minVal %d, maxVal %d\n",minVal,maxVal);
1370  char *meanPtr=(char*)currentChar;
1371  (*meanPtr)=(char)(mean);
1372  currentChar++;
1373 
1374  for(wordNum=0;wordNum<MAX_NUMBER_SAMPLES;wordNum++) {
1375  testVal=input[wordNum]-mean;
1376  if(testVal>maxVal) testVal=maxVal;
1377  if(testVal<minVal) testVal=minVal;
1378  newVal=convertToMuLawUC(testVal,inputBits,mulawBits);
1379 // printf("input %d, testVal %d, newVal %d\n",input[wordNum],testVal,newVal);
1380  numBitsLeft=bitSize;
1381  while(numBitsLeft) {
1382  if(numBitsLeft>(8-currentBit)) {
1383  bitMask=0;
1384  for(bitNum=0;bitNum<(8-currentBit);bitNum++)
1385  bitMask|=(1<<bitNum);
1386  (*currentChar)|= (newVal&bitMask)<<currentBit;
1387  newVal=(newVal>>(8-currentBit));
1388  numBitsLeft-=(8-currentBit);
1389  currentChar++;
1390  currentBit=0;
1391  }
1392  else {
1393  bitMask=0;
1394  for(bitNum=0;bitNum<numBitsLeft;bitNum++)
1395  bitMask|=(1<<bitNum);
1396  (*currentChar)|= (newVal&bitMask)<<currentBit;
1397  currentBit+=numBitsLeft;
1398  if(currentBit==8) {
1399  currentBit=0;
1400  currentChar++;
1401  }
1402  numBitsLeft=0;
1403  }
1404  }
1405  }
1406  // for(int i=0;i<int(currentChar-buffer);i++) {
1407  // cout << i << "\t" << (int)buffer[i] << endl;
1408  // }
1409  if(currentBit) currentChar++;
1410  return (int)(currentChar-buffer);
1411 
1412 
1413 }
1414 
1415 
1416 
1417 CompressErrorCode_t AnitaCompress::decodePSWaveLossyMuLaw(unsigned char *input,int numBytes,SurfChannelPedSubbed_t *chanPtr,ChannelEncodingType_t encType)
1418 {
1419  int sampNum=0;
1420  char *meanPtr=(char*)input;
1421  short mean=(short)(*meanPtr);
1422  int inputBits=0,mulawBits=0;
1423  getInputAndMuLawBits(encType,&inputBits,&mulawBits);
1424  int bitSize=mulawBits;
1425  int bitNum;
1426 
1427  unsigned char *currentChar=&input[1];
1428  int currentBit=0;
1429  unsigned char tempNum;
1430  short newVal;
1431 
1432 // printf("mean %d, mulawBits %d, inputBits %d\n",mean,mulawBits,inputBits);
1433 
1434  while(sampNum<MAX_NUMBER_SAMPLES) {
1435  int fred = *( (int*) currentChar);
1436 // bin_prnt_int(fred);
1437  tempNum=0;
1438  for(bitNum=currentBit;bitNum<currentBit+bitSize;bitNum++) {
1439  tempNum|= (((fred>>bitNum)&0x1)<<(bitNum-currentBit));
1440 // bin_prnt_short(tempNum);
1441 // cout << (((fred>>bitNum)&0x1)<<(bitNum-currentBit));
1442  }
1443 // cout << endl;
1444 // bin_prnt_short(tempNum);
1445 // cout << sampNum << "\t" << tempNum << endl;
1446  newVal=convertFromMuLawUC(tempNum,inputBits,mulawBits);
1447  chanPtr->data[sampNum]=mean+newVal;
1448 // printf("output %d, newVal %d, tempNum %d\n",chanPtr->data[sampNum],
1449 // newVal,tempNum);
1450 
1451  sampNum++;
1452  currentBit+=bitSize;
1453  while(currentBit>=8) {
1454  currentBit-=8;
1455  currentChar++;
1456  }
1457  if(((int)(currentChar-input))>numBytes) return COMPRESS_E_BADSIZE;
1458  }
1459  return COMPRESS_E_OK;
1460 
1461 
1462 }
1463 
1464 void AnitaCompress::getInputAndMuLawBits(ChannelEncodingType_t encType, int *inputPtr,
1465  int *mulawPtr)
1466 {
1467  switch(encType) {
1468  case ENCODE_LOSSY_MULAW_11_8:
1469  *inputPtr=11;
1470  *mulawPtr=8;
1471  return;
1472  case ENCODE_LOSSY_MULAW_11_7:
1473  *inputPtr=11;
1474  *mulawPtr=7;
1475  return;
1476  case ENCODE_LOSSY_MULAW_11_6:
1477  *inputPtr=11;
1478  *mulawPtr=6;
1479  return;
1480  case ENCODE_LOSSY_MULAW_11_5:
1481  *inputPtr=11;
1482  *mulawPtr=5;
1483  return;
1484  case ENCODE_LOSSY_MULAW_11_4:
1485  *inputPtr=11;
1486  *mulawPtr=4;
1487  return;
1488  case ENCODE_LOSSY_MULAW_11_3:
1489  *inputPtr=11;
1490  *mulawPtr=3;
1491  return;
1492  case ENCODE_LOSSY_MULAW_10_8:
1493  *inputPtr=10;
1494  *mulawPtr=8;
1495  return;
1496  case ENCODE_LOSSY_MULAW_10_7:
1497  *inputPtr=10;
1498  *mulawPtr=7;
1499  return;
1500  case ENCODE_LOSSY_MULAW_10_6:
1501  *inputPtr=10;
1502  *mulawPtr=6;
1503  return;
1504  case ENCODE_LOSSY_MULAW_10_5:
1505  *inputPtr=10;
1506  *mulawPtr=5;
1507  return;
1508  case ENCODE_LOSSY_MULAW_10_4:
1509  *inputPtr=10;
1510  *mulawPtr=4;
1511  return;
1512  case ENCODE_LOSSY_MULAW_10_3:
1513  *inputPtr=10;
1514  *mulawPtr=3;
1515  return;
1516  case ENCODE_LOSSY_MULAW_9_7:
1517  *inputPtr=9;
1518  *mulawPtr=7;
1519  return;
1520  case ENCODE_LOSSY_MULAW_9_6:
1521  *inputPtr=9;
1522  *mulawPtr=6;
1523  return;
1524  case ENCODE_LOSSY_MULAW_9_5:
1525  *inputPtr=9;
1526  *mulawPtr=5;
1527  return;
1528  case ENCODE_LOSSY_MULAW_9_4:
1529  *inputPtr=9;
1530  *mulawPtr=4;
1531  return;
1532  case ENCODE_LOSSY_MULAW_9_3:
1533  *inputPtr=9;
1534  *mulawPtr=3;
1535  return;
1536  case ENCODE_LOSSY_MULAW_8_6:
1537  *inputPtr=8;
1538  *mulawPtr=6;
1539  return;
1540  case ENCODE_LOSSY_MULAW_8_5:
1541  *inputPtr=8;
1542  *mulawPtr=5;
1543  return;
1544  case ENCODE_LOSSY_MULAW_8_4:
1545  *inputPtr=8;
1546  *mulawPtr=4;
1547  return;
1548  case ENCODE_LOSSY_MULAW_8_3:
1549  *inputPtr=8;
1550  *mulawPtr=3;
1551  return;
1552  case ENCODE_LOSSY_MULAW_7_5:
1553  *inputPtr=7;
1554  *mulawPtr=5;
1555  return;
1556  case ENCODE_LOSSY_MULAW_7_4:
1557  *inputPtr=7;
1558  *mulawPtr=4;
1559  return;
1560  case ENCODE_LOSSY_MULAW_7_3:
1561  *inputPtr=7;
1562  *mulawPtr=3;
1563  return;
1564  case ENCODE_LOSSY_MULAW_6_4:
1565  *inputPtr=6;
1566  *mulawPtr=4;
1567  return;
1568  case ENCODE_LOSSY_MULAW_6_3:
1569  *inputPtr=6;
1570  *mulawPtr=3;
1571  return;
1572  default:
1573  *inputPtr=11;
1574  *mulawPtr=8;
1575  return;
1576  }
1577  *inputPtr=11;
1578  *mulawPtr=11;
1579  return;
1580 
1581 }
1582 
1583 ChannelEncodingType_t AnitaCompress::getEncodingTypeFromInputAndMuLawBits(int inputBits,
1584  int mulawBits)
1585 {
1586  switch (inputBits) {
1587  case 11:
1588  switch (mulawBits) {
1589  case 8:
1590  return ENCODE_LOSSY_MULAW_11_8;
1591  case 7:
1592  return ENCODE_LOSSY_MULAW_11_7;
1593  case 6:
1594  return ENCODE_LOSSY_MULAW_11_6;
1595  case 5:
1596  return ENCODE_LOSSY_MULAW_11_5;
1597  case 4:
1598  return ENCODE_LOSSY_MULAW_11_4;
1599  case 3:
1600  return ENCODE_LOSSY_MULAW_11_3;
1601  default:
1602  return ENCODE_LOSSY_MULAW_11_8;
1603  }
1604  case 10:
1605  switch (mulawBits) {
1606  case 8:
1607  return ENCODE_LOSSY_MULAW_10_8;
1608  case 7:
1609  return ENCODE_LOSSY_MULAW_10_7;
1610  case 6:
1611  return ENCODE_LOSSY_MULAW_10_6;
1612  case 5:
1613  return ENCODE_LOSSY_MULAW_10_5;
1614  case 4:
1615  return ENCODE_LOSSY_MULAW_10_4;
1616  case 3:
1617  return ENCODE_LOSSY_MULAW_10_3;
1618  default:
1619  return ENCODE_LOSSY_MULAW_10_8;
1620  }
1621  case 9:
1622  switch (mulawBits) {
1623  case 7:
1624  return ENCODE_LOSSY_MULAW_9_7;
1625  case 6:
1626  return ENCODE_LOSSY_MULAW_9_6;
1627  case 5:
1628  return ENCODE_LOSSY_MULAW_9_5;
1629  case 4:
1630  return ENCODE_LOSSY_MULAW_9_4;
1631  case 3:
1632  return ENCODE_LOSSY_MULAW_9_3;
1633  default:
1634  return ENCODE_LOSSY_MULAW_9_7;
1635  }
1636  case 8:
1637  switch (mulawBits) {
1638  case 6:
1639  return ENCODE_LOSSY_MULAW_8_6;
1640  case 5:
1641  return ENCODE_LOSSY_MULAW_8_5;
1642  case 4:
1643  return ENCODE_LOSSY_MULAW_8_4;
1644  case 3:
1645  return ENCODE_LOSSY_MULAW_8_3;
1646  default:
1647  return ENCODE_LOSSY_MULAW_8_6;
1648  }
1649  case 7:
1650  switch (mulawBits) {
1651  case 5:
1652  return ENCODE_LOSSY_MULAW_7_5;
1653  case 4:
1654  return ENCODE_LOSSY_MULAW_7_4;
1655  case 3:
1656  return ENCODE_LOSSY_MULAW_7_3;
1657  default:
1658  return ENCODE_LOSSY_MULAW_7_5;
1659  }
1660  case 6:
1661  switch (mulawBits) {
1662  case 4:
1663  return ENCODE_LOSSY_MULAW_6_4;
1664  case 3:
1665  return ENCODE_LOSSY_MULAW_6_3;
1666  default:
1667  return ENCODE_LOSSY_MULAW_6_4;
1668  }
1669  default:
1670  switch (mulawBits) {
1671  case 8:
1672  return ENCODE_LOSSY_MULAW_11_8;
1673  case 7:
1674  return ENCODE_LOSSY_MULAW_11_7;
1675  case 6:
1676  return ENCODE_LOSSY_MULAW_11_6;
1677  case 5:
1678  return ENCODE_LOSSY_MULAW_11_5;
1679  case 4:
1680  return ENCODE_LOSSY_MULAW_11_4;
1681  case 3:
1682  return ENCODE_LOSSY_MULAW_11_3;
1683  default:
1684  return ENCODE_LOSSY_MULAW_11_8;
1685  }
1686  }
1687  return ENCODE_NONE;
1688 }
1689 
1690 ChannelEncodingType_t AnitaCompress::getBinaryEncType(int bitSize) {
1691  switch(bitSize) {
1692  case 12: return ENCODE_LOSSLESS_12BIT;
1693  case 11: return ENCODE_LOSSLESS_11BIT;
1694  case 10: return ENCODE_LOSSLESS_10BIT;
1695  case 9: return ENCODE_LOSSLESS_9BIT;
1696  case 8: return ENCODE_LOSSLESS_8BIT;
1697  case 7: return ENCODE_LOSSLESS_7BIT;
1698  case 6: return ENCODE_LOSSLESS_6BIT;
1699  case 5: return ENCODE_LOSSLESS_5BIT;
1700  case 4: return ENCODE_LOSSLESS_4BIT;
1701  case 3: return ENCODE_LOSSLESS_3BIT;
1702  case 2: return ENCODE_LOSSLESS_2BIT;
1703  case 1: return ENCODE_LOSSLESS_1BIT;
1704  default:
1705  return ENCODE_LOSSLESS_12BIT;
1706  }
1707  return ENCODE_LOSSLESS_12BIT;
1708 }
1709 
1710 
1711 int AnitaCompress::getBinaryBitSize(ChannelEncodingType_t encType) {
1712  switch(encType) {
1713  case ENCODE_LOSSLESS_12BIT: return 12;
1714  case ENCODE_LOSSLESS_11BIT: return 11;
1715  case ENCODE_LOSSLESS_10BIT: return 10;
1716  case ENCODE_LOSSLESS_9BIT: return 9;
1717  case ENCODE_LOSSLESS_8BIT: return 8;
1718  case ENCODE_LOSSLESS_7BIT: return 7;
1719  case ENCODE_LOSSLESS_6BIT: return 6;
1720  case ENCODE_LOSSLESS_5BIT: return 5;
1721  case ENCODE_LOSSLESS_4BIT: return 4;
1722  case ENCODE_LOSSLESS_3BIT: return 3;
1723  case ENCODE_LOSSLESS_2BIT: return 2;
1724  case ENCODE_LOSSLESS_1BIT: return 1;
1725  default:
1726  return 12;
1727  }
1728  return 12;
1729 }
1730 
1731 
1732 ChannelEncodingType_t AnitaCompress::getBinFibEncType(int bitSize) {
1733  switch(bitSize) {
1734  case 10: return ENCODE_LOSSLESS_BINFIB_10BIT;
1735  case 9: return ENCODE_LOSSLESS_BINFIB_9BIT;
1736  case 8: return ENCODE_LOSSLESS_BINFIB_8BIT;
1737  case 7: return ENCODE_LOSSLESS_BINFIB_7BIT;
1738  case 6: return ENCODE_LOSSLESS_BINFIB_6BIT;
1739  case 5: return ENCODE_LOSSLESS_BINFIB_5BIT;
1740  case 4: return ENCODE_LOSSLESS_BINFIB_4BIT;
1741  case 3: return ENCODE_LOSSLESS_BINFIB_3BIT;
1742  case 2: return ENCODE_LOSSLESS_BINFIB_2BIT;
1743  case 1: return ENCODE_LOSSLESS_BINFIB_1BIT;
1744  default:
1745  return ENCODE_LOSSLESS_BINFIB_10BIT;
1746  }
1747  return ENCODE_LOSSLESS_BINFIB_10BIT;
1748 }
1749 
1750 
1751 int AnitaCompress::getBinFibBitSize(ChannelEncodingType_t encType) {
1752  switch(encType) {
1753  case ENCODE_LOSSLESS_BINFIB_10BIT: return 10;
1754  case ENCODE_LOSSLESS_BINFIB_9BIT: return 9;
1755  case ENCODE_LOSSLESS_BINFIB_8BIT: return 8;
1756  case ENCODE_LOSSLESS_BINFIB_7BIT: return 7;
1757  case ENCODE_LOSSLESS_BINFIB_6BIT: return 6;
1758  case ENCODE_LOSSLESS_BINFIB_5BIT: return 5;
1759  case ENCODE_LOSSLESS_BINFIB_4BIT: return 4;
1760  case ENCODE_LOSSLESS_BINFIB_3BIT: return 3;
1761  case ENCODE_LOSSLESS_BINFIB_2BIT: return 2;
1762  case ENCODE_LOSSLESS_BINFIB_1BIT: return 1;
1763  default:
1764  return 10;
1765  }
1766  return 10;
1767 }
1768 
1769 
1770 
1771 
1772 
1773 
1774 unsigned short AnitaCompress::simpleCrcShort(unsigned short *p, unsigned long n)
1775 {
1776 
1777  unsigned short sum = 0;
1778  unsigned long i;
1779  for (i=0L; i<n; i++) {
1780  sum += *p++;
1781  }
1782  return ((0xffff - sum) + 1);
1783 }
1784 
1785 const char *AnitaCompress::compressErrorCodeAsString(CompressErrorCode_t code)
1786 {
1787  const char *string;
1788  switch(code) {
1789  case COMPRESS_E_OK:
1790  string = "Success";
1791  break;
1792  case COMPRESS_E_PACK:
1793  string = "Error packing data";
1794  break;
1795  case COMPRESS_E_BADSIZE:
1796  string = "Enocded data size wrong";
1797  break;
1798  case COMPRESS_E_UNPACK:
1799  string = "Error unpacking data";
1800  break;
1801  case COMPRESS_E_NO_PEDS:
1802  string = "Pedestals not available";
1803  break;
1804  case COMPRESS_E_BAD_PEDS:
1805  string = "Pedestals malformed";
1806  break;
1807  case COMPRESS_E_TOO_BIG:
1808  string = "Data overflow";
1809  break;
1810  case COMPRESS_E_BAD_CRC:
1811  string = "Checksum mismatch";
1812  break;
1813  default:
1814  string = "Unknown error code" ;
1815  }
1816 
1817  return (string) ;
1818 }
1819 
1820 #ifndef MEMCPY
1821 /* For unix, use the following: */
1822 #define MEMCPY memcpy
1823 #endif
1824 
1825 void AnitaCompress::unpack12bit(unsigned short *w, void *srcp)
1826 {
1827  char *dumPtr = (char *) srcp;
1828  unsigned short val;
1829  w[3] = 0;
1830 
1831  MEMCPY((char *)&val, dumPtr, sizeof(short));
1832  w[0] = val & 0x0fff;
1833  w[3] += ((val & 0xf000) >> 12);
1834 
1835  MEMCPY((char *)&val, dumPtr + sizeof(short), sizeof(short));
1836  w[1] = val & 0x0fff;
1837  w[3] += ((val & 0xf000) >> 8);
1838 
1839  MEMCPY((char *)&val, dumPtr + (2 * sizeof(short)), sizeof(short));
1840  w[2] = val & 0x0fff;
1841  w[3] += ((val & 0xf000) >> 4);
1842 }
1843 
1844 void AnitaCompress::pack12bit(unsigned short *w, unsigned char *destp)
1845 {
1846  unsigned short val;
1847 
1848  val = (w[0] & 0x0fff) + ((w[3] << 12) & 0xf000);
1849  MEMCPY(destp, (char *)&val, sizeof(short));
1850 
1851  val = (w[1] & 0x0fff) + ((w[3] << 8) & 0xf000);
1852  MEMCPY(destp+2, (char *)&val, sizeof(short));
1853 
1854  val = (w[2] & 0x0fff) + ((w[3] << 4) & 0xf000);
1855  MEMCPY(destp+4, (char *)&val, sizeof(short));
1856 }
1857 
1858 
1859 unsigned char AnitaCompress::convertToMuLawUC(short input, int inputBits,
1860  int mulawBits)
1861 {
1862  char val=convertToMuLaw(input,inputBits,mulawBits);
1863 // printf("c %d, uc %d\n",val,charbifurcate(val));
1864  return charbifurcate(val);
1865 }
1866 
1867 char AnitaCompress::convertToMuLaw(short input, int inputBits, int mulawBits)
1868 {
1869  //It is the responsibilty of the caller to ensure input is within the range specified.
1870  //Might add checks as I don't trust the user.
1871  int index=input+(1<<(inputBits-1));
1872  switch (inputBits) {
1873  case 11:
1874  switch (mulawBits) {
1875  case 8:
1876  return linear11toMuLaw8[index];
1877  case 7:
1878  return linear11toMuLaw7[index];
1879  case 6:
1880  return linear11toMuLaw6[index];
1881  case 5:
1882  return linear11toMuLaw5[index];
1883  case 4:
1884  return linear11toMuLaw4[index];
1885  case 3:
1886  return linear11toMuLaw3[index];
1887  default:
1888  return linear11toMuLaw8[index];
1889  }
1890  case 10:
1891  switch (mulawBits) {
1892  case 8:
1893  return linear10toMuLaw8[index];
1894  case 7:
1895  return linear10toMuLaw7[index];
1896  case 6:
1897  return linear10toMuLaw6[index];
1898  case 5:
1899  return linear10toMuLaw5[index];
1900  case 4:
1901  return linear10toMuLaw4[index];
1902  case 3:
1903  return linear10toMuLaw3[index];
1904  default:
1905  return linear10toMuLaw8[index];
1906  }
1907  case 9:
1908  switch (mulawBits) {
1909  case 7:
1910  return linear9toMuLaw7[index];
1911  case 6:
1912  return linear9toMuLaw6[index];
1913  case 5:
1914  return linear9toMuLaw5[index];
1915  case 4:
1916  return linear9toMuLaw4[index];
1917  case 3:
1918  return linear9toMuLaw3[index];
1919  default:
1920  return linear9toMuLaw7[index];
1921  }
1922  case 8:
1923  switch (mulawBits) {
1924  case 6:
1925  return linear8toMuLaw6[index];
1926  case 5:
1927  return linear8toMuLaw5[index];
1928  case 4:
1929  return linear8toMuLaw4[index];
1930  case 3:
1931  return linear8toMuLaw3[index];
1932  default:
1933  return linear8toMuLaw6[index];
1934  }
1935  case 7:
1936  switch (mulawBits) {
1937  case 5:
1938  return linear7toMuLaw5[index];
1939  case 4:
1940  return linear7toMuLaw4[index];
1941  case 3:
1942  return linear7toMuLaw3[index];
1943  default:
1944  return linear7toMuLaw5[index];
1945  }
1946  case 6:
1947  switch (mulawBits) {
1948  case 4:
1949  return linear6toMuLaw4[index];
1950  case 3:
1951  return linear6toMuLaw3[index];
1952  default:
1953  return linear6toMuLaw4[index];
1954  }
1955  default:
1956  switch (mulawBits) {
1957  case 8:
1958  return linear11toMuLaw8[index];
1959  case 7:
1960  return linear11toMuLaw7[index];
1961  case 6:
1962  return linear11toMuLaw6[index];
1963  case 5:
1964  return linear11toMuLaw5[index];
1965  case 4:
1966  return linear11toMuLaw4[index];
1967  case 3:
1968  return linear11toMuLaw3[index];
1969  default:
1970  return linear11toMuLaw8[index];
1971  }
1972  }
1973  return 0;
1974 }
1975 
1976 short AnitaCompress::convertFromMuLawUC(unsigned char input, int outputBits, int mulawBits)
1977 {
1978 // printf("uc %d, c %d\n",input,charunbifurcate(input));
1979  return convertFromMuLaw(charunbifurcate(input),outputBits,mulawBits);
1980 }
1981 
1982 short AnitaCompress::convertFromMuLaw(char input, int outputBits, int mulawBits)
1983 {
1984  int index=input+(1<<(mulawBits-1));
1985  switch (outputBits) {
1986  case 11:
1987  switch (mulawBits) {
1988  case 8:
1989  return mulaw8toLinear11[index];
1990  case 7:
1991  return mulaw7toLinear11[index];
1992  case 6:
1993  return mulaw6toLinear11[index];
1994  case 5:
1995  return mulaw5toLinear11[index];
1996  case 4:
1997  return mulaw4toLinear11[index];
1998  case 3:
1999  return mulaw3toLinear11[index];
2000  default:
2001  return mulaw8toLinear11[index];
2002  }
2003  case 10:
2004  switch (mulawBits) {
2005  case 8:
2006  return mulaw8toLinear10[index];
2007  case 7:
2008  return mulaw7toLinear10[index];
2009  case 6:
2010  return mulaw6toLinear10[index];
2011  case 5:
2012  return mulaw5toLinear10[index];
2013  case 4:
2014  return mulaw4toLinear10[index];
2015  case 3:
2016  return mulaw3toLinear10[index];
2017  default:
2018  return mulaw8toLinear10[index];
2019  }
2020  case 9:
2021  switch (mulawBits) {
2022  case 7:
2023  return mulaw7toLinear9[index];
2024  case 6:
2025  return mulaw6toLinear9[index];
2026  case 5:
2027  return mulaw5toLinear9[index];
2028  case 4:
2029  return mulaw4toLinear9[index];
2030  case 3:
2031  return mulaw3toLinear9[index];
2032  default:
2033  return mulaw7toLinear9[index];
2034  }
2035  case 8:
2036  switch (mulawBits) {
2037  case 6:
2038  return mulaw6toLinear8[index];
2039  case 5:
2040  return mulaw5toLinear8[index];
2041  case 4:
2042  return mulaw4toLinear8[index];
2043  case 3:
2044  return mulaw3toLinear8[index];
2045  default:
2046  return mulaw6toLinear8[index];
2047  }
2048  case 7:
2049  switch (mulawBits) {
2050  case 5:
2051  return mulaw5toLinear7[index];
2052  case 4:
2053  return mulaw4toLinear7[index];
2054  case 3:
2055  return mulaw3toLinear7[index];
2056  default:
2057  return mulaw5toLinear7[index];
2058  }
2059  case 6:
2060  switch (mulawBits) {
2061  case 4:
2062  return mulaw4toLinear6[index];
2063  case 3:
2064  return mulaw3toLinear6[index];
2065  default:
2066  return mulaw4toLinear6[index];
2067  }
2068  default:
2069  switch (mulawBits) {
2070  case 8:
2071  return mulaw8toLinear11[index];
2072  case 7:
2073  return mulaw7toLinear11[index];
2074  case 6:
2075  return mulaw6toLinear11[index];
2076  case 5:
2077  return mulaw5toLinear11[index];
2078  case 4:
2079  return mulaw4toLinear11[index];
2080  case 3:
2081  return mulaw3toLinear11[index];
2082  default:
2083  return mulaw8toLinear11[index];
2084  }
2085  }
2086  return 0;
2087 }
2088 
2089 
2090 unsigned int fFibNums[24]={1,2,3,5,8,13,21,34,55,89,
2091  144,233,377,610,987,1597,2584,4181,6765,10946,
2092  17711,28657,46368,75025};
2093 //these are enough to encode unsigned short
2094 
2095 //convert a short to its fibonacci representation with a 11 prefix
2096 unsigned int AnitaCompress::fibonacci(unsigned short input){
2097  int numBits;
2098  return encodeFibonacci(input,&numBits);
2099 }
2100 
2101 unsigned int AnitaCompress::encodeFibonacci(unsigned short input,int *numBits){
2102  unsigned int output;
2103  int i;
2104  i=0;
2105  // find the first fibonacci number greater than input
2106  while(input>=fFibNums[i]){
2107  i++;
2108  }
2109  // set the prefix bit
2110  (*numBits)=i+1;
2111  output=1<<(i);
2112  i--; // we are now at the largest fibonacci number less than input
2113  //now set the bits for the minimal fibonacci representation
2114  while(i>=0){
2115  if (input>=fFibNums[i]){
2116  output += (1<<i);
2117  input -= fFibNums[i];
2118  }
2119  i--;
2120  }
2121  return output;
2122 }
2123 
2124 // reverse the above operation
2125 unsigned short AnitaCompress::unfibonacci(unsigned int input)
2126 {
2127  unsigned int i;
2128  unsigned short output;
2129  unsigned int curbit, lastbit;
2130  output=0;
2131  lastbit=0;
2132  for (i=0; i<23; i++){
2133  curbit=(input>>i) & 0x0001;
2134  if (curbit==1 && lastbit==1) break; // done--found the prefix bit
2135  else if (curbit==1) output+=fFibNums[i];
2136  lastbit=curbit;
2137  }
2138  return output;
2139 }
2140 
2141 
2142 
2143 // perform the bifurcation mapping from integers to the positive
2144 // integers as a prelude to applying prefix codes (e.g. fibonacci)
2145 //
2146 // chosen mapping is 0,-1,1,-2,2... => 1,2,3,4,5
2147 //
2148 // posi integers map to 2*n+1
2149 // negative integers map 2*abs(n)
2150 //
2151 
2152 unsigned short AnitaCompress::bifurcate(short input)
2153 {
2154  unsigned short output;
2155  if (input>=0){
2156  output=(2*(unsigned short) input + 1);
2157  }
2158  else{
2159  output=(2* (unsigned short)abs(input));
2160  }
2161  return output;
2162 }
2163 
2164 short AnitaCompress::unbifurcate(unsigned short input)
2165 {
2166  // note zero is not a valid input
2167  short output;
2168  if ((input % 2) == 1){//odd => non-negative
2169  output=((input-1)/2);
2170  }
2171  else{ //even => negative
2172  output=-(input/2);
2173  }
2174  return output;
2175 }
2176 
2177 unsigned char AnitaCompress::charbifurcate(char input)
2178 {
2179  unsigned char output;
2180  if (input>=0){
2181  output=(2*(unsigned char) input + 1);
2182  }
2183  else{
2184  input*=-1;
2185  output=(2* (unsigned char)input);
2186  }
2187  return output;
2188 }
2189 
2190 char AnitaCompress::charunbifurcate(unsigned char input)
2191 {
2192  // note zero is not a valid input
2193  char output;
2194  if ((input % 2) == 1){//odd => non-negative
2195  output=((input-1)/2);
2196  }
2197  else{ //even => negative
2198  output=-(input/2);
2199  }
2200  return output;
2201 }
2202 
2203 
2204 
2205 // discard (in place) the last nbits bits of the data, shifting right
2206 // number of words is nwords
2207 void AnitaCompress::bitstrip(unsigned short nbits, unsigned short nwords, unsigned short *data)
2208 {
2209  unsigned short i;
2210  for (i=0; i<nwords; i++){
2211  data[i]=data[i]>>nbits;
2212  }
2213 }
2214 
2215 
2216 // pack the nbits least-significant bits of the data
2217 // into a byte stream. Returns number of bytes of buffer used.
2218 // The input data are left unchanged.
2219 unsigned short AnitaCompress::bitpack(unsigned short nbits, unsigned short nwords,
2220  unsigned short *in, unsigned char *out)
2221 {
2222  unsigned short i;
2223  unsigned short scratch, mask1,mask2, byte, bit, nbitsleft;
2224  byte=0; //current output byte
2225  bit=0; //current output bit
2226  out[0]=0;
2227  mask1= ~(0xffff << (unsigned short) nbits); //mask to yield nbits lsbs
2228  for (i=0; i<nwords; i++){
2229  scratch= in[i] & mask1;
2230  nbitsleft=nbits;
2231  while (nbitsleft>0){
2232  if (nbitsleft>(8-bit)){ //won't all fit
2233  mask2 = ~((0xffff)<<(8-bit));
2234  out[byte] |= (scratch & mask2) << bit;
2235  mask2 = ~mask2;
2236  scratch = ((scratch & mask2) >> (8-bit));
2237  nbitsleft -= (8-bit);
2238  byte++; bit=0; out[byte]=0;
2239  }
2240  else { //everything fits in current byte
2241  out[byte] |= scratch << bit;
2242  bit = bit + nbitsleft;
2243  if (bit==8){ byte++; bit=0; out[byte]=0;}
2244  nbitsleft=0;
2245  }
2246  }
2247  }
2248  if (bit==0) return byte;
2249  else return byte+1;
2250 }
2251 
2252 //pack fibonacci code into bytes
2253 
2254 int AnitaCompress::codepack(int n, unsigned int *in, unsigned char *out)
2255 {
2256  //need to add checks on m!!!
2257  int byte,i;
2258  unsigned char bit, nbits;
2259  unsigned int sbit,scratch,mask;
2260  // in[n] is packed into out with leading zeros removed.
2261  // it must be filled with nonzero data in a prefix code
2262  byte=0;//current output byte
2263  bit=0;//next bit to be written
2264  out[0]=0;
2265  for (i=0; i<n; i++){ //i indexes input array
2266  //how many bits in in[i]?
2267  nbits=0;sbit=0x1;
2268  while (sbit<=in[i]) {sbit=sbit<<1; nbits++;}
2269  //there are nbit bits before there are leading zeros
2270  //last 1 is in bit (nbit-1)
2271  scratch=in[i];
2272  while (nbits>0){
2273  if (nbits>((unsigned char)8-bit)){
2274  //pack the least significant bits into the current byte
2275  mask= ~((unsigned int)(0xffffffff)<<(8-bit));
2276  out[byte] |= (scratch & mask) << bit;
2277  mask = ~mask;
2278  scratch=(scratch & mask) >> (8-bit);
2279  nbits -= (8-bit);
2280  byte++; bit=0; out[byte]=0;
2281  }
2282  else{//everything fits
2283  out[byte] |= scratch << bit;
2284  bit= bit + nbits;
2285  if (bit==8){ byte++; bit=0; out[byte]=0;}
2286  nbits=0;
2287  }
2288  }
2289  }
2290  if (bit==0) return byte;
2291  else return byte+1;
2292 }
2293 
2294 //unpack fibonacci code
2295 
2296 int AnitaCompress::codeunpack(int m, unsigned char *in, unsigned int *out)
2297 {
2298  int inbyte, inbit;
2299  int outword, outbit;
2300  unsigned int curbit, lastbit;
2301 /* proceed one bit at a time. When two ones are seen, advance
2302  to the next output word */
2303  inbyte=0; inbit=0;
2304  outword=0,outbit=0;
2305  lastbit=0;
2306  out[outword]=0;
2307  while (inbyte<m){
2308  curbit=(in[inbyte]>>inbit) & 0x1;
2309  out[outword] |= curbit << outbit;
2310  inbit++; outbit++;
2311  if (inbit==8){ inbyte++; inbit=0;}
2312  if ((curbit==1 && lastbit==1)|| outbit==32){
2313  outword++; outbit=0; out[outword]=0;
2314  //printf("%i %hx\n",outword,out[outword-1]);
2315  }
2316  if (outbit!=0) lastbit=curbit;
2317  else lastbit=0;
2318  }
2319  return outword;
2320 }
PACKET_ENC_WV_PEDSUB
EncodedPedSubbedChannelPacketHeader_t – Yes.
Definition: simpleStructs.h:216
SSHkDataStruct_t
SS Hk Data Struct – Telemetered.
Definition: simpleStructs.h:1174
PACKET_MONITOR
MonitorStruct_t – Yes.
Definition: simpleStructs.h:230
PACKET_GPS_ADU5_PAT
GpsAdu5PatStruct_t – Yes.
Definition: simpleStructs.h:221
PACKET_HKD
HkDataStruct_t – Yes.
Definition: simpleStructs.h:227
PACKET_BD
AnitaEventBody_t – No.
Definition: simpleStructs.h:200
PACKET_ZIPPED_FILE
ZippedFile_t – Yes.
Definition: simpleStructs.h:239
ENCODE_LOSSLESS_12BIT
Done.
Definition: simpleStructs.h:275
EncodedEventWrapper_t::numBytes
unsigned numBytes
Not including the EncodedEventWrapper_t;.
Definition: simpleStructs.h:1367
PedSubbedEventBody_t::whichPeds
unsigned int whichPeds
whichPedestals did we subtract
Definition: simpleStructs.h:1347
fillGenericHeader
void fillGenericHeader(void *thePtr, PacketCode_t code, unsigned short numBytes)
fillGenericHeader – utility function
Definition: AnitaPacketUtil.cxx:156
PACKET_SUM_TURF_RATE
SummedTurfRateStruct_t – yes.
Definition: simpleStructs.h:208
ChannelEncodingType_t
ChannelEncodingType_t
The encoding enumeration.
Definition: simpleStructs.h:273
unzipZippedPacket
int unzipZippedPacket(ZippedPacket_t *zipPacket, char *output, unsigned int numBytesOut)
unzipZippedPacket – utility function
Definition: AnitaPacketUtil.cxx:274
GpsAdu5SatStruct_t
ADU5 Satellite Info – Telemetered.
Definition: simpleStructs.h:1073
GpsdStartStruct_t
Gpsd Start Block – Telemetered.
Definition: simpleStructs.h:1120
SummedTurfRateStruct_t
Summed Turf Rates – Telemetered.
Definition: simpleStructs.h:870
PACKET_PEDSUB_SURF
PedSubbedSurfPacket_t – Yes.
Definition: simpleStructs.h:218
GenericHeader_t
The Generic Header.
Definition: simpleStructs.h:374
ENCODE_NONE
Done.
Definition: simpleStructs.h:274
SlowRateFull_t
Slow Rate Block – Telemetered.
Definition: simpleStructs.h:801
getVersionId
unsigned char getVersionId(PacketCode_t code)
getVersionId – utility function
Definition: AnitaPacketUtil.cxx:108
PACKET_ENC_SURF_PEDSUB
EncodedPedSubbedSurfPacketHeader_t – Yes.
Definition: simpleStructs.h:213
CompressErrorCode_t
CompressErrorCode_t
CompressErrorCode_t – Enumeration for compression errors.
Definition: AnitaPacketUtil.h:107
RawSurfChannelHeader_t::chanId
unsigned char chanId
Channel Id.
Definition: simpleStructs.h:467
PACKET_OTHER_MONITOR
OtherMonitorStruct_t – Yes.
Definition: simpleStructs.h:241
PACKET_RUN_START
RunStart_t – Yes.
Definition: simpleStructs.h:240
PedSubbedEventBody_t
Pedestal subtracted event format.
Definition: simpleStructs.h:1343
ENCODE_LOSSLESS_BINFIB_COMBO
Done is just a marker for below.
Definition: simpleStructs.h:289
PACKET_GPS_GGA
GpsGgaStruct_t – Yes.
Definition: simpleStructs.h:226
GpsAdu5VtgStruct_t
ADU5 course and speed info – Telemetered.
Definition: simpleStructs.h:1084
PACKET_LOGWATCHD_START
LogWatchdStart_t – Yes.
Definition: simpleStructs.h:243
AcqdStartStruct_t
The Acqd Startup Struct – Telemetered.
Definition: simpleStructs.h:1139
PACKET_SURF_HK
FullSurfHkStruct_t –Yes.
Definition: simpleStructs.h:205
GpsG12SatStruct_t
G12 Satellite Info – Telemetered.
Definition: simpleStructs.h:1062
RawWaveformPacket_t
Raw waveform packet – Telemetered.
Definition: simpleStructs.h:936
ENCODE_LOSSLESS_BINARY
Done is just a marker for below.
Definition: simpleStructs.h:276
FullLabChipPedStruct_t
Pedestal Block – Telemetered.
Definition: simpleStructs.h:1273
AnitaEventBody_t
Raw event format.
Definition: simpleStructs.h:1332
PACKET_ACQD_START
AcqdStartStruct_t – Yes.
Definition: simpleStructs.h:244
HkDataStruct_t
Hk Data Struct – Telemetered.
Definition: simpleStructs.h:1160
PACKET_ENC_SURF
EncodedSurfPacketHeader_t – Yes.
Definition: simpleStructs.h:212
SurfChannelPedSubbed_t::rms
float rms
Filled by pedestalLib.
Definition: simpleStructs.h:521
PACKET_WV
RawWaveformPacket_t –Yes.
Definition: simpleStructs.h:202
MonitorStruct_t
Monitor Block – Telemetered.
Definition: simpleStructs.h:1244
PACKET_SLOW_FULL
SlowRateFull_t – Yes.
Definition: simpleStructs.h:237
AnitaEventHeader_t
ANITA Event Header – Telemetered.
Definition: simpleStructs.h:889
getPacketSize
int getPacketSize(PacketCode_t code)
getPacketSize – utility function
Definition: AnitaPacketUtil.cxx:32
packetCodeAsString
const char * packetCodeAsString(PacketCode_t code)
packetCodeAsString – utility function
Definition: AnitaPacketUtil.cxx:223
checkPacket
int checkPacket(void *thePtr)
checkPacket – utility function
Definition: AnitaPacketUtil.cxx:180
GpsAdu5PatStruct_t
ADU5 Postion and Attitude – Telemetered.
Definition: simpleStructs.h:1010
ZippedPacket_t
Zipped packet – Telemetered.
Definition: simpleStructs.h:1284
PacketCode_t
PacketCode_t
The Packet Code.
Definition: simpleStructs.h:199
AveragedSurfHkStruct_t
Average Surf Hk – Telemetered.
Definition: simpleStructs.h:1208
PACKET_TURF_RATE
TurfRateStruct_t – Yes.
Definition: simpleStructs.h:206
simpleIntCrc
unsigned int simpleIntCrc(unsigned int *p, unsigned int n)
simpleIntCrc – utility function
Definition: AnitaPacketUtil.cxx:96
BaseWavePacketHeader_t
Encoded PedSubbed Packet Header – Telemetered.
Definition: simpleStructs.h:997
PACKET_ENC_PEDSUB_EVENT_WRAPPER
EncodedEventWrapper_t – No.
Definition: simpleStructs.h:217
CommandEcho_t
Command Echo – Telemetered.
Definition: simpleStructs.h:1232
EncodedEventWrapper_t
Wrapper for data that is written encoded.
Definition: simpleStructs.h:1364
RawSurfChannelHeader_t::lastHitbus
unsigned char lastHitbus
Last sample of the hitbus.
Definition: simpleStructs.h:487
PACKET_PED_SUBBED_EVENT
PedSubbedEventBody_t – No too big.
Definition: simpleStructs.h:215
GpsG12PosStruct_t
G12 Position and speed info – Telemetered.
Definition: simpleStructs.h:1098
PedSubbedWaveformPacket_t
Pedsubbed Waveform packet – Telemetered.
Definition: simpleStructs.h:948
PACKET_HD_SLAC
Disused.
Definition: simpleStructs.h:204
SlowRateType1_t
Disused.
Definition: simpleStructs.h:787
GpsGgaStruct_t
ADU5 Postion and Geoid – Telemetered.
Definition: simpleStructs.h:1030
GpuPhiSectorPowerSpectrumStruct_t
Definition: simpleStructs.h:1768
RawSurfChannelHeader_t::firstHitbus
unsigned char firstHitbus
First sample of the hitbus.
Definition: simpleStructs.h:481
ENCODE_LOSSY_MULAW
Done is just a marker for below.
Definition: simpleStructs.h:300
PACKET_AVG_SURF_HK
AveragedSurfHkStruct_t – yes.
Definition: simpleStructs.h:207
FullPedStruct_t
Pedestal utility.
Definition: simpleStructs.h:1731
ENCODE_LOSSLESS_FIBONACCI
Done.
Definition: simpleStructs.h:288
AnitaGeomTool::getChanIndex
static Int_t getChanIndex(Int_t surf, Int_t chan)
Surf + channel to channel index.
Definition: AnitaGeomTool.cxx:468
PACKET_GPS_ADU5_VTG
GpsAdu5VtgStruct_t – Yes.
Definition: simpleStructs.h:223
PACKET_FULL_PED
PedestalStruct_t – No (Too Big)
Definition: simpleStructs.h:220
PACKET_HKD_SS
SSHkDataStruct_t – Yes.
Definition: simpleStructs.h:228
PACKET_GPS_G12_SAT
GpsG12SatStruct_t – Yes.
Definition: simpleStructs.h:225
PACKET_GPU_AVE_POW_SPEC
GpuPhiSectorPowerSpectrum_t – Yes.
Definition: simpleStructs.h:245
RunStart_t
Run Start Block - Telemetered.
Definition: simpleStructs.h:1305
PACKET_GPSD_START
GpsdStartStruct_t – Yes.
Definition: simpleStructs.h:242
PedSubbedSurfPacket_t
Pedestal subtracted SURF wavefom packet – Telemetered.
Definition: simpleStructs.h:969
TurfRateStruct_t
Turf Rates – Telemetered.
Definition: simpleStructs.h:812
SurfChannelPedSubbed_t
A complete pedestal subtracted SURF channel.
Definition: simpleStructs.h:516
LogWatchdStart_t
LogWatchd Start Block – Telemetered.
Definition: simpleStructs.h:1316
PACKET_ZIPPED_PACKET
ZippedPacket_t – Yes.
Definition: simpleStructs.h:238
SurfChannelPedSubbed_t::data
short data[MAX_NUMBER_SAMPLES]
Pedestal subtracted and 11bit data.
Definition: simpleStructs.h:522
unzipBuffer
int unzipBuffer(char *input, char *output, unsigned int inputBytes, unsigned int *outputBytes)
unzipBuffer – utility function
Definition: AnitaPacketUtil.cxx:303
SurfChannelFull_t
A complete SURF channel.
Definition: simpleStructs.h:507
PACKET_PEDSUB_WV
PedSubbedWaveformPacket_t – Yes.
Definition: simpleStructs.h:211
EncodeControlStruct_t
No idea.
Definition: simpleStructs.h:1604
PACKET_GPS_ADU5_SAT
GpsAdu5SatStruct_t – Yes.
Definition: simpleStructs.h:222
PACKET_TURF_REGISTER
TurfRegisterContents_t – probably not.
Definition: simpleStructs.h:209
PACKET_LAB_PED
FullLabChipPedStruct_t – Yes.
Definition: simpleStructs.h:219
FullSurfHkStruct_t
SURF Hk – Telemetered.
Definition: simpleStructs.h:1185
RawSurfPacket_t
Raw SURF wavefom packet – Telemetered.
Definition: simpleStructs.h:959
RawSurfChannelHeader_t::chipIdFlag
unsigned char chipIdFlag
chip id bitmask
Definition: simpleStructs.h:475
zipBuffer
int zipBuffer(char *input, char *output, unsigned int inputBytes, unsigned int *outputBytes)
zipBuffer – utility function
Definition: AnitaPacketUtil.cxx:287
PACKET_CMD_ECHO
CommandEcho_t – Yes.
Definition: simpleStructs.h:229
PACKET_GPS_G12_POS
GpsG12PosStruct_t – Yes.
Definition: simpleStructs.h:224
simplePacketCheck
int simplePacketCheck(GenericHeader_t *gHdr, PacketCode_t code)
simplePacketCheck – utility function
Definition: AnitaPacketUtil.cxx:13
SurfChannelPedSubbed_t::mean
float mean
Filled by pedestalLib.
Definition: simpleStructs.h:520
EncodedSurfChannelHeader_t
Channel header for encoded data.
Definition: simpleStructs.h:496
PACKET_SURF
RawSurfPacket_t – Yes.
Definition: simpleStructs.h:203
PACKET_HD
AnitaEventHeader_t –Yes.
Definition: simpleStructs.h:201
Generated by   doxygen 1.8.14