root/platform/cups/rpdl/trunk/rastertorpdl.c @ 36567

/*
   This software is distributed in the hope that it will be useful, but
   WITHOUT ANY WARRANTY.  No author or distributor accepts responsibility
   to anyone for the consequences of using it or for whether it serves any
   particular purpose or works at all, unless he says so in writing.  Refer
   to the GNU General Public License for full details.

   Everyone is granted permission to copy, modify and redistribute
   this software, but only under the conditions described in the GNU
   General Public License.  A copy of this license is supposed to have been
   given to you along with this software so you can know your rights and
   responsibilities.  It should be in a file named COPYING.  Among other
   things, the copyright notice and this notice must be preserved on all
   copies.
 */
/* 
   ESC sequences in RPDL are copied from Ricoh RPDL driver for Ghostscript.
   That implementation was released under GPL, and covered with
   copyright (C) 1999, 2000 Norihito Ohmori.
 */
#include <cups/cups.h>
#include <cups/i18n.h>
#include <cups/raster.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <signal.h>
#include <errno.h>

int g_canceled = 0;

static void
cancel_job(int sig)
{
    g_canceled = 1;
}

static void
rpdl_init(FILE *out, ppd_file_t *ppd)
{
    fputs(
        "\033\022!@R00\033 "        /* enter RPDL mode */
        "\0334"                     /* leave graphic mode */
        "\033\032I"                 /* printer reset */
        "\033\022YP,2 "             /* select RPDL mode */
        , out);
}

static int
rpdl_set_custom_paper_size(FILE *out, int width, int height /* in pt */)
{
    int w, h;

    if (width < height) {
        w = width;
        h = height;
    }
    else {
        w = height;
        h = width;
    }

    fprintf(out, "\033\022?5%d,%d\033 ",
            (int) (w * 25.4 / 72.0),
            (int) (h * 25.4 / 72.0));

    return 1;
}

struct paper_name_map_t {
    const char *name;
    const char *code[2];
};

static int
rpdl_set_paper_size_by_name(FILE *out, const char *name)
{
    struct paper_name_map_t *pmap;
    static struct paper_name_map_t paper_name_map[] = {
        { "A1", { "A1R", "A1" } },
        { "A2", { "A2R", "A2" } },
        { "A3", { "A3R", "A3" } },
        { "A4", { "A4R", "A4" } },
        { "A5", { "A5R", "A5" } },
        { "A6", { "A6R", "A6" } },

        { "B4", { "B4R", "B4" } },
        { "B5", { "B5R", "B5" } },
        { "B6", { "B6R", "B6" } },

        { "Letter",    { "LTR", "LT" } },    /* Letter */
        { "Legal",     { "LGR", "LG" } },    /* Legal */
        { "Statement", { "HLR", "HLT" } },   /* Half Letter / Statement */
        { "Ledger",    { "DLR", "DLT" } },   /* Ledger / Double Letter */

        { NULL, { NULL, NULL } },
    };

    for (pmap = paper_name_map; pmap->name; pmap ++) {
        if (! strcasecmp(pmap->name, name)) {
            int i;

            for (i = 0; i < 2; i ++) {
                if (pmap->code[i])
                    fprintf(out, "\033\02251@%s\033 ", pmap->code[i]);
            }

            return 1;
        }
    }

    return 0;
}

struct paper_size_map_t {
    short int width;
    short int height;
    const char *name;
};

static int
rpdl_set_paper_size_by_size(FILE *out, int width, int height /* in pt */)
{
    int w, h;
    struct paper_size_map_t *pmap;
    static struct paper_size_map_t paper_size_map[] = {
        { 1684, 2384, "A1" },
        { 1191, 1684, "A2" },
        {  842, 1191, "A3" },
        {  595,  842, "A4" },
        {  420,  595, "A5" },
        {  297,  420, "A6" },

        {  729, 1032, "B4" },
        {  516,  729, "B5" },
        {  363,  516, "B6" },

        {  612,  792, "Letter"    },
        {  612, 1008, "Legal"     },
        {  396,  612, "Statement" },
        {  792, 1224, "Ledger"    },

        { -1, -1, NULL },
    };

    if (width < height) {
        w = width;
        h = height;
    }
    else {
        w = height;
        h = width;
    }

    for (pmap = paper_size_map; pmap->width > 0; pmap ++) {
        if (w == pmap->width && h == pmap->height) {
            return rpdl_set_paper_size_by_name(out, pmap->name);
        }
    }

    return 0;
}

