高质量的快速图像缩放-二次线性插值和三次卷积插值

1、高质量的快速的图像缩放二次线性插值和三次卷积插值限制条件:为了便于讨论，这里只处理32bit的ARGB颜色;代码使用C+;涉及到汇编优化的时候假定为x86平台;使用的编译器为vc2005;为了代码的可读性,没有加入异常处理代码;测试使用的CPU为AMD64x2 4200+(2.37G) 和 Intel Core2 4400(2.00G);速度测试说明:只测试内存数据到内存数据的缩放测试图片都是800*600缩放到1024*768; fps表示每秒钟的帧数,值越大表示函数越快A: 近邻取样插值、二次线性插值、三次卷积插值 缩放效果对比 原图 近邻取样缩放到0.6倍 近邻取样缩放到1.6倍 二次线

2、性插值缩放到0.6倍 二次线性插值缩放到1.6倍 三次卷积插值缩放到0.6倍 三次卷积插值缩放到1.6倍 原图 近邻取样缩放到8倍 二次线性插值缩放到8倍 三次卷积插值缩放到8倍 二次线性插值(近似公式)近邻取样插值缩放简单、速度快，但很多时候缩放出的图片质量比较差(特别是对于人物、景色等)，图片的缩放有比较明显的锯齿；使用二次或更高次插值有利于改善缩放效果；B: 首先定义图像数据结构:#define asm _asmtypedef unsigned char TUInt8; / 0.255struct TARGB32 /32 bit color TUInt8 b,g,r,a; /a is a

3、lpha;struct TPicRegion /一块颜色数据区的描述，便于参数传递 TARGB32* pdata; /颜色数据首地址 long byte_width; /一行数据的物理宽度(字节宽度)； /abs(byte_width)有可能大于等于width*sizeof(TARGB32); long width; /像素宽度 long height; /像素高度;/那么访问一个点的函数可以写为：inline TARGB32& Pixels(const TPicRegion& pic,const long x,const long y) return ( (TARGB32*)(TUInt8*

4、)pic.pdata+pic.byte_width*y) )x;二次线性差值C: 二次线性插值缩放原理和公式图示: 缩放后图片 原图片 (宽DW,高DH) (宽SW,高SH)缩放映射原理: (Sx-0)/(SW-0)=(Dx-0)/(DW-0) (Sy-0)/(SH-0)=(Dy-0)/(DH-0) = Sx=Dx*SW/DW Sy=Dy*SH/DH聚焦看看(Sx,Sy)坐标点(Sx,Sy为浮点数)附近的情况； 对于近邻取样插值的缩放算法，直接取Color0颜色作为缩放后点的颜色；二次线性插值需要考虑(Sx,Sy)坐标点周围的4个颜色值Color0Color1Color2Color3，把(Sx

5、,Sy)到ABCD坐标点的距离作为系数来把4个颜色混合出缩放后点的颜色；(u=Sx-floor(Sx); v=Sy-floor(Sy); 说明:floor函数的返回值为小于等于参数的最大整数 ) 二次线性插值公式为: tmpColor0=Color0*(1-u) + Color2*u; tmpColor1=Color1*(1-u) + Color3*u; DstColor =tmpColor0*(1-v) + tmpColor2*v; 展开公式为: pm0=(1-u)*(1-v); pm1=v*(1-u); pm2=u*(1-v); pm3=u*v; 则颜色混合公式为: DstColor =

6、Color0*pm0 + Color1*pm1 + Color2*pm2 + Color3*pm3;参数函数图示：二次线性插值函数图示对于上面的公式，它将图片向右下各移动了半个像素，需要对此做一个修正；= Sx=(Dx+0.5)*SW/DW-0.5; Sy=(Dy+0.5)*SH/DH-0.5;而实际的程序,还需要考虑到边界(访问源图片可能超界)对于算法的影响,边界的处理可能有各种方案(不处理边界或边界回绕或边界饱和或边界映射或用背景颜色混合等;文章中默认使用边界饱和来处理超界);比如: 边界饱和函数: /访问一个点的函数，(x,y)坐标可能超出图片边界； /边界处理模式:边界饱和inline

