← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/foo2zjs/gutsy-updates

« back to all changes in this revision

Viewing changes to foo2lava.c

  • Committer: Bazaar Package Importer
  • Author(s): Till Kamppeter
  • Date: 2007-06-25 17:25:17 UTC
  • mfrom: (1.1.8 upstream)
  • Revision ID: james.westby@ubuntu.com-20070625172517-hfgsrqo8mmvtylad
Tags: 20070625-0ubuntu1
* New upstream release
  - Added support for Samsung CLP-300, CLP-600, CLX-3160, Xerox Phaser
    6110, 6115MFP, Konica Minolta magicolor 2480, 2490, 2530.
  - Bug fixes.
  debian/patches/10-makefile.dpatch: Regenerated to adapt to new foo2zjs
  version.
* Do not fail if building of manual.pdf fails. This file is not important
  and should not hold back releases.

Show diffs side-by-side

added added

removed removed

Lines of Context:
foo2lava.c
6
6
 
7
7
With this utility, you can print to some HP and Minolta/QMS printers,
8
8
such as these:
 
9
    Model 0:
 
10
     - Konica Minolta magicolor 2490 MF         B/W and color
9
11
     - Konica Minolta magicolor 2530 DL         B/W and color
 
12
     - Xerox Phaser 6115MFP                     B/W and color
 
13
 
 
14
    Model 1:
 
15
     - Konica Minolta magicolor 2480 MF         B/W and color
10
16
 
11
17
AUTHORS
12
18
It also uses Markus Kuhn's jbig-kit compression library (included, but
43
49
 
44
50
*/
45
51
 
46
 
static char Version[] = "$Id: foo2lava.c,v 1.10 2006/12/24 06:22:52 rick Exp $";
 
52
static char Version[] = "$Id: foo2lava.c,v 1.24 2007/06/07 12:17:31 rick Exp $";
47
53
 
48
54
#include <stdio.h>
49
55
#include <stdlib.h>
65
71
int     ResY = 600;
66
72
int     Bpp = 1;
67
73
int     PaperCode = 1;
 
74
char    *PaperStr = "na_letter_8.5x11in";
68
75
int     PageWidth = 1200 * 8.5;
69
76
int     PageHeight = 600 * 11;
70
77
int     UpperLeftX = 0;
75
82
int     Duplex = 1;
76
83
int     SourceCode = 255;
77
84
int     MediaCode = 0;
 
85
char    *MediaStr = "plain";
78
86
char    *Username = NULL;
79
87
char    *Filename = NULL;
80
88
int     Mode = 0;
81
89
                #define MODE_MONO       1
82
90
                #define MODE_COLOR      2
83
91
int     Model = 0;
84
 
                #define MODEL_2300DL    0
85
 
                #define MODEL_HP1020    1
86
 
                #define MODEL_2530DL    2
87
 
                #define MODEL_LAST      2
 
92
                #define MODEL_2530DL    0
 
93
                #define MODEL_2480MF    1
 
94
                #define MODEL_LAST      1
88
95
 
89
96
int     Color2Mono = 0;
90
97
int     BlackClears = 0;
125
132
    /* L0 */
126
133
    128,
127
134
    /* MX */
128
 
    16,
 
135
    0,
129
136
    /* MY */
130
137
    0
131
138
};
193
200
"-P                Do not output START_PLANE codes.  May be needed by some\n"
194
201
"                  some black and white only printers.\n"
195
202
"-X padlen         Add extra zero padding to the end of BID segments [%d]\n"
196
 
"-z model          Model: 0=2300DL 1=hp1020 [%d]\n"
 
203
"-z model          Model: 0=2530DL (LAVAFLOW), 1=2480MF (OPL) [%d]\n"
197
204
"\n"
198
205
"Debugging Options:\n"
199
206
"-S plane          Output just a single color plane from a color print [all]\n"
394
401
    if (current->len != 20)
395
402
        error(1,"wrong BIH length\n"); 
