Xvid 进行视频编码

1 Vs2005下编译XDiv库

1.从网上下载www.xvid.org上下载1.1.2,并解压 http://downloads.xvid.org/downloads/xvidcore-1.2.2.zip
2.编译过程中需要用到nasm这个编译汇编的工具http://sourceforge.net/projects/nasm/下 载一个win32版本
将你安装的nasm的工具的目录加入VS中如果你你解压的方式，也一样，工具->选项->项目和解决方案->VC++
目录 可执行文件下面就是要添加你的的nasm工具的目录.
3.找到xvidcore/build/win32目录双击xvidcore.dsw就可以打开目录了，这个解决方案里有很多项目，我的做法是一个一个来，所以除了libxvidcore这个项目，其它的全部卸载
4.开始编译
出现
   nasm: error: no input file specified
type `nasm -h' for help              有这句话说明你的nasm在你的VS中已经使用了，但用法错误
Assembling xxx/src/image/x86_asm/colorspace_yuyv_mmx.asm
导致这个错误的原因不在于你，在 xvid的论坛上找到了错误原因，因为在VC6工程转换到.NET工程的时候，命令行里的宏给自动加上了双引号，（牛人告诉我的）
你需要找到libxvidcore->image->colorspace_yuyv_mmx.asm ,右击选择它的属性
配置属性->自定义属性->命令行
把有" 号去掉，千万不要多删，
nasm -o $(IntDir)/$(InputName).obj -f win32 -DWINDOWS -I../../src/ -I$(InputDir)/ $(InputPath)
像这样，尤其右边有个空格不能自作多情的删掉，
然后编译，很多警告，无视它。
就可以在win32的bin目录下找到xvidcore.dll和xvidcore.dll.a，其实到这里我在工程中要用到的
东西已经够了，但牛人们都给了完整的方案了，咱就勤快点，跟着做呗！


这写项目里还有其它几个项目，经试验xvid_bench和xvid_decraw_static 应为库的问题，链接出错
将刚编译bin/所有文件拷到win32目录下，在出错的项目属性中
项目属性->配置属性->连接器->输入->附加依赖库中添加libxvidcore.lib ,就不报错了。

.5、 编译VFW工程
没出现错误
6.编译dshow工程，因为它会用到directshow的sample里面的头文件
需要下载directshow SDK 没那份心思，不干了，留给需要的人去做吧。
参考贴 
http://www.cnblogs.com/hyamw/archive/2007/01/25/630594.html

2 xvid静态库的封装类（编码和解码）

北京理工大学 20981 陈罡

xvid静态库用起来虽然速度很快，但是很不方便，有必要用c++把它好好封装一下，方便开发人员使用。下面的代码已经在p2p视频会议中采用，很好用，速度也很快。

 

xvid编码器头文件：

#ifndef _XVID_ENCODE_H
#define _XVID_ENCODE_H
#include <xvid.h>

class CXvidEncHandler {
public:
 virtual void PostEncHandler(unsigned char * xvid, int key, int xvid_len) = 0 ;
};

class CXvidEnc {
protected:
 // original encode routine in xvid lib
 int   enc_core(unsigned char *image, unsigned char *bitstream, int *key);

public:
 CXvidEnc() ;
 ~CXvidEnc() ;
 bool            Open();
 bool            Close();
 static void     XVID_GLOBAL_INIT();
 void            Encode(unsigned char * image);
 void   AttachCaller(int width, int height, CXvidEncHandler * enc_caller) ;
protected:
 CXvidEncHandler* m_enc_caller ;
 void *           m_enc_handle;
 unsigned char*   m_bitstream;
 bool             m_closed;
 int        m_key ;
 int     m_width ;
 int     m_height ;
};
#endif

 

编码器源文件：

#include "StdAfx.h"
#include "./xvidenc.h"
#include "xvid.h"

static const int motion_presets[] = {
 /* quality 0 */
 0,
 /* quality 1 */
 XVID_ME_ADVANCEDDIAMOND16,
 /* quality 2 */
 XVID_ME_ADVANCEDDIAMOND16 | XVID_ME_HALFPELREFINE16,
 /* quality 3 */
 XVID_ME_ADVANCEDDIAMOND16 | XVID_ME_HALFPELREFINE16 |
 XVID_ME_ADVANCEDDIAMOND8 | XVID_ME_HALFPELREFINE8,
 /* quality 4 */
 XVID_ME_ADVANCEDDIAMOND16 | XVID_ME_HALFPELREFINE16 |
 XVID_ME_ADVANCEDDIAMOND8 | XVID_ME_HALFPELREFINE8 |
 XVID_ME_CHROMA_PVOP | XVID_ME_CHROMA_BVOP,
 /* quality 5 */
 XVID_ME_ADVANCEDDIAMOND16 | XVID_ME_HALFPELREFINE16 |
 XVID_ME_ADVANCEDDIAMOND8 | XVID_ME_HALFPELREFINE8 |
 XVID_ME_CHROMA_PVOP | XVID_ME_CHROMA_BVOP,
 /* quality 6 */
 XVID_ME_ADVANCEDDIAMOND16 | XVID_ME_HALFPELREFINE16 | XVID_ME_EXTSEARCH16 |
 XVID_ME_ADVANCEDDIAMOND8 | XVID_ME_HALFPELREFINE8 | XVID_ME_EXTSEARCH8 |
 XVID_ME_CHROMA_PVOP | XVID_ME_CHROMA_BVOP,
};

#define ME_ELEMENTS (sizeof(motion_presets)/sizeof(motion_presets[0]))

static const int vop_presets[] = {
 /* quality 0 */
 0,
 /* quality 1 */
 0,
 /* quality 2 */
 XVID_VOP_HALFPEL,
 /* quality 3 */
 XVID_VOP_HALFPEL | XVID_VOP_INTER4V,
 /* quality 4 */
 XVID_VOP_HALFPEL | XVID_VOP_INTER4V,
 /* quality 5 */
 XVID_VOP_HALFPEL | XVID_VOP_INTER4V |
 XVID_VOP_TRELLISQUANT,
 /* quality 6 */
 XVID_VOP_HALFPEL | XVID_VOP_INTER4V |
 XVID_VOP_TRELLISQUANT | XVID_VOP_HQACPRED,
};

#define VOP_ELEMENTS (sizeof(vop_presets)/sizeof(vop_presets[0]))
//
#define MAX_ZONES   64
/* Maximum number of frames to encode */
#define ABS_MAXFRAMENR 9999
static int ARG_STATS = 0;
static int ARG_DUMP = 0;
static int ARG_LUMIMASKING = 0;
static int ARG_BITRATE = 0;
static int ARG_SINGLE = 0;
static char *ARG_PASS1 = 0;
static char *ARG_PASS2 = 0;
static int ARG_QUALITY = ME_ELEMENTS - 1;
static float ARG_FRAMERATE = 25.00f;
static int ARG_MAXFRAMENR = ABS_MAXFRAMENR;
static int ARG_MAXKEYINTERVAL = 0;
static char *ARG_INPUTFILE = NULL;
static int ARG_INPUTTYPE = 0;
static int ARG_SAVEMPEGSTREAM = 0;
static int ARG_SAVEINDIVIDUAL = 0;
static char *ARG_OUTPUTFILE = NULL;
static int ARG_BQRATIO = 150;
static int ARG_BQOFFSET = 100;
static int ARG_MAXBFRAMES = 0;
static int ARG_PACKED = 0;
static int ARG_VOPDEBUG = 0;
static int ARG_GMC = 0;
static int ARG_INTERLACING = 0;
static int ARG_QPEL = 0;
static int ARG_CLOSED_GOP = 0;

#ifndef READ_PNM
#define IMAGE_SIZE(x,y) ((x)*(y)*3/2)
#else
#define IMAGE_SIZE(x,y) ((x)*(y)*3)
#endif

#define MAX(A,B) ( ((A)>(B)) ? (A) : (B) )
#define SMALL_EPS (1e-10)
#define SWAP(a) ( (((a)&0x000000ff)<<24) | (((a)&0x0000ff00)<<8) | (((a)&0x00ff0000)>>8)  | (((a)&0xff000000)>>24) )

//
CXvidEnc::CXvidEnc()
{
 m_closed = true ;
 m_enc_caller = NULL ;
 m_enc_handle = NULL ;
 m_key = 0 ;
 m_width = 0 ;
 m_height = 0 ;
 m_bitstream = NULL ;
}

CXvidEnc::~CXvidEnc() {
 if(m_bitstream) free(m_bitstream) ;
 m_bitstream = NULL ;
}

bool CXvidEnc::Close() {
 int xerr = 0 ;
 m_closed = true;
 /* Destroy the encoder instance */
 xerr = xvid_encore(m_enc_handle, XVID_ENC_DESTROY, NULL, NULL);
 return (xerr) ? false : true ;
}

void CXvidEnc::AttachCaller(int width, int height, CXvidEncHandler * enc_caller)
{
 m_width = width ;
 m_height = height ;
 m_enc_caller = enc_caller ;
 if(m_width > 0 && m_height > 0) {
  // max size
  int max = (m_width > m_height) ? m_width : m_height ;
  int xvid_len = (int)(max * max) ;
  m_bitstream = (unsigned char *)malloc(xvid_len) ;
  memset(m_bitstream, 0, xvid_len) ;
  CXvidEnc::XVID_GLOBAL_INIT() ;
 }
}

void CXvidEnc::XVID_GLOBAL_INIT(){
 /*------------------------------------------------------------------------
  * XviD core initialization
  *----------------------------------------------------------------------*/
 xvid_gbl_init_t xvid_gbl_init;
 memset(&xvid_gbl_init, 0, sizeof(xvid_gbl_init));
 xvid_gbl_init.version = XVID_VERSION;
 xvid_gbl_init.cpu_flags = XVID_CPU_FORCE | XVID_CPU_ASM ; // here we use asm optimized code
 /* Initialize XviD core -- Should be done once per __process__ */
 xvid_global(NULL, XVID_GBL_INIT, &xvid_gbl_init, NULL);
}

bool CXvidEnc::Open() {
 if(!m_enc_caller) return false ;
 static xvid_enc_create_t xvid_enc_create;
 int xerr = 0;
 m_closed = false;
 /*------------------------------------------------------------------------
 * XviD encoder initialization
 *----------------------------------------------------------------------*/
 memset(&xvid_enc_create, 0, sizeof(xvid_enc_create));
 xvid_enc_create.version = XVID_VERSION;

 /* Width and Height of input frames */
 xvid_enc_create.width = m_width ;
 xvid_enc_create.height = m_height ;
 xvid_enc_create.profile = XVID_PROFILE_AS_L4;

 /* init plugins  */
 /*
 xvid_enc_create.zones = ZONES;
 xvid_enc_create.num_zones = NUM_ZONES;
 xvid_enc_create.plugins = plugins;
 xvid_enc_create.num_plugins = 0;
 */
 /* No fancy thread tests */
 xvid_enc_create.num_threads = 0;

 /* Frame rate - Do some quick float fps = fincr/fbase hack */   
 xvid_enc_create.fincr = 1;
 xvid_enc_create.fbase = (int)10;

 /* Maximum key frame interval */
 xvid_enc_create.max_key_interval = (int)-1;    //--default 10s
 
 /* Bframes settings */
 xvid_enc_create.max_bframes = ARG_MAXBFRAMES;
 xvid_enc_create.bquant_ratio = ARG_BQRATIO;
 xvid_enc_create.bquant_offset = ARG_BQOFFSET;
 
 /* Dropping ratio frame -- we don't need that */
 xvid_enc_create.frame_drop_ratio = 0;
 
 /* Global encoder options */
 xvid_enc_create.global = 0;
 if (ARG_PACKED)
  xvid_enc_create.global |= XVID_GLOBAL_PACKED;

 if (ARG_CLOSED_GOP)
  xvid_enc_create.global |= XVID_GLOBAL_CLOSED_GOP;

 if (ARG_STATS)
  xvid_enc_create.global |= XVID_GLOBAL_EXTRASTATS_ENABLE;

 /* I use a small value here, since will not encode whole movies, but short clips */
 xerr = xvid_encore(NULL, XVID_ENC_CREATE, &xvid_enc_create, NULL);
 
 m_enc_handle = xvid_enc_create.handle;
 
 return true;
}

void CXvidEnc::Encode(unsigned char * image) {
 int ret = 0 ;   
 if(m_closed) return;

 ret = enc_core(image, m_bitstream, &m_key) ;

 // really encode some images into xvid data
 if (ret > 0)
  m_enc_caller->PostEncHandler(m_bitstream, m_key, ret) ;
 }

/*
 raw CXvidEnc procedure
*/
int CXvidEnc::enc_core(unsigned char *image,unsigned char *bitstream, int * key)
{
 int ret;   
 xvid_enc_frame_t xvid_enc_frame;
 xvid_enc_stats_t xvid_enc_stats;
    
 /* Version for the frame and the stats */
 memset(&xvid_enc_frame, 0, sizeof(xvid_enc_frame));
 xvid_enc_frame.version = XVID_VERSION;

 memset(&xvid_enc_stats, 0, sizeof(xvid_enc_stats));
 xvid_enc_stats.version = XVID_VERSION;

 /* Bind output buffer */
 xvid_enc_frame.bitstream = bitstream;
 xvid_enc_frame.length = -1;
    
 /* Initialize input image fields */
 xvid_enc_frame.input.plane[0] = image;
 xvid_enc_frame.input.csp = XVID_CSP_BGR; // suppose we get data from usb web cam
 xvid_enc_frame.input.stride[0] = m_width*3;
 /* Set up core's general features */
 xvid_enc_frame.vol_flags = 0;
     
 /* Set up core's general features */
 xvid_enc_frame.vop_flags = vop_presets[ARG_QUALITY-2];
   
 /* Frame type -- let core decide for us */
 xvid_enc_frame.type = XVID_TYPE_AUTO;
    
 /* Force the right quantizer -- It is internally managed by RC plugins */
 xvid_enc_frame.quant = 0;

 /* Set up motion estimation flags */
 xvid_enc_frame.motion = motion_presets[ARG_QUALITY-2];
 /* We don't use special matrices */
 xvid_enc_frame.quant_intra_matrix = NULL;
 xvid_enc_frame.quant_inter_matrix = NULL;

 /* Encode the frame */
 ret = xvid_encore(m_enc_handle, XVID_ENC_ENCODE, &xvid_enc_frame,NULL);
 //    &xvid_enc_stats);
 //--判别是否是关键帧
 *key = (xvid_enc_frame.out_flags & XVID_KEYFRAME);
 //*stats_type = xvid_enc_stats.type;
 //*stats_quant = xvid_enc_stats.quant;
 //*stats_length = xvid_enc_stats.length;
 //sse[0] = xvid_enc_stats.sse_y;
 //sse[1] = xvid_enc_stats.sse_u;
 //sse[2] = xvid_enc_stats.sse_v;
    
 return (ret);
}

 

解码器头文件：

#ifndef _XVID_DECODE_H
#define _XVID_DECODE_H
 
#include <xvid.h>
 
class CXvidDecHandler {
public:
 virtual void PostDecHandler(unsigned char * image, int used_bytes) = 0 ;
};

class CXvidDec {

public:
 CXvidDec() ;
 ~CXvidDec() ;
 bool               Open();
 bool               Close();
 void               Decode(unsigned char* xvid, int xvid_len);
 static void     XVID_GLOBAL_INIT();
 void      AttachCaller(int width, int height, CXvidDecHandler * dec_caller) ;

protected:
 int                dec_core(unsigned char *bitstream, unsigned char *image, int bs_size) ;

protected:
 CXvidDecHandler*  m_dec_caller ;
 void*             m_dec_handle ;
 unsigned char *   m_image ;
 int      m_width ;
 int      m_height ;
};
#endif

 

解码器源文件：

#include "StdAfx.h"
#include "./xviddec.h"
#include "xvid.h"

CXvidDec::CXvidDec() {
 m_width = 0 ;
 m_height = 0 ;
 m_image = NULL ;
 m_dec_handle = NULL ;
 m_dec_caller = NULL ;
}

CXvidDec::~CXvidDec()
{
 if(m_image) free(m_image) ;
 m_image = NULL ;
}

void CXvidDec::AttachCaller(int width, int height, CXvidDecHandler * dec_caller)
{
 m_width = width ;
 m_height = height ;
 m_dec_caller = dec_caller ;
 if((m_width > 0) && (m_height > 0)) {
  int image_len = m_width * m_height * 3 ;
  m_image = (unsigned char *)malloc(image_len) ;
  memset(m_image, 0, image_len) ;
  CXvidDec::XVID_GLOBAL_INIT() ;
 }
}

bool CXvidDec::Close(){
 int xerr = 0 ;

 /* Destroy the encoder instance */
 xerr = xvid_decore(m_dec_handle, XVID_ENC_DESTROY, NULL, NULL);

 return (xerr) ? false : true ;
}

void CXvidDec::XVID_GLOBAL_INIT() {
 /*------------------------------------------------------------------------
  * XviD core initialization
  *----------------------------------------------------------------------*/
 xvid_gbl_init_t xvid_gbl_init;
 memset(&xvid_gbl_init, 0, sizeof(xvid_gbl_init));
 xvid_gbl_init.version = XVID_VERSION;
 xvid_gbl_init.cpu_flags = XVID_CPU_FORCE | XVID_CPU_ASM ; // force to use asm optimized routine
 /* Initialize XviD core -- Should be done once per __process__ */
 xvid_global(NULL, XVID_GBL_INIT, &xvid_gbl_init, NULL);
}

bool CXvidDec::Open() {
 if(!m_dec_caller) return false ;
 static xvid_dec_create_t xvid_dec_create ;
 int ret = 0;
 /*------------------------------------------------------------------------
  * XviD encoder initialization
  *----------------------------------------------------------------------*/
 
 memset(&xvid_dec_create, 0, sizeof(xvid_dec_create_t));
 xvid_dec_create.version = XVID_VERSION;
 /* Width and Height of input frames */
 xvid_dec_create.width = m_width ;
 xvid_dec_create.height = m_height ;
 ret = xvid_decore(NULL, XVID_DEC_CREATE, &xvid_dec_create, NULL) ;
 m_dec_handle = xvid_dec_create.handle;
 return true;
}

void CXvidDec::Decode(unsigned char * xvid, int xvid_len) {
 int ret = 0;
 ret = dec_core(xvid, m_image, xvid_len);
 if (ret > 0)
  m_dec_caller->PostDecHandler(m_image, ret) ;  
 }

 /* raw xvid_encode procedure  */
int CXvidDec::dec_core(unsigned char *bitstream,unsigned char *image, int bs_size)
{
 int ret;
 xvid_dec_frame_t xvid_dec_frame;
 /* Reset all structures */
 memset(&xvid_dec_frame, 0, sizeof(xvid_dec_frame_t));
 
 /* Set version */
 xvid_dec_frame.version = XVID_VERSION;
 //xvid_dec_stats->version = XVID_VERSION;
 
 /* No general flags to set */
 xvid_dec_frame.general          = 0;
 
 /* Input stream */
 xvid_dec_frame.bitstream        = bitstream;
 xvid_dec_frame.length           = bs_size;
 
 /* Output frame structure */
 xvid_dec_frame.output.plane[0]  = image;
 xvid_dec_frame.output.stride[0] = m_width*3;
 xvid_dec_frame.output.csp = XVID_CSP_BGR;

 ret = xvid_decore(m_dec_handle, XVID_DEC_DECODE, &xvid_dec_frame, NULL);
 return(ret);   
}

 

大家关注到这里编解码器有两个虚基类：CXvidDecHandler和CXvidEncHandler，使用的时候从这两个类派生，然后重载它即可。注意，这里是为了配合摄像头使用所以是直接对BGR24格式的数据进行编解码，如果对yuv420原始数据进行编解码，需要略微调整一下代码。

 

在这里我列一下使用流程：

（1）重载虚基类：

class CCapSvrDlg : public CDialog, 
       public CXvidEncHandler,  // xvid encode handler
       public CXvidDecHandler   // xvid decode handler
{ ...

 

（2）重载纯虚函数：

public: // override the CXvidEncHandler
 void PostEncHandler(unsigned char * xvid, int key, int xvid_len) ;
public:
 void PostDecHandler(unsigned char * image, int used_bytes) ;

这里的PostEncHandler和PostDecHandler分别代表编码或者解码完毕后的数据处理。

比如：调用编码，xvid编码完毕后，会自动调用这里重载的PostEncHandler，这里的xvid就是编码后的视频数据，xvid_len就是视频数据的长度，这个key就是标明当前编码是否为关键帧。

解码也是一样，不在赘述。

 

（3）定义编解码器指针：

CXvidEnc *  m_vdo_enc ;
CXvidDec *  m_vdo_dec ;

 

（4）在OnInitDialog中初始化：

 m_vdo_enc = new CXvidEnc() ;
 m_vdo_enc->AttachCaller(320, 240, this) ;
 m_vdo_enc->Open() ;

 

 m_vdo_dec = new CXvidDec() ;
 m_vdo_dec->AttachCaller(320, 240, this) ;
 m_vdo_dec->Open() ;

 

（5）编解码操作：

编码：

m_vdo_enc->Encode(pBuffer) ; // 这里pBuffer是BGR24的320x240的数据

编码如果成功，就会自动调用PostEncHandler函数，就可以得到编码后的结果

 

解码：

m_vdo_dec->Decode(xvid, xvid_len) ; // 传入的存有xvid数据的buffer和长度

解码成功后，会自动调用PostDecHandler，注意对于流媒体数据而言，在这个函数中还有一个形参是标明本次解码用掉了多少个字节的xvid缓冲区的数据，便于下一帧解码的时候调整缓冲区指针

 

（6）OnDestroy函数中，关闭编解码器

 m_vdo_enc->Close() ;
 m_vdo_dec->Close() ;
 delete m_vdo_dec ;
 delete m_vdo_enc ;

 

这些就是全部的xvid静态库的c++封装了，是不是特简单？只要编译一下xvid-core1.1.2即可。

链接的时候，需要libxvidcore.lib。

注意，debug版的需要debug版的libxvidcore.lib，release版的需要release版的xvidcore库。

3

北京理工大学 20981班 陈罡

xvid从上次开始就已经深深吸引住我的视线，上一篇已经讲解了vs2005下面编译它的方法，很多朋友会问，这个xvid-core编译完毕后，如何使用呢？我就写了一个解码的程序（vs2005下编译通过），感兴趣的朋友可以看附件。下面的是一个在vs2005下面运行的效果图，加入了非常简单的双缓冲技术，感兴趣的朋友可以下载它的源代码包看看。

有几个的设置需要注意的地方：

(1)vs2005的additional include directories里面需要加入xvidcore-1.1.2/src这个目录，这样编译器才会找到#include "xvid.h"

(2)在additional lib directories里面加入xvidcore-1.1.2/bin目录，然后在additional dependicies里面加入libxvidcore.lib这样，就可以把xvid静态的链接到你的程序里面了。

(3)具体的解码过程十分简单，读入mpeg4数据，然后解一帧出来，然后显示，然后解下一帧。这个过程是循环往复的，直到到达文件末尾。而且从代码上看起来，到达文件末尾后，似乎解码器里面还有没有显示完的图像，所以又一个循环，去读取一下，就是后面的flush decoder里面的内容了。这也难怪，mpeg4本来就是那种预测型的视频编码，每一帧都是根据前一帧计算得出的，所以数据传入完了，还能继续预测出几帧的图像也是很正常的。

很多朋友会问，你的那个test.mp4是怎么生成的，其实很简单，从网上下载一个yuv测试序列，注意必须是qcif的（176x144）的，然后进入xvidcore-1.1.2/build/win32/bin里面，找到xvid_encraw程序，然后运行它具体的命令行使用方式如下：

xvid_encraw -type 0 -i xxxxxx.yuv -w 176 -h 144 -o test.mp4

这时候会输出一大堆编码时候帧的信息。一会儿功夫就编码好了，注意这里是test.mp4，我们只需要把编码好的文件保存程test.mp4，然后把它放到与这个XvidDecTest.exe相同的目录下面，运行demo程序，就可以看到结果了。偶做了简单的双缓冲，其实还是太笨，而且也懒得直接显示yuv420的解码结果（yuv420转rgb的函数已经写好了），这个东西权当作练手的一个方法了。下次要开始像pocket pc上面移植了。

祝大家晚安。