Annotation of /trunk/xvidcore/vfw/src/codec.c

Revision 1816 - (view) (download)

1 :	edgomez	1382	/**************************************************************************
2 :			*
3 :			* XVID VFW FRONTEND
4 :			* codec
5 :			*
6 :			* This program is free software; you can redistribute it and/or modify
7 :			* it under the terms of the GNU General Public License as published by
8 :			* the Free Software Foundation; either version 2 of the License, or
9 :			* (at your option) any later version.
10 :			*
11 :			* This program is distributed in the hope that it will be useful,
12 :			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13 :			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 :			* GNU General Public License for more details.
15 :			*
16 :			* You should have received a copy of the GNU General Public License
17 :			* along with this program; if not, write to the Free Software
18 :			* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 :			*
20 :			*************************************************************************/
21 :
22 :			/**************************************************************************
23 :			*
24 :			* History:
25 :			*
26 :			* 12.07.2002 num_threads
27 :			* 23.06.2002 XVID_CPU_CHKONLY; loading speed up
28 :			* 25.04.2002 ICDECOMPRESS_PREROLL
29 :			* 17.04.2002 re-enabled lumi masking for 1st pass
30 :			* 15.04.2002 updated cbr support
31 :			* 04.04.2002 separated 2-pass code to 2pass.c
32 :			* interlacing support
33 :			* hinted ME support
34 :			* 23.03.2002 daniel smith <danielsmith@astroboymail.com>
35 :			* changed inter4v to only be in modes 5 or 6
36 :			* fixed null mode crash ?
37 :			* merged foxer's alternative 2-pass code
38 :			* added DEBUGERR output on errors instead of returning
39 :			* 16.03.2002 daniel smith <danielsmith@astroboymail.com>
40 :			* changed BITMAPV4HEADER to BITMAPINFOHEADER
41 :			* - prevents memcpy crash in compress_get_format()
42 :			* credits are processed in external 2pass mode
43 :			* motion search precision = 0 now effective in 2-pass
44 :			* modulated quantization
45 :			* added DX50 fourcc
46 :			* 01.12.2001 inital version; (c)2001 peter ross <pross@xvid.org>
47 :			*
48 :			*************************************************************************/
49 :
50 :			#include <windows.h>
51 :			#include <vfw.h>
52 :			#include <stdio.h>
53 :			#include "vfwext.h"
54 :
55 :			#include <xvid.h>
56 :			#include "debug.h"
57 :			#include "codec.h"
58 :			#include "status.h"
59 :
60 :
61 :
62 :			static const int pmvfast_presets[7] = {
63 :			0, 0, 0, 0,
64 :			0 \| XVID_ME_HALFPELREFINE16 \| 0,
65 :			0 \| XVID_ME_HALFPELREFINE16 \| 0 \|
66 :			XVID_ME_ADVANCEDDIAMOND16, XVID_ME_HALFPELREFINE16 \| XVID_ME_EXTSEARCH16 \|
67 :			XVID_ME_HALFPELREFINE8 \| 0 \| XVID_ME_USESQUARES16
68 :			};
69 :
70 :
71 :
72 :			/* return xvid compatbile colorspace,
73 :			or XVID_CSP_NULL if failure
74 :			*/
75 :
76 :			static int get_colorspace(BITMAPINFOHEADER * hdr)
77 :			{
78 :			/* rgb only: negative height specifies top down image */
79 :			int rgb_flip = (hdr->biHeight < 0 ? 0 : XVID_CSP_VFLIP);
80 :
81 :			switch(hdr->biCompression)
82 :			{
83 :			case BI_RGB :
84 :			if (hdr->biBitCount == 16)
85 :			{
86 :			DPRINTF("RGB16 (RGB555)");
87 :			return rgb_flip \| XVID_CSP_RGB555;
88 :			}
89 :			if (hdr->biBitCount == 24)
90 :			{
91 :			DPRINTF("RGB24");
92 :			return rgb_flip \| XVID_CSP_BGR;
93 :			}
94 :			if (hdr->biBitCount == 32)
95 :			{
96 :			DPRINTF("RGB32");
97 :			return rgb_flip \| XVID_CSP_BGRA;
98 :			}
99 :
100 :			DPRINTF("unsupported BI_RGB biBitCount=%i", hdr->biBitCount);
101 :			return XVID_CSP_NULL;
102 :
103 :			case BI_BITFIELDS :
104 :			if (hdr->biSize >= sizeof(BITMAPV4HEADER))
105 :			{
106 :			BITMAPV4HEADER * hdr4 = (BITMAPV4HEADER *)hdr;
107 :
108 :			if (hdr4->bV4BitCount == 16 &&
109 :			hdr4->bV4RedMask == 0x7c00 &&
110 :			hdr4->bV4GreenMask == 0x3e0 &&
111 :			hdr4->bV4BlueMask == 0x1f)
112 :			{
113 :			DPRINTF("RGB555");
114 :			return rgb_flip \| XVID_CSP_RGB555;
115 :			}
116 :
117 :			if(hdr4->bV4BitCount == 16 &&
118 :			hdr4->bV4RedMask == 0xf800 &&
119 :			hdr4->bV4GreenMask == 0x7e0 &&
120 :			hdr4->bV4BlueMask == 0x1f)
121 :			{
122 :			DPRINTF("RGB565");
123 :			return rgb_flip \| XVID_CSP_RGB565;
124 :			}
125 :
126 :			DPRINTF("unsupported BI_BITFIELDS mode");
127 :			return XVID_CSP_NULL;
128 :			}
129 :
130 :			DPRINTF("unsupported BI_BITFIELDS/BITMAPHEADER combination");
131 :			return XVID_CSP_NULL;
132 :
133 :			case FOURCC_I420 :
134 :			case FOURCC_IYUV :
135 :			DPRINTF("IYUY");
136 :			return XVID_CSP_I420;
137 :
138 :			case FOURCC_YV12 :
139 :			DPRINTF("YV12");
140 :			return XVID_CSP_YV12;
141 :
142 :			case FOURCC_YUYV :
143 :			case FOURCC_YUY2 :
144 :			DPRINTF("YUY2");
145 :			return XVID_CSP_YUY2;
146 :
147 :			case FOURCC_YVYU :
148 :			DPRINTF("YVYU");
149 :			return XVID_CSP_YVYU;
150 :
151 :			case FOURCC_UYVY :
152 :			DPRINTF("UYVY");
153 :			return XVID_CSP_UYVY;
154 :
155 :			default :
156 :			DPRINTF("unsupported colorspace %c%c%c%c",
157 :			hdr->biCompression&0xff,
158 :			(hdr->biCompression>>8)&0xff,
159 :			(hdr->biCompression>>16)&0xff,
160 :			(hdr->biCompression>>24)&0xff);
161 :			return XVID_CSP_NULL;
162 :			}
163 :			}
164 :
165 :
166 :			/* compressor */
167 :
168 :
169 :			/* test the output format */
170 :
171 :			LRESULT compress_query(CODEC * codec, BITMAPINFO * lpbiInput, BITMAPINFO * lpbiOutput)
172 :			{
173 :			BITMAPINFOHEADER * inhdr = &lpbiInput->bmiHeader;
174 :			BITMAPINFOHEADER * outhdr = &lpbiOutput->bmiHeader;
175 :
176 :			/* VFWEXT detection */
177 :			if (inhdr->biCompression == VFWEXT_FOURCC) {
178 :			return (ICM_USER+0x0fff);
179 :			}
180 :
181 :			if (get_colorspace(inhdr) == XVID_CSP_NULL)
182 :			{
183 :			return ICERR_BADFORMAT;
184 :			}
185 :
186 :			if (lpbiOutput == NULL)
187 :			{
188 :			return ICERR_OK;
189 :			}
190 :
191 :			if (inhdr->biWidth != outhdr->biWidth \|\| inhdr->biHeight != outhdr->biHeight \|\|
192 :			(outhdr->biCompression != FOURCC_XVID && outhdr->biCompression != FOURCC_DIVX && outhdr->biCompression != FOURCC_DX50))
193 :			{
194 :			return ICERR_BADFORMAT;
195 :			}
196 :
197 :			return ICERR_OK;
198 :			}
199 :
200 :
201 :			LRESULT compress_get_format(CODEC * codec, BITMAPINFO * lpbiInput, BITMAPINFO * lpbiOutput)
202 :			{
203 :			BITMAPINFOHEADER * inhdr = &lpbiInput->bmiHeader;
204 :			BITMAPINFOHEADER * outhdr = &lpbiOutput->bmiHeader;
205 :
206 :			if (get_colorspace(inhdr) == XVID_CSP_NULL)
207 :			{
208 :			return ICERR_BADFORMAT;
209 :			}
210 :
211 :			if (lpbiOutput == NULL)
212 :			{
213 :			return sizeof(BITMAPINFOHEADER);
214 :			}
215 :
216 :			memcpy(outhdr, inhdr, sizeof(BITMAPINFOHEADER));
217 :			outhdr->biSize = sizeof(BITMAPINFOHEADER);
218 :			outhdr->biSizeImage = compress_get_size(codec, lpbiInput, lpbiOutput);
219 :			outhdr->biXPelsPerMeter = 0;
220 :			outhdr->biYPelsPerMeter = 0;
221 :			outhdr->biClrUsed = 0;
222 :			outhdr->biClrImportant = 0;
223 :
224 :			if (codec->config.fourcc_used == 0)
225 :			{
226 :			outhdr->biCompression = FOURCC_XVID;
227 :			}
228 :			else if (codec->config.fourcc_used == 1)
229 :			{
230 :			outhdr->biCompression = FOURCC_DIVX;
231 :			}
232 :			else
233 :			{
234 :			outhdr->biCompression = FOURCC_DX50;
235 :			}
236 :
237 :			return ICERR_OK;
238 :			}
239 :
240 :
241 :			LRESULT compress_get_size(CODEC * codec, BITMAPINFO * lpbiInput, BITMAPINFO * lpbiOutput)
242 :			{
243 :			return 2 * lpbiOutput->bmiHeader.biWidth * lpbiOutput->bmiHeader.biHeight * 3;
244 :			}
245 :
246 :
247 :			LRESULT compress_frames_info(CODEC * codec, ICCOMPRESSFRAMES * icf)
248 :			{
249 :			#if 0
250 :			DPRINTF("%i %i", icf->lStartFrame, icf->lFrameCount);
251 :			#endif
252 :			codec->fincr = icf->dwScale;
253 :			codec->fbase = icf->dwRate;
254 :			return ICERR_OK;
255 :			}
256 :
257 :
258 :			static char type2char(int type)
259 :			{
260 :			if (type==XVID_TYPE_IVOP)
261 :			return 'I';
262 :			if (type==XVID_TYPE_PVOP)
263 :			return 'P';
264 :			if (type==XVID_TYPE_BVOP)
265 :			return 'B';
266 :			return 'S';
267 :			}
268 :
269 :			static int vfw_debug(void *handle,
270 :			int opt,
271 :			void *param1,
272 :			void *param2)
273 :			{
274 :			switch (opt) {
275 :			case XVID_PLG_CREATE:
276 :			((void*)param2) = NULL;
277 :			case XVID_PLG_INFO:
278 :			case XVID_PLG_DESTROY:
279 :			case XVID_PLG_BEFORE:
280 :			return 0;
281 :
282 :			case XVID_PLG_AFTER:
283 :			{
284 :			xvid_plg_data_t data = (xvid_plg_data_t ) param1;
285 :
286 :			/* We don't use DPRINTF here because it's active only for _DEBUG
287 :			* builds and that activates lot of other debug printfs. We only
288 :			* want these all the time */
289 :			char buf[1024];
290 :			sprintf(buf, "[%6i] type=%c Q:%2i length:%6i",
291 :			data->frame_num,
292 :			type2char(data->type),
293 :			data->quant,
294 :			data->length);
295 :			OutputDebugString(buf);
296 :
297 :			return 0;
298 :			}
299 :			}
300 :
301 :			return XVID_ERR_FAIL;
302 :			}
303 :
304 :			#define XVID_DLL_NAME "xvidcore.dll"
305 :
306 :	edgomez	1398	static int init_dll(CODEC* codec)
307 :	edgomez	1382	{
308 :	edgomez	1398	if (codec->m_hdll != NULL)
309 :			return 0;
310 :	edgomez	1382
311 :			DPRINTF("init_dll");
312 :	edgomez	1398	codec->m_hdll = LoadLibrary(XVID_DLL_NAME);
313 :			if (codec->m_hdll == NULL) {
314 :	edgomez	1382	DPRINTF("dll load failed");
315 :			MessageBox(0, XVID_DLL_NAME " not found!","Error!", MB_ICONEXCLAMATION\|MB_OK);
316 :			return XVID_ERR_FAIL;
317 :			}
318 :
319 :	edgomez	1398	codec->xvid_global_func = (int (__cdecl )(void , int, void , void ))GetProcAddress(codec->m_hdll, "xvid_global");
320 :			if (codec->xvid_global_func == NULL) {
321 :	edgomez	1382	MessageBox(0, "xvid_global() not found", "Error", 0);
322 :			return XVID_ERR_FAIL;
323 :			}
324 :
325 :	edgomez	1398	codec->xvid_encore_func = (int (__cdecl )(void , int, void , void ))GetProcAddress(codec->m_hdll, "xvid_encore");
326 :			if (codec->xvid_encore_func == NULL) {
327 :	edgomez	1382	MessageBox(0, "xvid_encore() not found", "Error", 0);
328 :			return XVID_ERR_FAIL;
329 :			}
330 :
331 :	edgomez	1398	codec->xvid_decore_func = (int (__cdecl )(void , int, void , void ))GetProcAddress(codec->m_hdll, "xvid_decore");
332 :			if (codec->xvid_decore_func == NULL) {
333 :	edgomez	1382	MessageBox(0, "xvid_decore() not found", "Error", 0);
334 :			return XVID_ERR_FAIL;
335 :			}
336 :
337 :	edgomez	1398	codec->xvid_plugin_single_func =
338 :			(int (__cdecl )(void , int, void , void ))(GetProcAddress(codec->m_hdll, "xvid_plugin_single"));
339 :			codec->xvid_plugin_2pass1_func =
340 :			(int (__cdecl )(void , int, void , void ))(GetProcAddress(codec->m_hdll, "xvid_plugin_2pass1"));
341 :			codec->xvid_plugin_2pass2_func =
342 :			(int (__cdecl )(void , int, void , void ))(GetProcAddress(codec->m_hdll, "xvid_plugin_2pass2"));
343 :			codec->xvid_plugin_lumimasking_func =
344 :			(int (__cdecl )(void , int, void , void ))(GetProcAddress(codec->m_hdll, "xvid_plugin_lumimasking"));
345 :			codec->xvid_plugin_psnr_func =
346 :			(int (__cdecl )(void , int, void , void ))(GetProcAddress(codec->m_hdll, "xvid_plugin_psnr"));
347 :	edgomez	1382
348 :			return 0;
349 :			}
350 :
351 :			/* constant-quant zones for fixed quant encoding */
352 :			static void
353 :			prepare_cquant_zones(CONFIG * config) {
354 :
355 :			int i = 0;
356 :			if (config->num_zones == 0 \|\| config->zones[0].frame != 0) {
357 :			/* first zone does not start at frame 0 or doesn't exist */
358 :
359 :			if (config->num_zones >= MAX_ZONES) config->num_zones--; /* we scrifice last zone */
360 :
361 :			config->zones[config->num_zones].frame = 0;
362 :			config->zones[config->num_zones].mode = RC_ZONE_QUANT;
363 :			config->zones[config->num_zones].weight = 100;
364 :			config->zones[config->num_zones].quant = config->desired_quant;
365 :			config->zones[config->num_zones].type = XVID_TYPE_AUTO;
366 :			config->zones[config->num_zones].greyscale = 0;
367 :			config->zones[config->num_zones].chroma_opt = 0;
368 :			config->zones[config->num_zones].bvop_threshold = 0;
369 :			config->num_zones++;
370 :
371 :			sort_zones(config->zones, config->num_zones, &i);
372 :			}
373 :
374 :			/* step 2: let's change all weight zones into quant zones */
375 :
376 :			for(i = 0; i < config->num_zones; i++)
377 :			if (config->zones[i].mode == RC_ZONE_WEIGHT) {
378 :			config->zones[i].mode = RC_ZONE_QUANT;
379 :			config->zones[i].quant = (100*config->desired_quant) / config->zones[i].weight;
380 :			}
381 :			}
382 :
383 :			/* full first pass zones */
384 :			static void
385 :			prepare_full1pass_zones(CONFIG * config) {
386 :
387 :			int i = 0;
388 :			if (config->num_zones == 0 \|\| config->zones[0].frame != 0) {
389 :			/* first zone does not start at frame 0 or doesn't exist */
390 :
391 :			if (config->num_zones >= MAX_ZONES) config->num_zones--; /* we scrifice last zone */
392 :
393 :			config->zones[config->num_zones].frame = 0;
394 :			config->zones[config->num_zones].mode = RC_ZONE_QUANT;
395 :			config->zones[config->num_zones].weight = 100;
396 :			config->zones[config->num_zones].quant = 200;
397 :			config->zones[config->num_zones].type = XVID_TYPE_AUTO;
398 :			config->zones[config->num_zones].greyscale = 0;
399 :			config->zones[config->num_zones].chroma_opt = 0;
400 :			config->zones[config->num_zones].bvop_threshold = 0;
401 :			config->num_zones++;
402 :
403 :			sort_zones(config->zones, config->num_zones, &i);
404 :			}
405 :
406 :			/* step 2: let's change all weight zones into quant zones */
407 :
408 :			for(i = 0; i < config->num_zones; i++)
409 :			if (config->zones[i].mode == RC_ZONE_WEIGHT) {
410 :			config->zones[i].mode = RC_ZONE_QUANT;
411 :			config->zones[i].quant = 200;
412 :			}
413 :			}
414 :
415 :
416 :			LRESULT compress_begin(CODEC * codec, BITMAPINFO * lpbiInput, BITMAPINFO * lpbiOutput)
417 :			{
418 :			xvid_gbl_init_t init;
419 :			xvid_enc_create_t create;
420 :			xvid_enc_plugin_t plugins[3];
421 :			xvid_plugin_single_t single;
422 :			xvid_plugin_2pass1_t pass1;
423 :			xvid_plugin_2pass2_t pass2;
424 :	Isibaar	1816	xvid_gbl_info_t info;
425 :	edgomez	1382	int i;
426 :			HANDLE hFile;
427 :	suxen_drol	1649	const quality_t* quality_preset = (codec->config.quality==quality_table_num) ?
428 :			&codec->config.quality_user : &quality_table[codec->config.quality];
429 :	edgomez	1382
430 :			CONFIG tmpCfg; /* if we want to alter config to suit our needs, it shouldn't be visible to user later */
431 :			memcpy(&tmpCfg, &codec->config, sizeof(CONFIG));
432 :
433 :	edgomez	1398	if (init_dll(codec) != 0) return ICERR_ERROR;
434 :	edgomez	1382	/* destroy previously created codec */
435 :			if(codec->ehandle) {
436 :	edgomez	1398	codec->xvid_encore_func(codec->ehandle, XVID_ENC_DESTROY, NULL, NULL);
437 :	edgomez	1382	codec->ehandle = NULL;
438 :			}
439 :
440 :			memset(&init, 0, sizeof(init));
441 :			init.version = XVID_VERSION;
442 :			init.cpu_flags = codec->config.cpu;
443 :			init.debug = codec->config.debug;
444 :	edgomez	1398	codec->xvid_global_func(0, XVID_GBL_INIT, &init, NULL);
445 :	edgomez	1382
446 :	Isibaar	1816	memset(&info, 0, sizeof(info));
447 :			info.version = XVID_VERSION;
448 :			codec->xvid_global_func(0, XVID_GBL_INFO, &info, NULL);
449 :
450 :	edgomez	1382	memset(&create, 0, sizeof(create));
451 :			create.version = XVID_VERSION;
452 :
453 :			/* plugins */
454 :			create.plugins = plugins;
455 :			switch (codec->config.mode)
456 :			{
457 :			case RC_MODE_1PASS :
458 :			memset(&single, 0, sizeof(single));
459 :			single.version = XVID_VERSION;
460 :			single.bitrate = codec->config.bitrate * CONFIG_KBPS;
461 :			single.reaction_delay_factor = codec->config.rc_reaction_delay_factor;
462 :			single.averaging_period = codec->config.rc_averaging_period;
463 :			single.buffer = codec->config.rc_buffer;
464 :	edgomez	1398	plugins[create.num_plugins].func = codec->xvid_plugin_single_func;
465 :	edgomez	1382	plugins[create.num_plugins].param = &single;
466 :			create.num_plugins++;
467 :			if (!codec->config.use_2pass_bitrate) /* constant-quant mode */
468 :			prepare_cquant_zones(&tmpCfg);
469 :			break;
470 :
471 :			case RC_MODE_2PASS1 :
472 :			memset(&pass1, 0, sizeof(pass1));
473 :			pass1.version = XVID_VERSION;
474 :			pass1.filename = codec->config.stats;
475 :			if (codec->config.full1pass)
476 :			prepare_full1pass_zones(&tmpCfg);
477 :	edgomez	1398	plugins[create.num_plugins].func = codec->xvid_plugin_2pass1_func;
478 :	edgomez	1382	plugins[create.num_plugins].param = &pass1;
479 :			create.num_plugins++;
480 :			break;
481 :
482 :			case RC_MODE_2PASS2 :
483 :			memset(&pass2, 0, sizeof(pass2));
484 :			pass2.version = XVID_VERSION;
485 :			if (codec->config.use_2pass_bitrate) {
486 :			pass2.bitrate = codec->config.bitrate * CONFIG_KBPS;
487 :			} else {
488 :			pass2.bitrate = -codec->config.desired_size; /* kilobytes */
489 :			}
490 :			pass2.filename = codec->config.stats;
491 :
492 :			hFile = CreateFile(pass2.filename, 0, FILE_SHARE_READ \| FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
493 :			if (hFile == INVALID_HANDLE_VALUE)
494 :			{
495 :			MessageBox(0, "Statsfile not found!","Error!", MB_ICONEXCLAMATION\|MB_OK);
496 :			return XVID_ERR_FAIL;
497 :			} else
498 :			{
499 :			CloseHandle(hFile);
500 :			}
501 :
502 :			pass2.keyframe_boost = codec->config.keyframe_boost; /* keyframe boost percentage: [0..100...]; */
503 :			pass2.curve_compression_high = codec->config.curve_compression_high;
504 :			pass2.curve_compression_low = codec->config.curve_compression_low;
505 :			pass2.overflow_control_strength = codec->config.overflow_control_strength;
506 :			pass2.max_overflow_improvement = codec->config.twopass_max_overflow_improvement;
507 :			pass2.max_overflow_degradation = codec->config.twopass_max_overflow_degradation;
508 :			pass2.kfreduction = codec->config.kfreduction;
509 :			pass2.kfthreshold = codec->config.kfthreshold;
510 :			pass2.container_frame_overhead = 24; /* AVI */
511 :
512 :	syskin	1562	/* VBV */
513 :			pass2.vbv_size = profiles[codec->config.profile].max_vbv_size;
514 :	suxen_drol	1607	pass2.vbv_initial = (profiles[codec->config.profile].max_vbv_size3)/4; / 75% */
515 :			pass2.vbv_maxrate = profiles[codec->config.profile].max_bitrate;
516 :	syskin	1562
517 :	suxen_drol	1607	// XXX: xvidcore current provides a "peak bits over 3secs" constraint.
518 :			// according to the latest dxn literature, a 1sec constraint is now used
519 :			pass2.vbv_peakrate = profiles[codec->config.profile].vbv_peakrate * 3;
520 :
521 :	edgomez	1398	plugins[create.num_plugins].func = codec->xvid_plugin_2pass2_func;
522 :	edgomez	1382	plugins[create.num_plugins].param = &pass2;
523 :			create.num_plugins++;
524 :			break;
525 :
526 :			case RC_MODE_NULL :
527 :			return ICERR_OK;
528 :
529 :			default :
530 :			break;
531 :			}
532 :
533 :			/* zones - copy from tmpCfg in case we automatically altered them above */
534 :			create.zones = malloc(sizeof(xvid_enc_zone_t) * tmpCfg.num_zones);
535 :			create.num_zones = tmpCfg.num_zones;
536 :			for (i=0; i < create.num_zones; i++) {
537 :			create.zones[i].frame = tmpCfg.zones[i].frame;
538 :			if (tmpCfg.zones[i].mode == RC_ZONE_QUANT) {
539 :			create.zones[i].mode = XVID_ZONE_QUANT;
540 :			create.zones[i].increment = tmpCfg.zones[i].quant;
541 :			}else{
542 :			create.zones[i].mode = XVID_ZONE_WEIGHT;
543 :			create.zones[i].increment = tmpCfg.zones[i].weight;
544 :			}
545 :			create.zones[i].base = 100;
546 :			}
547 :
548 :			/* lumimasking plugin */
549 :			if ((profiles[codec->config.profile].flags & PROFILE_ADAPTQUANT) && codec->config.lum_masking) {
550 :	edgomez	1398	plugins[create.num_plugins].func = codec->xvid_plugin_lumimasking_func;
551 :	edgomez	1382	plugins[create.num_plugins].param = NULL;
552 :			create.num_plugins++;
553 :			}
554 :
555 :			plugins[create.num_plugins].func = vfw_debug;
556 :			plugins[create.num_plugins].param = NULL;
557 :			create.num_plugins++;
558 :
559 :			create.profile = profiles[codec->config.profile].id;
560 :
561 :			create.width = lpbiInput->bmiHeader.biWidth;
562 :			create.height = lpbiInput->bmiHeader.biHeight;
563 :			create.fincr = codec->fincr;
564 :			create.fbase = codec->fbase;
565 :
566 :	suxen_drol	1649	create.max_key_interval = quality_preset->max_key_interval;
567 :	edgomez	1382
568 :	suxen_drol	1649	create.min_quant[0] = quality_preset->min_iquant;
569 :			create.max_quant[0] = quality_preset->max_iquant;
570 :			create.min_quant[1] = quality_preset->min_pquant;
571 :			create.max_quant[1] = quality_preset->max_pquant;
572 :			create.min_quant[2] = quality_preset->min_bquant;
573 :			create.max_quant[2] = quality_preset->max_bquant;
574 :	edgomez	1382
575 :			if ((profiles[codec->config.profile].flags & PROFILE_BVOP) && codec->config.use_bvop) {
576 :
577 :	suxen_drol	1607	/* dxn: prevent bframes usage if interlacing is selected */
578 :	Isibaar	1650	if (!((profiles[codec->config.profile].flags & PROFILE_EXTRA) && codec->config.interlacing)) {
579 :	suxen_drol	1607	create.max_bframes = codec->config.max_bframes;
580 :			create.bquant_ratio = codec->config.bquant_ratio;
581 :			create.bquant_offset = codec->config.bquant_offset;
582 :	edgomez	1382
583 :	suxen_drol	1607	if (codec->config.packed)
584 :			create.global \|= XVID_GLOBAL_PACKED;
585 :	edgomez	1382
586 :	suxen_drol	1607	create.global \|= XVID_GLOBAL_CLOSED_GOP;
587 :
588 :	Isibaar	1718	/* restrict max bframes */
589 :			if ((create.max_bframes > profiles[codec->config.profile].xvid_max_bframes) && (profiles[codec->config.profile].xvid_max_bframes >= 0))
590 :			create.max_bframes = profiles[codec->config.profile].xvid_max_bframes;
591 :	suxen_drol	1607
592 :	Isibaar	1718	/* DXN: enable packed bframes */
593 :			if ((profiles[codec->config.profile].flags & PROFILE_PACKED)) {
594 :	suxen_drol	1607	create.global \|= XVID_GLOBAL_PACKED;
595 :			}
596 :			}
597 :	edgomez	1382	}
598 :
599 :	Isibaar	1816	/* dxn: always write divx5 userdata */
600 :			if ((profiles[codec->config.profile].flags & PROFILE_EXTRA))
601 :			create.global \|= XVID_GLOBAL_DIVX5_USERDATA;
602 :	suxen_drol	1607
603 :	suxen_drol	1649	create.frame_drop_ratio = quality_preset->frame_drop_ratio;
604 :	edgomez	1382
605 :	Isibaar	1816	/* Encoder threads */
606 :			if (codec->config.num_threads == 0)
607 :			create.num_threads = info.num_threads; /* Autodetect */
608 :			else if (codec->config.num_threads == 1)
609 :			create.num_threads = -1; /* Single-threaded, disable SMP */
610 :			else
611 :			create.num_threads = codec->config.num_threads;
612 :	edgomez	1382
613 :	Isibaar	1816
614 :	edgomez	1398	switch(codec->xvid_encore_func(0, XVID_ENC_CREATE, &create, NULL))
615 :	edgomez	1382	{
616 :			case XVID_ERR_FAIL :
617 :			return ICERR_ERROR;
618 :
619 :			case XVID_ERR_MEMORY :
620 :			return ICERR_MEMORY;
621 :
622 :			case XVID_ERR_FORMAT :
623 :			return ICERR_BADFORMAT;
624 :
625 :			case XVID_ERR_VERSION :
626 :			return ICERR_UNSUPPORTED;
627 :			}
628 :
629 :	syskin	1477	free(create.zones);
630 :	edgomez	1382	codec->ehandle = create.handle;
631 :			codec->framenum = 0;
632 :			codec->keyspacing = 0;
633 :
634 :			if (codec->config.display_status) {
635 :			status_destroy_always(&codec->status);
636 :			status_create(&codec->status, codec->fincr, codec->fbase);
637 :			}
638 :
639 :			return ICERR_OK;
640 :			}
641 :
642 :
643 :			LRESULT compress_end(CODEC * codec)
644 :			{
645 :	suxen_drol	1685	if (codec==NULL)
646 :			return ICERR_OK;
647 :
648 :	edgomez	1398	if (codec->m_hdll != NULL) {
649 :	edgomez	1382	if (codec->ehandle != NULL) {
650 :	edgomez	1398	codec->xvid_encore_func(codec->ehandle, XVID_ENC_DESTROY, NULL, NULL);
651 :	edgomez	1382	codec->ehandle = NULL;
652 :			}
653 :			}
654 :
655 :			if (codec->config.display_status)
656 :			status_destroy(&codec->status);
657 :
658 :			return ICERR_OK;
659 :			}
660 :
661 :
662 :			static void apply_zone_modifiers(xvid_enc_frame_t * frame, CONFIG * config, int framenum)
663 :			{
664 :			int i;
665 :
666 :			for (i=0; i<config->num_zones && config->zones[i].frame <= framenum; i++) ;
667 :
668 :			if (--i < 0) return; /* there are no zones, or we're before the first zone */
669 :
670 :			if (framenum == config->zones[i].frame)
671 :			frame->type = config->zones[i].type;
672 :
673 :			if (config->zones[i].greyscale) {
674 :			frame->vop_flags \|= XVID_VOP_GREYSCALE;
675 :			}
676 :
677 :			if (config->zones[i].chroma_opt) {
678 :			frame->vop_flags \|= XVID_VOP_CHROMAOPT;
679 :			}
680 :
681 :	syskin	1588	if (config->zones[i].cartoon_mode) {
682 :			frame->vop_flags \|= XVID_VOP_CARTOON;
683 :			frame->motion \|= XVID_ME_DETECT_STATIC_MOTION;
684 :			}
685 :
686 :	edgomez	1382	if ((profiles[config->profile].flags & PROFILE_BVOP) && config->use_bvop) {
687 :			frame->bframe_threshold = config->zones[i].bvop_threshold;
688 :			}
689 :			}
690 :
691 :
692 :	suxen_drol	1495	#define CALC_BI_STRIDE(width,bitcount) ((((width * bitcount) + 31) & ~31) >> 3)
693 :
694 :	edgomez	1382	LRESULT compress(CODEC * codec, ICCOMPRESS * icc)
695 :			{
696 :			BITMAPINFOHEADER * inhdr = icc->lpbiInput;
697 :			BITMAPINFOHEADER * outhdr = icc->lpbiOutput;
698 :			xvid_enc_frame_t frame;
699 :			xvid_enc_stats_t stats;
700 :			int length;
701 :	suxen_drol	1649	const quality_t* quality_preset = (codec->config.quality==quality_table_num) ?
702 :			&codec->config.quality_user : &quality_table[codec->config.quality];
703 :	edgomez	1382
704 :			memset(&frame, 0, sizeof(frame));
705 :			frame.version = XVID_VERSION;
706 :
707 :			frame.type = XVID_TYPE_AUTO;
708 :
709 :			/* vol stuff */
710 :
711 :			if ((profiles[codec->config.profile].flags & PROFILE_MPEGQUANT) &&
712 :			codec->config.quant_type != QUANT_MODE_H263)
713 :			{
714 :			frame.vol_flags \|= XVID_VOL_MPEGQUANT;
715 :
716 :			if (codec->config.quant_type == QUANT_MODE_CUSTOM) {
717 :			frame.quant_intra_matrix = codec->config.qmatrix_intra;
718 :			frame.quant_inter_matrix = codec->config.qmatrix_inter;
719 :			}else{
720 :			frame.quant_intra_matrix = NULL;
721 :			frame.quant_inter_matrix = NULL;
722 :			}
723 :			}
724 :
725 :			if ((profiles[codec->config.profile].flags & PROFILE_QPEL) && codec->config.qpel) {
726 :			frame.vol_flags \|= XVID_VOL_QUARTERPEL;
727 :			frame.motion \|= XVID_ME_QUARTERPELREFINE16 \| XVID_ME_QUARTERPELREFINE8;
728 :			}
729 :
730 :			if ((profiles[codec->config.profile].flags & PROFILE_GMC) && codec->config.gmc) {
731 :			frame.vol_flags \|= XVID_VOL_GMC;
732 :			frame.motion \|= XVID_ME_GME_REFINE;
733 :			}
734 :
735 :			if ((profiles[codec->config.profile].flags & PROFILE_INTERLACE) && codec->config.interlacing)
736 :			frame.vol_flags \|= XVID_VOL_INTERLACING;
737 :
738 :	suxen_drol	1607	/* dxn: force 1:1 picture aspect ration */
739 :	Isibaar	1650	if ((profiles[codec->config.profile].flags & PROFILE_EXTRA)) {
740 :	suxen_drol	1607	frame.par = XVID_PAR_11_VGA;
741 :			} else if (codec->config.ar_mode == 0) { /* PAR */
742 :	edgomez	1382	if (codec->config.display_aspect_ratio != 5) {
743 :			frame.par = codec->config.display_aspect_ratio + 1;
744 :			} else {
745 :			frame.par = XVID_PAR_EXT;
746 :			frame.par_width = codec->config.par_x;
747 :			frame.par_height= codec->config.par_y;
748 :			}
749 :			} else { /* AR */
750 :			/* custom pixel aspect ratio -> calculated from DAR */
751 :			frame.par = XVID_PAR_EXT;
752 :			frame.par_width = (100 * inhdr->biHeight) / codec->config.ar_y;
753 :			frame.par_height= (100 * inhdr->biWidth) / codec->config.ar_x;
754 :			}
755 :
756 :			/* vop stuff */
757 :
758 :			frame.vop_flags \|= XVID_VOP_HALFPEL;
759 :			frame.vop_flags \|= XVID_VOP_HQACPRED;
760 :
761 :	syskin	1487	if (codec->config.interlacing && codec->config.tff)
762 :			frame.vop_flags \|= XVID_VOP_TOPFIELDFIRST;
763 :
764 :
765 :	edgomez	1382	if (codec->config.vop_debug)
766 :			frame.vop_flags \|= XVID_VOP_DEBUG;
767 :
768 :	suxen_drol	1649	if (quality_preset->trellis_quant) {
769 :	edgomez	1382	frame.vop_flags \|= XVID_VOP_TRELLISQUANT;
770 :			}
771 :
772 :	suxen_drol	1607	if ((profiles[codec->config.profile].flags & PROFILE_4MV)) {
773 :	suxen_drol	1649	if (quality_preset->motion_search > 4)
774 :	suxen_drol	1607	frame.vop_flags \|= XVID_VOP_INTER4V;
775 :			}
776 :	edgomez	1382
777 :	suxen_drol	1649	if (quality_preset->chromame)
778 :	edgomez	1382	frame.motion \|= XVID_ME_CHROMA_PVOP + XVID_ME_CHROMA_BVOP;
779 :
780 :	suxen_drol	1649	if (quality_preset->turbo)
781 :	edgomez	1382	frame.motion \|= XVID_ME_FASTREFINE16 \| XVID_ME_FASTREFINE8 \|
782 :			XVID_ME_SKIP_DELTASEARCH \| XVID_ME_FAST_MODEINTERPOLATE \|
783 :			XVID_ME_BFRAME_EARLYSTOP;
784 :
785 :	suxen_drol	1649	frame.motion \|= pmvfast_presets[quality_preset->motion_search];
786 :	edgomez	1382
787 :	suxen_drol	1649	if (quality_preset->vhq_bframe) frame.vop_flags \|= XVID_VOP_RD_BVOP;
788 :	syskin	1510
789 :
790 :	suxen_drol	1649	switch (quality_preset->vhq_mode)
791 :	edgomez	1382	{
792 :			case VHQ_MODE_DECISION :
793 :			frame.vop_flags \|= XVID_VOP_MODEDECISION_RD;
794 :			break;
795 :
796 :			case VHQ_LIMITED_SEARCH :
797 :			frame.vop_flags \|= XVID_VOP_MODEDECISION_RD;
798 :			frame.motion \|= XVID_ME_HALFPELREFINE16_RD;
799 :			frame.motion \|= XVID_ME_QUARTERPELREFINE16_RD;
800 :			break;
801 :
802 :			case VHQ_MEDIUM_SEARCH :
803 :			frame.vop_flags \|= XVID_VOP_MODEDECISION_RD;
804 :			frame.motion \|= XVID_ME_HALFPELREFINE16_RD;
805 :			frame.motion \|= XVID_ME_HALFPELREFINE8_RD;
806 :			frame.motion \|= XVID_ME_QUARTERPELREFINE16_RD;
807 :			frame.motion \|= XVID_ME_QUARTERPELREFINE8_RD;
808 :			frame.motion \|= XVID_ME_CHECKPREDICTION_RD;
809 :			break;
810 :
811 :			case VHQ_WIDE_SEARCH :
812 :			frame.vop_flags \|= XVID_VOP_MODEDECISION_RD;
813 :			frame.motion \|= XVID_ME_HALFPELREFINE16_RD;
814 :			frame.motion \|= XVID_ME_HALFPELREFINE8_RD;
815 :			frame.motion \|= XVID_ME_QUARTERPELREFINE16_RD;
816 :			frame.motion \|= XVID_ME_QUARTERPELREFINE8_RD;
817 :			frame.motion \|= XVID_ME_CHECKPREDICTION_RD;
818 :			frame.motion \|= XVID_ME_EXTSEARCH_RD;
819 :			break;
820 :
821 :			default :
822 :			break;
823 :			}
824 :
825 :			frame.input.plane[0] = icc->lpInput;
826 :	suxen_drol	1495	frame.input.stride[0] = CALC_BI_STRIDE(icc->lpbiInput->biWidth, icc->lpbiInput->biBitCount);
827 :	edgomez	1382
828 :			if ((frame.input.csp = get_colorspace(inhdr)) == XVID_CSP_NULL)
829 :			return ICERR_BADFORMAT;
830 :
831 :			if (frame.input.csp == XVID_CSP_I420 \|\| frame.input.csp == XVID_CSP_YV12) {
832 :			frame.input.stride[0] = (4 * icc->lpbiInput->biWidth + 3) / 4;
833 :			frame.input.stride[1] = frame.input.stride[2] = frame.input.stride[0] / 2 ;
834 :			}
835 :
836 :			frame.bitstream = icc->lpOutput;
837 :			frame.length = icc->lpbiOutput->biSizeImage;
838 :
839 :			frame.quant = 0;
840 :
841 :			if (codec->config.mode == RC_MODE_NULL) {
842 :			outhdr->biSizeImage = 0;
843 :			*icc->lpdwFlags = AVIIF_KEYFRAME;
844 :			return ICERR_OK;
845 :			}
846 :
847 :			// force keyframe spacing in 2-pass 1st pass
848 :	suxen_drol	1649	if (quality_preset->motion_search == 0)
849 :	edgomez	1382	frame.type = XVID_TYPE_IVOP;
850 :
851 :			/* frame-based stuff */
852 :			apply_zone_modifiers(&frame, &codec->config, codec->framenum);
853 :
854 :			/* call encore */
855 :
856 :			memset(&stats, 0, sizeof(stats));
857 :			stats.version = XVID_VERSION;
858 :
859 :	edgomez	1398	length = codec->xvid_encore_func(codec->ehandle, XVID_ENC_ENCODE, &frame, &stats);
860 :	edgomez	1382	switch (length)
861 :			{
862 :			case XVID_ERR_FAIL :
863 :			return ICERR_ERROR;
864 :
865 :			case XVID_ERR_MEMORY :
866 :			return ICERR_MEMORY;
867 :
868 :			case XVID_ERR_FORMAT :
869 :			return ICERR_BADFORMAT;
870 :
871 :			case XVID_ERR_VERSION :
872 :			return ICERR_UNSUPPORTED;
873 :			}
874 :
875 :			if (codec->config.display_status && stats.type>0) {
876 :			status_update(&codec->status, stats.type, stats.length, stats.quant);
877 :			}
878 :
879 :			DPRINTF("{type=%i len=%i} length=%i", stats.type, stats.length, length);
880 :
881 :			if (length == 0) /* no encoder output */
882 :			{
883 :			*icc->lpdwFlags = 0;
884 :			((char)icc->lpOutput)[0] = 0x7f; / virtual dub skip frame */
885 :			outhdr->biSizeImage = 1;
886 :
887 :			}else{
888 :			if (frame.out_flags & XVID_KEYFRAME)
889 :			{
890 :			codec->keyspacing = 0;
891 :			*icc->lpdwFlags = AVIIF_KEYFRAME;
892 :			}
893 :			else
894 :			{
895 :			*icc->lpdwFlags = 0;
896 :			}
897 :
898 :			outhdr->biSizeImage = length;
899 :
900 :			if (codec->config.mode == RC_MODE_2PASS1 && codec->config.discard1pass)
901 :			{
902 :			outhdr->biSizeImage = 0;
903 :			}
904 :			}
905 :
906 :			codec->framenum++;
907 :			codec->keyspacing++;
908 :
909 :			return ICERR_OK;
910 :			}
911 :
912 :
913 :			/* decompressor */
914 :
915 :
916 :			LRESULT decompress_query(CODEC * codec, BITMAPINFO lpbiInput, BITMAPINFO lpbiOutput)
917 :			{
918 :			BITMAPINFOHEADER * inhdr = &lpbiInput->bmiHeader;
919 :			BITMAPINFOHEADER * outhdr = &lpbiOutput->bmiHeader;
920 :
921 :			if (lpbiInput == NULL)
922 :			{
923 :			return ICERR_ERROR;
924 :			}
925 :
926 :			if (inhdr->biCompression != FOURCC_XVID && inhdr->biCompression != FOURCC_DIVX && inhdr->biCompression != FOURCC_DX50 && get_colorspace(inhdr) == XVID_CSP_NULL)
927 :			{
928 :			return ICERR_BADFORMAT;
929 :			}
930 :
931 :			if (lpbiOutput == NULL)
932 :			{
933 :			return ICERR_OK;
934 :			}
935 :
936 :			if (inhdr->biWidth != outhdr->biWidth \|\|
937 :			inhdr->biHeight != outhdr->biHeight \|\|
938 :			get_colorspace(outhdr) == XVID_CSP_NULL)
939 :			{
940 :			return ICERR_BADFORMAT;
941 :			}
942 :
943 :			return ICERR_OK;
944 :			}
945 :
946 :
947 :			LRESULT decompress_get_format(CODEC * codec, BITMAPINFO * lpbiInput, BITMAPINFO * lpbiOutput)
948 :			{
949 :			BITMAPINFOHEADER * inhdr = &lpbiInput->bmiHeader;
950 :			BITMAPINFOHEADER * outhdr = &lpbiOutput->bmiHeader;
951 :			LRESULT result;
952 :
953 :			if (lpbiOutput == NULL)
954 :			{
955 :			return sizeof(BITMAPINFOHEADER);
956 :			}
957 :
958 :			/* --- yv12 --- */
959 :
960 :			if (get_colorspace(inhdr) != XVID_CSP_NULL) {
961 :			memcpy(outhdr, inhdr, sizeof(BITMAPINFOHEADER));
962 :			/* XXX: should we set outhdr->biSize ?? */
963 :			return ICERR_OK;
964 :			}
965 :			/* --- yv12 --- */
966 :
967 :			result = decompress_query(codec, lpbiInput, lpbiOutput);
968 :			if (result != ICERR_OK)
969 :			{
970 :			return result;
971 :			}
972 :
973 :			outhdr->biSize = sizeof(BITMAPINFOHEADER);
974 :			outhdr->biWidth = inhdr->biWidth;
975 :			outhdr->biHeight = inhdr->biHeight;
976 :			outhdr->biPlanes = 1;
977 :			outhdr->biBitCount = 24;
978 :			outhdr->biCompression = BI_RGB; /* sonic foundry vegas video v3 only supports BI_RGB */
979 :	suxen_drol	1495	outhdr->biSizeImage = outhdr->biHeight * CALC_BI_STRIDE(outhdr->biWidth, outhdr->biBitCount);
980 :
981 :	edgomez	1382	outhdr->biXPelsPerMeter = 0;
982 :			outhdr->biYPelsPerMeter = 0;
983 :			outhdr->biClrUsed = 0;
984 :			outhdr->biClrImportant = 0;
985 :
986 :			return ICERR_OK;
987 :			}
988 :
989 :			#define REG_GET_N(X, Y, Z) \
990 :			{ \
991 :			DWORD size = sizeof(int); \
992 :			if (RegQueryValueEx(hKey, X, 0, 0, (LPBYTE)&Y, &size) != ERROR_SUCCESS) { \
993 :			Y=Z; \
994 :			} \
995 :			}while(0)
996 :
997 :			LRESULT decompress_begin(CODEC * codec, BITMAPINFO * lpbiInput, BITMAPINFO * lpbiOutput)
998 :			{
999 :			xvid_gbl_init_t init;
1000 :			xvid_dec_create_t create;
1001 :			HKEY hKey;
1002 :
1003 :	edgomez	1398	if (init_dll(codec) != 0) return ICERR_ERROR;
1004 :	edgomez	1382
1005 :			memset(&init, 0, sizeof(init));
1006 :			init.version = XVID_VERSION;
1007 :			init.cpu_flags = codec->config.cpu;
1008 :	suxen_drol	1597	init.debug = codec->config.debug;
1009 :	edgomez	1398	codec->xvid_global_func(0, XVID_GBL_INIT, &init, NULL);
1010 :	edgomez	1382
1011 :			memset(&create, 0, sizeof(create));
1012 :			create.version = XVID_VERSION;
1013 :			create.width = lpbiInput->bmiHeader.biWidth;
1014 :			create.height = lpbiInput->bmiHeader.biHeight;
1015 :
1016 :	edgomez	1398	switch(codec->xvid_decore_func(0, XVID_DEC_CREATE, &create, NULL))
1017 :	edgomez	1382	{
1018 :			case XVID_ERR_FAIL :
1019 :			return ICERR_ERROR;
1020 :
1021 :			case XVID_ERR_MEMORY :
1022 :			return ICERR_MEMORY;
1023 :
1024 :			case XVID_ERR_FORMAT :
1025 :			return ICERR_BADFORMAT;
1026 :
1027 :			case XVID_ERR_VERSION :
1028 :			return ICERR_UNSUPPORTED;
1029 :			}
1030 :
1031 :			codec->dhandle = create.handle;
1032 :
1033 :			RegOpenKeyEx(XVID_REG_KEY, XVID_REG_PARENT "\\" XVID_REG_CHILD, 0, KEY_READ, &hKey);
1034 :
1035 :	suxen_drol	1397	REG_GET_N("Brightness", pp_brightness, 0);
1036 :	edgomez	1382	REG_GET_N("Deblock_Y", pp_dy, 0)
1037 :			REG_GET_N("Deblock_UV", pp_duv, 0)
1038 :	syskin	1437	REG_GET_N("Dering_Y", pp_dry, 0)
1039 :			REG_GET_N("Dering_UV", pp_druv, 0)
1040 :	edgomez	1382	REG_GET_N("FilmEffect", pp_fe, 0)
1041 :
1042 :			RegCloseKey(hKey);
1043 :
1044 :			return ICERR_OK;
1045 :			}
1046 :
1047 :
1048 :			LRESULT decompress_end(CODEC * codec)
1049 :			{
1050 :	edgomez	1398	if (codec->m_hdll != NULL) {
1051 :	edgomez	1382	if (codec->dhandle != NULL) {
1052 :	edgomez	1398	codec->xvid_decore_func(codec->dhandle, XVID_DEC_DESTROY, NULL, NULL);
1053 :	edgomez	1382	codec->dhandle = NULL;
1054 :			}
1055 :			}
1056 :
1057 :			return ICERR_OK;
1058 :			}
1059 :
1060 :
1061 :			LRESULT decompress(CODEC * codec, ICDECOMPRESS * icd)
1062 :			{
1063 :			xvid_dec_frame_t frame;
1064 :
1065 :			/* --- yv12 --- */
1066 :			if (icd->lpbiInput->biCompression != FOURCC_XVID &&
1067 :			icd->lpbiInput->biCompression != FOURCC_DIVX &&
1068 :			icd->lpbiInput->biCompression != FOURCC_DX50)
1069 :			{
1070 :			xvid_gbl_convert_t convert;
1071 :
1072 :			DPRINTF("input=%c%c%c%c output=%c%c%c%c",
1073 :			icd->lpbiInput->biCompression&0xff,
1074 :			(icd->lpbiInput->biCompression>>8)&0xff,
1075 :			(icd->lpbiInput->biCompression>>16)&0xff,
1076 :			(icd->lpbiInput->biCompression>>24)&0xff,
1077 :			icd->lpbiOutput->biCompression&0xff,
1078 :			(icd->lpbiOutput->biCompression>>8)&0xff,
1079 :			(icd->lpbiOutput->biCompression>>16)&0xff,
1080 :			(icd->lpbiOutput->biCompression>>24)&0xff);
1081 :
1082 :			memset(&convert, 0, sizeof(convert));
1083 :			convert.version = XVID_VERSION;
1084 :
1085 :			convert.input.csp = get_colorspace(icd->lpbiInput);
1086 :			convert.input.plane[0] = icd->lpInput;
1087 :	suxen_drol	1495	convert.input.stride[0] = CALC_BI_STRIDE(icd->lpbiInput->biWidth, icd->lpbiInput->biBitCount);
1088 :	edgomez	1382	if (convert.input.csp == XVID_CSP_I420 \|\| convert.input.csp == XVID_CSP_YV12)
1089 :			convert.input.stride[0] = (convert.input.stride[0]*2)/3;
1090 :
1091 :			convert.output.csp = get_colorspace(icd->lpbiOutput);
1092 :			convert.output.plane[0] = icd->lpOutput;
1093 :	suxen_drol	1495	convert.output.stride[0] = CALC_BI_STRIDE(icd->lpbiOutput->biWidth, icd->lpbiOutput->biBitCount);
1094 :	edgomez	1382	if (convert.output.csp == XVID_CSP_I420 \|\| convert.output.csp == XVID_CSP_YV12)
1095 :			convert.output.stride[0] = (convert.output.stride[0]*2)/3;
1096 :
1097 :			convert.width = icd->lpbiInput->biWidth;
1098 :			convert.height = icd->lpbiInput->biHeight;
1099 :			convert.interlacing = 0;
1100 :			if (convert.input.csp == XVID_CSP_NULL \|\|
1101 :			convert.output.csp == XVID_CSP_NULL \|\|
1102 :	edgomez	1398	codec->xvid_global_func(0, XVID_GBL_CONVERT, &convert, NULL) < 0)
1103 :	edgomez	1382	{
1104 :			return ICERR_BADFORMAT;
1105 :			}
1106 :			return ICERR_OK;
1107 :			}
1108 :			/* --- yv12 --- */
1109 :
1110 :			memset(&frame, 0, sizeof(frame));
1111 :			frame.version = XVID_VERSION;
1112 :			frame.general = XVID_LOWDELAY; /* force low_delay_default mode */
1113 :			frame.bitstream = icd->lpInput;
1114 :			frame.length = icd->lpbiInput->biSizeImage;
1115 :
1116 :			if (~((icd->dwFlags & ICDECOMPRESS_HURRYUP) \| (icd->dwFlags & ICDECOMPRESS_UPDATE) \| (icd->dwFlags & ICDECOMPRESS_PREROLL)))
1117 :			{
1118 :			if ((frame.output.csp = get_colorspace(icd->lpbiOutput)) == XVID_CSP_NULL)
1119 :			{
1120 :			return ICERR_BADFORMAT;
1121 :			}
1122 :			frame.output.plane[0] = icd->lpOutput;
1123 :	suxen_drol	1495	frame.output.stride[0] = CALC_BI_STRIDE(icd->lpbiOutput->biWidth, icd->lpbiOutput->biBitCount);
1124 :	edgomez	1382	if (frame.output.csp == XVID_CSP_I420 \|\| frame.output.csp == XVID_CSP_YV12)
1125 :	suxen_drol	1558	frame.output.stride[0] = CALC_BI_STRIDE(icd->lpbiOutput->biWidth, 8);
1126 :	edgomez	1382	}
1127 :			else
1128 :			{
1129 :			frame.output.csp = XVID_CSP_NULL;
1130 :			}
1131 :
1132 :			if (pp_dy)frame.general \|= XVID_DEBLOCKY;
1133 :			if (pp_duv) frame.general \|= XVID_DEBLOCKUV;
1134 :	syskin	1437	if (pp_dry) frame.general \|= XVID_DERINGY;
1135 :			if (pp_druv) frame.general \|= XVID_DERINGUV;
1136 :	edgomez	1382	if (pp_fe) frame.general \|= XVID_FILMEFFECT;
1137 :
1138 :	suxen_drol	1397	frame.brightness = pp_brightness;
1139 :
1140 :	edgomez	1398	switch (codec->xvid_decore_func(codec->dhandle, XVID_DEC_DECODE, &frame, NULL))
1141 :	edgomez	1382	{
1142 :			case XVID_ERR_FAIL :
1143 :			return ICERR_ERROR;
1144 :
1145 :			case XVID_ERR_MEMORY :
1146 :			return ICERR_MEMORY;
1147 :
1148 :			case XVID_ERR_FORMAT :
1149 :			return ICERR_BADFORMAT;
1150 :
1151 :			case XVID_ERR_VERSION :
1152 :			return ICERR_UNSUPPORTED;
1153 :			}
1154 :
1155 :			return ICERR_OK;
1156 :			}
1157 :

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