二．整个MP3 文件结构：
MP3 文件大体分为三部分：TAG_V2(ID3V2)，Frame, TAG_V1(ID3V1)

ID3V2 包含了作者，作曲，专辑等信息，长度不固定，扩展了ID3V1 的信息量。
Frame 一系列的帧，个数由文件大小和帧长决定
. 每个FRAME 的长度可能不固定，也可能固定，由位率bitrate 决定
. 每个FRAME 又分为帧头和数据实体两部分
. 帧头记录了mp3 的位率，采样率，版本等信息，每个帧之间相互独立
Frame
ID3V1 包含了作者，作曲，专辑等信息，长度为128BYTE。

三．MP3的FRAME 格式：
每个FRAME 都有一个帧头FRAMEHEADER，长度是4BYTE（32bit）,帧头后面可能有两个字节的CRC 校
验，这两个字节的是否存在决定于FRAMEHEADER 信息的第16bit， 为0 则帧头后面无校验，为1 则有校验,
校验值长度为2 个字节，紧跟在FRAMEHEADER 后面，接着就是帧的实体数据了，格式如下：
FRAMEHEADER
CRC（free）
MAIN_DATA
4 BYTE
0 OR 2 BYTE
长度由帧头计算得出

1．帧头FRAMEHEADER 格式如下：
AAAAAAAA AAABBCCD EEEEFFGH IIJJKLMM
13 个帧头字符的含义如下：
Sign Length (bits)
Position (bits)
Description
A 11 (31-21) Frame sync (all bits set with 1)

B 2 (20,19) MPEG Audio version
00 - MPEG Version 2.5       01 - reserved     10 - MPEG Version 2     11 - MPEG Version 1

C 2 (18,17) Layer description
00 - reserved                      01 - Layer III      10 - Layer II                   11 - Layer I

D 1 (16) Protection bit
0 - Protected by CRC (16bit crc follows header)
1 - Not protected

E 4 (15,12) Bitrate index
bits       V1,L1      V1,L2    V1,L3     V2,L1    V2,L2      V2,L3
0000     free          free        free        free       free          free
0001     32            32           32          32          32           8 (8)
0010     64            48         40          64          48          16 (16)
0011     96             56          48          96         56          24 (24)
0100   128            64         56        128          64           32 (32)
0101   160           80          64         160          80          64 (40)
0110   192            96          80         192         96          80 (48)
0111   224          112         96         224         112          56 (56)
1000   256          128        112         256       128          64 (64)
1001   288          160       128         288         160         128 (80)
1010   320          192       160         320         192         160 (96)
1011   352          224       192         352        224         112 (112)
1100   384          256         224         384        256         128 (128)
1101   416          320        256          416        320          256 (144)
1110   448          384       320         448        384          320 (160)
1111   bad          bad        bad         bad     bad bad
NOTES: All values are in kbps
V1 - MPEG Version 1
V2 - MPEG Version 2 and Version 2.5
L1 - Layer I
L2 - Layer II
L3 - Layer III
"free" means variable bitrate.
"bad" means that this is not an allowed value
The values in parentheses are from different sources which
claim that those values are valid for V2,L2 and V2,L3. If
anyone can confirm please let me know.

F 2 (11,10) Sampling rate frequency index (values are in Hz)
bits    MPEG1   MPEG2     MPEG2.5
00      44100       22050      11025
01      48000       24000      12000
10      32000       16000       8000
11       reserv.       reserv.    reserv.

G 1 (9) Padding bit
0 - frame is not padded     1 - frame is padded with one extra bit

H 1 (8) Private bit (unknown purpose)

I 2 (7,6) Channel Mode
00 - Stereo
01 - Joint stereo (Stereo)
10 - Dual channel (Stereo)
11 - Single channel (Mono)

J 2 (5,4) Mode extension (Only if Joint stereo)
value Intensity stereo MS stereo
00    off off
01    on off
10    off on
11    on on

K 1 (3) Copyright
0 - Audio is not copyrighted
1 - Audio is copyrighted

L 1 (2) Original
0 - Copy of original media
1 - Original media

M 2 (1,0) Emphasis
00 - none
01 - 50/15 ms
10 - reserved
11 - CCIT J.17

1）每帧的播放时间：无论帧长是多少，每帧的播放时间都是26ms；
2）数据帧大小:
FrameSize = (((MpegVersion == MPEG1 ? 144 : 72) * Bitrate) / SamplingRate) + PaddingBit
例如: Bitrate ＝ 128000, a SamplingRate ＝44100, and PaddingBit ＝ 1
FrameSize = (144 * 128000) / 44100 + 1 = 417 bytes

2．MAIN_DATA：
MAIN_DATA 部分长度是否变化决定于FRAMEHEADER 的bitrate是否变化，一首MP3 歌曲，它有三个版本：96Kbps（96 千比特位每秒）、128Kbps 和192Kbps。Kbps （比特位速率）， 表明了音乐每秒的数据量，Kbps 值越高，音质越好，文件也越大，MP3标准规定，不变的bitrate 的MP3 文件称作CBR，大多数MP3 文件都是CBR 的，而变化的bitrate 的MP3 文件称作VBR， 每个FRAME 的长度都可能是变化的。下面是CBR 和VBR 的不同点：
1）CBR：固定位率的FRAME 的大小也是固定的（公式如上所述），只要知道文件总长度，和帧长即可由播放每帧需26ms 计算得出mp3 播放的总时间，也可通过计数帧的个数控制快进、快退慢放等操作。
2）VBR：VBR 是XING 公司推出的算法，所以在MP3 的FRAME 里会有“XING"这个关键字（现在很多流行的小软件也可以进行VBR 压缩，它们是否遵守这个约定，那就不得而知了），它存放在MP3 文件中的第一个有效FRAME 里，它标识了这个MP3 文件是VBR 的。同时第一个FRAME 里存放了MP3 文件的FRAME 的总个数，这就很容易获得了播放总时间，同时还有100 个字节存放了播放总时间的100 个时间分段的FRAME 的INDEX，假设4 分钟的MP3 歌曲，240S， 分成100 段，每两个相邻INDEX 的时间差就是2.4S， 所以通过这个INDEX，只要前后处理少数的FRAME，就能快速找出我们需要快进的FRAME 头，可参考下文：
This system was created to minimize file lengths and to preserve sound quality.
Higher frequencies generally needs more space for encoding (thats why many codecs cut all
frequencies above cca 16kHz) and lower tones requires less. So if some part of song doesnt consist
of higher tones then using eg. 192kbps is wasting of space. It should be enough to use only eg.
96kbps.
And it is the principle of VBR. Codec looks over frame and then choose bitrate suitable for its
sound quality.
It sounds perfect but it brings some problems:
If you want to jump over 2 minutes in song, it is not a problem with CBR because you are able
simply count amount of Bytes which is necessary to skip. But it is impossible with VBR. Frame
lengths should be arbitrary so you have to either go frame by frame and counts (time consuming
and very unpractical) or use another mechanism for approximate count.
If you want to cut 5 minutes from the middle of VBR file (all we know CDs where last song takes
10 minutes but 5 minutes is a pure silence, HELL!) problems are the same.
Result? VBR files are more difficult for controlling and adjusting. And I dont like feeling that
sound quality changes in every moment. And AFAIK many codecs have problems with creation VBR in good quality.
Personally I cant see any reason why to use VBR -I dont give a **** if size of one CD in MP3
is 55 MB with CBR or 51 MB with VBR. But everybody has a different taste... some people prefer
VBR.
VBR File Structure is the same as for CBR. But the first frame doesnt contain audio data and it is used for special information about VBR file.
Structure of the first frame(the table as follow):

Byte    Content
0-3   Standard audio frame header (as descripted above). Mostly it contains values FF
FB 30 4C, from which you can count FrameLen = 156 Bytes. And thats exactly enough
space for storing VBR info.
This header contains some important information valid for the whole file:
-MPEG (MPEG1 or MPEG2)
-SAMPLING rate frequency index
-CHANNEL (JointStereo etc.)
4-x Not used till string "Xing" (58 69 6E 67). This string is used as a main VBR file
identifier. If it is not found, file is supposed to be CBR. This string can be placed
at different locations according to values of MPEG and CHANNEL (ya, these from a
few lines upwards):
36-39 "Xing" for MPEG1 and CHANNEL != mono (mostly used)
21-24 "Xing" for MPEG1 and CHANNEL == mono
21-24 "Xing" for MPEG2 and CHANNEL != mono
13-16 "Xing" for MPEG2 and CHANNEL == mono
After "Xing" string there are placed flags, number of frames in file and a size
of file in Bytes. Each of these items has 4 Bytes and it is stored as ''int'' number
in memory. The first is the most significant Byte and the last is the least.
Following schema is for MPEG1 and CHANNEL != mon
40-43 Flags
Value Name Description
00 00 00 01 Frames Flag set if value for number of frames in file is stored
00 00 00 02 Bytes Flag set if value for filesize in Bytes is stored
00 00 00 04 TOC Flag set if values for TOC (see below) are stored
00 00 00 08 VBR Scale Flag set if values for VBR scale are stored
All these values can be stored simultaneously.
44-47 Frames
Number of frames in file (including the first info one)
48-51 Bytes
File length in Bytes
52-151 TOC (Table of Contents)
Contains of 100 indexes (one Byte length) for easier lookup in file. Approximately
solves problem with moving inside file.
Each Byte has a value according this formula:
(TOC[i] / 256) * fileLenInBytes
So if song lasts eg. 240 sec. and you want to jump to 60. sec. (and file is 5 000
000 Bytes length) you can use:
TOC[(60/240)*100] = TOC[25]
and corresponding Byte in file is then approximately at:
(TOC[25]/256) * 5000000
If you want to trim VBR file you should also reconstruct Frames, Bytes and TOC
properly.
152-155 VBR Scale
I dont know exactly system of storing of this values but this item probably doesnt
have deeper meaning.

四．ID3v1
ID3V1 比较简单，它是存放在MP3 文件的末尾，用16 进制的编辑器打开一个MP3 文件，查看其末尾
的128 个顺序存放字节，数据结构定义如下：
typedef struct tagID3V1
{
char Header[3]; /*标签头必须是"TAG"否则认为没有标签*/
char Title[30]; /*标题*/
char Artist[30]; /*作者*/
char Album[30]; /*专集*/
char Year[4]; /*出品年代*/
char Comment[28]; /*备注*/
char reserve; /*保留*/
char track;; /*音轨*/
char Genre; /*类型*/
}ID3V1,*pID3V1;
ID3V1 的各项信息都是顺序存放，没有任何标识将其分开，比如标题信息不足30 个字节，则使用''\0''
补足，否则将造成信息错误。Genre使用原码表示，对照表如下：
/* Standard genres */
0="Blues";
1="ClassicRock";
2="Country";
3="Dance";
4="Disco";
5="Funk";
6="Grunge";
7="Hip-Hop";
8="Jazz";
9="Metal";
10="NewAge";
11="Oldies";
12="Other";
13="Pop";
14="R&B";
15="Rap";
16="Reggae";
17="Rock";
18="Techno";
19="Industrial";
20="Alternative";
21="Ska";
22="DeathMetal";
23="Pranks";
24="Soundtrack";
25="Euro-Techno";
26="Ambient";
27="Trip-Hop";
28="Vocal";
29="Jazz+Funk";
30="Fusion";
31="Trance";
32="Classical";
33="Instrumental";
34="Acid";
35="House";
36="Game";
37="SoundClip";
38="Gospel";
39="Noise";
40="AlternRock";
41="Bass";
42="Soul";
43="Punk";
44="Space";
45="Meditative";
46="InstrumentalPop";
47="InstrumentalRock";
48="Ethnic";
49="Gothic";
50="Darkwave";
51="Techno-Industrial";
52="Electronic";
53="Pop-Folk";
54="Eurodance";
55="Dream";
56="SouthernRock";
57="Comedy";
58="Cult";
59="Gangsta";
60="Top40";
61="ChristianRap";
62="Pop/Funk";
63="Jungle";
64="NativeAmerican";
65="Cabaret";
66="NewWave";
67="Psychadelic";
68="Rave";
69="Showtunes";
70="Trailer";
71="Lo-Fi";
72="Tribal";
73="AcidPunk";
74="AcidJazz";
75="Polka";
76="Retro";
77="Musical";
78="Rock&Roll";
79="HardRock";
/* Extended genres */
80="Folk";
81="Folk-Rock";
82="NationalFolk";
83="Swing";
84="FastFusion";
85="Bebob";
86="Latin";
87="Revival";
88="Celtic";
89="Bluegrass";
90="Avantgarde";
91="GothicRock";
92="ProgessiveRock";
93="PsychedelicRock";
94="SymphonicRock";
95="SlowRock";
96="BigBand";
97="Chorus";
98="EasyListening";
99="Acoustic";
100="Humour";
101="Speech";
102="Chanson";
103="Opera";
104="ChamberMusic";
105="Sonata";
106="Symphony";
107="BootyBass";
108="Primus";
109="PornGroove";
110="Satire";
111="SlowJam";
112="Club";
113="Tango";
114="Samba";
115="Folklore";
116="Ballad";
117="PowerBallad";
118="RhythmicSoul";
119="Freestyle";
120="Duet";
121="PunkRock";
122="DrumSolo";
123="Acapella";
124="Euro-House";
125="DanceHall";
126="Goa";
127="Drum&Bass";
128="Club-House";
129="Hardcore";
130="Terror";
131="Indie";
132="BritPop";
133="Negerpunk";
134="PolskPunk";
135="Beat";
136="ChristianGangstaRap";
137="HeavyMetal";
138="BlackMetal";
139="Crossover";
140="ContemporaryChristian";
141="ChristianRock";
142="Merengue";
143="Salsa";
144="TrashMetal";
145="Anime";
146="JPop";
147="Synthpop";

