document the i_comment common tag

[imager.git] / maskimg.c

diff --git a/maskimg.c b/maskimg.c
index aa8f5efbae6277ca14f557ce093ac0ec4d67313f..5ed066026a280f5c3e9dd0abcfcbbdf69404d649 100644 (file)
--- a/maskimg.c
+++ b/maskimg.c
@@ -11,8 +11,8 @@ maskimg.c - implements masked images/image subsets
 =cut
 */
 
 =cut
 */
 

-#include "image.h"
-#include "imagei.h"
+#include "imager.h"
+#include "imageri.h"

 
 #include <stdio.h>
 /*
 
 #include <stdio.h>
 /*


@@ -27,27 +27,33 @@ image.
 typedef struct {
   i_img *targ;
   i_img *mask;
 typedef struct {
   i_img *targ;
   i_img *mask;

-  int xbase, ybase;
+  i_img_dim xbase, ybase;

   i_sample_t *samps; /* temp space */
 } i_img_mask_ext;
 
 #define MASKEXT(im) ((i_img_mask_ext *)((im)->ext_data))
 
 static void i_destroy_masked(i_img *im);
   i_sample_t *samps; /* temp space */
 } i_img_mask_ext;
 
 #define MASKEXT(im) ((i_img_mask_ext *)((im)->ext_data))
 
 static void i_destroy_masked(i_img *im);

-static int i_ppix_masked(i_img *im, int x, int y, i_color *pix);
-static int i_ppixf_masked(i_img *im, int x, int y, i_fcolor *pix);
-static int i_plin_masked(i_img *im, int l, int r, int y, i_color *vals);
-static int i_plinf_masked(i_img *im, int l, int r, int y, i_fcolor *vals);
-static int i_gpix_masked(i_img *im, int x, int y, i_color *pix);
-static int i_gpixf_masked(i_img *im, int x, int y, i_fcolor *pix);
-static int i_glin_masked(i_img *im, int l, int r, int y, i_color *vals);
-static int i_glinf_masked(i_img *im, int l, int r, int y, i_fcolor *vals);
-static int i_gsamp_masked(i_img *im, int l, int r, int y, i_sample_t *samp, 
+static int i_ppix_masked(i_img *im, i_img_dim x, i_img_dim y, const i_color *pix);
+static int i_ppixf_masked(i_img *im, i_img_dim x, i_img_dim y, const i_fcolor *pix);
+static i_img_dim i_plin_masked(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, const i_color *vals);
+static i_img_dim i_plinf_masked(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, const i_fcolor *vals);
+static int i_gpix_masked(i_img *im, i_img_dim x, i_img_dim y, i_color *pix);
+static int i_gpixf_masked(i_img *im, i_img_dim x, i_img_dim y, i_fcolor *pix);
+static i_img_dim i_glin_masked(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_color *vals);
+static i_img_dim i_glinf_masked(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_fcolor *vals);
+static i_img_dim i_gsamp_masked(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_sample_t *samp, 

                           int const *chans, int chan_count);
                           int const *chans, int chan_count);

-static int i_gsampf_masked(i_img *im, int l, int r, int y, i_fsample_t *samp, 
+static i_img_dim i_gsampf_masked(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_fsample_t *samp, 

                            int const *chans, int chan_count);
                            int const *chans, int chan_count);

-static int i_gpal_masked(i_img *im, int l, int r, int y, i_palidx *vals);
-static int i_ppal_masked(i_img *im, int l, int r, int y, i_palidx *vals);
+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
 
 /*
 =item IIM_base_masked


@@ -89,10 +95,16 @@ static i_img IIM_base_masked =
   i_setcolors_forward, /* i_f_setcolors */
 
   i_destroy_masked, /* i_f_destroy */
   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 */

 };
 
 /*
 };
 
 /*

-=item i_img_masked_new(i_img *targ, i_img *mask, int xbase, int ybase, int w, int h)
+=item i_img_masked_new(i_img *targ, i_img *mask, i_img_dim xbase, i_img_dim ybase, i_img_dim w, i_img_dim h)

 
 Create a new masked image.
 
 
 Create a new masked image.
 


@@ -112,7 +124,7 @@ sample is treated as boolean.
 =cut
 */
 
 =cut
 */
 

