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