Disclaimer Information in this document is provided in connection with Intel products. No license, express or implied, by estoppel or otherwise, to any intellectual property rights is granted by this document. Except as provided in Intel's Terms and Conditions of Sale for such products, Intel assumes no liability whatsoever, and Intel disclaims any express or implied warranty, relating to sale and/or use of Intel products including liability or warranties relating to fitness for a particular purpose, merchantability, or infringement of any patent, copyright or other intellectual property right. Intel products are not intended for use in medical, life saving, or life sustaining applications. Intel may make changes to specifications and product descriptions at any time, without notice. Copyright © Intel Corporation (1996). Thirdparty brands and names are the property of their respective owners.

The Intel Architecture MMX™ technology extensions use a Single Instruction Multiple Data (SIMD) technique to increase the efficiency of the software by operating on multiple data elements in parallel. In addition to the scalar registers the availability of eight 64bit registers can potentially decrease the usage of memory as temporary space thus reducing costly memory accesses. This application note illustrates how to use the MMX^{ }technology to achieve better performance in generating Mandelbrot Set fractals. In graphics applications fractal geometry methods are used to realistically describe and generate natural objects such as mountains and clouds. Unlike continuous Euclidean shapes fractal objects retain their sharpness on magnification, such that as the camera gets closer to an object smaller detail becomes more visible. In this paper the code for an MMX technology function, a scalar assembly function, and a floating point function are presented, and performance and accuracy tradeoffs are explained. Note that the concepts and coding tricks used in this paper are applicable to fractal functions other than the Mandelbrot Set. Figure 1 shows a sample Mandelbrot Set fractal.
Figure 1: Sample Mandelbrot Set Fractal
Fractal geometry uses procedures to describe fragmented or irregular shaped objects. In theory these objects are represented with procedures which are repeated infinitely. However, for graphical applications, the procedures are run for a finite count. There are several classes of fractals, and one of these uses nonlinear transformations named "invariant fractal sets". The Mandelbrot set, which is a selfsquaring fractal, is included in this class.
The Mandelbrot set is the set of complex values that do not diverge under the squaring transformation. In this application note, a complex number, z is defined to be an ordered pair of real numbers and is defined as:
z=x + jy ;where x=Re(z), y=Im(z)
The real and imaginary parts will further be referenced as c.r and c.i respectively.
Thus the squaring transformation for the Mandelbrot set can be written as:
z_{0} = z
z_{k} = z^{2}_{k1} + z_{0}, k=1,2,3,...
z_{k} is repeatedly calculated until it can be determined whether or not the transform is diverging.The fractal is the boundary of the convergence region in the complex plane.
To generate the Mandelbrot set a window is chosen in the complex plane. The major part of the set is in the region:
2.25 <= Re(z) <= 0.75
1.25 <= Im(z) <= 1.25
By selecting smaller windows in this range one can effectively zoom in and generate more detailed images. The algorithm maps the positions in this region to color coded pixel positions on the display surface. By using the magnitude of the complex number one can determine whether or not the number will diverge quickly. One can set a magnitude limit and iterate until this limit is reached or an arbitrary iteration limit is reached. The iteration count then can be used as an index to a color palette and the resulting pixel color is put on the display surface. The high level algorithm implemented in C is given below:
void mandelbrot ( rMin, rInc, iMin, iInc, cols, rows) { int xc, yc, ccount; COMPLEX zInit; PALETTE LocalPalette[256]; // rInc is defined as (rMax  rMin) /cols; // iInc is defined as (iMax  iMin) /rows; zInit.r = rMin; for (xc=0; xc<cols; xc++) { zInit.i = iMin; for (yc=0; yc<rows; yc++) { ccount = Iterate(zInit); PutPixel (xc, yc, LocalPalette[ccount]); zInit.i = zInit.i + iInc; } zInit.r = zInit.r + rInc; } }
int Iterate (COMPLEX zInit) { int cnt= 0; COMPLEX z; z= zInit; do { z = ComplexSqr(z); c.r = c.r + zInit.r; c.i = c.i + zInit.i; cnt++; } while ((c.r*c.r+c.i*c.i <=4.0) & (cnt <255)); return cnt; } COMPLEX ComplexSqr(COMPLEX c) { COMPLEX result; result.x = c.r * c.r  c.i * c.i ; result.y = 2 * c.r * c.i ; return result; }
Figure 2. The High Level Algorithm Implemented in C
The Mandelbrot function as shown in Figure 2 calculates the color intensity for each pixel and maps them to the display surface. The size of the display surface is defined by the row and column size, and the complex window is defined by the complex values passed in to the function. The color intensity value is returned by the iterate function. The maximum limit for the iteration count is set to 256, which will give 256 different colors with a 256 color palette. At each iteration the complex number is squared and incremented by the delta values. Then the magnitude for the resulting complex number is calculated and checked against the value 4.0. If the magnitude is equal or higher than 4.0 the iteration count is returned. In the event that the magnitude does not diverge the maximum iteration count is returned.
The real and imaginary parts of the complex numbers are each represented as a word (16bits) in fixed point notation 5.11 (five bits for the whole part and eleven bits for the fractional part). This format was chosen because the window for the Mandelbrot set can be represented with one decimal digit for the whole part. Five bits are sufficient to represent the whole part of the signed number in binary. Eleven fractional bits provide a reasonably sharp image. As sections of the image are enlarged a certain loss of precision is possible.
By using words to represent the real and imaginary parts, two complex numbers can be stored in one 64bit register, as shown in Figure 3. It is desirable to store multiple numbers in the registers so that they can be manipulated in parallel with MMX^{ }instructions.
Figure 3: Complex Numbers in 64bit Register
The loop iteration count, which also represents the color intensity index, is an unsigned byte. Even though eight bits are enough to access the palette a 32bit integer register is used to avoid prefix penalties. The color palette is an array of 256 24bit RGB values derived from the Microsoft Windows System Palette.
Several MMX^{ }technology registers are used to hold intermediate values to avoid partial read/writes to memory. As discussed in Section 2.0, the algorithm requires real and imaginary increment values to be added to complex numbers in the two loops which process x and ycoordinates. Two 64bit registers are initialized with the appropriate values to perform the increments in one cycle. The register contents are displayed in Figure 4, below.
Figure 4: Increment Value Registers
Both the complex number magnitude and the iteration count need to be checked at the innermost loop. To avoid two separate compares these two values are stored in one 64bit register, and one compare instruction is used. The register is shown in Figure 5.
Figure 5: Magnitude/Iteration Count Register
In this section the data setup is explained in detail to show how to effectively pass 32bit and 16bit parameters to functions. The parameters to the function are:
mandmmx( hdc, ptrmparams, CWIN_HEIGHT, CWIN_WIDTH, ptrPal);
The hdc is a window handle which is a 32bit value and ptrmparams is a 32bit pointer to the MMXPARAMS struct which contains the values for the complex window range. CWIN_HEIGHT and CWIN_WIDTH are 32bit integer values for the display surface size, and the ptrPal is a 32bit pointer to the palette used. Please note that all parameters passed to the function are 32bit aligned. The structure, MMXPARAMS, is of particular interest since by setting the data up properly we can avoid partial memory accesses and also read data 64bits at a time. The structure is 16bit word aligned. As explained in Section 3 the Mandelbrot MMX^{ }technology code operates on 16bit words, however, passing in the parameters as 16bit values would have been costly due to partial reads. The structure is defined as:
typedef struct defMMXPARAMS { int mm2_1; //rMin int mm2_2; //iMin int mm3_1; //0 int mm3_2; //iInc int mm4_1; //rInc int mm4_2; //iMin } MMXPARAMS;
As the structure element names imply, the first two values are loaded as a 64bit value into the register mm2, the next two into mm3, and the last two into mm4. A packssdw instruction is performed on all three registers to set the data up as 16bit words. The data setup code is given in Figure 6. Memory is accessed sequentially to shorten memory access time. Instructions are out of order for proper pairing.
mov edi, mparams ;pointer to mparams xor edx, edx ;clear xcoor counter movq mm2, [edi] ;load mm2 rMin iMin movq mm3, [edi+8] ;load mm3 0 iInc packssdw mm2, mm2 ;mm2 = rMin iMin rMin iMin movq mm4, [edi+16] ;load mm4 rInc iMin packssdw mm3, mm3 ;mm3 = 0 iInc 0 iInc packssdw mm4, mm4 ;mm4 = rInc iMin rInc iMin
Figure 6: Data Setup Code
The registers are formatted as shown below to facilitate efficiency in the code. The reason this format was chosen will be evident when the code is discussed later on.
after loading after packing to 16bits MM2 rMin iMin rMin iMin rMin iMin MM3 0 iInc 0 iInc 0 iInc MM4 rInc iMin rInc iMin rInc iMin
The MMX^{ }technology code is written using the algorithm given in Figure 2. At the top level there are two loops, one incrementing the xcoordinate and the other incrementing the ycoordinate. The iteration loop where the code spends most of its time is the innermost loop. A section of code is used to set up the stack for the Windows function to display the pixel on the surface. Each of these sections will be described below.
The code section in Figure 7 shows the two top level loops. The code's efficiency is contained in the method that the increments are performed. The code shown is not optimized.
loopx: movq mm0, mm2 ;mm0 gets a copy of m2 xor ecx, ecx ;clear y coor counter loopy: pxor mm5, mm5 ;clear count and magnitude register xor eax, eax ;color/count register iter: ;;This is the iteration loop doneiter: ;Set pixel data and make the call call SetPixelV@16 ;call to SetPixelV paddsw mm2, mm3 ;add iInc to mm2 movq mm0, mm2 ;mm0 gets m2 inc ecx ;increment yloop counter cmp ecx, rows ;done yet? jne loopy pand mm2, dword ptr EVENWORDMASK ;mm2 rval 0 rval 0 paddsw mm2, mm4 ;add rInc to mm2 inc edx ;increment x loop counter cmp edx, cols ;done yet? jne loopx
Figure 7: The Top Level Loops
In the iteration loop, MMX^{ }instructions are used to operate on multiple data in parallel to speed up the calculations. For instructional purposes the code given here is not optimized. The performance optimized code, which is given in Appendix A, needs to be examined carefully to understand the high instruction per clock ratio of this particular section.
iter: movq mm1, mm0 ;mm0=mm1 is c.r c.i c.r c.i pmullw mm1, dword ptr NEGMASK ; mm1 = c.r c.i c.r c.i pmaddwd mm1, mm0 ;multiply add mm1, mm0 psrad mm1, 11 ;adjust precision for fix pt punpckldq mm5, mm1 ;mm5 was 0 curcnt ;mm5 is now check curcnt pcmpgtd mm5, dword ptr CHECKCTRMASK ; check if mm5 greater than 4.0 255 ; if mm5 has any 1's then ; either condition was true packssdw mm5, mm5 ;pack upper and lower dwords into words movd ebx, mm5 ;ebx gets mm5 cmp ebx, 0h ;check if ebx is all zeros jne doneiter ;if not we are done iterating inc eax ;increment color/counter register movd mm5, eax ;lower dword of mm5 is color/cnter value psrlq mm1, 32 ;mm1 0 res.r movq mm6,mm0 ;mm6 gets a copy of mm0 psrlq mm0, 16 ;mm0 = 0 c.r c.i c.r pand mm0, dword ptr ODDWORDMASK ;mm0 = 0 c.r 0 c.r pmaddwd mm0, mm6 ;mm0 is 0+c.r*c.i 0+c.r*c.i psrad mm0, 10 ;adjust precision for fx pt ;actually (fracbits1) for the multiply. punpckldq mm0, mm1 ;mm0 res.r res.i packssdw mm0, mm0 ;mm0 is res.r res.i res.r res.i paddsw mm0,mm2 ;mm1 is z^2+z0 jmp iter
Figure 8: The Iteration Loop
There is no pairing shown in the above code. Figure 8 is a translation of the code in Figure 2 to MMX technology without regard to optimization. Note that in the first section with one pmaddwd instruction both the result.r and the magnitude are calculated. Also, by using the mm5 register to perform the compare both the magnitude and the maximum iteration count are checked in parallel. During the calculation of result.i the multiply by two is done without an extra shift or multiply instruction by shifting right one less than the number of fractional bits.
Even in this form, the MMX technology code will be quite efficient However, there are register dependencies on
registers mm0, mm1, and mm5 since the operations are performed sequentially. By taking some of the
instructions which work on mm0 and interleaving them with the instructions which use mm1 and mm5, the pairing
can be increased while lowering penalties. The resulting code with the optimal pairing is in Appendix A.
Pixel mapping to the display surface is accomplished by using the Windows API function SetPixelV. The parameters for this function must be pushed on the stack before the call is made. The integer registers are not preserved on returning from the function. Note that using this function is not the most optimal way of putting the pixels on the display surface. However, it keeps the overall algorithm simpler. It is also possible to store the pixel information in the memory and then use a high level block transfer function to update the display. Interested readers are encouraged to try this approach.
The sequence to call the SetPixelV is given below:
mov eax, PPal[eax] ;index to the palette mov ebx,hdc ;the handle push eax ;the color push ecx ;the y coor push edx ;the x coor push ebx call SetPixelV@16 ;call to SetPixelV ;@16 is reqired when the function ;is called from an assembly routine.
Figure 9: Pixel Display
The Mandelbrot algorithm shown in Figure 2 has also been implemented using integer assembly and floating point code. These two versions are also included in Appendix A.
Note that the integer scalar code uses 32bit registers but the fixed point format is left as 5.11. Prefix penalties are avoided by using 32bit registers and 32bit instructions. Since there are different exit conditions from the innermost loop, it is very difficult to save variables on the stack and retrieve them. Thus, memory is used to store most of the intermediate values. Wherever possible registers are saved on the stack. There is no apparent way to operate on two complex numbers simultaneously. However, with careful use of all available general purpose registers, penalties are avoided. Also note that imul instructions take ten clocks, as opposed to the single clock needed to issue pmaddwd instructions.
The floating point code uses single precision numbers. The code flow is similar to the integer version. One of the drawbacks is having to perform operations on the top of the stack as mandated by the definition of the instructions. This increases dependency on previous values and causes pipeline stalls. Additionally, saving from the top of the stack to memory takes several clock cycles. Floating point multiply instructions take three clocks each as opposed to the ten required by imul.
The executable file for the Mandelbrot Set is also included for downloading. This code is meant to be run under Microsoft Windows '95 OS on an Intel system with an MMX technology processor, and has not been tested on any other systems. The program can be run to obtain the number of CPU clocks execution takes with different complex windows.
The user can select either default parameters or custom parameters for the complex window. Once parameters are entered, the user executes the "run" instruction and the display is updated.
Table 12) Performance Numbers
TITLE mandmmx ;***************************************************************************/ ;* ;* This program has been developed by Intel Corporation. ;* You have Intel's permission to incorporate this code ;* into your product, royalty free. Intel has various ;* intellectual property rights which it may assert under ;* certain circumstances, such as if another manufacturer's ;* processor misidentifies itself as being "GenuineIntel" ;* when the CPUID instruction is executed. ;* ;* Intel specifically disclaims all warranties, express or ;* implied, and all liability, including consequential and ;* other indirect damages, for the use of this code, ;* including liability for infringement of any proprietary ;* rights, and including the warranties of merchantability ;* and fitness for a particular purpose. Intel does not ;* assume any responsibility for any errors which may ;* appear in this code nor any responsibility to update it. ;* ;* * Other brands and names are the property of their respective ;* owners. ;* ;***************************************************************************/ ; This program was assembled with Microsoft MASM 6.11d ; ; prevent listing of iammx.inc file .nolist INCLUDE iammx.inc ; IAMMX Macros .list .586 .model FLAT, STDCALL extern SetPixelV@16:proc ;Needed to put pixels on the surface ;**************************************************************************** ; Data Segment Declarations ;**************************************************************************** .data ODDWORDMASK QWORD 0000FFFF0000FFFFh EVENWORDMASK QWORD 0FFFF0000FFFF0000h EVENDWORDMASK QWORD 0FFFFFFFF00000000h NEGMASK QWORD 0001FFFF00010001h CHECKCTRMASK QWORD 00001FFF000000FFh FOUR DD 4.0; do not delete the period. ;Local vars for the mandfpu fzinitX DD ? fzinitY DD ? fzX DD ? fzY DD ? frInc DD ? fiInc DD ? ;Local vars for the mandasm zinitX DWORD ? zinitY DWORD ? zX DWORD ? zY DWORD ? temp DWORD ? temp1 DWORD ? ;**************************************************************************** ; Constant Segment Declarations ;**************************************************************************** .const ;**************************************************************************** ; Code Segment Declarations ;**************************************************************************** .code COMMENT ^ void mandmmx ( int *hdc, int mparams int cols, int rows, int PPal) ; ^ mandmmx PROC NEAR C USES eax ebx ecx edx, hdc: PTR DWORD, mparams: DWORD, cols: DWORD, rows: DWORD, PPal: DWORD mov edi, mparams ;pointer to mparams xor edx, edx ;clear xcoor counter movq mm2, [edi] ;load mm2 rMin iMin movq mm3, [edi+8] ;load mm3 0 iInc packssdw mm2, mm2 ;mm2 = rMin iMin rMin iMin movq mm4, [edi+16] ;load mm4 rInc iMin packssdw mm3, mm3 ;mm3 = 0 iInc 0 iInc packssdw mm4, mm4 ;mm4 = rInc iMin rInc iMin loopx: movq mm0, mm2 ;mm0 gets a copy of m2 xor ecx, ecx ;clear y coor counter loopy: pxor mm5, mm5 ;clear count and magnitude register xor eax, eax ;color/count register iter: movq mm1, mm0 ;mm0=mm1 is c.x c.y c.x c.y pmullw mm1, dword ptr NEGMASK ; mm1 = c.x c.y c.x c.y movq mm6,mm0 ;mm6 gets a copy of mm0 pmaddwd mm1, mm0 ;multiply add mm1, mm0 psrlq mm0, 16 ;mm0 = 0 c.x c.y c.x pand mm0, dword ptr ODDWORDMASK ;mm0 = 0 c.x 0 c.x psrad mm1, 11 ;adjust precision for fix pt punpckldq mm5, mm1 ;mm5 was 0 curcnt ;mm5 is now check curcnt pmaddwd mm0, mm6 ;mm0 is 0+c.x*c.y 0+c.x*c.y pcmpgtd mm5, dword ptr CHECKCTRMASK ; check if mm5 greater than 4.0 255 ; if mm5 has any 1's then ; either condition was true psrlq mm1, 32 ; mm1 0 res.x packssdw mm5, mm5 ;pack upper and lower dwords into words psrad mm0, 10 ;adjust precision for fx pt ;actually (fracbits1) for the multiply. movd ebx, mm5 ;ebx gets mm5 cmp ebx, 0h ;check if ebx is all zeros jne doneiter ;if not we are done iterating inc eax ;increment color/counter register punpckldq mm0, mm1 ;mm0 res.x res.y movd mm5, eax ;lower dword of mm5 is color/cnter value packssdw mm0, mm0 ;mm0 is res.x res.y res.x res.y paddsw mm0,mm2 ;mm1 is z^2+z0 jmp iter doneiter: ;Set pixel mov eax, PPal[eax] ;index to the palette push edx ;save xcoor counter push ecx ;save the ycoor counter mov ebx,hdc ;the handle push eax ;the color push ecx ;the y coor push edx ;the x coor push ebx call SetPixelV@16 ;call to SetPixelV paddsw mm2, mm3 ;add iInc to mm2 pop ecx pop edx movq mm0, mm2 ;mm0 gets m2 inc ecx ;increment yloop counter cmp ecx, rows ;done yet? jne loopy pand mm2, dword ptr EVENWORDMASK ;mm2 rval 0 rval 0 inc edx ;increment x loop counter cmp edx, cols ;done yet? paddsw mm2, mm4 ;add rInc to mm2 jne loopx Done: emms ret mandmmx ENDP ;;********************************************************************************* COMMENT ^ void mandasm ( int *hdc, int mparams int cols, int rows, int PPal) ; ^ mandasm PROC NEAR C USES eax ebx ecx edx, hdc: PTR DWORD, mparams: DWORD, cols: DWORD, rows: DWORD, PPal: DWORD mov edi, mparams ;ptr to mparams mov edx, [edi] mov zinitX, edx xor edx, edx ;clear xcoor counter loopx: mov ecx, [edi+8] ;imin mov zinitY, ecx xor ecx, ecx ;clear y coor counter loopy: mov eax, zinitX mov ebx, zinitY mov zX, eax mov zY, ebx xor eax, eax ;color/count register iter: push edx mov ebx, zY ;zY into register ebx mov edx, zX ;zX into register edx imul ebx, zY ;ebx is c.y*c.y imul edx, zX ;edx is c.x*c.x sar ebx, 11 ;shift for fixed pt mov temp, ebx ;temp is c.y*c.y sar edx, 11 ;shift for fixed pt mov temp1, edx ;temp1 is c.x*c.x add ebx, edx ;ebx is c.x*c.x+c.y*c.y pop edx cmp ebx, 01FFFh ;check if ebx is 4 or more jg doneiter ;if so we are done iterating cmp eax, 00FFh ;have we reached the iteration count jg doneiter push edx mov ebx, zY ;zY into register ebx inc eax ;increment counter imul ebx, zX ;ebx is c*x*c.y mov edx, temp1 ;edx gets temp1=c.x*c.x sar ebx, 10 ;2*c.x*c.y aligned for fixed pt. add ebx, zinitY ;ebx is 2*c.x*c.y+zinitY sub edx, temp ;edx is c.x*c.xc.y*c.y mov zY, ebx ;zY is 2*c.x*c.y+zinitY add edx, zinitX ;edx is c.x*c.xc.y*c.y+zinitX mov zX, edx ;zX is c.x*c.xc.y*c.y+zinitX pop edx jmp iter doneiter: ;Set pixel mov eax, PPal[eax] ;index to the palette push edx push ecx mov ebx,hdc ;the handle push eax ;the color push ecx ;the y coor push edx ;the x coor push ebx call SetPixelV@16 ;call to SetPixelV mov edx, zinitY pop ecx add edx, [edi+12] ; add iInc inc ecx ;increment yloop counter mov zinitY, edx ;save new zinitY pop edx cmp ecx, rows ;done yet? jne loopy mov ebx, zinitX inc edx ;increment x loop counter add ebx, [edi+4] ;add rInc cmp edx, cols ;done yet? mov zinitX, ebx ;save new zinitX jne loopx Done: ret mandasm ENDP
;;************************************************************************** COMMENT ^ void mandfpu ( int *hdc, int mparams int cols, int rows, int PPal) ; ^ mandfpu PROC NEAR C USES eax ebx ecx edx, hdc: PTR DWORD, mparams: DWORD, cols: DWORD, rows: DWORD, PPal: DWORD
;;All floating point instructions are in capital letters.
mov edi, mparams ;ptr to mparams FINIT ;initialize the Funit mov edx, [edi] xor eax, eax ;clear eax mov fzinitX, edx ;rMin mov ebx, [edi+4] mov frInc, ebx ;rInc mov ecx, [edi+12] mov fiInc, ecx ;iInc xor edx, edx ;clear xcoor counter loopx: mov ecx, [edi+8] ;iMin mov fzinitY, ecx ;fzinitY set to iMin xor ecx, ecx ;clear y coor counter loopy: mov eax, fzinitX mov ebx, fzinitY mov fzX, eax ;initialize fzX with fzinitX mov fzY, ebx ;initialize fzY with fzinitY xor ebx, ebx ;color intensity register iter: FLD fzY ;load zY to ST FMUL fzY ;ST is c.y*c.y FST ST(1) ;ST(1) is c.y*c.y FLD fzX ;load zX to ST FMUL fzX ;ST is c.x*c.x FST ST(3) ;ST(3) is zX^2 ;ST(3) is zX^2 ;ST(2) is zY^2 ;ST(1) is zY^2 ;ST is zX^2 FADDP ST(1), ST ;ST is c.x*c.x+c.y*c.y FCOMP FOUR ;check if ebx is 4 or more ;ST(1) is zX^2 ;ST is zY^2 FSTSW AX ;flags stored in AX test eax, 4500h ;mag greater then 4. jz doneiter ;if so we are done iterating test eax, 4000h ;mag equal to 4. jnz doneiter ;if so we are done iterating cmp ebx, 00FFh ;have we maxed out on colors? jg doneiter inc ebx ;increment color intensity ;ST(1) is zX^2 ;ST is zY^2 FSUBR ST , ST(1) ;ST=ST(1)ST; FLD fzX ;ST is fzX FMUL fzY ;ST is c.x*c.y FADD ST, ST(0) ;ST is 2*c.x*c.y FADD fzinitY ;ST is 2*c.x*c.y+fzinitY FSTP fzY ;store and pop FADD fzinitX ;ST is c.x*c.xc.y*c.y+fzinitX FSTP fzX ;store and pop ;STACK is empty jmp iter doneiter: ;Set pixel mov eax, PPal[ebx] ;index to the palette push edx push ecx mov ebx,hdc ;the handle push eax ;the color push ecx ;the y coor push edx ;the x coor push ebx call SetPixelV@16 ;call to SetPixelV FLD fzinitY ;ST is fzinitY FADD fiInc ;ST fzinitY+fiInc pop ecx pop edx inc ecx ;increment yloop counter cmp ecx, rows ;done yet? FSTP fzinitY ;fzinitY=fzinitY+fiInc pop ST ;STACK is empty jne loopy FLD fzinitX ;ST is fzinitX inc edx ;increment x loop counter FADD frInc ;ST is zinitX+frInc cmp edx, cols ;done yet? FSTP fzinitX ;fzinitX=fzinitX+frInc pop ST ;STACK is empty jne loopx Done: ret mandfpu ENDP END