RTSP再学习 -- Hi3516A RTSP实例

该程序rtsp源码结合 mpp 里 sample_venc 的视频编码样例可以用 VLC 播放 H.265 视频实时流将rtsp_server.h， sample_venc.c 这 2 个文件放到 mpp/sample/venc 目录下重新make即可。
在文件系统执行./sample_venc  VLC播放器里打开网络串流 ：

rtsp://Your ip:554/stream_chn0.h265   即可播放H.265视频流

修改 VLC->>打开网络串流->>勾选显示更多选项->>正在缓冲->> 300ms，可以稍微降低延时。不然延时有点大。

 

rtsp_server.h

 

1. #ifndef RTSP_SERVER_H

2. #define RTSP_SERVER_H

3.  

4. //#include "rtsp_cmd.h"

5.  

6. #if !defined(WIN32)

7. #define __PACKED__ __attribute__ ((__packed__))

8. #else

9. #define __PACKED__

10. #endif

11.  

12. typedef enum

13. {

14. RTSP_VIDEO=0,

15. RTSP_VIDEOSUB=1,

16. RTSP_AUDIO=2,

17. RTSP_YUV422=3,

18. RTSP_RGB=4,

19. RTSP_VIDEOPS=5,

20. RTSP_VIDEOSUBPS=6

21. }enRTSP_MonBlockType;

22.  

23. struct _RTP_FIXED_HEADER

24. {

25. /**//* byte 0 */

26. unsigned char csrc_len:4; /**//* expect 0 */

27. unsigned char extension:1; /**//* expect 1, see RTP_OP below */

28. unsigned char padding:1; /**//* expect 0 */

29. unsigned char version:2; /**//* expect 2 */

30. /**//* byte 1 */

31. unsigned char payload:7; /**//* RTP_PAYLOAD_RTSP */

32. unsigned char marker:1; /**//* expect 1 */

33. /**//* bytes 2, 3 */

34. unsigned short seq_no;

35. /**//* bytes 4-7 */

36. unsigned long timestamp;

37. /**//* bytes 8-11 */

38. unsigned long ssrc; /**//* stream number is used here. */

39. } __PACKED__;

40.  

41. typedef struct _RTP_FIXED_HEADER RTP_FIXED_HEADER;

42.  

43. struct _NALU_HEADER

44. {

45. //byte 0

46. unsigned char TYPE:5;

47. unsigned char NRI:2;

48. unsigned char F:1;

49.  

50. }__PACKED__; /**//* 1 BYTES */

51.  

52. typedef struct _NALU_HEADER NALU_HEADER;

53.  
54.  

55. struct _FU_INDICATOR

56. {

57. //byte 0

58. unsigned char TYPE:5;

59. unsigned char NRI:2;

60. unsigned char F:1;

61.  

62. }__PACKED__; /**//* 1 BYTES */

63.  

64. typedef struct _FU_INDICATOR FU_INDICATOR;

65.  

66. struct _FU_HEADER

67. {

68. //byte 0

69. unsigned char TYPE:5;

70. unsigned char R:1;

71. unsigned char E:1;

72. unsigned char S:1;

73. } __PACKED__; /**//* 1 BYTES */

74. typedef struct _FU_HEADER FU_HEADER;

75.  
76.  

77. struct _H265_NALU_HEADER

78. {

79. //byte 0

80. unsigned char LayerId_h:1;

81. unsigned char TYPE:6;

82. unsigned char F:1;

83.  

84. //byte 1

85. unsigned char TID:3;

86. unsigned char LayerId_l:5;

87.  

88. }__PACKED__; /**//* 2 BYTES */

89. typedef struct _H265_NALU_HEADER H265_NALU_HEADER;

90.  

91. struct _H265_FU_INDICATOR

92. {

93. //byte 0

94. unsigned char LayerId_h:1;

95. unsigned char TYPE:6;

96. unsigned char F:1;

97.  

98. //byte 1

99. unsigned char TID:3;

100. unsigned char LayerId_l:5;

101.  

102. }__PACKED__; /**//* 2 BYTES */

103.  

104. typedef struct _H265_FU_INDICATOR H265_FU_INDICATOR;

105.  

106. struct _H265_FU_HEADER

107. {

108. //byte 0

109. unsigned char FuTYPE:6;

110. unsigned char E:1;

111. unsigned char S:1;

112. } __PACKED__; /**//* 1 BYTES */

113. typedef struct _H265_FU_HEADER H265_FU_HEADER;

114.  

115. struct _AU_HEADER

116. {

117. //byte 0, 1

118. unsigned short au_len;

119. //byte 2,3

120. unsigned short frm_len:13;

121. unsigned char au_index:3;

122. } __PACKED__; /**//* 1 BYTES */

123. typedef struct _AU_HEADER AU_HEADER;

124.  
125.  

126. void InitRtspServer();

127. int AddFrameToRtspBuf(int nChanNum,enRTSP_MonBlockType eType, char * pData, unsigned int nSize, unsigned int nVidFrmNum,int bIFrm);

128.  

129. #endif

sample_venc.c

 

 

1. /******************************************************************************

2. A simple program of Hisilicon Hi35xx video encode implementation.

3. Copyright (C), 2010-2011, Hisilicon Tech. Co., Ltd.

4. ******************************************************************************

5. Modification: 2011-2 Created

6. ******************************************************************************/

7. #ifdef __cplusplus

8. #if __cplusplus

