在上一讲中，笔者介绍了DirectShow的总体系统框架。从这一讲开始，我们要从程序员的角度，进一步深入探讨一下DirectShow的应用以及Filter的开发。
在这之前，笔者首先要特别提一下微软提供的一个Filter测试工具——GraphEdit，它的路径在DXSDK\bin\DXUtils\GraphEdit.exe。（如果您还没有安装DirectX SDK，请到微软的网站上去下载。）通过这个工具，我们可以很直观地看到Filter Graph的运行及处理流程，方便我们进行程序调试。（如果您手边就有电脑，还等什么，马上体验一下吧：运行GraphEdit，执行File->Render Media File…选择一个媒体文件；当Filter Graph构建成功后，按下工具栏的运行按钮；您就能看到刚才选择的媒体文件被回放出来了！看到了吧，写一个媒体播放器也就这么回事！）
接下去，我们开讲Filter的开发。
学习DirectShow Filter的开发，不外乎以下几种方法：看帮助文档、看示例代码和看SDK基类源代码。看帮助文档，应着重于总体概念上的理解；看示例代码应与基类源代码的研究同步进行，因为自己写Filter，关键的第一步是选择一个合适的Filter基类和Pin的基类。对于Filter的把握，一般认为要掌握以下三方面的内容：Filter之间Pin的连接、Filter之间的数据传输以及流媒体的随机访问（或者说流的定位）。下面就开始分别进行阐述。
所谓的Filter Pin之间的连接，实际上是Pin之间Media Type（媒体类型）的一个协商过程。连接总是从输出Pin指向输入Pin的。要想深入了解具体的连接过程，就必须认真研读SDK的基类源代码（位于DXSDK\samples\Multimedia\DirectShow\BaseClasses\amfilter.cpp，类CBasePin的Connect方法）。连接的大致过程为，枚举欲连接的输入Pin上所有的媒体类型，逐一用这些媒体类型与输出Pin进行连接，如果输出Pin也接受这种媒体类型，则Pin之间的连接宣告成功；如果所有输入Pin上枚举的媒体类型输出Pin都不支持，则枚举输出Pin上的所有媒体类型，并逐一用这些媒体类型与输入Pin进行连接。如果输入Pin接受其中的一种媒体类型，则Pin之间的连接到此也宣告成功；如果输出Pin上的所有媒体类型，输入Pin都不支持，则这两个Pin之间的连接过程宣告失败。
有一点需要注意的是，上述的输入Pin与输出Pin一般不属于同一个Filter，典型的是上一级Filter（也叫Upstream Filter）的输出Pin连向下一级Filter（也叫Downstream Filter）的输入Pin。如下图所示：

当Filter的Pin之间连接完成，也就是说，连接双方通过协商取得了一种大家都支持的媒体类型之后，即开始为数据传输做准备。这些准备工作中，最重要的是Pin上的内存分配器的协商，一般也是由输出Pin发起。在DirectShow Filter之间，数据是通过一个一个数据包传送的，这个数据包叫做Sample。Sample本身是一个COM对象，拥有一段内存用以装载数据，Sample就由内存分配器（Allocator）来统一管理。已成功连接的一对输出、输入Pin使用同一个内存分配器，所以数据从输出Pin传送到输入Pin上是无需内存拷贝的。而典型的数据拷贝，一般发生在Filter内部，从Filter的输入Pin上读取数据后，进行一定意图的处理，然后在Filter的输出Pin上填充数据，然后继续往下传输。下面，我们就具体阐述一下Filter之间的数据传送。
首先，大家要区分一下Filter的两种主要的数据传输模式：推模式（Push Model）和拉模式(Pull Model)。参考图如下：

  
所谓推模式，即源Filter（Source Filter）自己能够产生数据，并且一般在它的输出Pin上有独立的子线程负责将数据发送出去，常见的情况如代表WDM模型的采集卡的Live Source Filter；而所谓拉模式，即源Filter不具有把自己的数据送出去的能力，这种情况下，一般源Filter后紧跟着接一个Parser Filter或Splitter Filter，这种Filter一般在输入Pin上有个独立的子线程，负责不断地从源Filter索取数据，然后经过处理后将数据传送下去，常见的情况如文件源。推模式下，源Filter是主动的；拉模式下，源Filter是被动的。而事实上，如果将上图拉模式中的源Filter和Splitter Filter看成另一个虚拟的源Filter，则后面的Filter之间的数据传输也与推模式完全相同。
那么，数据到底是怎么通过连接着的Pin传输的呢？首先来看推模式。在源Filter后面的Filter输入Pin上，一定实现了一个IMemInputPin接口，数据正是通过上一级Filter调用这个接口的Receive方法进行传输的。值得注意的是（上面已经提到过），数据从输出Pin通过Receive方法调用传输到输入Pin上，并没有进行内存拷贝，它只是一个相当于数据到达的“通知”。再看一下拉模式。拉模式下的源Filter的输出Pin上，一定实现了一个IAsyncReader接口；其后面的Splitter Filter，就是通过调用这个接口的Request方法或者SyncRead方法来获得数据。Splitter Filter然后像推模式一样，调用下一级Filter输入Pin上的IMemInputPin接口Receive方法实现数据的往下传送。深入了解这部分内容，请认真研读SDK的基类源代码（位于DXSDK\samples\Multimedia\DirectShow\BaseClasses\source.cpp和pullpin.cpp）。
下面，我们来讲一下流的定位（Media Seeking）。在GraphEdit中，当我们成功构建了一个Filter Graph之后，我们就可以播放它。在播放中，我们可以看到进度条也在相应地前进。当然，我们也可以通过拖动进度条，实现随机访问。要做到这一点，在应用程序级别应该可以知道Filter Graph总共要播放多长时间，当前播放到什么位置等等。那么，在Filter级别，这一点是怎么实现的呢？
我们知道，若干个Filter通过Pin的相互连接组成了Filter Graph。而这个Filter Graph是由另一个COM对象Filter Graph Manager来管理的。通过Filter Graph Manager，我们就可以得到一个IMediaSeeking的接口来实现对流媒体的定位。在Filter级别，我们可以看到，Filter Graph Manager首先从最后一个Filter（Renderer Filter）开始，询问上一级Filter的输出Pin是否支持IMediaSeeking接口。如果支持，则返回这个接口；如果不支持，则继续往上一级Filter询问，直到源Filter。一般在源Filter的输出Pin上实现IMediaSeeking接口，它告诉调用者总共有多长时间的媒体内容，当前播放位置等信息。（如果是文件源，一般在Parser Filter或Splitter Filter实现这个接口。）对于Filter开发者来说，如果我们写的是源Filter，我们就要在Filter的输出Pin上实现IMediaSeeking这个接口；如果写的是中间的传输Filter，只需要在输出Pin上将用户的获得接口请求往上传递给上一级Filter的输出Pin；如果写的是Renderer Filter，需要在Filter上将用户的获得接口请求往上传递给上一级Filter的输出Pin。进一步的了解，请认真研读SDK的基类源代码（位于DXSDK\samples\Multimedia\DirectShow\BaseClasses\transfrm.cpp的类方法CTransformOutputPin::NonDelegatingQueryInterface实现和ctlutil.cpp中类CPosPassThru的实现）。
以上我们介绍了一下如何学习DirectShow Filter开发，以及一些开始写自己的Filter之前的预备知识。下一讲，笔者将根据自己开发Filter的经验，手把手教你如何写自己的Filter。

来源:http://blog.csdn.net/happydeer/archive/2003/01/04/8769.aspx

流媒体的处理，以其复杂性和技术性，一向广受工业界的关注。特别伴随着因特网的普及，流媒体在网络上的广泛应用，怎样使流媒体的处理变得简单而富有成效逐渐成为了焦点问题。选择一种合适的应用方案，事半功倍。此时，微软的DirectShow，给了我们一个不错的选择。
DirectShow是微软公司提供的一套在Windows平台上进行流媒体处理的开发包，与DirectX开发包一起发布。目前，DirectX最新版本为9.0。
那么，DirectShow能够做些什么呢？且看，DirectShow为多媒体流的捕捉和回放提供了强有力的支持。运用DirectShow，我们可以很方便地从支持WDM驱动模型的采集卡上捕获数据，并且进行相应的后期处理乃至存储到文件中。它广泛地支持各种媒体格式，包括Asf、Mpeg、Avi、Dv、Mp3、Wave等等，使得多媒体数据的回放变得轻而易举。另外，DirectShow还集成了DirectX其它部分（比如DirectDraw、DirectSound）的技术，直接支持DVD的播放，视频的非线性编辑，以及与数字摄像机的数据交换。更值得一提的是，DirectShow提供的是一种开放式的开发环境，我们可以根据自己的需要定制自己的组件。
接下去，我们需要对DirectShow系统有个整体的印象。参见以下DirectShow的系统示意图：