五．ID3V2
ID3V2 到现在一共有4 个版本，但流行的播放软件一般只支持第3 版， 既ID3v2.3。由于ID3V1 记录
在MP3 文件的末尾，ID3V2就只好记录在MP3 文件的首部了(如果有一天发布ID3V3，真不知道该记录在哪
里)。也正是由于这个原因，对ID3V2 的操作比ID3V1 要慢。而且ID3V2 结构比ID3V1 的结构要复杂得多，
但比前者全面且可以伸缩和扩展。
下面就介绍一下ID3V2.3。
每个ID3V2.3 的标签都一个标签头和若干个标签帧或一个扩展标签头组成。关于曲目的信息如标题、作者
等都存放在不同的标签帧中，扩展标签头和标签帧并不是必要的，但每个标签至少要有一个标签帧。标签
头和标签帧一起顺序存放在MP3 文件的首部。
1、标签头
在文件的首部顺序记录10 个字节的ID3V2.3 的头部。数据结构如下：
char Header[3]; /*必须为"ID3"否则认为标签不存在*/
char Ver; /*版本号ID3V2.3 就记录3*/
char Revision; /*副版本号此版本记录为0*/
char Flag; /*存放标志的字节，这个版本只定义了三位，稍后详细解说*/
char Size[4]; /*标签大小，包括标签头的10 个字节和所有的标签帧的大小*/
1）.标志字节
标志字节一般为0，定义如下：
abc00000
a -- 表示是否使用Unsynchronisation(这个单词不知道是什么意思，字典里也没有找到，一般不设置)
b -- 表示是否有扩展头部，一般没有(至少Winamp 没有记录)，所以一般也不设置
c -- 表示是否为测试标签(99.99%的标签都不是测试用的啦，所以一般也不设置)
2）.标签大小
一共四个字节，但每个字节只用7 位，最高位不使用恒为0。所以格式如下
0xxxxxxx 0xxxxxxx 0xxxxxxx 0xxxxxxx
计算大小时要将0 去掉，得到一个28 位的二进制数，就是标签大小(不懂为什么要这样做)，计算公式如
下：
int total_size;
total_size = (Size[0]&0x7F)*0x200000
+(Size[1]&0x7F)*0x400
+(Size[2]&0x7F)*0x80
+(Size[3]&0x7F)
2、标签帧
每个标签帧都有一个10 个字节的帧头和至少一个字节的不固定长度的内容组成。它们也是顺序存放在文件
中，和标签头和其他的标签帧也没有特殊的字符分隔。得到一个完整的帧的内容只有从帧头中的到内容大
小后才能读出，读取时要注意大小，不要将其他帧的内容或帧头读入。
帧头的定义如下：
char FrameID[4]; /*用四个字符标识一个帧，说明其内容，稍后有常用的标识对照表*/
char Size[4]; /*帧内容的大小，不包括帧头，不得小于1*/
char Flags[2]; /*存放标志，只定义了6 位，稍后详细解说*/
1）.帧标识
用四个字符标识一个帧，说明一个帧的内容含义，常用的对照如下：
TIT2=标题 表示内容为这首歌的标题，下同
TPE1=作者
TALB=专集
TRCK=音轨 格式：N/M 其中N 为专集中的第N 首，M为专集中共M 首，N和M 为ASCII 码表示的数字
TYER=年代 是用ASCII 码表示的数字
TCON=类型 直接用字符串表示
COMM=备注 格式："eng\0备注内容"，其中eng 表示备注所使用的自然语言
2）.大小
这个可没有标签头的算法那么麻烦，每个字节的8 位全用，格式如下
xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx
算法如下：
int FSize;
FSize = Size[0]*0x100000000
+Size[1]*0x10000
+Size[2]*0x100
+Size[3];
3）.标志
只定义了6 位，另外的10 位为0，但大部分的情况下16 位都为0 就可以了。格式如下：
abc00000 ijk00000
a -- 标签保护标志，设置时认为此帧作废
b -- 文件保护标志，设置时认为此帧作废
c -- 只读标志，设置时认为此帧不能修改(但我没有找到一个软件理会这个标志)
i -- 压缩标志，设置时一个字节存放两个BCD 码表示数字
j -- 加密标志(没有见过哪个MP3 文件的标签用了加密)
k -- 组标志，设置时说明此帧和其他的某帧是一组
值得一提的是winamp 在保存和读取帧内容的时候会在内容前面加个''\0''，并把这个字节计算在帧内容的
大小中。
附：帧标识的含义
4）. Declared ID3v2 frames
The following frames are declared in this draft.
AENC Audio encryption
APIC Attached picture
COMM Comments
COMR Commercial frame
ENCR Encryption method registration
EQUA Equalization
ETCO Event timing codes
GEOB General encapsulated object
GRID Group identification registration
IPLS Involved people list
LINK Linked information
MCDI Music CD identifier
MLLT MPEG location lookup table
OWNE Ownership frame
PRIV Private frame
PCNT Play counter
POPM Popularimeter
POSS Position synchronisation frame
RBUF Recommended buffer size
RVAD Relative volume adjustment
RVRB Reverb
SYLT Synchronized lyric/text
SYTC Synchronized tempo codes
TALB Album/Movie/Show title
TBPM BPM (beats per minute)
TCOM Composer
TCON Content type
TCOP Copyright message
TDAT Date
TDLY Playlist delay
TENC Encoded by
TEXT Lyricist/Text writer
TFLT File type
TIME Time
TIT1 Content group description
TIT2 Title/songname/content description
TIT3 Subtitle/Description refinement
TKEY Initial key
TLAN Language(s)
TLEN Length
TMED Media type
TOAL Original album/movie/show title
TOFN Original filename
TOLY Original lyricist(s)/text writer(s)
TOPE Original artist(s)/performer(s)
TORY Original release year
TOWN File owner/licensee
TPE1 Lead performer(s)/Soloist(s)
TPE2 Band/orchestra/accompaniment
TPE3 Conductor/performer refinement
TPE4 Interpreted, remixed, or otherwise modified by
TPOS Part of a set
TPUB Publisher
TRCK Track number/Position in set
TRDA Recording dates
TRSN Internet radio station name
TRSO Internet radio station owner
TSIZ Size
TSRC ISRC (international standard recording code)
TSSE Software/Hardware and settings used for encoding
TYER Year
TXXX User defined text information frame
UFID Unique file identifier
USER Terms of use
USLT Unsychronized lyric/text transcription
WCOM Commercial information
WCOP Copyright/Legal information
WOAF Official audio file webpage
WOAR Official artist/performer webpage
WOAS Official audio source webpage
WORS Official internet radio station homepage
WPAY Payment
WPUB Publishers official webpage
WXXX User defined URL link frame

也可以不用内联汇编直接用函数,MS的最新的SDK和INTEL的编译器都支持这种方式
#include <xmmintrin.h>                            //使用所必须包含的头文件
__m64 a=_mm_set_pi16(1, 2, 3, 4);       //向a中写入4个16位的整数
__m64 b=_mm_set_pi16(5, 6, 7, 8);      //最后一位写入最低位，即8写入最低位
a=_m_paddsw(a,b);                               //完成16位加法运算
_m_empty;                                             //一样不要忘记擦PP，嘿嘿

以上只是最基本最简单的介绍，MMX一共有57条指令，包括基本算术运算指令，比较指令，转换指令，逻辑指令，位移和传输指令，此处就不一一列举，详细的指令介绍请参看INTEL的官方网站。但请记住MMX是针对整数运算的，千万不要用于浮点运算，浮点运算要用更为强大的SSE指令完成，预知SSE详解且待下回分解。

Basic Structure of SSE2
SSE2 works just like any other set of assembly calls. There are registers in which data can be stored and operations that can execute on these registers. Each register is 16 bytes (2 doubles). The 8 registers are named xmm0 through xmm7.

Basics
Some Code
inline void Add(double *x, double *y, double *retval)
{
asm
{
    // Copy the first 16 bytes into xmm0, starting at the memory x points to
    movupd xmm0, [x]
    // Copy the first 16 bytes into xmm1, starting at the memory y points to
    movupd xmm1, [y]
    // Add the 2 doubles in xmm1 to the 2 doubles in xmm0, and put the
    // result in xmm0, overwriting the previous data stored there
    addpd xmm0, xmm1
    // Copy the 16 bytes of data in xmm0 to the memory ret points to
    movupd [retval], xmm0
}
}
Hopefully my comments before each line were enough to let you know what was going on. In case they weren't, I'll go into a little more detail about each line.

    asm{}
This keyword lets your compiler know that the code you are giving it will be in assembly and that it should compile it as such. It also, conveniently, tells the compiler to inline the code. This means that there is NO overhead for the asm block.

    movupd xmm0, [x]
    movupd xmm1, [y]
This command copies data from the second operand to the first; as always in Intel syntax, the asm is in dest, src order. By putting brackets around the x, we tell the mov command to copy the data that x points to the actual value of the pointer. The square brackets can be thought of as a method of dereferencing a pointer.

    addpd xmm0, xmm1
This is the line that does the actual arithmetic. It takes the value from the 2nd operand, src, and adds it to the 1st operand, dest, and stores the resulting value in the 1st operand, dest.

    movupd [retval], xmm0
Here, we copy the data that is in xmm0 to the memory that retval points to. Again, the square brackets dereference the variable retval in the same way that a '*' does in C/C++.

Some more operations
subpd dest, src // subtract dest from src, store in dest
mulpd dest, src // multiply dest and src, store in dest
divpd dest, src // divide src by dest, store in dest
minpd dest, src // store the smallest value, either dest or src, in dest
maxpd dest, src // store the largest value, either dest or src, in dest
sqrtpd dest, src // take the square root of src and put the result in dest
A full list of SSE2 operations and a description of each can be found at HAYES Technologies.

Making the Most Of SSE2
The Faster Move Instruction
Up until now, we have been using movapd to move data to and from our registers. This is much slower than the instruction movapd which does the exact same thing, but assumes that the data is 16 byte aligned. This means that the pointer supplied must be divisible by 16. This becomes a rather large problem if you are compiling your code with gcc or the one supplied with Microsoft Visual C++. One solution to this problem is to use a different compiler such as one that Intel provides. The inherent problem with this is that the Intel compiler is not freeware like gcc. If you have already spent money on some other compiler, you probably do not want to spend more on this new compiler. One hack that I have come up with is the following:

#define AllignData(data) (void *)(((int)data + 15) &~ 0x0F)

//or an inline function if you prefer:

inline void *AllignData(void *data)
{
return (void *)(((int)data + 15) &~ 0x0F);
}

void main
{
const int sizeofdata = 512;

double *lotsofdata;
double *tempptr;

tempptr = new double[sizeofdata + 2];
lotsofdata = AllignData(tempptr);

asm
{
      movapd xmm0, [lotsofdata];
      // do lots of CPU intensive SSE2 operations on lotsofdata here
}

delete [] tempptr;
lotsofdata = 0;
// do not delete lotsofdata, just set it to 0, the memory it
// points to is no longer valid
}
What we need for this instruction to work is memory that has a 16-byte alligned memory address.

Memory that is 16byte alligned:

When we use the new command in C/C++ to allocate memory, we are given memory that may or may not be 16byte alligned. So, what we do, is instead of using the very first bit of our memory block, we start using it at the first place that is 16byte alligned.
-- yellow is unusbale, green is what we actually use --

By doing this, we waste the memory that comes before the first 16-byte alligned memory address. Normally this is not too big of a problem as the overhead is only once per memory block and if we are allocating large amounts of memory at once, 1 or even 12 bytes will hardly make a difference. The only problem with this is that by not using the beginning of our memory, we end up having a smaller amount of usable memory than we asked for. In the worst case, 15 bytes are not usable:

