jb_fsm.cpp

基于h323协议的软phone

   /* slm: MR4213 reset buffer creep flag */
   connCb->jitter.bufferCreep = 0;
   JbUpdateJitter(connCb, JB_PLAY_PACKET);

   /* slm: MR4213 update current play timestamp */
 //  if( connCb->key.rxCodec == JB_G723 )
   //   connCb->jitter.curTimestamp += (3 * JB_10MS_TIMESTAMP);
  // else
  //    connCb->jitter.curTimestamp += JB_10MS_TIMESTAMP;

   semGive(jbCb.sem);
//   jbCb.sem.unlock();

    /* slm: MR8849 changed to index based on line number */
   if (connCb->connIndex == jbCb.activeConn[connCb->key.lineNo])
   {
//printf("> GENERATE SILENCE (Play Underflow Long)\n");
        /* slm: MR4386 Need semaphore to protect DSP writes */
        semTake(jbCb.dspSem[connCb->key.lineNo], WAIT_FOREVER);
//        jbCb.dspSem[connCb->key.lineNo].lock();

        /* slm: MR4213 call silence for 1 frame at a time */
//        if(codecIndex != -1 && dspApiDecoder[codecIndex])
//            dspApiDecoder[codecIndex]->generateSilence(1);
		if(dspApiDecoder[connCb->key.lineNo])
	            dspApiDecoder[connCb->key.lineNo]->generateSilence(1);
        semGive(jbCb.dspSem[connCb->key.lineNo]);
//           jbCb.dspSem[connCb->key.lineNo].unlock();
   }

   RETVALUE(ROK);
}