9. extern "C"{

10. #endif

11. #endif /* End of #ifdef __cplusplus */

12.  

13. #include <stdio.h>

14. #include <stdlib.h>

15. #include <string.h>

16. #include <unistd.h>

17. #include <pthread.h>

18. #include <signal.h>

19. #include <time.h>

20. #include <netdb.h>

21. #include <sys/socket.h>

22.  

23. #include <sys/ioctl.h>

24. #include <fcntl.h>

25. #include <sys/ipc.h>

26. #include <sys/msg.h>

27. #include <netinet/if_ether.h>

28. #include <net/if.h>

29. #include <linux/if_ether.h>

30. #include <linux/sockios.h>

31. #include <netinet/in.h>

32. #include <arpa/inet.h>

33.  

34. #include "rtsp_server.h"

35. #include "sample_comm.h"

36.  

37. #define nalu_sent_len 15000 //def:14000

38. //#define nalu_sent_len 1400

39. #define RTP_H264 96

40. #define MAX_CHAN 8

41. #define RTP_AUDIO 97

42. #define MAX_RTSP_CLIENT 4

43. #define RTSP_SERVER_PORT 554

44. #define RTSP_RECV_SIZE 1024 //def:1024 VLC:2*1024 ffmpeg:1024

45. #define RTSP_MAX_VID (1152*1024) //def:1024*1024 VLC:2*1024 ffmpeg:1152*1024

46. #define RTSP_MAX_AUD (15*1024)

47.  

48. #define AU_HEADER_SIZE 4

49. #define PARAM_STRING_MAX 100

50.  

51. static SAMPLE_VENC_GETSTREAM_PARA_S gs_stPara;

52. static pthread_t gs_VencPid;

53.  

54. typedef unsigned short u_int16_t;

55. typedef unsigned char u_int8_t;

56. typedef u_int16_t portNumBits;

57. typedef u_int32_t netAddressBits;

58. typedef long long _int64;

59. #ifndef FALSE

60. #define FALSE 0

61. #endif

62. #ifndef TRUE

63. #define TRUE 1

64. #endif

65. #define AUDIO_RATE 8000

66. #define PACKET_BUFFER_END (unsigned int)0x00000000

67.  

68. typedef struct

69. {

70. int startblock;

71. int BlockFileNum;

72.  

73. }IDXFILEHEAD_INFO;

74.  

75. typedef struct

76. {

77. _int64 starttime;

78. _int64 endtime;

79. int startblock;

80. int stampnum;

81. }IDXFILEBLOCK_INFO;

82. typedef struct

83. {

84. int blockindex;

85. }IDXSTAMP_INFO;

86.  

87. typedef struct

88. {

89. char filename[150];

90. }FILESTAMP_INFO;

91.  

92. typedef struct

93. {

94. char channelid[9];

95. _int64 starttime;

96. _int64 endtime;

97. _int64 session;

98. int type;

99. int encodetype;

100. }FIND_INFO;

101.  

102. typedef enum

103. {

104. RTP_UDP,

105. RTP_TCP,

106. RAW_UDP

107. }StreamingMode;

108.  
109.  
110.  
111.  
112.  

113. extern char g_rtp_playload[20];

114. extern int g_audio_rate;

115.  

116. typedef enum

117. {

118. RTSP_IDLE = 0,

119. RTSP_CONNECTED = 1,

120. RTSP_SENDING = 2,

121. }RTSP_STATUS;

122.  

123. typedef struct

124. {

125. int nVidLen;

126. int nAudLen;

127. int bIsIFrm;

128. int bWaitIFrm;

129. int bIsFree;

130. char vidBuf[RTSP_MAX_VID];

131. char audBuf[RTSP_MAX_AUD];

132. }RTSP_PACK;

133.  

134. typedef struct

135. {

136. int index;

137. int socket;

138. int reqchn;

139. int seqnum;

140. int seqnum2;

141. unsigned int tsvid;

142. unsigned int tsaud;

143. int status;

144. int sessionid;

145. int rtpport[2];

146. int rtcpport;

147. char IP[20];

148. char urlPre[PARAM_STRING_MAX];

149. }RTSP_CLIENT;

150.  

151. typedef struct

152. {

153. int vidLen;

154. int audLen;

155. int nFrameID;

156. char vidBuf[RTSP_MAX_VID];

157. char audBuf[RTSP_MAX_AUD];

158. }FRAME_PACK;

159. typedef struct

160. {

161. int startcodeprefix_len; //! 4 for parameter sets and first slice in picture, 3 for everything else (suggested)

162. unsigned len; //! Length of the NAL unit (Excluding the start code, which does not belong to the NALU)

163. unsigned max_size; //! Nal Unit Buffer size

164. int forbidden_bit; //! should be always FALSE

165. int nal_reference_idc; //! NALU_PRIORITY_xxxx

166. int nal_unit_type; //! NALU_TYPE_xxxx

167. char *buf; //! contains the first byte followed by the EBSP

168. unsigned short lost_packets; //! true, if packet loss is detected

169. } NALU_t;

170.  
171.  

172. RTP_FIXED_HEADER *rtp_hdr;

173.  

174. #if 0 //for h264

175. NALU_HEADER *nalu_hdr;

176. FU_INDICATOR *fu_ind;

177. FU_HEADER *fu_hdr;

178. #endif

179.  

180. H265_NALU_HEADER *h265_nalu_hdr;

181. H265_FU_INDICATOR *h265_fu_ind;

182. H265_FU_HEADER *h265_fu_hdr;

183.  

184. FRAME_PACK g_FrmPack[MAX_CHAN];

185. RTSP_PACK g_rtpPack[MAX_CHAN];

186. RTSP_CLIENT g_rtspClients[MAX_RTSP_CLIENT];

187.  

188. int g_nSendDataChn = -1;

189. pthread_mutex_t g_mutex;

190. pthread_cond_t g_cond;

191. pthread_mutex_t g_sendmutex;

192.  

193. pthread_t g_SendDataThreadId = 0;

194. //HAL_CLIENT_HANDLE hMainStreamClient = NULL,hSubStreamClient = NULL,hAudioClient = NULL;

195. char g_rtp_playload[20];

196. int g_audio_rate = 8000;

197. VIDEO_NORM_E gs_enNorm = VIDEO_ENCODING_MODE_NTSC;//30fps

198. int g_nframerate;

199. //VIDEO_NORM_E gs_enNorm = VIDEO_ENCODING_MODE_PAL;//15fps

200. //int g_nframerate = 15;

201. int exitok = 0;

202. int udpfd;

203.  

204. /******************************************************************************

205. * function : show usage

206. ******************************************************************************/

207. void SAMPLE_VENC_Usage(char *sPrgNm)

208. {

209. printf("Usage : %s <index>\n", sPrgNm);

210. printf("index:\n");

211. printf("\t 0) 1*1080p H264 + 1*1080p H265 + 1*D1 H264 encode.\n");

212. printf("\t 1) 1*1080p MJPEG encode + 1*1080p jpeg.\n");

213. printf("\t 2) low delay encode.\n");

214. printf("\t 3) roi background framerate.\n");

215. printf("\t 4) svc-t H264\n");

216.  

217. return;

218. }

219.  

220. /******************************************************************************

221. * function : to process abnormal case

222. ******************************************************************************/

223. void SAMPLE_VENC_HandleSig(HI_S32 signo)

224. {

225. if (SIGINT == signo || SIGTERM == signo)

226. {

227. SAMPLE_COMM_ISP_Stop();

228. SAMPLE_COMM_SYS_Exit();

229. printf("\033[0;31mprogram termination abnormally!\033[0;39m\n");

230. }

231. exit(-1);

232. }

233.  

234. /******************************************************************************

235. * function : to process abnormal case - the case of stream venc

236. ******************************************************************************/

237. void SAMPLE_VENC_StreamHandleSig(HI_S32 signo)

238. {

239.  

240. if (SIGINT == signo || SIGTERM == signo)

241. {

242. SAMPLE_COMM_SYS_Exit();

243. printf("\033[0;31mprogram exit abnormally!\033[0;39m\n");

244. }

245.  

246. exit(0);

247. }

248.  

249. HI_S32 VENC_Sent(char *buffer,int buflen)

250. {

251. HI_S32 i;

252. //--------------------------------------------------------

253. int is=0;

254. int nChanNum=0;

255. //printf("s");

256. for(is=0;is<MAX_RTSP_CLIENT;is++)

257. {

258. if(g_rtspClients[is].status!=RTSP_SENDING)

259. {

260. continue;

261. }

262. int heart = g_rtspClients[is].seqnum % 1000;

263. #if 0

264. if(heart==0 && g_rtspClients[is].seqnum!=0)

265. {

266. char buf[2*1024];

267. memset(buf,0,2*1024);

268. char *pTemp = buf;

269. pTemp += sprintf(pTemp,"RTSP/1.0 200 OK\r\nCSeq: %s\r\nPublic: %s\r\n\r\n",

270. 0,"OPTIONS,DESCRIBE,SETUP,PLAY,PAUSE,TEARDOWN");

271.  

272. int reg = send(g_rtspClients[is].socket, buf,strlen(buf),0);

273. if(reg <= 0)

274. {

275. //printf("RTSP:Send Error---- %d\n",reg);

276. g_rtspClients[is].status = RTSP_IDLE;

277. g_rtspClients[is].seqnum = 0;

278. g_rtspClients[is].tsvid = 0;

279. g_rtspClients[is].tsaud = 0;

280. close(g_rtspClients[is].socket);

281. continue;

282. }

283. else

284. {

285. printf("Heart:%d\n",reg);

286. }

287. }

288. #endif

289. char* nalu_payload;

290. int nAvFrmLen = 0;

291. int nIsIFrm = 0;

292. int nNaluType = 0;

293. unsigned char u8NaluBytes1;

294. unsigned char u8NaluBytes2;

295. char sendbuf[320*1024+32];

296.  

297. //HI_S32 intdelta = -1000,tmptime;

298. //HI_S32 intdelta = 0,tmptime;

299.  

300. //char sendbuf[64*1024+32];

301. nChanNum = g_rtspClients[is].reqchn;

302. if(nChanNum<0 || nChanNum>=MAX_CHAN )

303. {

304. continue;

305. }

306. nAvFrmLen = buflen;

307. //printf("%d\n",nAvFrmLen);

308. //nAvFrmLen = vStreamInfo.dwSize ;//Streamlen

309. struct sockaddr_in server;

310. server.sin_family=AF_INET;

311. server.sin_port=htons(g_rtspClients[is].rtpport[0]);

312. server.sin_addr.s_addr=inet_addr(g_rtspClients[is].IP);

313. int bytes=0;

314. unsigned int timestamp_increse=0;

315.  

316. //timeing in = out,15fps in,so same f out

317. //if(VIDEO_ENCODING_MODE_PAL == gs_enNorm)g_nframerate = 15;

318. //else if(VIDEO_ENCODING_MODE_NTSC == gs_enNorm)g_nframerate = 30;

319. if(VIDEO_ENCODING_MODE_PAL == gs_enNorm)g_nframerate = 16;

320. else if(VIDEO_ENCODING_MODE_NTSC == gs_enNorm)g_nframerate = 32;//25

321.  

322. //if(VIDEO_ENCODING_MODE_PAL == gs_enNorm)timestamp_increse=5625;//90000/16

323. //else if(VIDEO_ENCODING_MODE_NTSC == gs_enNorm)timestamp_increse=2813;//90000/32

324.  

325. timestamp_increse=(unsigned int)(90000.0 / g_nframerate);

326. //sendto(udpfd, buffer, nAvFrmLen, 0, (struct sockaddr *)&server,sizeof(server));

327.  

328. rtp_hdr =(RTP_FIXED_HEADER*)&sendbuf[0];

329. rtp_hdr->payload = RTP_H264;

330. rtp_hdr->version = 2;

331. rtp_hdr->marker = 0;

332. rtp_hdr->ssrc = htonl(10);

333. if(nAvFrmLen<=nalu_sent_len)

334. {

335. /*设置rtp M位 */

336. //printf("a");

337.  

338. rtp_hdr->marker=1;

339. rtp_hdr->seq_no = htons(g_rtspClients[is].seqnum++);

340.  

341. h265_nalu_hdr=(H265_NALU_HEADER*)&sendbuf[12];

342. h265_nalu_hdr->F = 0;

343. h265_nalu_hdr->TYPE = nNaluType;

344. h265_nalu_hdr->LayerId_h = 0;

345.  

346. h265_nalu_hdr->LayerId_l = 0;

347. h265_nalu_hdr->TID =0x01;

348. nalu_payload=&sendbuf[13];

349. memcpy(nalu_payload,buffer,nAvFrmLen);

350.  

351. g_rtspClients[is].tsvid = g_rtspClients[is].tsvid+timestamp_increse;

352.  

353. rtp_hdr->timestamp=htonl(g_rtspClients[is].tsvid);

354. bytes=nAvFrmLen+ 13 ;

355. sendto(udpfd, sendbuf, bytes, 0, (struct sockaddr *)&server,sizeof(server));

356. }

357. else if(nAvFrmLen>nalu_sent_len)

358. {

359. //printf("b");

360. int k=0,l=0;

361. k=nAvFrmLen/nalu_sent_len;

362. l=nAvFrmLen%nalu_sent_len;

363. int t=0;

364. /*

365. tmptime = g_rtspClients[is].tsvid+timestamp_increse;

366. if(tmptime >= (-intdelta))g_rtspClients[is].tsvid=tmptime + intdelta;

367. else g_rtspClients[is].tsvid = tmptime;

368. */

369. g_rtspClients[is].tsvid = g_rtspClients[is].tsvid+timestamp_increse;

370.  

371. while(t<=k)

372. {

373. rtp_hdr->seq_no = htons(g_rtspClients[is].seqnum++);

374. if(t==0)

375. {

376. rtp_hdr->marker=0;

377. h265_fu_ind =(H265_FU_INDICATOR*)&sendbuf[12];

378. h265_fu_ind->F = 0;

379. h265_fu_ind->TYPE=49;

380. h265_fu_ind->LayerId_h = 0;

381. h265_fu_ind->LayerId_l =0;

382. h265_fu_ind->TID = 0x01;

383.  

384. h265_fu_hdr =(H265_FU_HEADER*)&sendbuf[14];

385. h265_fu_hdr->E=0;

386. h265_fu_hdr->S=1;

387. h265_fu_hdr->FuTYPE=nNaluType;

388.  

389. nalu_payload=&sendbuf[15];

390. memcpy(nalu_payload,buffer,nalu_sent_len);

391.  

392. bytes=nalu_sent_len+15;

393. sendto( udpfd, sendbuf, bytes, 0, (struct sockaddr *)&server,sizeof(server));

394. t++;

395.  

396. }

397. else if(k==t)

398. {

399. rtp_hdr->marker=1;

400. h265_fu_ind =(H265_FU_INDICATOR*)&sendbuf[12];

401. h265_fu_ind->F= 0 ;

402. h265_fu_ind->TYPE=49;

403. h265_fu_ind->LayerId_h = 0;

404. h265_fu_ind->LayerId_l = 0;

405. h265_fu_ind->TID =0x01;

406.  

407. h265_fu_hdr =(H265_FU_HEADER*)&sendbuf[14];

408. h265_fu_hdr->S=0;

409. h265_fu_hdr->FuTYPE =nNaluType;

410. h265_fu_hdr->E=1;

411. nalu_payload=&sendbuf[15];

412. memcpy(nalu_payload,buffer+t*nalu_sent_len,l);

413. bytes=l+15;

414. sendto(udpfd, sendbuf, bytes, 0, (struct sockaddr *)&server,sizeof(server));

415. t++;

416. }

417. else if(t<k && t!=0)

418. {

419.  

420. rtp_hdr->marker=0;

421. h265_fu_ind =(H265_FU_INDICATOR*)&sendbuf[12];

422. h265_fu_ind->F=0;

423. h265_fu_ind->TYPE=49;

424. h265_fu_ind->LayerId_h = 0;

425.  

426. h265_fu_ind->LayerId_l = 0;

427. h265_fu_ind->TID = 0x01;

428.  

429. h265_fu_hdr =(H265_FU_HEADER*)&sendbuf[14];

430. h265_fu_hdr->S=0;

431. h265_fu_hdr->E=0;

432. h265_fu_hdr->FuTYPE = nNaluType;

433. nalu_payload=&sendbuf[15];

434. memcpy(nalu_payload,buffer+t*nalu_sent_len,nalu_sent_len);

435. bytes=nalu_sent_len+15;

436. sendto(udpfd, sendbuf, bytes, 0, (struct sockaddr *)&server,sizeof(server));

437. t++;

438. }

439. }

440. }

441. }

442. //------------------------------------------------------------

443. }

444.  

445. /******************************************************************************

446. * funciton : sent H265 stream

447. ******************************************************************************/

448. HI_S32 SAMPLE_COMM_VENC_Sentjin(VENC_STREAM_S *pstStream)

449. {

450. HI_S32 i,flag=0;

451. HI_S32 s32Ret;

452. /*Venc get StreamBufInfo*/

453. VENC_STREAM_BUF_INFO_S stStreamBufInfo;

454. HI_U32 u32Left;

455. VENC_CHN VeChn = 0;

456. HI_U32 u32SrcPhyAddr, u32DestPhyAddr;

457. s32Ret = HI_MPI_VENC_GetStreamBufInfo(VeChn,&stStreamBufInfo);

458. if (HI_SUCCESS != s32Ret)

459. {

460. return HI_FAILURE;

461. }

462.  
463.  

464. for(i=0;i<MAX_RTSP_CLIENT;i++)//have atleast a connect

465. {

466. if(g_rtspClients[i].status == RTSP_SENDING)

467. {

468. flag = 1;

469. break;

470. }

471. }

472. if(flag)

473. {

474. //printf("a");

475. for (i = 0; i < pstStream->u32PackCount; i++)

476. {

477. HI_S32 lens=0,j,lastadd=0,newadd=0,showflap=0;

478. char sendbuf[200*1024];

479.  

480. memcpy(&sendbuf[0]+ lens ,

481. pstStream->pstPack[i].pu8Addr+pstStream->pstPack[i].u32Offset,

482. pstStream->pstPack[i].u32Len-pstStream->pstPack[i].u32Offset);

483.  

484. lens += pstStream->pstPack[i].u32Len-pstStream->pstPack[i].u32Offset;

485.  

486. VENC_Sent(sendbuf,lens);

487.  

488. lens = 0;

489. }

490. }

491.  

492. return HI_SUCCESS;

493. }

494.  
495.  

496. /******************************************************************************

497. * funciton : get stream from each channels and save them

498. ******************************************************************************/

499. HI_VOID* SAMPLE_COMM_VENC_GetVencStreamProcsent(HI_VOID *p)

500. {

501. pthread_detach(pthread_self());

502. printf("RTSP:-----create send thread\n");

503. //i=0,720p; i=1,VGA 640*480; i=2, 320*240;

504. HI_S32 i=0;//exe ch NO.

505. HI_S32 s32ChnTotal;

506. SAMPLE_VENC_GETSTREAM_PARA_S *pstPara;

507. HI_S32 maxfd = 0;

508. struct timeval TimeoutVal;

509. fd_set read_fds;

510. HI_S32 VencFd[VENC_MAX_CHN_NUM];

511. VENC_CHN_STAT_S stStat;

512. HI_S32 s32Ret;

513. VENC_STREAM_S stStream;

514.  

515. pstPara = (SAMPLE_VENC_GETSTREAM_PARA_S*)p;

516. s32ChnTotal = pstPara->s32Cnt;

517.  

518. /******************************************

519. step 1: check & prepare save-file & venc-fd

520. ******************************************/

521. if (s32ChnTotal >= VENC_MAX_CHN_NUM)

522. {

523. SAMPLE_PRT("input count invaild\n");

524. return NULL;

525. }

526.  

527. //for (i = 0; i < s32ChnTotal; i++)

528. {

529. /* Set Venc Fd. */

530. VencFd[i] = HI_MPI_VENC_GetFd(i);

531. if (VencFd[i] < 0)

532. {

533. SAMPLE_PRT("HI_MPI_VENC_GetFd failed with %#x!\n",

534. VencFd[i]);

535. return NULL;

536. }

537. if (maxfd <= VencFd[i])

538. {

539. maxfd = VencFd[i];

540. }

541. }

542.  
543.  
544.  

545. udpfd = socket(AF_INET,SOCK_DGRAM,0);//UDP

546. printf("udp up\n");

547.  

548. /******************************************

549. step 2: Start to get streams of each channel.

550. ******************************************/

551. while (HI_TRUE == pstPara->bThreadStart)

552. {

553. HI_S32 is,flag=0;

554.  

555. for(is=0;is<MAX_RTSP_CLIENT;is++)//have atleast a connect

556. {

557. if(g_rtspClients[is].status == RTSP_SENDING)

558. {

559. flag = 1;

560. break;

561. }

562. }

563. if(flag)

564. {

565. FD_ZERO(&read_fds);

566. //for (i = 0; i < s32ChnTotal; i++)

567. {

568. FD_SET(VencFd[i], &read_fds);

569. }

570.  

571. TimeoutVal.tv_sec = 2;

572. TimeoutVal.tv_usec = 0;

573. s32Ret = select(maxfd + 1, &read_fds, NULL, NULL, &TimeoutVal);

574. if (s32Ret < 0)

575. {

576. SAMPLE_PRT("select failed!\n");

577. break;

578. }

579. else if (s32Ret == 0)

580. {

581. SAMPLE_PRT("get venc stream time out, exit thread\n");

582. continue;

583. }

584. else

585. {

586. //only ch1 used

587. //for (i = 0; i < s32ChnTotal; i++)

588. //for (i = 0; i < 1; i++)

589. //i = 1;

590. {

591. if (FD_ISSET(VencFd[i], &read_fds))

592. {

593. /*******************************************************

594. step 2.1 : query how many packs in one-frame stream.

595. *******************************************************/

596. //printf("query how many packs \n");

597. memset(&stStream, 0, sizeof(stStream));

598. s32Ret = HI_MPI_VENC_Query(i, &stStat);

599. if (HI_SUCCESS != s32Ret)

600. {

601. SAMPLE_PRT("HI_MPI_VENC_Query chn[%d] failed with %#x!\n", i, s32Ret);

602. break;

603. }

604.  

605. /*******************************************************

606. step 2.2 : malloc corresponding number of pack nodes.

607. *******************************************************/

608. stStream.pstPack = (VENC_PACK_S*)malloc(sizeof(VENC_PACK_S) * stStat.u32CurPacks);

609. if (NULL == stStream.pstPack)

610. {

611. SAMPLE_PRT("malloc stream pack failed!\n");

612. break;

613. }

614.  

615. /*******************************************************

616. step 2.3 : call mpi to get one-frame stream

617. *******************************************************/

618. if(exitok)

619. {

620. free(stStream.pstPack);

621. stStream.pstPack = NULL;

622. exitok++;return NULL;

623. }

624. stStream.u32PackCount = stStat.u32CurPacks;

625. s32Ret = HI_MPI_VENC_GetStream(i, &stStream, HI_TRUE);

626. if (HI_SUCCESS != s32Ret)

627. {

628. free(stStream.pstPack);

629. stStream.pstPack = NULL;

630. SAMPLE_PRT("HI_MPI_VENC_GetStream failed with %#x!\n", \

631. s32Ret);

632. break;

633. }

634. //if(stStream.u32PackCount>0)printf("getpack%d\n",stStream.u32PackCount);

635. //printf("gt1\n");

636. SAMPLE_COMM_VENC_Sentjin(&stStream);

637.  

638. /*

639. pthread_t threadsentId = 0;

640. struct sched_param sentsched;

641. sentsched.sched_priority = 20;

642. //to listen visiting

643. pthread_create(&threadsentId, NULL, SAMPLE_COMM_VENC_Sentjin,(HI_VOID*)&stStream);

644. pthread_setschedparam(threadsentId,SCHED_RR,&sentsched);

645. */

646.  

647. //step 2.5 : release stream/

648. s32Ret = HI_MPI_VENC_ReleaseStream(i, &stStream);

649. if (HI_SUCCESS != s32Ret)

650. {

651. free(stStream.pstPack);

652. stStream.pstPack = NULL;

653. break;

654. }

655. //step 2.6 : free pack nodes/

656. free(stStream.pstPack);

657. stStream.pstPack = NULL;

658. if(exitok){ exitok++;return NULL; }

659.  

660. }

661. }

662. }

663. }

664. usleep(100);

665. }

666.  

667. return NULL;

668. }

669.  

670. /******************************************************************************

671. * function : H.264@1080p@30fps+H.265@1080p@30fps+H.264@D1@30fps

672. ******************************************************************************/

673. HI_S32 SAMPLE_VENC_1080P_CLASSIC(HI_VOID)

674. {

675. PAYLOAD_TYPE_E enPayLoad[3]= {PT_H265, PT_H264, PT_H264};//def:{PT_H264, PT_H265, PT_H264}

676. //PAYLOAD_TYPE_E enPayLoad[3]= {PT_H265,PT_H264, PT_JPEG};

677. PIC_SIZE_E enSize[3] = {PIC_HD1080, PIC_HD720, PIC_D1};

678. //PIC_SIZE_E enSize[3] = {PIC_2592x1520, PIC_VGA, PIC_D1};

679. HI_U32 u32Profile = 0;

680.  

681. VB_CONF_S stVbConf;

682. SAMPLE_VI_CONFIG_S stViConfig = {0};

683.  

684. VPSS_GRP VpssGrp;

685. VPSS_CHN VpssChn;

686. VPSS_GRP_ATTR_S stVpssGrpAttr;

687. VPSS_CHN_ATTR_S stVpssChnAttr;

688. VPSS_CHN_MODE_S stVpssChnMode;

689.  

690. VENC_CHN VencChn;

691. SAMPLE_RC_E enRcMode= SAMPLE_RC_CBR;

692.  

693. HI_S32 s32ChnNum=1;

694.  

695. HI_S32 s32Ret = HI_SUCCESS;

696. HI_U32 u32BlkSize;

697. SIZE_S stSize;

698. char c;

699.  
700.  

701. /*if ((SONY_IMX178_LVDS_5M_30FPS == SENSOR_TYPE)

702. || (APTINA_AR0330_MIPI_1536P_25FPS == SENSOR_TYPE)

703. || (APTINA_AR0330_MIPI_1296P_25FPS == SENSOR_TYPE))

704. {

705. s32ChnNum = 2;

706. }

707. else

708. {

709. s32ChnNum = 3;

710. }

711.  
712.  

713. if( OMNIVISION_OV4689_MIPI_4M_30FPS == SENSOR_TYPE)

714. {

715. enSize[0] = PIC_2592x1520;

716. }

717. else if(OMNIVISION_OV4689_MIPI_1080P_30FPS == SENSOR_TYPE)

718. {

719. enSize[0] = PIC_HD1080;

720. }*/

721.  
722.  

723. /******************************************

724. step 1: init sys variable

725. ******************************************/

726. memset(&stVbConf,0,sizeof(VB_CONF_S));

727.  

728. SAMPLE_COMM_VI_GetSizeBySensor(&enSize[0]);

729. switch(SENSOR_TYPE)

730. {

731. case SONY_IMX178_LVDS_5M_30FPS:

732. case APTINA_AR0330_MIPI_1536P_25FPS:

733. case APTINA_AR0330_MIPI_1296P_25FPS:

734. case OMNIVISION_OV4689_MIPI_4M_30FPS:

735. case OMNIVISION_OV4689_MIPI_1080P_30FPS:

736. enSize[1] = PIC_VGA;

737. break;

738. default:

739. break;

740. }

741.  

742. stVbConf.u32MaxPoolCnt = 128;

743.  

744. /*video buffer*/

745. u32BlkSize = SAMPLE_COMM_SYS_CalcPicVbBlkSize(gs_enNorm,\

746. enSize[0], SAMPLE_PIXEL_FORMAT, SAMPLE_SYS_ALIGN_WIDTH);

747. stVbConf.astCommPool[0].u32BlkSize = u32BlkSize;

748. stVbConf.astCommPool[0].u32BlkCnt = 10;//8 def:20

749.  

750. u32BlkSize = SAMPLE_COMM_SYS_CalcPicVbBlkSize(gs_enNorm,\

751. enSize[1], SAMPLE_PIXEL_FORMAT, SAMPLE_SYS_ALIGN_WIDTH);

752. stVbConf.astCommPool[1].u32BlkSize = u32BlkSize;

753. stVbConf.astCommPool[1].u32BlkCnt =10;//8 def:20

754.  

755. u32BlkSize = SAMPLE_COMM_SYS_CalcPicVbBlkSize(gs_enNorm,\

756. enSize[2], SAMPLE_PIXEL_FORMAT, SAMPLE_SYS_ALIGN_WIDTH);

757. stVbConf.astCommPool[2].u32BlkSize = u32BlkSize;

758. stVbConf.astCommPool[2].u32BlkCnt = 10;//10 def:20

759.  
760.  

761. /******************************************

762. step 2: mpp system init.

763. ******************************************/

764. s32Ret = SAMPLE_COMM_SYS_Init(&stVbConf);

765. if (HI_SUCCESS != s32Ret)

766. {

767. SAMPLE_PRT("system init failed with %d!\n", s32Ret);

768. goto END_VENC_1080P_CLASSIC_0;

769. }

770.  

771. /******************************************

772. step 3: start vi dev & chn to capture

773. ******************************************/

774. stViConfig.enViMode = SENSOR_TYPE;

775. stViConfig.enRotate = ROTATE_NONE;

776. stViConfig.enNorm = VIDEO_ENCODING_MODE_NTSC;//def: VIDEO_ENCODING_MODE_AUTO

777. stViConfig.enViChnSet = VI_CHN_SET_NORMAL;

778. stViConfig.enWDRMode = WDR_MODE_NONE;

779. s32Ret = SAMPLE_COMM_VI_StartVi(&stViConfig);

780. if (HI_SUCCESS != s32Ret)

781. {

782. SAMPLE_PRT("start vi failed!\n");

783. goto END_VENC_1080P_CLASSIC_1;

784. }

785.  

786. /******************************************

787. step 4: start vpss and vi bind vpss

788. ******************************************/

789. s32Ret = SAMPLE_COMM_SYS_GetPicSize(gs_enNorm, enSize[0], &stSize);

790. if (HI_SUCCESS != s32Ret)

791. {

792. SAMPLE_PRT("SAMPLE_COMM_SYS_GetPicSize failed!\n");

793. goto END_VENC_1080P_CLASSIC_1;

794. }

795.  

796. VpssGrp = 0;

797. stVpssGrpAttr.u32MaxW = stSize.u32Width;

798. stVpssGrpAttr.u32MaxH = stSize.u32Height;

799. stVpssGrpAttr.bIeEn = HI_FALSE;

800. stVpssGrpAttr.bNrEn = HI_TRUE;

801. stVpssGrpAttr.bHistEn = HI_FALSE;

802. stVpssGrpAttr.bDciEn = HI_FALSE;

803. stVpssGrpAttr.enDieMode = VPSS_DIE_MODE_NODIE;

804. stVpssGrpAttr.enPixFmt = SAMPLE_PIXEL_FORMAT;

805.  

806. s32Ret = SAMPLE_COMM_VPSS_StartGroup(VpssGrp, &stVpssGrpAttr);

807. if (HI_SUCCESS != s32Ret)

808. {

809. SAMPLE_PRT("Start Vpss failed!\n");

810. goto END_VENC_1080P_CLASSIC_2;

811. }

812.  

813. s32Ret = SAMPLE_COMM_VI_BindVpss(stViConfig.enViMode);

814. if (HI_SUCCESS != s32Ret)

815. {

816. SAMPLE_PRT("Vi bind Vpss failed!\n");

817. goto END_VENC_1080P_CLASSIC_3;

818. }

819.  

820. VpssChn = 0;

821. stVpssChnMode.enChnMode = VPSS_CHN_MODE_USER;

822. stVpssChnMode.bDouble = HI_FALSE;

823. stVpssChnMode.enPixelFormat = SAMPLE_PIXEL_FORMAT;

824. stVpssChnMode.u32Width = stSize.u32Width;

825. stVpssChnMode.u32Height = stSize.u32Height;

826. stVpssChnMode.enCompressMode = COMPRESS_MODE_SEG;

827. memset(&stVpssChnAttr, 0, sizeof(stVpssChnAttr));

828. stVpssChnAttr.s32SrcFrameRate = -1;

829. stVpssChnAttr.s32DstFrameRate = -1;

830. s32Ret = SAMPLE_COMM_VPSS_EnableChn(VpssGrp, VpssChn, &stVpssChnAttr, &stVpssChnMode, HI_NULL);

831. if (HI_SUCCESS != s32Ret)

832. {

833. SAMPLE_PRT("Enable vpss chn failed!\n");

834. goto END_VENC_1080P_CLASSIC_4;

835. }

836.  

837. VpssChn = 1;

838. stVpssChnMode.enChnMode = VPSS_CHN_MODE_USER;

839. stVpssChnMode.bDouble = HI_FALSE;

840. stVpssChnMode.enPixelFormat = SAMPLE_PIXEL_FORMAT;

841. stVpssChnMode.u32Width = stSize.u32Width; //640

842. stVpssChnMode.u32Height = stSize.u32Height; //480

843. stVpssChnMode.enCompressMode = COMPRESS_MODE_SEG;

844. stVpssChnAttr.s32SrcFrameRate = -1;

845. stVpssChnAttr.s32DstFrameRate = -1;

846. s32Ret = SAMPLE_COMM_VPSS_EnableChn(VpssGrp, VpssChn, &stVpssChnAttr, &stVpssChnMode, HI_NULL);

847. if (HI_SUCCESS != s32Ret)

848. {

849. SAMPLE_PRT("Enable vpss chn failed!\n");

850. goto END_VENC_1080P_CLASSIC_4;

851. }

852.  

853. if((SONY_IMX178_LVDS_5M_30FPS != SENSOR_TYPE)

854. && (APTINA_AR0330_MIPI_1536P_25FPS != SENSOR_TYPE)

855. && (APTINA_AR0330_MIPI_1296P_25FPS != SENSOR_TYPE))

856. {

857.  

858. VpssChn = 2;

859. stVpssChnMode.enChnMode = VPSS_CHN_MODE_USER;

860. stVpssChnMode.bDouble = HI_FALSE;

861. stVpssChnMode.enPixelFormat = SAMPLE_PIXEL_FORMAT;

862. stVpssChnMode.u32Width = 720;

863. stVpssChnMode.u32Height = (VIDEO_ENCODING_MODE_PAL==gs_enNorm)?576:480;;

864. stVpssChnMode.enCompressMode = COMPRESS_MODE_NONE;

865.  

866. stVpssChnAttr.s32SrcFrameRate = -1;

867. stVpssChnAttr.s32DstFrameRate = -1;

868.  

869. s32Ret = SAMPLE_COMM_VPSS_EnableChn(VpssGrp, VpssChn, &stVpssChnAttr, &stVpssChnMode, HI_NULL);

870. if (HI_SUCCESS != s32Ret)

871. {

872. SAMPLE_PRT("Enable vpss chn failed!\n");

873. goto END_VENC_1080P_CLASSIC_4;

874. }

875. }

876.  

877. /******************************************

878. step 5: start stream venc

879. ******************************************/

880. /*** HD1080P **/

881.  

882. enRcMode = SAMPLE_RC_CBR;

883. VpssGrp = 0;

884. VpssChn = 0;

885. VencChn = 0;

886. s32Ret = SAMPLE_COMM_VENC_Start(VencChn, enPayLoad[0],\

887. gs_enNorm, enSize[0], enRcMode,u32Profile);

888. if (HI_SUCCESS != s32Ret)

889. {

890. SAMPLE_PRT("Start Venc failed!\n");

891. goto END_VENC_1080P_CLASSIC_5;

892. }

893.  

894. s32Ret = SAMPLE_COMM_VENC_BindVpss(VencChn, VpssGrp, VpssChn);

895. if (HI_SUCCESS != s32Ret)

896. {

897. SAMPLE_PRT("Start Venc failed!\n");

898. goto END_VENC_1080P_CLASSIC_5;

899. }

900.  

901. /*** 1080p **/

902. /*VpssChn = 1;

903. VencChn = 1;

904. s32Ret = SAMPLE_COMM_VENC_Start(VencChn, enPayLoad[1], \

905. gs_enNorm, enSize[1], enRcMode,u32Profile);

906. if (HI_SUCCESS != s32Ret)

907. {

908. SAMPLE_PRT("Start Venc failed!\n");

909. goto END_VENC_1080P_CLASSIC_5;

910. }

911.  

912. s32Ret = SAMPLE_COMM_VENC_BindVpss(VencChn, VpssGrp, VpssChn);

913. if (HI_SUCCESS != s32Ret)

914. {

915. SAMPLE_PRT("Start Venc failed!\n");

916. goto END_VENC_1080P_CLASSIC_5;

917. }*/

918.  

919. /*** D1 **/

920. /*if(SONY_IMX178_LVDS_5M_30FPS != SENSOR_TYPE)

921. {

922. VpssChn = 2;

923. VencChn = 2;

924. s32Ret = SAMPLE_COMM_VENC_Start(VencChn, enPayLoad[2], \

925. gs_enNorm, enSize[2], enRcMode,u32Profile);

926. if (HI_SUCCESS != s32Ret)

927. {

928. SAMPLE_PRT("Start Venc failed!\n");

929. goto END_VENC_1080P_CLASSIC_5;

930. }

931.  

932. s32Ret = SAMPLE_COMM_VENC_BindVpss(VencChn, VpssGrp, VpssChn);

933. if (HI_SUCCESS != s32Ret)

934. {

935. SAMPLE_PRT("Start Venc failed!\n");

936. goto END_VENC_1080P_CLASSIC_5;

937. }

938. }*/

939. /******************************************

940. step 6: stream venc process -- get stream, then save it to file.

941. ******************************************/

942. /*s32Ret = SAMPLE_COMM_VENC_StartGetStream(s32ChnNum);

943. if (HI_SUCCESS != s32Ret)

944. {

945. SAMPLE_PRT("Start Venc failed!\n");

946. goto END_VENC_1080P_CLASSIC_5;

947. }*/

948.  

949. gs_stPara.bThreadStart = HI_TRUE;

950. gs_stPara.s32Cnt = s32ChnNum;

951.  

952. struct sched_param schedvenc;

953. schedvenc.sched_priority = 10;

954. //to get stream

955. pthread_create(&gs_VencPid, 0, SAMPLE_COMM_VENC_GetVencStreamProcsent, (HI_VOID*)&gs_stPara);

956. pthread_setschedparam(gs_VencPid,SCHED_RR,&schedvenc);

957.  

958. if (HI_SUCCESS != s32Ret)

959. {

960. SAMPLE_PRT("Start Venc failed!\n");

961. goto END_VENC_1080P_CLASSIC_5;

962. }

963.  
964.  

965. printf("please press twice ENTER to exit this sample\n");

966. getchar();

967. getchar();

968. /******************************************

969. step 7: exit process

970. ******************************************/

971. SAMPLE_COMM_VENC_StopGetStream();

972.  

973. END_VENC_1080P_CLASSIC_5:

974. VpssGrp = 0;

975.  

976. VpssChn = 0;

977. VencChn = 0;

978. SAMPLE_COMM_VENC_UnBindVpss(VencChn, VpssGrp, VpssChn);

979. SAMPLE_COMM_VENC_Stop(VencChn);

980.  

981. VpssChn = 1;

982. VencChn = 1;

983. SAMPLE_COMM_VENC_UnBindVpss(VencChn, VpssGrp, VpssChn);

984. SAMPLE_COMM_VENC_Stop(VencChn);

985.  
986.  

987. if(SONY_IMX178_LVDS_5M_30FPS != SENSOR_TYPE)

988. {

989. VpssChn = 2;

990. VencChn = 2;

991. SAMPLE_COMM_VENC_UnBindVpss(VencChn, VpssGrp, VpssChn);

992. SAMPLE_COMM_VENC_Stop(VencChn);

993. }

994.  

995. SAMPLE_COMM_VI_UnBindVpss(stViConfig.enViMode);

996. END_VENC_1080P_CLASSIC_4: //vpss stop

997. VpssGrp = 0;

998. VpssChn = 0;

999. SAMPLE_COMM_VPSS_DisableChn(VpssGrp, VpssChn);

1000. VpssChn = 1;

1001. SAMPLE_COMM_VPSS_DisableChn(VpssGrp, VpssChn);

1002. if(SONY_IMX178_LVDS_5M_30FPS != SENSOR_TYPE)

1003. {

1004. VpssChn = 2;

1005. SAMPLE_COMM_VPSS_DisableChn(VpssGrp, VpssChn);

1006. }

1007. END_VENC_1080P_CLASSIC_3: //vpss stop

1008. SAMPLE_COMM_VI_UnBindVpss(stViConfig.enViMode);

1009. END_VENC_1080P_CLASSIC_2: //vpss stop

1010. SAMPLE_COMM_VPSS_StopGroup(VpssGrp);

1011. END_VENC_1080P_CLASSIC_1: //vi stop

1012. SAMPLE_COMM_VI_StopVi(&stViConfig);

1013. END_VENC_1080P_CLASSIC_0: //system exit

1014. SAMPLE_COMM_SYS_Exit();

1015.  

1016. return s32Ret;

1017. }

1018.  
1019.  

1020. #if 0

1021. /******************************************************************************

1022. * function : 1路1080p MJPEG encode and 1路1080p JPEG snap

1023. ******************************************************************************/

1024. HI_S32 SAMPLE_VENC_1080P_MJPEG_JPEG(HI_VOID)

1025. {

1026. PAYLOAD_TYPE_E enPayLoad = PT_MJPEG;

1027. PIC_SIZE_E enSize = PIC_HD1080;

1028. HI_U32 u32Profile = 0;

1029.  

1030. VB_CONF_S stVbConf;

1031. SAMPLE_VI_CONFIG_S stViConfig = {0};

1032.  

1033. VPSS_GRP VpssGrp;

1034. VPSS_CHN VpssChn;

1035. VPSS_GRP_ATTR_S stVpssGrpAttr;

1036. VPSS_CHN_ATTR_S stVpssChnAttr;

1037. VPSS_CHN_MODE_S stVpssChnMode;

1038.  

1039. VENC_CHN VencChn;

1040. SAMPLE_RC_E enRcMode = SAMPLE_RC_CBR;

1041. HI_S32 s32ChnNum = 1;

1042.  

1043. HI_S32 s32Ret = HI_SUCCESS;

1044. HI_U32 u32BlkSize;

1045. SIZE_S stSize;

1046. HI_S32 i = 0;

1047. char ch;

1048.  

1049. /******************************************

1050. step 1: init sys variable

1051. ******************************************/

1052. memset(&stVbConf,0,sizeof(VB_CONF_S));

1053.  

1054. stVbConf.u32MaxPoolCnt = 128;

1055.  

1056. SAMPLE_COMM_VI_GetSizeBySensor(&enSize);

1057.  

1058. /*video buffer*/

1059. u32BlkSize = SAMPLE_COMM_SYS_CalcPicVbBlkSize(gs_enNorm,\

1060. enSize, SAMPLE_PIXEL_FORMAT, SAMPLE_SYS_ALIGN_WIDTH);

1061.  

1062. stVbConf.astCommPool[0].u32BlkSize = u32BlkSize;

1063. stVbConf.astCommPool[0].u32BlkCnt = 12;

1064.  
1065.  

1066. /******************************************

1067. step 2: mpp system init.

1068. ******************************************/

1069. s32Ret = SAMPLE_COMM_SYS_Init(&stVbConf);

1070. if (HI_SUCCESS != s32Ret)

1071. {

1072. SAMPLE_PRT("system init failed with %d!\n", s32Ret);

1073. goto END_VENC_MJPEG_JPEG_0;

1074. }

1075.  

1076. /******************************************

1077. step 3: start vi dev & chn to capture

1078. ******************************************/

1079. stViConfig.enViMode = SENSOR_TYPE;

1080. stViConfig.enRotate = ROTATE_NONE;

1081. stViConfig.enNorm = VIDEO_ENCODING_MODE_AUTO;

1082. stViConfig.enViChnSet = VI_CHN_SET_NORMAL;

1083. s32Ret = SAMPLE_COMM_VI_StartVi(&stViConfig);

1084. if (HI_SUCCESS != s32Ret)

1085. {

1086. SAMPLE_PRT("start vi failed!\n");

1087. goto END_VENC_MJPEG_JPEG_1;

1088. }

1089.  

1090. /******************************************

1091. step 4: start vpss and vi bind vpss

1092. ******************************************/

1093. s32Ret = SAMPLE_COMM_SYS_GetPicSize(gs_enNorm, enSize, &stSize);

1094. if (HI_SUCCESS != s32Ret)

1095. {

1096. SAMPLE_PRT("SAMPLE_COMM_SYS_GetPicSize failed!\n");

1097. goto END_VENC_MJPEG_JPEG_1;

1098. }

1099.  

1100. VpssGrp = 0;

1101. stVpssGrpAttr.u32MaxW = stSize.u32Width;

1102. stVpssGrpAttr.u32MaxH = stSize.u32Height;

1103. stVpssGrpAttr.bIeEn = HI_FALSE;

1104. stVpssGrpAttr.bNrEn = HI_TRUE;

1105. stVpssGrpAttr.bHistEn = HI_FALSE;

1106. stVpssGrpAttr.enDieMode = VPSS_DIE_MODE_NODIE;

1107. stVpssGrpAttr.enPixFmt = SAMPLE_PIXEL_FORMAT;

1108. stVpssGrpAttr.bDciEn = HI_FALSE;

1109. s32Ret = SAMPLE_COMM_VPSS_StartGroup(VpssGrp, &stVpssGrpAttr);

1110. if (HI_SUCCESS != s32Ret)

1111. {

1112. SAMPLE_PRT("Start Vpss failed!\n");

1113. goto END_VENC_MJPEG_JPEG_2;

1114. }

1115.  

1116. s32Ret = SAMPLE_COMM_VI_BindVpss(stViConfig.enViMode);

1117. if (HI_SUCCESS != s32Ret)

1118. {

1119. SAMPLE_PRT("Vi bind Vpss failed!\n");

1120. goto END_VENC_MJPEG_JPEG_3;

1121. }

1122.  
1123.  

1124. VpssChn = 0;

1125. stVpssChnMode.enChnMode = VPSS_CHN_MODE_USER;

1126. stVpssChnMode.bDouble = HI_FALSE;

1127. stVpssChnMode.enPixelFormat = SAMPLE_PIXEL_FORMAT;

1128. stVpssChnMode.u32Width = stSize.u32Width;

1129. stVpssChnMode.u32Height = stSize.u32Height;

1130. stVpssChnMode.enCompressMode = COMPRESS_MODE_NONE;

1131.  

1132. memset(&stVpssChnAttr, 0, sizeof(stVpssChnAttr));

1133. stVpssChnAttr.s32SrcFrameRate = -1;

1134. stVpssChnAttr.s32DstFrameRate = -1;

1135. s32Ret = SAMPLE_COMM_VPSS_EnableChn(VpssGrp, VpssChn, &stVpssChnAttr, &stVpssChnMode, HI_NULL);

1136. if (HI_SUCCESS != s32Ret)

1137. {

1138. SAMPLE_PRT("Enable vpss chn failed!\n");

1139. goto END_VENC_MJPEG_JPEG_4;

1140. }

1141.  
1142.  

1143. VpssChn = 1;

1144. stVpssChnMode.enChnMode = VPSS_CHN_MODE_USER;

1145. stVpssChnMode.bDouble = HI_FALSE;

1146. stVpssChnMode.enPixelFormat = SAMPLE_PIXEL_FORMAT;

1147. stVpssChnMode.u32Width = stSize.u32Width;

1148. stVpssChnMode.u32Height = stSize.u32Height;

1149. stVpssChnMode.enCompressMode = COMPRESS_MODE_NONE;

1150.  

1151. memset(&stVpssChnAttr, 0, sizeof(stVpssChnAttr));

1152. stVpssChnAttr.s32SrcFrameRate = -1;

1153. stVpssChnAttr.s32DstFrameRate = -1;

1154. s32Ret = SAMPLE_COMM_VPSS_EnableChn(VpssGrp, VpssChn, &stVpssChnAttr, &stVpssChnMode, HI_NULL);

1155. if (HI_SUCCESS != s32Ret)

1156. {

1157. SAMPLE_PRT("Enable vpss chn failed!\n");

1158. goto END_VENC_MJPEG_JPEG_4;

1159. }

1160.  

1161. /******************************************

1162. step 5: start stream venc

1163. ******************************************/

1164. VpssGrp = 0;

1165. VpssChn = 0;

1166. VencChn = 0;

1167. s32Ret = SAMPLE_COMM_VENC_Start(VencChn, enPayLoad,\

1168. gs_enNorm, enSize, enRcMode,u32Profile);

1169. if (HI_SUCCESS != s32Ret)

1170. {

1171. SAMPLE_PRT("Start Venc failed!\n");

1172. goto END_VENC_MJPEG_JPEG_5;

1173. }

1174.  

1175. s32Ret = SAMPLE_COMM_VENC_BindVpss(VencChn, VpssGrp, VpssChn);

1176. if (HI_SUCCESS != s32Ret)

1177. {

1178. SAMPLE_PRT("Start Venc failed!\n");

1179. goto END_VENC_MJPEG_JPEG_5;

1180. }

1181.  

1182. VpssGrp = 0;

1183. VpssChn = 1;

1184. VencChn = 1;

1185. s32Ret = SAMPLE_COMM_VENC_SnapStart(VencChn, &stSize);

1186. if (HI_SUCCESS != s32Ret)

1187. {

1188. SAMPLE_PRT("Start snap failed!\n");

1189. goto END_VENC_MJPEG_JPEG_5;

1190. }

1191.  
1192.  

1193. s32Ret = SAMPLE_COMM_VENC_BindVpss(VencChn, VpssGrp, VpssChn);

1194. if (HI_SUCCESS != s32Ret)

1195. {

1196. SAMPLE_PRT("Start Venc failed!\n");

1197. goto END_VENC_MJPEG_JPEG_5;

1198. }

1199.  

1200. /******************************************

1201. step 6: stream venc process -- get stream, then save it to file.

1202. ******************************************/

1203. s32Ret = SAMPLE_COMM_VENC_StartGetStream(s32ChnNum);

1204. if (HI_SUCCESS != s32Ret)

1205. {

1206. SAMPLE_PRT("Start Venc failed!\n");

1207. goto END_VENC_MJPEG_JPEG_5;

1208. }

1209.  

1210. printf("press 'q' to exit sample!\nperess ENTER to capture one picture to file\n");

1211. i = 0;

1212. while ((ch = getchar()) != 'q')

1213. {

1214. s32Ret = SAMPLE_COMM_VENC_SnapProcess(VencChn);

1215. if (HI_SUCCESS != s32Ret)

1216. {

1217. printf("%s: sanp process failed!\n", __FUNCTION__);

1218. break;

1219. }

1220. printf("snap %d success!\n", i);

1221. i++;

1222. }

1223.  

1224. printf("please press ENTER to exit this sample\n");

1225. getchar();

1226. getchar();

1227.  

1228. /******************************************

1229. step 8: exit process

1230. ******************************************/

1231. SAMPLE_COMM_VENC_StopGetStream();

1232.  

1233. END_VENC_MJPEG_JPEG_5:

1234. VpssGrp = 0;

1235. VpssChn = 0;

1236. VencChn = 0;

1237. SAMPLE_COMM_VENC_UnBindVpss(VencChn, VpssGrp, VpssChn);

1238. SAMPLE_COMM_VENC_Stop(VencChn);

1239.  

1240. VpssChn = 1;

1241. VencChn = 1;

1242. SAMPLE_COMM_VENC_UnBindVpss(VencChn, VpssGrp, VpssChn);

1243. SAMPLE_COMM_VENC_Stop(VencChn);

1244. END_VENC_MJPEG_JPEG_4: //vpss stop

1245. VpssGrp = 0;

1246. VpssChn = 0;

1247. SAMPLE_COMM_VPSS_DisableChn(VpssGrp, VpssChn);

1248. VpssChn = 1;

1249. SAMPLE_COMM_VPSS_DisableChn(VpssGrp, VpssChn);

1250. END_VENC_MJPEG_JPEG_3: //vpss stop

1251. SAMPLE_COMM_VI_UnBindVpss(stViConfig.enViMode);

1252. END_VENC_MJPEG_JPEG_2: //vpss stop

1253. SAMPLE_COMM_VPSS_StopGroup(VpssGrp);

1254. END_VENC_MJPEG_JPEG_1: //vi stop

1255. SAMPLE_COMM_VI_StopVi(&stViConfig);

1256. END_VENC_MJPEG_JPEG_0: //system exit

1257. SAMPLE_COMM_SYS_Exit();

1258.  

1259. return s32Ret;

1260. }

1261.  

1262. /******************************************************************************

1263. * function : 720p snap

1264. ******************************************************************************/

1265. HI_S32 SAMPLE_VENC_LOW_DELAY(HI_VOID)

1266. {

1267. PAYLOAD_TYPE_E enPayLoad[2]= {PT_H264, PT_H264};

1268. PIC_SIZE_E enSize[2] = {PIC_HD1080, PIC_VGA};

1269. HI_U32 u32Profile = 0;

1270.  

1271. VB_CONF_S stVbConf;

1272. SAMPLE_VI_CONFIG_S stViConfig = {0};

1273. HI_U32 u32Priority;

1274.  

1275. VPSS_GRP VpssGrp;

1276. VPSS_CHN VpssChn;

1277. VPSS_GRP_ATTR_S stVpssGrpAttr;

1278. VPSS_CHN_ATTR_S stVpssChnAttr;

1279. VPSS_CHN_MODE_S stVpssChnMode;

1280. VPSS_LOW_DELAY_INFO_S stLowDelayInfo;

1281.  

1282. VENC_CHN VencChn;

1283. SAMPLE_RC_E enRcMode= SAMPLE_RC_CBR;

1284. HI_S32 s32ChnNum = 2;

1285.  

1286. HI_S32 s32Ret = HI_SUCCESS;

1287. HI_U32 u32BlkSize;

1288. SIZE_S stSize;

1289. char c;

1290.  

1291. /******************************************

1292. step 1: init sys variable

1293. ******************************************/

1294. memset(&stVbConf,0,sizeof(VB_CONF_S));

1295. stVbConf.u32MaxPoolCnt = 128;

1296.  

1297. SAMPLE_COMM_VI_GetSizeBySensor(&enSize[0]);

1298.  

1299. /*video buffer*/

1300. u32BlkSize = SAMPLE_COMM_SYS_CalcPicVbBlkSize(gs_enNorm,\

1301. enSize[0], SAMPLE_PIXEL_FORMAT, SAMPLE_SYS_ALIGN_WIDTH);

1302.  

1303. printf("u32BlkSize: %d\n", u32BlkSize);

1304. stVbConf.astCommPool[0].u32BlkSize = u32BlkSize;

1305. stVbConf.astCommPool[0].u32BlkCnt = 10;

1306.  

1307. u32BlkSize = SAMPLE_COMM_SYS_CalcPicVbBlkSize(gs_enNorm,\

1308. enSize[1], SAMPLE_PIXEL_FORMAT, SAMPLE_SYS_ALIGN_WIDTH);

1309. stVbConf.astCommPool[1].u32BlkSize = u32BlkSize;

1310. stVbConf.astCommPool[1].u32BlkCnt = 6;

1311.  

1312. /******************************************

1313. step 2: mpp system init.

1314. ******************************************/

1315. s32Ret = SAMPLE_COMM_SYS_Init(&stVbConf);

1316. if (HI_SUCCESS != s32Ret)

1317. {

1318. SAMPLE_PRT("system init failed with %d!\n", s32Ret);

1319. goto END_VENC_LOW_DELAY_0;

1320. }

1321.  

1322. /******************************************

1323. step 3: start vi dev & chn to capture

1324. ******************************************/

1325. stViConfig.enViMode = SENSOR_TYPE;

1326. stViConfig.enRotate = ROTATE_NONE;

1327. stViConfig.enNorm = VIDEO_ENCODING_MODE_AUTO;

1328. stViConfig.enViChnSet = VI_CHN_SET_NORMAL;

1329. s32Ret = SAMPLE_COMM_VI_StartVi(&stViConfig);

1330. if (HI_SUCCESS != s32Ret)

1331. {

1332. SAMPLE_PRT("start vi failed!\n");

1333. goto END_VENC_LOW_DELAY_1;

1334. }

1335.  

1336. /******************************************

1337. step 4: start vpss and vi bind vpss

1338. ******************************************/

1339. s32Ret = SAMPLE_COMM_SYS_GetPicSize(gs_enNorm, enSize[0], &stSize);

1340. if (HI_SUCCESS != s32Ret)

1341. {

1342. SAMPLE_PRT("SAMPLE_COMM_SYS_GetPicSize failed!\n");

1343. goto END_VENC_LOW_DELAY_1;

1344. }

1345.  

1346. VpssGrp = 0;

1347. stVpssGrpAttr.u32MaxW = stSize.u32Width;

1348. stVpssGrpAttr.u32MaxH = stSize.u32Height;

1349. stVpssGrpAttr.bIeEn = HI_FALSE;

1350. stVpssGrpAttr.bNrEn = HI_TRUE;

1351. stVpssGrpAttr.bHistEn = HI_FALSE;

1352. stVpssGrpAttr.bDciEn = HI_FALSE;

1353. stVpssGrpAttr.enDieMode = VPSS_DIE_MODE_NODIE;

1354. stVpssGrpAttr.enPixFmt = SAMPLE_PIXEL_FORMAT;

1355. s32Ret = SAMPLE_COMM_VPSS_StartGroup(VpssGrp, &stVpssGrpAttr);

1356. if (HI_SUCCESS != s32Ret)

1357. {

1358. SAMPLE_PRT("Start Vpss failed!\n");

1359. goto END_VENC_LOW_DELAY_2;

1360. }

1361.  

1362. s32Ret = SAMPLE_COMM_VI_BindVpss(stViConfig.enViMode);

1363. if (HI_SUCCESS != s32Ret)

1364. {

1365. SAMPLE_PRT("Vi bind Vpss failed!\n");

1366. goto END_VENC_LOW_DELAY_3;

1367. }

1368.  

1369. VpssChn = 0;

1370. stVpssChnMode.enChnMode = VPSS_CHN_MODE_USER;

1371. stVpssChnMode.bDouble = HI_FALSE;

1372. stVpssChnMode.enPixelFormat = SAMPLE_PIXEL_FORMAT;

1373. stVpssChnMode.u32Width = stSize.u32Width;

1374. stVpssChnMode.u32Height = stSize.u32Height;

1375. stVpssChnMode.enCompressMode = COMPRESS_MODE_NONE;

1376. memset(&stVpssChnAttr, 0, sizeof(stVpssChnAttr));

1377. stVpssChnAttr.s32SrcFrameRate = -1;

1378. stVpssChnAttr.s32DstFrameRate = -1;

1379. s32Ret = SAMPLE_COMM_VPSS_EnableChn(VpssGrp, VpssChn, &stVpssChnAttr, &stVpssChnMode, HI_NULL);

1380. if (HI_SUCCESS != s32Ret)

1381. {

1382. SAMPLE_PRT("Enable vpss chn failed!\n");

1383. goto END_VENC_LOW_DELAY_4;

1384. }

1385.  

1386. VpssChn = 1;

1387. stVpssChnMode.enChnMode = VPSS_CHN_MODE_USER;

1388. stVpssChnMode.bDouble = HI_FALSE;

1389. stVpssChnMode.enPixelFormat = SAMPLE_PIXEL_FORMAT;

1390. stVpssChnMode.u32Width = stSize.u32Width;

1391. stVpssChnMode.u32Height = stSize.u32Height;

1392. stVpssChnMode.enCompressMode = COMPRESS_MODE_NONE;

1393. stVpssChnAttr.s32SrcFrameRate = -1;

1394. stVpssChnAttr.s32DstFrameRate = -1;

1395. s32Ret = SAMPLE_COMM_VPSS_EnableChn(VpssGrp, VpssChn, &stVpssChnAttr, &stVpssChnMode, HI_NULL);

1396. if (HI_SUCCESS != s32Ret)

1397. {

1398. SAMPLE_PRT("Enable vpss chn failed!\n");

1399. goto END_VENC_LOW_DELAY_4;

1400. }

1401.  

1402. /******************************************

1403. step 5: start stream venc

1404. ******************************************/

1405. /*** HD1080P **/

1406. printf("\t c) cbr.\n");

1407. printf("\t v) vbr.\n");

1408. printf("\t f) fixQp\n");

1409. printf("please input choose rc mode!\n");

1410. c = getchar();

1411. switch(c)

1412. {

1413. case 'c':

1414. enRcMode = SAMPLE_RC_CBR;

1415. break;

1416. case 'v':

1417. enRcMode = SAMPLE_RC_VBR;

1418. break;

1419. case 'f':

1420. enRcMode = SAMPLE_RC_FIXQP;

1421. break;

1422. default:

1423. printf("rc mode! is invaild!\n");

1424. goto END_VENC_LOW_DELAY_4;

1425. }

1426. VpssGrp = 0;

1427. VpssChn = 0;

1428. VencChn = 0;

1429. s32Ret = SAMPLE_COMM_VENC_Start(VencChn, enPayLoad[0],\

1430. gs_enNorm, enSize[0], enRcMode,u32Profile);

1431. if (HI_SUCCESS != s32Ret)

1432. {

1433. SAMPLE_PRT("Start Venc failed!\n");

1434. goto END_VENC_LOW_DELAY_5;

1435. }

1436.  

1437. s32Ret = SAMPLE_COMM_VENC_BindVpss(VencChn, VpssGrp, VpssChn);

1438. if (HI_SUCCESS != s32Ret)

1439. {

1440. SAMPLE_PRT("Start Venc failed!\n");

1441. goto END_VENC_LOW_DELAY_5;

1442. }

1443.  

1444. /*set chnl Priority*/

1445. s32Ret = HI_MPI_VENC_GetChnlPriority(VencChn,&u32Priority);

1446. if (HI_SUCCESS != s32Ret)

1447. {

1448. SAMPLE_PRT("Get Chnl Priority failed!\n");

1449. goto END_VENC_LOW_DELAY_5;

1450. }

1451.  

1452. u32Priority = 1;

1453.  

1454. s32Ret = HI_MPI_VENC_SetChnlPriority(VencChn,u32Priority);

1455. if (HI_SUCCESS != s32Ret)

1456. {

1457. SAMPLE_PRT("Set Chnl Priority failed!\n");

1458. goto END_VENC_LOW_DELAY_5;

1459. }

1460.  

1461. /*set low delay*/

1462. #if 1

1463. s32Ret = HI_MPI_VPSS_GetLowDelayAttr(VpssGrp,VpssChn,&stLowDelayInfo);

1464. if (HI_SUCCESS != s32Ret)

1465. {

1466. SAMPLE_PRT("HI_MPI_VPSS_GetLowDelayAttr failed!\n");

1467. goto END_VENC_LOW_DELAY_5;

1468. }

1469. stLowDelayInfo.bEnable = HI_TRUE;

1470. stLowDelayInfo.u32LineCnt = stVpssChnMode.u32Height/2;

1471. s32Ret = HI_MPI_VPSS_SetLowDelayAttr(VpssGrp,VpssChn,&stLowDelayInfo);

1472. if (HI_SUCCESS != s32Ret)

1473. {

1474. SAMPLE_PRT("HI_MPI_VPSS_SetLowDelayAttr failed!\n");

1475. goto END_VENC_LOW_DELAY_5;

1476. }

1477. #endif

1478. /*** 1080p **/

1479. VpssChn = 1;

1480. VencChn = 1;

1481. s32Ret = SAMPLE_COMM_VENC_Start(VencChn, enPayLoad[1], \

1482. gs_enNorm, enSize[1], enRcMode,u32Profile);

1483. if (HI_SUCCESS != s32Ret)

1484. {

1485. SAMPLE_PRT("Start Venc failed!\n");

1486. goto END_VENC_LOW_DELAY_5;

1487. }

1488.  

1489. s32Ret = SAMPLE_COMM_VENC_BindVpss(VencChn, VpssGrp, VpssChn);

1490. if (HI_SUCCESS != s32Ret)

1491. {

1492. SAMPLE_PRT("Start Venc failed!\n");

1493. goto END_VENC_LOW_DELAY_5;

1494. }

1495.  

1496. /******************************************

1497. step 6: stream venc process -- get stream, then save it to file.

1498. ******************************************/

1499. s32Ret = SAMPLE_COMM_VENC_StartGetStream(s32ChnNum);

1500. if (HI_SUCCESS != s32Ret)

1501. {

1502. SAMPLE_PRT("Start Venc failed!\n");

1503. goto END_VENC_LOW_DELAY_5;

1504. }

1505.  

1506. printf("please press twice ENTER to exit this sample\n");

1507. getchar();

1508. getchar();

1509.  

1510. /******************************************

1511. step 7: exit process

1512. ******************************************/

1513. SAMPLE_COMM_VENC_StopGetStream();

1514.  

1515. END_VENC_LOW_DELAY_5:

1516. VpssGrp = 0;

1517.  

1518. VpssChn = 0;

1519. VencChn = 0;

1520. SAMPLE_COMM_VENC_UnBindVpss(VencChn, VpssGrp, VpssChn);

1521. SAMPLE_COMM_VENC_Stop(VencChn);

1522.  

1523. VpssChn = 1;

1524. VencChn = 1;

1525. SAMPLE_COMM_VENC_UnBindVpss(VencChn, VpssGrp, VpssChn);

1526. SAMPLE_COMM_VENC_Stop(VencChn);

1527.  

1528. SAMPLE_COMM_VI_UnBindVpss(stViConfig.enViMode);

1529. END_VENC_LOW_DELAY_4: //vpss stop

1530. VpssGrp = 0;

1531. VpssChn = 0;

1532. SAMPLE_COMM_VPSS_DisableChn(VpssGrp, VpssChn);

1533. VpssChn = 1;

1534. SAMPLE_COMM_VPSS_DisableChn(VpssGrp, VpssChn);

1535. END_VENC_LOW_DELAY_3: //vpss stop

1536. SAMPLE_COMM_VI_UnBindVpss(stViConfig.enViMode);

1537. END_VENC_LOW_DELAY_2: //vpss stop

1538. SAMPLE_COMM_VPSS_StopGroup(VpssGrp);

1539. END_VENC_LOW_DELAY_1: //vi stop

1540. SAMPLE_COMM_VI_StopVi(&stViConfig);

1541. END_VENC_LOW_DELAY_0: //system exit

1542. SAMPLE_COMM_SYS_Exit();

1543.  

1544. return s32Ret;

1545. }

1546.  
1547.  

1548. HI_S32 SAMPLE_VENC_ROIBG_CLASSIC(HI_VOID)

1549. {

1550. PAYLOAD_TYPE_E enPayLoad= PT_H264;

1551. PIC_SIZE_E enSize[3] = {PIC_HD1080,PIC_HD720,PIC_D1};

1552. HI_U32 u32Profile = 0;

1553.  

1554. VB_CONF_S stVbConf;

1555. SAMPLE_VI_CONFIG_S stViConfig = {0};

1556.  

1557. VPSS_GRP VpssGrp;

1558. VPSS_CHN VpssChn;

1559. VPSS_GRP_ATTR_S stVpssGrpAttr;

1560. VPSS_CHN_ATTR_S stVpssChnAttr;

1561. VPSS_CHN_MODE_S stVpssChnMode;

1562. VENC_ROI_CFG_S stVencRoiCfg;

1563. VENC_ROIBG_FRAME_RATE_S stRoiBgFrameRate;

1564.  

1565. VENC_CHN VencChn;

1566. SAMPLE_RC_E enRcMode= SAMPLE_RC_CBR;

1567. HI_S32 s32ChnNum = 1;

1568.  

1569. HI_S32 s32Ret = HI_SUCCESS;

1570. HI_U32 u32BlkSize;

1571. SIZE_S stSize;

1572. char c;

1573.  

1574. /******************************************

1575. step 1: init sys variable

1576. ******************************************/

1577. memset(&stVbConf,0,sizeof(VB_CONF_S));

1578. SAMPLE_COMM_VI_GetSizeBySensor(&enSize[0]);

1579.  

1580. stVbConf.u32MaxPoolCnt = 128;

1581.  

1582. /*video buffer*/

1583. u32BlkSize = SAMPLE_COMM_SYS_CalcPicVbBlkSize(gs_enNorm,\

1584. enSize[0], SAMPLE_PIXEL_FORMAT, SAMPLE_SYS_ALIGN_WIDTH);

1585. stVbConf.astCommPool[0].u32BlkSize = u32BlkSize;

1586. stVbConf.astCommPool[0].u32BlkCnt = 10;

1587.  

1588. u32BlkSize = SAMPLE_COMM_SYS_CalcPicVbBlkSize(gs_enNorm,\

1589. enSize[1], SAMPLE_PIXEL_FORMAT, SAMPLE_SYS_ALIGN_WIDTH);

1590. stVbConf.astCommPool[1].u32BlkSize = u32BlkSize;

1591. stVbConf.astCommPool[1].u32BlkCnt = 6;

1592.  

1593. u32BlkSize = SAMPLE_COMM_SYS_CalcPicVbBlkSize(gs_enNorm,\

1594. enSize[2], SAMPLE_PIXEL_FORMAT, SAMPLE_SYS_ALIGN_WIDTH);

1595. stVbConf.astCommPool[2].u32BlkSize = u32BlkSize;

1596. stVbConf.astCommPool[2].u32BlkCnt = 6;

1597.  
1598.  

1599. /******************************************

1600. step 2: mpp system init.

1601. ******************************************/

1602. s32Ret = SAMPLE_COMM_SYS_Init(&stVbConf);

1603. if (HI_SUCCESS != s32Ret)

1604. {

1605. SAMPLE_PRT("system init failed with %d!\n", s32Ret);

1606. goto END_VENC_1080P_CLASSIC_0;

1607. }

1608.  

1609. /******************************************

1610. step 3: start vi dev & chn to capture

1611. ******************************************/

1612. stViConfig.enViMode = SENSOR_TYPE;

1613. stViConfig.enRotate = ROTATE_NONE;

1614. stViConfig.enNorm = VIDEO_ENCODING_MODE_AUTO;

1615. stViConfig.enViChnSet = VI_CHN_SET_NORMAL;

1616. s32Ret = SAMPLE_COMM_VI_StartVi(&stViConfig);

1617. if (HI_SUCCESS != s32Ret)

1618. {

1619. SAMPLE_PRT("start vi failed!\n");

1620. goto END_VENC_1080P_CLASSIC_1;

1621. }

1622.  

1623. /******************************************

1624. step 4: start vpss and vi bind vpss

1625. ******************************************/

1626. s32Ret = SAMPLE_COMM_SYS_GetPicSize(gs_enNorm, enSize[0], &stSize);

1627. if (HI_SUCCESS != s32Ret)

1628. {

1629. SAMPLE_PRT("SAMPLE_COMM_SYS_GetPicSize failed!\n");

1630. goto END_VENC_1080P_CLASSIC_1;

1631. }

1632.  

1633. VpssGrp = 0;

1634. stVpssGrpAttr.u32MaxW = stSize.u32Width;

1635. stVpssGrpAttr.u32MaxH = stSize.u32Height;

1636. stVpssGrpAttr.bIeEn = HI_FALSE;

1637. stVpssGrpAttr.bNrEn = HI_TRUE;

1638. stVpssGrpAttr.bHistEn = HI_FALSE;

1639. stVpssGrpAttr.bDciEn = HI_FALSE;

1640. stVpssGrpAttr.enDieMode = VPSS_DIE_MODE_NODIE;

1641. stVpssGrpAttr.enPixFmt = SAMPLE_PIXEL_FORMAT;

1642. s32Ret = SAMPLE_COMM_VPSS_StartGroup(VpssGrp, &stVpssGrpAttr);

1643. if (HI_SUCCESS != s32Ret)

1644. {

1645. SAMPLE_PRT("Start Vpss failed!\n");

1646. goto END_VENC_1080P_CLASSIC_2;

1647. }

1648.  

1649. s32Ret = SAMPLE_COMM_VI_BindVpss(stViConfig.enViMode);

1650. if (HI_SUCCESS != s32Ret)

1651. {

1652. SAMPLE_PRT("Vi bind Vpss failed!\n");

1653. goto END_VENC_1080P_CLASSIC_3;

1654. }

1655.  

1656. VpssChn = 0;

1657. stVpssChnMode.enChnMode = VPSS_CHN_MODE_USER;

1658. stVpssChnMode.bDouble = HI_FALSE;

1659. stVpssChnMode.enPixelFormat = SAMPLE_PIXEL_FORMAT;

1660. stVpssChnMode.u32Width = stSize.u32Width;

1661. stVpssChnMode.u32Height = stSize.u32Height;

1662. stVpssChnMode.enCompressMode = COMPRESS_MODE_NONE;

1663. memset(&stVpssChnAttr, 0, sizeof(stVpssChnAttr));

1664. stVpssChnAttr.s32SrcFrameRate = -1;

1665. stVpssChnAttr.s32DstFrameRate = -1;

1666. s32Ret = SAMPLE_COMM_VPSS_EnableChn(VpssGrp, VpssChn, &stVpssChnAttr, &stVpssChnMode, HI_NULL);

1667. if (HI_SUCCESS != s32Ret)

1668. {

1669. SAMPLE_PRT("Enable vpss chn failed!\n");

1670. goto END_VENC_1080P_CLASSIC_4;

1671. }

1672.  

1673. /******************************************

1674. step 5: start stream venc

1675. ******************************************/

1676. /*** HD1080P **/

1677. printf("\t c) cbr.\n");

1678. printf("\t v) vbr.\n");

1679. printf("\t f) fixQp\n");

1680. printf("please input choose rc mode!\n");

1681. c = getchar();

1682. switch(c)

1683. {

1684. case 'c':

1685. enRcMode = SAMPLE_RC_CBR;

1686. break;

1687. case 'v':

1688. enRcMode = SAMPLE_RC_VBR;

1689. break;

1690. case 'f':

1691. enRcMode = SAMPLE_RC_FIXQP;

1692. break;

1693. default:

1694. printf("rc mode! is invaild!\n");

1695. goto END_VENC_1080P_CLASSIC_4;

1696. }

1697. VpssGrp = 0;

1698. VpssChn = 0;

1699. VencChn = 0;

1700. s32Ret = SAMPLE_COMM_VENC_Start(VencChn, enPayLoad,\

1701. gs_enNorm, enSize[0], enRcMode,u32Profile);

1702. if (HI_SUCCESS != s32Ret)

1703. {

1704. SAMPLE_PRT("Start Venc failed!\n");

1705. goto END_VENC_1080P_CLASSIC_5;

1706. }

1707.  

1708. s32Ret = SAMPLE_COMM_VENC_BindVpss(VencChn, VpssGrp, VpssChn);

1709. if (HI_SUCCESS != s32Ret)

1710. {

1711. SAMPLE_PRT("Start Venc failed!\n");

1712. goto END_VENC_1080P_CLASSIC_5;

1713. }

1714. stVencRoiCfg.bAbsQp = HI_TRUE;

1715. stVencRoiCfg.bEnable = HI_TRUE;

1716. stVencRoiCfg.s32Qp = 30;

1717. stVencRoiCfg.u32Index = 0;

1718. stVencRoiCfg.stRect.s32X = 64;

1719. stVencRoiCfg.stRect.s32Y = 64;

1720. stVencRoiCfg.stRect.u32Height =256;

1721. stVencRoiCfg.stRect.u32Width =256;

1722. s32Ret = HI_MPI_VENC_SetRoiCfg(VencChn,&stVencRoiCfg);

1723. if (HI_SUCCESS != s32Ret)

1724. {

1725. SAMPLE_PRT("Start Venc failed!\n");

1726. goto END_VENC_1080P_CLASSIC_5;

1727. }

1728.  

1729. s32Ret = HI_MPI_VENC_GetRoiBgFrameRate(VencChn,&stRoiBgFrameRate);

1730. if (HI_SUCCESS != s32Ret)

1731. {

1732. SAMPLE_PRT("HI_MPI_VENC_GetRoiBgFrameRate failed!\n");

1733. goto END_VENC_1080P_CLASSIC_5;

1734. }

1735. stRoiBgFrameRate.s32SrcFrmRate = (VIDEO_ENCODING_MODE_PAL== gs_enNorm)?25:30;

1736. stRoiBgFrameRate.s32DstFrmRate = (VIDEO_ENCODING_MODE_PAL== gs_enNorm)?5:15;

1737.  

1738. s32Ret = HI_MPI_VENC_SetRoiBgFrameRate(VencChn,&stRoiBgFrameRate);

1739. if (HI_SUCCESS != s32Ret)

1740. {

1741. SAMPLE_PRT("HI_MPI_VENC_SetRoiBgFrameRate!\n");

1742. goto END_VENC_1080P_CLASSIC_5;

1743. }

1744. /******************************************

1745. step 6: stream venc process -- get stream, then save it to file.

1746. ******************************************/

1747. s32Ret = SAMPLE_COMM_VENC_StartGetStream(s32ChnNum);

1748. if (HI_SUCCESS != s32Ret)

1749. {

1750. SAMPLE_PRT("Start Venc failed!\n");

1751. goto END_VENC_1080P_CLASSIC_5;

1752. }

1753.  

1754. printf("please press ENTER to exit this sample\n");

1755. getchar();

1756. getchar();

1757.  

1758. /******************************************

1759. step 7: exit process

1760. ******************************************/

1761. SAMPLE_COMM_VENC_StopGetStream();

1762.  

1763. END_VENC_1080P_CLASSIC_5:

1764. VpssGrp = 0;

1765.  

1766. VpssChn = 0;

1767. VencChn = 0;

1768. SAMPLE_COMM_VENC_UnBindVpss(VencChn, VpssGrp, VpssChn);

1769. SAMPLE_COMM_VENC_Stop(VencChn);

1770.  
1771.  
1772.  

1773. SAMPLE_COMM_VI_UnBindVpss(stViConfig.enViMode);

1774. END_VENC_1080P_CLASSIC_4: //vpss stop

1775. VpssGrp = 0;

1776. VpssChn = 0;

1777. SAMPLE_COMM_VPSS_DisableChn(VpssGrp, VpssChn);

1778. END_VENC_1080P_CLASSIC_3: //vpss stop

1779. SAMPLE_COMM_VI_UnBindVpss(stViConfig.enViMode);

1780. END_VENC_1080P_CLASSIC_2: //vpss stop

1781. SAMPLE_COMM_VPSS_StopGroup(VpssGrp);

1782. END_VENC_1080P_CLASSIC_1: //vi stop

1783. SAMPLE_COMM_VI_StopVi(&stViConfig);

1784. END_VENC_1080P_CLASSIC_0: //system exit

1785. SAMPLE_COMM_SYS_Exit();

1786.  

1787. return s32Ret;

1788. }

1789.  

1790. HI_S32 SAMPLE_VENC_SVC_H264(HI_VOID)

1791. {

1792. PAYLOAD_TYPE_E enPayLoad= PT_H264;

1793. PIC_SIZE_E enSize[3] = {PIC_HD1080,PIC_HD720,PIC_D1};

1794. HI_U32 u32Profile = 3;/* Svc-t */

1795.  

1796. VB_CONF_S stVbConf;

1797. SAMPLE_VI_CONFIG_S stViConfig = {0};

1798.  

1799. VPSS_GRP VpssGrp;

1800. VPSS_CHN VpssChn;

1801. VPSS_GRP_ATTR_S stVpssGrpAttr;

1802. VPSS_CHN_ATTR_S stVpssChnAttr;

1803. VPSS_CHN_MODE_S stVpssChnMode;

1804.  
1805.  

1806. VENC_CHN VencChn;

1807. SAMPLE_RC_E enRcMode= SAMPLE_RC_CBR;

1808. HI_S32 s32ChnNum = 1;

1809.  

1810. HI_S32 s32Ret = HI_SUCCESS;

1811. HI_U32 u32BlkSize;

1812. SIZE_S stSize;

1813. char c;

1814.  

1815. /******************************************

1816. step 1: init sys variable

1817. ******************************************/

1818. memset(&stVbConf, 0, sizeof(VB_CONF_S));

1819.  

1820. SAMPLE_COMM_VI_GetSizeBySensor(&enSize[0]);

1821.  

1822. stVbConf.u32MaxPoolCnt = 128;

1823.  

1824. /*video buffer*/

1825. u32BlkSize = SAMPLE_COMM_SYS_CalcPicVbBlkSize(gs_enNorm,\

1826. enSize[0], SAMPLE_PIXEL_FORMAT, SAMPLE_SYS_ALIGN_WIDTH);

1827. stVbConf.astCommPool[0].u32BlkSize = u32BlkSize;

1828. stVbConf.astCommPool[0].u32BlkCnt = 10;

1829.  

1830. u32BlkSize = SAMPLE_COMM_SYS_CalcPicVbBlkSize(gs_enNorm,\

1831. enSize[1], SAMPLE_PIXEL_FORMAT, SAMPLE_SYS_ALIGN_WIDTH);

1832. stVbConf.astCommPool[1].u32BlkSize = u32BlkSize;

1833. stVbConf.astCommPool[1].u32BlkCnt = 6;

1834.  

1835. u32BlkSize = SAMPLE_COMM_SYS_CalcPicVbBlkSize(gs_enNorm,\

1836. enSize[2], SAMPLE_PIXEL_FORMAT, SAMPLE_SYS_ALIGN_WIDTH);

1837. stVbConf.astCommPool[2].u32BlkSize = u32BlkSize;

1838. stVbConf.astCommPool[2].u32BlkCnt = 6;

1839.  
1840.  

1841. /******************************************

1842. step 2: mpp system init.

1843. ******************************************/

1844. s32Ret = SAMPLE_COMM_SYS_Init(&stVbConf);

1845. if (HI_SUCCESS != s32Ret)

1846. {

1847. SAMPLE_PRT("system init failed with %d!\n", s32Ret);

1848. goto END_VENC_1080P_CLASSIC_0;

1849. }

1850.  

1851. /******************************************

1852. step 3: start vi dev & chn to capture

1853. ******************************************/

1854. stViConfig.enViMode = SENSOR_TYPE;

1855. stViConfig.enRotate = ROTATE_NONE;

1856. stViConfig.enNorm = VIDEO_ENCODING_MODE_AUTO;

1857. stViConfig.enViChnSet = VI_CHN_SET_NORMAL;

1858. s32Ret = SAMPLE_COMM_VI_StartVi(&stViConfig);

1859. if (HI_SUCCESS != s32Ret)

1860. {

1861. SAMPLE_PRT("start vi failed!\n");

1862. goto END_VENC_1080P_CLASSIC_1;

1863. }

1864.  

1865. /******************************************

1866. step 4: start vpss and vi bind vpss

1867. ******************************************/

1868. s32Ret = SAMPLE_COMM_SYS_GetPicSize(gs_enNorm, enSize[0], &stSize);

1869. if (HI_SUCCESS != s32Ret)

1870. {

1871. SAMPLE_PRT("SAMPLE_COMM_SYS_GetPicSize failed!\n");

1872. goto END_VENC_1080P_CLASSIC_1;

1873. }

1874.  

1875. VpssGrp = 0;

1876. stVpssGrpAttr.u32MaxW = stSize.u32Width;

1877. stVpssGrpAttr.u32MaxH = stSize.u32Height;

1878. stVpssGrpAttr.bIeEn = HI_FALSE;

1879. stVpssGrpAttr.bNrEn = HI_TRUE;

1880. stVpssGrpAttr.bHistEn = HI_FALSE;

1881. stVpssGrpAttr.bDciEn = HI_FALSE;

1882. stVpssGrpAttr.enDieMode = VPSS_DIE_MODE_NODIE;

1883. stVpssGrpAttr.enPixFmt = SAMPLE_PIXEL_FORMAT;

1884. s32Ret = SAMPLE_COMM_VPSS_StartGroup(VpssGrp, &stVpssGrpAttr);

1885. if (HI_SUCCESS != s32Ret)

1886. {

1887. SAMPLE_PRT("Start Vpss failed!\n");

1888. goto END_VENC_1080P_CLASSIC_2;

1889. }

1890.  

1891. s32Ret = SAMPLE_COMM_VI_BindVpss(stViConfig.enViMode);

1892. if (HI_SUCCESS != s32Ret)

1893. {

1894. SAMPLE_PRT("Vi bind Vpss failed!\n");

1895. goto END_VENC_1080P_CLASSIC_3;

1896. }

1897.  

1898. VpssChn = 0;

1899. stVpssChnMode.enChnMode = VPSS_CHN_MODE_USER;

1900. stVpssChnMode.bDouble = HI_FALSE;

1901. stVpssChnMode.enPixelFormat = SAMPLE_PIXEL_FORMAT;

1902. stVpssChnMode.u32Width = stSize.u32Width;

1903. stVpssChnMode.u32Height = stSize.u32Height;

1904. stVpssChnMode.enCompressMode = COMPRESS_MODE_NONE;

1905. memset(&stVpssChnAttr, 0, sizeof(stVpssChnAttr));

1906. stVpssChnAttr.s32SrcFrameRate = -1;

1907. stVpssChnAttr.s32DstFrameRate = -1;

1908. s32Ret = SAMPLE_COMM_VPSS_EnableChn(VpssGrp, VpssChn, &stVpssChnAttr, &stVpssChnMode, HI_NULL);

1909. if (HI_SUCCESS != s32Ret)

1910. {

1911. SAMPLE_PRT("Enable vpss chn failed!\n");

1912. goto END_VENC_1080P_CLASSIC_4;

1913. }

1914.  

1915. /******************************************

1916. step 5: start stream venc

1917. ******************************************/

1918. /*** HD1080P **/

1919. printf("\t c) cbr.\n");

1920. printf("\t v) vbr.\n");

1921. printf("\t f) fixQp\n");

1922. printf("please input choose rc mode!\n");

1923. c = getchar();

1924. switch(c)

1925. {

1926. case 'c':

1927. enRcMode = SAMPLE_RC_CBR;

1928. break;

1929. case 'v':

1930. enRcMode = SAMPLE_RC_VBR;

1931. break;

1932. case 'f':

1933. enRcMode = SAMPLE_RC_FIXQP;

1934. break;

1935. default:

1936. printf("rc mode! is invaild!\n");

1937. goto END_VENC_1080P_CLASSIC_4;

1938. }

1939. VpssGrp = 0;

1940. VpssChn = 0;

1941. VencChn = 0;

1942. s32Ret = SAMPLE_COMM_VENC_Start(VencChn, enPayLoad,\

1943. gs_enNorm, enSize[0], enRcMode,u32Profile);

1944.  

1945. printf("SAMPLE_COMM_VENC_Start is ok\n");

1946.  

1947. if (HI_SUCCESS != s32Ret)

1948. {

1949. SAMPLE_PRT("Start Venc failed!\n");

1950. goto END_VENC_1080P_CLASSIC_5;

1951. }

1952.  

1953. s32Ret = SAMPLE_COMM_VENC_BindVpss(VencChn, VpssGrp, VpssChn);

1954.  

1955. printf("SAMPLE_COMM_VENC_BindVpss is ok\n");

1956.  
1957.  

1958. if (HI_SUCCESS != s32Ret)

1959. {

1960. SAMPLE_PRT("Start Venc failed!\n");

1961. goto END_VENC_1080P_CLASSIC_5;

1962. }

1963.  

1964. /******************************************

1965. step 6: stream venc process -- get stream, then save it to file.

1966. ******************************************/

1967. s32Ret = SAMPLE_COMM_VENC_StartGetStream_Svc_t(s32ChnNum);

1968.  

1969. if (HI_SUCCESS != s32Ret)

1970. {

1971. SAMPLE_PRT("Start Venc failed!\n");

1972. goto END_VENC_1080P_CLASSIC_5;

1973. }

1974.  

1975. printf("please press ENTER to exit this sample\n");

1976. getchar();

1977. getchar();

1978.  

1979. /******************************************

1980. step 7: exit process

1981. ******************************************/

1982. SAMPLE_COMM_VENC_StopGetStream();

1983.  

1984. printf("SAMPLE_COMM_VENC_StopGetStream is ok\n");

1985. END_VENC_1080P_CLASSIC_5:

1986. VpssGrp = 0;

1987.  

1988. VpssChn = 0;

1989. VencChn = 0;

1990. SAMPLE_COMM_VENC_UnBindVpss(VencChn, VpssGrp, VpssChn);

1991. SAMPLE_COMM_VENC_Stop(VencChn);

1992.  
1993.  
1994.  

1995. SAMPLE_COMM_VI_UnBindVpss(stViConfig.enViMode);

1996. END_VENC_1080P_CLASSIC_4: //vpss stop

1997. VpssGrp = 0;

1998. VpssChn = 0;

1999. SAMPLE_COMM_VPSS_DisableChn(VpssGrp, VpssChn);

2000. END_VENC_1080P_CLASSIC_3: //vpss stop

2001. SAMPLE_COMM_VI_UnBindVpss(stViConfig.enViMode);

2002. END_VENC_1080P_CLASSIC_2: //vpss stop

2003. SAMPLE_COMM_VPSS_StopGroup(VpssGrp);

2004. END_VENC_1080P_CLASSIC_1: //vi stop

2005. SAMPLE_COMM_VI_StopVi(&stViConfig);

2006. END_VENC_1080P_CLASSIC_0: //system exit

2007. SAMPLE_COMM_SYS_Exit();

2008. return s32Ret;

2009. }

2010. #endif

2011.  

2012. static char const* dateHeader()

2013. {

2014. static char buf[200];

2015. #if !defined(_WIN32_WCE)

2016. time_t tt = time(NULL);

2017. strftime(buf, sizeof buf, "Date: %a, %b %d %Y %H:%M:%S GMT\r\n", gmtime(&tt));

2018. #endif

2019.  

2020. return buf;

2021. }

2022. static char* GetLocalIP(int sock)

2023. {

2024. struct ifreq ifreq;

2025. struct sockaddr_in *sin;

2026. char * LocalIP = malloc(20);

2027. strcpy(ifreq.ifr_name,"eth0");

2028. if (!(ioctl (sock, SIOCGIFADDR,&ifreq)))

2029. {

2030. sin = (struct sockaddr_in *)&ifreq.ifr_addr;

2031. sin->sin_family = AF_INET;

2032. strcpy(LocalIP,inet_ntoa(sin->sin_addr));

2033. //inet_ntop(AF_INET, &sin->sin_addr,LocalIP, 16);

2034. }

2035. printf("--------------------------------------------%s\n",LocalIP);

2036. return LocalIP;

2037. }

2038.  

2039. char* strDupSize(char const* str)

2040. {

2041. if (str == NULL) return NULL;

2042. size_t len = strlen(str) + 1;

2043. char* copy = malloc(len);

2044.  

2045. return copy;

2046. }

2047.  
2048.  

2049. int ParseRequestString(char const* reqStr,

2050. unsigned reqStrSize,

2051. char* resultCmdName,

2052. unsigned resultCmdNameMaxSize,

2053. char* resultURLPreSuffix,

2054. unsigned resultURLPreSuffixMaxSize,

2055. char* resultURLSuffix,

2056. unsigned resultURLSuffixMaxSize,

2057. char* resultCSeq,

2058. unsigned resultCSeqMaxSize)

2059. {

2060. // This parser is currently rather dumb; it should be made smarter #####

2061.  

2062. // Read everything up to the first space as the command name:

2063. int parseSucceeded = FALSE;

2064. unsigned i;

2065. for (i = 0; i < resultCmdNameMaxSize-1 && i < reqStrSize; ++i) {

2066. char c = reqStr[i];

2067. if (c == ' ' || c == '\t') {

2068. parseSucceeded = TRUE;

2069. break;

2070. }

2071.  

2072. resultCmdName[i] = c;

2073. }

2074. resultCmdName[i] = '\0';

2075. if (!parseSucceeded) return FALSE;

2076.  

2077. // Skip over the prefix of any "rtsp://" or "rtsp:/" URL that follows:

2078. unsigned j = i+1;

2079. while (j < reqStrSize && (reqStr[j] == ' ' || reqStr[j] == '\t')) ++j; // skip over any additional white space

2080. for (j = i+1; j < reqStrSize-8; ++j) {

2081. if ((reqStr[j] == 'r' || reqStr[j] == 'R')

2082. && (reqStr[j+1] == 't' || reqStr[j+1] == 'T')

2083. && (reqStr[j+2] == 's' || reqStr[j+2] == 'S')

2084. && (reqStr[j+3] == 'p' || reqStr[j+3] == 'P')

2085. && reqStr[j+4] == ':' && reqStr[j+5] == '/') {

2086. j += 6;

2087. if (reqStr[j] == '/') {

2088. // This is a "rtsp://" URL; skip over the host:port part that follows:

2089. ++j;

2090. while (j < reqStrSize && reqStr[j] != '/' && reqStr[j] != ' ') ++j;

2091. } else {

2092. // This is a "rtsp:/" URL; back up to the "/":

2093. --j;

2094. }

2095. i = j;

2096. break;

2097. }

2098. }

2099.  

2100. // Look for the URL suffix (before the following "RTSP/"):

2101. parseSucceeded = FALSE;

2102. unsigned k;

2103. for (k = i+1; k < reqStrSize-5; ++k) {

2104. if (reqStr[k] == 'R' && reqStr[k+1] == 'T' &&

2105. reqStr[k+2] == 'S' && reqStr[k+3] == 'P' && reqStr[k+4] == '/') {

2106. while (--k >= i && reqStr[k] == ' ') {} // go back over all spaces before "RTSP/"

2107. unsigned k1 = k;

2108. while (k1 > i && reqStr[k1] != '/' && reqStr[k1] != ' ') --k1;

2109. // the URL suffix comes from [k1+1,k]

2110.  

2111. // Copy "resultURLSuffix":

2112. if (k - k1 + 1 > resultURLSuffixMaxSize) return FALSE; // there's no room

2113. unsigned n = 0, k2 = k1+1;

2114. while (k2 <= k) resultURLSuffix[n++] = reqStr[k2++];

2115. resultURLSuffix[n] = '\0';

2116.  

2117. // Also look for the URL 'pre-suffix' before this:

2118. unsigned k3 = --k1;

2119. while (k3 > i && reqStr[k3] != '/' && reqStr[k3] != ' ') --k3;

2120. // the URL pre-suffix comes from [k3+1,k1]

2121.  

2122. // Copy "resultURLPreSuffix":

2123. if (k1 - k3 + 1 > resultURLPreSuffixMaxSize) return FALSE; // there's no room

2124. n = 0; k2 = k3+1;

2125. while (k2 <= k1) resultURLPreSuffix[n++] = reqStr[k2++];

2126. resultURLPreSuffix[n] = '\0';

2127.  

2128. i = k + 7; // to go past " RTSP/"

2129. parseSucceeded = TRUE;

2130. break;

2131. }

2132. }

2133. if (!parseSucceeded) return FALSE;

2134.  

2135. // Look for "CSeq:", skip whitespace,

2136. // then read everything up to the next \r or \n as 'CSeq':

2137. parseSucceeded = FALSE;

2138. for (j = i; j < reqStrSize-5; ++j) {

2139. if (reqStr[j] == 'C' && reqStr[j+1] == 'S' && reqStr[j+2] == 'e' &&

2140. reqStr[j+3] == 'q' && reqStr[j+4] == ':') {

2141. j += 5;

2142. unsigned n;

2143. while (j < reqStrSize && (reqStr[j] == ' ' || reqStr[j] == '\t')) ++j;

2144. for (n = 0; n < resultCSeqMaxSize-1 && j < reqStrSize; ++n,++j) {

2145. char c = reqStr[j];

2146. if (c == '\r' || c == '\n') {

2147. parseSucceeded = TRUE;

2148. break;

2149. }

2150.  

2151. resultCSeq[n] = c;

2152. }

2153. resultCSeq[n] = '\0';

2154. break;

2155. }

2156. }

2157. if (!parseSucceeded) return FALSE;

2158.  

2159. return TRUE;

2160. }

2161.  

2162. int OptionAnswer(char *cseq, int sock)

2163. {

2164. if (sock != 0)

2165. {

2166. char buf[1024];

2167. memset(buf,0,1024);

2168. char *pTemp = buf;

2169. pTemp += sprintf(pTemp,"RTSP/1.0 200 OK\r\nCSeq: %s\r\n%sPublic: %s\r\n\r\n",

2170. cseq,dateHeader(),"OPTIONS,DESCRIBE,SETUP,PLAY,PAUSE,TEARDOWN");

2171.  

2172. int reg = send(sock, buf,strlen(buf),0);

2173. if(reg <= 0)

2174. {

2175. return FALSE;

2176. }

2177. else

2178. {

2179. printf(">>>>>%s\n",buf);

2180. }

2181. return TRUE;

2182. }

2183. return FALSE;

2184. }

2185.  
2186.  

2187. int DescribeAnswer(char *cseq,int sock,char * urlSuffix,char* recvbuf)

2188. {

2189. if (sock != 0)

2190. {

2191. char sdpMsg[1024];

2192. char buf[2048];

2193. memset(buf,0,2048);

2194. memset(sdpMsg,0,1024);

2195. char*localip;

2196. localip = GetLocalIP(sock);

2197.  

2198. char *pTemp = buf;

2199. pTemp += sprintf(pTemp,"RTSP/1.0 200 OK\r\nCSeq: %s\r\n",cseq);

2200. pTemp += sprintf(pTemp,"%s",dateHeader());

2201. pTemp += sprintf(pTemp,"Content-Type: application/sdp\r\n");

2202.  

2203. //TODO 掳?貌?D?1矛???渭???a?藟矛??渭

2204. char *pTemp2 = sdpMsg;

2205. pTemp2 += sprintf(pTemp2,"v=0\r\n");

2206. pTemp2 += sprintf(pTemp2,"o=StreamingServer 3331435948 1116907222000 IN IP4 %s\r\n",localip);

2207. pTemp2 += sprintf(pTemp2,"s=H.265\r\n");

2208. pTemp2 += sprintf(pTemp2,"c=IN IP4 0.0.0.0\r\n");

2209. pTemp2 += sprintf(pTemp2,"t=0 0\r\n");

2210. pTemp2 += sprintf(pTemp2,"a=control:*\r\n");

2211.  

2212. /*锚贸?渭??矛??猫锚?*/

2213. /*H264 TrackID=0 RTP_PT 96*/

2214. pTemp2 += sprintf(pTemp2,"m=video 0 RTP/AVP 96\r\n");

2215. pTemp2 += sprintf(pTemp2,"a=control:track1\r\n");

2216. pTemp2 += sprintf(pTemp2,"a=rtpmap:96 H265/90000\r\n");

2217. //pTemp2 += sprintf(pTemp2,"a=fmtp:96 packetization-mode=1; sprop-parameter-sets=%s\r\n", "AAABBCCC");

2218. pTemp2 += sprintf(pTemp2,"a=fmtp:96 profile-space=0;profile-id=1;tier-flag=0;level-id=123;interop-constraints=B00000000000;");

2219. pTemp2 += sprintf(pTemp2,"sprop-vps=QAEMAf//AWAAAAMAsAAAAwAAAwB7qgJA;sprop-sps=QgEBAWAAAAMAsAAAAwAAAwB7oAPAgBDljaqSTL5A;sprop-pps=RAHA8vA8kA==\r\n");

2220. #if 1

2221. /*貌??渭??矛??猫锚?*/

2222. /*G726*/

2223. /*TODO 貌??渭*/

2224. pTemp2 += sprintf(pTemp2,"m=audio 0 RTP/AVP 97\r\n");

2225. pTemp2 += sprintf(pTemp2,"a=control:trackID=1\r\n");

2226. if(strcmp(g_rtp_playload,"AAC")==0)

2227. {

2228. pTemp2 += sprintf(pTemp2,"a=rtpmap:97 MPEG4-GENERIC/%d/2\r\n",16000);

2229. 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");

2230. }

2231. else

2232. {

2233. pTemp2 += sprintf(pTemp2,"a=rtpmap:97 G726-32/%d/1\r\n",8000);

2234. pTemp2 += sprintf(pTemp2,"a=fmtp:97 packetization-mode=1\r\n");

2235. }

2236. #endif

2237. pTemp += sprintf(pTemp,"Content-length: %d\r\n", strlen(sdpMsg));

2238. pTemp += sprintf(pTemp,"Content-Base: rtsp://%s/%s/\r\n\r\n",localip,urlSuffix);

2239.  

2240. //printf("mem ready\n");

2241. strcat(pTemp, sdpMsg);

2242. free(localip);

2243. //printf("Describe ready sent\n");

2244. int re = send(sock, buf, strlen(buf),0);

2245. if(re <= 0)

2246. {

2247. return FALSE;

2248. }

2249. else

2250. {

2251. printf(">>>>>%s\n",buf);

2252. }

2253. }

2254.  

2255. return TRUE;

2256. }

2257.  

2258. void ParseTransportHeader(char const* buf,

2259. StreamingMode* streamingMode,

2260. char**streamingModeString,

2261. char**destinationAddressStr,

2262. u_int8_t* destinationTTL,

2263. portNumBits* clientRTPPortNum, // if UDP

2264. portNumBits* clientRTCPPortNum, // if UDP

2265. unsigned char* rtpChannelId, // if TCP

2266. unsigned char* rtcpChannelId // if TCP

2267. )

2268. {

2269. // Initialize the result parameters to default values:

2270. *streamingMode = RTP_UDP;

2271. *streamingModeString = NULL;

2272. *destinationAddressStr = NULL;

2273. *destinationTTL = 255;

2274. *clientRTPPortNum = 0;

2275. *clientRTCPPortNum = 1;

2276. *rtpChannelId = *rtcpChannelId = 0xFF;

2277.  

2278. portNumBits p1, p2;

2279. unsigned ttl, rtpCid, rtcpCid;

2280.  

2281. // First, find "Transport:"

2282. while (1) {

2283. if (*buf == '\0') return; // not found

2284. if (strncasecmp(buf, "Transport: ", 11) == 0) break;

2285. ++buf;

2286. }

2287.  

2288. // Then, run through each of the fields, looking for ones we handle:

2289. char const* fields = buf + 11;

2290. char* field = strDupSize(fields);

2291. while (sscanf(fields, "%[^;]", field) == 1) {

2292. if (strcmp(field, "RTP/AVP/TCP") == 0) {

2293. *streamingMode = RTP_TCP;

2294. } else if (strcmp(field, "RAW/RAW/UDP") == 0 ||

2295. strcmp(field, "MP2T/H2221/UDP") == 0) {

2296. *streamingMode = RAW_UDP;

2297. //*streamingModeString = strDup(field);

2298. } else if (strncasecmp(field, "destination=", 12) == 0)

2299. {

2300. //delete[] destinationAddressStr;

2301. free(destinationAddressStr);

2302. //destinationAddressStr = strDup(field+12);

2303. } else if (sscanf(field, "ttl%u", &ttl) == 1) {

2304. destinationTTL = (u_int8_t)ttl;

2305. } else if (sscanf(field, "client_port=%hu-%hu", &p1, &p2) == 2) {

2306. *clientRTPPortNum = p1;

2307. *clientRTCPPortNum = p2;

2308. } else if (sscanf(field, "client_port=%hu", &p1) == 1) {

2309. *clientRTPPortNum = p1;

2310. *clientRTCPPortNum = streamingMode == RAW_UDP ? 0 : p1 + 1;

2311. } else if (sscanf(field, "interleaved=%u-%u", &rtpCid, &rtcpCid) == 2) {

2312. *rtpChannelId = (unsigned char)rtpCid;

2313. *rtcpChannelId = (unsigned char)rtcpCid;

2314. }

2315.  

2316. fields += strlen(field);

2317. while (*fields == ';') ++fields; // skip over separating ';' chars

2318. if (*fields == '\0' || *fields == '\r' || *fields == '\n') break;

2319. }

2320. free(field);

2321. }

2322.  

2323. int SetupAnswer(char *cseq,int sock,int SessionId,char * urlSuffix,char* recvbuf,int* rtpport, int* rtcpport)

2324. {

2325. if (sock != 0)

2326. {

2327. char buf[1024];

2328. memset(buf,0,1024);

2329.  

2330. StreamingMode streamingMode;

2331. char* streamingModeString; // set when RAW_UDP streaming is specified

2332. char* clientsDestinationAddressStr;

2333. u_int8_t clientsDestinationTTL;

2334. portNumBits clientRTPPortNum, clientRTCPPortNum;

2335. unsigned char rtpChannelId, rtcpChannelId;

2336. ParseTransportHeader(recvbuf,&streamingMode, &streamingModeString,

2337. &clientsDestinationAddressStr, &clientsDestinationTTL,

2338. &clientRTPPortNum, &clientRTCPPortNum,

2339. &rtpChannelId, &rtcpChannelId);

2340.  

2341. //Port clientRTPPort(clientRTPPortNum);

2342. //Port clientRTCPPort(clientRTCPPortNum);

2343. *rtpport = clientRTPPortNum;

2344. *rtcpport = clientRTCPPortNum;

2345.  

2346. char *pTemp = buf;

2347. char*localip;

2348. localip = GetLocalIP(sock);

2349. 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",

2350. cseq,dateHeader(),localip,

2351. ntohs(htons(clientRTPPortNum)),

2352. ntohs(htons(clientRTCPPortNum)),

2353. ntohs(2000),

2354. ntohs(2001),

2355. SessionId);

2356.  

2357. free(localip);

2358. int reg = send(sock, buf,strlen(buf),0);

2359. if(reg <= 0)

2360. {

2361. return FALSE;

2362. }

2363. else

2364. {

2365. printf(">>>>>%s",buf);

2366. }

2367. return TRUE;

2368. }

2369. return FALSE;

2370. }

