sys/src/cmd/jpg/writetif.c

   1 /*
   2 * code/documentation:
   3 * http://partners.adobe.com/public/developer/en/tiff/TIFF6.pdf
   4 * http://paulbourke.net/dataformats/tiff/
   5 * http://www.fileformat.info/format/tiff/egff.htm
   6 * http://www.fileformat.info/mirror/egff/ch09_05.htm
   7 * http://www.itu.int/rec/T-REC-T.4-199904-S/en
   8 * http://www.itu.int/rec/T-REC-T.6-198811-I/en
   9 *
  10 * copy-pasted fax codes and copy-pasted lzw encoding
  11 * hash table implementation:
  12 * http://www.remotesensing.org/libtiff/
  13 */
  14 #include <u.h>
  15 #include <libc.h>
  16 #include <bio.h>
  17 #include <draw.h>
  18 #include <memdraw.h>
  19 #include "imagefile.h"
  20
  21 enum {
  22         Tbyte = 0x0001,
  23         Tascii = 0x0002,
  24         Tshort = 0x0003,
  25         Tlong = 0x0004,
  26         Trational = 0x0005,
  27         Tnocomp = 0x0001,
  28         Thuffman = 0x0002,
  29         Tt4enc = 0x0003,
  30         Tt6enc = 0x0004,
  31         Tlzw = 0x0005,
  32         Tpackbits = 0x8005
  33 };
  34
  35 enum {
  36         Twidth,
  37         Tlength,
  38         Tbits,
  39         Tcomp,
  40         Tphoto,
  41         Tfill,
  42         Tdesc,
  43         Tstrips,
  44         Tsamples,
  45         Trows,
  46         Tcounts,
  47         Txres,
  48         Tyres,
  49         T4opt,
  50         Tresunit,
  51         Tpredictor,
  52         Tcolor
  53 };
  54
  55 enum {
  56         Kpar = 2,
  57         Nfaxtab = 105
  58 };
  59
  60 enum {
  61         Clrcode = 256,
  62         Eoicode = 257,
  63         Tabsz = 1<<12,
  64         Hshift = 13 - 8,
  65         Hsize = 9001L
  66 };
  67
  68 typedef struct Tab Tab;
  69 typedef struct Fax Fax;
  70 typedef struct Hash Hash;
  71 typedef struct Lzw Lzw;
  72 typedef struct Pkb Pkb;
  73 typedef struct Fld Fld;
  74 typedef struct Tif Tif;
  75
  76 struct Tab {
  77         int len;
  78         int code;
  79         int run;
  80 };
  81
  82 struct Fax {
  83         int st;
  84         Tab *tab[2];
  85         int byte;
  86         int nbyte;
  87         ulong *l1;
  88         ulong *l2;
  89         uchar *data;
  90         ulong ndata;
  91         ulong n;
  92 };
  93
  94 struct Hash {
  95         long hash;
  96         u16int code;
  97 };
  98
  99 struct Lzw {
 100         Hash hash[Hsize];
 101         int ntab;
 102         int len;
 103         int byte;
 104         int nbyte;
 105         uchar *data;
 106         ulong ndata;
 107         ulong n;
 108 };
 109
 110 struct Pkb {
 111         uchar *data;
 112         ulong ndata;
 113         ulong n;
 114 };
 115
 116 struct Fld {
 117         ushort tag;
 118         ushort typ;
 119 };
 120
 121 struct Tif {
 122         ulong dx;
 123         ulong dy;
 124         ushort depth[3];
 125         ushort comp;
 126         ulong opt;
 127         char *(*compress)(Tif *);
 128         ushort photo;
 129         char *desc;
 130         ulong *strips;
 131         ulong nstrips;
 132         ushort samples;
 133         ulong rows;
 134         ulong *counts;
 135         ushort *color;
 136         ulong ncolor;
 137         uchar *data;
 138         ulong ndata;
 139         ushort nfld;
 140         int bpl;
 141 };
 142
 143 static Fld flds[] = {
 144         [Twidth] {0x0100, Tlong},
 145         [Tlength] {0x0101, Tlong},
 146         [Tbits] {0x0102, Tshort},
 147         [Tcomp] {0x0103, Tshort},
 148         [Tphoto] {0x0106, Tshort},
 149         [Tfill] {0x010a, Tshort},
 150         [Tdesc] {0x010e, Tascii},
 151         [Tstrips] {0x0111, Tlong},
 152         [Tsamples] {0x0115, Tshort},
 153         [Trows] {0x0116, Tlong},
 154         [Tcounts] {0x0117, Tlong},
 155         [Txres] {0x011a, Trational},
 156         [Tyres] {0x011b, Trational},
 157         [T4opt] {0x0124, Tlong},
 158         [Tresunit] {0x0128, Tshort},
 159         [Tpredictor] {0x013d, Tshort},
 160         [Tcolor] {0x0140, Tshort}
 161 };
 162
 163 /*
 164 * imported from libdraw/arith.c to permit
 165 * extern log2 function
 166 */
 167 static int log2[] = {
 168         -1, 0, 1, -1, 2, -1, -1, -1, 3,
 169         -1, -1, -1, -1, -1, -1, -1, 4,
 170         -1, -1, -1, -1, -1, -1, -1, 4 /* BUG */,
 171         -1, -1, -1, -1, -1, -1, -1, 5
 172 };
 173
 174 static Tab faxwhite[Nfaxtab] = {
 175         {8, 0x35, 0}, /* 0011 0101 */
 176         {6, 0x7, 1}, /* 0001 11 */
 177         {4, 0x7, 2}, /* 0111 */
 178         {4, 0x8, 3}, /* 1000 */
 179         {4, 0xb, 4}, /* 1011 */
 180         {4, 0xc, 5}, /* 1100 */
 181         {4, 0xe, 6}, /* 1110 */
 182         {4, 0xf, 7}, /* 1111 */
 183         {5, 0x13, 8}, /* 1001 1 */
 184         {5, 0x14, 9}, /* 1010 0 */
 185         {5, 0x7, 10}, /* 0011 1 */
 186         {5, 0x8, 11}, /* 0100 0 */
 187         {6, 0x8, 12}, /* 0010 00 */
 188         {6, 0x3, 13}, /* 0000 11 */
 189         {6, 0x34, 14}, /* 1101 00 */
 190         {6, 0x35, 15}, /* 1101 01 */
 191         {6, 0x2a, 16}, /* 1010 10 */
 192         {6, 0x2b, 17}, /* 1010 11 */
 193         {7, 0x27, 18}, /* 0100 111 */
 194         {7, 0xc, 19}, /* 0001 100 */
 195         {7, 0x8, 20}, /* 0001 000 */
 196         {7, 0x17, 21}, /* 0010 111 */
 197         {7, 0x3, 22}, /* 0000 011 */
 198         {7, 0x4, 23}, /* 0000 100 */
 199         {7, 0x28, 24}, /* 0101 000 */
 200         {7, 0x2b, 25}, /* 0101 011 */
 201         {7, 0x13, 26}, /* 0010 011 */
 202         {7, 0x24, 27}, /* 0100 100 */
 203         {7, 0x18, 28}, /* 0011 000 */
 204         {8, 0x2, 29}, /* 0000 0010 */
 205         {8, 0x3, 30}, /* 0000 0011 */
 206         {8, 0x1a, 31}, /* 0001 1010 */
 207         {8, 0x1b, 32}, /* 0001 1011 */
 208         {8, 0x12, 33}, /* 0001 0010 */
 209         {8, 0x13, 34}, /* 0001 0011 */
 210         {8, 0x14, 35}, /* 0001 0100 */
 211         {8, 0x15, 36}, /* 0001 0101 */
 212         {8, 0x16, 37}, /* 0001 0110 */
 213         {8, 0x17, 38}, /* 0001 0111 */
 214         {8, 0x28, 39}, /* 0010 1000 */
 215         {8, 0x29, 40}, /* 0010 1001 */
 216         {8, 0x2a, 41}, /* 0010 1010 */
 217         {8, 0x2b, 42}, /* 0010 1011 */
 218         {8, 0x2c, 43}, /* 0010 1100 */
 219         {8, 0x2d, 44}, /* 0010 1101 */
 220         {8, 0x4, 45}, /* 0000 0100 */
 221         {8, 0x5, 46}, /* 0000 0101 */
 222         {8, 0xa, 47}, /* 0000 1010 */
 223         {8, 0xb, 48}, /* 0000 1011 */
 224         {8, 0x52, 49}, /* 0101 0010 */
 225         {8, 0x53, 50}, /* 0101 0011 */
 226         {8, 0x54, 51}, /* 0101 0100 */
 227         {8, 0x55, 52}, /* 0101 0101 */
 228         {8, 0x24, 53}, /* 0010 0100 */
 229         {8, 0x25, 54}, /* 0010 0101 */
 230         {8, 0x58, 55}, /* 0101 1000 */
 231         {8, 0x59, 56}, /* 0101 1001 */
 232         {8, 0x5a, 57}, /* 0101 1010 */
 233         {8, 0x5b, 58}, /* 0101 1011 */
 234         {8, 0x4a, 59}, /* 0100 1010 */
 235         {8, 0x4b, 60}, /* 0100 1011 */
 236         {8, 0x32, 61}, /* 0011 0010 */
 237         {8, 0x33, 62}, /* 0011 0011 */
 238         {8, 0x34, 63}, /* 0011 0100 */
 239         {5, 0x1b, 64}, /* 1101 1 */
 240         {5, 0x12, 128}, /* 1001 0 */
 241         {6, 0x17, 192}, /* 0101 11 */
 242         {7, 0x37, 256}, /* 0110 111 */
 243         {8, 0x36, 320}, /* 0011 0110 */
 244         {8, 0x37, 384}, /* 0011 0111 */
 245         {8, 0x64, 448}, /* 0110 0100 */
 246         {8, 0x65, 512}, /* 0110 0101 */
 247         {8, 0x68, 576}, /* 0110 1000 */
 248         {8, 0x67, 640}, /* 0110 0111 */
 249         {9, 0xcc, 704}, /* 0110 0110 0 */
 250         {9, 0xcd, 768}, /* 0110 0110 1 */
 251         {9, 0xd2, 832}, /* 0110 1001 0 */
 252         {9, 0xd3, 896}, /* 0110 1001 1 */
 253         {9, 0xd4, 960}, /* 0110 1010 0 */
 254         {9, 0xd5, 1024}, /* 0110 1010 1 */
 255         {9, 0xd6, 1088}, /* 0110 1011 0 */
 256         {9, 0xd7, 1152}, /* 0110 1011 1 */
 257         {9, 0xd8, 1216}, /* 0110 1100 0 */
 258         {9, 0xd9, 1280}, /* 0110 1100 1 */
 259         {9, 0xda, 1344}, /* 0110 1101 0 */
 260         {9, 0xdb, 1408}, /* 0110 1101 1 */
 261         {9, 0x98, 1472}, /* 0100 1100 0 */
 262         {9, 0x99, 1536}, /* 0100 1100 1 */
 263         {9, 0x9a, 1600}, /* 0100 1101 0 */
 264         {6, 0x18, 1664}, /* 0110 00 */
 265         {9, 0x9b, 1728}, /* 0100 1101 1 */
 266         {11, 0x8, 1792}, /* 0000 0001 000 */
 267         {11, 0xc, 1856}, /* 0000 0001 100 */
 268         {11, 0xd, 1920}, /* 0000 0001 101 */
 269         {12, 0x12, 1984}, /* 0000 0001 0010 */
 270         {12, 0x13, 2048}, /* 0000 0001 0011 */
 271         {12, 0x14, 2112}, /* 0000 0001 0100 */
 272         {12, 0x15, 2176}, /* 0000 0001 0101 */
 273         {12, 0x16, 2240}, /* 0000 0001 0110 */
 274         {12, 0x17, 2304}, /* 0000 0001 0111 */
 275         {12, 0x1c, 2368}, /* 0000 0001 1100 */
 276         {12, 0x1d, 2432}, /* 0000 0001 1101 */
 277         {12, 0x1e, 2496}, /* 0000 0001 1110 */
 278         {12, 0x1f, 2560}, /* 0000 0001 1111 */
 279         {12, 0x1, -1} /* 0000 0000 0001 */
 280 };
 281
 282 static Tab faxblack[Nfaxtab] = {
 283         {10, 0x37, 0}, /* 0000 1101 11 */
 284         {3, 0x2, 1}, /* 010 */
 285         {2, 0x3, 2}, /* 11 */
 286         {2, 0x2, 3}, /* 10 */
 287         {3, 0x3, 4}, /* 011 */
 288         {4, 0x3, 5}, /* 0011 */
 289         {4, 0x2, 6}, /* 0010 */
 290         {5, 0x3, 7}, /* 0001 1 */
 291         {6, 0x5, 8}, /* 0001 01 */
 292         {6, 0x4, 9}, /* 0001 00 */
 293         {7, 0x4, 10}, /* 0000 100 */
 294         {7, 0x5, 11}, /* 0000 101 */
 295         {7, 0x7, 12}, /* 0000 111 */
 296         {8, 0x4, 13}, /* 0000 0100 */
 297         {8, 0x7, 14}, /* 0000 0111 */
 298         {9, 0x18, 15}, /* 0000 1100 0 */
 299         {10, 0x17, 16}, /* 0000 0101 11 */
 300         {10, 0x18, 17}, /* 0000 0110 00 */
 301         {10, 0x8, 18}, /* 0000 0010 00 */
 302         {11, 0x67, 19}, /* 0000 1100 111 */
 303         {11, 0x68, 20}, /* 0000 1101 000 */
 304         {11, 0x6c, 21}, /* 0000 1101 100 */
 305         {11, 0x37, 22}, /* 0000 0110 111 */
 306         {11, 0x28, 23}, /* 0000 0101 000 */
 307         {11, 0x17, 24}, /* 0000 0010 111 */
 308         {11, 0x18, 25}, /* 0000 0011 000 */
 309         {12, 0xca, 26}, /* 0000 1100 1010 */
 310         {12, 0xcb, 27}, /* 0000 1100 1011 */
 311         {12, 0xcc, 28}, /* 0000 1100 1100 */
 312         {12, 0xcd, 29}, /* 0000 1100 1101 */
 313         {12, 0x68, 30}, /* 0000 0110 1000 */
 314         {12, 0x69, 31}, /* 0000 0110 1001 */
 315         {12, 0x6a, 32}, /* 0000 0110 1010 */
 316         {12, 0x6b, 33}, /* 0000 0110 1011 */
 317         {12, 0xd2, 34}, /* 0000 1101 0010 */
 318         {12, 0xd3, 35}, /* 0000 1101 0011 */
 319         {12, 0xd4, 36}, /* 0000 1101 0100 */
 320         {12, 0xd5, 37}, /* 0000 1101 0101 */
 321         {12, 0xd6, 38}, /* 0000 1101 0110 */
 322         {12, 0xd7, 39}, /* 0000 1101 0111 */
 323         {12, 0x6c, 40}, /* 0000 0110 1100 */
 324         {12, 0x6d, 41}, /* 0000 0110 1101 */
 325         {12, 0xda, 42}, /* 0000 1101 1010 */
 326         {12, 0xdb, 43}, /* 0000 1101 1011 */
 327         {12, 0x54, 44}, /* 0000 0101 0100 */
 328         {12, 0x55, 45}, /* 0000 0101 0101 */
 329         {12, 0x56, 46}, /* 0000 0101 0110 */
 330         {12, 0x57, 47}, /* 0000 0101 0111 */
 331         {12, 0x64, 48}, /* 0000 0110 0100 */
 332         {12, 0x65, 49}, /* 0000 0110 0101 */
 333         {12, 0x52, 50}, /* 0000 0101 0010 */
 334         {12, 0x53, 51}, /* 0000 0101 0011 */
 335         {12, 0x24, 52}, /* 0000 0010 0100 */
 336         {12, 0x37, 53}, /* 0000 0011 0111 */
 337         {12, 0x38, 54}, /* 0000 0011 1000 */
 338         {12, 0x27, 55}, /* 0000 0010 0111 */
 339         {12, 0x28, 56}, /* 0000 0010 1000 */
 340         {12, 0x58, 57}, /* 0000 0101 1000 */
 341         {12, 0x59, 58}, /* 0000 0101 1001 */
 342         {12, 0x2b, 59}, /* 0000 0010 1011 */
 343         {12, 0x2c, 60}, /* 0000 0010 1100 */
 344         {12, 0x5a, 61}, /* 0000 0101 1010 */
 345         {12, 0x66, 62}, /* 0000 0110 0110 */
 346         {12, 0x67, 63}, /* 0000 0110 0111 */
 347         {10, 0xf, 64}, /* 0000 0011 11 */
 348         {12, 0xc8, 128}, /* 0000 1100 1000 */
 349         {12, 0xc9, 192}, /* 0000 1100 1001 */
 350         {12, 0x5b, 256}, /* 0000 0101 1011 */
 351         {12, 0x33, 320}, /* 0000 0011 0011 */
 352         {12, 0x34, 384}, /* 0000 0011 0100 */
 353         {12, 0x35, 448}, /* 0000 0011 0101 */
 354         {13, 0x6c, 512}, /* 0000 0011 0110 0 */
 355         {13, 0x6d, 576}, /* 0000 0011 0110 1 */
 356         {13, 0x4a, 640}, /* 0000 0010 0101 0 */
 357         {13, 0x4b, 704}, /* 0000 0010 0101 1 */
 358         {13, 0x4c, 768}, /* 0000 0010 0110 0 */
 359         {13, 0x4d, 832}, /* 0000 0010 0110 1 */
 360         {13, 0x72, 896}, /* 0000 0011 1001 0 */
 361         {13, 0x73, 960}, /* 0000 0011 1001 1 */
 362         {13, 0x74, 1024}, /* 0000 0011 1010 0 */
 363         {13, 0x75, 1088}, /* 0000 0011 1010 1 */
 364         {13, 0x76, 1152}, /* 0000 0011 1011 0 */
 365         {13, 0x77, 1216}, /* 0000 0011 1011 1 */
 366         {13, 0x52, 1280}, /* 0000 0010 1001 0 */
 367         {13, 0x53, 1344}, /* 0000 0010 1001 1 */
 368         {13, 0x54, 1408}, /* 0000 0010 1010 0 */
 369         {13, 0x55, 1472}, /* 0000 0010 1010 1 */
 370         {13, 0x5a, 1536}, /* 0000 0010 1101 0 */
 371         {13, 0x5b, 1600}, /* 0000 0010 1101 1 */
 372         {13, 0x64, 1664}, /* 0000 0011 0010 0 */
 373         {13, 0x65, 1728}, /* 0000 0011 0010 1 */
 374         {11, 0x8, 1792}, /* 0000 0001 000 */
 375         {11, 0xc, 1856}, /* 0000 0001 100 */
 376         {11, 0xd, 1920}, /* 0000 0001 101 */
 377         {12, 0x12, 1984}, /* 0000 0001 0010 */
 378         {12, 0x13, 2048}, /* 0000 0001 0011 */
 379         {12, 0x14, 2112}, /* 0000 0001 0100 */
 380         {12, 0x15, 2176}, /* 0000 0001 0101 */
 381         {12, 0x16, 2240}, /* 0000 0001 0110 */
 382         {12, 0x17, 2304}, /* 0000 0001 0111 */
 383         {12, 0x1c, 2368}, /* 0000 0001 1100 */
 384         {12, 0x1d, 2432}, /* 0000 0001 1101 */
 385         {12, 0x1e, 2496}, /* 0000 0001 1110 */
 386         {12, 0x1f, 2560}, /* 0000 0001 1111 */
 387         {12, 0x1, -1} /* 0000 0000 0001 */
 388 };
 389
 390 static Tab faxcodes[] = {
 391         {4, 0x1, 0}, /* 0001 */
 392         {3, 0x1, 0}, /* 001 */
 393         {1, 0x1, 0}, /* 1 */
 394         {3, 0x2, 0}, /* 010 */
 395         {6, 0x2, 0}, /* 0000 10 */
 396         {7, 0x2, 0}, /* 0000 010 */
 397         {3, 0x3, 0}, /* 011 */
 398         {6, 0x3, 0}, /* 0000 11 */
 399         {7, 0x3, 0} /* 0000 011 */
 400 };
 401
 402 static int typesizes[] = {0, 1, 1, 2, 4, 8};
 403 static char memerr[] = "WriteTIF: malloc failed";
 404
 405 static int
 406 put1(Biobuf *b, uchar c)
 407 {
 408         return Bputc(b, c);
 409 }
 410
 411 static int
 412 put2(Biobuf *b, uint s)
 413 {
 414         if(put1(b, s>>8) < 0)
 415                 return -1;
 416         return put1(b, s);
 417 }
 418
 419 static int
 420 put4(Biobuf *b, ulong l)
 421 {
 422         if(put2(b, l>>16) < 0)
 423                 return -1;
 424         return put2(b, l);
 425 }
 426
 427 static char *
 428 nocomp(Tif *)
 429 {
 430         return nil;
 431 }
 432
 433 static char *
 434 faxputbyte(Fax *f)
 435 {
 436         if(f->n >= f->ndata) {
 437                 f->ndata *= 2;
 438                 f->data = realloc(f->data,
 439                         f->ndata*sizeof *f->data);
 440                 if(f->data == nil)
 441                         return memerr;
 442         }
 443         f->data[f->n++] = f->byte;
 444         f->byte = f->nbyte = 0;
 445         return nil;
 446 }
 447
 448 static char *
 449 faxputbit(Fax *f, int bit)
 450 {
 451         f->byte = (f->byte << 1) | bit;
 452         f->nbyte++;
 453         return f->nbyte >= 8? faxputbyte(f): nil;
 454 }
 455
 456 static char *
 457 faxbytealign(Fax *f)
 458 {
 459         char *err;
 460
 461         err = nil;
 462         if(f->nbyte != 0) {
 463                 f->byte <<= 8 - f->nbyte;
 464                 err = faxputbyte(f);
 465         }
 466         return err;
 467 }
 468
 469 static char *
 470 faxputcode(Fax *f, Tab *tab)
 471 {
 472         int i, bit;
 473         char *err;
 474
 475         for(i = tab->len-1; i >= 0; i--) {
 476                 bit = (tab->code >> i) & 0x1;
 477                 if((err = faxputbit(f, bit)) != nil)
 478                         return err;
 479         }
 480         return nil;
 481 }
 482
 483 static int
 484 faxgettab(int run)
 485 {
 486         if(run >= 0) {
 487                 if(run <= 64)
 488                         return run;
 489                 if(run <= 2560)
 490                         return 64 + run/64 - 1;
 491         }
 492         return Nfaxtab - 1;
 493 }
 494
 495 static char *
 496 faxputrun(Fax *f, long run)
 497 {
 498         char *err;
 499         Tab *tab, *p;
 500
 501         tab = f->tab[f->st];
 502         p = &tab[faxgettab(2560)];
 503         while(run >= 2624) {
 504                 if((err = faxputcode(f, p)) != nil)
 505                         return err;
 506                 run -= 2560;
 507         }
 508         if(run >= 64) {
 509                 p = &tab[faxgettab(run)];
 510                 if((err = faxputcode(f, p)) != nil)
 511                         return err;
 512                 run -= p->run;
 513         }
 514         p = &tab[faxgettab(run)];
 515         err = faxputcode(f, p);
 516         f->st ^= 1;
 517         return err;
 518 }
 519
 520 static char *
 521 faxputeol(Fax *f)
 522 {
 523         return faxputcode(f, &f->tab[0][faxgettab(-1)]);
 524 }
 525
 526 static char *
 527 fax1d(Fax *f, ulong dx)
 528 {
 529         ulong i;
 530         long run;
 531         char *err;
 532
 533         f->st = 0;
 534         run = f->l2[0];
 535         for(i = 0;;) {
 536                 if((err = faxputrun(f, run)) != nil)
 537                         return err;
 538                 if(f->l2[i++] >= dx)
 539                         break;
 540                 run = f->l2[i] - f->l2[i-1];
 541         }
 542         memmove(f->l1, f->l2, i*sizeof *f->l1);
 543         return nil;
 544 }
 545
 546 static char *
 547 fax2d(Fax *f, ulong dx)
 548 {
 549         int j, v;
 550         ulong i;
 551         long a0, a1, a2, b1, b2;
 552         char *err;
 553         Tab *tab, *p;
 554
 555         f->st = 0;
 556         a0 = a1 = -1;
 557         tab = faxcodes;
 558         for(i = 0, err = nil; err == nil;) {
 559                 while(a1 <= a0)
 560                         a1 = f->l2[i++];
 561                 for(j = 0;; j++) {
 562                         b1 = f->l1[j];
 563                         if(b1 > a0 && f->st == j%2)
 564                                 break;
 565                         if(b1 >= dx)
 566                                 break;
 567                 }
 568                 if((b2 = b1) < dx)
 569                         b2 = f->l1[j+1];
 570                 if(b2 < a1) {
 571                         /* pass */
 572                         p = &tab[0];
 573                         err = faxputcode(f, p);
 574                         a0 = b2;
 575                 } else if(abs(v = a1-b1) < 3) {
 576                         /* vertical */
 577                         p = &tab[2+(v>0?3:0)+abs(v)];
 578                         err = faxputcode(f, p);
 579                         f->st ^= 1;
 580                         a0 = a1;
 581                 } else {
 582                         /* horizontal */
 583                         if(a0 < 0)
 584                                 a0 = 0;
 585                         p = &tab[1];
 586                         if((err = faxputcode(f, p)) != nil)
 587                                 return err;
 588                         a2 = a1 < dx? f->l2[i++]: a1;
 589                         if((err = faxputrun(f, a1-a0)) != nil)
 590                                 return err;
 591                         err = faxputrun(f, a2-a1);
 592                         a0 = a2;
 593                 }
 594                 if(a0 >= dx)
 595                         break;
 596         }
 597         memmove(f->l1, f->l2, i*sizeof *f->l1);
 598         return err;
 599 }
 600
 601 static char *
 602 faxstrip(Tif *t, Fax *f, uchar *data, ulong n, ulong dx)
 603 {
 604         int k, s, d1, two;
 605         ulong i, j, x;
 606         char *err;
 607
 608         d1 = t->comp != Tt6enc;
 609         two = 0;
 610         if(t->comp == Tt4enc) {
 611                 if((err = faxputeol(f)) != nil)
 612                         return err;
 613                 if(t->opt && (err = faxputbit(f, 1)) != nil)
 614                         return err;
 615         }
 616         for(i = j = x = 0; i < n;) {
 617                 s = 7 - x++%8;
 618                 k = ((data[i] >> s) & 0x1) ^ 0x1;
 619                 if(s == 0)
 620                         i++;
 621                 if(k != f->st) {
 622                         f->l2[j++] = x - 1;
 623                         f->st ^= 1;
 624                 }
 625                 if(x == dx) {
 626                         f->l2[j] = dx;
 627                         if(d1) {
 628                                 err = fax1d(f, dx);
 629                                 if(t->comp == Tt4enc &&
 630                                         t->opt) {
 631                                         two = Kpar - 1;
 632                                         d1 = 0;
 633                                 }
 634                         } else {
 635                                 err = fax2d(f, dx);
 636                                 if(two > 0 && --two <= 0)
 637                                         d1 = 1;
 638                         }
 639                         if(err != nil)
 640                                 return err;
 641                         if(t->comp == Thuffman)
 642                                 err = faxbytealign(f);
 643                         else if(t->comp == Tt4enc &&
 644                                 t->opt) {
 645                                 if((err = faxputeol(f)) != nil)
 646                                         return err;
 647                                 err = faxputbit(f, d1);
 648                         } else if(t->comp == Tt4enc)
 649                                 err = faxputeol(f);
 650                         if(err != nil)
 651                                 return err;
 652                         f->st = 0;
 653                         if(s != 0)
 654                                 i++;
 655                         x = 0;
 656                         j = 0;
 657                 }
 658         }
 659         if(t->comp == Tt4enc || t->comp == Tt6enc) {
 660                 i = t->comp == Tt4enc? 5: 2;
 661                 for(; i > 0; i--) {
 662                         if((err = faxputeol(f)) != nil)
 663                                 return err;
 664                         if(t->comp == Tt4enc && t->opt) {
 665                                 err = faxputbit(f, 1);
 666                                 if(err != nil)
 667                                         return err;
 668                         }
 669                 }
 670         }
 671         return faxbytealign(f);
 672 }
 673
 674 static char *
 675 fax(Tif *t)
 676 {
 677         ulong i, m, n;
 678         char *err;
 679         uchar *data;
 680         Fax f;
 681
 682         f.ndata = t->ndata;
 683         if((f.data = malloc(f.ndata*sizeof *f.data)) == nil)
 684                 return memerr;
 685         f.l1 = mallocz((t->dx+1)*sizeof *f.l1, 1);
 686         f.l2 = mallocz((t->dx+1)*sizeof *f.l2, 1);
 687         if(f.l1 == nil || f.l2 == nil) {
 688                 free(f.data);
 689                 if(f.l1 != nil)
 690                         free(f.l1);
 691                 if(f.l2 != nil)
 692                         free(f.l2);
 693                 return memerr;
 694         }
 695         f.tab[0] = faxwhite;
 696         f.tab[1] = faxblack;
 697         f.n = f.byte = f.nbyte = 0;
 698         for(i = n = 0, data = t->data; i < t->nstrips; i++) {
 699                 f.st = 0;
 700                 f.l1[0] = t->dx;
 701                 m = t->counts[i];
 702                 if((err = faxstrip(t, &f, data, m, t->dx)) != nil) {
 703                         if(f.data != nil)
 704                                 free(f.data);
 705                         return err;
 706                 }
 707                 data += m;
 708                 t->counts[i] = f.n - n;
 709                 n = f.n;
 710         }
 711         free(t->data);
 712         free(f.l1);
 713         free(f.l2);
 714         t->data = f.data;
 715         t->ndata = f.n;
 716         return nil;
 717 }
 718
 719 static void
 720 lzwtabinit(Lzw *l)
 721 {
 722         long i;
 723         Hash *hp;
 724
 725         l->ntab = Eoicode + 1;
 726         l->len = 9;
 727         hp = &l->hash[Hsize-1];
 728         i = Hsize - 8;
 729         do {
 730                 i -= 8;
 731                 hp[-7].hash = -1;
 732                 hp[-6].hash = -1;
 733                 hp[-5].hash = -1;
 734                 hp[-4].hash = -1;
 735                 hp[-3].hash = -1;
 736                 hp[-2].hash = -1;
 737                 hp[-1].hash = -1;
 738                 hp[0].hash = -1;
 739                 hp -= 8;
 740         } while(i >= 0);
 741         for(i += 8; i > 0; i--, hp--)
 742                 hp->hash = -1;
 743 }
 744
 745 static char *
 746 lzwputbyte(Lzw *l)
 747 {
 748         if(l->n >= l->ndata) {
 749                 l->ndata *= 2;
 750                 l->data = realloc(l->data,
 751                         l->ndata*sizeof *l->data);
 752                 if(l->data == nil)
 753                         return memerr;
 754         }
 755         l->data[l->n++] = l->byte;
 756         l->byte = l->nbyte = 0;
 757         return nil;
 758 }
 759
 760 static char *
 761 lzwbytealign(Lzw *l)
 762 {
 763         char *err;
 764
 765         err = nil;
 766         if(l->nbyte != 0) {
 767                 l->byte <<= 8 - l->nbyte;
 768                 err = lzwputbyte(l);
 769         }
 770         return err;
 771 }
 772
 773 static char *
 774 lzwputcode(Lzw *l, int code)
 775 {
 776         int i, c;
 777         char *err;
 778
 779         for(i = l->len-1; i >= 0; i--) {
 780                 c = (code >> i) & 0x1;
 781                 l->byte = (l->byte << 1) | c;
 782                 l->nbyte++;
 783                 if(l->nbyte >= 8) {
 784                         if((err = lzwputbyte(l)) != nil)
 785                                 return err;
 786                 }
 787         }
 788         return nil;
 789 }
 790
 791 static void
 792 predict1(Tif *t)
 793 {
 794         int pix, b[8], d, m, n, j;
 795         ulong i, x, y;
 796
 797         d = *t->depth;
 798         m = (1 << d) - 1;
 799         n = 8 / d;
 800         for(y = 0; y < t->dy; y++) {
 801                 for(x = t->bpl-1;; x--) {
 802                         i = y*t->bpl + x;
 803                         pix = t->data[i];
 804                         for(j = 0; j < n; j++) {
 805                                 b[j] = (pix >> d*j) & m;
 806                                 if(j > 0)
 807                                         b[j-1] -= b[j];
 808                         }
 809                         if(x > 0)
 810                                 b[n-1] -= t->data[i-1] & m;
 811                         for(j = pix = 0; j < n; j++)
 812                                 pix |= (b[j] & m) << d*j;
 813                         t->data[i] = pix;
 814                         if(x == 0)
 815                                 break;
 816                 }
 817         }
 818 }
 819
 820 static void
 821 predict8(Tif *t)
 822 {
 823         ulong i, j, s, x, y;
 824
 825         s = t->samples;
 826         for(y = 0; y < t->dy; y++) {
 827                 for(x = t->dx-1; x >= 1; x--) {
 828                         i = (y*t->dx + x) * s;
 829                         for(j = 0; j < s; i++, j++)
 830                                 t->data[i] -= t->data[i-s];
 831                 }
 832         }
 833 }
 834
 835 static char *
 836 lzwstrip(Lzw *l, uchar *data, ulong n)
 837 {
 838         int k, h;
 839         long fcode, disp;
 840         ulong i;
 841         char *err;
 842         Hash *hp;
 843         u16int ent;
 844
 845         if((err = lzwputcode(l, Clrcode)) != nil)
 846                 return err;
 847         i = 0;
 848         ent = data[i++];
 849         for(; i < n; i++) {
 850                 k = data[i];
 851                 fcode = ((long)k << 12) + ent;
 852                 h = (k << Hshift) ^ ent;
 853                 hp = &l->hash[h];
 854                 if(hp->hash == fcode) {
 855 hit:
 856                         ent = hp->code;
 857                         continue;
 858                 }
 859                 if(hp->hash >= 0) {
 860                         disp = h == 0? 1: Hsize - h;
 861                         do {
 862                                 if((h -= disp) < 0)
 863                                         h += Hsize;
 864                                 hp = &l->hash[h];
 865                                 if(hp->hash == fcode)
 866                                         goto hit;
 867                         } while(hp->hash >= 0);
 868                 }
 869                 if((err = lzwputcode(l, ent)) != nil)
 870                         return err;
 871                 ent = k;
 872                 hp->hash = fcode;
 873                 switch(hp->code = l->ntab) {
 874                 case 511:
 875                 case 1023:
 876                 case 2047:
 877                         l->len++;
 878                         break;
 879                 default:
 880                         break;
 881                 }
 882                 if(l->ntab++ >= Tabsz-2) {
 883                         err = lzwputcode(l, Clrcode);
 884                         if(err != nil)
 885                                 return err;
 886                         lzwtabinit(l);
 887                 }
 888         }
 889         if((err = lzwputcode(l, ent)) != nil)
 890                 return err;
 891         if((err = lzwputcode(l, Eoicode)) != nil)
 892                 return err;
 893         return lzwbytealign(l);
 894 }
 895
 896 static char *
 897 lzw(Tif *t)
 898 {
 899         ulong i, m, n;
 900         char *err;
 901         uchar *data;
 902         Lzw l;
 903
 904         if(t->opt)
 905                 *t->depth < 8? predict1(t): predict8(t);
 906         l.ndata = t->ndata;
 907         if((l.data = malloc(l.ndata*sizeof *l.data)) == nil)
 908                 return memerr;
 909         l.n = l.byte = l.nbyte = 0;
 910         err = nil;
 911         for(i = n = 0, data = t->data; i < t->nstrips; i++) {
 912                 lzwtabinit(&l);
 913                 m = t->counts[i];
 914                 if((err = lzwstrip(&l, data, m)) != nil)
 915                         break;
 916                 data += m;
 917                 t->counts[i] = l.n - n;
 918                 n = l.n;
 919         }
 920         if(err != nil) {
 921                 if(l.data != nil)
 922                         free(l.data);
 923                 return err;
 924         }
 925         free(t->data);
 926         t->data = l.data;
 927         t->ndata = l.n;
 928         return nil;
 929 }
 930
 931 static char *
 932 pkbrow(Pkb *p, uchar *data, int ndata, long *buf)
 933 {
 934         int b, repl;
 935         long i, j, k, n;
 936         ulong m;
 937
 938         i = n = 0;
 939         buf[n++] = i;
 940         b = data[i++];
 941         if(i < ndata)
 942                 repl = b == data[i]? 1: 0;
 943         else
 944                 repl = 0;
 945         for(; i < ndata; i++) {
 946                 k = data[i];
 947                 j = labs(buf[n-1]);
 948                 if(repl) {
 949                         if(b != k) {
 950                                 repl ^= 1;
 951                                 buf[n++] = -i;
 952                         }
 953                 } else {
 954                         if(b == k) {
 955                                 repl ^= 1;
 956                                 if(i-j > 1)
 957                                         buf[n++] = i - 1;
 958                         }
 959                 }
 960                 b = k;
 961         }
 962         buf[n++] = repl? -i: i;
 963         for(i = 1; i < n;) {
 964                 k = buf[i];
 965                 j = labs(buf[i-1]);
 966                 if(i < n-2 && k > 0 && buf[i+1] < 0 &&
 967                         buf[i+2] > 0 && -buf[i+1]-k <= 2) {
 968                         buf[i] = buf[i+1] = buf[i+2];
 969                         continue;
 970                 }
 971                 if((b = labs(k) - j) > 128) {
 972                         b = 128;
 973                         buf[i-1] += buf[i-1] < 0? -b: b;
 974                 } else
 975                         i++;
 976                 if(b == 0)
 977                         continue;
 978                 m = 1 + (k < 0? 1: b);
 979                 if(p->n+m > p->ndata) {
 980                         p->ndata = (p->n + m) * 2;
 981                         p->data = realloc(p->data,
 982                                 p->ndata*sizeof *p->data);
 983                         if(p->data == nil)
 984                                 return memerr;
 985                 }
 986                 if(k < 0) {
 987                         p->data[p->n++] = 1 - b;
 988                         p->data[p->n++] = data[j];
 989                 } else {
 990                         p->data[p->n++] = b - 1;
 991                         memmove(p->data+p->n, data+j, b);
 992                         p->n += b;
 993                 }
 994         }
 995         return nil;
 996 }
 997
 998 static char *
 999 packbits(Tif *t)