7、 TARGB32 Pixels_Bound(const TPicRegion& pic,long x,long y) /assert(pic.width0)&(pic.height0); bool IsInPic=true; if (x=pic.width ) x=pic.width -1; IsInPic=false; if (y=pic.height) y=pic.height-1; IsInPic=false; TARGB32 result=Pixels(pic,x,y);if (!IsInPic) result.a=0;return result;D: 二次线性插值缩放算法的一个参考实

8、现：PicZoom_BilInear0该函数并没有做什么优化，只是一个简单的浮点实现版本；inline void Bilinear0(const TPicRegion& pic,float fx,float fy,TARGB32* result) long x=(long)fx; if (xfx) -x; /x=floor(fx); long y=(long)fy; if (yfy) -y; /y=floor(fy); TARGB32 Color0=Pixels_Bound(pic,x,y); TARGB32 Color2=Pixels_Bound(pic,x+1,y); TARGB32 Co

9、lor1=Pixels_Bound(pic,x,y+1); TARGB32 Color3=Pixels_Bound(pic,x+1,y+1); float u=fx-x; float v=fy-y; float pm3=u*v; float pm2=u*(1-v); float pm1=v*(1-u); float pm0=(1-u)*(1-v); result-a=(pm0*Color0.a+pm1*Color1.a+pm2*Color2.a+pm3*Color3.a); result-r=(pm0*Color0.r+pm1*Color1.r+pm2*Color2.r+pm3*Color3.

10、r); result-g=(pm0*Color0.g+pm1*Color1.g+pm2*Color2.g+pm3*Color3.g); result-b=(pm0*Color0.b+pm1*Color1.b+pm2*Color2.b+pm3*Color3.b); void PicZoom_Bilinear0(const TPicRegion& Dst,const TPicRegion& Src) if ( (0=Dst.width)|(0=Dst.height) |(0=Src.width)|(0=Src.height) return; unsigned long dst_width=Dst.

11、width; TARGB32* pDstLine=Dst.pdata; for (unsigned long y=0;yDst.height;+y) float srcy=(y+0.4999999)*Src.height/Dst.height-0.5; for (unsigned long x=0;x16; long y=y_1616; TARGB32 Color0=Pixels_Bound(pic,x,y); TARGB32 Color2=Pixels_Bound(pic,x+1,y); TARGB32 Color1=Pixels_Bound(pic,x,y+1); TARGB32 Colo

12、r3=Pixels_Bound(pic,x+1,y+1); unsigned long u_8=(x_16 & 0 xFFFF)8; unsigned long v_8=(y_16 & 0 xFFFF)8; unsigned long pm3_16=(u_8*v_8); unsigned long pm2_16=(u_8*(unsigned long)(255-v_8); unsigned long pm1_16=(v_8*(unsigned long)(255-u_8); unsigned long pm0_16=(255-u_8)*(255-v_8); result-a=(pm0_16*C

13、olor0.a+pm1_16*Color1.a+pm2_16*Color2.a+pm3_16*Color3.a)16); result-r=(pm0_16*Color0.r+pm1_16*Color1.r+pm2_16*Color2.r+pm3_16*Color3.r)16); result-g=(pm0_16*Color0.g+pm1_16*Color1.g+pm2_16*Color2.g+pm3_16*Color3.g)16); result-b=(pm0_16*Color0.b+pm1_16*Color1.b+pm2_16*Color2.b+pm3_16*Color3.b)16); vo

14、id PicZoom_Bilinear1(const TPicRegion& Dst,const TPicRegion& Src) if ( (0=Dst.width)|(0=Dst.height) |(0=Src.width)|(0=Src.height) return; long xrIntFloat_16=(Src.width)16)/Dst.width+1; long yrIntFloat_16=(Src.height)16)/Dst.height+1; const long csDErrorX=-(11); const long csDErrorY=-(11); unsigned l

