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.

579 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. bool bSupport = false;
  254. char szOutBuffer[40960] = {0};
  255. int nInOutSize = sizeof(szOutBuffer);
  256. int nResult = 0;
  257. int nCompression;
  258. int nMainStreamResolution = 0;
  259. // unsigned long ulMask = 0;
  260. int nQuality = 0;
  261. int nGop = 0;
  262. int nFps = 0;
  263. bool m_bH265Bitrate[STREAM_NUM];
  264. bool m_bMultiStream = false;
  265. bool m_bLowBitrate = false;
  266. bool m_bFisheyeBitrate = false;
  267. m_bH265Bitrate[MAIN_STREAM] = false;
  268. m_bH265Bitrate[EXPAND_STREAM] = false;
  269. m_bH265Bitrate[COMBINE_STREAM] = false;
  270. unsigned long lFreePower = 0;
  271. ///////////////////////////////////现有支持的所有分辨率/////////////////////////////////
  272. m_resolution[CAPTURE_IMAGE_SIZE_D1].dwSize = 704 * 480;
  273. m_resolution[CAPTURE_IMAGE_SIZE_HD1].dwSize = 704 * 240;
  274. m_resolution[CAPTURE_IMAGE_SIZE_BCIF].dwSize = 352 * 480;
  275. m_resolution[CAPTURE_IMAGE_SIZE_CIF].dwSize = 352 * 240;
  276. m_resolution[CAPTURE_IMAGE_SIZE_QCIF].dwSize = 176 * 120;
  277. m_resolution[CAPTURE_IMAGE_SIZE_VGA].dwSize = 640 * 480;
  278. m_resolution[CAPTURE_IMAGE_SIZE_QVGA].dwSize = 320 * 240;
  279. m_resolution[CAPTURE_IMAGE_SIZE_SVCD].dwSize = 480 * 480;
  280. m_resolution[CAPTURE_IMAGE_SIZE_QQVGA].dwSize = 160 * 128;
  281. m_resolution[CAPTURE_IMAGE_SIZE_ND1].dwSize = 240*192;
  282. m_resolution[CAPTURE_IMAGE_SIZE_650TVL].dwSize = 928*480;
  283. m_resolution[CAPTURE_IMAGE_SIZE_720P].dwSize = 1280*720;
  284. m_resolution[CAPTURE_IMAGE_SIZE_1_3M].dwSize = 1280*960;
  285. m_resolution[CAPTURE_IMAGE_SIZE_UXGA].dwSize = 1600*1200;
  286. m_resolution[CAPTURE_IMAGE_SIZE_1080P].dwSize = 1920*1080;
  287. m_resolution[CAPTURE_IMAGE_SIZE_WUXGA].dwSize = 1920*1200;
  288. m_resolution[CAPTURE_IMAGE_SIZE_2_5M].dwSize = 1872*1408;
  289. m_resolution[CAPTURE_IMAGE_SIZE_3M].dwSize = 2048*1536;
  290. m_resolution[CAPTURE_IMAGE_SIZE_5M].dwSize = 3744*1408;
  291. m_resolution[CAPTURE_IMAGE_SIZE_1080N].dwSize = 944*1080;
  292. m_resolution[CAPTURE_IMAGE_SIZE_4M].dwSize = 2592*1520;
  293. m_resolution[CAPTURE_IMAGE_SIZE_6M].dwSize = 3072*2048;
  294. m_resolution[CAPTURE_IMAGE_SIZE_8M].dwSize = 3264*2448;
  295. m_resolution[CAPTURE_IMAGE_SIZE_12M].dwSize = 4000*3000;
  296. m_resolution[CAPTURE_IMAGE_SIZE_4K].dwSize = 4096*2160;
  297. m_resolution[CAPTURE_IMAGE_SIZE_720N].dwSize = 640*720;
  298. m_resolution[CAPTURE_IMAGE_SIZE_WSVGA].dwSize = 1024*576;
  299. m_resolution[CAPTURE_IMAGE_SIZE_NHD].dwSize = 640*360;
  300. m_resolution[CAPTURE_IMAGE_SIZE_3M_N].dwSize = 1024*1536;
  301. m_resolution[CAPTURE_IMAGE_SIZE_4M_N].dwSize = 1296*1520;
  302. m_resolution[CAPTURE_IMAGE_SIZE_5M_N].dwSize = 1872*1408;
  303. m_resolution[CAPTURE_IMAGE_SIZE_4K_N].dwSize = 2048*2160; ///2048 * 2160通用/1920*2160海思
  304. /////////////////////////////////////////////掩码//////////////////////////////////////////
  305. 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);
  306. m_resolution[CAPTURE_IMAGE_SIZE_HD1].dsMask = BITMSK(CAPTURE_IMAGE_SIZE_HD1) | BITMSK(CAPTURE_IMAGE_SIZE_CIF) | BITMSK(CAPTURE_IMAGE_SIZE_QCIF);
  307. m_resolution[CAPTURE_IMAGE_SIZE_BCIF].dsMask = BITMSK(CAPTURE_IMAGE_SIZE_BCIF) | BITMSK(CAPTURE_IMAGE_SIZE_CIF) | BITMSK(CAPTURE_IMAGE_SIZE_QCIF);
  308. m_resolution[CAPTURE_IMAGE_SIZE_CIF].dsMask = BITMSK(CAPTURE_IMAGE_SIZE_CIF) | BITMSK(CAPTURE_IMAGE_SIZE_QCIF);
  309. m_resolution[CAPTURE_IMAGE_SIZE_QCIF].dsMask = BITMSK(CAPTURE_IMAGE_SIZE_QCIF);
  310. m_resolution[CAPTURE_IMAGE_SIZE_VGA].dsMask = BITMSK(CAPTURE_IMAGE_SIZE_VGA) | BITMSK(CAPTURE_IMAGE_SIZE_QVGA);
  311. m_resolution[CAPTURE_IMAGE_SIZE_QVGA].dsMask = BITMSK(CAPTURE_IMAGE_SIZE_QVGA);
  312. m_resolution[CAPTURE_IMAGE_SIZE_SVCD].dsMask = BITMSK(CAPTURE_IMAGE_SIZE_SVCD);
  313. m_resolution[CAPTURE_IMAGE_SIZE_QQVGA].dsMask = BITMSK(CAPTURE_IMAGE_SIZE_QQVGA);
  314. m_resolution[CAPTURE_IMAGE_SIZE_ND1].dsMask = BITMSK(CAPTURE_IMAGE_SIZE_ND1);
  315. 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);
  316. 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);
  317. 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);
  318. 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);
  319. 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);
  320. 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);
  321. 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);
  322. 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);
  323. 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);
  324. 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);
  325. 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);
  326. m_resolution[CAPTURE_IMAGE_SIZE_720N].dsMask = BITMSK(CAPTURE_IMAGE_SIZE_CIF) | BITMSK(CAPTURE_IMAGE_SIZE_QCIF);
  327. while((c = getchar()) != 'q')
  328. {
  329. switch(c)
  330. {
  331. //判断是否支持组合编码
  332. case 'a':
  333. {
  334. memset(&szOutBuffer, 0, 40960);
  335. nResult = XSDK_DevGetSysConfigSyn(g_hDevice, JK_SystemFunction, szOutBuffer, &nInOutSize, 4000, JK_SystemFunction_MsgId);
  336. if(nResult >= 0)
  337. {
  338. SystemFunction sysfunc;
  339. sysfunc.Parse(szOutBuffer);
  340. bSupport = sysfunc.mEncodeFunction.CombineStream.ToBool();
  341. m_bMultiStream = sysfunc.mEncodeFunction.DoubleStream.ToBool();
  342. m_bLowBitrate = sysfunc.mEncodeFunction.LowBitRate.ToBool();
  343. m_bFisheyeBitrate = sysfunc.mOtherFunction.SupportFishEye.ToBool();
  344. printf("bSupport = %d, m_bMultiStream = %d, m_bLowBitrate = %d, m_bFisheyeBitrate = %d\r\n",
  345. bSupport, m_bMultiStream, m_bLowBitrate, m_bFisheyeBitrate);
  346. }
  347. }
  348. break;
  349. case 'b':
  350. {
  351. memset(&szOutBuffer, 0, 40960);
  352. nResult = XSDK_DevGetSysConfigSyn(g_hDevice, JK_EncodeCapability, szOutBuffer, &nInOutSize, 4000, EXCMD_ABILITY_GET);
  353. if(nResult >= 0)
  354. {
  355. EncodeCapability encode;
  356. encode.Parse(szOutBuffer);
  357. ///////////////////////////////////获取主辅码流支持的压缩格式/////////////////////////////////
  358. ////获取主码流支持的压缩格式
  359. nCompression = encode.mEncodeInfo[0].CompressionMask.Value();
  360. for ( int i = 0; i < CAPTURE_COMPRESS_NR; i ++ )
  361. {
  362. if (nCompression & ( 1 << i ) )
  363. {
  364. printf("[Main]Support Compression Type = %s\r\n", CompressionMap[i].name);
  365. }
  366. }
  367. ////获取辅码流的支持的压缩格式
  368. nCompression = encode.mEncodeInfo[1].CompressionMask.Value();
  369. for ( int i = 0; i < CAPTURE_COMPRESS_NR; i ++ )
  370. {
  371. if (nCompression & ( 1 << i ) )
  372. {
  373. printf("[Extra]Support Compression Type = %s\r\n", CompressionMap[i].name);
  374. }
  375. }
  376. lFreePower = encode.MaxEncodePower.Value();
  377. //ulMask = encode.ImageSizePerChannel[0].Value();
  378. }
  379. }
  380. break;
  381. case 'g':
  382. {
  383. char szOutBuf[40960] = {0};
  384. int nInOutBufLen = sizeof(szOutBuf);
  385. SDK_VIDEO_FORMAT mainFormat;
  386. memset(&mainFormat, 0, sizeof(SDK_VIDEO_FORMAT));
  387. int nGetCfg = XSDK_DevGetSysConfigSyn(g_hDevice, JK_Simplify_Encode, szOutBuf, &nInOutBufLen, 4000, EXCMD_CONFIG_GET);
  388. if (nGetCfg >= 0 && nInOutBufLen > 0)
  389. {
  390. JObjArrayObject<Simplify_Encode> cfg(NULL, JK_Simplify_Encode);
  391. cfg.Parse(szOutBuf);
  392. if(cfg.objs.Size() > 0)
  393. {
  394. ///主码流分辨率
  395. const char * mainStrRes = cfg.objs[0].mMainFormat.mVideo.Resolution.Value();
  396. printf("MainFormat[Resolution:%s]\r\n", cfg.objs[0].mMainFormat.mVideo.Resolution.Value());
  397. for ( int i = 0; i < CAPTURE_IMAGE_SIZE_EXT_V3_NR; i ++ )
  398. {
  399. if(strcmp(mainStrRes, s_videoResolutionMap[i].name) == 0)
  400. {
  401. nMainStreamResolution = i;
  402. }
  403. }
  404. if(nMainStreamResolution == CAPTURE_COMPRESS_H265)
  405. {
  406. m_bH265Bitrate[EXPAND_STREAM] = true;
  407. }
  408. else
  409. {
  410. m_bH265Bitrate[EXPAND_STREAM] = false;
  411. }
  412. mainFormat.iResolution = nMainStreamResolution;
  413. ///主码流帧率
  414. nFps = cfg.objs[0].mMainFormat.mVideo.FPS.Value();
  415. printf("MainFormat[FPS:%d]\r\n", cfg.objs[0].mMainFormat.mVideo.FPS.Value());
  416. mainFormat.nFPS = nFps;
  417. ///主码流码流值
  418. printf("MainFormat[BitRate:%d]\r\n", cfg.objs[0].mMainFormat.mVideo.BitRate.Value());
  419. mainFormat.nBitRate = cfg.objs[0].mMainFormat.mVideo.BitRate.Value();
  420. ///主码流帧间隔
  421. nGop = cfg.objs[0].mMainFormat.mVideo.GOP.Value();
  422. printf("MainFormat[GOP:%d]\r\n", cfg.objs[0].mMainFormat.mVideo.GOP.Value());
  423. mainFormat.iGOP = cfg.objs[0].mMainFormat.mVideo.GOP.Value();
  424. ///主码流码率控制
  425. printf("MainFormat[BitRateControl:%s]\r\n", cfg.objs[0].mMainFormat.mVideo.BitRateControl.Value());
  426. ///主码流压缩格式
  427. printf("MainFormat[Compression:%s]\r\n", cfg.objs[0].mMainFormat.mVideo.Compression.Value());
  428. int iCompression = 0;
  429. for ( int i = 0; i < CAPTURE_COMPRESS_NR; i ++ )
  430. {
  431. if(strcmp(mainStrRes, CompressionMap[i].name) == 0)
  432. {
  433. iCompression = i;
  434. }
  435. }
  436. mainFormat.iCompression = iCompression;
  437. ///主码流画质
  438. nQuality = cfg.objs[0].mMainFormat.mVideo.Quality.Value();
  439. printf("MainFormat[Quality:%d]\r\n", cfg.objs[0].mMainFormat.mVideo.Quality.Value());
  440. mainFormat.iQuality = nQuality;
  441. /////////////////////////////////////////////设置//////////////////////////////////////////////////
  442. int nChannelCount = 1; //通道个数,默认为1
  443. unsigned long dwChnUsed = 0;
  444. unsigned long dwChnFree = 0;
  445. unsigned long dwPower = lFreePower / nChannelCount;
  446. int nExStreamResolution = 0;
  447. int nExFps = 0;
  448. const char * ExStrRes = cfg.objs[0].mExtraFormat.mVideo.Resolution.Value();
  449. nExFps = cfg.objs[0].mExtraFormat.mVideo.FPS.Value();
  450. for ( int i = 0; i < CAPTURE_IMAGE_SIZE_EXT_V3_NR; i ++ )
  451. {
  452. if(strcmp(ExStrRes, s_videoResolutionMap[i].name) == 0)
  453. {
  454. nExStreamResolution = i;
  455. }
  456. }
  457. if (m_bMultiStream && cfg.objs[0].mExtraFormat.VideoEnable.Value())
  458. {
  459. dwChnUsed = m_resolution[nExStreamResolution].dwSize * nExFps;
  460. }
  461. dwChnFree = dwPower - dwChnUsed;
  462. ////////////主码流/////////
  463. mainFormat.nFPS = 25;
  464. int MaxSize = 0;
  465. GetMaxResolAndRate(MaxSize, nFps, dwChnFree);
  466. //GetSupportRes(MaxSize, ulMask);
  467. //////固定码率时的码流值选择
  468. CalculateCodeStreamValue(&mainFormat, m_bLowBitrate, m_bFisheyeBitrate, m_bH265Bitrate);
  469. //////////设置码流值
  470. cfg.objs[0].mMainFormat.mVideo.FPS.SetValue(25);
  471. mainFormat.nFPS = 25;
  472. int nFPS = 25;
  473. int nTmpFPS = 25; /////设置的帧率
  474. int dwBitrate = 0;
  475. //////////码流值的计算////////
  476. if (m_bLowBitrate)
  477. {
  478. dwBitrate = LOWBITRATE_STREAM_CODE_VALUE[mainFormat.iResolution][mainFormat.iQuality - 1] * (mainFormat.iGOP * nTmpFPS + IFRAME_EQ_PFRAME - 1) / (mainFormat.iGOP * nFPS + IFRAME_EQ_PFRAME - 1);
  479. }
  480. else if(m_bFisheyeBitrate)
  481. {
  482. dwBitrate = FISHEYE_STREAM_CODE_VALUE[mainFormat.iResolution][mainFormat.iQuality - 1] * (mainFormat.iGOP * nTmpFPS + IFRAME_EQ_PFRAME - 1) / (mainFormat.iGOP * nFPS + IFRAME_EQ_PFRAME - 1);
  483. }
  484. else if (m_bH265Bitrate[MAIN_STREAM])
  485. {
  486. dwBitrate = H265_STREAM_CODE_VALUE[mainFormat.iResolution][mainFormat.iQuality - 1] * (mainFormat.iGOP * nTmpFPS + IFRAME_EQ_PFRAME - 1) / (mainFormat.iGOP * nFPS + IFRAME_EQ_PFRAME - 1);
  487. }
  488. else
  489. {
  490. dwBitrate = STREAM_CODE_VALUE[mainFormat.iResolution][mainFormat.iQuality - 1] * (mainFormat.iGOP * nTmpFPS + IFRAME_EQ_PFRAME - 1) / (mainFormat.iGOP * nFPS + IFRAME_EQ_PFRAME - 1);
  491. }
  492. cfg.objs[0].mMainFormat.mVideo.BitRate.SetValue(dwBitrate);
  493. const char *pCfg = cfg.ToString();
  494. XSDK_DevSetSysConfig(g_hDevice, JK_Simplify_Encode, pCfg, strlen(pCfg), 1, 5000, EXCMD_CONFIG_SET);
  495. }
  496. }
  497. }
  498. break;
  499. }
  500. }
  501. return 0;
  502. }