path: root/test/testsuites/barcode/barcode_test_suite.c

/**
 * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <mv_barcode.h>

#include <image_helper.h>
#include <mv_private.h>

#include <ctype.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>

#include <libswscale/swscale.h>
#include <libavcodec/avcodec.h>
#include <libavutil/pixfmt.h>

#include <curses.h>
#include <error.h>
#include <argp.h>

#define MINX 0
#define MINY 0
#define MANUAL 0
#define AUTO 1
#define MININTERVAL 0
#define MAXINTERVAL 9

#define ARRAY_SIZE(x) (sizeof((x)) / sizeof((x)[0]))

typedef struct {
	mv_barcode_type_e type;
	mv_barcode_qr_ecc_e ecc;
	mv_barcode_qr_mode_e mode;
	int is_hrt;
	int version;
	size_t width;
	size_t height;
	mv_barcode_image_format_e out_image_format;
	mv_colorspace_e colorspace;
	char *message;
	char *file_name;
	char *out_file_name;
	unsigned char *out_buffer_ptr;
	char *front_color;
	char *back_color;
} barcode_model_s;

typedef enum { MV_TS_GENERATE_TO_IMAGE_FCN, MV_TS_GENERATE_TO_SOURCE_FCN } generation_fcn_e;

static int current_y = MINY;
static int mode = MANUAL;
static int test_interval = 0;

static const char doc[] = "mv_barcode_test -- mediavision barcode test";
static const char args_doc[] = "";

static struct argp_option arg_options[] = {
	{ "mode", 'm', "MODE", OPTION_ARG_OPTIONAL, "Run test by MODE [0=manual|1=auto] (default 0)" },
	{ "interval", 'i', "TIME", OPTION_ARG_OPTIONAL, "Run test by TIME (default 0 sec, maximum 9 sec) interval" },
	{ 0 }
};

struct arguments {
	int mode;
	int interval;
};

int convert_rgb_to(unsigned char *src_buffer, unsigned char **dst_buffer, image_data_s image_data,
				   mv_colorspace_e dst_colorspace, unsigned long *cvt_buffer_size)
{
	enum AVPixelFormat pixel_format = AV_PIX_FMT_NONE;

	MEDIA_VISION_FUNCTION_ENTER();

	switch (dst_colorspace) {
	case MEDIA_VISION_COLORSPACE_Y800:
		pixel_format = AV_PIX_FMT_GRAY8;
		break;
	case MEDIA_VISION_COLORSPACE_I420:
		pixel_format = AV_PIX_FMT_YUV420P;
		break;
	case MEDIA_VISION_COLORSPACE_NV12:
		pixel_format = AV_PIX_FMT_NV12;
		break;
	case MEDIA_VISION_COLORSPACE_YV12:
		/* the same as I420 with inversed U and V */
		pixel_format = AV_PIX_FMT_YUV420P;
		break;
	case MEDIA_VISION_COLORSPACE_NV21:
		pixel_format = AV_PIX_FMT_NV21;
		break;
	case MEDIA_VISION_COLORSPACE_YUYV:
		pixel_format = AV_PIX_FMT_YUYV422;
		break;
	case MEDIA_VISION_COLORSPACE_UYVY:
		pixel_format = AV_PIX_FMT_UYVY422;
		break;
	case MEDIA_VISION_COLORSPACE_422P:
		pixel_format = AV_PIX_FMT_YUV422P;
		break;
	case MEDIA_VISION_COLORSPACE_RGB565:
		pixel_format = AV_PIX_FMT_RGB565BE;
		break;
	case MEDIA_VISION_COLORSPACE_RGBA:
		pixel_format = AV_PIX_FMT_RGBA;
		break;
	case MEDIA_VISION_COLORSPACE_RGB888:
		*cvt_buffer_size = image_data.image_width * image_data.image_height * 3;
		(*dst_buffer) = (unsigned char *) malloc(*cvt_buffer_size);
		memcpy(*dst_buffer, src_buffer, *cvt_buffer_size);

		MEDIA_VISION_FUNCTION_LEAVE();
		return MEDIA_VISION_ERROR_NONE;
	default:
		MEDIA_VISION_FUNCTION_LEAVE();
		return MEDIA_VISION_ERROR_NOT_SUPPORTED;
	}

	AVPicture src_picture;
	AVPicture dst_picture;

	avpicture_fill(&src_picture, (uint8_t *) src_buffer, AV_PIX_FMT_RGB24, image_data.image_width,
				   image_data.image_height);

	avpicture_alloc(&dst_picture, pixel_format, image_data.image_width, image_data.image_height);

	struct SwsContext *context = sws_getContext(image_data.image_width, image_data.image_height, AV_PIX_FMT_RGB24,
												image_data.image_width, image_data.image_height, pixel_format,
												SWS_FAST_BILINEAR, 0, 0, 0);

	sws_scale(context, (const uint8_t *const *) src_picture.data, src_picture.linesize, 0, image_data.image_height,
			  dst_picture.data, dst_picture.linesize);

	int picture_size = avpicture_get_size(pixel_format, image_data.image_width, image_data.image_height);
	if (picture_size < 0) {
		avpicture_free(&dst_picture);
		MEDIA_VISION_FUNCTION_LEAVE();
		return MEDIA_VISION_ERROR_OUT_OF_MEMORY;
	}
	*cvt_buffer_size = (unsigned long) picture_size;

	(*dst_buffer) = (unsigned char *) malloc(*cvt_buffer_size);
	memcpy(*dst_buffer, dst_picture.data[0], *cvt_buffer_size);

	avpicture_free(&dst_picture);

	MEDIA_VISION_FUNCTION_LEAVE();

	return MEDIA_VISION_ERROR_NONE;
}

int find_min_x(const mv_quadrangle_s *quadrangle, int *minX)
{
	MEDIA_VISION_FUNCTION_ENTER();

	if (NULL == quadrangle) {
		MEDIA_VISION_FUNCTION_LEAVE();
		return MEDIA_VISION_ERROR_INVALID_PARAMETER;
	}

	*minX = quadrangle->points[0].x;
	*minX = quadrangle->points[1].x < *minX ? quadrangle->points[1].x : *minX;
	*minX = quadrangle->points[2].x < *minX ? quadrangle->points[2].x : *minX;
	*minX = quadrangle->points[3].x < *minX ? quadrangle->points[3].x : *minX;

	MEDIA_VISION_FUNCTION_LEAVE();

	return MEDIA_VISION_ERROR_NONE;
}

