add psamp(), psampf() to C image API
authorTony Cook <tony@develop-help.com>
Mon, 30 Jan 2012 12:04:27 +0000 (23:04 +1100)
committerTony Cook <tony@develop-help.com>
Mon, 13 Feb 2012 10:00:09 +0000 (21:00 +1100)
apidocs.perl
imdatatypes.h
imexttypes.h
img16.c
img8.c
imgdouble.c
immacros.h
lib/Imager/APIRef.pod
maskimg.c
palimg.c

index 68bac80..d08cf1f 100644 (file)
@@ -187,7 +187,7 @@ close OUT;
 
 
 sub make_func_list {
-  my @funcs = qw(i_img i_color i_fcolor i_fill_t mm_log i_img_color_channels i_img_has_alpha i_img_dim i_DF i_DFc i_DFp i_DFcp i_psamp_bits i_gsamp_bits);
+  my @funcs = qw(i_img i_color i_fcolor i_fill_t mm_log i_img_color_channels i_img_has_alpha i_img_dim i_DF i_DFc i_DFp i_DFcp i_psamp_bits i_gsamp_bits i_psamp i_psampf);
   open FUNCS, "< imexttypes.h"
     or die "Cannot open imexttypes.h: $!\n";
   my $in_struct;
index e20372f..d9ad0eb 100644 (file)
@@ -175,6 +175,12 @@ typedef i_img_dim (*i_f_gsamp_bits_t)(i_img *im, i_img_dim x, i_img_dim r, i_img
                            const int *chans, int chan_count, int bits);
 typedef i_img_dim (*i_f_psamp_bits_t)(i_img *im, i_img_dim x, i_img_dim r, i_img_dim y, unsigned const *samp,
                                 const int *chans, int chan_count, int bits);
+typedef i_img_dim
+(*i_f_psamp_t)(i_img *im, i_img_dim x, i_img_dim r, i_img_dim y, 
+               const i_sample_t *samp, const int *chan, int chan_count);
+typedef i_img_dim
+(*i_f_psampf_t)(i_img *im, i_img_dim x, i_img_dim r, i_img_dim y,
+               const i_fsample_t *samp, const int *chan, int chan_count);
 
 /*
 =item i_img
@@ -269,6 +275,14 @@ i_f_gsamp_bits - implements i_gsamp_bits() for this image.
 
 i_f_psamp_bits - implements i_psamp_bits() for this image.
 
+=item *
+
+i_f_psamp - implements psamp() for this image.
+
+=item *
+
+i_f_psampf - implements psamp() for this image.
+
 =back
 
 =cut
@@ -316,6 +330,10 @@ struct i_img_ {
   i_f_gsamp_bits_t i_f_gsamp_bits;
   i_f_psamp_bits_t i_f_psamp_bits;
 
+  /* as of 0.88 */
+  i_f_psamp_t i_f_psamp;
+  i_f_psampf_t i_f_psampf;
+
   void *im_data;
 };
 
index 1355382..69836c9 100644 (file)
  readers.  Switching away from calling readcb etc to i_io_read() etc
  should fix your code.
 
+ Version 4 added i_psamp() and i_psampf() pointers to the i_img
+ structure.
+
 */