static int
rpdl_set_paper_size(FILE *out, ppd_file_t *ppd, cups_page_header2_t *header)
{
    int r;

    r = 0;
    if (*(header->cupsPageSizeName)) {
        r = rpdl_set_paper_size_by_name(out, header->cupsPageSizeName);
        if (r)
            return r;
    }

    r = rpdl_set_paper_size_by_size(out, header->PageSize[0],
                                          header->PageSize[1]);
    if (r)
        return r;

    return rpdl_set_custom_paper_size(out, header->PageSize[0],
                                           header->PageSize[1]);
}

static void
rpdl_set_paper_type(FILE *out, int paper_type)
{
    fprintf(out, "\033\022?6T,%d\033 ", paper_type);
}

static int
rpdl_set_tray(FILE *out, ppd_file_t *ppd, cups_page_header2_t *header)
{
    switch (header->MediaPosition) {
    case 0:     /* auto */
        fputs("\033\022Z2 ", out);
        break;
    case 1:     /* manual tray */
        fputs("\033\022Z1 "
              "\033\031M", out);
        break;
    default:    /* tray N */
        fputs("\033\022Z1 ", out);
        fprintf(out, "\033\031%d", header->MediaPosition);
    }

    return 0;
}

static int
rpdl_set_paper_tray(FILE *out, ppd_file_t *ppd, cups_page_header2_t *header)
{
    int r;

    switch (header->MediaPosition) {
    case 0:     /* auto */
        /* paper type can not be specified */
        break;
    case 1:     /* manual tray */
        rpdl_set_paper_type(out, 0);
        break;
    default:    /* tray N */
        /* always 15 */
        rpdl_set_paper_type(out, 15);
    }

    r = rpdl_set_tray(out, ppd, header);

    if (header->MediaPosition == 0 /* auto */) {
        r = rpdl_set_paper_size(out, ppd, header);
    }

    return 0;
}

static int
rpdl_setup_page(FILE *out, ppd_file_t *ppd, cups_page_header2_t *header)
{
    if (header->cupsBitsPerColor != 1) {
        fputs("ERROR: BPC is not 1!\n", stderr);
        return -1;
    }

    if (header->cupsColorSpace != CUPS_CSPACE_K) {
        fputs("ERROR: Color Space is not K!\n", stderr);
        return -1;
    }

    if (header->Duplex) {
        fputs("\033\022YA06,2 ", out);      /* duplex: on */

        if (header->Tumble) {
            fputs("\033\022YA03,1 ", out);  /* top binding */
        }
        else {
            fputs("\033\022YA03,2 ", out);  /* left binding */
        }
            /* right binding is 3 */
    }
    else {
        fputs("\033\022YA06,1 ", out);      /* duplex: off */
    }

    switch (header->HWResolution[0] /* dpi */) {
    case 1200:
        fputs(
            "\033\022YA04,4 "               /* engine           */
            "\033\022YW,4 "                 /* graphics unit    */
            "\033\022YI,9 "                 /* unknown unit     */
            "\033\022#5 "                   /* cartecian unit   */
            "\033\022Q6 "                   /* spacing unit     */
            , out);
        break;
    case 600:
        fputs(
            "\033\022YA04,3 "               /* engine           */
            "\033\022YW,3 "                 /* graphics unit    */
            "\033\022YI,8 "                 /* unknown unit     */
            "\033\022#4 "                   /* cartecian unit   */
            "\033\022Q5 "                   /* spacing unit     */
            , out);
        break;
    case 400:
    default:
        fputs(
            "\033\022YA04,1 "               /* engine           */
            "\033\022YW,1 "                 /* graphics unit    */
            "\033\022YI,7 "                 /* unknown unit     */
            "\033\022#2 "                   /* cartecian unit   */
            "\033\022Q4 "                   /* spacing unit     */
            , out);
    }

    switch (header->cupsInteger[1]) {
    case 2:
        fputs("\033\022YA02,1 ", out);      /* strong toner save */
        break;
    case 1:
        fputs("\033\022YA02,3 ", out);      /* light toner save */
        break;
    default:
        if (header->cupsInteger[0]) {
            fputs("\033\022YA02,2 ", out);  /* smoothing on */
        }
        else {
            fputs("\033\022YA02,4 ", out);  /* smoothing off */
        }
    }

    fputs(
        "\033\022YQ,2 "                     /* page length - maximum */
        "\033\022YB,2 "                     /* printable area - maximum */
        "\033\022YK,1 "                     /* left margin - 0 mm */
        "\033\022YL,1 "                     /* top margin  - 0 mm */
        "\033\022YM,1 "                     /* zoom - 100% */
        , out);        

    rpdl_set_paper_tray(out, ppd, header);

    if (header->PageSize[0] > header->PageSize[1]) {
        fputs("\033\022D2 ", out);          /* landscape */
    }
    else {
        fputs("\033\022D1 ", out);          /* portrait */
    }

    /* number of copies */
    fprintf(out, "\033\022N%d ", header->NumCopies);

    return 0;
}