int find_min_y(const mv_quadrangle_s *quadrangle, int *minY)
{
	MEDIA_VISION_FUNCTION_ENTER();

	if (NULL == quadrangle) {
		MEDIA_VISION_FUNCTION_LEAVE();
		return MEDIA_VISION_ERROR_INVALID_PARAMETER;
	}

	*minY = quadrangle->points[0].y;
	*minY = quadrangle->points[1].y < *minY ? quadrangle->points[1].y : *minY;
	*minY = quadrangle->points[2].y < *minY ? quadrangle->points[2].y : *minY;
	*minY = quadrangle->points[3].y < *minY ? quadrangle->points[3].y : *minY;

	MEDIA_VISION_FUNCTION_LEAVE();

	return MEDIA_VISION_ERROR_NONE;
}

int find_max_x(const mv_quadrangle_s *quadrangle, int *maxX)
{
	MEDIA_VISION_FUNCTION_ENTER();

	if (NULL == quadrangle) {
		MEDIA_VISION_FUNCTION_LEAVE();
		return MEDIA_VISION_ERROR_INVALID_PARAMETER;
	}

	*maxX = quadrangle->points[0].x;
	*maxX = quadrangle->points[1].x > *maxX ? quadrangle->points[1].x : *maxX;
	*maxX = quadrangle->points[2].x > *maxX ? quadrangle->points[2].x : *maxX;
	*maxX = quadrangle->points[3].x > *maxX ? quadrangle->points[3].x : *maxX;

	MEDIA_VISION_FUNCTION_LEAVE();

	return MEDIA_VISION_ERROR_NONE;
}

int find_max_y(const mv_quadrangle_s *quadrangle, int *maxY)
{
	MEDIA_VISION_FUNCTION_ENTER();

	if (NULL == quadrangle) {
		MEDIA_VISION_FUNCTION_LEAVE();
		return MEDIA_VISION_ERROR_INVALID_PARAMETER;
	}

	*maxY = quadrangle->points[0].y;
	*maxY = quadrangle->points[1].y > *maxY ? quadrangle->points[1].y : *maxY;
	*maxY = quadrangle->points[2].y > *maxY ? quadrangle->points[2].y : *maxY;
	*maxY = quadrangle->points[3].y > *maxY ? quadrangle->points[3].y : *maxY;

	MEDIA_VISION_FUNCTION_LEAVE();

	return MEDIA_VISION_ERROR_NONE;
}

bool _mv_engine_config_supported_attribute(mv_config_attribute_type_e attribute_type, const char *attribute_name,
										   void *user_data)
{
	mvprintw(current_y++, MINX, "Callback call for engine configuration attribute");

	if (user_data == NULL)
		return false;

	mv_engine_config_h mv_engine_config = (mv_engine_config_h *) user_data;

	int int_value = 0;
	double double_value = 0.0;
	bool bool_value = false;
	char *str_value = NULL;
	switch (attribute_type) {
	case MV_ENGINE_CONFIG_ATTR_TYPE_DOUBLE:
		if (MEDIA_VISION_ERROR_KEY_NOT_AVAILABLE ==
			mv_engine_config_get_double_attribute(mv_engine_config, attribute_name, &double_value)) {
			mvprintw(current_y++, MINX, "Default double attribute %s wasn't set in engine", attribute_name);
			return false;
		}
		mvprintw(current_y++, MINX, "Default double attribute %s was set to %f in engine", attribute_name,
				 double_value);
		break;
	case MV_ENGINE_CONFIG_ATTR_TYPE_INTEGER:
		if (MEDIA_VISION_ERROR_KEY_NOT_AVAILABLE ==
			mv_engine_config_get_int_attribute(mv_engine_config, attribute_name, &int_value)) {
			mvprintw(current_y++, MINX, "Default integer attribute %s wasn't set in engine", attribute_name);
			return false;
		}
		mvprintw(current_y++, MINX, "Default integer attribute %s was set to %d in engine", attribute_name, int_value);
		break;
	case MV_ENGINE_CONFIG_ATTR_TYPE_BOOLEAN:
		if (MEDIA_VISION_ERROR_KEY_NOT_AVAILABLE ==
			mv_engine_config_get_bool_attribute(mv_engine_config, attribute_name, &bool_value)) {
			mvprintw(current_y++, MINX, "Default bool attribute %s wasn't set in engine", attribute_name);
			return false;
		}
		mvprintw(current_y++, MINX, "Default bool attribute %s was set to %s in engine", attribute_name,
				 bool_value ? "TRUE" : "FALSE");
		break;
	case MV_ENGINE_CONFIG_ATTR_TYPE_STRING:
		if (MEDIA_VISION_ERROR_KEY_NOT_AVAILABLE ==
			mv_engine_config_get_string_attribute(mv_engine_config, attribute_name, &str_value)) {
			mvprintw(current_y++, MINX, "Default string attribute %s wasn't set in engine", attribute_name);
			return false;
		}
		mvprintw(current_y++, MINX, "Default string attribute %s was set to %s in engine", attribute_name, str_value);

		free(str_value);
		str_value = NULL;
		break;
	default:
		mvprintw(current_y++, MINX, "Not supported attribute type");
		return false;
	}

	return true;
}