-#define IMAGER_API_VERSION 3
+#define IMAGER_API_VERSION 4
 
 /*
  IMAGER_API_LEVEL is the level of the structure.  New function pointers
diff --git a/img16.c b/img16.c
index 267c1d6..f44f8b3 100644 (file)
--- a/img16.c
+++ b/img16.c
@@ -39,6 +39,8 @@ static i_img_dim i_gsamp_bits_d16(i_img *im, i_img_dim l, i_img_dim r, i_img_dim
                            int const *chans, int chan_count, int bits);
 static i_img_dim i_psamp_bits_d16(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, unsigned const *samps, 
                            int const *chans, int chan_count, int bits);
+static i_img_dim i_psamp_d16(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, const i_sample_t *samps, const int *chans, int chan_count);
+static i_img_dim i_psampf_d16(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, const i_fsample_t *samps, const int *chans, int chan_count);
 
 /*
 =item IIM_base_16bit_direct
@@ -85,6 +87,9 @@ static i_img IIM_base_16bit_direct =
 
   i_gsamp_bits_d16,
   i_psamp_bits_d16,
+
+  i_psamp_d16,
+  i_psampf_d16
 };
 
 /* it's possible some platforms won't have a 16-bit integer type,
@@ -632,6 +637,191 @@ i_psamp_bits_d16(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, unsigned cons
   }
 }
 
+/*
+=item i_psamp_d16(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, const i_sample_t *samps, int *chans, int chan_count)
+
+Writes sample values to im for the horizontal line (l, y) to (r-1,y)
+for the channels specified by chans, an array of int with chan_count
+elements.
+
+Returns the number of samples written (which should be (r-l) *
+bits_set(chan_mask)
+
+=cut
+*/
+
+static
+i_img_dim
+i_psamp_d16(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, 
+         const i_sample_t *samps, const int *chans, int chan_count) {
+  int ch;
+  i_img_dim count, i, w;
+
+  if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) {
+    int all_unmasked;
+    i_img_dim offset;
+    if (r > im->xsize)
+      r = im->xsize;
+    offset = (l+y*im->xsize) * im->channels;
+    w = r - l;
+    count = 0;
+
+    if (chans) {
+      /* make sure we have good channel numbers */
+      /* and test if all channels specified are in the mask */
+      int all_in_mask = 1;
+      for (ch = 0; ch < chan_count; ++ch) {
+        if (chans[ch] < 0 || chans[ch] >= im->channels) {
+          i_push_errorf(0, "No channel %d in this image", chans[ch]);
+          return -1;
+        }
+       if (!((1 << chans[ch]) & im->ch_mask))
+         all_in_mask = 0;
+      }
+      if (all_in_mask) {
+       for (i = 0; i < w; ++i) {
+         for (ch = 0; ch < chan_count; ++ch) {
+           STORE8as16(im->idata, offset + chans[ch], *samps);
+           ++samps;
+           ++count;
+         }
+         offset += im->channels;
+       }
+      }
+      else {
+       for (i = 0; i < w; ++i) {
+         for (ch = 0; ch < chan_count; ++ch) {
+           if (im->ch_mask & (1 << (chans[ch])))
+           STORE8as16(im->idata, offset + chans[ch], *samps);
+           ++samps;
+           ++count;
+         }
+         offset += im->channels;
+       }
+      }
+    }
+    else {
+      if (chan_count <= 0 || chan_count > im->channels) {
+       i_push_errorf(0, "chan_count %d out of range, must be >0, <= channels", 
+                     chan_count);
+       return -1;
+      }
+      for (i = 0; i < w; ++i) {
+       unsigned mask = 1;
+        for (ch = 0; ch < chan_count; ++ch) {
+         if (im->ch_mask & mask)
+           STORE8as16(im->idata, offset + ch, *samps);
+         ++samps;
+          ++count;
+         mask <<= 1;
+        }
+        offset += im->channels;
+      }
+    }
+
+    return count;
+  }
+  else {
+    i_push_error(0, "Image position outside of image");
+    return -1;
+  }
+}
+
+/*
+=item i_psampf_d16(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, const i_fsample_t *samps, int *chans, int chan_count)
+
+Writes sample values to im for the horizontal line (l, y) to (r-1,y)
+for the channels specified by chans, an array of int with chan_count
+elements.
+
+Returns the number of samples written (which should be (r-l) *
+bits_set(chan_mask)
+
+=cut
+*/
+
+static
+i_img_dim
+i_psampf_d16(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, 
+         const i_fsample_t *samps, const int *chans, int chan_count) {
+  int ch;
+  i_img_dim count, i, w;
+
+  if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) {
+    int all_unmasked;
+    i_img_dim offset;
+    if (r > im->xsize)
+      r = im->xsize;
+    offset = (l+y*im->xsize) * im->channels;
+    w = r - l;
+    count = 0;
+
+    if (chans) {
+      /* make sure we have good channel numbers */
+      /* and test if all channels specified are in the mask */
+      int all_in_mask = 1;
+      for (ch = 0; ch < chan_count; ++ch) {
+        if (chans[ch] < 0 || chans[ch] >= im->channels) {
+          i_push_errorf(0, "No channel %d in this image", chans[ch]);
+          return -1;
+        }
+       if (!((1 << chans[ch]) & im->ch_mask))
+         all_in_mask = 0;
+      }
+      if (all_in_mask) {
+       for (i = 0; i < w; ++i) {
+         for (ch = 0; ch < chan_count; ++ch) {
+           unsigned samp16 = SampleFTo16(*samps);
+           STORE16(im->idata, offset + chans[ch], samp16);
+           ++samps;
+           ++count;
+         }
+         offset += im->channels;
+       }
+      }
+      else {
+       for (i = 0; i < w; ++i) {
+         for (ch = 0; ch < chan_count; ++ch) {
+           if (im->ch_mask & (1 << (chans[ch]))) {
+             unsigned samp16 = SampleFTo16(*samps);
+             STORE16(im->idata, offset + chans[ch], samp16);
+           }
+           ++samps;
+           ++count;
+         }
+         offset += im->channels;
+       }
+      }
+    }
+    else {
+      if (chan_count <= 0 || chan_count > im->channels) {
+       i_push_errorf(0, "chan_count %d out of range, must be >0, <= channels", 
+                     chan_count);
+       return -1;
+      }
+      for (i = 0; i < w; ++i) {
+       unsigned mask = 1;
+        for (ch = 0; ch < chan_count; ++ch) {
+         if (im->ch_mask & mask) {
+           unsigned samp16 = SampleFTo16(*samps);
+           STORE16(im->idata, offset + ch, samp16);
+         }
+         ++samps;
+          ++count;
+         mask <<= 1;
+        }
+        offset += im->channels;
+      }
+    }
+
+    return count;
+  }
+  else {
+    i_push_error(0, "Image position outside of image");
+    return -1;
+  }
+}
+
 /*
 =back
 
diff --git a/img8.c b/img8.c
index ea23d28..9a799f3 100644 (file)
--- a/img8.c
+++ b/img8.c
@@ -11,6 +11,8 @@ static i_img_dim i_glinf_d(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_f
 static i_img_dim i_plinf_d(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, const i_fcolor *vals);
 static i_img_dim i_gsamp_d(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_sample_t *samps, const int *chans, int chan_count);
 static i_img_dim i_gsampf_d(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_fsample_t *samps, const int *chans, int chan_count);
+static i_img_dim i_psamp_d(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, const i_sample_t *samps, const int *chans, int chan_count);
+static i_img_dim i_psampf_d(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, const i_fsample_t *samps, const int *chans, int chan_count);
 
 /*
 =item IIM_base_8bit_direct (static)
@@ -55,6 +57,9 @@ static i_img IIM_base_8bit_direct =
 
   i_gsamp_bits_fb,
   NULL, /* i_f_psamp_bits */
