Annotation of /trunk/xvidcore/examples/xvid_encraw.c

Revision 1676 - (view) (download)

1 :	edgomez	558	/*****************************************************************************
2 :	chl	376	*
3 :	edgomez	558	* XVID MPEG-4 VIDEO CODEC
4 :			* - Console based test application -
5 :	chl	376	*
6 :	edgomez	1382	* Copyright(C) 2002-2003 Christoph Lampert <gruel@web.de>
7 :			* 2002-2003 Edouard Gomez <ed.gomez@free.fr>
8 :			* 2003 Peter Ross <pross@xvid.org>
9 :	chl	376	*
10 :	edgomez	558	* This program is free software; you can redistribute it and/or modify
11 :			* it under the terms of the GNU General Public License as published by
12 :			* the Free Software Foundation; either version 2 of the License, or
13 :			* (at your option) any later version.
14 :	chl	376	*
15 :	edgomez	558	* This program is distributed in the hope that it will be useful,
16 :			* but WITHOUT ANY WARRANTY; without even the implied warranty of
17 :			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 :			* GNU General Public License for more details.
19 :	chl	376	*
20 :	edgomez	558	* You should have received a copy of the GNU General Public License
21 :			* along with this program; if not, write to the Free Software
22 :			* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 :			*
24 :	Isibaar	1676	* $Id: xvid_encraw.c,v 1.23 2006-01-17 19:06:25 Isibaar Exp $
25 :	edgomez	558	*
26 :			****************************************************************************/
27 :	chl	376
28 :	edgomez	558	/*****************************************************************************
29 :			* Application notes :
30 :	chl	376	*
31 :	edgomez	1382	* A sequence of raw YUV I420 pics or YUV I420 PGM file format is encoded
32 :			* The speed is measured and frames' PSNR are taken from core.
33 :	chl	376	*
34 :			* The program is plain C and needs no libraries except for libxvidcore,
35 :	edgomez	558	* and maths-lib.
36 :	edgomez	1382	*
37 :			* Use ./xvid_encraw -help for a list of options
38 :	chl	376	*
39 :			************************************************************************/
40 :
41 :			#include <stdio.h>
42 :			#include <stdlib.h>
43 :	edgomez	566	#include <string.h>
44 :	edgomez	558	#include <math.h>
45 :	edgomez	851	#ifndef WIN32
46 :	edgomez	558	#include <sys/time.h>
47 :			#else
48 :	Isibaar	1645	#include <windows.h>
49 :			#include <vfw.h>
50 :	edgomez	558	#include <time.h>
51 :	Isibaar	1645	#define XVID_AVI_INPUT
52 :	edgomez	558	#endif
53 :	chl	376
54 :	edgomez	558	#include "xvid.h"
55 :	chl	376
56 :	edgomez	1382	#undef READ_PNM
57 :
58 :	edgomez	558	/*****************************************************************************
59 :			* Quality presets
60 :			****************************************************************************/
61 :	chl	376
62 :	edgomez	1382	static const int motion_presets[] = {
63 :			/* quality 0 */
64 :			0,
65 :
66 :			/* quality 1 */
67 :			XVID_ME_ADVANCEDDIAMOND16,
68 :
69 :			/* quality 2 */
70 :			XVID_ME_ADVANCEDDIAMOND16 \| XVID_ME_HALFPELREFINE16,
71 :
72 :			/* quality 3 */
73 :			XVID_ME_ADVANCEDDIAMOND16 \| XVID_ME_HALFPELREFINE16 \|
74 :			XVID_ME_ADVANCEDDIAMOND8 \| XVID_ME_HALFPELREFINE8,
75 :
76 :			/* quality 4 */
77 :			XVID_ME_ADVANCEDDIAMOND16 \| XVID_ME_HALFPELREFINE16 \|
78 :			XVID_ME_ADVANCEDDIAMOND8 \| XVID_ME_HALFPELREFINE8 \|
79 :			XVID_ME_CHROMA_PVOP \| XVID_ME_CHROMA_BVOP,
80 :
81 :			/* quality 5 */
82 :			XVID_ME_ADVANCEDDIAMOND16 \| XVID_ME_HALFPELREFINE16 \|
83 :			XVID_ME_ADVANCEDDIAMOND8 \| XVID_ME_HALFPELREFINE8 \|
84 :			XVID_ME_CHROMA_PVOP \| XVID_ME_CHROMA_BVOP,
85 :
86 :			/* quality 6 */
87 :			XVID_ME_ADVANCEDDIAMOND16 \| XVID_ME_HALFPELREFINE16 \| XVID_ME_EXTSEARCH16 \|
88 :			XVID_ME_ADVANCEDDIAMOND8 \| XVID_ME_HALFPELREFINE8 \| XVID_ME_EXTSEARCH8 \|
89 :			XVID_ME_CHROMA_PVOP \| XVID_ME_CHROMA_BVOP,
90 :
91 :	edgomez	558	};
92 :	edgomez	1382	#define ME_ELEMENTS (sizeof(motion_presets)/sizeof(motion_presets[0]))
93 :	edgomez	558
94 :	edgomez	1382	static const int vop_presets[] = {
95 :			/* quality 0 */
96 :			0,
97 :
98 :			/* quality 1 */
99 :			0,
100 :
101 :			/* quality 2 */
102 :			XVID_VOP_HALFPEL,
103 :
104 :			/* quality 3 */
105 :			XVID_VOP_HALFPEL \| XVID_VOP_INTER4V,
106 :
107 :			/* quality 4 */
108 :			XVID_VOP_HALFPEL \| XVID_VOP_INTER4V,
109 :
110 :			/* quality 5 */
111 :			XVID_VOP_HALFPEL \| XVID_VOP_INTER4V \|
112 :			XVID_VOP_TRELLISQUANT,
113 :
114 :			/* quality 6 */
115 :			XVID_VOP_HALFPEL \| XVID_VOP_INTER4V \|
116 :			XVID_VOP_TRELLISQUANT \| XVID_VOP_HQACPRED,
117 :
118 :	edgomez	558	};
119 :	edgomez	1382	#define VOP_ELEMENTS (sizeof(vop_presets)/sizeof(vop_presets[0]))
120 :	chl	376
121 :	edgomez	558	/*****************************************************************************
122 :			* Command line global variables
123 :			****************************************************************************/
124 :	chl	376
125 :	edgomez	1382	#define MAX_ZONES 64
126 :
127 :			static xvid_enc_zone_t ZONES[MAX_ZONES];
128 :			static int NUM_ZONES = 0;
129 :
130 :	edgomez	558	/* Maximum number of frames to encode */
131 :	Isibaar	1676	#define ABS_MAXFRAMENR -1 /* no limit */
132 :	chl	376
133 :	edgomez	1382	static int ARG_STATS = 0;
134 :			static int ARG_DUMP = 0;
135 :			static int ARG_LUMIMASKING = 0;
136 :			static int ARG_BITRATE = 0;
137 :			static int ARG_SINGLE = 0;
138 :			static char *ARG_PASS1 = 0;
139 :			static char *ARG_PASS2 = 0;
140 :			static int ARG_QUALITY = ME_ELEMENTS - 1;
141 :	edgomez	558	static float ARG_FRAMERATE = 25.00f;
142 :	edgomez	1382	static int ARG_MAXFRAMENR = ABS_MAXFRAMENR;
143 :			static int ARG_MAXKEYINTERVAL = 0;
144 :	edgomez	558	static char *ARG_INPUTFILE = NULL;
145 :	edgomez	1382	static int ARG_INPUTTYPE = 0;
146 :			static int ARG_SAVEMPEGSTREAM = 0;
147 :			static int ARG_SAVEINDIVIDUAL = 0;
148 :	edgomez	558	static char *ARG_OUTPUTFILE = NULL;
149 :	edgomez	1382	static int XDIM = 0;
150 :			static int YDIM = 0;
151 :			static int ARG_BQRATIO = 150;
152 :			static int ARG_BQOFFSET = 100;
153 :			static int ARG_MAXBFRAMES = 0;
154 :			static int ARG_PACKED = 0;
155 :			static int ARG_DEBUG = 0;
156 :			static int ARG_VOPDEBUG = 0;
157 :	Skal	1622	static int ARG_GREYSCALE = 0;
158 :	Isibaar	1645	static int ARG_QTYPE = 0;
159 :			static int ARG_QMATRIX = 0;
160 :	edgomez	1382	static int ARG_GMC = 0;
161 :	chl	1559	static int ARG_INTERLACING = 0;
162 :	edgomez	1382	static int ARG_QPEL = 0;
163 :	Isibaar	1645	static int ARG_TURBO = 0;
164 :	chl	1624	static int ARG_VHQMODE = 0;
165 :	Isibaar	1645	static int ARG_BVHQ = 0;
166 :	edgomez	1382	static int ARG_CLOSED_GOP = 0;
167 :
168 :			#ifndef READ_PNM
169 :	edgomez	558	#define IMAGE_SIZE(x,y) ((x)(y)3/2)
170 :	edgomez	1382	#else
171 :			#define IMAGE_SIZE(x,y) ((x)(y)3)
172 :			#endif
173 :	chl	376
174 :	edgomez	558	#define MAX(A,B) ( ((A)>(B)) ? (A) : (B) )
175 :	edgomez	1382	#define SMALL_EPS (1e-10)
176 :	chl	376
177 :	edgomez	558	#define SWAP(a) ( (((a)&0x000000ff)<<24) \| (((a)&0x0000ff00)<<8) \| \
178 :			(((a)&0x00ff0000)>>8) \| (((a)&0xff000000)>>24) )
179 :	chl	376
180 :	edgomez	558	/****************************************************************************
181 :			* Nasty global vars ;-)
182 :			***************************************************************************/
183 :	chl	376
184 :	edgomez	1382	static int i;
185 :	chl	376
186 :	edgomez	558	/* the path where to save output */
187 :			static char filepath[256] = "./";
188 :	chl	376
189 :	edgomez	558	/* Internal structures (handles) for encoding and decoding */
190 :			static void *enc_handle = NULL;
191 :
192 :	Isibaar	1645	static unsigned char qmatrix_intra[64];
193 :			static unsigned char qmatrix_inter[64];
194 :
195 :			#ifdef XVID_AVI_INPUT
196 :			static PAVISTREAM avi_stream = NULL;
197 :			#endif
198 :
199 :	edgomez	558	/*****************************************************************************
200 :			* Local prototypes
201 :			****************************************************************************/
202 :
203 :			/* Prints program usage message */
204 :			static void usage();
205 :
206 :			/* Statistical functions */
207 :			static double msecond();
208 :
209 :			/* PGM related functions */
210 :	edgomez	1382	#ifndef READ_PNM
211 :			static int read_pgmheader(FILE * handle);
212 :			static int read_pgmdata(FILE * handle,
213 :			unsigned char *image);
214 :			#else
215 :			static int read_pnmheader(FILE * handle);
216 :			static int read_pnmdata(FILE * handle,
217 :			unsigned char *image);
218 :			#endif
219 :			static int read_yuvdata(FILE * handle,
220 :			unsigned char *image);
221 :	edgomez	558
222 :			/* Encoder related functions */
223 :			static int enc_init(int use_assembler);
224 :			static int enc_stop();
225 :	edgomez	1382	static int enc_main(unsigned char *image,
226 :			unsigned char *bitstream,
227 :			int *key,
228 :			int *stats_type,
229 :			int *stats_quant,
230 :			int *stats_length,
231 :			int stats[3]);
232 :	edgomez	558
233 :			/*****************************************************************************
234 :			* Main function
235 :			****************************************************************************/
236 :
237 :	edgomez	1382	int
238 :			main(int argc,
239 :			char *argv[])
240 :	edgomez	558	{
241 :
242 :			unsigned char *mp4_buffer = NULL;
243 :			unsigned char *in_buffer = NULL;
244 :			unsigned char *out_buffer = NULL;
245 :
246 :			double enctime;
247 :	edgomez	1382	double totalenctime = 0.;
248 :			float totalPSNR[3] = {0., 0., 0.};
249 :
250 :			int totalsize;
251 :			int result;
252 :			int m4v_size;
253 :			int key;
254 :			int stats_type;
255 :			int stats_quant;
256 :			int stats_length;
257 :	Isibaar	1627	int use_assembler = 1;
258 :	edgomez	1382
259 :			int input_num;
260 :			int output_num;
261 :
262 :	edgomez	558	char filename[256];
263 :	edgomez	1382
264 :	edgomez	558	FILE *in_file = stdin;
265 :			FILE *out_file = NULL;
266 :
267 :	edgomez	741	printf("xvid_encraw - raw mpeg4 bitstream encoder ");
268 :	edgomez	851	printf("written by Christoph Lampert 2002-2003\n\n");
269 :	edgomez	558
270 :	edgomez	1382	/* Is there a dumb XviD coder ? */
271 :			if(ME_ELEMENTS != VOP_ELEMENTS) {
272 :			fprintf(stderr, "Presets' arrays should have the same number of elements -- Please fill a bug to xvid-devel@xvid.org\n");
273 :			return(-1);
274 :			}
275 :
276 :	edgomez	558	/*****************************************************************************
277 :			* Command line parsing
278 :			****************************************************************************/
279 :
280 :	edgomez	1382	for (i = 1; i < argc; i++) {
281 :
282 :			if (strcmp("-asm", argv[i]) == 0) {
283 :	edgomez	558	use_assembler = 1;
284 :	chl	1623	} else if (strcmp("-noasm", argv[i]) == 0) {
285 :			use_assembler = 0;
286 :	edgomez	1382	} else if (strcmp("-w", argv[i]) == 0 && i < argc - 1) {
287 :	edgomez	558	i++;
288 :			XDIM = atoi(argv[i]);
289 :	edgomez	1382	} else if (strcmp("-h", argv[i]) == 0 && i < argc - 1) {
290 :	edgomez	558	i++;
291 :			YDIM = atoi(argv[i]);
292 :	edgomez	1382	} else if (strcmp("-bitrate", argv[i]) == 0 && i < argc - 1) {
293 :	edgomez	558	i++;
294 :			ARG_BITRATE = atoi(argv[i]);
295 :	edgomez	1382	} else if (strcmp("-single", argv[i]) == 0) {
296 :			ARG_SINGLE = 1;
297 :			} else if (strcmp("-pass1", argv[i]) == 0 && i < argc - 1) {
298 :	edgomez	851	i++;
299 :	edgomez	1382	ARG_PASS1 = argv[i];
300 :			} else if (strcmp("-pass2", argv[i]) == 0 && i < argc - 1) {
301 :			i++;
302 :			ARG_PASS2 = argv[i];
303 :			} else if (strcmp("-max_bframes", argv[i]) == 0 && i < argc - 1) {
304 :			i++;
305 :	edgomez	851	ARG_MAXBFRAMES = atoi(argv[i]);
306 :	edgomez	1382	} else if (strcmp("-packed", argv[i]) == 0) {
307 :			ARG_PACKED = 1;
308 :			} else if (strcmp("-bquant_ratio", argv[i]) == 0 && i < argc - 1) {
309 :	edgomez	851	i++;
310 :			ARG_BQRATIO = atoi(argv[i]);
311 :	edgomez	1382	} else if (strcmp("-bquant_offset", argv[i]) == 0 && i < argc - 1) {
312 :	edgomez	851	i++;
313 :			ARG_BQOFFSET = atoi(argv[i]);
314 :	edgomez	1382
315 :			} else if ((strcmp("-zq", argv[i]) == 0 \|\| strcmp("-zw", argv[i]) == 0) && i < argc - 2) {
316 :
317 :			if (NUM_ZONES >= MAX_ZONES) {
318 :			fprintf(stderr,"warning: too many zones; zone ignored\n");
319 :			continue;
320 :			}
321 :			ZONES[NUM_ZONES].mode = strcmp("-zq", argv[i])==0 ? XVID_ZONE_QUANT : XVID_ZONE_WEIGHT;
322 :	edgomez	558	i++;
323 :	edgomez	1382	ZONES[NUM_ZONES].frame = atoi(argv[i]);
324 :			i++;
325 :			ZONES[NUM_ZONES].increment = (int)(atof(argv[i]) * 100);
326 :			ZONES[NUM_ZONES].base = 100;
327 :			NUM_ZONES++;
328 :
329 :			} else if (strcmp("-quality", argv[i]) == 0 && i < argc - 1) {
330 :			i++;
331 :	edgomez	558	ARG_QUALITY = atoi(argv[i]);
332 :	chl	1624	} else if (strcmp("-vhqmode", argv[i]) == 0 && i < argc - 1) {
333 :			i++;
334 :			ARG_VHQMODE = atoi(argv[i]);
335 :	edgomez	1382	} else if (strcmp("-framerate", argv[i]) == 0 && i < argc - 1) {
336 :	edgomez	558	i++;
337 :	edgomez	1382	ARG_FRAMERATE = (float) atof(argv[i]);
338 :			} else if (strcmp("-max_key_interval", argv[i]) == 0 && i < argc - 1) {
339 :	edgomez	558	i++;
340 :	edgomez	1382	ARG_MAXKEYINTERVAL = atoi(argv[i]);
341 :			} else if (strcmp("-i", argv[i]) == 0 && i < argc - 1) {
342 :			i++;
343 :	edgomez	558	ARG_INPUTFILE = argv[i];
344 :	edgomez	1382	} else if (strcmp("-stats", argv[i]) == 0) {
345 :			ARG_STATS = 1;
346 :			} else if (strcmp("-dump", argv[i]) == 0) {
347 :			ARG_DUMP = 1;
348 :			} else if (strcmp("-lumimasking", argv[i]) == 0) {
349 :			ARG_LUMIMASKING = 1;
350 :			} else if (strcmp("-type", argv[i]) == 0 && i < argc - 1) {
351 :	edgomez	558	i++;
352 :			ARG_INPUTTYPE = atoi(argv[i]);
353 :	edgomez	1382	} else if (strcmp("-frames", argv[i]) == 0 && i < argc - 1) {
354 :	edgomez	558	i++;
355 :	edgomez	1382	ARG_MAXFRAMENR = atoi(argv[i]);
356 :	Isibaar	1645	} else if (strcmp("-qtype", argv[i]) == 0 && i < argc - 1) {
357 :			i++;
358 :			ARG_QTYPE = atoi(argv[i]);
359 :			} else if (strcmp("-qmatrix", argv[i]) == 0 && i < argc - 1) {
360 :			FILE *fp = fopen(argv[++i], "rb");
361 :			if (fp == NULL) {
362 :			fprintf(stderr, "Error opening input file %s\n", argv[i]);
363 :			return (-1);
364 :			}
365 :			fseek(fp, 0, SEEK_END);
366 :			if (ftell(fp) != 128) {
367 :			fprintf(stderr, "Unexpected size of input file %s\n", argv[i]);
368 :			return (-1);
369 :			}
370 :
371 :			fseek(fp, 0, SEEK_SET);
372 :			fread(qmatrix_intra, 1, 64, fp);
373 :			fread(qmatrix_inter, 1, 64, fp);
374 :
375 :			ARG_QMATRIX = 1;
376 :	edgomez	1382	} else if (strcmp("-save", argv[i]) == 0) {
377 :			ARG_SAVEMPEGSTREAM = 1;
378 :			ARG_SAVEINDIVIDUAL = 1;
379 :			} else if (strcmp("-debug", argv[i]) == 0) {
380 :	edgomez	558	i++;
381 :	edgomez	1382	if (sscanf(argv[i],"0x%x", &ARG_DEBUG) \|\| sscanf(argv[i],"%d", &ARG_DEBUG)) ;
382 :			} else if (strcmp("-o", argv[i]) == 0 && i < argc - 1) {
383 :			ARG_SAVEMPEGSTREAM = 1;
384 :	edgomez	558	i++;
385 :			ARG_OUTPUTFILE = argv[i];
386 :	edgomez	1382	} else if (strcmp("-vop_debug", argv[i]) == 0) {
387 :			ARG_VOPDEBUG = 1;
388 :	Isibaar	1627	} else if (strcmp("-grey", argv[i]) == 0) {
389 :	Skal	1622	ARG_GREYSCALE = 1;
390 :	Isibaar	1645	} else if (strcmp("-bvhq", argv[i]) == 0) {
391 :			ARG_BVHQ = 1;
392 :	Isibaar	1627	} else if (strcmp("-qpel", argv[i]) == 0) {
393 :	edgomez	1382	ARG_QPEL = 1;
394 :	Isibaar	1645	} else if (strcmp("-turbo", argv[i]) == 0) {
395 :			ARG_TURBO = 1;
396 :	edgomez	1382	} else if (strcmp("-gmc", argv[i]) == 0) {
397 :			ARG_GMC = 1;
398 :	chl	1559	} else if (strcmp("-interlaced", argv[i]) == 0) {
399 :			ARG_INTERLACING = 1;
400 :	edgomez	1382	} else if (strcmp("-closed_gop", argv[i]) == 0) {
401 :			ARG_CLOSED_GOP = 1;
402 :			} else if (strcmp("-help", argv[i])) {
403 :	edgomez	558	usage();
404 :	edgomez	1382	return (0);
405 :			} else {
406 :	edgomez	558	usage();
407 :			exit(-1);
408 :			}
409 :	edgomez	1382
410 :	edgomez	558	}
411 :	edgomez	1382
412 :	edgomez	558	/*****************************************************************************
413 :			* Arguments checking
414 :			****************************************************************************/
415 :
416 :	edgomez	1382	if (XDIM <= 0 \|\| XDIM >= 4096 \|\| YDIM <= 0 \|\| YDIM >= 4096) {
417 :			fprintf(stderr,
418 :	Isibaar	1645	"Trying to retrieve width and height from input header\n");
419 :			if (!ARG_INPUTTYPE)
420 :			ARG_INPUTTYPE = 1; /* pgm */
421 :	edgomez	558	}
422 :
423 :	edgomez	1382	if (ARG_QUALITY < 0 ) {
424 :			ARG_QUALITY = 0;
425 :			} else if (ARG_QUALITY >= ME_ELEMENTS) {
426 :			ARG_QUALITY = ME_ELEMENTS - 1;
427 :	edgomez	558	}
428 :
429 :	edgomez	1382	if (ARG_FRAMERATE <= 0) {
430 :			fprintf(stderr, "Wrong Framerate %s \n", argv[5]);
431 :			return (-1);
432 :	edgomez	558	}
433 :
434 :	Isibaar	1676	if (ARG_MAXFRAMENR == 0) {
435 :	edgomez	1382	fprintf(stderr, "Wrong number of frames\n");
436 :			return (-1);
437 :	edgomez	558	}
438 :
439 :	edgomez	1382	if (ARG_INPUTFILE == NULL \|\| strcmp(ARG_INPUTFILE, "stdin") == 0) {
440 :	edgomez	558	in_file = stdin;
441 :	edgomez	1382	} else {
442 :	Isibaar	1645	#ifdef XVID_AVI_INPUT
443 :			if (strcmp(ARG_INPUTFILE+(strlen(ARG_INPUTFILE)-3), "avs")==0 \|\|
444 :			strcmp(ARG_INPUTFILE+(strlen(ARG_INPUTFILE)-3), "avi")==0 \|\|
445 :			ARG_INPUTTYPE==2)
446 :			{
447 :			AVISTREAMINFO avi_info;
448 :	Isibaar	1676	FILE *avi_fp = fopen(ARG_INPUTFILE, "rb");
449 :			if (avi_fp == NULL) {
450 :			fprintf(stderr, "Couldn't open file '%s'!\n", ARG_INPUTFILE);
451 :			return (-1);
452 :			}
453 :			fclose(avi_fp);
454 :	edgomez	558
455 :	Isibaar	1645	AVIFileInit();
456 :			if (AVIStreamOpenFromFile(&avi_stream, ARG_INPUTFILE, streamtypeVIDEO, 0, OF_READ, NULL) != AVIERR_OK) {
457 :			fprintf(stderr, "Can't open stream from file '%s'!\n", ARG_INPUTFILE);
458 :			AVIFileExit();
459 :			return (-1);
460 :			}
461 :
462 :			if(AVIStreamInfo(avi_stream, &avi_info, sizeof(AVISTREAMINFO)) != AVIERR_OK) {
463 :			fprintf(stderr, "Can't get stream info from file '%s'!\n", ARG_INPUTFILE);
464 :			AVIStreamRelease(avi_stream);
465 :			AVIFileExit();
466 :			return (-1);
467 :			}
468 :
469 :			if (avi_info.fccHandler != MAKEFOURCC('Y', 'V', '1', '2')) {
470 :			fprintf(stderr, "Unsupported input colorspace! Only YV12 is supported!\n");
471 :			AVIStreamRelease(avi_stream);
472 :			AVIFileExit();
473 :			return (-1);
474 :			}
475 :
476 :	Isibaar	1676
477 :			if (ARG_MAXFRAMENR<0)
478 :			ARG_MAXFRAMENR = avi_info.dwLength;
479 :			else
480 :			ARG_MAXFRAMENR = min(ARG_MAXFRAMENR, avi_info.dwLength);
481 :	suxen_drol	1646
482 :	Isibaar	1645	XDIM = avi_info.rcFrame.right - avi_info.rcFrame.left;
483 :			YDIM = avi_info.rcFrame.bottom - avi_info.rcFrame.top;
484 :			ARG_FRAMERATE = (float) avi_info.dwRate / (float) avi_info.dwScale;
485 :
486 :			ARG_INPUTTYPE = 2;
487 :			}
488 :			else
489 :			#endif
490 :			{
491 :			in_file = fopen(ARG_INPUTFILE, "rb");
492 :			if (in_file == NULL) {
493 :			fprintf(stderr, "Error opening input file %s\n", ARG_INPUTFILE);
494 :			return (-1);
495 :			}
496 :	edgomez	558	}
497 :			}
498 :
499 :	Isibaar	1645	if (ARG_INPUTTYPE==1) {
500 :	edgomez	1382	#ifndef READ_PNM
501 :	edgomez	558	if (read_pgmheader(in_file)) {
502 :	edgomez	1382	#else
503 :			if (read_pnmheader(in_file)) {
504 :			#endif
505 :			fprintf(stderr,
506 :			"Wrong input format, I want YUV encapsulated in PGM\n");
507 :			return (-1);
508 :	edgomez	558	}
509 :			}
510 :
511 :			/* now we know the sizes, so allocate memory */
512 :	edgomez	1382	in_buffer = (unsigned char *) malloc(IMAGE_SIZE(XDIM, YDIM));
513 :	edgomez	558	if (!in_buffer)
514 :			goto free_all_memory;
515 :
516 :			/* this should really be enough memory ! */
517 :	edgomez	1382	mp4_buffer = (unsigned char ) malloc(IMAGE_SIZE(XDIM, YDIM) 2);
518 :	edgomez	558	if (!mp4_buffer)
519 :	edgomez	1382	goto free_all_memory;
520 :	edgomez	558
521 :			/*****************************************************************************
522 :			* XviD PART Start
523 :			****************************************************************************/
524 :
525 :
526 :	edgomez	1382	result = enc_init(use_assembler);
527 :			if (result) {
528 :			fprintf(stderr, "Encore INIT problem, return value %d\n", result);
529 :	edgomez	558	goto release_all;
530 :			}
531 :
532 :			/*****************************************************************************
533 :			* Main loop
534 :			****************************************************************************/
535 :
536 :	edgomez	851	if (ARG_SAVEMPEGSTREAM && ARG_OUTPUTFILE) {
537 :	edgomez	561
538 :	edgomez	1382	if ((out_file = fopen(ARG_OUTPUTFILE, "w+b")) == NULL) {
539 :	edgomez	558	fprintf(stderr, "Error opening output file %s\n", ARG_OUTPUTFILE);
540 :			goto release_all;
541 :			}
542 :
543 :	edgomez	1382	} else {
544 :	edgomez	558	out_file = NULL;
545 :			}
546 :
547 :			/*****************************************************************************
548 :			* Encoding loop
549 :			****************************************************************************/
550 :
551 :			totalsize = 0;
552 :
553 :	edgomez	1382	result = 0;
554 :
555 :			input_num = 0; /* input frame counter */
556 :			output_num = 0; /* output frame counter */
557 :
558 :	edgomez	558	do {
559 :
560 :	edgomez	1382	char *type;
561 :			int sse[3];
562 :
563 :	Isibaar	1676	if (input_num >= ARG_MAXFRAMENR && ARG_MAXFRAMENR > 0) {
564 :	edgomez	1382	result = 1;
565 :	edgomez	558	}
566 :
567 :	edgomez	1382	if (!result) {
568 :	Isibaar	1645	#ifdef XVID_AVI_INPUT
569 :			if (ARG_INPUTTYPE==2) {
570 :			/* read avs/avi data (YUV-format) */
571 :			if(AVIStreamRead(avi_stream, input_num, 1, in_buffer, IMAGE_SIZE(XDIM, YDIM), NULL, NULL ) != AVIERR_OK)
572 :			result = 1;
573 :			} else
574 :			#endif
575 :			if (ARG_INPUTTYPE==1) {
576 :	edgomez	1382	/* read PGM data (YUV-format) */
577 :			#ifndef READ_PNM
578 :			result = read_pgmdata(in_file, in_buffer);
579 :			#else
580 :			result = read_pnmdata(in_file, in_buffer);
581 :			#endif
582 :			} else {
583 :			/* read raw data (YUV-format) */
584 :			result = read_yuvdata(in_file, in_buffer);
585 :			}
586 :	edgomez	728	}
587 :
588 :			/*****************************************************************************
589 :	edgomez	558	* Encode and decode this frame
590 :			****************************************************************************/
591 :
592 :			enctime = msecond();
593 :	edgomez	1382	m4v_size =
594 :			enc_main(!result ? in_buffer : 0, mp4_buffer, &key, &stats_type,
595 :			&stats_quant, &stats_length, sse);
596 :	edgomez	558	enctime = msecond() - enctime;
597 :
598 :	edgomez	1382	/* Write the Frame statistics */
599 :	edgomez	851
600 :	edgomez	1382	printf("%5d: key=%i, time= %6.0f, len= %7d", !result ? input_num : -1,
601 :			key, (float) enctime, (int) m4v_size);
602 :	edgomez	851
603 :	edgomez	1382	if (stats_type > 0) { /* !XVID_TYPE_NOTHING */
604 :	edgomez	851
605 :	edgomez	1382	switch (stats_type) {
606 :			case XVID_TYPE_IVOP:
607 :			type = "I";
608 :			break;
609 :			case XVID_TYPE_PVOP:
610 :			type = "P";
611 :			break;
612 :			case XVID_TYPE_BVOP:
613 :			type = "B";
614 :			break;
615 :			case XVID_TYPE_SVOP:
616 :			type = "S";
617 :			break;
618 :			default:
619 :			type = "U";
620 :			break;
621 :			}
622 :	edgomez	851
623 :	edgomez	1382	printf(" \| type=%s, quant= %2d, len= %7d", type, stats_quant,
624 :			stats_length);
625 :
626 :			#define SSE2PSNR(sse, width, height) ((!(sse))?0.0f : 48.131f - 10(float)log10((float)(sse)/((float)((width)(height)))))
627 :
628 :			if (ARG_STATS) {
629 :			printf(", psnr y = %2.2f, psnr u = %2.2f, psnr v = %2.2f",
630 :			SSE2PSNR(sse[0], XDIM, YDIM), SSE2PSNR(sse[1], XDIM / 2,
631 :			YDIM / 2),
632 :			SSE2PSNR(sse[2], XDIM / 2, YDIM / 2));
633 :
634 :			totalPSNR[0] += SSE2PSNR(sse[0], XDIM, YDIM);
635 :			totalPSNR[1] += SSE2PSNR(sse[1], XDIM/2, YDIM/2);
636 :			totalPSNR[2] += SSE2PSNR(sse[2], XDIM/2, YDIM/2);
637 :			}
638 :
639 :	edgomez	851	}
640 :	edgomez	1382	#undef SSE2PSNR
641 :	edgomez	851
642 :	edgomez	1382	printf("\n");
643 :
644 :			if (m4v_size < 0) {
645 :			break;
646 :			}
647 :
648 :	edgomez	851	/* Update encoding time stats */
649 :	edgomez	558	totalenctime += enctime;
650 :			totalsize += m4v_size;
651 :
652 :	edgomez	728	/*****************************************************************************
653 :	edgomez	1382	* Save stream to file
654 :	edgomez	728	****************************************************************************/
655 :
656 :	edgomez	1382	if (m4v_size > 0 && ARG_SAVEMPEGSTREAM) {
657 :	edgomez	728
658 :	edgomez	558	/* Save single files */
659 :	edgomez	1382	if (ARG_SAVEINDIVIDUAL) {
660 :			FILE *out;
661 :			sprintf(filename, "%sframe%05d.m4v", filepath, output_num);
662 :			out = fopen(filename, "w+b");
663 :			fwrite(mp4_buffer, m4v_size, 1, out);
664 :			fclose(out);
665 :			output_num++;
666 :	edgomez	558	}
667 :
668 :	edgomez	1382	/* Save ES stream */
669 :			if (ARG_OUTPUTFILE && out_file)
670 :	edgomez	851	fwrite(mp4_buffer, 1, m4v_size, out_file);
671 :	edgomez	558	}
672 :
673 :	edgomez	1382	input_num++;
674 :	edgomez	558
675 :	edgomez	1382	/* Read the header if it's pgm stream */
676 :	Isibaar	1645	if (!result && (ARG_INPUTTYPE==1))
677 :	edgomez	1382	#ifndef READ_PNM
678 :			result = read_pgmheader(in_file);
679 :			#else
680 :			result = read_pnmheader(in_file);
681 :			#endif
682 :			} while (1);
683 :	edgomez	558
684 :
685 :	edgomez	1382
686 :	edgomez	558	/*****************************************************************************
687 :			* Calculate totals and averages for output, print results
688 :			****************************************************************************/
689 :	chl	376
690 :	edgomez	1382	printf("Tot: enctime(ms) =%7.2f, length(bytes) = %7d\n",
691 :			totalenctime, (int) totalsize);
692 :	chl	376
693 :	edgomez	1382	if (input_num > 0) {
694 :			totalsize /= input_num;
695 :			totalenctime /= input_num;
696 :			totalPSNR[0] /= input_num;
697 :			totalPSNR[1] /= input_num;
698 :			totalPSNR[2] /= input_num;
699 :			} else {
700 :			totalsize = -1;
701 :			totalenctime = -1;
702 :			}
703 :	chl	376
704 :	edgomez	1382	printf("Avg: enctime(ms) =%7.2f, fps =%7.2f, length(bytes) = %7d",
705 :			totalenctime, 1000 / totalenctime, (int) totalsize);
706 :			if (ARG_STATS) {
707 :			printf(", psnr y = %2.2f, psnr u = %2.2f, psnr v = %2.2f",
708 :			totalPSNR[0],totalPSNR[1],totalPSNR[2]);
709 :			}
710 :			printf("\n");
711 :
712 :
713 :	edgomez	558	/*****************************************************************************
714 :			* XviD PART Stop
715 :			****************************************************************************/
716 :	chl	376
717 :	edgomez	1382	release_all:
718 :	chl	376
719 :	Isibaar	1645	#ifdef XVID_AVI_INPUT
720 :			if (avi_stream) {
721 :			AVIStreamRelease(avi_stream);
722 :			AVIFileExit();
723 :			}
724 :			#endif
725 :
726 :	edgomez	1382	if (enc_handle) {
727 :			result = enc_stop();
728 :			if (result)
729 :			fprintf(stderr, "Encore RELEASE problem return value %d\n",
730 :			result);
731 :	edgomez	558	}
732 :	chl	376
733 :	edgomez	1382	if (in_file)
734 :	edgomez	728	fclose(in_file);
735 :	edgomez	1382	if (out_file)
736 :	edgomez	558	fclose(out_file);
737 :
738 :	edgomez	1382	free_all_memory:
739 :	edgomez	558	free(out_buffer);
740 :			free(mp4_buffer);
741 :			free(in_buffer);
742 :
743 :	edgomez	1382	return (0);
744 :	edgomez	558
745 :			}
746 :
747 :
748 :			/*****************************************************************************
749 :			* "statistical" functions
750 :			*
751 :			* these are not needed for encoding or decoding, but for measuring
752 :			* time and quality, there in nothing specific to XviD in these
753 :			*
754 :			*****************************************************************************/
755 :
756 :			/* Return time elapsed time in miliseconds since the program started */
757 :	edgomez	1382	static double
758 :			msecond()
759 :			{
760 :	edgomez	824	#ifndef WIN32
761 :	edgomez	1382	struct timeval tv;
762 :
763 :	chl	376	gettimeofday(&tv, 0);
764 :	edgomez	1382	return (tv.tv_sec * 1.0e3 + tv.tv_usec * 1.0e-3);
765 :	edgomez	558	#else
766 :			clock_t clk;
767 :	edgomez	1382
768 :	edgomez	558	clk = clock();
769 :	suxen_drol	1646	return (clk * 1000.0 / CLOCKS_PER_SEC);
770 :	edgomez	558	#endif
771 :	chl	376	}
772 :
773 :	edgomez	558	/*****************************************************************************
774 :			* Usage message
775 :			*****************************************************************************/
776 :	chl	376
777 :	edgomez	1382	static void
778 :			usage()
779 :	edgomez	558	{
780 :	edgomez	1382	fprintf(stderr, "Usage : xvid_stat [OPTIONS]\n\n");
781 :			fprintf(stderr, "Input options:\n");
782 :			fprintf(stderr, " -i string : input filename (default=stdin)\n");
783 :	Isibaar	1645	#ifdef XVID_AVI_INPUT
784 :			fprintf(stderr, " -type integer: input data type (yuv=0, pgm=1, avi/avs=2)\n");
785 :			#else
786 :	edgomez	1382	fprintf(stderr, " -type integer: input data type (yuv=0, pgm=1)\n");
787 :	Isibaar	1645	#endif
788 :	edgomez	1382	fprintf(stderr, " -w integer: frame width ([1.2048])\n");
789 :			fprintf(stderr, " -h integer: frame height ([1.2048])\n");
790 :			fprintf(stderr, " -frames integer: number of frames to encode\n");
791 :			fprintf(stderr, "\n");
792 :			fprintf(stderr, "Output options:\n");
793 :			fprintf(stderr, " -dump : save decoder output\n");
794 :			fprintf(stderr, " -save : save an Elementary Stream file per frame\n");
795 :			fprintf(stderr, " -o string: save an Elementary Stream for the complete sequence\n");
796 :			fprintf(stderr, "\n");
797 :			fprintf(stderr, "BFrames options:\n");
798 :			fprintf(stderr, " -max_bframes integer: max bframes (default=0)\n");
799 :			fprintf(stderr, " -bquant_ratio integer: bframe quantizer ratio (default=150)\n");
800 :			fprintf(stderr, " -bquant_offset integer: bframe quantizer offset (default=100)\n");
801 :			fprintf(stderr, "\n");
802 :			fprintf(stderr, "Rate control options:\n");
803 :			fprintf(stderr, " -framerate float : target framerate (>0 \| default=25.0)\n");
804 :			fprintf(stderr, " -bitrate integer : target bitrate\n");
805 :			fprintf(stderr, " -single : single pass mode\n");
806 :			fprintf(stderr, " -pass1 filename : twopass mode (first pass)\n");
807 :			fprintf(stderr, " -pass2 filename : twopass mode (2nd pass)\n");
808 :			fprintf(stderr, " -zq starting_frame float : bitrate zone; quant\n");
809 :			fprintf(stderr, " -zw starting_frame float : bitrate zone; weight\n");
810 :			fprintf(stderr, " -max_key_interval integer : maximum keyframe interval\n");
811 :			fprintf(stderr, "\n");
812 :			fprintf(stderr, "Other options\n");
813 :	Isibaar	1645	fprintf(stderr, " -noasm : do not use assembly optmized code\n");
814 :			fprintf(stderr, " -turbo : use turbo presets for higher encoding speed\n");
815 :			fprintf(stderr, " -quality integer : quality ([0..%d])\n", ME_ELEMENTS - 1);
816 :			fprintf(stderr, " -vhqmode integer : level of Rate-Distortion optimizations ([0..4]) (default=0)\n");
817 :			fprintf(stderr, " -bvhq : use Rate-Distortion optimizations for B-frames too\n");
818 :			fprintf(stderr, " -qpel : use quarter pixel ME\n");
819 :			fprintf(stderr, " -gmc : use global motion compensation\n");
820 :			fprintf(stderr, " -qtype integer : quantization type (H263:0, MPEG4:1) (default=0)\n");
821 :			fprintf(stderr, " -qmatrix filename: use custom MPEG4 quantization matrix\n");
822 :			fprintf(stderr, " -interlaced : use interlaced encoding (this is NOT a deinterlacer!)\n");
823 :			fprintf(stderr, " -packed : packed mode\n");
824 :			fprintf(stderr, " -closed_gop : closed GOP mode\n");
825 :			fprintf(stderr, " -grey : grey scale coding (chroma is discarded)\n");
826 :			fprintf(stderr, " -lumimasking : use lumimasking algorithm\n");
827 :			fprintf(stderr, " -stats : print stats about encoded frames\n");
828 :			fprintf(stderr, " -debug : activates xvidcore internal debugging output\n");
829 :			fprintf(stderr, " -vop_debug : print some info directly into encoded frames\n");
830 :			fprintf(stderr, " -help : prints this help message\n");
831 :	edgomez	1382	fprintf(stderr, "\n");
832 :			fprintf(stderr, "NB: You can define %d zones repeating the -z[qw] option as many times as needed.\n", MAX_ZONES);
833 :			fprintf(stderr, "\n");
834 :	edgomez	558	}
835 :
836 :			/*****************************************************************************
837 :			* Input and output functions
838 :			*
839 :			* the are small and simple routines to read and write PGM and YUV
840 :			* image. It's just for convenience, again nothing specific to XviD
841 :			*
842 :			*****************************************************************************/
843 :
844 :	edgomez	1382	#ifndef READ_PNM
845 :			static int
846 :			read_pgmheader(FILE * handle)
847 :			{
848 :			int bytes, xsize, ysize, depth;
849 :	chl	376	char dummy[2];
850 :
851 :	edgomez	1382	bytes = fread(dummy, 1, 2, handle);
852 :	edgomez	558
853 :	edgomez	1382	if ((bytes < 2) \|\| (dummy[0] != 'P') \|\| (dummy[1] != '5'))
854 :			return (1);
855 :
856 :			fscanf(handle, "%d %d %d", &xsize, &ysize, &depth);
857 :	edgomez	1398	if ((xsize > 4096) \|\| (ysize > 4096*3/2) \|\| (depth != 255)) {
858 :	edgomez	1382	fprintf(stderr, "%d %d %d\n", xsize, ysize, depth);
859 :			return (2);
860 :	chl	376	}
861 :	edgomez	1382	if ((XDIM == 0) \|\| (YDIM == 0)) {
862 :			XDIM = xsize;
863 :			YDIM = ysize * 2 / 3;
864 :	chl	376	}
865 :
866 :	edgomez	1382	return (0);
867 :	chl	376	}
868 :
869 :	edgomez	1382	static int
870 :			read_pgmdata(FILE * handle,
871 :			unsigned char *image)
872 :			{
873 :	edgomez	558	int i;
874 :	chl	376	char dummy;
875 :	edgomez	1382
876 :	edgomez	558	unsigned char *y = image;
877 :	edgomez	1382	unsigned char u = image + XDIM YDIM;
878 :			unsigned char v = image + XDIM YDIM + XDIM / 2 * YDIM / 2;
879 :	chl	376
880 :	edgomez	558	/* read Y component of picture */
881 :	edgomez	1382	fread(y, 1, XDIM * YDIM, handle);
882 :
883 :			for (i = 0; i < YDIM / 2; i++) {
884 :	edgomez	558	/* read U */
885 :	edgomez	1382	fread(u, 1, XDIM / 2, handle);
886 :	edgomez	558
887 :			/* read V */
888 :	edgomez	1382	fread(v, 1, XDIM / 2, handle);
889 :	edgomez	558
890 :			/* Update pointers */
891 :	edgomez	1382	u += XDIM / 2;
892 :			v += XDIM / 2;
893 :	chl	376	}
894 :	edgomez	558
895 :	edgomez	1382	/* I don't know why, but this seems needed */
896 :	edgomez	558	fread(&dummy, 1, 1, handle);
897 :
898 :	edgomez	1382	return (0);
899 :	chl	376	}
900 :	edgomez	1382	#else
901 :			static int
902 :			read_pnmheader(FILE * handle)
903 :			{
904 :			int bytes, xsize, ysize, depth;
905 :			char dummy[2];
906 :	chl	376
907 :	edgomez	1382	bytes = fread(dummy, 1, 2, handle);
908 :
909 :			if ((bytes < 2) \|\| (dummy[0] != 'P') \|\| (dummy[1] != '6'))
910 :			return (1);
911 :
912 :			fscanf(handle, "%d %d %d", &xsize, &ysize, &depth);
913 :			if ((xsize > 1440) \|\| (ysize > 2880) \|\| (depth != 255)) {
914 :			fprintf(stderr, "%d %d %d\n", xsize, ysize, depth);
915 :			return (2);
916 :			}
917 :
918 :			XDIM = xsize;
919 :			YDIM = ysize;
920 :
921 :			return (0);
922 :			}
923 :
924 :			static int
925 :			read_pnmdata(FILE * handle,
926 :			unsigned char *image)
927 :	edgomez	558	{
928 :	edgomez	1382	int i;
929 :			char dummy;
930 :
931 :			/* read Y component of picture */
932 :			fread(image, 1, XDIM * YDIM * 3, handle);
933 :
934 :			/* I don't know why, but this seems needed */
935 :			fread(&dummy, 1, 1, handle);
936 :
937 :			return (0);
938 :	chl	376	}
939 :	edgomez	1382	#endif
940 :	chl	376
941 :	edgomez	1382	static int
942 :			read_yuvdata(FILE * handle,
943 :			unsigned char *image)
944 :			{
945 :
946 :			if (fread(image, 1, IMAGE_SIZE(XDIM, YDIM), handle) !=
947 :			(unsigned int) IMAGE_SIZE(XDIM, YDIM))
948 :			return (1);
949 :			else
950 :			return (0);
951 :			}
952 :
953 :	edgomez	558	/*****************************************************************************
954 :			* Routines for encoding: init encoder, frame step, release encoder
955 :			****************************************************************************/
956 :	chl	376
957 :	edgomez	1382	/* sample plugin */
958 :
959 :			int
960 :			rawenc_debug(void *handle,
961 :			int opt,
962 :			void *param1,
963 :			void *param2)
964 :			{
965 :			switch (opt) {
966 :			case XVID_PLG_INFO:
967 :			{
968 :			xvid_plg_info_t info = (xvid_plg_info_t ) param1;
969 :
970 :			info->flags = XVID_REQDQUANTS;
971 :			return 0;
972 :			}
973 :
974 :			case XVID_PLG_CREATE:
975 :			case XVID_PLG_DESTROY:
976 :			case XVID_PLG_BEFORE:
977 :			return 0;
978 :
979 :			case XVID_PLG_AFTER:
980 :			{
981 :			xvid_plg_data_t data = (xvid_plg_data_t ) param1;
982 :			int i, j;
983 :
984 :			printf("---[ frame: %5i quant: %2i length: %6i ]---\n",
985 :			data->frame_num, data->quant, data->length);
986 :			for (j = 0; j < data->mb_height; j++) {
987 :			for (i = 0; i < data->mb_width; i++)
988 :			printf("%2i ", data->dquant[j * data->dquant_stride + i]);
989 :			printf("\n");
990 :			}
991 :
992 :			return 0;
993 :			}
994 :			}
995 :
996 :			return XVID_ERR_FAIL;
997 :			}
998 :
999 :
1000 :	chl	376	#define FRAMERATE_INCR 1001
1001 :
1002 :	edgomez	1382
1003 :	edgomez	558	/* Initialize encoder for first use, pass all needed parameters to the codec */
1004 :	edgomez	1382	static int
1005 :			enc_init(int use_assembler)
1006 :	edgomez	558	{
1007 :	chl	376	int xerr;
1008 :	edgomez	1382	//xvid_plugin_cbr_t cbr;
1009 :			xvid_plugin_single_t single;
1010 :			xvid_plugin_2pass1_t rc2pass1;
1011 :			xvid_plugin_2pass2_t rc2pass2;
1012 :			//xvid_plugin_fixed_t rcfixed;
1013 :			xvid_enc_plugin_t plugins[7];
1014 :			xvid_gbl_init_t xvid_gbl_init;
1015 :			xvid_enc_create_t xvid_enc_create;
1016 :	chl	376
1017 :	edgomez	1382	/*------------------------------------------------------------------------
1018 :			* XviD core initialization
1019 :			----------------------------------------------------------------------/
1020 :	chl	376
1021 :	edgomez	1382	/* Set version -- version checking will done by xvidcore */
1022 :			memset(&xvid_gbl_init, 0, sizeof(xvid_gbl_init));
1023 :			xvid_gbl_init.version = XVID_VERSION;
1024 :			xvid_gbl_init.debug = ARG_DEBUG;
1025 :
1026 :
1027 :			/* Do we have to enable ASM optimizations ? */
1028 :			if (use_assembler) {
1029 :
1030 :	suxen_drol	860	#ifdef ARCH_IS_IA64
1031 :	edgomez	1382	xvid_gbl_init.cpu_flags = XVID_CPU_FORCE \| XVID_CPU_ASM;
1032 :	chl	376	#else
1033 :	edgomez	1382	xvid_gbl_init.cpu_flags = 0;
1034 :	chl	376	#endif
1035 :	edgomez	1382	} else {
1036 :			xvid_gbl_init.cpu_flags = XVID_CPU_FORCE;
1037 :	edgomez	558	}
1038 :	edgomez	1382
1039 :			/* Initialize XviD core -- Should be done once per __process__ */
1040 :			xvid_global(NULL, XVID_GBL_INIT, &xvid_gbl_init, NULL);
1041 :
1042 :			/*------------------------------------------------------------------------
1043 :			* XviD encoder initialization
1044 :			----------------------------------------------------------------------/
1045 :
1046 :			/* Version again */
1047 :			memset(&xvid_enc_create, 0, sizeof(xvid_enc_create));
1048 :			xvid_enc_create.version = XVID_VERSION;
1049 :
1050 :			/* Width and Height of input frames */
1051 :			xvid_enc_create.width = XDIM;
1052 :			xvid_enc_create.height = YDIM;
1053 :			xvid_enc_create.profile = XVID_PROFILE_AS_L4;
1054 :
1055 :			/* init plugins */
1056 :			xvid_enc_create.zones = ZONES;
1057 :			xvid_enc_create.num_zones = NUM_ZONES;
1058 :
1059 :			xvid_enc_create.plugins = plugins;
1060 :			xvid_enc_create.num_plugins = 0;
1061 :
1062 :			if (ARG_SINGLE) {
1063 :			memset(&single, 0, sizeof(xvid_plugin_single_t));
1064 :			single.version = XVID_VERSION;
1065 :			single.bitrate = ARG_BITRATE;
1066 :
1067 :			plugins[xvid_enc_create.num_plugins].func = xvid_plugin_single;
1068 :			plugins[xvid_enc_create.num_plugins].param = &single;
1069 :			xvid_enc_create.num_plugins++;
1070 :	edgomez	558	}
1071 :	chl	376
1072 :	edgomez	1382	if (ARG_PASS2) {
1073 :			memset(&rc2pass2, 0, sizeof(xvid_plugin_2pass2_t));
1074 :			rc2pass2.version = XVID_VERSION;
1075 :			rc2pass2.filename = ARG_PASS2;
1076 :			rc2pass2.bitrate = ARG_BITRATE;
1077 :	chl	376
1078 :	chl	1470	/* An example of activating VBV could look like this
1079 :			rc2pass2.vbv_size = 3145728;
1080 :			rc2pass2.vbv_initial = 2359296;
1081 :			rc2pass2.vbv_maxrate = 4000000;
1082 :			rc2pass2.vbv_peakrate = 10000000;
1083 :			*/
1084 :
1085 :	edgomez	1382	plugins[xvid_enc_create.num_plugins].func = xvid_plugin_2pass2;
1086 :			plugins[xvid_enc_create.num_plugins].param = &rc2pass2;
1087 :			xvid_enc_create.num_plugins++;
1088 :	chl	376	}
1089 :	edgomez	1382
1090 :			if (ARG_PASS1) {
1091 :			memset(&rc2pass1, 0, sizeof(xvid_plugin_2pass1_t));
1092 :			rc2pass1.version = XVID_VERSION;
1093 :			rc2pass1.filename = ARG_PASS1;
1094 :
1095 :			plugins[xvid_enc_create.num_plugins].func = xvid_plugin_2pass1;
1096 :			plugins[xvid_enc_create.num_plugins].param = &rc2pass1;
1097 :			xvid_enc_create.num_plugins++;
1098 :	chl	376	}
1099 :
1100 :	edgomez	1382	if (ARG_LUMIMASKING) {
1101 :			plugins[xvid_enc_create.num_plugins].func = xvid_plugin_lumimasking;
1102 :			plugins[xvid_enc_create.num_plugins].param = NULL;
1103 :			xvid_enc_create.num_plugins++;
1104 :			}
1105 :
1106 :			if (ARG_DUMP) {
1107 :			plugins[xvid_enc_create.num_plugins].func = xvid_plugin_dump;
1108 :			plugins[xvid_enc_create.num_plugins].param = NULL;
1109 :			xvid_enc_create.num_plugins++;
1110 :			}
1111 :
1112 :			#if 0
1113 :			if (ARG_DEBUG) {
1114 :			plugins[xvid_enc_create.num_plugins].func = rawenc_debug;
1115 :			plugins[xvid_enc_create.num_plugins].param = NULL;
1116 :			xvid_enc_create.num_plugins++;
1117 :			}
1118 :			#endif
1119 :
1120 :			/* No fancy thread tests */
1121 :			xvid_enc_create.num_threads = 0;
1122 :
1123 :			/* Frame rate - Do some quick float fps = fincr/fbase hack */
1124 :			if ((ARG_FRAMERATE - (int) ARG_FRAMERATE) < SMALL_EPS) {
1125 :			xvid_enc_create.fincr = 1;
1126 :			xvid_enc_create.fbase = (int) ARG_FRAMERATE;
1127 :			} else {
1128 :			xvid_enc_create.fincr = FRAMERATE_INCR;
1129 :			xvid_enc_create.fbase = (int) (FRAMERATE_INCR * ARG_FRAMERATE);
1130 :			}
1131 :
1132 :			/* Maximum key frame interval */
1133 :			if (ARG_MAXKEYINTERVAL > 0) {
1134 :			xvid_enc_create.max_key_interval = ARG_MAXKEYINTERVAL;
1135 :			}else {
1136 :			xvid_enc_create.max_key_interval = (int) ARG_FRAMERATE *10;
1137 :			}
1138 :
1139 :			/* Bframes settings */
1140 :			xvid_enc_create.max_bframes = ARG_MAXBFRAMES;
1141 :			xvid_enc_create.bquant_ratio = ARG_BQRATIO;
1142 :			xvid_enc_create.bquant_offset = ARG_BQOFFSET;
1143 :
1144 :			/* Dropping ratio frame -- we don't need that */
1145 :			xvid_enc_create.frame_drop_ratio = 0;
1146 :
1147 :			/* Global encoder options */
1148 :			xvid_enc_create.global = 0;
1149 :
1150 :			if (ARG_PACKED)
1151 :			xvid_enc_create.global \|= XVID_GLOBAL_PACKED;
1152 :
1153 :			if (ARG_CLOSED_GOP)
1154 :			xvid_enc_create.global \|= XVID_GLOBAL_CLOSED_GOP;
1155 :
1156 :			if (ARG_STATS)
1157 :			xvid_enc_create.global \|= XVID_GLOBAL_EXTRASTATS_ENABLE;
1158 :
1159 :	edgomez	558	/* I use a small value here, since will not encode whole movies, but short clips */
1160 :	edgomez	1382	xerr = xvid_encore(NULL, XVID_ENC_CREATE, &xvid_enc_create, NULL);
1161 :	chl	376
1162 :	edgomez	1382	/* Retrieve the encoder instance from the structure */
1163 :			enc_handle = xvid_enc_create.handle;
1164 :	chl	376
1165 :	edgomez	1382	return (xerr);
1166 :	chl	376	}
1167 :
1168 :	edgomez	1382	static int
1169 :			enc_stop()
1170 :	edgomez	558	{
1171 :			int xerr;
1172 :	chl	376
1173 :	edgomez	1382	/* Destroy the encoder instance */
1174 :	chl	376	xerr = xvid_encore(enc_handle, XVID_ENC_DESTROY, NULL, NULL);
1175 :	edgomez	558
1176 :	edgomez	1382	return (xerr);
1177 :	chl	376	}
1178 :
1179 :	edgomez	1382	static int
1180 :			enc_main(unsigned char *image,
1181 :			unsigned char *bitstream,
1182 :			int *key,
1183 :			int *stats_type,
1184 :			int *stats_quant,
1185 :			int *stats_length,
1186 :			int sse[3])
1187 :	edgomez	558	{
1188 :	edgomez	1382	int ret;
1189 :	chl	376
1190 :	edgomez	1382	xvid_enc_frame_t xvid_enc_frame;
1191 :			xvid_enc_stats_t xvid_enc_stats;
1192 :	chl	376
1193 :	edgomez	1382	/* Version for the frame and the stats */
1194 :			memset(&xvid_enc_frame, 0, sizeof(xvid_enc_frame));
1195 :			xvid_enc_frame.version = XVID_VERSION;
1196 :	chl	376
1197 :	edgomez	1382	memset(&xvid_enc_stats, 0, sizeof(xvid_enc_stats));
1198 :			xvid_enc_stats.version = XVID_VERSION;
1199 :	chl	376
1200 :	edgomez	1382	/* Bind output buffer */
1201 :			xvid_enc_frame.bitstream = bitstream;
1202 :			xvid_enc_frame.length = -1;
1203 :	chl	376
1204 :	edgomez	1382	/* Initialize input image fields */
1205 :			if (image) {
1206 :			xvid_enc_frame.input.plane[0] = image;
1207 :			#ifndef READ_PNM
1208 :	Isibaar	1645	if (ARG_INPUTTYPE==2)
1209 :			xvid_enc_frame.input.csp = XVID_CSP_YV12;
1210 :			else
1211 :			xvid_enc_frame.input.csp = XVID_CSP_I420;
1212 :	edgomez	1382	xvid_enc_frame.input.stride[0] = XDIM;
1213 :			#else
1214 :			xvid_enc_frame.input.csp = XVID_CSP_BGR;
1215 :			xvid_enc_frame.input.stride[0] = XDIM*3;
1216 :			#endif
1217 :			} else {
1218 :			xvid_enc_frame.input.csp = XVID_CSP_NULL;
1219 :			}
1220 :	chl	376
1221 :	edgomez	1382	/* Set up core's general features */
1222 :			xvid_enc_frame.vol_flags = 0;
1223 :			if (ARG_STATS)
1224 :			xvid_enc_frame.vol_flags \|= XVID_VOL_EXTRASTATS;
1225 :	Isibaar	1645	if (ARG_QTYPE)
1226 :			xvid_enc_frame.vol_flags \|= XVID_VOL_MPEGQUANT;
1227 :	edgomez	1382	if (ARG_QPEL)
1228 :			xvid_enc_frame.vol_flags \|= XVID_VOL_QUARTERPEL;
1229 :			if (ARG_GMC)
1230 :			xvid_enc_frame.vol_flags \|= XVID_VOL_GMC;
1231 :	chl	1559	if (ARG_INTERLACING)
1232 :			xvid_enc_frame.vol_flags \|= XVID_VOL_INTERLACING;
1233 :	edgomez	728
1234 :	edgomez	1382	/* Set up core's general features */
1235 :			xvid_enc_frame.vop_flags = vop_presets[ARG_QUALITY];
1236 :	edgomez	728
1237 :	edgomez	1382	if (ARG_VOPDEBUG) {
1238 :			xvid_enc_frame.vop_flags \|= XVID_VOP_DEBUG;
1239 :			}
1240 :	edgomez	728
1241 :	Skal	1622	if (ARG_GREYSCALE) {
1242 :			xvid_enc_frame.vop_flags \|= XVID_VOP_GREYSCALE;
1243 :			}
1244 :
1245 :	edgomez	1382	/* Frame type -- let core decide for us */
1246 :			xvid_enc_frame.type = XVID_TYPE_AUTO;
1247 :	chl	376
1248 :	edgomez	1382	/* Force the right quantizer -- It is internally managed by RC plugins */
1249 :			xvid_enc_frame.quant = 0;
1250 :	edgomez	728
1251 :	edgomez	1382	/* Set up motion estimation flags */
1252 :			xvid_enc_frame.motion = motion_presets[ARG_QUALITY];
1253 :	chl	376
1254 :	edgomez	1382	if (ARG_GMC)
1255 :			xvid_enc_frame.motion \|= XVID_ME_GME_REFINE;
1256 :
1257 :			if (ARG_QPEL)
1258 :			xvid_enc_frame.motion \|= XVID_ME_QUARTERPELREFINE16;
1259 :			if (ARG_QPEL && (xvid_enc_frame.vop_flags & XVID_VOP_INTER4V))
1260 :			xvid_enc_frame.motion \|= XVID_ME_QUARTERPELREFINE8;
1261 :
1262 :	Isibaar	1645	if (ARG_TURBO)
1263 :			xvid_enc_frame.motion \|= XVID_ME_FASTREFINE16 \| XVID_ME_FASTREFINE8 \|
1264 :			XVID_ME_SKIP_DELTASEARCH \| XVID_ME_FAST_MODEINTERPOLATE \|
1265 :			XVID_ME_BFRAME_EARLYSTOP;
1266 :
1267 :			if (ARG_BVHQ)
1268 :			xvid_enc_frame.vop_flags \|= XVID_VOP_RD_BVOP;
1269 :
1270 :	chl	1624	switch (ARG_VHQMODE) /* this is the same code as for vfw */
1271 :			{
1272 :			case 1: /* VHQ_MODE_DECISION */
1273 :			xvid_enc_frame.vop_flags \|= XVID_VOP_MODEDECISION_RD;
1274 :			break;
1275 :
1276 :			case 2: /* VHQ_LIMITED_SEARCH */
1277 :			xvid_enc_frame.vop_flags \|= XVID_VOP_MODEDECISION_RD;
1278 :			xvid_enc_frame.motion \|= XVID_ME_HALFPELREFINE16_RD;
1279 :			xvid_enc_frame.motion \|= XVID_ME_QUARTERPELREFINE16_RD;
1280 :			break;
1281 :
1282 :			case 3: /* VHQ_MEDIUM_SEARCH */
1283 :			xvid_enc_frame.vop_flags \|= XVID_VOP_MODEDECISION_RD;
1284 :			xvid_enc_frame.motion \|= XVID_ME_HALFPELREFINE16_RD;
1285 :			xvid_enc_frame.motion \|= XVID_ME_HALFPELREFINE8_RD;
1286 :			xvid_enc_frame.motion \|= XVID_ME_QUARTERPELREFINE16_RD;
1287 :			xvid_enc_frame.motion \|= XVID_ME_QUARTERPELREFINE8_RD;
1288 :			xvid_enc_frame.motion \|= XVID_ME_CHECKPREDICTION_RD;
1289 :			break;
1290 :
1291 :			case 4: /* VHQ_WIDE_SEARCH */
1292 :			xvid_enc_frame.vop_flags \|= XVID_VOP_MODEDECISION_RD;
1293 :			xvid_enc_frame.motion \|= XVID_ME_HALFPELREFINE16_RD;
1294 :			xvid_enc_frame.motion \|= XVID_ME_HALFPELREFINE8_RD;
1295 :			xvid_enc_frame.motion \|= XVID_ME_QUARTERPELREFINE16_RD;
1296 :			xvid_enc_frame.motion \|= XVID_ME_QUARTERPELREFINE8_RD;
1297 :			xvid_enc_frame.motion \|= XVID_ME_CHECKPREDICTION_RD;
1298 :			xvid_enc_frame.motion \|= XVID_ME_EXTSEARCH_RD;
1299 :			break;
1300 :
1301 :			default :
1302 :			break;
1303 :			}
1304 :
1305 :	Isibaar	1645	if (ARG_QMATRIX) {
1306 :			/* We don't use special matrices */
1307 :			xvid_enc_frame.quant_intra_matrix = qmatrix_intra;
1308 :			xvid_enc_frame.quant_inter_matrix = qmatrix_inter;
1309 :			}
1310 :			else {
1311 :			/* We don't use special matrices */
1312 :			xvid_enc_frame.quant_intra_matrix = NULL;
1313 :			xvid_enc_frame.quant_inter_matrix = NULL;
1314 :			}
1315 :	edgomez	1382
1316 :			/* Encode the frame */
1317 :			ret = xvid_encore(enc_handle, XVID_ENC_ENCODE, &xvid_enc_frame,
1318 :			&xvid_enc_stats);
1319 :
1320 :			*key = (xvid_enc_frame.out_flags & XVID_KEYFRAME);
1321 :			*stats_type = xvid_enc_stats.type;
1322 :			*stats_quant = xvid_enc_stats.quant;
1323 :			*stats_length = xvid_enc_stats.length;
1324 :			sse[0] = xvid_enc_stats.sse_y;
1325 :			sse[1] = xvid_enc_stats.sse_u;
1326 :			sse[2] = xvid_enc_stats.sse_v;
1327 :
1328 :			return (ret);
1329 :	chl	376	}

No admin address has been configured	ViewVC Help
Powered by ViewVC 1.0.4