#include <windows.h>
#include <stdio.h>
#include <errno.h>    
#include <srllib.h>
#include <dxxxlib.h>

/* firmware parameters that need to be changed to correct
** the problem of poor PAMD performance with digital lines
**
** NOTE: DO NOT ATTEMPT TO MODIFY THIS PARAMETERS TO ANY OTHER VALUES 
**
*/
#define PAMD_TEMPLID	11
#define PVD_TEMPLID	5

#define MAX_STRING_SIZE 1000

int printSummary();

int chg_qpamd();
int chg_qpvd();

int get_qpamd();
int get_qpvd();

int def_qpamd();
int def_qpvd();

int qminsnr, qmaxsnr, maxpk, maxring, ringthres, pvdwin, pvdthresh, pvdrblow, pvdrbhig = 0;
int maxansiz, maxans2, maxans3, lohiss, hihiss, bhparm, cvthr1, cvthr2, maxcvth, nmaxbrod, nmaxerg, maxsil, voice_thres, sil_thres, bandf_low, bandf_high = 0;

FILE *infstream;
char line[MAX_STRING_SIZE];
char tmplType[7];


TN_QLT tn_qlt;

//  Help Screen information

char  *helpscr[]={
   "Qualification Utility Program",
   "",
   "qual [option_list]",
   "",
   "Options:",
   "",
   "  -?         =  Display this help screen",
   "  -b<num>    =  Starting board num - default = dxxxB1",
   "  -n<num>    =  Number if voice channels",
   "  -g         =  Get PAMD and PVD parameter",
   "  -s         =  Set PAMD and PVD parameter to definitions in .inf",
   "  -d         =  Set PAMD and PVD parameter to default",
   ""
   
};

// End of Help Screen

void options(int argc, char **argv);

int DevCount = 1;
int setqual = 0;
int getqual = 0;
int defqual = 0;
int ukqual = 0;
int startVox = 1; 

void main(int argc, char *argv[]) 
{
	int PVDQualDone = 0, PAMDQualDone = 0;
	int dev, i, index, num_params;
	char devName[10];


	
//checking options
	options(argc, argv);
	
	if( (infstream = fopen( "PVDPAMDQual.inf", "r" )) == NULL )
	{
		printf( "The file 'data' was not opened\n" );
	}

	if (infstream == NULL) {
		printf("Unable to open PVDPAMDQual for read\n");
		perror("Reason is: ");
		exit(1);
	}

	while (fgets(line, MAX_STRING_SIZE, infstream))
	{
		/* strip trailing white space */
		index = strlen(line) - 1;
		while (index && (line[index] <= ' '))
		{
			line[index] = '\0';
			index--;
		}

		/* ignore blank lines */
		if (index == 0) {
			continue;
		}

		if (line[0] == '#')
			continue;

		num_params = sscanf(line, "%s", tmplType);
		if (strcmp(tmplType, "<PVD>") == 0)
		{
			/* Parse PVD qualification parameters */ 
			num_params = sscanf(line, "%s%d%d%d%d%d%d%d%d%d",
				tmplType,
				&qminsnr,
				&qmaxsnr,
				&maxpk,
				&maxring,
				&ringthres,
				&pvdwin,
				&pvdthresh,
				&pvdrblow,
				&pvdrbhig);
			PVDQualDone = 1;
		}
		if (strcmp(tmplType, "<PAMD>") == 0)
		{
			/* Parse PVD qualification parameters */ 
			num_params = sscanf(line, "%s%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d",
				tmplType,
				&maxansiz,
				&maxans2,
				&maxans3,
				&lohiss,
				&hihiss,
				&bhparm,
				&cvthr1,
				&cvthr2,
				&maxcvth,
				&nmaxbrod,
				&nmaxerg,
				&maxsil,
				&voice_thres,
				&sil_thres,
				&bandf_low,
				&bandf_high);
			PAMDQualDone = 1;
		}
		if ((PAMDQualDone) && (PVDQualDone))
			break;
	}



	for (i=startVox; i<(DevCount+startVox); i++)
	{
		if(startVox < 1)
			exit(1);

		sprintf(devName, "dxxxB%d", i); 
		if((dev = dx_open(devName,0)) == -1)
		{
			printf("error %d opening %s\n",errno,devName);
			exit(1);
		}
	
		if (defqual == 1)
		{
			if (def_qpvd(dev) == -1)
			{
				printf("Error on get_qpvd - Exiting\n");
				exit(0);
			}
			if (def_qpamd(dev) == -1)
			{
				printf("Error on get_qpamd - Exiting\n");
				exit(0);
			}
		}

		if (getqual == 1)
		{
		//	if (get_qpvd(dev) == -1)
		//	{
		//		printf("Error on get_qpvd - Exiting\n");
		//		exit(0);
		//	}
			
		//	if (get_qpamd(dev) == -1)
		//	{
		//		printf("Error on get_qpamd - Exiting\n");
		//		exit(0);
		//	}

		//	if (printSummary(dev) == -1)
		//	{
		//		printf("Error on get PVD/PAMD - Exiting\n");
		//	}

		}

		if (setqual == 1)
		{
			if (chg_qpvd(dev) == -1)
			{
				printf("Error on get_qpvd - Exiting\n");
				exit(0);
			}

			if (chg_qpamd(dev) == -1)
			{
				printf("Error on get_qpamd - Exiting\n");
				exit(0);
			}
		}
	
		if (printSummary(dev) == -1)
			{
				printf("Error on get PVD/PAMD - Exiting\n");
			}

		dx_close(dev);
	}
	printf("Process complete\n\n");


}// end of main