15、ong dst_width=Dst.width; TARGB32* pDstLine=Dst.pdata; long srcy_16=csDErrorY; long y; for (y=0;yDst.height;+y) long srcx_16=csDErrorX; for (unsigned long x=0;xdst_width;+x) Bilinear1(Src,srcx_16,srcy_16,&pDstLinex); /border srcx_16+=xrIntFloat_16; srcy_16+=yrIntFloat_16; (TUInt8*&)pDstLine)+=Dst.byt

16、e_width; /速度测试:/=/ PicZoom_BilInear1 17.7 fps/F: 边界访问超界的问题二次线性插值需要考略边界访问超界的问题，我们可以将边界区域和内部区域分开处理，这样就可以优化内部的插值实现函数了：比如不需要判断访问超界、减少颜色数据复制、减少一些不必要的重复坐标计算等等inline void Bilinear2_Fast(TARGB32* PColor0,TARGB32* PColor1,unsigned long u_8,unsigned long v_8,TARGB32* result) unsigned long pm3_16=u_8*v_8; unsi

17、gned long pm2_16=(u_88)-pm3_16; unsigned long pm1_16=(v_88)-pm3_16; unsigned long pm0_16=(1a=(pm0_16*PColor00.a+pm2_16*PColor01.a+pm1_16*PColor10.a+pm3_16*PColor11.a)16); result-r=(pm0_16*PColor00.r+pm2_16*PColor01.r+pm1_16*PColor10.r+pm3_16*PColor11.r)16); result-g=(pm0_16*PColor00.g+pm2_16*PColor0

18、1.g+pm1_16*PColor10.g+pm3_16*PColor11.g)16); result-b=(pm0_16*PColor00.b+pm2_16*PColor01.b+pm1_16*PColor10.b+pm3_16*PColor11.b)16); inline void Bilinear2_Border(const TPicRegion& pic,const long x_16,const long y_16,TARGB32* result) long x=(x_1616); long y=(y_1616); unsigned long u_16=(unsigned short

19、)(x_16); unsigned long v_16=(unsigned short)(y_16); TARGB32 pixel4; pixel0=Pixels_Bound(pic,x,y); pixel1=Pixels_Bound(pic,x+1,y); pixel2=Pixels_Bound(pic,x,y+1); pixel3=Pixels_Bound(pic,x+1,y+1); Bilinear2_Fast(&pixel0,&pixel2,u_168,v_168,result); void PicZoom_Bilinear2(const TPicRegion& Dst,const T

20、PicRegion& Src) if ( (0=Dst.width)|(0=Dst.height) |(0=Src.width)|(0=Src.height) return; long xrIntFloat_16=(Src.width)16)/Dst.width+1; long yrIntFloat_16=(Src.height)16)/Dst.height+1; const long csDErrorX=-(11); const long csDErrorY=-(11); unsigned long dst_width=Dst.width; /计算出需要特殊处理的边界 long border

21、_y0=-csDErrorY/yrIntFloat_16+1; /y0+y*yr=0; y0=csDErrorY = y=-csDErrorY/yr if (border_y0=Dst.height) border_y0=Dst.height; long border_x0=-csDErrorX/xrIntFloat_16+1; if (border_x0=Dst.width ) border_x0=Dst.width; long border_y1=(Src.height-2)16)-csDErrorY)/yrIntFloat_16+1; /y0+y*yr y=(height-2-csDEr

22、rorY)/yr if (border_y1border_y0) border_y1=border_y0; long border_x1=(Src.width-2)16)-csDErrorX)/xrIntFloat_16+1; if (border_x1border_x0) border_x1=border_x0; TARGB32* pDstLine=Dst.pdata; long Src_byte_width=Src.byte_width; long srcy_16=csDErrorY; long y; for (y=0;yborder_y0;+y) long srcx_16=csDErro