396
403
 
 
404
    if (Model == MODEL_2480MF)
 
405
    {
 
406
        int w, h, x = 0;
 
407
 
 
408
        switch (planeNum)
 
409
        {
 
410
        case 3: x = 0x00FFFF; break;
 
411
        case 2: x = 0xFF00FF; break;
 
412
        case 1: x = 0xFFFF00; break;
 
413
        }
 
414
        fprintf(fp, "RasterObject.Planes=%06X,0,0,0,0,0,0;", x);
 
415
 
 
416
        /* startpage, jbig_bih, jbig_bid, jbig_end, endpage */
 
417
        w = (((long) current->data[ 4] << 24)
 
418
            | ((long) current->data[ 5] << 16)
 
419
            | ((long) current->data[ 6] <<  8)
 
420
            | (long) current->data[ 7]);
 
421
        h = (((long) current->data[ 8] << 24)
 
422
            | ((long) current->data[ 9] << 16)
 
423
            | ((long) current->data[10] <<  8)
 
424
            | (long) current->data[11]);
 
425
        fprintf(fp, "RasterObject.Width=%d;", w);
 
426
        fprintf(fp, "RasterObject.Height=%d;", h);
 
427
    }
 
428
 
397
429
    for (current = *root; current && current->len; current = current->next)
398
430
    {
399
431
        if (current == *root)
400
432
        {
401
 
            fprintf(fp, "\033*b20V");
402
 
            fwrite(current->data, 1, current->len, fp);
 
433
            switch (Model)
 
434
            {
 
435
            case MODEL_2530DL:
 
436
                fprintf(fp, "\033*b20V");
 
437
                fwrite(current->data, 1, current->len, fp);
 
438
                break;
 
439
            case MODEL_2480MF:
 
440
                fprintf(fp, "RasterObject.Data#%d=", (int) current->len);
 
441
                fwrite(current->data, 1, current->len, fp);
 
442
                fprintf(fp, ";");
 
443
                break;
 
444
            }
403
445
        }
404
446
        else
405
447
        {
 
448
            int i;
 
449
            int pad;
 
450
            #define PAD 32
 
451
 
406
452
            len = current->len;
407
453
            next = current->next;
408
 
            fprintf(fp, "\033*b%d%s", len, next ? "V" : "W");
409
 
            fwrite(current->data, 1, len, fp);
 
454
            if (!next || !next->len)
 
455
                pad = PAD * ((len+PAD-1)/PAD) - len;
 
456
            else
 
457
                pad = 0;
 
458
            switch (Model)
 
459
            {
 
460
            case MODEL_2530DL:
 
461
                fprintf(fp, "\033*b%d%s", len + pad, next ? "V" : "W");
 
462
                fwrite(current->data, 1, len, fp);
 
463
                for (i = 0; i < pad; i++)
 
464
                    putc(0, fp);
 
465
                break;
 
466
            case MODEL_2480MF:
 
467
                fprintf(fp, "RasterObject.Data#%d=", len + pad);
 
468
                fwrite(current->data, 1, len, fp);
 
469
                for (i = 0; i < pad; i++)
 
470
                    putc(0, fp);
 
471
                fprintf(fp, ";");
 
472
                break;
 
473
            }
410
474
        }
411
475
    }
412
476
 
413
477
    free_chain(*root);
414
478
 
415
 
    //chunk_write(ZJT_END_JBIG, 0, 0, fp);
416
 
    //if (planeNum)
417
 
        //chunk_write(ZJT_END_PLANE, 0, 0, fp);
418
479
    return 0;
419
480
}
420
481
 
423
484
{
424
485
    BIE_CHAIN           *current = *root;
425
486
    unsigned long       w, h;
 
487
    int                 i, np;
426
488
 
427
489
    /* error handling */
428
490
    if (!current)
443
505
            | (long) current->data[11]);
444
506
    TotalDots = w*h;
445
507
 