图中央最大的一块即是DirectShow系统。DirectShow使用一种叫Filter Graph的模型来管理整个数据流的处理过程；参与数据处理的各个功能模块叫做Filter；各个Filter在Filter Graph中按一定的顺序连接成一条“流水线”协同工作。大家可以看到，按照功能来分，Filter大致分为三类：Source Filters、Transform Filters和Rendering Filters。Source Filters主要负责取得数据，数据源可以是文件、因特网、或者计算机里的采集卡、数字摄像机等，然后将数据往下传输；Transform Fitlers主要负责数据的格式转换、传输；Rendering Filtes主要负责数据的最终去向，我们可以将数据送给声卡、显卡进行多媒体的演示，也可以输出到文件进行存储。值得注意的是，三个部分并不是都只有一个Filter去完成功能。恰恰相反，每个部分往往是有几个Fitler协同工作的。比如，Transform Filters可能包含了一个Mpeg的解码Filter、以及视频色彩空间的转换Filter、音频采样频率转换Filter等等。除了系统提供的大量Filter外，我们可以定制自己的Filter，以完成我们需要的功能。下图是一条典型的Avi文件回放Filter Graph链路：

在DirectShow系统之上，我们看到的，即是我们的应用程序（Application）。应用程序要按照一定的意图建立起相应的Filter Graph，然后通过Filter Graph Manager来控制整个的数据处理过程。DirectShow能在Filter Graph运行的时候接收到各种事件，并通过消息的方式发送到我们的应用程序。这样，就实现了应用程序与DirectShow系统之间的交互。下图给出了DirectShow应用程序开发的一般过程：

以上简单介绍了DirectShow的系统结构，希望大家对这个强劲的应用框架已经有了大概的认识。如果你有兴趣，可以详细研究DirectX的帮助文档。DirectShow是一个强大的开发包；另外，它是基于COM的，因此要求程序员具有COM编程的一些基本知识。关于如何深入学习DirectShow应用结构以及开发自己的Filter，请参阅笔者的后续文章。笔者将从编程的角度，详细讲述来源于实际工作中的经验之谈。

来源:http://blog.csdn.net/happydeer

小知识：AVI文件格式----摘自《DirectShow实务精选》 作者：陆其明

AVI（Audio Video Interleaved的缩写）是一种RIFF（Resource Interchange File Format的缩写）文件格式，多用于音视频捕捉、编辑、回放等应用程序中。通常情况下，一个AVI文件可以包含多个不同类型的媒体流（典型的情况下有一个音频流和一个视频流），不过含有单一音频流或单一视频流的AVI文件也是合法的。AVI可以算是Windows操作系统上最基本的、也是最常用的一种媒体文件格式。

先来介绍RIFF文件格式。RIFF文件使用四字符码FOURCC（four-character code）来表征数据类型，比如‘RIFF’、‘AVI ’、‘LIST’等。注意，Windows操作系统使用的字节顺序是little-endian，因此一个四字符码‘abcd’实际的DWORD值应为0x64636261。另外，四字符码中像‘AVI ’一样含有空格也是合法的。

RIFF文件首先含有一个如图3.31的文件头结构。

 

图3.31 RIFF文件结构

最开始的4个字节是一个四字符码‘RIFF’，表示这是一个RIFF文件；紧跟着后面用4个字节表示此RIFF文件的大小；然后又是一个四字符码说明文件的具体类型（比如AVI、WAVE等）；最后就是实际的数据。注意文件大小值的计算方法为：实际数据长度 + 4（文件类型域的大小）；也就是说，文件大小的值不包括‘RIFF’域和“文件大小”域本身的大小。

RIFF文件的实际数据中，通常还使用了列表（List）和块（Chunk）的形式来组织。列表可以嵌套子列表和块。其中，列表的结构为：‘LIST’ listSize listType listData ——‘LIST’是一个四字符码，表示这是一个列表；listSize占用4字节，记录了整个列表的大小；listType也是一个四字符码，表示本列表的具体类型；listData就是实际的列表数据。注意listSize值的计算方法为：实际的列表数据长度 + 4（listType域的大小）；也就是说listSize值不包括‘LIST’域和listSize域本身的大小。再来看块的结构：ckID ckSize ckData ——ckID是一个表示块类型的四字符码；ckSize占用4字节，记录了整个块的大小；ckData为实际的块数据。注意ckSize值指的是实际的块数据长度，而不包括ckID域和ckSize域本身的大小。（注意：在下面的内容中，将以LIST ( listType ( listData ) )的形式来表示一个列表，以ckID ( ckData )的形式来表示一个块，如[ optional element ]中括号中的元素表示为可选项。）

接下来介绍AVI文件格式。AVI文件类型用一个四字符码‘AVI ’来表示。整个AVI文件的结构为：一个RIFF头 + 两个列表（一个用于描述媒体流格式、一个用于保存媒体流数据） + 一个可选的索引块。AVI文件的展开结构大致如下：

 

RIFF (‘AVI ’
      LIST (‘hdrl’
            ‘avih’(主AVI信息头数据)
            LIST (‘strl’
                  ‘strh’ (流的头信息数据)
                  ‘strf’ (流的格式信息数据)
                  [‘strd’ (可选的额外的头信息数据) ]
                  [‘strn’ (可选的流的名字) ]
                  ...
                 )
             ...
           )
      LIST (‘movi’
            { SubChunk | LIST (‘rec ’
                              SubChunk1
                              SubChunk2
                              ...
                             )
               ...
            }
            ...
           )
      [‘idx1’ (可选的AVI索引块数据) ]
     )

首先，RIFF (‘AVI ’…)表征了AVI文件类型。然后就是AVI文件必需的第一个列表——‘hdrl’列表，用于描述AVI文件中各个流的格式信息（AVI文件中的每一路媒体数据都称为一个流）。‘hdrl’列表嵌套了一系列块和子列表——首先是一个‘avih’块，用于记录AVI文件的全局信息，比如流的数量、视频图像的宽和高等，可以使用一个AVIMAINHEADER数据结构来操作：

typedef struct _avimainheader {
    FOURCC fcc;   // 必须为‘avih’
    DWORD  cb;    // 本数据结构的大小，不包括最初的8个字节（fcc和cb两个域）
    DWORD  dwMicroSecPerFrame;   // 视频帧间隔时间（以毫秒为单位）
    DWORD  dwMaxBytesPerSec;     // 这个AVI文件的最大数据率
    DWORD  dwPaddingGranularity; // 数据填充的粒度
    DWORD  dwFlags;         // AVI文件的全局标记，比如是否含有索引块等
    DWORD  dwTotalFrames;   // 总帧数
    DWORD  dwInitialFrames; // 为交互格式指定初始帧数（非交互格式应该指定为0）
    DWORD  dwStreams;       // 本文件包含的流的个数
    DWORD  dwSuggestedBufferSize; // 建议读取本文件的缓存大小（应能容纳最大的块）
    DWORD  dwWidth;         // 视频图像的宽（以像素为单位）
    DWORD  dwHeight;        // 视频图像的高（以像素为单位）
    DWORD  dwReserved[4];   // 保留
} AVIMAINHEADER;

然后，就是一个或多个‘strl’子列表。（文件中有多少个流，这里就对应有多少个‘strl’子列表。）每个‘strl’子列表至少包含一个‘strh’块和一个‘strf’块，而‘strd’块（保存编解码器需要的一些配置信息）和‘strn’块（保存流的名字）是可选的。首先是‘strh’块，用于说明这个流的头信息，可以使用一个AVISTREAMHEADER数据结构来操作：