23、rX; for (unsigned long x=0;xdst_width;+x) Bilinear2_Border(Src,srcx_16,srcy_16,&pDstLinex); /border srcx_16+=xrIntFloat_16; srcy_16+=yrIntFloat_16; (TUInt8*&)pDstLine)+=Dst.byte_width; for (y=border_y0;yborder_y1;+y) long srcx_16=csDErrorX; long x; for (x=0;x8; TARGB32* PSrcLineColor= (TARGB32*)(TUI

24、nt8*)(Src.pdata)+Src_byte_width*(srcy_1616) ; for (unsigned long x=border_x0;x16; TARGB32* PColor1=(TARGB32*)(TUInt8*)(PColor0)+Src_byte_width); Bilinear2_Fast(PColor0,PColor1,(srcx_16 & 0 xFFFF)8,v_8,&pDstLinex); srcx_16+=xrIntFloat_16; for (x=border_x1;xdst_width;+x) Bilinear2_Border(Src,srcx_16,s

25、rcy_16,&pDstLinex);/border srcx_16+=xrIntFloat_16; srcy_16+=yrIntFloat_16; (TUInt8*&)pDstLine)+=Dst.byte_width; for (y=border_y1;yDst.height;+y) long srcx_16=csDErrorX; for (unsigned long x=0;x=2;SH=2)证明这个公式不会造成内存访问超界: 要求Dx=DW-1时: sx+1=int( (dw-1)/dw*(dw-1) ) +1 = (sw-1) 有: int( (sw-1)*(dw-1)/dw ) =

26、sw-2 (sw-1)*(dw-1)/dw (sw-1) (dw-1) /dw1 (dw-1) Src.width)|(2Src.height) return; long xrIntFloat_16=(Src.width-1)16)/Dst.width; long yrIntFloat_16=(Src.height-1)16)/Dst.height; unsigned long dst_width=Dst.width; long Src_byte_width=Src.byte_width; TARGB32* pDstLine=Dst.pdata; long srcy_16=0; for (un

27、signed long y=0;y8; TARGB32* PSrcLineColor= (TARGB32*)(TUInt8*)(Src.pdata)+Src_byte_width*(srcy_1616) ; long srcx_16=0; for (unsigned long x=0;x16; Bilinear_Fast_Common(PColor0,(TARGB32*)(TUInt8*)(PColor0)+Src_byte_width),(srcx_16 & 0 xFFFF)8,v_8,&pDstLinex); srcx_16+=xrIntFloat_16; srcy_16+=yrIntFl

28、oat_16; (TUInt8*&)pDstLine)+=Dst.byte_width; G: 模拟单指令多数据处理利用单指令多数据处理的MMX指令一般都可以加快颜色的运算；在使用MMX改写之前，利用32bit寄存器(或变量)来模拟单指令多数据处理；数据储存原理:一个颜色数据分量只有一个字节,用2个字节来储存单个颜色分量的计算结果，对于很多颜色计算来说精度就够了；那么一个32bit寄存器(或变量)就可以储存2个计算出的临时颜色分量；从而达到了单个指令两路数据处理的目的;单个指令两路数据处理的计算:乘法： (0 x00AA*a)16) | (0 x00BB*a) = 0 x00AA00BB *