Therefore, to make sure that we get a specific number of usable bytes, we allocate at least 15 extra bytes. In the case of allocating double values, this means we must allocate an extra 2 doubles, giving us 16 extra bytes:

If you are not using doubles, just make sure that at least 15 extra bytes are allocated. Just determine the size of the data type and compute how many are needed to give you the needed padding.

Another important thing to notice is that we delete the variable that holds the original pointer to all of our memory. If you try to delete the memory starting in the middle of our memory block, you cause a general protection fault and have a memory leak.

Ordering Your Operations
One thing that is often over looked is the order that registers are used. When an operation is performed, there is a delay while the result is bieng moved to its destination. if the next operation requires this value, it must wait for it to be stored into the register. If however, the next operation does not need this data, it does not need to wait for it to be stored, it can go ahead and execute at the same time that the previous result is getting stored.

For instance, there will be a speed difference between the following two code segments:

#1:

asm
{
movupd xmm0, [x]   // xmm0 = x
movupd xmm1, [y]   // xmm1 = y
movupd xmm2, [z]   // xmm2 = z
movupd xmm3, [w]   // xmm3 = w

movapd xmm4, xmm2 // xmm4 = z
movapd xmm5, xmm1 // xmm5 = y
movapd xmm6, xmm0 // xmm6 = x
   
addpd xmm2, xmm3   // xmm2 = z + w
addpd xmm1, xmm2   // xmm1 = y + z + w
addpd xmm0, xmm1   // xmm0 = x + y + z + w

mulpd xmm4, xmm3   // xmm4 = z * w
mulpd xmm5, xmm4   // xmm5 = y * z * w
mulpd xmm6, xmm5   // xmm6 = x * y * z * w

divpd xmm0, xmm6   // xmm0 = (x * y * z * w) / (x + y + z + w)

movupd [ret], xmm0 // ret = (x * y * z * w) / (x + y + z + w)
}
#2:

asm
{
movupd xmm0, [x]   // xmm0 = x
movupd xmm1, [y]   // xmm1 = y
movupd xmm2, [z]   // xmm2 = z
movupd xmm3, [w]   // xmm3 = w

movapd xmm4, xmm2 // xmm4 = z
movapd xmm5, xmm1 // xmm5 = y
movapd xmm6, xmm0 // xmm6 = x
   
addpd xmm2, xmm3   // xmm2 = z + w
mulpd xmm4, xmm3   // xmm4 = z * w
addpd xmm1, xmm2   // xmm1 = y + z + w
mulpd xmm5, xmm4   // xmm5 = y * z * w
addpd xmm0, xmm1   // xmm0 = x + y + z + w
mulpd xmm6, xmm5   // xmm6 = x * y * z * w

divpd xmm0, xmm6   // xmm0 = (x * y * z * w) / (x + y + z + w)

movupd [ret], xmm0 // ret = (x * y * z * w) / (x + y + z + w)
}
The second piece of code will run faster. This is because in the second case, there are only 2 cases where one instruction relies on the data from the previous one to perform its computations. Because of this, instructions can be executed immediately after the previous one finsihes instead of waiting for it to store its result in the registers.

Don't get carried away
A common mistake made by people new to SSE2 is to convert a lot of their old and future code into SSE2. This can actually result in slower code. The reason for this is the very large overhead for the CPU to copy memory to the registers. If you have an application that is doing a small number of operations on a large data set, you can expect to be less efficient than if you are doing a lot of operations on a small amount of data.