typedef struct _avistreamheader {
     FOURCC fcc;  // 必须为‘strh’
     DWORD  cb;   // 本数据结构的大小，不包括最初的8个字节（fcc和cb两个域）
FOURCC fccType;    // 流的类型：‘auds’（音频流）、‘vids’（视频流）、
                   //‘mids’（MIDI流）、‘txts’（文字流）
     FOURCC fccHandler; // 指定流的处理者，对于音视频来说就是解码器
     DWORD  dwFlags;    // 标记：是否允许这个流输出？调色板是否变化？
     WORD   wPriority;  // 流的优先级（当有多个相同类型的流时优先级最高的为默认流）
     WORD   wLanguage;
     DWORD  dwInitialFrames; // 为交互格式指定初始帧数
     DWORD  dwScale;   // 这个流使用的时间尺度
     DWORD  dwRate;
     DWORD  dwStart;   // 流的开始时间
     DWORD  dwLength;  // 流的长度（单位与dwScale和dwRate的定义有关）
     DWORD  dwSuggestedBufferSize; // 读取这个流数据建议使用的缓存大小
     DWORD  dwQuality;    // 流数据的质量指标（0 ~ 10,000）
     DWORD  dwSampleSize; // Sample的大小
     struct {
         short int left;
         short int top;
         short int right;
         short int bottom;
}  rcFrame;  // 指定这个流（视频流或文字流）在视频主窗口中的显示位置
             // 视频主窗口由AVIMAINHEADER结构中的dwWidth和dwHeight决定
} AVISTREAMHEADER;

然后是‘strf’块，用于说明流的具体格式。如果是视频流，则使用一个BITMAPINFO数据结构来描述；如果是音频流，则使用一个WAVEFORMATEX数据结构来描述。

当AVI文件中的所有流都使用一个‘strl’子列表说明了以后（注意：‘strl’子列表出现的顺序与媒体流的编号是对应的，比如第一个‘strl’子列表说明的是第一个流（Stream 0），第二个‘strl’子列表说明的是第二个流（Stream 1），以此类推），‘hdrl’列表的任务也就完成了，随后跟着的就是AVI文件必需的第二个列表——‘movi’列表，用于保存真正的媒体流数据（视频图像帧数据或音频采样数据等）。那么，怎么来组织这些数据呢？可以将数据块直接嵌在‘movi’列表里面，也可以将几个数据块分组成一个‘rec ’列表后再编排进‘movi’列表。（注意：在读取AVI文件内容时，建议将一个‘rec ’列表中的所有数据块一次性读出。）但是，当AVI文件中包含有多个流的时候，数据块与数据块之间如何来区别呢？于是数据块使用了一个四字符码来表征它的类型，这个四字符码由2个字节的类型码和2个字节的流编号组成。标准的类型码定义如下：‘db’（非压缩视频帧）、‘dc’（压缩视频帧）、‘pc’（改用新的调色板）、‘wb’（音缩视频）。比如第一个流（Stream 0）是音频，则表征音频数据块的四字符码为‘00wb’；第二个流（Stream 1）是视频，则表征视频数据块的四字符码为‘00db’或‘00dc’。对于视频数据来说，在AVI数据序列中间还可以定义一个新的调色板，每个改变的调色板数据块用‘xxpc’来表征，新的调色板使用一个数据结构AVIPALCHANGE来定义。（注意：如果一个流的调色办中途可能改变，则应在这个流格式的描述中，也就是AVISTREAMHEADER结构的dwFlags中包含一个AVISF_VIDEO_PALCHANGES标记。）另外，文字流数据块可以使用随意的类型码表征。

最后，紧跟在‘hdrl’列表和‘movi’列表之后的，就是AVI文件可选的索引块。这个索引块为AVI文件中每一个媒体数据块进行索引，并且记录它们在文件中的偏移（可能相对于‘movi’列表，也可能相对于AVI文件开头）。索引块使用一个四字符码‘idx1’来表征，索引信息使用一个数据结构来AVIOLDINDEX定义。

 

typedef struct _avioldindex {
   FOURCC  fcc;  // 必须为‘idx1’
   DWORD   cb;   // 本数据结构的大小，不包括最初的8个字节（fcc和cb两个域）
   struct _avioldindex_entry {
      DWORD   dwChunkId;   // 表征本数据块的四字符码
      DWORD   dwFlags;     // 说明本数据块是不是关键帧、是不是‘rec ’列表等信息
      DWORD   dwOffset;    // 本数据块在文件中的偏移量
      DWORD   dwSize;      // 本数据块的大小
  } aIndex[]; // 这是一个数组！为每个媒体数据块都定义一个索引信息
} AVIOLDINDEX;

注意：如果一个AVI文件包含有索引块，则应在主AVI信息头的描述中，也就是AVIMAINHEADER结构的dwFlags中包含一个AVIF_HASINDEX标记。

还有一种特殊的数据块，用一个四字符码‘JUNK’来表征，它用于内部数据的队齐（填充），应用程序应该忽略这些数据块的实际意义。

在我的另一篇日志中,说到利用FFmpeg从视频截图的命令,那天在找从视频截取指定帧的图片的办法,这么多天没有进展,原来我从网上找的关于FFmpeg的参数命令列表并不全,少了-ss这么一个参数.于是这个问题也到现在才解决.

    今天利用FFmpeg -h > ffmpeg.txt,把FFmpeg的命令打印出来后,才发现了这一参数:

-ss time_off set the start time offset

使用-ss参数,可以从指定的时间开始处理转换任务.如:

ffmpeg -i test2.asf -y -f image2 -ss 08.010 -t 0.001 -s 352x240 b.jpg

那么从任意一帧截图的问题也就解决了.只要-ss后的时间参数是随机产生,并且在视频的有效时间内,就可以了.

 另外,-ss后跟的时间单位为秒。

2006-06-27 补充：

来源：http://ffmpeg.blogbus.com/logs/445361.html

在为Linux开发应用程序时，绝大多数情况下使用的都是C语言，因此几乎每一位Linux程序员面临的首要问题都是如何灵活运用C编译器。目前Linux下最常用的C语言编译器是GCC（GNU Compiler Collection），它是GNU项目中符合ANSI C标准的编译系统，能够编译用C、C++和Object C等语言编写的程序。GCC不仅功能非常强大，结构也异常灵活。最值得称道的一点就是它可以通过不同的前端模块来支持各种语言，如Java、Fortran、Pascal、Modula-3和Ada等。

开放、自由和灵活是Linux的魅力所在，而这一点在GCC上的体现就是程序员通过它能够更好地控制整个编译过程。在使用GCC编译程序时，编译过程可以被细分为四个阶段：

◆ 预处理（Pre-Processing）

◆ 编译（Compiling）

◆ 汇编（Assembling）

◆ 链接（Linking）

Linux程序员可以根据自己的需要让GCC在编译的任何阶段结束，以便检查或使用编译器在该阶段的输出信息，或者对最后生成的二进制文件进行控制，以便通过加入不同数量和种类的调试代码来为今后的调试做好准备。和其它常用的编译器一样，GCC也提供了灵活而强大的代码优化功能，利用它可以生成执行效率更高的代码。

GCC提供了30多条警告信息和三个警告级别，使用它们有助于增强程序的稳定性和可移植性。此外，GCC还对标准的C和C++语言进行了大量的扩展，提高程序的执行效率，有助于编译器进行代码优化，能够减轻编程的工作量。

GCC起步

在学习使用GCC之前，下面的这个例子能够帮助用户迅速理解GCC的工作原理，并将其立即运用到实际的项目开发中去。首先用熟悉的编辑器输入清单1所示的代码：

清单1：hello.c

 #include <stdio.h>
 int main(void)
 {
  printf ("Hello world, Linux programming!\n");
  return 0;
 }
 
然后执行下面的命令编译和运行这段程序：

 # gcc hello.c -o hello # ./hello Hello world, Linux programming!
 
从程序员的角度看，只需简单地执行一条GCC命令就可以了，但从编译器的角度来看，却需要完成一系列非常繁杂的工作。首先，GCC需要调用预处理程序cpp，由它负责展开在源文件中定义的宏，并向其中插入“#include”语句所包含的内容；接着，GCC会调用ccl和as将处理后的源代码编译成目标代码；最后，GCC会调用链接程序ld，把生成的目标代码链接成一个可执行程序。

为了更好地理解GCC的工作过程，可以把上述编译过程分成几个步骤单独进行，并观察每步的运行结果。第一步是进行预编译，使用-E参数可以让GCC在预处理结束后停止编译过程：

 # gcc -E hello.c -o hello.i
 
此时若查看hello.cpp文件中的内容，会发现stdio.h的内容确实都插到文件里去了，而其它应当被预处理的宏定义也都做了相应的处理。下一步是将hello.i编译为目标代码，这可以通过使用-c参数来完成：

 # gcc -c hello.i -o hello.o
 
GCC默认将.i文件看成是预处理后的C语言源代码，因此上述命令将自动跳过预处理步骤而开始执行编译过程，也可以使用-x参数让GCC从指定的步骤开始编译。最后一步是将生成的目标文件链接成可执行文件：

 # gcc hello.o -o hello
 