2371.  

2372. int PlayAnswer(char *cseq, int sock,int SessionId,char* urlPre,char* recvbuf)

2373. {

2374. if (sock != 0)

2375. {

2376. char buf[1024];

2377. memset(buf,0,1024);

2378. char *pTemp = buf;

2379. char*localip;

2380. localip = GetLocalIP(sock);

2381. 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",

2382. cseq,dateHeader(),SessionId,localip,urlPre);

2383.  

2384. free(localip);

2385.  

2386. int reg = send(sock, buf,strlen(buf),0);

2387. if(reg <= 0)

2388. {

2389. return FALSE;

2390. }

2391. else

2392. {

2393. printf(">>>>>%s",buf);

2394. }

2395. return TRUE;

2396. }

2397. return FALSE;

2398. }

2399.  
2400.  
2401.  

2402. int PauseAnswer(char *cseq,int sock,char *recvbuf)

2403. {

2404. if (sock != 0)

2405. {

2406. char buf[1024];

2407. memset(buf,0,1024);

2408. char *pTemp = buf;

2409. pTemp += sprintf(pTemp,"RTSP/1.0 200 OK\r\nCSeq: %s\r\n%s\r\n\r\n",

2410. cseq,dateHeader());

2411.  

2412. int reg = send(sock, buf,strlen(buf),0);

2413. if(reg <= 0)

2414. {

2415. return FALSE;

2416. }

2417. else

2418. {

2419. printf(">>>>>%s",buf);

2420. }

2421. return TRUE;

2422. }

2423. return FALSE;

2424. }

