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

Revision 2020 - (view) (download)

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

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