1  下载 mingw-msys ，安装
 
 2  开始 -- 程序 MinGW-MSYS ，打开 MinGW 命令界面 ，进入 ffmpeg 目录
 
 3  configure 参数， 贴一张我编译的参数，实现 h264 + rtsp 解码用  ，时间很长 ，等吧 
 
 这个编译的静态库 ，  动态库 编译参数里 更改  --disable-static --eanble-shared  ，要先 disable ,再 enable
 
 
 
 
 4   make   ， 然后 在  make install ,
 
 5  到 msys\1.0\local 下面去找编译好的  动态库 或者 静态库 
 
     动态库 放在了  bin 文件夹下，以及与之 相关的 lib 
 
     静态库 放在了 lib 文件夹下，.a格式
 
 VS2008 使用编译好的 ffmpeg  
 
 1 动态编译  使用动态库比较简单了，包含头文件  ，连接bin 下的 lib 文件就可以了
 
 2 静态编译 ，比较麻烦 
 
    1) 包含头文件 ，包含 lib 文件夹下的 .a 库文件
 
    2) 需要引入另外的库文件 ，libgcc.a libmingwex.a libmoldname.a  ，这些在 MinGW - MSYS 安装目录下 搜索就行了 ，
 
 我用到库是这样
 
      Version.lib
 libgcc.a
 libmingwex.a
 libmoldname.a
 libavcodec.a
 libavformat.a
 
   libswscale.a
 libavutil.a
 libavfilter.a
 
 3)   如果编译到一个DLL或者 activex 控件里 ，那么 release 版本可能注册不上 ，修改  链接器--优化--引用---保留未引用数据(/OPT:NOREF)，

Linux C 编程入门之一：gcc 编译动态库和静态库
cheungmine
2012

参考:
C程序编译过程浅析
http://blog.csdn.net/koudaidai/article/details/8092647


1 准备工作
Windows7+Cygwin+gcc

在同一个目录下准备好下面3个文件，其中3-2，3-3用来生成动态库或静态库:
主调用程序源代码3-1：main.c


/**
 * main.c
 */
#include <stdio.h>
#include <math.h>

#include "hello_fn.h"

int
main ()
{
  hello("cheungmine");
  printf("sqrt(2.0) = %f\n", sqrt(2.0));
  return 0;
}

库源代码3-2：hello_fn.c


/**
 * hello_fn.c
 */
#include <stdio.h>

void hello(const char *msg)
{
  printf("Hello %s!\n", msg);
}


 
库头文件源代码3-3：hello_fn.h

/**
 * hello_fn.h
 */
void hello(const char *msg);


2 编译库
2.1 首先编译源文件生成对象(obj)文件(main.o, hello_fn.o)：

$ gcc -W -Wall -ansi -pedantic -I. -c main.c
$ gcc -W -Wall -ansi -pedantic -I. -c hello_fn.c


2.2 然后从对象文件编译动态库文件(libhello.so)和静态库(libhello.a)

$ gcc -shared hello_fn.o -o libhello.so
或者直接从源代码编译：
$ gcc -shared -I. hello_fn.c -o libhello.so
编译静态库相对简单，就是相当于目标文件归档：
$ ar r libhello.a hello_fn.o




3 编译使用库的主程序
3.1 如果不链接库的情况下编译一个主程序是：

$ gcc main.o -o main
或者
$ gcc -c main.c -o main
但是由于我们在main.c的代码中写固定了调用库的代码(hello函数)，所以，必须链接到这个库才行。

3.2 链接到动态库libhello.so

$ gcc main.o -o main ./libhello.so

这样在当前目录下就生成了：main.exe（我的cygwin环境，Linux环境下没有扩展名）

运行这个main.exe：

$ ./main.exe
删除libhello.so，再运行main.exe会报错误：error while loading shared libraries: libhello.so: cannot open shared object...

3.3 链接到静态库libhello.a

$ gcc main.o -o main2 ./libhello.a
删除libhello.a，运行main2.exe，一切正常。说明程序的确链接到静态库了。

4 查看程序依赖的库

$ file main.exe main2.exe
$ ldd main.exe main2.exe
如果我们的动态库libhello.so与主程序不在同一个目录下，怎么办？

复制libhello.so和libhello.a到另外一个目录，比如：/cygdrive/c/temp，那么编译主程序为：

$ gcc main.o -o main /cygdrive/c/temp/libhello.so
执行：
$ export PATH=/cygdrive/c/temp:$PATH
$ ./main.exe 


5 运行时加载动态库
修改main.c文件为如下清单：

/**
 * main.c
 */
