该程序rtsp源码结合 mpp 里 sample_venc 的视频编码样例可以用 VLC 播放 H.265 视频实时流将rtsp_server.h， sample_venc.c 这 2 个文件放到 mpp/sample/venc 目录下重新make即可。
在文件系统执行./sample_venc VLC播放器里打开网络串流 ：
在文件系统执行./sample_venc VLC播放器里打开网络串流 ：
rtsp://Your ip:554/stream_chn0.h265 即可播放H.265视频流
修改 VLC->>打开网络串流->>勾选显示更多选项->>正在缓冲->> 300ms，可以稍微降低延时。不然延时有点大。
rtsp_server.h
#ifndef RTSP_SERVER_H
#define RTSP_SERVER_H
//#include "rtsp_cmd.h"
#if !defined(WIN32)
#define __PACKED__ __attribute__ ((__packed__))
#else
#define __PACKED__
#endif
typedef enum
{
RTSP_VIDEO=0,
RTSP_VIDEOSUB=1,
RTSP_AUDIO=2,
RTSP_YUV422=3,
RTSP_RGB=4,
RTSP_VIDEOPS=5,
RTSP_VIDEOSUBPS=6
}enRTSP_MonBlockType;
struct _RTP_FIXED_HEADER
{
/**//* byte 0 */
unsigned char csrc_len:4; /**//* expect 0 */
unsigned char extension:1; /**//* expect 1, see RTP_OP below */
unsigned char padding:1; /**//* expect 0 */
unsigned char version:2; /**//* expect 2 */
/**//* byte 1 */
unsigned char payload:7; /**//* RTP_PAYLOAD_RTSP */
unsigned char marker:1; /**//* expect 1 */
/**//* bytes 2, 3 */
unsigned short seq_no;
/**//* bytes 4-7 */
unsigned long timestamp;
/**//* bytes 8-11 */
unsigned long ssrc; /**//* stream number is used here. */
} __PACKED__;
typedef struct _RTP_FIXED_HEADER RTP_FIXED_HEADER;
struct _NALU_HEADER
{
//byte 0
unsigned char TYPE:5;
unsigned char NRI:2;
unsigned char F:1;
}__PACKED__; /**//* 1 BYTES */
typedef struct _NALU_HEADER NALU_HEADER;
struct _FU_INDICATOR
{
//byte 0
unsigned char TYPE:5;
unsigned char NRI:2;
unsigned char F:1;
}__PACKED__; /**//* 1 BYTES */
typedef struct _FU_INDICATOR FU_INDICATOR;
struct _FU_HEADER
{
//byte 0
unsigned char TYPE:5;
unsigned char R:1;
unsigned char E:1;
unsigned char S:1;
} __PACKED__; /**//* 1 BYTES */
typedef struct _FU_HEADER FU_HEADER;
struct _H265_NALU_HEADER
{
//byte 0
unsigned char LayerId_h:1;
unsigned char TYPE:6;
unsigned char F:1;
//byte 1
unsigned char TID:3;
unsigned char LayerId_l:5;
}__PACKED__; /**//* 2 BYTES */
typedef struct _H265_NALU_HEADER H265_NALU_HEADER;
struct _H265_FU_INDICATOR
{
//byte 0
unsigned char LayerId_h:1;
unsigned char TYPE:6;
unsigned char F:1;
//byte 1
unsigned char TID:3;
unsigned char LayerId_l:5;
}__PACKED__; /**//* 2 BYTES */
typedef struct _H265_FU_INDICATOR H265_FU_INDICATOR;
struct _H265_FU_HEADER
{
//byte 0
unsigned char FuTYPE:6;
unsigned char E:1;
unsigned char S:1;
} __PACKED__; /**//* 1 BYTES */
typedef struct _H265_FU_HEADER H265_FU_HEADER;
struct _AU_HEADER
{
//byte 0, 1
unsigned short au_len;
//byte 2,3
unsigned short frm_len:13;
unsigned char au_index:3;
} __PACKED__; /**//* 1 BYTES */
typedef struct _AU_HEADER AU_HEADER;
void InitRtspServer();
int AddFrameToRtspBuf(int nChanNum,enRTSP_MonBlockType eType, char * pData, unsigned int nSize, unsigned int nVidFrmNum,int bIFrm);
#endif
/******************************************************************************
A simple program of Hisilicon Hi35xx video encode implementation.
Copyright (C), 2010-2011, Hisilicon Tech. Co., Ltd.
******************************************************************************
Modification: 2011-2 Created
******************************************************************************/
#ifdef __cplusplus
#if __cplusplus
extern "C"{
#endif
#endif /* End of #ifdef __cplusplus */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <signal.h>
#include <time.h>
#include <netdb.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <netinet/if_ether.h>
#include <net/if.h>
#include <linux/if_ether.h>
#include <linux/sockios.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "rtsp_server.h"
#include "sample_comm.h"
#define nalu_sent_len 15000 //def:14000
//#define nalu_sent_len 1400
#define RTP_H264 96
#define MAX_CHAN 8
#define RTP_AUDIO 97
#define MAX_RTSP_CLIENT 4
#define RTSP_SERVER_PORT 554
#define RTSP_RECV_SIZE 1024 //def:1024 VLC:2*1024 ffmpeg:1024
#define RTSP_MAX_VID (1152*1024) //def:1024*1024 VLC:2*1024 ffmpeg:1152*1024
#define RTSP_MAX_AUD (15*1024)
#define AU_HEADER_SIZE 4
#define PARAM_STRING_MAX 100
static SAMPLE_VENC_GETSTREAM_PARA_S gs_stPara;
static pthread_t gs_VencPid;
typedef unsigned short u_int16_t;
typedef unsigned char u_int8_t;
typedef u_int16_t portNumBits;
typedef u_int32_t netAddressBits;
typedef long long _int64;
#ifndef FALSE
#define FALSE 0
#endif
#ifndef TRUE
#define TRUE 1
#endif
#define AUDIO_RATE 8000
#define PACKET_BUFFER_END (unsigned int)0x00000000
typedef struct
{
int startblock;
int BlockFileNum;
}IDXFILEHEAD_INFO;
typedef struct
{
_int64 starttime;
_int64 endtime;
int startblock;
int stampnum;
}IDXFILEBLOCK_INFO;
typedef struct
{
int blockindex;
}IDXSTAMP_INFO;
typedef struct
{
char filename[150];
}FILESTAMP_INFO;
typedef struct
{
char channelid[9];
_int64 starttime;
_int64 endtime;
_int64 session;
int type;
int encodetype;
}FIND_INFO;
typedef enum
{
RTP_UDP,
RTP_TCP,
RAW_UDP
}StreamingMode;
extern char g_rtp_playload[20];
extern int g_audio_rate;
typedef enum
{
RTSP_IDLE = 0,
RTSP_CONNECTED = 1,
RTSP_SENDING = 2,
}RTSP_STATUS;
typedef struct
{
int nVidLen;
int nAudLen;
int bIsIFrm;
int bWaitIFrm;
int bIsFree;
char vidBuf[RTSP_MAX_VID];
char audBuf[RTSP_MAX_AUD];
}RTSP_PACK;
typedef struct
{
int index;
int socket;
int reqchn;
int seqnum;
int seqnum2;
unsigned int tsvid;
unsigned int tsaud;
int status;
int sessionid;
int rtpport[2];
int rtcpport;
char IP[20];
char urlPre[PARAM_STRING_MAX];
}RTSP_CLIENT;
typedef struct
{
int vidLen;
int audLen;
int nFrameID;
char vidBuf[RTSP_MAX_VID];
char audBuf[RTSP_MAX_AUD];
}FRAME_PACK;
typedef struct
{
int startcodeprefix_len; //! 4 for parameter sets and first slice in picture, 3 for everything else (suggested)
unsigned len; //! Length of the NAL unit (Excluding the start code, which does not belong to the NALU)
unsigned max_size; //! Nal Unit Buffer size
int forbidden_bit; //! should be always FALSE
int nal_reference_idc; //! NALU_PRIORITY_xxxx
int nal_unit_type; //! NALU_TYPE_xxxx
char *buf; //! contains the first byte followed by the EBSP
unsigned short lost_packets; //! true, if packet loss is detected
} NALU_t;
RTP_FIXED_HEADER *rtp_hdr;
#if 0 //for h264
NALU_HEADER *nalu_hdr;
FU_INDICATOR *fu_ind;
FU_HEADER *fu_hdr;
#endif
H265_NALU_HEADER *h265_nalu_hdr;
H265_FU_INDICATOR *h265_fu_ind;
H265_FU_HEADER *h265_fu_hdr;
FRAME_PACK g_FrmPack[MAX_CHAN];
RTSP_PACK g_rtpPack[MAX_CHAN];
RTSP_CLIENT g_rtspClients[MAX_RTSP_CLIENT];
int g_nSendDataChn = -1;
pthread_mutex_t g_mutex;
pthread_cond_t g_cond;
pthread_mutex_t g_sendmutex;
pthread_t g_SendDataThreadId = 0;
//HAL_CLIENT_HANDLE hMainStreamClient = NULL,hSubStreamClient = NULL,hAudioClient = NULL;
char g_rtp_playload[20];
int g_audio_rate = 8000;
VIDEO_NORM_E gs_enNorm = VIDEO_ENCODING_MODE_NTSC;//30fps
int g_nframerate;
//VIDEO_NORM_E gs_enNorm = VIDEO_ENCODING_MODE_PAL;//15fps
//int g_nframerate = 15;
int exitok = 0;
int udpfd;
/******************************************************************************
* function : show usage
******************************************************************************/
void SAMPLE_VENC_Usage(char *sPrgNm)
{
printf("Usage : %s <index>\n", sPrgNm);
printf("index:\n");
printf("\t 0) 1*1080p H264 + 1*1080p H265 + 1*D1 H264 encode.\n");
printf("\t 1) 1*1080p MJPEG encode + 1*1080p jpeg.\n");
printf("\t 2) low delay encode.\n");
printf("\t 3) roi background framerate.\n");
printf("\t 4) svc-t H264\n");
return;
}
/******************************************************************************
* function : to process abnormal case
******************************************************************************/
void SAMPLE_VENC_HandleSig(HI_S32 signo)
{
if (SIGINT == signo || SIGTERM == signo)
{
SAMPLE_COMM_ISP_Stop();
SAMPLE_COMM_SYS_Exit();
printf("\033[0;31mprogram termination abnormally!\033[0;39m\n");
}
exit(-1);
}
/******************************************************************************
* function : to process abnormal case - the case of stream venc
******************************************************************************/
void SAMPLE_VENC_StreamHandleSig(HI_S32 signo)
{
if (SIGINT == signo || SIGTERM == signo)
{
SAMPLE_COMM_SYS_Exit();
printf("\033[0;31mprogram exit abnormally!\033[0;39m\n");
}
exit(0);
}
HI_S32 VENC_Sent(char *buffer,int buflen)
{
HI_S32 i;
//--------------------------------------------------------
int is=0;
int nChanNum=0;
//printf("s");
for(is=0;is<MAX_RTSP_CLIENT;is++)
{
if(g_rtspClients[is].status!=RTSP_SENDING)
{
continue;
}
int heart = g_rtspClients[is].seqnum % 1000;
#if 0
if(heart==0 && g_rtspClients[is].seqnum!=0)
{
char buf[2*1024];
memset(buf,0,2*1024);
char *pTemp = buf;
pTemp += sprintf(pTemp,"RTSP/1.0 200 OK\r\nCSeq: %s\r\nPublic: %s\r\n\r\n",
0,"OPTIONS,DESCRIBE,SETUP,PLAY,PAUSE,TEARDOWN");
int reg = send(g_rtspClients[is].socket, buf,strlen(buf),0);
if(reg <= 0)
{
//printf("RTSP:Send Error---- %d\n",reg);
g_rtspClients[is].status = RTSP_IDLE;
g_rtspClients[is].seqnum = 0;
g_rtspClients[is].tsvid = 0;
g_rtspClients[is].tsaud = 0;
close(g_rtspClients[is].socket);
continue;
}
else
{
printf("Heart:%d\n",reg);
}
}
#endif
char* nalu_payload;
int nAvFrmLen = 0;
int nIsIFrm = 0;
int nNaluType = 0;
unsigned char u8NaluBytes1;
unsigned char u8NaluBytes2;
char sendbuf[320*1024+32];
//HI_S32 intdelta = -1000,tmptime;
//HI_S32 intdelta = 0,tmptime;
//char sendbuf[64*1024+32];
nChanNum = g_rtspClients[is].reqchn;
if(nChanNum<0 || nChanNum>=MAX_CHAN )
{
continue;
}
nAvFrmLen = buflen;
//printf("%d\n",nAvFrmLen);
//nAvFrmLen = vStreamInfo.dwSize ;//Streamlen
struct sockaddr_in server;
server.sin_family=AF_INET;
server.sin_port=htons(g_rtspClients[is].rtpport[0]);
server.sin_addr.s_addr=inet_addr(g_rtspClients[is].IP);
int bytes=0;
unsigned int timestamp_increse=0;
//timeing in = out,15fps in,so same f out
//if(VIDEO_ENCODING_MODE_PAL == gs_enNorm)g_nframerate = 15;
//else if(VIDEO_ENCODING_MODE_NTSC == gs_enNorm)g_nframerate = 30;
if(VIDEO_ENCODING_MODE_PAL == gs_enNorm)g_nframerate = 16;
else if(VIDEO_ENCODING_MODE_NTSC == gs_enNorm)g_nframerate = 32;//25
//if(VIDEO_ENCODING_MODE_PAL == gs_enNorm)timestamp_increse=5625;//90000/16
//else if(VIDEO_ENCODING_MODE_NTSC == gs_enNorm)timestamp_increse=2813;//90000/32
timestamp_increse=(unsigned int)(90000.0 / g_nframerate);
//sendto(udpfd, buffer, nAvFrmLen, 0, (struct sockaddr *)&server,sizeof(server));
rtp_hdr =(RTP_FIXED_HEADER*)&sendbuf[0];
rtp_hdr->payload = RTP_H264;
rtp_hdr->version = 2;
rtp_hdr->marker = 0;
rtp_hdr->ssrc = htonl(10);
if(nAvFrmLen<=nalu_sent_len)
{
/*设置rtp M位 */
//printf("a");
rtp_hdr->marker=1;
rtp_hdr->seq_no = htons(g_rtspClients[is].seqnum++);
h265_nalu_hdr=(H265_NALU_HEADER*)&sendbuf[12];
h265_nalu_hdr->F = 0;
h265_nalu_hdr->TYPE = nNaluType;
h265_nalu_hdr->LayerId_h = 0;
h265_nalu_hdr->LayerId_l = 0;
h265_nalu_hdr->TID =0x01;
nalu_payload=&sendbuf[13];
memcpy(nalu_payload,buffer,nAvFrmLen);
g_rtspClients[is].tsvid = g_rtspClients[is].tsvid+timestamp_increse;
rtp_hdr->timestamp=htonl(g_rtspClients[is].tsvid);
bytes=nAvFrmLen+ 13 ;
sendto(udpfd, sendbuf, bytes, 0, (struct sockaddr *)&server,sizeof(server));
}
else if(nAvFrmLen>nalu_sent_len)
{
//printf("b");
int k=0,l=0;
k=nAvFrmLen/nalu_sent_len;
l=nAvFrmLen%nalu_sent_len;
int t=0;
/*
tmptime = g_rtspClients[is].tsvid+timestamp_increse;
if(tmptime >= (-intdelta))g_rtspClients[is].tsvid=tmptime + intdelta;
else g_rtspClients[is].tsvid = tmptime;
*/
g_rtspClients[is].tsvid = g_rtspClients[is].tsvid+timestamp_increse;
while(t<=k)
{
rtp_hdr->seq_no = htons(g_rtspClients[is].seqnum++);
if(t==0)
{
rtp_hdr->marker=0;
h265_fu_ind =(H265_FU_INDICATOR*)&sendbuf[12];
h265_fu_ind->F = 0;
h265_fu_ind->TYPE=49;
h265_fu_ind->LayerId_h = 0;
h265_fu_ind->LayerId_l =0;
h265_fu_ind->TID = 0x01;
h265_fu_hdr =(H265_FU_HEADER*)&sendbuf[14];
h265_fu_hdr->E=0;
h265_fu_hdr->S=1;
h265_fu_hdr->FuTYPE=nNaluType;
nalu_payload=&sendbuf[15];
memcpy(nalu_payload,buffer,nalu_sent_len);
bytes=nalu_sent_len+15;
sendto( udpfd, sendbuf, bytes, 0, (struct sockaddr *)&server,sizeof(server));
t++;
}
else if(k==t)
{
rtp_hdr->marker=1;
h265_fu_ind =(H265_FU_INDICATOR*)&sendbuf[12];
h265_fu_ind->F= 0 ;
h265_fu_ind->TYPE=49;
h265_fu_ind->LayerId_h = 0;
h265_fu_ind->LayerId_l = 0;
h265_fu_ind->TID =0x01;
h265_fu_hdr =(H265_FU_HEADER*)&sendbuf[14];
h265_fu_hdr->S=0;
h265_fu_hdr->FuTYPE =nNaluType;
h265_fu_hdr->E=1;
nalu_payload=&sendbuf[15];
memcpy(nalu_payload,buffer+t*nalu_sent_len,l);
bytes=l+15;
sendto(udpfd, sendbuf, bytes, 0, (struct sockaddr *)&server,sizeof(server));
t++;
}
else if(t<k && t!=0)
{
rtp_hdr->marker=0;
h265_fu_ind =(H265_FU_INDICATOR*)&sendbuf[12];
h265_fu_ind->F=0;
h265_fu_ind->TYPE=49;
h265_fu_ind->LayerId_h = 0;
h265_fu_ind->LayerId_l = 0;
h265_fu_ind->TID = 0x01;
h265_fu_hdr =(H265_FU_HEADER*)&sendbuf[14];
h265_fu_hdr->S=0;
h265_fu_hdr->E=0;
h265_fu_hdr->FuTYPE = nNaluType;
nalu_payload=&sendbuf[15];
memcpy(nalu_payload,buffer+t*nalu_sent_len,nalu_sent_len);
bytes=nalu_sent_len+15;
sendto(udpfd, sendbuf, bytes, 0, (struct sockaddr *)&server,sizeof(server));
t++;
}
}
}
}
//------------------------------------------------------------
}
/******************************************************************************
* funciton : sent H265 stream
******************************************************************************/
HI_S32 SAMPLE_COMM_VENC_Sentjin(VENC_STREAM_S *pstStream)
{
HI_S32 i,flag=0;
HI_S32 s32Ret;
/*Venc get StreamBufInfo*/
VENC_STREAM_BUF_INFO_S stStreamBufInfo;
HI_U32 u32Left;
VENC_CHN VeChn = 0;
HI_U32 u32SrcPhyAddr, u32DestPhyAddr;
s32Ret = HI_MPI_VENC_GetStreamBufInfo(VeChn,&stStreamBufInfo);
if (HI_SUCCESS != s32Ret)
{
return HI_FAILURE;
}
for(i=0;i<MAX_RTSP_CLIENT;i++)//have atleast a connect
{
if(g_rtspClients[i].status == RTSP_SENDING)
{
flag = 1;
break;
}
}
if(flag)
{
//printf("a");
for (i = 0; i < pstStream->u32PackCount; i++)
{
HI_S32 lens=0,j,lastadd=0,newadd=0,showflap=0;
char sendbuf[200*1024];
memcpy(&sendbuf[0]+ lens ,
pstStream->pstPack[i].pu8Addr+pstStream->pstPack[i].u32Offset,
pstStream->pstPack[i].u32Len-pstStream->pstPack[i].u32Offset);
lens += pstStream->pstPack[i].u32Len-pstStream->pstPack[i].u32Offset;
VENC_Sent(sendbuf,lens);
lens = 0;
}
}
return HI_SUCCESS;
}
/******************************************************************************
* funciton : get stream from each channels and save them
******************************************************************************/
HI_VOID* SAMPLE_COMM_VENC_GetVencStreamProcsent(HI_VOID *p)
{
pthread_detach(pthread_self());
printf("RTSP:-----create send thread\n");
//i=0,720p; i=1,VGA 640*480; i=2, 320*240;
HI_S32 i=0;//exe ch NO.
HI_S32 s32ChnTotal;
SAMPLE_VENC_GETSTREAM_PARA_S *pstPara;
HI_S32 maxfd = 0;
struct timeval TimeoutVal;
fd_set read_fds;
HI_S32 VencFd[VENC_MAX_CHN_NUM];
VENC_CHN_STAT_S stStat;
HI_S32 s32Ret;
VENC_STREAM_S stStream;
pstPara = (SAMPLE_VENC_GETSTREAM_PARA_S*)p;
s32ChnTotal = pstPara->s32Cnt;
/******************************************
step 1: check & prepare save-file & venc-fd
******************************************/
if (s32ChnTotal >= VENC_MAX_CHN_NUM)
{
SAMPLE_PRT("input count invaild\n");
return NULL;
}
//for (i = 0; i < s32ChnTotal; i++)
{
/* Set Venc Fd. */
VencFd[i] = HI_MPI_VENC_GetFd(i);
if (VencFd[i] < 0)
{
SAMPLE_PRT("HI_MPI_VENC_GetFd failed with %#x!\n",
VencFd[i]);
return NULL;
}
if (maxfd <= VencFd[i])
{
maxfd = VencFd[i];
}
}
udpfd = socket(AF_INET,SOCK_DGRAM,0);//UDP
printf("udp up\n");
/******************************************
step 2: Start to get streams of each channel.
******************************************/
while (HI_TRUE == pstPara->bThreadStart)
{
HI_S32 is,flag=0;
for(is=0;is<MAX_RTSP_CLIENT;is++)//have atleast a connect
{
if(g_rtspClients[is].status == RTSP_SENDING)
{
flag = 1;
break;
}
}
if(flag)
{
FD_ZERO(&read_fds);
//for (i = 0; i < s32ChnTotal; i++)
{
FD_SET(VencFd[i], &read_fds);
}
TimeoutVal.tv_sec = 2;
TimeoutVal.tv_usec = 0;
s32Ret = select(maxfd + 1, &read_fds, NULL, NULL, &TimeoutVal);
if (s32Ret < 0)
{
SAMPLE_PRT("select failed!\n");
break;
}
else if (s32Ret == 0)
{
SAMPLE_PRT("get venc stream time out, exit thread\n");
continue;
}
else
{
//only ch1 used
//for (i = 0; i < s32ChnTotal; i++)
//for (i = 0; i < 1; i++)
//i = 1;
{
if (FD_ISSET(VencFd[i], &read_fds))
{
/*******************************************************
step 2.1 : query how many packs in one-frame stream.
*******************************************************/
//printf("query how many packs \n");
memset(&stStream, 0, sizeof(stStream));
s32Ret = HI_MPI_VENC_Query(i, &stStat);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VENC_Query chn[%d] failed with %#x!\n", i, s32Ret);
break;
}
/*******************************************************
step 2.2 : malloc corresponding number of pack nodes.
*******************************************************/
stStream.pstPack = (VENC_PACK_S*)malloc(sizeof(VENC_PACK_S) * stStat.u32CurPacks);
if (NULL == stStream.pstPack)
{
SAMPLE_PRT("malloc stream pack failed!\n");
break;
}
/*******************************************************
step 2.3 : call mpi to get one-frame stream
*******************************************************/
if(exitok)
{
free(stStream.pstPack);
stStream.pstPack = NULL;
exitok++;return NULL;
}
stStream.u32PackCount = stStat.u32CurPacks;
s32Ret = HI_MPI_VENC_GetStream(i, &stStream, HI_TRUE);
if (HI_SUCCESS != s32Ret)
{
free(stStream.pstPack);
stStream.pstPack = NULL;
SAMPLE_PRT("HI_MPI_VENC_GetStream failed with %#x!\n", \
s32Ret);
break;
}
//if(stStream.u32PackCount>0)printf("getpack%d\n",stStream.u32PackCount);
//printf("gt1\n");
SAMPLE_COMM_VENC_Sentjin(&stStream);
/*
pthread_t threadsentId = 0;
struct sched_param sentsched;
sentsched.sched_priority = 20;
//to listen visiting
pthread_create(&threadsentId, NULL, SAMPLE_COMM_VENC_Sentjin,(HI_VOID*)&stStream);
pthread_setschedparam(threadsentId,SCHED_RR,&sentsched);
*/
//step 2.5 : release stream/
s32Ret = HI_MPI_VENC_ReleaseStream(i, &stStream);
if (HI_SUCCESS != s32Ret)
{
free(stStream.pstPack);
stStream.pstPack = NULL;
break;
}
//step 2.6 : free pack nodes/
free(stStream.pstPack);
stStream.pstPack = NULL;
if(exitok){ exitok++;return NULL; }
}
}
}
}
usleep(100);
}
return NULL;
}
/******************************************************************************
* function : H.264@1080p@30fps+H.265@1080p@30fps+H.264@D1@30fps
******************************************************************************/
HI_S32 SAMPLE_VENC_1080P_CLASSIC(HI_VOID)
{
PAYLOAD_TYPE_E enPayLoad[3]= {PT_H265, PT_H264, PT_H264};//def:{PT_H264, PT_H265, PT_H264}
//PAYLOAD_TYPE_E enPayLoad[3]= {PT_H265,PT_H264, PT_JPEG};
PIC_SIZE_E enSize[3] = {PIC_HD1080, PIC_HD720, PIC_D1};
//PIC_SIZE_E enSize[3] = {PIC_2592x1520, PIC_VGA, PIC_D1};
HI_U32 u32Profile = 0;
VB_CONF_S stVbConf;
SAMPLE_VI_CONFIG_S stViConfig = {0};
VPSS_GRP VpssGrp;
VPSS_CHN VpssChn;
VPSS_GRP_ATTR_S stVpssGrpAttr;
VPSS_CHN_ATTR_S stVpssChnAttr;
VPSS_CHN_MODE_S stVpssChnMode;
VENC_CHN VencChn;
SAMPLE_RC_E enRcMode= SAMPLE_RC_CBR;
HI_S32 s32ChnNum=1;
HI_S32 s32Ret = HI_SUCCESS;
HI_U32 u32BlkSize;
SIZE_S stSize;
char c;
/*if ((SONY_IMX178_LVDS_5M_30FPS == SENSOR_TYPE)
|| (APTINA_AR0330_MIPI_1536P_25FPS == SENSOR_TYPE)
|| (APTINA_AR0330_MIPI_1296P_25FPS == SENSOR_TYPE))
{
s32ChnNum = 2;
}
else
{
s32ChnNum = 3;
}
if( OMNIVISION_OV4689_MIPI_4M_30FPS == SENSOR_TYPE)
{
enSize[0] = PIC_2592x1520;
}
else if(OMNIVISION_OV4689_MIPI_1080P_30FPS == SENSOR_TYPE)
{
enSize[0] = PIC_HD1080;
}*/
/******************************************
step 1: init sys variable
******************************************/
memset(&stVbConf,0,sizeof(VB_CONF_S));
SAMPLE_COMM_VI_GetSizeBySensor(&enSize[0]);
switch(SENSOR_TYPE)
{
case SONY_IMX178_LVDS_5M_30FPS:
case APTINA_AR0330_MIPI_1536P_25FPS:
case APTINA_AR0330_MIPI_1296P_25FPS:
case OMNIVISION_OV4689_MIPI_4M_30FPS:
case OMNIVISION_OV4689_MIPI_1080P_30FPS:
enSize[1] = PIC_VGA;
break;
default:
break;
}
stVbConf.u32MaxPoolCnt = 128;
/*video buffer*/
u32BlkSize = SAMPLE_COMM_SYS_CalcPicVbBlkSize(gs_enNorm,\
enSize[0], SAMPLE_PIXEL_FORMAT, SAMPLE_SYS_ALIGN_WIDTH);
stVbConf.astCommPool[0].u32BlkSize = u32BlkSize;
stVbConf.astCommPool[0].u32BlkCnt = 10;//8 def:20
u32BlkSize = SAMPLE_COMM_SYS_CalcPicVbBlkSize(gs_enNorm,\
enSize[1], SAMPLE_PIXEL_FORMAT, SAMPLE_SYS_ALIGN_WIDTH);
stVbConf.astCommPool[1].u32BlkSize = u32BlkSize;
stVbConf.astCommPool[1].u32BlkCnt =10;//8 def:20
u32BlkSize = SAMPLE_COMM_SYS_CalcPicVbBlkSize(gs_enNorm,\
enSize[2], SAMPLE_PIXEL_FORMAT, SAMPLE_SYS_ALIGN_WIDTH);
stVbConf.astCommPool[2].u32BlkSize = u32BlkSize;
stVbConf.astCommPool[2].u32BlkCnt = 10;//10 def:20
/******************************************
step 2: mpp system init.
******************************************/
s32Ret = SAMPLE_COMM_SYS_Init(&stVbConf);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("system init failed with %d!\n", s32Ret);
goto END_VENC_1080P_CLASSIC_0;
}
/******************************************
step 3: start vi dev & chn to capture
******************************************/
stViConfig.enViMode = SENSOR_TYPE;
stViConfig.enRotate = ROTATE_NONE;
stViConfig.enNorm = VIDEO_ENCODING_MODE_NTSC;//def: VIDEO_ENCODING_MODE_AUTO
stViConfig.enViChnSet = VI_CHN_SET_NORMAL;
stViConfig.enWDRMode = WDR_MODE_NONE;
s32Ret = SAMPLE_COMM_VI_StartVi(&stViConfig);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("start vi failed!\n");
goto END_VENC_1080P_CLASSIC_1;
}
/******************************************
step 4: start vpss and vi bind vpss
******************************************/
s32Ret = SAMPLE_COMM_SYS_GetPicSize(gs_enNorm, enSize[0], &stSize);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("SAMPLE_COMM_SYS_GetPicSize failed!\n");
goto END_VENC_1080P_CLASSIC_1;
}
VpssGrp = 0;
stVpssGrpAttr.u32MaxW = stSize.u32Width;
stVpssGrpAttr.u32MaxH = stSize.u32Height;
stVpssGrpAttr.bIeEn = HI_FALSE;
stVpssGrpAttr.bNrEn = HI_TRUE;
stVpssGrpAttr.bHistEn = HI_FALSE;
stVpssGrpAttr.bDciEn = HI_FALSE;
stVpssGrpAttr.enDieMode = VPSS_DIE_MODE_NODIE;
stVpssGrpAttr.enPixFmt = SAMPLE_PIXEL_FORMAT;
s32Ret = SAMPLE_COMM_VPSS_StartGroup(VpssGrp, &stVpssGrpAttr);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Start Vpss failed!\n");
goto END_VENC_1080P_CLASSIC_2;
}
s32Ret = SAMPLE_COMM_VI_BindVpss(stViConfig.enViMode);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Vi bind Vpss failed!\n");
goto END_VENC_1080P_CLASSIC_3;
}
VpssChn = 0;
stVpssChnMode.enChnMode = VPSS_CHN_MODE_USER;
stVpssChnMode.bDouble = HI_FALSE;
stVpssChnMode.enPixelFormat = SAMPLE_PIXEL_FORMAT;
stVpssChnMode.u32Width = stSize.u32Width;
stVpssChnMode.u32Height = stSize.u32Height;
stVpssChnMode.enCompressMode = COMPRESS_MODE_SEG;
memset(&stVpssChnAttr, 0, sizeof(stVpssChnAttr));
stVpssChnAttr.s32SrcFrameRate = -1;
stVpssChnAttr.s32DstFrameRate = -1;
s32Ret = SAMPLE_COMM_VPSS_EnableChn(VpssGrp, VpssChn, &stVpssChnAttr, &stVpssChnMode, HI_NULL);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Enable vpss chn failed!\n");
goto END_VENC_1080P_CLASSIC_4;
}
VpssChn = 1;
stVpssChnMode.enChnMode = VPSS_CHN_MODE_USER;
stVpssChnMode.bDouble = HI_FALSE;
stVpssChnMode.enPixelFormat = SAMPLE_PIXEL_FORMAT;
stVpssChnMode.u32Width = stSize.u32Width; //640
stVpssChnMode.u32Height = stSize.u32Height; //480
stVpssChnMode.enCompressMode = COMPRESS_MODE_SEG;
stVpssChnAttr.s32SrcFrameRate = -1;
stVpssChnAttr.s32DstFrameRate = -1;
s32Ret = SAMPLE_COMM_VPSS_EnableChn(VpssGrp, VpssChn, &stVpssChnAttr, &stVpssChnMode, HI_NULL);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Enable vpss chn failed!\n");
goto END_VENC_1080P_CLASSIC_4;
}
if((SONY_IMX178_LVDS_5M_30FPS != SENSOR_TYPE)
&& (APTINA_AR0330_MIPI_1536P_25FPS != SENSOR_TYPE)
&& (APTINA_AR0330_MIPI_1296P_25FPS != SENSOR_TYPE))
{
VpssChn = 2;
stVpssChnMode.enChnMode = VPSS_CHN_MODE_USER;
stVpssChnMode.bDouble = HI_FALSE;
stVpssChnMode.enPixelFormat = SAMPLE_PIXEL_FORMAT;
stVpssChnMode.u32Width = 720;
stVpssChnMode.u32Height = (VIDEO_ENCODING_MODE_PAL==gs_enNorm)?576:480;;
stVpssChnMode.enCompressMode = COMPRESS_MODE_NONE;
stVpssChnAttr.s32SrcFrameRate = -1;
stVpssChnAttr.s32DstFrameRate = -1;
s32Ret = SAMPLE_COMM_VPSS_EnableChn(VpssGrp, VpssChn, &stVpssChnAttr, &stVpssChnMode, HI_NULL);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Enable vpss chn failed!\n");
goto END_VENC_1080P_CLASSIC_4;
}
}
/******************************************
step 5: start stream venc
******************************************/
/*** HD1080P **/
enRcMode = SAMPLE_RC_CBR;
VpssGrp = 0;
VpssChn = 0;
VencChn = 0;
s32Ret = SAMPLE_COMM_VENC_Start(VencChn, enPayLoad[0],\
gs_enNorm, enSize[0], enRcMode,u32Profile);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Start Venc failed!\n");
goto END_VENC_1080P_CLASSIC_5;
}
s32Ret = SAMPLE_COMM_VENC_BindVpss(VencChn, VpssGrp, VpssChn);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Start Venc failed!\n");
goto END_VENC_1080P_CLASSIC_5;
}
/*** 1080p **/
/*VpssChn = 1;
VencChn = 1;
s32Ret = SAMPLE_COMM_VENC_Start(VencChn, enPayLoad[1], \
gs_enNorm, enSize[1], enRcMode,u32Profile);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Start Venc failed!\n");
goto END_VENC_1080P_CLASSIC_5;
}
s32Ret = SAMPLE_COMM_VENC_BindVpss(VencChn, VpssGrp, VpssChn);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Start Venc failed!\n");
goto END_VENC_1080P_CLASSIC_5;
}*/
/*** D1 **/
/*if(SONY_IMX178_LVDS_5M_30FPS != SENSOR_TYPE)
{
VpssChn = 2;
VencChn = 2;
s32Ret = SAMPLE_COMM_VENC_Start(VencChn, enPayLoad[2], \
gs_enNorm, enSize[2], enRcMode,u32Profile);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Start Venc failed!\n");
goto END_VENC_1080P_CLASSIC_5;
}
s32Ret = SAMPLE_COMM_VENC_BindVpss(VencChn, VpssGrp, VpssChn);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Start Venc failed!\n");
goto END_VENC_1080P_CLASSIC_5;
}
}*/
/******************************************
step 6: stream venc process -- get stream, then save it to file.
******************************************/
/*s32Ret = SAMPLE_COMM_VENC_StartGetStream(s32ChnNum);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Start Venc failed!\n");
goto END_VENC_1080P_CLASSIC_5;
}*/
gs_stPara.bThreadStart = HI_TRUE;
gs_stPara.s32Cnt = s32ChnNum;
struct sched_param schedvenc;
schedvenc.sched_priority = 10;
//to get stream
pthread_create(&gs_VencPid, 0, SAMPLE_COMM_VENC_GetVencStreamProcsent, (HI_VOID*)&gs_stPara);
pthread_setschedparam(gs_VencPid,SCHED_RR,&schedvenc);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Start Venc failed!\n");
goto END_VENC_1080P_CLASSIC_5;
}
printf("please press twice ENTER to exit this sample\n");
getchar();
getchar();
/******************************************
step 7: exit process
******************************************/
SAMPLE_COMM_VENC_StopGetStream();
END_VENC_1080P_CLASSIC_5:
VpssGrp = 0;
VpssChn = 0;
VencChn = 0;
SAMPLE_COMM_VENC_UnBindVpss(VencChn, VpssGrp, VpssChn);
SAMPLE_COMM_VENC_Stop(VencChn);
VpssChn = 1;
VencChn = 1;
SAMPLE_COMM_VENC_UnBindVpss(VencChn, VpssGrp, VpssChn);
SAMPLE_COMM_VENC_Stop(VencChn);
if(SONY_IMX178_LVDS_5M_30FPS != SENSOR_TYPE)
{
VpssChn = 2;
VencChn = 2;
SAMPLE_COMM_VENC_UnBindVpss(VencChn, VpssGrp, VpssChn);
SAMPLE_COMM_VENC_Stop(VencChn);
}
SAMPLE_COMM_VI_UnBindVpss(stViConfig.enViMode);
END_VENC_1080P_CLASSIC_4: //vpss stop
VpssGrp = 0;
VpssChn = 0;
SAMPLE_COMM_VPSS_DisableChn(VpssGrp, VpssChn);
VpssChn = 1;
SAMPLE_COMM_VPSS_DisableChn(VpssGrp, VpssChn);
if(SONY_IMX178_LVDS_5M_30FPS != SENSOR_TYPE)
{
VpssChn = 2;
SAMPLE_COMM_VPSS_DisableChn(VpssGrp, VpssChn);
}
END_VENC_1080P_CLASSIC_3: //vpss stop
SAMPLE_COMM_VI_UnBindVpss(stViConfig.enViMode);
END_VENC_1080P_CLASSIC_2: //vpss stop
SAMPLE_COMM_VPSS_StopGroup(VpssGrp);
END_VENC_1080P_CLASSIC_1: //vi stop
SAMPLE_COMM_VI_StopVi(&stViConfig);
END_VENC_1080P_CLASSIC_0: //system exit
SAMPLE_COMM_SYS_Exit();
return s32Ret;
}
#if 0
/******************************************************************************
* function : 1路1080p MJPEG encode and 1路1080p JPEG snap
******************************************************************************/
HI_S32 SAMPLE_VENC_1080P_MJPEG_JPEG(HI_VOID)
{
PAYLOAD_TYPE_E enPayLoad = PT_MJPEG;
PIC_SIZE_E enSize = PIC_HD1080;
HI_U32 u32Profile = 0;
VB_CONF_S stVbConf;
SAMPLE_VI_CONFIG_S stViConfig = {0};
VPSS_GRP VpssGrp;
VPSS_CHN VpssChn;
VPSS_GRP_ATTR_S stVpssGrpAttr;
VPSS_CHN_ATTR_S stVpssChnAttr;
VPSS_CHN_MODE_S stVpssChnMode;
VENC_CHN VencChn;
SAMPLE_RC_E enRcMode = SAMPLE_RC_CBR;
HI_S32 s32ChnNum = 1;
HI_S32 s32Ret = HI_SUCCESS;
HI_U32 u32BlkSize;
SIZE_S stSize;
HI_S32 i = 0;
char ch;
/******************************************
step 1: init sys variable
******************************************/
memset(&stVbConf,0,sizeof(VB_CONF_S));
stVbConf.u32MaxPoolCnt = 128;
SAMPLE_COMM_VI_GetSizeBySensor(&enSize);
/*video buffer*/
u32BlkSize = SAMPLE_COMM_SYS_CalcPicVbBlkSize(gs_enNorm,\
enSize, SAMPLE_PIXEL_FORMAT, SAMPLE_SYS_ALIGN_WIDTH);
stVbConf.astCommPool[0].u32BlkSize = u32BlkSize;
stVbConf.astCommPool[0].u32BlkCnt = 12;
/******************************************
step 2: mpp system init.
******************************************/
s32Ret = SAMPLE_COMM_SYS_Init(&stVbConf);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("system init failed with %d!\n", s32Ret);
goto END_VENC_MJPEG_JPEG_0;
}
/******************************************
step 3: start vi dev & chn to capture
******************************************/
stViConfig.enViMode = SENSOR_TYPE;
stViConfig.enRotate = ROTATE_NONE;
stViConfig.enNorm = VIDEO_ENCODING_MODE_AUTO;
stViConfig.enViChnSet = VI_CHN_SET_NORMAL;
s32Ret = SAMPLE_COMM_VI_StartVi(&stViConfig);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("start vi failed!\n");
goto END_VENC_MJPEG_JPEG_1;
}
/******************************************
step 4: start vpss and vi bind vpss
******************************************/
s32Ret = SAMPLE_COMM_SYS_GetPicSize(gs_enNorm, enSize, &stSize);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("SAMPLE_COMM_SYS_GetPicSize failed!\n");
goto END_VENC_MJPEG_JPEG_1;
}
VpssGrp = 0;
stVpssGrpAttr.u32MaxW = stSize.u32Width;
stVpssGrpAttr.u32MaxH = stSize.u32Height;
stVpssGrpAttr.bIeEn = HI_FALSE;
stVpssGrpAttr.bNrEn = HI_TRUE;
stVpssGrpAttr.bHistEn = HI_FALSE;
stVpssGrpAttr.enDieMode = VPSS_DIE_MODE_NODIE;
stVpssGrpAttr.enPixFmt = SAMPLE_PIXEL_FORMAT;
stVpssGrpAttr.bDciEn = HI_FALSE;
s32Ret = SAMPLE_COMM_VPSS_StartGroup(VpssGrp, &stVpssGrpAttr);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Start Vpss failed!\n");
goto END_VENC_MJPEG_JPEG_2;
}
s32Ret = SAMPLE_COMM_VI_BindVpss(stViConfig.enViMode);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Vi bind Vpss failed!\n");
goto END_VENC_MJPEG_JPEG_3;
}
VpssChn = 0;
stVpssChnMode.enChnMode = VPSS_CHN_MODE_USER;
stVpssChnMode.bDouble = HI_FALSE;
stVpssChnMode.enPixelFormat = SAMPLE_PIXEL_FORMAT;
stVpssChnMode.u32Width = stSize.u32Width;
stVpssChnMode.u32Height = stSize.u32Height;
stVpssChnMode.enCompressMode = COMPRESS_MODE_NONE;
memset(&stVpssChnAttr, 0, sizeof(stVpssChnAttr));
stVpssChnAttr.s32SrcFrameRate = -1;
stVpssChnAttr.s32DstFrameRate = -1;
s32Ret = SAMPLE_COMM_VPSS_EnableChn(VpssGrp, VpssChn, &stVpssChnAttr, &stVpssChnMode, HI_NULL);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Enable vpss chn failed!\n");
goto END_VENC_MJPEG_JPEG_4;
}
VpssChn = 1;
stVpssChnMode.enChnMode = VPSS_CHN_MODE_USER;
stVpssChnMode.bDouble = HI_FALSE;
stVpssChnMode.enPixelFormat = SAMPLE_PIXEL_FORMAT;
stVpssChnMode.u32Width = stSize.u32Width;
stVpssChnMode.u32Height = stSize.u32Height;
stVpssChnMode.enCompressMode = COMPRESS_MODE_NONE;
memset(&stVpssChnAttr, 0, sizeof(stVpssChnAttr));
stVpssChnAttr.s32SrcFrameRate = -1;
stVpssChnAttr.s32DstFrameRate = -1;
s32Ret = SAMPLE_COMM_VPSS_EnableChn(VpssGrp, VpssChn, &stVpssChnAttr, &stVpssChnMode, HI_NULL);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Enable vpss chn failed!\n");
goto END_VENC_MJPEG_JPEG_4;
}
/******************************************
step 5: start stream venc
******************************************/
VpssGrp = 0;
VpssChn = 0;
VencChn = 0;
s32Ret = SAMPLE_COMM_VENC_Start(VencChn, enPayLoad,\
gs_enNorm, enSize, enRcMode,u32Profile);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Start Venc failed!\n");
goto END_VENC_MJPEG_JPEG_5;
}
s32Ret = SAMPLE_COMM_VENC_BindVpss(VencChn, VpssGrp, VpssChn);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Start Venc failed!\n");
goto END_VENC_MJPEG_JPEG_5;
}
VpssGrp = 0;
VpssChn = 1;
VencChn = 1;
s32Ret = SAMPLE_COMM_VENC_SnapStart(VencChn, &stSize);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Start snap failed!\n");
goto END_VENC_MJPEG_JPEG_5;
}
s32Ret = SAMPLE_COMM_VENC_BindVpss(VencChn, VpssGrp, VpssChn);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Start Venc failed!\n");
goto END_VENC_MJPEG_JPEG_5;
}
/******************************************
step 6: stream venc process -- get stream, then save it to file.
******************************************/
s32Ret = SAMPLE_COMM_VENC_StartGetStream(s32ChnNum);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Start Venc failed!\n");
goto END_VENC_MJPEG_JPEG_5;
}
printf("press 'q' to exit sample!\nperess ENTER to capture one picture to file\n");
i = 0;
while ((ch = getchar()) != 'q')
{
s32Ret = SAMPLE_COMM_VENC_SnapProcess(VencChn);
if (HI_SUCCESS != s32Ret)
{
printf("%s: sanp process failed!\n", __FUNCTION__);
break;
}
printf("snap %d success!\n", i);
i++;
}
printf("please press ENTER to exit this sample\n");
getchar();
getchar();
/******************************************
step 8: exit process
******************************************/
SAMPLE_COMM_VENC_StopGetStream();
END_VENC_MJPEG_JPEG_5:
VpssGrp = 0;
VpssChn = 0;
VencChn = 0;
SAMPLE_COMM_VENC_UnBindVpss(VencChn, VpssGrp, VpssChn);
SAMPLE_COMM_VENC_Stop(VencChn);
VpssChn = 1;
VencChn = 1;
SAMPLE_COMM_VENC_UnBindVpss(VencChn, VpssGrp, VpssChn);
SAMPLE_COMM_VENC_Stop(VencChn);
END_VENC_MJPEG_JPEG_4: //vpss stop
VpssGrp = 0;
VpssChn = 0;
SAMPLE_COMM_VPSS_DisableChn(VpssGrp, VpssChn);
VpssChn = 1;
SAMPLE_COMM_VPSS_DisableChn(VpssGrp, VpssChn);
END_VENC_MJPEG_JPEG_3: //vpss stop
SAMPLE_COMM_VI_UnBindVpss(stViConfig.enViMode);
END_VENC_MJPEG_JPEG_2: //vpss stop
SAMPLE_COMM_VPSS_StopGroup(VpssGrp);
END_VENC_MJPEG_JPEG_1: //vi stop
SAMPLE_COMM_VI_StopVi(&stViConfig);
END_VENC_MJPEG_JPEG_0: //system exit
SAMPLE_COMM_SYS_Exit();
return s32Ret;
}
/******************************************************************************
* function : 720p snap
******************************************************************************/
HI_S32 SAMPLE_VENC_LOW_DELAY(HI_VOID)
{
PAYLOAD_TYPE_E enPayLoad[2]= {PT_H264, PT_H264};
PIC_SIZE_E enSize[2] = {PIC_HD1080, PIC_VGA};
HI_U32 u32Profile = 0;
VB_CONF_S stVbConf;
SAMPLE_VI_CONFIG_S stViConfig = {0};
HI_U32 u32Priority;
VPSS_GRP VpssGrp;
VPSS_CHN VpssChn;
VPSS_GRP_ATTR_S stVpssGrpAttr;
VPSS_CHN_ATTR_S stVpssChnAttr;
VPSS_CHN_MODE_S stVpssChnMode;
VPSS_LOW_DELAY_INFO_S stLowDelayInfo;
VENC_CHN VencChn;
SAMPLE_RC_E enRcMode= SAMPLE_RC_CBR;
HI_S32 s32ChnNum = 2;
HI_S32 s32Ret = HI_SUCCESS;
HI_U32 u32BlkSize;
SIZE_S stSize;
char c;
/******************************************
step 1: init sys variable
******************************************/
memset(&stVbConf,0,sizeof(VB_CONF_S));
stVbConf.u32MaxPoolCnt = 128;
SAMPLE_COMM_VI_GetSizeBySensor(&enSize[0]);
/*video buffer*/
u32BlkSize = SAMPLE_COMM_SYS_CalcPicVbBlkSize(gs_enNorm,\
enSize[0], SAMPLE_PIXEL_FORMAT, SAMPLE_SYS_ALIGN_WIDTH);
printf("u32BlkSize: %d\n", u32BlkSize);
stVbConf.astCommPool[0].u32BlkSize = u32BlkSize;
stVbConf.astCommPool[0].u32BlkCnt = 10;
u32BlkSize = SAMPLE_COMM_SYS_CalcPicVbBlkSize(gs_enNorm,\
enSize[1], SAMPLE_PIXEL_FORMAT, SAMPLE_SYS_ALIGN_WIDTH);
stVbConf.astCommPool[1].u32BlkSize = u32BlkSize;
stVbConf.astCommPool[1].u32BlkCnt = 6;
/******************************************
step 2: mpp system init.
******************************************/
s32Ret = SAMPLE_COMM_SYS_Init(&stVbConf);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("system init failed with %d!\n", s32Ret);
goto END_VENC_LOW_DELAY_0;
}
/******************************************
step 3: start vi dev & chn to capture
******************************************/
stViConfig.enViMode = SENSOR_TYPE;
stViConfig.enRotate = ROTATE_NONE;
stViConfig.enNorm = VIDEO_ENCODING_MODE_AUTO;
stViConfig.enViChnSet = VI_CHN_SET_NORMAL;
s32Ret = SAMPLE_COMM_VI_StartVi(&stViConfig);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("start vi failed!\n");
goto END_VENC_LOW_DELAY_1;
}
/******************************************
step 4: start vpss and vi bind vpss
******************************************/
s32Ret = SAMPLE_COMM_SYS_GetPicSize(gs_enNorm, enSize[0], &stSize);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("SAMPLE_COMM_SYS_GetPicSize failed!\n");
goto END_VENC_LOW_DELAY_1;
}
VpssGrp = 0;
stVpssGrpAttr.u32MaxW = stSize.u32Width;
stVpssGrpAttr.u32MaxH = stSize.u32Height;
stVpssGrpAttr.bIeEn = HI_FALSE;
stVpssGrpAttr.bNrEn = HI_TRUE;
stVpssGrpAttr.bHistEn = HI_FALSE;
stVpssGrpAttr.bDciEn = HI_FALSE;
stVpssGrpAttr.enDieMode = VPSS_DIE_MODE_NODIE;
stVpssGrpAttr.enPixFmt = SAMPLE_PIXEL_FORMAT;
s32Ret = SAMPLE_COMM_VPSS_StartGroup(VpssGrp, &stVpssGrpAttr);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Start Vpss failed!\n");
goto END_VENC_LOW_DELAY_2;
}
s32Ret = SAMPLE_COMM_VI_BindVpss(stViConfig.enViMode);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Vi bind Vpss failed!\n");
goto END_VENC_LOW_DELAY_3;
}
VpssChn = 0;
stVpssChnMode.enChnMode = VPSS_CHN_MODE_USER;
stVpssChnMode.bDouble = HI_FALSE;
stVpssChnMode.enPixelFormat = SAMPLE_PIXEL_FORMAT;
stVpssChnMode.u32Width = stSize.u32Width;
stVpssChnMode.u32Height = stSize.u32Height;
stVpssChnMode.enCompressMode = COMPRESS_MODE_NONE;
memset(&stVpssChnAttr, 0, sizeof(stVpssChnAttr));
stVpssChnAttr.s32SrcFrameRate = -1;
stVpssChnAttr.s32DstFrameRate = -1;
s32Ret = SAMPLE_COMM_VPSS_EnableChn(VpssGrp, VpssChn, &stVpssChnAttr, &stVpssChnMode, HI_NULL);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Enable vpss chn failed!\n");
goto END_VENC_LOW_DELAY_4;
}
VpssChn = 1;
stVpssChnMode.enChnMode = VPSS_CHN_MODE_USER;
stVpssChnMode.bDouble = HI_FALSE;
stVpssChnMode.enPixelFormat = SAMPLE_PIXEL_FORMAT;
stVpssChnMode.u32Width = stSize.u32Width;
stVpssChnMode.u32Height = stSize.u32Height;
stVpssChnMode.enCompressMode = COMPRESS_MODE_NONE;
stVpssChnAttr.s32SrcFrameRate = -1;
stVpssChnAttr.s32DstFrameRate = -1;
s32Ret = SAMPLE_COMM_VPSS_EnableChn(VpssGrp, VpssChn, &stVpssChnAttr, &stVpssChnMode, HI_NULL);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Enable vpss chn failed!\n");
goto END_VENC_LOW_DELAY_4;
}
/******************************************
step 5: start stream venc
******************************************/
/*** HD1080P **/
printf("\t c) cbr.\n");
printf("\t v) vbr.\n");
printf("\t f) fixQp\n");
printf("please input choose rc mode!\n");
c = getchar();
switch(c)
{
case 'c':
enRcMode = SAMPLE_RC_CBR;
break;
case 'v':
enRcMode = SAMPLE_RC_VBR;
break;
case 'f':
enRcMode = SAMPLE_RC_FIXQP;
break;
default:
printf("rc mode! is invaild!\n");
goto END_VENC_LOW_DELAY_4;
}
VpssGrp = 0;
VpssChn = 0;
VencChn = 0;
s32Ret = SAMPLE_COMM_VENC_Start(VencChn, enPayLoad[0],\
gs_enNorm, enSize[0], enRcMode,u32Profile);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Start Venc failed!\n");
goto END_VENC_LOW_DELAY_5;
}
s32Ret = SAMPLE_COMM_VENC_BindVpss(VencChn, VpssGrp, VpssChn);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Start Venc failed!\n");
goto END_VENC_LOW_DELAY_5;
}
/*set chnl Priority*/
s32Ret = HI_MPI_VENC_GetChnlPriority(VencChn,&u32Priority);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Get Chnl Priority failed!\n");
goto END_VENC_LOW_DELAY_5;
}
u32Priority = 1;
s32Ret = HI_MPI_VENC_SetChnlPriority(VencChn,u32Priority);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Set Chnl Priority failed!\n");
goto END_VENC_LOW_DELAY_5;
}
/*set low delay*/
#if 1
s32Ret = HI_MPI_VPSS_GetLowDelayAttr(VpssGrp,VpssChn,&stLowDelayInfo);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VPSS_GetLowDelayAttr failed!\n");
goto END_VENC_LOW_DELAY_5;
}
stLowDelayInfo.bEnable = HI_TRUE;
stLowDelayInfo.u32LineCnt = stVpssChnMode.u32Height/2;
s32Ret = HI_MPI_VPSS_SetLowDelayAttr(VpssGrp,VpssChn,&stLowDelayInfo);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VPSS_SetLowDelayAttr failed!\n");
goto END_VENC_LOW_DELAY_5;
}
#endif
/*** 1080p **/
VpssChn = 1;
VencChn = 1;
s32Ret = SAMPLE_COMM_VENC_Start(VencChn, enPayLoad[1], \
gs_enNorm, enSize[1], enRcMode,u32Profile);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Start Venc failed!\n");
goto END_VENC_LOW_DELAY_5;
}
s32Ret = SAMPLE_COMM_VENC_BindVpss(VencChn, VpssGrp, VpssChn);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Start Venc failed!\n");
goto END_VENC_LOW_DELAY_5;
}
/******************************************
step 6: stream venc process -- get stream, then save it to file.
******************************************/
s32Ret = SAMPLE_COMM_VENC_StartGetStream(s32ChnNum);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Start Venc failed!\n");
goto END_VENC_LOW_DELAY_5;
}
printf("please press twice ENTER to exit this sample\n");
getchar();
getchar();
/******************************************
step 7: exit process
******************************************/
SAMPLE_COMM_VENC_StopGetStream();
END_VENC_LOW_DELAY_5:
VpssGrp = 0;
VpssChn = 0;
VencChn = 0;
SAMPLE_COMM_VENC_UnBindVpss(VencChn, VpssGrp, VpssChn);
SAMPLE_COMM_VENC_Stop(VencChn);
VpssChn = 1;
VencChn = 1;
SAMPLE_COMM_VENC_UnBindVpss(VencChn, VpssGrp, VpssChn);
SAMPLE_COMM_VENC_Stop(VencChn);
SAMPLE_COMM_VI_UnBindVpss(stViConfig.enViMode);
END_VENC_LOW_DELAY_4: //vpss stop
VpssGrp = 0;
VpssChn = 0;
SAMPLE_COMM_VPSS_DisableChn(VpssGrp, VpssChn);
VpssChn = 1;
SAMPLE_COMM_VPSS_DisableChn(VpssGrp, VpssChn);
END_VENC_LOW_DELAY_3: //vpss stop
SAMPLE_COMM_VI_UnBindVpss(stViConfig.enViMode);
END_VENC_LOW_DELAY_2: //vpss stop
SAMPLE_COMM_VPSS_StopGroup(VpssGrp);
END_VENC_LOW_DELAY_1: //vi stop
SAMPLE_COMM_VI_StopVi(&stViConfig);
END_VENC_LOW_DELAY_0: //system exit
SAMPLE_COMM_SYS_Exit();
return s32Ret;
}
HI_S32 SAMPLE_VENC_ROIBG_CLASSIC(HI_VOID)
{
PAYLOAD_TYPE_E enPayLoad= PT_H264;
PIC_SIZE_E enSize[3] = {PIC_HD1080,PIC_HD720,PIC_D1};
HI_U32 u32Profile = 0;
VB_CONF_S stVbConf;
SAMPLE_VI_CONFIG_S stViConfig = {0};
VPSS_GRP VpssGrp;
VPSS_CHN VpssChn;
VPSS_GRP_ATTR_S stVpssGrpAttr;
VPSS_CHN_ATTR_S stVpssChnAttr;
VPSS_CHN_MODE_S stVpssChnMode;
VENC_ROI_CFG_S stVencRoiCfg;
VENC_ROIBG_FRAME_RATE_S stRoiBgFrameRate;
VENC_CHN VencChn;
SAMPLE_RC_E enRcMode= SAMPLE_RC_CBR;
HI_S32 s32ChnNum = 1;
HI_S32 s32Ret = HI_SUCCESS;
HI_U32 u32BlkSize;
SIZE_S stSize;
char c;
/******************************************
step 1: init sys variable
******************************************/
memset(&stVbConf,0,sizeof(VB_CONF_S));
SAMPLE_COMM_VI_GetSizeBySensor(&enSize[0]);
stVbConf.u32MaxPoolCnt = 128;
/*video buffer*/
u32BlkSize = SAMPLE_COMM_SYS_CalcPicVbBlkSize(gs_enNorm,\
enSize[0], SAMPLE_PIXEL_FORMAT, SAMPLE_SYS_ALIGN_WIDTH);
stVbConf.astCommPool[0].u32BlkSize = u32BlkSize;
stVbConf.astCommPool[0].u32BlkCnt = 10;
u32BlkSize = SAMPLE_COMM_SYS_CalcPicVbBlkSize(gs_enNorm,\
enSize[1], SAMPLE_PIXEL_FORMAT, SAMPLE_SYS_ALIGN_WIDTH);
stVbConf.astCommPool[1].u32BlkSize = u32BlkSize;
stVbConf.astCommPool[1].u32BlkCnt = 6;
u32BlkSize = SAMPLE_COMM_SYS_CalcPicVbBlkSize(gs_enNorm,\
enSize[2], SAMPLE_PIXEL_FORMAT, SAMPLE_SYS_ALIGN_WIDTH);
stVbConf.astCommPool[2].u32BlkSize = u32BlkSize;
stVbConf.astCommPool[2].u32BlkCnt = 6;
/******************************************
step 2: mpp system init.
******************************************/
s32Ret = SAMPLE_COMM_SYS_Init(&stVbConf);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("system init failed with %d!\n", s32Ret);
goto END_VENC_1080P_CLASSIC_0;
}
/******************************************
step 3: start vi dev & chn to capture
******************************************/
stViConfig.enViMode = SENSOR_TYPE;
stViConfig.enRotate = ROTATE_NONE;
stViConfig.enNorm = VIDEO_ENCODING_MODE_AUTO;
stViConfig.enViChnSet = VI_CHN_SET_NORMAL;
s32Ret = SAMPLE_COMM_VI_StartVi(&stViConfig);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("start vi failed!\n");
goto END_VENC_1080P_CLASSIC_1;
}
/******************************************
step 4: start vpss and vi bind vpss
******************************************/
s32Ret = SAMPLE_COMM_SYS_GetPicSize(gs_enNorm, enSize[0], &stSize);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("SAMPLE_COMM_SYS_GetPicSize failed!\n");
goto END_VENC_1080P_CLASSIC_1;
}
VpssGrp = 0;
stVpssGrpAttr.u32MaxW = stSize.u32Width;
stVpssGrpAttr.u32MaxH = stSize.u32Height;
stVpssGrpAttr.bIeEn = HI_FALSE;
stVpssGrpAttr.bNrEn = HI_TRUE;
stVpssGrpAttr.bHistEn = HI_FALSE;
stVpssGrpAttr.bDciEn = HI_FALSE;
stVpssGrpAttr.enDieMode = VPSS_DIE_MODE_NODIE;
stVpssGrpAttr.enPixFmt = SAMPLE_PIXEL_FORMAT;
s32Ret = SAMPLE_COMM_VPSS_StartGroup(VpssGrp, &stVpssGrpAttr);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Start Vpss failed!\n");
goto END_VENC_1080P_CLASSIC_2;
}
s32Ret = SAMPLE_COMM_VI_BindVpss(stViConfig.enViMode);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Vi bind Vpss failed!\n");
goto END_VENC_1080P_CLASSIC_3;
}
VpssChn = 0;
stVpssChnMode.enChnMode = VPSS_CHN_MODE_USER;
stVpssChnMode.bDouble = HI_FALSE;
stVpssChnMode.enPixelFormat = SAMPLE_PIXEL_FORMAT;
stVpssChnMode.u32Width = stSize.u32Width;
stVpssChnMode.u32Height = stSize.u32Height;
stVpssChnMode.enCompressMode = COMPRESS_MODE_NONE;
memset(&stVpssChnAttr, 0, sizeof(stVpssChnAttr));
stVpssChnAttr.s32SrcFrameRate = -1;
stVpssChnAttr.s32DstFrameRate = -1;
s32Ret = SAMPLE_COMM_VPSS_EnableChn(VpssGrp, VpssChn, &stVpssChnAttr, &stVpssChnMode, HI_NULL);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Enable vpss chn failed!\n");
goto END_VENC_1080P_CLASSIC_4;
}
/******************************************
step 5: start stream venc
******************************************/
/*** HD1080P **/
printf("\t c) cbr.\n");
printf("\t v) vbr.\n");
printf("\t f) fixQp\n");
printf("please input choose rc mode!\n");
c = getchar();
switch(c)
{
case 'c':
enRcMode = SAMPLE_RC_CBR;
break;
case 'v':
enRcMode = SAMPLE_RC_VBR;
break;
case 'f':
enRcMode = SAMPLE_RC_FIXQP;
break;
default:
printf("rc mode! is invaild!\n");
goto END_VENC_1080P_CLASSIC_4;
}
VpssGrp = 0;
VpssChn = 0;
VencChn = 0;
s32Ret = SAMPLE_COMM_VENC_Start(VencChn, enPayLoad,\
gs_enNorm, enSize[0], enRcMode,u32Profile);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Start Venc failed!\n");
goto END_VENC_1080P_CLASSIC_5;
}
s32Ret = SAMPLE_COMM_VENC_BindVpss(VencChn, VpssGrp, VpssChn);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Start Venc failed!\n");
goto END_VENC_1080P_CLASSIC_5;
}
stVencRoiCfg.bAbsQp = HI_TRUE;
stVencRoiCfg.bEnable = HI_TRUE;
stVencRoiCfg.s32Qp = 30;
stVencRoiCfg.u32Index = 0;
stVencRoiCfg.stRect.s32X = 64;
stVencRoiCfg.stRect.s32Y = 64;
stVencRoiCfg.stRect.u32Height =256;
stVencRoiCfg.stRect.u32Width =256;
s32Ret = HI_MPI_VENC_SetRoiCfg(VencChn,&stVencRoiCfg);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Start Venc failed!\n");
goto END_VENC_1080P_CLASSIC_5;
}
s32Ret = HI_MPI_VENC_GetRoiBgFrameRate(VencChn,&stRoiBgFrameRate);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VENC_GetRoiBgFrameRate failed!\n");
goto END_VENC_1080P_CLASSIC_5;
}
stRoiBgFrameRate.s32SrcFrmRate = (VIDEO_ENCODING_MODE_PAL== gs_enNorm)?25:30;
stRoiBgFrameRate.s32DstFrmRate = (VIDEO_ENCODING_MODE_PAL== gs_enNorm)?5:15;
s32Ret = HI_MPI_VENC_SetRoiBgFrameRate(VencChn,&stRoiBgFrameRate);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VENC_SetRoiBgFrameRate!\n");
goto END_VENC_1080P_CLASSIC_5;
}
/******************************************
step 6: stream venc process -- get stream, then save it to file.
******************************************/
s32Ret = SAMPLE_COMM_VENC_StartGetStream(s32ChnNum);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Start Venc failed!\n");
goto END_VENC_1080P_CLASSIC_5;
}
printf("please press ENTER to exit this sample\n");
getchar();
getchar();
/******************************************
step 7: exit process
******************************************/
SAMPLE_COMM_VENC_StopGetStream();
END_VENC_1080P_CLASSIC_5:
VpssGrp = 0;
VpssChn = 0;
VencChn = 0;
SAMPLE_COMM_VENC_UnBindVpss(VencChn, VpssGrp, VpssChn);
SAMPLE_COMM_VENC_Stop(VencChn);
SAMPLE_COMM_VI_UnBindVpss(stViConfig.enViMode);
END_VENC_1080P_CLASSIC_4: //vpss stop
VpssGrp = 0;
VpssChn = 0;
SAMPLE_COMM_VPSS_DisableChn(VpssGrp, VpssChn);
END_VENC_1080P_CLASSIC_3: //vpss stop
SAMPLE_COMM_VI_UnBindVpss(stViConfig.enViMode);
END_VENC_1080P_CLASSIC_2: //vpss stop
SAMPLE_COMM_VPSS_StopGroup(VpssGrp);
END_VENC_1080P_CLASSIC_1: //vi stop
SAMPLE_COMM_VI_StopVi(&stViConfig);
END_VENC_1080P_CLASSIC_0: //system exit
SAMPLE_COMM_SYS_Exit();
return s32Ret;
}
HI_S32 SAMPLE_VENC_SVC_H264(HI_VOID)
{
PAYLOAD_TYPE_E enPayLoad= PT_H264;
PIC_SIZE_E enSize[3] = {PIC_HD1080,PIC_HD720,PIC_D1};
HI_U32 u32Profile = 3;/* Svc-t */
VB_CONF_S stVbConf;
SAMPLE_VI_CONFIG_S stViConfig = {0};
VPSS_GRP VpssGrp;
VPSS_CHN VpssChn;
VPSS_GRP_ATTR_S stVpssGrpAttr;
VPSS_CHN_ATTR_S stVpssChnAttr;
VPSS_CHN_MODE_S stVpssChnMode;
VENC_CHN VencChn;
SAMPLE_RC_E enRcMode= SAMPLE_RC_CBR;
HI_S32 s32ChnNum = 1;
HI_S32 s32Ret = HI_SUCCESS;
HI_U32 u32BlkSize;
SIZE_S stSize;
char c;
/******************************************
step 1: init sys variable
******************************************/
memset(&stVbConf, 0, sizeof(VB_CONF_S));
SAMPLE_COMM_VI_GetSizeBySensor(&enSize[0]);
stVbConf.u32MaxPoolCnt = 128;
/*video buffer*/
u32BlkSize = SAMPLE_COMM_SYS_CalcPicVbBlkSize(gs_enNorm,\
enSize[0], SAMPLE_PIXEL_FORMAT, SAMPLE_SYS_ALIGN_WIDTH);
stVbConf.astCommPool[0].u32BlkSize = u32BlkSize;
stVbConf.astCommPool[0].u32BlkCnt = 10;
u32BlkSize = SAMPLE_COMM_SYS_CalcPicVbBlkSize(gs_enNorm,\
enSize[1], SAMPLE_PIXEL_FORMAT, SAMPLE_SYS_ALIGN_WIDTH);
stVbConf.astCommPool[1].u32BlkSize = u32BlkSize;
stVbConf.astCommPool[1].u32BlkCnt = 6;
u32BlkSize = SAMPLE_COMM_SYS_CalcPicVbBlkSize(gs_enNorm,\
enSize[2], SAMPLE_PIXEL_FORMAT, SAMPLE_SYS_ALIGN_WIDTH);
stVbConf.astCommPool[2].u32BlkSize = u32BlkSize;
stVbConf.astCommPool[2].u32BlkCnt = 6;
/******************************************
step 2: mpp system init.
******************************************/
s32Ret = SAMPLE_COMM_SYS_Init(&stVbConf);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("system init failed with %d!\n", s32Ret);
goto END_VENC_1080P_CLASSIC_0;
}
/******************************************
step 3: start vi dev & chn to capture
******************************************/
stViConfig.enViMode = SENSOR_TYPE;
stViConfig.enRotate = ROTATE_NONE;
stViConfig.enNorm = VIDEO_ENCODING_MODE_AUTO;
stViConfig.enViChnSet = VI_CHN_SET_NORMAL;
s32Ret = SAMPLE_COMM_VI_StartVi(&stViConfig);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("start vi failed!\n");
goto END_VENC_1080P_CLASSIC_1;
}
/******************************************
step 4: start vpss and vi bind vpss
******************************************/
s32Ret = SAMPLE_COMM_SYS_GetPicSize(gs_enNorm, enSize[0], &stSize);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("SAMPLE_COMM_SYS_GetPicSize failed!\n");
goto END_VENC_1080P_CLASSIC_1;
}
VpssGrp = 0;
stVpssGrpAttr.u32MaxW = stSize.u32Width;
stVpssGrpAttr.u32MaxH = stSize.u32Height;
stVpssGrpAttr.bIeEn = HI_FALSE;
stVpssGrpAttr.bNrEn = HI_TRUE;
stVpssGrpAttr.bHistEn = HI_FALSE;
stVpssGrpAttr.bDciEn = HI_FALSE;
stVpssGrpAttr.enDieMode = VPSS_DIE_MODE_NODIE;
stVpssGrpAttr.enPixFmt = SAMPLE_PIXEL_FORMAT;
s32Ret = SAMPLE_COMM_VPSS_StartGroup(VpssGrp, &stVpssGrpAttr);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Start Vpss failed!\n");
goto END_VENC_1080P_CLASSIC_2;
}
s32Ret = SAMPLE_COMM_VI_BindVpss(stViConfig.enViMode);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Vi bind Vpss failed!\n");
goto END_VENC_1080P_CLASSIC_3;
}
VpssChn = 0;
stVpssChnMode.enChnMode = VPSS_CHN_MODE_USER;
stVpssChnMode.bDouble = HI_FALSE;
stVpssChnMode.enPixelFormat = SAMPLE_PIXEL_FORMAT;
stVpssChnMode.u32Width = stSize.u32Width;
stVpssChnMode.u32Height = stSize.u32Height;
stVpssChnMode.enCompressMode = COMPRESS_MODE_NONE;
memset(&stVpssChnAttr, 0, sizeof(stVpssChnAttr));
stVpssChnAttr.s32SrcFrameRate = -1;
stVpssChnAttr.s32DstFrameRate = -1;
s32Ret = SAMPLE_COMM_VPSS_EnableChn(VpssGrp, VpssChn, &stVpssChnAttr, &stVpssChnMode, HI_NULL);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Enable vpss chn failed!\n");
goto END_VENC_1080P_CLASSIC_4;
}
/******************************************
step 5: start stream venc
******************************************/
/*** HD1080P **/
printf("\t c) cbr.\n");
printf("\t v) vbr.\n");
printf("\t f) fixQp\n");
printf("please input choose rc mode!\n");
c = getchar();
switch(c)
{
case 'c':
enRcMode = SAMPLE_RC_CBR;
break;
case 'v':
enRcMode = SAMPLE_RC_VBR;
break;
case 'f':
enRcMode = SAMPLE_RC_FIXQP;
break;
default:
printf("rc mode! is invaild!\n");
goto END_VENC_1080P_CLASSIC_4;
}
VpssGrp = 0;
VpssChn = 0;
VencChn = 0;
s32Ret = SAMPLE_COMM_VENC_Start(VencChn, enPayLoad,\
gs_enNorm, enSize[0], enRcMode,u32Profile);
printf("SAMPLE_COMM_VENC_Start is ok\n");
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Start Venc failed!\n");
goto END_VENC_1080P_CLASSIC_5;
}
s32Ret = SAMPLE_COMM_VENC_BindVpss(VencChn, VpssGrp, VpssChn);
printf("SAMPLE_COMM_VENC_BindVpss is ok\n");
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Start Venc failed!\n");
goto END_VENC_1080P_CLASSIC_5;
}
/******************************************
step 6: stream venc process -- get stream, then save it to file.
******************************************/
s32Ret = SAMPLE_COMM_VENC_StartGetStream_Svc_t(s32ChnNum);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Start Venc failed!\n");
goto END_VENC_1080P_CLASSIC_5;
}
printf("please press ENTER to exit this sample\n");
getchar();
getchar();
/******************************************
step 7: exit process
******************************************/
SAMPLE_COMM_VENC_StopGetStream();
printf("SAMPLE_COMM_VENC_StopGetStream is ok\n");
END_VENC_1080P_CLASSIC_5:
VpssGrp = 0;
VpssChn = 0;
VencChn = 0;
SAMPLE_COMM_VENC_UnBindVpss(VencChn, VpssGrp, VpssChn);
SAMPLE_COMM_VENC_Stop(VencChn);
SAMPLE_COMM_VI_UnBindVpss(stViConfig.enViMode);
END_VENC_1080P_CLASSIC_4: //vpss stop
VpssGrp = 0;
VpssChn = 0;
SAMPLE_COMM_VPSS_DisableChn(VpssGrp, VpssChn);
END_VENC_1080P_CLASSIC_3: //vpss stop
SAMPLE_COMM_VI_UnBindVpss(stViConfig.enViMode);
END_VENC_1080P_CLASSIC_2: //vpss stop
SAMPLE_COMM_VPSS_StopGroup(VpssGrp);
END_VENC_1080P_CLASSIC_1: //vi stop
SAMPLE_COMM_VI_StopVi(&stViConfig);
END_VENC_1080P_CLASSIC_0: //system exit
SAMPLE_COMM_SYS_Exit();
return s32Ret;
}
#endif
static char const* dateHeader()
{
static char buf[200];
#if !defined(_WIN32_WCE)
time_t tt = time(NULL);
strftime(buf, sizeof buf, "Date: %a, %b %d %Y %H:%M:%S GMT\r\n", gmtime(&tt));
#endif
return buf;
}
static char* GetLocalIP(int sock)
{
struct ifreq ifreq;
struct sockaddr_in *sin;
char * LocalIP = malloc(20);
strcpy(ifreq.ifr_name,"eth0");
if (!(ioctl (sock, SIOCGIFADDR,&ifreq)))
{
sin = (struct sockaddr_in *)&ifreq.ifr_addr;
sin->sin_family = AF_INET;
strcpy(LocalIP,inet_ntoa(sin->sin_addr));
//inet_ntop(AF_INET, &sin->sin_addr,LocalIP, 16);
}
printf("--------------------------------------------%s\n",LocalIP);
return LocalIP;
}
char* strDupSize(char const* str)
{
if (str == NULL) return NULL;
size_t len = strlen(str) + 1;
char* copy = malloc(len);
return copy;
}
int ParseRequestString(char const* reqStr,
unsigned reqStrSize,
char* resultCmdName,
unsigned resultCmdNameMaxSize,
char* resultURLPreSuffix,
unsigned resultURLPreSuffixMaxSize,
char* resultURLSuffix,
unsigned resultURLSuffixMaxSize,
char* resultCSeq,
unsigned resultCSeqMaxSize)
{
// This parser is currently rather dumb; it should be made smarter #####
// Read everything up to the first space as the command name:
int parseSucceeded = FALSE;
unsigned i;
for (i = 0; i < resultCmdNameMaxSize-1 && i < reqStrSize; ++i) {
char c = reqStr[i];
if (c == ' ' || c == '\t') {
parseSucceeded = TRUE;
break;
}
resultCmdName[i] = c;
}
resultCmdName[i] = '\0';
if (!parseSucceeded) return FALSE;
// Skip over the prefix of any "rtsp://" or "rtsp:/" URL that follows:
unsigned j = i+1;
while (j < reqStrSize && (reqStr[j] == ' ' || reqStr[j] == '\t')) ++j; // skip over any additional white space
for (j = i+1; j < reqStrSize-8; ++j) {
if ((reqStr[j] == 'r' || reqStr[j] == 'R')
&& (reqStr[j+1] == 't' || reqStr[j+1] == 'T')
&& (reqStr[j+2] == 's' || reqStr[j+2] == 'S')
&& (reqStr[j+3] == 'p' || reqStr[j+3] == 'P')
&& reqStr[j+4] == ':' && reqStr[j+5] == '/') {
j += 6;
if (reqStr[j] == '/') {
// This is a "rtsp://" URL; skip over the host:port part that follows:
++j;
while (j < reqStrSize && reqStr[j] != '/' && reqStr[j] != ' ') ++j;
} else {
// This is a "rtsp:/" URL; back up to the "/":
--j;
}
i = j;
break;
}
}
// Look for the URL suffix (before the following "RTSP/"):
parseSucceeded = FALSE;
unsigned k;
for (k = i+1; k < reqStrSize-5; ++k) {
if (reqStr[k] == 'R' && reqStr[k+1] == 'T' &&
reqStr[k+2] == 'S' && reqStr[k+3] == 'P' && reqStr[k+4] == '/') {
while (--k >= i && reqStr[k] == ' ') {} // go back over all spaces before "RTSP/"
unsigned k1 = k;
while (k1 > i && reqStr[k1] != '/' && reqStr[k1] != ' ') --k1;
// the URL suffix comes from [k1+1,k]
// Copy "resultURLSuffix":
if (k - k1 + 1 > resultURLSuffixMaxSize) return FALSE; // there's no room
unsigned n = 0, k2 = k1+1;
while (k2 <= k) resultURLSuffix[n++] = reqStr[k2++];
resultURLSuffix[n] = '\0';
// Also look for the URL 'pre-suffix' before this:
unsigned k3 = --k1;
while (k3 > i && reqStr[k3] != '/' && reqStr[k3] != ' ') --k3;
// the URL pre-suffix comes from [k3+1,k1]
// Copy "resultURLPreSuffix":
if (k1 - k3 + 1 > resultURLPreSuffixMaxSize) return FALSE; // there's no room
n = 0; k2 = k3+1;
while (k2 <= k1) resultURLPreSuffix[n++] = reqStr[k2++];
resultURLPreSuffix[n] = '\0';
i = k + 7; // to go past " RTSP/"
parseSucceeded = TRUE;
break;
}
}
if (!parseSucceeded) return FALSE;
// Look for "CSeq:", skip whitespace,
// then read everything up to the next \r or \n as 'CSeq':
parseSucceeded = FALSE;
for (j = i; j < reqStrSize-5; ++j) {
if (reqStr[j] == 'C' && reqStr[j+1] == 'S' && reqStr[j+2] == 'e' &&
reqStr[j+3] == 'q' && reqStr[j+4] == ':') {
j += 5;
unsigned n;
while (j < reqStrSize && (reqStr[j] == ' ' || reqStr[j] == '\t')) ++j;
for (n = 0; n < resultCSeqMaxSize-1 && j < reqStrSize; ++n,++j) {
char c = reqStr[j];
if (c == '\r' || c == '\n') {
parseSucceeded = TRUE;
break;
}
resultCSeq[n] = c;
}
resultCSeq[n] = '\0';
break;
}
}
if (!parseSucceeded) return FALSE;
return TRUE;
}
int OptionAnswer(char *cseq, int sock)
{
if (sock != 0)
{
char buf[1024];
memset(buf,0,1024);
char *pTemp = buf;
pTemp += sprintf(pTemp,"RTSP/1.0 200 OK\r\nCSeq: %s\r\n%sPublic: %s\r\n\r\n",
cseq,dateHeader(),"OPTIONS,DESCRIBE,SETUP,PLAY,PAUSE,TEARDOWN");
int reg = send(sock, buf,strlen(buf),0);
if(reg <= 0)
{
return FALSE;
}
else
{
printf(">>>>>%s\n",buf);
}
return TRUE;
}
return FALSE;
}
int DescribeAnswer(char *cseq,int sock,char * urlSuffix,char* recvbuf)
{
if (sock != 0)
{
char sdpMsg[1024];
char buf[2048];
memset(buf,0,2048);
memset(sdpMsg,0,1024);
char*localip;
localip = GetLocalIP(sock);
char *pTemp = buf;
pTemp += sprintf(pTemp,"RTSP/1.0 200 OK\r\nCSeq: %s\r\n",cseq);
pTemp += sprintf(pTemp,"%s",dateHeader());
pTemp += sprintf(pTemp,"Content-Type: application/sdp\r\n");
//TODO 掳?貌?D?1矛???渭???a?藟矛??渭
char *pTemp2 = sdpMsg;
pTemp2 += sprintf(pTemp2,"v=0\r\n");
pTemp2 += sprintf(pTemp2,"o=StreamingServer 3331435948 1116907222000 IN IP4 %s\r\n",localip);
pTemp2 += sprintf(pTemp2,"s=H.265\r\n");
pTemp2 += sprintf(pTemp2,"c=IN IP4 0.0.0.0\r\n");
pTemp2 += sprintf(pTemp2,"t=0 0\r\n");
pTemp2 += sprintf(pTemp2,"a=control:*\r\n");
/*锚贸?渭??矛??猫锚?*/
/*H264 TrackID=0 RTP_PT 96*/
pTemp2 += sprintf(pTemp2,"m=video 0 RTP/AVP 96\r\n");
pTemp2 += sprintf(pTemp2,"a=control:track1\r\n");
pTemp2 += sprintf(pTemp2,"a=rtpmap:96 H265/90000\r\n");
//pTemp2 += sprintf(pTemp2,"a=fmtp:96 packetization-mode=1; sprop-parameter-sets=%s\r\n", "AAABBCCC");
pTemp2 += sprintf(pTemp2,"a=fmtp:96 profile-space=0;profile-id=1;tier-flag=0;level-id=123;interop-constraints=B00000000000;");
pTemp2 += sprintf(pTemp2,"sprop-vps=QAEMAf//AWAAAAMAsAAAAwAAAwB7qgJA;sprop-sps=QgEBAWAAAAMAsAAAAwAAAwB7oAPAgBDljaqSTL5A;sprop-pps=RAHA8vA8kA==\r\n");
#if 1
/*貌??渭??矛??猫锚?*/
/*G726*/
/*TODO 貌??渭*/
pTemp2 += sprintf(pTemp2,"m=audio 0 RTP/AVP 97\r\n");
pTemp2 += sprintf(pTemp2,"a=control:trackID=1\r\n");
if(strcmp(g_rtp_playload,"AAC")==0)
{
pTemp2 += sprintf(pTemp2,"a=rtpmap:97 MPEG4-GENERIC/%d/2\r\n",16000);
pTemp2 += sprintf(pTemp2,"a=fmtp:97 streamtype=5;profile-level-id=1;mode=AAC-hbr;sizelength=13;indexlength=3;indexdeltalength=3;config=1410\r\n");
}
else
{
pTemp2 += sprintf(pTemp2,"a=rtpmap:97 G726-32/%d/1\r\n",8000);
pTemp2 += sprintf(pTemp2,"a=fmtp:97 packetization-mode=1\r\n");
}
#endif
pTemp += sprintf(pTemp,"Content-length: %d\r\n", strlen(sdpMsg));
pTemp += sprintf(pTemp,"Content-Base: rtsp://%s/%s/\r\n\r\n",localip,urlSuffix);
//printf("mem ready\n");
strcat(pTemp, sdpMsg);
free(localip);
//printf("Describe ready sent\n");
int re = send(sock, buf, strlen(buf),0);
if(re <= 0)
{
return FALSE;
}
else
{
printf(">>>>>%s\n",buf);
}
}
return TRUE;
}
void ParseTransportHeader(char const* buf,
StreamingMode* streamingMode,
char**streamingModeString,
char**destinationAddressStr,
u_int8_t* destinationTTL,
portNumBits* clientRTPPortNum, // if UDP
portNumBits* clientRTCPPortNum, // if UDP
unsigned char* rtpChannelId, // if TCP
unsigned char* rtcpChannelId // if TCP
)
{
// Initialize the result parameters to default values:
*streamingMode = RTP_UDP;
*streamingModeString = NULL;
*destinationAddressStr = NULL;
*destinationTTL = 255;
*clientRTPPortNum = 0;
*clientRTCPPortNum = 1;
*rtpChannelId = *rtcpChannelId = 0xFF;
portNumBits p1, p2;
unsigned ttl, rtpCid, rtcpCid;
// First, find "Transport:"
while (1) {
if (*buf == '\0') return; // not found
if (strncasecmp(buf, "Transport: ", 11) == 0) break;
++buf;
}
// Then, run through each of the fields, looking for ones we handle:
char const* fields = buf + 11;
char* field = strDupSize(fields);
while (sscanf(fields, "%[^;]", field) == 1) {
if (strcmp(field, "RTP/AVP/TCP") == 0) {
*streamingMode = RTP_TCP;
} else if (strcmp(field, "RAW/RAW/UDP") == 0 ||
strcmp(field, "MP2T/H2221/UDP") == 0) {
*streamingMode = RAW_UDP;
//*streamingModeString = strDup(field);
} else if (strncasecmp(field, "destination=", 12) == 0)
{
//delete[] destinationAddressStr;
free(destinationAddressStr);
//destinationAddressStr = strDup(field+12);
} else if (sscanf(field, "ttl%u", &ttl) == 1) {
destinationTTL = (u_int8_t)ttl;
} else if (sscanf(field, "client_port=%hu-%hu", &p1, &p2) == 2) {
*clientRTPPortNum = p1;
*clientRTCPPortNum = p2;
} else if (sscanf(field, "client_port=%hu", &p1) == 1) {
*clientRTPPortNum = p1;
*clientRTCPPortNum = streamingMode == RAW_UDP ? 0 : p1 + 1;
} else if (sscanf(field, "interleaved=%u-%u", &rtpCid, &rtcpCid) == 2) {
*rtpChannelId = (unsigned char)rtpCid;
*rtcpChannelId = (unsigned char)rtcpCid;
}
fields += strlen(field);
while (*fields == ';') ++fields; // skip over separating ';' chars
if (*fields == '\0' || *fields == '\r' || *fields == '\n') break;
}
free(field);
}
int SetupAnswer(char *cseq,int sock,int SessionId,char * urlSuffix,char* recvbuf,int* rtpport, int* rtcpport)
{
if (sock != 0)
{
char buf[1024];
memset(buf,0,1024);
StreamingMode streamingMode;
char* streamingModeString; // set when RAW_UDP streaming is specified
char* clientsDestinationAddressStr;
u_int8_t clientsDestinationTTL;
portNumBits clientRTPPortNum, clientRTCPPortNum;
unsigned char rtpChannelId, rtcpChannelId;
ParseTransportHeader(recvbuf,&streamingMode, &streamingModeString,
&clientsDestinationAddressStr, &clientsDestinationTTL,
&clientRTPPortNum, &clientRTCPPortNum,
&rtpChannelId, &rtcpChannelId);
//Port clientRTPPort(clientRTPPortNum);
//Port clientRTCPPort(clientRTCPPortNum);
*rtpport = clientRTPPortNum;
*rtcpport = clientRTCPPortNum;
char *pTemp = buf;
char*localip;
localip = GetLocalIP(sock);
pTemp += sprintf(pTemp,"RTSP/1.0 200 OK\r\nCSeq: %s\r\n%sTransport: RTP/AVP;unicast;destination=%s;client_port=%d-%d;server_port=%d-%d\r\nSession: %d\r\n\r\n",
cseq,dateHeader(),localip,
ntohs(htons(clientRTPPortNum)),
ntohs(htons(clientRTCPPortNum)),
ntohs(2000),
ntohs(2001),
SessionId);
free(localip);
int reg = send(sock, buf,strlen(buf),0);
if(reg <= 0)
{
return FALSE;
}
else
{
printf(">>>>>%s",buf);
}
return TRUE;
}
return FALSE;
}
int PlayAnswer(char *cseq, int sock,int SessionId,char* urlPre,char* recvbuf)
{
if (sock != 0)
{
char buf[1024];
memset(buf,0,1024);
char *pTemp = buf;
char*localip;
localip = GetLocalIP(sock);
pTemp += sprintf(pTemp,"RTSP/1.0 200 OK\r\nCSeq: %s\r\n%sRange: npt=0.000-\r\nSession: %d\r\nRTP-Info: url=rtsp://%s/%s;seq=0\r\n\r\n",
cseq,dateHeader(),SessionId,localip,urlPre);
free(localip);
int reg = send(sock, buf,strlen(buf),0);
if(reg <= 0)
{
return FALSE;
}
else
{
printf(">>>>>%s",buf);
}
return TRUE;
}
return FALSE;
}
int PauseAnswer(char *cseq,int sock,char *recvbuf)
{
if (sock != 0)
{
char buf[1024];
memset(buf,0,1024);
char *pTemp = buf;
pTemp += sprintf(pTemp,"RTSP/1.0 200 OK\r\nCSeq: %s\r\n%s\r\n\r\n",
cseq,dateHeader());
int reg = send(sock, buf,strlen(buf),0);
if(reg <= 0)
{
return FALSE;
}
else
{
printf(">>>>>%s",buf);
}
return TRUE;
}
return FALSE;
}
int TeardownAnswer(char *cseq,int sock,int SessionId,char *recvbuf)
{
if (sock != 0)
{
char buf[1024];
memset(buf,0,1024);
char *pTemp = buf;
pTemp += sprintf(pTemp,"RTSP/1.0 200 OK\r\nCSeq: %s\r\n%sSession: %d\r\n\r\n",
cseq,dateHeader(),SessionId);
int reg = send(sock, buf,strlen(buf),0);
if(reg <= 0)
{
return FALSE;
}
else
{
printf(">>>>>%s",buf);
}
return TRUE;
}
return FALSE;
}
void * RtspClientMsg(void*pParam)
{
pthread_detach(pthread_self());
int nRes;
char pRecvBuf[RTSP_RECV_SIZE];
RTSP_CLIENT * pClient = (RTSP_CLIENT*)pParam;
memset(pRecvBuf,0,sizeof(pRecvBuf));
printf("RTSP:-----Create Client %s\n",pClient->IP);
while(pClient->status != RTSP_IDLE)
{
nRes = recv(pClient->socket, pRecvBuf, RTSP_RECV_SIZE,0);
//printf("-------------------%d\n",nRes);
if(nRes < 1)
{
//usleep(1000);
printf("RTSP:Recv Error--- %d\n",nRes);
g_rtspClients[pClient->index].status = RTSP_IDLE;
g_rtspClients[pClient->index].seqnum = 0;
g_rtspClients[pClient->index].tsvid = 0;
g_rtspClients[pClient->index].tsaud = 0;
close(pClient->socket);
break;
}
char cmdName[PARAM_STRING_MAX];
char urlPreSuffix[PARAM_STRING_MAX];
char urlSuffix[PARAM_STRING_MAX];
char cseq[PARAM_STRING_MAX];
ParseRequestString(pRecvBuf,nRes,cmdName,sizeof(cmdName),urlPreSuffix,sizeof(urlPreSuffix),
urlSuffix,sizeof(urlSuffix),cseq,sizeof(cseq));
char *p = pRecvBuf;
printf("<<<<<%s\n",p);
//printf("\--------------------------\n");
//printf("%s %s\n",urlPreSuffix,urlSuffix);
if(strstr(cmdName, "OPTIONS"))
{
OptionAnswer(cseq,pClient->socket);
}
else if(strstr(cmdName, "DESCRIBE"))
{
DescribeAnswer(cseq,pClient->socket,urlSuffix,p);
//printf("-----------------------------DescribeAnswer %s %s\n",
// urlPreSuffix,urlSuffix);
}
else if(strstr(cmdName, "SETUP"))
{
int rtpport,rtcpport;
int trackID=0;
SetupAnswer(cseq,pClient->socket,pClient->sessionid,urlPreSuffix,p,&rtpport,&rtcpport);
sscanf(urlSuffix, "trackID=%u", &trackID);
//printf("----------------------------------------------TrackId %d\n",trackID);
if(trackID<0 || trackID>=2)trackID=0;
g_rtspClients[pClient->index].rtpport[trackID] = rtpport;
g_rtspClients[pClient->index].rtcpport= rtcpport;
g_rtspClients[pClient->index].reqchn = atoi(urlPreSuffix);
if(strlen(urlPreSuffix)<100)
strcpy(g_rtspClients[pClient->index].urlPre,urlPreSuffix);
//printf("-----------------------------SetupAnswer %s-%d-%d\n",
// urlPreSuffix,g_rtspClients[pClient->index].reqchn,rtpport);
}
else if(strstr(cmdName, "PLAY"))
{
PlayAnswer(cseq,pClient->socket,pClient->sessionid,g_rtspClients[pClient->index].urlPre,p);
g_rtspClients[pClient->index].status = RTSP_SENDING;
printf("Start Play\n",pClient->index);
//printf("-----------------------------PlayAnswer %d %d\n",pClient->index);
//usleep(100);
}
else if(strstr(cmdName, "PAUSE"))
{
PauseAnswer(cseq,pClient->socket,p);
}
else if(strstr(cmdName, "TEARDOWN"))
{
TeardownAnswer(cseq,pClient->socket,pClient->sessionid,p);
g_rtspClients[pClient->index].status = RTSP_IDLE;
g_rtspClients[pClient->index].seqnum = 0;
g_rtspClients[pClient->index].tsvid = 0;
g_rtspClients[pClient->index].tsaud = 0;
close(pClient->socket);
}
if(exitok){ exitok++;return NULL; }
}
printf("RTSP:-----Exit Client %s\n",pClient->IP);
return NULL;
}
void * RtspServerListen(void*pParam)
{
int s32Socket;
struct sockaddr_in servaddr;
int s32CSocket;
int s32Rtn;
int s32Socket_opt_value = 1;
int nAddrLen;
struct sockaddr_in addrAccept;
int bResult;
memset(&servaddr, 0, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(RTSP_SERVER_PORT);
s32Socket = socket(AF_INET, SOCK_STREAM, 0);
if (setsockopt(s32Socket ,SOL_SOCKET,SO_REUSEADDR,&s32Socket_opt_value,sizeof(int)) == -1)
{
return (void *)(-1);
}
s32Rtn = bind(s32Socket, (struct sockaddr *)&servaddr, sizeof(struct sockaddr_in));
if(s32Rtn < 0)
{
return (void *)(-2);
}
s32Rtn = listen(s32Socket, 50); /*50,脳??贸渭?谩??贸锚y*/
if(s32Rtn < 0)
{
return (void *)(-2);
}
nAddrLen = sizeof(struct sockaddr_in);
int nSessionId = 1000;
while ((s32CSocket = accept(s32Socket, (struct sockaddr*)&addrAccept, &nAddrLen)) >= 0)
{
printf("<<<<RTSP Client %s Connected...\n", inet_ntoa(addrAccept.sin_addr));
int nMaxBuf = 10 * 1024; // ?渭铆3???谩路??? 2 x nMaxBuf 渭??o3??贸D?
if(setsockopt(s32CSocket, SOL_SOCKET, SO_SNDBUF, (char*)&nMaxBuf, sizeof(nMaxBuf)) == -1)
printf("RTSP:!!!!!! Enalarge socket sending buffer error !!!!!!\n");
int i;
int bAdd=FALSE;
for(i=0;i<MAX_RTSP_CLIENT;i++)
{
if(g_rtspClients[i].status == RTSP_IDLE)
{
memset(&g_rtspClients[i],0,sizeof(RTSP_CLIENT));
g_rtspClients[i].index = i;
g_rtspClients[i].socket = s32CSocket;
g_rtspClients[i].status = RTSP_CONNECTED ;//RTSP_SENDING;
g_rtspClients[i].sessionid = nSessionId++;
strcpy(g_rtspClients[i].IP,inet_ntoa(addrAccept.sin_addr));
pthread_t threadIdlsn = 0;
struct sched_param sched;
sched.sched_priority = 1;
//to return ACKecho
pthread_create(&threadIdlsn, NULL, RtspClientMsg, &g_rtspClients[i]);
pthread_setschedparam(threadIdlsn,SCHED_RR,&sched);
bAdd = TRUE;
break;
}
}
if(bAdd==FALSE)
{
memset(&g_rtspClients[0],0,sizeof(RTSP_CLIENT));
g_rtspClients[0].index = 0;
g_rtspClients[0].socket = s32CSocket;
g_rtspClients[0].status = RTSP_CONNECTED ;//RTSP_SENDING;
g_rtspClients[0].sessionid = nSessionId++;
strcpy(g_rtspClients[0].IP,inet_ntoa(addrAccept.sin_addr));
pthread_t threadIdlsn = 0;
struct sched_param sched;
sched.sched_priority = 1;
//to return ACKecho
pthread_create(&threadIdlsn, NULL, RtspClientMsg, &g_rtspClients[0]);
pthread_setschedparam(threadIdlsn,SCHED_RR,&sched);
bAdd = TRUE;
}
if(exitok){ exitok++;return NULL; }
}
if(s32CSocket < 0)
{
// HI_OUT_Printf(0, "RTSP listening on port %d,accept err, %d\n", RTSP_SERVER_PORT, s32CSocket);
}
printf("----- INIT_RTSP_Listen() Exit !! \n");
return NULL;
}
void InitRtspServer()
{
int i;
pthread_t threadId = 0;
for(i=0;i<MAX_CHAN;i++)
{
memset(&g_rtpPack[i],0,sizeof(RTSP_PACK));
g_rtpPack[i].bIsFree = TRUE;
//g_rtpPack.bWaitIFrm = TRUE;
memset(&g_FrmPack[i],0,sizeof(FRAME_PACK));
}
memset(g_rtp_playload,0,sizeof(g_rtp_playload));
strcpy(g_rtp_playload,"G726-32");
g_audio_rate = 8000;
pthread_mutex_init(&g_sendmutex,NULL);
pthread_mutex_init(&g_mutex,NULL);
pthread_cond_init(&g_cond,NULL);
memset(g_rtspClients,0,sizeof(RTSP_CLIENT)*MAX_RTSP_CLIENT);
//pthread_create(&g_SendDataThreadId, NULL, SendDataThread, NULL);
struct sched_param thdsched;
thdsched.sched_priority = 2;
//to listen visiting
pthread_create(&threadId, NULL, RtspServerListen, NULL);
pthread_setschedparam(threadId,SCHED_RR,&thdsched);
printf("RTSP:-----Init Rtsp server\n");
HI_S32 s32Ret;
// s32Ret = SAMPLE_VENC_720P_CLASSIC();
s32Ret = SAMPLE_VENC_1080P_CLASSIC();
//exit
if (HI_SUCCESS == s32Ret)
printf("program exit normally!\n");
else
printf("program exit abnormally!\n");
exitok++;
}
int loop()
{
while(1)
{
usleep(1000);
if(exitok>0)exitok++;
if(exitok>10)exit(0);
}
return 1;
}
/******************************************************************************
* function : main()
* Description : video venc sample
******************************************************************************/
int main(int argc, char *argv[])
{
HI_S32 s32Ret;
InitRtspServer();
loop();
/* H.264@1080p@30fps+H.265@1080p@30fps+H.264@D1@30fps */
// s32Ret = SAMPLE_VENC_1080P_CLASSIC();
/* 1*1080p mjpeg encode + 1*1080p jpeg */
// s32Ret = SAMPLE_VENC_1080P_MJPEG_JPEG();
/* low delay */
//s32Ret = SAMPLE_VENC_LOW_DELAY();
/* roibg framerate */
//s32Ret = SAMPLE_VENC_ROIBG_CLASSIC();
/* H.264 Svc-t */
//s32Ret = SAMPLE_VENC_SVC_H264();
//if (HI_SUCCESS == s32Ret)
// printf("program exit normally!\n");
//else
// printf("program exit abnormally!\n");
//exit(s32Ret);
}
#ifdef __cplusplus
#if __cplusplus
}
#endif
#endif /* End of #ifdef __cplusplus */
扫一扫
2093
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
