能是最快的算法alpha blend汇编源代码

最新推荐文章于 2023-04-24 21:44:03 发布
最新推荐文章于 2023-04-24 21:44:03 发布
阅读量1.5k 收藏 3
点赞数 1
分类专栏： Microsoft技术 文章标签： blend 算法 汇编 dst byte file
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/moonet/article/details/13939
版权

Intel官方网站有一个ablend_565的快速汇编算法，理论上是是把一块32bit RGBA渲染到16bit的buffer上，我的机器是PIII800,函数在system menory中进行，640*480的256级alpha blending，达到100fps，我想可以满足绝大部分的要求了，在这里，我提供了这个算法的应用，希望可以对大家有所帮助。

ablend_565函数，源代码可以直接编译使用，无需其他库函数，感谢intel提供这么好的东西。
首先，我提供一些本人编写的把32bit tga文件读入pRGBABuffer的函数
文件尺寸保存在 width,height

//-----------------------------------------------------------------------
// Name: LoadTgaFile( TCHAR* strPathname, DWORD** pRGBABuffer, long* width, long* height )
// Desc: 读取32bit tga文件到DWORD缓冲里，返回其尺寸
// Time: 2002.06.22 00:36
// Author: RealRender
// Para:
// Return:
// Note: 这段代码来自directx 7.0 sample中的d3dtextr.cpp，我把他提取了出来
// 方便使用
//-----------------------------------------------------------------------
BOOL LoadTgaFile( TCHAR* strPathname, DWORD** pRGBABuffer, long* width, long* height )
{
FILE* file = fopen( strPathname, "rb" );
if( NULL == file )
return false;

struct TargaHeader
{
BYTE IDLength;
BYTE ColormapType;
BYTE ImageType;
BYTE ColormapSpecification[5];
WORD XOrigin;
WORD YOrigin;
WORD ImageWidth;
WORD ImageHeight;
BYTE PixelDepth;
BYTE ImageDescriptor;
} tga;

fread( &tga, sizeof(TargaHeader), 1, file );

// Only true color, non-mapped images are supported
if( ( 0 != tga.ColormapType ) ||
( tga.ImageType != 10 && tga.ImageType != 2 ) )
{
fclose( file );
return false;
}

// Skip the ID field. The first byte of the header is the length of this field
if( tga.IDLength )
fseek( file, tga.IDLength, SEEK_CUR );

DWORD m_dwWidth = tga.ImageWidth;
DWORD m_dwHeight = tga.ImageHeight;
DWORD m_dwBPP = tga.PixelDepth;
DWORD *m_pRGBAData = new DWORD[m_dwWidth*m_dwHeight];

if( m_pRGBAData == NULL )
{
fclose(file);
return false;
}

for( DWORD y=0; y
{
DWORD dwOffset = y*m_dwWidth;

if( 0 == ( tga.ImageDescriptor & 0x0010 ) )
dwOffset = (m_dwHeight-y-1)*m_dwWidth;

for( DWORD x=0; x
{
if( tga.ImageType == 10 )
{
BYTE PacketInfo = getc( file );
WORD PacketType = 0x80 & PacketInfo;
WORD PixelCount = ( 0x007f & PacketInfo ) + 1;

if( PacketType )
{
DWORD b = getc( file );
DWORD g = getc( file );
DWORD r = getc( file );
DWORD a = 0xff;
if( m_dwBPP == 32 )
a = getc( file );

while( PixelCount-- )
{
m_pRGBAData[dwOffset+x] = (r<<24L)+(g<<16L)+(b<<8L)+(a);
x++;
}
}
else
{
while( PixelCount-- )
{
BYTE b = getc( file );
BYTE g = getc( file );
BYTE r = getc( file );
BYTE a = 0xff;
if( m_dwBPP == 32 )
a = getc( file );

m_pRGBAData[dwOffset+x] = (r<<24L)+(g<<16L)+(b<<8L)+(a);
x++;
}
}
}
else
{
BYTE b = getc( file );
BYTE g = getc( file );
BYTE r = getc( file );
BYTE a = 0xff;
if( m_dwBPP == 32 )
a = getc( file );

m_pRGBAData[dwOffset+x] = (r<<24L)+(g<<16L)+(b<<8L)+(a);
x++;
}
}
}

fclose( file );

// Check for alpha content
for( DWORD i=0; i<(m_dwWidth*m_dwHeight); i++ )
{
if( m_pRGBAData[i] & 0x000000ff != 0xff )
{
//m_bHasAlpha = TRUE;
break;
}
}

*pRGBABuffer = m_pRGBAData;
*width = m_dwWidth;
*height = m_dwHeight;
return true;
}

把32bit buffer分割为rgb和alpha的代码。

 

 

注意，分割后的pBitmap一定要是8字节对齐，这是优化的一个重要条件，所以，我的算法中：

BYTE* p = new BYTE[lSize*2+8];
BYTE* pOrig = p;
p += (DWORD)p%8;
WORD* color = (WORD*)p;

这是不规范的写法，把指针强行改变为8位对齐，实际使用的时候，要记住释放的原始指针不是p，而是pOrig，在这里，我没有释放分配的内存，请谅解。

//-----------------------------------------------------------------------
// Name: SplitRGBA( DWORD* pRGBABuffer, LPBYTE* pAlpha, LPWORD* pBitmap, long lWidth, long lHeight )
// Desc:
// Time: 2002.06.22 00:36
// Author: RealRender
// Para:
// Return:
// Note: 把从32bit的缓冲建立16bit的565缓冲和8bit的alpha通道
//-----------------------------------------------------------------------
void SplitRGBA( DWORD* pRGBABuffer, LPBYTE* pAlpha, LPWORD* pBitmap, long lWidth, long lHeight )
{
long lSize = lWidth*lHeight;
BYTE* alpha = new BYTE[lSize];
BYTE* p = new BYTE[lSize*2+8];
// 强行转换为8字节对齐
p += (DWORD)p%8;
WORD* color = (WORD*)p;

DWORD dwPixel;
DWORD r, g, b, a;
for( int i = 0; i < lSize; i++ )
{
dwPixel = pRGBABuffer[i];
r = ((dwPixel>>24)&0x000000ff);
g = ((dwPixel>>16)&0x000000ff);
b = ((dwPixel>> 8)&0x000000ff);
a = ((dwPixel>> 0)&0x000000ff);

alpha[i] = a;
// 888i转化为565
color[i] = RGBTo16( r, g, b );
}
*pAlpha = alpha;
*pBitmap = color;
}

//

这个视intel官方提供的函数，函数的描述，用我的话来说就是把一个带有256级alpha通道的565颜色数据绘制到16位目标页面。

 

 

函数说明：

unsigned char *lpAlpha, // 256 级 alpha 通道
unsigned int iAlpPitch, // alpha 通道的 pitch
unsigned char *lpSrc, // 原色彩缓冲
unsigned int iSrcX, //
unsigned int iSrcY, // 原色彩位置
unsigned int iSrcPitch, // 原色彩 pitch
unsigned char *lpDst, // 目标缓冲
unsigned int iDstX,
unsigned int iDstY, // 目标位置
unsigned int iDstW,
unsigned int iDstH, // 目标缓冲的尺寸
unsigned int iDstPitch // 目标缓冲的 pitch

void ablend_565(unsigned char *lpAlpha,unsigned int iAlpPitch,
unsigned char *lpSrc,unsigned int iSrcX, unsigned int iSrcY,
unsigned int iSrcPitch, unsigned char *lpDst,
unsigned int iDstX, unsigned int iDstY,
unsigned int iDstW, unsigned int iDstH,
unsigned int iDstPitch)
{
//Mask for isolating the red,green, and blue components

static __int64 MASKB=0x001F001F001F001F;

static __int64 MASKG=0x07E007E007E007E0;

static __int64 MASKSHIFTG=0x03F003F003F003F0;

static __int64 MASKR=0xF800F800F800F800;

//constants used by the integer alpha blending equation

static __int64 SIXTEEN=0x0010001000100010;

static __int64 FIVETWELVE=0x0200020002000200;

static __int64 SIXONES=0x003F003F003F003F;

unsigned char *lpLinearDstBp=(iDstX<<1)+(iDstY*iDstPitch)+lpDst; //base pointer for linear destination

unsigned char *lpLinearSrcBp=(iSrcX<<1)+(iSrcY*iSrcPitch)+lpSrc; //base pointer for linear source

unsigned char *lpLinearAlpBp=iSrcX+(iSrcY*iAlpPitch)+lpAlpha; //base pointer for linear alpha

_asm{

mov esi,lpLinearSrcBp; //src

mov edi,lpLinearDstBp; //dst

mov eax,lpLinearAlpBp; //alpha

mov ecx,iDstH; //ecx=number of lines to copy

mov ebx,iDstW; //ebx=span width to copy

test esi,6; //check if source address is qword aligned

//since addr coming in is always word aligned(16bit)

jnz done; //if not qword aligned we don't do anything

primeloop:

movd mm1,[eax]; //mm1=00 00 00 00 a3 a2 a1 a0

pxor mm2,mm2; //mm2=0;

movq mm4,[esi]; //g1: mm4=src3 src2 src1 src0

punpcklbw mm1,mm2; //mm1=00a3 00a2 00a1 00a0

loopqword:

mov edx,[eax];

test ebx,0xFFFFFFFC; //check if only 3 pixels left

jz checkback; //3 or less pixels left

//early out tests

cmp edx,0xffffffff; //test for alpha value of 1

je copyback; //if 1's copy the source pixels to the destination

test edx,0xffffffff; //test for alpha value of 0

jz leavefront; //if so go to the next 4 pixels

//the alpha blend starts

//green

//i=a*sg+(63-a)*dg;

//i=(i+32)+((i+32)>>6)>>6;

//red

//i=a*sr+(31-a)*dr;

//i=(i+16)+((i+16)>>5)>>5;

movq mm5,[edi]; //g2: mm5=dst3 dst2 dst1 dst0

psrlw mm1,2; //mm1=a?>>2 nuke out lower 2 bits

movq mm7,MASKSHIFTG; //g3: mm7=1 bit shifted green mask

psrlw mm4,1; //g3a: move src green down by 1 so that we won't overflow

movq mm0,mm1; //mm0=00a3 00a2 00a1 00a0

psrlw mm5,1; //g3b: move dst green down by 1 so that we won't overflow

psrlw mm1,1; //mm1=a?>>1 nuke out lower 1 bits

pand mm4,mm7; //g5: mm4=sg3 sg2 sg1 sg0

movq mm2,SIXONES;//g4: mm2=63

pand mm5,mm7; //g7: mm5=dg3 dg2 dg1 dg0

movq mm3,[esi]; //b1: mm3=src3 src2 src1 src0

psubsb mm2,mm0; //g6: mm2=63-a3 63-a2 63-a1 63-a0

movq mm7,MASKB; //b2: mm7=BLUE MASK

pmullw mm4,mm0; //g8: mm4=sg?*a?

movq mm0,[edi]; //b3: mm0=dst3 dst2 dst1 dst0

pmullw mm5,mm2; //g9: mm5=dg?*(1-a?)

movq mm2,mm7; //b4: mm2=fiveones

pand mm3,mm7; //b4: mm3=sb3 sb2 sb1 sb0

pmullw mm3,mm1; //b6: mm3=sb?*a?

pand mm0,mm7; //b5: mm0=db3 db2 db1 db0

movq mm7,[esi]; //r1: mm7=src3 src2 src1 src0

paddw mm4,mm5; //g10: mm4=sg?*a?+dg?*(1-a?)

pand mm7,MASKR; //r2: mm7=sr3 sr2 sr1 sr0 　

psubsb mm2,mm1; //b5a: mm2=31-a3 31-a2 31-a1 31-a0

paddw mm4,FIVETWELVE; //g11: mm4=(mm4+512) green

pmullw mm0,mm2; //b7: mm0=db?*(1-a?)

movq mm5,mm4; //g12: mm5=mm4 green

psrlw mm7,11; //r4: shift src red down to position 0

psrlw mm4,6; //g13: mm4=mm4>>6

paddw mm4,mm5; //g14: mm4=mm4+mm5 green

paddw mm0,mm3; //b8: mm0=sb?*a?+db?*(1-a?)

movq mm5,[edi]; //r3: mm5=dst3 dst2 dst1 dst0

paddw mm0,SIXTEEN; //b9: mm0=(mm0+16) blue

pand mm5,MASKR; //r5: mm5=dr3 dr2 dr1 dr0

psrlw mm4,5; //g15: mm4=0?g0 0?g0 0?g0 0?g0 green

movq mm3,mm0; //b10: mm3=mm0 blue

psrlw mm0,5; //b11: mm0=mm0>>5 blue

psrlw mm5,11; //r6: shift dst red down to position 0

paddw mm0,mm3; //b12: mm0=mm3+mm0 blue

psrlw mm0,5; //b13: mm0=000b 000b 000b 000b blue

pmullw mm7,mm1; //mm7=sr?*a?

pand mm4,MASKG; //g16: mm4=00g0 00g0 00g0 00g0 green

pmullw mm5,mm2; //r7: mm5=dr?*(31-a?)

por mm0,mm4; //mm0=00gb 00gb 00gb 00gb

add eax,4; //move to next 4 alphas

add esi,8; //move to next 4 pixels in src

add edi,8; //move to next 4 pixels in dst

movd mm1,[eax]; //mm1=00 00 00 00 a3 a2 a1 a0

paddw mm5,mm7; //r8: mm5=sr?*a?+dr?*(31-a?)

paddw mm5,SIXTEEN; //r9: mm5=(mm5+16) red

pxor mm2,mm2; //mm2=0;

movq mm7,mm5; //r10: mm7=mm5 red

psrlw mm5,5; //r11: mm5=mm5>>5 red

movq mm4,[esi]; //g1: mm4=src3 src2 src1 src0

paddw mm5,mm7; //r12: mm5=mm7+mm5 red

punpcklbw mm1,mm2; //mm1=00a3 00a2 00a1 00a0

psrlw mm5,5; //r13: mm5=mm5>>5 red

psllw mm5,11; //r14: mm5=mm5<<10 red

por mm0,mm5; //mm0=0rgb 0rgb 0rgb 0rgb

sub ebx,4; //polished off 4 pixels

movq [edi-8],mm0; //dst=0rgb 0rgb 0rgb 0rgb

jmp loopqword; //go back to start

copyback:

movq [edi],mm4; //copy source to destination

leavefront:

add edi,8; //advance destination by 4 pixels

add eax,4; //advance alpha by 4

add esi,8; //advance source by 4 pixels

sub ebx,4; //decrease pixel count by 4

jmp primeloop;

checkback:

test ebx,0xFF; //check if 0 pixels left

jz nextline; //done with this span

//backalign: //work out back end pixels

movq mm5,[edi]; //g2: mm5=dst3 dst2 dst1 dst0

psrlw mm1,2; //mm1=a?>>2 nuke out lower 2 bits

movq mm7,MASKSHIFTG; //g3: mm7=shift 1 bit green mask

psrlw mm4,1; //g3a: move src green down by 1 so that we won't overflow

movq mm0,mm1; //mm0=00a3 00a2 00a1 00a0

psrlw mm5,1; //g3b: move dst green down by 1 so that we won't overflow

psrlw mm1,1; //mm1=a?>>1 nuke out lower 1 bits

pand mm4,mm7; //g5: mm4=sg3 sg2 sg1 sg0

movq mm2,SIXONES;//g4: mm2=63

pand mm5,mm7; //g7: mm5=dg3 dg2 dg1 dg0

movq mm3,[esi]; //b1: mm3=src3 src2 src1 src0

psubsb mm2,mm0; //g6: mm2=63-a3 63-a2 63-a1 63-a0

movq mm7,MASKB; //b2: mm7=BLUE MASK

pmullw mm4,mm0; //g8: mm4=sg?*a?

movq mm0,[edi]; //b3: mm0=dst3 dst2 dst1 dst0

pmullw mm5,mm2; //g9: mm5=dg?*(1-a?)

movq mm2,mm7; //b4: mm2=fiveones

pand mm3,mm7; //b4: mm3=sr3 sr2 sr1 sr0

pmullw mm3,mm1; //b6: mm3=sb?*a?

pand mm0,mm7; //b5: mm0=db3 db2 db1 db0

movq mm7,[esi]; //r1: mm7=src3 src2 src1 src0

paddw mm4,mm5; //g10: mm4=sg?*a?+dg?*(1-a?)

pand mm7,MASKR; //r2: mm7=sr3 sr2 sr1 sr0

psubsb mm2,mm1; //b5a: mm2=31-a3 31-a2 31-a1 31-a0

paddw mm4,FIVETWELVE; //g11: mm4=(i+512) green

pmullw mm0,mm2; //b7: mm0=db?*(1-a?)

movq mm5,mm4; //g12: mm5=(i+512) green

psrlw mm7,11; //r4: shift src red down to position 0

psrlw mm4,6; //g13: mm4=(i+512)>>6

paddw mm4,mm5; //g14: mm4=(i+512)+((i+512)>>6) green

paddw mm0,mm3; //b8: mm0=sb?*a?+db?*(1-a?)

movq mm5,[edi]; //r3: mm5=dst3 dst2 dst1 dst0

paddw mm0,SIXTEEN; //b9: mm0=(i+16) blue

pand mm5,MASKR; //r5: mm5=dr3 dr2 dr1 dr0

psrlw mm4,5; //g15: mm4=0?g0 0?g0 0?g0 0?g0 green

movq mm3,mm0; //b10: mm3=(i+16) blue

psrlw mm0,5; //b11: mm0=(i+16)>>5 blue

psrlw mm5,11; //r6: shift dst red down to position 0

paddw mm0,mm3; //b12: mm0=(i+16)+(i+16)>>5 blue

psrlw mm0,5; //b13: mm0=000r 000r 000r 000r blue

pmullw mm7,mm1; //mm7=sr?*a?

pand mm4,MASKG; //g16: mm4=00g0 00g0 00g0 00g0 green

pmullw mm5,mm2; //r7: mm5=dr?*(31-a?)

por mm0,mm4; //mm0=00gb 00gb 00gb 00gb

add eax,4; //move to next 4 alphas

//stall

paddw mm5,mm7; //r8: mm5=sr?*a?+dr?*(31-a?)

paddw mm5,SIXTEEN; //r9: mm5=(i+16) red

movq mm7,mm5; //r10: mm7=(i+16) red

psrlw mm5,5; //r11: mm5=(i+16)>>5 red

paddw mm5,mm7; //r12: mm5=(i+16)+((i+16)>>5) red

psrlw mm5,5; //r13: mm5=(i+16)+((i+16)>>5)>>5 red

psllw mm5,11; //r14: mm5=mm5<<10 red

por mm0,mm5; //mm0=0rgb 0rgb 0rgb 0rgb

test ebx,2; //check if there are 2 pixels

jz oneendpixel; //goto one pixel if that's it

movd [edi],mm0; //dst=0000 0000 0rgb 0rgb

psrlq mm0,32; //mm0>>32

add edi,4; //edi=edi+4

sub ebx,2; //saved 2 pixels

jz nextline; //all done goto next line

oneendpixel: //work on last pixel

movd edx,mm0; //edx=0rgb

mov [edi],dx; //dst=0rgb

nextline: //goto next line

dec ecx; //nuke one line

jz done; //all done

mov eax,lpLinearAlpBp; //alpha

mov esi,lpLinearSrcBp; //src

mov edi,lpLinearDstBp; //dst

add eax,iAlpPitch; //inc alpha ptr by 1 line

add esi,iSrcPitch; //inc src ptr by 1 line

add edi,iDstPitch; //inc dst ptr by 1 line

mov lpLinearAlpBp,eax; //save new alpha base ptr

mov ebx,iDstW; //ebx=span width to copy

mov lpLinearSrcBp,esi; //save new src base ptr

mov lpLinearDstBp,edi; //save new dst base ptr

jmp primeloop; //start the next span

done:

emms

}

}
moonet
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Alpha Blending
hm成长之路
11-24 270
代码 //=============================================================== //FileName: // AlphaBlending.cpp //Date: // 2019/11/24 //Author: // khoing(https://blog.csdn.net/qq_453...
能是最快的算法alpha blend汇编源代码 (转)
csd3176的博客
08-16 193
能是最快的算法alpha blend汇编源代码 (转)[@more@]intel官方网站有一个ablend_565的快速汇编算法，理论上是是把一块32bit RGBA渲染到16bit的buffer上，我的机器是PIII800,函...
最快的算法alphablend汇编源代码，Intel官方提供(转)
congjukun0600的博客
08-12 184
最快的算法alphablend汇编源代码，Intel官方提供(转)[@more@]　　Intel官方网站有一个ablend_565的快速汇编算法，理论上是是把一块32bit RGBA渲染到16bit的buffer上，我的机器是P...
使用Alpha Blending的方式来实现伪运动模糊的效果
Nhsoft的专栏
06-23 2275
使用Alpha Blending的方式来实现伪运动模糊的效果 潘李亮 2003 8 31 Stanly Lee 2003-10-4 Email : xheartblue@etang.com Homepage gamehunter.3322.net/xpertsoft/ 我们知道运动模糊效果能给我们的场景带来很大的视觉真实性。通常的书上和其他的地方介绍的运动模糊的实现方法都是基于累积缓冲
图片混合透明操作示例[AlphaBlendDemo.rar]-精品源代码
10-11
图片混合透明操作示例[AlphaBlendDemo.rar]-精品源代码
可能是最快的算法alpha-blend汇编源代码，排序算法数据结构.doc
04-07
可能是最快的算法alpha-blend汇编源代码，排序算法数据结构.doc
最快的排序算法 最快的算法alpha-blend，排序算法数据结构
04-07
最快的排序算法 最快的算法alpha-blend，排序算法数据结构
Alpha-Blend-Toolbar.zip_Alpha_blend
09-14
2. **颜色混合算法**：如Porter-Duff算法或乘法混合，通过计算源图像和目标图像的颜色及Alpha值，得到混合后的结果。 3. **GDI+ API**：Windows API提供了GDI+库，其中包含`Graphics::DrawImage`等方法，支持Alpha ...
AlphaBlend_alpha混合_Alpha_Direct3D_
10-01
在压缩包文件"AlphaBlend"中，可能包含一个演示Alpha混合的Direct3D程序。此程序可能包括创建设备、加载纹理、设置混合状态、绘制几何体等步骤，并通过改变Alpha值展示不同的透明效果。通过分析和学习这个示例，...
AlphaBlend图片透明过渡动画特效-精品源代码
10-11
这个源代码可能就利用了这样的API，通过对图片的Alpha通道进行操作，实现了图片之间的平滑过渡。 总之，AlphaBlend图片透明过渡动画特效是一个利用Alpha通道控制图片透明度来创建动态视觉效果的技术。通过理解和...
alpha混合算法代码(c语言)
12-16
alphablend.c alphablendnosort.c
汇编alpha运算处理 16位/64位
蓝天的博客
03-02 418
自己看汇编资料用MMX指令写的alpha运算代码还可以更优化仅供参考(VC++下)///////////////////////////////////////使用汇编完成@运算处理一次16位/////////////////////////////////////void DoAlpha(WORD *source,WORD *dest) { __asm  {  //对源图像的数据
Alpha-Blending 技术简介
我是程序员
08-25 1496
　现在的游戏，不管是 2D 还是 3D 的，为了追求透明光影效果，通常都会使用到 Alpha-Blending 技术。下面，我们将谈论什么是 Alpha-Blending 技术并简单介绍 Alpha-Blending 技术的具体算法。　　所谓 Alpha-Blending，其实就是按照“Alpha”混合向量的值来混合源像素和目标像素。为了便于理解，我们就从两个像素间的 Alpha-Blending
gcc编译c语言中内嵌汇编
fifan的专栏
01-25 4665
gcc编译c语言中内嵌汇编--AT&T and Intel 汇编语法对照寄存器命名：AT&T:  %eaxIntel: eaxAT&T 语法源地址在左侧，目的地址在右侧与Intel 方式语法相反将eax值传入ebxAT&T:  movl %eax, %ebxIntel: mov ebx, eaxAT&T 语法在立即数前有前缀$. AT&T:  movl $0x0h, %eaxInt
Win95.Yildiz源代码
zhangjie0072的专栏
06-01 1302
NAME: Win95.YildizAUTHOR: Black Jack [independant Austrian Win32asm virus coder]CONTACT: Black_Jack_VX@hotmail.com | http://www.coderz.net/blackjackTYPE: Win9x direct acting/global ring3 resident PE h
hit 计算机系统大作业——程序人生
m0_62224692的博客
04-24 515
P2P：程序员在Windows或Linux环境下，利用编辑器敲入C语言代码（Program），然后利用gcc编译器对C语言程序执行编译命令：hello.c文件先经过预处理器cpp，生成hello.i文件，再经过编译器ccl生成hello.s汇编程序，然后经过汇编器as生成可重定位目标程序hello.o，最后通过链接器ld链接生成可执行文件hello。在Linux终端执行./hello命令，运行该可执行文件（Process）。
Annotated x86 Disassembly - 带注解的 x86 反汇编
Jave.Lin 的学习笔记
05-26 398
文章目录In this article - 此文Source Code - 源代码 系列目录：Processor Architecture - 处理器体系架构 原文：Annotated x86 Disassembly In this article - 此文 以下小节将带你过一篇反汇编的例子： Source Code - 源代码 下面的代码是用于分析用的函数。 HRESULT CUserView::CloseView(void) { if (m_fDestroyed) return S_OK;
Win32 PE病毒原理分析
liwei8703的专栏
12-07 3496
by guojpeng/CVC.GB在绝大多数病毒爱好者眼中，真正的病毒技术在Win32 PE病毒中才会得到真正的体现（令病毒极度疯狂的DOS时代已经过去）。并且要掌握病毒技术的精髓，学会Win32汇编是非常必要的。本节所涉及到的源代码全部采用Win32汇编语言编写。Win32病毒同时也是所有病毒中数量极多，破坏性极大，技巧性最强的一类病毒。譬如FunLove、中国黑客等病毒都是属于这
图像处理之透明混合 - Alpha Blending效果
web开发
11-09 1153
基本原理： 图像的透明混合有个专属名词– Alpha Blending 对任意两张图像可以合成为一张图像，合成图像的像素取值根据数学公式： RGB3 = (1- a) * RGB1 + a * RGB2 其中a为混合透明度取值范围[0, 1]之间, RGB3为目标像素值, RGB1与RGB2的值分别来自两 张不同的图像。 两张源图像分别为： 第二张源图像是房屋设计图 ...
AlphaBlend 头文件
最新发布
03-19
AlphaBlend是Windows API中的一个函数，用于实现图像的混合效果。它位于Winuser.h头文件中。 以下是AlphaBlend函数的声明： ```cpp BOOL AlphaBlend( HDC hdcDest, int xoriginDest, int yoriginDest, int ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值