h264 / aac es流转ts流 代码

已于 2024-03-02 14:01:35 修改
阅读量328 收藏 9
点赞数 5
分类专栏： 音视频 linux 文章标签： 音视频 linux
于 2024-02-29 20:00:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37059136/article/details/136379381
版权

开发中遇到调用sdk返回音视频es数据,需要封包成ts流转发到组播,再拉流回放,其中es到ts之间经历了两次封包,其中细节可参考如下文章:

打包TS

es pes ts 分析

关于es ts

几代人的努力,智慧的结晶,人类的文明之光,黑暗中的那道光,出现吧,源码!!!

头文件 es2ts.h

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/types.h>
#include <time.h>

#define DATA_TYPE_UNKNOWN 0
#define DATA_TYPE_VIDEO	96
#define DATA_TYPE_AUDIO	98

#define DATA_TYPE_USER	3

#define MAX_SIZE_SAVE_TS 6000*188

#define TS_PKT_LEN	188
#define DEF_TS_PKT_LEN	1316
#define LPCMPACKTLEN	4
#define PCMAUDIOPETPACKETLEN	14
#define PMTLEN	44
#define DATELEN	22
#define DATELEN1	12
#define VIDEOTIMEINTERVAL 3000
#define AUDIOTIMEINTERVAL 1920//1875
#define CACHEVIDEOFREMCNT	15 //视频缓存个数
#define VIDEOFREAMLEN	150



typedef struct
{
	unsigned int 		m_iDatalen;
	int				m_frametype;
	unsigned int		m_uiPartTimeTamp;//音频分帧时间戳
	unsigned char		m_c48KTwoChnPcmBufPart[8192];
}TAudio48KTwoChnPart;

typedef struct
{
	int 				m_iDatalen;
	int 				m_frametype;
	unsigned int		m_uTimeTamp;
	unsigned char		m_cVideoBuf[VIDEOFREAMLEN * 1024];
}TVideoFream;

typedef struct _es2tsParam
{
	unsigned short pc48KTwoChnPcmBigEndianBuf[4096 * 3];//存放转化后的大端音频格式
	TAudio48KTwoChnPart Audio48KTwoChnPcmPart[6];//存放音频分解的数据
	TVideoFream VideoFreamCach[CACHEVIDEOFREMCNT];//存放缓存的视频数据,缓存5帧视频,累计大于5帧开始丢弃
	unsigned int videoLastTime ;
	unsigned int audioLastTime ;
	int videoAddTime ;//VIDEOTIMEINTERVAL;
	int audioAddTime ;//AUDIOTIMEINTERVAL;
	double videoFPS ;
	int fpsFlag ;
	int audioFlag ;
	int audioTmp ;
	int nFindPFream ;
	int iNeedAudioFream ;
	int iNeedVideoFream ;
	unsigned int uiVideoCnt ;
	unsigned int uiAudioCnt ;
	unsigned int uiWritVideoCnt ;//写入 Ts中的视频帧个数
	int iCachVideoCnt ;//缓存的视频帧个数
	unsigned int iWritAudioCnt ;
	unsigned int iExistAudioFream ;//存在 音频帧
	unsigned int uiCurWtsTime ; //记录当前音视频写入 Ts 的时间戳
	int need_i_frame ;
	int g_iWriteTsPCMFileFd ;
}es2tsParam;
typedef struct
{
    int maxPacketSize;
    int encid;
    int encrypt;
    int ts_id;
    int prog_num;
    int pmt_pid;
    int pcr_pid;
    int vid_pid;
    int aud_pid;
    int cbr;
    int cbr_pkt_rate;
    int pcr_interval;
    int cbr_bit;
    int vbitrate;
    int fps;
} TSWRITER_CONFIG;

typedef struct
{
    TSWRITER_CONFIG cfg;

    int video_audio;
    int pat_present;
    int pat_cnt;
    int pmt_cnt;
    int pcr_cnt;
    int *pcr_cnt_ptr;
    int vid_cnt;
    int aud_cnt;
    int spsFound;
    int samplingFrequencyIndex;
    int channelConfiguration;

    int first_pcr;
    int avg_count;
    int pkt_count;
    unsigned int pcr;
    unsigned int pcr_high;
    int accum_pkt;	// number of packets accum
    int frame_pkt;

} TSWRITER_HANDLE;

unsigned int sync_timestamp_a_to_v(unsigned timestamp, int samplingFrequencyIndex);
int store_ts_from_es(unsigned char *outPut,unsigned int outPtrLen, unsigned char *esbuf, int boxSize, unsigned int sample_type, unsigned int timestamp, int samplingFrequencyIndex = 0, int channelConfiguration = 0);
int sampling_frequeny_change(long fre);
int init_e2t_param(es2tsParam * e2tPtr);
int m_es2ts(es2tsParam * e2tPtr ,unsigned char *data,unsigned int dataLen,unsigned int frameType, unsigned int timestamp,unsigned char *outPut,unsigned int outPutLen);
void InitSocket(int *UdpSocket, int iPort,char * ethName,char * MulticIp);
int send_ts_stream(int socket,unsigned char * sendPtr,int sendLen);

cpp文件

#include "es2ts.h"
#include "g711.h"
#include <net/if.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/time.h>

typedef unsigned int DWORD32, *PDWORD32;
typedef unsigned long       DWORD;
typedef unsigned char       BYTE;

typedef enum 
{
    STREAM_FRAME_RAW_AUDIO = 3,
    STREAM_FRAME_H264_IDR,
    STREAM_FRAME_H264_I,
    STREAM_FRAME_H264_P,
    STREAM_FRAME_H264_B,
    STREAM_FRAME_H264_SPS,
    STREAM_FRAME_H264_PPS,
    STREAM_FRAME_JPEG,
    STREAM_FRAME_G711,
    STREAM_FRAME_AAC,
    STREAM_FRAME_MPEG4_I,
    STREAM_FRAME_MPEG4_P,
    STREAM_FRAME_MPEG4_B,
    STREAM_FRAME_MPEG4_VOL,
    STREAM_FRAME_MOTION_VALUES = 18,
    STREAM_FRAME_RAW_VIDEO,
    STREAM_FRAME_H264_SVC_SEI,
    STREAM_FRAME_H264_SVC_PREFIX,
    STREAM_FRAME_H264_SVC_SUBSET_SPS,
    STREAM_FRAME_H264_SVC_SLICE_SCALABLE,
    STREAM_FRAME_MPEG2_I,
    STREAM_FRAME_MPEG2_P,
    STREAM_FRAME_MPEG2_B,
    STREAM_FRAME_CMD_RESPONSE,
    STREAM_FRAME_JPEG_SNAPSHOT,
    STREAM_FRAME_APP_ANALYTIC = 90,
    STREAM_FRAME_VIDEO_ENCODED_PRIMARY = 100,
    STREAM_FRAME_VIDEO_ENCODED_SECONDARY,
    STREAM_FRAME_AUDIO_ENCODED,
    STREAM_FRAME_ANALYTIC,
    STREAM_FRAME_RAW_VIDEO_SECONDARY,
    STREAM_FRAME_VIDEO_ENCODED,
    STREAM_FRAME_RTP_PACKAGE_H264 = 150,
    STREAM_FRAME_RTP_PACKAGE_MPEG4V,
    STREAM_FRAME_RTP_PACKAGE_MJPEG,
    STREAM_FRAME_RTP_PACKAGE_MP2T,
    STREAM_FRAME_RTP_PACKAGE_G711A = 180,
    STREAM_FRAME_RTP_PACKAGE_G711U,
    STREAM_FRAME_RTP_PACKAGE_L16,
    STREAM_FRAME_RTP_PACKAGE_AAC,
    STREAM_FRAME_RTP_PACKAGE_G726,
    STREAM_FRAME_RTP_PACKAGE_MPA,
    STREAM_FRAME_TS_PACKAGE,
    STREAM_FRAME_DOWNLOAD_PROGRESS_INDICATOR = 254,       // 下载进度提示
    STREAM_FRAME_INVALID = 255
}Stream_Frame_type;
#define DBG_MSG_ON 0



static unsigned char pat_pkt[] = {
  0x47, 0x40, 0x00, 0x10, 0x00, 0x00, 0xB0, 0x0D, 0x59, 0x81, 0xEB, 0x00, 0x00, 0x00, 0x01, 0xE0,
  0x42, 0x5E, 0x44, 0x05, 0x9A, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};