/*
*
*       Fun:   jbE01S01
*
*       Desc:  This function is for Ev=PlayPacket St=ActiveHold
*
*       Ret:   ROK on sucesss, RFAILED on failure
*
*       Notes:
*
*       File:  jb_fsm.c
*
*/
#ifdef ANSI
PRIVATE S16 jbE01S01
(
JbConnCb *connCb,                 /* Connection Control Block */
Data *dBuf,                   /* Data */
HrRtpHdr *rtpHdr        /* RTP header for data */
)
#else
PRIVATE S16 jbE01S01(connCb, dBuf, rtpHdr)
JbConnCb *connCb;                 /* Connection Control Block */
Data *dBuf;                   /* Data */
HrRtpHdr *rtpHdr;       /* RTP header for data */
#endif
{
   S16 ret;

//   TRC3(jbE01S01)

   if (!connCb)
   {
       RETVALUE(RFAILED);
   }

//   semTake(jbCb.sem., WAIT_FOREVER);
	semTake(jbCb.sem, JB_MAX_TICKS);
	if (errnoGet() == S_objLib_OBJ_TIMEOUT)
	{
		errnoSet(0);
		RETVALUE(ROK);
	}

   connCb->jitter.playPacketCount++;
   /* slm: MR4213 reset buffer creep flag */
   connCb->jitter.bufferCreep = 0;
   JbUpdateJitter(connCb, JB_PLAY_PACKET);

#if 0
   connCb->jitter.playAttempts++;
   if ((connCb->jitter.playAttempts >=
        MULTPERCENT(connCb->sts.jitterBufferSize, jbCb.jitCfg.maxHoldTime))
     && (connCb->sts.numPackets > connCb->sts.jitterBufferSize))
   {
      /* slm: clear playAttempts so we restart from 0 if we reenter this state */
      connCb->jitter.playAttempts = 0;
      JBSTATE(JB_ACTIVE_PLAY)
   }
#endif

   /* If we have ANY packets in the queue and our timestamp is >= the first packet,
   ** then play it now.
   ** This could happen if the far end is sending silence frames.
   ** In this case we underflow when empty and go to this state (active hold) after
   ** we rcv a packet.  When we're in active hold, monitor the timestamp of the 1st
   ** packet in the queue to see if we need to play it */
   ret = RFAILED;
   if (connCb->sts.numPackets)
   {
        U8 nextP = (connCb->jitter.p + 1) & (jbCb.genCfg.maxSize - 1);
        //if((S32)connCb->jitter.curTimestamp >= (S32) connCb->jitter.jBuf[nextP].timeStamp)
        {
            JBSTATE(JB_ACTIVE_PLAY);
            /* Prevent any buffer drop in case UpdateJitter() set this flag */
            connCb->jitter.bufferDrop = 0;
            /* if JbRemovePacket succeeds, ret == ROK */
            ret = JbRemovePacket(connCb);
        }
   }

   semGive(jbCb.sem);
//   jbCb.sem.unlock();

	if(ret == ROK)
	{
		/* slm: MR8849 now use array of coders for multiple lines */
    		if (connCb->connIndex == jbCb.activeConn[connCb->key.lineNo])
    		{
	
	
       		 /* slm: MR4386 Need semaphore to protect DSP writes */
        		semTake(jbCb.dspSem[connCb->key.lineNo], WAIT_FOREVER);
			// jbCb.dspSem[connCb->key.lineNo].lock();
			//printf("putbufferbegin = %d\n",tickGet());
	  		if(dspApiDecoder[connCb->key.lineNo])
         			 dspApiDecoder[connCb->key.lineNo]->putBuffer(dspBuffer.putBuffer, dspBuffer.frames, dspBuffer.bufLen);
		    //   if(dspApiDecoder[1])
         		// dspApiDecoder[1]->putBuffer(putBuffer, frames, bufLen,1);
				//if(codecIndex != -1 && dspApiDecoder[codecIndex])
		//dspApiDecoder[codecIndex]->putBuffer(putBuffer, frames, bufLen);
	       semGive(jbCb.dspSem[connCb->key.lineNo]);
		// jbCb.dspSem[connCb->key.lineNo].unlock();
    		}
	}
	
   /* Ret = RFAILED if JBRemovePacket fails (above), or is not called */
   if( ret == RFAILED )
   {
       /* slm: MR4213 update current play timestamp */
    //   if( connCb->key.rxCodec == JB_G723 )
  //        connCb->jitter.curTimestamp += (3 * JB_10MS_TIMESTAMP);
     //  else
     //     connCb->jitter.curTimestamp += JB_10MS_TIMESTAMP;


       /* slm: MR8849 changed to index based on line number */
       if (connCb->connIndex == jbCb.activeConn[connCb->key.lineNo])
       {
//printf("> PACKET LOSS CONCEALMENT (Play Hold)\n");
            /* slm: MR4386 Need semaphore to protect DSP writes */
            semTake(jbCb.dspSem[connCb->key.lineNo], WAIT_FOREVER);
//           jbCb.dspSem[connCb->key.lineNo].lock();

            /* slm: MR4213
            ** If we're holding (because need to wait for more packets in the JB),
            ** then we should call PLC instead of silence
            ** Call PLC for 1 frame at a time
            */
            if(dspApiDecoder[connCb->key.lineNo])
                dspApiDecoder[connCb->key.lineNo]->packetLossConcealment(1);
                /*if(codecIndex != -1 && dspApiDecoder[codecIndex])
                dspApiDecoder[codecIndex]->packetLossConcealment(1);*/

            semGive(jbCb.dspSem[connCb->key.lineNo]);
//             jbCb.dspSem[connCb->key.lineNo].unlock();
       }

   }
   RETVALUE(ROK);
}


