code_app/modules/sane_user/HGSaneImpl.cpp

#include "HGSaneImpl.hpp"
#include "../base/HGInc.h"

HGSaneManagerImpl::HGSaneManagerImpl()
{
	m_dll = NULL;
	m_f_sane_init = NULL;
	m_f_sane_exit = NULL;
	m_f_sane_get_devices = NULL;
	m_f_sane_open = NULL;
	m_f_sane_close = NULL;
	m_f_sane_start = NULL;
	m_f_sane_read = NULL;
	m_f_sane_cancel = NULL;
	m_f_sane_set_io_mode = NULL;
	m_f_sane_strstatus = NULL;
	m_f_sane_get_parameters = NULL;
	m_f_sane_get_option_descriptor = NULL;
	m_f_sane_control_option = NULL;
	memset(&m_saneApi, 0, sizeof(SANEAPI));
}

HGSaneManagerImpl::~HGSaneManagerImpl()
{

}

HGResult HGSaneManagerImpl::Create(const HGChar* sanePath)
{
	assert(NULL == m_dll);

	HGResult ret = HGBase_CreateDll(sanePath, &m_dll);
	if (HGBASE_ERR_OK != ret)
	{
		return ret;
	}

	ret = FindFunctions();
	if (HGBASE_ERR_OK != ret)
	{
		HGBase_DestroyDll(m_dll);
		m_dll = NULL;
		return ret;
	}

	if (SANE_STATUS_GOOD != m_f_sane_init(NULL, NULL))
	{
		HGBase_DestroyDll(m_dll);
		m_dll = NULL;
		return HGSANE_ERR_FAIL;
	}

	return HGBASE_ERR_OK;
}

HGResult HGSaneManagerImpl::Destroy()
{
	assert(NULL != m_dll);

	if (!m_listDeviceImpl.empty())
	{
		return HGBASE_ERR_FAIL;
	}

	m_f_sane_exit();

	HGBase_DestroyDll(m_dll);
	m_dll = NULL;
	return HGBASE_ERR_OK;
}

HGResult HGSaneManagerImpl::GetDeviceCount(HGUInt* count)
{
	if (NULL == count)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	const SANE_Device** device_list;
	if (SANE_STATUS_GOOD != m_f_sane_get_devices(&device_list, SANE_TRUE))
	{
		return HGSANE_ERR_FAIL;
	}

	*count = 0;
	const SANE_Device** p;
	for (p = device_list; *p != NULL; ++p)
		++(*count);

	return HGBASE_ERR_OK;
}

HGResult HGSaneManagerImpl::GetDeviceName(HGUInt index, HGChar* name, HGUInt maxLen)
{
	if (NULL == name || 0 == maxLen)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	const SANE_Device** device_list;
	if (SANE_STATUS_GOOD != m_f_sane_get_devices(&device_list, SANE_TRUE))
	{
		return HGSANE_ERR_FAIL;
	}

	HGUInt count = 0;
	const SANE_Device** p;
	for (p = device_list; *p != NULL; ++p)
		++count;

	if (index >= count)
		return HGBASE_ERR_INVALIDARG;

	if (NULL == device_list[index]->name)
		return HGBASE_ERR_FAIL;
	if (maxLen < strlen(device_list[index]->name) + 1)
		return HGBASE_ERR_FAIL;
	strcpy(name, device_list[index]->name);
	return HGBASE_ERR_OK;
}

HGResult HGSaneManagerImpl::OpenDevice(HGUInt index, HGSaneDeviceImpl** deviceImpl, HGChar* errInfo, HGUInt errInfoLen)
{
	if (NULL == deviceImpl)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	const SANE_Device** device_list;
	if (SANE_STATUS_GOOD != m_f_sane_get_devices(&device_list, SANE_TRUE))
	{
		return HGSANE_ERR_FAIL;
	}

	HGUInt count = 0;
	const SANE_Device** p;
	for (p = device_list; *p != NULL; ++p)
		++count;

	if (index >= count)
		return HGBASE_ERR_INVALIDARG;

	HGSaneDeviceImpl* newDeviceImpl = new HGSaneDeviceImpl(this);
	HGResult ret = newDeviceImpl->Open(device_list[index]->name, errInfo, errInfoLen);
	if (HGBASE_ERR_OK != ret)
	{
		delete newDeviceImpl;
		return ret;
	}

	m_listDeviceImpl.push_back(newDeviceImpl);
	*deviceImpl = newDeviceImpl;
	return HGBASE_ERR_OK;
}

