Annotation of /branches/release-1_3-branch/xvidcore/examples/xvid_encraw.c

Revision 1627 - (view) (download)
Original Path: trunk/xvidcore/examples/xvid_encraw.c

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

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