在采用模块化的设计思想进行软件开发时，通常整个程序是由多个源文件组成的，相应地也就形成了多个编译单元，使用GCC能够很好地管理这些编译单元。假设有一个由foo1.c和foo2.c两个源文件组成的程序，为了对它们进行编译，并最终生成可执行程序foo，可以使用下面这条命令：

 # gcc foo1.c foo2.c -o foo
 
如果同时处理的文件不止一个，GCC仍然会按照预处理、编译和链接的过程依次进行。如果深究起来，上面这条命令大致相当于依次执行如下三条命令：

 # gcc -c foo1.c -o foo1.o # gcc -c foo2.c -o foo2.o # gcc foo1.o foo2.o -o foo
 
在编译一个包含许多源文件的工程时，若只用一条GCC命令来完成编译是非常浪费时间的。假设项目中有100个源文件需要编译，并且每个源文件中都包含10000行代码，如果像上面那样仅用一条GCC命令来完成编译工作，那么GCC需要将每个源文件都重新编译一遍，然后再全部连接起来。很显然，这样浪费的时间相当多，尤其是当用户只是修改了其中某一个文件的时候，完全没有必要将每个文件都重新编译一遍，因为很多已经生成的目标文件是不会改变的。要解决这个问题，关键是要灵活运用GCC，同时还要借助像Make这样的工具。

警告提示功能

GCC包含完整的出错检查和警告提示功能，它们可以帮助Linux程序员写出更加专业和优美的代码。先来读读清单2所示的程序，这段代码写得很糟糕，仔细检查一下不难挑出很多毛病：

◆main函数的返回值被声明为void，但实际上应该是int；

◆使用了GNU语法扩展，即使用long long来声明64位整数，不符合ANSI/ISO C语言标准；

◆main函数在终止前没有调用return语句。

清单2：illcode.c

 #include <stdio.h>
 void main(void)
 {
  long long int var = 1;
  printf("It is not standard C code!\n");
 }

下面来看看GCC是如何帮助程序员来发现这些错误的。当GCC在编译不符合ANSI/ISO C语言标准的源代码时，如果加上了-pedantic选项，那么使用了扩展语法的地方将产生相应的警告信息：

 # gcc -pedantic illcode.c -o illcode illcode.c: In function `main': illcode.c:9: ISO C89 does not support `long long' illcode.c:8: return type of `main' is not `int'

需要注意的是，-pedantic编译选项并不能保证被编译程序与ANSI/ISO C标准的完全兼容，它仅仅只能用来帮助Linux程序员离这个目标越来越近。或者换句话说，-pedantic选项能够帮助程序员发现一些不符合ANSI/ISO C标准的代码，但不是全部，事实上只有ANSI/ISO C语言标准中要求进行编译器诊断的那些情况，才有可能被GCC发现并提出警告。

除了-pedantic之外，GCC还有一些其它编译选项也能够产生有用的警告信息。这些选项大多以-W开头，其中最有价值的当数-Wall了，使用它能够使GCC产生尽可能多的警告信息：

 # gcc -Wall illcode.c -o illcode illcode.c:8: warning: return type of `main' is not `int' illcode.c: In function `main': illcode.c:9: warning: unused variable `var'

GCC给出的警告信息虽然从严格意义上说不能算作是错误，但却很可能成为错误的栖身之所。一个优秀的Linux程序员应该尽量避免产生警告信息，使自己的代码始终保持简洁、优美和健壮的特性。

在处理警告方面，另一个常用的编译选项是-Werror，它要求GCC将所有的警告当成错误进行处理，这在使用自动编译工具（如Make等）时非常有用。如果编译时带上-Werror选项，那么GCC会在所有产生警告的地方停止编译，迫使程序员对自己的代码进行修改。只有当相应的警告信息消除时，才可能将编译过程继续朝前推进。执行情况如下：

 # gcc -Wall -Werror illcode.c -o illcode cc1: warnings being treated as errors illcode.c:8: warning: return type of `main' is not `int' illcode.c: In function `main': illcode.c:9: warning: unused variable `var'

对Linux程序员来讲，GCC给出的警告信息是很有价值的，它们不仅可以帮助程序员写出更加健壮的程序，而且还是跟踪和调试程序的有力工具。建议在用GCC编译源代码时始终带上-Wall选项，并把它逐渐培养成为一种习惯，这对找出常见的隐式编程错误很有帮助。

库依赖

在Linux下开发软件时，完全不使用第三方函数库的情况是比较少见的，通常来讲都需要借助一个或多个函数库的支持才能够完成相应的功能。从程序员的角度看，函数库实际上就是一些头文件（.h）和库文件（.so或者.a）的集合。虽然Linux下的大多数函数都默认将头文件放到/usr/include/目录下，而库文件则放到/usr/lib/目录下，但并不是所有的情况都是这样。正因如此，GCC在编译时必须有自己的办法来查找所需要的头文件和库文件。

GCC采用搜索目录的办法来查找所需要的文件，-I选项可以向GCC的头文件搜索路径中添加新的目录。例如，如果在/home/xiaowp/include/目录下有编译时所需要的头文件，为了让GCC能够顺利地找到它们，就可以使用-I选项：

 # gcc foo.c -I /home/xiaowp/include -o foo

同样，如果使用了不在标准位置的库文件，那么可以通过-L选项向GCC的库文件搜索路径中添加新的目录。例如，如果在/home/xiaowp/lib/目录下有链接时所需要的库文件libfoo.so，为了让GCC能够顺利地找到它，可以使用下面的命令：

 # gcc foo.c -L /home/xiaowp/lib -lfoo -o foo

值得好好解释一下的是-l选项，它指示GCC去连接库文件libfoo.so。Linux下的库文件在命名时有一个约定，那就是应该以lib三个字母开头，由于所有的库文件都遵循了同样的规范，因此在用-l选项指定链接的库文件名时可以省去lib三个字母，也就是说GCC在对-lfoo进行处理时，会自动去链接名为libfoo.so的文件。

Linux下的库文件分为两大类分别是动态链接库（通常以.so结尾）和静态链接库（通常以.a结尾），两者的差别仅在程序执行时所需的代码是在运行时动态加载的，还是在编译时静态加载的。默认情况下，GCC在链接时优先使用动态链接库，只有当动态链接库不存在时才考虑使用静态链接库，如果需要的话可以在编译时加上-static选项，强制使用静态链接库。例如，如果在/home/xiaowp/lib/目录下有链接时所需要的库文件libfoo.so和libfoo.a，为了让GCC在链接时只用到静态链接库，可以使用下面的命令：

 # gcc foo.c -L /home/xiaowp/lib -static -lfoo -o foo
 
代码优化

代码优化指的是编译器通过分析源代码，找出其中尚未达到最优的部分，然后对其重新进行组合，目的是改善程序的执行性能。GCC提供的代码优化功能非常强大，它通过编译选项-On来控制优化代码的生成，其中n是一个代表优化级别的整数。对于不同版本的GCC来讲，n的取值范围及其对应的优化效果可能并不完全相同，比较典型的范围是从0变化到2或3。

编译时使用选项-O可以告诉GCC同时减小代码的长度和执行时间，其效果等价于-O1。在这一级别上能够进行的优化类型虽然取决于目标处理器，但一般都会包括线程跳转（Thread Jump）和延迟退栈（Deferred Stack Pops）两种优化。选项-O2告诉GCC除了完成所有-O1级别的优化之外，同时还要进行一些额外的调整工作，如处理器指令调度等。选项-O3则除了完成所有-O2级别的优化之外，还包括循环展开和其它一些与处理器特性相关的优化工作。通常来说，数字越大优化的等级越高，同时也就意味着程序的运行速度越快。许多Linux程序员都喜欢使用-O2选项，因为它在优化长度、编译时间和代码大小之间，取得了一个比较理想的平衡点。

下面通过具体实例来感受一下GCC的代码优化功能，所用程序如清单3所示。

清单3：optimize.c

 #include <stdio.h>
 int main(void)
 {
  double counter;
  double result;
  double temp;
  
  for (counter = 0; counter < 2000.0 * 2000.0 * 2000.0 / 20.0 + 2020; counter += (5 - 1) / 4)
  {
    temp = counter / 1979; result = counter;
  }
  printf("Result is %lf\n", result); return 0;
 }

首先不加任何优化选项进行编译：

 # gcc -Wall optimize.c -o optimize
 
