图形图像处理－之－彩色转化到灰度的速度优化

               图形图像处理－之－彩色转化到灰度的速度优化
                   HouSisong@GMail.com  2009.02.08

tag:灰度算法,速度优化,定点数优化,MMX,SSE,SSE2,CPU缓存优化

摘要:
  彩色转化到灰度的速度优化文章包括图形图像处理简单Demo框架和灰度转换的实
现及其速度优化,并演示其使用SIMD指令集的优化;
   本篇文章将第一次提供完整的可以编译的图像处理完整项目代码;
   (以后会用这个框架逐步改写以前的图形图像处理文章)

正文：  
  为了便于讨论，这里只处理32bit的ARGB颜色；代码使用C++;使用的编译器为vc2008;
(经过测试代码也可以在DevC++和xcode下编译通过) 测试使用的CPU为AMD64x2 4200+(2.33G);

速度测试说明:
  只测试内存数据到内存数据的ARGB32颜色的灰度转化;
  测试图片是800*600; fps表示每秒钟的帧数,值越大表示函数越快;

A: 图形图像处理简单Demo框架
   
  我以前写的图形图像处理方面的blog文章都没有完整的可以编译运行的代码,
而仅仅列出了关键的核心代码;经常有网友看了我的文章,但因为不能实际运行看看,
从而对代码的理解不深,也不能把代码移植到自己的项目中使用; 所以决定为我的图形
图像处理系列blog文章建立一个简单的小型的框架;我把它命名为hGraphic32,
它会尽量的小,演示为主,仅支持ARGB32颜色,能够加载和保存bmp图片文件,能够在
多个编译器和平台下编译和运行;
   现在就下载完整项目源代码吧:  完整项目源代码

  <hGraphic32>文件夹里的文件说明:
    "hColor32.h"  : 里面定义了32bitARGB颜色类型Color32,它占用4字节,代表一个颜色;
        TPixels32Ref是图像数据区的描述信息,可以把它理解为一个"指针",指向了Color32构成的像素区;
        IPixels32Buf是图像数据区接口,用于描述一个图像的缓冲区;
    "hPixels32.h" : 里面定义了TPixels32类,它实现了IPixels32Buf接口,用于申请和管理一块内存像素;
    "hStream.h"   : 里面定义了IInputStream输入流接口;
        IBufInputStream数据区输入流接口,继承自IInputStream;
        TFileInputStream文件输入流类,它实现了IBufInputStream接口;
        IOutputStream输出流接口;
        TFileOutputStream文件输出流类,它实现了IOutputStream接口;
     "hBmpFile.h" : 里面定义了TBmpFile类,它负责加载bmp和保存bmp;
     "hGraphic32.h" 文件include了上面的*.h头文件,所以使用的时候,只要#include "hGraphic32.h"就可以了

B: 灰度转化项目
  所有的转换和测试代码都在"ColorToGray/ColorToGray.cpp"文件中(带有main函数的命令行程序);
  "ColorToGray/win_vc/ColorToGray.sln"是windows系统下的vc2008项目文件(测试的时请设定调试运行目录为"..");
  "ColorToGray/win_DevC++/ColorToGray.dev"是windows系统下的DevC++项目文件;
  "ColorToGray/macosx_xcode/ColorToGray.xcodeproj"是macosx系统下的xcode项目文件;
  你也可以自己建立项目,包含ColorToGray.cpp文件和<hGraphic32>文件夹下的所有文件,就可以编译了;

C: 灰度转化公式和代码实现
  文章中用的灰度公式: Gray = R*0.299 + G*0.587  + B*0.114;
 
代码实现:

//灰度转换系数 const double gray_r_coeff=0.299; const double gray_g_coeff=0.587; const double gray_b_coeff=0.114; //处理一个点 must_inline double toGray_float(const Color32& src){ return (src.r*gray_r_coeff +src.g*gray_g_coeff +src.b*gray_b_coeff); } //处理一行 void colorToGrayLine_float(const Color32* src,Color32* dst,long width){ for (long x = 0; x < width; ++x){ int gray=(int)toGray_float(src[x]); dst[x]=Color32(gray,gray,gray,src[x].a);//R,G,B都设置为相同的亮度值,A不变 } } void colorToGray_float(const TPixels32Ref& src,const TPixels32Ref& dst){ long width=std::min(src.width,dst.width); long height=std::min(src.height,dst.height); Color32* srcLine=src.pdata; Color32* dstLine=dst.pdata; for (long y = 0; y < height; ++y){ colorToGrayLine_float(srcLine,dstLine,width); src.nextLine(srcLine); dst.nextLine(dstLine); } }

