图像缩放算法（中篇）

最新推荐文章于 2023-10-17 00:53:46 发布
最新推荐文章于 2023-10-17 00:53:46 发布
阅读量1.5k 收藏 3
点赞数
分类专栏： 图像缩放
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hantoy/article/details/105858269
版权

图像缩放算法（中篇）

=================================

转载别人的，但是这篇文章写得确实太好了，所以想分享出来。

原文地址：http://blog.chinaunix.net/uid-22915173-id-2185545.html

摘要:首先给出一个基本的图像缩放算法，然后一步一步的优化其速度和缩放质量；

高质量的快速的图像缩放 全文 分为:
上篇 近邻取样插值和其速度优化
中篇 二次线性插值和三次卷积插值
下篇 三次线性插值和MipMap链

正文：
为了便于讨论，这里只处理32bit的ARGB颜色；
代码使用C++;涉及到汇编优化的时候假定为x86平台;使用的编译器为vc2005;
为了代码的可读性,没有加入异常处理代码;
测试使用的CPU为AMD64x2 4200+(2.37G) 和 Intel Core2 4400(2.00G);

速度测试说明:
只测试内存数据到内存数据的缩放
测试图片都是800600缩放到1024768; fps表示每秒钟的帧数,值越大表示函数越快

A:近邻取样插值、二次线性插值、三次卷积插值 缩放效果对比

原图 近邻取样缩放到0.6倍 近邻取样缩放到1.6倍

二次线性插值缩放到0.6倍 二次线性插值缩放到1.6倍

三次卷积插值缩放到0.6倍 三次卷积插值缩放到1.6倍

原图 近邻取样缩放到8倍 二次线性插值缩放到8倍 三次卷积插值缩放到8倍 二次线性插值(近似公式)

近邻取样插值缩放简单、速度快，但很多时候缩放出的图片质量比较差(特别是对于人物、景色等),
图片的缩放有比较明显的锯齿；使用二次或更高次插值有利于改善缩放效果；

B: 首先定义图像数据结构:

#defineasm __asm

typedef unsignedcharTUInt8;// [0…255]
structTARGB32//32 bit color
{
TUInt8 b,g,r,a;//a is alpha
};

structTPicRegion//一块颜色数据区的描述，便于参数传递
{
TARGB32* pdata;//颜色数据首地址
longbyte_width;//一行数据的物理宽度(字节宽度)；
//abs(byte_width)有可能大于等于width*sizeof(TARGB32);
longwidth;//像素宽度
longheight;//像素高度
};

