You are viewing a plain text version of this content. The canonical link for it is here.
Posted to bluesky-commits@incubator.apache.org by pi...@apache.org on 2009/11/30 12:18:38 UTC
svn commit: r885395 [21/23] - in /incubator/bluesky/trunk/RealClass/Student:
./ autom4te.cache/ src/ src/.deps/ src/pic/
Added: incubator/bluesky/trunk/RealClass/Student/src/en_de_video.h
URL: http://svn.apache.org/viewvc/incubator/bluesky/trunk/RealClass/Student/src/en_de_video.h?rev=885395&view=auto
==============================================================================
--- incubator/bluesky/trunk/RealClass/Student/src/en_de_video.h (added)
+++ incubator/bluesky/trunk/RealClass/Student/src/en_de_video.h Mon Nov 30 12:18:34 2009
@@ -0,0 +1,435 @@
+/** \file en_de_video.h Classes for video operation:capture,encoder,decoder,sender,receiver
+*
+*
+*Licensed to the Apache Software Foundation (ASF) under one
+*or more contributor license agreements. See the NOTICE file
+*distributed with this work for additional information
+*regarding copyright ownership. The ASF licenses this file
+*to you under the Apache License, Version 2.0 (the
+*"License"); you may not use this file except in compliance
+*with the License. You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+*Unless required by applicable law or agreed to in writing,
+*software distributed under the License is distributed on an
+*"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+*KIND, either express or implied. See the License for the
+*specific language governing permissions and limitations
+*under the License.
+*/
+
+#include "fecrtpsession.h"
+
+#include <vector>
+#include <deque>
+using std::vector;
+using std::deque;
+
+#include <string>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <time.h>
+#include <sys/time.h>
+#include <iostream>
+#include <stdlib.h>
+
+#define _DEVICE_H_
+#define _LINUX_TIME_H
+
+#include <linux/videodev.h>
+#include <linux/types.h>
+
+// FFmpeg
+#include <ffmpeg/avcodec.h>
+#include <ffmpeg/avformat.h>
+
+// X11
+#include <X11/Intrinsic.h>
+#include <X11/XWDFile.h>
+// Jthread and JMutex
+#include <jthread.h>
+#include <jmutex.h>
+
+#include "en_de_sendthread.h"
+#include "en_de_screen.h"
+
+#if !defined(_EN_DE_VIDEO_H__INCLUDED_)
+#define _EN_DE_VIDEO_H__INCLUDED_
+
+
+//!Video capture
+class V4L
+{
+
+private:
+ //!V4L params
+ enum V4LPARA
+ {
+ VideoWidth = 320, VideoHeight = 240
+ };
+
+private:
+ //!file descriptor
+ int fd;
+ //!Video width
+ int width;
+ //!Video height
+ int height;
+ //!map memory
+ void *map;
+ //!video_mmap struct
+ struct video_mmap frame[32];
+ //!frame stored in maps memory
+ int frame_maps;
+ //!next frame
+ int frame_next;
+ //!number of frames
+ int frames;
+ //!/dev/video0
+ char *device;
+ //!PAL
+ char *input;
+ //!samples per second
+ int sample;
+ //!frames per second
+ int fps;
+public:
+ //!V4LCapability Instance
+ struct video_capability *capability;
+ //!Constuctor
+ V4L();
+ //!Destructor
+ virtual ~V4L();
+ //!Set capture information
+ /*!
+ \param device video device name
+ \param input NTSC or PAL
+ \param sample sample rate for capture
+ */
+ void setInfo(char *device, char *input, int sample);
+ //!Open audio device
+ bool openDevice();
+ //!get Video Width
+ int getWidth();
+ //!get Video Height
+ int getHeight();
+ //!initialise Capture
+ bool initialiseCapture(int format);
+ //!get Next Frame
+ void *getNextFrame();
+ //!get mapped Memory Size
+ int mappedMemorySize(bool init = false);
+};
+//!Video Header Information
+/*!
+\param width video width
+\param height video height
+*/
+typedef struct VideoHeader
+{
+ int width;
+ int height;
+} VideoHeader;
+
+//!Video decoder.
+class CVDecoder
+{
+ friend class CVideoReceiver;
+private:
+ //!video buffer params
+ enum VDECODERBUFSIZE
+ {
+ V_De_ExtraHeaderSize = 10000,
+ V_De_SDLBufSize = 512 * 1024,
+ V_De_INBUF_SIZE = 1024
+ };
+public:
+ //!Constructor
+ CVDecoder();
+ //!Destructor
+ virtual ~CVDecoder();
+ //!Decode a video frame
+ /*!
+ \param encodeddata_v pointer to encodeddata
+ \param encodeddatasize_v the encodeddata size
+ */
+ int DecodeProcess(uint8_t *encodeddata_v, const int encodeddatasize_v);
+ //!Initialise
+ /*!
+ \param width the video width
+ \param height the video height
+ \param nCodecID the Codec ID
+ */
+ bool Init(int width, int height, enum CodecID nCodecID);
+ //!Params for video codec
+ enum VIDEO_CODEC_PARA
+ {
+ V_CODEC_width = 320,
+ V_CODEC_height = 240,
+ V_CODEC_framerate = 25,
+ V_CODEC_frame_rate_base = 1,
+ V_CODEC_gop_size = 8,
+ V_CODEC_max_b_frames = 1
+ };
+ //!Show the decoded video (image)
+ /*!
+ \param parent the Drawable parent window
+ \param x the coordinate
+ \param y the coordinate
+ \param width image width
+ \param height image height
+ */
+ bool CreateXImage(Drawable parent, int x, int y, int width, int height);
+ //!close image display
+ void CloseXImage();
+ //!Get image Color Info
+ /*!
+ \param image the source XImage Struct
+ \param ci the return ColorInfo Struct
+ */
+ void GetColorInfo(XImage *image, ColorInfo *ci /* return struct */);
+
+private:
+ //!close the codec
+ void CloseCodec();
+ //!reset codec params
+ /*!
+ \param width the video width
+ \param height the video height
+ */
+ bool ResetCodec(const int width, const int height);
+ //!mark init status
+ bool m_bInit;
+ //!AVCodec Instance to store the codec
+ AVCodec *m_pCodec;
+ //!AVCodecContext Instance to store the codec content
+ AVCodecContext *m_pCodecCtx;
+ //!AVFrame Instance to store decoded frame
+ AVFrame *m_pOutFrame;
+ //!AVPicture Instance to store decoded picture
+ AVPicture pic_rgb;
+ //!codec width
+ int m_width;
+ //!codec height
+ int m_height;
+ //!Display Instance
+ Display *m_display;
+ //!For dislay image
+ GC m_gc;
+ //!Root window
+ Window m_d;
+ //!window for display image
+ Window m_win;
+ //!image to be displayed
+ XImage *m_image;
+ //!mutex variable for image display
+ JMutex m_imagemutex;
+ //!Store color infor
+ ColorInfo c_info;
+public:
+ //!input pixel format
+ static int input_pixfmt;
+
+};
+
+//!video receiver
+class CVideoReceiver: public CFECRtpSession
+{
+public:
+ //!video header information
+ VideoHeader* pVideo;
+ //Constructor
+ CVideoReceiver();
+ //Destructor
+ virtual ~CVideoReceiver();
+ //Initialise
+ bool Init();
+ //!start receive video data
+ int Start(int nHostPort);
+ //!stop receive the thread
+ void Stop();
+
+public:
+ //!show the image
+ bool CreateXImage(Drawable parent, int x, int y, int width, int height);
+ //!close the image display
+ void CloseXImage();
+
+private:
+ //!Deal with the received video data
+ /*!
+ \param framedata pointer to frame data
+ \param framelen length of frame
+ */
+ virtual void ProcessFrame(unsigned char* framedata, int framelen);
+
+private:
+ //!mark init status
+ bool m_bInit;
+ //!call video decoder
+ CVDecoder m_vdecoder;
+};
+//!Video encoder
+class CV4LVEncoder
+{
+ friend class CV4LStuVideoSender;
+
+private:
+ enum V4L_VENCODE_BUFSIZE
+ {
+ V_En_OutBufSize = 400 * 1024
+ };
+ //!Params for video codec
+ enum V4L_VIDEO_CODEC_PARA
+ {
+ V_CODEC_framerate = 16,
+ V_CODEC_frame_rate_base = 1,
+ V_CODEC_gop_size = 12,
+ V_CODEC_max_b_frames = 1
+ };
+public:
+ //!Constructor
+ CV4LVEncoder();
+ //!Destructor
+ virtual ~CV4LVEncoder();
+ //!Get Captured video Size
+ /*!
+ \param width video width
+ \param height video height
+ */
+ bool GetCapSize(int &width, int &height);
+ //!Encode the captured video data
+ /*!
+ \param frameaddress pointer to captured video data
+ \param pOutBuf store the encoded video data
+ \param nOutsize the encoded data size
+ */
+ int EncodeProcess(char * frameaddress, uint8_t * pOutBuf, int nOutsize);
+ //!Initialise
+ /*!
+ \param width the video width
+ \param height the video height
+ \param nCodecID the Codec ID
+ */
+ bool Init(int width, int height, enum CodecID nCodecID = CODEC_ID_MPEG4);
+
+private:
+ //!mark init status
+ bool m_bInit;
+ //!AVCodec Instance to store the codec
+ AVCodec *m_pCodec;
+ //!AVCodecContext Instance to store the codec content
+ AVCodecContext *m_pCodecCtx;
+ //!AVFrame Instance to store decoded frame
+ AVFrame *m_pFrame;
+ //!AVPicture Instance to store decoded picture
+ AVPicture m_pic_rgb;
+ //!frame buffer
+ uint8_t *m_pFrameBuf;
+ //!video header information
+ VideoHeader m_VideoHeader;
+};
+
+//!video sender.
+class CV4LStuVideoSender: private JThread
+{
+public:
+ //!work mode
+ enum V4LSTUVIDEO_SEND_MODE
+ {
+ ModeNone = 0, ModeCapture = 1, ModeTransmit = 2
+ };
+private:
+ //!video size
+ enum V4LSTUVIDEO_SEND_PARA
+ {
+ VideoWidth = 320, VideoHeight = 240
+ };
+public:
+ //!Constructor
+ CV4LStuVideoSender();
+ //!Destructor
+ ~CV4LStuVideoSender();
+ //!Initialise
+ bool Init(int nHostPort);
+ //!Add Destination for sending
+ bool AddDestination(const RTPIPv4Address &des);
+ //!Clear Destinations
+ void ClearDestinations();
+ //!start the sender thread
+ int Start();
+ //!stop the sender thread
+ void Stop();
+ //!set work mode
+ void SetMode(V4LSTUVIDEO_SEND_MODE mode);
+ //!Show the captured video (image)
+ /*!
+ \param parent the Drawable parent window
+ \param x the coordinate
+ \param y the coordinate
+ \param width image width
+ \param height image height
+ */
+ bool CreateXImage(Drawable parent, int x, int y, int width, int height);
+ //!close image display
+ void CloseXImage();
+ //!check initialise status
+ bool IsInitialized();
+
+private:
+ //!open video device
+ bool OpenVideo();
+ //!close video device
+ void CloseVideo();
+ //!capture video
+ int Capture(uint8_t** data);
+ //!Play back the captured video
+ void Playback(uint8_t* videodata);
+ //!work thread
+ void *Thread();
+ //!stop tag
+ bool stop;
+ //!mutex for stoping thread
+ JMutex stopmutex;
+private:
+ //!call v4l
+ V4L *m_pV4Ldev;
+ //!call video encoder
+ CV4LVEncoder m_vencoder;
+ //!store the sending data
+ uint8_t *m_pOutBuf;
+ //!mark init status
+ bool m_bInit;
+ //!mutex for init
+ JMutex m_initmutex;
+ //!work mode
+ V4LSTUVIDEO_SEND_MODE m_mode;
+ //!mutex for work mode
+ JMutex m_modemutex;
+
+ //!for fec transmmiosn.
+ CFECRtpSession m_fecrtpsession;
+
+ //!Display Instance
+ Display *m_display;
+ //!For dislay image
+ GC m_gc;
+ //!Root window
+ Window m_d;
+ //!window for display image
+ Window m_win;
+ //!image to be displayed
+ XImage *m_image;
+ //!mutex variable for image display
+ JMutex m_imagemutex;
+ //!Store color infor
+ ColorInfo c_info;
+
+};
+
+#endif // !defined(_EN_DE_VIDEO_H__INCLUDED_)
Added: incubator/bluesky/trunk/RealClass/Student/src/errormessage.h
URL: http://svn.apache.org/viewvc/incubator/bluesky/trunk/RealClass/Student/src/errormessage.h?rev=885395&view=auto
==============================================================================
--- incubator/bluesky/trunk/RealClass/Student/src/errormessage.h (added)
+++ incubator/bluesky/trunk/RealClass/Student/src/errormessage.h Mon Nov 30 12:18:34 2009
@@ -0,0 +1,89 @@
+/** \file errormessage.h define various errors
+*
+*
+*Licensed to the Apache Software Foundation (ASF) under one
+*or more contributor license agreements. See the NOTICE file
+*distributed with this work for additional information
+*regarding copyright ownership. The ASF licenses this file
+*to you under the Apache License, Version 2.0 (the
+*"License"); you may not use this file except in compliance
+*with the License. You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+*Unless required by applicable law or agreed to in writing,
+*software distributed under the License is distributed on an
+*"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+*KIND, either express or implied. See the License for the
+*specific language governing permissions and limitations
+*under the License.
+*/
+#define screensize_error "Screen config failure "
+
+#define screensize_errorms "\n\nPlease set screen as 1024Ã768 "
+
+#define getIP_error "Can't obtain local IP!"
+
+#define getIP_errorms "\n\nManual configure please!"
+
+#define usename_error "Logon failure"
+
+#define usename_errorms "\n\nNo user name!"
+
+#define usename_error1 "Logon failure"
+
+#define usename_error1ms "User name too long!\n No more than 10 Chinese characters \nor 30 English characters"
+
+#define config_error1 "Receive port error!"
+
+#define config_error1ms "\nPlease set the port as an \neven number greater than 1024."
+
+#define load_error1 "Logon server failure!"
+
+#define load_error1ms "\nCan't logon server.\nCheck the configuration please."
+
+#define load_error2 "Can't logon system."
+
+#define load_error2ms "\nUser name have been used.\nChange another one please!"
+
+#define load_error3 "Can't logon system."
+
+#define load_error3ms "\n\nStudents client overload."
+
+#define load_error4 "Can't logon system."
+
+#define load_error4ms "\n\nNetwork error.Logon again!"
+
+#define getclasslist_error "Obtain group message error."
+
+#define getclasslist_errorms "\nJoin class later \nor logon system again."
+
+#define addclass_error "Join class failure."
+
+#define addclass_errorms "\n\nSelect class again please."
+
+#define addclass_error1 "Join class failure."
+
+#define addclass_error1ms "\nSorry!Too many students \njoin this class.Try later."
+
+#define exitclass_error " "
+
+#define exitclass_errorms "Quit class failure,try again!"
+
+#define focus_error1 "Apply for focus failure."
+
+#define focus_error1ms "\nFocus already exist.\nTry later."
+
+#define focus_error2 "Apply for focus failure."
+
+#define focus_error2ms "\nTeacher client deny.\nTry later."
+
+#define killfocus_error "Kill focus failure."
+
+#define killfocus_errorms "\nCan't get teacher's permit.\nTry later."
+
+#define getstulist_error "Can't obtain the students list.\nTry again."
+
+#define port_error "Receive port configuration error."
+
+#define port_errorms "\nPlease set the port as an \neven number greater than 1024."
Added: incubator/bluesky/trunk/RealClass/Student/src/fecrtpsession.cpp
URL: http://svn.apache.org/viewvc/incubator/bluesky/trunk/RealClass/Student/src/fecrtpsession.cpp?rev=885395&view=auto
==============================================================================
--- incubator/bluesky/trunk/RealClass/Student/src/fecrtpsession.cpp (added)
+++ incubator/bluesky/trunk/RealClass/Student/src/fecrtpsession.cpp Mon Nov 30 12:18:34 2009
@@ -0,0 +1,1448 @@
+/** \file fecrtpsession.cpp implementation of the CFECRtpSession class
+*
+*
+*Licensed to the Apache Software Foundation (ASF) under one
+*or more contributor license agreements. See the NOTICE file
+*distributed with this work for additional information
+*regarding copyright ownership. The ASF licenses this file
+*to you under the Apache License, Version 2.0 (the
+*"License"); you may not use this file except in compliance
+*with the License. You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+*Unless required by applicable law or agreed to in writing,
+*software distributed under the License is distributed on an
+*"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+*KIND, either express or implied. See the License for the
+*specific language governing permissions and limitations
+*under the License.
+*/
+
+#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/src/fecrtpsession.h
URL: http://svn.apache.org/viewvc/incubator/bluesky/trunk/RealClass/Student/src/fecrtpsession.h?rev=885395&view=auto
==============================================================================
--- incubator/bluesky/trunk/RealClass/Student/src/fecrtpsession.h (added)
+++ incubator/bluesky/trunk/RealClass/Student/src/fecrtpsession.h Mon Nov 30 12:18:34 2009
@@ -0,0 +1,137 @@
+/** \file fecrtpsession.h interface for the CFECRtpSession class
+*
+*
+*Licensed to the Apache Software Foundation (ASF) under one
+*or more contributor license agreements. See the NOTICE file
+*distributed with this work for additional information
+*regarding copyright ownership. The ASF licenses this file
+*to you under the Apache License, Version 2.0 (the
+*"License"); you may not use this file except in compliance
+*with the License. You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+*Unless required by applicable law or agreed to in writing,
+*software distributed under the License is distributed on an
+*"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+*KIND, either express or implied. See the License for the
+*specific language governing permissions and limitations
+*under the License.
+*/
+
+
+#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_)