ftp.nice.ch/pub/next/unix/audio/sms.N.bs.tar.gz#/sms/smsClean/smsClean.c

This is smsClean.c in view mode; [Download] [Up]

/*
 *
 *    main program for smsClean
 *
 */
#include "../sms.h"
#define USAGE "Usage: smsClean <inputSmsFile> <outputSmsFile>"

void SearchSms (SMS_DATA smsData, float *pFFreq, int *pIGoodRecords)
{
	int i;

	for (i = 0; i < smsData.nTraj; i++)
		if (smsData.pFMagTraj[i] > 0)
		{		
			pFFreq[i] += smsData.pFFreqTraj[i];
			pIGoodRecords[i]++;
		}
}	    

int calcRecordBSize (SMSHeader *pSmsHeader, int nTrajectories)
{
	int iSize = 0, nGain = 1, nComp = 2;
    
	if (pSmsHeader->iStochasticType == STOC_NONE)
		nGain = 0;
    
	if (pSmsHeader->iFormat == FORMAT_HARMONIC_WITH_PHASE ||
	    pSmsHeader->iFormat == FORMAT_INHARMONIC_WITH_PHASE)
		nComp = 3;
     
	iSize = sizeof (float) * (nComp * nTrajectories + 
		pSmsHeader->nStochasticCoeff + nGain);
	return(iSize);
}	     

void setTraj (float *pFFreq, int inNTraj, 
               int *pITrajOrder, int outNTraj)
{
	int i, j, iTraj;
	float fTmp = 22000, fLow = 0;

	for (i = 0; i < outNTraj; i++)
	{
		for (j = 0; j < inNTraj; j++)
		{
			if (pFFreq[j] > fLow)
				fTmp = MIN (pFFreq[j], fTmp);
			if (fTmp == pFFreq[j])
				iTraj = j;
		}
		fLow = fTmp;
		fTmp = 22000;
		pITrajOrder[i] = iTraj;
	}
}

void cleanSms (SMS_DATA inSmsData, SMS_DATA *pOutSmsData, int *pITrajOrder)
{
	int iTraj, iCoeff;

	for (iTraj = 0; iTraj < pOutSmsData->nTraj; iTraj++)
	{
		pOutSmsData->pFFreqTraj[iTraj] = 
			inSmsData.pFFreqTraj[pITrajOrder[iTraj]];
		pOutSmsData->pFMagTraj[iTraj] = 
			inSmsData.pFMagTraj[pITrajOrder[iTraj]];
	}

	if (inSmsData.nCoeff > 0)
	{
		pOutSmsData->nCoeff = inSmsData.nCoeff;
			*(pOutSmsData->pFStocGain) = *(inSmsData.pFStocGain);

		for (iCoeff = 0; iCoeff < pOutSmsData->nCoeff; iCoeff++)
			pOutSmsData->pFStocCoeff[iCoeff] = 
				inSmsData.pFStocCoeff[iCoeff];
	}
}

