Moved code and documentation from landfill to tidy repository.

6 files changed, 1103 insertions, 0 deletions

diff --git a/src/Makefile b/src/Makefile
new file mode 100644
index 0000000..2c2cf5f
--- /dev/null
+++ b/src/Makefile
@@ -0,0 +1,11 @@
+CC=gcc
+CFLAGS=-Wall -Wextra -g
+#CFLAGS=-g
+
+rastertoql570: ql570.h ql570.c rastertoql570.h rastertoql570.c
+	rm -f ../rastertoql570
+	$(CC) $(CFLAGS) -lcups -lcupsimage ql570.c rastertoql570.c -o ../rastertoql570
+
+minimal: ql570.h ql570.c examples/minimal.c
+	rm -f ../minimal
+	$(CC) $(CFLAGS) -lcups -lcupsimage ql570.c examples/minimal.c -o ../minimal
diff --git a/src/examples/minimal.c b/src/examples/minimal.c
new file mode 100644
index 0000000..5550e9e
--- /dev/null
+++ b/src/examples/minimal.c
@@ -0,0 +1,119 @@
+/* minimal.c: a minmal example for using the QL-570 utility functions
+ *
+ * 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 "../ql570.h"
+
+/**
+ * Raster line length for the QL-570 is 90 bytes. There are some other QL
+ * series printers that need a larger buffer.
+ */
+#define BUFFER_SIZE 90
+
+/**
+ * Minimal example program for direct printer access.
+ *
+ * For a better understanding of what goes on here, please refer
+ * to the documentation of each function. At times there are
+ * interesting bits of information over there.
+ *
+ */
+int main()
+{
+	FILE *device = fopen("/dev/usb/lp0", "wb");
+	ql_status status = {0};
+	uint8_t buffer[BUFFER_SIZE];
+
+	/*
+	 * Request a print job with 150 lines (the minimal amount of lines for
+	 * the QL-570). Note that this number is mandatory. If you print less
+	 * than 150 lines, or indicate some wrong amount of lines here, the
+	 * printer will just resort to blinking its red LED while observing you
+	 * with displeasure.
+	 */
+	ql_print_info print_info = { .raster_number[0] = 150 };
+
+	/*
+	 * Initialise printer. The first flag indicates that we won't be
+	 * flushing the printer with 200 bytes of zeroes.
+	 */
+	ql_init(false, device);
+
+	/*
+	 * Ask the printer to give us a status report.
+	 */
+	ql_status_request(device);
+
+	/*
+	 * Retrieve the status report.
+	 */
+	ql_status_read(&status, device);
+
+	/*
+	 * Send the contents of `print_info` to the printer.
+	 */
+	ql_page_start(&print_info, device);
+
+	/*
+	 * Set some extended options: cut-at-end plus 300dpi printing.
+	 */
+	ql_set_extended_options(true, false, device);
+	
+	/*
+	 * Print some black lines.
+	 */
+	for (int i = 0; i < 150; i++) {
+
+		/*
+		 * Every now and then: Many, many 1s.
+		 */
+	        memset(buffer, i % 5 == 0 ? 0xFF : 0x00, BUFFER_SIZE);
+
+		/*
+		 * We empty the first two bytes in order to force a small
+		 * margin. Note that for 62mm the right and left margin is
+		 * about 12 dots. I observed that I have a margin any way on
+		 * one side, but it looks like it is printing outside the label
+		 * area on the other side. It's not that important, but I do
+		 * it anyway because I'm not sure about the mechanics and how
+		 * well the print heads cope with doing their thing outside
+		 * the printable area.
+		 *
+		 */
+		buffer[0] = 0x00;
+		buffer[1] = 0x00;
+
+		/*
+		 * Send this raster line to the printer.
+		 */
+	        ql_raster(BUFFER_SIZE, buffer, device);
+	}
+	
+	/*
+	 * Indicate the end of raster data to the printer.
+	 */
+	ql_raster_end(BUFFER_SIZE, device);
+
+	/*
+	 * Tell it that this was the last page.
+	 */
+	ql_page_end(true, device);
+
+	fclose(device);
+}
diff --git a/src/ql570.c b/src/ql570.c
new file mode 100644
index 0000000..e642f91
--- /dev/null
+++ b/src/ql570.c
@@ -0,0 +1,280 @@
+/* ql570.c: facilities for communicating with 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 "ql570.h"
+
+/**
+ * Request status from printer.
+ *
+ * @param device file descriptor to write to
+ */
+void
+ql_status_request(FILE *device)
+{
+	uint8_t request[3] = {QL_ESC, 0x69, 0x53};
+	fwrite(request, 3, 1, device);
+	fflush(device);
+}
+
+/**
+ * Read a status response from the printer.
+ *
+ * @param status ql_status struct holding the response
+ * @param device file descriptor to write to
+ * @return true if successful, false if short read
+ */
+bool
+ql_status_read(ql_status *status, FILE *device)
+{
+	size_t len = fread(status, sizeof(ql_status), 1, device);
+
+	if (len != sizeof(ql_status)) {
+		return false;
+	}
+
+	return true;
+}
+
+/**
+ * Initialise printer.
+ *
+ * The protocol specification has an optional recommendation to flush lingering
+ * partial commands with 200 bytes of 0x00.
+ *
+ * @param flush prepend 200 bytes of invalid (0x00) data
+ * @param device file descriptor to write to
+ */
+void
+ql_init(bool flush, FILE *device)
+{
+	if (flush) {
+		uint8_t init_buffer[200];
+		memset(&init_buffer, 0x0, 200);
+		fwrite(init_buffer, sizeof(uint8_t), 200, device);
+		fflush(device);
+	}
+
+	uint8_t request[2] = {QL_ESC, 0x40};
+	fwrite(request, 2, 1, device);
+	fflush(device);
+}
+
+/**
+ * Write one line of raster data to the printer.
+ *
+ * For most printers in the QL series one raster line is at most 90 bytes long.
+ * As these are monochrome printers this means a line has 720 pixels (at most).
+ *
+ * @param length length of the raster data
+ * @param data pointer to the raster data
+ * @param device file descriptor to write to
+ */
+void
+ql_raster(uint8_t length, uint8_t *data, FILE *device)
+{
+	uint8_t request[3] = {0x67, 0x00, length};
+	fwrite(request, 3, 1, device);
+	fwrite(data, length, 1, device);
+	fflush(device);
+}
+
+/**
+ * Signal end of raster data.
+ *
+ * @param length length of raster data (0x00)
+ * @param device file descriptor to write to
+ */
+void
+ql_raster_end(uint8_t length, FILE *device)
+{
+	uint8_t request[3] = {0x67, 0xFF, length};
+
+	uint8_t data[length];
+	memset(&data, 0x00, length);
+
+	fwrite(request, 3, 1, device);
+	fwrite(data, length, 1, device);
+
+	fflush(device);
+}
+
+/**
+ * Start a new page.
+ *
+ * This will write out the contents of the print_info pointer to the printer.
+ *
+ * @param print_info print_info
+ * @param device file descriptor to write to
+ */
+void
+ql_page_start(ql_print_info *print_info, FILE *device)
+{
+	uint8_t request[3] = {QL_ESC, 0x69, 0x7A};
+	fwrite(request, 3, 1, device);
+	fwrite(print_info, sizeof(ql_print_info), 1, device);
+	fflush(device);
+}
+
+/**
+ * End the current page.
+ *
+ * @param last_page indicate that this is the last page
+ * @param device file descriptor to write to
+ */
+void
+ql_page_end(bool last_page, FILE *device)
+{
+	uint8_t request;
+
+	if (last_page) {
+		request = 0x1A;
+	} else {
+		request = 0x0C;
+	}
+
+	fwrite(&request, 1, 1, device);
+	fflush(device);
+}
+
+
+/**
+ * Set extended options.
+ *
+ * This is called 'set expanded mode' in the specification.
+ *
+ * ### Cutting
+ *
+ * Pain points with the specification:
+ *
+ * * The diagram is wrong. The description says, this is bit 3, the diagram
+ *   says, this is bit 4. This cost me some time.
+ *   TODO: Check 720N/NW. The documentation there lacks the diagram and the
+ *   description sys it is bit 4. I bet this is wrong!
+ * * Not cutting is the default. The description says that 'cut at end' is the
+ *   default.
+ *
+ * TODO: This seems to cut after each page, regardless of whether last_page is
+ * set. I don't get it.
+ *
+ * ### High resolution printing
+ *
+ * Note that this is the resolution along the label _length_. The resolution
+ * along the _width_ of the media will stay the same. This means that more
+ * lines will be squeezed in the same space.
+ *
+ * Selecting high resolution printing, will allow the shortest label produced
+ * to be shrunk from 12.7mm to 6.35mm. The minimum label length is 150 lines,
+ * doubling the resolution will halve the length.
+ *
+ * @param cut_at_end
+ * @param high_resolution false: 300x300 dpi, true: 300x600 dpi
+ * @param device file descriptor to write to
+ */
+void
+ql_set_extended_options(bool cut_at_end, bool high_resolution, FILE *device)
+{
+	uint8_t options = 0x00;
+
+	if (cut_at_end)
+		options |= OPT_CUT_AT_END;
+
+	if (high_resolution)
+		options |= OPT_HIGH_RESOLUTION;
+
+	uint8_t request[4] = {QL_ESC, 0x69, 0x4B, options};
+	fwrite(request, 4, 1, device);
+	fflush(device);
+}
+
+/**
+ * Enable automatic label cutting.
+ *
+ * The specification calls this "set each mode". The bits of the last byte in
+ * the command sequence are either described as unused or undefined, setting
+ * bit 6 enables auto cut.
+ *
+ * @param device file descriptor to write to
+ */
+void
+ql_autocut_enable(FILE *device)
+{
+	uint8_t request[4] = {QL_ESC, 0x69, 0x4D, 0b01000000};
+	fwrite(request, 4, 1, device);
+	fflush(device);
+}
+
+/**
+ * Cut after each _n_ labels.
+ *
+ * For continuous length labels it makes sense to cut after every page. For 
+ * other label types it might make sense to cut after several labels.
+ *
+ * TODO: default is 1, does that work? If yes, note here
+ *
+ * @param interval cut after _interval_ number of pages
+ * @param device file descriptor to write to
+ */
+void
+ql_autocut_interval(uint8_t interval, FILE *device)
+{
+	uint8_t request[4] = {QL_ESC, 0x69, 0x41, interval};
+	fwrite(request, 4, 1, device);
+	fflush(device);
+}
+
+/**
+ * Sets the default margins.
+ *
+ * The specification recommends setting the margins to 35 for several printer
+ * types, including the QL-570. For other types this is not indicated. Setting
+ * this seems to be optional.
+ *
+ * If the media is 'die cut', then the margins will always be 0.
+ *
+ * See ql_set_margins for details.
+ *
+ * @param
+ * @param device file descriptor to write to
+ *
+ */
+void
+ql_set_default_margins(enum ql_media_type media_type, FILE *device)
+{
+	if (media_type == MT_CONTINUOUS)
+		ql_set_margins(35, device);
+	else
+		ql_set_margins(0, device);
+}
+
+/**
+ * Set margins on continuous tape.
+ *
+ * This adds _margins_ amount of blank lines before and after the label.
+ *
+ * @param margins number of blank lines
+ * @param device file descriptor to write to
+ */
+void
+ql_set_margins(uint16_t margins, FILE *device)
+{
+	uint8_t request[5] = {QL_ESC, 0x69, 0x64, margins & 0x00FF, (margins & 0xFF00) >> 8};
+	fwrite(request, 5, 1, device);
+	fflush(device);
+}
diff --git a/src/ql570.h b/src/ql570.h
new file mode 100644
index 0000000..c346e9a
--- /dev/null
+++ b/src/ql570.h
@@ -0,0 +1,300 @@
+/* ql570.h: facilities for communicating with 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/>.
+ */
+
+#ifndef _QL570_H_
+#define _QL570_H_
+
+#include <stdio.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <string.h>
+
+#define QL_ESC 0x1b
+#define QL_INVALID 0x00
+
+enum ql_extended_option {
+	OPT_CUT_AT_END      = 0x08,
+	OPT_HIGH_RESOLUTION = 0x40
+};
+
+enum ql_printer_type {
+	QL_OTHER   = 0x00,
+	QL_500_550 = 0x4F,
+	QL_560     = 0x31,
+	QL_570     = 0x32,
+	QL_580N    = 0x33,
+	QL_650TD   = 0x51,
+	QL_700     = 0x35,
+	QL_1050    = 0x50,
+	QL_1060N   = 0x34
+};
+
+enum ql_error_info_1 {
+	NO_MEDIA         = 0x01,
+	END_OF_MEDIA     = 0x02,
+	TAPE_CUTTER_JAM  = 0x04,
+	MAIN_UNIT_IN_USE = 0x10,
+	FAN_MALFUNCTION  = 0x80
+};
+
+enum ql_error_info_2 {
+	/**
+	 * Requested media type is not loaded into the printer.
+	 *
+	 * Another gem from the specification. The table in section 4.2.1
+	 * describes that bit 0 of _Error information 2_ is unused.  The
+	 * command description for _Print information command_ states that bit
+	 * 0 of that field is set to `true` when media type, width and length
+	 * are set in the struct's `valid_flag` and the wrong media is loaded.
+	 */
+	WRONG_MEDIA	   = 0x01,
+	TRANSMISSION_ERROR = 0x04,
+	COVER_OPENED       = 0x10,
+	CANNOT_FEED        = 0x40,
+	SYSTEM_ERROR       = 0x80
+};
+
+enum ql_media_type {
+	MT_CONTINUOUS = 0x0A,
+	MT_DIE_CUT    = 0x0B
+};
+
+enum ql_status_type {
+	ST_REPLY        = 0x00,
+	ST_COMPLETED    = 0x01,
+	ST_ERROR        = 0x02,
+	ST_NOTIFICATION = 0x05,
+	ST_PHASE_CHANGE = 0x06
+};
+
+enum ql_notification_type {
+	NT_NA = 0x00,
+	NT_COOLING_STARTED  = 0x03,
+	NT_COOLING_FINISHED = 0x04
+};
+
+enum ql_phase_type {
+	PT_WAITING  = 0x00,
+	PT_PRINTING = 0x01
+};
+
+enum ql_print_info_validity {
+	/**
+	 * Stop with error (`ql_error_info_2.WRONG_MEDIA`) if the requested
+	 * media type is different from the loaded media type.
+	 */
+	PIV_MEDIA_TYPE    = 0x02,
+
+	/**
+	 * Stop with error (`ql_error_info_2.WRONG_MEDIA`) if the requested
+	 * media width is different from the loaded media width.
+	 */
+	PIV_MEDIA_WIDTH   = 0x04,
+
+	/**
+	 * Stop with error (`ql_error_info_2.WRONG_MEDIA`) if the requested
+	 * media length is different from the loaded media length.
+	 */
+	PIV_MEDIA_LENGTH  = 0x08,
+
+	/**
+	 * Prefer quality over speed.
+	 */
+	PIV_QUALITY       = 0x40,
+
+	/**
+	 * A mysterious flag described as "Always ON" in the specification.  An
+	 * intial suspicion that this might signal the printer to recover from
+	 * errors after a short amount of time turned out to be wrong. (This
+	 * was based on the name `PI_RECOVER` as used in the specification.)
+	 */
+	PIV_RECOVER       = 0x80
+};
+
+typedef struct ql_print_info ql_print_info;
+struct ql_print_info {
+	/*
+	 * See #ql_print_info_validity.
+	 */
+	uint8_t valid_flag;
+	uint8_t media_type;
+	uint8_t media_width;
+	uint8_t media_length;
+
+	/*
+	 * Number of lines to be printed.
+	 *
+	 * TODO: rename?
+	 */
+	uint8_t raster_number[4];
+
+	/**
+	 * TODO: What are the effects of this setting?
+	 *
+	 * Set to `0` on the first page, `1` for successive pages;
+	 */
+	uint8_t successive_page;
+	uint8_t _fixed;
+};
+
+typedef struct ql_status ql_status;
+struct ql_status {
+	/**
+	 * Always 0x80.
+	 */
+	uint8_t print_head_mark;
+
+	/**
+	 * Always 32 bytes.
+	 */
+	uint8_t size;
+	uint8_t _reserved3;
+	uint8_t _reserved4;
+
+	/**
+	 * Officially named 'reserved' but according to the documentation it
+	 * indeed does identify the printer. Note that the specification is
+	 * from 2011 and thus cannot include any newer printers in the QL
+	 * series.
+	 */
+	uint8_t printer_id;
+
+	/**
+	 * Always 0x30.
+	 */
+	uint8_t _reserved6;
+
+	/**
+	 * Always 0x00.
+	 */
+	uint8_t _reserved7;
+
+	/**
+	 * Always 0x00.
+	 */
+	uint8_t _reserved8;
+
+	/**
+	 * See #ql_error_info_1.
+	 */
+	uint8_t error_info_1;
+
+	/**
+	 * See #ql_error_info_2.
+	 */
+	uint8_t error_info_2;
+
+	/**
+	 * Width of the label.
+	 */
+	uint8_t media_width;
+
+	/**
+	 * See #ql_media_type.
+	 */
+	uint8_t media_type;
+
+	/**
+	 * Always 0x00.
+	 */
+	uint8_t _reserved13;
+
+	/**
+	 * Always 0x00.
+	 */
+	uint8_t _reserved14;
+
+	/**
+	 * Not set.
+	 */
+	uint8_t _reserved15;
+
+	/**
+	 * Not set.
+	 */
+	uint8_t _reserved16;
+
+	/**
+	 * Always 0x00.
+	 */
+	uint8_t _reserved17;
+
+	/**
+	 * Length of ready-to-use labels, or zero for continuous labels.
+	 */
+	uint8_t media_length;
+
+	/**
+	 * See #ql_status_type.
+	 */
+	uint8_t status_type;
+
+	/**
+	 * See #ql_phase_type.
+	 */
+	uint8_t phase_type;
+
+	/**
+	 * Effectively 0x00. The specification states that this fields is 0x00
+	 * if it is not used (i.e. no 'phase change' was indicated in the
+	 * status_type field.). The table for the 'phase types' also indicates
+	 * that this field is 0x00 in both phases.
+	 */
+	uint8_t phase_num_h;
+
+	/**
+	 * Effectively 0x00. The specification states that this fields is 0x00
+	 * if it is not used (i.e. no 'phase change' was indicated in the
+	 * status_type field.). The table for the 'phase types' also indicates
+	 * that this field is 0x00 in both phases.
+	 */
+	uint8_t phase_num_l;
+
+	/**
+	 * See #ql_notification_type.
+	 */
+	uint8_t notification_type;
+
+	/**
+	 * Not set.
+	 */
+	uint8_t _reserved24;
+
+	/**
+	 * Not set. This is probably just for padding the struct to 32 bytes.
+	 */
+	uint8_t _reserved25[8];
+};
+
+void ql_init(bool flush, FILE* device);
+void ql_status_request(FILE* device);
+bool ql_status_read(ql_status* status, FILE* device);
+void ql_status_debug(ql_status* status);
+void ql_raster(uint8_t length, uint8_t* data, FILE* device);
+void ql_raster_end(uint8_t length, FILE* device);
+void ql_page_start(ql_print_info* print_info, FILE* device);
+void ql_page_end(bool last_page, FILE* device);
+void ql_set_extended_options(bool cutAtEnd, bool highResolution, FILE* device);
+void ql_autocut_enable(FILE* device);
+void ql_autocut_interval(uint8_t interval, FILE* device);
+void ql_set_default_margins(enum ql_media_type, FILE* device);
+void ql_set_margins(uint16_t margins, FILE* device);
+
+#endif
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);
+}
diff --git a/src/rastertoql570.h b/src/rastertoql570.h
new file mode 100644
index 0000000..7e1fe2d
--- /dev/null
+++ b/src/rastertoql570.h
@@ -0,0 +1,32 @@
+/* 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/>.
+ */
+
+#ifndef _RASTERTOQL570_H
+#define _RASTERTOQL570_H
+
+bool backchannel_read_status(ql_status*);
+bool init(ql_status*, FILE*);
+bool request_status(ql_status*, FILE*);
+void wait_for_page_end();
+bool handle_status(ql_status*);
+void print_blank_lines(uint32_t count, size_t buffer_size, FILE *device);
+void handle_page(cups_raster_t*, cups_page_header2_t, ql_status, unsigned int, FILE*);
+
+#endif