-i_img *i_img_masked_new(i_img *targ, i_img *mask, int x, int y, int w, int h) {
+i_img *i_img_masked_new(i_img *targ, i_img *mask, i_img_dim x, i_img_dim y, i_img_dim w, i_img_dim h) {

   i_img *im;
   i_img_mask_ext *ext;
 
   i_img *im;
   i_img_mask_ext *ext;
 


@@ -168,7 +180,7 @@ static void i_destroy_masked(i_img *im) {
 }
 
 /*
 }
 
 /*

-=item i_ppix_masked(i_img *im, int x, int y, i_color *pix)
+=item i_ppix_masked(i_img *im, i_img_dim x, i_img_dim y, const i_color *pix)

 
 Write a pixel to a masked image.
 
 
 Write a pixel to a masked image.
 


@@ -176,7 +188,7 @@ Internal function.
 
 =cut
 */
 
 =cut
 */

-static int i_ppix_masked(i_img *im, int x, int y, i_color *pix) {
+static int i_ppix_masked(i_img *im, i_img_dim x, i_img_dim y, const i_color *pix) {

   i_img_mask_ext *ext = MASKEXT(im);
   int result;
 
   i_img_mask_ext *ext = MASKEXT(im);
   int result;
 


@@ -194,7 +206,7 @@ static int i_ppix_masked(i_img *im, int x, int y, i_color *pix) {
 }
 
 /*
 }
 
 /*

-=item i_ppixf_masked(i_img *im, int x, int y, i_fcolor *pix)
+=item i_ppixf_masked(i_img *im, i_img_dim x, i_img_dim y, const i_fcolor *pix)

 
 Write a pixel to a masked image.
 
 
 Write a pixel to a masked image.
 


@@ -202,7 +214,7 @@ Internal function.
 
 =cut
 */
 
 =cut
 */

-static int i_ppixf_masked(i_img *im, int x, int y, i_fcolor *pix) {
+static int i_ppixf_masked(i_img *im, i_img_dim x, i_img_dim y, const i_fcolor *pix) {

   i_img_mask_ext *ext = MASKEXT(im);
   int result;
 
   i_img_mask_ext *ext = MASKEXT(im);
   int result;
 


@@ -220,7 +232,7 @@ static int i_ppixf_masked(i_img *im, int x, int y, i_fcolor *pix) {
 }
 
 /*
 }
 
 /*

-=item i_plin_masked(i_img *im, int l, int r, int y, i_color *vals)
+=item i_plin_masked(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, const i_color *vals)

 
 Write a row of data to a masked image.
 
 
 Write a row of data to a masked image.
 


@@ -228,25 +240,25 @@ Internal function.
 
 =cut
 */
 
 =cut
 */

-static int i_plin_masked(i_img *im, int l, int r, int y, i_color *vals) {
+static i_img_dim i_plin_masked(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, const i_color *vals) {

   i_img_mask_ext *ext = MASKEXT(im);
 
   if (y >= 0 && y < im->ysize && l < im->xsize && l >= 0) {
     if (r > im->xsize)
       r = im->xsize;
     if (ext->mask) {
   i_img_mask_ext *ext = MASKEXT(im);
 
   if (y >= 0 && y < im->ysize && l < im->xsize && l >= 0) {
     if (r > im->xsize)
       r = im->xsize;
     if (ext->mask) {

-      int i;
+      i_img_dim i;

       int simple = 0;
       i_sample_t *samps = ext->samps;
       int simple = 0;
       i_sample_t *samps = ext->samps;

-      int w = r - l;
+      i_img_dim w = r - l;

 
       i_gsamp(ext->mask, l, r, y, samps, NULL, 1);
       if (w < 10)
 
       i_gsamp(ext->mask, l, r, y, samps, NULL, 1);
       if (w < 10)

-        simple = 0;
+        simple = 1;

       else {
         /* the idea is to make a fast scan to see how often the state
            changes */
       else {
         /* the idea is to make a fast scan to see how often the state
            changes */

-        int changes = 0;
+        i_img_dim changes = 0;

         for (i = 0; i < w-1; ++i)
           if (!samps[i] != !samps[i+1])
             ++changes;
         for (i = 0; i < w-1; ++i)
           if (!samps[i] != !samps[i+1])
             ++changes;


@@ -269,7 +281,7 @@ static int i_plin_masked(i_img *im, int l, int r, int y, i_color *vals) {
         /* the scan above indicates there should be some contiguous 
            regions, look for them and render
         */
         /* the scan above indicates there should be some contiguous 
            regions, look for them and render
         */

-        int start;
+        i_img_dim start;

         i = 0;
         while (i < w) {
           while (i < w && !samps[i])
         i = 0;
         while (i < w) {
           while (i < w && !samps[i])


@@ -286,7 +298,7 @@ static int i_plin_masked(i_img *im, int l, int r, int y, i_color *vals) {
       }
     }
     else {
       }
     }
     else {

-      int result = i_plin(ext->targ, l + ext->xbase, r + ext->xbase, 
+      i_img_dim result = i_plin(ext->targ, l + ext->xbase, r + ext->xbase, 

                           y + ext->ybase, vals);
       im->type = ext->targ->type;
       return result;
                           y + ext->ybase, vals);
       im->type = ext->targ->type;
       return result;


@@ -298,7 +310,7 @@ static int i_plin_masked(i_img *im, int l, int r, int y, i_color *vals) {
 }
 
 /*
 }
 
 /*

-=item i_plinf_masked(i_img *im, int l, int r, int y, i_fcolor *vals)
+=item i_plinf_masked(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, const i_fcolor *vals)

 
 Write a row of data to a masked image.
 
 
 Write a row of data to a masked image.
 


@@ -306,24 +318,24 @@ Internal function.
 
 =cut
 */
 
 =cut
 */

-static int i_plinf_masked(i_img *im, int l, int r, int y, i_fcolor *vals) {
+static i_img_dim i_plinf_masked(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, const i_fcolor *vals) {

   i_img_mask_ext *ext = MASKEXT(im);
   if (y >= 0 && y < im->ysize && l < im->xsize && l >= 0) {
     if (r > im->xsize)
       r = im->xsize;
     if (ext->mask) {
   i_img_mask_ext *ext = MASKEXT(im);
   if (y >= 0 && y < im->ysize && l < im->xsize && l >= 0) {
     if (r > im->xsize)
       r = im->xsize;
     if (ext->mask) {

-      int i;
+      i_img_dim i;

       int simple = 0;
       i_sample_t *samps = ext->samps;
       int simple = 0;
       i_sample_t *samps = ext->samps;

-      int w = r - l;
+      i_img_dim w = r - l;

 
       i_gsamp(ext->mask, l, r, y, samps, NULL, 1);
       if (w < 10)
 
       i_gsamp(ext->mask, l, r, y, samps, NULL, 1);
       if (w < 10)

-        simple = 0;
+        simple = 1;

       else {
         /* the idea is to make a fast scan to see how often the state
            changes */
       else {
         /* the idea is to make a fast scan to see how often the state
            changes */

-        int changes = 0;
+        i_img_dim changes = 0;

         for (i = 0; i < w-1; ++i)
           if (!samps[i] != !samps[i+1])
             ++changes;
         for (i = 0; i < w-1; ++i)
           if (!samps[i] != !samps[i+1])
             ++changes;


@@ -346,7 +358,7 @@ static int i_plinf_masked(i_img *im, int l, int r, int y, i_fcolor *vals) {
         /* the scan above indicates there should be some contiguous 
            regions, look for them and render
         */
         /* the scan above indicates there should be some contiguous 
            regions, look for them and render
         */

-        int start;
+        i_img_dim start;

         i = 0;
         while (i < w) {
           while (i < w && !samps[i])
         i = 0;
         while (i < w) {
           while (i < w && !samps[i])


@@ -363,7 +375,7 @@ static int i_plinf_masked(i_img *im, int l, int r, int y, i_fcolor *vals) {
       }
     }
     else {
       }
     }
     else {

-      int result = i_plinf(ext->targ, l + ext->xbase, r + ext->xbase, 
+      i_img_dim result = i_plinf(ext->targ, l + ext->xbase, r + ext->xbase, 

                            y + ext->ybase, vals);
       im->type = ext->targ->type;
       return result;
                            y + ext->ybase, vals);
       im->type = ext->targ->type;
       return result;


@@ -375,7 +387,7 @@ static int i_plinf_masked(i_img *im, int l, int r, int y, i_fcolor *vals) {
 }
 
 /*
 }
 
 /*

-=item i_gpix_masked(i_img *im, int x, int y, i_color *pix)
+=item i_gpix_masked(i_img *im, i_img_dim x, i_img_dim y, i_color *pix)

 
 Read a pixel from a masked image.
 
 
 Read a pixel from a masked image.
 


@@ -383,7 +395,7 @@ Internal.
 
 =cut
 */
 
 =cut
 */

-static int i_gpix_masked(i_img *im, int x, int y, i_color *pix) {
+static int i_gpix_masked(i_img *im, i_img_dim x, i_img_dim y, i_color *pix) {

   i_img_mask_ext *ext = MASKEXT(im);
 
   if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize)
   i_img_mask_ext *ext = MASKEXT(im);
 
   if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize)


@@ -393,7 +405,7 @@ static int i_gpix_masked(i_img *im, int x, int y, i_color *pix) {
 }
 
 /*
 }
 
 /*

-=item i_gpixf_masked(i_img *im, int x, int y, i_fcolor *pix)
+=item i_gpixf_masked(i_img *im, i_img_dim x, i_img_dim y, i_fcolor *pix)

 
 Read a pixel from a masked image.
 
 
 Read a pixel from a masked image.
 


@@ -401,7 +413,7 @@ Internal.
 
 =cut
 */
 
 =cut
 */

-static int i_gpixf_masked(i_img *im, int x, int y, i_fcolor *pix) {
+static int i_gpixf_masked(i_img *im, i_img_dim x, i_img_dim y, i_fcolor *pix) {

   i_img_mask_ext *ext = MASKEXT(im);
 
   if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize)
   i_img_mask_ext *ext = MASKEXT(im);
 
   if (x < 0 || x >= im->xsize || y < 0 || y >= im->ysize)


@@ -410,7 +422,7 @@ static int i_gpixf_masked(i_img *im, int x, int y, i_fcolor *pix) {
   return i_gpixf(ext->targ, x + ext->xbase, y + ext->ybase, pix);
 }
 
   return i_gpixf(ext->targ, x + ext->xbase, y + ext->ybase, pix);
 }
 

-static int i_glin_masked(i_img *im, int l, int r, int y, i_color *vals) {
+static i_img_dim i_glin_masked(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_color *vals) {

   i_img_mask_ext *ext = MASKEXT(im);
   if (y >= 0 && y < im->ysize && l < im->xsize && l >= 0) {
     if (r > im->xsize)
   i_img_mask_ext *ext = MASKEXT(im);
   if (y >= 0 && y < im->ysize && l < im->xsize && l >= 0) {
     if (r > im->xsize)


@@ -423,7 +435,7 @@ static int i_glin_masked(i_img *im, int l, int r, int y, i_color *vals) {
   }
 }
 
   }
 }
 

-static int i_glinf_masked(i_img *im, int l, int r, int y, i_fcolor *vals) {
+static i_img_dim i_glinf_masked(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_fcolor *vals) {

   i_img_mask_ext *ext = MASKEXT(im);
   if (y >= 0 && y < im->ysize && l < im->xsize && l >= 0) {
     if (r > im->xsize)
   i_img_mask_ext *ext = MASKEXT(im);
   if (y >= 0 && y < im->ysize && l < im->xsize && l >= 0) {
     if (r > im->xsize)


@@ -436,7 +448,7 @@ static int i_glinf_masked(i_img *im, int l, int r, int y, i_fcolor *vals) {
   }
 }
 
   }
 }
 

-static int i_gsamp_masked(i_img *im, int l, int r, int y, i_sample_t *samp, 
+static i_img_dim i_gsamp_masked(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_sample_t *samp, 

                           int const *chans, int chan_count) {
   i_img_mask_ext *ext = MASKEXT(im);
   if (y >= 0 && y < im->ysize && l < im->xsize && l >= 0) {
                           int const *chans, int chan_count) {
   i_img_mask_ext *ext = MASKEXT(im);
   if (y >= 0 && y < im->ysize && l < im->xsize && l >= 0) {


@@ -450,7 +462,7 @@ static int i_gsamp_masked(i_img *im, int l, int r, int y, i_sample_t *samp,
   }
 }
 
   }
 }
 

-static int i_gsampf_masked(i_img *im, int l, int r, int y, i_fsample_t *samp, 
+static i_img_dim i_gsampf_masked(i_img *im, i_img_dim l, i_img_dim r, i_img_dim y, i_fsample_t *samp, 

                           int const *chans, int chan_count) {
   i_img_mask_ext *ext = MASKEXT(im);
   if (y >= 0 && y < im->ysize && l < im->xsize && l >= 0) {
                           int const *chans, int chan_count) {
   i_img_mask_ext *ext = MASKEXT(im);
   if (y >= 0 && y < im->ysize && l < im->xsize && l >= 0) {


@@ -464,7 +476,7 @@ static int i_gsampf_masked(i_img *im, int l, int r, int y, i_fsample_t *samp,
   }
 }
 
   }
 }
 

-static int i_gpal_masked(i_img *im, int l, int r, int y, i_palidx *vals) {
+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) {

   i_img_mask_ext *ext = MASKEXT(im);
   if (y >= 0 && y < im->ysize && l < im->xsize && l >= 0) {
     if (r > im->xsize)
   i_img_mask_ext *ext = MASKEXT(im);
   if (y >= 0 && y < im->ysize && l < im->xsize && l >= 0) {
     if (r > im->xsize)


@@ -477,17 +489,18 @@ static int i_gpal_masked(i_img *im, int l, int r, int y, i_palidx *vals) {
   }
 }
 
   }
 }
 

-static int i_ppal_masked(i_img *im, int l, int r, int 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) {

   i_img_mask_ext *ext = MASKEXT(im);
   if (y >= 0 && y < im->ysize && l < im->xsize && l >= 0) {
     if (r > im->xsize)
       r = im->xsize;
     if (ext->mask) {
   i_img_mask_ext *ext = MASKEXT(im);
   if (y >= 0 && y < im->ysize && l < im->xsize && l >= 0) {
     if (r > im->xsize)
       r = im->xsize;
     if (ext->mask) {

-      int i;
+      i_img_dim i;

       i_sample_t *samps = ext->samps;
       i_sample_t *samps = ext->samps;

-      int w = r - l;
-      int start;
+      i_img_dim w = r - l;
+      i_img_dim start;

       
       

+      i_gsamp(ext->mask, l, r, y, samps, NULL, 1);

       i = 0;
       while (i < w) {
         while (i < w && !samps[i])
       i = 0;
       while (i < w) {
         while (i < w && !samps[i])


@@ -511,6 +524,139 @@ static int i_ppal_masked(i_img *im, int l, int r, int y, i_palidx *vals) {
   }
 }
 
   }
 }
 

+/*
+=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
 
 /*
 =back