#include "image.h"
#include "imagei.h"
-#include "io.h"
/*
=head1 NAME
Some of these functions are internal.
-=over 4
+=over
=cut
*/
#define minmax(a,b,i) ( ((a>=i)?a: ( (b<=i)?b:i )) )
/* Hack around an obscure linker bug on solaris - probably due to builtin gcc thingies */
-void fake(void) { ceil(1); }
+static void fake(void) { ceil(1); }
static int i_ppix_d(i_img *im, int x, int y, i_color *val);
static int i_gpix_d(i_img *im, int x, int y, i_color *val);
static int i_gpixf_d(i_img *im, int x, int y, i_fcolor *val);
static int i_glinf_d(i_img *im, int l, int r, int y, i_fcolor *vals);
static int i_plinf_d(i_img *im, int l, int r, int y, i_fcolor *vals);
-static int i_gsamp_d(i_img *im, int l, int r, int y, i_sample_t *samps, int *chans, int chan_count);
-static int i_gsampf_d(i_img *im, int l, int r, int y, i_fsample_t *samps, int *chans, int chan_count);
+static int i_gsamp_d(i_img *im, int l, int r, int y, i_sample_t *samps, const int *chans, int chan_count);
+static int i_gsampf_d(i_img *im, int l, int r, int y, i_fsample_t *samps, const int *chans, int chan_count);
+/*static int i_psamp_d(i_img *im, int l, int r, int y, i_sample_t *samps, int *chans, int chan_count);
+ static int i_psampf_d(i_img *im, int l, int r, int y, i_fsample_t *samps, int *chans, int chan_count);*/
/*
=item ICL_new_internal(r, g, b, a)
{
0, /* channels set */
0, 0, 0, /* xsize, ysize, bytes */
- ~0, /* ch_mask */
+ ~0U, /* ch_mask */
i_8_bits, /* bits */
i_direct_type, /* type */
0, /* virtual */
i_img *
i_img_empty_ch(i_img *im,int x,int y,int ch) {
+ int bytes;
+
mm_log((1,"i_img_empty_ch(*im %p, x %d, y %d, ch %d)\n", im, x, y, ch));
+
+ if (x < 1 || y < 1) {
+ i_push_error(0, "Image sizes must be positive");
+ return NULL;
+ }
+ if (ch < 1 || ch > MAXCHANNELS) {
+ i_push_errorf(0, "channels must be between 1 and %d", MAXCHANNELS);
+ return NULL;
+ }
+ /* check this multiplication doesn't overflow */
+ bytes = x*y*ch;
+ if (bytes / y / ch != x) {
+ i_push_errorf(0, "integer overflow calculating image allocation");
+ return NULL;
+ }
+
if (im == NULL)
if ( (im=mymalloc(sizeof(i_img))) == NULL)
m_fatal(2,"malloc() error\n");
im->ysize = y;
im->channels = ch;
im->ch_mask = MAXINT;
- im->bytes=x*y*im->channels;
- if ( (im->idata=mymalloc(im->bytes)) == NULL) m_fatal(2,"malloc() error\n");
+ im->bytes=bytes;
+ if ( (im->idata=mymalloc(im->bytes)) == NULL)
+ m_fatal(2,"malloc() error\n");
memset(im->idata,0,(size_t)im->bytes);
im->ext_data = NULL;
void
i_img_destroy(i_img *im) {
- mm_log((1,"i_img_destroy(im* 0x%x)\n",im));
+ mm_log((1,"i_img_destroy(im %p)\n",im));
i_img_exorcise(im);
if (im) { myfree(im); }
}
i_img_getchannels(i_img *im) { return im->channels; }
-/*
-=item i_ppix(im, x, y, col)
-
-Sets the pixel at (I<x>,I<y>) in I<im> to I<col>.
-
-Returns true if the pixel could be set, false if x or y is out of
-range.
-
-=cut
-*/
-int
-(i_ppix)(i_img *im, int x, int y, i_color *val) { return im->i_f_ppix(im, x, y, val); }
-
-/*
-=item i_gpix(im, x, y, &col)
-
-Get the pixel at (I<x>,I<y>) in I<im> into I<col>.
-
-Returns true if the pixel could be retrieved, false otherwise.
-
-=cut
-*/
-int
-(i_gpix)(i_img *im, int x, int y, i_color *val) { return im->i_f_gpix(im, x, y, val); }
-
-/*
-=item i_ppix_pch(im, x, y, ch)
-
-Get the value from the channel I<ch> for pixel (I<x>,I<y>) from I<im>
-scaled to [0,1].
-
-Returns zero if x or y is out of range.
-
-Warning: this ignores the vptr interface for images.
-
-=cut
-*/
-float
-i_gpix_pch(i_img *im,int x,int y,int ch) {
- /* FIXME */
- if (x>-1 && x<im->xsize && y>-1 && y<im->ysize) return ((float)im->idata[(x+y*im->xsize)*im->channels+ch]/255);
- else return 0;
-}
-
/*
=item i_copyto_trans(im, src, x1, y1, x2, y2, tx, ty, trans)
myfree(pv);
}
else {
- /* currently the only other depth is 16 */
i_fcolor *pv;
- i_img_16_new_low(im, x1, y1, src->channels);
+ if (src->bits == i_16_bits)
+ i_img_16_new_low(im, x1, y1, src->channels);
+ else if (src->bits == i_double_bits)
+ i_img_double_new_low(im, x1, y1, src->channels);
+ else {
+ fprintf(stderr, "i_copy(): Unknown image bit size %d\n", src->bits);
+ return; /* I dunno */
+ }
+
pv = mymalloc(sizeof(i_fcolor) * x1);
for (y = 0; y < y1; ++y) {
i_glinf(src, 0, x1, y, pv);
/*
-=item i_rubthru(im, src, tx, ty)
+=item i_rubthru(im, src, tx, ty, src_minx, src_miny, src_maxx, src_maxy )
-Takes the image I<src> and applies it at an original (I<tx>,I<ty>) in I<im>.
+Takes the sub image I<src[src_minx, src_maxx)[src_miny, src_maxy)> and
+overlays it at (I<tx>,I<ty>) on the image object.
The alpha channel of each pixel in I<src> is used to control how much
the existing colour in I<im> is replaced, if it is 255 then the colour
*/
int
-i_rubthru(i_img *im,i_img *src,int tx,int ty) {
+i_rubthru(i_img *im, i_img *src, int tx, int ty, int src_minx, int src_miny,
+ int src_maxx, int src_maxy) {
int x, y, ttx, tty;
int chancount;
int chans[3];
int alphachan;
int ch;
- mm_log((1,"i_rubthru(im %p, src %p, tx %d, ty %d)\n", im, src, tx, ty));
+ mm_log((1,"i_rubthru(im %p, src %p, tx %d, ty %d, src_minx %d, "
+ "src_miny %d, src_maxx %d, src_maxy %d)\n",
+ im, src, tx, ty, src_minx, src_miny, src_maxx, src_maxy));
i_clear_error();
if (im->channels == 3 && src->channels == 4) {
changed in a similar fashion - TC */
int alpha;
i_color pv, orig, dest;
- ttx = tx;
- for(x=0; x<src->xsize; x++) {
- tty=ty;
- for(y=0;y<src->ysize;y++) {
- /* fprintf(stderr,"reading (%d,%d) writing (%d,%d).\n",x,y,ttx,tty); */
+ tty = ty;
+ for(y = src_miny; y < src_maxy; y++) {
+ ttx = tx;
+ for(x = src_minx; x < src_maxx; x++) {
i_gpix(src, x, y, &pv);
i_gpix(im, ttx, tty, &orig);
alpha = pv.channel[alphachan];
+ (255 - alpha) * orig.channel[ch])/255;
}
i_ppix(im, ttx, tty, &dest);
- tty++;
+ ttx++;
}
- ttx++;
+ tty++;
}
}
else {
double alpha;
i_fcolor pv, orig, dest;
- ttx = tx;
- for(x=0; x<src->xsize; x++) {
- tty=ty;
- for(y=0;y<src->ysize;y++) {
- /* fprintf(stderr,"reading (%d,%d) writing (%d,%d).\n",x,y,ttx,tty); */
+ tty = ty;
+ for(y = src_miny; y < src_maxy; y++) {
+ ttx = tx;
+ for(x = src_minx; x < src_maxx; x++) {
i_gpixf(src, x, y, &pv);
i_gpixf(im, ttx, tty, &orig);
alpha = pv.channel[alphachan];
for (ch = 0; ch < chancount; ++ch) {
dest.channel[ch] = alpha * pv.channel[chans[ch]]
- + (1 - alpha) * orig.channel[ch];
+ + (1 - alpha) * orig.channel[ch];
}
i_ppixf(im, ttx, tty, &dest);
- tty++;
+ ttx++;
}
- ttx++;
+ tty++;
}
}
else return(sin(PIx) / PIx * sin(PIx2) / PIx2);
}
+
/*
=item i_scaleaxis(im, value, axis)
int hsize, vsize, i, j, k, l, lMax, iEnd, jEnd;
int LanczosWidthFactor;
float *l0, *l1, OldLocation;
- int T, TempJump1, TempJump2;
+ int T;
+ float t;
float F, PictureValue[MAXCHANNELS];
short psave;
i_color val,val1,val2;
i_img *new_img;
- mm_log((1,"i_scaleaxis(im 0x%x,Value %.2f,Axis %d)\n",im,Value,Axis));
+ mm_log((1,"i_scaleaxis(im %p,Value %.2f,Axis %d)\n",im,Value,Axis));
+
if (Axis == XAXIS) {
- hsize = (int) ((float) im->xsize * Value);
+ hsize = (int)(0.5 + im->xsize * Value);
+ if (hsize < 1) {
+ hsize = 1;
+ Value = 1.0 / im->xsize;
+ }
vsize = im->ysize;
jEnd = hsize;
iEnd = vsize;
-
- TempJump1 = (hsize - 1) * 3;
- TempJump2 = hsize * (vsize - 1) * 3 + TempJump1;
} else {
hsize = im->xsize;
- vsize = (int) ((float) im->ysize * Value);
-
+ vsize = (int)(0.5 + im->ysize * Value);
+
+ if (vsize < 1) {
+ vsize = 1;
+ Value = 1.0 / im->ysize;
+ }
+
jEnd = vsize;
iEnd = hsize;
-
- TempJump1 = 0;
- TempJump2 = 0;
}
- new_img=i_img_empty_ch(NULL,hsize,vsize,im->channels);
-
- if (Value >=1) LanczosWidthFactor = 1;
- else LanczosWidthFactor = (int) (1.0/Value);
+ new_img = i_img_empty_ch(NULL, hsize, vsize, im->channels);
+ /* 1.4 is a magic number, setting it to 2 will cause rather blurred images */
+ LanczosWidthFactor = (Value >= 1) ? 1 : (int) (1.4/Value);
lMax = LanczosWidthFactor << 1;
- l0 = (float *) mymalloc(lMax * sizeof(float));
- l1 = (float *) mymalloc(lMax * sizeof(float));
+ l0 = mymalloc(lMax * sizeof(float));
+ l1 = mymalloc(lMax * sizeof(float));
for (j=0; j<jEnd; j++) {
OldLocation = ((float) j) / Value;
T = (int) (OldLocation);
F = OldLocation - (float) T;
- for (l = 0; l < lMax; l++) {
+ for (l = 0; l<lMax; l++) {
l0[lMax-l-1] = Lanczos(((float) (lMax-l-1) + F) / (float) LanczosWidthFactor);
- l1[l] = Lanczos(((float) (l + 1) - F) / (float) LanczosWidthFactor);
+ l1[l] = Lanczos(((float) (l+1) - F) / (float) LanczosWidthFactor);
}
- if (Axis== XAXIS) {
+ /* Make sure filter is normalized */
+ t = 0.0;
+ for(l=0; l<lMax; l++) {
+ t+=l0[l];
+ t+=l1[l];
+ }
+ t /= (float)LanczosWidthFactor;
+
+ for(l=0; l<lMax; l++) {
+ l0[l] /= t;
+ l1[l] /= t;
+ }
+
+ if (Axis == XAXIS) {
for (i=0; i<iEnd; i++) {
for (k=0; k<im->channels; k++) PictureValue[k] = 0.0;
- for (l=0; l < lMax; l++) {
- i_gpix(im,T+l+1, i, &val1);
- i_gpix(im,T-lMax+l+1, i, &val2);
+ for (l=0; l<lMax; l++) {
+ int mx = T-lMax+l+1;
+ int Mx = T+l+1;
+ mx = (mx < 0) ? 0 : mx;
+ Mx = (Mx >= im->xsize) ? im->xsize-1 : Mx;
+
+ i_gpix(im, Mx, i, &val1);
+ i_gpix(im, mx, i, &val2);
+
for (k=0; k<im->channels; k++) {
- PictureValue[k] += l1[l] * val1.channel[k];
+ PictureValue[k] += l1[l] * val1.channel[k];
PictureValue[k] += l0[lMax-l-1] * val2.channel[k];
}
}
for(k=0;k<im->channels;k++) {
- psave = (short)( PictureValue[k] / LanczosWidthFactor);
+ psave = (short)(0.5+(PictureValue[k] / LanczosWidthFactor));
val.channel[k]=minmax(0,255,psave);
}
- i_ppix(new_img,j,i,&val);
+ i_ppix(new_img, j, i, &val);
}
} else {
for (i=0; i<iEnd; i++) {
for (k=0; k<im->channels; k++) PictureValue[k] = 0.0;
for (l=0; l < lMax; l++) {
- i_gpix(im,i, T+l+1, &val1);
- i_gpix(im,i, T-lMax+l+1, &val2);
+ int mx = T-lMax+l+1;
+ int Mx = T+l+1;
+ mx = (mx < 0) ? 0 : mx;
+ Mx = (Mx >= im->ysize) ? im->ysize-1 : Mx;
+
+ i_gpix(im, i, Mx, &val1);
+ i_gpix(im, i, mx, &val2);
for (k=0; k<im->channels; k++) {
- PictureValue[k] += l1[l] * val1.channel[k];
+ PictureValue[k] += l1[l] * val1.channel[k];
PictureValue[k] += l0[lMax-l-1] * val2.channel[k];
}
}
for (k=0; k<im->channels; k++) {
- psave = (short)( PictureValue[k] / LanczosWidthFactor);
- val.channel[k]=minmax(0,255,psave);
+ psave = (short)(0.5+(PictureValue[k] / LanczosWidthFactor));
+ val.channel[k] = minmax(0, 255, psave);
}
- i_ppix(new_img,i,j,&val);
+ i_ppix(new_img, i, j, &val);
}
}
myfree(l0);
myfree(l1);
- mm_log((1,"(0x%x) <- i_scaleaxis\n",new_img));
+ mm_log((1,"(%p) <- i_scaleaxis\n", new_img));
return new_img;
}
mm_log((1,"i_scale_nn(im 0x%x,scx %.2f,scy %.2f)\n",im,scx,scy));
nxsize = (int) ((float) im->xsize * scx);
+ if (nxsize < 1) {
+ nxsize = 1;
+ scx = 1 / im->xsize;
+ }
nysize = (int) ((float) im->ysize * scy);
+ if (nysize < 1) {
+ nysize = 1;
+ scy = 1 / im->ysize;
+ }
new_img=i_img_empty_ch(NULL,nxsize,nysize,im->channels);
if (src->bits == 8) {
return i_img_empty_ch(NULL, xsize, ysize, src->channels);
}
- else if (src->bits == 16) {
+ else if (src->bits == i_16_bits) {
return i_img_16_new(xsize, ysize, src->channels);
}
+ else if (src->bits == i_double_bits) {
+ return i_img_double_new(xsize, ysize, src->channels);
+ }
else {
i_push_error(0, "Unknown image bits");
return NULL;
}
}
+/*
+=item i_sametype_chans(i_img *im, int xsize, int ysize, int channels)
+
+Returns an image of the same type (sample size).
+
+For paletted images the equivalent direct type is returned.
+
+=cut
+*/
+
+i_img *i_sametype_chans(i_img *src, int xsize, int ysize, int channels) {
+ if (src->bits == 8) {
+ return i_img_empty_ch(NULL, xsize, ysize, channels);
+ }
+ else if (src->bits == i_16_bits) {
+ return i_img_16_new(xsize, ysize, channels);
+ }
+ else if (src->bits == i_double_bits) {
+ return i_img_double_new(xsize, ysize, channels);
+ }
+ else {
+ i_push_error(0, "Unknown image bits");
+ return NULL;
+ }
+}
+
/*
=item i_transform(im, opx, opxl, opy, opyl, parm, parmlen)
parm[1]=(double)ny;
/* fprintf(stderr,"(%d,%d) ->",nx,ny); */
- rx=op_run(opx,opxl,parm,parmlen);
- ry=op_run(opy,opyl,parm,parmlen);
+ rx=i_op_run(opx,opxl,parm,parmlen);
+ ry=i_op_run(opy,opyl,parm,parmlen);
/* fprintf(stderr,"(%f,%f)\n",rx,ry); */
i_gpix(im,rx,ry,&val);
i_ppix(new_img,nx,ny,&val);
return colorcnt;
}
-
-symbol_table_t symbol_table={i_has_format,ICL_set_internal,ICL_info,
- i_img_new,i_img_empty,i_img_empty_ch,i_img_exorcise,
- i_img_info,i_img_setmask,i_img_getmask,i_ppix,i_gpix,
- i_box,i_draw,i_arc,i_copyto,i_copyto_trans,i_rubthru};
-
-
/*
=back
=cut
*/
+static
int
i_ppix_d(i_img *im, int x, int y, i_color *val) {
int ch;
=cut
*/
+static
int
i_gpix_d(i_img *im, int x, int y, i_color *val) {
int ch;
if (x>-1 && x<im->xsize && y>-1 && y<im->ysize) {
for(ch=0;ch<im->channels;ch++)
- val->channel[ch]=im->idata[(x+y*im->xsize)*im->channels+ch];
+ val->channel[ch]=im->idata[(x+y*im->xsize)*im->channels+ch];
return 0;
}
+ for(ch=0;ch<im->channels;ch++) val->channel[ch] = 0;
return -1; /* error was cliped */
}
=cut
*/
+static
int
i_glin_d(i_img *im, int l, int r, int y, i_color *vals) {
int ch, count, i;
=cut
*/
+static
int
i_plin_d(i_img *im, int l, int r, int y, i_color *vals) {
int ch, count, i;
=cut
*/
+static
int
i_ppixf_d(i_img *im, int x, int y, i_fcolor *val) {
int ch;
=cut
*/
+static
int
i_gpixf_d(i_img *im, int x, int y, i_fcolor *val) {
int ch;
=cut
*/
+static
int
i_glinf_d(i_img *im, int l, int r, int y, i_fcolor *vals) {
int ch, count, i;
=cut
*/
+static
int
i_plinf_d(i_img *im, int l, int r, int y, i_fcolor *vals) {
int ch, count, i;
=cut
*/
-int i_gsamp_d(i_img *im, int l, int r, int y, i_sample_t *samps,
- int *chans, int chan_count) {
+static
+int
+i_gsamp_d(i_img *im, int l, int r, int y, i_sample_t *samps,
+ const int *chans, int chan_count) {
int ch, count, i, w;
unsigned char *data;
=cut
*/
-int i_gsampf_d(i_img *im, int l, int r, int y, i_fsample_t *samps,
- int *chans, int chan_count) {
+static
+int
+i_gsampf_d(i_img *im, int l, int r, int y, i_fsample_t *samps,
+ const int *chans, int chan_count) {
int ch, count, i, w;
unsigned char *data;
for (ch = 0; ch < chan_count; ++ch) {
=cut
*/
int i_gsampf_fp(i_img *im, int l, int r, int y, i_fsample_t *samp,
- int *chans, int chan_count) {
+ int const *chans, int chan_count) {
i_sample_t *work;
if (y >= 0 && y < im->ysize && l < im->xsize && l >= 0) {
gci->cpos = 0;
gci->length = did_read;
- copy_size = min(length, gci->length);
+ copy_size = i_min(length, gci->length);
memcpy(buf, gci->buffer, copy_size);
gci->cpos += copy_size;
buf += copy_size;
}
/*
-=item free_gen_read_data(i_gen_read_data *)
+=item i_free_gen_read_data(i_gen_read_data *)
Cleans up.
=cut
*/
-void free_gen_read_data(i_gen_read_data *self) {
+void i_free_gen_read_data(i_gen_read_data *self) {
myfree(self);
}
Allocates and initializes the data structure used by i_gen_writer.
-This should be released with L<image.c/free_gen_write_data>
+This should be released with L<image.c/i_free_gen_write_data>
=cut
*/
i_gen_write_data *self = mymalloc(sizeof(i_gen_write_data));
self->cb = cb;
self->userdata = userdata;
- self->maxlength = min(max_length, sizeof(self->buffer));
+ self->maxlength = i_min(max_length, sizeof(self->buffer));
if (self->maxlength < 0)
self->maxlength = sizeof(self->buffer);
self->filledto = 0;
}
/*
-=item free_gen_write_data(i_gen_write_data *info, int flush)
+=item i_free_gen_write_data(i_gen_write_data *info, int flush)
Cleans up the write buffer.
=cut
*/
-int free_gen_write_data(i_gen_write_data *info, int flush)
+int i_free_gen_write_data(i_gen_write_data *info, int flush)
{
int result = !flush ||
info->filledto == 0 ||
return result;
}
+
+
+/*
+=item i_test_format_probe(io_glue *data, int length)
+
+Check the beginning of the supplied file for a 'magic number'
+
+=cut
+*/
+
+
+char *
+i_test_format_probe(io_glue *data, int length) {
+
+ static struct {
+ char *magic;
+ char *name;
+ } formats[] = {
+ {"\xFF\xD8", "jpeg"},
+ {"GIF87a", "gif"},
+ {"GIF89a", "gif"},
+ {"MM\0*", "tiff"},
+ {"II*\0", "tiff"},
+ {"BM", "bmp"},
+ {"\x89PNG\x0d\x0a\x1a\x0a", "png"},
+ {"P1", "pnm"},
+ {"P2", "pnm"},
+ {"P3", "pnm"},
+ {"P4", "pnm"},
+ {"P5", "pnm"},
+ {"P6", "pnm"},
+ };
+ unsigned int i;
+ char head[18];
+ char *match = NULL;
+ ssize_t rc;
+
+ io_glue_commit_types(data);
+ rc = data->readcb(data, head, 18);
+ if (rc == -1) return NULL;
+ data->seekcb(data, -rc, SEEK_CUR);
+
+ for(i=0; i<sizeof(formats)/sizeof(formats[0]); i++) {
+ int c;
+ ssize_t len = strlen(formats[i].magic);
+ if (rc<len) continue;
+ c = !strncmp(formats[i].magic, head, len);
+ if (c) {
+ match = formats[i].name;
+ break;
+ }
+ }
+
+ /*
+ if (match && !strcmp(match, "jpeg")) {
+ unsigned int x0, x1;
+ rc = data->readcb(data, head, 18);
+ if (rc == -1) return NULL;
+ x0 = (unsigned char)head[0];
+ x1 = (unsigned char)head[1];
+ data->seekcb(data, -rc, SEEK_CUR);
+ printf("Jpeg reread: %x %x\n", x0, x1);
+ }
+ */
+
+ if (!match &&
+ (rc == 18) &&
+ tga_header_verify(head)) return "tga";
+ return match;
+}
+
+
+
+
/*
=back
+=head1 AUTHOR
+
+Arnar M. Hrafnkelsson <addi@umich.edu>
+
+Tony Cook <tony@develop-help.com>
+
=head1 SEE ALSO
L<Imager>, L<gif.c>
projects / imager.git / blobdiff