jb_fsm.cpp

基于h323协议的软phone

/********************************************************************20**

     Nhce:     Jitter Buffer - Finite State Machine

     Type:     C source file

     Desc:     Finite State Machine file for Jitter Buffer.

     File:     jb_fsm.cpp

     Sid:      jb_fsm.c 1.0  -  01/24/2000

     Prg:      sdg

*********************************************************************21*/


/************************************************************************

Upper layer primitives:

The following functions are provided in this file:

    jbFSM

************************************************************************/


/* header include files (.h) */

//#include "envopt.h"        /* environment options */
//#include "envdep.h"        /* environment dependent */
//#include "envind.h"        /* environment independent */
//#include "gen.h"           /* general layer */
//#include "ssi.h"           /* system services */
//#include "cm_hash.h"       /* common hash functions */
//#include "cm5.h"           /* common timer functions */
//#include "cm_tpt.h"
//#include "lhi.h"
//#include "hrt.h"
#if 0
#include <time.h>
#include <sys/times.h>

#include <errnoLib.h>
#endif
#include "stdafx.h"
#include "myphone.h"
#include "myphoneDlg.h"
#include "jb.h"        /* Jitter Buffer definitions */

//#include "gen.x"           /* general layer */
//#include "ssi.x"           /* system services */
//#include "cm_hash.x"       /* hashing functions */
//#include "cm5.x"           /* timer functions */
//#include "cm_lib.x"        /* common lib */
//#include "cm_tpt.x"
//#include "cm_llist.x"
//#include "poac.h"
//#include "lhi.x"
//#include "hrt.x"
#include "jb.x"        /* Jitter Buffer structures/prototypes */
#include "dspManager.h"

/* local defines */

/* local typedefs */


/* local externs */
/* slm: MR8849 now use array of coders for multiple lines */
EXTERN CdspDecoder *dspApiDecoder[DSP_MAX_DECODER_USERS];
EXTERN CdspEncoder *dspApiEncoder[DSP_MAX_ENCODER_USERS];

/* forward references */
PRIVATE S16 jbIgnore ARGS((JbConnCb *connCb, Data *dBuf, HrRtpHdr *rtpHdr));
PRIVATE S16 jbE00S00 ARGS((JbConnCb *connCb, Data *dBuf, HrRtpHdr *rtpHdr));
PRIVATE S16 jbE00S01 ARGS((JbConnCb *connCb, Data *dBuf, HrRtpHdr *rtpHdr));
PRIVATE S16 jbE00S02 ARGS((JbConnCb *connCb, Data *dBuf, HrRtpHdr *rtpHdr));
PRIVATE S16 jbE00S03 ARGS((JbConnCb *connCb, Data *dBuf, HrRtpHdr *rtpHdr));
PRIVATE S16 jbE01S00 ARGS((JbConnCb *connCb, Data *dBuf, HrRtpHdr *rtpHdr));
PRIVATE S16 jbE01S01 ARGS((JbConnCb *connCb, Data *dBuf, HrRtpHdr *rtpHdr));
PRIVATE S16 jbE01S02 ARGS((JbConnCb *connCb, Data *dBuf, HrRtpHdr *rtpHdr));
PRIVATE S16 jbE01S03 ARGS((JbConnCb *connCb, Data *dBuf, HrRtpHdr *rtpHdr));
PRIVATE S16 jbE02S03 ARGS((JbConnCb *connCb, Data *dBuf, HrRtpHdr *rtpHdr));

/* public variable declarations */
#ifdef __cplusplus
extern "C" {
#endif

//extern int codecIndex;
#ifdef DEBUG_JB
int jbstate_print=0;
jbstate_on()
{
    jbstate_print=1;
    return jbstate_print;
}
jbstate_off()
{
    jbstate_print=0;
    return jbstate_print;
}
#endif

#ifdef __cplusplus
}
#endif

extern DSPBuffer dspBuffer;

/* private variable declarations */

PFJBFSM JbFSM[NMB_JB_EVNT][NMB_JB_ST] =
{
   /* Receive Packet Event */
   {
      jbE00S00,         /* Underflow Long Silence */
      jbE00S01,         /* Active Hold */
      jbE00S02,         /* Active Play */
      jbE00S03,         /* Underflow */
   },
   {
   /* Play Packet Event */
      jbE01S00,         /* Underflow Long Silence */
      jbE01S01,         /* Active Hold */
      jbE01S02,         /* Active Play */
      jbE01S03,         /* Underflow */
   },
   {
   /* Long Silence Event */
      jbIgnore,         /* Underflow Long Silence */
      jbIgnore,         /* Active Hold */
      jbIgnore,         /* Active Play */
      jbE02S03,         /* Underflow */
   }
};