void barcode_detected_cb(mv_source_h source, mv_engine_config_h engine_cfg, const mv_quadrangle_s *barcodes_locations,
						 const char *messages[], const mv_barcode_type_e *types, int number_of_barcodes,
						 void *user_data)
{
	MEDIA_VISION_FUNCTION_ENTER();

	mvprintw(current_y++, MINX, "%i barcodes were detected on the image.", number_of_barcodes);
	if (number_of_barcodes > 0) {
		int is_source_data_loaded = 0;

		char *file_name = NULL;
		unsigned char *out_buffer = NULL;
		unsigned char *draw_buffer = NULL;
		unsigned int buf_size = 0;
		image_data_s image_data = { 0, 0, MEDIA_VISION_COLORSPACE_INVALID };
		/* Check Media Vision source: */
		if (MEDIA_VISION_ERROR_NONE != mv_source_get_buffer(source, &out_buffer, &buf_size) ||
			MEDIA_VISION_ERROR_NONE != mv_source_get_width(source, &(image_data.image_width)) ||
			MEDIA_VISION_ERROR_NONE != mv_source_get_height(source, &(image_data.image_height)) ||
			MEDIA_VISION_ERROR_NONE != mv_source_get_colorspace(source, &(image_data.image_colorspace)) ||
			user_data == NULL) {
			mvprintw(current_y++, MINX, "ERROR : Creating out image is impossible.");
		} else {
			file_name = ((barcode_model_s *) user_data)->out_file_name;
			draw_buffer = ((barcode_model_s *) user_data)->out_buffer_ptr;
			image_data.image_colorspace = MEDIA_VISION_COLORSPACE_RGB888;
			is_source_data_loaded = 1;
		}

		int i = 0;
		for (i = 0; i < number_of_barcodes; ++i) {
			const char *cur_message = messages[i];
			mv_barcode_type_e cur_type = types[i];
			const char *str_type = NULL;
			switch (cur_type) {
			case MV_BARCODE_QR:
				str_type = "QR";
				break;
			case MV_BARCODE_UPC_A:
				str_type = "UPC-A";
				break;
			case MV_BARCODE_UPC_E:
				str_type = "UPC-E";
				break;
			case MV_BARCODE_EAN_8:
			case MV_BARCODE_EAN_13:
				str_type = "EAN-8/13";
				break;
			case MV_BARCODE_CODE128:
				str_type = "CODE128";
				break;
			case MV_BARCODE_CODE39:
				str_type = "CODE39";
				break;
			case MV_BARCODE_I2_5:
				str_type = "I25";
				break;
			case MV_BARCODE_EAN_2:
				str_type = "EAN_2";
				break;
			case MV_BARCODE_EAN_5:
				str_type = "EAN_5";
				break;
			case MV_BARCODE_CODE93:
				str_type = "CODE93";
				break;
			case MV_BARCODE_CODABAR:
				str_type = "CODABAR";
				break;
			case MV_BARCODE_DATABAR:
				str_type = "DATABAR";
				break;
			case MV_BARCODE_DATABAR_EXPAND:
				str_type = "DATABAR_EXPAND";
				break;
			default:
				str_type = "Undetected";
				break;
			}
			mvprintw(current_y++, MINX, "\tBarcode %i : type is %s", i, str_type);
			if (cur_message != NULL)
				mvprintw(current_y++, MINX, "\t            message is %s", cur_message);
			else
				mvprintw(current_y++, MINX, "\t            message wasn't detected");

			if (is_source_data_loaded == 1) {
				int minX = 0;
				int minY = 0;
				int maxX = 0;
				int maxY = 0;
				if (MEDIA_VISION_ERROR_NONE != find_min_x(&barcodes_locations[i], &minX) ||
					MEDIA_VISION_ERROR_NONE != find_min_y(&barcodes_locations[i], &minY) ||
					MEDIA_VISION_ERROR_NONE != find_max_x(&barcodes_locations[i], &maxX) ||
					MEDIA_VISION_ERROR_NONE != find_max_y(&barcodes_locations[i], &maxY)) {
					continue;
				}

				const int drawing_color[] = { 255, 0, 0 };

				if (MEDIA_VISION_ERROR_NONE !=
					draw_rectangle_on_buffer(minX, minY, maxX, maxY, 6, drawing_color, &image_data, draw_buffer))
					continue;
			}
		}

		if (file_name != NULL &&
			MEDIA_VISION_ERROR_NONE == save_image_from_buffer(file_name, draw_buffer, &image_data, 100))
			mvprintw(current_y++, MINX, "Image was generated as %s", file_name);
		else
			mvprintw(current_y++, MINX, "ERROR : Failed to generate output file. Check file name and permissions.");

		current_y++;
	}
	getch();

	MEDIA_VISION_FUNCTION_LEAVE();
}

