358 lines
7.5 KiB
C
358 lines
7.5 KiB
C
#include <u.h>
|
|
#include <lib9.h>
|
|
#include <bio.h>
|
|
#include <draw.h>
|
|
#include <event.h>
|
|
#include <keyboard.h>
|
|
#include "imagefile.h"
|
|
|
|
int cflag = 0;
|
|
int dflag = 0;
|
|
int eflag = 0;
|
|
int jflag = 0;
|
|
int fflag = 0;
|
|
int Fflag = 0;
|
|
int nineflag = 0;
|
|
int threeflag = 0;
|
|
int colorspace = CYCbCr; /* default for 8-bit displays: combine color rotation with dither */
|
|
int output = 0;
|
|
uint32_t outchan = CMAP8;
|
|
Image *image;
|
|
int defaultcolor = 1;
|
|
|
|
enum{
|
|
Border = 2,
|
|
Edge = 5
|
|
};
|
|
|
|
char *show(int, char*, int);
|
|
|
|
Rectangle
|
|
imager(Image *i)
|
|
{
|
|
Point p1, p2;
|
|
|
|
p1 = addpt(divpt(subpt(i->r.max, i->r.min), 2), i->r.min);
|
|
p2 = addpt(divpt(subpt(screen->clipr.max, screen->clipr.min), 2), screen->clipr.min);
|
|
return rectaddpt(i->r, subpt(p2, p1));
|
|
}
|
|
|
|
void
|
|
eresized(int new)
|
|
{
|
|
Rectangle r;
|
|
|
|
if(new && getwindow(display, Refnone) < 0){
|
|
fprint(2, "jpg: can't reattach to window\n");
|
|
exits("resize");
|
|
}
|
|
if(image == nil)
|
|
return;
|
|
r = imager(image);
|
|
border(screen, r, -Border, nil, ZP);
|
|
drawop(screen, r, image, nil, image->r.min, S);
|
|
flushimage(display, 1);
|
|
}
|
|
|
|
void
|
|
main(int argc, char *argv[])
|
|
{
|
|
int fd, i, yflag;
|
|
char *err;
|
|
char buf[12+1];
|
|
|
|
yflag = 0;
|
|
ARGBEGIN{
|
|
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 'F':
|
|
Fflag++; /* make a movie */
|
|
fflag++; /* merge two fields per image */
|
|
break;
|
|
case 'f':
|
|
fflag++; /* merge two fields per image */
|
|
break;
|
|
case 'J': /* decode jpeg only; no display or remap (for debugging, etc.) */
|
|
jflag++;
|
|
break;
|
|
case 'k': /* force black and white */
|
|
defaultcolor = 0;
|
|
outchan = GREY8;
|
|
break;
|
|
case 'r':
|
|
colorspace = CRGB;
|
|
break;
|
|
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 'v': /* force RGBV */
|
|
defaultcolor = 0;
|
|
outchan = CMAP8;
|
|
break;
|
|
case 'y': /* leave it in CYCbCr; for debugging only */
|
|
yflag = 1;
|
|
colorspace = CYCbCr;
|
|
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: jpg -39cdefFkJrtvy [file.jpg ...]\n");
|
|
exits("usage");
|
|
}ARGEND;
|
|
|
|
if(yflag==0 && dflag==0 && colorspace==CYCbCr){ /* see if we should convert right to RGB */
|
|
fd = sys_open("/dev/screen", OREAD);
|
|
if(fd >= 0){
|
|
buf[12] = '\0';
|
|
if(jehanne_read(fd, buf, 12)==12 && chantodepth(strtochan(buf))>8)
|
|
colorspace = CRGB;
|
|
sys_close(fd);
|
|
}
|
|
}
|
|
|
|
err = nil;
|
|
if(argc == 0)
|
|
err = show(0, "<stdin>", outchan);
|
|
else{
|
|
for(i=0; i<argc; i++){
|
|
fd = sys_open(argv[i], OREAD);
|
|
if(fd < 0){
|
|
fprint(2, "jpg: can't open %s: %r\n", argv[i]);
|
|
err = "open";
|
|
}else{
|
|
err = show(fd, argv[i], outchan);
|
|
sys_close(fd);
|
|
}
|
|
if((nineflag || cflag) && argc>1 && err==nil){
|
|
fprint(2, "jpg: exiting after one file\n");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
exits(err);
|
|
}
|
|
|
|
Rawimage**
|
|
vidmerge(Rawimage **aa1, Rawimage **aa2)
|
|
{
|
|
Rawimage **aao, *ao, *a1, *a2;
|
|
int i, c, row, col;
|
|
|
|
aao = nil;
|
|
for (i = 0; aa1[i]; i++) {
|
|
|
|
a1 = aa1[i];
|
|
a2 = aa2[i];
|
|
if (a2 == nil){
|
|
fprint(2, "jpg: vidmerge: unequal lengths\n");
|
|
return nil;
|
|
}
|
|
aao = realloc(aao, (i+2)*sizeof(Rawimage *));
|
|
if (aao == nil){
|
|
fprint(2, "jpg: vidmerge: realloc\n");
|
|
return nil;
|
|
}
|
|
aao[i+1] = nil;
|
|
ao = aao[i] = malloc(sizeof(Rawimage));
|
|
if (ao == nil){
|
|
fprint(2, "jpg: vidmerge: malloc\n");
|
|
return nil;
|
|
}
|
|
memcpy(ao, a1, sizeof(Rawimage));
|
|
if (!eqrect(a1->r , a2->r)){
|
|
fprint(2, "jpg: vidmerge: rects different in img %d\n", i);
|
|
return nil;
|
|
}
|
|
if (a1->cmaplen != a2->cmaplen){
|
|
fprint(2, "jpg: vidmerge: cmaplen different in img %d\n", i);
|
|
return nil;
|
|
}
|
|
if (a1->nchans != a2->nchans){
|
|
fprint(2, "jpg: vidmerge: nchans different in img %d\n", i);
|
|
return nil;
|
|
}
|
|
if (a1->fields != a2->fields){
|
|
fprint(2, "jpg: vidmerge: fields different in img %d\n", i);
|
|
return nil;
|
|
}
|
|
ao->r.max.y += Dy(ao->r);
|
|
ao->chanlen += ao->chanlen;
|
|
if (ao->chanlen != Dx(ao->r)*Dy(ao->r)){
|
|
fprint(2, "jpg: vidmerge: chanlen wrong %d != %d*%d\n",
|
|
ao->chanlen, Dx(ao->r), Dy(ao->r));
|
|
return nil;
|
|
}
|
|
row = Dx(a1->r);
|
|
for (c = 0; c < ao->nchans; c++) {
|
|
unsigned char *po, *p1, *p2;
|
|
|
|
ao->chans[c] = malloc(ao->chanlen);
|
|
if (ao->chans[c] == nil){
|
|
fprint(2, "jpg: vidmerge: malloc chan\n");
|
|
return nil;
|
|
}
|
|
po = ao->chans[c];
|
|
p1 = a1->chans[c];
|
|
p2 = a2->chans[c];
|
|
for (col = 0; col < Dy(a1->r); col++) {
|
|
memcpy(po, p1, row);
|
|
po += row, p1 += row;
|
|
memcpy(po, p2, row);
|
|
po += row, p2 += row;
|
|
}
|
|
free(a1->chans[c]);
|
|
free(a2->chans[c]);
|
|
}
|
|
if(a2->cmap != nil)
|
|
free(a2->cmap);
|
|
free(a1);
|
|
free(a2);
|
|
}
|
|
if (aa2[i] != nil)
|
|
fprint(2, "jpg: vidmerge: unequal lengths\n");
|
|
free(aa1);
|
|
free(aa2);
|
|
return aao;
|
|
}
|
|
|
|
char*
|
|
show(int fd, char *name, int outc)
|
|
{
|
|
Rawimage **array, *r, *c;
|
|
static int inited;
|
|
Image *i;
|
|
int j, ch, outchan;
|
|
Biobuf b;
|
|
char buf[32];
|
|
|
|
if(Binit(&b, fd, OREAD) < 0)
|
|
return nil;
|
|
outchan = outc;
|
|
rpt: array = Breadjpg(&b, colorspace);
|
|
if(array == nil || array[0]==nil){
|
|
fprint(2, "jpg: decode %s failed: %r\n", name);
|
|
return "decode";
|
|
}
|
|
if (fflag) {
|
|
Rawimage **a;
|
|
|
|
a = Breadjpg(&b, colorspace);
|
|
if(a == nil || a[0]==nil){
|
|
fprint(2, "jpg: decode %s-2 failed: %r\n", name);
|
|
return "decode";
|
|
}
|
|
array = vidmerge(a, array);
|
|
} else
|
|
Bterm(&b);
|
|
|
|
r = array[0];
|
|
c = nil;
|
|
if(jflag)
|
|
goto Return;
|
|
if(!dflag){
|
|
if (!inited) {
|
|
if(initdraw(0, 0, 0) < 0){
|
|
fprint(2, "jpg: initdraw failed: %r\n");
|
|
return "initdraw";
|
|
}
|
|
if(Fflag == 0)
|
|
einit(Ekeyboard|Emouse);
|
|
inited++;
|
|
}
|
|
if(defaultcolor && screen->depth>8 && outchan==CMAP8)
|
|
outchan = RGB24;
|
|
}
|
|
if(outchan == CMAP8)
|
|
c = torgbv(r, !eflag);
|
|
else{
|
|
if(outchan==GREY8 || (r->chandesc==CY && threeflag==0)){
|
|
c = totruecolor(r, CY);
|
|
outchan = GREY8;
|
|
}else
|
|
c = totruecolor(r, CRGB24);
|
|
}
|
|
if(c == nil){
|
|
fprint(2, "jpg: conversion of %s failed: %r\n", name);
|
|
return "torgbv";
|
|
}
|
|
if(!dflag){
|
|
if(c->chandesc == CY)
|
|
i = allocimage(display, c->r, GREY8, 0, 0);
|
|
else
|
|
i = allocimage(display, c->r, outchan, 0, 0);
|
|
if(i == nil){
|
|
fprint(2, "jpg: allocimage %s failed: %r\n", name);
|
|
return "allocimage";
|
|
}
|
|
if(loadimage(i, i->r, c->chans[0], c->chanlen) < 0){
|
|
fprint(2, "jpg: loadimage %s failed: %r\n", name);
|
|
return "loadimage";
|
|
}
|
|
image = i;
|
|
eresized(0);
|
|
if (Fflag) {
|
|
freeimage(i);
|
|
for(j=0; j<r->nchans; j++)
|
|
free(r->chans[j]);
|
|
free(r->cmap);
|
|
free(r);
|
|
free(array);
|
|
goto rpt;
|
|
}
|
|
if((ch=ekbd())=='q' || ch==Kdel || ch==Keof)
|
|
exits(nil);
|
|
draw(screen, screen->clipr, display->white, nil, ZP);
|
|
image = nil;
|
|
freeimage(i);
|
|
}
|
|
if(nineflag){
|
|
chantostr(buf, outchan);
|
|
print("%11s %11d %11d %11d %11d ", buf,
|
|
c->r.min.x, c->r.min.y, c->r.max.x, c->r.max.y);
|
|
if(jehanne_write(1, c->chans[0], c->chanlen) != c->chanlen){
|
|
fprint(2, "jpg: %s: write error %r\n", name);
|
|
return "write";
|
|
}
|
|
}else if(cflag){
|
|
if(writerawimage(1, c) < 0){
|
|
fprint(2, "jpg: %s: write error: %r\n", name);
|
|
return "write";
|
|
}
|
|
}
|
|
Return:
|
|
for(j=0; j<r->nchans; j++)
|
|
free(r->chans[j]);
|
|
free(r->cmap);
|
|
free(r);
|
|
free(array);
|
|
if(c){
|
|
free(c->chans[0]);
|
|
free(c);
|
|
}
|
|
if (Fflag) goto rpt;
|
|
return nil;
|
|
}
|