Fix #34156: Spec. and Alpha Intensity OpenGL issue
[blender.git] / source / blender / render / intern / source / imagetexture.c
index 6d26495..55dadc1 100644 (file)
@@ -1,7 +1,4 @@
 /*
- *
- * $Id$
- *
  * ***** BEGIN GPL LICENSE BLOCK *****
  *
  * This program is free software; you can redistribute it and/or
@@ -30,9 +27,6 @@
  *  \ingroup render
  */
 
-
-
-
 #include <stdio.h>
 #include <string.h>
 #include <fcntl.h>
@@ -82,18 +76,18 @@ static void boxsample(ImBuf *ibuf, float minx, float miny, float maxx, float max
 
 
 /* x and y have to be checked for image size */
-static void ibuf_get_color(float *col, struct ImBuf *ibuf, int x, int y)
+static void ibuf_get_color(float col[4], struct ImBuf *ibuf, int x, int y)
 {
        int ofs = y * ibuf->x + x;
        
-       if(ibuf->rect_float) {
-               if(ibuf->channels==4) {
+       if (ibuf->rect_float) {
+               if (ibuf->channels==4) {
                        float *fp= ibuf->rect_float + 4*ofs;
-                       QUATCOPY(col, fp);
+                       copy_v4_v4(col, fp);
                }
-               else if(ibuf->channels==3) {
+               else if (ibuf->channels==3) {
                        float *fp= ibuf->rect_float + 3*ofs;
-                       VECCOPY(col, fp);
+                       copy_v3_v3(col, fp);
                        col[3]= 1.0f;
                }
                else {
@@ -108,10 +102,15 @@ static void ibuf_get_color(float *col, struct ImBuf *ibuf, int x, int y)
                col[1] = ((float)rect[1])*(1.0f/255.0f);
                col[2] = ((float)rect[2])*(1.0f/255.0f);
                col[3] = ((float)rect[3])*(1.0f/255.0f);
-       }       
+
+               /* bytes are internally straight, however render pipeline seems to expect premul */
+               col[0] *= col[3];
+               col[1] *= col[3];
+               col[2] *= col[3];
+       }
 }
 
-int imagewrap(Tex *tex, Image *ima, ImBuf *ibuf, float *texvec, TexResult *texres)
+int imagewrap(Tex *tex, Image *ima, ImBuf *ibuf, const float texvec[3], TexResult *texres, struct ImagePool *pool)
 {
        float fx, fy, val1, val2, val3;
        int x, y, retval;
@@ -123,21 +122,26 @@ int imagewrap(Tex *tex, Image *ima, ImBuf *ibuf, float *texvec, TexResult *texre
        retval= texres->nor?3:1;
        
        /* quick tests */
-       if(ibuf==NULL && ima==NULL)
+       if (ibuf==NULL && ima==NULL)
                return retval;
-       if(ima) {
+       if (ima) {
                
                /* hack for icon render */
-               if(ima->ibufs.first==NULL && (R.r.scemode & R_NO_IMAGE_LOAD))
+               if (ima->ibufs.first==NULL && (R.r.scemode & R_NO_IMAGE_LOAD))
                        return retval;
-               
-               ibuf= BKE_image_get_ibuf(ima, &tex->iuser);
+
+               ibuf = BKE_image_pool_acquire_ibuf(ima, &tex->iuser, pool);
+
+               ima->flag|= IMA_USED_FOR_RENDER;
        }
-       if(ibuf==NULL || (ibuf->rect==NULL && ibuf->rect_float==NULL))
+       if (ibuf==NULL || (ibuf->rect==NULL && ibuf->rect_float==NULL)) {
+               if (ima)
+                       BKE_image_pool_release_ibuf(ima, ibuf, pool);
                return retval;
+       }
        
        /* setup mapping */
-       if(tex->imaflag & TEX_IMAROT) {
+       if (tex->imaflag & TEX_IMAROT) {
                fy= texvec[0];
                fx= texvec[1];
        }
@@ -146,7 +150,7 @@ int imagewrap(Tex *tex, Image *ima, ImBuf *ibuf, float *texvec, TexResult *texre
                fy= texvec[1];
        }
        
-       if(tex->extend == TEX_CHECKER) {
+       if (tex->extend == TEX_CHECKER) {
                int xs, ys;
                
                xs= (int)floor(fx);
@@ -154,14 +158,25 @@ int imagewrap(Tex *tex, Image *ima, ImBuf *ibuf, float *texvec, TexResult *texre
                fx-= xs;
                fy-= ys;
 
-               if( (tex->flag & TEX_CHECKER_ODD)==0) {
-                       if((xs+ys) & 1);else return retval;
+               if ( (tex->flag & TEX_CHECKER_ODD) == 0) {
+                       if ((xs + ys) & 1) {
+                               /* pass */
+                       }
+                       else {
+                               if (ima)
+                                       BKE_image_pool_release_ibuf(ima, ibuf, pool);
+                               return retval;
+                       }
                }
-               if( (tex->flag & TEX_CHECKER_EVEN)==0) {
-                       if((xs+ys) & 1) return retval; 
+               if ( (tex->flag & TEX_CHECKER_EVEN)==0) {
+                       if ((xs+ys) & 1) {
+                               if (ima)
+                                       BKE_image_pool_release_ibuf(ima, ibuf, pool);
+                               return retval;
+                       }
                }
                /* scale around center, (0.5, 0.5) */
-               if(tex->checkerdist<1.0f) {
+               if (tex->checkerdist<1.0f) {
                        fx= (fx-0.5f)/(1.0f-tex->checkerdist) +0.5f;
                        fy= (fy-0.5f)/(1.0f-tex->checkerdist) +0.5f;
                }
@@ -170,40 +185,51 @@ int imagewrap(Tex *tex, Image *ima, ImBuf *ibuf, float *texvec, TexResult *texre
        x= xi= (int)floorf(fx*ibuf->x);
        y= yi= (int)floorf(fy*ibuf->y);
 
-       if(tex->extend == TEX_CLIPCUBE) {
-               if(x<0 || y<0 || x>=ibuf->x || y>=ibuf->y || texvec[2]<-1.0f || texvec[2]>1.0f) {
+       if (tex->extend == TEX_CLIPCUBE) {
+               if (x<0 || y<0 || x>=ibuf->x || y>=ibuf->y || texvec[2]<-1.0f || texvec[2]>1.0f) {
+                       if (ima)
+                               BKE_image_pool_release_ibuf(ima, ibuf, pool);
                        return retval;
                }
        }
-       else if( tex->extend==TEX_CLIP || tex->extend==TEX_CHECKER) {
-               if(x<0 || y<0 || x>=ibuf->x || y>=ibuf->y) {
+       else if ( tex->extend==TEX_CLIP || tex->extend==TEX_CHECKER) {
+               if (x<0 || y<0 || x>=ibuf->x || y>=ibuf->y) {
+                       if (ima)
+                               BKE_image_pool_release_ibuf(ima, ibuf, pool);
                        return retval;
                }
        }
        else {
-               if(tex->extend==TEX_EXTEND) {
-                       if(x>=ibuf->x) x = ibuf->x-1;
-                       else if(x<0) x= 0;
+               if (tex->extend==TEX_EXTEND) {
+                       if (x>=ibuf->x) x = ibuf->x-1;
+                       else if (x<0) x= 0;
                }
                else {
                        x= x % ibuf->x;
-                       if(x<0) x+= ibuf->x;
+                       if (x<0) x+= ibuf->x;
                }
-               if(tex->extend==TEX_EXTEND) {
-                       if(y>=ibuf->y) y = ibuf->y-1;
-                       else if(y<0) y= 0;
+               if (tex->extend==TEX_EXTEND) {
+                       if (y>=ibuf->y) y = ibuf->y-1;
+                       else if (y<0) y= 0;
                }
                else {
                        y= y % ibuf->y;
-                       if(y<0) y+= ibuf->y;
+                       if (y<0) y+= ibuf->y;
                }
        }
        
        /* warning, no return before setting back! */
-       if( (R.flag & R_SEC_FIELD) && (ibuf->flags & IB_fields) ) {
+       if ( (R.flag & R_SEC_FIELD) && (ibuf->flags & IB_fields) ) {
                ibuf->rect+= (ibuf->x*ibuf->y);
        }
 
+       /* keep this before interpolation [#29761] */
+       if (tex->ima && (tex->ima->flag & IMA_IGNORE_ALPHA) == 0) {
+               if ((tex->imaflag & TEX_CALCALPHA) == 0) {
+                       texres->talpha = TRUE;
+               }
+       }
+
        /* interpolate */
        if (tex->imaflag & TEX_INTERPOL) {
                float filterx, filtery;
@@ -222,24 +248,19 @@ int imagewrap(Tex *tex, Image *ima, ImBuf *ibuf, float *texvec, TexResult *texre
                ibuf_get_color(&texres->tr, ibuf, x, y);
        }
        
-       if( (R.flag & R_SEC_FIELD) && (ibuf->flags & IB_fields) ) {
+       if ( (R.flag & R_SEC_FIELD) && (ibuf->flags & IB_fields) ) {
                ibuf->rect-= (ibuf->x*ibuf->y);
        }
 
-       if(tex->imaflag & TEX_USEALPHA) {
-               if(tex->imaflag & TEX_CALCALPHA);
-               else texres->talpha= 1;
-       }
-       
-       if(texres->nor) {
-               if(tex->imaflag & TEX_NORMALMAP) {
-                       // qdn: normal from color
-                       // The invert of the red channel is to make
-                       // the normal map compliant with the outside world.
-                       // It needs to be done because in Blender
-                       // the normal used in the renderer points inward. It is generated
-                       // this way in calc_vertexnormals(). Should this ever change
-                       // this negate must be removed.
+       if (texres->nor) {
+               if (tex->imaflag & TEX_NORMALMAP) {
+                       /* qdn: normal from color
+                        * The invert of the red channel is to make
+                        * the normal map compliant with the outside world.
+                        * It needs to be done because in Blender
+                        * the normal used in the renderer points inward. It is generated
+                        * this way in calc_vertexnormals(). Should this ever change
+                        * this negate must be removed. */
                        texres->nor[0] = -2.f*(texres->tr - 0.5f);
                        texres->nor[1] = 2.f*(texres->tg - 0.5f);
                        texres->nor[2] = 2.f*(texres->tb - 0.5f);
@@ -248,14 +269,14 @@ int imagewrap(Tex *tex, Image *ima, ImBuf *ibuf, float *texvec, TexResult *texre
                        /* bump: take three samples */
                        val1= texres->tr+texres->tg+texres->tb;
 
-                       if(x<ibuf->x-1) {
+                       if (x<ibuf->x-1) {
                                float col[4];
                                ibuf_get_color(col, ibuf, x+1, y);
                                val2= (col[0]+col[1]+col[2]);
                        }
                        else val2= val1;
 
-                       if(y<ibuf->y-1) {
+                       if (y<ibuf->y-1) {
                                float col[4];
                                ibuf_get_color(col, ibuf, x, y+1);
                                val3= (col[0]+col[1]+col[2]);
@@ -268,22 +289,25 @@ int imagewrap(Tex *tex, Image *ima, ImBuf *ibuf, float *texvec, TexResult *texre
                }
        }
 
-       if(texres->talpha) texres->tin= texres->ta;
-       else if(tex->imaflag & TEX_CALCALPHA) {
-               texres->ta= texres->tin= MAX3(texres->tr, texres->tg, texres->tb);
+       if (texres->talpha) texres->tin= texres->ta;
+       else if (tex->imaflag & TEX_CALCALPHA) {
+               texres->ta = texres->tin = max_fff(texres->tr, texres->tg, texres->tb);
        }
        else texres->ta= texres->tin= 1.0;
        
-       if(tex->flag & TEX_NEGALPHA) texres->ta= 1.0f-texres->ta;
+       if (tex->flag & TEX_NEGALPHA) texres->ta= 1.0f-texres->ta;
 
        /* de-premul, this is being premulled in shade_input_do_shade() */
-       if(texres->ta!=1.0f && texres->ta>1e-4f) {
+       if (texres->ta!=1.0f && texres->ta>1e-4f) {
                fx= 1.0f/texres->ta;
                texres->tr*= fx;
                texres->tg*= fx;
                texres->tb*= fx;
        }
-       
+
+       if (ima)
+               BKE_image_pool_release_ibuf(ima, ibuf, pool);
+
        BRICONTRGB;
        
        return retval;
@@ -296,45 +320,45 @@ static void clipx_rctf_swap(rctf *stack, short *count, float x1, float x2)
 
        a= *count;
        rf= stack;
-       for(;a>0;a--) {
-               if(rf->xmin<x1) {
-                       if(rf->xmax<x1) {
+       for (;a>0;a--) {
+               if (rf->xmin<x1) {
+                       if (rf->xmax<x1) {
                                rf->xmin+= (x2-x1);
                                rf->xmax+= (x2-x1);
                        }
                        else {
-                               if(rf->xmax>x2) rf->xmax= x2;
+                               if (rf->xmax>x2) rf->xmax = x2;
                                newrct= stack+ *count;
                                (*count)++;
 
-                               newrct->xmax= x2;
-                               newrct->xmin= rf->xmin+(x2-x1);
-                               newrct->ymin= rf->ymin;
-                               newrct->ymax= rf->ymax;
+                               newrct->xmax = x2;
+                               newrct->xmin = rf->xmin+(x2-x1);
+                               newrct->ymin = rf->ymin;
+                               newrct->ymax = rf->ymax;
                                
-                               if(newrct->xmin==newrct->xmax) (*count)--;
+                               if (newrct->xmin ==newrct->xmax) (*count)--;
                                
-                               rf->xmin= x1;
+                               rf->xmin = x1;
                        }
                }
-               else if(rf->xmax>x2) {
-                       if(rf->xmin>x2) {
+               else if (rf->xmax>x2) {
+                       if (rf->xmin>x2) {
                                rf->xmin-= (x2-x1);
                                rf->xmax-= (x2-x1);
                        }
                        else {
-                               if(rf->xmin<x1) rf->xmin= x1;
+                               if (rf->xmin<x1) rf->xmin = x1;
                                newrct= stack+ *count;
                                (*count)++;
 
-                               newrct->xmin= x1;
-                               newrct->xmax= rf->xmax-(x2-x1);
-                               newrct->ymin= rf->ymin;
-                               newrct->ymax= rf->ymax;
+                               newrct->xmin = x1;
+                               newrct->xmax = rf->xmax-(x2-x1);
+                               newrct->ymin = rf->ymin;
+                               newrct->ymax = rf->ymax;
 
-                               if(newrct->xmin==newrct->xmax) (*count)--;
+                               if (newrct->xmin ==newrct->xmax) (*count)--;
 
-                               rf->xmax= x2;
+                               rf->xmax = x2;
                        }
                }
                rf++;
@@ -349,45 +373,45 @@ static void clipy_rctf_swap(rctf *stack, short *count, float y1, float y2)
 
        a= *count;
        rf= stack;
-       for(;a>0;a--) {
-               if(rf->ymin<y1) {
-                       if(rf->ymax<y1) {
+       for (;a>0;a--) {
+               if (rf->ymin<y1) {
+                       if (rf->ymax<y1) {
                                rf->ymin+= (y2-y1);
                                rf->ymax+= (y2-y1);
                        }
                        else {
-                               if(rf->ymax>y2) rf->ymax= y2;
+                               if (rf->ymax>y2) rf->ymax = y2;
                                newrct= stack+ *count;
                                (*count)++;
 
-                               newrct->ymax= y2;
-                               newrct->ymin= rf->ymin+(y2-y1);
-                               newrct->xmin= rf->xmin;
-                               newrct->xmax= rf->xmax;
+                               newrct->ymax = y2;
+                               newrct->ymin = rf->ymin+(y2-y1);
+                               newrct->xmin = rf->xmin;
+                               newrct->xmax = rf->xmax;
 
-                               if(newrct->ymin==newrct->ymax) (*count)--;
+                               if (newrct->ymin==newrct->ymax) (*count)--;
 
-                               rf->ymin= y1;
+                               rf->ymin = y1;
                        }
                }
-               else if(rf->ymax>y2) {
-                       if(rf->ymin>y2) {
+               else if (rf->ymax>y2) {
+                       if (rf->ymin>y2) {
                                rf->ymin-= (y2-y1);
                                rf->ymax-= (y2-y1);
                        }
                        else {
-                               if(rf->ymin<y1) rf->ymin= y1;
+                               if (rf->ymin<y1) rf->ymin = y1;
                                newrct= stack+ *count;
                                (*count)++;
 
-                               newrct->ymin= y1;
-                               newrct->ymax= rf->ymax-(y2-y1);
-                               newrct->xmin= rf->xmin;
-                               newrct->xmax= rf->xmax;
+                               newrct->ymin = y1;
+                               newrct->ymax = rf->ymax-(y2-y1);
+                               newrct->xmin = rf->xmin;
+                               newrct->xmax = rf->xmax;
 
-                               if(newrct->ymin==newrct->ymax) (*count)--;
+                               if (newrct->ymin==newrct->ymax) (*count)--;
 
-                               rf->ymax= y2;
+                               rf->ymax = y2;
                        }
                }
                rf++;
@@ -398,29 +422,29 @@ static float square_rctf(rctf *rf)
 {
        float x, y;
 
-       x= rf->xmax- rf->xmin;
-       y= rf->ymax- rf->ymin;
-       return (x*y);
+       x = BLI_rctf_size_x(rf);
+       y = BLI_rctf_size_y(rf);
+       return x * y;
 }
 
 static float clipx_rctf(rctf *rf, float x1, float x2)
 {
        float size;
 
-       size= rf->xmax - rf->xmin;
+       size = BLI_rctf_size_x(rf);
 
-       if(rf->xmin<x1) {
-               rf->xmin= x1;
+       if (rf->xmin<x1) {
+               rf->xmin = x1;
        }
-       if(rf->xmax>x2) {
-               rf->xmax= x2;
+       if (rf->xmax>x2) {
+               rf->xmax = x2;
        }
-       if(rf->xmin > rf->xmax) {
+       if (rf->xmin > rf->xmax) {
                rf->xmin = rf->xmax;
                return 0.0;
        }
-       else if(size!=0.0f) {
-               return (rf->xmax - rf->xmin)/size;
+       else if (size != 0.0f) {
+               return BLI_rctf_size_x(rf) / size;
        }
        return 1.0;
 }
@@ -429,21 +453,21 @@ static float clipy_rctf(rctf *rf, float y1, float y2)
 {
        float size;
 
-       size= rf->ymax - rf->ymin;
+       size = BLI_rctf_size_y(rf);
 
-       if(rf->ymin<y1) {
-               rf->ymin= y1;
+       if (rf->ymin<y1) {
+               rf->ymin = y1;
        }
-       if(rf->ymax>y2) {
-               rf->ymax= y2;
+       if (rf->ymax>y2) {
+               rf->ymax = y2;
        }
 
-       if(rf->ymin > rf->ymax) {
+       if (rf->ymin > rf->ymax) {
                rf->ymin = rf->ymax;
                return 0.0;
        }
-       else if(size!=0.0f) {
-               return (rf->ymax - rf->ymin)/size;
+       else if (size != 0.0f) {
+               return BLI_rctf_size_y(rf) / size;
        }
        return 1.0;
 
@@ -452,7 +476,7 @@ static float clipy_rctf(rctf *rf, float y1, float y2)
 static void boxsampleclip(struct ImBuf *ibuf, rctf *rf, TexResult *texres)
 {
        /* sample box, is clipped already, and minx etc. have been set at ibuf size.
-          Enlarge with antialiased edges of the pixels */
+        * Enlarge with antialiased edges of the pixels */
 
        float muly, mulx, div, col[4];
        int x, y, startx, endx, starty, endy;
@@ -462,27 +486,29 @@ static void boxsampleclip(struct ImBuf *ibuf, rctf *rf, TexResult *texres)
        starty= (int)floor(rf->ymin);
        endy= (int)floor(rf->ymax);
 
-       if(startx < 0) startx= 0;
-       if(starty < 0) starty= 0;
-       if(endx>=ibuf->x) endx= ibuf->x-1;
-       if(endy>=ibuf->y) endy= ibuf->y-1;
+       if (startx < 0) startx= 0;
+       if (starty < 0) starty= 0;
+       if (endx>=ibuf->x) endx= ibuf->x-1;
+       if (endy>=ibuf->y) endy= ibuf->y-1;
 
-       if(starty==endy && startx==endx) {
+       if (starty==endy && startx==endx) {
                ibuf_get_color(&texres->tr, ibuf, startx, starty);
        }
        else {
                div= texres->tr= texres->tg= texres->tb= texres->ta= 0.0;
-               for(y=starty; y<=endy; y++) {
+               for (y=starty; y<=endy; y++) {
                        
                        muly= 1.0;
 
-                       if(starty==endy);
+                       if (starty==endy) {
+                               /* pass */
+                       }
                        else {
-                               if(y==starty) muly= 1.0f-(rf->ymin - y);
-                               if(y==endy) muly= (rf->ymax - y);
+                               if (y==starty) muly= 1.0f-(rf->ymin - y);
+                               if (y==endy) muly= (rf->ymax - y);
                        }
                        
-                       if(startx==endx) {
+                       if (startx==endx) {
                                mulx= muly;
                                
                                ibuf_get_color(col, ibuf, startx, y);
@@ -494,14 +520,14 @@ static void boxsampleclip(struct ImBuf *ibuf, rctf *rf, TexResult *texres)
                                div+= mulx;
                        }
                        else {
-                               for(x=startx; x<=endx; x++) {
+                               for (x=startx; x<=endx; x++) {
                                        mulx= muly;
-                                       if(x==startx) mulx*= 1.0f-(rf->xmin - x);
-                                       if(x==endx) mulx*= (rf->xmax - x);
+                                       if (x==startx) mulx*= 1.0f-(rf->xmin - x);
+                                       if (x==endx) mulx*= (rf->xmax - x);
 
                                        ibuf_get_color(col, ibuf, x, y);
                                        
-                                       if(mulx==1.0f) {
+                                       if (mulx==1.0f) {
                                                texres->ta+= col[3];
                                                texres->tr+= col[0];
                                                texres->tg+= col[1];
@@ -519,7 +545,7 @@ static void boxsampleclip(struct ImBuf *ibuf, rctf *rf, TexResult *texres)
                        }
                }
 
-               if(div!=0.0f) {
+               if (div!=0.0f) {
                        div= 1.0f/div;
                        texres->tb*= div;
                        texres->tg*= div;
@@ -539,9 +565,9 @@ static void boxsample(ImBuf *ibuf, float minx, float miny, float maxx, float max
         * If variable 'imaprepeat' has been set, the
         * clipped-away parts are sampled as well.
         */
-       /* note: actually minx etc isnt in the proper range... this due to filter size and offset vectors for bump */
+       /* note: actually minx etc isn't in the proper range... this due to filter size and offset vectors for bump */
        /* note: talpha must be initialized */
-       /* note: even when 'imaprepeat' is set, this can only repeate once in any direction.
+       /* note: even when 'imaprepeat' is set, this can only repeat once in any direction.
         * the point which min/max is derived from is assumed to be wrapped */
        TexResult texr;
        rctf *rf, stack[8];
@@ -549,46 +575,46 @@ static void boxsample(ImBuf *ibuf, float minx, float miny, float maxx, float max
        short count=1;
 
        rf= stack;
-       rf->xmin= minx*(ibuf->x);
-       rf->xmax= maxx*(ibuf->x);
-       rf->ymin= miny*(ibuf->y);
-       rf->ymax= maxy*(ibuf->y);
+       rf->xmin = minx*(ibuf->x);
+       rf->xmax = maxx*(ibuf->x);
+       rf->ymin = miny*(ibuf->y);
+       rf->ymax = maxy*(ibuf->y);
 
        texr.talpha= texres->talpha;    /* is read by boxsample_clip */
        
-       if(imapextend) {
+       if (imapextend) {
                CLAMP(rf->xmin, 0.0f, ibuf->x-1);
                CLAMP(rf->xmax, 0.0f, ibuf->x-1);
        }
-       else if(imaprepeat) 
+       else if (imaprepeat)
                clipx_rctf_swap(stack, &count, 0.0, (float)(ibuf->x));
        else {
                alphaclip= clipx_rctf(rf, 0.0, (float)(ibuf->x));
 
-               if(alphaclip<=0.0f) {
+               if (alphaclip<=0.0f) {
                        texres->tr= texres->tb= texres->tg= texres->ta= 0.0;
                        return;
                }
        }
 
-       if(imapextend) {
+       if (imapextend) {
                CLAMP(rf->ymin, 0.0f, ibuf->y-1);
                CLAMP(rf->ymax, 0.0f, ibuf->y-1);
        }
-       else if(imaprepeat) 
+       else if (imaprepeat)
                clipy_rctf_swap(stack, &count, 0.0, (float)(ibuf->y));
        else {
                alphaclip*= clipy_rctf(rf, 0.0, (float)(ibuf->y));
 
-               if(alphaclip<=0.0f) {
+               if (alphaclip<=0.0f) {
                        texres->tr= texres->tb= texres->tg= texres->ta= 0.0;
                        return;
                }
        }
 
-       if(count>1) {
+       if (count>1) {
                tot= texres->tr= texres->tb= texres->tg= texres->ta= 0.0;
-               while(count--) {
+               while (count--) {
                        boxsampleclip(ibuf, rf, &texr);
                        
                        opp= square_rctf(rf);
@@ -597,22 +623,22 @@ static void boxsample(ImBuf *ibuf, float minx, float miny, float maxx, float max
                        texres->tr+= opp*texr.tr;
                        texres->tg+= opp*texr.tg;
                        texres->tb+= opp*texr.tb;
-                       if(texres->talpha) texres->ta+= opp*texr.ta;
+                       if (texres->talpha) texres->ta+= opp*texr.ta;
                        rf++;
                }
-               if(tot!= 0.0f) {
+               if (tot!= 0.0f) {
                        texres->tr/= tot;
                        texres->tg/= tot;
                        texres->tb/= tot;
-                       if(texres->talpha) texres->ta/= tot;
+                       if (texres->talpha) texres->ta/= tot;
                }
        }
        else
                boxsampleclip(ibuf, rf, texres);
 
-       if(texres->talpha==0) texres->ta= 1.0;
+       if (texres->talpha==0) texres->ta= 1.0;
        
-       if(alphaclip!=1.0f) {
+       if (alphaclip!=1.0f) {
                /* premul it all */
                texres->tr*= alphaclip;
                texres->tg*= alphaclip;
@@ -621,36 +647,36 @@ static void boxsample(ImBuf *ibuf, float minx, float miny, float maxx, float max
        }
 }      
 
-//-----------------------------------------------------------------------------------------------------------------
-// from here, some functions only used for the new filtering
+/*-----------------------------------------------------------------------------------------------------------------
+ * from here, some functions only used for the new filtering */
 
-// anisotropic filters, data struct used instead of long line of (possibly unused) func args
+/* anisotropic filters, data struct used instead of long line of (possibly unused) func args */
 typedef struct afdata_t {
        float dxt[2], dyt[2];
        int intpol, extflag;
-       // feline only
+       /* feline only */
        float majrad, minrad, theta;
        int iProbes;
        float dusc, dvsc;
 } afdata_t;
 
-// this only used here to make it easier to pass extend flags as single int
-enum {TXC_XMIR=1, TXC_YMIR, TXC_REPT, TXC_EXTD};
+/* this only used here to make it easier to pass extend flags as single int */
+enum {TXC_XMIR = 1, TXC_YMIR, TXC_REPT, TXC_EXTD};
 
-// similar to ibuf_get_color() but clips/wraps coords according to repeat/extend flags
-// returns true if out of range in clipmode
-static int ibuf_get_color_clip(float *col, ImBuf *ibuf, int x, int y, int extflag)
+/* similar to ibuf_get_color() but clips/wraps coords according to repeat/extend flags
+ * returns true if out of range in clipmode */
+static int ibuf_get_color_clip(float col[4], ImBuf *ibuf, int x, int y, int extflag)
 {
        int clip = 0;
        switch (extflag) {
-               case TXC_XMIR:  // y rep
+               case TXC_XMIR:  /* y rep */
                        x %= 2*ibuf->x;
                        x += x < 0 ? 2*ibuf->x : 0;
                        x = x >= ibuf->x ? 2*ibuf->x - x - 1 : x;
                        y %= ibuf->y;
                        y += y < 0 ? ibuf->y : 0;
                        break;
-               case TXC_YMIR:  // x rep
+               case TXC_YMIR:  /* x rep */
                        x %= ibuf->x;
                        x += x < 0 ? ibuf->x : 0;
                        y %= 2*ibuf->y;
@@ -667,11 +693,12 @@ static int ibuf_get_color_clip(float *col, ImBuf *ibuf, int x, int y, int extfla
                        y %= ibuf->y;
                        y += (y < 0) ? ibuf->y : 0;
                        break;
-               default:        {       // as extend, if clipped, set alpha to 0.0
-                       if (x < 0) { x = 0;  } // TXF alpha: clip = 1; }
-                       if (x >= ibuf->x) { x = ibuf->x - 1; } // TXF alpha:  clip = 1; }
-                       if (y < 0) { y = 0; } // TXF alpha:  clip = 1; }
-                       if (y >= ibuf->y) { y = ibuf->y - 1; } // TXF alpha:  clip = 1; }
+               default:
+               {       /* as extend, if clipped, set alpha to 0.0 */
+                       if (x < 0) { x = 0;  } /* TXF alpha: clip = 1; } */
+                       if (x >= ibuf->x) { x = ibuf->x - 1; } /* TXF alpha:  clip = 1; } */
+                       if (y < 0) { y = 0; } /* TXF alpha:  clip = 1; } */
+                       if (y >= ibuf->y) { y = ibuf->y - 1; } /* TXF alpha:  clip = 1; } */
                }
        }
 
@@ -687,17 +714,18 @@ static int ibuf_get_color_clip(float *col, ImBuf *ibuf, int x, int y, int extfla
                }
        }
        else {
-               char* rect = (char*)(ibuf->rect + x + y*ibuf->x);
-               col[0] = rect[0]*(1.f/255.f);
-               col[1] = rect[1]*(1.f/255.f);
-               col[2] = rect[2]*(1.f/255.f);
+               char *rect = (char *)(ibuf->rect + x + y*ibuf->x);
+               float inv_alpha_fac = (1.0f / 255.0f) * rect[3] * (1.0f / 255.0f);
+               col[0] = rect[0] * inv_alpha_fac;
+               col[1] = rect[1] * inv_alpha_fac;
+               col[2] = rect[2] * inv_alpha_fac;
                col[3] = clip ? 0.f : rect[3]*(1.f/255.f);
        }
        return clip;
 }
 
-// as above + bilerp
-static int ibuf_get_color_clip_bilerp(float *col, ImBuf *ibuf, float u, float v, int intpol, int extflag)
+/* as above + bilerp */
+static int ibuf_get_color_clip_bilerp(float col[4], ImBuf *ibuf, float u, float v, int intpol, int extflag)
 {
        if (intpol) {
                float c00[4], c01[4], c10[4], c11[4];
@@ -718,7 +746,7 @@ static int ibuf_get_color_clip_bilerp(float *col, ImBuf *ibuf, float u, float v,
        return ibuf_get_color_clip(col, ibuf, (int)u, (int)v, extflag);
 }
 
-static void area_sample(TexResult* texr, ImBuf* ibuf, float fx, float fy, afdata_t* AFD)
+static void area_sample(TexResult *texr, ImBuf *ibuf, float fx, float fy, afdata_t *AFD)
 {
        int xs, ys, clip = 0;
        float tc[4], xsd, ysd, cw = 0.f;
@@ -751,51 +779,51 @@ static void area_sample(TexResult* texr, ImBuf* ibuf, float fx, float fy, afdata
        texr->tr *= xsd;
        texr->tg *= xsd;
        texr->tb *= xsd;
-       // clipping can be ignored if alpha used, texr->ta already includes filtered edge
+       /* clipping can be ignored if alpha used, texr->ta already includes filtered edge */
        texr->ta = texr->talpha ? texr->ta*xsd : (clip ? cw*xsd : 1.f);
 }
 
-// table of (exp(ar) - exp(a)) / (1 - exp(a)) for r in range [0, 1] and a = -2
-// used instead of actual gaussian, otherwise at high texture magnifications circular artifacts are visible
+/* table of (exp(ar) - exp(a)) / (1 - exp(a)) for r in range [0, 1] and a = -2
+ * used instead of actual gaussian, otherwise at high texture magnifications circular artifacts are visible */
 #define EWA_MAXIDX 255
-static float EWA_WTS[EWA_MAXIDX + 1] =
-{ 1.f, 0.990965f, 0.982f, 0.973105f, 0.96428f, 0.955524f, 0.946836f, 0.938216f, 0.929664f,
- 0.921178f, 0.912759f, 0.904405f, 0.896117f, 0.887893f, 0.879734f, 0.871638f, 0.863605f,
- 0.855636f, 0.847728f, 0.839883f, 0.832098f, 0.824375f, 0.816712f, 0.809108f, 0.801564f,
- 0.794079f, 0.786653f, 0.779284f, 0.771974f, 0.76472f, 0.757523f, 0.750382f, 0.743297f,
- 0.736267f, 0.729292f, 0.722372f, 0.715505f, 0.708693f, 0.701933f, 0.695227f, 0.688572f,
- 0.68197f, 0.67542f, 0.66892f, 0.662471f, 0.656073f, 0.649725f, 0.643426f, 0.637176f,
- 0.630976f, 0.624824f, 0.618719f, 0.612663f, 0.606654f, 0.600691f, 0.594776f, 0.588906f,
- 0.583083f, 0.577305f, 0.571572f, 0.565883f, 0.56024f, 0.55464f, 0.549084f, 0.543572f,
- 0.538102f, 0.532676f, 0.527291f, 0.521949f, 0.516649f, 0.511389f, 0.506171f, 0.500994f,
- 0.495857f, 0.490761f, 0.485704f, 0.480687f, 0.475709f, 0.470769f, 0.465869f, 0.461006f,
- 0.456182f, 0.451395f, 0.446646f, 0.441934f, 0.437258f, 0.432619f, 0.428017f, 0.42345f,
- 0.418919f, 0.414424f, 0.409963f, 0.405538f, 0.401147f, 0.39679f, 0.392467f, 0.388178f,
- 0.383923f, 0.379701f, 0.375511f, 0.371355f, 0.367231f, 0.363139f, 0.359079f, 0.355051f,
- 0.351055f, 0.347089f, 0.343155f, 0.339251f, 0.335378f, 0.331535f, 0.327722f, 0.323939f,
- 0.320186f, 0.316461f, 0.312766f, 0.3091f, 0.305462f, 0.301853f, 0.298272f, 0.294719f,
- 0.291194f, 0.287696f, 0.284226f, 0.280782f, 0.277366f, 0.273976f, 0.270613f, 0.267276f,
- 0.263965f, 0.26068f, 0.257421f, 0.254187f, 0.250979f, 0.247795f, 0.244636f, 0.241502f,
- 0.238393f, 0.235308f, 0.232246f, 0.229209f, 0.226196f, 0.223206f, 0.220239f, 0.217296f,
- 0.214375f, 0.211478f, 0.208603f, 0.20575f, 0.20292f, 0.200112f, 0.197326f, 0.194562f,
- 0.191819f, 0.189097f, 0.186397f, 0.183718f, 0.18106f, 0.178423f, 0.175806f, 0.17321f,
- 0.170634f, 0.168078f, 0.165542f, 0.163026f, 0.16053f, 0.158053f, 0.155595f, 0.153157f,
- 0.150738f, 0.148337f, 0.145955f, 0.143592f, 0.141248f, 0.138921f, 0.136613f, 0.134323f,
- 0.132051f, 0.129797f, 0.12756f, 0.125341f, 0.123139f, 0.120954f, 0.118786f, 0.116635f,
- 0.114501f, 0.112384f, 0.110283f, 0.108199f, 0.106131f, 0.104079f, 0.102043f, 0.100023f,
- 0.0980186f, 0.09603f, 0.094057f, 0.0920994f, 0.0901571f, 0.08823f, 0.0863179f, 0.0844208f,
- 0.0825384f, 0.0806708f, 0.0788178f, 0.0769792f, 0.0751551f, 0.0733451f, 0.0715493f, 0.0697676f,
- 0.0679997f, 0.0662457f, 0.0645054f, 0.0627786f, 0.0610654f, 0.0593655f, 0.0576789f, 0.0560055f,
- 0.0543452f, 0.0526979f, 0.0510634f, 0.0494416f, 0.0478326f, 0.0462361f, 0.0446521f, 0.0430805f,
- 0.0415211f, 0.039974f, 0.0384389f, 0.0369158f, 0.0354046f, 0.0339052f, 0.0324175f, 0.0309415f,
- 0.029477f, 0.0280239f, 0.0265822f, 0.0251517f, 0.0237324f, 0.0223242f, 0.020927f, 0.0195408f,
- 0.0181653f, 0.0168006f, 0.0154466f, 0.0141031f, 0.0127701f, 0.0114476f, 0.0101354f, 0.00883339f,
- 0.00754159f, 0.00625989f, 0.00498819f, 0.00372644f, 0.00247454f, 0.00123242f, 0.f
+static float EWA_WTS[EWA_MAXIDX + 1] = {
+       1.f, 0.990965f, 0.982f, 0.973105f, 0.96428f, 0.955524f, 0.946836f, 0.938216f, 0.929664f,
      0.921178f, 0.912759f, 0.904405f, 0.896117f, 0.887893f, 0.879734f, 0.871638f, 0.863605f,
      0.855636f, 0.847728f, 0.839883f, 0.832098f, 0.824375f, 0.816712f, 0.809108f, 0.801564f,
      0.794079f, 0.786653f, 0.779284f, 0.771974f, 0.76472f, 0.757523f, 0.750382f, 0.743297f,
      0.736267f, 0.729292f, 0.722372f, 0.715505f, 0.708693f, 0.701933f, 0.695227f, 0.688572f,
      0.68197f, 0.67542f, 0.66892f, 0.662471f, 0.656073f, 0.649725f, 0.643426f, 0.637176f,
      0.630976f, 0.624824f, 0.618719f, 0.612663f, 0.606654f, 0.600691f, 0.594776f, 0.588906f,
      0.583083f, 0.577305f, 0.571572f, 0.565883f, 0.56024f, 0.55464f, 0.549084f, 0.543572f,
      0.538102f, 0.532676f, 0.527291f, 0.521949f, 0.516649f, 0.511389f, 0.506171f, 0.500994f,
      0.495857f, 0.490761f, 0.485704f, 0.480687f, 0.475709f, 0.470769f, 0.465869f, 0.461006f,
      0.456182f, 0.451395f, 0.446646f, 0.441934f, 0.437258f, 0.432619f, 0.428017f, 0.42345f,
      0.418919f, 0.414424f, 0.409963f, 0.405538f, 0.401147f, 0.39679f, 0.392467f, 0.388178f,
      0.383923f, 0.379701f, 0.375511f, 0.371355f, 0.367231f, 0.363139f, 0.359079f, 0.355051f,
      0.351055f, 0.347089f, 0.343155f, 0.339251f, 0.335378f, 0.331535f, 0.327722f, 0.323939f,
      0.320186f, 0.316461f, 0.312766f, 0.3091f, 0.305462f, 0.301853f, 0.298272f, 0.294719f,
      0.291194f, 0.287696f, 0.284226f, 0.280782f, 0.277366f, 0.273976f, 0.270613f, 0.267276f,
      0.263965f, 0.26068f, 0.257421f, 0.254187f, 0.250979f, 0.247795f, 0.244636f, 0.241502f,
      0.238393f, 0.235308f, 0.232246f, 0.229209f, 0.226196f, 0.223206f, 0.220239f, 0.217296f,
      0.214375f, 0.211478f, 0.208603f, 0.20575f, 0.20292f, 0.200112f, 0.197326f, 0.194562f,
      0.191819f, 0.189097f, 0.186397f, 0.183718f, 0.18106f, 0.178423f, 0.175806f, 0.17321f,
      0.170634f, 0.168078f, 0.165542f, 0.163026f, 0.16053f, 0.158053f, 0.155595f, 0.153157f,
      0.150738f, 0.148337f, 0.145955f, 0.143592f, 0.141248f, 0.138921f, 0.136613f, 0.134323f,
      0.132051f, 0.129797f, 0.12756f, 0.125341f, 0.123139f, 0.120954f, 0.118786f, 0.116635f,
      0.114501f, 0.112384f, 0.110283f, 0.108199f, 0.106131f, 0.104079f, 0.102043f, 0.100023f,
      0.0980186f, 0.09603f, 0.094057f, 0.0920994f, 0.0901571f, 0.08823f, 0.0863179f, 0.0844208f,
      0.0825384f, 0.0806708f, 0.0788178f, 0.0769792f, 0.0751551f, 0.0733451f, 0.0715493f, 0.0697676f,
      0.0679997f, 0.0662457f, 0.0645054f, 0.0627786f, 0.0610654f, 0.0593655f, 0.0576789f, 0.0560055f,
      0.0543452f, 0.0526979f, 0.0510634f, 0.0494416f, 0.0478326f, 0.0462361f, 0.0446521f, 0.0430805f,
      0.0415211f, 0.039974f, 0.0384389f, 0.0369158f, 0.0354046f, 0.0339052f, 0.0324175f, 0.0309415f,
      0.029477f, 0.0280239f, 0.0265822f, 0.0251517f, 0.0237324f, 0.0223242f, 0.020927f, 0.0195408f,
      0.0181653f, 0.0168006f, 0.0154466f, 0.0141031f, 0.0127701f, 0.0114476f, 0.0101354f, 0.00883339f,
      0.00754159f, 0.00625989f, 0.00498819f, 0.00372644f, 0.00247454f, 0.00123242f, 0.f
 };
 
-// test if a float value is 'nan'
-// there is a C99 function for this: isnan(), but blender seems to use C90 (according to gcc warns),
-// and may not be supported by other compilers either
+/* test if a float value is 'nan'
+ * there is a C99 function for this: isnan(), but blender seems to use C90 (according to gcc warns),
+ * and may not be supported by other compilers either */
 #ifndef ISNAN
 #define ISNAN(x) ((x) != (x))
 #endif
@@ -804,7 +832,7 @@ static float EWA_WTS[EWA_MAXIDX + 1] =
 static void radangle2imp(float a2, float b2, float th, float* A, float* B, float* C, float* F)
 {
        float ct2 = cosf(th);
-       const float st2 = 1.f - ct2*ct2;        // <- sin(th)^2
+       const float st2 = 1.0f - ct2 * ct2;     /* <- sin(th)^2 */
        ct2 *= ct2;
        *A = a2*st2 + b2*ct2;
        *B = (b2 - a2)*sinf(2.f*th);
@@ -812,10 +840,10 @@ static void radangle2imp(float a2, float b2, float th, float* A, float* B, float
        *F = a2*b2;
 }
 
-// all tests here are done to make sure possible overflows are hopefully minimized
+/* all tests here are done to make sure possible overflows are hopefully minimized */
 static void imp2radangle(float A, float B, float C, float F, float* a, float* b, float* th, float* ecc)
 {
-       if (F <= 1e-5f) {       // use arbitrary major radius, zero minor, infinite eccentricity
+       if (F <= 1e-5f) {       /* use arbitrary major radius, zero minor, infinite eccentricity */
                *a = sqrtf(A > C ? A : C);
                *b = 0.f;
                *ecc = 1e10f;
@@ -835,31 +863,31 @@ static void imp2radangle(float A, float B, float C, float F, float* a, float* b,
                        *b = sqrtf(F2 / d);
                        *ecc = *a / *b;
                }
-               // incr theta by 0.5*pi (angle of major axis)
+               /* incr theta by 0.5*pi (angle of major axis) */
                *th = 0.5f*(atan2f(B, AmC) + (float)M_PI);
        }
 }
 
-static void ewa_eval(TexResult* texr, ImBuf* ibuf, float fx, float fy, afdata_t* AFD)
+static void ewa_eval(TexResult *texr, ImBuf *ibuf, float fx, float fy, afdata_t *AFD)
 {
-       // scaling dxt/dyt by full resolution can cause overflow because of huge A/B/C and esp. F values,
-       // scaling by aspect ratio alone does the opposite, so try something in between instead...
+       /* scaling dxt/dyt by full resolution can cause overflow because of huge A/B/C and esp. F values,
+        * scaling by aspect ratio alone does the opposite, so try something in between instead... */
        const float ff2 = ibuf->x, ff = sqrtf(ff2), q = ibuf->y / ff;
        const float Ux = AFD->dxt[0]*ff, Vx = AFD->dxt[1]*q, Uy = AFD->dyt[0]*ff, Vy = AFD->dyt[1]*q;
        float A = Vx*Vx + Vy*Vy;
        float B = -2.f*(Ux*Vx + Uy*Vy);
        float C = Ux*Ux + Uy*Uy;
        float F = A*C - B*B*0.25f;
-       float a, b, th, ecc, a2, b2, ue, ve, U0, V0, DDQ, U, ac1, ac2, BU, d; // TXF alpha: cw = 0.f;
-       int u, v, u1, u2, v1, v2; // TXF alpha: clip = 0;
-
-       // The so-called 'high' quality ewa method simply adds a constant of 1 to both A & C,
-       // so the ellipse always covers at least some texels. But since the filter is now always larger,
-       // it also means that everywhere else it's also more blurry then ideally should be the case.
-       // So instead here the ellipse radii are modified instead whenever either is too low.
-       // Use a different radius based on interpolation switch, just enough to anti-alias when interpolation is off,
-       // and slightly larger to make result a bit smoother than bilinear interpolation when interpolation is on
-       // (minimum values: const float rmin = intpol ? 1.f : 0.5f;)
+       float a, b, th, ecc, a2, b2, ue, ve, U0, V0, DDQ, U, ac1, ac2, BU, d; /* TXF alpha: cw = 0.f; */
+       int u, v, u1, u2, v1, v2; /* TXF alpha: clip = 0; */
+
+       /* The so-called 'high' quality ewa method simply adds a constant of 1 to both A & C,
+        * so the ellipse always covers at least some texels. But since the filter is now always larger,
+        * it also means that everywhere else it's also more blurry then ideally should be the case.
+        * So instead here the ellipse radii are modified instead whenever either is too low.
+        * Use a different radius based on interpolation switch, just enough to anti-alias when interpolation is off,
+        * and slightly larger to make result a bit smoother than bilinear interpolation when interpolation is on
+        * (minimum values: const float rmin = intpol ? 1.f : 0.5f;) */
        const float rmin = (AFD->intpol ? 1.5625f : 0.765625f)/ff2;
        imp2radangle(A, B, C, F, &a, &b, &th, &ecc);
        if ((b2 = b*b) < rmin) {
@@ -905,8 +933,8 @@ static void ewa_eval(TexResult* texr, ImBuf* ibuf, float fx, float fy, afdata_t*
                                float tc[4];
                                const float wt = EWA_WTS[(Q < 0.f) ? 0 : (unsigned int)Q];
                                /*const int out =*/ ibuf_get_color_clip(tc, ibuf, u, v, AFD->extflag);
-                               // TXF alpha: clip |= out;
-                               // TXF alpha: cw += out ? 0.f : wt;
+                               /* TXF alpha: clip |= out;
+                                * TXF alpha: cw += out ? 0.f : wt; */
                                texr->tr += tc[0]*wt;
                                texr->tg += tc[1]*wt;
                                texr->tb += tc[2]*wt;
@@ -918,26 +946,26 @@ static void ewa_eval(TexResult* texr, ImBuf* ibuf, float fx, float fy, afdata_t*
                }
        }
 
-       // d should hopefully never be zero anymore
+       /* d should hopefully never be zero anymore */
        d = 1.f/d;
        texr->tr *= d;
        texr->tg *= d;
        texr->tb *= d;
-       // clipping can be ignored if alpha used, texr->ta already includes filtered edge
-       texr->ta = texr->talpha ? texr->ta*d : 1.f; // TXF alpha (clip ? cw*d : 1.f);
+       /* clipping can be ignored if alpha used, texr->ta already includes filtered edge */
+       texr->ta = texr->talpha ? texr->ta*d : 1.f; /* TXF alpha (clip ? cw*d : 1.f); */
 }
 
-static void feline_eval(TexResult* texr, ImBuf* ibuf, float fx, float fy, afdata_t* AFD)
+static void feline_eval(TexResult *texr, ImBuf *ibuf, float fx, float fy, afdata_t *AFD)
 {
        const int maxn = AFD->iProbes - 1;
        const float ll = ((AFD->majrad == AFD->minrad) ? 2.f*AFD->majrad : 2.f*(AFD->majrad - AFD->minrad)) / (maxn ? (float)maxn : 1.f);
        float du = maxn ? cosf(AFD->theta)*ll : 0.f;
        float dv = maxn ? sinf(AFD->theta)*ll : 0.f;
-       //const float D = -0.5f*(du*du + dv*dv) / (AFD->majrad*AFD->majrad);
+       /* const float D = -0.5f*(du*du + dv*dv) / (AFD->majrad*AFD->majrad); */
        const float D = (EWA_MAXIDX + 1)*0.25f*(du*du + dv*dv) / (AFD->majrad*AFD->majrad);
-       float d; // TXF alpha: cw = 0.f;
-       int n; // TXF alpha: clip = 0;
-       // have to use same scaling for du/dv here as for Ux/Vx/Uy/Vy (*after* D calc.)
+       float d; /* TXF alpha: cw = 0.f; */
+       int n; /* TXF alpha: clip = 0; */
+       /* have to use same scaling for du/dv here as for Ux/Vx/Uy/Vy (*after* D calc.) */
        du *= AFD->dusc;
        dv *= AFD->dvsc;
        d = texr->tr = texr->tb = texr->tg = texr->ta = 0.f;
@@ -945,12 +973,12 @@ static void feline_eval(TexResult* texr, ImBuf* ibuf, float fx, float fy, afdata
                float tc[4];
                const float hn = n*0.5f;
                const float u = fx + hn*du, v = fy + hn*dv;
-               //const float wt = expf(n*n*D);
-               // can use ewa table here too
+               /*const float wt = expf(n*n*D);
+                * can use ewa table here too */
                const float wt = EWA_WTS[(int)(n*n*D)];
                /*const int out =*/ ibuf_get_color_clip_bilerp(tc, ibuf, ibuf->x*u, ibuf->y*v, AFD->intpol, AFD->extflag);
-               // TXF alpha: clip |= out;
-               // TXF alpha: cw += out ? 0.f : wt;
+               /* TXF alpha: clip |= out;
+                * TXF alpha: cw += out ? 0.f : wt; */
                texr->tr += tc[0]*wt;
                texr->tg += tc[1]*wt;
                texr->tb += tc[2]*wt;
@@ -962,7 +990,7 @@ static void feline_eval(TexResult* texr, ImBuf* ibuf, float fx, float fy, afdata
        texr->tr *= d;
        texr->tg *= d;
        texr->tb *= d;
-       // clipping can be ignored if alpha used, texr->ta already includes filtered edge
+       /* clipping can be ignored if alpha used, texr->ta already includes filtered edge */
        texr->ta = texr->talpha ? texr->ta*d : 1.f; // TXF alpha: (clip ? cw*d : 1.f);
 }
 #undef EWA_MAXIDX
@@ -972,20 +1000,20 @@ static void alpha_clip_aniso(ImBuf *ibuf, float minx, float miny, float maxx, fl
        float alphaclip;
        rctf rf;
 
-       // TXF apha: we're doing the same alphaclip here as boxsample, but i'm doubting
-       // if this is actually correct for the all the filtering algorithms ..
+       /* TXF apha: we're doing the same alphaclip here as boxsample, but i'm doubting
+        * if this is actually correct for the all the filtering algorithms .. */
 
-       if(!(extflag == TXC_REPT || extflag == TXC_EXTD)) {
-               rf.xmin= minx*(ibuf->x);
-               rf.xmax= maxx*(ibuf->x);
-               rf.ymin= miny*(ibuf->y);
-               rf.ymax= maxy*(ibuf->y);
+       if (!(extflag == TXC_REPT || extflag == TXC_EXTD)) {
+               rf.xmin = minx*(ibuf->x);
+               rf.xmax = maxx*(ibuf->x);
+               rf.ymin = miny*(ibuf->y);
+               rf.ymax = maxy*(ibuf->y);
 
-               alphaclip = clipx_rctf(&rf, 0.0, (float)(ibuf->x));
-               alphaclip*= clipy_rctf(&rf, 0.0, (float)(ibuf->y));
-               alphaclip= MAX2(alphaclip, 0.0f);
+               alphaclip  = clipx_rctf(&rf, 0.0, (float)(ibuf->x));
+               alphaclip *= clipy_rctf(&rf, 0.0, (float)(ibuf->y));
+               alphaclip  = max_ff(alphaclip, 0.0f);
 
-               if(alphaclip!=1.0f) {
+               if (alphaclip!=1.0f) {
                        /* premul it all */
                        texres->tr*= alphaclip;
                        texres->tg*= alphaclip;
@@ -1005,7 +1033,7 @@ static void image_mipmap_test(Tex *tex, ImBuf *ibuf)
                                if (ibuf->userflags & IB_MIPMAP_INVALID) {
                                        IMB_remakemipmap(ibuf, tex->imaflag & TEX_GAUSS_MIP);
                                        ibuf->userflags &= ~IB_MIPMAP_INVALID;
-                               }                               
+                               }
                                BLI_unlock_thread(LOCK_IMAGE);
                        }
                        if (ibuf->mipmap[0] == NULL) {
@@ -1019,7 +1047,7 @@ static void image_mipmap_test(Tex *tex, ImBuf *ibuf)
        
 }
 
-static int imagewraposa_aniso(Tex *tex, Image *ima, ImBuf *ibuf, float *texvec, float *dxt, float *dyt, TexResult *texres)
+static int imagewraposa_aniso(Tex *tex, Image *ima, ImBuf *ibuf, const float texvec[3], float dxt[2], float dyt[2], TexResult *texres, struct ImagePool *pool)
 {
        TexResult texr;
        float fx, fy, minx, maxx, miny, maxy;
@@ -1042,23 +1070,34 @@ static int imagewraposa_aniso(Tex *tex, Image *ima, ImBuf *ibuf, float *texvec,
 
        texres->tin = texres->ta = texres->tr = texres->tg = texres->tb = 0.f;
 
-       // we need to set retval OK, otherwise texture code generates normals itself...
+       /* we need to set retval OK, otherwise texture code generates normals itself... */
        retval = texres->nor ? 3 : 1;
 
-       // quick tests
+       /* quick tests */
        if (ibuf==NULL && ima==NULL) return retval;
 
-       if (ima) {      // hack for icon render
+       if (ima) {      /* hack for icon render */
                if ((ima->ibufs.first == NULL) && (R.r.scemode & R_NO_IMAGE_LOAD)) return retval;
-               ibuf = BKE_image_get_ibuf(ima, &tex->iuser); 
+               ibuf = BKE_image_pool_acquire_ibuf(ima, &tex->iuser, pool);
        }
 
-       if ((ibuf == NULL) || ((ibuf->rect == NULL) && (ibuf->rect_float == NULL))) return retval;
+       if ((ibuf == NULL) || ((ibuf->rect == NULL) && (ibuf->rect_float == NULL))) {
+               if (ima)
+                       BKE_image_pool_release_ibuf(ima, ibuf, pool);
+               return retval;
+       }
+
+       if (ima) {
+               ima->flag |= IMA_USED_FOR_RENDER;
+       }
 
        /* mipmap test */
        image_mipmap_test(tex, ibuf);
        
-       if ((tex->imaflag & TEX_USEALPHA) && ((tex->imaflag & TEX_CALCALPHA) == 0)) texres->talpha = 1;
+       if (tex->ima && (tex->ima->flag & IMA_IGNORE_ALPHA) == 0) {
+               if ((tex->imaflag & TEX_CALCALPHA) == 0)
+                       texres->talpha = 1;
+       }
        texr.talpha = texres->talpha;
 
        if (tex->imaflag & TEX_IMAROT) {
@@ -1081,19 +1120,19 @@ static int imagewraposa_aniso(Tex *tex, Image *ima, ImBuf *ibuf, float *texvec,
                }
        }
 
-       // pixel coordinates
-       minx = MIN3(dxt[0], dyt[0], dxt[0] + dyt[0]);
-       maxx = MAX3(dxt[0], dyt[0], dxt[0] + dyt[0]);
-       miny = MIN3(dxt[1], dyt[1], dxt[1] + dyt[1]);
-       maxy = MAX3(dxt[1], dyt[1], dxt[1] + dyt[1]);
+       /* pixel coordinates */
+       minx = min_fff(dxt[0], dyt[0], dxt[0] + dyt[0]);
+       maxx = max_fff(dxt[0], dyt[0], dxt[0] + dyt[0]);
+       miny = min_fff(dxt[1], dyt[1], dxt[1] + dyt[1]);
+       maxy = max_fff(dxt[1], dyt[1], dxt[1] + dyt[1]);
 
-       // tex_sharper has been removed
+       /* tex_sharper has been removed */
        minx = (maxx - minx)*0.5f;
        miny = (maxy - miny)*0.5f;
 
        if (tex->imaflag & TEX_FILTER_MIN) {
-               // make sure the filtersize is minimal in pixels (normal, ref map can have miniature pixel dx/dy)
-                const float addval = (0.5f * tex->filtersize) / (float)MIN2(ibuf->x, ibuf->y);
+               /* make sure the filtersize is minimal in pixels (normal, ref map can have miniature pixel dx/dy) */
+               const float addval = (0.5f * tex->filtersize) / (float)MIN2(ibuf->x, ibuf->y);
                if (addval > minx) minx = addval;
                if (addval > miny) miny = addval;
        }
@@ -1109,9 +1148,9 @@ static int imagewraposa_aniso(Tex *tex, Image *ima, ImBuf *ibuf, float *texvec,
        if (tex->imaflag & TEX_IMAROT) {
                float t;
                SWAP(float, minx, miny);
-               // must rotate dxt/dyt 90 deg
-               // yet another blender problem is that swapping X/Y axes (or any tex proj switches) should do something similar,
-               // but it doesn't, it only swaps coords, so filter area will be incorrect in those cases.
+               /* must rotate dxt/dyt 90 deg
+                * yet another blender problem is that swapping X/Y axes (or any tex proj switches) should do something similar,
+                * but it doesn't, it only swaps coords, so filter area will be incorrect in those cases. */
                t = dxt[0];
                dxt[0] = dxt[1];
                dxt[1] = -t;
@@ -1120,11 +1159,11 @@ static int imagewraposa_aniso(Tex *tex, Image *ima, ImBuf *ibuf, float *texvec,
                dyt[1] = -t;
        }
 
-       // side faces of unit-cube
+       /* side faces of unit-cube */
        minx = (minx > 0.25f) ? 0.25f : ((minx < 1e-5f) ? 1e-5f : minx);
        miny = (miny > 0.25f) ? 0.25f : ((miny < 1e-5f) ? 1e-5f : miny);
 
-       // repeat and clip
+       /* repeat and clip */
 
        if (tex->extend == TEX_REPEAT) {
                if ((tex->flag & (TEX_REPEAT_XMIR | TEX_REPEAT_YMIR)) == (TEX_REPEAT_XMIR | TEX_REPEAT_YMIR))
@@ -1141,7 +1180,7 @@ static int imagewraposa_aniso(Tex *tex, Image *ima, ImBuf *ibuf, float *texvec,
 
        if (tex->extend == TEX_CHECKER) {
                int xs = (int)floorf(fx), ys = (int)floorf(fy);
-               // both checkers available, no boundary exceptions, checkerdist will eat aliasing
+               /* both checkers available, no boundary exceptions, checkerdist will eat aliasing */
                if ((tex->flag & TEX_CHECKER_ODD) && (tex->flag & TEX_CHECKER_EVEN)) {
                        fx -= xs;
                        fy -= ys;
@@ -1162,13 +1201,21 @@ static int imagewraposa_aniso(Tex *tex, Image *ima, ImBuf *ibuf, float *texvec,
                                }
                        }
                        else {
-                               if ((tex->flag & TEX_CHECKER_ODD) == 0 && ((xs + ys) & 1) == 0) return retval;
-                               if ((tex->flag & TEX_CHECKER_EVEN) == 0 && (xs + ys) & 1) return retval;
+                               if ((tex->flag & TEX_CHECKER_ODD) == 0 && ((xs + ys) & 1) == 0) {
+                                       if (ima)
+                                               BKE_image_pool_release_ibuf(ima, ibuf, pool);
+                                       return retval;
+                               }
+                               if ((tex->flag & TEX_CHECKER_EVEN) == 0 && (xs + ys) & 1) {
+                                       if (ima)
+                                               BKE_image_pool_release_ibuf(ima, ibuf, pool);
+                                       return retval;
+                               }
                                fx -= xs;
                                fy -= ys;
                        }
                }
-               // scale around center, (0.5, 0.5)
+               /* scale around center, (0.5, 0.5) */
                if (tex->checkerdist < 1.f) {
                        const float omcd = 1.f / (1.f - tex->checkerdist);
                        fx = (fx - 0.5f)*omcd + 0.5f;
@@ -1179,10 +1226,18 @@ static int imagewraposa_aniso(Tex *tex, Image *ima, ImBuf *ibuf, float *texvec,
        }
 
        if (tex->extend == TEX_CLIPCUBE) {
-               if ((fx + minx) < 0.f || (fy + miny) < 0.f || (fx - minx) > 1.f || (fy - miny) > 1.f || texvec[2] < -1.f || texvec[2] > 1.f) return retval;
+               if ((fx + minx) < 0.f || (fy + miny) < 0.f || (fx - minx) > 1.f || (fy - miny) > 1.f || texvec[2] < -1.f || texvec[2] > 1.f) {
+                       if (ima)
+                               BKE_image_pool_release_ibuf(ima, ibuf, pool);
+                       return retval;
+               }
        }
        else if (tex->extend == TEX_CLIP || tex->extend == TEX_CHECKER) {
-               if ((fx + minx) < 0.f || (fy + miny) < 0.f || (fx - minx) > 1.f || (fy - miny) > 1.f) return retval;
+               if ((fx + minx) < 0.f || (fy + miny) < 0.f || (fx - minx) > 1.f || (fy - miny) > 1.f) {
+                       if (ima)
+                               BKE_image_pool_release_ibuf(ima, ibuf, pool);
+                       return retval;
+               }
        }
        else {
                if (tex->extend == TEX_EXTEND) {
@@ -1197,34 +1252,34 @@ static int imagewraposa_aniso(Tex *tex, Image *ima, ImBuf *ibuf, float *texvec,
 
        intpol = tex->imaflag & TEX_INTERPOL;
 
-       // warning no return!
+       /* warning no return! */
        if ((R.flag & R_SEC_FIELD) && (ibuf->flags & IB_fields))
                ibuf->rect += ibuf->x*ibuf->y;
 
-       // struct common data
+       /* struct common data */
        copy_v2_v2(AFD.dxt, dxt);
        copy_v2_v2(AFD.dyt, dyt);
        AFD.intpol = intpol;
        AFD.extflag = extflag;
 
-       // brecht: added stupid clamping here, large dx/dy can give very large
-       // filter sizes which take ages to render, it may be better to do this
-       // more intelligently later in the code .. probably it's not noticeable
-       if(AFD.dxt[0]*AFD.dxt[0] + AFD.dxt[1]*AFD.dxt[1] > 2.0f*2.0f)
+       /* brecht: added stupid clamping here, large dx/dy can give very large
+        * filter sizes which take ages to render, it may be better to do this
+        * more intelligently later in the code .. probably it's not noticeable */
+       if (AFD.dxt[0]*AFD.dxt[0] + AFD.dxt[1]*AFD.dxt[1] > 2.0f*2.0f)
                mul_v2_fl(AFD.dxt, 2.0f/len_v2(AFD.dxt));
-       if(AFD.dyt[0]*AFD.dyt[0] + AFD.dyt[1]*AFD.dyt[1] > 2.0f*2.0f)
+       if (AFD.dyt[0]*AFD.dyt[0] + AFD.dyt[1]*AFD.dyt[1] > 2.0f*2.0f)
                mul_v2_fl(AFD.dyt, 2.0f/len_v2(AFD.dyt));
 
-       // choice:
+       /* choice: */
        if (tex->imaflag & TEX_MIPMAP) {
                ImBuf *previbuf, *curibuf;
                float levf;
                int maxlev;
-               ImBufmipmaps[IB_MIPMAP_LEVELS + 1];
+               ImBuf *mipmaps[IB_MIPMAP_LEVELS + 1];
 
-               // modify ellipse minor axis if too eccentric, use for area sampling as well
-               // scaling dxt/dyt as done in pbrt is not the same
-               // (as in ewa_eval(), scale by sqrt(ibuf->x) to maximize precision)
+               /* modify ellipse minor axis if too eccentric, use for area sampling as well
+                * scaling dxt/dyt as done in pbrt is not the same
+                * (as in ewa_eval(), scale by sqrt(ibuf->x) to maximize precision) */
                const float ff = sqrtf(ibuf->x), q = ibuf->y/ff;
                const float Ux = dxt[0]*ff, Vx = dxt[1]*q, Uy = dyt[0]*ff, Vy = dyt[1]*q;
                const float A = Vx*Vx + Vy*Vy;
@@ -1237,8 +1292,8 @@ static int imagewraposa_aniso(Tex *tex, Image *ima, ImBuf *ibuf, float *texvec,
                        float fProbes;
                        a *= ff;
                        b *= ff;
-                       a = MAX2(a, 1.f);
-                       b = MAX2(b, 1.f);
+                       a = max_ff(a, 1.0f);
+                       b = max_ff(b, 1.0f);
                        fProbes = 2.f*(a / b) - 1.f;
                        AFD.iProbes = (int)floorf(fProbes + 0.5f);
                        AFD.iProbes = MIN2(AFD.iProbes, tex->afmax);
@@ -1250,12 +1305,12 @@ static int imagewraposa_aniso(Tex *tex, Image *ima, ImBuf *ibuf, float *texvec,
                        AFD.dusc = 1.f/ff;
                        AFD.dvsc = ff / (float)ibuf->y;
                }
-               else {  // EWA & area
+               else {  /* EWA & area */
                        if (ecc > (float)tex->afmax) b = a / (float)tex->afmax;
                        b *= ff;
                }
-               maxd = MAX2(b, 1e-8f);
-               levf = ((float)M_LOG2E)*logf(maxd);
+               maxd = max_ff(b, 1e-8f);
+               levf = ((float)M_LOG2E) * logf(maxd);
 
                curmap = 0;
                maxlev = 1;
@@ -1266,8 +1321,8 @@ static int imagewraposa_aniso(Tex *tex, Image *ima, ImBuf *ibuf, float *texvec,
                        curmap++;
                }
 
-               // mipmap level
-               if (levf < 0.f) {       // original image only
+               /* mipmap level */
+               if (levf < 0.f) {  /* original image only */
                        previbuf = curibuf = mipmaps[0];
                        levf = 0.f;
                }
@@ -1283,39 +1338,39 @@ static int imagewraposa_aniso(Tex *tex, Image *ima, ImBuf *ibuf, float *texvec,
                        levf -= floorf(levf);
                }
 
-               // filter functions take care of interpolation themselves, no need to modify dxt/dyt here
+               /* filter functions take care of interpolation themselves, no need to modify dxt/dyt here */
 
                if (texres->nor && ((tex->imaflag & TEX_NORMALMAP) == 0)) {
-                       // color & normal
+                       /* color & normal */
                        filterfunc(texres, curibuf, fx, fy, &AFD);
                        val1 = texres->tr + texres->tg + texres->tb;
                        filterfunc(&texr, curibuf, fx + dxt[0], fy + dxt[1], &AFD);
                        val2 = texr.tr + texr.tg + texr.tb;
                        filterfunc(&texr, curibuf, fx + dyt[0], fy + dyt[1], &AFD);
                        val3 = texr.tr + texr.tg + texr.tb;
-                       // don't switch x or y!
+                       /* don't switch x or y! */
                        texres->nor[0] = val1 - val2;
                        texres->nor[1] = val1 - val3;
-                       if (previbuf != curibuf) {  // interpolate
+                       if (previbuf != curibuf) {  /* interpolate */
                                filterfunc(&texr, previbuf, fx, fy, &AFD);
-                               // rgb
+                               /* rgb */
                                texres->tr += levf*(texr.tr - texres->tr);
                                texres->tg += levf*(texr.tg - texres->tg);
                                texres->tb += levf*(texr.tb - texres->tb);
                                texres->ta += levf*(texr.ta - texres->ta);
-                               // normal
+                               /* normal */
                                val1 += levf*((texr.tr + texr.tg + texr.tb) - val1);
                                filterfunc(&texr, previbuf, fx + dxt[0], fy + dxt[1], &AFD);
                                val2 += levf*((texr.tr + texr.tg + texr.tb) - val2);
                                filterfunc(&texr, previbuf, fx + dyt[0], fy + dyt[1], &AFD);
                                val3 += levf*((texr.tr + texr.tg + texr.tb) - val3);
-                               texres->nor[0] = val1 - val2;   // vals have been interpolated above!
+                               texres->nor[0] = val1 - val2;  /* vals have been interpolated above! */
                                texres->nor[1] = val1 - val3;
                        }
                }
-               else {  // color
+               else {  /* color */
                        filterfunc(texres, curibuf, fx, fy, &AFD);
-                       if (previbuf != curibuf) {  // interpolate
+                       if (previbuf != curibuf) {  /* interpolate */
                                filterfunc(&texr, previbuf, fx, fy, &AFD);
                                texres->tr += levf*(texr.tr - texres->tr);
                                texres->tg += levf*(texr.tg - texres->tg);
@@ -1326,8 +1381,8 @@ static int imagewraposa_aniso(Tex *tex, Image *ima, ImBuf *ibuf, float *texvec,
                        alpha_clip_aniso(ibuf, fx-minx, fy-miny, fx+minx, fy+miny, extflag, texres);
                }
        }
-       else {  // no mipmap
-               // filter functions take care of interpolation themselves, no need to modify dxt/dyt here
+       else {  /* no mipmap */
+               /* filter functions take care of interpolation themselves, no need to modify dxt/dyt here */
                if (tex->texfilter == TXF_FELINE) {
                        const float ff = sqrtf(ibuf->x), q = ibuf->y/ff;
                        const float Ux = dxt[0]*ff, Vx = dxt[1]*q, Uy = dyt[0]*ff, Vy = dyt[1]*q;
@@ -1339,10 +1394,10 @@ static int imagewraposa_aniso(Tex *tex, Image *ima, ImBuf *ibuf, float *texvec,
                        imp2radangle(A, B, C, F, &a, &b, &th, &ecc);
                        a *= ff;
                        b *= ff;
-                       a = MAX2(a, 1.f);
-                       b = MAX2(b, 1.f);
+                       a = max_ff(a, 1.0f);
+                       b = max_ff(b, 1.0f);
                        fProbes = 2.f*(a / b) - 1.f;
-                       // no limit to number of Probes here
+                       /* no limit to number of Probes here */
                        AFD.iProbes = (int)floorf(fProbes + 0.5f);
                        if (AFD.iProbes < fProbes) b = 2.f*a / (float)(AFD.iProbes + 1);
                        AFD.majrad = a/ff;
@@ -1352,14 +1407,14 @@ static int imagewraposa_aniso(Tex *tex, Image *ima, ImBuf *ibuf, float *texvec,
                        AFD.dvsc = ff / (float)ibuf->y;
                }
                if (texres->nor && ((tex->imaflag & TEX_NORMALMAP) == 0)) {
-                       // color & normal
+                       /* color & normal */
                        filterfunc(texres, ibuf, fx, fy, &AFD);
                        val1 = texres->tr + texres->tg + texres->tb;
                        filterfunc(&texr, ibuf, fx + dxt[0], fy + dxt[1], &AFD);
                        val2 = texr.tr + texr.tg + texr.tb;
                        filterfunc(&texr, ibuf, fx + dyt[0], fy + dyt[1], &AFD);
                        val3 = texr.tr + texr.tg + texr.tb;
-                       // don't switch x or y!
+                       /* don't switch x or y! */
                        texres->nor[0] = val1 - val2;
                        texres->nor[1] = val1 - val3;
                }
@@ -1370,7 +1425,7 @@ static int imagewraposa_aniso(Tex *tex, Image *ima, ImBuf *ibuf, float *texvec,
        }
 
        if (tex->imaflag & TEX_CALCALPHA)
-               texres->ta = texres->tin = texres->ta * MAX3(texres->tr, texres->tg, texres->tb);
+               texres->ta = texres->tin = texres->ta * max_fff(texres->tr, texres->tg, texres->tb);
        else
                texres->tin = texres->ta;
        if (tex->flag & TEX_NEGALPHA) texres->ta = 1.f - texres->ta;
@@ -1378,23 +1433,23 @@ static int imagewraposa_aniso(Tex *tex, Image *ima, ImBuf *ibuf, float *texvec,
        if ((R.flag & R_SEC_FIELD) && (ibuf->flags & IB_fields))
                ibuf->rect -= ibuf->x*ibuf->y;
 
-       if (texres->nor && (tex->imaflag & TEX_NORMALMAP)) {    // normal from color
-               // The invert of the red channel is to make
-               // the normal map compliant with the outside world.
-               // It needs to be done because in Blender
-               // the normal used in the renderer points inward. It is generated
-               // this way in calc_vertexnormals(). Should this ever change
-               // this negate must be removed.
+       if (texres->nor && (tex->imaflag & TEX_NORMALMAP)) {    /* normal from color */
+               /* The invert of the red channel is to make
+                * the normal map compliant with the outside world.
+                * It needs to be done because in Blender
+                * the normal used in the renderer points inward. It is generated
+                * this way in calc_vertexnormals(). Should this ever change
+                * this negate must be removed. */
                texres->nor[0] = -2.f*(texres->tr - 0.5f);
                texres->nor[1] = 2.f*(texres->tg - 0.5f);
                texres->nor[2] = 2.f*(texres->tb - 0.5f);
        }
-       
-       // de-premul, this is being premulled in shade_input_do_shade()
-       // TXF: this currently does not (yet?) work properly, destroys edge AA in clip/checker mode, so for now commented out
-       // also disabled in imagewraposa() to be able to compare results with blender's default texture filtering
 
-       // brecht: tried to fix this, see "TXF alpha" comments
+       /* de-premul, this is being premulled in shade_input_do_shade()
+        * TXF: this currently does not (yet?) work properly, destroys edge AA in clip/checker mode, so for now commented out
+        * also disabled in imagewraposa() to be able to compare results with blender's default texture filtering */
+
+       /* brecht: tried to fix this, see "TXF alpha" comments */
 
        if (texres->ta != 1.f && (texres->ta > 1e-4f)) {
                fx = 1.f/texres->ta;
@@ -1403,27 +1458,30 @@ static int imagewraposa_aniso(Tex *tex, Image *ima, ImBuf *ibuf, float *texvec,
                texres->tb *= fx;
        }
 
+       if (ima)
+               BKE_image_pool_release_ibuf(ima, ibuf, pool);
+
        BRICONTRGB;
        
        return retval;
 }
 
 
-int imagewraposa(Tex *tex, Image *ima, ImBuf *ibuf, float *texvec, float *DXT, float *DYT, TexResult *texres)
+int imagewraposa(Tex *tex, Image *ima, ImBuf *ibuf, const float texvec[3], const float DXT[2], const float DYT[2], TexResult *texres, struct ImagePool *pool)
 {
        TexResult texr;
-       float fx, fy, minx, maxx, miny, maxy, dx, dy, dxt[3], dyt[3];
+       float fx, fy, minx, maxx, miny, maxy, dx, dy, dxt[2], dyt[2];
        float maxd, pixsize, val1, val2, val3;
        int curmap, retval, imaprepeat, imapextend;
 
-       // TXF: since dxt/dyt might be modified here and since they might be needed after imagewraposa() call,
-       // make a local copy here so that original vecs remain untouched
-       VECCOPY(dxt, DXT);
-       VECCOPY(dyt, DYT);
+       /* TXF: since dxt/dyt might be modified here and since they might be needed after imagewraposa() call,
+        * make a local copy here so that original vecs remain untouched */
+       copy_v2_v2(dxt, DXT);
+       copy_v2_v2(dyt, DYT);
 
-       // anisotropic filtering
+       /* anisotropic filtering */
        if (tex->texfilter != TXF_BOX)
-               return imagewraposa_aniso(tex, ima, ibuf, texvec, dxt, dyt, texres);
+               return imagewraposa_aniso(tex, ima, ibuf, texvec, dxt, dyt, texres, pool);
 
        texres->tin= texres->ta= texres->tr= texres->tg= texres->tb= 0.0f;
        
@@ -1431,30 +1489,36 @@ int imagewraposa(Tex *tex, Image *ima, ImBuf *ibuf, float *texvec, float *DXT, f
        retval= texres->nor?3:1;
        
        /* quick tests */
-       if(ibuf==NULL && ima==NULL)
+       if (ibuf==NULL && ima==NULL)
                return retval;
-       if(ima) {
+       if (ima) {
 
                /* hack for icon render */
-               if(ima->ibufs.first==NULL && (R.r.scemode & R_NO_IMAGE_LOAD))
+               if (ima->ibufs.first==NULL && (R.r.scemode & R_NO_IMAGE_LOAD))
                        return retval;
                
-               ibuf= BKE_image_get_ibuf(ima, &tex->iuser); 
+               ibuf = BKE_image_pool_acquire_ibuf(ima, &tex->iuser, pool);
+
+               ima->flag|= IMA_USED_FOR_RENDER;
        }
-       if(ibuf==NULL || (ibuf->rect==NULL && ibuf->rect_float==NULL))
+       if (ibuf==NULL || (ibuf->rect==NULL && ibuf->rect_float==NULL)) {
+               if (ima)
+                       BKE_image_pool_release_ibuf(ima, ibuf, pool);
                return retval;
+       }
        
        /* mipmap test */
        image_mipmap_test(tex, ibuf);
 
-       if(tex->imaflag & TEX_USEALPHA) {
-               if(tex->imaflag & TEX_CALCALPHA);
-               else texres->talpha= 1;
+       if (tex->ima && (tex->ima->flag & IMA_IGNORE_ALPHA) == 0) {
+               if ((tex->imaflag & TEX_CALCALPHA) == 0) {
+                       texres->talpha = TRUE;
+               }
        }
        
        texr.talpha= texres->talpha;
        
-       if(tex->imaflag & TEX_IMAROT) {
+       if (tex->imaflag & TEX_IMAROT) {
                fy= texvec[0];
                fx= texvec[1];
        }
@@ -1463,9 +1527,9 @@ int imagewraposa(Tex *tex, Image *ima, ImBuf *ibuf, float *texvec, float *DXT, f
                fy= texvec[1];
        }
        
-       if(ibuf->flags & IB_fields) {
-               if(R.r.mode & R_FIELDS) {                       /* field render */
-                       if(R.flag & R_SEC_FIELD) {              /* correction for 2nd field */
+       if (ibuf->flags & IB_fields) {
+               if (R.r.mode & R_FIELDS) {                      /* field render */
+                       if (R.flag & R_SEC_FIELD) {             /* correction for 2nd field */
                                /* fac1= 0.5/( (float)ibuf->y ); */
                                /* fy-= fac1; */
                        }
@@ -1477,25 +1541,25 @@ int imagewraposa(Tex *tex, Image *ima, ImBuf *ibuf, float *texvec, float *DXT, f
        
        /* pixel coordinates */
 
-       minx= MIN3(dxt[0],dyt[0],dxt[0]+dyt[0] );
-       maxx= MAX3(dxt[0],dyt[0],dxt[0]+dyt[0] );
-       miny= MIN3(dxt[1],dyt[1],dxt[1]+dyt[1] );
-       maxy= MAX3(dxt[1],dyt[1],dxt[1]+dyt[1] );
+       minx = min_fff(dxt[0], dyt[0], dxt[0] + dyt[0]);
+       maxx = max_fff(dxt[0], dyt[0], dxt[0] + dyt[0]);
+       miny = min_fff(dxt[1], dyt[1], dxt[1] + dyt[1]);
+       maxy = max_fff(dxt[1], dyt[1], dxt[1] + dyt[1]);
 
        /* tex_sharper has been removed */
        minx= (maxx-minx)/2.0f;
        miny= (maxy-miny)/2.0f;
        
-       if(tex->imaflag & TEX_FILTER_MIN) {
+       if (tex->imaflag & TEX_FILTER_MIN) {
                /* make sure the filtersize is minimal in pixels (normal, ref map can have miniature pixel dx/dy) */
                float addval= (0.5f * tex->filtersize) / (float) MIN2(ibuf->x, ibuf->y);
 
-               if(addval > minx)
+               if (addval > minx)
                        minx= addval;
-               if(addval > miny)
+               if (addval > miny)
                        miny= addval;
        }
-       else if(tex->filtersize!=1.0f) {
+       else if (tex->filtersize!=1.0f) {
                minx*= tex->filtersize;
                miny*= tex->filtersize;
                
@@ -1505,33 +1569,33 @@ int imagewraposa(Tex *tex, Image *ima, ImBuf *ibuf, float *texvec, float *DXT, f
                dyt[1]*= tex->filtersize;
        }
 
-       if(tex->imaflag & TEX_IMAROT) SWAP(float, minx, miny);
+       if (tex->imaflag & TEX_IMAROT) SWAP(float, minx, miny);
        
-       if(minx>0.25f) minx= 0.25f;
-       else if(minx<0.00001f) minx= 0.00001f;  /* side faces of unit-cube */
-       if(miny>0.25f) miny= 0.25f;
-       else if(miny<0.00001f) miny= 0.00001f;
+       if (minx>0.25f) minx= 0.25f;
+       else if (minx<0.00001f) minx= 0.00001f; /* side faces of unit-cube */
+       if (miny>0.25f) miny= 0.25f;
+       else if (miny<0.00001f) miny= 0.00001f;
 
        
        /* repeat and clip */
        imaprepeat= (tex->extend==TEX_REPEAT);
        imapextend= (tex->extend==TEX_EXTEND);
 
-       if(tex->extend == TEX_REPEAT) {
-               if(tex->flag & (TEX_REPEAT_XMIR|TEX_REPEAT_YMIR)) {
+       if (tex->extend == TEX_REPEAT) {
+               if (tex->flag & (TEX_REPEAT_XMIR|TEX_REPEAT_YMIR)) {
                        imaprepeat= 0;
                        imapextend= 1;
                }
        }
 
-       if(tex->extend == TEX_CHECKER) {
+       if (tex->extend == TEX_CHECKER) {
                int xs, ys, xs1, ys1, xs2, ys2, boundary;
                
                xs= (int)floor(fx);
                ys= (int)floor(fy);
                
-               // both checkers available, no boundary exceptions, checkerdist will eat aliasing
-               if( (tex->flag & TEX_CHECKER_ODD) && (tex->flag & TEX_CHECKER_EVEN) ) {
+               /* both checkers available, no boundary exceptions, checkerdist will eat aliasing */
+               if ( (tex->flag & TEX_CHECKER_ODD) && (tex->flag & TEX_CHECKER_EVEN) ) {
                        fx-= xs;
                        fy-= ys;
                }
@@ -1543,37 +1607,47 @@ int imagewraposa(Tex *tex, Image *ima, ImBuf *ibuf, float *texvec, float *DXT, f
                        ys2= (int)floor(fy+miny);
                        boundary= (xs1!=xs2) || (ys1!=ys2);
 
-                       if(boundary==0) {
-                               if( (tex->flag & TEX_CHECKER_ODD)==0) {
-                                       if((xs+ys) & 1); 
-                                       else return retval;
+                       if (boundary==0) {
+                               if ( (tex->flag & TEX_CHECKER_ODD)==0) {
+                                       if ((xs + ys) & 1) {
+                                               /* pass */
+                                       }
+                                       else {
+                                               if (ima)
+                                                       BKE_image_pool_release_ibuf(ima, ibuf, pool);
+                                               return retval;
+                                       }
                                }
-                               if( (tex->flag & TEX_CHECKER_EVEN)==0) {
-                                       if((xs+ys) & 1) return retval;
+                               if ( (tex->flag & TEX_CHECKER_EVEN)==0) {
+                                       if ((xs + ys) & 1) {
+                                               if (ima)
+                                                       BKE_image_pool_release_ibuf(ima, ibuf, pool);
+                                               return retval;
+                                       }
                                }
                                fx-= xs;
                                fy-= ys;
                        }
                        else {
-                               if(tex->flag & TEX_CHECKER_ODD) {
-                                       if((xs1+ys) & 1) fx-= xs2;
+                               if (tex->flag & TEX_CHECKER_ODD) {
+                                       if ((xs1+ys) & 1) fx-= xs2;
                                        else fx-= xs1;
                                        
-                                       if((ys1+xs) & 1) fy-= ys2;
+                                       if ((ys1+xs) & 1) fy-= ys2;
                                        else fy-= ys1;
                                }
-                               if(tex->flag & TEX_CHECKER_EVEN) {
-                                       if((xs1+ys) & 1) fx-= xs1;
+                               if (tex->flag & TEX_CHECKER_EVEN) {
+                                       if ((xs1+ys) & 1) fx-= xs1;
                                        else fx-= xs2;
                                        
-                                       if((ys1+xs) & 1) fy-= ys1;
+                                       if ((ys1+xs) & 1) fy-= ys1;
                                        else fy-= ys2;
                                }
                        }
                }
 
                /* scale around center, (0.5, 0.5) */
-               if(tex->checkerdist<1.0f) {
+               if (tex->checkerdist<1.0f) {
                        fx= (fx-0.5f)/(1.0f-tex->checkerdist) +0.5f;
                        fy= (fy-0.5f)/(1.0f-tex->checkerdist) +0.5f;
                        minx/= (1.0f-tex->checkerdist);
@@ -1581,74 +1655,78 @@ int imagewraposa(Tex *tex, Image *ima, ImBuf *ibuf, float *texvec, float *DXT, f
                }
        }
 
-       if(tex->extend == TEX_CLIPCUBE) {
-               if(fx+minx<0.0f || fy+miny<0.0f || fx-minx>1.0f || fy-miny>1.0f || texvec[2]<-1.0f || texvec[2]>1.0f) {
+       if (tex->extend == TEX_CLIPCUBE) {
+               if (fx+minx<0.0f || fy+miny<0.0f || fx-minx>1.0f || fy-miny>1.0f || texvec[2]<-1.0f || texvec[2]>1.0f) {
+                       if (ima)
+                               BKE_image_pool_release_ibuf(ima, ibuf, pool);
                        return retval;
                }
        }
-       else if(tex->extend==TEX_CLIP || tex->extend==TEX_CHECKER) {
-               if(fx+minx<0.0f || fy+miny<0.0f || fx-minx>1.0f || fy-miny>1.0f) {
+       else if (tex->extend==TEX_CLIP || tex->extend==TEX_CHECKER) {
+               if (fx+minx<0.0f || fy+miny<0.0f || fx-minx>1.0f || fy-miny>1.0f) {
+                       if (ima)
+                               BKE_image_pool_release_ibuf(ima, ibuf, pool);
                        return retval;
                }
        }
        else {
-               if(imapextend) {
-                       if(fx>1.0f) fx = 1.0f;
-                       else if(fx<0.0f) fx= 0.0f;
+               if (imapextend) {
+                       if (fx>1.0f) fx = 1.0f;
+                       else if (fx<0.0f) fx= 0.0f;
                }
                else {
-                       if(fx>1.0f) fx -= (int)(fx);
-                       else if(fx<0.0f) fx+= 1-(int)(fx);
+                       if (fx>1.0f) fx -= (int)(fx);
+                       else if (fx<0.0f) fx+= 1-(int)(fx);
                }
                
-               if(imapextend) {
-                       if(fy>1.0f) fy = 1.0f;
-                       else if(fy<0.0f) fy= 0.0f;
+               if (imapextend) {
+                       if (fy>1.0f) fy = 1.0f;
+                       else if (fy<0.0f) fy= 0.0f;
                }
                else {
-                       if(fy>1.0f) fy -= (int)(fy);
-                       else if(fy<0.0f) fy+= 1-(int)(fy);
+                       if (fy>1.0f) fy -= (int)(fy);
+                       else if (fy<0.0f) fy+= 1-(int)(fy);
                }
        }
 
        /* warning no return! */
-       if( (R.flag & R_SEC_FIELD) && (ibuf->flags & IB_fields) ) {
+       if ( (R.flag & R_SEC_FIELD) && (ibuf->flags & IB_fields) ) {
                ibuf->rect+= (ibuf->x*ibuf->y);
        }
 
        /* choice:  */
-       if(tex->imaflag & TEX_MIPMAP) {
+       if (tex->imaflag & TEX_MIPMAP) {
                ImBuf *previbuf, *curibuf;
                float bumpscale;
                
-               dx= minx;
-               dy= miny;
-               maxd= MAX2(dx, dy);
-               if(maxd>0.5f) maxd= 0.5f;
+               dx = minx;
+               dy = miny;
+               maxd = max_ff(dx, dy);
+               if (maxd > 0.5f) maxd = 0.5f;
 
-               pixsize = 1.0f/ (float) MIN2(ibuf->x, ibuf->y);
+               pixsize = 1.0f / (float) MIN2(ibuf->x, ibuf->y);
                
                bumpscale= pixsize/maxd;
-               if(bumpscale>1.0f) bumpscale= 1.0f;
+               if (bumpscale>1.0f) bumpscale= 1.0f;
                else bumpscale*=bumpscale;
                
                curmap= 0;
                previbuf= curibuf= ibuf;
-               while(curmap<IB_MIPMAP_LEVELS && ibuf->mipmap[curmap]) {
-                       if(maxd < pixsize) break;
+               while (curmap<IB_MIPMAP_LEVELS && ibuf->mipmap[curmap]) {
+                       if (maxd < pixsize) break;
                        previbuf= curibuf;
                        curibuf= ibuf->mipmap[curmap];
                        pixsize= 1.0f / (float)MIN2(curibuf->x, curibuf->y);
                        curmap++;
                }
 
-               if(previbuf!=curibuf || (tex->imaflag & TEX_INTERPOL)) {
+               if (previbuf!=curibuf || (tex->imaflag & TEX_INTERPOL)) {
                        /* sample at least 1 pixel */
                        if (minx < 0.5f / ibuf->x) minx = 0.5f / ibuf->x;
                        if (miny < 0.5f / ibuf->y) miny = 0.5f / ibuf->y;
                }
                
-               if(texres->nor && (tex->imaflag & TEX_NORMALMAP)==0) {
+               if (texres->nor && (tex->imaflag & TEX_NORMALMAP)==0) {
                        /* a bit extra filter */
                        //minx*= 1.35f;
                        //miny*= 1.35f;
@@ -1664,13 +1742,13 @@ int imagewraposa(Tex *tex, Image *ima, ImBuf *ibuf, float *texvec, float *DXT, f
                        texres->nor[0]= (val1-val2);
                        texres->nor[1]= (val1-val3);
                        
-                       if(previbuf!=curibuf) {  /* interpolate */
+                       if (previbuf!=curibuf) {  /* interpolate */
                                
                                boxsample(previbuf, fx-minx, fy-miny, fx+minx, fy+miny, &texr, imaprepeat, imapextend);
                                
                                /* calc rgb */
                                dx= 2.0f*(pixsize-maxd)/pixsize;
-                               if(dx>=1.0f) {
+                               if (dx>=1.0f) {
                                        texres->ta= texr.ta; texres->tb= texr.tb;
                                        texres->tg= texr.tg; texres->tr= texr.tr;
                                }
@@ -1691,7 +1769,7 @@ int imagewraposa(Tex *tex, Image *ima, ImBuf *ibuf, float *texvec, float *DXT, f
                                texres->nor[0]= (val1-val2);    /* vals have been interpolated above! */
                                texres->nor[1]= (val1-val3);
                                
-                               if(dx<1.0f) {
+                               if (dx<1.0f) {
                                        dy= 1.0f-dx;
                                        texres->tb= dy*texres->tb+ dx*texr.tb;
                                        texres->tg= dy*texres->tg+ dx*texr.tg;
@@ -1710,15 +1788,16 @@ int imagewraposa(Tex *tex, Image *ima, ImBuf *ibuf, float *texvec, float *DXT, f
 
                        boxsample(curibuf, minx, miny, maxx, maxy, texres, imaprepeat, imapextend);
 
-                       if(previbuf!=curibuf) {  /* interpolate */
+                       if (previbuf!=curibuf) {  /* interpolate */
                                boxsample(previbuf, minx, miny, maxx, maxy, &texr, imaprepeat, imapextend);
                                
                                fx= 2.0f*(pixsize-maxd)/pixsize;
                                
-                               if(fx>=1.0f) {
+                               if (fx>=1.0f) {
                                        texres->ta= texr.ta; texres->tb= texr.tb;
                                        texres->tg= texr.tg; texres->tr= texr.tr;
-                               } else {
+                               }
+                               else {
                                        fy= 1.0f-fx;
                                        texres->tb= fy*texres->tb+ fx*texr.tb;
                                        texres->tg= fy*texres->tg+ fx*texr.tg;
@@ -1736,7 +1815,7 @@ int imagewraposa(Tex *tex, Image *ima, ImBuf *ibuf, float *texvec, float *DXT, f
                        if (miny < 0.5f / ibuf->y) miny = 0.5f / ibuf->y;
                }
 
-               if(texres->nor && (tex->imaflag & TEX_NORMALMAP)==0) {
+               if (texres->nor && (tex->imaflag & TEX_NORMALMAP)==0) {
                        boxsample(ibuf, fx-minx, fy-miny, fx+minx, fy+miny, texres, imaprepeat, imapextend);
                        val1= texres->tr+texres->tg+texres->tb;
                        boxsample(ibuf, fx-minx+dxt[0], fy-miny+dxt[1], fx+minx+dxt[0], fy+miny+dxt[1], &texr, imaprepeat, imapextend);
@@ -1752,76 +1831,73 @@ int imagewraposa(Tex *tex, Image *ima, ImBuf *ibuf, float *texvec, float *DXT, f
                        boxsample(ibuf, fx-minx, fy-miny, fx+minx, fy+miny, texres, imaprepeat, imapextend);
        }
        
-       if(tex->imaflag & TEX_CALCALPHA) {
-               texres->ta= texres->tin= texres->ta*MAX3(texres->tr, texres->tg, texres->tb);
+       if (tex->imaflag & TEX_CALCALPHA) {
+               texres->ta = texres->tin = texres->ta * max_fff(texres->tr, texres->tg, texres->tb);
        }
        else texres->tin= texres->ta;
 
-       if(tex->flag & TEX_NEGALPHA) texres->ta= 1.0f-texres->ta;
+       if (tex->flag & TEX_NEGALPHA) texres->ta= 1.0f-texres->ta;
        
-       if( (R.flag & R_SEC_FIELD) && (ibuf->flags & IB_fields) ) {
+       if ( (R.flag & R_SEC_FIELD) && (ibuf->flags & IB_fields) ) {
                ibuf->rect-= (ibuf->x*ibuf->y);
        }
 
-       if(texres->nor && (tex->imaflag & TEX_NORMALMAP)) {
-               // qdn: normal from color
-               // The invert of the red channel is to make
-               // the normal map compliant with the outside world.
-               // It needs to be done because in Blender
-               // the normal used in the renderer points inward. It is generated
-               // this way in calc_vertexnormals(). Should this ever change
-               // this negate must be removed.
+       if (texres->nor && (tex->imaflag & TEX_NORMALMAP)) {
+               /* qdn: normal from color
+                * The invert of the red channel is to make
+                * the normal map compliant with the outside world.
+                * It needs to be done because in Blender
+                * the normal used in the renderer points inward. It is generated
+                * this way in calc_vertexnormals(). Should this ever change
+                * this negate must be removed. */
                texres->nor[0] = -2.f*(texres->tr - 0.5f);
                texres->nor[1] = 2.f*(texres->tg - 0.5f);
                texres->nor[2] = 2.f*(texres->tb - 0.5f);
        }
-       
+
        /* de-premul, this is being premulled in shade_input_do_shade() */
-       if(texres->ta!=1.0f && texres->ta>1e-4f) {
-               fx= 1.0f/texres->ta;
-               texres->tr*= fx;
-               texres->tg*= fx;
-               texres->tb*= fx;
+       if (texres->ta != 1.0f && texres->ta > 1e-4f) {
+               mul_v3_fl(&texres->tr, 1.0f / texres->ta);
        }
 
+       if (ima)
+               BKE_image_pool_release_ibuf(ima, ibuf, pool);
+
        BRICONTRGB;
        
        return retval;
 }
 
-void image_sample(Image *ima, float fx, float fy, float dx, float dy, float *result)
+void image_sample(Image *ima, float fx, float fy, float dx, float dy, float result[4], struct ImagePool *pool)
 {
        TexResult texres;
-       ImBuf *ibuf= BKE_image_get_ibuf(ima, NULL);
+       ImBuf *ibuf = BKE_image_pool_acquire_ibuf(ima, NULL, pool);
        
-       if(ibuf==NULL) {
-               result[0]= result[1]= result[2]= result[3]= 0.0f;
+       if (UNLIKELY(ibuf == NULL)) {
+               zero_v4(result);
                return;
        }
        
-       if( (R.flag & R_SEC_FIELD) && (ibuf->flags & IB_fields) )
+       if ( (R.flag & R_SEC_FIELD) && (ibuf->flags & IB_fields) )
                ibuf->rect+= (ibuf->x*ibuf->y);
 
-       texres.talpha= 1; /* boxsample expects to be initialized */
-       boxsample(ibuf, fx, fy, fx+dx, fy+dy, &texres, 0, 1);
-       result[0]= texres.tr;
-       result[1]= texres.tg;
-       result[2]= texres.tb;
-       result[3]= texres.ta;
+       texres.talpha = TRUE; /* boxsample expects to be initialized */
+       boxsample(ibuf, fx, fy, fx + dx, fy + dy, &texres, 0, 1);
+       copy_v4_v4(result, &texres.tr);
        
-       if( (R.flag & R_SEC_FIELD) && (ibuf->flags & IB_fields) )
+       if ( (R.flag & R_SEC_FIELD) && (ibuf->flags & IB_fields) )
                ibuf->rect-= (ibuf->x*ibuf->y);
+
+       ima->flag|= IMA_USED_FOR_RENDER;
+
+       BKE_image_pool_release_ibuf(ima, ibuf, pool);
 }
 
-void ibuf_sample(ImBuf *ibuf, float fx, float fy, float dx, float dy, float *result)
+void ibuf_sample(ImBuf *ibuf, float fx, float fy, float dx, float dy, float result[4])
 {
-       TexResult texres;
+       TexResult texres = {0};
        afdata_t AFD;
-       
-       if(ibuf==NULL) {
-               return;
-       }
-       
+
        AFD.dxt[0] = dx; AFD.dxt[1] = dx;
        AFD.dyt[0] = dy; AFD.dyt[1] = dy;
        //copy_v2_v2(AFD.dxt, dx);
@@ -1829,13 +1905,8 @@ void ibuf_sample(ImBuf *ibuf, float fx, float fy, float dx, float dy, float *res
        
        AFD.intpol = 1;
        AFD.extflag = TXC_EXTD;
-       
-       memset(&texres, 0, sizeof(texres));
+
        ewa_eval(&texres, ibuf, fx, fy, &AFD);
        
-       
-       result[0]= texres.tr;
-       result[1]= texres.tg;
-       result[2]= texres.tb;
-       result[3]= texres.ta;
+       copy_v4_v4(result, &texres.tr);
 }