src/rcv_rtp.c

   1 /*
   2  * Mausezahn - A fast versatile traffic generator
   3  * Copyright (C) 2008-2010 Herbert Haas
   4  *
   5  * This program is free software; you can redistribute it and/or modify it under
   6  * the terms of the GNU General Public License version 2 as published by the
   7  * Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  11  * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
  12  * details.
  13  *
  14  * You should have received a copy of the GNU General Public License along with
  15  * this program; if not, see http://www.gnu.org/licenses/gpl-2.0.html
  16  *
  17 */
  18
  19
  20 ///////////////////////////////////////////////////
  21 //
  22 // Table of contents:
  23 //
  24 // rcv_rtp_init()
  25 // rcv_rtp()
  26 // compare4B()
  27 // got_rtp_packet()
  28 // print_jitterbar()
  29 //
  30
  31 ///////////////////////////////////////////////////
  32 //
  33 // Documentation about RTP traffic analysis
  34 //
  35 // See http://wiki.wireshark.org/RTP_statistics
  36 //
  37 //
  38
  39 #include "mz.h"
  40 #include "mops.h"
  41
  42 // Initialize the rcv_rtp process: Read user parameters and initialize globals
  43 int rcv_rtp_init()
  44 {
  45         char argval[MAX_PAYLOAD_SIZE];
  46         char dummy[512];
  47         int len;
  48         u_int32_t port = 30000;  // 4-byte variable to catch errors, see below
  49
  50         int ssrc_s = 0;
  51
  52         // Help text
  53
  54         if (getarg(tx.arg_string,"help", NULL)==1) {
  55                 fprintf(stderr,"\n"
  56                         MAUSEZAHN_VERSION
  57                 "\n"
  58                 "| RTP reception for jitter measurements.\n"
  59                 "|\n"
  60                 "| Parameters:\n"
  61                 "|\n"
  62                 "|   bar             ...... Display modes: By default 'bar' is used and shows the RFC 3550 jitter as\n"
  63                 "|                          ASCII-based waterfall diagram.\n"
  64                 "|   txt             ...... The 'txt' mode prints all measurement values numerically upon each\n"
  65                 "|                          measurement interval.\n"
  66 //              "|   curse           ...... Shows all values and a diagram within an resizesable ncurses window.\n"
  67                 "|\n"
  68                 "|   ssrc            ....... Listen to the stream with the specified SSRC. You must specify this\n"
  69                 "|                           when there are concurrent streams, e. g. one in each direction.\n"
  70                 "|\n"
  71                 "|   log             ....... Write moving average also in a datafile (not only on terminal).\n"
  72                 "|   logg            ....... Like log but additionally write detailed real-time statistics in a data file\n"
  73                 "|   path = <path>    ....... Path to directory where datafiles can be stored (default: local directory).\n"
  74                 "|   num = <10-%d> ...... number of packets to be received for averaging (default: %d).\n"
  75                 "|   port = <0-65535> ....... Change if RTP packets are sent to a different port than 30000 (default).\n"
  76                 "|\n"
  77                 "| Note:\n"
  78                 "|\n"
  79                 "|  Mausezahn can log actual realtime measurement data in data files (in the specified path or\n"
  80                 "|  current directory) but always prints the moving average on the command line (this can be disabled\n"
  81                 "|  using the 'quiet' option (-q)).\n"
  82                 "|\n"
  83                 "|  The realtime data file(s) consist of two columns:\n"
  84                 "|\n"
  85                 "|  1. relative timestamp in usec\n"
  86                 "|  2. 'true' jitter in usec\n"
  87                 "|\n"
  88                 "|  where the 'true' jitter is calculated using the (relative) timestamps inside the received\n"
  89                 "|  packets t(i) and the (relative) timestamps T(i) observed locally when packets are received using\n"
  90                 "|  the formula:\n"
  91                 "|\n"
  92                 "|    jitter(i) = [T(i) - T(i-1)] - [t(i) - t(i-1)] + jitter(i-1)  .\n"
  93                 "|\n"
  94                 "|  This method has two advantages: (i) we do not need to synchronize the clocks of sender and\n"
  95                 "|  receiver, and (ii) the TX-side jitter (mainly caused by the kernel-scheduler) is subtracted\n"
  96                 "|  so that we primarily measure the jitter caused by the network.\n"
  97                 "|  \n"
  98                 "|  The data files consist of seven columns:\n"
  99                 "|  \n"
 100                 "|  1. relative timestamp in seconds\n"
 101                 "|  2. minimum jitter\n"
 102                 "|  3. average jitter\n"
 103                 "|  4. minimum jitter\n"
 104                 "|  5. estimated jitter variance according RFC-3550\n"
 105                 "|  6. packet drop count (total)\n"
 106                 "|  7. packet disorder count (total)\n"
 107                 "|  \n"
 108                 "|  All measurement values are done in usec and refer to the current set of samples (see parameter 'num').\n"
 109                 "|  Note that an RFC-conform jitter (smoothed mean deviation) is calculated and collected in column five.\n"
 110                 "|  The drop value refers to the current measurement window, while the total drop and disorder values are\n"
 111                 "|  calculated using some weird estimation functions; the goal was to provide a 'time-less' estimation\n"
 112                 "|  while being able to automatically resynchronize to a re-started RTP measurement stream.\n"
 113                 "|  \n"
 114                 "| EXAMPLE USAGE:\n"
 115                 "|\n"
 116                 "|  At the TX-station enter:\n"
 117                 "|\n"
 118                 "|    # mz eth0 -t rtp -B 10.3.3.42    (optionally change rate via -d option, payload size via pld command)\n"
 119                 "|\n"
 120                 "|  At the RX-station (10.3.3.42) enter:\n"
 121                 "|\n"
 122                 "|    # mz eth0 -T rtp \"log, path=/tmp/mz/\"\n"
 123                 "|\n"
 124                 "\n", TIME_COUNT_MAX, TIME_COUNT);
 125         exit(0);
 126         }
 127
 128
 129         // check argstring for arguments
 130
 131         if (getarg(tx.arg_string,"bar", NULL)==1) {
 132                 rtp_dm = BAR;
 133         }
 134
 135         if (getarg(tx.arg_string,"txt", NULL)==1) {
 136                 rtp_dm = TEXT;
 137         }
 138
 139         if (getarg(tx.arg_string,"curses", NULL)==1) {
 140                 rtp_dm = BAR; //NCURSES;
 141                 fprintf(stderr, " XXX This Mausezahn version does not support ncurses windows.\n");
 142         }
 143
 144         if (getarg(tx.arg_string,"width", argval)==1) {
 145                 if (rtp_dm != BAR) {
 146                         fprintf(stderr, " mz/rcv_rtp: The 'width' parameter requires the display mode 'bar'\n");
 147                         return -1;
 148                 }
 149                 bwidth = (int) str2int(argval); // [TODO] bwidth is currently not used
 150                 if (bwidth>RCV_RTP_MAX_BAR_WIDTH) {
 151                         fprintf(stderr, "The width must not exceed %i\n",
 152                                 RCV_RTP_MAX_BAR_WIDTH);
 153                         return -1;
 154                 }
 155         } else bwidth=80;
 156
 157         if (getarg(tx.arg_string,"ssrc", argval)==1) {
 158                 ssrc_s = str2hex(argval, mz_ssrc, 4);
 159                 if (ssrc_s<0) {
 160                         fprintf(stderr, " mz/rtp_rcv: invalid ssrc!\n");
 161                         return -1;
 162                 }
 163         }
 164
 165         if (getarg(tx.arg_string,"log", NULL)==1) {
 166                 rtp_log = 1;
 167         }
 168
 169         if (getarg(tx.arg_string,"logg", NULL)==1) {
 170                 rtp_log = 2;
 171         }
 172
 173
 174         if (getarg(tx.arg_string,"path", argval)==1) {
 175                 len = strlen(argval);
 176                 if (len>128) {
 177                         fprintf(stderr, " mz/Error: path must not exceed 128 characters!\n");
 178                         exit (-1);
 179                 }
 180                 if (argval[len-1]!='/') {
 181                         strncat(argval, "/",1); // ensure that all paths end with "/"
 182                 }
 183                 strncpy(path, argval, 128);
 184         }
 185
 186
 187         if (getarg(tx.arg_string,"num", argval)==1) {
 188                 gind_max = (u_int32_t) str2int(argval);
 189                 if (gind_max > TIME_COUNT_MAX) {
 190                         gind_max = TIME_COUNT_MAX;
 191                         fprintf(stderr, " mz/Warning: num range is 10..%d. Will reset to %d.\n",
 192                                 TIME_COUNT_MAX, TIME_COUNT_MAX);
 193                 }
 194                 else if (gind_max < 10) {
 195                         gind_max = 10;
 196                         fprintf(stderr, " mz/Warning: num range is 10..%d. Will reset to 10.\n",
 197                                 TIME_COUNT_MAX);
 198                 }
 199         }
 200
 201
 202         // initialize global filter string
 203         strncpy (rtp_filter_str, "udp dst port 30000", 64);
 204
 205         if (getarg(tx.arg_string,"port", argval)==1) {
 206                 port = (u_int32_t) str2int(argval);
 207                 if (port>65535) {
 208                         port = 30000;
 209                         fprintf(stderr, " mz: Too large port number! Reset to default port (30000).\n");
 210                 }
 211
 212                 sprintf(rtp_filter_str, "udp dst port %u", (unsigned int) port);
 213         }
 214
 215         //
 216         if (ssrc_s==0) str2hex("ca:fe:fe:ed", mz_ssrc, 4);
 217
 218         // open file
 219         //
 220         if (rtp_log) {
 221                 // get a new filename
 222                 timestamp_human(filename, "rtp_avg_");
 223                 strncpy(dummy, path, 128);
 224                 strncat(dummy, filename, 64);
 225                 if (verbose) fprintf(stderr, " mz: Will open %s\n", dummy);
 226
 227                 fp = fopen (dummy, "w+");
 228
 229                 if (fp == NULL) {
 230                         perror("fopen");
 231                         exit (-1);
 232                 }
 233
 234                 gtotal=0; // counts written data blocks
 235                 fprintf(fp, "# Average jitter measurements made by Mausezahn " MAUSEZAHN_VERSION_SHORT ".\n");
 236                 fprintf(fp, "# Timestamp is in seconds, all other values in microseconds.\n");
 237                 fprintf(fp, "# Column values (from left to right):\n");
 238                 fprintf(fp, "#  1. Timestamp\n"
 239                         "#  2. min_jitter\n"
 240                         "#  3. avg_jitter\n"
 241                         "#  4. max_jitter\n"
 242                         "#  5. estimated jitter according RFC-3550\n"
 243                         "#  6. packet drop count (total)\n"
 244                         "#  7. packet disorder count (total)\n");
 245
 246
 247                 ///////////// also detailed log required /////////////
 248                 if (rtp_log==2) {
 249                         // get a new filename
 250                         timestamp_human(filename, "rtp_rt_");
 251                         strncpy(dummy, path, 128);
 252                         strncat(dummy, filename, 64);
 253                         if (verbose) fprintf(stderr, " mz: Will open %s\n", dummy);
 254
 255                         fp2 = fopen (dummy, "w+");
 256
 257                         if (fp2 == NULL) {
 258                                 perror("fopen");
 259                                 exit (-1);
 260                         }
 261
 262                         fprintf(fp2, "# Jitter measurements by Mausezahn " MAUSEZAHN_VERSION_SHORT ".\n");
 263                         fprintf(fp2, "# Timestamp (usec) , true jitter (nsec)\n");
 264                 }
 265
 266         }
 267
 268         drop=0;
 269         dis=0;
 270         jitter_rfc=0;
 271
 272         return 0;
 273 }
 274
 275
 276
 277
 278
 279
 280
 281 ////////////////////////////////////////////////////////////////////////////////////////////
 282 //
 283 // Defines the pcap handler and the callback function
 284 int rcv_rtp()
 285 {
 286    char   errbuf[PCAP_ERRBUF_SIZE];
 287
 288    pcap_t     *p;
 289
 290    struct bpf_program filter;
 291
 292
 293
 294    p = pcap_open_live (tx.device,
 295                        MAXBYTES_TO_READ,   // max num of bytes to read
 296                        0,                  // 1 if promiscuous mode
 297                        PCAP_READ_TIMEOUT_MSEC,     // read timeout in msec
 298                        errbuf);
 299
 300    if (p == NULL)
 301      {
 302         fprintf(stderr," mz/rcv_rtp: %s\n",errbuf);
 303         exit(1);
 304      }
 305
 306
 307    if ( pcap_compile(p,
 308                      &filter,         // the compiled version of the filter
 309                      rtp_filter_str,  // text version of filter
 310                      0,               // 1 = optimize
 311                      0)               // netmask
 312         == -1)
 313      {
 314         fprintf(stderr," mz/rcv_rtp: Error calling pcap_compile\n");
 315         exit(1);
 316      }
 317
 318
 319
 320    if ( pcap_setfilter(p, &filter) == -1)
 321      {
 322         fprintf(stderr," mz/rcv_rtp: Error setting filter\n");
 323         pcap_geterr(p);
 324         exit(1);
 325      }
 326
 327    again:
 328
 329
 330    pcap_loop (p,
 331               1,                // number of packets to wait
 332               got_rtp_packet,   // name of callback function
 333               NULL);            // optional additional arguments for callback function
 334
 335
 336    goto again;
 337
 338
 339    // TODO: Currently we never reach this point!
 340    fprintf(stderr, " mz: receiving of RTP finished.\n");
 341    pcap_close(p);
 342
 343    return 0;
 344 }
 345
 346
 347
 348
 349 // Compares two 4-byte variables byte by byte
 350 // returns 0 if identical, 1 if different
 351 inline int compare4B (u_int8_t *ip1, u_int8_t *ip2)
 352 {
 353    if (*ip1 != *ip2) return 1;
 354    if (*(ip1+1) != *(ip2+1)) return 1;
 355    if (*(ip1+2) != *(ip2+2)) return 1;
 356    if (*(ip1+3) != *(ip2+3)) return 1;
 357
 358    return 0;
 359 }
 360
 361
 362
 363
 364
 365 // Handler function to do something when RTP messages are received
 366 void got_rtp_packet(u_char *args,
 367                     const struct pcap_pkthdr *header, // statistics about the packet (see 'struct pcap_pkthdr')
 368                     const u_char *packet)             // the bytestring sniffed
 369 {
 370         const struct struct_ethernet *ethernet;
 371         const struct struct_ip       *ip;
 372         const struct struct_udp      *udp;
 373         const struct struct_rtp      *rtp;
 374
 375         int size_ethernet = sizeof(struct struct_ethernet);
 376         int size_ip = sizeof(struct struct_ip);
 377         int size_udp = sizeof(struct struct_udp);
 378         // int size_rtp = sizeof(struct struct_rtp);
 379         //
 380         ethernet = (struct struct_ethernet*)(packet);
 381         ip       = (struct struct_ip*)(packet+size_ethernet);
 382         udp      = (struct struct_udp*)(packet+size_ethernet+size_ip);
 383         rtp      = (struct struct_rtp*)(packet+size_ethernet+size_ip+size_udp);
 384
 385         struct mz_timestamp
 386                 deltaTX,
 387                 deltaRX;
 388
 389         u_int32_t
 390                 i,
 391                 jitter_abs,
 392                 jitter_avg,
 393                 jitter_max,
 394                 jitter_min,
 395                 curtime=0;
 396
 397         int32_t ltemp;
 398
 399         u_int8_t *x,*y;
 400
 401         char dummy[256];
 402         char ts_hms[10];
 403         unsigned char *dum;
 404         static u_int32_t drop_last=0, drop_prev=0;
 405         int s1, s2;
 406
 407         // check if the RTP packet is really from a Mausezahn instance:
 408         if (compare4B((u_int8_t*) &rtp->ssrc, mz_ssrc)==0) {
 409                 // we got a valid RTP packet from a Mausezahn instance
 410                 // Get current SQNR and store it in 'sqnr_cur' in host byte order
 411                 x  = (u_int8_t*) &rtp->sqnr;
 412                 y  = (u_int8_t*) &sqnr_cur;
 413
 414                 *y = *(x+1);
 415                 y++;
 416                 *y = *x;
 417
 418                 /////////////////////////////////////////////////////////////////////
 419                 // Packet drop and disorder detection:
 420                 if (sqnr0_flag) {
 421                         if (sqnr_next==sqnr_cur) {  // correct SQNR received
 422                                 sqnr_next++;
 423                                 sqnr_last++;
 424                         } else if (sqnr_last>sqnr_cur) { // disordered sequence
 425                                 dis++;
 426                                 if (drop) drop--; // don't get below 0
 427                                 else { // drop reached zero: resync (restarted RTP stream?)
 428                                         sqnr_last = sqnr_cur;
 429                                         sqnr_next = (++sqnr_last);
 430                                         dis=0;
 431                                 }
 432                         } else {  // packet drop
 433                                 drop += (sqnr_cur-sqnr_next);
 434                                 sqnr_last = sqnr_cur;
 435                                 sqnr_next = (++sqnr_last);
 436                         }
 437                 } else {
 438                         // initial synchronization with observed SQNR:
 439                         sqnr_last = sqnr_cur;
 440                         sqnr_next = (++sqnr_last);
 441                         sqnr0_flag++;
 442                 }
 443                 //
 444                 /////////////////////////////////////////////////////////////////////
 445
 446
 447                 // Get RX timestamp from pcap header
 448                 timeRX[gind].sec  = header->ts.tv_sec;
 449                 timeRX[gind].nsec = header->ts.tv_usec *1000;
 450
 451                 // Get TX timestamp from the packet
 452                 mops_hton4((u_int32_t*) &rtp->time_sec,  (u_int8_t*) &timeTX[gind].sec);
 453                 mops_hton4((u_int32_t*) &rtp->time_nsec, (u_int8_t*) &timeTX[gind].nsec);
 454
 455 //              printf("%li %li\n", (long int) timeTX[gind].sec, (long int) timeTX[gind].nsec);
 456
 457                 gind++;
 458
 459                 ////////////////////////////////////////////////////////////////
 460                 if (gind == gind_max) { // array full, now calculate statistics
 461                         gind=0;
 462                         gtotal++;
 463
 464                         jitter_avg = 0;
 465                         jitter_min = 0xffffffff;
 466                         jitter_max = 0;
 467
 468
 469                         ///////////////////////////////////////////////////////
 470                         // calculate deltas and jitters
 471                         for (i=2; i<gind_max; i++) { // omit the first 2 data
 472                                                      // entries because of
 473                                                      // artificial high TX-delta!
 474                                                      //
 475                                 ///////////////////////////////////////////////
 476                                 // calculate deltaTX and deltaRX
 477                                 //
 478                                 s1=timestamp_subtract (&timeTX[i], &timeTX[i-1], &deltaTX);
 479                                 s2=timestamp_subtract (&timeRX[i], &timeRX[i-1], &deltaRX);
 480                                 if (s1) fprintf(stderr, " ***  ***\n");
 481
 482                                 // Then calculate the precise jitter by considering
 483                                 // also TX-jitter: (pseudo)jitter = deltaRX - deltaTX,
 484                                 // hence we have positive and negative jitter (delay
 485                                 // deviations) jitter entries are in +/- nanoseconds
 486                                 jitter[i] = (deltaRX.sec*1000000000L + deltaRX.nsec)
 487                                           - (deltaTX.sec*1000000000L + deltaTX.nsec);
 488                                 // Calculate RFC 3550 jitter estimation. According to
 489                                 // that RFC the jitter should be measured in timestamp
 490                                 // units; however currently Mausezahn uses nanoseconds.
 491                                 // (If we want to solve this: G.711 timestamp units are
 492                                 // 125 usec, so jitter/=125 would be sufficient, AFAIK)
 493                                 ltemp = labs(jitter[i]) - jitter_rfc;
 494                                 jitter_rfc += (ltemp>>4);
 495                                 // Add previous pseudojitter to get the true jitter
 496                                 // (See Documentation!)
 497                                 jitter[i] += jitter[i-1];
 498                                 //
 499                                 ////////////////////////////////////////////////
 500
 501
 502
 503
 504                                 ////////////////////////////////////////////////
 505                                 // Determine avg, min, and max jitter within this time frame:
 506                                 jitter_abs = labs(jitter[i]);
 507                                 jitter_avg += jitter_abs;
 508                                 if (jitter_abs < jitter_min) jitter_min = jitter_abs;
 509                                 if (jitter_abs > jitter_max) jitter_max = jitter_abs;
 510                                 //
 511                                 ////////////////////////////////
 512
 513                                 /// PRINT IN FILE_2: Detailed jitter data ///
 514                                 if (rtp_log==2) {
 515                                         // Calculate relative timestamp for column 1 of the datafile
 516                                         curtime = timeRX[i].sec*1000000+timeRX[i].nsec/1000;
 517                                         if (time0_flag) {
 518                                                 curtime = curtime - time0;
 519                                         } else { // this is only done once during the Mausezahn process
 520                                                 time0 = curtime;
 521                                                 time0_flag=1;
 522                                                 curtime = curtime - time0;
 523                                         }
 524                                         fprintf(fp2, "%lu, %li\n",
 525                                                 (long unsigned int) curtime,
 526                                                 (long int) jitter[i]);
 527                                         fflush(fp2); // save everything immediately
 528                                                      // (CHECK if fsync() is additionally needed)
 529                                 }
 530                         } // end for (i=2; i<gind_max; i++)
 531                         //
 532                         ////////////////////////////////////////////////////////
 533
 534
 535                         jitter_avg = jitter_avg / (gind_max-2);    // average true jitter, always positive
 536
 537                         if (drop>=drop_prev) { // because the total drop count may decrease(!) if disordered packets appear lately
 538                                 drop_last = drop - drop_prev;
 539                                 drop_prev=drop;
 540                         } else drop_last=0;
 541
 542                         // PRINT ON CLI: statistics data
 543                         switch (rtp_dm) {
 544                          case TEXT:
 545                                 dum =  (unsigned char*) &ip->src;
 546                                 fprintf(stdout,
 547                                         "Got %u packets from host %u.%u.%u.%u: %lu lost (%lu absolute lost, %lu out of order)\n"
 548                                         "  Jitter_RFC (low pass filtered) = %li usec\n"
 549                                         "  Samples jitter (min/avg/max)   = %lu/%lu/%lu usec\n",
 550                                         gind_max,
 551                                         *(dum),*(dum+1),*(dum+2),*(dum+3),
 552                                         (long unsigned int) drop_last,
 553                                         (long unsigned int) drop,
 554                                         (long unsigned int) dis,
 555                                         (long int) jitter_rfc/1000,
 556                                         (long unsigned int) jitter_min/1000,
 557                                         (long unsigned int) jitter_avg/1000,
 558                                         (long unsigned int) jitter_max/1000);
 559                                 break;
 560
 561                          case BAR:
 562                                 print_jitterbar(jitter_rfc/1000, drop_last);
 563                                 break;
 564
 565                          case NCURSES: // would be nice...?
 566                                 break;
 567
 568                          default:
 569                                 break;
 570                         }
 571
 572                         // Determine whether some packets got lost:
 573                         //
 574                         //
 575                         //
 576                         //
 577
 578
 579
 580                         /// PRINT IN FILE_1: statistics only ///
 581                         if (rtp_log) {
 582                                 ts_hms[0]=0x00;
 583                                 timestamp_hms (ts_hms);
 584                                 fprintf(fp,
 585                                         "%s, %lu, %lu, %lu, %li, %u, %u\n",
 586                                         ts_hms,
 587                                         (long unsigned int) jitter_min/1000,
 588                                         (long unsigned int) jitter_avg/1000,
 589                                         (long unsigned int) jitter_max/1000,
 590                                         (long int) jitter_rfc/1000,
 591                                         drop,
 592                                         dis);
 593                                 fflush(fp);
 594                         }
 595
 596
 597
 598                         // Open another file if current file reaches a limit
 599                         //
 600                         if ((rtp_log==2) && (gtotal>MAX_DATA_BLOCKS)) { // file big enough,
 601                                 gtotal=0;
 602                                 if (fclose(fp2) == EOF) {
 603                                         perror("fclose");
 604                                         exit(1);
 605                                 }
 606
 607                                 if (verbose)
 608                                         fprintf(stderr, " mz: %s written.\n",filename);
 609
 610                                 timestamp_human(filename, "rtp_");  // get a new filename
 611                                 strncpy(dummy, path, 128);
 612                                 strncat(dummy, filename, 64);
 613
 614                                 if (verbose) fprintf(stderr, " mz: Will open %s\n", dummy);
 615
 616                                 if  ( (fp2 = fopen (dummy, "w+")) == NULL) {
 617                                         if (errno != EAGAIN) {
 618                                                 perror("fopen");
 619                                                 exit (-1);
 620                                         }
 621                                 }
 622                                 fprintf(fp2, "# Jitter measurements by Mausezahn "
 623                                         MAUSEZAHN_VERSION_SHORT ".\n");
 624                                 fprintf(fp2, "# Timestamp (usec) , true jitter (nsec)\n");
 625                         }
 626                 } // statistics end *********************************************************************
 627         }
 628 }
 629
 630
 631
 632
 633 void print_jitterbar (long int j, u_int32_t d)
 634 {
 635         // Determine actual data window by considering two events:
 636         //
 637         //  1) window move     (j exceeds lower or upper limit)
 638         //  2) window rescale  (window moves happen too often or the variance
 639         //                      of successive data points is too small)
 640         //
 641         // The most critical value is the chosen resolution (window range),
 642         // especially the _initial_ resolution.
 643
 644         static long int range=0, min=0, max=0, minvar=0, j0=0, dj=0;
 645         static int moved=0, varcount=0, barcount=0;
 646         char str[128], bar[150],
 647                 str1[8], str2[8], str3[8], str4[8];
 648         int event=0, anz;
 649         long int tmp;
 650
 651         // Initialize vars (start with an opened window)
 652         // Note that 'range' is actually half of the window
 653         if (!range) {
 654                 range=j;
 655                 if (range<500) range=500;
 656                 max = j+range;
 657                 min = 0;
 658                 minvar=range/40;
 659                 event++;
 660         } else {
 661                 dj = labs(j-j0);  // no initialization: calculate jitter delta
 662         }
 663
 664         // Move window when borders crossed:
 665         if ((j<min) || (j>max)) {
 666                 max = j + range;
 667                 min = max-2*range;
 668                 if (min<0) {
 669                         min=0;
 670                         range=(max-min)/2;
 671                         fprintf(stdout, "\nNOTE: +- Rescaled window to %4.2f msec\n", (double) range/500);
 672                 }
 673                 moved++;
 674                 event++;
 675                 fprintf(stdout,"\n");
 676 //              printf("move event: min=%li max=%li\n", min, max);
 677         } else {
 678                 if (moved) moved--;
 679 //              printf("normal event: min=%li max=%li\n", min, max);
 680         }
 681
 682
 683         // Increase range when window moved 5 times in a row
 684         if (moved>2) {
 685                 range*=3;
 686                 if (range>10000000L) range=10000000L;
 687                 minvar=range/40;
 688                 if (minvar<1000) minvar=1000;
 689                 max=j+range;
 690                 min=j-range;
 691                 if (min<0) {
 692                         min=0;
 693                         range=(max-min)/2;
 694                 }
 695                 moved=0;
 696                 event++;
 697 //              printf("scale up event: min=%li max=%li\n", min, max);
 698                 fprintf(stdout, "\nNOTE: ++ Rescaled window to %4.2f msec\n", (double) range/500);
 699         }
 700
 701
 702         // Decrease range when jitter deltas are smaller than minvar
 703         // 5 times in a row
 704         if (dj<minvar)
 705                 varcount++;
 706         else
 707                 varcount=0;
 708
 709         if (varcount>5) {
 710                 range*=0.75;
 711                 if (range>j) range=j;
 712                 if (range<500)  {
 713                         range=500;
 714                 }
 715                 minvar=range/40;
 716                 if (minvar<1000) minvar=1000;
 717                 max=j+range;
 718                 min=j-range;
 719                 if (min<0) {
 720                         min=0;
 721                         range=(max-min)/2;
 722                 }
 723                 fprintf(stdout, "\nNOTE: -- Rescaled window to %4.2f msec\n", (double) range/500);
 724                 varcount=0;
 725                 event++;
 726 //              printf("scale down event: min=%li max=%li\n", min, max);
 727         }
 728
 729         j0=j;
 730
 731         barcount++;
 732         if (barcount==24) {
 733                 event=1;
 734                 barcount=0;
 735         }
 736
 737         if (event) {
 738                 tmp=range*0.667;
 739                 sprintf(str1,"%4.2f", (double) min/1000);
 740                 sprintf(str2,"%4.2f", (double) (min+tmp)/1000);
 741                 sprintf(str3,"%4.2f", (double) (max-tmp)/1000);
 742                 sprintf(str4,"%4.2f", (double) max/1000);
 743
 744                 fprintf(stdout,
 745                         "%-6s                   %-6s                    %-6s                    %-6s\n"
 746                         "|-------------------------|-------------------------|-------------------------|\n",
 747                         str1, str2, str3, str4);
 748                 barcount=0;
 749         }
 750
 751         anz = 80*(j-min)/(2*range);
 752         if (anz) {
 753                 memset((void*) str, '#', anz);
 754                 memset((void*) str+anz, ' ', 80-anz);
 755                 str[80]='\0';
 756         }
 757         else {
 758                 memset((void*) str, ' ', 80);
 759                 str[0]='#';
 760                 str[80]='\0';
 761         }
 762         if (d)
 763                 sprintf(bar, "%s%4.2f msec !%lu dropped!", str, (double) j/1000, (unsigned long int) d);
 764         else
 765                 sprintf(bar, "%s%4.2f msec", str, (double) j/1000);
 766
 767         fprintf(stdout,"%s\n", bar);
 768 }
 769