由于视频开发的需求，封装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