int generate_barcode_to_image(barcode_model_s model)
{
	MEDIA_VISION_FUNCTION_ENTER();

	if (model.message == NULL || model.file_name == NULL) {
		MEDIA_VISION_FUNCTION_LEAVE();

		return MEDIA_VISION_ERROR_INVALID_PARAMETER;
	}

	LOGI("Call the mv_barcode_generate_image() function");

	mv_engine_config_h mv_engine_config;
	int err = mv_create_engine_config(&mv_engine_config);

	if (MEDIA_VISION_ERROR_NONE != err) {
		mvprintw(current_y++, MINX,
				 "ERROR : Errors were occurred during creating the media engine "
				 "config : %i",
				 err);
		MEDIA_VISION_FUNCTION_LEAVE();

		return err;
	}

	err = mv_engine_config_set_int_attribute(mv_engine_config, MV_BARCODE_GENERATE_ATTR_TEXT, model.is_hrt);
	if (MEDIA_VISION_ERROR_NONE != err) {
		mvprintw(current_y++, MINX,
				 "ERROR : Errors were occurred during set integer attribute to "
				 "media engine config : %i",
				 err);
		goto cleanup;
	}

	err = mv_engine_config_set_string_attribute(mv_engine_config, MV_BARCODE_GENERATE_ATTR_COLOR_FRONT,
												model.front_color);
	if (MEDIA_VISION_ERROR_NONE != err) {
		mvprintw(current_y++, MINX,
				 "ERROR : Errors were occurred during set string attribute to "
				 "media engine config : %i",
				 err);
		goto cleanup;
	}

	err = mv_engine_config_set_string_attribute(mv_engine_config, MV_BARCODE_GENERATE_ATTR_COLOR_BACK,
												model.back_color);
	if (MEDIA_VISION_ERROR_NONE != err) {
		mvprintw(current_y++, MINX,
				 "ERROR : Errors were occurred during set string attribute to "
				 "media engine config : %i",
				 err);
		goto cleanup;
	}
	err = mv_barcode_generate_image(mv_engine_config, model.message, model.width, model.height, model.type, model.mode,
									model.ecc, model.version, model.file_name, model.out_image_format);
	if (MEDIA_VISION_ERROR_NONE != err)
		mvprintw(current_y++, MINX, "ERROR : Errors were occurred during generate image error : %i", err);
cleanup:
	if (MEDIA_VISION_ERROR_NONE != err) {
		int err2 = mv_destroy_engine_config(mv_engine_config);
		if (MEDIA_VISION_ERROR_NONE != err2)
			mvprintw(current_y++, MINX, "ERROR : Errors were occurred during destroying the media engine config : %i",
					 err2);

	} else {
		err = mv_destroy_engine_config(mv_engine_config);
		if (MEDIA_VISION_ERROR_NONE != err)
			mvprintw(current_y++, MINX, "ERROR : Errors were occurred during destroying the media engine config : %i",
					 err);
	}
	MEDIA_VISION_FUNCTION_LEAVE();
	return err;
}
int generate_barcode_to_source(barcode_model_s model)
{
	MEDIA_VISION_FUNCTION_ENTER();

	if (model.message == NULL || model.file_name == NULL) {
		MEDIA_VISION_FUNCTION_LEAVE();

		return MEDIA_VISION_ERROR_INVALID_PARAMETER;
	}

	LOGI("mv_source_h creation started");

	mv_source_h source = NULL;
	int err = mv_create_source(&source);
	if (MEDIA_VISION_ERROR_NONE != err) {
		mvprintw(current_y++, MINX,
				 "ERROR : Error occurred when trying to create Media Vision "
				 "source. Error code : %i",
				 err);

		MEDIA_VISION_FUNCTION_LEAVE();

		return err;
	}

	LOGI("mv_source_h creation finished");

	LOGI("Call the mv_barcode_generate_source() function");

	mv_engine_config_h mv_engine_config;
	err = mv_create_engine_config(&mv_engine_config);
	if (MEDIA_VISION_ERROR_NONE != err) {
		mvprintw(current_y++, MINX,
				 "ERROR : Errors were occurred during creating the media engine "
				 "config : %i",
				 err);
		goto clean_source;
	}

	err = mv_engine_config_set_string_attribute(mv_engine_config, MV_BARCODE_GENERATE_ATTR_COLOR_FRONT,
												model.front_color);
	if (MEDIA_VISION_ERROR_NONE != err) {
		mvprintw(current_y++, MINX,
				 "ERROR : Errors were occurred during set string attribute to "
				 "media engine config : %i",
				 err);
		goto clean_all;
	}

	err = mv_engine_config_set_string_attribute(mv_engine_config, MV_BARCODE_GENERATE_ATTR_COLOR_BACK,
												model.back_color);
	if (MEDIA_VISION_ERROR_NONE != err) {
		mvprintw(current_y++, MINX,
				 "ERROR : Errors were occurred during set string attribute to "
				 "media engine config : %i",
				 err);
		goto clean_all;
	}

	err = mv_barcode_generate_source(mv_engine_config, model.message, model.type, model.mode, model.ecc, model.version,
									 source);

	if (MEDIA_VISION_ERROR_NONE != err) {
		mvprintw(current_y++, MINX,
				 "ERROR : Error occurred during generation barcode to the "
				 "Media Vision source. Error code : %i",
				 err);
		goto clean_all;
	}

	unsigned char *data_buffer = NULL;
	unsigned int buffer_size = 0;
	unsigned int image_width = 0;
	unsigned int image_height = 0;
	mv_colorspace_e image_colorspace = MEDIA_VISION_COLORSPACE_INVALID;

	err = mv_source_get_buffer(source, &data_buffer, &buffer_size);
	if (MEDIA_VISION_ERROR_NONE != err) {
		mvprintw(current_y++, MINX,
				 "ERROR : Error occurred when trying to get buffer from "
				 "Media Vision source. Error code : %i",
				 err);
		goto clean_all;
	}

	err = mv_source_get_width(source, &image_width);
	if (MEDIA_VISION_ERROR_NONE != err) {
		mvprintw(current_y++, MINX,
				 "ERROR : Error occurred when trying to get width of "
				 "Media Vision source. Error code : %i",
				 err);
		goto clean_all;
	}

	err = mv_source_get_height(source, &image_height);
	if (MEDIA_VISION_ERROR_NONE != err) {
		mvprintw(current_y++, MINX,
				 "ERROR : Error occurred when trying to get height of "
				 "Media Vision source. Error code : %i",
				 err);
		goto clean_all;
	}

	err = mv_source_get_colorspace(source, &image_colorspace);
	if (MEDIA_VISION_ERROR_NONE != err) {
		mvprintw(current_y++, MINX,
				 "ERROR : Error occurred when trying to get colorspace of "
				 "Media Vision source. Error code : %i",
				 err);
		goto clean_all;
	}

	const image_data_s image_data = { image_width, image_height, image_colorspace };

	char *jpeg_file_name;
	if (0 == strcmp(model.file_name + strlen(model.file_name) - 4, ".jpg") ||
		0 == strcmp(model.file_name + strlen(model.file_name) - 5, ".jpeg")) {
		jpeg_file_name = strdup(model.file_name);
		if (jpeg_file_name == NULL) {
			err = MEDIA_VISION_ERROR_OUT_OF_MEMORY;
			goto clean_all;
		}
	} else {
		size_t size = strlen(model.file_name);
		jpeg_file_name = (char *) malloc(size + 5);
		if (jpeg_file_name == NULL) {
			err = MEDIA_VISION_ERROR_OUT_OF_MEMORY;
			goto clean_all;
		}
		strncpy(jpeg_file_name, model.file_name, size);
		strncat(jpeg_file_name, ".jpg", 4);
	}
	err = save_image_from_buffer(jpeg_file_name, data_buffer, &image_data, 100);
	if (MEDIA_VISION_ERROR_NONE != err) {
		mvprintw(current_y++, MINX,
				 "ERROR : Error occurred when try to save image from buffer."
				 "Error code : %i",
				 err);
	}
	free(jpeg_file_name);
clean_all:
	if (MEDIA_VISION_ERROR_NONE != err) {
		int err2 = mv_destroy_engine_config(mv_engine_config);
		if (MEDIA_VISION_ERROR_NONE != err2)
			mvprintw(current_y++, MINX, "ERROR : Errors were occurred during destroying the media engine config : %i",
					 err2);
	} else {
		err = mv_destroy_engine_config(mv_engine_config);
		if (MEDIA_VISION_ERROR_NONE != err)
			mvprintw(current_y++, MINX, "ERROR : Errors were occurred during destroying the media engine config : %i",
					 err);
	}
clean_source:
	if (MEDIA_VISION_ERROR_NONE != err) {
		int err2 = mv_destroy_source(source);
		if (MEDIA_VISION_ERROR_NONE != err2)
			mvprintw(current_y++, MINX,
					 "ERROR : Error occurred when try to destroy Media Vision source. Error code : %i", err2);
	} else {
		err = mv_destroy_source(source);
		if (MEDIA_VISION_ERROR_NONE != err)
			mvprintw(current_y++, MINX,
					 "ERROR : Error occurred when try to destroy Media Vision source. Error code : %i", err);
	}
	MEDIA_VISION_FUNCTION_LEAVE();
	return err;
}

