aboutsummaryrefslogtreecommitdiff
path: root/src/cmd/jpg/gif.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/cmd/jpg/gif.c')
-rw-r--r--src/cmd/jpg/gif.c421
1 files changed, 421 insertions, 0 deletions
diff --git a/src/cmd/jpg/gif.c b/src/cmd/jpg/gif.c
new file mode 100644
index 00000000..f9927017
--- /dev/null
+++ b/src/cmd/jpg/gif.c
@@ -0,0 +1,421 @@
+#include <u.h>
+#include <libc.h>
+#include <bio.h>
+#include <draw.h>
+#include <event.h>
+#include "imagefile.h"
+
+int cflag = 0;
+int dflag = 0;
+int eflag = 0;
+int nineflag = 0;
+int threeflag = 0;
+int output = 0;
+ulong outchan = CMAP8;
+Image **allims;
+Image **allmasks;
+int which;
+int defaultcolor = 1;
+
+enum{
+ Border = 2,
+ Edge = 5
+};
+
+char *show(int, char*);
+
+Rectangle
+imager(void)
+{
+ Rectangle r;
+
+ if(allims==nil || allims[0]==nil)
+ return screen->r;
+ r = insetrect(screen->clipr, Edge+Border);
+ r.max.x = r.min.x+Dx(allims[0]->r);
+ r.max.y = r.min.y+Dy(allims[0]->r);
+ return r;
+}
+
+void
+eresized(int new)
+{
+ Rectangle r;
+
+ if(new && getwindow(display, Refnone) < 0){
+ fprint(2, "gif: can't reattach to window\n");
+ exits("resize");
+ }
+ if(allims==nil || allims[which]==nil)
+ return;
+ r = imager();
+ border(screen, r, -Border, nil, ZP);
+ r.min.x += allims[which]->r.min.x - allims[0]->r.min.x;
+ r.min.y += allims[which]->r.min.y - allims[0]->r.min.y;
+ drawop(screen, r, allims[which], allmasks[which], allims[which]->r.min, S);
+ flushimage(display, 1);
+}
+
+void
+main(int argc, char *argv[])
+{
+ int fd, i;
+ char *err;
+
+ ARGBEGIN{
+ case '3': /* produce encoded, compressed, three-color bitmap file; no display by default */
+ threeflag++;
+ /* fall through */
+ case 't': /* produce encoded, compressed, true-color bitmap file; no display by default */
+ cflag++;
+ dflag++;
+ output++;
+ defaultcolor = 0;
+ outchan = RGB24;
+ break;
+ case 'c': /* produce encoded, compressed, bitmap file; no display by default */
+ cflag++;
+ dflag++;
+ output++;
+ if(defaultcolor)
+ outchan = CMAP8;
+ break;
+ case 'd': /* suppress display of image */
+ dflag++;
+ break;
+ case 'e': /* disable floyd-steinberg error diffusion */
+ eflag++;
+ break;
+ case 'k': /* force black and white */
+ defaultcolor = 0;
+ outchan = GREY8;
+ break;
+ case 'v': /* force RGBV */
+ defaultcolor = 0;
+ outchan = CMAP8;
+ break;
+ case '9': /* produce plan 9, uncompressed, bitmap file; no display by default */
+ nineflag++;
+ dflag++;
+ output++;
+ if(defaultcolor)
+ outchan = CMAP8;
+ break;
+ default:
+ fprint(2, "usage: gif -39cdektv [file.gif ...]\n");
+ exits("usage");
+ }ARGEND;
+
+ err = nil;
+ if(argc == 0)
+ err = show(0, "<stdin>");
+ else{
+ for(i=0; i<argc; i++){
+ fd = open(argv[i], OREAD);
+ if(fd < 0){
+ fprint(2, "gif: can't open %s: %r\n", argv[i]);
+ err = "open";
+ }else{
+ err = show(fd, argv[i]);
+ close(fd);
+ }
+ if(output && argc>1 && err==nil){
+ fprint(2, "gif: exiting after one file\n");
+ break;
+ }
+ }
+ }
+ exits(err);
+}
+
+Image*
+transparency(Rawimage *r, char *name)
+{
+ Image *i;
+ int j, index;
+ uchar *pic, *mpic, *mask;
+
+ if((r->gifflags&TRANSP) == 0)
+ return nil;
+ i = allocimage(display, r->r, GREY8, 0, 0);
+ if(i == nil){
+ fprint(2, "gif: allocimage for mask of %s failed: %r\n", name);
+ return nil;
+ }
+ pic = r->chans[0];
+ mask = malloc(r->chanlen);
+ if(mask == nil){
+ fprint(2, "gif: malloc for mask of %s failed: %r\n", name);
+ freeimage(i);
+ return nil;
+ }
+ index = r->giftrindex;
+ mpic = mask;
+ for(j=0; j<r->chanlen; j++)
+ if(*pic++ == index)
+ *mpic++ = 0;
+ else
+ *mpic++ = 0xFF;
+ if(loadimage(i, i->r, mask, r->chanlen) < 0){
+ fprint(2, "gif: loadimage for mask of %s failed: %r\n", name);
+ free(mask);
+ freeimage(i);
+ return nil;
+ }
+ free(mask);
+ return i;
+}
+
+/* interleave alpha values of 0xFF in data stream. alpha value comes first, then b g r */
+uchar*
+expand(uchar *u, int chanlen, int nchan)
+{
+ int j, k;
+ uchar *v, *up, *vp;
+
+ v = malloc(chanlen*(nchan+1));
+ if(v == nil){
+ fprint(2, "gif: malloc fails: %r\n");
+ exits("malloc");
+ }
+ up = u;
+ vp = v;
+ for(j=0; j<chanlen; j++){
+ *vp++ = 0xFF;
+ for(k=0; k<nchan; k++)
+ *vp++ = *up++;
+ }
+ return v;
+}
+
+void
+addalpha(Rawimage *i)
+{
+ char buf[32];
+
+ switch(outchan){
+ case CMAP8:
+ i->chans[0] = expand(i->chans[0], i->chanlen/1, 1);
+ i->chanlen = 2*(i->chanlen/1);
+ i->chandesc = CRGBVA16;
+ outchan = CHAN2(CMap, 8, CAlpha, 8);
+ break;
+
+ case GREY8:
+ i->chans[0] = expand(i->chans[0], i->chanlen/1, 1);
+ i->chanlen = 2*(i->chanlen/1);
+ i->chandesc = CYA16;
+ outchan = CHAN2(CGrey, 8, CAlpha, 8);
+ break;
+
+ case RGB24:
+ i->chans[0] = expand(i->chans[0], i->chanlen/3, 3);
+ i->chanlen = 4*(i->chanlen/3);
+ i->chandesc = CRGBA32;
+ outchan = RGBA32;
+ break;
+
+ default:
+ chantostr(buf, outchan);
+ fprint(2, "gif: can't add alpha to type %s\n", buf);
+ exits("err");
+ }
+}
+
+/*
+ * Called only when writing output. If the output is RGBA32,
+ * we must write four bytes per pixel instead of two.
+ * There's always at least two: data plus alpha.
+ * r is used only for reference; the image is already in c.
+ */
+void
+whiteout(Rawimage *r, Rawimage *c)
+{
+ int i, trindex;
+ uchar *rp, *cp;
+
+ rp = r->chans[0];
+ cp = c->chans[0];
+ trindex = r->giftrindex;
+ if(outchan == RGBA32)
+ for(i=0; i<r->chanlen; i++){
+ if(*rp == trindex){
+ *cp++ = 0x00;
+ *cp++ = 0xFF;
+ *cp++ = 0xFF;
+ *cp++ = 0xFF;
+ }else{
+ *cp++ = 0xFF;
+ cp += 3;
+ }
+ rp++;
+ }
+ else
+ for(i=0; i<r->chanlen; i++){
+ if(*rp == trindex){
+ *cp++ = 0x00;
+ *cp++ = 0xFF;
+ }else{
+ *cp++ = 0xFF;
+ cp++;
+ }
+ rp++;
+ }
+}
+
+int
+init(void)
+{
+ static int inited;
+
+ if(inited == 0){
+ if(initdraw(0, 0, 0) < 0){
+ fprint(2, "gif: initdraw failed: %r\n");
+ return -1;
+ }
+ einit(Ekeyboard|Emouse);
+ inited++;
+ }
+ return 1;
+}
+
+char*
+show(int fd, char *name)
+{
+ Rawimage **images, **rgbv;
+ Image **ims, **masks;
+ int j, k, n, ch, nloop, loopcount, dt;
+ char *err;
+ char buf[32];
+
+ err = nil;
+ images = readgif(fd, CRGB);
+ if(images == nil){
+ fprint(2, "gif: decode %s failed: %r\n", name);
+ return "decode";
+ }
+ for(n=0; images[n]; n++)
+ ;
+ ims = malloc((n+1)*sizeof(Image*));
+ masks = malloc((n+1)*sizeof(Image*));
+ rgbv = malloc((n+1)*sizeof(Rawimage*));
+ if(masks==nil || rgbv==nil || ims==nil){
+ fprint(2, "gif: malloc of masks for %s failed: %r\n", name);
+ err = "malloc";
+ goto Return;
+ }
+ memset(masks, 0, (n+1)*sizeof(Image*));
+ memset(ims, 0, (n+1)*sizeof(Image*));
+ memset(rgbv, 0, (n+1)*sizeof(Rawimage*));
+ if(!dflag){
+ if(init() < 0){
+ err = "initdraw";
+ goto Return;
+ }
+ if(defaultcolor && screen->depth>8)
+ outchan = RGB24;
+ }
+
+ for(k=0; k<n; k++){
+ if(outchan == CMAP8)
+ rgbv[k] = torgbv(images[k], !eflag);
+ else{
+ if(outchan==GREY8 || (images[k]->chandesc==CY && threeflag==0))
+ rgbv[k] = totruecolor(images[k], CY);
+ else
+ rgbv[k] = totruecolor(images[k], CRGB24);
+ }
+ if(rgbv[k] == nil){
+ fprint(2, "gif: converting %s to local format failed: %r\n", name);
+ err = "torgbv";
+ goto Return;
+ }
+ if(!dflag){
+ masks[k] = transparency(images[k], name);
+ if(rgbv[k]->chandesc == CY)
+ ims[k] = allocimage(display, rgbv[k]->r, GREY8, 0, 0);
+ else
+ ims[k] = allocimage(display, rgbv[k]->r, outchan, 0, 0);
+ if(ims[k] == nil){
+ fprint(2, "gif: allocimage %s failed: %r\n", name);
+ err = "allocimage";
+ goto Return;
+ }
+ if(loadimage(ims[k], ims[k]->r, rgbv[k]->chans[0], rgbv[k]->chanlen) < 0){
+ fprint(2, "gif: loadimage %s failed: %r\n", name);
+ err = "loadimage";
+ goto Return;
+ }
+ }
+ }
+
+ allims = ims;
+ allmasks = masks;
+ loopcount = images[0]->gifloopcount;
+ if(!dflag){
+ nloop = 0;
+ do{
+ for(k=0; k<n; k++){
+ which = k;
+ eresized(0);
+ dt = images[k]->gifdelay*10;
+ if(dt < 50)
+ dt = 50;
+ while(n==1 || ecankbd()){
+ if((ch=ekbd())=='q' || ch==0x7F || ch==0x04) /* an odd, democratic list */
+ exits(nil);
+ if(ch == '\n')
+ goto Out;
+ }sleep(dt);
+ }
+ /* loopcount -1 means no loop (this code's rule), loopcount 0 means loop forever (netscape's rule)*/
+ }while(loopcount==0 || ++nloop<loopcount);
+ /* loop count has run out */
+ ekbd();
+ Out:
+ drawop(screen, screen->clipr, display->white, nil, ZP, S);
+ }
+ if(n>1 && output)
+ fprint(2, "gif: warning: only writing first image in %d-image GIF %s\n", n, name);
+ if(nineflag){
+ if(images[0]->gifflags&TRANSP){
+ addalpha(rgbv[0]);
+ whiteout(images[0], rgbv[0]);
+ }
+ chantostr(buf, outchan);
+ print("%11s %11d %11d %11d %11d ", buf,
+ rgbv[0]->r.min.x, rgbv[0]->r.min.y, rgbv[0]->r.max.x, rgbv[0]->r.max.y);
+ if(write(1, rgbv[0]->chans[0], rgbv[0]->chanlen) != rgbv[0]->chanlen){
+ fprint(2, "gif: %s: write error %r\n", name);
+ return "write";
+ }
+ }else if(cflag){
+ if(images[0]->gifflags&TRANSP){
+ addalpha(rgbv[0]);
+ whiteout(images[0], rgbv[0]);
+ }
+ if(writerawimage(1, rgbv[0]) < 0){
+ fprint(2, "gif: %s: write error: %r\n", name);
+ return "write";
+ }
+ }
+
+ Return:
+ allims = nil;
+ allmasks = nil;
+ for(k=0; images[k]; k++){
+ for(j=0; j<images[k]->nchans; j++)
+ free(images[k]->chans[j]);
+ free(images[k]->cmap);
+ if(rgbv[k])
+ free(rgbv[k]->chans[0]);
+ freeimage(ims[k]);
+ freeimage(masks[k]);
+ free(images[k]);
+ free(rgbv[k]);
+ }
+ free(images);
+ free(masks);
+ free(ims);
+ return err;
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-10-01 09:48:34 +0000