[svn] / trunk / xvidcore / vfw / src / codec.c Repository:
ViewVC logotype

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1562 - (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 :     int i;
425 :     HANDLE hFile;
426 :    
427 :     CONFIG tmpCfg; /* if we want to alter config to suit our needs, it shouldn't be visible to user later */
428 :     memcpy(&tmpCfg, &codec->config, sizeof(CONFIG));
429 :    
430 : edgomez 1398 if (init_dll(codec) != 0) return ICERR_ERROR;
431 : edgomez 1382 /* destroy previously created codec */
432 :     if(codec->ehandle) {
433 : edgomez 1398 codec->xvid_encore_func(codec->ehandle, XVID_ENC_DESTROY, NULL, NULL);
434 : edgomez 1382 codec->ehandle = NULL;
435 :     }
436 :    
437 :     memset(&init, 0, sizeof(init));
438 :     init.version = XVID_VERSION;
439 :     init.cpu_flags = codec->config.cpu;
440 :     init.debug = codec->config.debug;
441 : edgomez 1398 codec->xvid_global_func(0, XVID_GBL_INIT, &init, NULL);
442 : edgomez 1382
443 :     memset(&create, 0, sizeof(create));
444 :     create.version = XVID_VERSION;
445 :    
446 :     /* plugins */
447 :     create.plugins = plugins;
448 :     switch (codec->config.mode)
449 :     {
450 :     case RC_MODE_1PASS :
451 :     memset(&single, 0, sizeof(single));
452 :     single.version = XVID_VERSION;
453 :     single.bitrate = codec->config.bitrate * CONFIG_KBPS;
454 :     single.reaction_delay_factor = codec->config.rc_reaction_delay_factor;
455 :     single.averaging_period = codec->config.rc_averaging_period;
456 :     single.buffer = codec->config.rc_buffer;
457 : edgomez 1398 plugins[create.num_plugins].func = codec->xvid_plugin_single_func;
458 : edgomez 1382 plugins[create.num_plugins].param = &single;
459 :     create.num_plugins++;
460 :     if (!codec->config.use_2pass_bitrate) /* constant-quant mode */
461 :     prepare_cquant_zones(&tmpCfg);
462 :     break;
463 :    
464 :     case RC_MODE_2PASS1 :
465 :     memset(&pass1, 0, sizeof(pass1));
466 :     pass1.version = XVID_VERSION;
467 :     pass1.filename = codec->config.stats;
468 :     if (codec->config.full1pass)
469 :     prepare_full1pass_zones(&tmpCfg);
470 : edgomez 1398 plugins[create.num_plugins].func = codec->xvid_plugin_2pass1_func;
471 : edgomez 1382 plugins[create.num_plugins].param = &pass1;
472 :     create.num_plugins++;
473 :     break;
474 :    
475 :     case RC_MODE_2PASS2 :
476 :     memset(&pass2, 0, sizeof(pass2));
477 :     pass2.version = XVID_VERSION;
478 :     if (codec->config.use_2pass_bitrate) {
479 :     pass2.bitrate = codec->config.bitrate * CONFIG_KBPS;
480 :     } else {
481 :     pass2.bitrate = -codec->config.desired_size; /* kilobytes */
482 :     }
483 :     pass2.filename = codec->config.stats;
484 :    
485 :     hFile = CreateFile(pass2.filename, 0, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
486 :     if (hFile == INVALID_HANDLE_VALUE)
487 :     {
488 :     MessageBox(0, "Statsfile not found!","Error!", MB_ICONEXCLAMATION|MB_OK);
489 :     return XVID_ERR_FAIL;
490 :     } else
491 :     {
492 :     CloseHandle(hFile);
493 :     }
494 :    
495 :     pass2.keyframe_boost = codec->config.keyframe_boost; /* keyframe boost percentage: [0..100...]; */
496 :     pass2.curve_compression_high = codec->config.curve_compression_high;
497 :     pass2.curve_compression_low = codec->config.curve_compression_low;
498 :     pass2.overflow_control_strength = codec->config.overflow_control_strength;
499 :     pass2.max_overflow_improvement = codec->config.twopass_max_overflow_improvement;
500 :     pass2.max_overflow_degradation = codec->config.twopass_max_overflow_degradation;
501 :     pass2.kfreduction = codec->config.kfreduction;
502 :     pass2.kfthreshold = codec->config.kfthreshold;
503 :     pass2.container_frame_overhead = 24; /* AVI */
504 :    
505 : syskin 1562 /* VBV */
506 :     pass2.vbv_size = profiles[codec->config.profile].max_vbv_size;
507 :     pass2.vbv_initial = (profiles[codec->config.profile].max_vbv_size*3)/4;
508 :     pass2.vbv_maxrate = 1000*profiles[codec->config.profile].max_bitrate;
509 :     pass2.vbv_peakrate = 10000000; /* 10mbps -- fixme */
510 :    
511 : edgomez 1398 plugins[create.num_plugins].func = codec->xvid_plugin_2pass2_func;
512 : edgomez 1382 plugins[create.num_plugins].param = &pass2;
513 :     create.num_plugins++;
514 :     break;
515 :    
516 :     case RC_MODE_NULL :
517 :     return ICERR_OK;
518 :    
519 :     default :
520 :     break;
521 :     }
522 :    
523 :     /* zones - copy from tmpCfg in case we automatically altered them above */
524 :     create.zones = malloc(sizeof(xvid_enc_zone_t) * tmpCfg.num_zones);
525 :     create.num_zones = tmpCfg.num_zones;
526 :     for (i=0; i < create.num_zones; i++) {
527 :     create.zones[i].frame = tmpCfg.zones[i].frame;
528 :     if (tmpCfg.zones[i].mode == RC_ZONE_QUANT) {
529 :     create.zones[i].mode = XVID_ZONE_QUANT;
530 :     create.zones[i].increment = tmpCfg.zones[i].quant;
531 :     }else{
532 :     create.zones[i].mode = XVID_ZONE_WEIGHT;
533 :     create.zones[i].increment = tmpCfg.zones[i].weight;
534 :     }
535 :     create.zones[i].base = 100;
536 :     }
537 :    
538 :     /* lumimasking plugin */
539 :     if ((profiles[codec->config.profile].flags & PROFILE_ADAPTQUANT) && codec->config.lum_masking) {
540 : edgomez 1398 plugins[create.num_plugins].func = codec->xvid_plugin_lumimasking_func;
541 : edgomez 1382 plugins[create.num_plugins].param = NULL;
542 :     create.num_plugins++;
543 :     }
544 :    
545 :     plugins[create.num_plugins].func = vfw_debug;
546 :     plugins[create.num_plugins].param = NULL;
547 :     create.num_plugins++;
548 :    
549 :     create.profile = profiles[codec->config.profile].id;
550 :    
551 :     create.width = lpbiInput->bmiHeader.biWidth;
552 :     create.height = lpbiInput->bmiHeader.biHeight;
553 :     create.fincr = codec->fincr;
554 :     create.fbase = codec->fbase;
555 :    
556 :     create.max_key_interval = codec->config.max_key_interval;
557 :    
558 :     create.min_quant[0] = codec->config.min_iquant;
559 :     create.max_quant[0] = codec->config.max_iquant;
560 :     create.min_quant[1] = codec->config.min_pquant;
561 :     create.max_quant[1] = codec->config.max_pquant;
562 :     create.min_quant[2] = codec->config.min_bquant;
563 :     create.max_quant[2] = codec->config.max_bquant;
564 :    
565 :     if ((profiles[codec->config.profile].flags & PROFILE_BVOP) && codec->config.use_bvop) {
566 :     create.max_bframes = codec->config.max_bframes;
567 :     create.bquant_ratio = codec->config.bquant_ratio;
568 :     create.bquant_offset = codec->config.bquant_offset;
569 :    
570 :     if (codec->config.packed)
571 :     create.global |= XVID_GLOBAL_PACKED;
572 :    
573 :     if (codec->config.closed_gov)
574 :     create.global |= XVID_GLOBAL_CLOSED_GOP;
575 :    
576 :     }
577 :    
578 :     create.frame_drop_ratio = codec->config.frame_drop_ratio;
579 :    
580 :     create.num_threads = codec->config.num_threads;
581 :    
582 : edgomez 1398 switch(codec->xvid_encore_func(0, XVID_ENC_CREATE, &create, NULL))
583 : edgomez 1382 {
584 :     case XVID_ERR_FAIL :
585 :     return ICERR_ERROR;
586 :    
587 :     case XVID_ERR_MEMORY :
588 :     return ICERR_MEMORY;
589 :    
590 :     case XVID_ERR_FORMAT :
591 :     return ICERR_BADFORMAT;
592 :    
593 :     case XVID_ERR_VERSION :
594 :     return ICERR_UNSUPPORTED;
595 :     }
596 :    
597 : syskin 1477 free(create.zones);
598 : edgomez 1382 codec->ehandle = create.handle;
599 :     codec->framenum = 0;
600 :     codec->keyspacing = 0;
601 :    
602 :     if (codec->config.display_status) {
603 :     status_destroy_always(&codec->status);
604 :     status_create(&codec->status, codec->fincr, codec->fbase);
605 :     }
606 :    
607 :     return ICERR_OK;
608 :     }
609 :    
610 :    
611 :     LRESULT compress_end(CODEC * codec)
612 :     {
613 : edgomez 1398 if (codec->m_hdll != NULL) {
614 : edgomez 1382 if (codec->ehandle != NULL) {
615 : edgomez 1398 codec->xvid_encore_func(codec->ehandle, XVID_ENC_DESTROY, NULL, NULL);
616 : edgomez 1382 codec->ehandle = NULL;
617 :     }
618 :     }
619 :    
620 :     if (codec->config.display_status)
621 :     status_destroy(&codec->status);
622 :    
623 :     return ICERR_OK;
624 :     }
625 :    
626 :    
627 :     static void apply_zone_modifiers(xvid_enc_frame_t * frame, CONFIG * config, int framenum)
628 :     {
629 :     int i;
630 :    
631 :     for (i=0; i<config->num_zones && config->zones[i].frame <= framenum; i++) ;
632 :    
633 :     if (--i < 0) return; /* there are no zones, or we're before the first zone */
634 :    
635 :     if (framenum == config->zones[i].frame)
636 :     frame->type = config->zones[i].type;
637 :    
638 :     if (config->zones[i].greyscale) {
639 :     frame->vop_flags |= XVID_VOP_GREYSCALE;
640 :     }
641 :    
642 :     if (config->zones[i].chroma_opt) {
643 :     frame->vop_flags |= XVID_VOP_CHROMAOPT;
644 :     }
645 :    
646 :     if ((profiles[config->profile].flags & PROFILE_BVOP) && config->use_bvop) {
647 :     frame->bframe_threshold = config->zones[i].bvop_threshold;
648 :     }
649 :     }
650 :    
651 :    
652 : suxen_drol 1495 #define CALC_BI_STRIDE(width,bitcount) ((((width * bitcount) + 31) & ~31) >> 3)
653 :    
654 : edgomez 1382 LRESULT compress(CODEC * codec, ICCOMPRESS * icc)
655 :     {
656 :     BITMAPINFOHEADER * inhdr = icc->lpbiInput;
657 :     BITMAPINFOHEADER * outhdr = icc->lpbiOutput;
658 :     xvid_enc_frame_t frame;
659 :     xvid_enc_stats_t stats;
660 :     int length;
661 :    
662 :     memset(&frame, 0, sizeof(frame));
663 :     frame.version = XVID_VERSION;
664 :    
665 :     frame.type = XVID_TYPE_AUTO;
666 :    
667 :     /* vol stuff */
668 :    
669 :     if ((profiles[codec->config.profile].flags & PROFILE_MPEGQUANT) &&
670 :     codec->config.quant_type != QUANT_MODE_H263)
671 :     {
672 :     frame.vol_flags |= XVID_VOL_MPEGQUANT;
673 :    
674 :     if (codec->config.quant_type == QUANT_MODE_CUSTOM) {
675 :     frame.quant_intra_matrix = codec->config.qmatrix_intra;
676 :     frame.quant_inter_matrix = codec->config.qmatrix_inter;
677 :     }else{
678 :     frame.quant_intra_matrix = NULL;
679 :     frame.quant_inter_matrix = NULL;
680 :     }
681 :     }
682 :    
683 :     if ((profiles[codec->config.profile].flags & PROFILE_REDUCED) &&
684 :     codec->config.reduced_resolution) {
685 :     frame.vol_flags |= XVID_VOL_REDUCED_ENABLE;
686 :     frame.vop_flags |= XVID_VOP_REDUCED; /* XXX: need auto decion mode */
687 :     }
688 :    
689 :     if ((profiles[codec->config.profile].flags & PROFILE_QPEL) && codec->config.qpel) {
690 :     frame.vol_flags |= XVID_VOL_QUARTERPEL;
691 :     frame.motion |= XVID_ME_QUARTERPELREFINE16 | XVID_ME_QUARTERPELREFINE8;
692 :     }
693 :    
694 :     if ((profiles[codec->config.profile].flags & PROFILE_GMC) && codec->config.gmc) {
695 :     frame.vol_flags |= XVID_VOL_GMC;
696 :     frame.motion |= XVID_ME_GME_REFINE;
697 :     }
698 :    
699 :     if ((profiles[codec->config.profile].flags & PROFILE_INTERLACE) && codec->config.interlacing)
700 :     frame.vol_flags |= XVID_VOL_INTERLACING;
701 :    
702 :     if (codec->config.ar_mode == 0) { /* PAR */
703 :     if (codec->config.display_aspect_ratio != 5) {
704 :     frame.par = codec->config.display_aspect_ratio + 1;
705 :     } else {
706 :     frame.par = XVID_PAR_EXT;
707 :     frame.par_width = codec->config.par_x;
708 :     frame.par_height= codec->config.par_y;
709 :     }
710 :     } else { /* AR */
711 :     /* custom pixel aspect ratio -> calculated from DAR */
712 :     frame.par = XVID_PAR_EXT;
713 :     frame.par_width = (100 * inhdr->biHeight) / codec->config.ar_y;
714 :     frame.par_height= (100 * inhdr->biWidth) / codec->config.ar_x;
715 :     }
716 :    
717 :     /* vop stuff */
718 :    
719 :     frame.vop_flags |= XVID_VOP_HALFPEL;
720 :     frame.vop_flags |= XVID_VOP_HQACPRED;
721 :    
722 : syskin 1487 if (codec->config.interlacing && codec->config.tff)
723 :     frame.vop_flags |= XVID_VOP_TOPFIELDFIRST;
724 :    
725 :    
726 : edgomez 1382 if (codec->config.vop_debug)
727 :     frame.vop_flags |= XVID_VOP_DEBUG;
728 :    
729 :     if (codec->config.trellis_quant) {
730 :     frame.vop_flags |= XVID_VOP_TRELLISQUANT;
731 :     }
732 :    
733 :     if (codec->config.motion_search > 4)
734 :     frame.vop_flags |= XVID_VOP_INTER4V;
735 :    
736 :     if (codec->config.chromame)
737 :     frame.motion |= XVID_ME_CHROMA_PVOP + XVID_ME_CHROMA_BVOP;
738 :    
739 :     if (codec->config.cartoon_mode) {
740 :     frame.vop_flags |= XVID_VOP_CARTOON;
741 :     frame.motion |= XVID_ME_DETECT_STATIC_MOTION;
742 :     }
743 :    
744 :     if (codec->config.turbo)
745 :     frame.motion |= XVID_ME_FASTREFINE16 | XVID_ME_FASTREFINE8 |
746 :     XVID_ME_SKIP_DELTASEARCH | XVID_ME_FAST_MODEINTERPOLATE |
747 :     XVID_ME_BFRAME_EARLYSTOP;
748 :    
749 :     frame.motion |= pmvfast_presets[codec->config.motion_search];
750 :    
751 : syskin 1510 if (codec->config.vhq_bframe) frame.vop_flags |= XVID_VOP_RD_BVOP;
752 :    
753 :    
754 : edgomez 1382 switch (codec->config.vhq_mode)
755 :     {
756 :     case VHQ_MODE_DECISION :
757 :     frame.vop_flags |= XVID_VOP_MODEDECISION_RD;
758 :     break;
759 :    
760 :     case VHQ_LIMITED_SEARCH :
761 :     frame.vop_flags |= XVID_VOP_MODEDECISION_RD;
762 :     frame.motion |= XVID_ME_HALFPELREFINE16_RD;
763 :     frame.motion |= XVID_ME_QUARTERPELREFINE16_RD;
764 :     break;
765 :    
766 :     case VHQ_MEDIUM_SEARCH :
767 :     frame.vop_flags |= XVID_VOP_MODEDECISION_RD;
768 :     frame.motion |= XVID_ME_HALFPELREFINE16_RD;
769 :     frame.motion |= XVID_ME_HALFPELREFINE8_RD;
770 :     frame.motion |= XVID_ME_QUARTERPELREFINE16_RD;
771 :     frame.motion |= XVID_ME_QUARTERPELREFINE8_RD;
772 :     frame.motion |= XVID_ME_CHECKPREDICTION_RD;
773 :     break;
774 :    
775 :     case VHQ_WIDE_SEARCH :
776 :     frame.vop_flags |= XVID_VOP_MODEDECISION_RD;
777 :     frame.motion |= XVID_ME_HALFPELREFINE16_RD;
778 :     frame.motion |= XVID_ME_HALFPELREFINE8_RD;
779 :     frame.motion |= XVID_ME_QUARTERPELREFINE16_RD;
780 :     frame.motion |= XVID_ME_QUARTERPELREFINE8_RD;
781 :     frame.motion |= XVID_ME_CHECKPREDICTION_RD;
782 :     frame.motion |= XVID_ME_EXTSEARCH_RD;
783 :     break;
784 :    
785 :     default :
786 :     break;
787 :     }
788 :    
789 :     frame.input.plane[0] = icc->lpInput;
790 : suxen_drol 1495 frame.input.stride[0] = CALC_BI_STRIDE(icc->lpbiInput->biWidth, icc->lpbiInput->biBitCount);
791 : edgomez 1382
792 :     if ((frame.input.csp = get_colorspace(inhdr)) == XVID_CSP_NULL)
793 :     return ICERR_BADFORMAT;
794 :    
795 :     if (frame.input.csp == XVID_CSP_I420 || frame.input.csp == XVID_CSP_YV12) {
796 :     frame.input.stride[0] = (4 * icc->lpbiInput->biWidth + 3) / 4;
797 :     frame.input.stride[1] = frame.input.stride[2] = frame.input.stride[0] / 2 ;
798 :     }
799 :    
800 :     frame.bitstream = icc->lpOutput;
801 :     frame.length = icc->lpbiOutput->biSizeImage;
802 :    
803 :     frame.quant = 0;
804 :    
805 :     if (codec->config.mode == RC_MODE_NULL) {
806 :     outhdr->biSizeImage = 0;
807 :     *icc->lpdwFlags = AVIIF_KEYFRAME;
808 :     return ICERR_OK;
809 :     }
810 :    
811 :     // force keyframe spacing in 2-pass 1st pass
812 :     if (codec->config.motion_search == 0)
813 :     frame.type = XVID_TYPE_IVOP;
814 :    
815 :     /* frame-based stuff */
816 :     apply_zone_modifiers(&frame, &codec->config, codec->framenum);
817 :    
818 :     /* call encore */
819 :    
820 :     memset(&stats, 0, sizeof(stats));
821 :     stats.version = XVID_VERSION;
822 :    
823 : edgomez 1398 length = codec->xvid_encore_func(codec->ehandle, XVID_ENC_ENCODE, &frame, &stats);
824 : edgomez 1382 switch (length)
825 :     {
826 :     case XVID_ERR_FAIL :
827 :     return ICERR_ERROR;
828 :    
829 :     case XVID_ERR_MEMORY :
830 :     return ICERR_MEMORY;
831 :    
832 :     case XVID_ERR_FORMAT :
833 :     return ICERR_BADFORMAT;
834 :    
835 :     case XVID_ERR_VERSION :
836 :     return ICERR_UNSUPPORTED;
837 :     }
838 :    
839 :     if (codec->config.display_status && stats.type>0) {
840 :     status_update(&codec->status, stats.type, stats.length, stats.quant);
841 :     }
842 :    
843 :     DPRINTF("{type=%i len=%i} length=%i", stats.type, stats.length, length);
844 :    
845 :     if (length == 0) /* no encoder output */
846 :     {
847 :     *icc->lpdwFlags = 0;
848 :     ((char*)icc->lpOutput)[0] = 0x7f; /* virtual dub skip frame */
849 :     outhdr->biSizeImage = 1;
850 :    
851 :     }else{
852 :     if (frame.out_flags & XVID_KEYFRAME)
853 :     {
854 :     codec->keyspacing = 0;
855 :     *icc->lpdwFlags = AVIIF_KEYFRAME;
856 :     }
857 :     else
858 :     {
859 :     *icc->lpdwFlags = 0;
860 :     }
861 :    
862 :     outhdr->biSizeImage = length;
863 :    
864 :     if (codec->config.mode == RC_MODE_2PASS1 && codec->config.discard1pass)
865 :     {
866 :     outhdr->biSizeImage = 0;
867 :     }
868 :     }
869 :    
870 :     codec->framenum++;
871 :     codec->keyspacing++;
872 :    
873 :     return ICERR_OK;
874 :     }
875 :    
876 :    
877 :     /* decompressor */
878 :    
879 :    
880 :     LRESULT decompress_query(CODEC * codec, BITMAPINFO *lpbiInput, BITMAPINFO *lpbiOutput)
881 :     {
882 :     BITMAPINFOHEADER * inhdr = &lpbiInput->bmiHeader;
883 :     BITMAPINFOHEADER * outhdr = &lpbiOutput->bmiHeader;
884 :    
885 :     if (lpbiInput == NULL)
886 :     {
887 :     return ICERR_ERROR;
888 :     }
889 :    
890 :     if (inhdr->biCompression != FOURCC_XVID && inhdr->biCompression != FOURCC_DIVX && inhdr->biCompression != FOURCC_DX50 && get_colorspace(inhdr) == XVID_CSP_NULL)
891 :     {
892 :     return ICERR_BADFORMAT;
893 :     }
894 :    
895 :     if (lpbiOutput == NULL)
896 :     {
897 :     return ICERR_OK;
898 :     }
899 :    
900 :     if (inhdr->biWidth != outhdr->biWidth ||
901 :     inhdr->biHeight != outhdr->biHeight ||
902 :     get_colorspace(outhdr) == XVID_CSP_NULL)
903 :     {
904 :     return ICERR_BADFORMAT;
905 :     }
906 :    
907 :     return ICERR_OK;
908 :     }
909 :    
910 :    
911 :     LRESULT decompress_get_format(CODEC * codec, BITMAPINFO * lpbiInput, BITMAPINFO * lpbiOutput)
912 :     {
913 :     BITMAPINFOHEADER * inhdr = &lpbiInput->bmiHeader;
914 :     BITMAPINFOHEADER * outhdr = &lpbiOutput->bmiHeader;
915 :     LRESULT result;
916 :    
917 :     if (lpbiOutput == NULL)
918 :     {
919 :     return sizeof(BITMAPINFOHEADER);
920 :     }
921 :    
922 :     /* --- yv12 --- */
923 :    
924 :     if (get_colorspace(inhdr) != XVID_CSP_NULL) {
925 :     memcpy(outhdr, inhdr, sizeof(BITMAPINFOHEADER));
926 :     /* XXX: should we set outhdr->biSize ?? */
927 :     return ICERR_OK;
928 :     }
929 :     /* --- yv12 --- */
930 :    
931 :     result = decompress_query(codec, lpbiInput, lpbiOutput);
932 :     if (result != ICERR_OK)
933 :     {
934 :     return result;
935 :     }
936 :    
937 :     outhdr->biSize = sizeof(BITMAPINFOHEADER);
938 :     outhdr->biWidth = inhdr->biWidth;
939 :     outhdr->biHeight = inhdr->biHeight;
940 :     outhdr->biPlanes = 1;
941 :     outhdr->biBitCount = 24;
942 :     outhdr->biCompression = BI_RGB; /* sonic foundry vegas video v3 only supports BI_RGB */
943 : suxen_drol 1495 outhdr->biSizeImage = outhdr->biHeight * CALC_BI_STRIDE(outhdr->biWidth, outhdr->biBitCount);
944 :    
945 : edgomez 1382 outhdr->biXPelsPerMeter = 0;
946 :     outhdr->biYPelsPerMeter = 0;
947 :     outhdr->biClrUsed = 0;
948 :     outhdr->biClrImportant = 0;
949 :    
950 :     return ICERR_OK;
951 :     }
952 :    
953 :     #define REG_GET_N(X, Y, Z) \
954 :     { \
955 :     DWORD size = sizeof(int); \
956 :     if (RegQueryValueEx(hKey, X, 0, 0, (LPBYTE)&Y, &size) != ERROR_SUCCESS) { \
957 :     Y=Z; \
958 :     } \
959 :     }while(0)
960 :    
961 :     LRESULT decompress_begin(CODEC * codec, BITMAPINFO * lpbiInput, BITMAPINFO * lpbiOutput)
962 :     {
963 :     xvid_gbl_init_t init;
964 :     xvid_dec_create_t create;
965 :     HKEY hKey;
966 :    
967 : edgomez 1398 if (init_dll(codec) != 0) return ICERR_ERROR;
968 : edgomez 1382
969 :     memset(&init, 0, sizeof(init));
970 :     init.version = XVID_VERSION;
971 :     init.cpu_flags = codec->config.cpu;
972 : edgomez 1398 codec->xvid_global_func(0, XVID_GBL_INIT, &init, NULL);
973 : edgomez 1382
974 :     memset(&create, 0, sizeof(create));
975 :     create.version = XVID_VERSION;
976 :     create.width = lpbiInput->bmiHeader.biWidth;
977 :     create.height = lpbiInput->bmiHeader.biHeight;
978 :    
979 : edgomez 1398 switch(codec->xvid_decore_func(0, XVID_DEC_CREATE, &create, NULL))
980 : edgomez 1382 {
981 :     case XVID_ERR_FAIL :
982 :     return ICERR_ERROR;
983 :    
984 :     case XVID_ERR_MEMORY :
985 :     return ICERR_MEMORY;
986 :    
987 :     case XVID_ERR_FORMAT :
988 :     return ICERR_BADFORMAT;
989 :    
990 :     case XVID_ERR_VERSION :
991 :     return ICERR_UNSUPPORTED;
992 :     }
993 :    
994 :     codec->dhandle = create.handle;
995 :    
996 :     RegOpenKeyEx(XVID_REG_KEY, XVID_REG_PARENT "\\" XVID_REG_CHILD, 0, KEY_READ, &hKey);
997 :    
998 : suxen_drol 1397 REG_GET_N("Brightness", pp_brightness, 0);
999 : edgomez 1382 REG_GET_N("Deblock_Y", pp_dy, 0)
1000 :     REG_GET_N("Deblock_UV", pp_duv, 0)
1001 : syskin 1437 REG_GET_N("Dering_Y", pp_dry, 0)
1002 :     REG_GET_N("Dering_UV", pp_druv, 0)
1003 : edgomez 1382 REG_GET_N("FilmEffect", pp_fe, 0)
1004 :    
1005 :     RegCloseKey(hKey);
1006 :    
1007 :     return ICERR_OK;
1008 :     }
1009 :    
1010 :    
1011 :     LRESULT decompress_end(CODEC * codec)
1012 :     {
1013 : edgomez 1398 if (codec->m_hdll != NULL) {
1014 : edgomez 1382 if (codec->dhandle != NULL) {
1015 : edgomez 1398 codec->xvid_decore_func(codec->dhandle, XVID_DEC_DESTROY, NULL, NULL);
1016 : edgomez 1382 codec->dhandle = NULL;
1017 :     }
1018 :     }
1019 :    
1020 :     return ICERR_OK;
1021 :     }
1022 :    
1023 :    
1024 :     LRESULT decompress(CODEC * codec, ICDECOMPRESS * icd)
1025 :     {
1026 :     xvid_dec_frame_t frame;
1027 :    
1028 :     /* --- yv12 --- */
1029 :     if (icd->lpbiInput->biCompression != FOURCC_XVID &&
1030 :     icd->lpbiInput->biCompression != FOURCC_DIVX &&
1031 :     icd->lpbiInput->biCompression != FOURCC_DX50)
1032 :     {
1033 :     xvid_gbl_convert_t convert;
1034 :    
1035 :     DPRINTF("input=%c%c%c%c output=%c%c%c%c",
1036 :     icd->lpbiInput->biCompression&0xff,
1037 :     (icd->lpbiInput->biCompression>>8)&0xff,
1038 :     (icd->lpbiInput->biCompression>>16)&0xff,
1039 :     (icd->lpbiInput->biCompression>>24)&0xff,
1040 :     icd->lpbiOutput->biCompression&0xff,
1041 :     (icd->lpbiOutput->biCompression>>8)&0xff,
1042 :     (icd->lpbiOutput->biCompression>>16)&0xff,
1043 :     (icd->lpbiOutput->biCompression>>24)&0xff);
1044 :    
1045 :     memset(&convert, 0, sizeof(convert));
1046 :     convert.version = XVID_VERSION;
1047 :    
1048 :     convert.input.csp = get_colorspace(icd->lpbiInput);
1049 :     convert.input.plane[0] = icd->lpInput;
1050 : suxen_drol 1495 convert.input.stride[0] = CALC_BI_STRIDE(icd->lpbiInput->biWidth, icd->lpbiInput->biBitCount);
1051 : edgomez 1382 if (convert.input.csp == XVID_CSP_I420 || convert.input.csp == XVID_CSP_YV12)
1052 :     convert.input.stride[0] = (convert.input.stride[0]*2)/3;
1053 :    
1054 :     convert.output.csp = get_colorspace(icd->lpbiOutput);
1055 :     convert.output.plane[0] = icd->lpOutput;
1056 : suxen_drol 1495 convert.output.stride[0] = CALC_BI_STRIDE(icd->lpbiOutput->biWidth, icd->lpbiOutput->biBitCount);
1057 : edgomez 1382 if (convert.output.csp == XVID_CSP_I420 || convert.output.csp == XVID_CSP_YV12)
1058 :     convert.output.stride[0] = (convert.output.stride[0]*2)/3;
1059 :    
1060 :     convert.width = icd->lpbiInput->biWidth;
1061 :     convert.height = icd->lpbiInput->biHeight;
1062 :     convert.interlacing = 0;
1063 :     if (convert.input.csp == XVID_CSP_NULL ||
1064 :     convert.output.csp == XVID_CSP_NULL ||
1065 : edgomez 1398 codec->xvid_global_func(0, XVID_GBL_CONVERT, &convert, NULL) < 0)
1066 : edgomez 1382 {
1067 :     return ICERR_BADFORMAT;
1068 :     }
1069 :     return ICERR_OK;
1070 :     }
1071 :     /* --- yv12 --- */
1072 :    
1073 :     memset(&frame, 0, sizeof(frame));
1074 :     frame.version = XVID_VERSION;
1075 :     frame.general = XVID_LOWDELAY; /* force low_delay_default mode */
1076 :     frame.bitstream = icd->lpInput;
1077 :     frame.length = icd->lpbiInput->biSizeImage;
1078 :    
1079 :     if (~((icd->dwFlags & ICDECOMPRESS_HURRYUP) | (icd->dwFlags & ICDECOMPRESS_UPDATE) | (icd->dwFlags & ICDECOMPRESS_PREROLL)))
1080 :     {
1081 :     if ((frame.output.csp = get_colorspace(icd->lpbiOutput)) == XVID_CSP_NULL)
1082 :     {
1083 :     return ICERR_BADFORMAT;
1084 :     }
1085 :     frame.output.plane[0] = icd->lpOutput;
1086 : suxen_drol 1495 frame.output.stride[0] = CALC_BI_STRIDE(icd->lpbiOutput->biWidth, icd->lpbiOutput->biBitCount);
1087 : edgomez 1382 if (frame.output.csp == XVID_CSP_I420 || frame.output.csp == XVID_CSP_YV12)
1088 : suxen_drol 1558 frame.output.stride[0] = CALC_BI_STRIDE(icd->lpbiOutput->biWidth, 8);
1089 : edgomez 1382 }
1090 :     else
1091 :     {
1092 :     frame.output.csp = XVID_CSP_NULL;
1093 :     }
1094 :    
1095 :     if (pp_dy)frame.general |= XVID_DEBLOCKY;
1096 :     if (pp_duv) frame.general |= XVID_DEBLOCKUV;
1097 : syskin 1437 if (pp_dry) frame.general |= XVID_DERINGY;
1098 :     if (pp_druv) frame.general |= XVID_DERINGUV;
1099 : edgomez 1382 if (pp_fe) frame.general |= XVID_FILMEFFECT;
1100 :    
1101 : suxen_drol 1397 frame.brightness = pp_brightness;
1102 :    
1103 : edgomez 1398 switch (codec->xvid_decore_func(codec->dhandle, XVID_DEC_DECODE, &frame, NULL))
1104 : edgomez 1382 {
1105 :     case XVID_ERR_FAIL :
1106 :     return ICERR_ERROR;
1107 :    
1108 :     case XVID_ERR_MEMORY :
1109 :     return ICERR_MEMORY;
1110 :    
1111 :     case XVID_ERR_FORMAT :
1112 :     return ICERR_BADFORMAT;
1113 :    
1114 :     case XVID_ERR_VERSION :
1115 :     return ICERR_UNSUPPORTED;
1116 :     }
1117 :    
1118 :     return ICERR_OK;
1119 :     }
1120 :    

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