xvid 数据编码和解码

由于视频开发的需求，封装xvid c调用接口，使之优雅易用
我已经对pc camera视频流(RGB)进行尝试，编码之后传输到远程主机进行解码回放，效果不错
具体的xvid的参数可以进一步优化，这里只是提供简单的范例
1. xvid 解码

 1 
 2  /*
 3      encode.cpp
 4      xvid 编码YUV数据，为进一步传输提供准备
 5 
 6  */
 7  #ifndef _XVID_ENCODE_H
 8  #define  _XVID_ENCODE_H
 9 
10  #include  < xvid.h >
11 
12  struct  DecodeInfo{
13      unsigned  short     width;
14      unsigned  short   height;        
15       void  ( * after_decode)( void   *  data,unsigned  int  size, int  width, int  height, void *  user);
16       void   *  user;
17  };
18 
19 
20  class  Xvid_Decoder{
21      
22  public :
23      Xvid_Decoder(){ 
24      }
25       bool             Open();
26       void             Close();
27      DecodeInfo  &     GetDecodeInfo(){     return  _dec_info;}
28       void             decode( void   * data,unsigned  int  size);
29       static      void     xvid_global_init();
30      xvid_dec_create_t &     GetHandle(){     return  _xvid_dec_create;}
31  private :
32       int                 xvid_dec(unsigned  char   * bitstream, int  bs_size,unsigned  char   * image);
33  private :
34      DecodeInfo    _dec_info;
35       void *         _dec_handle;
36       char          _image[ 1024 * 768 * 3 ];
37      xvid_dec_create_t _xvid_dec_create;    
38  };
39 
40  #endif
41 

 

 

 1 
 2  /*
 3      encode.cpp
 4      xvid 编码YUV数据，为进一步传输提供准备
 5 
 6  */
 7  #include  " xvid_dec.h "
 8  #include  < windows.h >
 9 
10  //
11 
12 
13  void  Xvid_Decoder::Close(){
14       int  xerr;    
15       /*  Destroy the encoder instance  */
16      xerr  =  xvid_decore(_dec_handle, XVID_ENC_DESTROY, NULL, NULL);    
17  }
18 
19  void  Xvid_Decoder::xvid_global_init(){
20       /* ------------------------------------------------------------------------
21       * XviD core initialization
22       *---------------------------------------------------------------------- */
23      xvid_gbl_init_t xvid_gbl_init;
24      memset( & xvid_gbl_init,  0 ,  sizeof (xvid_gbl_init));
25      xvid_gbl_init.version  =  XVID_VERSION;
26      xvid_gbl_init.cpu_flags  =  XVID_CPU_FORCE;
27       /*  Initialize XviD core -- Should be done once per __process__  */
28      xvid_global(NULL, XVID_GBL_INIT,  & xvid_gbl_init, NULL);
29  }
30 
31  bool  Xvid_Decoder::Open(){
32       int  ret;    
33      
34       /* ------------------------------------------------------------------------
35       * XviD encoder initialization
36       *---------------------------------------------------------------------- */
37       int  width,height;
38      width  =  _xvid_dec_create.width ;
39      height  =  _xvid_dec_create.height;
40      memset( & _xvid_dec_create,  0 ,  sizeof (xvid_dec_create_t));
41      _xvid_dec_create.version  =  XVID_VERSION;
42 
43       /*  Width and Height of input frames  */
44      _xvid_dec_create.width  =  width;
45      _xvid_dec_create.height  =  height;
46 
47      ret  =  xvid_decore(NULL, XVID_DEC_CREATE,  & _xvid_dec_create, NULL);
48      _dec_handle  =  _xvid_dec_create.handle;
49       return   true ;
50  }
51 
52  void  Xvid_Decoder::decode( void   *  data,unsigned  int  size){
53       int  ret;
54      ret  =  xvid_dec((unsigned  char * )data,( int )size,(unsigned  char   * )_image);    
55       if  (ret  > 0 )
56          _dec_info.after_decode(_image,(unsigned  int )ret,( int )_xvid_dec_create.width,( int )_xvid_dec_create.height,_dec_info.user);
57  }
58 
59  /*
60  raw xvid_encode procedure
61  */
62  int     Xvid_Decoder::xvid_dec(unsigned  char   * bitstream, int  bs_size,unsigned  char   * image)
63  {
64       int  ret;
65      xvid_dec_frame_t xvid_dec_frame;
66 
67       /*  Reset all structures  */
68      memset( & xvid_dec_frame,  0 ,  sizeof (xvid_dec_frame_t));
69       /*  Set version  */
70      xvid_dec_frame.version  =  XVID_VERSION;
71  //     xvid_dec_stats->version = XVID_VERSION;
72 
73       /*  No general flags to set  */
74      xvid_dec_frame.general           =   0 ;
75 
76       /*  Input stream  */
77      xvid_dec_frame.bitstream         =  bitstream;
78      xvid_dec_frame.length            =  bs_size;
79 
80       /*  Output frame structure  */
81      xvid_dec_frame.output.plane[ 0 ]   =  image;
82      xvid_dec_frame.output.stride[ 0 ]  =  _xvid_dec_create.width   * 3 ;
83      xvid_dec_frame.output.csp  =  XVID_CSP_BGR;
84 
85      ret  =  xvid_decore(_dec_handle, XVID_DEC_DECODE,  & xvid_dec_frame, NULL);
86       return (ret);    
87  }
88 
89 
90 

