www.pudn.com > eval-1.2.zip > stat.c

#include 
#include 
#include 
#include 
#include 

#include "def.h"
#include "stat.h"

void CalcDist(dump_t *pD, unsigned l, loss_t *pS)
{
  unsigned long i, j;

  for (i=0; i= CN) j = CN - 1;
    pS->cl[j].size++;

    switch (pD[i].type) {
      case 'I': pS->cl[j].I++; break;
      case 'P': pS->cl[j].P++; break;
      case 'B': pS->cl[j].B++; break;
      default : break;
    }

    if (pD[i].lost) pS->cl[j].lost++;
  }
}

void CalcLoss(dump_t *pD, unsigned l, loss_t *pS, char *id)
{
  FILE *f;
  unsigned long i, w = 0;
  char s[32];

  for (i=0; inH++; if (pD[i].lost) pS->lH++; break;
      case 'I': pS->nI++; if (pD[i].lost) pS->lI++; break;
      case 'P': pS->nP++; if (pD[i].lost) pS->lP++; break;
      case 'B': pS->nB++; if (pD[i].lost) pS->lB++; break;
      default : if (pD[i].lost) w++; break;
    }

  pS->nA = pS->nH + pS->nI + pS->nP + pS->nB;
  pS->lA = pS->lH + pS->lI + pS->lP + pS->lB;

  if (id) {
    sprintf(s, "loss_%s.txt", id);
    if ((f = fopen(s, "w")) == 0) {
      fprintf(stderr, "Could not open %s\n", s);
      return;
    }
    if (!w)
      fprintf(f, "%8.1f%8.1f%8.1f%8.1f\n",
        pS->nI ? 100. * pS->lI / pS->nI : 0,
        pS->nP ? 100. * pS->lP / pS->nP : 0,
        pS->nB ? 100. * pS->lB / pS->nB : 0,
        pS->nA ? 100. * pS->lA / pS->nA : 0);
    else
      fprintf(f, "%8.1f\n", l ? 100. * w / l : 0);
    fclose(f);
  }
}

void CalcJitter(dump_t *pD, unsigned l)
{
	int i, j;
	double tmp;
	
	for (i=0; i=0; j--)
					if (!pD[j].lost) {
						tmp = pD[i].t2 - pD[j].t2;
						break;
					}
			}/* else tmp = pD[i].j1;*/
			
		pD[i].d2 = tmp - pD[i].j1;
	}
	
	pD[0].j1 = 0;
	pD[0].j2 = 0;
}

void CalcDelay(dump_t *pD, unsigned l)
{
	int i, j;
	double tmp;
	
	for (i=0; i=0; j--)
					if (!pD[j].lost) {
						tmp = pD[i].t2 - pD[j].t2;
						break;
					}
			}
		*/
		/* else tmp = pD[i].j1;*/
		/*pD[i].d2 = tmp - pD[i].j1;*/

		if (pD[i].lost == 0)
			pD[i].d2 = pD[i].t2 - pD[i].t1;
		else
			pD[i].d2 = 0.0;
	}
	
	pD[0].j1 = 0;
	pD[0].j2 = 0;
}