/****************************************************************
*        NAME : chg_qpvd(dev)
* DESCRIPTION : change qualification template 5 
*       INPUT : chdev = channel number
*      OUTPUT : none
*     RETURNS : none
****************************************************************/
chg_qpvd(int dev)
{
  int qual_template;  /* qualification template number */

  qual_template = PVD_TEMPLID;
  
  if((dx_getqualtmplate(dev,qual_template,&tn_qlt))==-1)
  {
    printf("getqual failed \n");
    printf("%s \n", ATDV_ERRMSGP(dev));
    return (-1);
  }

  tn_qlt.pvd_qual.qminsnr = qminsnr;
  tn_qlt.pvd_qual.qmaxsnr = qmaxsnr;
  tn_qlt.pvd_qual.maxpk	= maxpk;
  tn_qlt.pvd_qual.maxring = maxring;
  tn_qlt.pvd_qual.ringthres = ringthres;
  tn_qlt.pvd_qual.pvdwin = pvdwin;
  tn_qlt.pvd_qual.pvdthresh = pvdthresh;
  tn_qlt.pvd_qual.pvdrblow = pvdrblow;
  tn_qlt.pvd_qual.pvdrbhig = pvdrbhig;


  if((dx_setqualtmplate(dev,qual_template,&tn_qlt)) ==-1)
  {
    printf("setqual failed  \n");
    printf("%s \n", ATDV_ERRMSGP(dev));
    return (-1);
  }
      
  if((dx_getqualtmplate(dev,qual_template,&tn_qlt))==-1)
  {
    printf("getqual failed \n");
    printf("%s \n", ATDV_ERRMSGP(dev));
    return (-1);
  }

  return 0;
} /* end chg_q */