int detect_barcode(barcode_model_s model, mv_rectangle_s roi)
{
	MEDIA_VISION_FUNCTION_ENTER();

	unsigned char *data_buffer = NULL;
	unsigned long buffer_size = 0;
	image_data_s image_data;

	int err = load_image_to_buffer(model.file_name, &data_buffer, &buffer_size, &image_data);
	if (MEDIA_VISION_ERROR_NONE != err) {
		mvprintw(current_y++, MINX, "ERROR : Errors were occurred during opening the file!!! code : %i", err);

		if (data_buffer != NULL)
			destroy_loaded_buffer(data_buffer);

		MEDIA_VISION_FUNCTION_LEAVE();

		return err;
	}

	unsigned char *converted_buffer = NULL;
	unsigned long converted_buffer_size = 0;
	err = convert_rgb_to(data_buffer, &converted_buffer, image_data, model.colorspace, &converted_buffer_size);
	if (MEDIA_VISION_ERROR_NONE != err) {
		mvprintw(current_y++, MINX, "ERROR : Can't convert to the selected colorspace!!! code : %i", err);

		if (data_buffer != NULL)
			destroy_loaded_buffer(data_buffer);

		free(converted_buffer);

		MEDIA_VISION_FUNCTION_LEAVE();

		return err;
	}

	model.out_buffer_ptr = data_buffer;

	mv_engine_config_h mv_engine_config = NULL;
	err = mv_create_engine_config(&mv_engine_config);
	if (MEDIA_VISION_ERROR_NONE != err)
		mvprintw(current_y++, MINX, "ERROR : Errors were occurred during creating the media engine config : %i", err);

	mv_engine_config_foreach_supported_attribute(_mv_engine_config_supported_attribute, mv_engine_config);

	err = mv_engine_config_set_int_attribute(mv_engine_config, MV_BARCODE_DETECT_ATTR_TARGET,
											 MV_BARCODE_DETECT_ATTR_TARGET_ALL);
	if (MEDIA_VISION_ERROR_NONE != err) {
		mvprintw(current_y++, MINX,
				 "ERROR : Errors were occurred during target attribute"
				 "configuration : %i",
				 err);
	}

	mv_source_h source;
	err = mv_create_source(&source);
	if (MEDIA_VISION_ERROR_NONE != err) {
		mvprintw(current_y++, MINX, "ERROR : Errors were occurred during creating the source!!! code : %i", err);

		if (data_buffer != NULL)
			destroy_loaded_buffer(data_buffer);

		free(converted_buffer);

		if (mv_engine_config)
			mv_destroy_engine_config(mv_engine_config);

		MEDIA_VISION_FUNCTION_LEAVE();

		return err;
	}

	err = mv_source_fill_by_buffer(source, converted_buffer, converted_buffer_size, image_data.image_width,
								   image_data.image_height, model.colorspace);
	if (MEDIA_VISION_ERROR_NONE != err) {
		mvprintw(current_y++, MINX, "ERROR : Errors were occurred during filling the source!!! code : %i", err);

		if (data_buffer != NULL)
			destroy_loaded_buffer(data_buffer);

		free(converted_buffer);

		if (mv_engine_config)
			mv_destroy_engine_config(mv_engine_config);

		mv_destroy_source(source);
		MEDIA_VISION_FUNCTION_LEAVE();

		return err;
	}

	free(converted_buffer);

	err = mv_barcode_detect(source, mv_engine_config, roi, barcode_detected_cb, &model);

	if (data_buffer != NULL)
		destroy_loaded_buffer(data_buffer);

	if (MEDIA_VISION_ERROR_NONE != err)
		mvprintw(current_y++, MINX, "ERROR : Errors were occurred during barcode detection!!! code : %i", err);

	err = mv_destroy_source(source);
	if (MEDIA_VISION_ERROR_NONE != err)
		mvprintw(current_y++, MINX, "ERROR : Errors were occurred during destroying the source!!! code : %i", err);

	err = mv_destroy_engine_config(mv_engine_config);
	if (MEDIA_VISION_ERROR_NONE != err)
		mvprintw(current_y++, MINX, "ERROR : Error were occurred during destroying the source!!! code : %i", err);

	MEDIA_VISION_FUNCTION_LEAVE();

	return err;
}

int input_string(const char *prompt, size_t max_len, char **string)
{
	MEDIA_VISION_FUNCTION_ENTER();

	mvaddstr(current_y++, MINX, prompt);

	char buffer[max_len];
	int err = getnstr(buffer, max_len);
	if (err != OK) {
		LOGE("getnstr failed with error code (0x%08x)", err);
		MEDIA_VISION_FUNCTION_LEAVE();
		return -1;
	}

	size_t string_len = strlen(buffer);
	buffer[string_len] = '\0';
	size_t real_string_len = string_len + 1;
	*string = (char *) malloc(real_string_len * sizeof(char));
	if (*string == NULL) {
		MEDIA_VISION_FUNCTION_LEAVE();
		return -1;
	}

	strncpy(*string, buffer, real_string_len);
	size_t str_len = strlen(*string);

	if (test_interval > 0)
		sleep(test_interval);

	MEDIA_VISION_FUNCTION_LEAVE();

	return str_len;
}

int input_size(const char *prompt, size_t max_size, size_t *size)
{
	MEDIA_VISION_FUNCTION_ENTER();

	char buffer[20];
	mvaddstr(current_y++, MINX, prompt);

	int err = getnstr(buffer, 20);
	if (err != OK) {
		LOGE("getnstr failed with error code (0x%08x)", err);
		MEDIA_VISION_FUNCTION_LEAVE();
		return -1;
	}
	*size = atoi(buffer);
	int ret = (*size > max_size ? -1 : 0);

	if (test_interval > 0)
		sleep(test_interval);

	MEDIA_VISION_FUNCTION_LEAVE();

	return ret;
}