Compiling SSE2 with gcc/g++
The first thing that you need to remember to do when you want to compile SSE2 embedded C/C++ code with gcc/g++, is to throw in the -masm=intel switch during compile. You must also put ".intel_syntax noprefix" in front of your asm code and surround it with quotes like this:

    asm(".intel_syntax noprefix\n");
    asm("    mov eax, x\n");
    asm("    movupd xmm0, [eax+0x00]\n");
    asm("    movupd xmm1, [eax+0x10]\n");
    asm("    addpd xmm0, xmm1\n");
    asm("    movupd [eax+0x20], xmm0\n");

    or

    asm(".intel_syntax noprefix
         mov eax, x
         movupd xmm0, [eax+0x00]
         movupd xmm1, [eax+0x10]
         addpd xmm0, xmm1
         movupd [eax+0x20], xmm0\n");
Note that the asm block is inside "()" not "{}". Also, if you want to use a variable declared in your C/C++ code, you must define it publicly. Any variables defined locally, whether inside your main function, inside a for loop, etc, will not be seen by the linker and will be considered an "undefined reference".

本文来自CSDN博客，转载出处：http://blog.csdn.net/liu_chulong/articles/833911.aspx

　　SIMD（single-instruction, multiple-data）是一种使用单道指令处理多道数据流的CPU执行模式，即在一个CPU指令执行周期内用一道指令完成处理多个数据的操作。考虑一下下面这个任务：计算一个很长的浮点型数组中每一个元素的平方根。实现这个任务的算法可以这样写：

    for each f in array //对数组中的每一个元素
    f = sqrt(f) //计算它的平方根

为了了解实现的细节，我们把上面的代码这样写：

    for each f in array
    {
        把f从内存加载到浮点寄存器
        计算平方根
        再把计算结果从寄存器中取出放入内存
    }

具有Intel SSE指令集支持的处理器有8个128位的寄存器，每一个寄存器可以存放4个（32位）单精度的浮点数。SSE同时提供了一个指令集，其中的指令可以允许把浮点数加载到这些128位的寄存器之中，这些数就可以在这些寄存器中进行算术逻辑运算，然后把结果放回内存。采用SSE技术后，算法可以写成下面的样子：

    for each 4 members in array //对数组中的每4个元素
    {
        把数组中的这4个数加载到一个128位的SSE寄存器中
        在一个CPU指令执行周期中完成计算这4个数的平方根的操作
        把所得的4个结果取出写入内存
    }

C++编程人员在使用SSE指令函数编程时不必关心这些128位的寄存器，你可以使用128位的数据类型“__m128”和一系列C++函数来实现这些算术和逻辑操作，而决定程序使用哪个SSE寄存器以及代码优化是C++编译器的任务。当需要对很长的浮点数数组中的元素进行处理的时候，SSE技术确实是一种很高效的方法。

SSE程序设计详细介绍

包含的头文件：

所有的SSE指令函数和__m128数据类型都在xmmintrin.h文件中定义：

    #include <xmmintrin.h>

因为程序中用到的SSE处理器指令是由编译器决定，所以它并没有相关的.lib库文件。

　数据分组（Data Alignment）

　　由SSE指令处理的每一个浮点数数组必须把其中需要处理的数每16个字节（128位二进制）分为一组。一个静态数组（static array）可由__declspec(align(16))关键字声明：

    __declspec(align(16)) float m_fArray[ARRAY_SIZE];

动态数组（dynamic array）可由_aligned_malloc函数为其分配空间：

    m_fArray = (float*) _aligned_malloc(ARRAY_SIZE * sizeof(float), 16);

由_aligned_malloc函数分配空间的动态数组可以由_aligned_free函数释放其占用的空间：

    _aligned_free(m_fArray);

　__m128 数据类型

　　该数据类型的变量可用做SSE指令的操作数，它们不能被用户指令直接存取。_m128类型的变量被自动分配为16个字节的字长。

　CPU对SSE指令集的支持

　　如果你的CPU能够具有了SSE指令集，你就可以使用Visual Studio .NET 2003提供的对SSE指令集支持的C++函数库了，你可以查看MSDN中的一个Visual C++ CPUID的例子[4]，它可以帮你检测你的CPU是否支持SSE、MMX指令集或其它的CPU功能。

　编程实例

　　以下讲解了SSE技术在Visual Studio .NET 2003下的应用实例，你可以在http://www.codeproject.com/cpp/sseintro/SSE_src.zip下载示例程序压缩包。该压缩包中含有两个项目，这两个项目是基于微软基本类库（MFC）建立的Visual C++.NET项目，你也可以按照下面的讲解建立这两个项目。

　SSETest 示例项目

SSETest项目是一个基于对话框的应用程序，它用到了三个浮点数组参与运算：

    fResult[i] = sqrt( fSource1[i]*fSource1[i] + fSource2[i]*fSource2[i] ) + 0.5

其中i = 0, 1, 2 ... ARRAY_SIZE-1

其中ARRAY_SIZE被定义为30000。数据源数组（Source数组）通过使用sin和cos函数给它赋值，我们用Kris Jearakul开发的瀑布状图表控件（Waterfall chart control）[3] 来显示参与计算的源数组和结果数组。计算所需的时间(以毫秒ms为单位)在对话框中显示出来。我们使用三种不同的途径来完成计算：

纯C++代码；
使用SSE指令函数的C++代码；
包含SSE汇编指令的代码。

　纯C++代码：

    void CSSETestDlg::ComputeArrayCPlusPlus(
                                            float* pArray1, // [输入] 源数组1
                                            float* pArray2, // [输入] 源数组2
                                            float* pResult, // [输出] 用来存放结果的数组
                                            int nSize) // [输入] 数组的大小
    {

        int i;

        float* pSource1 = pArray1;
        float* pSource2 = pArray2;
        float* pDest = pResult;

        for ( i = 0; i < nSize; i++ )
        {
            *pDest = (float)sqrt((*pSource1) * (*pSource1) + (*pSource2) * (*pSource2)) + 0.5f;

            pSource1++;
            pSource2++;
            pDest++;
        }
    }

　　下面我们用具有SSE特性的C++代码重写上面这个函数。为了查询使用SSE指令C++函数的方法，我参考了Intel软件说明书（Intel Software manuals）中有关SSE汇编指令的说明，首先我是在第一卷的第九章找到的相关SSE指令，然后在第二卷找到了这些SSE指令的详细说明，这些说明有一部分涉及了与其特性相关的C++函数。然后我通过这些SSE指令对应的C++函数查找了MSDN中与其相关的说明。搜索的结果见下表：
　
实现的功能 对应的SSE汇编指令 Visual C++.NET中的SSE函数
将4个32位浮点数放进一个128位的存储单元。 movss 和 shufps _mm_set_ps1
将4对32位浮点数同时进行相乘操作。这4对32位浮点数来自两个128位的存储单元，再把计算结果（乘积）赋给一个128位的存储单元。 mulps _mm_mul_ps
将4对32位浮点数同时进行相加操作。这4对32位浮点数来自两个128位的存储单元，再把计算结果（相加之和）赋给一个128位的存储单元。 addps _mm_add_ps
对一个128位存储单元中的4个32位浮点数同时进行求平方根操作。 sqrtps _mm_sqrt_ps

　使用Visual C++.NET的 SSE指令函数的代码：

    void CSSETestDlg::ComputeArrayCPlusPlusSSE(
                                                float* pArray1, // [输入] 源数组1
                                                float* pArray2, // [输入] 源数组2
                                                float* pResult, // [输出] 用来存放结果的数组
                                                int nSize) // [输入] 数组的大小
    {
        int nLoop = nSize/ 4;

        __m128 m1, m2, m3, m4;

        __m128* pSrc1 = (__m128*) pArray1;
        __m128* pSrc2 = (__m128*) pArray2;
        __m128* pDest = (__m128*) pResult;

        __m128 m0_5 = _mm_set_ps1(0.5f); // m0_5[0, 1, 2, 3] = 0.5

        for ( int i = 0; i < nLoop; i++ )
        {
            m1 = _mm_mul_ps(*pSrc1, *pSrc1); // m1 = *pSrc1 * *pSrc1
            m2 = _mm_mul_ps(*pSrc2, *pSrc2); // m2 = *pSrc2 * *pSrc2
            m3 = _mm_add_ps(m1, m2); // m3 = m1 + m2
            m4 = _mm_sqrt_ps(m3); // m4 = sqrt(m3)
            *pDest = _mm_add_ps(m4, m0_5); // *pDest = m4 + 0.5

            pSrc1++;
            pSrc2++;
            pDest++;
        }
    }

　使用SSE汇编指令实现的C++函数代码：

    void CSSETestDlg::ComputeArrayAssemblySSE(
                                                float* pArray1, // [输入] 源数组1
                                                float* pArray2, // [输入] 源数组2
                                                float* pResult, // [输出] 用来存放结果的数组
                                                int nSize) // [输入] 数组的大小
    {
        int nLoop = nSize/4;
        float f = 0.5f;

        _asm
        {
            movss xmm2, f // xmm2[0] = 0.5
            shufps xmm2, xmm2, 0 // xmm2[1, 2, 3] = xmm2[0]

            mov esi, pArray1 // 输入的源数组1的地址送往esi
            mov edx, pArray2 // 输入的源数组2的地址送往edx

            mov edi, pResult // 输出结果数组的地址保存在edi
            mov ecx, nLoop //循环次数送往ecx

start_loop:
            movaps xmm0, [esi] // xmm0 = [esi]
            mulps xmm0, xmm0 // xmm0 = xmm0 * xmm0

            movaps xmm1, [edx] // xmm1 = [edx]
            mulps xmm1, xmm1 // xmm1 = xmm1 * xmm1

            addps xmm0, xmm1 // xmm0 = xmm0 + xmm1
            sqrtps xmm0, xmm0 // xmm0 = sqrt(xmm0)

            addps xmm0, xmm2 // xmm0 = xmm1 + xmm2

            movaps [edi], xmm0 // [edi] = xmm0

            add esi, 16 // esi += 16
            add edx, 16 // edx += 16
            add edi, 16 // edi += 16

            dec ecx // ecx--
            jnz start_loop //如果不为0则转向start_loop
        }
    }

最后，在我的计算机上运行计算测试的结果：

纯C++代码计算所用的时间是26 毫秒
使用SSE的C++ 函数计算所用的时间是 9 毫秒
包含SSE汇编指令的C++代码计算所用的时间是 9 毫秒

以上的时间结果是在Release优化编译后执行程序得出的。

SSESample 示例项目

SSESample项目是一个基于对话框的应用程序，其中它用下面的浮点数数组进行计算：

    fResult[i] = sqrt(fSource[i]*2.8)

其中i = 0, 1, 2 ... ARRAY_SIZE-1

这个程序同时计算了数组中的最大值和最小值。ARRAY_SIZE被定义为100000，数组中的计算结果在列表框中显示出来。其中在我的机子上用下面三种方法计算所需的时间是：
    纯C++代码计算 6 毫秒
    使用SSE的C++ 函数计算 3 毫秒
    使用SSE汇编指令计算 2 毫秒

大家看到，使用SSE汇编指令计算的结果会好一些，因为使用了效率增强了的SSX寄存器组。但是在通常情况下，使用SSE的C++ 函数计算会比汇编代码计算的效率更高一些，因为C++编译器的优化后的代码有很高的运算效率，若要使汇编代码比优化后的代码运算效率更高，这通常是很难做到的。

　纯C++代码：

    // 输入: m_fInitialArray
    // 输出: m_fResultArray, m_fMin, m_fMax
    void CSSESampleDlg::OnBnClickedButtonCplusplus()
    {
        m_fMin = FLT_MAX;
        m_fMax = FLT_MIN;

        int i;

        for ( i = 0; i < ARRAY_SIZE; i++ )
        {
            m_fResultArray[i] = sqrt(m_fInitialArray[i] * 2.8f);

            if ( m_fResultArray[i] < m_fMin )
                m_fMin = m_fResultArray[i];

            if ( m_fResultArray[i] > m_fMax )
                m_fMax = m_fResultArray[i];
        }
    }

　使用Visual C++.NET的 SSE指令函数的代码：

    // 输入: m_fInitialArray
    // 输出: m_fResultArray, m_fMin, m_fMax
    void CSSESampleDlg::OnBnClickedButtonSseC()
    {
        __m128 coeff = _mm_set_ps1(2.8f); // coeff[0, 1, 2, 3] = 2.8
        __m128 tmp;

        __m128 min128 = _mm_set_ps1(FLT_MAX); // min128[0, 1, 2, 3] = FLT_MAX
        __m128 max128 = _mm_set_ps1(FLT_MIN); // max128[0, 1, 2, 3] = FLT_MIN

        __m128* pSource = (__m128*) m_fInitialArray;
        __m128* pDest = (__m128*) m_fResultArray;

        for ( int i = 0; i < ARRAY_SIZE/4; i++ )
        {
            tmp = _mm_mul_ps(*pSource, coeff); // tmp = *pSource * coeff
            *pDest = _mm_sqrt_ps(tmp); // *pDest = sqrt(tmp)

            min128 = _mm_min_ps(*pDest, min128);
            max128 = _mm_max_ps(*pDest, max128);

            pSource++;
            pDest++;
        }

        // 计算max128的最大值和min128的最小值
        union u
        {
            __m128 m;
            float f[4];
        } x;

        x.m = min128;
        m_fMin = min(x.f[0], min(x.f[1], min(x.f[2], x.f[3])));

        x.m = max128;
        m_fMax = max(x.f[0], max(x.f[1], max(x.f[2], x.f[3])));
    }

　使用SSE汇编指令的C++函数代码：

    // 输入: m_fInitialArray
    // 输出: m_fResultArray, m_fMin, m_fMax
    void CSSESampleDlg::OnBnClickedButtonSseAssembly()
    {

        float* pIn = m_fInitialArray;
        float* pOut = m_fResultArray;

        float f = 2.8f;
        float flt_min = FLT_MIN;
        float flt_max = FLT_MAX;

        __m128 min128;
        __m128 max128;

        // 使用以下的附加寄存器:xmm2、xmm3、xmm4:
        // xmm2 – 相乘系数
        // xmm3 – 最小值
        // xmm4 – 最大值

        _asm
        {
            movss xmm2, f // xmm2[0] = 2.8
            shufps xmm2, xmm2, 0 // xmm2[1, 2, 3] = xmm2[0]

            movss xmm3, flt_max // xmm3 = FLT_MAX
            shufps xmm3, xmm3, 0 // xmm3[1, 2, 3] = xmm3[0]

            movss xmm4, flt_min // xmm4 = FLT_MIN
            shufps xmm4, xmm4, 0 // xmm3[1, 2, 3] = xmm3[0]

            mov esi, pIn // 输入数组的地址送往esi
            mov edi, pOut // 输出数组的地址送往edi
            mov ecx, ARRAY_SIZE/4 // 循环计数器初始化

start_loop:
            movaps xmm1, [esi] // xmm1 = [esi]
            mulps xmm1, xmm2 // xmm1 = xmm1 * xmm2
            sqrtps xmm1, xmm1 // xmm1 = sqrt(xmm1)
            movaps [edi], xmm1 // [edi] = xmm1

            minps xmm3, xmm1
            maxps xmm4, xmm1

            add esi, 16
            add edi, 16

            dec ecx
            jnz start_loop

            movaps min128, xmm3
            movaps max128, xmm4
        }

        union u
        {
            __m128 m;
            float f[4];
        } x;

        x.m = min128;
        m_fMin = min(x.f[0], min(x.f[1], min(x.f[2], x.f[3])));

        x.m = max128;
        m_fMax = max(x.f[0], max(x.f[1], max(x.f[2], x.f[3])));
    }

参考文档：

[1]MSDN, SSE技术主题：
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vclang/html/vcrefstreamingsimdextensions.asp

[2]Intel软件说明书（Intel Software manuals）：
http://developer.intel.com/design/archives/processors/mmx/index.htm

[3] Kris Jearakul的瀑布状图表控件：http://www.codeguru.com/controls/Waterfall.shtml

[4] Microsoft Visual C++ CPUID示例：
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vcsample/html/vcsamcpuiddeterminecpucapabilities.asp

[5] Matt Pietrek在Microsoft Systems Journal 1998年2月刊上的评论文章：
http://www.microsoft.com/msj/0298/hood0298.aspx 。

本文来自CSDN博客，转载出处：http://blog.csdn.net/liu_chulong/articles/833915.aspx

虽然SSE从理论上来讲要比传统的浮点运算会快，但是他所受的限制也很多，首先，虽然他执行一次相当于四次，会比传统的浮点运算执行4次的速度要快，但是他执行一次的速度却并没有想象中的那么快，所以要体现SSE的速度，必须有Stream做前提，就是大量的流数据，这样才能发挥SIMD的强大作用。其次，SSE支持的数据类型是4个32位（共计128位）浮点数集合，就是C、C++语言中的float[4]，并且必须是以16位字节边界对齐的（稍后会以代码来进行阐释，关于边界对齐的概念，读者可以参考论坛上的其它文章，都会有很详细的解答，我这里就恕不赘述了）。因此这也给输入和输出带来了不少的麻烦，实际上主要影响SSE发挥性能的就是不停的对数据进行复制以适用应它的数据格式。

我是一个C++程序员，对汇编并不很熟，但我又想用SSE来优化我的程序，我该怎么做呢？幸好VC++.net为我们提供了很方便的指令C函数级的封装和C格式数据类型，我们只需像平时写C++代码一样定义变量、调用函数就可以很好的应用SSE指令了。

当然了，我们需要包含一个头文件，这里面包括了我们需要的数据类型和函数的声明：

#include <xmmintrin.h>

SSE运算的标准数据类型只有一个，就是：

__m128，它是这样定义的：

typedef struct __declspec(intrin_type) __declspec(align(16)) __m128 {

   float m128_f32[4];

} __m128;

简化一下，就是：

struct __m128

{

   float m128_f32[4];

};

比如要定义一个__m128变量，并为它赋四个float整数，可以这样写：

__m128 S1 = { 1.0f, 2.0f, 3,0f, 4,0f };

要改变其中第2个（基数为0）元素时可以这样写：

S1.m128_f32[2] = 6.0f;

令外我们还会用到几个赋值的指令，它可以让我们更方便的使用这个数据结构：

S1 = _mm_set_ps1( 2.0f );

它会让S1.m128_f32中的四个元素全部赋予2.0f，这样会比你一个一个赋值要快的多。

S1 = _mm_setzero_ps();

这会让S1中的所有4个浮点数都置零。

还有一些其它的赋值指令，但执行起来还没有自己逐个赋值来的快，只做为一些特殊用途，如果你想了解更多的信息，可以参考MSDN -> VisualC++参考 -> C/C++Language -> C++Language Reference -> Compiler Intrinsics -> MMX, SSE, and SSE2 Intrinsics -> Stream SIMD Extensions(SSE)章节。

一般来讲，所有SSE指令函数都有3个部分组成，中间用下划线隔开：

_mm_set_ps1

mm表示多媒体扩展指令集

set表示此函数的含义缩写

ps1表示该函数对结果变量的影响，由两个字母组成，第一个字母表示对结果变量的影响方式，p表示把结果做为指向一组数据的指针，每一个元素都将参与运算，S表示只将结果变量中的第一个元素参与运算；第二个字母表示参与运算的数据类型。s表示32位浮点数，d表示64位浮点数，i32表示32位定点数，i64表示64位定点数，由于SSE只支持32位浮点数的运算，所以你可能会在这些指令封装函数中找不到包含非s修饰符的，但你可以在MMX和SSE2的指令集中去认识它们。

接下来我举一个例子来说明SSE的指令函数是如何使用的，必须要说明的是我以下的代码都是在VC7.1的平台上写的，不保证对其它如Dev-C++、Borland C++等开发平台的完全兼容。

为了方便对比速度，我会用常归方法和SSE优化两种写法写出，并会用一个测试速度的类CTimer来进行计时。

这个算法是对一组float值进行放大，函数ScaleValue1是使用SSE指令优化的，函数ScaleValue2则没有。我们用10000个元素的float数组数据来测试这两个算法，每个算法运算10000遍，下面是测试程序和结果：

#include <xmmintrin.h>

#include <windows.h>

class CTimer

{

public:

       __forceinline CTimer( void )

       {

              QueryPerformanceFrequency( &m_Frequency );

              QueryPerformanceCounter( &m_StartCount );

       }

       __forceinline void Reset( void )

       {

              QueryPerformanceCounter( &m_StartCount );

       }

       __forceinline double End( void )

       {

              static __int64 nCurCount;

              QueryPerformanceCounter( (PLARGE_INTEGER)&nCurCount );

              return double(( nCurCount - ( *(__int64*)&m_StartCount ) ) )/ double( *(__int64*)&m_Frequency );

       }

private:

       LARGE_INTEGER m_Frequency;

       LARGE_INTEGER m_StartCount;

};

void ScaleValue1( float *pArray, DWORD dwCount, float fScale )

{

       DWORD dwGroupCount = dwCount / 4;

       __m128 e_Scale = _mm_set_ps1( fScale );

       for ( DWORD i = 0; i < dwGroupCount; i++ )

       {

              *(__m128*)( pArray + i * 4 ) = _mm_mul_ps( *(__m128*)( pArray + i * 4 ), e_Scale );

       }

}

void ScaleValue2( float *pArray, DWORD dwCount, float fScale )

{

       for ( DWORD i = 0; i < dwCount; i++ )

       {

              pArray[i] *= fScale;

       }

}

#define ARRAYCOUNT 10000

int __cdecl main()

{

       float __declspec(align(16)) Array[ARRAYCOUNT];

       memset( Array, 0, sizeof(float) * ARRAYCOUNT );

       CTimer t;

       double dTime;

       t.Reset();

      for ( int i = 0; i < 100000; i++ )

       {

              ScaleValue1( Array, ARRAYCOUNT, 1000.0f );

       }

       dTime = t.End();

       cout << "Use SSE：" << dTime << "秒" << endl;

       t.Reset();

       for ( int i = 0; i < 100000; i++ )

       {

              ScaleValue2( Array, ARRAYCOUNT, 1000.0f );

       }

       dTime = t.End();

       cout << "Not Use SSE：" << dTime << "秒" << endl;

       system( "pause" );

       return 0;

}

Use SSE：0.997817

Not Use SSE：2.84963

这里要注意一下，我使用了__declspec(align(16))做为数组定义的修释符，这表示该数组是以16字节为边界对齐的，因为SSE指令只能支持这种格式的内存数据。

本文来自CSDN博客，转载出处：http://blog.csdn.net/liu_chulong/articles/833916.aspx

cvttss2si ecx, xmm0
movss xmm5, _ps_am_1
mov edx, ecx
shl edx, (31 - 1)
cvtsi2ss xmm1, ecx
and edx, 0x80000000
and ecx, 0x1

subss xmm0, xmm1
movss xmm6, _sincos_masks[ecx * 4]
minss xmm0, xmm5

movss xmm1, _ps_sincos_p3
subss xmm5, xmm0

andps xmm5, xmm6
movss xmm7, _ps_sincos_p2
andnps xmm6, xmm0
mov temp, edx
orps xmm5, xmm6
movss xmm0, xmm5

mulss xmm5, xmm5
movss xmm4, _ps_sincos_p1
movss xmm2, xmm5
mulss xmm5, xmm1
movss xmm1, _ps_sincos_p0
addss xmm5, xmm7
mulss xmm5, xmm2
movss xmm3, temp
addss xmm5, xmm4
mulss xmm5, xmm2
orps xmm0, xmm3
addss xmm5, xmm1
mulss xmm0, xmm5

movss   x,    xmm0

}