HGResult HGSaneManagerImpl::OpenSelectedDevice(HGWindow parent, class HGSaneDeviceImpl** deviceImpl)
{
	if (NULL == deviceImpl)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	SANE_Handle handle = NULL;
	char devName[256] = {0};
        if (-2 == show_devlist_ui(&m_saneApi, parent, &handle, devName, 256))
	{
		return HGBASE_ERR_NOTSUPPORT;
	}

	if (NULL == handle)
	{
		return HGSANE_ERR_FAIL;
	}

	HGSaneDeviceImpl* newDeviceImpl = new HGSaneDeviceImpl(this);
	HGResult ret = newDeviceImpl->Init(devName, handle);
	if (HGBASE_ERR_OK != ret)
	{
		delete newDeviceImpl;
		return ret;
	}

	m_listDeviceImpl.push_back(newDeviceImpl);
	*deviceImpl = newDeviceImpl;
	return HGBASE_ERR_OK;
}

HGResult HGSaneManagerImpl::FindFunctions()
{
	HGResult ret = HGBASE_ERR_OK;

	do
	{
		ret = HGBase_GetDllProcAddress(m_dll, "sane_hgsane_init", (HGPointer*)&m_f_sane_init);
		if (HGBASE_ERR_OK != ret)
			break;

		ret = HGBase_GetDllProcAddress(m_dll, "sane_hgsane_exit", (HGPointer*)&m_f_sane_exit);
		if (HGBASE_ERR_OK != ret)
			break;

		ret = HGBase_GetDllProcAddress(m_dll, "sane_hgsane_get_devices", (HGPointer*)&m_f_sane_get_devices);
		if (HGBASE_ERR_OK != ret)
			break;

		ret = HGBase_GetDllProcAddress(m_dll, "sane_hgsane_open", (HGPointer*)&m_f_sane_open);
		if (HGBASE_ERR_OK != ret)
			break;

		ret = HGBase_GetDllProcAddress(m_dll, "sane_hgsane_close", (HGPointer*)&m_f_sane_close);
		if (HGBASE_ERR_OK != ret)
			break;

		ret = HGBase_GetDllProcAddress(m_dll, "sane_hgsane_start", (HGPointer*)&m_f_sane_start);
		if (HGBASE_ERR_OK != ret)
			break;

		ret = HGBase_GetDllProcAddress(m_dll, "sane_hgsane_read", (HGPointer*)&m_f_sane_read);
		if (HGBASE_ERR_OK != ret)
			break;

		ret = HGBase_GetDllProcAddress(m_dll, "sane_hgsane_cancel", (HGPointer*)&m_f_sane_cancel);
		if (HGBASE_ERR_OK != ret)
			break;

		ret = HGBase_GetDllProcAddress(m_dll, "sane_hgsane_set_io_mode", (HGPointer*)&m_f_sane_set_io_mode);
		if (HGBASE_ERR_OK != ret)
			break;

		ret = HGBase_GetDllProcAddress(m_dll, "sane_hgsane_strstatus", (HGPointer*)&m_f_sane_strstatus);
		if (HGBASE_ERR_OK != ret)
			break;

		ret = HGBase_GetDllProcAddress(m_dll, "sane_hgsane_get_parameters", (HGPointer*)&m_f_sane_get_parameters);
		if (HGBASE_ERR_OK != ret)
			break;

		ret = HGBase_GetDllProcAddress(m_dll, "sane_hgsane_get_option_descriptor", (HGPointer*)&m_f_sane_get_option_descriptor);
		if (HGBASE_ERR_OK != ret)
			break;

		ret = HGBase_GetDllProcAddress(m_dll, "sane_hgsane_control_option", (HGPointer*)&m_f_sane_control_option);
		if (HGBASE_ERR_OK != ret)
			break;

	} while (0);

	m_saneApi.sane_get_devices_api = m_f_sane_get_devices;
	m_saneApi.sane_open_api = m_f_sane_open;
	m_saneApi.sane_close_api = m_f_sane_close;
	m_saneApi.sane_start_api = m_f_sane_start;
	m_saneApi.sane_read_api = m_f_sane_read;
	m_saneApi.sane_cancel_api = m_f_sane_cancel;
	m_saneApi.sane_set_io_mode_api = m_f_sane_set_io_mode;
	m_saneApi.sane_strstatus_api = m_f_sane_strstatus;
	m_saneApi.sane_get_parameters_api = m_f_sane_get_parameters;
	m_saneApi.sane_get_option_descriptor_api = m_f_sane_get_option_descriptor;
	m_saneApi.sane_control_option_api = m_f_sane_control_option;
	return ret;
}