2425.  

2426. int TeardownAnswer(char *cseq,int sock,int SessionId,char *recvbuf)

2427. {

2428. if (sock != 0)

2429. {

2430. char buf[1024];

2431. memset(buf,0,1024);

2432. char *pTemp = buf;

2433. pTemp += sprintf(pTemp,"RTSP/1.0 200 OK\r\nCSeq: %s\r\n%sSession: %d\r\n\r\n",

2434. cseq,dateHeader(),SessionId);

2435.  

2436. int reg = send(sock, buf,strlen(buf),0);

2437. if(reg <= 0)

2438. {

2439. return FALSE;

2440. }

2441. else

2442. {

2443. printf(">>>>>%s",buf);

2444. }

2445. return TRUE;

2446. }

2447. return FALSE;

2448. }

2449.  
2450.  

2451. void * RtspClientMsg(void*pParam)

2452. {

2453. pthread_detach(pthread_self());

2454. int nRes;

2455. char pRecvBuf[RTSP_RECV_SIZE];

2456. RTSP_CLIENT * pClient = (RTSP_CLIENT*)pParam;

2457. memset(pRecvBuf,0,sizeof(pRecvBuf));

2458. printf("RTSP:-----Create Client %s\n",pClient->IP);

2459. while(pClient->status != RTSP_IDLE)

2460. {

2461. nRes = recv(pClient->socket, pRecvBuf, RTSP_RECV_SIZE,0);

2462. //printf("-------------------%d\n",nRes);

2463. if(nRes < 1)

2464. {

2465. //usleep(1000);

2466. printf("RTSP:Recv Error--- %d\n",nRes);

2467. g_rtspClients[pClient->index].status = RTSP_IDLE;

2468. g_rtspClients[pClient->index].seqnum = 0;

2469. g_rtspClients[pClient->index].tsvid = 0;

2470. g_rtspClients[pClient->index].tsaud = 0;

2471. close(pClient->socket);

2472. break;

2473. }

2474. char cmdName[PARAM_STRING_MAX];

2475. char urlPreSuffix[PARAM_STRING_MAX];

2476. char urlSuffix[PARAM_STRING_MAX];

2477. char cseq[PARAM_STRING_MAX];

2478.  

2479. ParseRequestString(pRecvBuf,nRes,cmdName,sizeof(cmdName),urlPreSuffix,sizeof(urlPreSuffix),

2480. urlSuffix,sizeof(urlSuffix),cseq,sizeof(cseq));

2481.  

2482. char *p = pRecvBuf;

2483.  

2484. printf("<<<<<%s\n",p);

2485.  

2486. //printf("\--------------------------\n");

2487. //printf("%s %s\n",urlPreSuffix,urlSuffix);

2488.  

2489. if(strstr(cmdName, "OPTIONS"))

2490. {

2491. OptionAnswer(cseq,pClient->socket);

2492. }

2493. else if(strstr(cmdName, "DESCRIBE"))

2494. {

2495. DescribeAnswer(cseq,pClient->socket,urlSuffix,p);

2496. //printf("-----------------------------DescribeAnswer %s %s\n",

2497. // urlPreSuffix,urlSuffix);

2498. }

2499. else if(strstr(cmdName, "SETUP"))

2500. {

2501. int rtpport,rtcpport;

2502. int trackID=0;

2503. SetupAnswer(cseq,pClient->socket,pClient->sessionid,urlPreSuffix,p,&rtpport,&rtcpport);

2504.  

2505. sscanf(urlSuffix, "trackID=%u", &trackID);

2506. //printf("----------------------------------------------TrackId %d\n",trackID);

2507. if(trackID<0 || trackID>=2)trackID=0;

2508. g_rtspClients[pClient->index].rtpport[trackID] = rtpport;

2509. g_rtspClients[pClient->index].rtcpport= rtcpport;

2510. g_rtspClients[pClient->index].reqchn = atoi(urlPreSuffix);

2511. if(strlen(urlPreSuffix)<100)

2512. strcpy(g_rtspClients[pClient->index].urlPre,urlPreSuffix);

2513. //printf("-----------------------------SetupAnswer %s-%d-%d\n",

2514. // urlPreSuffix,g_rtspClients[pClient->index].reqchn,rtpport);

2515. }

2516. else if(strstr(cmdName, "PLAY"))

2517. {

2518. PlayAnswer(cseq,pClient->socket,pClient->sessionid,g_rtspClients[pClient->index].urlPre,p);

2519. g_rtspClients[pClient->index].status = RTSP_SENDING;

2520. printf("Start Play\n",pClient->index);

2521. //printf("-----------------------------PlayAnswer %d %d\n",pClient->index);

2522. //usleep(100);

2523. }

2524. else if(strstr(cmdName, "PAUSE"))

2525. {

2526. PauseAnswer(cseq,pClient->socket,p);

2527. }

2528. else if(strstr(cmdName, "TEARDOWN"))

2529. {

2530. TeardownAnswer(cseq,pClient->socket,pClient->sessionid,p);

2531. g_rtspClients[pClient->index].status = RTSP_IDLE;

2532. g_rtspClients[pClient->index].seqnum = 0;

2533. g_rtspClients[pClient->index].tsvid = 0;

2534. g_rtspClients[pClient->index].tsaud = 0;

2535. close(pClient->socket);

2536. }

2537. if(exitok){ exitok++;return NULL; }

2538. }

2539. printf("RTSP:-----Exit Client %s\n",pClient->IP);

2540. return NULL;

2541. }

