incubator-bluesky-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From p...@apache.org
Subject svn commit: r819898 [4/5] - in /incubator/bluesky/trunk/RealClass/Student-1.0: ./ src/ src/pic/
Date Tue, 29 Sep 2009 12:17:19 GMT
Added: incubator/bluesky/trunk/RealClass/Student-1.0/src/fecrtpsession.cpp
URL: http://svn.apache.org/viewvc/incubator/bluesky/trunk/RealClass/Student-1.0/src/fecrtpsession.cpp?rev=819898&view=auto
==============================================================================
--- incubator/bluesky/trunk/RealClass/Student-1.0/src/fecrtpsession.cpp (added)
+++ incubator/bluesky/trunk/RealClass/Student-1.0/src/fecrtpsession.cpp Tue Sep 29 12:17:17
2009
@@ -0,0 +1,1429 @@
+// fecrtpsession.cpp: implementation of the CFECRtpSession class.
+
+#include <unistd.h>
+#include "fecrtpsession.h"
+
+#ifndef GF_BITS
+#define GF_BITS  8	
+#endif
+
+#define u_char unsigned char
+#define u_short unsigned short
+#define u_long unsigned long
+
+#define bcmp(a,b,n) memcmp(a,b,n)
+#define bcopy(s, d, siz)        memcpy((d), (s), (siz))
+#define bzero(d, siz)   memset((d), '\0', (siz))
+
+#define DEB(x)
+#define DDB(x) x
+
+#if (GF_BITS < 2  && GF_BITS >16)
+#error "GF_BITS must be 2 .. 16"
+#endif
+
+#if (GF_BITS <= 8)
+typedef unsigned char gf;
+#else
+typedef unsigned short gf;
+#endif
+
+#define	GF_SIZE ((1 << GF_BITS) - 1)	/* powers of \alpha */
+
+static char *allPp[] =
+{ /* GF_BITS	polynomial		*/
+0, /*  0	no code			*/
+0, /*  1	no code			*/
+"111", /*  2	1+x+x^2			*/
+"1101", /*  3	1+x+x^3			*/
+"11001", /*  4	1+x+x^4			*/
+"101001", /*  5	1+x^2+x^5		*/
+"1100001", /*  6	1+x+x^6			*/
+"10010001", /*  7	1 + x^3 + x^7		*/
+"101110001", /*  8	1+x^2+x^3+x^4+x^8	*/
+"1000100001", /*  9	1+x^4+x^9		*/
+"10010000001", /* 10	1+x^3+x^10		*/
+"101000000001", /* 11	1+x^2+x^11		*/
+"1100101000001", /* 12	1+x+x^4+x^6+x^12	*/
+"11011000000001", /* 13	1+x+x^3+x^4+x^13	*/
+"110000100010001", /* 14	1+x+x^6+x^10+x^14	*/
+"1100000000000001", /* 15	1+x+x^15		*/
+"11010000000010001" /* 16	1+x+x^3+x^12+x^16	*/
+};
+
+static gf gf_exp[2 * GF_SIZE]; /* index->poly form conversion table	*/
+static int gf_log[GF_SIZE + 1]; /* Poly->index form conversion table	*/
+static gf inverse[GF_SIZE + 1]; /* inverse of field elem.		*/
+
+int modnn(int x)
+{
+	while (x >= GF_SIZE)
+	{
+		x -= GF_SIZE;
+		x = (x >> GF_BITS) + (x & GF_SIZE);
+	}
+	return x;
+}
+
+#define SWAP(a,b,t) {t tmp; tmp=a; a=b; b=tmp;}
+
+#if (GF_BITS <= 8)
+static gf gf_mul_table[GF_SIZE + 1][GF_SIZE + 1];
+
+#define gf_mul(x,y) gf_mul_table[x][y]
+
+#define USE_GF_MULC register gf * __gf_mulc_
+#define GF_MULC0(c) __gf_mulc_ = gf_mul_table[c]
+#define GF_ADDMULC(dst, x) dst ^= __gf_mulc_[x]
+
+static void init_mul_table()
+{
+	int i, j;
+	for (i = 0; i < GF_SIZE + 1; i++)
+		for (j = 0; j < GF_SIZE + 1; j++)
+			gf_mul_table[i][j] = gf_exp[modnn(gf_log[i] + gf_log[j])];
+
+	for (j = 0; j < GF_SIZE + 1; j++)
+		gf_mul_table[0][j] = gf_mul_table[j][0] = 0;
+}
+#else	
+static inline gf gf_mul(gf x,gf y)
+{
+	if ( (x) == 0 || (y)==0 ) return 0;
+
+	return gf_exp[gf_log[x] + gf_log[y] ];
+}
+#define init_mul_table()
+
+#define USE_GF_MULC register gf * __gf_mulc_
+#define GF_MULC0(c) __gf_mulc_ = &gf_exp[ gf_log[c] ]
+#define GF_ADDMULC(dst, x) { if (x) dst ^= __gf_mulc_[ gf_log[x] ] ; }
+#endif
+
+static void* my_malloc(int sz, char *err_string)
+{
+	void *p = malloc(sz);
+	if (p == 0)
+	{
+	}
+	return p;
+}
+
+#define NEW_GF_MATRIX(rows, cols) (gf *)my_malloc(rows * cols * sizeof(gf), " ## __LINE__
## " )
+
+static void generate_gf(void)
+{
+	int i;
+	gf mask;
+	char *Pp = allPp[GF_BITS];
+
+	mask = 1; /* x ** 0 = 1 */
+	gf_exp[GF_BITS] = 0; /* will be updated at the end of the 1st loop */
+
+	for (i = 0; i < GF_BITS; i++, mask <<= 1)
+	{
+		gf_exp[i] = mask;
+		gf_log[gf_exp[i]] = i;
+		if (Pp[i] == '1')
+			gf_exp[GF_BITS] ^= mask;
+	}
+	gf_log[gf_exp[GF_BITS]] = GF_BITS;
+
+	mask = 1 << (GF_BITS - 1);
+	for (i = GF_BITS + 1; i < GF_SIZE; i++)
+	{
+		if (gf_exp[i - 1] >= mask)
+			gf_exp[i] = gf_exp[GF_BITS] ^ ((gf_exp[i - 1] ^ mask) << 1);
+		else
+			gf_exp[i] = gf_exp[i - 1] << 1;
+		gf_log[gf_exp[i]] = i;
+	}
+
+	gf_log[0] = GF_SIZE;
+
+	for (i = 0; i < GF_SIZE; i++)
+		gf_exp[i + GF_SIZE] = gf_exp[i];
+
+	inverse[0] = 0;
+	inverse[1] = 1;
+	for (i = 2; i <= GF_SIZE; i++)
+		inverse[i] = gf_exp[GF_SIZE - gf_log[i]];
+}
+
+#define addmul(dst, src, c, sz) \
+    if (c != 0) addmul1(dst, src, c, sz)
+
+#define UNROLL 16 /* 1, 4, 8, 16 */
+static void addmul1(gf *dst1, gf *src1, gf c, int sz)
+{
+	USE_GF_MULC ;
+	register gf *dst = dst1, *src = src1;
+	gf *lim = &dst[sz - UNROLL + 1];
+
+	GF_MULC0(c);
+
+#if (UNROLL > 1) /* unrolling by 8/16 is quite effective on the pentium */
+	for (; dst < lim; dst += UNROLL, src += UNROLL)
+	{
+		GF_ADDMULC( dst[0] , src[0] );
+		GF_ADDMULC( dst[1] , src[1] );
+		GF_ADDMULC( dst[2] , src[2] );
+		GF_ADDMULC( dst[3] , src[3] );
+#if (UNROLL > 4)
+		GF_ADDMULC( dst[4] , src[4] );
+		GF_ADDMULC( dst[5] , src[5] );
+		GF_ADDMULC( dst[6] , src[6] );
+		GF_ADDMULC( dst[7] , src[7] );
+#endif
+#if (UNROLL > 8)
+		GF_ADDMULC( dst[8] , src[8] );
+		GF_ADDMULC( dst[9] , src[9] );
+		GF_ADDMULC( dst[10] , src[10] );
+		GF_ADDMULC( dst[11] , src[11] );
+		GF_ADDMULC( dst[12] , src[12] );
+		GF_ADDMULC( dst[13] , src[13] );
+		GF_ADDMULC( dst[14] , src[14] );
+		GF_ADDMULC( dst[15] , src[15] );
+#endif
+	}
+#endif
+	lim += UNROLL - 1;
+	for (; dst < lim; dst++, src++) /* final components */
+		GF_ADDMULC( *dst , *src );
+}
+
+static void matmul(gf *a, gf *b, gf *c, int n, int k, int m)
+{
+	int row, col, i;
+
+	for (row = 0; row < n; row++)
+	{
+		for (col = 0; col < m; col++)
+		{
+			gf *pa = &a[row * k];
+			gf *pb = &b[col];
+			gf acc = 0;
+			for (i = 0; i < k; i++, pa++, pb += m)
+				acc ^= gf_mul( *pa, *pb );
+			c[row * m + col] = acc;
+		}
+	}
+}
+
+#ifdef DEBUG
+static int is_identity(gf *m, int k)
+{
+	int row, col;
+	for (row=0; row<k; row++)
+	for (col=0; col<k; col++)
+	if ( (row==col && *m != 1) || (row!=col && *m != 0) )
+	return 0;
+	else
+	m++;
+	return 1;
+}
+#endif /* debug */
+
+DEB( int pivloops=0; int pivswaps=0; /* diagnostic */)
+static int invert_mat(gf *src, int k)
+{
+	gf c, *p;
+	int irow, icol, row, col, i, ix;
+
+	int error = 1;
+	int *indxc = (int *) my_malloc(k * sizeof(int), "indxc");
+
+	int *indxr = (int *) my_malloc(k * sizeof(int), "indxr");
+	int *ipiv = (int *) my_malloc(k * sizeof(int), "ipiv");
+	gf *id_row = NEW_GF_MATRIX(1, k);
+	gf *temp_row = NEW_GF_MATRIX(1, k);
+
+	if ((indxc == 0) || (indxr == 0) || (id_row == 0) || (temp_row == 0)
+			|| (ipiv == 0))
+	{
+		goto fail;
+	}
+
+	bzero(id_row, k*sizeof(gf));
+	DEB( pivloops=0; pivswaps=0; /* diagnostic */)
+
+	for (i = 0; i < k; i++)
+		ipiv[i] = 0;
+
+	for (col = 0; col < k; col++)
+	{
+		gf *pivot_row;
+
+		irow = icol = -1;
+		if (ipiv[col] != 1 && src[col * k + col] != 0)
+		{
+			irow = col;
+			icol = col;
+			goto found_piv;
+		}
+		for (row = 0; row < k; row++)
+		{
+			if (ipiv[row] != 1)
+			{
+				for (ix = 0; ix < k; ix++)
+				{
+					DEB( pivloops++; )
+					if (ipiv[ix] == 0)
+					{
+						if (src[row * k + ix] != 0)
+						{
+							irow = row;
+							icol = ix;
+							goto found_piv;
+						}
+					}
+					else if (ipiv[ix] > 1)
+					{
+						//fprintf(stderr, "singular matrix\n");
+						goto fail;
+					}
+				}
+			}
+		}
+		if (icol == -1)
+		{
+			goto fail;
+		}
+		found_piv: ++(ipiv[icol]);
+
+		if (irow != icol)
+		{
+			for (ix = 0; ix < k; ix++)
+			{
+				SWAP( src[irow*k + ix], src[icol*k + ix], gf);
+			}
+		}
+		indxr[col] = irow;
+		indxc[col] = icol;
+		pivot_row = &src[icol * k];
+		c = pivot_row[icol];
+		if (c == 0)
+		{
+			goto fail;
+		}
+		if (c != 1)
+		{
+			DEB( pivswaps++; )
+			c = inverse[c];
+			pivot_row[icol] = 1;
+			for (ix = 0; ix < k; ix++)
+				pivot_row[ix] = gf_mul(c, pivot_row[ix] );
+		}
+		id_row[icol] = 1;
+		if (bcmp(pivot_row, id_row, k*sizeof(gf)) != 0)
+		{
+			for (p = src, ix = 0; ix < k; ix++, p += k)
+			{
+				if (ix != icol)
+				{
+					c = p[icol];
+					p[icol] = 0;
+					addmul(p, pivot_row, c, k );
+				}
+			}
+		}
+		id_row[icol] = 0;
+	} /* done all columns */
+	for (col = k - 1; col >= 0; col--)
+	{
+		if (indxr[col] < 0 || indxr[col] >= k)
+		{
+			goto fail;
+		}
+		else if (indxc[col] < 0 || indxc[col] >= k)
+		{
+			goto fail;
+		}
+		else if (indxr[col] != indxc[col])
+		{
+			for (row = 0; row < k; row++)
+			{
+				SWAP( src[row*k + indxr[col]], src[row*k + indxc[col]], gf);
+			}
+		}
+	}
+
+	error = 0;
+	fail: if (indxc != 0)
+		free(indxc);
+	if (indxr != 0)
+		free(indxr);
+	if (ipiv != 0)
+		free(ipiv);
+	if (id_row != 0)
+		free(id_row);
+	if (temp_row != 0)
+		free(temp_row);
+	return error;
+}
+
+int invert_vdm(gf *src, int k)
+{
+	int i, j, row, col;
+	gf *b, *c, *p;
+	gf t, xx;
+
+	if (k == 1) /* degenerate case, matrix must be p^0 = 1 */
+		return 0;
+
+	c = NEW_GF_MATRIX(1, k);
+
+	b = NEW_GF_MATRIX(1, k);
+
+	p = NEW_GF_MATRIX(1, k);
+	if ((c == 0) || (b == 0) || (p == 0))
+	{
+		if (b == 0)
+			free(b);
+		if (c == 0)
+			free(c);
+		if (p == 0)
+			free(p);
+		return 1;
+	}
+
+	for (j = 1, i = 0; i < k; i++, j += k)
+	{
+		c[i] = 0;
+		p[i] = src[j]; /* p[i] */
+	}
+	c[k - 1] = p[0]; /* really -p(0), but x = -x in GF(2^m) */
+	for (i = 1; i < k; i++)
+	{
+		gf p_i = p[i]; /* see above comment */
+		for (j = k - 1 - (i - 1); j < k - 1; j++)
+			c[j] ^= gf_mul( p_i, c[j+1] );
+		c[k - 1] ^= p_i;
+	}
+
+	for (row = 0; row < k; row++)
+	{
+
+		xx = p[row];
+		t = 1;
+		b[k - 1] = 1; /* this is in fact c[k] */
+		for (i = k - 2; i >= 0; i--)
+		{
+			b[i] = c[i + 1] ^ gf_mul(xx, b[i+1]);
+			t = gf_mul(xx, t) ^ b[i];
+		}
+		for (col = 0; col < k; col++)
+			src[col * k + row] = gf_mul(inverse[t], b[col] );
+	}
+	free(c);
+	free(b);
+	free(p);
+	return 0;
+}
+
+static int fec_initialized = 0;
+static void init_fec()
+{
+
+	generate_gf();
+
+	init_mul_table();
+
+	fec_initialized = 1;
+}
+
+#define FEC_MAGIC	0xFECC0DEC
+
+struct fec_parms
+{
+	u_long magic;
+	int k, n; /* parameters of the code */
+	gf *enc_matrix;
+};
+
+void fec_free(struct fec_parms *p)
+{
+	if (p == 0 || p->magic != (((FEC_MAGIC ^ p->k) ^ p->n)
+			^ (int) (p->enc_matrix)))
+	{
+		return;
+	}
+	free(p->enc_matrix);
+	free(p);
+}
+
+struct fec_parms * fec_new(int k, int n)
+{
+	int row, col;
+	gf *p, *tmp_m;
+
+	struct fec_parms *retval;
+
+	if (fec_initialized == 0)
+		init_fec();
+
+	if (k > GF_SIZE + 1 || n > GF_SIZE + 1 || k > n)
+	{
+		return 0;
+	}
+
+	retval
+			= (struct fec_parms*) my_malloc(sizeof(struct fec_parms),
+					"new_code");
+	if (retval == 0)
+		return 0;
+
+	retval->k = k;
+	retval->n = n;
+	retval->enc_matrix = NEW_GF_MATRIX(n, k);
+	if (retval->enc_matrix == 0)
+	{
+		free(retval);
+		return 0;
+	}
+
+	retval->magic = ((FEC_MAGIC ^ k) ^ n) ^ (int) (retval->enc_matrix);
+	tmp_m = NEW_GF_MATRIX(n, k);
+	if (tmp_m == 0)
+	{
+		free(retval->enc_matrix);
+		free(retval);
+		return 0;
+	}
+
+	tmp_m[0] = 1;
+	for (col = 1; col < k; col++)
+		tmp_m[col] = 0;
+	for (p = tmp_m + k, row = 0; row < n - 1; row++, p += k)
+	{
+		for (col = 0; col < k; col++)
+			p[col] = gf_exp[modnn(row * col)];
+	}
+
+	if (invert_vdm(tmp_m, k)) /* much faster than invert_mat */
+	{
+		free(retval->enc_matrix);
+		free(retval);
+		free(tmp_m);
+		return 0;
+	}
+	matmul(tmp_m + k * k, tmp_m, retval->enc_matrix + k * k, n - k, k, k);
+
+	bzero(retval->enc_matrix, k*k*sizeof(gf) );
+	for (p = retval->enc_matrix, col = 0; col < k; col++, p += k + 1)
+		*p = 1;
+	free(tmp_m);
+
+	DEB(pr_matrix(retval->enc_matrix, n, k, "encoding_matrix");)
+	return retval;
+}
+
+void fec_encode(struct fec_parms *code, gf *src[], gf *fec, int index, int sz)
+{
+	int i, k = code->k;
+	gf *p;
+
+	if (GF_BITS > 8)
+		sz /= 2;
+
+	if (index < k)
+		bcopy(src[index], fec, sz*sizeof(gf) );
+	else if (index < code->n)
+	{
+		p = &(code->enc_matrix[index * k]);
+		bzero(fec, sz*sizeof(gf));
+		for (i = 0; i < k; i++)
+			addmul(fec, src[i], p[i], sz );
+	}
+	else
+		;
+
+}
+
+static int shuffle(gf *pkt[], int index[], int k)
+{
+	int i;
+
+	for (i = 0; i < k;)
+	{
+		if (index[i] >= k || index[i] == i)
+			i++;
+		else
+		{
+			int c = index[i];
+
+			if (index[c] == c)
+			{
+				return 1;
+			}
+			SWAP(index[i], index[c], int);
+			SWAP(pkt[i], pkt[c], gf *);
+		}
+	}
+	DEB(
+			for ( i = 0; i < k; i++ )
+			{
+				if (index[i] < k && index[i] != i)
+				{
+					return 1;
+				}
+			}
+	)
+	return 0;
+}
+
+static gf* build_decode_matrix(struct fec_parms *code, gf *pkt[], int index[])
+{
+	int i, k = code->k;
+	gf *p, *matrix = NEW_GF_MATRIX(k, k);
+
+	if (matrix == 0)
+	{
+		return 0;
+	}
+	for (i = 0, p = matrix; i < k; i++, p += k)
+	{
+		if (index[i] < k)
+		{
+			bzero(p, k*sizeof(gf) );
+			p[i] = 1;
+		}
+		else if (index[i] < code->n)
+			bcopy( &(code->enc_matrix[index[i]*k]), p, k*sizeof(gf) );
+		else
+		{
+			free(matrix);
+			return 0;
+		}
+	}
+
+	if (invert_mat(matrix, k))
+	{
+		free(matrix);
+		matrix = 0;
+	}
+	return matrix;
+}
+
+int fec_decode(struct fec_parms *code, gf *pkt[], int index[], int sz)
+{
+	gf *m_dec;
+	gf **new_pkt;
+	int i, row, col, k = code->k;
+
+	if (GF_BITS > 8)
+		sz /= 2;
+
+	if (shuffle(pkt, index, k)) /* error if true */
+		return 1;
+	m_dec = build_decode_matrix(code, pkt, index);
+
+	if (m_dec == 0)
+		return 1; /* error */
+
+	new_pkt = (gf **) my_malloc(k * sizeof(gf *), "new pkt pointers");
+	if (new_pkt == 0)
+	{
+		free(m_dec);
+		return 1;
+	}
+	for (row = 0; row < k; row++)
+	{
+		if (index[row] >= k)
+		{
+			new_pkt[row] = (gf *) my_malloc(sz * sizeof(gf), "new pkt buffer");
+			if (new_pkt[row] == 0)
+			{
+				free(m_dec);
+				for (i = 0; i < row; i++)
+				{
+					free(new_pkt[row]);
+				}
+				free(new_pkt);
+				return 1;
+			}
+			bzero(new_pkt[row], sz * sizeof(gf) );
+			for (col = 0; col < k; col++)
+				addmul(new_pkt[row], pkt[col], m_dec[row*k + col], sz);
+		}
+	}
+
+	for (row = 0; row < k; row++)
+	{
+		if (index[row] >= k)
+		{
+			bcopy(new_pkt[row], pkt[row], sz*sizeof(gf));
+			free(new_pkt[row]);
+		}
+	}
+	free(new_pkt);
+	free(m_dec);
+	return 0;
+}
+
+CFECRtpSession::CFECRtpSession()
+{
+
+	//init for send.
+	m_nRedundentRate = 1;
+	m_nFrameNo = 0;
+
+	m_oldVideotimestamp = 0;
+	m_usLatestVideoSeq = 0;
+
+	int i;
+	for (i = 0; i < FECLISTSIZE; i++)
+	{
+		m_FECListInfo[i].b_isEmpty = true;
+		m_FECListInfo[i].ul_HaveArriveNum = 0;
+		m_FECListInfo[i].ul_timestamp = 0;
+		m_FECListInfo[i].ul_TotalNeedNum = 0;
+	}
+
+}
+
+CFECRtpSession::~CFECRtpSession()
+{
+
+}
+
+void CFECRtpSession::OnRTPPacket(RTPPacket *pack, const RTPTime &receivetime,
+		const RTPAddress *senderaddress)
+{
+	FECHEADER* fec_header;
+	unsigned char *RecvData;
+	RecvData = pack->GetPayloadData();
+	fec_header = (FECHEADER*) RecvData;
+	int Datalen = pack->GetPayloadLength();
+
+	int rtptimestamp = pack->GetTimestamp();
+	int rtpFramNo = pack->GetExtensionID();
+
+	if (m_oldVideotimestamp != 0 || m_usLatestVideoSeq != 0)
+	{
+		if (rtptimestamp <= m_oldVideotimestamp && rtpFramNo
+				<= m_usLatestVideoSeq)
+		{
+			if (m_usLatestVideoSeq - rtpFramNo <= 10 && m_oldVideotimestamp
+					- rtptimestamp <= 10)
+				return;
+
+		}
+		m_usLatestVideoSeq = 0;
+		m_oldVideotimestamp = 0;
+	}
+
+	if (fec_header->FecCoded == 0)
+	{
+
+		int nVideoframeNum;
+		bool bIsSameVideoUDP = false;
+		nVideoframeNum = m_PreSendFrameList.size();
+
+		if (bIsSameVideoUDP == false)
+		{
+			unsigned char* pPacket;
+			pPacket = new unsigned char[Datalen];
+			if (pPacket == NULL)
+			{
+				return;
+			}
+
+			memcpy(pPacket, RecvData, Datalen);
+
+			FRAMEINFO* pFrameInfo = NULL;
+			pFrameInfo = new FRAMEINFO;
+
+			if (pFrameInfo == NULL)
+			{
+				delete pPacket;
+				return;
+			}
+
+			pFrameInfo->FECCoded = false;
+			pFrameInfo->ul_timestamp = rtptimestamp;
+			pFrameInfo->us_latestseq = rtpFramNo;
+			pFrameInfo->l_datalen = Datalen - sizeof(FECHEADER);
+			pFrameInfo->pData = pPacket + sizeof(FECHEADER);
+
+			m_PreSendFrameList.insert(m_PreSendFrameList.end(), pFrameInfo);
+			UpdateFrames();
+
+		}
+	}
+	else
+	{
+		if (fec_header->FecCoded == 1)
+		{//7	
+
+			FRAMEINFO* pFrameInfo;
+			FRAMEINFOLIST::iterator itera;
+			for (itera = m_PreSendFrameList.begin(); itera
+					!= m_PreSendFrameList.end(); ++itera)
+			{
+				pFrameInfo = *itera;
+				if (rtptimestamp == pFrameInfo->ul_timestamp)
+					return;
+			}
+
+			int i;
+			bool b_isNotAdd = true;
+
+			for (i = 0; i < FECLISTSIZE; i++)
+			{//6
+				if (m_VideoDataList[i].size() != 0)
+				{//5
+					if (rtptimestamp == m_FECListInfo[i].ul_timestamp)
+					{
+						b_isNotAdd = false;
+
+						bool bIsSameFECVideoData = false;
+
+						if (bIsSameFECVideoData == false)
+						{
+							unsigned char *pPack = new unsigned char[Datalen];
+							if (pPack == NULL)
+							{
+								return;
+							}
+							memcpy(pPack, RecvData, Datalen);
+
+							m_VideoDataList[i].insert(m_VideoDataList[i].end(),
+									(char*) pPack);
+
+							m_FECListInfo[i].ul_HaveArriveNum++;
+
+							if (m_FECListInfo[i].ul_HaveArriveNum
+									== m_FECListInfo[i].ul_TotalNeedNum)
+							{
+								if (FECDecode(&(m_FECListInfo[i]),
+										&m_VideoDataList[i], pack) == 0)
+								{
+
+									UpdateFrames();
+								}
+								else
+								{
+									printf("\nFEC decode failed.");
+
+								}
+							}
+						}//4
+					}//5					
+				}//6
+			}
+			if (b_isNotAdd)
+			{
+				for (i = 0; i < FECLISTSIZE; i++)
+				{
+
+					if (m_FECListInfo[i].b_isEmpty)
+					{
+						unsigned char *pPack = new unsigned char[Datalen];
+						if (pPack == NULL)
+						{
+							return;
+						}
+						memcpy(pPack, RecvData, Datalen);
+
+						m_VideoDataList[i].insert(m_VideoDataList[i].end(),
+								(char*) pPack);
+
+						m_FECListInfo[i].b_isEmpty = false;
+						m_FECListInfo[i].ul_HaveArriveNum = 1;
+						m_FECListInfo[i].ul_timestamp = rtptimestamp;
+
+						m_FECListInfo[i].ul_TotalNeedNum
+								= fec_header->OriginalK;
+						b_isNotAdd = false;
+						return;
+					}
+				}
+			}
+			if (b_isNotAdd)
+			{
+				ulong time = m_FECListInfo[0].ul_timestamp;
+				int j = 0;
+
+				for (i = 1; i < FECLISTSIZE; i++)
+				{
+					if (m_FECListInfo[i].ul_timestamp < time)
+					{
+						time = m_FECListInfo[i].ul_timestamp;
+						j = i;
+					}
+				}
+
+				char* p;
+				FECDATALIST::iterator itera;
+				for (itera = m_VideoDataList[j].begin(); itera
+						!= m_VideoDataList[j].end(); ++itera)
+				{
+					p = *itera;
+					delete p;
+					p = 0;
+				}
+				m_VideoDataList[j].clear();
+
+				unsigned char *pPack = new unsigned char[Datalen];
+				if (pPack == NULL)
+				{
+					return;
+				}
+				memcpy(pPack, RecvData, Datalen);
+
+				m_VideoDataList[j].insert(m_VideoDataList[j].end(),
+						(char*) pPack);
+
+				m_FECListInfo[j].b_isEmpty = false;
+				m_FECListInfo[j].ul_HaveArriveNum = 1;
+				m_FECListInfo[j].ul_timestamp = rtptimestamp;
+				m_FECListInfo[j].ul_TotalNeedNum = fec_header->OriginalK;
+				return;
+			}
+		}
+	}
+	return;
+
+}
+
+int CFECRtpSession::FECDecode(FECLISTINFO* pFecListInfo,
+		FECDATALIST *pFecDataList, RTPPacket *pack)
+{
+	int PSize;
+	int *ixs;
+	void *code;
+	unsigned char* *d_src;
+
+	unsigned char * pDataBuf;
+	ulong ul_timestamp;
+	unsigned int kCount;
+	kCount = pFecListInfo->ul_TotalNeedNum;
+
+	FECHEADER* fec_header;
+	unsigned char *RecvData;
+	RecvData = pack->GetPayloadData();
+	fec_header = (FECHEADER*) RecvData;
+	int rtptimestamp = pack->GetTimestamp();
+	int rtpFramNo = pack->GetExtensionID();
+
+	ul_timestamp = rtptimestamp;
+	PSize = fec_header->PacketSize;
+
+	code = (*fec_new)(fec_header->OriginalK, fec_header->RedunN);
+	if (code == NULL)
+	{
+		return 1;
+	}
+	ixs = new int[kCount];
+	if (ixs == NULL)
+	{
+		fec_free((struct fec_parms *) code);
+		return 1;
+	}
+	d_src = new PUCHAR[kCount];
+	if (d_src == NULL)
+	{
+		delete ixs;
+		fec_free((struct fec_parms *) code);
+		return 1;
+	}
+	long OriginalDataLen;
+	unsigned int j;
+	for (j = 0; j < kCount; j++)
+	{
+		d_src[j] = new unsigned char[PSize];
+		if (d_src[j] == NULL)
+		{
+			delete ixs;
+			fec_free((struct fec_parms *) code);
+			for (unsigned int ii = 0; ii < j; ii++)
+			{
+				delete d_src[ii];
+			}
+			delete d_src;
+			return 1;
+		}
+	}
+	char* p;
+	FECDATALIST::iterator itera;
+	for (j = 0, itera = pFecDataList->begin(); j < kCount && itera
+			!= pFecDataList->end(); j++, itera++)
+	{
+		FECHEADER* fec_header1;
+		p = *itera;
+		fec_header1 = (FECHEADER*) (p);
+
+		ixs[j] = fec_header1->OrigiCol;
+		memcpy(d_src[j], (char*) (p + sizeof(FECHEADER)),
+				fec_header1->PacketSize);
+		delete p;
+	}
+
+	pFecDataList->clear();
+
+	pFecListInfo->b_isEmpty = true;
+	pFecListInfo->ul_HaveArriveNum = 0;
+	pFecListInfo->ul_timestamp = 0;
+	pFecListInfo->ul_TotalNeedNum = 0;
+
+	int CodeResult = 0;
+	try
+	{
+		CodeResult = fec_decode((struct fec_parms *) code,
+				(unsigned char **) d_src, ixs, PSize);
+	} catch (...)
+	{
+		CodeResult = 1;
+	}
+
+	if (CodeResult == 0)
+	{
+
+		OriginalDataLen = GetDataLen(d_src, PSize, kCount);
+		pDataBuf = new unsigned char[OriginalDataLen];
+		if (pDataBuf != NULL)
+		{
+			GetData(pDataBuf, d_src, PSize, kCount);
+
+			FRAMEINFO *pFrameInfo;
+			pFrameInfo = new FRAMEINFO;
+			if (pFrameInfo != NULL)
+			{
+				pFrameInfo->FECCoded = true;
+				pFrameInfo->ul_timestamp = ul_timestamp;
+				pFrameInfo->us_latestseq = rtpFramNo;
+				pFrameInfo->l_datalen = OriginalDataLen;
+				pFrameInfo->pData = pDataBuf;
+
+				m_PreSendFrameList.insert(m_PreSendFrameList.end(), pFrameInfo);
+			}
+		}
+
+	}
+
+	delete ixs;
+	for (unsigned int i = 0; i < kCount; i++)
+	{
+		delete d_src[i];
+	}
+	delete d_src;
+	fec_free((struct fec_parms *) code);
+
+	return CodeResult;
+
+}
+
+long CFECRtpSession::GetDataLen(PUCHAR* d_src, long lPacketSize,
+		unsigned int kCount)
+{
+	PADHEADER* pad_header;
+	long OriginalDataLen = 0;
+
+	for (unsigned int i = 0; i < kCount; i++)
+	{
+		pad_header = (PADHEADER*) (d_src[i]);
+		if (pad_header->paddled == 0)
+		{
+			OriginalDataLen = OriginalDataLen + lPacketSize - sizeof(PADHEADER);
+		}
+		else if (pad_header->paddled == 1)
+		{
+			OriginalDataLen = OriginalDataLen + lPacketSize - sizeof(PADHEADER)
+					- pad_header->padlen;
+		}
+	}
+	return OriginalDataLen;
+}
+
+void CFECRtpSession::GetData(unsigned char* pData, PUCHAR* d_src,
+		long lPacketSize, unsigned int kCount)
+{
+	unsigned char* midbuf;
+	midbuf = pData;
+	PADHEADER* pad_header;
+	for (unsigned int i = 0; i < kCount; i++)
+	{
+		pad_header = (PADHEADER*) (d_src[i]);
+		if (pad_header->paddled == 0)
+		{
+			memcpy(midbuf, d_src[i] + sizeof(PADHEADER), lPacketSize
+					- sizeof(PADHEADER));
+			midbuf = midbuf + lPacketSize - sizeof(PADHEADER);
+		}
+		else if (pad_header->paddled == 1)
+		{
+			memcpy(midbuf, d_src[i] + sizeof(PADHEADER), lPacketSize
+					- sizeof(PADHEADER) - pad_header->padlen);
+			midbuf = midbuf + lPacketSize - sizeof(PADHEADER)
+					- pad_header->padlen;
+		}
+	}
+
+}
+
+int CFECRtpSession::GetRtpMaxLen()
+{
+
+	return RtpMaxLen;
+}
+
+int CFECRtpSession::SendFECPacket(void *lpData, int datalen, int ndelay /* = 5000*/)
+{
+	int nRtpMaxLen;
+	char *pFECPacket;
+	FECHEADER* fec_header;
+
+	pFECPacket = 0;
+	nRtpMaxLen = GetRtpMaxLen();
+
+	IncrementTimestamp(1);
+	SetDefaultTimestampIncrement(0);
+	m_nFrameNo++;
+	if (datalen + sizeof(FECHEADER) <= nRtpMaxLen)
+	{ //Send a FEC packet directly.
+		pFECPacket = new char[datalen + sizeof(FECHEADER)];
+		if (pFECPacket == 0)
+		{
+			return -1;
+		}
+		fec_header = (FECHEADER*) pFECPacket;
+		fec_header->FecCoded = 0;
+		memcpy(pFECPacket + sizeof(FECHEADER), lpData, datalen);
+
+		SendPacketEx(pFECPacket, datalen + sizeof(FECHEADER), m_nFrameNo, 0, 0);
+		delete[] pFECPacket;
+		usleep(ndelay);
+		return 0;
+	}
+
+	FECEncodeSend(lpData, datalen, m_nFrameNo, ndelay);
+	return 0;
+}
+
+int CFECRtpSession::FECEncodeSend(void *pData, long datalen,
+		unsigned int FrameNo, int ndelay)
+{
+	int SZ;
+	void *code = 0;
+	int kk;
+	uchar* SendData = 0;
+	FECHEADER* fec_header;
+	PADHEADER* pad_header;
+	int lim = GF_SIZE + 1;
+	int *ixs = 0;
+	int redudant, i;
+	int lastpacketlen;
+	uchar **d_original, **d_src;
+
+	bool CodeResult = true;
+
+	SZ = GetRtpMaxLen();
+	try
+	{
+		kk = datalen / (SZ - sizeof(PADHEADER));
+	} catch (...)
+	{
+		return -1;
+	}
+	if (kk < 0)
+		return -1;
+	lastpacketlen = datalen % (SZ - sizeof(PADHEADER));
+	if (lastpacketlen != 0)
+		kk++;
+	d_original = (uchar**) malloc(kk * sizeof(void *));
+	if (d_original == 0)
+		return -2;
+
+	d_src = (uchar**) malloc(kk * sizeof(void *));
+	if ((d_original == 0) || (d_src == 0))
+	{
+		free(d_original);
+		return -3;
+	}
+	for (i = 0; i < kk; i++)
+	{
+		d_original[i] = 0;
+		d_src[i] = 0;
+	}
+
+	for (i = 0; i < kk; i++)
+	{
+		d_original[i] = (uchar*) malloc(SZ);
+		if (d_original[i] == 0)
+			goto fail;
+		d_src[i] = (uchar*) malloc(SZ);
+		if (d_src[i] == 0)
+			goto fail;
+	}
+	code = (*fec_new)(kk, lim);
+	if (code == 0)
+	{
+		goto fail;
+	}
+
+	ixs = (int*) malloc(kk * sizeof(int));
+	if (ixs == 0)
+		goto fail;
+
+	SendData = (uchar*) malloc(SZ + sizeof(FECHEADER));
+	if (SendData == 0)
+		goto fail;
+
+	for (i = 0; i < kk; i++)
+		ixs[i] = kk + i;
+
+	for (i = 0; i < kk; i++)
+	{
+		pad_header = (PADHEADER*) d_original[i];
+		if ((i != (kk - 1)) || (lastpacketlen == 0))
+		{
+			pad_header->paddled = UNPAD;
+			pad_header->padlen = 0;
+
+			memcpy(d_original[i] + sizeof(PADHEADER), (uchar*) pData + i * (SZ
+					- sizeof(PADHEADER)), SZ - sizeof(PADHEADER));
+		}
+		else
+		{
+			pad_header->paddled = ISPAD;
+			pad_header->padlen = SZ - sizeof(PADHEADER) - lastpacketlen;
+			memcpy(d_original[i] + sizeof(PADHEADER), (uchar*) pData + i * (SZ
+					- sizeof(PADHEADER)), lastpacketlen);
+			memset(d_original[i] + sizeof(PADHEADER) + lastpacketlen, 'A', SZ
+					- sizeof(PADHEADER) - lastpacketlen);
+		}
+	}
+
+	int maxpacket;
+
+	if (m_nRedundentRate <= 0)
+	{
+		maxpacket = 0;
+	}
+	else if (m_nRedundentRate > 200)
+	{
+
+		maxpacket = 0;
+	}
+	else if (m_nRedundentRate > 100)
+	{
+		maxpacket = (int) ((m_nRedundentRate - 100) * kk / 100) + 1;
+		if (maxpacket > kk)
+		{
+			maxpacket = kk;
+		}
+
+		if (maxpacket > MAXFECPACKET - kk)
+		{
+			maxpacket = MAXFECPACKET - kk;
+		}
+	}
+	else
+	{
+		if (kk < 5)
+		{
+			maxpacket = kk;
+
+			if (maxpacket > MAXFECPACKET - kk)
+			{
+				maxpacket = MAXFECPACKET - kk;
+			}
+		}
+		else
+		{
+			maxpacket = (int) (m_nRedundentRate * kk / 100) + 5;
+
+			if (maxpacket > kk)
+			{
+				maxpacket = kk;
+			}
+			if (maxpacket > MAXFECPACKET - kk)
+			{
+				maxpacket = MAXFECPACKET - kk;
+			}
+		}
+	}
+
+	for (i = 0; i < maxpacket; i++)
+	{
+		try
+		{
+			fec_encode((fec_parms *) code, (unsigned char**) d_original,
+					(unsigned char*) (d_src[i]), ixs[i], SZ);
+		} catch (...)
+		{
+			CodeResult = false;
+		}
+	}
+
+	if (CodeResult == false)
+		goto fail;
+	redudant = 0;
+
+	if ((redudant != -1))
+	{
+		for (i = 0; i < kk; i++)
+		{
+			memset(SendData, 0, SZ + sizeof(FECHEADER));
+			fec_header = (FECHEADER*) SendData;
+			fec_header->FecCoded = FECCODED;
+			fec_header->OriginalK = kk;
+			fec_header->OrigiCol = i;
+			fec_header->PacketSize = SZ;
+			fec_header->RedunN = lim;
+			memcpy(SendData + sizeof(FECHEADER), d_original[i], SZ);
+
+			SendPacketEx(SendData, SZ + sizeof(FECHEADER), FrameNo, 0, 0);
+			usleep(ndelay);
+		}
+	}
+
+	if (kk > 20)
+	{
+		if (redudant == -1)
+		{
+			redudant = 1;
+		}
+		else if (kk > 20)
+		{
+			redudant = +5;
+		}
+	}
+
+	if (redudant >= kk)
+	{
+		redudant = kk;
+	}
+
+	if (kk + redudant >= MAXFECPACKET)
+		redudant = MAXFECPACKET - kk;
+
+	for (i = 0; i < maxpacket; i++)
+	{
+		memset(SendData, 0, SZ + sizeof(FECHEADER));
+		fec_header = (FECHEADER*) SendData;
+		fec_header->FecCoded = FECCODED;
+		fec_header->OriginalK = kk;
+		fec_header->OrigiCol = kk + i;
+		fec_header->PacketSize = SZ;
+		fec_header->RedunN = lim;
+		memcpy(SendData + sizeof(FECHEADER), d_src[i], SZ);
+
+		SendPacketEx(SendData, SZ + sizeof(FECHEADER), FrameNo, 0, 0);
+		usleep(ndelay);
+	}
+
+	if (SendData != 0)
+		free(SendData);
+	if (code != 0)
+		fec_free((fec_parms *) code);
+	for (i = 0; i < kk; i++)
+	{
+		free(d_original[i]);
+		free(d_src[i]);
+	}
+	free(d_original);
+	free(d_src);
+	free(ixs);
+	return 0;
+	fail: if (SendData != 0)
+		free(SendData);
+	if (code != 0)
+		fec_free((fec_parms *) code);
+	for (i = 0; i < kk; i++)
+	{
+		if (d_original[i] != 0)
+			free(d_original[i]);
+		if (d_src[i] != 0)
+			free(d_src[i]);
+	}
+	if (d_original != 0)
+		free(d_original);
+	if (d_src != 0)
+		free(d_src);
+	if (ixs != 0)
+		free(ixs);
+	return -5;
+}
+
+void CFECRtpSession::UpdateFrames()
+{
+	int framecount;
+	FRAMEINFO * p;
+	FRAMEINFOLIST::iterator itera;
+
+	framecount = m_PreSendFrameList.size();
+	if (framecount == 0)
+		return;
+
+	for (itera = m_PreSendFrameList.begin(); itera != m_PreSendFrameList.end(); ++itera)
+	{
+		p = *itera;
+		m_usLatestVideoSeq = p->us_latestseq;
+		m_oldVideotimestamp = p->ul_timestamp;
+		ProcessFrame(p->pData, p->l_datalen);
+		RemoveFrame(p);
+		p = 0;
+	}
+	m_PreSendFrameList.clear();
+	return;
+
+	for (itera = m_PreSendFrameList.begin(); itera != m_PreSendFrameList.end(); ++itera)
+	{
+		p = *itera;
+		if (p->us_latestseq == uint16_t(m_usLatestVideoSeq + 1))
+		{
+			m_usLatestVideoSeq = p->us_latestseq;
+			m_oldVideotimestamp = p->ul_timestamp;
+			ProcessFrame(p->pData, p->l_datalen);
+			RemoveFrame(p);
+			p = 0;
+			m_PreSendFrameList.erase(itera);
+			UpdateFrames();
+			return;
+		}
+	}
+
+	if (framecount < 3)
+		return;
+
+	FRAMEINFO *fff;
+	FRAMEINFOLIST::iterator kkk;
+	kkk = m_PreSendFrameList.begin();
+	fff = *kkk;
+	for (itera = kkk; itera != m_PreSendFrameList.end(); ++itera)
+	{
+		p = *itera;
+		if (fff->ul_timestamp > p->ul_timestamp)
+		{
+			kkk = itera;
+			fff = p;
+		}
+	}
+
+	m_usLatestVideoSeq = fff->us_latestseq;
+	m_oldVideotimestamp = fff->ul_timestamp;
+	ProcessFrame(fff->pData, fff->l_datalen);
+	RemoveFrame(fff);
+	fff = 0;
+	m_PreSendFrameList.erase(kkk);
+
+	return;
+
+}
+
+void CFECRtpSession::ProcessFrame(unsigned char *recvdata, int recvlen)
+{
+	return;
+
+}
+
+void CFECRtpSession::RemoveFrame(FRAMEINFO *p)
+{
+	if (p->FECCoded)
+		delete p->pData;
+	else if (!p->FECCoded)
+		delete (p->pData - sizeof(FECHEADER));
+	delete p;
+}