借助Linux提供的time命令，可以大致统计出该程序在运行时所需要的时间：

 # time ./optimize Result is 400002019.000000 real 0m14.942s user 0m14.940s sys 0m0.000s
 
接下去使用优化选项来对代码进行优化处理：

 # gcc -Wall -O optimize.c -o optimize
 
在同样的条件下再次测试一下运行时间：

 # time ./optimize Result is 400002019.000000 real 0m3.256s user 0m3.240s sys 0m0.000s
 
对比两次执行的输出结果不难看出，程序的性能的确得到了很大幅度的改善，由原来的14秒缩短到了3秒。这个例子是专门针对GCC的优化功能而设计的，因此优化前后程序的执行速度发生了很大的改变。尽管GCC的代码优化功能非常强大，但作为一名优秀的Linux程序员，首先还是要力求能够手工编写出高质量的代码。如果编写的代码简短，并且逻辑性强，编译器就不会做更多的工作，甚至根本用不着优化。

优化虽然能够给程序带来更好的执行性能，但在如下一些场合中应该避免优化代码：

◆ 程序开发的时候 优化等级越高，消耗在编译上的时间就越长，因此在开发的时候最好不要使用优化选项，只有到软件发行或开发结束的时候，才考虑对最终生成的代码进行优化。

◆ 资源受限的时候 一些优化选项会增加可执行代码的体积，如果程序在运行时能够申请到的内存资源非常紧张（如一些实时嵌入式设备），那就不要对代码进行优化，因为由这带来的负面影响可能会产生非常严重的后果。

◆ 跟踪调试的时候 在对代码进行优化的时候，某些代码可能会被删除或改写，或者为了取得更佳的性能而进行重组，从而使跟踪和调试变得异常困难。

调试

一个功能强大的调试器不仅为程序员提供了跟踪程序执行的手段，而且还可以帮助程序员找到解决问题的方法。对于Linux程序员来讲，GDB（GNU Debugger）通过与GCC的配合使用，为基于Linux的软件开发提供了一个完善的调试环境。

默认情况下，GCC在编译时不会将调试符号插入到生成的二进制代码中，因为这样会增加可执行文件的大小。如果需要在编译时生成调试符号信息，可以使用GCC的-g或者-ggdb选项。GCC在产生调试符号时，同样采用了分级的思路，开发人员可以通过在-g选项后附加数字1、2或3来指定在代码中加入调试信息的多少。默认的级别是2（-g2），此时产生的调试信息包括扩展的符号表、行号、局部或外部变量信息。级别3（-g3）包含级别2中的所有调试信息，以及源代码中定义的宏。级别1（-g1）不包含局部变量和与行号有关的调试信息，因此只能够用于回溯跟踪和堆栈转储之用。回溯跟踪指的是监视程序在运行过程中的函数调用历史，堆栈转储则是一种以原始的十六进制格式保存程序执行环境的方法，两者都是经常用到的调试手段。

GCC产生的调试符号具有普遍的适应性，可以被许多调试器加以利用，但如果使用的是GDB，那么还可以通过-ggdb选项在生成的二进制代码中包含GDB专用的调试信息。这种做法的优点是可以方便GDB的调试工作，但缺点是可能导致其它调试器（如DBX）无法进行正常的调试。选项-ggdb能够接受的调试级别和-g是完全一样的，它们对输出的调试符号有着相同的影响。

需要注意的是，使用任何一个调试选项都会使最终生成的二进制文件的大小急剧增加，同时增加程序在执行时的开销，因此调试选项通常仅在软件的开发和调试阶段使用。调试选项对生成代码大小的影响从下面的对比过程中可以看出来：

 # gcc optimize.c -o optimize # ls optimize -l -rwxrwxr-x 1 xiaowp xiaowp 11649 Nov 20 08:53 optimize (未加调试选项) # gcc -g optimize.c -o optimize # ls optimize -l -rwxrwxr-x 1 xiaowp xiaowp 15889 Nov 20 08:54 optimize (加入调试选项)
 
虽然调试选项会增加文件的大小，但事实上Linux中的许多软件在测试版本甚至最终发行版本中仍然使用了调试选项来进行编译，这样做的目的是鼓励用户在发现问题时自己动手解决，是Linux的一个显著特色。

下面还是通过一个具体的实例说明如何利用调试符号来分析错误，所用程序见清单4所示。

清单4：crash.c

 #include <stdio.h>
 int main(void)
 {
  int input =0;
  
  printf("Input an integer:");
  scanf("%d", input);
  printf("The integer you input is %d\n", input);
  return 0;
 }
 
编译并运行上述代码，会产生一个严重的段错误（Segmentation fault）如下：

 # gcc -g crash.c -o crash # ./crash Input an integer:10 Segmentation fault
 
为了更快速地发现错误所在，可以使用GDB进行跟踪调试，方法如下：

 # gdb crash GNU gdb Red Hat Linux (5.3post-0.20021129.18rh) …… (gdb)
 
当GDB提示符出现的时候，表明GDB已经做好准备进行调试了，现在可以通过run命令让程序开始在GDB的监控下运行：

 (gdb) run Starting program: /home/xiaowp/thesis/gcc/code/crash Input an integer:10 Program received signal SIGSEGV, Segmentation fault. 0x4008576b in _IO_vfscanf_internal () from /lib/libc.so.6
 
仔细分析一下GDB给出的输出结果不难看出，程序是由于段错误而导致异常中止的，说明内存操作出了问题，具体发生问题的地方是在调用_IO_vfscanf_internal ( )的时候。为了得到更加有价值的信息，可以使用GDB提供的回溯跟踪命令backtrace，执行结果如下：

 (gdb) backtrace #0 0x4008576b in _IO_vfscanf_internal () from /lib/libc.so.6 #1 0xbffff0c0 in ?? () #2 0x4008e0ba in scanf () from /lib/libc.so.6 #3 0x08048393 in main () at crash.c:11 #4 0x40042917 in __libc_start_main () from /lib/libc.so.6
 
跳过输出结果中的前面三行，从输出结果的第四行中不难看出，GDB已经将错误定位到crash.c中的第11行了。现在仔细检查一下：

 (gdb) frame 3 #3 0x08048393 in main () at crash.c:11 11 scanf("%d", input);
 
使用GDB提供的frame命令可以定位到发生错误的代码段，该命令后面跟着的数值可以在backtrace命令输出结果中的行首找到。现在已经发现错误所在了，应该将

 scanf("%d", input); 改为 scanf("%d", &input);
 
完成后就可以退出GDB了，命令如下：

 (gdb) quit
 
GDB的功能远远不止如此，它还可以单步跟踪程序、检查内存变量和设置断点等。

调试时可能会需要用到编译器产生的中间结果，这时可以使用-save-temps选项，让GCC将预处理代码、汇编代码和目标代码都作为文件保存起来。如果想检查生成的代码是否能够通过手工调整的办法来提高执行性能，在编译过程中生成的中间文件将会很有帮助，具体情况如下：

 # gcc -save-temps foo.c -o foo # ls foo* foo foo.c foo.i foo.s
 
GCC支持的其它调试选项还包括-p和-pg，它们会将剖析（Profiling）信息加入到最终生成的二进制代码中。剖析信息对于找出程序的性能瓶颈很有帮助，是协助Linux程序员开发出高性能程序的有力工具。在编译时加入-p选项会在生成的代码中加入通用剖析工具（Prof）能够识别的统计信息，而-pg选项则生成只有GNU剖析工具（Gprof）才能识别的统计信息。

最后提醒一点，虽然GCC允许在优化的同时加入调试符号信息，但优化后的代码对于调试本身而言将是一个很大的挑战。代码在经过优化之后，在源程序中声明和使用的变量很可能不再使用，控制流也可能会突然跳转到意外的地方，循环语句有可能因为循环展开而变得到处都有，所有这些对调试来讲都将是一场噩梦。建议在调试的时候最好不使用任何优化选项，只有当程序在最终发行的时候才考虑对其进行优化。

上次的培训园地中介绍了GCC的编译过程、警告提示功能、库依赖、代码优化和程序调试六个方面的内容。这期是最后的一部分内容。

加速

在将源代码变成可执行文件的过程中，需要经过许多中间步骤，包含预处理、编译、汇编和连接。这些过程实际上是由不同的程序负责完成的。大多数情况下GCC可以为Linux程序员完成所有的后台工作，自动调用相应程序进行处理。

