| 1 | #include "brpaqu.h"
|
|---|
| 2 |
|
|---|
| 3 |
|
|---|
| 4 | static inline void bswap4(void* p)
|
|---|
| 5 | {
|
|---|
| 6 | UInt32 tmp = *(UInt32*)p;
|
|---|
| 7 | *(UInt32*)p = ((tmp >> 24) & 0x000000FF) |
|
|---|
| 8 | ((tmp >> 8) & 0x0000FF00) |
|
|---|
| 9 | ((tmp & 0x0000FF00) << 8) |
|
|---|
| 10 | ((tmp & 0x000000FF) << 24);
|
|---|
| 11 | }
|
|---|
| 12 |
|
|---|
| 13 | /* --Methode__ */
|
|---|
| 14 | BRPaquet::BRPaquet(Byte* src, Byte* dst, int paqsz, BRDataFmtConv fgswap)
|
|---|
| 15 | // swapall = true -> on swap tout le paquet, sinon swap entete seulement
|
|---|
| 16 | {
|
|---|
| 17 | dst_ = dst;
|
|---|
| 18 | sz_ = paqsz;
|
|---|
| 19 | if ((src == NULL) || (dst == NULL)) return;
|
|---|
| 20 | // Il faut mettre une protection (throw) si dst==NULL ou sz==0
|
|---|
| 21 |
|
|---|
| 22 | UInt32* src32 = (UInt32*)src;
|
|---|
| 23 | UInt32* dst32 = (UInt32*)dst;
|
|---|
| 24 |
|
|---|
| 25 | switch ( fgswap ) {
|
|---|
| 26 | case BR_DoNothing : // rien a faire
|
|---|
| 27 | break;
|
|---|
| 28 | case BR_Copy : // copie directe
|
|---|
| 29 | memcpy(dst_, src, sz_);
|
|---|
| 30 | break;
|
|---|
| 31 | case BR_Swap32 : // On swappe toutes les donnees du paquet
|
|---|
| 32 | // les bytes sont dans l'ordre par paquet de 4 octets (Int32) , les deux Int32 de
|
|---|
| 33 | // On copie la zone donnees en faisant un byte-swap correspondant a 8 octets (4->8 Reza/firmware SGDMA)
|
|---|
| 34 | for(int ka=0; ka<sz_/4; ka+=2) {
|
|---|
| 35 | dst32[ka] = src32[ka+1];
|
|---|
| 36 | dst32[ka+1] = src32[ka];
|
|---|
| 37 | }
|
|---|
| 38 |
|
|---|
| 39 | break;
|
|---|
| 40 | case BR_SwapAll:
|
|---|
| 41 | for(int ka=0; ka<sz_; ka+=8) {
|
|---|
| 42 | for(int kb=0; kb<4; kb++) {
|
|---|
| 43 | dst_[ka+kb] = src[ka+3-kb+4];
|
|---|
| 44 | dst_[ka+kb+4] = src[ka+3-kb];
|
|---|
| 45 | }
|
|---|
| 46 | }
|
|---|
| 47 | for(int ka=HeaderSize()+DataSize(); ka<sz_; ka+=8) {
|
|---|
| 48 | for(int kb=0; kb<4; kb++) {
|
|---|
| 49 | dst_[ka+kb] = src[ka+3-kb+4];
|
|---|
| 50 | dst_[ka+kb+4] = src[ka+3-kb];
|
|---|
| 51 | }
|
|---|
| 52 | }
|
|---|
| 53 | break;
|
|---|
| 54 | case BR_SwapHDR :
|
|---|
| 55 | case BR_FFTOneChan :
|
|---|
| 56 | case BR_FFTTwoChan :
|
|---|
| 57 | // ByteSwap 8 (4->8 Reza/firmware SGDMA) de l'enete
|
|---|
| 58 | for(int ka=0; ka<BRHDRSIZE; ka+=8) {
|
|---|
| 59 | for(int kb=0; kb<4; kb++) {
|
|---|
| 60 | dst_[ka+kb] = src[ka+3-kb+4];
|
|---|
| 61 | dst_[ka+kb+4] = src[ka+3-kb];
|
|---|
| 62 | }
|
|---|
| 63 | }
|
|---|
| 64 |
|
|---|
| 65 | if (fgswap == BR_FFTOneChan) ReorderFFTData(src+HeaderSize(), dst_+HeaderSize(), DataSize());
|
|---|
| 66 | else if (fgswap == BR_FFTTwoChan) {
|
|---|
| 67 | ReorderFFTData(src+HeaderSize(), dst_+HeaderSize(), DataSize()/2);
|
|---|
| 68 | ReorderFFTData(src+HeaderSize()+DataSize()/2, dst_+HeaderSize()+DataSize()/2, DataSize()/2);
|
|---|
| 69 | }
|
|---|
| 70 | for(int ka=HeaderSize()+DataSize(); ka<sz_; ka+=8) {
|
|---|
| 71 | for(int kb=0; kb<4; kb++) {
|
|---|
| 72 | dst_[ka+kb] = src[ka+3-kb+4];
|
|---|
| 73 | dst_[ka+kb+4] = src[ka+3-kb];
|
|---|
| 74 | }
|
|---|
| 75 | }
|
|---|
| 76 | break;
|
|---|
| 77 |
|
|---|
| 78 | case BR_FFTOneChan32 :
|
|---|
| 79 | case BR_FFTTwoChan32 :
|
|---|
| 80 | // on swappe tout en attendant le swap general sinon il faut encore créer une fonctiondifferente de ReorderFFT
|
|---|
| 81 | // swapp du header uniquement
|
|---|
| 82 | for(int ka=0; ka<BRHDRSIZE/4; ka+=2) {
|
|---|
| 83 | dst32[ka] = src32[ka+1];
|
|---|
| 84 | dst32[ka+1] = src32[ka];
|
|---|
| 85 | }
|
|---|
| 86 |
|
|---|
| 87 | // on reoordonne et on swappe en mem temps
|
|---|
| 88 | if (fgswap == BR_FFTOneChan32) ReorderFFTData32(src+HeaderSize(), dst_+HeaderSize(), DataSize());
|
|---|
| 89 | else if (fgswap == BR_FFTTwoChan32) {
|
|---|
| 90 | ReorderFFTData32(src+HeaderSize(), dst_+HeaderSize(), DataSize()/2);
|
|---|
| 91 | ReorderFFTData32(src+HeaderSize()+DataSize()/2, dst_+HeaderSize()+DataSize()/2, DataSize()/2);
|
|---|
| 92 | }
|
|---|
| 93 | // swap du trailler uniquement
|
|---|
| 94 | for(int ka=(HeaderSize()+DataSize())/4;ka < sz_/4; ka+=2) {
|
|---|
| 95 | dst32[ka] = src32[ka+1];
|
|---|
| 96 | dst32[ka+1] = src32[ka];
|
|---|
| 97 | }
|
|---|
| 98 |
|
|---|
| 99 | case BR_FFTOneChanNoSwap :
|
|---|
| 100 | case BR_FFTTwoChanNoSwap :
|
|---|
| 101 | // on a plus de swapdonc il faut copier dans dst
|
|---|
| 102 | memcpy(dst_, src, sz_);
|
|---|
| 103 | // on reoordonne et on swappe en mem temps
|
|---|
| 104 | if (fgswap == BR_FFTOneChanNoSwap) ReorderFFTDataNoSwap(src+HeaderSize(), dst_+HeaderSize(), DataSize());
|
|---|
| 105 | else if (fgswap == BR_FFTTwoChanNoSwap) {
|
|---|
| 106 | ReorderFFTDataNoSwap(src+HeaderSize(), dst_+HeaderSize(), DataSize()/2);
|
|---|
| 107 | ReorderFFTDataNoSwap(src+HeaderSize()+DataSize()/2, dst_+HeaderSize()+DataSize()/2, DataSize()/2);
|
|---|
| 108 | }
|
|---|
| 109 |
|
|---|
| 110 | break;
|
|---|
| 111 | } // Fin switch
|
|---|
| 112 |
|
|---|
| 113 | }
|
|---|
| 114 |
|
|---|
| 115 | /* --Methode__ */
|
|---|
| 116 | BRPaquet::BRPaquet(Byte* srcdst, int paqsz)
|
|---|
| 117 | {
|
|---|
| 118 | dst_ = srcdst;
|
|---|
| 119 | sz_ = paqsz;
|
|---|
| 120 | // Il faut mettre une protection (throw) si srcdst==NULL ou sz==0
|
|---|
| 121 | }
|
|---|
| 122 |
|
|---|
| 123 |
|
|---|
| 124 | /* --Methode__ */
|
|---|
| 125 | UInt16 BRPaquet::ChannelID()
|
|---|
| 126 | {
|
|---|
| 127 |
|
|---|
| 128 | UInt16 ChnId=ChanId();
|
|---|
| 129 | UInt16 ChpId=ChipId();
|
|---|
| 130 |
|
|---|
| 131 |
|
|---|
| 132 | if (ChpId == 2)
|
|---|
| 133 | {
|
|---|
| 134 | if (ChnId == 1) ChnId = Ch3;
|
|---|
| 135 | if (ChnId == 2) ChnId = Ch4;
|
|---|
| 136 | if (ChnId == 3) ChnId = Ch3_4;
|
|---|
| 137 | }
|
|---|
| 138 | return(ChnId);
|
|---|
| 139 | }
|
|---|
| 140 |
|
|---|
| 141 | /* --Methode__ */
|
|---|
| 142 | UInt16 BRPaquet::ModeAcquisition()
|
|---|
| 143 | {
|
|---|
| 144 | UInt16 ModAq;
|
|---|
| 145 | printf("Mod Acq %x \n",ModeAcq());
|
|---|
| 146 | ModAq = ((ModeAcq() & 0x30)>> 4);
|
|---|
| 147 | return(ModAq);
|
|---|
| 148 |
|
|---|
| 149 | }
|
|---|
| 150 |
|
|---|
| 151 | /* --Methode__ */
|
|---|
| 152 | void BRPaquet::Print(ostream & os, int nelt, bool prht)
|
|---|
| 153 | {
|
|---|
| 154 | os << endl << "BRPaquet::Print() PaqSz=" << PaquetSize() << " DataSize=" << DataSize()
|
|---|
| 155 | << " dst_pointer=(hex)" << hex << (unsigned long)dst_ << dec << endl;
|
|---|
| 156 | if (dst_ == NULL) {
|
|---|
| 157 | os << " ...NULL paquet " << endl;
|
|---|
| 158 | return;
|
|---|
| 159 | }
|
|---|
| 160 |
|
|---|
| 161 | os << endl << " BR AcqMode: " << ModeAcquisition() << " Channel: " << ChannelID() << endl;
|
|---|
| 162 |
|
|---|
| 163 | if (TrailerSize() > 0)
|
|---|
| 164 | os << " ...HDRMarker(hex)=" << hex << HDRMarker() << " TRLMarker=" << TRLMarker() << dec << endl;
|
|---|
| 165 | else
|
|---|
| 166 | os << " ...HDRMarker(hex)=" << hex << HDRMarker() << " NO TRLMarker=" << dec << endl;
|
|---|
| 167 | UInt32 tt1, tt2;
|
|---|
| 168 | tt2 = TimeTag1();
|
|---|
| 169 | tt1 = TimeTag2();
|
|---|
| 170 | os << " ...TimeTag (hex)=" << hex << "TimeTag()" << " TT1= " << tt1 << " TT2=" << tt2 << dec << endl;
|
|---|
| 171 | // os << " ...Position Chariot (hex)= " << hex << PositionChariot() << endl;
|
|---|
| 172 | if (nelt > DataSize()/2) nelt = DataSize()/2;
|
|---|
| 173 | os << " ...Data[1.." << nelt << "]= ";
|
|---|
| 174 |
|
|---|
| 175 | for(int k=0; k<nelt; k++) os << (int)(*(Data1()+k)) << " , ";
|
|---|
| 176 | os << endl;
|
|---|
| 177 | os << " ...Data[" << DataSize()-nelt << ".." << DataSize()-1 << "]= ";
|
|---|
| 178 | for(int k=DataSize()-nelt; k<DataSize(); k++) os << (int)(*(Data1()+k)) << " , ";
|
|---|
| 179 | os << endl;
|
|---|
| 180 | if (prht) { // Impression header / trailer
|
|---|
| 181 | UInt32* hdr = (UInt32*)Header();
|
|---|
| 182 | os << " ...Header (hex):" << hex ;
|
|---|
| 183 | for(int k=0; k<HeaderSize()/sizeof(UInt32); k++)
|
|---|
| 184 | os << hdr[k] << " , " ;
|
|---|
| 185 | os << dec << endl;
|
|---|
| 186 | if (TrailerSize() > 0) {
|
|---|
| 187 | UInt32* trl = (UInt32*)Trailer();
|
|---|
| 188 | os << " ...Trailer (hex):" << hex ;
|
|---|
| 189 | for(int k=0; k<TrailerSize()/sizeof(UInt32); k++)
|
|---|
| 190 | os << trl[k] << " , " ;
|
|---|
| 191 | os << dec << endl;
|
|---|
| 192 | }
|
|---|
| 193 | }
|
|---|
| 194 | }
|
|---|
| 195 |
|
|---|
| 196 |
|
|---|
| 197 | // ---------------------------------------------------------
|
|---|
| 198 | // **** REMARQUE N/2+1 complexes -> N/2 complexes *****
|
|---|
| 199 | // N = Nb d'echantillon en temps -> N/2 paires (real, imag)
|
|---|
| 200 | // Il y a le continu, et N/2 frequences ---> N/2+1 nombres complexes,
|
|---|
| 201 | // mais avec la contrainte Z(0).imag = 0 Z(N/2).imag = 0
|
|---|
| 202 | // f(i) i=0...N-1 ===> Z(k) ( Z complexe , k=0...N/2 )
|
|---|
| 203 | // mais avec la contrainte Z(0).imag = 0 Z(N/2).imag = 0
|
|---|
| 204 | // On peut donc tout mettre ds N/2 complexes en choisissant
|
|---|
| 205 | // de mettre ds Z(0).imag Z(N/2).real
|
|---|
| 206 | // ----------------------------------------------------------
|
|---|
| 207 |
|
|---|
| 208 | // Fonction magique qui donne le pointeur permettant de tenir compte du byte-swp sur 8 octets
|
|---|
| 209 | static inline int IndexByteSwap8(int idx)
|
|---|
| 210 | {
|
|---|
| 211 | return ( (idx-(idx%8))+(7-idx%8) ) ;
|
|---|
| 212 | }
|
|---|
| 213 |
|
|---|
| 214 | /* --Methode__ */
|
|---|
| 215 | void BRPaquet::ReorderFFTData(Byte* src, Byte* dst, int N)
|
|---|
| 216 | {
|
|---|
| 217 | // Code recopie depuis /Dev/DisplayData/HistoWindow.cc
|
|---|
| 218 | // fonction TraceWind::DisplayBaoDatasFFT() et adapte aux structures BRPaquet et Cie
|
|---|
| 219 | // Modif par rapport au code de Bruno : N/2 elements complexes au lieu de N/2+1 - Remarque ci-dessus
|
|---|
| 220 |
|
|---|
| 221 | int nCoef = N / 2; // to change
|
|---|
| 222 | int debutIndex = N / 4 + 1;
|
|---|
| 223 | int fifoSize = N / 4 - 1;
|
|---|
| 224 | int i;
|
|---|
| 225 |
|
|---|
| 226 | TwoByteComplex* dstcmplx = (TwoByteComplex*)dst;
|
|---|
| 227 |
|
|---|
| 228 | // cout << " Display BAO Datas FFT (" << N << ")" << " : from 0 to "<< nCoef << endl;
|
|---|
| 229 | // cout << " Variables : debutIndex, fifoSize " << debutIndex << ", " << fifoSize << endl;
|
|---|
| 230 |
|
|---|
| 231 |
|
|---|
| 232 | // Sortie 1
|
|---|
| 233 | for (i = 0; i < fifoSize ; i++)
|
|---|
| 234 | {
|
|---|
| 235 | dstcmplx[debutIndex + i].realB() = src[IndexByteSwap8(2*i)];
|
|---|
| 236 | dstcmplx[debutIndex + i].imagB() = src[IndexByteSwap8(2*i + 1)];
|
|---|
| 237 | }
|
|---|
| 238 |
|
|---|
| 239 | // element au milieu
|
|---|
| 240 | dstcmplx[N / 4].realB() = src[IndexByteSwap8(2*fifoSize)];
|
|---|
| 241 | dstcmplx[N / 4].imagB() = src[IndexByteSwap8(2*fifoSize + 1)];
|
|---|
| 242 |
|
|---|
| 243 | // Sortie 2
|
|---|
| 244 | for (i = 0; i < fifoSize ; i++)
|
|---|
| 245 | {
|
|---|
| 246 | dstcmplx[fifoSize - i].realB() = src[IndexByteSwap8(nCoef + 2*i)];
|
|---|
| 247 | dstcmplx[fifoSize - i].imagB() = src[IndexByteSwap8(nCoef + 2*i + 1)];
|
|---|
| 248 | }
|
|---|
| 249 |
|
|---|
| 250 | // k = 0 et k = N/2
|
|---|
| 251 | dstcmplx[0].realB() = src[IndexByteSwap8(N - 2)];
|
|---|
| 252 | // Voir Remarque ci-dessus Z(N/2).real -> Z(0).image
|
|---|
| 253 | dstcmplx[0].imagB() = src[IndexByteSwap8(N - 1)]; // Attention, on met ici la real(fmax)
|
|---|
| 254 |
|
|---|
| 255 | return ;
|
|---|
| 256 | }
|
|---|
| 257 |
|
|---|
| 258 | static inline int IndexByteSwap8_32(int idx)
|
|---|
| 259 | {
|
|---|
| 260 | return ( (idx-(idx%8))+((4+idx%8)%8) ) ;
|
|---|
| 261 | }
|
|---|
| 262 |
|
|---|
| 263 | void BRPaquet::ReorderFFTData32(Byte* src, Byte* dst, int N)
|
|---|
| 264 | {
|
|---|
| 265 | // Code recopie depuis /Dev/DisplayData/HistoWindow.cc
|
|---|
| 266 | // fonction TraceWind::DisplayBaoDatasFFT() et adapte aux structures BRPaquet et Cie
|
|---|
| 267 | // Modif par rapport au code de Bruno : N/2 elements complexes au lieu de N/2+1 - Remarque ci-dessus
|
|---|
| 268 |
|
|---|
| 269 | int nCoef = N / 2; // to change
|
|---|
| 270 | int debutIndex = N / 4 + 1;
|
|---|
| 271 | int fifoSize = N / 4 - 1;
|
|---|
| 272 | int i;
|
|---|
| 273 |
|
|---|
| 274 | TwoByteComplex* dstcmplx = (TwoByteComplex*)dst;
|
|---|
| 275 |
|
|---|
| 276 | // cout << " Display BAO Datas FFT (" << N << ")" << " : from 0 to "<< nCoef << endl;
|
|---|
| 277 | // cout << " Variables : debutIndex, fifoSize " << debutIndex << ", " << fifoSize << endl;
|
|---|
| 278 |
|
|---|
| 279 |
|
|---|
| 280 | // Sortie 1
|
|---|
| 281 | for (i = 0; i < fifoSize ; i++)
|
|---|
| 282 | {
|
|---|
| 283 | dstcmplx[debutIndex + i].realB() = src[IndexByteSwap8_32(2*i)];
|
|---|
| 284 | dstcmplx[debutIndex + i].imagB() = src[IndexByteSwap8_32(2*i + 1)];
|
|---|
| 285 | }
|
|---|
| 286 |
|
|---|
| 287 | // element au milieu
|
|---|
| 288 | dstcmplx[N / 4].realB() = src[IndexByteSwap8_32(2*fifoSize)];
|
|---|
| 289 | dstcmplx[N / 4].imagB() = src[IndexByteSwap8_32(2*fifoSize + 1)];
|
|---|
| 290 |
|
|---|
| 291 | // Sortie 2
|
|---|
| 292 | for (i = 0; i < fifoSize ; i++)
|
|---|
| 293 | {
|
|---|
| 294 | dstcmplx[fifoSize - i].realB() = src[IndexByteSwap8_32(nCoef + 2*i)];
|
|---|
| 295 | dstcmplx[fifoSize - i].imagB() = src[IndexByteSwap8_32(nCoef + 2*i + 1)];
|
|---|
| 296 | }
|
|---|
| 297 |
|
|---|
| 298 | // k = 0 et k = N/2
|
|---|
| 299 | dstcmplx[0].realB() = src[IndexByteSwap8_32(N - 2)];
|
|---|
| 300 | // Voir Remarque ci-dessus Z(N/2).real -> Z(0).image
|
|---|
| 301 | dstcmplx[0].imagB() = src[IndexByteSwap8_32(N - 1)]; // Attention, on met ici la real(fmax)
|
|---|
| 302 |
|
|---|
| 303 | return ;
|
|---|
| 304 | }
|
|---|
| 305 | void BRPaquet::ReorderFFTDataNoSwap(Byte* src, Byte* dst, int N)
|
|---|
| 306 | {
|
|---|
| 307 | // Code recopie depuis /Dev/DisplayData/HistoWindow.cc
|
|---|
| 308 | // fonction TraceWind::DisplayBaoDatasFFT() et adapte aux structures BRPaquet et Cie
|
|---|
| 309 | // Modif par rapport au code de Bruno : N/2 elements complexes au lieu de N/2+1 - Remarque ci-dessus
|
|---|
| 310 |
|
|---|
| 311 | int nCoef = N / 2; // to change
|
|---|
| 312 | int debutIndex = N / 4 + 1;
|
|---|
| 313 | int fifoSize = N / 4 - 1;
|
|---|
| 314 | int i;
|
|---|
| 315 |
|
|---|
| 316 | TwoByteComplex* dstcmplx = (TwoByteComplex*)dst;
|
|---|
| 317 |
|
|---|
| 318 | // cout << " Display BAO Datas FFT (" << N << ")" << " : from 0 to "<< nCoef << endl;
|
|---|
| 319 | // cout << " Variables : debutIndex, fifoSize " << debutIndex << ", " << fifoSize << endl;
|
|---|
| 320 |
|
|---|
| 321 |
|
|---|
| 322 | // Sortie 1
|
|---|
| 323 | for (i = 0; i < fifoSize ; i++)
|
|---|
| 324 | {
|
|---|
| 325 | dstcmplx[debutIndex + i].realB() = src[(2*i)];
|
|---|
| 326 | dstcmplx[debutIndex + i].imagB() = src[(2*i + 1)];
|
|---|
| 327 | }
|
|---|
| 328 |
|
|---|
| 329 | // element au milieu
|
|---|
| 330 | dstcmplx[N / 4].realB() = src[(2*fifoSize)];
|
|---|
| 331 | dstcmplx[N / 4].imagB() = src[(2*fifoSize + 1)];
|
|---|
| 332 |
|
|---|
| 333 | // Sortie 2
|
|---|
| 334 | for (i = 0; i < fifoSize ; i++)
|
|---|
| 335 | {
|
|---|
| 336 | dstcmplx[fifoSize - i].realB() = src[(nCoef + 2*i)];
|
|---|
| 337 | dstcmplx[fifoSize - i].imagB() = src[(nCoef + 2*i + 1)];
|
|---|
| 338 | }
|
|---|
| 339 |
|
|---|
| 340 | // k = 0 et k = N/2
|
|---|
| 341 | dstcmplx[0].realB() = src[(N - 2)];
|
|---|
| 342 | // Voir Remarque ci-dessus Z(N/2).real -> Z(0).image
|
|---|
| 343 | dstcmplx[0].imagB() = src[(N - 1)]; // Attention, on met ici la real(fmax)
|
|---|
| 344 |
|
|---|
| 345 | return ;
|
|---|
| 346 | }
|
|---|
| 347 |
|
|---|
| 348 | /* --Methode__ */
|
|---|
| 349 | const char* BRPaquet::FmtConvToString(BRDataFmtConv fgswap)
|
|---|
| 350 | {
|
|---|
| 351 | const char * rs="";
|
|---|
| 352 | switch ( fgswap ) {
|
|---|
| 353 | case BR_DoNothing :
|
|---|
| 354 | rs = "BR_DoNothing";
|
|---|
| 355 | break;
|
|---|
| 356 | case BR_Copy :
|
|---|
| 357 | rs = "BR_Copy";
|
|---|
| 358 | break;
|
|---|
| 359 | case BR_SwapAll :
|
|---|
| 360 | rs = "BR_SwapAll";
|
|---|
| 361 | break;
|
|---|
| 362 | case BR_SwapHDR :
|
|---|
| 363 | rs = "BR_SwapHDR";
|
|---|
| 364 | break;
|
|---|
| 365 | case BR_FFTOneChan :
|
|---|
| 366 | rs = "BR_FFTOneChan";
|
|---|
| 367 | break;
|
|---|
| 368 | case BR_FFTTwoChan :
|
|---|
| 369 | rs = "BR_FFTTwoChan";
|
|---|
| 370 | break;
|
|---|
| 371 | case BR_Swap32 :
|
|---|
| 372 | rs = "BR_Swap32";
|
|---|
| 373 | break;
|
|---|
| 374 | case BR_FFTOneChan32 :
|
|---|
| 375 | rs = "BR_FFTOneChan32";
|
|---|
| 376 | break;
|
|---|
| 377 | case BR_FFTTwoChan32 :
|
|---|
| 378 | rs = "BR_FFTTwoChan32";
|
|---|
| 379 | break;
|
|---|
| 380 | case BR_FFTOneChanNoSwap :
|
|---|
| 381 | rs = "BR_FFTOneChanNoSwap";
|
|---|
| 382 | break;
|
|---|
| 383 | case BR_FFTTwoChanNoSwap :
|
|---|
| 384 | rs = "BR_FFTTwoChanNoSwap";
|
|---|
| 385 | break;
|
|---|
| 386 | default:
|
|---|
| 387 | rs = "?????";
|
|---|
| 388 | break;
|
|---|
| 389 | } // Fin switch
|
|---|
| 390 | return rs;
|
|---|
| 391 | }
|
|---|
| 392 |
|
|---|
| 393 | // --------------------------------------------------------------------------
|
|---|
| 394 | // Classe pour effectuer des verifications d'integrite sur les paquets/frames
|
|---|
| 395 | // --------------------------------------------------------------------------
|
|---|
| 396 |
|
|---|
| 397 | BRPaqChecker::BRPaqChecker()
|
|---|
| 398 | {
|
|---|
| 399 | totnframes = 0;
|
|---|
| 400 | nframeok = 0;
|
|---|
| 401 | lostframes = 0;
|
|---|
| 402 | frclst = 0;
|
|---|
| 403 | }
|
|---|
| 404 |
|
|---|
| 405 | BRPaqChecker::~BRPaqChecker()
|
|---|
| 406 | {
|
|---|
| 407 | }
|
|---|
| 408 |
|
|---|
| 409 | bool BRPaqChecker::Check(BRPaquet& paq)
|
|---|
| 410 | {
|
|---|
| 411 | totnframes++;
|
|---|
| 412 | if (paq.HDRMarker() != 0x76543210) return false;
|
|---|
| 413 | unsigned int curfc = paq.FrameCounter();
|
|---|
| 414 | unsigned int delfc = 0;
|
|---|
| 415 | if (nframeok > 0) {
|
|---|
| 416 | if (curfc>frclst) delfc = (curfc-frclst);
|
|---|
| 417 | else delfc = (65535-frclst+curfc);
|
|---|
| 418 | lostframes += (unsigned long long)delfc - 1;
|
|---|
| 419 | }
|
|---|
| 420 | nframeok++; frclst = curfc;
|
|---|
| 421 | return true;
|
|---|
| 422 | }
|
|---|
| 423 |
|
|---|
| 424 | ostream& BRPaqChecker::Print(ostream& os)
|
|---|
| 425 | {
|
|---|
| 426 | os << "BRPaqChecker: Tot.Nb.Frames.Proc=" << totnframes << " NbFrameOK=" << nframeok
|
|---|
| 427 | << " LostFrames=" << lostframes
|
|---|
| 428 | << " Loss=" << (double)lostframes*100./(double)totnframes << " %" << endl;
|
|---|
| 429 | return os;
|
|---|
| 430 | }
|
|---|
![(please configure the [header_logo] section in trac.ini)](/PI/chrome/site/your_project_logo.png){kind=logo}