/*
*
*       Fun:   jbE01S02
*
*       Desc:  This function is for Ev=PlayPacket St=ActivePlay
*
*       Ret:   ROK on sucesss, RFAILED on failure
*
*       Notes:
*
*       File:  jb_fsm.c
*
*/
#ifdef ANSI
PRIVATE S16 jbE01S02
(
JbConnCb *connCb,                 /* Connection Control Block */
Data *dBuf,                   /* Data */
HrRtpHdr *rtpHdr        /* RTP header for data */
)
#else
PRIVATE S16 jbE01S02(connCb, dBuf, rtpHdr)
JbConnCb *connCb;                 /* Connection Control Block */
Data *dBuf;                   /* Data */
HrRtpHdr *rtpHdr;       /* RTP header for data */
#endif
{
//   TRC3(jbE01S02)

   if (!connCb)
   {
       RETVALUE(RFAILED);
   }

//   semTake(jbCb.sem., WAIT_FOREVER);
	semTake(jbCb.sem, JB_MAX_TICKS);
	if (errnoGet() == S_objLib_OBJ_TIMEOUT)
	{
		errnoSet(0);
		RETVALUE(ROK);
	}

   if (connCb->jitter.p == connCb->jitter.q)
   {
        JbStartTimer(connCb);
        JBSTATE(JB_UNDERFLOW)
        semGive(jbCb.sem);
//        jbCb.sem.unlock();
        RETVALUE(ROK);
   }

   /* Bump play count before updating jitter */
   connCb->jitter.playPacketCount++;
   JbUpdateJitter(connCb, JB_PLAY_PACKET);
 	S16 ret = JbRemovePacket(connCb);
     semGive(jbCb.sem);
//   jbCb.sem.unlock();

	if(ret == ROK)
	{
		/* slm: MR8849 now use array of coders for multiple lines */
    		if (connCb->connIndex == jbCb.activeConn[connCb->key.lineNo])
    		{
	
	
       		 /* slm: MR4386 Need semaphore to protect DSP writes */
        		semTake(jbCb.dspSem[connCb->key.lineNo], WAIT_FOREVER);
			// jbCb.dspSem[connCb->key.lineNo].lock();
			//printf("putbufferbegin = %d\n",tickGet());
	  		if(dspApiDecoder[connCb->key.lineNo])
         			 dspApiDecoder[connCb->key.lineNo]->putBuffer(dspBuffer.putBuffer, dspBuffer.frames, dspBuffer.bufLen);
		    //   if(dspApiDecoder[1])
         		// dspApiDecoder[1]->putBuffer(putBuffer, frames, bufLen,1);
				//if(codecIndex != -1 && dspApiDecoder[codecIndex])
		//dspApiDecoder[codecIndex]->putBuffer(putBuffer, frames, bufLen);
	       semGive(jbCb.dspSem[connCb->key.lineNo]);
		// jbCb.dspSem[connCb->key.lineNo].unlock();
    		}
	}

   if (ret != ROK)
   {
       /* slm: MR4213 update current play timestamp */
      // if( connCb->key.rxCodec == JB_G723 )
     //     connCb->jitter.curTimestamp += (3 * JB_10MS_TIMESTAMP);
     //  else
   //       connCb->jitter.curTimestamp += JB_10MS_TIMESTAMP;


       /* slm: MR8849 changed to index based on line number */
       if (connCb->connIndex == jbCb.activeConn[connCb->key.lineNo])
       {
//printf("> PACKET LOSS CONCEALMENT\n");
            /* slm: MR4386 Need semaphore to protect DSP writes */
            semTake(jbCb.dspSem[connCb->key.lineNo], WAIT_FOREVER);
//            jbCb.dspSem[connCb->key.lineNo].lock();

            /* slm: MR4213 call PLC for 1 frame at a time */
            if(dspApiDecoder[connCb->key.lineNo])
                dspApiDecoder[connCb->key.lineNo]->packetLossConcealment(1);
		/*if(codecIndex != -1 && dspApiDecoder[codecIndex])
                dspApiDecoder[codecIndex]->packetLossConcealment(1);*/

            semGive(jbCb.dspSem[connCb->key.lineNo]);
//            jbCb.dspSem[connCb->key.lineNo].unlock();
       }
   }

   RETVALUE(ROK);
}