static int
rpdl_finish(FILE *out, ppd_file_t *ppd, cups_page_header2_t *header)
{
    if (header->Duplex) {
        if (header->Tumble) {   /* in case of top binding */
            fputs("\033\022YA03,2 ", out);  /* reset to left binding */
        }

        fputs("\033\022YA06,1 ", out);      /* duplex: off */
    }

    if (header->MediaPosition != 0 /* auto */) {
        fputs("\033\022Z2 ", out);          /* tray auto */
        rpdl_set_paper_size_by_name(out, "A4");
    }

    return 0;
}

static int
runlength_line2(const unsigned char *source, int cb_source,
                unsigned char *buffer, size_t cb_buffer)
{
    const unsigned char *ps, *es;
    unsigned char *pb, *eb;
    int c = -1;

    ps = source;
    es = source + cb_source;
    pb = buffer;
    eb = buffer + cb_buffer;
    while (ps < es) {
        unsigned char nc;
        int run;

        if (pb >= eb)
            return -1;

        nc = *pb ++ = *ps ++;

        if (nc != c) {
            c = nc;
            continue;
        }

        /* begin run */
        run = 0;
        while (ps < es && run < 255) {
            if (*ps != c)
                break;

            ps ++;
            run ++;
        }

        if (pb >= eb)
            return -1;

        *pb ++ = run;
        c = -1;
    }

    return pb - buffer;
}

static void
trim_line(const unsigned char *source, int cb_source,
          int *offset, int *length)
{
    const unsigned char *sp, *ep;

    ep = source + cb_source;
    for (sp = source; sp < ep; sp ++)
        if (*sp != 0)
            break;

    for (           ; ep > sp; ep --)
        if (*(ep - 1) != 0)
            break;

    *offset = sp - source;
    *length = ep - sp;
}

static int
rpdl_render_line(FILE *out, const unsigned char *line_buf, int cb_line,
                 int x, int y, int use_compression, int use_trim,
                 unsigned char *comp_buf, int cb_cbuf)
{
    int cb_cdat;
    int of_trim, cb_trim;

    if (use_trim) {
        trim_line(line_buf, cb_line, &of_trim, &cb_trim);
    }
    else {
        cb_trim = cb_line;
        of_trim = 0;
    }

    if (cb_trim == 0)
        return 0;

    if (use_compression) {
        cb_cdat = runlength_line2(line_buf + of_trim, cb_trim, comp_buf,
                                  cb_cbuf);
        if (cb_cdat < 0)
            return -1;

        if (cb_cdat == 0)
            return 0;
    }

    if (! use_compression || cb_cdat >= cb_trim) {
        /* non-effective compression => raw */
        fprintf(out, "\033\022G3,%d,%d,,,%d,%d@",
                cb_trim * 8, 1, (x + of_trim * 8) * 1, y * 1);

        fwrite(line_buf + of_trim, 1, cb_trim, out);
    }
    else {
        /* effective compression */
        fprintf(out, "\033\022G3,%d,%d,,4,%d,%d,%d@",
                cb_trim * 8, 1, (x + of_trim * 8) * 1, y * 1,
                cb_cdat);

        fwrite(comp_buf, 1, cb_cdat, out);
    }

    return 1;
}

#if 0   /* example */
static int
rpdl_render_image(FILE *out, const unsigned char *ptr, int width, int height,
                  int ox, int oy, int use_compression, int use_trim)
{
    int cb_line, cb_cbuf;
    unsigned char *comp_buf;
    int y;

    cb_line = (width + 7) / 8;

    cb_cbuf = (cb_line * 3 + 1) / 2;
    comp_buf = malloc(cb_cbuf);
    if (! comp_buf)
        return -1;

    for (y = 0; y < height; y ++) {
        int r;

        r = rpdl_render_line(out, ptr, cb_line, ox, oy + y, use_compression,
                             use_trim, comp_buf, cb_cbuf);

        if (r < 0) {
            fputs("ERROR: buffer is small.\n", stderr);
            return -1;
        }

        ptr += cb_line;
    }

    free(comp_buf);

    return 0;
}
#endif

