You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

580 lines
22 KiB

  1. #include "../XNetSDKTest.h"
  2. #include "Simplify_Encode.h"
  3. #include "XNetSDKSyn.h"
  4. #include "EncodeCapability.h"
  5. #include "SystemFunction.h"
  6. USE_NS_NETSDK_CFG
  7. #define IFRAME_EQ_PFRAME 10
  8. #define BITMSK(bit) (int)(1 << (bit))
  9. typedef struct
  10. {
  11. unsigned long dwSize;
  12. unsigned long dsMask;
  13. }SResolution;
  14. enum
  15. {
  16. MAIN_STREAM = 0,
  17. EXPAND_STREAM,
  18. COMBINE_STREAM,
  19. STREAM_NUM,
  20. };
  21. static SResolution m_resolution[CAPTURE_IMAGE_SIZE_EXT_V3_NR];
  22. static int STREAM_CODE_VALUE[CAPTURE_IMAGE_SIZE_EXT_V3_NR][6] = {
  23. {512, 768, 1024, 1536, 2048, 2560}, ///< D1
  24. {384, 512, 768, 1024, 1536, 2048}, ///< HD1
  25. {384, 512, 768, 1024, 1536, 2048}, ///< BCIF
  26. {64, 192, 384, 512, 768, 1024}, ///< CIF
  27. {64, 128, 192, 384, 448, 512}, ///< QCIF
  28. {512, 768, 896, 1280, 1536, 2048}, ///< VGA
  29. {256, 384, 512, 640, 768, 1024}, ///< QVGA
  30. {512, 768, 896, 1280, 1536, 2048}, ///< SVCD
  31. {64, 128, 192, 384, 448, 512}, ///< QQVGA
  32. {64, 128, 256, 448, 512, 768}, ///< ND1
  33. {896, 1024, 1536, 2048, 3072, 4096}, ///< 650TVL
  34. {1024,1536, 2048, 2560, 3072, 4096}, ///< 720P
  35. {1024,1536, 2048, 3072, 4096, 5120}, ///< 1_3M
  36. {1024,2048, 3072, 4096, 6144, 8192}, ///< UXGA
  37. {1024,2048, 3072, 4096, 6144, 8192}, ///< 1080P
  38. {1177,2355, 3532, 4710, 7065, 10240}, ///< WUXGA
  39. {1280,2560, 3840, 5120, 7680, 10240}, ///< 2_5M
  40. {1536, 3072, 4096, 6144, 8192, 10240}, ///< 3M
  41. {2048, 3072, 4096, 6144, 8192,10240}, ///5M
  42. {1024,1536, 2048, 2560, 3072, 4096}, ///< 1080N
  43. {1536, 3072, 4096, 6144, 8192, 10240}, ///< 4M
  44. {1536, 3072, 4096, 6144, 8192, 10240}, ///< 6M
  45. {1536, 3072, 4096, 6144, 8192, 10240}, ///< 8M
  46. {1536, 3072, 4096, 6144, 8192, 10240}, ///< 12M
  47. {2048, 4096, 6144, 8192, 11264, 13312}, ///< 4K
  48. {512, 768, 1024, 1536, 2048, 2560}, ///< 720N
  49. {1024,1536, 2048, 2560, 3072, 4096}, ///< WSVGA
  50. {512, 768, 896, 1280, 1536, 2048}, ///< NHD
  51. {1024,1536, 2048, 3072, 4096, 5120}, ///< 3M_N
  52. {1024,2048, 3072, 4096, 6144, 8192}, ///< 4M_N
  53. {1280, 2560, 3840, 5120, 7680, 10240}, ///< 5M_N
  54. {1536, 3072, 4096, 6144, 8192, 10240}, ///< 4K_N
  55. };
  56. //大小眼睛的低码率
  57. static int LOWBITRATE_STREAM_CODE_VALUE[CAPTURE_IMAGE_SIZE_EXT_V3_NR][6] = {
  58. {384, 576, 768, 1152, 1536, 1920}, ///< D1
  59. {384, 512, 768, 1024, 1536, 2048}, ///< HD1
  60. {384, 512, 768, 1024, 1536, 2048}, ///< BCIF
  61. {48, 144, 288, 384, 576, 768}, ///< CIF
  62. {48, 96, 144, 288, 336, 384}, ///< QCIF
  63. {512, 768, 896, 1280, 1536, 2048}, ///< VGA
  64. {256, 384, 512, 640, 768, 1024}, ///< QVGA
  65. {512, 768, 896, 1280, 1536, 2048}, ///< SVCD
  66. {64, 128, 192, 384, 448, 512}, ///< QQVGA
  67. {64, 128, 256, 448, 512, 768}, ///< ND1
  68. {896, 1024, 1536, 2048, 3072, 4096}, ///< 960H
  69. {768, 1152, 1536, 1920, 2304, 3072}, ///< 720P
  70. {1024,1536, 2048, 3072, 4096, 5120}, ///< 960P
  71. {1024,2048, 3072, 4096, 6144, 8192}, ///< UXGA
  72. {1024,2048, 3072, 4096, 6144, 8192}, ///< 1080P
  73. {640, 1024, 1536, 2048, 3072, 4096}, ///< WUXGA
  74. {640, 1024, 1536, 2048, 3072, 4096}, ///< 2_5M
  75. {640, 1024, 1536, 2048, 3072, 4096}, ///< 3M
  76. {720, 1024, 1536, 2048, 3072, 5120}, ///< 5M
  77. {0,0, 0, 0, 0, 0}, ///< 1080N
  78. {0, 0, 0, 0, 0, 0}, ///< 4M
  79. {0,0,0,0,0,0}, //6M
  80. {0,0,0,0,0,0}, //8M
  81. {0,0,0,0,0,0}, //12M
  82. {0,0,0,0,0,0}, //4K
  83. {0, 0, 0, 0, 0, 0}, ///< 720N
  84. {0,0,0,0,0,0}, //RES1
  85. {0,0,0,0,0,0}, //RES2
  86. {0,0,0,0,0,0}, //RES3
  87. {0,0,0,0,0,0}, //RES4
  88. {0,0,0,0,0,0}, //RES5
  89. {0,0,0,0,0,0}, //RES6
  90. };
  91. static int FISHEYE_STREAM_CODE_VALUE[CAPTURE_IMAGE_SIZE_EXT_V3_NR][6] = {
  92. {512, 768, 1024, 1536, 2048, 2560}, ///< D1
  93. {384, 512, 768, 1024, 1536, 2048}, ///< HD1
  94. {384, 512, 768, 1024, 1536, 2048}, ///< BCIF
  95. {64, 192, 384, 512, 768, 1024}, ///< CIF
  96. {64, 128, 192, 384, 448, 512}, ///< QCIF
  97. {512, 768, 896, 1280, 1536, 2048}, ///< VGA
  98. {256, 384, 512, 640, 768, 1024}, ///< QVGA
  99. {512, 768, 896, 1280, 1536, 2048}, ///< SVCD
  100. {64, 128, 192, 384, 448, 512}, ///< QQVGA
  101. {64, 128, 256, 448, 512, 768}, ///< ND1
  102. {896, 1024, 1536, 2048, 3072, 4096}, ///< 650TVL
  103. {1536, 2048, 2560, 3072, 4096, 6096}, ///< 720P
  104. {1024,1536, 2048, 3072, 4096, 5120}, ///< 1_3M
  105. {1024,2048, 3072, 4096, 6144, 8192}, ///< UXGA
  106. {1024,2048, 3072, 4096, 6144, 8192}, ///< 1080P
  107. {1177,2355, 3532, 4710, 7065, 10240}, ///< WUXGA
  108. {1280,2560, 3840, 5120, 7680, 10240}, ///< 2_5M
  109. {1536, 3072, 4096, 6144, 8192, 10240}, ///< 3M
  110. {2048, 3072, 4096, 6144, 8192,10240}, ///5M
  111. {1024,1536, 2048, 2560, 3072, 4096}, ///< 1080N
  112. {1536, 3072, 4096, 6144, 8192, 10240}, ///< 4M
  113. {0,0,0,0,0,0}, //6M
  114. {0,0,0,0,0,0}, //8M
  115. {0,0,0,0,0,0}, //12M
  116. {0,0,0,0,0,0}, //4K
  117. {512, 768, 1024, 1536, 2048, 2560}, ///< 720N
  118. {1024,1536, 2048, 2560, 3072, 4096}, ///< WSVGA
  119. {0,0,0,0,0,0}, //RES2
  120. {0,0,0,0,0,0}, //RES3
  121. {0,0,0,0,0,0}, //RES4
  122. {0,0,0,0,0,0}, //RES5
  123. {0,0,0,0,0,0}, //RES6
  124. };
  125. static int H265_STREAM_CODE_VALUE[CAPTURE_IMAGE_SIZE_EXT_V3_NR][6] = {
  126. {332, 499, 665, 998, 1331, 1664}, ///< D1
  127. {249, 332, 499, 665, 998, 1331}, ///< HD1
  128. {249, 332, 499, 665, 998, 1331}, ///< BCIF
  129. {41, 124, 249, 332, 499, 665}, ///< CIF
  130. {41, 83, 124, 249, 291, 332}, ///< QCIF
  131. {332, 499, 582, 832, 998, 1331}, ///< VGA
  132. {166, 249, 332, 416, 499, 665}, ///< QVGA
  133. {332, 499, 582, 832, 998, 1331}, ///< SVCD
  134. {41, 83, 124, 249, 291, 332}, ///< QQVGA
  135. {41, 83, 166, 291, 332, 499}, ///< ND1
  136. {582, 665, 998, 1331, 1996, 2662}, ///< 650TVL
  137. {665,998, 1331, 1664, 1996, 2662}, ///< 720P
  138. {665,998, 1331, 1996, 2662, 3328}, ///< 1_3M
  139. {665,1331, 1996, 2662, 3993, 5324}, ///< UXGA
  140. {665,1331, 1996, 2662, 3993, 5324}, ///< 1080P
  141. {765,1530, 2295, 3061, 4592, 6656}, ///< WUXGA
  142. {832,1664, 2496, 3328, 4992, 6656}, ///< 2_5M
  143. {998, 1996, 2662, 3993, 5324, 6656}, ///< 3M
  144. {1331, 1996, 2662, 3993, 5324,6656}, ///5M
  145. {665,998, 1331, 1664, 1996, 2662}, ///< 1080N
  146. {998, 1996, 2662, 3993, 5324, 6656}, ///< 4M
  147. {998, 1996, 2662, 3993, 5324, 6656}, ///< 6M
  148. {998, 1996, 2662, 3993, 5324, 6656}, ///< 8M
  149. {998, 1996, 2662, 3993, 5324, 6656}, ///< 12M
  150. {1331, 2662, 3993, 5324, 7321, 8652}, ///< 4K
  151. {332, 499, 665, 998, 1331, 1664}, ///< 720N
  152. {582, 665, 998, 1331, 1996, 2662}, ///< WSVGA(1024*576)
  153. {332, 499, 582, 832, 998, 1327}, ///< NHD
  154. {665,998, 1331, 1996, 2662, 3328}, ///< 3M_N
  155. {665,1331, 1996, 2662, 3993, 5324}, ///< 4M_N
  156. {832, 1664, 2496, 3328, 4992, 6656}, ///< 5M_N
  157. {1331, 1996, 2665, 3993, 5324, 6656}, ///< 4K_N
  158. };
  159. //函数说明:计算码固定码率支持的码流值
  160. //参数说明:
  161. //dstFormat : 媒体格式
  162. //bLowBitrate : 是否支持大小眼
  163. //bLowBitrate : 是否支持鱼眼
  164. //bH265Bitrate : 是否支持h265
  165. void CalculateCodeStreamValue(SDK_VIDEO_FORMAT * vfSetFormat, bool bLowBitrate, bool bFisheyeBitrate, bool bH265Bitrate)
  166. {
  167. int j = 0;
  168. int nTmpFPS = 0;
  169. int nFPS = 25;
  170. nTmpFPS = min(vfSetFormat->nFPS, nFPS);
  171. int iBitrate = 0;
  172. if(bLowBitrate)
  173. {
  174. for (j = 0; j < sizeof(LOWBITRATE_STREAM_CODE_VALUE[vfSetFormat->iResolution]) / sizeof(int); ++j)
  175. {
  176. iBitrate = LOWBITRATE_STREAM_CODE_VALUE[vfSetFormat->iResolution][j] * (vfSetFormat->iGOP * nTmpFPS + IFRAME_EQ_PFRAME - 1) / (vfSetFormat->iGOP * nFPS + IFRAME_EQ_PFRAME - 1);
  177. printf("Support iBitrate[%d] = %d\r\n", j, iBitrate);
  178. }
  179. }
  180. else if(bFisheyeBitrate)
  181. {
  182. for (j = 0; j < sizeof(FISHEYE_STREAM_CODE_VALUE[vfSetFormat->iResolution]) / sizeof(int); ++j)
  183. {
  184. iBitrate = FISHEYE_STREAM_CODE_VALUE[vfSetFormat->iResolution][j] * (vfSetFormat->iGOP * nTmpFPS + IFRAME_EQ_PFRAME - 1) / (vfSetFormat->iGOP * nFPS + IFRAME_EQ_PFRAME - 1);
  185. printf("Support iBitrate[%d] = %d\r\n", j, iBitrate);
  186. }
  187. }
  188. else if(bH265Bitrate)
  189. {
  190. for (j = 0; j < sizeof(H265_STREAM_CODE_VALUE[vfSetFormat->iResolution]) / sizeof(int); ++j)
  191. {
  192. iBitrate = H265_STREAM_CODE_VALUE[vfSetFormat->iResolution][j] * (vfSetFormat->iGOP * nTmpFPS + IFRAME_EQ_PFRAME - 1) / (vfSetFormat->iGOP * nFPS + IFRAME_EQ_PFRAME - 1);
  193. printf("Support iBitrate[%d] = %d\r\n", j, iBitrate);
  194. }
  195. }
  196. else
  197. {
  198. for (j = 0; j < sizeof(STREAM_CODE_VALUE[vfSetFormat->iResolution]) / sizeof(int); ++j)
  199. {
  200. iBitrate = STREAM_CODE_VALUE[vfSetFormat->iResolution][j] * (vfSetFormat->iGOP * nTmpFPS + IFRAME_EQ_PFRAME - 1) / (vfSetFormat->iGOP * nFPS + IFRAME_EQ_PFRAME - 1);
  201. printf("Support iBitrate[%d] = %d\r\n", j, iBitrate);
  202. }
  203. }
  204. }
  205. void GetMaxResolAndRate(int &nResolu, int &nRate, long lFreePower)
  206. {
  207. if ( lFreePower <= 0 )
  208. {
  209. return;
  210. }
  211. int nSize = m_resolution[nResolu].dwSize;
  212. if ( nSize > lFreePower )
  213. {
  214. nResolu = -1;
  215. nRate = -1;
  216. return;
  217. }
  218. else
  219. {
  220. int nTempRate = lFreePower / nSize;
  221. if ( nTempRate > 25 )
  222. {
  223. nTempRate = 25;
  224. }
  225. nRate = nTempRate;
  226. }
  227. long lMaxSize = nSize;
  228. for ( int i = 0; i < CAPTURE_IMAGE_SIZE_EXT_V3_NR; i ++ )
  229. {
  230. long lTempsize = m_resolution[i].dwSize;
  231. if ( lFreePower >= lTempsize && lMaxSize < lTempsize )
  232. {
  233. nResolu = i;
  234. lMaxSize = lTempsize;
  235. }
  236. }
  237. }
  238. void GetSupportRes(int maxSize, unsigned long dwMask )
  239. {
  240. for (int i = 0; i < CAPTURE_IMAGE_SIZE_EXT_V3_NR ; i ++)
  241. {
  242. if ( (m_resolution[i].dwSize <= m_resolution[maxSize].dwSize )
  243. && ( dwMask & (0x01<<i) ) )
  244. {
  245. printf("m_resolution[%d]\r\n", i);
  246. }
  247. }
  248. }
  249. int TestEncodeConfig()
  250. {
  251. printf("%s\r\n", __FUNCTION__);
  252. char c = 0;
  253. int nRet = 0;
  254. bool bSupport = false;
  255. char szOutBuffer[40960] = {0};
  256. int nInOutSize = sizeof(szOutBuffer);
  257. int nResult = 0;
  258. int nCompression;
  259. int nMainStreamResolution = 0;
  260. unsigned long ulMask = 0;
  261. int nQuality = 0;
  262. int nGop = 0;
  263. int nFps = 0;
  264. bool m_bH265Bitrate[STREAM_NUM];
  265. bool m_bMultiStream = false;
  266. bool m_bLowBitrate = false;
  267. bool m_bFisheyeBitrate = false;
  268. m_bH265Bitrate[MAIN_STREAM] = false;
  269. m_bH265Bitrate[EXPAND_STREAM] = false;
  270. m_bH265Bitrate[COMBINE_STREAM] = false;
  271. unsigned long lFreePower = 0;
  272. ///////////////////////////////////现有支持的所有分辨率/////////////////////////////////
  273. m_resolution[CAPTURE_IMAGE_SIZE_D1].dwSize = 704 * 480;
  274. m_resolution[CAPTURE_IMAGE_SIZE_HD1].dwSize = 704 * 240;
  275. m_resolution[CAPTURE_IMAGE_SIZE_BCIF].dwSize = 352 * 480;
  276. m_resolution[CAPTURE_IMAGE_SIZE_CIF].dwSize = 352 * 240;
  277. m_resolution[CAPTURE_IMAGE_SIZE_QCIF].dwSize = 176 * 120;
  278. m_resolution[CAPTURE_IMAGE_SIZE_VGA].dwSize = 640 * 480;
  279. m_resolution[CAPTURE_IMAGE_SIZE_QVGA].dwSize = 320 * 240;
  280. m_resolution[CAPTURE_IMAGE_SIZE_SVCD].dwSize = 480 * 480;
  281. m_resolution[CAPTURE_IMAGE_SIZE_QQVGA].dwSize = 160 * 128;
  282. m_resolution[CAPTURE_IMAGE_SIZE_ND1].dwSize = 240*192;
  283. m_resolution[CAPTURE_IMAGE_SIZE_650TVL].dwSize = 928*480;
  284. m_resolution[CAPTURE_IMAGE_SIZE_720P].dwSize = 1280*720;
  285. m_resolution[CAPTURE_IMAGE_SIZE_1_3M].dwSize = 1280*960;
  286. m_resolution[CAPTURE_IMAGE_SIZE_UXGA].dwSize = 1600*1200;
  287. m_resolution[CAPTURE_IMAGE_SIZE_1080P].dwSize = 1920*1080;
  288. m_resolution[CAPTURE_IMAGE_SIZE_WUXGA].dwSize = 1920*1200;
  289. m_resolution[CAPTURE_IMAGE_SIZE_2_5M].dwSize = 1872*1408;
  290. m_resolution[CAPTURE_IMAGE_SIZE_3M].dwSize = 2048*1536;
  291. m_resolution[CAPTURE_IMAGE_SIZE_5M].dwSize = 3744*1408;
  292. m_resolution[CAPTURE_IMAGE_SIZE_1080N].dwSize = 944*1080;
  293. m_resolution[CAPTURE_IMAGE_SIZE_4M].dwSize = 2592*1520;
  294. m_resolution[CAPTURE_IMAGE_SIZE_6M].dwSize = 3072*2048;
  295. m_resolution[CAPTURE_IMAGE_SIZE_8M].dwSize = 3264*2448;
  296. m_resolution[CAPTURE_IMAGE_SIZE_12M].dwSize = 4000*3000;
  297. m_resolution[CAPTURE_IMAGE_SIZE_4K].dwSize = 4096*2160;
  298. m_resolution[CAPTURE_IMAGE_SIZE_720N].dwSize = 640*720;
  299. m_resolution[CAPTURE_IMAGE_SIZE_WSVGA].dwSize = 1024*576;
  300. m_resolution[CAPTURE_IMAGE_SIZE_NHD].dwSize = 640*360;
  301. m_resolution[CAPTURE_IMAGE_SIZE_3M_N].dwSize = 1024*1536;
  302. m_resolution[CAPTURE_IMAGE_SIZE_4M_N].dwSize = 1296*1520;
  303. m_resolution[CAPTURE_IMAGE_SIZE_5M_N].dwSize = 1872*1408;
  304. m_resolution[CAPTURE_IMAGE_SIZE_4K_N].dwSize = 2048*2160; ///2048 * 2160通用/1920*2160海思
  305. /////////////////////////////////////////////掩码//////////////////////////////////////////
  306. m_resolution[CAPTURE_IMAGE_SIZE_D1].dsMask = BITMSK(CAPTURE_IMAGE_SIZE_D1) | BITMSK(CAPTURE_IMAGE_SIZE_HD1) | BITMSK(CAPTURE_IMAGE_SIZE_CIF) | BITMSK(CAPTURE_IMAGE_SIZE_QCIF);
  307. m_resolution[CAPTURE_IMAGE_SIZE_HD1].dsMask = BITMSK(CAPTURE_IMAGE_SIZE_HD1) | BITMSK(CAPTURE_IMAGE_SIZE_CIF) | BITMSK(CAPTURE_IMAGE_SIZE_QCIF);
  308. m_resolution[CAPTURE_IMAGE_SIZE_BCIF].dsMask = BITMSK(CAPTURE_IMAGE_SIZE_BCIF) | BITMSK(CAPTURE_IMAGE_SIZE_CIF) | BITMSK(CAPTURE_IMAGE_SIZE_QCIF);
  309. m_resolution[CAPTURE_IMAGE_SIZE_CIF].dsMask = BITMSK(CAPTURE_IMAGE_SIZE_CIF) | BITMSK(CAPTURE_IMAGE_SIZE_QCIF);
  310. m_resolution[CAPTURE_IMAGE_SIZE_QCIF].dsMask = BITMSK(CAPTURE_IMAGE_SIZE_QCIF);
  311. m_resolution[CAPTURE_IMAGE_SIZE_VGA].dsMask = BITMSK(CAPTURE_IMAGE_SIZE_VGA) | BITMSK(CAPTURE_IMAGE_SIZE_QVGA);
  312. m_resolution[CAPTURE_IMAGE_SIZE_QVGA].dsMask = BITMSK(CAPTURE_IMAGE_SIZE_QVGA);
  313. m_resolution[CAPTURE_IMAGE_SIZE_SVCD].dsMask = BITMSK(CAPTURE_IMAGE_SIZE_SVCD);
  314. m_resolution[CAPTURE_IMAGE_SIZE_QQVGA].dsMask = BITMSK(CAPTURE_IMAGE_SIZE_QQVGA);
  315. m_resolution[CAPTURE_IMAGE_SIZE_ND1].dsMask = BITMSK(CAPTURE_IMAGE_SIZE_ND1);
  316. m_resolution[CAPTURE_IMAGE_SIZE_650TVL].dsMask = BITMSK(CAPTURE_IMAGE_SIZE_D1) | BITMSK(CAPTURE_IMAGE_SIZE_HD1) | BITMSK(CAPTURE_IMAGE_SIZE_CIF) | BITMSK(CAPTURE_IMAGE_SIZE_QCIF);
  317. m_resolution[CAPTURE_IMAGE_SIZE_720P].dsMask = BITMSK(CAPTURE_IMAGE_SIZE_D1) | BITMSK(CAPTURE_IMAGE_SIZE_HD1) | BITMSK(CAPTURE_IMAGE_SIZE_CIF) | BITMSK(CAPTURE_IMAGE_SIZE_QCIF);
  318. m_resolution[CAPTURE_IMAGE_SIZE_1_3M].dsMask = BITMSK(CAPTURE_IMAGE_SIZE_D1) | BITMSK(CAPTURE_IMAGE_SIZE_HD1) | BITMSK(CAPTURE_IMAGE_SIZE_CIF) | BITMSK(CAPTURE_IMAGE_SIZE_QCIF);
  319. m_resolution[CAPTURE_IMAGE_SIZE_UXGA].dsMask = BITMSK(CAPTURE_IMAGE_SIZE_D1) | BITMSK(CAPTURE_IMAGE_SIZE_HD1) | BITMSK(CAPTURE_IMAGE_SIZE_CIF) | BITMSK(CAPTURE_IMAGE_SIZE_QCIF);
  320. m_resolution[CAPTURE_IMAGE_SIZE_1080P].dsMask = BITMSK(CAPTURE_IMAGE_SIZE_D1) | BITMSK(CAPTURE_IMAGE_SIZE_HD1) | BITMSK(CAPTURE_IMAGE_SIZE_CIF) | BITMSK(CAPTURE_IMAGE_SIZE_QCIF);
  321. m_resolution[CAPTURE_IMAGE_SIZE_WUXGA].dsMask = BITMSK(CAPTURE_IMAGE_SIZE_D1) | BITMSK(CAPTURE_IMAGE_SIZE_HD1) | BITMSK(CAPTURE_IMAGE_SIZE_CIF) | BITMSK(CAPTURE_IMAGE_SIZE_QCIF);
  322. m_resolution[CAPTURE_IMAGE_SIZE_2_5M].dsMask = BITMSK(CAPTURE_IMAGE_SIZE_D1) | BITMSK(CAPTURE_IMAGE_SIZE_HD1) | BITMSK(CAPTURE_IMAGE_SIZE_CIF) | BITMSK(CAPTURE_IMAGE_SIZE_QCIF);
  323. m_resolution[CAPTURE_IMAGE_SIZE_3M].dsMask = BITMSK(CAPTURE_IMAGE_SIZE_D1) | BITMSK(CAPTURE_IMAGE_SIZE_HD1) | BITMSK(CAPTURE_IMAGE_SIZE_CIF) | BITMSK(CAPTURE_IMAGE_SIZE_QCIF);
  324. m_resolution[CAPTURE_IMAGE_SIZE_5M].dsMask = BITMSK(CAPTURE_IMAGE_SIZE_D1) | BITMSK(CAPTURE_IMAGE_SIZE_HD1) | BITMSK(CAPTURE_IMAGE_SIZE_CIF) | BITMSK(CAPTURE_IMAGE_SIZE_QCIF);
  325. m_resolution[CAPTURE_IMAGE_SIZE_1080N].dsMask = BITMSK(CAPTURE_IMAGE_SIZE_650TVL) | BITMSK(CAPTURE_IMAGE_SIZE_D1) | BITMSK(CAPTURE_IMAGE_SIZE_CIF) | BITMSK(CAPTURE_IMAGE_SIZE_QCIF) | BITMSK(CAPTURE_IMAGE_SIZE_720P);
  326. m_resolution[CAPTURE_IMAGE_SIZE_4M].dsMask = BITMSK(CAPTURE_IMAGE_SIZE_D1) | BITMSK(CAPTURE_IMAGE_SIZE_HD1) | BITMSK(CAPTURE_IMAGE_SIZE_CIF) | BITMSK(CAPTURE_IMAGE_SIZE_QCIF) | BITMSK(CAPTURE_IMAGE_SIZE_720P);
  327. m_resolution[CAPTURE_IMAGE_SIZE_720N].dsMask = BITMSK(CAPTURE_IMAGE_SIZE_CIF) | BITMSK(CAPTURE_IMAGE_SIZE_QCIF);
  328. while((c = getchar()) != 'q')
  329. {
  330. switch(c)
  331. {
  332. //判断是否支持组合编码
  333. case 'a':
  334. {
  335. memset(&szOutBuffer, 0, 40960);
  336. nResult = XSDK_DevGetSysConfigSyn(g_hDevice, JK_SystemFunction, szOutBuffer, &nInOutSize, 4000, JK_SystemFunction_MsgId);
  337. if(nResult >= 0)
  338. {
  339. SystemFunction sysfunc;
  340. sysfunc.Parse(szOutBuffer);
  341. bSupport = sysfunc.mEncodeFunction.CombineStream.ToBool();
  342. m_bMultiStream = sysfunc.mEncodeFunction.DoubleStream.ToBool();
  343. m_bLowBitrate = sysfunc.mEncodeFunction.LowBitRate.ToBool();
  344. m_bFisheyeBitrate = sysfunc.mOtherFunction.SupportFishEye.ToBool();
  345. printf("bSupport = %d, m_bMultiStream = %d, m_bLowBitrate = %d, m_bFisheyeBitrate = %d\r\n",
  346. bSupport, m_bMultiStream, m_bLowBitrate, m_bFisheyeBitrate);
  347. }
  348. }
  349. break;
  350. case 'b':
  351. {
  352. memset(&szOutBuffer, 0, 40960);
  353. nResult = XSDK_DevGetSysConfigSyn(g_hDevice, JK_EncodeCapability, szOutBuffer, &nInOutSize, 4000, EXCMD_ABILITY_GET);
  354. if(nResult >= 0)
  355. {
  356. EncodeCapability encode;
  357. encode.Parse(szOutBuffer);
  358. ///////////////////////////////////获取主辅码流支持的压缩格式/////////////////////////////////
  359. ////获取主码流支持的压缩格式
  360. nCompression = encode.mEncodeInfo[0].CompressionMask.Value();
  361. for ( int i = 0; i < CAPTURE_COMPRESS_NR; i ++ )
  362. {
  363. if (nCompression & ( 1 << i ) )
  364. {
  365. printf("[Main]Support Compression Type = %s\r\n", CompressionMap[i].name);
  366. }
  367. }
  368. ////获取辅码流的支持的压缩格式
  369. nCompression = encode.mEncodeInfo[1].CompressionMask.Value();
  370. for ( int i = 0; i < CAPTURE_COMPRESS_NR; i ++ )
  371. {
  372. if (nCompression & ( 1 << i ) )
  373. {
  374. printf("[Extra]Support Compression Type = %s\r\n", CompressionMap[i].name);
  375. }
  376. }
  377. lFreePower = encode.MaxEncodePower.Value();
  378. ulMask = encode.ImageSizePerChannel[0].Value();
  379. }
  380. }
  381. break;
  382. case 'g':
  383. {
  384. char szOutBuf[40960] = {0};
  385. int nInOutBufLen = sizeof(szOutBuf);
  386. SDK_VIDEO_FORMAT mainFormat;
  387. memset(&mainFormat, 0, sizeof(SDK_VIDEO_FORMAT));
  388. int nGetCfg = XSDK_DevGetSysConfigSyn(g_hDevice, JK_Simplify_Encode, szOutBuf, &nInOutBufLen, 4000, EXCMD_CONFIG_GET);
  389. if (nGetCfg >= 0 && nInOutBufLen > 0)
  390. {
  391. JObjArrayObject<Simplify_Encode> cfg(NULL, JK_Simplify_Encode);
  392. cfg.Parse(szOutBuf);
  393. if(cfg.objs.Size() > 0)
  394. {
  395. ///主码流分辨率
  396. const char * mainStrRes = cfg.objs[0].mMainFormat.mVideo.Resolution.Value();
  397. printf("MainFormat[Resolution:%s]\r\n", cfg.objs[0].mMainFormat.mVideo.Resolution.Value());
  398. for ( int i = 0; i < CAPTURE_IMAGE_SIZE_EXT_V3_NR; i ++ )
  399. {
  400. if(strcmp(mainStrRes, s_videoResolutionMap[i].name) == 0)
  401. {
  402. nMainStreamResolution = i;
  403. }
  404. }
  405. if(nMainStreamResolution == CAPTURE_COMPRESS_H265)
  406. {
  407. m_bH265Bitrate[EXPAND_STREAM] = true;
  408. }
  409. else
  410. {
  411. m_bH265Bitrate[EXPAND_STREAM] = false;
  412. }
  413. mainFormat.iResolution = nMainStreamResolution;
  414. ///主码流帧率
  415. nFps = cfg.objs[0].mMainFormat.mVideo.FPS.Value();
  416. printf("MainFormat[FPS:%d]\r\n", cfg.objs[0].mMainFormat.mVideo.FPS.Value());
  417. mainFormat.nFPS = nFps;
  418. ///主码流码流值
  419. printf("MainFormat[BitRate:%d]\r\n", cfg.objs[0].mMainFormat.mVideo.BitRate.Value());
  420. mainFormat.nBitRate = cfg.objs[0].mMainFormat.mVideo.BitRate.Value();
  421. ///主码流帧间隔
  422. nGop = cfg.objs[0].mMainFormat.mVideo.GOP.Value();
  423. printf("MainFormat[GOP:%d]\r\n", cfg.objs[0].mMainFormat.mVideo.GOP.Value());
  424. mainFormat.iGOP = cfg.objs[0].mMainFormat.mVideo.GOP.Value();
  425. ///主码流码率控制
  426. printf("MainFormat[BitRateControl:%s]\r\n", cfg.objs[0].mMainFormat.mVideo.BitRateControl.Value());
  427. ///主码流压缩格式
  428. printf("MainFormat[Compression:%s]\r\n", cfg.objs[0].mMainFormat.mVideo.Compression.Value());
  429. int iCompression = 0;
  430. for ( int i = 0; i < CAPTURE_COMPRESS_NR; i ++ )
  431. {
  432. if(strcmp(mainStrRes, CompressionMap[i].name) == 0)
  433. {
  434. iCompression = i;
  435. }
  436. }
  437. mainFormat.iCompression = iCompression;
  438. ///主码流画质
  439. nQuality = cfg.objs[0].mMainFormat.mVideo.Quality.Value();
  440. printf("MainFormat[Quality:%d]\r\n", cfg.objs[0].mMainFormat.mVideo.Quality.Value());
  441. mainFormat.iQuality = nQuality;
  442. /////////////////////////////////////////////设置//////////////////////////////////////////////////
  443. int nChannelCount = 1; //通道个数,默认为1
  444. unsigned long dwChnUsed = 0;
  445. unsigned long dwChnFree = 0;
  446. unsigned long dwPower = lFreePower / nChannelCount;
  447. int nExStreamResolution = 0;
  448. int nExFps = 0;
  449. const char * ExStrRes = cfg.objs[0].mExtraFormat.mVideo.Resolution.Value();
  450. nExFps = cfg.objs[0].mExtraFormat.mVideo.FPS.Value();
  451. for ( int i = 0; i < CAPTURE_IMAGE_SIZE_EXT_V3_NR; i ++ )
  452. {
  453. if(strcmp(ExStrRes, s_videoResolutionMap[i].name) == 0)
  454. {
  455. nExStreamResolution = i;
  456. }
  457. }
  458. if (m_bMultiStream && cfg.objs[0].mExtraFormat.VideoEnable.Value())
  459. {
  460. dwChnUsed = m_resolution[nExStreamResolution].dwSize * nExFps;
  461. }
  462. dwChnFree = dwPower - dwChnUsed;
  463. ////////////主码流/////////
  464. mainFormat.nFPS = 25;
  465. int MaxSize = 0;
  466. GetMaxResolAndRate(MaxSize, nFps, dwChnFree);
  467. GetSupportRes(MaxSize, ulMask);
  468. //////固定码率时的码流值选择
  469. CalculateCodeStreamValue(&mainFormat, m_bLowBitrate, m_bFisheyeBitrate, m_bH265Bitrate);
  470. //////////设置码流值
  471. cfg.objs[0].mMainFormat.mVideo.FPS.SetValue(25);
  472. mainFormat.nFPS = 25;
  473. int nFPS = 25;
  474. int nTmpFPS = 25; /////设置的帧率
  475. int dwBitrate = 0;
  476. //////////码流值的计算////////
  477. if (m_bLowBitrate)
  478. {
  479. dwBitrate = LOWBITRATE_STREAM_CODE_VALUE[mainFormat.iResolution][mainFormat.iQuality - 1] * (mainFormat.iGOP * nTmpFPS + IFRAME_EQ_PFRAME - 1) / (mainFormat.iGOP * nFPS + IFRAME_EQ_PFRAME - 1);
  480. }
  481. else if(m_bFisheyeBitrate)
  482. {
  483. dwBitrate = FISHEYE_STREAM_CODE_VALUE[mainFormat.iResolution][mainFormat.iQuality - 1] * (mainFormat.iGOP * nTmpFPS + IFRAME_EQ_PFRAME - 1) / (mainFormat.iGOP * nFPS + IFRAME_EQ_PFRAME - 1);
  484. }
  485. else if (m_bH265Bitrate[MAIN_STREAM])
  486. {
  487. dwBitrate = H265_STREAM_CODE_VALUE[mainFormat.iResolution][mainFormat.iQuality - 1] * (mainFormat.iGOP * nTmpFPS + IFRAME_EQ_PFRAME - 1) / (mainFormat.iGOP * nFPS + IFRAME_EQ_PFRAME - 1);
  488. }
  489. else
  490. {
  491. dwBitrate = STREAM_CODE_VALUE[mainFormat.iResolution][mainFormat.iQuality - 1] * (mainFormat.iGOP * nTmpFPS + IFRAME_EQ_PFRAME - 1) / (mainFormat.iGOP * nFPS + IFRAME_EQ_PFRAME - 1);
  492. }
  493. cfg.objs[0].mMainFormat.mVideo.BitRate.SetValue(dwBitrate);
  494. const char *pCfg = cfg.ToString();
  495. XSDK_DevSetSysConfig(g_hDevice, JK_Simplify_Encode, pCfg, strlen(pCfg), 1, 5000, EXCMD_CONFIG_SET);
  496. }
  497. }
  498. }
  499. break;
  500. }
  501. }
  502. return 0;
  503. }