//速度测试
//==============================================================================
// colorToGray_float           145.49 FPS


D: 将浮点运算转化为定点数(整数)运算
    
must_inline int toGray_int16(const Color32& src){ const long bit=16; const int gray_r_coeff_int=(int)( gray_r_coeff*(1<<bit)+0.4999999 ); const int gray_g_coeff_int=(int)( gray_g_coeff*(1<<bit)+0.4999999 ); const int gray_b_coeff_int=(1<<bit)-gray_r_coeff_int-gray_g_coeff_int; return (src.r*gray_r_coeff_int +src.g*gray_g_coeff_int +src.b*gray_b_coeff_int) >> bit; } inline void colorToGrayLine_int16(const Color32* src,Color32* dst,long width){ for (long x = 0; x < width; ++x){ int gray=toGray_int16(src[x]); dst[x]=Color32(gray,gray,gray,src[x].a); } } void colorToGray_int16(const TPixels32Ref& src,const TPixels32Ref& dst){ long width=std::min(src.width,dst.width); long height=std::min(src.height,dst.height); Color32* srcLine=src.pdata; Color32* dstLine=dst.pdata; for (long y = 0; y < height; ++y){ colorToGrayLine_int16(srcLine,dstLine,width); src.nextLine(srcLine); dst.nextLine(dstLine); } }


//速度测试
//==============================================================================
// colorToGray_int16           355.33 FPS


E: 做一个简单的循环代码展开
//四路展开 void colorToGrayLine_int16_expand4(const Color32* src,Color32* dst,long width){ long widthFast=width>>2<<2; for (long x = 0; x < widthFast; x+=4){ int gray0=toGray_int16(src[x ]); int gray1=toGray_int16(src[x+1]); dst[x ]=Color32(gray0,gray0,gray0,src[x ].a); dst[x+1]=Color32(gray1,gray1,gray1,src[x+1].a); int gray2=toGray_int16(src[x+2]); int gray3=toGray_int16(src[x+3]); dst[x+2]=Color32(gray2,gray2,gray2,src[x+2].a); dst[x+3]=Color32(gray3,gray3,gray3,src[x+3].a); } //border if (width>widthFast) colorToGrayLine_int16(&src[widthFast],&dst[widthFast],width-widthFast); } void colorToGray_int16_expand4(const TPixels32Ref& src,const TPixels32Ref& dst){ long width=std::min(src.width,dst.width); long height=std::min(src.height,dst.height); Color32* srcLine=src.pdata; Color32* dstLine=dst.pdata; for (long y = 0; y < height; ++y){ colorToGrayLine_int16_expand4(srcLine,dstLine,width); src.nextLine(srcLine); dst.nextLine(dstLine); } }


//速度测试
//==============================================================================
// colorToGray_int16_expand4   413.22 FPS


F: 一个特别的版本
   在高级语言范围内进行单条指令多数据流计算,减少需要的乘法量;