/*
*
*       Fun:   jbIgnore
*
*       Desc:  This function is for undefined events
*
*       Ret:   RFAILED
*
*       Notes:
*
*       File:  jb_fsm.c
*
*/
#ifdef ANSI
PRIVATE S16 jbIgnore
(
JbConnCb *connCb,                 /* Connection Control Block */
Data *dBuf,                   /* Data */
HrRtpHdr *rtpHdr        /* RTP header for data */
)
#else
PRIVATE S16 jbIgnore(connCb, dBuf, rtpHdr)
JbConnCb *connCb;                 /* Connection Control Block */
Data *dBuf;                   /* Data */
HrRtpHdr *rtpHdr;       /* RTP header for data */
#endif
{

//   TRC3(jbIgnore)
   RETVALUE(RFAILED);
}


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

//   TRC3(jbE00S00)

//   semTake(jbCb.sem., WAIT_FOREVER);
//   jbCb.sem.lock();
	semTake(jbCb.sem, JB_MAX_TICKS);
	if (errnoGet() == S_objLib_OBJ_TIMEOUT)
	{
		errnoSet(0);
		RETVALUE(ROK);
	}
   JbInsertPacket(connCb, dBuf, rtpHdr);
   JbUpdateJitter(connCb, JB_RECEIVE_PACKET);
   /*
    * MR: 4213 reduce path delay
    * was ">". Changed to ">=" to allow playback when the #
    * of packets equals the size of the jitter buffer
	*
	*/
   if (connCb->sts.numPackets >= connCb->sts.jitterBufferSize)
   {
      JBSTATE(JB_ACTIVE_PLAY)
   }
   else
   {
      JBSTATE(JB_ACTIVE_HOLD)
   }
   semGive(jbCb.sem);
//   jbCb.sem.unlock();
   RETVALUE(ROK);
}


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

//   TRC3(jbE00S01)

//   semTake(jbCb.sem., WAIT_FOREVER);
//   jbCb.sem.lock();
	semTake(jbCb.sem, JB_MAX_TICKS);
	if (errnoGet() == S_objLib_OBJ_TIMEOUT)
	{
		errnoSet(0);
		RETVALUE(ROK);
	}
   JbInsertPacket(connCb, dBuf, rtpHdr);
   JbUpdateJitter(connCb, JB_RECEIVE_PACKET);
   /*
    * MR: 4213 reduce path delay
    * was ">". Changed to ">=" to allow playback when the #
    * of packets equals the size of the jitter buffer
	*
	*/
   if (connCb->sts.numPackets >= connCb->sts.jitterBufferSize)
   {
      JBSTATE(JB_ACTIVE_PLAY);
   }
   semGive(jbCb.sem);
//   jbCb.sem.unlock();
   RETVALUE(ROK);
}


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

//   TRC3(jbE00S02)

//   semTake(jbCb.sem., WAIT_FOREVER);
	semTake(jbCb.sem, JB_MAX_TICKS);
	if (errnoGet() == S_objLib_OBJ_TIMEOUT)
	{
		errnoSet(0);
		RETVALUE(ROK);
	}
   JbInsertPacket(connCb, dBuf, rtpHdr);
   JbUpdateJitter(connCb, JB_RECEIVE_PACKET);
   semGive(jbCb.sem);
//   jbCb.sem.unlock();
   RETVALUE(ROK);
}


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

//   TRC3(jbE00S03)

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

   JbStopTimer(connCb);
   connCb->sts.breaks++;
   JbInsertPacket(connCb, dBuf, rtpHdr);
   JbUpdateJitter(connCb, JB_RECEIVE_PACKET);
   /*
    * MR: 4213 reduce path delay
    * was ">". Changed to ">=" to allow playback when the #
    * of packets equals the size of the jitter buffer
	*
	*/
   if (connCb->sts.numPackets >= connCb->sts.jitterBufferSize)
   {
      JBSTATE(JB_ACTIVE_PLAY)
   } else
   {
      JBSTATE(JB_ACTIVE_HOLD)
   }
   semGive(jbCb.sem);
//   jbCb.sem.unlock();
   RETVALUE(ROK);
}


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

   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++;