增加自定义区域及gamma属性

build.sh

@@ -9,9 +9,10 @@ elif [ "$sys" == "kylin" ];then
     sed -i "s/uos/$1/g"             hgdriver/wrapper/CMakeLists.txt
 fi
 
+cd ../
 mkdir build
 cd build 
-cmake ..
+cmake ../code_device
 make 
 
 if [ $? -ne 0 ];then

hgdriver/hgdev/ImageMatQueue.cpp

@@ -58,6 +58,6 @@ G400Decode::G400Decode(std::shared_ptr<std::vector<char>> buff,bool i)
         memcpy(buf->data(), buff->data(), bytes);
         m_buffs.push_back(buf);*/
         m_buffs.push_back(buff);
-        printf("G400 :buff->size()=%d\r\n",buff->size());
+        // printf("G400 :buff->size()=%d\r\n",buff->size());
 }
 

hgdriver/hgdev/common_setting.h

@@ -622,7 +622,9 @@ enum tagUsbKeyWords
     START_COMMAND_COUNT = 38,
     SET_SLEEP_TIME = 39,
     GET_SLEEP_TIME = 40,
-    CLR_HARDWARE_CACHE = 41
+    CLR_HARDWARE_CACHE = 41,
+
+	CHECK_IS_SLEEP = 0x100,
 };
 
 //G100 G200 3399设备协议 - OVER

hgdriver/hgdev/hg_scanner.cpp