446
 
    fprintf(ofp, "\033&l%dO", 0);
447
 
    fprintf(ofp, "\033*r%dU", Mode == MODE_COLOR ? 1004 : 1);
448
 
    fprintf(ofp, "\033*g%dW", Mode == MODE_COLOR ? 26 : 8);
449
 
    fprintf(ofp, "\033*b%dM", 1234);
450
 
    fprintf(ofp, "\033&l%dA", PaperCode);
451
 
    fprintf(ofp, "\033&l%dH", SourceCode);
452
 
    fprintf(ofp, "\033&l%dM", MediaCode);
453
 
    fprintf(ofp, "\033&l%dE", 0);
454
 
    fprintf(ofp, "\033*r%dS", (int) w);
455
 
    fprintf(ofp, "\033*r%dT", (int) h);
456
 
    fprintf(ofp, "\033&l%dU", 0);
457
 
    fprintf(ofp, "\033&l%dZ", 0);
458
 
    fprintf(ofp, "\033*p%dX", 200);
459
 
    fprintf(ofp, "\033*p%dY", 200);
 
508
    switch (Model)
 
509
    {
 
510
    case MODEL_2530DL:
 
511
        fprintf(ofp, "\033&l%dO", 0);
 
512
        fprintf(ofp, "\033*r%dU", Mode == MODE_COLOR ? -1004 : 1);
 
513
        fprintf(ofp, "\033*g%dW", Mode == MODE_COLOR ? 26 : 8);
 
514
        putc(2, ofp);
 
515
        putc(nbie, ofp);
 
516
        np = Mode == MODE_COLOR ? 4 : 1;
 
517
        for (i = 0; i < np; ++i)
 
518
        {
 
519
            putc(ResX>>8, ofp);
 
520
            putc(ResX, ofp);
 
521
            putc(ResY>>8, ofp);
 
522
            putc(ResY, ofp);
 
523
            putc(0, ofp);
 
524
            //putc(Mode == MODE_COLOR ? 2 : 0, ofp);    // Number of bpc
 
525
            putc(2, ofp);
 
526
        }
 
527
        fprintf(ofp, "\033*b%dM", 1234);
 
528
        fprintf(ofp, "\033&l%dA", PaperCode);
 
529
        if (PaperCode == 101)
 
530
        {
 
531
            fprintf(ofp, "\033&f%dG", PageHeight * 720 / ResY); // Custom Y
 
532
            fprintf(ofp, "\033&f%dF", PageWidth * 720 / ResX);  // Custom X
 
533
        }
 
534
        fprintf(ofp, "\033&l%dH", SourceCode);
 
535
        fprintf(ofp, "\033&l%dM", MediaCode);
 
536
        fprintf(ofp, "\033&l%dE", 0);
 
537
        fprintf(ofp, "\033*r%dS", (int) w);
 
538
        fprintf(ofp, "\033*r%dT", (int) h);
 
539
        fprintf(ofp, "\033&l%dU", 0);
 
540
        fprintf(ofp, "\033&l%dZ", 0);
 
541
        fprintf(ofp, "\033*p%dX", ResX / 6);
 
542
        fprintf(ofp, "\033*p%dY", ResX / 6);
460
543
 
461
 
    fprintf(ofp, "\033*r1A");
 
544
        fprintf(ofp, "\033*r1A");
 
545
        break;
 
546
    case MODEL_2480MF:
 
547
        fprintf(ofp, "MediaSize=%s;", PaperStr);
 
548
        fprintf(ofp, "MediaType=%s;", MediaStr);
 
549
        fprintf(ofp, "MediaInputTrayCheck=top;");
 
550
        fprintf(ofp, "RasterObject.BitsPerPixel=1;");
 
551
        break;
 
552
    }
462
553
 
463
554
    if ((PageNum & 1) == 0 && EvenPages)
464
555
        SeekMedia = ftell(EvenPages) - 4;
