libxcoder  5.2.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  }
124 
125  // concatenate string to buffer
126  vsprintf(dyn_str_buf->str_buf + dyn_str_buf->str_len, fmt, vl);
127  dyn_str_buf->str_len += formatted_len;
128 
129  va_end(vl);
130  return 0;
131 }
132 
134 {
135  free(dyn_str_buf->str_buf);
136  memset(dyn_str_buf, 0, sizeof(dyn_str_buf_t));
137 }
138 
139 
140 
141 static void print_text(ni_device_t *p_device)
142 {
143  if (!p_device)
144  {
145  ni_log(NI_LOG_INFO, "WARNING: NULL parameter passed in!\n");
146  return;
147  }
148 
149  dyn_str_buf_t output_buf = {0};
150  ni_device_info_t *p_dev_info = NULL;
151  for (int xcoder_index_1 = 0;
152  xcoder_index_1 < p_device->xcoder_cnt[NI_DEVICE_TYPE_ENCODER];
153  xcoder_index_1++)
154  {
155  p_dev_info = &p_device->xcoders[NI_DEVICE_TYPE_ENCODER][xcoder_index_1];
156 
157  strcat_dyn_buf(&output_buf, "Device #%d:\n", xcoder_index_1);
158  strcat_dyn_buf(&output_buf, " Serial number: %.*s\n",
159  (int)sizeof(p_dev_info->serial_number),
160  p_dev_info->serial_number);
161  strcat_dyn_buf(&output_buf, " Model number: %.*s\n",
162  (int)sizeof(p_dev_info->model_number),
163  p_dev_info->model_number);
164  strcat_dyn_buf(&output_buf, " Last ran firmware loader version: %.8s\n",
165  p_dev_info->fl_ver_last_ran);
166  strcat_dyn_buf(&output_buf, " NOR flash firmware loader version: %.8s\n",
167  p_dev_info->fl_ver_nor_flash);
168  strcat_dyn_buf(&output_buf, " Current firmware revision: %.8s\n",
169  p_dev_info->fw_rev);
170  strcat_dyn_buf(&output_buf, " NOR flash firmware revision: %.8s\n",
171  p_dev_info->fw_rev_nor_flash);
172  strcat_dyn_buf(&output_buf, " F/W & S/W compatibility: %s\n",
173  p_dev_info->fw_ver_compat_warning ?
174  "no, possible missing features" : "yes");
175  strcat_dyn_buf(&output_buf, " F/W branch: %s\n",
176  p_dev_info->fw_branch_name);
177  strcat_dyn_buf(&output_buf, " F/W commit time: %s\n",
178  p_dev_info->fw_commit_time);
179  strcat_dyn_buf(&output_buf, " F/W commit hash: %s\n",
180  p_dev_info->fw_commit_hash);
181  strcat_dyn_buf(&output_buf, " F/W build time: %s\n",
182  p_dev_info->fw_build_time);
183  strcat_dyn_buf(&output_buf, " F/W build id: %s\n",p_dev_info->fw_build_id);
184  strcat_dyn_buf(&output_buf, " DeviceID: %s\n", p_dev_info->dev_name);
185  strcat_dyn_buf(&output_buf, " PixelFormats: yuv420p, yuv420p10le, nv12, p010le"
186  ", ni_quadra\n");
187 
188  for (size_t dev_type = NI_DEVICE_TYPE_DECODER;
189  dev_type != NI_DEVICE_TYPE_XCODER_MAX; dev_type++)
190  {
191  for (int xcoder_index_2 = 0;
192  xcoder_index_2 < p_device->xcoder_cnt[NI_DEVICE_TYPE_ENCODER];
193  xcoder_index_2++)
194  {
195  if (strcmp(p_dev_info->dev_name,
196  p_device->xcoders[dev_type][xcoder_index_2].dev_name)
197  == 0 && p_dev_info->module_id >= 0)
198  {
199  const ni_device_info_t *p_device_info =
200  &(p_device->xcoders[dev_type][xcoder_index_2]);
201  int i;
202 
203  if (!p_device_info)
204  {
205  ni_log(NI_LOG_ERROR, "ERROR: Cannot print device info!\n");
206  } else
207  {
208  strcat_dyn_buf(&output_buf, " %s #%d\n",
209  GET_XCODER_DEVICE_TYPE_STR(p_device_info->device_type),
210  p_device_info->module_id);
211  strcat_dyn_buf(&output_buf, " H/W ID: %d\n", p_device_info->hw_id);
212  strcat_dyn_buf(&output_buf, " MaxNumInstances: %d\n",
213  p_device_info->max_instance_cnt);
214 
215  if (NI_DEVICE_TYPE_SCALER == p_device_info->device_type)
216  {
217  strcat_dyn_buf(&output_buf, " Capabilities:\n");
218  strcat_dyn_buf(&output_buf,
219  " Operations: Crop (ni_quadra_crop), Scale (ni_quadra_scale), Pad "
220  "(ni_quadra_pad), Overlay (ni_quadra_overlay)\n"
221  " Drawbox (ni_quadra_drawbox), Rotate (ni_quadra_rotate), XStack (ni_quadra_xstack)\n");
222  } else if (NI_DEVICE_TYPE_AI == p_device_info->device_type)
223  {
224  strcat_dyn_buf(&output_buf, " Capabilities:\n");
225  strcat_dyn_buf(&output_buf,
226  " Operations: ROI (ni_quadra_roi), Background Replace (ni_quadra_bg)\n");
227  } else if (NI_DEVICE_TYPE_DECODER == p_device_info->device_type ||
228  NI_DEVICE_TYPE_ENCODER == p_device_info->device_type)
229  {
230  strcat_dyn_buf(&output_buf, " Max4KFps: %d\n", p_device_info->max_fps_4k);
231  for (i = 0; i < EN_CODEC_MAX; i++)
232  {
233  if (EN_INVALID != p_device_info->dev_cap[i].supports_codec)
234  {
235  strcat_dyn_buf(&output_buf, " %s ",
236  ni_codec_format_str[p_device_info->dev_cap[i]
237  .supports_codec]);
238  strcat_dyn_buf(&output_buf, "(%s) Capabilities:\n",
240  p_device_info->device_type ?
241  ni_dec_name_str[p_device_info->dev_cap[i]
242  .supports_codec] :
243  ni_enc_name_str[p_device_info->dev_cap[i]
244  .supports_codec]);
245  strcat_dyn_buf(&output_buf, " MaxResolution: %dx%d\n",
246  p_device_info->dev_cap[i].max_res_width,
247  p_device_info->dev_cap[i].max_res_height);
248  strcat_dyn_buf(&output_buf, " MinResolution: %dx%d\n",
249  p_device_info->dev_cap[i].min_res_width,
250  p_device_info->dev_cap[i].min_res_height);
251 
252  // no profile for JPEG encode, or level for JPEG
253  if (! (NI_DEVICE_TYPE_ENCODER == p_device_info->device_type &&
254  EN_JPEG == p_device_info->dev_cap[i].supports_codec))
255  {
256  strcat_dyn_buf(&output_buf, " Profiles: %s\n",
257  p_device_info->dev_cap[i].profiles_supported);
258  }
259  if (EN_JPEG != p_device_info->dev_cap[i].supports_codec)
260  {
261  strcat_dyn_buf(&output_buf, " Level: %s\n",
262  p_device_info->dev_cap[i].level);
263  }
264  }
265  }
266  }
267  }
268  }
269  }
270  }
271  }
272 if (output_buf.str_buf)
273  printf("%s", output_buf.str_buf);
274  clear_dyn_str_buf(&output_buf);
275 }
276 
277 static void print_full_text(ni_device_t *p_device)
278 {
279  if (!p_device)
280  {
281  ni_log(NI_LOG_INFO, "WARNING: NULL parameter passed in!\n");
282  return;
283  }
284 
285  dyn_str_buf_t output_buf = {0};
286  ni_device_info_t *p_dev_info = NULL;
287  for (int xcoder_index_1 = 0;
288  xcoder_index_1 < p_device->xcoder_cnt[NI_DEVICE_TYPE_ENCODER];
289  xcoder_index_1++)
290  {
291  p_dev_info = &p_device->xcoders[NI_DEVICE_TYPE_ENCODER][xcoder_index_1];
292  strcat_dyn_buf(&output_buf, "Device #%d:\n", xcoder_index_1);
293  strcat_dyn_buf(&output_buf, " Serial number: %.*s\n",
294  (int)sizeof(p_dev_info->serial_number),
295  p_dev_info->serial_number);
296  strcat_dyn_buf(&output_buf, " Model number: %.*s\n",
297  (int)sizeof(p_dev_info->model_number),
298  p_dev_info->model_number);
299  strcat_dyn_buf(&output_buf, " Last ran firmware loader version: %.8s\n",
300  p_dev_info->fl_ver_last_ran);
301  strcat_dyn_buf(&output_buf, " NOR flash firmware loader version: %.8s\n",
302  p_dev_info->fl_ver_nor_flash);
303  strcat_dyn_buf(&output_buf, " Current firmware revision: %.8s\n",
304  p_dev_info->fw_rev);
305  strcat_dyn_buf(&output_buf, " NOR flash firmware revision: %.8s\n",
306  p_dev_info->fw_rev_nor_flash);
307  strcat_dyn_buf(&output_buf, " F/W & S/W compatibility: %s\n",
308  p_dev_info->fw_ver_compat_warning ?
309  "no, possible missing features" : "yes");
310  strcat_dyn_buf(&output_buf, " F/W branch: %s\n",
311  p_dev_info->fw_branch_name);
312  strcat_dyn_buf(&output_buf, " F/W commit time: %s\n",
313  p_dev_info->fw_commit_time);
314  strcat_dyn_buf(&output_buf, " F/W commit hash: %s\n",
315  p_dev_info->fw_commit_hash);
316  strcat_dyn_buf(&output_buf, " F/W build time: %s\n",
317  p_dev_info->fw_build_time);
318  strcat_dyn_buf(&output_buf, " F/W build id: %s\n",p_dev_info->fw_build_id);
319  strcat_dyn_buf(&output_buf, " DeviceID: %s\n", p_dev_info->dev_name);
320 
321  for (size_t dev_type = NI_DEVICE_TYPE_DECODER;
322  dev_type != NI_DEVICE_TYPE_XCODER_MAX; dev_type++)
323  {
324  for (int xcoder_index_2 = 0;
325  xcoder_index_2 < p_device->xcoder_cnt[NI_DEVICE_TYPE_ENCODER];
326  xcoder_index_2++)
327  {
328  if (strcmp(p_dev_info->dev_name,
329  p_device->xcoders[dev_type][xcoder_index_2].dev_name)
330  == 0 && p_dev_info->module_id >= 0)
331  {
332  const ni_device_info_t *p_device_info =
333  &(p_device->xcoders[dev_type][xcoder_index_2]);
334  int i;
335 
336  if (!p_device_info)
337  {
338  ni_log(NI_LOG_ERROR, "ERROR: Cannot print device info!\n");
339  } else
340  {
341  strcat_dyn_buf(&output_buf, " %s #%d\n",
342  GET_XCODER_DEVICE_TYPE_STR(p_device_info->device_type),
343  p_device_info->module_id);
344  strcat_dyn_buf(&output_buf, " H/W ID: %d\n", p_device_info->hw_id);
345  strcat_dyn_buf(&output_buf, " MaxNumInstances: %d\n",
346  p_device_info->max_instance_cnt);
347 
348  if (NI_DEVICE_TYPE_SCALER == p_device_info->device_type)
349  {
350  strcat_dyn_buf(&output_buf, " Capabilities:\n");
351  strcat_dyn_buf(&output_buf,
352  " Operations: Crop (ni_quadra_crop), Scale (ni_quadra_scale), Pad "
353  "(ni_quadra_pad), Overlay (ni_quadra_overlay)\n"
354  " Drawbox (ni_quadra_drawbox), Rotate (ni_quadra_rotate), XStack (ni_quadra_xstack)\n"
355  " Delogo (ni_quadra_delogo), Merge (ni_quadra_merge), Flip (ni_quadra_flip)\n"
356  " Drawtext (ni_quadra_drawtext)\n");
357  } else if (NI_DEVICE_TYPE_AI == p_device_info->device_type)
358  {
359  strcat_dyn_buf(&output_buf, " Capabilities:\n");
360  strcat_dyn_buf(&output_buf, " Cores: 2\n");
361  strcat_dyn_buf(&output_buf, " Computing Power: int8 18 tops\n");
362  strcat_dyn_buf(&output_buf,
363  " Operations: ROI (ni_quadra_roi), Background Replace (ni_quadra_bg), Ai Pre-processing (ni_quadra_ai_pre)\n"
364  " Background Remove (ni_quadra_bgr), Hvsplus (ni_quadra_hvsplus)\n");
365  } else if (NI_DEVICE_TYPE_DECODER == p_device_info->device_type ||
366  NI_DEVICE_TYPE_ENCODER == p_device_info->device_type)
367  {
368  strcat_dyn_buf(&output_buf, " Max4KFps: %d\n", p_device_info->max_fps_4k);
369  for (i = 0; i < EN_CODEC_MAX; i++)
370  {
371  if (EN_INVALID != p_device_info->dev_cap[i].supports_codec)
372  {
373  strcat_dyn_buf(&output_buf, " %s ",
374  ni_codec_format_str[p_device_info->dev_cap[i]
375  .supports_codec]);
376  strcat_dyn_buf(&output_buf, "(%s) Capabilities:\n",
378  p_device_info->device_type ?
379  ni_dec_name_str[p_device_info->dev_cap[i]
380  .supports_codec] :
381  ni_enc_name_str[p_device_info->dev_cap[i]
382  .supports_codec]);
383  if (NI_DEVICE_TYPE_DECODER == p_device_info->device_type)
384  {
385  switch (p_device_info->dev_cap[i].supports_codec)
386  {
387  case EN_H264:
388  case EN_H265:
389  case EN_VP9:
390  strcat_dyn_buf(&output_buf, " PixelFormats: "
391  "yuv420p, yuv420p10le, nv12, p010le, ni_quad\n");
392  break;
393  case EN_JPEG:
394  strcat_dyn_buf(&output_buf, " PixelFormats: "
395  "yuvj420p, ni_quad\n");
396  break;
397  case EN_AV1:
398  default:
399  break;
400  }
401  }
402  else
403  {
404  switch (p_device_info->dev_cap[i].supports_codec)
405  {
406  case EN_H264:
407  case EN_H265:
408  case EN_AV1:
409  strcat_dyn_buf(&output_buf, " PixelFormats: "
410  "yuv420p, yuvj420p, yuv420p10le, nv12, p010le, ni_quad\n");
411  break;
412  case EN_JPEG:
413  strcat_dyn_buf(&output_buf, " PixelFormats: "
414  "yuvj420p, ni_quad\n");
415  break;
416  case EN_VP9:
417  default:
418  break;
419  }
420  }
421  strcat_dyn_buf(&output_buf, " MaxResolution: %dx%d\n",
422  p_device_info->dev_cap[i].max_res_width,
423  p_device_info->dev_cap[i].max_res_height);
424  strcat_dyn_buf(&output_buf, " MinResolution: %dx%d\n",
425  p_device_info->dev_cap[i].min_res_width,
426  p_device_info->dev_cap[i].min_res_height);
427 
428  // no profile for JPEG encode, or level for JPEG
429  if (! (NI_DEVICE_TYPE_ENCODER == p_device_info->device_type &&
430  EN_JPEG == p_device_info->dev_cap[i].supports_codec))
431  {
432  strcat_dyn_buf(&output_buf, " Profiles: %s\n",
433  p_device_info->dev_cap[i].profiles_supported);
434  }
435  if (EN_JPEG != p_device_info->dev_cap[i].supports_codec)
436  {
437  strcat_dyn_buf(&output_buf, " Level: %s\n",
438  p_device_info->dev_cap[i].level);
439  }
440  }
441  }
442  }
443  }
444  }
445  }
446  }
447  }
448  if (output_buf.str_buf)
449  printf("%s", output_buf.str_buf);
450  clear_dyn_str_buf(&output_buf);
451 }
452 
453 static void print_json(ni_device_t *p_device)
454 {
455  if (!p_device)
456  {
457  ni_log(NI_LOG_INFO, "WARNING: NULL parameter passed in!\n");
458  return;
459  }
460 
461  dyn_str_buf_t output_buf = {0};
462  ni_device_info_t *p_dev_info = NULL;
463  strcat_dyn_buf(&output_buf,"{\n");
464  for (int xcoder_index_1 = 0;
465  xcoder_index_1 < p_device->xcoder_cnt[NI_DEVICE_TYPE_ENCODER];
466  xcoder_index_1++)
467  {
468  p_dev_info = &p_device->xcoders[NI_DEVICE_TYPE_ENCODER][xcoder_index_1];
469  strcat_dyn_buf(&output_buf, " \"Device #%d\": [\n", xcoder_index_1);
470  strcat_dyn_buf(&output_buf, "\t{\n"
471  "\t\t\"Serial number\": \"%.*s\",\n"
472  "\t\t\"Model number:\": \"%.*s\",\n"
473  "\t\t\"Last ran firmware loader version\": \"%.8s\",\n"
474  "\t\t\"NOR flash firmware loader version\": \"%.8s\",\n"
475  "\t\t\"Current firmware revision\": \"%.8s\",\n"
476  "\t\t\"NOR flash firmware revision\": \"%.8s\",\n"
477  "\t\t\"F/W & S/W compatibility\": \"%s\",\n"
478  "\t\t\"F/W branch\": \"%s\",\n"
479  "\t\t\"F/W commit time\": \"%s\",\n"
480  "\t\t\"F/W commit hash\": \"%s\",\n"
481  "\t\t\"F/W build time\": \"%s\",\n"
482  "\t\t\"F/W build id\": \"%s\",\n"
483  "\t\t\"DeviceID\": \"%s\",\n"
484  , (int)sizeof(p_dev_info->serial_number), p_dev_info->serial_number,
485  (int)sizeof(p_dev_info->model_number), p_dev_info->model_number,
486  p_dev_info->fl_ver_last_ran, p_dev_info->fl_ver_nor_flash,
487  p_dev_info->fw_rev, p_dev_info->fw_rev_nor_flash,
488  p_dev_info->fw_ver_compat_warning ? "no, possible missing features" : "yes",
489  p_dev_info->fw_branch_name, p_dev_info->fw_commit_time,
490  p_dev_info->fw_commit_hash, p_dev_info->fw_build_time,
491  p_dev_info->fw_build_id, p_dev_info->dev_name);
492  for (size_t dev_type = NI_DEVICE_TYPE_DECODER;
493  dev_type != NI_DEVICE_TYPE_XCODER_MAX; dev_type++)
494  {
495  for (int xcoder_index_2 = 0;
496  xcoder_index_2 < p_device->xcoder_cnt[NI_DEVICE_TYPE_ENCODER];
497  xcoder_index_2++)
498  {
499  if (strcmp(p_dev_info->dev_name,
500  p_device->xcoders[dev_type][xcoder_index_2].dev_name)
501  == 0 && p_dev_info->module_id >= 0)
502  {
503  const ni_device_info_t *p_device_info =
504  &(p_device->xcoders[dev_type][xcoder_index_2]);
505  int i;
506 
507  if (!p_device_info)
508  {
509  ni_log(NI_LOG_ERROR, "ERROR: Cannot print device info!\n");
510  } else
511  {
512  strcat_dyn_buf(&output_buf, "\t\t\"%s #%d\": [\n",
513  GET_XCODER_DEVICE_TYPE_STR(p_device_info->device_type),
514  p_device_info->module_id);
515  strcat_dyn_buf(&output_buf, "\t\t\t{\n");
516  strcat_dyn_buf(&output_buf, "\t\t\t\t\"H/W ID\": %d,\n"
517  "\t\t\t\t\"MaxNumInstances\": %d,\n"
518  , p_device_info->hw_id,
519  p_device_info->max_instance_cnt);
520  if (NI_DEVICE_TYPE_SCALER == p_device_info->device_type)
521  {
522  strcat_dyn_buf(&output_buf, "\t\t\t\t\"Capabilities\": [\n");
523  strcat_dyn_buf(&output_buf, "\t\t\t\t\t{\n");
524  strcat_dyn_buf(&output_buf, "\t\t\t\t\t\t\"Operations\": "
525  "\"Crop (ni_quadra_crop), Scale (ni_quadra_scale), Pad "
526  "(ni_quadra_pad), Overlay (ni_quadra_overlay), "
527  "Drawbox (ni_quadra_drawbox), Rotate (ni_quadra_rotate), "
528  "XStack (ni_quadra_xstack), Delogo (ni_quadra_delogo), "
529  "Merge (ni_quadra_merge), Flip (ni_quadra_flip), "
530  "Drawtext (ni_quadra_drawtext)\"\n");
531  strcat_dyn_buf(&output_buf, "\t\t\t\t\t}\n\t\t\t\t]\n");
532  strcat_dyn_buf(&output_buf, "\t\t\t}\n\t\t],\n");
533  } else if (NI_DEVICE_TYPE_AI == p_device_info->device_type)
534  {
535  strcat_dyn_buf(&output_buf, "\t\t\t\t\"Capabilities\": [\n");
536  strcat_dyn_buf(&output_buf, "\t\t\t\t\t{\n");
537  strcat_dyn_buf(&output_buf, "\t\t\t\t\t\t\"Cores\": 2,\n"
538  "\t\t\t\t\t\t\"Computing Power\": \"int8 18 tops\",\n"
539  "\t\t\t\t\t\t\"Operations\": "
540  "\"ROI (ni_quadra_roi), Background Replace (ni_quadra_bg), "
541  "Ai Pre-processing (ni_quadra_ai_pre), "
542  "Background Remove (ni_quadra_bgr), Hvsplus (ni_quadra_hvsplus)\"\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_DECODER == p_device_info->device_type ||
546  NI_DEVICE_TYPE_ENCODER == p_device_info->device_type)
547  {
548  strcat_dyn_buf(&output_buf, "\t\t\t\t\"Max4KFps\": %d,\n",
549  p_device_info->max_fps_4k);
550  for (i = 0; i < EN_CODEC_MAX; i++)
551  {
552  if (EN_INVALID != p_device_info->dev_cap[i].supports_codec)
553  {
554  strcat_dyn_buf(&output_buf, "\t\t\t\t\"%s (%s) Capabilities\": [\n",
555  ni_codec_format_str[p_device_info->dev_cap[i].supports_codec],
556  NI_DEVICE_TYPE_DECODER == p_device_info->device_type ?
557  ni_dec_name_str[p_device_info->dev_cap[i].supports_codec] :
558  ni_enc_name_str[p_device_info->dev_cap[i].supports_codec]);
559  strcat_dyn_buf(&output_buf, "\t\t\t\t\t{\n");
560  if (NI_DEVICE_TYPE_DECODER == p_device_info->device_type)
561  {
562  switch (p_device_info->dev_cap[i].supports_codec)
563  {
564  case EN_H264:
565  case EN_H265:
566  case EN_VP9:
567  strcat_dyn_buf(&output_buf, "\t\t\t\t\t\t\"PixelFormats\": "
568  "\"yuv420p, yuv420p10le, nv12, p010le, ni_quad\",\n");
569  break;
570  case EN_JPEG:
571  strcat_dyn_buf(&output_buf, "\t\t\t\t\t\t\"PixelFormats\": "
572  "\"yuvj420p, ni_quad\",\n");
573  break;
574  case EN_AV1:
575  default:
576  break;
577  }
578  }
579  else
580  {
581  switch (p_device_info->dev_cap[i].supports_codec)
582  {
583  case EN_H264:
584  case EN_H265:
585  case EN_AV1:
586  strcat_dyn_buf(&output_buf, "\t\t\t\t\t\t\"PixelFormats\": "
587  "\"yuv420p, yuvj420p, 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_VP9:
594  default:
595  break;
596  }
597  }
598  strcat_dyn_buf(&output_buf, "\t\t\t\t\t\t\"MaxResolution\": \"%dx%d\",\n"
599  "\t\t\t\t\t\t\"MinResolution\": \"%dx%d\""
600  ,p_device_info->dev_cap[i].max_res_width,
601  p_device_info->dev_cap[i].max_res_height,
602  p_device_info->dev_cap[i].min_res_width,
603  p_device_info->dev_cap[i].min_res_height);
604  // no profile for JPEG encode, or level for JPEG
605  if (! (NI_DEVICE_TYPE_ENCODER == p_device_info->device_type &&
606  EN_JPEG == p_device_info->dev_cap[i].supports_codec))
607  {
608  strcat_dyn_buf(&output_buf, ",\n\t\t\t\t\t\t\"Profiles\": \"%s\"",
609  p_device_info->dev_cap[i].profiles_supported);
610  }
611  if (EN_JPEG != p_device_info->dev_cap[i].supports_codec)
612  {
613  strcat_dyn_buf(&output_buf, ",\n\t\t\t\t\t\t\"Level\": \"%s\"",
614  p_device_info->dev_cap[i].level);
615  }
616  if ((NI_DEVICE_TYPE_DECODER == p_device_info->device_type &&
617  EN_VP9 == p_device_info->dev_cap[i].supports_codec) ||
618  (NI_DEVICE_TYPE_ENCODER == p_device_info->device_type &&
619  EN_AV1 == p_device_info->dev_cap[i].supports_codec))
620  {
621  strcat_dyn_buf(&output_buf, "\n\t\t\t\t\t}\n\t\t\t\t]\n");
622  }
623  else
624  {
625  strcat_dyn_buf(&output_buf, "\n\t\t\t\t\t}\n\t\t\t\t],\n");
626  }
627  }
628  }
629  strcat_dyn_buf(&output_buf, "\t\t\t}\n\t\t],\n");
630  }
631  }
632  }
633  }
634  }
635  if (xcoder_index_1 == p_device->xcoder_cnt[NI_DEVICE_TYPE_ENCODER] - 1)
636  strcat_dyn_buf(&output_buf, "\t}\n ]\n");
637  else
638  strcat_dyn_buf(&output_buf, "\t}\n ],\n");
639  }
640  strcat_dyn_buf(&output_buf,"}\n");
641  if (output_buf.str_buf)
642  printf("%s", output_buf.str_buf);
643  clear_dyn_str_buf(&output_buf);
644 }
645 
646 
647 int32_t main(int argc, char *argv[])
648 {
649  int opt;
650  bool list_uninitialized = false;
651  ni_log_level_t log_level = NI_LOG_INFO;
652  int printFormat = FMT_TEXT;
653 
654  // arg handling
655  while ((opt = getopt(argc, argv, "ahvlo:")) != -1)
656  {
657  switch (opt)
658  {
659  case 'a':
660  list_uninitialized = true;
661  break;
662  case 'h':
663  // help message
664  printf("-------- ni_rsrc_list v%s --------\n"
665  "Display information for NETINT hardware.\n"
666  "\n"
667  "-a Print includes info for uninitialized cards.\n"
668  "-h Display this help and exit.\n"
669  "-v Print version info.\n"
670  "-o Output format. [text, full, json]\n"
671  " Default: text\n"
672  "-l Set loglevel of libxcoder API.\n"
673  " [none, fatal, error, info, debug, trace]\n"
674  " Default: info\n",
676  return 0;
677  case 'v':
678  printf("Release ver: %s\n"
679  "API ver: %s\n"
680  "Date: %s\n"
681  "ID: %s\n",
684  return 0;
685  case 'l':
686  log_level = arg_to_ni_log_level(optarg);
687  if (log_level != NI_LOG_INVALID)
688  {
689  ni_log_set_level(log_level);
690  } else {
691  fprintf(stderr, "FATAL: invalid log level selected: %s\n",
692  optarg);
693  exit(1);
694  }
695  break;
696  case 'o':
697  // Output print format
698  if (!strcmp(optarg, "text"))
699  {
700  printFormat = FMT_TEXT;
701  }
702  else if (!strcmp(optarg, "full"))
703  {
704  printFormat = FMT_FULL_TEXT;
705  }
706  else if (!strcmp(optarg, "json"))
707  {
708  printFormat = FMT_JSON;
709  }
710  else
711  {
712  fprintf(stderr, "Error: unknown selection for outputFormat: %s\n", optarg);
713  return 1;
714  }
715  break;
716  default:
717  fprintf(stderr, "FATAL: invalid arg '%c'\n", opt);
718  return 1;
719  }
720  }
721 
722  ni_log_set_level(log_level);
723  ni_device_t *device = NULL;
724  device = (ni_device_t *)malloc(sizeof(ni_device_t));
725  if (!device)
726  {
727  ni_log(NI_LOG_ERROR, "ERROR %s() failed to malloc memory: %s\n",
728  __func__, strerror(NI_ERRNO));
729  return 1;
730  }
731  memset(device, 0, sizeof(ni_device_t));
732 
733  if (NI_RETCODE_SUCCESS != ni_rsrc_list_all_devices2(device, list_uninitialized))
734  {
735  free(device);
736  return 1;
737  }
738 
739  switch(printFormat)
740  {
741  case FMT_TEXT:
742  print_text(device);
743  break;
744  case FMT_FULL_TEXT:
745  print_full_text(device);
746  break;
747  case FMT_JSON:
748  print_json(device);
749  break;
750  }
751  free(device);
752  return 0;
753 }
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:55
_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:347
_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:1113
NI_DEVICE_TYPE_DECODER
@ NI_DEVICE_TYPE_DECODER
Definition: ni_defs.h:346
_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:427
_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:95
_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:133
_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:2056
dyn_str_buf
Definition: ni_rsrc_list.c:58
NI_LOG_INFO
@ NI_LOG_INFO
Definition: ni_log.h:61
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:60
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:349
va_list
__gnuc_va_list va_list
Definition: ni_quadra_filter_api.h:69
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:57
_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:348
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:647
NI_ERRNO
#define NI_ERRNO
Definition: ni_defs.h:217
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:633
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:1487
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:112
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:350
_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:417
_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