path: root/src/ql.c

/*
 * Copyright 2017 DiUS Computing Pty Ltd. All rights reserved.
 *
 * Released under GPLv3, see LICENSE for details.
 *
 * @author Johny Mattsson <jmattsson@dius.com.au>
 */
#include "ql.h"
#include <unistd.h>
#include <errno.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>

struct ql_ctx {
	char *printer;
	int fd;
};

#define ESC 0x1b

#define NUM_STATUS_READ_RETRIES 100

#define full_write(fd, buf) (retry_write(fd, buf, sizeof(buf)) == (ssize_t)sizeof(buf))

ssize_t retry_write(int fd, const char *buf, size_t len)
{
	size_t written = 0;
	while (written != len) {
		ssize_t n = write(fd, buf + written, len - written);
		if (n == -1) {
			if (errno == EAGAIN || errno == EINTR)
				continue;
			else
				break;
		} else
			written += n;
	}
	return written;
}

ql_ctx_t ql_open(const char *printer)
{
	int fd = open(printer, O_RDWR);
	if (fd < 0)
		return NULL;

	ql_ctx_t ctx = malloc(sizeof(struct ql_ctx));
	if (!ctx)
		return NULL;
	ctx->printer = strdup(printer);
	ctx->fd = fd;

	const char clear[200] = { 0, };
	(void)full_write(fd, clear);	// recommended to clear old/errored jobs

	return ctx;
}

void ql_close(ql_ctx_t ctx)
{
	free(ctx->printer);
	close(ctx->fd);
	free(ctx);
}

bool ql_init(ql_ctx_t ctx)
{
	const char init[] = { ESC, '@' };
	return full_write(ctx->fd, init);
}

bool ql_request_status(ql_ctx_t ctx)
{
	const char status_req[] = { ESC, 'i', 'S' };
	return full_write(ctx->fd, status_req);
}

bool ql_read_status(ql_ctx_t ctx, ql_status_t * status)
{
	for (int i = 0; i < NUM_STATUS_READ_RETRIES; ++i) {
		int ret = read(ctx->fd, status, sizeof(*status));
		if (ret == 32)
			return true;
		else if ((ret == 0)	// "no data yet, too bad we just eof'd your fd, sucker"
			 || (ret == -1 && errno == EBADF))	// in case we messed up, somehow
		{
			close(ctx->fd);
			ctx->fd = open(ctx->printer, O_RDWR);
			if (ctx->fd < 0)
				return false;
		} else if (ret == -1 && (errno != EAGAIN || errno != EINTR))
			return false;	// non-recoverable
	}
	errno = ETIME;
	return false;
}

bool ql_set_mode(ql_ctx_t ctx, unsigned mode)
{
	char cmd[] = { ESC, 'i', 'M', mode };
	return full_write(ctx->fd, cmd);
}

bool ql_set_expanded_mode(ql_ctx_t ctx, unsigned mode)
{
	char cmd[] = { ESC, 'i', 'K', mode };
	return full_write(ctx->fd, cmd);
}

bool ql_set_autocut_every_n(ql_ctx_t ctx, uint8_t n)
{
	char cmd[] = { ESC, 'i', 'A', n };
	return full_write(ctx->fd, cmd);
}

bool ql_set_margin(ql_ctx_t ctx, uint16_t dots)
{
	char cmd[] = { ESC, 'i', 'd', dots & 0xff, dots >> 8 };
	return full_write(ctx->fd, cmd);
}

bool ql_needs_mode_switch(const ql_status_t * status)
{
	switch (status->model_code) {
	case '3':
	case '4':
	case 'P':
	case 'Q':
		return true;
	default:
		break;
	}
	return false;
}

bool ql_switch_to_raster_mode(ql_ctx_t ctx)
{
#define MODE_ESC_P  0
#define MODE_RASTER 1
#define MODE_P_TOUCH_TEMPLATE 3
	char cmd[] = { ESC, 'i', 'a', MODE_RASTER };
	return full_write(ctx->fd, cmd);
}

static void pack_column(uint8_t * out, uint16_t bytes, uint16_t colno,
			const ql_raster_image_t * img, uint8_t black_below_v)
{
	for (unsigned n = 0; n < bytes; ++n, ++out) {
		*out = 0;
		for (unsigned i = 0; i < 8; ++i) {
			unsigned img_row = n * 8 + i;
			if (img_row < img->height)
				if (img->data[img_row * img->width + colno] < black_below_v)
					*out |= 1 << (7 - i);
		}
		//for(int i = 7; i >= 0; --i) fprintf(stderr, "%c", (*out & (1<<i)) ? '#' : '.');
	}
	//fprintf(stderr,"\n");
}

bool ql_print_raster_image(ql_ctx_t ctx, const ql_status_t * status,
			   const ql_raster_image_t * img, const ql_print_cfg_t * cfg)
{
	unsigned dn = 90;	// default raster transmission block size (720 pixels)
	if (status->model_code == 'P' || status->model_code == '4')
		dn = 162;	// 1296 pixels

	if (img->height > dn * 8)
		return false;	// image too wide for printer

	char print_info[] = { ESC, 'i', 'z',
		cfg->flags | 0x80,
		(cfg->flags & QL_PRINT_CFG_MEDIA_TYPE) ? cfg->media_type : 0,
		(cfg->flags & QL_PRINT_CFG_MEDIA_WIDTH) ? cfg->media_width : 0,
		(cfg->flags & QL_PRINT_CFG_MEDIA_LENGTH) ? cfg->media_length : 0,
		img->width & 0xff, img->width >> 8, 0, 0,
		cfg->first_page ? 0 : 1, 0
	};
	if (!full_write(ctx->fd, print_info))
		return false;

	for (unsigned w = 0; w < img->width; ++w) {
		char block[dn + 3];
		block[0] = 'g';
		block[1] = 0;
		block[2] = dn;
		pack_column((uint8_t *) block + 3, dn, w, img, cfg->threshold);
		if (!full_write(ctx->fd, block))
			return false;
	}

	char done[] = { 0x1a };	// print with feeding
	return full_write(ctx->fd, done);
}

