rtcppacketbuilder.cpp

G726局域网语音通话源代码G726局域网语音通话源代码G726局域网语音通话源代码

					uint32_t expected = curseq-prevseq;
					uint8_t fraclost;
					
					if (expected < num) // got duplicates
						fraclost = 0;
					else
					{
						double lost = (double)(expected-num);
						double frac = lost/((double)expected);
						fraclost = (uint8_t)(frac*256.0);
					}

					expected = curseq-srcdat->INF_GetBaseSequenceNumber();
					num = srcdat->INF_GetNumPacketsReceived();

					uint32_t diff = expected-num;
					int32_t *packlost = (int32_t *)&diff;
					
					uint32_t jitter = srcdat->INF_GetJitter();
					uint32_t lsr;
					uint32_t dlsr; 	

					if (!srcdat->SR_HasInfo())
					{
						lsr = 0;
						dlsr = 0;
					}
					else
					{
						RTPNTPTime srtime = srcdat->SR_GetNTPTimestamp();
						uint32_t m = (srtime.GetMSW()&0xFFFF);
						uint32_t l = ((srtime.GetLSW()>>16)&0xFFFF);
						lsr = ((m<<16)|l);

						RTPTime diff = curtime;
						diff -= srcdat->SR_GetReceiveTime();
						double diff2 = diff.GetDouble();
						diff2 *= 65536.0;
						dlsr = (uint32_t)diff2;
					}

					status = rtcpcomppack->AddReportBlock(rr_ssrc,fraclost,*packlost,curseq,jitter,lsr,dlsr);
					if (status < 0)
					{
						if (status == ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT)
						{
							done = true;
							filled = true;
						}
						else
							return status;
					}
					else
					{
						addedcount++;
						if (addedcount >= maxcount)
						{
							done = true;
							if (!sources.GotoNextSource())
								atend = true;
						}
						srcdat->INF_StartNewInterval();
						srcdat->SetProcessedInRTCP(true);
					}
				}
			}

			if (!done)
			{
				if (!sources.GotoNextSource())
				{
					atend = true;
					done = true;
				}
			}

		} while (!done);
	}
	
	*added = addedcount;
	*skipped = skippedcount;
	*full = filled;
	
	if (!atend) // search for available sources
	{
		bool shouldprocess = false;
		
		do
		{	
			srcdat = sources.GetCurrentSourceInfo();
			if (!srcdat->IsOwnSSRC()) // don't send to ourselves
			{
				if (!srcdat->IsCSRC()) // p 35: no reports should go to CSRCs
				{
					if (srcdat->INF_HasSentData()) // if this isn't true, INF_GetLastRTPPacketTime() won't make any sense
					{
						if (firstpacket)
							shouldprocess = true;
						else
						{
							// p 35: only if rtp packets were received since the last RTP packet, a report block
							// should be added
							
							RTPTime lastrtptime = srcdat->INF_GetLastRTPPacketTime();
							
							if (lastrtptime > prevbuildtime)
								shouldprocess = true;
						}
					}
				}
			}
			
			if (shouldprocess)
			{
				if (srcdat->IsProcessedInRTCP())
					shouldprocess = false;
			}

			if (!shouldprocess)
			{
				if (!sources.GotoNextSource())
					atend = true;
			}
	
		} while (!atend && !shouldprocess);
	}	

	*atendoflist = atend;
	return 0;	
}

int RTCPPacketBuilder::FillInSDES(RTCPCompoundPacketBuilder *rtcpcomppack,bool *full,bool *processedall,int *added)
{
	int status;
	uint8_t *data;
	size_t datalen;
	
	*full = false;
	*processedall = false;
	*added = 0;

	// We don't need to add a SSRC for our own data, this is still set
	// from adding the CNAME
	if (doname)
	{
		if (!ownsdesinfo.ProcessedName())
		{
			data = ownsdesinfo.GetName(&datalen);
			if ((status = rtcpcomppack->AddSDESNormalItem(RTCPSDESPacket::NAME,data,datalen)) < 0)
			{
				if (status == ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT)
				{
					*full = true;
					return 0;
				}
			}
			(*added)++;
			ownsdesinfo.SetProcessedName(true);
		}
	}
	if (doemail)
	{
		if (!ownsdesinfo.ProcessedEMail())
		{
			data = ownsdesinfo.GetEMail(&datalen);
			if ((status = rtcpcomppack->AddSDESNormalItem(RTCPSDESPacket::EMAIL,data,datalen)) < 0)
			{
				if (status == ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT)
				{
					*full = true;
					return 0;
				}
			}
			(*added)++;
			ownsdesinfo.SetProcessedEMail(true);
		}
	}
	if (doloc)
	{
		if (!ownsdesinfo.ProcessedLocation())
		{
			data = ownsdesinfo.GetLocation(&datalen);
			if ((status = rtcpcomppack->AddSDESNormalItem(RTCPSDESPacket::LOC,data,datalen)) < 0)
			{
				if (status == ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT)
				{
					*full = true;
					return 0;
				}
			}
			(*added)++;
			ownsdesinfo.SetProcessedLocation(true);
		}
	}
	if (dophone)
	{
		if (!ownsdesinfo.ProcessedPhone())
		{
			data = ownsdesinfo.GetPhone(&datalen);
			if ((status = rtcpcomppack->AddSDESNormalItem(RTCPSDESPacket::PHONE,data,datalen)) < 0)
			{
				if (status == ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT)
				{
					*full = true;
					return 0;
				}
			}
			(*added)++;
			ownsdesinfo.SetProcessedPhone(true);
		}
	}
	if (dotool)
	{
		if (!ownsdesinfo.ProcessedTool())
		{
			data = ownsdesinfo.GetTool(&datalen);
			if ((status = rtcpcomppack->AddSDESNormalItem(RTCPSDESPacket::TOOL,data,datalen)) < 0)
			{
				if (status == ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT)
				{
					*full = true;
					return 0;
				}
			}
			(*added)++;
			ownsdesinfo.SetProcessedTool(true);
		}
	}
	if (donote)
	{
		if (!ownsdesinfo.ProcessedNote())
		{
			data = ownsdesinfo.GetNote(&datalen);
			if ((status = rtcpcomppack->AddSDESNormalItem(RTCPSDESPacket::NOTE,data,datalen)) < 0)
			{
				if (status == ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT)
				{
					*full = true;
					return 0;
				}
			}
			(*added)++;
			ownsdesinfo.SetProcessedNote(true);
		}
	}

	*processedall = true;
	return 0;
}