#if 0
void CalcJitter(dump_t *pD, unsigned l)
{
  double tb=0, j1=0, j2=0;
  unsigned i, tbi=0;

  if (pD[0].t1 != 0) {
    i = l;
    while (i--) pD[i].j1 = pD[i].t1 - pD[0].t1;
  }

  if (pD[0].t2 != 0) {
    i = l;
    while (i--) pD[i].j2 = pD[i].t2 - pD[0].t2;
  }

  for (i=0; i= tbi ? pD[i-1].t2 + (pD[i].t1 - pD[i-1].t1) : tb;

  for (i=0; i 25) id[25] = 0;

  for (i=0, hist[i] = 0; i max / width) j = max / width;
    hist[j]++;
  }

  if (id) {
    sprintf(s, "jitt_%s", id);
    if ((f = fopen(s, "w")) == 0) {
      fprintf(stderr, "Could not open %s\n", s);
      return;
    }
    for (i=0; i tdrop) F[i].lost = 1, F[i].d2 = F[i-1].d2 + tdrop;
    else F[i].d2 = F[i-1].d2 + (F[i].t2 - F[i-1].t2);

  for (i=0; inF; i++)
    if (!D->F[i].lost && D->F[i].d2 > tdrop)
      D->F[i].lost = 1;
}
#endif

void PoBLoss(data_t *D, unsigned PoB)
{
	double cjit = 0, tdrop = PoB / 1000.;
	unsigned i,j;
	
	j = 0;
	for (i=1; inF; i++) {
		if (j==425)
			printf("here\n");
#ifndef PLAYOUT_TIME_LMTD
		cjit += D->F[i].d2;
#else
		cjit = D->F[i].d2;
#endif
		if (!D->F[i].lost && cjit > tdrop) 
#ifndef PLAYOUT_TIME_LMTD
		{
			D->F[i].lost = 1;
		}
#else
		{
			D->F[i].lost = (int) ((cjit-tdrop)/0.03333)+2;
			D->F[i].play = j + D->F[i].lost - 1; /* Point to which frame instance this frame can be sed */
		}		 
#endif
		if (D->F[i].type != 'H')
			j++;
	}
}

void CalcTime(dump_t *P, unsigned l, char *id)
{
  FILE *f;
  char s[32];

  if (id) {
    sprintf(s, "time_%s", id);
    if ((f = fopen(s, "w")) == 0) {
      fprintf(stderr, "Could not open %s\n", s);
      return;
    }
  } else f = stdout;

  fprintf(f, "%.2f\n", P[l-1].t2 - P[0].t2);

  fclose(f);
}

double avg(avg_t *pD, DIR dir, double start, double end)
{
  int i = 0, j = 0;
  double sum = 0;

  while (i < pD->nP && pD->P[i].t[dir] < start) i++;

  while (i < pD->nP && (pD->P[i].t[dir] < end || pD->P[i].t[dir] == -1 || end == -1)) {
    if (pD->P[i].signal[dir] != -1 && pD->P[i].t[dir] != -1) {
      sum += pD->P[i].signal[dir];
      j++;
    }
    i++;
  }

  return j ? sum / j : 0;
}

double std(avg_t *pD, DIR dir, double start, double end, double mean)
{
  int i = 0, j = 0;
  double v = 0;

  if (mean == DBL_MAX) mean = avg(pD, dir, start, end);

  while (i < pD->nP && pD->P[i].t[dir] < start) i++;

  while (i < pD->nP && (pD->P[i].t[dir] < end || pD->P[i].t[dir] == -1 || end == -1)) {
    if (pD->P[i].signal[dir] != -1 && pD->P[i].t[dir] != -1) {
      v += (pD->P[i].signal[dir] - mean) * (pD->P[i].signal[dir] - mean);
      j++;
    }
    i++;
  }

  return sqrt(j - 1 ? v / (j - 1) : 0);
}

double expsmooth(avg_t *pD, DIR dir, double start, double end, double p)
{
  int i = 0;
  double g = -424242;

  while (i < pD->nP && pD->P[i].t[dir] < start) i++;

  while (i < pD->nP && (pD->P[i].t[dir] < end || pD->P[i].t[dir] == -1 || end == -1)) {
    if (pD->P[i].signal[dir] != -1 && pD->P[i].t[dir] != -1) {
      if (g == -424242) g = pD->P[i].signal[dir];
      else {
        g = p * pD->P[i].signal[dir] + (1 - p) * g;
      }
    }
    i++;
  }

  return g;
}

/*
double min(avg_t *pD, DIR dir, double start, double end)
{
  int i = 0;
  double min;

  while (i < pD->nP && pD->P[i].t[dir] < start) i++;

  min = pD->P[i++].signal[dir];
  while (i < pD->nP && (pD->P[i].t[dir] < end || pD->P[i].t[dir] == -1 || end == -1)) {
    if (pD->P[i].signal[dir] != 0 && pD->P[i].t[dir] != -1) {
      if (pD->P[i].signal[dir] < min)
        min = pD->P[i].signal[dir];
    }
    i++;
  }

  return min;
}

double max(avg_t *pD, DIR dir, double start, double end)
{
  int i = 0;
  double max;

  while (i < pD->nP && pD->P[i].t[dir] < start) i++;

  max = pD->P[i++].signal[dir];
  while (i < pD->nP && (pD->P[i].t[dir] < end || pD->P[i].t[dir] == -1 || end == -1)) {
    if (pD->P[i].signal[dir] != 0 && pD->P[i].t[dir] != -1) {
      if (pD->P[i].signal[dir] > max)
        max = pD->P[i].signal[dir];
    }
    i++;
  }

  return max;
}

void norm(avg_t *pD)
{
  unsigned i;
  double min1, max1, min2, max2;

  MINV(min1, pD, TO_MOBILE, pD->P[0].t[TO_MOBILE], pD->P[pD->nP - 1].t[TO_MOBILE], signal);
  MINV(min2, pD, FROM_MOBILE, pD->P[0].t[FROM_MOBILE], pD->P[pD->nP - 1].t[FROM_MOBILE], signal);
  MAXV(max1, pD, TO_MOBILE, pD->P[0].t[TO_MOBILE], pD->P[pD->nP - 1].t[TO_MOBILE], signal);
  MAXV(max2, pD, FROM_MOBILE, pD->P[0].t[FROM_MOBILE], pD->P[pD->nP - 1].t[FROM_MOBILE], signal);

  MINV(min1, pD, TO_MOBILE, pD->P[0].t[TO_MOBILE], pD->P[pD->nP - 1].t[TO_MOBILE], signal);
  MINV(min2, pD, FROM_MOBILE, pD->P[0].t[FROM_MOBILE], pD->P[pD->nP - 1].t[FROM_MOBILE], signal);
  MAXV(max1, pD, TO_MOBILE, pD->P[0].t[TO_MOBILE], pD->P[pD->nP - 1].t[TO_MOBILE], signal);
  MAXV(max2, pD, FROM_MOBILE, pD->P[0].t[FROM_MOBILE], pD->P[pD->nP - 1].t[FROM_MOBILE], signal);

  min1 = min(pD, TO_MOBILE, pD->P[0].t[TO_MOBILE], pD->P[pD->nP - 1].t[TO_MOBILE]);
  min2 = min(pD, FROM_MOBILE, pD->P[0].t[FROM_MOBILE], pD->P[pD->nP - 1].t[FROM_MOBILE]);
  max1 = max(pD, TO_MOBILE, pD->P[0].t[TO_MOBILE], pD->P[pD->nP - 1].t[TO_MOBILE]);
  max2 = max(pD, FROM_MOBILE, pD->P[0].t[FROM_MOBILE], pD->P[pD->nP - 1].t[FROM_MOBILE]);

  for (i=0; inP; i++) {
    if (pD->P[i].signal[TO_MOBILE])
      pD->P[i].signal[TO_MOBILE] = 2 * (pD->P[i].signal[TO_MOBILE] - min1) / (max1 - min1) - 1;
    if (pD->P[i].signal[FROM_MOBILE])
      pD->P[i].signal[FROM_MOBILE] = 2 * (pD->P[i].signal[FROM_MOBILE] - min2) / (max2 - min2) - 1;
  }
}
*/

void norm1(avg_t *pD, double iv)
{
  unsigned i, j;
  double avg1, avg2;

  i = 0;
  while (i < pD->nP && pD->P[i].t[TO_MOBILE] < iv) i++;

  for (j=i; jnP; j++) {
    avg1 = avg(pD, TO_MOBILE, pD->P[j].t[TO_MOBILE] - iv, pD->P[j].t[TO_MOBILE]);
    if (pD->P[j].signal[TO_MOBILE] != -1 && pD->P[j].t[TO_MOBILE] != -1 && avg1 != 0)
      pD->P[j].avg[TO_MOBILE] = pD->P[j].signal[TO_MOBILE] - avg1;
    else
      pD->P[j].avg[TO_MOBILE] = -424242;
  }

  i = 0;
  while (i < pD->nP && pD->P[i].t[FROM_MOBILE] < iv) i++;

  for (j=i; jnP; j++) {
    avg2 = avg(pD, FROM_MOBILE, pD->P[j].t[FROM_MOBILE] - iv, pD->P[j].t[FROM_MOBILE]);
    if (pD->P[j].signal[FROM_MOBILE] != -1 && pD->P[j].t[FROM_MOBILE] != -1 && avg2 != 0)
      pD->P[j].avg[FROM_MOBILE] = pD->P[j].signal[FROM_MOBILE] - avg2;
    else
      pD->P[j].avg[FROM_MOBILE] = -424242;
  }
}

int pred(avg_t *pD, DIR dir, int n, double hor)
{
  unsigned i = n;

  if (pD->P[n].t[dir] == -1) return -1;

  while (i < pD->nP && (pD->P[i].t[dir] <= pD->P[n].t[dir] + hor + TT || pD->P[i].t[dir] == -1))
    i++;

  --i;

  if (pD->P[i].t[dir] == -1 || pD->P[i].t[dir] <= pD->P[n].t[dir] + hor - TT)
    return -1;

  return i;
}


double KorrKoeff(avg_t *pD, double start, double end)
{
  int i = 0, j = 0, k = 0;
  double avg1, avg2, std1, std2, r = 0;

  avg1 = avg(pD, TO_MOBILE, start, end);
  std1 = std(pD, TO_MOBILE, start, end, avg1);
  avg2 = avg(pD, FROM_MOBILE, start, end);
  std2 = std(pD, FROM_MOBILE, start, end, avg2);

  while (i < pD->nP && pD->P[i].t[TO_MOBILE] < start) i++;
  while (k < pD->nP && pD->P[k].t[FROM_MOBILE] < start) k++;

  while (i < pD->nP && k < pD->nP && pD->P[i].t[TO_MOBILE] < end && pD->P[k].t[FROM_MOBILE] < end) {
    if (pD->P[i].signal[TO_MOBILE] != 0 && pD->P[k].signal[FROM_MOBILE] != 0) {
      r += (pD->P[i].signal[TO_MOBILE] - avg1) * (pD->P[k].signal[FROM_MOBILE] - avg2);
      j++;
    }
    i++;
    k++;
  }

  return j && std1 * std2 ? (r / j) / (std1 * std2) : 0;
}

double AutoKorr(avg_t *pD, double start, double end)
{
  int i = 0, j = 0;
  double a = 0;

  while (i < pD->nP && pD->P[i].t[TO_MOBILE] < start) i++;

  while (i < pD->nP && pD->P[i].t[TO_MOBILE] < end) {
    if (pD->P[i].signal[TO_MOBILE] != 0) {
      a += pD->P[i].signal[TO_MOBILE] * pD->P[j].signal[FROM_MOBILE];
      j++;
    }
    i++;
  }

  return j ? a / j : 0;
}

void Hist(double *D, unsigned l, double min, double max, unsigned interv)
{
  int i, k, *hist, num = 0;
  double cdf = 0;

  if ((hist = calloc(interv, sizeof *hist)) == 0) {
    fprintf(stderr, "malloc error!");
    return;
  }

  for (i=0; i= interv) k = interv - 1;
    ++hist[k];
    ++num;
  }

  for (i=0; i