[Filter/Custom] Expose filter properties to custom filters

In order to let custom filters to be flexible,
they need to be aware of filter/main's properties (e.g., pad caps).

Signed-off-by: MyungJoo Ham <myungjoo.ham@samsung.com>

diff --git a/include/tensor_filter_custom.h b/include/tensor_filter_custom.h
index c182f3b..8a5a140 100644 (file)
--- a/include/tensor_filter_custom.h
+++ b/include/tensor_filter_custom.h
@@ -65,41 +65,46 @@
 
 /**
  * @brief A function that is called before calling other functions.
+ * @param[in] prop Tensor_Filter's property values. Do not change its values.
  * @return The returned pointer will be passed to other functions as "private_data".
  */
-typedef void *(*NNS_custom_init_func)(void);
+typedef void *(*NNS_custom_init_func)(const GstTensor_Filter_Properties *prop);
 
 /**
  * @brief A function that is called after calling other functions, when it's ready to close.
  * @param[in] private_data If you have allocated *private_data at init, free it here.
+ * @param[in] prop Tensor_Filter's property values. Do not change its values.
  */
-typedef void (*NNS_custom_exit_func)(void *private_data);
+typedef void (*NNS_custom_exit_func)(void *private_data, const GstTensor_Filter_Properties *prop);
 
 /**
  * @brief Get input tensor type.
  * @param[in] private_data The pointer returned by NNStreamer_custom_exit.
+ * @param[in] prop Tensor_Filter's property values. Do not change its values.
  * @param[out] inputDimension uint32_t[NNS_TENSOR_RANK_LIMIT]
  * @param[out] type Type of each element in the input tensor
  */