29、a可见只要保证0 x00AA*a和0 x00BB*a都小于(116)那么乘法可以直接使用无符号数乘法了加法: (0 x00AA+0 x00CC)16) | (0 x00BB+0 x00DD) = 0 x00AA00BB + 0 x00CC00DD可见只要0 x00AA+0 x00CC和0 x00BB+0 x00DD小于(18; unsigned long pm2_8=u_8-pm3_8; unsigned long pm1_8=v_8-pm3_8; unsigned long pm0_8=256-pm1_8-pm2_8-pm3_8; unsigned long Color=*(unsigned

30、 long*)(PColor0); unsigned long BR=(Color & 0 x00FF00FF)*pm0_8; unsigned long GA=(Color & 0 xFF00FF00)8)*pm0_8; Color=(unsigned long*)(PColor0)1; GA+=(Color & 0 xFF00FF00)8)*pm2_8; BR+=(Color & 0 x00FF00FF)*pm2_8; Color=*(unsigned long*)(PColor1); GA+=(Color & 0 xFF00FF00)8)*pm1_8; BR+=(Color & 0 x0

31、0FF00FF)*pm1_8; Color=(unsigned long*)(PColor1)1; GA+=(Color & 0 xFF00FF00)8)*pm3_8; BR+=(Color & 0 x00FF00FF)*pm3_8; *(unsigned long*)(result)=(GA & 0 xFF00FF00)|(BR & 0 xFF00FF00)8); inline void Bilinear_Border_Common(const TPicRegion& pic,const long x_16,const long y_16,TARGB32* result) long x=(x

32、_1616); long y=(y_1616); unsigned long u_16=(unsigned short)(x_16); unsigned long v_16=(unsigned short)(y_16); TARGB32 pixel4; pixel0=Pixels_Bound(pic,x,y); pixel1=Pixels_Bound(pic,x+1,y); pixel2=Pixels_Bound(pic,x,y+1); pixel3=Pixels_Bound(pic,x+1,y+1); Bilinear_Fast_Common(&pixel0,&pixel2,u_168,v_

33、168,result); void PicZoom_Bilinear_Common(const TPicRegion& Dst,const TPicRegion& Src) if ( (0=Dst.width)|(0=Dst.height) |(0=Src.width)|(0=Src.height) return; long xrIntFloat_16=(Src.width)16)/Dst.width+1; long yrIntFloat_16=(Src.height)16)/Dst.height+1; const long csDErrorX=-(11); const long csDErr

34、orY=-(11); unsigned long dst_width=Dst.width; /计算出需要特殊处理的边界 long border_y0=-csDErrorY/yrIntFloat_16+1; /y0+y*yr=0; y0=csDErrorY = y=-csDErrorY/yr if (border_y0=Dst.height) border_y0=Dst.height; long border_x0=-csDErrorX/xrIntFloat_16+1; if (border_x0=Dst.width ) border_x0=Dst.width; long border_y1=(

35、Src.height-2)16)-csDErrorY)/yrIntFloat_16+1; /y0+y*yr y=(height-2-csDErrorY)/yr if (border_y1border_y0) border_y1=border_y0; long border_x1=(Src.width-2)16)-csDErrorX)/xrIntFloat_16+1; if (border_x1border_x0) border_x1=border_x0; TARGB32* pDstLine=Dst.pdata; long Src_byte_width=Src.byte_width; long

36、srcy_16=csDErrorY; long y; for (y=0;yborder_y0;+y) long srcx_16=csDErrorX; for (unsigned long x=0;xdst_width;+x) Bilinear_Border_Common(Src,srcx_16,srcy_16,&pDstLinex); /border srcx_16+=xrIntFloat_16; srcy_16+=yrIntFloat_16; (TUInt8*&)pDstLine)+=Dst.byte_width; for (y=border_y0;yborder_y1;+y) long s