2542.  

2543. void * RtspServerListen(void*pParam)

2544. {

2545. int s32Socket;

2546. struct sockaddr_in servaddr;

2547. int s32CSocket;

2548. int s32Rtn;

2549. int s32Socket_opt_value = 1;

2550. int nAddrLen;

2551. struct sockaddr_in addrAccept;

2552. int bResult;

2553.  

2554. memset(&servaddr, 0, sizeof(servaddr));

2555. servaddr.sin_family = AF_INET;

2556. servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

2557. servaddr.sin_port = htons(RTSP_SERVER_PORT);

2558.  

2559. s32Socket = socket(AF_INET, SOCK_STREAM, 0);

2560.  

2561. if (setsockopt(s32Socket ,SOL_SOCKET,SO_REUSEADDR,&s32Socket_opt_value,sizeof(int)) == -1)

2562. {

2563. return (void *)(-1);

2564. }

2565. s32Rtn = bind(s32Socket, (struct sockaddr *)&servaddr, sizeof(struct sockaddr_in));

2566. if(s32Rtn < 0)

2567. {

2568. return (void *)(-2);

2569. }

2570.  

2571. s32Rtn = listen(s32Socket, 50); /*50,脳??贸渭?谩??贸锚y*/

2572. if(s32Rtn < 0)

2573. {

2574.  

2575. return (void *)(-2);

2576. }

2577.  
2578.  

2579. nAddrLen = sizeof(struct sockaddr_in);

2580. int nSessionId = 1000;

2581. while ((s32CSocket = accept(s32Socket, (struct sockaddr*)&addrAccept, &nAddrLen)) >= 0)

2582. {

2583. printf("<<<<RTSP Client %s Connected...\n", inet_ntoa(addrAccept.sin_addr));

2584.  

2585. int nMaxBuf = 10 * 1024; // ?渭铆3???谩路??? 2 x nMaxBuf 渭??o3??贸D?

2586. if(setsockopt(s32CSocket, SOL_SOCKET, SO_SNDBUF, (char*)&nMaxBuf, sizeof(nMaxBuf)) == -1)

2587. printf("RTSP:!!!!!! Enalarge socket sending buffer error !!!!!!\n");

2588. int i;

2589. int bAdd=FALSE;

2590. for(i=0;i<MAX_RTSP_CLIENT;i++)

2591. {

2592. if(g_rtspClients[i].status == RTSP_IDLE)

2593. {

2594. memset(&g_rtspClients[i],0,sizeof(RTSP_CLIENT));

2595. g_rtspClients[i].index = i;

2596. g_rtspClients[i].socket = s32CSocket;

2597. g_rtspClients[i].status = RTSP_CONNECTED ;//RTSP_SENDING;

2598. g_rtspClients[i].sessionid = nSessionId++;

2599. strcpy(g_rtspClients[i].IP,inet_ntoa(addrAccept.sin_addr));

2600. pthread_t threadIdlsn = 0;

2601.  

2602. struct sched_param sched;

2603. sched.sched_priority = 1;

2604. //to return ACKecho

2605. pthread_create(&threadIdlsn, NULL, RtspClientMsg, &g_rtspClients[i]);

2606. pthread_setschedparam(threadIdlsn,SCHED_RR,&sched);

2607.  

2608. bAdd = TRUE;

2609. break;

2610. }

2611. }

2612. if(bAdd==FALSE)

2613. {

2614. memset(&g_rtspClients[0],0,sizeof(RTSP_CLIENT));

2615. g_rtspClients[0].index = 0;

2616. g_rtspClients[0].socket = s32CSocket;

2617. g_rtspClients[0].status = RTSP_CONNECTED ;//RTSP_SENDING;

2618. g_rtspClients[0].sessionid = nSessionId++;

2619. strcpy(g_rtspClients[0].IP,inet_ntoa(addrAccept.sin_addr));

2620. pthread_t threadIdlsn = 0;

2621. struct sched_param sched;

2622. sched.sched_priority = 1;

2623. //to return ACKecho

2624. pthread_create(&threadIdlsn, NULL, RtspClientMsg, &g_rtspClients[0]);

2625. pthread_setschedparam(threadIdlsn,SCHED_RR,&sched);

2626. bAdd = TRUE;

2627. }

2628. if(exitok){ exitok++;return NULL; }

2629. }

2630. if(s32CSocket < 0)

2631. {

2632. // HI_OUT_Printf(0, "RTSP listening on port %d,accept err, %d\n", RTSP_SERVER_PORT, s32CSocket);

2633. }

2634.  

2635. printf("----- INIT_RTSP_Listen() Exit !! \n");

2636.  

2637. return NULL;

2638. }