2. xvid 编码

 1 
 2  /*
 3      encode.cpp
 4      xvid 编码YUV数据，为进一步传输提供准备
 5 
 6  */
 7  #ifndef _XVID_ENCODE_H
 8  #define  _XVID_ENCODE_H
 9 
10  #include  < xvid.h >
11  #include  < nv.h >
12 
13 
14 
15  struct  EncodeInfo{
16      unsigned  short     width;
17      unsigned  short   height;        
18       void  ( * after_encode)( void   *  data,unsigned  int  size, void *  user);
19       void   *  user;
20  };
21 
22  class  Xvid_Encoder: public  NVObject{
23  public :
24      Xvid_Encoder(){ _closed  =   true ;
25      }
26       bool             Open();
27       void             Close();
28      EncodeInfo  &     GetEncodeInfo(){     return  _enc_info;}
29       void             encode( void   * data,unsigned  int  size);
30       static      void     xvid_global_init();
31       int                 xvid_enc(unsigned  char   * image,unsigned  char   * bitstream);
32  private :
33      EncodeInfo    _enc_info;
34       void *         _enc_handle;
35       char          _bitstream[ 1024 * 100 ];
36       bool         _closed;
37      
38 
39  };
40 
41  #endif
42 

  1 
  2  /*
  3      encode.cpp
  4      xvid 编码YUV数据，为进一步传输提供准备
  5 
  6  */
  7  #include  " encode.h "
  8  #include  < windows.h >
  9 
 10 
 11  static   const   int  motion_presets[]  =  {
 12       /*  quality 0  */
 13       0 ,
 14          
 15           /*  quality 1  */
 16          XVID_ME_ADVANCEDDIAMOND16,
 17          
 18           /*  quality 2  */
 19          XVID_ME_ADVANCEDDIAMOND16  |  XVID_ME_HALFPELREFINE16,
 20          
 21           /*  quality 3  */
 22          XVID_ME_ADVANCEDDIAMOND16  |  XVID_ME_HALFPELREFINE16  |
 23          XVID_ME_ADVANCEDDIAMOND8  |  XVID_ME_HALFPELREFINE8,
 24          
 25           /*  quality 4  */
 26          XVID_ME_ADVANCEDDIAMOND16  |  XVID_ME_HALFPELREFINE16  |
 27          XVID_ME_ADVANCEDDIAMOND8  |  XVID_ME_HALFPELREFINE8  |
 28          XVID_ME_CHROMA_PVOP  |  XVID_ME_CHROMA_BVOP,
 29          
 30           /*  quality 5  */
 31          XVID_ME_ADVANCEDDIAMOND16  |  XVID_ME_HALFPELREFINE16  |
 32          XVID_ME_ADVANCEDDIAMOND8  |  XVID_ME_HALFPELREFINE8  |
 33          XVID_ME_CHROMA_PVOP  |  XVID_ME_CHROMA_BVOP,
 34          
 35           /*  quality 6  */
 36          XVID_ME_ADVANCEDDIAMOND16  |  XVID_ME_HALFPELREFINE16  |  XVID_ME_EXTSEARCH16  |
 37          XVID_ME_ADVANCEDDIAMOND8  |  XVID_ME_HALFPELREFINE8  |  XVID_ME_EXTSEARCH8  |
 38          XVID_ME_CHROMA_PVOP  |  XVID_ME_CHROMA_BVOP,
 39          
 40  };
 41  #define  ME_ELEMENTS (sizeof(motion_presets)/sizeof(motion_presets[0]))
 42 
 43  static   const   int  vop_presets[]  =  {
 44       /*  quality 0  */
 45       0 ,
 46          
 47       /*  quality 1  */
 48       0 ,
 49 
 50       /*  quality 2  */
 51      XVID_VOP_HALFPEL,
 52 
 53       /*  quality 3  */
 54      XVID_VOP_HALFPEL  |  XVID_VOP_INTER4V,
 55 
 56       /*  quality 4  */
 57      XVID_VOP_HALFPEL  |  XVID_VOP_INTER4V,
 58 
 59       /*  quality 5  */
 60      XVID_VOP_HALFPEL  |  XVID_VOP_INTER4V  |
 61      XVID_VOP_TRELLISQUANT,
 62 
 63       /*  quality 6  */
 64      XVID_VOP_HALFPEL  |  XVID_VOP_INTER4V  |
 65      XVID_VOP_TRELLISQUANT  |  XVID_VOP_HQACPRED,
 66 
 67  };
 68  #define  VOP_ELEMENTS (sizeof(vop_presets)/sizeof(vop_presets[0]))
 69 
 70  //
 71  #define  MAX_ZONES   64
 72 
 73  /*  Maximum number of frames to encode  */
 74  #define  ABS_MAXFRAMENR 9999
 75 
 76  static   int  ARG_STATS  =   0 ;
 77  static   int  ARG_DUMP  =   0 ;
 78  static   int  ARG_LUMIMASKING  =   0 ;
 79  static   int  ARG_BITRATE  =   0 ;
 80  static   int  ARG_SINGLE  =   0 ;
 81  static   char   * ARG_PASS1  =   0 ;
 82  static   char   * ARG_PASS2  =   0 ;
 83  static   int  ARG_QUALITY  =  ME_ELEMENTS  -   1 ;
 84  static   float  ARG_FRAMERATE  =   25.00f ;
 85  static   int  ARG_MAXFRAMENR  =  ABS_MAXFRAMENR;
 86  static   int  ARG_MAXKEYINTERVAL  =   0 ;
 87  static   char   * ARG_INPUTFILE  =  NULL;
 88  static   int  ARG_INPUTTYPE  =   0 ;
 89  static   int  ARG_SAVEMPEGSTREAM  =   0 ;
 90  static   int  ARG_SAVEINDIVIDUAL  =   0 ;
 91  static   char   * ARG_OUTPUTFILE  =  NULL;
 92 
 93  static   int  ARG_BQRATIO  =   150 ;
 94  static   int  ARG_BQOFFSET  =   100 ;
 95  static   int  ARG_MAXBFRAMES  =   0 ;
 96  static   int  ARG_PACKED  =   0 ;
 97 
 98  static   int  ARG_VOPDEBUG  =   0 ;
 99  static   int  ARG_GMC  =   0 ;
