static
Cimage *
loadimg(Rune *src, int x , int y)
{
Channel *sync;
Cimage *ci;
Runestr rs;
Exec *e;
char *filter;
int fd, p[2], q[2];
ci = emalloc(sizeof(Cimage));
rs. r = src;
rs.nr = runestrlen(rs.r);
ci->url = urlalloc(&rs, nil, HGet);
fd = urlopen(ci->url);
if(fd < 0){
Err1:
return ci;
}
filter = getfilter(ci->url->ctype.r, x, y);
if(filter == nil){
werrstr("%S unsupported: %S", ci->url->ctype.r, ci->url->act.r);
Err2:
close(fd);
goto Err1;
}
if(pipe(p)<0 || pipe(q)<0)
error("can't create pipe");
close(p[0]);
p[0] = fd;
sync = chancreate(sizeof(ulong), 0);
if(sync == nil)
error("can't create channel");
e = emalloc(sizeof(Exec));
e->p[0] = p[0];
e->p[1] = p[1];
e->q[0] = q[0];
e->q[1] = q[1];
e->cmd = filter;
e->sync = sync;
proccreate(execproc, e, STACK);
recvul(sync);
chanfree(sync);
close(p[0]);
close(p[1]);
close(q[1]);
ci->mi = readmemimage(q[0]);
close(q[0]);
if(ci->mi == nil){
werrstr("can't read image");
goto Err2;
}
free(filter);
return ci;
}
void
main(int argc, char *argv[])
{
Biobuf bout;
Memimage *i;
int fd;
char *err, *filename;
ImageInfo II;
ARGBEGIN{
case 'c':
II.comment = ARGF();
if(II.comment == nil)
usage();
II.fields_set |= II_COMMENT;
break;
case 'g':
II.gamma = atof(ARGF());
if(II.gamma == 0.)
usage();
II.fields_set |= II_GAMMA;
break;
case 't':
break;
default:
usage();
}ARGEND
if(Binit(&bout, 1, OWRITE) < 0)
sysfatal("Binit failed: %r");
memimageinit();
if(argc == 0){
fd = 0;
filename = "<stdin>";
}else{
fd = open(argv[0], OREAD);
if(fd < 0)
sysfatal("can't open %s: %r", argv[0]);
filename = argv[0];
}
i = readmemimage(fd);
if(i == nil)
sysfatal("can't readimage %s: %r", filename);
close(fd);
err = memwritepng(&bout, i, &II);
freememimage(i);
if(err != nil)
fprint(2, "topng: %s\n", err);
exits(err);
}
Memsubfont*
openmemsubfont(char *name)
{
Memsubfont *sf;
Memimage *i;
Fontchar *fc;
int fd, n;
char hdr[3*12+4+1];
uchar *p;
fd = open(name, OREAD);
if(fd < 0)
return nil;
p = nil;
i = readmemimage(fd);
if(i == nil)
goto Err;
if(readn(fd, hdr, 3*12) != 3*12){
werrstr("openmemsubfont: header read error: %r");
goto Err;
}
n = atoi(hdr);
if(n <= 0 || n > 0x7fff){
werrstr("openmemsubfont: bad fontchar count %d", n);
goto Err;
}
p = malloc(6*(n+1));
if(p == nil)
goto Err;
if(readn(fd, p, 6*(n+1)) != 6*(n+1)){
werrstr("openmemsubfont: fontchar read error: %r");
goto Err;
}
fc = malloc(sizeof(Fontchar)*(n+1));
if(fc == nil)
goto Err;
_unpackinfo(fc, p, n);
sf = allocmemsubfont(name, n, atoi(hdr+12), atoi(hdr+24), fc, i);
if(sf == nil){
free(fc);
goto Err;
}
close(fd);
free(p);
return sf;
Err:
close(fd);
free(p);
freememimage(i);
return nil;
}
void
main(int argc, char *argv[])
{
Memimage *m;
int fd, r;
char f;
f = 0;
r = 0;
fd = 0;
ARGBEGIN {
case 'u':
f = 'u';
break;
case 'l':
f = 'l';
break;
case 'r':
r = atoi(EARGF(usage()));
break;
default:
usage();
} ARGEND;
if(*argv){
fd = open(*argv, OREAD);
if(fd < 0)
sysfatal("open: %r");
}
memimageinit();
if((m = readmemimage(fd)) == nil)
sysfatal("readmemimage: %r");
if(f == 'u' || f == 'l'){
m = upsidedown(m);
if(f == 'l')
r = 180;
}
switch(r % 360){
case 270:
m = rot90(m);
case 180:
m = rot90(m);
case 90:
m = rot90(m);
break;
}
if(writememimage(1, m) < 0)
sysfatal("writememimage: %r");
exits(0);
}
void
main(int argc, char *argv[])
{
Biobuf bout;
Memimage *i, *ni;
int fd, j, dt, trans, loop;
char buf[256];
char *err, *comment, *s;
comment = nil;
dt = -1;
trans = -1;
loop = UNSET;
ARGBEGIN{
case 'l':
s = ARGF();
if(s==nil || (!isdigit(s[0]) && s[0]!='-'))
usage();
loop = atoi(s);
break;
case 'c':
comment = ARGF();
if(comment == nil)
usage();
break;
case 'd':
s = ARGF();
if(s==nil || !isdigit(s[0]))
usage();
dt = atoi(s);
break;
case 't':
s = ARGF();
if(s==nil || !isdigit(s[0]))
usage();
trans = atoi(s);
if(trans > 255)
usage();
break;
default:
usage();
}ARGEND
if(Binit(&bout, 1, OWRITE) < 0)
sysfatal("Binit failed: %r");
memimageinit();
err = nil;
if(argc == 0){
i = readmemimage(0);
if(i == nil)
sysfatal("reading input: %r");
ni = memonechan(i);
if(ni == nil)
sysfatal("converting image to RGBV: %r");
if(i != ni){
freememimage(i);
i = ni;
}
err = memstartgif(&bout, i, -1);
if(err == nil){
if(comment)
err = memwritegif(&bout, i, comment, dt, trans);
else{
snprint(buf, sizeof buf, "Converted by Plan 9 from <stdin>");
err = memwritegif(&bout, i, buf, dt, trans);
}
}
}else{
if(loop == UNSET){
if(argc == 1)
loop = -1; /* no loop for single image */
else
loop = 0; /* the default case: 0 means infinite loop */
}
for(j=0; j<argc; j++){
if(argv[j][0] == '-' && argv[j][1]=='d'){
/* time change */
if(argv[j][2] == '\0'){
s = argv[++j];
if(j == argc)
usage();
}else
s = &argv[j][2];
if(!isdigit(s[0]))
usage();
dt = atoi(s);
if(j == argc-1) /* last argument must be file */
usage();
continue;
}
fd = open(argv[j], OREAD);
if(fd < 0)
sysfatal("can't open %s: %r", argv[j]);
i = readmemimage(fd);
if(i == nil)
sysfatal("can't readimage %s: %r", argv[j]);
close(fd);
ni = memonechan(i);
if(ni == nil)
sysfatal("converting image to RGBV: %r");
if(i != ni){
freememimage(i);
i = ni;
}
if(j == 0){
err = memstartgif(&bout, i, loop);
if(err != nil)
break;
}
if(comment)
err = memwritegif(&bout, i, comment, dt, trans);
else{
snprint(buf, sizeof buf, "Converted by Plan 9 from %s", argv[j]);
err = memwritegif(&bout, i, buf, dt, trans);
}
if(err != nil)
break;
freememimage(i);
comment = nil;
}
}
memendgif(&bout);
if(err != nil)
fprint(2, "togif: %s\n", err);
exits(err);
}
void
main(int argc, char *argv[]) {
int i, fd = 0;
double xmag = 1.0, ymag = 1.0;
char *optstr, *Patch;
Memimage *memimage;
Patch = nil;
for (i=1; i<argc; i++) {
if (*argv[i] != '-') break;
switch(argv[i][1]) {
case 'b':
if (argv[i][2] == '\0')
dpi = atoi(argv[++i]);
else
dpi = atoi(&(argv[i][2]));
break;
case 'd':
debug = 1;
break;
case 'm':
if (argv[i][2] == '\0')
optstr = argv[++i];
else
optstr = &(argv[i][2]);
if ((optstr=strtok(optstr, " ,")) != 0)
xmag = ymag = atof(optstr);
if ((optstr=strtok(0, " ,")) != 0)
ymag = atof(optstr);
break;
case 'L':
landscape = 1;
break;
case 'P':
if (argv[i][2] == '\0')
Patch = argv[++i];
else
Patch = &(argv[i][2]);
break;
case 'p':
optstr = argv[++i];
if(optstr == nil)
goto Usage;
paperlength = 72*atof(optstr);
optstr = argv[++i];
if(optstr == nil)
goto Usage;
paperwidth = 72*atof(optstr);
if(paperlength < 72 || paperwidth < 72)
goto Usage;
break;
default:
Usage:
fprint(2, "usage: %s [-b dpi] [-m magnification] [-L] [-P postscript_patch_string] [-p paperlength paperwidth (in inches)] inputfile\n", argv[0]);
exits("usage");
}
}
if (i < argc) {
file = argv[i];
fd = open(file, OREAD);
if (fd < 0)
error("open");
}
memimageinit();
memimage = readmemimage(fd);
if(memimage == nil)
error("alloc memory for");
psinit(0, 0);
if(xmag != 1.0)
psopt("xmagnification", &xmag);
if(ymag != 1.0)
psopt("ymagnification", &ymag);
if(landscape)
psopt("landscape", &landscape);
if(Patch)
psopt("Patch", &Patch);
image2psfile(1, memimage, dpi);
exits("");
}
void
main(int argc, char **argv)
{
int fd, xsize, ysize;
Memimage *im, *nim;
ulong ochan, tchan;
xsize = ysize = 0;
ARGBEGIN{
case 'a':
xsize = ysize = getsize(EARGF(usage()));
break;
case 'x':
xsize = getsize(EARGF(usage()));
break;
case 'y':
ysize = getsize(EARGF(usage()));
break;
default:
usage();
}ARGEND
fd = 0;
if(*argv){
fd = open(*argv, OREAD);
if(fd < 0)
sysfatal("open: %r");
}
memimageinit();
if((im = readmemimage(fd)) == nil)
sysfatal("readmemimage: %r");
if(xsize & PERCENT)
xsize = ((xsize & ~PERCENT) * Dx(im->r)) / 100;
if(ysize & PERCENT)
ysize = ((ysize & ~PERCENT) * Dy(im->r)) / 100;
if(xsize || ysize){
if(ysize == 0)
ysize = (xsize * Dy(im->r)) / Dx(im->r);
if(xsize == 0)
xsize = (ysize * Dx(im->r)) / Dy(im->r);
ochan = im->chan;
switch(ochan){
default:
for(tchan = ochan; tchan; tchan >>= 8)
if(TYPE(tchan) == CAlpha){
tchan = RGBA32;
break;
}
if(tchan == 0)
tchan = RGB24;
break;
case GREY8:
case RGB24:
case RGBA32:
case ARGB32:
case XRGB32:
tchan = ochan;
break;
case GREY1:
case GREY2:
case GREY4:
tchan = GREY8;
break;
}
if(tchan != ochan){
if((nim = allocmemimage(im->r, tchan)) == nil)
sysfatal("allocimage: %r");
memimagedraw(nim, nim->r, im, im->r.min, nil, ZP, S);
freememimage(im);
im = nim;
}
if((nim = allocmemimage(
Rect(im->r.min.x, im->r.min.y, im->r.min.x+xsize, im->r.min.y+ysize),
tchan)) == nil)
sysfatal("allocmemimage: %r");
resample(nim, nim->r, im, im->r);
freememimage(im);
im = nim;
if(tchan != ochan){
if((im = allocmemimage(nim->r, ochan)) == nil)
sysfatal("allocimage: %r");
memimagedraw(im, im->r, nim, nim->r.min, nil, ZP, S);
freememimage(nim);
}
}
if(writememimage(1, im) < 0)
sysfatal("writememimage: %r");
exits(0);
}
void
main(int argc, char *argv[])
{
char *tostr, *file;
int fd, uncompressed;
ulong tochan;
Memimage *m, *n;
tostr = nil;
uncompressed = 0;
ARGBEGIN{
case 'c':
tostr = EARGF(usage());
break;
case 'u':
uncompressed = 1;
break;
default:
usage();
}ARGEND
memimageinit();
file = "<stdin>";
m = nil;
switch(argc){
case 0:
m = readmemimage(0);
break;
case 1:
file = argv[0];
fd = open(file, OREAD);
if(fd < 0)
sysfatal("can't open %s: %r", file);
m = readmemimage(fd);
close(fd);
break;
default:
usage();
}
if(m == nil)
sysfatal("can't read %s: %r", file);
if(tostr == nil)
tochan = m->chan;
else{
tochan = strtochan(tostr);
if(tochan == 0)
sysfatal("bad channel descriptor '%s'", tostr);
}
n = allocmemimage(m->r, tochan);
if(n == nil)
sysfatal("can't allocate new image: %r");
memimagedraw(n, n->r, m, m->r.min, nil, ZP, S);
if(uncompressed)
writeuncompressed(1, n);
else
writememimage(1, n);
exits(nil);
}
