ql-series.h

Go to the documentation of this file.

#pragma once
/*
 * SPDX-License-Identifier: GPL-2.0-or-later
 *
 * (c) 2022 Juergen Borleis <projects@caps-printing.org>
 *
 * This program 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 2 of the License, or (at your option)
 * any later version.
 */
#include <stdlib.h>
#include <stdint.h>
 
#include <libcapsbase.h>
#include <libcapsdriver.h>
 
#ifdef DEBUG
# define caps_print_debug(fmt, ...) caps_print_debug_template(fmt, ##__VA_ARGS__)
# else
# define caps_print_debug(fmt, ...)
#endif
 
#define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))
#define DOTS_TO_BYTES(x) ((x + 7U) / 8U)
#define DOTS_TO_WORDS(x) ((x + 15U) / 16U)
#define BIT(x) (1 << (x))
 
/* handle NLS */
#ifdef ENABLE_NLS
 
# ifndef PACKAGE
#  error "Missing 'PACKAGE' macro: include 'config.h' first"
# endif
 
# include <libintl.h>
 
/* regular and inconspicuous NLS marker */
# define _(string) dgettext(PACKAGE, string)
 
#else /* ENABLE_NLS */
 
# define _(string) (string)
 
#endif /* !ENABLE_NLS */
 
/* a more inconspicuous NLS marker used for all NLS strings in static data */
#define NLS_(string) (string)
 
#include "ql-printer-series.h"
 
 
#undef TEST_1
 
#define COLOUR_VAL_DARK 0x00
#define COLOUR_VAL_BRIGHT 0xff
 
#define PRINT_DOT_VAL 0x00
 
#define DEFAULT_QL_LINE_SIZE 90
 
enum ql_half_tone {
    QL_UNKNOWN = 0, 
    QL_NONE = 1, 
    QL_ORDERED = 2, 
    QL_ERROR_DIFFUSION = 4, 
};
typedef unsigned char conv_type;
struct halftone_converter {
    unsigned right_left:1; 
    signed int dotval[2]; 
    signed int threshold; 
    size_t pixel_count; 
    conv_type *sliding_lines[2]; 
};
 
/*
 * How does the printer prints?
 *
@verbatim
                                          ^ Paper roll
 |                                        |
 |                       Printer |                    | |
 |                               |                    | |
 | ##############################|####################| | <--- printer head
 +-------------------------------|                    |-+
                                 |       Paper        |
                                 |                    |
                                 +--------------------+
                                           |
                                           v Paper move direction
@endverbatim
 *
 * Printing is face down. You can't see what you have printed until you
 * cut the tape.
 * And the printer prints from right to left, the first pixel comes with bit 7 in the first byte.
 * The paper/tape is always right aligned.
 */
 
/*
 * @brief The printer's mechanics:
 *
 * For continuous length tape:
 *
 * |<--------------------------- mechanical paper feed 66 mm ------------------------------------->|
 * |<-------------------------------- widest tape 66 mm ------------------------------------------>|
 * |<>|<------------------------- widest paper on tape 62 mm ---------------------------------->|<>| ~2 mm margins at both sides
 * |<->|<------------------------ widest printable area 61 mm -------------------------------->|<->| 2,5 mm margins at both sides
 *
 * Assumption: the printer head spans the printable area with its 720 dots.
 *
 * Open questions:
 * - is the print head centered?
 * - or is the print head "left-aligned"
 *
 * The 61 mm are calculated with: 720 dots at 300 DPI results into 60,96 mm
 *
 * For a die-cut 17 mm x 54 mm label:
 *
 * |<--------------------------- mechanical paper feed 66 mm ------------------------------------->|
 * |<--------- tape 18 mm ---------->|
 * |<>|<-- paper on tape 17 mm -->|<>| FIXME mm margins at both sides
 *
 * For a die-cut 29 mm x 90,3 mm label:
 *
 * |<--------------------------- mechanical paper feed 66 mm ------------------------------------->|
 * |<------------ tape 32 mm ------------->|
 * |<>|<----- paper on tape 29 mm ----->|<>| 1,5 mm magins at both sides
 */
 
struct ql_trim {
    unsigned raster_width; 
    unsigned raster_height; 
    unsigned medium_width; 
    unsigned medium_height; 
    double medium_width_mm; 
    double medium_height_mm; 
    unsigned top_skip; 
    unsigned top_offset; 
    unsigned top_keep; 
    unsigned left_skip; 
    unsigned left_offset; 
    unsigned left_keep; 
};
struct ql_job {
    double resx, resy;
    enum ql_half_tone half_tone_type;
    unsigned high_density_print:1;
    struct ql_trim trim;
    int first_page;
};
struct ql_drv {
    struct caps_drv *drvi;
    FILE *writeto; 
    enum ql_printer sel_prn; 
    /* Printer device parameters */
    unsigned leading_bytes; 
    unsigned bytes_per_line; 
    unsigned dot_count; 
    unsigned manual_cutter:1; 
    unsigned auto_cutter:1; 
    unsigned bi_colour_prn_caps:1; 
    unsigned high_density_prn_caps:1; 
    /* Printer device specific medium parameters */
    unsigned min_margin; 
    unsigned max_margin; 
    unsigned min_length; 
    unsigned max_length; 
    unsigned min_width; 
    unsigned max_width; 
    /* Medium parameters */
    unsigned bi_colour_medium_present:1; 
    unsigned pre_sized:1; 
    struct caps_area print_large_margins; /* …for large sized labels */
    struct caps_area print_small_margins; /* …for small sized labels */
 
