mv_inference: fix coding style based on Tizen C++ Coding Rule

Tizen C++ Coding Rule:
https://wiki.tizen.org/Native_Platform_Coding_Idiom_and_Style_Guide#C.2B.2B_Coding_Style

Change-Id: Ifdb19e21f9ec67784213218a3f2465312aa43dbe
Signed-off-by: Inki Dae <inki.dae@samsung.com>

8 files changed, 4420 insertions, 4619 deletions

diff --git a/mv_inference/inference/include/Inference.h b/mv_inference/inference/include/Inference.h
index c2a7b2e3..895f6d59 100755..100644
--- a/mv_inference/inference/include/Inference.h
+++ b/mv_inference/inference/include/Inference.h
@@ -35,326 +35,321 @@
 using namespace InferenceEngineInterface::Common;
 
 typedef struct _ImageClassficationResults {
-    int number_of_classes;
-    std::vector<int> indices;
-    std::vector<std::string> names;
-    std::vector<float> confidences;
+	int number_of_classes;
+	std::vector<int> indices;
+	std::vector<std::string> names;
+	std::vector<float> confidences;
 } ImageClassificationResults; /**< structure ImageClassificationResults */
 
 typedef struct _ObjectDetectionResults {
-    int number_of_objects;
-    std::vector<int> indices;
-    std::vector<std::string> names;
-    std::vector<float> confidences;
-    std::vector<cv::Rect> locations;
-} ObjectDetectionResults;  /**< structure ObjectDetectionResults */
+	int number_of_objects;
+	std::vector<int> indices;
+	std::vector<std::string> names;
+	std::vector<float> confidences;
+	std::vector<cv::Rect> locations;
+} ObjectDetectionResults; /**< structure ObjectDetectionResults */
 
 typedef struct _FaceDetectionResults {
-    int number_of_faces;
-    std::vector<float> confidences;
-    std::vector<cv::Rect> locations;
-} FaceDetectionResults;  /**< structure FaceDetectionResults */
+	int number_of_faces;
+	std::vector<float> confidences;
+	std::vector<cv::Rect> locations;
+} FaceDetectionResults; /**< structure FaceDetectionResults */
 
 typedef struct _FacialLandMarkDetectionResults {
-    int number_of_landmarks;
-    std::vector<cv::Point> locations;
-} FacialLandMarkDetectionResults;  /**< structure FacialLandMarkDetectionResults */
+	int number_of_landmarks;
+	std::vector<cv::Point> locations;
+} FacialLandMarkDetectionResults; /**< structure FacialLandMarkDetectionResults */
 
 typedef struct _PoseEstimationResults {
-    int number_of_pose_estimation;
-    std::vector<cv::Point> locations;
-} PoseEstimationResults;  /**< structure PoseEstimationResults */
-
-namespace mediavision {
-namespace inference {
-
-struct TensorInfo {
-    int width;
-    int height;
-    int dim;
-    int ch;
-};
-
-struct InferenceConfig {
-	/**
-	 * @brief Default constructor for the @ref InferenceConfig
-	 *
-	 * @since_tizen 5.0
-	 */
-	InferenceConfig();
-
-	std::string mConfigFilePath; /**< Path of a model configuration file */
-
-	std::string mWeightFilePath; /**< Path of a model weight file */
-
-	std::string mUserFilePath; /**< Path of model user file */
-
-	TensorInfo mTensorInfo; /**< Tensor information */
-
-	mv_inference_data_type_e mDataType; /**< Data type of a input tensor */
-
-	mv_inference_backend_type_e mBackedType; /**< Backed type of model files */
-
-	int mTargetTypes; /**< Target type to run inference */
-
-	double mConfidenceThresHold; /**< Confidence threshold value */
-
-	double mMeanValue; /**< The mean value for normalization */
-
-	double mStdValue; /**< The scale factor value for normalization */
-
-	int mMaxOutputNumbers;
-
-	std::vector<std::string> mInputLayerNames; /**< The input layer names */
-	std::vector<std::string> mOutputLayerNames; /**< The output layer names */
-};
-
-
-class Inference {
-public:
-	/**
-	 * @brief   Creates an Inference class instance.
-	 *
-	 * @since_tizen 5.5
-	 */
-	Inference();
-
-	/**
-	 * @brief   Destroys an Inference class instance including
-	 *           its all resources.
-	 *
-	 * @since_tizen 5.5
-	 */
-	~Inference();
-
-	/**
-	 * @brief   Configure modelfiles
-	 *
-	 * @since_tizen 5.5
-	 */
-    void ConfigureModelFiles(
-                const std::string modelConfigFilePath,
-		        const std::string modelWeightFilePath,
-		        const std::string modelUserFilePath);
-
-	/**
-	 * @brief   Configure input tensor information
-	 *
-	 * @since_tizen 5.5
-	 * @remarks deprecated Replayced by ConfigureInputInfo
-	 */
-    void ConfigureTensorInfo(int width,
-                int height,
-                int dim,
-                int ch,
-				double stdValue,
-				double meanValue);
-
-	/**
-	 * @brief Configure input infomation
-	 *
-	 * @since_tizen 6.0
-	 */
-	void ConfigureInputInfo(int width,
-		int height,
-		int dim,
-		int ch,
-		double stdValue,
-		double meanValue,
-		int dataType,
-		const std::vector<std::string> names);
-
-	void ConfigureOutputInfo(std::vector<std::string> names);
-
-	/**
-	 * @brief   Configure inference backend type.
-	 *
-	 * @since_tizen 6.0
-	 */
-	int ConfigureBackendType(const mv_inference_backend_type_e backendType);
-
-	/**
-	 * @brief   Configure a inference target device type such as CPU, GPU or NPU. (only one type can be set)
-	 * @details Internally, a given device type will be converted to new type.
-	 * 			This API is just used for backward compatibility.
-	 *
-	 * @since_tizen 6.0 (Deprecated)
-	 */
-	int ConfigureTargetTypes(const int targetType);
-
-	/**
-	 * @brief   Configure inference target devices such as CPU, GPU or NPU. (one more types can be combined)
-	 *
-	 * @since_tizen 6.0
-	 */
-	int ConfigureTargetDevices(const int targetDevices);
-
-	/**
-	 * @brief   Configure the maximum number of inference results
-	 *
-	 * @since_tizen 5.5
-	 */
-	void ConfigureOutput(const int maxOutputNumbers);
-
-	/**
-	 * @brief   Configure the confidence threshold
-	 *
-	 * @since_tizen 5.5
-	 */
-	void ConfigureThreshold(const double threshold);
-
-	/**
-	 * @brief   Bind a backend engine
-	 * @details Use this function to bind a backend engine for the inference.
-	 * 			This creates a inference engine common class object, and loads a backend
-	 *			library which inferfaces with a Neural Network runtime such as TF Lite,
-	 *			OpenCV, ARMNN and so on.
-	 *
-	 *			Ps. The created inference engine common object will be released and its
-	 *				corresponding backend library will be unbound when deconstructor
-	 *				of Inference class will be called.
-	 *
-	 * @since_tizen 6.0
-	 *
-	 * @return @c 0 on success, otherwise a negative error value
-	 * @retval #MEDIA_VISION_ERROR_NONE Successful
-	 * @retval #MEDIA_VISION_ERROR_INVALID_PARAMETER Invalid parameter
-	 */
-	int Bind();
-
-	/**
-	 * @brief   Set default configuration for the inference
-	 * @details Use this function to set default configuration given in json file by user.
-	 *
-	 * 			Ps. this callback should be called after Bind callback.
-	 *
-	 * @since_tizen 6.0
-	 *
-	 * @return @c 0 on success, otherwise a negative error value
-	 * @retval #MEDIA_VISION_ERROR_NONE Successful
-	 * @retval #MEDIA_VISION_ERROR_INVALID_PARAMETER Invalid parameter
-	 */
-	int Prepare();
-
-	/**
-	 * @brief   Load model files
-	 * @details Use this function to load given model files for the inference.
-	 *
-	 * 			Ps. this callback should be called after Prepare callback.
-	 *
-	 * @since_tizen 6.0
-	 *
-	 * @return @c 0 on success, otherwise a negative error value
-	 * @retval #MEDIA_VISION_ERROR_NONE Successful
-	 * @retval #MEDIA_VISION_ERROR_INVALID_PARAMETER Invalid parameter
-	 */
-	int Load();
-
-	/**
-	 * @brief	Runs inference with a region of a given image
-	 * @details Use this function to run forward pass with the given image.
-	 *          The given image is preprocessed and the region of the image is
-	 *          thrown to neural network. Then, the output tensor is returned.
-	 *          If roi is NULL, then full source will be analyzed.
-	 *
-	 * @since_tizen 5.5
-	 * @return @c true on success, otherwise a negative error value
-	 */
-	int Run(std::vector<mv_source_h> &mvSources, std::vector<mv_rectangle_s> &rects);
-
-	/**
-	 * @brief	Gets that given engine is supported or not
-	 *
-	 * @since_tizen 5.5
-	 * @return @c true on success, otherwise a negative error value
-	 */
-	std::pair<std::string, bool> GetSupportedInferenceBackend(int backend);
-
-	/**
-	 * @brief	Gets the ImageClassificationResults
-	 *
-	 * @since_tizen 5.5
-	 * @return @c true on success, otherwise a negative error value
-	 */
-	int GetClassficationResults(ImageClassificationResults *classificationResults);
-
-	/**
-	 * @brief	Gets the ObjectDetectioResults
-	 *
-	 * @since_tizen 5.5
-	 * @return @c true on success, otherwise a negative error value
-	 */
-	int GetObjectDetectionResults(ObjectDetectionResults *detectionResults);
-
-	/**
-	 * @brief	Gets the FaceDetectioResults
-	 *
-	 * @since_tizen 5.5
-	 * @return @c true on success, otherwise a negative error value
-	 */
-	int GetFaceDetectionResults(FaceDetectionResults *detectionResults);
-
-	/**
-	 * @brief	Gets the FacialLandmarkDetectionResults
-	 *
-	 * @since_tizen 5.5
-	 * @return @c true on success, otherwise a negative error value
-	 */
-	int GetFacialLandMarkDetectionResults(FacialLandMarkDetectionResults* results);
-
-	/**
-	 * @brief	Gets the PoseEstimationDetectionResults
-	 *
-	 * @since_tizen 6.0
-	 * @return @c true on success, otherwise a negative error value
-	 */
-	int GetPoseEstimationDetectionResults(PoseEstimationResults* results);
-
-	int GetResults(std::vector<std::vector<int>>* dimInfo, std::vector<float*> *results);
-
-	mv_engine_config_h GetEngineConfig(void) { return engine_config; }
-
-	void SetEngineConfig(mv_engine_config_h config) { engine_config = config; }
-
-private:
-	bool mCanRun; /**< The flag indicating ready to run Inference */
-    InferenceConfig mConfig;
-	inference_engine_capacity mBackendCapacity;
-	std::map<int, std::pair<std::string, bool>> mSupportedInferenceBackend;
-	cv::Size mInputSize;
-	int mCh;
-	int mDim;
-	double mDeviation;
-	double mMean;
-	double mThreshold;
-	int mOutputNumbers;
-	cv::Size mSourceSize;
-	cv::Mat mInputBuffer;
-
-	mv_engine_config_h engine_config;
-
-	InferenceEngineCommon * mBackend;
-
-	std::map<std::string, int> mModelFormats;
-    std::vector<std::string> mUserListName;
-
-	std::vector<inference_engine_tensor_buffer> mInputTensorBuffers;
-	inference_engine_layer_property mInputLayerProperty;
-	std::vector<inference_engine_tensor_buffer> mOutputTensorBuffers;
-	inference_engine_layer_property mOutputLayerProperty;
-
-private:
-	void CheckSupportedInferenceBackend();
-	int ConvertEngineErrorToVisionError(int error);
-	int ConvertTargetTypes(int given_types);
-	int ConvertToCv(int given_type);
-	inference_tensor_data_type_e ConvertToIE(int given_type);
-	int Preprocess(cv::Mat cvImg, cv::Mat cvDst, int data_type);
-	int PrepareTenosrBuffers(void);
-	void CleanupTensorBuffers(void);
-	int SetUserFile(std::string filename);
-	int FillOutputResult(tensor_t &outputData);
-};
+	int number_of_pose_estimation;
+	std::vector<cv::Point> locations;
+} PoseEstimationResults; /**< structure PoseEstimationResults */
+
+namespace mediavision
+{
+namespace inference
+{
+	struct TensorInfo {
+		int width;
+		int height;
+		int dim;
+		int ch;
+	};
+
+	struct InferenceConfig {
+		/**
+		 * @brief Default constructor for the @ref InferenceConfig
+		 *
+		 * @since_tizen 5.0
+		 */
+		InferenceConfig();
+
+		std::string mConfigFilePath; /**< Path of a model configuration file */
+
+		std::string mWeightFilePath; /**< Path of a model weight file */
+
+		std::string mUserFilePath; /**< Path of model user file */
+
+		TensorInfo mTensorInfo; /**< Tensor information */
+
+		mv_inference_data_type_e mDataType; /**< Data type of a input tensor */
+
+		mv_inference_backend_type_e mBackedType; /**< Backed type of model files */
+
+		int mTargetTypes; /**< Target type to run inference */
+
+		double mConfidenceThresHold; /**< Confidence threshold value */
+
+		double mMeanValue; /**< The mean value for normalization */
+
+		double mStdValue; /**< The scale factor value for normalization */
+
+		int mMaxOutputNumbers;
+
+		std::vector<std::string> mInputLayerNames; /**< The input layer names */
+		std::vector<std::string> mOutputLayerNames; /**< The output layer names */
+	};
+
+	class Inference
+	{
+	public:
+		/**
+		 * @brief   Creates an Inference class instance.
+		 *
+		 * @since_tizen 5.5
+		 */
+		Inference();
+
+		/**
+		 * @brief   Destroys an Inference class instance including
+		 *           its all resources.
+		 *
+		 * @since_tizen 5.5
+		 */
+		~Inference();
+
+		/**
+		 * @brief   Configure modelfiles
+		 *
+		 * @since_tizen 5.5
+		 */
+		void ConfigureModelFiles(const std::string modelConfigFilePath,
+								 const std::string modelWeightFilePath,
+								 const std::string modelUserFilePath);
+
+		/**
+		 * @brief   Configure input tensor information
+		 *
+		 * @since_tizen 5.5
+		 * @remarks deprecated Replayced by ConfigureInputInfo
+		 */
+		void ConfigureTensorInfo(int width, int height, int dim, int ch,
+								 double stdValue, double meanValue);
+
+		/**
+		 * @brief Configure input infomation
+		 *
+		 * @since_tizen 6.0
+		 */
+		void ConfigureInputInfo(int width, int height, int dim, int ch,
+								double stdValue, double meanValue, int dataType,
+								const std::vector<std::string> names);
+
+		void ConfigureOutputInfo(std::vector<std::string> names);
+
+		/**
+		 * @brief   Configure inference backend type.
+		 *
+		 * @since_tizen 6.0
+		 */
+		int ConfigureBackendType(const mv_inference_backend_type_e backendType);
+
+		/**
+		 * @brief   Configure a inference target device type such as CPU, GPU or NPU. (only one type can be set)
+		 * @details Internally, a given device type will be converted to new type.
+		 * 			This API is just used for backward compatibility.
+		 *
+		 * @since_tizen 6.0 (Deprecated)
+		 */
+		int ConfigureTargetTypes(const int targetType);
+
+		/**
+		 * @brief   Configure inference target devices such as CPU, GPU or NPU. (one more types can be combined)
+		 *
+		 * @since_tizen 6.0
+		 */
+		int ConfigureTargetDevices(const int targetDevices);
+
+		/**
+		 * @brief   Configure the maximum number of inference results
+		 *
+		 * @since_tizen 5.5
+		 */
+		void ConfigureOutput(const int maxOutputNumbers);
+
+		/**
+		 * @brief   Configure the confidence threshold
+		 *
+		 * @since_tizen 5.5
+		 */
+		void ConfigureThreshold(const double threshold);
+
+		/**
+		 * @brief   Bind a backend engine
+		 * @details Use this function to bind a backend engine for the inference.
+		 * 			This creates a inference engine common class object, and loads a backend
+		 *			library which inferfaces with a Neural Network runtime such as TF Lite,
+		 *			OpenCV, ARMNN and so on.
+		 *
+		 *			Ps. The created inference engine common object will be released and its
+		 *				corresponding backend library will be unbound when deconstructor
+		 *				of Inference class will be called.
+		 *
+		 * @since_tizen 6.0
+		 *
+		 * @return @c 0 on success, otherwise a negative error value
+		 * @retval #MEDIA_VISION_ERROR_NONE Successful
+		 * @retval #MEDIA_VISION_ERROR_INVALID_PARAMETER Invalid parameter
+		 */
+		int Bind();
+
+		/**
+		 * @brief   Set default configuration for the inference
+		 * @details Use this function to set default configuration given in json file by user.
+		 *
+		 * 			Ps. this callback should be called after Bind callback.
+		 *
+		 * @since_tizen 6.0
+		 *
+		 * @return @c 0 on success, otherwise a negative error value
+		 * @retval #MEDIA_VISION_ERROR_NONE Successful
+		 * @retval #MEDIA_VISION_ERROR_INVALID_PARAMETER Invalid parameter
+		 */
+		int Prepare();
+
+		/**
+		 * @brief   Load model files
+		 * @details Use this function to load given model files for the inference.
+		 *
+		 * 			Ps. this callback should be called after Prepare callback.
+		 *
+		 * @since_tizen 6.0
+		 *
+		 * @return @c 0 on success, otherwise a negative error value
+		 * @retval #MEDIA_VISION_ERROR_NONE Successful
+		 * @retval #MEDIA_VISION_ERROR_INVALID_PARAMETER Invalid parameter
+		 */
+		int Load();
+
+		/**
+		 * @brief	Runs inference with a region of a given image
+		 * @details Use this function to run forward pass with the given image.
+		 *          The given image is preprocessed and the region of the image is
+		 *          thrown to neural network. Then, the output tensor is returned.
+		 *          If roi is NULL, then full source will be analyzed.
+		 *
+		 * @since_tizen 5.5
+		 * @return @c true on success, otherwise a negative error value
+		 */
+		int Run(std::vector<mv_source_h> &mvSources,
+				std::vector<mv_rectangle_s> &rects);
+
+		/**
+		 * @brief	Gets that given engine is supported or not
+		 *
+		 * @since_tizen 5.5
+		 * @return @c true on success, otherwise a negative error value
+		 */
+		std::pair<std::string, bool> GetSupportedInferenceBackend(int backend);
+
+		/**
+		 * @brief	Gets the ImageClassificationResults
+		 *
+		 * @since_tizen 5.5
+		 * @return @c true on success, otherwise a negative error value
+		 */
+		int GetClassficationResults(ImageClassificationResults *classificationResults);
+
+		/**
+		 * @brief	Gets the ObjectDetectioResults
+		 *
+		 * @since_tizen 5.5
+		 * @return @c true on success, otherwise a negative error value
+		 */
+		int GetObjectDetectionResults(ObjectDetectionResults *detectionResults);
+
+		/**
+		 * @brief	Gets the FaceDetectioResults
+		 *
+		 * @since_tizen 5.5
+		 * @return @c true on success, otherwise a negative error value
+		 */
+		int GetFaceDetectionResults(FaceDetectionResults *detectionResults);
+
+		/**
+		 * @brief	Gets the FacialLandmarkDetectionResults
+		 *
+		 * @since_tizen 5.5
+		 * @return @c true on success, otherwise a negative error value
+		 */
+		int GetFacialLandMarkDetectionResults(FacialLandMarkDetectionResults *results);
+
+		/**
+		 * @brief	Gets the PoseEstimationDetectionResults
+		 *
+		 * @since_tizen 6.0
+		 * @return @c true on success, otherwise a negative error value
+		 */
+		int GetPoseEstimationDetectionResults(PoseEstimationResults *results);
+
+		int GetResults(std::vector<std::vector<int> > *dimInfo,
+					   std::vector<float *> *results);
+
+		mv_engine_config_h GetEngineConfig(void)
+		{
+			return engine_config;
+		}
+
+		void SetEngineConfig(mv_engine_config_h config)
+		{
+			engine_config = config;
+		}
+
+	private:
+		bool mCanRun; /**< The flag indicating ready to run Inference */
+		InferenceConfig mConfig;
+		inference_engine_capacity mBackendCapacity;
+		std::map<int, std::pair<std::string, bool> > mSupportedInferenceBackend;
+		cv::Size mInputSize;
+		int mCh;
+		int mDim;
+		double mDeviation;
+		double mMean;
+		double mThreshold;
+		int mOutputNumbers;
+		cv::Size mSourceSize;
+		cv::Mat mInputBuffer;
+		mv_engine_config_h engine_config;
+		InferenceEngineCommon *mBackend;
+		std::map<std::string, int> mModelFormats;
+		std::vector<std::string> mUserListName;
+		std::vector<inference_engine_tensor_buffer> mInputTensorBuffers;
+		inference_engine_layer_property mInputLayerProperty;
+		std::vector<inference_engine_tensor_buffer> mOutputTensorBuffers;
+		inference_engine_layer_property mOutputLayerProperty;
+
+	private:
+		void CheckSupportedInferenceBackend();
+		int ConvertEngineErrorToVisionError(int error);
+		int ConvertTargetTypes(int given_types);
+		int ConvertToCv(int given_type);
+		inference_tensor_data_type_e ConvertToIE(int given_type);
+		int Preprocess(cv::Mat cvImg, cv::Mat cvDst, int data_type);
+		int PrepareTenosrBuffers(void);
+		void CleanupTensorBuffers(void);
+		int SetUserFile(std::string filename);
+		int FillOutputResult(tensor_t &outputData);
+	};
 
 } /* Inference */
 } /* MediaVision */
diff --git a/mv_inference/inference/include/InferenceIni.h b/mv_inference/inference/include/InferenceIni.h
index 0834f195..7a586148 100644
--- a/mv_inference/inference/include/InferenceIni.h
+++ b/mv_inference/inference/include/InferenceIni.h
@@ -21,48 +21,50 @@
 #include <vector>
 #include <mv_inference_type.h>
 
-namespace mediavision {
-namespace inference {
+namespace mediavision
+{
+namespace inference
+{
+	class InferenceInI
+	{
+	public:
+		/**
+		 * @brief   Creates an Inference class instance.
+		 *
+		 * @since_tizen 5.5
+		 */
+		InferenceInI();
 
-class InferenceInI {
-public:
-	/**
-	 * @brief   Creates an Inference class instance.
-	 *
-	 * @since_tizen 5.5
-	 */
-	InferenceInI();
+		/**
+		 * @brief   Destroys an Inference class instance including
+		 *           its all resources.
+		 *
+		 * @since_tizen 5.5
+		 */
+		~InferenceInI();
 
-	/**
-	 * @brief   Destroys an Inference class instance including
-	 *           its all resources.
-	 *
-	 * @since_tizen 5.5
-	 */
-	~InferenceInI();
+		/**
+		 * @brief   Load()
+		 *
+		 * @since_tizen 5.5
+		 */
+		int LoadInI();
 
-	/**
-	 * @brief   Load()
-	 *
-	 * @since_tizen 5.5
-	 */
-    int LoadInI();
+		/**
+		 * @brief   Unload()
+		 *
+		 * @since_tizen 5.5
+		 */
+		void UnLoadInI();
 
-	/**
-	 * @brief   Unload()
-	 *
-	 * @since_tizen 5.5
-	 */
-    void UnLoadInI();
+		std::vector<int> GetSupportedInferenceEngines();
 
-	std::vector<int> GetSupportedInferenceEngines();
-
-private:
-	std::vector<int> mSupportedInferenceBackend;
-	std::string mIniDefaultPath;
-	std::string mDefaultBackend;
-	std::string mDelimeter;
-};
+	private:
+		std::vector<int> mSupportedInferenceBackend;
+		std::string mIniDefaultPath;
+		std::string mDefaultBackend;
+		std::string mDelimeter;
+	};
 
 } /* Inference */
 } /* MediaVision */
diff --git a/mv_inference/inference/include/mv_inference_open.h b/mv_inference/inference/include/mv_inference_open.h
index e3140524..43ce8e41 100755..100644
--- a/mv_inference/inference/include/mv_inference_open.h
+++ b/mv_inference/inference/include/mv_inference_open.h
@@ -22,516 +22,517 @@
 #include <mv_inference.h>
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif /* __cplusplus */
 
-/**
- * @file   mv_inference_open.h
- * @brief  This file contains the Media Vision Inference Open API.
- */
+	/**
+	 * @file   mv_inference_open.h
+	 * @brief  This file contains the Media Vision Inference Open API.
+	 */
 
-/*************/
-/* Inference */
-/*************/
+	/*************/
+	/* Inference */
+	/*************/
 
-mv_engine_config_h mv_inference_get_engine_config(mv_inference_h infer);
+	mv_engine_config_h mv_inference_get_engine_config(mv_inference_h infer);
 
-/**
- * @brief Create infernce handle.
- * @details Use this function to create an inference handle. After creation
- *          the inference handle has to be prepared with
- *          @ref mv_inference_prepare() function to prepare an inference.
- *
- * @since_tizen 5.5
- *
- * @param [out] infer    The handle to the inference to be created
- *
- * @return @c 0 on success, otherwise a negative error value
- * @retval #MEDIA_VISION_ERROR_NONE Successful
- * @retval #MEDIA_VISION_ERROR_INVALID_PARAMETER Invalid parameter
- * @retval #MEDIA_VISION_ERROR_OUT_OF_MEMORY Out of memory
- *
- * @post Release @a infer by using
- *       @ref mv_inference_destroy() function when it is not needed
- *       anymore
- *
- * @see mv_inference_destroy_open()
- * @see mv_inference_prepare_open()
- */
-int mv_inference_create_open(mv_inference_h *infer);
+	/**
+	 * @brief Create infernce handle.
+	 * @details Use this function to create an inference handle. After creation
+	 *          the inference handle has to be prepared with
+	 *          @ref mv_inference_prepare() function to prepare an inference.
+	 *
+	 * @since_tizen 5.5
+	 *
+	 * @param [out] infer    The handle to the inference to be created
+	 *
+	 * @return @c 0 on success, otherwise a negative error value
+	 * @retval #MEDIA_VISION_ERROR_NONE Successful
+	 * @retval #MEDIA_VISION_ERROR_INVALID_PARAMETER Invalid parameter
+	 * @retval #MEDIA_VISION_ERROR_OUT_OF_MEMORY Out of memory
+ 	 *
+	 * @post Release @a infer by using
+	 *       @ref mv_inference_destroy() function when it is not needed
+	 *       anymore
+	 *
+	 * @see mv_inference_destroy_open()
+	 * @see mv_inference_prepare_open()
+	 */
+	int mv_inference_create_open(mv_inference_h *infer);
 
-/**
- * @brief Destroy inference handle and releases all its resources.
- *
- * @since_tizen 5.5
- *
- * @param [in] infer    The handle to the inference to be destroyed
- *
- * @return @c 0 on success, otherwise a negative error value
- * @retval #MEDIA_VISION_ERROR_NONE Successful
- * @retval #MEDIA_VISION_ERROR_INVALID_PARAMETER Invalid parameter
- *
- * @pre Create an inference handle by using @ref mv_inference_create_open()
- *
- * @see mv_inference_create_open()
- */
-int mv_inference_destroy_open(mv_inference_h infer);
+	/**
+	 * @brief Destroy inference handle and releases all its resources.
+	 *
+	 * @since_tizen 5.5
+	 *
+	 * @param [in] infer    The handle to the inference to be destroyed
+	 *
+	 * @return @c 0 on success, otherwise a negative error value
+	 * @retval #MEDIA_VISION_ERROR_NONE Successful
+	 * @retval #MEDIA_VISION_ERROR_INVALID_PARAMETER Invalid parameter
+	 *
+	 * @pre Create an inference handle by using @ref mv_inference_create_open()
+	 *
+	 * @see mv_inference_create_open()
+	 */
+	int mv_inference_destroy_open(mv_inference_h infer);
 
-/**
- * @brief Configure the inference model data to inference handle
- *
- * @since_tizen 5.5
- *
- * @param [in] infer         The handle to the inference
- * @param [in] engine_config The handle to the configuration of
- *                           engine.
- *
- * @return @c 0 on success, otherwise a negative error value
- * @retval #MEDIA_VISION_ERROR_NONE Successful
- * @retval #MEDIA_VISION_ERROR_INVALID_PARAMETER Invalid parameter
- *                                               in @a engine_config
- * @retval #MEDIA_VISION_ERROR_INVALID_PATH Invalid path of model data
- *                                          in @a engine_config
- * @retval #MEDIA_VISION_ERROR_INVALID_DATA Invalid model data
- * @retval #MEDIA_VISION_ERROR_OUT_OF_MEMORY Out of memory
- * @retval #MEDIA_VISION_ERROR_NOT_SUPPORTED Not supported
- */
-int mv_inference_configure_model_open(mv_inference_h infer, mv_engine_config_h engine_config);
+	/**
+	 * @brief Configure the inference model data to inference handle
+	 *
+	 * @since_tizen 5.5
+	 *
+	 * @param [in] infer         The handle to the inference
+	 * @param [in] engine_config The handle to the configuration of
+	 *                           engine.
+	 *
+	 * @return @c 0 on success, otherwise a negative error value
+	 * @retval #MEDIA_VISION_ERROR_NONE Successful
+	 * @retval #MEDIA_VISION_ERROR_INVALID_PARAMETER Invalid parameter
+	 *                                               in @a engine_config
+	 * @retval #MEDIA_VISION_ERROR_INVALID_PATH Invalid path of model data
+	 *                                          in @a engine_config
+	 * @retval #MEDIA_VISION_ERROR_INVALID_DATA Invalid model data
+	 * @retval #MEDIA_VISION_ERROR_OUT_OF_MEMORY Out of memory
+	 * @retval #MEDIA_VISION_ERROR_NOT_SUPPORTED Not supported
+	 */
+	int mv_inference_configure_model_open(mv_inference_h infer,
+										  mv_engine_config_h engine_config);
 
-/**
- * @brief Configure the tensor information to the inference handle
- *
- * @since_tizen 5.5
- * @remarks deprecated Replaced by mv_inference_configure_input_info
- *
- * @param [in] infer         The handle to the inference
- * @param [in] engine_config The handle to the configuration of
- *                           engine.
- *
- * @return @c 0 on success, otherwise a negative error value
- * @retval #MEDIA_VISION_ERROR_NONE Successful
- * @retval #MEDIA_VISION_ERROR_INVALID_PARAMETER Invalid parameter
- *                                               in @a engine_config
- * @retval #MEDIA_VISION_ERROR_INVALID_PATH Invalid path of model data
- *                                          in @a engine_config
- * @retval #MEDIA_VISION_ERROR_INVALID_DATA Invalid model data
- * @retval #MEDIA_VISION_ERROR_OUT_OF_MEMORY Out of memory
- * @retval #MEDIA_VISION_ERROR_NOT_SUPPORTED Not supported
- */
+	/**
+	 * @brief Configure the tensor information to the inference handle
+	 *
+	 * @since_tizen 5.5
+	 * @remarks deprecated Replaced by mv_inference_configure_input_info
+	 *
+	 * @param [in] infer         The handle to the inference
+	 * @param [in] engine_config The handle to the configuration of
+	 *                           engine.
+	 *
+	 * @return @c 0 on success, otherwise a negative error value
+	 * @retval #MEDIA_VISION_ERROR_NONE Successful
+	 * @retval #MEDIA_VISION_ERROR_INVALID_PARAMETER Invalid parameter
+	 *                                               in @a engine_config
+	 * @retval #MEDIA_VISION_ERROR_INVALID_PATH Invalid path of model data
+	 *                                          in @a engine_config
+	 * @retval #MEDIA_VISION_ERROR_INVALID_DATA Invalid model data
+	 * @retval #MEDIA_VISION_ERROR_OUT_OF_MEMORY Out of memory
+	 * @retval #MEDIA_VISION_ERROR_NOT_SUPPORTED Not supported
+	 */
 
-int mv_inference_configure_input_info_open(mv_inference_h infer, mv_engine_config_h engine_config);
+	int
+	mv_inference_configure_input_info_open(mv_inference_h infer,
+										   mv_engine_config_h engine_config);
 
-/**
- * @brief Configure the input information to the inference handle
- *
- * @since_tizen 6.0
- *
- * @param [in] infer         The handle to the inference
- * @param [in] engine_config The handle to the configuration of
- *                           engine.
- *
- * @return @c 0 on success, otherwise a negative error value
- * @retval #MEDIA_VISION_ERROR_NONE Successful
- * @retval #MEDIA_VISION_ERROR_INVALID_PARAMETER Invalid parameter
- *                                               in @a engine_config
- * @retval #MEDIA_VISION_ERROR_INVALID_PATH Invalid path of model data
- *                                          in @a engine_config
- * @retval #MEDIA_VISION_ERROR_INVALID_DATA Invalid model data
- * @retval #MEDIA_VISION_ERROR_OUT_OF_MEMORY Out of memory
- * @retval #MEDIA_VISION_ERROR_NOT_SUPPORTED Not supported
- */
-int mv_inference_configure_input_info_open(mv_inference_h infer, mv_engine_config_h engine_config);
+	/**
+	 * @brief Configure the input information to the inference handle
+	 *
+	 * @since_tizen 6.0
+	 *
+	 * @param [in] infer         The handle to the inference
+	 * @param [in] engine_config The handle to the configuration of
+	 *                           engine.
+	 *
+	 * @return @c 0 on success, otherwise a negative error value
+	 * @retval #MEDIA_VISION_ERROR_NONE Successful
+	 * @retval #MEDIA_VISION_ERROR_INVALID_PARAMETER Invalid parameter
+	 *                                               in @a engine_config
+	 * @retval #MEDIA_VISION_ERROR_INVALID_PATH Invalid path of model data
+	 *                                          in @a engine_config
+	 * @retval #MEDIA_VISION_ERROR_INVALID_DATA Invalid model data
+	 * @retval #MEDIA_VISION_ERROR_OUT_OF_MEMORY Out of memory
+	 * @retval #MEDIA_VISION_ERROR_NOT_SUPPORTED Not supported
+	 */
+	int
+	mv_inference_configure_input_info_open(mv_inference_h infer,
+										   mv_engine_config_h engine_config);
 
-/**
- * @brief Configure the backend to the inference handle
- *
- * @since_tizen 5.5
- *
- * @param [in] infer         The handle to the inference
- * @param [in] engine_config The handle to the configuration of
- *                           engine.
- *
- * @return @c 0 on success, otherwise a negative error value
- * @retval #MEDIA_VISION_ERROR_NONE Successful
- * @retval #MEDIA_VISION_ERROR_INVALID_PARAMETER Invalid parameter
- *                                               in @a engine_config
- * @retval #MEDIA_VISION_ERROR_INVALID_PATH Invalid path of model data
- *                                          in @a engine_config
- * @retval #MEDIA_VISION_ERROR_INVALID_DATA Invalid model data
- * @retval #MEDIA_VISION_ERROR_OUT_OF_MEMORY Out of memory
- * @retval #MEDIA_VISION_ERROR_NOT_SUPPORTED Not supported
- */
-int mv_inference_configure_engine_open(mv_inference_h infer, mv_engine_config_h engine_config);
+	/**
+	 * @brief Configure the backend to the inference handle
+	 *
+	 * @since_tizen 5.5
+	 *
+	 * @param [in] infer         The handle to the inference
+	 * @param [in] engine_config The handle to the configuration of
+	 *                           engine.
+	 *
+	 * @return @c 0 on success, otherwise a negative error value
+	 * @retval #MEDIA_VISION_ERROR_NONE Successful
+	 * @retval #MEDIA_VISION_ERROR_INVALID_PARAMETER Invalid parameter
+	 *                                               in @a engine_config
+	 * @retval #MEDIA_VISION_ERROR_INVALID_PATH Invalid path of model data
+	 *                                          in @a engine_config
+	 * @retval #MEDIA_VISION_ERROR_INVALID_DATA Invalid model data
+	 * @retval #MEDIA_VISION_ERROR_OUT_OF_MEMORY Out of memory
+	 * @retval #MEDIA_VISION_ERROR_NOT_SUPPORTED Not supported
+	 */
+	int mv_inference_configure_engine_open(mv_inference_h infer,
+										   mv_engine_config_h engine_config);
 
-/**
- * @brief Configure the number of output to the inference handle
- *
- * @since_tizen 5.5
- * @remarks deprecated Replaced by mv_inference_configure_post_process_info_open
- *
- * @param [in] infer         The handle to the inference
- * @param [in] engine_config The handle to the configuration of
- *                           engine.
- *
- * @return @c 0 on success, otherwise a negative error value
- * @retval #MEDIA_VISION_ERROR_NONE Successful
- * @retval #MEDIA_VISION_ERROR_INVALID_PARAMETER Invalid parameter
- *                                               in @a engine_config
- * @retval #MEDIA_VISION_ERROR_INVALID_PATH Invalid path of model data
- *                                          in @a engine_config
- * @retval #MEDIA_VISION_ERROR_INVALID_DATA Invalid model data
- * @retval #MEDIA_VISION_ERROR_OUT_OF_MEMORY Out of memory
- * @retval #MEDIA_VISION_ERROR_NOT_SUPPORTED Not supported
- */
-int mv_inference_configure_output_open(mv_inference_h infer, mv_engine_config_h engine_config);
+	/**
+	 * @brief Configure the number of output to the inference handle
+	 *
+	 * @since_tizen 5.5
+	 * @remarks deprecated Replaced by mv_inference_configure_post_process_info_open
+	 *
+	 * @param [in] infer         The handle to the inference
+	 * @param [in] engine_config The handle to the configuration of
+	 *                           engine.
+	 *
+	 * @return @c 0 on success, otherwise a negative error value
+	 * @retval #MEDIA_VISION_ERROR_NONE Successful
+	 * @retval #MEDIA_VISION_ERROR_INVALID_PARAMETER Invalid parameter
+	 *                                               in @a engine_config
+	 * @retval #MEDIA_VISION_ERROR_INVALID_PATH Invalid path of model data
+	 *                                          in @a engine_config
+	 * @retval #MEDIA_VISION_ERROR_INVALID_DATA Invalid model data
+	 * @retval #MEDIA_VISION_ERROR_OUT_OF_MEMORY Out of memory
+	 * @retval #MEDIA_VISION_ERROR_NOT_SUPPORTED Not supported
+	 */
+	int mv_inference_configure_output_open(mv_inference_h infer,
+										   mv_engine_config_h engine_config);
 
-/**
- * @brief Configure the confidence threshold value to the inference handle
- *
- * @since_tizen 5.5
- * @remarks deprecated Replaced by mv_inference_configure_post_process_info_open
- *
- * @param [in] infer         The handle to the inference
- * @param [in] engine_config The handle to the configuration of
- *                           engine.
- *
- * @return @c 0 on success, otherwise a negative error value
- * @retval #MEDIA_VISION_ERROR_NONE Successful
- * @retval #MEDIA_VISION_ERROR_INVALID_PARAMETER Invalid parameter
- *                                               in @a engine_config
- * @retval #MEDIA_VISION_ERROR_INVALID_PATH Invalid path of model data
- *                                          in @a engine_config
- * @retval #MEDIA_VISION_ERROR_INVALID_DATA Invalid model data
- * @retval #MEDIA_VISION_ERROR_OUT_OF_MEMORY Out of memory
- * @retval #MEDIA_VISION_ERROR_NOT_SUPPORTED Not supported
- */
-int mv_inference_configure_confidence_threshold_open(mv_inference_h infer, mv_engine_config_h engine_config);
+	/**
+	 * @brief Configure the confidence threshold value to the inference handle
+	 *
+	 * @since_tizen 5.5
+	 * @remarks deprecated Replaced by mv_inference_configure_post_process_info_open
+	 *
+	 * @param [in] infer         The handle to the inference
+	 * @param [in] engine_config The handle to the configuration of
+	 *                           engine.
+	 *
+	 * @return @c 0 on success, otherwise a negative error value
+	 * @retval #MEDIA_VISION_ERROR_NONE Successful
+	 * @retval #MEDIA_VISION_ERROR_INVALID_PARAMETER Invalid parameter
+	 *                                               in @a engine_config
+	 * @retval #MEDIA_VISION_ERROR_INVALID_PATH Invalid path of model data
+	 *                                          in @a engine_config
+	 * @retval #MEDIA_VISION_ERROR_INVALID_DATA Invalid model data
+	 * @retval #MEDIA_VISION_ERROR_OUT_OF_MEMORY Out of memory
+	 * @retval #MEDIA_VISION_ERROR_NOT_SUPPORTED Not supported
+	 */
+	int mv_inference_configure_confidence_threshold_open(
+			mv_inference_h infer, mv_engine_config_h engine_config);
 
-/**
- * @brief Configure the post process infomation to the inference handle
- *
- * @since_tizen 6.0
- *
- * @param [in] infer         The handle to the inference
- * @param [in] engine_config The handle to the configuration of
- *                           engine.
- *
- * @return @c 0 on success, otherwise a negative error value
- * @retval #MEDIA_VISION_ERROR_NONE Successful
- * @retval #MEDIA_VISION_ERROR_INVALID_PARAMETER Invalid parameter
- *                                               in @a engine_config
- * @retval #MEDIA_VISION_ERROR_INVALID_PATH Invalid path of model data
- *                                          in @a engine_config
- * @retval #MEDIA_VISION_ERROR_INVALID_DATA Invalid model data
- * @retval #MEDIA_VISION_ERROR_OUT_OF_MEMORY Out of memory
- * @retval #MEDIA_VISION_ERROR_NOT_SUPPORTED Not supported
- */
-int mv_inference_configure_post_process_info_open(mv_inference_h infer, mv_engine_config_h engine_config);
+	/**
+	 * @brief Configure the post process infomation to the inference handle
+	 *
+	 * @since_tizen 6.0
+	 *
+	 * @param [in] infer         The handle to the inference
+	 * @param [in] engine_config The handle to the configuration of
+	 *                           engine.
+	 *
+	 * @return @c 0 on success, otherwise a negative error value
+	 * @retval #MEDIA_VISION_ERROR_NONE Successful
+	 * @retval #MEDIA_VISION_ERROR_INVALID_PARAMETER Invalid parameter
+	 *                                               in @a engine_config
+	 * @retval #MEDIA_VISION_ERROR_INVALID_PATH Invalid path of model data
+	 *                                          in @a engine_config
+	 * @retval #MEDIA_VISION_ERROR_INVALID_DATA Invalid model data
+	 * @retval #MEDIA_VISION_ERROR_OUT_OF_MEMORY Out of memory
+	 * @retval #MEDIA_VISION_ERROR_NOT_SUPPORTED Not supported
+	 */
+	int mv_inference_configure_post_process_info_open(
+			mv_inference_h infer, mv_engine_config_h engine_config);
 
-/**
- * @brief Configure the set of output node names to the inference handle
- *
- * @since_tizen 5.5
- * @remarks deprecated Replaced by mv_inference_configure_output_info_open
- *
- * @param [in] infer         The handle to the inference
- * @param [in] engine_config The handle to the configuration of
- *                           engine.
- *
- * @return @c 0 on success, otherwise a negative error value
- * @retval #MEDIA_VISION_ERROR_NONE Successful
- * @retval #MEDIA_VISION_ERROR_INVALID_PARAMETER Invalid parameter
- *                                               in @a engine_config
- * @retval #MEDIA_VISION_ERROR_INVALID_PATH Invalid path of model data
- *                                          in @a engine_config
- * @retval #MEDIA_VISION_ERROR_INVALID_DATA Invalid model data
- * @retval #MEDIA_VISION_ERROR_OUT_OF_MEMORY Out of memory
- * @retval #MEDIA_VISION_ERROR_NOT_SUPPORTED Not supported
- */
-int mv_inference_configure_output_node_names_open(mv_inference_h infer, mv_engine_config_h engine_config);
+	/**
+	 * @brief Configure the set of output node names to the inference handle
+	 *
+	 * @since_tizen 5.5
+	 * @remarks deprecated Replaced by mv_inference_configure_output_info_open
+	 *
+	 * @param [in] infer         The handle to the inference
+	 * @param [in] engine_config The handle to the configuration of
+	 *                           engine.
+	 *
+	 * @return @c 0 on success, otherwise a negative error value
+	 * @retval #MEDIA_VISION_ERROR_NONE Successful
+	 * @retval #MEDIA_VISION_ERROR_INVALID_PARAMETER Invalid parameter
+	 *                                               in @a engine_config
+	 * @retval #MEDIA_VISION_ERROR_INVALID_PATH Invalid path of model data
+	 *                                          in @a engine_config
+	 * @retval #MEDIA_VISION_ERROR_INVALID_DATA Invalid model data
+	 * @retval #MEDIA_VISION_ERROR_OUT_OF_MEMORY Out of memory
+	 * @retval #MEDIA_VISION_ERROR_NOT_SUPPORTED Not supported
+	 */
+	int mv_inference_configure_output_node_names_open(
+			mv_inference_h infer, mv_engine_config_h engine_config);
 
-/**
- * @brief Configure the output information to the inference handle
- *
- * @since_tizen 6.0
- *
- * @param [in] infer         The handle to the inference
- * @param [in] engine_config The handle to the configuration of
- *                           engine.
- *
- * @return @c 0 on success, otherwise a negative error value
- * @retval #MEDIA_VISION_ERROR_NONE Successful
- * @retval #MEDIA_VISION_ERROR_INVALID_PARAMETER Invalid parameter
- *                                               in @a engine_config
- * @retval #MEDIA_VISION_ERROR_INVALID_PATH Invalid path of model data
- *                                          in @a engine_config
- * @retval #MEDIA_VISION_ERROR_INVALID_DATA Invalid model data
- * @retval #MEDIA_VISION_ERROR_OUT_OF_MEMORY Out of memory
- * @retval #MEDIA_VISION_ERROR_NOT_SUPPORTED Not supported
- */
-int mv_inference_configure_output_info_open(mv_inference_h infer, mv_engine_config_h engine_config);
+	/**
+	 * @brief Configure the output information to the inference handle
+	 *
+	 * @since_tizen 6.0
+	 *
+	 * @param [in] infer         The handle to the inference
+	 * @param [in] engine_config The handle to the configuration of
+	 *                           engine.
+	 *
+	 * @return @c 0 on success, otherwise a negative error value
+	 * @retval #MEDIA_VISION_ERROR_NONE Successful
+	 * @retval #MEDIA_VISION_ERROR_INVALID_PARAMETER Invalid parameter
+	 *                                               in @a engine_config
+	 * @retval #MEDIA_VISION_ERROR_INVALID_PATH Invalid path of model data
+	 *                                          in @a engine_config
+	 * @retval #MEDIA_VISION_ERROR_INVALID_DATA Invalid model data
+	 * @retval #MEDIA_VISION_ERROR_OUT_OF_MEMORY Out of memory
+	 * @retval #MEDIA_VISION_ERROR_NOT_SUPPORTED Not supported
+	 */
+	int
+	mv_inference_configure_output_info_open(mv_inference_h infer,
+											mv_engine_config_h engine_config);
 
-/**
- * @brief Prepare inference.
- * @details Use this function to prepare inference based on
- *          the configured network.
- *
- * @since_tizen 5.5
- *
- * @param [in] infer         The handle to the inference
- *
- * @return @c 0 on success, otherwise a negative error value
- * @retval #MEDIA_VISION_ERROR_NONE Successful
- * @retval #MEDIA_VISION_ERROR_INVALID_PARAMETER Invalid parameter
- *                                               in @a engine_config
- * @retval #MEDIA_VISION_ERROR_INVALID_PATH Invalid path of model data
- *                                          in @a engine_config
- * @retval #MEDIA_VISION_ERROR_INVALID_DATA Invalid model data
- * @retval #MEDIA_VISION_ERROR_OUT_OF_MEMORY Out of memory
-  */
-int mv_inference_prepare_open(mv_inference_h infer);
+	/**
+	 * @brief Prepare inference.
+	 * @details Use this function to prepare inference based on
+	 *          the configured network.
+	 *
+	 * @since_tizen 5.5
+	 *
+	 * @param [in] infer         The handle to the inference
+	 *
+	 * @return @c 0 on success, otherwise a negative error value
+	 * @retval #MEDIA_VISION_ERROR_NONE Successful
+	 * @retval #MEDIA_VISION_ERROR_INVALID_PARAMETER Invalid parameter
+	 *                                               in @a engine_config
+	 * @retval #MEDIA_VISION_ERROR_INVALID_PATH Invalid path of model data
+	 *                                          in @a engine_config
+	 * @retval #MEDIA_VISION_ERROR_INVALID_DATA Invalid model data
+	 * @retval #MEDIA_VISION_ERROR_OUT_OF_MEMORY Out of memory
+	 */
+	int mv_inference_prepare_open(mv_inference_h infer);
 
-/**
-* @brief Traverses the list of supported engines for inference.
-* @details Using this function the supported engines can be obtained.
-*          The names can be used with mv_engine_config_h related
-*          getters and setters to get/set MV_INFERENCE_BACKEND_TYPE attribute
-*          value.
-*
-* @since_tizen 5.5
-* @param [in] infer The handle to the inference
-* @param [in] callback The iteration callback function
-* @param [in] user_data The user data to be passed to the callback function
-* @return @c 0 on success, otherwise a negative error value
-* @retval #MEDIA_VISION_ERROR_NONE Successful
-* @retval #MEDIA_VISION_ERROR_INVALID_PARAMETER Invalid parameter
-* @retval #MEDIA_VISION_ERROR_INVALID_OPERATION Invalid operation
-* @retval #MEDIA_VISION_ERROR_NOT_SUPPORTED Not supported
-*
-* @pre @a engine_cfg must be created
-*
-* @see mv_engine_config_set_string_attribute()
-* @see mv_engine_config_get_string_attribute()
-*/
-int mv_inference_foreach_supported_engine_open(
-	mv_inference_h infer,
-	mv_inference_supported_engine_cb callback,
-	void *user_data);
+	/**
+	 * @brief Traverses the list of supported engines for inference.
+	 * @details Using this function the supported engines can be obtained.
+	 *          The names can be used with mv_engine_config_h related
+	 *          getters and setters to get/set MV_INFERENCE_BACKEND_TYPE attribute
+	 *          value.
+	 *
+	 * @since_tizen 5.5
+	 * @param [in] infer The handle to the inference
+	 * @param [in] callback The iteration callback function
+	 * @param [in] user_data The user data to be passed to the callback function
+	 * @return @c 0 on success, otherwise a negative error value
+	 * @retval #MEDIA_VISION_ERROR_NONE Successful
+	 * @retval #MEDIA_VISION_ERROR_INVALID_PARAMETER Invalid parameter
+	 * @retval #MEDIA_VISION_ERROR_INVALID_OPERATION Invalid operation
+	 * @retval #MEDIA_VISION_ERROR_NOT_SUPPORTED Not supported
+	 *
+	 * @pre @a engine_cfg must be created
+	 *
+	 * @see mv_engine_config_set_string_attribute()
+	 * @see mv_engine_config_get_string_attribute()
+	 */
+	int mv_inference_foreach_supported_engine_open(
+			mv_inference_h infer, mv_inference_supported_engine_cb callback,
+			void *user_data);
 
-/**
- * @brief Performs image classification on the @a source
- * @details Use this function to launch image classification.
- *          Each time when mv_inference_image_classify is
- *          called, @a classified_cb will receive classes
- *          which the media source may belong to.
- *
- * @since_tizen 5.5
- *
- * @param [in] source         The handle to the source of the media
- * @param [in] infer          The handle to the inference
- * @param [in] roi            Rectangular box bounding the region-of-interest on the
- *                           @a source. If NULL, then full source will be
- *                           analyzed.
- * @param [in] classified_cb  The callback which will be called for
- *                            classification on media source.
- *                            This callback will receive classification results.
- * @param [in] user_data      The user data passed from the code where
- *                            @ref mv_inference_image_classify_open() is invoked. This data will
- *                            be accessible from @a classified_cb callback.
- * @return @c 0 on success, otherwise a negative error value
- * @retval #MEDIA_VISION_ERROR_NONE Successful
- * @retval #MEDIA_VISION_ERROR_INVALID_PARAMETER Invalid parameter
- * @retval #MEDIA_VISION_ERROR_INTERNAL          Internal error
- * @retval #MEDIA_VISION_ERROR_NOT_SUPPORTED_FORMAT Source colorspace
- *                                                  isn't supported
- * @retval #MEDIA_VISION_ERROR_OUT_OF_MEMORY Out of memory
- * @retval #MEDIA_VISION_ERROR_NOT_SUPPORTED Not supported
- *
- * @pre Create a source handle by calling @ref mv_create_source()
- * @pre Create an inference handle by calling @ref mv_inference_create()
- * @pre Configure an inference handle by calling @ref mv_inference_configure()
- * @pre Prepare an inference by calling @ref mv_inference_prepare()
- * @post @a classified_cb will be called to process classification results
- *
- * @see mv_inference_image_classified_cb
- */
-int mv_inference_image_classify_open(
-    mv_source_h source,
-    mv_inference_h infer,
-    mv_rectangle_s *roi,
-    mv_inference_image_classified_cb classified_cb,
-    void *user_data);
+	/**
+	 * @brief Performs image classification on the @a source
+	 * @details Use this function to launch image classification.
+	 *          Each time when mv_inference_image_classify is
+	 *          called, @a classified_cb will receive classes
+	 *          which the media source may belong to.
+	 *
+	 * @since_tizen 5.5
+	 *
+	 * @param [in] source         The handle to the source of the media
+	 * @param [in] infer          The handle to the inference
+	 * @param [in] roi            Rectangular box bounding the region-of-interest on the
+	 *                           @a source. If NULL, then full source will be
+	 *                           analyzed.
+	 * @param [in] classified_cb  The callback which will be called for
+	 *                            classification on media source.
+	 *                            This callback will receive classification results.
+	 * @param [in] user_data      The user data passed from the code where
+	 *                            @ref mv_inference_image_classify_open() is invoked. This data will
+	 *                            be accessible from @a classified_cb callback.
+	 * @return @c 0 on success, otherwise a negative error value
+	 * @retval #MEDIA_VISION_ERROR_NONE Successful
+	 * @retval #MEDIA_VISION_ERROR_INVALID_PARAMETER Invalid parameter
+	 * @retval #MEDIA_VISION_ERROR_INTERNAL          Internal error
+	 * @retval #MEDIA_VISION_ERROR_NOT_SUPPORTED_FORMAT Source colorspace
+	 *                                                  isn't supported
+	 * @retval #MEDIA_VISION_ERROR_OUT_OF_MEMORY Out of memory
+	 * @retval #MEDIA_VISION_ERROR_NOT_SUPPORTED Not supported
+	 *
+	 * @pre Create a source handle by calling @ref mv_create_source()
+	 * @pre Create an inference handle by calling @ref mv_inference_create()
+	 * @pre Configure an inference handle by calling @ref mv_inference_configure()
+	 * @pre Prepare an inference by calling @ref mv_inference_prepare()
+	 * @post @a classified_cb will be called to process classification results
+	 *
+	 * @see mv_inference_image_classified_cb
+	 */
+	int mv_inference_image_classify_open(
+			mv_source_h source, mv_inference_h infer, mv_rectangle_s *roi,
+			mv_inference_image_classified_cb classified_cb, void *user_data);
 
+	/**
+	 * @brief Performs object detection on the @a source
+	 * @details Use this function to launch object detection.
+	 *          Each time when mv_inference_object_detection is
+	 *          called, @a detected_cb will receive  a list of objects and their locations
+	 *          on the media source.
+	 *
+	 * @since_tizen 5.5
+	 *
+	 * @param [in] source         The handle to the source of the media
+	 * @param [in] infer          The handle to the inference
+	 * @param [in] detected_cb    The callback which will be called for
+	 *                            detecting objects on media source.
+	 *                            This callback will receive the detection results.
+	 * @param [in] user_data      The user data passed from the code where
+	 *                            @ref mv_inference_object_detect() is invoked. This data will
+	 *                            be accessible from @a detected_cb callback.
+	 * @return @c 0 on success, otherwise a negative error value
+	 * @retval #MEDIA_VISION_ERROR_NONE Successful
+	 * @retval #MEDIA_VISION_ERROR_INVALID_PARAMETER Invalid parameter
+	 * @retval #MEDIA_VISION_ERROR_INTERNAL          Internal error
+	 * @retval #MEDIA_VISION_ERROR_NOT_SUPPORTED_FORMAT Source colorspace
+	 *                                                  isn't supported
+	 * @retval #MEDIA_VISION_ERROR_OUT_OF_MEMORY Out of memory
+	 * @retval #MEDIA_VISION_ERROR_NOT_SUPPORTED Not supported
+	 *
+	 * @pre Create a source handle by calling @ref mv_create_source()
+	 * @pre Create an inference handle by calling @ref mv_inference_create()
+	 * @pre Configure an inference handle by calling @ref mv_inference_configure()
+	 * @pre Prepare an inference by calling @ref mv_inference_prepare()
+	 * @post @a detected_cb will be called to process detection results
+	 *
+	 * @see mv_inference_object_detected_cb
+	 */
+	int
+	mv_inference_object_detect_open(mv_source_h source, mv_inference_h infer,
+									mv_inference_object_detected_cb detected_cb,
+									void *user_data);
 
-/**
- * @brief Performs object detection on the @a source
- * @details Use this function to launch object detection.
- *          Each time when mv_inference_object_detection is
- *          called, @a detected_cb will receive  a list of objects and their locations
- *          on the media source.
- *
- * @since_tizen 5.5
- *
- * @param [in] source         The handle to the source of the media
- * @param [in] infer          The handle to the inference
- * @param [in] detected_cb    The callback which will be called for
- *                            detecting objects on media source.
- *                            This callback will receive the detection results.
- * @param [in] user_data      The user data passed from the code where
- *                            @ref mv_inference_object_detect() is invoked. This data will
- *                            be accessible from @a detected_cb callback.
- * @return @c 0 on success, otherwise a negative error value
- * @retval #MEDIA_VISION_ERROR_NONE Successful
- * @retval #MEDIA_VISION_ERROR_INVALID_PARAMETER Invalid parameter
- * @retval #MEDIA_VISION_ERROR_INTERNAL          Internal error
- * @retval #MEDIA_VISION_ERROR_NOT_SUPPORTED_FORMAT Source colorspace
- *                                                  isn't supported
- * @retval #MEDIA_VISION_ERROR_OUT_OF_MEMORY Out of memory
- * @retval #MEDIA_VISION_ERROR_NOT_SUPPORTED Not supported
- *
- * @pre Create a source handle by calling @ref mv_create_source()
- * @pre Create an inference handle by calling @ref mv_inference_create()
- * @pre Configure an inference handle by calling @ref mv_inference_configure()
- * @pre Prepare an inference by calling @ref mv_inference_prepare()
- * @post @a detected_cb will be called to process detection results
- *
- * @see mv_inference_object_detected_cb
- */
-int mv_inference_object_detect_open(
-	mv_source_h source,
-	mv_inference_h infer,
-	mv_inference_object_detected_cb detected_cb,
-	void *user_data);
-
-/**
- * @brief Performs face detection on the @a source
- * @details Use this function to launch face detection.
- *          Each time when mv_inference_face_detection is
- *          called, @a detected_cb will receive  a list of faces and their locations
- *          on the media source.
- *
- * @since_tizen 5.5
- *
- * @param [in] source         The handle to the source of the media
- * @param [in] infer          The handle to the inference
- * @param [in] detected_cb    The callback which will be called for
- *                            detecting faces on media source.
- *                            This callback will receive the detection results.
- * @param [in] user_data      The user data passed from the code where
- *                            @ref mv_inference_face_detect() is invoked. This data will
- *                            be accessible from @a detected_cb callback.
- * @return @c 0 on success, otherwise a negative error value
- * @retval #MEDIA_VISION_ERROR_NONE Successful
- * @retval #MEDIA_VISION_ERROR_INVALID_PARAMETER Invalid parameter
- * @retval #MEDIA_VISION_ERROR_INTERNAL          Internal error
- * @retval #MEDIA_VISION_ERROR_NOT_SUPPORTED_FORMAT Source colorspace
- *                                                  isn't supported
- * @retval #MEDIA_VISION_ERROR_OUT_OF_MEMORY Out of memory
- * @retval #MEDIA_VISION_ERROR_NOT_SUPPORTED Not supported
- *
- * @pre Create a source handle by calling @ref mv_create_source()
- * @pre Create an inference handle by calling @ref mv_inference_create()
- * @pre Configure an inference handle by calling @ref mv_inference_configure()
- * @pre Prepare an inference by calling @ref mv_inference_prepare()
- * @post @a detected_cb will be called to process detection results
- *
- * @see mv_inference_face_detected_cb
- */
-int mv_inference_face_detect_open(
-	mv_source_h source,
-	mv_inference_h infer,
-	mv_inference_face_detected_cb detected_cb,
-	void *user_data);
+	/**
+	 * @brief Performs face detection on the @a source
+	 * @details Use this function to launch face detection.
+	 *          Each time when mv_inference_face_detection is
+	 *          called, @a detected_cb will receive  a list of faces and their locations
+	 *          on the media source.
+	 *
+	 * @since_tizen 5.5
+	 *
+	 * @param [in] source         The handle to the source of the media
+	 * @param [in] infer          The handle to the inference
+	 * @param [in] detected_cb    The callback which will be called for
+	 *                            detecting faces on media source.
+	 *                            This callback will receive the detection results.
+	 * @param [in] user_data      The user data passed from the code where
+	 *                            @ref mv_inference_face_detect() is invoked. This data will
+	 *                            be accessible from @a detected_cb callback.
+	 * @return @c 0 on success, otherwise a negative error value
+	 * @retval #MEDIA_VISION_ERROR_NONE Successful
+	 * @retval #MEDIA_VISION_ERROR_INVALID_PARAMETER Invalid parameter
+	 * @retval #MEDIA_VISION_ERROR_INTERNAL          Internal error
+	 * @retval #MEDIA_VISION_ERROR_NOT_SUPPORTED_FORMAT Source colorspace
+	 *                                                  isn't supported
+	 * @retval #MEDIA_VISION_ERROR_OUT_OF_MEMORY Out of memory
+	 * @retval #MEDIA_VISION_ERROR_NOT_SUPPORTED Not supported
+	 *
+	 * @pre Create a source handle by calling @ref mv_create_source()
+	 * @pre Create an inference handle by calling @ref mv_inference_create()
+	 * @pre Configure an inference handle by calling @ref mv_inference_configure()
+	 * @pre Prepare an inference by calling @ref mv_inference_prepare()
+	 * @post @a detected_cb will be called to process detection results
+	 *
+	 * @see mv_inference_face_detected_cb
+	 */
+	int mv_inference_face_detect_open(mv_source_h source, mv_inference_h infer,
+									  mv_inference_face_detected_cb detected_cb,
+									  void *user_data);
 
-/**
- * @brief Performs facial landmarks detection on the @a source
- * @details Use this function to launch facial landmark detection.
- *          Each time when mv_inference_facial_landmark_detect() is
- *          called, @a detected_cb will receive a list facial landmark's locations
- *          on the media source.
- *
- * @since_tizen 5.5
- *
- * @param [in] source         The handle to the source of the media
- * @param [in] infer          The handle to the inference
- * @param[in] roi            Rectangular box bounding face image on the
- *                           @a source. If NULL, then full source will be
- *                           analyzed.
- * @param [in] detected_cb    The callback which will be called for
- *                            detecting facial landmark on media source.
- *                            This callback will receive the detection results.
- * @param [in] user_data      The user data passed from the code where
- *                            @ref mv_inference_facial_landmark_detect() is invoked.
- *                            This data will be accessible from @a detected_cb callback.
- *
- * @return @c 0 on success, otherwise a negative error value
- * @retval #MEDIA_VISION_ERROR_NONE Successful
- * @retval #MEDIA_VISION_ERROR_INVALID_PARAMETER Invalid parameter
- * @retval #MEDIA_VISION_ERROR_INTERNAL          Internal error
- * @retval #MEDIA_VISION_ERROR_NOT_SUPPORTED_FORMAT Source colorspace
- *                                                  isn't supported
- * @retval #MEDIA_VISION_ERROR_OUT_OF_MEMORY Out of memory
- * @retval #MEDIA_VISION_ERROR_NOT_SUPPORTED Not supported
- *
- * @pre Create a source handle by calling @ref mv_create_source()
- * @pre Create an inference handle by calling @ref mv_inference_create()
- * @pre Configure an inference handle by calling @ref mv_inference_configure()
- * @pre Prepare an inference by calling @ref mv_inference_prepare()
- * @post @a detected_cb will be called to process detection results
- *
- * @see mv_inference_facial_landmark_detected_cb
- */
-int mv_inference_facial_landmark_detect_open(
-	mv_source_h source,
-	mv_inference_h infer,
-        mv_rectangle_s *roi,
-	mv_inference_facial_landmark_detected_cb detected_cb,
-	void *user_data);
+	/**
+	 * @brief Performs facial landmarks detection on the @a source
+	 * @details Use this function to launch facial landmark detection.
+	 *          Each time when mv_inference_facial_landmark_detect() is
+	 *          called, @a detected_cb will receive a list facial landmark's locations
+	 *          on the media source.
+	 *
+	 * @since_tizen 5.5
+	 *
+	 * @param [in] source         The handle to the source of the media
+	 * @param [in] infer          The handle to the inference
+	 * @param[in] roi            Rectangular box bounding face image on the
+	 *                           @a source. If NULL, then full source will be
+	 *                           analyzed.
+	 * @param [in] detected_cb    The callback which will be called for
+	 *                            detecting facial landmark on media source.
+	 *                            This callback will receive the detection results.
+	 * @param [in] user_data      The user data passed from the code where
+	 *                            @ref mv_inference_facial_landmark_detect() is invoked.
+	 *                            This data will be accessible from @a detected_cb callback.
+	 *
+	 * @return @c 0 on success, otherwise a negative error value
+	 * @retval #MEDIA_VISION_ERROR_NONE Successful
+	 * @retval #MEDIA_VISION_ERROR_INVALID_PARAMETER Invalid parameter
+	 * @retval #MEDIA_VISION_ERROR_INTERNAL          Internal error
+	 * @retval #MEDIA_VISION_ERROR_NOT_SUPPORTED_FORMAT Source colorspace
+	 *                                                  isn't supported
+	 * @retval #MEDIA_VISION_ERROR_OUT_OF_MEMORY Out of memory
+	 * @retval #MEDIA_VISION_ERROR_NOT_SUPPORTED Not supported
+	 *
+	 * @pre Create a source handle by calling @ref mv_create_source()
+	 * @pre Create an inference handle by calling @ref mv_inference_create()
+	 * @pre Configure an inference handle by calling @ref mv_inference_configure()
+	 * @pre Prepare an inference by calling @ref mv_inference_prepare()
+	 * @post @a detected_cb will be called to process detection results
+	 *
+	 * @see mv_inference_facial_landmark_detected_cb
+	 */
+	int mv_inference_facial_landmark_detect_open(
+			mv_source_h source, mv_inference_h infer, mv_rectangle_s *roi,
+			mv_inference_facial_landmark_detected_cb detected_cb,
+			void *user_data);
 
-/**
- * @brief Performs pose estimation detection on the @a source
- * @details Use this function to launch pose estimation detection.
- *          Each time when mv_inference_pose_estimation_detect() is
- *          called, @a detected_cb will receive a list pose estimation's locations
- *          on the media source.
- *
- * @since_tizen 5.5
- *
- * @param [in] source         The handle to the source of the media
- * @param [in] infer          The handle to the inference
- * @param[in] roi            Rectangular box bounding face image on the
- *                           @a source. If NULL, then full source will be
- *                           analyzed.
- * @param [in] detected_cb    The callback which will be called for
- *                            detecting facial landmark on media source.
- *                            This callback will receive the detection results.
- * @param [in] user_data      The user data passed from the code where
- *                            @ref mv_inference_facial_landmark_detect() is invoked.
- *                            This data will be accessible from @a detected_cb callback.
- *
- * @return @c 0 on success, otherwise a negative error value
- * @retval #MEDIA_VISION_ERROR_NONE Successful
- * @retval #MEDIA_VISION_ERROR_INVALID_PARAMETER Invalid parameter
- * @retval #MEDIA_VISION_ERROR_INTERNAL          Internal error
- * @retval #MEDIA_VISION_ERROR_NOT_SUPPORTED_FORMAT Source colorspace
- *                                                  isn't supported
- * @retval #MEDIA_VISION_ERROR_OUT_OF_MEMORY Out of memory
- * @retval #MEDIA_VISION_ERROR_NOT_SUPPORTED Not supported
- *
- * @pre Create a source handle by calling @ref mv_create_source()
- * @pre Create an inference handle by calling @ref mv_inference_create()
- * @pre Configure an inference handle by calling @ref mv_inference_configure()
- * @pre Prepare an inference by calling @ref mv_inference_prepare()
- * @post @a detected_cb will be called to process detection results
- *
- * @see mv_inference_pose_estimation_detected_cb
- */
-int mv_inference_pose_estimation_detect_open(
-	mv_source_h source,
-	mv_inference_h infer,
-    mv_rectangle_s *roi,
-	mv_inference_pose_estimation_detected_cb detected_cb,
-	void *user_data);
+	/**
+	 * @brief Performs pose estimation detection on the @a source
+	 * @details Use this function to launch pose estimation detection.
+	 *          Each time when mv_inference_pose_estimation_detect() is
+	 *          called, @a detected_cb will receive a list pose estimation's locations
+	 *          on the media source.
+	 *
+	 * @since_tizen 5.5
+	 *
+	 * @param [in] source         The handle to the source of the media
+	 * @param [in] infer          The handle to the inference
+	 * @param[in] roi            Rectangular box bounding face image on the
+	 *                           @a source. If NULL, then full source will be
+	 *                           analyzed.
+	 * @param [in] detected_cb    The callback which will be called for
+	 *                            detecting facial landmark on media source.
+	 *                            This callback will receive the detection results.
+	 * @param [in] user_data      The user data passed from the code where
+	 *                            @ref mv_inference_facial_landmark_detect() is invoked.
+	 *                            This data will be accessible from @a detected_cb callback.
+	 *
+	 * @return @c 0 on success, otherwise a negative error value
+	 * @retval #MEDIA_VISION_ERROR_NONE Successful
+	 * @retval #MEDIA_VISION_ERROR_INVALID_PARAMETER Invalid parameter
+	 * @retval #MEDIA_VISION_ERROR_INTERNAL          Internal error
+	 * @retval #MEDIA_VISION_ERROR_NOT_SUPPORTED_FORMAT Source colorspace
+	 *                                                  isn't supported
+	 * @retval #MEDIA_VISION_ERROR_OUT_OF_MEMORY Out of memory
+	 * @retval #MEDIA_VISION_ERROR_NOT_SUPPORTED Not supported
+	 *
+	 * @pre Create a source handle by calling @ref mv_create_source()
+	 * @pre Create an inference handle by calling @ref mv_inference_create()
+	 * @pre Configure an inference handle by calling @ref mv_inference_configure()
+	 * @pre Prepare an inference by calling @ref mv_inference_prepare()
+	 * @post @a detected_cb will be called to process detection results
+	 *
+	 * @see mv_inference_pose_estimation_detected_cb
+	 */
+	int mv_inference_pose_estimation_detect_open(
+			mv_source_h source, mv_inference_h infer, mv_rectangle_s *roi,
+			mv_inference_pose_estimation_detected_cb detected_cb,
+			void *user_data);
 
 #ifdef __cplusplus
 }
diff --git a/mv_inference/inference/src/Inference.cpp b/mv_inference/inference/src/Inference.cpp
index ae44143a..62262adc 100755..100644
--- a/mv_inference/inference/src/Inference.cpp
+++ b/mv_inference/inference/src/Inference.cpp
@@ -31,1298 +31,1396 @@
 #define MV_INFERENCE_CONFIDENCE_THRESHOLD_MAX 1.0
 #define MV_INFERENCE_CONFIDENCE_THRESHOLD_MIN 0.0
 
-typedef enum  {
-  InputAttrNoType = 0,
-  InputAttrFloat32 = 1,
-  InputAttrInt32 = 2,
-  InputAttrUInt8 = 3,
-  InputAttrInt64 = 4,
-  InputAttrString = 5,
-  InputAttrBool = 6,
+typedef enum {
+	InputAttrNoType = 0,
+	InputAttrFloat32 = 1,
+	InputAttrInt32 = 2,
+	InputAttrUInt8 = 3,
+	InputAttrInt64 = 4,
+	InputAttrString = 5,
+	InputAttrBool = 6,
 } InputAttrType;
 
-namespace mediavision {
-namespace inference {
-InferenceConfig::InferenceConfig() :
-    mConfigFilePath(),
-	mWeightFilePath(),
-	mUserFilePath(),
-	mDataType(MV_INFERENCE_DATA_FLOAT32),
-	mBackedType(MV_INFERENCE_BACKEND_NONE),
-	mTargetTypes(MV_INFERENCE_TARGET_NONE),
-	mConfidenceThresHold(),
-	mMeanValue(),
-	mStdValue(),
-	mMaxOutputNumbers(1)
+namespace mediavision
 {
-	mTensorInfo.width = -1;
-	mTensorInfo.height = -1;
-	mTensorInfo.dim = -1;
-	mTensorInfo.ch = -1;
-}
-
-Inference::Inference() :
-	mCanRun(),
-	mConfig(),
-	mBackendCapacity(),
-	mSupportedInferenceBackend(),
-    mInputSize(cv::Size()),
-    mCh(),
-    mDim(),
-    mDeviation(),
-    mMean(),
-    mThreshold(),
-    mOutputNumbers(),
-    mSourceSize(cv::Size()),
-    mInputBuffer(cv::Mat()),
-    engine_config(),
-	mBackend()
+namespace inference
 {
-	LOGI("ENTER");
-
-	mSupportedInferenceBackend.insert(std::make_pair(MV_INFERENCE_BACKEND_OPENCV, std::make_pair("opencv", false)));
-	mSupportedInferenceBackend.insert(std::make_pair(MV_INFERENCE_BACKEND_TFLITE, std::make_pair("tflite", false)));
-	mSupportedInferenceBackend.insert(std::make_pair(MV_INFERENCE_BACKEND_ARMNN, std::make_pair("armnn", false)));
-	mSupportedInferenceBackend.insert(std::make_pair(MV_INFERENCE_BACKEND_MLAPI, std::make_pair("mlapi", false)));
-	mSupportedInferenceBackend.insert(std::make_pair(MV_INFERENCE_BACKEND_NNFW, std::make_pair("mlapi", false)));
+	InferenceConfig::InferenceConfig() :
+			mConfigFilePath(),
+			mWeightFilePath(),
+			mUserFilePath(),
+			mDataType(MV_INFERENCE_DATA_FLOAT32),
+			mBackedType(MV_INFERENCE_BACKEND_NONE),
+			mTargetTypes(MV_INFERENCE_TARGET_NONE),
+			mConfidenceThresHold(),
+			mMeanValue(),
+			mStdValue(),
+			mMaxOutputNumbers(1)
+	{
+		mTensorInfo.width = -1;
+		mTensorInfo.height = -1;
+		mTensorInfo.dim = -1;
+		mTensorInfo.ch = -1;
+	}
 
-	CheckSupportedInferenceBackend();
+	Inference::Inference() :
+			mCanRun(),
+			mConfig(),
+			mBackendCapacity(),
+			mSupportedInferenceBackend(),
+			mInputSize(cv::Size()),
+			mCh(),
+			mDim(),
+			mDeviation(),
+			mMean(),
+			mThreshold(),
+			mOutputNumbers(),
+			mSourceSize(cv::Size()),
+			mInputBuffer(cv::Mat()),
+			engine_config(),
+			mBackend()
+	{
+		LOGI("ENTER");
+
+		mSupportedInferenceBackend.insert(std::make_pair(
+				MV_INFERENCE_BACKEND_OPENCV, std::make_pair("opencv", false)));
+		mSupportedInferenceBackend.insert(std::make_pair(
+				MV_INFERENCE_BACKEND_TFLITE, std::make_pair("tflite", false)));
+		mSupportedInferenceBackend.insert(std::make_pair(
+				MV_INFERENCE_BACKEND_ARMNN, std::make_pair("armnn", false)));
+		mSupportedInferenceBackend.insert(std::make_pair(
+				MV_INFERENCE_BACKEND_MLAPI, std::make_pair("mlapi", false)));
+		mSupportedInferenceBackend.insert(std::make_pair(
+				MV_INFERENCE_BACKEND_NNFW, std::make_pair("mlapi", false)));
+
+		CheckSupportedInferenceBackend();
+
+		for (int i = 0; i < MV_INFERENCE_BACKEND_MAX; ++i) {
+			auto iter = mSupportedInferenceBackend.find(i);
+			LOGE("%d: %s: %s", i, (iter->second).first.c_str(),
+				 (iter->second).second ? "TRUE" : "FALSE");
+		}
 
-	for(int i = 0; i < MV_INFERENCE_BACKEND_MAX; ++i) {
-		auto iter = mSupportedInferenceBackend.find(i);
-		LOGE("%d: %s: %s", i, (iter->second).first.c_str(), (iter->second).second ? "TRUE" : "FALSE");
+		mModelFormats.insert(std::make_pair<std::string, int>(
+				"caffemodel", INFERENCE_MODEL_CAFFE));
+		mModelFormats.insert(
+				std::make_pair<std::string, int>("pb", INFERENCE_MODEL_TF));
+		mModelFormats.insert(std::make_pair<std::string, int>(
+				"tflite", INFERENCE_MODEL_TFLITE));
+		mModelFormats.insert(
+				std::make_pair<std::string, int>("t7", INFERENCE_MODEL_TORCH));
+		mModelFormats.insert(std::make_pair<std::string, int>(
+				"weights", INFERENCE_MODEL_DARKNET));
+		mModelFormats.insert(
+				std::make_pair<std::string, int>("bin", INFERENCE_MODEL_DLDT));
+		mModelFormats.insert(
+				std::make_pair<std::string, int>("onnx", INFERENCE_MODEL_ONNX));
+		mModelFormats.insert(std::make_pair<std::string, int>(
+				"nb", INFERENCE_MODEL_VIVANTE));
+
+		LOGI("LEAVE");
 	}
 
-	mModelFormats.insert(std::make_pair<std::string, int>("caffemodel", INFERENCE_MODEL_CAFFE));
-	mModelFormats.insert(std::make_pair<std::string, int>("pb", INFERENCE_MODEL_TF));
-	mModelFormats.insert(std::make_pair<std::string, int>("tflite", INFERENCE_MODEL_TFLITE));
-	mModelFormats.insert(std::make_pair<std::string, int>("t7", INFERENCE_MODEL_TORCH));
-	mModelFormats.insert(std::make_pair<std::string, int>("weights", INFERENCE_MODEL_DARKNET));
-	mModelFormats.insert(std::make_pair<std::string, int>("bin", INFERENCE_MODEL_DLDT));
-	mModelFormats.insert(std::make_pair<std::string, int>("onnx", INFERENCE_MODEL_ONNX));
-	mModelFormats.insert(std::make_pair<std::string, int>("nb", INFERENCE_MODEL_VIVANTE));
-
-	LOGI("LEAVE");
-}
+	Inference::~Inference()
+	{
+		CleanupTensorBuffers();
 
-Inference::~Inference()
-{
-	CleanupTensorBuffers();
+		if (!mInputLayerProperty.tensor_infos.empty()) {
+			mInputLayerProperty.tensor_infos.clear();
+			std::vector<inference_engine_tensor_info>().swap(
+					mInputLayerProperty.tensor_infos);
+		}
+		if (!mOutputLayerProperty.tensor_infos.empty()) {
+			mOutputLayerProperty.tensor_infos.clear();
+			std::vector<inference_engine_tensor_info>().swap(
+					mOutputLayerProperty.tensor_infos);
+		}
 
-	if (!mInputLayerProperty.tensor_infos.empty()) {
-		mInputLayerProperty.tensor_infos.clear();
-		std::vector<inference_engine_tensor_info>().swap(mInputLayerProperty.tensor_infos);
-	}
-	if (!mOutputLayerProperty.tensor_infos.empty()) {
-		mOutputLayerProperty.tensor_infos.clear();
-		std::vector<inference_engine_tensor_info>().swap(mOutputLayerProperty.tensor_infos);
-	}
+		mModelFormats.clear();
 
-	mModelFormats.clear();
+		// Release backend engine.
+		if (mBackend) {
+			mBackend->UnbindBackend();
+			delete mBackend;
+		}
 
-	// Release backend engine.
-	if (mBackend) {
-		mBackend->UnbindBackend();
-		delete mBackend;
+		LOGI("Released backend engine.");
 	}
 
-	LOGI("Released backend engine.");
-}
+	void Inference::CheckSupportedInferenceBackend()
+	{
+		LOGE("ENTER");
 
-void Inference::CheckSupportedInferenceBackend()
-{
-	LOGE("ENTER");
+		InferenceInI ini;
+		ini.LoadInI();
 
-	InferenceInI ini;
-	ini.LoadInI();
-
-	std::vector<int> supportedBackend = ini.GetSupportedInferenceEngines();
-	for (std::vector<int>::const_iterator it = supportedBackend.begin();
-		it != supportedBackend.end(); ++it) {
+		std::vector<int> supportedBackend = ini.GetSupportedInferenceEngines();
+		for (std::vector<int>::const_iterator it = supportedBackend.begin();
+			 it != supportedBackend.end(); ++it) {
 			LOGE("engine: %d", *it);
 
-		auto iter = mSupportedInferenceBackend.find(*it);
-		(iter->second).second = true;
-	}
+			auto iter = mSupportedInferenceBackend.find(*it);
+			(iter->second).second = true;
+		}
 
-	LOGE("LEAVE");
+		LOGE("LEAVE");
+	}
 
-}
+	int Inference::ConvertEngineErrorToVisionError(int error)
+	{
+		int ret = MEDIA_VISION_ERROR_NONE;
+
+		switch (error) {
+		case INFERENCE_ENGINE_ERROR_NONE:
+			ret = MEDIA_VISION_ERROR_NONE;
+			break;
+		case INFERENCE_ENGINE_ERROR_NOT_SUPPORTED:
+			ret = MEDIA_VISION_ERROR_NOT_SUPPORTED;
+			break;
+		case INFERENCE_ENGINE_ERROR_MSG_TOO_LONG:
+			ret = MEDIA_VISION_ERROR_MSG_TOO_LONG;
+			break;
+		case INFERENCE_ENGINE_ERROR_NO_DATA:
+			ret = MEDIA_VISION_ERROR_NO_DATA;
+			break;
+		case INFERENCE_ENGINE_ERROR_KEY_NOT_AVAILABLE:
+			ret = MEDIA_VISION_ERROR_KEY_NOT_AVAILABLE;
+			break;
+		case INFERENCE_ENGINE_ERROR_OUT_OF_MEMORY:
+			ret = MEDIA_VISION_ERROR_OUT_OF_MEMORY;
+			break;
+		case INFERENCE_ENGINE_ERROR_INVALID_PARAMETER:
+			ret = MEDIA_VISION_ERROR_INVALID_PARAMETER;
+			break;
+		case INFERENCE_ENGINE_ERROR_INVALID_OPERATION:
+			ret = MEDIA_VISION_ERROR_INVALID_OPERATION;
+			break;
+		case INFERENCE_ENGINE_ERROR_PERMISSION_DENIED:
+			ret = MEDIA_VISION_ERROR_PERMISSION_DENIED;
+			break;
+		case INFERENCE_ENGINE_ERROR_NOT_SUPPORTED_FORMAT:
+			ret = MEDIA_VISION_ERROR_NOT_SUPPORTED_FORMAT;
+			break;
+		case INFERENCE_ENGINE_ERROR_INTERNAL:
+			ret = MEDIA_VISION_ERROR_INTERNAL;
+			break;
+		case INFERENCE_ENGINE_ERROR_INVALID_DATA:
+			ret = MEDIA_VISION_ERROR_INVALID_DATA;
+			break;
+		case INFERENCE_ENGINE_ERROR_INVALID_PATH:
+			ret = MEDIA_VISION_ERROR_INVALID_PATH;
+			break;
+		default:
+			LOGE("Unknown inference engine error type");
+		}
 
-int Inference::ConvertEngineErrorToVisionError(int error)
-{
-	int ret = MEDIA_VISION_ERROR_NONE;
-
-	switch(error) {
-	case INFERENCE_ENGINE_ERROR_NONE:
-		ret = MEDIA_VISION_ERROR_NONE;
-		break;
-	case INFERENCE_ENGINE_ERROR_NOT_SUPPORTED:
-		ret = MEDIA_VISION_ERROR_NOT_SUPPORTED;
-		break;
-	case INFERENCE_ENGINE_ERROR_MSG_TOO_LONG:
-		ret = MEDIA_VISION_ERROR_MSG_TOO_LONG;
-		break;
-	case INFERENCE_ENGINE_ERROR_NO_DATA:
-		ret = MEDIA_VISION_ERROR_NO_DATA;
-		break;
-	case INFERENCE_ENGINE_ERROR_KEY_NOT_AVAILABLE:
-		ret = MEDIA_VISION_ERROR_KEY_NOT_AVAILABLE;
-		break;
-	case INFERENCE_ENGINE_ERROR_OUT_OF_MEMORY:
-		ret = MEDIA_VISION_ERROR_OUT_OF_MEMORY;
-		break;
-	case INFERENCE_ENGINE_ERROR_INVALID_PARAMETER:
-		ret = MEDIA_VISION_ERROR_INVALID_PARAMETER;
-		break;
-	case INFERENCE_ENGINE_ERROR_INVALID_OPERATION:
-		ret = MEDIA_VISION_ERROR_INVALID_OPERATION;
-		break;
-	case INFERENCE_ENGINE_ERROR_PERMISSION_DENIED:
-		ret = MEDIA_VISION_ERROR_PERMISSION_DENIED;
-		break;
-	case INFERENCE_ENGINE_ERROR_NOT_SUPPORTED_FORMAT:
-		ret = MEDIA_VISION_ERROR_NOT_SUPPORTED_FORMAT;
-		break;
-	case INFERENCE_ENGINE_ERROR_INTERNAL:
-		ret = MEDIA_VISION_ERROR_INTERNAL;
-		break;
-	case INFERENCE_ENGINE_ERROR_INVALID_DATA:
-		ret = MEDIA_VISION_ERROR_INVALID_DATA;
-		break;
-	case INFERENCE_ENGINE_ERROR_INVALID_PATH:
-		ret = MEDIA_VISION_ERROR_INVALID_PATH;
-		break;
-	default:
-		LOGE("Unknown inference engine error type");
+		return ret;
 	}
 
-	return ret;
-}
+	int Inference::ConvertTargetTypes(int given_types)
+	{
+		int target_types = INFERENCE_TARGET_NONE;
 
-int Inference::ConvertTargetTypes(int given_types)
-{
-	int target_types = INFERENCE_TARGET_NONE;
+		if (given_types & MV_INFERENCE_TARGET_DEVICE_CPU)
+			target_types |= INFERENCE_TARGET_CPU;
+		if (given_types & MV_INFERENCE_TARGET_DEVICE_GPU)
+			target_types |= INFERENCE_TARGET_GPU;
+		if (given_types & MV_INFERENCE_TARGET_DEVICE_CUSTOM)
+			target_types |= INFERENCE_TARGET_CUSTOM;
 
-	if (given_types & MV_INFERENCE_TARGET_DEVICE_CPU)
-		target_types |= INFERENCE_TARGET_CPU;
-	if (given_types & MV_INFERENCE_TARGET_DEVICE_GPU)
-		target_types |= INFERENCE_TARGET_GPU;
-	if (given_types & MV_INFERENCE_TARGET_DEVICE_CUSTOM)
-		target_types |= INFERENCE_TARGET_CUSTOM;
+		return target_types;
+	}
 
-	return target_types;
-}
+	int Inference::ConvertToCv(int given_type)
+	{
+		int type = 0;
+
+		switch (given_type) {
+		case INFERENCE_TENSOR_DATA_TYPE_UINT8:
+			LOGI("Type is %d ch with UINT8", mCh);
+			type = mCh == 1 ? CV_8UC1 : CV_8UC3;
+			break;
+		case INFERENCE_TENSOR_DATA_TYPE_FLOAT32:
+			LOGI("Type is %d ch with FLOAT32", mCh);
+			type = mCh == 1 ? CV_32FC1 : CV_32FC3;
+			break;
+		default:
+			LOGI("unknown data type so FLOAT32 data type will be used in default");
+			type = mCh == 1 ? CV_32FC1 : CV_32FC3;
+			break;
+		}
 
-int Inference::ConvertToCv(int given_type)
-{
-	int type = 0;
-
-	switch (given_type) {
-	case INFERENCE_TENSOR_DATA_TYPE_UINT8:
-		LOGI("Type is %d ch with UINT8", mCh);
-		type = mCh == 1 ? CV_8UC1 : CV_8UC3;
-		break;
-	case INFERENCE_TENSOR_DATA_TYPE_FLOAT32:
-		LOGI("Type is %d ch with FLOAT32", mCh);
-		type = mCh == 1 ? CV_32FC1 : CV_32FC3;
-		break;
-	default:
-		LOGI("unknown data type so FLOAT32 data type will be used in default");
-		type = mCh == 1 ? CV_32FC1 : CV_32FC3;
-		break;
+		return type;
 	}
 
-	return type;
-}
+	inference_tensor_data_type_e Inference::ConvertToIE(int given_type)
+	{
+		inference_tensor_data_type_e type = INFERENCE_TENSOR_DATA_TYPE_FLOAT32;
+
+		switch (given_type) {
+		case MV_INFERENCE_DATA_FLOAT32:
+			type = INFERENCE_TENSOR_DATA_TYPE_FLOAT32;
+			break;
+		case MV_INFERENCE_DATA_UINT8:
+			type = INFERENCE_TENSOR_DATA_TYPE_UINT8;
+			break;
+		default:
+			LOGI("unknown data type so FLOAT32 data type will be used in default");
+			break;
+		}
 
-inference_tensor_data_type_e Inference::ConvertToIE(int given_type)
-{
-	inference_tensor_data_type_e type = INFERENCE_TENSOR_DATA_TYPE_FLOAT32;
-
-	switch (given_type) {
-	case MV_INFERENCE_DATA_FLOAT32:
-		type = INFERENCE_TENSOR_DATA_TYPE_FLOAT32;
-		break;
-	case MV_INFERENCE_DATA_UINT8:
-		type = INFERENCE_TENSOR_DATA_TYPE_UINT8;
-		break;
-	default:
-		LOGI("unknown data type so FLOAT32 data type will be used in default");
-		break;
+		return type;
 	}
 
-	return type;
-}
+	int Inference::Preprocess(cv::Mat cvImg, cv::Mat cvDst, int data_type)
+	{
+		mSourceSize = cvImg.size();
+		int width = mInputSize.width;
+		int height = mInputSize.height;
+
+		cv::Mat sample;
+		if (cvImg.channels() == 3 && mCh == 1)
+			cv::cvtColor(cvImg, sample, cv::COLOR_BGR2GRAY);
+		else
+			sample = cvImg;
+
+		// size
+		cv::Mat sampleResized;
+		if (sample.size() != cv::Size(width, height))
+			cv::resize(sample, sampleResized, cv::Size(width, height));
+		else
+			sampleResized = sample;
+
+		// type
+		cv::Mat sampleFloat;
+		if (mCh == 3)
+			sampleResized.convertTo(sampleFloat, CV_32FC3);
+		else
+			sampleResized.convertTo(sampleFloat, CV_32FC1);
+
+		// normalize
+		cv::Mat sampleNormalized;
+		cv::Mat meanMat;
+		if (mCh == 3)
+			meanMat = cv::Mat(sampleFloat.size(), CV_32FC3,
+							  cv::Scalar((float) mMean, (float) mMean,
+							  (float) mMean));
+		else
+			meanMat = cv::Mat(sampleFloat.size(), CV_32FC1,
+							  cv::Scalar((float) mMean));
+
+		cv::subtract(sampleFloat, meanMat, sampleNormalized);
+
+		sampleNormalized /= static_cast<float>(mDeviation);
+
+		sampleNormalized.convertTo(cvDst, data_type);
+
+		return MEDIA_VISION_ERROR_NONE;
+	}
 
-int Inference::Preprocess(cv::Mat cvImg, cv::Mat cvDst, int data_type)
-{
-    mSourceSize = cvImg.size();
-    int width = mInputSize.width;
-    int height = mInputSize.height;
-
-    cv::Mat sample;
-    if (cvImg.channels() == 3 && mCh == 1)
-        cv::cvtColor(cvImg, sample, cv::COLOR_BGR2GRAY);
-    else
-        sample = cvImg;
-
-    // size
-    cv::Mat sampleResized;
-    if (sample.size() != cv::Size(width, height))
-        cv::resize(sample, sampleResized, cv::Size(width, height));
-    else
-        sampleResized = sample;
-
-    // type
-    cv::Mat sampleFloat;
-    if (mCh == 3)
-        sampleResized.convertTo(sampleFloat, CV_32FC3);
-    else
-        sampleResized.convertTo(sampleFloat, CV_32FC1);
-
-    // normalize
-    cv::Mat sampleNormalized;
-    cv::Mat meanMat;
-    if (mCh == 3)
-        meanMat = cv::Mat(sampleFloat.size(), CV_32FC3, cv::Scalar((float)mMean, (float)mMean, (float)mMean));
-    else
-        meanMat = cv::Mat(sampleFloat.size(), CV_32FC1, cv::Scalar((float)mMean));
-
-    cv::subtract(sampleFloat, meanMat, sampleNormalized);
-
-    sampleNormalized /= static_cast<float>(mDeviation);
-
-    sampleNormalized.convertTo(cvDst, data_type);
-
-    return MEDIA_VISION_ERROR_NONE;
-}
-
-int Inference::SetUserFile(std::string filename)
-{
-    std::ifstream fp(filename.c_str());
-    if (!fp.is_open()) {
-        return MEDIA_VISION_ERROR_INVALID_PATH;
-    }
-
-    std::string userListName;
-    while (!fp.eof()) {
-        std::getline(fp, userListName);
-        if (userListName.length())
-			mUserListName.push_back(userListName);
-    }
-
-    fp.close();
-
-    return MEDIA_VISION_ERROR_NONE;
-}
-
-void Inference::ConfigureModelFiles(const std::string modelConfigFilePath,
-		    const std::string modelWeightFilePath,
-		    const std::string modelUserFilePath)
-{
-	LOGI("ENTER");
+	int Inference::SetUserFile(std::string filename)
+	{
+		std::ifstream fp(filename.c_str());
+		if (!fp.is_open()) {
+			return MEDIA_VISION_ERROR_INVALID_PATH;
+		}
 
-	mConfig.mConfigFilePath = modelConfigFilePath;
-	mConfig.mWeightFilePath = modelWeightFilePath;
-	mConfig.mUserFilePath = modelUserFilePath;
+		std::string userListName;
+		while (!fp.eof()) {
+			std::getline(fp, userListName);
+			if (userListName.length())
+				mUserListName.push_back(userListName);
+		}
 
-	LOGI("LEAVE");
-}
+		fp.close();
 
-void Inference::ConfigureTensorInfo(int width,
-            int height,
-            int dim,
-            int ch,
-			double stdValue,
-			double meanValue)
-{
-	LOGI("ENTER");
-
-	mConfig.mTensorInfo = {width, height, dim, ch};
-	mConfig.mStdValue = stdValue;
-	mConfig.mMeanValue = meanValue;
-
-	LOGI("LEAVE");
-}
-
-void Inference::ConfigureInputInfo(int width,
-            int height,
-            int dim,
-            int ch,
-            double stdValue,
-            double meanValue,
-            int dataType,
-            const std::vector<std::string> names)
-{
-	LOGI("ENTER");
-
-	mConfig.mTensorInfo = {width, height, dim, ch};
-	mConfig.mStdValue = stdValue;
-	mConfig.mMeanValue = meanValue;
-	mConfig.mDataType = static_cast<mv_inference_data_type_e>(dataType);
-	mConfig.mInputLayerNames = names;
-
-	inference_engine_layer_property property;
-	// In case of that a inference plugin deosn't support to get properties,
-	// the tensor info given by a user will be used.
-	// If the plugin supports that, the given info will be ignored.
-	inference_engine_tensor_info tensor_info;
-
-	tensor_info.data_type = ConvertToIE(dataType);
-
-	// In case of OpenCV, only supports NCHW
-	tensor_info.shape_type = INFERENCE_TENSOR_SHAPE_NCHW;
-	// modify to handle multiple tensor infos
-	tensor_info.shape.push_back(mConfig.mTensorInfo.dim);
-	tensor_info.shape.push_back(mConfig.mTensorInfo.ch);
-	tensor_info.shape.push_back(mConfig.mTensorInfo.height);
-	tensor_info.shape.push_back(mConfig.mTensorInfo.width);
-
-	tensor_info.size = 1;
-	for (std::vector<size_t>::iterator iter = tensor_info.shape.begin();
-		iter != tensor_info.shape.end(); ++iter) {
-			tensor_info.size *= (*iter);
+		return MEDIA_VISION_ERROR_NONE;
 	}
 
-	property.layer_names = mConfig.mInputLayerNames;
-	property.tensor_infos.push_back(tensor_info);
+	void Inference::ConfigureModelFiles(const std::string modelConfigFilePath,
+										const std::string modelWeightFilePath,
+										const std::string modelUserFilePath)
+	{
+		LOGI("ENTER");
+
+		mConfig.mConfigFilePath = modelConfigFilePath;
+		mConfig.mWeightFilePath = modelWeightFilePath;
+		mConfig.mUserFilePath = modelUserFilePath;
 
-	int ret = mBackend->SetInputLayerProperty(property);
-	if (ret != INFERENCE_ENGINE_ERROR_NONE) {
-		LOGE("Fail to set input layer property");
+		LOGI("LEAVE");
 	}
 
-	LOGI("LEAVE");
-}
+	void Inference::ConfigureTensorInfo(int width, int height, int dim, int ch,
+										double stdValue, double meanValue)
+	{
+		LOGI("ENTER");
 
-void Inference::ConfigureOutputInfo(const std::vector<std::string> names)
-{
-	LOGI("ENTER");
+		mConfig.mTensorInfo = { width, height, dim, ch };
+		mConfig.mStdValue = stdValue;
+		mConfig.mMeanValue = meanValue;
 
-	mConfig.mOutputLayerNames = names;
+		LOGI("LEAVE");
+	}
 
-	inference_engine_layer_property property;
+	void Inference::ConfigureInputInfo(int width, int height, int dim, int ch,
+									   double stdValue, double meanValue,
+									   int dataType,
+									   const std::vector<std::string> names)
+	{
+		LOGI("ENTER");
+
+		mConfig.mTensorInfo = { width, height, dim, ch };
+		mConfig.mStdValue = stdValue;
+		mConfig.mMeanValue = meanValue;
+		mConfig.mDataType = static_cast<mv_inference_data_type_e>(dataType);
+		mConfig.mInputLayerNames = names;
+
+		inference_engine_layer_property property;
+		// In case of that a inference plugin deosn't support to get properties,
+		// the tensor info given by a user will be used.
+		// If the plugin supports that, the given info will be ignored.
+		inference_engine_tensor_info tensor_info;
+
+		tensor_info.data_type = ConvertToIE(dataType);
+
+		// In case of OpenCV, only supports NCHW
+		tensor_info.shape_type = INFERENCE_TENSOR_SHAPE_NCHW;
+		// modify to handle multiple tensor infos
+		tensor_info.shape.push_back(mConfig.mTensorInfo.dim);
+		tensor_info.shape.push_back(mConfig.mTensorInfo.ch);
+		tensor_info.shape.push_back(mConfig.mTensorInfo.height);
+		tensor_info.shape.push_back(mConfig.mTensorInfo.width);
+
+		tensor_info.size = 1;
+		for (std::vector<size_t>::iterator iter = tensor_info.shape.begin();
+			 iter != tensor_info.shape.end(); ++iter) {
+			tensor_info.size *= (*iter);
+		}
 
-	property.layer_names = names;
-	int ret = mBackend->SetOutputLayerProperty(property);
-	if (ret != INFERENCE_ENGINE_ERROR_NONE) {
-		LOGE("Fail to set output layer property");
-	}
+		property.layer_names = mConfig.mInputLayerNames;
+		property.tensor_infos.push_back(tensor_info);
 
-	LOGI("LEAVE");
-}
+		int ret = mBackend->SetInputLayerProperty(property);
+		if (ret != INFERENCE_ENGINE_ERROR_NONE) {
+			LOGE("Fail to set input layer property");
+		}
 
-int Inference::ConfigureBackendType(const mv_inference_backend_type_e backendType)
-{
-	std::pair<std::string, bool> backend = mSupportedInferenceBackend[backendType];
-	if (backend.second == false) {
-		LOGE("%s type is not supported", (backend.first).c_str());
-		return MEDIA_VISION_ERROR_NOT_SUPPORTED_FORMAT;
+		LOGI("LEAVE");
 	}
 
-	LOGI("backend engine : %d", backendType);
+	void Inference::ConfigureOutputInfo(const std::vector<std::string> names)
+	{
+		LOGI("ENTER");
 
-	mConfig.mBackedType = backendType;
+		mConfig.mOutputLayerNames = names;
 
-	return MEDIA_VISION_ERROR_NONE;
-}
+		inference_engine_layer_property property;
 
-int Inference::ConfigureTargetTypes(const int targetType)
-{
-	// Check if given target types are valid or not.
-	if (MV_INFERENCE_TARGET_NONE >= targetType || MV_INFERENCE_TARGET_MAX <= targetType) {
-		LOGE("Invalid target device.");
-		return MEDIA_VISION_ERROR_INVALID_PARAMETER;
-	}
+		property.layer_names = names;
+		int ret = mBackend->SetOutputLayerProperty(property);
+		if (ret != INFERENCE_ENGINE_ERROR_NONE) {
+			LOGE("Fail to set output layer property");
+		}
 
-	LOGI("Before convering target types : %d", targetType);
-
-	unsigned int new_type = MV_INFERENCE_TARGET_DEVICE_NONE;
-
-	// Convert old type to new one.
-	switch (targetType) {
-	case MV_INFERENCE_TARGET_CPU:
-		new_type = MV_INFERENCE_TARGET_DEVICE_CPU;
-		break;
-	case MV_INFERENCE_TARGET_GPU:
-		new_type = MV_INFERENCE_TARGET_DEVICE_GPU;
-		break;
-	case MV_INFERENCE_TARGET_CUSTOM:
-		new_type = MV_INFERENCE_TARGET_DEVICE_CUSTOM;
-		break;
+		LOGI("LEAVE");
 	}
 
-	LOGI("After convering target types : %d", new_type);
+	int Inference::ConfigureBackendType(
+			const mv_inference_backend_type_e backendType)
+	{
+		std::pair<std::string, bool> backend =
+				mSupportedInferenceBackend[backendType];
+		if (backend.second == false) {
+			LOGE("%s type is not supported", (backend.first).c_str());
+			return MEDIA_VISION_ERROR_NOT_SUPPORTED_FORMAT;
+		}
 
-	mConfig.mTargetTypes = new_type;
+		LOGI("backend engine : %d", backendType);
 
-	return MEDIA_VISION_ERROR_NONE;
-}
+		mConfig.mBackedType = backendType;
 
-int Inference::ConfigureTargetDevices(const int targetDevices)
-{
-	// Check if given target types are valid or not.
-	if (MV_INFERENCE_TARGET_DEVICE_NONE >= targetDevices || MV_INFERENCE_TARGET_DEVICE_MAX <= targetDevices) {
-		LOGE("Invalid target device.");
-		return MEDIA_VISION_ERROR_INVALID_PARAMETER;
+		return MEDIA_VISION_ERROR_NONE;
 	}
 
-	LOGI("target devices : %d", targetDevices);
+	int Inference::ConfigureTargetTypes(const int targetType)
+	{
+		// Check if given target types are valid or not.
+		if (MV_INFERENCE_TARGET_NONE >= targetType ||
+			MV_INFERENCE_TARGET_MAX <= targetType) {
+			LOGE("Invalid target device.");
+			return MEDIA_VISION_ERROR_INVALID_PARAMETER;
+		}
 
-	mConfig.mTargetTypes = targetDevices;
+		LOGI("Before convering target types : %d", targetType);
+
+		unsigned int new_type = MV_INFERENCE_TARGET_DEVICE_NONE;
+
+		// Convert old type to new one.
+		switch (targetType) {
+		case MV_INFERENCE_TARGET_CPU:
+			new_type = MV_INFERENCE_TARGET_DEVICE_CPU;
+			break;
+		case MV_INFERENCE_TARGET_GPU:
+			new_type = MV_INFERENCE_TARGET_DEVICE_GPU;
+			break;
+		case MV_INFERENCE_TARGET_CUSTOM:
+			new_type = MV_INFERENCE_TARGET_DEVICE_CUSTOM;
+			break;
+		}
 
-	return MEDIA_VISION_ERROR_NONE;
-}
+		LOGI("After convering target types : %d", new_type);
 
-void Inference::ConfigureOutput(const int maxOutputNumbers)
-{
-	mConfig.mMaxOutputNumbers =  std::max(std::min(maxOutputNumbers, MV_INFERENCE_OUTPUT_NUMBERS_MAX),
-									MV_INFERENCE_OUTPUT_NUMBERS_MIN);
-}
+		mConfig.mTargetTypes = new_type;
 
-void Inference::ConfigureThreshold(const double threshold)
-{
-	mConfig.mConfidenceThresHold = std::max(std::min(threshold, MV_INFERENCE_CONFIDENCE_THRESHOLD_MAX),
-									 MV_INFERENCE_CONFIDENCE_THRESHOLD_MIN);
-}
+		return MEDIA_VISION_ERROR_NONE;
+	}
 
-void Inference::CleanupTensorBuffers(void)
-{
-	LOGI("ENTER");
+	int Inference::ConfigureTargetDevices(const int targetDevices)
+	{
+		// Check if given target types are valid or not.
+		if (MV_INFERENCE_TARGET_DEVICE_NONE >= targetDevices ||
+			MV_INFERENCE_TARGET_DEVICE_MAX <= targetDevices) {
+			LOGE("Invalid target device.");
+			return MEDIA_VISION_ERROR_INVALID_PARAMETER;
+		}
 
-	if (!mInputTensorBuffers.empty()) {
-		std::vector<inference_engine_tensor_buffer>::iterator iter;
-		for (iter = mInputTensorBuffers.begin(); iter != mInputTensorBuffers.end(); iter++) {
-			inference_engine_tensor_buffer tensor_buffer = *iter;
+		LOGI("target devices : %d", targetDevices);
 
-			// If tensor buffer owner is a backend then skip to release the tensor buffer.
-			// This tensor buffer will be released by the backend.
-			if (tensor_buffer.owner_is_backend) {
-				continue;
-			}
+		mConfig.mTargetTypes = targetDevices;
 
-			if (tensor_buffer.data_type == INFERENCE_TENSOR_DATA_TYPE_FLOAT32)
-				delete[] static_cast<float *>(tensor_buffer.buffer);
-			else
-				delete[] static_cast<unsigned char *>(tensor_buffer.buffer);
-		}
+		return MEDIA_VISION_ERROR_NONE;
+	}
 
-		LOGI("input tensor buffers(%zu) have been released.", mInputTensorBuffers.size());
-		std::vector<inference_engine_tensor_buffer>().swap(mInputTensorBuffers);
+	void Inference::ConfigureOutput(const int maxOutputNumbers)
+	{
+		mConfig.mMaxOutputNumbers = std::max(
+				std::min(maxOutputNumbers, MV_INFERENCE_OUTPUT_NUMBERS_MAX),
+				MV_INFERENCE_OUTPUT_NUMBERS_MIN);
 	}
 
-	if (!mOutputTensorBuffers.empty()) {
-		std::vector<inference_engine_tensor_buffer>::iterator iter;
-		for (iter = mOutputTensorBuffers.begin(); iter != mOutputTensorBuffers.end(); iter++) {
-			inference_engine_tensor_buffer tensor_buffer = *iter;
+	void Inference::ConfigureThreshold(const double threshold)
+	{
+		mConfig.mConfidenceThresHold = std::max(
+				std::min(threshold, MV_INFERENCE_CONFIDENCE_THRESHOLD_MAX),
+				MV_INFERENCE_CONFIDENCE_THRESHOLD_MIN);
+	}
 
-			// If tensor buffer owner is a backend then skip to release the tensor buffer.
-			// This tensor buffer will be released by the backend.
-			if (tensor_buffer.owner_is_backend) {
-				continue;
+	void Inference::CleanupTensorBuffers(void)
+	{
+		LOGI("ENTER");
+
+		if (!mInputTensorBuffers.empty()) {
+			std::vector<inference_engine_tensor_buffer>::iterator iter;
+			for (iter = mInputTensorBuffers.begin();
+				 iter != mInputTensorBuffers.end(); iter++) {
+				inference_engine_tensor_buffer tensor_buffer = *iter;
+
+				// If tensor buffer owner is a backend then skip to release the tensor buffer.
+				// This tensor buffer will be released by the backend.
+				if (tensor_buffer.owner_is_backend) {
+					continue;
+				}
+
+				if (tensor_buffer.data_type ==
+					INFERENCE_TENSOR_DATA_TYPE_FLOAT32)
+					delete[] static_cast<float *>(tensor_buffer.buffer);
+				else
+					delete[] static_cast<unsigned char *>(tensor_buffer.buffer);
 			}
 
-			if (tensor_buffer.data_type == INFERENCE_TENSOR_DATA_TYPE_FLOAT32)
-				delete[] static_cast<float *>(tensor_buffer.buffer);
-			else
-				delete[] static_cast<unsigned char *>(tensor_buffer.buffer);
+			LOGI("input tensor buffers(%zu) have been released.",
+				 mInputTensorBuffers.size());
+			std::vector<inference_engine_tensor_buffer>().swap(
+					mInputTensorBuffers);
 		}
 
-		LOGI("output tensor buffers(%zu) have been released.", mOutputTensorBuffers.size());
-		std::vector<inference_engine_tensor_buffer>().swap(mOutputTensorBuffers);
-	}
+		if (!mOutputTensorBuffers.empty()) {
+			std::vector<inference_engine_tensor_buffer>::iterator iter;
+			for (iter = mOutputTensorBuffers.begin();
+				 iter != mOutputTensorBuffers.end(); iter++) {
+				inference_engine_tensor_buffer tensor_buffer = *iter;
+
+				// If tensor buffer owner is a backend then skip to release the tensor buffer.
+				// This tensor buffer will be released by the backend.
+				if (tensor_buffer.owner_is_backend) {
+					continue;
+				}
+
+				if (tensor_buffer.data_type ==
+					INFERENCE_TENSOR_DATA_TYPE_FLOAT32)
+					delete[] static_cast<float *>(tensor_buffer.buffer);
+				else
+					delete[] static_cast<unsigned char *>(tensor_buffer.buffer);
+			}
 
-	LOGI("LEAVE");
-}
+			LOGI("output tensor buffers(%zu) have been released.",
+				 mOutputTensorBuffers.size());
+			std::vector<inference_engine_tensor_buffer>().swap(
+					mOutputTensorBuffers);
+		}
 
-int Inference::PrepareTenosrBuffers(void)
-{
-	// If there are input and output tensor buffers allocated before then release the buffers.
-	// They will be allocated again according to a new model file to be loaded.
-	CleanupTensorBuffers();
-
-	// IF model file is loaded again then the model type could be different so
-	// clean up input and output layer properties so that they can be updated again
-	// after reloading the model file.
-	if (!mInputLayerProperty.tensor_infos.empty()) {
-		mInputLayerProperty.tensor_infos.clear();
-		std::vector<inference_engine_tensor_info>().swap(mInputLayerProperty.tensor_infos);
-	}
-	if (!mOutputLayerProperty.tensor_infos.empty()) {
-		mOutputLayerProperty.tensor_infos.clear();
-		std::vector<inference_engine_tensor_info>().swap(mOutputLayerProperty.tensor_infos);
+		LOGI("LEAVE");
 	}
 
-	// Get input tensor buffers from a backend engine if the backend engine allocated.
-	int ret = mBackend->GetInputTensorBuffers(mInputTensorBuffers);
-	if (ret != INFERENCE_ENGINE_ERROR_NONE) {
-		LOGE("Fail to get input tensor buffers from backend engine.");
-		return ConvertEngineErrorToVisionError(ret);
-	}
+	int Inference::PrepareTenosrBuffers(void)
+	{
+		// If there are input and output tensor buffers allocated before then release the buffers.
+		// They will be allocated again according to a new model file to be loaded.
+		CleanupTensorBuffers();
+
+		// IF model file is loaded again then the model type could be different so
+		// clean up input and output layer properties so that they can be updated again
+		// after reloading the model file.
+		if (!mInputLayerProperty.tensor_infos.empty()) {
+			mInputLayerProperty.tensor_infos.clear();
+			std::vector<inference_engine_tensor_info>().swap(
+					mInputLayerProperty.tensor_infos);
+		}
+		if (!mOutputLayerProperty.tensor_infos.empty()) {
+			mOutputLayerProperty.tensor_infos.clear();
+			std::vector<inference_engine_tensor_info>().swap(
+					mOutputLayerProperty.tensor_infos);
+		}
 
-	ret = mBackend->GetInputLayerProperty(mInputLayerProperty);
-	if (ret != INFERENCE_ENGINE_ERROR_NONE) {
-		LOGE("Fail to get input layer property from backend engine.");
-		return ConvertEngineErrorToVisionError(ret);
-	}
+		// Get input tensor buffers from a backend engine if the backend engine allocated.
+		int ret = mBackend->GetInputTensorBuffers(mInputTensorBuffers);
+		if (ret != INFERENCE_ENGINE_ERROR_NONE) {
+			LOGE("Fail to get input tensor buffers from backend engine.");
+			return ConvertEngineErrorToVisionError(ret);
+		}
 
-	// If the backend engine isn't able to allocate input tensor buffers internally,
-	// then allocate the buffers at here.
-	if (mInputTensorBuffers.empty()) {
-		for (int i = 0; i < mInputLayerProperty.tensor_infos.size(); ++i) {
-			inference_engine_tensor_info tensor_info = mInputLayerProperty.tensor_infos[i];
-			inference_engine_tensor_buffer tensor_buffer;
-			if (tensor_info.data_type == INFERENCE_TENSOR_DATA_TYPE_FLOAT32) {
-				tensor_buffer.buffer = new float[tensor_info.size];
-				tensor_buffer.size = tensor_info.size * 4;
-			} else if (tensor_info.data_type == INFERENCE_TENSOR_DATA_TYPE_UINT8) {
-				tensor_buffer.buffer = new unsigned char[tensor_info.size];
-				tensor_buffer.size = tensor_info.size;
-			} else if (tensor_info.data_type == INFERENCE_TENSOR_DATA_TYPE_FLOAT16) {
-				tensor_buffer.buffer = new short[tensor_info.size];
-				tensor_buffer.size = tensor_info.size;
-			} else {
-				LOGE("Invalid input tensor data type.");
-				return MEDIA_VISION_ERROR_INVALID_PARAMETER;
-			}
+		ret = mBackend->GetInputLayerProperty(mInputLayerProperty);
+		if (ret != INFERENCE_ENGINE_ERROR_NONE) {
+			LOGE("Fail to get input layer property from backend engine.");
+			return ConvertEngineErrorToVisionError(ret);
+		}
 
-			if (tensor_buffer.buffer == NULL) {
-				LOGE("Fail to allocate input tensor buffer.");
-				return MEDIA_VISION_ERROR_OUT_OF_MEMORY;
+		// If the backend engine isn't able to allocate input tensor buffers internally,
+		// then allocate the buffers at here.
+		if (mInputTensorBuffers.empty()) {
+			for (int i = 0; i < mInputLayerProperty.tensor_infos.size(); ++i) {
+				inference_engine_tensor_info tensor_info =
+						mInputLayerProperty.tensor_infos[i];
+				inference_engine_tensor_buffer tensor_buffer;
+				if (tensor_info.data_type ==
+					INFERENCE_TENSOR_DATA_TYPE_FLOAT32) {
+					tensor_buffer.buffer = new float[tensor_info.size];
+					tensor_buffer.size = tensor_info.size * 4;
+				} else if (tensor_info.data_type ==
+						   INFERENCE_TENSOR_DATA_TYPE_UINT8) {
+					tensor_buffer.buffer = new unsigned char[tensor_info.size];
+					tensor_buffer.size = tensor_info.size;
+				} else if (tensor_info.data_type ==
+						   INFERENCE_TENSOR_DATA_TYPE_FLOAT16) {
+					tensor_buffer.buffer = new short[tensor_info.size];
+					tensor_buffer.size = tensor_info.size;
+				} else {
+					LOGE("Invalid input tensor data type.");
+					return MEDIA_VISION_ERROR_INVALID_PARAMETER;
+				}
+
+				if (tensor_buffer.buffer == NULL) {
+					LOGE("Fail to allocate input tensor buffer.");
+					return MEDIA_VISION_ERROR_OUT_OF_MEMORY;
+				}
+
+				LOGI("Allocated input tensor buffer(size = %zu, data type = %d)",
+					 tensor_info.size, tensor_info.data_type);
+				tensor_buffer.owner_is_backend = 0;
+				tensor_buffer.data_type = tensor_info.data_type;
+				mInputTensorBuffers.push_back(tensor_buffer);
 			}
-
-			LOGI("Allocated input tensor buffer(size = %zu, data type = %d)", tensor_info.size, tensor_info.data_type);
-			tensor_buffer.owner_is_backend = 0;
-			tensor_buffer.data_type = tensor_info.data_type;
-			mInputTensorBuffers.push_back(tensor_buffer);
 		}
-	}
 
-	LOGI("Input tensor buffer count is %zu", mInputTensorBuffers.size());
+		LOGI("Input tensor buffer count is %zu", mInputTensorBuffers.size());
 
-	// Get output tensor buffers from a backend engine if the backend engine allocated.
-	ret = mBackend->GetOutputTensorBuffers(mOutputTensorBuffers);
-	if (ret != INFERENCE_ENGINE_ERROR_NONE) {
-		LOGE("Fail to get output tensor buffers from backend engine.");
-		return ConvertEngineErrorToVisionError(ret);
-	}
-
-	ret = mBackend->GetOutputLayerProperty(mOutputLayerProperty);
-	if (ret != INFERENCE_ENGINE_ERROR_NONE) {
-		LOGE("Fail to get output layer property from backend engine.");
-		return ConvertEngineErrorToVisionError(ret);
-	}
+		// Get output tensor buffers from a backend engine if the backend engine allocated.
+		ret = mBackend->GetOutputTensorBuffers(mOutputTensorBuffers);
+		if (ret != INFERENCE_ENGINE_ERROR_NONE) {
+			LOGE("Fail to get output tensor buffers from backend engine.");
+			return ConvertEngineErrorToVisionError(ret);
+		}
 
-	// If the backend engine isn't able to allocate output tensor buffers internally,
-	// then allocate the buffers at here.
-	if (mOutputTensorBuffers.empty()) {
-		for (int i = 0; i < mOutputLayerProperty.tensor_infos.size(); ++i) {
-			inference_engine_tensor_info tensor_info = mOutputLayerProperty.tensor_infos[i];
-			inference_engine_tensor_buffer tensor_buffer;
-			if (tensor_info.data_type == INFERENCE_TENSOR_DATA_TYPE_FLOAT32) {
-				tensor_buffer.buffer = new float[tensor_info.size];
-				tensor_buffer.size = tensor_info.size * 4;
-			} else if (tensor_info.data_type == INFERENCE_TENSOR_DATA_TYPE_UINT8) {
-				tensor_buffer.buffer = new char[tensor_info.size];
-				tensor_buffer.size = tensor_info.size;
-			} else if (tensor_info.data_type == INFERENCE_TENSOR_DATA_TYPE_FLOAT16) {
-				tensor_buffer.buffer = new short[tensor_info.size];
-				tensor_buffer.size = tensor_info.size;
-			} else {
-				LOGE("Invalid output tensor data type.");
-				CleanupTensorBuffers();
-				return MEDIA_VISION_ERROR_INVALID_PARAMETER;
-			}
+		ret = mBackend->GetOutputLayerProperty(mOutputLayerProperty);
+		if (ret != INFERENCE_ENGINE_ERROR_NONE) {
+			LOGE("Fail to get output layer property from backend engine.");
+			return ConvertEngineErrorToVisionError(ret);
+		}
 
-			if (tensor_buffer.buffer == NULL) {
-				LOGE("Fail to allocate output tensor buffer.");
-				CleanupTensorBuffers();
-				return MEDIA_VISION_ERROR_OUT_OF_MEMORY;
+		// If the backend engine isn't able to allocate output tensor buffers internally,
+		// then allocate the buffers at here.
+		if (mOutputTensorBuffers.empty()) {
+			for (int i = 0; i < mOutputLayerProperty.tensor_infos.size(); ++i) {
+				inference_engine_tensor_info tensor_info =
+						mOutputLayerProperty.tensor_infos[i];
+				inference_engine_tensor_buffer tensor_buffer;
+				if (tensor_info.data_type ==
+					INFERENCE_TENSOR_DATA_TYPE_FLOAT32) {
+					tensor_buffer.buffer = new float[tensor_info.size];
+					tensor_buffer.size = tensor_info.size * 4;
+				} else if (tensor_info.data_type ==
+						   INFERENCE_TENSOR_DATA_TYPE_UINT8) {
+					tensor_buffer.buffer = new char[tensor_info.size];
+					tensor_buffer.size = tensor_info.size;
+				} else if (tensor_info.data_type ==
+						   INFERENCE_TENSOR_DATA_TYPE_FLOAT16) {
+					tensor_buffer.buffer = new short[tensor_info.size];
+					tensor_buffer.size = tensor_info.size;
+				} else {
+					LOGE("Invalid output tensor data type.");
+					CleanupTensorBuffers();
+					return MEDIA_VISION_ERROR_INVALID_PARAMETER;
+				}
+
+				if (tensor_buffer.buffer == NULL) {
+					LOGE("Fail to allocate output tensor buffer.");
+					CleanupTensorBuffers();
+					return MEDIA_VISION_ERROR_OUT_OF_MEMORY;
+				}
+
+				LOGI("Allocated output tensor buffer(size = %zu, data type = %d)",
+					 tensor_info.size, tensor_info.data_type);
+
+				tensor_buffer.owner_is_backend = 0;
+				tensor_buffer.data_type = tensor_info.data_type;
+				mOutputTensorBuffers.push_back(tensor_buffer);
 			}
+		}
 
-			LOGI("Allocated output tensor buffer(size = %zu, data type = %d)", tensor_info.size, tensor_info.data_type);
+		LOGI("Output tensor buffer count is %zu", mOutputTensorBuffers.size());
 
-			tensor_buffer.owner_is_backend = 0;
-			tensor_buffer.data_type = tensor_info.data_type;
-			mOutputTensorBuffers.push_back(tensor_buffer);
-		}
+		return MEDIA_VISION_ERROR_NONE;
 	}
 
-	LOGI("Output tensor buffer count is %zu", mOutputTensorBuffers.size());
+	int Inference::FillOutputResult(tensor_t &outputData)
+	{
+		for (int i = 0; i < mOutputLayerProperty.tensor_infos.size(); ++i) {
+			inference_engine_tensor_info tensor_info =
+					mOutputLayerProperty.tensor_infos[i];
 
-	return MEDIA_VISION_ERROR_NONE;
-}
+			std::vector<int> tmpDimInfo;
+			for (int i = 0; i < static_cast<int>(tensor_info.shape.size());
+				 i++) {
+				tmpDimInfo.push_back(tensor_info.shape[i]);
+			}
 
-int Inference::FillOutputResult(tensor_t &outputData)
-{
-	for (int i = 0; i < mOutputLayerProperty.tensor_infos.size(); ++i) {
-		inference_engine_tensor_info tensor_info = mOutputLayerProperty.tensor_infos[i];
+			outputData.dimInfo.push_back(tmpDimInfo);
 
-		std::vector<int> tmpDimInfo;
-		for (int i = 0; i < static_cast<int>(tensor_info.shape.size()); i++) {
-			tmpDimInfo.push_back(tensor_info.shape[i]);
-		}
+			// Normalize output tensor data converting it to float type in case of quantized model.
+			if (tensor_info.data_type == INFERENCE_TENSOR_DATA_TYPE_UINT8) {
+				float *new_buf = new float[tensor_info.size];
+				if (new_buf == NULL) {
+					LOGE("Fail to allocate a new output tensor buffer.");
+					return MEDIA_VISION_ERROR_OUT_OF_MEMORY;
+				}
 
-		outputData.dimInfo.push_back(tmpDimInfo);
+				unsigned char *ori_buf = static_cast<unsigned char *>(
+						mOutputTensorBuffers[i].buffer);
 
-		// Normalize output tensor data converting it to float type in case of quantized model.
-		if (tensor_info.data_type == INFERENCE_TENSOR_DATA_TYPE_UINT8) {
-			float *new_buf = new float[tensor_info.size];
-			if (new_buf == NULL) {
-				LOGE("Fail to allocate a new output tensor buffer.");
-				return MEDIA_VISION_ERROR_OUT_OF_MEMORY;
-			}
+				for (int j = 0; j < tensor_info.size; j++) {
+					new_buf[j] = static_cast<float>(ori_buf[j]) / 255.0f;
+				}
 
-			unsigned char *ori_buf = static_cast<unsigned char *>(mOutputTensorBuffers[i].buffer);
+				// replace original buffer with new one, and release origin one.
+				mOutputTensorBuffers[i].buffer = new_buf;
 
-			for (int j = 0; j < tensor_info.size; j++) {
-				new_buf[j] = static_cast<float>(ori_buf[j]) / 255.0f;
+				if (!mOutputTensorBuffers[i].owner_is_backend)
+					delete[] ori_buf;
 			}
 
-			// replace original buffer with new one, and release origin one.
-			mOutputTensorBuffers[i].buffer = new_buf;
+			if (tensor_info.data_type == INFERENCE_TENSOR_DATA_TYPE_FLOAT16) {
+				float *new_buf = new float[tensor_info.size];
+				if (new_buf == NULL) {
+					LOGE("Fail to allocate a new output tensor buffer.");
+					return MEDIA_VISION_ERROR_OUT_OF_MEMORY;
+				}
 
-			if (!mOutputTensorBuffers[i].owner_is_backend)
-				delete[] ori_buf;
-		}
+				short *ori_buf =
+						static_cast<short *>(mOutputTensorBuffers[i].buffer);
 
-		if (tensor_info.data_type == INFERENCE_TENSOR_DATA_TYPE_FLOAT16) {
-			float *new_buf = new float[tensor_info.size];
-			if (new_buf == NULL) {
-				LOGE("Fail to allocate a new output tensor buffer.");
-				return MEDIA_VISION_ERROR_OUT_OF_MEMORY;
-			}
+				for (int j = 0; j < tensor_info.size; j++) {
+					new_buf[j] = static_cast<float>(ori_buf[j]);
+				}
 
-			short *ori_buf = static_cast<short *>(mOutputTensorBuffers[i].buffer);
+				// replace original buffer with new one, and release origin one.
+				mOutputTensorBuffers[i].buffer = new_buf;
 
-			for (int j = 0; j < tensor_info.size; j++) {
-				new_buf[j] = static_cast<float>(ori_buf[j]);
+				if (!mOutputTensorBuffers[i].owner_is_backend)
+					delete[] ori_buf;
 			}
 
-			// replace original buffer with new one, and release origin one.
-			mOutputTensorBuffers[i].buffer = new_buf;
-
-			if (!mOutputTensorBuffers[i].owner_is_backend)
-				delete[] ori_buf;
+			outputData.data.push_back(
+					static_cast<void *>(mOutputTensorBuffers[i].buffer));
 		}
 
-		outputData.data.push_back(static_cast<void *>(mOutputTensorBuffers[i].buffer));
+		return MEDIA_VISION_ERROR_NONE;
 	}
 
-	return MEDIA_VISION_ERROR_NONE;
-}
+	int Inference::Bind(void)
+	{
+		LOGI("ENTER");
 
-int Inference::Bind(void)
-{
-	LOGI("ENTER");
+		if (mConfig.mBackedType <= MV_INFERENCE_BACKEND_NONE ||
+			mConfig.mBackedType >= MV_INFERENCE_BACKEND_MAX) {
+			LOGE("NOT SUPPORTED BACKEND %d", mConfig.mBackedType);
+			return MEDIA_VISION_ERROR_INVALID_OPERATION;
+		}
 
-	if (mConfig.mBackedType <= MV_INFERENCE_BACKEND_NONE ||
-		mConfig.mBackedType >= MV_INFERENCE_BACKEND_MAX) {
-		LOGE("NOT SUPPORTED BACKEND %d", mConfig.mBackedType);
-		return MEDIA_VISION_ERROR_INVALID_OPERATION;
-	}
+		auto iter = mSupportedInferenceBackend.find(mConfig.mBackedType);
+		std::string backendName = (iter->second).first;
+		LOGI("backend string name: %s", backendName.c_str());
+
+		inference_engine_config config = {
+			.backend_name = backendName,
+			.backend_type = mConfig.mBackedType,
+			// As a default, Target device is CPU. If user defined desired device type in json file
+			// then the device type will be set by Load callback.
+			.target_devices = mConfig.mTargetTypes,
+		};
+
+		// Create a backend class object.
+		try {
+			mBackend = new InferenceEngineCommon();
+		} catch (const std::bad_alloc &ex) {
+			LOGE("Fail to create backend : %s", ex.what());
+			return MEDIA_VISION_ERROR_OUT_OF_MEMORY;
+		}
 
-	auto iter = mSupportedInferenceBackend.find(mConfig.mBackedType);
-	std::string backendName = (iter->second).first;
-	LOGI("backend string name: %s", backendName.c_str());
-
-	inference_engine_config config = {
-		.backend_name = backendName,
-		.backend_type = mConfig.mBackedType,
-		// As a default, Target device is CPU. If user defined desired device type in json file
-		// then the device type will be set by Load callback.
-		.target_devices = mConfig.mTargetTypes,
-	};
-
-	// Create a backend class object.
-	try {
-		mBackend = new InferenceEngineCommon();
-	} catch (const std::bad_alloc &ex) {
-		LOGE("Fail to create backend : %s", ex.what());
-		return MEDIA_VISION_ERROR_OUT_OF_MEMORY;
-	}
+		// Bind a backend library.
+		int ret = mBackend->BindBackend(&config);
+		if (ret != INFERENCE_ENGINE_ERROR_NONE) {
+			LOGE("Fail to bind backend library.(%d)", mConfig.mBackedType);
+			return MEDIA_VISION_ERROR_INVALID_OPERATION;
+		}
 
-	// Bind a backend library.
-	int ret = mBackend->BindBackend(&config);
-	if (ret != INFERENCE_ENGINE_ERROR_NONE) {
-		LOGE("Fail to bind backend library.(%d)", mConfig.mBackedType);
-		return MEDIA_VISION_ERROR_INVALID_OPERATION;
-	}
+		// Get capacity information from a backend.
+		ret = mBackend->GetBackendCapacity(&mBackendCapacity);
+		if (ret != MEDIA_VISION_ERROR_NONE) {
+			LOGE("Fail to get backend capacity.");
+			return ret;
+		}
 
-	// Get capacity information from a backend.
-	ret = mBackend->GetBackendCapacity(&mBackendCapacity);
-	if (ret != MEDIA_VISION_ERROR_NONE) {
-		LOGE("Fail to get backend capacity.");
-		return ret;
+		LOGI("LEAVE");
+
+		return MEDIA_VISION_ERROR_NONE;
 	}
 
-	LOGI("LEAVE");
+	int Inference::Prepare(void)
+	{
+		LOGI("ENTER");
 
-	return MEDIA_VISION_ERROR_NONE;
-}
+		mCh = mConfig.mTensorInfo.ch;
+		mDim = mConfig.mTensorInfo.dim;
+		mInputSize =
+				cv::Size(mConfig.mTensorInfo.width, mConfig.mTensorInfo.height);
+		LOGI("InputSize is %d x %d\n", mInputSize.width, mInputSize.height);
 
-int Inference::Prepare(void)
-{
-	LOGI("ENTER");
+		mDeviation = mConfig.mStdValue;
+		mMean = mConfig.mMeanValue;
+		LOGI("mean %.4f, deviation %.4f", mMean, mDeviation);
 
-	mCh = mConfig.mTensorInfo.ch;
-	mDim = mConfig.mTensorInfo.dim;
-	mInputSize = cv::Size(mConfig.mTensorInfo.width, mConfig.mTensorInfo.height);
-	LOGI("InputSize is %d x %d\n", mInputSize.width, mInputSize.height);
+		mOutputNumbers = mConfig.mMaxOutputNumbers;
+		LOGI("outputNumber %d", mOutputNumbers);
 
-	mDeviation = mConfig.mStdValue;
-	mMean = mConfig.mMeanValue;
-	LOGI("mean %.4f, deviation %.4f", mMean, mDeviation);
+		mThreshold = mConfig.mConfidenceThresHold;
+		LOGI("threshold %.4f", mThreshold);
 
-	mOutputNumbers = mConfig.mMaxOutputNumbers;
-	LOGI("outputNumber %d", mOutputNumbers);
+		// Check if backend supports a given target device/devices or not.
+		if (mConfig.mTargetTypes & MV_INFERENCE_TARGET_DEVICE_CPU) {
+			if (!(mBackendCapacity.supported_accel_devices &
+				  INFERENCE_TARGET_CPU)) {
+				LOGE("Backend doesn't support CPU device as an accelerator.");
+				return MEDIA_VISION_ERROR_INVALID_PARAMETER;
+			}
+		}
 
-	mThreshold = mConfig.mConfidenceThresHold;
-	LOGI("threshold %.4f", mThreshold);
+		if (mConfig.mTargetTypes & MV_INFERENCE_TARGET_DEVICE_GPU) {
+			if (!(mBackendCapacity.supported_accel_devices &
+				  INFERENCE_TARGET_GPU)) {
+				LOGE("Backend doesn't support CPU device as an accelerator.");
+				return MEDIA_VISION_ERROR_INVALID_PARAMETER;
+			}
+		}
 
-	// Check if backend supports a given target device/devices or not.
-	if (mConfig.mTargetTypes & MV_INFERENCE_TARGET_DEVICE_CPU) {
-		if (!(mBackendCapacity.supported_accel_devices & INFERENCE_TARGET_CPU)) {
-			LOGE("Backend doesn't support CPU device as an accelerator.");
-			return MEDIA_VISION_ERROR_INVALID_PARAMETER;
+		if (mConfig.mTargetTypes & MV_INFERENCE_TARGET_DEVICE_CUSTOM) {
+			if (!(mBackendCapacity.supported_accel_devices &
+				  INFERENCE_TARGET_CUSTOM)) {
+				LOGE("Backend doesn't support CPU device as an accelerator.");
+				return MEDIA_VISION_ERROR_INVALID_PARAMETER;
+			}
 		}
+
+		mBackend->SetTargetDevices(ConvertTargetTypes(mConfig.mTargetTypes));
+
+		LOGI("LEAVE");
+
+		return MEDIA_VISION_ERROR_NONE;
 	}
 
-	if (mConfig.mTargetTypes & MV_INFERENCE_TARGET_DEVICE_GPU) {
-		if (!(mBackendCapacity.supported_accel_devices & INFERENCE_TARGET_GPU)) {
-			LOGE("Backend doesn't support CPU device as an accelerator.");
+	int Inference::Load(void)
+	{
+		LOGI("ENTER");
+
+		std::string label_file = mConfig.mUserFilePath;
+		size_t userFileLength = label_file.length();
+		if (userFileLength > 0 && access(label_file.c_str(), F_OK)) {
+			LOGE("Label file path in [%s] ", label_file.c_str());
 			return MEDIA_VISION_ERROR_INVALID_PARAMETER;
 		}
-	}
 
-	if (mConfig.mTargetTypes & MV_INFERENCE_TARGET_DEVICE_CUSTOM) {
-		if (!(mBackendCapacity.supported_accel_devices & INFERENCE_TARGET_CUSTOM)) {
-			LOGE("Backend doesn't support CPU device as an accelerator.");
+		int ret = (userFileLength > 0) ? SetUserFile(label_file) :
+										 MEDIA_VISION_ERROR_NONE;
+		if (ret != MEDIA_VISION_ERROR_NONE) {
+			LOGE("Fail to load label file.");
+			return ret;
+		}
+
+		// Check if model file is valid or not.
+		std::string ext_str = mConfig.mWeightFilePath.substr(
+				mConfig.mWeightFilePath.find_last_of(".") + 1);
+		std::map<std::string, int>::iterator key = mModelFormats.find(ext_str);
+		if (key == mModelFormats.end()) {
+			LOGE("Invalid model file format.(ext = %s)", ext_str.c_str());
 			return MEDIA_VISION_ERROR_INVALID_PARAMETER;
 		}
-	}
 
-	mBackend->SetTargetDevices(ConvertTargetTypes(mConfig.mTargetTypes));
+		LOGI("%s model file has been detected.", ext_str.c_str());
+
+		std::vector<std::string> models;
+
+		inference_model_format_e model_format =
+				static_cast<inference_model_format_e>(key->second);
+
+		// Push model file information to models vector properly according to detected model format.
+		switch (model_format) {
+		case INFERENCE_MODEL_CAFFE:
+		case INFERENCE_MODEL_TF:
+		case INFERENCE_MODEL_DARKNET:
+		case INFERENCE_MODEL_DLDT:
+		case INFERENCE_MODEL_ONNX:
+		case INFERENCE_MODEL_VIVANTE:
+			models.push_back(mConfig.mWeightFilePath);
+			models.push_back(mConfig.mConfigFilePath);
+			break;
+		case INFERENCE_MODEL_TFLITE:
+		case INFERENCE_MODEL_TORCH:
+			models.push_back(mConfig.mWeightFilePath);
+			break;
+		default:
+			break;
+		}
 
-	LOGI("LEAVE");
+		// Request model loading to backend engine.
+		ret = mBackend->Load(models, model_format);
+		if (ret != INFERENCE_ENGINE_ERROR_NONE) {
+			delete mBackend;
+			LOGE("Fail to load model");
+			mCanRun = false;
+			std::vector<std::string>().swap(models);
+			return ConvertEngineErrorToVisionError(ret);
+		}
 
-	return MEDIA_VISION_ERROR_NONE;
-}
+		std::vector<std::string>().swap(models);
 
-int Inference::Load(void)
-{
-	LOGI("ENTER");
-
-    std::string label_file = mConfig.mUserFilePath;
-    size_t userFileLength = label_file.length();
-    if (userFileLength > 0 && access(label_file.c_str(), F_OK)) {
-        LOGE("Label file path in [%s] ", label_file.c_str());
-        return MEDIA_VISION_ERROR_INVALID_PARAMETER;
-    }
-
-    int ret = (userFileLength > 0) ? SetUserFile(label_file) : MEDIA_VISION_ERROR_NONE;
-    if (ret != MEDIA_VISION_ERROR_NONE) {
-        LOGE("Fail to load label file.");
-		return ret;
-    }
-
-	// Check if model file is valid or not.
-	std::string ext_str = mConfig.mWeightFilePath.substr(mConfig.mWeightFilePath.find_last_of(".") + 1);
-	std::map<std::string, int>::iterator key = mModelFormats.find(ext_str);
-	if (key == mModelFormats.end()) {
-		LOGE("Invalid model file format.(ext = %s)", ext_str.c_str());
-		return MEDIA_VISION_ERROR_INVALID_PARAMETER;
-	}
+		// Prepare input and output tensor buffers.
+		PrepareTenosrBuffers();
 
-	LOGI("%s model file has been detected.", ext_str.c_str());
-
-	std::vector<std::string> models;
-
-	inference_model_format_e model_format = static_cast<inference_model_format_e>(key->second);
-
-	// Push model file information to models vector properly according to detected model format.
-	switch (model_format) {
-	case INFERENCE_MODEL_CAFFE:
-	case INFERENCE_MODEL_TF:
-	case INFERENCE_MODEL_DARKNET:
-	case INFERENCE_MODEL_DLDT:
-	case INFERENCE_MODEL_ONNX:
-	case INFERENCE_MODEL_VIVANTE:
-		models.push_back(mConfig.mWeightFilePath);
-		models.push_back(mConfig.mConfigFilePath);
-		break;
-	case INFERENCE_MODEL_TFLITE:
-	case INFERENCE_MODEL_TORCH:
-		models.push_back(mConfig.mWeightFilePath);
-		break;
-	default:
-		break;
-	}
+		mCanRun = true;
+
+		LOGI("LEAVE");
 
-    // Request model loading to backend engine.
-    ret = mBackend->Load(models, model_format);
-	if (ret != INFERENCE_ENGINE_ERROR_NONE) {
-		delete mBackend;
-		LOGE("Fail to load model");
-		mCanRun = false;
-		std::vector<std::string>().swap(models);
 		return ConvertEngineErrorToVisionError(ret);
 	}
 
-	std::vector<std::string>().swap(models);
+	int Inference::Run(std::vector<mv_source_h> &mvSources,
+					   std::vector<mv_rectangle_s> &rects)
+	{
+		int ret = INFERENCE_ENGINE_ERROR_NONE;
 
-	// Prepare input and output tensor buffers.
-	PrepareTenosrBuffers();
+		if (!mCanRun) {
+			LOGE("Invalid to run inference");
+			return MEDIA_VISION_ERROR_INVALID_OPERATION;
+		}
 
-	mCanRun = true;
+		/* convert mv_source to cv::Mat */
+		cv::Mat cvSource;
+		cv::Rect cvRoi;
+		unsigned int width = 0, height = 0;
+		unsigned int bufferSize = 0;
+		unsigned char *buffer = NULL;
 
-	LOGI("LEAVE");
+		if (mvSources.empty()) {
+			LOGE("mvSources should contain only one cv source.");
+			return MEDIA_VISION_ERROR_INVALID_PARAMETER;
+		}
 
-	return ConvertEngineErrorToVisionError(ret);
-}
+		// We are able to request Only one input data for the inference as of now.
+		if (mvSources.size() > 1) {
+			LOGE("It allows only one mv source for the inference.");
+			return MEDIA_VISION_ERROR_INVALID_PARAMETER;
+		}
 
-int Inference::Run(std::vector<mv_source_h> &mvSources, std::vector<mv_rectangle_s> &rects)
-{
-	int ret = INFERENCE_ENGINE_ERROR_NONE;
+		// TODO. Consider multiple sources.
+		mv_source_h mvSource = mvSources.front();
+		mv_rectangle_s *roi = rects.empty() ? NULL : &(rects.front());
 
-	if (!mCanRun) {
-		LOGE("Invalid to run inference");
-		return MEDIA_VISION_ERROR_INVALID_OPERATION;
-	}
+		mv_colorspace_e colorspace = MEDIA_VISION_COLORSPACE_INVALID;
 
-	/* convert mv_source to cv::Mat */
-	cv::Mat cvSource;
-	cv::Rect cvRoi;
-	unsigned int width = 0, height = 0;
-	unsigned int bufferSize = 0;
-	unsigned char *buffer = NULL;
+		if (mv_source_get_width(mvSource, &width) != MEDIA_VISION_ERROR_NONE ||
+			mv_source_get_height(mvSource, &height) !=
+					MEDIA_VISION_ERROR_NONE ||
+			mv_source_get_colorspace(mvSource, &colorspace) !=
+					MEDIA_VISION_ERROR_NONE ||
+			mv_source_get_buffer(mvSource, &buffer, &bufferSize))
+			return MEDIA_VISION_ERROR_INTERNAL;
 
-	if (mvSources.empty()) {
-		LOGE("mvSources should contain only one cv source.");
-		return MEDIA_VISION_ERROR_INVALID_PARAMETER;
-	}
+		// TODO. Let's support various color spaces.
 
-	// We are able to request Only one input data for the inference as of now.
-	if (mvSources.size() > 1) {
-		LOGE("It allows only one mv source for the inference.");
-		return MEDIA_VISION_ERROR_INVALID_PARAMETER;
-	}
+		if (colorspace != MEDIA_VISION_COLORSPACE_RGB888) {
+			LOGE("Not Supported format!\n");
+			return MEDIA_VISION_ERROR_NOT_SUPPORTED_FORMAT;
+		}
 
-	// TODO. Consider multiple sources.
-	mv_source_h mvSource = mvSources.front();
-	mv_rectangle_s *roi = rects.empty() ? NULL : &(rects.front());
+		if (roi == NULL) {
+			cvSource = cv::Mat(cv::Size(width, height), CV_MAKETYPE(CV_8U, 3),
+							   buffer)
+							   .clone();
+		} else {
+			cvRoi.x = roi->point.x;
+			cvRoi.y = roi->point.y;
+			cvRoi.width = (roi->point.x + roi->width) >= width ?
+								  width - roi->point.x :
+								  roi->width;
+			cvRoi.height = (roi->point.y + roi->height) >= height ?
+								   height - roi->point.y :
+								   roi->height;
+			cvSource = cv::Mat(cv::Size(width, height), CV_MAKETYPE(CV_8U, 3),
+							   buffer)(cvRoi)
+							   .clone();
+		}
 
-	mv_colorspace_e colorspace = MEDIA_VISION_COLORSPACE_INVALID;
+		LOGE("Size: w:%u, h:%u", cvSource.size().width, cvSource.size().height);
 
-	if (mv_source_get_width(mvSource, &width) != MEDIA_VISION_ERROR_NONE ||
-			mv_source_get_height(mvSource, &height) != MEDIA_VISION_ERROR_NONE ||
-			mv_source_get_colorspace(mvSource, &colorspace) != MEDIA_VISION_ERROR_NONE ||
-			mv_source_get_buffer(mvSource, &buffer, &bufferSize))
-		return MEDIA_VISION_ERROR_INTERNAL;
+		if (mCh != 1 && mCh != 3) {
+			LOGE("Channel not supported.");
+			return MEDIA_VISION_ERROR_INVALID_PARAMETER;
+		}
 
-	// TODO. Let's support various color spaces.
+		std::vector<inference_engine_tensor_buffer>::iterator iter;
+		for (iter = mInputTensorBuffers.begin();
+			 iter != mInputTensorBuffers.end(); iter++) {
+			inference_engine_tensor_buffer tensor_buffer = *iter;
 
-	if (colorspace != MEDIA_VISION_COLORSPACE_RGB888) {
-		LOGE("Not Supported format!\n");
-		return MEDIA_VISION_ERROR_NOT_SUPPORTED_FORMAT;
-	}
+			int data_type = ConvertToCv(tensor_buffer.data_type);
 
-	if (roi == NULL) {
-		cvSource = cv::Mat(cv::Size(width, height), CV_MAKETYPE(CV_8U, 3), buffer).clone();
-	} else {
-		cvRoi.x = roi->point.x;
-		cvRoi.y = roi->point.y;
-		cvRoi.width = (roi->point.x + roi->width) >= width ? width - roi->point.x : roi->width;
-		cvRoi.height = (roi->point.y + roi->height) >= height ? height - roi->point.y : roi->height;
-		cvSource = cv::Mat(cv::Size(width, height), CV_MAKETYPE(CV_8U, 3), buffer)(cvRoi).clone();
-	}
+			// Convert color space of input tensor data and then normalize it.
+			ret = Preprocess(cvSource,
+							 cv::Mat(mInputSize.height, mInputSize.width,
+									 data_type, tensor_buffer.buffer),
+							 data_type);
+			if (ret != MEDIA_VISION_ERROR_NONE) {
+				LOGE("Fail to preprocess input tensor data.");
+				return ret;
+			}
+		}
 
-	LOGE("Size: w:%u, h:%u", cvSource.size().width, cvSource.size().height);
+		ret = mBackend->Run(mInputTensorBuffers, mOutputTensorBuffers);
 
-	if (mCh != 1 && mCh != 3) {
-		LOGE("Channel not supported.");
-		return MEDIA_VISION_ERROR_INVALID_PARAMETER;
+		return ConvertEngineErrorToVisionError(ret);
 	}
 
-	std::vector<inference_engine_tensor_buffer>::iterator iter;
-	for (iter = mInputTensorBuffers.begin(); iter != mInputTensorBuffers.end(); iter++) {
-		inference_engine_tensor_buffer tensor_buffer = *iter;
+	std::pair<std::string, bool>
+	Inference::GetSupportedInferenceBackend(int backend)
+	{
+		return mSupportedInferenceBackend[backend];
+	}
 
-		int data_type = ConvertToCv(tensor_buffer.data_type);
+	int Inference::GetClassficationResults(
+			ImageClassificationResults *classificationResults)
+	{
+		tensor_t outputData;
 
-		// Convert color space of input tensor data and then normalize it.
-		ret = Preprocess(cvSource, cv::Mat(mInputSize.height, mInputSize.width, data_type, tensor_buffer.buffer), data_type);
+		// Get inference result and contain it to outputData.
+		int ret = FillOutputResult(outputData);
 		if (ret != MEDIA_VISION_ERROR_NONE) {
-			LOGE("Fail to preprocess input tensor data.");
+			LOGE("Fail to get output result.");
 			return ret;
 		}
-	}
-
-	ret = mBackend->Run(mInputTensorBuffers, mOutputTensorBuffers);
-
-	return ConvertEngineErrorToVisionError(ret);
-}
-
-std::pair<std::string, bool> Inference::GetSupportedInferenceBackend(int backend)
-{
-	return mSupportedInferenceBackend[backend];
-}
-
-int Inference::GetClassficationResults(ImageClassificationResults *classificationResults)
-{
-	tensor_t outputData;
 
-	// Get inference result and contain it to outputData.
-	int ret = FillOutputResult(outputData);
-	if (ret != MEDIA_VISION_ERROR_NONE) {
-		LOGE("Fail to get output result.");
-		return ret;
-	}
+		// Will contain top N results in ascending order.
+		std::vector<std::pair<float, int> > top_results;
+		std::priority_queue<std::pair<float, int>,
+							std::vector<std::pair<float, int> >,
+							std::greater<std::pair<float, int> > >
+				top_result_pq;
+		float value = 0.0f;
 
-	// Will contain top N results in ascending order.
-	std::vector<std::pair<float, int>> top_results;
-	std::priority_queue<std::pair<float, int>,
-		std::vector<std::pair<float, int>>,
-		std::greater<std::pair<float, int>>> top_result_pq;
-	float value = 0.0f;
+		std::vector<std::vector<int> > inferDimInfo(outputData.dimInfo);
+		std::vector<void *> inferResults(outputData.data.begin(),
+										 outputData.data.end());
 
-	std::vector<std::vector<int>> inferDimInfo(outputData.dimInfo);
-	std::vector<void*> inferResults(outputData.data.begin(), outputData.data.end());
+		int count = inferDimInfo[0][1];
+		LOGI("count: %d", count);
 
-	int count = inferDimInfo[0][1];
-	LOGI("count: %d", count);
+		float *prediction = reinterpret_cast<float *>(inferResults[0]);
+		for (int i = 0; i < count; ++i) {
+			value = prediction[i];
 
-	float *prediction = reinterpret_cast<float*>(inferResults[0]);
-	for (int i = 0; i < count; ++i) {
-		value = prediction[i];
+			// Only add it if it beats the threshold and has a chance at being in
+			// the top N.
+			top_result_pq.push(std::pair<float, int>(value, i));
 
-		// Only add it if it beats the threshold and has a chance at being in
-		// the top N.
-		top_result_pq.push(std::pair<float, int>(value, i));
+			// If at capacity, kick the smallest value out.
+			if (top_result_pq.size() > mOutputNumbers) {
+				top_result_pq.pop();
+			}
+		}
 
-		// If at capacity, kick the smallest value out.
-		if (top_result_pq.size() > mOutputNumbers) {
+		// Copy to output vector and reverse into descending order.
+		while (!top_result_pq.empty()) {
+			top_results.push_back(top_result_pq.top());
 			top_result_pq.pop();
 		}
-	}
-
-	// Copy to output vector and reverse into descending order.
-	while (!top_result_pq.empty()) {
-		top_results.push_back(top_result_pq.top());
-		top_result_pq.pop();
-	}
-	std::reverse(top_results.begin(), top_results.end());
-
-	int classIdx = -1;
-	ImageClassificationResults results;
-	results.number_of_classes = 0;
-	for (int idx = 0; idx < top_results.size(); ++idx) {
-		if (top_results[idx].first < mThreshold)
-			continue;
-		LOGI("idx:%d", idx);
-		LOGI("classIdx: %d", top_results[idx].second);
-		LOGI("classProb: %f", top_results[idx].first);
-
-		classIdx = top_results[idx].second;
-		results.indices.push_back(classIdx);
-		results.confidences.push_back(top_results[idx].first);
-		results.names.push_back(mUserListName[classIdx]);
-		results.number_of_classes++;
-	}
-
-	*classificationResults = results;
-	LOGE("Inference: GetClassificationResults: %d\n", results.number_of_classes);
-	return MEDIA_VISION_ERROR_NONE;
-}
-
-int Inference::GetObjectDetectionResults(ObjectDetectionResults *detectionResults)
-{
-	tensor_t outputData;
+		std::reverse(top_results.begin(), top_results.end());
 
-	// Get inference result and contain it to outputData.
-	int ret = FillOutputResult(outputData);
-	if (ret != MEDIA_VISION_ERROR_NONE) {
-		LOGE("Fail to get output result.");
-		return ret;
-	}
+		int classIdx = -1;
+		ImageClassificationResults results;
+		results.number_of_classes = 0;
+		for (int idx = 0; idx < top_results.size(); ++idx) {
+			if (top_results[idx].first < mThreshold)
+				continue;
+			LOGI("idx:%d", idx);
+			LOGI("classIdx: %d", top_results[idx].second);
+			LOGI("classProb: %f", top_results[idx].first);
+
+			classIdx = top_results[idx].second;
+			results.indices.push_back(classIdx);
+			results.confidences.push_back(top_results[idx].first);
+			results.names.push_back(mUserListName[classIdx]);
+			results.number_of_classes++;
+		}
 
-	// In case of object detection,
-	// a model may apply post-process but others may not.
-	// Thus, those cases should be hanlded separately.
-	std::vector<std::vector<int>> inferDimInfo(outputData.dimInfo);
-	LOGI("inferDimInfo size: %zu", outputData.dimInfo.size());
-
-	std::vector<void*> inferResults(outputData.data.begin(), outputData.data.end());
-	LOGI("inferResults size: %zu", inferResults.size());
-
-	float* boxes = nullptr;
-	float* classes = nullptr;
-	float* scores = nullptr;
-	int number_of_detections = 0;
-
-	cv::Mat cvScores, cvClasses, cvBoxes;
-	if (outputData.dimInfo.size() == 1) {
-		// there is no way to know how many objects are detect unless the number of objects aren't
-		// provided. In the case, each backend should provide the number of results manually.
-		// For example, in OpenCV, MobilenetV1-SSD doesn't provide it so the number of objects are
-		// written to the 1st element i.e., outputData.data[0] (the shape is 1x1xNx7 and the 1st of 7
-		// indicats the image id. But it is useless if a batch mode isn't supported.
-		// So, use the 1st of 7.
-
-		number_of_detections = static_cast<int>(*reinterpret_cast<float*>(outputData.data[0]));
-		cv::Mat cvOutputData(number_of_detections, inferDimInfo[0][3], CV_32F, outputData.data[0]);
-
-		// boxes
-		cv::Mat cvLeft = cvOutputData.col(3).clone();
-		cv::Mat cvTop = cvOutputData.col(4).clone();
-		cv::Mat cvRight = cvOutputData.col(5).clone();
-		cv::Mat cvBottom = cvOutputData.col(6).clone();
-
-		cv::Mat cvBoxElems[] = { cvTop, cvLeft, cvBottom, cvRight };
-		cv::hconcat(cvBoxElems, 4, cvBoxes);
-
-		// classes
-		cvClasses = cvOutputData.col(1).clone();
-
-		// scores
-		cvScores = cvOutputData.col(2).clone();
-
-		boxes = cvBoxes.ptr<float>(0);
-		classes = cvClasses.ptr<float>(0);
-		scores = cvScores.ptr<float>(0);
-
-	} else {
-		boxes = reinterpret_cast<float*>(inferResults[0]);
-		classes = reinterpret_cast<float*>(inferResults[1]);
-		scores = reinterpret_cast<float*>(inferResults[2]);
-		number_of_detections = (int)(*reinterpret_cast<float*>(inferResults[3]));
+		*classificationResults = results;
+		LOGE("Inference: GetClassificationResults: %d\n",
+			 results.number_of_classes);
+		return MEDIA_VISION_ERROR_NONE;
 	}
 
+	int Inference::GetObjectDetectionResults(
+			ObjectDetectionResults *detectionResults)
+	{
+		tensor_t outputData;
 
-	LOGI("number_of_detections = %d", number_of_detections);
+		// Get inference result and contain it to outputData.
+		int ret = FillOutputResult(outputData);
+		if (ret != MEDIA_VISION_ERROR_NONE) {
+			LOGE("Fail to get output result.");
+			return ret;
+		}
 
-	int left, top, right, bottom;
-	cv::Rect loc;
+		// In case of object detection,
+		// a model may apply post-process but others may not.
+		// Thus, those cases should be hanlded separately.
+		std::vector<std::vector<int> > inferDimInfo(outputData.dimInfo);
+		LOGI("inferDimInfo size: %zu", outputData.dimInfo.size());
+
+		std::vector<void *> inferResults(outputData.data.begin(),
+										 outputData.data.end());
+		LOGI("inferResults size: %zu", inferResults.size());
+
+		float *boxes = nullptr;
+		float *classes = nullptr;
+		float *scores = nullptr;
+		int number_of_detections = 0;
+
+		cv::Mat cvScores, cvClasses, cvBoxes;
+		if (outputData.dimInfo.size() == 1) {
+			// there is no way to know how many objects are detect unless the number of objects aren't
+			// provided. In the case, each backend should provide the number of results manually.
+			// For example, in OpenCV, MobilenetV1-SSD doesn't provide it so the number of objects are
+			// written to the 1st element i.e., outputData.data[0] (the shape is 1x1xNx7 and the 1st of 7
+			// indicats the image id. But it is useless if a batch mode isn't supported.
+			// So, use the 1st of 7.
+
+			number_of_detections = static_cast<int>(
+					*reinterpret_cast<float *>(outputData.data[0]));
+			cv::Mat cvOutputData(number_of_detections, inferDimInfo[0][3],
+								 CV_32F, outputData.data[0]);
+
+			// boxes
+			cv::Mat cvLeft = cvOutputData.col(3).clone();
+			cv::Mat cvTop = cvOutputData.col(4).clone();
+			cv::Mat cvRight = cvOutputData.col(5).clone();
+			cv::Mat cvBottom = cvOutputData.col(6).clone();
+
+			cv::Mat cvBoxElems[] = { cvTop, cvLeft, cvBottom, cvRight };
+			cv::hconcat(cvBoxElems, 4, cvBoxes);
+
+			// classes
+			cvClasses = cvOutputData.col(1).clone();
+
+			// scores
+			cvScores = cvOutputData.col(2).clone();
+
+			boxes = cvBoxes.ptr<float>(0);
+			classes = cvClasses.ptr<float>(0);
+			scores = cvScores.ptr<float>(0);
+
+		} else {
+			boxes = reinterpret_cast<float *>(inferResults[0]);
+			classes = reinterpret_cast<float *>(inferResults[1]);
+			scores = reinterpret_cast<float *>(inferResults[2]);
+			number_of_detections =
+					(int) (*reinterpret_cast<float *>(inferResults[3]));
+		}
 
-	ObjectDetectionResults results;
-	results.number_of_objects = 0;
-	for (int idx = 0; idx < number_of_detections; ++idx) {
-		if (scores[idx] < mThreshold)
-			continue;
+		LOGI("number_of_detections = %d", number_of_detections);
 
-		left =   static_cast<int>(boxes[idx*4 + 1] * mSourceSize.width);
-		top  =   static_cast<int>(boxes[idx*4 + 0] * mSourceSize.height);
-		right  = static_cast<int>(boxes[idx*4 + 3] * mSourceSize.width);
-		bottom = static_cast<int>(boxes[idx*4 + 2] * mSourceSize.height);
+		int left, top, right, bottom;
+		cv::Rect loc;
 
-		loc.x = left;
-		loc.y = top;
-		loc.width = right -left + 1;
-		loc.height = bottom - top + 1;
+		ObjectDetectionResults results;
+		results.number_of_objects = 0;
+		for (int idx = 0; idx < number_of_detections; ++idx) {
+			if (scores[idx] < mThreshold)
+				continue;
 
-		results.indices.push_back(static_cast<int>(classes[idx]));
-		results.confidences.push_back(scores[idx]);
-		results.names.push_back(mUserListName[static_cast<int>(classes[idx])]);
-		results.locations.push_back(loc);
-		results.number_of_objects++;
+			left = static_cast<int>(boxes[idx * 4 + 1] * mSourceSize.width);
+			top = static_cast<int>(boxes[idx * 4 + 0] * mSourceSize.height);
+			right = static_cast<int>(boxes[idx * 4 + 3] * mSourceSize.width);
+			bottom = static_cast<int>(boxes[idx * 4 + 2] * mSourceSize.height);
+
+			loc.x = left;
+			loc.y = top;
+			loc.width = right - left + 1;
+			loc.height = bottom - top + 1;
+
+			results.indices.push_back(static_cast<int>(classes[idx]));
+			results.confidences.push_back(scores[idx]);
+			results.names.push_back(
+					mUserListName[static_cast<int>(classes[idx])]);
+			results.locations.push_back(loc);
+			results.number_of_objects++;
+
+			LOGI("objectClass: %d", static_cast<int>(classes[idx]));
+			LOGI("confidence:%f", scores[idx]);
+			LOGI("left:%d, top:%d, right:%d, bottom:%d", left, top, right,
+				 bottom);
+		}
 
-		LOGI("objectClass: %d", static_cast<int>(classes[idx]));
-		LOGI("confidence:%f", scores[idx]);
-		LOGI("left:%d, top:%d, right:%d, bottom:%d", left, top, right, bottom);
+		*detectionResults = results;
+		LOGE("Inference: GetObjectDetectionResults: %d\n",
+			 results.number_of_objects);
+		return MEDIA_VISION_ERROR_NONE;
 	}
 
-	*detectionResults = results;
-	LOGE("Inference: GetObjectDetectionResults: %d\n", results.number_of_objects);
-	return MEDIA_VISION_ERROR_NONE;
-}
+	int
+	Inference::GetFaceDetectionResults(FaceDetectionResults *detectionResults)
+	{
+		tensor_t outputData;
 
-int Inference::GetFaceDetectionResults(FaceDetectionResults *detectionResults)
-{
-	tensor_t outputData;
+		// Get inference result and contain it to outputData.
+		int ret = FillOutputResult(outputData);
+		if (ret != MEDIA_VISION_ERROR_NONE) {
+			LOGE("Fail to get output result.");
+			return ret;
+		}
 
-	// Get inference result and contain it to outputData.
-	int ret = FillOutputResult(outputData);
-	if (ret != MEDIA_VISION_ERROR_NONE) {
-		LOGE("Fail to get output result.");
-		return ret;
-	}
+		// In case of object detection,
+		// a model may apply post-process but others may not.
+		// Thus, those cases should be hanlded separately.
+		std::vector<std::vector<int> > inferDimInfo(outputData.dimInfo);
+		LOGI("inferDimInfo size: %zu", outputData.dimInfo.size());
+
+		std::vector<void *> inferResults(outputData.data.begin(),
+										 outputData.data.end());
+		LOGI("inferResults size: %zu", inferResults.size());
+
+		float *boxes = nullptr;
+		float *classes = nullptr;
+		float *scores = nullptr;
+		int number_of_detections = 0;
+
+		cv::Mat cvScores, cvClasses, cvBoxes;
+		if (outputData.dimInfo.size() == 1) {
+			// there is no way to know how many objects are detect unless the number of objects aren't
+			// provided. In the case, each backend should provide the number of results manually.
+			// For example, in OpenCV, MobilenetV1-SSD doesn't provide it so the number of objects are
+			// written to the 1st element i.e., outputData.data[0] (the shape is 1x1xNx7 and the 1st of 7
+			// indicats the image id. But it is useless if a batch mode isn't supported.
+			// So, use the 1st of 7.
+
+			number_of_detections = static_cast<int>(
+					*reinterpret_cast<float *>(outputData.data[0]));
+			cv::Mat cvOutputData(number_of_detections, inferDimInfo[0][3],
+								 CV_32F, outputData.data[0]);
+
+			// boxes
+			cv::Mat cvLeft = cvOutputData.col(3).clone();
+			cv::Mat cvTop = cvOutputData.col(4).clone();
+			cv::Mat cvRight = cvOutputData.col(5).clone();
+			cv::Mat cvBottom = cvOutputData.col(6).clone();
+
+			cv::Mat cvBoxElems[] = { cvTop, cvLeft, cvBottom, cvRight };
+			cv::hconcat(cvBoxElems, 4, cvBoxes);
+
+			// classes
+			cvClasses = cvOutputData.col(1).clone();
+
+			// scores
+			cvScores = cvOutputData.col(2).clone();
+
+			boxes = cvBoxes.ptr<float>(0);
+			classes = cvClasses.ptr<float>(0);
+			scores = cvScores.ptr<float>(0);
+
+		} else {
+			boxes = reinterpret_cast<float *>(inferResults[0]);
+			classes = reinterpret_cast<float *>(inferResults[1]);
+			scores = reinterpret_cast<float *>(inferResults[2]);
+			number_of_detections = static_cast<int>(
+					*reinterpret_cast<float *>(inferResults[3]));
+		}
 
-	// In case of object detection,
-	// a model may apply post-process but others may not.
-	// Thus, those cases should be hanlded separately.
-	std::vector<std::vector<int>> inferDimInfo(outputData.dimInfo);
-	LOGI("inferDimInfo size: %zu", outputData.dimInfo.size());
-
-	std::vector<void*> inferResults(outputData.data.begin(), outputData.data.end());
-	LOGI("inferResults size: %zu", inferResults.size());
-
-	float* boxes = nullptr;
-	float* classes = nullptr;
-	float* scores = nullptr;
-	int number_of_detections = 0;
-
-	cv::Mat cvScores, cvClasses, cvBoxes;
-	if (outputData.dimInfo.size() == 1) {
-		// there is no way to know how many objects are detect unless the number of objects aren't
-		// provided. In the case, each backend should provide the number of results manually.
-		// For example, in OpenCV, MobilenetV1-SSD doesn't provide it so the number of objects are
-		// written to the 1st element i.e., outputData.data[0] (the shape is 1x1xNx7 and the 1st of 7
-		// indicats the image id. But it is useless if a batch mode isn't supported.
-		// So, use the 1st of 7.
-
-		number_of_detections = static_cast<int>(*reinterpret_cast<float*>(outputData.data[0]));
-		cv::Mat cvOutputData(number_of_detections, inferDimInfo[0][3], CV_32F, outputData.data[0]);
-
-		// boxes
-		cv::Mat cvLeft = cvOutputData.col(3).clone();
-		cv::Mat cvTop = cvOutputData.col(4).clone();
-		cv::Mat cvRight = cvOutputData.col(5).clone();
-		cv::Mat cvBottom = cvOutputData.col(6).clone();
-
-		cv::Mat cvBoxElems[] = { cvTop, cvLeft, cvBottom, cvRight };
-		cv::hconcat(cvBoxElems, 4, cvBoxes);
-
-		// classes
-		cvClasses = cvOutputData.col(1).clone();
-
-		// scores
-		cvScores = cvOutputData.col(2).clone();
-
-		boxes = cvBoxes.ptr<float>(0);
-		classes = cvClasses.ptr<float>(0);
-		scores = cvScores.ptr<float>(0);
-
-	} else {
-		boxes = reinterpret_cast<float*>(inferResults[0]);
-		classes = reinterpret_cast<float*>(inferResults[1]);
-		scores = reinterpret_cast<float*>(inferResults[2]);
-		number_of_detections = static_cast<int>(*reinterpret_cast<float*>(inferResults[3]));
-	}
+		int left, top, right, bottom;
+		cv::Rect loc;
+
+		FaceDetectionResults results;
+		results.number_of_faces = 0;
+		for (int idx = 0; idx < number_of_detections; ++idx) {
+			if (scores[idx] < mThreshold)
+				continue;
 
-	int left, top, right, bottom;
-	cv::Rect loc;
-
-	FaceDetectionResults results;
-	results.number_of_faces = 0;
-	for (int idx = 0; idx < number_of_detections; ++idx) {
-		if (scores[idx] < mThreshold)
-			continue;
-
-		left =   static_cast<int>(boxes[idx*4 + 1] * mSourceSize.width);
-		top  =   static_cast<int>(boxes[idx*4 + 0] * mSourceSize.height);
-		right  = static_cast<int>(boxes[idx*4 + 3] * mSourceSize.width);
-		bottom = static_cast<int>(boxes[idx*4 + 2] * mSourceSize.height);
-
-		loc.x = left;
-		loc.y = top;
-		loc.width = right -left + 1;
-		loc.height = bottom - top + 1;
-
-		results.confidences.push_back(scores[idx]);
-		results.locations.push_back(loc);
-		results.number_of_faces++;
-
-		LOGI("confidence:%f", scores[idx]);
-		LOGI("class: %f", classes[idx]);
-		LOGI("left:%f, top:%f, right:%f, bottom:%f", boxes[idx*4 + 1], boxes[idx*4 + 0], boxes[idx*4 + 3], boxes[idx*4 + 2]);
-		LOGI("left:%d, top:%d, right:%d, bottom:%d", left, top, right, bottom);
+			left = static_cast<int>(boxes[idx * 4 + 1] * mSourceSize.width);
+			top = static_cast<int>(boxes[idx * 4 + 0] * mSourceSize.height);
+			right = static_cast<int>(boxes[idx * 4 + 3] * mSourceSize.width);
+			bottom = static_cast<int>(boxes[idx * 4 + 2] * mSourceSize.height);
+
+			loc.x = left;
+			loc.y = top;
+			loc.width = right - left + 1;
+			loc.height = bottom - top + 1;
+
+			results.confidences.push_back(scores[idx]);
+			results.locations.push_back(loc);
+			results.number_of_faces++;
+
+			LOGI("confidence:%f", scores[idx]);
+			LOGI("class: %f", classes[idx]);
+			LOGI("left:%f, top:%f, right:%f, bottom:%f", boxes[idx * 4 + 1],
+				 boxes[idx * 4 + 0], boxes[idx * 4 + 3], boxes[idx * 4 + 2]);
+			LOGI("left:%d, top:%d, right:%d, bottom:%d", left, top, right,
+				 bottom);
+		}
+
+		*detectionResults = results;
+		LOGE("Inference: GetFaceDetectionResults: %d\n",
+			 results.number_of_faces);
+		return MEDIA_VISION_ERROR_NONE;
 	}
 
-	*detectionResults = results;
-	LOGE("Inference: GetFaceDetectionResults: %d\n", results.number_of_faces);
-	return MEDIA_VISION_ERROR_NONE;
-}
+	int Inference::GetFacialLandMarkDetectionResults(
+			FacialLandMarkDetectionResults *detectionResults)
+	{
+		tensor_t outputData;
 
-int Inference::GetFacialLandMarkDetectionResults(FacialLandMarkDetectionResults *detectionResults)
-{
-	tensor_t outputData;
+		// Get inference result and contain it to outputData.
+		int ret = FillOutputResult(outputData);
+		if (ret != MEDIA_VISION_ERROR_NONE) {
+			LOGE("Fail to get output result.");
+			return ret;
+		}
 
-	// Get inference result and contain it to outputData.
-	int ret = FillOutputResult(outputData);
-	if (ret != MEDIA_VISION_ERROR_NONE) {
-		LOGE("Fail to get output result.");
-		return ret;
-	}
+		std::vector<std::vector<int> > inferDimInfo(outputData.dimInfo);
+		std::vector<void *> inferResults(outputData.data.begin(),
+										 outputData.data.end());
 
-	std::vector<std::vector<int>> inferDimInfo(outputData.dimInfo);
-	std::vector<void*> inferResults(outputData.data.begin(), outputData.data.end());
+		long number_of_detections = inferDimInfo[0][1];
+		float *loc = reinterpret_cast<float *>(inferResults[0]);
 
-	long number_of_detections = inferDimInfo[0][1];
-	float* loc = reinterpret_cast<float*>(inferResults[0]);
+		FacialLandMarkDetectionResults results;
+		results.number_of_landmarks = 0;
 
-	FacialLandMarkDetectionResults results;
-	results.number_of_landmarks = 0;
+		cv::Point point(0, 0);
+		results.number_of_landmarks = 0;
+		LOGI("imgW:%d, imgH:%d", mSourceSize.width, mSourceSize.height);
+		for (int idx = 0; idx < number_of_detections; idx += 2) {
+			point.x = static_cast<int>(loc[idx] * mSourceSize.width);
+			point.y = static_cast<int>(loc[idx + 1] * mSourceSize.height);
 
-	cv::Point point(0,0);
-	results.number_of_landmarks = 0;
-	LOGI("imgW:%d, imgH:%d", mSourceSize.width, mSourceSize.height);
-	for (int idx = 0; idx < number_of_detections; idx+=2) {
-		point.x = static_cast<int>(loc[idx] * mSourceSize.width);
-		point.y = static_cast<int>(loc[idx+1] * mSourceSize.height);
+			results.locations.push_back(point);
+			results.number_of_landmarks++;
 
-		results.locations.push_back(point);
-		results.number_of_landmarks++;
+			LOGI("x:%d, y:%d", point.x, point.y);
+		}
 
-		LOGI("x:%d, y:%d", point.x, point.y);
+		*detectionResults = results;
+		LOGE("Inference: FacialLandmarkDetectionResults: %d\n",
+			 results.number_of_landmarks);
+		return MEDIA_VISION_ERROR_NONE;
 	}
 
-	*detectionResults = results;
-	LOGE("Inference: FacialLandmarkDetectionResults: %d\n", results.number_of_landmarks);
-	return MEDIA_VISION_ERROR_NONE;
-}
+	int Inference::GetPoseEstimationDetectionResults(
+			PoseEstimationResults *detectionResults)
+	{
+		tensor_t outputData;
 
-int Inference::GetPoseEstimationDetectionResults(PoseEstimationResults *detectionResults)
-{
-	tensor_t outputData;
+		// Get inference result and contain it to outputData.
+		int ret = FillOutputResult(outputData);
+		if (ret != MEDIA_VISION_ERROR_NONE) {
+			LOGE("Fail to get output result.");
+			return ret;
+		}
 
-	// Get inference result and contain it to outputData.
-	int ret = FillOutputResult(outputData);
-	if (ret != MEDIA_VISION_ERROR_NONE) {
-		LOGE("Fail to get output result.");
-		return ret;
-	}
+		std::vector<std::vector<int> > inferDimInfo(outputData.dimInfo);
+		std::vector<void *> inferResults(outputData.data.begin(),
+										 outputData.data.end());
 
-	std::vector<std::vector<int>> inferDimInfo(outputData.dimInfo);
-	std::vector<void*> inferResults(outputData.data.begin(), outputData.data.end());
+		long number_of_pose = inferDimInfo[0][3];
+		float *tmp = static_cast<float *>(inferResults[0]);
+		cv::Size heatMapSize(inferDimInfo[0][1], inferDimInfo[0][2]);
 
-	long number_of_pose = inferDimInfo[0][3];
-	float * tmp = static_cast<float*>(inferResults[0]);
-	cv::Size heatMapSize(inferDimInfo[0][1], inferDimInfo[0][2]);
+		cv::Point loc;
+		double score;
+		cv::Mat blurredHeatMap;
 
-	cv::Point loc;
-	double score;
-	cv::Mat blurredHeatMap;
+		cv::Mat reShapeTest(cv::Size(inferDimInfo[0][2], inferDimInfo[0][1]),
+							CV_32FC(inferDimInfo[0][3]), (void *) tmp);
 
-	cv::Mat reShapeTest( cv::Size(inferDimInfo[0][2], inferDimInfo[0][1]), CV_32FC(inferDimInfo[0][3]), (void*)tmp);
+		cv::Mat multiChannels[inferDimInfo[0][3]];
+		split(reShapeTest, multiChannels);
 
-	cv::Mat multiChannels[inferDimInfo[0][3]];
-	split(reShapeTest, multiChannels);
+		float ratioX = static_cast<float>(mSourceSize.width) /
+					   static_cast<float>(inferDimInfo[0][2]);
+		float ratioY = static_cast<float>(mSourceSize.height) /
+					   static_cast<float>(inferDimInfo[0][1]);
 
-	float ratioX = static_cast<float>(mSourceSize.width) / static_cast<float>(inferDimInfo[0][2]);
-	float ratioY = static_cast<float>(mSourceSize.height) / static_cast<float>(inferDimInfo[0][1]);
+		PoseEstimationResults results;
+		results.number_of_pose_estimation = 0;
+		for (int poseIdx = 0; poseIdx < number_of_pose; poseIdx++) {
+			cv::Mat heatMap = multiChannels[poseIdx];
 
-	PoseEstimationResults results;
-	results.number_of_pose_estimation = 0;
-	for (int poseIdx = 0; poseIdx < number_of_pose; poseIdx++) {
-		cv::Mat heatMap = multiChannels[poseIdx];
+			cv::GaussianBlur(heatMap, blurredHeatMap, cv::Size(), 5.0, 5.0);
+			cv::minMaxLoc(heatMap, NULL, &score, NULL, &loc);
 
-		cv::GaussianBlur(heatMap, blurredHeatMap, cv::Size(), 5.0, 5.0);
-		cv::minMaxLoc(heatMap, NULL, &score, NULL, &loc);
+			LOGI("PoseIdx[%2d]: x[%2d], y[%2d], score[%.3f]", poseIdx, loc.x,
+				 loc.y, score);
+			LOGI("PoseIdx[%2d]: x[%2d], y[%2d], score[%.3f]", poseIdx,
+				 static_cast<int>(static_cast<float>(loc.x + 1) * ratioX),
+				 static_cast<int>(static_cast<float>(loc.y + 1) * ratioY),
+				 score);
 
-		LOGI("PoseIdx[%2d]: x[%2d], y[%2d], score[%.3f]", poseIdx, loc.x, loc.y, score);
-		LOGI("PoseIdx[%2d]: x[%2d], y[%2d], score[%.3f]", poseIdx, static_cast<int>(static_cast<float>(loc.x+1) * ratioX), static_cast<int>(static_cast<float>(loc.y+1) * ratioY), score);
+			loc.x = static_cast<int>(static_cast<float>(loc.x + 1) * ratioX);
+			loc.y = static_cast<int>(static_cast<float>(loc.y + 1) * ratioY);
+			results.locations.push_back(loc);
+			results.number_of_pose_estimation++;
+		}
 
-		loc.x = static_cast<int>(static_cast<float>(loc.x+1) * ratioX);
-		loc.y = static_cast<int>(static_cast<float>(loc.y+1) * ratioY);
-		results.locations.push_back(loc);
-		results.number_of_pose_estimation++;
+		*detectionResults = results;
+		LOGE("Inference: PoseEstimationResults: %d\n",
+			 results.number_of_pose_estimation);
+		return MEDIA_VISION_ERROR_NONE;
 	}
 
-	*detectionResults = results;
-	LOGE("Inference: PoseEstimationResults: %d\n", results.number_of_pose_estimation);
-	return MEDIA_VISION_ERROR_NONE;
-}
-
 } /* Inference */
 } /* MediaVision */
diff --git a/mv_inference/inference/src/InferenceIni.cpp b/mv_inference/inference/src/InferenceIni.cpp
index 68b32b8a..a258cd8d 100644
--- a/mv_inference/inference/src/InferenceIni.cpp
+++ b/mv_inference/inference/src/InferenceIni.cpp
@@ -21,79 +21,84 @@
 #include "mv_private.h"
 #include "InferenceIni.h"
 
-namespace mediavision {
-namespace inference {
-
-const std::string INFERENCE_INI_FILENAME = "/inference/inference_engine.ini";
-
-static inline std::string& rtrim(std::string& s, const char* t = " \t\n\r\f\v")
-{
-	s.erase(s.find_last_not_of(t) + 1);
-	return s;
-}
-
-static inline std::string& ltrim(std::string& s, const char* t = " \t\n\r\f\v")
-{
-	s.erase(s.find_first_not_of(t) + 1);
-	return s;
-}
-
-static inline std::string& trim(std::string& s, const char* t = " \t\n\r\f\v")
+namespace mediavision
 {
-	return ltrim(rtrim(s,t), t);
-}
-
-InferenceInI::InferenceInI() :
-	mIniDefaultPath(SYSCONFDIR),
-	mDefaultBackend("OPENCV"),
-	mDelimeter(",")
+namespace inference
 {
-	mIniDefaultPath += INFERENCE_INI_FILENAME;
-}
-
-InferenceInI::~InferenceInI()
-{
-
-}
-
-int InferenceInI::LoadInI()
-{
-	LOGE("ENTER");
-	dictionary *dict = iniparser_load(mIniDefaultPath.c_str());
-	if (dict == NULL) {
-		LOGE("Fail to load ini");
-		return  -1;
+	const std::string INFERENCE_INI_FILENAME =
+			"/inference/inference_engine.ini";
+
+	static inline std::string &rtrim(std::string &s,
+									 const char *t = " \t\n\r\f\v")
+	{
+		s.erase(s.find_last_not_of(t) + 1);
+		return s;
 	}
 
-	std::string list = std::string(iniparser_getstring(dict, "inference backend:supported backend types", (char*)mDefaultBackend.c_str()));
-
-	size_t pos = 0;
-	while((pos = list.find(mDelimeter)) != std::string::npos) {
-		std::string tmp = list.substr(0, pos);
-		mSupportedInferenceBackend.push_back(atoi(tmp.c_str()));
+	static inline std::string &ltrim(std::string &s,
+									 const char *t = " \t\n\r\f\v")
+	{
+		s.erase(s.find_first_not_of(t) + 1);
+		return s;
+	}
 
-		list.erase(0, pos + mDelimeter.length());
+	static inline std::string &trim(std::string &s,
+									const char *t = " \t\n\r\f\v")
+	{
+		return ltrim(rtrim(s, t), t);
 	}
-	mSupportedInferenceBackend.push_back(atoi(list.c_str()));
 
-	if(dict) {
-		iniparser_freedict(dict);
-		dict = NULL;
+	InferenceInI::InferenceInI()
+			: mIniDefaultPath(SYSCONFDIR)
+			, mDefaultBackend("OPENCV")
+			, mDelimeter(",")
+	{
+		mIniDefaultPath += INFERENCE_INI_FILENAME;
 	}
 
-	LOGE("LEAVE");
-	return 0;
-}
+	InferenceInI::~InferenceInI()
+	{}
+
+	int InferenceInI::LoadInI()
+	{
+		LOGE("ENTER");
+		dictionary *dict = iniparser_load(mIniDefaultPath.c_str());
+		if (dict == NULL) {
+			LOGE("Fail to load ini");
+			return -1;
+		}
+
+		std::string list = std::string(iniparser_getstring(
+				dict, "inference backend:supported backend types",
+				(char *) mDefaultBackend.c_str()));
+
+		size_t pos = 0;
+		while ((pos = list.find(mDelimeter)) != std::string::npos) {
+			std::string tmp = list.substr(0, pos);
+			mSupportedInferenceBackend.push_back(atoi(tmp.c_str()));
+
+			list.erase(0, pos + mDelimeter.length());
+		}
+		mSupportedInferenceBackend.push_back(atoi(list.c_str()));
+
+		if (dict) {
+			iniparser_freedict(dict);
+			dict = NULL;
+		}
+
+		LOGE("LEAVE");
+		return 0;
+	}
 
-void InferenceInI::UnLoadInI()
-{
-	;
-}
+	void InferenceInI::UnLoadInI()
+	{
+		;
+	}
 
-std::vector<int> InferenceInI::GetSupportedInferenceEngines()
-{
-	return mSupportedInferenceBackend;
-}
+	std::vector<int> InferenceInI::GetSupportedInferenceEngines()
+	{
+		return mSupportedInferenceBackend;
+	}
 
 } /* Inference */
 } /* MediaVision */
diff --git a/mv_inference/inference/src/mv_inference.c b/mv_inference/inference/src/mv_inference.c
index 56ca9993..50e0f130 100755..100644
--- a/mv_inference/inference/src/mv_inference.c
+++ b/mv_inference/inference/src/mv_inference.c
@@ -36,7 +36,8 @@
 
 int mv_inference_create(mv_inference_h *infer)
 {
-	MEDIA_VISION_SUPPORT_CHECK(__mv_inference_check_system_info_feature_supported());
+	MEDIA_VISION_SUPPORT_CHECK(
+			__mv_inference_check_system_info_feature_supported());
 	MEDIA_VISION_NULL_ARG_CHECK(infer);
 
 	MEDIA_VISION_FUNCTION_ENTER();
@@ -59,7 +60,8 @@ int mv_inference_create(mv_inference_h *infer)
 
 int mv_inference_destroy(mv_inference_h infer)
 {
-	MEDIA_VISION_SUPPORT_CHECK(__mv_inference_check_system_info_feature_supported());
+	MEDIA_VISION_SUPPORT_CHECK(
+			__mv_inference_check_system_info_feature_supported());
 	MEDIA_VISION_INSTANCE_CHECK(infer);
 
 	MEDIA_VISION_FUNCTION_ENTER();
@@ -80,11 +82,13 @@ int mv_inference_destroy(mv_inference_h infer)
 	return ret;
 }
 
-int mv_inference_configure(mv_inference_h infer, mv_engine_config_h engine_config)
+int mv_inference_configure(mv_inference_h infer,
+						   mv_engine_config_h engine_config)
 {
-	MEDIA_VISION_SUPPORT_CHECK(__mv_inference_check_system_info_feature_supported());
+	MEDIA_VISION_SUPPORT_CHECK(
+			__mv_inference_check_system_info_feature_supported());
 	MEDIA_VISION_INSTANCE_CHECK(infer);
-    MEDIA_VISION_INSTANCE_CHECK(engine_config);
+	MEDIA_VISION_INSTANCE_CHECK(engine_config);
 
 	MEDIA_VISION_FUNCTION_ENTER();
 
@@ -96,11 +100,11 @@ int mv_inference_configure(mv_inference_h infer, mv_engine_config_h engine_confi
 
 #else
 
-    ret = mv_inference_configure_engine_open(infer, engine_config);
-    if (ret != MEDIA_VISION_ERROR_NONE){
-        LOGE("Fail to configure engine and target");
-        return ret;
-    }
+	ret = mv_inference_configure_engine_open(infer, engine_config);
+	if (ret != MEDIA_VISION_ERROR_NONE) {
+		LOGE("Fail to configure engine and target");
+		return ret;
+	}
 
 #endif /* MEDIA_VISION_INFERENCE_LICENSE_PORT */
 
@@ -108,17 +112,17 @@ int mv_inference_configure(mv_inference_h infer, mv_engine_config_h engine_confi
 	return ret;
 }
 
-
 int mv_inference_prepare(mv_inference_h infer)
 {
-	MEDIA_VISION_SUPPORT_CHECK(__mv_inference_check_system_info_feature_supported());
+	MEDIA_VISION_SUPPORT_CHECK(
+			__mv_inference_check_system_info_feature_supported());
 	MEDIA_VISION_INSTANCE_CHECK(infer);
 
 	MEDIA_VISION_FUNCTION_ENTER();
 
 	int ret = MEDIA_VISION_ERROR_NONE;
 
-    mv_engine_config_h engine_config = mv_inference_get_engine_config(infer);
+	mv_engine_config_h engine_config = mv_inference_get_engine_config(infer);
 
 #ifdef MEDIA_VISION_INFERENCE_LICENSE_PORT
 
@@ -127,21 +131,21 @@ int mv_inference_prepare(mv_inference_h infer)
 #else
 
 	ret = mv_inference_configure_model_open(infer, engine_config);
-    if (ret != MEDIA_VISION_ERROR_NONE){
-        LOGE("Fail to configure model");
-        return ret;
-    }
+	if (ret != MEDIA_VISION_ERROR_NONE) {
+		LOGE("Fail to configure model");
+		return ret;
+	}
 
 	// input tensor, input layer
 	ret = mv_inference_configure_input_info_open(infer, engine_config);
-    if (ret != MEDIA_VISION_ERROR_NONE){
-        LOGE("Fail to configure input info");
-        return ret;
-    }
+	if (ret != MEDIA_VISION_ERROR_NONE) {
+		LOGE("Fail to configure input info");
+		return ret;
+	}
 
 	// output layer
 	ret = mv_inference_configure_output_info_open(infer, engine_config);
-		if (ret != MEDIA_VISION_ERROR_NONE) {
+	if (ret != MEDIA_VISION_ERROR_NONE) {
 		LOGE("Fail to configure output info");
 		return ret;
 	}
@@ -162,11 +166,11 @@ int mv_inference_prepare(mv_inference_h infer)
 }
 
 int mv_inference_foreach_supported_engine(
-	mv_inference_h infer,
-	mv_inference_supported_engine_cb callback,
-	void *user_data)
+		mv_inference_h infer, mv_inference_supported_engine_cb callback,
+		void *user_data)
 {
-	MEDIA_VISION_SUPPORT_CHECK(__mv_inference_check_system_info_feature_supported());
+	MEDIA_VISION_SUPPORT_CHECK(
+			__mv_inference_check_system_info_feature_supported());
 	MEDIA_VISION_INSTANCE_CHECK(infer);
 	MEDIA_VISION_NULL_ARG_CHECK(callback);
 	MEDIA_VISION_FUNCTION_ENTER();
@@ -179,7 +183,8 @@ int mv_inference_foreach_supported_engine(
 
 #else
 
-	ret = mv_inference_foreach_supported_engine_open(infer, callback, user_data);
+	ret = mv_inference_foreach_supported_engine_open(infer, callback,
+													 user_data);
 
 #endif
 
@@ -188,15 +193,13 @@ int mv_inference_foreach_supported_engine(
 	return ret;
 }
 
-
-int mv_inference_image_classify(
-	mv_source_h source,
-	mv_inference_h infer,
-	mv_rectangle_s *roi,
-	mv_inference_image_classified_cb classified_cb,
-	void *user_data)
+int mv_inference_image_classify(mv_source_h source, mv_inference_h infer,
+								mv_rectangle_s *roi,
+								mv_inference_image_classified_cb classified_cb,
+								void *user_data)
 {
-	MEDIA_VISION_SUPPORT_CHECK(__mv_inference_image_check_system_info_feature_supported());
+	MEDIA_VISION_SUPPORT_CHECK(
+			__mv_inference_image_check_system_info_feature_supported());
 	MEDIA_VISION_INSTANCE_CHECK(source);
 	MEDIA_VISION_INSTANCE_CHECK(infer);
 	MEDIA_VISION_NULL_ARG_CHECK(classified_cb);
@@ -213,7 +216,8 @@ int mv_inference_image_classify(
 
 #else
 
-	ret = mv_inference_image_classify_open(source, infer, roi, classified_cb, user_data);
+	ret = mv_inference_image_classify_open(source, infer, roi, classified_cb,
+										   user_data);
 
 #endif /* MEDIA_VISION_INFERENCE_LICENSE_PORT */
 
@@ -222,13 +226,12 @@ int mv_inference_image_classify(
 	return ret;
 }
 
-int mv_inference_object_detect(
-	mv_source_h source,
-	mv_inference_h infer,
-	mv_inference_object_detected_cb detected_cb,
-	void *user_data)
+int mv_inference_object_detect(mv_source_h source, mv_inference_h infer,
+							   mv_inference_object_detected_cb detected_cb,
+							   void *user_data)
 {
-	MEDIA_VISION_SUPPORT_CHECK(__mv_inference_image_check_system_info_feature_supported());
+	MEDIA_VISION_SUPPORT_CHECK(
+			__mv_inference_image_check_system_info_feature_supported());
 	MEDIA_VISION_INSTANCE_CHECK(source);
 	MEDIA_VISION_INSTANCE_CHECK(infer);
 	MEDIA_VISION_NULL_ARG_CHECK(detected_cb);
@@ -245,7 +248,8 @@ int mv_inference_object_detect(
 
 #else
 
-	ret = mv_inference_object_detect_open(source, infer, detected_cb, user_data);
+	ret = mv_inference_object_detect_open(source, infer, detected_cb,
+										  user_data);
 
 #endif /* MEDIA_VISION_INFERENCE_LICENSE_PORT */
 
@@ -254,13 +258,12 @@ int mv_inference_object_detect(
 	return ret;
 }
 
-int mv_inference_face_detect(
-	mv_source_h source,
-	mv_inference_h infer,
-	mv_inference_face_detected_cb detected_cb,
-	void *user_data)
+int mv_inference_face_detect(mv_source_h source, mv_inference_h infer,
+							 mv_inference_face_detected_cb detected_cb,
+							 void *user_data)
 {
-	MEDIA_VISION_SUPPORT_CHECK(__mv_inference_face_check_system_info_feature_supported());
+	MEDIA_VISION_SUPPORT_CHECK(
+			__mv_inference_face_check_system_info_feature_supported());
 	MEDIA_VISION_INSTANCE_CHECK(source);
 	MEDIA_VISION_INSTANCE_CHECK(infer);
 	MEDIA_VISION_NULL_ARG_CHECK(detected_cb);
@@ -285,13 +288,11 @@ int mv_inference_face_detect(
 }
 
 int mv_inference_facial_landmark_detect(
-	mv_source_h source,
-	mv_inference_h infer,
-	mv_rectangle_s *roi,
-	mv_inference_facial_landmark_detected_cb detected_cb,
-	void *user_data)
+		mv_source_h source, mv_inference_h infer, mv_rectangle_s *roi,
+		mv_inference_facial_landmark_detected_cb detected_cb, void *user_data)
 {
-	MEDIA_VISION_SUPPORT_CHECK(__mv_inference_face_check_system_info_feature_supported());
+	MEDIA_VISION_SUPPORT_CHECK(
+			__mv_inference_face_check_system_info_feature_supported());
 	MEDIA_VISION_INSTANCE_CHECK(source);
 	MEDIA_VISION_INSTANCE_CHECK(infer);
 	MEDIA_VISION_NULL_ARG_CHECK(detected_cb);
@@ -306,7 +307,8 @@ int mv_inference_facial_landmark_detect(
 	*/
 #else
 
-	ret = mv_inference_facial_landmark_detect_open(source, infer, roi, detected_cb, user_data);
+	ret = mv_inference_facial_landmark_detect_open(source, infer, roi,
+												   detected_cb, user_data);
 
 	MEDIA_VISION_FUNCTION_LEAVE();
 
@@ -316,13 +318,11 @@ int mv_inference_facial_landmark_detect(
 }
 
 int mv_inference_pose_estimation_detect(
-	mv_source_h source,
-	mv_inference_h infer,
-	mv_rectangle_s *roi,
-	mv_inference_pose_estimation_detected_cb detected_cb,
-	void *user_data)
+		mv_source_h source, mv_inference_h infer, mv_rectangle_s *roi,
+		mv_inference_pose_estimation_detected_cb detected_cb, void *user_data)
 {
-	MEDIA_VISION_SUPPORT_CHECK(__mv_inference_face_check_system_info_feature_supported());
+	MEDIA_VISION_SUPPORT_CHECK(
+			__mv_inference_face_check_system_info_feature_supported());
 	MEDIA_VISION_INSTANCE_CHECK(source);
 	MEDIA_VISION_INSTANCE_CHECK(infer);
 	MEDIA_VISION_NULL_ARG_CHECK(detected_cb);
@@ -337,7 +337,8 @@ int mv_inference_pose_estimation_detect(
 	*/
 #else
 
-	ret = mv_inference_pose_estimation_detect_open(source, infer, roi, detected_cb, user_data);
+	ret = mv_inference_pose_estimation_detect_open(source, infer, roi,
+												   detected_cb, user_data);
 
 	MEDIA_VISION_FUNCTION_LEAVE();
 
diff --git a/mv_inference/inference/src/mv_inference_open.cpp b/mv_inference/inference/src/mv_inference_open.cpp
index 57cdfa92..e63d2b92 100755..100644
--- a/mv_inference/inference/src/mv_inference_open.cpp
+++ b/mv_inference/inference/src/mv_inference_open.cpp
@@ -25,19 +25,18 @@
 
 using namespace mediavision::inference;
 
-static int check_mv_inference_engine_version(mv_engine_config_h engine_config, bool *is_new_version)
+static int check_mv_inference_engine_version(mv_engine_config_h engine_config,
+											 bool *is_new_version)
 {
 	int oldType = 0, newType = 0;
 
-	int ret = mv_engine_config_get_int_attribute(engine_config,
-											MV_INFERENCE_TARGET_TYPE,
-											&oldType);
+	int ret = mv_engine_config_get_int_attribute(
+			engine_config, MV_INFERENCE_TARGET_TYPE, &oldType);
 	if (ret != MEDIA_VISION_ERROR_NONE)
 		oldType = -1;
 
-	ret = mv_engine_config_get_int_attribute(engine_config,
-											MV_INFERENCE_TARGET_DEVICE_TYPE,
-											&newType);
+	ret = mv_engine_config_get_int_attribute(
+			engine_config, MV_INFERENCE_TARGET_DEVICE_TYPE, &newType);
 	if (ret != MEDIA_VISION_ERROR_NONE)
 		newType = -1;
 
@@ -48,7 +47,8 @@ static int check_mv_inference_engine_version(mv_engine_config_h engine_config, b
 
 	// If values of both types are changed then return an error.
 	// only one of two types should be used.
-	if (oldType != MV_INFERENCE_TARGET_CPU && newType != MV_INFERENCE_TARGET_DEVICE_CPU) {
+	if (oldType != MV_INFERENCE_TARGET_CPU &&
+		newType != MV_INFERENCE_TARGET_DEVICE_CPU) {
 		LOGE("Please use only one of below two device types.");
 		LOGE("MV_INFERENCE_TARGET_TYPE(deprecated) or MV_INFERENCE_TARGET_DEVICE_TYPE(recommended).");
 		return MEDIA_VISION_ERROR_INVALID_PARAMETER;
@@ -62,7 +62,8 @@ static int check_mv_inference_engine_version(mv_engine_config_h engine_config, b
 	//   (oldType == MV_INFERENCE_TARGET_CPU && newType == MV_INFERENCE_TARGET_DEVICE_CPU)
 	// - default value of only new type is changed.
 	//   (oldType == MV_INFERENCE_TARGET_CPU && (newType != -1 && newType != MV_INFERENCE_TARGET_DEVICE_CPU))
-	if ((oldType != -1 && oldType != MV_INFERENCE_TARGET_CPU) && newType == MV_INFERENCE_TARGET_DEVICE_CPU)
+	if ((oldType != -1 && oldType != MV_INFERENCE_TARGET_CPU) &&
+		newType == MV_INFERENCE_TARGET_DEVICE_CPU)
 		*is_new_version = false;
 	else
 		*is_new_version = true;
@@ -78,12 +79,12 @@ mv_engine_config_h mv_inference_get_engine_config(mv_inference_h infer)
 
 int mv_inference_create_open(mv_inference_h *infer)
 {
-	if (infer == NULL ) {
+	if (infer == NULL) {
 		LOGE("Handle can't be created because handle pointer is NULL");
 		return MEDIA_VISION_ERROR_INVALID_PARAMETER;
 	}
 
-	(*infer) = static_cast<mv_inference_h>(new (std::nothrow)Inference());
+	(*infer) = static_cast<mv_inference_h>(new (std::nothrow) Inference());
 
 	if (*infer == NULL) {
 		LOGE("Failed to create inference handle");
@@ -103,86 +104,85 @@ int mv_inference_destroy_open(mv_inference_h infer)
 	}
 
 	LOGD("Destroying inference handle [%p]", infer);
-	delete static_cast<Inference*>(infer);
+	delete static_cast<Inference *>(infer);
 	LOGD("Inference handle has been destroyed");
 
 	return MEDIA_VISION_ERROR_NONE;
 }
 
-
-int mv_inference_configure_model_open(mv_inference_h infer, mv_engine_config_h engine_config)
+int mv_inference_configure_model_open(mv_inference_h infer,
+									  mv_engine_config_h engine_config)
 {
 	LOGI("ENTER");
 
-    Inference *pInfer = static_cast<Inference *>(infer);
+	Inference *pInfer = static_cast<Inference *>(infer);
 
-    int ret = MEDIA_VISION_ERROR_NONE;
+	int ret = MEDIA_VISION_ERROR_NONE;
 
 	char *modelConfigFilePath = NULL;
 	char *modelWeightFilePath = NULL;
 	char *modelUserFilePath = NULL;
 	double modelMeanValue = 0.0;
-	int backendType= 0;
+	int backendType = 0;
 	int targetTypes = 0;
 	size_t userFileLength = 0;
 
-    ret = mv_engine_config_get_string_attribute(engine_config,
-											MV_INFERENCE_MODEL_CONFIGURATION_FILE_PATH,
-											&modelConfigFilePath);
+	ret = mv_engine_config_get_string_attribute(
+			engine_config, MV_INFERENCE_MODEL_CONFIGURATION_FILE_PATH,
+			&modelConfigFilePath);
 	if (ret != MEDIA_VISION_ERROR_NONE) {
 		LOGE("Fail to get model configuration file path");
 		goto _ERROR_;
 	}
 
-	ret = mv_engine_config_get_string_attribute(engine_config,
-											MV_INFERENCE_MODEL_WEIGHT_FILE_PATH,
-											&modelWeightFilePath);
+	ret = mv_engine_config_get_string_attribute(
+			engine_config, MV_INFERENCE_MODEL_WEIGHT_FILE_PATH,
+			&modelWeightFilePath);
 	if (ret != MEDIA_VISION_ERROR_NONE) {
 		LOGE("Fail to get model weight file path");
 		goto _ERROR_;
 	}
 
-	ret = mv_engine_config_get_string_attribute(engine_config,
-											MV_INFERENCE_MODEL_USER_FILE_PATH,
-											&modelUserFilePath);
+	ret = mv_engine_config_get_string_attribute(
+			engine_config, MV_INFERENCE_MODEL_USER_FILE_PATH,
+			&modelUserFilePath);
 	if (ret != MEDIA_VISION_ERROR_NONE) {
 		LOGE("Fail to get model user file path");
 		goto _ERROR_;
 	}
 
-	ret = mv_engine_config_get_double_attribute(engine_config,
-												MV_INFERENCE_MODEL_MEAN_VALUE,
-												&modelMeanValue);
+	ret = mv_engine_config_get_double_attribute(
+			engine_config, MV_INFERENCE_MODEL_MEAN_VALUE, &modelMeanValue);
 	if (ret != MEDIA_VISION_ERROR_NONE) {
 		LOGE("Fail to get model mean value");
 		goto _ERROR_;
 	}
 
-	ret = mv_engine_config_get_int_attribute(engine_config,
-												MV_INFERENCE_BACKEND_TYPE,
-												&backendType);
+	ret = mv_engine_config_get_int_attribute(
+			engine_config, MV_INFERENCE_BACKEND_TYPE, &backendType);
 	if (ret != MEDIA_VISION_ERROR_NONE) {
 		LOGE("Fail to get inference backend type");
 		goto _ERROR_;
 	}
 
-	ret = mv_engine_config_get_int_attribute(engine_config,
-											MV_INFERENCE_TARGET_DEVICE_TYPE,
-											&targetTypes);
+	ret = mv_engine_config_get_int_attribute(
+			engine_config, MV_INFERENCE_TARGET_DEVICE_TYPE, &targetTypes);
 	if (ret != MEDIA_VISION_ERROR_NONE) {
 		LOGE("Fail to get inference target type");
 		goto _ERROR_;
 	}
 
-	if ( access(modelWeightFilePath, F_OK)) {
+	if (access(modelWeightFilePath, F_OK)) {
 		LOGE("weightFilePath in [%s] ", modelWeightFilePath);
 		ret = MEDIA_VISION_ERROR_INVALID_PATH;
 		goto _ERROR_;
 	}
 
-	if ( (backendType > MV_INFERENCE_BACKEND_NONE  && backendType < MV_INFERENCE_BACKEND_MAX)
-		&& (backendType != MV_INFERENCE_BACKEND_TFLITE) && (backendType != MV_INFERENCE_BACKEND_ARMNN)) {
-		if ( access(modelConfigFilePath, F_OK)) {
+	if ((backendType > MV_INFERENCE_BACKEND_NONE &&
+		 backendType < MV_INFERENCE_BACKEND_MAX) &&
+		(backendType != MV_INFERENCE_BACKEND_TFLITE) &&
+		(backendType != MV_INFERENCE_BACKEND_ARMNN)) {
+		if (access(modelConfigFilePath, F_OK)) {
 			LOGE("modelConfigFilePath in [%s] ", modelConfigFilePath);
 			ret = MEDIA_VISION_ERROR_INVALID_PATH;
 			goto _ERROR_;
@@ -210,21 +210,23 @@ int mv_inference_configure_model_open(mv_inference_h infer, mv_engine_config_h e
 
 	if (is_new_version) {
 		// Use new type.
-		if (pInfer->ConfigureTargetDevices(targetTypes) != MEDIA_VISION_ERROR_NONE) {
+		if (pInfer->ConfigureTargetDevices(targetTypes) !=
+			MEDIA_VISION_ERROR_NONE) {
 			LOGE("Tried to configure invalid target types.");
 			goto _ERROR_;
 		}
 	} else {
 		// Convert old type to new one and then use it.
-		if (pInfer->ConfigureTargetTypes(targetTypes) != MEDIA_VISION_ERROR_NONE) {
+		if (pInfer->ConfigureTargetTypes(targetTypes) !=
+			MEDIA_VISION_ERROR_NONE) {
 			LOGE("Tried to configure invalid target types.");
 			goto _ERROR_;
 		}
 	}
 
 	pInfer->ConfigureModelFiles(std::string(modelConfigFilePath),
-					std::string(modelWeightFilePath),
-					std::string(modelUserFilePath));
+								std::string(modelWeightFilePath),
+								std::string(modelUserFilePath));
 
 _ERROR_:
 	if (modelConfigFilePath)
@@ -238,78 +240,76 @@ _ERROR_:
 
 	LOGI("LEAVE");
 
-    return ret;
+	return ret;
 }
 
-int mv_inference_configure_tensor_info_open(mv_inference_h infer, mv_engine_config_h engine_config)
+int mv_inference_configure_tensor_info_open(mv_inference_h infer,
+											mv_engine_config_h engine_config)
 {
 	LOGI("ENTER");
 
-    Inference *pInfer = static_cast<Inference *>(infer);
+	Inference *pInfer = static_cast<Inference *>(infer);
 
-    int ret = MEDIA_VISION_ERROR_NONE;
+	int ret = MEDIA_VISION_ERROR_NONE;
 
 	int tensorWidth, tensorHeight, tensorDim, tensorCh;
 	double meanValue, stdValue;
 
 	// This should be one. only one batch is supported
 	tensorDim = 1;
-    ret = mv_engine_config_get_int_attribute(engine_config,
-											MV_INFERENCE_INPUT_TENSOR_WIDTH,
-											&tensorWidth);
+	ret = mv_engine_config_get_int_attribute(
+			engine_config, MV_INFERENCE_INPUT_TENSOR_WIDTH, &tensorWidth);
 	if (ret != MEDIA_VISION_ERROR_NONE) {
 		LOGE("Fail to get tensor width");
 		goto _ERROR_;
 	}
 
-    ret = mv_engine_config_get_int_attribute(engine_config,
-											MV_INFERENCE_INPUT_TENSOR_HEIGHT,
-											&tensorHeight);
+	ret = mv_engine_config_get_int_attribute(
+			engine_config, MV_INFERENCE_INPUT_TENSOR_HEIGHT, &tensorHeight);
 	if (ret != MEDIA_VISION_ERROR_NONE) {
 		LOGE("Fail to get tensor height");
 		goto _ERROR_;
 	}
 
-    ret = mv_engine_config_get_int_attribute(engine_config,
-											MV_INFERENCE_INPUT_TENSOR_CHANNELS,
-											&tensorCh);
+	ret = mv_engine_config_get_int_attribute(
+			engine_config, MV_INFERENCE_INPUT_TENSOR_CHANNELS, &tensorCh);
 	if (ret != MEDIA_VISION_ERROR_NONE) {
 		LOGE("Fail to get tensor channels");
 		goto _ERROR_;
 	}
 
-	ret = mv_engine_config_get_double_attribute(engine_config,
-											MV_INFERENCE_MODEL_MEAN_VALUE,
-											&meanValue);
+	ret = mv_engine_config_get_double_attribute(
+			engine_config, MV_INFERENCE_MODEL_MEAN_VALUE, &meanValue);
 	if (ret != MEDIA_VISION_ERROR_NONE) {
 		LOGE("Fail to get meanValue");
 		goto _ERROR_;
 	}
 
-	ret = mv_engine_config_get_double_attribute(engine_config,
-											MV_INFERENCE_MODEL_STD_VALUE,
-											&stdValue);
+	ret = mv_engine_config_get_double_attribute(
+			engine_config, MV_INFERENCE_MODEL_STD_VALUE, &stdValue);
 	if (ret != MEDIA_VISION_ERROR_NONE) {
 		LOGE("Fail to get stdValue");
 		goto _ERROR_;
 	}
 
-    pInfer->ConfigureTensorInfo(tensorWidth, tensorHeight, tensorDim, tensorCh, stdValue, meanValue);
+	pInfer->ConfigureTensorInfo(tensorWidth, tensorHeight, tensorDim, tensorCh,
+								stdValue, meanValue);
 
-_ERROR_ :
+_ERROR_:
 
 	LOGI("LEAVE");
 
-    return ret;
+	return ret;
 }
 
-int mv_inference_configure_input_info_open(mv_inference_h infer, mv_engine_config_h engine_config)
+int mv_inference_configure_input_info_open(mv_inference_h infer,
+										   mv_engine_config_h engine_config)
 {
 	LOGI("ENTER");
 
-    Inference *pInfer = static_cast<Inference *>(infer);
+	Inference *pInfer = static_cast<Inference *>(infer);
 
-    int ret = MEDIA_VISION_ERROR_NONE;
+	int ret = MEDIA_VISION_ERROR_NONE;
 
 	int tensorWidth, tensorHeight, tensorDim, tensorCh;
 	double meanValue, stdValue;
@@ -318,72 +318,60 @@ int mv_inference_configure_input_info_open(mv_inference_h infer, mv_engine_confi
 
 	// This should be one. only one batch is supported
 	tensorDim = 1;
-    ret = mv_engine_config_get_int_attribute(engine_config,
-											MV_INFERENCE_INPUT_TENSOR_WIDTH,
-											&tensorWidth);
+	ret = mv_engine_config_get_int_attribute(
+			engine_config, MV_INFERENCE_INPUT_TENSOR_WIDTH, &tensorWidth);
 	if (ret != MEDIA_VISION_ERROR_NONE) {
 		LOGE("Fail to get tensor width");
 		goto _ERROR_;
 	}
 
-    ret = mv_engine_config_get_int_attribute(engine_config,
-											MV_INFERENCE_INPUT_TENSOR_HEIGHT,
-											&tensorHeight);
+	ret = mv_engine_config_get_int_attribute(
+			engine_config, MV_INFERENCE_INPUT_TENSOR_HEIGHT, &tensorHeight);
 	if (ret != MEDIA_VISION_ERROR_NONE) {
 		LOGE("Fail to get tensor height");
 		goto _ERROR_;
 	}
 
-    ret = mv_engine_config_get_int_attribute(engine_config,
-											MV_INFERENCE_INPUT_TENSOR_CHANNELS,
-											&tensorCh);
+	ret = mv_engine_config_get_int_attribute(
+			engine_config, MV_INFERENCE_INPUT_TENSOR_CHANNELS, &tensorCh);
 	if (ret != MEDIA_VISION_ERROR_NONE) {
 		LOGE("Fail to get tensor channels");
 		goto _ERROR_;
 	}
 
-	ret = mv_engine_config_get_double_attribute(engine_config,
-											MV_INFERENCE_MODEL_MEAN_VALUE,
-											&meanValue);
+	ret = mv_engine_config_get_double_attribute(
+			engine_config, MV_INFERENCE_MODEL_MEAN_VALUE, &meanValue);
 	if (ret != MEDIA_VISION_ERROR_NONE) {
 		LOGE("Fail to get meanValue");
 		goto _ERROR_;
 	}
 
-	ret = mv_engine_config_get_double_attribute(engine_config,
-											MV_INFERENCE_MODEL_STD_VALUE,
-											&stdValue);
+	ret = mv_engine_config_get_double_attribute(
+			engine_config, MV_INFERENCE_MODEL_STD_VALUE, &stdValue);
 	if (ret != MEDIA_VISION_ERROR_NONE) {
 		LOGE("Fail to get stdValue");
 		goto _ERROR_;
 	}
 
-    ret = mv_engine_config_get_int_attribute(engine_config,
-											MV_INFERENCE_INPUT_DATA_TYPE,
-											&dataType);
+	ret = mv_engine_config_get_int_attribute(
+			engine_config, MV_INFERENCE_INPUT_DATA_TYPE, &dataType);
 	if (ret != MEDIA_VISION_ERROR_NONE) {
 		LOGE("Fail to get a input tensor data type");
 		goto _ERROR_;
 	}
 
-    ret = mv_engine_config_get_string_attribute(engine_config,
-											  MV_INFERENCE_INPUT_NODE_NAME,
-											  &node_name);
+	ret = mv_engine_config_get_string_attribute(
+			engine_config, MV_INFERENCE_INPUT_NODE_NAME, &node_name);
 	if (ret != MEDIA_VISION_ERROR_NONE) {
 		LOGE("Fail to get tensor width");
 		goto _ERROR_;
 	}
 
-    pInfer->ConfigureInputInfo(tensorWidth,
-							tensorHeight,
-							tensorDim,
-							tensorCh,
-							stdValue,
-							meanValue,
-							dataType,
-							std::vector<std::string>(1, std::string(node_name)));
+	pInfer->ConfigureInputInfo(
+			tensorWidth, tensorHeight, tensorDim, tensorCh, stdValue, meanValue,
+			dataType, std::vector<std::string>(1, std::string(node_name)));
 
-_ERROR_ :
+_ERROR_:
 
 	if (node_name) {
 		free(node_name);
@@ -392,32 +380,33 @@ _ERROR_ :
 
 	LOGI("LEAVE");
 
-    return ret;
+	return ret;
 }
 
-int mv_inference_configure_engine_open(mv_inference_h infer, mv_engine_config_h engine_config)
+int mv_inference_configure_engine_open(mv_inference_h infer,
+									   mv_engine_config_h engine_config)
 {
 	LOGI("ENTER");
 
-    Inference *pInfer = static_cast<Inference *>(infer);
+	Inference *pInfer = static_cast<Inference *>(infer);
 	int backendType = 0;
-    int ret = MEDIA_VISION_ERROR_NONE;
+	int ret = MEDIA_VISION_ERROR_NONE;
 
 	pInfer->SetEngineConfig(engine_config);
 
-	ret = mv_engine_config_get_int_attribute(engine_config,
-											MV_INFERENCE_BACKEND_TYPE,
-											&backendType);
+	ret = mv_engine_config_get_int_attribute(
+			engine_config, MV_INFERENCE_BACKEND_TYPE, &backendType);
 	if (ret != MEDIA_VISION_ERROR_NONE) {
 		LOGE("Fail to get inference backend type");
 		goto _ERROR_;
 	}
 
-	ret = pInfer->ConfigureBackendType((mv_inference_backend_type_e)backendType);
-    if (ret != MEDIA_VISION_ERROR_NONE) {
+	ret = pInfer->ConfigureBackendType(
+			(mv_inference_backend_type_e) backendType);
+	if (ret != MEDIA_VISION_ERROR_NONE) {
 		LOGE("Fail to configure a backend type.");
 		goto _ERROR_;
-    }
+	}
 
 	// Create a inference-engine-common class object and load its corresponding library.
 	ret = pInfer->Bind();
@@ -430,7 +419,8 @@ _ERROR_:
 	return ret;
 }
 
-int mv_inference_configure_output_open(mv_inference_h infer, mv_engine_config_h engine_config)
+int mv_inference_configure_output_open(mv_inference_h infer,
+									   mv_engine_config_h engine_config)
 {
 	LOGI("ENTER");
 
@@ -439,9 +429,8 @@ int mv_inference_configure_output_open(mv_inference_h infer, mv_engine_config_h
 	int maxOutput = 0;
 	int ret = MEDIA_VISION_ERROR_NONE;
 
-	ret = mv_engine_config_get_int_attribute(engine_config,
-											MV_INFERENCE_OUTPUT_MAX_NUMBER,
-											&maxOutput);
+	ret = mv_engine_config_get_int_attribute(
+			engine_config, MV_INFERENCE_OUTPUT_MAX_NUMBER, &maxOutput);
 	if (ret != MEDIA_VISION_ERROR_NONE) {
 		LOGE("Fail to get inference output maximum numbers");
 		goto _ERROR_;
@@ -454,7 +443,8 @@ _ERROR_:
 	return ret;
 }
 
-int mv_inference_configure_confidence_threshold_open(mv_inference_h infer, mv_engine_config_h engine_config)
+int mv_inference_configure_confidence_threshold_open(
+		mv_inference_h infer, mv_engine_config_h engine_config)
 {
 	LOGI("ENTER");
 
@@ -463,9 +453,8 @@ int mv_inference_configure_confidence_threshold_open(mv_inference_h infer, mv_en
 	double threshold = 0;
 	int ret = MEDIA_VISION_ERROR_NONE;
 
-	ret = mv_engine_config_get_double_attribute(engine_config,
-											  MV_INFERENCE_CONFIDENCE_THRESHOLD,
-											  &threshold);
+	ret = mv_engine_config_get_double_attribute(
+			engine_config, MV_INFERENCE_CONFIDENCE_THRESHOLD, &threshold);
 	if (ret != MEDIA_VISION_ERROR_NONE) {
 		LOGE("Fail to get inference confidence threshold value");
 		goto _ERROR_;
@@ -478,7 +467,8 @@ _ERROR_:
 	return ret;
 }
 
-int mv_inference_configure_post_process_info_open(mv_inference_h infer, mv_engine_config_h engine_config)
+int mv_inference_configure_post_process_info_open(
+		mv_inference_h infer, mv_engine_config_h engine_config)
 {
 	LOGI("ENTER");
 
@@ -488,9 +478,8 @@ int mv_inference_configure_post_process_info_open(mv_inference_h infer, mv_engin
 	double threshold = 0;
 	int ret = MEDIA_VISION_ERROR_NONE;
 
-	ret = mv_engine_config_get_int_attribute(engine_config,
-											MV_INFERENCE_OUTPUT_MAX_NUMBER,
-											&maxOutput);
+	ret = mv_engine_config_get_int_attribute(
+			engine_config, MV_INFERENCE_OUTPUT_MAX_NUMBER, &maxOutput);
 	if (ret != MEDIA_VISION_ERROR_NONE) {
 		LOGE("Fail to get inference output maximum numbers");
 		goto _ERROR_;
@@ -498,9 +487,8 @@ int mv_inference_configure_post_process_info_open(mv_inference_h infer, mv_engin
 
 	pInfer->ConfigureOutput(maxOutput);
 
-	ret = mv_engine_config_get_double_attribute(engine_config,
-											  MV_INFERENCE_CONFIDENCE_THRESHOLD,
-											  &threshold);
+	ret = mv_engine_config_get_double_attribute(
+			engine_config, MV_INFERENCE_CONFIDENCE_THRESHOLD, &threshold);
 	if (ret != MEDIA_VISION_ERROR_NONE) {
 		LOGE("Fail to get inference confidence threshold value");
 		goto _ERROR_;
@@ -513,27 +501,26 @@ _ERROR_:
 	return ret;
 }
 
-int mv_inference_configure_output_info_open(mv_inference_h infer, mv_engine_config_h engine_config)
+int mv_inference_configure_output_info_open(mv_inference_h infer,
+											mv_engine_config_h engine_config)
 {
 	LOGI("ENTER");
 
-    Inference *pInfer = static_cast<Inference *>(infer);
+	Inference *pInfer = static_cast<Inference *>(infer);
 
-    int ret = MEDIA_VISION_ERROR_NONE;
+	int ret = MEDIA_VISION_ERROR_NONE;
 	int idx = 0;
 	char **node_names = NULL;
 	int size = 0;
 	std::vector<std::string> names;
-    ret = mv_engine_config_get_array_string_attribute(engine_config,
-											  MV_INFERENCE_OUTPUT_NODE_NAMES,
-											  &node_names,
-											  &size);
+	ret = mv_engine_config_get_array_string_attribute(
+			engine_config, MV_INFERENCE_OUTPUT_NODE_NAMES, &node_names, &size);
 	if (ret != MEDIA_VISION_ERROR_NONE) {
 		LOGE("Fail to get _output_node_names");
 		goto _ERROR_;
 	}
 
-	for (idx = 0 ; idx < size; ++idx)
+	for (idx = 0; idx < size; ++idx)
 		names.push_back(std::string(node_names[idx]));
 
 	pInfer->ConfigureOutputInfo(names);
@@ -561,17 +548,17 @@ int mv_inference_prepare_open(mv_inference_h infer)
 
 	int ret = MEDIA_VISION_ERROR_NONE;
 
-    // Pass parameters needed to load model files to a backend engine.
+	// Pass parameters needed to load model files to a backend engine.
 	ret = pInfer->Prepare();
 	if (ret != MEDIA_VISION_ERROR_NONE) {
 		LOGE("Fail to prepare inference");
-        return ret;
-    }
+		return ret;
+	}
 
-    // Request to load model files to a backend engine.
-    ret = pInfer->Load();
-    if (ret != MEDIA_VISION_ERROR_NONE)
-        LOGE("Fail to load model files.");
+	// Request to load model files to a backend engine.
+	ret = pInfer->Load();
+	if (ret != MEDIA_VISION_ERROR_NONE)
+		LOGE("Fail to load model files.");
 
 	LOGI("LEAVE");
 
@@ -579,9 +566,8 @@ int mv_inference_prepare_open(mv_inference_h infer)
 }
 
 int mv_inference_foreach_supported_engine_open(
-	mv_inference_h infer,
-	mv_inference_supported_engine_cb callback,
-	void *user_data)
+		mv_inference_h infer, mv_inference_supported_engine_cb callback,
+		void *user_data)
 {
 	LOGI("ENTER");
 
@@ -603,11 +589,8 @@ int mv_inference_foreach_supported_engine_open(
 }
 
 int mv_inference_image_classify_open(
-		mv_source_h source,
-		mv_inference_h infer,
-		mv_rectangle_s *roi,
-		mv_inference_image_classified_cb classified_cb,
-		void *user_data)
+		mv_source_h source, mv_inference_h infer, mv_rectangle_s *roi,
+		mv_inference_image_classified_cb classified_cb, void *user_data)
 {
 	Inference *pInfer = static_cast<Inference *>(infer);
 
@@ -637,33 +620,31 @@ int mv_inference_image_classify_open(
 
 	numberOfOutputs = classificationResults.number_of_classes;
 
-
 	int *indices = classificationResults.indices.data();
 	float *confidences = classificationResults.confidences.data();
 	static const int START_CLASS_NUMBER = 10;
-	static std::vector<const char*> names(START_CLASS_NUMBER);
+	static std::vector<const char *> names(START_CLASS_NUMBER);
 
 	if (numberOfOutputs > START_CLASS_NUMBER)
 		names.resize(numberOfOutputs);
 
-	LOGE("mv_inference_open: number_of_classes: %d\n", classificationResults.number_of_classes);
+	LOGE("mv_inference_open: number_of_classes: %d\n",
+		 classificationResults.number_of_classes);
 
 	for (int n = 0; n < numberOfOutputs; ++n) {
 		LOGE("names: %s", classificationResults.names[n].c_str());
 		names[n] = classificationResults.names[n].c_str();
 	}
 
-	classified_cb(source, numberOfOutputs, indices, names.data(), confidences, user_data);
+	classified_cb(source, numberOfOutputs, indices, names.data(), confidences,
+				  user_data);
 
 	return ret;
 }
 
-
-int mv_inference_object_detect_open(
-	mv_source_h source,
-	mv_inference_h infer,
-	mv_inference_object_detected_cb detected_cb,
-	void *user_data)
+int mv_inference_object_detect_open(mv_source_h source, mv_inference_h infer,
+									mv_inference_object_detected_cb detected_cb,
+									void *user_data)
 {
 	Inference *pInfer = static_cast<Inference *>(infer);
 
@@ -692,7 +673,7 @@ int mv_inference_object_detect_open(
 	int *indices = objectDetectionResults.indices.data();
 	float *confidences = objectDetectionResults.confidences.data();
 	static const int START_OBJECT_NUMBER = 20;
-	static std::vector<const char*> names(START_OBJECT_NUMBER);
+	static std::vector<const char *> names(START_OBJECT_NUMBER);
 	static std::vector<mv_rectangle_s> locations(START_OBJECT_NUMBER);
 
 	if (numberOfOutputs > START_OBJECT_NUMBER) {
@@ -710,16 +691,15 @@ int mv_inference_object_detect_open(
 		locations[n].height = objectDetectionResults.locations[n].height;
 	}
 
-	detected_cb(source, numberOfOutputs, indices, names.data(), confidences, locations.data(), user_data);
+	detected_cb(source, numberOfOutputs, indices, names.data(), confidences,
+				locations.data(), user_data);
 
 	return ret;
 }
 
-int mv_inference_face_detect_open(
-	mv_source_h source,
-	mv_inference_h infer,
-	mv_inference_face_detected_cb detected_cb,
-	void *user_data)
+int mv_inference_face_detect_open(mv_source_h source, mv_inference_h infer,
+								  mv_inference_face_detected_cb detected_cb,
+								  void *user_data)
 {
 	Inference *pInfer = static_cast<Inference *>(infer);
 
@@ -755,17 +735,15 @@ int mv_inference_face_detect_open(
 		locations[n].height = faceDetectionResults.locations[n].height;
 	}
 
-	detected_cb(source, numberOfOutputs, confidences, locations.data(), user_data);
+	detected_cb(source, numberOfOutputs, confidences, locations.data(),
+				user_data);
 
 	return ret;
 }
 
 int mv_inference_facial_landmark_detect_open(
-	mv_source_h source,
-	mv_inference_h infer,
-	mv_rectangle_s *roi,
-	mv_inference_facial_landmark_detected_cb detected_cb,
-	void *user_data)
+		mv_source_h source, mv_inference_h infer, mv_rectangle_s *roi,
+		mv_inference_facial_landmark_detected_cb detected_cb, void *user_data)
 {
 	Inference *pInfer = static_cast<Inference *>(infer);
 
@@ -786,7 +764,8 @@ int mv_inference_facial_landmark_detect_open(
 	}
 
 	FacialLandMarkDetectionResults facialLandMarkDetectionResults;
-	ret = pInfer->GetFacialLandMarkDetectionResults(&facialLandMarkDetectionResults);
+	ret = pInfer->GetFacialLandMarkDetectionResults(
+			&facialLandMarkDetectionResults);
 	if (ret != MEDIA_VISION_ERROR_NONE) {
 		LOGE("Fail to get inference results");
 		return ret;
@@ -797,7 +776,6 @@ int mv_inference_facial_landmark_detect_open(
 	std::vector<mv_point_s> locations(numberOfLandmarks);
 
 	for (int n = 0; n < numberOfLandmarks; ++n) {
-
 		locations[n].x = facialLandMarkDetectionResults.locations[n].x;
 		locations[n].y = facialLandMarkDetectionResults.locations[n].y;
 	}
@@ -808,11 +786,8 @@ int mv_inference_facial_landmark_detect_open(
 }
 
 int mv_inference_pose_estimation_detect_open(
-	mv_source_h source,
-	mv_inference_h infer,
-	mv_rectangle_s *roi,
-	mv_inference_pose_estimation_detected_cb detected_cb,
-	void *user_data)
+		mv_source_h source, mv_inference_h infer, mv_rectangle_s *roi,
+		mv_inference_pose_estimation_detected_cb detected_cb, void *user_data)
 {
 	Inference *pInfer = static_cast<Inference *>(infer);
 
@@ -844,7 +819,6 @@ int mv_inference_pose_estimation_detect_open(
 	std::vector<mv_point_s> locations(numberOfPoseEstimation);
 
 	for (int n = 0; n < numberOfPoseEstimation; ++n) {
-
 		locations[n].x = poseEstimationResults.locations[n].x;
 		locations[n].y = poseEstimationResults.locations[n].y;
 	}
diff --git a/test/testsuites/inference/inference_test_suite.c b/test/testsuites/inference/inference_test_suite.c
index 11761256..3b4d52f8 100644
--- a/test/testsuites/inference/inference_test_suite.c
+++ b/test/testsuites/inference/inference_test_suite.c
@@ -31,43 +31,63 @@
 #include <limits.h>
 #include <time.h>
 
-#define ARRAY_SIZE(x)	(sizeof((x))/sizeof((x)[0]))
+#define ARRAY_SIZE(x) (sizeof((x)) / sizeof((x)[0]))
 #define FILE_PATH_SIZE 1024
 
 //Image Classification
-#define IC_LABEL_PATH "/usr/share/capi-media-vision/models/IC/tflite/ic_label.txt"
-#define IC_TFLITE_WEIGHT_PATH "/usr/share/capi-media-vision/models/IC/tflite/ic_tflite_model.tflite"
-
-#define IC_VIVANTE_LABEL_PATH "/usr/share/capi-media-vision/models/IC/vivante/ic_label.txt"
-#define IC_VIVANTE_WEIGHT_PATH "/usr/share/capi-media-vision/models/IC/vivante/ic_vivante_model.nb"
-#define IC_VIVANTE_CONFIG_PATH "/usr/share/capi-media-vision/models/IC/vivante/ic_vivante_model.so"
-
-#define IC_OPENCV_LABEL_CAFFE_PATH "/usr/share/capi-media-vision/models/IC/caffe/ic_caffe_label_squeezenet.txt"
-#define IC_OPENCV_WEIGHT_CAFFE_PATH "/usr/share/capi-media-vision/models/IC/caffe/ic_caffe_model_squeezenet.caffemodel"
-#define IC_OPENCV_CONFIG_CAFFE_PATH "/usr/share/capi-media-vision/models/IC/caffe/ic_caffe_model_squeezenet.prototxt"
+#define IC_LABEL_PATH \
+	"/usr/share/capi-media-vision/models/IC/tflite/ic_label.txt"
+#define IC_TFLITE_WEIGHT_PATH \
+	"/usr/share/capi-media-vision/models/IC/tflite/ic_tflite_model.tflite"
+
+#define IC_VIVANTE_LABEL_PATH \
+	"/usr/share/capi-media-vision/models/IC/vivante/ic_label.txt"
+#define IC_VIVANTE_WEIGHT_PATH \
+	"/usr/share/capi-media-vision/models/IC/vivante/ic_vivante_model.nb"
+#define IC_VIVANTE_CONFIG_PATH \
+	"/usr/share/capi-media-vision/models/IC/vivante/ic_vivante_model.so"
+
+#define IC_OPENCV_LABEL_CAFFE_PATH \
+	"/usr/share/capi-media-vision/models/IC/caffe/ic_caffe_label_squeezenet.txt"
+#define IC_OPENCV_WEIGHT_CAFFE_PATH \
+	"/usr/share/capi-media-vision/models/IC/caffe/ic_caffe_model_squeezenet.caffemodel"
+#define IC_OPENCV_CONFIG_CAFFE_PATH \
+	"/usr/share/capi-media-vision/models/IC/caffe/ic_caffe_model_squeezenet.prototxt"
 
 //Obeject Detection
-#define OD_LABEL_PATH "/usr/share/capi-media-vision/models/OD/tflite/od_label.txt"
-#define OD_TFLITE_WEIGHT_PATH "/usr/share/capi-media-vision/models/OD/tflite/od_tflite_model.tflite"
-
-#define OD_OPENCV_LABEL_CAFFE_PATH "/usr/share/capi-media-vision/models/OD/caffe/od_caffe_label_mobilenetv1ssd.txt"
-#define OD_OPENCV_WEIGHT_CAFFE_PATH "/usr/share/capi-media-vision/models/OD/caffe/od_caffe_model_mobilenetv1ssd.caffemodel"
-#define OD_OPENCV_CONFIG_CAFFE_PATH "/usr/share/capi-media-vision/models/OD/caffe/od_caffe_model_mobilenetv1ssd.prototxt"
+#define OD_LABEL_PATH \
+	"/usr/share/capi-media-vision/models/OD/tflite/od_label.txt"
+#define OD_TFLITE_WEIGHT_PATH \
+	"/usr/share/capi-media-vision/models/OD/tflite/od_tflite_model.tflite"
+
+#define OD_OPENCV_LABEL_CAFFE_PATH \
+	"/usr/share/capi-media-vision/models/OD/caffe/od_caffe_label_mobilenetv1ssd.txt"
+#define OD_OPENCV_WEIGHT_CAFFE_PATH \
+	"/usr/share/capi-media-vision/models/OD/caffe/od_caffe_model_mobilenetv1ssd.caffemodel"
+#define OD_OPENCV_CONFIG_CAFFE_PATH \
+	"/usr/share/capi-media-vision/models/OD/caffe/od_caffe_model_mobilenetv1ssd.prototxt"
 
 //Face Detection
-#define FD_TFLITE_WEIGHT_PATH "/usr/share/capi-media-vision/models/FD/tflite/fd_tflite_model1.tflite"
+#define FD_TFLITE_WEIGHT_PATH \
+	"/usr/share/capi-media-vision/models/FD/tflite/fd_tflite_model1.tflite"
 
-#define FD_OPENCV_WEIGHT_CAFFE_PATH "/usr/share/capi-media-vision/models/FD/caffe/fd_caffe_model_resnet10ssd.caffemodel"
-#define FD_OPENCV_CONFIG_CAFFE_PATH "/usr/share/capi-media-vision/models/FD/caffe/fd_caffe_model_resnet10ssd.prototxt"
+#define FD_OPENCV_WEIGHT_CAFFE_PATH \
+	"/usr/share/capi-media-vision/models/FD/caffe/fd_caffe_model_resnet10ssd.caffemodel"
+#define FD_OPENCV_CONFIG_CAFFE_PATH \
+	"/usr/share/capi-media-vision/models/FD/caffe/fd_caffe_model_resnet10ssd.prototxt"
 
 //Facila LandmarkDetection
-#define FLD_TFLITE_WEIGHT_PATH "/usr/share/capi-media-vision/models/FLD/tflite/fld_tflite_model1.tflite"
+#define FLD_TFLITE_WEIGHT_PATH \
+	"/usr/share/capi-media-vision/models/FLD/tflite/fld_tflite_model1.tflite"
 
-#define FLD_OPENCV_WEIGHT_CAFFE_PATH "/usr/share/capi-media-vision/models/FLD/caffe/fld_caffe_model_tweak.caffemodel"
-#define FLD_OPENCV_CONFIG_CAFFE_PATH "/usr/share/capi-media-vision/models/FLD/caffe/fld_caffe_model_tweak.prototxt"
+#define FLD_OPENCV_WEIGHT_CAFFE_PATH \
+	"/usr/share/capi-media-vision/models/FLD/caffe/fld_caffe_model_tweak.caffemodel"
+#define FLD_OPENCV_CONFIG_CAFFE_PATH \
+	"/usr/share/capi-media-vision/models/FLD/caffe/fld_caffe_model_tweak.prototxt"
 
 //Pose Estimation
-#define PE_TFLITE_WEIGHT_PATH "/usr/share/capi-media-vision/models/PE/tflite/ped_tflite_model.tflite"
+#define PE_TFLITE_WEIGHT_PATH \
+	"/usr/share/capi-media-vision/models/PE/tflite/ped_tflite_model.tflite"
 
 /******
  * Public model:
@@ -81,1069 +101,929 @@
  */
 
 #define NANO_PER_SEC ((__clock_t) 1000000000)
-#define NANO_PER_MILLI  ((__clock_t) 1000000)
-#define MILLI_PER_SEC  ((__clock_t) 1000)
+#define NANO_PER_MILLI ((__clock_t) 1000000)
+#define MILLI_PER_SEC ((__clock_t) 1000)
 
 struct timespec diff(struct timespec start, struct timespec end)
 {
-    struct timespec temp;
-    if ((end.tv_nsec - start.tv_nsec) < 0) {
-        temp.tv_sec = end.tv_sec - start.tv_sec - 1;
-        temp.tv_nsec = NANO_PER_SEC + end.tv_nsec - start.tv_nsec;
-    }
-    else {
-        temp.tv_sec = end.tv_sec - start.tv_sec;
-        temp.tv_nsec = end.tv_nsec - start.tv_nsec;
-    }
-    return temp;
+	struct timespec temp;
+	if ((end.tv_nsec - start.tv_nsec) < 0) {
+		temp.tv_sec = end.tv_sec - start.tv_sec - 1;
+		temp.tv_nsec = NANO_PER_SEC + end.tv_nsec - start.tv_nsec;
+	} else {
+		temp.tv_sec = end.tv_sec - start.tv_sec;
+		temp.tv_nsec = end.tv_nsec - start.tv_nsec;
+	}
+	return temp;
 }
 
 unsigned long gettotalmillisec(const struct timespec time)
 {
-    return time.tv_sec * MILLI_PER_SEC + time.tv_nsec / NANO_PER_MILLI;
+	return time.tv_sec * MILLI_PER_SEC + time.tv_nsec / NANO_PER_MILLI;
 }
 
-void _object_detected_cb (
-        mv_source_h source,
-        const int number_of_objects,
-        const int *indices,
-        const char **names,
-        const float *confidences,
-        const mv_rectangle_s *locations,
-        void *user_data)
+void _object_detected_cb(mv_source_h source, const int number_of_objects,
+						 const int *indices, const char **names,
+						 const float *confidences,
+						 const mv_rectangle_s *locations, void *user_data)
 {
-    printf("In callback: %d objects\n", number_of_objects);
-
-    for (int n = 0; n < number_of_objects; n++) {
-        printf("%2d\n", indices[n]);
-        printf("%s\n", names[n]);
-        printf("%.3f\n", confidences[n]);
-        printf("%d,%d,%d,%d\n", locations[n].point.x,
-                                locations[n].point.y,
-                                locations[n].width,
-                                locations[n].height);
-    }
+	printf("In callback: %d objects\n", number_of_objects);
+
+	for (int n = 0; n < number_of_objects; n++) {
+		printf("%2d\n", indices[n]);
+		printf("%s\n", names[n]);
+		printf("%.3f\n", confidences[n]);
+		printf("%d,%d,%d,%d\n", locations[n].point.x, locations[n].point.y,
+			   locations[n].width, locations[n].height);
+	}
 }
 
-void _face_detected_cb (
-        mv_source_h source,
-        const int number_of_faces,
-        const float *confidences,
-        const mv_rectangle_s *locations,
-        void *user_data)
+void _face_detected_cb(mv_source_h source, const int number_of_faces,
+					   const float *confidences,
+					   const mv_rectangle_s *locations, void *user_data)
 {
-    printf("In callback: %d faces\n", number_of_faces);
-
-    for (int n = 0; n < number_of_faces; n++) {
-        printf("%.3f\n", confidences[n]);
-        printf("%d,%d,%d,%d\n", locations[n].point.x,
-                                locations[n].point.y,
-                                locations[n].width,
-                                locations[n].height);
-    }
+	printf("In callback: %d faces\n", number_of_faces);
 
+	for (int n = 0; n < number_of_faces; n++) {
+		printf("%.3f\n", confidences[n]);
+		printf("%d,%d,%d,%d\n", locations[n].point.x, locations[n].point.y,
+			   locations[n].width, locations[n].height);
+	}
 }
 
-void _facial_landmark_detected_cb (
-        mv_source_h source,
-        const int number_of_landmarks,
-        const mv_point_s *locations,
-        void *user_data)
+void _facial_landmark_detected_cb(mv_source_h source,
+								  const int number_of_landmarks,
+								  const mv_point_s *locations, void *user_data)
 {
-    printf("In callback, %d landmarks\n", number_of_landmarks);
-    for (int n = 0; n < number_of_landmarks; n++) {
-        printf("%d: x[%d], y[%d]\n", n, locations[n].x, locations[n].y);
-    }
+	printf("In callback, %d landmarks\n", number_of_landmarks);
+	for (int n = 0; n < number_of_landmarks; n++) {
+		printf("%d: x[%d], y[%d]\n", n, locations[n].x, locations[n].y);
+	}
 }
 
-void _pose_estimation_detected_cb (
-        mv_source_h source,
-        const int number_of_pose_estimation,
-        const mv_point_s *locations,
-        void *user_data)
+void _pose_estimation_detected_cb(mv_source_h source,
+								  const int number_of_pose_estimation,
+								  const mv_point_s *locations, void *user_data)
 {
-    printf("In callback, %d pose estimation\n", number_of_pose_estimation);
-    for (int n = 0; n < number_of_pose_estimation; n++) {
-        printf("%d: x[%d], y[%d]\n", n, locations[n].x, locations[n].y);
-    }
+	printf("In callback, %d pose estimation\n", number_of_pose_estimation);
+	for (int n = 0; n < number_of_pose_estimation; n++) {
+		printf("%d: x[%d], y[%d]\n", n, locations[n].x, locations[n].y);
+	}
 }
 
-void _image_classified_cb (
-	    mv_source_h source,
-	    const int number_of_classes,
-	    const int *indices,
-        const char **names,
-	    const float *confidences,
-	    void *user_data)
+void _image_classified_cb(mv_source_h source, const int number_of_classes,
+						  const int *indices, const char **names,
+						  const float *confidences, void *user_data)
 {
-    printf("In callback: %d classes\n", number_of_classes);
+	printf("In callback: %d classes\n", number_of_classes);
 
-    for (int n=0; n<number_of_classes; ++n) {
-        printf("%2d\n", indices[n]);
-        printf("%s\n",  names[n]);
-        printf("%.3f\n", confidences[n]);
-    }
+	for (int n = 0; n < number_of_classes; ++n) {
+		printf("%2d\n", indices[n]);
+		printf("%s\n", names[n]);
+		printf("%.3f\n", confidences[n]);
+	}
 }
 
-int show_menu(const char *title, const int *options, const char **names, int cnt)
+int show_menu(const char *title, const int *options, const char **names,
+			  int cnt)
 {
-    printf("*********************************************\n");
-    printf("* %38s *\n", title);
-    printf("*-------------------------------------------*\n");
-    int i = 0;
-    for (i = 0; i < cnt; ++i)
-        printf("* %2i. %34s *\n", options[i], names[i]);
-
-    printf("*********************************************\n\n");
-    int selection = 0;
-    printf("Your choice: ");
-    if (scanf("%20i", &selection) == 0) {
-        if (scanf("%*[^\n]%*c") != 0) {
-            printf("ERROR: Reading the input line error.\n");
-            return -1;
-        }
-        printf("ERROR: Incorrect input.\n");
-    }
-
-    return selection;
+	printf("*********************************************\n");
+	printf("* %38s *\n", title);
+	printf("*-------------------------------------------*\n");
+	int i = 0;
+	for (i = 0; i < cnt; ++i)
+		printf("* %2i. %34s *\n", options[i], names[i]);
+
+	printf("*********************************************\n\n");
+	int selection = 0;
+	printf("Your choice: ");
+	if (scanf("%20i", &selection) == 0) {
+		if (scanf("%*[^\n]%*c") != 0) {
+			printf("ERROR: Reading the input line error.\n");
+			return -1;
+		}
+		printf("ERROR: Incorrect input.\n");
+	}
+
+	return selection;
 }
 
 int perform_configure_set_model_config_path(mv_engine_config_h engine_cfg)
 {
-    int err = MEDIA_VISION_ERROR_NONE;
-    char *filePath = NULL;
-    while (-1 == input_string(
-        "Model configuration file path:",
-        FILE_PATH_SIZE,
-        &(filePath))) {
-            printf("Incorrect file path! Try again.\n");
-    }
-
-    err = mv_engine_config_set_string_attribute(engine_cfg,
-                            MV_INFERENCE_MODEL_CONFIGURATION_FILE_PATH,
-                            filePath);
-    if (err != MEDIA_VISION_ERROR_NONE) {
-        printf("Fail to set model configuration file path: %s\n", filePath);
-    }
-
-    free(filePath);
-    filePath = NULL;
-
-    return err;
+	int err = MEDIA_VISION_ERROR_NONE;
+	char *filePath = NULL;
+	while (-1 == input_string("Model configuration file path:", FILE_PATH_SIZE,
+							  &(filePath))) {
+		printf("Incorrect file path! Try again.\n");
+	}
+
+	err = mv_engine_config_set_string_attribute(
+			engine_cfg, MV_INFERENCE_MODEL_CONFIGURATION_FILE_PATH, filePath);
+	if (err != MEDIA_VISION_ERROR_NONE) {
+		printf("Fail to set model configuration file path: %s\n", filePath);
+	}
+
+	free(filePath);
+	filePath = NULL;
+
+	return err;
 }
 
 int perform_configure_set_model_weights_path(mv_engine_config_h engine_cfg)
 {
-    int err = MEDIA_VISION_ERROR_NONE;
-    char *filePath = NULL;
-    while (-1 == input_string(
-        "Model weights file path:",
-        FILE_PATH_SIZE,
-        &(filePath))) {
-            printf("Incorrect file path! Try again.\n");
-    }
-
-    err = mv_engine_config_set_string_attribute(engine_cfg,
-                            MV_INFERENCE_MODEL_WEIGHT_FILE_PATH,
-                            filePath);
-    if (err != MEDIA_VISION_ERROR_NONE) {
-        printf("Fail to set model weights file path: %s\n", filePath);
-    }
-
-    free(filePath);
-    filePath = NULL;
-
-    return err;
+	int err = MEDIA_VISION_ERROR_NONE;
+	char *filePath = NULL;
+	while (-1 == input_string("Model weights file path:", FILE_PATH_SIZE,
+							  &(filePath))) {
+		printf("Incorrect file path! Try again.\n");
+	}
+
+	err = mv_engine_config_set_string_attribute(
+			engine_cfg, MV_INFERENCE_MODEL_WEIGHT_FILE_PATH, filePath);
+	if (err != MEDIA_VISION_ERROR_NONE) {
+		printf("Fail to set model weights file path: %s\n", filePath);
+	}
+
+	free(filePath);
+	filePath = NULL;
+
+	return err;
 }
 
 int perform_configure_set_input_data_type(mv_engine_config_h engine_cfg)
 {
-    int err = MEDIA_VISION_ERROR_NONE;
-    int dataType = 0;
-    while (-1 == input_int(
-        "Input Tensor Data Type:",
-        0,
-        4,
-        &dataType)) {
-            printf("Invalid type! Try again.\n");
-    }
-
-    err = mv_engine_config_set_int_attribute(engine_cfg,
-                            MV_INFERENCE_INPUT_DATA_TYPE,
-                            (mv_inference_data_type_e)dataType);
-    if (err != MEDIA_VISION_ERROR_NONE) {
-        printf("Fail to set input tensor data type: %d\n", dataType);
-    }
-
-    return err;
+	int err = MEDIA_VISION_ERROR_NONE;
+	int dataType = 0;
+	while (-1 == input_int("Input Tensor Data Type:", 0, 4, &dataType)) {
+		printf("Invalid type! Try again.\n");
+	}
+
+	err = mv_engine_config_set_int_attribute(
+			engine_cfg, MV_INFERENCE_INPUT_DATA_TYPE,
+			(mv_inference_data_type_e) dataType);
+	if (err != MEDIA_VISION_ERROR_NONE) {
+		printf("Fail to set input tensor data type: %d\n", dataType);
+	}
+
+	return err;
 }
 
 int perform_configure_set_model_userfile_path(mv_engine_config_h engine_cfg)
 {
-    int err = MEDIA_VISION_ERROR_NONE;
-    char *filePath = NULL;
-    while (-1 == input_string(
-        "Model user file (category list) path:",
-        FILE_PATH_SIZE,
-        &(filePath))) {
-            printf("Incorrect file path! Try again.\n");
-    }
-
-    err = mv_engine_config_set_string_attribute(engine_cfg,
-                            MV_INFERENCE_MODEL_USER_FILE_PATH,
-                            filePath);
-    if (err != MEDIA_VISION_ERROR_NONE) {
-        printf("Fail to set model user file path: %s\n", filePath);
-    }
-
-    free(filePath);
-    filePath = NULL;
-
-    return err;
+	int err = MEDIA_VISION_ERROR_NONE;
+	char *filePath = NULL;
+	while (-1 == input_string("Model user file (category list) path:",
+							  FILE_PATH_SIZE, &(filePath))) {
+		printf("Incorrect file path! Try again.\n");
+	}
+
+	err = mv_engine_config_set_string_attribute(
+			engine_cfg, MV_INFERENCE_MODEL_USER_FILE_PATH, filePath);
+	if (err != MEDIA_VISION_ERROR_NONE) {
+		printf("Fail to set model user file path: %s\n", filePath);
+	}
+
+	free(filePath);
+	filePath = NULL;
+
+	return err;
 }
 
 int perform_configure_set_model_mean_value(mv_engine_config_h engine_cfg)
 {
-    int err = MEDIA_VISION_ERROR_NONE;
-    double meanValue = 0.0;
-    while (-1 == input_double(
-        "mean value:",
-        0.0,
-        255.0,
-        &meanValue)) {
-            printf("Invalid value! Try again.\n");
-    }
-
-    err = mv_engine_config_set_double_attribute(engine_cfg,
-                            MV_INFERENCE_MODEL_MEAN_VALUE,
-                            meanValue);
-    if (err != MEDIA_VISION_ERROR_NONE) {
-        printf("Fail to set model mean value: %f\n", meanValue);
-    }
-
-    return err;
+	int err = MEDIA_VISION_ERROR_NONE;
+	double meanValue = 0.0;
+	while (-1 == input_double("mean value:", 0.0, 255.0, &meanValue)) {
+		printf("Invalid value! Try again.\n");
+	}
+
+	err = mv_engine_config_set_double_attribute(
+			engine_cfg, MV_INFERENCE_MODEL_MEAN_VALUE, meanValue);
+	if (err != MEDIA_VISION_ERROR_NONE) {
+		printf("Fail to set model mean value: %f\n", meanValue);
+	}
+
+	return err;
 }
 
 int perform_configure_set_image_scale(mv_engine_config_h engine_cfg)
 {
-    int err = MEDIA_VISION_ERROR_NONE;
-    double stdValue = 0.0;
-    while (-1 == input_double(
-        "Image scale factor:",
-        1.0,
-        255.0,
-        &stdValue)) {
-            printf("Invalid value! Try again.\n");
-    }
-
-    err = mv_engine_config_set_double_attribute(engine_cfg,
-                            MV_INFERENCE_MODEL_STD_VALUE,
-                            stdValue);
-    if (err != MEDIA_VISION_ERROR_NONE) {
-        printf("Fail to set std value: %lf\n", stdValue);
-    }
-
-    return err;
+	int err = MEDIA_VISION_ERROR_NONE;
+	double stdValue = 0.0;
+	while (-1 == input_double("Image scale factor:", 1.0, 255.0, &stdValue)) {
+		printf("Invalid value! Try again.\n");
+	}
+
+	err = mv_engine_config_set_double_attribute(
+			engine_cfg, MV_INFERENCE_MODEL_STD_VALUE, stdValue);
+	if (err != MEDIA_VISION_ERROR_NONE) {
+		printf("Fail to set std value: %lf\n", stdValue);
+	}
+
+	return err;
 }
 
 int perform_configure_set_confidence_threshold(mv_engine_config_h engine_cfg)
 {
-    int err = MEDIA_VISION_ERROR_NONE;
-    double threshold = 0.0;
-    while (-1 == input_double(
-        "threshold:",
-        0.0,
-        1.0,
-        &threshold)) {
-            printf("Invalid value! Try again.\n");
-    }
-
-    err = mv_engine_config_set_double_attribute(engine_cfg,
-                            MV_INFERENCE_CONFIDENCE_THRESHOLD,
-                            threshold);
-    if (err != MEDIA_VISION_ERROR_NONE) {
-        printf("Fail to set image scale value: %lf\n", threshold);
-    }
-
-    return err;
+	int err = MEDIA_VISION_ERROR_NONE;
+	double threshold = 0.0;
+	while (-1 == input_double("threshold:", 0.0, 1.0, &threshold)) {
+		printf("Invalid value! Try again.\n");
+	}
+
+	err = mv_engine_config_set_double_attribute(
+			engine_cfg, MV_INFERENCE_CONFIDENCE_THRESHOLD, threshold);
+	if (err != MEDIA_VISION_ERROR_NONE) {
+		printf("Fail to set image scale value: %lf\n", threshold);
+	}
+
+	return err;
 }
 
 int perform_configure_set_backend(mv_engine_config_h engine_cfg)
 {
-    int err = MEDIA_VISION_ERROR_NONE;
-    int backendType = 0;
-    while (-1 == input_int(
-        "Backend Type:",
-        1,
-        3,
-        &backendType)) {
-            printf("Invalid type! Try again.\n");
-    }
-
-    err = mv_engine_config_set_int_attribute(engine_cfg,
-                            MV_INFERENCE_BACKEND_TYPE,
-                            (mv_inference_backend_type_e)backendType);
-    if (err != MEDIA_VISION_ERROR_NONE) {
-        printf("Fail to set backend type: %d\n", backendType);
-    }
-
-    return err;
+	int err = MEDIA_VISION_ERROR_NONE;
+	int backendType = 0;
+	while (-1 == input_int("Backend Type:", 1, 3, &backendType)) {
+		printf("Invalid type! Try again.\n");
+	}
+
+	err = mv_engine_config_set_int_attribute(
+			engine_cfg, MV_INFERENCE_BACKEND_TYPE,
+			(mv_inference_backend_type_e) backendType);
+	if (err != MEDIA_VISION_ERROR_NONE) {
+		printf("Fail to set backend type: %d\n", backendType);
+	}
+
+	return err;
 }
 
 int perform_configure_set_target(mv_engine_config_h engine_cfg)
 {
-    int err = MEDIA_VISION_ERROR_NONE;
-    int targetType = 0;
-    while (-1 == input_int(
-        "Backend Type:",
-        1,
-        2,
-        &targetType)) {
-            printf("Invalid type! Try again.\n");
-    }
-
-    err = mv_engine_config_set_int_attribute(engine_cfg,
-                            MV_INFERENCE_TARGET_TYPE,
-                            (mv_inference_target_type_e)targetType);
-    if (err != MEDIA_VISION_ERROR_NONE) {
-        printf("Fail to set target type: %d\n", targetType);
-    }
-
-    return err;
+	int err = MEDIA_VISION_ERROR_NONE;
+	int targetType = 0;
+	while (-1 == input_int("Backend Type:", 1, 2, &targetType)) {
+		printf("Invalid type! Try again.\n");
+	}
+
+	err = mv_engine_config_set_int_attribute(
+			engine_cfg, MV_INFERENCE_TARGET_TYPE,
+			(mv_inference_target_type_e) targetType);
+	if (err != MEDIA_VISION_ERROR_NONE) {
+		printf("Fail to set target type: %d\n", targetType);
+	}
+
+	return err;
 }
 
 int perform_configure_set_tensor_width(mv_engine_config_h engine_cfg)
 {
-    int err = MEDIA_VISION_ERROR_NONE;
-    int tensorW = 0;
-    while (-1 == input_int(
-        "Tensor Width:",
-        INT_MIN,
-        INT_MAX,
-        &tensorW)) {
-            printf("Invalid value! Try again.\n");
-    }
-
-    err = mv_engine_config_set_int_attribute(engine_cfg,
-                            MV_INFERENCE_INPUT_TENSOR_WIDTH,
-                            tensorW);
-    if (err != MEDIA_VISION_ERROR_NONE) {
-        printf("Fail to set tensor width: %d\n", tensorW);
-    }
-
-    return err;
+	int err = MEDIA_VISION_ERROR_NONE;
+	int tensorW = 0;
+	while (-1 == input_int("Tensor Width:", INT_MIN, INT_MAX, &tensorW)) {
+		printf("Invalid value! Try again.\n");
+	}
+
+	err = mv_engine_config_set_int_attribute(
+			engine_cfg, MV_INFERENCE_INPUT_TENSOR_WIDTH, tensorW);
+	if (err != MEDIA_VISION_ERROR_NONE) {
+		printf("Fail to set tensor width: %d\n", tensorW);
+	}
+
+	return err;
 }
 
 int perform_configure_set_tensor_height(mv_engine_config_h engine_cfg)
 {
-    int err = MEDIA_VISION_ERROR_NONE;
-    int tensorH = 0;
-    while (-1 == input_int(
-        "Tensor Height:",
-        INT_MIN,
-        INT_MAX,
-        &tensorH)) {
-            printf("Invalid value! Try again.\n");
-    }
-
-    err = mv_engine_config_set_int_attribute(engine_cfg,
-                            MV_INFERENCE_INPUT_TENSOR_HEIGHT,
-                            tensorH);
-    if (err != MEDIA_VISION_ERROR_NONE) {
-        printf("Fail to set tensor height: %d\n", tensorH);
-    }
-
-    return err;
+	int err = MEDIA_VISION_ERROR_NONE;
+	int tensorH = 0;
+	while (-1 == input_int("Tensor Height:", INT_MIN, INT_MAX, &tensorH)) {
+		printf("Invalid value! Try again.\n");
+	}
+
+	err = mv_engine_config_set_int_attribute(
+			engine_cfg, MV_INFERENCE_INPUT_TENSOR_HEIGHT, tensorH);
+	if (err != MEDIA_VISION_ERROR_NONE) {
+		printf("Fail to set tensor height: %d\n", tensorH);
+	}
+
+	return err;
 }
 
 int perform_configure_set_tensor_channels(mv_engine_config_h engine_cfg)
 {
-    int err = MEDIA_VISION_ERROR_NONE;
-    int tensorC = 0;
-    while (-1 == input_int(
-        "Tensor Channels:",
-        INT_MIN,
-        INT_MAX,
-        &tensorC)) {
-            printf("Invalid value! Try again.\n");
-    }
-
-    err = mv_engine_config_set_int_attribute(engine_cfg,
-                            MV_INFERENCE_INPUT_TENSOR_CHANNELS,
-                            tensorC);
-    if (err != MEDIA_VISION_ERROR_NONE) {
-        printf("Fail to set tensor channels: %d\n", tensorC);
-    }
-
-    return err;
+	int err = MEDIA_VISION_ERROR_NONE;
+	int tensorC = 0;
+	while (-1 == input_int("Tensor Channels:", INT_MIN, INT_MAX, &tensorC)) {
+		printf("Invalid value! Try again.\n");
+	}
+
+	err = mv_engine_config_set_int_attribute(
+			engine_cfg, MV_INFERENCE_INPUT_TENSOR_CHANNELS, tensorC);
+	if (err != MEDIA_VISION_ERROR_NONE) {
+		printf("Fail to set tensor channels: %d\n", tensorC);
+	}
+
+	return err;
 }
 
 int perform_configuration(mv_engine_config_h *engine_cfg)
 {
-    int err = MEDIA_VISION_ERROR_NONE;
-
-    int sel_opt = 0;
-    const int options[13] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 ,12, 13};
-    const char *names[13] = { "Set Model Configuration",
-                           "Set Model Weights",
-                           "Set Model Data Type",
-                           "Set Model UserFile",
-                           "Set Model MeanFile",
-                           "Set Image Scale",
-                           "Set Confidence Threshold",
-                           "Set Backend",
-                           "Set Target",
-                           "Set InputTensor Width",
-                           "Set InputTensor Height",
-                           "Set InputTensor Channels",
-                           "Back" };
-
-    mv_engine_config_h handle = NULL;
-    err = mv_create_engine_config(&handle);
-    if (err != MEDIA_VISION_ERROR_NONE) {
-        printf("Fail to create engine configuration handle.\n");
-        if (handle) {
-            int err2 = mv_destroy_engine_config(handle);
-            if (err2 != MEDIA_VISION_ERROR_NONE) {
-                printf("Fail to destroy engine cofniguration.\n");
-            }
-        }
-        return err;
-    }
-
-    while (sel_opt == 0) {
-        sel_opt = show_menu("Select Actions: ", options, names, ARRAY_SIZE(options));
-        switch (sel_opt) {
-        case 1:
-            err = perform_configure_set_model_config_path(handle);
-            sel_opt = 0;
-        break;
-        case 2:
-            err = perform_configure_set_model_weights_path(handle);
-            sel_opt = 0;
-        break;
-        case 3:
-            err = perform_configure_set_input_data_type(handle);
-            sel_opt = 0;
-        break;
-        case 4:
-            err = perform_configure_set_model_userfile_path(handle);
-            sel_opt = 0;
-        break;
-        case 5:
-            err = perform_configure_set_model_mean_value(handle);
-            sel_opt = 0;
-        break;
-        case 6:
-            err = perform_configure_set_image_scale(handle);
-            sel_opt = 0;
-        break;
+	int err = MEDIA_VISION_ERROR_NONE;
+
+	int sel_opt = 0;
+	const int options[13] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 };
+	const char *names[13] = { "Set Model Configuration",
+							  "Set Model Weights",
+							  "Set Model Data Type",
+							  "Set Model UserFile",
+							  "Set Model MeanFile",
+							  "Set Image Scale",
+							  "Set Confidence Threshold",
+							  "Set Backend",
+							  "Set Target",
+							  "Set InputTensor Width",
+							  "Set InputTensor Height",
+							  "Set InputTensor Channels",
+							  "Back" };
+
+	mv_engine_config_h handle = NULL;
+	err = mv_create_engine_config(&handle);
+	if (err != MEDIA_VISION_ERROR_NONE) {
+		printf("Fail to create engine configuration handle.\n");
+		if (handle) {
+			int err2 = mv_destroy_engine_config(handle);
+			if (err2 != MEDIA_VISION_ERROR_NONE) {
+				printf("Fail to destroy engine cofniguration.\n");
+			}
+		}
+		return err;
+	}
+
+	while (sel_opt == 0) {
+		sel_opt = show_menu("Select Actions: ", options, names,
+							ARRAY_SIZE(options));
+		switch (sel_opt) {
+		case 1:
+			err = perform_configure_set_model_config_path(handle);
+			sel_opt = 0;
+			break;
+		case 2:
+			err = perform_configure_set_model_weights_path(handle);
+			sel_opt = 0;
+			break;
+		case 3:
+			err = perform_configure_set_input_data_type(handle);
+			sel_opt = 0;
+			break;
+		case 4:
+			err = perform_configure_set_model_userfile_path(handle);
+			sel_opt = 0;
+			break;
+		case 5:
+			err = perform_configure_set_model_mean_value(handle);
+			sel_opt = 0;
+			break;
+		case 6:
+			err = perform_configure_set_image_scale(handle);
+			sel_opt = 0;
+			break;
 		case 7:
 			err = perform_configure_set_confidence_threshold(handle);
 			sel_opt = 0;
-		break;
-        case 8:
-            err = perform_configure_set_backend(handle);
-            sel_opt = 0;
-        break;
-        case 9:
-            err = perform_configure_set_target(handle);
-            sel_opt = 0;
-        break;
-        case 10:
-            err = perform_configure_set_tensor_width(handle);
-            sel_opt = 0;
-        break;
-        case 11:
-            err = perform_configure_set_tensor_height(handle);
-            sel_opt = 0;
-        break;
-        case 12:
-            err = perform_configure_set_tensor_channels(handle);
-            sel_opt = 0;
-        break;
-        case 13:
-            err = MEDIA_VISION_ERROR_NONE;
-        break;
-        default:
-            printf("Invalid option.\n");
-            sel_opt = 0;
-        }
-    }
-
-
-    *engine_cfg = handle;
-    return err;
+			break;
+		case 8:
+			err = perform_configure_set_backend(handle);
+			sel_opt = 0;
+			break;
+		case 9:
+			err = perform_configure_set_target(handle);
+			sel_opt = 0;
+			break;
+		case 10:
+			err = perform_configure_set_tensor_width(handle);
+			sel_opt = 0;
+			break;
+		case 11:
+			err = perform_configure_set_tensor_height(handle);
+			sel_opt = 0;
+			break;
+		case 12:
+			err = perform_configure_set_tensor_channels(handle);
+			sel_opt = 0;
+			break;
+		case 13:
+			err = MEDIA_VISION_ERROR_NONE;
+			break;
+		default:
+			printf("Invalid option.\n");
+			sel_opt = 0;
+		}
+	}
+
+	*engine_cfg = handle;
+	return err;
 }
 
 int perform_tflite_mobilenetv1_config(mv_engine_config_h *engine_cfg)
 {
-    int err = MEDIA_VISION_ERROR_NONE;
-
-    mv_engine_config_h handle = NULL;
-    err = mv_create_engine_config(&handle);
-    if (err != MEDIA_VISION_ERROR_NONE) {
-        printf("Fail to create engine configuration handle.\n");
-        if (handle) {
-            int err2 = mv_destroy_engine_config(handle);
-            if (err2 != MEDIA_VISION_ERROR_NONE) {
-                printf("Fail to destroy engine cofniguration.\n");
-            }
-        }
-        return err;
-    }
-
-    char *inputNodeName = "input_2";
-    char *outputNodeName[1] = {"dense_3/Softmax"};
-
-    mv_engine_config_set_string_attribute(handle,
-                        MV_INFERENCE_MODEL_WEIGHT_FILE_PATH,
-                        IC_TFLITE_WEIGHT_PATH);
+	int err = MEDIA_VISION_ERROR_NONE;
 
-	mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_DATA_TYPE,
-                        MV_INFERENCE_DATA_FLOAT32);
+	mv_engine_config_h handle = NULL;
+	err = mv_create_engine_config(&handle);
+	if (err != MEDIA_VISION_ERROR_NONE) {
+		printf("Fail to create engine configuration handle.\n");
+		if (handle) {
+			int err2 = mv_destroy_engine_config(handle);
+			if (err2 != MEDIA_VISION_ERROR_NONE) {
+				printf("Fail to destroy engine cofniguration.\n");
+			}
+		}
+		return err;
+	}
+
+	char *inputNodeName = "input_2";
+	char *outputNodeName[1] = { "dense_3/Softmax" };
 
-    mv_engine_config_set_string_attribute(handle,
-                        MV_INFERENCE_MODEL_USER_FILE_PATH,
-                        IC_LABEL_PATH);
+	mv_engine_config_set_string_attribute(
+			handle, MV_INFERENCE_MODEL_WEIGHT_FILE_PATH, IC_TFLITE_WEIGHT_PATH);
 
-    mv_engine_config_set_double_attribute(handle,
-                        MV_INFERENCE_MODEL_MEAN_VALUE,
-                        127.0);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_INPUT_DATA_TYPE,
+									   MV_INFERENCE_DATA_FLOAT32);
 
-    mv_engine_config_set_double_attribute(handle,
-                        MV_INFERENCE_MODEL_STD_VALUE,
-                        127.0);
+	mv_engine_config_set_string_attribute(
+			handle, MV_INFERENCE_MODEL_USER_FILE_PATH, IC_LABEL_PATH);
 
-    mv_engine_config_set_double_attribute(handle,
-                        MV_INFERENCE_CONFIDENCE_THRESHOLD,
-                        0.6);
+	mv_engine_config_set_double_attribute(handle, MV_INFERENCE_MODEL_MEAN_VALUE,
+										  127.0);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_BACKEND_TYPE,
-                        MV_INFERENCE_BACKEND_TFLITE);
+	mv_engine_config_set_double_attribute(handle, MV_INFERENCE_MODEL_STD_VALUE,
+										  127.0);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_TARGET_TYPE,
-                        MV_INFERENCE_TARGET_CPU);
+	mv_engine_config_set_double_attribute(
+			handle, MV_INFERENCE_CONFIDENCE_THRESHOLD, 0.6);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_TENSOR_WIDTH,
-                        224);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_BACKEND_TYPE,
+									   MV_INFERENCE_BACKEND_TFLITE);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_TENSOR_HEIGHT,
-                        224);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_TARGET_TYPE,
+									   MV_INFERENCE_TARGET_CPU);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_TENSOR_CHANNELS,
-                        3);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_INPUT_TENSOR_WIDTH,
+									   224);
 
-    mv_engine_config_set_string_attribute(handle,
-                        MV_INFERENCE_INPUT_NODE_NAME,
-                        inputNodeName);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_INPUT_TENSOR_HEIGHT,
+									   224);
 
-    mv_engine_config_set_array_string_attribute(handle,
-                        MV_INFERENCE_OUTPUT_NODE_NAMES,
-                        outputNodeName,
-                        1);
+	mv_engine_config_set_int_attribute(handle,
+									   MV_INFERENCE_INPUT_TENSOR_CHANNELS, 3);
+
+	mv_engine_config_set_string_attribute(handle, MV_INFERENCE_INPUT_NODE_NAME,
+										  inputNodeName);
 
+	mv_engine_config_set_array_string_attribute(
+			handle, MV_INFERENCE_OUTPUT_NODE_NAMES, outputNodeName, 1);
 
-    *engine_cfg = handle;
-    return err;
+	*engine_cfg = handle;
+	return err;
 }
 
 int perform_armnn_mobilenetv1_config(mv_engine_config_h *engine_cfg)
 {
-    int err = MEDIA_VISION_ERROR_NONE;
-
-    mv_engine_config_h handle = NULL;
-    err = mv_create_engine_config(&handle);
-    if (err != MEDIA_VISION_ERROR_NONE) {
-        printf("Fail to create engine configuration handle.\n");
-        if (handle) {
-            int err2 = mv_destroy_engine_config(handle);
-            if (err2 != MEDIA_VISION_ERROR_NONE) {
-                printf("Fail to destroy engine cofniguration.\n");
-            }
-        }
-        return err;
-    }
-
-    char *inputNodeName = "input_2";
-    char *outputNodeName[1] = {"dense_3/Softmax"};
-
-    mv_engine_config_set_string_attribute(handle,
-                        MV_INFERENCE_MODEL_WEIGHT_FILE_PATH,
-                        IC_TFLITE_WEIGHT_PATH);
+	int err = MEDIA_VISION_ERROR_NONE;
 
-	mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_DATA_TYPE,
-                        MV_INFERENCE_DATA_FLOAT32);
+	mv_engine_config_h handle = NULL;
+	err = mv_create_engine_config(&handle);
+	if (err != MEDIA_VISION_ERROR_NONE) {
+		printf("Fail to create engine configuration handle.\n");
+		if (handle) {
+			int err2 = mv_destroy_engine_config(handle);
+			if (err2 != MEDIA_VISION_ERROR_NONE) {
+				printf("Fail to destroy engine cofniguration.\n");
+			}
+		}
+		return err;
+	}
 
-    mv_engine_config_set_string_attribute(handle,
-                        MV_INFERENCE_MODEL_USER_FILE_PATH,
-                        IC_LABEL_PATH);
+	char *inputNodeName = "input_2";
+	char *outputNodeName[1] = { "dense_3/Softmax" };
 
-    mv_engine_config_set_double_attribute(handle,
-                        MV_INFERENCE_MODEL_MEAN_VALUE,
-                        127.0);
+	mv_engine_config_set_string_attribute(
+			handle, MV_INFERENCE_MODEL_WEIGHT_FILE_PATH, IC_TFLITE_WEIGHT_PATH);
 
-    mv_engine_config_set_double_attribute(handle,
-                        MV_INFERENCE_MODEL_STD_VALUE,
-                        127.0);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_INPUT_DATA_TYPE,
+									   MV_INFERENCE_DATA_FLOAT32);
 
-    mv_engine_config_set_double_attribute(handle,
-                        MV_INFERENCE_CONFIDENCE_THRESHOLD,
-                        0.6);
+	mv_engine_config_set_string_attribute(
+			handle, MV_INFERENCE_MODEL_USER_FILE_PATH, IC_LABEL_PATH);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_BACKEND_TYPE,
-                        MV_INFERENCE_BACKEND_ARMNN);
+	mv_engine_config_set_double_attribute(handle, MV_INFERENCE_MODEL_MEAN_VALUE,
+										  127.0);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_TARGET_TYPE,
-                        MV_INFERENCE_TARGET_CPU);
+	mv_engine_config_set_double_attribute(handle, MV_INFERENCE_MODEL_STD_VALUE,
+										  127.0);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_TENSOR_WIDTH,
-                        224);
+	mv_engine_config_set_double_attribute(
+			handle, MV_INFERENCE_CONFIDENCE_THRESHOLD, 0.6);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_TENSOR_HEIGHT,
-                        224);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_BACKEND_TYPE,
+									   MV_INFERENCE_BACKEND_ARMNN);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_TENSOR_CHANNELS,
-                        3);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_TARGET_TYPE,
+									   MV_INFERENCE_TARGET_CPU);
 
-    mv_engine_config_set_string_attribute(handle,
-                        MV_INFERENCE_INPUT_NODE_NAME,
-                        inputNodeName);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_INPUT_TENSOR_WIDTH,
+									   224);
+
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_INPUT_TENSOR_HEIGHT,
+									   224);
+
+	mv_engine_config_set_int_attribute(handle,
+									   MV_INFERENCE_INPUT_TENSOR_CHANNELS, 3);
 
-    mv_engine_config_set_array_string_attribute(handle,
-                        MV_INFERENCE_OUTPUT_NODE_NAMES,
-                        outputNodeName,
-                        1);
+	mv_engine_config_set_string_attribute(handle, MV_INFERENCE_INPUT_NODE_NAME,
+										  inputNodeName);
 
+	mv_engine_config_set_array_string_attribute(
+			handle, MV_INFERENCE_OUTPUT_NODE_NAMES, outputNodeName, 1);
 
-    *engine_cfg = handle;
-    return err;
+	*engine_cfg = handle;
+	return err;
 }
 
 int perform_vivante_inceptionv3_config(mv_engine_config_h *engine_cfg)
 {
-    int err = MEDIA_VISION_ERROR_NONE;
-
-    mv_engine_config_h handle = NULL;
-    err = mv_create_engine_config(&handle);
-    if (err != MEDIA_VISION_ERROR_NONE) {
-        printf("Fail to create engine configuration handle.\n");
-        if (handle) {
-            int err2 = mv_destroy_engine_config(handle);
-            if (err2 != MEDIA_VISION_ERROR_NONE) {
-                printf("Fail to destroy engine cofniguration.\n");
-            }
-        }
-        return err;
-    }
-
-    char *inputNodeName = "input";
-    char *outputNodeName[1] = {"InceptionV3/Predictions/Peshape_1"};
-
-    mv_engine_config_set_string_attribute(handle,
-                        MV_INFERENCE_MODEL_WEIGHT_FILE_PATH,
-                        IC_VIVANTE_WEIGHT_PATH);
-
-    mv_engine_config_set_string_attribute(handle,
-                        MV_INFERENCE_MODEL_CONFIGURATION_FILE_PATH,
-                        IC_VIVANTE_CONFIG_PATH);
+	int err = MEDIA_VISION_ERROR_NONE;
 
-	mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_DATA_TYPE,
-                        MV_INFERENCE_DATA_UINT8);
+	mv_engine_config_h handle = NULL;
+	err = mv_create_engine_config(&handle);
+	if (err != MEDIA_VISION_ERROR_NONE) {
+		printf("Fail to create engine configuration handle.\n");
+		if (handle) {
+			int err2 = mv_destroy_engine_config(handle);
+			if (err2 != MEDIA_VISION_ERROR_NONE) {
+				printf("Fail to destroy engine cofniguration.\n");
+			}
+		}
+		return err;
+	}
+
+	char *inputNodeName = "input";
+	char *outputNodeName[1] = { "InceptionV3/Predictions/Peshape_1" };
+
+	mv_engine_config_set_string_attribute(handle,
+										  MV_INFERENCE_MODEL_WEIGHT_FILE_PATH,
+										  IC_VIVANTE_WEIGHT_PATH);
 
-    mv_engine_config_set_string_attribute(handle,
-                        MV_INFERENCE_MODEL_USER_FILE_PATH,
-                        IC_VIVANTE_LABEL_PATH);
+	mv_engine_config_set_string_attribute(
+			handle, MV_INFERENCE_MODEL_CONFIGURATION_FILE_PATH,
+			IC_VIVANTE_CONFIG_PATH);
 
-    mv_engine_config_set_double_attribute(handle,
-                        MV_INFERENCE_MODEL_MEAN_VALUE,
-                        0.0);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_INPUT_DATA_TYPE,
+									   MV_INFERENCE_DATA_UINT8);
 
-    mv_engine_config_set_double_attribute(handle,
-                        MV_INFERENCE_MODEL_STD_VALUE,
-                        1.0);
+	mv_engine_config_set_string_attribute(
+			handle, MV_INFERENCE_MODEL_USER_FILE_PATH, IC_VIVANTE_LABEL_PATH);
 
-    mv_engine_config_set_double_attribute(handle,
-                        MV_INFERENCE_CONFIDENCE_THRESHOLD,
-                        0.6);
+	mv_engine_config_set_double_attribute(handle, MV_INFERENCE_MODEL_MEAN_VALUE,
+										  0.0);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_BACKEND_TYPE,
-                        MV_INFERENCE_BACKEND_MLAPI);
+	mv_engine_config_set_double_attribute(handle, MV_INFERENCE_MODEL_STD_VALUE,
+										  1.0);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_TARGET_DEVICE_TYPE,
-                        MV_INFERENCE_TARGET_DEVICE_CUSTOM);
+	mv_engine_config_set_double_attribute(
+			handle, MV_INFERENCE_CONFIDENCE_THRESHOLD, 0.6);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_TENSOR_WIDTH,
-                        299);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_BACKEND_TYPE,
+									   MV_INFERENCE_BACKEND_MLAPI);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_TENSOR_HEIGHT,
-                        299);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_TARGET_DEVICE_TYPE,
+									   MV_INFERENCE_TARGET_DEVICE_CUSTOM);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_TENSOR_CHANNELS,
-                        3);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_INPUT_TENSOR_WIDTH,
+									   299);
 
-    mv_engine_config_set_string_attribute(handle,
-                        MV_INFERENCE_INPUT_NODE_NAME,
-                        inputNodeName);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_INPUT_TENSOR_HEIGHT,
+									   299);
 
-    mv_engine_config_set_array_string_attribute(handle,
-                        MV_INFERENCE_OUTPUT_NODE_NAMES,
-                        outputNodeName,
-                        1);
+	mv_engine_config_set_int_attribute(handle,
+									   MV_INFERENCE_INPUT_TENSOR_CHANNELS, 3);
+
+	mv_engine_config_set_string_attribute(handle, MV_INFERENCE_INPUT_NODE_NAME,
+										  inputNodeName);
 
+	mv_engine_config_set_array_string_attribute(
+			handle, MV_INFERENCE_OUTPUT_NODE_NAMES, outputNodeName, 1);
 
-    *engine_cfg = handle;
-    return err;
+	*engine_cfg = handle;
+	return err;
 }
 
 int perform_opencv_caffe_squeezenet_config(mv_engine_config_h *engine_cfg)
 {
-    int err = MEDIA_VISION_ERROR_NONE;
-
-    mv_engine_config_h handle = NULL;
-    err = mv_create_engine_config(&handle);
-    if (err != MEDIA_VISION_ERROR_NONE) {
-        printf("Fail to create engine configuration handle.\n");
-        if (handle) {
-            int err2 = mv_destroy_engine_config(handle);
-            if (err2 != MEDIA_VISION_ERROR_NONE) {
-                printf("Fail to destroy engine cofniguration.\n");
-            }
-        }
-        return err;
-    }
-
-    char *inputNodeName = "data";
-    char *outputNodeName[1] = {"prob"};
-
-    mv_engine_config_set_string_attribute(handle,
-                        MV_INFERENCE_MODEL_WEIGHT_FILE_PATH,
-                        IC_OPENCV_WEIGHT_CAFFE_PATH);
+	int err = MEDIA_VISION_ERROR_NONE;
 
-	mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_DATA_TYPE,
-                        MV_INFERENCE_DATA_FLOAT32);
+	mv_engine_config_h handle = NULL;
+	err = mv_create_engine_config(&handle);
+	if (err != MEDIA_VISION_ERROR_NONE) {
+		printf("Fail to create engine configuration handle.\n");
+		if (handle) {
+			int err2 = mv_destroy_engine_config(handle);
+			if (err2 != MEDIA_VISION_ERROR_NONE) {
+				printf("Fail to destroy engine cofniguration.\n");
+			}
+		}
+		return err;
+	}
 
-    mv_engine_config_set_string_attribute(handle,
-                        MV_INFERENCE_MODEL_CONFIGURATION_FILE_PATH,
-                        IC_OPENCV_CONFIG_CAFFE_PATH);
+	char *inputNodeName = "data";
+	char *outputNodeName[1] = { "prob" };
 
-    mv_engine_config_set_string_attribute(handle,
-                        MV_INFERENCE_MODEL_USER_FILE_PATH,
-                        IC_OPENCV_LABEL_CAFFE_PATH);
+	mv_engine_config_set_string_attribute(handle,
+										  MV_INFERENCE_MODEL_WEIGHT_FILE_PATH,
+										  IC_OPENCV_WEIGHT_CAFFE_PATH);
 
-    mv_engine_config_set_double_attribute(handle,
-                        MV_INFERENCE_MODEL_MEAN_VALUE,
-                        0.0);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_INPUT_DATA_TYPE,
+									   MV_INFERENCE_DATA_FLOAT32);
 
-    mv_engine_config_set_double_attribute(handle,
-                        MV_INFERENCE_MODEL_STD_VALUE,
-                        1.0);
+	mv_engine_config_set_string_attribute(
+			handle, MV_INFERENCE_MODEL_CONFIGURATION_FILE_PATH,
+			IC_OPENCV_CONFIG_CAFFE_PATH);
 
-    mv_engine_config_set_double_attribute(handle,
-                        MV_INFERENCE_CONFIDENCE_THRESHOLD,
-                        0.3);
+	mv_engine_config_set_string_attribute(handle,
+										  MV_INFERENCE_MODEL_USER_FILE_PATH,
+										  IC_OPENCV_LABEL_CAFFE_PATH);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_BACKEND_TYPE,
-                        MV_INFERENCE_BACKEND_OPENCV);
+	mv_engine_config_set_double_attribute(handle, MV_INFERENCE_MODEL_MEAN_VALUE,
+										  0.0);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_TARGET_TYPE,
-                        MV_INFERENCE_TARGET_CPU);
+	mv_engine_config_set_double_attribute(handle, MV_INFERENCE_MODEL_STD_VALUE,
+										  1.0);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_TENSOR_WIDTH,
-                        227);
+	mv_engine_config_set_double_attribute(
+			handle, MV_INFERENCE_CONFIDENCE_THRESHOLD, 0.3);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_TENSOR_HEIGHT,
-                        227);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_BACKEND_TYPE,
+									   MV_INFERENCE_BACKEND_OPENCV);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_TENSOR_CHANNELS,
-                        3);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_TARGET_TYPE,
+									   MV_INFERENCE_TARGET_CPU);
 
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_INPUT_TENSOR_WIDTH,
+									   227);
 
-    mv_engine_config_set_string_attribute(handle,
-                        MV_INFERENCE_INPUT_NODE_NAME,
-                        inputNodeName);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_INPUT_TENSOR_HEIGHT,
+									   227);
 
-    mv_engine_config_set_array_string_attribute(handle,
-                        MV_INFERENCE_OUTPUT_NODE_NAMES,
-                        outputNodeName,
-                        1);
+	mv_engine_config_set_int_attribute(handle,
+									   MV_INFERENCE_INPUT_TENSOR_CHANNELS, 3);
 
-    *engine_cfg = handle;
-    return err;
-}
+	mv_engine_config_set_string_attribute(handle, MV_INFERENCE_INPUT_NODE_NAME,
+										  inputNodeName);
+
+	mv_engine_config_set_array_string_attribute(
+			handle, MV_INFERENCE_OUTPUT_NODE_NAMES, outputNodeName, 1);
 
+	*engine_cfg = handle;
+	return err;
+}
 
 int perform_image_classification()
 {
-    int err = MEDIA_VISION_ERROR_NONE;
-
-    int sel_opt = 0;
-    const int options[8] = { 1, 2, 3, 4, 5, 6, 7, 8};
-    const char *names[8] = { "Configuration",
-                             "TFLite(cpu + Mobilenet)",
-                             "OpenCV(cpu + Squeezenet)",
-                             "ARMNN(cpu + Mobilenet)",
-                             "Vivante(NPU + Inceptionv3)",
-                             "Prepare",
-                             "Run",
-                             "Back"};
-
-    mv_engine_config_h engine_cfg = NULL;
-    mv_inference_h infer = NULL;
-    mv_source_h mvSource = NULL;
-
-    while(sel_opt == 0) {
-        sel_opt = show_menu("Select Action:", options, names, ARRAY_SIZE(options));
-        switch (sel_opt) {
-        case 1:
-        {
-            //perform configuration
-            if (engine_cfg) {
-                int err2 = mv_destroy_engine_config(engine_cfg);
-                if (err2 != MEDIA_VISION_ERROR_NONE)
-                    printf("Fail to destroy engine_cfg [err:%i]\n", err2);
-                engine_cfg = NULL;
-            }
-
-            err = perform_configuration(&engine_cfg);
-        }
-            break;
-        case 2:
-        {
-            // perform TFLite
-            if (engine_cfg) {
-                int err2 = mv_destroy_engine_config(engine_cfg);
-                if (err2 != MEDIA_VISION_ERROR_NONE)
-                    printf("Fail to destroy engine_cfg [err:%i]\n", err2);
-                engine_cfg = NULL;
-            }
-
-            err = perform_tflite_mobilenetv1_config(&engine_cfg);
-        }
-            break;
-
-        case 3:
-        {
-            // perform OpenCV
-            if (engine_cfg) {
-                int err2 = mv_destroy_engine_config(engine_cfg);
-                if (err2 != MEDIA_VISION_ERROR_NONE)
-                    printf("Fail to destroy engine_cfg [err:%i]\n", err2);
-                engine_cfg = NULL;
-            }
-
-            err = perform_opencv_caffe_squeezenet_config(&engine_cfg);
-        }
-            break;
-        case 4:
-        {
-            // perform ARMNN
-            if (engine_cfg) {
-                int err2 = mv_destroy_engine_config(engine_cfg);
-                if (err2 != MEDIA_VISION_ERROR_NONE)
-                    printf("Fail to destroy engine_cfg [err:%i]\n", err2);
-            }
-
-            err = perform_armnn_mobilenetv1_config(&engine_cfg);
-        }
-            break;
-        case 5:
-        {
-            // perform Vivante
-            if (engine_cfg) {
-                int err2 = mv_destroy_engine_config(engine_cfg);
-                if (err2 != MEDIA_VISION_ERROR_NONE)
-                    printf("Fail to destroy engine_cfg [err:%i]\n", err2);
-            }
-
-            err = perform_vivante_inceptionv3_config(&engine_cfg);
-        }
-            break;
-        case 6:
-        {
-            //create - configure - prepare
-            if (infer) {
-                int err2 = mv_inference_destroy(infer);
-                if (err2 != MEDIA_VISION_ERROR_NONE)
-                    printf("Fail to destroy inference handle [err:%i]\n", err2);
-                infer = NULL;
-            }
-
-            // inference
-            // create handle
-            err = mv_inference_create(&infer);
-            if (err != MEDIA_VISION_ERROR_NONE) {
-                printf("Fail to create inference handle [err:%i]\n", err);
-                break;
-            }
-
-            // configure
-            err = mv_inference_configure(infer, engine_cfg);
-            if (err != MEDIA_VISION_ERROR_NONE) {
-                printf("Fail to configure inference handle\n");
-                break;
-            }
-
-            // prepare
-            err = mv_inference_prepare(infer);
-            if (err != MEDIA_VISION_ERROR_NONE) {
-                printf("Fail to prepare inference handle.");
-                break;
-            }
-        }
-            break;
-        case 7:
-        {
-            if (mvSource) {
-                int err2 = mv_destroy_source(mvSource);
-                if (err2 != MEDIA_VISION_ERROR_NONE)
-                    printf("Fail to destroy mvSource.\n");
-                mvSource = NULL;
-            }
-
-            char *in_file_name = NULL;
-            /* Load media source */
-            while (input_string("Input file name to be inferred:", 1024, &(in_file_name)) == -1)
-                printf("Incorrect input! Try again.\n");
-
-            err = mv_create_source(&mvSource);
-            if (err != MEDIA_VISION_ERROR_NONE) {
-                printf("Fail to create mvSource.\n");
-                free(in_file_name);
-                break;
-            }
-
-            err = load_mv_source_from_file(in_file_name, mvSource);
-            if (MEDIA_VISION_ERROR_NONE != err) {
-                int err2 = mv_destroy_source(mvSource);
-                if (err2 != MEDIA_VISION_ERROR_NONE)
-                    printf("Fail to destroy mvSource.\n", err2);
-                mvSource = NULL;
-                free(in_file_name);
-                break;
-            }
-            free(in_file_name);
-
-            struct timespec s_tspec;
-            struct timespec e_tspec;
-
-            clock_gettime(CLOCK_MONOTONIC, &s_tspec);
-
-            // Run
-            err = mv_inference_image_classify(mvSource, infer, NULL, _image_classified_cb, NULL);
-
-            clock_gettime(CLOCK_MONOTONIC, &e_tspec);
-
-            struct timespec diffspec = diff(s_tspec, e_tspec);
-            unsigned long timeDiff = gettotalmillisec(diffspec);
-            printf("elased time : %lu(ms)\n", timeDiff);
-
-        }
-            break;
-        case 8:
-        {
-            //perform destroy
-            if (engine_cfg) {
-                err = mv_destroy_engine_config(engine_cfg);
-                if (err != MEDIA_VISION_ERROR_NONE)
-                    printf("Fail to destroy engine_cfg [err:%i]\n", err);
-                engine_cfg = NULL;
-            }
-
-            if (infer) {
-                err = mv_inference_destroy(infer);
-                if (err != MEDIA_VISION_ERROR_NONE)
-                    printf("Fail to destroy inference handle [err:%i]\n", err);
-                infer = NULL;
-            }
-
-            if (mvSource) {
-                err = mv_destroy_source(mvSource);
-                if (err != MEDIA_VISION_ERROR_NONE)
-                    printf("Fail to destroy mvSource [err:%i]\n", err);
-                mvSource = NULL;
-            }
-        }
-            break;
-        default:
-            printf("Invalid option.\n");
-            sel_opt = 0;
-            continue;
-        }
-
-        int do_another = 0;
-        if (err != MEDIA_VISION_ERROR_NONE) {
-            printf("ERROR: Action is finished with error code: %i\n");
-        }
-
-        sel_opt = 0;
-        const int options_last[2] = { 1, 2 };
-        const char *names_last[2] = { "Yes", "No" };
-
-        while (sel_opt == 0) {
-            sel_opt = show_menu("Run Image Classification again?: ", options_last, names_last, ARRAY_SIZE(options_last));
-            switch (sel_opt) {
-            case 1:
-                do_another = 1;
-                break;
-            case 2:
-                do_another = 0;
-                break;
-            default:
-                printf("Invalid option.\n");
-                sel_opt = 0;
-            }
-        }
-
-        sel_opt = (do_another == 1) ? 0 : 1;
-    }
-
-    if (engine_cfg) {
-        err = mv_destroy_engine_config(engine_cfg);
-        if (err != MEDIA_VISION_ERROR_NONE)
-            printf("Fail to destroy engine_cfg [err:%i]\n", err);
-        engine_cfg = NULL;
-    }
-
-    if (infer) {
-        err = mv_inference_destroy(infer);
-        if (err != MEDIA_VISION_ERROR_NONE)
-            printf("Fail to destroy inference handle [err:%i]\n", err);
-        infer = NULL;
-    }
-
-    if (mvSource) {
-        err = mv_destroy_source(mvSource);
-        if (err != MEDIA_VISION_ERROR_NONE)
-            printf("Fail to destroy mvSource [err:%i]\n", err);
-        mvSource = NULL;
-    }
-
-    return MEDIA_VISION_ERROR_NONE;
+	int err = MEDIA_VISION_ERROR_NONE;
+
+	int sel_opt = 0;
+	const int options[8] = { 1, 2, 3, 4, 5, 6, 7, 8 };
+	const char *names[8] = { "Configuration",
+							 "TFLite(cpu + Mobilenet)",
+							 "OpenCV(cpu + Squeezenet)",
+							 "ARMNN(cpu + Mobilenet)",
+							 "Vivante(NPU + Inceptionv3)",
+							 "Prepare",
+							 "Run",
+							 "Back" };
+
+	mv_engine_config_h engine_cfg = NULL;
+	mv_inference_h infer = NULL;
+	mv_source_h mvSource = NULL;
+
+	while (sel_opt == 0) {
+		sel_opt = show_menu("Select Action:", options, names,
+							ARRAY_SIZE(options));
+		switch (sel_opt) {
+		case 1: {
+			//perform configuration
+			if (engine_cfg) {
+				int err2 = mv_destroy_engine_config(engine_cfg);
+				if (err2 != MEDIA_VISION_ERROR_NONE)
+					printf("Fail to destroy engine_cfg [err:%i]\n", err2);
+				engine_cfg = NULL;
+			}
+
+			err = perform_configuration(&engine_cfg);
+		} break;
+		case 2: {
+			// perform TFLite
+			if (engine_cfg) {
+				int err2 = mv_destroy_engine_config(engine_cfg);
+				if (err2 != MEDIA_VISION_ERROR_NONE)
+					printf("Fail to destroy engine_cfg [err:%i]\n", err2);
+				engine_cfg = NULL;
+			}
+
+			err = perform_tflite_mobilenetv1_config(&engine_cfg);
+		} break;
+
+		case 3: {
+			// perform OpenCV
+			if (engine_cfg) {
+				int err2 = mv_destroy_engine_config(engine_cfg);
+				if (err2 != MEDIA_VISION_ERROR_NONE)
+					printf("Fail to destroy engine_cfg [err:%i]\n", err2);
+				engine_cfg = NULL;
+			}
+
+			err = perform_opencv_caffe_squeezenet_config(&engine_cfg);
+		} break;
+		case 4: {
+			// perform ARMNN
+			if (engine_cfg) {
+				int err2 = mv_destroy_engine_config(engine_cfg);
+				if (err2 != MEDIA_VISION_ERROR_NONE)
+					printf("Fail to destroy engine_cfg [err:%i]\n", err2);
+			}
+
+			err = perform_armnn_mobilenetv1_config(&engine_cfg);
+		} break;
+		case 5: {
+			// perform Vivante
+			if (engine_cfg) {
+				int err2 = mv_destroy_engine_config(engine_cfg);
+				if (err2 != MEDIA_VISION_ERROR_NONE)
+					printf("Fail to destroy engine_cfg [err:%i]\n", err2);
+			}
+
+			err = perform_vivante_inceptionv3_config(&engine_cfg);
+		} break;
+		case 6: {
+			//create - configure - prepare
+			if (infer) {
+				int err2 = mv_inference_destroy(infer);
+				if (err2 != MEDIA_VISION_ERROR_NONE)
+					printf("Fail to destroy inference handle [err:%i]\n", err2);
+				infer = NULL;
+			}
+
+			// inference
+			// create handle
+			err = mv_inference_create(&infer);
+			if (err != MEDIA_VISION_ERROR_NONE) {
+				printf("Fail to create inference handle [err:%i]\n", err);
+				break;
+			}
+
+			// configure
+			err = mv_inference_configure(infer, engine_cfg);
+			if (err != MEDIA_VISION_ERROR_NONE) {
+				printf("Fail to configure inference handle\n");
+				break;
+			}
+
+			// prepare
+			err = mv_inference_prepare(infer);
+			if (err != MEDIA_VISION_ERROR_NONE) {
+				printf("Fail to prepare inference handle.");
+				break;
+			}
+		} break;
+		case 7: {
+			if (mvSource) {
+				int err2 = mv_destroy_source(mvSource);
+				if (err2 != MEDIA_VISION_ERROR_NONE)
+					printf("Fail to destroy mvSource.\n");
+				mvSource = NULL;
+			}
+
+			char *in_file_name = NULL;
+			/* Load media source */
+			while (input_string("Input file name to be inferred:", 1024,
+								&(in_file_name)) == -1)
+				printf("Incorrect input! Try again.\n");
+
+			err = mv_create_source(&mvSource);
+			if (err != MEDIA_VISION_ERROR_NONE) {
+				printf("Fail to create mvSource.\n");
+				free(in_file_name);
+				break;
+			}
+
+			err = load_mv_source_from_file(in_file_name, mvSource);
+			if (MEDIA_VISION_ERROR_NONE != err) {
+				int err2 = mv_destroy_source(mvSource);
+				if (err2 != MEDIA_VISION_ERROR_NONE)
+					printf("Fail to destroy mvSource.\n", err2);
+				mvSource = NULL;
+				free(in_file_name);
+				break;
+			}
+			free(in_file_name);
+
+			struct timespec s_tspec;
+			struct timespec e_tspec;
+
+			clock_gettime(CLOCK_MONOTONIC, &s_tspec);
+
+			// Run
+			err = mv_inference_image_classify(mvSource, infer, NULL,
+											  _image_classified_cb, NULL);
+
+			clock_gettime(CLOCK_MONOTONIC, &e_tspec);
+
+			struct timespec diffspec = diff(s_tspec, e_tspec);
+			unsigned long timeDiff = gettotalmillisec(diffspec);
+			printf("elased time : %lu(ms)\n", timeDiff);
+
+		} break;
+		case 8: {
+			//perform destroy
+			if (engine_cfg) {
+				err = mv_destroy_engine_config(engine_cfg);
+				if (err != MEDIA_VISION_ERROR_NONE)
+					printf("Fail to destroy engine_cfg [err:%i]\n", err);
+				engine_cfg = NULL;
+			}
+
+			if (infer) {
+				err = mv_inference_destroy(infer);
+				if (err != MEDIA_VISION_ERROR_NONE)
+					printf("Fail to destroy inference handle [err:%i]\n", err);
+				infer = NULL;
+			}
+
+			if (mvSource) {
+				err = mv_destroy_source(mvSource);
+				if (err != MEDIA_VISION_ERROR_NONE)
+					printf("Fail to destroy mvSource [err:%i]\n", err);
+				mvSource = NULL;
+			}
+		} break;
+		default:
+			printf("Invalid option.\n");
+			sel_opt = 0;
+			continue;
+		}
+
+		int do_another = 0;
+		if (err != MEDIA_VISION_ERROR_NONE) {
+			printf("ERROR: Action is finished with error code: %i\n");
+		}
+
+		sel_opt = 0;
+		const int options_last[2] = { 1, 2 };
+		const char *names_last[2] = { "Yes", "No" };
+
+		while (sel_opt == 0) {
+			sel_opt =
+					show_menu("Run Image Classification again?: ", options_last,
+							  names_last, ARRAY_SIZE(options_last));
+			switch (sel_opt) {
+			case 1:
+				do_another = 1;
+				break;
+			case 2:
+				do_another = 0;
+				break;
+			default:
+				printf("Invalid option.\n");
+				sel_opt = 0;
+			}
+		}
+
+		sel_opt = (do_another == 1) ? 0 : 1;
+	}
+
+	if (engine_cfg) {
+		err = mv_destroy_engine_config(engine_cfg);
+		if (err != MEDIA_VISION_ERROR_NONE)
+			printf("Fail to destroy engine_cfg [err:%i]\n", err);
+		engine_cfg = NULL;
+	}
+
+	if (infer) {
+		err = mv_inference_destroy(infer);
+		if (err != MEDIA_VISION_ERROR_NONE)
+			printf("Fail to destroy inference handle [err:%i]\n", err);
+		infer = NULL;
+	}
+
+	if (mvSource) {
+		err = mv_destroy_source(mvSource);
+		if (err != MEDIA_VISION_ERROR_NONE)
+			printf("Fail to destroy mvSource [err:%i]\n", err);
+		mvSource = NULL;
+	}
+
+	return MEDIA_VISION_ERROR_NONE;
 }
 
 /*
@@ -1153,1640 +1033,1485 @@ int perform_image_classification()
  */
 int perform_tflite_mobilenetv1ssd_config(mv_engine_config_h *engine_cfg)
 {
-    int err = MEDIA_VISION_ERROR_NONE;
-
-    mv_engine_config_h handle = NULL;
-    err = mv_create_engine_config(&handle);
-    if (err != MEDIA_VISION_ERROR_NONE) {
-        printf("Fail to create engine configuration handle.\n");
-        if (handle) {
-            int err2 = mv_destroy_engine_config(handle);
-            if (err2 != MEDIA_VISION_ERROR_NONE) {
-                printf("Fail to destroy engine cofniguration.\n");
-            }
-        }
-        return err;
-    }
+	int err = MEDIA_VISION_ERROR_NONE;
 
+	mv_engine_config_h handle = NULL;
+	err = mv_create_engine_config(&handle);
+	if (err != MEDIA_VISION_ERROR_NONE) {
+		printf("Fail to create engine configuration handle.\n");
+		if (handle) {
+			int err2 = mv_destroy_engine_config(handle);
+			if (err2 != MEDIA_VISION_ERROR_NONE) {
+				printf("Fail to destroy engine cofniguration.\n");
+			}
+		}
+		return err;
+	}
 
-    char *inputNodeName = "normalized_input_image_tensor";
-    char *outputNodeName[4] = {"TFLite_Detection_PostProcess", "TFLite_Detection_PostProcess:1", "TFLite_Detection_PostProcess:2", "TFLite_Detection_PostProcess:3"};
+	char *inputNodeName = "normalized_input_image_tensor";
+	char *outputNodeName[4] = { "TFLite_Detection_PostProcess",
+								"TFLite_Detection_PostProcess:1",
+								"TFLite_Detection_PostProcess:2",
+								"TFLite_Detection_PostProcess:3" };
 
-    mv_engine_config_set_string_attribute(handle,
-                        MV_INFERENCE_MODEL_WEIGHT_FILE_PATH,
-                        OD_TFLITE_WEIGHT_PATH);
+	mv_engine_config_set_string_attribute(
+			handle, MV_INFERENCE_MODEL_WEIGHT_FILE_PATH, OD_TFLITE_WEIGHT_PATH);
 
-	mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_DATA_TYPE,
-                        MV_INFERENCE_DATA_FLOAT32);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_INPUT_DATA_TYPE,
+									   MV_INFERENCE_DATA_FLOAT32);
 
-    mv_engine_config_set_string_attribute(handle,
-                        MV_INFERENCE_MODEL_USER_FILE_PATH,
-                        OD_LABEL_PATH);
+	mv_engine_config_set_string_attribute(
+			handle, MV_INFERENCE_MODEL_USER_FILE_PATH, OD_LABEL_PATH);
 
-    mv_engine_config_set_double_attribute(handle,
-                        MV_INFERENCE_MODEL_MEAN_VALUE,
-                        127.5);
+	mv_engine_config_set_double_attribute(handle, MV_INFERENCE_MODEL_MEAN_VALUE,
+										  127.5);
 
-    mv_engine_config_set_double_attribute(handle,
-                        MV_INFERENCE_MODEL_STD_VALUE,
-                        127.5);
+	mv_engine_config_set_double_attribute(handle, MV_INFERENCE_MODEL_STD_VALUE,
+										  127.5);
 
-    mv_engine_config_set_double_attribute(handle,
-                        MV_INFERENCE_CONFIDENCE_THRESHOLD,
-                        0.3);
+	mv_engine_config_set_double_attribute(
+			handle, MV_INFERENCE_CONFIDENCE_THRESHOLD, 0.3);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_BACKEND_TYPE,
-                        MV_INFERENCE_BACKEND_TFLITE);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_BACKEND_TYPE,
+									   MV_INFERENCE_BACKEND_TFLITE);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_TARGET_TYPE,
-                        MV_INFERENCE_TARGET_CPU);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_TARGET_TYPE,
+									   MV_INFERENCE_TARGET_CPU);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_TENSOR_WIDTH,
-                        300);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_INPUT_TENSOR_WIDTH,
+									   300);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_TENSOR_HEIGHT,
-                        300);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_INPUT_TENSOR_HEIGHT,
+									   300);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_TENSOR_CHANNELS,
-                        3);
+	mv_engine_config_set_int_attribute(handle,
+									   MV_INFERENCE_INPUT_TENSOR_CHANNELS, 3);
 
-    mv_engine_config_set_string_attribute(handle,
-                        MV_INFERENCE_INPUT_NODE_NAME,
-                        inputNodeName);
+	mv_engine_config_set_string_attribute(handle, MV_INFERENCE_INPUT_NODE_NAME,
+										  inputNodeName);
 
-    mv_engine_config_set_array_string_attribute(handle,
-                        MV_INFERENCE_OUTPUT_NODE_NAMES,
-                        outputNodeName,
-                        4);
+	mv_engine_config_set_array_string_attribute(
+			handle, MV_INFERENCE_OUTPUT_NODE_NAMES, outputNodeName, 4);
 
-    *engine_cfg = handle;
-    return err;
+	*engine_cfg = handle;
+	return err;
 }
 
 int perform_opencv_mobilenetv1ssd_config(mv_engine_config_h *engine_cfg)
 {
-    int err = MEDIA_VISION_ERROR_NONE;
-
-    mv_engine_config_h handle = NULL;
-    err = mv_create_engine_config(&handle);
-    if (err != MEDIA_VISION_ERROR_NONE) {
-        printf("Fail to create engine configuration handle.\n");
-        if (handle) {
-            int err2 = mv_destroy_engine_config(handle);
-            if (err2 != MEDIA_VISION_ERROR_NONE) {
-                printf("Fail to destroy engine cofniguration.\n");
-            }
-        }
-        return err;
-    }
-
-
-    char *inputNodeName = "data";
-    char *outputNodeName[1] = {"detection_out"};
-
-    mv_engine_config_set_string_attribute(handle,
-                        MV_INFERENCE_MODEL_WEIGHT_FILE_PATH,
-                        OD_OPENCV_WEIGHT_CAFFE_PATH);
-
-    mv_engine_config_set_string_attribute(handle,
-                        MV_INFERENCE_MODEL_CONFIGURATION_FILE_PATH,
-                        OD_OPENCV_CONFIG_CAFFE_PATH);
-
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_DATA_TYPE,
-                        MV_INFERENCE_DATA_FLOAT32);
-
-    mv_engine_config_set_string_attribute(handle,
-                        MV_INFERENCE_MODEL_USER_FILE_PATH,
-                        OD_OPENCV_LABEL_CAFFE_PATH);
-
-    mv_engine_config_set_double_attribute(handle,
-                        MV_INFERENCE_MODEL_MEAN_VALUE,
-                        127.5);
-
-    mv_engine_config_set_double_attribute(handle,
-                        MV_INFERENCE_MODEL_STD_VALUE,
-                        127.5);
-
-    mv_engine_config_set_double_attribute(handle,
-                        MV_INFERENCE_CONFIDENCE_THRESHOLD,
-                        0.3);
-
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_BACKEND_TYPE,
-                        MV_INFERENCE_BACKEND_OPENCV);
-
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_TARGET_TYPE,
-                        MV_INFERENCE_TARGET_CPU);
-
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_TENSOR_WIDTH,
-                        300);
-
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_TENSOR_HEIGHT,
-                        300);
-
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_TENSOR_CHANNELS,
-                        3);
-
-    mv_engine_config_set_string_attribute(handle,
-                        MV_INFERENCE_INPUT_NODE_NAME,
-                        inputNodeName);
-
-    mv_engine_config_set_array_string_attribute(handle,
-                        MV_INFERENCE_OUTPUT_NODE_NAMES,
-                        outputNodeName,
-                        1);
-
-    *engine_cfg = handle;
-    return err;
-}
+	int err = MEDIA_VISION_ERROR_NONE;
 
+	mv_engine_config_h handle = NULL;
+	err = mv_create_engine_config(&handle);
+	if (err != MEDIA_VISION_ERROR_NONE) {
+		printf("Fail to create engine configuration handle.\n");
+		if (handle) {
+			int err2 = mv_destroy_engine_config(handle);
+			if (err2 != MEDIA_VISION_ERROR_NONE) {
+				printf("Fail to destroy engine cofniguration.\n");
+			}
+		}
+		return err;
+	}
 
-int perform_armnn_mobilenetv1ssd_config(mv_engine_config_h *engine_cfg)
-{
-    int err = MEDIA_VISION_ERROR_NONE;
+	char *inputNodeName = "data";
+	char *outputNodeName[1] = { "detection_out" };
+
+	mv_engine_config_set_string_attribute(handle,
+										  MV_INFERENCE_MODEL_WEIGHT_FILE_PATH,
+										  OD_OPENCV_WEIGHT_CAFFE_PATH);
+
+	mv_engine_config_set_string_attribute(
+			handle, MV_INFERENCE_MODEL_CONFIGURATION_FILE_PATH,
+			OD_OPENCV_CONFIG_CAFFE_PATH);
+
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_INPUT_DATA_TYPE,
+									   MV_INFERENCE_DATA_FLOAT32);
+
+	mv_engine_config_set_string_attribute(handle,
+										  MV_INFERENCE_MODEL_USER_FILE_PATH,
+										  OD_OPENCV_LABEL_CAFFE_PATH);
+
+	mv_engine_config_set_double_attribute(handle, MV_INFERENCE_MODEL_MEAN_VALUE,
+										  127.5);
+
+	mv_engine_config_set_double_attribute(handle, MV_INFERENCE_MODEL_STD_VALUE,
+										  127.5);
+
+	mv_engine_config_set_double_attribute(
+			handle, MV_INFERENCE_CONFIDENCE_THRESHOLD, 0.3);
 
-    mv_engine_config_h handle = NULL;
-    err = mv_create_engine_config(&handle);
-    if (err != MEDIA_VISION_ERROR_NONE) {
-        printf("Fail to create engine configuration handle.\n");
-        if (handle) {
-            int err2 = mv_destroy_engine_config(handle);
-            if (err2 != MEDIA_VISION_ERROR_NONE) {
-                printf("Fail to destroy engine cofniguration.\n");
-            }
-        }
-        return err;
-    }
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_BACKEND_TYPE,
+									   MV_INFERENCE_BACKEND_OPENCV);
 
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_TARGET_TYPE,
+									   MV_INFERENCE_TARGET_CPU);
 
-    char *inputNodeName = "normalized_input_image_tensor";
-    char *outputNodeName[4] = {"TFLite_Detection_PostProcess", "TFLite_Detection_PostProcess:1", "TFLite_Detection_PostProcess:2", "TFLite_Detection_PostProcess:3"};
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_INPUT_TENSOR_WIDTH,
+									   300);
 
-    mv_engine_config_set_string_attribute(handle,
-                        MV_INFERENCE_MODEL_WEIGHT_FILE_PATH,
-                        OD_TFLITE_WEIGHT_PATH);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_INPUT_TENSOR_HEIGHT,
+									   300);
 
 	mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_DATA_TYPE,
-                        MV_INFERENCE_DATA_FLOAT32);
+									   MV_INFERENCE_INPUT_TENSOR_CHANNELS, 3);
 
-    mv_engine_config_set_string_attribute(handle,
-                        MV_INFERENCE_MODEL_USER_FILE_PATH,
-                        OD_LABEL_PATH);
+	mv_engine_config_set_string_attribute(handle, MV_INFERENCE_INPUT_NODE_NAME,
+										  inputNodeName);
 
-    mv_engine_config_set_double_attribute(handle,
-                        MV_INFERENCE_MODEL_MEAN_VALUE,
-                        127.5);
+	mv_engine_config_set_array_string_attribute(
+			handle, MV_INFERENCE_OUTPUT_NODE_NAMES, outputNodeName, 1);
 
-    mv_engine_config_set_double_attribute(handle,
-                        MV_INFERENCE_MODEL_STD_VALUE,
-                        127.5);
+	*engine_cfg = handle;
+	return err;
+}
+
+int perform_armnn_mobilenetv1ssd_config(mv_engine_config_h *engine_cfg)
+{
+	int err = MEDIA_VISION_ERROR_NONE;
 
-    mv_engine_config_set_double_attribute(handle,
-                        MV_INFERENCE_CONFIDENCE_THRESHOLD,
-                        0.3);
+	mv_engine_config_h handle = NULL;
+	err = mv_create_engine_config(&handle);
+	if (err != MEDIA_VISION_ERROR_NONE) {
+		printf("Fail to create engine configuration handle.\n");
+		if (handle) {
+			int err2 = mv_destroy_engine_config(handle);
+			if (err2 != MEDIA_VISION_ERROR_NONE) {
+				printf("Fail to destroy engine cofniguration.\n");
+			}
+		}
+		return err;
+	}
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_BACKEND_TYPE,
-                        MV_INFERENCE_BACKEND_ARMNN);
+	char *inputNodeName = "normalized_input_image_tensor";
+	char *outputNodeName[4] = { "TFLite_Detection_PostProcess",
+								"TFLite_Detection_PostProcess:1",
+								"TFLite_Detection_PostProcess:2",
+								"TFLite_Detection_PostProcess:3" };
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_TARGET_TYPE,
-                        MV_INFERENCE_TARGET_CPU);
+	mv_engine_config_set_string_attribute(
+			handle, MV_INFERENCE_MODEL_WEIGHT_FILE_PATH, OD_TFLITE_WEIGHT_PATH);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_TENSOR_WIDTH,
-                        300);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_INPUT_DATA_TYPE,
+									   MV_INFERENCE_DATA_FLOAT32);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_TENSOR_HEIGHT,
-                        300);
+	mv_engine_config_set_string_attribute(
+			handle, MV_INFERENCE_MODEL_USER_FILE_PATH, OD_LABEL_PATH);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_TENSOR_CHANNELS,
-                        3);
+	mv_engine_config_set_double_attribute(handle, MV_INFERENCE_MODEL_MEAN_VALUE,
+										  127.5);
 
-    mv_engine_config_set_string_attribute(handle,
-                        MV_INFERENCE_INPUT_NODE_NAME,
-                        inputNodeName);
+	mv_engine_config_set_double_attribute(handle, MV_INFERENCE_MODEL_STD_VALUE,
+										  127.5);
 
-    mv_engine_config_set_array_string_attribute(handle,
-                        MV_INFERENCE_OUTPUT_NODE_NAMES,
-                        outputNodeName,
-                        4);
+	mv_engine_config_set_double_attribute(
+			handle, MV_INFERENCE_CONFIDENCE_THRESHOLD, 0.3);
 
-    *engine_cfg = handle;
-    return err;
-}
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_BACKEND_TYPE,
+									   MV_INFERENCE_BACKEND_ARMNN);
+
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_TARGET_TYPE,
+									   MV_INFERENCE_TARGET_CPU);
+
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_INPUT_TENSOR_WIDTH,
+									   300);
+
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_INPUT_TENSOR_HEIGHT,
+									   300);
+
+	mv_engine_config_set_int_attribute(handle,
+									   MV_INFERENCE_INPUT_TENSOR_CHANNELS, 3);
+
+	mv_engine_config_set_string_attribute(handle, MV_INFERENCE_INPUT_NODE_NAME,
+										  inputNodeName);
+
+	mv_engine_config_set_array_string_attribute(
+			handle, MV_INFERENCE_OUTPUT_NODE_NAMES, outputNodeName, 4);
 
+	*engine_cfg = handle;
+	return err;
+}
 
 int perform_object_detection()
 {
-    int err = MEDIA_VISION_ERROR_NONE;
-
-    int sel_opt = 0;
-    const int options[7] = {1, 2, 3, 4, 5, 6, 7};
-    const char *names[7] = { "Configuration",
-                        "TFLITE(CPU) + MobileNetV1+SSD",
-                        "OPENCV(CPU) + MobileNetV1+SSD",
-                        "ARMNN(CPU) + MobileNetV1+SSD",
-                        "Prepare",
-                        "Run",
-                        "Back"};
-
-    mv_engine_config_h engine_cfg = NULL;
-    mv_inference_h infer = NULL;
-    mv_source_h mvSource = NULL;
-
-    while(sel_opt == 0) {
-        sel_opt = show_menu("Select Action:", options, names, ARRAY_SIZE(options));
-        switch (sel_opt) {
-        case 1:
-        {
-            //perform configuration
-            if (engine_cfg) {
-                int err2 = mv_destroy_engine_config(engine_cfg);
-                if (err2 != MEDIA_VISION_ERROR_NONE)
-                    printf("Fail to destroy engine_cfg [err:%i]\n", err2);
-                engine_cfg = NULL;
-            }
-
-            err = perform_configuration(&engine_cfg);
-        }
-            break;
-        case 2:
-        {
-            //perform TFlite MobileSSD config
-            if (engine_cfg) {
-                int err2 = mv_destroy_engine_config(engine_cfg);
-                if (err2 != MEDIA_VISION_ERROR_NONE)
-                    printf("Fail to destroy engine_cfg [err:%i]\n", err2);
-                engine_cfg = NULL;
-            }
-
-            err = perform_tflite_mobilenetv1ssd_config(&engine_cfg);
-        }
-            break;
-
-        case 3:
-        {
-            //perform OpenCV MobileSSD config
-            if (engine_cfg) {
-                int err2 = mv_destroy_engine_config(engine_cfg);
-                if (err2 != MEDIA_VISION_ERROR_NONE)
-                    printf("Fail to destroy engine_cfg [err:%i]\n", err2);
-            }
-
-            err = perform_opencv_mobilenetv1ssd_config(&engine_cfg);
-        }
-            break;
-
-        case 4:
-        {
-            //perform ARMNN MobileSSD config
-            if (engine_cfg) {
-                int err2 = mv_destroy_engine_config(engine_cfg);
-                if (err2 != MEDIA_VISION_ERROR_NONE)
-                    printf("Fail to destroy engine_cfg [err:%i]\n", err2);
-            }
-
-            err = perform_armnn_mobilenetv1ssd_config(&engine_cfg);
-        }
-            break;
-        case 5:
-        {
-            // create - configure - prepare
-            if (infer) {
-                int err2 = mv_inference_destroy(infer);
-                if (err2 != MEDIA_VISION_ERROR_NONE)
-                    printf("Fail to destroy inference handle [err:%i]\n", err2);
-                infer = NULL;
-            }
-
-            // inference
-            // create handle
-            err = mv_inference_create(&infer);
-            if (err != MEDIA_VISION_ERROR_NONE) {
-                printf("Fail to create inference handle [err:%i]\n", err);
-                break;
-            }
-
-            //configure
-            err = mv_inference_configure(infer, engine_cfg);
-            if (err != MEDIA_VISION_ERROR_NONE) {
-                printf("Fail to configure inference handle [err:%i]\n", err);
-                break;
-            }
-
-            //prepare
-            err = mv_inference_prepare(infer);
-            if (err != MEDIA_VISION_ERROR_NONE) {
-                printf("Fail to prepare inference handle");
-                break;
-            }
-        }
-            break;
-        case 6:
-        {
-            if (mvSource) {
-                int err2 = mv_destroy_source(mvSource);
-                if (err2 != MEDIA_VISION_ERROR_NONE)
-                    printf("Fail to destroy mvSource\n");
-                mvSource = NULL;
-            }
-
-            char *in_file_name = NULL;
-            /* Load media source */
-            while (input_string("Input file name to be inferred:", 1024, &(in_file_name)) == -1)
-                printf("Incorrect input! Try again.\n");
-
-            err = mv_create_source(&mvSource);
-            if (err != MEDIA_VISION_ERROR_NONE) {
-                printf("Fail to create mvSource.\n");
-                free(in_file_name);
-                break;
-            }
-
-            err = load_mv_source_from_file(in_file_name, mvSource);
-            if (err != MEDIA_VISION_ERROR_NONE) {
-                int err2 = mv_destroy_source(mvSource);
-                if (err2 != MEDIA_VISION_ERROR_NONE)
-                    printf("Fail to destroy mvSource.\n");
-                mvSource = NULL;
-                free(in_file_name);
-                break;
-            }
-            free(in_file_name);
-
-            struct timespec s_tspec;
-            struct timespec e_tspec;
-
-            clock_gettime(CLOCK_MONOTONIC, &s_tspec);
-
-            // Object Detect
-            err = mv_inference_object_detect(mvSource, infer, _object_detected_cb, NULL);
-
-            clock_gettime(CLOCK_MONOTONIC, &e_tspec);
-
-            struct timespec diffspec = diff(s_tspec, e_tspec);
-            unsigned long timeDiff = gettotalmillisec(diffspec);
-            printf("elased time : %lu(ms)\n", timeDiff);
-
-        }
-            break;
-        case 7:
-        {
-            //perform destroy
-            if (engine_cfg) {
-                err = mv_destroy_engine_config(engine_cfg);
-                if (err != MEDIA_VISION_ERROR_NONE)
-                    printf("Fail to destroy engine_cfg [err:%i]\n", err);
-                engine_cfg = NULL;
-            }
-
-            if (infer) {
-                err = mv_inference_destroy(infer);
-                if (err != MEDIA_VISION_ERROR_NONE)
-                    printf("Fail to destroy inference handle [err:%i]\n", err);
-                infer = NULL;
-            }
-
-            if (mvSource) {
-                err = mv_destroy_source(mvSource);
-                if (err != MEDIA_VISION_ERROR_NONE)
-                    printf("Fail to destroy mvSource.\n");
-                mvSource = NULL;
-            }
-        }
-            break;
-        default:
-            printf("Invalid option.\n");
-            sel_opt = 0;
-            continue;
-        }
-
-        int do_another = 0;
-        if (err != MEDIA_VISION_ERROR_NONE) {
-            printf("ERROR: Action is finished with error code: %i\n");
-        }
-
-        sel_opt = 0;
-        const int options_last[2] = {1, 2};
-        const char *names_last[2] = { "Yes", "No" };
-
-        while (sel_opt == 0) {
-            sel_opt = show_menu("Run Object Detection again?:", options_last, names_last, ARRAY_SIZE(options_last));
-            switch(sel_opt) {
-            case 1:
-                do_another = 1;
-                break;
-            case 2:
-                do_another = 0;
-                break;
-            default:
-                printf("Invalid option.\n");
-                sel_opt = 0;
-            }
-        }
-
-        sel_opt = (do_another == 1) ? 0 : 1;
-    }
-
-    if (engine_cfg) {
-        err = mv_destroy_engine_config(engine_cfg);
-        if (err != MEDIA_VISION_ERROR_NONE)
-            printf("Fail to destroy engine_cfg [err:%i]\n", err);
-        engine_cfg = NULL;
-    }
-
-    if (infer) {
-        err = mv_inference_destroy(infer);
-        if (err != MEDIA_VISION_ERROR_NONE)
-            printf("Fail to destroy inference handle [err:%i]\n", err);
-        infer = NULL;
-    }
-
-    if (mvSource) {
-        err = mv_destroy_source(mvSource);
-        if (err != MEDIA_VISION_ERROR_NONE)
-            printf("Fail to destroy mvSource\n");
-        mvSource = NULL;
-    }
-
-    return MEDIA_VISION_ERROR_NONE;
+	int err = MEDIA_VISION_ERROR_NONE;
+
+	int sel_opt = 0;
+	const int options[7] = { 1, 2, 3, 4, 5, 6, 7 };
+	const char *names[7] = { "Configuration",
+							 "TFLITE(CPU) + MobileNetV1+SSD",
+							 "OPENCV(CPU) + MobileNetV1+SSD",
+							 "ARMNN(CPU) + MobileNetV1+SSD",
+							 "Prepare",
+							 "Run",
+							 "Back" };
+
+	mv_engine_config_h engine_cfg = NULL;
+	mv_inference_h infer = NULL;
+	mv_source_h mvSource = NULL;
+
+	while (sel_opt == 0) {
+		sel_opt = show_menu("Select Action:", options, names,
+							ARRAY_SIZE(options));
+		switch (sel_opt) {
+		case 1: {
+			//perform configuration
+			if (engine_cfg) {
+				int err2 = mv_destroy_engine_config(engine_cfg);
+				if (err2 != MEDIA_VISION_ERROR_NONE)
+					printf("Fail to destroy engine_cfg [err:%i]\n", err2);
+				engine_cfg = NULL;
+			}
+
+			err = perform_configuration(&engine_cfg);
+		} break;
+		case 2: {
+			//perform TFlite MobileSSD config
+			if (engine_cfg) {
+				int err2 = mv_destroy_engine_config(engine_cfg);
+				if (err2 != MEDIA_VISION_ERROR_NONE)
+					printf("Fail to destroy engine_cfg [err:%i]\n", err2);
+				engine_cfg = NULL;
+			}
+
+			err = perform_tflite_mobilenetv1ssd_config(&engine_cfg);
+		} break;
+
+		case 3: {
+			//perform OpenCV MobileSSD config
+			if (engine_cfg) {
+				int err2 = mv_destroy_engine_config(engine_cfg);
+				if (err2 != MEDIA_VISION_ERROR_NONE)
+					printf("Fail to destroy engine_cfg [err:%i]\n", err2);
+			}
+
+			err = perform_opencv_mobilenetv1ssd_config(&engine_cfg);
+		} break;
+
+		case 4: {
+			//perform ARMNN MobileSSD config
+			if (engine_cfg) {
+				int err2 = mv_destroy_engine_config(engine_cfg);
+				if (err2 != MEDIA_VISION_ERROR_NONE)
+					printf("Fail to destroy engine_cfg [err:%i]\n", err2);
+			}
+
+			err = perform_armnn_mobilenetv1ssd_config(&engine_cfg);
+		} break;
+		case 5: {
+			// create - configure - prepare
+			if (infer) {
+				int err2 = mv_inference_destroy(infer);
+				if (err2 != MEDIA_VISION_ERROR_NONE)
+					printf("Fail to destroy inference handle [err:%i]\n", err2);
+				infer = NULL;
+			}
+
+			// inference
+			// create handle
+			err = mv_inference_create(&infer);
+			if (err != MEDIA_VISION_ERROR_NONE) {
+				printf("Fail to create inference handle [err:%i]\n", err);
+				break;
+			}
+
+			//configure
+			err = mv_inference_configure(infer, engine_cfg);
+			if (err != MEDIA_VISION_ERROR_NONE) {
+				printf("Fail to configure inference handle [err:%i]\n", err);
+				break;
+			}
+
+			//prepare
+			err = mv_inference_prepare(infer);
+			if (err != MEDIA_VISION_ERROR_NONE) {
+				printf("Fail to prepare inference handle");
+				break;
+			}
+		} break;
+		case 6: {
+			if (mvSource) {
+				int err2 = mv_destroy_source(mvSource);
+				if (err2 != MEDIA_VISION_ERROR_NONE)
+					printf("Fail to destroy mvSource\n");
+				mvSource = NULL;
+			}
+
+			char *in_file_name = NULL;
+			/* Load media source */
+			while (input_string("Input file name to be inferred:", 1024,
+								&(in_file_name)) == -1)
+				printf("Incorrect input! Try again.\n");
+
+			err = mv_create_source(&mvSource);
+			if (err != MEDIA_VISION_ERROR_NONE) {
+				printf("Fail to create mvSource.\n");
+				free(in_file_name);
+				break;
+			}
+
+			err = load_mv_source_from_file(in_file_name, mvSource);
+			if (err != MEDIA_VISION_ERROR_NONE) {
+				int err2 = mv_destroy_source(mvSource);
+				if (err2 != MEDIA_VISION_ERROR_NONE)
+					printf("Fail to destroy mvSource.\n");
+				mvSource = NULL;
+				free(in_file_name);
+				break;
+			}
+			free(in_file_name);
+
+			struct timespec s_tspec;
+			struct timespec e_tspec;
+
+			clock_gettime(CLOCK_MONOTONIC, &s_tspec);
+
+			// Object Detect
+			err = mv_inference_object_detect(mvSource, infer,
+											 _object_detected_cb, NULL);
+
+			clock_gettime(CLOCK_MONOTONIC, &e_tspec);
+
+			struct timespec diffspec = diff(s_tspec, e_tspec);
+			unsigned long timeDiff = gettotalmillisec(diffspec);
+			printf("elased time : %lu(ms)\n", timeDiff);
+
+		} break;
+		case 7: {
+			//perform destroy
+			if (engine_cfg) {
+				err = mv_destroy_engine_config(engine_cfg);
+				if (err != MEDIA_VISION_ERROR_NONE)
+					printf("Fail to destroy engine_cfg [err:%i]\n", err);
+				engine_cfg = NULL;
+			}
+
+			if (infer) {
+				err = mv_inference_destroy(infer);
+				if (err != MEDIA_VISION_ERROR_NONE)
+					printf("Fail to destroy inference handle [err:%i]\n", err);
+				infer = NULL;
+			}
+
+			if (mvSource) {
+				err = mv_destroy_source(mvSource);
+				if (err != MEDIA_VISION_ERROR_NONE)
+					printf("Fail to destroy mvSource.\n");
+				mvSource = NULL;
+			}
+		} break;
+		default:
+			printf("Invalid option.\n");
+			sel_opt = 0;
+			continue;
+		}
+
+		int do_another = 0;
+		if (err != MEDIA_VISION_ERROR_NONE) {
+			printf("ERROR: Action is finished with error code: %i\n");
+		}
+
+		sel_opt = 0;
+		const int options_last[2] = { 1, 2 };
+		const char *names_last[2] = { "Yes", "No" };
+
+		while (sel_opt == 0) {
+			sel_opt = show_menu("Run Object Detection again?:", options_last,
+								names_last, ARRAY_SIZE(options_last));
+			switch (sel_opt) {
+			case 1:
+				do_another = 1;
+				break;
+			case 2:
+				do_another = 0;
+				break;
+			default:
+				printf("Invalid option.\n");
+				sel_opt = 0;
+			}
+		}
+
+		sel_opt = (do_another == 1) ? 0 : 1;
+	}
+
+	if (engine_cfg) {
+		err = mv_destroy_engine_config(engine_cfg);
+		if (err != MEDIA_VISION_ERROR_NONE)
+			printf("Fail to destroy engine_cfg [err:%i]\n", err);
+		engine_cfg = NULL;
+	}
+
+	if (infer) {
+		err = mv_inference_destroy(infer);
+		if (err != MEDIA_VISION_ERROR_NONE)
+			printf("Fail to destroy inference handle [err:%i]\n", err);
+		infer = NULL;
+	}
+
+	if (mvSource) {
+		err = mv_destroy_source(mvSource);
+		if (err != MEDIA_VISION_ERROR_NONE)
+			printf("Fail to destroy mvSource\n");
+		mvSource = NULL;
+	}
+
+	return MEDIA_VISION_ERROR_NONE;
 }
 
 int perform_tflite_mobilenetv1ssd_face(mv_engine_config_h *engine_cfg)
 {
-    int err = MEDIA_VISION_ERROR_NONE;
-
-    mv_engine_config_h handle = NULL;
-    err = mv_create_engine_config(&handle);
-    if (err != MEDIA_VISION_ERROR_NONE) {
-        printf("Fail to create engine configuration handle.\n");
-        if (handle) {
-            int err2 = mv_destroy_engine_config(handle);
-            if (err2 != MEDIA_VISION_ERROR_NONE) {
-                printf("Fail to destroy engine cofniguration.\n");
-            }
-        }
-        return err;
-    }
-
-    char *inputNodeName = "normalized_input_image_tensor";
-    char *outputNodeName[4] = {"TFLite_Detection_PostProcess",
-                                "TFLite_Detection_PostProcess:1",
-                                "TFLite_Detection_PostProcess:2",
-                                "TFLite_Detection_PostProcess:3"};
-
-    mv_engine_config_set_string_attribute(handle,
-                        MV_INFERENCE_MODEL_WEIGHT_FILE_PATH,
-                        FD_TFLITE_WEIGHT_PATH);
+	int err = MEDIA_VISION_ERROR_NONE;
 
-	mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_DATA_TYPE,
-                        MV_INFERENCE_DATA_FLOAT32);
+	mv_engine_config_h handle = NULL;
+	err = mv_create_engine_config(&handle);
+	if (err != MEDIA_VISION_ERROR_NONE) {
+		printf("Fail to create engine configuration handle.\n");
+		if (handle) {
+			int err2 = mv_destroy_engine_config(handle);
+			if (err2 != MEDIA_VISION_ERROR_NONE) {
+				printf("Fail to destroy engine cofniguration.\n");
+			}
+		}
+		return err;
+	}
+
+	char *inputNodeName = "normalized_input_image_tensor";
+	char *outputNodeName[4] = { "TFLite_Detection_PostProcess",
+								"TFLite_Detection_PostProcess:1",
+								"TFLite_Detection_PostProcess:2",
+								"TFLite_Detection_PostProcess:3" };
+
+	mv_engine_config_set_string_attribute(
+			handle, MV_INFERENCE_MODEL_WEIGHT_FILE_PATH, FD_TFLITE_WEIGHT_PATH);
+
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_INPUT_DATA_TYPE,
+									   MV_INFERENCE_DATA_FLOAT32);
 
-    mv_engine_config_set_double_attribute(handle,
-                        MV_INFERENCE_MODEL_MEAN_VALUE,
-                        127.5);
+	mv_engine_config_set_double_attribute(handle, MV_INFERENCE_MODEL_MEAN_VALUE,
+										  127.5);
 
-    mv_engine_config_set_double_attribute(handle,
-                        MV_INFERENCE_MODEL_STD_VALUE,
-                        127.5);
+	mv_engine_config_set_double_attribute(handle, MV_INFERENCE_MODEL_STD_VALUE,
+										  127.5);
 
-    mv_engine_config_set_double_attribute(handle,
-                        MV_INFERENCE_CONFIDENCE_THRESHOLD,
-                        0.3);
+	mv_engine_config_set_double_attribute(
+			handle, MV_INFERENCE_CONFIDENCE_THRESHOLD, 0.3);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_BACKEND_TYPE,
-                        MV_INFERENCE_BACKEND_TFLITE);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_BACKEND_TYPE,
+									   MV_INFERENCE_BACKEND_TFLITE);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_TARGET_TYPE,
-                        MV_INFERENCE_TARGET_CPU);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_TARGET_TYPE,
+									   MV_INFERENCE_TARGET_CPU);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_TENSOR_WIDTH,
-                        300);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_INPUT_TENSOR_WIDTH,
+									   300);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_TENSOR_HEIGHT,
-                        300);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_INPUT_TENSOR_HEIGHT,
+									   300);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_TENSOR_CHANNELS,
-                        3);
+	mv_engine_config_set_int_attribute(handle,
+									   MV_INFERENCE_INPUT_TENSOR_CHANNELS, 3);
 
-    mv_engine_config_set_string_attribute(handle,
-                        MV_INFERENCE_INPUT_NODE_NAME,
-                        inputNodeName);
+	mv_engine_config_set_string_attribute(handle, MV_INFERENCE_INPUT_NODE_NAME,
+										  inputNodeName);
 
-    mv_engine_config_set_array_string_attribute(handle,
-                        MV_INFERENCE_OUTPUT_NODE_NAMES,
-                        outputNodeName,
-                        4);
+	mv_engine_config_set_array_string_attribute(
+			handle, MV_INFERENCE_OUTPUT_NODE_NAMES, outputNodeName, 4);
 
-    *engine_cfg = handle;
-    return err;
+	*engine_cfg = handle;
+	return err;
 }
 
 int perform_opencv_resnet10ssd_face(mv_engine_config_h *engine_cfg)
 {
-    int err = MEDIA_VISION_ERROR_NONE;
-
-    mv_engine_config_h handle = NULL;
-    err = mv_create_engine_config(&handle);
-    if (err != MEDIA_VISION_ERROR_NONE) {
-        printf("Fail to create engine configuration handle.\n");
-        if (handle) {
-            int err2 = mv_destroy_engine_config(handle);
-            if (err2 != MEDIA_VISION_ERROR_NONE) {
-                printf("Fail to destroy engine cofniguration.\n");
-            }
-        }
-        return err;
-    }
-
-    char *inputNodeName = "data";
-    char *outputNodeName[1] = {"detection_out"};
-
-    mv_engine_config_set_string_attribute(handle,
-                        MV_INFERENCE_MODEL_WEIGHT_FILE_PATH,
-                        FD_OPENCV_WEIGHT_CAFFE_PATH);
+	int err = MEDIA_VISION_ERROR_NONE;
 
-	mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_DATA_TYPE,
-                        MV_INFERENCE_DATA_FLOAT32);
+	mv_engine_config_h handle = NULL;
+	err = mv_create_engine_config(&handle);
+	if (err != MEDIA_VISION_ERROR_NONE) {
+		printf("Fail to create engine configuration handle.\n");
+		if (handle) {
+			int err2 = mv_destroy_engine_config(handle);
+			if (err2 != MEDIA_VISION_ERROR_NONE) {
+				printf("Fail to destroy engine cofniguration.\n");
+			}
+		}
+		return err;
+	}
+
+	char *inputNodeName = "data";
+	char *outputNodeName[1] = { "detection_out" };
 
-    mv_engine_config_set_string_attribute(handle,
-                        MV_INFERENCE_MODEL_CONFIGURATION_FILE_PATH,
-                        FD_OPENCV_CONFIG_CAFFE_PATH);
+	mv_engine_config_set_string_attribute(handle,
+										  MV_INFERENCE_MODEL_WEIGHT_FILE_PATH,
+										  FD_OPENCV_WEIGHT_CAFFE_PATH);
 
-    mv_engine_config_set_double_attribute(handle,
-                        MV_INFERENCE_MODEL_MEAN_VALUE,
-                        135.7);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_INPUT_DATA_TYPE,
+									   MV_INFERENCE_DATA_FLOAT32);
 
-    mv_engine_config_set_double_attribute(handle,
-                        MV_INFERENCE_MODEL_STD_VALUE,
-                        1.0);
+	mv_engine_config_set_string_attribute(
+			handle, MV_INFERENCE_MODEL_CONFIGURATION_FILE_PATH,
+			FD_OPENCV_CONFIG_CAFFE_PATH);
 
-    mv_engine_config_set_double_attribute(handle,
-                        MV_INFERENCE_CONFIDENCE_THRESHOLD,
-                        0.3);
+	mv_engine_config_set_double_attribute(handle, MV_INFERENCE_MODEL_MEAN_VALUE,
+										  135.7);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_BACKEND_TYPE,
-                        MV_INFERENCE_BACKEND_OPENCV);
+	mv_engine_config_set_double_attribute(handle, MV_INFERENCE_MODEL_STD_VALUE,
+										  1.0);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_TARGET_TYPE,
-                        MV_INFERENCE_TARGET_CPU);
+	mv_engine_config_set_double_attribute(
+			handle, MV_INFERENCE_CONFIDENCE_THRESHOLD, 0.3);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_TENSOR_WIDTH,
-                        300);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_BACKEND_TYPE,
+									   MV_INFERENCE_BACKEND_OPENCV);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_TENSOR_HEIGHT,
-                        300);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_TARGET_TYPE,
+									   MV_INFERENCE_TARGET_CPU);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_TENSOR_CHANNELS,
-                        3);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_INPUT_TENSOR_WIDTH,
+									   300);
+
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_INPUT_TENSOR_HEIGHT,
+									   300);
+
+	mv_engine_config_set_int_attribute(handle,
+									   MV_INFERENCE_INPUT_TENSOR_CHANNELS, 3);
 
-    mv_engine_config_set_string_attribute(handle,
-                        MV_INFERENCE_INPUT_NODE_NAME,
-                        inputNodeName);
+	mv_engine_config_set_string_attribute(handle, MV_INFERENCE_INPUT_NODE_NAME,
+										  inputNodeName);
 
-    mv_engine_config_set_array_string_attribute(handle,
-                        MV_INFERENCE_OUTPUT_NODE_NAMES,
-                        outputNodeName,
-                        1);
+	mv_engine_config_set_array_string_attribute(
+			handle, MV_INFERENCE_OUTPUT_NODE_NAMES, outputNodeName, 1);
 
-    *engine_cfg = handle;
-    return err;
+	*engine_cfg = handle;
+	return err;
 }
 
 int perform_armnn_mobilenetv1ssd_face(mv_engine_config_h *engine_cfg)
 {
-    int err = MEDIA_VISION_ERROR_NONE;
-
-    mv_engine_config_h handle = NULL;
-    err = mv_create_engine_config(&handle);
-    if (err != MEDIA_VISION_ERROR_NONE) {
-        printf("Fail to create engine configuration handle.\n");
-        if (handle) {
-            int err2 = mv_destroy_engine_config(handle);
-            if (err2 != MEDIA_VISION_ERROR_NONE) {
-                printf("Fail to destroy engine cofniguration.\n");
-            }
-        }
-        return err;
-    }
-
-    char *inputNodeName = "normalized_input_image_tensor";
-    char *outputNodeName[4] = {"TFLite_Detection_PostProcess",
-                                "TFLite_Detection_PostProcess:1",
-                                "TFLite_Detection_PostProcess:2",
-                                "TFLite_Detection_PostProcess:3"};
-
-    mv_engine_config_set_string_attribute(handle,
-                        MV_INFERENCE_MODEL_WEIGHT_FILE_PATH,
-                        FD_TFLITE_WEIGHT_PATH);
+	int err = MEDIA_VISION_ERROR_NONE;
 
-	mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_DATA_TYPE,
-                        MV_INFERENCE_DATA_FLOAT32);
+	mv_engine_config_h handle = NULL;
+	err = mv_create_engine_config(&handle);
+	if (err != MEDIA_VISION_ERROR_NONE) {
+		printf("Fail to create engine configuration handle.\n");
+		if (handle) {
+			int err2 = mv_destroy_engine_config(handle);
+			if (err2 != MEDIA_VISION_ERROR_NONE) {
+				printf("Fail to destroy engine cofniguration.\n");
+			}
+		}
+		return err;
+	}
+
+	char *inputNodeName = "normalized_input_image_tensor";
+	char *outputNodeName[4] = { "TFLite_Detection_PostProcess",
+								"TFLite_Detection_PostProcess:1",
+								"TFLite_Detection_PostProcess:2",
+								"TFLite_Detection_PostProcess:3" };
+
+	mv_engine_config_set_string_attribute(
+			handle, MV_INFERENCE_MODEL_WEIGHT_FILE_PATH, FD_TFLITE_WEIGHT_PATH);
 
-    mv_engine_config_set_double_attribute(handle,
-                        MV_INFERENCE_MODEL_MEAN_VALUE,
-                        127.5);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_INPUT_DATA_TYPE,
+									   MV_INFERENCE_DATA_FLOAT32);
 
-    mv_engine_config_set_double_attribute(handle,
-                        MV_INFERENCE_MODEL_STD_VALUE,
-                        127.5);
+	mv_engine_config_set_double_attribute(handle, MV_INFERENCE_MODEL_MEAN_VALUE,
+										  127.5);
 
-    mv_engine_config_set_double_attribute(handle,
-                        MV_INFERENCE_CONFIDENCE_THRESHOLD,
-                        0.3);
+	mv_engine_config_set_double_attribute(handle, MV_INFERENCE_MODEL_STD_VALUE,
+										  127.5);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_BACKEND_TYPE,
-                        MV_INFERENCE_BACKEND_ARMNN);
+	mv_engine_config_set_double_attribute(
+			handle, MV_INFERENCE_CONFIDENCE_THRESHOLD, 0.3);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_TARGET_TYPE,
-                        MV_INFERENCE_TARGET_CPU);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_BACKEND_TYPE,
+									   MV_INFERENCE_BACKEND_ARMNN);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_TENSOR_WIDTH,
-                        300);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_TARGET_TYPE,
+									   MV_INFERENCE_TARGET_CPU);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_TENSOR_HEIGHT,
-                        300);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_INPUT_TENSOR_WIDTH,
+									   300);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_TENSOR_CHANNELS,
-                        3);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_INPUT_TENSOR_HEIGHT,
+									   300);
 
-    mv_engine_config_set_string_attribute(handle,
-                        MV_INFERENCE_INPUT_NODE_NAME,
-                        inputNodeName);
+	mv_engine_config_set_int_attribute(handle,
+									   MV_INFERENCE_INPUT_TENSOR_CHANNELS, 3);
+
+	mv_engine_config_set_string_attribute(handle, MV_INFERENCE_INPUT_NODE_NAME,
+										  inputNodeName);
 
-    mv_engine_config_set_array_string_attribute(handle,
-                        MV_INFERENCE_OUTPUT_NODE_NAMES,
-                        outputNodeName,
-                        4);
+	mv_engine_config_set_array_string_attribute(
+			handle, MV_INFERENCE_OUTPUT_NODE_NAMES, outputNodeName, 4);
 
-    *engine_cfg = handle;
-    return err;
+	*engine_cfg = handle;
+	return err;
 }
 
 int perform_face_detection()
 {
-    int err = MEDIA_VISION_ERROR_NONE;
-
-    int sel_opt = 0;
-    const int options[7] = {1, 2, 3, 4, 5, 6, 7};
-    const char *names[7] = { "Configuration",
-                        "TFLite(CPU) + MobileNetV1 + SSD",
-                        "OPENCV(CPU) + Resnet10 + SSD",
-                        "ARMNN(CPU) + MobileNetV1 + SSD",
-                        "Prepare",
-                        "Run",
-                        "Back"};
-
-    mv_engine_config_h engine_cfg = NULL;
-    mv_inference_h infer = NULL;
-    mv_source_h mvSource = NULL;
-
-    while(sel_opt == 0) {
-        sel_opt = show_menu("Select Action:", options, names, ARRAY_SIZE(options));
-        switch (sel_opt) {
-        case 1:
-        {
-            //perform configuration
-            if (engine_cfg) {
-                int err2 = mv_destroy_engine_config(engine_cfg);
-                if (err2 != MEDIA_VISION_ERROR_NONE)
-                    printf("Fail to destroy engine_cfg [err:%i]\n", err2);
-                engine_cfg = NULL;
-            }
-
-            err = perform_configuration(&engine_cfg);
-        }
-            break;
-        case 2:
-        {
-            //perform TF Mobilenetssd config
-            if (engine_cfg) {
-                int err2 = mv_destroy_engine_config(engine_cfg);
-                if (err2 != MEDIA_VISION_ERROR_NONE)
-                    printf("Fail to destroy engine_cfg [err:%i]\n", err2);
-                engine_cfg = NULL;
-            }
-
-            err = perform_tflite_mobilenetv1ssd_face(&engine_cfg);
-        }
-            break;
-        case 3:
-        {
-            //perform TF Lite Mobilenetssd config
-            if (engine_cfg) {
-                int err2 = mv_destroy_engine_config(engine_cfg);
-                if (err2 != MEDIA_VISION_ERROR_NONE)
-                    printf("Fail to destroy engine_cfg [err:%i]\n", err2);
-            }
-
-            err = perform_opencv_resnet10ssd_face(&engine_cfg);
-        }
-            break;
-        case 4:
-        {
-            //perform TF Lite Mobilenetssd config
-            if (engine_cfg) {
-                int err2 = mv_destroy_engine_config(engine_cfg);
-                if (err2 != MEDIA_VISION_ERROR_NONE)
-                    printf("Fail to destroy engine_cfg [err:%i]\n", err2);
-            }
-
-            err = perform_armnn_mobilenetv1ssd_face(&engine_cfg);
-        }
-            break;
-        case 5:
-        {
-            // create - configure - prepare
-            if (infer) {
-                int err2 = mv_inference_destroy(infer);
-                if (err2 != MEDIA_VISION_ERROR_NONE)
-                    printf("Fail to destroy inference handle [err:%i]\n", err2);
-                infer = NULL;
-            }
-
-            // inference
-            // create handle
-            err = mv_inference_create(&infer);
-            if (err != MEDIA_VISION_ERROR_NONE) {
-                printf("Fail to create inference handle [err:%i]\n", err);
-                break;
-            }
-
-            //configure
-            err = mv_inference_configure(infer, engine_cfg);
-            if (err != MEDIA_VISION_ERROR_NONE) {
-                printf("Fail to configure inference handle [err:%i]\n", err);
-                break;
-            }
-
-            //prepare
-            err = mv_inference_prepare(infer);
-            if (err != MEDIA_VISION_ERROR_NONE) {
-                printf("Fail to prepare inference handle");
-                break;
-            }
-        }
-            break;
-        case 6:
-        {
-            if (mvSource) {
-                int err2 = mv_destroy_source(mvSource);
-                if (err2 != MEDIA_VISION_ERROR_NONE)
-                    printf("Fail to destroy mvSource\n");
-                mvSource = NULL;
-            }
-
-            char *in_file_name = NULL;
-            /* Load media source */
-            while (input_string("Input file name to be inferred:", 1024, &(in_file_name)) == -1)
-                printf("Incorrect input! Try again.\n");
-
-            err = mv_create_source(&mvSource);
-            if (err != MEDIA_VISION_ERROR_NONE) {
-                printf("Fail to create mvSource.\n");
-                free(in_file_name);
-                break;
-            }
-
-            err = load_mv_source_from_file(in_file_name, mvSource);
-            if (err != MEDIA_VISION_ERROR_NONE) {
-                int err2 = mv_destroy_source(mvSource);
-                if (err2 != MEDIA_VISION_ERROR_NONE)
-                    printf("Fail to destroy mvSource.\n", err2);
-                mvSource = NULL;
-                free(in_file_name);
-                break;
-            }
-            free(in_file_name);
-
-            struct timespec s_tspec;
-            struct timespec e_tspec;
-
-            clock_gettime(CLOCK_MONOTONIC, &s_tspec);
-
-            // Object Detect
-            err = mv_inference_face_detect(mvSource, infer, _face_detected_cb, NULL);
-
-            clock_gettime(CLOCK_MONOTONIC, &e_tspec);
-
-            struct timespec diffspec = diff(s_tspec, e_tspec);
-            unsigned long timeDiff = gettotalmillisec(diffspec);
-            printf("elased time : %lu(ms)\n", timeDiff);
-        }
-            break;
-        case 7:
-        {
-            //perform destroy
-            if (engine_cfg) {
-                err = mv_destroy_engine_config(engine_cfg);
-                if (err != MEDIA_VISION_ERROR_NONE)
-                    printf("Fail to destroy engine_cfg [err:%i]\n", err);
-                engine_cfg = NULL;
-            }
-
-            if (infer) {
-                err = mv_inference_destroy(infer);
-                if (err != MEDIA_VISION_ERROR_NONE)
-                    printf("Fail to destroy inference handle [err:%i]\n", err);
-                infer = NULL;
-            }
-
-            if (mvSource) {
-                err = mv_destroy_source(mvSource);
-                if (err != MEDIA_VISION_ERROR_NONE)
-                    printf("Fail to destroy mvSource [err:%i]\n", err);
-                mvSource = NULL;
-            }
-        }
-            break;
-        default:
-            printf("Invalid option.\n");
-            sel_opt = 0;
-            continue;
-        }
-
-        int do_another = 0;
-        if (err != MEDIA_VISION_ERROR_NONE) {
-            printf("ERROR: Action is finished with error code: %i\n");
-        }
-
-        sel_opt = 0;
-        const int options_last[2] = {1, 2};
-        const char *names_last[2] = { "Yes", "No" };
-
-        while (sel_opt == 0) {
-            sel_opt = show_menu("Run Face Detection again?:", options_last, names_last, ARRAY_SIZE(options_last));
-            switch(sel_opt) {
-            case 1:
-                do_another = 1;
-                break;
-            case 2:
-                do_another = 0;
-                break;
-            default:
-                printf("Invalid option.\n");
-                sel_opt = 0;
-            }
-        }
-
-        sel_opt = (do_another == 1) ? 0 : 1;
-    }
-
-    if (engine_cfg) {
-        err = mv_destroy_engine_config(engine_cfg);
-        if (err != MEDIA_VISION_ERROR_NONE)
-            printf("Fail to destroy engine_cfg [err:%i]\n", err);
-        engine_cfg = NULL;
-    }
-
-    if (infer) {
-        err = mv_inference_destroy(infer);
-        if (err != MEDIA_VISION_ERROR_NONE)
-            printf("Fail to destroy inference handle [err:%i]\n", err);
-        infer = NULL;
-    }
-
-    if (mvSource) {
-        err = mv_destroy_source(mvSource);
-        if (err != MEDIA_VISION_ERROR_NONE)
-            printf("Fail to destroy mvSource [err:%i]\n", err);
-        mvSource = NULL;
-    }
-
-    return MEDIA_VISION_ERROR_NONE;
+	int err = MEDIA_VISION_ERROR_NONE;
+
+	int sel_opt = 0;
+	const int options[7] = { 1, 2, 3, 4, 5, 6, 7 };
+	const char *names[7] = { "Configuration",
+							 "TFLite(CPU) + MobileNetV1 + SSD",
+							 "OPENCV(CPU) + Resnet10 + SSD",
+							 "ARMNN(CPU) + MobileNetV1 + SSD",
+							 "Prepare",
+							 "Run",
+							 "Back" };
+
+	mv_engine_config_h engine_cfg = NULL;
+	mv_inference_h infer = NULL;
+	mv_source_h mvSource = NULL;
+
+	while (sel_opt == 0) {
+		sel_opt = show_menu("Select Action:", options, names,
+							ARRAY_SIZE(options));
+		switch (sel_opt) {
+		case 1: {
+			//perform configuration
+			if (engine_cfg) {
+				int err2 = mv_destroy_engine_config(engine_cfg);
+				if (err2 != MEDIA_VISION_ERROR_NONE)
+					printf("Fail to destroy engine_cfg [err:%i]\n", err2);
+				engine_cfg = NULL;
+			}
+
+			err = perform_configuration(&engine_cfg);
+		} break;
+		case 2: {
+			//perform TF Mobilenetssd config
+			if (engine_cfg) {
+				int err2 = mv_destroy_engine_config(engine_cfg);
+				if (err2 != MEDIA_VISION_ERROR_NONE)
+					printf("Fail to destroy engine_cfg [err:%i]\n", err2);
+				engine_cfg = NULL;
+			}
+
+			err = perform_tflite_mobilenetv1ssd_face(&engine_cfg);
+		} break;
+		case 3: {
+			//perform TF Lite Mobilenetssd config
+			if (engine_cfg) {
+				int err2 = mv_destroy_engine_config(engine_cfg);
+				if (err2 != MEDIA_VISION_ERROR_NONE)
+					printf("Fail to destroy engine_cfg [err:%i]\n", err2);
+			}
+
+			err = perform_opencv_resnet10ssd_face(&engine_cfg);
+		} break;
+		case 4: {
+			//perform TF Lite Mobilenetssd config
+			if (engine_cfg) {
+				int err2 = mv_destroy_engine_config(engine_cfg);
+				if (err2 != MEDIA_VISION_ERROR_NONE)
+					printf("Fail to destroy engine_cfg [err:%i]\n", err2);
+			}
+
+			err = perform_armnn_mobilenetv1ssd_face(&engine_cfg);
+		} break;
+		case 5: {
+			// create - configure - prepare
+			if (infer) {
+				int err2 = mv_inference_destroy(infer);
+				if (err2 != MEDIA_VISION_ERROR_NONE)
+					printf("Fail to destroy inference handle [err:%i]\n", err2);
+				infer = NULL;
+			}
+
+			// inference
+			// create handle
+			err = mv_inference_create(&infer);
+			if (err != MEDIA_VISION_ERROR_NONE) {
+				printf("Fail to create inference handle [err:%i]\n", err);
+				break;
+			}
+
+			//configure
+			err = mv_inference_configure(infer, engine_cfg);
+			if (err != MEDIA_VISION_ERROR_NONE) {
+				printf("Fail to configure inference handle [err:%i]\n", err);
+				break;
+			}
+
+			//prepare
+			err = mv_inference_prepare(infer);
+			if (err != MEDIA_VISION_ERROR_NONE) {
+				printf("Fail to prepare inference handle");
+				break;
+			}
+		} break;
+		case 6: {
+			if (mvSource) {
+				int err2 = mv_destroy_source(mvSource);
+				if (err2 != MEDIA_VISION_ERROR_NONE)
+					printf("Fail to destroy mvSource\n");
+				mvSource = NULL;
+			}
+
+			char *in_file_name = NULL;
+			/* Load media source */
+			while (input_string("Input file name to be inferred:", 1024,
+								&(in_file_name)) == -1)
+				printf("Incorrect input! Try again.\n");
+
+			err = mv_create_source(&mvSource);
+			if (err != MEDIA_VISION_ERROR_NONE) {
+				printf("Fail to create mvSource.\n");
+				free(in_file_name);
+				break;
+			}
+
+			err = load_mv_source_from_file(in_file_name, mvSource);
+			if (err != MEDIA_VISION_ERROR_NONE) {
+				int err2 = mv_destroy_source(mvSource);
+				if (err2 != MEDIA_VISION_ERROR_NONE)
+					printf("Fail to destroy mvSource.\n", err2);
+				mvSource = NULL;
+				free(in_file_name);
+				break;
+			}
+			free(in_file_name);
+
+			struct timespec s_tspec;
+			struct timespec e_tspec;
+
+			clock_gettime(CLOCK_MONOTONIC, &s_tspec);
+
+			// Object Detect
+			err = mv_inference_face_detect(mvSource, infer, _face_detected_cb,
+										   NULL);
+
+			clock_gettime(CLOCK_MONOTONIC, &e_tspec);
+
+			struct timespec diffspec = diff(s_tspec, e_tspec);
+			unsigned long timeDiff = gettotalmillisec(diffspec);
+			printf("elased time : %lu(ms)\n", timeDiff);
+		} break;
+		case 7: {
+			//perform destroy
+			if (engine_cfg) {
+				err = mv_destroy_engine_config(engine_cfg);
+				if (err != MEDIA_VISION_ERROR_NONE)
+					printf("Fail to destroy engine_cfg [err:%i]\n", err);
+				engine_cfg = NULL;
+			}
+
+			if (infer) {
+				err = mv_inference_destroy(infer);
+				if (err != MEDIA_VISION_ERROR_NONE)
+					printf("Fail to destroy inference handle [err:%i]\n", err);
+				infer = NULL;
+			}
+
+			if (mvSource) {
+				err = mv_destroy_source(mvSource);
+				if (err != MEDIA_VISION_ERROR_NONE)
+					printf("Fail to destroy mvSource [err:%i]\n", err);
+				mvSource = NULL;
+			}
+		} break;
+		default:
+			printf("Invalid option.\n");
+			sel_opt = 0;
+			continue;
+		}
+
+		int do_another = 0;
+		if (err != MEDIA_VISION_ERROR_NONE) {
+			printf("ERROR: Action is finished with error code: %i\n");
+		}
+
+		sel_opt = 0;
+		const int options_last[2] = { 1, 2 };
+		const char *names_last[2] = { "Yes", "No" };
+
+		while (sel_opt == 0) {
+			sel_opt = show_menu("Run Face Detection again?:", options_last,
+								names_last, ARRAY_SIZE(options_last));
+			switch (sel_opt) {
+			case 1:
+				do_another = 1;
+				break;
+			case 2:
+				do_another = 0;
+				break;
+			default:
+				printf("Invalid option.\n");
+				sel_opt = 0;
+			}
+		}
+
+		sel_opt = (do_another == 1) ? 0 : 1;
+	}
+
+	if (engine_cfg) {
+		err = mv_destroy_engine_config(engine_cfg);
+		if (err != MEDIA_VISION_ERROR_NONE)
+			printf("Fail to destroy engine_cfg [err:%i]\n", err);
+		engine_cfg = NULL;
+	}
+
+	if (infer) {
+		err = mv_inference_destroy(infer);
+		if (err != MEDIA_VISION_ERROR_NONE)
+			printf("Fail to destroy inference handle [err:%i]\n", err);
+		infer = NULL;
+	}
+
+	if (mvSource) {
+		err = mv_destroy_source(mvSource);
+		if (err != MEDIA_VISION_ERROR_NONE)
+			printf("Fail to destroy mvSource [err:%i]\n", err);
+		mvSource = NULL;
+	}
+
+	return MEDIA_VISION_ERROR_NONE;
 }
 
 int perform_tflite_TweakCNN(mv_engine_config_h *engine_cfg)
 {
-    int err = MEDIA_VISION_ERROR_NONE;
-
-    mv_engine_config_h handle = NULL;
-    err = mv_create_engine_config(&handle);
-    if (err != MEDIA_VISION_ERROR_NONE) {
-        printf("Fail to create engine configuration handle.\n");
-        if (handle) {
-            int err2 = mv_destroy_engine_config(handle);
-            if (err2 != MEDIA_VISION_ERROR_NONE) {
-                printf("Fail to destroy engine cofniguration.\n");
-            }
-        }
-        return err;
-    }
-
-    char *inputNodeName = "INPUT_TENSOR_NAME";
-    char *outputNodeName[1] = {"OUTPUT_TENSOR_NAME"};
-
-    mv_engine_config_set_string_attribute(handle,
-                        MV_INFERENCE_MODEL_WEIGHT_FILE_PATH,
-                        FLD_TFLITE_WEIGHT_PATH);
+	int err = MEDIA_VISION_ERROR_NONE;
 
-	mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_DATA_TYPE,
-                        MV_INFERENCE_DATA_FLOAT32);
+	mv_engine_config_h handle = NULL;
+	err = mv_create_engine_config(&handle);
+	if (err != MEDIA_VISION_ERROR_NONE) {
+		printf("Fail to create engine configuration handle.\n");
+		if (handle) {
+			int err2 = mv_destroy_engine_config(handle);
+			if (err2 != MEDIA_VISION_ERROR_NONE) {
+				printf("Fail to destroy engine cofniguration.\n");
+			}
+		}
+		return err;
+	}
+
+	char *inputNodeName = "INPUT_TENSOR_NAME";
+	char *outputNodeName[1] = { "OUTPUT_TENSOR_NAME" };
+
+	mv_engine_config_set_string_attribute(handle,
+										  MV_INFERENCE_MODEL_WEIGHT_FILE_PATH,
+										  FLD_TFLITE_WEIGHT_PATH);
 
-    mv_engine_config_set_double_attribute(handle,
-                        MV_INFERENCE_MODEL_MEAN_VALUE,
-                        0.0);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_INPUT_DATA_TYPE,
+									   MV_INFERENCE_DATA_FLOAT32);
 
-    mv_engine_config_set_double_attribute(handle,
-                        MV_INFERENCE_MODEL_STD_VALUE,
-                        1.0);
+	mv_engine_config_set_double_attribute(handle, MV_INFERENCE_MODEL_MEAN_VALUE,
+										  0.0);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_BACKEND_TYPE,
-                        MV_INFERENCE_BACKEND_TFLITE);
+	mv_engine_config_set_double_attribute(handle, MV_INFERENCE_MODEL_STD_VALUE,
+										  1.0);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_TARGET_TYPE,
-                        MV_INFERENCE_TARGET_CPU);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_BACKEND_TYPE,
+									   MV_INFERENCE_BACKEND_TFLITE);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_TENSOR_WIDTH,
-                        128);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_TARGET_TYPE,
+									   MV_INFERENCE_TARGET_CPU);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_TENSOR_HEIGHT,
-                        128);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_INPUT_TENSOR_WIDTH,
+									   128);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_TENSOR_CHANNELS,
-                        3);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_INPUT_TENSOR_HEIGHT,
+									   128);
 
-    mv_engine_config_set_string_attribute(handle,
-                        MV_INFERENCE_INPUT_NODE_NAME,
-                        inputNodeName);
+	mv_engine_config_set_int_attribute(handle,
+									   MV_INFERENCE_INPUT_TENSOR_CHANNELS, 3);
+
+	mv_engine_config_set_string_attribute(handle, MV_INFERENCE_INPUT_NODE_NAME,
+										  inputNodeName);
 
-    mv_engine_config_set_array_string_attribute(handle,
-                        MV_INFERENCE_OUTPUT_NODE_NAMES,
-                        outputNodeName,
-                        1);
+	mv_engine_config_set_array_string_attribute(
+			handle, MV_INFERENCE_OUTPUT_NODE_NAMES, outputNodeName, 1);
 
-    *engine_cfg = handle;
-    return err;
+	*engine_cfg = handle;
+	return err;
 }
 
 int perform_opencv_cnncascade(mv_engine_config_h *engine_cfg)
 {
-    int err = MEDIA_VISION_ERROR_NONE;
-
-    mv_engine_config_h handle = NULL;
-    err = mv_create_engine_config(&handle);
-    if (err != MEDIA_VISION_ERROR_NONE) {
-        printf("Fail to create engine configuration handle.\n");
-        if (handle) {
-            int err2 = mv_destroy_engine_config(handle);
-            if (err2 != MEDIA_VISION_ERROR_NONE) {
-                printf("Fail to destroy engine cofniguration.\n");
-            }
-        }
-        return err;
-    }
-
-    char *inputNodeName = "data";
-    char *outputNodeName[1] = {"Sigmoid_fc2"};
-
-    mv_engine_config_set_string_attribute(handle,
-                        MV_INFERENCE_MODEL_WEIGHT_FILE_PATH,
-                        FLD_OPENCV_WEIGHT_CAFFE_PATH);
+	int err = MEDIA_VISION_ERROR_NONE;
 
-	mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_DATA_TYPE,
-                        MV_INFERENCE_DATA_FLOAT32);
+	mv_engine_config_h handle = NULL;
+	err = mv_create_engine_config(&handle);
+	if (err != MEDIA_VISION_ERROR_NONE) {
+		printf("Fail to create engine configuration handle.\n");
+		if (handle) {
+			int err2 = mv_destroy_engine_config(handle);
+			if (err2 != MEDIA_VISION_ERROR_NONE) {
+				printf("Fail to destroy engine cofniguration.\n");
+			}
+		}
+		return err;
+	}
 
-    mv_engine_config_set_string_attribute(handle,
-                        MV_INFERENCE_MODEL_CONFIGURATION_FILE_PATH,
-                        FLD_OPENCV_CONFIG_CAFFE_PATH);
+	char *inputNodeName = "data";
+	char *outputNodeName[1] = { "Sigmoid_fc2" };
 
-    mv_engine_config_set_double_attribute(handle,
-                        MV_INFERENCE_MODEL_MEAN_VALUE,
-                        127.5);
+	mv_engine_config_set_string_attribute(handle,
+										  MV_INFERENCE_MODEL_WEIGHT_FILE_PATH,
+										  FLD_OPENCV_WEIGHT_CAFFE_PATH);
 
-    mv_engine_config_set_double_attribute(handle,
-                        MV_INFERENCE_MODEL_STD_VALUE,
-                        127.5);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_INPUT_DATA_TYPE,
+									   MV_INFERENCE_DATA_FLOAT32);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_BACKEND_TYPE,
-                        MV_INFERENCE_BACKEND_OPENCV);
+	mv_engine_config_set_string_attribute(
+			handle, MV_INFERENCE_MODEL_CONFIGURATION_FILE_PATH,
+			FLD_OPENCV_CONFIG_CAFFE_PATH);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_TARGET_TYPE,
-                        MV_INFERENCE_TARGET_CPU);
+	mv_engine_config_set_double_attribute(handle, MV_INFERENCE_MODEL_MEAN_VALUE,
+										  127.5);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_TENSOR_WIDTH,
-                        128);
+	mv_engine_config_set_double_attribute(handle, MV_INFERENCE_MODEL_STD_VALUE,
+										  127.5);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_TENSOR_HEIGHT,
-                        128);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_BACKEND_TYPE,
+									   MV_INFERENCE_BACKEND_OPENCV);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_TENSOR_CHANNELS,
-                        3);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_TARGET_TYPE,
+									   MV_INFERENCE_TARGET_CPU);
 
-    mv_engine_config_set_string_attribute(handle,
-                        MV_INFERENCE_INPUT_NODE_NAME,
-                        inputNodeName);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_INPUT_TENSOR_WIDTH,
+									   128);
 
-    mv_engine_config_set_array_string_attribute(handle,
-                        MV_INFERENCE_OUTPUT_NODE_NAMES,
-                        outputNodeName,
-                        1);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_INPUT_TENSOR_HEIGHT,
+									   128);
 
-    *engine_cfg = handle;
-    return err;
+	mv_engine_config_set_int_attribute(handle,
+									   MV_INFERENCE_INPUT_TENSOR_CHANNELS, 3);
+
+	mv_engine_config_set_string_attribute(handle, MV_INFERENCE_INPUT_NODE_NAME,
+										  inputNodeName);
+
+	mv_engine_config_set_array_string_attribute(
+			handle, MV_INFERENCE_OUTPUT_NODE_NAMES, outputNodeName, 1);
+
+	*engine_cfg = handle;
+	return err;
 }
 
 int perform_facial_landmark_detection()
 {
-    int err = MEDIA_VISION_ERROR_NONE;
-
-    int sel_opt = 0;
-    const int options[6] = {1, 2, 3, 4, 5, 6};
-    const *names[6] = { "Configuration",
-                        "Tflite(CPU) + TweakCNN",
-                        "OPENCV(CPU) + TweakCNN",
-                        "Prepare",
-                        "Run",
-                        "Back"};
-
-    mv_engine_config_h engine_cfg = NULL;
-    mv_inference_h infer = NULL;
-    mv_source_h mvSource = NULL;
-
-    while(sel_opt == 0) {
-        sel_opt = show_menu("Select Action:", options, names, ARRAY_SIZE(options));
-        switch (sel_opt) {
-        case 1:
-        {
-            //perform configuration
-            if (engine_cfg) {
-                int err2 = mv_destroy_engine_config(engine_cfg);
-                if (err2 != MEDIA_VISION_ERROR_NONE)
-                    printf("Fail to destroy engine_cfg [err:%i]\n", err2);
-                engine_cfg = NULL;
-            }
-
-            err = perform_configuration(&engine_cfg);
-        }
-            break;
-        case 2:
-        {
-            //perform SRID TweakCNN config
-            if (engine_cfg) {
-                int err2 = mv_destroy_engine_config(engine_cfg);
-                if (err2 != MEDIA_VISION_ERROR_NONE)
-                    printf("Fail to destroy engine_cfg [err:%i]\n", err2);
-                engine_cfg = NULL;
-            }
-            err = perform_tflite_TweakCNN(&engine_cfg);
-        }
-            break;
-        case 3:
-        {
-            //perform CNN cascade
-            if (engine_cfg) {
-                int err2 = mv_destroy_engine_config(engine_cfg);
-                if (err2 != MEDIA_VISION_ERROR_NONE)
-                    printf("Fail to destroy engine_cfg [err:%i]\n", err2);
-            }
-            err = perform_opencv_cnncascade(&engine_cfg);
-        }
-            break;
-        case 4:
-        {
-            // create - configure - prepare
-            if (infer) {
-                int err2 = mv_inference_destroy(infer);
-                if (err2 != MEDIA_VISION_ERROR_NONE)
-                    printf("Fail to destroy inference handle [err:%i]\n", err2);
-                infer = NULL;
-            }
-
-            // inference
-            // create handle
-            err = mv_inference_create(&infer);
-            if (err != MEDIA_VISION_ERROR_NONE) {
-                printf("Fail to create inference handle [err:%i]\n", err);
-                break;
-            }
-
-            //configure
-            err = mv_inference_configure(infer, engine_cfg);
-            if (err != MEDIA_VISION_ERROR_NONE) {
-                printf("Fail to configure inference handle [err:%i]\n", err);
-                break;
-            }
-
-            //prepare
-            err = mv_inference_prepare(infer);
-            if (err != MEDIA_VISION_ERROR_NONE) {
-                printf("Fail to prepare inference handle");
-                break;
-            }
-        }
-            break;
-        case 5:
-        {
-            if (mvSource) {
-                int err2 = mv_destroy_source(mvSource);
-                if (err2 != MEDIA_VISION_ERROR_NONE)
-                    printf("Fail to destroy mvSource\n");
-                mvSource = NULL;
-            }
-
-            char *in_file_name = NULL;
-            /* Load media source */
-            while (input_string("Input file name to be inferred:", 1024, &(in_file_name)) == -1)
-                printf("Incorrect input! Try again.\n");
-
-            err = mv_create_source(&mvSource);
-            if (err != MEDIA_VISION_ERROR_NONE) {
-                printf("Fail to create mvSource.\n");
-                free(in_file_name);
-                break;
-            }
-
-            err = load_mv_source_from_file(in_file_name, mvSource);
-            if (err != MEDIA_VISION_ERROR_NONE) {
-                int err2 = mv_destroy_source(mvSource);
-                if (err2 != MEDIA_VISION_ERROR_NONE)
-                    printf("Fail to destroy mvSource.\n", err2);
-                mvSource = NULL;
-                free(in_file_name);
-                break;
-            }
-            free(in_file_name);
-
-            struct timespec s_tspec;
-            struct timespec e_tspec;
-
-            clock_gettime(CLOCK_MONOTONIC, &s_tspec);
-
-            // Object Detect
-            err = mv_inference_facial_landmark_detect(mvSource, infer, NULL, _facial_landmark_detected_cb, NULL);
-
-            clock_gettime(CLOCK_MONOTONIC, &e_tspec);
-
-            struct timespec diffspec = diff(s_tspec, e_tspec);
-            unsigned long timeDiff = gettotalmillisec(diffspec);
-            printf("elased time : %lu(ms)\n", timeDiff);
-        }
-            break;
-        case 6:
-        {
-            //perform destroy
-            if (engine_cfg) {
-                err = mv_destroy_engine_config(engine_cfg);
-                if (err != MEDIA_VISION_ERROR_NONE)
-                    printf("Fail to destroy engine_cfg [err:%i]\n", err);
-                engine_cfg = NULL;
-            }
-
-            if (infer) {
-                err = mv_inference_destroy(infer);
-                if (err != MEDIA_VISION_ERROR_NONE)
-                    printf("Fail to destroy inference handle [err:%i]\n", err);
-                infer = NULL;
-            }
-
-            if (mvSource) {
-                err = mv_destroy_source(mvSource);
-                if (err != MEDIA_VISION_ERROR_NONE)
-                    printf("Fail to destroy mvSource [err:%i]\n", err);
-                mvSource = NULL;
-            }
-        }
-            break;
-        default:
-            printf("Invalid option.\n");
-            sel_opt = 0;
-            continue;
-        }
-
-        int do_another = 0;
-        if (err != MEDIA_VISION_ERROR_NONE) {
-            printf("ERROR: Action is finished with error code: %i\n");
-        }
-
-        sel_opt = 0;
-        const int options_last[2] = {1, 2};
-        const char *names_last[2] = { "Yes", "No" };
-
-        while (sel_opt == 0) {
-            sel_opt = show_menu("Run Facial Landmark Detection again?:", options_last, names_last, ARRAY_SIZE(options_last));
-            switch(sel_opt) {
-            case 1:
-                do_another = 1;
-                break;
-            case 2:
-                do_another = 0;
-                break;
-            default:
-                printf("Invalid option.\n");
-                sel_opt = 0;
-            }
-        }
-
-        sel_opt = (do_another == 1) ? 0 : 1;
-    }
-
-    if (engine_cfg) {
-        err = mv_destroy_engine_config(engine_cfg);
-        if (err != MEDIA_VISION_ERROR_NONE)
-            printf("Fail to destroy engine_cfg [err:%i]\n", err);
-        engine_cfg = NULL;
-    }
-
-    if (infer) {
-        err = mv_inference_destroy(infer);
-        if (err != MEDIA_VISION_ERROR_NONE)
-            printf("Fail to destroy inference handle [err:%i]\n", err);
-        infer = NULL;
-    }
-
-    if (mvSource) {
-        err = mv_destroy_source(mvSource);
-        if (err != MEDIA_VISION_ERROR_NONE)
-            printf("Fail to destroy mvSource [err:%i]\n", err);
-        mvSource = NULL;
-    }
-
-    return MEDIA_VISION_ERROR_NONE;
+	int err = MEDIA_VISION_ERROR_NONE;
+
+	int sel_opt = 0;
+	const int options[6] = { 1, 2, 3, 4, 5, 6 };
+	const *names[6] = { "Configuration",
+						"Tflite(CPU) + TweakCNN",
+						"OPENCV(CPU) + TweakCNN",
+						"Prepare",
+						"Run",
+						"Back" };
+
+	mv_engine_config_h engine_cfg = NULL;
+	mv_inference_h infer = NULL;
+	mv_source_h mvSource = NULL;
+
+	while (sel_opt == 0) {
+		sel_opt = show_menu("Select Action:", options, names,
+							ARRAY_SIZE(options));
+		switch (sel_opt) {
+		case 1: {
+			//perform configuration
+			if (engine_cfg) {
+				int err2 = mv_destroy_engine_config(engine_cfg);
+				if (err2 != MEDIA_VISION_ERROR_NONE)
+					printf("Fail to destroy engine_cfg [err:%i]\n", err2);
+				engine_cfg = NULL;
+			}
+
+			err = perform_configuration(&engine_cfg);
+		} break;
+		case 2: {
+			//perform SRID TweakCNN config
+			if (engine_cfg) {
+				int err2 = mv_destroy_engine_config(engine_cfg);
+				if (err2 != MEDIA_VISION_ERROR_NONE)
+					printf("Fail to destroy engine_cfg [err:%i]\n", err2);
+				engine_cfg = NULL;
+			}
+			err = perform_tflite_TweakCNN(&engine_cfg);
+		} break;
+		case 3: {
+			//perform CNN cascade
+			if (engine_cfg) {
+				int err2 = mv_destroy_engine_config(engine_cfg);
+				if (err2 != MEDIA_VISION_ERROR_NONE)
+					printf("Fail to destroy engine_cfg [err:%i]\n", err2);
+			}
+			err = perform_opencv_cnncascade(&engine_cfg);
+		} break;
+		case 4: {
+			// create - configure - prepare
+			if (infer) {
+				int err2 = mv_inference_destroy(infer);
+				if (err2 != MEDIA_VISION_ERROR_NONE)
+					printf("Fail to destroy inference handle [err:%i]\n", err2);
+				infer = NULL;
+			}
+
+			// inference
+			// create handle
+			err = mv_inference_create(&infer);
+			if (err != MEDIA_VISION_ERROR_NONE) {
+				printf("Fail to create inference handle [err:%i]\n", err);
+				break;
+			}
+
+			//configure
+			err = mv_inference_configure(infer, engine_cfg);
+			if (err != MEDIA_VISION_ERROR_NONE) {
+				printf("Fail to configure inference handle [err:%i]\n", err);
+				break;
+			}
+
+			//prepare
+			err = mv_inference_prepare(infer);
+			if (err != MEDIA_VISION_ERROR_NONE) {
+				printf("Fail to prepare inference handle");
+				break;
+			}
+		} break;
+		case 5: {
+			if (mvSource) {
+				int err2 = mv_destroy_source(mvSource);
+				if (err2 != MEDIA_VISION_ERROR_NONE)
+					printf("Fail to destroy mvSource\n");
+				mvSource = NULL;
+			}
+
+			char *in_file_name = NULL;
+			/* Load media source */
+			while (input_string("Input file name to be inferred:", 1024,
+								&(in_file_name)) == -1)
+				printf("Incorrect input! Try again.\n");
+
+			err = mv_create_source(&mvSource);
+			if (err != MEDIA_VISION_ERROR_NONE) {
+				printf("Fail to create mvSource.\n");
+				free(in_file_name);
+				break;
+			}
+
+			err = load_mv_source_from_file(in_file_name, mvSource);
+			if (err != MEDIA_VISION_ERROR_NONE) {
+				int err2 = mv_destroy_source(mvSource);
+				if (err2 != MEDIA_VISION_ERROR_NONE)
+					printf("Fail to destroy mvSource.\n", err2);
+				mvSource = NULL;
+				free(in_file_name);
+				break;
+			}
+			free(in_file_name);
+
+			struct timespec s_tspec;
+			struct timespec e_tspec;
+
+			clock_gettime(CLOCK_MONOTONIC, &s_tspec);
+
+			// Object Detect
+			err = mv_inference_facial_landmark_detect(
+					mvSource, infer, NULL, _facial_landmark_detected_cb, NULL);
+
+			clock_gettime(CLOCK_MONOTONIC, &e_tspec);
+
+			struct timespec diffspec = diff(s_tspec, e_tspec);
+			unsigned long timeDiff = gettotalmillisec(diffspec);
+			printf("elased time : %lu(ms)\n", timeDiff);
+		} break;
+		case 6: {
+			//perform destroy
+			if (engine_cfg) {
+				err = mv_destroy_engine_config(engine_cfg);
+				if (err != MEDIA_VISION_ERROR_NONE)
+					printf("Fail to destroy engine_cfg [err:%i]\n", err);
+				engine_cfg = NULL;
+			}
+
+			if (infer) {
+				err = mv_inference_destroy(infer);
+				if (err != MEDIA_VISION_ERROR_NONE)
+					printf("Fail to destroy inference handle [err:%i]\n", err);
+				infer = NULL;
+			}
+
+			if (mvSource) {
+				err = mv_destroy_source(mvSource);
+				if (err != MEDIA_VISION_ERROR_NONE)
+					printf("Fail to destroy mvSource [err:%i]\n", err);
+				mvSource = NULL;
+			}
+		} break;
+		default:
+			printf("Invalid option.\n");
+			sel_opt = 0;
+			continue;
+		}
+
+		int do_another = 0;
+		if (err != MEDIA_VISION_ERROR_NONE) {
+			printf("ERROR: Action is finished with error code: %i\n");
+		}
+
+		sel_opt = 0;
+		const int options_last[2] = { 1, 2 };
+		const char *names_last[2] = { "Yes", "No" };
+
+		while (sel_opt == 0) {
+			sel_opt = show_menu(
+					"Run Facial Landmark Detection again?:", options_last,
+					names_last, ARRAY_SIZE(options_last));
+			switch (sel_opt) {
+			case 1:
+				do_another = 1;
+				break;
+			case 2:
+				do_another = 0;
+				break;
+			default:
+				printf("Invalid option.\n");
+				sel_opt = 0;
+			}
+		}
+
+		sel_opt = (do_another == 1) ? 0 : 1;
+	}
+
+	if (engine_cfg) {
+		err = mv_destroy_engine_config(engine_cfg);
+		if (err != MEDIA_VISION_ERROR_NONE)
+			printf("Fail to destroy engine_cfg [err:%i]\n", err);
+		engine_cfg = NULL;
+	}
+
+	if (infer) {
+		err = mv_inference_destroy(infer);
+		if (err != MEDIA_VISION_ERROR_NONE)
+			printf("Fail to destroy inference handle [err:%i]\n", err);
+		infer = NULL;
+	}
+
+	if (mvSource) {
+		err = mv_destroy_source(mvSource);
+		if (err != MEDIA_VISION_ERROR_NONE)
+			printf("Fail to destroy mvSource [err:%i]\n", err);
+		mvSource = NULL;
+	}
+
+	return MEDIA_VISION_ERROR_NONE;
 }
 
 int perform_armnn_pose_estimation_detection(mv_engine_config_h *engine_cfg)
 {
-    int err = MEDIA_VISION_ERROR_NONE;
-
-    mv_engine_config_h handle = NULL;
-    err = mv_create_engine_config(&handle);
-    if (err != MEDIA_VISION_ERROR_NONE) {
-        printf("Fail to create engine configuration handle.\n");
-        if (handle) {
-            int err2 = mv_destroy_engine_config(handle);
-            if (err2 != MEDIA_VISION_ERROR_NONE) {
-                printf("Fail to destroy engine cofniguration.\n");
-            }
-        }
-        return err;
-    }
-
-    char *inputNodeName = "image";
-    char *outputNodeName[1] = {"Convolutional_Pose_Machine/stage_5_out"};
-
-    mv_engine_config_set_string_attribute(handle,
-                        MV_INFERENCE_MODEL_WEIGHT_FILE_PATH,
-                        PE_TFLITE_WEIGHT_PATH);
+	int err = MEDIA_VISION_ERROR_NONE;
 
-	mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_DATA_TYPE,
-                        MV_INFERENCE_DATA_FLOAT32);
+	mv_engine_config_h handle = NULL;
+	err = mv_create_engine_config(&handle);
+	if (err != MEDIA_VISION_ERROR_NONE) {
+		printf("Fail to create engine configuration handle.\n");
+		if (handle) {
+			int err2 = mv_destroy_engine_config(handle);
+			if (err2 != MEDIA_VISION_ERROR_NONE) {
+				printf("Fail to destroy engine cofniguration.\n");
+			}
+		}
+		return err;
+	}
 
-    mv_engine_config_set_double_attribute(handle,
-                        MV_INFERENCE_MODEL_MEAN_VALUE,
-                        0.0);
+	char *inputNodeName = "image";
+	char *outputNodeName[1] = { "Convolutional_Pose_Machine/stage_5_out" };
 
-    mv_engine_config_set_double_attribute(handle,
-                        MV_INFERENCE_MODEL_STD_VALUE,
-                        1.0);
+	mv_engine_config_set_string_attribute(
+			handle, MV_INFERENCE_MODEL_WEIGHT_FILE_PATH, PE_TFLITE_WEIGHT_PATH);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_BACKEND_TYPE,
-                        MV_INFERENCE_BACKEND_ARMNN);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_INPUT_DATA_TYPE,
+									   MV_INFERENCE_DATA_FLOAT32);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_TARGET_TYPE,
-                        MV_INFERENCE_TARGET_CPU);
+	mv_engine_config_set_double_attribute(handle, MV_INFERENCE_MODEL_MEAN_VALUE,
+										  0.0);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_TENSOR_WIDTH,
-                        192);
+	mv_engine_config_set_double_attribute(handle, MV_INFERENCE_MODEL_STD_VALUE,
+										  1.0);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_TENSOR_HEIGHT,
-                        192);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_BACKEND_TYPE,
+									   MV_INFERENCE_BACKEND_ARMNN);
 
-    mv_engine_config_set_int_attribute(handle,
-                        MV_INFERENCE_INPUT_TENSOR_CHANNELS,
-                        3);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_TARGET_TYPE,
+									   MV_INFERENCE_TARGET_CPU);
 
-    mv_engine_config_set_string_attribute(handle,
-                        MV_INFERENCE_INPUT_NODE_NAME,
-                        inputNodeName);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_INPUT_TENSOR_WIDTH,
+									   192);
 
-    mv_engine_config_set_array_string_attribute(handle,
-                        MV_INFERENCE_OUTPUT_NODE_NAMES,
-                        outputNodeName,
-                        1);
+	mv_engine_config_set_int_attribute(handle, MV_INFERENCE_INPUT_TENSOR_HEIGHT,
+									   192);
 
-    *engine_cfg = handle;
-    return err;
+	mv_engine_config_set_int_attribute(handle,
+									   MV_INFERENCE_INPUT_TENSOR_CHANNELS, 3);
+
+	mv_engine_config_set_string_attribute(handle, MV_INFERENCE_INPUT_NODE_NAME,
+										  inputNodeName);
+
+	mv_engine_config_set_array_string_attribute(
+			handle, MV_INFERENCE_OUTPUT_NODE_NAMES, outputNodeName, 1);
+
+	*engine_cfg = handle;
+	return err;
 }
 
 int perform_pose_estimation_detection()
 {
-    int err = MEDIA_VISION_ERROR_NONE;
-
-    int sel_opt = 0;
-    const int options[5] = {1, 2, 3, 4, 5};
-    const *names[5] = { "Configuration",
-                        "ARMNN(CPU) + PoseEstimation",
-                        "Prepare",
-                        "Run",
-                        "Back"};
-
-    mv_engine_config_h engine_cfg = NULL;
-    mv_inference_h infer = NULL;
-    mv_source_h mvSource = NULL;
-
-    while(sel_opt == 0) {
-        sel_opt = show_menu("Select Action:", options, names, ARRAY_SIZE(options));
-        switch (sel_opt) {
-        case 1:
-        {
-            //perform configuration
-            if (engine_cfg) {
-                int err2 = mv_destroy_engine_config(engine_cfg);
-                if (err2 != MEDIA_VISION_ERROR_NONE)
-                    printf("Fail to destroy engine_cfg [err:%i]\n", err2);
-            }
-
-            err = perform_configuration(&engine_cfg);
-        }
-            break;
-        case 2:
-        {
-            //perform pose estimation config
-            if (engine_cfg) {
-                int err2 = mv_destroy_engine_config(engine_cfg);
-                if (err2 != MEDIA_VISION_ERROR_NONE)
-                    printf("Fail to destroy engine_cfg [err:%i]\n", err2);
-            }
-            err = perform_armnn_pose_estimation_detection(&engine_cfg);
-        }
-            break;
-        case 3:
-        {
-            // create - configure - prepare
-            if (infer) {
-                int err2 = mv_inference_destroy(infer);
-                if (err2 != MEDIA_VISION_ERROR_NONE) {
-                    printf("Fail to destroy inference handle [err:%i]\n", err2);
-                }
-            }
-
-            // inference
-            // create handle
-            err = mv_inference_create(&infer);
-            if (err != MEDIA_VISION_ERROR_NONE) {
-                printf("Fail to create inference handle [err:%i]\n", err);
-                break;
-            }
-
-            //configure
-            err = mv_inference_configure(infer, engine_cfg);
-            if (err != MEDIA_VISION_ERROR_NONE) {
-                printf("Fail to configure inference handle [err:%i]\n", err);
-                break;
-            }
-
-            //prepare
-            err = mv_inference_prepare(infer);
-            if (err != MEDIA_VISION_ERROR_NONE) {
-                printf("Fail to prepare inference handle");
-                break;
-            }
-        }
-            break;
-        case 4:
-        {
-            if (mvSource) {
-                int err2 = mv_destroy_source(mvSource);
-                if (err2 != MEDIA_VISION_ERROR_NONE);
-                    printf("Fail to destroy mvSource\n");
-            }
-
-            char *in_file_name = NULL;
-            /* Load media source */
-            while (input_string("Input file name to be inferred:", 1024, &(in_file_name)) == -1)
-                printf("Incorrect input! Try again.\n");
-
-            err = mv_create_source(&mvSource);
-            if (err != MEDIA_VISION_ERROR_NONE) {
-                printf("Fail to create mvSource.\n");
-                free(in_file_name);
-                break;
-            }
-
-            err = load_mv_source_from_file(in_file_name, mvSource);
-            if (err != MEDIA_VISION_ERROR_NONE) {
-                int err2 = mv_destroy_source(mvSource);
-                if (err2 != MEDIA_VISION_ERROR_NONE) {
-                    printf("Fail to destroy mvSource.\n", err2);
-                }
-                free(in_file_name);
-                break;
-            }
-            free(in_file_name);
-
-            struct timespec s_tspec;
-            struct timespec e_tspec;
-
-            clock_gettime(CLOCK_MONOTONIC, &s_tspec);
-
-            // Pose estimation
-            err = mv_inference_pose_estimation_detect(mvSource, infer, NULL, _pose_estimation_detected_cb, NULL);
-
-            clock_gettime(CLOCK_MONOTONIC, &e_tspec);
-
-            struct timespec diffspec = diff(s_tspec, e_tspec);
-            unsigned long timeDiff = gettotalmillisec(diffspec);
-            printf("elased time : %lu(ms)\n", timeDiff);
-
-            break;
-        }
-        case 5:
-        {
-            //perform destroy
-            if (engine_cfg) {
-                err = mv_destroy_engine_config(engine_cfg);
-                if (err != MEDIA_VISION_ERROR_NONE) {
-                    printf("Fail to destroy engine_cfg [err:%i]\n", err);
-                }
-            }
-
-            if (infer) {
-                err = mv_inference_destroy(infer);
-                if (err != MEDIA_VISION_ERROR_NONE) {
-                    printf("Fail to destroy inference handle [err:%i]\n", err);
-                }
-            }
-        }
-            break;
-        default:
-            printf("Invalid option.\n");
-            sel_opt = 0;
-            continue;
-        }
-
-        int do_another = 0;
-        if (err != MEDIA_VISION_ERROR_NONE) {
-            printf("ERROR: Action is finished with error code: %i\n");
-        }
-
-        sel_opt = 0;
-        const int options_last[2] = {1, 2};
-        const char *names_last[2] = { "Yes", "No" };
-
-        while (sel_opt == 0) {
-            sel_opt = show_menu("Run Pose Estimation Detection again?:", options_last, names_last, ARRAY_SIZE(options_last));
-            switch(sel_opt) {
-            case 1:
-                do_another = 1;
-                break;
-            case 2:
-                do_another = 0;
-                break;
-            default:
-                printf("Invalid option.\n");
-                sel_opt = 0;
-            }
-        }
-
-        sel_opt = (do_another == 1) ? 0 : 1;
-    }
-
-    return MEDIA_VISION_ERROR_NONE;
+	int err = MEDIA_VISION_ERROR_NONE;
+
+	int sel_opt = 0;
+	const int options[5] = { 1, 2, 3, 4, 5 };
+	const *names[5] = { "Configuration", "ARMNN(CPU) + PoseEstimation",
+						"Prepare", "Run", "Back" };
+
+	mv_engine_config_h engine_cfg = NULL;
+	mv_inference_h infer = NULL;
+	mv_source_h mvSource = NULL;
+
+	while (sel_opt == 0) {
+		sel_opt = show_menu("Select Action:", options, names,
+							ARRAY_SIZE(options));
+		switch (sel_opt) {
+		case 1: {
+			//perform configuration
+			if (engine_cfg) {
+				int err2 = mv_destroy_engine_config(engine_cfg);
+				if (err2 != MEDIA_VISION_ERROR_NONE)
+					printf("Fail to destroy engine_cfg [err:%i]\n", err2);
+			}
+
+			err = perform_configuration(&engine_cfg);
+		} break;
+		case 2: {
+			//perform pose estimation config
+			if (engine_cfg) {
+				int err2 = mv_destroy_engine_config(engine_cfg);
+				if (err2 != MEDIA_VISION_ERROR_NONE)
+					printf("Fail to destroy engine_cfg [err:%i]\n", err2);
+			}
+			err = perform_armnn_pose_estimation_detection(&engine_cfg);
+		} break;
+		case 3: {
+			// create - configure - prepare
+			if (infer) {
+				int err2 = mv_inference_destroy(infer);
+				if (err2 != MEDIA_VISION_ERROR_NONE) {
+					printf("Fail to destroy inference handle [err:%i]\n", err2);
+				}
+			}
+
+			// inference
+			// create handle
+			err = mv_inference_create(&infer);
+			if (err != MEDIA_VISION_ERROR_NONE) {
+				printf("Fail to create inference handle [err:%i]\n", err);
+				break;
+			}
+
+			//configure
+			err = mv_inference_configure(infer, engine_cfg);
+			if (err != MEDIA_VISION_ERROR_NONE) {
+				printf("Fail to configure inference handle [err:%i]\n", err);
+				break;
+			}
+
+			//prepare
+			err = mv_inference_prepare(infer);
+			if (err != MEDIA_VISION_ERROR_NONE) {
+				printf("Fail to prepare inference handle");
+				break;
+			}
+		} break;
+		case 4: {
+			if (mvSource) {
+				int err2 = mv_destroy_source(mvSource);
+				if (err2 != MEDIA_VISION_ERROR_NONE)
+					;
+				printf("Fail to destroy mvSource\n");
+			}
+
+			char *in_file_name = NULL;
+			/* Load media source */
+			while (input_string("Input file name to be inferred:", 1024,
+								&(in_file_name)) == -1)
+				printf("Incorrect input! Try again.\n");
+
+			err = mv_create_source(&mvSource);
+			if (err != MEDIA_VISION_ERROR_NONE) {
+				printf("Fail to create mvSource.\n");
+				free(in_file_name);
+				break;
+			}
+
+			err = load_mv_source_from_file(in_file_name, mvSource);
+			if (err != MEDIA_VISION_ERROR_NONE) {
+				int err2 = mv_destroy_source(mvSource);
+				if (err2 != MEDIA_VISION_ERROR_NONE) {
+					printf("Fail to destroy mvSource.\n", err2);
+				}
+				free(in_file_name);
+				break;
+			}
+			free(in_file_name);
+
+			struct timespec s_tspec;
+			struct timespec e_tspec;
+
+			clock_gettime(CLOCK_MONOTONIC, &s_tspec);
+
+			// Pose estimation
+			err = mv_inference_pose_estimation_detect(
+					mvSource, infer, NULL, _pose_estimation_detected_cb, NULL);
+
+			clock_gettime(CLOCK_MONOTONIC, &e_tspec);
+
+			struct timespec diffspec = diff(s_tspec, e_tspec);
+			unsigned long timeDiff = gettotalmillisec(diffspec);
+			printf("elased time : %lu(ms)\n", timeDiff);
+
+			break;
+		}
+		case 5: {
+			//perform destroy
+			if (engine_cfg) {
+				err = mv_destroy_engine_config(engine_cfg);
+				if (err != MEDIA_VISION_ERROR_NONE) {
+					printf("Fail to destroy engine_cfg [err:%i]\n", err);
+				}
+			}
+
+			if (infer) {
+				err = mv_inference_destroy(infer);
+				if (err != MEDIA_VISION_ERROR_NONE) {
+					printf("Fail to destroy inference handle [err:%i]\n", err);
+				}
+			}
+		} break;
+		default:
+			printf("Invalid option.\n");
+			sel_opt = 0;
+			continue;
+		}
+
+		int do_another = 0;
+		if (err != MEDIA_VISION_ERROR_NONE) {
+			printf("ERROR: Action is finished with error code: %i\n");
+		}
+
+		sel_opt = 0;
+		const int options_last[2] = { 1, 2 };
+		const char *names_last[2] = { "Yes", "No" };
+
+		while (sel_opt == 0) {
+			sel_opt = show_menu(
+					"Run Pose Estimation Detection again?:", options_last,
+					names_last, ARRAY_SIZE(options_last));
+			switch (sel_opt) {
+			case 1:
+				do_another = 1;
+				break;
+			case 2:
+				do_another = 0;
+				break;
+			default:
+				printf("Invalid option.\n");
+				sel_opt = 0;
+			}
+		}
+
+		sel_opt = (do_another == 1) ? 0 : 1;
+	}
+
+	return MEDIA_VISION_ERROR_NONE;
 }
 
 int main()
 {
-    int sel_opt = 0;
-
-    const int options[6] = {1, 2, 3, 4, 5, 6};
-    const char *names[6] = { "Image Classification",
-                             "Object Detection",
-                             "Face Detection",
-                             "Facial LandmarkDetection",
-                             "Pose Estimation",
-                             "Exit"};
-
-    int err = MEDIA_VISION_ERROR_NONE;
-    while (sel_opt == 0) {
-        sel_opt = show_menu("Select Action:", options, names, ARRAY_SIZE(options));
-        switch (sel_opt) {
-        case 1:
-        {
-            err = perform_image_classification();
-            if (err != MEDIA_VISION_ERROR_NONE) {
-                printf("Fail to perform image classification\n");
-            }
-        }
-            break;
-        case 2:
-        {
-            err = perform_object_detection();
-            if (err != MEDIA_VISION_ERROR_NONE) {
-                printf("Fail to perform object detection\n");
-            }
-        }
-            break;
-        case 3:
-        {
-            err = perform_face_detection();
-            if (err != MEDIA_VISION_ERROR_NONE) {
-                printf("Fail to perform face detection\n");
-            }
-        }
-            break;
-        case 4:
-        {
-            err = perform_facial_landmark_detection();
-            if (err != MEDIA_VISION_ERROR_NONE) {
-                printf("Fail to perform facial landmark detection");
-            }
-            break;
-        }
-        case 5:
-        {
-            err = perform_pose_estimation_detection();
-            if (err != MEDIA_VISION_ERROR_NONE) {
-                printf("Fail to perform pose estimation");
-            }
-            break;
-        }
-        case 6:
-        {
-            printf("Exit");
-        }
-            break;
-        default:
-            printf("Invalid option");
-            sel_opt = 0;
-            continue;
-        }
-
-        int do_another = 0;
-        if (err != MEDIA_VISION_ERROR_NONE) {
-            printf("ERROR: Action is finished with error code: %i\n");
-        }
-
-        sel_opt = 0;
-        const int options_last[2] = { 1, 2 };
-        const char *names_last[2] = { "Yes", "No" };
-
-        while (sel_opt == 0) {
-            sel_opt = show_menu("Another action?: ", options_last, names_last, 2);
-            switch (sel_opt) {
-            case 1:
-                do_another = 1;
-                break;
-            case 2:
-                do_another = 0;
-                break;
-            default:
-                printf("Invalid option.\n");
-                sel_opt = 0;
-            }
-        }
-
-        sel_opt = (do_another == 1) ? 0 : 1;
-    }
-
-    return 0;
+	int sel_opt = 0;
+
+	const int options[6] = { 1, 2, 3, 4, 5, 6 };
+	const char *names[6] = { "Image Classification", "Object Detection",
+							 "Face Detection",		 "Facial LandmarkDetection",
+							 "Pose Estimation",		 "Exit" };
+
+	int err = MEDIA_VISION_ERROR_NONE;
+	while (sel_opt == 0) {
+		sel_opt = show_menu("Select Action:", options, names,
+							ARRAY_SIZE(options));
+		switch (sel_opt) {
+		case 1: {
+			err = perform_image_classification();
+			if (err != MEDIA_VISION_ERROR_NONE) {
+				printf("Fail to perform image classification\n");
+			}
+		} break;
+		case 2: {
+			err = perform_object_detection();
+			if (err != MEDIA_VISION_ERROR_NONE) {
+				printf("Fail to perform object detection\n");
+			}
+		} break;
+		case 3: {
+			err = perform_face_detection();
+			if (err != MEDIA_VISION_ERROR_NONE) {
+				printf("Fail to perform face detection\n");
+			}
+		} break;
+		case 4: {
+			err = perform_facial_landmark_detection();
+			if (err != MEDIA_VISION_ERROR_NONE) {
+				printf("Fail to perform facial landmark detection");
+			}
+			break;
+		}
+		case 5: {
+			err = perform_pose_estimation_detection();
+			if (err != MEDIA_VISION_ERROR_NONE) {
+				printf("Fail to perform pose estimation");
+			}
+			break;
+		}
+		case 6: {
+			printf("Exit");
+		} break;
+		default:
+			printf("Invalid option");
+			sel_opt = 0;
+			continue;
+		}
+
+		int do_another = 0;
+		if (err != MEDIA_VISION_ERROR_NONE) {
+			printf("ERROR: Action is finished with error code: %i\n");
+		}
+
+		sel_opt = 0;
+		const int options_last[2] = { 1, 2 };
+		const char *names_last[2] = { "Yes", "No" };
+
+		while (sel_opt == 0) {
+			sel_opt =
+					show_menu("Another action?: ", options_last, names_last, 2);
+			switch (sel_opt) {
+			case 1:
+				do_another = 1;
+				break;
+			case 2:
+				do_another = 0;
+				break;
+			default:
+				printf("Invalid option.\n");
+				sel_opt = 0;
+			}
+		}
+
+		sel_opt = (do_another == 1) ? 0 : 1;
+	}
+
+	return 0;
 }