@@ -24,6 +24,11 @@ hg_scanner::hg_scanner(ScannerSerial serial
 					, notify_setting_result_(false), user_cancel_(false), cb_mem_(true), test_1_paper_(false)
 					, setting_count_(0),img_type_(""), online_(false)
 {
+	paper_size_mm_.cx = 210;
+	paper_size_mm_.cy = 297;
+	for (int i = 0; i < sizeof(custom_gamma_val_); ++i)
+		custom_gamma_val_[i] = i;
+
 	HG_VLOG_MINI_2(HG_LOG_LEVEL_DEBUG_INFO, "%s(%s) constructed\n", name_.c_str(), hg_log::format_ptr(this).c_str());
 	image_prc_param_.value = 0;
 
@@ -446,6 +451,15 @@ int hg_scanner::restore(int setting_no)
 	std::string	val("");
 
 	sprintf(key, "%d", setting_no);
+	setting_jsn_.at(key).at("name").get_to(val);
+	if (val == KNOWN_OPT_NAME_CUSTOM_GAMMA)
+	{
+		for (size_t i = 0; i < sizeof(custom_gamma_val_); ++i)
+			custom_gamma_val_[i] = i;
+
+		return HG_ERR_OK;
+	}
+
 	setting_jsn_.at(key).at("type").get_to(val);
 	if (val == "string")
 	{
@@ -489,6 +503,16 @@ bool hg_scanner::get_default_value(void* buf, json* jsn)
 {
 	std::string type("");
 	
+	jsn->at("name").get_to(type);
+	if (type == KNOWN_OPT_NAME_CUSTOM_GAMMA)
+	{
+		SANE_Int* gma = (SANE_Int*)buf;
+		for (size_t i = 0; i < sizeof(custom_gamma_val_); ++i)
+			gma[i] = i & 0x0ff;
+
+		return true;
+	}
+
 	jsn->at("type").get_to(type);
 	if (type == "bool")
 	{
@@ -659,6 +683,75 @@ void hg_scanner::working_done(void*)
 	test_1_paper_ = false;
 }
 
+void hg_scanner::reset_custom_area_range(int paper)
+{
+	if (paper == PAPER_A3)
+	{
+		paper_size_mm_.cx = 297;
+		paper_size_mm_.cy = 420;
+	}
+	else if (paper == PAPER_A4)
+	{
+		paper_size_mm_.cx = 210;
+		paper_size_mm_.cy = 297;
+	}
+	else if (paper == PAPER_A4_LATERAL)
+	{
+		paper_size_mm_.cx = 297;
+		paper_size_mm_.cy = 210;
+	}
+	else if (paper == PAPER_A5)
+	{
+		paper_size_mm_.cx = 148;
+		paper_size_mm_.cy = 210;
+	}
+	else if (paper == PAPER_A5_LATERAL)
+	{
+		paper_size_mm_.cx = 210;
+		paper_size_mm_.cy = 148;
+	}
+	else if (paper == PAPER_A6)
+	{
+		paper_size_mm_.cx = 105;
+		paper_size_mm_.cy = 148;
+	}
+	else if (paper == PAPER_A6_LATERAL)
+	{
+		paper_size_mm_.cx = 148;
+		paper_size_mm_.cy = 105;
+	}
+	else if (paper == PAPER_B4)
+	{
+		paper_size_mm_.cx = 250;
+		paper_size_mm_.cy = 353;
+	}
+	else if (paper == PAPER_B5)
+	{
+		paper_size_mm_.cx = 176;
+		paper_size_mm_.cy = 250;
+	}
+	else if (paper == PAPER_B6)
+	{
+		paper_size_mm_.cx = 125;
+		paper_size_mm_.cy = 176;
+	}
+	else if (paper == PAPER_B5_LATERAL)
+	{
+		paper_size_mm_.cx = 250;
+		paper_size_mm_.cy = 176;
+	}
+	else if (paper == PAPER_B6_LATERAL)
+	{
+		paper_size_mm_.cx = 176;
+		paper_size_mm_.cy = 125;
+	}
+	else
+	{
+		paper_size_mm_.cx = 2338;
+		paper_size_mm_.cy = 3307;
+	}
+}
+
 int hg_scanner::setting_restore(void* data)
 {
 	// restore ...
@@ -857,6 +950,8 @@ int hg_scanner::setting_paper(void* data)
 
 	if(ret == HG_ERR_NOT_EXACT)
 		strcpy((char*)data, paper.c_str());	
+	if(old != image_prc_param_.bits.paper)
+		reset_custom_area_range(image_prc_param_.bits.paper);
 
 	return ret;
 }
@@ -1248,6 +1343,69 @@ int hg_scanner::setting_skew_check_level(void* data)
 
 	return ret;
 }
+int hg_scanner::setting_is_custom_gamma(void* data)
+{
+	SANE_Bool* v = (SANE_Bool*)data;
+
+	custom_gamma_ = *v == SANE_TRUE;
+
+	return HG_ERR_OK;
+}
+int hg_scanner::setting_custom_gamma_data(void* data)
+{
+	SANE_Int* v = (SANE_Int*)data;
+	int		len = 256;
+
+	if (image_prc_param_.bits.color_mode == COLOR_MODE_24_BITS ||
+		image_prc_param_.bits.color_mode == COLOR_MODE_AUTO_MATCH)
+	{
+		len = 3 * 256;
+	}
+	for (int i = 0; i < len; ++i)
+		custom_gamma_val_[i] = v[i];
+
+	return HG_ERR_OK;
+}
+int hg_scanner::setting_is_custom_area(void* data)
+{
+	SANE_Bool* v = (SANE_Bool*)data;
+
+	custom_area_ = *v == SANE_TRUE;
+
+	return HG_ERR_OK;
+}
+int hg_scanner::setting_custom_area_left(void* data)
+{
+	SANE_Fixed* v = (SANE_Fixed*)data;
+
+	custom_area_lt_x_ = SANE_UNFIX(*v);
+
+	return HG_ERR_OK;
+}
+int hg_scanner::setting_custom_area_top(void* data)
+{
+	SANE_Fixed* v = (SANE_Fixed*)data;
+
+	custom_area_lt_y_ = SANE_UNFIX(*v);
+
+	return HG_ERR_OK;
+}
+int hg_scanner::setting_custom_area_right(void* data)
+{
+	SANE_Fixed* v = (SANE_Fixed*)data;
+
+	custom_area_br_x_ = SANE_UNFIX(*v);
+
+	return HG_ERR_OK;
+}
+int hg_scanner::setting_custom_area_bottom(void* data)
+{
+	SANE_Fixed* v = (SANE_Fixed*)data;
+
+	custom_area_br_y_ = SANE_UNFIX(*v);
+
+	return HG_ERR_OK;
+}
 
 int hg_scanner::on_color_mode_changed(int& color_mode)
 {
@@ -1313,6 +1471,9 @@ void hg_scanner::init_settings(const char* json_setting_text)
 		std::string	val("");
 
 		sprintf(key, "%d", sn);
+		setting_jsn_.at(key).at("name").get_to(val);
+		if (val == KNOWN_OPT_NAME_CUSTOM_GAMMA)
+			continue;
 		setting_jsn_.at(key).at("type").get_to(val);
 		if (val == "string")
 		{
@@ -1576,6 +1737,11 @@ int hg_scanner::set_setting(int setting_no, void* data, int len)
 		, &hg_scanner::setting_noise_optimize_range
 		, &hg_scanner::setting_paper
 		, &hg_scanner::setting_paper_check
+		, &hg_scanner::setting_is_custom_area
+		, &hg_scanner::setting_custom_area_left
+		, &hg_scanner::setting_custom_area_right
+		, &hg_scanner::setting_custom_area_top
+		, &hg_scanner::setting_custom_area_bottom
 		, &hg_scanner::setting_page
 		, &hg_scanner::setting_page_omit_empty
 		, &hg_scanner::setting_resolution
@@ -1584,9 +1750,11 @@ int hg_scanner::set_setting(int setting_no, void* data, int len)
 		, &hg_scanner::setting_automatic_skew
 		, &hg_scanner::setting_rid_hole
 		, &hg_scanner::setting_rid_hoe_range
+		, &hg_scanner::setting_is_custom_gamma		// 2022-05-05
 		, &hg_scanner::setting_bright
 		, &hg_scanner::setting_contrast
 		, &hg_scanner::setting_gamma
+		, &hg_scanner::setting_custom_gamma_data
 		, &hg_scanner::setting_sharpen
 		, &hg_scanner::setting_dark_sample
 		, &hg_scanner::setting_erase_black_frame
@@ -1609,7 +1777,6 @@ int hg_scanner::set_setting(int setting_no, void* data, int len)
 		, &hg_scanner::setting_fractate_check_level
 		, &hg_scanner::setting_skew_check
 		, &hg_scanner::setting_skew_check_level		
-		
 	};
 
 	bool	hit = false;
@@ -1702,19 +1869,88 @@ int hg_scanner::get_setting(int setting_no, char* json_txt_buf, int* len)
 		return HG_ERR_OUT_OF_RANGE;
 
 	char		 sn[20];
-	std::string text("");
+	std::string text(""), name(""), tag("");
+	int			add = 0;
+	bool		is_gamma = false, is_area_x = false, is_area_y = false;
 
 	sprintf(sn, "%d", setting_no);
 	if (!setting_jsn_.contains(sn))
 		HG_VLOG_MINI_2(HG_LOG_LEVEL_FATAL, "!!!option(%d - %s) is not found.\n", setting_no, sn);
 	text = setting_jsn_.at(sn).dump();
-	if (*len <= text.length())
+	setting_jsn_.at(sn).at("name").get_to(name);
+	if (name == KNOWN_OPT_NAME_CUSTOM_GAMMA)
 	{
-		*len = text.length() + 8;
+		is_gamma = true;
+		add = 4 * sizeof(custom_gamma_val_);
+	}
+	else if (name == KNOWN_OPT_NAME_CUSTOM_AREA_LEFT || name == KNOWN_OPT_NAME_CUSTOM_AREA_RIGHT)
+	{
+		is_area_x = true;
+		add = 20;
+	}
+	else if (name == KNOWN_OPT_NAME_CUSTOM_AREA_TOP || name == KNOWN_OPT_NAME_CUSTOM_AREA_BOTTOM)
+	{
+		is_area_y = true;
+		add = 20;
+	}
+	if (*len <= text.length() + add)
+	{
+		*len = text.length() + 8 + add;
 
 		return HG_ERR_INSUFFICIENT_MEMORY;
 	}
 
+	if (is_gamma)
+	{
+		name = "";
+		add = 256;
+		if (image_prc_param_.bits.color_mode == COLOR_MODE_24_BITS ||
+			image_prc_param_.bits.color_mode == COLOR_MODE_AUTO_MATCH)
+		{
+			add = 3 * 256;
+		}
+		sprintf(sn, "[%u", custom_gamma_val_[0]);
+		name += sn;
+		for (int i = 1; i < add; ++i)
+		{
+			sprintf(sn, ",%u", custom_gamma_val_[i]);
+			name += sn;
+		}
+		name += "]";
+		tag = "\"cur\":";
+	}
+	else if (is_area_x)
+	{
+		sprintf(sn, "%u.0", paper_size_mm_.cx);
+		name = sn;
+		tag = "\"max\":";
+	}
+	else if (is_area_y)
+	{
+		sprintf(sn, "%u.0", paper_size_mm_.cy);
+		name = sn;
+		tag = "\"max\":";
+	}
+	if (!tag.empty())
+	{
+		size_t pos = text.find(tag), end = pos;
+		if (pos != std::string::npos)
+		{
+			pos += tag.length();
+			end = pos;
+			while (end < text.length())
+			{
+				if (text[end] == ',' || text[end] == '}' || text[end] == ']' || text[end] == '\r' || text[end] == '\n')
+					break;
+				end++;
+			}
+			if (end > pos)
+				text.replace(pos, end - pos, name);
+			else
+				text.insert(end, name);
+		}
+	}
+
 	strcpy(json_txt_buf, text.c_str());
 	*len = text.length();
 
@@ -1958,6 +2194,25 @@ int hg_scanner::device_io_control(unsigned long code, void* data, unsigned* len)
 		}
 		return set_sleep_time(sleeptime);
 	}
+	else if (code == IO_CTRL_CODE_GET_CUSTOM_GAMMA)
+	{
+		SANE_Int* v = (SANE_Int*)data;
+		int			count = *len;
+		for (int i = 0; i < count && i < sizeof(custom_gamma_val_); ++i)
+			v[i] = custom_gamma_val_[i];
+
+		return HG_ERR_OK;
+	}
+	else if (code == IO_CTRL_CODE_GET_CUSTOM_GAMMA)
+	{
+		SANE_Int*	v = (SANE_Int*)data;
+		int			count = *len;
+		for (int i = 0; i < count && i < sizeof(custom_gamma_val_); ++i)
+			custom_gamma_val_[i] = v[i];
+
+		return HG_ERR_OK;
+	}
+
 	return HG_ERR_DEVICE_NOT_SUPPORT;
 }
 std::string hg_scanner::get_firmware_version(void)

hgdriver/hgdev/hg_scanner.h

@@ -19,6 +19,8 @@
 #include "common_setting.h"
 #include "image_process.h"
 #include "StopWatch.h"
+#include "PaperSize.h"
+
 #ifdef WIN32
 #else
 #include <unistd.h>
@@ -38,6 +40,11 @@ enum
     HG_BASE_SETTING_INDEX_NOISE_OPTIMIZE_SIZE,              // 噪点优化尺寸    
     HG_BASE_SETTING_INDEX_PAPER,                            // 纸张尺寸    
     HG_BASE_SETTING_INDEX_PAPER_SIZE_CHECK,                 // 尺寸检测    
+    HG_BASE_SETTING_INDEX_IS_CUSTOM_AREA,                   // 是否启用自定义区域
+    HG_BASE_SETTING_INDEX_CUSTOM_AREA_LEFT,                 // 自定义区域左侧（mm）
+    HG_BASE_SETTING_INDEX_CUSTOM_AREA_RIGHT,                // 自定义区域右侧（mm）
+    HG_BASE_SETTING_INDEX_CUSTOM_AREA_TOP,                  // 自定义区域上侧（mm）
+    HG_BASE_SETTING_INDEX_CUSTOM_AREA_BOTTOM,               // 自定义区域下侧（mm）
     HG_BASE_SETTING_INDEX_PAGE,                             // 扫描页面    
     HG_BASE_SETTING_INDEX_PAGE_OMIT_EMPTY_LEVEL,            // 跳过空白页灵敏度    
     HG_BASE_SETTING_INDEX_RESOLUTION,                       // 分辨率    
@@ -46,9 +53,11 @@ enum
     HG_BASE_SETTING_INDEX_AUTO_CORRECT,                     // 自动纠偏                
     HG_BASE_SETTING_INDEX_RID_HOLE,                         // 穿孔移除                
     HG_BASE_SETTING_INDEX_RID_HOLE_RANGE,                   // 穿孔搜索范围                    
+    HG_BASE_SETTING_INDEX_IS_CUSTOM_GAMMA,                  // 是否启用自定义伽玛
     HG_BASE_SETTING_INDEX_BRIGHT,                           // 亮度                    
     HG_BASE_SETTING_INDEX_CONTRAST,                         // 对比度                    
     HG_BASE_SETTING_INDEX_GAMMA,                            // 伽玛            
+    HG_BASE_SETTING_INDEX_CUSTOM_GAMMA_DATA,                // 自定义伽玛数据
     HG_BASE_SETTING_INDEX_SHARPEN,                          // 锐化与模糊                    
     HG_BASE_SETTING_INDEX_DARK_SAMPLE,                      // 深色样张                                    
     HG_BASE_SETTING_INDEX_ERASE_BLACK_FRAME,                // 消除黑框                                          
@@ -103,6 +112,8 @@ class hg_scanner
     void working_begin(void*);
     void working_done(void*);
 
+    void reset_custom_area_range(int paper);
+
     // 设置接口
 protected:
 
@@ -161,6 +172,13 @@ protected:
     int setting_fractate_check_level(void* data);
     int setting_skew_check(void* data);
     int setting_skew_check_level(void* data);
+    int setting_is_custom_gamma(void* data);
+    int setting_custom_gamma_data(void* data);
+    int setting_is_custom_area(void* data);
+    int setting_custom_area_left(void* data);
+    int setting_custom_area_top(void* data);
+    int setting_custom_area_right(void* data);
+    int setting_custom_area_bottom(void* data);
     
 
     virtual int on_color_mode_changed(int& color_mode); // COLOR_MODE_xxx
@@ -231,6 +249,20 @@ protected:
     int save_usb_data(std::shared_ptr<std::vector<char>> data);
     int save_final_image(hg_imgproc::LPIMGHEAD head, void* buf);
 
+
+    ////////////////////////////////////////////////////////////////
+    // 新增自定义伽玛曲线及扫描区域属性 - 2022-05-05
+    bool    custom_gamma_;                  // 为true时，应用custom_gamma_val_阵列调整图像色彩；为false时，保持原来的处理方式
+    uint8_t custom_gamma_val_[3 * 256];     // 当为RGB或者彩色时，为三组256字节的数据；当为黑白或灰度时，只有一组256字节
+    bool    custom_area_;                   // 是否启用自定义区域，为true时才使用下列4个数据；为false时保持原来的处理方式
+    double  custom_area_lt_x_;              // 自定义区域左上角x坐标
+    double  custom_area_lt_y_;              // 自定义区域左上角y坐标
+    double  custom_area_br_x_;              // 自定义区域右下角x坐标
+    double  custom_area_br_y_;              // 自定义区域右下角y坐标
+    SIZE    paper_size_mm_;                 // 当前纸张尺寸（mm）
+    // 新增自定义伽玛曲线及扫描区域属性 - END
+    ////////////////////////////////////////////////////////////////
+
 public:
     void set_ui_callback(sane_callback cb, bool enable_async_io);
     int reset_io(usb_io* io);

hgdriver/hgdev/hg_scanner_200.h

@@ -15,6 +15,23 @@
 
 class hg_scanner_200 : public hg_scanner
 {
+    // reading buffers ... (for overlapped IO maybe rewrite the buffer after the timeout)
+    typedef struct _usb_block
+    {
+        USBCB   data;
+        int     len;
+    }USBBLOCK;
+    const int buf_read_img_len_;
+    char    *buf_read_img_;
+    int     io_read_img_;
+
+    char    buf_mini_str_[20];
+
+    USBBLOCK    buf_sleep_;
+    USBBLOCK    buf_paper_on_;
+    USBBLOCK    buf_is_sleep_;
+    USBBLOCK    buf_statu_;
+
 	void discard_prev(void);
 
 protected:
@@ -44,9 +61,8 @@ public:
 private:
  	int initdevice();
 	int writeusb(USBCB &usb);
-	int readusb(USBCB &usb);
 	int pop_image();
-	int get_scanner_status(USBCB &usb);
+	int get_scanner_status(void);
 	int get_img_data(unsigned int bytes);
 	int writedown_device_configuration(bool type =false,HGSCANCONF_DSP *d = NULL);
 	void writedown_image_configuration(void);

hgdriver/hgdev/image_process.cpp

@@ -29,7 +29,7 @@ using namespace std;
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // functional ...
 ////////////////////////////////////////////////////////////////////////////////
-//	NEW，flow ...
+//	NEW，flow ...
 	static int num=0;
 
 namespace hg_imgproc
@@ -127,7 +127,7 @@ namespace hg_imgproc
 
 			if(buffs.empty())
 				return -1;
-/////cmake当中进行定义　mips64　//在mips64下使用reset会导致崩溃
+/////cmake褰撲腑杩涜<EFBFBD>瀹氫箟銆€mips64銆€//鍦╩ips64涓嬩娇鐢╮eset浼氬<E6B5BC>鑷村穿婧?
 		    //#ifndef mips64
                         //printf("\n buffer_  reset");
                              buffer_.reset(new std::vector<char >());
@@ -481,7 +481,7 @@ namespace hg_imgproc
 			}
 			return ret;
 		}