/*
*
*       Fun:   jbE01S03
*
*       Desc:  This function is for Ev=PlayPacket St=Underflow
*
*       Ret:   ROK on sucesss, RFAILED on failure
*
*       Notes:
*
*       File:  jb_fsm.c
*
*/
#ifdef ANSI
PRIVATE S16 jbE01S03
(
JbConnCb *connCb,                 /* Connection Control Block */
Data *dBuf,                   /* Data */
HrRtpHdr *rtpHdr        /* RTP header for data */
)
#else
PRIVATE S16 jbE01S03(connCb, dBuf, rtpHdr)
JbConnCb *connCb;                 /* Connection Control Block */
Data *dBuf;                   /* Data */
HrRtpHdr *rtpHdr;       /* RTP header for data */
#endif
{
//   TRC3(jbE01S03)

   if (!connCb)
   {
       RETVALUE(RFAILED);
   }

//   semTake(jbCb.sem., WAIT_FOREVER);
	semTake(jbCb.sem, JB_MAX_TICKS);
	if (errnoGet() == S_objLib_OBJ_TIMEOUT)
	{
		errnoSet(0);
		RETVALUE(ROK);
	}

   connCb->jitter.playPacketCount++;
   /* slm: MR4213 reset buffer creep flag */
   connCb->jitter.bufferCreep = 0;
   JbUpdateJitter(connCb, JB_PLAY_PACKET);
   /* slm: clear playAttempts so we restart from 0 */
   connCb->jitter.playAttempts = 0;

   /* slm: MR4213 update current play timestamp */
 //  if( connCb->key.rxCodec == JB_G723 )
   //   connCb->jitter.curTimestamp += (3 * JB_10MS_TIMESTAMP);
  // else
  //    connCb->jitter.curTimestamp += JB_10MS_TIMESTAMP;

   semGive(jbCb.sem);
//   jbCb.sem.unlock();

   /* slm: MR8849 changed to index based on line number */
   if (connCb->connIndex == jbCb.activeConn[connCb->key.lineNo])
   {

//printf("> PACKET LOSS CONCEALMENT (Play Underflow)\n");
        /* slm: MR4386 Need semaphore to protect DSP writes */
        semTake(jbCb.dspSem[connCb->key.lineNo], WAIT_FOREVER);
//        jbCb.dspSem[connCb->key.lineNo].lock();

        /* slm: MR4213
        ** If we're underflowing (because we've emptied the JB),
        ** then we should call PLC instead of silence
        ** call PLC for 1 frame at a time
        */
        if(dspApiDecoder[connCb->key.lineNo])
            dspApiDecoder[connCb->key.lineNo]->packetLossConcealment(1);
/*	if(codecIndex != -1 && dspApiDecoder[codecIndex])
            dspApiDecoder[codecIndex]->packetLossConcealment(1);*/

        semGive(jbCb.dspSem[connCb->key.lineNo]);
//        jbCb.dspSem[connCb->key.lineNo].unlock();
   }

   RETVALUE(ROK);
}


/*
*
*       Fun:   jbE02S03
*
*       Desc:  This function is for Ev=LongSilence St=Underflow
*
*       Ret:   ROK on sucesss, RFAILED on failure
*
*       Notes:
*
*       File:  jb_fsm.c
*
*/
#ifdef ANSI
PRIVATE S16 jbE02S03
(
JbConnCb *connCb,                 /* Connection Control Block */
Data *dBuf,                   /* Data */
HrRtpHdr *rtpHdr        /* RTP header for data */
)
#else
PRIVATE S16 jbE02S03(connCb, dBuf, rtpHdr)
JbConnCb *connCb;                 /* Connection Control Block */
Data *dBuf;                   /* Data */
HrRtpHdr *rtpHdr;       /* RTP header for data */
#endif
{
    S16 i;

//    TRC3(jbE02S03)

//   semTake(jbCb.sem., WAIT_FOREVER);
	semTake(jbCb.sem, JB_MAX_TICKS);
	if (errnoGet() == S_objLib_OBJ_TIMEOUT)
	{
		errnoSet(0);
		RETVALUE(ROK);
	}

    connCb->jitter.p = 0;
    connCb->jitter.q = 0;
    connCb->jitter.maxJitter = 0;
    connCb->jitter.currentStableTime = 0;
    connCb->jitter.playAttempts = 0;
    connCb->jitter.receivePacketCount = 0;
    connCb->jitter.playPacketCount = 0;

    for (i = 0; i < jbCb.genCfg.maxSize; i++)
    {
        /* slm: use len instead of seqNum since 0 is a valid seqnum
        ** connCb->jitter.jBuf[i].seqNum = 0;
        */
        connCb->jitter.jBuf[i].len = 0;
    }

    JBSTATE(JB_UNDERFLOW_LONG_SILENCE)
   semGive(jbCb.sem);
//   jbCb.sem.unlock();

    RETVALUE(ROK);
}