void HGSaneManagerImpl::RemoveDevice(class HGSaneDeviceImpl* deviceImpl)
{
	std::list<class HGSaneDeviceImpl*>::iterator iter;
	for (iter = m_listDeviceImpl.begin(); iter != m_listDeviceImpl.end(); ++iter)
	{
		if (*iter == deviceImpl)
		{
			m_listDeviceImpl.erase(iter);
			delete deviceImpl;
			break;
		}
	}
}


HGSaneDeviceImpl::HGSaneDeviceImpl(HGSaneManagerImpl* mgrImpl)
{
	m_mgrImpl = mgrImpl;
	m_devName.clear();
	m_devHandle = NULL;
	m_buffer = NULL;
	m_bufferSize = 0;
	m_dpi = 0;
	m_eventFunc = NULL;
	m_eventParam = NULL;
	m_imageFunc = NULL;
	m_imageParam = NULL;
	m_stopThread = HGFALSE;
	m_thread = NULL;
}

HGSaneDeviceImpl::~HGSaneDeviceImpl()
{

}

HGResult HGSaneDeviceImpl::Init(const HGChar* devName, SANE_Handle handle)
{
	assert(NULL == m_devHandle);

	if (NULL == devName || NULL == handle)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	m_devName = devName;
	m_mgrImpl->m_f_sane_set_io_mode(handle, SANE_FALSE);
	m_devHandle = handle;
	return HGBASE_ERR_OK;
}

HGResult HGSaneDeviceImpl::Open(const HGChar* devName, HGChar* errInfo, HGUInt errInfoLen)
{
	assert(NULL == m_devHandle);

	if (NULL == devName)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	SANE_Handle handle = NULL;
	SANE_Status stat = m_mgrImpl->m_f_sane_open(devName, &handle);
	if (SANE_STATUS_GOOD != stat)
	{
		if (NULL != errInfo)
		{
			const char* err = m_mgrImpl->m_f_sane_strstatus(stat);
			if (NULL != err && errInfoLen >= strlen(err) + 1)
			{
				strcpy(errInfo, err);
			}
		}

		return HGSANE_ERR_FAIL;
	}

	m_devName = devName;
	m_mgrImpl->m_f_sane_set_io_mode(handle, SANE_FALSE);
	m_devHandle = handle;
	return HGBASE_ERR_OK;
}

HGResult HGSaneDeviceImpl::Close()
{
	assert(NULL != m_devHandle);

	Stop();
	m_mgrImpl->m_f_sane_close(m_devHandle);
	m_devHandle = NULL;
	m_devName.clear();
	m_mgrImpl->RemoveDevice(this);
	return HGBASE_ERR_OK;
}

HGResult HGSaneDeviceImpl::GetName(HGChar* name, HGUInt maxLen)
{
	if (NULL == name || 0 == maxLen)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	if (maxLen < m_devName.size() + 1)
		return HGBASE_ERR_FAIL;
	strcpy(name, m_devName.c_str());
	return HGBASE_ERR_OK;
}

HGResult HGSaneDeviceImpl::ShowSettingDlg(HGWindow parent)
{
	if (NULL != m_thread)
	{
		return HGBASE_ERR_FAIL;
	}

        if (-2 == show_setting_ui(&m_mgrImpl->m_saneApi, m_devHandle, parent))
	{
		return HGBASE_ERR_NOTSUPPORT;
	}

	return HGBASE_ERR_OK;
}