1000 {
1001         ulong i, j, n;
1002         char *err;
1003         uchar *data;
1004         long *buf;
1005         Pkb p;
1006
1007         p.ndata = t->ndata;
1008         if((p.data = malloc(p.ndata*sizeof *p.data)) == nil)
1009                 return memerr;
1010         if((buf = malloc((t->bpl+1)*sizeof *buf)) == nil) {
1011                 free(p.data);
1012                 return memerr;
1013         }
1014         p.n = 0;
1015         data = t->data;
1016         for(i = j = n = 0, err = nil; i < t->dy; i++) {
1017                 if((err = pkbrow(&p, data, t->bpl, buf)) != nil)
1018                         break;
1019                 data += t->bpl;
1020                 if(i%t->rows == t->rows-1) {
1021                         t->counts[j++] = p.n - n;
1022                         n = p.n;
1023                 }
1024         }
1025         free(buf);
1026         if(err != nil) {
1027                 if(p.data != nil)
1028                         free(p.data);
1029                 return err;
1030         }
1031         if(j < t->nstrips)
1032                 t->counts[j] = p.n - n;
1033         free(t->data);
1034         t->data = p.data;
1035         t->ndata = p.n;
1036         return nil;
1037 }
1038
1039 static char *
1040 alloctif(Tif *t)
1041 {
1042         int rgb;
1043         ulong i, count, n;
1044
1045         count = t->ndata < 0x2000? t->ndata: 0x2000;
1046         t->rows = (count + t->bpl - 1) / t->bpl;
1047         if(t->comp == Tt4enc && t->opt) {
1048                 if((n = t->rows%Kpar) != 0)
1049                         t->rows += Kpar - n;
1050         }
1051         t->nstrips = (t->dy + t->rows - 1) / t->rows;
1052         t->strips = malloc(t->nstrips*sizeof *t->strips);
1053         if(t->strips == nil)
1054                 return memerr;
1055         t->counts = malloc(t->nstrips*sizeof *t->counts);
1056         if(t->counts == nil) {
1057                 free(t->strips);
1058                 return memerr;
1059         }
1060         if(t->ncolor > 0) {
1061                 t->color = malloc(t->ncolor*sizeof *t->color);
1062                 if(t->color == nil) {
1063                         free(t->strips);
1064                         free(t->counts);
1065                         return memerr;
1066                 }
1067                 for(i = 0; i < 256; i++) {
1068                         rgb = cmap2rgb(i);
1069                         t->color[i] = (rgb >> 16) & 0xff;
1070                         t->color[i+256] = (rgb >> 8) & 0xff;
1071                         t->color[i+256*2] = rgb & 0xff;
1072                 }
1073         }
1074         count = t->rows * t->bpl;
1075         for(i = 0, n = t->ndata; i < t->nstrips-1; i++) {
1076                 t->counts[i] = count;
1077                 n -= count;
1078         }
1079         t->counts[i] = n;
1080         return nil;
1081 }
1082
1083 static void
1084 freetif(Tif *t)
1085 {
1086         free(t->strips);
1087         free(t->counts);
1088         if(t->color != nil)
1089                 free(t->color);
1090         free(t->data);
1091 }
1092
1093 static int
1094 typesize(int fld)
1095 {
1096         return typesizes[flds[fld].typ];
1097 }
1098
1099 static void
1100 writefld(Biobuf *fd, int fld, ulong cnt, ulong val)
1101 {
1102         put2(fd, flds[fld].tag);
1103         put2(fd, flds[fld].typ);
1104         put4(fd, cnt);
1105         put4(fd, val);
1106 }
1107
1108 static void
1109 writeflds(Biobuf *fd, Tif *t)
1110 {
1111         int n;
1112         ulong i, off, slen, s, offs[7];
1113
1114         slen = t->desc == nil? 0: strlen(t->desc) + 1;
1115         put2(fd, 0x4d4d);
1116         put2(fd, 0x002a);
1117         off = 0x00000008;
1118         memset(offs, 0, sizeof offs);
1119         n = 0;
1120         offs[n++] = off;
1121         if(t->samples > 1) {
1122                 off += t->samples * typesize(Tbits);
1123                 offs[n++] = off;
1124         }
1125         if(slen > 4) {
1126                 off += slen * typesize(Tdesc);
1127                 offs[n++] = off;
1128         }
1129         if(t->nstrips > 1) {
1130                 off += t->nstrips * typesize(Tstrips);
1131                 offs[n++] = off;
1132                 off += t->nstrips * typesize(Tcounts);
1133                 offs[n++] = off;
1134         }
1135         off += typesize(Txres);
1136         offs[n++] = off;
1137         off += typesize(Tyres);
1138         offs[n] = off;
1139         if(t->color != nil)
1140                 off += t->ncolor * typesize(Tcolor);
1141         for(i = 0; i < t->nstrips-1; i++) {
1142                 t->strips[i] = off;
1143                 off += t->counts[i];
1144         }
1145         t->strips[i] = off;
1146         off += t->counts[i];
1147         put4(fd, off);
1148         if(t->samples > 1) {
1149                 for(i = 0; i < t->samples; i++)
1150                         put2(fd, t->depth[i]);
1151         }
1152         if(slen > 4) {
1153                 Bwrite(fd, t->desc, slen-1);
1154                 put1(fd, 0x00);
1155         }
1156         if(t->nstrips > 1) {
1157                 for(i = 0; i < t->nstrips; i++)
1158                         put4(fd, t->strips[i]);
1159                 for(i = 0; i < t->nstrips; i++)
1160                         put4(fd, t->counts[i]);
1161         }
1162         put4(fd, t->dx);
1163         put4(fd, 0x00000004);
1164         put4(fd, t->dy);
1165         put4(fd, 0x00000004);
1166         if(t->color != nil) {
1167                 for(i = 0; i < t->ncolor; i++)
1168                         put2(fd, t->color[i]);
1169         }
1170         Bwrite(fd, t->data, t->ndata);
1171         n = 0;
1172         put2(fd, t->nfld);
1173         writefld(fd, Twidth, 1, t->dx);
1174         writefld(fd, Tlength, 1, t->dy);
1175         if(t->samples > 1)
1176                 writefld(fd, Tbits, t->samples, offs[n++]);
1177         else
1178                 writefld(fd, Tbits, t->samples, *t->depth<<16);
1179         writefld(fd, Tcomp, 1, t->comp<<16);
1180         writefld(fd, Tphoto, 1, t->photo<<16);
1181         if(t->comp >= 2 && t->comp <= 4)
1182                 writefld(fd, Tfill, 1, 1<<16);
1183         if(slen > 1) {
1184                 if(slen <= 4) {
1185                         for(i = s = 0; i < slen-1; i++)
1186                                 s = (s << 8) | t->desc[i];
1187                         s <<= 8;
1188                         writefld(fd, Tdesc, slen, s);
1189                 } else
1190                         writefld(fd, Tdesc, slen, offs[n++]);
1191         }
1192         if(t->nstrips > 1)
1193                 writefld(fd, Tstrips, t->nstrips, offs[n++]);
1194         else
1195                 writefld(fd, Tstrips, t->nstrips, *t->strips);
1196         if(t->samples > 1)
1197                 writefld(fd, Tsamples, 1, t->samples<<16);
1198         writefld(fd, Trows, 1, t->rows);
1199         if(t->nstrips > 1)
1200                 writefld(fd, Tcounts, t->nstrips, offs[n++]);
1201         else
1202                 writefld(fd, Tcounts, t->nstrips, *t->counts);
1203         writefld(fd, Txres, 1, offs[n++]);
1204         writefld(fd, Tyres, 1, offs[n++]);
1205         if(t->comp == Tt4enc && t->opt)
1206                 writefld(fd, T4opt, 1, 1);
1207         writefld(fd, Tresunit, 1, 2<<16);
1208         if(t->comp == Tlzw && t->opt)
1209                 writefld(fd, Tpredictor, 1, 2<<16);
1210         if(t->color != nil)
1211                 writefld(fd, Tcolor, t->ncolor, offs[n]);
1212         put4(fd, 0x00000000);
1213 }
1214
1215 static char *
1216 writedata(Biobuf *fd, Image *i, Memimage *m, Tif *t)
1217 {
1218         char *err;
1219         uchar *data;
1220         int j, ndata, depth;
1221         Rectangle r;
1222
1223         if(m != nil) {
1224                 r = m->r;
1225                 depth = m->depth;
1226         } else {
1227                 r = i->r;
1228                 depth = i->depth;
1229         }
1230         t->dx = Dx(r);
1231         t->dy = Dy(r);
1232         for(j = 0; j < t->samples; j++)
1233                 t->depth[j] = depth / t->samples;
1234         /*
1235         * potentially one extra byte on each
1236         * end of each scan line
1237         */
1238         ndata = t->dy * (2 + t->dx*depth/8);
1239         if((data = malloc(ndata)) == nil)
1240                 return memerr;
1241         if(m != nil)
1242                 ndata = unloadmemimage(m, r, data, ndata);
1243         else
1244                 ndata = unloadimage(i, r, data, ndata);
1245         if(ndata < 0) {
1246                 free(data);
1247                 if((err = malloc(ERRMAX*sizeof *err)) == nil)
1248                         return memerr;
1249                 snprint(err, ERRMAX, "WriteTIF: %r");
1250         } else {
1251                 t->data = data;
1252                 t->ndata = ndata;
1253                 t->bpl = bytesperline(r, depth);
1254                 err = alloctif(t);
1255                 if(err != nil) {
1256                         freetif(t);
1257                         return err;
1258                 }
1259                 if((err = (*t->compress)(t)) == nil)
1260                         writeflds(fd, t);
1261                 freetif(t);
1262         }
1263         return err;
1264 }
1265
1266 static char *
1267 writetif0(Biobuf *fd, Image *image, Memimage *memimage,
1268         ulong chan, char *s, int comp, int opt)
1269 {
1270         Tif t;
1271
1272         t.nfld = 11;
1273         t.color = nil;
1274         if((t.desc = s) != nil)
1275                 t.nfld++;
1276         t.opt = opt;
1277         t.comp = comp;
1278         switch(chan) {
1279         case GREY1:
1280         case GREY4:
1281         case GREY8:
1282                 t.photo = 1;
1283                 t.samples = 1;
1284                 t.ncolor = 0;
1285                 break;
1286         case CMAP8:
1287                 t.photo = 3;
1288                 t.samples = 1;
1289                 t.ncolor = 3 * 256;
1290                 t.nfld++;
1291                 break;
1292         case BGR24:
1293                 t.photo = 2;
1294                 t.samples = 3;
1295                 t.ncolor = 0;
1296                 t.nfld++;
1297                 break;
1298         default:
1299                 return "WriteTIF: can't handle channel type";
1300         }
1301         switch(t.comp) {
1302         case Tnocomp:
1303                 t.compress = nocomp;
1304                 break;
1305         case Thuffman:
1306         case Tt4enc:
1307         case Tt6enc:
1308                 t.photo = 0;
1309                 t.nfld++;
1310                 if(t.comp == Tt4enc && t.opt)
1311                         t.nfld++;
1312                 t.compress = fax;
1313                 break;
1314         case Tlzw:
1315                 t.compress = lzw;
1316                 if(t.opt)
1317                         t.nfld++;
1318                 break;
1319         case Tpackbits:
1320                 t.compress = packbits;
1321                 break;
1322         default:
1323                 return "WriteTIF: unknown compression";
1324         }
1325         return writedata(fd, image, memimage, &t);
1326 }
1327
1328 char *
1329 writetif(Biobuf *fd, Image *i, char *s, int comp, int opt)
1330 {
1331         return writetif0(fd, i, nil, i->chan, s, comp, opt);
1332 }
1333
1334 char *
1335 memwritetif(Biobuf *fd, Memimage *m, char *s, int comp, int opt)
1336 {
1337         return writetif0(fd, nil, m, m->chan, s, comp, opt);
1338 }