convert spaces to tabs and some formatting.

1 files changed, 1197 insertions, 1107 deletions

diff --git a/source/blender/nodes/composite/nodes/node_composite_doubleEdgeMask.c b/source/blender/nodes/composite/nodes/node_composite_doubleEdgeMask.c
index d3c6561ac34..d012815fff9 100644
--- a/source/blender/nodes/composite/nodes/node_composite_doubleEdgeMask.c
+++ b/source/blender/nodes/composite/nodes/node_composite_doubleEdgeMask.c
@@ -33,1025 +33,1112 @@
 
 
 static bNodeSocketTemplate cmp_node_doubleedgemask_in[]= {
-    { SOCK_FLOAT, 1, "Inner Mask", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f, PROP_NONE},  // inner mask socket definition
-    { SOCK_FLOAT, 1, "Outer Mask", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f, PROP_NONE},  // outer mask socket definition
-    { -1, 0, ""	}                                                                   // input socket array terminator
+	{ SOCK_FLOAT, 1, "Inner Mask", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f, PROP_NONE},	// inner mask socket definition
+	{ SOCK_FLOAT, 1, "Outer Mask", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f, PROP_NONE},	// outer mask socket definition
+	{ -1, 0, ""	}																	// input socket array terminator
 };
 static bNodeSocketTemplate cmp_node_doubleedgemask_out[]= {
-    { SOCK_FLOAT, 0, "Mask"},          // output socket definition
-    { -1, 0, "" }                      // output socket array terminator
+	{ SOCK_FLOAT, 0, "Mask"},		// output socket definition
+	{ -1, 0, "" }					// output socket array terminator
 };
 
 static void do_adjacentKeepBorders(unsigned int t, unsigned int rw, unsigned int *limask, unsigned int *lomask, unsigned int *lres, float *res, unsigned int *rsize)
 {
-    int x;
-    unsigned int isz=0; // inner edge size
-    unsigned int osz=0; // outer edge size
-    unsigned int gsz=0; // gradient fill area size
-    /* Test the four corners */
-    /* upper left corner */
-    x=t-rw+1;
-    // test if inner mask is filled
-    if(limask[x]){
-        // test if pixel underneath, or to the right, are empty in the inner mask,
-        // but filled in the outer mask
-        if((!limask[x-rw] && lomask[x-rw]) || (!limask[x+1] && lomask[x+1])){
-            isz++;                               // increment inner edge size
-            lres[x]=4;                           // flag pixel as inner edge
-        } else {
-            res[x]=1.0f;                         // pixel is just part of inner mask, and it's not an edge
-        }
-    } else if(lomask[x]){                        // inner mask was empty, test if outer mask is filled
-        osz++;                                   // increment outer edge size
-        lres[x]=3;                               // flag pixel as outer edge
-    }
-    /* upper right corner */
-    x=t;
-    // test if inner mask is filled
-    if(limask[x]){
-        // test if pixel underneath, or to the left, are empty in the inner mask,
-        // but filled in the outer mask
-        if((!limask[x-rw] && lomask[x-rw]) || (!limask[x-1] && lomask[x-1])){
-            isz++;                               // increment inner edge size
-            lres[x]=4;                           // flag pixel as inner edge
-        } else {
-            res[x]=1.0f;                         // pixel is just part of inner mask, and it's not an edge
-        }
-    } else if(lomask[x]){                        // inner mask was empty, test if outer mask is filled
-        osz++;                                   // increment outer edge size
-        lres[x]=3;                               // flag pixel as outer edge
-    }
-    /* lower left corner */
-    x=0;
-    // test if inner mask is filled
-    if(limask[x]){
-        // test if pixel above, or to the right, are empty in the inner mask,
-        // but filled in the outer mask
-        if((!limask[x+rw] && lomask[x+rw]) || (!limask[x+1] && lomask[x+1])){
-            isz++;                               // increment inner edge size
-            lres[x]=4;                           // flag pixel as inner edge
-        } else {
-            res[x]=1.0f;                         // pixel is just part of inner mask, and it's not an edge
-        }
-    } else if(lomask[x]){                        // inner mask was empty, test if outer mask is filled
-        osz++;                                   // increment outer edge size
-        lres[x]=3;                               // flag pixel as outer edge
-    }
-    /* lower right corner */
-    x=rw-1;
-    // test if inner mask is filled
-    if(limask[x]){
-        // test if pixel above, or to the left, are empty in the inner mask,
-        // but filled in the outer mask
-        if((!limask[x+rw] && lomask[x+rw]) || (!limask[x-1] && lomask[x-1])){
-            isz++;                               // increment inner edge size
-            lres[x]=4;                           // flag pixel as inner edge
-        } else {
-            res[x]=1.0f;                         // pixel is just part of inner mask, and it's not an edge
-        }
-    } else if(lomask[x]){                        // inner mask was empty, test if outer mask is filled
-        osz++;                                   // increment outer edge size
-        lres[x]=3;                               // flag pixel as outer edge
-    }
-
-    /* Test the TOP row of pixels in buffer, except corners */
-    for(x= t-1; x>=(t-rw)+2; x--) {
-        // test if inner mask is filled
-        if(limask[x]) {
-            // test if pixel to the right, or to the left, are empty in the inner mask,
-            // but filled in the outer mask
-            if((!limask[x-1] && lomask[x-1]) || (!limask[x+1] && lomask[x+1])) {
-                isz++;                           // increment inner edge size
-                lres[x]=4;                       // flag pixel as inner edge
-            } else {
-                res[x]=1.0f;                     // pixel is just part of inner mask, and it's not an edge
-            }
-        } else if(lomask[x]) {                   // inner mask was empty, test if outer mask is filled
-            osz++;                               // increment outer edge size
-            lres[x]=3;                           // flag pixel as outer edge
-        }
-    }
-
-    /* Test the BOTTOM row of pixels in buffer, except corners */
-    for(x= rw-2; x; x--) {
-        // test if inner mask is filled
-        if(limask[x]) {
-            // test if pixel to the right, or to the left, are empty in the inner mask,
-            // but filled in the outer mask
-            if((!limask[x-1] && lomask[x-1]) || (!limask[x+1] && lomask[x+1])) {
-                isz++;                           // increment inner edge size
-                lres[x]=4;                       // flag pixel as inner edge
-            } else {
-                res[x]=1.0f;                     // pixel is just part of inner mask, and it's not an edge
-            }
-        } else if(lomask[x]) {                   // inner mask was empty, test if outer mask is filled
-            osz++;                               // increment outer edge size
-            lres[x]=3;                           // flag pixel as outer edge
-        }
-    }
-    /* Test the LEFT edge of pixels in buffer, except corners */
-    for(x= t-(rw<<1)+1; x>=rw; x-=rw) {
-        // test if inner mask is filled
-        if(limask[x]) {
-            // test if pixel underneath, or above, are empty in the inner mask,
-            // but filled in the outer mask
-            if((!limask[x-rw] && lomask[x-rw]) || (!limask[x+rw] && lomask[x+rw])) {
-                isz++;                           // increment inner edge size
-                lres[x]=4;                       // flag pixel as inner edge
-            } else {
-                res[x]=1.0f;                     // pixel is just part of inner mask, and it's not an edge
-            }
-        } else if(lomask[x]) {                   // inner mask was empty, test if outer mask is filled
-            osz++;                               // increment outer edge size
-            lres[x]=3;                           // flag pixel as outer edge
-        }
-    }
-
-    /* Test the RIGHT edge of pixels in buffer, except corners */
-    for(x= t-rw; x>rw; x-=rw) {
-        // test if inner mask is filled
-        if(limask[x]) {
-            // test if pixel underneath, or above, are empty in the inner mask,
-            // but filled in the outer mask
-            if((!limask[x-rw] && lomask[x-rw]) || (!limask[x+rw] && lomask[x+rw])) {
-                isz++;                           // increment inner edge size
-                lres[x]=4;                       // flag pixel as inner edge
-            } else {
-                res[x]=1.0f;                     // pixel is just part of inner mask, and it's not an edge
-            }
-        } else if(lomask[x]) {                   // inner mask was empty, test if outer mask is filled
-            osz++;                               // increment outer edge size
-            lres[x]=3;                           // flag pixel as outer edge
-        }
-    }
-
-    rsize[0]=isz;  // fill in our return sizes for edges + fill
-    rsize[1]=osz;
-    rsize[2]=gsz;
+	int x;
+	unsigned int isz=0; // inner edge size
+	unsigned int osz=0; // outer edge size
+	unsigned int gsz=0; // gradient fill area size
+	/* Test the four corners */
+	/* upper left corner */
+	x=t-rw+1;
+	// test if inner mask is filled
+	if (limask[x]) {
+		// test if pixel underneath, or to the right, are empty in the inner mask,
+		// but filled in the outer mask
+		if ((!limask[x-rw] && lomask[x-rw]) || (!limask[x+1] && lomask[x+1])) {
+			isz++;								// increment inner edge size
+			lres[x]=4;							// flag pixel as inner edge
+		}
+		else {
+			res[x]=1.0f;						// pixel is just part of inner mask, and it's not an edge
+		}
+	}
+	else if (lomask[x]) {						// inner mask was empty, test if outer mask is filled
+		osz++;									// increment outer edge size
+		lres[x]=3;								// flag pixel as outer edge
+	}
+	/* upper right corner */
+	x=t;
+	// test if inner mask is filled
+	if (limask[x]) {
+		// test if pixel underneath, or to the left, are empty in the inner mask,
+		// but filled in the outer mask
+		if ((!limask[x-rw] && lomask[x-rw]) || (!limask[x-1] && lomask[x-1])) {
+			isz++;								// increment inner edge size
+			lres[x]=4;							// flag pixel as inner edge
+		}
+		else {
+			res[x]=1.0f;						// pixel is just part of inner mask, and it's not an edge
+		}
+	}
+	else if (lomask[x]) {						// inner mask was empty, test if outer mask is filled
+		osz++;									// increment outer edge size
+		lres[x]=3;								// flag pixel as outer edge
+	}
+	/* lower left corner */
+	x=0;
+	// test if inner mask is filled
+	if (limask[x]) {
+		// test if pixel above, or to the right, are empty in the inner mask,
+		// but filled in the outer mask
+		if ((!limask[x+rw] && lomask[x+rw]) || (!limask[x+1] && lomask[x+1])) {
+			isz++;								// increment inner edge size
+			lres[x]=4;							// flag pixel as inner edge
+		}
+		else {
+			res[x]=1.0f;						// pixel is just part of inner mask, and it's not an edge
+		}
+	}
+	else if (lomask[x]) {						// inner mask was empty, test if outer mask is filled
+		osz++;									// increment outer edge size
+		lres[x]=3;								// flag pixel as outer edge
+	}
+	/* lower right corner */
+	x=rw-1;
+	// test if inner mask is filled
+	if (limask[x]) {
+		// test if pixel above, or to the left, are empty in the inner mask,
+		// but filled in the outer mask
+		if ((!limask[x+rw] && lomask[x+rw]) || (!limask[x-1] && lomask[x-1])) {
+			isz++;								// increment inner edge size
+			lres[x]=4;							// flag pixel as inner edge
+		}
+		else {
+			res[x]=1.0f;						// pixel is just part of inner mask, and it's not an edge
+		}
+	}
+	else if (lomask[x]) {						// inner mask was empty, test if outer mask is filled
+		osz++;									// increment outer edge size
+		lres[x]=3;								// flag pixel as outer edge
+	}
+
+	/* Test the TOP row of pixels in buffer, except corners */
+	for (x= t-1; x>=(t-rw)+2; x--) {
+		// test if inner mask is filled
+		if (limask[x]) {
+			// test if pixel to the right, or to the left, are empty in the inner mask,
+			// but filled in the outer mask
+			if ((!limask[x-1] && lomask[x-1]) || (!limask[x+1] && lomask[x+1])) {
+				isz++;							// increment inner edge size
+				lres[x]=4;						// flag pixel as inner edge
+			}
+			else {
+				res[x]=1.0f;					// pixel is just part of inner mask, and it's not an edge
+			}
+		}
+		else if (lomask[x]) {					// inner mask was empty, test if outer mask is filled
+			osz++;								// increment outer edge size
+			lres[x]=3;							// flag pixel as outer edge
+		}
+	}
+
+	/* Test the BOTTOM row of pixels in buffer, except corners */
+	for (x= rw-2; x; x--) {
+		// test if inner mask is filled
+		if (limask[x]) {
+			// test if pixel to the right, or to the left, are empty in the inner mask,
+			// but filled in the outer mask
+			if ((!limask[x-1] && lomask[x-1]) || (!limask[x+1] && lomask[x+1])) {
+				isz++;							// increment inner edge size
+				lres[x]=4;						// flag pixel as inner edge
+			}
+			else {
+				res[x]=1.0f;					// pixel is just part of inner mask, and it's not an edge
+			}
+		}
+		else if (lomask[x]) {					// inner mask was empty, test if outer mask is filled
+			osz++;								// increment outer edge size
+			lres[x]=3;							// flag pixel as outer edge
+		}
+	}
+	/* Test the LEFT edge of pixels in buffer, except corners */
+	for (x= t-(rw<<1)+1; x>=rw; x-=rw) {
+		// test if inner mask is filled
+		if (limask[x]) {
+			// test if pixel underneath, or above, are empty in the inner mask,
+			// but filled in the outer mask
+			if ((!limask[x-rw] && lomask[x-rw]) || (!limask[x+rw] && lomask[x+rw])) {
+				isz++;							// increment inner edge size
+				lres[x]=4;						// flag pixel as inner edge
+			}
+			else {
+				res[x]=1.0f;					// pixel is just part of inner mask, and it's not an edge
+			}
+		}
+		else if (lomask[x]) {					// inner mask was empty, test if outer mask is filled
+			osz++;								// increment outer edge size
+			lres[x]=3;							// flag pixel as outer edge
+		}
+	}
+
+	/* Test the RIGHT edge of pixels in buffer, except corners */
+	for (x= t-rw; x>rw; x-=rw) {
+		// test if inner mask is filled
+		if (limask[x]) {
+			// test if pixel underneath, or above, are empty in the inner mask,
+			// but filled in the outer mask
+			if ((!limask[x-rw] && lomask[x-rw]) || (!limask[x+rw] && lomask[x+rw])) {
+				isz++;							// increment inner edge size
+				lres[x]=4;						// flag pixel as inner edge
+			}
+			else {
+				res[x]=1.0f;					// pixel is just part of inner mask, and it's not an edge
+			}
+		}
+		else if (lomask[x]) {					// inner mask was empty, test if outer mask is filled
+			osz++;								// increment outer edge size
+			lres[x]=3;							// flag pixel as outer edge
+		}
+	}
+
+	rsize[0]=isz; // fill in our return sizes for edges + fill
+	rsize[1]=osz;
+	rsize[2]=gsz;
 }
 
 static void do_adjacentBleedBorders(unsigned int t, unsigned int rw, unsigned int *limask, unsigned int *lomask, unsigned int *lres, float *res, unsigned int *rsize)
 {
-    int x;
-    unsigned int isz=0; // inner edge size
-    unsigned int osz=0; // outer edge size
-    unsigned int gsz=0; // gradient fill area size
-    /* Test the four corners */
-    /* upper left corner */
-    x=t-rw+1;
-    // test if inner mask is filled
-    if(limask[x]){
-        // test if pixel underneath, or to the right, are empty in the inner mask,
-        // but filled in the outer mask
-        if((!limask[x-rw] && lomask[x-rw]) || (!limask[x+1] && lomask[x+1])){
-            isz++;                               // increment inner edge size
-            lres[x]=4;                           // flag pixel as inner edge
-        } else {
-            res[x]=1.0f;                         // pixel is just part of inner mask, and it's not an edge
-        }
-    } else if(lomask[x]){                        // inner mask was empty, test if outer mask is filled
-        if(!lomask[x-rw] || !lomask[x+1]) {      // test if outer mask is empty underneath or to the right
-            osz++;                               // increment outer edge size
-            lres[x]=3;                           // flag pixel as outer edge
-        } else {
-            gsz++;                               // increment the gradient pixel count
-            lres[x]=2;                           // flag pixel as gradient
-        }
-    }
-    /* upper right corner */
-    x=t;
-    // test if inner mask is filled
-    if(limask[x]){
-        // test if pixel underneath, or to the left, are empty in the inner mask,
-        // but filled in the outer mask
-        if((!limask[x-rw] && lomask[x-rw]) || (!limask[x-1] && lomask[x-1])){
-            isz++;                               // increment inner edge size
-            lres[x]=4;                           // flag pixel as inner edge
-        } else {
-            res[x]=1.0f;                         // pixel is just part of inner mask, and it's not an edge
-        }
-    } else if(lomask[x]){                        // inner mask was empty, test if outer mask is filled
-        if(!lomask[x-rw] || !lomask[x-1]) {      // test if outer mask is empty underneath or to the left
-            osz++;                               // increment outer edge size
-            lres[x]=3;                           // flag pixel as outer edge
-        } else {
-            gsz++;                               // increment the gradient pixel count
-            lres[x]=2;                           // flag pixel as gradient
-        }
-    }
-    /* lower left corner */
-    x=0;
-    // test if inner mask is filled
-    if(limask[x]){
-        // test if pixel above, or to the right, are empty in the inner mask,
-        // but filled in the outer mask
-        if((!limask[x+rw] && lomask[x+rw]) || (!limask[x+1] && lomask[x+1])){
-            isz++;                               // increment inner edge size
-            lres[x]=4;                           // flag pixel as inner edge
-        } else {
-            res[x]=1.0f;                         // pixel is just part of inner mask, and it's not an edge
-        }
-    } else if(lomask[x]){                        // inner mask was empty, test if outer mask is filled
-        if(!lomask[x+rw] || !lomask[x+1]) {      // test if outer mask is empty above or to the right
-            osz++;                               // increment outer edge size
-            lres[x]=3;                           // flag pixel as outer edge
-        } else {
-            gsz++;                               // increment the gradient pixel count
-            lres[x]=2;                           // flag pixel as gradient
-        }
-    }
-    /* lower right corner */
-    x=rw-1;
-    // test if inner mask is filled
-    if(limask[x]){
-        // test if pixel above, or to the left, are empty in the inner mask,
-        // but filled in the outer mask
-        if((!limask[x+rw] && lomask[x+rw]) || (!limask[x-1] && lomask[x-1])){
-            isz++;                               // increment inner edge size
-            lres[x]=4;                           // flag pixel as inner edge
-        } else {
-            res[x]=1.0f;                         // pixel is just part of inner mask, and it's not an edge
-        }
-    } else if(lomask[x]){                        // inner mask was empty, test if outer mask is filled
-        if(!lomask[x+rw] || !lomask[x-1]) {      // test if outer mask is empty above or to the left
-            osz++;                               // increment outer edge size
-            lres[x]=3;                           // flag pixel as outer edge
-        } else {
-            gsz++;                               // increment the gradient pixel count
-            lres[x]=2;                           // flag pixel as gradient
-        }
-    }
-    /* Test the TOP row of pixels in buffer, except corners */
-    for(x= t-1; x>=(t-rw)+2; x--) {
-        // test if inner mask is filled
-        if(limask[x]) {
-            // test if pixel to the left, or to the right, are empty in the inner mask,
-            // but filled in the outer mask
-            if((!limask[x-1] && lomask[x-1]) || (!limask[x+1] && lomask[x+1])) {
-                isz++;                           // increment inner edge size
-                lres[x]=4;                       // flag pixel as inner edge
-            } else {
-                res[x]=1.0f;                     // pixel is just part of inner mask, and it's not an edge
-            }
-        } else if(lomask[x]) {                   // inner mask was empty, test if outer mask is filled
-            if(!lomask[x-1] || !lomask[x+1]) {   // test if outer mask is empty to the left or to the right
-                osz++;                           // increment outer edge size
-                lres[x]=3;                       // flag pixel as outer edge
-            } else {
-                gsz++;                           // increment the gradient pixel count
-                lres[x]=2;                       // flag pixel as gradient
-            }
-        }
-    }
-
-    /* Test the BOTTOM row of pixels in buffer, except corners */
-    for(x= rw-2; x; x--) {
-        // test if inner mask is filled
-        if(limask[x]) {
-            // test if pixel to the left, or to the right, are empty in the inner mask,
-            // but filled in the outer mask
-            if((!limask[x-1] && lomask[x-1]) || (!limask[x+1] && lomask[x+1])) {
-                isz++;                           // increment inner edge size
-                lres[x]=4;                       // flag pixel as inner edge
-            } else {
-                res[x]=1.0f;                     // pixel is just part of inner mask, and it's not an edge
-            }
-        } else if(lomask[x]) {                   // inner mask was empty, test if outer mask is filled
-            if(!lomask[x-1] || !lomask[x+1]) {   // test if outer mask is empty to the left or to the right
-                osz++;                           // increment outer edge size
-                lres[x]=3;                       // flag pixel as outer edge
-            } else {
-                gsz++;                           // increment the gradient pixel count
-                lres[x]=2;                       // flag pixel as gradient
-            }
-        }
-    }
-    /* Test the LEFT edge of pixels in buffer, except corners */
-    for(x= t-(rw<<1)+1; x>=rw; x-=rw) {
-        // test if inner mask is filled
-        if(limask[x]) {
-            // test if pixel underneath, or above, are empty in the inner mask,
-            // but filled in the outer mask
-            if((!limask[x-rw] && lomask[x-rw]) || (!limask[x+rw] && lomask[x+rw])) {
-                isz++;                           // increment inner edge size
-                lres[x]=4;                       // flag pixel as inner edge
-            } else {
-                res[x]=1.0f;                     // pixel is just part of inner mask, and it's not an edge
-            }
-        } else if(lomask[x]) {                   // inner mask was empty, test if outer mask is filled
-            if(!lomask[x-rw] || !lomask[x+rw]) { // test if outer mask is empty underneath or above
-                osz++;                           // increment outer edge size
-                lres[x]=3;                       // flag pixel as outer edge
-            } else {
-                gsz++;                           // increment the gradient pixel count
-                lres[x]=2;                       // flag pixel as gradient
-            }
-        }
-    }
-
-    /* Test the RIGHT edge of pixels in buffer, except corners */
-    for(x= t-rw; x>rw; x-=rw) {
-        // test if inner mask is filled
-        if(limask[x]) {
-            // test if pixel underneath, or above, are empty in the inner mask,
-            // but filled in the outer mask
-            if((!limask[x-rw] && lomask[x-rw]) || (!limask[x+rw] && lomask[x+rw])) {
-                isz++;                           // increment inner edge size
-                lres[x]=4;                       // flag pixel as inner edge
-            } else {
-                res[x]=1.0f;                     // pixel is just part of inner mask, and it's not an edge
-            }
-        } else if(lomask[x]) {                   // inner mask was empty, test if outer mask is filled
-            if(!lomask[x-rw] || !lomask[x+rw]) { // test if outer mask is empty underneath or above
-                osz++;                           // increment outer edge size
-                lres[x]=3;                       // flag pixel as outer edge
-            } else {
-                gsz++;                           // increment the gradient pixel count
-                lres[x]=2;                       // flag pixel as gradient
-            }
-        }
-    }
-
-    rsize[0]=isz;  // fill in our return sizes for edges + fill
-    rsize[1]=osz;
-    rsize[2]=gsz;
+	int x;
+	unsigned int isz=0; // inner edge size
+	unsigned int osz=0; // outer edge size
+	unsigned int gsz=0; // gradient fill area size
+	/* Test the four corners */
+	/* upper left corner */
+	x=t-rw+1;
+	// test if inner mask is filled
+	if (limask[x]) {
+		// test if pixel underneath, or to the right, are empty in the inner mask,
+		// but filled in the outer mask
+		if ((!limask[x-rw] && lomask[x-rw]) || (!limask[x+1] && lomask[x+1])) {
+			isz++;								// increment inner edge size
+			lres[x]=4;							// flag pixel as inner edge
+		}
+		else {
+			res[x]=1.0f;						// pixel is just part of inner mask, and it's not an edge
+		}
+	}
+	else if (lomask[x]) {						// inner mask was empty, test if outer mask is filled
+		if (!lomask[x-rw] || !lomask[x+1]) {		// test if outer mask is empty underneath or to the right
+			osz++;								// increment outer edge size
+			lres[x]=3;							// flag pixel as outer edge
+		}
+		else {
+			gsz++;								// increment the gradient pixel count
+			lres[x]=2;							// flag pixel as gradient
+		}
+	}
+	/* upper right corner */
+	x=t;
+	// test if inner mask is filled
+	if (limask[x]) {
+		// test if pixel underneath, or to the left, are empty in the inner mask,
+		// but filled in the outer mask
+		if ((!limask[x-rw] && lomask[x-rw]) || (!limask[x-1] && lomask[x-1])) {
+			isz++;								// increment inner edge size
+			lres[x]=4;							// flag pixel as inner edge
+		}
+		else {
+			res[x]=1.0f;						// pixel is just part of inner mask, and it's not an edge
+		}
+	}
+	else if (lomask[x]) {						// inner mask was empty, test if outer mask is filled
+		if (!lomask[x-rw] || !lomask[x-1]) {	// test if outer mask is empty underneath or to the left
+			osz++;								// increment outer edge size
+			lres[x]=3;							// flag pixel as outer edge
+		}
+		else {
+			gsz++;								// increment the gradient pixel count
+			lres[x]=2;							// flag pixel as gradient
+		}
+	}
+	/* lower left corner */
+	x=0;
+	// test if inner mask is filled
+	if (limask[x]) {
+		// test if pixel above, or to the right, are empty in the inner mask,
+		// but filled in the outer mask
+		if ((!limask[x+rw] && lomask[x+rw]) || (!limask[x+1] && lomask[x+1])) {
+			isz++;								// increment inner edge size
+			lres[x]=4;							// flag pixel as inner edge
+		}
+		else {
+			res[x]=1.0f;						// pixel is just part of inner mask, and it's not an edge
+		}
+	}
+	else if (lomask[x]) {						// inner mask was empty, test if outer mask is filled
+		if (!lomask[x+rw] || !lomask[x+1]) {	// test if outer mask is empty above or to the right
+			osz++;								// increment outer edge size
+			lres[x]=3;							// flag pixel as outer edge
+		}
+		else {
+			gsz++;								// increment the gradient pixel count
+			lres[x]=2;							// flag pixel as gradient
+		}
+	}
+	/* lower right corner */
+	x=rw-1;
+	// test if inner mask is filled
+	if (limask[x]) {
+		// test if pixel above, or to the left, are empty in the inner mask,
+		// but filled in the outer mask
+		if ((!limask[x+rw] && lomask[x+rw]) || (!limask[x-1] && lomask[x-1])) {
+			isz++;								// increment inner edge size
+			lres[x]=4;							// flag pixel as inner edge
+		}
+		else {
+			res[x]=1.0f;						// pixel is just part of inner mask, and it's not an edge
+		}
+	}
+	else if (lomask[x]) {						// inner mask was empty, test if outer mask is filled
+		if (!lomask[x+rw] || !lomask[x-1]) {	// test if outer mask is empty above or to the left
+			osz++;								// increment outer edge size
+			lres[x]=3;							// flag pixel as outer edge
+		}
+		else {
+			gsz++;								// increment the gradient pixel count
+			lres[x]=2;							// flag pixel as gradient
+		}
+	}
+	/* Test the TOP row of pixels in buffer, except corners */
+	for (x= t-1; x>=(t-rw)+2; x--) {
+		// test if inner mask is filled
+		if (limask[x]) {
+			// test if pixel to the left, or to the right, are empty in the inner mask,
+			// but filled in the outer mask
+			if ((!limask[x-1] && lomask[x-1]) || (!limask[x+1] && lomask[x+1])) {
+				isz++;							// increment inner edge size
+				lres[x]=4;						// flag pixel as inner edge
+			}
+			else {
+				res[x]=1.0f;					// pixel is just part of inner mask, and it's not an edge
+			}
+		}
+		else if (lomask[x]) {					// inner mask was empty, test if outer mask is filled
+			if (!lomask[x-1] || !lomask[x+1]) {	// test if outer mask is empty to the left or to the right
+				osz++;							// increment outer edge size
+				lres[x]=3;						// flag pixel as outer edge
+			}
+			else {
+				gsz++;							// increment the gradient pixel count
+				lres[x]=2;						// flag pixel as gradient
+			}
+		}
+	}
+
+	/* Test the BOTTOM row of pixels in buffer, except corners */
+	for (x= rw-2; x; x--) {
+		// test if inner mask is filled
+		if (limask[x]) {
+			// test if pixel to the left, or to the right, are empty in the inner mask,
+			// but filled in the outer mask
+			if ((!limask[x-1] && lomask[x-1]) || (!limask[x+1] && lomask[x+1])) {
+				isz++;							// increment inner edge size
+				lres[x]=4;						// flag pixel as inner edge
+			}
+			else {
+				res[x]=1.0f;					// pixel is just part of inner mask, and it's not an edge
+			}
+		}
+		else if (lomask[x]) {					// inner mask was empty, test if outer mask is filled
+			if (!lomask[x-1] || !lomask[x+1]) {	// test if outer mask is empty to the left or to the right
+				osz++;							// increment outer edge size
+				lres[x]=3;						// flag pixel as outer edge
+			}
+			else {
+				gsz++;							// increment the gradient pixel count
+				lres[x]=2;						// flag pixel as gradient
+			}
+		}
+	}
+	/* Test the LEFT edge of pixels in buffer, except corners */
+	for (x= t-(rw<<1)+1; x>=rw; x-=rw) {
+		// test if inner mask is filled
+		if (limask[x]) {
+			// test if pixel underneath, or above, are empty in the inner mask,
+			// but filled in the outer mask
+			if ((!limask[x-rw] && lomask[x-rw]) || (!limask[x+rw] && lomask[x+rw])) {
+				isz++;							// increment inner edge size
+				lres[x]=4;						// flag pixel as inner edge
+			}
+			else {
+				res[x]=1.0f;					// pixel is just part of inner mask, and it's not an edge
+			}
+		}
+		else if (lomask[x]) {						// inner mask was empty, test if outer mask is filled
+			if (!lomask[x-rw] || !lomask[x+rw]) {	// test if outer mask is empty underneath or above
+				osz++;								// increment outer edge size
+				lres[x]=3;							// flag pixel as outer edge
+			}
+			else {
+				gsz++;							// increment the gradient pixel count
+				lres[x]=2;						// flag pixel as gradient
+			}
+		}
+	}
+
+	/* Test the RIGHT edge of pixels in buffer, except corners */
+	for (x= t-rw; x>rw; x-=rw) {
+		// test if inner mask is filled
+		if (limask[x]) {
+			// test if pixel underneath, or above, are empty in the inner mask,
+			// but filled in the outer mask
+			if ((!limask[x-rw] && lomask[x-rw]) || (!limask[x+rw] && lomask[x+rw])) {
+				isz++;							// increment inner edge size
+				lres[x]=4;						// flag pixel as inner edge
+			}
+			else {
+				res[x]=1.0f;					// pixel is just part of inner mask, and it's not an edge
+			}
+		}
+		else if (lomask[x]) {						// inner mask was empty, test if outer mask is filled
+			if (!lomask[x-rw] || !lomask[x+rw]) {	// test if outer mask is empty underneath or above
+				osz++;								// increment outer edge size
+				lres[x]=3;							// flag pixel as outer edge
+			}
+			else {
+				gsz++;							// increment the gradient pixel count
+				lres[x]=2;						// flag pixel as gradient
+			}
+		}
+	}
+
+	rsize[0]=isz;  // fill in our return sizes for edges + fill
+	rsize[1]=osz;
+	rsize[2]=gsz;
 }
 
 static void do_allKeepBorders(unsigned int t, unsigned int rw, unsigned int *limask, unsigned int *lomask, unsigned int *lres, float *res, unsigned int *rsize)
 {
-    int x;
-    unsigned int isz=0; // inner edge size
-    unsigned int osz=0; // outer edge size
-    unsigned int gsz=0; // gradient fill area size
-    /* Test the four corners */
-    /* upper left corner */
-    x=t-rw+1;
-    // test if inner mask is filled
-    if(limask[x]){
-        // test if the inner mask is empty underneath or to the right
-        if(!limask[x-rw] || !limask[x+1]){
-            isz++;                               // increment inner edge size
-            lres[x]=4;                           // flag pixel as inner edge
-        } else {
-            res[x]=1.0f;                         // pixel is just part of inner mask, and it's not an edge
-        }
-    } else if(lomask[x]){                        // inner mask was empty, test if outer mask is filled
-        osz++;                                   // increment outer edge size
-        lres[x]=3;                               // flag pixel as outer edge
-    }
-    /* upper right corner */
-    x=t;
-    // test if inner mask is filled
-    if(limask[x]){
-        // test if the inner mask is empty underneath or to the left
-        if(!limask[x-rw] || !limask[x-1]){
-            isz++;                               // increment inner edge size
-            lres[x]=4;                           // flag pixel as inner edge
-        } else {
-            res[x]=1.0f;                         // pixel is just part of inner mask, and it's not an edge
-        }
-    } else if(lomask[x]){                        // inner mask was empty, test if outer mask is filled
-        osz++;                                   // increment outer edge size
-        lres[x]=3;                               // flag pixel as outer edge
-    }
-    /* lower left corner */
-    x=0;
-    // test if inner mask is filled
-    if(limask[x]){
-        // test if inner mask is empty above or to the right
-        if(!limask[x+rw] || !limask[x+1]){
-            isz++;                               // increment inner edge size
-            lres[x]=4;                           // flag pixel as inner edge
-        } else {
-            res[x]=1.0f;                         // pixel is just part of inner mask, and it's not an edge
-        }
-    } else if(lomask[x]){                        // inner mask was empty, test if outer mask is filled
-        osz++;                                   // increment outer edge size
-        lres[x]=3;                               // flag pixel as outer edge
-    }
-    /* lower right corner */
-    x=rw-1;
-    // test if inner mask is filled
-    if(limask[x]){
-        // test if inner mask is empty above or to the left
-        if(!limask[x+rw] || !limask[x-1]){
-            isz++;                               // increment inner edge size
-            lres[x]=4;                           // flag pixel as inner edge
-        } else {
-            res[x]=1.0f;                         // pixel is just part of inner mask, and it's not an edge
-        }
-    } else if(lomask[x]){                        // inner mask was empty, test if outer mask is filled
-        osz++;                                   // increment outer edge size
-        lres[x]=3;                               // flag pixel as outer edge
-    }
-
-    /* Test the TOP row of pixels in buffer, except corners */
-    for(x= t-1; x>=(t-rw)+2; x--) {
-        // test if inner mask is filled
-        if(limask[x]) {
-            // test if inner mask is empty to the left or to the right
-            if(!limask[x-1] || !limask[x+1]) {
-                isz++;                           // increment inner edge size
-                lres[x]=4;                       // flag pixel as inner edge
-            } else {
-                res[x]=1.0f;                     // pixel is just part of inner mask, and it's not an edge
-            }
-        } else if(lomask[x]) {                   // inner mask was empty, test if outer mask is filled
-            osz++;                               // increment outer edge size
-            lres[x]=3;                           // flag pixel as outer edge
-        }
-    }
-
-    /* Test the BOTTOM row of pixels in buffer, except corners */
-    for(x= rw-2; x; x--) {
-        // test if inner mask is filled
-        if(limask[x]) {
-            // test if inner mask is empty to the left or to the right
-            if(!limask[x-1] || !limask[x+1]) {
-                isz++;                           // increment inner edge size
-                lres[x]=4;                       // flag pixel as inner edge
-            } else {
-                res[x]=1.0f;                     // pixel is just part of inner mask, and it's not an edge
-            }
-        } else if(lomask[x]) {                   // inner mask was empty, test if outer mask is filled
-            osz++;                               // increment outer edge size
-            lres[x]=3;                           // flag pixel as outer edge
-        }
-    }
-    /* Test the LEFT edge of pixels in buffer, except corners */
-    for(x= t-(rw<<1)+1; x>=rw; x-=rw) {
-        // test if inner mask is filled
-        if(limask[x]) {
-            // test if inner mask is empty underneath or above
-            if(!limask[x-rw] || !limask[x+rw]) {
-                isz++;                           // increment inner edge size
-                lres[x]=4;                       // flag pixel as inner edge
-            } else {
-                res[x]=1.0f;                     // pixel is just part of inner mask, and it's not an edge
-            }
-        } else if(lomask[x]) {                   // inner mask was empty, test if outer mask is filled
-            osz++;                               // increment outer edge size
-            lres[x]=3;                           // flag pixel as outer edge
-        }
-    }
-
-    /* Test the RIGHT edge of pixels in buffer, except corners */
-    for(x= t-rw; x>rw; x-=rw) {
-        // test if inner mask is filled
-        if(limask[x]) {
-            // test if inner mask is empty underneath or above
-            if(!limask[x-rw] || !limask[x+rw]) {
-                isz++;                           // increment inner edge size
-                lres[x]=4;                       // flag pixel as inner edge
-            } else {
-                res[x]=1.0f;                     // pixel is just part of inner mask, and it's not an edge
-            }
-        } else if(lomask[x]) {                   // inner mask was empty, test if outer mask is filled
-            osz++;                               // increment outer edge size
-            lres[x]=3;                           // flag pixel as outer edge
-        }
-    }
-
-    rsize[0]=isz;  // fill in our return sizes for edges + fill
-    rsize[1]=osz;
-    rsize[2]=gsz;
+	int x;
+	unsigned int isz=0; // inner edge size
+	unsigned int osz=0; // outer edge size
+	unsigned int gsz=0; // gradient fill area size
+	/* Test the four corners */
+	/* upper left corner */
+	x=t-rw+1;
+	// test if inner mask is filled
+	if (limask[x]) {
+		// test if the inner mask is empty underneath or to the right
+		if (!limask[x-rw] || !limask[x+1]) {
+			isz++;								// increment inner edge size
+			lres[x]=4;							// flag pixel as inner edge
+		}
+		else {
+			res[x]=1.0f;						// pixel is just part of inner mask, and it's not an edge
+		}
+	}
+	else if (lomask[x]) {						// inner mask was empty, test if outer mask is filled
+		osz++;									// increment outer edge size
+		lres[x]=3;								// flag pixel as outer edge
+	}
+	/* upper right corner */
+	x=t;
+	// test if inner mask is filled
+	if (limask[x]) {
+		// test if the inner mask is empty underneath or to the left
+		if (!limask[x-rw] || !limask[x-1]) {
+			isz++;								// increment inner edge size
+			lres[x]=4;							// flag pixel as inner edge
+		}
+		else {
+			res[x]=1.0f;						// pixel is just part of inner mask, and it's not an edge
+		}
+	}
+	else if (lomask[x]) {						// inner mask was empty, test if outer mask is filled
+		osz++;									// increment outer edge size
+		lres[x]=3;								// flag pixel as outer edge
+	}
+	/* lower left corner */
+	x=0;
+	// test if inner mask is filled
+	if (limask[x]) {
+		// test if inner mask is empty above or to the right
+		if (!limask[x+rw] || !limask[x+1]) {
+			isz++;								// increment inner edge size
+			lres[x]=4;							// flag pixel as inner edge
+		}
+		else {
+			res[x]=1.0f;						// pixel is just part of inner mask, and it's not an edge
+		}
+	}
+	else if (lomask[x]) {						// inner mask was empty, test if outer mask is filled
+		osz++;									// increment outer edge size
+		lres[x]=3;								// flag pixel as outer edge
+	}
+	/* lower right corner */
+	x=rw-1;
+	// test if inner mask is filled
+	if (limask[x]) {
+		// test if inner mask is empty above or to the left
+		if (!limask[x+rw] || !limask[x-1]) {
+			isz++;								// increment inner edge size
+			lres[x]=4;							// flag pixel as inner edge
+		}
+		else {
+			res[x]=1.0f;						// pixel is just part of inner mask, and it's not an edge
+		}
+	}
+	else if (lomask[x]) {						// inner mask was empty, test if outer mask is filled
+		osz++;									// increment outer edge size
+		lres[x]=3;								// flag pixel as outer edge
+	}
+
+	/* Test the TOP row of pixels in buffer, except corners */
+	for (x= t-1; x>=(t-rw)+2; x--) {
+		// test if inner mask is filled
+		if (limask[x]) {
+			// test if inner mask is empty to the left or to the right
+			if (!limask[x-1] || !limask[x+1]) {
+				isz++;							// increment inner edge size
+				lres[x]=4;						// flag pixel as inner edge
+			}
+			else {
+				res[x]=1.0f;					// pixel is just part of inner mask, and it's not an edge
+			}
+		}
+		else if (lomask[x]) {					// inner mask was empty, test if outer mask is filled
+			osz++;								// increment outer edge size
+			lres[x]=3;							// flag pixel as outer edge
+		}
+	}
+
+	/* Test the BOTTOM row of pixels in buffer, except corners */
+	for (x= rw-2; x; x--) {
+		// test if inner mask is filled
+		if (limask[x]) {
+			// test if inner mask is empty to the left or to the right
+			if (!limask[x-1] || !limask[x+1]) {
+				isz++;							// increment inner edge size
+				lres[x]=4;						// flag pixel as inner edge
+			}
+			else {
+				res[x]=1.0f;					// pixel is just part of inner mask, and it's not an edge
+			}
+		}
+		else if (lomask[x]) {					// inner mask was empty, test if outer mask is filled
+			osz++;								// increment outer edge size
+			lres[x]=3;							// flag pixel as outer edge
+		}
+	}
+	/* Test the LEFT edge of pixels in buffer, except corners */
+	for (x= t-(rw<<1)+1; x>=rw; x-=rw) {
+		// test if inner mask is filled
+		if (limask[x]) {
+			// test if inner mask is empty underneath or above
+			if (!limask[x-rw] || !limask[x+rw]) {
+				isz++;							// increment inner edge size
+				lres[x]=4;						// flag pixel as inner edge
+			}
+			else {
+				res[x]=1.0f;					// pixel is just part of inner mask, and it's not an edge
+			}
+		}
+		else if (lomask[x]) {					// inner mask was empty, test if outer mask is filled
+			osz++;								// increment outer edge size
+			lres[x]=3;							// flag pixel as outer edge
+		}
+	}
+
+	/* Test the RIGHT edge of pixels in buffer, except corners */
+	for (x= t-rw; x>rw; x-=rw) {
+		// test if inner mask is filled
+		if (limask[x]) {
+			// test if inner mask is empty underneath or above
+			if (!limask[x-rw] || !limask[x+rw]) {
+				isz++;							// increment inner edge size
+				lres[x]=4;						// flag pixel as inner edge
+			}
+			else {
+				res[x]=1.0f;					// pixel is just part of inner mask, and it's not an edge
+			}
+		}
+		else if (lomask[x]) {					// inner mask was empty, test if outer mask is filled
+			osz++;								// increment outer edge size
+			lres[x]=3;							// flag pixel as outer edge
+		}
+	}
+
+	rsize[0]=isz;  // fill in our return sizes for edges + fill
+	rsize[1]=osz;
+	rsize[2]=gsz;
 }
 
 static void do_allBleedBorders(unsigned int t, unsigned int rw, unsigned int *limask, unsigned int *lomask, unsigned int *lres, float *res, unsigned int *rsize)
 {
-    int x;
-    unsigned int isz=0; // inner edge size
-    unsigned int osz=0; // outer edge size
-    unsigned int gsz=0; // gradient fill area size
-    /* Test the four corners */
-    /* upper left corner */
-    x=t-rw+1;
-    // test if inner mask is filled
-    if(limask[x]){
-        // test if the inner mask is empty underneath or to the right
-        if(!limask[x-rw] || !limask[x+1]){
-            isz++;                               // increment inner edge size
-            lres[x]=4;                           // flag pixel as inner edge
-        } else {
-            res[x]=1.0f;                         // pixel is just part of inner mask, and it's not an edge
-        }
-    } else if(lomask[x]){                        // inner mask was empty, test if outer mask is filled
-        if(!lomask[x-rw] || !lomask[x+1]) {      // test if outer mask is empty underneath or to the right
-            osz++;                               // increment outer edge size
-            lres[x]=3;                           // flag pixel as outer edge
-        } else {
-            gsz++;                               // increment the gradient pixel count
-            lres[x]=2;                           // flag pixel as gradient
-        }
-    }
-    /* upper right corner */
-    x=t;
-    // test if inner mask is filled
-    if(limask[x]){
-        // test if the inner mask is empty underneath or to the left
-        if(!limask[x-rw] || !limask[x-1]){
-            isz++;                               // increment inner edge size
-            lres[x]=4;                           // flag pixel as inner edge
-        } else {
-            res[x]=1.0f;                         // pixel is just part of inner mask, and it's not an edge
-        }
-    } else if(lomask[x]){                        // inner mask was empty, test if outer mask is filled
-        if(!lomask[x-rw] || !lomask[x-1]) {      // test if outer mask is empty above or to the left
-            osz++;                               // increment outer edge size
-            lres[x]=3;                           // flag pixel as outer edge
-        } else {
-            gsz++;                               // increment the gradient pixel count
-            lres[x]=2;                           // flag pixel as gradient
-        }
-    }
-    /* lower left corner */
-    x=0;
-    // test if inner mask is filled
-    if(limask[x]){
-        // test if inner mask is empty above or to the right
-        if(!limask[x+rw] || !limask[x+1]){
-            isz++;                               // increment inner edge size
-            lres[x]=4;                           // flag pixel as inner edge
-        } else {
-            res[x]=1.0f;                         // pixel is just part of inner mask, and it's not an edge
-        }
-    } else if(lomask[x]){                        // inner mask was empty, test if outer mask is filled
-        if(!lomask[x+rw] || !lomask[x+1]) {      // test if outer mask is empty underneath or to the right
-            osz++;                               // increment outer edge size
-            lres[x]=3;                           // flag pixel as outer edge
-        } else {
-            gsz++;                               // increment the gradient pixel count
-            lres[x]=2;                           // flag pixel as gradient
-        }
-    }
-    /* lower right corner */
-    x=rw-1;
-    // test if inner mask is filled
-    if(limask[x]){
-        // test if inner mask is empty above or to the left
-        if(!limask[x+rw] || !limask[x-1]){
-            isz++;                               // increment inner edge size
-            lres[x]=4;                           // flag pixel as inner edge
-        } else {
-            res[x]=1.0f;                         // pixel is just part of inner mask, and it's not an edge
-        }
-    } else if(lomask[x]){                        // inner mask was empty, test if outer mask is filled
-        if(!lomask[x+rw] || !lomask[x-1]) {      // test if outer mask is empty underneath or to the left
-            osz++;                               // increment outer edge size
-            lres[x]=3;                           // flag pixel as outer edge
-        } else {
-            gsz++;                               // increment the gradient pixel count
-            lres[x]=2;                           // flag pixel as gradient
-        }
-    }
-    /* Test the TOP row of pixels in buffer, except corners */
-    for(x= t-1; x>=(t-rw)+2; x--) {
-        // test if inner mask is filled
-        if(limask[x]) {
-            // test if inner mask is empty to the left or to the right
-            if(!limask[x-1] || !limask[x+1]) {
-                isz++;                           // increment inner edge size
-                lres[x]=4;                       // flag pixel as inner edge
-            } else {
-                res[x]=1.0f;                     // pixel is just part of inner mask, and it's not an edge
-            }
-        } else if(lomask[x]) {                   // inner mask was empty, test if outer mask is filled
-            if(!lomask[x-1] || !lomask[x+1]) {   // test if outer mask is empty to the left or to the right
-                osz++;                           // increment outer edge size
-                lres[x]=3;                       // flag pixel as outer edge
-            } else {
-                gsz++;                           // increment the gradient pixel count
-                lres[x]=2;                       // flag pixel as gradient
-            }
-        }
-    }
-
-    /* Test the BOTTOM row of pixels in buffer, except corners */
-    for(x= rw-2; x; x--) {
-        // test if inner mask is filled
-        if(limask[x]) {
-            // test if inner mask is empty to the left or to the right
-            if(!limask[x-1] || !limask[x+1]) {
-                isz++;                           // increment inner edge size
-                lres[x]=4;                       // flag pixel as inner edge
-            } else {
-                res[x]=1.0f;                     // pixel is just part of inner mask, and it's not an edge
-            }
-        } else if(lomask[x]) {                   // inner mask was empty, test if outer mask is filled
-            if(!lomask[x-1] || !lomask[x+1]) {   // test if outer mask is empty to the left or to the right
-                osz++;                           // increment outer edge size
-                lres[x]=3;                       // flag pixel as outer edge
-            } else {
-                gsz++;                           // increment the gradient pixel count
-                lres[x]=2;                       // flag pixel as gradient
-            }
-        }
-    }
-    /* Test the LEFT edge of pixels in buffer, except corners */
-    for(x= t-(rw<<1)+1; x>=rw; x-=rw) {
-        // test if inner mask is filled
-        if(limask[x]) {
-            // test if inner mask is empty underneath or above
-            if(!limask[x-rw] || !limask[x+rw]) {
-                isz++;                           // increment inner edge size
-                lres[x]=4;                       // flag pixel as inner edge
-            } else {
-                res[x]=1.0f;                     // pixel is just part of inner mask, and it's not an edge
-            }
-        } else if(lomask[x]) {                   // inner mask was empty, test if outer mask is filled
-            if(!lomask[x-rw] || !lomask[x+rw]) { // test if outer mask is empty underneath or above
-                osz++;                           // increment outer edge size
-                lres[x]=3;                       // flag pixel as outer edge
-            } else {
-                gsz++;                           // increment the gradient pixel count
-                lres[x]=2;                       // flag pixel as gradient
-            }
-        }
-    }
-
-    /* Test the RIGHT edge of pixels in buffer, except corners */
-    for(x= t-rw; x>rw; x-=rw) {
-        // test if inner mask is filled
-        if(limask[x]) {
-            // test if inner mask is empty underneath or above
-            if(!limask[x-rw] || !limask[x+rw]) {
-                isz++;                           // increment inner edge size
-                lres[x]=4;                       // flag pixel as inner edge
-            } else {
-                res[x]=1.0f;                     // pixel is just part of inner mask, and it's not an edge
-            }
-        } else if(lomask[x]) {                   // inner mask was empty, test if outer mask is filled
-            if(!lomask[x-rw] || !lomask[x+rw]) { // test if outer mask is empty underneath or above
-                osz++;                           // increment outer edge size
-                lres[x]=3;                       // flag pixel as outer edge
-            } else {
-                gsz++;                           // increment the gradient pixel count
-                lres[x]=2;                       // flag pixel as gradient
-            }
-        }
-    }
-
-    rsize[0]=isz;  // fill in our return sizes for edges + fill
-    rsize[1]=osz;
-    rsize[2]=gsz;
+	int x;
+	unsigned int isz=0; // inner edge size
+	unsigned int osz=0; // outer edge size
+	unsigned int gsz=0; // gradient fill area size
+	/* Test the four corners */
+	/* upper left corner */
+	x=t-rw+1;
+	// test if inner mask is filled
+	if (limask[x]) {
+		// test if the inner mask is empty underneath or to the right
+		if (!limask[x-rw] || !limask[x+1]) {
+			isz++;								// increment inner edge size
+			lres[x]=4;							// flag pixel as inner edge
+		}
+		else {
+			res[x]=1.0f;						// pixel is just part of inner mask, and it's not an edge
+		}
+	}
+	else if (lomask[x]) {						// inner mask was empty, test if outer mask is filled
+		if (!lomask[x-rw] || !lomask[x+1]) {	// test if outer mask is empty underneath or to the right
+			osz++;								// increment outer edge size
+			lres[x]=3;							// flag pixel as outer edge
+		}
+		else {
+			gsz++;								// increment the gradient pixel count
+			lres[x]=2;							// flag pixel as gradient
+		}
+	}
+	/* upper right corner */
+	x=t;
+	// test if inner mask is filled
+	if (limask[x]) {
+		// test if the inner mask is empty underneath or to the left
+		if (!limask[x-rw] || !limask[x-1]) {
+			isz++;								// increment inner edge size
+			lres[x]=4;							// flag pixel as inner edge
+		}
+		else {
+			res[x]=1.0f;						// pixel is just part of inner mask, and it's not an edge
+		}
+	}
+	else if (lomask[x]) {						// inner mask was empty, test if outer mask is filled
+		if (!lomask[x-rw] || !lomask[x-1]) {		// test if outer mask is empty above or to the left
+			osz++;								// increment outer edge size
+			lres[x]=3;							// flag pixel as outer edge
+		}
+		else {
+			gsz++;								// increment the gradient pixel count
+			lres[x]=2;							// flag pixel as gradient
+		}
+	}
+	/* lower left corner */
+	x=0;
+	// test if inner mask is filled
+	if (limask[x]) {
+		// test if inner mask is empty above or to the right
+		if (!limask[x+rw] || !limask[x+1]) {
+			isz++;								// increment inner edge size
+			lres[x]=4;							// flag pixel as inner edge
+		}
+		else {
+			res[x]=1.0f;						// pixel is just part of inner mask, and it's not an edge
+		}
+	}
+	else if (lomask[x]) {						// inner mask was empty, test if outer mask is filled
+		if (!lomask[x+rw] || !lomask[x+1]) {	// test if outer mask is empty underneath or to the right
+			osz++;								// increment outer edge size
+			lres[x]=3;							// flag pixel as outer edge
+		}
+		else {
+			gsz++;								// increment the gradient pixel count
+			lres[x]=2;							// flag pixel as gradient
+		}
+	}
+	/* lower right corner */
+	x=rw-1;
+	// test if inner mask is filled
+	if (limask[x]) {
+		// test if inner mask is empty above or to the left
+		if (!limask[x+rw] || !limask[x-1]) {
+			isz++;								// increment inner edge size
+			lres[x]=4;							// flag pixel as inner edge
+		}
+		else {
+			res[x]=1.0f;						// pixel is just part of inner mask, and it's not an edge
+		}
+	}
+	else if (lomask[x]) {						// inner mask was empty, test if outer mask is filled
+		if (!lomask[x+rw] || !lomask[x-1]) {	// test if outer mask is empty underneath or to the left
+			osz++;								// increment outer edge size
+			lres[x]=3;							// flag pixel as outer edge
+		}
+		else {
+			gsz++;								// increment the gradient pixel count
+			lres[x]=2;							// flag pixel as gradient
+		}
+	}
+	/* Test the TOP row of pixels in buffer, except corners */
+	for (x= t-1; x>=(t-rw)+2; x--) {
+		// test if inner mask is filled
+		if (limask[x]) {
+			// test if inner mask is empty to the left or to the right
+			if (!limask[x-1] || !limask[x+1]) {
+				isz++;							// increment inner edge size
+				lres[x]=4;						// flag pixel as inner edge
+			}
+			else {
+				res[x]=1.0f;					// pixel is just part of inner mask, and it's not an edge
+			}
+		}
+		else if (lomask[x]) {					// inner mask was empty, test if outer mask is filled
+			if (!lomask[x-1] || !lomask[x+1]) {	// test if outer mask is empty to the left or to the right
+				osz++;							// increment outer edge size
+				lres[x]=3;						// flag pixel as outer edge
+			}
+			else {
+				gsz++;							// increment the gradient pixel count
+				lres[x]=2;						// flag pixel as gradient
+			}
+		}
+	}
+
+	/* Test the BOTTOM row of pixels in buffer, except corners */
+	for (x= rw-2; x; x--) {
+		// test if inner mask is filled
+		if (limask[x]) {
+			// test if inner mask is empty to the left or to the right
+			if (!limask[x-1] || !limask[x+1]) {
+				isz++;							// increment inner edge size
+				lres[x]=4;						// flag pixel as inner edge
+			}
+			else {
+				res[x]=1.0f;					// pixel is just part of inner mask, and it's not an edge
+			}
+		}
+		else if (lomask[x]) {					// inner mask was empty, test if outer mask is filled
+			if (!lomask[x-1] || !lomask[x+1]) {	// test if outer mask is empty to the left or to the right
+				osz++;							// increment outer edge size
+				lres[x]=3;						// flag pixel as outer edge
+			}
+			else {
+				gsz++;							// increment the gradient pixel count
+				lres[x]=2;						// flag pixel as gradient
+			}
+		}
+	}
+	/* Test the LEFT edge of pixels in buffer, except corners */
+	for (x= t-(rw<<1)+1; x>=rw; x-=rw) {
+		// test if inner mask is filled
+		if (limask[x]) {
+			// test if inner mask is empty underneath or above
+			if (!limask[x-rw] || !limask[x+rw]) {
+				isz++;								// increment inner edge size
+				lres[x]=4;							// flag pixel as inner edge
+			}
+			else {
+				res[x]=1.0f;						// pixel is just part of inner mask, and it's not an edge
+			}
+		}
+		else if (lomask[x]) {						// inner mask was empty, test if outer mask is filled
+			if (!lomask[x-rw] || !lomask[x+rw]) {	// test if outer mask is empty underneath or above
+				osz++;								// increment outer edge size
+				lres[x]=3;							// flag pixel as outer edge
+			}
+			else {
+				gsz++;								// increment the gradient pixel count
+				lres[x]=2;							// flag pixel as gradient
+			}
+		}
+	}
+
+	/* Test the RIGHT edge of pixels in buffer, except corners */
+	for (x= t-rw; x>rw; x-=rw) {
+		// test if inner mask is filled
+		if (limask[x]) {
+			// test if inner mask is empty underneath or above
+			if (!limask[x-rw] || !limask[x+rw]) {
+				isz++;							// increment inner edge size
+				lres[x]=4;						// flag pixel as inner edge
+			}
+			else {
+				res[x]=1.0f;					// pixel is just part of inner mask, and it's not an edge
+			}
+		}
+		else if (lomask[x]) {						// inner mask was empty, test if outer mask is filled
+			if (!lomask[x-rw] || !lomask[x+rw]) {	// test if outer mask is empty underneath or above
+				osz++;								// increment outer edge size
+				lres[x]=3;							// flag pixel as outer edge
+			}
+			else {
+				gsz++;							// increment the gradient pixel count
+				lres[x]=2;						// flag pixel as gradient
+			}
+		}
+	}
+
+	rsize[0]=isz;  // fill in our return sizes for edges + fill
+	rsize[1]=osz;
+	rsize[2]=gsz;
 }
 
 static void do_allEdgeDetection(unsigned int t, unsigned int rw, unsigned int *limask, unsigned int *lomask, unsigned int *lres, float *res, unsigned int *rsize, unsigned int in_isz, unsigned int in_osz, unsigned int in_gsz)
 {
-    int x;                             // x = pixel loop counter
-    int a;                             // a = pixel loop counter
-    int dx;                            // dx = delta x
-    int pix_prevRow;                   // pix_prevRow = pixel one row behind the one we are testing in a loop
-    int pix_nextRow;                   // pix_nextRow = pixel one row in front of the one we are testing in a loop
-    int pix_prevCol;                   // pix_prevCol = pixel one column behind the one we are testing in a loop
-    int pix_nextCol;                   // pix_nextCol = pixel one column in front of the one we are testing in a loop
-    /* Test all rows between the FIRST and LAST rows, excluding left and right edges */
-    for(x= (t-rw)+1, dx=x-(rw-2); dx>rw; x-=rw,dx-=rw) {
-        a=x-2;
-        pix_prevRow=a+rw;
-        pix_nextRow=a-rw;
-        pix_prevCol=a+1;
-        pix_nextCol=a-1;
-        while(a>dx-2) {
-            if(!limask[a]) {             // if the inner mask is empty
-                if(lomask[a]) {          // if the outer mask is full
-                    /*
-                      Next we test all 4 directions around the current pixel: next/prev/up/down
-                      The test ensures that the outer mask is empty and that the inner mask
-                      is also empty. If both conditions are true for any one of the 4 adjacent pixels
-                      then the current pixel is counted as being a true outer edge pixel.
-                     */
-                    if((!lomask[pix_nextCol] && !limask[pix_nextCol]) ||
-                       (!lomask[pix_prevCol] && !limask[pix_prevCol]) ||
-                       (!lomask[pix_nextRow] && !limask[pix_nextRow]) ||
-                       (!lomask[pix_prevRow] && !limask[pix_prevRow]))
+	int x;								// x = pixel loop counter
+	int a;								// a = pixel loop counter
+	int dx;								// dx = delta x
+	int pix_prevRow;					// pix_prevRow = pixel one row behind the one we are testing in a loop
+	int pix_nextRow;					// pix_nextRow = pixel one row in front of the one we are testing in a loop
+	int pix_prevCol;					// pix_prevCol = pixel one column behind the one we are testing in a loop
+	int pix_nextCol;					// pix_nextCol = pixel one column in front of the one we are testing in a loop
+	/* Test all rows between the FIRST and LAST rows, excluding left and right edges */
+	for (x= (t-rw)+1, dx=x-(rw-2); dx>rw; x-=rw,dx-=rw) {
+		a=x-2;
+		pix_prevRow=a+rw;
+		pix_nextRow=a-rw;
+		pix_prevCol=a+1;
+		pix_nextCol=a-1;
+		while(a>dx-2) {
+			if (!limask[a]) {			// if the inner mask is empty
+				if (lomask[a]) {		// if the outer mask is full
+					/*
+					 * Next we test all 4 directions around the current pixel: next/prev/up/down
+					 * The test ensures that the outer mask is empty and that the inner mask
+					 * is also empty. If both conditions are true for any one of the 4 adjacent pixels
+					 * then the current pixel is counted as being a true outer edge pixel.
+					 */
+					if ((!lomask[pix_nextCol] && !limask[pix_nextCol]) ||
+					    (!lomask[pix_prevCol] && !limask[pix_prevCol]) ||
+					    (!lomask[pix_nextRow] && !limask[pix_nextRow]) ||
+					    (!lomask[pix_prevRow] && !limask[pix_prevRow]))
 					{
-                        in_osz++;           // increment the outer boundary pixel count
-                        lres[a]=3;       // flag pixel as part of outer edge
-                    } else {             // it's not a boundary pixel, but it is a gradient pixel
-                        in_gsz++;           // increment the gradient pixel count
-                        lres[a]=2;       // flag pixel as gradient
-                    }
-                }
-
-            } else {
-                if(!limask[pix_nextCol] || !limask[pix_prevCol] || !limask[pix_nextRow] || !limask[pix_prevRow]) {
-                    in_isz++;               // increment the inner boundary pixel count
-                    lres[a]=4;           // flag pixel as part of inner edge
-                } else {
-                    res[a]=1.0f;         // pixel is part of inner mask, but not at an edge
-                }
-            }
-            a--;
-            pix_prevRow--;
-            pix_nextRow--;
-            pix_prevCol--;
-            pix_nextCol--;
-        }
-    }
-
-    rsize[0]=in_isz;  // fill in our return sizes for edges + fill
-    rsize[1]=in_osz;
-    rsize[2]=in_gsz;
+						in_osz++;		// increment the outer boundary pixel count
+						lres[a]=3;		// flag pixel as part of outer edge
+					}
+					else {				// it's not a boundary pixel, but it is a gradient pixel
+						in_gsz++;		// increment the gradient pixel count
+						lres[a]=2;		// flag pixel as gradient
+					}
+				}
+
+			}
+			else {
+				if (!limask[pix_nextCol] || !limask[pix_prevCol] || !limask[pix_nextRow] || !limask[pix_prevRow]) {
+					in_isz++;			// increment the inner boundary pixel count
+					lres[a]=4;			// flag pixel as part of inner edge
+				}
+				else {
+					res[a]=1.0f;		// pixel is part of inner mask, but not at an edge
+				}
+			}
+			a--;
+			pix_prevRow--;
+			pix_nextRow--;
+			pix_prevCol--;
+			pix_nextCol--;
+		}
+	}
+
+	rsize[0]=in_isz;  // fill in our return sizes for edges + fill
+	rsize[1]=in_osz;
+	rsize[2]=in_gsz;
 }
 
 static void do_adjacentEdgeDetection(unsigned int t, unsigned int rw, unsigned int *limask, unsigned int *lomask, unsigned int *lres, float *res, unsigned int *rsize, unsigned int in_isz, unsigned int in_osz, unsigned int in_gsz)
 {
-    int x;                             // x = pixel loop counter
-    int a;                             // a = pixel loop counter
-    int dx;                            // dx = delta x
-    int pix_prevRow;                   // pix_prevRow = pixel one row behind the one we are testing in a loop
-    int pix_nextRow;                   // pix_nextRow = pixel one row in front of the one we are testing in a loop
-    int pix_prevCol;                   // pix_prevCol = pixel one column behind the one we are testing in a loop
-    int pix_nextCol;                   // pix_nextCol = pixel one column in front of the one we are testing in a loop
-    /* Test all rows between the FIRST and LAST rows, excluding left and right edges */
-    for(x= (t-rw)+1, dx=x-(rw-2); dx>rw; x-=rw,dx-=rw) {
-        a=x-2;
-        pix_prevRow=a+rw;
-        pix_nextRow=a-rw;
-        pix_prevCol=a+1;
-        pix_nextCol=a-1;
-        while(a>dx-2) {
-            if(!limask[a]) {             // if the inner mask is empty
-                if(lomask[a]) {          // if the outer mask is full
-                    /*
-                      Next we test all 4 directions around the current pixel: next/prev/up/down
-                      The test ensures that the outer mask is empty and that the inner mask
-                      is also empty. If both conditions are true for any one of the 4 adjacent pixels
-                      then the current pixel is counted as being a true outer edge pixel.
-                     */
-                    if((!lomask[pix_nextCol] && !limask[pix_nextCol]) ||
-                       (!lomask[pix_prevCol] && !limask[pix_prevCol]) ||
-                       (!lomask[pix_nextRow] && !limask[pix_nextRow]) ||
-                       (!lomask[pix_prevRow] && !limask[pix_prevRow]))
+	int x;							// x = pixel loop counter
+	int a;							// a = pixel loop counter
+	int dx;							// dx = delta x
+	int pix_prevRow;				// pix_prevRow = pixel one row behind the one we are testing in a loop
+	int pix_nextRow;				// pix_nextRow = pixel one row in front of the one we are testing in a loop
+	int pix_prevCol;				// pix_prevCol = pixel one column behind the one we are testing in a loop
+	int pix_nextCol;				// pix_nextCol = pixel one column in front of the one we are testing in a loop
+	/* Test all rows between the FIRST and LAST rows, excluding left and right edges */
+	for (x= (t-rw)+1, dx=x-(rw-2); dx>rw; x-=rw,dx-=rw) {
+		a=x-2;
+		pix_prevRow=a+rw;
+		pix_nextRow=a-rw;
+		pix_prevCol=a+1;
+		pix_nextCol=a-1;
+		while(a>dx-2) {
+			if (!limask[a]) {			// if the inner mask is empty
+				if (lomask[a]) {		// if the outer mask is full
+					/*
+					 * Next we test all 4 directions around the current pixel: next/prev/up/down
+					 * The test ensures that the outer mask is empty and that the inner mask
+					 * is also empty. If both conditions are true for any one of the 4 adjacent pixels
+					 * then the current pixel is counted as being a true outer edge pixel.
+					 */
+					if ((!lomask[pix_nextCol] && !limask[pix_nextCol]) ||
+					    (!lomask[pix_prevCol] && !limask[pix_prevCol]) ||
+					    (!lomask[pix_nextRow] && !limask[pix_nextRow]) ||
+					    (!lomask[pix_prevRow] && !limask[pix_prevRow]))
 					{
-                        in_osz++;           // increment the outer boundary pixel count
-                        lres[a]=3;       // flag pixel as part of outer edge
-                    } else {             // it's not a boundary pixel, but it is a gradient pixel
-                        in_gsz++;           // increment the gradient pixel count
-                        lres[a]=2;       // flag pixel as gradient
-                    }
-                }
-
-            } else {
-                if((!limask[pix_nextCol] && lomask[pix_nextCol]) ||
-                   (!limask[pix_prevCol] && lomask[pix_prevCol]) ||
-                   (!limask[pix_nextRow] && lomask[pix_nextRow]) ||
-                   (!limask[pix_prevRow] && lomask[pix_prevRow]))
+						in_osz++;		// increment the outer boundary pixel count
+						lres[a]=3;		// flag pixel as part of outer edge
+					}
+					else {				// it's not a boundary pixel, but it is a gradient pixel
+						in_gsz++;		// increment the gradient pixel count
+						lres[a]=2;		// flag pixel as gradient
+					}
+				}
+
+			}
+			else {
+				if ((!limask[pix_nextCol] && lomask[pix_nextCol]) ||
+				    (!limask[pix_prevCol] && lomask[pix_prevCol]) ||
+				    (!limask[pix_nextRow] && lomask[pix_nextRow]) ||
+				    (!limask[pix_prevRow] && lomask[pix_prevRow]))
 				{
-                    in_isz++;               // increment the inner boundary pixel count
-                    lres[a]=4;           // flag pixel as part of inner edge
-                } else {
-                    res[a]=1.0f;         // pixel is part of inner mask, but not at an edge
-                }
-            }
-            a--;
-            pix_prevRow--;              // advance all four "surrounding" pixel pointers
-            pix_nextRow--;
-            pix_prevCol--;
-            pix_nextCol--;
-        }
-    }
-
-    rsize[0]=in_isz;  // fill in our return sizes for edges + fill
-    rsize[1]=in_osz;
-    rsize[2]=in_gsz;
+					in_isz++;			// increment the inner boundary pixel count
+					lres[a]=4;			// flag pixel as part of inner edge
+				}
+				else {
+					res[a]=1.0f;		// pixel is part of inner mask, but not at an edge
+				}
+			}
+			a--;
+			pix_prevRow--;				// advance all four "surrounding" pixel pointers
+			pix_nextRow--;
+			pix_prevCol--;
+			pix_nextCol--;
+		}
+	}
+
+	rsize[0]=in_isz;  // fill in our return sizes for edges + fill
+	rsize[1]=in_osz;
+	rsize[2]=in_gsz;
 }
 
 static void do_createEdgeLocationBuffer(unsigned int t, unsigned int rw, unsigned int *lres, float *res, unsigned short *gbuf, unsigned int *innerEdgeOffset, unsigned int *outerEdgeOffset, unsigned int isz, unsigned int gsz)
 {
-    int x;                             // x = pixel loop counter
-    int a;                             // a = temporary pixel index buffer loop counter
-    unsigned int ud;                   // ud = unscaled edge distance
-    unsigned int dmin;                 // dmin = minimun edge distance
-
-    unsigned int rsl;                  // long used for finding fast 1.0/sqrt
-    unsigned int gradientFillOffset;
-    unsigned int innerAccum=0;         // for looping inner edge pixel indexes, represents current position from offset
-    unsigned int outerAccum=0;         // for looping outer edge pixel indexes, represents current position from offset
-    unsigned int gradientAccum=0;      // for looping gradient pixel indexes, represents current position from offset
-    /*
-    Here we compute the size of buffer needed to hold (row,col) coordinates
-    for each pixel previously determined to be either gradient, inner edge,
-    or outer edge.
-
-    Allocation is done by requesting 4 bytes "sizeof(int)" per pixel, even
-    though gbuf[] is declared as unsigned short* (2 bytes) because we don't
-    store the pixel indexes, we only store x,y location of pixel in buffer.
-
-    This does make the assumption that x and y can fit in 16 unsigned bits
-    so if Blender starts doing renders greater than 65536 in either direction
-    this will need to allocate gbuf[] as unsigned int* and allocate 8 bytes
-    per flagged pixel.
-
-    In general, the buffer on-screen:
-
-    Example:  9 by 9 pixel block
-
-    . = pixel non-white in both outer and inner mask
-    o = pixel white in outer, but not inner mask, adjacent to "." pixel
-    g = pixel white in outer, but not inner mask, not adjacent to "." pixel
-    i = pixel white in inner mask, adjacent to "g" or "." pixel
-    F = pixel white in inner mask, only adjacent to other pixels white in the inner mask
-
-
-                     .........   <----- pixel #80
-                     ..oooo...
-                     .oggggo..
-                     .oggiggo.
-                     .ogiFigo.
-                     .oggiggo.
-                     .oggggo..
-                     ..oooo...
-    pixel #00 -----> .........
-
-    gsz = 18   (18 "g" pixels above)
-    isz = 4    (4 "i" pixels above)
-    osz = 18   (18 "o" pixels above)
-
-
-    The memory in gbuf[] after filling will look like this:
-
-     gradientFillOffset (0 pixels)                   innerEdgeOffset (18 pixels)    outerEdgeOffset (22 pixels)
-    /                                               /                              /
-    /                                               /                              /
-    |X   Y   X   Y   X   Y   X   Y   >     <X   Y   X   Y   >     <X   Y   X   Y   X   Y   >     <X   Y   X   Y   | <- (x,y)
-    +-------------------------------->     <---------------->     <------------------------>     <----------------+
-    |0   2   4   6   8   10  12  14  > ... <68  70  72  74  > ... <80  82  84  86  88  90  > ... <152 154 156 158 | <- bytes
-    +-------------------------------->     <---------------->     <------------------------>     <----------------+
-    |g0  g0  g1  g1  g2  g2  g3  g3  >     <g17 g17 i0  i0  >     <i2  i2  i3  i3  o0  o0  >     <o16 o16 o17 o17 | <- pixel
-                                                 /                              /                              /
-                                                /                              /                              /
-                                               /                              /                              /
-      +---------- gradientAccum (18) ---------+      +--- innerAccum (22) ---+      +--- outerAccum (40) ---+
-
-
-    Ultimately we do need the pixel's memory buffer index to set the output
-    pixel color, but it's faster to reconstruct the memory buffer location
-    each iteration of the final gradient calculation than it is to deconstruct
-    a memory location into x,y pairs each round.
-*/
-
-
-    gradientFillOffset=0;                              // since there are likely "more" of these, put it first. :)
-    *innerEdgeOffset=gradientFillOffset+gsz;           // set start of inner edge indexes
-    *outerEdgeOffset=(*innerEdgeOffset)+isz;           // set start of outer edge indexes
-    /* set the accumulators to correct positions */    // set up some accumulator variables for loops
-    gradientAccum = gradientFillOffset;                // each accumulator variable starts at its respective
-    innerAccum = *innerEdgeOffset;                     // section's offset so when we start filling, each
-    outerAccum = *outerEdgeOffset;                     // section fills up it's allocated space in gbuf
-    //uses dmin=row, rsl=col
-    for(x=0,dmin=0; x<t; x+=rw,dmin++) {
-        for(rsl=0; rsl<rw; rsl++) {
-            a=x+rsl;
-            if(lres[a]==2) {           // it is a gradient pixel flagged by 2
-                ud=gradientAccum<<1;   // double the index to reach correct unsigned short location
-                gbuf[ud]=dmin;         // insert pixel's row into gradient pixel location buffer
-                gbuf[ud+1]=rsl;        // insert pixel's column into gradient pixel location buffer
-                gradientAccum++;       // increment gradient index buffer pointer
-            } else if(lres[a]==3) {    // it is an outer edge pixel flagged by 3
-                ud=outerAccum<<1;      // double the index to reach correct unsigned short location
-                gbuf[ud]=dmin;         // insert pixel's row into outer edge pixel location buffer
-                gbuf[ud+1]=rsl;        // insert pixel's column into outer edge pixel location buffer
-                outerAccum++;          // increment outer edge index buffer pointer
-                res[a]=0.0f;           // set output pixel intensity now since it won't change later
-            } else if(lres[a]==4) {    // it is an inner edge pixel flagged by 4
-                ud=innerAccum<<1;      // double int index to reach correct unsigned short location
-                gbuf[ud]=dmin;         // insert pixel's row into inner edge pixel location buffer
-                gbuf[ud+1]=rsl;        // insert pixel's column into inner edge pixel location buffer
-                innerAccum++;          // increment inner edge index buffer pointer
-                res[a]=1.0f;           // set output pixel intensity now since it won't change later
-            }
-        }
-    }
+	int x;							// x = pixel loop counter
+	int a;							// a = temporary pixel index buffer loop counter
+	unsigned int ud;				// ud = unscaled edge distance
+	unsigned int dmin;				// dmin = minimun edge distance
+
+	unsigned int rsl;				// long used for finding fast 1.0/sqrt
+	unsigned int gradientFillOffset;
+	unsigned int innerAccum=0;		// for looping inner edge pixel indexes, represents current position from offset
+	unsigned int outerAccum=0;		// for looping outer edge pixel indexes, represents current position from offset
+	unsigned int gradientAccum=0;	// for looping gradient pixel indexes, represents current position from offset
+	/*
+	 * Here we compute the size of buffer needed to hold (row,col) coordinates
+	 * for each pixel previously determined to be either gradient, inner edge,
+	 * or outer edge.
+	 *
+	 * Allocation is done by requesting 4 bytes "sizeof(int)" per pixel, even
+	 * though gbuf[] is declared as unsigned short* (2 bytes) because we don't
+	 * store the pixel indexes, we only store x,y location of pixel in buffer.
+	 *
+	 * This does make the assumption that x and y can fit in 16 unsigned bits
+	 * so if Blender starts doing renders greater than 65536 in either direction
+	 * this will need to allocate gbuf[] as unsigned int* and allocate 8 bytes
+	 * per flagged pixel.
+	 *
+	 * In general, the buffer on-screen:
+	 *
+	 * Example:  9 by 9 pixel block
+	 *
+	 * . = pixel non-white in both outer and inner mask
+	 * o = pixel white in outer, but not inner mask, adjacent to "." pixel
+	 * g = pixel white in outer, but not inner mask, not adjacent to "." pixel
+	 * i = pixel white in inner mask, adjacent to "g" or "." pixel
+	 * F = pixel white in inner mask, only adjacent to other pixels white in the inner mask
+	 *
+	 *
+	 *                  .........   <----- pixel #80
+	 *                  ..oooo...
+	 *                  .oggggo..
+	 *                  .oggiggo.
+	 *                  .ogiFigo.
+	 *                  .oggiggo.
+	 *                  .oggggo..
+	 *                  ..oooo...
+	 * pixel #00 -----> .........
+	 *
+	 * gsz = 18   (18 "g" pixels above)
+	 * isz = 4    (4 "i" pixels above)
+	 * osz = 18   (18 "o" pixels above)
+	 *
+	 *
+	 * The memory in gbuf[] after filling will look like this:
+	 *
+	 *  gradientFillOffset (0 pixels)                   innerEdgeOffset (18 pixels)    outerEdgeOffset (22 pixels)
+	 * /                                               /                              /
+	 * /                                               /                              /
+	 * |X   Y   X   Y   X   Y   X   Y   >     <X   Y   X   Y   >     <X   Y   X   Y   X   Y   >     <X   Y   X   Y   | <- (x,y)
+	 * +-------------------------------->     <---------------->     <------------------------>     <----------------+
+	 * |0   2   4   6   8   10  12  14  > ... <68  70  72  74  > ... <80  82  84  86  88  90  > ... <152 154 156 158 | <- bytes
+	 * +-------------------------------->     <---------------->     <------------------------>     <----------------+
+	 * |g0  g0  g1  g1  g2  g2  g3  g3  >     <g17 g17 i0  i0  >     <i2  i2  i3  i3  o0  o0  >     <o16 o16 o17 o17 | <- pixel
+	 *                                              /                              /                              /
+	 *                                             /                              /                              /
+	 *                                            /                              /                              /
+	 *   +---------- gradientAccum (18) ---------+      +--- innerAccum (22) ---+      +--- outerAccum (40) ---+
+	 *
+	 *
+	 * Ultimately we do need the pixel's memory buffer index to set the output
+	 * pixel color, but it's faster to reconstruct the memory buffer location
+	 * each iteration of the final gradient calculation than it is to deconstruct
+	 * a memory location into x,y pairs each round.
+	 */
+
+
+	gradientFillOffset=0;								// since there are likely "more" of these, put it first. :)
+	*innerEdgeOffset=gradientFillOffset+gsz;			// set start of inner edge indexes
+	*outerEdgeOffset=(*innerEdgeOffset)+isz;			// set start of outer edge indexes
+	/* set the accumulators to correct positions */		// set up some accumulator variables for loops
+	gradientAccum = gradientFillOffset;					// each accumulator variable starts at its respective
+	innerAccum = *innerEdgeOffset;						// section's offset so when we start filling, each
+	outerAccum = *outerEdgeOffset;						// section fills up it's allocated space in gbuf
+	//uses dmin=row, rsl=col
+	for (x=0,dmin=0; x<t; x+=rw,dmin++) {
+		for (rsl=0; rsl<rw; rsl++) {
+			a=x+rsl;
+			if (lres[a]==2) {			// it is a gradient pixel flagged by 2
+				ud=gradientAccum<<1;	// double the index to reach correct unsigned short location
+				gbuf[ud]=dmin;			// insert pixel's row into gradient pixel location buffer
+				gbuf[ud+1]=rsl;			// insert pixel's column into gradient pixel location buffer
+				gradientAccum++;		// increment gradient index buffer pointer
+			}
+			else if (lres[a]==3) {		// it is an outer edge pixel flagged by 3
+				ud=outerAccum<<1;		// double the index to reach correct unsigned short location
+				gbuf[ud]=dmin;			// insert pixel's row into outer edge pixel location buffer
+				gbuf[ud+1]=rsl;			// insert pixel's column into outer edge pixel location buffer
+				outerAccum++;			// increment outer edge index buffer pointer
+				res[a]=0.0f;			// set output pixel intensity now since it won't change later
+			}
+			else if (lres[a]==4) {		// it is an inner edge pixel flagged by 4
+				ud=innerAccum<<1;		// double int index to reach correct unsigned short location
+				gbuf[ud]=dmin;			// insert pixel's row into inner edge pixel location buffer
+				gbuf[ud+1]=rsl;			// insert pixel's column into inner edge pixel location buffer
+				innerAccum++;			// increment inner edge index buffer pointer
+				res[a]=1.0f;			// set output pixel intensity now since it won't change later
+			}
+		}
+	}
 
 }
 
 static void do_fillGradientBuffer(unsigned int rw, float *res, unsigned short *gbuf, unsigned int isz, unsigned int osz, unsigned int gsz, unsigned int innerEdgeOffset, unsigned int outerEdgeOffset)
 {
-    int x;                             // x = pixel loop counter
-    int a;                             // a = temporary pixel index buffer loop counter
-    int fsz;                           // size of the frame
-    unsigned int rsl;                  // long used for finding fast 1.0/sqrt
-    float rsf;                         // float used for finding fast 1.0/sqrt
-    const float rsopf = 1.5f;          // constant float used for finding fast 1.0/sqrt
-
-    unsigned int gradientFillOffset;
-    unsigned int t;
-    unsigned int ud;                   // ud = unscaled edge distance
-    unsigned int dmin;                 // dmin = minimun edge distance
-    float odist;                       // odist = current outer edge distance
-    float idist;                       // idist = current inner edge distance
-    int dx;                            // dx = X-delta (used for distance proportion calculation)
-    int dy;                            // dy = Y-delta (used for distance proportion calculation)
-
-    /*
-     The general algorithm used to color each gradient pixel is:
-
-     1.) Loop through all gradient pixels.
-        A.) For each gradient pixel:
-            a.) Loop though all outside edge pixels, looking for closest one
-                to the gradient pixel we are in.
-            b.) Loop through all inside edge pixels, looking for closest one
-                to the gradient pixel we are in.
-            c.) Find proportion of distance from gradient pixel to inside edge
-                pixel compared to sum of distance to inside edge and distance to
-                outside edge.
-
-                In an image where:
-                . = blank (black) pixels, not covered by inner mask or outer mask
-                + = desired gradient pixels, covered only by outer mask
-                * = white full mask pixels, covered by at least inner mask
-
-                ...............................
-                ...............+++++++++++.....
-                ...+O++++++..++++++++++++++....
-                ..+++\++++++++++++++++++++.....
-                .+++++G+++++++++*******+++.....
-                .+++++|+++++++*********+++.....
-                .++***I****************+++.....
-                .++*******************+++......
-                .+++*****************+++.......
-                ..+++***************+++........
-                ....+++**********+++...........
-                ......++++++++++++.............
-                ...............................
-
-                    O = outside edge pixel
-                     \
-                      G = gradient pixel
-                      |
-                      I = inside edge pixel
-
-                                 __
-                      *note that IO does not need to be a straight line, in fact
-                       many cases can arise where straight lines do not work
-                       correctly.
-
-                                            __       __     __
-            d.) Pixel color is assigned as |GO| / ( |GI| + |GO| )
-
-     The implementation does not compute distance, but the reciprocal of the
-     distance. This is done to avoid having to compute a square root, as a
-     reciprocal square root can be computed faster. Therefore, the code computes
-     pixel color as |GI| / (|GI| + |GO|). Since these are reciprocals, GI serves the
-     purpose of GO for the proportion calculation.
-
-     For the purposes of the minimun distance comparisons, we only check
-     the sums-of-squares against each other, since they are in the same
-     mathematical sort-order as if we did go ahead and take square roots
-
-     Loop through all gradient pixels.
-     */
-
-    for(x= gsz-1; x>=0; x--) {
-        gradientFillOffset=x<<1;
-        t=gbuf[gradientFillOffset];         // calculate column of pixel indexed by gbuf[x]
-        fsz=gbuf[gradientFillOffset+1];     // calculate row of pixel indexed by gbuf[x]
-        dmin=0xffffffff;                    // reset min distance to edge pixel
-        for(a=outerEdgeOffset+osz-1; a>=outerEdgeOffset; a--) {   // loop through all outer edge buffer pixels
-            ud=a<<1;
-            dy=t-gbuf[ud];                  // set dx to gradient pixel column - outer edge pixel row
-            dx=fsz-gbuf[ud+1];              // set dy to gradient pixel row - outer edge pixel column
-            ud=dx*dx+dy*dy;                 // compute sum of squares
-            if(ud<dmin) {                   // if our new sum of squares is less than the current minimum
-                dmin=ud;                    // set a new minimum equal to the new lower value
-            }
-        }
-        odist=(float)(dmin);                     // cast outer min to a float
-        rsf=odist*0.5f;                          //
-        rsl=*(unsigned int*)&odist;              // use some peculiar properties of the way bits are stored
-        rsl=0x5f3759df-(rsl>>1);                 // in floats vs. unsigned ints to compute an approximate
-        odist=*(float*)&rsl;                     // reciprocal square root
-        odist=odist*(rsopf-(rsf*odist*odist));   // -- ** this line can be iterated for more accuracy ** --
-        dmin=0xffffffff;                         // reset min distance to edge pixel
-        for(a= innerEdgeOffset+isz-1; a>=innerEdgeOffset; a--) {   // loop through all inside edge pixels
-            ud=a<<1;
-            dy=t-gbuf[ud];         // compute delta in Y from gradient pixel to inside edge pixel
-            dx=fsz-gbuf[ud+1];     // compute delta in X from gradient pixel to inside edge pixel
-            ud=dx*dx+dy*dy;        // compute sum of squares
-            if(ud<dmin) {          // if our new sum of squares is less than the current minimum we've found
-                dmin=ud;           // set a new minimum equal to the new lower value
-            }
-        }
-        idist=(float)(dmin);                     // cast inner min to a float
-        rsf=idist*0.5f;                          //
-        rsl=*(unsigned int*)&idist;              //
-        rsl=0x5f3759df-(rsl>>1);                 // see notes above
-        idist=*(float*)&rsl;                     //
-        idist=idist*(rsopf-(rsf*idist*idist));   //
-        /*
-         Note once again that since we are using reciprocals of distance values our
-         proportion is already the correct intensity, and does not need to be
-         subracted from 1.0 like it would have if we used real distances.
-         */
-
-        /*
-         Here we reconstruct the pixel's memory location in the CompBuf by
-         Pixel Index = Pixel Column + ( Pixel Row * Row Width )
-         */
-        res[gbuf[gradientFillOffset+1]+(gbuf[gradientFillOffset]*rw)]=(idist/(idist+odist));	//set intensity
-    }
+	int x;							// x = pixel loop counter
+	int a;							// a = temporary pixel index buffer loop counter
+	int fsz;						// size of the frame
+	unsigned int rsl;				// long used for finding fast 1.0/sqrt
+	float rsf;						// float used for finding fast 1.0/sqrt
+	const float rsopf = 1.5f;		// constant float used for finding fast 1.0/sqrt
+
+	unsigned int gradientFillOffset;
+	unsigned int t;
+	unsigned int ud;				// ud = unscaled edge distance
+	unsigned int dmin;				// dmin = minimun edge distance
+	float odist;					// odist = current outer edge distance
+	float idist;					// idist = current inner edge distance
+	int dx;							// dx = X-delta (used for distance proportion calculation)
+	int dy;							// dy = Y-delta (used for distance proportion calculation)
+	/*
+	 * The general algorithm used to color each gradient pixel is:
+	 *
+	 * 1.) Loop through all gradient pixels.
+	 *    A.) For each gradient pixel:
+	 *        a.) Loop though all outside edge pixels, looking for closest one
+	 *            to the gradient pixel we are in.
+	 *        b.) Loop through all inside edge pixels, looking for closest one
+	 *            to the gradient pixel we are in.
+	 *        c.) Find proportion of distance from gradient pixel to inside edge
+	 *            pixel compared to sum of distance to inside edge and distance to
+	 *            outside edge.
+	 *
+	 *            In an image where:
+	 *            . = blank (black) pixels, not covered by inner mask or outer mask
+	 *            + = desired gradient pixels, covered only by outer mask
+	 *            * = white full mask pixels, covered by at least inner mask
+	 *
+	 *            ...............................
+	 *            ...............+++++++++++.....
+	 *            ...+O++++++..++++++++++++++....
+	 *            ..+++\++++++++++++++++++++.....
+	 *            .+++++G+++++++++*******+++.....
+	 *            .+++++|+++++++*********+++.....
+	 *            .++***I****************+++.....
+	 *            .++*******************+++......
+	 *            .+++*****************+++.......
+	 *            ..+++***************+++........
+	 *            ....+++**********+++...........
+	 *            ......++++++++++++.............
+	 *            ...............................
+	 *
+	 *                O = outside edge pixel
+	 *                 \
+	 *                  G = gradient pixel
+	 *                  |
+	 *                  I = inside edge pixel
+	 *
+	 *                             __
+	 *                  *note that IO does not need to be a straight line, in fact
+	 *                   many cases can arise where straight lines do not work
+	 *                   correctly.
+	 *
+	 *                                        __       __     __
+	 *        d.) Pixel color is assigned as |GO| / ( |GI| + |GO| )
+	 *
+	 * The implementation does not compute distance, but the reciprocal of the
+	 * distance. This is done to avoid having to compute a square root, as a
+	 * reciprocal square root can be computed faster. Therefore, the code computes
+	 * pixel color as |GI| / (|GI| + |GO|). Since these are reciprocals, GI serves the
+	 * purpose of GO for the proportion calculation.
+	 *
+	 * For the purposes of the minimun distance comparisons, we only check
+	 * the sums-of-squares against each other, since they are in the same
+	 * mathematical sort-order as if we did go ahead and take square roots
+	 *
+	 * Loop through all gradient pixels.
+	 */
+
+	for (x= gsz-1; x>=0; x--) {
+		gradientFillOffset=x<<1;
+		t=gbuf[gradientFillOffset];		// calculate column of pixel indexed by gbuf[x]
+		fsz=gbuf[gradientFillOffset+1];	// calculate row of pixel indexed by gbuf[x]
+		dmin=0xffffffff;					// reset min distance to edge pixel
+		for (a=outerEdgeOffset+osz-1; a>=outerEdgeOffset; a--) {	// loop through all outer edge buffer pixels
+			ud=a<<1;
+			dy=t-gbuf[ud];					// set dx to gradient pixel column - outer edge pixel row
+			dx=fsz-gbuf[ud+1];				// set dy to gradient pixel row - outer edge pixel column
+			ud=dx*dx+dy*dy;					// compute sum of squares
+			if (ud<dmin) {					// if our new sum of squares is less than the current minimum
+				dmin=ud;					// set a new minimum equal to the new lower value
+			}
+		}
+		odist=(float)(dmin);					// cast outer min to a float
+		rsf=odist*0.5f;							//
+		rsl=*(unsigned int*)&odist;				// use some peculiar properties of the way bits are stored
+		rsl=0x5f3759df-(rsl>>1);				// in floats vs. unsigned ints to compute an approximate
+		odist=*(float*)&rsl;					// reciprocal square root
+		odist=odist*(rsopf-(rsf*odist*odist));	// -- ** this line can be iterated for more accuracy ** --
+		dmin=0xffffffff;						// reset min distance to edge pixel
+		for (a= innerEdgeOffset+isz-1; a>=innerEdgeOffset; a--) {	// loop through all inside edge pixels
+			ud=a<<1;
+			dy=t-gbuf[ud];			// compute delta in Y from gradient pixel to inside edge pixel
+			dx=fsz-gbuf[ud+1];		// compute delta in X from gradient pixel to inside edge pixel
+			ud=dx*dx+dy*dy;			// compute sum of squares
+			if (ud<dmin) {			// if our new sum of squares is less than the current minimum we've found
+				dmin=ud;			// set a new minimum equal to the new lower value
+			}
+		}
+		idist=(float)(dmin);					// cast inner min to a float
+		rsf=idist*0.5f;							//
+		rsl=*(unsigned int*)&idist;				//
+		rsl=0x5f3759df-(rsl>>1);				// see notes above
+		idist=*(float*)&rsl;					//
+		idist=idist*(rsopf-(rsf*idist*idist));	//
+		/*
+		 * Note once again that since we are using reciprocals of distance values our
+		 * proportion is already the correct intensity, and does not need to be
+		 * subracted from 1.0 like it would have if we used real distances.
+		 */
+
+		/*
+		 * Here we reconstruct the pixel's memory location in the CompBuf by
+		 * Pixel Index = Pixel Column + ( Pixel Row * Row Width )
+		 */
+		res[gbuf[gradientFillOffset+1]+(gbuf[gradientFillOffset]*rw)]=(idist/(idist+odist));	//set intensity
+	}
 
 }
 
