code cleanup: favor braces when blocks have mixed brace use.
[blender.git] / source / blender / render / intern / source / imagetexture.c
index d454ea60705d40a0e4193afc5f937034f9a93085..756fb09888224fdfb82f08a47d78db43b50e5cbe 100644 (file)
@@ -76,7 +76,7 @@ static void boxsample(ImBuf *ibuf, float minx, float miny, float maxx, float max
 
 
 /* x and y have to be checked for image size */
 
 
 /* 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;
        
 {
        int ofs = y * ibuf->x + x;
        
@@ -102,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);
                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, const float texvec[3], 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;
 {
        float fx, fy, val1, val2, val3;
        int x, y, retval;
@@ -124,13 +129,16 @@ int imagewrap(Tex *tex, Image *ima, ImBuf *ibuf, const float texvec[3], TexResul
                /* hack for icon render */
                if (ima->ibufs.first==NULL && (R.r.scemode & R_NO_IMAGE_LOAD))
                        return retval;
                /* 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);
 
                ima->flag|= IMA_USED_FOR_RENDER;
        }
 
                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;
                return retval;
+       }
        
        /* setup mapping */
        if (tex->imaflag & TEX_IMAROT) {
        
        /* setup mapping */
        if (tex->imaflag & TEX_IMAROT) {
@@ -150,11 +158,22 @@ int imagewrap(Tex *tex, Image *ima, ImBuf *ibuf, const float texvec[3], TexResul
                fx-= xs;
                fy-= ys;
 
                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 ( (tex->flag & TEX_CHECKER_EVEN)==0) {
-                       if ((xs+ys) & 1) return retval;
+                       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) {
                }
                /* scale around center, (0.5, 0.5) */
                if (tex->checkerdist<1.0f) {
@@ -168,11 +187,15 @@ int imagewrap(Tex *tex, Image *ima, ImBuf *ibuf, const float texvec[3], TexResul
 
        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) {
                        return retval;
                }
        }
        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;
                }
        }
                        return retval;
                }
        }
@@ -201,10 +224,10 @@ int imagewrap(Tex *tex, Image *ima, ImBuf *ibuf, const float texvec[3], TexResul
        }
 
        /* keep this before interpolation [#29761] */
        }
 
        /* keep this before interpolation [#29761] */
-       if (tex->imaflag & TEX_USEALPHA) {
+       if ((tex->imaflag & TEX_USEALPHA) && tex->ima && (tex->ima->flag & IMA_IGNORE_ALPHA) == 0) {
                if ((tex->imaflag & TEX_CALCALPHA) == 0) {
                        texres->talpha = TRUE;
                if ((tex->imaflag & TEX_CALCALPHA) == 0) {
                        texres->talpha = TRUE;
-               } 
+               }
        }
 
        /* interpolate */
        }
 
        /* interpolate */
@@ -231,13 +254,13 @@ int imagewrap(Tex *tex, Image *ima, ImBuf *ibuf, const float texvec[3], TexResul
 
        if (texres->nor) {
                if (tex->imaflag & TEX_NORMALMAP) {
 
        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.
+                       /* 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);
                        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);
@@ -251,14 +274,18 @@ int imagewrap(Tex *tex, Image *ima, ImBuf *ibuf, const float texvec[3], TexResul
                                ibuf_get_color(col, ibuf, x+1, y);
                                val2= (col[0]+col[1]+col[2]);
                        }
                                ibuf_get_color(col, ibuf, x+1, y);
                                val2= (col[0]+col[1]+col[2]);
                        }
-                       else val2= val1;
+                       else {
+                               val2= val1;
+                       }
 
                        if (y<ibuf->y-1) {
                                float col[4];
                                ibuf_get_color(col, ibuf, x, 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]);
+                               val3 = (col[0]+col[1]+col[2]);
+                       }
+                       else {
+                               val3 = val1;
                        }
                        }
-                       else val3= val1;
 
                        /* do not mix up x and y here! */
                        texres->nor[0]= (val1-val2);
 
                        /* do not mix up x and y here! */
                        texres->nor[0]= (val1-val2);
@@ -266,13 +293,19 @@ int imagewrap(Tex *tex, Image *ima, ImBuf *ibuf, const float texvec[3], TexResul
                }
        }
 
                }
        }
 
