Moved code and documentation from landfill to tidy repository.

1 files changed, 361 insertions, 0 deletions

diff --git a/src/rastertoql570.c b/src/rastertoql570.c
new file mode 100644
index 0000000..ffd16b5
--- /dev/null
+++ b/src/rastertoql570.c
@@ -0,0 +1,361 @@
+/* rastertoql570.c: a CUPS driver for the QL-570 label printer
+ *
+ * Copyright (C) 2015 Clemens Fries <github-raster@xenoworld.de>
+ *
+ * This file is part of rastertoql570.
+ *
+ * rastertoql570 is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * rastertoql570 is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with rastertoql570.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdio.h>
+#include <unistd.h>
+#include <signal.h>
+#include <string.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <time.h>
+#include <cups/cups.h>
+#include <cups/raster.h>
+#include <cups/sidechannel.h>
+
+#include "ql570.h"
+#include "rastertoql570.h"
+
+int
+main(int argc, char** argv)
+{
+	// As per recommendation in the CUPS documentation 
+	// TODO: use sigaction()
+	signal(SIGPIPE, SIG_IGN);
+
+	FILE *fout = fdopen(STDOUT_FILENO, "wb");
+
+	if (fout == NULL) {
+		fprintf(stderr, "CRIT: Error while opening file.\n");
+		return 1;
+	}
+
+	// NOTE: Currently the resulting update of `status` by `init` (below)
+	// is not used. We still query for some status in order to determine if
+	// the printer is responding. Also, at a later stage, we can use the
+	// information in `status` to determine the printer type and set some
+	// variables, such as the raster buffer size, the minimal raster line
+	// count, etc.
+	ql_status status = { 0 };
+
+	if (!init(&status, fout)) {
+		fprintf(stderr, "CRIT: Could not get status information.\n");
+		return 1;
+	}
+
+	cups_raster_t *raster = cupsRasterOpen(0, CUPS_RASTER_READ);
+	cups_page_header2_t header;
+	unsigned int page_counter = 0;
+
+	while (cupsRasterReadHeader2(raster, &header)) {
+		handle_page(raster, header, status, page_counter, fout);
+		page_counter++;
+
+		// Printing this information will also end up on the jobs page
+		// of the CUPS web interface. I've seen a lot of printers that
+		// do not include this information and so the "Pages" number
+		// will end up being "Unknown".
+		fprintf(stderr, "PAGE: %d #-pages\n", page_counter);
+	}
+
+	cupsRasterClose(raster);
+	fclose(fout);
+
+	return EXIT_SUCCESS;
+}
+
+/**
+ * Print a page.
+ *
+ * This was factored out from main(), so (for the moment) it is a bit unwieldy
+ * with regards to parameters.
+ *
+ */
+void
+handle_page(cups_raster_t *raster, cups_page_header2_t header, ql_status status, unsigned int page_counter, FILE *fout)
+{
+	/* // TODO: Support some safety option for testing.
+	if( header.cupsHeight > 900 )
+		header.cupsHeight = 900;
+	*/
+
+	uint32_t cupsHeight = header.cupsHeight;
+
+	// Enforce a minimum of 150 lines.
+	if( cupsHeight < 150 ) {
+		cupsHeight = 150;
+	}
+
+	ql_print_info print_info = {
+		.valid_flag = PIV_QUALITY,
+		.raster_number[0] = cupsHeight & 0x00FF,
+		.raster_number[1] = (cupsHeight & 0xFF00) >> 8,
+		.successive_page = page_counter > 0
+	};
+
+	ql_page_start(&print_info, fout);
+
+	if (header.HWResolution[1] == 600)
+		ql_set_extended_options(true, true, fout);
+	else
+		ql_set_extended_options(true, false, fout);
+
+	uint8_t buffer[header.cupsBytesPerLine];
+	size_t output_buffer_size = 90; // TODO: Depends on printer type
+	uint8_t output_buffer[output_buffer_size];
+	memset(output_buffer, 0x00, output_buffer_size);
+
+	/*
+	 * We insert blank lines before and after the raster output, if the
+	 * line count of the original raster data is below 150.
+	 *
+	 * TODO: Depends on printer type, some other types need 295 lines.
+	 */
+	int blanks = 150 - header.cupsHeight;
+
+	if (blanks > 0)
+		print_blank_lines(blanks / 2, output_buffer_size, fout);
+
+	for (unsigned int i = 0; i < header.cupsHeight; ++i) {
+		if(cupsRasterReadPixels(raster, buffer, header.cupsBytesPerLine) == 0)
+			break;
+
+		// In the (undesirable) case that the input_buffer is smaller than
+		// the output_buffer
+		if (header.cupsBytesPerLine < output_buffer_size)
+			memcpy(output_buffer, buffer, header.cupsBytesPerLine);
+		else
+			memcpy(output_buffer, buffer, output_buffer_size);
+
+		ql_raster(output_buffer_size, output_buffer, fout);
+	}
+
+	if (blanks > 0)
+		print_blank_lines(blanks / 2 + (blanks % 2), output_buffer_size, fout);
+
+	ql_raster_end(output_buffer_size, fout);
+
+	// TODO: Determine total number of pages and correctly indicate last page.
+	ql_page_end(false, fout);
+	
+	// Give the printer a moment to return status data.
+	nanosleep(&(struct timespec){0, 100e6}, NULL);
+
+	wait_for_page_end();
+}
+
+/**
+ * Wait for a status indicating that the next page can be sent.
+ *
+ * This function tries to follow the printer status after a page has been
+ * submitted.  It will try up to 25 times to read a status struct and find out
+ * if an end state has been reached.
+ */
+void
+wait_for_page_end()
+{
+	ql_status status = {0};
+
+	for (uint8_t i = 0; i < 25; i++) {
+		// Sleep and skip in case of error.
+		if (!backchannel_read_status(&status)) {
+			nanosleep(&(struct timespec){0, 100e6}, NULL);
+			fprintf(stderr, "ERROR: Backchannel short read, retrying.\n");
+			continue;
+		}
+		
+		// Skip this round if data seems to be corrupt.
+		if (status.print_head_mark != 0x80) {
+			fprintf(stderr, "ERROR: Print status returned is invalid, retrying.\n");
+			continue;
+		}
+
+		if (handle_status(&status))
+			return;
+	}
+}
+
+
+/**
+ * Turns status information into user visible information.
+ *
+ * This function returns true to indicate that an end state has been reached.
+ * This means either an error occured or the printer changed to PT_WAITING
+ * (ready state).
+ *
+ * TODO: Maybe split this into further pieces, just look at that switch beneath
+ * a case!
+ *
+ * @param status the printer status to be inspected
+ * @returns true to indicate that polling can be stopped.
+ */
+bool
+handle_status(ql_status *status)
+{
+	switch(status->status_type) {
+	case ST_COMPLETED:
+		fprintf(stderr, "INFO: Page completed.\n");
+		break;
+
+	// TODO: Reduce general ugliness (the problem is that multiple error
+	// conditions might exist at the same time)
+	case ST_ERROR:
+		if(status->error_info_1 & NO_MEDIA)
+			fprintf(stderr, "ERROR: No media.\n");
+
+		if(status->error_info_1 & END_OF_MEDIA)
+			fprintf(stderr, "ERROR: End of media.\n");
+
+		if(status->error_info_1 & TAPE_CUTTER_JAM)
+			fprintf(stderr, "ERROR: Tape cutter jam.\n");
+
+		if(status->error_info_1 & MAIN_UNIT_IN_USE)
+			fprintf(stderr, "ERROR: Main unit in use.\n");
+
+		if(status->error_info_1 & FAN_MALFUNCTION)
+			fprintf(stderr, "ERROR: Fan malfunction.\n");
+
+		if(status->error_info_2 & WRONG_MEDIA)
+			fprintf(stderr, "ERROR: Wrong media.\n");
+
+		if(status->error_info_2 & TRANSMISSION_ERROR)
+			fprintf(stderr, "ERROR: Transmission error.\n");
+
+		if(status->error_info_2 & COVER_OPENED)
+			fprintf(stderr, "ERROR: Cover opened.\n");
+
+		if(status->error_info_2 & CANNOT_FEED)
+			fprintf(stderr, "ERROR: Cannot feed.\n");
+
+		return true; // stop polling
+
+	case ST_NOTIFICATION:
+		switch (status->notification_type) {
+		case NT_COOLING_STARTED:
+			fprintf(stderr, "INFO: Cooling started.\n");
+			break;
+
+		case NT_COOLING_FINISHED:
+			fprintf(stderr, "INFO: Cooling finished.\n");
+			break;
+		}
+		break;
+
+	case ST_PHASE_CHANGE:
+		switch(status->phase_type) {
+		case PT_WAITING:
+			fprintf(stderr, "INFO: Ready.\n");
+			return true; // stop polling
+
+		case PT_PRINTING:
+			fprintf(stderr, "INFO: Printing...\n");
+			break;
+		}
+		break;
+	}
+
+	return false;
+}
+
+/**
+ * Initialise the printer.
+ *
+ * This will try a few times to initalise the printer. After the first try,
+ * ql_init() will be called with flush=true. We will sleep for 100ms after each
+ * call to ql_init(), because I observed that sometimes data is not ready, but
+ * the timeout on cupsBackChannelRead will no come into effect. I guess I am
+ * misunderstanding something with regards to the timeout.
+ *
+ * TODO: Understand timeout, rewrite above paragraph. It is mucho ugly.
+ *
+ * @param status status struct to populate with a response from the printer
+ * @param device file descriptor to write to
+ */
+bool
+init(ql_status *status, FILE* device)
+{
+	bool flush = false;
+
+	for(int i = 0; i < 10; ++i) {
+		ql_init(flush, device);
+
+		nanosleep(&(struct timespec){0, 100e6}, NULL);
+
+		if (!request_status(status, device))
+			continue;
+
+		if (status->print_head_mark == 0x80)
+			return true;
+
+		// Flush printer buffers on subsequent retries.
+		flush = true;
+	}
+
+	return false;
+}
+
+/**
+ * Read status information from backchannel.
+ *
+ * @param status status struct to fill
+ * @returns false if number of bytes read was not `sizeof(ql_status)`
+ */
+bool
+backchannel_read_status(ql_status* status)
+{
+	ssize_t ret = cupsBackChannelRead((uint8_t*)status, sizeof(ql_status), 10.0);
+
+	if (ret != sizeof(ql_status))
+		return false;
+
+	return true;
+}
+
+/**
+ * Insert blank lines into raster data.
+ *
+ * @param count number of lines
+ * @param buffer_size size of the raster line (e.g. 90)
+ * @param device file descriptor to write to
+ */
+void
+print_blank_lines(uint32_t count, size_t buffer_size, FILE *device)
+{
+	uint8_t buffer[buffer_size];
+	memset(buffer, 0x00, buffer_size);
+
+	for(uint32_t i = 0; i < count; i++)
+		ql_raster(buffer_size, buffer, device);
+}
+
+/**
+ * Request status and read response from backchannel.
+ *
+ * @param status status struct to fill
+ * @returns status of backchannel_read_status() operation
+ */
+bool
+request_status(ql_status *status, FILE *device)
+{
+	// Send status request
+	ql_status_request(device);
+
+	// Read response
+	return backchannel_read_status(status);
+}