-typedef int (*NNS_custom_get_input_dimension)(void *private_data,
+typedef int (*NNS_custom_get_input_dimension)(void *private_data, const GstTensor_Filter_Properties *prop,
     uint32_t *inputDimension, tensor_type *type);
 
 /**
  * @brief Get output tensor type.
  * @param[in] private_data The pointer returned by NNStreamer_custom_exit.
+ * @param[in] prop Tensor_Filter's property values. Do not change its values.
  * @param[out] outputDimension uint32_t[NNS_TENSOR_RANK_LIMIT]
  * @param[out] type Type of each element in the output tensor
  */
-typedef int (*NNS_custom_get_output_dimension)(void *private_data,
+typedef int (*NNS_custom_get_output_dimension)(void *private_data, const GstTensor_Filter_Properties *prop,
     uint32_t *outputDimension, tensor_type *type);
 
 /**
  * @brief Invoke the "main function".
  * @param[in] private_data The pointer returned by NNStreamer_custom_exit.
+ * @param[in] prop Tensor_Filter's property values. Do not change its values.
  * @param[in] inputPtr pointer to input tensor, size = dim1 x dim2 x dim3 x dim4 x typesize, allocated by caller
  * @param[in] inputPtr pointer to output tensor, size = dim1 x dim2 x dim3 x dim4 x typesize, allocated by caller
  */
-typedef int (*NNS_custom_invoke)(void *private_data,
+typedef int (*NNS_custom_invoke)(void *private_data, const GstTensor_Filter_Properties *prop,
     uint8_t *inputPtr, uint8_t *outputPtr);
 
 /**

diff --git a/include/tensor_typedef.h b/include/tensor_typedef.h
index 9cd16df..707c3c7 100644 (file)
--- a/include/tensor_typedef.h
+++ b/include/tensor_typedef.h
@@ -75,4 +75,47 @@ typedef enum _nns_tensor_type {
   _NNS_END,
 } tensor_type;
 
+/**
+ * @brief NN Frameworks
+ */
+typedef enum _nnfw_type {
+  _T_F_UNDEFINED = 0, /* Not defined or supported. Cannot proceed in this status */
+
+  _T_F_CUSTOM, /* NYI. Custom other/tensor -> other/tensor shared object (dysym) */
+  _T_F_TENSORFLOW_LITE, /* NYI */
+  _T_F_TENSORFLOW, /* NYI */
+  _T_F_CAFFE2, /* NYI */
+
+  _T_F_NNFW_END,
+} nnfw_type;
+
+struct _GstTensor_Filter_Framework;
+typedef struct _GstTensor_Filter_Framework GstTensor_Filter_Framework;
+
+/**
+ * @brief Tensor_Filter's properties (internal data structure)
+ *
+ * Because custom filters of tensor_filter may need to access internal data
+ * of Tensor_Filter, we define this data structure here.
+ */
+typedef struct _GstTensor_Filter_Properties
+{
+  gboolean silent; /**< Verbose mode if FALSE */
+  gboolean debug; /**< Print out more thinkgs if TRUE */
+  gboolean inputConfigured; /**< TRUE if input dimension is configured */
+  gboolean outputConfigured; /** < TRUE if output dimension is configured */
+  nnfw_type nnfw; /**< The enum value of corresponding NNFW. _T_F_UNDEFINED if not configured */
+  GstTensor_Filter_Framework *fw; /**< The implementation core of the NNFW. NULL if not configured */
+  const gchar *modelFilename; /**< Filepath to the model file (as an argument for NNFW) */
+
+  uint32_t inputDimension[NNS_TENSOR_RANK_LIMIT]; /**< The input tensor dimension */
+  tensor_type inputType; /**< The type for each element in the input tensor */
+  gboolean inputCapNegotiated;
+  uint32_t outputDimension[NNS_TENSOR_RANK_LIMIT]; /**< The output tensor dimension */
+  tensor_type outputType; /**< The type for each element in the output tensor */
+  gboolean outputCapNegotiated;
+
+  const gchar *customProperties; /**< sub-plugin specific custom property values in string */
+} GstTensor_Filter_Properties;
+
 #endif /*__GST_TENSOR_TYPEDEF_H__*/

diff --git a/nnstreamer_example/custom_example_passthrough/nnstreamer_customfilter_example_passthrough.c b/nnstreamer_example/custom_example_passthrough/nnstreamer_customfilter_example_passthrough.c
index 5a44677..fe0c982 100644 (file)
--- a/nnstreamer_example/custom_example_passthrough/nnstreamer_customfilter_example_passthrough.c
+++ b/nnstreamer_example/custom_example_passthrough/nnstreamer_customfilter_example_passthrough.c
@@ -29,7 +29,7 @@ typedef struct _pt_data
 } pt_data;
 
 static void *
-pt_init ()
+pt_init (const GstTensor_Filter_Properties * prop)
 {
   pt_data *data = (pt_data *) malloc (sizeof (pt_data));
   int i;
@@ -46,7 +46,7 @@ pt_init ()
 }
 
 static void
-pt_exit (void *private_data)
+pt_exit (void *private_data, const GstTensor_Filter_Properties * prop)
 {
   pt_data *data = private_data;
   g_assert (data);
@@ -54,7 +54,7 @@ pt_exit (void *private_data)
 }
 
 static int
-get_inputDim (void *private_data,
+get_inputDim (void *private_data, const GstTensor_Filter_Properties * prop,
     uint32_t inputDimension[NNS_TENSOR_RANK_LIMIT], tensor_type * type)
 {
   pt_data *data = private_data;
@@ -73,7 +73,7 @@ get_inputDim (void *private_data,
 }
 
 static int
-get_outputDim (void *private_data,
+get_outputDim (void *private_data, const GstTensor_Filter_Properties * prop,
     uint32_t outputDimension[NNS_TENSOR_RANK_LIMIT], tensor_type * type)
 {
   pt_data *data = private_data;
@@ -91,7 +91,8 @@ get_outputDim (void *private_data,
 }
 
 static int
-pt_invoke (void *private_data, uint8_t * inptr, uint8_t * outptr)
+pt_invoke (void *private_data, const GstTensor_Filter_Properties * prop,
+    uint8_t * inptr, uint8_t * outptr)
 {
   pt_data *data = private_data;
   size_t size;

diff --git a/tensor_filter/tensor_filter.c b/tensor_filter/tensor_filter.c
index d68ebd6..d6eb090 100644 (file)
--- a/tensor_filter/tensor_filter.c
+++ b/tensor_filter/tensor_filter.c
@@ -246,28 +246,28 @@ gst_tensor_filter_class_init (GstTensor_FilterClass * g_class)
 static void
 gst_tensor_filter_init (GstTensor_Filter * filter)
 {
-  filter->silent = TRUE;
-  filter->nnfw = _T_F_UNDEFINED;
-  filter->fw = NULL;
-  filter->inputConfigured = FALSE;
-  filter->outputConfigured = FALSE;
-  filter->modelFilename = NULL;
-
-  filter->inputDimension[0] = 1;        /* innermost */
-  filter->inputDimension[1] = 1;
-  filter->inputDimension[2] = 1;
-  filter->inputDimension[3] = 1;        /* out */
-  filter->inputType = _NNS_END; /* not initialized */
-  filter->inputCapNegotiated = FALSE;
-
-  filter->outputDimension[0] = 1;       /* innermost */
-  filter->outputDimension[1] = 1;
-  filter->outputDimension[2] = 1;
-  filter->outputDimension[3] = 1;       /* out */
-  filter->outputType = _NNS_END;        /* not initialized */
-  filter->outputCapNegotiated = FALSE;
-
-  filter->customProperties = NULL;
+  filter->prop.silent = TRUE;
+  filter->prop.nnfw = _T_F_UNDEFINED;
+  filter->prop.fw = NULL;
+  filter->prop.inputConfigured = FALSE;
+  filter->prop.outputConfigured = FALSE;
+  filter->prop.modelFilename = NULL;
+
+  filter->prop.inputDimension[0] = 1;   /* innermost */
+  filter->prop.inputDimension[1] = 1;
+  filter->prop.inputDimension[2] = 1;
+  filter->prop.inputDimension[3] = 1;   /* out */
+  filter->prop.inputType = _NNS_END;    /* not initialized */
+  filter->prop.inputCapNegotiated = FALSE;
+
+  filter->prop.outputDimension[0] = 1;  /* innermost */
+  filter->prop.outputDimension[1] = 1;
+  filter->prop.outputDimension[2] = 1;
+  filter->prop.outputDimension[3] = 1;  /* out */
+  filter->prop.outputType = _NNS_END;   /* not initialized */
+  filter->prop.outputCapNegotiated = FALSE;
+
+  filter->prop.customProperties = NULL;
   filter->privateData = NULL;   /* mark not initialized. */
 }
 
@@ -313,18 +313,18 @@ gst_tensor_filter_fix_caps (GstTensor_Filter * filter, gboolean isInput,
   int rank;
 
   if (isInput == TRUE) {
-    type = &(filter->inputType);
-    dimension = filter->inputDimension;
+    type = &(filter->prop.inputType);
+    dimension = filter->prop.inputDimension;
   } else {
-    type = &(filter->outputType);
-    dimension = filter->outputDimension;
+    type = &(filter->prop.outputType);
+    dimension = filter->prop.outputDimension;
   }
 
   /* 2. configure caps based on type & dimension */
   rank = gst_tensor_filter_get_rank (dimension);
   tmp = gst_caps_new_simple ("other/tensor", "rank", G_TYPE_INT, rank, "type", G_TYPE_STRING, tensor_element_typename[*type], "dim1", G_TYPE_INT, dimension[0], "dim2", G_TYPE_INT, dimension[1], "dim3", G_TYPE_INT, dimension[2], "dim4", G_TYPE_INT, dimension[3], "framerate", GST_TYPE_FRACTION, 0, 1,     /* @TODO: support other framerates! */
       NULL);                    /* Framerate is not determined with the given info */
-  if (filter->silent == FALSE) {
+  if (filter->prop.silent == FALSE) {
     gchar *str = gst_caps_to_string (tmp);
     debug_print (TRUE, "Caps(%s) Narrowing to %s\n",
         (isInput == TRUE) ? "input/sink" : "output/src", str);
@@ -338,7 +338,7 @@ gst_tensor_filter_fix_caps (GstTensor_Filter * filter, gboolean isInput,
 
   if (targetCaps) {
     gchar *str;
-    if (filter->silent == FALSE) {
+    if (filter->prop.silent == FALSE) {
       str = gst_caps_to_string (targetCaps);
       debug_print (TRUE, "targetCaps: %s\n", str);
       g_free (str);
@@ -346,13 +346,13 @@ gst_tensor_filter_fix_caps (GstTensor_Filter * filter, gboolean isInput,
     tmp2 = gst_caps_intersect_full (targetCaps, tmp, GST_CAPS_INTERSECT_FIRST);
     gst_caps_unref (tmp);
     tmp = tmp2;
-    if (filter->silent == FALSE) {
+    if (filter->prop.silent == FALSE) {
       str = gst_caps_to_string (tmp);
       debug_print (TRUE, "resultCaps: %s\n", str);
       g_free (str);
     }
   } else {
-    if (filter->silent == FALSE) {
+    if (filter->prop.silent == FALSE) {
       gchar *str = gst_caps_to_string (tmp);
       debug_print (TRUE, "resultCaps w/o targetCaps: %s\n", str);
       g_free (str);
@@ -392,88 +392,93 @@ gst_tensor_filter_set_property (GObject * object, guint prop_id,
 {
   GstTensor_Filter *filter = GST_TENSOR_FILTER (object);
 
-  debug_print (!filter->silent, "Setting property. for Prop %d.\n", prop_id);
+  debug_print (!filter->prop.silent, "Setting property. for Prop %d.\n",
+      prop_id);
 
   switch (prop_id) {
     case PROP_SILENT:
-      filter->silent = g_value_get_boolean (value);
-      debug_print (!filter->silent, "Debug mode on (silent off)\n");
+      filter->prop.silent = g_value_get_boolean (value);
+      debug_print (!filter->prop.silent, "Debug mode on (silent off)\n");
       break;
     case PROP_FRAMEWORK:
-      g_assert (filter->nnfw == _T_F_UNDEFINED && value);
+      g_assert (filter->prop.nnfw == _T_F_UNDEFINED && value);
       /* Once configures, it cannot be changed in runtime */
-      filter->nnfw = find_key_strv (nnfw_names, g_value_get_string (value));
-      debug_print (!filter->silent, "Framework = %s\n",
+      filter->prop.nnfw =
+          find_key_strv (nnfw_names, g_value_get_string (value));
+      debug_print (!filter->prop.silent, "Framework = %s\n",
           g_value_get_string (value));
-      g_assert (filter->nnfw != -1);
-      g_assert (filter->nnfw != _T_F_UNDEFINED);
-      g_assert (nnfw_support_status[filter->nnfw] == TRUE);
-      filter->fw = tensor_filter_supported[filter->nnfw];
-      g_assert (filter->fw != NULL);
+      g_assert (filter->prop.nnfw != -1);
+      g_assert (filter->prop.nnfw != _T_F_UNDEFINED);
+      g_assert (nnfw_support_status[filter->prop.nnfw] == TRUE);
+      filter->prop.fw = tensor_filter_supported[filter->prop.nnfw];
+      g_assert (filter->prop.fw != NULL);
       break;
     case PROP_MODEL:
-      g_assert (filter->modelFilename == NULL && value);
+      g_assert (filter->prop.modelFilename == NULL && value);
       /* Once configures, it cannot be changed in runtime */
-      filter->modelFilename = g_value_dup_string (value);
-      debug_print (!filter->silent, "Model = %s\n", filter->modelFilename);
-      g_assert (g_file_test (filter->modelFilename,
+      filter->prop.modelFilename = g_value_dup_string (value);
+      debug_print (!filter->prop.silent, "Model = %s\n",
+          filter->prop.modelFilename);
+      g_assert (g_file_test (filter->prop.modelFilename,
               G_FILE_TEST_IS_REGULAR) == TRUE);
       break;
     case PROP_INPUT:
-      g_assert (filter->inputConfigured == FALSE && value);
+      g_assert (filter->prop.inputConfigured == FALSE && value);
       /* Once configures, it cannot be changed in runtime */
       {
         int rank = get_tensor_dimension (g_value_get_string (value),
-            filter->inputDimension);
+            filter->prop.inputDimension);
         g_assert (rank > 0 && rank <= NNS_TENSOR_RANK_LIMIT);
-        filter->inputConfigured = TRUE;
-        debug_print (!filter->silent, "Input Prop: %d:%d:%d:%d Rank %d\n",
-            filter->inputDimension[0], filter->inputDimension[1],
-            filter->inputDimension[2], filter->inputDimension[3], rank);
+        filter->prop.inputConfigured = TRUE;
+        debug_print (!filter->prop.silent, "Input Prop: %d:%d:%d:%d Rank %d\n",
+            filter->prop.inputDimension[0], filter->prop.inputDimension[1],
+            filter->prop.inputDimension[2], filter->prop.inputDimension[3],
+            rank);
       }
-      if (filter->inputType != _NNS_END && filter->silent == FALSE)
+      if (filter->prop.inputType != _NNS_END && filter->prop.silent == FALSE)
         gst_tensor_filter_fix_caps (filter, TRUE, NULL, TRUE);
       break;
     case PROP_OUTPUT:
-      g_assert (filter->outputConfigured == FALSE && value);
+      g_assert (filter->prop.outputConfigured == FALSE && value);
       /* Once configures, it cannot be changed in runtime */
       {
         int rank = get_tensor_dimension (g_value_get_string (value),
-            filter->outputDimension);
+            filter->prop.outputDimension);
         g_assert (rank > 0 && rank <= NNS_TENSOR_RANK_LIMIT);
-        filter->outputConfigured = TRUE;
-        debug_print (!filter->silent, "Output Prop: %d:%d:%d:%d Rank %d\n",
-            filter->outputDimension[0], filter->outputDimension[1],
-            filter->outputDimension[2], filter->outputDimension[3], rank);
+        filter->prop.outputConfigured = TRUE;
+        debug_print (!filter->prop.silent, "Output Prop: %d:%d:%d:%d Rank %d\n",
+            filter->prop.outputDimension[0], filter->prop.outputDimension[1],
+            filter->prop.outputDimension[2], filter->prop.outputDimension[3],
+            rank);
       }
 
-      if (filter->outputType != _NNS_END && filter->silent == FALSE)
+      if (filter->prop.outputType != _NNS_END && filter->prop.silent == FALSE)
         gst_tensor_filter_fix_caps (filter, FALSE, NULL, TRUE);
       break;
     case PROP_INPUTTYPE:
-      g_assert (filter->inputType == _NNS_END && value);
+      g_assert (filter->prop.inputType == _NNS_END && value);
       /* Once configures, it cannot be changed in runtime */
-      filter->inputType = get_tensor_type (g_value_get_string (value));
-      debug_print (!filter->silent, "Output Type: %s -> %d\n",
-          g_value_get_string (value), filter->inputType);
-      g_assert (filter->inputType != _NNS_END);
-      if (filter->inputConfigured == TRUE && filter->silent == FALSE)
+      filter->prop.inputType = get_tensor_type (g_value_get_string (value));
+      debug_print (!filter->prop.silent, "Output Type: %s -> %d\n",
+          g_value_get_string (value), filter->prop.inputType);
+      g_assert (filter->prop.inputType != _NNS_END);
+      if (filter->prop.inputConfigured == TRUE && filter->prop.silent == FALSE)
         gst_tensor_filter_fix_caps (filter, TRUE, NULL, TRUE);
       break;
     case PROP_OUTPUTTYPE:
-      g_assert (filter->outputType == _NNS_END && value);
+      g_assert (filter->prop.outputType == _NNS_END && value);
       /* Once configures, it cannot be changed in runtime */
-      filter->outputType = get_tensor_type (g_value_get_string (value));
-      g_assert (filter->outputType != _NNS_END);
-      if (filter->outputConfigured == TRUE && filter->silent == FALSE)
+      filter->prop.outputType = get_tensor_type (g_value_get_string (value));
+      g_assert (filter->prop.outputType != _NNS_END);
+      if (filter->prop.outputConfigured == TRUE && filter->prop.silent == FALSE)
         gst_tensor_filter_fix_caps (filter, FALSE, NULL, TRUE);
       break;
     case PROP_CUSTOM:
-      g_assert (filter->customProperties == NULL && value);
+      g_assert (filter->prop.customProperties == NULL && value);
       /* Once configures, it cannot be changed in runtime */
-      filter->customProperties = g_value_dup_string (value);
-      if (filter->debug == TRUE)
-        g_printerr ("Custom Option = %s\n", filter->customProperties);
+      filter->prop.customProperties = g_value_dup_string (value);
+      if (filter->prop.debug == TRUE)
+        g_printerr ("Custom Option = %s\n", filter->prop.customProperties);
       break;
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@@ -487,24 +492,25 @@ gst_tensor_filter_get_property (GObject * object, guint prop_id,
 {
   GstTensor_Filter *filter = GST_TENSOR_FILTER (object);
 
-  debug_print (!filter->silent, "Getting property. for Prop %d.\n", prop_id);
+  debug_print (!filter->prop.silent, "Getting property. for Prop %d.\n",
+      prop_id);
 
   switch (prop_id) {
     case PROP_SILENT:
-      g_value_set_boolean (value, filter->silent);
+      g_value_set_boolean (value, filter->prop.silent);
       break;
     case PROP_FRAMEWORK:
-      g_value_set_string (value, nnfw_names[filter->nnfw]);
+      g_value_set_string (value, nnfw_names[filter->prop.nnfw]);
       break;
     case PROP_MODEL:
-      g_value_set_string (value, filter->modelFilename);
+      g_value_set_string (value, filter->prop.modelFilename);
       break;
     case PROP_INPUT:{
       GArray *input =
           g_array_sized_new (FALSE, FALSE, 4, NNS_TENSOR_RANK_LIMIT);
       int i;
       for (i = 0; i < NNS_TENSOR_RANK_LIMIT; i++)
-        g_array_append_val (input, filter->inputDimension[i]);
+        g_array_append_val (input, filter->prop.inputDimension[i]);
       g_value_take_boxed (value, input);
       /* take function hands the object over from here so that we don't need to free it. */
     }
@@ -514,19 +520,21 @@ gst_tensor_filter_get_property (GObject * object, guint prop_id,
           g_array_sized_new (FALSE, FALSE, 4, NNS_TENSOR_RANK_LIMIT);
       int i;
       for (i = 0; i < NNS_TENSOR_RANK_LIMIT; i++)
-        g_array_append_val (output, filter->outputDimension[i]);
+        g_array_append_val (output, filter->prop.outputDimension[i]);
       g_value_take_boxed (value, output);
       /* take function hands the object over from here so that we don't need to free it. */
     }
       break;
     case PROP_INPUTTYPE:
-      g_value_set_string (value, tensor_element_typename[filter->inputType]);
+      g_value_set_string (value,
+          tensor_element_typename[filter->prop.inputType]);
       break;
     case PROP_OUTPUTTYPE:
-      g_value_set_string (value, tensor_element_typename[filter->outputType]);
+      g_value_set_string (value,
+          tensor_element_typename[filter->prop.outputType]);
       break;
     case PROP_CUSTOM:
-      g_value_set_string (value, filter->customProperties);
+      g_value_set_string (value, filter->prop.customProperties);
       break;
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@@ -587,29 +595,30 @@ GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
   uint8_t *inptr, *outptr;
   GstMapInfo inInfo, outInfo;
 
-  if (G_UNLIKELY (filter->inputCapNegotiated == FALSE
-          || filter->outputCapNegotiated == FALSE))
+  if (G_UNLIKELY (filter->prop.inputCapNegotiated == FALSE
+          || filter->prop.outputCapNegotiated == FALSE))
     goto unknown_format;
-  if (G_UNLIKELY (!filter->fw))
+  if (G_UNLIKELY (!filter->prop.fw))
     goto unknown_framework;
-  if (G_UNLIKELY (!filter->modelFilename))
+  if (G_UNLIKELY (!filter->prop.modelFilename))
     goto unknown_model;
-  if (G_UNLIKELY (!filter->fw->invoke_NN))
+  if (G_UNLIKELY (!filter->prop.fw->invoke_NN))
     goto unknown_invoke;
 
   /* 0. Check all properties and inbuf size. */
-  debug_print (!filter->silent, "Invoking %s with %s model\n", filter->fw->name,
-      filter->modelFilename);
+  debug_print (!filter->prop.silent, "Invoking %s with %s model\n",
+      filter->prop.fw->name, filter->prop.modelFilename);
 
-  if (filter->fw->getInputDimension) {
-    ret = filter->fw->getInputDimension (filter, inputDimChk, &inputType);
+  if (filter->prop.fw->getInputDimension) {
+    ret = filter->prop.fw->getInputDimension (filter, inputDimChk, &inputType);
     /* @TODO check inputDimChk / inputType with filter internal info */
   } else {
     /* @TODO printout debug msg */
   }
 
-  if (filter->fw->getOutputDimension) {
-    ret = filter->fw->getOutputDimension (filter, outputDimChk, &outputType);
+  if (filter->prop.fw->getOutputDimension) {
+    ret =
+        filter->prop.fw->getOutputDimension (filter, outputDimChk, &outputType);
     /* @TODO check outputDimChk / outputType with filter internal info */
   } else {
     /* @TODO printout debug msg */
@@ -617,8 +626,8 @@ GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
 
   /* 1. Allocate outbuf */
   g_assert (outbuf);
-  outBufSize = tensor_element_size[filter->inputType] *
-      get_tensor_element_count (filter->inputDimension);
+  outBufSize = tensor_element_size[filter->prop.inputType] *
+      get_tensor_element_count (filter->prop.inputDimension);
   if (gst_buffer_get_size (outbuf) < outBufSize) {
     gst_buffer_set_size (outbuf, outBufSize);
   }
@@ -630,7 +639,7 @@ GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
   inptr = inInfo.data;
   outptr = outInfo.data;
 
-  ret = filter->fw->invoke_NN (filter, inptr, outptr);
+  ret = filter->prop.fw->invoke_NN (filter, inptr, outptr);
 
   gst_buffer_unmap (inbuf, &inInfo);
   gst_buffer_unmap (outbuf, &outInfo);
@@ -685,14 +694,14 @@ gst_tensor_filter_transform_caps (GstBaseTransform * trans,
 
   if (direction == GST_PAD_SINK) {
     /* caps: sink pad. get src pad info */
-    obj->outputCapNegotiated = TRUE;
+    obj->prop.outputCapNegotiated = TRUE;
 
     /* @TODO 1. Check caps w/ getInputDimension && saved input dimension */
     /* @TODO 2. Check returning-caps w/ getOutputDimension && saved output dimension */
     return gst_tensor_filter_fix_caps (obj, FALSE, filter, FALSE);
   } else {
     /* caps: src pad. get sink pad info */
-    obj->inputCapNegotiated = TRUE;
+    obj->prop.inputCapNegotiated = TRUE;
 
     /* @TODO 1. Check caps w/ getOutputDimension && saved output dimension */
     /* @TODO 2. Check returning-caps w/ getInputDimension && saved input dimension */
@@ -724,9 +733,9 @@ gst_tensor_filter_fixate_caps (GstBaseTransform * trans,
     if (gst_caps_is_subset (caps, result)) {
       gst_caps_replace (&result, caps);
     }
-    obj->inputCapNegotiated = TRUE;
+    obj->prop.inputCapNegotiated = TRUE;
   } else {
-    obj->outputCapNegotiated = TRUE;
+    obj->prop.outputCapNegotiated = TRUE;
   }
   return result;
 }

diff --git a/tensor_filter/tensor_filter.h b/tensor_filter/tensor_filter.h
index 6492646..4b0f720 100644 (file)
--- a/tensor_filter/tensor_filter.h
+++ b/tensor_filter/tensor_filter.h
@@ -79,20 +79,6 @@ typedef struct _GstTensor_Filter GstTensor_Filter;
 
 typedef struct _GstTensor_FilterClass GstTensor_FilterClass;
 
-/**
- * @brief NN Frameworks
- */
-typedef enum _nnfw_type {
-  _T_F_UNDEFINED = 0, /* Not defined or supported. Cannot proceed in this status */
-
-  _T_F_CUSTOM, /* NYI. Custom other/tensor -> other/tensor shared object (dysym) */
-  _T_F_TENSORFLOW_LITE, /* NYI */
-  _T_F_TENSORFLOW, /* NYI */
-  _T_F_CAFFE2, /* NYI */
-
-  _T_F_NNFW_END,
-} nnfw_type;
-
 extern const char* nnfw_names[];
 
 /**
@@ -112,9 +98,6 @@ static const gboolean nnfw_support_status[] = {
   FALSE,
 };
 
-struct _GstTensor_Filter_Framework;
-typedef struct _GstTensor_Filter_Framework GstTensor_Filter_Framework;
-
 /**
  * @brief Internal data structure for tensor_filter instances.
  */
@@ -122,24 +105,9 @@ struct _GstTensor_Filter
 {
   GstBaseTransform element;    /**< This is the parent object */
 
-  gboolean silent; /**< Verbose mode if FALSE */
-  gboolean debug; /**< Print out more thinkgs if TRUE */
-  gboolean inputConfigured; /**< TRUE if input dimension is configured */
-  gboolean outputConfigured; /** < TRUE if output dimension is configured */
-  nnfw_type nnfw; /**< The enum value of corresponding NNFW. _T_F_UNDEFINED if not configured */
-  GstTensor_Filter_Framework *fw; /**< The implementation core of the NNFW. NULL if not configured */
-  const gchar *modelFilename; /**< Filepath to the model file (as an argument for NNFW) */
-
-  uint32_t inputDimension[NNS_TENSOR_RANK_LIMIT]; /**< The input tensor dimension */
-  tensor_type inputType; /**< The type for each element in the input tensor */
-  gboolean inputCapNegotiated;
-  uint32_t outputDimension[NNS_TENSOR_RANK_LIMIT]; /**< The output tensor dimension */
-  tensor_type outputType; /**< The type for each element in the output tensor */
-  gboolean outputCapNegotiated;
-
-  const gchar *customProperties; /**< sub-plugin specific custom property values in string */
-
   void *privateData; /**< NNFW plugin's private data is stored here */
+
+  GstTensor_Filter_Properties prop;
 };
 
 /*

diff --git a/tensor_filter/tensor_filter_custom.c b/tensor_filter/tensor_filter_custom.c
index d2826ea..450261b 100644 (file)
--- a/tensor_filter/tensor_filter_custom.c
+++ b/tensor_filter/tensor_filter_custom.c
@@ -88,7 +88,7 @@ custom_loadlib (GstTensor_Filter * filter)
   ptr->parent = filter;
 
   /* Load .so if this is the first time for this instance. */
-  ptr->handle = dlopen (filter->modelFilename, RTLD_NOW);
+  ptr->handle = dlopen (filter->prop.modelFilename, RTLD_NOW);
   if (!ptr->handle) {
     g_free (ptr);
     filter->privateData = NULL;
@@ -108,7 +108,7 @@ custom_loadlib (GstTensor_Filter * filter)
   }
 
   g_assert (ptr->methods->initfunc);
-  ptr->customFW_private_data = ptr->methods->initfunc ();
+  ptr->customFW_private_data = ptr->methods->initfunc (&(filter->prop));
   return 0;
 }
 
@@ -133,7 +133,8 @@ custom_invoke (GstTensor_Filter * filter, uint8_t * inptr, uint8_t * outptr)
   g_assert (filter->privateData);
   ptr = filter->privateData;
 
-  return ptr->methods->invoke (ptr->customFW_private_data, inptr, outptr);
+  return ptr->methods->invoke (ptr->customFW_private_data, &(filter->prop),
+      inptr, outptr);
 }
 
 /**
@@ -152,8 +153,8 @@ custom_getInputDim (GstTensor_Filter * filter, uint32_t * inputDimension,
   g_assert (filter->privateData);
   ptr = filter->privateData;
 
-  return ptr->methods->getInputDim (ptr->customFW_private_data, inputDimension,
-      type);
+  return ptr->methods->getInputDim (ptr->customFW_private_data, &(filter->prop),
+      inputDimension, type);
 }
 
 /**
@@ -173,7 +174,7 @@ custom_getOutputDim (GstTensor_Filter * filter, uint32_t * outputDimension,
   ptr = filter->privateData;
 
   return ptr->methods->getOutputDim (ptr->customFW_private_data,
-      outputDimension, type);
+      &(filter->prop), outputDimension, type);
 }
 
 /**
@@ -184,7 +185,7 @@ custom_close (GstTensor_Filter * filter)
 {
   internal_data *ptr = filter->privateData;
 
-  ptr->methods->exitfunc (ptr->customFW_private_data);
+  ptr->methods->exitfunc (ptr->customFW_private_data, &(filter->prop));
   g_free (ptr);
   filter->privateData = NULL;
 }