    struct ql_job job;
};
static inline struct ql_drv *to_ql_drv(void *d) { return (struct ql_drv *)d; }
 
void sliding_halftone_get(struct halftone_converter *cnv) __nonnull();
void sliding_halftone_put(struct halftone_converter *cnv) __nonnull();
void halftone_line_no_dither(struct halftone_converter *cnv) __nonnull();
void halftone_line_ordered(struct halftone_converter *cnv) __nonnull();
void halftone_line_with_error_diffusion(struct halftone_converter *cnv) __nonnull();
void move_in_next_line(struct halftone_converter *cnv, const struct caps_dot_grey raw[cnv->pixel_count]) __nonnull();
void move_in_empty_line(struct halftone_converter *cnv, conv_type val) __nonnull();
 
enum dk_caps {
    DK_CAP_UNKNOWN = 0,
    DK_CAP_CONTINUOUS = 1,
    DK_CAP_DIE_CUT = 2,
    DK_CAP_RED = 4, 
};
 
struct dk_roll_types {
    const char *dkname; 
    const char *like; 
    enum dk_caps caps;
    float margin; 
};
 
int ql_dk_information_get(struct dk_roll_types *medium, const char *name) __nonnull();
int ql_reset(struct ql_drv *t) __nonnull() __wur;
int ql_page_print(struct ql_drv *t) __nonnull() __wur;
int ql_last_page_print(struct ql_drv *t) __nonnull() __wur;
int ql_invalidate_and_initialize(struct ql_drv *t) __nonnull() __wur;
int ql_status_request(struct ql_drv *t, unsigned char buffer[32] __nonstring) __nonnull() __wur;
 
#define QL_MEDIA_TYPE_CONTINUOUS 0xa
#define QL_MEDIA_TYPE_DIE_CUT 0xb
#define QL_QUALITY_PRINT 0x40 /* never use while bi-colour printing (according to the datasheet) */
#define QL_FAST_PRINT 0x00 /* always use with bi-colour printing (according to the datasheet) */
 
struct ql_simple_command {
    uint8_t escape;
    uint8_t command;
    uint8_t option;
    uint8_t value;
} __packed;
#define QL_MAX_SELECTIONS 10
void ql_driver_halftone_selection_setup(struct ql_drv *t, struct caps_ppd_base *base) __nonnull();
void ql_driver_power_selection_setup(struct ql_drv *t, struct caps_ppd_base *base) __nonnull();
void ql_driver_bi_colour_medium_selection_setup(struct ql_drv *t, struct caps_ppd_base *base) __nonnull();
void ql_driver_base_setup(struct ql_drv *t) __nonnull();
int ql_numerical_setting_read(struct ql_drv *t, const char *section, const char *keyword) __nonnull();
int ql_job_header_generate(struct ql_drv *t) __nonnull();
int ql_driver_send(struct ql_drv *t, size_t count, const void *data, int flush) __nonnull() __wur;
int ql_driver_data_send(struct ql_drv *t, size_t count, const void *data, int flush) __nonnull() __wur;
void ql_driver_raster_crop(struct ql_drv *t) __nonnull();
#define QL_FIRST_PAGE 1
#define QL_NEXT_PAGE 0
 
int ql_page_header_generate(struct ql_drv *t, int first_page) __nonnull() __wur;
int ql_auto_powerdown(struct ql_drv *t, unsigned short time_out) __nonnull() __wur;
int ql_auto_powerup(struct ql_drv *t, unsigned short mode) __nonnull() __wur;
static inline void  __nonnull() transform_to_monochrome(size_t input_cnt, const conv_type input[__restrict input_cnt], unsigned char * __restrict data)
{
    unsigned char wire_data;
    size_t u, x;
 
    caps_assert((input_cnt % 8) == 0);
 
    for (x = 0, u = input_cnt; u >= 8; x++, u -= 8) {
        /* Convert 8 consecutive signed shorts into one byte */
        wire_data = 0;
        if (input[u - 1] == PRINT_DOT_VAL)
            wire_data |= BIT(7);
        if (input[u - 2] == PRINT_DOT_VAL)
            wire_data |= BIT(6);
        if (input[u - 3] == PRINT_DOT_VAL)
            wire_data |= BIT(5);
        if (input[u - 4] == PRINT_DOT_VAL)
            wire_data |= BIT(4);
        if (input[u - 5] == PRINT_DOT_VAL)
            wire_data |= BIT(3);
        if (input[u - 6] == PRINT_DOT_VAL)
            wire_data |= BIT(2);
        if (input[u - 7] == PRINT_DOT_VAL)
            wire_data |= BIT(1);
        if (input[u - 8] == PRINT_DOT_VAL)
            wire_data |= BIT(0);
        data[x] = wire_data;
    }
}
static inline unsigned pts_to_pixel(double pts, unsigned resolution)
{
    return (unsigned)(((pts * (double)resolution) / 72.0) + 0.5);
}
static inline unsigned mm_to_pixel(unsigned mm, unsigned resolution)
{
    return (unsigned)(mm * (double)resolution / 25.4);
}
static inline double pts_to_mm(double pts)
{
    return pts * 25.4 / 72.0;
}
static inline double mm_to_pts(double mm)
{
    return (mm * 72.0) / 25.4;
}
static inline double pixel_to_mm(unsigned pixel, unsigned resolution)
{
    return (pixel / (double)resolution) * 25.4;
}
enum ql_half_tone ql_driver_job_halftone_get(struct ql_drv *t) __nonnull();
void ql_driver_job_bi_colour_medium_get(struct ql_drv *t) __nonnull();
int ql_monochome_page_print(struct ql_drv *t) __nonnull();