/* * code/documentation from: * http://www.w3.org/Graphics/JPEG/jfif3.pdf * http://www.w3.org/Graphics/JPEG/itu-t81.pdf * http://en.wikipedia.org/wiki/JPEG * http://en.wikibooks.org/wiki/JPEG_-_Idea_and_Practice * http://code.google.com/p/go/source/browse/src/pkg/image/jpeg/writer.go * /sys/src/cmd/jpg * * fdct code from: * http://www.ijg.org/files/jpegsrc.v8c.tar.gz * http://code.google.com/p/go/source/browse/src/pkg/image/jpeg/fdct.go */ #include #include #include #include #include #include "imagefile.h" /* * imported from libdraw/arith.c to permit * extern log2 function */ static int log2[] = { -1, 0, 1, -1, 2, -1, -1, -1, 3, -1, -1, -1, -1, -1, -1, -1, 4, -1, -1, -1, -1, -1, -1, -1, 4 /* BUG */, -1, -1, -1, -1, -1, -1, -1, 5 }; /* fdct constants */ enum { Fix02 = 2446, /* 0.298631336 */ Fix03 = 3196, /* 0.390180644 */ Fix05 = 4433, /* 0.541196100 */ Fix07 = 6270, /* 0.765366865 */ Fix08 = 7373, /* 0.899976223 */ Fix11 = 9633, /* 1.175875602 */ Fix15 = 12299, /* 1.501321110 */ Fix18 = 15137, /* 1.847759065 */ Fix19 = 16069, /* 1.961570560 */ Fix20 = 16819, /* 2.053119869 */ Fix25 = 20995, /* 2.562915447 */ Fix30 = 25172 /* 3.072711026 */ }; static int zigzag[64] = { 0, 1, 5, 6, 14, 15, 27, 28, 2, 4, 7, 13, 16, 26, 29, 42, 3, 8, 12, 17, 25, 30, 41, 43, 9, 11, 18, 24, 31, 40, 44, 53, 10, 19, 23, 32, 39, 45, 52, 54, 20, 22, 33, 38, 46, 51, 55, 60, 21, 34, 37, 47, 50, 56, 59, 61, 35, 36, 48, 49, 57, 58, 62, 63 }; static int invzigzag[64] = { 0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5, 12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13, 6, 7, 14, 21, 28, 35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51, 58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63 }; /* section K.1 for quantization tables */ static int qt[2][64] = { /* luminance */ {16, 11, 10, 16, 24, 40, 51, 61, 12, 12, 14, 19, 26, 58, 60, 55, 14, 13, 16, 24, 40, 57, 69, 56, 14, 17, 22, 29, 51, 87, 80, 62, 18, 22, 37, 56, 68, 109, 103, 77, 24, 35, 55, 64, 81, 104, 113, 92, 49, 64, 78, 87, 103, 121, 120, 101, 72, 92, 95, 98, 112, 100, 103, 99}, /* chrominance */ {17, 18, 24, 47, 99, 99, 99, 99, 18, 21, 26, 66, 99, 99, 99, 99, 24, 26, 56, 99, 99, 99, 99, 99, 47, 66, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99} }; /* section K.3.3 for huffman tables */ static int dcbits[2][16] = { /* luminance */ {0x00, 0x01, 0x05, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* chrominance */ {0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00} }; static int dchuffval[2][12] = { /* luminance */ {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b}, /* chrominance */ {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b} }; static int acbits[2][16] = { /* luminance */ {0x00, 0x02, 0x01, 0x03, 0x03, 0x02, 0x04, 0x03, 0x05, 0x05, 0x04, 0x04, 0x00, 0x00, 0x01, 0x7d}, /* chrominance */ {0x00, 0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04, 0x07, 0x05, 0x04, 0x04, 0x00, 0x01, 0x02, 0x77} }; static int achuffval[2][162] = { /* luminance */ {0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07, 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08, 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0, 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa}, /* chrominance */ {0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71, 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0, 0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34, 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa} }; static int ehufcod[2][12]; /* dc codes */ static int ehufsid[2][12]; /* dc sizes */ static int ehufcoa[2][251]; /* ac codes */ static int ehufsia[2][251]; /* ac sizes */ static int byte; static int nbyte; /* utilities */ static int Bputs(Biobuf *, int); static int min(int, int); /* encoding */ static void grey2rgb(int *, int *, int *, int, int); static void rgb2ycc(int *, int *, int *, int, int, int); static void fdct(int *, int); static int csize(int, int); static void writebyte(Biobuf *); static void writebits(Biobuf *, int, int); static void writecode(Biobuf *, int, int); static int huf(Biobuf *, int *, int, int, int); static char *toycc1(int *, int *, int *, int, int, int, int, int, unsigned char *, int, int); static char *toycc2(int *, int *, int *, int, int, int, int, int, unsigned char *, int, int); static char *encode(Biobuf *, Rectangle, unsigned char *, uint32_t, int, int, int); /* huffman tables */ static void makehuf(int *, int *, int *, int *, int); /* tables, markers, headers, trailers */ static void writejfif(Biobuf *, int, int); static void writecomment(Biobuf *, char *); static void writequant(Biobuf *, int, int); static void writehuffman(Biobuf *, int, int); static void writeframe(Biobuf *, int, int, int); static void writescan(Biobuf *, int); static void writeheader(Biobuf *, int, int, char *, int, int); static void writetrailer(Biobuf *); static char *writedata(Biobuf *, Image *, Memimage *, int, int); static char *writejpg0(Biobuf *, Image *, Memimage *, Rectangle, uint32_t, char *, int, int); static int Bputs(Biobuf *b, int s) { if(Bputc(b, s>>8) < 0) return -1; return Bputc(b, s); } static int min(int a, int b) { return a < b? a: b; } static void grey2rgb(int *r, int *g, int *b, int c, int depth) { if(depth == 1) { if(c != 0) c = 0xff; } else if(depth == 2) c = (c << 6) | (c << 4) | (c << 2) | c; else c = (c << 4) | c; c = cmap2rgb(c); *r = (c >> 16) & 0xff; *g = (c >> 8) & 0xff; *b = c & 0xff; } static void rgb2ycc(int *y, int *cb, int *cr, int r, int g, int b) { *y = (int)(0.299*r + 0.587*g + 0.114*b); *cb = (int)(128.0 - 0.1687*r - 0.3313*g + 0.5*b); *cr = (int)(128.0 + 0.5*r - 0.4187*g - 0.0813*b); } /* coefficients remain scaled up by 8 at the end */ static void fdct(int *b, int sflag) { int x, y, z, tmp0, tmp1, tmp2, tmp3; int tmp10, tmp12, tmp11, tmp13; /* rows */ for(y = 0; y < 8; y++) { tmp0 = b[y*8+0] + b[y*8+7]; tmp1 = b[y*8+1] + b[y*8+6]; tmp2 = b[y*8+2] + b[y*8+5]; tmp3 = b[y*8+3] + b[y*8+4]; tmp10 = tmp0 + tmp3; tmp12 = tmp0 - tmp3; tmp11 = tmp1 + tmp2; tmp13 = tmp1 - tmp2; tmp0 = b[y*8+0] - b[y*8+7]; tmp1 = b[y*8+1] - b[y*8+6]; tmp2 = b[y*8+2] - b[y*8+5]; tmp3 = b[y*8+3] - b[y*8+4]; b[y*8+0] = (tmp10 + tmp11 - 8*128) << 2; b[y*8+4] = (tmp10 - tmp11) << 2; z = (tmp12 + tmp13) * Fix05; z += 1 << 10; b[y*8+2] = (z + tmp12*Fix07) >> 11; b[y*8+6] = (z - tmp13*Fix18) >> 11; tmp10 = tmp0 + tmp3; tmp11 = tmp1 + tmp2; tmp12 = tmp0 + tmp2; tmp13 = tmp1 + tmp3; z = (tmp12 + tmp13) * Fix11; z += 1 << 10; tmp0 *= Fix15; tmp1 *= Fix30; tmp2 *= Fix20; tmp3 *= Fix02; tmp10 *= -Fix08; tmp11 *= -Fix25; tmp12 *= -Fix03; tmp13 *= -Fix19; tmp12 += z; tmp13 += z; b[y*8+1] = (tmp0 + tmp10 + tmp12) >> 11; b[y*8+3] = (tmp1 + tmp11 + tmp13) >> 11; b[y*8+5] = (tmp2 + tmp11 + tmp12) >> 11; b[y*8+7] = (tmp3 + tmp10 + tmp13) >> 11; } /* columns */ for(x = 0; x < 8; x++) { tmp0 = b[0*8+x] + b[7*8+x]; tmp1 = b[1*8+x] + b[6*8+x]; tmp2 = b[2*8+x] + b[5*8+x]; tmp3 = b[3*8+x] + b[4*8+x]; if(sflag) tmp10 = (tmp0 + tmp3 + 1) << 1; else tmp10 = tmp0 + tmp3 + (1 << 1); tmp12 = tmp0 - tmp3; tmp11 = tmp1 + tmp2; tmp13 = tmp1 - tmp2; tmp0 = b[0*8+x] - b[7*8+x]; tmp1 = b[1*8+x] - b[6*8+x]; tmp2 = b[2*8+x] - b[5*8+x]; tmp3 = b[3*8+x] - b[4*8+x]; b[0*8+x] = (tmp10 + tmp11) >> 2; b[4*8+x] = (tmp10 - tmp11) >> 2; z = (tmp12 + tmp13) * Fix05; z += 1 << 14; b[2*8+x] = (z + tmp12*Fix07) >> 15; b[6*8+x] = (z - tmp13*Fix18) >> 15; tmp10 = tmp0 + tmp3; tmp11 = tmp1 + tmp2; tmp12 = tmp0 + tmp2; tmp13 = tmp1 + tmp3; z = (tmp12 + tmp13) * Fix11; z += 1 << 14; tmp0 *= Fix15; tmp1 *= Fix30; tmp2 *= Fix20; tmp3 *= Fix02; tmp10 *= -Fix08; tmp11 *= -Fix25; tmp12 *= -Fix03; tmp13 *= -Fix19; tmp12 += z; tmp13 += z; b[1*8+x] = (tmp0 + tmp10 + tmp12) >> 15; b[3*8+x] = (tmp1 + tmp11 + tmp13) >> 15; b[5*8+x] = (tmp2 + tmp11 + tmp12) >> 15; b[7*8+x] = (tmp3 + tmp10 + tmp13) >> 15; } } static int csize(int coeff, int ac) { int i, max; max = 1 << 10; if(!ac) max <<= 1; if(coeff < 0) coeff *= -1; if(coeff > max) sysfatal("csize: coeff too big: %d", coeff); i = ac? 1: 0; while(coeff >= (1< 10)) sysfatal("csize: invalid ac ssss: %d", i); if(!ac && (i < 0 || i > 11)) sysfatal("csize: invalid dc ssss: %d", i); return i; } static void writebyte(Biobuf *fd) { Bputc(fd, byte); if(byte == 0xff) /* byte stuffing */ Bputc(fd, 0x00); byte = 0; nbyte = 7; } static void writebits(Biobuf *fd, int co, int si) { int i, bit; for(i = si-1; i >= 0; i--) { bit = (co >> i) & 0x1; byte |= bit << nbyte; nbyte--; if(nbyte < 0) writebyte(fd); } } static void writecode(Biobuf *fd, int co, int si) { if(si > 8) { writebits(fd, co>>8, si-8); si = 8; } writebits(fd, co, si); } static int huf(Biobuf *fd, int *b, int pred, int chr, int sflag) { int k, r, s, rs, si, co, dc, diff, zz[64], p, q, z; if(sflag) { for(k = 0; k < 64; k++) { p = b[zigzag[k]]; q = qt[chr][zigzag[k]]; zz[k] = p / q; } } else { for(k = 0; k < 64; k++) { p = b[k]; q = (qt[chr][k] << 3); /* rounding */ if(p >= 0) z = (p + (q >> 1)) / q; else z = -(-p + (q >> 1)) / q; zz[zigzag[k]] = z; } } /* dc coefficient */ dc = zz[0]; zz[0] = diff = dc - pred; s = csize(diff, 0); si = ehufsid[chr][s]; co = ehufcod[chr][s]; writecode(fd, co, si); if(diff < 0) diff -= 1; writecode(fd, diff, s); /* figure F.2 */ for(k = 1, r = 0; k < 64; k++) { if(zz[k] == 0) { if(k < 63) r++; else { si = ehufsia[chr][0x00]; co = ehufcoa[chr][0x00]; writecode(fd, co, si); } } else { while(r > 15) { si = ehufsia[chr][0xf0]; co = ehufcoa[chr][0xf0]; writecode(fd, co, si); r -= 16; } /* figure F.3 */ s = csize(zz[k], 1); rs = (r << 4) | s; si = ehufsia[chr][rs]; co = ehufcoa[chr][rs]; writecode(fd, co, si); if(zz[k] < 0) zz[k] -= 1; writecode(fd, zz[k], s); r = 0; } } return dc; } static char * toycc1(int *y, int *cb, int *cr, int jx, int jy, int dx, int dy, int bpl, unsigned char *data, int ndata, int depth) { int i, j, k, l, m, n, u, v, pos, pmask, nmask, pix; int r, g, b; m = 8 / depth; pmask = (1 << depth) - 1; nmask = 7 >> log2[depth]; for(i = jy, k = 0; i < jy+8; i++) { v = min(i, dy-1); for(l = 0, j = jx/m; l < 8; l++, k++) { u = min(j, (dx-1)/m); n = l+jx >= dx? dx-jx-1: l; pos = v*bpl + u; if(pos >= ndata) return "WriteJPG: overflow"; /* thanks writeppm */ pix = (data[pos] >> depth*((nmask - n) & nmask)) & pmask; if(((n + 1) & nmask) == 0) j++; grey2rgb(&r, &g, &b, pix, depth); rgb2ycc(&y[k], &cb[k], &cr[k], r, g, b); } } return nil; } static char * toycc2(int *y, int *cb, int *cr, int jx, int jy, int dx, int dy, int bpl, unsigned char *data, int ndata, int depth) { int i, j, k, m, u, v, pos; m = depth / 8; for(i = jy, k = 0; i < jy+8; i++) { v = min(i, dy-1); for(j = jx*m; j < (jx+8)*m; j+=m, k++) { u = min(j, (dx-1)*m); pos = v*bpl + u; if(pos+m-1 >= ndata) return "WriteJPG: overflow"; rgb2ycc(&y[k], &cb[k], &cr[k], data[pos+2*m/3], data[pos+m/3], data[pos]); } } return nil; } static char * encode(Biobuf *fd, Rectangle r, unsigned char *data, uint32_t chan, int ndata, int kflag, int sflag) { int k, x, y, dx, dy, depth, bpl, ncomp; int b[3][64], pred[3]; char *err; char *(*toycc)(int *, int *, int *, int, int, int, int, int, unsigned char *, int, int); byte = 0; nbyte = 7; switch(chan) { case GREY1: case GREY2: case GREY4: toycc = toycc1; break; case GREY8: case RGB24: toycc = toycc2; break; default: return "WriteJPG: can't handle channel type"; } /* * if dx or dy is not a multiple of 8, * the decoder should continue until reaching * the last mcu, even if the extra pixels go beyond * 0xffff. they are not shown anyway. */ dx = min(Dx(r), 0xffff); dy = min(Dy(r), 0xffff); depth = chantodepth(chan); bpl = bytesperline(r, depth); ncomp = kflag? 1: 3; memset(pred, 0, sizeof pred); for(x = 0, y = 0;;) { err = (*toycc)(b[0], b[1], b[2], x, y, dx, dy, bpl, data, ndata, depth); if(err != nil) return err; for(k = 0; k < ncomp; k++) { fdct(b[k], sflag); pred[k] = huf(fd, b[k], pred[k], k>0, sflag); } if((x += 8) >= dx) { if((y += 8) >= dy) break; x = 0; } } if(nbyte < 7) { /* bit padding */ for(; nbyte >= 0; nbyte--) byte |= 0x1 << nbyte; writebyte(fd); } return err; } static void makehuf(int *ehufco, int *ehufsi, int *bits, int *huffval, int n) { int i, j, k, code, si, lastk, *huffcode, *huffsize; /* n+1 for lastk */ if((huffcode = malloc((n+1)*sizeof *huffcode)) == nil) sysfatal("malloc: %r"); if((huffsize = malloc((n+1)*sizeof *huffsize)) == nil) sysfatal("malloc: %r"); /* figure C.1 */ for(k = 0, i = 1, j = 1; i <= 16;) { if(j > bits[i-1]) { /* bits[i] in T.81: bug? */ i++; j = 1; } else { huffsize[k++] = i; j++; } } huffsize[k] = 0; lastk = k; /* figure C.2 */ for(k = 0, code = 0, si = huffsize[0];;) { do { huffcode[k++] = code++; } while(huffsize[k] == si); if(huffsize[k] == 0) break; while(huffsize[k] != si) { code <<= 1; si++; } } /* figure C.3 */ for(k = 0; k < lastk; k++) { i = huffval[k]; ehufco[i] = huffcode[k]; ehufsi[i] = huffsize[k]; } free(huffcode); free(huffsize); } static void writejfif(Biobuf *fd, int dx, int dy) { if(dx > 0xffff || dy > 0xffff) sysfatal("writejfif: dx or dy too big"); Bputs(fd, 0xffe0); Bputs(fd, 0x0010); Bputc(fd, 0x4a); Bputc(fd, 0x46); Bputc(fd, 0x49); Bputc(fd, 0x46); Bputc(fd, 0x00); Bputs(fd, 0x0102); Bputc(fd, 0x01); Bputs(fd, dx); Bputs(fd, dy); Bputc(fd, 0x00); Bputc(fd, 0x00); } static void writecomment(Biobuf *fd, char *com) { int n; if(com != nil && com[0] != '\0') { n = min(strlen(com)+2, 0xffff); Bputs(fd, 0xfffe); Bputs(fd, n); Bwrite(fd, com, n-2); } } static void writequant(Biobuf *fd, int tq, int sflag) { int i, *p, *q; if(tq != 0x0 && tq != 0x1) sysfatal("writequant: invalid Tq"); q = qt[tq]; Bputs(fd, 0xffdb); Bputs(fd, 0x0043); Bputc(fd, (0x0<<4)|tq); p = sflag? zigzag: invzigzag; for(i = 0; i < 64; i++) Bputc(fd, q[p[i]]); } static void writehuffman(Biobuf *fd, int tc, int th) { int i, n, m, *b, *hv; if((tc != 0x0 && tc != 0x1) || (th != 0x0 && th != 0x1)) sysfatal("writehuffman: invalid Tc or Th"); n = 0x0013; if(tc == 0x0) { b = dcbits[th]; hv = dchuffval[th]; m = nelem(dchuffval[th]); } else { b = acbits[th]; hv = achuffval[th]; m = nelem(achuffval[th]); } Bputs(fd, 0xffc4); Bputs(fd, n+m); Bputc(fd, (tc<<4)|th); for(i = 0; i < 16; i++) Bputc(fd, b[i]); for(i = 0; i < m; i++) Bputc(fd, hv[i]); } static void writeframe(Biobuf *fd, int y, int x, int kflag) { int n, nf; nf = kflag? 0x01: 0x03; n = 0x0008 + 0x0003*nf; Bputs(fd, 0xffc0); Bputs(fd, n); Bputc(fd, 0x08); Bputs(fd, y); Bputs(fd, x); Bputc(fd, nf); /* Y component */ Bputc(fd, 0x00); Bputc(fd, (0x1<<4)|0x1); Bputc(fd, 0x00); if(!kflag) { /* Cb component */ Bputc(fd, 0x01); Bputc(fd, (0x1<<4)|0x1); Bputc(fd, 0x01); /* Cr component */ Bputc(fd, 0x02); Bputc(fd, (0x1<<4)|0x1); Bputc(fd, 0x01); } } static void writescan(Biobuf *fd, int kflag) { int n, ns; ns = kflag? 0x01: 0x03; n = 0x0006 + 0x0002*ns; Bputs(fd, 0xffda); Bputs(fd, n); Bputc(fd, ns); /* Y component */ Bputc(fd, 0x00); Bputc(fd, (0x0<<4)|0x0); if(!kflag) { /* Cb component */ Bputc(fd, 0x01); Bputc(fd, (0x1<<4)|0x1); /* Cr component */ Bputc(fd, 0x02); Bputc(fd, (0x1<<4)|0x1); } Bputc(fd, 0x00); Bputc(fd, 0x3f); Bputc(fd, (0x0<<4)|0x0); } static void writeheader(Biobuf *fd, int dx, int dy, char *s, int kflag, int sflag) { int i; dx = min(dx, 0xffff); dy = min(dy, 0xffff); Bputs(fd, 0xffd8); writejfif(fd, dx, dy); writecomment(fd, s); writequant(fd, 0, sflag); if(!kflag) writequant(fd, 1, sflag); writeframe(fd, dy, dx, kflag); for(i = 0; i < 2; i++) { writehuffman(fd, i, 0); if(!kflag) writehuffman(fd, i, 1); } writescan(fd, kflag); } static void writetrailer(Biobuf *fd) { Bputs(fd, 0xffd9); } static char * writedata(Biobuf *fd, Image *i, Memimage *m, int kflag, int sflag) { char *err; unsigned char *data; int ndata, depth; uint32_t chan; Rectangle r; if(m != nil) { r = m->r; depth = m->depth; chan = m->chan; } else { r = i->r; depth = i->depth; chan = i->chan; } /* * potentially one extra byte on each * end of each scan line */ ndata = Dy(r) * (2 + Dx(r)*depth/8); if((data = malloc(ndata)) == nil) return "WriteJPG: malloc failed"; if(m != nil) ndata = unloadmemimage(m, r, data, ndata); else ndata = unloadimage(i, r, data, ndata); if(ndata < 0) { if((err = malloc(ERRMAX)) == nil) { free(data); return "WriteJPG: malloc failed"; } snprint(err, ERRMAX, "WriteJPG: %r"); } else err = encode(fd, r, data, chan, ndata, kflag, sflag); free(data); return err; } static char * writejpg0(Biobuf *fd, Image *image, Memimage *memimage, Rectangle r, uint32_t chan, char *s, int kflag, int sflag) { int i; char *err; switch(chan) { case GREY1: case GREY2: case GREY4: case GREY8: kflag = 1; break; case RGB24: break; default: return "WriteJPG: can't handle channel type"; } for(i = 0; i < 2; i++) { memset(ehufcod[i], 0, sizeof ehufcod[i]); memset(ehufsid[i], 0, sizeof ehufsid[i]); memset(ehufcoa[i], 0, sizeof ehufcoa[i]); memset(ehufsia[i], 0, sizeof ehufsia[i]); makehuf(ehufcod[i], ehufsid[i], dcbits[i], dchuffval[i], nelem(dchuffval[i])); makehuf(ehufcoa[i], ehufsia[i], acbits[i], achuffval[i], nelem(achuffval[i])); } writeheader(fd, Dx(r), Dy(r), s, kflag, sflag); err = writedata(fd, image, memimage, kflag, sflag); writetrailer(fd); return err; } char * writejpg(Biobuf *fd, Image *i, char *s, int kflag, int sflag) { return writejpg0(fd, i, nil, i->r, i->chan, s, kflag, sflag); } char * memwritejpg(Biobuf *fd, Memimage *m, char *s, int kflag, int sflag) { return writejpg0(fd, nil, m, m->r, m->chan, s, kflag, sflag); }