2639.  

2640. void InitRtspServer()

2641. {

2642. int i;

2643. pthread_t threadId = 0;

2644. for(i=0;i<MAX_CHAN;i++)

2645. {

2646. memset(&g_rtpPack[i],0,sizeof(RTSP_PACK));

2647. g_rtpPack[i].bIsFree = TRUE;

2648. //g_rtpPack.bWaitIFrm = TRUE;

2649. memset(&g_FrmPack[i],0,sizeof(FRAME_PACK));

2650. }

2651. memset(g_rtp_playload,0,sizeof(g_rtp_playload));

2652. strcpy(g_rtp_playload,"G726-32");

2653. g_audio_rate = 8000;

2654. pthread_mutex_init(&g_sendmutex,NULL);

2655. pthread_mutex_init(&g_mutex,NULL);

2656. pthread_cond_init(&g_cond,NULL);

2657. memset(g_rtspClients,0,sizeof(RTSP_CLIENT)*MAX_RTSP_CLIENT);

2658.  

2659. //pthread_create(&g_SendDataThreadId, NULL, SendDataThread, NULL);

2660.  

2661. struct sched_param thdsched;

2662. thdsched.sched_priority = 2;

2663. //to listen visiting

2664. pthread_create(&threadId, NULL, RtspServerListen, NULL);

2665. pthread_setschedparam(threadId,SCHED_RR,&thdsched);

2666. printf("RTSP:-----Init Rtsp server\n");

2667.  

2668. HI_S32 s32Ret;

2669. // s32Ret = SAMPLE_VENC_720P_CLASSIC();

2670. s32Ret = SAMPLE_VENC_1080P_CLASSIC();

2671. //exit

2672. if (HI_SUCCESS == s32Ret)

2673. printf("program exit normally!\n");

2674. else

2675. printf("program exit abnormally!\n");

2676. exitok++;

2677.  

2678. }