void RTCPPacketBuilder::ClearAllSDESFlags()
{
	ownsdesinfo.ClearFlags();
}
	
int RTCPPacketBuilder::BuildBYEPacket(RTCPCompoundPacket **pack,const void *reason,size_t reasonlength,bool useSRifpossible)
{
	if (!init)
		return ERR_RTP_RTCPPACKETBUILDER_NOTINIT;

	RTCPCompoundPacketBuilder *rtcpcomppack;
	int status;
	
	if (reasonlength > 255)
		reasonlength = 255;
	
	*pack = 0;
	
	rtcpcomppack = new RTCPCompoundPacketBuilder();
	if (rtcpcomppack == 0)
		return ERR_RTP_OUTOFMEM;
	
	if ((status = rtcpcomppack->InitBuild(maxpacketsize)) < 0)
	{
		delete rtcpcomppack;
		return status;
	}
	
	uint32_t ssrc = rtppacketbuilder.GetSSRC();
	bool useSR = false;
	
	if (useSRifpossible)
	{
		RTPSourceData *srcdat;
		
		if ((srcdat = sources.GetOwnSourceInfo()) != 0)
		{
			if (srcdat->IsSender())
				useSR = true;
		}
	}
			
	if (useSR)
	{
		RTPTime curtime = RTPTime::CurrentTime();
		RTPTime rtppacktime = rtppacketbuilder.GetPacketTime();
		uint32_t rtppacktimestamp = rtppacketbuilder.GetPacketTimestamp();
		uint32_t packcount = rtppacketbuilder.GetPacketCount();
		uint32_t octetcount = rtppacketbuilder.GetPayloadOctetCount();
		RTPTime diff = curtime;
		diff -= rtppacktime;
		
		uint32_t tsdiff = (uint32_t)((diff.GetDouble()/timestampunit)+0.5);
		uint32_t rtptimestamp = rtppacktimestamp+tsdiff;
		RTPNTPTime ntptimestamp = curtime.GetNTPTime();

		if ((status = rtcpcomppack->StartSenderReport(ssrc,ntptimestamp,rtptimestamp,packcount,octetcount)) < 0)
		{
			delete rtcpcomppack;
			if (status == ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT)
				return ERR_RTP_RTCPPACKETBUILDER_PACKETFILLEDTOOSOON;
			return status;
		}
	}
	else
	{
		if ((status = rtcpcomppack->StartReceiverReport(ssrc)) < 0)
		{
			delete rtcpcomppack;
			if (status == ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT)
				return ERR_RTP_RTCPPACKETBUILDER_PACKETFILLEDTOOSOON;
			return status;
		}
	}

	uint8_t *owncname;
	size_t owncnamelen;

	owncname = ownsdesinfo.GetCNAME(&owncnamelen);

	if ((status = rtcpcomppack->AddSDESSource(ssrc)) < 0)
	{
		delete rtcpcomppack;
		if (status == ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT)
			return ERR_RTP_RTCPPACKETBUILDER_PACKETFILLEDTOOSOON;
		return status;
	}
	if ((status = rtcpcomppack->AddSDESNormalItem(RTCPSDESPacket::CNAME,owncname,owncnamelen)) < 0)
	{
		delete rtcpcomppack;
		if (status == ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT)
			return ERR_RTP_RTCPPACKETBUILDER_PACKETFILLEDTOOSOON;
		return status;
	}

	uint32_t ssrcs[1];

	ssrcs[0] = ssrc;
	
	if ((status = rtcpcomppack->AddBYEPacket(ssrcs,1,(const uint8_t *)reason,reasonlength)) < 0)
	{
		delete rtcpcomppack;
		if (status == ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT)
			return ERR_RTP_RTCPPACKETBUILDER_PACKETFILLEDTOOSOON;
		return status;
	}
	
	if ((status = rtcpcomppack->EndBuild()) < 0)
	{
		delete rtcpcomppack;
		return status;
	}

	*pack = rtcpcomppack;
	return 0;
}