libxcoder 5.8.0
Loading...
Searching...
No Matches
ni_rsrc_list.c
Go to the documentation of this file.
1/*******************************************************************************
2 *
3 * Copyright (C) 2022 NETINT Technologies
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a copy
6 * of this software and associated documentation files (the "Software"), to deal
7 * in the Software without restriction, including without limitation the rights
8 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 * copies of the Software, and to permit persons to whom the Software is
10 * furnished to do so, subject to the following conditions:
11 *
12 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
13 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
14 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
15 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
16 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
17 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
18 * SOFTWARE.
19 *
20 ******************************************************************************/
21
22/*!*****************************************************************************
23 * \file ni_rsrc_list.c
24 *
25 * \brief Application to query and print info about NETINT video processing
26 * devices on system
27 ******************************************************************************/
28
29#if __linux__ || __APPLE__
30#include <unistd.h>
31#include <sys/types.h>
32#elif _WIN32
33#include "ni_getopt.h"
34#endif
35
36#include <stdio.h>
37#include <stdlib.h>
38
39#include "ni_rsrc_api.h"
40#include "ni_util.h"
41
48
49static const char *ni_codec_format_str[] = {"H.264", "H.265", "VP9", "JPEG",
50 "AV1"};
51static const char *ni_dec_name_str[] = {"h264_ni_quadra_dec", "h265_ni_quadra_dec",
52 "vp9_ni_quadra_dec", "jpeg_ni_quadra_dec"};
53static const char *ni_enc_name_str[] = {"h264_ni_quadra_enc", "h265_ni_quadra_enc", "empty",
54 "jpeg_ni_quadra_enc", "av1_ni_quadra_enc"};
55
56
57#define DYN_STR_BUF_CHUNK_SIZE 4096
58typedef struct dyn_str_buf
59{
60 int str_len; // Note: this does not include EOL char
61 int buf_size;
62 char *str_buf; // Pointer to string
63} dyn_str_buf_t;
64
65/*!*****************************************************************************
66 * \brief Accumulate string data in a dynamically sized buffer. This is
67 * useful to separate error messages from json and table output.
68 *
69 * \param[in] *dyn_str_buf pointer to structure holding dyn_str_buf info
70 * \param[in] *fmt printf format specifier
71 * \param[in] ... additional arguments
72 *
73 * \return 0 for success, -1 for error
74 ******************************************************************************/
75int strcat_dyn_buf(dyn_str_buf_t *dyn_str_buf, const char *fmt, ...)
76{
77 int avail_buf;
78 int formatted_len;
79 int add_buf_size = 0;
80 char *tmp_char_ptr = NULL;
81
82 if (!dyn_str_buf)
83 {
84 (void)fprintf(stderr, "ERROR: invalid param *dyn_str_buf\n");
85 return -1;
86 }
87
88 if (!fmt)
89 {
90 return 0;
91 }
92
93 va_list vl, tmp_vl;
94 va_start(vl, fmt);
95 va_copy(tmp_vl, vl);
96
97 // determine length of string to add
98 formatted_len = vsnprintf(NULL, 0, fmt, tmp_vl);
99 va_end(tmp_vl);
100
101 // check if str_buf needs to be expanded in increments of chunk size
102 avail_buf = dyn_str_buf->buf_size - dyn_str_buf->str_len;
103 add_buf_size = (formatted_len + 1) > avail_buf ?
104 ((formatted_len + 1 - avail_buf + DYN_STR_BUF_CHUNK_SIZE - 1) /
105 DYN_STR_BUF_CHUNK_SIZE) *
106 DYN_STR_BUF_CHUNK_SIZE :
107 0;
108
109 // realloc() to expand str_buf if necessary
110 if (add_buf_size)
111 {
112 tmp_char_ptr = (char *)realloc(dyn_str_buf->str_buf,
113 sizeof(char) * dyn_str_buf->buf_size +
114 add_buf_size);
115 if (!tmp_char_ptr)
116 {
117 (void)fprintf(stderr, "ERROR: strcat_dyn_buf() failed realloc()\n");
118 va_end(vl);
119 return -1;
120 }
121 dyn_str_buf->str_buf = tmp_char_ptr;
122 dyn_str_buf->buf_size += add_buf_size;
123 avail_buf = dyn_str_buf->buf_size - dyn_str_buf->str_len;
124 }
125
126 // concatenate string to buffer
127 ni_vsprintf(dyn_str_buf->str_buf + dyn_str_buf->str_len, avail_buf, fmt, vl);
128 dyn_str_buf->str_len += formatted_len;
129
130 va_end(vl);
131 return 0;
132}
133
134void clear_dyn_str_buf(dyn_str_buf_t *dyn_str_buf)
135{
136 free(dyn_str_buf->str_buf);
137 memset(dyn_str_buf, 0, sizeof(dyn_str_buf_t));
138}
139
140
141
142static void print_text(ni_device_t *p_device)
143{
144 if (!p_device)
145 {
146 ni_log(NI_LOG_INFO, "WARNING: NULL parameter passed in!\n");
147 return;
148 }
149
150 dyn_str_buf_t output_buf = {0};
151 ni_device_info_t *p_dev_info = NULL;
152 for (int xcoder_index_1 = 0;
153 xcoder_index_1 < p_device->xcoder_cnt[NI_DEVICE_TYPE_ENCODER];
154 xcoder_index_1++)
155 {
156 p_dev_info = &p_device->xcoders[NI_DEVICE_TYPE_ENCODER][xcoder_index_1];
157
158 strcat_dyn_buf(&output_buf, "Device #%d:\n", xcoder_index_1);
159 strcat_dyn_buf(&output_buf, " Serial number: %.*s\n",
160 (int)sizeof(p_dev_info->serial_number),
161 p_dev_info->serial_number);
162 strcat_dyn_buf(&output_buf, " Model number: %.*s\n",
163 (int)sizeof(p_dev_info->model_number),
164 p_dev_info->model_number);
165 strcat_dyn_buf(&output_buf, " Last ran firmware loader version: %.8s\n",
166 p_dev_info->fl_ver_last_ran);
167 strcat_dyn_buf(&output_buf, " NOR flash firmware loader version: %.8s\n",
168 p_dev_info->fl_ver_nor_flash);
169 strcat_dyn_buf(&output_buf, " Current firmware revision: %.8s\n",
170 p_dev_info->fw_rev);
171 strcat_dyn_buf(&output_buf, " NOR flash firmware revision: %.8s\n",
172 p_dev_info->fw_rev_nor_flash);
173 strcat_dyn_buf(&output_buf, " F/W & S/W compatibility: %s\n",
174 p_dev_info->fw_ver_compat_warning ?
175 "no, possible missing features" : "yes");
176 strcat_dyn_buf(&output_buf, " F/W branch: %s\n",
177 p_dev_info->fw_branch_name);
178 strcat_dyn_buf(&output_buf, " F/W commit time: %s\n",
179 p_dev_info->fw_commit_time);
180 strcat_dyn_buf(&output_buf, " F/W commit hash: %s\n",
181 p_dev_info->fw_commit_hash);
182 strcat_dyn_buf(&output_buf, " F/W build time: %s\n",
183 p_dev_info->fw_build_time);
184 strcat_dyn_buf(&output_buf, " F/W build id: %s\n",p_dev_info->fw_build_id);
185 strcat_dyn_buf(&output_buf, " F/W flavour: %c\n",
186 p_dev_info->fw_flavour ? p_dev_info->fw_flavour : '-');
187 strcat_dyn_buf(&output_buf, " DeviceID: %s\n", p_dev_info->dev_name);
188 strcat_dyn_buf(&output_buf, " PixelFormats: yuv420p, yuv420p10le, nv12, p010le"
189 ", ni_quadra\n");
190
191 for (size_t dev_type = NI_DEVICE_TYPE_DECODER;
192 dev_type != NI_DEVICE_TYPE_XCODER_MAX; dev_type++)
193 {
194 for (int xcoder_index_2 = 0;
195 xcoder_index_2 < p_device->xcoder_cnt[NI_DEVICE_TYPE_ENCODER];
196 xcoder_index_2++)
197 {
198 if (strcmp(p_dev_info->dev_name,
199 p_device->xcoders[dev_type][xcoder_index_2].dev_name)
200 == 0 && p_dev_info->module_id >= 0)
201 {
202 const ni_device_info_t *p_device_info =
203 &(p_device->xcoders[dev_type][xcoder_index_2]);
204 int i;
205
206 if (!p_device_info)
207 {
208 ni_log(NI_LOG_ERROR, "ERROR: Cannot print device info!\n");
209 } else
210 {
211 strcat_dyn_buf(&output_buf, " %s #%d\n",
212 GET_XCODER_DEVICE_TYPE_STR(p_device_info->device_type),
213 p_device_info->module_id);
214 strcat_dyn_buf(&output_buf, " H/W ID: %d\n", p_device_info->hw_id);
215 strcat_dyn_buf(&output_buf, " MaxNumInstances: %d\n",
216 p_device_info->max_instance_cnt);
217
218 if (NI_DEVICE_TYPE_SCALER == p_device_info->device_type)
219 {
220 strcat_dyn_buf(&output_buf, " Capabilities:\n");
221 strcat_dyn_buf(&output_buf,
222 " Operations: Crop (ni_quadra_crop), Scale (ni_quadra_scale), Pad "
223 "(ni_quadra_pad), Overlay (ni_quadra_overlay)\n"
224 " Drawbox (ni_quadra_drawbox), Rotate (ni_quadra_rotate), XStack (ni_quadra_xstack)\n");
225 } else if (NI_DEVICE_TYPE_AI == p_device_info->device_type)
226 {
227 strcat_dyn_buf(&output_buf, " Capabilities:\n");
228 strcat_dyn_buf(&output_buf,
229 " Operations: ROI (ni_quadra_roi), Background Replace (ni_quadra_bg)\n");
230 } else if (NI_DEVICE_TYPE_DECODER == p_device_info->device_type ||
231 NI_DEVICE_TYPE_ENCODER == p_device_info->device_type)
232 {
233 strcat_dyn_buf(&output_buf, " Max4KFps: %d\n", p_device_info->max_fps_4k);
234 for (i = 0; i < EN_CODEC_MAX; i++)
235 {
236 if (EN_INVALID != p_device_info->dev_cap[i].supports_codec)
237 {
238 strcat_dyn_buf(&output_buf, " %s ",
239 ni_codec_format_str[p_device_info->dev_cap[i]
240 .supports_codec]);
241 strcat_dyn_buf(&output_buf, "(%s) Capabilities:\n",
242 NI_DEVICE_TYPE_DECODER ==
243 p_device_info->device_type ?
244 ni_dec_name_str[p_device_info->dev_cap[i]
245 .supports_codec] :
246 ni_enc_name_str[p_device_info->dev_cap[i]
247 .supports_codec]);
248 strcat_dyn_buf(&output_buf, " MaxResolution: %dx%d\n",
249 p_device_info->dev_cap[i].max_res_width,
250 p_device_info->dev_cap[i].max_res_height);
251 strcat_dyn_buf(&output_buf, " MinResolution: %dx%d\n",
252 p_device_info->dev_cap[i].min_res_width,
253 p_device_info->dev_cap[i].min_res_height);
254
255 // no profile for JPEG encode, or level for JPEG
256 if (! (NI_DEVICE_TYPE_ENCODER == p_device_info->device_type &&
257 EN_JPEG == p_device_info->dev_cap[i].supports_codec))
258 {
259 strcat_dyn_buf(&output_buf, " Profiles: %s\n",
260 p_device_info->dev_cap[i].profiles_supported);
261 }
262 if (EN_JPEG != p_device_info->dev_cap[i].supports_codec)
263 {
264 strcat_dyn_buf(&output_buf, " Level: %s\n",
265 p_device_info->dev_cap[i].level);
266 }
267 }
268 }
269 }
270 }
271 }
272 }
273 }
274 }
275 if (output_buf.str_buf)
276 printf("%s", output_buf.str_buf);
277 clear_dyn_str_buf(&output_buf);
278}
279
280static void print_full_text(ni_device_t *p_device)
281{
282 if (!p_device)
283 {
284 ni_log(NI_LOG_INFO, "WARNING: NULL parameter passed in!\n");
285 return;
286 }
287
288 dyn_str_buf_t output_buf = {0};
289 ni_device_info_t *p_dev_info = NULL;
290 int ddr_module_id = -1;
291 for (int xcoder_index_1 = 0;
292 xcoder_index_1 < p_device->xcoder_cnt[NI_DEVICE_TYPE_ENCODER];
293 xcoder_index_1++)
294 {
295 p_dev_info = &p_device->xcoders[NI_DEVICE_TYPE_ENCODER][xcoder_index_1];
296 strcat_dyn_buf(&output_buf, "Device #%d:\n", xcoder_index_1);
297 strcat_dyn_buf(&output_buf, " Serial number: %.*s\n",
298 (int)sizeof(p_dev_info->serial_number),
299 p_dev_info->serial_number);
300 strcat_dyn_buf(&output_buf, " Model number: %.*s\n",
301 (int)sizeof(p_dev_info->model_number),
302 p_dev_info->model_number);
303 strcat_dyn_buf(&output_buf, " Last ran firmware loader version: %.8s\n",
304 p_dev_info->fl_ver_last_ran);
305 strcat_dyn_buf(&output_buf, " NOR flash firmware loader version: %.8s\n",
306 p_dev_info->fl_ver_nor_flash);
307 strcat_dyn_buf(&output_buf, " Current firmware revision: %.8s\n",
308 p_dev_info->fw_rev);
309 strcat_dyn_buf(&output_buf, " NOR flash firmware revision: %.8s\n",
310 p_dev_info->fw_rev_nor_flash);
311 strcat_dyn_buf(&output_buf, " F/W & S/W compatibility: %s\n",
312 p_dev_info->fw_ver_compat_warning ?
313 "no, possible missing features" : "yes");
314 strcat_dyn_buf(&output_buf, " F/W branch: %s\n",
315 p_dev_info->fw_branch_name);
316 strcat_dyn_buf(&output_buf, " F/W commit time: %s\n",
317 p_dev_info->fw_commit_time);
318 strcat_dyn_buf(&output_buf, " F/W commit hash: %s\n",
319 p_dev_info->fw_commit_hash);
320 strcat_dyn_buf(&output_buf, " F/W build time: %s\n",
321 p_dev_info->fw_build_time);
322 strcat_dyn_buf(&output_buf, " F/W build id: %s\n",p_dev_info->fw_build_id);
323 strcat_dyn_buf(&output_buf, " F/W flavour: %c\n",
324 p_dev_info->fw_flavour ? p_dev_info->fw_flavour : '-');
325 strcat_dyn_buf(&output_buf, " DeviceID: %s\n", p_dev_info->dev_name);
326
327 for (size_t dev_type = NI_DEVICE_TYPE_DECODER;
328 dev_type != NI_DEVICE_TYPE_XCODER_MAX; dev_type++)
329 {
330 for (int xcoder_index_2 = 0;
331 xcoder_index_2 < p_device->xcoder_cnt[NI_DEVICE_TYPE_ENCODER];
332 xcoder_index_2++)
333 {
334 if (strcmp(p_dev_info->dev_name,
335 p_device->xcoders[dev_type][xcoder_index_2].dev_name)
336 == 0 && p_dev_info->module_id >= 0)
337 {
338 const ni_device_info_t *p_device_info =
339 &(p_device->xcoders[dev_type][xcoder_index_2]);
340 int i;
341
342 if (!p_device_info)
343 {
344 ni_log(NI_LOG_ERROR, "ERROR: Cannot print device info!\n");
345 } else
346 {
347 ddr_module_id = p_device_info->module_id;
348 strcat_dyn_buf(&output_buf, " %s #%d\n",
349 GET_XCODER_DEVICE_TYPE_STR(p_device_info->device_type),
350 p_device_info->module_id);
351 strcat_dyn_buf(&output_buf, " H/W ID: %d\n", p_device_info->hw_id);
352 strcat_dyn_buf(&output_buf, " MaxNumInstances: %d\n",
353 p_device_info->max_instance_cnt);
354
355 if (NI_DEVICE_TYPE_SCALER == p_device_info->device_type)
356 {
357 strcat_dyn_buf(&output_buf, " Capabilities:\n");
358 strcat_dyn_buf(&output_buf,
359 " Operations: Crop (ni_quadra_crop), Scale (ni_quadra_scale), Pad "
360 "(ni_quadra_pad), Overlay (ni_quadra_overlay)\n"
361 " Drawbox (ni_quadra_drawbox), Rotate (ni_quadra_rotate), XStack (ni_quadra_xstack)\n"
362 " Delogo (ni_quadra_delogo), Merge (ni_quadra_merge), Flip (ni_quadra_flip)\n"
363 " Drawtext (ni_quadra_drawtext)\n");
364 } else if (NI_DEVICE_TYPE_AI == p_device_info->device_type)
365 {
366 strcat_dyn_buf(&output_buf, " Capabilities:\n");
367 strcat_dyn_buf(&output_buf, " Cores: 2\n");
368 strcat_dyn_buf(&output_buf, " Computing Power: int8 18 tops\n");
369 strcat_dyn_buf(&output_buf,
370 " Operations: ROI (ni_quadra_roi), Background Replace (ni_quadra_bg), Ai Pre-processing (ni_quadra_ai_pre)\n"
371 " Background Remove (ni_quadra_bgr), Hvsplus (ni_quadra_hvsplus)\n");
372 } else if (NI_DEVICE_TYPE_DECODER == p_device_info->device_type ||
373 NI_DEVICE_TYPE_ENCODER == p_device_info->device_type)
374 {
375 strcat_dyn_buf(&output_buf, " Max4KFps: %d\n", p_device_info->max_fps_4k);
376 for (i = 0; i < EN_CODEC_MAX; i++)
377 {
378 if (EN_INVALID != p_device_info->dev_cap[i].supports_codec)
379 {
380 strcat_dyn_buf(&output_buf, " %s ",
381 ni_codec_format_str[p_device_info->dev_cap[i]
382 .supports_codec]);
383 strcat_dyn_buf(&output_buf, "(%s) Capabilities:\n",
384 NI_DEVICE_TYPE_DECODER ==
385 p_device_info->device_type ?
386 ni_dec_name_str[p_device_info->dev_cap[i]
387 .supports_codec] :
388 ni_enc_name_str[p_device_info->dev_cap[i]
389 .supports_codec]);
390 if (NI_DEVICE_TYPE_DECODER == p_device_info->device_type)
391 {
392 switch (p_device_info->dev_cap[i].supports_codec)
393 {
394 case EN_H264:
395 case EN_H265:
396 case EN_VP9:
397 strcat_dyn_buf(&output_buf, " PixelFormats: "
398 "yuv420p, yuv420p10le, nv12, p010le, ni_quad\n");
399 break;
400 case EN_JPEG:
401 strcat_dyn_buf(&output_buf, " PixelFormats: "
402 "yuvj420p, ni_quad\n");
403 break;
404 case EN_AV1:
405 default:
406 break;
407 }
408 }
409 else
410 {
411 switch (p_device_info->dev_cap[i].supports_codec)
412 {
413 case EN_H264:
414 case EN_H265:
415 case EN_AV1:
416 strcat_dyn_buf(&output_buf, " PixelFormats: "
417 "yuv420p, yuvj420p, yuv420p10le, nv12, p010le, ni_quad\n");
418 break;
419 case EN_JPEG:
420 strcat_dyn_buf(&output_buf, " PixelFormats: "
421 "yuvj420p, ni_quad\n");
422 break;
423 case EN_VP9:
424 default:
425 break;
426 }
427 }
428 strcat_dyn_buf(&output_buf, " MaxResolution: %dx%d\n",
429 p_device_info->dev_cap[i].max_res_width,
430 p_device_info->dev_cap[i].max_res_height);
431 strcat_dyn_buf(&output_buf, " MinResolution: %dx%d\n",
432 p_device_info->dev_cap[i].min_res_width,
433 p_device_info->dev_cap[i].min_res_height);
434
435 // no profile for JPEG encode, or level for JPEG
436 if (! (NI_DEVICE_TYPE_ENCODER == p_device_info->device_type &&
437 EN_JPEG == p_device_info->dev_cap[i].supports_codec))
438 {
439 strcat_dyn_buf(&output_buf, " Profiles: %s\n",
440 p_device_info->dev_cap[i].profiles_supported);
441 }
442 if (EN_JPEG != p_device_info->dev_cap[i].supports_codec)
443 {
444 strcat_dyn_buf(&output_buf, " Level: %s\n",
445 p_device_info->dev_cap[i].level);
446 }
447 }
448 }
449 }
450 }
451 }
452 }
453 }
454 if (ddr_module_id >= 0)
455 {
456 strcat_dyn_buf(&output_buf, " Memory #%d\n", ddr_module_id);
457 strcat_dyn_buf(&output_buf, " Type: DDR4\n");
458 strcat_dyn_buf(&output_buf, " Size: 8GB\n");
459 ddr_module_id = -1;
460 }
461 }
462 if (output_buf.str_buf)
463 printf("%s", output_buf.str_buf);
464 clear_dyn_str_buf(&output_buf);
465}
466
467static void print_json(ni_device_t *p_device)
468{
469 if (!p_device)
470 {
471 ni_log(NI_LOG_INFO, "WARNING: NULL parameter passed in!\n");
472 return;
473 }
474
475 dyn_str_buf_t output_buf = {0};
476 ni_device_info_t *p_dev_info = NULL;
477 int ddr_module_id = -1;
478 strcat_dyn_buf(&output_buf,"{\n");
479 for (int xcoder_index_1 = 0;
480 xcoder_index_1 < p_device->xcoder_cnt[NI_DEVICE_TYPE_ENCODER];
481 xcoder_index_1++)
482 {
483 p_dev_info = &p_device->xcoders[NI_DEVICE_TYPE_ENCODER][xcoder_index_1];
484 strcat_dyn_buf(&output_buf, " \"Device #%d\": [\n", xcoder_index_1);
485 strcat_dyn_buf(&output_buf, "\t{\n"
486 "\t\t\"Serial number\": \"%.*s\",\n"
487 "\t\t\"Model number:\": \"%.*s\",\n"
488 "\t\t\"Last ran firmware loader version\": \"%.8s\",\n"
489 "\t\t\"NOR flash firmware loader version\": \"%.8s\",\n"
490 "\t\t\"Current firmware revision\": \"%.8s\",\n"
491 "\t\t\"NOR flash firmware revision\": \"%.8s\",\n"
492 "\t\t\"F/W & S/W compatibility\": \"%s\",\n"
493 "\t\t\"F/W branch\": \"%s\",\n"
494 "\t\t\"F/W commit time\": \"%s\",\n"
495 "\t\t\"F/W commit hash\": \"%s\",\n"
496 "\t\t\"F/W build time\": \"%s\",\n"
497 "\t\t\"F/W build id\": \"%s\",\n"
498 "\t\t\"F/W flavour\": \"%c\",\n"
499 "\t\t\"DeviceID\": \"%s\",\n"
500 , (int)sizeof(p_dev_info->serial_number), p_dev_info->serial_number,
501 (int)sizeof(p_dev_info->model_number), p_dev_info->model_number,
502 p_dev_info->fl_ver_last_ran, p_dev_info->fl_ver_nor_flash,
503 p_dev_info->fw_rev, p_dev_info->fw_rev_nor_flash,
504 p_dev_info->fw_ver_compat_warning ? "no, possible missing features" : "yes",
505 p_dev_info->fw_branch_name, p_dev_info->fw_commit_time,
506 p_dev_info->fw_commit_hash, p_dev_info->fw_build_time,
507 p_dev_info->fw_build_id,
508 p_dev_info->fw_flavour ? p_dev_info->fw_flavour : '-',
509 p_dev_info->dev_name);
510 for (size_t dev_type = NI_DEVICE_TYPE_DECODER;
511 dev_type != NI_DEVICE_TYPE_XCODER_MAX; dev_type++)
512 {
513 for (int xcoder_index_2 = 0;
514 xcoder_index_2 < p_device->xcoder_cnt[NI_DEVICE_TYPE_ENCODER];
515 xcoder_index_2++)
516 {
517 if (strcmp(p_dev_info->dev_name,
518 p_device->xcoders[dev_type][xcoder_index_2].dev_name)
519 == 0 && p_dev_info->module_id >= 0)
520 {
521 const ni_device_info_t *p_device_info =
522 &(p_device->xcoders[dev_type][xcoder_index_2]);
523 int i;
524
525 if (!p_device_info)
526 {
527 ni_log(NI_LOG_ERROR, "ERROR: Cannot print device info!\n");
528 } else
529 {
530 ddr_module_id = p_device_info->module_id;
531 strcat_dyn_buf(&output_buf, "\t\t\"%s #%d\": [\n",
532 GET_XCODER_DEVICE_TYPE_STR(p_device_info->device_type),
533 p_device_info->module_id);
534 strcat_dyn_buf(&output_buf, "\t\t\t{\n");
535 strcat_dyn_buf(&output_buf, "\t\t\t\t\"H/W ID\": %d,\n"
536 "\t\t\t\t\"MaxNumInstances\": %d,\n"
537 , p_device_info->hw_id,
538 p_device_info->max_instance_cnt);
539 if (NI_DEVICE_TYPE_SCALER == p_device_info->device_type)
540 {
541 strcat_dyn_buf(&output_buf, "\t\t\t\t\"Capabilities\": [\n");
542 strcat_dyn_buf(&output_buf, "\t\t\t\t\t{\n");
543 strcat_dyn_buf(&output_buf, "\t\t\t\t\t\t\"Operations\": "
544 "\"Crop (ni_quadra_crop), Scale (ni_quadra_scale), Pad "
545 "(ni_quadra_pad), Overlay (ni_quadra_overlay), "
546 "Drawbox (ni_quadra_drawbox), Rotate (ni_quadra_rotate), "
547 "XStack (ni_quadra_xstack), Delogo (ni_quadra_delogo), "
548 "Merge (ni_quadra_merge), Flip (ni_quadra_flip), "
549 "Drawtext (ni_quadra_drawtext)\"\n");
550 strcat_dyn_buf(&output_buf, "\t\t\t\t\t}\n\t\t\t\t]\n");
551 strcat_dyn_buf(&output_buf, "\t\t\t}\n\t\t],\n");
552 } else if (NI_DEVICE_TYPE_AI == p_device_info->device_type)
553 {
554 strcat_dyn_buf(&output_buf, "\t\t\t\t\"Capabilities\": [\n");
555 strcat_dyn_buf(&output_buf, "\t\t\t\t\t{\n");
556 strcat_dyn_buf(&output_buf, "\t\t\t\t\t\t\"Cores\": 2,\n"
557 "\t\t\t\t\t\t\"Computing Power\": \"int8 18 tops\",\n"
558 "\t\t\t\t\t\t\"Operations\": "
559 "\"ROI (ni_quadra_roi), Background Replace (ni_quadra_bg), "
560 "Ai Pre-processing (ni_quadra_ai_pre), "
561 "Background Remove (ni_quadra_bgr), Hvsplus (ni_quadra_hvsplus)\"\n");
562 strcat_dyn_buf(&output_buf, "\t\t\t\t\t}\n\t\t\t\t]\n");
563 strcat_dyn_buf(&output_buf, "\t\t\t}\n\t\t],\n");
564 } else if (NI_DEVICE_TYPE_DECODER == p_device_info->device_type ||
565 NI_DEVICE_TYPE_ENCODER == p_device_info->device_type)
566 {
567 strcat_dyn_buf(&output_buf, "\t\t\t\t\"Max4KFps\": %d,\n",
568 p_device_info->max_fps_4k);
569 for (i = 0; i < EN_CODEC_MAX; i++)
570 {
571 if (EN_INVALID != p_device_info->dev_cap[i].supports_codec)
572 {
573 strcat_dyn_buf(&output_buf, "\t\t\t\t\"%s (%s) Capabilities\": [\n",
574 ni_codec_format_str[p_device_info->dev_cap[i].supports_codec],
575 NI_DEVICE_TYPE_DECODER == p_device_info->device_type ?
576 ni_dec_name_str[p_device_info->dev_cap[i].supports_codec] :
577 ni_enc_name_str[p_device_info->dev_cap[i].supports_codec]);
578 strcat_dyn_buf(&output_buf, "\t\t\t\t\t{\n");
579 if (NI_DEVICE_TYPE_DECODER == p_device_info->device_type)
580 {
581 switch (p_device_info->dev_cap[i].supports_codec)
582 {
583 case EN_H264:
584 case EN_H265:
585 case EN_VP9:
586 strcat_dyn_buf(&output_buf, "\t\t\t\t\t\t\"PixelFormats\": "
587 "\"yuv420p, yuv420p10le, nv12, p010le, ni_quad\",\n");
588 break;
589 case EN_JPEG:
590 strcat_dyn_buf(&output_buf, "\t\t\t\t\t\t\"PixelFormats\": "
591 "\"yuvj420p, ni_quad\",\n");
592 break;
593 case EN_AV1:
594 default:
595 break;
596 }
597 }
598 else
599 {
600 switch (p_device_info->dev_cap[i].supports_codec)
601 {
602 case EN_H264:
603 case EN_H265:
604 case EN_AV1:
605 strcat_dyn_buf(&output_buf, "\t\t\t\t\t\t\"PixelFormats\": "
606 "\"yuv420p, yuvj420p, yuv420p10le, nv12, p010le, ni_quad\",\n");
607 break;
608 case EN_JPEG:
609 strcat_dyn_buf(&output_buf, "\t\t\t\t\t\t\"PixelFormats\": "
610 "\"yuvj420p, ni_quad\",\n");
611 break;
612 case EN_VP9:
613 default:
614 break;
615 }
616 }
617 strcat_dyn_buf(&output_buf, "\t\t\t\t\t\t\"MaxResolution\": \"%dx%d\",\n"
618 "\t\t\t\t\t\t\"MinResolution\": \"%dx%d\""
619 ,p_device_info->dev_cap[i].max_res_width,
620 p_device_info->dev_cap[i].max_res_height,
621 p_device_info->dev_cap[i].min_res_width,
622 p_device_info->dev_cap[i].min_res_height);
623 // no profile for JPEG encode, or level for JPEG
624 if (! (NI_DEVICE_TYPE_ENCODER == p_device_info->device_type &&
625 EN_JPEG == p_device_info->dev_cap[i].supports_codec))
626 {
627 strcat_dyn_buf(&output_buf, ",\n\t\t\t\t\t\t\"Profiles\": \"%s\"",
628 p_device_info->dev_cap[i].profiles_supported);
629 }
630 if (EN_JPEG != p_device_info->dev_cap[i].supports_codec)
631 {
632 strcat_dyn_buf(&output_buf, ",\n\t\t\t\t\t\t\"Level\": \"%s\"",
633 p_device_info->dev_cap[i].level);
634 }
635 if ((NI_DEVICE_TYPE_DECODER == p_device_info->device_type &&
636 EN_VP9 == p_device_info->dev_cap[i].supports_codec) ||
637 (NI_DEVICE_TYPE_ENCODER == p_device_info->device_type &&
638 EN_AV1 == p_device_info->dev_cap[i].supports_codec))
639 {
640 strcat_dyn_buf(&output_buf, "\n\t\t\t\t\t}\n\t\t\t\t]\n");
641 }
642 else
643 {
644 strcat_dyn_buf(&output_buf, "\n\t\t\t\t\t}\n\t\t\t\t],\n");
645 }
646 }
647 }
648 strcat_dyn_buf(&output_buf, "\t\t\t}\n\t\t],\n");
649 }
650 }
651 }
652 }
653 }
654 if (ddr_module_id >= 0)
655 {
656 strcat_dyn_buf(&output_buf, "\t\t\"Memory #%d\": [\n", ddr_module_id);
657 strcat_dyn_buf(&output_buf, "\t\t\t{\n");
658 strcat_dyn_buf(&output_buf, "\t\t\t\t\"Type\": \"DDR4\",\n"
659 "\t\t\t\t\"Size\": \"8GB\"\n");
660 strcat_dyn_buf(&output_buf, "\t\t\t}\n\t\t]\n");
661 ddr_module_id = -1;
662 }
663 if (xcoder_index_1 == p_device->xcoder_cnt[NI_DEVICE_TYPE_ENCODER] - 1)
664 strcat_dyn_buf(&output_buf, "\t}\n ]\n");
665 else
666 strcat_dyn_buf(&output_buf, "\t}\n ],\n");
667 }
668 strcat_dyn_buf(&output_buf,"}\n");
669 if (output_buf.str_buf)
670 printf("%s", output_buf.str_buf);
671 clear_dyn_str_buf(&output_buf);
672}
673
674
675int32_t main(int argc, char *argv[])
676{
677 int opt;
678 bool list_uninitialized = false;
679 ni_log_level_t log_level = NI_LOG_INFO;
680 int printFormat = FMT_TEXT;
681
682 // arg handling
683 while ((opt = getopt(argc, argv, "ahvlo:")) != -1) // NOLINT(concurrency-mt-unsafe) - single-threaded CLI tool
684 {
685 switch (opt)
686 {
687 case 'a':
688 list_uninitialized = true;
689 break;
690 case 'h':
691 // help message
692 printf("-------- ni_rsrc_list v%s --------\n"
693 "Display information for NETINT hardware.\n"
694 "\n"
695 "-a Print includes info for uninitialized cards.\n"
696 "-h Display this help and exit.\n"
697 "-v Print version info.\n"
698 "-o Output format. [text, full, json]\n"
699 " Default: text\n"
700 "-l Set loglevel of libxcoder API.\n"
701 " [none, fatal, error, info, debug, trace]\n"
702 " Default: info\n",
703 NI_XCODER_REVISION);
704 return 0;
705 case 'v':
706 printf("Release ver: %s\n"
707 "API ver: %s\n"
708 "Date: %s\n"
709 "ID: %s\n",
710 NI_XCODER_REVISION, LIBXCODER_API_VERSION,
711 NI_SW_RELEASE_TIME, NI_SW_RELEASE_ID);
712 return 0;
713 case 'l':
714 log_level = arg_to_ni_log_level(optarg);
715 if (log_level != NI_LOG_INVALID)
716 {
717 ni_log_set_level(log_level);
718 } else {
719 (void)fprintf(stderr, "FATAL: invalid log level selected: %s\n",
720 optarg);
721 exit(1); // NOLINT(concurrency-mt-unsafe) - single-threaded CLI tool
722 }
723 break;
724 case 'o':
725 // Output print format
726 if (!strcmp(optarg, "text"))
727 {
728 printFormat = FMT_TEXT;
729 }
730 else if (!strcmp(optarg, "full"))
731 {
732 printFormat = FMT_FULL_TEXT;
733 }
734 else if (!strcmp(optarg, "json"))
735 {
736 printFormat = FMT_JSON;
737 }
738 else
739 {
740 (void)fprintf(stderr, "Error: unknown selection for outputFormat: %s\n", optarg);
741 return 1;
742 }
743 break;
744 default:
745 (void)fprintf(stderr, "FATAL: invalid arg '%c'\n", opt);
746 return 1;
747 }
748 }
749
750 ni_log_set_level(log_level);
751 ni_device_t *device = NULL;
752 device = (ni_device_t *)malloc(sizeof(ni_device_t));
753 if (!device)
754 {
755 char errmsg[NI_ERRNO_LEN] = {0};
756 ni_strerror(errmsg, NI_ERRNO_LEN, NI_ERRNO);
757 ni_log(NI_LOG_ERROR, "ERROR %s() failed to malloc memory: %s\n",
758 __func__, errmsg);
759 return 1;
760 }
761 memset(device, 0, sizeof(ni_device_t));
762
763 if (NI_RETCODE_SUCCESS != ni_rsrc_list_all_devices2(device, list_uninitialized))
764 {
765 free(device);
766 return 1;
767 }
768
769 switch(printFormat)
770 {
771 case FMT_TEXT:
772 print_text(device);
773 break;
774 case FMT_FULL_TEXT:
775 print_full_text(device);
776 break;
777 case FMT_JSON:
778 print_json(device);
779 break;
780 default:
781 break;
782 }
783 free(device);
784 return 0;
785}
main
int main()
Definition client.cpp:51
NI_XCODER_REVISION
#define NI_XCODER_REVISION
Definition ni_defs.h:98
LIBXCODER_API_VERSION
#define LIBXCODER_API_VERSION
Definition ni_defs.h:115
NI_DEVICE_TYPE_SCALER
@ NI_DEVICE_TYPE_SCALER
Definition ni_defs.h:362
NI_DEVICE_TYPE_AI
@ NI_DEVICE_TYPE_AI
Definition ni_defs.h:363
NI_DEVICE_TYPE_DECODER
@ NI_DEVICE_TYPE_DECODER
Definition ni_defs.h:360
NI_DEVICE_TYPE_ENCODER
@ NI_DEVICE_TYPE_ENCODER
Definition ni_defs.h:361
NI_DEVICE_TYPE_XCODER_MAX
@ NI_DEVICE_TYPE_XCODER_MAX
Definition ni_defs.h:364
NI_ERRNO
#define NI_ERRNO
Definition ni_defs.h:229
GET_XCODER_DEVICE_TYPE_STR
#define GET_XCODER_DEVICE_TYPE_STR(t)
Definition ni_defs.h:438
NI_RETCODE_SUCCESS
@ NI_RETCODE_SUCCESS
Definition ni_defs.h:448
getopt
int getopt(int argc, char *argv[], const char *optstring)
Definition ni_getopt.c:38
optarg
char * optarg
Definition ni_getopt.c:33
ni_getopt.h
Implementation of getopt() and getopt_long() for Windows environment.
arg_to_ni_log_level
ni_log_level_t arg_to_ni_log_level(const char *arg_str)
Convert terminal arg string to ni_log_level_t.
Definition ni_log.c:262
ni_log_set_level
void ni_log_set_level(ni_log_level_t level)
Set ni_log_level.
Definition ni_log.c:202
ni_log
void ni_log(ni_log_level_t level, const char *fmt,...)
print log message using ni_log_callback
Definition ni_log.c:183
NI_ERRNO_LEN
#define NI_ERRNO_LEN
Definition ni_log.h:51
ni_log_level_t
ni_log_level_t
Definition ni_log.h:58
NI_LOG_ERROR
@ NI_LOG_ERROR
Definition ni_log.h:62
NI_LOG_INFO
@ NI_LOG_INFO
Definition ni_log.h:63
NI_LOG_INVALID
@ NI_LOG_INVALID
Definition ni_log.h:59
NI_SW_RELEASE_ID
#define NI_SW_RELEASE_ID
Definition ni_release_info.h:29
NI_SW_RELEASE_TIME
#define NI_SW_RELEASE_TIME
Definition ni_release_info.h:28
ni_rsrc_list_all_devices2
ni_retcode_t ni_rsrc_list_all_devices2(ni_device_t *p_device, bool list_uninitialized)
Grabs information for every initialized and uninitialized device.
Definition ni_rsrc_api.cpp:1523
ni_rsrc_api.h
Public definitions for managing NETINT video processing devices.
EN_JPEG
@ EN_JPEG
Definition ni_rsrc_api.h:53
EN_INVALID
@ EN_INVALID
Definition ni_rsrc_api.h:49
EN_AV1
@ EN_AV1
Definition ni_rsrc_api.h:54
EN_H264
@ EN_H264
Definition ni_rsrc_api.h:50
EN_H265
@ EN_H265
Definition ni_rsrc_api.h:51
EN_CODEC_MAX
@ EN_CODEC_MAX
Definition ni_rsrc_api.h:55
EN_VP9
@ EN_VP9
Definition ni_rsrc_api.h:52
DYN_STR_BUF_CHUNK_SIZE
#define DYN_STR_BUF_CHUNK_SIZE
Definition ni_rsrc_list.c:57
dyn_str_buf_t
struct dyn_str_buf dyn_str_buf_t
strcat_dyn_buf
int strcat_dyn_buf(dyn_str_buf_t *dyn_str_buf, const char *fmt,...)
Accumulate string data in a dynamically sized buffer. This is useful to separate error messages from ...
Definition ni_rsrc_list.c:75
outFormat
outFormat
Definition ni_rsrc_list.c:43
FMT_JSON
@ FMT_JSON
Definition ni_rsrc_list.c:46
FMT_FULL_TEXT
@ FMT_FULL_TEXT
Definition ni_rsrc_list.c:45
FMT_TEXT
@ FMT_TEXT
Definition ni_rsrc_list.c:44
clear_dyn_str_buf
void clear_dyn_str_buf(dyn_str_buf_t *dyn_str_buf)
Definition ni_rsrc_list.c:134
ni_strerror
ni_retcode_t ni_strerror(char *dest, size_t dmax, int errnum)
Definition ni_util.c:663
ni_vsprintf
int ni_vsprintf(char *dest, const size_t dmax, const char *fmt, va_list args)
Definition ni_util.c:1054
ni_util.h
Utility definitions.
_ni_device_info
Definition ni_rsrc_api.h:103
_ni_device_info::fw_build_id
uint8_t fw_build_id[256]
Definition ni_rsrc_api.h:120
_ni_device_info::hw_id
int hw_id
Definition ni_rsrc_api.h:106
_ni_device_info::module_id
int module_id
Definition ni_rsrc_api.h:107
_ni_device_info::fw_commit_time
uint8_t fw_commit_time[26]
Definition ni_rsrc_api.h:117
_ni_device_info::serial_number
uint8_t serial_number[20]
Definition ni_rsrc_api.h:122
_ni_device_info::dev_name
char dev_name[NI_MAX_DEVICE_NAME_LEN]
Definition ni_rsrc_api.h:104
_ni_device_info::fw_rev
uint8_t fw_rev[8]
Definition ni_rsrc_api.h:115
_ni_device_info::fw_commit_hash
uint8_t fw_commit_hash[41]
Definition ni_rsrc_api.h:118
_ni_device_info::max_fps_4k
int max_fps_4k
Definition ni_rsrc_api.h:126
_ni_device_info::fw_ver_compat_warning
int fw_ver_compat_warning
Definition ni_rsrc_api.h:111
_ni_device_info::max_instance_cnt
int max_instance_cnt
Definition ni_rsrc_api.h:127
_ni_device_info::device_type
ni_device_type_t device_type
Definition ni_rsrc_api.h:129
_ni_device_info::fl_ver_last_ran
uint8_t fl_ver_last_ran[8]
Definition ni_rsrc_api.h:113
_ni_device_info::fw_branch_name
uint8_t fw_branch_name[256]
Definition ni_rsrc_api.h:116
_ni_device_info::model_number
uint8_t model_number[40]
Definition ni_rsrc_api.h:123
_ni_device_info::fw_rev_nor_flash
uint8_t fw_rev_nor_flash[8]
Definition ni_rsrc_api.h:114
_ni_device_info::fw_flavour
uint8_t fw_flavour
Definition ni_rsrc_api.h:137
_ni_device_info::fw_build_time
uint8_t fw_build_time[26]
Definition ni_rsrc_api.h:119
_ni_device_info::fl_ver_nor_flash
uint8_t fl_ver_nor_flash[8]
Definition ni_rsrc_api.h:112
_ni_device_info::dev_cap
ni_device_video_capability_t dev_cap[EN_CODEC_MAX]
Definition ni_rsrc_api.h:132
_ni_device_video_capability::supports_codec
int supports_codec
Definition ni_rsrc_api.h:76
_ni_device_video_capability::max_res_height
int max_res_height
Definition ni_rsrc_api.h:78
_ni_device_video_capability::level
char level[NI_LEVELS_SUPP_STR_LEN]
Definition ni_rsrc_api.h:82
_ni_device_video_capability::max_res_width
int max_res_width
Definition ni_rsrc_api.h:77
_ni_device_video_capability::profiles_supported
char profiles_supported[NI_PROFILES_SUPP_STR_LEN]
Definition ni_rsrc_api.h:81
_ni_device_video_capability::min_res_width
int min_res_width
Definition ni_rsrc_api.h:79
_ni_device_video_capability::min_res_height
int min_res_height
Definition ni_rsrc_api.h:80
_ni_device
Definition ni_rsrc_api.h:142
_ni_device::xcoders
ni_device_info_t xcoders[NI_DEVICE_TYPE_XCODER_MAX][NI_MAX_DEVICE_CNT]
Definition ni_rsrc_api.h:144
_ni_device::xcoder_cnt
int xcoder_cnt[NI_DEVICE_TYPE_XCODER_MAX]
Definition ni_rsrc_api.h:143
dyn_str_buf
Definition ni_rsrc_list.c:59
dyn_str_buf::buf_size
int buf_size
Definition ni_rsrc_list.c:61
dyn_str_buf::str_buf
char * str_buf
Definition ni_rsrc_list.c:62
dyn_str_buf::str_len
int str_len
Definition ni_rsrc_list.c:60