467
558
void
468
559
end_page(FILE *ofp)
469
560
{
470
 
    if (Mode == MODE_COLOR)
 
561
    switch (Model)
471
562
    {
472
 
        fprintf(ofp, "\033*x%dY", Dots[0]);
473
 
        fprintf(ofp, "\033*x%dU", TotalDots - Dots[0]);
474
 
        fprintf(ofp, "\033*x%dM", Dots[1]);
475
 
        fprintf(ofp, "\033*x%dV", TotalDots - Dots[1]);
476
 
        fprintf(ofp, "\033*x%dC", Dots[2]);
477
 
        fprintf(ofp, "\033*x%dZ", TotalDots - Dots[2]);
 
563
    case MODEL_2530DL:
 
564
        if (Mode == MODE_COLOR)
 
565
        {
 
566
            fprintf(ofp, "\033*x%dY", Dots[0]);
 
567
            fprintf(ofp, "\033*x%dU", TotalDots - Dots[0]);
 
568
            fprintf(ofp, "\033*x%dM", Dots[1]);
 
569
            fprintf(ofp, "\033*x%dV", TotalDots - Dots[1]);
 
570
            fprintf(ofp, "\033*x%dC", Dots[2]);
 
571
            fprintf(ofp, "\033*x%dZ", TotalDots - Dots[2]);
 
572
        }
 
573
        fprintf(ofp, "\033*x%dK", Dots[3]);
 
574
        fprintf(ofp, "\033*x%dW", TotalDots - Dots[3]);
 
575
 
 
576
        fprintf(ofp, "\033*rC");
 
577
        if (0)
 
578
            fprintf(ofp, "\f");         // Eject page
 
579
        else
 
580
            fprintf(ofp, "\033&l0H");   // Eject page
 
581
        break;
 
582
    case MODEL_2480MF:
 
583
        fprintf(ofp, "Event=EndOfPage;");
 
584
        break;
478
585
    }
479
 
    fprintf(ofp, "\033*x%dK", Dots[3]);
480
 
    fprintf(ofp, "\033*x%dW", TotalDots - Dots[3]);
481
 
 
482
 
    fprintf(ofp, "\033*r0C");
483
586
}
484
587
 
485
588
int
519
622
    BIE_CHAIN   *current, **root = (BIE_CHAIN **) cbarg;
520
623
    int         size = 65536;   // Printer does strange things otherwise.
521
624
 
 
625
    if (Model == MODEL_2480MF)
 
626
        size = 32768;
 
627
 
522
628
    if ( (*root) == NULL)
