libxcoder  5.2.0
ni_quadra_filter_api.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_quadra_filter_api.c
24  *
25  * \brief Private definitions used by ni_quadra_filter_api.c for video processing
26  * tasks
27  ******************************************************************************/
28 #include "ni_quadra_filter_api.h"
29 #include "ni_defs.h"
30 #include "ni_rsrc_api.h"
31 #include "ni_util.h"
32 #include "ni_device_api.h"
33 #include "ni_av_codec.h"
34 #include "ni_bitstream.h"
35 
36 /*!******************************************************************************
37  * \brief Initialize a fifo buffer
38  *
39  * \param[in] number_of_buffers Total number of buffers in this fifo
40  * \param[in] size The size of every buffer
41  *
42  * \return On success return fifo pointer, On failure return NULL
43  *******************************************************************************/
44 ni_fifo_buffer_t *ni_fifo_initialize(uint32_t number_of_buffers, uint32_t size)
45 {
46  ni_fifo_buffer_t *p_fifo = NULL;
47 
48  ni_log(NI_LOG_TRACE, "%s: enter\n", __FUNCTION__);
49 
50  if ((p_fifo = (ni_fifo_buffer_t *)malloc(sizeof(ni_fifo_buffer_t))) == NULL)
51  {
52  ni_log(NI_LOG_ERROR, "Error %d: %s alloc for fifo\n", NI_ERRNO,
53  __FUNCTION__);
54  return NULL;
55  }
56 
57  //initialise the struct
58  memset(p_fifo, 0, sizeof(ni_fifo_buffer_t));
59  ni_pthread_mutex_init(&(p_fifo->mutex));
60  p_fifo->number_of_buffers = number_of_buffers;
61  p_fifo->buffer_size = size;
62 
63  // alloc fifo buffer
64  p_fifo->buffer = malloc(number_of_buffers * size);
65  if (p_fifo->buffer == NULL)
66  {
67  free(p_fifo);
68  p_fifo = NULL;
69  ni_log(NI_LOG_ERROR, "Error %d: %s alloc for fifo buffer\n", NI_ERRNO,
70  __FUNCTION__);
71  return NULL;
72  }
73  memset(p_fifo->buffer, 0, (number_of_buffers * size));
74 
75  return p_fifo;
76 }
77 
78 /*!******************************************************************************
79  * \brief Free a fifo
80  *
81  * \param[in] p_fifo The pointer of ni_fifo_buffer_t
82  *
83  * \return
84  *******************************************************************************/
86 {
87  ni_log(NI_LOG_TRACE, "%s: enter\n", __FUNCTION__);
88 
89  if (!p_fifo)
90  {
91  ni_log(NI_LOG_TRACE, "%s: null fifo, return\n", __FUNCTION__);
92  return;
93  }
94  ni_pthread_mutex_destroy(&(p_fifo->mutex));
95 
96  free(p_fifo->buffer);
97  p_fifo->buffer = NULL;
98 
99  free(p_fifo);
100 
101  return;
102 }
103 
104 /*!******************************************************************************
105  * \brief Check if a fifo is full
106  *
107  * \param[in] p_fifo The pointer of ni_fifo_buffer_t
108  *
109  * \return 1 is full; 0 is not full
110  *******************************************************************************/
112 {
113  return (p_fifo->number_of_buffers_used == p_fifo->number_of_buffers);
114 }
115 
116 /*!******************************************************************************
117  * \brief Check if a fifo is empty
118  *
119  * \param[in] p_fifo The pointer of ni_fifo_buffer_t
120  *
121  * \return 1 is empty; 0 is not empty
122  *******************************************************************************/
124 {
125  return (p_fifo->number_of_buffers_used == 0);
126 }
127 
128 /*!******************************************************************************
129  * \brief Get number of buffers used in fifo
130  *
131  * \param[in] p_fifo The pointer of ni_fifo_buffer_t
132  *
133  * \return fifo's number_of_buffers_used
134  *******************************************************************************/
136 {
137  return p_fifo->number_of_buffers_used;
138 }
139 
140 /*!******************************************************************************
141  * \brief Get free buffer to write in the fifo
142  *
143  * \param[in] p_fifo The pointer of ni_fifo_buffer_t
144  *
145  * \return On success return the pointer of free buffer,
146  * On failure return NULL
147  *******************************************************************************/
149 {
150  uint8_t *p_buffer;
151  ni_log(NI_LOG_TRACE, "%s: enter\n", __FUNCTION__);
152 
153  if (NULL == p_fifo || ni_fifo_is_full(p_fifo))
154  {
155  ni_log(NI_LOG_TRACE, "Warning pointer is null or fifo is full, %p\n",
156  p_fifo);
157  return NULL;
158  }
159 
160  ni_pthread_mutex_lock(&(p_fifo->mutex));
161 
162  p_buffer = p_fifo->buffer + p_fifo->wndx * p_fifo->buffer_size;
163  p_fifo->wndx = (p_fifo->wndx + 1) % p_fifo->number_of_buffers;
164  p_fifo->number_of_buffers_used++;
165 
166  ni_pthread_mutex_unlock(&(p_fifo->mutex));
167  return p_buffer;
168 }
169 
170 /*!******************************************************************************
171  * \brief Get first filled buffer to read in the fifo
172  *
173  * \param[in] p_fifo The pointer of ni_fifo_buffer_t
174  *
175  * \return On success return the pointer of filled buffer in fifo,
176  * On failure return NULL
177  *******************************************************************************/
179 {
180  uint8_t *p_buffer;
181  ni_log(NI_LOG_TRACE, "%s: enter\n", __FUNCTION__);
182 
183  if (NULL == p_fifo || ni_fifo_is_empty(p_fifo))
184  {
185  ni_log(NI_LOG_TRACE, "Warning pointer is null or fifo is empty, %p\n",
186  p_fifo);
187  return NULL;
188  }
189 
190  ni_pthread_mutex_lock(&(p_fifo->mutex));
191  p_buffer = p_fifo->buffer + p_fifo->rndx * p_fifo->buffer_size;
192  p_fifo->rndx = (p_fifo->rndx + 1) % p_fifo->number_of_buffers;
193  p_fifo->number_of_buffers_used--;
194 
195  ni_pthread_mutex_unlock(&(p_fifo->mutex));
196  return p_buffer;
197 }
198 
199 /*!******************************************************************************
200  * \brief Push back the last read buffer to the fifo
201  *
202  * \param[in] p_fifo The pointer of ni_fifo_buffer_t
203  *
204  * \return On success return 0,
205  * On failure return -1
206  *******************************************************************************/
208 {
209  ni_log(NI_LOG_TRACE, "%s: enter\n", __FUNCTION__);
210 
211  if (NULL == p_fifo || ni_fifo_is_full(p_fifo))
212  {
213  ni_log(NI_LOG_TRACE, "Warning pointer is null or fifo is full, %p\n",
214  p_fifo);
215  return -1;
216  }
217 
218  ni_pthread_mutex_lock(&(p_fifo->mutex));
219 
220  p_fifo->rndx =
221  p_fifo->rndx > 0 ? (p_fifo->rndx - 1) : (p_fifo->number_of_buffers - 1);
222  p_fifo->number_of_buffers_used++;
223 
224  ni_pthread_mutex_unlock(&(p_fifo->mutex));
225  return 0;
226 }
227 
229 {
230  ni_scaler_params_t *p_param = NULL;
231  ni_session_context_t *p_session_ctx = NULL;
232  ni_session_data_io_t *dst_frame = NULL;
233  ni_session_data_io_t *dst_pkt = NULL;
234 
235  int ret = NI_RETCODE_SUCCESS;
236  ni_log(NI_LOG_DEBUG, "XCoder setup device decoder\n");
237 
238  if (!nifilter->dst_frame)
239  {
240  dst_frame = malloc(sizeof(ni_session_data_io_t));
241  if (!dst_frame)
242  {
244  "ERROR %d:%s() line %d, alloc dst_frame failed\n", NI_ERRNO,
245  __FUNCTION__, __LINE__);
247  goto end;
248  } else
249  {
250  nifilter->dst_frame = dst_frame;
251  }
252  memset(dst_frame, 0, sizeof(ni_frame_t));
253  }
254  if (nifilter->device_type == NI_QUADRA_DEVICE_TYPE_AI && !nifilter->dst_pkt)
255  {
256  dst_pkt = malloc(sizeof(ni_session_data_io_t));
257  if (!dst_pkt)
258  {
260  "ERROR %d:%s() line %d, alloc dst_pkt failed\n", NI_ERRNO,
261  __FUNCTION__, __LINE__);
263  goto end;
264  } else
265  {
266  nifilter->dst_pkt = dst_pkt;
267  }
268  memset(dst_pkt, 0, sizeof(ni_packet_t));
269  }
270  // Xcoder Session Context
271  if (!nifilter->api_ctx)
272  {
273  p_session_ctx = malloc(sizeof(ni_session_context_t));
274  if (!p_session_ctx)
275  {
277  "ERROR %d:%s() line %d, alloc session context failed\n",
278  NI_ERRNO, __FUNCTION__, __LINE__);
280  goto end;
281  } else
282  {
283  nifilter->api_ctx = p_session_ctx;
285  }
286  }
287  else
288  {
289  p_session_ctx = (ni_session_context_t *)nifilter->api_ctx;
290  }
291 
292  if (ni_device_session_context_init(p_session_ctx) < 0)
293  {
294  ni_log(NI_LOG_ERROR, "ni filter session context init failure\n");
295  ret = NI_RETCODE_FAILURE;
296  goto end;
297  }
298 
299  if (nifilter->hw_action)
300  {
301  p_session_ctx->device_handle = nifilter->device_handle;
302  p_session_ctx->blk_io_handle = nifilter->blk_io_handle;
303  }
304  p_session_ctx->hw_id = nifilter->hw_id;
305  p_session_ctx->device_type = nifilter->device_type;
306  p_session_ctx->scaler_operation = nifilter->scaler_operation;
307  p_session_ctx->keep_alive_timeout = nifilter->keep_alive_timeout;
308  p_session_ctx->isP2P = nifilter->is_p2p;
309  p_session_ctx->hw_action = nifilter->hw_action;
310  ni_log(NI_LOG_ERROR, "Open filter session, hdl %d, blk_hdl %d\n",
311  p_session_ctx->device_handle, p_session_ctx->blk_io_handle);
312 
313  ret = ni_device_session_open(p_session_ctx, p_session_ctx->device_type);
314  if (ret != NI_RETCODE_SUCCESS)
315  {
316  ni_log(NI_LOG_ERROR, "Can't open device session\n");
317  ni_device_session_close(p_session_ctx, 1, p_session_ctx->device_type);
318  ni_device_session_context_clear(p_session_ctx);
319  goto end;
320  }
321  nifilter->session_opened = 1;
322  if (p_session_ctx->scaler_operation == NI_QUADRA_SCALER_OPCODE_SCALE ||
325  {
326  p_param = malloc(sizeof(ni_scaler_params_t));
327  if (!p_param)
328  {
330  "ERROR %d:%s() line %d, alloc session context failed\n",
331  NI_ERRNO, __FUNCTION__, __LINE__);
333  goto end;
334  } else
335  {
336  nifilter->params = p_param;
337  // init ni_scaler_params_t data
338  p_param->nb_inputs = 0;
339  p_param->filterblit = 0;
340  }
341  p_param->scaler_param_b = nifilter->scaler_param_b;
342  p_param->scaler_param_c = nifilter->scaler_param_c;
343  if (nifilter->scaler_param_b != 0 || nifilter->scaler_param_c != 0.75)
344  {
345  p_param->enable_scaler_params = true;
346  }
347  else
348  {
349  p_param->enable_scaler_params = false;
350  }
351 
352  if (nifilter->filterblit)
353  {
354  p_param->filterblit = nifilter->filterblit;
355  ret = ni_scaler_set_params(nifilter->api_ctx, nifilter->params);
356  if (ret < 0)
357  goto end;
358  }
359  }
360 
361  return ret;
362 end:
363  if (ret != NI_RETCODE_SUCCESS)
364  {
365  if (p_session_ctx)
366  free(p_session_ctx);
367  nifilter->api_ctx = NULL;
368  if (p_param)
369  free(p_param);
370  nifilter->params = NULL;
371  if (dst_frame)
372  free(dst_frame);
373  nifilter->dst_frame = NULL;
374  if (nifilter->dst_pkt)
375  free(nifilter->dst_pkt);
376  nifilter->dst_pkt = NULL;
377  }
378  return ret;
379 }
380 
382  int height, int out_format, int pool_size)
383 {
384  ni_session_context_t *p_session_ctx = nifilter->api_ctx;
385  int ret;
386  int options;
387 
389  if (p_session_ctx->isP2P)
390  {
391  options |= NI_SCALER_FLAG_P2;
392  }
393  /* Allocate a pool of frames by the scaler */
394  ret = ni_device_alloc_frame(p_session_ctx, NIALIGN(width, 2),
395  NIALIGN(height, 2), out_format, options,
396  0, // rec width
397  0, // rec height
398  0, // rec X pos
399  0, // rec Y pos
400  pool_size, // rgba color/pool size
401  0, // frame index
403  return ret;
404 }
405 
407  int video_width, int video_height,
408  int extra_len)
409 {
410  ni_session_data_io_t *niframe = nifilter->dst_frame;
411  return ni_frame_buffer_alloc_hwenc(&niframe->data.frame, video_width,
412  video_height, extra_len);
413 }
414 
416  int height, int format, int options,
417  int rectangle_width,
418  int rectangle_height, int rectangle_x,
419  int rectangle_y, int rgba_color,
420  int frame_index, int type)
421 {
422  ni_session_context_t *p_session_ctx = nifilter->api_ctx;
423  return ni_device_alloc_frame(p_session_ctx, width, height, format, options,
424  rectangle_width, rectangle_height, rectangle_x,
425  rectangle_y, rgba_color, frame_index, type);
426 }
427 
429  niquadraFrameSurface1_t *p_hwdesc,
430  int type)
431 {
432  ni_session_context_t *p_session_ctx = nifilter->api_ctx;
433  return ni_device_alloc_dst_frame(p_session_ctx,
434  (niFrameSurface1_t *)p_hwdesc,
435  type);
436 }
437 
439  ni_quadra_filter_t *nifilter,
440  ni_quadra_frameclone_desc_t *p_frameclone_desc)
441 {
442  ni_session_context_t *p_session_ctx = nifilter->api_ctx;
443  return ni_device_clone_hwframe(p_session_ctx,
444  (ni_frameclone_desc_t *)p_frameclone_desc);
445 }
446 
447 int ni_quadra_device_session_read_hwdesc(void *p_ctx, void *p_data,
448  int device_type)
449 {
450  ni_session_context_t *p_session_ctx = p_ctx;
451  ni_session_data_io_t *niframe = p_data;
452  return ni_device_session_read_hwdesc(p_session_ctx, niframe, device_type);
453 }
454 
455 int ni_quadra_device_session_read(void *p_ctx, void *p_data,
456  int device_type)
457 {
458  ni_session_context_t *p_session_ctx = p_ctx;
459  ni_session_data_io_t *ni_pkt = p_data;
460  return ni_device_session_read(p_session_ctx, ni_pkt, device_type);
461 }
462 
465 {
466  ni_session_context_t *p_session_ctx = nifilter->api_ctx;
467  return ni_scaler_set_drawbox_params(p_session_ctx, (ni_scaler_drawbox_params_t *)p_params);
468 }
469 
472 {
473  ni_session_context_t *p_session_ctx = nifilter->api_ctx;
474  return ni_scaler_set_watermark_params(p_session_ctx, (ni_scaler_watermark_params_t* )p_params);
475 }
476 
478  uint8_t *data, int width, int height)
479 {
480  ni_session_data_io_t *niframe = nifilter->dst_frame;
481  niFrameSurface1_t *frame_surface = (niFrameSurface1_t *)data;
482  niFrameSurface1_t *new_frame_surface = (niFrameSurface1_t *)niframe->data.frame.p_data[3];
483  frame_surface->ui16FrameIdx = new_frame_surface->ui16FrameIdx;
484  frame_surface->ui16session_ID = new_frame_surface->ui16session_ID;
485  frame_surface->device_handle = new_frame_surface->device_handle;
486  frame_surface->output_idx = new_frame_surface->output_idx;
487  frame_surface->src_cpu = new_frame_surface->src_cpu;
488  frame_surface->dma_buf_fd = 0;
489  frame_surface->ui32nodeAddress = 0;
490  frame_surface->ui16width = width;
491  frame_surface->ui16height = height;
492  return 0;
493 }
494 
495 uint8_t *ni_quadra_filter_get_data3(void *p_frame)
496 {
497  ni_session_data_io_t *niframe = p_frame;
498  return niframe->data.frame.p_data[3];
499 }
500 
502 {
503  int ret = 0;
504  if (!*niframe)
505  {
506  ni_session_data_io_t *p_data = NULL;
507  *niframe = malloc(sizeof(ni_session_data_io_t));
508  if (!*niframe)
509  {
511  "ERROR %d:%s() line %d, alloc session data failed\n",
512  NI_ERRNO, __FUNCTION__, __LINE__);
514  }
515  memset(*niframe, 0, sizeof(ni_session_data_io_t));
516  }
517  return ret;
518 }
519 
520 int ni_quadra_filter_frame_buffer_alloc_dl(void *niframe, int video_width,
521  int video_height, int pixel_format)
522 {
523  ni_session_data_io_t *p_frame = niframe;
524 
525  return ni_frame_buffer_alloc_dl(&(p_frame->data.frame), video_width,
526  video_height, pixel_format);
527 }
528 
530 {
531  ni_session_context_t *p_session_ctx = nifilter->api_ctx;
532  ni_session_data_io_t *niframe = nifilter->dst_frame;
533 // ni_scaler_params_t *p_param = nifilter->params;
534  if (niframe && niframe->data.frame.p_buffer)
535  ni_frame_buffer_free(&niframe->data.frame);
536 
537  if (nifilter->dl_frame)
538  {
539  ni_session_data_io_t *p_frame = nifilter->dl_frame;
540  ni_frame_buffer_free(&p_frame->data.frame);
541  if (nifilter->dl_frame)
542  free(nifilter->dl_frame);
543  }
544  if (nifilter->txt_frame)
545  {
546  ni_session_data_io_t *p_frame = nifilter->txt_frame;
547  ni_frame_buffer_free(&p_frame->data.frame);
548  if (nifilter->txt_frame)
549  free(nifilter->txt_frame);
550  }
551  if (nifilter->dst_pkt)
552  {
553  ni_session_data_io_t *p_packet = nifilter->dst_pkt;
554  ni_packet_buffer_free(&p_packet->data.packet);
555  if (nifilter->dst_pkt)
556  free(nifilter->dst_pkt);
557  }
558  if (nifilter->session_opened)
559  {
560  /* Close operation will free the device frames */
561  ni_device_session_close(p_session_ctx, 1, nifilter->device_type);
562  ni_device_session_context_clear(p_session_ctx);
563  }
564  if (nifilter->api_ctx)
565  free(nifilter->api_ctx);
566  if (nifilter->dst_frame)
567  free(nifilter->dst_frame);
568  if (nifilter->params)
569  free(nifilter->params);
570  nifilter->api_ctx = NULL;
571  nifilter->params = NULL;
572  nifilter->dst_frame = NULL;
573 }
574 
576  ni_quadra_network_data_t *p_network,
577  const char *file)
578 {
579  ni_session_context_t *p_session_ctx = nifilter->api_ctx;
580  return ni_ai_config_network_binary(p_session_ctx, (ni_network_data_t *)p_network, file);
581 }
582 
584  ni_quadra_network_data_t *p_network,
585  int nb_width,
586  int nb_height,
587  int level,
588  int format)
589 {
590  ni_session_context_t *p_session_ctx = nifilter->api_ctx;
591 
592  p_session_ctx->active_video_width = nb_width;
593  p_session_ctx->active_video_height = nb_height;
594  p_session_ctx->hvsplus_level = level;
595  p_session_ctx->pixel_format = format;
596 
597  return ni_ai_config_hvsplus(p_session_ctx, (ni_network_data_t *)p_network);
598 }
599 
601  ni_quadra_network_data_t *p_network)
602 {
603  ni_session_data_io_t *p_dst_frame = p_frame;
604  return ni_ai_frame_buffer_alloc(&p_dst_frame->data.frame, (ni_network_data_t *)p_network);
605 }
606 
608  ni_quadra_network_data_t *p_network)
609 {
610  ni_session_data_io_t *p_packet = p_pkt;
611  return ni_ai_packet_buffer_alloc(&p_packet->data.packet, (ni_network_data_t *)p_network);
612 }
613 
614 uint32_t
616 {
618 }
619 
621 {
623 }
624 
626  float *dst, uint32_t num,
627  ni_quadra_network_data_t *p_network,
628  uint32_t layer)
629 {
630  ni_session_data_io_t *p_packet = p_data;
631  return (int)ni_network_layer_convert_output(dst, num, &p_packet->data.packet,
632  (ni_network_data_t *)p_network, layer);
633 }
634 
635 int ni_quadra_frame_buffer_alloc_pixfmt(void *p_frame, int pixel_format,
636  int video_width, int video_height,
637  int linesize[], int alignment,
638  int extra_len)
639 {
640  ni_session_data_io_t *p_data = p_frame;
641  return ni_frame_buffer_alloc_pixfmt(&p_data->data.frame, pixel_format,
642  video_width, video_height, linesize,
643  alignment, extra_len);
644 }
645 
646 int ni_quadra_device_session_hwdl(void *p_ctx, void *p_data,
647  niquadraFrameSurface1_t *hwdesc)
648 {
649  ni_session_context_t *p_session_ctx = p_ctx;
650  ni_session_data_io_t *p_session_data = p_data;
651  return ni_device_session_hwdl(p_session_ctx, p_session_data, (niFrameSurface1_t *)hwdesc);
652 }
653 
655 {
656  ni_session_context_t *p_session_ctx = NULL;
657  ni_session_data_io_t *dst_frame = NULL;
658  int ret = NI_RETCODE_SUCCESS;
659  p_session_ctx = malloc(sizeof(ni_session_context_t));
660  if (!p_session_ctx)
661  {
663  "ERROR %d:%s() line %d, alloc session context failed\n",
664  NI_ERRNO, __FUNCTION__, __LINE__);
666  goto end;
667  } else
668  {
669  ni_ctx->api_ctx = p_session_ctx;
671  }
672  if (ni_device_session_context_init(p_session_ctx) < 0)
673  {
674  ni_log(NI_LOG_ERROR, "ni init context failure\n");
676  goto end;
677  }
678 
679  dst_frame = malloc(sizeof(ni_session_data_io_t));
680  if (!dst_frame)
681  {
682  ni_log(NI_LOG_ERROR, "ERROR %d:%s() line %d, alloc dst_frame failed\n",
683  NI_ERRNO, __FUNCTION__, __LINE__);
685  goto end;
686  } else
687  {
688  ni_ctx->src_session_io_data = dst_frame;
689  }
690  memset(dst_frame, 0, sizeof(ni_session_data_io_t));
691  return ret;
692 end:
693  if (ret != NI_RETCODE_SUCCESS)
694  {
695  free(p_session_ctx);
696  ni_ctx->api_ctx = NULL;
697  // free (p_param);
698  // nifilter->params = NULL;
699  free(dst_frame);
700  ni_ctx->src_session_io_data = NULL;
701  }
702  return ret;
703 }
704 
705 int ni_quadra_init_split_rsrc(NIFramesContext *ni_ctx, int w, int h)
706 {
707  int i;
708  int ret = NI_RETCODE_SUCCESS;
709  ni_split_context_t *p_split_ctx = (ni_split_context_t *)&ni_ctx->split_ctx;
710  memset(p_split_ctx, 0, sizeof(ni_split_context_t));
711  for (i = 0; i < 3; i++)
712  {
713  p_split_ctx->w[i] = w;
714  p_split_ctx->h[i] = h;
715  p_split_ctx->f[i] = -1;
716  }
717  return ret;
718 }
719 
721 {
722  int i;
723  if (ni_hw_ctx->uploader_handle != NI_INVALID_DEVICE_HANDLE)
724  {
725  ni_device_close(ni_hw_ctx->uploader_handle);
726  ni_hw_ctx->uploader_handle = NI_INVALID_DEVICE_HANDLE;
727  }
728  for (i = 0; i < NI_MAX_DEVICE_CNT; i++)
729  {
730  ni_device_handle_t fd = ni_hw_ctx->cards[i];
731  if (fd != NI_INVALID_DEVICE_HANDLE)
732  {
733  ni_hw_ctx->cards[i] = NI_INVALID_DEVICE_HANDLE;
734  ni_device_close(fd);
735  } else
736  {
737  break;
738  }
739  }
740 }
741 
743 {
745 }
746 
748  uint32_t pool_size,
749  uint32_t pool)
750 {
751  ni_session_context_t *p_session_ctx = ni_ctx->api_ctx;
752  return ni_device_session_init_framepool(p_session_ctx, pool_size, pool);
753 }
754 
756 {
757  ni_session_context_t *p_session_ctx = ni_ctx->api_ctx;
758  ni_session_data_io_t *p_data = ni_ctx->src_session_io_data;
759  if (ni_ctx->uploader_device_id != -2 && pool_size >= 0)
760  {
761  if(p_data)
762  {
763  if (p_data->data.frame.buffer_size ||
764  p_data->data.frame.metadata_buffer_size ||
765  p_data->data.frame.start_buffer_size)
766  {
767  ni_log(NI_LOG_DEBUG, "%s:free upload src frame buffer\n", __func__);
768  ni_frame_buffer_free(&p_data->data.frame);
769  }
770  }
771 
772  if(p_session_ctx)
773  {
774  ni_log(NI_LOG_DEBUG, "SessionID = %d!\n", p_session_ctx->session_id);
775  if (p_session_ctx->session_id != NI_INVALID_SESSION_ID)
776  {
778  }
779 
780  ni_device_session_context_clear(p_session_ctx);
781  }
782  }
783  if (ni_ctx->suspended_device_handle != -1)
784  {
785  ni_log(NI_LOG_DEBUG, "%s: close file handle =%d\n", __func__,
786  ni_ctx->suspended_device_handle);
788  ni_ctx->suspended_device_handle = -1;
789  }
790  if (ni_ctx->api_ctx)
791  {
792  free(ni_ctx->api_ctx);
793  ni_ctx->api_ctx = NULL;
794  }
795  if (ni_ctx->src_session_io_data)
796  {
797  free(ni_ctx->src_session_io_data);
798  ni_ctx->src_session_io_data = NULL;
799  }
800  if (ni_ctx->dst_frame)
801  {
802  free(ni_ctx->dst_frame);
803  ni_ctx->dst_frame = NULL;
804  }
805 
806  return 0;
807 }
808 
810  int *height, int ni_fmat, int keep_alive_time)
811 {
812  ni_session_context_t *p_session_ctx = ni_ctx->api_ctx;
813  int linesize_aligned, height_aligned;
814  linesize_aligned = *width;
815  if (QUADRA)
816  {
817  linesize_aligned = NI_VPU_CEIL(linesize_aligned, 2);
818  } else
819  {
820  linesize_aligned = ((*width + 31) / 32) * 32;
821  if (linesize_aligned < NI_MIN_WIDTH)
822  {
823  linesize_aligned = NI_MIN_WIDTH;
824  } else if (linesize_aligned > *width)
825  {
826  }
827  }
828  *width = linesize_aligned;
829 
830  height_aligned = *height;
831  if (QUADRA)
832  {
833  *height = NI_VPU_CEIL(height_aligned, 2);
834  } else
835  {
836  height_aligned = ((*height + 15) / 16) * 16;
837  if (height_aligned < NI_MIN_HEIGHT)
838  {
839  *height = NI_MIN_HEIGHT;
840  height_aligned = NI_MIN_HEIGHT;
841  } else if (height_aligned > *height)
842  {
843  *height = height_aligned;
844  }
845  }
846  p_session_ctx->active_video_width = *width;
847  p_session_ctx->active_video_height = *height;
848  switch (ni_fmat)
849  {
850  case NI_PIX_FMT_YUV420P:
851  p_session_ctx->bit_depth_factor = 1;
852  p_session_ctx->src_bit_depth = 8;
853  p_session_ctx->pixel_format = NI_PIX_FMT_YUV420P;
854  break;
856  p_session_ctx->bit_depth_factor = 2;
857  p_session_ctx->src_bit_depth = 10;
858  p_session_ctx->src_endian = NI_FRAME_LITTLE_ENDIAN;
859  p_session_ctx->pixel_format = NI_PIX_FMT_YUV420P10LE;
860  break;
861  case NI_PIX_FMT_NV12:
862  p_session_ctx->bit_depth_factor = 1;
863  p_session_ctx->src_bit_depth = 8;
864  p_session_ctx->pixel_format = NI_PIX_FMT_NV12;
865  break;
866  case NI_PIX_FMT_P010LE:
867  p_session_ctx->bit_depth_factor = 2;
868  p_session_ctx->src_bit_depth = 10;
869  p_session_ctx->pixel_format = NI_PIX_FMT_P010LE;
870  p_session_ctx->src_endian = NI_FRAME_LITTLE_ENDIAN;
871  break;
872  case NI_PIX_FMT_RGBA:
873  p_session_ctx->bit_depth_factor = 4;
874  p_session_ctx->src_bit_depth = 32;
875  p_session_ctx->src_endian = NI_FRAME_LITTLE_ENDIAN;
876  p_session_ctx->pixel_format = NI_PIX_FMT_RGBA;
877  break;
878  case NI_PIX_FMT_BGRA:
879  p_session_ctx->bit_depth_factor = 4;
880  p_session_ctx->src_bit_depth = 32;
881  p_session_ctx->src_endian = NI_FRAME_LITTLE_ENDIAN;
882  p_session_ctx->pixel_format = NI_PIX_FMT_BGRA;
883  break;
884  case NI_PIX_FMT_ABGR:
885  p_session_ctx->bit_depth_factor = 4;
886  p_session_ctx->src_bit_depth = 32;
887  p_session_ctx->src_endian = NI_FRAME_LITTLE_ENDIAN;
888  p_session_ctx->pixel_format = NI_PIX_FMT_ABGR;
889  break;
890  case NI_PIX_FMT_ARGB:
891  p_session_ctx->bit_depth_factor = 4;
892  p_session_ctx->src_bit_depth = 32;
893  p_session_ctx->src_endian = NI_FRAME_LITTLE_ENDIAN;
894  p_session_ctx->pixel_format = NI_PIX_FMT_ARGB;
895  break;
896  case NI_PIX_FMT_BGR0:
897  p_session_ctx->bit_depth_factor = 4;
898  p_session_ctx->src_bit_depth = 32;
899  p_session_ctx->src_endian = NI_FRAME_LITTLE_ENDIAN;
900  p_session_ctx->pixel_format = NI_PIX_FMT_BGR0;
901  break;
902  case NI_PIX_FMT_BGRP:
903  p_session_ctx->bit_depth_factor = 1;
904  p_session_ctx->src_bit_depth = 24;
905  p_session_ctx->src_endian = NI_FRAME_LITTLE_ENDIAN;
906  p_session_ctx->pixel_format = NI_PIX_FMT_BGRP;
907  break;
908  case NI_PIX_FMT_YUYV422:
909  p_session_ctx->bit_depth_factor = 1;
910  p_session_ctx->src_bit_depth = 8;
911  p_session_ctx->src_endian = NI_FRAME_LITTLE_ENDIAN;
912  p_session_ctx->pixel_format = NI_PIX_FMT_YUYV422;
913  break;
914  case NI_PIX_FMT_UYVY422:
915  p_session_ctx->bit_depth_factor = 1;
916  p_session_ctx->src_bit_depth = 8;
917  p_session_ctx->src_endian = NI_FRAME_LITTLE_ENDIAN;
918  p_session_ctx->pixel_format = NI_PIX_FMT_UYVY422;
919  break;
920  case NI_PIX_FMT_NV16:
921  p_session_ctx->bit_depth_factor = 1;
922  p_session_ctx->src_bit_depth = 8;
923  p_session_ctx->src_endian = NI_FRAME_LITTLE_ENDIAN;
924  p_session_ctx->pixel_format = NI_PIX_FMT_NV16;
925  break;
926  default:
927  ni_log(NI_LOG_ERROR, "Pixel format not supported by device.\n");
928  return NI_RETCODE_FAILURE;
929  }
930  if (*width > NI_MAX_RESOLUTION_WIDTH ||
931  *height > NI_MAX_RESOLUTION_HEIGHT ||
932  *width * (*height) > NI_MAX_RESOLUTION_AREA)
933  {
934  ni_log(NI_LOG_ERROR, "Error XCoder resolution %dx%d not supported\n",
935  *width, *height);
936  ni_log(NI_LOG_ERROR, "Max Supported Width: %d Height %d Area %d\n",
939  return NI_RETCODE_FAILURE;
940  } else if (ni_ctx->uploader_device_id >= -1)
941  {
942  // leave it to ni_device_session_open to handle uploader session open
943  // based on api_ctx.hw_id set to proper value
944  } else
945  {
946  ni_log(NI_LOG_ERROR, "Error XCoder command line options");
947  return NI_RETCODE_FAILURE;
948  }
949  p_session_ctx->hw_id = ni_ctx->uploader_device_id;
950  p_session_ctx->keep_alive_timeout = keep_alive_time;
951  if (0 == p_session_ctx->keep_alive_timeout)
952  {
954  }
955  return 0;
956 }
957 
959  const char *device)
960 {
961  char *blk_name;
962  int i, module_id = 0, ret = 0;
963  ni_device_handle_t fd;
964  uint32_t max_io_size = 0;
965  ni_device_t *p_ni_devices = NULL;
966 
967  p_ni_devices = calloc(1, sizeof(ni_device_t));
968  if(!p_ni_devices)
969  {
970  ni_log(NI_LOG_ERROR, "could not allocate memory for p_ni_devices in %s", __func__);
971  return NI_RETCODE_FAILURE;
972  }
973 
974  ni_hw_ctx->uploader_ID =
975  -2; // -1 is auto load balance, default -2 invalid
976  ni_hw_ctx->uploader_handle = NI_INVALID_DEVICE_HANDLE;
977 
978  if (device)
979  {
980  /* parse device string and fail if incorrect */
981  ni_log(NI_LOG_DEBUG, "%s %s\n", __func__, device);
982  ni_hw_ctx->uploader_ID = atoi(device);
983  ni_log(NI_LOG_DEBUG, "%s: given uploader ID %d\n", __func__,
984  ni_hw_ctx->uploader_ID);
985  if (ni_hw_ctx->uploader_ID < -1)
986  {
987  ni_log(NI_LOG_ERROR, "%s: uploader ID %d must be >= -1.\n",
988  __func__, ni_hw_ctx->uploader_ID);
989  ret = NI_RETCODE_FAILURE;
990  LRETURN;
991  }
992  }
993 
994  for (i = 0; i < NI_MAX_DEVICE_CNT; i++)
995  {
996  ni_hw_ctx->cards[i] = NI_INVALID_DEVICE_HANDLE;
997  }
998 
999  /* Scan all cards on the host, only look at NETINT cards */
1000  if (ni_rsrc_list_all_devices(p_ni_devices) == NI_RETCODE_SUCCESS)
1001  {
1002  // Note: this only checks for Netint encoders
1003  for (i = 0; i < p_ni_devices->xcoder_cnt[NI_DEVICE_TYPE_ENCODER]; i++)
1004  {
1005  blk_name =
1006  &(p_ni_devices->xcoders[NI_DEVICE_TYPE_ENCODER][i].blk_name[0]);
1007  // one-to-one correspondence between card index and module_id
1008  module_id = p_ni_devices->xcoders[NI_DEVICE_TYPE_ENCODER][i].module_id;
1009  ni_log(NI_LOG_DEBUG, "%s blk name %s\n", __func__, blk_name);
1010  fd = ni_device_open(blk_name, &max_io_size);
1011  if (fd != NI_INVALID_DEVICE_HANDLE)
1012  {
1013  ni_hw_ctx->cards[module_id] = fd;
1014  }
1015  }
1016  } else
1017  {
1018  ret = NI_RETCODE_FAILURE;
1019  }
1020 END:
1021  free(p_ni_devices);
1022  return ret;
1023 }
1024 
1025 int ni_quadra_filter_get_buffer(NIFramesContext *ni_ctx, uint8_t **dstbuf,
1026  uint8_t **dstdata, uint32_t *data_len,
1027  int width, int height, int is_planar)
1028 {
1029  ni_session_context_t *p_session_ctx = ni_ctx->api_ctx;
1030  ni_session_data_io_t dst_session_io_data;
1031  ni_session_data_io_t *p_dst_session_data = &dst_session_io_data;
1032  int ret = NI_RETCODE_SUCCESS;
1033  // alloc dest avframe buff
1034  // alloc dest avframe buff
1035  memset(p_dst_session_data, 0, sizeof(dst_session_io_data));
1036  ret = ni_frame_buffer_alloc(&p_dst_session_data->data.frame, width, height,
1037  0, 1, // codec type does not matter, metadata exists
1038  p_session_ctx->bit_depth_factor, 1, !is_planar);
1039  if (ret != 0)
1040  {
1042  }
1043 
1044  ni_quadra_get_frame_data_len(p_dst_session_data, data_len);
1045  *dstbuf = p_dst_session_data->data.frame.p_buffer;
1046  *dstdata = p_dst_session_data->data.frame.p_data[0];
1047 
1048  ni_log(NI_LOG_DEBUG, "ni_quadra_filter_get_buffer exit\n");
1049  return ret;
1050 }
1051 
1052 void ni_quadra_filter_frame_free(void *opaque, uint8_t *data)
1053 {
1054  if (data)
1055  {
1056  niFrameSurface1_t *ni_surf = (niFrameSurface1_t *)data;
1057  if (ni_surf->ui16FrameIdx != 0)
1058  {
1059  ni_hwframe_buffer_recycle(ni_surf, ni_surf->device_handle);
1060  }
1061  ni_aligned_free(ni_surf);
1062  }
1063 }
1064 
1065 static int av_to_niframe_copy(const int dst_stride[4], ni_frame_t *dst,
1066  int width, int height, int ni_fmat, int nb_planes,
1067  const int *linesize, uint8_t **src_data)
1068 {
1069  int src_height[4], hpad[4], vpad[4];
1070  int i, j, h;
1071  uint8_t *src_line, *dst_line, YUVsample, *sample, *dest;
1072  uint16_t lastidx;
1073  bool tenBit;
1074 
1075  switch (ni_fmat)
1076  {
1077  case NI_PIX_FMT_YUV420P:
1078  hpad[0] = NIMAX(dst_stride[0] - linesize[0], 0);
1079  hpad[1] = NIMAX(dst_stride[1] - linesize[1], 0);
1080  hpad[2] = NIMAX(dst_stride[2] - linesize[2], 0);
1081  hpad[3] = 0;
1082 
1083  src_height[0] = height;
1084  src_height[1] = NIALIGN(height, 2) / 2;
1085  src_height[2] = NIALIGN(height, 2) / 2;
1086  src_height[3] = 0;
1087 
1088  vpad[0] = NIALIGN(src_height[0], 2) - src_height[0];
1089  vpad[1] = NIALIGN(src_height[1], 2) - src_height[1];
1090  vpad[2] = NIALIGN(src_height[2], 2) - src_height[2];
1091  vpad[3] = 0;
1092 
1093  tenBit = false;
1094  break;
1095 
1097  hpad[0] = NIMAX(dst_stride[0] - linesize[0], 0);
1098  hpad[1] = NIMAX(dst_stride[1] - linesize[1], 0);
1099  hpad[2] = NIMAX(dst_stride[2] - linesize[2], 0);
1100  hpad[3] = 0;
1101 
1102  src_height[0] = height;
1103  src_height[1] = NIALIGN(height, 2) / 2;
1104  src_height[2] = NIALIGN(height, 2) / 2;
1105  src_height[3] = 0;
1106 
1107  vpad[0] = NIALIGN(src_height[0], 2) - src_height[0];
1108  vpad[1] = NIALIGN(src_height[1], 2) - src_height[1];
1109  vpad[2] = NIALIGN(src_height[2], 2) - src_height[2];
1110  vpad[3] = 0;
1111 
1112  tenBit = true;
1113  break;
1114 
1115  case NI_PIX_FMT_NV12:
1116  hpad[0] = NIMAX(dst_stride[0] - linesize[0], 0);
1117  hpad[1] = NIMAX(dst_stride[1] - linesize[1], 0);
1118  hpad[2] = 0;
1119  hpad[3] = 0;
1120 
1121  src_height[0] = height;
1122  src_height[1] = NIALIGN(height, 2) / 2;
1123  src_height[2] = 0;
1124  src_height[3] = 0;
1125 
1126  vpad[0] = NIALIGN(src_height[0], 2) - src_height[0];
1127  vpad[1] = NIALIGN(src_height[1], 2) - src_height[1];
1128  vpad[2] = 0;
1129  vpad[3] = 0;
1130 
1131  tenBit = false;
1132  break;
1133  case NI_PIX_FMT_NV16:
1134  hpad[0] = 0;
1135  hpad[1] = 0;
1136  hpad[2] = 0;
1137  hpad[3] = 0;
1138 
1139  src_height[0] = height;
1140  src_height[1] = height;
1141  src_height[2] = 0;
1142  src_height[3] = 0;
1143 
1144  vpad[0] = 0;
1145  vpad[1] = 0;
1146  vpad[2] = 0;
1147  vpad[3] = 0;
1148 
1149  tenBit = false;
1150  break;
1151 
1152  case NI_PIX_FMT_P010LE:
1153  hpad[0] = NIMAX(dst_stride[0] - linesize[0], 0);
1154  hpad[1] = NIMAX(dst_stride[1] - linesize[1], 0);
1155  hpad[2] = 0;
1156  hpad[3] = 0;
1157 
1158  src_height[0] = height;
1159  src_height[1] = NIALIGN(height, 2) / 2;
1160  src_height[2] = 0;
1161  src_height[3] = 0;
1162 
1163  vpad[0] = NIALIGN(src_height[0], 2) - src_height[0];
1164  vpad[1] = NIALIGN(src_height[1], 2) - src_height[1];
1165  vpad[2] = 0;
1166  vpad[3] = 0;
1167 
1168  tenBit = true;
1169  break;
1170 
1171  case NI_PIX_FMT_RGBA:
1172  case NI_PIX_FMT_BGRA:
1173  case NI_PIX_FMT_ABGR:
1174  case NI_PIX_FMT_ARGB:
1175  case NI_PIX_FMT_BGR0:
1176  hpad[0] = NIMAX(dst_stride[0] - linesize[0], 0);
1177  hpad[1] = 0;
1178  hpad[2] = 0;
1179  hpad[3] = 0;
1180 
1181  src_height[0] = height;
1182  src_height[1] = 0;
1183  src_height[2] = 0;
1184  src_height[3] = 0;
1185 
1186  vpad[0] = 0;
1187  vpad[1] = 0;
1188  vpad[2] = 0;
1189  vpad[3] = 0;
1190 
1191  tenBit = false;
1192  break;
1193 
1194  case NI_PIX_FMT_BGRP:
1195  hpad[0] = NIMAX(dst_stride[0] - linesize[0], 0);
1196  hpad[1] = NIMAX(dst_stride[1] - linesize[1], 0);
1197  hpad[2] = NIMAX(dst_stride[2] - linesize[2], 0);
1198  hpad[3] = 0;
1199 
1200  src_height[0] = height;
1201  src_height[1] = height;
1202  src_height[2] = height;
1203  src_height[3] = 0;
1204 
1205  vpad[0] = 0;
1206  vpad[1] = 0;
1207  vpad[2] = 0;
1208  vpad[3] = 0;
1209 
1210  tenBit = false;
1211  break;
1212 
1213  case NI_PIX_FMT_YUYV422:
1214  case NI_PIX_FMT_UYVY422:
1215  hpad[0] = NIMAX(dst_stride[0] - linesize[0], 0);
1216  hpad[1] = 0;
1217  hpad[2] = 0;
1218  hpad[3] = 0;
1219 
1220  src_height[0] = height;
1221  src_height[1] = 0;
1222  src_height[2] = 0;
1223  src_height[3] = 0;
1224 
1225  vpad[0] = 0;
1226  vpad[1] = 0;
1227  vpad[2] = 0;
1228  vpad[3] = 0;
1229 
1230  tenBit = false;
1231  break;
1232 
1233  default:
1234  ni_log(NI_LOG_ERROR, "Pixel format %s not supported\n", ni_fmat);
1235  break;
1236  }
1237 
1238  for (i = 0; i < nb_planes; i++)
1239  {
1240  dst_line = dst->p_data[i];
1241  src_line = src_data[i];
1242 
1243  for (h = 0; h < src_height[i]; h++)
1244  {
1245  memcpy(dst_line, src_line, NIMIN(linesize[i], dst_stride[i]));
1246 
1247  if (hpad[i])
1248  {
1249  lastidx = linesize[i];
1250 
1251  if (tenBit)
1252  {
1253  sample = &src_line[lastidx - 2];
1254  dest = &dst_line[lastidx];
1255 
1256  /* two bytes per sample */
1257  for (j = 0; j < hpad[i] / 2; j++)
1258  {
1259  memcpy(dest, sample, 2);
1260  dest += 2;
1261  }
1262  } else
1263  {
1264  YUVsample = dst_line[lastidx - 1];
1265  memset(&dst_line[lastidx], YUVsample, hpad[i]);
1266  }
1267  }
1268 
1269  src_line += linesize[i];
1270  dst_line += dst_stride[i];
1271  }
1272 
1273  /* Extend the height by cloning the last line */
1274  src_line = dst_line - dst_stride[i];
1275  for (h = 0; h < vpad[i]; h++)
1276  {
1277  memcpy(dst_line, src_line, dst_stride[i]);
1278  dst_line += dst_stride[i];
1279  }
1280  }
1281 
1282  return 0;
1283 }
1284 
1285 static int ni_to_avframe_copy(const ni_frame_t *src, int width, int height,
1286  int ni_fmat, int nb_planes, const int *linesize,
1287  uint8_t **dst_data)
1288 {
1289  int src_linesize[4], src_height[4];
1290  int i, h;
1291  uint8_t *src_line, *dst_line;
1292 
1293  switch (ni_fmat)
1294  {
1295  case NI_PIX_FMT_YUV420P:
1296  src_linesize[0] = NIALIGN(width, 128);
1297  src_linesize[1] = NIALIGN(width / 2, 128);
1298  src_linesize[2] = src_linesize[1];
1299  src_linesize[3] = 0;
1300 
1301  src_height[0] = height;
1302  src_height[1] = NIALIGN(height, 2) / 2;
1303  src_height[2] = src_height[1];
1304  src_height[3] = 0;
1305  break;
1306 
1308  src_linesize[0] = NIALIGN(width * 2, 128);
1309  src_linesize[1] = NIALIGN(width, 128);
1310  src_linesize[2] = src_linesize[1];
1311  src_linesize[3] = 0;
1312 
1313  src_height[0] = height;
1314  src_height[1] = NIALIGN(height, 2) / 2;
1315  src_height[2] = src_height[1];
1316  src_height[3] = 0;
1317  break;
1318 
1319  case NI_PIX_FMT_NV12:
1320  src_linesize[0] = NIALIGN(width, 128);
1321  src_linesize[1] = NIALIGN(width, 128);
1322  src_linesize[2] = 0;
1323  src_linesize[3] = 0;
1324 
1325  src_height[0] = height;
1326  src_height[1] = NIALIGN(height, 2) / 2;
1327  src_height[2] = 0;
1328  src_height[3] = 0;
1329  break;
1330 
1331  case NI_PIX_FMT_NV16:
1332  src_linesize[0] = NIALIGN(width, 64);
1333  src_linesize[1] = NIALIGN(width, 64);
1334  src_linesize[2] = 0;
1335  src_linesize[3] = 0;
1336 
1337  src_height[0] = height;
1338  src_height[1] = height;
1339  src_height[2] = 0;
1340  src_height[3] = 0;
1341  break;
1342 
1343  case NI_PIX_FMT_YUYV422:
1344  case NI_PIX_FMT_UYVY422:
1345  src_linesize[0] = NIALIGN(width, 16) * 2;
1346  src_linesize[1] = 0;
1347  src_linesize[2] = 0;
1348  src_linesize[3] = 0;
1349 
1350  src_height[0] = height;
1351  src_height[1] = 0;
1352  src_height[2] = 0;
1353  src_height[3] = 0;
1354  break;
1355 
1356  case NI_PIX_FMT_P010LE:
1357  src_linesize[0] = NIALIGN(width * 2, 128);
1358  src_linesize[1] = NIALIGN(width * 2, 128);
1359  src_linesize[2] = 0;
1360  src_linesize[3] = 0;
1361 
1362  src_height[0] = height;
1363  src_height[1] = NIALIGN(height, 2) / 2;
1364  src_height[2] = 0;
1365  src_height[3] = 0;
1366  break;
1367 
1368  case NI_PIX_FMT_RGBA:
1369  case NI_PIX_FMT_BGRA:
1370  case NI_PIX_FMT_ABGR:
1371  case NI_PIX_FMT_ARGB:
1372  case NI_PIX_FMT_BGR0:
1373  src_linesize[0] = NIALIGN(width, 16) * 4;
1374  src_linesize[1] = 0;
1375  src_linesize[2] = 0;
1376  src_linesize[3] = 0;
1377 
1378  src_height[0] = height;
1379  src_height[1] = 0;
1380  src_height[2] = 0;
1381  src_height[3] = 0;
1382  break;
1383 
1384  case NI_PIX_FMT_BGRP:
1385  src_linesize[0] = NIALIGN(width, 32);
1386  src_linesize[1] = NIALIGN(width, 32);
1387  src_linesize[2] = NIALIGN(width, 32);
1388  src_linesize[3] = 0;
1389 
1390  src_height[0] = height;
1391  src_height[1] = height;
1392  src_height[2] = height;
1393  src_height[3] = 0;
1394  break;
1395 
1396  default:
1397  ni_log(NI_LOG_ERROR, "Unsupported pixel format %d\n", ni_fmat);
1398  return NI_RETCODE_FAILURE;
1399  }
1400 
1401  for (i = 0; i < nb_planes; i++)
1402  {
1403  dst_line = dst_data[i];
1404  src_line = src->p_data[i];
1405  for (h = 0; h < src_height[i]; h++)
1406  {
1407  memcpy(dst_line, src_line, NIMIN(src_linesize[i], linesize[i]));
1408  dst_line += linesize[i];
1409  src_line += src_linesize[i];
1410  }
1411  }
1412 
1413  return 0;
1414 }
1415 
1417  niquadraFrameSurface1_t *dst_surf, int width,
1418  int height, int ni_fmat, int nb_planes,
1419  const int *linesize, uint8_t **src_data)
1420 {
1421  ni_session_context_t *p_session_ctx = ni_ctx->api_ctx;
1422  ni_session_data_io_t *p_src_session_data = ni_ctx->src_session_io_data;
1423  ni_split_context_t *p_split_ctx = (ni_split_context_t *)&ni_ctx->split_ctx;
1424  int need_to_copy = 1;
1425  bool isSemiPlanar;
1426  int dst_stride[4];
1427  int ret;
1428 
1429  switch (ni_fmat)
1430  {
1431  /* 8-bit YUV420 planar */
1432  case NI_PIX_FMT_YUV420P:
1433  dst_stride[0] = NIALIGN(width, 128);
1434  dst_stride[1] = NIALIGN((width / 2), 128);
1435  dst_stride[2] = dst_stride[1];
1436  dst_stride[3] = 0;
1437 
1438  isSemiPlanar = false;
1439  break;
1440 
1441  /* 10-bit YUV420 planar, little-endian, least significant bits */
1443  dst_stride[0] = NIALIGN(width * 2, 128);
1444  dst_stride[1] = NIALIGN(width, 128);
1445  dst_stride[2] = dst_stride[1];
1446  dst_stride[3] = 0;
1447 
1448  isSemiPlanar = false;
1449  break;
1450 
1451  /* 8-bit YUV420 semi-planar */
1452  case NI_PIX_FMT_NV12:
1453  dst_stride[0] = NIALIGN(width, 128);
1454  dst_stride[1] = dst_stride[0];
1455  dst_stride[2] = 0;
1456  dst_stride[3] = 0;
1457 
1458  isSemiPlanar = true;
1459  break;
1460 
1461  /* 8-bit yuv422 semi-planar */
1462  case NI_PIX_FMT_NV16:
1463  dst_stride[0] = NIALIGN(width, 64);
1464  dst_stride[1] = dst_stride[0];
1465  dst_stride[2] = 0;
1466  dst_stride[3] = 0;
1467 
1468  isSemiPlanar = false;
1469  break;
1470 
1471  /*8-bit yuv422 planar */
1472  case NI_PIX_FMT_YUYV422:
1473  case NI_PIX_FMT_UYVY422:
1474  dst_stride[0] = NIALIGN(width, 16) * 2;
1475  dst_stride[1] = 0;
1476  dst_stride[2] = 0;
1477  dst_stride[3] = 0;
1478 
1479  isSemiPlanar = false;
1480  break;
1481 
1482  /* 10-bit YUV420 semi-planar, little endian, most significant bits */
1483  case NI_PIX_FMT_P010LE:
1484  dst_stride[0] = NIALIGN(width * 2, 128);
1485  dst_stride[1] = dst_stride[0];
1486  dst_stride[2] = 0;
1487  dst_stride[3] = 0;
1488 
1489  isSemiPlanar = true;
1490  break;
1491 
1492  /* 32-bit RGBA packed */
1493  /* RGBA for the scaler has a 16-byte width/64-byte stride alignment */
1494  case NI_PIX_FMT_RGBA:
1495  case NI_PIX_FMT_BGRA:
1496  case NI_PIX_FMT_ABGR:
1497  case NI_PIX_FMT_ARGB:
1498  case NI_PIX_FMT_BGR0:
1499  dst_stride[0] = NIALIGN(width, 16) * 4;
1500  dst_stride[1] = 0;
1501  dst_stride[2] = 0;
1502  dst_stride[3] = 0;
1503 
1504  isSemiPlanar = false;
1505  break;
1506 
1507  /* 24-bit BGR planar not supported for hwupload */
1508  /*
1509  case AV_PIX_FMT_BGRP:
1510  dst_stride[0] = NIALIGN(width, 32);
1511  dst_stride[1] = NIALIGN(width, 32);
1512  dst_stride[2] = NIALIGN(width, 32);
1513  dst_stride[3] = 0;
1514 
1515  pixel_format = NI_PIX_FMT_BGRP;
1516  isSemiPlanar = false;
1517  break;
1518  */
1519  default:
1520  ni_log(NI_LOG_ERROR, "Pixel format %d not supported\n", ni_fmat);
1521  return NI_RETCODE_FAILURE;
1522  }
1523 
1524  // check input resolution zero copy compatible or not
1525  if (ni_uploader_frame_zerocopy_check(p_session_ctx, width, height,
1526  (const int *)linesize,
1527  ni_fmat) == NI_RETCODE_SUCCESS)
1528  {
1529  need_to_copy = 0;
1530  p_src_session_data->data.frame.extra_data_len =
1532  // alloc metadata buffer etc. (if needed)
1534  &p_src_session_data->data.frame, width, height,
1535  (const int *)linesize, (const uint8_t **)src_data,
1536  (int)p_src_session_data->data.frame.extra_data_len);
1537  if (ret != NI_RETCODE_SUCCESS)
1539  } else
1540  {
1541  // allocate only once per upload Session when we have frame info
1542  p_src_session_data->data.frame.extra_data_len =
1544 
1546  &p_src_session_data->data.frame, ni_fmat, width, height, dst_stride,
1547  1, // force to av_codec_id_h264 for max compat
1548  (int)p_src_session_data->data.frame.extra_data_len);
1549  if (ret < 0)
1550  {
1551  ni_log(NI_LOG_ERROR, "Cannot allocate ni_frame %d\n", ret);
1552  return ret;
1553  }
1554  }
1555  if (need_to_copy)
1556  {
1557  ret = av_to_niframe_copy(dst_stride, &p_src_session_data->data.frame,
1558  width, height, ni_fmat, nb_planes, linesize,
1559  src_data);
1560  if (ret < 0)
1561  {
1562  ni_log(NI_LOG_ERROR, "%s can't copy frame\n", __func__);
1563  return NI_RETCODE_FAILURE;
1564  }
1565  }
1566  ret = ni_device_session_hwup(p_session_ctx, p_src_session_data, (niFrameSurface1_t *)dst_surf);
1567  if (ret < 0)
1568  {
1569  ni_log(NI_LOG_ERROR, "%s failed to upload frame %d\n", __func__, ret);
1570  return NI_RETCODE_FAILURE;
1571  }
1572 
1573  dst_surf->ui16width = p_split_ctx->w[0] = width;
1574  dst_surf->ui16height = p_split_ctx->h[0] = height;
1575  dst_surf->ui32nodeAddress = 0; // always 0 offset for upload
1576  dst_surf->encoding_type = isSemiPlanar ? NI_PIXEL_PLANAR_FORMAT_SEMIPLANAR :
1578 
1579  ni_log(NI_LOG_DEBUG, "%s trace ui16FrameIdx = [%u] hdl %d SID%d\n",
1580  __func__, dst_surf->ui16FrameIdx, dst_surf->device_handle,
1581  dst_surf->ui16session_ID);
1582 
1583  // Update frames context
1584  p_split_ctx->f[0] = (int)dst_surf->encoding_type;
1585  return ret;
1586 }
1587 
1589  niquadraFrameSurface1_t *src_surf, int width,
1590  int height, int ni_fmat, int nb_planes,
1591  const int *linesize, uint8_t **dst_data)
1592 {
1593  ni_session_context_t *p_session_ctx = ni_ctx->api_ctx;
1594  ni_session_data_io_t session_io_data;
1595  ni_session_data_io_t *p_session_data = &session_io_data;
1596  int ret = 0;
1597  memset(p_session_data, 0, sizeof(ni_session_data_io_t));
1598  ret = ni_frame_buffer_alloc_dl(&(p_session_data->data.frame), width, height,
1599  ni_fmat);
1600  if (ret != NI_RETCODE_SUCCESS)
1601  {
1602  ni_log(NI_LOG_ERROR, "%s Cannot allocate ni_frame\n", __func__);
1604  }
1605 
1606  p_session_ctx->is_auto_dl = false;
1607  ret = ni_device_session_hwdl(p_session_ctx, p_session_data, (niFrameSurface1_t *)src_surf);
1608  if (ret <= 0)
1609  {
1610  ni_log(NI_LOG_ERROR, "%s failed to retrieve frame\n", __func__);
1611  ni_frame_buffer_free(&p_session_data->data.frame);
1612  return NI_RETCODE_FAILURE;
1613  }
1614 
1615  ret = ni_to_avframe_copy(&p_session_data->data.frame, width, height,
1616  ni_fmat, nb_planes, linesize, dst_data);
1617  if (ret < 0)
1618  {
1619  ni_log(NI_LOG_ERROR, "Can't copy frame %d\n", ret);
1620  ni_frame_buffer_free(&p_session_data->data.frame);
1621  return ret;
1622  }
1623 
1624  ni_frame_buffer_free(&p_session_data->data.frame);
1625  return ret;
1626 }
1627 
1629  niquadraFrameSurface1_t *ni_surf,
1630  niquadraFrameSurface1_t *ni_surf_1,
1631  niquadraFrameSurface1_t *ni_surf_2,
1632  int num_extra_outputs)
1633 {
1634  ni_split_context_t *split_ctx = (ni_split_context_t *)&ni_ctx->split_ctx;
1635  split_ctx->enabled = (num_extra_outputs >= 1) ? 1 : 0;
1636  split_ctx->w[0] = ni_surf->ui16width;
1637  split_ctx->h[0] = ni_surf->ui16height;
1638  split_ctx->f[0] = (int)ni_surf->encoding_type;
1639  split_ctx->f8b[0] = (int)ni_surf->bit_depth;
1640  split_ctx->w[1] = (num_extra_outputs >= 1) ? ni_surf_1->ui16width : 0;
1641  split_ctx->h[1] = (num_extra_outputs >= 1) ? ni_surf_1->ui16height : 0;
1642  split_ctx->f[1] = (num_extra_outputs >= 1) ? ni_surf_1->encoding_type : 0;
1643  split_ctx->f8b[1] = (num_extra_outputs >= 1) ? ni_surf_1->bit_depth : 0;
1644  split_ctx->w[2] = (num_extra_outputs == 2) ? ni_surf_2->ui16width : 0;
1645  split_ctx->h[2] = (num_extra_outputs == 2) ? ni_surf_2->ui16height : 0;
1646  split_ctx->f[2] = (num_extra_outputs == 2) ? ni_surf_2->encoding_type : 0;
1647  split_ctx->f8b[2] = (num_extra_outputs == 2) ? ni_surf_2->bit_depth : 0;
1648 }
1649 
1650 int ni_quadra_get_device_id(void *session_ctx)
1651 {
1652  ni_session_context_t *p_session_ctx = session_ctx;
1653  return p_session_ctx->hw_id;
1654 }
1655 
1656 uint32_t ni_quadra_get_session_id(void *session_ctx)
1657 {
1658  ni_session_context_t *p_session_ctx = session_ctx;
1659  return p_session_ctx->session_id;
1660 }
1661 
1662 void ni_quadra_device_close(int32_t handle)
1663 {
1664  ni_device_close(handle);
1665 }
1666 
1667 int32_t ni_quadra_get_device_handle(void *session_ctx)
1668 {
1669  ni_session_context_t *p_session_ctx = session_ctx;
1670  return p_session_ctx->device_handle;
1671 }
1672 
1673 void ni_quadra_set_device_handle(void *session_ctx, int32_t handle)
1674 {
1675  ni_session_context_t *p_session_ctx = session_ctx;
1676  p_session_ctx->blk_io_handle = handle;
1677 }
1678 
1679 void ni_quadra_filter_session_dl_set(void *session_ctx, bool value)
1680 {
1681  ni_session_context_t *p_session_ctx = session_ctx;
1682  p_session_ctx->is_auto_dl = value;
1683 }
1684 
1685 int ni_quadra_device_session_copy(void *src_ctx, void *dst_ctx)
1686 {
1687  return ni_device_session_copy(src_ctx, dst_ctx);
1688 }
1689 
1690 void ni_quadra_session_timestamp_copy(void *src_ctx, void *dst_ctx)
1691 {
1692  ni_session_context_t *p_src_session = src_ctx;
1693  ni_session_context_t *p_dst_session = dst_ctx;
1694  p_dst_session->session_timestamp = p_src_session->session_timestamp;
1695 }
1696 
1697 int ni_quadra_get_session_status(void *session_ctx)
1698 {
1699  ni_session_context_t *p_session_ctx = session_ctx;
1700  return p_session_ctx->status;
1701 }
1702 int ni_quadra_get_session_runstatus(void *session_ctx)
1703 {
1704  ni_session_context_t *p_session_ctx = session_ctx;
1705  return p_session_ctx->session_run_state;
1706 }
1708 {
1709  ni_session_context_t *p_session_ctx = session_ctx;
1710  return p_session_ctx->blk_io_handle;
1711 }
1712 
1713 uint16_t ni_quadra_get_frame_idx(void *niframe)
1714 {
1715  ni_session_data_io_t *p_frame = niframe;
1716  niFrameSurface1_t *frame_surface = (niFrameSurface1_t *)p_frame->data.frame.p_data[3];
1717  return frame_surface->ui16FrameIdx;
1718 }
1719 
1720 uint8_t *ni_quadra_get_niframe(void *niframe)
1721 {
1722  ni_session_data_io_t *p_frame = niframe;
1723  return (uint8_t *)&p_frame->data.frame;
1724 }
1725 
1726 uint8_t *ni_quadra_get_frame_buffer(void *niframe)
1727 {
1728  ni_session_data_io_t *p_frame = niframe;
1729  return p_frame->data.frame.p_buffer;
1730 }
1731 
1732 uint32_t ni_quadra_get_frame_buffer_size(void *niframe)
1733 {
1734  ni_session_data_io_t *p_frame = niframe;
1735  return p_frame->data.frame.buffer_size;
1736 }
1737 
1738 uint8_t **ni_quadra_get_frame_data(void *niframe)
1739 {
1740  ni_session_data_io_t *p_frame = niframe;
1741  return (uint8_t **)&p_frame->data.frame.p_data;
1742 }
1743 
1744 uint8_t *ni_quadra_get_packet_data(void *nipacket)
1745 {
1746  ni_session_data_io_t *p_pkt = nipacket;
1747  return p_pkt->data.packet.p_data;
1748 }
1749 
1750 uint32_t ni_quadra_get_packet_data_len(void *nipacket)
1751 {
1752  ni_session_data_io_t *p_pkt = nipacket;
1753  return p_pkt->data.packet.data_len;
1754 }
1755 
1756 void ni_quadra_get_frame_data_len(void *niframe, uint32_t *dst_datalen)
1757 {
1758  ni_session_data_io_t *p_frame = niframe;
1759  int i;
1760  for (i = 0; i < NI_QUADRA_MAX_NUM_DATA_POINTERS; i++)
1761  {
1762  dst_datalen[i] = p_frame->data.frame.data_len[i];
1763  }
1764 }
1765 
1766 int ni_quadra_filter_hwframe_recycle(void *session_ctx, void *niframe)
1767 {
1768  ni_session_context_t *p_session_ctx = session_ctx;
1769  ni_session_data_io_t *p_frame = niframe;
1770 
1772  (niFrameSurface1_t *)p_frame->data.frame.p_data[3],
1773  p_session_ctx->device_handle);
1774 }
1775 
1776 void ni_quadra_set_session_runstatus(void *session_ctx, int status)
1777 {
1778  ni_session_context_t *p_session_ctx = session_ctx;
1779  p_session_ctx->session_run_state = status;
1780 }
1781 
1783  ni_quadra_frame_config_t *p_cfg)
1784 {
1785  ni_session_context_t *p_session_ctx = p_ctx;
1786  return ni_device_config_frame(p_session_ctx, (ni_frame_config_t *)p_cfg);
1787 }
1788 
1790  int32_t device_handle)
1791 {
1792  return ni_hwframe_buffer_recycle((niFrameSurface1_t *)surface, device_handle);
1793 }
1794 
1795 void ni_quadra_get_hw_yuv420p_dim(int width, int height, int factor,
1796  int is_semiplanar, int plane_stride[4],
1797  int plane_height[4])
1798 {
1799  // strides are multiples of 128
1800  if (width < NI_MIN_WIDTH)
1801  {
1802  plane_stride[0] = ((NI_MIN_WIDTH * factor + 127) / 128) * 128;
1803  plane_stride[1] =
1804  (((NI_MIN_WIDTH / (is_semiplanar ? 1 : 2) * factor) + 127) / 128) *
1805  128;
1806  plane_stride[2] =
1807  ((((is_semiplanar ? 0 : NI_MIN_WIDTH) / 2 * factor) + 127) / 128) *
1808  128;
1809  } else
1810  {
1811  width = ((width + 1) / 2) * 2; // pad odd resolution
1812  plane_stride[0] = ((width * factor + 127) / 128) * 128;
1813  plane_stride[1] =
1814  (((width / (is_semiplanar ? 1 : 2) * factor) + 127) / 128) * 128;
1815  plane_stride[2] = (is_semiplanar ? 0 : plane_stride[1]);
1816  }
1817 
1818  // height (in lines) just needs to be even number
1819  if (height < NI_MIN_HEIGHT)
1820  {
1821  plane_height[0] = NI_MIN_HEIGHT;
1822  } else
1823  {
1824  plane_height[0] = ((height + 1) / 2) * 2;
1825  }
1826  plane_height[1] = plane_height[2] = plane_height[0] / 2;
1827 }
1828 
1830 {
1831  return sizeof(ni_custom_sei_set_t);
1832 }
1833 
1835 {
1837 }
1838 
1839 void ni_quadra_log_set_callback(void (*log_callback)(int, const char *,
1840  va_list))
1841 {
1842  ni_log_set_callback(log_callback);
1843 }
1844 
1846 {
1847  return (ni_quadra_log_level_t)ff_to_ni_log_level(fflog_level);
1848 }
1849 
1851 {
1853 }
1854 
1856 {
1858 }
1859 
1860 ni_quadra_hw_device_info_t *ni_quadra_hw_device_info_alloc(int device_type_num, int avaliable_card_num)
1861 {
1862  return (ni_quadra_hw_device_info_t *) ni_hw_device_info_alloc_quadra(device_type_num, avaliable_card_num);
1863 }
1864 
1866 {
1868 }
1869 
1870 int ni_quadra_check_hw_info(ni_quadra_hw_device_info_t **pointer_to_p_hw_device_info,
1871  int task_mode,
1872  ni_quadra_hw_device_info_threshold_param_t *hw_info_threshold_param,
1873  int preferential_device_type,
1875  int hw_mode,
1876  int consider_mem)
1877 {
1878 
1879  return ni_check_hw_info((ni_hw_device_info_quadra_t **)pointer_to_p_hw_device_info,
1880  task_mode,
1881  (ni_hw_device_info_quadra_threshold_param_t *)hw_info_threshold_param,
1882  preferential_device_type,
1884  hw_mode,
1885  consider_mem);
1886 }
1887 
1889  ni_quadra_device_type_t device_type)
1890 {
1891  return ni_rsrc_get_device_by_block_name(blk_name, (ni_device_type_t)device_type);
1892 }
1893 
1894 /*!*****************************************************************************
1895  * \brief Open a new device session depending on the device_type parameter
1896  * If device_type is NI_DEVICE_TYPE_DECODER opens decoding session
1897  * If device_type is NI_DEVICE_TYPE_ENCODER opens encoding session
1898  * If device_type is NI_DEVICE_TYPE_SCALER opens scaling session
1899  *
1900  * \param[in] p_ctx Pointer to a caller allocated
1901  * ni_session_context_t struct
1902  * \param[in] device_type NI_DEVICE_TYPE_DECODER, NI_DEVICE_TYPE_ENCODER,
1903  * or NI_DEVICE_TYPE_SCALER
1904  * \return On success
1905  * NI_RETCODE_SUCCESS
1906  * On failure
1907  * NI_RETCODE_INVALID_PARAM
1908  * NI_RETCODE_ERROR_MEM_ALOC
1909  * NI_RETCODE_ERROR_NVME_CMD_FAILED
1910  * NI_RETCODE_ERROR_INVALID_SESSION
1911  ******************************************************************************/
1913  ni_quadra_device_type_t device_type)
1914 {
1915  ni_session_context_t *p_session_ctx = p_ctx;
1916  return ni_device_session_open(p_session_ctx, (ni_device_type_t)device_type);
1917 }
1918 
1919 /*!*****************************************************************************
1920  * \brief Sends data to the device
1921  * If device_type is NI_DEVICE_TYPE_DECODER sends data packet to
1922  * decoder
1923  * If device_type is NI_DEVICE_TYPE_ENCODER sends data frame to encoder
1924  * If device_type is NI_DEVICE_TYPE_AI sends data frame to ai engine
1925  *
1926  * \param[in] p_ctx Pointer to a caller allocated
1927  * ni_session_context_t struct
1928  * \param[in] p_data Pointer to a caller allocated
1929  * ni_session_data_io_t struct which contains either a
1930  * ni_frame_t data frame or ni_packet_t data packet to
1931  * send
1932  * \param[in] device_type NI_DEVICE_TYPE_DECODER or NI_DEVICE_TYPE_ENCODER or
1933  * NI_DEVICE_TYPE_AI
1934  * If NI_DEVICE_TYPE_DECODER is specified, it is
1935  * expected that the ni_packet_t struct inside the
1936  * p_data pointer contains data to send.
1937  * If NI_DEVICE_TYPE_ENCODER or NI_DEVICE_TYPE_AI is
1938  * specified, it is expected that the ni_frame_t
1939  * struct inside the p_data pointer contains data to
1940  * send.
1941  * \return On success
1942  * Total number of bytes written
1943  * On failure
1944  * NI_RETCODE_INVALID_PARAM
1945  * NI_RETCODE_ERROR_NVME_CMD_FAILED
1946  * NI_RETCODE_ERROR_INVALID_SESSION
1947  ******************************************************************************/
1948 int ni_quadra_device_session_write(void *p_ctx, void *p_data,
1949  ni_quadra_device_type_t device_type)
1950 {
1952  (ni_session_data_io_t *)p_data, (ni_device_type_t)device_type);
1953 }
1954 
1955 /*!*****************************************************************************
1956  * \brief Free packet buffer that was previously allocated with
1957  * ni_packet_buffer_alloc
1958  *
1959  * \param[in] p_data Pointer to void *
1960  * ni_session_data_io_t struct
1961  *
1962  * \return On success NI_RETCODE_SUCCESS
1963  * On failure NI_RETCODE_INVALID_PARAM
1964  ******************************************************************************/
1966 {
1967  ni_session_data_io_t *p_packet = p_data;
1968  return ni_packet_buffer_free(&p_packet->data.packet);
1969 }
1970 
1971 /*!*****************************************************************************
1972  * \brief Free frame buffer that was previously allocated with either
1973  * ni_frame_buffer_alloc or ni_encoder_frame_buffer_alloc or
1974  * ni_frame_buffer_alloc_nv
1975  *
1976  * \param[in] p_data Pointer to void *
1977  * ni_session_data_io_t struct
1978  *
1979  * \return On success NI_RETCODE_SUCCESS
1980  * On failure NI_RETCODE_INVALID_PARAM
1981  ******************************************************************************/
1983 {
1984  ni_session_data_io_t *p_frame = p_data;
1985  return ni_frame_buffer_free(&p_frame->data.frame);
1986 }
1987 
1988 /*!*****************************************************************************
1989  * \brief Create and return the allocated ni_device_pool_t struct
1990  *
1991  * \param None
1992  *
1993  * \return Pointer to ni_device_pool_t struct on success, or NULL on failure
1994  *******************************************************************************/
1996 {
1998 }
1999 
2000 /*!*****************************************************************************
2001  * \brief Close device session that was previously opened by calling
2002  * ni_device_session_open()
2003  * If device_type is NI_DEVICE_TYPE_DECODER closes decoding session
2004  * If device_type is NI_DEVICE_TYPE_ENCODER closes encoding session
2005  * If device_type is NI_DEVICE_TYPE_SCALER closes scaling session
2006  *
2007  * \param[in] p_ctx Pointer to a caller allocated
2008  * ni_session_context_t struct
2009  * \param[in] eos_received Flag indicating if End Of Stream indicator was
2010  * received
2011  * \param[in] device_type NI_DEVICE_TYPE_DECODER, NI_DEVICE_TYPE_ENCODER,
2012  * or NI_DEVICE_TYPE_SCALER
2013  * \return On success
2014  * NI_RETCODE_SUCCESS
2015  * On failure
2016  * NI_RETCODE_INVALID_PARAM
2017  * NI_RETCODE_ERROR_NVME_CMD_FAILED
2018  * NI_RETCODE_ERROR_INVALID_SESSION
2019  ******************************************************************************/
2021  int eos_recieved,
2022  ni_quadra_device_type_t device_type)
2023 {
2024  ni_session_context_t *p_session_ctx = p_ctx;
2025  return ni_device_session_close(p_session_ctx, eos_recieved, (ni_device_type_t)device_type);
2026 }
2027 
2028 /*!*****************************************************************************
2029  * \brief Clear already allocated session context
2030  *
2031  * \param[in] p_ctx Pointer to an already allocated ni_session_context_t
2032  *
2033  *
2034  ******************************************************************************/
2036 {
2037  ni_session_context_t *p_session_ctx = p_ctx;
2038  ni_device_session_context_clear(p_session_ctx);
2039 }
2040 
2042  int video_width, int video_height,
2043  int extra_len)
2044 {
2045  ni_session_data_io_t *p_frame = niframe;
2046  return ni_frame_buffer_alloc_hwenc(&p_frame->data.frame, video_width,
2047  video_height, extra_len);
2048 }
2049 
2050 void ni_quadra_set_framerate(void *p_ctx, int num, int den)
2051 {
2052  ni_session_context_t *p_session_ctx = p_ctx;
2053 
2054  p_session_ctx->framerate.framerate_num = num;
2055  p_session_ctx->framerate.framerate_denom = den;
2056 }
2057 
2059 {
2060  ni_session_context_t *p_session_ctx = p_ctx;
2061  return p_session_ctx->pkt_num;
2062 }
2063 
2065 {
2066  ni_session_context_t *p_session_ctx = p_ctx;
2067  return p_session_ctx->frame_num;
2068 }
ni_quadra_set_device_handle
void ni_quadra_set_device_handle(void *session_ctx, int32_t handle)
Set session device handle.
Definition: ni_quadra_filter_api.c:1673
NI_PIX_FMT_UYVY422
@ NI_PIX_FMT_UYVY422
Definition: ni_device_api.h:274
ni_pthread_mutex_unlock
int ni_pthread_mutex_unlock(ni_pthread_mutex_t *mutex)
thread mutex unlock
Definition: ni_util.c:4083
NI_PIX_FMT_BGRA
@ NI_PIX_FMT_BGRA
Definition: ni_device_api.h:267
ni_quadra_get_session_runstatus
int ni_quadra_get_session_runstatus(void *session_ctx)
Get session context run status.
Definition: ni_quadra_filter_api.c:1702
ni_quadra_rsrc_get_device_by_block_name
int ni_quadra_rsrc_get_device_by_block_name(const char *blk_name, ni_quadra_device_type_t device_type)
Get GUID of the device by block device name and type.
Definition: ni_quadra_filter_api.c:1888
ni_scaler_set_params
ni_retcode_t ni_scaler_set_params(ni_session_context_t *p_ctx, ni_scaler_params_t *p_params)
Set parameters on the device for the 2D engine.
Definition: ni_device_api.c:8671
ni_quadra_ai_packet_buffer_alloc
int ni_quadra_ai_packet_buffer_alloc(void *p_pkt, ni_quadra_network_data_t *p_network)
Allocate output layers memory for the packet buffer based on provided network.
Definition: ni_quadra_filter_api.c:607
ni_quadra_log_set_callback
void ni_quadra_log_set_callback(void(*log_callback)(int, const char *, va_list))
Set ni_log() callback.
Definition: ni_quadra_filter_api.c:1839
NI_MAX_RESOLUTION_HEIGHT
#define NI_MAX_RESOLUTION_HEIGHT
Definition: ni_device_api.h:101
NI_DEVICE_TYPE_ENCODER
@ NI_DEVICE_TYPE_ENCODER
Definition: ni_defs.h:347
ni_quadra_ai_config_hvsplus
int ni_quadra_ai_config_hvsplus(ni_quadra_filter_t *nifilter, ni_quadra_network_data_t *p_network, int nb_width, int nb_height, int level, int format)
configure a hvsplus context based with the network binary
Definition: ni_quadra_filter_api.c:583
ff_to_ni_log_level
ni_log_level_t ff_to_ni_log_level(int fflog_level)
Convert ffmpeg log level integer to appropriate ni_log_level_t.
Definition: ni_log.c:224
_ni_quadra_filter_t::api_ctx
void * api_ctx
Definition: ni_quadra_filter_api.h:357
_ni_frame::buffer_size
uint32_t buffer_size
Definition: ni_device_api.h:2667
_ni_network_data
Definition: ni_device_api.h:1363
ni_ai_config_network_binary
ni_retcode_t ni_ai_config_network_binary(ni_session_context_t *p_ctx, ni_network_data_t *p_network, const char *file)
configure a network context based with the network binary
Definition: ni_device_api.c:9562
ni_quadra_ff_to_ni_log_level
ni_quadra_log_level_t ni_quadra_ff_to_ni_log_level(int fflog_level)
Convert ffmpeg log level integer to appropriate ni_quadra_log_level_t.
Definition: ni_quadra_filter_api.c:1845
_ni_quadra_hw_device_info_coder_param
Definition: ni_quadra_filter_api.h:523
_niquadraFrameSurface1::ui16height
uint16_t ui16height
Definition: ni_quadra_filter_api.h:390
ni_bitstream.h
Utility definitions to operate on bits in a bitstream.
_ni_quadra_network_layer_params_t
Definition: ni_quadra_filter_api.h:275
_ni_quadra_filter_t::hw_action
int hw_action
Definition: ni_quadra_filter_api.h:354
ni_frame_buffer_free
ni_retcode_t ni_frame_buffer_free(ni_frame_t *p_frame)
Free frame buffer that was previously allocated with either ni_frame_buffer_alloc or ni_encoder_frame...
Definition: ni_device_api.c:3561
_ni_device::xcoders
ni_device_info_t xcoders[NI_DEVICE_TYPE_XCODER_MAX][NI_MAX_DEVICE_CNT]
Definition: ni_rsrc_api.h:142
ni_quadra_device_session_open
int ni_quadra_device_session_open(void *p_ctx, ni_quadra_device_type_t device_type)
Open a new device session depending on the device_type parameter If device_type is NI_DEVICE_TYPE_DEC...
Definition: ni_quadra_filter_api.c:1912
ni_quadra_hw_device_info_alloc
ni_quadra_hw_device_info_t * ni_quadra_hw_device_info_alloc(int device_type_num, int avaliable_card_num)
Create a pointer to ni_hw_device_info_quadra_t instance .
Definition: ni_quadra_filter_api.c:1860
NI_QUADRA_SCALER_OPCODE_MERGE
@ NI_QUADRA_SCALER_OPCODE_MERGE
Definition: ni_quadra_filter_api.h:192
_ni_split_context_t::f8b
int f8b[3]
Definition: ni_device_api.h:1732
ni_destory_hw_device_info_quadra_coder_param
void ni_destory_hw_device_info_quadra_coder_param(ni_hw_device_info_quadra_coder_param_t *p_hw_device_info_quadra_coder_param)
Free resource in p_hw_device_info_quadra_coder_param This function is used for ni_check_hw_info()
Definition: ni_rsrc_api.cpp:3271
ni_quadra_network_layer_convert_output
int ni_quadra_network_layer_convert_output(void *p_data, float *dst, uint32_t num, ni_quadra_network_data_t *p_network, uint32_t layer)
Convert data from nipacket to dst data.
Definition: ni_quadra_filter_api.c:625
ni_quadra_device_close
void ni_quadra_device_close(int32_t handle)
Close device handle.
Definition: ni_quadra_filter_api.c:1662
_ni_frame::metadata_buffer_size
uint32_t metadata_buffer_size
Definition: ni_device_api.h:2696
ni_quadra_get_frame_idx
uint16_t ni_quadra_get_frame_idx(void *niframe)
Get niframui16FrameIdxe.
Definition: ni_quadra_filter_api.c:1713
ni_device_close
void ni_device_close(ni_device_handle_t device_handle)
Close device and release resources.
Definition: ni_device_api.c:503
_niFrameSurface1::ui16height
uint16_t ui16height
Definition: ni_device_api.h:2798
ni_fifo_generic_write
uint8_t * ni_fifo_generic_write(ni_fifo_buffer_t *p_fifo)
Get free buffer to write in the fifo.
Definition: ni_quadra_filter_api.c:148
_ni_scaler_watermark_params_t
Definition: ni_device_api.h:2584
_ni_session_context::session_id
uint32_t session_id
Definition: ni_device_api.h:1480
ni_quadra_split_ctx_set
void ni_quadra_split_ctx_set(NIFramesContext *ni_ctx, niquadraFrameSurface1_t *ni_surf, niquadraFrameSurface1_t *ni_surf_1, niquadraFrameSurface1_t *ni_surf_2, int num_extra_outputs)
Split context set.
Definition: ni_quadra_filter_api.c:1628
NIFramesContext::uploader_device_id
int uploader_device_id
Definition: ni_quadra_filter_api.h:410
ni_quadra_get_packet_data
uint8_t * ni_quadra_get_packet_data(void *nipacket)
Get nipacket data address.
Definition: ni_quadra_filter_api.c:1744
ni_fifo_return_read
int ni_fifo_return_read(ni_fifo_buffer_t *p_fifo)
Push back the last read buffer to the fifo.
Definition: ni_quadra_filter_api.c:207
ni_network_layer_convert_output
ni_retcode_t ni_network_layer_convert_output(float *dst, uint32_t dst_len, ni_packet_t *p_packet, ni_network_data_t *p_network, uint32_t layer)
Definition: ni_util.c:3084
_ni_quadra_filter_t::hw_id
int hw_id
Definition: ni_quadra_filter_api.h:353
NI_PIX_FMT_YUV420P
@ NI_PIX_FMT_YUV420P
Definition: ni_device_api.h:262
ni_device_type_t
ni_device_type_t
Definition: ni_defs.h:341
_niFrameSurface1::ui32nodeAddress
uint32_t ui32nodeAddress
Definition: ni_device_api.h:2799
_ni_session_context::isP2P
int32_t isP2P
Definition: ni_device_api.h:1617
ni_quadra_get_frame_data
uint8_t ** ni_quadra_get_frame_data(void *niframe)
Get niframe data address.
Definition: ni_quadra_filter_api.c:1738
ni_frame_buffer_alloc
ni_retcode_t ni_frame_buffer_alloc(ni_frame_t *p_frame, int video_width, int video_height, int alignment, int metadata_flag, int factor, int hw_frame_count, int is_planar)
Allocate preliminary memory for the frame buffer based on provided parameters. Applicable to YUV420 P...
Definition: ni_device_api.c:2123
_ni_session_data_io::packet
ni_packet_t packet
Definition: ni_device_api.h:2871
ni_quadra_frame_buffer_alloc_pixfmt
int ni_quadra_frame_buffer_alloc_pixfmt(void *p_frame, int pixel_format, int video_width, int video_height, int linesize[], int alignment, int extra_len)
Allocate memory for the frame buffer based on provided parameters taking into account the pixel forma...
Definition: ni_quadra_filter_api.c:635
_ni_quadra_filter_t::scaler_operation
uint32_t scaler_operation
Definition: ni_quadra_filter_api.h:355
NI_RETCODE_SUCCESS
@ NI_RETCODE_SUCCESS
Definition: ni_defs.h:427
_ni_session_context::active_video_width
uint32_t active_video_width
Definition: ni_device_api.h:1549
ni_quadra_get_session_blkiohandle
int ni_quadra_get_session_blkiohandle(void *session_ctx)
Get session context blk_io_handle.
Definition: ni_quadra_filter_api.c:1707
_ni_framerate::framerate_denom
int32_t framerate_denom
Definition: ni_device_api.h:701
NI_DEVICE_TYPE_UPLOAD
@ NI_DEVICE_TYPE_UPLOAD
Definition: ni_defs.h:353
ni_device_open
ni_device_handle_t ni_device_open(const char *p_dev, uint32_t *p_max_io_size_out)
Open device and return device device_handle if successful.
Definition: ni_device_api.c:360
AVNIDeviceContext
Definition: ni_quadra_filter_api.h:415
_ni_session_context::status
int status
Definition: ni_device_api.h:1524
ni_fifo_generic_read
uint8_t * ni_fifo_generic_read(ni_fifo_buffer_t *p_fifo)
Get first filled buffer to read in the fifo.
Definition: ni_quadra_filter_api.c:178
NI_INVALID_SESSION_ID
#define NI_INVALID_SESSION_ID
Definition: ni_device_api.h:111
ni_log_set_level
void ni_log_set_level(ni_log_level_t level)
Set ni_log_level.
Definition: ni_log.c:202
NI_PIX_FMT_BGR0
@ NI_PIX_FMT_BGR0
Definition: ni_device_api.h:270
_ni_frameclone_desc
Definition: ni_device_api.h:1375
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_quadra_filter_t::params
void * params
Definition: ni_quadra_filter_api.h:358
ni_av_codec.h
Audio/video related utility definitions.
ni_quadra_filter_hwframe_recycle
int ni_quadra_filter_hwframe_recycle(void *session_ctx, void *niframe)
Recycle a frame buffer on card.
Definition: ni_quadra_filter_api.c:1766
_ni_quadra_filter_t::device_type
uint32_t device_type
Definition: ni_quadra_filter_api.h:351
ni_packet_buffer_free
ni_retcode_t ni_packet_buffer_free(ni_packet_t *p_packet)
Free packet buffer that was previously allocated with ni_packet_buffer_alloc.
Definition: ni_device_api.c:3843
_ni_session_context::blk_io_handle
ni_device_handle_t blk_io_handle
Definition: ni_device_api.h:1465
ni_scaler_set_drawbox_params
ni_retcode_t ni_scaler_set_drawbox_params(ni_session_context_t *p_ctx, ni_scaler_drawbox_params_t *p_params)
Send a p_config command to configure scaling drawbox parameters.
Definition: ni_device_api.c:8701
_ni_quadra_scaler_watermark_params_t
Definition: ni_quadra_filter_api.h:433
ni_custom_sei_set_t
struct _ni_custom_sei_set ni_custom_sei_set_t
ni_quadra_filter_hwup_frame
int ni_quadra_filter_hwup_frame(NIFramesContext *ni_ctx, niquadraFrameSurface1_t *dst_surf, int width, int height, int ni_fmat, int nb_planes, const int *linesize, uint8_t **src_data)
Upload frame.
Definition: ni_quadra_filter_api.c:1416
NIFramesContext::api_ctx
void * api_ctx
Definition: ni_quadra_filter_api.h:405
ni_quadra_get_niframe
uint8_t * ni_quadra_get_niframe(void *niframe)
Get niframe address.
Definition: ni_quadra_filter_api.c:1720
ni_quadra_filter_device_config_frame
int ni_quadra_filter_device_config_frame(void *p_ctx, ni_quadra_frame_config_t *p_cfg)
Configure the 2D engine to work based on provided parameters.
Definition: ni_quadra_filter_api.c:1782
_ni_frame_config
Definition: ni_device_api.h:2808
NI_PIX_FMT_BGRP
@ NI_PIX_FMT_BGRP
Definition: ni_device_api.h:271
NI_SCALER_FLAG_IO
#define NI_SCALER_FLAG_IO
Definition: ni_device_api.h:291
_niFrameSurface1::src_cpu
int8_t src_cpu
Definition: ni_device_api.h:2804
_ni_session_context::src_endian
int src_endian
Definition: ni_device_api.h:1493
ni_quadra_filter_get_data3
uint8_t * ni_quadra_filter_get_data3(void *p_frame)
Get niframe data3 from device.
Definition: ni_quadra_filter_api.c:495
ni_ai_config_hvsplus
ni_retcode_t ni_ai_config_hvsplus(ni_session_context_t *p_ctx, ni_network_data_t *p_network)
configure a hvsplus filter
Definition: ni_device_api.c:9651
ni_create_hw_device_info_quadra_coder_param
ni_hw_device_info_quadra_coder_param_t * ni_create_hw_device_info_quadra_coder_param(int mode)
Create and alloc a pointer to ni_hw_device_info_quadra_coder_param_t This function is used for ni_che...
Definition: ni_rsrc_api.cpp:3118
_ni_frame::p_buffer
uint8_t * p_buffer
Definition: ni_device_api.h:2666
ni_quadra_set_session_runstatus
void ni_quadra_set_session_runstatus(void *session_ctx, int status)
Set session context run status.
Definition: ni_quadra_filter_api.c:1776
_ni_split_context_t::h
int h[3]
Definition: ni_device_api.h:1730
NIMIN
#define NIMIN(a, b)
Definition: ni_quadra_filter_api.h:113
NI_DEFAULT_KEEP_ALIVE_TIMEOUT
#define NI_DEFAULT_KEEP_ALIVE_TIMEOUT
Definition: ni_device_api.h:311
ni_quadra_build_frame_pool
int ni_quadra_build_frame_pool(ni_quadra_filter_t *nifilter, int width, int height, int out_format, int pool_size)
Alloc frame pool for filter.
Definition: ni_quadra_filter_api.c:381
ni_quadra_scaler_set_drawbox_params
int ni_quadra_scaler_set_drawbox_params(ni_quadra_filter_t *nifilter, ni_quadra_scaler_drawbox_params_t *p_params)
Send a p_config command to configure scaling drawbox parameters.
Definition: ni_quadra_filter_api.c:463
ni_device_config_frame
ni_retcode_t ni_device_config_frame(ni_session_context_t *p_ctx, ni_frame_config_t *p_cfg)
Configure the 2D engine to work based on provided parameters.
Definition: ni_device_api.c:9049
_ni_session_context::bit_depth_factor
int bit_depth_factor
Definition: ni_device_api.h:1494
_ni_session_context::hw_id
int hw_id
Definition: ni_device_api.h:1478
ni_quadra_create_hw_device_info_coder_param
ni_quadra_hw_device_info_coder_param_t * ni_quadra_create_hw_device_info_coder_param(int mode)
Create a pointer to hw_device_info_coder_param_t instance. This instance will be created and set to d...
Definition: ni_quadra_filter_api.c:1850
_ni_network_layer_params_t
Definition: ni_device_api.h:1326
ni_fifo_is_empty
int ni_fifo_is_empty(ni_fifo_buffer_t *p_fifo)
Check if a fifo is empty.
Definition: ni_quadra_filter_api.c:123
ni_quadra_check_hw_info
int ni_quadra_check_hw_info(ni_quadra_hw_device_info_t **pointer_to_p_hw_device_info, int task_mode, ni_quadra_hw_device_info_threshold_param_t *hw_info_threshold_param, int preferential_device_type, ni_quadra_hw_device_info_coder_param_t *coder_param, int hw_mode, int consider_mem)
check hw info, return the appropriate card number to use depends on the load&task_num&used resource
Definition: ni_quadra_filter_api.c:1870
ni_quadra_device_session_close
int ni_quadra_device_session_close(void *p_ctx, int eos_recieved, ni_quadra_device_type_t device_type)
Close device session that was previously opened by calling ni_device_session_open() If device_type is...
Definition: ni_quadra_filter_api.c:2020
_ni_scaler_params_t
Definition: ni_device_api.h:2566
NI_RETCODE_ERROR_MEM_ALOC
@ NI_RETCODE_ERROR_MEM_ALOC
Definition: ni_defs.h:431
AVNIDeviceContext::uploader_ID
int uploader_ID
Definition: ni_quadra_filter_api.h:417
ni_device_clone_hwframe
ni_retcode_t ni_device_clone_hwframe(ni_session_context_t *p_ctx, ni_frameclone_desc_t *p_frameclone_desc)
Copy the data of src hwframe to dst hwframe.
Definition: ni_device_api.c:8997
ni_quadra_device_session_read_hwdesc
int ni_quadra_device_session_read_hwdesc(void *p_ctx, void *p_data, int device_type)
Read data from the device If device_type is NI_DEVICE_TYPE_DECODER reads data hwdesc from decoder If ...
Definition: ni_quadra_filter_api.c:447
SESSION_RUN_STATE_NORMAL
@ SESSION_RUN_STATE_NORMAL
Definition: ni_device_api.h:1177
ni_quadra_set_framerate
void ni_quadra_set_framerate(void *p_ctx, int num, int den)
Definition: ni_quadra_filter_api.c:2050
_ni_fifo_buffer_t::number_of_buffers_used
uint32_t number_of_buffers_used
Definition: ni_quadra_filter_api.h:154
ni_quadra_init_split_rsrc
int ni_quadra_init_split_rsrc(NIFramesContext *ni_ctx, int w, int h)
Init filter split context malloc session and set it default.
Definition: ni_quadra_filter_api.c:705
_ni_session_context::framerate
ni_framerate_t framerate
Definition: ni_device_api.h:1604
ni_quadra_device_session_read
int ni_quadra_device_session_read(void *p_ctx, void *p_data, int device_type)
Read data from the device If device_type is NI_DEVICE_TYPE_DECODER reads data packet from decoder If ...
Definition: ni_quadra_filter_api.c:455
ni_quadra_device_session_write
int ni_quadra_device_session_write(void *p_ctx, void *p_data, ni_quadra_device_type_t device_type)
Sends data to the device If device_type is NI_DEVICE_TYPE_DECODER sends data packet to decoder If dev...
Definition: ni_quadra_filter_api.c:1948
_ni_quadra_device_pool
Definition: ni_quadra_filter_api.h:538
NIMAX
#define NIMAX(a, b)
Definition: ni_quadra_filter_api.h:112
_ni_quadra_frame_config
Definition: ni_quadra_filter_api.h:258
NI_QUADRA_DEVICE_TYPE_AI
@ NI_QUADRA_DEVICE_TYPE_AI
Definition: ni_quadra_filter_api.h:225
_niFrameSurface1::ui16FrameIdx
uint16_t ui16FrameIdx
Definition: ni_device_api.h:2795
ni_rsrc_get_device_pool
LIB_API ni_device_pool_t * ni_rsrc_get_device_pool(void)
Create and return the allocated ni_device_pool_t struct.
_ni_fifo_buffer_t::rndx
uint32_t rndx
Definition: ni_quadra_filter_api.h:156
AVNIDeviceContext::uploader_handle
int32_t uploader_handle
Definition: ni_quadra_filter_api.h:418
NI_APP_ENC_FRAME_META_DATA_SIZE
#define NI_APP_ENC_FRAME_META_DATA_SIZE
Definition: ni_defs.h:308
NI_LOG_ERROR
@ NI_LOG_ERROR
Definition: ni_log.h:60
_ni_session_context::src_bit_depth
int src_bit_depth
Definition: ni_device_api.h:1492
ni_quadra_packet_buffer_free
int ni_quadra_packet_buffer_free(void *p_data)
Free packet buffer that was previously allocated with ni_packet_buffer_alloc.
Definition: ni_quadra_filter_api.c:1965
NI_MAX_RESOLUTION_WIDTH
#define NI_MAX_RESOLUTION_WIDTH
Definition: ni_device_api.h:100
_ni_framerate::framerate_num
int32_t framerate_num
Definition: ni_device_api.h:698
_niFrameSurface1::ui16session_ID
uint16_t ui16session_ID
Definition: ni_device_api.h:2796
ni_ai_packet_buffer_alloc
ni_retcode_t ni_ai_packet_buffer_alloc(ni_packet_t *p_packet, ni_network_data_t *p_network)
Allocate output layers memory for the packet buffer based on provided network.
Definition: ni_device_api.c:9779
ni_defs.h
Common NETINT definitions used by all modules.
NI_PIX_FMT_NV12
@ NI_PIX_FMT_NV12
Definition: ni_device_api.h:264
ni_quadra_filter_device_create
int ni_quadra_filter_device_create(AVNIDeviceContext *ni_hw_ctx, const char *device)
Sends frame pool setup info to device.
Definition: ni_quadra_filter_api.c:958
_ni_frame::data_len
uint32_t data_len[NI_MAX_NUM_DATA_POINTERS]
Definition: ni_device_api.h:2664
_ni_frame::extra_data_len
unsigned int extra_data_len
Definition: ni_device_api.h:2657
ni_quadra_device_session_copy
int ni_quadra_device_session_copy(void *src_ctx, void *dst_ctx)
Copy filter session context.
Definition: ni_quadra_filter_api.c:1685
ni_quadra_device_session_context_clear
void ni_quadra_device_session_context_clear(void *p_ctx)
Clear already allocated session context.
Definition: ni_quadra_filter_api.c:2035
ni_quadra_get_hw_yuv420p_dim
void ni_quadra_get_hw_yuv420p_dim(int width, int height, int factor, int is_semiplanar, int plane_stride[4], int plane_height[4])
Get dimension information of Netint HW YUV420p frame to be sent to encoder for encoding....
Definition: ni_quadra_filter_api.c:1795
ni_quadra_filter_device_session_init_framepool
int ni_quadra_filter_device_session_init_framepool(NIFramesContext *ni_ctx, uint32_t pool_size, uint32_t pool)
Sends frame pool setup info to device.
Definition: ni_quadra_filter_api.c:747
ni_quadra_get_session_frame_num
int ni_quadra_get_session_frame_num(void *p_ctx)
Get session_ctx send/recieve frame number.
Definition: ni_quadra_filter_api.c:2064
ni_device_session_hwup
int ni_device_session_hwup(ni_session_context_t *p_ctx, ni_session_data_io_t *p_src_data, niFrameSurface1_t *hwdesc)
Sends raw YUV input to uploader instance and retrieves a HW descriptor to represent it.
Definition: ni_device_api.c:8363
va_list
__gnuc_va_list va_list
Definition: ni_quadra_filter_api.h:69
ni_quadra_init_filters
int ni_quadra_init_filters(ni_quadra_filter_t *nifilter)
Init filter.
Definition: ni_quadra_filter_api.c:228
_ni_quadra_network_data
Definition: ni_quadra_filter_api.h:312
NIFramesContext::src_session_io_data
void * src_session_io_data
Definition: ni_quadra_filter_api.h:406
_ni_scaler_params_t::nb_inputs
int nb_inputs
Definition: ni_device_api.h:2569
_ni_scaler_drawbox_params_t
Definition: ni_device_api.h:2575
NI_LOG_TRACE
@ NI_LOG_TRACE
Definition: ni_log.h:63
ni_scaler_set_watermark_params
ni_retcode_t ni_scaler_set_watermark_params(ni_session_context_t *p_ctx, ni_scaler_watermark_params_t *p_params)
Send a p_config command to configure scaling watermark parameters.
Definition: ni_device_api.c:8781
ni_pthread_mutex_lock
int ni_pthread_mutex_lock(ni_pthread_mutex_t *mutex)
thread mutex lock
Definition: ni_util.c:4057
_niFrameSurface1::encoding_type
int8_t encoding_type
Definition: ni_device_api.h:2802
NI_PIX_FMT_NV16
@ NI_PIX_FMT_NV16
Definition: ni_device_api.h:272
_ni_session_context::device_handle
ni_device_handle_t device_handle
Definition: ni_device_api.h:1462
ni_ai_network_layer_dims
uint32_t ni_ai_network_layer_dims(ni_network_layer_params_t *p_param)
Definition: ni_util.c:3369
ni_quadra_filter_api.h
NETINT filters API header file.
_ni_packet::p_data
void * p_data
Definition: ni_device_api.h:2837
_ni_session_data_io
Definition: ni_device_api.h:2866
ni_quadra_get_session_status
int ni_quadra_get_session_status(void *session_ctx)
Get session context status.
Definition: ni_quadra_filter_api.c:1697
_niquadraFrameSurface1::ui16width
uint16_t ui16width
Definition: ni_quadra_filter_api.h:389
ni_quadra_init_internal_session
int ni_quadra_init_internal_session(NIFramesContext *ni_ctx)
Init filter session context only malloc session.
Definition: ni_quadra_filter_api.c:654
_ni_quadra_filter_t::dst_frame
void * dst_frame
Definition: ni_quadra_filter_api.h:359
NI_PIX_FMT_YUV420P10LE
@ NI_PIX_FMT_YUV420P10LE
Definition: ni_device_api.h:263
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_quadra_get_device_handle
int32_t ni_quadra_get_device_handle(void *session_ctx)
Get session device handle id.
Definition: ni_quadra_filter_api.c:1667
_ni_split_context_t
Definition: ni_device_api.h:1726
ni_frame_buffer_alloc_pixfmt
ni_retcode_t ni_frame_buffer_alloc_pixfmt(ni_frame_t *p_frame, int pixel_format, int video_width, int video_height, int linesize[], int alignment, int extra_len)
Allocate memory for the frame buffer based on provided parameters taking into account the pixel forma...
Definition: ni_device_api.c:9252
ni_quadra_get_session_id
uint32_t ni_quadra_get_session_id(void *session_ctx)
Get session device session id.
Definition: ni_quadra_filter_api.c:1656
ni_quadra_session_timestamp_copy
void ni_quadra_session_timestamp_copy(void *src_ctx, void *dst_ctx)
Copy filter session context.
Definition: ni_quadra_filter_api.c:1690
_ni_device_info::module_id
int module_id
Definition: ni_rsrc_api.h:107
_ni_session_context::keep_alive_timeout
uint32_t keep_alive_timeout
Definition: ni_device_api.h:1521
ni_quadra_upload_device_session_open
int ni_quadra_upload_device_session_open(NIFramesContext *ni_ctx)
Open hwupload filter.
Definition: ni_quadra_filter_api.c:742
ni_ai_frame_buffer_alloc
ni_retcode_t ni_ai_frame_buffer_alloc(ni_frame_t *p_frame, ni_network_data_t *p_network)
Allocate input layers memory for AI frame buffer based on provided parameters taking into account wid...
Definition: ni_device_api.c:9698
_ni_quadra_filter_t::scaler_param_b
double scaler_param_b
Definition: ni_quadra_filter_api.h:371
ni_quadra_filter_session_dl_set
void ni_quadra_filter_session_dl_set(void *session_ctx, bool value)
Set download filter session context.
Definition: ni_quadra_filter_api.c:1679
_ni_hw_device_info_quadra_coder_param
Definition: ni_rsrc_api.h:221
ni_quadra_get_frame_buffer
uint8_t * ni_quadra_get_frame_buffer(void *niframe)
Get niframe buffer address.
Definition: ni_quadra_filter_api.c:1726
_ni_fifo_buffer_t
Definition: ni_quadra_filter_api.h:149
_ni_session_context::device_type
uint32_t device_type
Definition: ni_device_api.h:1484
_niquadraFrameSurface1
Definition: ni_quadra_filter_api.h:385
_ni_scaler_params_t::scaler_param_b
double scaler_param_b
Definition: ni_device_api.h:2570
ni_encoder_frame_zerocopy_buffer_alloc
ni_retcode_t ni_encoder_frame_zerocopy_buffer_alloc(ni_frame_t *p_frame, int video_width, int video_height, const int linesize[], const uint8_t *data[], int extra_len)
Allocate memory for encoder zero copy (metadata, etc.) for encoding based on given parameters,...
Definition: ni_device_api.c:2879
LRETURN
#define LRETURN
Definition: ni_defs.h:323
NI_PIXEL_PLANAR_FORMAT_SEMIPLANAR
@ NI_PIXEL_PLANAR_FORMAT_SEMIPLANAR
Definition: ni_device_api.h:920
_ni_quadra_scaler_drawbox_params_t
Definition: ni_quadra_filter_api.h:424
_ni_scaler_params_t::enable_scaler_params
bool enable_scaler_params
Definition: ni_device_api.h:2572
NIFramesContext::suspended_device_handle
int32_t suspended_device_handle
Definition: ni_quadra_filter_api.h:409
ni_quadra_filter_frames_close
int ni_quadra_filter_frames_close(NIFramesContext *ni_ctx, int pool_size)
Close filter context and frame.
Definition: ni_quadra_filter_api.c:755
_ni_packet
Definition: ni_device_api.h:2825
_ni_fifo_buffer_t::buffer_size
uint32_t buffer_size
Definition: ni_quadra_filter_api.h:153
ni_quadra_hw_device_info_free
void ni_quadra_hw_device_info_free(ni_quadra_hw_device_info_t *p_hw_device_info)
Release a pointer to ni_hw_device_info_quadra_t instance created by create_hw_device_info_coder_param...
Definition: ni_quadra_filter_api.c:1865
_ni_session_context::frame_num
uint64_t frame_num
Definition: ni_device_api.h:1531
ni_device_session_context_clear
void ni_device_session_context_clear(ni_session_context_t *p_ctx)
Clear already allocated session context.
Definition: ni_device_api.c:249
ni_quadra_get_packet_data_len
uint32_t ni_quadra_get_packet_data_len(void *nipacket)
Get nipacket data len.
Definition: ni_quadra_filter_api.c:1750
NIALIGN
#define NIALIGN(x, a)
Definition: ni_quadra_enc_api.h:54
ni_quadra_get_device_id
int ni_quadra_get_device_id(void *session_ctx)
Get session device id.
Definition: ni_quadra_filter_api.c:1650
ni_quadra_frame_buffer_free
int ni_quadra_frame_buffer_free(void *p_data)
Free frame buffer that was previously allocated with either ni_frame_buffer_alloc or ni_encoder_frame...
Definition: ni_quadra_filter_api.c:1982
ni_quadra_ai_frame_buffer_alloc
int ni_quadra_ai_frame_buffer_alloc(void *p_frame, ni_quadra_network_data_t *p_network)
Allocate input layers memory for AI frame buffer based on provided parameters taking into account wid...
Definition: ni_quadra_filter_api.c:600
_ni_frame::p_data
uint8_t * p_data[NI_MAX_NUM_DATA_POINTERS]
Definition: ni_device_api.h:2663
NI_VPU_CEIL
#define NI_VPU_CEIL(_data, _align)
Definition: ni_device_api.h:328
ni_quadra_device_session_hwdl
int ni_quadra_device_session_hwdl(void *p_ctx, void *p_data, niquadraFrameSurface1_t *hwdesc)
Reads YUV data from hw descriptor stored location on device.
Definition: ni_quadra_filter_api.c:646
ni_fifo_initialize
ni_fifo_buffer_t * ni_fifo_initialize(uint32_t number_of_buffers, uint32_t size)
Initialize a fifo buffer.
Definition: ni_quadra_filter_api.c:44
ni_device_alloc_frame
ni_retcode_t ni_device_alloc_frame(ni_session_context_t *p_ctx, int width, int height, int format, int options, int rectangle_width, int rectangle_height, int rectangle_x, int rectangle_y, int rgba_color, int frame_index, ni_device_type_t device_type)
Allocate a frame on the device for 2D engine or AI engine to work on based on provided parameters.
Definition: ni_device_api.c:8880
ni_log_set_callback
void ni_log_set_callback(void(*log_callback)(int, const char *, va_list))
Set ni_log() callback.
Definition: ni_log.c:169
_ni_device_info::blk_name
char blk_name[NI_MAX_DEVICE_NAME_LEN]
Definition: ni_rsrc_api.h:105
NI_QUADRA_MAX_NUM_DATA_POINTERS
#define NI_QUADRA_MAX_NUM_DATA_POINTERS
Definition: ni_quadra_filter_api.h:86
NI_DEVICE_TYPE_SCALER
@ NI_DEVICE_TYPE_SCALER
Definition: ni_defs.h:348
ni_quadra_hwframe_buffer_recycle
int ni_quadra_hwframe_buffer_recycle(niquadraFrameSurface1_t *surface, int32_t device_handle)
Recycle a frame buffer on card.
Definition: ni_quadra_filter_api.c:1789
ni_fifo_is_full
int ni_fifo_is_full(ni_fifo_buffer_t *p_fifo)
Check if a fifo is full.
Definition: ni_quadra_filter_api.c:111
NI_ERRNO
#define NI_ERRNO
Definition: ni_defs.h:217
ni_quadra_filter_device_alloc_frame
int ni_quadra_filter_device_alloc_frame(ni_quadra_filter_t *nifilter, int width, int height, int format, int options, int rectangle_width, int rectangle_height, int rectangle_x, int rectangle_y, int rgba_color, int frame_index, int type)
Allocate a frame on the device for 2D engine or AI engine to work on based on provided parameters.
Definition: ni_quadra_filter_api.c:415
NIFramesContext
Definition: ni_quadra_filter_api.h:400
_ni_quadra_filter_t::is_p2p
bool is_p2p
Definition: ni_quadra_filter_api.h:368
_ni_session_context::hw_action
int hw_action
Definition: ni_device_api.h:1609
_niquadraFrameSurface1::encoding_type
int8_t encoding_type
Definition: ni_quadra_filter_api.h:394
_ni_session_context
Definition: ni_device_api.h:1408
ni_fifo_number_of_buffers
uint32_t ni_fifo_number_of_buffers(ni_fifo_buffer_t *p_fifo)
Get number of buffers used in fifo.
Definition: ni_quadra_filter_api.c:135
ni_quadra_filter_device_close
void ni_quadra_filter_device_close(AVNIDeviceContext *ni_hw_ctx)
Close device.
Definition: ni_quadra_filter_api.c:720
NI_PIX_FMT_P010LE
@ NI_PIX_FMT_P010LE
Definition: ni_device_api.h:265
NI_MAX_DEVICE_CNT
#define NI_MAX_DEVICE_CNT
Definition: ni_defs.h:223
ni_device_session_read
int ni_device_session_read(ni_session_context_t *p_ctx, ni_session_data_io_t *p_data, ni_device_type_t device_type)
Read data from the device If device_type is NI_DEVICE_TYPE_DECODER reads data packet from decoder If ...
Definition: ni_device_api.c:1769
_niFrameSurface1
Definition: ni_device_api.h:2793
ni_frame_buffer_alloc_hwenc
ni_retcode_t ni_frame_buffer_alloc_hwenc(ni_frame_t *p_frame, int video_width, int video_height, int extra_len)
Allocate memory for the hwDescriptor buffer based on provided parameters taking into account pic size...
Definition: ni_device_api.c:8399
NI_QUADRA_SCALER_OPCODE_SCALE
@ NI_QUADRA_SCALER_OPCODE_SCALE
Definition: ni_quadra_filter_api.h:181
_ni_quadra_filter_t::filterblit
int filterblit
Definition: ni_quadra_filter_api.h:369
_ni_quadra_filter_t::dl_frame
void * dl_frame
Definition: ni_quadra_filter_api.h:361
ni_pthread_mutex_init
int ni_pthread_mutex_init(ni_pthread_mutex_t *mutex)
initialize a mutex
Definition: ni_util.c:4001
_ni_session_data_io::data
union _ni_session_data_io::@19 data
_ni_frame
Definition: ni_device_api.h:2601
NI_PIX_FMT_YUYV422
@ NI_PIX_FMT_YUYV422
Definition: ni_device_api.h:273
NI_PIX_FMT_RGBA
@ NI_PIX_FMT_RGBA
Definition: ni_device_api.h:266
ni_device_session_open
ni_retcode_t ni_device_session_open(ni_session_context_t *p_ctx, ni_device_type_t device_type)
Open a new device session depending on the device_type parameter If device_type is NI_DEVICE_TYPE_DEC...
Definition: ni_device_api.c:710
ni_quadra_filter_frame_buffer_alloc_hwenc
int ni_quadra_filter_frame_buffer_alloc_hwenc(ni_quadra_filter_t *nifilter, int video_width, int video_height, int extra_len)
Allocate memory for the hwDescriptor buffer based on provided parameters taking into account pic size...
Definition: ni_quadra_filter_api.c:406
_ni_quadra_filter_t::scaler_param_c
double scaler_param_c
Definition: ni_quadra_filter_api.h:372
_niquadraFrameSurface1::bit_depth
int8_t bit_depth
Definition: ni_quadra_filter_api.h:393
_ni_quadra_hw_device_info_threshold_param
Definition: ni_quadra_filter_api.h:516
NI_PIX_FMT_ABGR
@ NI_PIX_FMT_ABGR
Definition: ni_device_api.h:269
ni_device_session_copy
ni_retcode_t ni_device_session_copy(ni_session_context_t *src_p_ctx, ni_session_context_t *dst_p_ctx)
Copy existing decoding session params for hw frame usage.
Definition: ni_device_api.c:8015
NI_PIX_FMT_ARGB
@ NI_PIX_FMT_ARGB
Definition: ni_device_api.h:268
_ni_quadra_filter_t::device_handle
int32_t device_handle
Definition: ni_quadra_filter_api.h:348
ni_quadra_filter_frame_buffer_alloc_dl
int ni_quadra_filter_frame_buffer_alloc_dl(void *niframe, int video_width, int video_height, int pixel_format)
Allocate preliminary memory for the frame buffer based on provided parameters.
Definition: ni_quadra_filter_api.c:520
ni_quadra_get_frame_buffer_size
uint32_t ni_quadra_get_frame_buffer_size(void *niframe)
Get niframe buffer size.
Definition: ni_quadra_filter_api.c:1732
_ni_session_context::scaler_operation
uint32_t scaler_operation
Definition: ni_device_api.h:1610
ni_device_alloc_dst_frame
ni_retcode_t ni_device_alloc_dst_frame(ni_session_context_t *p_ctx, niFrameSurface1_t *p_out_surface, ni_device_type_t device_type)
Allocate a frame on the device and return the frame index.
Definition: ni_device_api.c:8947
_ni_session_context::is_auto_dl
uint8_t is_auto_dl
Definition: ni_device_api.h:1470
_niFrameSurface1::ui16width
uint16_t ui16width
Definition: ni_device_api.h:2797
_ni_session_data_io::frame
ni_frame_t frame
Definition: ni_device_api.h:2870
ni_quadra_filter_device_alloc_dst_frame
int ni_quadra_filter_device_alloc_dst_frame(ni_quadra_filter_t *nifilter, niquadraFrameSurface1_t *p_hwdesc, int type)
Allocate a frame on the device and return the frame index.
Definition: ni_quadra_filter_api.c:428
ni_quadra_scaler_set_watermark_params
int ni_quadra_scaler_set_watermark_params(ni_quadra_filter_t *nifilter, ni_quadra_scaler_watermark_params_t *p_params)
Send a p_config command to configure watermark parameters.
Definition: ni_quadra_filter_api.c:470
ni_quadra_ai_network_layer_size
uint32_t ni_quadra_ai_network_layer_size(ni_quadra_network_layer_params_t *p_param)
Definition: ni_quadra_filter_api.c:620
ni_quadra_filter_frame_free
void ni_quadra_filter_frame_free(void *opaque, uint8_t *data)
Free filter frame.
Definition: ni_quadra_filter_api.c:1052
NI_QUADRA_SCALER_OPCODE_DRAWBOX
@ NI_QUADRA_SCALER_OPCODE_DRAWBOX
Definition: ni_quadra_filter_api.h:188
_ni_scaler_params_t::filterblit
int filterblit
Definition: ni_device_api.h:2568
ni_quadra_filter_get_output_data
int ni_quadra_filter_get_output_data(ni_quadra_filter_t *nifilter, uint8_t *data, int width, int height)
Get data from device.
Definition: ni_quadra_filter_api.c:477
_niFrameSurface1::output_idx
int8_t output_idx
Definition: ni_device_api.h:2803
NI_SCALER_FLAG_P2
#define NI_SCALER_FLAG_P2
Definition: ni_device_api.h:294
_ni_quadra_filter_t::blk_io_handle
int32_t blk_io_handle
Definition: ni_quadra_filter_api.h:349
ni_quadra_device_type_t
ni_quadra_device_type_t
Definition: ni_quadra_filter_api.h:217
_ni_split_context_t::enabled
int enabled
Definition: ni_device_api.h:1728
ni_quadra_rsrc_get_device_pool
ni_quadra_device_pool_t * ni_quadra_rsrc_get_device_pool(void)
Create and return the allocated ni_device_pool_t struct.
Definition: ni_quadra_filter_api.c:1995
atoi
#define atoi(p_str)
Definition: ni_device_api.c:7178
_ni_quadra_filter_t::session_opened
int session_opened
Definition: ni_quadra_filter_api.h:366
ni_quadra_filter_get_buffer
int ni_quadra_filter_get_buffer(NIFramesContext *ni_ctx, uint8_t **dstbuf, uint8_t **dstdata, uint32_t *data_len, int width, int height, int is_planar)
Sends frame pool setup info to device.
Definition: ni_quadra_filter_api.c:1025
END
#define END
Definition: ni_defs.h:324
AVNIDeviceContext::cards
int32_t cards[128]
Definition: ni_quadra_filter_api.h:420
ni_check_hw_info
int ni_check_hw_info(ni_hw_device_info_quadra_t **pointer_to_p_hw_device_info, int task_mode, ni_hw_device_info_quadra_threshold_param_t *hw_info_threshold_param, ni_device_type_t preferential_device_type, ni_hw_device_info_quadra_coder_param_t *coder_param, int hw_mode, int consider_mem)
check hw info, return the appropriate card number to use depends on the load&task_num&used resource
Definition: ni_rsrc_api.cpp:3401
ni_rsrc_list_all_devices
ni_retcode_t ni_rsrc_list_all_devices(ni_device_t *p_device)
List all devices with full information including s/w instances on the system.
Definition: ni_rsrc_api.cpp:1445
_ni_session_context::hvsplus_level
int hvsplus_level
encoder:calculate PSNR end
Definition: ni_device_api.h:1715
_ni_session_context::active_video_height
uint32_t active_video_height
Definition: ni_device_api.h:1551
ni_pthread_mutex_destroy
int ni_pthread_mutex_destroy(ni_pthread_mutex_t *mutex)
destory a mutex
Definition: ni_util.c:4039
ni_fifo_free
void ni_fifo_free(ni_fifo_buffer_t *p_fifo)
Free a fifo.
Definition: ni_quadra_filter_api.c:85
_ni_session_context::session_run_state
ni_session_run_state_t session_run_state
Definition: ni_device_api.h:1547
_niFrameSurface1::device_handle
int32_t device_handle
Definition: ni_device_api.h:2800
ni_quadra_filter_device_clone_hwframe
int ni_quadra_filter_device_clone_hwframe(ni_quadra_filter_t *nifilter, ni_quadra_frameclone_desc_t *p_frameclone_desc)
Copy the data of src hwframe to dst hwframe.
Definition: ni_quadra_filter_api.c:438
ni_quadra_log_level_t
ni_quadra_log_level_t
Definition: ni_quadra_filter_api.h:159
ni_device_session_write
int ni_device_session_write(ni_session_context_t *p_ctx, ni_session_data_io_t *p_data, ni_device_type_t device_type)
Sends data to the device If device_type is NI_DEVICE_TYPE_DECODER sends data packet to decoder If dev...
Definition: ni_device_api.c:1668
ni_device_api.h
Public definitions for operating NETINT video processing devices for video processing.
ni_hwframe_buffer_recycle
ni_retcode_t ni_hwframe_buffer_recycle(niFrameSurface1_t *surface, int32_t device_handle)
Recycle a frame buffer on card.
Definition: ni_device_api.c:8487
_ni_fifo_buffer_t::buffer
uint8_t * buffer
Definition: ni_quadra_filter_api.h:155
_ni_quadra_filter_t::txt_frame
void * txt_frame
Definition: ni_quadra_filter_api.h:362
_ni_session_context::session_timestamp
uint64_t session_timestamp
Definition: ni_device_api.h:1482
ni_quadra_get_session_packet_num
int ni_quadra_get_session_packet_num(void *p_ctx)
Get session_ctx send/recive packet number.
Definition: ni_quadra_filter_api.c:2058
_ni_fifo_buffer_t::number_of_buffers
uint32_t number_of_buffers
Definition: ni_quadra_filter_api.h:152
NI_MIN_HEIGHT
#define NI_MIN_HEIGHT
Definition: ni_device_api.h:126
NI_RETCODE_FAILURE
@ NI_RETCODE_FAILURE
Definition: ni_defs.h:428
_niFrameSurface1::dma_buf_fd
int32_t dma_buf_fd
Definition: ni_device_api.h:2805
ni_quadra_log_set_level
void ni_quadra_log_set_level(int level)
Set ni_log_level.
Definition: ni_quadra_filter_api.c:1834
_ni_fifo_buffer_t::wndx
uint32_t wndx
Definition: ni_quadra_filter_api.h:156
NI_SCALER_FLAG_PC
#define NI_SCALER_FLAG_PC
Definition: ni_device_api.h:292
_ni_fifo_buffer_t::mutex
pthread_mutex_t mutex
Definition: ni_quadra_filter_api.h:151
ni_util.h
Utility definitions.
ni_device_session_hwdl
int ni_device_session_hwdl(ni_session_context_t *p_ctx, ni_session_data_io_t *p_data, niFrameSurface1_t *hwdesc)
Reads YUV data from hw descriptor stored location on device.
Definition: ni_device_api.c:8210
ni_device_session_read_hwdesc
int ni_device_session_read_hwdesc(ni_session_context_t *p_ctx, ni_session_data_io_t *p_data, ni_device_type_t device_type)
Read data from the device If device_type is NI_DEVICE_TYPE_DECODER reads data hwdesc from decoder If ...
Definition: ni_device_api.c:8043
_ni_split_context_t::f
int f[3]
Definition: ni_device_api.h:1731
ni_quadra_filter_close
void ni_quadra_filter_close(ni_quadra_filter_t *nifilter)
Close filter.
Definition: ni_quadra_filter_api.c:529
ni_quadra_destory_hw_device_info_coder_param
void ni_quadra_destory_hw_device_info_coder_param(ni_quadra_hw_device_info_coder_param_t *p_quadra_hw_device_info_coder_param)
Release a pointer to hw_device_info_coder_param_t instance created by create_hw_device_info_coder_par...
Definition: ni_quadra_filter_api.c:1855
_ni_hw_device_info_quadra_threshold_param
Definition: ni_rsrc_api.h:214
_ni_quadra_filter_t::dst_pkt
void * dst_pkt
Definition: ni_quadra_filter_api.h:363
_ni_hw_device_info_quadra
Definition: ni_rsrc_api.h:163
ni_frame_buffer_alloc_dl
ni_retcode_t ni_frame_buffer_alloc_dl(ni_frame_t *p_frame, int video_width, int video_height, int pixel_format)
Allocate preliminary memory for the frame buffer based on provided parameters.
Definition: ni_device_api.c:2393
ni_hw_device_info_alloc_quadra
ni_hw_device_info_quadra_t * ni_hw_device_info_alloc_quadra(int device_type_num, int avaliable_card_num)
Create a ni_hw_device_info_quadra_t This function is used for ni_check_hw_info()
Definition: ni_rsrc_api.cpp:3310
ni_quadra_filter_frames_init
int ni_quadra_filter_frames_init(NIFramesContext *ni_ctx, int *width, int *height, int ni_fmat, int keep_alive_time)
Init filter frame context and set value to session context.
Definition: ni_quadra_filter_api.c:809
ni_aligned_free
#define ni_aligned_free(p_memptr)
Definition: ni_util.h:399
ni_quadra_frame_buffer_alloc_hwenc
int ni_quadra_frame_buffer_alloc_hwenc(void *niframe, int video_width, int video_height, int extra_len)
Definition: ni_quadra_filter_api.c:2041
_ni_session_context::pkt_num
uint64_t pkt_num
Definition: ni_device_api.h:1532
ni_quadra_ai_network_layer_dims
uint32_t ni_quadra_ai_network_layer_dims(ni_quadra_network_layer_params_t *p_param)
Get dims from ni_quadra_network_layer_params_t.
Definition: ni_quadra_filter_api.c:615
ni_quadra_get_frame_data_len
void ni_quadra_get_frame_data_len(void *niframe, uint32_t *dst_datalen)
Get niframe data datalen.
Definition: ni_quadra_filter_api.c:1756
_ni_frame::start_buffer_size
uint32_t start_buffer_size
Definition: ni_device_api.h:2703
ni_quadra_filter_hwdl_frame
int ni_quadra_filter_hwdl_frame(NIFramesContext *ni_ctx, niquadraFrameSurface1_t *src_surf, int width, int height, int ni_fmat, int nb_planes, const int *linesize, uint8_t **dst_data)
Download frame.
Definition: ni_quadra_filter_api.c:1588
NI_FRAME_LITTLE_ENDIAN
#define NI_FRAME_LITTLE_ENDIAN
Definition: ni_device_api.h:108
NI_MIN_WIDTH
#define NI_MIN_WIDTH
Definition: ni_device_api.h:124
ni_device_session_context_init
ni_retcode_t ni_device_session_context_init(ni_session_context_t *p_ctx)
Initialize already allocated session context to a known state.
Definition: ni_device_api.c:156
ni_uploader_frame_zerocopy_check
ni_retcode_t ni_uploader_frame_zerocopy_check(ni_session_context_t *p_upl_ctx, int width, int height, const int linesize[], int pixel_format)
Check if incoming frame is hwupload zero copy compatible or not.
Definition: ni_device_api.c:3028
ni_device_session_init_framepool
int ni_device_session_init_framepool(ni_session_context_t *p_ctx, uint32_t pool_size, uint32_t pool)
Sends frame pool setup info to device.
Definition: ni_device_api.c:8564
_ni_session_context::pixel_format
int pixel_format
Definition: ni_device_api.h:1616
QUADRA
#define QUADRA
Definition: ni_defs.h:120
ni_ai_network_layer_size
uint32_t ni_ai_network_layer_size(ni_network_layer_params_t *p_param)
Definition: ni_util.c:3363
NIFramesContext::split_ctx
ni_quadra_split_context_t split_ctx
Definition: ni_quadra_filter_api.h:407
NI_LOG_DEBUG
@ NI_LOG_DEBUG
Definition: ni_log.h:62
ni_quadra_get_seiset_size
int ni_quadra_get_seiset_size()
Recycle a frame buffer on card.
Definition: ni_quadra_filter_api.c:1829
_ni_quadra_hw_device_info
Definition: ni_quadra_filter_api.h:465
_ni_quadra_filter_t::keep_alive_timeout
int keep_alive_timeout
Definition: ni_quadra_filter_api.h:367
_ni_quadra_filter_t
Definition: ni_quadra_filter_api.h:346
ni_device_session_close
ni_retcode_t ni_device_session_close(ni_session_context_t *p_ctx, int eos_recieved, ni_device_type_t device_type)
Close device session that was previously opened by calling ni_device_session_open() If device_type is...
Definition: ni_device_api.c:1379
NI_PIXEL_PLANAR_FORMAT_PLANAR
@ NI_PIXEL_PLANAR_FORMAT_PLANAR
Definition: ni_device_api.h:921
ni_hw_device_info_free_quadra
void ni_hw_device_info_free_quadra(ni_hw_device_info_quadra_t *p_hw_device_info)
Free resource in a pointer of ni_hw_device_info_quadra_t This function is used for ni_check_hw_info()
Definition: ni_rsrc_api.cpp:3381
NIFramesContext::dst_frame
void * dst_frame
Definition: ni_quadra_filter_api.h:408
ni_quadra_ai_config_network_binary
int ni_quadra_ai_config_network_binary(ni_quadra_filter_t *nifilter, ni_quadra_network_data_t *p_network, const char *file)
configure a network context based with the network binary
Definition: ni_quadra_filter_api.c:575
_ni_split_context_t::w
int w[3]
Definition: ni_device_api.h:1729
NI_MAX_RESOLUTION_AREA
#define NI_MAX_RESOLUTION_AREA
Definition: ni_device_api.h:102
ni_rsrc_get_device_by_block_name
int ni_rsrc_get_device_by_block_name(const char *blk_name, ni_device_type_t device_type)
Get GUID of the device by block device name and type.
Definition: ni_rsrc_api.cpp:1799
_ni_quadra_frameclone_desc
Definition: ni_quadra_filter_api.h:324
_ni_scaler_params_t::scaler_param_c
double scaler_param_c
Definition: ni_device_api.h:2571
ni_quadra_filter_drawtext_prep_frames
int ni_quadra_filter_drawtext_prep_frames(void **niframe)
prepare frames for ni_drawtext filter
Definition: ni_quadra_filter_api.c:501
_ni_packet::data_len
uint32_t data_len
Definition: ni_device_api.h:2838