这样做有一个很明显的缺点，就是GCC在处理每一个源文件时，最终都需要生成好几个临时文件才能完成相应的工作，从而无形中导致处理速度变慢。例如，GCC在处理一个源文件时，可能需要一个临时文件来保存预处理的输出、一个临时文件来保存编译器的输出、一个临时文件来保存汇编器的输出，而读写这些临时文件显然需要耗费一定的时间。当软件项目变得非常庞大的时候，花费在这上面的代价可能会变得很沉重。

解决的办法是，使用Linux提供的一种更加高效的通信方式—管道。它可以用来同时连接两个程序，其中一个程序的输出将被直接作为另一个程序的输入，这样就可以避免使用临时文件，但编译时却需要消耗更多的内存。

在编译过程中使用管道是由GCC的-pipe选项决定的。下面的这条命令就是借助GCC的管道功能来提高编译速度的：

 # gcc -pipe foo.c -o foo
 
在编译小型工程时使用管道，编译时间上的差异可能还不是很明显，但在源代码非常多的大型工程中，差异将变得非常明显。

文件扩展名

在使用GCC的过程中，用户对一些常用的扩展名一定要熟悉，并知道其含义。为了方便大家学习使用GCC，在此将这些扩展名罗列如下：

.c C原始程序；

.C C++原始程序；

.cc C++原始程序；

.cxx C++原始程序；

.m Objective-C原始程序；

.i 已经过预处理的C原始程序；

.ii 已经过预处理之C++原始程序；

.s 组合语言原始程序；

.S 组合语言原始程序；

.h 预处理文件(标头文件)；

.o 目标文件；

.a 存档文件。

GCC常用选项

GCC作为Linux下C/C++重要的编译环境，功能强大，编译选项繁多。为了方便大家日后编译方便，在此将常用的选项及说明罗列出来如下：

-c 通知GCC取消链接步骤，即编译源码并在最后生成目标文件；

-Dmacro 定义指定的宏，使它能够通过源码中的#ifdef进行检验；

-E 不经过编译预处理程序的输出而输送至标准输出；

-g3 获得有关调试程序的详细信息，它不能与-o选项联合使用；

-Idirectory 在包含文件搜索路径的起点处添加指定目录；

-llibrary 提示链接程序在创建最终可执行文件时包含指定的库；

-O、-O2、-O3 将优化状态打开，该选项不能与-g选项联合使用；

-S 要求编译程序生成来自源代码的汇编程序输出；

-v 启动所有警报；

-Wall 在发生警报时取消编译操作，即将警报看作是错误；

-Werror 在发生警报时取消编译操作，即把报警当作是错误；

-w 禁止所有的报警。

小结

GCC是在Linux下开发程序时必须掌握的工具之一。本文对GCC做了一个简要的介绍，主要讲述了如何使用GCC编译程序、产生警告信息、调试程序和加快GCC的编译速度。对所有希望早日跨入Linux开发者行列的人来说，GCC就是成为一名优秀的Linux程序员的起跑线。

来源:http://ffmpeg.blogbus.com/logs/578829.html

2004年4月20日最新版本的GCC编译器3.4.0发布了。目前，GCC可以用来编译C/C++、FORTRAN、JAVA、OBJC、ADA等语言的程序，可根据需要选择安装支持的语言。GCC 3.4.0比以前版本更好地支持了C++标准。本文以在Redhat Linux上安装GCC3.4.0为例，介绍了GCC的安装过程。

　　安装之前，系统中必须要有cc或者gcc等编译器，并且是可用的，或者用环境变量CC指定系统上的编译器。如果系统上没有编译器，不能安装源代码形式的GCC 3.4.0。如果是这种情况，可以在网上找一个与你系统相适应的如RPM等二进制形式的GCC软件包来安装使用。本文介绍的是以源代码形式提供的GCC软件包的安装过程，软件包本身和其安装过程同样适用于其它Linux和Unix系统。

　　系统上原来的GCC编译器可能是把gcc等命令文件、库文件、头文件等分别存放到系统中的不同目录下的。与此不同，现在GCC建议我们将一个版本的GCC安装在一个单独的目录下。这样做的好处是将来不需要它的时候可以方便地删除整个目录即可（因为GCC没有uninstall功能）；缺点是在安装完成后要做一些设置工作才能使编译器工作正常。在本文中我采用这个方案安装GCC 3.4.0，并且在安装完成后，仍然能够使用原来低版本的GCC编译器，即一个系统上可以同时存在并使用多个版本的GCC编译器。

　　按照本文提供的步骤和设置选项，即使以前没有安装过GCC，也可以在系统上安装上一个可工作的新版本的GCC编译器。

　　1. 下载

　　在GCC网站上（http://gcc.gnu.org/）或者通过网上搜索可以查找到下载资源。目前GCC的最新版本为 3.4.0。可供下载的文件一般有两种形式：gcc-3.4.0.tar.gz和gcc-3.4.0.tar.bz2，只是压缩格式不一样，内容完全一致，下载其中一种即可。

　　2. 解压缩

　　根据压缩格式，选择下面相应的一种方式解包（以下的“%”表示命令行提示符）：

　　% tar xzvf gcc-3.4.0.tar.gz
　　或者
　　% bzcat gcc-3.4.0.tar.bz2 | tar xvf -

　　新生成的gcc-3.4.0这个目录被称为源目录，用${srcdir}表示它。以后在出现${srcdir}的地方，应该用真实的路径来替换它。用pwd命令可以查看当前路径。

　　在${srcdir}/INSTALL目录下有详细的GCC安装说明，可用浏览器打开index.html阅读。

　　3. 建立目标目录
 
　　目标目录（用${objdir}表示）是用来存放编译结果的地方。GCC建议编译后的文件不要放在源目录${srcdir]中（虽然这样做也可以），最好单独存放在另外一个目录中，而且不能是${srcdir}的子目录。

　　例如，可以这样建立一个叫 gcc-build 的目标目录（与源目录${srcdir}是同级目录）：

　　% mkdir gcc-build
　　% cd gcc-build

　　以下的操作主要是在目标目录 ${objdir} 下进行。

　　4. 配置
 
　　配置的目的是决定将GCC编译器安装到什么地方（${destdir}），支持什么语言以及指定其它一些选项等。其中，${destdir}不能与${objdir}或${srcdir}目录相同。

　　配置是通过执行${srcdir}下的configure来完成的。其命令格式为（记得用你的真实路径替换${destdir}）：

　　% ${srcdir}/configure --prefix=${destdir} [其它选项]

　　例如，如果想将GCC 3.4.0安装到/usr/local/gcc-3.4.0目录下，则${destdir}就表示这个路径。

　　在我的机器上，我是这样配置的：

　　% ../gcc-3.4.0/configure --prefix=/usr/local/gcc-3.4.0 --enable-threads=posix --disable-checking --enable--long-long --host=i386-redhat-linux --with-system-zlib --enable-languages=c,c++,java

　　将GCC安装在/usr/local/gcc-3.4.0目录下，支持C/C++和JAVA语言，其它选项参见GCC提供的帮助说明。

　　5. 编译

　　% make

　　这是一个漫长的过程。在我的机器上（P4-1.6），这个过程用了50多分钟。

　　6. 安装

　　执行下面的命令将编译好的库文件等拷贝到${destdir}目录中（根据你设定的路径，可能需要管理员的权限）：

　　% make install

　　至此，GCC 3.4.0安装过程就完成了。

　　6. 其它设置

　　GCC 3.4.0的所有文件，包括命令文件（如gcc、g++）、库文件等都在${destdir}目录下分别存放，如命令文件放在bin目录下、库文件在lib下、头文件在include下等。由于命令文件和库文件所在的目录还没有包含在相应的搜索路径内，所以必须要作适当的设置之后编译器才能顺利地找到并使用它们。

　　6.1 gcc、g++、gcj的设置

　　要想使用GCC 3.4.0的gcc等命令，简单的方法就是把它的路径${destdir}/bin放在环境变量PATH中。我不用这种方式，而是用符号连接的方式实现，这样做的好处是我仍然可以使用系统上原来的旧版本的GCC编译器。

　　首先，查看原来的gcc所在的路径：

　　% which gcc

　　在我的系统上，上述命令显示：/usr/bin/gcc。因此，原来的gcc命令在/usr/bin目录下。我们可以把GCC 3.4.0中的gcc、g++、gcj等命令在/usr/bin目录下分别做一个符号连接：

　　% cd /usr/bin
　　% ln -s ${destdir}/bin/gcc gcc34
　　% ln -s ${destdir}/bin/g++ g++34
　　% ln -s ${destdir}/bin/gcj gcj34