int input_int(const char *prompt, int min_value, int max_value, int *value)
{
	MEDIA_VISION_FUNCTION_ENTER();

	char buffer[20];
	mvaddstr(current_y++, MINX, prompt);

	int err = getnstr(buffer, 20);
	if (err != OK) {
		LOGE("getnstr failed with error code (0x%08x)", err);
		MEDIA_VISION_FUNCTION_LEAVE();
		return -1;
	}
	*value = atoi(buffer);
	int ret = (*value < min_value || *value > max_value ? -1 : 0);

	if (test_interval > 0)
		sleep(test_interval);

	MEDIA_VISION_FUNCTION_LEAVE();

	return ret;
}

int show_menu(const char *title, const int *options, const char **names, int cnt)
{
	MEDIA_VISION_FUNCTION_ENTER();

	erase();
	refresh();

	current_y = MINY;
	mvaddstr(current_y++, MINX, "***************************");
	mvprintw(current_y++, MINX, "* %23s *", title);
	mvaddstr(current_y++, MINX, "*-------------------------*");
	int i = 0;
	for (i = 0; i < cnt; ++i) {
		mvprintw(current_y++, MINX, "* %2i. %19s *", options[i], names[i]);
	}
	mvaddstr(current_y++, MINX, "***************************");

	char buf[256];
	int selection = 0;
	bool condition = false;
	refresh();
	do {
		mvaddstr(current_y++, MINX, "Your Choice : ");
		getstr(&buf);
		selection = atoi(buf);
		condition = selection > options[cnt - 1];
		if (condition)
			mvprintw(current_y++, MINX, "You pressed invalid menu, try again");

		refresh();
	} while (condition);

	if (test_interval > 0)
		sleep(test_interval);

	MEDIA_VISION_FUNCTION_LEAVE();

	return selection;
}

mv_barcode_type_e select_type(void)
{
	mv_barcode_type_e selected_type = MV_BARCODE_UNKNOWN;
	int sel_opt = 0;
	const int options[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 };
	const char *names[] = { "qr",			"upca", "upce", "ean8",	  "ean13",	 "code39",	"code128",
							"interleave25", "ean2", "ean5", "code93", "codabar", "databar", "databarExpand" };

	MEDIA_VISION_FUNCTION_ENTER();

	while (sel_opt == 0) {
		sel_opt = show_menu("Select barcode type : ", options, names, ARRAY_SIZE(options));

		switch (sel_opt) {
		case 1:
			selected_type = MV_BARCODE_QR;
			break;
		case 2:
			selected_type = MV_BARCODE_UPC_A;
			break;
		case 3:
			selected_type = MV_BARCODE_UPC_E;
			break;
		case 4:
			selected_type = MV_BARCODE_EAN_8;
			break;
		case 5:
			selected_type = MV_BARCODE_EAN_13;
			break;
		case 6:
			selected_type = MV_BARCODE_CODE39;
			break;
		case 7:
			selected_type = MV_BARCODE_CODE128;
			break;
		case 8:
			selected_type = MV_BARCODE_I2_5;
			break;
		case 9:
			selected_type = MV_BARCODE_EAN_2;
			break;
		case 10:
			selected_type = MV_BARCODE_EAN_5;
			break;
		case 11:
			selected_type = MV_BARCODE_CODE93;
			break;
		case 12:
			selected_type = MV_BARCODE_CODABAR;
			break;
		case 13:
			selected_type = MV_BARCODE_DATABAR;
			break;
		case 14:
			selected_type = MV_BARCODE_DATABAR_EXPAND;
			break;
		default:
			sel_opt = 0;
			break;
		}
	}

	MEDIA_VISION_FUNCTION_LEAVE();

	return selected_type;
}

mv_barcode_qr_mode_e select_mode(void)
{
	mv_barcode_qr_mode_e selected_mode = MV_BARCODE_QR_MODE_UNAVAILABLE;
	int sel_opt = 0;
	const int options[] = { 1, 2, 3, 4 };
	const char *names[] = { "numeric", "alphanumeric", "byte", "utf8" };

	MEDIA_VISION_FUNCTION_ENTER();

	while (sel_opt == 0) {
		sel_opt = show_menu("Select encoding mode : ", options, names, ARRAY_SIZE(options));
		switch (sel_opt) {
		case 1:
			selected_mode = MV_BARCODE_QR_MODE_NUMERIC;
			break;
		case 2:
			selected_mode = MV_BARCODE_QR_MODE_ALPHANUMERIC;
			break;
		case 3:
			selected_mode = MV_BARCODE_QR_MODE_BYTE;
			break;
		case 4:
			selected_mode = MV_BARCODE_QR_MODE_UTF8;
			break;
		default:
			sel_opt = 0;
			break;
		}
	}

	MEDIA_VISION_FUNCTION_LEAVE();

	return selected_mode;
}

mv_barcode_qr_ecc_e select_ecc(void)
{
	mv_barcode_qr_ecc_e selected_ecc = MV_BARCODE_QR_ECC_UNAVAILABLE;
	int sel_opt = 0;
	const int options[] = { 1, 2, 3, 4 };
	const char *names[] = { "low", "medium", "quartile", "high" };

	MEDIA_VISION_FUNCTION_ENTER();

	while (sel_opt == 0) {
		sel_opt = show_menu("Select ECC level : ", options, names, ARRAY_SIZE(options));
		switch (sel_opt) {
		case 1:
			selected_ecc = MV_BARCODE_QR_ECC_LOW;
			break;
		case 2:
			selected_ecc = MV_BARCODE_QR_ECC_MEDIUM;
			break;
		case 3:
			selected_ecc = MV_BARCODE_QR_ECC_QUARTILE;
			break;
		case 4:
			selected_ecc = MV_BARCODE_QR_ECC_HIGH;
			break;
		default:
			sel_opt = 0;
			break;
		}
	}

	MEDIA_VISION_FUNCTION_LEAVE();

	return selected_ecc;
}

int select_attribute_text(void)
{
	MEDIA_VISION_FUNCTION_ENTER();

	int sel_opt = 0;
	int selected_attr = 0;
	const int options[] = { 1, 2 };
	const char *names[] = { "Invisible", "Visible" };

	while (sel_opt == 0) {
		sel_opt = show_menu("Select attribute text", options, names, ARRAY_SIZE(options));
		switch (sel_opt) {
		case 1:
			selected_attr = 0;
			break;
		case 2:
			selected_attr = 1;
			break;
		default:
			sel_opt = 0;
			break;
		}
	}

	MEDIA_VISION_FUNCTION_LEAVE();

	return selected_attr;
}