/****************************************************************
*        NAME : chg_qpamd(dev)
* DESCRIPTION : change qualification template 5 
*       INPUT : chdev = channel number
*      OUTPUT : none
*     RETURNS : none
****************************************************************/
chg_qpamd(int dev)
{
  int qual_template;  /* qualification template number */

  qual_template = PAMD_TEMPLID;

  if((dx_getqualtmplate(dev,qual_template,&tn_qlt))==-1)
  {
    printf("getqual failed \n");
    printf("%s \n", ATDV_ERRMSGP(dev));
    return (-1);
  }

//  printf("Modifying pamd qual template for %s\n", ATDV_NAMEP(dev));

  tn_qlt.amd_qual.maxansiz = maxansiz;    
  tn_qlt.amd_qual.maxans2 = maxans2;     
  tn_qlt.amd_qual.maxans3 = maxans3;    
  tn_qlt.amd_qual.lohiss = lohiss;     
  tn_qlt.amd_qual.hihiss = hihiss;     
  tn_qlt.amd_qual.bhparm = bhparm;     
  tn_qlt.amd_qual.cvthr1 = cvthr1;     
  tn_qlt.amd_qual.cvthr2 = cvthr2;     
  tn_qlt.amd_qual.maxcvth = maxcvth;     
  tn_qlt.amd_qual.nmaxbrod = nmaxbrod;     
  tn_qlt.amd_qual.nmaxerg = nmaxerg;     
  tn_qlt.amd_qual.maxsil = maxsil;     
  tn_qlt.amd_qual.voice_thres = voice_thres;     
  tn_qlt.amd_qual.sil_thres = sil_thres;     
  tn_qlt.amd_qual.bandf_low = bandf_low;    
  tn_qlt.amd_qual.bandf_high = bandf_high;    

  if((dx_setqualtmplate(dev,qual_template,&tn_qlt)) ==-1)
  {
    printf("setqual failed  \n");
    printf("%s \n", ATDV_ERRMSGP(dev));
    return (-1);
  }
      
  if((dx_getqualtmplate(dev,qual_template,&tn_qlt))==-1)
  {
    printf("getqual failed \n");
    printf("%s \n", ATDV_ERRMSGP(dev));
    return (-1);
  }

  return (0);
} /* end chg_q */

//////////////////////////////////////////////////////////////////////////
/****************************************************************
*        NAME : get_qpvd(dev)
* DESCRIPTION : get qualification template 5 
*       INPUT : chdev = channel number
*      OUTPUT : none
*     RETURNS : none
****************************************************************/
int get_qpvd(dev)
{
  int qual_template;  /* qualification template number */
  qual_template = PVD_TEMPLID;

  if((dx_getqualtmplate(dev,qual_template,&tn_qlt))==-1)
  {
    printf("getqual failed \n");
    printf("%s \n", ATDV_ERRMSGP(dev));
    return (-1);
  }

  return 0;
} /* end get pvd*/

/****************************************************************
*        NAME : get_qpamd(dev)
* DESCRIPTION : change qualification template 5 
*       INPUT : chdev = channel number
*      OUTPUT : none
*     RETURNS : none
****************************************************************/
int get_qpamd(dev)
{
  int qual_template;  /* qualification template number */
  
  qual_template = PAMD_TEMPLID;

  if((dx_getqualtmplate(dev,qual_template,&tn_qlt))==-1)
  {
    printf("getqual failed \n");
    printf("%s \n", ATDV_ERRMSGP(dev));
    return (-1);
  }

  return(1);
} /* end chg_q */

/****************************************************************
*        NAME : void options(argc, argp)
* DESCRIPTION : Get Command Line Options
*       INPUT : argc - Number of command line options
*             : argp - Pointer to command line options
*      OUTPUT : none
*     RETURNS : none
*    CAUTIONS : none
****************************************************************/
void options(int argc, char **argv)
{
	short argno;
	char buffer[1024];
	
	/* process command line switchs */
	printf("Checking agruments\n");
	
	if (argc < 3)
	{
		printf("Incorrect Args - Exiting\n"); 
		exit(1);
	}

	for( argno=1; argno < argc && *argv[argno] == '-'; argno++ )
	{
		switch( *(argv[argno]+1) )
		{
		
		case 'b':
		case 'B':
			//extract the starting vox resource
			strcpy(buffer,argv[argno]+2);
			startVox = atoi(buffer);
			printf("*** Starting voice channels <dxxxB%d> ***\n",startVox);
			break; 
		
		case 'g':
		case 'G':
			getqual = 1;
			break;
		
		case 'd':
		case 'D':
			defqual = 1;
			break;
		
		case 's':	
		case 'S':
			setqual = 1;
			break;
		
		case 'n':              /* voice channel */
		case 'N':
			strcpy(buffer,argv[argno]+2);
			DevCount = atoi(buffer);
			printf("*** Number of voice channels <%d> ***\n",DevCount);
			break;
		
		case '?':
		default:
			for(argno = 1; argno < (sizeof(helpscr)/sizeof(char *)); argno++)
			{
				puts(helpscr[argno]);
			} // end for 
			exit(0);
	
		} /* end switch */
	} /* end for */

} // end of function