523
629
    {
524
630
        (*root) = malloc(sizeof(BIE_CHAIN));
575
681
    time_t      now;
576
682
    struct tm   *tmp;
577
683
 
578
 
    now = time(NULL);
579
 
    tmp = localtime(&now);
580
 
    strftime(buf, sizeof(buf), "%m/%d/%Y", tmp);
581
 
 
582
 
    fprintf(fp, "\033%%-12345X@PJL JOB NAME=\"%s\"\n",
583
 
        Filename ? Filename : "stdin");
584
 
    fprintf(fp, "\033%%-12345X@PJL JOB USERNAME=\"%s\"\n",
585
 
        Username ? Username : "");
586
 
    fprintf(fp, "\033%%-12345X@PJL JOB TIMESTAMP=\"%s\"\n", buf);
587
 
    #ifdef linux
 
684
    switch (Model)
588
685
    {
589
 
        struct utsname u;
590
 
 
591
 
        u.release[0] = 0;
592
 
        uname(&u);
593
 
 
594
 
        fprintf(fp, "\033%%-12345X@PJL JOB OSINFO=\"Linux/%s\"\n", u.release);
 
686
    case MODEL_2530DL:
 
687
        now = time(NULL);
 
688
        tmp = localtime(&now);
 
689
        strftime(buf, sizeof(buf), "%m/%d/%Y", tmp);
 
690
 
 
691
        fprintf(fp, "\033%%-12345X@PJL JOB NAME=\"%s\"\n",
 
692
            Filename ? Filename : "stdin");
 
693
        fprintf(fp, "\033%%-12345X@PJL JOB USERNAME=\"%s\"\n",
 
694
            Username ? Username : "");
 
695
        fprintf(fp, "\033%%-12345X@PJL JOB TIMESTAMP=\"%s\"\n", buf);
 
696
        #ifdef linux
 
697
        {
 
698
            struct utsname u;
 
699
 
 
700
            u.release[0] = 0;
 
701
            uname(&u);
 
702
 
 
703
            fprintf(fp, "\033%%-12345X@PJL JOB OSINFO=\"Linux/%s\"\n",
 
704
                    u.release);
 
705
        }
 
706
        #else
 
707
            fprintf(fp, "\033%%-12345X@PJL JOB OSINFO=\"%s\"\n", "Unknown");
 
708
        #endif
 
709
        fprintf(fp, "\033%%-12345X@PJL ENTER LANGUAGE=LAVAFLOW\n");
 
710
        fprintf(fp, "\033E");
 
711
        fprintf(fp, "\033&l%dS", Duplex-1);
 
712
        fprintf(fp, "\033&l%dG", 0);
 
713
        fprintf(fp, "\033&u%dD", ResX);
 
714
        fprintf(fp, "\033&l%dX", 1);
 
715
        fprintf(fp, "\033&x%dX", 1);
 
716
        break;
 
717
    case MODEL_2480MF:
 
718
        fprintf(fp, "Event=StartOfJob;");
 
719
        fprintf(fp, "OSVersion=Linux;");
 
720
        fprintf(fp, "DrvVersion=2.0.1410.0;");
 
721
        fprintf(fp, "Resolution=%dx%d;", ResX, ResY);
 
722
        fprintf(fp, "RasterObject.Compression=JBIG;");
 
723
        fprintf(fp, "Sides=%sSided;", (Duplex-1) ? "Two" : "One");
 
724
        break;
595
725
    }
596
 
    #else
597
 
        fprintf(fp, "\033%%-12345X@PJL JOB OSINFO=\"%s\"\n", "Unknown");
598
 
    #endif
599
 
    fprintf(fp, "\033%%-12345X@PJL ENTER LANGUAGE=LAVAFLOW\n");
600
 
    fprintf(fp, "\033E");
601
 
    fprintf(fp, "\033&l%dS", Duplex-1);
602
 
    fprintf(fp, "\033&l%dG", 0);
603
 
    fprintf(fp, "\033&u%dD", ResX);
604
 
    fprintf(fp, "\033&l%dX", 1);
605
 
    fprintf(fp, "\033&x%dX", 1);
606
726
}
607
727
 
608
728
void
609
729
end_doc(FILE *fp)
610
730
{
611
 
    fprintf(fp, "\033E");
612
 
    fprintf(fp, "\033%%-12345X");
 
731
    switch (Model)
 
732
    {
 
733
    case MODEL_2530DL:
 
734
        fprintf(fp, "\033E");
 
735
        fprintf(fp, "\033%%-12345X");
 
736
        break;
 
737
    case MODEL_2480MF:
 
738
        fprintf(fp, "Event=EndOfJob;");
 
739
        break;
 
740
    }
613
741
}
614
742
 
615
743
void
820
948
    int bpl, bpl16;
821
949
 
822
950
    RealWidth = w;
823
 
    if (Model == MODEL_HP1020)
824
 
        w = (w + 127) & ~127;
 
951
    //if (Model == MODEL_HP1020)
 
952
        //w = (w + 127) & ~127;
825
953
 
826
954
    Dots[3] = 0;
827
955
    bpl = (w + 7) / 8;
828
 
    if (Model == MODEL_2300DL)
 
956
    //if (Model == MODEL_2300DL)
829
957
        bpl16 = bpl;
830
 
    else
831
 
        bpl16 = (bpl + 15) & ~15;
 