+
+  i_psamp_d,
+  i_psampf_d
 };
 
 /*static void set_8bit_direct(i_img *im) {
@@ -609,6 +614,185 @@ i_gsampf_d(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_fsample_t *samps,
   }
 }
 
+/*
+=item i_psamp_d(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_sample_t *samps, int *chans, int chan_count)
+
+Writes sample values to im for the horizontal line (l, y) to (r-1,y)
+for the channels specified by chans, an array of int with chan_count
+elements.
+
+Returns the number of samples written (which should be (r-l) *
+bits_set(chan_mask)
+
+=cut
+*/
+
+static
+i_img_dim
+i_psamp_d(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, 
+         const i_sample_t *samps, const int *chans, int chan_count) {
+  int ch;
+  i_img_dim count, i, w;
+  unsigned char *data;
+
+  if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) {
+    int all_unmasked;
+    if (r > im->xsize)
+      r = im->xsize;
+    data = im->idata + (l+y*im->xsize) * im->channels;
+    w = r - l;
+    count = 0;
+
+    if (chans) {
+      /* make sure we have good channel numbers */
+      /* and test if all channels specified are in the mask */
+      int all_in_mask = 1;
+      for (ch = 0; ch < chan_count; ++ch) {
+        if (chans[ch] < 0 || chans[ch] >= im->channels) {
+          i_push_errorf(0, "No channel %d in this image", chans[ch]);
+          return -1;
+        }
+       if (!((1 << chans[ch]) & im->ch_mask))
+         all_in_mask = 0;
+      }
+      if (all_in_mask) {
+       for (i = 0; i < w; ++i) {
+         for (ch = 0; ch < chan_count; ++ch) {
+           data[chans[ch]] = *samps++;
+           ++count;
+         }
+         data += im->channels;
+       }
+      }
+      else {
+       for (i = 0; i < w; ++i) {
+         for (ch = 0; ch < chan_count; ++ch) {
+           if (im->ch_mask & (1 << (chans[ch])))
+             data[chans[ch]] = *samps;
+           ++samps;
+           ++count;
+         }
+         data += im->channels;
+       }
+      }
+    }
+    else {
+      if (chan_count <= 0 || chan_count > im->channels) {
+       i_push_errorf(0, "chan_count %d out of range, must be >0, <= channels", 
+                     chan_count);
+       return -1;
+      }
+      for (i = 0; i < w; ++i) {
+       unsigned mask = 1;
+        for (ch = 0; ch < chan_count; ++ch) {
+         if (im->ch_mask & mask)
+           data[ch] = *samps;
+         ++samps;
+          ++count;
+         mask <<= 1;
+        }
+        data += im->channels;
+      }
+    }
+
+    return count;
+  }
+  else {
+    i_push_error(0, "Image position outside of image");
+    return -1;
+  }
+}
+
+/*
+=item i_psampf_d(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, const i_fsample_t *samps, int *chans, int chan_count)
+
+Writes sample values to im for the horizontal line (l, y) to (r-1,y)
+for the channels specified by chans, an array of int with chan_count
+elements.
+
+Returns the number of samples written (which should be (r-l) *
+bits_set(chan_mask)
+
+=cut
+*/
+
+static
+i_img_dim
+i_psampf_d(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, 
+         const i_fsample_t *samps, const int *chans, int chan_count) {
+  int ch;
+  i_img_dim count, i, w;
+  unsigned char *data;
+
+  if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) {
+    int all_unmasked;
+    if (r > im->xsize)
+      r = im->xsize;
+    data = im->idata + (l+y*im->xsize) * im->channels;
+    w = r - l;
+    count = 0;
+
+    if (chans) {
+      /* make sure we have good channel numbers */
+      /* and test if all channels specified are in the mask */
+      int all_in_mask = 1;
+      for (ch = 0; ch < chan_count; ++ch) {
+        if (chans[ch] < 0 || chans[ch] >= im->channels) {
+          i_push_errorf(0, "No channel %d in this image", chans[ch]);
+          return -1;
+        }
+       if (!((1 << chans[ch]) & im->ch_mask))
+         all_in_mask = 0;
+      }
+      if (all_in_mask) {
+       for (i = 0; i < w; ++i) {
+         for (ch = 0; ch < chan_count; ++ch) {
+           data[chans[ch]] = SampleFTo8(*samps);
+           ++samps;
+           ++count;
+         }
+         data += im->channels;
+       }
+      }
+      else {
+       for (i = 0; i < w; ++i) {
+         for (ch = 0; ch < chan_count; ++ch) {
+           if (im->ch_mask & (1 << (chans[ch])))
+             data[chans[ch]] = SampleFTo8(*samps);
+           ++samps;
+           ++count;
+         }
+         data += im->channels;
+       }
+      }
+    }
+    else {
+      if (chan_count <= 0 || chan_count > im->channels) {
+       i_push_errorf(0, "chan_count %d out of range, must be >0, <= channels", 
+                     chan_count);
+       return -1;
+      }
+      for (i = 0; i < w; ++i) {
+       unsigned mask = 1;
+        for (ch = 0; ch < chan_count; ++ch) {
+         if (im->ch_mask & mask)
+           data[ch] = SampleFTo8(*samps);
+         ++samps;
+          ++count;
+         mask <<= 1;
+        }
+        data += im->channels;
+      }
+    }
+
+    return count;
+  }
+  else {
+    i_push_error(0, "Image position outside of image");
+    return -1;
+  }
+}
+
 /*
 =back
 
index c6b2a5b..0838a29 100644 (file)
@@ -35,6 +35,10 @@ static i_img_dim i_gsamp_ddoub(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y,
                        int const *chans, int chan_count);
 static i_img_dim i_gsampf_ddoub(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_fsample_t *samps, 
                         int const *chans, int chan_count);
+static i_img_dim 
+i_psamp_ddoub(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, const i_sample_t *samps, const int *chans, int chan_count);
+static i_img_dim 
+i_psampf_ddoub(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, const i_fsample_t *samps, const int *chans, int chan_count);
 
 /*
 =item IIM_base_16bit_direct
@@ -81,6 +85,9 @@ static i_img IIM_base_double_direct =
 
   i_gsamp_bits_fb,
   NULL, /* i_f_psamp_bits */