在乘法运算代价比较高昂的cpu上应该效果不错; (x86上速度可能慢)
must_inline UInt32 toGray_int8_opMul(const Color32* src2Color){ const UInt32 gray_r_coeff_8=(UInt32)( gray_r_coeff*(1<<8)+0.4999999); const UInt32 gray_g_coeff_8=(UInt32)( gray_g_coeff*(1<<8)+0.4999999); const UInt32 gray_b_coeff_8=(1<<8)-gray_r_coeff_8-gray_g_coeff_8; UInt32 RR,GG,BB; BB=src2Color[0].b | (src2Color[1].b<<16); GG=src2Color[0].g | (src2Color[1].g<<16); RR=src2Color[0].r | (src2Color[1].r<<16); BB*=gray_b_coeff_8; GG*=gray_g_coeff_8; RR*=gray_r_coeff_8; return BB+GG+RR; } void colorToGrayLine_int8_opMul(const Color32* src,Color32* dst,long width){ long widthFast=width>>2<<2; for (long x = 0; x < widthFast; x+=4){ UInt32 gray01=toGray_int8_opMul(&src[x ]); int gray0=(gray01&0x0000FF00)>>8; int gray1=gray01>>24; dst[x ]=Color32(gray0,gray0,gray0,src[x ].a); dst[x+1]=Color32(gray1,gray1,gray1,src[x+1].a); UInt32 gray23=toGray_int8_opMul(&src[x+2]); int gray2=(gray23&0x0000FF00)>>8; int gray3=gray23>>24; dst[x+2]=Color32(gray2,gray2,gray2,src[x+2].a); dst[x+3]=Color32(gray3,gray3,gray3,src[x+3].a); } //border if (width>widthFast) colorToGrayLine_int16(&src[widthFast],&dst[widthFast],width-widthFast); } void colorToGray_int8_opMul(const TPixels32Ref& src,const TPixels32Ref& dst){ long width=std::min(src.width,dst.width); long height=std::min(src.height,dst.height); Color32* srcLine=src.pdata; Color32* dstLine=dst.pdata; for (long y = 0; y < height; ++y){ colorToGrayLine_int8_opMul(srcLine,dstLine,width); src.nextLine(srcLine); dst.nextLine(dstLine); } }

//速度测试
//==============================================================================
// colorToGray_int8_opMul      387.97 FPS


G: 内联汇编的MMX实现版本
   注意:这里的MMX代码都只支持x86CPU(奔腾MMX以上CPU);
   在x64下不再有MMX寄存器,而应该使用SEE的XMM寄存器;
   而且在x64模式下vc2008编译器还没有提供内联汇编的直接支持,而必须使用函数指令方式的实现;
   GCC编译器也支持内联汇编模式,但是汇编语法不同,请参考相应的说明;

void colorToGrayLine_MMX(const Color32* src,Color32* dst,long width){ //const UInt32 gray_r_coeff_7=(UInt32)( gray_r_coeff*(1<<7)+0.4999999 ); //const UInt32 gray_g_coeff_7=(UInt32)( gray_g_coeff*(1<<7)+0.4999999 ); //const UInt32 gray_b_coeff_7=(1<<7)-gray_r_coeff_7-gray_g_coeff_7; // csMMX_rgb_coeff_w= short[ 0 , gray_r_coeff_7 , gray_g_coeff_7 , gray_b_coeff_7 ] const UInt64 csMMX_rgb_coeff_w = (((UInt64)0x00000026)<<32) | 0x004b000f; long widthFast=width>>1<<1; if (widthFast>0){ asm{ pcmpeqb mm5,mm5 // FF FF FF FF FF FF FF FF mov ecx,widthFast pxor mm7,mm7 // 00 00 00 00 00 00 00 00 pcmpeqb mm4,mm4 // FF FF FF FF FF FF FF FF mov eax,src mov edx,dst movq mm6,csMMX_rgb_coeff_w psrlw mm5,15 // 1 1 1 1 lea eax,[eax+ecx*4] lea edx,[edx+ecx*4] pslld mm4,24 // FF 00 00 00 FF 00 00 00 neg ecx loop_beign: movq mm0,[eax+ecx*4] // A1 R1 G1 B1 A0 R0 G0 B0 movq mm1,mm0 movq mm3,mm0 punpcklbw mm0,mm7 // 00 A0 00 R0 00 G0 00 B0 punpckhbw mm1,mm7 // 00 A1 00 R1 00 G1 00 B1 pmaddwd mm0,mm6 // R0*r_coeff G0*g_coeff+B0*b_coeff pmaddwd mm1,mm6 // R1*r_coeff G1*g_coeff+B1*b_coeff pand mm3,mm4 // A1 00 00 00 A0 00 00 00 packssdw mm0,mm1 // sR1 sG1+sB1 sR0 sG0+sB0 pmaddwd mm0,mm5 // sR1+sG1+sB1 sR0+sG0+sB0 psrld mm0,7 // 00 00 00 Gray1 00 00 00 Gray0 movq mm1,mm0 movq mm2,mm0 pslld mm1,8 // 00 00 Gray1 00 00 00 Gray0 00 por mm0,mm3 pslld mm2,16 // 00 Gray1 00 00 00 Gray0 00 00 por mm0,mm1 por mm0,mm2 // A1 Gray1 Gray1 Gray1 A0 Gray0 Gray0 Gray0 movq [edx+ecx*4],mm0 add ecx,2 jnz loop_beign } } //border if (width>widthFast) colorToGrayLine_int16(&src[widthFast],&dst[widthFast],width-widthFast); } void colorToGray_MMX(const TPixels32Ref& src,const TPixels32Ref& dst){ long width=std::min(src.width,dst.width); long height=std::min(src.height,dst.height); Color32* srcLine=src.pdata; Color32* dstLine=dst.pdata; for (long y = 0; y < height; ++y){ colorToGrayLine_MMX(srcLine,dstLine,width); src.nextLine(srcLine); dst.nextLine(dstLine); } asm{ emms //MMX使用结束 } }


//速度测试
//==============================================================================
// colorToGray_MMX             590.84 FPS


H: 优化写缓冲的内联汇编的MMX实现版本
  该版本相应于上面的MMX版本只改写了两句:
   一是写内存的movq [edx+ecx*4],mm0 改成了 movntq [edx+ecx*4],mm0 绕过缓存
   二是函数结束的时候调用sfence刷新写入
  完整代码如下:

void colorToGrayLine_MMX2(const Color32* src,Color32* dst,long width){ //const UInt32 gray_r_coeff_7=(UInt32)( gray_r_coeff*(1<<7)+0.4999999 ); //const UInt32 gray_g_coeff_7=(UInt32)( gray_g_coeff*(1<<7)+0.4999999 ); //const UInt32 gray_b_coeff_7=(1<<7)-gray_r_coeff_7-gray_g_coeff_7; // csMMX_rgb_coeff_w= short[ 0 , gray_r_coeff_7 , gray_g_coeff_7 , gray_b_coeff_7 ] const UInt64 csMMX_rgb_coeff_w = (((UInt64)0x00000026)<<32) | 0x004b000f; long widthFast=width>>1<<1; if (widthFast>0){ asm{ pcmpeqb mm5,mm5 // FF FF FF FF FF FF FF FF mov ecx,widthFast pxor mm7,mm7 // 00 00 00 00 00 00 00 00 pcmpeqb mm4,mm4 // FF FF FF FF FF FF FF FF mov eax,src mov edx,dst movq mm6,csMMX_rgb_coeff_w psrlw mm5,15 // 1 1 1 1 lea eax,[eax+ecx*4] lea edx,[edx+ecx*4] pslld mm4,24 // FF 00 00 00 FF 00 00 00 neg ecx loop_beign: movq mm0,[eax+ecx*4] // A1 R1 G1 B1 A0 R0 G0 B0 movq mm1,mm0 movq mm3,mm0 punpcklbw mm0,mm7 // 00 A0 00 R0 00 G0 00 B0 punpckhbw mm1,mm7 // 00 A1 00 R1 00 G1 00 B1 pmaddwd mm0,mm6 // R0*r_coeff G0*g_coeff+B0*b_coeff pmaddwd mm1,mm6 // R1*r_coeff G1*g_coeff+B1*b_coeff pand mm3,mm4 // A1 00 00 00 A0 00 00 00 packssdw mm0,mm1 // sR1 sG1+sB1 sR0 sG0+sB0 pmaddwd mm0,mm5 // sR1+sG1+sB1 sR0+sG0+sB0 psrld mm0,7 // 00 00 00 Gray1 00 00 00 Gray0 movq mm1,mm0 movq mm2,mm0 pslld mm1,8 // 00 00 Gray1 00 00 00 Gray0 00 por mm0,mm3 pslld mm2,16 // 00 Gray1 00 00 00 Gray0 00 00 por mm0,mm1 por mm0,mm2 // A1 Gray1 Gray1 Gray1 A0 Gray0 Gray0 Gray0 movntq [edx+ecx*4],mm0 //和colorToGrayLine_MMX的不同之处 add ecx,2 jnz loop_beign } } //border if (width>widthFast) colorToGrayLine_int16(&src[widthFast],&dst[widthFast],width-widthFast); } void colorToGray_MMX2(const TPixels32Ref& src,const TPixels32Ref& dst){ long width=std::min(src.width,dst.width); long height=std::min(src.height,dst.height); Color32* srcLine=src.pdata; Color32* dstLine=dst.pdata; for (long y = 0; y < height; ++y){ colorToGrayLine_MMX2(srcLine,dstLine,width); src.nextLine(srcLine); dst.nextLine(dstLine); } asm{ sfence //刷新写入 emms } }



//速度测试
//==============================================================================
// colorToGray_MMX2            679.50 FPS


I: 使用MMX函数指令方式的实现
  MMX/SSE等特殊指令除了内联汇编来使用外,也可以使用函数指令方式的实现,从而在多种
编译器下都可以使用SIMD相关指令,可移植性也会好很多;
  但现在看来,vc对此的优化还不够,还可能遇到编译器的实现bug;
  (可以考虑使用intel的编译器编译这些代码,感觉优化能力很不错)

#include <mmintrin.h> //mmx //#include <mm3dnow.h> //3dnow #include <xmmintrin.h> //sse //#include <emmintrin.h> //sse2 //#include <pmmintrin.h> //sse3 //#include <tmmintrin.h> //ssse3 //#include <intrin.h> //sse4a //#include <smmintrin.h> //sse4.1 //#include <nmmintrin.h> //sse4.2 //---------------------------------- void colorToGrayLine_MMX_mmh(const Color32* src,Color32* dst,long width){ //const UInt32 gray_r_coeff_7=(UInt32)( gray_r_coeff*(1<<7)+0.4999999 ); //const UInt32 gray_g_coeff_7=(UInt32)( gray_g_coeff*(1<<7)+0.4999999 ); //const UInt32 gray_b_coeff_7=(1<<7)-gray_r_coeff_7-gray_g_coeff_7; // csMMX_rgb_coeff_w= short[ 0 , gray_r_coeff_7 , gray_g_coeff_7 , gray_b_coeff_7 ] long widthFast=width>>1<<1; if (widthFast>0){ const UInt64 csMMX_rgb_coeff_w =(((UInt64)0x00000026)<<32) | 0x004b000f; const __m64 mm6=*(const __m64*)&csMMX_rgb_coeff_w; const __m64 mm7=_mm_setzero_si64(); //mm?变量值同colorToGrayLine_MMX中的mmx值一致 __m64 mm5=_mm_cmpeq_pi8(mm7,mm7); //想写成__m64 mm5; mm5=_mm_cmpeq_pi8(mm5,mm5);但会出错:( const __m64 mm4=_mm_slli_pi32(mm5,24); // ... mm5=_mm_srli_pi16(mm5,15); // ... for (long x = 0; x < widthFast; x+=2){ __m64 mm0=*(__m64*)&src[x]; __m64 mm1=mm0; __m64 mm3=mm0; mm0=_mm_unpacklo_pi8(mm0,mm7); mm1=_mm_unpackhi_pi8(mm1,mm7); mm0=_mm_madd_pi16(mm0,mm6); mm1=_mm_madd_pi16(mm1,mm6); mm3=_mm_and_si64(mm3,mm4); mm0=_mm_packs_pi32(mm0,mm1); mm0=_mm_madd_pi16(mm0,mm5); mm0=_mm_srli_pi32(mm0,7); mm1=mm0; __m64 mm2=mm0; mm1=_mm_slli_pi32(mm1,8); mm0=_mm_or_si64(mm0,mm3); mm2=_mm_slli_pi32(mm2,16); mm0=_mm_or_si64(mm0,mm1); mm0=_mm_or_si64(mm0,mm2); *(__m64*)&dst[x]=mm0; } } //border if (width>widthFast) colorToGrayLine_int16(&src[widthFast],&dst[widthFast],width-widthFast); } void colorToGray_MMX_mmh(const TPixels32Ref& src,const TPixels32Ref& dst){ long width=std::min(src.width,dst.width); long height=std::min(src.height,dst.height); Color32* srcLine=src.pdata; Color32* dstLine=dst.pdata; for (long y = 0; y < height; ++y){ colorToGrayLine_MMX_mmh(srcLine,dstLine,width); src.nextLine(srcLine); dst.nextLine(dstLine); } _mm_empty(); //MMX使用结束 }


//速度测试
//==============================================================================
// colorToGray_MMX_mmh         508.69 FPS



 优化写缓冲的使用MMX函数指令方式的实现

void colorToGrayLine_MMX2_mmh(const Color32* src,Color32* dst,long width){ //const UInt32 gray_r_coeff_7=(UInt32)( gray_r_coeff*(1<<7)+0.4999999 ); //const UInt32 gray_g_coeff_7=(UInt32)( gray_g_coeff*(1<<7)+0.4999999 ); //const UInt32 gray_b_coeff_7=(1<<7)-gray_r_coeff_7-gray_g_coeff_7; // csMMX_rgb_coeff_w= short[ 0 , gray_r_coeff_7 , gray_g_coeff_7 , gray_b_coeff_7 ] long widthFast=width>>1<<1; if (widthFast>0){ const UInt64 csMMX_rgb_coeff_w =(((UInt64)0x00000026)<<32) | 0x004b000f; const __m64 mm6=*(const __m64*)&csMMX_rgb_coeff_w; const __m64 mm7=_mm_setzero_si64(); //mm?变量值同colorToGrayLine_MMX中的mmx值一致 __m64 mm5=_mm_cmpeq_pi8(mm7,mm7); // ... const __m64 mm4=_mm_slli_pi32(mm5,24); // ... mm5=_mm_srli_pi16(mm5,15); // ... for (long x = 0; x < widthFast; x+=2){ __m64 mm0=*(__m64*)&src[x]; __m64 mm1=mm0; __m64 mm3=mm0; mm0=_mm_unpacklo_pi8(mm0,mm7); mm1=_mm_unpackhi_pi8(mm1,mm7); mm0=_mm_madd_pi16(mm0,mm6); mm1=_mm_madd_pi16(mm1,mm6); mm3=_mm_and_si64(mm3,mm4); mm0=_mm_packs_pi32(mm0,mm1); mm0=_mm_madd_pi16(mm0,mm5); mm0=_mm_srli_pi32(mm0,7); mm1=mm0; __m64 mm2=mm0; mm1=_mm_slli_pi32(mm1,8); mm0=_mm_or_si64(mm0,mm3); mm2=_mm_slli_pi32(mm2,16); mm0=_mm_or_si64(mm0,mm1); mm0=_mm_or_si64(mm0,mm2); //*(__m64*)&dst[x]=mm0; _mm_stream_pi((__m64*)&dst[x],mm0); } } //border if (width>widthFast) colorToGrayLine_int16(&src[widthFast],&dst[widthFast],width-widthFast); } void colorToGray_MMX2_mmh(const TPixels32Ref& src,const TPixels32Ref& dst){ long width=std::min(src.width,dst.width); long height=std::min(src.height,dst.height); Color32* srcLine=src.pdata; Color32* dstLine=dst.pdata; for (long y = 0; y < height; ++y){ colorToGrayLine_MMX2_mmh(srcLine,dstLine,width); src.nextLine(srcLine); dst.nextLine(dstLine); } _mm_sfence();//刷新写入 _mm_empty(); //MMX使用结束 }


//速度测试
//==============================================================================
// colorToGray_MMX2_mmh        540.78 FPS


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


//CPU: AMD64x2 4200+(2.33G)  800*600 to 800*600
//==============================================================================
// colorToGray_float           145.49 FPS
// colorToGray_int16           355.33 FPS
// colorToGray_int16_expand4   413.22 FPS
// colorToGray_int8_opMul      387.97 FPS
// colorToGray_MMX             590.84 FPS
// colorToGray_MMX2            679.50 FPS
// colorToGray_MMX_mmh         508.69 FPS
// colorToGray_MMX2_mmh        540.78 FPS


ps:用SSE的浮点指令的版本/用SSE2整数指令的版本/利用SSE3的水平加指令等的实现版本有机会时再补充
ps:SIMD特殊指令集的使用框架请参见我的<YUV视频格式到RGB32格式转换的速度优化 中篇>一文,从而
根据CPU对指令集的支持情况动态的调用最优的实现函数版本;