[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 2161 - (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_width*mb_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_size*3)/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 : Isibaar 2140 if (codec->config.debug > 0) {
569 : Isibaar 2138 plugins[create.num_plugins].func = vfw_debug;
570 :     plugins[create.num_plugins].param = NULL;
571 :     create.num_plugins++;
572 :     }
573 :    
574 : edgomez 1382 create.profile = profiles[codec->config.profile].id;
575 :    
576 :     create.width = lpbiInput->bmiHeader.biWidth;
577 :     create.height = lpbiInput->bmiHeader.biHeight;
578 :     create.fincr = codec->fincr;
579 :     create.fbase = codec->fbase;
580 :    
581 : suxen_drol 1649 create.max_key_interval = quality_preset->max_key_interval;
582 : edgomez 1382
583 : suxen_drol 1649 create.min_quant[0] = quality_preset->min_iquant;
584 :     create.max_quant[0] = quality_preset->max_iquant;
585 :     create.min_quant[1] = quality_preset->min_pquant;
586 :     create.max_quant[1] = quality_preset->max_pquant;
587 :     create.min_quant[2] = quality_preset->min_bquant;
588 :     create.max_quant[2] = quality_preset->max_bquant;
589 : edgomez 1382
590 :     if ((profiles[codec->config.profile].flags & PROFILE_BVOP) && codec->config.use_bvop) {
591 :    
592 : suxen_drol 1607 /* dxn: prevent bframes usage if interlacing is selected */
593 : Isibaar 1650 if (!((profiles[codec->config.profile].flags & PROFILE_EXTRA) && codec->config.interlacing)) {
594 : suxen_drol 1607 create.max_bframes = codec->config.max_bframes;
595 :     create.bquant_ratio = codec->config.bquant_ratio;
596 :     create.bquant_offset = codec->config.bquant_offset;
597 : edgomez 1382
598 : suxen_drol 1607 if (codec->config.packed)
599 :     create.global |= XVID_GLOBAL_PACKED;
600 : edgomez 1382
601 : suxen_drol 1607 create.global |= XVID_GLOBAL_CLOSED_GOP;
602 :    
603 : Isibaar 1718 /* restrict max bframes */
604 :     if ((create.max_bframes > profiles[codec->config.profile].xvid_max_bframes) && (profiles[codec->config.profile].xvid_max_bframes >= 0))
605 :     create.max_bframes = profiles[codec->config.profile].xvid_max_bframes;
606 : suxen_drol 1607
607 : Isibaar 1718 /* DXN: enable packed bframes */
608 :     if ((profiles[codec->config.profile].flags & PROFILE_PACKED)) {
609 : suxen_drol 1607 create.global |= XVID_GLOBAL_PACKED;
610 :     }
611 :     }
612 : edgomez 1382 }
613 :    
614 : Isibaar 1816 /* dxn: always write divx5 userdata */
615 :     if ((profiles[codec->config.profile].flags & PROFILE_EXTRA))
616 :     create.global |= XVID_GLOBAL_DIVX5_USERDATA;
617 : suxen_drol 1607
618 : Isibaar 1952 if ((profiles[codec->config.profile].flags & PROFILE_EXTRA) ||
619 :     (profiles[codec->config.profile].flags & PROFILE_XVID)) {
620 :     create.frame_drop_ratio = 0;
621 :     } else {
622 :     create.frame_drop_ratio = quality_preset->frame_drop_ratio;
623 :     }
624 : edgomez 1382
625 : edgomez 1398 switch(codec->xvid_encore_func(0, XVID_ENC_CREATE, &create, NULL))
626 : edgomez 1382 {
627 :     case XVID_ERR_FAIL :
628 :     return ICERR_ERROR;
629 :    
630 :     case XVID_ERR_MEMORY :
631 :     return ICERR_MEMORY;
632 :    
633 :     case XVID_ERR_FORMAT :
634 :     return ICERR_BADFORMAT;
635 :    
636 :     case XVID_ERR_VERSION :
637 :     return ICERR_UNSUPPORTED;
638 :     }
639 :    
640 : syskin 1477 free(create.zones);
641 : edgomez 1382 codec->ehandle = create.handle;
642 :     codec->framenum = 0;
643 :     codec->keyspacing = 0;
644 :    
645 :     if (codec->config.display_status) {
646 :     status_destroy_always(&codec->status);
647 :     status_create(&codec->status, codec->fincr, codec->fbase);
648 :     }
649 :    
650 :     return ICERR_OK;
651 :     }
652 :    
653 :    
654 :     LRESULT compress_end(CODEC * codec)
655 :     {
656 : suxen_drol 1685 if (codec==NULL)
657 :     return ICERR_OK;
658 :    
659 : edgomez 1398 if (codec->m_hdll != NULL) {
660 : edgomez 1382 if (codec->ehandle != NULL) {
661 : edgomez 1398 codec->xvid_encore_func(codec->ehandle, XVID_ENC_DESTROY, NULL, NULL);
662 : edgomez 1382 codec->ehandle = NULL;
663 :     }
664 :     }
665 :    
666 :     if (codec->config.display_status)
667 :     status_destroy(&codec->status);
668 :    
669 :     return ICERR_OK;
670 :     }
671 :    
672 :    
673 :     static void apply_zone_modifiers(xvid_enc_frame_t * frame, CONFIG * config, int framenum)
674 :     {
675 :     int i;
676 :    
677 :     for (i=0; i<config->num_zones && config->zones[i].frame <= framenum; i++) ;
678 :    
679 :     if (--i < 0) return; /* there are no zones, or we're before the first zone */
680 :    
681 :     if (framenum == config->zones[i].frame)
682 :     frame->type = config->zones[i].type;
683 :    
684 :     if (config->zones[i].greyscale) {
685 :     frame->vop_flags |= XVID_VOP_GREYSCALE;
686 :     }
687 :    
688 :     if (config->zones[i].chroma_opt) {
689 :     frame->vop_flags |= XVID_VOP_CHROMAOPT;
690 :     }
691 :    
692 : syskin 1588 if (config->zones[i].cartoon_mode) {
693 :     frame->vop_flags |= XVID_VOP_CARTOON;
694 :     frame->motion |= XVID_ME_DETECT_STATIC_MOTION;
695 :     }
696 :    
697 : edgomez 1382 if ((profiles[config->profile].flags & PROFILE_BVOP) && config->use_bvop) {
698 :     frame->bframe_threshold = config->zones[i].bvop_threshold;
699 :     }
700 :     }
701 :    
702 :    
703 : suxen_drol 1495 #define CALC_BI_STRIDE(width,bitcount) ((((width * bitcount) + 31) & ~31) >> 3)
704 :    
705 : edgomez 1382 LRESULT compress(CODEC * codec, ICCOMPRESS * icc)
706 :     {
707 :     BITMAPINFOHEADER * inhdr = icc->lpbiInput;
708 :     BITMAPINFOHEADER * outhdr = icc->lpbiOutput;
709 :     xvid_enc_frame_t frame;
710 :     xvid_enc_stats_t stats;
711 :     int length;
712 : suxen_drol 1649 const quality_t* quality_preset = (codec->config.quality==quality_table_num) ?
713 :     &codec->config.quality_user : &quality_table[codec->config.quality];
714 : edgomez 1382
715 :     memset(&frame, 0, sizeof(frame));
716 :     frame.version = XVID_VERSION;
717 :    
718 :     frame.type = XVID_TYPE_AUTO;
719 :    
720 :     /* vol stuff */
721 :    
722 :     if ((profiles[codec->config.profile].flags & PROFILE_MPEGQUANT) &&
723 :     codec->config.quant_type != QUANT_MODE_H263)
724 :     {
725 :     frame.vol_flags |= XVID_VOL_MPEGQUANT;
726 :    
727 :     if (codec->config.quant_type == QUANT_MODE_CUSTOM) {
728 :     frame.quant_intra_matrix = codec->config.qmatrix_intra;
729 :     frame.quant_inter_matrix = codec->config.qmatrix_inter;
730 :     }else{
731 :     frame.quant_intra_matrix = NULL;
732 :     frame.quant_inter_matrix = NULL;
733 :     }
734 :     }
735 :    
736 :     if ((profiles[codec->config.profile].flags & PROFILE_QPEL) && codec->config.qpel) {
737 :     frame.vol_flags |= XVID_VOL_QUARTERPEL;
738 :     frame.motion |= XVID_ME_QUARTERPELREFINE16 | XVID_ME_QUARTERPELREFINE8;
739 :     }
740 :    
741 :     if ((profiles[codec->config.profile].flags & PROFILE_GMC) && codec->config.gmc) {
742 :     frame.vol_flags |= XVID_VOL_GMC;
743 :     frame.motion |= XVID_ME_GME_REFINE;
744 :     }
745 :    
746 :     if ((profiles[codec->config.profile].flags & PROFILE_INTERLACE) && codec->config.interlacing)
747 :     frame.vol_flags |= XVID_VOL_INTERLACING;
748 :    
749 : suxen_drol 1607 /* dxn: force 1:1 picture aspect ration */
750 : Isibaar 1650 if ((profiles[codec->config.profile].flags & PROFILE_EXTRA)) {
751 : suxen_drol 1607 frame.par = XVID_PAR_11_VGA;
752 :     } else if (codec->config.ar_mode == 0) { /* PAR */
753 : edgomez 1382 if (codec->config.display_aspect_ratio != 5) {
754 :     frame.par = codec->config.display_aspect_ratio + 1;
755 :     } else {
756 :     frame.par = XVID_PAR_EXT;
757 :     frame.par_width = codec->config.par_x;
758 :     frame.par_height= codec->config.par_y;
759 :     }
760 :     } else { /* AR */
761 :     /* custom pixel aspect ratio -> calculated from DAR */
762 :     frame.par = XVID_PAR_EXT;
763 :     frame.par_width = (100 * inhdr->biHeight) / codec->config.ar_y;
764 :     frame.par_height= (100 * inhdr->biWidth) / codec->config.ar_x;
765 :     }
766 :    
767 :     /* vop stuff */
768 :    
769 :     frame.vop_flags |= XVID_VOP_HALFPEL;
770 :     frame.vop_flags |= XVID_VOP_HQACPRED;
771 :    
772 : syskin 1487 if (codec->config.interlacing && codec->config.tff)
773 :     frame.vop_flags |= XVID_VOP_TOPFIELDFIRST;
774 :    
775 :    
776 : edgomez 1382 if (codec->config.vop_debug)
777 :     frame.vop_flags |= XVID_VOP_DEBUG;
778 :    
779 : suxen_drol 1649 if (quality_preset->trellis_quant) {
780 : edgomez 1382 frame.vop_flags |= XVID_VOP_TRELLISQUANT;
781 :     }
782 :    
783 : suxen_drol 1607 if ((profiles[codec->config.profile].flags & PROFILE_4MV)) {
784 : suxen_drol 1649 if (quality_preset->motion_search > 4)
785 : suxen_drol 1607 frame.vop_flags |= XVID_VOP_INTER4V;
786 :     }
787 : edgomez 1382
788 : suxen_drol 1649 if (quality_preset->chromame)
789 : edgomez 1382 frame.motion |= XVID_ME_CHROMA_PVOP + XVID_ME_CHROMA_BVOP;
790 :    
791 : suxen_drol 1649 if (quality_preset->turbo)
792 : edgomez 1382 frame.motion |= XVID_ME_FASTREFINE16 | XVID_ME_FASTREFINE8 |
793 :     XVID_ME_SKIP_DELTASEARCH | XVID_ME_FAST_MODEINTERPOLATE |
794 :     XVID_ME_BFRAME_EARLYSTOP;
795 :    
796 : suxen_drol 1649 frame.motion |= pmvfast_presets[quality_preset->motion_search];
797 : edgomez 1382
798 : suxen_drol 1649 if (quality_preset->vhq_bframe) frame.vop_flags |= XVID_VOP_RD_BVOP;
799 : syskin 1510
800 :    
801 : suxen_drol 1649 switch (quality_preset->vhq_mode)
802 : edgomez 1382 {
803 :     case VHQ_MODE_DECISION :
804 :     frame.vop_flags |= XVID_VOP_MODEDECISION_RD;
805 :     break;
806 :    
807 :     case VHQ_LIMITED_SEARCH :
808 :     frame.vop_flags |= XVID_VOP_MODEDECISION_RD;
809 :     frame.motion |= XVID_ME_HALFPELREFINE16_RD;
810 :     frame.motion |= XVID_ME_QUARTERPELREFINE16_RD;
811 :     break;
812 :    
813 :     case VHQ_MEDIUM_SEARCH :
814 :     frame.vop_flags |= XVID_VOP_MODEDECISION_RD;
815 :     frame.motion |= XVID_ME_HALFPELREFINE16_RD;
816 :     frame.motion |= XVID_ME_HALFPELREFINE8_RD;
817 :     frame.motion |= XVID_ME_QUARTERPELREFINE16_RD;
818 :     frame.motion |= XVID_ME_QUARTERPELREFINE8_RD;
819 :     frame.motion |= XVID_ME_CHECKPREDICTION_RD;
820 :     break;
821 :    
822 :     case VHQ_WIDE_SEARCH :
823 :     frame.vop_flags |= XVID_VOP_MODEDECISION_RD;
824 :     frame.motion |= XVID_ME_HALFPELREFINE16_RD;
825 :     frame.motion |= XVID_ME_HALFPELREFINE8_RD;
826 :     frame.motion |= XVID_ME_QUARTERPELREFINE16_RD;
827 :     frame.motion |= XVID_ME_QUARTERPELREFINE8_RD;
828 :     frame.motion |= XVID_ME_CHECKPREDICTION_RD;
829 :     frame.motion |= XVID_ME_EXTSEARCH_RD;
830 :     break;
831 :    
832 :     default :
833 :     break;
834 :     }
835 :    
836 : Isibaar 1914 if (quality_preset->vhq_metric == 1)
837 :     frame.vop_flags |= XVID_VOP_RD_PSNRHVSM;
838 :    
839 : edgomez 1382 frame.input.plane[0] = icc->lpInput;
840 : suxen_drol 1495 frame.input.stride[0] = CALC_BI_STRIDE(icc->lpbiInput->biWidth, icc->lpbiInput->biBitCount);
841 : edgomez 1382
842 :     if ((frame.input.csp = get_colorspace(inhdr)) == XVID_CSP_NULL)
843 :     return ICERR_BADFORMAT;
844 :    
845 :     if (frame.input.csp == XVID_CSP_I420 || frame.input.csp == XVID_CSP_YV12) {
846 :     frame.input.stride[0] = (4 * icc->lpbiInput->biWidth + 3) / 4;
847 :     frame.input.stride[1] = frame.input.stride[2] = frame.input.stride[0] / 2 ;
848 :     }
849 :    
850 :     frame.bitstream = icc->lpOutput;
851 :     frame.length = icc->lpbiOutput->biSizeImage;
852 :    
853 :     frame.quant = 0;
854 :    
855 :     if (codec->config.mode == RC_MODE_NULL) {
856 :     outhdr->biSizeImage = 0;
857 :     *icc->lpdwFlags = AVIIF_KEYFRAME;
858 :     return ICERR_OK;
859 :     }
860 :    
861 :     // force keyframe spacing in 2-pass 1st pass
862 : suxen_drol 1649 if (quality_preset->motion_search == 0)
863 : edgomez 1382 frame.type = XVID_TYPE_IVOP;
864 :    
865 :     /* frame-based stuff */
866 :     apply_zone_modifiers(&frame, &codec->config, codec->framenum);
867 :    
868 :     /* call encore */
869 :    
870 :     memset(&stats, 0, sizeof(stats));
871 :     stats.version = XVID_VERSION;
872 :    
873 : edgomez 1398 length = codec->xvid_encore_func(codec->ehandle, XVID_ENC_ENCODE, &frame, &stats);
874 : edgomez 1382 switch (length)
875 :     {
876 :     case XVID_ERR_FAIL :
877 :     return ICERR_ERROR;
878 :    
879 :     case XVID_ERR_MEMORY :
880 :     return ICERR_MEMORY;
881 :    
882 :     case XVID_ERR_FORMAT :
883 :     return ICERR_BADFORMAT;
884 :    
885 :     case XVID_ERR_VERSION :
886 :     return ICERR_UNSUPPORTED;
887 :     }
888 :    
889 :     if (codec->config.display_status && stats.type>0) {
890 :     status_update(&codec->status, stats.type, stats.length, stats.quant);
891 :     }
892 :    
893 :     DPRINTF("{type=%i len=%i} length=%i", stats.type, stats.length, length);
894 :    
895 :     if (length == 0) /* no encoder output */
896 :     {
897 :     *icc->lpdwFlags = 0;
898 :     ((char*)icc->lpOutput)[0] = 0x7f; /* virtual dub skip frame */
899 :     outhdr->biSizeImage = 1;
900 :    
901 :     }else{
902 :     if (frame.out_flags & XVID_KEYFRAME)
903 :     {
904 :     codec->keyspacing = 0;
905 :     *icc->lpdwFlags = AVIIF_KEYFRAME;
906 :     }
907 :     else
908 :     {
909 :     *icc->lpdwFlags = 0;
910 :     }
911 :    
912 :     outhdr->biSizeImage = length;
913 :    
914 :     if (codec->config.mode == RC_MODE_2PASS1 && codec->config.discard1pass)
915 :     {
916 :     outhdr->biSizeImage = 0;
917 :     }
918 :     }
919 :    
920 :     codec->framenum++;
921 :     codec->keyspacing++;
922 :    
923 :     return ICERR_OK;
924 :     }
925 :    
926 :    
927 :     /* decompressor */
928 :    
929 :    
930 :     LRESULT decompress_query(CODEC * codec, BITMAPINFO *lpbiInput, BITMAPINFO *lpbiOutput)
931 :     {
932 :     BITMAPINFOHEADER * inhdr = &lpbiInput->bmiHeader;
933 :     BITMAPINFOHEADER * outhdr = &lpbiOutput->bmiHeader;
934 : Isibaar 1945 int in_csp = XVID_CSP_NULL, out_csp = XVID_CSP_NULL;
935 : edgomez 1382
936 :     if (lpbiInput == NULL)
937 :     {
938 :     return ICERR_ERROR;
939 :     }
940 :    
941 : Isibaar 1952 if (inhdr->biCompression != FOURCC_XVID && inhdr->biCompression != FOURCC_DIVX && inhdr->biCompression != FOURCC_DX50 && inhdr->biCompression != FOURCC_MP4V &&
942 :     inhdr->biCompression != FOURCC_xvid && inhdr->biCompression != FOURCC_divx && inhdr->biCompression != FOURCC_dx50 && inhdr->biCompression != FOURCC_mp4v &&
943 : Isibaar 2161 inhdr->biCompression != FOURCC_YV12 && (in_csp = get_colorspace(inhdr)) != XVID_CSP_YV12)
944 : edgomez 1382 {
945 :     return ICERR_BADFORMAT;
946 :     }
947 :    
948 :     if (lpbiOutput == NULL)
949 :     {
950 :     return ICERR_OK;
951 :     }
952 :    
953 : Isibaar 1945 out_csp = get_colorspace(outhdr);
954 :    
955 : edgomez 1382 if (inhdr->biWidth != outhdr->biWidth ||
956 :     inhdr->biHeight != outhdr->biHeight ||
957 : Isibaar 1945 out_csp == XVID_CSP_NULL ||
958 :     (in_csp == XVID_CSP_YV12 && in_csp != out_csp))
959 : edgomez 1382 {
960 :     return ICERR_BADFORMAT;
961 :     }
962 :    
963 :     return ICERR_OK;
964 :     }
965 :    
966 :    
967 :     LRESULT decompress_get_format(CODEC * codec, BITMAPINFO * lpbiInput, BITMAPINFO * lpbiOutput)
968 :     {
969 :     BITMAPINFOHEADER * inhdr = &lpbiInput->bmiHeader;
970 :     BITMAPINFOHEADER * outhdr = &lpbiOutput->bmiHeader;
971 :     LRESULT result;
972 :    
973 :     if (lpbiOutput == NULL)
974 :     {
975 :     return sizeof(BITMAPINFOHEADER);
976 :     }
977 :    
978 :     /* --- yv12 --- */
979 :    
980 :     if (get_colorspace(inhdr) != XVID_CSP_NULL) {
981 :     memcpy(outhdr, inhdr, sizeof(BITMAPINFOHEADER));
982 :     /* XXX: should we set outhdr->biSize ?? */
983 :     return ICERR_OK;
984 :     }
985 :     /* --- yv12 --- */
986 :    
987 :     result = decompress_query(codec, lpbiInput, lpbiOutput);
988 :     if (result != ICERR_OK)
989 :     {
990 :     return result;
991 :     }
992 :    
993 :     outhdr->biSize = sizeof(BITMAPINFOHEADER);
994 :     outhdr->biWidth = inhdr->biWidth;
995 :     outhdr->biHeight = inhdr->biHeight;
996 :     outhdr->biPlanes = 1;
997 :     outhdr->biBitCount = 24;
998 :     outhdr->biCompression = BI_RGB; /* sonic foundry vegas video v3 only supports BI_RGB */
999 : suxen_drol 1495 outhdr->biSizeImage = outhdr->biHeight * CALC_BI_STRIDE(outhdr->biWidth, outhdr->biBitCount);
1000 :    
1001 : edgomez 1382 outhdr->biXPelsPerMeter = 0;
1002 :     outhdr->biYPelsPerMeter = 0;
1003 :     outhdr->biClrUsed = 0;
1004 :     outhdr->biClrImportant = 0;
1005 :    
1006 :     return ICERR_OK;
1007 :     }
1008 :    
1009 :     #define REG_GET_N(X, Y, Z) \
1010 :     { \
1011 :     DWORD size = sizeof(int); \
1012 :     if (RegQueryValueEx(hKey, X, 0, 0, (LPBYTE)&Y, &size) != ERROR_SUCCESS) { \
1013 :     Y=Z; \
1014 :     } \
1015 :     }while(0)
1016 :    
1017 :     LRESULT decompress_begin(CODEC * codec, BITMAPINFO * lpbiInput, BITMAPINFO * lpbiOutput)
1018 :     {
1019 : Isibaar 1890 BITMAPINFOHEADER * inhdr = &lpbiInput->bmiHeader;
1020 : edgomez 1382 xvid_gbl_init_t init;
1021 : Isibaar 1914 xvid_gbl_info_t info;
1022 : edgomez 1382 xvid_dec_create_t create;
1023 :     HKEY hKey;
1024 :    
1025 : edgomez 1398 if (init_dll(codec) != 0) return ICERR_ERROR;
1026 : edgomez 1382
1027 :     memset(&init, 0, sizeof(init));
1028 :     init.version = XVID_VERSION;
1029 :     init.cpu_flags = codec->config.cpu;
1030 : Isibaar 1890 init.debug = codec->config.debug;
1031 : edgomez 1398 codec->xvid_global_func(0, XVID_GBL_INIT, &init, NULL);
1032 : edgomez 1382
1033 : Isibaar 1914 memset(&info, 0, sizeof(info));
1034 :     info.version = XVID_VERSION;
1035 :     codec->xvid_global_func(0, XVID_GBL_INFO, &info, NULL);
1036 :    
1037 : edgomez 1382 memset(&create, 0, sizeof(create));
1038 :     create.version = XVID_VERSION;
1039 :     create.width = lpbiInput->bmiHeader.biWidth;
1040 :     create.height = lpbiInput->bmiHeader.biHeight;
1041 : Isibaar 1890 create.fourcc = inhdr->biCompression;
1042 : edgomez 1382
1043 : Isibaar 1914 /* Decoder threads */
1044 :     if (codec->config.cpu & XVID_CPU_FORCE)
1045 :     create.num_threads = codec->config.num_threads;
1046 :     else
1047 :     create.num_threads = info.num_threads; /* Autodetect */
1048 :    
1049 : edgomez 1398 switch(codec->xvid_decore_func(0, XVID_DEC_CREATE, &create, NULL))
1050 : edgomez 1382 {
1051 :     case XVID_ERR_FAIL :
1052 :     return ICERR_ERROR;
1053 :    
1054 :     case XVID_ERR_MEMORY :
1055 :     return ICERR_MEMORY;
1056 :    
1057 :     case XVID_ERR_FORMAT :
1058 :     return ICERR_BADFORMAT;
1059 :    
1060 :     case XVID_ERR_VERSION :
1061 :     return ICERR_UNSUPPORTED;
1062 :     }
1063 :    
1064 :     codec->dhandle = create.handle;
1065 :    
1066 :     RegOpenKeyEx(XVID_REG_KEY, XVID_REG_PARENT "\\" XVID_REG_CHILD, 0, KEY_READ, &hKey);
1067 :    
1068 : suxen_drol 1397 REG_GET_N("Brightness", pp_brightness, 0);
1069 : Isibaar 1887 REG_GET_N("Deblock_Y", pp_dy, 0);
1070 :     REG_GET_N("Deblock_UV", pp_duv, 0);
1071 :     REG_GET_N("Dering_Y", pp_dry, 0);
1072 :     REG_GET_N("Dering_UV", pp_druv, 0);
1073 :     REG_GET_N("FilmEffect", pp_fe, 0);
1074 : edgomez 1382
1075 :     RegCloseKey(hKey);
1076 :    
1077 :     return ICERR_OK;
1078 :     }
1079 :    
1080 :    
1081 :     LRESULT decompress_end(CODEC * codec)
1082 :     {
1083 : edgomez 1398 if (codec->m_hdll != NULL) {
1084 : edgomez 1382 if (codec->dhandle != NULL) {
1085 : edgomez 1398 codec->xvid_decore_func(codec->dhandle, XVID_DEC_DESTROY, NULL, NULL);
1086 : edgomez 1382 codec->dhandle = NULL;
1087 :     }
1088 :     }
1089 :    
1090 :     return ICERR_OK;
1091 :     }
1092 :    
1093 :    
1094 :     LRESULT decompress(CODEC * codec, ICDECOMPRESS * icd)
1095 :     {
1096 :     xvid_dec_frame_t frame;
1097 :    
1098 :     /* --- yv12 --- */
1099 :     if (icd->lpbiInput->biCompression != FOURCC_XVID &&
1100 :     icd->lpbiInput->biCompression != FOURCC_DIVX &&
1101 : Isibaar 1952 icd->lpbiInput->biCompression != FOURCC_DX50 &&
1102 :     icd->lpbiInput->biCompression != FOURCC_MP4V &&
1103 :     icd->lpbiInput->biCompression != FOURCC_xvid &&
1104 :     icd->lpbiInput->biCompression != FOURCC_divx &&
1105 :     icd->lpbiInput->biCompression != FOURCC_dx50 &&
1106 :     icd->lpbiInput->biCompression != FOURCC_mp4v)
1107 : edgomez 1382 {
1108 :     xvid_gbl_convert_t convert;
1109 :    
1110 :     DPRINTF("input=%c%c%c%c output=%c%c%c%c",
1111 :     icd->lpbiInput->biCompression&0xff,
1112 :     (icd->lpbiInput->biCompression>>8)&0xff,
1113 :     (icd->lpbiInput->biCompression>>16)&0xff,
1114 :     (icd->lpbiInput->biCompression>>24)&0xff,
1115 :     icd->lpbiOutput->biCompression&0xff,
1116 :     (icd->lpbiOutput->biCompression>>8)&0xff,
1117 :     (icd->lpbiOutput->biCompression>>16)&0xff,
1118 :     (icd->lpbiOutput->biCompression>>24)&0xff);
1119 :    
1120 :     memset(&convert, 0, sizeof(convert));
1121 :     convert.version = XVID_VERSION;
1122 :    
1123 :     convert.input.csp = get_colorspace(icd->lpbiInput);
1124 :     convert.input.plane[0] = icd->lpInput;
1125 : suxen_drol 1495 convert.input.stride[0] = CALC_BI_STRIDE(icd->lpbiInput->biWidth, icd->lpbiInput->biBitCount);
1126 : edgomez 1382 if (convert.input.csp == XVID_CSP_I420 || convert.input.csp == XVID_CSP_YV12)
1127 :     convert.input.stride[0] = (convert.input.stride[0]*2)/3;
1128 :    
1129 :     convert.output.csp = get_colorspace(icd->lpbiOutput);
1130 :     convert.output.plane[0] = icd->lpOutput;
1131 : suxen_drol 1495 convert.output.stride[0] = CALC_BI_STRIDE(icd->lpbiOutput->biWidth, icd->lpbiOutput->biBitCount);
1132 : edgomez 1382 if (convert.output.csp == XVID_CSP_I420 || convert.output.csp == XVID_CSP_YV12)
1133 :     convert.output.stride[0] = (convert.output.stride[0]*2)/3;
1134 :    
1135 :     convert.width = icd->lpbiInput->biWidth;
1136 :     convert.height = icd->lpbiInput->biHeight;
1137 :     convert.interlacing = 0;
1138 :     if (convert.input.csp == XVID_CSP_NULL ||
1139 :     convert.output.csp == XVID_CSP_NULL ||
1140 : edgomez 1398 codec->xvid_global_func(0, XVID_GBL_CONVERT, &convert, NULL) < 0)
1141 : edgomez 1382 {
1142 :     return ICERR_BADFORMAT;
1143 :     }
1144 :     return ICERR_OK;
1145 :     }
1146 :     /* --- yv12 --- */
1147 :    
1148 :     memset(&frame, 0, sizeof(frame));
1149 :     frame.version = XVID_VERSION;
1150 :     frame.general = XVID_LOWDELAY; /* force low_delay_default mode */
1151 :     frame.bitstream = icd->lpInput;
1152 :     frame.length = icd->lpbiInput->biSizeImage;
1153 :    
1154 :     if (~((icd->dwFlags & ICDECOMPRESS_HURRYUP) | (icd->dwFlags & ICDECOMPRESS_UPDATE) | (icd->dwFlags & ICDECOMPRESS_PREROLL)))
1155 :     {
1156 :     if ((frame.output.csp = get_colorspace(icd->lpbiOutput)) == XVID_CSP_NULL)
1157 :     {
1158 :     return ICERR_BADFORMAT;
1159 :     }
1160 :     frame.output.plane[0] = icd->lpOutput;
1161 : suxen_drol 1495 frame.output.stride[0] = CALC_BI_STRIDE(icd->lpbiOutput->biWidth, icd->lpbiOutput->biBitCount);
1162 : edgomez 1382 if (frame.output.csp == XVID_CSP_I420 || frame.output.csp == XVID_CSP_YV12)
1163 : suxen_drol 1558 frame.output.stride[0] = CALC_BI_STRIDE(icd->lpbiOutput->biWidth, 8);
1164 : edgomez 1382 }
1165 :     else
1166 :     {
1167 :     frame.output.csp = XVID_CSP_NULL;
1168 :     }
1169 :    
1170 :     if (pp_dy)frame.general |= XVID_DEBLOCKY;
1171 :     if (pp_duv) frame.general |= XVID_DEBLOCKUV;
1172 : syskin 1437 if (pp_dry) frame.general |= XVID_DERINGY;
1173 :     if (pp_druv) frame.general |= XVID_DERINGUV;
1174 : edgomez 1382 if (pp_fe) frame.general |= XVID_FILMEFFECT;
1175 :    
1176 : suxen_drol 1397 frame.brightness = pp_brightness;
1177 :    
1178 : edgomez 1398 switch (codec->xvid_decore_func(codec->dhandle, XVID_DEC_DECODE, &frame, NULL))
1179 : edgomez 1382 {
1180 :     case XVID_ERR_FAIL :
1181 :     return ICERR_ERROR;
1182 :    
1183 :     case XVID_ERR_MEMORY :
1184 :     return ICERR_MEMORY;
1185 :    
1186 :     case XVID_ERR_FORMAT :
1187 :     return ICERR_BADFORMAT;
1188 :    
1189 :     case XVID_ERR_VERSION :
1190 :     return ICERR_UNSUPPORTED;
1191 :     }
1192 :    
1193 :     return ICERR_OK;
1194 :     }
1195 :    

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