100  static   int  ARG_INTERLACING  =   0 ;
101  static   int  ARG_QPEL  =   0 ;
102  static   int  ARG_CLOSED_GOP  =   0 ;
103 
104  #ifndef READ_PNM
105  #define  IMAGE_SIZE(x,y) ((x)*(y)*3/2)
106  #else
107  #define  IMAGE_SIZE(x,y) ((x)*(y)*3)
108  #endif
109 
110  #define  MAX(A,B) ( ((A)>(B)) ? (A) : (B) )
111  #define  SMALL_EPS (1e-10)
112 
113  #define  SWAP(a) ( (((a)&0x000000ff)<<24) | (((a)&0x0000ff00)<<8) | \
114  (((a) & 0x00ff0000 ) >> 8 )   |  (((a) & 0xff000000 ) >> 24 ) )
115 
116 
117  //
118 
119 
120  void  Xvid_Encoder::Close(){
121       int  xerr;    
122      NVMutexLock  lock (_lock);
123 
124      _closed  =   true ;
125       /*  Destroy the encoder instance  */
126      xerr  =  xvid_encore(_enc_handle, XVID_ENC_DESTROY, NULL, NULL);    
127 
128  }
129 
130  void  Xvid_Encoder::xvid_global_init(){
131       /* ------------------------------------------------------------------------
132       * XviD core initialization
133       *---------------------------------------------------------------------- */
134      xvid_gbl_init_t xvid_gbl_init;
135      memset( & xvid_gbl_init,  0 ,  sizeof (xvid_gbl_init));
136      xvid_gbl_init.version  =  XVID_VERSION;
137      xvid_gbl_init.cpu_flags  =  XVID_CPU_FORCE;
138       /*  Initialize XviD core -- Should be done once per __process__  */
139      xvid_global(NULL, XVID_GBL_INIT,  & xvid_gbl_init, NULL);
140  }
141 
142  bool  Xvid_Encoder::Open(){
143       int  xerr;        
144      xvid_enc_create_t xvid_enc_create;
145      _closed  =   false ;
146       /* ------------------------------------------------------------------------
147       * XviD encoder initialization
148       *---------------------------------------------------------------------- */
149      memset( & xvid_enc_create,  0 ,  sizeof (xvid_enc_create));
150      xvid_enc_create.version  =  XVID_VERSION;
151 
152       /*  Width and Height of input frames  */
153      xvid_enc_create.width  =  GetEncodeInfo().width;
154      xvid_enc_create.height  =  GetEncodeInfo().height;
155      xvid_enc_create.profile  =  XVID_PROFILE_AS_L4;
156 
157       /*  init plugins   */
158       /*
159      xvid_enc_create.zones = ZONES;
160      xvid_enc_create.num_zones = NUM_ZONES;
161 
162      xvid_enc_create.plugins = plugins;
163      xvid_enc_create.num_plugins = 0;
164       */
165 
166 
167       /*  No fancy thread tests  */
168      xvid_enc_create.num_threads  =   0 ;
169 
170       /*  Frame rate - Do some quick float fps = fincr/fbase hack  */     
171      xvid_enc_create.fincr  =   1 ;
172      xvid_enc_create.fbase  =  ( int )  10 ;
173       /*  Maximum key frame interval  */
174      xvid_enc_create.max_key_interval  =  ( int ) - 1 ;     // --default 10s
175       /*  Bframes settings  */
176      xvid_enc_create.max_bframes  =  ARG_MAXBFRAMES;
177      xvid_enc_create.bquant_ratio  =  ARG_BQRATIO;
178      xvid_enc_create.bquant_offset  =  ARG_BQOFFSET;
179 
180       /*  Dropping ratio frame -- we don't need that  */
181      xvid_enc_create.frame_drop_ratio  =   0 ;
182       /*  Global encoder options  */
183      xvid_enc_create.global  =   0 ;
184 
185       if  (ARG_PACKED)
186          xvid_enc_create.global  |=  XVID_GLOBAL_PACKED;
187 
188       if  (ARG_CLOSED_GOP)
189          xvid_enc_create.global  |=  XVID_GLOBAL_CLOSED_GOP;
190 
191       if  (ARG_STATS)
192          xvid_enc_create.global  |=  XVID_GLOBAL_EXTRASTATS_ENABLE;
193 
194       /*  I use a small value here, since will not encode whole movies, but short clips  */
195      xerr  =  xvid_encore(NULL, XVID_ENC_CREATE,  & xvid_enc_create, NULL);
196      _enc_handle  =  xvid_enc_create.handle;
197       return   true ;
198  }
199 
200  void  Xvid_Encoder::encode( void   *  data,unsigned  int  size){
201       int  ret;    
202      _lock.Lock();
203       if ( _closed ){
204          _lock.Unlock();
205           return ;
206      }
207      ret  =  xvid_enc((unsigned  char * )data,(unsigned  char   * )_bitstream);        
208      _lock.Unlock();
209       if  (ret  > 0 )
210          _enc_info.after_encode(_bitstream,(unsigned  int )ret,_enc_info.user);
211      
212  }
213 
214  /*
215  raw xvid_encode procedure
216  */
217  int  Xvid_Encoder::xvid_enc(unsigned  char   * image,unsigned  char   * bitstream)
218  {
219       int  ret;    
220      xvid_enc_frame_t xvid_enc_frame;
221      xvid_enc_stats_t xvid_enc_stats;
222      
223       /*  Version for the frame and the stats  */
224      memset( & xvid_enc_frame,  0 ,  sizeof (xvid_enc_frame));
225      xvid_enc_frame.version  =  XVID_VERSION;
226      
227      memset( & xvid_enc_stats,  0 ,  sizeof (xvid_enc_stats));
228      xvid_enc_stats.version  =  XVID_VERSION;
229      
230       /*  Bind output buffer  */
231      xvid_enc_frame.bitstream  =  bitstream;
232      xvid_enc_frame.length  =   - 1 ;
233      
234       /*  Initialize input image fields  */
235      xvid_enc_frame.input.plane[ 0 ]  =  image;
236      xvid_enc_frame.input.csp  =  XVID_CSP_BGR;
237      xvid_enc_frame.input.stride[ 0 ]  =  _enc_info.width * 3 ;
238 
239      
240       /*  Set up core's general features  */
241      xvid_enc_frame.vol_flags  =   0 ;
242      
243       /*  Set up core's general features  */
244      xvid_enc_frame.vop_flags  =  vop_presets[ARG_QUALITY - 2 ];
245      
246       /*  Frame type -- let core decide for us  */
247      xvid_enc_frame.type  =  XVID_TYPE_AUTO;
248      
249       /*  Force the right quantizer -- It is internally managed by RC plugins  */
250      xvid_enc_frame.quant  =   0 ;
251      
252       /*  Set up motion estimation flags  */
253      xvid_enc_frame.motion  =  motion_presets[ARG_QUALITY - 2 ];
254      
255       /*  We don't use special matrices  */
256      xvid_enc_frame.quant_intra_matrix  =  NULL;
257      xvid_enc_frame.quant_inter_matrix  =  NULL;
258      
259       /*  Encode the frame  */
260      ret  =  xvid_encore(_enc_handle, XVID_ENC_ENCODE,  & xvid_enc_frame,NULL);
261       //     &xvid_enc_stats);
262       // --判别是否是关键帧
263       // *key = (xvid_enc_frame.out_flags & XVID_KEYFRAME);
264       // *stats_type = xvid_enc_stats.type;
265       // *stats_quant = xvid_enc_stats.quant;
266       // *stats_length = xvid_enc_stats.length;
267       // sse[0] = xvid_enc_stats.sse_y;
268       // sse[1] = xvid_enc_stats.sse_u;
269       // sse[2] = xvid_enc_stats.sse_v;
270      
271       return  (ret);
272  }
273 
274 
275