/****************************************************************
*        NAME : def_qpvd(dev)
* DESCRIPTION : change qualification template 5 to default
*       INPUT : chdev = channel number
*      OUTPUT : none
*     RETURNS : none
****************************************************************/
def_qpvd(int dev)
{
  int qual_template;  /* qualification template number */
  qual_template = PVD_TEMPLID;

  if((dx_getqualtmplate(dev,qual_template,&tn_qlt))==-1)
  {
    printf("getqual failed \n");
    printf("%s \n", ATDV_ERRMSGP(dev));
    return (-1);
  }

  tn_qlt.pvd_qual.qminsnr = 50;
  tn_qlt.pvd_qual.qmaxsnr = 600;
  tn_qlt.pvd_qual.maxpk	= 2;
  tn_qlt.pvd_qual.maxring = 5;
  tn_qlt.pvd_qual.ringthres = 10000;
  tn_qlt.pvd_qual.pvdwin = 8;
  tn_qlt.pvd_qual.pvdthresh = 30;
  tn_qlt.pvd_qual.pvdrblow = 380;
  tn_qlt.pvd_qual.pvdrbhig = 510;

  if((dx_setqualtmplate(dev,qual_template,&tn_qlt)) ==-1)
  {
    printf("setqual failed  \n");
    printf("%s \n", ATDV_ERRMSGP(dev));
    return (-1);
  }
      
  if((dx_getqualtmplate(dev,qual_template,&tn_qlt))==-1)
  {
    printf("getqual failed \n");
    printf("%s \n", ATDV_ERRMSGP(dev));
    return (-1);
  }

  return 0;

} /* end chg_q */

/****************************************************************
*        NAME : def_qpamd(dev)
* DESCRIPTION : change qualification template 5 
*       INPUT : chdev = channel number
*      OUTPUT : none
*     RETURNS : none
****************************************************************/
def_qpamd(int dev)
{
  int qual_template;  /* qualification template number */
  qual_template = PAMD_TEMPLID;

 if((dx_getqualtmplate(dev,qual_template,&tn_qlt))==-1)
  {
    printf("getqual failed \n");
    printf("%s \n", ATDV_ERRMSGP(dev));
    return (-1);
  }

  tn_qlt.amd_qual.maxansiz = 125  ;
  tn_qlt.amd_qual.maxans2 = 50;
  tn_qlt.amd_qual.maxans3 = 220;  
  tn_qlt.amd_qual.lohiss = 22;
  tn_qlt.amd_qual.hihiss = 16;
  tn_qlt.amd_qual.bhparm = 5;
  tn_qlt.amd_qual.cvthr1 = 80; 
  tn_qlt.amd_qual.cvthr2 = 165; 
  tn_qlt.amd_qual.maxcvth = 390;
  tn_qlt.amd_qual.nmaxbrod = 2;
  tn_qlt.amd_qual.nmaxerg = 65;
  tn_qlt.amd_qual.maxsil = 30;
  tn_qlt.amd_qual.voice_thres = 25; 
  tn_qlt.amd_qual.sil_thres = 30;  
  tn_qlt.amd_qual.bandf_low = 0;
  tn_qlt.amd_qual.bandf_high = 0;

  if((dx_setqualtmplate(dev,qual_template,&tn_qlt)) ==-1)
  {
    printf("setqual failed  \n");
    printf("%s \n", ATDV_ERRMSGP(dev));
    return (-1);
  }
      
  if((dx_getqualtmplate(dev,qual_template,&tn_qlt))==-1)
  {
    printf("getqual failed \n");
    printf("%s \n", ATDV_ERRMSGP(dev));
    return (-1);
  }

  return (0);

} /* end chg_q */

