sys/src/cmd/jpg/jpg.c

   1 #include <u.h>
   2 #include <libc.h>
   3 #include <bio.h>
   4 #include <draw.h>
   5 #include <event.h>
   6 #include <keyboard.h>
   7 #include "imagefile.h"
   8
   9 int             cflag = 0;
  10 int             dflag = 0;
  11 int             eflag = 0;
  12 int             jflag = 0;
  13 int             fflag = 0;
  14 int             Fflag = 0;
  15 int             nineflag = 0;
  16 int             threeflag = 0;
  17 int             colorspace = CYCbCr;    /* default for 8-bit displays: combine color rotation with dither */
  18 int             output = 0;
  19 ulong   outchan = CMAP8;
  20 Image   *image;
  21 int             defaultcolor = 1;
  22
  23 enum{
  24         Border  = 2,
  25         Edge            = 5
  26 };
  27
  28 char    *show(int, char*, int);
  29
  30 Rectangle
  31 imager(Image *i)
  32 {
  33         Point p1, p2;
  34
  35         p1 = addpt(divpt(subpt(i->r.max, i->r.min), 2), i->r.min);
  36         p2 = addpt(divpt(subpt(screen->clipr.max, screen->clipr.min), 2), screen->clipr.min);
  37         return rectaddpt(i->r, subpt(p2, p1));
  38 }
  39
  40 void
  41 eresized(int new)
  42 {
  43         Rectangle r;
  44
  45         if(new && getwindow(display, Refnone) < 0){
  46                 fprint(2, "jpg: can't reattach to window\n");
  47                 exits("resize");
  48         }
  49         if(image == nil)
  50                 return;
  51         r = imager(image);
  52         border(screen, r, -Border, nil, ZP);
  53         drawop(screen, r, image, nil, image->r.min, S);
  54         flushimage(display, 1);
  55 }
  56
  57 void
  58 main(int argc, char *argv[])
  59 {
  60         int fd, i, yflag;
  61         char *err;
  62         char buf[12+1];
  63
  64         yflag = 0;
  65         ARGBEGIN{
  66         case 'c':               /* produce encoded, compressed, bitmap file; no display by default */
  67                 cflag++;
  68                 dflag++;
  69                 output++;
  70                 if(defaultcolor)
  71                         outchan = CMAP8;
  72                 break;
  73         case 'd':               /* suppress display of image */
  74                 dflag++;
  75                 break;
  76         case 'e':               /* disable floyd-steinberg error diffusion */
  77                 eflag++;
  78                 break;
  79         case 'F':
  80                 Fflag++;        /* make a movie */
  81                 fflag++;        /* merge two fields per image */
  82                 break;
  83         case 'f':
  84                 fflag++;        /* merge two fields per image */
  85                 break;
  86         case 'J':               /* decode jpeg only; no display or remap (for debugging, etc.) */
  87                 jflag++;
  88                 break;
  89         case 'k':               /* force black and white */
  90                 defaultcolor = 0;
  91                 outchan = GREY8;
  92                 break;
  93         case 'r':
  94                 colorspace = CRGB;
  95                 break;
  96         case '3':               /* produce encoded, compressed, three-color bitmap file; no display by default */
  97                 threeflag++;
  98                 /* fall through */
  99         case 't':               /* produce encoded, compressed, true-color bitmap file; no display by default */
 100                 cflag++;
 101                 dflag++;
 102                 output++;
 103                 defaultcolor = 0;
 104                 outchan = RGB24;
 105                 break;
 106         case 'v':               /* force RGBV */
 107                 defaultcolor = 0;
 108                 outchan = CMAP8;
 109                 break;
 110         case 'y':       /* leave it in CYCbCr; for debugging only */
 111                 yflag = 1;
 112                 colorspace = CYCbCr;
 113                 break;
 114         case '9':               /* produce plan 9, uncompressed, bitmap file; no display by default */
 115                 nineflag++;
 116                 dflag++;
 117                 output++;
 118                 if(defaultcolor)
 119                         outchan = CMAP8;
 120                 break;
 121         default:
 122                 fprint(2, "usage: jpg -39cdefFkJrtvy [file.jpg ...]\n");
 123                 exits("usage");
 124         }ARGEND;
 125
 126         if(yflag==0 && dflag==0 && colorspace==CYCbCr){ /* see if we should convert right to RGB */
 127                 fd = open("/dev/screen", OREAD);
 128                 if(fd >= 0){
 129                         buf[12] = '\0';
 130                         if(read(fd, buf, 12)==12 && chantodepth(strtochan(buf))>8)
 131                                 colorspace = CRGB;
 132                         close(fd);
 133                 }
 134         }
 135
 136         err = nil;
 137         if(argc == 0)
 138                 err = show(0, "<stdin>", outchan);
 139         else{
 140                 for(i=0; i<argc; i++){
 141                         fd = open(argv[i], OREAD);
 142                         if(fd < 0){
 143                                 fprint(2, "jpg: can't open %s: %r\n", argv[i]);
 144                                 err = "open";
 145                         }else{
 146                                 err = show(fd, argv[i], outchan);
 147                                 close(fd);
 148                         }
 149                         if((nineflag || cflag) && argc>1 && err==nil){
 150                                 fprint(2, "jpg: exiting after one file\n");
 151                                 break;
 152                         }
 153                 }
 154         }
 155         exits(err);
 156 }
 157
 158 Rawimage**
 159 vidmerge(Rawimage **aa1, Rawimage **aa2)
 160 {
 161         Rawimage **aao, *ao, *a1, *a2;
 162         int i, c, row, col;
 163
 164         aao = nil;
 165         for (i = 0; aa1[i]; i++) {
 166
 167                 a1 = aa1[i];
 168                 a2 = aa2[i];
 169                 if (a2 == nil){
 170                         fprint(2, "jpg: vidmerge: unequal lengths\n");
 171                         return nil;
 172                 }
 173                 aao = realloc(aao, (i+2)*sizeof(Rawimage *));
 174                 if (aao == nil){
 175                         fprint(2, "jpg: vidmerge: realloc\n");
 176                         return nil;
 177                 }
 178                 aao[i+1] = nil;
 179                 ao = aao[i] = malloc(sizeof(Rawimage));
 180                 if (ao == nil){
 181                         fprint(2, "jpg: vidmerge: malloc\n");
 182                         return nil;
 183                 }
 184                 memcpy(ao, a1, sizeof(Rawimage));
 185                 if (!eqrect(a1->r , a2->r)){
 186                         fprint(2, "jpg: vidmerge: rects different in img %d\n", i);
 187                         return nil;
 188                 }
 189                 if (a1->cmaplen != a2->cmaplen){
 190                         fprint(2, "jpg: vidmerge: cmaplen different in img %d\n", i);
 191                         return nil;
 192                 }
 193                 if (a1->nchans != a2->nchans){
 194                         fprint(2, "jpg: vidmerge: nchans different in img %d\n", i);
 195                         return nil;
 196                 }
 197                 if (a1->fields != a2->fields){
 198                         fprint(2, "jpg: vidmerge: fields different in img %d\n", i);
 199                         return nil;
 200                 }
 201                 ao->r.max.y += Dy(ao->r);
 202                 ao->chanlen += ao->chanlen;
 203                 if (ao->chanlen != Dx(ao->r)*Dy(ao->r)){
 204                         fprint(2, "jpg: vidmerge: chanlen wrong %d != %d*%d\n",
 205                                 ao->chanlen, Dx(ao->r), Dy(ao->r));
 206                         return nil;
 207                 }
 208                 row = Dx(a1->r);
 209                 for (c = 0; c < ao->nchans; c++) {
 210                         uchar *po, *p1, *p2;
 211
 212                         ao->chans[c] = malloc(ao->chanlen);
 213                         if (ao->chans[c] == nil){
 214                                 fprint(2, "jpg: vidmerge: malloc chan\n");
 215                                 return nil;
 216                         }
 217                         po = ao->chans[c];
 218                         p1 = a1->chans[c];
 219                         p2 = a2->chans[c];
 220                         for (col = 0; col < Dy(a1->r); col++) {
 221                                 memcpy(po, p1, row);
 222                                 po += row, p1 += row;
 223                                 memcpy(po, p2, row);
 224                                 po += row, p2 += row;
 225                         }
 226                         free(a1->chans[c]);
 227                         free(a2->chans[c]);
 228                 }
 229                 if(a2->cmap != nil)
 230                         free(a2->cmap);
 231                 free(a1);
 232                 free(a2);
 233         }
 234         if (aa2[i] != nil)
 235                 fprint(2, "jpg: vidmerge: unequal lengths\n");
 236         free(aa1);
 237         free(aa2);
 238         return aao;
 239 }
 240
 241 char*
 242 show(int fd, char *name, int outc)
 243 {
 244         Rawimage **array, *r, *c;
 245         static int inited;
 246         Image *i;
 247         int j, ch, outchan;
 248         Biobuf b;
 249         char buf[32];
 250
 251         if(Binit(&b, fd, OREAD) < 0)
 252                 return nil;
 253         outchan = outc;
 254 rpt:    array = Breadjpg(&b, colorspace);
 255         if(array == nil || array[0]==nil){
 256                 fprint(2, "jpg: decode %s failed: %r\n", name);
 257                 return "decode";
 258         }
 259         if (fflag) {
 260                 Rawimage **a;
 261
 262                 a = Breadjpg(&b, colorspace);
 263                 if(a == nil || a[0]==nil){
 264                         fprint(2, "jpg: decode %s-2 failed: %r\n", name);
 265                         return "decode";
 266                 }
 267                 array = vidmerge(a, array);
 268         } else
 269                 Bterm(&b);
 270
 271         r = array[0];
 272         c = nil;
 273         if(jflag)
 274                 goto Return;
 275         if(!dflag){
 276                 if (!inited) {
 277                         if(initdraw(0, 0, 0) < 0){
 278                                 fprint(2, "jpg: initdraw failed: %r\n");
 279                                 return "initdraw";
 280                         }
 281                         if(Fflag == 0)
 282                                 einit(Ekeyboard|Emouse);
 283                         inited++;
 284                 }
 285                 if(defaultcolor && screen->depth>8 && outchan==CMAP8)
 286                         outchan = RGB24;
 287         }
 288         if(outchan == CMAP8)
 289                 c = torgbv(r, !eflag);
 290         else{
 291                 if(outchan==GREY8 || (r->chandesc==CY && threeflag==0)){
 292                         c = totruecolor(r, CY);
 293                         outchan = GREY8;
 294                 }else
 295                         c = totruecolor(r, CRGB24);
 296         }
 297         if(c == nil){
 298                 fprint(2, "jpg: conversion of %s failed: %r\n", name);
 299                 return "torgbv";
 300         }
 301         if(!dflag){
 302                 if(c->chandesc == CY)
 303                         i = allocimage(display, c->r, GREY8, 0, 0);
 304                 else
 305                         i = allocimage(display, c->r, outchan, 0, 0);
 306                 if(i == nil){
 307                         fprint(2, "jpg: allocimage %s failed: %r\n", name);
 308                         return "allocimage";
 309                 }
 310                 if(loadimage(i, i->r, c->chans[0], c->chanlen) < 0){
 311                         fprint(2, "jpg: loadimage %s failed: %r\n", name);
 312                         return "loadimage";
 313                 }
 314                 image = i;
 315                 eresized(0);
 316                 if (Fflag) {
 317                         freeimage(i);
 318                         for(j=0; j<r->nchans; j++)
 319                                 free(r->chans[j]);
 320                         free(r->cmap);
 321                         free(r);
 322                         free(array);
 323                         goto rpt;
 324                 }
 325                 if((ch=ekbd())=='q' || ch==Kdel || ch==Keof)
 326                         exits(nil);
 327                 draw(screen, screen->clipr, display->white, nil, ZP);
 328                 image = nil;
 329                 freeimage(i);
 330         }
 331         if(nineflag){
 332                 chantostr(buf, outchan);
 333                 print("%11s %11d %11d %11d %11d ", buf,
 334                         c->r.min.x, c->r.min.y, c->r.max.x, c->r.max.y);
 335                 if(write(1, c->chans[0], c->chanlen) != c->chanlen){
 336                         fprint(2, "jpg: %s: write error %r\n", name);
 337                         return "write";
 338                 }
 339         }else if(cflag){
 340                 if(writerawimage(1, c) < 0){
 341                         fprint(2, "jpg: %s: write error: %r\n", name);
 342                         return "write";
 343                 }
 344         }
 345     Return:
 346         for(j=0; j<r->nchans; j++)
 347                 free(r->chans[j]);
 348         free(r->cmap);
 349         free(r);
 350         free(array);
 351         if(c){
 352                 free(c->chans[0]);
 353                 free(c);
 354         }
 355         if (Fflag) goto rpt;
 356         return nil;
 357 }