+
+  i_psamp_ddoub, /* i_f_psamp */
+  i_psampf_ddoub /* i_f_psampf */
 };
 
 /*
@@ -410,6 +417,190 @@ static i_img_dim i_gsampf_ddoub(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y
   }
 }
 
+/*
+=item i_psamp_ddoub(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, const i_sample_t *samps, int *chans, int chan_count)
+
+Writes sample values to im for the horizontal line (l, y) to (r-1,y)
+for the channels specified by chans, an array of int with chan_count
+elements.
+
+Returns the number of samples written (which should be (r-l) *
+bits_set(chan_mask)
+
+=cut
+*/
+
+static
+i_img_dim
+i_psamp_ddoub(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, 
+         const i_sample_t *samps, const int *chans, int chan_count) {
+  int ch;
+  i_img_dim count, i, w;
+
+  if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) {
+    int all_unmasked;
+    i_img_dim offset;
+    if (r > im->xsize)
+      r = im->xsize;
+    offset = (l+y*im->xsize) * im->channels;
+    w = r - l;
+    count = 0;
+
+    if (chans) {
+      /* make sure we have good channel numbers */
+      /* and test if all channels specified are in the mask */
+      int all_in_mask = 1;
+      for (ch = 0; ch < chan_count; ++ch) {
+        if (chans[ch] < 0 || chans[ch] >= im->channels) {
+          i_push_errorf(0, "No channel %d in this image", chans[ch]);
+          return -1;
+        }
+       if (!((1 << chans[ch]) & im->ch_mask))
+         all_in_mask = 0;
+      }
+      if (all_in_mask) {
+       for (i = 0; i < w; ++i) {
+         for (ch = 0; ch < chan_count; ++ch) {
+           ((double*)im->idata)[offset + chans[ch]] = Sample8ToF(*samps);
+           ++samps;
+           ++count;
+         }
+         offset += im->channels;
+       }
+      }
+      else {
+       for (i = 0; i < w; ++i) {
+         for (ch = 0; ch < chan_count; ++ch) {
+           if (im->ch_mask & (1 << (chans[ch])))
+             ((double*)im->idata)[offset + chans[ch]] = Sample8ToF(*samps);
+           
+           ++samps;
+           ++count;
+         }
+         offset += im->channels;
+       }
+      }
+    }
+    else {
+      if (chan_count <= 0 || chan_count > im->channels) {
+       i_push_errorf(0, "chan_count %d out of range, must be >0, <= channels", 
+                     chan_count);
+       return -1;
+      }
+      for (i = 0; i < w; ++i) {
+       unsigned mask = 1;
+        for (ch = 0; ch < chan_count; ++ch) {
+         if (im->ch_mask & mask)
+           ((double*)im->idata)[offset + ch] = Sample8ToF(*samps);
+
+         ++samps;
+          ++count;
+         mask <<= 1;
+        }
+        offset += im->channels;
+      }
+    }
+
+    return count;
+  }
+  else {
+    i_push_error(0, "Image position outside of image");
+    return -1;
+  }
+}
+
+/*
+=item i_psampf_ddoub(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, const i_fsample_t *samps, int *chans, int chan_count)
+
+Writes sample values to im for the horizontal line (l, y) to (r-1,y)
+for the channels specified by chans, an array of int with chan_count
+elements.
+
+Returns the number of samples written (which should be (r-l) *
+bits_set(chan_mask)
+
+=cut
+*/
+
+static
+i_img_dim
+i_psampf_ddoub(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, 
+              const i_fsample_t *samps, const int *chans, int chan_count) {
+  int ch;
+  i_img_dim count, i, w;
+
+  if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) {
+    int all_unmasked;
+    i_img_dim offset;
+    if (r > im->xsize)
+      r = im->xsize;
+    offset = (l+y*im->xsize) * im->channels;
+    w = r - l;
+    count = 0;
+
+    if (chans) {
+      /* make sure we have good channel numbers */
+      /* and test if all channels specified are in the mask */
+      int all_in_mask = 1;
+      for (ch = 0; ch < chan_count; ++ch) {
+        if (chans[ch] < 0 || chans[ch] >= im->channels) {
+          i_push_errorf(0, "No channel %d in this image", chans[ch]);
+          return -1;
+        }
+       if (!((1 << chans[ch]) & im->ch_mask))
+         all_in_mask = 0;
+      }
+      if (all_in_mask) {
+       for (i = 0; i < w; ++i) {
+         for (ch = 0; ch < chan_count; ++ch) {
+           ((double*)im->idata)[offset + chans[ch]] = *samps;
+           ++samps;
+           ++count;
+         }
+         offset += im->channels;
+       }
+      }
+      else {
+       for (i = 0; i < w; ++i) {
+         for (ch = 0; ch < chan_count; ++ch) {
+           if (im->ch_mask & (1 << (chans[ch])))
+             ((double*)im->idata)[offset + chans[ch]] = *samps;
+           
+           ++samps;
+           ++count;
+         }
+         offset += im->channels;
+       }
+      }
+    }
+    else {
+      if (chan_count <= 0 || chan_count > im->channels) {
+       i_push_errorf(0, "chan_count %d out of range, must be >0, <= channels", 
+                     chan_count);
+       return -1;
+      }
+      for (i = 0; i < w; ++i) {
+       unsigned mask = 1;
+        for (ch = 0; ch < chan_count; ++ch) {
+         if (im->ch_mask & mask)
+           ((double*)im->idata)[offset + ch] = *samps;
+
+         ++samps;
+          ++count;
+         mask <<= 1;
+        }
+        offset += im->channels;
+      }
+    }
+
+    return count;
+  }
+  else {
+    i_push_error(0, "Image position outside of image");
+    return -1;
+  }
+}
+
 /*
 =item i_img_to_drgb(im)
 
index bd0e4c0..81ad3af 100644 (file)
@@ -30,4 +30,49 @@ The number of channels holding color information.
 
 #define i_img_color_channels(im) (i_img_has_alpha(im) ? (im)->channels - 1 : (im)->channels)
 
+/*
+=item i_psamp(im, left, right, y, samples, channels, channel_count)
+=category Drawing
+
+Writes sample values from C<samples> to C<im> for the horizontal line
+(left, y) to (right-1, y) inclusive for the channels specified by
+C<channels>, an array of C<int> with C<channel_count> elements.
+
+If C<channels> is C<NULL> then the first C<channels_count> channels
+are written to for each pixel.
+
+Returns the number of samples written, which should be (right - left)
+* channel_count.  If a channel not in the image is in channels, left
+is negative, left is outside the image or y is outside the image,
+returns -1 and pushes an error.
+
+=cut
+*/
+
+#define i_psamp(im, l, r, y, samps, chans, count) \
+  (((im)->i_f_psamp)((im), (l), (r), (y), (samps), (chans), (count)))
+
+/*
+=item i_psampf(im, left, right, y, samples, channels, channel_count)
+=category Drawing
+
+Writes floating point sample values from C<samples> to C<im> for the
+horizontal line (left, y) to (right-1, y) inclusive for the channels
+specified by C<channels>, an array of C<int> with C<channel_count>
+elements.
+
+If C<channels> is C<NULL> then the first C<channels_count> channels
+are written to for each pixel.
+
+Returns the number of samples written, which should be (right - left)
+* channel_count.  If a channel not in the image is in channels, left
+is negative, left is outside the image or y is outside the image,
+returns -1 and pushes an error.
+
+=cut
+*/
+
+#define i_psampf(im, l, r, y, samps, chans, count) \
+  (((im)->i_f_psampf)((im), (l), (r), (y), (samps), (chans), (count)))
+
 #endif