-       if (texres->talpha) texres->tin= texres->ta;
+       if (texres->talpha) {
+               texres->tin = texres->ta;
+       }
        else if (tex->imaflag & TEX_CALCALPHA) {
        else if (tex->imaflag & TEX_CALCALPHA) {
-               texres->ta= texres->tin= MAX3(texres->tr, texres->tg, texres->tb);
+               texres->ta = texres->tin = max_fff(texres->tr, texres->tg, texres->tb);
+       }
+       else {
+               texres->ta = texres->tin = 1.0;
        }
        }
-       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) {
 
        /* de-premul, this is being premulled in shade_input_do_shade() */
        if (texres->ta!=1.0f && texres->ta>1e-4f) {
@@ -281,7 +314,10 @@ int imagewrap(Tex *tex, Image *ima, ImBuf *ibuf, const float texvec[3], TexResul
                texres->tg*= fx;
                texres->tb*= fx;
        }
                texres->tg*= fx;
                texres->tb*= fx;
        }
-       
+
+       if (ima)
+               BKE_image_pool_release_ibuf(ima, ibuf, pool);
+
        BRICONTRGB;
        
        return retval;
        BRICONTRGB;
        
        return retval;
@@ -396,16 +432,16 @@ static float square_rctf(rctf *rf)
 {
        float x, y;
 
 {
        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;
 
 }
 
 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;
@@ -417,8 +453,8 @@ static float clipx_rctf(rctf *rf, float x1, float x2)
                rf->xmin = rf->xmax;
                return 0.0;
        }
                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;
 }
        }
        return 1.0;
 }
@@ -427,7 +463,7 @@ static float clipy_rctf(rctf *rf, float y1, float y2)
 {
        float size;
 
 {
        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;
@@ -440,8 +476,8 @@ static float clipy_rctf(rctf *rf, float y1, float y2)
                rf->ymin = rf->ymax;
                return 0.0;
        }
                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;
 
        }
        return 1.0;
 
@@ -474,7 +510,9 @@ static void boxsampleclip(struct ImBuf *ibuf, rctf *rf, TexResult *texres)
                        
                        muly= 1.0;
 
                        
                        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);
                        else {
                                if (y==starty) muly= 1.0f-(rf->ymin - y);
                                if (y==endy) muly= (rf->ymax - y);
@@ -539,7 +577,7 @@ static void boxsample(ImBuf *ibuf, float minx, float miny, float maxx, float max
         */
        /* 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: 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];
         * the point which min/max is derived from is assumed to be wrapped */
        TexResult texr;
        rctf *rf, stack[8];
@@ -619,36 +657,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;
 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;
 
        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) {
 {
        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;
                        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;
                        x %= ibuf->x;
                        x += x < 0 ? ibuf->x : 0;
                        y %= 2*ibuf->y;
@@ -665,11 +703,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;
                        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; } */
                }
        }
 
                }
        }
 
@@ -685,17 +724,18 @@ static int ibuf_get_color_clip(float *col, ImBuf *ibuf, int x, int y, int extfla
                }
        }
        else {
                }
        }
        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;
 }
 
                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];
 {
        if (intpol) {
                float c00[4], c01[4], c10[4], c11[4];
@@ -716,7 +756,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);
 }
 
        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;
 {
        int xs, ys, clip = 0;
        float tc[4], xsd, ysd, cw = 0.f;
@@ -749,60 +789,60 @@ static void area_sample(TexResult* texr, ImBuf* ibuf, float fx, float fy, afdata
        texr->tr *= xsd;
        texr->tg *= xsd;
        texr->tb *= xsd;
        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);
 }
 
        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
 #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
 //static int ISNAN(float x) { return (x != x); }
 
 #ifndef ISNAN
 #define ISNAN(x) ((x) != (x))
 #endif
 //static int ISNAN(float x) { return (x != x); }
 
-static void radangle2imp(float a2, float b2, float th, float* A, float* B, float* C, float* F)
+static void radangle2imp(float a2, float b2, float th, float *A, float *B, float *C, float *F)
 {
        float ct2 = cosf(th);
 {
        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);
        ct2 *= ct2;
        *A = a2*st2 + b2*ct2;
        *B = (b2 - a2)*sinf(2.f*th);
@@ -810,10 +850,10 @@ static void radangle2imp(float a2, float b2, float th, float* A, float* B, float
        *F = a2*b2;
 }
 
        *F = a2*b2;
 }
 