void main (int argc, char *argv[])
{
	char *pChInputSmsFile = NULL, *pChOutputSmsFile = NULL, *pChProgramName;
	SMSHeader *pInSmsHeader, *pOutSmsHeader;
	char *pInData, *pOutData;
	float *pFFreq;
	SMS_DATA inSmsData, outSmsData;
	int iError, *pIGoodRecords, *pITrajOrder, iRecord, iGoodTraj = 0, iTraj,
		iRecordBSize, iHeadBSize, iDataBSize;
  
	/* get user arguments */
	pChProgramName = argv[0];
	if (argc != 3) 
		quit(USAGE);   
    
	pChInputSmsFile = argv[1];
	pChOutputSmsFile = argv[2];

	if ((iError = readSmsFile (pChInputSmsFile, &pInSmsHeader)) < 0)
	{
		if (iError == SMS_NOPEN)
			quit ("cannot open file");
		if (iError == SMS_RDERR)
			quit("read error");
		if (iError == SMS_NSMS)
			quit ("not an SMS file");
		if (iError == SMS_MALLOC)
			quit ("cannot allocate memory");
			quit ("error");
	}	    
  
	if ((pFFreq =  
	     (float *) calloc (pInSmsHeader->nTrajectories, sizeof (float))) == 
		 NULL)
		quit ("error allocating memory for pFFreq");
	if ((pIGoodRecords =  
	     (int *) calloc (pInSmsHeader->nTrajectories, sizeof (int))) == NULL)
		quit ("error allocating memory for pIGoodRecords");

	initSms (&inSmsData);

	pInData = (char *) pInSmsHeader + pInSmsHeader->iHeadBSize;

	for (iRecord = 1; iRecord < pInSmsHeader->nRecords; iRecord++)
	{
		setSmsRecord (pInSmsHeader, pInData, &inSmsData);
		SearchSms (inSmsData, pFFreq, pIGoodRecords);	    
		pInData += pInSmsHeader->iRecordBSize;
	}
  
	for (iTraj = 0; iTraj < pInSmsHeader->nTrajectories; iTraj++)
		if (pIGoodRecords[iTraj] > 0)
		{
			iGoodTraj++;
			pFFreq[iTraj] /= pIGoodRecords[iTraj];
		}
	
	iRecordBSize = calcRecordBSize (pInSmsHeader, iGoodTraj);
	iHeadBSize = sizeof(SMSHeader);
	iDataBSize = iRecordBSize * pInSmsHeader->nRecords;
	/* allocate virtual memory for SMS file */
	if ((pOutSmsHeader =  
	     (SMSHeader *) malloc ((size_t)(iHeadBSize+iDataBSize))) == NULL)
		quit("error allocating memory for SMS file");
	
	initSmsHeader (pOutSmsHeader);
	pOutSmsHeader->iRecordBSize = iRecordBSize;
	pOutSmsHeader->nRecords = pInSmsHeader->nRecords;
	pOutSmsHeader->iFormat = pInSmsHeader->iFormat;
	pOutSmsHeader->iFrameRate = pInSmsHeader->iFrameRate;
	pOutSmsHeader->iStochasticType = pInSmsHeader->iStochasticType;
	pOutSmsHeader->nTrajectories = iGoodTraj;
	pOutSmsHeader->nStochasticCoeff = pInSmsHeader->nStochasticCoeff;
	pOutSmsHeader->pChDataRecords = 
		(char *)pOutSmsHeader + pOutSmsHeader->iHeadBSize;
	pOutSmsHeader->fOriginalSRate = pInSmsHeader->fOriginalSRate;
	pOutSmsHeader->nTextCharacters = pInSmsHeader->nTextCharacters;
	pOutSmsHeader->pChTextCharacters = pInSmsHeader->pChTextCharacters;

	pOutData = (char *) pOutSmsHeader + pOutSmsHeader->iHeadBSize;
	initSms (&outSmsData);
	pInData = (char *) pInSmsHeader + pInSmsHeader->iHeadBSize;
	initSms (&inSmsData);
	if ((pITrajOrder =  
	     (int *) calloc (pOutSmsHeader->nTrajectories, sizeof (int))) == NULL)
		quit ("error allocating memory for pITrajOrder");

	setTraj (pFFreq, pInSmsHeader->nTrajectories, pITrajOrder, 
	         pOutSmsHeader->nTrajectories);

	for (iRecord = 1; iRecord < pOutSmsHeader->nRecords; iRecord++)
	{
		setSmsRecord (pOutSmsHeader, pOutData, &outSmsData);
		setSmsRecord (pInSmsHeader, pInData, &inSmsData);
		cleanSms (inSmsData, &outSmsData, pITrajOrder);
		pOutData += pOutSmsHeader->iRecordBSize;
		pInData += pInSmsHeader->iRecordBSize;
	}

	
	writeSmsFile (pChOutputSmsFile, pOutSmsHeader);

	free (pInSmsHeader);
	free (pOutSmsHeader);
	free (pFFreq);
	free (pIGoodRecords);
	free (pITrajOrder);
	exit (0);
}

These are the contents of the former NiCE NeXT User Group NeXTSTEP/OpenStep software archive, currently hosted by Netfuture.ch.