HGResult HGSaneDeviceImpl::Start(HGSane_DeviceEventFunc eventFunc, HGPointer eventParam,
	HGSane_DeviceImageFunc imageFunc, HGPointer imageParam, HGChar* errInfo, HGUInt errInfoLen)
{
	if (NULL != m_thread)
	{
		return HGBASE_ERR_FAIL;
	}

	SANE_Parameters params;
	memset(&params, 0, sizeof(SANE_Parameters));
	SANE_Status stat = m_mgrImpl->m_f_sane_get_parameters(m_devHandle, &params);
	if (SANE_STATUS_GOOD != stat)
	{
		if (NULL != errInfo)
		{
			const char* err = m_mgrImpl->m_f_sane_strstatus(stat);
			if (NULL != err && errInfoLen >= strlen(err) + 1)
			{
				strcpy(errInfo, err);
			}
		}

		return HGSANE_ERR_FAIL;
	}

	m_bufferSize = 5000 * 4000;
	m_buffer = (HGByte *)malloc(m_bufferSize);
	if (NULL == m_buffer)
	{
		return HGBASE_ERR_OUTOFMEMORY;
	}

	m_dpi = GetDpi();
	stat = m_mgrImpl->m_f_sane_start(m_devHandle);
	if (SANE_STATUS_GOOD != stat)
	{
		if (NULL != errInfo)
		{
			const char* err = m_mgrImpl->m_f_sane_strstatus(stat);
			if (NULL != err && errInfoLen >= strlen(err) + 1)
			{
				strcpy(errInfo, err);
			}
		}

		m_dpi = 0;
		free(m_buffer);
		m_buffer = NULL;
		m_bufferSize = 0;
		return HGSANE_ERR_FAIL;
	}

	m_eventFunc = eventFunc;
	m_eventParam = eventParam;
	m_imageFunc = imageFunc;
	m_imageParam = imageParam;
	m_stopThread = HGFALSE;
	HGBase_OpenThread(ThreadFunc, this, &m_thread);
	return HGBASE_ERR_OK;
}

HGResult HGSaneDeviceImpl::Stop()
{
	if (NULL == m_thread)
	{
		return HGBASE_ERR_FAIL;
	}

	m_stopThread = HGTRUE;
	m_mgrImpl->m_f_sane_cancel(m_devHandle);
	HGBase_CloseThread(m_thread);
	m_thread = NULL;
	m_eventFunc = NULL;
	m_eventParam = NULL;
	m_imageFunc = NULL;
	m_imageParam = NULL;

	m_dpi = 0;
	free(m_buffer);
	m_buffer = NULL;
	m_bufferSize = 0;
	return HGBASE_ERR_OK;
}

HGResult HGSaneDeviceImpl::StartWithUI(HGWindow parent, HGSane_DeviceImageFunc imageFunc, HGPointer imageParam)
{
	if (NULL != m_thread)
	{
		return HGBASE_ERR_FAIL;
	}

	m_dpi = GetDpi();
	m_imageFunc = imageFunc;
	m_imageParam = imageParam;

        if (-2 == show_scan_ui(&m_mgrImpl->m_saneApi, m_devHandle, parent, ShowScanImageCallback, this))
	{
		return HGBASE_ERR_NOTSUPPORT;
	}

	return HGBASE_ERR_OK;
}

HGUInt HGSaneDeviceImpl::GetDpi()
{
	HGUInt dpi = 0;
	SANE_Int num_dev_options = 0;
	m_mgrImpl->m_f_sane_control_option(m_devHandle, 0, SANE_ACTION_GET_VALUE, &num_dev_options, NULL);
	for (int i = 1; i < num_dev_options; ++i)
	{
		const SANE_Option_Descriptor* desp = m_mgrImpl->m_f_sane_get_option_descriptor(m_devHandle, i);
		if (nullptr == desp)
			continue;

		if (SANE_TYPE_INT == desp->type)
		{
			SANE_Int value = 0;
			m_mgrImpl->m_f_sane_control_option(m_devHandle, i, SANE_ACTION_GET_VALUE, &value, NULL);
			if (0 == strcmp(desp->name, "resolution"))
			{
				dpi = (HGUInt)value;
				break;
			}
		}
	}

	return dpi;
}