-// 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)
+/* 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;
                *a = sqrtf(A > C ? A : C);
                *b = 0.f;
                *ecc = 1e10f;
@@ -833,31 +873,31 @@ static void imp2radangle(float A, float B, float C, float F, float* a, float* b,
                        *b = sqrtf(F2 / d);
                        *ecc = *a / *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);
        }
 }
 
                *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;
        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) {
        const float rmin = (AFD->intpol ? 1.5625f : 0.765625f)/ff2;
        imp2radangle(A, B, C, F, &a, &b, &th, &ecc);
        if ((b2 = b*b) < rmin) {
@@ -903,8 +943,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);
                                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;
                                texr->tr += tc[0]*wt;
                                texr->tg += tc[1]*wt;
                                texr->tb += tc[2]*wt;
@@ -916,26 +956,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;
        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 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);
        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;
        du *= AFD->dusc;
        dv *= AFD->dvsc;
        d = texr->tr = texr->tb = texr->tg = texr->ta = 0.f;
@@ -943,12 +983,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;
                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);
                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;
                texr->tr += tc[0]*wt;
                texr->tg += tc[1]*wt;
                texr->tb += tc[2]*wt;
@@ -960,7 +1000,7 @@ static void feline_eval(TexResult* texr, ImBuf* ibuf, float fx, float fy, afdata
        texr->tr *= d;
        texr->tg *= d;
        texr->tb *= d;
        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
        texr->ta = texr->talpha ? texr->ta*d : 1.f; // TXF alpha: (clip ? cw*d : 1.f);
 }
 #undef EWA_MAXIDX
@@ -970,8 +1010,8 @@ static void alpha_clip_aniso(ImBuf *ibuf, float minx, float miny, float maxx, fl
        float alphaclip;
        rctf rf;
 
        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);
 
        if (!(extflag == TXC_REPT || extflag == TXC_EXTD)) {
                rf.xmin = minx*(ibuf->x);
@@ -979,9 +1019,9 @@ static void alpha_clip_aniso(ImBuf *ibuf, float minx, float miny, float maxx, fl
                rf.ymin = miny*(ibuf->y);
                rf.ymax = maxy*(ibuf->y);
 
                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) {
                        /* premul it all */
 
                if (alphaclip!=1.0f) {
                        /* premul it all */
@@ -1003,7 +1043,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;
                                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) {
                                BLI_unlock_thread(LOCK_IMAGE);
                        }
                        if (ibuf->mipmap[0] == NULL) {
@@ -1012,12 +1052,16 @@ static void image_mipmap_test(Tex *tex, ImBuf *ibuf)
                                        IMB_makemipmap(ibuf, tex->imaflag & TEX_GAUSS_MIP);
                                BLI_unlock_thread(LOCK_IMAGE);
                        }
                                        IMB_makemipmap(ibuf, tex->imaflag & TEX_GAUSS_MIP);
                                BLI_unlock_thread(LOCK_IMAGE);
                        }
+                       /* if no mipmap could be made, fall back on non-mipmap render */
+                       if (ibuf->mipmap[0] == NULL) {
+                               tex->imaflag &= ~TEX_MIPMAP;
+                       }
                }
        }
        
 }
 
                }
        }
        
 }
 
-static int imagewraposa_aniso(Tex *tex, Image *ima, ImBuf *ibuf, const float texvec[3], float dxt[3], float dyt[3], 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;
 {
        TexResult texr;
        float fx, fy, minx, maxx, miny, maxy;
@@ -1040,23 +1084,34 @@ static int imagewraposa_aniso(Tex *tex, Image *ima, ImBuf *ibuf, const float tex
 
        texres->tin = texres->ta = texres->tr = texres->tg = texres->tb = 0.f;
 
 
        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;
 
        retval = texres->nor ? 3 : 1;
 
-       // quick tests
+       /* quick tests */
        if (ibuf==NULL && ima==NULL) return retval;
 
        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;
                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))) {
+               if (ima)
+                       BKE_image_pool_release_ibuf(ima, ibuf, pool);
+               return retval;
        }
 
        }
 
-       if ((ibuf == NULL) || ((ibuf->rect == NULL) && (ibuf->rect_float == NULL))) return retval;
+       if (ima) {
+               ima->flag |= IMA_USED_FOR_RENDER;
+       }
 
        /* mipmap test */
        image_mipmap_test(tex, ibuf);
        
 
        /* mipmap test */
        image_mipmap_test(tex, ibuf);
        