int select_version(void)
{
	MEDIA_VISION_FUNCTION_ENTER();

	int sel_opt = 0;
	while (sel_opt == 0) {
		const int options[] = { 1, 40 };
		const char *names[] = { "1..", "..40" };
		sel_opt = show_menu("Select QR version : ", options, names, ARRAY_SIZE(options));
		if (sel_opt < 1 || sel_opt > 40)
			sel_opt = 0;
	}

	MEDIA_VISION_FUNCTION_LEAVE();

	return sel_opt;
}

generation_fcn_e select_gen_function(void)
{
	generation_fcn_e ret_fcn_type = MV_TS_GENERATE_TO_IMAGE_FCN;
	int sel_opt = 0;
	const int options[] = { 1, 2 };
	const char *names[] = { "Generate to file", "Generate to source" };

	MEDIA_VISION_FUNCTION_ENTER();

	while (sel_opt == 0) {
		sel_opt = show_menu("Select API function : ", options, names, ARRAY_SIZE(options));
		switch (sel_opt) {
		case 1:
			ret_fcn_type = MV_TS_GENERATE_TO_IMAGE_FCN;
			break;
		case 2:
			ret_fcn_type = MV_TS_GENERATE_TO_SOURCE_FCN;
			break;
		default:
			sel_opt = 0;
			break;
		}
	}

	MEDIA_VISION_FUNCTION_LEAVE();

	return ret_fcn_type;
}

mv_barcode_image_format_e select_file_format(void)
{
	mv_barcode_image_format_e image_format = MV_BARCODE_IMAGE_FORMAT_JPG;
	int sel_opt = 0;
	const int options[] = { 1, 2, 3 };
	const char *names[] = { "BMP", "JPG", "PNG" };

	MEDIA_VISION_FUNCTION_ENTER();

	while (sel_opt == 0) {
		sel_opt = show_menu("Select file format : ", options, names, ARRAY_SIZE(options));
		switch (sel_opt) {
		case 1:
			image_format = MV_BARCODE_IMAGE_FORMAT_BMP;
			break;
		case 2:
			image_format = MV_BARCODE_IMAGE_FORMAT_JPG;
			break;
		case 3:
			image_format = MV_BARCODE_IMAGE_FORMAT_PNG;
			break;
		default:
			sel_opt = 0;
			break;
		}
	}

	MEDIA_VISION_FUNCTION_LEAVE();

	return image_format;
}

int perform_detect()
{
	MEDIA_VISION_FUNCTION_ENTER();

	barcode_model_s detect_model = { MV_BARCODE_UNKNOWN,
									 MV_BARCODE_QR_ECC_UNAVAILABLE,
									 MV_BARCODE_QR_MODE_UNAVAILABLE,
									 0,
									 0,
									 0,
									 0,
									 MV_BARCODE_IMAGE_FORMAT_PNG,
									 MEDIA_VISION_COLORSPACE_INVALID,
									 NULL,
									 NULL,
									 NULL,
									 NULL,
									 NULL,
									 NULL };

	while (input_string("Input file name to be analyzed : ", 1024, &(detect_model.file_name)) == -1)
		mvprintw(current_y++, MINX, "Incorrect input! Try again.");

	LOGI("Barcode input image has been specified");

	mv_rectangle_s roi = { { 0, 0 }, 0, 0 };

	while (input_int("Input x coordinate for ROI top left vertex : ", 0, 10000, &(roi.point.x)) == -1)
		mvprintw(current_y++, MINX, "Incorrect input! Try again.");

	while (input_int("Input y coordinate for ROI top left vertex : ", 0, 10000, &(roi.point.y)) == -1)
		mvprintw(current_y++, MINX, "Incorrect input! Try again.");

	while (input_int("Input ROI width : ", 0, 10000, &(roi.width)) == -1)
		mvprintw(current_y++, MINX, "Incorrect input! Try again.");

	while (input_int("Input ROI height : ", 0, 10000, &(roi.height)) == -1)
		mvprintw(current_y++, MINX, "Incorrect input! Try again.");

	LOGI("Region of interest (ROI) to detect barcode into has been specified");

	while (input_string("Input file name to be generated : ", 1024, &(detect_model.out_file_name)) == -1)
		mvprintw(current_y++, MINX, "Incorrect input! Try again.");

	LOGI("Barcode output image has been specified");

	const int options[] = { MEDIA_VISION_COLORSPACE_Y800,	MEDIA_VISION_COLORSPACE_I420,
							MEDIA_VISION_COLORSPACE_NV12,	MEDIA_VISION_COLORSPACE_YV12,
							MEDIA_VISION_COLORSPACE_NV21,	MEDIA_VISION_COLORSPACE_YUYV,
							MEDIA_VISION_COLORSPACE_UYVY,	MEDIA_VISION_COLORSPACE_422P,
							MEDIA_VISION_COLORSPACE_RGB565, MEDIA_VISION_COLORSPACE_RGB888,
							MEDIA_VISION_COLORSPACE_RGBA };
	const char *names[] = { "Y800", "I420", "NV12", "YV12", "NV21", "YUYV", "UYVY", "422P", "RGB565", "RGB888", "RGBA" };

	while (true) {
		int sel_opt = show_menu("Select colorspace to test detector on : ", options, names, ARRAY_SIZE(options));
		if (sel_opt < MEDIA_VISION_COLORSPACE_Y800 || sel_opt > MEDIA_VISION_COLORSPACE_RGBA)
			continue;

		detect_model.colorspace = (mv_colorspace_e) sel_opt;
		LOGI("User selection is %i", sel_opt);
		break;
	}

	int err = detect_barcode(detect_model, roi);

	free(detect_model.file_name);

	free(detect_model.out_file_name);

	if (err != MEDIA_VISION_ERROR_NONE)
		LOGE("Barcode detection failed with error code (0x%08x)", err);

	MEDIA_VISION_FUNCTION_LEAVE();

	return err;
}