#include <stdio.h>
#include <math.h>
#include <dlfcn.h>
#include "hello_fn.h"

void dl_hello()
{
  void *dp;
  char *error;
  void (*fn_hello)(const char*);

  dp = dlopen("libhello.so", RTLD_LAZY );
  if(!dp) {
    printf("%s\n", dlerror());
    exit(1);
  }

  fn_hello = dlsym(dp, "hello");
  if(!fn_hello) {
    printf("%s\n", dlerror());
    exit(1);
  }

  fn_hello("cheungmine: load library when running");

  dlclose(dp);
}
    
int
main ()
{
//  hello("cheungmine");
  dl_hello();
  printf("sqrt(2.0) = %f\n", sqrt(2.0));
  return 0;
}


然后重新编译main.exe和libhello.so如下：


编译源文件
$ gcc -Wall -I. -c main.c
$ gcc -Wall -I. -c hello_fn.c
编译动态库
$ gcc -shared hello_fn.o -o libhello.so
链接主程序，但不链接到动态库。
$ gcc main.o -o main.exe
执行下面的代码可以看到libhello.so并不在main.exe的依存之列：
$ ldd main.exe
移动库到其他目录，通过修改环境变量，程序main.exe执行正确： 
$ mv libhello.so /cygdrive/c/temp
$ export PATH=.:/cygdrive/c/temp:$PATH
$ ./main.exe




6 总结
通过上面的练习，基本清楚了如何用gcc编译程序，包括静态链接库和动态链接库。通过下面的表格可以看到
Linux和Windows的区别：

                               Windows                      Unix/Linux

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

静态链接库              hello.lib                            libhello.a

动态链接库              hello.dll                            libhello.so
延迟加载                  LoadLibrary                    dlopen
                                  GetProcAddress            dlsym
                                  FreeLibrary                     dlclose


本文全部内容在cygwin上运行的，和真实的Linux环境还是存在差异的。gcc版本3.4.4。

网上找了n多编译的过程，都不是真正编译静态库，要么就是还是使用的老版本的方法，使用以下方法，编译成功静态库和动态可以，make一下。
 
 
 
以下为windows上安装过程
 
1、下载 openssl-1.1.0.tar.gz
 
2、安装 ActivePerl， http://www.activestate.com/activeperl/downloads下载最新版本， 需要用到 perl 解释器。
 
     注：Perl 最低版本要求5.10以上，Windows XP用户最后支持版本ActivePerl 5.20.2.2002 版本
 
3、使用 VS2010 下的 Visual Studio 2010 Command Prompt 进入控制台模式 。
 
4、如果提示安装dmake，就ppm install dmake，已安装过忽略。
 
5、解压缩 openssl 源代码包，进入 openssl 的根目录， 如 E:\openssl-1.1.0。
 
6、动态库：perl configure VC-WIN32 --prefix="e:\mylib"
 
     静态库：perl configure  no-shared VC-WIN32 --prefix="e:\mylib"
 
必须在 c:\openssl-1.1.0 目录下执行该命令， 否则找不到 Configure 文件， 这时就必须指定完整的 Configure 文件路径。
 
64编译的话 Win64/x64 执行 perl Configure VC-WIN64A；Win64/IA64 执行 perl Configure VC-WIN64I。
 
注意：VC-WIN32必须大写，编译选项有大小写区分，--prefix设置编译成功后lib的存放目录
 
7、正式编译
 
8、编译, nmake
 
9、编译, nmake test
 
10、编译, nmake install

类似Windows系统中的动态链接库，Linux中也有相应的共享库用以支持代码的复用。Windows中为*.dll，而Linux中为*.so，我来详细的告诉你如何在linux下编写动态库,以及如何使用它.
 
在linux下编写动态链接库的步骤:
 
 
 
1.      编写库的头文件和源文件.
 
2.      把所有涉及到的源文件用如下方式编译为目标文件:
 
 
 
g++/gcc -g -c -fPIC -o library1.o library1.cpp
 
g++/gcc -g -c -fPIC -o library2.o library2.cpp
       ......
 
......
 
（注释：-fPIC指通过这个选项来生成与位置无关的代码，可以在任何地址被连接和装载，-c指只编译而不连接原程序）
 
 
 
3.      把所有的目标文件链接为动态库:
 
 
 
g++/gcc -g -shared -Wl,-soname,lib***.so -o lib***.so.1.0.0 library1.o library2.o ....  -lc
 
                
 
    （注释：-lc选项，表示使用c语言库，一般都要用到）
 
 
 
4.      建立一个库名链接
 
 
 