Added: incubator/bluesky/trunk/RealClass/Student-1.0/src/fecrtpsession.h
URL: http://svn.apache.org/viewvc/incubator/bluesky/trunk/RealClass/Student-1.0/src/fecrtpsession.h?rev=819898&view=auto
==============================================================================
--- incubator/bluesky/trunk/RealClass/Student-1.0/src/fecrtpsession.h (added)
+++ incubator/bluesky/trunk/RealClass/Student-1.0/src/fecrtpsession.h Tue Sep 29 12:17:17
2009
@@ -0,0 +1,117 @@
+// fecrtpsession.h: interface for the CFECRtpSession class.
+
+#include <rtpsession.h>
+#include <rtppacket.h>
+#include <rtpipv4address.h>
+#include <rtpsessionparams.h>
+#include <rtpudpv4transmitter.h>
+
+#if !defined(_FECRTPSESSION_H__INCLUDED_)
+#define _FECRTPSESSION_H__INCLUDED_
+
+#define uchar char 
+#define ushort unsigned short   
+#define ulong unsigned long    
+
+#define  ISPAD 1            
+#define  UNPAD 0             
+#define  FECCODED 1
+#define  SENDFREQUENCY  1        
+#define  MAXSENDBUFFER 10000     
+#define  MAXFECPACKET   255       
+
+#define  FRAMENUM	2
+typedef struct _PADHEADER
+{
+	ushort paddled;
+	ushort padlen;
+} PADHEADER;
+
+typedef struct _FECHEADER
+{
+	ulong FecCoded :1;
+	ulong OriginalK :10;
+	ulong RedunN :11;
+	ulong OrigiCol :10;
+	ulong PacketSize;
+} FECHEADER;
+
+typedef struct _FECLISTINFO
+{
+	ulong ul_timestamp;
+	ulong ul_TotalNeedNum;
+	ulong ul_HaveArriveNum;
+	bool b_isEmpty;
+} FECLISTINFO;
+
+typedef struct _FRAMEINFO
+{
+	bool FECCoded;
+	ulong ul_timestamp;
+	uint16_t us_latestseq;
+	long l_datalen;
+	unsigned char *pData;
+} FRAMEINFO;
+
+typedef std::list<char*> FECDATALIST;
+typedef std::list<FRAMEINFO*> FRAMEINFOLIST;
+
+typedef unsigned char * PUCHAR;
+
+#define FECLISTSIZE	3
+
+class CFECRtpSession: public RTPSession
+{
+public:
+	int ScreenWidth;
+	int ScreenHeight;
+private:
+	enum FECRTP
+	{
+		RtpMaxLen = 4096
+	};
+
+private:
+	long GetDataLen(PUCHAR* d_src, long lPacketSize, unsigned int kCount);
+	void GetData(unsigned char* pData, PUCHAR* d_src, long lPacketSize,
+			unsigned int kCount);
+	virtual void OnRTPPacket(RTPPacket *pack, const RTPTime &receivetime,
+			const RTPAddress *senderaddress);
+	int FECDecode(FECLISTINFO* pFecListInfo, FECDATALIST *pFecDataList,
+			RTPPacket *pack);
+public:
+
+	inline uint16_t GetFrameNo()
+	{
+		return m_nFrameNo;
+	}
+	;
+	int SendFECPacket(void *lpData, int datalen, int delay = 5000);
+public:
+	CFECRtpSession();
+	virtual ~CFECRtpSession();
+private:
+	int FECEncodeSend(void* pData, long datalen, unsigned int FrameNo,
+			int delay);
+	int GetRtpMaxLen();
+
+private:
+	void RemoveFrame(FRAMEINFO* p);
+	virtual void ProcessFrame(unsigned char* framedata, int framelen);
+	void UpdateFrames();
+	//for FECEncode send.
+	uint16_t m_nFrameNo;
+	int m_nRedundentRate;
+
+protected:
+	uint16_t m_usLatestVideoSeq;
+	int m_oldVideotimestamp;
+
+private:
+	FRAMEINFOLIST m_PreSendFrameList; //
+	FECLISTINFO m_FECListInfo[FECLISTSIZE]; //
+	FECDATALIST m_VideoDataList[FECLISTSIZE]; //
+
+};
+
+#endif // !defined(_FECRTPSESSION_H__INCLUDED_)



Mime
View raw message