void HGAPI HGSaneDeviceImpl::ThreadFunc(HGThread thread, HGPointer param)
{
	HGSaneDeviceImpl* p = (HGSaneDeviceImpl*)param;
	while (!p->m_stopThread)
	{
		SANE_Parameters params;
		memset(&params, 0, sizeof(SANE_Parameters));
		SANE_Status stat1 = p->m_mgrImpl->m_f_sane_get_parameters(p->m_devHandle, &params);

		SANE_Int readSize = 0;
		SANE_Status stat2 = SANE_STATUS_GOOD;
		while (readSize < p->m_bufferSize)
		{
			SANE_Int len = 0;
			stat2 = p->m_mgrImpl->m_f_sane_read(p->m_devHandle, p->m_buffer + readSize, p->m_bufferSize - readSize, &len);
			readSize += len;
			if (SANE_STATUS_GOOD != stat2)
			{
				break;
			}
		}

		if (SANE_STATUS_GOOD == stat2)
		{
			// m_bufferSize空间不够
			if (NULL != p->m_eventFunc)
				p->m_eventFunc((HGSaneDevice)p, HGSANE_ERR_FAIL, p->m_mgrImpl->m_f_sane_strstatus(SANE_STATUS_INVAL), p->m_eventParam);
			break;
		}
		else if (SANE_STATUS_EOF == stat2)
		{
			if (0 == readSize)
			{
				if (NULL != p->m_eventFunc)
					p->m_eventFunc((HGSaneDevice)p, HGBASE_ERR_OK, NULL, p->m_eventParam);
				break;
			}
			else if (SANE_STATUS_GOOD != stat1 || readSize != params.bytes_per_line * params.lines)
			{
				if (NULL != p->m_eventFunc)
					p->m_eventFunc((HGSaneDevice)p, HGSANE_ERR_FAIL, p->m_mgrImpl->m_f_sane_strstatus(SANE_STATUS_INVAL), p->m_eventParam);
				break;
			}
		}
		else if (SANE_STATUS_CANCELLED == stat2)
		{
			break;
		}
		else
		{
			if (NULL != p->m_eventFunc)
				p->m_eventFunc((HGSaneDevice)p, HGSANE_ERR_FAIL, p->m_mgrImpl->m_f_sane_strstatus(stat2), p->m_eventParam);
			break;
		}

		if (NULL != p->m_imageFunc)
		{
			HGUInt imgType = 0;
			if (params.format == SANE_FRAME_GRAY)
			{
				if (1 == params.depth)
					imgType = HGBASE_IMGTYPE_BINARY;
				else if (8 == params.depth)
					imgType = HGBASE_IMGTYPE_GRAY;
			}
			else if (params.format == SANE_FRAME_RGB)
			{
				imgType = HGBASE_IMGTYPE_RGB;
			}

			HGImageInfo imgInfo = { (HGUInt)params.pixels_per_line, (HGUInt)params.lines,
									imgType, (HGUInt)params.bytes_per_line, HGBASE_IMGORIGIN_TOP };
			HGImage img = NULL;
			HGBase_CreateImageWithData(p->m_buffer, &imgInfo, &img);
			if (NULL != img)
			{
				HGBase_SetImageDpi(img, p->m_dpi, p->m_dpi);
				p->m_imageFunc((HGSaneDevice)p, img, p->m_imageParam);
				HGBase_DestroyImage(img);
			}
		}
	}
}

void HGSaneDeviceImpl::ShowScanImageCallback(const SANE_Parameters* imageFormat, const SANE_Byte* imageData, void* callbackParam)
{
	HGSaneDeviceImpl* p = (HGSaneDeviceImpl*)callbackParam;

	if (NULL != p->m_imageFunc)
	{
		HGUInt imgType = 0;
		if (imageFormat->format == SANE_FRAME_GRAY)
		{
			if (1 == imageFormat->depth)
				imgType = HGBASE_IMGTYPE_BINARY;
			else if (8 == imageFormat->depth)
				imgType = HGBASE_IMGTYPE_GRAY;
		}
		else if (imageFormat->format == SANE_FRAME_RGB)
		{
			imgType = HGBASE_IMGTYPE_RGB;
		}

		HGImageInfo imgInfo = { (HGUInt)imageFormat->pixels_per_line, (HGUInt)imageFormat->lines,
								imgType, (HGUInt)imageFormat->bytes_per_line, HGBASE_IMGORIGIN_TOP };
		HGImage img = NULL;
		HGBase_CreateImageWithData((HGByte*)imageData, &imgInfo, &img);
		if (NULL != img)
		{
			HGBase_SetImageDpi(img, p->m_dpi, p->m_dpi);
			p->m_imageFunc((HGSaneDevice)p, img, p->m_imageParam);
			HGBase_DestroyImage(img);
		}
	}
}