2679.  

2680. int loop()

2681. {

2682. while(1)

2683. {

2684. usleep(1000);

2685. if(exitok>0)exitok++;

2686. if(exitok>10)exit(0);

2687. }

2688. return 1;

2689.  
2690.  

2691. }

2692.  

2693. /******************************************************************************

2694. * function : main()

2695. * Description : video venc sample

2696. ******************************************************************************/

2697. int main(int argc, char *argv[])

2698. {

2699. HI_S32 s32Ret;

2700.  

2701. InitRtspServer();

2702. loop();

2703. /* H.264@1080p@30fps+H.265@1080p@30fps+H.264@D1@30fps */

2704. // s32Ret = SAMPLE_VENC_1080P_CLASSIC();

2705.  

2706. /* 1*1080p mjpeg encode + 1*1080p jpeg */

2707. // s32Ret = SAMPLE_VENC_1080P_MJPEG_JPEG();

2708.  

2709. /* low delay */

2710. //s32Ret = SAMPLE_VENC_LOW_DELAY();

2711.  

2712. /* roibg framerate */

2713. //s32Ret = SAMPLE_VENC_ROIBG_CLASSIC();

2714.  

2715. /* H.264 Svc-t */

2716. //s32Ret = SAMPLE_VENC_SVC_H264();

2717.  

2718. //if (HI_SUCCESS == s32Ret)

2719. // printf("program exit normally!\n");

2720. //else

2721. // printf("program exit abnormally!\n");

2722. //exit(s32Ret);

2723. }

2724.  

2725. #ifdef __cplusplus

2726. #if __cplusplus

2727. }

2728. #endif

2729. #endif /* End of #ifdef __cplusplus */