libxcoder  5.4.0
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 
43 {
47 };
48 
49 static const char *ni_codec_format_str[] = {"H.264", "H.265", "VP9", "JPEG",
50  "AV1"};
51 static const char *ni_dec_name_str[] = {"h264_ni_quadra_dec", "h265_ni_quadra_dec",
52  "vp9_ni_quadra_dec", "jpeg_ni_quadra_dec"};
53 static 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
58 typedef 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
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  ******************************************************************************/
75 int 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  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) /
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  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 
135 {
136  free(dyn_str_buf->str_buf);
137  memset(dyn_str_buf, 0, sizeof(dyn_str_buf_t));
138 }
139 
140 
141 
142 static 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, " DeviceID: %s\n", p_dev_info->dev_name);
186  strcat_dyn_buf(&output_buf, " PixelFormats: yuv420p, yuv420p10le, nv12, p010le"
187  ", ni_quadra\n");
188 
189  for (size_t dev_type = NI_DEVICE_TYPE_DECODER;
190  dev_type != NI_DEVICE_TYPE_XCODER_MAX; dev_type++)
191  {
192  for (int xcoder_index_2 = 0;
193  xcoder_index_2 < p_device->xcoder_cnt[NI_DEVICE_TYPE_ENCODER];
194  xcoder_index_2++)
195  {
196  if (strcmp(p_dev_info->dev_name,
197  p_device->xcoders[dev_type][xcoder_index_2].dev_name)
198  == 0 && p_dev_info->module_id >= 0)
199  {
200  const ni_device_info_t *p_device_info =
201  &(p_device->xcoders[dev_type][xcoder_index_2]);
202  int i;
203 
204  if (!p_device_info)
205  {
206  ni_log(NI_LOG_ERROR, "ERROR: Cannot print device info!\n");
207  } else
208  {
209  strcat_dyn_buf(&output_buf, " %s #%d\n",
210  GET_XCODER_DEVICE_TYPE_STR(p_device_info->device_type),
211  p_device_info->module_id);
212  strcat_dyn_buf(&output_buf, " H/W ID: %d\n", p_device_info->hw_id);
213  strcat_dyn_buf(&output_buf, " MaxNumInstances: %d\n",
214  p_device_info->max_instance_cnt);
215 
216  if (NI_DEVICE_TYPE_SCALER == p_device_info->device_type)
217  {
218  strcat_dyn_buf(&output_buf, " Capabilities:\n");
219  strcat_dyn_buf(&output_buf,
220  " Operations: Crop (ni_quadra_crop), Scale (ni_quadra_scale), Pad "
221  "(ni_quadra_pad), Overlay (ni_quadra_overlay)\n"
222  " Drawbox (ni_quadra_drawbox), Rotate (ni_quadra_rotate), XStack (ni_quadra_xstack)\n");
223  } else if (NI_DEVICE_TYPE_AI == p_device_info->device_type)
224  {
225  strcat_dyn_buf(&output_buf, " Capabilities:\n");
226  strcat_dyn_buf(&output_buf,
227  " Operations: ROI (ni_quadra_roi), Background Replace (ni_quadra_bg)\n");
228  } else if (NI_DEVICE_TYPE_DECODER == p_device_info->device_type ||
229  NI_DEVICE_TYPE_ENCODER == p_device_info->device_type)
230  {
231  strcat_dyn_buf(&output_buf, " Max4KFps: %d\n", p_device_info->max_fps_4k);
232  for (i = 0; i < EN_CODEC_MAX; i++)
233  {
234  if (EN_INVALID != p_device_info->dev_cap[i].supports_codec)
235  {
236  strcat_dyn_buf(&output_buf, " %s ",
237  ni_codec_format_str[p_device_info->dev_cap[i]
238  .supports_codec]);
239  strcat_dyn_buf(&output_buf, "(%s) Capabilities:\n",
241  p_device_info->device_type ?
242  ni_dec_name_str[p_device_info->dev_cap[i]
243  .supports_codec] :
244  ni_enc_name_str[p_device_info->dev_cap[i]
245  .supports_codec]);
246  strcat_dyn_buf(&output_buf, " MaxResolution: %dx%d\n",
247  p_device_info->dev_cap[i].max_res_width,
248  p_device_info->dev_cap[i].max_res_height);
249  strcat_dyn_buf(&output_buf, " MinResolution: %dx%d\n",
250  p_device_info->dev_cap[i].min_res_width,
251  p_device_info->dev_cap[i].min_res_height);
252 
253  // no profile for JPEG encode, or level for JPEG
254  if (! (NI_DEVICE_TYPE_ENCODER == p_device_info->device_type &&
255  EN_JPEG == p_device_info->dev_cap[i].supports_codec))
256  {
257  strcat_dyn_buf(&output_buf, " Profiles: %s\n",
258  p_device_info->dev_cap[i].profiles_supported);
259  }
260  if (EN_JPEG != p_device_info->dev_cap[i].supports_codec)
261  {
262  strcat_dyn_buf(&output_buf, " Level: %s\n",
263  p_device_info->dev_cap[i].level);
264  }
265  }
266  }
267  }
268  }
269  }
270  }
271  }
272  }
273  if (output_buf.str_buf)
274  printf("%s", output_buf.str_buf);
275  clear_dyn_str_buf(&output_buf);
276 }
277 
278 static void print_full_text(ni_device_t *p_device)
279 {
280  if (!p_device)
281  {
282  ni_log(NI_LOG_INFO, "WARNING: NULL parameter passed in!\n");
283  return;
284  }
285 
286  dyn_str_buf_t output_buf = {0};
287  ni_device_info_t *p_dev_info = NULL;
288  int ddr_module_id = -1;
289  for (int xcoder_index_1 = 0;
290  xcoder_index_1 < p_device->xcoder_cnt[NI_DEVICE_TYPE_ENCODER];
291  xcoder_index_1++)
292  {
293  p_dev_info = &p_device->xcoders[NI_DEVICE_TYPE_ENCODER][xcoder_index_1];
294  strcat_dyn_buf(&output_buf, "Device #%d:\n", xcoder_index_1);
295  strcat_dyn_buf(&output_buf, " Serial number: %.*s\n",
296  (int)sizeof(p_dev_info->serial_number),
297  p_dev_info->serial_number);
298  strcat_dyn_buf(&output_buf, " Model number: %.*s\n",
299  (int)sizeof(p_dev_info->model_number),
300  p_dev_info->model_number);
301  strcat_dyn_buf(&output_buf, " Last ran firmware loader version: %.8s\n",
302  p_dev_info->fl_ver_last_ran);
303  strcat_dyn_buf(&output_buf, " NOR flash firmware loader version: %.8s\n",
304  p_dev_info->fl_ver_nor_flash);
305  strcat_dyn_buf(&output_buf, " Current firmware revision: %.8s\n",
306  p_dev_info->fw_rev);
307  strcat_dyn_buf(&output_buf, " NOR flash firmware revision: %.8s\n",
308  p_dev_info->fw_rev_nor_flash);
309  strcat_dyn_buf(&output_buf, " F/W & S/W compatibility: %s\n",
310  p_dev_info->fw_ver_compat_warning ?
311  "no, possible missing features" : "yes");
312  strcat_dyn_buf(&output_buf, " F/W branch: %s\n",
313  p_dev_info->fw_branch_name);
314  strcat_dyn_buf(&output_buf, " F/W commit time: %s\n",
315  p_dev_info->fw_commit_time);
316  strcat_dyn_buf(&output_buf, " F/W commit hash: %s\n",
317  p_dev_info->fw_commit_hash);
318  strcat_dyn_buf(&output_buf, " F/W build time: %s\n",
319  p_dev_info->fw_build_time);
320  strcat_dyn_buf(&output_buf, " F/W build id: %s\n",p_dev_info->fw_build_id);
321  strcat_dyn_buf(&output_buf, " DeviceID: %s\n", p_dev_info->dev_name);
322 
323  for (size_t dev_type = NI_DEVICE_TYPE_DECODER;
324  dev_type != NI_DEVICE_TYPE_XCODER_MAX; dev_type++)
325  {
326  for (int xcoder_index_2 = 0;
327  xcoder_index_2 < p_device->xcoder_cnt[NI_DEVICE_TYPE_ENCODER];
328  xcoder_index_2++)
329  {
330  if (strcmp(p_dev_info->dev_name,
331  p_device->xcoders[dev_type][xcoder_index_2].dev_name)
332  == 0 && p_dev_info->module_id >= 0)
333  {
334  const ni_device_info_t *p_device_info =
335  &(p_device->xcoders[dev_type][xcoder_index_2]);
336  int i;
337 
338  if (!p_device_info)
339  {
340  ni_log(NI_LOG_ERROR, "ERROR: Cannot print device info!\n");
341  } else
342  {
343  ddr_module_id = p_device_info->module_id;
344  strcat_dyn_buf(&output_buf, " %s #%d\n",
345  GET_XCODER_DEVICE_TYPE_STR(p_device_info->device_type),
346  p_device_info->module_id);
347  strcat_dyn_buf(&output_buf, " H/W ID: %d\n", p_device_info->hw_id);
348  strcat_dyn_buf(&output_buf, " MaxNumInstances: %d\n",
349  p_device_info->max_instance_cnt);
350 
351  if (NI_DEVICE_TYPE_SCALER == p_device_info->device_type)
352  {
353  strcat_dyn_buf(&output_buf, " Capabilities:\n");
354  strcat_dyn_buf(&output_buf,
355  " Operations: Crop (ni_quadra_crop), Scale (ni_quadra_scale), Pad "
356  "(ni_quadra_pad), Overlay (ni_quadra_overlay)\n"
357  " Drawbox (ni_quadra_drawbox), Rotate (ni_quadra_rotate), XStack (ni_quadra_xstack)\n"
358  " Delogo (ni_quadra_delogo), Merge (ni_quadra_merge), Flip (ni_quadra_flip)\n"
359  " Drawtext (ni_quadra_drawtext)\n");
360  } else if (NI_DEVICE_TYPE_AI == p_device_info->device_type)
361  {
362  strcat_dyn_buf(&output_buf, " Capabilities:\n");
363  strcat_dyn_buf(&output_buf, " Cores: 2\n");
364  strcat_dyn_buf(&output_buf, " Computing Power: int8 18 tops\n");
365  strcat_dyn_buf(&output_buf,
366  " Operations: ROI (ni_quadra_roi), Background Replace (ni_quadra_bg), Ai Pre-processing (ni_quadra_ai_pre)\n"
367  " Background Remove (ni_quadra_bgr), Hvsplus (ni_quadra_hvsplus)\n");
368  } else if (NI_DEVICE_TYPE_DECODER == p_device_info->device_type ||
369  NI_DEVICE_TYPE_ENCODER == p_device_info->device_type)
370  {
371  strcat_dyn_buf(&output_buf, " Max4KFps: %d\n", p_device_info->max_fps_4k);
372  for (i = 0; i < EN_CODEC_MAX; i++)
373  {
374  if (EN_INVALID != p_device_info->dev_cap[i].supports_codec)
375  {
376  strcat_dyn_buf(&output_buf, " %s ",
377  ni_codec_format_str[p_device_info->dev_cap[i]
378  .supports_codec]);
379  strcat_dyn_buf(&output_buf, "(%s) Capabilities:\n",
381  p_device_info->device_type ?
382  ni_dec_name_str[p_device_info->dev_cap[i]
383  .supports_codec] :
384  ni_enc_name_str[p_device_info->dev_cap[i]
385  .supports_codec]);
386  if (NI_DEVICE_TYPE_DECODER == p_device_info->device_type)
387  {
388  switch (p_device_info->dev_cap[i].supports_codec)
389  {
390  case EN_H264:
391  case EN_H265:
392  case EN_VP9:
393  strcat_dyn_buf(&output_buf, " PixelFormats: "
394  "yuv420p, yuv420p10le, nv12, p010le, ni_quad\n");
395  break;
396  case EN_JPEG:
397  strcat_dyn_buf(&output_buf, " PixelFormats: "
398  "yuvj420p, ni_quad\n");
399  break;
400  case EN_AV1:
401  default:
402  break;
403  }
404  }
405  else
406  {
407  switch (p_device_info->dev_cap[i].supports_codec)
408  {
409  case EN_H264:
410  case EN_H265:
411  case EN_AV1:
412  strcat_dyn_buf(&output_buf, " PixelFormats: "
413  "yuv420p, yuvj420p, yuv420p10le, nv12, p010le, ni_quad\n");
414  break;
415  case EN_JPEG:
416  strcat_dyn_buf(&output_buf, " PixelFormats: "
417  "yuvj420p, ni_quad\n");
418  break;
419  case EN_VP9:
420  default:
421  break;
422  }
423  }
424  strcat_dyn_buf(&output_buf, " MaxResolution: %dx%d\n",
425  p_device_info->dev_cap[i].max_res_width,
426  p_device_info->dev_cap[i].max_res_height);
427  strcat_dyn_buf(&output_buf, " MinResolution: %dx%d\n",
428  p_device_info->dev_cap[i].min_res_width,
429  p_device_info->dev_cap[i].min_res_height);
430 
431  // no profile for JPEG encode, or level for JPEG
432  if (! (NI_DEVICE_TYPE_ENCODER == p_device_info->device_type &&
433  EN_JPEG == p_device_info->dev_cap[i].supports_codec))
434  {
435  strcat_dyn_buf(&output_buf, " Profiles: %s\n",
436  p_device_info->dev_cap[i].profiles_supported);
437  }
438  if (EN_JPEG != p_device_info->dev_cap[i].supports_codec)
439  {
440  strcat_dyn_buf(&output_buf, " Level: %s\n",
441  p_device_info->dev_cap[i].level);
442  }
443  }
444  }
445  }
446  }
447  }
448  }
449  }
450  if (ddr_module_id >= 0)
451  {
452  strcat_dyn_buf(&output_buf, " Memory #%d\n", ddr_module_id);
453  strcat_dyn_buf(&output_buf, " Type: DDR4\n");
454  strcat_dyn_buf(&output_buf, " Size: 8GB\n");
455  ddr_module_id = -1;
456  }
457  }
458  if (output_buf.str_buf)
459  printf("%s", output_buf.str_buf);
460  clear_dyn_str_buf(&output_buf);
461 }
462 
463 static void print_json(ni_device_t *p_device)
464 {
465  if (!p_device)
466  {
467  ni_log(NI_LOG_INFO, "WARNING: NULL parameter passed in!\n");
468  return;
469  }
470 
471  dyn_str_buf_t output_buf = {0};
472  ni_device_info_t *p_dev_info = NULL;
473  int ddr_module_id = -1;
474  strcat_dyn_buf(&output_buf,"{\n");
475  for (int xcoder_index_1 = 0;
476  xcoder_index_1 < p_device->xcoder_cnt[NI_DEVICE_TYPE_ENCODER];
477  xcoder_index_1++)
478  {
479  p_dev_info = &p_device->xcoders[NI_DEVICE_TYPE_ENCODER][xcoder_index_1];
480  strcat_dyn_buf(&output_buf, " \"Device #%d\": [\n", xcoder_index_1);
481  strcat_dyn_buf(&output_buf, "\t{\n"
482  "\t\t\"Serial number\": \"%.*s\",\n"
483  "\t\t\"Model number:\": \"%.*s\",\n"
484  "\t\t\"Last ran firmware loader version\": \"%.8s\",\n"
485  "\t\t\"NOR flash firmware loader version\": \"%.8s\",\n"
486  "\t\t\"Current firmware revision\": \"%.8s\",\n"
487  "\t\t\"NOR flash firmware revision\": \"%.8s\",\n"
488  "\t\t\"F/W & S/W compatibility\": \"%s\",\n"
489  "\t\t\"F/W branch\": \"%s\",\n"
490  "\t\t\"F/W commit time\": \"%s\",\n"
491  "\t\t\"F/W commit hash\": \"%s\",\n"
492  "\t\t\"F/W build time\": \"%s\",\n"
493  "\t\t\"F/W build id\": \"%s\",\n"
494  "\t\t\"DeviceID\": \"%s\",\n"
495  , (int)sizeof(p_dev_info->serial_number), p_dev_info->serial_number,
496  (int)sizeof(p_dev_info->model_number), p_dev_info->model_number,
497  p_dev_info->fl_ver_last_ran, p_dev_info->fl_ver_nor_flash,
498  p_dev_info->fw_rev, p_dev_info->fw_rev_nor_flash,
499  p_dev_info->fw_ver_compat_warning ? "no, possible missing features" : "yes",
500  p_dev_info->fw_branch_name, p_dev_info->fw_commit_time,
501  p_dev_info->fw_commit_hash, p_dev_info->fw_build_time,
502  p_dev_info->fw_build_id, p_dev_info->dev_name);
503  for (size_t dev_type = NI_DEVICE_TYPE_DECODER;
504  dev_type != NI_DEVICE_TYPE_XCODER_MAX; dev_type++)
505  {
506  for (int xcoder_index_2 = 0;
507  xcoder_index_2 < p_device->xcoder_cnt[NI_DEVICE_TYPE_ENCODER];
508  xcoder_index_2++)
509  {
510  if (strcmp(p_dev_info->dev_name,
511  p_device->xcoders[dev_type][xcoder_index_2].dev_name)
512  == 0 && p_dev_info->module_id >= 0)
513  {
514  const ni_device_info_t *p_device_info =
515  &(p_device->xcoders[dev_type][xcoder_index_2]);
516  int i;
517 
518  if (!p_device_info)
519  {
520  ni_log(NI_LOG_ERROR, "ERROR: Cannot print device info!\n");
521  } else
522  {
523  ddr_module_id = p_device_info->module_id;
524  strcat_dyn_buf(&output_buf, "\t\t\"%s #%d\": [\n",
525  GET_XCODER_DEVICE_TYPE_STR(p_device_info->device_type),
526  p_device_info->module_id);
527  strcat_dyn_buf(&output_buf, "\t\t\t{\n");
528  strcat_dyn_buf(&output_buf, "\t\t\t\t\"H/W ID\": %d,\n"
529  "\t\t\t\t\"MaxNumInstances\": %d,\n"
530  , p_device_info->hw_id,
531  p_device_info->max_instance_cnt);
532  if (NI_DEVICE_TYPE_SCALER == p_device_info->device_type)
533  {
534  strcat_dyn_buf(&output_buf, "\t\t\t\t\"Capabilities\": [\n");
535  strcat_dyn_buf(&output_buf, "\t\t\t\t\t{\n");
536  strcat_dyn_buf(&output_buf, "\t\t\t\t\t\t\"Operations\": "
537  "\"Crop (ni_quadra_crop), Scale (ni_quadra_scale), Pad "
538  "(ni_quadra_pad), Overlay (ni_quadra_overlay), "
539  "Drawbox (ni_quadra_drawbox), Rotate (ni_quadra_rotate), "
540  "XStack (ni_quadra_xstack), Delogo (ni_quadra_delogo), "
541  "Merge (ni_quadra_merge), Flip (ni_quadra_flip), "
542  "Drawtext (ni_quadra_drawtext)\"\n");
543  strcat_dyn_buf(&output_buf, "\t\t\t\t\t}\n\t\t\t\t]\n");
544  strcat_dyn_buf(&output_buf, "\t\t\t}\n\t\t],\n");
545  } else if (NI_DEVICE_TYPE_AI == p_device_info->device_type)
546  {
547  strcat_dyn_buf(&output_buf, "\t\t\t\t\"Capabilities\": [\n");
548  strcat_dyn_buf(&output_buf, "\t\t\t\t\t{\n");
549  strcat_dyn_buf(&output_buf, "\t\t\t\t\t\t\"Cores\": 2,\n"
550  "\t\t\t\t\t\t\"Computing Power\": \"int8 18 tops\",\n"
551  "\t\t\t\t\t\t\"Operations\": "
552  "\"ROI (ni_quadra_roi), Background Replace (ni_quadra_bg), "
553  "Ai Pre-processing (ni_quadra_ai_pre), "
554  "Background Remove (ni_quadra_bgr), Hvsplus (ni_quadra_hvsplus)\"\n");
555  strcat_dyn_buf(&output_buf, "\t\t\t\t\t}\n\t\t\t\t]\n");
556  strcat_dyn_buf(&output_buf, "\t\t\t}\n\t\t],\n");
557  } else if (NI_DEVICE_TYPE_DECODER == p_device_info->device_type ||
558  NI_DEVICE_TYPE_ENCODER == p_device_info->device_type)
559  {
560  strcat_dyn_buf(&output_buf, "\t\t\t\t\"Max4KFps\": %d,\n",
561  p_device_info->max_fps_4k);
562  for (i = 0; i < EN_CODEC_MAX; i++)
563  {
564  if (EN_INVALID != p_device_info->dev_cap[i].supports_codec)
565  {
566  strcat_dyn_buf(&output_buf, "\t\t\t\t\"%s (%s) Capabilities\": [\n",
567  ni_codec_format_str[p_device_info->dev_cap[i].supports_codec],
568  NI_DEVICE_TYPE_DECODER == p_device_info->device_type ?
569  ni_dec_name_str[p_device_info->dev_cap[i].supports_codec] :
570  ni_enc_name_str[p_device_info->dev_cap[i].supports_codec]);
571  strcat_dyn_buf(&output_buf, "\t\t\t\t\t{\n");
572  if (NI_DEVICE_TYPE_DECODER == p_device_info->device_type)
573  {
574  switch (p_device_info->dev_cap[i].supports_codec)
575  {
576  case EN_H264:
577  case EN_H265:
578  case EN_VP9:
579  strcat_dyn_buf(&output_buf, "\t\t\t\t\t\t\"PixelFormats\": "
580  "\"yuv420p, yuv420p10le, nv12, p010le, ni_quad\",\n");
581  break;
582  case EN_JPEG:
583  strcat_dyn_buf(&output_buf, "\t\t\t\t\t\t\"PixelFormats\": "
584  "\"yuvj420p, ni_quad\",\n");
585  break;
586  case EN_AV1:
587  default:
588  break;
589  }
590  }
591  else
592  {
593  switch (p_device_info->dev_cap[i].supports_codec)
594  {
595  case EN_H264:
596  case EN_H265:
597  case EN_AV1:
598  strcat_dyn_buf(&output_buf, "\t\t\t\t\t\t\"PixelFormats\": "
599  "\"yuv420p, yuvj420p, yuv420p10le, nv12, p010le, ni_quad\",\n");
600  break;
601  case EN_JPEG:
602  strcat_dyn_buf(&output_buf, "\t\t\t\t\t\t\"PixelFormats\": "
603  "\"yuvj420p, ni_quad\",\n");
604  break;
605  case EN_VP9:
606  default:
607  break;
608  }
609  }
610  strcat_dyn_buf(&output_buf, "\t\t\t\t\t\t\"MaxResolution\": \"%dx%d\",\n"
611  "\t\t\t\t\t\t\"MinResolution\": \"%dx%d\""
612  ,p_device_info->dev_cap[i].max_res_width,
613  p_device_info->dev_cap[i].max_res_height,
614  p_device_info->dev_cap[i].min_res_width,
615  p_device_info->dev_cap[i].min_res_height);
616  // no profile for JPEG encode, or level for JPEG
617  if (! (NI_DEVICE_TYPE_ENCODER == p_device_info->device_type &&
618  EN_JPEG == p_device_info->dev_cap[i].supports_codec))
619  {
620  strcat_dyn_buf(&output_buf, ",\n\t\t\t\t\t\t\"Profiles\": \"%s\"",
621  p_device_info->dev_cap[i].profiles_supported);
622  }
623  if (EN_JPEG != p_device_info->dev_cap[i].supports_codec)
624  {
625  strcat_dyn_buf(&output_buf, ",\n\t\t\t\t\t\t\"Level\": \"%s\"",
626  p_device_info->dev_cap[i].level);
627  }
628  if ((NI_DEVICE_TYPE_DECODER == p_device_info->device_type &&
629  EN_VP9 == p_device_info->dev_cap[i].supports_codec) ||
630  (NI_DEVICE_TYPE_ENCODER == p_device_info->device_type &&
631  EN_AV1 == p_device_info->dev_cap[i].supports_codec))
632  {
633  strcat_dyn_buf(&output_buf, "\n\t\t\t\t\t}\n\t\t\t\t]\n");
634  }
635  else
636  {
637  strcat_dyn_buf(&output_buf, "\n\t\t\t\t\t}\n\t\t\t\t],\n");
638  }
639  }
640  }
641  strcat_dyn_buf(&output_buf, "\t\t\t}\n\t\t],\n");
642  }
643  }
644  }
645  }
646  }
647  if (ddr_module_id >= 0)
648  {
649  strcat_dyn_buf(&output_buf, "\t\t\"Memory #%d\": [\n", ddr_module_id);
650  strcat_dyn_buf(&output_buf, "\t\t\t{\n");
651  strcat_dyn_buf(&output_buf, "\t\t\t\t\"Type\": \"DDR4\",\n"
652  "\t\t\t\t\"Size\": \"8GB\"\n");
653  strcat_dyn_buf(&output_buf, "\t\t\t}\n\t\t]\n");
654  ddr_module_id = -1;
655  }
656  if (xcoder_index_1 == p_device->xcoder_cnt[NI_DEVICE_TYPE_ENCODER] - 1)
657  strcat_dyn_buf(&output_buf, "\t}\n ]\n");
658  else
659  strcat_dyn_buf(&output_buf, "\t}\n ],\n");
660  }
661  strcat_dyn_buf(&output_buf,"}\n");
662  if (output_buf.str_buf)
663  printf("%s", output_buf.str_buf);
664  clear_dyn_str_buf(&output_buf);
665 }
666 
667 
668 int32_t main(int argc, char *argv[])
669 {
670  int opt;
671  bool list_uninitialized = false;
672  ni_log_level_t log_level = NI_LOG_INFO;
673  int printFormat = FMT_TEXT;
674 
675  // arg handling
676  while ((opt = getopt(argc, argv, "ahvlo:")) != -1)
677  {
678  switch (opt)
679  {
680  case 'a':
681  list_uninitialized = true;
682  break;
683  case 'h':
684  // help message
685  printf("-------- ni_rsrc_list v%s --------\n"
686  "Display information for NETINT hardware.\n"
687  "\n"
688  "-a Print includes info for uninitialized cards.\n"
689  "-h Display this help and exit.\n"
690  "-v Print version info.\n"
691  "-o Output format. [text, full, json]\n"
692  " Default: text\n"
693  "-l Set loglevel of libxcoder API.\n"
694  " [none, fatal, error, info, debug, trace]\n"
695  " Default: info\n",
697  return 0;
698  case 'v':
699  printf("Release ver: %s\n"
700  "API ver: %s\n"
701  "Date: %s\n"
702  "ID: %s\n",
705  return 0;
706  case 'l':
707  log_level = arg_to_ni_log_level(optarg);
708  if (log_level != NI_LOG_INVALID)
709  {
710  ni_log_set_level(log_level);
711  } else {
712  fprintf(stderr, "FATAL: invalid log level selected: %s\n",
713  optarg);
714  exit(1);
715  }
716  break;
717  case 'o':
718  // Output print format
719  if (!strcmp(optarg, "text"))
720  {
721  printFormat = FMT_TEXT;
722  }
723  else if (!strcmp(optarg, "full"))
724  {
725  printFormat = FMT_FULL_TEXT;
726  }
727  else if (!strcmp(optarg, "json"))
728  {
729  printFormat = FMT_JSON;
730  }
731  else
732  {
733  fprintf(stderr, "Error: unknown selection for outputFormat: %s\n", optarg);
734  return 1;
735  }
736  break;
737  default:
738  fprintf(stderr, "FATAL: invalid arg '%c'\n", opt);
739  return 1;
740  }
741  }
742 
743  ni_log_set_level(log_level);
744  ni_device_t *device = NULL;
745  device = (ni_device_t *)malloc(sizeof(ni_device_t));
746  if (!device)
747  {
748  char errmsg[NI_ERRNO_LEN] = {0};
750  ni_log(NI_LOG_ERROR, "ERROR %s() failed to malloc memory: %s\n",
751  __func__, errmsg);
752  return 1;
753  }
754  memset(device, 0, sizeof(ni_device_t));
755 
756  if (NI_RETCODE_SUCCESS != ni_rsrc_list_all_devices2(device, list_uninitialized))
757  {
758  free(device);
759  return 1;
760  }
761 
762  switch(printFormat)
763  {
764  case FMT_TEXT:
765  print_text(device);
766  break;
767  case FMT_FULL_TEXT:
768  print_full_text(device);
769  break;
770  case FMT_JSON:
771  print_json(device);
772  break;
773  default:
774  break;
775  }
776  free(device);
777  return 0;
778 }
FMT_JSON
@ FMT_JSON
Definition: ni_rsrc_list.c:46
_ni_device_info::fw_rev
uint8_t fw_rev[8]
Definition: ni_rsrc_api.h:115
ni_log_level_t
ni_log_level_t
Definition: ni_log.h:57
_ni_device_info::serial_number
uint8_t serial_number[20]
Definition: ni_rsrc_api.h:122
EN_INVALID
@ EN_INVALID
Definition: ni_rsrc_api.h:49
NI_DEVICE_TYPE_ENCODER
@ NI_DEVICE_TYPE_ENCODER
Definition: ni_defs.h:361
ni_strerror
ni_retcode_t ni_strerror(char *dest, size_t dmax, int errnum)
Definition: ni_util.c:652
_ni_device_info::dev_cap
ni_device_video_capability_t dev_cap[EN_CODEC_MAX]
Definition: ni_rsrc_api.h:132
_ni_device::xcoders
ni_device_info_t xcoders[NI_DEVICE_TYPE_XCODER_MAX][NI_MAX_DEVICE_CNT]
Definition: ni_rsrc_api.h:142
dyn_str_buf_t
struct dyn_str_buf dyn_str_buf_t
print_json
void print_json(ni_device_queue_t *p_device_queue, ni_session_context_t *p_session_context, int detail, ni_instance_mgr_detail_status_v1_t *detail_data_v1)
Definition: ni_rsrc_mon.c:1244
NI_DEVICE_TYPE_DECODER
@ NI_DEVICE_TYPE_DECODER
Definition: ni_defs.h:360
_ni_device_info::fw_commit_hash
uint8_t fw_commit_hash[41]
Definition: ni_rsrc_api.h:118
_ni_device_video_capability::max_res_height
int max_res_height
Definition: ni_rsrc_api.h:78
NI_SW_RELEASE_ID
#define NI_SW_RELEASE_ID
Definition: ni_release_info.h:29
NI_RETCODE_SUCCESS
@ NI_RETCODE_SUCCESS
Definition: ni_defs.h:441
_ni_device_video_capability::min_res_width
int min_res_width
Definition: ni_rsrc_api.h:79
EN_H265
@ EN_H265
Definition: ni_rsrc_api.h:51
ni_log_set_level
void ni_log_set_level(ni_log_level_t level)
Set ni_log_level.
Definition: ni_log.c:202
ni_rsrc_api.h
Public definitions for managing NETINT video processing devices.
_ni_device::xcoder_cnt
int xcoder_cnt[NI_DEVICE_TYPE_XCODER_MAX]
Definition: ni_rsrc_api.h:141
_ni_device
Definition: ni_rsrc_api.h:139
NI_XCODER_REVISION
#define NI_XCODER_REVISION
Definition: ni_defs.h:98
_ni_device_info::fl_ver_nor_flash
uint8_t fl_ver_nor_flash[8]
Definition: ni_rsrc_api.h:112
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
clear_dyn_str_buf
void clear_dyn_str_buf(dyn_str_buf_t *dyn_str_buf)
Definition: ni_rsrc_list.c:134
_ni_device_info::fw_ver_compat_warning
int fw_ver_compat_warning
Definition: ni_rsrc_api.h:111
EN_H264
@ EN_H264
Definition: ni_rsrc_api.h:50
_ni_device_info::fw_commit_time
uint8_t fw_commit_time[26]
Definition: ni_rsrc_api.h:117
_ni_device_info::hw_id
int hw_id
Definition: ni_rsrc_api.h:106
_ni_device_info::dev_name
char dev_name[NI_MAX_DEVICE_NAME_LEN]
Definition: ni_rsrc_api.h:104
print_text
void print_text(ni_device_queue_t *coders, ni_session_context_t *sessionCtxt, int detail, ni_instance_mgr_detail_status_v1_t *detail_data_v1, ni_instance_mgr_detail_status_v1_t(*previous_detail_data_p)[NI_DEVICE_TYPE_XCODER_MAX], int checkInterval)
Definition: ni_rsrc_mon.c:2179
dyn_str_buf
Definition: ni_rsrc_list.c:58
NI_ERRNO_LEN
#define NI_ERRNO_LEN
Definition: ni_log.h:51
NI_LOG_INFO
@ NI_LOG_INFO
Definition: ni_log.h:63
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_ERROR
@ NI_LOG_ERROR
Definition: ni_log.h:62
EN_JPEG
@ EN_JPEG
Definition: ni_rsrc_api.h:53
_ni_device_info::fw_rev_nor_flash
uint8_t fw_rev_nor_flash[8]
Definition: ni_rsrc_api.h:114
_ni_device_video_capability::profiles_supported
char profiles_supported[NI_PROFILES_SUPP_STR_LEN]
Definition: ni_rsrc_api.h:81
_ni_device_info::max_instance_cnt
int max_instance_cnt
Definition: ni_rsrc_api.h:127
_ni_device_info
Definition: ni_rsrc_api.h:102
NI_DEVICE_TYPE_AI
@ NI_DEVICE_TYPE_AI
Definition: ni_defs.h:363
EN_AV1
@ EN_AV1
Definition: ni_rsrc_api.h:54
_ni_device_info::fl_ver_last_ran
uint8_t fl_ver_last_ran[8]
Definition: ni_rsrc_api.h:113
NI_SW_RELEASE_TIME
#define NI_SW_RELEASE_TIME
Definition: ni_release_info.h:28
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
DYN_STR_BUF_CHUNK_SIZE
#define DYN_STR_BUF_CHUNK_SIZE
Definition: ni_rsrc_list.c:57
NI_LOG_INVALID
@ NI_LOG_INVALID
Definition: ni_log.h:59
_ni_device_info::module_id
int module_id
Definition: ni_rsrc_api.h:107
dyn_str_buf::str_len
int str_len
Definition: ni_rsrc_list.c:60
FMT_TEXT
@ FMT_TEXT
Definition: ni_rsrc_list.c:44
_ni_device_info::fw_build_time
uint8_t fw_build_time[26]
Definition: ni_rsrc_api.h:119
EN_VP9
@ EN_VP9
Definition: ni_rsrc_api.h:52
optarg
char * optarg
Definition: ni_getopt.c:33
NI_DEVICE_TYPE_SCALER
@ NI_DEVICE_TYPE_SCALER
Definition: ni_defs.h:362
EN_CODEC_MAX
@ EN_CODEC_MAX
Definition: ni_rsrc_api.h:55
FMT_FULL_TEXT
@ FMT_FULL_TEXT
Definition: ni_rsrc_list.c:45
main
int32_t main(int argc, char *argv[])
Definition: ni_rsrc_list.c:668
NI_ERRNO
#define NI_ERRNO
Definition: ni_defs.h:229
print_full_text
void print_full_text(ni_device_queue_t *p_device_queue, ni_session_context_t *p_session_context, int detail, ni_instance_mgr_detail_status_v1_t *detail_data_v1)
Definition: ni_rsrc_mon.c:613
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:1515
getopt
int getopt(int argc, char *argv[], const char *optstring)
Definition: ni_getopt.c:38
_ni_device_info::max_fps_4k
int max_fps_4k
Definition: ni_rsrc_api.h:126
outFormat
outFormat
Definition: ni_rsrc_list.c:42
_ni_device_video_capability::min_res_height
int min_res_height
Definition: ni_rsrc_api.h:80
_ni_device_video_capability::max_res_width
int max_res_width
Definition: ni_rsrc_api.h:77
LIBXCODER_API_VERSION
#define LIBXCODER_API_VERSION
Definition: ni_defs.h:115
dyn_str_buf::str_buf
char * str_buf
Definition: ni_rsrc_list.c:62
_ni_device_info::model_number
uint8_t model_number[40]
Definition: ni_rsrc_api.h:123
NI_DEVICE_TYPE_XCODER_MAX
@ NI_DEVICE_TYPE_XCODER_MAX
Definition: ni_defs.h:364
_ni_device_video_capability::supports_codec
int supports_codec
Definition: ni_rsrc_api.h:76
_ni_device_info::fw_build_id
uint8_t fw_build_id[256]
Definition: ni_rsrc_api.h:120
ni_util.h
Utility definitions.
GET_XCODER_DEVICE_TYPE_STR
#define GET_XCODER_DEVICE_TYPE_STR(t)
Definition: ni_defs.h:431
ni_vsprintf
int ni_vsprintf(char *dest, const size_t dmax, const char *fmt, va_list args)
Definition: ni_util.c:1036
_ni_device_info::device_type
ni_device_type_t device_type
Definition: ni_rsrc_api.h:129
ni_getopt.h
Implementation of getopt() and getopt_long() for Windows environment.
_ni_device_info::fw_branch_name
uint8_t fw_branch_name[256]
Definition: ni_rsrc_api.h:116
_ni_device_video_capability::level
char level[NI_LEVELS_SUPP_STR_LEN]
Definition: ni_rsrc_api.h:82
dyn_str_buf::buf_size
int buf_size
Definition: ni_rsrc_list.c:61