-       if ((tex->imaflag & TEX_USEALPHA) && ((tex->imaflag & TEX_CALCALPHA) == 0)) texres->talpha = 1;
+       if ((tex->imaflag & TEX_USEALPHA) && 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) {
        texr.talpha = texres->talpha;
 
        if (tex->imaflag & TEX_IMAROT) {
@@ -1079,18 +1134,18 @@ static int imagewraposa_aniso(Tex *tex, Image *ima, ImBuf *ibuf, const float tex
                }
        }
 
                }
        }
 
-       // 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) {
        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)
+               /* 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;
                const float addval = (0.5f * tex->filtersize) / (float)MIN2(ibuf->x, ibuf->y);
                if (addval > minx) minx = addval;
                if (addval > miny) miny = addval;
@@ -1107,9 +1162,9 @@ static int imagewraposa_aniso(Tex *tex, Image *ima, ImBuf *ibuf, const float tex
        if (tex->imaflag & TEX_IMAROT) {
                float t;
                SWAP(float, minx, miny);
        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;
                t = dxt[0];
                dxt[0] = dxt[1];
                dxt[1] = -t;
@@ -1118,11 +1173,11 @@ static int imagewraposa_aniso(Tex *tex, Image *ima, ImBuf *ibuf, const float tex
                dyt[1] = -t;
        }
 
                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);
 
        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))
 
        if (tex->extend == TEX_REPEAT) {
                if ((tex->flag & (TEX_REPEAT_XMIR | TEX_REPEAT_YMIR)) == (TEX_REPEAT_XMIR | TEX_REPEAT_YMIR))
@@ -1139,7 +1194,7 @@ static int imagewraposa_aniso(Tex *tex, Image *ima, ImBuf *ibuf, const float tex
 
        if (tex->extend == TEX_CHECKER) {
                int xs = (int)floorf(fx), ys = (int)floorf(fy);
 
        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;
                if ((tex->flag & TEX_CHECKER_ODD) && (tex->flag & TEX_CHECKER_EVEN)) {
                        fx -= xs;
                        fy -= ys;
@@ -1160,13 +1215,21 @@ static int imagewraposa_aniso(Tex *tex, Image *ima, ImBuf *ibuf, const float tex
                                }
                        }
                        else {
                                }
                        }
                        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;
                        }
                }
                                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;
                if (tex->checkerdist < 1.f) {
                        const float omcd = 1.f / (1.f - tex->checkerdist);
                        fx = (fx - 0.5f)*omcd + 0.5f;
@@ -1177,10 +1240,18 @@ static int imagewraposa_aniso(Tex *tex, Image *ima, ImBuf *ibuf, const float tex
        }
 
        if (tex->extend == TEX_CLIPCUBE) {
        }
 
        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) {
        }
        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) {
        }
        else {
                if (tex->extend == TEX_EXTEND) {
@@ -1195,34 +1266,34 @@ static int imagewraposa_aniso(Tex *tex, Image *ima, ImBuf *ibuf, const float tex
 
        intpol = tex->imaflag & TEX_INTERPOL;
 
 
        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;
 
        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;
 
        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
+       /* 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)
                mul_v2_fl(AFD.dyt, 2.0f/len_v2(AFD.dyt));
 
        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)
                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;
        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;
                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;
@@ -1235,8 +1306,8 @@ static int imagewraposa_aniso(Tex *tex, Image *ima, ImBuf *ibuf, const float tex
                        float fProbes;
                        a *= ff;
                        b *= ff;
                        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);
                        fProbes = 2.f*(a / b) - 1.f;
                        AFD.iProbes = (int)floorf(fProbes + 0.5f);
                        AFD.iProbes = MIN2(AFD.iProbes, tex->afmax);
@@ -1248,12 +1319,12 @@ static int imagewraposa_aniso(Tex *tex, Image *ima, ImBuf *ibuf, const float tex
                        AFD.dusc = 1.f/ff;
                        AFD.dvsc = ff / (float)ibuf->y;
                }
                        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;
                }
                        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;
 
                curmap = 0;
                maxlev = 1;
@@ -1264,8 +1335,8 @@ static int imagewraposa_aniso(Tex *tex, Image *ima, ImBuf *ibuf, const float tex
                        curmap++;
                }
 
                        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;
                }
                        previbuf = curibuf = mipmaps[0];
                        levf = 0.f;
                }
@@ -1281,39 +1352,39 @@ static int imagewraposa_aniso(Tex *tex, Image *ima, ImBuf *ibuf, const float tex
                        levf -= floorf(levf);
                }
 
                        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)) {
 
                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;
                        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;
                        texres->nor[0] = val1 - val2;
                        texres->nor[1] = val1 - val3;
-                       if (previbuf != curibuf) {  // interpolate
+                       if (previbuf != curibuf) {  /* interpolate */
                                filterfunc(&texr, previbuf, fx, fy, &AFD);
                                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);
                                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);
                                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;
                        }
                }
                                texres->nor[1] = val1 - val3;
                        }
                }