index 22c45a3..0d28ad7 100644 (file)
@@ -257,6 +257,14 @@ i_f_gsamp_bits - implements i_gsamp_bits() for this image.
 
 i_f_psamp_bits - implements i_psamp_bits() for this image.
 
+=item *
+
+i_f_psamp - implements psamp() for this image.
+
+=item *
+
+i_f_psampf - implements psamp() for this image.
+
 =back
 
 
@@ -773,6 +781,24 @@ color to the image.
 =for comment
 From: File imext.c
 
+=item i_psamp(im, left, right, y, samples, channels, channel_count)
+
+Writes sample values from C<samples> to C<im> for the horizontal line
+(left, y) to (right-1, y) inclusive for the channels specified by
+C<channels>, an array of C<int> with C<channel_count> elements.
+
+If C<channels> is C<NULL> then the first C<channels_count> channels
+are written to for each pixel.
+
+Returns the number of samples written, which should be (right - left)
+* channel_count.  If a channel not in the image is in channels, left
+is negative, left is outside the image or y is outside the image,
+returns -1 and pushes an error.
+
+
+=for comment
+From: File immacros.h
+
 =item i_psamp_bits(im, left, right, y, samples, channels, channel_count, bits)
 
 Writes integer samples scaled to C<bits> bits of precision from the