int printSummary(int dev)
{
  int qual_template;  /* qualification template number */

  qual_template = PVD_TEMPLID;

  if((dx_getqualtmplate(dev,qual_template,&tn_qlt))==-1)
  {
    printf("getqual failed \n");
    printf("%s \n", ATDV_ERRMSGP(dev));
    return -1;
  }

  printf("\n***** <%s> Getting PVD Qualification Parameters ******\n\n",ATDV_NAMEP(dev)); 
  printf("  qminsnr   : %d  /* minimum allowable SNR for voice */\n",tn_qlt.pvd_qual.qminsnr);
  printf("  qmaxsnr   : %d  /* maximum allowable SNR for voice */\n",tn_qlt.pvd_qual.qmaxsnr);
  printf("  maxpk     : %d  /* maximum number of peaks for voice */\n",tn_qlt.pvd_qual.maxpk);
  printf("  maxring   : %d  /* maximum number of frames for ringback not voice */\n",tn_qlt.pvd_qual.maxring);
  printf("  ringthres : %d  /* signal to noise ratio for ringback */\n",tn_qlt.pvd_qual.ringthres);
  printf("  pvdwin    : %d  /* number of frames in a window sample */\n",tn_qlt.pvd_qual.pvdwin);
  printf("  pvdthresh : %d  /* minimum energy for voice */\n",tn_qlt.pvd_qual.pvdthresh);
  printf("  pvdrblow  : %d  /* lower frequency of ringback */\n",tn_qlt.pvd_qual.pvdrblow);
  printf("  pvdrbhig  : %d  /* upper frequency of ringback */\n",tn_qlt.pvd_qual.pvdrbhig);
  printf("***************************************************************\n\n");

  qual_template = PAMD_TEMPLID;

  if((dx_getqualtmplate(dev,qual_template,&tn_qlt))==-1)
  {
    printf("getqual failed \n");
    printf("%s \n", ATDV_ERRMSGP(dev));
    return -1;
  }

  printf("\n***** <%s> Getting PAMD Qualification Parameters ******\n\n",ATDV_NAMEP(dev)); 
  printf("  maxansiz    : %d  /* Size of answer #1 */\n",tn_qlt.amd_qual.maxansiz);
  printf("  maxans2     : %d  \n",tn_qlt.amd_qual.maxans2);
  printf("  maxans3     : %d  \n",tn_qlt.amd_qual.maxans3);
  printf("  lohiss      : %d  /* Low hiss (noise) range */ \n",tn_qlt.amd_qual.lohiss);
  printf("  hihiss      : %d  /* High hiss (noise) */ \n",tn_qlt.amd_qual.hihiss);
  printf("  bhparm      : %d  /* noise below hiss ratio */\n",tn_qlt.amd_qual.bhparm);
  printf("  cvthr1      : %d  /* cv. threshold #1 */\n",tn_qlt.amd_qual.cvthr1);
  printf("  cvthr2      : %d  \n",tn_qlt.amd_qual.cvthr2);
  printf("  maxcvth     : %d  /* Maximum cv threshold */ \n",tn_qlt.amd_qual.maxcvth);
  printf("  nmaxbrod    : %d  /* Maximum broad band energy - noise */ \n",tn_qlt.amd_qual.nmaxbrod);
  printf("  nmaxerg     : %d  /* Maximum total energy - noise */ \n",tn_qlt.amd_qual.nmaxerg);
  printf("  maxsil      : %d  \n",tn_qlt.amd_qual.maxsil);
  printf("  voice_thres : %d  \n",tn_qlt.amd_qual.voice_thres);
  printf("  sil_thres   : %d  \n",tn_qlt.amd_qual.sil_thres);
  printf("  bandf_low   : %d  /* Frequency Band filter, lower limit in hz */ \n",tn_qlt.amd_qual.bandf_low);
  printf("  bandf_high  : %d  /* upper limit in hz */ \n",tn_qlt.amd_qual.bandf_high);
  printf("***************************************************************\n\n");

  return 0; 

}//printSummary