　　这样，就可以分别使用gcc34、g++34、gcj34来调用GCC 3.4.0的gcc、g++、gcj完成对C、C++、JAVA程序的编译了。同时，仍然能够使用旧版本的GCC编译器中的gcc、g++等命令。

　　6.2 库路径的设置

　　将${destdir}/lib路径添加到环境变量LD_LIBRARY_PATH中，最好添加到系统的配置文件中，这样就不必要每次都设置这个环境变量了。

　　例如，如果GCC 3.4.0安装在/usr/local/gcc-3.4.0目录下，在RH Linux下可以直接在命令行上执行或者在文件/etc/profile中添加下面一句：

　　setenv LD_LIBRARY_PATH /usr/local/gcc-3.4.0/lib:$LD_LIBRARY_PATH

　　7. 测试
 
　　用新的编译命令（gcc34、g++34等）编译你以前的C、C++程序，检验新安装的GCC编译器是否能正常工作。

　　8. 根据需要，可以删除或者保留${srcdir}和${objdir}目录。

dwr.xml中的签名(Signatures)
signatures段使DWR能确定集合中存放的数据类型。例如下面的定义中我们无法知道list中存放的是什么类型。

public class Check
{
  public void setLotteryResults(List nos)
  {
      ...
  }
}
signatures段允许我们暗示DWR应该用什么类型去处理。格式对以了解JDK5的泛型的人来说很容易理解。

<signatures>
  <![CDATA[
  import java.util.List;
  import com.example.Check;
  Check.setLotteryResults(List<Integer> nos);
  ]]>
</signatures>
DWR中又一个解析器专门来做这件事，所以即便你的环境时JDK1.3 DWR也能正常工作。

解析规则基本上会和你预想规则的一样(有两个例外)，所以java.lang下面的类型会被默认import。

第一个是DWR1.0中解析器的bug，某些环境下不能返回正确类型。所以你也不用管它了。

第二个是这个解析器时"阳光(sunny day)"解析器。就是说它非常宽松，不想编译器那样严格的保证你一定正确。所以有时它也会允许你丢失import：

<signatures>
  <![CDATA[
  import java.util.List;
  Check.setLotteryResults(List<Integer>);
  ]]>
</signatures>
将来的DWR版本会使用一个更正式的解析器，这个编译器会基于官方Java定义，所以你最好不要使用太多这个不严格的东西。

signatures段只是用来确定泛型参数中的类型参数。DWR会自己使用反射机制或者运行时类型确定类型，或者假设它是一个String类型。所以：

不需要signatures - 没有泛型参数：

public void method(String p);
public void method(String[] p);
需要signatures - DWR不能通过反射确定：

public void method(List<Date> p);
public void method(Map<String, WibbleBean> p);
不需要signatures - DWR能正确的猜出:

public void method(List<String> p);
public void method(Map<String, String> p);
不需要signatures - DWR可以通过运行时类型确定：

public List<Date> method(String p);
没有必要让Javascript中的所有对象的key都是String类型 - 你可以使用其他类型作为key。但是他们在使用之前会被转换成String类型。DWR1.x用Javascript的特性把key转换成String。DWR2.0可能会用toString()方法，在服务段进行这一转换。

Comments  (Hide)
如果对于远程接口都包含public void method(Map<String, WibbleBean> p);和public void method(Map<String, String> p);的情况该怎么设置？DWR貌似会使用后面的设置，也就是好像不能够两种接口都成功设置。

转换器
转换器在客户端和服务器之间转换数据.

下面这些转换器有单独章节介绍

Array Converter
Bean and Object Converters
Collection Converter
Enum Converter
DOM Objects
Hibernate整合
Servlet Objects (HttpServletRequest, HttpSession, etc)
基础的转换器
原生类型，String，像BigDecimal这样的简单对象的转换器已经有了。你不需要在dwr.xml中<allow>部分的<convert>中定义。它们默认支持。

默认支持的类型包括： boolean, byte, short, int, long, float, double, char, java.lang.Boolean, java.lang.Byte, java.lang.Short, java.lang.Integer, java.lang.Long, java.lang.Float, java.lang.Double, java.lang.Character, java.math.BigInteger, java.math.BigDecimal 和 java.lang.String

Date转换器
Date转换器负责在Javascript的Date类型与Java中的Date类型(java.util.Date, java.sql.Date, java.sql.Times or java.sql.Timestamp)之间进行转换。同基础的转换器一样，DateConverter默认是支持的。

如果你有一个Javascript的字符串 (例如"01 Jan 2010") ，你想把它转换成Java的Date类型有两个办法：在javascript中用Date.parse()把它解析成Date类型，然后用DWR的DateConverter传递给服务器；或者把它作为字符串传递给Server,再用Java中的SimpleDateFormat(或者类似的)来解析。

同样，如果你有个Java的Date类型并且希望在HTML使用它。你可以先用SimpleDateFormat把它转换成字符串再使用。也可以直接传Date给Javascript，然后用Javascript格式化。第一种方式简单一些，尽管浪费了你的转换器，而且这样做也会是浏览器上的显示逻辑受到限制。其实后面的方法更好，也有一些工具可以帮你，例如：

The Javascript Toolbox Date formatter
Web Developers Notes on Date formatting
其他对象
其实创建自己的转换器也很简单。Converter接口的Javadoc包含了信息。其实这种需要很少出现。在你写自己的Converter之前先看看BeanConverter，它有可能就是你要的。

Bean 和 Object 转换器
两个没有默认打开的转换器是Bean 和 Object 转换器。Bean转换器可以把POJO转换成Javascript的接合数组(类似与Java中的Map)，或者反向转换。这个转换器默认情况下是没打开的，因为DWR要获得你的允许才能动你的代码。

Object转换器很相似，不同的是它直接应用于对象的成员，而不是通过getter和setter方法。下面的例子都是可以用object来替换bean的来直接访问对象成员。

如果你有一个在 <create ...> 中声明的远程调用Bean。它有个一参数也是一个bean，并且这个bean有一个setter存在一些安全隐患，那么攻击者就可能利用这一点。

你可以为某一个单独的类打开转换器：

<convert converter="bean" match="your.full.package.BeanName"/>
如果要允许转换一个包或者子包下面的所有类，可以这样写：

<convert converter="bean" match="your.full.package.*"/>
显而易见，这样写是允许转换所有的JavaBean：

<convert converter="bean" match="*"/>
BeanConverter 和 JavaBeans 规范
用于被BeanConverter转换的Bean必须符合JavaBeans的规范，因为转换器用的是Introspection，而不是Reflection。这就是说属性要符合一下条件：有getter和setter，setter有一个参数，并且这个参数的类型是getter的返回类型。setter应该返回void，getter应该没有任何参数。setter没有重载。以上这些属于常识。如果你用的不是JavaBean，那么你应该用ObjectConverter.

设置Javascript变量
DWR可以把Javascript对象(又名maps，或联合数组)转换成JavaBean或者Java对象。

一个简单的例子可以帮助你。假设你有下面的Java代码：

public class Remoted {
  public void setPerson(Person p) {
    // ...
  }
}

public class Person {
  public void setName(String name) { ... }
  public void setAge(int age) { ... }
  // ...
}
如果这个Remoted已经被配置成Creator了，Persion类也定义了BeanConverter，那么你可以通过下面的方式调用Java代码：

var p = { name:"Fred", age:21 };
Remoted.setPerson(p);
限制属性转换
就像你可以在creator的定义中剔出一些方法一样，converter也有类似的定义。

限制属性转换仅仅对于Bean有意义，很明显原生类型是不要需要这个功能的，所以只有BeanConverter及其子类型(HibernateBeanConverter))有这个功能。

语法是这样的：

<convert converter="bean" match="com.example.Fred">
  <param name="exclude" value="property1, property2"/>
</convert>
这就保证了DWR不会调用 fred.getProperty1() 和fred.getProperty2两个方法。另外如果你喜欢"白名单"而不是"黑名单"的话：

<convert converter="bean" match="com.example.Fred">
  <param name="include" value="property1, property2"/>
</convert>
安全上比较好的设计是使用"白名单"而不是"黑名单"。

对象的私有成员
通过'object'转换器的参数的一个名为force的参数，可以让DWR通过反射来访问对象私有成员。

语法是这样的：

<convert converter="object" match="com.example.Fred">
  <param name="force" value="true"/>
</convert>
直到DWR1.1.3,这里有一个bug，public的field反而不能被发现，所以你需要在public成员上设置force=true。

util.js包含一些有用的函数function,用于在客户端页面调用.