static unsigned char pmt_pkt_va[] = {
  0x47, 0x40, 0x42, 0x10, 0x00, 0x02, 0xb0, 0x2d, 0x00, 0x01, 0xd5, 0x00, 0x00, 0xe0, 0x44, 0xf0,
  0x0c, 0x05, 0x04, 0x48, 0x44, 0x4d, 0x56, 0x88, 0x04, 0x0f, 0xff, 0xfc, 0xfc, 0x1b, 0xe0, 0x44,
  0xf0, 0x00, 0x80, 0xe0, 0x45, 0xf0, 0x0a, 0x05, 0x08, 0x48, 0x44, 0x4d, 0x56, 0x00, 0x80, 0x61,
  0x40, 0x8c, 0xd6, 0x37, 0xbe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
  

static unsigned char pmt_pkt_v[] = {
  0x47, 0x40, 0x42, 0x10, 0x00, 0x02, 0xB0, 0x12, 0x00, 0x01, 0xD5, 0x00, 0x00, 0xE0, 0x44, 0xF0,
  0x00, 0x1B, 0xE0, 0x44, 0xF0, 0x00, 0xFE, 0x8A, 0x98, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };

static int sampling_frequeny[] = {96000, 88200, 64000, 48000, 
								44100, 32000, 24000, 22050,
								16000,  2000, 11025,  8000};

static DWORD32 crc32_table[256];
static unsigned char * ptsbuf = NULL;

unsigned int sync_timestamp_a_to_v(unsigned timestamp, int samplingFrequencyIndex){
	double tmp = 0;

	if(samplingFrequencyIndex <= 0xb)
		samplingFrequencyIndex = sampling_frequeny[samplingFrequencyIndex];
	tmp = 90 * ( ((double)timestamp) / (((double)samplingFrequencyIndex) / 1000));

	return (unsigned int)tmp;
}

int isIFrame(unsigned char frametype)
{
	if(frametype == 4 || frametype == 5)
		return 1;
	return 0;
}

int DateType(int frametype)
{
	switch(frametype)
	{
		case 4:
		case 5:
		case 6:
		case 7:	
			return DATA_TYPE_VIDEO;
		case 11:
			return DATA_TYPE_AUDIO;
		default:
			printf("frame_type unknown:%d\n", frametype);
			return DATA_TYPE_UNKNOWN;
	}
}

static void init_crc32_table()
{
        DWORD32 i, j, k;

        for( i = 0; i < 256; i++ )
        {
            k = 0;
            for( j = (i << 24) | 0x800000; j != 0x80000000; j <<= 1 )
                k = (k << 1) ^ (((k ^ j) & 0x80000000) ? 0x04c11db7 : 0);

            crc32_table[i] = k;
        }
}

DWORD32 crc32(DWORD32 _crc, const BYTE *buf, DWORD32 len)
{
	DWORD32 i_crc = _crc ^ 0xffffffff;
	unsigned int i;
	static int init=0;
	if (!init) {
		init_crc32_table();
		init = 1;
	}
	for (i = 0; i < len; i++)
		i_crc = (i_crc << 8) ^ crc32_table[((i_crc >> 24) ^ buf[i]) & 0xff];

	return i_crc;
}


TSWRITER_HANDLE *tsWriterCreate()
{
		TSWRITER_HANDLE *h;
	    if(!(h = (TSWRITER_HANDLE *)malloc(sizeof(TSWRITER_HANDLE))))
	        return NULL;

	    h->video_audio = 1;
	    h->pat_present = 0;
	    h->pat_cnt = 0;
	    h->pmt_cnt = 0;
	    h->pcr_cnt = 0;
	    h->vid_cnt = 0x0F;
	    h->aud_cnt = 0;

    // mark sps not found yet
	    h->spsFound = 0;

    // mark header as not found
	    h->samplingFrequencyIndex = -1;
	    h->channelConfiguration = -1;

    // bitrate count
	    h->first_pcr = 1;
	    h->avg_count = 0;
	    h->pkt_count = 0;
	    h->accum_pkt = 0;
	    h->frame_pkt = 0;

		ptsbuf = (ptsbuf) ? ptsbuf : (unsigned char*)malloc(MAX_SIZE_SAVE_TS);	

		h->cfg.maxPacketSize = DEF_TS_PKT_LEN;
		h->cfg.encid = 0;
		h->cfg.encrypt = 0;
		h->cfg.ts_id = 0x5981;
		h->cfg.prog_num = 1;
		h->cfg.pmt_pid = 0x42;
		h->cfg.pcr_pid = 0;
		h->cfg.vid_pid = 0x44;
		h->cfg.aud_pid = 0x45;
		h->cfg.cbr = 0;
		h->cfg.cbr_pkt_rate = 99;//0
		h->cfg.pcr_interval = 3003;//0
		h->cfg.cbr_bit = 0; 
		h->cfg.vbitrate = 3000000;//0
		h->cfg.fps = 30;//0

		if (h->cfg.pcr_pid == 0 || !h->cfg.cbr) {
    		h->cfg.pcr_pid = h->cfg.vid_pid;
	    		h->pcr_cnt_ptr = &h->vid_cnt;
	    } else {
	        h->pcr_cnt_ptr = &h->pcr_cnt;
	    }
	    if (h->cfg.cbr) {
	        h->avg_count = h->cfg.cbr_pkt_rate;
		    h->pkt_count = h->avg_count - 2;
		}
		return h;
}
int sampling_frequeny_change(long fre){
	switch(fre){
		case 96000:
			return 0x0;
		case 88200:
			return 0x1;
		case 64000:
			return 0x2;
		case 48000:
			return 0x3;
		case 44100:
			return 0x4;
		case 32000:
			return 0x5;
		case 24000:
			return 0x6;
		case 22050:
			return 0x7;
		case 16000:
			return 0x8;
		case 2000:
			return 0x9;
		case 11025:
			return 0xa;
		case 8000:
			return 0xb;
		default:
			return 0xc;
	}
}


int store_ts_from_es(unsigned char *outPut,unsigned int outPtrLen, unsigned char *esbuf, int boxSize, unsigned int frametype, unsigned int timestamp, int samplingFrequencyIndex, int channelConfiguration)
{
	if(!outPut)
		return -1; //ERR:no file...

	unsigned int sampleSize;
	unsigned int cts;
	unsigned int sample_type,sample_flags = 0;
	unsigned char *cur, *tsptr, *tspkt;
	int first;	// first piece of frame
	int payload_size, adaptsize;
	
	static unsigned cts_high = 0x0;
	static unsigned last_timestamp = 0;

	sampleSize = boxSize;//视频大小

	sample_type = DateType(frametype);
	sample_flags |= isIFrame(frametype);
	cts = timestamp;
	//if(cts == last_timestamp)
	//	cts++;

	//samplingFrequencyIndex = (samplingFrequencyIndex>=0x10)?sampling_frequeny_change(samplingFrequencyIndex):samplingFrequencyIndex;
	if(timestamp < last_timestamp && timestamp - last_timestamp <= 100)
		cts_high ^=  0x1;
	last_timestamp = timestamp;

	cur = esbuf;
	
    // malloc a handle
	static TSWRITER_HANDLE *h = NULL;
	if(h == NULL){
		if((h = tsWriterCreate()) == NULL)
			return -2;
	}
	h->video_audio = 1;
	tsptr = ptsbuf;

	if (sample_type == DATA_TYPE_VIDEO) {
        
		if (h->cfg.cbr == 1 || (sample_flags & 1)) 
		{
			unsigned int c;

			//开始组装 PAT 标号
			memcpy(tsptr, pat_pkt, 188);

			tsptr[3] = (tsptr[3] & 0xF0) | h->pat_cnt;
            h->pat_cnt = (h->pat_cnt + 1) & 0x0F;
			tsptr[8] = h->cfg.ts_id >> 8;
			tsptr[9] = h->cfg.ts_id & 0xFF;

			//填充节目号
			tsptr[13] = h->cfg.prog_num >> 8;
			tsptr[14] = h->cfg.prog_num & 0xFF;

			//PMT ID
			tsptr[15] = 0xE0 | (h->cfg.pmt_pid >> 8);
			tsptr[16] = h->cfg.pmt_pid & 0xFF; 

			//填充校验位
			c = crc32(0, tsptr+5, 12);
			tsptr[17] = c >> 24;
			tsptr[18] = (c >> 16) & 0xFF;
			tsptr[19] = (c >> 8) & 0xFF;
			tsptr[20] = c & 0xFF; //四个字节的校验位
			tsptr += 188; //PAT 包组装完成
			h->accum_pkt ++;
			h->pkt_count ++;

			if (h->cfg.cbr == 1 && h->pkt_count >= h->avg_count) 
			{
				unsigned int new_pcr;

				*tsptr++ = 0x47;
				*tsptr++ = h->cfg.pcr_pid>>8;
				*tsptr++ = h->cfg.pcr_pid&0xFF;
				*tsptr++ = 0x20|*h->pcr_cnt_ptr;
				*tsptr++ = 0xB7;
				*tsptr++ = 0x10;	// PCR
				*tsptr++ = (h->pcr_high<<7)|(h->pcr>>25);
				*tsptr++ = (h->pcr>>17)&0xFF;
				*tsptr++ = (h->pcr>>9)&0xFF;
				*tsptr++ = (h->pcr>>1)&0xFF;
				*tsptr++ = 0x7E;
				*tsptr++ = 0x00;
				memset(tsptr, 0xFF, 188-12);
				tsptr += 188-12;
				h->pkt_count = 0;

				new_pcr = h->pcr + h->cfg.pcr_interval;
				if (new_pcr < h->pcr)
					h->pcr_high = h->pcr_high ^ 1;
				h->pcr = new_pcr;
			}

			//开始组装 PMT 包
			memcpy(tsptr, h->video_audio ? pmt_pkt_va : pmt_pkt_v, 188);
			tsptr[1] = 0x40 | (h->cfg.pmt_pid >> 8);
			tsptr[2] = h->cfg.pmt_pid & 0xFF;
			tsptr[3] = (tsptr[3] & 0xF0) | h->pmt_cnt;
			h->pmt_cnt = (h->pmt_cnt + 1) & 0x0F;

			if (h->video_audio)
			{
				//PAT中填写的节目号
				tsptr[8] = h->cfg.prog_num >> 8;
				tsptr[9] = h->cfg.prog_num & 0xFF; 

				//PCR ID
				tsptr[13] = 0xE0 | (h->cfg.pcr_pid >> 8);
				tsptr[14] = h->cfg.pcr_pid & 0xFF;

				//video ID
				tsptr[18 + DATELEN1] = 0xE0 | (h->cfg.vid_pid >> 8); 
				tsptr[19 + DATELEN1] = h->cfg.vid_pid & 0xFF;

				//audio ID
				tsptr[23 + DATELEN1] = 0xE0 | (h->cfg.aud_pid >> 8);
				tsptr[24 + DATELEN1] = h->cfg.aud_pid & 0xFF;
				
				//填充校验位
				c = crc32(0, tsptr + 5, PMTLEN); 
				tsptr[27 + DATELEN] = c >> 24;
				tsptr[28 + DATELEN] = (c >> 16) & 0xFF;
				tsptr[29 + DATELEN] = (c >> 8) & 0xFF;
				tsptr[30 + DATELEN] = c & 0xFF;
			}
			else
			{
				tsptr[8] = h->cfg.prog_num >> 8;
				tsptr[9] = h->cfg.prog_num & 0xFF;
				tsptr[13] = 0xE0 | (h->cfg.pcr_pid >> 8);
				tsptr[14] = h->cfg.pcr_pid & 0xFF;
				tsptr[18] = 0xE0 | (h->cfg.vid_pid >> 8);
				tsptr[19] = h->cfg.vid_pid & 0xFF;
				c = crc32(0, tsptr+5, 17);
				tsptr[22] = c >> 24;
				tsptr[23] = (c >> 16) & 0xFF;
				tsptr[24] = (c >> 8) & 0xFF;
				tsptr[25] = c & 0xFF;
			}
			h->pat_present = 1;
			tsptr += 188;

			h->accum_pkt += 1;
			h->pkt_count += 1;
		}

		/* PCR */
		if (h->cfg.cbr == 1)
		{
			if (h->first_pcr)
			{
				h->pcr_high = cts_high ^ 1;
				h->pcr = cts - h->cfg.pcr_interval * 4;
				h->first_pcr = 0;
			}
		}

		/* Count NALs */
		/*
		num_nal = 0;
		size = sampleSize;
		while (size >= 4) {
			nalsize = (cur[0]<<24)|(cur[1]<<16)|(cur[2]<<8)|cur[3];
			nalsize_tab[num_nal++] = nalsize;
			cur += 4 + nalsize;
			size -= 4 + nalsize;
		}
		sampleSize -= size;*/
		cur = esbuf;
		first = 1;

		while (sampleSize > 0)
		{
			if (h->cfg.cbr == 1 && h->pkt_count >= h->avg_count)
			{
				unsigned int new_pcr;

				*tsptr++ = 0x47;
				*tsptr++ = h->cfg.pcr_pid>>8;
				*tsptr++ = h->cfg.pcr_pid&0xFF;
				*tsptr++ = 0x20|*h->pcr_cnt_ptr;
				*tsptr++ = 0xB7;
				*tsptr++ = 0x10;	// PCR
				*tsptr++ = (h->pcr_high<<7)|(h->pcr>>25);
				*tsptr++ = (h->pcr>>17)&0xFF;
				*tsptr++ = (h->pcr>>9)&0xFF;
				*tsptr++ = (h->pcr>>1)&0xFF;
				*tsptr++ = 0x7E;
				*tsptr++ = 0x00;
				memset(tsptr, 0xFF, 188-12);
				tsptr += 188-12;
				h->pkt_count = 0;

				new_pcr = h->pcr + h->cfg.pcr_interval;
				if (new_pcr < h->pcr)
					h->pcr_high = h->pcr_high ^ 1;
				h->pcr = new_pcr;
			}

			tspkt = tsptr;
			payload_size = sampleSize;
			
			if (first && h->cfg.cbr != 1) 
			{
				adaptsize = 8;		// PCR
				payload_size += 19;	// PTS
			}
			else
			{
				adaptsize = 0;
			}
			
			if (4 + adaptsize + payload_size >= TS_PKT_LEN)
			{
				payload_size = TS_PKT_LEN - 4 - adaptsize;	// shrink payload
			}
			else
			{
				adaptsize = TS_PKT_LEN - 4 - payload_size;	// padding
			}

			//组 TS 头 4字节
			*tsptr++ = 0x47;
			*tsptr++ = first ? (0x40|(h->cfg.vid_pid>>8)) : (h->cfg.vid_pid>>8);
			*tsptr++ = h->cfg.vid_pid&0xFF;
			h->vid_cnt = (h->vid_cnt+1)&0x0F;
			*tsptr++ = (adaptsize > 0 ? 0x30 : 0x10)|h->vid_cnt;

			if (adaptsize > 0)
			{
				*tsptr++ = adaptsize - 1;

				//组自适应数据
				if (first && h->cfg.cbr != 1)
				{
					*tsptr++ = 0x10;	// PCR
					*tsptr++ = (cts_high<<7)|(cts>>25);
					*tsptr++ = (cts>>17)&0xFF;
					*tsptr++ = (cts>>9)&0xFF;
					*tsptr++ = (cts>>1)&0xFF;
					*tsptr++ = 0x7E;
					*tsptr++ = 0x00;

					adaptsize -= 8;
				}
				else
				{	// just padding
					adaptsize--;
					if (adaptsize > 0)
					{
						*tsptr++ = 0x00;
						adaptsize--;
					}
				}
    			while (adaptsize-- > 0)
    				*tsptr++ = 0xFF;
			}

			//帧头组装 PES 包
			if (first) 
			{
				unsigned int pts, pts_high;
				pts = cts + h->cfg.pcr_interval*4;
				//*ppts = pts;

				if (pts < cts)
					pts_high = cts_high ^ 1;
				else
					pts_high = cts_high;

				//组 PES
				*tsptr++ = 0x00;
				*tsptr++ = 0x00;
				*tsptr++ = 0x01; //PES 包头
				*tsptr++ = 0xE0; //流 ID
				*tsptr++ = 0;
				*tsptr++ = 0; //PES一帧数据的总长度,可以填充0
				*tsptr++ = 0x80;
				*tsptr++ = 0xC0;
				*tsptr++ = 0x0A; //后面字节的个数

				// PTS
				*tsptr++ = 0x30|(pts_high<<3)|((pts>>29)&0x06)|1;
				*tsptr++ = (pts>>22);
				*tsptr++ = (pts>>14)|1;
				*tsptr++ = (pts>>7);
				*tsptr++ = (pts<<1)|1;

				// DTS
				*tsptr++ = 0x10|(pts_high<<3)|((pts>>29)&0x06)|1;
				*tsptr++ = (pts>>22);
				*tsptr++ = (pts>>14)|1;
				*tsptr++ = (pts>>7);
				*tsptr++ = (pts<<1)|1;
				payload_size -= 19;
			}

			if (tsptr - tspkt + payload_size != TS_PKT_LEN)
				printf("Error: payload_size = %d\n", payload_size);

			//printf("aa adaptsize = %d, payload_size = %d, tsptr = %p, h->cfg.vid_pid = 0x%x, sampleSize = %d\n", adaptsize, payload_size, tsptr, h->cfg.vid_pid, sampleSize);
			memcpy(tsptr, cur, payload_size);
			/*
			// write NAL start code
			while (curnal < num_nal) {
				while (scindex < 4 && scoff < payload_size) {
					tsptr[scoff] = (scindex == 3);
					scindex++;
					scoff++;
				}
				if (scoff >= payload_size) {
					scoff -= payload_size;
					break;
				}
				scoff += nalsize_tab[curnal];
				curnal++;
				scindex = 0;
			}*/
			tsptr += payload_size;
			cur += payload_size;
			sampleSize -= payload_size;
			first = 0;

			if (h->cfg.cbr == 1)
			{
				h->pkt_count++;
				h->accum_pkt++;
				h->frame_pkt++;
			}
		}

		if (h->cfg.cbr == 1)
		{
			while (h->accum_pkt < h->avg_count)
			{
				*tsptr++ = 0x47;
				*tsptr++ = h->cfg.vid_pid>>8;
				*tsptr++ = h->cfg.vid_pid&0xFF;
				*tsptr++ = 0x20|h->vid_cnt;
				*tsptr++ = 0x83;
				*tsptr++ = 0x00;
				memset(tsptr, 0xFF, 188-6);
				tsptr += 188-6;
				h->accum_pkt++;
				h->pkt_count++;
			}
			h->accum_pkt -= h->avg_count;
			h->frame_pkt = 0;
		}

		if (h->cfg.cbr == 1 && h->pkt_count >= h->avg_count) 
		{
			unsigned int new_pcr;

			*tsptr++ = 0x47;
			*tsptr++ = h->cfg.pcr_pid>>8;
			*tsptr++ = h->cfg.pcr_pid&0xFF;
			*tsptr++ = 0x20|*h->pcr_cnt_ptr;
			*tsptr++ = 0xB7;
			*tsptr++ = 0x10;	// PCR
			*tsptr++ = (h->pcr_high<<7)|(h->pcr>>25);
			*tsptr++ = (h->pcr>>17)&0xFF;
			*tsptr++ = (h->pcr>>9)&0xFF;
			*tsptr++ = (h->pcr>>1)&0xFF;
			*tsptr++ = 0x7E;
			*tsptr++ = 0x00;
			memset(tsptr, 0xFF, 188-12);
			tsptr += 188-12;
			h->pkt_count = 0;

			new_pcr = h->pcr + h->cfg.pcr_interval;
			if (new_pcr < h->pcr)
				h->pcr_high = h->pcr_high ^ 1;
			h->pcr = new_pcr;
		}
	} 
	else if (sample_type == DATA_TYPE_AUDIO){ 		
		if (!h->pat_present)
		{
			return -3;
		}
		
		int frameSize = 0;
		int bitsPerSample = -1; //位率
		int m_channelConfiguration = -1;  //频道
		int m_samplingFrequencyIndex = -1;//采样率索引

		//手动赋值 采样率 频道 位率
		bitsPerSample = 1; //16位
		m_channelConfiguration = 3;  //双声道
		m_samplingFrequencyIndex = 1;//采样率 1==48K
		
		if ((-1 == m_samplingFrequencyIndex) || (-1 == m_channelConfiguration) || (-1 == bitsPerSample)) 
		{
			printf("No sampleFreq or channelConfiguration or bitsPerSample\n");
			return -4;
		}

		first = 1;
		frameSize = sampleSize + LPCMPACKTLEN;// add LPCM HDMV Header(4 bytes)

		while (sampleSize > 0) 
		{
			payload_size = sampleSize;
			
			if (first) //This Audio fream is separated First Packet 
			{
				payload_size += (PCMAUDIOPETPACKETLEN + LPCMPACKTLEN);
			}

			if (4 + payload_size >= TS_PKT_LEN)
			{
				payload_size = TS_PKT_LEN - 4;
			}

			adaptsize = TS_PKT_LEN - 4 - payload_size;
			*tsptr++ = 0x47;
			*tsptr++ = first ? (0x40|(h->cfg.aud_pid >> 8)) : (h->cfg.aud_pid>>8);
			*tsptr++ = h->cfg.aud_pid & 0xFF;
			*tsptr++ = (adaptsize > 0 ? 0x30 : 0x10) | h->aud_cnt;
			h->aud_cnt = (h->aud_cnt+1)&0x0F;

			if (adaptsize > 0) 
			{
				adaptsize--;
				*tsptr++ = adaptsize;

				if (adaptsize > 0)
				{
					if(adaptsize >= 7 && first == 1)
					{
						*tsptr++ = 0x10;
						adaptsize--;
						// PCR info
						*tsptr++ = (cts_high <<7 ) | (cts >> 25);
						*tsptr++ = (cts >> 17) & 0xFF;
						*tsptr++ = (cts >> 9) & 0xFF;
						*tsptr++ = (cts >> 1) & 0xFF;
						*tsptr++ = 0x7E;
						*tsptr++ = 0x00;
						adaptsize -= 6;
					}
					else
					{
						*tsptr++ = 0;
						adaptsize--;
					}
					while (adaptsize-- > 0)
						*tsptr++ = 0xFF;
				}
			}

			if (first)
			{
				unsigned int pts, pts_high;
				pts = cts + h->cfg.pcr_interval*4;
				//*ppts = pts;
				if (pts < cts)
					pts_high = cts_high ^ 1;
				else
					pts_high = cts_high;

				//PES
				*tsptr++ = 0x00;
				*tsptr++ = 0x00;
				*tsptr++ = 0x01; //PES包起始前缀
				*tsptr++ = 0xC0; //流ID
				*tsptr++ = ((frameSize + 8) >> 8)&0xFF;
				*tsptr++ = (frameSize + 8)&0xFF; //PES 包长度
				*tsptr++ = 0x80; //默认规定
				*tsptr++ = 0x80; //只有PTS
				*tsptr++ = 0x05; //PES头数据长度,也就是 后面还有5个字节

				// PTS
				*tsptr++ = 0x20|(pts_high<<3)|((pts>>29)&0x06)|1;
				*tsptr++ = (pts>>22);
				*tsptr++ = (pts>>14)|1;
				*tsptr++ = (pts>>7);
				*tsptr++ = (pts<<1)|1;
				
				// LPCM HDMV Header//bitsPerSample//channel//samplingFrequencyIndex
				frameSize -= LPCMPACKTLEN;
				*tsptr++ = (frameSize >>8 )&0xff;
				*tsptr++ =  frameSize&0xff;
				*tsptr++ =(m_channelConfiguration&0x0f) << 4|(m_samplingFrequencyIndex&0x0f);
				*tsptr++ = ((bitsPerSample&0x3) << 6) & 0xc0;

				payload_size -= (PCMAUDIOPETPACKETLEN + LPCMPACKTLEN);
			}

			memcpy(tsptr, cur, payload_size);
			tsptr += payload_size;
			cur += payload_size;
			sampleSize -= payload_size;
			first = 0;
		}

	} 
	else
		return -5;

	//return 1;
	int ret = tsptr - ptsbuf;
	if(outPtrLen < ret)
	{
		return -6;
	}
	memcpy(outPut,ptsbuf,ret);
	/*int ret = 0; 
	ret	= fwrite(ptsbuf, 1, tsptr - ptsbuf, file);
	fflush(file);*/	
	return ret;
} 

static void G711ChangeToPcm(unsigned char *pcG711Buf, short *pcPcmBuf, int iDateLen)
{
	g711_t *g711 = NULL;
	g711_config_t config;
	config.law = G711_ALAW;
	config.num_channels = 1;
	config.channel_select = 0;
	
	g711_open(&config, &g711);
	g711_decode(g711, iDateLen, pcG711Buf, pcPcmBuf);
	g711_close(g711);
}


/*********************************
函数作用:调整音频采样率 , 原始采样率是8K
参数: 
		iFrequency = 1--> 48000
		iFrequency = 4--> 96000
		iFrequency = 5--> 192000
**********************************/
static void ReSampFrequency(unsigned char *pcPcmBuf, unsigned char *pcReSampPcmBuf, int iDateLen, int iFrequency)
{
	int m = 0;
	int n = 0;
	
	if (1 == iFrequency)//8K 采样率变 48K 采样率
	{
		unsigned char *cur_p48 = pcPcmBuf;
		
		for (n = 0; n < iDateLen; n += 2)
		{
			for (m = 0; m < 12; m += 2)
			{
				memcpy(pcReSampPcmBuf + m + n * 6, cur_p48 + n, 2);
			}
		}
	}
}


//单通道变双声道
static void PcmSingleChnToDoubleChn(unsigned char *pc48KPcmBuf, unsigned char *pc48KTwoChnPcmBuf)
{
	int i = 0;
	unsigned char *cur_p = pc48KPcmBuf;
	
	while (((i + 3) < (4096 * 6)) && cur_p)
	{
		pc48KTwoChnPcmBuf[i + 0] = *cur_p;
		pc48KTwoChnPcmBuf[i + 2] = *cur_p;
		cur_p++;
		pc48KTwoChnPcmBuf[i + 1] = *cur_p;
		pc48KTwoChnPcmBuf[i + 3] = *cur_p;
		cur_p++;
		i += 4;
	}
}

//返回音频数据的长度,pbs:音频数据指针, len:原始音频数据长度 
static int Dealwith8KSigChnG711Audio(unsigned char *pbs, unsigned int len, unsigned short *pc48KTwoChnPcmBigEndianBuf, 
                                     TAudio48KTwoChnPart *Audio48KTwoChnPcmPart, unsigned int *uiAudioCnt, int iFlag,int audioAddTime)
{
	int i = 0;
	short pcPcmBuf[4096] = {0}; //存放Pcm音频
	unsigned char pc48KSigChnPcmBuf[4096 * 6] = {0};//存放48K单声道Pcm音频
	unsigned char pc48KTwoChnPcmBuf[8192 * 6] = {0};//存放48K双声道Pcm音频
	

	// g711A to Pcm
	memset(pcPcmBuf, 0, sizeof(pcPcmBuf));
	G711ChangeToPcm(pbs, pcPcmBuf, len);
	len = 2 * len; // data * 2


	//8K to 48K frenquency
	memset(pc48KSigChnPcmBuf, 0, sizeof(pc48KSigChnPcmBuf));
	ReSampFrequency((unsigned char *)pcPcmBuf, pc48KSigChnPcmBuf, len, 1);
	len = len * 6;//data * 6

	//Pcm single chn to double chn
	memset(pc48KTwoChnPcmBuf, 0, sizeof(pc48KTwoChnPcmBuf));
	PcmSingleChnToDoubleChn(pc48KSigChnPcmBuf, pc48KTwoChnPcmBuf);
	len = len * 2;//data * 2


	memcpy(pc48KTwoChnPcmBigEndianBuf, pc48KTwoChnPcmBuf, sizeof(pc48KTwoChnPcmBuf));
	for(i = 0; i < (4096 * 3); i++)
	{
		pc48KTwoChnPcmBigEndianBuf[i] = ((pc48KTwoChnPcmBigEndianBuf[i] & 0x00ff) << 8) | ((pc48KTwoChnPcmBigEndianBuf[i] & 0xff00) >> 8);
	}
	
	memset(Audio48KTwoChnPcmPart, 0, 6 * sizeof(TAudio48KTwoChnPart));
	for (i = 0; i < 6; i++) //开始分帧 分6帧
	{
		Audio48KTwoChnPcmPart[i].m_frametype = 11;
		Audio48KTwoChnPcmPart[i].m_iDatalen = len / 6;
		Audio48KTwoChnPcmPart[i].m_uiPartTimeTamp = i * audioAddTime + (*uiAudioCnt - iFlag) * audioAddTime * 6;
		memcpy(Audio48KTwoChnPcmPart[i].m_c48KTwoChnPcmBufPart, (unsigned char *)pc48KTwoChnPcmBigEndianBuf + i * len / 6, Audio48KTwoChnPcmPart[i].m_iDatalen);
		//printf("--------Audio48KTwoChnPcmPart:%d,ts:%u\n",i,Audio48KTwoChnPcmPart[i].m_uiPartTimeTamp);
	}

	if (0 == iFlag)
	{
		(*uiAudioCnt)++;
	}
	
	return len;
}



int init_e2t_param(es2tsParam * e2tPtr )
{
	e2tPtr->videoLastTime = 0;
	e2tPtr->audioLastTime = 0;
	e2tPtr->videoAddTime = 0;
	e2tPtr->audioAddTime = 0;
	e2tPtr->videoFPS = 0;
	e2tPtr->fpsFlag = 0;
	e2tPtr->audioFlag = 0;
	e2tPtr->audioTmp = 0;
	e2tPtr->nFindPFream = 0;
	e2tPtr->iNeedAudioFream = 0;
	e2tPtr->iNeedVideoFream = 1;
	e2tPtr->uiVideoCnt = 0;
	e2tPtr->uiAudioCnt = 0;
	e2tPtr->uiWritVideoCnt = 0;
	e2tPtr->iCachVideoCnt = 0;
	e2tPtr->iWritAudioCnt = 0;
	e2tPtr->iExistAudioFream = 0;	
	e2tPtr->uiCurWtsTime = 0;
	e2tPtr->need_i_frame = 1;
	e2tPtr->g_iWriteTsPCMFileFd = -1;		
}

int m_es2ts(es2tsParam * e2tPtr ,unsigned char *data,unsigned int dataLen,unsigned int frameType, unsigned int timestamp,unsigned char *outPut,unsigned int outPutLen)
{
	int videoTmpFPS = 0;
	double tmpfps;
	int i;
	int len = 0;
	int ret;
	int maxLen = outPutLen;
	if(outPutLen <= 0)
	{
		printf("outPutLen is error\n");
		return -1;
	}
	#if DBG_MSG_ON
	if(e2tPtr->g_iWriteTsPCMFileFd < 0)
	{
		e2tPtr->g_iWriteTsPCMFileFd = open("WriteTsPcm.pcm", O_CREAT | O_WRONLY | O_APPEND, 0666);
		if(e2tPtr->g_iWriteTsPCMFileFd < 0)
		{
			perror("open outaudio file failed:");
		}
	}
	#endif
	if(e2tPtr->need_i_frame == 1)
	{
		if(frameType != STREAM_FRAME_H264_IDR)
		{
		}
		else
		{
			e2tPtr->need_i_frame = 0;
		}
	}
	if (e2tPtr->videoAddTime == 0 && (STREAM_FRAME_H264_IDR== frameType || STREAM_FRAME_H264_P == frameType))//根据时间戳计算音视频的时间戳增量
	{
		videoTmpFPS = timestamp-e2tPtr->videoLastTime;
		if(videoTmpFPS > 0 && videoTmpFPS < 90000)
		{
			printf("videoTmpFPS:%d,now:%u,last:%u\n",videoTmpFPS,timestamp,e2tPtr->videoLastTime);
			tmpfps = 90000/videoTmpFPS;
			/*if(videoTmpFPS <= 25)
			{
				videoTmpFPS = 25;
			}
			else if(videoTmpFPS <= 30)
			{
				videoTmpFPS = 30;
			}
			else if(videoTmpFPS <= 50)
			{
				videoTmpFPS = 50;
			}
			else
			{
				videoTmpFPS = 60;
			}*/
			printf("tmpfps:%f,videoFPS:%d\n",tmpfps,e2tPtr->videoFPS);
			if(tmpfps != e2tPtr->videoFPS)
			{
				e2tPtr->fpsFlag++;
				if(e2tPtr->fpsFlag > 5)
				{
					e2tPtr->videoFPS = tmpfps;
					e2tPtr->videoAddTime = 90000/e2tPtr->videoFPS;
					e2tPtr->fpsFlag = 0;
				}
			}
			else
			{
				e2tPtr->fpsFlag = 0;
			}
		}
		printf("videoAddTime:%d,now:%u,last:%u\n",e2tPtr->videoAddTime,timestamp,e2tPtr->videoLastTime);
		e2tPtr->videoLastTime = timestamp;
		if( e2tPtr->videoAddTime == 0)
		{
			return 0;
		}
	}
	else if (e2tPtr->audioAddTime == 0 && STREAM_FRAME_G711 == frameType)
	{
		e2tPtr->audioTmp = (timestamp-e2tPtr->audioLastTime)*15/8;
		if(e2tPtr->audioAddTime != e2tPtr->audioTmp)
		{
			e2tPtr->audioFlag++;
			if(e2tPtr->audioFlag > 5)
			{
				e2tPtr->audioAddTime =e2tPtr->audioTmp;
				e2tPtr->audioFlag = 0;
			}
		}
		else
		{
			e2tPtr->audioFlag = 0;
		}
		printf("audioAddTime:%u,%u,%u,len:%d\n",e2tPtr->audioAddTime,timestamp,e2tPtr->audioLastTime,dataLen);
		e2tPtr->audioLastTime = timestamp;
		if(e2tPtr->audioAddTime == 0)
		{
			return 0;
		}
	}
	if(e2tPtr->need_i_frame == 1)
	{
		return 0;
	}
	if(e2tPtr->audioAddTime != 0)//由于ts不支持g711格式所以有音频时需要额外处理
	{

                //先存起来音视频帧数据
                if (STREAM_FRAME_H264_IDR== frameType || STREAM_FRAME_H264_P == frameType)
                {

                    if (e2tPtr->iCachVideoCnt < CACHEVIDEOFREMCNT)//缓存视频帧小于5帧直接缓存起来
                    {

                        e2tPtr->VideoFreamCach[e2tPtr->iCachVideoCnt].m_iDatalen = dataLen;
                        e2tPtr->VideoFreamCach[e2tPtr->iCachVideoCnt].m_frametype = frameType;
                        e2tPtr->VideoFreamCach[e2tPtr->iCachVideoCnt].m_uTimeTamp = e2tPtr->uiVideoCnt * e2tPtr->videoAddTime;
                        memcpy(e2tPtr->VideoFreamCach[e2tPtr->iCachVideoCnt].m_cVideoBuf, data, dataLen); 
                        e2tPtr->uiVideoCnt++;
                        e2tPtr->iCachVideoCnt++;
                    }
                    else if ((CACHEVIDEOFREMCNT == e2tPtr->iCachVideoCnt) && (STREAM_FRAME_H264_P == frameType))//已经缓存5帧视频，来了一个p帧，直接扔掉
                    {
                        //printf("Delete One P Video Fream.\n");
			  for(i = 0;i < e2tPtr->iCachVideoCnt-1;i++)
			  {
			  	    ret = store_ts_from_es(outPut+len,maxLen-len, e2tPtr->VideoFreamCach[i].m_cVideoBuf,e2tPtr->VideoFreamCach[i].m_iDatalen, e2tPtr->VideoFreamCach[i].m_frametype, e2tPtr->VideoFreamCach[i].m_uTimeTamp);
				    if(ret >0)
				    {
				    	len += ret;
				    }
				    //tsNetBitstreamWriter.newBlock(handle, VideoFreamCach[i].m_cVideoBuf, VideoFreamCach[i].m_iDatalen, VideoFreamCach[i].m_frametype, VideoFreamCach[i].m_uTimeTamp);
                                e2tPtr->uiCurWtsTime = e2tPtr->VideoFreamCach[i].m_uTimeTamp;
				   e2tPtr->uiWritVideoCnt++;
			  }
			  e2tPtr->iCachVideoCnt= 0;
                    }
                    else if ((CACHEVIDEOFREMCNT == e2tPtr->iCachVideoCnt) && (STREAM_FRAME_H264_IDR== frameType))//已经缓存的5帧视频，来了一个I帧，向前找一个P帧删除
                    {
                        for (i = e2tPtr->iCachVideoCnt - 1; i >= 0; i--)
                        {
                            if(e2tPtr->VideoFreamCach[i].m_frametype == STREAM_FRAME_H264_P)
                            {
                                e2tPtr->nFindPFream = 1;
                                break;
                            }
                        }
                
                        if(1 == e2tPtr->nFindPFream)//如果找到缓存的p帧
                        {
                            for (; i < CACHEVIDEOFREMCNT - 1; i++)
                            {
                                memcpy(&(e2tPtr->VideoFreamCach[i]), &(e2tPtr->VideoFreamCach[i + 1]), sizeof(TVideoFream));
                            }
                            e2tPtr->nFindPFream = 0;
                        }
                
                        memset(&(e2tPtr->VideoFreamCach[CACHEVIDEOFREMCNT - 1]), 0, sizeof(TVideoFream));
                        e2tPtr->VideoFreamCach[CACHEVIDEOFREMCNT - 1].m_iDatalen = dataLen;
                        e2tPtr->VideoFreamCach[CACHEVIDEOFREMCNT - 1].m_frametype = frameType;
                        e2tPtr->VideoFreamCach[CACHEVIDEOFREMCNT - 1].m_uTimeTamp = e2tPtr->uiVideoCnt * e2tPtr->videoAddTime;
                        memcpy(e2tPtr->VideoFreamCach[CACHEVIDEOFREMCNT - 1].m_cVideoBuf, data, dataLen);  
                    }
                    //printf("AAA iCachVideoCnt = %d, uiVideoCnt = %d, m_uTimeTamp = %u\n", iCachVideoCnt, uiVideoCnt, VideoFreamCach[iCachVideoCnt - 1].m_uTimeTamp);
                }
                else if (STREAM_FRAME_G711 == frameType)
                {
			
                    if (1 == e2tPtr->iExistAudioFream) //如果音频没有写完,又来音频
                    {
                        if (0 == e2tPtr->iCachVideoCnt)//当需要视频,来的音频，且视频没有缓存时
                        {
                            e2tPtr->iExistAudioFream = 1;

                            dataLen = Dealwith8KSigChnG711Audio(data, dataLen, e2tPtr->pc48KTwoChnPcmBigEndianBuf, e2tPtr->Audio48KTwoChnPcmPart, &(e2tPtr->uiAudioCnt), 1,e2tPtr->audioAddTime);

				return 0;
                        }
                        while (6 != e2tPtr->iWritAudioCnt)
                        {
                        	if((e2tPtr->Audio48KTwoChnPcmPart[e2tPtr->iWritAudioCnt].m_uiPartTimeTamp < e2tPtr->uiCurWtsTime) )
				 {
		 	        #if DBG_MSG_ON
                                unsigned int ret = write(e2tPtr->g_iWriteTsPCMFileFd, e2tPtr->Audio48KTwoChnPcmPart[e2tPtr->iWritAudioCnt].m_c48KTwoChnPcmBufPart, e2tPtr->Audio48KTwoChnPcmPart[e2tPtr->iWritAudioCnt].m_iDatalen); 
                                if (ret != e2tPtr->Audio48KTwoChnPcmPart[e2tPtr->iWritAudioCnt].m_iDatalen)
                                {
                                    printf("g711 Write TsAudioFile is Error: ret = %d, len = %d\n", ret, dataLen);
                                }
                                #endif
				    ret = store_ts_from_es(outPut+len,maxLen-len, e2tPtr->Audio48KTwoChnPcmPart[e2tPtr->iWritAudioCnt].m_c48KTwoChnPcmBufPart, e2tPtr->Audio48KTwoChnPcmPart[e2tPtr->iWritAudioCnt].m_iDatalen, e2tPtr->Audio48KTwoChnPcmPart[e2tPtr->iWritAudioCnt].m_frametype, e2tPtr->Audio48KTwoChnPcmPart[e2tPtr->iWritAudioCnt].m_uiPartTimeTamp);
				    if(ret >0)
				    {
				    	len += ret;
				    }
				    //tsNetBitstreamWriter.newBlock(handle, Audio48KTwoChnPcmPart[iWritAudioCnt].m_c48KTwoChnPcmBufPart, 
                                //        Audio48KTwoChnPcmPart[iWritAudioCnt].m_iDatalen, Audio48KTwoChnPcmPart[iWritAudioCnt].m_frametype, Audio48KTwoChnPcmPart[iWritAudioCnt].m_uiPartTimeTamp);          
                                e2tPtr->uiCurWtsTime = e2tPtr->Audio48KTwoChnPcmPart[e2tPtr->iWritAudioCnt].m_uiPartTimeTamp;
                                e2tPtr->iWritAudioCnt++;
                                e2tPtr->iNeedAudioFream = 0;
                                e2tPtr->iNeedVideoFream = 1;
				   continue;
				 }
      				//printf("------runing0:%d--%u-%u--%u--\n",iWritAudioCnt,uiCurWtsTime,Audio48KTwoChnPcmPart[iWritAudioCnt].m_uiPartTimeTamp,uiWritVideoCnt * videoAddTime);
                            //当音频时间戳大于当前写TS流时间且小于下一帧视频时间戳时
                            while (e2tPtr->iWritAudioCnt < 6 &&(e2tPtr->Audio48KTwoChnPcmPart[e2tPtr->iWritAudioCnt].m_uiPartTimeTamp >= e2tPtr->uiCurWtsTime) 
                                && (e2tPtr->Audio48KTwoChnPcmPart[e2tPtr->iWritAudioCnt].m_uiPartTimeTamp <= e2tPtr->uiWritVideoCnt * e2tPtr->videoAddTime))
                            {
                                #if DBG_MSG_ON
                                unsigned int ret = write(e2tPtr->g_iWriteTsPCMFileFd, e2tPtr->Audio48KTwoChnPcmPart[e2tPtr->iWritAudioCnt].m_c48KTwoChnPcmBufPart, e2tPtr->Audio48KTwoChnPcmPart[e2tPtr->iWritAudioCnt].m_iDatalen); 
                                if (ret != e2tPtr->Audio48KTwoChnPcmPart[e2tPtr->iWritAudioCnt].m_iDatalen)
                                {
                                    printf("g711 Write TsAudioFile is Error: ret = %d, len = %d\n", ret, dataLen);
                                }
                                #endif
                                ret = store_ts_from_es(outPut+len,maxLen-len, e2tPtr->Audio48KTwoChnPcmPart[e2tPtr->iWritAudioCnt].m_c48KTwoChnPcmBufPart, e2tPtr->Audio48KTwoChnPcmPart[e2tPtr->iWritAudioCnt].m_iDatalen, e2tPtr->Audio48KTwoChnPcmPart[e2tPtr->iWritAudioCnt].m_frametype, e2tPtr->Audio48KTwoChnPcmPart[e2tPtr->iWritAudioCnt].m_uiPartTimeTamp);
				    if(ret >0)
				    {
				    	len += ret;
				    }
				    //tsNetBitstreamWriter.newBlock(handle, Audio48KTwoChnPcmPart[iWritAudioCnt].m_c48KTwoChnPcmBufPart, 
                                //        Audio48KTwoChnPcmPart[iWritAudioCnt].m_iDatalen, Audio48KTwoChnPcmPart[iWritAudioCnt].m_frametype, Audio48KTwoChnPcmPart[iWritAudioCnt].m_uiPartTimeTamp);          
                                e2tPtr->uiCurWtsTime = e2tPtr->Audio48KTwoChnPcmPart[e2tPtr->iWritAudioCnt].m_uiPartTimeTamp;
                                e2tPtr->iWritAudioCnt++;
                                e2tPtr->iNeedAudioFream = 0;
                                e2tPtr->iNeedVideoFream = 1;
                                //printf("AA uiCurWtsTime = %u, iWritAudioCnt = %d, uiAudioCnt = %d\n", uiCurWtsTime, iWritAudioCnt, uiAudioCnt);
                            }
    
                            if (6 == e2tPtr->iWritAudioCnt)
                            {
                                break;
                            }
                            else
                            {

                            	  if (e2tPtr->iCachVideoCnt > 0)
                            	  {
                                    if (e2tPtr->VideoFreamCach[0].m_uTimeTamp <= (e2tPtr->uiCurWtsTime + e2tPtr->audioAddTime))
                                    {
                                       ret = store_ts_from_es(outPut+len,maxLen-len,  e2tPtr->VideoFreamCach[0].m_cVideoBuf, e2tPtr->VideoFreamCach[0].m_iDatalen, e2tPtr->VideoFreamCach[0].m_frametype, e2tPtr->VideoFreamCach[0].m_uTimeTamp);
					    if(ret >0)
					    {
					    	len += ret;
					    }
					     //tsNetBitstreamWriter.newBlock(handle, VideoFreamCach[0].m_cVideoBuf, VideoFreamCach[0].m_iDatalen, VideoFreamCach[0].m_frametype, VideoFreamCach[0].m_uTimeTamp);
                                        e2tPtr->uiCurWtsTime = e2tPtr->VideoFreamCach[0].m_uTimeTamp;
                                        memset(&(e2tPtr->VideoFreamCach[0]), 0, sizeof(TVideoFream));
                                        for (i = 0; i <e2tPtr->iCachVideoCnt-1; i++)
                                        {
                                            memcpy(&(e2tPtr->VideoFreamCach[i]), &(e2tPtr->VideoFreamCach[i + 1]), sizeof(TVideoFream));
                                        }
                                        e2tPtr->uiWritVideoCnt++;
                                        e2tPtr->iCachVideoCnt--;
                                        //printf("BB Video has writed uiCurWtsTime = %u, uiVideoCnt = %d, iCachVideoCnt = %d, uiWritVideoCnt = %d\n", uiCurWtsTime, uiVideoCnt, iCachVideoCnt, uiWritVideoCnt);
                                    }
					  e2tPtr->iNeedAudioFream = 1;
					  e2tPtr->iNeedVideoFream = 0;
                            	  }
				  else
				  {
				  	break;
				  }

                            }
                        }
				 if (6 == e2tPtr->iWritAudioCnt)
				 {
                        e2tPtr->iWritAudioCnt = 0;
                        e2tPtr->iExistAudioFream = 0;
				 }
                    }
                
                    if (0 == e2tPtr->iExistAudioFream)
                    {
                        e2tPtr->iExistAudioFream = 1;

                        dataLen = Dealwith8KSigChnG711Audio(data, dataLen, e2tPtr->pc48KTwoChnPcmBigEndianBuf, e2tPtr->Audio48KTwoChnPcmPart, &(e2tPtr->uiAudioCnt), 0,e2tPtr->audioAddTime); 

			}
                }
                //printf("##00 iNeedVideoFream = %d, iNeedAudioFream = %d, uiCurWtsTime = %u\n", iNeedVideoFream, iNeedAudioFream, uiCurWtsTime);

                //开始写 TS 流
                if (e2tPtr->iCachVideoCnt > 0 && 1 == e2tPtr->iNeedVideoFream)
                {
                    if (e2tPtr->VideoFreamCach[0].m_uTimeTamp <= (e2tPtr->uiCurWtsTime + e2tPtr->audioAddTime))
                    {
                    	   ret = store_ts_from_es(outPut+len,maxLen-len,  e2tPtr->VideoFreamCach[0].m_cVideoBuf, e2tPtr->VideoFreamCach[0].m_iDatalen, e2tPtr->VideoFreamCach[0].m_frametype, e2tPtr->VideoFreamCach[0].m_uTimeTamp);
	   		    if(ret >0)
	   		    {
	   		    	len += ret;
	   		    }
			   //tsNetBitstreamWriter.newBlock(handle, VideoFreamCach[0].m_cVideoBuf, VideoFreamCach[0].m_iDatalen, VideoFreamCach[0].m_frametype, VideoFreamCach[0].m_uTimeTamp);
                        e2tPtr->uiCurWtsTime = e2tPtr->VideoFreamCach[0].m_uTimeTamp;
                        memset(&(e2tPtr->VideoFreamCach[0]), 0, sizeof(TVideoFream));
                        for (i = 0; i < e2tPtr->iCachVideoCnt-1; i++)
                        {
                            memcpy(&(e2tPtr->VideoFreamCach[i]), &(e2tPtr->VideoFreamCach[i + 1]), sizeof(TVideoFream));
                        }
                        e2tPtr->uiWritVideoCnt++;
                        e2tPtr->iCachVideoCnt--;
                        //printf("CC Video has writed uiCurWtsTime = %u, uiVideoCnt = %d, iCachVideoCnt = %d, uiWritVideoCnt = %d\n", uiCurWtsTime, uiVideoCnt, iCachVideoCnt, uiWritVideoCnt);
                    }
                    e2tPtr->iNeedAudioFream = 1;
                    e2tPtr->iNeedVideoFream = 0;
                }
                //printf("##11 iNeedVideoFream = %d, iNeedAudioFream = %d, uiCurWtsTime = %u\n", iNeedVideoFream, iNeedAudioFream, uiCurWtsTime);

                if (e2tPtr->uiAudioCnt > 0 && 1 == e2tPtr->iNeedAudioFream && 1 == e2tPtr->iExistAudioFream)
                {
                    while (e2tPtr->iWritAudioCnt < 6 &&(e2tPtr->Audio48KTwoChnPcmPart[e2tPtr->iWritAudioCnt].m_uiPartTimeTamp >= e2tPtr->uiCurWtsTime) 
                            && (e2tPtr->Audio48KTwoChnPcmPart[e2tPtr->iWritAudioCnt].m_uiPartTimeTamp <= e2tPtr->uiWritVideoCnt * e2tPtr->videoAddTime))
                    {
            	 	    #if DBG_MSG_ON
                        unsigned int ret = write(e2tPtr->g_iWriteTsPCMFileFd, e2tPtr->Audio48KTwoChnPcmPart[e2tPtr->iWritAudioCnt].m_c48KTwoChnPcmBufPart, e2tPtr->Audio48KTwoChnPcmPart[e2tPtr->iWritAudioCnt].m_iDatalen); 
                        if (ret != e2tPtr->Audio48KTwoChnPcmPart[e2tPtr->iWritAudioCnt].m_iDatalen)
                        {
                            printf("g711 Write TsAudioFile is Error: ret = %d, len = %d\n", ret, dataLen);
                        }
                        #endif
                	  ret = store_ts_from_es(outPut+len,maxLen-len,   e2tPtr->Audio48KTwoChnPcmPart[e2tPtr->iWritAudioCnt].m_c48KTwoChnPcmBufPart,  e2tPtr->Audio48KTwoChnPcmPart[e2tPtr->iWritAudioCnt].m_iDatalen, e2tPtr->Audio48KTwoChnPcmPart[e2tPtr->iWritAudioCnt].m_frametype, e2tPtr->Audio48KTwoChnPcmPart[e2tPtr->iWritAudioCnt].m_uiPartTimeTamp);
	   		    if(ret >0)
	   		    {
	   		    	len += ret;
	   		    }
			   //tsNetBitstreamWriter.newBlock(handle, Audio48KTwoChnPcmPart[iWritAudioCnt].m_c48KTwoChnPcmBufPart, 
                         //       Audio48KTwoChnPcmPart[iWritAudioCnt].m_iDatalen, Audio48KTwoChnPcmPart[iWritAudioCnt].m_frametype, Audio48KTwoChnPcmPart[iWritAudioCnt].m_uiPartTimeTamp);          
                        e2tPtr->uiCurWtsTime = e2tPtr->Audio48KTwoChnPcmPart[e2tPtr->iWritAudioCnt].m_uiPartTimeTamp;
                        e2tPtr->iWritAudioCnt++;
                        e2tPtr->iNeedAudioFream = 0;
                        e2tPtr->iNeedVideoFream = 1;
                        //printf("DD uiCurWtsTime = %u, iWritAudioCnt = %d, uiAudioCnt = %d\n", uiCurWtsTime, iWritAudioCnt, uiAudioCnt);
                    }
                    //printf("##22 iNeedVideoFream = %d, iNeedAudioFream = %d, uiCurWtsTime = %u\n", iNeedVideoFream, iNeedAudioFream, uiCurWtsTime);
                
                    //如果还有缓存的视频帧，检查视频是否可写
                    if (e2tPtr->iCachVideoCnt > 0 && 1 == e2tPtr->iNeedVideoFream)
                    {
                        if (e2tPtr->VideoFreamCach[0].m_uTimeTamp <= (e2tPtr->uiCurWtsTime + e2tPtr->audioAddTime))
                        {
				ret = store_ts_from_es(outPut+len,maxLen-len,  e2tPtr->VideoFreamCach[0].m_cVideoBuf, e2tPtr->VideoFreamCach[0].m_iDatalen, e2tPtr->VideoFreamCach[0].m_frametype, e2tPtr->VideoFreamCach[0].m_uTimeTamp);
    	   		      if(ret >0)
    	   		      {
    	   		       	len += ret;
    	   		      }
				//tsNetBitstreamWriter.newBlock(handle, VideoFreamCach[0].m_cVideoBuf, VideoFreamCach[0].m_iDatalen, VideoFreamCach[0].m_frametype, VideoFreamCach[0].m_uTimeTamp);
                            e2tPtr->uiCurWtsTime = e2tPtr->VideoFreamCach[0].m_uTimeTamp;
                            memset(&(e2tPtr->VideoFreamCach[0]), 0, sizeof(TVideoFream));
                            for (i = 0; i < e2tPtr->iCachVideoCnt-1; i++)
                            {
                                memcpy(&(e2tPtr->VideoFreamCach[i]), &(e2tPtr->VideoFreamCach[i + 1]), sizeof(TVideoFream));
                            }
                            e2tPtr->uiWritVideoCnt++;
                            e2tPtr->iCachVideoCnt--;
                            //printf("EE Video has writed uiCurWtsTime = %u, uiVideoCnt = %d, iCachVideoCnt = %d, uiWritVideoCnt = %d\n", uiCurWtsTime, uiVideoCnt, iCachVideoCnt, uiWritVideoCnt);
                        }
                        e2tPtr->iNeedAudioFream = 1;
                        e2tPtr->iNeedVideoFream = 0;
                        //printf("##33 iNeedVideoFream = %d, iNeedAudioFream = %d, uiCurWtsTime = %u\n", iNeedVideoFream, iNeedAudioFream, uiCurWtsTime);
           
                        while (e2tPtr->iWritAudioCnt < 6 && (e2tPtr->Audio48KTwoChnPcmPart[e2tPtr->iWritAudioCnt].m_uiPartTimeTamp >= e2tPtr->uiCurWtsTime) && (e2tPtr->Audio48KTwoChnPcmPart[e2tPtr->iWritAudioCnt].m_uiPartTimeTamp <= e2tPtr->uiWritVideoCnt * e2tPtr->videoAddTime))
                        {
                    	    #if DBG_MSG_ON
                            unsigned int ret = write(e2tPtr->g_iWriteTsPCMFileFd, e2tPtr->Audio48KTwoChnPcmPart[e2tPtr->iWritAudioCnt].m_c48KTwoChnPcmBufPart,e2tPtr-> e2tPtr->Audio48KTwoChnPcmPart[e2tPtr->iWritAudioCnt].m_iDatalen); 
                            if (ret != e2tPtr->Audio48KTwoChnPcmPart[e2tPtr->iWritAudioCnt].m_iDatalen)
                            {
                                printf("g711 Write TsAudioFile is Error: ret = %d, len = %d\n", ret, dataLen);
                            }
                            #endif
                            ret = store_ts_from_es(outPut+len,maxLen-len,  e2tPtr->Audio48KTwoChnPcmPart[e2tPtr->iWritAudioCnt].m_c48KTwoChnPcmBufPart,  e2tPtr->Audio48KTwoChnPcmPart[e2tPtr->iWritAudioCnt].m_iDatalen, e2tPtr->Audio48KTwoChnPcmPart[e2tPtr->iWritAudioCnt].m_frametype, e2tPtr->Audio48KTwoChnPcmPart[e2tPtr->iWritAudioCnt].m_uiPartTimeTamp);
    	   		      if(ret >0)
    	   		      {
    	   		       	len += ret;
    	   		      }
				//tsNetBitstreamWriter.newBlock(handle, Audio48KTwoChnPcmPart[iWritAudioCnt].m_c48KTwoChnPcmBufPart, 
                            //        Audio48KTwoChnPcmPart[iWritAudioCnt].m_iDatalen, Audio48KTwoChnPcmPart[iWritAudioCnt].m_frametype, Audio48KTwoChnPcmPart[iWritAudioCnt].m_uiPartTimeTamp);          
                            e2tPtr->uiCurWtsTime = e2tPtr->Audio48KTwoChnPcmPart[e2tPtr->iWritAudioCnt].m_uiPartTimeTamp;
                            e2tPtr->iWritAudioCnt++;
                            e2tPtr->iNeedAudioFream = 0;
                            e2tPtr->iNeedVideoFream = 1;
                            //printf("FF uiCurWtsTime = %u, iWritAudioCnt = %d, uiAudioCnt = %d\n", uiCurWtsTime, iWritAudioCnt, uiAudioCnt);
                        }

			//printf("##44 iNeedVideoFream = %d, iNeedAudioFream = %d, uiCurWtsTime = %u\n", iNeedVideoFream, iNeedAudioFream, uiCurWtsTime);
                    }
                
                    if (6 == e2tPtr->iWritAudioCnt)
                    {
                        e2tPtr->iWritAudioCnt = 0;
                        e2tPtr->iExistAudioFream = 0;
                    }
                }
	}
	else
	{	
		  ret = store_ts_from_es(outPut+len,maxLen-len,  data, dataLen, frameType, timestamp);
		if(ret >0)
		{
			len += ret;
		}
                //tsNetBitstreamWriter.newBlock(handle, (char *)data, dataLen, frameType, fileInfo.timestamp);
	}
	return len;
}

void InitSocket(int *UdpSocket, int iPort,char * ethName,char * MulticIp)
{
	int on = 1;
	//struct ip_mreq mreq;                                    /*加入多播组*/
	struct sockaddr_in servaddr;
    struct ifreq ifr;
	if ((*UdpSocket = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
	{
		perror("creat UdpSocket socket failed!");
		return ;
	}
        strcpy(ifr.ifr_name, ethName);
        //SIOCGIFADDR标志代表获取接口地址
        if (ioctl(*UdpSocket, SIOCGIFADDR, &ifr) <  0)
        {
                perror("ioctl");
		 close(*UdpSocket);
		*UdpSocket = -1;
		return ;
        }
        //printf("%s\n", inet_ntoa(((struct sockaddr_in*)&(ifr.ifr_addr))->sin_addr));	
	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(iPort);
	servaddr.sin_addr = ((struct sockaddr_in*)&(ifr.ifr_addr))->sin_addr;

	if((setsockopt(*UdpSocket, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on))) < 0)  
	{
		perror("set UDP_sock sockopt failed");
		close(*UdpSocket);
		*UdpSocket = -1;
		return ;
	}
	if (bind(*UdpSocket, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1)
	{
		perror("bind UDP_sock sockopt failed"); 
		close(*UdpSocket);
		*UdpSocket = -1;
		return ;
	}
	servaddr.sin_addr.s_addr = inet_addr ((char *)MulticIp);
	servaddr.sin_port = htons ((unsigned short)iPort);
	if ( connect(*UdpSocket, (struct sockaddr *)&servaddr,sizeof(servaddr)) == -1 )
	{
		perror("connect UDP_sock sockopt failed"); 
		close(*UdpSocket);
		*UdpSocket = -1;
		return ;
	}
}

int send_ts_stream(int socket,unsigned char * sendPtr,int sendLen)
{
	int bufSize = sendLen;
	unsigned char * bufData = sendPtr;
	int udpPayLoad = 0;
	int maxPayload = 1450;
	struct timeval  lastDatatime;        /* Stores the time before last data packet sending */
	struct timeval  nextDatatime;        /* Stores the time before next data packet sending */
	unsigned int  dt_interval = 0;     /* Data packet interval               */
    while(bufSize > 0)
    {

        udpPayLoad   = maxPayload < bufSize ? maxPayload : bufSize;

	#if 1
            gettimeofday(&nextDatatime,NULL);
            dt_interval = ((nextDatatime.tv_usec+nextDatatime.tv_sec*1000000)-(lastDatatime.tv_usec+lastDatatime.tv_sec*1000000));
            if( dt_interval < 160)
            {
				int i;
				/* 相当于睡250微秒 */
				for(i=0;i<43414;i++)
				{
					asm volatile("");
				}
            }
            lastDatatime.tv_usec = nextDatatime.tv_usec;
            lastDatatime.tv_sec  = nextDatatime.tv_sec;
	#endif
	 send(socket,bufData,((udpPayLoad/188) * 188),0);


        bufSize -= ((udpPayLoad/188) * 188);
        bufData += ((udpPayLoad/188) * 188);
    }
}

G711.h

/************************************************************************
Copyright (c) 2007 Stretch, Inc. All rights reserved.  Stretch products
are protected under numerous U.S. and foreign patents, maskwork rights,
copyrights and other intellectual property laws.

This source code and the related tools, software code and documentation,
and your use thereof, are subject to and governed by the terms and
conditions of the applicable Stretch IDE or SDK and RDK License Agreement
(either as agreed by you or found at www.stretchinc.com).  By using
these items, you indicate your acceptance of such terms and conditions
between you and Stretch, Inc.  In the event that you do not agree with
such terms and conditions, you may not use any of these items and must
immediately destroy any copies you have made.
************************************************************************/

/************************************************************************
    PACKAGE: g711 -- G711 Speech Codec

    DESCRIPTION:

    SECTION: Include
    {
    #include "g711.h"
    }

    SECTION: Introduction

    @g711@ is an implementation of the G711 speech coding standard
    optimized for the Stretch S6000 processors.  The codec support 
    both mu law and alaw encoding/decoding.

    SECTION: Usage model

    To use @g711@, a @g711@ encoder/decoder instance must be created first
    using g711_open().  After that, g711_encode() and g711_decode() can be
    called.  When finished, g711_close() must be called to free memories
    associated with the instance.  Due to the simplicify of g711 algorith,
    both encoding and decoding can be done using a single instance.

    This package supports single or multi channel interleaved inputs.
    In the multi-channel case, the API allows the encoding/decoding to
    be performed on a specific channel, without requiring the caller to
    extract the channel first.

    SECTION: Data representation

    Linear data has 16 bits.  Only the most significant 12 bits
    are used for encoding.  Compressed data has 8 bits stored in
    the least significant 8 bits of a short.
************************************************************************/
#ifndef G711_HEADER
#define G711_HEADER

/*******************************************************************************
   A necessary evil introduced for C++ compatibility.  C source files must
   not declare a function "extern"; instead, they must declare the function
   "EXTERN_G711".  For example:
   {
       EXTERN_G711 void my_external_symbol(int a, double f);
   }
   This specifies that the function has C linkage so that it can be used
   when compiled with a C++ compiler.
*******************************************************************************/
#if defined(__cplusplus)
   #define EXTERN_G711              extern "C"
#else
   #define EXTERN_G711              extern
#endif

/************************************************************************
    Return status for g711 routines
************************************************************************/
typedef enum g711_status_enum {
    G711_OK
} g711_status_e;

/************************************************************************
    Type of companding to use for encoding or decoding

    Use G711_ULAW for USA
    Use G711_ALAW for Asia and Europe
************************************************************************/
typedef enum g711_au_enum {
    G711_ALAW,
    G711_ULAW,
} g711_au_e;

/************************************************************************
    Structure used to configure a g711 encoder or decoder instance.
    Both encoding and decoding can use the same instance provided
    that they have the same configuration parameters.

    region (law) = ulaw, Use G711_ALAW for Asia and Europe
    num_channels - number of audio channels for 1 for mono, 2 for stereo
    channel_select - The channel used. First one is 0. Use 0 for both
    Mono and Stereo since in the case of stereo we are just duplicating
    left channel twice.

************************************************************************/
typedef struct g711_config_struct {
    g711_au_e law;
    unsigned char num_channels;
    unsigned char channel_select;
} g711_config_t;

/************************************************************************
    A g711 encoder/decoder handle
************************************************************************/
typedef struct g711_struct g711_t;

/************************************************************************
    GROUP: g711 instance management
************************************************************************/
EXTERN_G711 g711_status_e g711_open(g711_config_t *config, g711_t **g711);
EXTERN_G711 g711_status_e g711_close(g711_t *g711);

/************************************************************************
    GROUP: Encoding and decoding routines
************************************************************************/
EXTERN_G711 g711_status_e g711_encode_mono(g711_t *g711, unsigned num, short *ibuf, unsigned char *obuf);
EXTERN_G711 g711_status_e g711_encode_stereo(g711_t *g711, unsigned num, short *ibuf, unsigned char *obuf);
EXTERN_G711 g711_status_e g711_decode(g711_t *g711, unsigned num, unsigned char *ibuf, short *obuf);
#endif

G711.cpp

/************************************************************************
Copyright (c) 2007 Stretch, Inc. All rights reserved.  Stretch products
are protected under numerous U.S. and foreign patents, maskwork rights,
copyrights and other intellectual property laws.

This source code and the related tools, software code and documentation,
and your use thereof, are subject to and governed by the terms and
conditions of the applicable Stretch IDE or SDK and RDK License Agreement
(either as agreed by you or found at www.stretchinc.com).  By using
these items, you indicate your acceptance of such terms and conditions
between you and Stretch, Inc.  In the event that you do not agree with
such terms and conditions, you may not use any of these items and must
immediately destroy any copies you have made.
************************************************************************/
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include "g711.h"

/*************************************************************************
    A g711 codec handle.  It can be used for encoding or decoding.
*************************************************************************/
struct g711_struct {
    g711_config_t config;
};

/*************************************************************************
    A-law encoding rule according ITU-T Rec. G.711.
*************************************************************************/
static short g711_linear_to_alaw(short in)
{
    short out, ex;

    out = in < 0 ? (~in) >> 4 : in >> 4;

    if (out > 15) {
        ex = 1;
        while (out > 16 + 15) {
            out >>= 1;
            ex++;
        }
        out -= 16;
        out += ex << 4;
    }

    if (in >= 0) {
        out |= (0x0080);
    }

    return out ^ (0x0055);
}

/*************************************************************************
    ALaw decoding rule according ITU-T Rec. G.711.
*************************************************************************/
static short g711_alaw_to_linear(short in)
{
    short tmp, mant, ex;

    tmp = in ^ 0x0055;
    tmp &= (0x007F);
    ex = tmp >> 4;
    mant = tmp & (0x000F);
    if (ex > 0) {
        mant = mant + 16;
    }

    mant = (mant << 4) + (0x0008);
    if (ex > 1) {
      mant = mant << (ex - 1);
    }

    return in > 127 ? mant : -mant;
}

/*************************************************************************
    Mu law encoding rule according ITU-T Rec. G.711.
*************************************************************************/
static short g711_linear_to_ulaw(short in)
{
    short i, out, absno, segno, low_nibble, high_nibble;

    absno = in < 0 ? ((~in) >> 2) + 33 : ((in) >> 2) + 33;

    if (absno > (0x1FFF)) {
      absno = (0x1FFF);
    }

    i = absno >> 6;
    segno = 1;
    while (i != 0)
    {
        segno++;
        i >>= 1;
    }

    high_nibble = (0x0008) - segno;

    low_nibble = (absno >> segno) & (0x000F);
    low_nibble = (0x000F) - low_nibble;

    out = (high_nibble << 4) | low_nibble;

    /* Add sign bit */
    return in >= 0 ? (out | 0x0080) : out;
}

/*************************************************************************
    Mu Law decoding rule according ITU-T Rec. G.711.
*************************************************************************/
static short g711_ulaw_to_linear(short in)
{
    short out, segment, mantissa, exponent, sign, step;

    sign = in < 0x0080 ? -1 : 1;

    mantissa = ~in;
    exponent = (mantissa >> 4) & (0x0007);
    segment = exponent + 1;
    mantissa = mantissa & (0x000F);

    step = (4) << segment;

    out = sign * (((0x0080) << exponent) + step * mantissa + step / 2 - 4 * 33);

    return out;
}

/*************************************************************************
    Initialize and return a g711 codec instance in "*g711".  The 
    instance can be used for encoding as well as decoding as long as
    the configuration parameters are the same.
*************************************************************************/
g711_status_e g711_open(g711_config_t *config, g711_t **g711)
{
    g711_t *hdl;
    hdl = (g711_t *) malloc(sizeof(g711_t)); 
    memcpy(&hdl->config, config, sizeof(g711_config_t));
    *g711 = hdl;

    return G711_OK;
}

/*************************************************************************
    Encode "num" input samples in "ibuf" and store the output in *obuf.
    "ibuf" must hold "num" of shorts and "obuf" "num" of bytes.
    In case of multi-channel data, the "ibuf" should contain "n * num"
    number of interleaved samples where "n" is the number of channels.
    "obuf" is assumed to be sufficient to hold the encoded data.
    If "g711" is configured to have multiple channels and encode
    only one channel, the encoding will only be performed on the
    specific channel and the output is stored in "obuf" contiguously.
*************************************************************************/
g711_status_e g711_encode_mono(g711_t *g711, unsigned num, short *ibuf, unsigned char *obuf)
{
    int out_buf_index, input_buf_index, incr, init, size;

    incr = g711->config.channel_select < g711->config.num_channels ? g711->config.num_channels : 1;
    init = g711->config.channel_select;
    size = num * g711->config.num_channels;

    switch (g711->config.law) {
    case G711_ALAW:
        for (out_buf_index = 0, input_buf_index = init; input_buf_index < size; input_buf_index += incr, out_buf_index++) {
            obuf[out_buf_index] = (unsigned char) g711_linear_to_alaw(ibuf[input_buf_index]);
        }
        break;
    case G711_ULAW:
        for (out_buf_index = 0, input_buf_index = init; input_buf_index < size; input_buf_index += incr, out_buf_index++) {
            obuf[out_buf_index] = (unsigned char) g711_linear_to_ulaw(ibuf[input_buf_index]);
        }
        break;
    default:
        assert(0);
    }

    return G711_OK;
}
g711_status_e g711_encode_stereo(g711_t *g711, unsigned num, short *ibuf, unsigned char *obuf)
{
    int out_buf_index, input_buf_index, incr, init, size;

    incr = g711->config.channel_select < g711->config.num_channels ? g711->config.num_channels : 1;
    init = g711->config.channel_select;
    size = num * g711->config.num_channels;

    switch (g711->config.law) {
    case G711_ALAW:
        for (out_buf_index = 0, input_buf_index = init; input_buf_index < size; input_buf_index += incr, out_buf_index += 2) {
            obuf[out_buf_index] = (unsigned char) g711_linear_to_alaw(ibuf[input_buf_index]);
            obuf[out_buf_index+1] = obuf[out_buf_index];

        }
        break;
    case G711_ULAW:
        for (out_buf_index = 0, input_buf_index = init; input_buf_index < size; input_buf_index += incr, out_buf_index += 2) {
            obuf[out_buf_index] = (unsigned char) g711_linear_to_ulaw(ibuf[input_buf_index]);
            obuf[out_buf_index+1] = obuf[out_buf_index];

        }
        break;
    default:
        assert(0);
    }

    return G711_OK;
}

/****************************************************************************
   This function decodes the 8 bit encoded mono audio buffer in to a 16 bit raw
   PCM audio buffer.

   Parameters:

       g711 -  pointer to g711 handle that was previously opened by the call
               to g711_open()

       num_samples - The number of audio samples in 'src_buf' input buffer.
                     Note that this is not the size of src_buf. In case of two
                     channel stereo, this is half the size of the src_buf

       src_buf -  (Input) A buffer containing the 8 bit encoded mono audio buffer
               to be decoced.

       dest_buf - (Output) A pointer to a buffer to hold the decoded 16 bit raw
              audio. It is assumed that this buffer is at least twice as large as
              the input buffer 'srcBuf' in order to hold the decoded raw audio.
******************************************************************************/
g711_status_e g711_decode(g711_t *g711, unsigned num_samples, unsigned char *src_buf, short *dest_buf)
{
    int dest_buf_index, src_buf_index, src_buf_step, init, size;

    src_buf_step = g711->config.channel_select < g711->config.num_channels ? g711->config.num_channels : 1;
    init = g711->config.channel_select;
    size = g711->config.channel_select < g711->config.num_channels ? num_samples : num_samples * g711->config.num_channels;

    if (g711->config.num_channels == 1)
    {
        // Note: For Mono decodeing, since we are going from 8 bit buffer to 16 bit buffer, it requires us to expand
        //       the size of output audio buffer. Since it is possible that 'destBuf' and 'srcBuf' parameter
        //       overlap, we decode from the end of the 'src_buf' and save into end of the 'dest_buf'

        switch (g711->config.law) {
        case G711_ALAW:
            for (dest_buf_index = size - 1 ,src_buf_index = size - init - 1; src_buf_index >= 0; src_buf_index -= src_buf_step, dest_buf_index--) {
                dest_buf[dest_buf_index] = g711_alaw_to_linear(src_buf[src_buf_index]);
            }
            break;
        case G711_ULAW:
            for (dest_buf_index = size - 1 ,src_buf_index = size - init - 1; src_buf_index >= 0; src_buf_index -= src_buf_step, dest_buf_index--) {
                dest_buf[dest_buf_index] = g711_ulaw_to_linear(src_buf[src_buf_index]);
            }
            break;
        default:
            assert(0);
        }
    } 
    else
    {
        switch (g711->config.law) {
        case G711_ALAW:
            for (dest_buf_index = 0, src_buf_index = init; dest_buf_index < size; src_buf_index += src_buf_step, dest_buf_index++) {
                dest_buf[dest_buf_index] = g711_alaw_to_linear(src_buf[src_buf_index]);
            }
            break;
        case G711_ULAW:
            for (dest_buf_index = 0, src_buf_index = init; dest_buf_index < size; src_buf_index += src_buf_step, dest_buf_index++) {
                dest_buf[dest_buf_index] = g711_ulaw_to_linear(src_buf[src_buf_index]);
            }
            break;
        default:
            assert(0);
        }
    }

    return G711_OK;
}


/*************************************************************************
    Free the g711 codec instance
*************************************************************************/
g711_status_e g711_close(g711_t *g711)
{
    free(g711);
    return G711_OK;
}

具体的接口使用如下:

先定义 es2tsParam e2t;

static void rtpDataCallBack(DevSDK_SessionHandle hSession,DevSDK_StreamHandle hStream,Session_Event enmEvent
                            ,unsigned char *data,uint32 dataLen,uint32 frameType,int64 timestamp,uint32 frameSeqId,void *cbParam)
{
    if(enmEvent == EVENT_STREAM_OK)
    {
        bIsClosed = false;
        if (frameType == STREAM_FRAME_G711 || frameType == STREAM_FRAME_AAC)
            return ;                                                                     //shijianchuo
        progress = DevSDK_GetProgress((DevSDK_StreamHandle)hStream, (char *)data, dataLen,timestamp, frameType);
        LOGGER->Log(LOGGER_DEBUG, "progress: %d", progress);
//        if(forwardSocket == -1)
        if (MulticSocket == -1)
        {
            init_e2t_param(&e2t);
//            QString qEth = get_network_eth_name();
//            QString qEth = "eth1";
//            LOGGER->Log(LOGGER_DEBUG, "get network eth name: %s", qEth.toLatin1().data());
            InitSocket(&MulticSocket, 12345, "eth0", "225.1.2.3");
              //InitSocket(&MulticSocket, 12345, "eth1", "225.1.2.3");

//            forwardSocket = socket(AF_INET, SOCK_DGRAM, 0);
//            sAddr.sin_family = AF_INET;
//            sAddr.sin_port = htons(1234);
//            sAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
//            nAddrLen = sizeof(sAddr);
        }
        else
        {
            int outPutLen = 0;
            memset(outPut, 0, sizeof(outPut));
            stamp_last += 3600;
            outPutLen = m_es2ts(&e2t,(unsigned char *)data,dataLen,frameType,stamp_last,outPut,1024*1024);

            if(outPutLen > 0)
            {
                try{
                send_ts_stream(MulticSocket, outPut, outPutLen);
                }
                catch(...){
                LOGGER->Log(LOGGER_ERROR, "send_ts_stream error!!!");
                }
//                sendto(forwardSocket, outPut, outPutLen, 0, (struct sockaddr *)&sAddr, nAddrLen);
            }
        }
    }
    else if (enmEvent == EVENT_STREAM_CLOSED)
    {
        LOGGER->Log(LOGGER_DEBUG, "playback stream close success.");
        bIsClosed = true;
    }
}

痕忆丶
关注
  • 5
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
H.264视频裸流与AAC声音数据打包成TS
07-30
将H.264视频裸流与AAC声音数据打包成TS格式码流，用于网络传输，例如RTSP
简单实现h264转ts
baiwu4261的博客
01-05 1510
转载注明出处：https://www.cnblogs.com/dyan1024/p/10224538.html 最近一个项目中需要在项目中临时嵌入h264裸流编码成ts的代码，但是以前从没接触过视频，先是在网上搜索了2~3天（主要是想找个能用demo看看编码流程借鉴下）。只找到ffmpeg命令行转码的，ffmpeg也没接触过没那时间去分析怎么转的，而且我们不想使用ffmpeg这个库，之...
H264码合成TS专用API
STN_LCD的专栏
05-22 1552
http://blog.csdn.net/xiahua882/article/details/52622402 版权声明：本文为博主原创文章，未经博主允许不得转载。        为方便264码转换为TS码，针对TSTOOL源码进行分析修改，做成函数接口，供方便调用。目前该接口在VS2013工程环境已经测试通过，不废话，直接上货。    1.函数API
tstools封装H264+aac成TS文件
u011298831的专栏
08-06 2622
本例修改Tstools的esmerge.c示例 部分更改库内容，完成读取H264文件和AAC文件封装成TS文件。 使用函数指针做参数传递，达到把读取源文件和写目标文件方法提到更好操作的地方。 1. 下载tstools源码 官方网站：http://tstool.sourceforge.net/ CSDN资源下载：http://download.csdn.net/do...
H264和音频流打包成TS流 (MPEG2-TS)
热门推荐
音视频技术之路QQ_1695710968
06-30 1万+
  技术在于交流、沟通，转载请注明出处并保持作品的完整性。 原文：https://blog.csdn.net/hiwubihe/article/details/80865920   [本系列相关文章] H264和音频流打包成PS流 (MPEG2-PS) PS流解复用成H264和音频流(ES提取) H264和音频流打包成TS流 (MPEG2-TS) TS流解复用成H264和音频流(E...
Android RTMP 推送 H264/AAC
10-22
Android RTMP 推送 H264/AAC
h264,aac ts封装
05-31
c语言，分别读h264文件，aac文件，封装成ts文件。只有源码，linux下可以编译，源码改一下window也可以用
将H264与AAC打包Ipad可播放的TS流的总结
01-13
将H264与AAC打包Ipad可播放的TS流的总结，如何将裸的音视频打包成TS
RTMP/RTSP推流组件推送H264+AAC到EasyDarwin
12-03
介绍一个基于C++开发的RTSP/RTMP推流组件PushStream，PushStream推流基础组件是一款推送流媒体音/视频流给标准RTSP流媒体服务器 (如EasyDarwin、Wowza) 或者RTMP流媒体服务器 (如Nginx) 的流媒体推送库
Python 实现视频去抖动技术
一键难忘的博客
04-21 6920
Python 视频去抖动是指利用 Python 编程语言和相关的图像处理库，对视频中由于相机震动或手持拍摄等原因而导致的画面抖动进行处理的技术。视频去抖动的目的是使得视频画面更加稳定，减少抖动，提高观看体验。通常，视频去抖动的实现可以采用多种方法，包括基于帧差的方法、运动估计方法、深度学习方法等。其中，基于帧差的方法通过比较相邻帧之间的差异来进行处理，可以简单有效地减少画面抖动。而运动估计方法则通过对视频帧之间的运动进行估计，进而校正画面，使得画面更加稳定。
【剪映专业版】17高质量视频如何导出
小虾米的学习路程
04-21 389
查看原始素材的分辨率：右键单击素材，查看属性，查看详细信息，帧宽度和帧高度（1080P的帧宽度为1920，帧高度为1080）注意：如果原始素材的分辨率为小于1080P，如果导出时选择1080P，则导出的视频分辨率会比原始素材更加模糊。帧率：原始素材是多少帧率，导出就选择多少帧率。音频格式：MP3或者WAV，MP3为有损格式，WAV为无损格式，但是对于普通人来说，区别不大。字幕导出：SRT或者TXT，SRT需要专业的软件才能打开，TXT可以直接打卡。导出时长与导出大小：时长为精确值，大小为估计值。
SSTV音频转图片
orchid_sea的博客
04-22 459
SSTV工具有很多，这里使用RX-SSTV慢扫描工具。
嵌入式Linux driver开发实操（十八）：Linux音频ALSA开发
码农17年的博客
04-21 179
应用程序程序员应该使用库API，而不是内核API。alsa库提供了内核API 100%的功能，但增加了可用性方面的主要改进，使应用程序代码更简单、更美观。未来的修复程序或兼容性代码可能会放在库代码中，而不是放在内核驱动程序中。用来打开一个pcm音频设备，并得到这个音频设备的句柄， 即便用户使用了alsa的插件，使用时也同样是使用此接口，非常方便。通常是接触alsa-lib的第一个api,也通常是使用alsa进行录音或播放的第一步。正如名字中表示的一样，
`THREE.AudioAnalyser` 音频分析
qq_37030315的博客
04-24 501
demo案例 音频分析入参 (Input Parameters):出参 (Output): 可能不直接返回出参，而是提供方法来获取分析结果，如频谱数据或波形数据。方法 (Methods):属性 (Properties): 本内容来源于小豆包，想要更多内容请跳转小豆包 》
基于51单片机的电子秤LCD1602液晶显示( proteus仿真+程序+设计报告+讲解视频）
weixin_52733843的博客
04-22 826
基于51单片机电子秤LCD显示( proteus仿真+程序+设计报告+讲解视频）仿真图proteus8.9及以上程序编译器：keil 4/keil 5编程语言：C语言设计编号：S0083。
Python实现视频转音频
最新发布
zhu6201976的博客
04-25 249
Python实现视频转音频
【FFmpeg】视频与图片互相转换 ( 视频与 JPG 静态图片互相转换 | 视频与 GIF 动态图片互相转换 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
04-21 4003
一、视频与 JPG 静态图片互相转换 1、视频转静态图片 2、视频转多张静态图片 3、多张静态图片转视频 二、视频与 GIF 动态图片互相转换 1、视频转成 GIF 动态图片 2、 GIF 动态图片转成视频
FFmpeg javaUDP 输出H264/265的码流
03-27
要在Java中使用FFmpeg输出H264/265的码流，可以使用Java ProcessBuilder来启动FFmpeg进程，并将输出重定向到Java程序中。 以下是一个示例代码： ``` import java.io.BufferedReader; import java.io.IOException; ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值