@@ -790,6 +816,25 @@ Pushes errors, but does not call C<i_clear_error()>.
 =for comment
 From: File imext.c
 
+=item i_psampf(im, left, right, y, samples, channels, channel_count)
+
+Writes floating point sample values from C<samples> to C<im> for the
+horizontal line (left, y) to (right-1, y) inclusive for the channels
+specified by C<channels>, an array of C<int> with C<channel_count>
+elements.
+
+If C<channels> is C<NULL> then the first C<channels_count> channels
+are written to for each pixel.
+
+Returns the number of samples written, which should be (right - left)
+* channel_count.  If a channel not in the image is in channels, left
+is negative, left is outside the image or y is outside the image,
+returns -1 and pushes an error.
+
+
+=for comment
+From: File immacros.h
+
 
 =back
 
index 828c391..5ed0660 100644 (file)
--- a/maskimg.c
+++ b/maskimg.c
@@ -48,6 +48,12 @@ static i_img_dim i_gsampf_masked(i_img *im, i_img_dim l, i_img_dim r, i_img_dim
                            int const *chans, int chan_count);
 static i_img_dim i_gpal_masked(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_palidx *vals);
 static i_img_dim i_ppal_masked(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, const i_palidx *vals);
+static i_img_dim
+psamp_masked(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y,
+              const i_sample_t *samples, const int *chans, int chan_count);
+static i_img_dim
+psampf_masked(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y,
+              const i_fsample_t *samples, const int *chans, int chan_count);
 
 /*
 =item IIM_base_masked
@@ -89,6 +95,12 @@ static i_img IIM_base_masked =
   i_setcolors_forward, /* i_f_setcolors */
 
   i_destroy_masked, /* i_f_destroy */