-		//防止渗透
+		//闃叉<EFBFBD>娓楅€?
 		int 	antiInflow(int permeate_lv)
 		{
 			int ret = HG_ERR_OK;
@@ -549,7 +549,7 @@ namespace hg_imgproc
 #endif
 			return ret;
 	}
-	//除网纹
+	//闄ょ綉绾?
 	int 	textureRemove()
 	{
 		int ret = HG_ERR_OK;
@@ -623,7 +623,7 @@ namespace hg_imgproc
 		std::vector<cv::Mat>	mats(mats_);
 		mats_.clear();
 
-		double 		threshold = 40; //默认值
+		double 		threshold = 40; //榛樿<EFBFBD>鍊?
 		int 		edge = 150;
 		
 		CImageApplyDiscardBlank(threshold,edge,img_conf_.discardblank_percent);
@@ -639,7 +639,7 @@ namespace hg_imgproc
 		}
 		return ret;
 	}
-	//答题卡出红
+	//绛旈<EFBFBD>鍗″嚭绾?
 	int answerSheetFilterRed()
 	{
 		int ret = HG_ERR_OK;

hgsane/sane_hg_mdw.cpp

@@ -1394,18 +1394,9 @@ SANE_Option_Descriptor* hg_sane_middleware::from_json(scanner_handle h, json* js
 	double						lower = .0f, upper = .0f;
 	bool						db_val = false;
 	
-	if (jsn->get_value("name", val))
+	jsn->get_value("name", name);
-	{
+	jsn->get_value("title", title);
-		name = local_utility::utf8_2_ansi(val.c_str());
+	jsn->get_value("desc", desc);
-	}
-	if (jsn->get_value("title", val))
-	{
-		title = local_utility::utf8_2_ansi(val.c_str());
-	}
-	if (jsn->get_value("desc", val))
-	{
-		desc = local_utility::utf8_2_ansi(val.c_str());
-	}
 
 	if (!jsn->get_value("type", val))
 		return NULL;
@@ -1536,6 +1527,11 @@ SANE_Option_Descriptor* hg_sane_middleware::from_json(scanner_handle h, json* js
 			hg_log::log(HG_LOG_LEVEL_DEBUG_INFO, "set \345\210\206\350\276\250\347\216\207 unit to DPI\n");
 			ret->unit = SANE_UNIT_DPI;
 		}
+		else if (strcmp(ret->name, KNOWN_OPT_NAME_CUSTOM_AREA_LEFT) == 0 ||
+			strcmp(ret->name, KNOWN_OPT_NAME_CUSTOM_AREA_RIGHT) == 0 ||
+			strcmp(ret->name, KNOWN_OPT_NAME_CUSTOM_AREA_TOP) == 0 ||
+			strcmp(ret->name, KNOWN_OPT_NAME_CUSTOM_AREA_BOTTOM) == 0)
+			ret->unit = SANE_UNIT_MM;
 
 		//bool enabled = true;
 		//if (jsn->get_value("enable", enabled) && !enabled)
@@ -1657,9 +1653,20 @@ bool hg_sane_middleware::get_current_value(scanner_handle handle, int option, vo
 		jsn->get_value("type", val))
 	{
 		SANE_Value_Type	t = SANE_TYPE_STRING;
+		std::string		name("");
 
+		jsn->get_value("name", name);
 		ret = true;
-		if (val == "int")
+		if (name == KNOWN_OPT_NAME_CUSTOM_GAMMA)
+		{
+			SANE_Int* v = (SANE_Int*)value;
+			std::vector<std::string>	vs;
+
+			jsn->get_as_array("cur", vs);
+			for (int i = 0; i < 3 * 256 && i < vs.size(); ++i)
+				v[i] = atoi(vs[i].c_str());
+		}
+		else if (val == "int")
 		{
 			int v = 0;
 			jsn->get_value("cur", v);