主要功能如下：

代码

1、$() 获得页面参数值   
2、addOptions and removeAllOptions 初始化下拉框   
3、addRows and removeAllRows   填充表格   
4、getText   取得text属性值   
5、getValue 取得form表单值   
6、getValues 取得form多个值   
7、onReturn     
8、selectRange   
9、setValue   
10、setValues   
11、toDescriptiveString   
12、useLoadingMessage   
13、Submission box  

代码

1、$()函数   
   IE5.0 不支持   
   $ = document.getElementById   
   取得form表单值   
   var name = $("name");  

代码

a、如果你想在更新select 时，想保存原来的数据，即在原来的select中添加新的option：   
     var sel = DWRUtil.getValue(id);   
     DWRUtil.removeAllOptions(id);   
     DWRUtil.addOptions(id,...);   
     DWRUtil.setValue(id,sel);   
     demo:比如你想添加一个option：“--请选择--”   
DWRUtil.addOptions(id,["--请选择--"]);   
  
    DWRUtil.addOptions()有5中方式：  

代码

@ Simple Array Example: 简单数组   
     例如:   
     Array array = new Array[ 'Africa', 'America', 'Asia', 'Australasia', 'Europe' ]；   
     DWRUtil.addOptions("demo1",array);  

代码

@ Simple Object Array Example 简单数组,元素为beans   
       这种情况下,你需要指定要显示 beans 的 property 以及 对应的 bean 值   
       例如:   
        public class Person {   
      private String name;   
      private Integer id;   
      pirvate String address;   
      public void set(){……}   
      public String get(){……}   
        }   
        DWRUtil.addOptions("demo2",array,'id','name');   
        其中id指向及bean的id属性，在optiong中对应value，name指向bean的name属性，对应下拉框中显示的哪个值.  

代码

@ Advanced Object Array Example 基本同上   
     DWRUtil.addOptions( "demo3",   
                 [{ name:'Africa', id:'AF' },   
                  { name:'America', id:'AM' },   
                  { name:'Asia', id:'AS' },   
                  { name:'Australasia', id:'AU' },   
                  { name:'Europe', id:'EU' }   
         ],'id','name');  

代码

@ Map Example 用制定的map来填充 options:   
        如果 server 返回 Map,呢么这样处理即可：   
        DWRUtil.addOptions( "demo3",map);   
        其中 value 对应 map keys，text 对应 map values；  

代码

@ <ul> and <ol> list editing   
        
        DWRUtil.addOptions() 函数不但可以填出select,开可以填出<ul>和<ol>这样的heml元素  

3、addRows and removeAllRows 填充表格

DWR 提供2个函数来操作 table；

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

DWRUtil.addRows(); 添加行

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

DWRUtil.removeAllRows(id); 删除指定id的table

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

下面着重看一下 addRows() 函数：

DWRUtil.addRows(id, array, cellfuncs, [options]);

其中id 对应 table 的 id(更适合tbodye，推荐使用 tbodye)

array 是server端服务器的返回值，比如list，map等等

cellfuncs 及用返回值来天春表格

[options] 用来设置表格样式，它有2个内部函数来设置单元格样式(rowCreator、cellCreator)。

比如: server端返回list，而list中存放的是下面这个 bean：

代码

       public class Person {   
private String name;   
private Integer id;   
pirvate String address;   
public void set(){……}   
public String get(){……}   
      }  

下面用 DWRUtil.addRows();

代码

    function userList(data){   
     //var delButton = "<input type='button'/>";   
     //var editButton = "<input type='button'/>";   
     var cellfuncs = [   
         function(data){return data.id;},   
         function(data){return data.userName;},   
         function(data){return data.userTrueName;},   
         function(data){return data.birthday;},   
         function(data){   
         var idd = data.id;   
var delButton = document.createElement("<INPUT TYPE='button' onclick='delPerson("+ idd +")'>");   
             delButton.setAttribute("id","delete");   
             delButton.setAttribute("value","delete");   
             return delButton;   
         },   
         function(data){   
             var idd = data.id;   
             var editButton = document.createElement("<INPUT TYPE='button' onclick='editPerson("+ idd +")'>");   
             editButton.setAttribute("name","edit");   
             editButton.setAttribute("value","edit");               
             return editButton;   
         }   
     ];   
     DWRUtil.removeAllRows('tabId');   
     DWRUtil.addRows('tabId', data,cellfuncs,{   
     rowCreator:function(options) {   
         var row = document.createElement("tr");   
         var index = options.rowIndex * 50;   
         row.setAttribute("id",options.rowData.id);   
         row.style.collapse = "separate";   
         row.style.color = "rgb(" + index + ",0,0)";   
         return row;   
     },   
     cellCreator:function(options) {   
         var td = document.createElement("td");   
         var index = 255 - (options.rowIndex * 50);   
         //td.style.backgroundColor = "rgb(" + index + ",255,255)";   
         td.style.backgroundColor = "menu";   
         td.style.fontWeight = "bold";   
         td.style.align = "center";   
         return td;   
     }          
     });   
     document.getElementById("bt").style.display = "none";   
      }  

4、getText 取得text属性值

DWRUtil.getText(id): 用来获得 option 中的文本

比如：

代码

       <select id="select">  
<option   value="1"> 苹果 </option>  
<option   value="2" select> 香蕉 </option>  
<option   value="3"> 鸭梨 </option>  
       </select>  

调用 DWRUtil.getText("select"); 将返回 "香蕉" 字段；

DWRUtil.getText(id)；仅仅是用来获得 select 文本值，其他不适用。

5、DWRUtil.getValue(id): 用来获得 form 表单值

有如下几种情况：

代码

      Text area (id="textarea"): DWRUtil.getValue("textarea")将返回 Text area的值;   
Selection list (id="select"): DWRUtil.getValue("select") 将返回 Selection list 的值;   
Text input (id="text"): DWRUtil.getValue("text") 将返回 Text input 的值;   
Password input (id="password"): DWRUtil.getValue("text") 将返回 Password input 的值;   
Form button (id="formbutton"): DWRUtil.getValue("formbutton") 将返回 Form button 的值;   
Fancy button (id="button"): DWRUtil.getValue("formbutton") 将返回 Fancy button 的值;  

6、getValues 取得form多个值

批量获得页面表单的值,组合成数组的形式,返回 name/value;

例如: form():

代码

     <input type="textarea" id="textarea" value="1111"/>  
      <input type="text" id="text" value="2222"/>  
      <input type="password" id= "password" value="3333"/>  
      <select id="select">  
<option   value="1"> 苹果 </option>  
<option   value="4444" select> 香蕉 </option>  
<option   value="3"> 鸭梨 </option>  
       </select>  
      <input type="button" id="button" value="5555"/>  
        
      那么: DWRUtil.getValues({textarea:null,select:null,text:null,password:null,button:null})   
      将返回   ^^^^^^^^^^^^^^^^{textarea:1111,select:4444,text:2222,password:3333,button:5555}  

7、DWRUtil.onReturn 防止当在文本框中输入后，直接按回车就提交表单。

<input type="text" onkeypress="DWRUtil.onReturn(event, submitFunction)"/>

<input type="button" onclick="submitFunction()"/>

8、DWRUtil.selectRange(ele, start, end);

在一个input box里选一个范围

代码

DWRUtil.selectRange("sel-test", $("start").value, $("end").value);   
  
比如:<input type="text" id="sel-test" value="012345678901234567890">   
  
DWRUtil.selectRange("sel-test", 2, 15);  

9、DWRUtil.setValue(id,value);

为指定的id元素,设置一个新值;

10、DWRUtil.setValues({

name: "fzfx88",

password: "1234567890"

}

); 同上,批量更新表单值.

/***********************************************************************/

11、DWRUtil.toDescriptiveString()

带debug信息的toString，第一个为将要debug的对象，第二个参数为处理等级。等级如下：

0: Single line of debug 单行调试

1: Multi-line debug that does not dig into child objects 不分析子元素的多行调试

2: Multi-line debug that digs into the 2nd layer of child objects 最多分析到第二层子元素的多行调试

<input type="text" id="text">

DWRUtil。toDescriptiveString("text",0);

/******************************************************************************/

12、DWRUtil.useLoadingMessage();

当发出ajax请求后,页面显示的提示等待信息;

代码

    function searchUser(){   
var loadinfo = "loading....."  
try{   
     regUser.queryAllUser(userList);   
     DWRUtil.useLoadingMessage(loadinfo);           
}catch(e){   
  
}   
    }