-               else {  // color
+               else {  /* color */
                        filterfunc(texres, curibuf, fx, fy, &AFD);
                        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);
                                filterfunc(&texr, previbuf, fx, fy, &AFD);
                                texres->tr += levf*(texr.tr - texres->tr);
                                texres->tg += levf*(texr.tg - texres->tg);
@@ -1324,8 +1395,8 @@ static int imagewraposa_aniso(Tex *tex, Image *ima, ImBuf *ibuf, const float tex
                        alpha_clip_aniso(ibuf, fx-minx, fy-miny, fx+minx, fy+miny, extflag, texres);
                }
        }
                        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;
                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;
@@ -1337,10 +1408,10 @@ static int imagewraposa_aniso(Tex *tex, Image *ima, ImBuf *ibuf, const float tex
                        imp2radangle(A, B, C, F, &a, &b, &th, &ecc);
                        a *= ff;
                        b *= ff;
                        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;
                        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;
                        AFD.iProbes = (int)floorf(fProbes + 0.5f);
                        if (AFD.iProbes < fProbes) b = 2.f*a / (float)(AFD.iProbes + 1);
                        AFD.majrad = a/ff;
@@ -1350,14 +1421,14 @@ static int imagewraposa_aniso(Tex *tex, Image *ima, ImBuf *ibuf, const float tex
                        AFD.dvsc = ff / (float)ibuf->y;
                }
                if (texres->nor && ((tex->imaflag & TEX_NORMALMAP) == 0)) {
                        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;
                        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;
                }
                        texres->nor[0] = val1 - val2;
                        texres->nor[1] = val1 - val3;
                }
@@ -1368,7 +1439,7 @@ static int imagewraposa_aniso(Tex *tex, Image *ima, ImBuf *ibuf, const float tex
        }
 
        if (tex->imaflag & TEX_CALCALPHA)
        }
 
        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;
        else
                texres->tin = texres->ta;
        if (tex->flag & TEX_NEGALPHA) texres->ta = 1.f - texres->ta;
@@ -1376,23 +1447,23 @@ static int imagewraposa_aniso(Tex *tex, Image *ima, ImBuf *ibuf, const float tex
        if ((R.flag & R_SEC_FIELD) && (ibuf->flags & IB_fields))
                ibuf->rect -= ibuf->x*ibuf->y;
 
        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);
        }
                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;
 
        if (texres->ta != 1.f && (texres->ta > 1e-4f)) {
                fx = 1.f/texres->ta;
@@ -1401,27 +1472,30 @@ static int imagewraposa_aniso(Tex *tex, Image *ima, ImBuf *ibuf, const float tex
                texres->tb *= fx;
        }
 
                texres->tb *= fx;
        }
 
+       if (ima)
+               BKE_image_pool_release_ibuf(ima, ibuf, pool);
+
        BRICONTRGB;
        
        return retval;
 }
 
 
        BRICONTRGB;
        
        return retval;
 }
 
 