37、rcx_16=csDErrorX; long x; for (x=0;x8; TARGB32* PSrcLineColor= (TARGB32*)(TUInt8*)(Src.pdata)+Src_byte_width*(srcy_1616) ; for (unsigned long x=border_x0;x16; TARGB32* PColor1=(TARGB32*)(TUInt8*)(PColor0)+Src_byte_width); Bilinear_Fast_Common(PColor0,PColor1,(srcx_16 & 0 xFFFF)8,v_8,&pDstLinex); src

38、x_16+=xrIntFloat_16; for (x=border_x1;xdst_width;+x) Bilinear_Border_Common(Src,srcx_16,srcy_16,&pDstLinex);/border srcx_16+=xrIntFloat_16; srcy_16+=yrIntFloat_16; (TUInt8*&)pDstLine)+=Dst.byte_width; for (y=border_y1;yDst.height;+y) long srcx_16=csDErrorX; for (unsigned long x=0;x16); long y=(y_161

39、6); unsigned long u_16=(unsigned short)(x_16); unsigned long v_16=(unsigned short)(y_16); TARGB32 pixel4; pixel0=Pixels_Bound(pic,x,y); pixel1=Pixels_Bound(pic,x+1,y); pixel2=Pixels_Bound(pic,x,y+1); pixel3=Pixels_Bound(pic,x+1,y+1); Bilinear_Fast_MMX(&pixel0,&pixel2,u_168,v_168,result); void PicZoo

40、m_Bilinear_MMX(const TPicRegion& Dst,const TPicRegion& Src) if ( (0=Dst.width)|(0=Dst.height) |(0=Src.width)|(0=Src.height) return; long xrIntFloat_16=(Src.width)16)/Dst.width+1; long yrIntFloat_16=(Src.height)16)/Dst.height+1; const long csDErrorX=-(11); const long csDErrorY=-(11); unsigned long ds

41、t_width=Dst.width; /计算出需要特殊处理的边界 long border_y0=-csDErrorY/yrIntFloat_16+1; /y0+y*yr=0; y0=csDErrorY = y=-csDErrorY/yr if (border_y0=Dst.height) border_y0=Dst.height; long border_x0=-csDErrorX/xrIntFloat_16+1; if (border_x0=Dst.width ) border_x0=Dst.width; long border_y1=(Src.height-2)16)-csDErrorY)

42、/yrIntFloat_16+1; /y0+y*yr y=(height-2-csDErrorY)/yr if (border_y1border_y0) border_y1=border_y0; long border_x1=(Src.width-2)16)-csDErrorX)/xrIntFloat_16+1; if (border_x1border_x0) border_x1=border_x0; TARGB32* pDstLine=Dst.pdata; long Src_byte_width=Src.byte_width; long srcy_16=csDErrorY; long y;

43、for (y=0;yborder_y0;+y) long srcx_16=csDErrorX; for (unsigned long x=0;xdst_width;+x) Bilinear_Border_MMX(Src,srcx_16,srcy_16,&pDstLinex); /border srcx_16+=xrIntFloat_16; srcy_16+=yrIntFloat_16; (TUInt8*&)pDstLine)+=Dst.byte_width; for (y=border_y0;yborder_y1;+y) long srcx_16=csDErrorX; long x; for

44、(x=0;x8; TARGB32* PSrcLineColor= (TARGB32*)(TUInt8*)(Src.pdata)+Src_byte_width*(srcy_1616) ; for (unsigned long x=border_x0;x16; TARGB32* PColor1=(TARGB32*)(TUInt8*)(PColor0)+Src_byte_width); Bilinear_Fast_MMX(PColor0,PColor1,(srcx_16 & 0 xFFFF)8,v_8,&pDstLinex); srcx_16+=xrIntFloat_16; for (x=borde

45、r_x1;xdst_width;+x) Bilinear_Border_MMX(Src,srcx_16,srcy_16,&pDstLinex);/border srcx_16+=xrIntFloat_16; srcy_16+=yrIntFloat_16; (TUInt8*&)pDstLine)+=Dst.byte_width; for (y=border_y1;yDst.height;+y) long srcx_16=csDErrorX; for (unsigned long x=0;xdst_width;+x) Bilinear_Border_MMX(Src,srcx_16,srcy_16,

46、&pDstLinex); /border srcx_16+=xrIntFloat_16; srcy_16+=yrIntFloat_16; (TUInt8*&)pDstLine)+=Dst.byte_width; asm emms/速度测试:/=/ PicZoom_BilInear_MMX 132.9 fps/H: 对BilInear_MMX简单改进:PicZoom_Bilinear_MMX_Exvoid PicZoom_Bilinear_MMX_Ex(const TPicRegion& Dst,const TPicRegion& Src) if ( (0=Dst.width)|(0=Dst.h

47、eight) |(0=Src.width)|(0=Src.height) return; long xrIntFloat_16=(Src.width)16)/Dst.width+1; long yrIntFloat_16=(Src.height)16)/Dst.height+1; const long csDErrorX=-(11); const long csDErrorY=-(11); unsigned long dst_width=Dst.width; /计算出需要特殊处理的边界 long border_y0=-csDErrorY/yrIntFloat_16+1; /y0+y*yr=0;