int perform_generate(void)
{
	MEDIA_VISION_FUNCTION_ENTER();

	barcode_model_s generate_model = { MV_BARCODE_UNKNOWN,
									   MV_BARCODE_QR_ECC_UNAVAILABLE,
									   MV_BARCODE_QR_MODE_UNAVAILABLE,
									   0,
									   0,
									   0,
									   0,
									   MV_BARCODE_IMAGE_FORMAT_PNG,
									   MEDIA_VISION_COLORSPACE_INVALID,
									   NULL,
									   NULL,
									   NULL,
									   NULL,
									   NULL,
									   NULL };

	generation_fcn_e gen_fcn = select_gen_function();
	generate_model.type = select_type();
	LOGI("Barcode type has been selected");

	if (generate_model.type == MV_BARCODE_QR) {
		generate_model.mode = select_mode();
		LOGI("Barcode encoding mode has been selected");
		generate_model.ecc = select_ecc();
		LOGI("Barcode ecc level has been selected");
		generate_model.version = select_version();
		LOGI("Barcode version has been selected");
	}

	if (generate_model.type != MV_BARCODE_QR) {
		generate_model.is_hrt = select_attribute_text();
		LOGI("Barcode readable text attribute has been selected");
	}

	if (gen_fcn == MV_TS_GENERATE_TO_IMAGE_FCN) {
		generate_model.out_image_format = select_file_format();
		LOGI("Barcode output image format has been selected");
	}

	while (input_string("Input message : ", 7089, &generate_model.message) == -1)
		mvaddstr(current_y++, MINX, "Incorrect input! Try again.");

	LOGI("Barcode message has been specified");

	while (input_string("Input file name : ", 255, &generate_model.file_name) == -1)
		mvprintw(current_y++, MINX, "Incorrect input! Try again.");

	LOGI("Barcode output file name has been specified");

	while (input_string("Input foreground color (ex:black is 000000) : ", 6, &generate_model.front_color) == -1)
		mvprintw(current_y++, MINX, "Incorrect input! Try again.");

	LOGI("Foreground color is %s", generate_model.front_color);

	while (input_string("Input background color (ex:white is ffffff) : ", 6, &generate_model.back_color) == -1)
		mvprintw(current_y++, MINX, "Incorrect input! Try again.");

	LOGI("Background color is %s", generate_model.back_color);

	if (gen_fcn == MV_TS_GENERATE_TO_IMAGE_FCN) {
		while (input_size("Input image width : ", 10000, &generate_model.width) == -1)
			mvprintw(current_y++, MINX, "Incorrect input! Try again.");

		LOGI("Barcode output file width has been specified");

		while (input_size("Input image height : ", 10000, &generate_model.height) == -1)
			mvprintw(current_y++, MINX, "Incorrect input! Try again.");

		LOGI("Barcode output file height has been specified");
	}

	const int err = gen_fcn == MV_TS_GENERATE_TO_IMAGE_FCN ? generate_barcode_to_image(generate_model) :
															 generate_barcode_to_source(generate_model);

	free(generate_model.message);
	free(generate_model.file_name);
	free(generate_model.front_color);
	free(generate_model.back_color);

	if (err != MEDIA_VISION_ERROR_NONE) {
		LOGE("Barcode generation failed with error code (0x%08x)", err);
		mvprintw(current_y++, MINX, "ERROR : Errors were occurred during barcode generation!!!");
		MEDIA_VISION_FUNCTION_LEAVE();
		return err;
	}

	LOGI("Barcode output file has been generated");
	current_y++;
	mvprintw(current_y++, MINX, "Barcode image was successfully generated.");
	current_y++;
	mvprintw(current_y++, MINX, "Press any key to continue...");
	getch();

	MEDIA_VISION_FUNCTION_LEAVE();

	return 0;
}

static error_t parse_opt(int key, char *arg, struct argp_state *state)
{
	struct arguments *arguments = state->input;

	switch (key) {
	case 'm':
		arguments->mode = arg ? atoi(arg) : 0;
		break;
	case 'i':
		arguments->interval = arg ? atoi(arg) : 0;
		if (arguments->interval > MAXINTERVAL) {
			printf("WARN : value is out of range, reset to max value.\n");
			arguments->interval = MAXINTERVAL;
		} else if (arguments->interval < MININTERVAL) {
			printf("WARN : value is out of range, reset to min value.\n");
			arguments->interval = MININTERVAL;
		}
		break;
	case ARGP_KEY_NO_ARGS:
		/* do nothing */
		break;
	default:
		return ARGP_ERR_UNKNOWN;
	}
	return 0;
}

static struct argp argp = { arg_options, parse_opt, args_doc, doc };

int main(int argc, char *argv[])
{
	LOGI("Media Vision Testsuite is launched.");

	int err = MEDIA_VISION_ERROR_NONE;

	int sel_opt = 0;
	const int options[] = { 1, 2 };
	const char *names[] = { "Generate", "Detect" };
	struct arguments arguments;

	arguments.mode = 0;
	arguments.interval = 0;

	argp_parse(&argp, argc, argv, 0, 0, &arguments);
	mode = arguments.mode;
	test_interval = arguments.interval;

	if (arguments.mode == AUTO) {
		char buf[29];
		snprintf(buf, 29, "mv_barcode_test_suite_auto %d", test_interval);
		system(buf);
		endwin();
		return 0;
	} else if (arguments.mode == MANUAL) {
		/* do nothing */
	} else {
		printf("Please check mode and try it again.\n");
		return 0;
	}

	initscr();
	while (sel_opt == 0) {
		sel_opt = show_menu("Select action : ", options, names, ARRAY_SIZE(options));
		switch (sel_opt) {
		case 1:
			LOGI("Start the barcode generation flow");
			err = perform_generate();
			break;
		case 2:
			LOGI("Start the barcode detection flow");
			err = perform_detect();
			break;
		default:
			sel_opt = 0;
			continue;
		}

		int do_another = 0;

		if (err != MEDIA_VISION_ERROR_NONE)
			mvprintw(current_y++, MINX, "ERROR : Action is finished with error code : %i", err);

		sel_opt = 0;
		const int options_last[] = { 1, 2 };
		const char *names_last[] = { "YES", "NO" };

		while (sel_opt == 0) {
			sel_opt = show_menu("Perform another action?", options_last, names_last, ARRAY_SIZE(options));
			switch (sel_opt) {
			case 1:
				do_another = 1;
				break;
			case 2:
				do_another = 0;
				break;
			default:
				sel_opt = 0;
				break;
			}
		}
		LOGI("User selection is %i", sel_opt);

		sel_opt = (do_another == 1 ? 0 : sel_opt);
	}

	LOGI("Media Vision Testsuite is closed.");
	endwin();

	return err;
}