958
    //else
 
959
        //bpl16 = (bpl + 15) & ~15;
832
960
 
833
961
    if (SaveToner)
834
962
    {
1219
1347
        bpl = (w + 7) / 8;
1220
1348
        rightBpl = (rawW - UpperLeftX + 7) / 8;
1221
1349
 
1222
 
        switch (Model)
1223
 
        {
1224
 
        case MODEL_2300DL:      bpl16 = bpl; break;
1225
 
        case MODEL_HP1020:      bpl16 = (bpl + 15) & ~15; break;
1226
 
        default:                error(1, "Bad model %d\n", Model); break;
1227
 
        }
 
1350
        //switch (Model)
 
1351
        //{
 
1352
        //case MODEL_2300DL:    bpl16 = bpl; break;
 
1353
        //case MODEL_HP1020:    bpl16 = (bpl + 15) & ~15; break;
 
1354
        //default:              error(1, "Bad model %d\n", Model); break;
 
1355
        //}
 
1356
        bpl16 = bpl;
1228
1357
 
1229
1358
        buf = malloc(bpl16 * h);
1230
1359
        if (!buf)
1266
1395
    w = PageWidth - UpperLeftX - LowerRightX;
1267
1396
    h = PageHeight - UpperLeftY - LowerRightY;
1268
1397
    bpl = (w + 7) / 8;
1269
 
    switch (Model)
1270
 
    {
1271
 
    case MODEL_2300DL:  bpl16 = bpl; break;
1272
 
    case MODEL_HP1020:  bpl16 = (bpl + 15) & ~15; break;
1273
 
    default:            error(1, "Bad model %d\n", Model); break;
1274
 
    }
 
1398
    bpl16 = bpl;
 
1399
    //switch (Model)
 
1400
    //{
 
1401
    //case MODEL_2300DL:        bpl16 = bpl; break;
 
1402
    //case MODEL_HP1020:        bpl16 = (bpl + 15) & ~15; break;
 
1403
    //default:          error(1, "Bad model %d\n", Model); break;
 
1404
    //}
1275
1405
 
1276
1406
    plane = malloc(bpl16 * h);
1277
1407
    if (!plane)
1360
1490
                        if (PageHeight < 0 || PageHeight > 1000000)
1361
1491
                            error(1, "Illegal Y value '%s' for -g\n", optarg);
1362
1492
                        break;
1363
 
        case 'm':       MediaCode = atoi(optarg); break;
 
1493
        case 'm':       if (isalpha(optarg[0]))
 
1494
                            MediaStr = optarg;
 
1495
                        else
 
1496
                            MediaCode = atoi(optarg);
 
1497
                        break;
1364
1498
        case 'n':       Copies = atoi(optarg); break;
1365
 
        case 'p':       PaperCode = atoi(optarg); break;
 
1499
        case 'p':       if (strstr(optarg,"in") || strstr(optarg, "mm"))
 
1500
                            PaperStr = optarg;
 
1501
                        else
 
1502
                            PaperCode = atoi(optarg);
 
1503
                        break;
1366
1504
        case 'r':       if (parse_xy(optarg, &ResX, &ResY))
1367
1505
                            error(1, "Illegal format '%s' for -r\n", optarg);
1368
1506
                        break;
1411
1549
    argc -= optind;
1412
1550
    argv += optind;
1413
1551
 
1414
 
    if (Model == MODEL_HP1020)
 
1552
    if (0)//Model == MODEL_HP1020)
1415
1553
    {
1416
1554
        Bpp = ResX / 600;
1417
1555
        ResX = 600;
1471
1609
        /*
1472
1610
         *  Manual Pause
1473
1611
         */
1474
 
        if (Model == MODEL_HP1020)
 
1612
        if (0)//Model == MODEL_HP1020)
1475
1613
            load_tray2(stdout);
1476
1614
 
1477
1615
        fseek(EvenPages, SeekMedia, 0L);