const char *ql_decode_model(const ql_status_t * status)
{
	switch (status->model_code) {
	case '1':
		return "QL-560";
	case '2':
		return "QL-570";
	case '3':
		return "QL-580N";
	case '4':
		return "QL-1060N";
	case '5':
		return "QL-700";
	case '6':
		return "QL-710W";
	case '7':
		return "QL-720NW";
	case 'O':
		return "QL-500/550";
	case 'P':
		return "QL-1050";
	case 'Q':
		return "QL-650TD";
	default:
		{
			static char buf[] = "unrecognised (type code 0x$$)";
			char *q = strchr(buf, '$');
			sprintf(q, "%02hhx)", status->model_code);
			return buf;
		}
	}
}

const char *ql_decode_mode(const ql_status_t * status)
{
	if (status->mode & QL_MODE_AUTOCUT)
		return "auto-cut";
	else
		return "no-auto-cut";
}

const char *ql_decode_errors(const ql_status_t * status)
{
	typedef struct {
		uint16_t bit;
		const char *str;
	} strmap_t;

#define ERR1(x) (x << 0)
#define ERR2(x) (x << 8)
	const strmap_t strmap[] = {
		{ERR1(QL_ERR_1_NO_MEDIA), "no-media "},
		{ERR1(QL_ERR_1_END_OF_MEDIA), "end-of-media "},
		{ERR1(QL_ERR_1_CUTTER_JAM), "cutter-jam "},
		{ERR1(QL_ERR_1_PRINTER_IN_USE), "printer-in-use "},
		{ERR1(QL_ERR_1_PRINTER_TURNED_OFF), "printer-turned-off "},
		{ERR1(QL_ERR_1_HIGH_VOLTAGE_ADAPTER), "high-voltage-adapter "},
		{ERR1(QL_ERR_1_FAN_MOTOR_ERROR), "fan-motor-error "},

		{ERR2(QL_ERR_2_REPLACE_MEDIA), "replace-media "},
		{ERR2(QL_ERR_2_EXPANSION_BUFFER_FULL), "expansion-buffer-full "},
		{ERR2(QL_ERR_2_COMMUNICATION_ERROR), "communication-error "},
		{ERR2(QL_ERR_2_COMMUNICATION_BUFFER_FULL), "communication-buffer-full "},
		{ERR2(QL_ERR_2_COVER_OPEN), "cover-open "},
		{ERR2(QL_ERR_2_CANCEL_KEY), "cancel-key-pressed "},
		{ERR2(QL_ERR_2_MEDIA_CANNOT_BE_FED), "media-cannot-be-fed "},
		{ERR2(QL_ERR_2_SYSTEM_ERROR), "system-error "}
	};

	static char *buf = 0;
	if (!buf) {
		int len = 0;
		for (unsigned i = 0; i < (sizeof(strmap) / sizeof(strmap[0])); ++i)
			len += strlen(strmap[i].str);
		buf = malloc(len + 1);
		if (!buf)
			return "<host-out-of-memory>";
	}

	uint16_t errs = ERR1(status->err_info_1) | ERR2(status->err_info_2);
	buf[0] = 0;
	for (unsigned i = 0; i < (sizeof(strmap) / sizeof(strmap[0])); ++i) {
		if (errs & strmap[i].bit)
			strcat(buf, strmap[i].str);
	}
	return (buf[0] == 0) ? "none" : buf;
}

const char *ql_decode_media_type(const ql_status_t * status)
{
	switch (status->media_type) {
	case QL_MEDIA_TYPE_NO_MEDIA:
		return "no-media";
	case QL_MEDIA_TYPE_CONTINUOUS:
	case QL_MEDIA_TYPE_CONTINUOUS_ALT:
		return "continuous-length-tape";
	case QL_MEDIA_TYPE_DIECUT_LABELS:
	case QL_MEDIA_TYPE_DIECUT_LABELS_ALT:
		return "die-cut-labels";
	default:{
			static char buf[] = "unknown (code 0x$$)";
			char *q = strchr(buf, '$');
			sprintf(q, "%02hhx)", status->media_type);
			return buf;
		}
	}
}

void ql_decode_print_status(FILE * f, const ql_status_t * status, unsigned flags)
{
	if (!status)
		return;

	const char *fmt_s = "%17s: %s\n";
	const char *fmt_u = "%17s: %u\n";
	if (flags & QL_DECODE_MODEL)
		fprintf(f, fmt_s, "Printer", ql_decode_model(status));
	if (flags & QL_DECODE_MODE)
		fprintf(f, fmt_s, "Mode", ql_decode_mode(status));
	if (flags & QL_DECODE_ERROR)
		fprintf(f, fmt_s, "Errors", ql_decode_errors(status));
	if (flags & QL_DECODE_MEDIA) {
		fprintf(f, fmt_s, "Media type", ql_decode_media_type(status));
		fprintf(f, fmt_u, "Media width (mm)", status->media_width_mm);
		if (status->media_type != QL_MEDIA_TYPE_CONTINUOUS)
			fprintf(f, fmt_u, "Media length (mm)", status->media_length_mm);
	}
}