-int imagewraposa(Tex *tex, Image *ima, ImBuf *ibuf, const float texvec[3], const float DXT[3], const float DYT[3], 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;
 {
        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;
 
        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
-       copy_v3_v3(dxt, DXT);
-       copy_v3_v3(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)
        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;
        
 
        texres->tin= texres->ta= texres->tr= texres->tg= texres->tb= 0.0f;
        
@@ -1437,19 +1511,23 @@ int imagewraposa(Tex *tex, Image *ima, ImBuf *ibuf, const float texvec[3], const
                if (ima->ibufs.first==NULL && (R.r.scemode & R_NO_IMAGE_LOAD))
                        return retval;
                
                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;
        }
 
                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;
                return retval;
+       }
        
        /* mipmap test */
        image_mipmap_test(tex, ibuf);
 
        
        /* mipmap test */
        image_mipmap_test(tex, ibuf);
 
-       if (tex->imaflag & TEX_USEALPHA) {
-               if (tex->imaflag & TEX_CALCALPHA);
-               else texres->talpha= 1;
+       if ((tex->imaflag & TEX_USEALPHA) && tex->ima && (tex->ima->flag & IMA_IGNORE_ALPHA) == 0) {
+               if ((tex->imaflag & TEX_CALCALPHA) == 0) {
+                       texres->talpha = TRUE;
+               }
        }
        
        texr.talpha= texres->talpha;
        }
        
        texr.talpha= texres->talpha;
@@ -1477,10 +1555,10 @@ int imagewraposa(Tex *tex, Image *ima, ImBuf *ibuf, const float texvec[3], const
        
        /* pixel coordinates */
 
        
        /* 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;
 
        /* tex_sharper has been removed */
        minx= (maxx-minx)/2.0f;
@@ -1530,7 +1608,7 @@ int imagewraposa(Tex *tex, Image *ima, ImBuf *ibuf, const float texvec[3], const
                xs= (int)floor(fx);
                ys= (int)floor(fy);
                
                xs= (int)floor(fx);
                ys= (int)floor(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;
                if ( (tex->flag & TEX_CHECKER_ODD) && (tex->flag & TEX_CHECKER_EVEN) ) {
                        fx-= xs;
                        fy-= ys;
@@ -1545,11 +1623,21 @@ int imagewraposa(Tex *tex, Image *ima, ImBuf *ibuf, const float texvec[3], const
 
                        if (boundary==0) {
                                if ( (tex->flag & TEX_CHECKER_ODD)==0) {
 
                        if (boundary==0) {
                                if ( (tex->flag & TEX_CHECKER_ODD)==0) {
-                                       if ((xs+ys) & 1);
-                                       else return retval;
+                                       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 ( (tex->flag & TEX_CHECKER_EVEN)==0) {
-                                       if ((xs+ys) & 1) return retval;
+                                       if ((xs + ys) & 1) {
+                                               if (ima)
+                                                       BKE_image_pool_release_ibuf(ima, ibuf, pool);
+                                               return retval;
+                                       }
                                }
                                fx-= xs;
                                fy-= ys;
                                }
                                fx-= xs;
                                fy-= ys;
@@ -1583,11 +1671,15 @@ int imagewraposa(Tex *tex, Image *ima, ImBuf *ibuf, const float texvec[3], const
 
        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) {
                        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) {
+                       if (ima)
+                               BKE_image_pool_release_ibuf(ima, ibuf, pool);
                        return retval;
                }
        }
                        return retval;
                }
        }
@@ -1621,12 +1713,12 @@ int imagewraposa(Tex *tex, Image *ima, ImBuf *ibuf, const float texvec[3], const
                ImBuf *previbuf, *curibuf;
                float bumpscale;
                
                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;
                
                bumpscale= pixsize/maxd;
                if (bumpscale>1.0f) bumpscale= 1.0f;
@@ -1754,9 +1846,11 @@ int imagewraposa(Tex *tex, Image *ima, ImBuf *ibuf, const float texvec[3], const
        }
        
        if (tex->imaflag & TEX_CALCALPHA) {
        }
        
        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;
        }
        }
-       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;
        
@@ -1765,66 +1859,61 @@ int imagewraposa(Tex *tex, Image *ima, ImBuf *ibuf, const float texvec[3], const
        }
 
        if (texres->nor && (tex->imaflag & TEX_NORMALMAP)) {
        }
 
        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.
+               /* 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);
        }
                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() */
        /* 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;
 }
 
        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;
 {
        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) )
                ibuf->rect+= (ibuf->x*ibuf->y);
 
                return;
        }
        
        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) )
                ibuf->rect-= (ibuf->x*ibuf->y);
 
        ima->flag|= IMA_USED_FOR_RENDER;
        
        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;
        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);
        AFD.dxt[0] = dx; AFD.dxt[1] = dx;
        AFD.dyt[0] = dy; AFD.dyt[1] = dy;
        //copy_v2_v2(AFD.dxt, dx);
@@ -1832,13 +1921,8 @@ void ibuf_sample(ImBuf *ibuf, float fx, float fy, float dx, float dy, float *res
        
        AFD.intpol = 1;
        AFD.extflag = TXC_EXTD;
        
        AFD.intpol = 1;
        AFD.extflag = TXC_EXTD;
-       
-       memset(&texres, 0, sizeof(texres));
+
        ewa_eval(&texres, ibuf, fx, fy, &AFD);
        
        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);
 }
 }