//那么访问一个点的函数可以写为：
inline TARGB32& Pixels(constTPicRegion& pic,constlongx,constlongy)
{
return( (TARGB32*)((TUInt8*)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=DxSW/DW Sy=DySH/DH

聚焦看看(Sx,Sy)坐标点(Sx,Sy为浮点数)附近的情况；

对于近邻取样插值的缩放算法，直接取Color0颜色作为缩放后点的颜色；
二次线性插值需要考虑(Sx,Sy)坐标点周围的4个颜色值Color0\Color1\Color2\Color3，
把(Sx,Sy)到A\B\C\D坐标点的距离作为系数来把4个颜色混合出缩放后点的颜色；
( u=Sx-floor(Sx); v=Sy-floor(Sy); 说明:floor函数的返回值为小于等于参数的最大整数 )
二次线性插值公式为:
tmpColor0=Color0*(1-u) + Color2u;
tmpColor1=Color1(1-u) + Color3u;
DstColor =tmpColor0(1-v) + tmpColor2*v;

展开公式为:
pm0=(1-u)(1-v);
pm1=v(1-u);
pm2=u*(1-v);
pm3=uv;
则颜色混合公式为:
DstColor = Color0pm0 + Color1pm1 + Color2pm2 + Color3*pm3;

参数函数图示：

二次线性插值函数图示

对于上面的公式，它将图片向右下各移动了半个像素，需要对此做一个修正；
=> Sx=(Dx+0.5)*SW/DW-0.5; Sy=(Dy+0.5)*SH/DH-0.5;
而实际的程序,还需要考虑到边界(访问源图片可能超界)对于算法的影响,边界的处理可能有各种
方案(不处理边界或边界回绕或边界饱和或边界映射或用背景颜色混合等;文章中默认使用边界饱和来处理超界);
比如:边界饱和函数:

//访问一个点的函数，(x,y)坐标可能超出图片边界； //边界处理模式:边界饱和
inline TARGB32 Pixels_Bound(constTPicRegion& pic,longx,longy)
{
//assert((pic.width>0)&&(pic.height>0));
boolIsInPic=true;
if(x<0) {x=0; IsInPic=false; }elseif(x>=pic.width ) {x=pic.width -1; IsInPic=false; }
if(y<0) {y=0; IsInPic=false; }elseif(y>=pic.height) {y=pic.height-1; IsInPic=false; }
TARGB32 result=Pixels(pic,x,y);
if(!IsInPic) result.a=0;
returnresult;
}

D: 二次线性插值缩放算法的一个参考实现：PicZoom_BilInear0
该函数并没有做什么优化，只是一个简单的浮点实现版本；

inlinevoidBilinear0(constTPicRegion& pic,floatfx,floatfy,TARGB32* result)
{
longx=(long)fx;if(x>fx) --x;//x=floor(fx);
longy=(long)fy;if(y>fy) --y;//y=floor(fy);

TARGB32 Color0=Pixels_Bound(pic,x,y);
TARGB32 Color2=Pixels_Bound(pic,x+1,y);
TARGB32 Color1=Pixels_Bound(pic,x,y+1);
TARGB32 Color3=Pixels_Bound(pic,x+1,y+1);

floatu=fx-x;
floatv=fy-y;
floatpm3=uv;
floatpm2=u(1-v);
floatpm1=v*(1-u);
floatpm0=(1-u)*(1-v);

result->a=(pm0Color0.a+pm1Color1.a+pm2Color2.a+pm3Color3.a);
result->r=(pm0Color0.r+pm1Color1.r+pm2Color2.r+pm3Color3.r);
result->g=(pm0Color0.g+pm1Color1.g+pm2Color2.g+pm3Color3.g);
result->b=(pm0Color0.b+pm1Color1.b+pm2Color2.b+pm3Color3.b);
}

voidPicZoom_Bilinear0(constTPicRegion& Dst,constTPicRegion& Src)
{
if( (0 == Dst.width)||(0 == Dst.height)
||(0 == Src.width)||(0 == Src.height))return;

unsignedlongdst_width=Dst.width;
TARGB32* pDstLine=Dst.pdata;
for(unsignedlongy=0;y
{

floatsrcy=(y+0.4999999)*Src.height/Dst.height-0.5;
for(unsignedlongx=0;x
{

floatsrcx=(x+0.4999999)Src.width/Dst.width-0.5;
Bilinear0(Src,srcx,srcy,&pDstLine[x]);
}
((TUInt8&)pDstLine)+=Dst.byte_width;
}
}

//速度测试:
//==============================================================================
// PicZoom_BilInear0 8.3 fps

E: 把PicZoom_BilInear0的浮点计算改写为定点数实现：PicZoom_BilInear1

inlinevoidBilinear1(constTPicRegion& pic,constlongx_16,constlongy_16,TARGB32* result)
{
longx=x_16>>16;
longy=y_16>>16;
TARGB32 Color0=Pixels_Bound(pic,x,y);
TARGB32 Color2=Pixels_Bound(pic,x+1,y);
TARGB32 Color1=Pixels_Bound(pic,x,y+1);
TARGB32 Color3=Pixels_Bound(pic,x+1,y+1);

unsignedlongu_8=(x_16 & 0xFFFF)>>8;
unsignedlongv_8=(y_16 & 0xFFFF)>>8;
unsignedlongpm3_16=(u_8v_8);
unsignedlongpm2_16=(u_8(unsignedlong)(256-v_8));
unsignedlongpm1_16=(v_8*(unsignedlong)(256-u_8));
unsignedlongpm0_16=((256-u_8)*(256-v_8));

result->a=((pm0_16Color0.a+pm1_16Color1.a+pm2_16Color2.a+pm3_16Color3.a)>>16);
result->r=((pm0_16Color0.r+pm1_16Color1.r+pm2_16Color2.r+pm3_16Color3.r)>>16);
result->g=((pm0_16Color0.g+pm1_16Color1.g+pm2_16Color2.g+pm3_16Color3.g)>>16);
result->b=((pm0_16Color0.b+pm1_16Color1.b+pm2_16Color2.b+pm3_16Color3.b)>>16);
}

voidPicZoom_Bilinear1(constTPicRegion& Dst,constTPicRegion& Src)
{
if( (0 == Dst.width)||(0 == Dst.height)
||(0 == Src.width)||(0 == Src.height))return;

longxrIntFloat_16=((Src.width)<<16)/Dst.width+1;
longyrIntFloat_16=((Src.height)<<16)/Dst.height+1;
constlongcsDErrorX=-(1<<15)+(xrIntFloat_16>>1);
constlongcsDErrorY=-(1<<15)+(yrIntFloat_16>>1);

unsignedlongdst_width=Dst.width;

TARGB32* pDstLine=Dst.pdata;
longsrcy_16=csDErrorY;
longy;
for(y=0;y
{

longsrcx_16=csDErrorX;
for(unsignedlongx=0;x
{
Bilinear1(Src,srcx_16,srcy_16,&pDstLine[x]);
//border
srcx_16+=xrIntFloat_16;
}
srcy_16+=yrIntFloat_16;
((TUInt8*&)pDstLine)+=Dst.byte_width;
}
}


//速度测试:
//==============================================================================
// PicZoom_BilInear1 17.7 fps

F: 二次线性插值需要考略边界访问超界的问题，我们可以将边界区域和内部区域分开处理，这样就可以优化内部的插值实现函数了：比如不需要判断访问超界、减少颜色数据复制、减少一些不必要的重复坐标计算等等

inlinevoidBilinear2_Fast(TARGB32* PColor0,TARGB32* PColor1,unsignedlongu_8,unsignedlongv_8,TARGB32* result)
{
unsignedlongpm3_16=u_8*v_8;
unsignedlongpm2_16=(u_8<<8)-pm3_16;
unsignedlongpm1_16=(v_8<<8)-pm3_16;
unsignedlongpm0_16=(1<<16)-pm1_16-pm2_16-pm3_16;

result->a=((pm0_16PColor0[0].a+pm2_16PColor0[1].a+pm1_16PColor1[0].a+pm3_16PColor1[1].a)>>16);
result->r=((pm0_16PColor0[0].r+pm2_16PColor0[1].r+pm1_16PColor1[0].r+pm3_16PColor1[1].r)>>16);
result->g=((pm0_16PColor0[0].g+pm2_16PColor0[1].g+pm1_16PColor1[0].g+pm3_16PColor1[1].g)>>16);
result->b=((pm0_16PColor0[0].b+pm2_16PColor0[1].b+pm1_16PColor1[0].b+pm3_16PColor1[1].b)>>16);
}

inlinevoidBilinear2_Border(constTPicRegion& pic,constlongx_16,constlongy_16,TARGB32* result)
{
longx=(x_16>>16);
longy=(y_16>>16);
unsignedlongu_16=((unsignedshort)(x_16));
unsignedlongv_16=((unsignedshort)(y_16));

TARGB32 pixel[4];
pixel[0]=Pixels_Bound(pic,x,y);
pixel[1]=Pixels_Bound(pic,x+1,y);
pixel[2]=Pixels_Bound(pic,x,y+1);
pixel[3]=Pixels_Bound(pic,x+1,y+1);

Bilinear2_Fast(&pixel[0],&pixel[2],u_16>>8,v_16>>8,result);
}

voidPicZoom_Bilinear2(constTPicRegion& Dst,constTPicRegion& Src)
{
if( (0 == Dst.width)||(0 == Dst.height)
||(0 == Src.width)||(0 == Src.height))return;

longxrIntFloat_16=((Src.width)<<16)/Dst.width+1;
longyrIntFloat_16=((Src.height)<<16)/Dst.height+1;
constlongcsDErrorX=-(1<<15)+(xrIntFloat_16>>1);
constlongcsDErrorY=-(1<<15)+(yrIntFloat_16>>1);

unsignedlongdst_width=Dst.width;

//计算出需要特殊处理的边界
longborder_y0=-csDErrorY/yrIntFloat_16+1;//y0+yyr>=0; y0=csDErrorY => y>=-csDErrorY/yr
if(border_y0>=Dst.height) border_y0=Dst.height;
longborder_x0=-csDErrorX/xrIntFloat_16+1;
if(border_x0>=Dst.width ) border_x0=Dst.width;
longborder_y1=(((Src.height-2)<<16)-csDErrorY)/yrIntFloat_16+1;//y0+yyr<=(height-2) => y<=(height-2-csDErrorY)/yr
if(border_y1 longborder_x1=(((Src.width-2)<<16)-csDErrorX)/xrIntFloat_16+1;
if(border_x1
TARGB32* pDstLine=Dst.pdata;
longSrc_byte_width=Src.byte_width;
longsrcy_16=csDErrorY;
longy;
for(y=0;y
{

longsrcx_16=csDErrorX;
for(unsignedlongx=0;x
{
Bilinear2_Border(Src,srcx_16,srcy_16,&pDstLine[x]);
//border
srcx_16+=xrIntFloat_16;
}
srcy_16+=yrIntFloat_16;
((TUInt8*&)pDstLine)+=Dst.byte_width;
}
for(y=border_y0;y
{

longsrcx_16=csDErrorX;
longx;
for(x=0;x
{
Bilinear2_Border(Src,srcx_16,srcy_16,&pDstLine[x]);
//border
srcx_16+=xrIntFloat_16;
}

{
unsignedlongv_8=(srcy_16 & 0xFFFF)>>8;
TARGB32* PSrcLineColor= (TARGB32*)((TUInt8*)(Src.pdata)+Src_byte_width*(srcy_16>>16)) ;
for(unsignedlongx=border_x0;x
{
TARGB32* PColor0=&PSrcLineColor[srcx_16>>16];
TARGB32* PColor1=(TARGB32*)((TUInt8*)(PColor0)+Src_byte_width);
Bilinear2_Fast(PColor0,PColor1,(srcx_16 & 0xFFFF)>>8,v_8,&pDstLine[x]);
srcx_16+=xrIntFloat_16;
}
}

for(x=border_x1;x
{
Bilinear2_Border(Src,srcx_16,srcy_16,&pDstLine[x]);
//border
srcx_16+=xrIntFloat_16;
}
srcy_16+=yrIntFloat_16;
((TUInt8*&)pDstLine)+=Dst.byte_width;
}
for(y=border_y1;y
{

longsrcx_16=csDErrorX;
for(unsignedlongx=0;x
{
Bilinear2_Border(Src,srcx_16,srcy_16,&pDstLine[x]);
//border
srcx_16+=xrIntFloat_16;
}
srcy_16+=yrIntFloat_16;
((TUInt8*&)pDstLine)+=Dst.byte_width;
}
}

//速度测试:
//==============================================================================
// PicZoom_BilInear2 43.4 fps

(F’补充:
如果不想处理边界访问超界问题，可以考虑扩大源图片的尺寸，加一个边框 (“哨兵”优化)；
这样插值算法就不用考虑边界问题了，程序写起来也简单很多!
如果对缩放结果的边界像素级精度要求不是太高，我还有一个方案，一个稍微改变的缩放公式:
Sx=Dx*(SW-1)/DW； Sy=Dy*(SH-1)/DH； (源图片宽和高:SW>=2;SH>=2)
证明这个公式不会造成内存访问超界:
要求Dx=DW-1时: sx+1=int( (dw-1)/dw*(dw-1) ) +1 <= (sw-1)
有: int( (sw-1)(dw-1)/dw ) <=sw-2
(sw-1)(dw-1)/dw <(sw-1)
(dw-1) /dw<1
(dw-1)
比如，按这个公式的一个简单实现: (缩放效果见前面的"二次线性插值(近似公式)"图示)

voidPicZoom_ftBilinear_Common(constTPicRegion& Dst,constTPicRegion& Src)
{
if( (0 == Dst.width)||(0 == Dst.height)
||(2>Src.width)||(2>Src.height))return;

longxrIntFloat_16=((Src.width-1)<<16)/Dst.width;
longyrIntFloat_16=((Src.height-1)<<16)/Dst.height;

unsignedlongdst_width=Dst.width;
longSrc_byte_width=Src.byte_width;
TARGB32* pDstLine=Dst.pdata;
longsrcy_16=0;
for(unsignedlongy=0;y
{
unsigned
longv_8=(srcy_16 & 0xFFFF)>>8;
TARGB32* PSrcLineColor= (TARGB32*)((TUInt8*)(Src.pdata)+Src_byte_width*(srcy_16>>16)) ;
longsrcx_16=0;
for(unsignedlongx=0;x
{
TARGB32* PColor0=&PSrcLineColor[srcx_16>>16];
Bilinear_Fast_Common(PColor0,(TARGB32*)((TUInt8*)(PColor0)+Src_byte_width),(srcx_16 & 0xFFFF)>>8,v_8,&pDstLine[x]);
srcx_16+=xrIntFloat_16;
}
srcy_16+=yrIntFloat_16;
((TUInt8*&)pDstLine)+=Dst.byte_width;
}
}

)

G:利用单指令多数据处理的MMX指令一般都可以加快颜色的运算；在使用MMX改写之前，利用
32bit寄存器(或变量)来模拟单指令多数据处理；
数据储存原理:一个颜色数据分量只有一个字节,用2个字节来储存单个颜色分量的计算结果，
对于很多颜色计算来说精度就够了；那么一个32bit寄存器(或变量)就可以储存2个计算出的
临时颜色分量；从而达到了单个指令两路数据处理的目的;
单个指令两路数据处理的计算:
乘法： ((0x00AAa)<<16) | (0x00BBa) = 0x00AA00BB * a
可见只要保证0x00AAa和0x00BBa都小于(1<<16)那么乘法可以直接使用无符号数乘法了
加法: ((0x00AA+0x00CC)<<16) | (0x00BB+0x00DD) = 0x00AA00BB + 0x00CC00DD
可见只要0x00AA+0x00CC和0x00BB+0x00DD小于(1<<16)那么加法可以直接使用无符号数加法了
(移位、减法等稍微复杂一点,因为这里没有用到就不推倒运算公式了)

inlinevoidBilinear_Fast_Common(TARGB32* PColor0,TARGB32* PColor1,unsignedlongu_8,unsignedlongv_8,TARGB32* result)
{
unsignedlongpm3_8=(u_8*v_8)>>8;
unsignedlongpm2_8=u_8-pm3_8;
unsignedlongpm1_8=v_8-pm3_8;
unsignedlongpm0_8=256-pm1_8-pm2_8-pm3_8;

unsignedlongColor=(unsignedlong)(PColor0);
unsignedlongBR=(Color & 0x00FF00FF)*pm0_8;
unsignedlongGA=((Color & 0xFF00FF00)>>8)pm0_8;
Color=((unsignedlong)(PColor0))[1];
GA+=((Color & 0xFF00FF00)>>8)pm2_8;
BR+=(Color & 0x00FF00FF)pm2_8;
Color=(unsignedlong)(PColor1);
GA+=((Color & 0xFF00FF00)>>8)*pm1_8;
BR+=(Color & 0x00FF00FF)pm1_8;
Color=((unsignedlong)(PColor1))[1];
GA+=((Color & 0xFF00FF00)>>8)*pm3_8;
BR+=(Color & 0x00FF00FF)*pm3_8;

(unsignedlong)(result)=(GA & 0xFF00FF00)|((BR & 0xFF00FF00)>>8);
}

inlinevoidBilinear_Border_Common(constTPicRegion& pic,constlongx_16,constlongy_16,TARGB32* result)
{
longx=(x_16>>16);
longy=(y_16>>16);
unsignedlongu_16=((unsignedshort)(x_16));
unsignedlongv_16=((unsignedshort)(y_16));

TARGB32 pixel[4];
pixel[0]=Pixels_Bound(pic,x,y);
pixel[1]=Pixels_Bound(pic,x+1,y);
pixel[2]=Pixels_Bound(pic,x,y+1);
pixel[3]=Pixels_Bound(pic,x+1,y+1);

Bilinear_Fast_Common(&pixel[0],&pixel[2],u_16>>8,v_16>>8,result);
}

voidPicZoom_Bilinear_Common(constTPicRegion& Dst,constTPicRegion& Src)
{
if( (0 == Dst.width)||(0 == Dst.height)
||(0 == Src.width)||(0 == Src.height))return;

longxrIntFloat_16=((Src.width)<<16)/Dst.width+1;
longyrIntFloat_16=((Src.height)<<16)/Dst.height+1;
constlongcsDErrorX=-(1<<15)+(xrIntFloat_16>>1);
constlongcsDErrorY=-(1<<15)+(yrIntFloat_16>>1);

unsignedlongdst_width=Dst.width;

//计算出需要特殊处理的边界
longborder_y0=-csDErrorY/yrIntFloat_16+1;//y0+yyr>=0; y0=csDErrorY => y>=-csDErrorY/yr
if(border_y0>=Dst.height) border_y0=Dst.height;
longborder_x0=-csDErrorX/xrIntFloat_16+1;
if(border_x0>=Dst.width ) border_x0=Dst.width;
longborder_y1=(((Src.height-2)<<16)-csDErrorY)/yrIntFloat_16+1;//y0+yyr<=(height-2) => y<=(height-2-csDErrorY)/yr
if(border_y1 longborder_x1=(((Src.width-2)<<16)-csDErrorX)/xrIntFloat_16+1;
if(border_x1
TARGB32* pDstLine=Dst.pdata;
longSrc_byte_width=Src.byte_width;
longsrcy_16=csDErrorY;
longy;
for(y=0;y
{

longsrcx_16=csDErrorX;
for(unsignedlongx=0;x
{
Bilinear_Border_Common(Src,srcx_16,srcy_16,&pDstLine[x]);
//border
srcx_16+=xrIntFloat_16;
}
srcy_16+=yrIntFloat_16;
((TUInt8*&)pDstLine)+=Dst.byte_width;
}
for(y=border_y0;y
{

longsrcx_16=csDErrorX;
longx;
for(x=0;x
{
Bilinear_Border_Common(Src,srcx_16,srcy_16,&pDstLine[x]);
//border
srcx_16+=xrIntFloat_16;
}

{
unsignedlongv_8=(srcy_16 & 0xFFFF)>>8;
TARGB32* PSrcLineColor= (TARGB32*)((TUInt8*)(Src.pdata)+Src_byte_width*(srcy_16>>16)) ;
for(unsignedlongx=border_x0;x
{
TARGB32* PColor0=&PSrcLineColor[srcx_16>>16];
TARGB32* PColor1=(TARGB32*)((TUInt8*)(PColor0)+Src_byte_width);
Bilinear_Fast_Common(PColor0,PColor1,(srcx_16 & 0xFFFF)>>8,v_8,&pDstLine[x]);
srcx_16+=xrIntFloat_16;
}
}

for(x=border_x1;x
{
Bilinear_Border_Common(Src,srcx_16,srcy_16,&pDstLine[x]);
//border
srcx_16+=xrIntFloat_16;
}
srcy_16+=yrIntFloat_16;
((TUInt8*&)pDstLine)+=Dst.byte_width;
}
for(y=border_y1;y
{

longsrcx_16=csDErrorX;
for(unsignedlongx=0;x
{
Bilinear_Border_Common(Src,srcx_16,srcy_16,&pDstLine[x]);
//border
srcx_16+=xrIntFloat_16;
}
srcy_16+=yrIntFloat_16;
((TUInt8*&)pDstLine)+=Dst.byte_width;
}
}

//速度测试:
//==============================================================================
// PicZoom_BilInear_Common 65.3 fps

H:使用MMX指令改写:PicZoom_Bilinear_MMX

inlinevoidBilinear_Fast_MMX(TARGB32* PColor0,TARGB32* PColor1,unsignedlongu_8,unsignedlongv_8,TARGB32* result)
{
asm
{
MOVD MM6,v_8
MOVD MM5,u_8
mov edx,PColor0
mov eax,PColor1
PXOR mm7,mm7

MOVD MM2,dword ptr [eax]
MOVD MM0,dword ptr [eax+4]
PUNPCKLWD MM5,MM5
PUNPCKLWD MM6,MM6
MOVD MM3,dword ptr [edx]
MOVD MM1,dword ptr [edx+4]
PUNPCKLDQ MM5,MM5
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
PUNPCKLDQ MM6,MM6
PADDw MM0,MM2
PADDw MM1,MM3

PSRLw MM0,8
PSRLw MM1,8
PSUBw MM0,MM1
PSLLw MM1,8
PMULlw MM0,MM6
mov eax,result
PADDw MM0,MM1

PSRLw MM0,8
PACKUSwb MM0,MM7
movd [eax],MM0
//emms
}
}

voidBilinear_Border_MMX(constTPicRegion& pic,constlongx_16,constlongy_16,TARGB32* result)
{
longx=(x_16>>16);
longy=(y_16>>16);
unsignedlongu_16=((unsignedshort)(x_16));
unsignedlongv_16=((unsignedshort)(y_16));

TARGB32 pixel[4];
pixel[0]=Pixels_Bound(pic,x,y);
pixel[1]=Pixels_Bound(pic,x+1,y);
pixel[2]=Pixels_Bound(pic,x,y+1);
pixel[3]=Pixels_Bound(pic,x+1,y+1);

Bilinear_Fast_MMX(&pixel[0],&pixel[2],u_16>>8,v_16>>8,result);
}

voidPicZoom_Bilinear_MMX(constTPicRegion& Dst,constTPicRegion& Src)
{
if( (0 == Dst.width)||(0 == Dst.height)
||(0 == Src.width)||(0 == Src.height))return;

longxrIntFloat_16=((Src.width)<<16)/Dst.width+1;
longyrIntFloat_16=((Src.height)<<16)/Dst.height+1;
constlongcsDErrorX=-(1<<15)+(xrIntFloat_16>>1);
constlongcsDErrorY=-(1<<15)+(yrIntFloat_16>>1);

unsignedlongdst_width=Dst.width;

//计算出需要特殊处理的边界
longborder_y0=-csDErrorY/yrIntFloat_16+1;//y0+yyr>=0; y0=csDErrorY => y>=-csDErrorY/yr
if(border_y0>=Dst.height) border_y0=Dst.height;
longborder_x0=-csDErrorX/xrIntFloat_16+1;
if(border_x0>=Dst.width ) border_x0=Dst.width;
longborder_y1=(((Src.height-2)<<16)-csDErrorY)/yrIntFloat_16+1;//y0+yyr<=(height-2) => y<=(height-2-csDErrorY)/yr
if(border_y1 longborder_x1=(((Src.width-2)<<16)-csDErrorX)/xrIntFloat_16+1;
if(border_x1
TARGB32* pDstLine=Dst.pdata;
longSrc_byte_width=Src.byte_width;
longsrcy_16=csDErrorY;
longy;
for(y=0;y
{

longsrcx_16=csDErrorX;
for(unsignedlongx=0;x
{
Bilinear_Border_MMX(Src,srcx_16,srcy_16,&pDstLine[x]);
//border
srcx_16+=xrIntFloat_16;
}
srcy_16+=yrIntFloat_16;
((TUInt8*&)pDstLine)+=Dst.byte_width;
}
for(y=border_y0;y
{

longsrcx_16=csDErrorX;
longx;
for(x=0;x
{
Bilinear_Border_MMX(Src,srcx_16,srcy_16,&pDstLine[x]);
//border
srcx_16+=xrIntFloat_16;
}

{
unsignedlongv_8=(srcy_16 & 0xFFFF)>>8;
TARGB32* PSrcLineColor= (TARGB32*)((TUInt8*)(Src.pdata)+Src_byte_width*(srcy_16>>16)) ;
for(unsignedlongx=border_x0;x
{
TARGB32* PColor0=&PSrcLineColor[srcx_16>>16];
TARGB32* PColor1=(TARGB32*)((TUInt8*)(PColor0)+Src_byte_width);
Bilinear_Fast_MMX(PColor0,PColor1,(srcx_16 & 0xFFFF)>>8,v_8,&pDstLine[x]);
srcx_16+=xrIntFloat_16;
}
}

for(x=border_x1;x
{
Bilinear_Border_MMX(Src,srcx_16,srcy_16,&pDstLine[x]);
//border
srcx_16+=xrIntFloat_16;
}
srcy_16+=yrIntFloat_16;
((TUInt8*&)pDstLine)+=Dst.byte_width;
}
for(y=border_y1;y
{

longsrcx_16=csDErrorX;
for(unsignedlongx=0;x
{
Bilinear_Border_MMX(Src,srcx_16,srcy_16,&pDstLine[x]);
//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_Ex

voidPicZoom_Bilinear_MMX_Ex(constTPicRegion& Dst,constTPicRegion& Src)
{
if( (0 == Dst.width)||(0 == Dst.height)
||(0 == Src.width)||(0 == Src.height))return;

longxrIntFloat_16=((Src.width)<<16)/Dst.width+1;
longyrIntFloat_16=((Src.height)<<16)/Dst.height+1;
constlongcsDErrorX=-(1<<15)+(xrIntFloat_16>>1);
constlongcsDErrorY=-(1<<15)+(yrIntFloat_16>>1);

unsignedlongdst_width=Dst.width;

//计算出需要特殊处理的边界
longborder_y0=-csDErrorY/yrIntFloat_16+1;//y0+yyr>=0; y0=csDErrorY => y>=-csDErrorY/yr
if(border_y0>=Dst.height) border_y0=Dst.height;
longborder_x0=-csDErrorX/xrIntFloat_16+1;
if(border_x0>=Dst.width ) border_x0=Dst.width;
longborder_y1=(((Src.height-2)<<16)-csDErrorY)/yrIntFloat_16+1;//y0+yyr<=(height-2) => y<=(height-2-csDErrorY)/yr
if(border_y1 longborder_x1=(((Src.width-2)<<16)-csDErrorX)/xrIntFloat_16+1;
if(border_x1
TARGB32* pDstLine=Dst.pdata;
longSrc_byte_width=Src.byte_width;
longsrcy_16=csDErrorY;
longy;
for(y=0;y
{

longsrcx_16=csDErrorX;
for(unsignedlongx=0;x
{
Bilinear_Border_MMX(Src,srcx_16,srcy_16,&pDstLine[x]);
//border
srcx_16+=xrIntFloat_16;
}
srcy_16+=yrIntFloat_16;
((TUInt8*&)pDstLine)+=Dst.byte_width;
}

for(y=border_y0;y
{

longsrcx_16=csDErrorX;
longx;
for(x=0;x
{
Bilinear_Border_MMX(Src,srcx_16,srcy_16,&pDstLine[x]);
//border
srcx_16+=xrIntFloat_16;
}

{
longdst_width_fast=border_x1-border_x0;
if(dst_width_fast>0)
{
unsignedlongv_8=(srcy_16 & 0xFFFF)>>8;
TARGB32* PSrcLineColor= (TARGB32*)((TUInt8*)(Src.pdata)+Src_byte_width*(srcy_16>>16)) ;
TARGB32* PSrcLineColorNext= (TARGB32*)((TUInt8*)(PSrcLineColor)+Src_byte_width) ;
TARGB32* pDstLine_Fast=&pDstLine[border_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
mov 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_16>>16

MOVD MM2,dword ptr [ecx+eax4]
MOVD MM0,dword ptr [ecx+eax4+4]
PUNPCKLWD MM5,MM5
MOVD MM3,dword ptr [esi+eax4]
MOVD MM1,dword ptr [esi+eax4+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 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;x
{
Bilinear_Border_MMX(Src,srcx_16,srcy_16,&pDstLine[x]);
//border
srcx_16+=xrIntFloat_16;
}
srcy_16+=yrIntFloat_16;
((TUInt8*&)pDstLine)+=Dst.byte_width;
}
for(y=border_y1;y
{

longsrcx_16=csDErrorX;
for(unsignedlongx=0;x
{
Bilinear_Border_MMX(Src,srcx_16,srcy_16,&pDstLine[x]);
//border
srcx_16+=xrIntFloat_16;
}
srcy_16+=yrIntFloat_16;
((TUInt8*&)pDstLine)+=Dst.byte_width;
}
asm emms
}

//速度测试:
//==============================================================================
// PicZoom_Bilinear_MMX_Ex 157.0 fps

I: 把测试成绩放在一起：


//CPU: AMD64x2 4200+(2.37G) zoom 800600 to 1024768
//==============================================================================
// 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_BilInear_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 800600 to 1024768
//==============================================================================
// PicZoom3_SSE 1099.7 fps
//
// PicZoom_BilInear0 10.7 fps
// PicZoom_BilInear1 24.2 fps
// PicZoom_BilInear2 54.3 fps
// PicZoom_BilInear_Common 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(xPI)/(xPI),如图:

三次卷积插值曲线sin(xPI)/(xPI) （其中PI=3.1415926…）

K:三次卷积插值缩放算法的一个参考实现：PicZoom_ThreeOrder0
该函数并没有做过多的优化，只是一个简单的浮点实现版本;

inlinedoubleSinXDivX(doublex)
{
//该函数计算插值曲线sin(xPI)/(xPI)的值 //PI=3.1415926535897932385;
//下面是它的近似拟合表达式
constfloata = -1;//a还可以取 a=-2,-1,-0.75,-0.5等等，起到调节锐化或模糊程度的作用

if(x<0) x=-x;//x=abs(x);
doublex2=xx;
doublex3=x2x;
if(x<=1)
return(a+2)x3 - (a+3)x2 + 1;
elseif(x<=2)
returnax3 - (5a)x2 + (8a)x - (4a);
else
return0;
}

inline TUInt8 border_color(longColor)
{
if(Color<=0)
return0;
elseif(Color>=255)
return255;
else
returnColor;
}

voidThreeOrder0(constTPicRegion& pic,constfloatfx,constfloatfy,TARGB32* result)
{
longx0=(long)fx;if(x0>fx) --x0;//x0=floor(fx);
longy0=(long)fy;if(y0>fy) --y0;//y0=floor(fy);
floatfu=fx-x0;
floatfv=fy-y0;

TARGB32 pixel[16];
longi,j;

for(i=0;i<4;++i)
{
for(j=0;j<4;++j)
{
longx=x0-1+j;
longy=y0-1+i;
pixel[i*4+j]=Pixels_Bound(pic,x,y);
}
}

floatafu[4],afv[4];
//
afu[0]=SinXDivX(1+fu);
afu[1]=SinXDivX(fu);
afu[2]=SinXDivX(1-fu);
afu[3]=SinXDivX(2-fu);
afv[0]=SinXDivX(1+fv);
afv[1]=SinXDivX(fv);
afv[2]=SinXDivX(1-fv);
afv[3]=SinXDivX(2-fv);

floatsR=0,sG=0,sB=0,sA=0;
for(i=0;i<4;++i)
{
floataR=0,aG=0,aB=0,aA=0;
for(longj=0;j<4;++j)
{
aA+=afu[j]pixel[i4+j].a;
aR+=afu[j]pixel[i4+j].r;
aG+=afu[j]pixel[i4+j].g;
aB+=afu[j]pixel[i4+j].b;
}
sA+=aAafv[i];
sR+=aRafv[i];
sG+=aGafv[i];
sB+=aBafv[i];
}

result->a=border_color((long)(sA+0.5));
result->r=border_color((long)(sR+0.5));
result->g=border_color((long)(sG+0.5));
result->b=border_color((long)(sB+0.5));
}

voidPicZoom_ThreeOrder0(constTPicRegion& Dst,constTPicRegion& Src)
{
if( (0 == Dst.width)||(0 == Dst.height)
||(0 == Src.width)||(0 == Src.height))return;

unsignedlongdst_width=Dst.width;
TARGB32* pDstLine=Dst.pdata;
for(unsignedlongy=0;y
{

floatsrcy=(y+0.4999999)*Src.height/Dst.height-0.5;
for(unsignedlongx=0;x
{

floatsrcx=(x+0.4999999)Src.width/Dst.width-0.5;
ThreeOrder0(Src,srcx,srcy,&pDstLine[x]);
}
((TUInt8&)pDstLine)+=Dst.byte_width;
}
}

//速度测试:
//==============================================================================
// PicZoom_ThreeOrder0 3.6 fps

L: 使用定点数来优化缩放函数;边界和内部分开处理；对SinXDivX做一个查找表;对border_color做一个查找表；

staticlongSinXDivX_Table_8[(2<<8)+1];
class_CAutoInti_SinXDivX_Table {
private:
void_Inti_SinXDivX_Table()
{
for(longi=0;i<=(2<<8);++i)
SinXDivX_Table_8[i]=long(0.5+256SinXDivX(i(1.0/(256))))*1;
};
public:
_CAutoInti_SinXDivX_Table() { _Inti_SinXDivX_Table(); }
};
static_CAutoInti_SinXDivX_Table __tmp_CAutoInti_SinXDivX_Table;

//颜色查表
staticTUInt8 _color_table[2563];
staticconstTUInt8 color_table=&_color_table[256];
class_CAuto_inti_color_table
{
public:
_CAuto_inti_color_table() {
for(inti=0;i<256*3;++i)
_color_table[i]=border_color(i-256);
}
};
static_CAuto_inti_color_table _Auto_inti_color_table;

voidThreeOrder_Fast_Common(constTPicRegion& pic,constlongx_16,constlongy_16,TARGB32* result)
{
unsignedlongu_8=(unsignedchar)((x_16)>>8);
unsignedlongv_8=(unsignedchar)((y_16)>>8);
constTARGB32* pixel=&Pixels(pic,(x_16>>16)-1,(y_16>>16)-1);
longpic_byte_width=pic.byte_width;

longau_8[4],av_8[4];
//
au_8[0]=SinXDivX_Table_8[(1<<8)+u_8];
au_8[1]=SinXDivX_Table_8[u_8];
au_8[2]=SinXDivX_Table_8[(1<<8)-u_8];
au_8[3]=SinXDivX_Table_8[(2<<8)-u_8];
av_8[0]=SinXDivX_Table_8[(1<<8)+v_8];
av_8[1]=SinXDivX_Table_8[v_8];
av_8[2]=SinXDivX_Table_8[(1<<8)-v_8];
av_8[3]=SinXDivX_Table_8[(2<<8)-v_8];

longsR=0,sG=0,sB=0,sA=0;
for(longi=0;i<4;++i)
{
longaA=au_8[0]*pixel[0].a + au_8[1]*pixel[1].a + au_8[2]*pixel[2].a + au_8[3]*pixel[3].a;
longaR=au_8[0]*pixel[0].r + au_8[1]*pixel[1].r + au_8[2]*pixel[2].r + au_8[3]*pixel[3].r;
longaG=au_8[0]*pixel[0].g + au_8[1]*pixel[1].g + au_8[2]*pixel[2].g + au_8[3]pixel[3].g;
longaB=au_8[0]pixel[0].b + au_8[1]pixel[1].b + au_8[2]pixel[2].b + au_8[3]pixel[3].b;
sA+=aAav_8[i];
sR+=aRav_8[i];
sG+=aGav_8[i];
sB+=aBav_8[i];
((TUInt8&)pixel)+=pic_byte_width;
}

result->a=color_table[sA>>16];
result->r=color_table[sR>>16];
result->g=color_table[sG>>16];
result->b=color_table[sB>>16];
}

voidThreeOrder_Border_Common(constTPicRegion& pic,constlongx_16,constlongy_16,TARGB32* result)
{
longx0_sub1=(x_16>>16)-1;
longy0_sub1=(y_16>>16)-1;
unsignedlongu_16_add1=((unsignedshort)(x_16))+(1<<16);
unsignedlongv_16_add1=((unsignedshort)(y_16))+(1<<16);

TARGB32 pixel[16];
longi;

for(i=0;i<4;++i)
{
longy=y0_sub1+i;
pixel[i4+0]=Pixels_Bound(pic,x0_sub1+0,y);
pixel[i4+1]=Pixels_Bound(pic,x0_sub1+1,y);
pixel[i4+2]=Pixels_Bound(pic,x0_sub1+2,y);
pixel[i4+3]=Pixels_Bound(pic,x0_sub1+3,y);
}

TPicRegion npic;
npic.pdata =&pixel[0];
npic.byte_width=4*sizeof(TARGB32);
//npic.width =4;
//npic.height =4;
ThreeOrder_Fast_Common(npic,u_16_add1,v_16_add1,result);
}

voidPicZoom_ThreeOrder_Common(constTPicRegion& Dst,constTPicRegion& Src)
{
if( (0 == Dst.width)||(0 == Dst.height)
||(0 == Src.width)||(0 == Src.height))return;

longxrIntFloat_16=((Src.width)<<16)/Dst.width+1;
longyrIntFloat_16=((Src.height)<<16)/Dst.height+1;
constlongcsDErrorX=-(1<<15)+(xrIntFloat_16>>1);
constlongcsDErrorY=-(1<<15)+(yrIntFloat_16>>1);

unsignedlongdst_width=Dst.width;

//计算出需要特殊处理的边界
longborder_y0=((1<<16)-csDErrorY)/yrIntFloat_16+1;//y0+yyr>=1; y0=csDErrorY => y>=(1-csDErrorY)/yr
if(border_y0>=Dst.height) border_y0=Dst.height;
longborder_x0=((1<<16)-csDErrorX)/xrIntFloat_16+1;
if(border_x0>=Dst.width ) border_x0=Dst.width;
longborder_y1=(((Src.height-3)<<16)-csDErrorY)/yrIntFloat_16+1;//y0+yyr<=(height-3) => y<=(height-3-csDErrorY)/yr
if(border_y1 longborder_x1=(((Src.width-3)<<16)-csDErrorX)/xrIntFloat_16+1;;
if(border_x1
TARGB32* pDstLine=Dst.pdata;
longsrcy_16=csDErrorY;
longy;
for(y=0;y
{

longsrcx_16=csDErrorX;
for(unsignedlongx=0;x
{
ThreeOrder_Border_Common(Src,srcx_16,srcy_16,&pDstLine[x]);
//border
srcx_16+=xrIntFloat_16;
}
srcy_16+=yrIntFloat_16;
((TUInt8*&)pDstLine)+=Dst.byte_width;
}
for(y=border_y0;y
{

longsrcx_16=csDErrorX;
longx;
for(x=0;x
{
ThreeOrder_Border_Common(Src,srcx_16,srcy_16,&pDstLine[x]);
//border
srcx_16+=xrIntFloat_16;
}
for(x=border_x0;x
{
ThreeOrder_Fast_Common(Src,srcx_16,srcy_16,&pDstLine[x]);
//fast !
srcx_16+=xrIntFloat_16;
}
for(x=border_x1;x
{
ThreeOrder_Border_Common(Src,srcx_16,srcy_16,&pDstLine[x]);
//border
srcx_16+=xrIntFloat_16;
}
srcy_16+=yrIntFloat_16;
((TUInt8*&)pDstLine)+=Dst.byte_width;
}
for(y=border_y1;y
{

longsrcx_16=csDErrorX;
for(unsignedlongx=0;x
{
ThreeOrder_Border_Common(Src,srcx_16,srcy_16,&pDstLine[x]);
//border
srcx_16+=xrIntFloat_16;
}
srcy_16+=yrIntFloat_16;
((TUInt8*&)pDstLine)+=Dst.byte_width;
}
}

//速度测试:
//==============================================================================
// PicZoom_ThreeOrder_Common 16.9 fps

M: 用MMX来优化ThreeOrder_Common函数:ThreeOrder_MMX

typedef unsignedlongTMMXData32;
staticTMMXData32 SinXDivX_Table_MMX[(2<<8)+1];
class_CAutoInti_SinXDivX_Table_MMX {
private:
void_Inti_SinXDivX_Table_MMX()
{
for(longi=0;i<=(2<<8);++i)
{
unsignedshortt=long(0.5+(1<<14)SinXDivX(i(1.0/(256))));
unsignedlongtl=t | (((unsignedlong)t)<<16);
SinXDivX_Table_MMX[i]=tl;
}
};
public:
_CAutoInti_SinXDivX_Table_MMX() { _Inti_SinXDivX_Table_MMX(); }
};
static_CAutoInti_SinXDivX_Table_MMX __tmp_CAutoInti_SinXDivX_Table_MMX;

void__declspec(naked) _private_ThreeOrder_Fast_MMX()
{
asm
{
movd mm1,dword ptr [edx]
movd mm2,dword ptr [edx+4]
movd mm3,dword ptr [edx+8]
movd mm4,dword ptr [edx+12]
movd mm5,dword ptr [(offset SinXDivX_Table_MMX)+2564+eax4]
movd mm6,dword ptr [(offset SinXDivX_Table_MMX)+eax4]
punpcklbw mm1,mm7
punpcklbw mm2,mm7
punpcklwd mm5,mm5
punpcklwd mm6,mm6
psllw mm1,7
psllw mm2,7
pmulhw mm1,mm5
pmulhw mm2,mm6
punpcklbw mm3,mm7
punpcklbw mm4,mm7
movd mm5,dword ptr [(offset SinXDivX_Table_MMX)+2564+ecx4]
movd mm6,dword ptr [(offset SinXDivX_Table_MMX)+5124+ecx*4]
punpcklwd mm5,mm5
punpcklwd mm6,mm6
psllw mm3,7
psllw mm4,7
pmulhw mm3,mm5
pmulhw mm4,mm6
paddsw mm1,mm2
paddsw mm3,mm4
movd mm6,dword ptr [ebx]//v
paddsw mm1,mm3
punpcklwd mm6,mm6

pmulhw mm1,mm6
add edx,esi//+pic.byte_width
paddsw mm0,mm1

ret
}
}

inlinevoidThreeOrder_Fast_MMX(constTPicRegion& pic,constlongx_16,constlongy_16,TARGB32* result)
{
asm
{
mov ecx,pic
mov eax,y_16
mov ebx,x_16
movzx edi,ah//v_8
mov edx,[ecx+TPicRegion::pdata]
shr eax,16
mov esi,[ecx+TPicRegion::byte_width]
dec eax
movzx ecx,bh//u_8
shr ebx,16
imul eax,esi
lea edx,[edx+ebx*4-4]
add edx,eax//pixel

mov eax,ecx
neg ecx

pxor mm7,mm7//0
//mov edx,pixel
pxor mm0,mm0//result=0
//lea eax,auv_7

lea ebx,[(offset SinXDivX_Table_MMX)+2564+edi4]
call _private_ThreeOrder_Fast_MMX
lea ebx,[(offset SinXDivX_Table_MMX)+edi4]
call _private_ThreeOrder_Fast_MMX
neg edi
lea ebx,[(offset SinXDivX_Table_MMX)+2564+edi4]
call _private_ThreeOrder_Fast_MMX
lea ebx,[(offset SinXDivX_Table_MMX)+5124+edi*4]
call _private_ThreeOrder_Fast_MMX

psraw mm0,3
mov eax,result
packuswb mm0,mm7
movd [eax],mm0
//emms
}
}

voidThreeOrder_Border_MMX(constTPicRegion& pic,constlongx_16,constlongy_16,TARGB32* result)
{
unsignedlongx0_sub1=(x_16>>16)-1;
unsignedlongy0_sub1=(y_16>>16)-1;
longu_16_add1=((unsignedshort)(x_16))+(1<<16);
longv_16_add1=((unsignedshort)(y_16))+(1<<16);

TARGB32 pixel[16];

for(longi=0;i<4;++i)
{
longy=y0_sub1+i;
pixel[i4+0]=Pixels_Bound(pic,x0_sub1 ,y);
pixel[i4+1]=Pixels_Bound(pic,x0_sub1+1,y);
pixel[i4+2]=Pixels_Bound(pic,x0_sub1+2,y);
pixel[i4+3]=Pixels_Bound(pic,x0_sub1+3,y);
}

TPicRegion npic;
npic.pdata =&pixel[0];
npic.byte_width=4*sizeof(TARGB32);
//npic.width =4;
//npic.height =4;
ThreeOrder_Fast_MMX(npic,u_16_add1,v_16_add1,result);
}

voidPicZoom_ThreeOrder_MMX(constTPicRegion& Dst,constTPicRegion& Src)
{
if( (0 == Dst.width)||(0 == Dst.height)
||(0 == Src.width)||(0 == Src.height))return;

longxrIntFloat_16=((Src.width)<<16)/Dst.width+1;
longyrIntFloat_16=((Src.height)<<16)/Dst.height+1;
constlongcsDErrorX=-(1<<15)+(xrIntFloat_16>>1);
constlongcsDErrorY=-(1<<15)+(yrIntFloat_16>>1);

unsignedlongdst_width=Dst.width;

//计算出需要特殊处理的边界
longborder_y0=((1<<16)-csDErrorY)/yrIntFloat_16+1;//y0+yyr>=1; y0=csDErrorY => y>=(1-csDErrorY)/yr
if(border_y0>=Dst.height) border_y0=Dst.height;
longborder_x0=((1<<16)-csDErrorX)/xrIntFloat_16+1;
if(border_x0>=Dst.width ) border_x0=Dst.width;
longborder_y1=(((Src.height-3)<<16)-csDErrorY)/yrIntFloat_16+1;//y0+yyr<=(height-3) => y<=(height-3-csDErrorY)/yr
if(border_y1 longborder_x1=(((Src.width-3)<<16)-csDErrorX)/xrIntFloat_16+1;;
if(border_x1
TARGB32* pDstLine=Dst.pdata;
longsrcy_16=csDErrorY;
longy;
for(y=0;y
{

longsrcx_16=csDErrorX;
for(unsignedlongx=0;x
{
ThreeOrder_Border_MMX(Src,srcx_16,srcy_16,&pDstLine[x]);
//border
srcx_16+=xrIntFloat_16;
}
srcy_16+=yrIntFloat_16;
((TUInt8*&)pDstLine)+=Dst.byte_width;
}
for(y=border_y0;y
{

longsrcx_16=csDErrorX;
longx;
for(x=0;x
{
ThreeOrder_Border_MMX(Src,srcx_16,srcy_16,&pDstLine[x]);
//border
srcx_16+=xrIntFloat_16;
}
for(x=border_x0;x
{
ThreeOrder_Fast_MMX(Src,srcx_16,srcy_16,&pDstLine[x]);
//fast MMX !
srcx_16+=xrIntFloat_16;
}
for(x=border_x1;x
{
ThreeOrder_Border_MMX(Src,srcx_16,srcy_16,&pDstLine[x]);
//border
srcx_16+=xrIntFloat_16;
}
srcy_16+=yrIntFloat_16;
((TUInt8*&)pDstLine)+=Dst.byte_width;
}
for(y=border_y1;y
{

longsrcx_16=csDErrorX;
for(unsignedlongx=0;x
{
ThreeOrder_Border_MMX(Src,srcx_16,srcy_16,&pDstLine[x]);
//border
srcx_16+=xrIntFloat_16;
}
srcy_16+=yrIntFloat_16;
((TUInt8*&)pDstLine)+=Dst.byte_width;
}
asm emms
}

//速度测试:
//==============================================================================
// PicZoom_ThreeOrder_MMX 34.3 fps

N：将测试结果放到一起：


//CPU: AMD64x2 4200+(2.37G) zoom 800600 to 1024768
//==============================================================================
// StretchBlt 232.7 fps
// PicZoom3_SSE 711.7 fps
// PicZoom_BilInear_MMX_Ex 157.0 fps
//
// PicZoom_ThreeOrder0 3.6 fps
// PicZoom_ThreeOrder_Common 16.9 fps
// PicZoom_ThreeOrder_MMX 34.3 fps

补充Intel Core2 4400上的测试成绩:


//CPU: Intel Core2 4400(2.00G) zoom 800600 to 1024768
//==============================================================================
// PicZoom3_SSE 1099.7 fps
// PicZoom_BilInear_MMX_Ex 142.9 fps
//
// PicZoom_ThreeOrder0 4.2 fps
// PicZoom_ThreeOrder_Common 17.6 fps
// PicZoom_ThreeOrder_MMX 34.4 fps

hantoy
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
图像分割算法简介（下）
DoBit的专栏
03-13 6639
4.基于图论的图像分割 将图论的方法用于图像处理，主要是将图像与图进行映射，利用图的分割方法进行图像分割。 通俗来说，图像映射为图之后，根据采取的准则方法，图像中的前景和背景都转化为了图中的顶点，并且每个顶点之间都被赋予了一定的权值。若将这个图割开来一分为二，当割在前景顶点和背景顶点之间时能得到最小的一个割。GraphCut[10]采用图论中的最小割（Minimum Cut）来
图像分割算法简介(上）
DoBit的专栏
03-02 1万+
（ps：这是我的一份作业，用一个寒假的看了一些资料，写的这篇关于图像分割的简介，删除了作业中一些凑字数的话...） 摘要：本文将分类介绍以下算法：基于边缘的图像分割（包括一阶、二阶梯度算子、Canny算子），基于阈值的图像分割（全局阈值、局部阈值），基于区域的图像分割（区域生长合并、区域分裂合并、形态学分水岭、mean shift图像分割以及JSEG算法），基于图论的图像分割（Graph c
图像缩放算法
09-07
图像缩放的三种算法：邻近像素插值算法，二线性插值算法，立方卷积算法
图像缩放算法小结
热门推荐
小豆豆~
04-10 3万+
参考网址： https://blog.csdn.net/lfz_sau/article/details/51366700 http://www.cnblogs.com/blfshiye/p/4823027.html https://en.wikipedia.org/wiki/Lanczos_resampling https://wenku.baidu.com/view/22b38b70a41786...
android 笔记 --- 位图和矢量图区别
zkl_1987的专栏
05-27 696
位图和矢量图是计算机图形中的两大概念，这两种图形都被广泛应用到出版，印刷，互联网[如flash和svg]等各个方面，他们各有优缺点，两者各自的好处几乎是无法相互替代的，所以，长久以来，矢量跟位图在应用中一直是平分秋色。 位图[bitmap]，也叫做点阵图，删格图象，像素图，简单的说，就是最小单位由象素构成的图，缩放会失真。构成位图的最小单位是象素，位图就是由象素阵列的排列来实现其显示效果的，...
03｜缩放算法：如何高质量地缩放图像？
最新发布
qq_37756660的博客
10-17 1552
在开始讲双线性插值的原理之前，我们先来看看双线性插值的基础，也就是线性插值的原理。线性插值是在两个点中间的某一个位置插值得到一个新的值。线性插值认为，这个需要插值得到的点跟这两个已知点都有一定的关系，并且，待插值点与离它近的那个点更相似。因此，
图像缩放
basketball in c++
10-17 3250
 第一篇文章.插值算法对于缩放比例较小的情况是完全可以接受的，令人信服的。一般的，缩小0.5倍以上或放大3.0倍以下，对任何图像都是可以接受的。最邻近插值（近邻取样法）：　　最临近插值的的思想很简单。对于通过反向变换得到的的一个浮点坐标，对其进行简单的取整，得到一个整数型坐标，这个整数型坐标对应的像素值就是目的像素的像素值，也就是说，取浮点坐标最邻近的左上角点（对于DIB是右上角，因为
yuv图像缩放算法
07-25
本文将深入探讨YUV图像缩放算法，并通过一个具体的例子来解释如何在代码中实现这一过程。 YUV图像缩放涉及调整Y、U和V分量的像素大小，以适应不同的显示尺寸。常见的缩放方法包括最近邻插值、双线性插值和更高级的...
图像缩放算法的超简单讲解.pdf
08-05
"图像缩放算法的超简单讲解" 图像缩放算法是计算机图像处理中的一种基本技术，它可以将图像放大或缩小到不同的大小。今天，我们将讨论一种简单的图像缩放算法，称为最临近插值算法，并且还将介绍一种更好的图像缩放...
时域图像缩放算法比较
05-09
### 时域图像缩放算法比较 #### 一、引言 随着计算机视觉技术的发展，图像缩放成为了图像处理中的一个重要环节。为了适应不同的显示需求和处理任务，我们需要能够高效地调整图像的尺寸。本文将重点介绍几种常用的...
图像缩放的双线性内插值算法的原理解析
okadler0518的专栏
07-21 2478
图像缩放的双线性内插值算法的原理解析  图像的缩放很好理解,就是图像的放大和缩小。传统的绘画工具中,有一种叫做“放大尺”的绘画工具，画家常用它来放大图画。当然，在计算机上，我们不再需要用放大尺去放大或缩小图像了，把这个工作交给程序来完成就可以了。下面就来讲讲计算机怎么来放大缩小图象；在本文中，我们所说的图像都是指点阵图，也就是用一个像素矩阵来描述图像的方法，对于另一种图像：用函数来描述
用线性插值算法实现图像缩放
weixin_30595035的博客
08-18 281
什么是双线性插值 简单比方 原来的数值序列：0，10，20，30，40 线性插值一次为：0，5，10，15，20，25，30，35，40 即认为其变化（增减）是线形的，可以在坐标图上画出一条直线 在数码相机技术中，这些数值可以代表组成一张照片的不同像素点的色彩、色度等指标。 为了方便理解，先考虑一维情况下的线性插值 对于一个数列c，我们假设c[a]到c[a+1]之间是线性变化的 那么对...
SSE2指令集
feixiaku的专栏
12-27 2558
1移动指令: 1.       Movaps movaps XMM,XMM/m128 movaps XMM/128,XMM 把源存储器内容值送入目的寄存器,当有m128时,必须对齐内存16字节,也就是内存地址低4位为0. 2.       Movups movups XMM,XMM/m128 movaps XMM/128,XMM 把源存储器内容值送入目的寄存器,但不必对齐内存1
图像处理-放大和缩小
陈建驱的博客
08-16 1万+
个人博客：http://www.chenjianqu.com/ 原文链接：http://www.chenjianqu.com/show-7.html 在计算机图像处理和计算机图形学中，图像缩放（image scaling）是指对数字图像的大小进行调整的过程。图像缩放是一种非平凡的过程，需要在处理效率以及结果的平滑度（smoothness）和清晰度（sharpness）上做一个权衡。当一个图像的...
SSE2指令集系列之二----整数运算相关指令
weixin_34281537的博客
04-23 323
本小节描述的是SSE2整数运算指令。 5. 数据搬移指令 　　movdqa XMM,XMM/m128 movdqa XMM/m128,XMM 　　把源存储器内容值送入目的寄存器,当有m128时,内存地址必须16字节对齐. 　　movdqu XMM,XMM/m128 movdqu XMM/m128,XMM 　　把源存储器内容值送入目的寄存器,...
SSE指令集优化学习：双线性插值
djzhao的专栏
10-31 2028
from:http://www.cnblogs.com/wangguchangqing/p/5445652.html 对SSE的学习总算迈出了第一步，用2天时间对双线性插值的代码进行了优化，现将实现的过程梳理以下，算是对这段学习的一个总结。 1. 什么是SSE 说到SSE，首先要弄清楚的一个概念是SIMD（单指令多数据流，Single Instruction Multiple
FASM 第二章 – 2.1 x86 体系指令
hintonic的专栏
06-18 3219
2.1 x86 体系指令 这一章讲述了汇编语言指令语法和功能。更多的技术信息可以阅读Intel软件开发者手册。 汇编指令有助记符（指令名称）和0到3个操作符组成。如果有大于两个的操作符，通常第一个为目的操作符第二个为源操作符。每个操作符都可以为寄存器，内存或立即数（操作符语法见1.2节）。每条指令描述后悔有操作符不同用法的例子。 一些指令用作前缀，可以和其他指令放在同行一起使用，一行也允许有
FPGA实现的图像缩放算法与Scaler设计
"这篇硕士学位论文来自上海大学，由刘婧撰写，导师冉峰指导，专业为电工理论与新技术，主题聚焦于FPGA图像缩放算法及其在平板显示器件(FPD)中的应用。" 正文: 图像缩放算法在现代电子设备中扮演着至关重要的角色，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值