xpmr.c

asterisk 是一个很有知名度开源软件

	{
		if(pSps==NULL)
			pSps=pChan->spsTx=createPmrSps();
		else
			pSps=pSps->nextSps=createPmrSps();
		pSps->source=inputTmp;
		pSps->sourceB=pChan->pTxLsdLpf;		 //asdf ??? !!! maw pTxLsdLpf
		pSps->sink=pChan->pTxComposite;
		pSps->sigProc=pmrMixer;
		pSps->enabled=1;
		pSps->nSamples=pChan->nSamplesTx;
		pSps->inputGain=2*M_Q8;	
		pSps->inputGainB=1*M_Q8/8; 
		pSps->outputGain=1*M_Q8;
		pSps->setpt=0;
		inputTmp=pSps->sink;
		pChan->ptxCtcssAdjust=&pSps->inputGainB;
	}

	// Chan A Upsampler and Filter 
	if(pSps==NULL) pSps=pChan->spsTx=createPmrSps();
	else pSps=pSps->nextSps=createPmrSps();

	pChan->spsTxOutA=pSps;
	if(!pChan->spsTx)pChan->spsTx=pSps;
	pSps->parentChan=pChan;

	if(pChan->txMixA==TX_OUT_COMPOSITE)
	{
		pSps->source=pChan->pTxComposite;	
	}
	else if(pChan->txMixA==TX_OUT_LSD)
	{
		pSps->source=pChan->pTxLsdLpf;	
	}
	else if(pChan->txMixA==TX_OUT_VOICE)
	{
		pSps->source=pChan->pTxHpf;
	}
	else if (pChan->txMixA==TX_OUT_AUX)
	{
		pSps->source=inputTmp;				 
	}
	else
	{
		pSps->source=NULL;				 
	}
	
	pSps->sink=pChan->pTxOut;  
	pSps->sigProc=pmr_gp_fir;
	pSps->enabled=1;
	pSps->numChanOut=2;
	pSps->selChanOut=0;
	pSps->nSamples=pChan->nSamplesTx;
	pSps->interpolate=6;
	pSps->ncoef=taps_fir_lpf_3K_1;
	pSps->size_coef=2;
	pSps->coef=(void*)coef_fir_lpf_3K_1;
	pSps->nx=taps_fir_lpf_3K_1;
	pSps->size_x=2;
	pSps->x=(void*)(calloc(pSps->nx,pSps->size_x));
	if(pSps==NULL)printf("Error: calloc(), createPmrChannel()\n"); 
	pSps->calcAdjust=gain_fir_lpf_3K_1;
	pSps->inputGain=(1*M_Q8);
	pSps->outputGain=(1*M_Q8);
	if(pChan->txMixA==pChan->txMixB)pSps->monoOut=1;
	else pSps->monoOut=0;


	// Chan B Upsampler and Filter 
	if((pChan->txMixA!=pChan->txMixB)&&(pChan->txMixB!=TX_OUT_OFF))
	{
		if(pSps==NULL) pSps=pChan->spsTx=createPmrSps();
		else pSps=pSps->nextSps=createPmrSps();

		pChan->spsTxOutB=pSps;
		pSps->parentChan=pChan;
		if(pChan->txMixB==TX_OUT_COMPOSITE)
		{
			pSps->source=pChan->pTxComposite;	
		}
		else if(pChan->txMixB==TX_OUT_LSD)
		{
			pSps->source=pChan->pTxLsdLpf;
			// pChan->ptxCtcssAdjust=&pSps->inputGain;
		}
		else if(pChan->txMixB==TX_OUT_VOICE)
		{
			pSps->source=inputTmp;
		}
		else if(pChan->txMixB==TX_OUT_AUX)
		{
			pSps->source=pChan->pTxHpf;
		}
		else
		{
			pSps->source=NULL;	 
		}

		pSps->sink=pChan->pTxOut;  
		pSps->sigProc=pmr_gp_fir;
		pSps->enabled=1;
		pSps->numChanOut=2;
		pSps->selChanOut=1;
		pSps->mixOut=0;
		pSps->nSamples=pChan->nSamplesTx;
		pSps->interpolate=6;
		pSps->ncoef=taps_fir_lpf_3K_1;
		pSps->size_coef=2;
		pSps->coef=(void*)coef_fir_lpf_3K_1;
		pSps->nx=taps_fir_lpf_3K_1;
		pSps->size_x=2;
		pSps->x=(void*)(calloc(pSps->nx,pSps->size_x));
		if(pSps==NULL)printf("Error: calloc(), createPmrChannel()\n");
		pSps->calcAdjust=(gain_fir_lpf_3K_1);
		pSps->inputGain=(1*M_Q8);
		pSps->outputGain=(1*M_Q8);
		
	}

	pSps->nextSps=NULL;

	#if XPMR_DEBUG0 == 1
	{
	    t_tdet     	*ptdet;
		TRACEX((" configure tracing\n"));
		
		pChan->rxCtcss->pDebug0=calloc(numSamples,2);
		pChan->rxCtcss->pDebug1=calloc(numSamples,2);
		pChan->rxCtcss->pDebug2=calloc(numSamples,2);

		for(i=0;i<CTCSS_NUM_CODES;i++){
			ptdet=&(pChan->rxCtcss->tdet[i]);
			ptdet->pDebug0=calloc(numSamples,2);
			ptdet->pDebug1=calloc(numSamples,2);
			ptdet->pDebug2=calloc(numSamples,2);
		}

		// buffer, 2 bytes per sample, and 16 channels
		pChan->prxDebug=calloc(numSamples*16,2);
		pChan->ptxDebug=calloc(numSamples*16,2);
	}
 	#endif

	TRACEX((" createPmrChannel() end\n"));

	return pChan;
}
/*	
*/
i16 destroyPmrChannel(t_pmr_chan *pChan)
{
	t_pmr_sps  	*pmr_sps, *tmp_sps;
	i16 i;

	TRACEX(("destroyPmrChannel()\n"));

	free(pChan->pRxDemod);
	free(pChan->pRxNoise);
	free(pChan->pRxBase);
	free(pChan->pRxHpf);
	free(pChan->pRxLsd);
	free(pChan->pRxSpeaker);
	free(pChan->pRxDcTrack);
	if(pChan->pRxLsdLimit)free(pChan->pRxLsdLimit);
	free(pChan->pTxBase);
	free(pChan->pTxHpf);
	free(pChan->pTxPreEmp);
	free(pChan->pTxLimiter);
	free(pChan->pTxLsd);
	free(pChan->pTxLsdLpf);
	if(pChan->pTxComposite)free(pChan->pTxComposite);
	free(pChan->pTxCode);
	free(pChan->pTxOut);

	if(pChan->pSigGen0)free(pChan->pSigGen0);
	if(pChan->pSigGen1)free(pChan->pSigGen1);

	#if XPMR_DEBUG0 == 1
	free(pChan->pTxPttIn);
	free(pChan->pTxPttOut);
	if(pChan->prxDebug)free(pChan->prxDebug);
	if(pChan->ptxDebug)free(pChan->ptxDebug);
	free(pChan->rxCtcss->pDebug0);
	free(pChan->rxCtcss->pDebug1);

	free(pChan->prxDebug0);
 	free(pChan->prxDebug1);
	free(pChan->prxDebug2);
	free(pChan->prxDebug3);

	free(pChan->ptxDebug0);
 	free(pChan->ptxDebug1);
	free(pChan->ptxDebug2);
	free(pChan->ptxDebug3);

	for(i=0;i<CTCSS_NUM_CODES;i++)
	{
		free(pChan->rxCtcss->tdet[i].pDebug0);
		free(pChan->rxCtcss->tdet[i].pDebug1);
		free(pChan->rxCtcss->tdet[i].pDebug2);
	}
	#endif

	free(pChan->pRxCtcss);

	pmr_sps=pChan->spsRx;
							
	while(pmr_sps)
	{
		tmp_sps = pmr_sps;
		pmr_sps = tmp_sps->nextSps;
		destroyPmrSps(tmp_sps);
	}

	free(pChan);

	return 0;
}
/*
*/
t_pmr_sps *createPmrSps(void)
{
	t_pmr_sps  *pSps;

	TRACEX(("createPmrSps()\n"));

	pSps = (t_pmr_sps *)calloc(sizeof(t_pmr_sps),1);

	if(!pSps)printf("Error: createPmrSps()\n");

	// pSps->x=calloc(pSps->nx,pSps->size_x);

	return pSps;
}
/*
*/
i16 destroyPmrSps(t_pmr_sps  *pSps)
{
	TRACEX(("destroyPmrSps(%i)\n",pSps->index));

	if(pSps->x!=NULL)free(pSps->x);
	free(pSps);
	return 0;
}
/*	
	PmrRx does the whole buffer
*/
i16 PmrRx(t_pmr_chan *pChan, i16 *input, i16 *output)
{
	int i,ii;
	t_pmr_sps *pmr_sps;

	TRACEX(("PmrRx() %i\n",pChan->frameCountRx));

	if(pChan==NULL){
		printf("PmrRx() pChan == NULL\n");
		return 1;
	}

	pChan->frameCountRx++;

	pmr_sps=pChan->spsRx;		// first sps
	pmr_sps->source=input;

	if(output!=NULL)pChan->spsRxOut->sink=output;	 //last sps

	#if 0
	if(pChan->inputBlanking>0)
	{
		pChan->inputBlanking-=pChan->nSamplesRx;
		if(pChan->inputBlanking<0)pChan->inputBlanking=0;
		for(i=0;i<pChan->nSamplesRx*6;i++)
			input[i]=0;
	}
	#endif
	
	// || (pChan->radioDuplex && (pChan->pttIn || pChan->pttOut)))
	if(pChan->rxCpuSaver && !pChan->rxCarrierDetect) 
	{
		if(pChan->spsRxHpf)pChan->spsRxHpf->enabled=0;
		if(pChan->spsRxDeEmp)pChan->spsRxDeEmp->enabled=0;
	}
	else
	{
		if(pChan->spsRxHpf)pChan->spsRxHpf->enabled=1;
		if(pChan->spsRxDeEmp)pChan->spsRxDeEmp->enabled=1;
	}

	i=0;
	while(pmr_sps!=NULL && pmr_sps!=0)
	{
		TRACEX(("PmrRx() sps %i\n",i++));
		pmr_sps->sigProc(pmr_sps);
		pmr_sps = (t_pmr_sps *)(pmr_sps->nextSps);
		//pmr_sps=NULL;	// sph maw
	}

	#define XPMR_VOX_HANGTIME	2000
	
	if(pChan->rxCdType==CD_XPMR_VOX)
	{
		if(pChan->spsRxVox->compOut)
		{
			pChan->rxVoxTimer=XPMR_VOX_HANGTIME;    //VOX HangTime in ms
		}
		if(pChan->rxVoxTimer>0)
		{
			pChan->rxVoxTimer-=MS_PER_FRAME;
			pChan->rxCarrierDetect=1;
		}
		else
		{
			pChan->rxVoxTimer=0;
			pChan->rxCarrierDetect=0;
		}
	}
	else
	{
		pChan->rxCarrierDetect=!pChan->spsRx->compOut;
	}

	if( !pChan->rxCpuSaver || pChan->rxCarrierDetect 
		|| pChan->rxCtcss->decode!=-1) ctcss_detect(pChan);

	#if XPMR_DEBUG0 == 1
	// TRACEX(("Write file.\n"));
	ii=0;
	if(pChan->b.rxCapture)
	{
		for(i=0;i<pChan->nSamplesRx;i++)
		{
			pChan->prxDebug[ii++]=input[i*2*6];		  												// input data
			pChan->prxDebug[ii++]=output[i];														// output data
			pChan->prxDebug[ii++]=pChan->rxCarrierDetect*M_Q14;		 								// carrier detect
			if(pChan->rxCtcss)
				pChan->prxDebug[ii++]=pChan->rxCtcss->decode*M_Q15/CTCSS_NUM_CODES;					// decoded ctcss
			else
				pChan->prxDebug[ii++]=0;															
	
			pChan->prxDebug[ii++]=pChan->pRxNoise[i];												// rssi
			pChan->prxDebug[ii++]=pChan->pRxBase[i];												// decimated, low pass filtered
			pChan->prxDebug[ii++]=pChan->pRxHpf[i];													// output to network
			pChan->prxDebug[ii++]=pChan->pRxSpeaker[i];
	
			pChan->prxDebug[ii++]=pChan->pRxLsd[i];		  											// CTCSS Filtered
			pChan->prxDebug[ii++]=pChan->pRxDcTrack[i];												// DC Restoration
			pChan->prxDebug[ii++]=pChan->pRxLsdLimit[i];											// Amplitude Limited
			
			//pChan->prxDebug[ii++]=pChan->rxCtcss->tdet[pChan->rxCtcss->testIndex+1].pDebug0[i];	// Upper Adjacent CTCSS Code
			pChan->prxDebug[ii++]=pChan->rxCtcss->tdet[pChan->rxCtcss->testIndex].pDebug0[i];		// Primary CTCSS Code
			pChan->prxDebug[ii++]=pChan->rxCtcss->tdet[pChan->rxCtcss->testIndex].pDebug1[i];		// dv/dt of decoder output
			pChan->prxDebug[ii++]=pChan->rxCtcss->tdet[pChan->rxCtcss->testIndex].pDebug2[i];

			//pChan->prxDebug[ii++]=pChan->rxCtcss->tdet[pChan->rxCtcss->testIndex-1].pDebug0[i];	   	// Lower Adjacent CTCSS Code
			
			pChan->prxDebug[ii++]=pChan->prxDebug1[i];		// Measure Output for VOX
			pChan->prxDebug[ii++]=pChan->prxDebug2[i];	  	// Measure Output for Tuning
		}
	}
	#endif

	return 0;
}
/*	
	PmrTx does the whole buffer
*/
i16 PmrTx(t_pmr_chan *pChan, i16 *input, i16 *output)
{
	int i, hit=0;
	t_pmr_sps *pmr_sps;

	pChan->frameCountTx++;

	TRACEX(("PmrTx() %i\n",pChan->frameCountTx));

	if(pChan==NULL){
		printf("PmrTx() pChan == NULL\n");
		return 1;
	}

	if(pChan->b.startSpecialTone)
	{
		pChan->b.startSpecialTone=0;
		pChan->spsSigGen1->option=1;
		pChan->spsSigGen1->enabled=1;
		pChan->b.doingSpecialTone=1;
	} else if(pChan->b.stopSpecialTone)
	{
		pChan->b.stopSpecialTone=0;
		pChan->spsSigGen1->option=0;
		pChan->b.doingSpecialTone=0;
		pChan->spsSigGen1->enabled=0;
	} else if(pChan->b.doingSpecialTone)
	{
		pChan->spsSigGen1->sink=output;
		pChan->spsSigGen1->sigProc(pChan->spsSigGen1);
		for(i=0;i<(pChan->nSamplesTx*2*6);i+=2)output[i+1]=output[i];
		return 0;
	}

	// handle transmitter ptt input
	hit=0;
	if( pChan->txPttIn && pChan->txState==0)
	{
		pChan->txState = 2;
		pChan->txPttOut=1;
		pChan->spsSigGen0->freq=pChan->txCtcssFreq*10;
		pChan->spsSigGen0->option=1;
		pChan->spsSigGen0->enabled=1;
		if(pChan->spsTxOutA)pChan->spsTxOutA->enabled=1;
		if(pChan->spsTxOutB)pChan->spsTxOutB->enabled=1;
		if(pChan->spsTxLsdLpf)pChan->spsTxLsdLpf->enabled=1;
		TRACEX((" TxOn\n"));
	}
	else if(!pChan->txPttIn && pChan->txState==2)
	{
		if( pChan->txTocType==TOC_NONE || !pChan->txCtcssFreq )
		{
			hit=1;
			TRACEX((" Tx Off Immediate.\n"));
        }
		else if(pChan->txCtcssFreq && pChan->txTocType==TOC_NOTONE)
		{
			pChan->txState=3;
			pChan->txHangTime=TOC_NOTONE_TIME/MS_PER_FRAME;
			pChan->spsSigGen0->option=3;
			TRACEX((" Tx Turn Off No Tone Start.\n"));
		}
 		else
		{
			pChan->txState=3;
			pChan->txHangTime=0;
			pChan->spsSigGen0->option=2;
			TRACEX((" Tx Turn Off Phase Shift Start.\n"));
		}
	} 
	else if(pChan->txState==3)
	{
		if(pChan->txHangTime)
		{
			if(--pChan->txHangTime==0)hit=1;

		}
		else if(pChan->txHangTime<=0 && pChan->spsSigGen0->state==0)
		{	
			hit=1;
			TRACEX((" Tx Off TOC.\n"));
		}
		if(pChan->txPttIn)
		{
			TRACEX((" Tx Key During HangTime\n"));		 
			if((pChan->txTocType==TOC_PHASE)||(pChan->txTocType==TOC_NONE))
			{
				pChan->txState = 2;
				hit=0;
			}
		}
	}

	if( pChan->txCpuSaver && !hit && !pChan->txPttIn && !pChan->txPttOut && pChan->txState==0 ) return (1); 

	if(hit)
	{
		pChan->txPttOut=0;
		pChan->txState=0;
		if(pChan->spsTxLsdLpf)pChan->spsTxLsdLpf->option=3;
		if(pChan->spsTxOutA)pChan->spsTxOutA->option=3;
		if(pChan->spsTxOutB)pChan->spsTxOutB->option=3;
		TRACEX((" Tx Off hit.\n"));
	}

	if(pChan->spsSigGen0)
	{
		pChan->spsSigGen0->sigProc(pChan->spsSigGen0);
		pmr_sps=pChan->spsSigGen0->nextSps;
		i=0;
		while(pmr_sps!=NULL && pmr_sps!=0)
		{
			TRACEX((" PmrTx() subaudible sps %i\n",i++));
			//printf(" CTCSS ENCODE %i %i\n",pChan->spsSigGen0->freq,pChan->spsSigGen0->outputGain);
			pmr_sps->sigProc(pmr_sps);
			pmr_sps = (t_pmr_sps *)(pmr_sps->nextSps);
		}
	}

	if(pChan->spsSigGen1 && pChan->spsSigGen1->enabled)
	{
		pChan->spsSigGen1->sigProc(pChan->spsSigGen1);
	}

	// Do Voice
	pmr_sps=pChan->spsTx;
	if(!pChan->spsSigGen1->enabled)pmr_sps->source=input;
	else input=pmr_sps->source;

	if(output!=NULL)
	{
		if(pChan->spsTxOutA)pChan->spsTxOutA->sink=output;
		if(pChan->spsTxOutB)pChan->spsTxOutB->sink=output;
	}

	i=0;
	while(pmr_sps!=NULL && pmr_sps!=0)
	{
		TRACEX((" PmrTx() sps %i\n",i++));
		pmr_sps->sigProc(pmr_sps);
		pmr_sps = (t_pmr_sps *)(pmr_sps->nextSps);
	}


	if(pChan->txMixA==TX_OUT_OFF || !pChan->txPttOut){
		for(i=0;i<pChan->nSamplesTx*2*6;i+=2)output[i]=0;
	}

	if(pChan->txMixB==TX_OUT_OFF || !pChan->txPttOut ){
		for(i=0;i<pChan->nSamplesTx*2*6;i+=2)output[i+1]=0;
	}

	#if XPMR_DEBUG0 == 1
	if(pChan->b.txCapture)
	{
		i16 ii=0;
		for(i=0;i<pChan->nSamplesTx;i++)
		{
			pChan->ptxDebug[ii++]=input[i];
			pChan->ptxDebug[ii++]=output[i*2*6];
			pChan->ptxDebug[ii++]=output[(i*2*6)+1];
			pChan->ptxDebug[ii++]=pChan->txPttIn*8192;
	
			pChan->ptxDebug[ii++]=pChan->txPttOut*8192;
			if(pChan->txHpfEnable)pChan->ptxDebug[ii++]=pChan->pTxHpf[i];
			else pChan->ptxDebug[ii++]=0; 
			if(pChan->txPreEmpEnable)pChan->ptxDebug[ii++]=pChan->pTxPreEmp[i];
			else pChan->ptxDebug[ii++]=0;
			if(pChan->txLimiterEnable)pChan->ptxDebug[ii++]=pChan->pTxLimiter[i];
			else pChan->ptxDebug[ii++]=0;
	
			pChan->ptxDebug[ii++]=pChan->pTxLsd[i];
			pChan->ptxDebug[ii++]=pChan->pTxLsdLpf[i];
			pChan->ptxDebug[ii++]=pChan->pTxComposite[i];
			pChan->ptxDebug[ii++]=pChan->pSigGen1[i];
					 
			#if 1
			pChan->ptxDebug[ii++]=pChan->ptxDebug0[i];
			pChan->ptxDebug[ii++]=pChan->ptxDebug1[i];
			pChan->ptxDebug[ii++]=pChan->ptxDebug2[i];
			pChan->ptxDebug[ii++]=pChan->ptxDebug3[i];
			#else
			pChan->ptxDebug[ii++]=0;
			pChan->ptxDebug[ii++]=0;
			pChan->ptxDebug[ii++]=0;
			pChan->ptxDebug[ii++]=0;
			#endif
		}
	}
	#endif

	return 0;
}
/* end of file */