48、 y0=csDErrorY = y=-csDErrorY/yr if (border_y0=Dst.height) border_y0=Dst.height; long border_x0=-csDErrorX/xrIntFloat_16+1; if (border_x0=Dst.width ) border_x0=Dst.width; long border_y1=(Src.height-2)16)-csDErrorY)/yrIntFloat_16+1; /y0+y*yr y=(height-2-csDErrorY)/yr if (border_y1border_y0) border_y1=

49、border_y0; long border_x1=(Src.width-2)16)-csDErrorX)/xrIntFloat_16+1; if (border_x1border_x0) border_x1=border_x0; TARGB32* pDstLine=Dst.pdata; long Src_byte_width=Src.byte_width; long srcy_16=csDErrorY; long y; for (y=0;yborder_y0;+y) long srcx_16=csDErrorX; for (unsigned long x=0;xdst_width;+x) B

50、ilinear_Border_MMX(Src,srcx_16,srcy_16,&pDstLinex); /border srcx_16+=xrIntFloat_16; srcy_16+=yrIntFloat_16; (TUInt8*&)pDstLine)+=Dst.byte_width; for (y=border_y0;yborder_y1;+y) long srcx_16=csDErrorX; long x; for (x=0;x0) unsigned long v_8=(srcy_16 & 0 xFFFF)8; TARGB32* PSrcLineColor= (TARGB32*)(TUI

51、nt8*)(Src.pdata)+Src_byte_width*(srcy_1616) ; TARGB32* PSrcLineColorNext= (TARGB32*)(TUInt8*)(PSrcLineColor)+Src_byte_width) ; TARGB32* pDstLine_Fast=&pDstLineborder_x0; asm movd mm6,v_8 pxor mm7,mm7 /mm7=0 PUNPCKLWD MM6,MM6 PUNPCKLDQ MM6,MM6/mm6=v_8 mov esi,PSrcLineColor mov ecx,PSrcLineColorNext m

52、ov edx,srcx_16 mov ebx,dst_width_fast mov edi,pDstLine_Fast lea edi,edi+ebx*4 push ebp mov ebp,xrIntFloat_16 neg ebx loop_start: mov eax,edx shl eax,16 shr eax,24 /= movzx eax,dh /eax=u_8 MOVD MM5,eax mov eax,edx shr eax,16 /srcx_1616 MOVD MM2,dword ptr ecx+eax*4 MOVD MM0,dword ptr ecx+eax*4+4 PUNPC

53、KLWD MM5,MM5 MOVD MM3,dword ptr esi+eax*4 MOVD MM1,dword ptr esi+eax*4+4 PUNPCKLDQ MM5,MM5 /mm5=u_8 PUNPCKLBW MM0,MM7 PUNPCKLBW MM1,MM7 PUNPCKLBW MM2,MM7 PUNPCKLBW MM3,MM7 PSUBw MM0,MM2 PSUBw MM1,MM3 PSLLw MM2,8 PSLLw MM3,8 PMULlw MM0,MM5 PMULlw MM1,MM5 PADDw MM0,MM2 PADDw MM1,MM3 PSRLw MM0,8 PSRLw