ln -s lib***.so.1.0.0 lib***.so
 
 
 
现在你就可以引用库了.下面我分别给出简单例子告诉你如何动态和静态使用动态库:
 
假如你的应用程序源代码叫testlib.cpp
 
采用/如下方式编译:
 
 
 
      g++ -g -o testlib testlib.cpp -ldl
 
            
 
    （注释：-ldl选项，表示生成的对象模块需要使用共享库）
 
 
 
这个例子告诉你如何动态的调用.so库
 
testlib.cpp
 
#include <dlfcn.h>
 
#include <iostream.h>
 
#include ...
 
int main()
 
{
 
       void *handle=NULL;
 
       //define a pointer which will point to the function in the lib you want to use.
 
       YourFuntionType (*pFunc)(YourFunctionPerameterList........);
 
       //open the lib you want to use.
 
       handle=dlopen("/../../../yourlib.so",RTLD_LAZY);
 
       if(handle==NULL)
 
       {
 
              cout<<"failed loading library!"<<endl;
 
              return -1;
 
       }
 
       dlerror();
 
       //try to load the function in lib
 
       pFunc=(YourFuntionType(*)(YourFunctionPerameterList))dlsym(handle,"YourFuntionName");
 
       if(dlerror()!=NULL)
 
       {
 
              cout<<"Loading function in lib error!"<<endl;
 
              return -1;
 
       }
 
       //now you can use the funtion like this
 
       (*pFunc)(YourFuntionPerameterList);
 
       return 0;
 
}  
 
 
 
（注释：dlopen()
 
              第一个参数：指定共享库的名称，将会在下面位置查找指定的共享库。
 
－环境变量LD_LIBRARY_PATH列出的用分号间隔的所有目录。
 
－文件/etc/ld.so.cache中找到的库的列表，用ldconfig维护。
 
－目录usr/lib。
 
－目录/lib。
 
－当前目录。（这里就是这种情况）
 
 
 
第二个参数：指定如何打开共享库。
 
－RTLD_NOW：将共享库中的所有函数加载到内存
 
－RTLD_LAZY：             会推后共享库中的函数的加载操作，直到调用dlsym()时方加载某函数
 
dlsym()
 
          调用dlsym时，利用dlopen()返回的共享库的phandle以及函数名称作为参数，返回要加载函数的入口地址。
 
       dlerror()
 
    该函数用于检查调用共享库的相关函数出现的错误。
 
）
 
 
 
特别需要注意的几点问题:
 
1.      当你想用c++写动态库的时候,记住千万别忘了在头文件里面加上如下内容,否则生成的库在动态调用的时候会出问题!!!!!!!
 
 #ifdef __cplusplus
        extern "C" {
 
#endif
 
....
 
....
 
   #ifdef __cplusplus
 
}
 
#endif 
 
 
 
2.      当你的库中包括与omniORB3相关的东西的时候,一定要在makefile中加上 -D__x86__ -D__OSVERSION=4
 
 
 
/这个例子告诉你如何静态调用.so库
 
首先你得确保你的应用程序能够找到你的.so库,这可以有几种方法来实现.
 
方法一:
 
1.你可以把YourLib.so.1.0.0 和YourLib.so放到/usr/lib中,然后执行命令:ldconfig,这样你就可以在你的应用程序中直接调用你库中的函数了,当然你 得把库的头文件包含到你的应用程序中
 
2.编译你的应用程序
 
g++/gcc -g -o yourapp yourapp.cpp –lYourLib
 
 
 
方法二:
 
1.你也可以采用在系统中设置环境变量的办法来实现. 在root目录下:
 
vi .bash_profile
 
然后添加LD_LIBRARY=/../YourDirIncludingYourLib
 
然后注消一次,环境变量就生效了,这样你就可以在你的应用程序中直接调用库中的函数了,同样你得有头文件.
 
2.编译你的应用程序
 
g++/gcc -g -o yourapp yourapp.cpp –lYourLib
 
 
 
方法三:
 
你可以直接采用在编译链接的时候告诉系统你的库在什么地方
        g++/gcc -g -o yourapp yourapp.cpp -L/YourDirIncludingYourLib –lYourLib
 
/
 
假如你的库中有个函数:int eat(.....)
 
那么采用如下方式调用它
 
yourapp.cpp
 
#include "YourLib.h"
 
int main()
 
{
 
       eat();
 
return 0;
 
}
 
 
 
是不是很easy?对了在静态调用的时候好像不存在上面的"注意1"的问题,不过鉴于保险起见,最好还是按照标准的方式写c++头文件吧,这绝对是个好习惯.