return x;
}

float _SSE2_cos(float x)
{
__asm
{
movss xmm0, x
movss xmm1, _ps_am_inv_sign_mask
movss xmm2, _ps_am_pi_o_2
movss xmm3, _ps_am_2_o_pi
andps xmm0, xmm1
addss xmm0, xmm2
mulss xmm0, xmm3

pxor xmm3, xmm3
movd xmm5, _epi32_1
movss xmm4, _ps_am_1
cvttps2dq xmm2, xmm0
pand xmm5, xmm2
movd xmm1, _epi32_2
pcmpeqd xmm5, xmm3
cvtdq2ps xmm6, xmm2
pand xmm2, xmm1
pslld xmm2, (31 - 1)

subss xmm0, xmm6
movss xmm3, _ps_sincos_p3
minss xmm0, xmm4
subss xmm4, xmm0
andps xmm0, xmm5
andnps xmm5, xmm4
orps xmm0, xmm5

movaps xmm1, xmm0
movss xmm4, _ps_sincos_p2
mulss xmm0, xmm0
movss xmm5, _ps_sincos_p1
orps xmm1, xmm2
movaps xmm7, xmm0
mulss xmm0, xmm3
movss xmm6, _ps_sincos_p0
addss xmm0, xmm4
mulss xmm0, xmm7
addss xmm0, xmm5
mulss xmm0, xmm7
addss xmm0, xmm6
mulss xmm0, xmm1
movss   x,    xmm0
}

return x;
}

float _SSE_Sqrt(float x)
{

float root = 0.f;
_asm
{
sqrtss xmm0, x
movss root, xmm0
}

return root;
}

本文来自CSDN博客，转载出处：http://blog.csdn.net/liu_chulong/articles/833856.aspx

在这里随便提一个Intel Compiler 8.0,这个编译器的优化能力的确是强，个人感觉大概比Visual C++ 6.0 SP6快10-20%左右，它可以针对不同的CPU作出优化，如果你是P4系列的cpu,在编译的时候加上参数/fast /QxW /Qip /Qunroll40，会有意想不到的结果，如果你再阅读一个它的用户手册，按照里面的方法稍微修改一下程序将会有更多提高，向所有崇拜极限优化的朋友推荐这款编译器。题外话少说，再次转入SSE正题，下面还是给出一个简单的例子:

在VC中使用内联汇编
float a[]={1.0,2.0,3.0,4.0};
float b[]={5.0,6.0,7.0,8.0};
_asm{
mov ecx,a;
mov edx,b;
movaps xmm0,[ecx];
movaps xmm1,[edx];
addps xmm0,xmm1;
movaps [ecx],xmm0;
}

跟MMX一样也可以不用汇编只用包含一个头文件就可以直接在C里面使用了：
#include
__m128 a = _mm_set_ps(1, 2, 3, 4)
__m128 b = _mm_set_ps(5, 6, 7, 8)
a = _mm_add_ps(a, b);
这个时候就感觉使用Intrinsics方便多了，因为它制定了好多合成的伪指令，方便了不少。

下面顺便贴一段SSE的部分指令介绍，更全的可以找Intel下载指令手册。下面这部分是引用至：
http://dwbclz.myetang.com/articles/piii/sse-ins-ref.html

ADDPS

格式：ADDPS xmm1, xmm2/m128

功能：两组单精度数相加

算法：

DEST[31-0] = DEST[31-0] + SRC/m128[31-0] ;
DEST[63-32] = DEST[63-32] + SRC/m128[63-32] ;
DEST[95-64] = DEST[95-64] + SRC/m128[95-64] ;
DEST[127-96] = DEST[127-96] + SRC/m128[127-96];

ADDSS

格式：ADDSS xmm1, xmm2/m32

功能：低位单精度数相加

算法：

DEST[31-0] = DEST[31-0] + SRC/m32[31-0];
DEST[63-32] = DEST[63-32] ;
DEST[95-64] = DEST[95-64] ;
DEST[127-96] = DEST[127-96];

ANDNPS

格式：ANDNPS xmm1, xmm2/m128

功能：xmm1“取反”再和 xmm2/m128 求“与”运算

算法：

DEST[127-0] = NOT (DEST[127-0]) AND SRC/m128[127-0];

ANDPS

格式：ANDPS xmm1, xmm2/m128

功能：进行两个寄存器的逻辑“与”操作

算法：

DEST[127-0] AND= SRC/m128[127-0];

CMPPS

格式：CMPPS xmm1, xmm2/m128, imm8

功能：比较两个寄存器的数值，根据imm8的不同数值采用不同的比较方法

imm8 == 0, ==; imm8 == 1, <; imm8 == 2, <=; imm8 == 3, ;
imm8 == 4, !=; imm8 == 5, !<; imm8 == 6, !<=; imm8 == 7, !;

算法：

IF (imm8 = 0) THEN
OP = "EQ";
ELSEIF (imm8 = 1) THEN
OP = "LT";
ELSEIF (imm8 = 2) THEN
OP = "LE";
ELSEIF (imm8 = 3) THEN
OP = "UNORD";
ELSEIF (imm8 = 4) THEN
OP = "NE";
ELSEIF (imm8 = 5) THEN
OP = "NLT";
ELSEIF (imm8 = 6) THEN
OP = "NLE";
ELSEIF (imm8 = 7) THEN
OP = "ORD";
FI

CMP0 = DEST[31-0] OP SRC/m128[31-0];
CMP1 = DEST[63-32] OP SRC/m128[63-32];
CMP2 = DEST [95-64] OP SRC/m128[95-64];
CMP3 = DEST[127-96] OP SRC/m128[127-96];

IF (CMP0 = TRUE) THEN
DEST[31-0] = 0XFFFFFFFF;
ELSE
DEST[31-0] = 0X00000000;
FI
IF (CMP1 = TRUE) THEN
DEST[63-32] = 0XFFFFFFFF;
ELSE
DEST[63-32] = 0X00000000;
FI
IF (CMP2 = TRUE) THEN
DEST[95-64] = 0XFFFFFFFF;
ELSE
DEST[95-64] = 0X00000000;
FI
IF (CMP3 = TRUE) THEN
DEST[127-96] = 0XFFFFFFFF;
ELSE
DEST[127-96] = 0X00000000;
FI

其它：你可以使用下面的可读性良好的指令

指令 实现
CMPEQPS xmm1, xmm2； CMPPS xmm1,xmm2, 0
CMPLTPS xmm1, xmm2； CMPPS xmm1,xmm2, 1
CMPLEPS xmm1, xmm2； CMPPS xmm1,xmm2, 2
CMPUNORDPS xmm1, xmm2； CMPPS xmm1,xmm2, 3
CMPNEQPS xmm1, xmm2； CMPPS xmm1,xmm2, 4
CMPNLTPS xmm1, xmm2； CMPPS xmm1,xmm2, 5
CMPNLEPS xmm1, xmm2； CMPPS xmm1,xmm2, 6
CMPORDPS xmm1, xmm2； CMPPS xmm1,xmm2, 7

CMPSS

格式：CMPSS xmm1, xmm2/m32, imm8

功能：低位单精度数做比较

算法：算法同CMPPS相似，只不过只是针对DEST[31-0]进行操作。

同样也可以利用可读性更好的指令

指令 实现
CMPEQSS xmm1, xmm2 CMPSS xmm1,xmm2, 0
CMPLTSS xmm1, xmm2 CMPSS xmm1,xmm2, 1
CMPLESS xmm1, xmm2 CMPSS xmm1,xmm2, 2
CMPUNORDSS xmm1, xmm2 CMPSS xmm1,xmm2, 3
CMPNEQSS xmm1, xmm2 CMPSS xmm1,xmm2, 4
CMPNLTSS xmm1, xmm2 CMPSS xmm1,xmm2, 5
CMPNLESS xmm1, xmm2 CMPSS xmm1,xmm2, 6
CMPORDSS xmm1, xmm2 CMPSS xmm1,xmm2, 7

COMISS

格式：COMISS xmm1, xmm2/m32

功能：比较低位数并且设置标识位

算法：

