sys/src/cmd/jpg/readtif.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 * fax codes and lzw:
  11 * http://www.remotesensing.org/libtiff/
  12 */
  13 #include <u.h>
  14 #include <libc.h>
  15 #include <bio.h>
  16 #include <draw.h>
  17 #include "imagefile.h"
  18
  19 enum {
  20         II = 0x4949, /* little-endian */
  21         MM = 0x4d4d, /* big-endian */
  22         TIF = 0x002a /* tiff magic number */
  23 };
  24
  25 enum {
  26         Byte = 1,
  27         Short = 3,
  28         Long = 4
  29 };
  30
  31 enum {
  32         Width = 0x0100,
  33         Length = 0x0101,
  34         Bits = 0x0102,
  35
  36         Compression = 0x0103,
  37         Nocomp = 0x0001,
  38         Huffman = 0x0002,
  39         T4enc = 0x0003,
  40         T6enc = 0x0004,
  41         Lzwenc = 0x0005,
  42         Packbits = 0x8005,
  43
  44         Photometric = 0x0106,
  45         Whitezero = 0x0000,
  46         Blackzero = 0x0001,
  47         Rgb = 0x0002,
  48         Palette = 0x0003,
  49
  50         Fill = 0x010a,
  51         Strips = 0x0111,
  52         Orientation = 0x0112,
  53         Samples = 0x0115,
  54         Rows = 0x0116,
  55         Counts = 0x0117,
  56         Planar = 0x011c,
  57         T4opts = 0x0124,
  58         T6opts = 0x0125,
  59         Predictor = 0x13d,
  60         Color = 0x0140
  61 };
  62
  63 enum {
  64         Nfaxcodes = 10,
  65         Nfaxtab = 105
  66 };
  67
  68 enum {
  69         Clrcode = 256,
  70         Eoicode = 257,
  71         Tabsz = 1<<12
  72 };
  73
  74 typedef struct Tab Tab;
  75 typedef struct Fax Fax;
  76 typedef struct Code Code;
  77 typedef struct Lzw Lzw;
  78 typedef struct Fld Fld;
  79 typedef struct Tif Tif;
  80
  81 struct Tab {
  82         int len;
  83         int code;
  84         int run; /* run length */
  85 };
  86
  87 struct Fax {
  88         ulong n;
  89         int m;
  90         int st; /* state */
  91         Tab *tab[2];
  92         int ntab; /* position in tab */
  93         Tab *eol;
  94         int (*getbit)(Fax *);
  95         int *l1;
  96         int *l2;
  97         ulong nl;
  98         uchar *data;
  99         ulong next; /* next strip offset in data */
 100 };
 101
 102 struct Code {
 103         uchar val;
 104         Code *next;
 105 };
 106
 107 struct Lzw {
 108         Code tab[Tabsz];
 109         int ntab;
 110         int len; /* code length */
 111         ulong n;
 112         int m;
 113         uchar *data;
 114         ulong next; /* next strip offset in data */
 115         /* remaining allocated codes */
 116         Code *first;
 117         Code *last;
 118 };
 119
 120 struct Fld {
 121         uint tag;
 122         uint typ;
 123         ulong cnt;
 124         ulong off; /* value offset */
 125         ulong *val;
 126         ulong nval;
 127 };
 128
 129 struct Tif {
 130         Biobuf *fd;
 131         uint end; /* endianness */
 132         uchar tmp[4];
 133         uchar *buf;
 134         ulong nbuf;
 135         int eof; /* reached end of image */
 136         ulong n; /* offset in buf array */
 137         ulong off;
 138         uint nfld;
 139         Fld *fld;
 140         ulong (*byte2)(uchar *);
 141         ulong (*byte4)(uchar *);
 142
 143         /* field data */
 144         ulong dx;
 145         ulong dy;
 146         ulong depth;
 147         ulong comp;
 148         uchar *(*uncompress)(Tif *);
 149         ulong orientation;
 150         ulong photo;
 151         int (*decode)(Tif *, Rawimage *, uchar *);
 152         ulong fill;
 153         ulong *strips;
 154         ulong nstrips;
 155         ulong samples;
 156         ulong rows;
 157         ulong *counts;
 158         ulong ncounts;
 159         ulong planar;
 160         ulong *color; /* color map */
 161         ulong ncolor;
 162         ulong t4;
 163         ulong t6;
 164         ulong predictor;
 165
 166         /* image data */
 167         uchar *data;
 168         ulong ndata;
 169 };
 170
 171 /*
 172 * imported from libdraw/arith.c to permit
 173 * extern log2 function
 174 */
 175 static int log2[] = {
 176         -1, 0, 1, -1, 2, -1, -1, -1, 3,
 177         -1, -1, -1, -1, -1, -1, -1, 4,
 178         -1, -1, -1, -1, -1, -1, -1, 4 /* BUG */,
 179         -1, -1, -1, -1, -1, -1, -1, 5
 180 };
 181
 182 static Tab faxwhite[Nfaxtab] = {
 183         {4, 0x7, 2}, /* 0111 */
 184         {4, 0x8, 3}, /* 1000 */
 185         {4, 0xb, 4}, /* 1011 */
 186         {4, 0xc, 5}, /* 1100 */
 187         {4, 0xe, 6}, /* 1110 */
 188         {4, 0xf, 7}, /* 1111 */
 189         {5, 0x12, 128}, /* 1001 0 */
 190         {5, 0x13, 8}, /* 1001 1 */
 191         {5, 0x14, 9}, /* 1010 0 */
 192         {5, 0x1b, 64}, /* 1101 1 */
 193         {5, 0x7, 10}, /* 0011 1 */
 194         {5, 0x8, 11}, /* 0100 0 */
 195         {6, 0x17, 192}, /* 0101 11 */
 196         {6, 0x18, 1664}, /* 0110 00 */
 197         {6, 0x2a, 16}, /* 1010 10 */
 198         {6, 0x2b, 17}, /* 1010 11 */
 199         {6, 0x3, 13}, /* 0000 11 */
 200         {6, 0x34, 14}, /* 1101 00 */
 201         {6, 0x35, 15}, /* 1101 01 */
 202         {6, 0x7, 1}, /* 0001 11 */
 203         {6, 0x8, 12}, /* 0010 00 */
 204         {7, 0x13, 26}, /* 0010 011 */
 205         {7, 0x17, 21}, /* 0010 111 */
 206         {7, 0x18, 28}, /* 0011 000 */
 207         {7, 0x24, 27}, /* 0100 100 */
 208         {7, 0x27, 18}, /* 0100 111 */
 209         {7, 0x28, 24}, /* 0101 000 */
 210         {7, 0x2b, 25}, /* 0101 011 */
 211         {7, 0x3, 22}, /* 0000 011 */
 212         {7, 0x37, 256}, /* 0110 111 */
 213         {7, 0x4, 23}, /* 0000 100 */
 214         {7, 0x8, 20}, /* 0001 000 */
 215         {7, 0xc, 19}, /* 0001 100 */
 216         {8, 0x12, 33}, /* 0001 0010 */
 217         {8, 0x13, 34}, /* 0001 0011 */
 218         {8, 0x14, 35}, /* 0001 0100 */
 219         {8, 0x15, 36}, /* 0001 0101 */
 220         {8, 0x16, 37}, /* 0001 0110 */
 221         {8, 0x17, 38}, /* 0001 0111 */
 222         {8, 0x1a, 31}, /* 0001 1010 */
 223         {8, 0x1b, 32}, /* 0001 1011 */
 224         {8, 0x2, 29}, /* 0000 0010 */
 225         {8, 0x24, 53}, /* 0010 0100 */
 226         {8, 0x25, 54}, /* 0010 0101 */
 227         {8, 0x28, 39}, /* 0010 1000 */
 228         {8, 0x29, 40}, /* 0010 1001 */
 229         {8, 0x2a, 41}, /* 0010 1010 */
 230         {8, 0x2b, 42}, /* 0010 1011 */
 231         {8, 0x2c, 43}, /* 0010 1100 */
 232         {8, 0x2d, 44}, /* 0010 1101 */
 233         {8, 0x3, 30}, /* 0000 0011 */
 234         {8, 0x32, 61}, /* 0011 0010 */
 235         {8, 0x33, 62}, /* 0011 0011 */
 236         {8, 0x34, 63}, /* 0011 0100 */
 237         {8, 0x35, 0}, /* 0011 0101 */
 238         {8, 0x36, 320}, /* 0011 0110 */
 239         {8, 0x37, 384}, /* 0011 0111 */
 240         {8, 0x4, 45}, /* 0000 0100 */
 241         {8, 0x4a, 59}, /* 0100 1010 */
 242         {8, 0x4b, 60}, /* 0100 1011 */
 243         {8, 0x5, 46}, /* 0000 0101 */
 244         {8, 0x52, 49}, /* 0101 0010 */
 245         {8, 0x53, 50}, /* 0101 0011 */
 246         {8, 0x54, 51}, /* 0101 0100 */
 247         {8, 0x55, 52}, /* 0101 0101 */
 248         {8, 0x58, 55}, /* 0101 1000 */
 249         {8, 0x59, 56}, /* 0101 1001 */
 250         {8, 0x5a, 57}, /* 0101 1010 */
 251         {8, 0x5b, 58}, /* 0101 1011 */
 252         {8, 0x64, 448}, /* 0110 0100 */
 253         {8, 0x65, 512}, /* 0110 0101 */
 254         {8, 0x67, 640}, /* 0110 0111 */
 255         {8, 0x68, 576}, /* 0110 1000 */
 256         {8, 0xa, 47}, /* 0000 1010 */
 257         {8, 0xb, 48}, /* 0000 1011 */
 258         {9, 0x98, 1472}, /* 0100 1100 0 */
 259         {9, 0x99, 1536}, /* 0100 1100 1 */
 260         {9, 0x9a, 1600}, /* 0100 1101 0 */
 261         {9, 0x9b, 1728}, /* 0100 1101 1 */
 262         {9, 0xcc, 704}, /* 0110 0110 0 */
 263         {9, 0xcd, 768}, /* 0110 0110 1 */
 264         {9, 0xd2, 832}, /* 0110 1001 0 */
 265         {9, 0xd3, 896}, /* 0110 1001 1 */
 266         {9, 0xd4, 960}, /* 0110 1010 0 */
 267         {9, 0xd5, 1024}, /* 0110 1010 1 */
 268         {9, 0xd6, 1088}, /* 0110 1011 0 */
 269         {9, 0xd7, 1152}, /* 0110 1011 1 */
 270         {9, 0xd8, 1216}, /* 0110 1100 0 */
 271         {9, 0xd9, 1280}, /* 0110 1100 1 */
 272         {9, 0xda, 1344}, /* 0110 1101 0 */
 273         {9, 0xdb, 1408}, /* 0110 1101 1 */
 274         {11, 0x8, 1792}, /* 0000 0001 000 */
 275         {11, 0xc, 1856}, /* 0000 0001 100 */
 276         {11, 0xd, 1920}, /* 0000 0001 101 */
 277         {12, 0x1, -1}, /* 0000 0000 0001 */
 278         {12, 0x12, 1984}, /* 0000 0001 0010 */
 279         {12, 0x13, 2048}, /* 0000 0001 0011 */
 280         {12, 0x14, 2112}, /* 0000 0001 0100 */
 281         {12, 0x15, 2176}, /* 0000 0001 0101 */
 282         {12, 0x16, 2240}, /* 0000 0001 0110 */
 283         {12, 0x17, 2304}, /* 0000 0001 0111 */
 284         {12, 0x1c, 2368}, /* 0000 0001 1100 */
 285         {12, 0x1d, 2432}, /* 0000 0001 1101 */
 286         {12, 0x1e, 2496}, /* 0000 0001 1110 */
 287         {12, 0x1f, 2560} /* 0000 0001 1111 */
 288 };
 289
 290 static Tab faxblack[Nfaxtab] = {
 291         {2, 0x2, 3}, /* 10 */
 292         {2, 0x3, 2}, /* 11 */
 293         {3, 0x2, 1}, /* 010 */
 294         {3, 0x3, 4}, /* 011 */
 295         {4, 0x2, 6}, /* 0010 */
 296         {4, 0x3, 5}, /* 0011 */
 297         {5, 0x3, 7}, /* 0001 1 */
 298         {6, 0x4, 9}, /* 0001 00 */
 299         {6, 0x5, 8}, /* 0001 01 */
 300         {7, 0x4, 10}, /* 0000 100 */
 301         {7, 0x5, 11}, /* 0000 101 */
 302         {7, 0x7, 12}, /* 0000 111 */
 303         {8, 0x4, 13}, /* 0000 0100 */
 304         {8, 0x7, 14}, /* 0000 0111 */
 305         {9, 0x18, 15}, /* 0000 1100 0 */
 306         {10, 0x17, 16}, /* 0000 0101 11 */
 307         {10, 0x18, 17}, /* 0000 0110 00 */
 308         {10, 0x37, 0}, /* 0000 1101 11 */
 309         {10, 0x8, 18}, /* 0000 0010 00 */
 310         {10, 0xf, 64}, /* 0000 0011 11 */
 311         {11, 0x17, 24}, /* 0000 0010 111 */
 312         {11, 0x18, 25}, /* 0000 0011 000 */
 313         {11, 0x28, 23}, /* 0000 0101 000 */
 314         {11, 0x37, 22}, /* 0000 0110 111 */
 315         {11, 0x67, 19}, /* 0000 1100 111 */
 316         {11, 0x68, 20}, /* 0000 1101 000 */
 317         {11, 0x6c, 21}, /* 0000 1101 100 */
 318         {11, 0x8, 1792}, /* 0000 0001 000 */
 319         {11, 0xc, 1856}, /* 0000 0001 100 */
 320         {11, 0xd, 1920}, /* 0000 0001 101 */
 321         {12, 0x1, -1}, /* 0000 0000 0001 */
 322         {12, 0x12, 1984}, /* 0000 0001 0010 */
 323         {12, 0x13, 2048}, /* 0000 0001 0011 */
 324         {12, 0x14, 2112}, /* 0000 0001 0100 */
 325         {12, 0x15, 2176}, /* 0000 0001 0101 */
 326         {12, 0x16, 2240}, /* 0000 0001 0110 */
 327         {12, 0x17, 2304}, /* 0000 0001 0111 */
 328         {12, 0x1c, 2368}, /* 0000 0001 1100 */
 329         {12, 0x1d, 2432}, /* 0000 0001 1101 */
 330         {12, 0x1e, 2496}, /* 0000 0001 1110 */
 331         {12, 0x1f, 2560}, /* 0000 0001 1111 */
 332         {12, 0x24, 52}, /* 0000 0010 0100 */
 333         {12, 0x27, 55}, /* 0000 0010 0111 */
 334         {12, 0x28, 56}, /* 0000 0010 1000 */
 335         {12, 0x2b, 59}, /* 0000 0010 1011 */
 336         {12, 0x2c, 60}, /* 0000 0010 1100 */
 337         {12, 0x33, 320}, /* 0000 0011 0011 */
 338         {12, 0x34, 384}, /* 0000 0011 0100 */
 339         {12, 0x35, 448}, /* 0000 0011 0101 */
 340         {12, 0x37, 53}, /* 0000 0011 0111 */
 341         {12, 0x38, 54}, /* 0000 0011 1000 */
 342         {12, 0x52, 50}, /* 0000 0101 0010 */
 343         {12, 0x53, 51}, /* 0000 0101 0011 */
 344         {12, 0x54, 44}, /* 0000 0101 0100 */
 345         {12, 0x55, 45}, /* 0000 0101 0101 */
 346         {12, 0x56, 46}, /* 0000 0101 0110 */
 347         {12, 0x57, 47}, /* 0000 0101 0111 */
 348         {12, 0x58, 57}, /* 0000 0101 1000 */
 349         {12, 0x59, 58}, /* 0000 0101 1001 */
 350         {12, 0x5a, 61}, /* 0000 0101 1010 */
 351         {12, 0x5b, 256}, /* 0000 0101 1011 */
 352         {12, 0x64, 48}, /* 0000 0110 0100 */
 353         {12, 0x65, 49}, /* 0000 0110 0101 */
 354         {12, 0x66, 62}, /* 0000 0110 0110 */
 355         {12, 0x67, 63}, /* 0000 0110 0111 */
 356         {12, 0x68, 30}, /* 0000 0110 1000 */
 357         {12, 0x69, 31}, /* 0000 0110 1001 */
 358         {12, 0x6a, 32}, /* 0000 0110 1010 */
 359         {12, 0x6b, 33}, /* 0000 0110 1011 */
 360         {12, 0x6c, 40}, /* 0000 0110 1100 */
 361         {12, 0x6d, 41}, /* 0000 0110 1101 */
 362         {12, 0xc8, 128}, /* 0000 1100 1000 */
 363         {12, 0xc9, 192}, /* 0000 1100 1001 */
 364         {12, 0xca, 26}, /* 0000 1100 1010 */
 365         {12, 0xcb, 27}, /* 0000 1100 1011 */
 366         {12, 0xcc, 28}, /* 0000 1100 1100 */
 367         {12, 0xcd, 29}, /* 0000 1100 1101 */
 368         {12, 0xd2, 34}, /* 0000 1101 0010 */
 369         {12, 0xd3, 35}, /* 0000 1101 0011 */
 370         {12, 0xd4, 36}, /* 0000 1101 0100 */
 371         {12, 0xd5, 37}, /* 0000 1101 0101 */
 372         {12, 0xd6, 38}, /* 0000 1101 0110 */
 373         {12, 0xd7, 39}, /* 0000 1101 0111 */
 374         {12, 0xda, 42}, /* 0000 1101 1010 */
 375         {12, 0xdb, 43}, /* 0000 1101 1011 */
 376         {13, 0x4a, 640}, /* 0000 0010 0101 0 */
 377         {13, 0x4b, 704}, /* 0000 0010 0101 1 */
 378         {13, 0x4c, 768}, /* 0000 0010 0110 0 */
 379         {13, 0x4d, 832}, /* 0000 0010 0110 1 */
 380         {13, 0x52, 1280}, /* 0000 0010 1001 0 */
 381         {13, 0x53, 1344}, /* 0000 0010 1001 1 */
 382         {13, 0x54, 1408}, /* 0000 0010 1010 0 */
 383         {13, 0x55, 1472}, /* 0000 0010 1010 1 */
 384         {13, 0x5a, 1536}, /* 0000 0010 1101 0 */
 385         {13, 0x5b, 1600}, /* 0000 0010 1101 1 */
 386         {13, 0x64, 1664}, /* 0000 0011 0010 0 */
 387         {13, 0x65, 1728}, /* 0000 0011 0010 1 */
 388         {13, 0x6c, 512}, /* 0000 0011 0110 0 */
 389         {13, 0x6d, 576}, /* 0000 0011 0110 1 */
 390         {13, 0x72, 896}, /* 0000 0011 1001 0 */
 391         {13, 0x73, 960}, /* 0000 0011 1001 1 */
 392         {13, 0x74, 1024}, /* 0000 0011 1010 0 */
 393         {13, 0x75, 1088}, /* 0000 0011 1010 1 */
 394         {13, 0x76, 1152}, /* 0000 0011 1011 0 */
 395         {13, 0x77, 1216} /* 0000 0011 1011 1 */
 396 };
 397
 398 static Tab faxcodes[Nfaxcodes] = {
 399         {1, 0x1, 0}, /* 1 */
 400         {3, 0x1, 0}, /* 001 */
 401         {3, 0x2, 0}, /* 010 */
 402         {3, 0x3, 0}, /* 011 */
 403         {4, 0x1, 0}, /* 0001 */
 404         {6, 0x2, 0}, /* 0000 10 */
 405         {6, 0x3, 0}, /* 0000 11 */
 406         {7, 0x2, 0}, /* 0000 010 */
 407         {7, 0x3, 0}, /* 0000 011 */
 408         {12, 0x1, -1} /* 0000 0000 0001 */
 409 };
 410
 411 static int typesizes[] = {0, 1, 0, 2, 4};
 412 static int vcodeval[] = {0, 0, 0, 1, 0, 0, 2, 3};
 413
 414 static ulong byte2le(uchar *);
 415 static ulong byte4le(uchar *);
 416 static ulong byte2be(uchar *);
 417 static ulong byte4be(uchar *);
 418 static void readdata(Tif *, ulong);
 419 static void readnbytes(Tif *, ulong);
 420 static ulong readbyte(Tif *);
 421 static ulong readshort(Tif *);
 422 static ulong readlong(Tif *);
 423 static int gototif(Tif *, ulong);
 424 static int readheader(Tif *);
 425 static uchar *nocomp(Tif *);
 426 static int getbit1(Fax *);
 427 static int getbit2(Fax *);
 428 static Tab *findtab(Fax *, int, int, Tab *, int);
 429 static Tab *gettab(Fax *, int);
 430 static Tab *geteol(Fax *);
 431 static int faxfill(Fax *, uchar *, ulong, ulong *, ulong *, ulong, int);
 432 static void fillbits(Fax *);
 433 static int faxalloclines(Fax *);
 434 static Tab *getfax1d(Fax *, uchar *, ulong, ulong *, ulong *, ulong);
 435 static Tab *getfax2d(Fax *, uchar *, ulong, ulong *, ulong *, ulong);
 436 static int faxstrip(Tif *, Fax *, uchar *, ulong, ulong *);
 437 static uchar *fax(Tif *);
 438 static void tabinit(Lzw *);
 439 static Code *newcode(Lzw *, Code *);
 440 static void listadd(Lzw *, Code *);
 441 static Code *tabadd(Lzw *, Code *, Code *);
 442 static int getcode(Lzw *);
 443 static int wstr(uchar *, ulong, ulong *, Code *, long *);
 444 static void predict(Tif *, uchar *);
 445 static int lzwstrip(Lzw *, uchar *, ulong, ulong *, long);
 446 static uchar *lzw(Tif *);
 447 static uchar *packbits(Tif *);
 448 static int faxdecode(Tif *, Rawimage *, uchar *);
 449 static int greydecode(Tif *, Rawimage *, uchar *);
 450 static int rgbdecode(Tif *, Rawimage *, uchar *);
 451 static int paldecode(Tif *, Rawimage *, uchar *);
 452 static int parsefield(Tif *, Fld *);
 453 static int readfield(Tif *, Fld *);
 454 static int checkfields(Tif *);
 455 static int readstrips(Tif *);
 456 static Rawimage *decode(Tif *);
 457 static void freefields(Tif *);
 458 static Rawimage *readslave(Tif *);
 459
 460 static ulong
 461 byte2le(uchar *buf)
 462 {
 463         return (buf[1] << 8) | buf[0];
 464 }
 465
 466 static ulong
 467 byte4le(uchar *buf)
 468 {
 469         return (byte2le(buf+2) << 16) | byte2le(buf);
 470 }
 471
 472 static ulong
 473 byte2be(uchar *buf)
 474 {
 475         return (buf[0] << 8) | buf[1];
 476 }
 477
 478 static ulong
 479 byte4be(uchar *buf)
 480 {
 481         return (byte2be(buf) << 16) | byte2be(buf+2);
 482 }
 483
 484 static void
 485 readdata(Tif *t, ulong offset)
 486 {
 487         long n, m;
 488         ulong size;
 489
 490         if(offset < t->nbuf)
 491                 offset = t->nbuf;
 492         m = offset + 4096 - t->nbuf;
 493         size = (m + t->nbuf) * sizeof *t->buf;
 494         if(t->buf == nil) {
 495                 if((t->buf = malloc(size)) == nil)
 496                         sysfatal("malloc: %r");
 497         } else {
 498                 if((t->buf = realloc(t->buf, size)) == nil)
 499                         sysfatal("realloc: %r");
 500         }
 501         if((n = Bread(t->fd, t->buf+t->nbuf, m)) < 0)
 502                 sysfatal("Bread: %r");
 503         if(n != m)
 504                 t->eof = 1;
 505         t->nbuf += n;
 506 }
 507
 508 static void
 509 readnbytes(Tif *t, ulong n)
 510 {
 511         if(n <= 0 || n > 4)
 512                 sysfatal("cannot read %lud bytes", n);
 513         if(t->n+n > t->nbuf) {
 514                 if(t->eof)
 515                         sysfatal("reached end of file");
 516                 readdata(t, 0);
 517         }
 518         memmove(t->tmp, t->buf+t->n, n);
 519         t->n += n;
 520 }
 521
 522 static ulong
 523 readbyte(Tif *t)
 524 {
 525         readnbytes(t, 1);
 526         return t->tmp[0];
 527 }
 528
 529 static ulong
 530 readshort(Tif *t)
 531 {
 532         readnbytes(t, 2);
 533         return (*t->byte2)(t->tmp);
 534 }
 535
 536 static ulong
 537 readlong(Tif *t)
 538 {
 539         readnbytes(t, 4);
 540         return (*t->byte4)(t->tmp);
 541 }
 542
 543 static int
 544 gototif(Tif *t, ulong n)
 545 {
 546         if(n < 8) {
 547                 werrstr("offset pointing to header");
 548                 return -1;
 549         }
 550         if(n > t->nbuf)
 551                 readdata(t, n);
 552         t->n = n;
 553         return 0;
 554 }
 555
 556 static int
 557 readheader(Tif *t)
 558 {
 559         uint n;
 560
 561         t->end = readshort(t);
 562         switch(t->end) {
 563         case II:
 564                 break;
 565         case MM:
 566                 t->byte2 = byte2be;
 567                 t->byte4 = byte4be;
 568                 break;
 569         default:
 570                 werrstr("illegal byte order: %#.4x", t->end);
 571                 return -1;
 572         }
 573         if((n = readshort(t)) != TIF) {
 574                 werrstr("illegal tiff magic: %#.4x", n);
 575                 return -1;
 576         }
 577         t->off = readlong(t);
 578         return gototif(t, t->off);
 579 }
 580
 581 static uchar *
 582 nocomp(Tif *t)
 583 {
 584         return t->data;
 585 }
 586
 587 static int
 588 getbit1(Fax *f)
 589 {
 590         int bit;
 591
 592         if(f->n >= f->next)
 593                 return -1;
 594         bit = (f->data[f->n] >> f->m) & 0x1;
 595         f->m--;
 596         if(f->m < 0) {
 597                 f->n++;
 598                 f->m = 7;
 599         }
 600         return bit;
 601 }
 602
 603 static int
 604 getbit2(Fax *f)
 605 {
 606         int bit;
 607
 608         if(f->n >= f->next)
 609                 return -1;
 610         bit = (f->data[f->n] >> f->m) & 0x1;
 611         f->m++;
 612         if(f->m >= 8) {
 613                 f->n++;
 614                 f->m = 0;
 615         }
 616         return bit;
 617 }
 618
 619 static Tab *
 620 findtab(Fax *f, int code, int len, Tab *tab, int max)
 621 {
 622         Tab *p;
 623
 624         while(f->ntab < max) {
 625                 p = &tab[f->ntab];
 626                 if(p->len > len)
 627                         break;
 628                 if(p->code == code) {
 629                         f->ntab = 0;
 630                         return p;
 631                 }
 632                 f->ntab++;
 633         }
 634         return nil;
 635 }
 636
 637 static Tab *
 638 gettab(Fax *f, int mode)
 639 {
 640         int i, n, maxlen, bit, code;
 641         Tab *p, *tab;
 642
 643         code = 0;
 644         if(mode) {
 645                 n = Nfaxcodes;
 646                 tab = faxcodes;
 647         } else {
 648                 n = Nfaxtab;
 649                 tab = f->tab[f->st];
 650         }
 651         maxlen = tab[n-1].len;
 652         for(i = 1; i <= maxlen; i++) {
 653                 if((bit = (*f->getbit)(f)) < 0) {
 654                         f->st = -1;
 655                         return nil;
 656                 }
 657                 code = (code << 1) | bit;
 658                 if((p = findtab(f, code, i, tab, n)) != nil)
 659                         return p;
 660         }
 661         werrstr("code not found");
 662         return nil;
 663 }
 664
 665 static Tab *
 666 geteol(Fax *f)
 667 {
 668         int i, bit;
 669         Tab *p;
 670
 671         if(f->eol == nil) {
 672                 if((p = gettab(f, 0)) == nil || p->run >= 0) {
 673                         werrstr("first eol");
 674                         return nil;
 675                 }
 676                 f->eol = p;
 677                 return p;
 678         }
 679         for(i = 0; (bit = (*f->getbit)(f)) == 0; i++)
 680                 ;
 681         if(bit < 0) {
 682                 f->st = -1;
 683                 return nil;
 684         }
 685         if(i < 11) {
 686                 werrstr("eol");
 687                 return nil;
 688         }
 689         return f->eol;
 690 }
 691
 692 static int
 693 faxfill(Fax *f, uchar *data, ulong size, ulong *i, ulong *x, ulong dx,
 694         int n)
 695 {
 696         if((*x += n) > dx) {
 697                 werrstr("fax row overflow");
 698                 return -1;
 699         }
 700         if((*i += n) >= size) {
 701                 werrstr("fax data overflow");
 702                 return -1;
 703         }
 704         if(f->st != 0)
 705                 memset(data+*i-n, f->st, n);
 706         return 0;
 707 }
 708
 709 static void
 710 fillbits(Fax *f)
 711 {
 712         if(f->getbit == getbit1) {
 713                 if(f->m != 7) {
 714                         f->n++;
 715                         f->m = 7;
 716                 }
 717         } else {
 718                 if(f->m != 0) {
 719                         f->n++;
 720                         f->m = 0;
 721                 }
 722         }
 723 }
 724
 725 static int
 726 faxalloclines(Fax *f)
 727 {
 728         f->nl *= 2;
 729         f->l1 = realloc(f->l1, f->nl*sizeof *f->l1);
 730         if(f->l1 == nil)
 731                 return -1;
 732         f->l2 = realloc(f->l2, f->nl*sizeof *f->l2);
 733         if(f->l2 == nil) {
 734                 free(f->l1);
 735                 return -1;
 736         }
 737         return 0;
 738 }
 739
 740 static Tab *
 741 getfax1d(Fax *f, uchar *data, ulong size, ulong *i, ulong *x,
 742         ulong dx)
 743 {
 744         int j, n;
 745         Tab *p;
 746
 747         for(j = 0; *x < dx;) {
 748                 if((p = gettab(f, 0)) == nil)
 749                         return nil;
 750                 if((n = p->run) < 0) {
 751                         f->l1[j] = dx;
 752                         return f->eol;
 753                 }
 754                 if(faxfill(f, data, size, i, x, dx, n) < 0)
 755                         return nil;
 756                 if(n < 64) {
 757                         f->l1[j++] = *x;
 758                         f->st ^= 1;
 759                 }
 760                 if(j >= f->nl)
 761                         faxalloclines(f);
 762         }
 763         return nil;
 764 }
 765
 766 static Tab *
 767 getfax2d(Fax *f, uchar *data, ulong size, ulong *i, ulong *x,
 768         ulong dx)
 769 {
 770         int j, k, n, code, len, a0, a1, b1, b2, v;
 771         Tab *p;
 772
 773         a0 = -1;
 774         for(j = 0; *x < dx;) {
 775                 for(k = 0;; k++) {
 776                         b1 = f->l1[k];
 777                         if(b1 > a0 && f->st == k%2)
 778                                 break;
 779                         if(b1 >= dx)
 780                                 break;
 781                 }
 782                 if((b2 = b1) < dx)
 783                         b2 = f->l1[k+1];
 784                 if((p = gettab(f, 1)) == nil)
 785                         return nil;
 786                 /* early eofb */
 787                 if(p->run < 0) {
 788                         f->st = -1;
 789                         return nil;
 790                 }
 791                 len = p->len;
 792                 code = p->code;
 793                 if(code == 1 && len == 3) {
 794                         /* horizontal */
 795                         for(k = 0; k < 2;) {
 796                                 if((p = gettab(f, 0)) == nil)
 797                                         return nil;
 798                                 n = p->run;
 799                                 if(faxfill(f, data, size, i, x,
 800                                         dx, n) < 0)
 801                                         return nil;
 802                                 if(n < 64) {
 803                                         f->l2[j++] = *x;
 804                                         f->st ^= 1;
 805                                         k++;
 806                                 }
 807                         }
 808                 } else if(code == 1 && len == 4) {
 809                         /* pass */
 810                         n = b2 - *x;
 811                         if(faxfill(f, data, size, i, x, dx, n) < 0)
 812                                 return nil;
 813                         if(*x == dx)
 814                                 f->l2[j++] = *x;
 815                 } else {
 816                         /* vertical */
 817                         switch(code) {
 818                         case 1:
 819                         case 2:
 820                                 v = -vcodeval[len];
 821                                 break;
 822                         case 3:
 823                                 v = vcodeval[len];
 824                                 break;
 825                         default:
 826                                 werrstr("mode");
 827                                 return nil;
 828                         }
 829                         a1 = b1 + v;
 830                         n = a1 - *x;
 831                         if(faxfill(f, data, size, i, x, dx, n) < 0)
 832                                 return nil;
 833                         f->l2[j++] = *x;
 834                         f->st ^= 1;
 835                 }
 836                 if(j >= f->nl)
 837                         faxalloclines(f);
 838                 a0 = *x;
 839         }
 840         memmove(f->l1, f->l2, j*sizeof *f->l1);
 841         return nil;
 842 }
 843
 844 static int
 845 faxstrip(Tif *t, Fax *f, uchar *data, ulong size, ulong *i)
 846 {
 847         int d1;
 848         ulong x, y;
 849         Tab *p;
 850
 851         d1 = t->comp != T6enc;
 852         p = nil;
 853         for(x = y = 0; x < t->dx || y < t->rows;) {
 854                 f->st = 0;
 855                 if(t->comp == T4enc) {
 856                         if(p == nil && geteol(f) == nil) {
 857                                 if(f->st >= 0)
 858                                         return -1;
 859                                 break;
 860                         }
 861                         if(y > 0)
 862                                 *i += t->dx - x;
 863                         if(t->t4 & 1) {
 864                                 d1 = (*f->getbit)(f);
 865                                 if(d1 < 0)
 866                                         break;
 867                         }
 868                 }
 869                 x = 0;
 870                 y++;
 871                 if(d1) {
 872                         p = getfax1d(f, data, size, i,
 873                                 &x, t->dx);
 874                 } else {
 875                         p = getfax2d(f, data, size, i,
 876                                 &x, t->dx);
 877                 }
 878                 if(t->comp == Huffman)
 879                         fillbits(f);
 880                 if(p == nil && x != t->dx) {
 881                         if(f->st >= 0 || x > t->dx)
 882                                 return -1;
 883                         break;
 884                 }
 885         }
 886         return 0;
 887 }
 888
 889 /*
 890 * the t4 fax test images i decoded did not follow the
 891 * spec. in particular, they did not have rtcs.
 892 */
 893 static uchar *
 894 fax(Tif *t)
 895 {
 896         int m;
 897         ulong i, j, datasz, linesz;
 898         uchar *data;
 899         Fax f;
 900
 901         datasz = t->dx * t->dy * sizeof *data;
 902         data = malloc(datasz);
 903         f.nl = t->dx;
 904         linesz = f.nl * sizeof *f.l1;
 905         f.l1 = malloc(linesz);
 906         f.l2 = malloc(linesz);
 907         if(data == nil || f.l1 == nil || f.l2 == nil) {
 908                 free(t->data);
 909                 if(data != nil)
 910                         free(data);
 911                 if(f.l1 != nil)
 912                         free(f.l1);
 913                 if(f.l2 != nil)
 914                         free(f.l2);
 915                 return nil;
 916         }
 917         memset(data, 0, datasz);
 918         memset(f.l1, 0, linesz);
 919         memset(f.l2, 0, linesz);
 920         if(t->fill == 1) {
 921                 f.getbit = getbit1;
 922                 m = 7;
 923         } else {
 924                 f.getbit = getbit2;
 925                 m = 0;
 926         }
 927         f.tab[0] = faxwhite;
 928         f.tab[1] = faxblack;
 929         f.ntab = 0;
 930         f.eol = nil;
 931         f.data = t->data;
 932         for(i = j = 0; i < t->nstrips; i++) {
 933                 f.l1[0] = t->dx;
 934                 f.n = t->strips[i];
 935                 f.m = m;
 936                 if(i < t->nstrips-1)
 937                         f.next = t->strips[i+1];
 938                 else
 939                         f.next = t->ndata;
 940                 if(faxstrip(t, &f, data, datasz, &j) < 0)
 941                         break;
 942         }
 943         if(i < t->nstrips) {
 944                 free(data);
 945                 data = nil;
 946         }
 947         free(t->data);
 948         free(f.l1);
 949         free(f.l2);
 950         return data;
 951 }
 952
 953 static void
 954 tabinit(Lzw *l)
 955 {
 956         l->ntab = Eoicode + 1;
 957         l->len = 9;
 958 }
 959
 960 static Code *
 961 newcode(Lzw *l, Code *p)
 962 {
 963         Code *q;
 964
 965         if(p == nil)
 966                 return nil;
 967         if(l->first != nil) {
 968                 q = l->first;
 969                 if((l->first = l->first->next) == nil)
 970                         l->last = nil;
 971         } else if((q = malloc(sizeof *q)) == nil)
 972                 return nil;
 973         q->val = p->val;
 974         q->next = nil;
 975         return q;
 976 }
 977
 978 static void
 979 listadd(Lzw *l, Code *p)
 980 {
 981         if(p == nil)
 982                 return;
 983         if(l->last != nil)
 984                 l->last->next = p;
 985         else
 986                 l->first = l->last = p;
 987         while(l->last->next != nil)
 988                 l->last = l->last->next;
 989 }
 990
 991 static Code *
 992 tabadd(Lzw *l, Code *p, Code *q)
 993 {
 994         Code *r, *s;
 995
 996         if(l->ntab >= Tabsz) {
 997                 werrstr("lzw table full");
 998                 return nil;
 999         }
1000         r = s = &l->tab[l->ntab++];
1001         switch(l->ntab) {
1002         case 511:
1003         case 1023:
1004         case 2047:
1005                 l->len++;
1006                 break;
1007         default:
1008                 break;
1009         }
1010         s->val = p->val;
1011         while((p = p->next) != nil) {
1012                 if(s->next != nil)
1013                         s->next->val = p->val;
1014                 else if((s->next = newcode(l, p)) == nil)
1015                         return nil;
1016                 s = s->next;
1017         }
1018         if(s->next != nil) {
1019                 s->next->val = q->val;
1020                 s = s->next;
1021                 if(s->next != nil) {
1022                         listadd(l, s->next);
1023                         s->next = nil;
1024                 }
1025         } else if((s->next = newcode(l, q)) == nil)
1026                 return nil;
1027         return r;
1028 }
1029
1030 static int
1031 getcode(Lzw *l)
1032 {
1033         int i, c, code;
1034
1035         if(l->n >= l->next) {
1036                 werrstr("lzw eof");
1037                 return -1;
1038         }
1039         code = 0;
1040         for(i = l->len-1; i >= 0; i--) {
1041                 c = (l->data[l->n] >> l->m) & 0x1;
1042                 code |= c << i;
1043                 l->m--;
1044                 if(l->m < 0) {
1045                         l->n++;
1046                         l->m = 7;
1047                 }
1048         }
1049         return code;
1050 }
1051
1052 static int
1053 wstr(uchar *data, ulong size, ulong *i, Code *p, long *striplen)
1054 {
1055         for(; p != nil; p = p->next, ++*i, --*striplen) {
1056                 if(*i >= size || *striplen < 0) {
1057                         werrstr("lzw overflow");
1058                         return -1;
1059                 }
1060                 data[*i] = p->val;
1061         }
1062         return 0;
1063 }
1064
1065 static void
1066 predict(Tif *t, uchar *data)
1067 {
1068         char a, b;
1069         ulong y, x, i, j, k, s;
1070
1071         s = t->samples;
1072         for(y = 0; y < t->dy; y++) {
1073                 for(x = 1; x < t->dx; x++) {
1074                         i = y*t->dx + x;
1075                         for(j = 0; j < s; j++) {
1076                                 k = i*s + j;
1077                                 a = (char)data[k];
1078                                 b = (char)data[k-s];
1079                                 data[k] = (uchar)(a + b);
1080                         }
1081                 }
1082         }
1083 }
1084
1085 static int
1086 lzwstrip(Lzw *l, uchar *data, ulong size, ulong *i, long striplen)
1087 {
1088         int c, oc;
1089         Code *p, *q;
1090
1091         if((c = getcode(l)) != Clrcode) {
1092                 werrstr("clear code");
1093                 return -1;
1094         }
1095         for(oc = -1; c != Eoicode;) {
1096                 if(c < 0)
1097                         return -1;
1098                 if(c == Clrcode) {
1099                         if(oc >= 0)
1100                                 tabinit(l);
1101                         if((c = getcode(l)) == Eoicode)
1102                                 break;
1103                         if(c < 0)
1104                                 return -1;
1105                         if(wstr(data, size, i, &l->tab[c],
1106                                 &striplen) < 0)
1107                                 return -1;
1108                 } else if(c < l->ntab) {
1109                         p = &l->tab[c];
1110                         if(wstr(data, size, i, p,
1111                                 &striplen) < 0)
1112                                 return -1;
1113                         q = &l->tab[oc];
1114                         if(tabadd(l, q, p) == nil)
1115                                 return -1;
1116                 } else {
1117                         q = &l->tab[oc];
1118                         if((p = tabadd(l, q, q)) == nil)
1119                                 return -1;
1120                         if(wstr(data, size, i, p,
1121                                 &striplen) < 0)
1122                                 return -1;
1123                 }
1124                 if(striplen <= 0)
1125                         break;
1126                 oc = c;
1127                 c = getcode(l);
1128         }
1129         return 0;
1130 }
1131
1132 static uchar *
1133 lzw(Tif *t)
1134 {
1135         ulong i, j, size;
1136         long striplen;
1137         uchar *data;
1138         Lzw l;
1139         Code *p, *q;
1140
1141         i = t->dx * t->rows * t->depth;
1142         striplen = i%8 == 0? i/8: i/8+1;
1143         size = t->nstrips * striplen * sizeof *data;
1144         if((data = malloc(size)) == nil) {
1145                 free(t->data);
1146                 return nil;
1147         }
1148         for(i = 0; i < Tabsz; i++) {
1149                 l.tab[i].val = i;
1150                 l.tab[i].next = nil;
1151         }
1152         l.data = t->data;
1153         l.first = l.last = nil;
1154         for(i = j = 0; i < t->nstrips; i++) {
1155                 tabinit(&l);
1156                 l.n = t->strips[i];
1157                 l.m = 7;
1158                 if(i < t->nstrips-1)
1159                         l.next = t->strips[i+1];
1160                 else
1161                         l.next = t->ndata;
1162                 if(lzwstrip(&l, data, size, &j, striplen) < 0)
1163                         break;
1164         }
1165         if(i < t->nstrips) {
1166                 free(data);
1167                 data = nil;
1168         }
1169         for(i = 0; i < Tabsz; i++) {
1170                 for(p = l.tab[i].next; (q = p) != nil;) {
1171                         p = p->next;
1172                         free(q);
1173                 }
1174         }
1175         for(p = l.first; (q = p) != nil;) {
1176                 p = p->next;
1177                 free(q);
1178         }
1179         free(t->data);
1180         if(data != nil && t->predictor == 2)
1181                 predict(t, data);
1182         return data;
1183 }
1184
1185 static uchar *
1186 packbits(Tif *t)
1187 {
1188         char n;
1189         ulong i, j, k, size;
1190         uchar *data;
1191
1192         size = t->dx * t->dy * t->samples * sizeof *data;
1193         if((data = malloc(size)) == nil) {
1194                 free(t->data);
1195                 return nil;
1196         }
1197         for(i = 0, j = 0; i < t->ndata;) {
1198                 n = (char)t->data[i++];
1199                 if(n >= 0) {
1200                         k = n + 1;
1201                         if(j+k >= size || i+k >= t->ndata)
1202                                 break;
1203                         memmove(data+j, t->data+i, k);
1204                         i += k;
1205                         j += k;
1206                 } else if(n > -128 && n < 0) {
1207                         k = j - n + 1;
1208                         if(k > size || i >= t->ndata)
1209                                 break;
1210                         for(; j < k; j++)
1211                                 data[j] = t->data[i];
1212                         i++;
1213                 }
1214         }
1215         if(i < t->ndata) {
1216                 werrstr("packbits overflow");
1217                 free(data);
1218                 data = nil;
1219         }
1220         free(t->data);
1221         return data;
1222 }
1223
1224 static int
1225 faxdecode(Tif *t, Rawimage *im, uchar *data)
1226 {
1227         ulong n;
1228
1229         for(n = 0; n < im->chanlen; n++) {
1230                 if(t->photo == Whitezero)
1231                         data[n] ^= 1;
1232                 im->chans[0][n] = data[n] * 0xff;
1233         }
1234         return 0;
1235 }
1236
1237 static int
1238 greydecode(Tif *t, Rawimage *im, uchar *data)
1239 {
1240         int pix, pmask, xmask;
1241         ulong i, n, x, y;
1242
1243         pmask = (1 << t->depth) - 1;
1244         xmask = 7 >> log2[t->depth];
1245         for(y = 0, n = 0; y < t->dy; y++) {
1246                 i = y * bytesperline(im->r, t->depth);
1247                 for(x = 0; x < t->dx; x++, n++) {
1248                         if(n >= im->chanlen) {
1249                                 werrstr("grey overflow");
1250                                 return -1;
1251                         }
1252                         pix = (data[i] >> t->depth*((xmask -
1253                                 x) & xmask)) & pmask;
1254                         if(((x + 1) & xmask) == 0)
1255                                 i++;
1256                         if(t->photo == Whitezero)
1257                                 pix ^= pmask;
1258                         pix = (pix * 0xff) / pmask;
1259                         im->chans[0][n] = pix;
1260                 }
1261         }
1262         return 0;
1263 }
1264
1265 static int
1266 rgbdecode(Tif *t, Rawimage *im, uchar *data)
1267 {
1268         ulong i, n, x, y;
1269
1270         for(y = 0, n = 0; y < t->dy; y++) {
1271                 for(x = 0; x < t->dx; x++, n += 3) {
1272                         if(n >= im->chanlen) {
1273                                 werrstr("rgb overflow");
1274                                 return -1;
1275                         }
1276                         i = (y*t->dx + x) * 3;
1277                         im->chans[0][n] = data[i+2];
1278                         im->chans[0][n+1] = data[i+1];
1279                         im->chans[0][n+2] = data[i];
1280                 }
1281         }
1282         return 0;
1283 }
1284
1285 static int
1286 paldecode(Tif *t, Rawimage *im, uchar *data)
1287 {
1288         int pix, pmask, xmask;
1289         ulong i, n, x, y, *r, *g, *b;
1290
1291         pmask = (1 << t->depth) - 1;
1292         xmask = 7 >> log2[t->depth];
1293         r = t->color;
1294         g = r + pmask + 1;
1295         b = g + pmask + 1;
1296         for(y = 0, n = 0; y < t->dy; y++) {
1297                 i = y * bytesperline(im->r, t->depth);
1298                 for(x = 0; x < t->dx; x++, n += 3) {
1299                         if(n >= im->chanlen) {
1300                                 werrstr("palette overflow");
1301                                 return -1;
1302                         }
1303                         pix = (data[i] >> t->depth*((xmask -
1304                                 x) & xmask)) & pmask;
1305                         if(((x + 1) & xmask) == 0)
1306                                 i++;
1307                         im->chans[0][n] = b[pix];
1308                         im->chans[0][n+1] = g[pix];
1309                         im->chans[0][n+2] = r[pix];
1310                 }
1311         }
1312         return 0;
1313 }
1314
1315 static int
1316 parsefield(Tif *t, Fld *f)
1317 {
1318         ulong v;
1319
1320         v = f->val[0];
1321         switch(f->tag) {
1322         case Width:
1323                 t->dx = v;
1324                 break;
1325         case Length:
1326                 t->dy = v;
1327                 break;
1328         case Bits:
1329                 t->depth = v;
1330                 if(f->cnt == 3)
1331                         t->depth += f->val[1] + f->val[2];
1332                 break;
1333         case Compression:
1334                 t->comp = v;
1335                 break;
1336         case Photometric:
1337                 t->photo = v;
1338                 switch(t->photo) {
1339                 case Whitezero:
1340                 case Blackzero:
1341                         t->decode = greydecode;
1342                         break;
1343                 case Rgb:
1344                         t->decode = rgbdecode;
1345                         break;
1346                 case Palette:
1347                         t->decode = paldecode;
1348                         break;
1349                 default:
1350                         break;
1351                 }
1352                 break;
1353         case Strips:
1354                 t->strips = f->val;
1355                 t->nstrips = f->cnt;
1356                 break;
1357         case Fill:
1358                 t->fill = v;
1359                 break;
1360         case Orientation:
1361                 t->orientation = v;
1362                 break;
1363         case Samples:
1364                 t->samples = v;
1365                 break;
1366         case Rows:
1367                 t->rows = v;
1368                 break;
1369         case Counts:
1370                 t->counts = f->val;
1371                 t->ncounts = f->cnt;
1372                 break;
1373         case Planar:
1374                 t->planar = v;
1375                 break;
1376         case T4opts:
1377                 t->t4 = v;
1378                 break;
1379         case T6opts:
1380                 t->t6 = v;
1381                 break;
1382         case Predictor:
1383                 t->predictor = v;
1384                 break;
1385         case Color:
1386                 t->color = f->val;
1387                 t->ncolor = f->cnt;
1388                 break;
1389         default:
1390                 werrstr("shouldn't reach");
1391                 return -1;
1392         }
1393         return 0;
1394 }
1395
1396 static int
1397 readfield(Tif *t, Fld *f)
1398 {
1399         int size;
1400         ulong i, j, n, off;
1401         ulong (*readval)(Tif *);
1402
1403         f->tag = readshort(t);
1404         f->typ = readshort(t);
1405         f->cnt = readlong(t);
1406         f->val = nil;
1407         switch(f->tag) {
1408         case Width:
1409         case Length:
1410         case Compression:
1411         case Photometric:
1412         case Fill:
1413         case Orientation:
1414         case Samples:
1415         case Rows:
1416         case Planar:
1417         case T4opts:
1418         case T6opts:
1419         case Predictor:
1420                 if(f->cnt != 1) {
1421                         werrstr("field count");
1422                         return -1;
1423                 }
1424                 break;
1425         case Bits:
1426                 if(f->cnt != 1 && f->cnt != 3) {
1427                         werrstr("field count");
1428                         return -1;
1429                 }
1430                 break;
1431         case Strips:
1432         case Counts:
1433         case Color:
1434                 break;
1435         default:
1436                 readlong(t);
1437                 return 0;
1438         }
1439         switch(f->typ) {
1440         case Byte:
1441                 readval = readbyte;
1442                 break;
1443         case Short:
1444                 readval = readshort;
1445                 break;
1446         case Long:
1447                 readval = readlong;
1448                 break;
1449         default:
1450                 werrstr("unsupported type\n");
1451                 return -1;
1452         }
1453         if((f->val = malloc(f->cnt*sizeof *f->val)) == nil)
1454                 return -1;
1455         size = typesizes[f->typ];
1456         if((n = size*f->cnt) <= 4) {
1457                 for(i = 0; i < f->cnt; i++)
1458                         f->val[i] = readval(t);
1459                 f->off = 0x0;
1460                 f->nval = i;
1461                 for(j = n; j < 4; j += size)
1462                         readval(t);
1463         } else {
1464                 f->off = readlong(t);
1465                 off = t->n;
1466                 if(gototif(t, f->off) < 0)
1467                         return -1;
1468                 for(i = 0; i < f->cnt; i++)
1469                         f->val[i] = readval(t);
1470                 f->nval = i;
1471                 if(gototif(t, off) < 0)
1472                         return -1;
1473         }
1474         return parsefield(t, f);
1475 }
1476
1477 static int
1478 checkfields(Tif *t)
1479 {
1480         double a, b;
1481         ulong n, size;
1482
1483         if(t->dx == 0) {
1484                 werrstr("image width");
1485                 return -1;
1486         }
1487         if(t->dy == 0) {
1488                 werrstr("image length");
1489                 return -1;
1490         }
1491         switch(t->depth) {
1492         case 1:
1493         case 4:
1494         case 8:
1495         case 24:
1496                 break;
1497         default:
1498                 werrstr("bits per sample");
1499                 return -1;
1500         }
1501         switch(t->comp) {
1502         case Nocomp:
1503                 t->uncompress = nocomp;
1504                 break;
1505         case Huffman:
1506         case T4enc:
1507         case T6enc:
1508                 t->uncompress = fax;
1509                 if(t->decode != nil)
1510                         t->decode = faxdecode;
1511                 if((t->comp == T4enc && t->t4 & (1<<1)) ||
1512                         (t->comp == T6enc &&
1513                         t->t6 & (1<<1))) {
1514                         werrstr("uncompressed mode");
1515                         return -1;
1516                 }
1517                 break;
1518         case Lzwenc:
1519                 t->uncompress = lzw;
1520                 break;
1521         case Packbits:
1522                 t->uncompress = packbits;
1523                 break;
1524         default:
1525                 werrstr("compression");
1526                 return -1;
1527         }
1528         if(t->decode == nil) {
1529                 werrstr("photometric interpretation");
1530                 return -1;
1531         }
1532         if(t->depth > 1 && (t->comp == Huffman ||
1533                 t->comp == T4enc || t->comp == T6enc)) {
1534                 werrstr("compression");
1535                 return -1;
1536         }
1537         if(t->fill != 1 && t->fill != 2) {
1538                 werrstr("fill order");
1539                 return -1;
1540         }
1541         if(t->fill == 2 && t->depth != 1) {
1542                 werrstr("depth should be 1 with fill order 2");
1543                 return -1;
1544         }
1545         if(t->orientation != 1) {
1546                 werrstr("orientation");
1547                 return -1;
1548         }
1549         if(t->rows == 0) {
1550                 werrstr("rows per strip");
1551                 return -1;
1552         }
1553         a = (double)t->dy;
1554         b = (double)t->rows;
1555         n = (ulong)floor((a+b-1)/b);
1556         if(t->strips == nil || t->nstrips != n) {
1557                 werrstr("strip offsets");
1558                 return -1;
1559         }
1560         if(t->samples == 1 && t->photo == Rgb) {
1561                 werrstr("not enough samples per pixel");
1562                 return -1;
1563         }
1564         if(t->samples == 3 && t->photo != Rgb) {
1565                 werrstr("too many samples per pixel");
1566                 return -1;
1567         }
1568         if(t->samples != 1 && t->samples != 3) {
1569                 werrstr("samples per pixel");
1570                 return -1;
1571         }
1572         /*
1573         * strip byte counts should not be missing,
1574         * but we can guess correctly in this case
1575         */
1576         size = sizeof *t->counts;
1577         if(t->counts == nil && t->comp == Nocomp &&
1578                 t->nstrips == 1 &&
1579                 (t->counts = malloc(size)) != nil) {
1580                 n = t->dx * t->dy * t->depth;
1581                 t->counts[0] = n%8 == 0? n/8: n/8+1;
1582                 t->ncounts = t->nstrips;
1583         }
1584         if(t->counts == nil || t->ncounts != t->nstrips) {
1585                 werrstr("strip byte counts");
1586                 return -1;
1587         }
1588         if(t->planar != 1) {
1589                 werrstr("planar configuration");
1590                 return -1;
1591         }
1592         if(t->photo == Palette && (t->color == nil ||
1593                 t->ncolor != 3*(1<<t->depth))) {
1594                 werrstr("color map");
1595                 return -1;
1596         }
1597         if(t->predictor == 2 && t->depth == 1) {
1598                 werrstr("depth too low for predictor 2");
1599                 return -1;
1600         }
1601         return 0;
1602 }
1603
1604 static int
1605 readstrips(Tif *t)
1606 {
1607         int i, j, n;
1608         ulong off;
1609
1610         t->ndata = 0;
1611         for(i = 0; i < t->nstrips; i++)
1612                 t->ndata += t->counts[i];
1613         if((t->data = malloc(t->ndata*sizeof *t->data)) == nil)
1614                 return -1;
1615         off = t->n;
1616         for(i = n = 0; i < t->nstrips; i++) {
1617                 if(gototif(t, t->strips[i]) < 0)
1618                         return -1;
1619                 /*
1620                 * we store each strip's offset in t->data
1621                 * in order to skip the final rtc or eofb
1622                 * during fax decoding. t->strips is used
1623                 * to save on memory allocation. these
1624                 * offsets are also used in lzw as a
1625                 * preventive measure.
1626                 */
1627                 t->strips[i] = n;
1628                 for(j = 0; j < t->counts[i]; j++, n++)
1629                         t->data[n] = readbyte(t);
1630         }
1631         return gototif(t, off);
1632 }
1633
1634 static Rawimage *
1635 decode(Tif *t)
1636 {
1637         ulong size;
1638         uchar *data;
1639         Rawimage *im;
1640
1641         if((im = malloc(sizeof *im)) == nil)
1642                 return nil;
1643         im->r = Rect(0, 0, t->dx, t->dy);
1644         im->cmap = nil;
1645         im->cmaplen = 0;
1646         im->chanlen = t->dx * t->dy;
1647         if(t->photo == Rgb || t->photo == Palette) {
1648                 im->chandesc = CRGB24;
1649                 im->chanlen *= 3;
1650         } else
1651                 im->chandesc = CY;
1652         im->nchans = 1;
1653         size = im->chanlen * sizeof *im->chans[0];
1654         if((im->chans[0] = malloc(size)) == nil)
1655                 return nil;
1656         /* unused members */
1657         im->fields = 0;
1658         im->gifflags = 0;
1659         im->gifdelay = 0;
1660         im->giftrindex = 0;
1661         im->gifloopcount = 1;
1662         if((data = (*t->uncompress)(t)) == nil)
1663                 return nil;
1664         if((*t->decode)(t, im, data) < 0) {
1665                 free(im->chans[0]);
1666                 free(im);
1667                 im = nil;
1668         }
1669         free(data);
1670         return im;
1671 }
1672
1673 static void
1674 freefields(Tif *t)
1675 {
1676         uint i;
1677
1678         for(i = 0; i < t->nfld; i++) {
1679                 if(t->fld[i].val != nil)
1680                         free(t->fld[i].val);
1681         }
1682         free(t->fld);
1683 }
1684
1685 static Rawimage *
1686 readslave(Tif *t)
1687 {
1688         uint i, j;
1689         Rawimage *r;
1690
1691         if(readheader(t) < 0)
1692                 return nil;
1693         if((t->nfld = readshort(t)) <= 0) {
1694                 werrstr("illegal field number: %#.4x", t->nfld);
1695                 return nil;
1696         }
1697         if((t->fld = malloc(t->nfld*sizeof *t->fld)) == nil)
1698                 return nil;
1699         for(i = 0; i < t->nfld; i++) {
1700                 if(readfield(t, &t->fld[i]) < 0) {
1701                         if(t->fld[i].val != nil)
1702                                 free(t->fld[i].val);
1703                         break;
1704                 }
1705         }
1706         if(i < t->nfld) {
1707                 for(j = 0; j < i; j++) {
1708                         if(t->fld[j].val != nil)
1709                                 free(t->fld[j].val);
1710                 }
1711                 free(t->fld);
1712                 return nil;
1713         }
1714         readlong(t);
1715         if(checkfields(t) < 0) {
1716                 freefields(t);
1717                 return nil;
1718         }
1719         if(readstrips(t) < 0) {
1720                 freefields(t);
1721                 if(t->data != nil)
1722                         free(t->data);
1723                 return nil;
1724         }
1725         free(t->buf);
1726         r = decode(t);
1727         freefields(t);
1728         return r;
1729 }
1730
1731 Rawimage **
1732 Breadtif(Biobuf *b)
1733 {
1734         Rawimage **array, *r;
1735         Tif *t;
1736
1737         if((t = malloc(sizeof *t)) == nil)
1738                 return nil;
1739         if((array = malloc(2*sizeof *array)) == nil)
1740                 return nil;
1741         t->fd = b;
1742         t->buf = nil;
1743         t->nbuf = t->eof = t->n = 0;
1744         /* order doesn't matter for the first two bytes */
1745         t->byte2 = byte2le;
1746         t->byte4 = byte4le;
1747         /* defaults */
1748         t->dx = 0;
1749         t->dy = 0;
1750         t->depth = 1;
1751         t->comp = 1;
1752         t->uncompress = nil;
1753         t->photo = 0;
1754         t->decode = nil;
1755         t->fill = 1;
1756         t->orientation = 1;
1757         t->strips = nil;
1758         t->nstrips = 0;
1759         t->samples = 1;
1760         t->rows = 0xffffffff; /* entire image is one strip */
1761         t->counts = nil;
1762         t->ncounts = 0;
1763         t->planar = 1;
1764         t->t4 = 0;
1765         t->t6 = 0;
1766         t->predictor = 1;
1767         t->color = nil;
1768         t->ncolor = 0;
1769         r = readslave(t);
1770         free(t);
1771         array[0] = r;
1772         array[1] = nil;
1773         return array;
1774 }
1775
1776 Rawimage **
1777 readtif(int fd)
1778 {
1779         Rawimage **a;
1780         Biobuf b;
1781
1782         if(Binit(&b, fd, OREAD) < 0)
1783                 return nil;
1784         a = Breadtif(&b);
1785         Bterm(&b);
1786         return a;
1787 }