rtp解包组包.zip

1、H264的RTP组包和拆包，主要是对于单帧包和FU-A包的处理；
2、H265的RTP组包和拆包，主要是对于单帧包和FU-A包的处理；
3、H264和H265的SPS数据解析；

#include “H2645ParseSPS.h“
#include 
#include 
#include 
#include 

typedef unsigned char BYTE;
typedef int INT;
typedef unsigned int UINT;

typedef struct
{
	const BYTE *data;   //sps数据
	UINT size;          //sps数据大小
	UINT index;         //当前计算位所在的位置标记
} sps_bit_stream;

static BYTE *ff_avc_find_startcode_internal（BYTE *p BYTE *end）
{
	BYTE *a = p + 4 - （（long long）p & 3）;

	for （end -= 3; p < a && p < end; p++）
	{
		if （p[0] == 0 && p[1] == 0 && p[2] == 1）
			return p;
	}

	for （end -= 3; p < end; p += 4）
	{
		UINT x = *（const UINT*）p;
		//      if （（x - 0x01000100） & （~x） & 0x80008000） // little endian
		//      if （（x - 0x00010001） & （~x） & 0x00800080） // big endian
		if （（x - 0x01010101） & （~x） & 0x80808080）
		{ // generic
			if （p[1] == 0）
			{
				if （p[0] == 0 && p[2] == 1）
					return p;
				if （p[2] == 0 && p[3] == 1）
					return p + 1;
			}
			if （p[3] == 0）
			{
				if （p[2] == 0 && p[4] == 1）
					return p + 2;
				if （p[4] == 0 && p[5] == 1）
					return p + 3;
			}
		}
	}

	for （end += 3; p < end; p++）
	{
		if （p[0] == 0 && p[1] == 0 && p[2] == 1）
			return p;
	}

	return end + 3;
}

static BYTE *ff_avc_find_startcode（BYTE *p BYTE *end）
{
	BYTE *out = ff_avc_find_startcode_internal（p end）;
	if （p < out && out < end && !out[-1]）
		out--;
	return out;
}




/**
移除H264的NAL防竞争码（0x03）
@param data sps数据
@param dataSize sps数据大小
*/
static void del_emulation_prevention（BYTE *data UINT *dataSize）
{
	UINT dataSizeTemp = *dataSize;
	for （UINT i = 0 j = 0; i<（dataSizeTemp - 2）; i++） 
	{
		int val = （data[i] ^ 0x0） + （data[i + 1] ^ 0x0） + （data[i + 2] ^ 0x3）;    //检测是否是竞争码
		if （val == 0） 
		{
			for （j = i + 2; j			{    //移除竞争码
				data[j] = data[j + 1];
			}

			（*dataSize）--;      //data size 减1
		}
	}
}

static void sps_bs_init（sps_bit_stream *bs const BYTE *data UINT size）
{
	if （bs）
	{
		bs->data = data;
		bs->size = size;
		bs->index = 0;
	}
}

/**
是否已经到数据流最后

@param bs sps_bit_stream数据
@return 1：yes，0：no
*/
static INT eof（sps_bit_stream *bs）
{
	return （bs->index >= bs->size * 8）;    //位偏移已经超出数据
}

/**
读取从起始位开始的BitCount个位所表示的值

@param bs sps_bit_stream数据
@param bitCount bit位个数（从低到高）
@return value
*/
static UINT u（sps_bit_stream *bs BYTE bitCount）
{
	UINT val = 0;
	for （BYTE i = 0; i	{
		val <<= 1;
		if （eof（bs））
		{
			val = 0;
			break;
		}
		else if （bs->data[bs->index / 8] & （0x80 >> （bs->index % 8））） 
		{     //计算index所在的位是否为1
			val |= 1;
		}
		bs->index++;  //递增当前起始位（表示该位已经被计算，在后面的计算过程中不需要再次去计算所在的起始位索引，缺点：后面每个bit位都需要去位移）
	}

	return val;
}

/**
读取无符号哥伦布编码值（UE）
#2^LeadingZeroBits - 1 + （xxx）
@param bs sps_bit_stream数据
@return value
*/
static UINT ue（sps_bit_stream *bs）
{
	UINT zeroNum = 0;
	while （u（bs 1） == 0 && !eof（bs） && zeroNum < 32） 
	{
		zeroNum++;
	}

	return （UINT）（（1 << zeroNum） - 1 + u（bs zeroNum））;
}

/**
读取有符号哥伦布编码值（SE）
#（-1）^（k+1） * Ceil（k/2）

@param bs sps_bit_stream数据
@re

 属性            大小     日期    时间   名称
----------- ---------  ---------- -----  ----
     目录           0  2019-06-19 16:22  rtp解包组包\
     文件       19974  2019-03-15 15:04  rtp解包组包\H2645ParseSPS.cpp
     文件         730  2019-03-14 14:40  rtp解包组包\H2645ParseSPS.h
     文件       10938  2019-04-02 18:53  rtp解包组包\ParseSPS.cpp
     文件         435  2019-04-02 18:56  rtp解包组包\ParseSPS.h
     文件        1984  2019-03-19 14:18  rtp解包组包\RTPProcessor.cpp
     文件        1880  2019-04-02 11:36  rtp解包组包\RTPProcessor.h
     文件       11221  2019-03-21 20:39  rtp解包组包\RTPRecvProcessor.cpp
     文件        1023  2019-03-15 11:27  rtp解包组包\RTPRecvProcessor.h
     文件        7668  2019-03-26 11:47  rtp解包组包\RTPSendProcessor.cpp
     文件        1007  2019-03-14 10:29  rtp解包组包\RTPSendProcessor.h