1 /*
2 * Copyright (c) 2022 HiSilicon (Shanghai) Technologies CO., LIMITED.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include <stdio.h>
16 #include <stdlib.h>
17 #include <string.h>
18 #include <errno.h>
19 #include <fcntl.h>
20 #include <sys/mman.h>
21 #include <sys/stat.h>
22 #include <sys/types.h>
23 #include <unistd.h>
24 #include <signal.h>
25 #include <pthread.h>
26 #include <sys/prctl.h>
27 #include <math.h>
28
29 #include "hi_common.h"
30 #include "hi_comm_sys.h"
31 #include "hi_comm_svp.h"
32 #include "sample_comm.h"
33 #include "sample_comm_svp.h"
34 #include "sample_comm_nnie.h"
35 #include "sample_ive_main.h"
36 #include "sample_comm_ive.h"
37 #include "sample_ive_queue.h"
38
39 #define SAMPLE_IVE_MAX(a, b) (((a) > (b)) ? (a) : (b))
40 #define SAMPLE_IVE_MIN(a, b) (((a) < (b)) ? (a) : (b))
41
42 #define SAMPLE_IVE_MUTEX_INIT_LOCK(mutex) \
43 do { \
44 (void)pthread_mutex_init(&(mutex), NULL); \
45 } while (0)
46 #define SAMPLE_IVE_MUTEX_LOCK(mutex) \
47 do { \
48 (void)pthread_mutex_lock(&(mutex)); \
49 } while (0)
50 #define SAMPLE_IVE_MUTEX_UNLOCK(mutex) \
51 do { \
52 (void)pthread_mutex_unlock(&(mutex)); \
53 } while (0)
54 #define SAMPLE_IVE_MUTEX_DESTROY(mutex) \
55 do { \
56 (void)pthread_mutex_destroy(&(mutex)); \
57 } while (0)
58
59 #define SAMPLE_IVE_KCF_NODE_MAX_NUM 64
60 #define SAMPLE_IVE_KCF_GAUSS_PEAK_TOTAL_SIZE 455680
61 #define SAMPLE_IVE_KCF_COS_WINDOW_TOTAL_SIZE 832
62 #define SAMPLE_IVE_KCF_COS_WINDOW_SIZE 64
63 #define SAMPLE_IVE_KCF_TEMP_BUF_SIZE 47616
64 #define SAMPLE_IVE_KCF_HOG_FEATRUE_BUF_SIZE 47616
65
66 #define SAMPLE_IVE_KCF_ROI_PADDING_MAX_WIDTH 1024
67 #define SAMPLE_IVE_KCF_ROI_PADDING_MIN_WIDTH 40
68 #define SAMPLE_IVE_KCF_ROI_PADDING_MAX_HEIGHT 1024
69 #define SAMPLE_IVE_KCF_ROI_PADDING_MIN_HEIGHT 40
70
71 #define SAMPLE_IVE_QUEUE_LEN 16
72
73 #define SAMPLE_IVE_PROPOSAL_WIDTH 6 /* the number of proposal values */
74 #define SAMPLE_IVE_COORDI_NUM 4 /* coordinate numbers */
75 #define SAMPLE_IVE_QUANT_BASE 4096 /* the base value */
76 #define SAMPLE_IVE_SCORE_NUM 2 /* the num of RPN scores */
77 #define SAMPLE_IVE_HALF 0.5f /* the half value */
78 #define SAMPLE_IVE_X_MIN_OFFSET 0
79 #define SAMPLE_IVE_Y_MIN_OFFSET 1
80 #define SAMPLE_IVE_X_MAX_OFFSET 2
81 #define SAMPLE_IVE_Y_MAX_OFFSET 3
82 #define SAMPLE_IVE_SCORE_OFFSET 4
83 #define SAMPLE_IVE_SUPPRESS_FLAG_OFFSET 5
84 #define SAMPLE_IVE_KCF_BASE_ANCHOR_ARR_NUM 4
85 #define SAMPLE_IVE_KCF_IDX_0 0
86 #define SAMPLE_IVE_KCF_IDX_1 1
87 #define SAMPLE_IVE_KCF_IDX_2 2
88 #define SAMPLE_IVE_KCF_IDX_3 3
89 #define SAMPLE_IVE_KCF_IDX_4 4
90 #define SAMPLE_IVE_KCF_SEG_1 1
91 #define SAMPLE_IVE_KCF_SEG_2 2
92 #define SAMPLE_IVE_KCF_CLASS_NUM 21
93 #define SAMPLE_IVE_KCF_RATIO_ANCHOR_NUM 3
94 #define SAMPLE_IVE_KCF_SCALE_ANCHOR_NUM 3
95 #define SAMPLE_IVE_KCF_SCALE_0 (8 * SAMPLE_IVE_QUANT_BASE)
96 #define SAMPLE_IVE_KCF_SCALE_1 (16 * SAMPLE_IVE_QUANT_BASE)
97 #define SAMPLE_IVE_KCF_SCALE_2 (32 * SAMPLE_IVE_QUANT_BASE)
98 #define SAMPLE_IVE_KCF_RATIO_0 (0.5 * SAMPLE_IVE_QUANT_BASE)
99 #define SAMPLE_IVE_KCF_RATIO_1 (1 * SAMPLE_IVE_QUANT_BASE)
100 #define SAMPLE_IVE_KCF_RATIO_2 (2 * SAMPLE_IVE_QUANT_BASE)
101 #define SAMPLE_IVE_KCF_MIN_SIZE 16
102 #define SAMPLE_IVE_KCF_FILTER_THR 0
103 #define SAMPLE_IVE_KCF_SPATIAL_SCALE (0.0625 * SAMPLE_IVE_QUANT_BASE)
104 #define SAMPLE_IVE_KCF_NMS_THR (0.7 * SAMPLE_IVE_QUANT_BASE)
105 #define SAMPLE_IVE_KCF_NUM_BEFORE_NMS 6000
106 #define SAMPLE_IVE_KCF_SCORE_THR 0.8f
107 #define SAMPLE_IVE_KCF_VALID_NMS_THR (0.3 * 4096)
108 #define SAMPLE_IVE_KCF_ROI_FIX_POINT 256
109 #define SAMPLE_IVE_KCF_PAD_FIX_POINT 32
110 #define SAMPLE_IVE_KCF_PAD_VALUE_2 2
111 #define SAMPLE_IVE_KCF_PAD_VALUE_48 (1.5 * 32)
112 #define SAMPLE_IVE_KCF_CAR_IDX 7
113 #define SAMPLE_IVE_KCF_IOU_NMS_THR 0.3f
114 #define SAMPLE_IVE_KCF_INTER_FACTOR (0.02 * 1024 * 32)
115 #define SAMPLE_IVE_KCF_LAMDA 10
116 #define SAMPLE_IVE_KCF_SIGMA (0.5 * 256)
117 #define SAMPLE_IVE_KCF_TRANC_ALFA (0.2 * 4096)
118 #define SAMPLE_IVE_KCF_RESP_THR 32
119 #define SAMPLE_IVE_KCF_BLK_CNT_4 4
120 #define SAMPLE_IVE_KCF_BLK_CNT_10 10
121 #define SAMPLE_IVE_KCF_MAX_POOL_CNT 4
122 #define SAMPLE_IVE_KCF_RPN_MAX_ROI_NUM 300
123 #define SAMPLE_IVE_KCF_VPSS_MAX_CHN 2
124 #define SAMPLE_IVE_KCF_MAX_PIC_SIZE 3
125 #define SAMPLE_IVE_KCF_COLOR 0x0000FF00
126 #define SAMPLE_IVE_KCF_MAX_BBOX 64
127 #define SAMPLE_IVE_KCF_MAX_FRM_NUM 2
128 #define SAMPLE_IVE_KCF_CONV_OUT_NUM 2
129 typedef enum hiSAMPLE_IVE_CNN_GET_FRM_STATUS_E {
130 CNN_GET_FRM_START = 0x0,
131 CNN_GET_FRM_END = 0x1,
132
133 CNN_GET_FRM_BUTT
134 } SAMPLE_IVE_CNN_GET_FRM_STATUS_E;
135
136 typedef enum hiSAMPLE_IVE_CNN_PROC_STATUS_E {
137 CNN_PROC_START = 0x0,
138 CNN_PROC_END = 0x1,
139
140 CNN_PROC_BUTT
141 } SAMPLE_IVE_CNN_PROC_STATUS_E;
142
143 typedef struct hiSAMPLE_IVE_KCF_S {
144 IVE_ROI_INFO_S astRoiInfo[SAMPLE_IVE_KCF_MAX_BBOX];
145 HI_U32 u32RoiNum;
146 IVE_MEM_INFO_S stTotalMem;
147 IVE_MEM_INFO_S stListMem;
148 IVE_MEM_INFO_S stCosWinX;
149 IVE_MEM_INFO_S stCosWinY;
150 IVE_MEM_INFO_S stGaussPeak;
151 IVE_KCF_OBJ_LIST_S stObjList;
152 IVE_KCF_PRO_CTRL_S stKcfProCtrl;
153 IVE_KCF_BBOX_S astBbox[SAMPLE_IVE_KCF_MAX_BBOX];
154 HI_U32 u32BboxObjNum;
155 IVE_KCF_BBOX_CTRL_S stKcfBboxCtrl;
156 HI_U3Q5 u3q5Padding;
157 HI_U8 u8Reserved;
158
159 SAMPLE_IVE_CNN_GET_FRM_STATUS_E enCnnGetFrmStat;
160 SAMPLE_IVE_CNN_PROC_STATUS_E enCnnProcStat;
161 HI_BOOL bNewDetect;
162 HI_BOOL bFirstDetect;
163
164 SAMPLE_IVE_QUEUE_S *pstQueueHead;
165 VIDEO_FRAME_INFO_S astFrameInfo[SAMPLE_IVE_KCF_MAX_FRM_NUM];
166 pthread_mutex_t CnnDetectMutex;
167 pthread_mutex_t QueueMutex;
168 pthread_mutex_t GetFrmMutex;
169 } SAMPLE_IVE_KCF_S;
170
171 /* rfcn para */
172 static SAMPLE_SVP_NNIE_MODEL_S s_stRfcnModel = {0};
173 static SAMPLE_SVP_NNIE_PARAM_S s_stRfcnNnieParam = {0};
174 static SAMPLE_SVP_NNIE_RFCN_SOFTWARE_PARAM_S s_stRfcnSoftwareParam = {0};
175 static HI_BOOL s_bIveKcfStopSignal = HI_FALSE;
176 static pthread_t s_IveDetectThread = 0;
177 static pthread_t s_IveGetFrmThread = 0;
178 static pthread_t s_IveTrackThread = 0;
179 static SAMPLE_VI_CONFIG_S s_stViConfig = {0};
180 static SAMPLE_VO_CONFIG_S s_stVoConfig = {0};
181 static SAMPLE_IVE_KCF_S s_stIveKcfInfo = {0};
182
183 /* stack for sort */
184 typedef struct hiSAMPLE_IVE_STACK {
185 HI_S32 s32Min;
186 HI_S32 s32Max;
187 } SAMPLE_IVE_STACK_S;
188
189 static HI_FLOAT s_af32ExpCoef[10][16] = {
190 {
191 1.0f, 1.00024f, 1.00049f, 1.00073f, 1.00098f, 1.00122f, 1.00147f, 1.00171f,
192 1.00196f, 1.0022f, 1.00244f, 1.00269f, 1.00293f, 1.00318f, 1.00342f, 1.00367f
193 },
194 {
195 1.0f, 1.00391f, 1.00784f, 1.01179f, 1.01575f, 1.01972f, 1.02371f, 1.02772f,
196 1.03174f, 1.03578f, 1.03984f, 1.04391f, 1.04799f, 1.05209f, 1.05621f, 1.06034f
197 },
198 {
199 1.0f, 1.06449f, 1.13315f, 1.20623f, 1.28403f, 1.36684f, 1.45499f, 1.54883f,
200 1.64872f, 1.75505f, 1.86825f, 1.98874f, 2.117f, 2.25353f, 2.39888f, 2.55359f
201 },
202 {
203 1.0f, 2.71828f, 7.38906f, 20.0855f, 54.5981f, 148.413f, 403.429f, 1096.63f,
204 2980.96f, 8103.08f, 22026.5f, 59874.1f, 162755.0f, 442413.0f, 1.2026e+006f, 3.26902e+006f
205 },
206 {
207 1.0f, 8.88611e+006f, 7.8963e+013f, 7.01674e+020f, 6.23515e+027f, 5.54062e+034f,
208 5.54062e+034f, 5.54062e+034f, 5.54062e+034f, 5.54062e+034f, 5.54062e+034f,
209 5.54062e+034f, 5.54062e+034f, 5.54062e+034f, 5.54062e+034f, 5.54062e+034f
210 },
211 {
212 1.0f, 0.999756f, 0.999512f, 0.999268f, 0.999024f, 0.99878f, 0.998536f,
213 0.998292f, 0.998049f, 0.997805f, 0.997562f, 0.997318f, 0.997075f,
214 0.996831f, 0.996588f, 0.996345f
215 },
216 {
217 1.0f, 0.996101f, 0.992218f, 0.98835f, 0.984496f, 0.980658f, 0.976835f,
218 0.973027f, 0.969233f, 0.965455f, 0.961691f, 0.957941f, 0.954207f,
219 0.950487f, 0.946781f, 0.94309f
220 },
221 {
222 1.0f, 0.939413f, 0.882497f, 0.829029f, 0.778801f, 0.731616f, 0.687289f,
223 0.645649f, 0.606531f, 0.569783f, 0.535261f, 0.502832f, 0.472367f,
224 0.443747f, 0.416862f, 0.391606f
225 },
226 {
227 1.0f, 0.367879f, 0.135335f, 0.0497871f, 0.0183156f, 0.00673795f, 0.00247875f,
228 0.000911882f, 0.000335463f, 0.00012341f, 4.53999e-005f, 1.67017e-005f,
229 6.14421e-006f, 2.26033e-006f, 8.31529e-007f, 3.05902e-007f
230 },
231 {
232 1.0f, 1.12535e-007f, 1.26642e-014f, 1.42516e-021f, 1.60381e-028f, 1.80485e-035f,
233 2.03048e-042f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f
234 }
235 };
236
IVE_QuickExp(HI_S32 s32Value)237 static HI_FLOAT IVE_QuickExp(HI_S32 s32Value)
238 {
239 HI_U32 tmp_val;
240 /* calculate exp by lookup table */
241 if (s32Value < 0) {
242 tmp_val = *((HI_U32 *)&s32Value);
243 tmp_val = (~tmp_val + 0x00000001);
244 return (s_af32ExpCoef[5][tmp_val & 0x0000000F] * s_af32ExpCoef[6][(tmp_val >> 4) & 0x0000000F] *
245 s_af32ExpCoef[7][(tmp_val >> 8) & 0x0000000F] * s_af32ExpCoef[8][(tmp_val >> 12) & 0x0000000F] *
246 s_af32ExpCoef[9][(tmp_val >> 16) & 0x0000000F]);
247 } else {
248 tmp_val = (HI_U32)s32Value;
249 return (s_af32ExpCoef[0][tmp_val & 0x0000000F] * s_af32ExpCoef[1][(tmp_val >> 4) & 0x0000000F] *
250 s_af32ExpCoef[2][(tmp_val >> 8) & 0x0000000F] * s_af32ExpCoef[3][(tmp_val >> 12) & 0x0000000F] *
251 s_af32ExpCoef[4][(tmp_val >> 16) & 0x0000000F]);
252 }
253 }
254
IVE_SoftMax(HI_FLOAT * pf32Src,HI_U32 u32Num)255 static HI_S32 IVE_SoftMax(HI_FLOAT *pf32Src, HI_U32 u32Num)
256 {
257 HI_FLOAT f32Max = 0;
258 HI_FLOAT f32Sum = 0;
259 HI_U32 i;
260
261 for (i = 0; i < u32Num; ++i) {
262 if (f32Max < pf32Src[i]) {
263 f32Max = pf32Src[i];
264 }
265 }
266
267 for (i = 0; i < u32Num; ++i) {
268 pf32Src[i] = (HI_FLOAT)IVE_QuickExp((HI_S32)((pf32Src[i] - f32Max) * SAMPLE_IVE_QUANT_BASE));
269 f32Sum += pf32Src[i];
270 }
271
272 for (i = 0; i < u32Num; ++i) {
273 pf32Src[i] /= f32Sum;
274 }
275 return HI_SUCCESS;
276 }
277
IVE_Argswap(HI_S32 * ps32Src1,HI_S32 * ps32Src2)278 static void IVE_Argswap(HI_S32 *ps32Src1, HI_S32 *ps32Src2)
279 {
280 HI_U32 i = 0;
281 HI_S32 u32Tmp = 0;
282 for (i = 0; i < SAMPLE_IVE_PROPOSAL_WIDTH; i++) {
283 u32Tmp = ps32Src1[i];
284 ps32Src1[i] = ps32Src2[i];
285 ps32Src2[i] = u32Tmp;
286 }
287 }
288
IVE_NonRecursiveArgQuickSort(HI_S32 * ps32Array,HI_S32 s32Low,HI_S32 s32High,SAMPLE_IVE_STACK_S * pstStack,HI_U32 u32MaxNum)289 static HI_S32 IVE_NonRecursiveArgQuickSort(HI_S32 *ps32Array, HI_S32 s32Low, HI_S32 s32High,
290 SAMPLE_IVE_STACK_S *pstStack, HI_U32 u32MaxNum)
291 {
292 HI_S32 i = s32Low;
293 HI_S32 j = s32High;
294 HI_S32 s32Top = 0;
295 HI_S32 offset = SAMPLE_IVE_SCORE_OFFSET;
296 HI_S32 s32KeyConfidence = ps32Array[SAMPLE_IVE_PROPOSAL_WIDTH * s32Low + offset];
297 pstStack[s32Top].s32Min = s32Low;
298 pstStack[s32Top].s32Max = s32High;
299
300 while (s32Top > -1) {
301 s32Low = pstStack[s32Top].s32Min;
302 s32High = pstStack[s32Top].s32Max;
303 i = s32Low;
304 j = s32High;
305 s32Top--;
306
307 s32KeyConfidence = ps32Array[SAMPLE_IVE_PROPOSAL_WIDTH * s32Low + offset];
308
309 while (i < j) {
310 while ((i < j) && (s32KeyConfidence > ps32Array[j * SAMPLE_IVE_PROPOSAL_WIDTH + offset])) {
311 j--;
312 }
313 if (i < j) {
314 IVE_Argswap(&ps32Array[i * SAMPLE_IVE_PROPOSAL_WIDTH], &ps32Array[j * SAMPLE_IVE_PROPOSAL_WIDTH]);
315 i++;
316 }
317
318 while ((i < j) && (s32KeyConfidence < ps32Array[i * SAMPLE_IVE_PROPOSAL_WIDTH + offset])) {
319 i++;
320 }
321 if (i < j) {
322 IVE_Argswap(&ps32Array[i * SAMPLE_IVE_PROPOSAL_WIDTH], &ps32Array[j * SAMPLE_IVE_PROPOSAL_WIDTH]);
323 j--;
324 }
325 }
326
327 if (s32Low <= (HI_S32)u32MaxNum) {
328 if (s32Low < i - 1) {
329 s32Top++;
330 pstStack[s32Top].s32Min = s32Low;
331 pstStack[s32Top].s32Max = i - 1;
332 }
333
334 if (s32High > i + 1) {
335 s32Top++;
336 pstStack[s32Top].s32Min = i + 1;
337 pstStack[s32Top].s32Max = s32High;
338 }
339 }
340 }
341 return HI_SUCCESS;
342 }
343
IVE_Overlap(HI_S32 s32XMin1,HI_S32 s32YMin1,HI_S32 s32XMax1,HI_S32 s32YMax1,HI_S32 s32XMin2,HI_S32 s32YMin2,HI_S32 s32XMax2,HI_S32 s32YMax2,HI_S32 * s32AreaSum,HI_S32 * s32AreaInter)344 static HI_S32 IVE_Overlap(HI_S32 s32XMin1, HI_S32 s32YMin1, HI_S32 s32XMax1, HI_S32 s32YMax1, HI_S32 s32XMin2,
345 HI_S32 s32YMin2, HI_S32 s32XMax2, HI_S32 s32YMax2, HI_S32 *s32AreaSum, HI_S32 *s32AreaInter)
346 {
347 HI_S32 s32Inter = 0;
348 HI_S32 s32Total = 0;
349 HI_S32 s32XMin = 0;
350 HI_S32 s32YMin = 0;
351 HI_S32 s32XMax = 0;
352 HI_S32 s32YMax = 0;
353 HI_S32 s32Area1 = 0;
354 HI_S32 s32Area2 = 0;
355 HI_S32 s32InterWidth = 0;
356 HI_S32 s32InterHeight = 0;
357
358 s32XMin = SAMPLE_IVE_MAX(s32XMin1, s32XMin2);
359 s32YMin = SAMPLE_IVE_MAX(s32YMin1, s32YMin2);
360 s32XMax = SAMPLE_IVE_MIN(s32XMax1, s32XMax2);
361 s32YMax = SAMPLE_IVE_MIN(s32YMax1, s32YMax2);
362
363 s32InterWidth = s32XMax - s32XMin + 1;
364 s32InterHeight = s32YMax - s32YMin + 1;
365
366 s32InterWidth = (s32InterWidth >= 0) ? s32InterWidth : 0;
367 s32InterHeight = (s32InterHeight >= 0) ? s32InterHeight : 0;
368
369 s32Inter = s32InterWidth * s32InterHeight;
370 s32Area1 = (s32XMax1 - s32XMin1 + 1) * (s32YMax1 - s32YMin1 + 1);
371 s32Area2 = (s32XMax2 - s32XMin2 + 1) * (s32YMax2 - s32YMin2 + 1);
372
373 s32Total = s32Area1 + s32Area2 - s32Inter;
374
375 *s32AreaSum = s32Total;
376 *s32AreaInter = s32Inter;
377 return HI_SUCCESS;
378 }
379
IVE_FilterLowScoreBbox(HI_S32 * ps32Proposals,HI_U32 u32AnchorsNum,HI_U32 u32FilterThresh,HI_U32 * u32NumAfterFilter)380 static HI_S32 IVE_FilterLowScoreBbox(HI_S32 *ps32Proposals, HI_U32 u32AnchorsNum, HI_U32 u32FilterThresh,
381 HI_U32 *u32NumAfterFilter)
382 {
383 HI_U32 u32ProposalCnt = u32AnchorsNum;
384 HI_U32 i = 0;
385
386 if (u32FilterThresh > 0) {
387 for (i = 0; i < u32AnchorsNum; i++) {
388 if (ps32Proposals[SAMPLE_IVE_PROPOSAL_WIDTH * i + SAMPLE_IVE_SCORE_OFFSET] < (HI_S32)u32FilterThresh) {
389 ps32Proposals[SAMPLE_IVE_PROPOSAL_WIDTH * i + SAMPLE_IVE_SUPPRESS_FLAG_OFFSET ] = 1;
390 }
391 }
392
393 u32ProposalCnt = 0;
394 for (i = 0; i < u32AnchorsNum; i++) {
395 if (ps32Proposals[SAMPLE_IVE_PROPOSAL_WIDTH * i + SAMPLE_IVE_SUPPRESS_FLAG_OFFSET ] == 0) {
396 ps32Proposals[SAMPLE_IVE_PROPOSAL_WIDTH * u32ProposalCnt] =
397 ps32Proposals[SAMPLE_IVE_PROPOSAL_WIDTH * i];
398 ps32Proposals[SAMPLE_IVE_PROPOSAL_WIDTH * u32ProposalCnt + SAMPLE_IVE_Y_MIN_OFFSET] =
399 ps32Proposals[SAMPLE_IVE_PROPOSAL_WIDTH * i + SAMPLE_IVE_Y_MIN_OFFSET];
400 ps32Proposals[SAMPLE_IVE_PROPOSAL_WIDTH * u32ProposalCnt + SAMPLE_IVE_X_MAX_OFFSET] =
401 ps32Proposals[SAMPLE_IVE_PROPOSAL_WIDTH * i + SAMPLE_IVE_X_MAX_OFFSET];
402 ps32Proposals[SAMPLE_IVE_PROPOSAL_WIDTH * u32ProposalCnt + SAMPLE_IVE_Y_MAX_OFFSET] =
403 ps32Proposals[SAMPLE_IVE_PROPOSAL_WIDTH * i + SAMPLE_IVE_Y_MAX_OFFSET];
404 ps32Proposals[SAMPLE_IVE_PROPOSAL_WIDTH * u32ProposalCnt + SAMPLE_IVE_SCORE_OFFSET] =
405 ps32Proposals[SAMPLE_IVE_PROPOSAL_WIDTH * i + SAMPLE_IVE_SCORE_OFFSET];
406 ps32Proposals[SAMPLE_IVE_PROPOSAL_WIDTH * u32ProposalCnt + SAMPLE_IVE_SUPPRESS_FLAG_OFFSET ] =
407 ps32Proposals[SAMPLE_IVE_PROPOSAL_WIDTH * i + SAMPLE_IVE_SUPPRESS_FLAG_OFFSET ];
408 u32ProposalCnt++;
409 }
410 }
411 }
412 *u32NumAfterFilter = u32ProposalCnt;
413 return HI_SUCCESS;
414 }
415
IVE_NonMaxSuppression(HI_S32 * ps32Proposals,HI_U32 u32AnchorsNum,HI_U32 u32NmsThresh,HI_U32 u32MaxRoiNum)416 static HI_S32 IVE_NonMaxSuppression(HI_S32 *ps32Proposals, HI_U32 u32AnchorsNum, HI_U32 u32NmsThresh,
417 HI_U32 u32MaxRoiNum)
418 {
419 HI_S32 s32XMin1 = 0;
420 HI_S32 s32YMin1 = 0;
421 HI_S32 s32XMax1 = 0;
422 HI_S32 s32YMax1 = 0;
423 HI_S32 s32XMin2 = 0;
424 HI_S32 s32YMin2 = 0;
425 HI_S32 s32XMax2 = 0;
426 HI_S32 s32YMax2 = 0;
427 HI_S32 s32AreaTotal = 0;
428 HI_S32 s32AreaInter = 0;
429 HI_U32 i, j;
430 HI_U32 u32Num = 0;
431 HI_BOOL bNoOverlap = HI_TRUE;
432
433 for (i = 0; i < u32AnchorsNum && u32Num < u32MaxRoiNum; i++) {
434 if (ps32Proposals[SAMPLE_IVE_PROPOSAL_WIDTH * i + SAMPLE_IVE_SUPPRESS_FLAG_OFFSET ] == 0) {
435 u32Num++;
436 s32XMin1 = ps32Proposals[SAMPLE_IVE_PROPOSAL_WIDTH * i];
437 s32YMin1 = ps32Proposals[SAMPLE_IVE_PROPOSAL_WIDTH * i + SAMPLE_IVE_Y_MIN_OFFSET];
438 s32XMax1 = ps32Proposals[SAMPLE_IVE_PROPOSAL_WIDTH * i + SAMPLE_IVE_X_MAX_OFFSET];
439 s32YMax1 = ps32Proposals[SAMPLE_IVE_PROPOSAL_WIDTH * i + SAMPLE_IVE_Y_MAX_OFFSET];
440 for (j = i + 1; j < u32AnchorsNum; j++) {
441 if (ps32Proposals[SAMPLE_IVE_PROPOSAL_WIDTH * j + SAMPLE_IVE_SUPPRESS_FLAG_OFFSET ] == 0) {
442 s32XMin2 = ps32Proposals[SAMPLE_IVE_PROPOSAL_WIDTH * j];
443 s32YMin2 = ps32Proposals[SAMPLE_IVE_PROPOSAL_WIDTH * j + SAMPLE_IVE_Y_MIN_OFFSET];
444 s32XMax2 = ps32Proposals[SAMPLE_IVE_PROPOSAL_WIDTH * j + SAMPLE_IVE_X_MAX_OFFSET];
445 s32YMax2 = ps32Proposals[SAMPLE_IVE_PROPOSAL_WIDTH * j + SAMPLE_IVE_Y_MAX_OFFSET];
446 bNoOverlap = (s32XMin2 > s32XMax1) || (s32XMax2 < s32XMin1) || (s32YMin2 > s32YMax1) ||
447 (s32YMax2 < s32YMin1);
448 if (bNoOverlap) {
449 continue;
450 }
451 (void)IVE_Overlap(s32XMin1, s32YMin1, s32XMax1, s32YMax1, s32XMin2, s32YMin2, s32XMax2, s32YMax2,
452 &s32AreaTotal, &s32AreaInter);
453 if (s32AreaInter * SAMPLE_IVE_QUANT_BASE > ((HI_S32)u32NmsThresh * s32AreaTotal)) {
454 if (ps32Proposals[SAMPLE_IVE_PROPOSAL_WIDTH * i + SAMPLE_IVE_SCORE_OFFSET] >=
455 ps32Proposals[SAMPLE_IVE_PROPOSAL_WIDTH * j + SAMPLE_IVE_SCORE_OFFSET]) {
456 ps32Proposals[SAMPLE_IVE_PROPOSAL_WIDTH * j + SAMPLE_IVE_SUPPRESS_FLAG_OFFSET ] = 1;
457 } else {
458 ps32Proposals[SAMPLE_IVE_PROPOSAL_WIDTH * i + SAMPLE_IVE_SUPPRESS_FLAG_OFFSET ] = 1;
459 }
460 }
461 }
462 }
463 }
464 }
465 return HI_SUCCESS;
466 }
467
IVE_Rpn(HI_S32 ** pps32Src,HI_U32 u32NumRatioAnchors,HI_U32 u32NumScaleAnchors,HI_U32 * au32Scales,HI_U32 * au32Ratios,HI_U32 u32OriImHeight,HI_U32 u32OriImWidth,HI_U32 * pu32ConvHeight,HI_U32 * pu32ConvWidth,HI_U32 * pu32ConvChannel,HI_U32 u32ConvStride,HI_U32 u32MaxRois,HI_U32 u32MinSize,HI_U32 u32SpatialScale,HI_U32 u32NmsThresh,HI_U32 u32FilterThresh,HI_U32 u32NumBeforeNms,HI_U32 * pu32MemPool,HI_S32 * ps32ProposalResult,HI_U32 * pu32NumRois)468 static HI_S32 IVE_Rpn(HI_S32 **pps32Src, HI_U32 u32NumRatioAnchors, HI_U32 u32NumScaleAnchors, HI_U32 *au32Scales,
469 HI_U32 *au32Ratios, HI_U32 u32OriImHeight, HI_U32 u32OriImWidth, HI_U32 *pu32ConvHeight, HI_U32 *pu32ConvWidth,
470 HI_U32 *pu32ConvChannel, HI_U32 u32ConvStride, HI_U32 u32MaxRois, HI_U32 u32MinSize, HI_U32 u32SpatialScale,
471 HI_U32 u32NmsThresh, HI_U32 u32FilterThresh, HI_U32 u32NumBeforeNms, HI_U32 *pu32MemPool,
472 HI_S32 *ps32ProposalResult, HI_U32 *pu32NumRois)
473 {
474 HI_U32 u32Size = 0;
475 HI_S32 *ps32Anchors = NULL;
476 HI_S32 *ps32BboxDelta = NULL;
477 HI_S32 *ps32Proposals = NULL;
478 HI_U32 *pu32Ptr = NULL;
479 HI_S32 *ps32Ptr = NULL;
480 HI_U32 u32NumAfterFilter = 0;
481 HI_U32 u32NumAnchors = 0;
482 HI_FLOAT f32BaseW = 0;
483 HI_FLOAT f32BaseH = 0;
484 HI_FLOAT f32BaseXCtr = 0;
485 HI_FLOAT f32BaseYCtr = 0;
486 HI_FLOAT f32SizeRatios = 0;
487 HI_FLOAT *pf32RatioAnchors = NULL;
488 HI_FLOAT *pf32Ptr = NULL;
489 HI_FLOAT *pf32Ptr2 = NULL;
490 HI_FLOAT *pf32ScaleAnchors = NULL;
491 HI_FLOAT *pf32Scores = NULL;
492 HI_FLOAT f32Ratios = 0;
493 HI_FLOAT f32Size = 0;
494 HI_U32 u32PixelInterval = 0;
495 HI_U32 u32SrcBboxIndex = 0;
496 HI_U32 u32SrcFgProbIndex = 0;
497 HI_U32 u32SrcBgProbIndex = 0;
498 HI_U32 u32SrcBboxBias = 0;
499 HI_U32 u32SrcProbBias = 0;
500 HI_U32 u32DesBox = 0;
501 HI_U32 u32BgBlobSize = 0;
502 HI_U32 u32AnchorsPerPixel = 0;
503 HI_U32 u32MapSize = 0;
504 HI_U32 u32LineSize = 0;
505 HI_S32 *ps32Ptr2 = NULL;
506 HI_S32 *ps32Ptr3 = NULL;
507 HI_S32 s32ProposalWidth = 0;
508 HI_S32 s32ProposalHeight = 0;
509 HI_S32 s32ProposalCenterX = 0;
510 HI_S32 s32ProposalCenterY = 0;
511 HI_S32 s32PredW = 0;
512 HI_S32 s32PredH = 0;
513 HI_S32 s32PredCenterX = 0;
514 HI_S32 s32PredCenterY = 0;
515 HI_U32 u32DesBboxDeltaIndex = 0;
516 HI_U32 u32DesScoreIndex = 0;
517 HI_U32 u32RoiCount = 0;
518 SAMPLE_IVE_STACK_S *pstStack = NULL;
519 HI_S32 s32Ret = HI_SUCCESS;
520 HI_U32 c = 0;
521 HI_U32 h = 0;
522 HI_U32 w = 0;
523 HI_U32 i = 0;
524 HI_U32 j = 0;
525 HI_U32 p = 0;
526 HI_U32 q = 0;
527 HI_U32 z = 0;
528 HI_U32 au32BaseAnchor[SAMPLE_IVE_KCF_BASE_ANCHOR_ARR_NUM] = {0, 0, (u32MinSize -1), (u32MinSize -1)};
529
530 /* Faster RCNN */
531 /* calculate the start pointer of each part in MemPool */
532 pu32Ptr = (HI_U32 *)pu32MemPool;
533 ps32Anchors = (HI_S32 *)pu32Ptr;
534 u32NumAnchors = u32NumRatioAnchors * u32NumScaleAnchors * (pu32ConvHeight[0] * pu32ConvWidth[0]);
535 u32Size = SAMPLE_IVE_COORDI_NUM * u32NumAnchors;
536 pu32Ptr += u32Size;
537
538 ps32BboxDelta = (HI_S32 *)pu32Ptr;
539 pu32Ptr += u32Size;
540
541 ps32Proposals = (HI_S32 *)pu32Ptr;
542 u32Size = SAMPLE_IVE_PROPOSAL_WIDTH * u32NumAnchors;
543 pu32Ptr += u32Size;
544
545 pf32RatioAnchors = (HI_FLOAT *)pu32Ptr;
546 pf32Ptr = (HI_FLOAT *)pu32Ptr;
547 u32Size = u32NumRatioAnchors * SAMPLE_IVE_COORDI_NUM;
548 pf32Ptr = pf32Ptr + u32Size;
549
550 pf32ScaleAnchors = pf32Ptr;
551 u32Size = u32NumScaleAnchors * u32NumRatioAnchors * SAMPLE_IVE_COORDI_NUM;
552 pf32Ptr = pf32Ptr + u32Size;
553
554 pf32Scores = pf32Ptr;
555 u32Size = u32NumAnchors * SAMPLE_IVE_SCORE_NUM;
556 pf32Ptr = pf32Ptr + u32Size;
557
558 pstStack = (SAMPLE_IVE_STACK_S *)pf32Ptr;
559
560 /* Generate the base anchor */
561 f32BaseW = (HI_FLOAT)(au32BaseAnchor[SAMPLE_IVE_KCF_IDX_2] - au32BaseAnchor[SAMPLE_IVE_KCF_IDX_0] + 1);
562 f32BaseH = (HI_FLOAT)(au32BaseAnchor[SAMPLE_IVE_KCF_IDX_3] - au32BaseAnchor[SAMPLE_IVE_KCF_IDX_1] + 1);
563 f32BaseXCtr = (HI_FLOAT)(au32BaseAnchor[SAMPLE_IVE_KCF_IDX_0] + ((f32BaseW - 1) * SAMPLE_IVE_HALF));
564 f32BaseYCtr = (HI_FLOAT)(au32BaseAnchor[SAMPLE_IVE_KCF_IDX_1] + ((f32BaseH - 1) * SAMPLE_IVE_HALF));
565
566 /* Generate Ratio Anchors for the base anchor */
567 pf32Ptr = pf32RatioAnchors;
568 f32Size = f32BaseW * f32BaseH;
569 for (i = 0; i < u32NumRatioAnchors; i++) {
570 f32Ratios = (HI_FLOAT)au32Ratios[i] / SAMPLE_IVE_QUANT_BASE;
571 f32SizeRatios = f32Size / f32Ratios;
572 f32BaseW = sqrt(f32SizeRatios);
573 f32BaseW = (HI_FLOAT)(1.0 *
574 ((f32BaseW) >= 0 ? (HI_S32)(f32BaseW + SAMPLE_IVE_HALF) : (HI_S32)(f32BaseW - SAMPLE_IVE_HALF)));
575 f32BaseH = f32BaseW * f32Ratios;
576 f32BaseH = (HI_FLOAT)(1.0 *
577 ((f32BaseH) >= 0 ? (HI_S32)(f32BaseH + SAMPLE_IVE_HALF) : (HI_S32)(f32BaseH - SAMPLE_IVE_HALF)));
578
579 *pf32Ptr++ = (HI_FLOAT)(f32BaseXCtr - ((f32BaseW - 1) * SAMPLE_IVE_HALF));
580 *(pf32Ptr++) = (HI_FLOAT)(f32BaseYCtr - ((f32BaseH - 1) * SAMPLE_IVE_HALF));
581 *(pf32Ptr++) = (HI_FLOAT)(f32BaseXCtr + ((f32BaseW - 1) * SAMPLE_IVE_HALF));
582 *(pf32Ptr++) = (HI_FLOAT)(f32BaseYCtr + ((f32BaseH - 1) * SAMPLE_IVE_HALF));
583 }
584
585 /* Generate Scale Anchors for each Ratio Anchor */
586 pf32Ptr = pf32RatioAnchors;
587 pf32Ptr2 = pf32ScaleAnchors;
588 /* Generate Scale Anchors for one pixel */
589 for (i = 0; i < u32NumRatioAnchors; i++) {
590 for (j = 0; j < u32NumScaleAnchors; j++) {
591 f32BaseW = *(pf32Ptr + SAMPLE_IVE_X_MAX_OFFSET) - *(pf32Ptr) + 1;
592 f32BaseH = *(pf32Ptr + SAMPLE_IVE_Y_MAX_OFFSET) - *(pf32Ptr + SAMPLE_IVE_Y_MIN_OFFSET) + 1;
593 f32BaseXCtr = (HI_FLOAT)(*(pf32Ptr) + ((f32BaseW - 1) * SAMPLE_IVE_HALF));
594 f32BaseYCtr = (HI_FLOAT)(*(pf32Ptr + 1) + ((f32BaseH - 1) * SAMPLE_IVE_HALF));
595
596 *(pf32Ptr2++) = (HI_FLOAT)(f32BaseXCtr -
597 ((f32BaseW * ((HI_FLOAT)au32Scales[j] / SAMPLE_IVE_QUANT_BASE) - 1) * SAMPLE_IVE_HALF));
598 *(pf32Ptr2++) = (HI_FLOAT)(f32BaseYCtr -
599 ((f32BaseH * ((HI_FLOAT)au32Scales[j] / SAMPLE_IVE_QUANT_BASE) - 1) * SAMPLE_IVE_HALF));
600 *(pf32Ptr2++) = (HI_FLOAT)(f32BaseXCtr +
601 ((f32BaseW * ((HI_FLOAT)au32Scales[j] / SAMPLE_IVE_QUANT_BASE) - 1) * SAMPLE_IVE_HALF));
602 *(pf32Ptr2++) = (HI_FLOAT)(f32BaseYCtr +
603 ((f32BaseH * ((HI_FLOAT)au32Scales[j] / SAMPLE_IVE_QUANT_BASE) - 1) * SAMPLE_IVE_HALF));
604 }
605 pf32Ptr += SAMPLE_IVE_COORDI_NUM;
606 }
607
608 /* Copy the anchors to every pixel in the feature map */
609 ps32Ptr = ps32Anchors;
610 if (u32SpatialScale == 0) {
611 printf("Divisor u32SpatialScale cannot be 0!\n");
612 return HI_FAILURE;
613 }
614 u32PixelInterval = SAMPLE_IVE_QUANT_BASE / u32SpatialScale;
615
616 for (p = 0; p < pu32ConvHeight[0]; p++) {
617 for (q = 0; q < pu32ConvWidth[0]; q++) {
618 pf32Ptr2 = pf32ScaleAnchors;
619 for (z = 0; z < u32NumScaleAnchors * u32NumRatioAnchors; z++) {
620 *(ps32Ptr++) = (HI_S32)(q * u32PixelInterval + *(pf32Ptr2++));
621 *(ps32Ptr++) = (HI_S32)(p * u32PixelInterval + *(pf32Ptr2++));
622 *(ps32Ptr++) = (HI_S32)(q * u32PixelInterval + *(pf32Ptr2++));
623 *(ps32Ptr++) = (HI_S32)(p * u32PixelInterval + *(pf32Ptr2++));
624 }
625 }
626 }
627
628 /* do transpose, convert the blob from (M,C,H,W) to (M,H,W,C) */
629 u32MapSize = pu32ConvHeight[1] * u32ConvStride / sizeof(HI_U32);
630 u32AnchorsPerPixel = u32NumRatioAnchors * u32NumScaleAnchors;
631 u32BgBlobSize = u32AnchorsPerPixel * u32MapSize;
632 u32LineSize = u32ConvStride / sizeof(HI_U32);
633 u32SrcProbBias = 0;
634 u32SrcBboxBias = 0;
635
636 for (c = 0; c < pu32ConvChannel[1]; c++) {
637 for (h = 0; h < pu32ConvHeight[1]; h++) {
638 for (w = 0; w < pu32ConvWidth[1]; w++) {
639 u32SrcBboxIndex = u32SrcBboxBias + c * u32MapSize + h * u32LineSize + w;
640 u32SrcBgProbIndex = u32SrcProbBias + (c / SAMPLE_IVE_COORDI_NUM) * u32MapSize + h * u32LineSize + w;
641 u32SrcFgProbIndex = u32BgBlobSize + u32SrcBgProbIndex;
642
643 u32DesBox = (u32AnchorsPerPixel) * (h * pu32ConvWidth[1] + w) + c / SAMPLE_IVE_COORDI_NUM;
644
645 u32DesBboxDeltaIndex = SAMPLE_IVE_COORDI_NUM * u32DesBox + c % SAMPLE_IVE_COORDI_NUM;
646 ps32BboxDelta[u32DesBboxDeltaIndex] = (HI_S32)pps32Src[1][u32SrcBboxIndex];
647
648 u32DesScoreIndex = (SAMPLE_IVE_SCORE_NUM)*u32DesBox;
649 pf32Scores[u32DesScoreIndex] =
650 (HI_FLOAT)((HI_S32)pps32Src[0][u32SrcBgProbIndex]) / SAMPLE_IVE_QUANT_BASE;
651 pf32Scores[u32DesScoreIndex + 1] =
652 (HI_FLOAT)((HI_S32)pps32Src[0][u32SrcFgProbIndex]) / SAMPLE_IVE_QUANT_BASE;
653 }
654 }
655 }
656
657 /* do softmax */
658 pf32Ptr = pf32Scores;
659 for (i = 0; i < u32NumAnchors; i++) {
660 s32Ret = IVE_SoftMax(pf32Ptr, SAMPLE_IVE_SCORE_NUM);
661 pf32Ptr += SAMPLE_IVE_SCORE_NUM;
662 }
663
664 /* BBox Transform */
665 /* use parameters from Conv3 to adjust the coordinates of anchors */
666 ps32Ptr = ps32Anchors;
667 ps32Ptr2 = ps32Proposals;
668 ps32Ptr3 = ps32BboxDelta;
669 for (i = 0; i < u32NumAnchors; i++) {
670 ps32Ptr = ps32Anchors;
671 ps32Ptr = ps32Ptr + SAMPLE_IVE_COORDI_NUM * i;
672 ps32Ptr2 = ps32Proposals;
673 ps32Ptr2 = ps32Ptr2 + SAMPLE_IVE_PROPOSAL_WIDTH * i;
674 ps32Ptr3 = ps32BboxDelta;
675 ps32Ptr3 = ps32Ptr3 + SAMPLE_IVE_COORDI_NUM * i;
676 pf32Ptr = pf32Scores;
677 pf32Ptr = pf32Ptr + i * (SAMPLE_IVE_SCORE_NUM);
678
679 s32ProposalWidth = *(ps32Ptr + SAMPLE_IVE_X_MAX_OFFSET) - *(ps32Ptr) + 1;
680 s32ProposalHeight = *(ps32Ptr + SAMPLE_IVE_Y_MAX_OFFSET) - *(ps32Ptr + SAMPLE_IVE_Y_MIN_OFFSET) + 1;
681 s32ProposalCenterX = *(ps32Ptr) + (HI_S32)(s32ProposalWidth * SAMPLE_IVE_HALF);
682 s32ProposalCenterY = *(ps32Ptr + 1) + (HI_S32)(s32ProposalHeight * SAMPLE_IVE_HALF);
683 s32PredCenterX =
684 (HI_S32)(((HI_FLOAT)(*(ps32Ptr3)) / SAMPLE_IVE_QUANT_BASE) * s32ProposalWidth + s32ProposalCenterX);
685 s32PredCenterY =
686 (HI_S32)(((HI_FLOAT)(*(ps32Ptr3 + 1)) / SAMPLE_IVE_QUANT_BASE) * s32ProposalHeight + s32ProposalCenterY);
687
688 s32PredW = (HI_S32)(s32ProposalWidth * IVE_QuickExp((HI_S32)(*(ps32Ptr3 + SAMPLE_IVE_X_MAX_OFFSET))));
689 s32PredH = (HI_S32)(s32ProposalHeight * IVE_QuickExp((HI_S32)(*(ps32Ptr3 + SAMPLE_IVE_Y_MAX_OFFSET))));
690 *(ps32Ptr2) = (HI_S32)(s32PredCenterX - SAMPLE_IVE_HALF * s32PredW);
691 *(ps32Ptr2 + SAMPLE_IVE_Y_MIN_OFFSET) = (HI_S32)(s32PredCenterY - SAMPLE_IVE_HALF * s32PredH);
692 *(ps32Ptr2 + SAMPLE_IVE_X_MAX_OFFSET) = (HI_S32)(s32PredCenterX + SAMPLE_IVE_HALF * s32PredW);
693 *(ps32Ptr2 + SAMPLE_IVE_Y_MAX_OFFSET) = (HI_S32)(s32PredCenterY + SAMPLE_IVE_HALF * s32PredH);
694 *(ps32Ptr2 + SAMPLE_IVE_SCORE_OFFSET) = (HI_S32)(*(pf32Ptr + 1) * SAMPLE_IVE_QUANT_BASE);
695 *(ps32Ptr2 + SAMPLE_IVE_SUPPRESS_FLAG_OFFSET) = 0;
696 }
697
698 /* clip bbox */
699 for (i = 0; i < u32NumAnchors; i++) {
700 ps32Ptr = ps32Proposals;
701 ps32Ptr = ps32Ptr + SAMPLE_IVE_PROPOSAL_WIDTH * i;
702 *ps32Ptr = SAMPLE_IVE_MAX(SAMPLE_IVE_MIN(*ps32Ptr, (HI_S32)u32OriImWidth - 1), 0);
703 *(ps32Ptr + SAMPLE_IVE_Y_MIN_OFFSET) =
704 SAMPLE_IVE_MAX(SAMPLE_IVE_MIN(*(ps32Ptr + SAMPLE_IVE_Y_MIN_OFFSET), (HI_S32)u32OriImHeight - 1), 0);
705 *(ps32Ptr + SAMPLE_IVE_X_MAX_OFFSET) =
706 SAMPLE_IVE_MAX(SAMPLE_IVE_MIN(*(ps32Ptr + SAMPLE_IVE_X_MAX_OFFSET), (HI_S32)u32OriImWidth - 1), 0);
707 *(ps32Ptr + SAMPLE_IVE_Y_MAX_OFFSET) =
708 SAMPLE_IVE_MAX(SAMPLE_IVE_MIN(*(ps32Ptr + SAMPLE_IVE_Y_MAX_OFFSET), (HI_S32)u32OriImHeight - 1), 0);
709 }
710
711 /* remove the bboxes which are too small */
712 for (i = 0; i < u32NumAnchors; i++) {
713 ps32Ptr = ps32Proposals;
714 ps32Ptr = ps32Ptr + SAMPLE_IVE_PROPOSAL_WIDTH * i;
715 s32ProposalWidth = *(ps32Ptr + SAMPLE_IVE_X_MAX_OFFSET) - *(ps32Ptr) + 1;
716 s32ProposalHeight = *(ps32Ptr + SAMPLE_IVE_Y_MAX_OFFSET) - *(ps32Ptr + SAMPLE_IVE_Y_MIN_OFFSET) + 1;
717 if (s32ProposalWidth < (HI_S32)u32MinSize || s32ProposalHeight < (HI_S32)u32MinSize) {
718 *(ps32Ptr + SAMPLE_IVE_SUPPRESS_FLAG_OFFSET) = 1;
719 }
720 }
721
722 /* remove low score bboxes */
723 (void)IVE_FilterLowScoreBbox(ps32Proposals, u32NumAnchors, u32FilterThresh, &u32NumAfterFilter);
724 if (u32NumAfterFilter >= 1) {
725 (void)IVE_NonRecursiveArgQuickSort(ps32Proposals, 0, u32NumAfterFilter - 1, pstStack, u32NumBeforeNms);
726 }
727 u32NumAfterFilter = (u32NumAfterFilter < u32NumBeforeNms) ? u32NumAfterFilter : u32NumBeforeNms;
728
729 /* do nms to remove highly overlapped bbox */
730 (void)IVE_NonMaxSuppression(ps32Proposals, u32NumAfterFilter, u32NmsThresh, u32MaxRois); /* function NMS */
731
732 /* write the final result to output */
733 u32RoiCount = 0;
734 for (i = 0; i < u32NumAfterFilter; i++) {
735 ps32Ptr = ps32Proposals;
736 ps32Ptr = ps32Ptr + SAMPLE_IVE_PROPOSAL_WIDTH * i;
737 if (*(ps32Ptr + SAMPLE_IVE_SUPPRESS_FLAG_OFFSET) == 0) {
738 /* In this sample,the output Roi coordinates will be input in hardware,
739 so the type coordinates are convert to HI_S20Q12 */
740 ps32ProposalResult[SAMPLE_IVE_COORDI_NUM * u32RoiCount] = *ps32Ptr * SAMPLE_IVE_QUANT_BASE;
741 ps32ProposalResult[SAMPLE_IVE_COORDI_NUM * u32RoiCount + SAMPLE_IVE_Y_MIN_OFFSET] =
742 *(ps32Ptr + SAMPLE_IVE_Y_MIN_OFFSET) * SAMPLE_IVE_QUANT_BASE;
743 ps32ProposalResult[SAMPLE_IVE_COORDI_NUM * u32RoiCount + SAMPLE_IVE_X_MAX_OFFSET] =
744 *(ps32Ptr + SAMPLE_IVE_X_MAX_OFFSET) * SAMPLE_IVE_QUANT_BASE;
745 ps32ProposalResult[SAMPLE_IVE_COORDI_NUM * u32RoiCount + SAMPLE_IVE_Y_MAX_OFFSET] =
746 *(ps32Ptr + SAMPLE_IVE_Y_MAX_OFFSET) * SAMPLE_IVE_QUANT_BASE;
747 u32RoiCount++;
748 }
749 if (u32RoiCount >= u32MaxRois) {
750 break;
751 }
752 }
753
754 *pu32NumRois = u32RoiCount;
755
756 return s32Ret;
757 }
758
IVE_Rfcn_GetResult(HI_S32 * ps32FcScore,HI_U32 u32FcScoreStride,HI_S32 * ps32FcBbox,HI_U32 u32FcBboxStride,HI_S32 * ps32Proposals,HI_U32 u32RoiCnt,HI_U32 * pu32ConfThresh,HI_U32 u32MaxRoi,HI_U32 u32ClassNum,HI_U32 u32OriImWidth,HI_U32 u32OriImHeight,HI_U32 u32NmsThresh,HI_U32 * pu32MemPool,HI_S32 * ps32DstScores,HI_S32 * ps32DstRoi,HI_S32 * ps32ClassRoiNum)759 static HI_S32 IVE_Rfcn_GetResult(HI_S32 *ps32FcScore, HI_U32 u32FcScoreStride, HI_S32 *ps32FcBbox,
760 HI_U32 u32FcBboxStride, HI_S32 *ps32Proposals, HI_U32 u32RoiCnt, HI_U32 *pu32ConfThresh, HI_U32 u32MaxRoi,
761 HI_U32 u32ClassNum, HI_U32 u32OriImWidth, HI_U32 u32OriImHeight, HI_U32 u32NmsThresh, HI_U32 *pu32MemPool,
762 HI_S32 *ps32DstScores, HI_S32 *ps32DstRoi, HI_S32 *ps32ClassRoiNum)
763 {
764 HI_U32 u32Size = 0;
765 HI_U32 u32ClsScoreChannels = 0;
766 HI_U32 u32FcScoreWidth = 0;
767 HI_FLOAT f32ProposalWidth = 0.0;
768 HI_FLOAT f32ProposalHeight = 0.0;
769 HI_FLOAT f32ProposalCenterX = 0.0;
770 HI_FLOAT f32ProposalCenterY = 0.0;
771 HI_FLOAT f32PredW = 0.0;
772 HI_FLOAT f32PredH = 0.0;
773 HI_FLOAT f32PredCenterX = 0.0;
774 HI_FLOAT f32PredCenterY = 0.0;
775 HI_FLOAT *pf32FcScoresMemPool = NULL;
776 HI_S32 *ps32FcBboxMemPool = NULL;
777 HI_S32 *ps32ProposalMemPool = NULL;
778 HI_S32 *ps32ProposalTmp = NULL;
779 HI_U32 u32FcBboxIndex = 0;
780 HI_U32 u32ProposalMemPoolIndex = 0;
781 HI_FLOAT *pf32Ptr = NULL;
782 HI_S32 *ps32Ptr = NULL;
783 HI_S32 *ps32DstScore = NULL;
784 HI_S32 *ps32DstBbox = NULL;
785 HI_U32 u32RoiOutCnt = 0;
786 HI_U32 u32SrcIndex = 0;
787 HI_U32 u32DstIndex = 0;
788 HI_U32 i = 0;
789 HI_U32 j = 0;
790 HI_U32 u32OffSet = 0;
791 SAMPLE_IVE_STACK_S *pstStack = NULL;
792 HI_S32 s32Ret = HI_SUCCESS;
793
794 /* Get or calculate parameters */
795 u32ClsScoreChannels = u32ClassNum; /* channel num is equal to class size, cls_score class */
796 u32FcScoreWidth = u32ClsScoreChannels;
797
798 /* Get Start Pointer of MemPool */
799 pf32FcScoresMemPool = (HI_FLOAT *)(pu32MemPool);
800 pf32Ptr = pf32FcScoresMemPool;
801 u32Size = u32MaxRoi * u32ClsScoreChannels;
802 pf32Ptr += u32Size;
803
804 ps32FcBboxMemPool = (HI_S32 *)pf32Ptr;
805 ps32Ptr = (HI_S32 *)pf32Ptr;
806 u32Size = u32MaxRoi * SAMPLE_IVE_COORDI_NUM;
807 ps32Ptr += u32Size;
808
809 ps32ProposalMemPool = (HI_S32 *)ps32Ptr;
810 ps32Ptr = ps32ProposalMemPool;
811 u32Size = u32MaxRoi * SAMPLE_IVE_PROPOSAL_WIDTH;
812 ps32Ptr += u32Size;
813 pstStack = (SAMPLE_IVE_STACK_S *)ps32Ptr;
814
815 // prepare input data
816 for (i = 0; i < u32RoiCnt; i++) {
817 for (j = 0; j < u32ClsScoreChannels; j++) {
818 u32DstIndex = u32FcScoreWidth * i + j;
819 u32SrcIndex = u32FcScoreStride / sizeof(HI_U32) * i + j;
820 pf32FcScoresMemPool[u32DstIndex] = (HI_FLOAT)(ps32FcScore[u32SrcIndex]) / SAMPLE_IVE_QUANT_BASE;
821 }
822 }
823
824 for (i = 0; i < u32RoiCnt; i++) {
825 for (j = 0; j < SAMPLE_IVE_COORDI_NUM; j++) {
826 u32SrcIndex = u32FcBboxStride / sizeof(HI_U32) * i + SAMPLE_IVE_COORDI_NUM + j;
827 u32DstIndex = SAMPLE_IVE_COORDI_NUM * i + j;
828 ps32FcBboxMemPool[u32DstIndex] = ps32FcBbox[u32SrcIndex];
829 }
830 }
831 /*
832 * bbox transform
833 * change the fc output to Proposal temp MemPool.
834 * Each Line of the Proposal has 6 bits.
835 * The Format of the Proposal is:
836 * 0-3: The four coordinate of the bbox, x1,y1,x2, y2
837 * 4: The Confidence Score of the bbox
838 * 5: The suprressed flag
839 */
840 for (j = 0; j < u32ClsScoreChannels; j++) {
841 for (i = 0; i < u32RoiCnt; i++) {
842 f32ProposalWidth = ps32Proposals[SAMPLE_IVE_COORDI_NUM * i + SAMPLE_IVE_X_MAX_OFFSET] -
843 ps32Proposals[SAMPLE_IVE_COORDI_NUM * i] + 1;
844 f32ProposalHeight = ps32Proposals[SAMPLE_IVE_COORDI_NUM * i + SAMPLE_IVE_Y_MAX_OFFSET] -
845 ps32Proposals[SAMPLE_IVE_COORDI_NUM * i + SAMPLE_IVE_Y_MIN_OFFSET] + 1;
846 f32ProposalCenterX = ps32Proposals[SAMPLE_IVE_COORDI_NUM * i] + SAMPLE_IVE_HALF * f32ProposalWidth;
847 f32ProposalCenterY = ps32Proposals[SAMPLE_IVE_COORDI_NUM * i + SAMPLE_IVE_Y_MIN_OFFSET] +
848 SAMPLE_IVE_HALF * f32ProposalHeight;
849
850 u32FcBboxIndex = SAMPLE_IVE_COORDI_NUM * i;
851 f32PredCenterX = ((HI_FLOAT)ps32FcBboxMemPool[u32FcBboxIndex] / SAMPLE_IVE_QUANT_BASE) * f32ProposalWidth +
852 f32ProposalCenterX;
853 f32PredCenterY = ((HI_FLOAT)ps32FcBboxMemPool[u32FcBboxIndex + 1] / SAMPLE_IVE_QUANT_BASE) *
854 f32ProposalHeight + f32ProposalCenterY;
855 f32PredW = f32ProposalWidth * IVE_QuickExp(ps32FcBboxMemPool[u32FcBboxIndex + SAMPLE_IVE_X_MAX_OFFSET]);
856 f32PredH = f32ProposalHeight * IVE_QuickExp(ps32FcBboxMemPool[u32FcBboxIndex + SAMPLE_IVE_Y_MAX_OFFSET]);
857
858 u32ProposalMemPoolIndex = SAMPLE_IVE_PROPOSAL_WIDTH * i;
859 ps32ProposalMemPool[u32ProposalMemPoolIndex] = (HI_S32)(f32PredCenterX - SAMPLE_IVE_HALF * f32PredW);
860 ps32ProposalMemPool[u32ProposalMemPoolIndex + SAMPLE_IVE_Y_MIN_OFFSET] =
861 (HI_S32)(f32PredCenterY - SAMPLE_IVE_HALF * f32PredH);
862 ps32ProposalMemPool[u32ProposalMemPoolIndex + SAMPLE_IVE_X_MAX_OFFSET] =
863 (HI_S32)(f32PredCenterX + SAMPLE_IVE_HALF * f32PredW);
864 ps32ProposalMemPool[u32ProposalMemPoolIndex + SAMPLE_IVE_Y_MAX_OFFSET] =
865 (HI_S32)(f32PredCenterY + SAMPLE_IVE_HALF * f32PredH);
866 ps32ProposalMemPool[u32ProposalMemPoolIndex + SAMPLE_IVE_SCORE_OFFSET] =
867 (HI_S32)(pf32FcScoresMemPool[u32ClsScoreChannels * i + j] * SAMPLE_IVE_QUANT_BASE);
868 ps32ProposalMemPool[u32ProposalMemPoolIndex + SAMPLE_IVE_SUPPRESS_FLAG_OFFSET ] = 0; /* suprressed flag */
869 }
870
871 /* clip bbox */
872 for (i = 0; i < u32RoiCnt; i++) {
873 u32ProposalMemPoolIndex = SAMPLE_IVE_PROPOSAL_WIDTH * i;
874 ps32ProposalMemPool[u32ProposalMemPoolIndex] =
875 ((ps32ProposalMemPool[u32ProposalMemPoolIndex]) > ((HI_S32)u32OriImWidth - 1) ?
876 ((HI_S32)u32OriImWidth - 1) : (ps32ProposalMemPool[u32ProposalMemPoolIndex])) > 0 ?
877 ((ps32ProposalMemPool[u32ProposalMemPoolIndex]) > ((HI_S32)u32OriImWidth) ?
878 (HI_S32)(u32OriImWidth - 1) : (ps32ProposalMemPool[u32ProposalMemPoolIndex])) : 0;
879 ps32ProposalMemPool[u32ProposalMemPoolIndex + SAMPLE_IVE_Y_MIN_OFFSET] =
880 ((ps32ProposalMemPool[u32ProposalMemPoolIndex + SAMPLE_IVE_Y_MIN_OFFSET]) >
881 ((HI_S32)u32OriImHeight - 1) ? ((HI_S32)u32OriImHeight - 1) :
882 (ps32ProposalMemPool[u32ProposalMemPoolIndex + SAMPLE_IVE_Y_MIN_OFFSET])) > 0 ?
883 ((ps32ProposalMemPool[u32ProposalMemPoolIndex + SAMPLE_IVE_Y_MIN_OFFSET]) > ((HI_S32)u32OriImHeight) ?
884 (HI_S32)(u32OriImHeight - 1) : (ps32ProposalMemPool[u32ProposalMemPoolIndex +
885 SAMPLE_IVE_Y_MIN_OFFSET])) : 0;
886 ps32ProposalMemPool[u32ProposalMemPoolIndex + SAMPLE_IVE_X_MAX_OFFSET] =
887 ((ps32ProposalMemPool[u32ProposalMemPoolIndex + SAMPLE_IVE_X_MAX_OFFSET]) >
888 ((HI_S32)u32OriImWidth - 1) ? ((HI_S32)u32OriImWidth - 1) :
889 (ps32ProposalMemPool[u32ProposalMemPoolIndex + SAMPLE_IVE_X_MAX_OFFSET])) > 0 ?
890 ((ps32ProposalMemPool[u32ProposalMemPoolIndex + SAMPLE_IVE_X_MAX_OFFSET]) > ((HI_S32)u32OriImWidth) ?
891 (HI_S32)(u32OriImWidth - 1) : (ps32ProposalMemPool[u32ProposalMemPoolIndex +
892 SAMPLE_IVE_X_MAX_OFFSET])) : 0;
893 ps32ProposalMemPool[u32ProposalMemPoolIndex + SAMPLE_IVE_Y_MAX_OFFSET] =
894 ((ps32ProposalMemPool[u32ProposalMemPoolIndex + SAMPLE_IVE_Y_MAX_OFFSET]) >
895 ((HI_S32)u32OriImHeight - 1) ? ((HI_S32)u32OriImHeight - 1) :
896 (ps32ProposalMemPool[u32ProposalMemPoolIndex + SAMPLE_IVE_Y_MAX_OFFSET])) > 0 ?
897 ((ps32ProposalMemPool[u32ProposalMemPoolIndex + SAMPLE_IVE_Y_MAX_OFFSET]) > ((HI_S32)u32OriImHeight) ?
898 (HI_S32)(u32OriImHeight - 1) :
899 (ps32ProposalMemPool[u32ProposalMemPoolIndex + SAMPLE_IVE_Y_MAX_OFFSET])) : 0;
900 }
901
902 ps32ProposalTmp = ps32ProposalMemPool;
903 if (u32RoiCnt >= 1) {
904 (hi_void)IVE_NonRecursiveArgQuickSort(ps32ProposalTmp, 0, u32RoiCnt - 1, pstStack, u32RoiCnt);
905 }
906 s32Ret = IVE_NonMaxSuppression(ps32ProposalTmp, u32RoiCnt, u32NmsThresh, u32RoiCnt);
907 u32RoiOutCnt = 0;
908
909 ps32DstScore = (HI_S32 *)ps32DstScores;
910 ps32DstBbox = (HI_S32 *)ps32DstRoi;
911
912 ps32DstScore += (HI_S32)u32OffSet;
913 ps32DstBbox += (HI_S32)(SAMPLE_IVE_COORDI_NUM * u32OffSet);
914 for (i = 0; i < u32RoiCnt; i++) {
915 u32ProposalMemPoolIndex = SAMPLE_IVE_PROPOSAL_WIDTH * i;
916 if ((ps32ProposalMemPool[u32ProposalMemPoolIndex + SAMPLE_IVE_SUPPRESS_FLAG_OFFSET] == 0) &&
917 (ps32ProposalMemPool[u32ProposalMemPoolIndex + SAMPLE_IVE_SCORE_OFFSET] > (HI_S32)pu32ConfThresh[j])) {
918 ps32DstScore[u32RoiOutCnt] = ps32ProposalMemPool[u32ProposalMemPoolIndex + SAMPLE_IVE_SCORE_OFFSET];
919 ps32DstBbox[u32RoiOutCnt * SAMPLE_IVE_COORDI_NUM] = ps32ProposalMemPool[u32ProposalMemPoolIndex];
920 ps32DstBbox[u32RoiOutCnt * SAMPLE_IVE_COORDI_NUM + SAMPLE_IVE_Y_MIN_OFFSET] =
921 ps32ProposalMemPool[u32ProposalMemPoolIndex + SAMPLE_IVE_Y_MIN_OFFSET];
922 ps32DstBbox[u32RoiOutCnt * SAMPLE_IVE_COORDI_NUM + SAMPLE_IVE_X_MAX_OFFSET] =
923 ps32ProposalMemPool[u32ProposalMemPoolIndex + SAMPLE_IVE_X_MAX_OFFSET];
924 ps32DstBbox[u32RoiOutCnt * SAMPLE_IVE_COORDI_NUM + SAMPLE_IVE_Y_MAX_OFFSET] =
925 ps32ProposalMemPool[u32ProposalMemPoolIndex + SAMPLE_IVE_Y_MAX_OFFSET];
926 u32RoiOutCnt++;
927 }
928 if (u32RoiOutCnt >= u32RoiCnt) {
929 break;
930 }
931 }
932 ps32ClassRoiNum[j] = (HI_S32)u32RoiOutCnt;
933 u32OffSet = u32OffSet + u32RoiOutCnt;
934 }
935
936 return s32Ret;
937 }
938
SAMPLE_IVE_RpnTmpBufSize(HI_U32 u32NumRatioAnchors,HI_U32 u32NumScaleAnchors,HI_U32 u32ConvHeight,HI_U32 u32ConvWidth)939 static HI_U32 SAMPLE_IVE_RpnTmpBufSize(HI_U32 u32NumRatioAnchors, HI_U32 u32NumScaleAnchors, HI_U32 u32ConvHeight,
940 HI_U32 u32ConvWidth)
941 {
942 HI_U32 u32AnchorsNum = u32NumRatioAnchors * u32NumScaleAnchors * u32ConvHeight * u32ConvWidth;
943 HI_U32 u32AnchorsSize = sizeof(HI_U32) * SAMPLE_IVE_COORDI_NUM * u32AnchorsNum;
944 HI_U32 u32BboxDeltaSize = u32AnchorsSize;
945 HI_U32 u32ProposalSize = sizeof(HI_U32) * SAMPLE_IVE_PROPOSAL_WIDTH * u32AnchorsNum;
946 HI_U32 u32RatioAnchorsSize = sizeof(HI_FLOAT) * u32NumRatioAnchors * SAMPLE_IVE_COORDI_NUM;
947 HI_U32 u32ScaleAnchorsSize = sizeof(HI_FLOAT) * u32NumRatioAnchors * u32NumScaleAnchors * SAMPLE_IVE_COORDI_NUM;
948 HI_U32 u32ScoreSize = sizeof(HI_FLOAT) * u32AnchorsNum * 2;
949 HI_U32 u32StackSize = sizeof(SAMPLE_IVE_STACK_S) * u32AnchorsNum;
950 HI_U32 u32TotalSize = u32AnchorsSize + u32BboxDeltaSize + u32ProposalSize + u32RatioAnchorsSize +
951 u32ScaleAnchorsSize + u32ScoreSize + u32StackSize;
952 return u32TotalSize;
953 }
954
SAMPLE_IVE_Rfcn_GetResultTmpBuf(HI_U32 u32MaxRoiNum,HI_U32 u32ClassNum)955 static HI_U32 SAMPLE_IVE_Rfcn_GetResultTmpBuf(HI_U32 u32MaxRoiNum, HI_U32 u32ClassNum)
956 {
957 HI_U32 u32ScoreSize = sizeof(HI_FLOAT) * u32MaxRoiNum * u32ClassNum;
958 HI_U32 u32ProposalSize = sizeof(HI_U32) * u32MaxRoiNum * SAMPLE_IVE_PROPOSAL_WIDTH;
959 HI_U32 u32BboxSize = sizeof(HI_U32) * u32MaxRoiNum * SAMPLE_IVE_COORDI_NUM;
960 HI_U32 u32StackSize = sizeof(SAMPLE_IVE_STACK_S) * u32MaxRoiNum;
961 HI_U32 u32TotalSize = u32ScoreSize + u32ProposalSize + u32BboxSize + u32StackSize;
962 return u32TotalSize;
963 }
964
SAMPLE_IVE_Rfcn_Rpn(SAMPLE_SVP_NNIE_RFCN_SOFTWARE_PARAM_S * pstSoftwareParam)965 static HI_S32 SAMPLE_IVE_Rfcn_Rpn(SAMPLE_SVP_NNIE_RFCN_SOFTWARE_PARAM_S *pstSoftwareParam)
966 {
967 HI_S32 s32Ret = HI_SUCCESS;
968
969 s32Ret = IVE_Rpn(pstSoftwareParam->aps32Conv, pstSoftwareParam->u32NumRatioAnchors,
970 pstSoftwareParam->u32NumScaleAnchors, pstSoftwareParam->au32Scales, pstSoftwareParam->au32Ratios,
971 pstSoftwareParam->u32OriImHeight, pstSoftwareParam->u32OriImWidth, pstSoftwareParam->au32ConvHeight,
972 pstSoftwareParam->au32ConvWidth, pstSoftwareParam->au32ConvChannel, pstSoftwareParam->u32ConvStride,
973 pstSoftwareParam->u32MaxRoiNum, pstSoftwareParam->u32MinSize, pstSoftwareParam->u32SpatialScale,
974 pstSoftwareParam->u32NmsThresh, pstSoftwareParam->u32FilterThresh, pstSoftwareParam->u32NumBeforeNms,
975 SAMPLE_SVP_NNIE_CONVERT_64BIT_ADDR(HI_U32, pstSoftwareParam->stRpnTmpBuf.u64VirAddr),
976 SAMPLE_SVP_NNIE_CONVERT_64BIT_ADDR(HI_S32, pstSoftwareParam->stRpnBbox.u64VirAddr),
977 &pstSoftwareParam->stRpnBbox.unShape.stWhc.u32Height);
978
979 SAMPLE_COMM_SVP_FlushCache(pstSoftwareParam->stRpnBbox.u64PhyAddr,
980 SAMPLE_SVP_NNIE_CONVERT_64BIT_ADDR(HI_VOID, pstSoftwareParam->stRpnBbox.u64VirAddr),
981 pstSoftwareParam->stRpnBbox.u32Num * pstSoftwareParam->stRpnBbox.unShape.stWhc.u32Chn *
982 pstSoftwareParam->stRpnBbox.unShape.stWhc.u32Height * pstSoftwareParam->stRpnBbox.u32Stride);
983 SAMPLE_SVP_CHECK_EXPR_RET(s32Ret != HI_SUCCESS, s32Ret, SAMPLE_SVP_ERR_LEVEL_ERROR, "Error,IVE_Rpn failed!\n");
984
985 return s32Ret;
986 }
987
SAMPLE_IVE_Rfcn_GetResult(SAMPLE_SVP_NNIE_PARAM_S * pstNnieParam,SAMPLE_SVP_NNIE_RFCN_SOFTWARE_PARAM_S * pstSoftwareParam)988 static HI_S32 SAMPLE_IVE_Rfcn_GetResult(SAMPLE_SVP_NNIE_PARAM_S *pstNnieParam,
989 SAMPLE_SVP_NNIE_RFCN_SOFTWARE_PARAM_S *pstSoftwareParam)
990 {
991 HI_S32 s32Ret = HI_SUCCESS;
992 HI_U32 i = 0;
993 HI_S32 *ps32Proposal = SAMPLE_SVP_NNIE_CONVERT_64BIT_ADDR(HI_S32, pstSoftwareParam->stRpnBbox.u64VirAddr);
994
995 SAMPLE_SVP_CHECK_EXPR_RET(pstSoftwareParam->stRpnBbox.u64VirAddr == 0, HI_INVALID_VALUE, SAMPLE_SVP_ERR_LEVEL_ERROR,
996 "Error,pstSoftwareParam->stRpnBbox.u64VirAddr can't be 0!\n");
997 for (i = 0; i < pstSoftwareParam->stRpnBbox.unShape.stWhc.u32Height; i++) {
998 *(ps32Proposal + SAMPLE_IVE_COORDI_NUM * i) /= SAMPLE_IVE_QUANT_BASE;
999 *(ps32Proposal + SAMPLE_IVE_COORDI_NUM * i + SAMPLE_IVE_Y_MIN_OFFSET) /= SAMPLE_IVE_QUANT_BASE;
1000 *(ps32Proposal + SAMPLE_IVE_COORDI_NUM * i + SAMPLE_IVE_X_MAX_OFFSET) /= SAMPLE_IVE_QUANT_BASE;
1001 *(ps32Proposal + SAMPLE_IVE_COORDI_NUM * i + SAMPLE_IVE_Y_MAX_OFFSET) /= SAMPLE_IVE_QUANT_BASE;
1002 }
1003 s32Ret =
1004 IVE_Rfcn_GetResult(SAMPLE_SVP_NNIE_CONVERT_64BIT_ADDR(HI_S32,
1005 pstNnieParam->astSegData[SAMPLE_IVE_KCF_SEG_1].astDst[0].u64VirAddr),
1006 pstNnieParam->astSegData[SAMPLE_IVE_KCF_SEG_1].astDst[0].u32Stride,
1007 SAMPLE_SVP_NNIE_CONVERT_64BIT_ADDR(HI_S32,
1008 pstNnieParam->astSegData[SAMPLE_IVE_KCF_SEG_2].astDst[0].u64VirAddr),
1009 pstNnieParam->astSegData[SAMPLE_IVE_KCF_SEG_2].astDst[0].u32Stride,
1010 SAMPLE_SVP_NNIE_CONVERT_64BIT_ADDR(HI_S32, pstSoftwareParam->stRpnBbox.u64VirAddr),
1011 pstSoftwareParam->stRpnBbox.unShape.stWhc.u32Height, pstSoftwareParam->au32ConfThresh,
1012 pstSoftwareParam->u32MaxRoiNum, pstSoftwareParam->u32ClassNum, pstSoftwareParam->u32OriImWidth,
1013 pstSoftwareParam->u32OriImHeight, pstSoftwareParam->u32ValidNmsThresh,
1014 SAMPLE_SVP_NNIE_CONVERT_64BIT_ADDR(HI_U32, pstSoftwareParam->stGetResultTmpBuf.u64VirAddr),
1015 SAMPLE_SVP_NNIE_CONVERT_64BIT_ADDR(HI_S32, pstSoftwareParam->stDstScore.u64VirAddr),
1016 SAMPLE_SVP_NNIE_CONVERT_64BIT_ADDR(HI_S32, pstSoftwareParam->stDstRoi.u64VirAddr),
1017 SAMPLE_SVP_NNIE_CONVERT_64BIT_ADDR(HI_S32, pstSoftwareParam->stClassRoiNum.u64VirAddr));
1018 SAMPLE_SVP_CHECK_EXPR_RET(s32Ret != HI_SUCCESS, s32Ret, SAMPLE_SVP_ERR_LEVEL_ERROR,
1019 "Error,IVE_Rfcn_GetResult failed!\n");
1020 return s32Ret;
1021 }
1022
SAMPLE_IVE_Rfcn_SoftwareDeinit(SAMPLE_SVP_NNIE_RFCN_SOFTWARE_PARAM_S * pstSoftWareParam)1023 static HI_S32 SAMPLE_IVE_Rfcn_SoftwareDeinit(SAMPLE_SVP_NNIE_RFCN_SOFTWARE_PARAM_S *pstSoftWareParam)
1024 {
1025 HI_S32 s32Ret = HI_SUCCESS;
1026 SAMPLE_SVP_CHECK_EXPR_RET(pstSoftWareParam == NULL, HI_INVALID_VALUE, SAMPLE_SVP_ERR_LEVEL_ERROR,
1027 "Error, pstSoftWareParam can't be NULL!\n");
1028 if ((pstSoftWareParam->stRpnTmpBuf.u64PhyAddr != 0) && (pstSoftWareParam->stRpnTmpBuf.u64VirAddr != 0)) {
1029 SAMPLE_SVP_MMZ_FREE(pstSoftWareParam->stRpnTmpBuf.u64PhyAddr, pstSoftWareParam->stRpnTmpBuf.u64VirAddr);
1030 pstSoftWareParam->stRpnTmpBuf.u64PhyAddr = 0;
1031 pstSoftWareParam->stRpnTmpBuf.u64VirAddr = 0;
1032 }
1033 return s32Ret;
1034 }
1035
SAMPLE_IVE_RfcnDeinit(SAMPLE_SVP_NNIE_PARAM_S * pstNnieParam,SAMPLE_SVP_NNIE_RFCN_SOFTWARE_PARAM_S * pstSoftWareParam,SAMPLE_SVP_NNIE_MODEL_S * pstNnieModel)1036 static HI_S32 SAMPLE_IVE_RfcnDeinit(SAMPLE_SVP_NNIE_PARAM_S *pstNnieParam,
1037 SAMPLE_SVP_NNIE_RFCN_SOFTWARE_PARAM_S *pstSoftWareParam, SAMPLE_SVP_NNIE_MODEL_S *pstNnieModel)
1038 {
1039 HI_S32 s32Ret = HI_SUCCESS;
1040 /* hardware deinit */
1041 if (pstNnieParam != NULL) {
1042 s32Ret = SAMPLE_COMM_SVP_NNIE_ParamDeinit(pstNnieParam);
1043 SAMPLE_SVP_CHECK_EXPR_TRACE(s32Ret != HI_SUCCESS, SAMPLE_SVP_ERR_LEVEL_ERROR,
1044 "Error,SAMPLE_COMM_SVP_NNIE_ParamDeinit failed!\n");
1045 }
1046 /* software deinit */
1047 if (pstSoftWareParam != NULL) {
1048 s32Ret = SAMPLE_IVE_Rfcn_SoftwareDeinit(pstSoftWareParam);
1049 SAMPLE_SVP_CHECK_EXPR_TRACE(s32Ret != HI_SUCCESS, SAMPLE_SVP_ERR_LEVEL_ERROR,
1050 "Error,SAMPLE_SVP_NNIE_Rfcn_SoftwareDeinit failed!\n");
1051 }
1052 /* model deinit */
1053 if (pstNnieModel != NULL) {
1054 s32Ret = SAMPLE_COMM_SVP_NNIE_UnloadModel(pstNnieModel);
1055 SAMPLE_SVP_CHECK_EXPR_TRACE(s32Ret != HI_SUCCESS, SAMPLE_SVP_ERR_LEVEL_ERROR,
1056 "Error,SAMPLE_COMM_SVP_NNIE_UnloadModel failed!\n");
1057 }
1058 return s32Ret;
1059 }
1060
1061 /* function : Rfcn software para init */
SAMPLE_IVE_Rfcn_SoftwareInit(SAMPLE_SVP_NNIE_CFG_S * pstCfg,SAMPLE_SVP_NNIE_PARAM_S * pstNnieParam,SAMPLE_SVP_NNIE_RFCN_SOFTWARE_PARAM_S * pstSoftWareParam)1062 static HI_S32 SAMPLE_IVE_Rfcn_SoftwareInit(SAMPLE_SVP_NNIE_CFG_S *pstCfg, SAMPLE_SVP_NNIE_PARAM_S *pstNnieParam,
1063 SAMPLE_SVP_NNIE_RFCN_SOFTWARE_PARAM_S *pstSoftWareParam)
1064 {
1065 HI_U32 i = 0, j = 0;
1066 HI_U32 u32RpnTmpBufSize = 0;
1067 HI_U32 u32RpnBboxBufSize = 0;
1068 HI_U32 u32GetResultTmpBufSize = 0;
1069 HI_U32 u32DstRoiSize = 0;
1070 HI_U32 u32DstScoreSize = 0;
1071 HI_U32 u32ClassRoiNumSize = 0;
1072 HI_U32 u32ClassNum = 0;
1073 HI_U32 u32TotalSize = 0;
1074 HI_S32 s32Ret = HI_SUCCESS;
1075 HI_U64 u64PhyAddr = 0;
1076 HI_U8 *pu8VirAddr = NULL;
1077
1078 /* init Rpn para */
1079 pstSoftWareParam->u32MaxRoiNum = pstCfg->u32MaxRoiNum;
1080 pstSoftWareParam->u32ClassNum = SAMPLE_IVE_KCF_CLASS_NUM;
1081 pstSoftWareParam->u32NumRatioAnchors = SAMPLE_IVE_KCF_RATIO_ANCHOR_NUM;
1082 pstSoftWareParam->u32NumScaleAnchors = SAMPLE_IVE_KCF_RATIO_ANCHOR_NUM;
1083 pstSoftWareParam->au32Scales[SAMPLE_IVE_KCF_IDX_0] = SAMPLE_IVE_KCF_SCALE_0;
1084 pstSoftWareParam->au32Scales[SAMPLE_IVE_KCF_IDX_1] = SAMPLE_IVE_KCF_SCALE_1;
1085 pstSoftWareParam->au32Scales[SAMPLE_IVE_KCF_IDX_2] = SAMPLE_IVE_KCF_SCALE_2;
1086 pstSoftWareParam->au32Ratios[SAMPLE_IVE_KCF_IDX_0] = SAMPLE_IVE_KCF_RATIO_0;
1087 pstSoftWareParam->au32Ratios[SAMPLE_IVE_KCF_IDX_1] = SAMPLE_IVE_KCF_RATIO_1;
1088 pstSoftWareParam->au32Ratios[SAMPLE_IVE_KCF_IDX_2] = SAMPLE_IVE_KCF_RATIO_2;
1089 pstSoftWareParam->u32OriImHeight = pstNnieParam->astSegData[0].astSrc[0].unShape.stWhc.u32Height;
1090 pstSoftWareParam->u32OriImWidth = pstNnieParam->astSegData[0].astSrc[0].unShape.stWhc.u32Width;
1091 pstSoftWareParam->u32MinSize = SAMPLE_IVE_KCF_MIN_SIZE;
1092 pstSoftWareParam->u32FilterThresh = SAMPLE_IVE_KCF_FILTER_THR;
1093 pstSoftWareParam->u32SpatialScale = (HI_U32)SAMPLE_IVE_KCF_SPATIAL_SCALE;
1094 pstSoftWareParam->u32NmsThresh = (HI_U32)SAMPLE_IVE_KCF_NMS_THR;
1095 pstSoftWareParam->u32NumBeforeNms = SAMPLE_IVE_KCF_NUM_BEFORE_NMS;
1096 for (i = 0; i < pstSoftWareParam->u32ClassNum; i++) {
1097 pstSoftWareParam->au32ConfThresh[i] = 1;
1098 pstSoftWareParam->af32ScoreThr[i] = SAMPLE_IVE_KCF_SCORE_THR;
1099 }
1100 pstSoftWareParam->u32ValidNmsThresh = (HI_U32)SAMPLE_IVE_KCF_VALID_NMS_THR;
1101
1102 /* set rpn input data info, the input info is set according to RPN data layers' name */
1103 for (i = 0; i < SAMPLE_IVE_KCF_CONV_OUT_NUM; i++) {
1104 for (j = 0; j < pstNnieParam->pstModel->astSeg[0].u16DstNum; j++) {
1105 if (strncmp(pstNnieParam->pstModel->astSeg[0].astDstNode[j].szName,
1106 pstSoftWareParam->apcRpnDataLayerName[i], SVP_NNIE_NODE_NAME_LEN) == 0) {
1107 pstSoftWareParam->aps32Conv[i] =
1108 SAMPLE_SVP_NNIE_CONVERT_64BIT_ADDR(HI_S32, pstNnieParam->astSegData[0].astDst[j].u64VirAddr);
1109 pstSoftWareParam->au32ConvHeight[i] =
1110 pstNnieParam->pstModel->astSeg[0].astDstNode[j].unShape.stWhc.u32Height;
1111 pstSoftWareParam->au32ConvWidth[i] =
1112 pstNnieParam->pstModel->astSeg[0].astDstNode[j].unShape.stWhc.u32Width;
1113 pstSoftWareParam->au32ConvChannel[i] =
1114 pstNnieParam->pstModel->astSeg[0].astDstNode[j].unShape.stWhc.u32Chn;
1115 break;
1116 }
1117 }
1118 SAMPLE_SVP_CHECK_EXPR_RET((j == pstNnieParam->pstModel->astSeg[0].u16DstNum), HI_FAILURE,
1119 SAMPLE_SVP_ERR_LEVEL_ERROR, "Error,failed to find report node %s!\n",
1120 pstSoftWareParam->apcRpnDataLayerName[i]);
1121 if (i == 0) {
1122 pstSoftWareParam->u32ConvStride = pstNnieParam->astSegData[0].astDst[j].u32Stride;
1123 }
1124 }
1125
1126 pstSoftWareParam->stRpnBbox.enType = SVP_BLOB_TYPE_S32;
1127 pstSoftWareParam->stRpnBbox.unShape.stWhc.u32Chn = 1;
1128 pstSoftWareParam->stRpnBbox.unShape.stWhc.u32Height = pstCfg->u32MaxRoiNum;
1129 pstSoftWareParam->stRpnBbox.unShape.stWhc.u32Width = SAMPLE_SVP_COORDI_NUM;
1130 pstSoftWareParam->stRpnBbox.u32Stride = SAMPLE_SVP_NNIE_ALIGN16(SAMPLE_SVP_COORDI_NUM * sizeof(HI_U32));
1131 pstSoftWareParam->stRpnBbox.u32Num = 1;
1132
1133 /* malloc software mem */
1134 u32RpnTmpBufSize = SAMPLE_IVE_RpnTmpBufSize(pstSoftWareParam->u32NumRatioAnchors,
1135 pstSoftWareParam->u32NumScaleAnchors, pstSoftWareParam->au32ConvHeight[0], pstSoftWareParam->au32ConvWidth[0]);
1136 u32RpnTmpBufSize = SAMPLE_SVP_NNIE_ALIGN16(u32RpnTmpBufSize);
1137 u32RpnBboxBufSize = pstSoftWareParam->stRpnBbox.u32Num * pstSoftWareParam->stRpnBbox.unShape.stWhc.u32Height *
1138 pstSoftWareParam->stRpnBbox.u32Stride;
1139 u32GetResultTmpBufSize = SAMPLE_IVE_Rfcn_GetResultTmpBuf(pstCfg->u32MaxRoiNum, pstSoftWareParam->u32ClassNum);
1140 u32GetResultTmpBufSize = SAMPLE_SVP_NNIE_ALIGN16(u32GetResultTmpBufSize);
1141 u32ClassNum = pstSoftWareParam->u32ClassNum;
1142 u32DstRoiSize =
1143 SAMPLE_SVP_NNIE_ALIGN16(u32ClassNum * pstCfg->u32MaxRoiNum * sizeof(HI_U32) * SAMPLE_IVE_COORDI_NUM);
1144 u32DstScoreSize = SAMPLE_SVP_NNIE_ALIGN16(u32ClassNum * pstCfg->u32MaxRoiNum * sizeof(HI_U32));
1145 u32ClassRoiNumSize = SAMPLE_SVP_NNIE_ALIGN16(u32ClassNum * sizeof(HI_U32));
1146 u32TotalSize = u32RpnTmpBufSize + u32RpnBboxBufSize + u32GetResultTmpBufSize + u32DstRoiSize + u32DstScoreSize +
1147 u32ClassRoiNumSize;
1148
1149 s32Ret = SAMPLE_COMM_SVP_MallocCached("SAMPLE_RFCN_INIT", NULL, (HI_U64 *)&u64PhyAddr, (void **)&pu8VirAddr,
1150 u32TotalSize);
1151 SAMPLE_SVP_CHECK_EXPR_RET(s32Ret != HI_SUCCESS, s32Ret, SAMPLE_SVP_ERR_LEVEL_ERROR,
1152 "Error,Malloc memory failed!\n");
1153 (HI_VOID)memset_s(pu8VirAddr, u32TotalSize, 0, u32TotalSize);
1154 SAMPLE_COMM_SVP_FlushCache(u64PhyAddr, (void *)pu8VirAddr, u32TotalSize);
1155
1156 pstSoftWareParam->stRpnTmpBuf.u64PhyAddr = u64PhyAddr;
1157 pstSoftWareParam->stRpnTmpBuf.u64VirAddr = (HI_U64)((HI_UINTPTR_T)pu8VirAddr);
1158 pstSoftWareParam->stRpnTmpBuf.u32Size = u32RpnTmpBufSize;
1159
1160 pstSoftWareParam->stRpnBbox.u64PhyAddr = u64PhyAddr + u32RpnTmpBufSize;
1161 pstSoftWareParam->stRpnBbox.u64VirAddr = (HI_U64)((HI_UINTPTR_T)pu8VirAddr) + u32RpnTmpBufSize;
1162
1163 pstSoftWareParam->stGetResultTmpBuf.u64PhyAddr = u64PhyAddr + u32RpnTmpBufSize + u32RpnBboxBufSize;
1164 pstSoftWareParam->stGetResultTmpBuf.u64VirAddr =
1165 (HI_U64)((HI_UINTPTR_T)pu8VirAddr + u32RpnTmpBufSize + u32RpnBboxBufSize);
1166 pstSoftWareParam->stGetResultTmpBuf.u32Size = u32GetResultTmpBufSize;
1167
1168 pstSoftWareParam->stDstRoi.enType = SVP_BLOB_TYPE_S32;
1169 pstSoftWareParam->stDstRoi.u64PhyAddr = u64PhyAddr + u32RpnTmpBufSize + u32RpnBboxBufSize + u32GetResultTmpBufSize;
1170 pstSoftWareParam->stDstRoi.u64VirAddr =
1171 (HI_U64)((HI_UINTPTR_T)pu8VirAddr + u32RpnTmpBufSize + u32RpnBboxBufSize + u32GetResultTmpBufSize);
1172 pstSoftWareParam->stDstRoi.u32Stride =
1173 SAMPLE_SVP_NNIE_ALIGN16(u32ClassNum * pstSoftWareParam->u32MaxRoiNum * sizeof(HI_U32) * SAMPLE_IVE_COORDI_NUM);
1174 pstSoftWareParam->stDstRoi.u32Num = 1;
1175 pstSoftWareParam->stDstRoi.unShape.stWhc.u32Chn = 1;
1176 pstSoftWareParam->stDstRoi.unShape.stWhc.u32Height = 1;
1177 pstSoftWareParam->stDstRoi.unShape.stWhc.u32Width =
1178 u32ClassNum * pstSoftWareParam->u32MaxRoiNum * SAMPLE_IVE_COORDI_NUM;
1179
1180 pstSoftWareParam->stDstScore.enType = SVP_BLOB_TYPE_S32;
1181 pstSoftWareParam->stDstScore.u64PhyAddr =
1182 u64PhyAddr + u32RpnTmpBufSize + u32RpnBboxBufSize + u32GetResultTmpBufSize + u32DstRoiSize;
1183 pstSoftWareParam->stDstScore.u64VirAddr = (HI_U64)((HI_UINTPTR_T)pu8VirAddr + u32RpnTmpBufSize + u32RpnBboxBufSize +
1184 u32GetResultTmpBufSize + u32DstRoiSize);
1185 pstSoftWareParam->stDstScore.u32Stride =
1186 SAMPLE_SVP_NNIE_ALIGN16(u32ClassNum * pstSoftWareParam->u32MaxRoiNum * sizeof(HI_U32));
1187 pstSoftWareParam->stDstScore.u32Num = 1;
1188 pstSoftWareParam->stDstScore.unShape.stWhc.u32Chn = 1;
1189 pstSoftWareParam->stDstScore.unShape.stWhc.u32Height = 1;
1190 pstSoftWareParam->stDstScore.unShape.stWhc.u32Width = u32ClassNum * pstSoftWareParam->u32MaxRoiNum;
1191
1192 pstSoftWareParam->stClassRoiNum.enType = SVP_BLOB_TYPE_S32;
1193 pstSoftWareParam->stClassRoiNum.u64PhyAddr =
1194 u64PhyAddr + u32RpnTmpBufSize + u32RpnBboxBufSize + u32GetResultTmpBufSize + u32DstRoiSize + u32DstScoreSize;
1195 pstSoftWareParam->stClassRoiNum.u64VirAddr = (HI_U64)((HI_UINTPTR_T)pu8VirAddr + u32RpnTmpBufSize +
1196 u32RpnBboxBufSize + u32GetResultTmpBufSize + u32DstRoiSize + u32DstScoreSize);
1197 pstSoftWareParam->stClassRoiNum.u32Stride = SAMPLE_SVP_NNIE_ALIGN16(u32ClassNum * sizeof(HI_U32));
1198 pstSoftWareParam->stClassRoiNum.u32Num = 1;
1199 pstSoftWareParam->stClassRoiNum.unShape.stWhc.u32Chn = 1;
1200 pstSoftWareParam->stClassRoiNum.unShape.stWhc.u32Height = 1;
1201 pstSoftWareParam->stClassRoiNum.unShape.stWhc.u32Width = u32ClassNum;
1202 return s32Ret;
1203 }
1204
SAMPLE_IVE_Rfcn_ParamInit(SAMPLE_SVP_NNIE_CFG_S * pstCfg,SAMPLE_SVP_NNIE_PARAM_S * pstNnieParam,SAMPLE_SVP_NNIE_RFCN_SOFTWARE_PARAM_S * pstSoftWareParam)1205 static HI_S32 SAMPLE_IVE_Rfcn_ParamInit(SAMPLE_SVP_NNIE_CFG_S *pstCfg, SAMPLE_SVP_NNIE_PARAM_S *pstNnieParam,
1206 SAMPLE_SVP_NNIE_RFCN_SOFTWARE_PARAM_S *pstSoftWareParam)
1207 {
1208 HI_S32 s32Ret = HI_SUCCESS;
1209 /* init hardware para */
1210 s32Ret = SAMPLE_COMM_SVP_NNIE_ParamInit(pstCfg, pstNnieParam);
1211 SAMPLE_SVP_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, INIT_FAIL_0, SAMPLE_SVP_ERR_LEVEL_ERROR,
1212 "Error(%#x),SAMPLE_COMM_SVP_NNIE_ParamInit failed!\n", s32Ret);
1213
1214 /* init software para */
1215 s32Ret = SAMPLE_IVE_Rfcn_SoftwareInit(pstCfg, pstNnieParam, pstSoftWareParam);
1216 SAMPLE_SVP_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, INIT_FAIL_0, SAMPLE_SVP_ERR_LEVEL_ERROR,
1217 "Error(%#x),SAMPLE_SVP_NNIE_Rfcn_SoftwareInit failed!\n", s32Ret);
1218
1219 return s32Ret;
1220 INIT_FAIL_0:
1221 s32Ret = SAMPLE_IVE_RfcnDeinit(pstNnieParam, pstSoftWareParam, NULL);
1222 SAMPLE_SVP_CHECK_EXPR_RET(s32Ret != HI_SUCCESS, s32Ret, SAMPLE_SVP_ERR_LEVEL_ERROR,
1223 "Error(%#x),SAMPLE_SVP_NNIE_Rfcn_Deinit failed!\n", s32Ret);
1224 return HI_FAILURE;
1225 }
1226
SAMPLE_IVE_RoiToRect(SVP_BLOB_S * pstDstScore,SVP_BLOB_S * pstDstRoi,SVP_BLOB_S * pstClassRoiNum,HI_FLOAT * paf32ScoreThr,HI_BOOL bRmBg,SAMPLE_SVP_NNIE_RECT_ARRAY_S * pstRect,HI_U32 u32SrcWidth,HI_U32 u32SrcHeight,HI_U32 u32DstWidth,HI_U32 u32DstHeight)1227 static HI_S32 SAMPLE_IVE_RoiToRect(SVP_BLOB_S *pstDstScore, SVP_BLOB_S *pstDstRoi, SVP_BLOB_S *pstClassRoiNum,
1228 HI_FLOAT *paf32ScoreThr, HI_BOOL bRmBg, SAMPLE_SVP_NNIE_RECT_ARRAY_S *pstRect, HI_U32 u32SrcWidth,
1229 HI_U32 u32SrcHeight, HI_U32 u32DstWidth, HI_U32 u32DstHeight)
1230 {
1231 HI_U32 i = 0, j = 0;
1232 HI_U32 u32RoiNumBias = 0;
1233 HI_U32 u32ScoreBias = 0;
1234 HI_U32 u32BboxBias = 0;
1235 HI_FLOAT f32Score = 0.0f;
1236 HI_S32 *ps32Score = SAMPLE_SVP_NNIE_CONVERT_64BIT_ADDR(HI_S32, pstDstScore->u64VirAddr);
1237 HI_S32 *ps32Roi = SAMPLE_SVP_NNIE_CONVERT_64BIT_ADDR(HI_S32, pstDstRoi->u64VirAddr);
1238 HI_S32 *ps32ClassRoiNum = SAMPLE_SVP_NNIE_CONVERT_64BIT_ADDR(HI_S32, pstClassRoiNum->u64VirAddr);
1239 HI_U32 u32ClassNum = pstClassRoiNum->unShape.stWhc.u32Width;
1240 HI_U32 u32RoiNumTmp = 0;
1241
1242 SAMPLE_SVP_CHECK_EXPR_RET(u32ClassNum > SAMPLE_SVP_NNIE_MAX_CLASS_NUM, HI_ERR_SVP_NNIE_ILLEGAL_PARAM,
1243 SAMPLE_SVP_ERR_LEVEL_ERROR, "Error(%#x),u32ClassNum(%u) must be less than or equal %u to!\n",
1244 HI_ERR_SVP_NNIE_ILLEGAL_PARAM, u32ClassNum, SAMPLE_SVP_NNIE_MAX_CLASS_NUM);
1245 pstRect->u32TotalNum = 0;
1246 pstRect->u32ClsNum = u32ClassNum;
1247 if (bRmBg) {
1248 pstRect->au32RoiNum[0] = 0;
1249 u32RoiNumBias += ps32ClassRoiNum[0];
1250 for (i = 1; i < u32ClassNum; i++) {
1251 u32ScoreBias = u32RoiNumBias;
1252 u32BboxBias = u32RoiNumBias * SAMPLE_IVE_COORDI_NUM;
1253 u32RoiNumTmp = 0;
1254 /* if the confidence score greater than result thresh, the result will be drawed */
1255 if (((HI_FLOAT)ps32Score[u32ScoreBias] / SAMPLE_IVE_QUANT_BASE >= paf32ScoreThr[i]) &&
1256 (ps32ClassRoiNum[i] != 0)) {
1257 for (j = 0; j < (HI_U32)ps32ClassRoiNum[i]; j++) {
1258 /* Score is descend order */
1259 f32Score = (HI_FLOAT)ps32Score[u32ScoreBias + j] / SAMPLE_IVE_QUANT_BASE;
1260 if ((f32Score < paf32ScoreThr[i]) || (u32RoiNumTmp >= SAMPLE_SVP_NNIE_MAX_ROI_NUM_OF_CLASS)) {
1261 break;
1262 }
1263
1264 pstRect->astRect[i][u32RoiNumTmp].astPoint[SAMPLE_IVE_KCF_IDX_0].s32X =
1265 (HI_U32)((HI_FLOAT)ps32Roi[u32BboxBias + j * SAMPLE_IVE_COORDI_NUM] / (HI_FLOAT)u32SrcWidth *
1266 (HI_FLOAT)u32DstWidth) &
1267 (~1);
1268 pstRect->astRect[i][u32RoiNumTmp].astPoint[SAMPLE_IVE_KCF_IDX_0].s32Y =
1269 (HI_U32)((HI_FLOAT)ps32Roi[u32BboxBias + j * SAMPLE_IVE_COORDI_NUM + SAMPLE_IVE_Y_MIN_OFFSET] /
1270 (HI_FLOAT)u32SrcHeight * (HI_FLOAT)u32DstHeight) &
1271 (~1);
1272
1273 pstRect->astRect[i][u32RoiNumTmp].astPoint[SAMPLE_IVE_KCF_IDX_1].s32X =
1274 (HI_U32)((HI_FLOAT)ps32Roi[u32BboxBias + j * SAMPLE_IVE_COORDI_NUM + SAMPLE_IVE_X_MAX_OFFSET] /
1275 (HI_FLOAT)u32SrcWidth * (HI_FLOAT)u32DstWidth) &
1276 (~1);
1277 pstRect->astRect[i][u32RoiNumTmp].astPoint[SAMPLE_IVE_KCF_IDX_1].s32Y =
1278 pstRect->astRect[i][u32RoiNumTmp].astPoint[SAMPLE_IVE_KCF_IDX_0].s32Y;
1279
1280 pstRect->astRect[i][u32RoiNumTmp].astPoint[SAMPLE_IVE_KCF_IDX_2].s32X =
1281 pstRect->astRect[i][u32RoiNumTmp].astPoint[SAMPLE_IVE_KCF_IDX_1].s32X;
1282 pstRect->astRect[i][u32RoiNumTmp].astPoint[SAMPLE_IVE_KCF_IDX_2].s32Y =
1283 (HI_U32)((HI_FLOAT)ps32Roi[u32BboxBias + j * SAMPLE_IVE_COORDI_NUM + SAMPLE_IVE_Y_MAX_OFFSET] /
1284 (HI_FLOAT)u32SrcHeight * (HI_FLOAT)u32DstHeight) &
1285 (~1);
1286
1287 pstRect->astRect[i][u32RoiNumTmp].astPoint[SAMPLE_IVE_KCF_IDX_3].s32X =
1288 pstRect->astRect[i][u32RoiNumTmp].astPoint[SAMPLE_IVE_KCF_IDX_0].s32X;
1289 pstRect->astRect[i][u32RoiNumTmp].astPoint[SAMPLE_IVE_KCF_IDX_3].s32Y =
1290 pstRect->astRect[i][u32RoiNumTmp].astPoint[SAMPLE_IVE_KCF_IDX_2].s32Y;
1291
1292 u32RoiNumTmp++;
1293 }
1294 }
1295
1296 pstRect->au32RoiNum[i] = u32RoiNumTmp;
1297 pstRect->u32TotalNum += u32RoiNumTmp;
1298 u32RoiNumBias += ps32ClassRoiNum[i];
1299 }
1300 }
1301 return HI_SUCCESS;
1302 }
1303
SAMPLE_IVE_Forward(SAMPLE_SVP_NNIE_PARAM_S * pstNnieParam,SAMPLE_SVP_NNIE_INPUT_DATA_INDEX_S * pstInputDataIdx,SAMPLE_SVP_NNIE_PROCESS_SEG_INDEX_S * pstProcSegIdx,HI_BOOL bInstant)1304 static HI_S32 SAMPLE_IVE_Forward(SAMPLE_SVP_NNIE_PARAM_S *pstNnieParam,
1305 SAMPLE_SVP_NNIE_INPUT_DATA_INDEX_S *pstInputDataIdx, SAMPLE_SVP_NNIE_PROCESS_SEG_INDEX_S *pstProcSegIdx,
1306 HI_BOOL bInstant)
1307 {
1308 HI_S32 s32Ret = HI_SUCCESS;
1309 HI_U32 i = 0, j = 0;
1310 HI_BOOL bFinish = HI_FALSE;
1311 SVP_NNIE_HANDLE hSvpNnieHandle = 0;
1312 HI_U32 u32TotalStepNum = 0;
1313
1314 SAMPLE_COMM_SVP_FlushCache(pstNnieParam->astForwardCtrl[pstProcSegIdx->u32SegIdx].stTskBuf.u64PhyAddr,
1315 SAMPLE_SVP_NNIE_CONVERT_64BIT_ADDR(HI_VOID,
1316 pstNnieParam->astForwardCtrl[pstProcSegIdx->u32SegIdx].stTskBuf.u64VirAddr),
1317 pstNnieParam->astForwardCtrl[pstProcSegIdx->u32SegIdx].stTskBuf.u32Size);
1318
1319 for (i = 0; i < pstNnieParam->astForwardCtrl[pstProcSegIdx->u32SegIdx].u32DstNum; i++) {
1320 if (SVP_BLOB_TYPE_SEQ_S32 == pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].enType) {
1321 for (j = 0; j < pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].u32Num; j++) {
1322 u32TotalStepNum += *(SAMPLE_SVP_NNIE_CONVERT_64BIT_ADDR(HI_U32,
1323 pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].unShape.stSeq.u64VirAddrStep) +
1324 j);
1325 }
1326 SAMPLE_COMM_SVP_FlushCache(pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].u64PhyAddr,
1327 SAMPLE_SVP_NNIE_CONVERT_64BIT_ADDR(HI_VOID,
1328 pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].u64VirAddr),
1329 u32TotalStepNum * pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].u32Stride);
1330 } else {
1331 SAMPLE_COMM_SVP_FlushCache(pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].u64PhyAddr,
1332 SAMPLE_SVP_NNIE_CONVERT_64BIT_ADDR(HI_VOID,
1333 pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].u64VirAddr),
1334 pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].u32Num *
1335 pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].unShape.stWhc.u32Chn *
1336 pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].unShape.stWhc.u32Height *
1337 pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].u32Stride);
1338 }
1339 }
1340
1341 /* set input blob according to node name */
1342 if (pstInputDataIdx->u32SegIdx != pstProcSegIdx->u32SegIdx) {
1343 for (i = 0; i < pstNnieParam->pstModel->astSeg[pstProcSegIdx->u32SegIdx].u16SrcNum; i++) {
1344 for (j = 0; j < pstNnieParam->pstModel->astSeg[pstInputDataIdx->u32SegIdx].u16DstNum; j++) {
1345 if (strncmp(pstNnieParam->pstModel->astSeg[pstInputDataIdx->u32SegIdx].astDstNode[j].szName,
1346 pstNnieParam->pstModel->astSeg[pstProcSegIdx->u32SegIdx].astSrcNode[i].szName,
1347 SVP_NNIE_NODE_NAME_LEN) == 0) {
1348 pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astSrc[i] =
1349 pstNnieParam->astSegData[pstInputDataIdx->u32SegIdx].astDst[j];
1350 break;
1351 }
1352 }
1353 SAMPLE_SVP_CHECK_EXPR_RET((j == pstNnieParam->pstModel->astSeg[pstInputDataIdx->u32SegIdx].u16DstNum),
1354 HI_FAILURE, SAMPLE_SVP_ERR_LEVEL_ERROR, "Error,can't find %d-th seg's %d-th src blob!\n",
1355 pstProcSegIdx->u32SegIdx, i);
1356 }
1357 }
1358
1359 /* NNIE_Forward */
1360 s32Ret = HI_MPI_SVP_NNIE_Forward(&hSvpNnieHandle, pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astSrc,
1361 pstNnieParam->pstModel, pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst,
1362 &pstNnieParam->astForwardCtrl[pstProcSegIdx->u32SegIdx], bInstant);
1363 SAMPLE_SVP_CHECK_EXPR_RET(s32Ret != HI_SUCCESS, s32Ret, SAMPLE_SVP_ERR_LEVEL_ERROR,
1364 "Error,HI_MPI_SVP_NNIE_Forward failed!\n");
1365
1366 if (bInstant) {
1367 /* Wait NNIE finish */
1368 while (HI_ERR_SVP_NNIE_QUERY_TIMEOUT == (s32Ret = HI_MPI_SVP_NNIE_Query(
1369 pstNnieParam->astForwardCtrl[pstProcSegIdx->u32SegIdx].enNnieId, hSvpNnieHandle, &bFinish, HI_TRUE))) {
1370 usleep(IVE_QUERY_SLEEP_TIME);
1371 SAMPLE_SVP_TRACE(SAMPLE_SVP_ERR_LEVEL_INFO, "HI_MPI_SVP_NNIE_Query Query timeout!\n");
1372 }
1373 }
1374 u32TotalStepNum = 0;
1375
1376 for (i = 0; i < pstNnieParam->astForwardCtrl[pstProcSegIdx->u32SegIdx].u32DstNum; i++) {
1377 if (SVP_BLOB_TYPE_SEQ_S32 == pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].enType) {
1378 for (j = 0; j < pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].u32Num; j++) {
1379 u32TotalStepNum += *(SAMPLE_SVP_NNIE_CONVERT_64BIT_ADDR(HI_U32,
1380 pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].unShape.stSeq.u64VirAddrStep) +
1381 j);
1382 }
1383 SAMPLE_COMM_SVP_FlushCache(pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].u64PhyAddr,
1384 SAMPLE_SVP_NNIE_CONVERT_64BIT_ADDR(HI_VOID,
1385 pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].u64VirAddr),
1386 u32TotalStepNum * pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].u32Stride);
1387 } else {
1388 SAMPLE_COMM_SVP_FlushCache(pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].u64PhyAddr,
1389 SAMPLE_SVP_NNIE_CONVERT_64BIT_ADDR(HI_VOID,
1390 pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].u64VirAddr),
1391 pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].u32Num *
1392 pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].unShape.stWhc.u32Chn *
1393 pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].unShape.stWhc.u32Height *
1394 pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].u32Stride);
1395 }
1396 }
1397
1398 return s32Ret;
1399 }
1400
SAMPLE_IVE_ForwardWithBbox(SAMPLE_SVP_NNIE_PARAM_S * pstNnieParam,SAMPLE_SVP_NNIE_INPUT_DATA_INDEX_S * pstInputDataIdx,SVP_SRC_BLOB_S astBbox[],SAMPLE_SVP_NNIE_PROCESS_SEG_INDEX_S * pstProcSegIdx,HI_BOOL bInstant)1401 static HI_S32 SAMPLE_IVE_ForwardWithBbox(SAMPLE_SVP_NNIE_PARAM_S *pstNnieParam,
1402 SAMPLE_SVP_NNIE_INPUT_DATA_INDEX_S *pstInputDataIdx, SVP_SRC_BLOB_S astBbox[],
1403 SAMPLE_SVP_NNIE_PROCESS_SEG_INDEX_S *pstProcSegIdx, HI_BOOL bInstant)
1404 {
1405 HI_S32 s32Ret = HI_SUCCESS;
1406 HI_BOOL bFinish = HI_FALSE;
1407 SVP_NNIE_HANDLE hSvpNnieHandle = 0;
1408 HI_U32 u32TotalStepNum = 0;
1409 HI_U32 i, j;
1410
1411 SAMPLE_COMM_SVP_FlushCache(pstNnieParam->astForwardWithBboxCtrl[pstProcSegIdx->u32SegIdx].stTskBuf.u64PhyAddr,
1412 SAMPLE_SVP_NNIE_CONVERT_64BIT_ADDR(HI_VOID,
1413 pstNnieParam->astForwardWithBboxCtrl[pstProcSegIdx->u32SegIdx].stTskBuf.u64VirAddr),
1414 pstNnieParam->astForwardWithBboxCtrl[pstProcSegIdx->u32SegIdx].stTskBuf.u32Size);
1415
1416 for (i = 0; i < pstNnieParam->astForwardWithBboxCtrl[pstProcSegIdx->u32SegIdx].u32DstNum; i++) {
1417 if (SVP_BLOB_TYPE_SEQ_S32 == pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].enType) {
1418 for (j = 0; j < pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].u32Num; j++) {
1419 u32TotalStepNum += *(SAMPLE_SVP_NNIE_CONVERT_64BIT_ADDR(HI_U32,
1420 pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].unShape.stSeq.u64VirAddrStep) +
1421 j);
1422 }
1423 SAMPLE_COMM_SVP_FlushCache(pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].u64PhyAddr,
1424 SAMPLE_SVP_NNIE_CONVERT_64BIT_ADDR(HI_VOID,
1425 pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].u64VirAddr),
1426 u32TotalStepNum * pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].u32Stride);
1427 } else {
1428 SAMPLE_COMM_SVP_FlushCache(pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].u64PhyAddr,
1429 SAMPLE_SVP_NNIE_CONVERT_64BIT_ADDR(HI_VOID,
1430 pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].u64VirAddr),
1431 pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].u32Num *
1432 pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].unShape.stWhc.u32Chn *
1433 pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].unShape.stWhc.u32Height *
1434 pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].u32Stride);
1435 }
1436 }
1437
1438 /* set input blob according to node name */
1439 if (pstInputDataIdx->u32SegIdx != pstProcSegIdx->u32SegIdx) {
1440 for (i = 0; i < pstNnieParam->pstModel->astSeg[pstProcSegIdx->u32SegIdx].u16SrcNum; i++) {
1441 for (j = 0; j < pstNnieParam->pstModel->astSeg[pstInputDataIdx->u32SegIdx].u16DstNum; j++) {
1442 if (strncmp(pstNnieParam->pstModel->astSeg[pstInputDataIdx->u32SegIdx].astDstNode[j].szName,
1443 pstNnieParam->pstModel->astSeg[pstProcSegIdx->u32SegIdx].astSrcNode[i].szName,
1444 SVP_NNIE_NODE_NAME_LEN) == 0) {
1445 pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astSrc[i] =
1446 pstNnieParam->astSegData[pstInputDataIdx->u32SegIdx].astDst[j];
1447 break;
1448 }
1449 }
1450 SAMPLE_SVP_CHECK_EXPR_RET((j == pstNnieParam->pstModel->astSeg[pstInputDataIdx->u32SegIdx].u16DstNum),
1451 HI_FAILURE, SAMPLE_SVP_ERR_LEVEL_ERROR, "Error,can't find %d-th seg's %d-th src blob!\n",
1452 pstProcSegIdx->u32SegIdx, i);
1453 }
1454 }
1455 /* NNIE_ForwardWithBbox */
1456 s32Ret = HI_MPI_SVP_NNIE_ForwardWithBbox(&hSvpNnieHandle, pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astSrc,
1457 astBbox, pstNnieParam->pstModel, pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst,
1458 &pstNnieParam->astForwardWithBboxCtrl[pstProcSegIdx->u32SegIdx], bInstant);
1459 SAMPLE_SVP_CHECK_EXPR_RET(s32Ret != HI_SUCCESS, s32Ret, SAMPLE_SVP_ERR_LEVEL_ERROR,
1460 "Error,HI_MPI_SVP_NNIE_ForwardWithBbox failed!\n");
1461
1462 if (bInstant) {
1463 /* Wait NNIE finish */
1464 while (HI_ERR_SVP_NNIE_QUERY_TIMEOUT ==
1465 (s32Ret = HI_MPI_SVP_NNIE_Query(pstNnieParam->astForwardWithBboxCtrl[pstProcSegIdx->u32SegIdx].enNnieId,
1466 hSvpNnieHandle, &bFinish, HI_TRUE))) {
1467 usleep(IVE_QUERY_SLEEP_TIME);
1468 SAMPLE_SVP_TRACE(SAMPLE_SVP_ERR_LEVEL_INFO, "HI_MPI_SVP_NNIE_Query Query timeout!\n");
1469 }
1470 }
1471
1472 u32TotalStepNum = 0;
1473
1474 for (i = 0; i < pstNnieParam->astForwardWithBboxCtrl[pstProcSegIdx->u32SegIdx].u32DstNum; i++) {
1475 if (SVP_BLOB_TYPE_SEQ_S32 == pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].enType) {
1476 for (j = 0; j < pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].u32Num; j++) {
1477 u32TotalStepNum += *(SAMPLE_SVP_NNIE_CONVERT_64BIT_ADDR(HI_U32,
1478 pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].unShape.stSeq.u64VirAddrStep) +
1479 j);
1480 }
1481 SAMPLE_COMM_SVP_FlushCache(pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].u64PhyAddr,
1482 SAMPLE_SVP_NNIE_CONVERT_64BIT_ADDR(HI_VOID,
1483 pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].u64VirAddr),
1484 u32TotalStepNum * pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].u32Stride);
1485 } else {
1486 SAMPLE_COMM_SVP_FlushCache(pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].u64PhyAddr,
1487 SAMPLE_SVP_NNIE_CONVERT_64BIT_ADDR(HI_VOID,
1488 pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].u64VirAddr),
1489 pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].u32Num *
1490 pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].unShape.stWhc.u32Chn *
1491 pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].unShape.stWhc.u32Height *
1492 pstNnieParam->astSegData[pstProcSegIdx->u32SegIdx].astDst[i].u32Stride);
1493 }
1494 }
1495
1496 return s32Ret;
1497 }
1498
SAMPLE_IVE_Rfcn_Proc(SAMPLE_SVP_NNIE_PARAM_S * pstParam,SAMPLE_SVP_NNIE_RFCN_SOFTWARE_PARAM_S * pstSwParam)1499 static HI_S32 SAMPLE_IVE_Rfcn_Proc(SAMPLE_SVP_NNIE_PARAM_S *pstParam, SAMPLE_SVP_NNIE_RFCN_SOFTWARE_PARAM_S *pstSwParam)
1500 {
1501 HI_S32 s32Ret = HI_FAILURE;
1502 SAMPLE_SVP_NNIE_INPUT_DATA_INDEX_S stInputDataIdx = { 0 };
1503 SAMPLE_SVP_NNIE_PROCESS_SEG_INDEX_S stProcSegIdx = { 0 };
1504
1505 stInputDataIdx.u32SegIdx = 0;
1506 stInputDataIdx.u32NodeIdx = 0;
1507
1508 /* NNIE process 0-th seg */
1509 stProcSegIdx.u32SegIdx = 0;
1510 s32Ret = SAMPLE_IVE_Forward(pstParam, &stInputDataIdx, &stProcSegIdx, HI_TRUE);
1511 SAMPLE_SVP_CHECK_EXPR_RET(s32Ret != HI_SUCCESS, s32Ret, SAMPLE_SVP_ERR_LEVEL_ERROR,
1512 "Error,SAMPLE_IVE_Forward failed!\n");
1513
1514 /* RPN */
1515 s32Ret = SAMPLE_IVE_Rfcn_Rpn(pstSwParam);
1516 SAMPLE_SVP_CHECK_EXPR_RET(s32Ret != HI_SUCCESS, s32Ret, SAMPLE_SVP_ERR_LEVEL_ERROR,
1517 "Error,SAMPLE_IVE_Rfcn_Rpn failed!\n");
1518
1519 /* NNIE process 1-th seg, the input data comes from 3-rd report node of 0-th seg,
1520 the input roi comes from RPN results */
1521 stInputDataIdx.u32SegIdx = 0;
1522 stInputDataIdx.u32NodeIdx = SAMPLE_IVE_KCF_IDX_3;
1523 stProcSegIdx.u32SegIdx = SAMPLE_IVE_KCF_IDX_1;
1524 s32Ret = SAMPLE_IVE_ForwardWithBbox(pstParam, &stInputDataIdx, &pstSwParam->stRpnBbox, &stProcSegIdx, HI_TRUE);
1525 SAMPLE_SVP_CHECK_EXPR_RET(s32Ret != HI_SUCCESS, s32Ret, SAMPLE_SVP_ERR_LEVEL_ERROR,
1526 "Error,SAMPLE_IVE_ForwardWithBbox failed!\n");
1527
1528 /* NNIE process 2-nd seg, the input data comes from 4-th report node of 0-th seg
1529 the input roi comes from RPN results */
1530 stInputDataIdx.u32SegIdx = 0;
1531 stInputDataIdx.u32NodeIdx = SAMPLE_IVE_KCF_IDX_4;
1532 stProcSegIdx.u32SegIdx = SAMPLE_IVE_KCF_IDX_2;
1533 s32Ret = SAMPLE_IVE_ForwardWithBbox(pstParam, &stInputDataIdx, &pstSwParam->stRpnBbox, &stProcSegIdx, HI_TRUE);
1534 SAMPLE_SVP_CHECK_EXPR_RET(s32Ret != HI_SUCCESS, s32Ret, SAMPLE_SVP_ERR_LEVEL_ERROR,
1535 "Error,SAMPLE_IVE_ForwardWithBbox failed!\n");
1536
1537 /* GetResult */
1538 /* if user has changed net struct, please make sure SAMPLE_IVE_Rfcn_GetResult
1539 function's input data are correct */
1540 s32Ret = SAMPLE_IVE_Rfcn_GetResult(pstParam, pstSwParam);
1541 SAMPLE_SVP_CHECK_EXPR_RET(s32Ret != HI_SUCCESS, s32Ret, SAMPLE_SVP_ERR_LEVEL_ERROR,
1542 "Error,SAMPLE_IVE_Rfcn_GetResult failed!\n");
1543
1544 return s32Ret;
1545 }
1546
SAMPLE_IVE_Rfcn_GetRect(SAMPLE_SVP_NNIE_PARAM_S * pstParam,SAMPLE_SVP_NNIE_RFCN_SOFTWARE_PARAM_S * pstSwParam,VIDEO_FRAME_INFO_S * pstExtFrmInfo,HI_U32 u32BaseWidth,HI_U32 u32BaseHeight)1547 static HI_S32 SAMPLE_IVE_Rfcn_GetRect(SAMPLE_SVP_NNIE_PARAM_S *pstParam,
1548 SAMPLE_SVP_NNIE_RFCN_SOFTWARE_PARAM_S *pstSwParam, VIDEO_FRAME_INFO_S *pstExtFrmInfo, HI_U32 u32BaseWidth,
1549 HI_U32 u32BaseHeight)
1550 {
1551 HI_S32 s32Ret = HI_FAILURE;
1552 SAMPLE_SVP_NNIE_INPUT_DATA_INDEX_S stInputDataIdx = { 0 };
1553
1554 stInputDataIdx.u32SegIdx = 0;
1555 stInputDataIdx.u32NodeIdx = 0;
1556 /* SP420 */
1557 pstParam->astSegData[stInputDataIdx.u32SegIdx].astSrc[stInputDataIdx.u32NodeIdx].u64VirAddr =
1558 pstExtFrmInfo->stVFrame.u64VirAddr[0];
1559 pstParam->astSegData[stInputDataIdx.u32SegIdx].astSrc[stInputDataIdx.u32NodeIdx].u64PhyAddr =
1560 pstExtFrmInfo->stVFrame.u64PhyAddr[0];
1561 pstParam->astSegData[stInputDataIdx.u32SegIdx].astSrc[stInputDataIdx.u32NodeIdx].u32Stride =
1562 pstExtFrmInfo->stVFrame.u32Stride[0];
1563
1564 s32Ret = SAMPLE_IVE_Rfcn_Proc(pstParam, pstSwParam);
1565 SAMPLE_SVP_CHECK_EXPR_RET(s32Ret != HI_SUCCESS, s32Ret, SAMPLE_SVP_ERR_LEVEL_ERROR,
1566 "Error,SAMPLE_SVP_NNIE_Rfcn_Proc failed!\n");
1567 /* draw result, this sample has 21 classes:
1568 class 0:background class 1:plane class 2:bicycle
1569 class 3:bird class 4:boat class 5:bottle
1570 class 6:bus class 7:car class 8:cat
1571 class 9:chair class10:cow class11:diningtable
1572 class 12:dog class13:horse class14:motorbike
1573 class 15:person class16:pottedplant class17:sheep
1574 class 18:sofa class19:train class20:tvmonitor */
1575 s32Ret = SAMPLE_IVE_RoiToRect(&(pstSwParam->stDstScore), &(pstSwParam->stDstRoi), &(pstSwParam->stClassRoiNum),
1576 pstSwParam->af32ScoreThr, HI_TRUE, &(pstSwParam->stRect), pstExtFrmInfo->stVFrame.u32Width,
1577 pstExtFrmInfo->stVFrame.u32Height, u32BaseWidth, u32BaseHeight);
1578 SAMPLE_SVP_CHECK_EXPR_RET(s32Ret != HI_SUCCESS, s32Ret, SAMPLE_SVP_ERR_LEVEL_ERROR,
1579 "Error(%#x),SAMPLE_SVP_NNIE_RoiToRect failed!\n", s32Ret);
1580
1581 return s32Ret;
1582 }
1583
SAMPLE_IVE_RectToRoiInfo(SAMPLE_SVP_NNIE_RECT_ARRAY_S * pstRect,HI_U32 u32BaseWidth,HI_U32 u32BaseHeight,SAMPLE_IVE_KCF_S * pstKcfInfo)1584 static HI_VOID SAMPLE_IVE_RectToRoiInfo(SAMPLE_SVP_NNIE_RECT_ARRAY_S *pstRect, HI_U32 u32BaseWidth,
1585 HI_U32 u32BaseHeight, SAMPLE_IVE_KCF_S *pstKcfInfo)
1586 {
1587 HI_U32 i, j, k;
1588 HI_U32 u32PaddW, u32PaddH;
1589
1590 k = 0;
1591
1592 for (i = 0; i < pstRect->u32ClsNum; i++) {
1593 if (i != SAMPLE_IVE_KCF_CAR_IDX) {
1594 continue;
1595 }
1596 for (j = 0; j < pstRect->au32RoiNum[i]; j++) {
1597 pstKcfInfo->astRoiInfo[k].stRoi.s24q8X =
1598 pstRect->astRect[i][j].astPoint[0].s32X * SAMPLE_IVE_KCF_ROI_FIX_POINT;
1599 pstKcfInfo->astRoiInfo[k].stRoi.s24q8Y =
1600 pstRect->astRect[i][j].astPoint[0].s32Y * SAMPLE_IVE_KCF_ROI_FIX_POINT;
1601
1602 pstKcfInfo->astRoiInfo[k].stRoi.u32Width =
1603 pstRect->astRect[i][j].astPoint[SAMPLE_IVE_KCF_IDX_2].s32X - pstRect->astRect[i][j].astPoint[0].s32X;
1604 pstKcfInfo->astRoiInfo[k].stRoi.u32Height =
1605 pstRect->astRect[i][j].astPoint[SAMPLE_IVE_KCF_IDX_2].s32Y - pstRect->astRect[i][j].astPoint[0].s32Y;
1606
1607 if ((pstKcfInfo->astRoiInfo[k].stRoi.s24q8X >= (HI_S32)(u32BaseWidth * SAMPLE_IVE_KCF_ROI_FIX_POINT)) ||
1608 (pstKcfInfo->astRoiInfo[k].stRoi.s24q8Y >= (HI_S32)(u32BaseHeight * SAMPLE_IVE_KCF_ROI_FIX_POINT))) {
1609 continue;
1610 }
1611
1612 u32PaddW = pstKcfInfo->astRoiInfo[k].stRoi.u32Width * pstKcfInfo->u3q5Padding /
1613 SAMPLE_IVE_KCF_PAD_FIX_POINT;
1614 if (u32PaddW > SAMPLE_IVE_KCF_ROI_PADDING_MAX_WIDTH) {
1615 pstKcfInfo->astRoiInfo[k].stRoi.u32Width =
1616 SAMPLE_IVE_KCF_ROI_PADDING_MAX_WIDTH * SAMPLE_IVE_KCF_PAD_FIX_POINT / pstKcfInfo->u3q5Padding;
1617 } else if (u32PaddW < SAMPLE_IVE_KCF_ROI_PADDING_MIN_WIDTH) {
1618 pstKcfInfo->astRoiInfo[k].stRoi.u32Width =
1619 SAMPLE_IVE_KCF_ROI_PADDING_MIN_WIDTH * SAMPLE_IVE_KCF_PAD_FIX_POINT / pstKcfInfo->u3q5Padding +
1620 SAMPLE_IVE_KCF_PAD_VALUE_2;
1621 }
1622
1623 u32PaddH = pstKcfInfo->astRoiInfo[k].stRoi.u32Height * pstKcfInfo->u3q5Padding /
1624 SAMPLE_IVE_KCF_PAD_FIX_POINT;
1625 if (u32PaddH > SAMPLE_IVE_KCF_ROI_PADDING_MAX_WIDTH) {
1626 pstKcfInfo->astRoiInfo[k].stRoi.u32Height =
1627 SAMPLE_IVE_KCF_ROI_PADDING_MAX_HEIGHT * SAMPLE_IVE_KCF_PAD_FIX_POINT / pstKcfInfo->u3q5Padding;
1628 } else if (u32PaddH < SAMPLE_IVE_KCF_ROI_PADDING_MIN_WIDTH) {
1629 pstKcfInfo->astRoiInfo[k].stRoi.u32Height =
1630 SAMPLE_IVE_KCF_ROI_PADDING_MIN_HEIGHT * SAMPLE_IVE_KCF_PAD_FIX_POINT / pstKcfInfo->u3q5Padding +
1631 SAMPLE_IVE_KCF_PAD_VALUE_2;
1632 }
1633
1634 k++;
1635 pstKcfInfo->astRoiInfo[k - 1].u32RoiId = k;
1636 pstKcfInfo->u32RoiNum = k;
1637 if (k >= SAMPLE_IVE_KCF_MAX_BBOX) {
1638 return;
1639 }
1640 }
1641 }
1642 }
1643
1644 /* function : Rfcn detect thread entry */
SAMPLE_IVE_Rfcn_Detect(HI_VOID * pArgs)1645 static HI_VOID *SAMPLE_IVE_Rfcn_Detect(HI_VOID *pArgs)
1646 {
1647 HI_S32 s32Ret;
1648 SAMPLE_SVP_NNIE_PARAM_S *pstParam;
1649 SAMPLE_SVP_NNIE_RFCN_SOFTWARE_PARAM_S *pstSwParam;
1650 HI_U32 u32Width, u32Height;
1651 VIDEO_FRAME_INFO_S stExtFrmInfo;
1652 HI_S32 s32VpssGrp = 0;
1653
1654 pstParam = &s_stRfcnNnieParam;
1655 pstSwParam = &s_stRfcnSoftwareParam;
1656
1657 while (HI_FALSE == s_bIveKcfStopSignal) {
1658 SAMPLE_IVE_MUTEX_LOCK(s_stIveKcfInfo.GetFrmMutex);
1659 if (CNN_PROC_START == s_stIveKcfInfo.enCnnProcStat) {
1660 u32Width = s_stIveKcfInfo.astFrameInfo[0].stVFrame.u32Width;
1661 u32Height = s_stIveKcfInfo.astFrameInfo[0].stVFrame.u32Height;
1662 (HI_VOID)memcpy_s(&stExtFrmInfo, sizeof(VIDEO_FRAME_INFO_S), &s_stIveKcfInfo.astFrameInfo[1],
1663 sizeof(VIDEO_FRAME_INFO_S));
1664 } else {
1665 SAMPLE_IVE_MUTEX_UNLOCK(s_stIveKcfInfo.GetFrmMutex);
1666 continue;
1667 }
1668 SAMPLE_IVE_MUTEX_UNLOCK(s_stIveKcfInfo.GetFrmMutex);
1669
1670 s32Ret = SAMPLE_IVE_Rfcn_GetRect(pstParam, pstSwParam, &stExtFrmInfo, u32Width, u32Height);
1671 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, BASE_RELEASE, "Error(%#x),SAMPLE_SVP_NNIE_Rfcn_Proc failed!\n",
1672 s32Ret);
1673
1674 SAMPLE_IVE_MUTEX_LOCK(s_stIveKcfInfo.CnnDetectMutex);
1675 SAMPLE_IVE_RectToRoiInfo(&pstSwParam->stRect, u32Width, u32Height, &s_stIveKcfInfo);
1676 if (s_stIveKcfInfo.u32RoiNum) {
1677 s_stIveKcfInfo.bNewDetect = HI_TRUE;
1678 }
1679 SAMPLE_IVE_MUTEX_UNLOCK(s_stIveKcfInfo.CnnDetectMutex);
1680
1681 BASE_RELEASE:
1682 s32Ret = HI_MPI_VPSS_ReleaseChnFrame(s32VpssGrp, 1, &stExtFrmInfo);
1683 if (s32Ret != HI_SUCCESS) {
1684 SAMPLE_PRT("Error(%#x),HI_MPI_VPSS_ReleaseChnFrame failed!\n", s32Ret);
1685 }
1686
1687 SAMPLE_IVE_MUTEX_LOCK(s_stIveKcfInfo.GetFrmMutex);
1688 s_stIveKcfInfo.enCnnGetFrmStat = CNN_GET_FRM_END;
1689 s_stIveKcfInfo.enCnnProcStat = CNN_PROC_END;
1690 SAMPLE_IVE_MUTEX_UNLOCK(s_stIveKcfInfo.GetFrmMutex);
1691 }
1692 (void)pArgs;
1693 return HI_NULL;
1694 }
1695
1696 /* function : Get frame thread entry */
SAMPLE_IVE_GetFrame(HI_VOID * pArgs)1697 static HI_VOID *SAMPLE_IVE_GetFrame(HI_VOID *pArgs)
1698 {
1699 VIDEO_FRAME_INFO_S astVideoFrame[SAMPLE_IVE_KCF_MAX_FRM_NUM];
1700 HI_S32 s32MilliSec = SAMPLE_IVE_FRM_TIMEOUT;
1701 HI_S32 s32Ret;
1702
1703 while (HI_FALSE == s_bIveKcfStopSignal) {
1704 s32Ret = HI_MPI_VPSS_GetChnFrame(0, 0, &astVideoFrame[0], s32MilliSec);
1705 if (s32Ret != HI_SUCCESS) {
1706 continue;
1707 }
1708
1709 SAMPLE_IVE_MUTEX_LOCK(s_stIveKcfInfo.QueueMutex);
1710 s32Ret = SAMPLE_IVE_QueueAddNode(s_stIveKcfInfo.pstQueueHead, &astVideoFrame[0]);
1711 if (s32Ret != HI_SUCCESS) {
1712 SAMPLE_PRT("Error(%#x),SAMPLE_IVE_QueueAddNode failed!\n", s32Ret);
1713 SAMPLE_IVE_MUTEX_UNLOCK(s_stIveKcfInfo.QueueMutex);
1714 goto RELEASE0;
1715 }
1716 SAMPLE_IVE_MUTEX_UNLOCK(s_stIveKcfInfo.QueueMutex);
1717
1718 SAMPLE_IVE_MUTEX_LOCK(s_stIveKcfInfo.GetFrmMutex);
1719 if (CNN_GET_FRM_END == s_stIveKcfInfo.enCnnGetFrmStat) {
1720 s_stIveKcfInfo.enCnnGetFrmStat = CNN_GET_FRM_START;
1721 s32Ret = HI_MPI_VPSS_GetChnFrame(0, 1, &astVideoFrame[1], s32MilliSec);
1722 if (s32Ret != HI_SUCCESS) {
1723 SAMPLE_IVE_MUTEX_UNLOCK(s_stIveKcfInfo.GetFrmMutex);
1724 continue;
1725 }
1726 (HI_VOID)memcpy_s(&s_stIveKcfInfo.astFrameInfo[0], sizeof(VIDEO_FRAME_INFO_S), &astVideoFrame[0],
1727 sizeof(VIDEO_FRAME_INFO_S));
1728 (HI_VOID)memcpy_s(&s_stIveKcfInfo.astFrameInfo[1], sizeof(VIDEO_FRAME_INFO_S), &astVideoFrame[1],
1729 sizeof(VIDEO_FRAME_INFO_S));
1730 s_stIveKcfInfo.enCnnProcStat = CNN_PROC_START;
1731 }
1732 SAMPLE_IVE_MUTEX_UNLOCK(s_stIveKcfInfo.GetFrmMutex);
1733
1734 continue;
1735
1736 RELEASE0:
1737 s32Ret = HI_MPI_VPSS_ReleaseChnFrame(0, 0, &astVideoFrame[0]);
1738 if (s32Ret != HI_SUCCESS) {
1739 SAMPLE_PRT("Error(%#x),HI_MPI_VPSS_ReleaseChnFrame failed,Grp(0) chn(0)!\n", s32Ret);
1740 }
1741 }
1742 (void)pArgs;
1743 return NULL;
1744 }
1745
SAMPLE_IVE_KcfCalcIOU(IVE_RECT_S24Q8_S * pstRect1,IVE_RECT_S24Q8_S * pstRect2)1746 static HI_FLOAT SAMPLE_IVE_KcfCalcIOU(IVE_RECT_S24Q8_S *pstRect1, IVE_RECT_S24Q8_S *pstRect2)
1747 {
1748 HI_S32 s32MinX, s32MinY, s32MaxX, s32MaxY;
1749 HI_FLOAT fArea1, fArea2, fInterArea, fIou;
1750 HI_S32 s32Width, s32Height;
1751
1752 s32MinX = SAMPLE_IVE_MAX(pstRect1->s24q8X / SAMPLE_IVE_KCF_ROI_FIX_POINT,
1753 pstRect2->s24q8X / SAMPLE_IVE_KCF_ROI_FIX_POINT);
1754 s32MinY = SAMPLE_IVE_MAX(pstRect1->s24q8Y / SAMPLE_IVE_KCF_ROI_FIX_POINT,
1755 pstRect2->s24q8Y / SAMPLE_IVE_KCF_ROI_FIX_POINT);
1756 s32MaxX = SAMPLE_IVE_MIN(pstRect1->s24q8X / SAMPLE_IVE_KCF_ROI_FIX_POINT + pstRect1->u32Width,
1757 pstRect2->s24q8X / SAMPLE_IVE_KCF_ROI_FIX_POINT + pstRect2->u32Width);
1758 s32MaxY = SAMPLE_IVE_MIN(pstRect1->s24q8Y / SAMPLE_IVE_KCF_ROI_FIX_POINT + pstRect1->u32Height,
1759 pstRect2->s24q8Y / SAMPLE_IVE_KCF_ROI_FIX_POINT + pstRect2->u32Height);
1760
1761 s32Width = s32MaxX - s32MinX + 1;
1762 s32Height = s32MaxY - s32MinY + 1;
1763
1764 s32Width = s32Width > 0 ? s32Width : 0;
1765 s32Height = s32Height > 0 ? s32Height : 0;
1766
1767 fInterArea = (HI_FLOAT)((HI_U32)s32Width * (HI_U32)s32Height);
1768
1769 fArea1 = (HI_FLOAT)(pstRect1->u32Width * pstRect1->u32Height);
1770 fArea2 = (pstRect2->u32Width * pstRect2->u32Height);
1771
1772 fIou = fInterArea / (fArea1 + fArea2 - fInterArea);
1773
1774 return fIou;
1775 }
1776
SAMPLE_IVE_KCF_ObjIOU(IVE_ROI_INFO_S astRoiInfo[],HI_U32 u32RoiNum,IVE_KCF_BBOX_S astBbox[],HI_U32 u32BboxNum,IVE_ROI_INFO_S astNewRoiInfo[],HI_U32 u32MaxRoiNum,HI_U32 * pu32NewRoiNum)1777 static HI_S32 SAMPLE_IVE_KCF_ObjIOU(IVE_ROI_INFO_S astRoiInfo[], HI_U32 u32RoiNum, IVE_KCF_BBOX_S astBbox[],
1778 HI_U32 u32BboxNum, IVE_ROI_INFO_S astNewRoiInfo[], HI_U32 u32MaxRoiNum, HI_U32 *pu32NewRoiNum)
1779 {
1780 HI_S32 s32Ret = HI_SUCCESS;
1781 HI_FLOAT f32NmsThr = SAMPLE_IVE_KCF_IOU_NMS_THR;
1782 HI_BOOL bTrackOk;
1783 HI_U32 u32NewRoiNum = 0;
1784 HI_U32 i, j;
1785
1786 if (u32BboxNum == 0) {
1787 s32Ret =
1788 memcpy_s(astNewRoiInfo, sizeof(IVE_ROI_INFO_S) * u32RoiNum, astRoiInfo, sizeof(IVE_ROI_INFO_S) * u32RoiNum);
1789 if (s32Ret != EOK) {
1790 SAMPLE_PRT("Error(%#x),memcpy_s roi_info failed!\n", s32Ret);
1791 return HI_ERR_IVE_ILLEGAL_PARAM;
1792 }
1793 *pu32NewRoiNum = u32RoiNum;
1794 return s32Ret;
1795 }
1796
1797 if (u32RoiNum == 0) {
1798 *pu32NewRoiNum = 0;
1799 return s32Ret;
1800 }
1801
1802 for (i = 0; i < u32RoiNum; i++) {
1803 for (j = 0; j < u32BboxNum; j++) {
1804 HI_BOOL bSuppressed;
1805 HI_FLOAT f32Iou;
1806
1807 if (astRoiInfo[i].u32RoiId == 0) {
1808 break;
1809 }
1810 if ((astBbox[j].stRoiInfo.u32RoiId == 0) || (HI_FALSE == astBbox[j].bTrackOk)) {
1811 continue;
1812 }
1813
1814 f32Iou = SAMPLE_IVE_KcfCalcIOU(&astRoiInfo[i].stRoi, &astBbox[j].stRoiInfo.stRoi);
1815 bSuppressed = (HI_BOOL)(f32Iou >= f32NmsThr);
1816
1817 if (bSuppressed) {
1818 s32Ret = HI_MPI_IVE_KCF_JudgeObjBboxTrackState(&astRoiInfo[i], &astBbox[j], &bTrackOk);
1819 if (s32Ret != HI_SUCCESS) {
1820 SAMPLE_PRT("Error(%#x),HI_MPI_IVE_KCF_JudgeObjBboxTrackState failed!\n", s32Ret);
1821 return s32Ret;
1822 }
1823
1824 // do not update the bbox's u32RoiId
1825 if (bTrackOk) {
1826 astBbox[j].stRoiInfo.stRoi.s24q8X = astRoiInfo[i].stRoi.s24q8X;
1827 astBbox[j].stRoiInfo.stRoi.s24q8Y = astRoiInfo[i].stRoi.s24q8Y;
1828 astBbox[j].stRoiInfo.stRoi.u32Width = astRoiInfo[i].stRoi.u32Width;
1829 astBbox[j].stRoiInfo.stRoi.u32Height = astRoiInfo[i].stRoi.u32Height;
1830 astBbox[j].bRoiRefresh = HI_TRUE;
1831
1832 astRoiInfo[i].u32RoiId = 0;
1833 } else {
1834 astBbox[j].bTrackOk = HI_FALSE;
1835 }
1836 break;
1837 }
1838 }
1839
1840 if (u32NewRoiNum == u32MaxRoiNum) {
1841 SAMPLE_PRT("reaching the maxRoiNum(%d), the rest roi will be cast away!\n", u32MaxRoiNum);
1842 *pu32NewRoiNum = u32NewRoiNum;
1843 return HI_SUCCESS;
1844 }
1845
1846 // u32RoiId!=0, means it hasn't been suppressed
1847 if (astRoiInfo[i].u32RoiId != 0) {
1848 (HI_VOID)memcpy_s(&astNewRoiInfo[u32NewRoiNum++], sizeof(IVE_ROI_INFO_S), &astRoiInfo[i],
1849 sizeof(IVE_ROI_INFO_S));
1850 }
1851 }
1852
1853 *pu32NewRoiNum = u32NewRoiNum;
1854 return s32Ret;
1855 }
1856
SAMPLE_IVE_FillImage(VIDEO_FRAME_INFO_S * pstFrameInfo,IVE_IMAGE_S * pstImage)1857 static void SAMPLE_IVE_FillImage(VIDEO_FRAME_INFO_S *pstFrameInfo, IVE_IMAGE_S *pstImage)
1858 {
1859 pstImage->au64PhyAddr[0] = pstFrameInfo->stVFrame.u64PhyAddr[0];
1860 pstImage->au64PhyAddr[1] = pstFrameInfo->stVFrame.u64PhyAddr[1];
1861 pstImage->au32Stride[0] = pstFrameInfo->stVFrame.u32Stride[0];
1862 pstImage->au32Stride[1] = pstFrameInfo->stVFrame.u32Stride[1];
1863 pstImage->u32Width = pstFrameInfo->stVFrame.u32Width;
1864 pstImage->u32Height = pstFrameInfo->stVFrame.u32Height;
1865
1866 if (pstFrameInfo->stVFrame.enPixelFormat == PIXEL_FORMAT_YVU_SEMIPLANAR_420) {
1867 pstImage->enType = IVE_IMAGE_TYPE_YUV420SP;
1868 } else {
1869 }
1870
1871 return;
1872 }
1873
SAMPLE_IVE_RectToPoint(IVE_KCF_BBOX_S astBbox[],HI_U32 u32BboxNum,HI_U32 u32BboxObjNum,SAMPLE_RECT_ARRAY_S * pstRect)1874 static HI_VOID SAMPLE_IVE_RectToPoint(IVE_KCF_BBOX_S astBbox[], HI_U32 u32BboxNum, HI_U32 u32BboxObjNum,
1875 SAMPLE_RECT_ARRAY_S *pstRect)
1876 {
1877 HI_U32 i;
1878 HI_U32 tmp_ux, tmp_uy;
1879 HI_S32 tmp_sx, tmp_sy;
1880
1881 pstRect->u16Num = 0;
1882 for (i = 0; i < u32BboxObjNum && i < u32BboxNum; i++) {
1883 tmp_sx = astBbox[i].stRoiInfo.stRoi.s24q8X / SAMPLE_IVE_KCF_ROI_FIX_POINT;
1884 tmp_sy = astBbox[i].stRoiInfo.stRoi.s24q8Y / SAMPLE_IVE_KCF_ROI_FIX_POINT;
1885
1886 if (tmp_sx < 0) {
1887 tmp_ux = *((hi_u32 *)&tmp_sx);
1888 tmp_ux = tmp_ux & (~1);
1889 tmp_sx = *((hi_s32 *)&tmp_ux);
1890 }
1891 if (tmp_sy < 0) {
1892 tmp_uy = *((hi_u32 *)&tmp_sy);
1893 tmp_uy = tmp_uy & (~1);
1894 tmp_sy = *((hi_s32 *)&tmp_sy);
1895 }
1896 if (tmp_sx > 0) {
1897 tmp_ux = (hi_u32)tmp_sx;
1898 tmp_ux = tmp_ux & (~1);
1899 tmp_sx = tmp_ux;
1900 }
1901 if (tmp_sy > 0) {
1902 tmp_uy = (hi_u32)tmp_sy;
1903 tmp_uy = tmp_uy & (~1);
1904 tmp_sy = tmp_uy;
1905 }
1906
1907 pstRect->astRect[i].astPoint[0].s32X = tmp_sx;
1908 pstRect->astRect[i].astPoint[0].s32Y = tmp_sy;
1909 if ((pstRect->astRect[i].astPoint[0].s32X < 0) || (pstRect->astRect[i].astPoint[0].s32Y < 0)) {
1910 pstRect->astRect[i].astPoint[0].s32X = 0;
1911 pstRect->astRect[i].astPoint[0].s32Y = 0;
1912 }
1913 pstRect->astRect[i].astPoint[SAMPLE_IVE_KCF_IDX_1].s32X =
1914 pstRect->astRect[i].astPoint[0].s32X + (astBbox[i].stRoiInfo.stRoi.u32Width & (~1));
1915 pstRect->astRect[i].astPoint[SAMPLE_IVE_KCF_IDX_1].s32Y = pstRect->astRect[i].astPoint[0].s32Y;
1916 pstRect->astRect[i].astPoint[SAMPLE_IVE_KCF_IDX_2].s32X =
1917 pstRect->astRect[i].astPoint[0].s32X + (astBbox[i].stRoiInfo.stRoi.u32Width & (~1));
1918 pstRect->astRect[i].astPoint[SAMPLE_IVE_KCF_IDX_2].s32Y =
1919 pstRect->astRect[i].astPoint[0].s32Y + (astBbox[i].stRoiInfo.stRoi.u32Height & (~1));
1920 pstRect->astRect[i].astPoint[SAMPLE_IVE_KCF_IDX_3].s32X = pstRect->astRect[i].astPoint[0].s32X;
1921 pstRect->astRect[i].astPoint[SAMPLE_IVE_KCF_IDX_3].s32Y =
1922 pstRect->astRect[i].astPoint[0].s32Y + (astBbox[i].stRoiInfo.stRoi.u32Height & (~1));
1923
1924 pstRect->u16Num++;
1925 }
1926 }
1927
SAMPLE_IVE_DispProcess(VIDEO_FRAME_INFO_S * pstFrameInfo,SAMPLE_RECT_ARRAY_S * pstRect)1928 static HI_S32 SAMPLE_IVE_DispProcess(VIDEO_FRAME_INFO_S *pstFrameInfo, SAMPLE_RECT_ARRAY_S *pstRect)
1929 {
1930 HI_S32 s32Ret;
1931 VO_LAYER voLayer = 0;
1932 VO_CHN voChn = 0;
1933 HI_S32 s32MilliSec = SAMPLE_IVE_FRM_TIMEOUT;
1934
1935 s32Ret = SAMPLE_COMM_VGS_FillRect(pstFrameInfo, pstRect, SAMPLE_IVE_KCF_COLOR);
1936 if (s32Ret != HI_SUCCESS) {
1937 SAMPLE_PRT("Error(%#x),SAMPLE_COMM_VGS_FillRect failed!\n", s32Ret);
1938 }
1939
1940 s32Ret = HI_MPI_VO_SendFrame(voLayer, voChn, pstFrameInfo, s32MilliSec);
1941 if (s32Ret != HI_SUCCESS) {
1942 SAMPLE_PRT("Error(%#x),HI_MPI_VO_SendFrame failed!\n", s32Ret);
1943 return s32Ret;
1944 }
1945
1946 return s32Ret;
1947 }
1948
1949 /* function : Kcf tracking and vo display thread entry */
SAMPLE_IVE_KcfTracking(HI_VOID * pArgs)1950 static HI_VOID *SAMPLE_IVE_KcfTracking(HI_VOID *pArgs)
1951 {
1952 IVE_KCF_BBOX_S astBbox[SAMPLE_IVE_KCF_MAX_BBOX] = {0};
1953 IVE_ROI_INFO_S astRoiInfo[SAMPLE_IVE_KCF_MAX_BBOX] = {0};
1954 IVE_ROI_INFO_S astNewRoiInfo[SAMPLE_IVE_KCF_MAX_BBOX] = {0};
1955 SAMPLE_RECT_ARRAY_S stRect = { 0 };
1956 HI_U32 u32BboxNum = 0;
1957 HI_U32 u32RoiNum = 0;
1958 HI_U32 u32MaxNewRoiNum = SAMPLE_IVE_KCF_MAX_BBOX;
1959 HI_U32 u32NewRoiNum = 0;
1960 IVE_HANDLE hIveHandle;
1961 HI_BOOL bInstant = HI_TRUE;
1962 IVE_IMAGE_S stSrc;
1963 SAMPLE_IVE_NODE_S *pstQueueNode = NULL;
1964 HI_S32 s32QueueLen;
1965 HI_S32 s32Ret;
1966 HI_BOOL bFinish = HI_FALSE;
1967 HI_BOOL bBlock = HI_TRUE;
1968
1969 while (HI_FALSE == s_bIveKcfStopSignal) {
1970 SAMPLE_IVE_MUTEX_LOCK(s_stIveKcfInfo.QueueMutex);
1971 s32QueueLen = SAMPLE_IVE_QueueSize(s_stIveKcfInfo.pstQueueHead);
1972 if (s32QueueLen <= 0) {
1973 SAMPLE_IVE_MUTEX_UNLOCK(s_stIveKcfInfo.QueueMutex);
1974 continue;
1975 }
1976 pstQueueNode = SAMPLE_IVE_QueueGetNode(s_stIveKcfInfo.pstQueueHead);
1977 if (pstQueueNode == NULL) {
1978 SAMPLE_IVE_MUTEX_UNLOCK(s_stIveKcfInfo.QueueMutex);
1979 continue;
1980 }
1981 SAMPLE_IVE_MUTEX_UNLOCK(s_stIveKcfInfo.QueueMutex);
1982 SAMPLE_IVE_FillImage(&pstQueueNode->stFrameInfo, &stSrc);
1983
1984 if (s_stIveKcfInfo.bNewDetect) {
1985 SAMPLE_IVE_MUTEX_LOCK(s_stIveKcfInfo.CnnDetectMutex);
1986 s_stIveKcfInfo.bNewDetect = HI_FALSE;
1987 u32RoiNum = s_stIveKcfInfo.u32RoiNum;
1988 s_stIveKcfInfo.u32RoiNum = 0;
1989 (HI_VOID)memcpy_s(astRoiInfo, sizeof(IVE_ROI_INFO_S) * u32RoiNum, s_stIveKcfInfo.astRoiInfo,
1990 sizeof(IVE_ROI_INFO_S) * u32RoiNum);
1991 SAMPLE_IVE_MUTEX_UNLOCK(s_stIveKcfInfo.CnnDetectMutex);
1992
1993 s32Ret = SAMPLE_IVE_KCF_ObjIOU(astRoiInfo, u32RoiNum, astBbox, u32BboxNum, astNewRoiInfo, u32MaxNewRoiNum,
1994 &u32NewRoiNum);
1995 if (s32Ret != HI_SUCCESS) {
1996 SAMPLE_PRT("Error(%#x),SAMPLE_IVE_KCF_ObjIOU failed!\n", s32Ret);
1997 goto FAIL;
1998 }
1999
2000 s32Ret = HI_MPI_IVE_KCF_ObjUpdate(&s_stIveKcfInfo.stObjList, astBbox, u32BboxNum);
2001 if (s32Ret != HI_SUCCESS) {
2002 SAMPLE_PRT("Error(%#x),HI_MPI_IVE_KCF_ObjUpdate failed!\n", s32Ret);
2003 goto FAIL;
2004 }
2005
2006 s32Ret = HI_MPI_IVE_KCF_GetTrainObj(s_stIveKcfInfo.u3q5Padding, astNewRoiInfo, u32NewRoiNum,
2007 &s_stIveKcfInfo.stCosWinX, &s_stIveKcfInfo.stCosWinY, &s_stIveKcfInfo.stGaussPeak,
2008 &s_stIveKcfInfo.stObjList);
2009 if (s32Ret != HI_SUCCESS) {
2010 SAMPLE_PRT("Error(%#x),HI_MPI_IVE_KCF_GetTrainObj failed!\n", s32Ret);
2011 goto FAIL;
2012 }
2013 }
2014
2015 if (s_stIveKcfInfo.stObjList.u32TrackObjNum != 0 || s_stIveKcfInfo.stObjList.u32TrainObjNum != 0) {
2016 s32Ret = HI_MPI_IVE_KCF_Process(&hIveHandle, &stSrc, &s_stIveKcfInfo.stObjList,
2017 &s_stIveKcfInfo.stKcfProCtrl, bInstant);
2018 if (s32Ret != HI_SUCCESS) {
2019 SAMPLE_PRT("Error(%#x),HI_MPI_IVE_KCF_Process failed!\n", s32Ret);
2020 goto FAIL;
2021 }
2022
2023 s32Ret = HI_MPI_IVE_Query(hIveHandle, &bFinish, bBlock);
2024 while (s32Ret == HI_ERR_IVE_QUERY_TIMEOUT) {
2025 usleep(IVE_QUERY_SLEEP_TIME);
2026 s32Ret = HI_MPI_IVE_Query(hIveHandle, &bFinish, bBlock);
2027 }
2028
2029 SAMPLE_CHECK_EXPR_RET(s32Ret != HI_SUCCESS, HI_FALSE, "Error(%#x),HI_MPI_IVE_Query failed!\n", s32Ret);
2030
2031 s32Ret = HI_MPI_IVE_KCF_GetObjBbox(&s_stIveKcfInfo.stObjList, astBbox, &u32BboxNum,
2032 &s_stIveKcfInfo.stKcfBboxCtrl);
2033 if (s32Ret != HI_SUCCESS) {
2034 SAMPLE_PRT("Error(%#x),HI_MPI_IVE_KCF_GetObjBbox failed!\n", s32Ret);
2035 }
2036 SAMPLE_IVE_RectToPoint(astBbox, SAMPLE_IVE_KCF_MAX_BBOX, u32BboxNum, &stRect);
2037 } else {
2038 stRect.u16Num = 0;
2039 }
2040
2041 s32Ret = SAMPLE_IVE_DispProcess(&pstQueueNode->stFrameInfo, &stRect);
2042 if (s32Ret != HI_SUCCESS) {
2043 SAMPLE_PRT("Error(%#x),SAMPLE_IVE_DispProcess failed!\n", s32Ret);
2044 }
2045
2046 FAIL:
2047 (HI_VOID)HI_MPI_VPSS_ReleaseChnFrame(0, 0, &pstQueueNode->stFrameInfo);
2048 SAMPLE_IVE_QueueFreeNode(pstQueueNode);
2049 }
2050 (void)pArgs;
2051 return NULL;
2052 }
2053
SAMPLE_IVE_KcfDeInit(SAMPLE_IVE_KCF_S * pstIveKcfInfo)2054 static HI_VOID SAMPLE_IVE_KcfDeInit(SAMPLE_IVE_KCF_S *pstIveKcfInfo)
2055 {
2056 SAMPLE_IVE_NODE_S *pstQueueNode = NULL;
2057
2058 if (CNN_PROC_START == pstIveKcfInfo->enCnnProcStat) {
2059 (HI_VOID)HI_MPI_VPSS_ReleaseChnFrame(0, 1, &pstIveKcfInfo->astFrameInfo[1]);
2060 SAMPLE_IVE_MUTEX_LOCK(pstIveKcfInfo->GetFrmMutex);
2061 pstIveKcfInfo->enCnnGetFrmStat = CNN_GET_FRM_END;
2062 pstIveKcfInfo->enCnnProcStat = CNN_PROC_END;
2063 SAMPLE_IVE_MUTEX_UNLOCK(pstIveKcfInfo->GetFrmMutex);
2064 }
2065
2066 SAMPLE_IVE_MUTEX_DESTROY(pstIveKcfInfo->QueueMutex);
2067 SAMPLE_IVE_MUTEX_DESTROY(pstIveKcfInfo->GetFrmMutex);
2068 SAMPLE_IVE_MUTEX_DESTROY(pstIveKcfInfo->CnnDetectMutex);
2069 (HI_VOID)HI_MPI_IVE_KCF_DestroyObjList(&pstIveKcfInfo->stObjList);
2070
2071 while (!SAMPLE_IVE_QueueIsEmpty(pstIveKcfInfo->pstQueueHead)) {
2072 pstQueueNode = SAMPLE_IVE_QueueGetNode(pstIveKcfInfo->pstQueueHead);
2073 if (pstQueueNode != NULL) {
2074 (HI_VOID)HI_MPI_VPSS_ReleaseChnFrame(0, 0, &pstQueueNode->stFrameInfo);
2075 SAMPLE_IVE_QueueFreeNode(pstQueueNode);
2076 }
2077 }
2078 SAMPLE_IVE_QueueDestory(pstIveKcfInfo->pstQueueHead);
2079 IVE_MMZ_FREE(pstIveKcfInfo->stTotalMem.u64PhyAddr, pstIveKcfInfo->stTotalMem.u64VirAddr);
2080
2081 return;
2082 }
2083
SAMPLE_IVE_KcfInit(SAMPLE_IVE_KCF_S * pstIveKcfInfo)2084 static HI_S32 SAMPLE_IVE_KcfInit(SAMPLE_IVE_KCF_S *pstIveKcfInfo)
2085 {
2086 HI_S32 s32Ret = HI_SUCCESS;
2087 HI_U32 u32Size;
2088 HI_U32 u32TotalSize;
2089 HI_S32 s32Len;
2090
2091 (HI_VOID)memset_s(pstIveKcfInfo, sizeof(SAMPLE_IVE_KCF_S), 0, sizeof(SAMPLE_IVE_KCF_S));
2092
2093 s32Ret = HI_MPI_IVE_KCF_GetMemSize(SAMPLE_IVE_KCF_NODE_MAX_NUM, &u32Size);
2094 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, FAIL_0, "Error(%#x),HI_MPI_IVE_KCF_GetMemSize failed!\n", s32Ret);
2095 /* (HOGFeatrue + Alpha + DstBuf) + Guasspeak + CosWinX + CosWinY + TmpBuf */
2096 u32TotalSize = u32Size + SAMPLE_IVE_KCF_GAUSS_PEAK_TOTAL_SIZE + SAMPLE_IVE_KCF_COS_WINDOW_TOTAL_SIZE +
2097 SAMPLE_IVE_KCF_COS_WINDOW_TOTAL_SIZE + SAMPLE_IVE_KCF_TEMP_BUF_SIZE;
2098 s32Ret = SAMPLE_COMM_IVE_CreateMemInfo(&pstIveKcfInfo->stTotalMem, u32TotalSize);
2099 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, FAIL_0, "Error(%#x),SAMPLE_COMM_IVE_CreateMemInfo failed!\n", s32Ret);
2100 (HI_VOID)memset_s((HI_U8 *)(HI_UINTPTR_T)pstIveKcfInfo->stTotalMem.u64VirAddr, u32TotalSize, 0x0, u32TotalSize);
2101
2102 pstIveKcfInfo->stListMem.u64PhyAddr = pstIveKcfInfo->stTotalMem.u64PhyAddr;
2103 pstIveKcfInfo->stListMem.u64VirAddr = pstIveKcfInfo->stTotalMem.u64VirAddr;
2104 pstIveKcfInfo->stListMem.u32Size = u32Size;
2105
2106 pstIveKcfInfo->stGaussPeak.u64PhyAddr = pstIveKcfInfo->stListMem.u64PhyAddr + u32Size;
2107 pstIveKcfInfo->stGaussPeak.u64VirAddr = pstIveKcfInfo->stListMem.u64VirAddr + u32Size;
2108 pstIveKcfInfo->stGaussPeak.u32Size = SAMPLE_IVE_KCF_GAUSS_PEAK_TOTAL_SIZE;
2109
2110 pstIveKcfInfo->stCosWinX.u64PhyAddr = pstIveKcfInfo->stGaussPeak.u64PhyAddr + SAMPLE_IVE_KCF_GAUSS_PEAK_TOTAL_SIZE;
2111 pstIveKcfInfo->stCosWinX.u64VirAddr = pstIveKcfInfo->stGaussPeak.u64VirAddr + SAMPLE_IVE_KCF_GAUSS_PEAK_TOTAL_SIZE;
2112 pstIveKcfInfo->stCosWinX.u32Size = SAMPLE_IVE_KCF_COS_WINDOW_TOTAL_SIZE;
2113
2114 pstIveKcfInfo->stCosWinY.u64PhyAddr = pstIveKcfInfo->stCosWinX.u64PhyAddr + SAMPLE_IVE_KCF_COS_WINDOW_TOTAL_SIZE;
2115 pstIveKcfInfo->stCosWinY.u64VirAddr = pstIveKcfInfo->stCosWinX.u64VirAddr + SAMPLE_IVE_KCF_COS_WINDOW_TOTAL_SIZE;
2116 pstIveKcfInfo->stCosWinY.u32Size = SAMPLE_IVE_KCF_COS_WINDOW_TOTAL_SIZE;
2117
2118 pstIveKcfInfo->stKcfProCtrl.stTmpBuf.u64PhyAddr =
2119 pstIveKcfInfo->stCosWinY.u64PhyAddr + SAMPLE_IVE_KCF_COS_WINDOW_TOTAL_SIZE;
2120 pstIveKcfInfo->stKcfProCtrl.stTmpBuf.u64VirAddr =
2121 pstIveKcfInfo->stCosWinY.u64VirAddr + SAMPLE_IVE_KCF_COS_WINDOW_TOTAL_SIZE;
2122 pstIveKcfInfo->stKcfProCtrl.stTmpBuf.u32Size = SAMPLE_IVE_KCF_TEMP_BUF_SIZE;
2123
2124 pstIveKcfInfo->stKcfProCtrl.enCscMode = IVE_CSC_MODE_VIDEO_BT709_YUV2RGB;
2125 pstIveKcfInfo->stKcfProCtrl.u1q15InterFactor = SAMPLE_IVE_KCF_INTER_FACTOR;
2126 pstIveKcfInfo->stKcfProCtrl.u0q16Lamda = SAMPLE_IVE_KCF_LAMDA;
2127 pstIveKcfInfo->stKcfProCtrl.u0q8Sigma = SAMPLE_IVE_KCF_SIGMA;
2128 pstIveKcfInfo->stKcfProCtrl.u4q12TrancAlfa = SAMPLE_IVE_KCF_TRANC_ALFA;
2129 pstIveKcfInfo->stKcfProCtrl.u8RespThr = SAMPLE_IVE_KCF_RESP_THR;
2130
2131 pstIveKcfInfo->u3q5Padding = SAMPLE_IVE_KCF_PAD_VALUE_48;
2132
2133 pstIveKcfInfo->stKcfBboxCtrl.u32MaxBboxNum = SAMPLE_IVE_KCF_NODE_MAX_NUM;
2134 pstIveKcfInfo->stKcfBboxCtrl.s32RespThr = 0;
2135
2136 s32Len = SAMPLE_IVE_QUEUE_LEN;
2137 pstIveKcfInfo->pstQueueHead = SAMPLE_IVE_QueueCreate(s32Len);
2138 SAMPLE_CHECK_EXPR_GOTO(pstIveKcfInfo->pstQueueHead == NULL, FAIL_1, "Error,SAMPLE_IVE_QueueCreate failed!\n");
2139
2140 s32Ret =
2141 HI_MPI_IVE_KCF_CreateObjList(&pstIveKcfInfo->stListMem, SAMPLE_IVE_KCF_NODE_MAX_NUM, &pstIveKcfInfo->stObjList);
2142 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, FAIL_2, "Error(%#x),HI_MPI_IVE_KCF_CreateObjList failed!\n", s32Ret);
2143
2144 s32Ret = HI_MPI_IVE_KCF_CreateGaussPeak(pstIveKcfInfo->u3q5Padding, &pstIveKcfInfo->stGaussPeak);
2145 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, FAIL_3, "Error(%#x),HI_MPI_IVE_KCF_CreateGaussPeak failed!\n", s32Ret);
2146
2147 s32Ret = HI_MPI_IVE_KCF_CreateCosWin(&pstIveKcfInfo->stCosWinX, &pstIveKcfInfo->stCosWinY);
2148 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, FAIL_3, "Error(%#x),HI_MPI_IVE_KCF_CreateCosWin failed!\n", s32Ret);
2149
2150 pstIveKcfInfo->enCnnGetFrmStat = CNN_GET_FRM_END;
2151 pstIveKcfInfo->enCnnProcStat = CNN_PROC_END;
2152 pstIveKcfInfo->bFirstDetect = HI_FALSE;
2153 SAMPLE_IVE_MUTEX_INIT_LOCK(pstIveKcfInfo->CnnDetectMutex);
2154 SAMPLE_IVE_MUTEX_INIT_LOCK(pstIveKcfInfo->GetFrmMutex);
2155 SAMPLE_IVE_MUTEX_INIT_LOCK(pstIveKcfInfo->QueueMutex);
2156
2157 return s32Ret;
2158
2159 FAIL_3:
2160 (HI_VOID)HI_MPI_IVE_KCF_DestroyObjList(&pstIveKcfInfo->stObjList);
2161 FAIL_2:
2162 SAMPLE_IVE_QueueDestory(pstIveKcfInfo->pstQueueHead);
2163 FAIL_1:
2164 IVE_MMZ_FREE(pstIveKcfInfo->stTotalMem.u64PhyAddr, pstIveKcfInfo->stTotalMem.u64VirAddr);
2165 FAIL_0:
2166 return s32Ret;
2167 }
2168
SAMPLE_IVE_KCF_Stop(HI_VOID)2169 static HI_VOID SAMPLE_IVE_KCF_Stop(HI_VOID)
2170 {
2171 VI_PIPE ViPipe = 0;
2172 VI_CHN ViChn = 0;
2173 VPSS_GRP VpssGrp = 0;
2174 HI_BOOL abChnEnable[VPSS_MAX_PHY_CHN_NUM] = {1, 1, 0};
2175
2176 s_bIveKcfStopSignal = HI_TRUE;
2177 if (s_IveGetFrmThread != 0) {
2178 pthread_join(s_IveGetFrmThread, NULL);
2179 s_IveGetFrmThread = 0;
2180 }
2181 if (s_IveTrackThread != 0) {
2182 pthread_join(s_IveTrackThread, NULL);
2183 s_IveTrackThread = 0;
2184 }
2185
2186 if (s_IveDetectThread != 0) {
2187 pthread_join(s_IveDetectThread, NULL);
2188 s_IveDetectThread = 0;
2189 }
2190
2191 SAMPLE_IVE_RfcnDeinit(&s_stRfcnNnieParam, &s_stRfcnSoftwareParam, &s_stRfcnModel);
2192 (HI_VOID)memset_s(&s_stRfcnNnieParam, sizeof(SAMPLE_SVP_NNIE_PARAM_S), 0, sizeof(SAMPLE_SVP_NNIE_PARAM_S));
2193 (HI_VOID)memset_s(&s_stRfcnSoftwareParam, sizeof(SAMPLE_SVP_NNIE_RFCN_SOFTWARE_PARAM_S), 0,
2194 sizeof(SAMPLE_SVP_NNIE_RFCN_SOFTWARE_PARAM_S));
2195 (HI_VOID)memset_s(&s_stRfcnModel, sizeof(SAMPLE_SVP_NNIE_MODEL_S), 0, sizeof(SAMPLE_SVP_NNIE_MODEL_S));
2196 SAMPLE_IVE_KcfDeInit(&s_stIveKcfInfo);
2197
2198 SAMPLE_COMM_VO_StopVO(&s_stVoConfig);
2199 SAMPLE_COMM_VI_UnBind_VPSS(ViPipe, ViChn, VpssGrp);
2200 SAMPLE_COMM_VPSS_Stop(VpssGrp, abChnEnable);
2201 SAMPLE_COMM_VI_StopVi(&s_stViConfig);
2202 SAMPLE_COMM_SYS_Exit();
2203 printf("\033[0;31mprogram termination abnormally!\033[0;39m\n");
2204 }
SAMPLE_IVE_KCF_Pause(HI_VOID)2205 static HI_S32 SAMPLE_IVE_KCF_Pause(HI_VOID)
2206 {
2207 printf("---------------press Enter key to exit!---------------\n");
2208 if (s_bIveKcfStopSignal == HI_TRUE) {
2209 SAMPLE_IVE_KCF_Stop();
2210 return HI_FAILURE;
2211 }
2212 (HI_VOID)getchar();
2213 if (s_bIveKcfStopSignal == HI_TRUE) {
2214 SAMPLE_IVE_KCF_Stop();
2215 return HI_FAILURE;
2216 }
2217 return HI_SUCCESS;
2218 }
2219
2220 /* function : Rfcn + Kcf detecting and tracking car. */
SAMPLE_IVE_Kcf(void)2221 void SAMPLE_IVE_Kcf(void)
2222 {
2223 HI_CHAR *pcModelName = "./data/input/kcf/inst_rfcn_resnet50_cycle_352x288.wk";
2224 SAMPLE_SVP_NNIE_CFG_S stNnieCfg = { 0 };
2225 HI_S32 s32Ret = HI_SUCCESS;
2226 HI_S32 s32ViCnt = 1;
2227 VI_DEV ViDev = 0;
2228 VI_PIPE ViPipe = 0;
2229 VI_CHN ViChn = 0;
2230 HI_S32 s32WorkSnsId = 0;
2231
2232 SIZE_S astSize[SAMPLE_IVE_KCF_MAX_PIC_SIZE];
2233 VB_CONFIG_S stVbConf;
2234 PIC_SIZE_E enPicSize;
2235 HI_U32 u32BlkSize;
2236
2237 WDR_MODE_E enWDRMode = WDR_MODE_NONE;
2238 DYNAMIC_RANGE_E enDynamicRange = DYNAMIC_RANGE_SDR8;
2239 PIXEL_FORMAT_E enPixFormat = PIXEL_FORMAT_YVU_SEMIPLANAR_420;
2240 VIDEO_FORMAT_E enVideoFormat = VIDEO_FORMAT_LINEAR;
2241 COMPRESS_MODE_E enCompressMode = COMPRESS_MODE_NONE;
2242 VI_VPSS_MODE_E enMastPipeMode = VI_ONLINE_VPSS_OFFLINE;
2243
2244 VPSS_GRP VpssGrp = 0;
2245 VPSS_GRP_ATTR_S stVpssGrpAttr;
2246 HI_BOOL abChnEnable[VPSS_MAX_PHY_CHN_NUM] = {0};
2247 VPSS_CHN_ATTR_S astVpssChnAttr[VPSS_MAX_PHY_CHN_NUM];
2248 HI_U32 i;
2249
2250 /* step 1: init vi vpss vo */
2251 SAMPLE_COMM_VI_GetSensorInfo(&s_stViConfig);
2252
2253 s_stViConfig.s32WorkingViNum = s32ViCnt;
2254 s_stViConfig.as32WorkingViId[0] = 0;
2255 s_stViConfig.astViInfo[s32WorkSnsId].stSnsInfo.MipiDev = ViDev;
2256 s_stViConfig.astViInfo[s32WorkSnsId].stSnsInfo.s32BusId = 0;
2257 s_stViConfig.astViInfo[s32WorkSnsId].stDevInfo.ViDev = ViDev;
2258 s_stViConfig.astViInfo[s32WorkSnsId].stDevInfo.enWDRMode = enWDRMode;
2259 s_stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.enMastPipeMode = enMastPipeMode;
2260 s_stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.aPipe[SAMPLE_IVE_KCF_IDX_0] = ViPipe;
2261 s_stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.aPipe[SAMPLE_IVE_KCF_IDX_1] = -1;
2262 s_stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.aPipe[SAMPLE_IVE_KCF_IDX_2] = -1;
2263 s_stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.aPipe[SAMPLE_IVE_KCF_IDX_3] = -1;
2264 s_stViConfig.astViInfo[s32WorkSnsId].stChnInfo.ViChn = ViChn;
2265 s_stViConfig.astViInfo[s32WorkSnsId].stChnInfo.enPixFormat = enPixFormat;
2266 s_stViConfig.astViInfo[s32WorkSnsId].stChnInfo.enDynamicRange = enDynamicRange;
2267 s_stViConfig.astViInfo[s32WorkSnsId].stChnInfo.enVideoFormat = enVideoFormat;
2268 s_stViConfig.astViInfo[s32WorkSnsId].stChnInfo.enCompressMode = enCompressMode;
2269
2270 /* get picture size */
2271 s32Ret = SAMPLE_COMM_VI_GetSizeBySensor(s_stViConfig.astViInfo[s32WorkSnsId].stSnsInfo.enSnsType, &enPicSize);
2272 if (s32Ret != HI_SUCCESS) {
2273 SAMPLE_PRT("get picture size by sensor failed!\n");
2274 return;
2275 }
2276
2277 s32Ret = SAMPLE_COMM_SYS_GetPicSize(enPicSize, &astSize[SAMPLE_IVE_KCF_IDX_0]);
2278 if (s32Ret != HI_SUCCESS) {
2279 SAMPLE_PRT("get picture size failed!\n");
2280 return;
2281 }
2282
2283 enPicSize = PIC_1080P;
2284 s32Ret = SAMPLE_COMM_SYS_GetPicSize(enPicSize, &astSize[SAMPLE_IVE_KCF_IDX_1]);
2285 if (s32Ret != HI_SUCCESS) {
2286 SAMPLE_PRT("get picture size failed!\n");
2287 return;
2288 }
2289
2290 enPicSize = PIC_CIF;
2291 s32Ret = SAMPLE_COMM_SYS_GetPicSize(enPicSize, &astSize[SAMPLE_IVE_KCF_IDX_2]);
2292 if (s32Ret != HI_SUCCESS) {
2293 SAMPLE_PRT("get picture size failed!\n");
2294 return;
2295 }
2296
2297 /* config vb */
2298 (HI_VOID)memset_s(&stVbConf, sizeof(VB_CONFIG_S), 0, sizeof(VB_CONFIG_S));
2299 stVbConf.u32MaxPoolCnt = SAMPLE_IVE_KCF_MAX_POOL_CNT;
2300
2301 u32BlkSize = COMMON_GetPicBufferSize(astSize[0].u32Width, astSize[0].u32Height, SAMPLE_PIXEL_FORMAT,
2302 DATA_BITWIDTH_8, COMPRESS_MODE_NONE, DEFAULT_ALIGN);
2303 stVbConf.astCommPool[0].u64BlkSize = u32BlkSize;
2304 stVbConf.astCommPool[0].u32BlkCnt = SAMPLE_IVE_KCF_BLK_CNT_10;
2305
2306 u32BlkSize = VI_GetRawBufferSize(astSize[0].u32Width, astSize[0].u32Height, PIXEL_FORMAT_RGB_BAYER_16BPP,
2307 COMPRESS_MODE_NONE, DEFAULT_ALIGN);
2308 stVbConf.astCommPool[SAMPLE_IVE_KCF_IDX_1].u64BlkSize = u32BlkSize;
2309 stVbConf.astCommPool[SAMPLE_IVE_KCF_IDX_1].u32BlkCnt = SAMPLE_IVE_KCF_BLK_CNT_4;
2310
2311 u32BlkSize = COMMON_GetPicBufferSize(astSize[SAMPLE_IVE_KCF_IDX_1].u32Width,
2312 astSize[SAMPLE_IVE_KCF_IDX_1].u32Height, SAMPLE_PIXEL_FORMAT, DATA_BITWIDTH_8, COMPRESS_MODE_NONE,
2313 DEFAULT_ALIGN);
2314 stVbConf.astCommPool[SAMPLE_IVE_KCF_IDX_2].u64BlkSize = u32BlkSize;
2315 stVbConf.astCommPool[SAMPLE_IVE_KCF_IDX_2].u32BlkCnt = SAMPLE_IVE_KCF_BLK_CNT_10;
2316
2317 u32BlkSize = COMMON_GetPicBufferSize(astSize[SAMPLE_IVE_KCF_IDX_2].u32Width,
2318 astSize[SAMPLE_IVE_KCF_IDX_2].u32Height, SAMPLE_PIXEL_FORMAT, DATA_BITWIDTH_8, COMPRESS_MODE_NONE,
2319 DEFAULT_ALIGN);
2320 stVbConf.astCommPool[SAMPLE_IVE_KCF_IDX_3].u64BlkSize = u32BlkSize;
2321 stVbConf.astCommPool[SAMPLE_IVE_KCF_IDX_3].u32BlkCnt = SAMPLE_IVE_KCF_BLK_CNT_10;
2322
2323 s32Ret = SAMPLE_COMM_SYS_Init(&stVbConf);
2324 if (s32Ret != HI_SUCCESS) {
2325 SAMPLE_PRT("system init failed with %d!\n", s32Ret);
2326 return;
2327 }
2328
2329 /* start vi */
2330 s32Ret = SAMPLE_COMM_VI_StartVi(&s_stViConfig);
2331 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, END_0, "Error(%#x),SAMPLE_COMM_VI_StartVi failed!\n", s32Ret);
2332
2333 /* config vpss */
2334 (HI_VOID)memset_s(&stVpssGrpAttr, sizeof(VPSS_GRP_ATTR_S), 0, sizeof(VPSS_GRP_ATTR_S));
2335 stVpssGrpAttr.stFrameRate.s32SrcFrameRate = -1;
2336 stVpssGrpAttr.stFrameRate.s32DstFrameRate = -1;
2337 stVpssGrpAttr.enDynamicRange = DYNAMIC_RANGE_SDR8;
2338 stVpssGrpAttr.enPixelFormat = enPixFormat;
2339 stVpssGrpAttr.u32MaxW = astSize[0].u32Width;
2340 stVpssGrpAttr.u32MaxH = astSize[0].u32Height;
2341 stVpssGrpAttr.bNrEn = HI_FALSE;
2342 stVpssGrpAttr.stNrAttr.enCompressMode = COMPRESS_MODE_NONE;
2343 stVpssGrpAttr.stNrAttr.enNrMotionMode = NR_MOTION_MODE_NORMAL;
2344
2345 for (i = 0; i < SAMPLE_IVE_KCF_VPSS_MAX_CHN; i++) {
2346 astVpssChnAttr[i].u32Width = astSize[i + 1].u32Width;
2347 astVpssChnAttr[i].u32Height = astSize[i + 1].u32Height;
2348 astVpssChnAttr[i].enChnMode = VPSS_CHN_MODE_USER;
2349 astVpssChnAttr[i].enCompressMode = enCompressMode;
2350 astVpssChnAttr[i].enDynamicRange = enDynamicRange;
2351 astVpssChnAttr[i].enVideoFormat = enVideoFormat;
2352 astVpssChnAttr[i].enPixelFormat = enPixFormat;
2353 astVpssChnAttr[i].stFrameRate.s32SrcFrameRate = -1;
2354 astVpssChnAttr[i].stFrameRate.s32DstFrameRate = -1;
2355 astVpssChnAttr[i].u32Depth = 1;
2356 astVpssChnAttr[i].bMirror = HI_FALSE;
2357 astVpssChnAttr[i].bFlip = HI_FALSE;
2358 astVpssChnAttr[i].stAspectRatio.enMode = ASPECT_RATIO_NONE;
2359
2360 abChnEnable[i] = HI_TRUE;
2361 }
2362 /* start vpss */
2363 s32Ret = SAMPLE_COMM_VPSS_Start(VpssGrp, abChnEnable, &stVpssGrpAttr, astVpssChnAttr);
2364 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, END_1, "Error(%#x),SAMPLE_COMM_VPSS_Start failed!\n", s32Ret);
2365
2366 /* vi bind vpss */
2367 s32Ret = SAMPLE_COMM_VI_Bind_VPSS(ViPipe, ViChn, VpssGrp);
2368 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, END_2, "Error(%#x),SAMPLE_COMM_VI_Bind_VPSS failed!\n", s32Ret);
2369
2370 /* config vo */
2371 SAMPLE_COMM_VO_GetDefConfig(&s_stVoConfig);
2372 s_stVoConfig.enDstDynamicRange = enDynamicRange;
2373 s_stVoConfig.enVoIntfType = VO_INTF_HDMI;
2374 s_stVoConfig.enPicSize = PIC_1080P;
2375
2376 /* start vo */
2377 s32Ret = SAMPLE_COMM_VO_StartVO(&s_stVoConfig);
2378 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, END_3, "Error(%#x),SAMPLE_COMM_VO_StartVO failed!\n", s32Ret);
2379
2380 (HI_VOID)memset_s(&s_stRfcnModel, sizeof(s_stRfcnModel), 0, sizeof(s_stRfcnModel));
2381 (HI_VOID)memset_s(&s_stRfcnNnieParam, sizeof(s_stRfcnNnieParam), 0, sizeof(s_stRfcnNnieParam));
2382 (HI_VOID)memset_s(&s_stRfcnSoftwareParam, sizeof(s_stRfcnSoftwareParam), 0, sizeof(s_stRfcnSoftwareParam));
2383
2384 /* step 2: init Kcf param */
2385 s32Ret = SAMPLE_IVE_KcfInit(&s_stIveKcfInfo);
2386 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, END_4, "Error(%#x),SAMPLE_IVE_KcfInit failed!\n", s32Ret);
2387 /* step 3: init NNIE param */
2388 stNnieCfg.pszPic = NULL;
2389 stNnieCfg.u32MaxInputNum = 1; // max input image num in each batch
2390 stNnieCfg.u32MaxRoiNum = SAMPLE_IVE_KCF_RPN_MAX_ROI_NUM;
2391 stNnieCfg.aenNnieCoreId[SAMPLE_IVE_KCF_IDX_0] = SVP_NNIE_ID_0; // set NNIE core for 0-th Seg
2392 stNnieCfg.aenNnieCoreId[SAMPLE_IVE_KCF_IDX_1] = SVP_NNIE_ID_0; // set NNIE core for 1-th Seg
2393 stNnieCfg.aenNnieCoreId[SAMPLE_IVE_KCF_IDX_2] = SVP_NNIE_ID_0; // set NNIE core for 2-th Seg
2394
2395 s32Ret = SAMPLE_COMM_SVP_NNIE_LoadModel(pcModelName, &s_stRfcnModel);
2396 SAMPLE_SVP_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, END_5, SAMPLE_SVP_ERR_LEVEL_ERROR,
2397 "Error,SAMPLE_COMM_SVP_NNIE_LoadModel failed!\n");
2398
2399 /* apcRpnDataLayerName is used to set RPN data layer name
2400 and search RPN input data,if user has changed network struct, please
2401 make sure the data layer names are correct */
2402 s_stRfcnNnieParam.pstModel = &s_stRfcnModel.stModel;
2403 s_stRfcnSoftwareParam.apcRpnDataLayerName[SAMPLE_IVE_KCF_IDX_0] = "rpn_cls_score";
2404 s_stRfcnSoftwareParam.apcRpnDataLayerName[SAMPLE_IVE_KCF_IDX_1] = "rpn_bbox_pred";
2405 s32Ret = SAMPLE_IVE_Rfcn_ParamInit(&stNnieCfg, &s_stRfcnNnieParam, &s_stRfcnSoftwareParam);
2406 SAMPLE_SVP_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, END_6, SAMPLE_SVP_ERR_LEVEL_ERROR,
2407 "Error,SAMPLE_SVP_NNIE_Rfcn_ParamInit failed!\n");
2408
2409 s_bIveKcfStopSignal = HI_FALSE;
2410
2411 /* step 4: Create work thread */
2412 prctl(PR_SET_NAME, "GetFrame", 0, 0, 0);
2413 pthread_create(&s_IveGetFrmThread, 0, SAMPLE_IVE_GetFrame, NULL);
2414
2415 prctl(PR_SET_NAME, "KcfTracking", 0, 0, 0);
2416 pthread_create(&s_IveTrackThread, 0, SAMPLE_IVE_KcfTracking, NULL);
2417
2418 prctl(PR_SET_NAME, "NNIEDetect", 0, 0, 0);
2419 pthread_create(&s_IveDetectThread, 0, SAMPLE_IVE_Rfcn_Detect, NULL);
2420
2421 s32Ret = SAMPLE_IVE_KCF_Pause();
2422 SAMPLE_SVP_CHECK_EXPR_RET_VOID(s32Ret != HI_SUCCESS, SAMPLE_SVP_ERR_LEVEL_ERROR, "pause failed!\n");
2423
2424 s_bIveKcfStopSignal = HI_TRUE;
2425
2426 pthread_join(s_IveGetFrmThread, NULL);
2427 s_IveGetFrmThread = 0;
2428
2429 pthread_join(s_IveTrackThread, NULL);
2430 s_IveTrackThread = 0;
2431
2432 pthread_join(s_IveDetectThread, NULL);
2433 s_IveDetectThread = 0;
2434
2435 END_6:
2436 SAMPLE_IVE_RfcnDeinit(&s_stRfcnNnieParam, &s_stRfcnSoftwareParam, &s_stRfcnModel);
2437 END_5:
2438 SAMPLE_IVE_KcfDeInit(&s_stIveKcfInfo);
2439 END_4:
2440 SAMPLE_COMM_VO_StopVO(&s_stVoConfig);
2441 END_3:
2442 SAMPLE_COMM_VI_UnBind_VPSS(ViPipe, ViChn, VpssGrp);
2443 END_2:
2444 SAMPLE_COMM_VPSS_Stop(VpssGrp, abChnEnable);
2445 END_1:
2446 SAMPLE_COMM_VI_StopVi(&s_stViConfig);
2447 END_0:
2448 SAMPLE_COMM_SYS_Exit();
2449
2450 return;
2451 }
2452
SAMPLE_IVE_Kcf_HandleSig(void)2453 void SAMPLE_IVE_Kcf_HandleSig(void)
2454 {
2455 s_bIveKcfStopSignal = HI_TRUE;
2456 }
2457