@@ -1059,136 +1146,139 @@ static void do_fillGradientBuffer(unsigned int rw, float *res, unsigned short *g
 static void node_composit_exec_doubleedgemask(void *UNUSED(data), bNode *node, bNodeStack **in, bNodeStack **out)
 {
 
-    float *imask;                      // imask = pointer to inner mask pixel buffer
-    float *omask;                      // omask = pointer to outer mask pixel buffer
-    float *res;                        // res = pointer to output mask
-
-    unsigned int *lres;                // lres = unsigned int pointer to output pixel buffer (for bit operations)
-    unsigned int *limask;              // limask = unsigned int pointer to inner mask (for bit operations)
-    unsigned int *lomask;              // lomask = unsigned int pointer to outer mask (for bit operations)
-
-    int rw;                            // rw = pixel row width
-    int t;                             // t = total number of pixels in buffer - 1 (used for loop starts)
-    int fsz;                           // size of the frame
-
-    unsigned int isz=0;                // size (in pixels) of inside edge pixel index buffer
-    unsigned int osz=0;                // size (in pixels) of outside edge pixel index buffer
-    unsigned int gsz=0;                // size (in pixels) of gradient pixel index buffer
-    unsigned int rsize[3];             // size storage to pass to helper functions
-    unsigned int innerEdgeOffset=0;    // offset into final buffer where inner edge pixel indexes start
-    unsigned int outerEdgeOffset=0;    // offset into final buffer where outer edge pixel indexes start
-
-    unsigned short *gbuf;              // gradient/inner/outer pixel location index buffer
-
-    CompBuf *cbuf;                     // pointer, will be set to inner mask data
-    CompBuf *dbuf;                     // pointer, will be set to outer mask data
-    CompBuf *stackbuf;                 // pointer, will get allocated as output buffer
-
-    if(out[0]->hasoutput==0) {         // if the node's output socket is not connected to anything...
-        return;                        //     do not execute any further, just exit the node immediately
-    }
-
-    if(in[0]->data && in[1]->data) {                    // if both input sockets have some data coming in...
-        cbuf= in[0]->data;                              //     get a pointer to the inner mask data
-        dbuf= in[1]->data;                              //     get a pointer to the outer mask data
-        if(cbuf->type!=CB_VAL || dbuf->type!=CB_VAL) {  // if either input socket has an incorrect data type coming in
-            return;                                     //     exit the node immediately
-        }
-
-        t=(cbuf->x*cbuf->y)-1;                                // determine size of the frame
-
-        stackbuf= alloc_compbuf(cbuf->x, cbuf->y, CB_VAL, 1); // allocate the output buffer
-
-        imask= cbuf->rect;             // set the inner mask
-        omask= dbuf->rect;             // set the outer mask
-        res= stackbuf->rect;           // set output pointer
-        lres= (unsigned int*)res;      // unsigned int pointer to output buffer (for bit level ops)
-        limask=(unsigned int*)imask;   // unsigned int pointer to input mask (for bit level ops)
-        lomask=(unsigned int*)omask;   // unsigned int pointer to output mask (for bit level ops)
-        rw= cbuf->x;                   // width of a row of pixels
-
-
-        /*
-         The whole buffer is broken up into 4 parts. The four CORNERS, the FIRST and LAST rows, the
-         LEFT and RIGHT edges (excluding the corner pixels), and all OTHER rows.
-         This allows for quick computation of outer edge pixels where
-         a screen edge pixel is marked to be gradient.
-
-         The pixel type (gradient vs inner-edge vs outer-edge) tests change
-         depending on the user selected "Inner Edge Mode" and the user selected
-         "Buffer Edge Mode" on the node's GUI. There are 4 sets of basically the
-         same algorithm:
-
-         1.) Inner Edge -> Adjacent Only
-             Buffer Edge -> Keep Inside
-
-         2.) Inner Edge -> Adjacent Only
-             Buffer Edge -> Bleed Out
-
-         3.) Inner Edge -> All
-             Buffer Edge -> Keep Inside
-
-         4.) Inner Edge -> All
-             Buffer Edge -> Bleed Out
-
-         Each version has slightly different criteria for detecting an edge pixel.
-         */
-        if(node->custom2) {            // if "adjacent only" inner edge mode is turned on
-            if(node->custom1) {        // if "keep inside" buffer edge mode is turned on
-                do_adjacentKeepBorders(t,rw,limask,lomask,lres,res,rsize);
-            }else{                     // "bleed out" buffer edge mode is turned on
-                do_adjacentBleedBorders(t,rw,limask,lomask,lres,res,rsize);
-            }
-            isz=rsize[0];              // set up inner edge, outer edge, and gradient buffer sizes after border pass
-            osz=rsize[1];
-            gsz=rsize[2];
-            // detect edges in all non-border pixels in the buffer
-            do_adjacentEdgeDetection(t,rw,limask,lomask,lres,res,rsize,isz,osz,gsz);
-        }else{                         // "all" inner edge mode is turned on
-            if(node->custom1) {        // if "keep inside" buffer edge mode is turned on
-                do_allKeepBorders(t,rw,limask,lomask,lres,res,rsize);
-            }else{                     // "bleed out" buffer edge mode is turned on
-                do_allBleedBorders(t,rw,limask,lomask,lres,res,rsize);
-            }
-            isz=rsize[0];              // set up inner edge, outer edge, and gradient buffer sizes after border pass
-            osz=rsize[1];
-            gsz=rsize[2];
-            // detect edges in all non-border pixels in the buffer
-            do_allEdgeDetection(t,rw,limask,lomask,lres,res,rsize,isz,osz,gsz);
-        }
-
-        isz=rsize[0];                  // set edge and gradient buffer sizes once again...
-        osz=rsize[1];                  // the sizes in rsize[] may have been modified
-        gsz=rsize[2];                  // by the do_*EdgeDetection() function.
-
-        // quick check for existance of edges in the buffer...
-        // if we don't have any one of the three sizes, the other two make no difference visually,
-        // so we can just pass the inner input buffer back as output.
-        if(!gsz || !isz || !osz) {
-            out[0]->data= stackbuf;    // point the node output buffer to our filled buffer
-            return;
-        }
-
-
-        fsz=gsz+isz+osz;                                   // calculate size of pixel index buffer needed
-        gbuf= MEM_mallocN(fsz*sizeof(int), "grd buf");     // allocate edge/gradient pixel index buffer
-
-        do_createEdgeLocationBuffer(t,rw,lres,res,gbuf,&innerEdgeOffset,&outerEdgeOffset,isz,gsz);
-        do_fillGradientBuffer(rw,res,gbuf,isz,osz,gsz,innerEdgeOffset,outerEdgeOffset);
-
-        MEM_freeN(gbuf);          // free the gradient index buffer
-        out[0]->data= stackbuf;   // point the node output buffer to our filled buffer
-    }
+	float *imask;					// imask = pointer to inner mask pixel buffer
+	float *omask;					// omask = pointer to outer mask pixel buffer
+	float *res;						// res = pointer to output mask
+
+	unsigned int *lres;				// lres = unsigned int pointer to output pixel buffer (for bit operations)
+	unsigned int *limask;			// limask = unsigned int pointer to inner mask (for bit operations)
+	unsigned int *lomask;			// lomask = unsigned int pointer to outer mask (for bit operations)
+
+	int rw;							// rw = pixel row width
+	int t;							// t = total number of pixels in buffer - 1 (used for loop starts)
+	int fsz;						// size of the frame
+
+	unsigned int isz=0;				// size (in pixels) of inside edge pixel index buffer
+	unsigned int osz=0;				// size (in pixels) of outside edge pixel index buffer
+	unsigned int gsz=0;				// size (in pixels) of gradient pixel index buffer
+	unsigned int rsize[3];			// size storage to pass to helper functions
+	unsigned int innerEdgeOffset=0;	// offset into final buffer where inner edge pixel indexes start
+	unsigned int outerEdgeOffset=0;	// offset into final buffer where outer edge pixel indexes start
+
+	unsigned short *gbuf;			// gradient/inner/outer pixel location index buffer
+
+	CompBuf *cbuf;					// pointer, will be set to inner mask data
+	CompBuf *dbuf;					// pointer, will be set to outer mask data
+	CompBuf *stackbuf;				// pointer, will get allocated as output buffer
+
+	if (out[0]->hasoutput==0) {		// if the node's output socket is not connected to anything...
+		return;						//     do not execute any further, just exit the node immediately
+	}
+
+	if (in[0]->data && in[1]->data) {					// if both input sockets have some data coming in...
+		cbuf= in[0]->data;								//     get a pointer to the inner mask data
+		dbuf= in[1]->data;								//     get a pointer to the outer mask data
+		if (cbuf->type!=CB_VAL || dbuf->type!=CB_VAL) {	// if either input socket has an incorrect data type coming in
+			return;										//     exit the node immediately
+		}
+
+		t=(cbuf->x*cbuf->y)-1;									// determine size of the frame
+
+		stackbuf= alloc_compbuf(cbuf->x, cbuf->y, CB_VAL, 1);	// allocate the output buffer
+
+		imask= cbuf->rect;				// set the inner mask
+		omask= dbuf->rect;				// set the outer mask
+		res= stackbuf->rect;			// set output pointer
+		lres= (unsigned int*)res;		// unsigned int pointer to output buffer (for bit level ops)
+		limask=(unsigned int*)imask;	// unsigned int pointer to input mask (for bit level ops)
+		lomask=(unsigned int*)omask;	// unsigned int pointer to output mask (for bit level ops)
+		rw= cbuf->x;					// width of a row of pixels
+
+
+		/*
+		 * The whole buffer is broken up into 4 parts. The four CORNERS, the FIRST and LAST rows, the
+		 * LEFT and RIGHT edges (excluding the corner pixels), and all OTHER rows.
+		 * This allows for quick computation of outer edge pixels where
+		 * a screen edge pixel is marked to be gradient.
+		 *
+		 * The pixel type (gradient vs inner-edge vs outer-edge) tests change
+		 * depending on the user selected "Inner Edge Mode" and the user selected
+		 * "Buffer Edge Mode" on the node's GUI. There are 4 sets of basically the
+		 * same algorithm:
+		 *
+		 * 1.) Inner Edge -> Adjacent Only
+		 *     Buffer Edge -> Keep Inside
+		 *
+		 * 2.) Inner Edge -> Adjacent Only
+		 *     Buffer Edge -> Bleed Out
+		 *
+		 * 3.) Inner Edge -> All
+		 *     Buffer Edge -> Keep Inside
+		 *
+		 * 4.) Inner Edge -> All
+		 *     Buffer Edge -> Bleed Out
+		 *
+		 * Each version has slightly different criteria for detecting an edge pixel.
+		 */
+		if (node->custom2) {		// if "adjacent only" inner edge mode is turned on
+			if (node->custom1) {	// if "keep inside" buffer edge mode is turned on
+				do_adjacentKeepBorders(t,rw,limask,lomask,lres,res,rsize);
+			}
+			else {					// "bleed out" buffer edge mode is turned on
+				do_adjacentBleedBorders(t,rw,limask,lomask,lres,res,rsize);
+			}
+			isz=rsize[0];			// set up inner edge, outer edge, and gradient buffer sizes after border pass
+			osz=rsize[1];
+			gsz=rsize[2];
+			// detect edges in all non-border pixels in the buffer
+			do_adjacentEdgeDetection(t,rw,limask,lomask,lres,res,rsize,isz,osz,gsz);
+		}
+		else {						// "all" inner edge mode is turned on
+			if (node->custom1) {	// if "keep inside" buffer edge mode is turned on
+				do_allKeepBorders(t,rw,limask,lomask,lres,res,rsize);
+			}
+			else {					// "bleed out" buffer edge mode is turned on
+				do_allBleedBorders(t,rw,limask,lomask,lres,res,rsize);
+			}
+			isz=rsize[0];			// set up inner edge, outer edge, and gradient buffer sizes after border pass
+			osz=rsize[1];
+			gsz=rsize[2];
+			// detect edges in all non-border pixels in the buffer
+			do_allEdgeDetection(t,rw,limask,lomask,lres,res,rsize,isz,osz,gsz);
+		}
+
+		isz=rsize[0];				// set edge and gradient buffer sizes once again...
+		osz=rsize[1];				// the sizes in rsize[] may have been modified
+		gsz=rsize[2];				// by the do_*EdgeDetection() function.
+
+		// quick check for existance of edges in the buffer...
+		// if we don't have any one of the three sizes, the other two make no difference visually,
+		// so we can just pass the inner input buffer back as output.
+		if (!gsz || !isz || !osz) {
+			out[0]->data= stackbuf;	// point the node output buffer to our filled buffer
+			return;
+		}
+
+
+		fsz=gsz+isz+osz;									// calculate size of pixel index buffer needed
+		gbuf= MEM_mallocN(fsz*sizeof(int), "grd buf");		// allocate edge/gradient pixel index buffer
+
+		do_createEdgeLocationBuffer(t,rw,lres,res,gbuf,&innerEdgeOffset,&outerEdgeOffset,isz,gsz);
+		do_fillGradientBuffer(rw,res,gbuf,isz,osz,gsz,innerEdgeOffset,outerEdgeOffset);
+
+		MEM_freeN(gbuf);		// free the gradient index buffer
+		out[0]->data= stackbuf;	// point the node output buffer to our filled buffer
+	}
 }
 
 void register_node_type_cmp_doubleedgemask(bNodeTreeType *ttype)
 {
-    static bNodeType ntype;      // allocate a node type data structure
+	static bNodeType ntype;	// allocate a node type data structure
 
-    node_type_base(ttype, &ntype, CMP_NODE_DOUBLEEDGEMASK, "Double Edge Mask", NODE_CLASS_MATTE, NODE_OPTIONS);
-    node_type_socket_templates(&ntype, cmp_node_doubleedgemask_in, cmp_node_doubleedgemask_out);
-    node_type_size(&ntype, 210, 210, 210);
-    node_type_exec(&ntype, node_composit_exec_doubleedgemask);
+	node_type_base(ttype, &ntype, CMP_NODE_DOUBLEEDGEMASK, "Double Edge Mask", NODE_CLASS_MATTE, NODE_OPTIONS);
+	node_type_socket_templates(&ntype, cmp_node_doubleedgemask_in, cmp_node_doubleedgemask_out);
+	node_type_size(&ntype, 210, 210, 210);
+	node_type_exec(&ntype, node_composit_exec_doubleedgemask);
 
-    nodeRegisterType(ttype, &ntype);
+	nodeRegisterType(ttype, &ntype);
 }