OF = 0;
SF = 0;
AF = 0;
IF ((DEST[31-0] UNORD SRC/m32[31-0]) = TRUE) THEN
ZF = 1;
PF = 1;
CF = 1;
ELSEIF ((DEST[31-0] GTRTHAN SRC/m32[31-0]) = TRUE)THEN
ZF = 0;
PF = 0;
CF = 0;
ELSEIF ((DEST[31-0] LESSTHAN SRC/m32[31-0]) = TRUE THEN
ZF = 0;
PF = 0;
CF = 1;
ELSE
ZF = 1;
PF = 0;
CF = 0;
FI

CVTPI2PS

格式：CVTPI2PS xmm, mm/m64

功能：32位整数转变为浮点数

算法：

DEST[31-0] = (float) (SRC/m64[31-0]) ;
DEST[63-32] = (float) (SRC/m64[63-32]);
DEST[95-64] = DEST[95-64] ;
DEST[127-96] = DEST[127-96];
CVTPS2PI

格式：CVTPS2PI mm, xmm/m64

功能：低位的两个浮点数转变为整数

算法：

DEST[31-0] = (int) (SRC/m64[31-0]);
DEST[63-32]= (int) (SRC/m64[63-32]);

CVTSI2SS

格式：CVTSI2SS xmm, r/m32

功能：32位整数转变为浮点数，存入低位

算法：

DEST[31-0] = (float) (R/m32);
DEST[63-32] = DEST[63-32] ;
DEST[95-64] = DEST[95-64] ;
DEST[127-96] = DEST[127-96];

CVTSS2SI

格式：CVTSS2SI r32, xmm/m32

功能：低位的浮点数转变为32位整数

算法：

r32 = (int) (SRC/m32[31-0]);

CVTTPS2PI

格式：CVTTPS2PI mm, xmm/m64

功能：低位的两个浮点数转变为整数，并且舍位

算法：

DEST[31-0] = (int) (SRC/m64[31-0]) ;
DEST[63-32] = (int) (SRC/m64[63-32]);

CVTTSS2SI

格式：CVTTSS2SI r32, xmm/ m32

功能：将最低位浮点数转换为整数，并舍位。

算法：

r32 = (INT) (SRC/m32[31-0]);

DIVPS

格式：DIVPS xmm1, xmm2/m128

功能：单精度数除法运算

算法：

DEST[31-0] = DEST[31-0] / (SRC/m128[31-0]) ;
DEST[63-32] = DEST[63-32] / (SRC/m128[63-32]) ;
DEST[95-64] = DEST[95-64] / (SRC/m128[95-64]) ;
DEST[127-96] = DEST[127-96] / (SRC/m128[127-96]);

DIVSS

格式：DIVSS xmm1, xmm2/m32

功能：低位单精度数除法

算法：

DEST[31-0] = DEST[31-0] / (SRC/m32[31-0]);
DEST[63-32] = DEST[63-32] ;
DEST[95-64] = DEST[95-64] ;
DEST[127-96] = DEST[127-96];

EMMS

格式：EMMS

功能：将浮点标识字置空

算法：

FPUTagWord <- FFFF

FXRSTOR

格式：FXRSTOR m512byte

功能：从m512byte中装入FP，MMX，以及SSE的状态

算法：

FP and MMX state and Streaming SIMD Extension state = m512byte;

FXSAVE

格式：FXSAVE m512byte

功能：向m512byte中存入FP，MMX，以及SSE的状态

算法：

m512byte = FP and MMX state and Streaming SIMD Extension state;

LDMXCSR

格式：LDMXCSR m32

功能：装入SSE的状态控制字

算法：

MXCSR = m32;

MAXPS

格式：MAXPS xmm1, xmm2/m128

功能：返回最大值

算法：

IF (DEST[31-0]=NaN) THEN
DEST[31-0] = SRC[31-0];
ELSEIF (SRC[31-0] = NaN) THEN
DEST[31-0] = SRC[31-0];
ELSEIF (DEST[31-0] > SRC/m128[31-0]) THEN
DEST[31-0] = DEST[31-0];
ELSE
DEST[31-0] = SRC/m128[31-0];
FI
IF (DEST[63-32]=NaN) THEN
DEST[63-32] = SRC[63-32];
ELSEIF (SRC[63-32] = NaN) THEN
DEST[63-32] = SRC[63-32];
ELSEIF (DEST[63-32] > SRC/m128[63-32]) THEN
DEST[63-32] = DEST[63-32];
ELSE
DEST[63-32] = SRC/m128[63-32];
FI
IF (DEST[95-64]=NaN) THEN
DEST[95-64] = SRC[95-64];
ELSEIF (SRC[95-64] = NaN) THEN
DEST[95-64] = SRC[95-64];
ELSEIF (DEST[95-64] > SRC/m128[95-64]) THEN
DEST[95-64] = DEST[95-64];
ELSE
DEST[95-64] = SRC/m128[95-64];
FI
IF (DEST[127-96]=NaN) THEN
DEST[127-96] = SRC[127-96];
ELSEIF (SRC[127-96] = NaN) THEN
DEST[127-96] = SRC[127-96];
ELSEIF (DEST[127-96] > SRC/m128[127-96]) THEN
DEST[127-96] = DEST[127-96];
ELSE
DEST[127-96] = SRC/m128[127-96];
FI

MAXSS

格式：MAXSS xmm1, xmm2/m32

功能：返回低位最大值

算法：同上面类似，区别在于只对DEST[31-0]进行操作

MINPS

格式：MINPS xmm1, xmm2/m128

功能：返回最小值

算法：略

MINSS

格式：MINSS xmm1, xmm2/m32

功能：返回低位最小值

算法：略

MOVAPS

格式：MOVAPS xmm1, xmm2/m128 或 MOVAPS xmm2/m128, xmm1

功能：对齐的数据传输指令

算法：

IF (destination = DEST) THEN
IF (SRC = m128)THEN (* load instruction *)
DEST[127-0] = m128;
ELSE(* move instruction *)
DEST[127=0] = SRC[127-0];
FI;
ELSE
IF (destination = m128)THEN (* store instruction *)
m128 = SRC[127-0];
ELSE(* move instruction *)
DEST[127-0] = SRC[127-0];
FI;
FI;

MOVHLPS

格式：MOVHLPS xmm1, xmm2

功能：高位的两个数传向低位

算法：

DEST[127-64] = DEST[127-64];
DEST[63-0] = SRC[127-64] ;

MOVHPS

格式：MOVHPS xmm, m64 或 MOVHPS m64, xmm

功能：高位数据传输指令

算法：

IF (destination = DEST) THEN(* load instruction *)
DEST[127-64] = m64;
DEST[31-0] = DEST[31-0];
DEST[63-32] = DEST[63-32];
ELSE (* store instruction *)
m64 = SRC[127-64];
FI;

MOVLPS

格式：MOVLPS xmm, m64 或 MOVLPS m64, xmm

功能：低位数据传输指令

算法：

IF (destination = DEST) THEN(* load instruction *)
DEST[63-0] = m64;
DEST[95-64] = DEST[95-64];
DEST[127-96] = DEST[127-96];
ELSE(* store instruction *)
m64 = DEST[63-0];
FI

MOVLHPS

格式：MOVLHPS xmm1, xmm2

功能：低位的两个数传向高位

算法：

DEST[127-64] = SRC[63-0];
DEST[63-0] = DEST[63-0];

MOVMSKPS

格式：MOVMSKPS r32, xmm

功能：掩码移入32位寄存器

算法：

r32[0] = SRC[31] ;
r32[1] = SRC[63] ;
r32[2] = SRC[95] ;
r32[3] = SRC[127];
r32[7-4] = 0X0 ;
r32[15-8] = 0X00 ;
r32[31-16] = 0X0000 ;

MOVNTPS

格式：MOVNTPS m128, xmm

功能：将数据直接存入内存，减小对缓存的压力

算法：

m128 = SRC;

MOVSS

格式：MOVSS xmm1, xmm2/m32 或 MOVSS xmm2/m32, xmm1

功能：最低位数据的传输指令

算法：

IF (destination = DEST) THEN
IF (SRC == m32) THEN(* load instruction *)
DEST[31-0] = m32;
DEST [63-32] = 0X00000000;
DEST [95-64] = 0X00000000;
DEST [127-96] = 0X00000000;
ELSE(* move instruction *)
DEST [31-0] = SRC[31-0];
DEST [63-32] = DEST [63-32];
DEST [95-64] = DEST [95-64];
DEST [127-96] = DEST [127-96];
FI
ELSE
IF (destination = m32) THEN(* store instruction *)
m32 = SRC[31-0];
ELSE (* move instruction *)
DEST [31-0] = SRC[31-0]
DEST [63-32] = DEST[63-32];
DEST [95-64] = DEST [95-64];
DEST [127-96] = DEST [127-96];
FI
FI

MOVUPS

格式：MOVUPS xmm1, xmm2/m128 或 MOVUPS xmm2/m128, xmm1

功能：非对齐数据的传输指令

算法：

IF (destination = xmm) THEN
IF (SRC = m128)THEN(* load instruction *)
DEST[127-0] = m128;
ELSE (* move instruction *)
DEST[127-0] = SRC[127-0];
FI
ELSE
IF (destination = m128) THEN(* store instruction *)
m128 = SRC[127-0];
ELSE (* move instruction *)
DEST[127-0] = SRC[127-0];
FI
FI

MULPS

格式：MULPS xmm1, xmm2/m128

功能：单精度数相乘

算法：

DEST[31-0] = DEST[31-0] * SRC/m128[31-0] ;
DEST[63-32] = DEST[63-32] * SRC/m128[63-32] ;
DEST[95-64] = DEST[95-64] * SRC/m128[95-64] ;
DEST[127-96] = DEST[127-96] * SRC/m128[127-96];

MULSS

格式：MULSS xmm1, xmm2/m32

功能：最低位的单精度数相乘

算法：

DEST[31-0] = DEST[31-0] * SRC/m32[31-0];
DEST[63-32] = DEST[63-32] ;
DEST[95-64] = DEST[95-64] ;
DEST[127-96] = DEST[127-96];

ORPS

格式：ORPS xmm1, xmm2/m128

功能：求或运算

算法：

DEST[127-0] |= SRC/m128[127-0];
RCPPS

格式：RCPPS xmm1, xmm2/m128

功能：求倒数的近似值

算法：

DEST[31-0] = APPROX (1.0/(SRC/m128[31-0])) ;
DEST[63-32] = APPROX (1.0/(SRC/m128[63-32])) ;
DEST[95-64] = APPROX (1.0/(SRC/m128[95-64])) ;
DEST[127-96] = APPROX (1.0/(SRC/m128[127-96]));

RCPSS

格式：RCPSS xmm1, xmm2/m32

功能：求最低位的倒数的近似值

算法：

DEST[31-0] = APPROX (1.0/(SRC/m32[31-0]));
DEST[63-32] = DEST[63-32] ;
DEST[95-64] = DEST[95-64] ;
DEST[127-96] = DEST[127-96];

RSQRTPS

格式：RSQRTPS xmm1, xmm2/m128

功能：求倒数平方根的近似值

算法：

DEST[31-0] = APPROX (1.0/SQRT(SRC/m128[31-0])) ;
DEST[63-32] = APPROX (1.0/SQRT(SRC/m128[63-32])) ;
DEST[95-64] = APPROX (1.0/SQRT(SRC/m128[95-64])) ;
DEST[127-96] = APPROX (1.0/SQRT(SRC/m128[127-96]));

RSQRTSS

格式：RSQRTSS xmm1, xmm2/m32

功能：求最低位倒数平方根的近似值

算法：

DEST[31-0] = APPROX (1.0/SQRT(SRC/m32[31-0]));
DEST[63-32] = DEST[63-32] ;
DEST[95-64] = DEST[95-64] ;
DEST[127-96] = DEST[127-96];

SHUFPS

格式：SHUFPS xmm1, xmm2/m128, imm8

功能：打乱顺序

算法：

FP_SELECT = (imm8 >> 0) AND 0X3;
IF (FP_SELECT = 0) THEN
DEST[31-0] = DEST[31-0];
ELSEIF (FP_SELECT = 1) THEN
DEST[31-0] = DEST[63-32];
ELSEIF (FP_SELECT = 2) THEN
DEST[31-0] = DEST[95-64];
ELSE
DEST[31-0] = DEST[127-96];
FI

FP_SELECT = (imm8 >> 2) AND 0X3;
IF (FP_SELECT = 0) THEN
DEST[63-32] = DEST[31-0];
ELSEIF (FP_SELECT = 1) THEN
DEST[63-32] = DEST[63-32];
ELSEIF (FP_SELECT = 2) THEN
DEST[63-32] = DEST[95-64];
ELSE
DEST[63-32] = DEST[127-96];
FI

FP_SELECT = (imm8 >> 4) AND 0X3;
IF (FP_SELECT = 0) THEN
DEST[95-64] = SRC/m128[31-0];
ELSEIF (FP_SELECT = 1) THEN
DEST[95-64] = SRC/m128 [63-32];
ELSEIF (FP_SELECT = 2) THEN
DEST[95-64] = SRC/m128 [95-64];
ELSE
DEST[95-64] = SRC/m128 [127-96];
FI

FP_SELECT = (imm8 >> 6) AND 0X3;
IF (FP_SELECT = 0) THEN
DEST[127-96] = SRC/m128 [31-0];
ELSEIF (FP_SELECT = 1) THEN
DEST[127-96] = SRC/m128 [63-32];
ELSEIF (FP_SELECT = 2) THEN
DEST[127-96] = SRC/m128 [95-64];
ELSE
DEST[127-96] = SRC/m128 [127-96];
FI

SQRTPS

格式：SQRTPS xmm1, xmm2/m128

功能：求平方根

算法：

DEST[31-0] = SQRT (SRC/m128[31-0] );
DEST[63-32] = SQRT (SRC/m128[63-32]);
DEST[95-64] = SQRT (SRC/m128[95-64]);
DEST[127-96] = SQRT (SRC/m128[127-96]);

SQRTSS

格式：SQRTSS xmm1, xmm2/m32

功能：最低位数求平方根

算法：

DEST[31-0] = SQRT (SRC/m32[31-0]);
DEST[63-32] = DEST[63-32];
DEST[95-64] = DEST[95-64];
DEST[127-96] = DEST[127-96];

STMXCSR

格式：STMXCSR m32

功能：存储SSE控制字

算法：

m32 = MXCSR;

SUBPS

格式：SUBPS xmm1, xmm2/m128

功能：单精度数的减法运算

算法：

DEST[31-0] = DEST[31-0] - SRC/m128[31-0] ;
DEST[63-32] = DEST[63-32] - SRC/m128[63-32];
DEST[95-64] = DEST[95-64] - SRC/m128[95-64];
DEST[127-96] = DEST[127-96] - SRC/m128[127-96];

SUBSS

格式：SUBSS xmm1, xmm2/m32

功能：最低位数相减

算法：

DEST[31-0] = DEST[31-0] - SRC/m32[31-0];
DEST[63-32] = DEST[63-32];
DEST[95-64] = DEST[95-64];
DEST[127-96] = DEST[127-96];

UCOMISS

格式：UCOMISS xmm1, xmm2/m32

功能：比较低位数并且设置标志位

算法：

OF = 0;
SF = 0;
AF = 0;
IF ((DEST[31-0] UNORD SRC/m32[31-0]) = TRUE) THEN
ZF = 1;
PF = 1;
CF = 1;
ELSEIF ((DEST[31-0] GTRTHAN SRC/m32[31-0]) = TRUE)THEN
ZF = 0;
PF = 0;
CF = 0;
ELSEIF ((DEST[31-0] LESSTHAN SRC/m32[31-0]) = TRUE THEN
ZF = 0;
PF = 0;
CF = 1;
ELSE
ZF = 1;
PF = 0;
CF = 0;
FI

UNPCKHPS

格式：UNPCKHPS xmm1, xmm2/m128

功能：高位两数交替传输

算法：

DEST[31-0] = DEST[95-64];
DEST[63-32] = SRC/m128[95-64];
DEST[95-64] = DEST[127-96];
DEST[127-96] = SRC/m128[127-96];

UNPCKLPS

格式：UNPCKLPS xmm1, xmm2/m128

功能：低位两数交替传输

算法：

DEST[31-0] = DEST[31-0];
DEST[63-32] = SRC/m128[31-0];
DEST[95-64] = DEST[63-32];
DEST[127-96] = SRC/m128[63-32];

XORPS

格式：XORPS xmm1, xmm2/m128

功能：异或运算

算法：

DEST[127-0] = DEST/m128[127-0] XOR SRC/m128[127-0]

本文来自CSDN博客，转载出处：http://blog.csdn.net/liu_chulong/articles/833896.aspx

    AAC(Advanced Audio Coding)也称为MPEG-2 AAC，是一种数据会遗失(lossy)的语音串流压缩标准。AAC是MPEG-2的一部份，是用来取代MP3的，但是AAC和MP3不同，AAC无法向后兼容，MP3可以，例如：MP3可以和MP2兼容。

    AAC最多可以支持48个频道，取样率从8 kHz到96 kHz。AAC的语音分辨率(resolution)比MP3高，一般而言，96 kbps的AAC之语音品质优于或等同于128 kbps的MP3，因此，AAC可以在低速的网络内传输语音串流，而且，不会影响语音的品质。
　　
HE-AAC(AAC+)

    HE(high efficiency) AAC又称为MPEG-4 HE-AAC或简称AAC+，它是MPEG-2 AAC和SBR(Spectral Band Replication)带宽延伸修订版的技术组合。HE-AAC不是要取代AAC，而是要延伸MPEG-4的语音品质，能够以更低的速率传输(32 kbps)。而且，HE-AAC译码器可以对AAC解碼。

    若要产生48 kbps的HE-AAC立体声，HE-AAC编码器会产生两种信号：一个是42 kbps的MPEG AAC信号，另一个是6 kbps的SBR信号。然后，此SBR信号置于MPEG AAC的辅助字段内(该字段是MPEG-4定义的)。最后，构成一个完整48 kbps的MPEG-4 HE-AAC串流。SBR代表高频的成份，而AAC代表低频的成份。HE-AAC译码器使用AAC和SBR信号，产生全频信号；而AAC译码器只使用AAC信号，亦即，只有低频成份被它解碼。

    HE-AAC能传输48 kbps的CD立体声，或128 kbps、5.1声道的“环场声”(surround sound)。这样的效率，使它适用于Internet传输，或移动数字广播。不过，由于HE-AAC的高延迟特性，使它不适用于双向的通信应用。
　　
EAAC+

    Enhanced AAC+(EAAC+)是在2004年时，纳入3GPP的第6版标准中。根据3GPP，它是由MPEG-4 AAC、MPEG-4 SBR和MPEG-4“参数立体声”(Parametric Stereo)技术组合的。“参数立体声”技术能够在低传输率中，进行“立体声”的编码，其基本原理类似SBR。
　　
AMR

    AMR(Adaptive Multi-Rate)标准是在1998年被提出。它的主要功能是提供移动装置使用的基本语音(baseline speech)。它以可变速率的非立体声(mono)传输，速率在4.75 kbps～12.2 kbps之间，它属于窄频，带宽只有3.5 kHz。它被3GPP当成3G无线电网络系统的基本编译码技术；3G是从GSM、WCDMA、EDGE、GPRS演变而来的，而且，不管是2G、2.5G或3G，AMR都是这些无线电网络标准的最基本编译码技术。

    AMR的基本原理是：当通信干扰增加时，就降低编译码速率，而且还能实现更多的校错(error correction)功能。AMR也可以让不同手机系统的编译码技术之间能够尽量兼容，这是靠ACELP(Algebraic Code Excited Linear Prediction)技术达到的。ACELP是一种语音压缩系统，它可以在低速的网络环境中，提供高品质的语音。
　　
AMR-WB

    AMR-WB(wideband extension)是AMR的升级版，它也是使用ACELP技术。2000年12月时，ETSI/3GPP将AMR-WB标准化，并公布于世。ITU-T在2002年采用它，并另命名为G.722.2。

    由于AMR-WB的语音带宽很宽(50 Hz～7 kHz)，所以它的语音品质很高。它具有9种采样速率(都是非立体声)，分别是：23.85 kbps、23.05 kbps、19.85 kbps、18.25 kbps、15.85 kbps、14.25 kbps、12.65 kbps、8.85 kbps、6.6 kbps。其中，能够保持高的语音品质，并且速率最低者是12.65 kbps。AMR-WB已经被UMTS/IMT-2000无线电网络采用，作为它的编译码基本技术；UMTS也是一种3G新标准。
　　
AMR-WB+

    2004年9月，ETSI/3GPP将AMR-WB+标准化。AMR-WB+是AMR-WB的升级版，它使用ACELP和TCX(Transform Coded Excitation)技术，提供高品质的语音和其它音频内容──这包括：自然声、数字音乐、与音乐相混合的声音(voice-between-music/voice-over-music)。

    AMR-WB+增加了立体声信号和支持更高的采样速率。并且，使用高效率的“参数立体声”(HE-PS)技术，能够以低速率传输高品质的立体声。TCX转换编码技术则补偿了ACELP的不足。

    AMR-WB+的采样速率是从6 kbps～48 kbps；立体声的采样速率是8 kbps～48 kbps，非立体声的采样速率是6 kbps～36 kbps。这使得它的语音带宽更宽(24 kHz)，接近CD的语音品质。此外，AMR-WB+可以和AMR-WB兼容。
　　
技术比较

    根据欧洲广播联盟(EBU)的人工测试(其方法称为MUSHRA)，除AMR家族尚未测试以外，编译码后的语音品质最好者是AAC+，在采样率为48 kbps时，它的品质与CD一样好。其它技术的语音品质，按优劣顺序分别是：MP3PRO、AAC、Real 8、7 kHz LPF、WMA 8、MP3、Real G2、3.5 kHz LPF。
按照3GPP的分类，依传输率大小，可区分成两类：

    1. 低于或等于24 kbps者：ARM-WB+、HE-AAC/AAC+、EAAC+。
    2. 高于24 kbps者：HE-AAC/AAC+、EAAC+。

    根据3GPP的MUSHRA测试结果，ARM-WB+在采样率为48 kbps时的语音品质最高。若以ARM-WB+与EAAC+做比较，在采样率低于24 kbps时，ARM-WB+的立体声优于EAAC+。
　　
结语

    目前，AAC和AMR-WB技术已经被使用于2G和2.5手机中。而AAC+、EAAC+和AMR-WB+则被使用于3G手机中。它们的应用如图1所示。音乐手机比视频手机、电视手机更早被市场接受。但是，MP3播放机的价格却一直下滑，所以，音乐手机或音乐播放机极需要AAC+、EAAC+和AMR-WB+的兴起和普及，以带动另一波的购买热潮。

    更好的语音编译码技术会继续推陈换新，但到2010－2015年，当手机的传输率可达到1 Gbps时，追求效率更佳的编解码技术的趋势可能会逐渐消退，不过，编解码技术的内涵仍然是很迷人的。

第一部分软件编程的时间分配概况

   高效率的程序员并不是敲键盘的速度比别人快，而是他有着良好的编程习惯，节省了别人浪费的时间。因此，要想提高自己的编程效率，根本在于怎么少浪费时间。只要能把别人浪费的时间节省下来，你的效率就可以快过别人，甚至数倍于别人。要想节省时间，当然首先需要明白编程中耗费时间的分配情况。

程序员软件开发的几个阶段：

   1、分析设计，

   分析设计的前提是充分理解需求说明文档，然后分析如何实现它们，并形成设计文档。分析设计的目的是明晰软件架构，软件算法和功能的逻辑，得出必要的设计文档，奠定后面编码的基础。合理的设计可以节省后面编码的时间，不合理甚至错误的设计将导致工作的重新开始，没有设计贸然开始编程会导致一些难以预见的逻辑错误。总之，较好的设计事半功倍。

   2、程序编码

   依照语法、设计文档编码。

   3、程序测试

   测试的目的是检测程序有没有问题，一旦发现问题，问题的定位越准，效率就越高。因此，程序中需要输出必要的提示信息。

   4、软件调试

   测试时发现程序有BUG，自然需要调试。显然，遇到的问题越少，调试的时间就越少。没有什么比一次性写好，不用调试更快的方法了。

   时间虽然无法具体分配到各个阶段，但是第一和第二阶段的质量决定了后面两阶段的时间花费，质量越高，测试和调试时间花费越少。反过来，质量越差，测试和调试时间越长。

第二部分 c/c++中常见的错误

   软件编程的过程中，程序员所犯的并不一定是重大错误，反而一些常见的错误屡见不鲜。这些错误严重影响到编程中测试和调试的时间。这一部分总结一下，时时提醒自己，告诫自己避免这些错误。

常见的错误有：

   1、内存泄露

   在c/c++中，内存管理器不会帮助你自动回收不再使用的内存，不管在什么情况下，采取谨慎的态度，杜绝内存泄露的出现，都是上策。尽管一些工具可以帮助我们检查内存泄露问题，但是编程时还是应该仔细一点，尽早排除这类错误，工具只是用作验证的手段。

   2、内存越界访问

1）读越界，即读了不属于自己的数据，如果所读的内存地址是无效的，程度立刻就崩溃了。如果所读内存地址是有效的，虽然读的时候不会出问题，但由于读到的数据是随机的，它会产生不可预料的后果。

2）写越界，也叫缓冲区溢出，所写入的数据对别人来说是随机的，它也会产生不可预料的后果。

内存越界访问造成的后果非常严重，是程序稳定性的致命威胁之一。更麻烦的是，它造成的后果是随机的，表现出来的症状和时机也是随机的，让BUG的现象和本质看似没有什么联系，这给BUG的定位带来极大的困难。一些工具可以够帮助检查内存越界访问的问题，但也不能太依赖于工具。内存越界访问通常是动态出现的，即依赖于测试数据，在极端的情况下才会出现，除非精心设计测试数据，工具也无能为力。工具本身也有一些限制，甚至在一些大型项目中，工具变得完全不可用。比较保险的方法还是在编程是就小心，特别是对于外部传入的参数要仔细检查。

c/c++中，数组中的越界问题尤其常见。例如：

---------------------------------------------------------------------------------------

#include <stdio.h>

#include <stdlib.h>
#include <string.h>

int main(int argc, char* argv[])
{
char str[10];
int array[10] = {0,1,2,3,4,5,6,7,8,9};

int data = array[10];// read error: array[10]
array[10] = data;

if(argc == 2)
{
strcpy(str, argv[1]);// write error: argv[1]的字符串可能字符个数超过10
}

return 0;
}
----------------------------------------------------------------------------------------

   3、野指针

   野指针是指已经释放了的内存指针。当调用free（p）；p本身没有变化，它指向的内存仍然是有效的。释放掉的内存会被内存管理器重新分配，此时，野指针指向的内存已经被赋予新的意义。对野指针指向内存的访问，无论是有意还是无意的，都为此会付出巨大代价，因为它造成的后果，如同越界访问一样是不可预料的。

较好的对策是：释放内存后立即把对应指针置为空值，这是避免野指针常用的方法。这个方法简单有效，只是要注意，当然指针是从函数外层传入的时，在函数内把指针置为空值，对外层的指针没有影响。比如，你在析构函数里把this指针置为空值，没有任何效果，这时应该在函数外层把指针置为空值。

   4、访问空指针

   空指针在C/C++中占有特殊的地址，通常用来判断一个指针的有效性。空指针一般定义为0。现代操作系统都会保留从0开始的一块内存，至于这块内存有多大，视不同的操作系统而定。一旦程序试图访问这块内存，系统就会触发一个异常/信号。

操作系统为什么要保留一块内存，而不是仅仅保留一个字节的内存呢？原因是：一般内存管理都是按页进行管理的，无法单纯保留一个字节，至少要保留一个页面。保留一块内存也有额外的好处，可以检查诸如p==NULL; p[1]之类的内存错误。

在一些嵌入式系统(如arm7)中，从0开始的一块内存是用来安装中断向量的，没有MMU的保护，直接访问这块内存好像不会引发异常。不过这块内存是代码段的，不是程序中有效的变量地址，所以用空指针来判断指针的有效性仍然可行。

   5、引用未初始化的变量

   未初始化变量的内容是随机的(有的编译器会在调试版本中把它们初始化为固定值，如0xcc)，使用这些数据会造成不可预料的后果，调试这样的BUG也是非常困难的。

较好的习惯是：在声明变量时就对它进行初始化。另外也要重视编译器的警告信息，发现有引用未初始化的变量，立即修改过来。

   6、指针运算

   依照指针类型进行指针运算，指针偏移值。

   7、结构的成员顺序变化引起的错误

   如：

-------------------------------------------------------------------------------------

Struct s
{
int l;
char* p;
};

int main(int argc, char* argv[])
{
struct s s1 = {4, "abcd"};

return 0;
}

-------------------------------------------------------------------------------------
以上这种方式是非常危险的，原因在于你对结构的内存布局作了假设。如果这个结构是第三方提供的，他很可能调整结构中成员的相对位置。而这样的调整往往不会在文档中说明，你自然很少去关注。如果调整的两个成员具有相同数据类型，编译时不会有任何警告，而程序的逻辑可能相距十万八千里了。

正确的初始化方法应该是（当然，一个成员一个成员的初始化也行）：

-------------------------------------------------------------------------------------

struct s
{
int l;
char* p;
};

int main(int argc, char* argv[])
{
struct s s1 = {.l=4, .p = "abcd"};

return 0;
}

-------------------------------------------------------------------------------------

   8、结构的大小变化引发的错误

   我们看看下面这个例子：

-------------------------------------------------------------------------------------

struct base
{
int n;

};

struct s
{
struct base b;
int m;
};

-------------------------------------------------------------------------------------
在OOP中，我们可以认为第二个结构继承了第一结构，这有什么问题吗？当然没有，这是C语言中实现继承的基本手法。

现在假设第一个结构是第三方提供的，第二个结构是你自己的。第三方提供的库是以DLL方式分发的，DLL最大好处在于可以独立替换。但随着软件的进化，问题可能就来了。

当第三方在第一个结构中增加了一个新的成员int k;，编译好后把DLL给你，你直接把它给了客户了，让他们替换掉老版本。程序加载时不会有任何问题，在运行逻辑可能完全改变！原因是两个结构的内存布局重叠了。

解决这类错误的唯一办法就是重新编译全部代码。由此看来，动态库并不见得可以动态替换，如果你想了解更多相关内容，建议你阅读《COM本质论》。

   9、分配/释放不配对

   大家都知道malloc要和free配对使用，new要和delete/delete[]配对使用，重载了类new操作，应该同时重载类的delete/delete[]操作。这些都是书上反复强调过的，除非当时晕了头，一般不会犯这样的低级错误。

而有时候我们却被蒙在鼓里，两个代码看起来都是调用的free函数，实际上却调用了不同的实现。比如在Win32下，调试版与发布版，单线程与多线程是不同的运行时库，不同的运行时库使用的是不同的内存管理器。一不小心链接错了库，那你就麻烦了。程序可能动则崩溃，原因在于在一个内存管理器中分配的内存，在另外一个内存管理器中释放时就会出现问题。

10、返回指向临时变量的指针

   大家都知道，栈里面的变量都是临时的。当前函数执行完成时，相关的临时变量和参数都被清除了。不能把指向这些临时变量的指针返回给调用者，这样的指针指向的数据是随机的，会给程序造成不可预料的后果。

下面是个错误的例子：

-------------------------------------------------------------------------------------
char* get_str(void)
{
char str[] = {"abcd"};

return str;
}

int main(int argc, char* argv[])
{

char* p = get_str();

printf("%s\n", p);

return 0;
}

-------------------------------------------------------------------------------------

下面这个例子没有问题，大家知道为什么吗？

-------------------------------------------------------------------------------------
char* get_str(void)
{
char* str = {"abcd"};

return str;
}

int main(int argc, char* argv[])
{

char* p = get_str();

printf("%s\n", p);

return 0;
}

-------------------------------------------------------------------------------------

   11、试图修改常量

   在函数参数前加上const修饰符，只是给编译器做类型检查用的，编译器禁止修改这样的变量。但这并不是强制的，你完全可以用强制类型转换绕过去，一般也不会出什么错。

而全局常量和字符串，用强制类型转换绕过去，运行时仍然会出错。原因在于它们是放在.rodata里面的，而.rodata内存页面是不能修改的。试图对它们修改，会引发内存错误。

下面这个程序在运行时会出错：

-------------------------------------------------------------------------------------
int main(int argc, char* argv[])
{
char* p = "abcd";
*p = '1';

return 0;
}

-------------------------------------------------------------------------------------

12、误解传值与传引用(函数参数单向传值问题）

   在C/C++中，参数默认传递方式是传值的，即在参数入栈时被拷贝一份。在函数里修改这些参数，不会影响外面的调用者。如：

-------------------------------------------------------------------------------------
#include <stdlib.h>
#include <stdio.h>

void get_str(char* p)
{

p = malloc(sizeof("abcd"));

strcpy(p, "abcd");

return;
}

int main(int argc, char* argv[])
{
char* p = NULL;

get_str(p);

printf("p=%p\n", p);

return 0;
}

-------------------------------------------------------------------------------------

在main函数里，p的值仍然是空值。当然在函数里修改指针指向的内容是可以的。

   13、重名符号(变量的作用域问题）

   无论是函数名还是变量名，如果在不同的作用范围内重名，自然没有问题。但如果两个符号的作用域有交集，如全局变量和局部变量，全局变量与全局变量之间，重名的现象一定要坚决避免。gcc有一些隐式规则来决定处理同名变量的方式，编译时可能没有任何警告和错误，但结果通常并非你所期望的。

下面例子编译时就没有警告：

-------------------------------------------------------------------------------------
t.c

#include <stdlib.h>
#include <stdio.h>

int count = 0;

int get_count(void)

{
return count;
}

main.c

#include <stdio.h>

extern int get_count(void);

int count;

int main(int argc, char* argv[])
{
count = 10;

printf("get_count=%d\n", get_count());

return 0;

}

-------------------------------------------------------------------------------------

如果把main.c中的int count;修改为int count = 0;，gcc就会编辑出错，说multiple definition of `count’。它的隐式规则比较奇妙吧，所以还是不要依赖它为好。

   14、栈溢出

   我们在前面关于堆栈的一节讲过，在PC上，普通线程的栈空间也有十几M，通常够用了，定义大一点的临时变量不会有什么问题。

而在一些嵌入式中，线程的栈空间可能只5K大小，甚至小到只有256个字节。在这样的平台中，栈溢出是最常用的错误之一。在编程时应该清楚自己平台的限制，避免栈溢出的可能。

   15、误用sizeof。

   尽管C/C++通常是按值传递参数，而数组则是例外，在传递数组参数时，数组退化为指针（即按引用传递），用sizeof是无法取得数组的大小的。

从下面这个例子可以看出：

-------------------------------------------------------------------------------------

void test(char str[20])
{
printf("%s:size=%d\n", __func__, sizeof(str));
}

int main(int argc, char* argv[])
{
char str[20] = {0};

test(str);

printf("%s:size=%d\n", __func__, sizeof(str));

return 0;
}

[root@localhost mm]# ./t.exe
test:size=4
main:size=20

-------------------------------------------------------------------------------------

     16、字节对齐

   字节对齐主要目的是提高内存访问的效率。但在有的平台(如arm7)上，就不光是效率问题了，如果不对齐，得到的数据是错误的。

所幸的是，大多数情况下，编译会保证全局变量和临时变量按正确的方式对齐。内存管理器会保证动态内存按正确的方式对齐。要注意的是，在不同类型的变量之间转换时要小心，如把char*强制转换为int*时，要格外小心。

另外，字节对齐也会造成结构大小的变化，在程序内部用sizeof来取得结构的大小，这就足够了。若数据要在不同的机器间传递时，在通信协议中要规定对齐的方式，避免对齐方式不一致引发的问题。

   17、大小端问题（字节顺序）

   字节顺序历来是设计跨平台软件时头疼的问题。字节顺序是关于数据在物理内存中的布局的问题，最常见的字节顺序有两种：大端模式与小端模式。

大端模式是高位字节数据存放在低地址处，低位字节数据存放在高地址处。

小端模式指低位字节数据存放在内存低地址处，高位字节数据存放在内存高地址处；

在普通软件中，字节顺序问题并不引人注目。而在开发与网络通信和数据交换有关的软件时，字节顺序问题就要特殊注意了。

   18、多线程共享变量没有用valotile修饰

   关键字valotile的作用是告诉编译器，不要把变量优化到寄存器里。在开发多线程并发的软件时，如果这些线程共享一些全局变量，这些全局变量最好用valotile修饰。这样可以避免因为编译器优化而引起的错误，这样的错误非常难查。

   19、忘记函数的返回值

   函数需要返回值，如果你忘记return语句，它仍然会返回一个值，因为在i386上，EAX用来保存返回值，如果没有明确返回，EAX最后的内容被返回，所以EAX的内容是随机的。

第三部分编写程序和检查程序的良好习惯

   第一阶段分析设计

   充分理解需求，设计软件框架时数据流，控制流尽可能完整；形成尽可能详尽的流程图；涉及到算法类的设计时，要将涉及到的数学公式或思想深入理解，如果需要采用快速算法的，可以参考经典的算法。参考网上的几篇博客和《高质量》

   第二阶段编写代码的习惯

   按照设计文档编，遵照良好的规范书写代码（文献【1】），时时刻刻牢记上面提到的二十种常见错误，争取第一次书写时就避免这样的错误。

   程序完成后，不急着编译，而是先仔细阅读：

1、第一遍阅读：重点关注语法错误、代码排版和命名规则等等问题，只要看不顺眼就修改它们。读完之后，你的代码很少有低级错误，看起来也比较干净清爽。

   2、第二遍阅读：重点关注第二部分的常见编程错误。

   3、模拟计算机执行：常见错误是比较死的东西，按照检查列表一条一条的做就行了。有些逻辑通常不是这么直观的，这时可以自己模拟计算机去执行，假想你自己是计算机，读入这些代码时你会怎么处理。这种方法能有效的完善我们的思路，考虑不同的输入数据，各种边界值，这能帮助我们想到一些没有处理的情况，让程序的逻辑更严谨。

至于读几遍合适，要根据情况而定，通常三遍是最佳的投资。

其他几项良好习惯：
1. 一组良好的接口，实现构造和析构函数。
2. 隐藏内部细节：内部函数尽量使用static声明，最好结构声明都不要放在头文件里，除非确实需要提供给外部。
3. 良好的编程风格：排版，布局，注释，命名需要规范。
4. 尽量满足同时供c/c++调用，条件声明成 extern“c”
---------------------------------------------------------------

#if defined(__cplusplus)
extern "C" {
#endif

#if defined(__cplusplus)
}
#endif

---------------------------------------------------------------
5. 需要带有自动测试程序，Demo程序。
6. 加上#ifndef/#define/#endif：防止重复include相同的头文件

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

参考文献：

【1】林锐 《高质量C/C++编程指南》

【2】http://www.limodev.cn/blog

1. 通过 http://fedoraproject.org/ 下载文件 Fedora-10-i386-DVD.iso 放在fat32格式 D盘根目录。

    通过 http://download.gna.org/grub4dos/ 下载好引导程序 grub4dos

2. 解压grub4dos, 拷贝 grldr, grub.exe, menu.lst三个文件放在c盘根目录下。

3. 在Fedora-10-i386-DVD.iso中提取（不需要全部解压）文件夹

1）isolinux 将目录中的文件vmlinuz, initrd.img拷贝到c盘根目录

2) images 将目录放到D盘根目录（注意和文件Fedora-10-i386-DVD.iso要在同一级目录，避免安装过程中找不到ISO文件）

4. 编辑c盘根目录的文件 menu.lst，在文件尾加上

title Install Fedora 10

kernel (hd0,0)/vmlinuz

initrd (hd0,0)/initrd.img

编辑系统隐藏文件boot.ini,在文件尾加上：

c:\grldr=GRUB

5. 重启，选择GRUB，再选择Install Fedora 10，只要前面的步骤正确，即可进入安装界面。

6. 安装过程中的注意事项：选择硬盘安装，/dev/sd5(笔者电脑分区，可能因人而异）（D盘）

7. 安装完毕后的几个重要配置：

1）电信ADSL上网配置

系统->管理->网络->新建->XDSL连接设置

登录名：*****@163.gd

口令：**********

设置好后，激活eth0 和 ppp0(默认)

2）添加yum源和update系统

添加常用的yum源

$ su

# rpm -Uvh http://download1.rpmfusion.org/free/fedora/rpmfusion-free-release-stable.noarch.rpm

# rpm -Uvh http://download1.rpmfusion.org/nonfree/fedora/rpmfusion-nonfree-release-stable.noarch.rpm

# rpm -Uvh http://livna-dl.reloumirrors.net/fedora/10/i386/livna-release-9-2.noarch.rpm
# yum update

更新的时间一般较长（视下载速度决定）

3）安装显卡驱动（笔者是Geforce4 MX440)

#yum install kmod-nvidia-96xx

4)关闭SELinux
系统->管理->SELinux Management，将系统默认的应用模式设为disable。