+
+  NULL, /* i_f_gsamp_bits */
+  NULL, /* i_f_psamp_bits */
+
+  psamp_masked, /* i_f_psamp */
+  psampf_masked /* i_f_psampf */
 };
 
 /*
@@ -512,6 +524,139 @@ static i_img_dim i_ppal_masked(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y,
   }
 }
 
+/*
+=item psamp_masked()
+
+i_psamp() implementation for masked images.
+
+=cut
+*/
+
+static i_img_dim
+psamp_masked(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y,
+            const i_sample_t *samples, const int *chans, int chan_count) {
+  i_img_mask_ext *ext = MASKEXT(im);
+
+  if (y >= 0 && y < im->ysize && l < im->xsize && l >= 0) {
+    unsigned old_ch_mask = ext->targ->ch_mask;
+    i_img_dim result = 0;
+    ext->targ->ch_mask = im->ch_mask;
+    if (r > im->xsize)
+      r = im->xsize;
+    if (ext->mask) {
+      i_img_dim w = r - l;
+      i_img_dim i = 0;
+      i_img_dim x = ext->xbase + l;
+      i_img_dim work_y = y + ext->ybase;
+      i_sample_t *mask_samps = ext->samps;
+       
+      i_gsamp(ext->mask, l, r, y, mask_samps, NULL, 1);
+      /* not optimizing this yet */
+      while (i < w) {
+       if (mask_samps[i]) {
+         /* found a set mask value, try to do a run */
+         i_img_dim run_left = x;
+         const i_sample_t *run_samps = samples;
+         ++i;
+         ++x;
+         samples += chan_count;
+         
+         while (i < w && mask_samps[i]) {
+           ++i;
+           ++x;
+           samples += chan_count;
+         }
+         result += i_psamp(ext->targ, run_left, x, work_y, run_samps, chans, chan_count);
+       }
+       else {
+         ++i;
+         ++x;
+         samples += chan_count;
+         result += chan_count; /* pretend we wrote masked off pixels */
+       }
+      }
+    }
+    else {
+      result = i_psamp(ext->targ, l + ext->xbase, r + ext->xbase, 
+                      y + ext->ybase, samples, chans, chan_count);
+      im->type = ext->targ->type;
+    }
+    ext->targ->ch_mask = old_ch_mask;
+    return result;
+  }
+  else {
+    i_push_error(0, "Image position outside of image");
+    return -1;
+  }
+}
+
+/*
+=item psampf_masked()
+
+i_psampf() implementation for masked images.
+
+=cut
+*/
+
+static i_img_dim
+psampf_masked(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y,
+            const i_fsample_t *samples, const int *chans, int chan_count) {
+  i_img_mask_ext *ext = MASKEXT(im);
+
+  if (y >= 0 && y < im->ysize && l < im->xsize && l >= 0) {
+    i_img_dim result = 0;
+    unsigned old_ch_mask = ext->targ->ch_mask;
+    ext->targ->ch_mask = im->ch_mask;
+    if (r > im->xsize)
+      r = im->xsize;
+    if (ext->mask) {
+      i_img_dim w = r - l;
+      i_img_dim i = 0;
+      i_img_dim x = ext->xbase + l;
+      i_img_dim work_y = y + ext->ybase;
+      i_sample_t *mask_samps = ext->samps;
+       
+      i_gsamp(ext->mask, l, r, y, mask_samps, NULL, 1);
+      /* not optimizing this yet */
+      while (i < w) {
+       if (mask_samps[i]) {
+         /* found a set mask value, try to do a run */
+         i_img_dim run_left = x;
+         const i_fsample_t *run_samps = samples;
+         ++i;
+         ++x;
+         samples += chan_count;
+         
+         while (i < w && mask_samps[i]) {
+           ++i;
+           ++x;
+           samples += chan_count;
+         }
+         result += i_psampf(ext->targ, run_left, x, work_y, run_samps, chans, chan_count);
+       }
+       else {
+         ++i;
+         ++x;
+         samples += chan_count;
+         result += chan_count; /* pretend we wrote masked off pixels */
+       }
+      }
+    }
+    else {
+      result = i_psampf(ext->targ, l + ext->xbase, r + ext->xbase, 
+                       y + ext->ybase, samples,
+                                chans, chan_count);
+      im->type = ext->targ->type;
+    }
+    ext->targ->ch_mask = old_ch_mask;
+    return result;
+  }
+  else {
+    i_push_error(0, "Image position outside of image");
+    return -1;
+  }
+}
+
 
 /*
 =back
index 07720d9..72b43fa 100644 (file)
--- a/palimg.c
+++ b/palimg.c
@@ -37,6 +37,10 @@ static int i_findcolor_p(i_img *im, const i_color *color, i_palidx *entry);
 static int i_setcolors_p(i_img *im, int index, const i_color *color, int count);
 
 static void i_destroy_p(i_img *im);
+static i_img_dim 
+i_psamp_p(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, const i_sample_t *samps, const int *chans, int chan_count);
+static i_img_dim 
+i_psampf_p(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, const i_fsample_t *samps, const int *chans, int chan_count);
 
 static i_img IIM_base_8bit_pal =
 {
@@ -74,6 +78,9 @@ static i_img IIM_base_8bit_pal =
 
   i_gsamp_bits_fb,
   NULL, /* i_f_psamp_bits */
+  
+  i_psamp_p,
+  i_psampf_p
 };
 
 /*
@@ -274,14 +281,33 @@ present in the image.
 */
 static int 
 i_ppix_p(i_img *im, i_img_dim x, i_img_dim y, const i_color *val) {
+  const i_color *work_val = val;
+  i_color workc;
   i_palidx which;
+  const unsigned all_mask = ( 1 << im->channels ) - 1;
+
   if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize)
     return -1;