int
main(int argc, char *argv[])
{
    int num_options;
    cups_option_t *options;
    FILE *out;
    int fd;
    cups_raster_t *ras;
    ppd_file_t *ppd;
    cups_page_header2_t header;
    int page, y;
    int inited;
#if ! defined(HAVE_SIGSET) && defined(HAVE_SIGACTION)
    struct sigaction action;
#endif

    setbuf(stderr, NULL);

    if (argc < 6 || argc > 7) {
        _cupsLangPrintf(stderr,
                        _("Usage: %s job-id user title copies options\n"),
                        argv[0]);

        return 1;
    }

    num_options = cupsParseOptions(argv[5], 0, &options);

    ppd = ppdOpenFile(getenv("PPD"));

    if (! ppd) {
        _cupsLangPuts(stderr, _("ERROR: Unable to open PPD file!\n"));
        return 1;
    }

    ppdMarkDefaults(ppd);
    cupsMarkOptions(ppd, num_options, options);

    if (argc >= 7) {
        fd = open(argv[6], O_RDONLY);
        if (fd < 0) {
            _cupsLangPrintf(stderr,
                            _("ERROR: Unable to open raster file - %s\n"),
                            strerror(errno));

            return 1;
        }
    }
    else
        fd = 0;

    ras = cupsRasterOpen(fd, CUPS_RASTER_READ);

    out = stdout;

    g_canceled = 0;

#if defined(HAVE_SIGSET)
    sigset(SIGTERM, cancel_job);
#elif defined(HAVE_SIGACTION)
    memset(&action, 0, sizeof(action));
    sigemptyset(&action.sa_mask);
    action.sa_handler = cancel_job;
    sigaction(SIGTERM, &action, NULL);
#else
    signal(SIGTERM, cancel_job);
#endif

    rpdl_init(out, ppd);

    inited = 0;
    page   = 0;
    while (cupsRasterReadHeader2(ras, &header)) {
        unsigned char *plane;
        unsigned char *comp_buf;
        int cb_cbuf;

        if (g_canceled) break;

        page ++;
        fprintf(stderr, "PAGE: %d %d\n", page, header.NumCopies);
        _cupsLangPrintf(stderr, _("INFO: Starting page %d...\n"), page);

        if (! inited) {
            rpdl_setup_page(out, ppd, &header);

            inited = 1;
        }

        plane = malloc(header.cupsBytesPerLine);
        if (! plane) {
            g_canceled = 1;
            break;
        }

        cb_cbuf = (header.cupsBytesPerLine * 3 + 1) / 2;
        comp_buf = malloc(cb_cbuf);
        if (! comp_buf) {
            if (plane)
                free(plane);

            g_canceled = 1;
            break;
        }

        for (y = 0; y < header.cupsHeight; y ++) {
            if (g_canceled) break;

            if (cupsRasterReadPixels(ras, plane,
                                     header.cupsBytesPerLine) < 1) {
                break;
            }

            rpdl_render_line(out, plane, header.cupsBytesPerLine, 0, y,
                             1, 1, comp_buf, cb_cbuf);
        }

        if (comp_buf)
            free(comp_buf);

        if (plane)
            free(plane);

        _cupsLangPrintf(stderr, _("INFO: Finished page %d...\n"), page);

        fputs("\014", out);     /* Form Feed */
    }

    if (! g_canceled && header.Duplex && page % 2 == 1) {
        fputs("\014", out);     /* Form Feed */
    }

    if (inited)
        rpdl_finish(out, ppd, &header);

    if (ppd)
        ppdClose(ppd);

    cupsRasterClose(ras);

    if (fd)
        close(fd);

    if (out != stdout)
        fclose(out);

    cupsFreeOptions(num_options, options);

    if (page == 0) {
        _cupsLangPuts(stderr, _("ERROR: No pages found!\n"));

        return 1;
    }
    else {
        _cupsLangPuts(stderr, _("INFO: Ready to print.\n"));

        return 0;
    }
}

/* vi: set expandtab ts=4 sw=4 sts=0 : */