54、MM1,8 PSUBw MM0,MM1 PSLLw MM1,8 PMULlw MM0,MM6 PADDw MM0,MM1 PSRLw MM0,8 PACKUSwb MM0,MM7 MOVd dword ptr edi+ebx*4,MM0 /write DstColor add edx,ebp /srcx_16+=xrIntFloat_16 inc ebx jnz loop_start pop ebp mov srcx_16,edx for (x=border_x1;xdst_width;+x) Bilinear_Border_MMX(Src,srcx_16,srcy_16,&pDstLinex

55、);/border srcx_16+=xrIntFloat_16; srcy_16+=yrIntFloat_16; (TUInt8*&)pDstLine)+=Dst.byte_width; for (y=border_y1;yDst.height;+y) long srcx_16=csDErrorX; for (unsigned long x=0;xdst_width;+x) Bilinear_Border_MMX(Src,srcx_16,srcy_16,&pDstLinex); /border srcx_16+=xrIntFloat_16; srcy_16+=yrIntFloat_16; (

56、TUInt8*&)pDstLine)+=Dst.byte_width; asm emms/速度测试:/=/ PicZoom_Bilinear_MMX_Ex 157.0 fps/I: 把测试成绩放在一起：/CPU: AMD64x2 4200+(2.37G) zoom 800*600 to 1024*768/=/ StretchBlt 232.7 fps / PicZoom3_SSE 711.7 fps/ PicZoom_BilInear0 8.3 fps/ PicZoom_BilInear1 17.7 fps/ PicZoom_BilInear2 43.4 fps/ PicZoom_BilIne

57、ar_Common 65.3 fps/ PicZoom_BilInear_MMX 132.9 fps/ PicZoom_BilInear_MMX_Ex 157.0 fps/补充Intel Core2 4400上的测试成绩:/CPU: Intel Core2 4400(2.00G) zoom 800*600 to 1024*768/=/ PicZoom3_SSE 1099.7 fps / PicZoom_BilInear0 10.7 fps/ PicZoom_BilInear1 24.2 fps/ PicZoom_BilInear2 54.3 fps/ PicZoom_BilInear_Comm

58、on 59.8 fps/ PicZoom_BilInear_MMX 118.4 fps/ PicZoom_BilInear_MMX_Ex 142.9 fps/三次卷积插值J: 三次卷积插值原理二次线性插值缩放出的图片很多时候让人感觉变得模糊(术语叫低通滤波)，特别是在放大的时候；使用三次卷积插值来改善插值结果；三次卷积插值考虑映射点周围16个点(4x4)的颜色来计算最终的混合颜色，如图；P(0,0)所在像素为映射的点，加上它周围的15个点，按一定系数混合得到最终输出结果；混合公式参见PicZoom_ThreeOrder0的实现； 插值曲线公式sin(x*PI)/(x*PI),如图:三次卷积插值

59、曲线sin(x*PI)/(x*PI) （其中PI=3.1415926.）K: 三次卷积插值缩放算法的一个参考实现：PicZoom_ThreeOrder0该函数并没有做过多的优化，只是一个简单的浮点实现版本; inline double SinXDivX(double x) /该函数计算插值曲线sin(x*PI)/(x*PI)的值 /PI=3.1415926535897932385; /下面是它的近似拟合表达式 const float a = -1; /a还可以取 a=-2,-1,-0.75,-0.5等等，起到调节锐化或模糊程度的作用 if (x0) x=-x; /x=abs(x); doubl

60、e x2=x*x; double x3=x2*x; if (x=1) return (a+2)*x3 - (a+3)*x2 + 1; else if (x=2) return a*x3 - (5*a)*x2 + (8*a)*x - (4*a); else return 0; inline TUInt8 border_color(long Color) if (Color=255) return 255; else return Color; void ThreeOrder0(const TPicRegion& pic,const float fx,const float fy,TARGB32*