-  if (i_findcolor(im, val, &which)) {
+
+  if ((im->ch_mask & all_mask) != all_mask) {
+    unsigned mask = 1;
+    int ch;
+    i_gpix(im, x, y, &workc);
+    for (ch = 0; ch < im->channels; ++ch) {
+      if (im->ch_mask & mask)
+       workc.channel[ch] = val->channel[ch];
+      mask <<= 1;
+    }
+    work_val = &workc;
+  }
+
+  if (i_findcolor(im, work_val, &which)) {
     ((i_palidx *)im->idata)[x + y * im->xsize] = which;
     return 0;
   }
   else {
+    mm_log((1, "i_ppix: color(%d,%d,%d) not found, converting to rgb\n",
+           val->channel[0], val->channel[1], val->channel[2]));
     if (i_img_to_rgb_inplace(im)) {
       return i_ppix(im, x, y, val);
     }
@@ -590,6 +616,148 @@ static int i_findcolor_p(i_img *im, const i_color *color, i_palidx *entry) {
   return 0;
 }
 
+/*
+=item i_psamp_p(im, l, r, y, samps, chans, chan_count)
+
+Implement psamp() for paletted images.
+
+Since writing samples doesn't really work as a concept for paletted
+images, this is slow.
+
+Also, writing samples may convert the image to a direct image in the
+process, so use i_ppix/i_gpix instead of directly calling the paletted
+handlers.
+
+=cut
+*/
+
+static i_img_dim 
+i_psamp_p(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y,
+         const i_sample_t *samps, const int *chans, int chan_count) {
+  if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) {
+    i_img_dim count = 0;
+    int ch;
+
+    if (r > im->xsize)
+      r = im->xsize;
+      
+    if (chans) {
+      /* make sure we have good channel numbers */
+      for (ch = 0; ch < chan_count; ++ch) {
+        if (chans[ch] < 0 || chans[ch] >= im->channels) {
+          i_push_errorf(0, "No channel %d in this image", chans[ch]);
+          return -1;
+        }
+      }
+      while (l < r) {
+       i_color c;
+       
+       i_gpix(im, l, y, &c);
+       for (ch = 0; ch < chan_count; ++ch)
+         c.channel[chans[ch]] = *samps++;
+       i_ppix(im, l, y, &c);
+       count += chan_count;
+       ++l;
+      }
+    }
+    else {
+      if (chan_count <= 0 || chan_count > im->channels) {
+       i_push_errorf(0, "chan_count %d out of range, must be >0, <= channels", 
+                     chan_count);
+       return -1;
+      }
+
+      while (l < r) {
+       i_color c;
+       
+       i_gpix(im, l, y, &c);
+       for (ch = 0; ch < chan_count; ++ch)
+         c.channel[ch] = *samps++;
+       i_ppix(im, l, y, &c);
+       count += chan_count;
+       ++l;
+      }
+    }
+
+    return count;
+  }
+  else {
+    i_push_error(0, "Image position outside of image");
+    return -1;
+  }
+}
+
+/*
+=item i_psampf_p(im, l, r, y, samps, chans, chan_count)
+
+Implement psampf() for paletted images.
+
+Since writing samples doesn't really work as a concept for paletted
+images, this is slow.
+
+Also, writing samples may convert the image to a direct image in the
+process, so use i_ppixf/i_gpixf instead of directly calling the paletted
+handlers.
+
+=cut
+*/
+
+static i_img_dim 
+i_psampf_p(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y,
+         const i_fsample_t *samps, const int *chans, int chan_count) {
+  if (y >=0 && y < im->ysize && l < im->xsize && l >= 0) {
+    i_img_dim count = 0;
+    int ch;
+
+    if (r > im->xsize)
+      r = im->xsize;
+      
+    if (chans) {
+      /* make sure we have good channel numbers */
+      for (ch = 0; ch < chan_count; ++ch) {
+        if (chans[ch] < 0 || chans[ch] >= im->channels) {
+          i_push_errorf(0, "No channel %d in this image", chans[ch]);
+          return -1;
+        }
+      }
+      while (l < r) {
+       i_fcolor c;
+       
+       i_gpixf(im, l, y, &c);
+       for (ch = 0; ch < chan_count; ++ch)
+         c.channel[chans[ch]] = *samps++;
+       i_ppixf(im, l, y, &c);
+       count += chan_count;
+       ++l;
+      }
+    }
+    else {
+      if (chan_count <= 0 || chan_count > im->channels) {
+       i_push_errorf(0, "chan_count %d out of range, must be >0, <= channels", 
+                     chan_count);
+       return -1;
+      }
+
+      while (l < r) {
+       i_fcolor c;
+       
+       i_gpixf(im, l, y, &c);
+       for (ch = 0; ch < chan_count; ++ch)
+         c.channel[ch] = *samps++;
+       i_ppixf(im, l, y, &c);
+       count += chan_count;
+       ++l;
+      }
+    }
+
+    return count;
+  }
+  else {
+    i_push_error(0, "Image position outside of image");
+    return -1;
+  }
+}
+
 /*
 =back